[嵌入式] 德州仪器(Ti)平台嵌入式开发-01

开发: C++知识库 Java知识库 JavaScript Python PHP知识库人工智能区块链大数据移动开发嵌入式开发工具数据结构与算法开发测试游戏开发网络协议系统运维
教程: HTML教程 CSS教程 JavaScript教程 Go语言教程 JQuery教程 VUE教程 VUE3教程 Bootstrap教程 SQL数据库教程 C语言教程 C++教程 Java教程 Python教程 Python3教程 C#教程
数码: 电脑笔记本显卡显示器固态硬盘硬盘耳机手机 iphone vivo oppo 小米华为单反装机图拉丁

-> 嵌入式 -> 德州仪器(Ti)平台嵌入式开发-01 -> 正文阅读

[嵌入式]德州仪器(Ti)平台嵌入式开发-01

这里写自定义目录标题

开发前的准备工作

SDK与ccs等开发工具环境下载与安装
- 登录 https://www.ti.com.cn/，在搜索界面输入MCU微处理器型号，进入产品界面,你可以看到包括产品详情，技术文档，设计和开发，订购和质量以及支持与培训界面。找到设计与开发，点开软件开发，选择对应的SDK，例如MMWAVE-MCUPLUS-SDK，下载安装之后，默认就会在c盘ti文件夹下看到相应SDK目录。我们后边主要需要修改的是mcu_plus_sdk_am273x_08_与mmwave_mcuplus_sdk_04_00。相关SDK的使用指导文档在对应文件夹下边docs文件夹中。
- 同样在软件开发下，下载Code Composer Studio 集成式开发环境 (IDE)，我们后边就简称为CCS，我们开发的主战场，建议下载最新版本，旧的版本会有一些仿真器配合上的问题。在WorkSpace的管理上建议统一到一个文件夹下，后期我开发过程中发现有些配置是不体现到WorkSpace中的，在切换工程的时候注意相关配置的修改。除了CCS，我们后边还需要用到Ti提供的SysConfig，TI CLANG Compiler Toolchain，还有用于flash下载的Python3以及OpenSSL。
- 如果你用的是官方评估版，你需要一个USB转TTL小板来进行代码烧写，串口配置115200波特率，板子也需要用跳线帽来选择为UART BOOTMODE。此时串口连接的话会打印C字符，断开串口后在${SDK_INSTALL_PATH}/tools/boot目录下打开cmd，根据串口编号输入python uart_uniflash.py -p COM --cfg=sbl_prebuilt/am273x-evm/default_sbl_null.cfg，python脚本会根据烧录配置文件调用相应工具完成烧录工作。然后通过跳线帽将板子的启动模式切换回QSPI mode，重启板子即可。
- 仿真环境需要根据使用的仿真器型号以及目标SOC，Goto “View > Target Configuration”，建立目标的配置位置，建立完之后，开始刚才建立的配置文件，如果通过仿真器正确连接了电脑以及板卡，则能够看到如下图的SOC上的核心，之后就可以仿真连接核心，reset核心，并下载mss/dss.out到板卡进行进行程序的仿真。

MCU+SDK 08.01.00

Ti的SDK大概分了四层，从硬件往上数起第一层为OS Kernel层，这一层一方面提供FreeRTOS的符合POSIX标准的OS接口，另一方面为上层提供所谓的Driver Porting Layer（DPL）接口，这一层后边我们会详述其中包含的各个模块。第二层是Drivers and HAL层，这一层主要包含板级外设以及片上外设的驱动代码。第三层包含一些实现TCP/UDP网络协议的LwIP和毫米波的中间件框架代码，最上层就是我们的毫米波Demos和一些针对不同驱动的Examples，而我们的主要工作就是利用这一层的代码，根据当前的硬件设计，集成一版固件，期间可能会修改到各个层的代码。期间用到Ti提供的工具如下图右侧。
SW modules

Driver Porting Layer (DPL)

这一层的API我们会常用，主要的子模块如下：

HW Interrupts
Semaphore
Task
Clock
Cycle Counter
Cache
MPU for ARMv7 (ARM R5, ARM M4)
Region based Address Translate
Heap
Debug
Event
今天我们主要几个别的平台也常见的子模块。

Semaphore

根据不同的用途我们创建一个信号量，如果涉及到中断里的任务间同步，使用二进制信号量，它的初始值是0。如果是用于串行化对critical section代码的访问，使用MutexSem，它的初始化为1。如果是连续的普通信号量，使用CountingSem。下边是各种信号量的初始化代码。

#include <kernel/dpl/SemaphoreP.h>
#include <kernel/dpl/ClockP.h>
/* semaphore objects, typically these are global's */
SemaphoreP_Object gBinarySem;
SemaphoreP_Object gMutexSem;
SemaphoreP_Object gCountingSem;
 
/* resource to protect with counting semaphore */
#define NUM_RESOURCES   (10u)
uint32_t gResource[NUM_RESOURCES];

针对二进制信号量，可以在各种外设挂接的中断处理函数中Post信号量，再在Task中统一处理外设报上来的这些中断，防止因为中断执行时间过长带来的问题。

void myISR(void *args)
{
    SemaphoreP_post(&gBinarySem);
}

void ISRHandleTask(void *args)
{
   int32_t status;
 	....
    SemaphoreP_constructBinary(&gBinarySem, 0);
 
    // initialize peripheral
    // register myISR
    // enable peripheral
 
    /* wait for 10ms for the semaphore to be post by the peripheral */
    status = SemaphoreP_pend(&gBinarySem, ClockP_usecToTicks(10*1000));
    if(status==SystemP_SUCCESS)
    {
        /* success */
    }
    else
    if(status==SystemP_TIMEOUT)
    {
        /* failed due to timeout */
    }
    else
    {
        /* other failure */
    }
    ....
}

