• 售前

  • 售后

热门帖子
入门百科

NXP S32K146 FREERTOS工程设置UART底层驱动

[复制链接]
凡八哥 显示全部楼层 发表于 2022-1-16 04:02:12 |阅读模式 打印 上一主题 下一主题
MCU平台照旧S32K146,开辟情况是S32DS 用官方的SDK3.0.0,PE设置外设,天生generation code。在SDK上边封装函数,第三库用的ringbuf循环队列,代码实现如下:
hal_uart.c
  1. #include "../inc/hal_uart.h"
  2. extern void LPUART_DRV_StopTxDma(uint32_t instance);
  3. extern void LPUART_DRV_SetIntMode(uint32_t instance, uint32_t intSrc, bool enable);
  4. /* func:set_hard_flow_ctrl
  5. * prara:Device instance number
  6. * return:none
  7. */
  8. static void hal_uart_set_hard_flow_ctrl(INT32U instance)
  9. {
  10.     hal_uart_hard_flowctrl_reg_t reg = {1, 0, 0, 1, 0};
  11.     LPUART_Type* const s_lpuartBase[LPUART_INSTANCE_COUNT] = LPUART_BASE_PTRS;
  12.     LPUART_Type* base = s_lpuartBase[instance];
  13.     base->MODIR = (base->MODIR & ~LPUART_MODIR_TXCTSE_MASK)     | ((reg.TXCTSE ? 1UL : 0UL)   << LPUART_MODIR_TXCTSE_SHIFT);
  14.     base->MODIR = (base->MODIR & ~LPUART_MODIR_TXRTSE_MASK)     | ((reg.TXRTSE ? 1UL : 0UL)   << LPUART_MODIR_TXRTSE_SHIFT);
  15.     base->MODIR = (base->MODIR & ~LPUART_MODIR_TXRTSPOL_MASK)   | ((reg.TXRTSPOL ? 1UL : 0UL) << LPUART_MODIR_TXRTSPOL_SHIFT);
  16.     base->MODIR = (base->MODIR & ~LPUART_MODIR_RXRTSE_MASK)     | ((reg.RXRTSE ? 1UL : 0UL)   << LPUART_MODIR_RXRTSE_SHIFT);
  17.     base->MODIR = (base->MODIR & ~LPUART_MODIR_RXRTSE_MASK)     | ((reg.RXRTSE ? 1UL : 0UL)   << LPUART_MODIR_RXRTSE_SHIFT);
  18. }
  19. /* func:   hal_uart_get_context
  20. * prara:  UART_CH_E
  21. * return: hal_uart_contex_t
  22. */
  23. static hal_uart_contex_t* hal_uart_get_context(UART_CH_E ch)
  24. {
  25.     hal_uart_contex_t* ctx = &g_uart_ctx[ch];
  26.     return ctx;
  27. }
  28. /* func:   uart dcb to config
  29. * prara:  uart_dcb_t/lpuart_user_config_t
  30. * return: BOOLEAN
  31. */
  32. static BOOLEAN hal_uart_dcb2conf(uart_dcb_t* dcb, lpuart_user_config_t* conf)
  33. {
  34.     switch (dcb->databit)
  35.     {
  36.             case UART_DATABIT_8:
  37.                 conf->bitCountPerChar = LPUART_8_BITS_PER_CHAR;
  38.                 break;
  39.             case UART_DATABIT_9:
  40.                 conf->bitCountPerChar = LPUART_9_BITS_PER_CHAR;
  41.                 break;
  42.             case UART_DATABIT_10:
  43.                 conf->bitCountPerChar = LPUART_10_BITS_PER_CHAR;
  44.                 break;
  45.             default:
  46.                 return FALSE;
  47.                 break;
  48.     }
  49.     /* convert parity check mode */
  50.     switch (dcb->parity)
  51.     {
  52.             case UART_PARITY_NONE:
  53.                 conf->parityMode = LPUART_PARITY_DISABLED;
  54.                 break;
  55.             case UART_PARITY_EVEN:
  56.                 conf->parityMode = LPUART_PARITY_EVEN;
  57.                 break;
  58.             case UART_PARITY_ODD:
  59.                 conf->parityMode = LPUART_PARITY_ODD;
  60.                 break;
  61.             default:
  62.                 return FALSE;
  63.                 break;
  64.     }
  65.     /* convert stop bit mode */
  66.     switch (dcb->stopbit)
  67.     {
  68.             case UART_STOPBIT_ONE:
  69.                 conf->stopBitCount = LPUART_ONE_STOP_BIT;
  70.                 break;
  71.             case UART_STOPBIT_TWO:
  72.                 conf->stopBitCount = LPUART_TWO_STOP_BIT;
  73.                 break;
  74.             default:
  75.                 return FALSE;
  76.                 break;
  77.     }
  78.     /* convert band rate */
  79.     conf->baudRate = dcb->baudrate;
  80.     return TRUE;
  81. }
  82. /* func:   uart free
  83. * prara:  hal_uart_contex_t
  84. * return: none
  85. */
  86. static void hal_uart_free(hal_uart_contex_t* ctx)
  87. {
  88.     if (ctx->instance == INST_LPUART1)
  89.     {
  90.         PINS_DRV_WritePin(PTB, 11, 0);
  91.     }
  92.     if (ctx->tx_task_hdl)
  93.     {
  94.         vTaskSuspend(ctx->tx_task_hdl);
  95.         vTaskDelete(ctx->tx_task_hdl);
  96.         ctx->tx_task_hdl = NULL;
  97.     }
  98.     if (ctx->rb_rx)
  99.     {
  100.         ringbuf_free(ctx->rb_rx);
  101.         ctx->rb_rx = NULL;
  102.     }
  103.     if (ctx->rb_tx)
  104.     {
  105.         ringbuf_free(ctx->rb_tx);
  106.         ctx->rb_tx = NULL;
  107.     }
  108.     if (ctx->bf_rx)
  109.     {
  110.         vPortFree(ctx->bf_rx);
  111.         ctx->bf_rx = NULL;
  112.     }
  113.     if (ctx->rb_tx_sem)
  114.     {
  115.         vSemaphoreDelete(ctx->rb_tx_sem);
  116.         ctx->rb_tx_sem = NULL;
  117.     }
  118.     if (ctx->rb_tx_mutex)
  119.     {
  120.         vSemaphoreDelete(ctx->rb_tx_mutex);
  121.         ctx->rb_tx_mutex = NULL;
  122.     }
  123.     if (ctx->tx_mutex)
  124.     {
  125.         vSemaphoreDelete(ctx->tx_mutex);
  126.         ctx->tx_mutex = NULL;
  127.     }
  128. }
  129. static void hal_uart_rx_callback(void* driverState, uart_event_t event, void* userData)
  130. {
  131.     /* Unused parameters */
  132.     (void)driverState;
  133.     INT32U remain_bytes = 0;
  134.     INT32U recv_bytes = 0;
  135.     //hw_sys_task_msg_e hw_sys_msg = 0xff;
  136.     portBASE_TYPE xHigherPriorityTaskWoken = pdFALSE;
  137.     hal_uart_contex_t* ctx = (hal_uart_contex_t*)userData;
  138.     /* Check the event type */
  139.     if (event == UART_EVENT_RX_FULL)
  140.     {
  141.         LPUART_DRV_GetReceiveStatus(ctx->instance, (uint32_t*)&remain_bytes);
  142.         /* calculate receive data bytes */
  143.         if (remain_bytes == ctx->bf_rx_size)
  144.         {
  145.             /* complete receive interrupt */
  146.             recv_bytes = remain_bytes;
  147.         }
  148.         else
  149.         {
  150.             /* idle interrupt */
  151.             recv_bytes = ctx->bf_rx_size - remain_bytes;
  152.         }
  153.         ctx->hw_recv_bytes += recv_bytes;
  154.         ctx->rb_recv_bytes += MIN(ringbuf_free_size(ctx->rb_rx), recv_bytes);
  155.         ringbuf_write(ctx->rb_rx, ctx->bf_rx, recv_bytes);
  156.        // if (ctx->ch == UART_CH_DEBUG)
  157.        // {
  158.        //     hw_sys_msg = HW_SYS_MSG_UART_DEBUG;
  159.        // }
  160.         //else if (ctx->ch == UART_CH_COMM)
  161.         //{
  162.        //     uart_receive_detect = HAL_UART_DETECT_TIMEOUT;
  163.         //    hw_sys_msg = HW_SYS_MSG_UART_COMM;
  164.        // }
  165.        // else if (ctx->ch == UART_CH_IVI)
  166.        // {
  167.        //     hw_sys_msg = HW_SYS_MSG_UART_IVI;
  168.        // }
  169.         //if (hw_sys_queue)
  170.         //{
  171.            // xQueueSendFromISR(hw_sys_queue, (void*)&hw_sys_msg, &xHigherPriorityTaskWoken);
  172.         //}
  173.         LPUART_DRV_SetRxBuffer(ctx->instance, ctx->bf_rx, ctx->bf_rx_size);
  174.         if (xHigherPriorityTaskWoken)
  175.         {
  176.             portYIELD_FROM_ISR(pdTRUE);
  177.         }
  178.     }
  179.     else if (event == UART_EVENT_ERROR)
  180.     {
  181.         if (ctx->ch == UART_CH_COMM)
  182.         {
  183.             //if (hal_pio_get_invalue(WK_MCU) == 1)
  184.             //{
  185.             //    LPUART_DRV_StopRxDma(ctx->instance);
  186.             //    LPUART_DRV_ReceiveData(ctx->instance, ctx->bf_rx, ctx->bf_rx_size);
  187.             //}
  188.             //else
  189.            // {
  190.            //     mpu_ready_flag = FALSE;
  191.            // }
  192.         }
  193.         else
  194.         {
  195.             LPUART_DRV_StopRxDma(ctx->instance);
  196.             LPUART_DRV_ReceiveData(ctx->instance, ctx->bf_rx, ctx->bf_rx_size);
  197.         }
  198.     }
  199.     else
  200.     {
  201.     }
  202. }
  203. /* func:   uart write API
  204. * prara:  UART_CH_E/pdata/len
  205. * return: BOOLEAN
  206. */
  207. BOOLEAN hal_uart_write(UART_CH_E ch, INT8U* pdata, INT16U len)
  208. {
  209.     INT32S left = len;
  210.     hal_uart_contex_t* ctx;
  211.     if (!(ch < MAX_UART_INDEX && pdata != NULL && len > 0))
  212.     {
  213.         return FALSE;
  214.     }
  215.     ctx = hal_uart_get_context(ch);
  216.     if (!(ctx != NULL && ctx->rb_tx_mutex != NULL && ctx->rb_tx != NULL && ctx->rb_tx_sem != NULL))
  217.     {
  218.         return FALSE;
  219.     }
  220.     xSemaphoreTake(ctx->tx_mutex, 10000); // 处理多线程并发访问一个硬件通道导致数据乱序问题
  221.     /* james 20210526 增加retry次数,防止一直占用CPU */
  222.     INT8S retry_cnt = 10;
  223.     while (left > 0 && retry_cnt-- > 0)
  224.     {
  225.         xSemaphoreTake(ctx->rb_tx_mutex, 1000);
  226.         if (!ringbuf_is_full(ctx->rb_tx))
  227.         {
  228.             len = ringbuf_write(ctx->rb_tx, pdata, MIN(ringbuf_free_size(ctx->rb_tx), left));
  229.             if (len > 0)
  230.             {
  231.                 left -= len;
  232.                 pdata += len;
  233.             }
  234.             xSemaphoreGive(ctx->rb_tx_mutex);
  235.             xSemaphoreGive(ctx->rb_tx_sem);
  236.         }
  237.         else
  238.         {
  239.             xSemaphoreGive(ctx->rb_tx_mutex);
  240.             xSemaphoreGive(ctx->rb_tx_sem);
  241.             vTaskDelay(2);//现在参数不对
  242.         }
  243.     }
  244.     xSemaphoreGive(ctx->tx_mutex);
  245.     if (left > 0)
  246.     {
  247.         return FALSE;
  248.     }
  249.     return TRUE;
  250. }
  251. /* func:   uart tx task os
  252. * prara:  args
  253. * return: none
  254. */
  255. static void hal_uart_tx_task(void* args)
  256. {
  257.     hal_uart_contex_t* ctx = (hal_uart_contex_t*)args;
  258.     INT32S txsize = 0;
  259.     char txbuf[HAL_UART_TX_TASK_STACK_SIZE - 384];
  260.     for (;;)
  261.     {
  262.         if (xSemaphoreTake(ctx->rb_tx_sem, HAL_UART_TX_WAIT_TIMEOUT))
  263.         {
  264.             xSemaphoreTake(ctx->rb_tx_mutex, 1000);
  265.             while (!ringbuf_is_empty(ctx->rb_tx))
  266.             {
  267.                 txsize = ringbuf_read(txbuf, ctx->rb_tx, sizeof(txbuf));
  268.                 if (txsize > 0)
  269.                 {
  270.                     xSemaphoreGive(ctx->rb_tx_mutex);
  271.                     if (LPUART_DRV_SendDataBlocking(ctx->instance, txbuf, txsize, 100))
  272.                     {
  273.                         LPUART_DRV_StopTxDma(ctx->instance);
  274.                     }
  275.                     xSemaphoreTake(ctx->rb_tx_mutex, 1000);
  276.                 }
  277.             }
  278.             xSemaphoreGive(ctx->rb_tx_mutex);
  279.         }
  280.     }
  281. }
  282. /* func:   hal uart open
  283. * prara:  UART_CH_E/uart_dcb_t
  284. * return: none
  285. */
  286. BOOLEAN hal_uart_open(UART_CH_E ch, uart_dcb_t* dcb)
  287. {
  288.     LPUART_Type* s_lpuartBase[LPUART_INSTANCE_COUNT] = LPUART_BASE_PTRS;
  289.     hal_uart_contex_t* ctx;
  290.     ctx = hal_uart_get_context(ch);                   //得到hal_uart_contex_t类型数组里面的配置
  291.     hal_uart_dcb2conf(dcb, ctx->conf);                //把调用传参的配置转换成CTX类型
  292.     ctx->ch = ch;                                     //赋值通道号
  293.     ctx->rb_rx = ringbuf_malloc(dcb->rbuf_size);      //申请调用传参时的buf空间
  294.     ctx->rb_tx_sem = xSemaphoreCreateCounting(255,0); //申请发送的计数型信号量
  295.     ctx->rb_tx_mutex = xSemaphoreCreateMutex();       //队列申请互斥信号量
  296.     ctx->rb_tx = ringbuf_malloc(dcb->tbuf_size);      //申请调用传参时的buf空间
  297.     ctx->bf_rx = (INT8U*)os_malloc(ctx->bf_rx_size);  //申请DMA缓存空间
  298.     ctx->tx_mutex = xSemaphoreCreateMutex();          //发送锁
  299.     LPUART_DRV_Init(ctx->instance, ctx->state, ctx->conf);//初始化函数
  300.     INT_SYS_DisableIRQGlobal();                           //关闭全局中断
  301.     LPUART_DRV_SetIntMode(ctx->instance, LPUART_INT_IDLE_LINE, true);//使能空闲中断
  302.     s_lpuartBase[ctx->instance]->CTRL = s_lpuartBase[ctx->instance]->CTRL | 0x0700;//设置空闲字数128个字节
  303.     if (dcb->flowctrl == UART_FLOWCTRL_RTSCTS)            //设置硬件流控
  304.     {
  305.        hal_uart_set_hard_flow_ctrl(ctx->instance);
  306.     }
  307.     INT_SYS_SetPriority(ctx->irq_num, configLIBRARY_MAX_SYSCALL_INTERRUPT_PRIORITY + 1);//收发中断优先级
  308.     if (ctx->instance == INST_LPUART1)//DMA通道优先级
  309.     {
  310.         INT_SYS_SetPriority(DMA1_IRQn, configLIBRARY_MAX_SYSCALL_INTERRUPT_PRIORITY + 1);
  311.         INT_SYS_SetPriority(DMA2_IRQn, configLIBRARY_MAX_SYSCALL_INTERRUPT_PRIORITY + 1);
  312.     }
  313.     LPUART_DRV_InstallRxCallback(ctx->instance, hal_uart_rx_callback, ctx);//配置回调函数
  314.     if (ctx->instance == INST_LPUART1)//唤醒232en
  315.     {
  316.         PINS_DRV_WritePin(PTB, 11, 1);
  317.     }
  318.     INT_SYS_EnableIRQGlobal();//打开全局中断
  319.     //ctx->tx_task_hdl = xTaskCreate(hal_uart_tx_task,ctx->tx_task_name, HAL_UART_TX_TASK_STACK_SIZE,ctx,HAL_UART_TX_TASK_PRIORITY,NULL) ;
  320.     /* start receive data from UART */
  321.     //LPUART_DRV_ReceiveData(ctx->instance, ctx->bf_rx, ctx->bf_rx_size);
  322. //放开上边两个函数后 程序进入DefaultISR:急需排查问题
  323.     return TRUE;
  324. }
  325. void test_uart(void)
  326. {
  327.     const uint8_t sbuf[20] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
  328.     for (;;)
  329.     {
  330.         hal_uart_write(UART_CH_DEBUG, sbuf, sizeof(sbuf));
  331.         vTaskDelay(100 / portTICK_RATE_MS);
  332.     }
  333. }