互斥信号量则需要成对使用，保护代码代码不被重入，引发竞争问题。

    SemaphoreP_constructMutex(&gMutexSem);
 
    /* wait forever for the mutex to be available, lock or enter the critical section */
    SemaphoreP_pend(&gMutexSem, SystemP_WAIT_FOREVER);
 
    /* mutual exclusion, critical section */
 
    /* unlock the mutex, exit critical section */
    SemaphoreP_post(&gMutexSem);

普通连续的信号量使用如下，协调消费者与生产者之间的同步关系：

    uint32_t resourceId = 0;
 
    SemaphoreP_constructCounting(&gCountingSem, NUM_RESOURCES, NUM_RESOURCES);
 
    /* wait for a resource to be available */
    SemaphoreP_pend(&gCountingSem, SystemP_WAIT_FOREVER);
 
    /* access the resource */
 
    /* release resoource */
    resourceId = (resourceId+1)%NUM_RESOURCES;
    SemaphoreP_post(&gCountingSem);

Task

任务类似一个独立运行的线程，有自己独立的、私有的栈区，共享诸如全局变量等其他资源。下面是创建一个任务需要提前定义的资源,包括一个任务入口函数，Task建立完成之后，入口函数得以以一个线程的角色被调度执行。

#include <kernel/dpl/TaskP.h>
/* Task priority, stack, stack size and task objects, these MUST be global's */
#define MY_TASK_PRI         (8U)
#define MY_TASK_STACK_SIZE  (4*1024U)
uint8_t gMyTaskStack[MY_TASK_STACK_SIZE] __attribute__((aligned(32)));
TaskP_Object gMyTask;
 
/* Application specific task arguments */
typedef struct {
    uint32_t value;
} MyTask_Args;
 
MyTask_Args gMyTask_args;

/* Task entry point or main function for this task */
void myTaskMain(void *args)
{
    MyTask_Args *myArgs = (MyTask_Args*)args;
    DebugP_assert(myArgs != NULL);
 
    /* myArgs points to structure pointer passed during TaskP_construct */
 
    /* do something in the task */
 
    /* when done call below function, DO NOT 'return` from this function */
    TaskP_exit();
}

创建一个任务的代码如下：

    int32_t status;
    TaskP_Params myTaskParams; /* this need not be global variable */
 
    TaskP_Params_init(&myTaskParams);
    myTaskParams.name = "MY_TASK";
    myTaskParams.stackSize = MY_TASK_STACK_SIZE;
    myTaskParams.stack = gMyTaskStack;
    myTaskParams.priority = MY_TASK_PRI;
    myTaskParams.args = &gMyTask_args;
    myTaskParams.taskMain = myTaskMain;
 
    status = TaskP_construct(&gMyTask, &myTaskParams);
    DebugP_assert(status == SystemP_SUCCESS);

Task子模块还提供获取当前/其他任务的CPU使用率，相关代码如下：

    TaskP_Load taskLoad;
    uint32_t cpuLoad;
 
    cpuLoad = TaskP_loadGetTotalCpuLoad();
    DebugP_log(" LOAD: CPU  = %2d.%2d %%\r\n", cpuLoad/100, cpuLoad%100 );
 
    TaskP_loadGet(&gMyTask, &taskLoad);
    DebugP_log(" LOAD: %s = %2d.%2d %%\r\n", taskLoad.name, taskLoad.cpuLoad/100, taskLoad.cpuLoad%100 );

Clock

首先，这个子模块提供了ClockP_usleep和ClockP_sleep,用来Block调用接口的Task本身直到指定睡眠时间结束。常用于Task任务每次循环执行的最后，用于挂起自身线程，让出CPU供其他同或者低优先级任务调度。
其次，这个子模块实现了获取当前系统执行时间的接口，可用于获取一段代码的执行时间。

#include <kernel/dpl/ClockP.h>
	uint64_t curTimeInUsecs;
	
	curTimeInUsecs = ClockP_getTimeUsec();
	
	// code or functions to profile
	// func1()
	// func2()
	
	curTimeInUsecs = ClockP_getTimeUsec() - curTimeInUsecs;

最后，RTOS的情况下，他可以创建一个软Timer，在no-RTOS的情况下，回调函数执行在中断上下文中。如果要建立一个硬Timer，现需要在syscfg创建，并挂接到时执行的回调函数。
在这里插入图片描述
针对Clock子模块，Timer创建首先要准备Timer到时的回调函数。

uint32_t gOneShotCount = 0;
uint32_t gPeriodicCount = 0;
 
void myClockCallback(ClockP_Object *obj, void *arg)
{
    uint32_t *value = (uint32_t*)arg;
 
    (*value)++; /* increment number of time's this callback is called */
}

准备好之后进行Clock的参数初始化，下面的代码建立一个以10ms为周期，one shot mode的Timer。

    ClockP_Params clockParams;
    ClockP_Object clockObj;
 
    ClockP_Params_init(&clockParams);
    clockParams.timeout = ClockP_usecToTicks(10*1000);
    clockParams.start = 1;
    clockParams.callback = myClockCallback;
    clockParams.args = &gOneShotCount; /* pass address of counter which is incremented in the callback */
 
    ClockP_construct(&clockObj, &clockParams);