复制代码
hardwaremanage.c
  1. #include "hardwareManage.h"
  2. void hw_uart_open(void)
  3. {
  4.     uart_dcb_t hal_dcb;
  5.     hal_dcb.rbuf_size = HW_UART_DBG_BUFF_SIZE;
  6.     hal_dcb.tbuf_size = HW_UART_DBG_BUFF_SIZE;
  7.     hal_uart_open(TO_HW_UART_CH(HW_UART_CH_DEBUG), &hal_dcb);
  8. }
  9. void vSystemHardwareHalInit(void)
  10. {
  11.         hw_uart_open();
  12. }
  13. //上边vSystemHardwareHalInit在主函数初始化
复制代码
main.c 小灯1S闪烁任务代表体系运行
  1. void vSystemHardwareWorkTask(void *p)
  2. {
  3.     while(1)
  4.     {
  5.             PINS_DRV_TogglePins(PTE,1<<3);
  6.         vTaskDelay(1000);
  7.     }
  8. }
  9. int main(void)
  10. {
  11.   /* Write your local variable definition here */
  12.   /*** Processor Expert internal initialization. DON'T REMOVE THIS CODE!!! ***/
  13.   #ifdef PEX_RTOS_INIT
  14.     PEX_RTOS_INIT();                   /* Initialization of the selected RTOS. Macro is defined by the RTOS component. */
  15.   #endif
  16.   /*** End of Processor Expert internal initialization.                    ***/
  17.     CLOCK_SYS_Init(g_clockManConfigsArr, CLOCK_MANAGER_CONFIG_CNT, g_clockManCallbacksArr, CLOCK_MANAGER_CALLBACK_CNT);
  18.     CLOCK_SYS_UpdateConfiguration(0U, CLOCK_MANAGER_POLICY_AGREEMENT);
  19.     PINS_DRV_Init(NUM_OF_CONFIGURED_PINS, g_pin_mux_InitConfigArr);
  20.         vSystemHardwareHalInit();
  21.     xTaskCreate( vSystemHardwareWorkTask, "SystemHardwareWorkTask",  310, 0, 1,0);//系统硬件工作任务 优先级1
  22.     vTaskStartScheduler();
复制代码
效果:工程不卡在DefaultISR中,但是由于是串口初始化导致的DefaultISR,打断点不能看到是哪个制止号出现的题目。换成下边这个
  1.   void DefaultISR(void)
  2.   {
  3.      #define VECTORNUM                     (*(volatile uint8_t*)(0xE000ED04))
  4.      printf("\n****default_isr entered on vector %d*****\r\n\n", VECTORNUM);
  5.      return;
  6.   }
复制代码
根据下边这张图定位到vector 3 根据打印出来的数据,判定VECTOR,是怎么缘故起因触发制止的。这里我的值为3,查对应芯片向量表,得知是Hard_Fault导致的。还得接着往下找详细是什么引起的硬件制止。

调试方法3:只要重写函数HardFault_Handler,然后在函数HardFault_Handler内里实行语句“asm(“bx lr”)”可以让步伐实行到进入函数HardFault_Handler制止之前的函数,如许是不是就很容易定位到这个地点啦?
  1.   void DefaultISR(void)
  2.   {
  3.      #define VECTORNUM                     (*(volatile uint8_t*)(0xE000ED04))
  4.      //printf("\n****default_isr entered on vector %d*****\r\n\n", VECTORNUM);
  5.           sprintf(buf,"\n****default_isr entered on vector %d  %x *****\r\n\n", (uint8_t)VECTORNUM, (uint32_t)VECTORNUM);
  6.      return;
  7.   }
复制代码
题目点好像定位到EDMA_DRV_InstallCallback函数,当通过BL或BLX指令调用子步伐时,硬件自动将子步伐返回地点生存在R14寄存器中。在子步伐返回时,把LR的值复制到步伐计数器PC即可实现子步伐返回。我在__asm(“bx lr”);打的断点然后单步运行的定位到EDMA_DRV_InstallCallback不知道是不是返回调用处。但是LPUART_DRV_StartReceiveDataUsingDma调用EDMA_DRV_InstallCallback;LPUART_DRV_ReceiveData调用LPUART_DRV_StartReceiveDataUsingDma,这也证明了题目出现在LPUART_DRV_ReceiveData函数。
调试方法4:
  1. void HardFault_Handler(void)
  2. {
  3.         // LR provides information of the return stack PSP/MSP
  4.         //__asm("MOVS R0, #4");
  5.         ///__asm("MOV R1, LR");
  6.         //__asm("TST R0, R1");
  7.         //__asm("BEQ _MSP");
  8.        // __asm("MRS R0, PSP");
  9.        /// //__asm("B getStackFrame");
  10.        // __asm("_MSP:");
  11.        // __asm("MRS R0, MSP");
  12.         //__asm("B getStackFrame");
  13.        __asm("bx lr");
  14.    //SystemSoftwareReset();
  15.    //return;
  16. }
复制代码
得到PC指针为6926 16进制0x1B0E也就是进EDMA_DRV_ConfigSingleBlockTransfer之后发生的硬件故障,原来试图定位代码但是没有找到相干方法。先分析一下这个函数是否有题目。

调试方法5:CmBacktrace(有点贫苦没有用)
办理:是我粗心。。。调用DMA没有初始化DMA,才发生的硬件制止。加上EDMA_DRV_Init(&dmaController1_State,&dmaController1_InitConfig0,edmaChnStateArray,edmaChnConfigArray,EDMA_CONFIGURED_CHANNELS_COUNT);就好了,这一天如同梦游,照旧对S32平台不熟悉的缘故。
修改后的源码:
hal_uart.c
  1. uint32_t r0;
  2. uint32_t r1;
  3. uint32_t r2;
  4. uint32_t r3;
  5. uint32_t r12;
  6. uint32_t lr;
  7. uint32_t pc;
  8. uint32_t psr;
  9. void getStackFrame(uint32_t *stackFrame)
  10. {
  11.         r0  = stackFrame[0];
  12.         r1  = stackFrame[1];
  13.         r2  = stackFrame[2];
  14.         r3  = stackFrame[3];
  15.         r12 = stackFrame[4];
  16.         lr  = stackFrame[5];
  17.         pc  = stackFrame[6];//程序计数器(pc)保存导致异常的指令的地址。
  18.         psr = stackFrame[7];
  19.         __asm("BKPT");  //断点中断指令
  20. }
  21.   void HardFault_Handler(void)
  22. {
  23.         // LR provides information of the return stack PSP/MSP
  24.         __asm("MOVS R0, #4");
  25.         __asm("MOV R1, LR");
  26.         __asm("TST R0, R1");
  27.         __asm("BEQ _MSP");
  28.         __asm("MRS R0, PSP");
  29.        __asm("B getStackFrame");
  30.         __asm("_MSP:");
  31.         __asm("MRS R0, MSP");
  32.         __asm("B getStackFrame");
  33.        //__asm("bx lr");
  34.    //SystemSoftwareReset();
  35.    return;
  36. }
复制代码
增肌hal_board.c
  1. /* func:   hal uart open
  2. * prara:  UART_CH_E/uart_dcb_t
  3. * return: none
  4. */
  5. BOOLEAN hal_uart_open(UART_CH_E ch, uart_dcb_t* dcb)
  6. {
  7.     LPUART_Type* s_lpuartBase[LPUART_INSTANCE_COUNT] = LPUART_BASE_PTRS;
  8.     hal_uart_contex_t* ctx;
  9.     ctx = hal_uart_get_context(ch);                   //得到hal_uart_contex_t类型数组里面的配置
  10.     hal_uart_dcb2conf(dcb, ctx->conf);                //把调用传参的配置转换成CTX类型
  11.     ctx->ch = ch;                                     //赋值通道号
  12.     ctx->rb_rx = ringbuf_malloc(dcb->rbuf_size);      //申请调用传参时的buf空间
  13.     ctx->rb_tx_sem = xSemaphoreCreateCounting(255,0); //申请发送的计数型信号量
  14.     ctx->rb_tx_mutex = xSemaphoreCreateMutex();       //队列申请互斥信号量
  15.     ctx->rb_tx = ringbuf_malloc(dcb->tbuf_size);      //申请调用传参时的buf空间
  16.     ctx->bf_rx = (INT8U*)os_malloc(ctx->bf_rx_size);  //申请DMA缓存空间
  17.     ctx->tx_mutex = xSemaphoreCreateMutex();          //发送锁
  18.     LPUART_DRV_Init(ctx->instance, ctx->state, ctx->conf);//初始化函数
  19.     INT_SYS_DisableIRQGlobal();                           //关闭全局中断
  20.     LPUART_DRV_SetIntMode(ctx->instance, LPUART_INT_IDLE_LINE, true);//使能空闲中断
  21.     s_lpuartBase[ctx->instance]->CTRL = s_lpuartBase[ctx->instance]->CTRL | 0x0700;//设置空闲字数128个字节
  22.     if (dcb->flowctrl == UART_FLOWCTRL_RTSCTS)            //设置硬件流控
  23.     {
  24.        hal_uart_set_hard_flow_ctrl(ctx->instance);
  25.     }
  26.     INT_SYS_SetPriority(ctx->irq_num, configLIBRARY_MAX_SYSCALL_INTERRUPT_PRIORITY + 1);//收发中断优先级
  27.     if (ctx->instance == INST_LPUART1)//DMA通道优先级
  28.     {
  29.         INT_SYS_SetPriority(DMA1_IRQn, configLIBRARY_MAX_SYSCALL_INTERRUPT_PRIORITY + 1);
  30.         INT_SYS_SetPriority(DMA2_IRQn, configLIBRARY_MAX_SYSCALL_INTERRUPT_PRIORITY + 1);
  31.     }
  32.     LPUART_DRV_InstallRxCallback(ctx->instance, hal_uart_rx_callback, ctx);//配置回调函数
  33.     if (ctx->instance == INST_LPUART1)//唤醒232en
  34.     {
  35.         PINS_DRV_WritePin(PTB, 11, 1);
  36.     }
  37.     INT_SYS_EnableIRQGlobal();//打开全局中断
  38.    
  39.     ctx->tx_task_hdl = xTaskCreate(hal_uart_tx_task,ctx->tx_task_name, HAL_UART_TX_TASK_STACK_SIZE,ctx,HAL_UART_TX_TASK_PRIORITY,NULL) ;
  40.     LPUART_DRV_ReceiveData(ctx->instance, ctx->bf_rx, ctx->bf_rx_size);  //开启接收
  41.     for (INT8U i = 0; i < sizeof(g_uart_save_status) / sizeof(g_uart_save_status[0]); i++)
  42.     {//初始化状态相关的全局变量
  43.         if (g_uart_save_status[i].ch == ch)
  44.         {
  45.             g_uart_save_status[i].dcb.baudrate  = dcb->baudrate;
  46.             g_uart_save_status[i].dcb.databit   = dcb->databit;
  47.             g_uart_save_status[i].dcb.flowctrl  = dcb->flowctrl;
  48.             g_uart_save_status[i].dcb.parity    = dcb->parity;
  49.             g_uart_save_status[i].dcb.rbuf_size = dcb->rbuf_size;
  50.             g_uart_save_status[i].dcb.stopbit   = dcb->stopbit;
  51.             g_uart_save_status[i].dcb.tbuf_size = dcb->tbuf_size;
  52.             g_uart_save_status[i].staus = HAL_UART_OPEN;
  53.             break;
  54.         }
  55.     }
  56.     return TRUE;
  57. }
复制代码
hardwaremanage.c
  1. #include "../inc/hal_board.h"
  2. BOOLEAN hal_board_init(void)
  3. {
  4.     CLOCK_SYS_Init(g_clockManConfigsArr, CLOCK_MANAGER_CONFIG_CNT, g_clockManCallbacksArr, CLOCK_MANAGER_CALLBACK_CNT);
  5.     CLOCK_SYS_UpdateConfiguration(0U, CLOCK_MANAGER_POLICY_AGREEMENT);
  6.     PINS_DRV_Init(NUM_OF_CONFIGURED_PINS, g_pin_mux_InitConfigArr);
  7.     //增加没有初始化的DMA
  8.     EDMA_DRV_Init(&dmaController1_State, &dmaController1_InitConfig0, edmaChnStateArray, edmaChnConfigArray, EDMA_CONFIGURED_CHANNELS_COUNT);
  9. }
复制代码
main.c
[code]  void vSystemHardwareWorkTask(void *p)  {      while(1)      {              PINS_DRV_TogglePins(PTE,1

本帖子中包含更多资源

您需要 登录 才可以下载或查看,没有帐号?立即注册

x

帖子地址: 

回复

使用道具 举报

分享
推广
火星云矿 | 预约S19Pro,享500抵1000!
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

草根技术分享(草根吧)是全球知名中文IT技术交流平台,创建于2021年,包含原创博客、精品问答、职业培训、技术社区、资源下载等产品服务,提供原创、优质、完整内容的专业IT技术开发社区。
  • 官方手机版

  • 微信公众号

  • 商务合作