[MM32硬件] 基于keil环境下mm32f327单片机rtthread的移植

[复制链接]
4975|76
 楼主| 为你转身 发表于 2022-7-30 23:46 | 显示全部楼层
 楼主| 为你转身 发表于 2022-7-30 23:47 | 显示全部楼层
startup分组下添加 :
Library\Device\MM32F327x\Source 下的 system_mm32f327x.c 文件;
Library\Device\MM32F327x\Source\KEIL_StartAsm下的startup_mm32f327x
.c文件;
 楼主| 为你转身 发表于 2022-7-30 23:48 | 显示全部楼层
 楼主| 为你转身 发表于 2022-7-30 23:48 | 显示全部楼层
doc分组添加工程的说明文档;
seekfree_libraries分组下添加:
Library\seekfree_libraries目录下的.c文件;
 楼主| 为你转身 发表于 2022-7-30 23:49 | 显示全部楼层
 楼主| 为你转身 发表于 2022-7-30 23:49 | 显示全部楼层
seekfree_peripheral分组下添加:
Library\seekfree_peripheral目录下的.c文件;
 楼主| 为你转身 发表于 2022-7-30 23:50 | 显示全部楼层
 楼主| 为你转身 发表于 2022-7-30 23:51 | 显示全部楼层
rtt_src分组下添加:
Library\rtthread_libraries\src目录下的.c文件;
9606062e5535661311.png
 楼主| 为你转身 发表于 2022-7-30 23:52 | 显示全部楼层
rtt_inc分组下添加:
Library\rtthread_libraries\include和Library\rtthread_libraries\include\libc目录下的.h文件;
 楼主| 为你转身 发表于 2022-7-30 23:52 | 显示全部楼层
 楼主| 为你转身 发表于 2022-7-30 23:53 | 显示全部楼层
rtt_lib分组下添加:
Library\rtthread_libraries\libcpu目录下的context_rvds.S和cpuport.c文件;
 楼主| 为你转身 发表于 2022-7-30 23:53 | 显示全部楼层
 楼主| 为你转身 发表于 2022-7-30 23:54 | 显示全部楼层
rtt_componer分组下添加:
Library\rtthread_libraries\components\finsh目录下的所有文件;
 楼主| 为你转身 发表于 2022-7-30 23:54 | 显示全部楼层
 楼主| 为你转身 发表于 2022-7-30 23:55 | 显示全部楼层
添加头文件路径如下:
5388962e55465e0b10.png
 楼主| 为你转身 发表于 2022-7-30 23:56 | 显示全部楼层
本帖最后由 为你转身 于 2022-7-30 23:57 编辑

更改相应的.c文件
isr.c文件:
  1. /*********************************************************************************************************************
  2. * COPYRIGHT NOTICE
  3. * Copyright (c)
  4. * All rights reserved.
  5. * [url=home.php?mod=space&uid=32416]@software[/url]                        IAR 8.3 or MDK 5.28
  6. * [url=home.php?mod=space&uid=73031]@target[/url] core                MM32F3277
  7. * [url=home.php?mod=space&uid=466179]@taobao[/url]                        https://seekfree.taobao.com/
  8. * [url=home.php?mod=space&uid=212281]@date[/url]                                2021-02-22
  9. ********************************************************************************************************************/

  10. #include "headfile.h"
  11. #include "isr.h"

  12. void TIM1_UP_IRQHandler (void)
  13. {
  14.         uint32 state = TIM1->SR;                                                                                                                // 读取中断状态
  15.         TIM1->SR &= ~state;                                                                                                                                // 清空中断状态
  16. }

  17. void TIM8_UP_IRQHandler (void)
  18. {
  19.         uint32 state = TIM8->SR;                                                                                                                // 读取中断状态
  20.         TIM8->SR &= ~state;                                                                                                                                // 清空中断状态
  21. }

  22. void TIM2_IRQHandler (void)
  23. {
  24.         uint32 state = TIM2->SR;                                                                                                                // 读取中断状态
  25.         TIM2->SR &= ~state;                                                                                                                                // 清空中断状态
  26. }

  27. void TIM5_IRQHandler (void)
  28. {
  29.         uint32 state = TIM5->SR;                                                                                                                // 读取中断状态
  30.         TIM5->SR &= ~state;                                                                                                                                // 清空中断状态
  31. }

  32. void TIM3_IRQHandler (void)
  33. {
  34.         uint32 state = TIM3->SR;                                                                                                                // 读取中断状态
  35.         TIM3->SR &= ~state;                                                                                                                                // 清空中断状态
  36. }

  37. void TIM4_IRQHandler (void)
  38. {
  39.         uint32 state = TIM4->SR;                                                                                                                // 读取中断状态
  40.         TIM4->SR &= ~state;                                                                                                                                // 清空中断状态
  41. }

  42. void TIM6_IRQHandler (void)
  43. {
  44.         uint32 state = TIM6->SR;                                                                                                                // 读取中断状态
  45.         TIM6->SR &= ~state;                                                                                                                                // 清空中断状态
  46. }

  47. void TIM7_IRQHandler (void)
  48. {
  49.         uint32 state = TIM7->SR;                                                                                                                // 读取中断状态
  50.         TIM7->SR &= ~state;                                                                                                                                // 清空中断状态
  51. }

  52. //void UART1_IRQHandler(void)
  53. //{
  54. //        if(UART1->ISR & UART_ISR_TX_INTF)                                                                                                // 串口发送缓冲空中断
  55. //        {
  56. //                UART1->ICR |= UART_ICR_TXICLR;                                                                                                // 清除中断标志位
  57. //        }
  58. //        if(UART1->ISR & UART_ISR_RX_INTF)                                                                                                // 串口接收缓冲中断
  59. //        {
  60. //                UART1->ICR |= UART_ICR_RXICLR;                                                                                                // 清除中断标志位
  61. //        }
  62. //}

  63. void UART2_IRQHandler(void)
  64. {
  65.         if(UART2->ISR & UART_ISR_TX_INTF)                                                                                                // 串口发送缓冲空中断
  66.         {
  67.                 UART2->ICR |= UART_ICR_TXICLR;                                                                                                // 清除中断标志位
  68.         }
  69.         if(UART2->ISR & UART_ISR_RX_INTF)                                                                                                // 串口接收缓冲中断
  70.         {
  71.                 UART2->ICR |= UART_ICR_RXICLR;                                                                                                // 清除中断标志位
  72.         }
  73. }

  74. void UART3_IRQHandler(void)
  75. {
  76.         if(UART3->ISR & UART_ISR_TX_INTF)                                                                                                // 串口发送缓冲空中断
  77.         {
  78.                 UART3->ICR |= UART_ICR_TXICLR;                                                                                                // 清除中断标志位
  79.         }
  80.         if(UART3->ISR & UART_ISR_RX_INTF)                                                                                                // 串口接收缓冲中断
  81.         {
  82.                 UART3->ICR |= UART_ICR_RXICLR;                                                                                                // 清除中断标志位
  83.         }
  84. }

  85. void UART4_IRQHandler(void)
  86. {
  87.         if(UART4->ISR & UART_ISR_TX_INTF)                                                                                                // 串口发送缓冲空中断
  88.         {
  89.                 UART4->ICR |= UART_ICR_TXICLR;                                                                                                // 清除中断标志位
  90.         }
  91.         if(UART4->ISR & UART_ISR_RX_INTF)                                                                                                // 串口接收缓冲中断
  92.         {
  93.                 UART4->ICR |= UART_ICR_RXICLR;                                                                                                // 清除中断标志位
  94.         }
  95. }

  96. void UART5_IRQHandler(void)
  97. {
  98.         if(UART5->ISR & UART_ISR_TX_INTF)                                                                                                // 串口发送缓冲空中断
  99.         {
  100.                 UART5->ICR |= UART_ICR_TXICLR;                                                                                                // 清除中断标志位
  101.         }
  102.         if(UART5->ISR & UART_ISR_RX_INTF)                                                                                                // 串口接收缓冲中断
  103.         {
  104.                 UART5->ICR |= UART_ICR_RXICLR;                                                                                                // 清除中断标志位
  105.         }
  106. }

  107. void UART6_IRQHandler(void)
  108. {
  109.         if(UART6->ISR & UART_ISR_TX_INTF)                                                                                                // 串口发送缓冲空中断
  110.         {
  111.                 UART6->ICR |= UART_ICR_TXICLR;                                                                                                // 清除中断标志位
  112.         }
  113.         if(UART6->ISR & UART_ISR_RX_INTF)                                                                                                // 串口接收缓冲中断
  114.         {
  115.                 UART6->ICR |= UART_ICR_RXICLR;                                                                                                // 清除中断标志位
  116.         }
  117. }

  118. void UART7_IRQHandler(void)
  119. {
  120.         if(UART7->ISR & UART_ISR_TX_INTF)                                                                                                // 串口发送缓冲空中断
  121.         {
  122.                 UART7->ICR |= UART_ICR_TXICLR;                                                                                                // 清除中断标志位
  123.         }
  124.         if(UART7->ISR & UART_ISR_RX_INTF)                                                                                                // 串口接收缓冲中断
  125.         {
  126.                 UART7->ICR |= UART_ICR_RXICLR;                                                                                                // 清除中断标志位
  127.         }
  128. }

  129. void UART8_IRQHandler(void)
  130. {
  131.         if(UART8->ISR & UART_ISR_TX_INTF)                                                                                                // 串口发送缓冲空中断
  132.         {
  133.                 UART8->ICR |= UART_ICR_TXICLR;                                                                                                // 清除中断标志位
  134.         }
  135.         if(UART8->ISR & UART_ISR_RX_INTF)                                                                                                // 串口接收缓冲中断
  136.         {
  137.                 UART8->ICR |= UART_ICR_RXICLR;                                                                                                // 清除中断标志位
  138.                 switch(camera_type)                                                                                                                        // 查询摄像头类型 未初始化摄像头则此处会进入default
  139.                 {
  140.                         case CAMERA_BIN_UART:                                                                                                         // 串口小钻风
  141.                                 ov7725_cof_uart_interrupt();                                                                                // 调用串口小钻风的串口接收处理
  142.                                 break;
  143.                         case CAMERA_GRAYSCALE:                                                                                                         // 总钻风
  144.                                 mt9v03x_uart_callback();                                                                                        // 调用总钻风的串口接收处理
  145.                                 break;
  146.                         default:
  147.                                 break;
  148.                 }
  149.         }
  150. }

  151. void EXTI0_IRQHandler(void)
  152. {
  153.         // 检测与清除中断标志可以根据实际应用进行删改
  154.         EXTI_ClearFlag(EXTI_Line0);                                                                                                                // 清除 line0 触发标志
  155. }

  156. void EXTI1_IRQHandler(void)
  157. {
  158.         // 检测与清除中断标志可以根据实际应用进行删改
  159.         EXTI_ClearFlag(EXTI_Line1);                                                                                                                // 清除 line1 触发标志
  160. }

  161. void EXTI2_IRQHandler(void)
  162. {
  163.         // 检测与清除中断标志可以根据实际应用进行删改
  164.         EXTI_ClearFlag(EXTI_Line2);                                                                                                                // 清除 line2 触发标志
  165. }

  166. void EXTI3_IRQHandler(void)
  167. {
  168.         // 检测与清除中断标志可以根据实际应用进行删改
  169.         EXTI_ClearFlag(EXTI_Line3);                                                                                                                // 清除 line3 触发标志
  170. }

  171. void EXTI4_IRQHandler(void)
  172. {
  173.         // 检测与清除中断标志可以根据实际应用进行删改
  174.         EXTI_ClearFlag(EXTI_Line4);                                                                                                                // 清除 line4 触发标志
  175. }

  176. void EXTI9_5_IRQHandler(void)
  177. {
  178.         // 检测与清除中断标志可以根据实际应用进行删改
  179.         if(EXTI_GetITStatus(EXTI_Line5))                                                                                                // 检测 line5 是否触发
  180.         {
  181.                 EXTI_ClearFlag(EXTI_Line5);                                                                                                        // 清除 line5 触发标志
  182.         }
  183.         if(EXTI_GetITStatus(EXTI_Line6))                                                                                                // 检测 line6 是否触发
  184.         {
  185.                 EXTI_ClearFlag(EXTI_Line6);                                                                                                        // 清除 line6 触发标志
  186.         }
  187.         if(EXTI_GetITStatus(EXTI_Line7))                                                                                                // 检测 line7 是否触发
  188.         {
  189.                 EXTI_ClearFlag(EXTI_Line7);                                                                                                        // 清除 line8 触发标志
  190.         }
  191.         if(EXTI_GetITStatus(EXTI_Line8))                                                                                                // 检测 line8 是否触发
  192.         {
  193.                 switch(camera_type)                                                                                                                        // 查询摄像头类型 未初始化摄像头则此处会进入default
  194.                 {
  195.                         case CAMERA_BIN:                                                                                                                  // IIC小钻风
  196.                                 ov7725_vsync();
  197.                                 break;
  198.                         case CAMERA_BIN_UART:                                                                                                          // 串口小钻风
  199.                                 ov7725_uart_vsync();
  200.                                 break;
  201.                         case CAMERA_GRAYSCALE:                                                                                                         // 总钻风
  202.                                 mt9v03x_vsync();
  203.                                 break;
  204.                         default:
  205.                                 break;
  206.                 }
  207.                 EXTI_ClearFlag(EXTI_Line8);                                                                                                        // 清除 line8 触发标志
  208.         }
  209.         if(EXTI_GetITStatus(EXTI_Line9))                                                                                                // 检测 line9 是否触发
  210.         {
  211.                 EXTI_ClearFlag(EXTI_Line9);                                                                                                        // 清除 line9 触发标志
  212.         }
  213. }

  214. void EXTI15_10_IRQHandler (void)
  215. {
  216.         // 检测与清除中断标志可以根据实际应用进行删改
  217.         if(EXTI_GetITStatus(EXTI_Line10))                                                                                                // 检测 line10 是否触发
  218.         {
  219.                 EXTI_ClearFlag(EXTI_Line10);                                                                                                // 清除 line10 触发标志
  220.         }
  221.         if(EXTI_GetITStatus(EXTI_Line11))                                                                                                // 检测 line11 是否触发
  222.         {
  223.                 EXTI_ClearFlag(EXTI_Line11);                                                                                                // 清除 line11 触发标志
  224.         }
  225.         if(EXTI_GetITStatus(EXTI_Line12))                                                                                                // 检测 line12 是否触发
  226.         {
  227.                 EXTI_ClearFlag(EXTI_Line12);                                                                                                // 清除 line12 触发标志
  228.         }
  229.         if(EXTI_GetITStatus(EXTI_Line13))                                                                                                // 检测 line13 是否触发
  230.         {
  231.                 EXTI_ClearFlag(EXTI_Line13);                                                                                                // 清除 line13 触发标志
  232.         }
  233.         if(EXTI_GetITStatus(EXTI_Line14))                                                                                                // 检测 line14 是否触发
  234.         {
  235.                 EXTI_ClearFlag(EXTI_Line14);                                                                                                // 清除 line14 触发标志
  236.         }
  237.         if(EXTI_GetITStatus(EXTI_Line15))                                                                                                // 检测 line15 是否触发
  238.         {
  239.                 EXTI_ClearFlag(EXTI_Line15);                                                                                                // 清除 line15 触发标志
  240.         }
  241. }

  242. void DMA1_Channel1_IRQHandler(void)
  243. {
  244.         if(SET == DMA_GetFlagStatus(DMA1_FLAG_TC1))                                                                                // 判断触发通道
  245.         {
  246.                 DMA_ClearFlag(DMA1_FLAG_TC1);                                                                                                // 清空该通道中断标志
  247.         }
  248. }

  249. void DMA1_Channel2_IRQHandler(void)
  250. {
  251.         if(SET == DMA_GetFlagStatus(DMA1_FLAG_TC2))                                                                                // 判断触发通道
  252.         {
  253.                 DMA_ClearFlag(DMA1_FLAG_TC2);                                                                                                // 清空该通道中断标志
  254.         }
  255. }

  256. void DMA1_Channel3_IRQHandler(void)
  257. {
  258.         if(SET == DMA_GetFlagStatus(DMA1_FLAG_TC3))                                                                                // 判断触发通道
  259.         {
  260.                 DMA_ClearFlag(DMA1_FLAG_TC3);                                                                                                // 清空该通道中断标志
  261.         }
  262. }

  263. void DMA1_Channel4_IRQHandler(void)
  264. {
  265.         if(SET == DMA_GetFlagStatus(DMA1_FLAG_TC4))                                                                                // 判断触发通道
  266.         {
  267.                 DMA_ClearFlag(DMA1_FLAG_TC4);                                                                                                // 清空该通道中断标志
  268.                 switch(camera_type)                                                                                                                        // 查询摄像头类型 未初始化摄像头则此处会进入default
  269.                 {
  270.                         case CAMERA_BIN:                                                                                                                  // IIC小钻风
  271.                                 ov7725_dma();
  272.                                 break;
  273.                         case CAMERA_BIN_UART:                                                                                                          // 串口小钻风
  274.                                 ov7725_uart_dma();
  275.                                 break;
  276.                         case CAMERA_GRAYSCALE:                                                                                                         // 总钻风
  277.                                 mt9v03x_dma();
  278.                                 break;
  279.                         default:
  280.                                 break;
  281.                 }
  282.         }
  283. }

  284. void DMA1_Channel5_IRQHandler(void)
  285. {
  286.         if(SET == DMA_GetFlagStatus(DMA1_FLAG_TC5))                                                                                // 判断触发通道
  287.         {
  288.                 DMA_ClearFlag(DMA1_FLAG_TC5);                                                                                                // 清空该通道中断标志
  289.         }
  290. }

  291. void DMA1_Channel6_IRQHandler(void)
  292. {
  293.         if(SET == DMA_GetFlagStatus(DMA1_FLAG_TC6))                                                                                // 判断触发通道
  294.         {
  295.                 DMA_ClearFlag(DMA1_FLAG_TC6);                                                                                                // 清空该通道中断标志
  296.         }
  297. }

  298. void DMA1_Channel7_IRQHandler(void)
  299. {
  300.         if(SET == DMA_GetFlagStatus(DMA1_FLAG_TC7))                                                                                // 判断触发通道
  301.         {
  302.                 DMA_ClearFlag(DMA1_FLAG_TC7);                                                                                                // 清空该通道中断标志
  303.         }
  304. }

  305. void DMA2_Channel1_IRQHandler(void)
  306. {
  307.         if(SET == DMA_GetFlagStatus(DMA2_FLAG_TC1))                                                                                // 判断触发通道
  308.         {
  309.                 DMA_ClearFlag(DMA2_FLAG_TC1);                                                                                                // 清空该通道中断标志
  310.         }
  311. }

  312. void DMA2_Channel2_IRQHandler(void)
  313. {
  314.         if(SET == DMA_GetFlagStatus(DMA2_FLAG_TC2))                                                                                // 判断触发通道
  315.         {
  316.                 DMA_ClearFlag(DMA2_FLAG_TC2);                                                                                                // 清空该通道中断标志
  317.         }
  318. }

  319. void DMA2_Channel3_IRQHandler(void)
  320. {
  321.         if(SET == DMA_GetFlagStatus(DMA2_FLAG_TC3))                                                                                // 判断触发通道
  322.         {
  323.                 DMA_ClearFlag(DMA2_FLAG_TC3);                                                                                                // 清空该通道中断标志
  324.         }
  325. }

  326. void DMA2_Channel4_IRQHandler(void)
  327. {
  328.         if(SET == DMA_GetFlagStatus(DMA2_FLAG_TC4))                                                                                // 判断触发通道
  329.         {
  330.                 DMA_ClearFlag(DMA2_FLAG_TC4);                                                                                                // 清空该通道中断标志
  331.         }
  332. }

  333. void DMA2_Channel5_IRQHandler(void)
  334. {
  335.         if(SET == DMA_GetFlagStatus(DMA2_FLAG_TC5))                                                                                // 判断触发通道
  336.         {
  337.                 DMA_ClearFlag(DMA2_FLAG_TC5);                                                                                                // 清空该通道中断标志
  338.         }
  339. }

  340. #ifdef Will_never_be_defined
  341. WWDG_IRQHandler
  342. PVD_IRQHandler
  343. TAMPER_IRQHandler
  344. RTC_IRQHandler
  345. FLASH_IRQHandler
  346. RCC_CRS_IRQHandler
  347. EXTI0_IRQHandler
  348. EXTI1_IRQHandler
  349. EXTI2_IRQHandler
  350. EXTI3_IRQHandler
  351. EXTI4_IRQHandler
  352. DMA1_Channel1_IRQHandler
  353. DMA1_Channel2_IRQHandler
  354. DMA1_Channel3_IRQHandler
  355. DMA1_Channel4_IRQHandler
  356. DMA1_Channel5_IRQHandler
  357. DMA1_Channel6_IRQHandler
  358. DMA1_Channel7_IRQHandler
  359. ADC1_2_IRQHandler
  360. FlashCache_IRQHandler
  361. CAN1_RX_IRQHandler
  362. EXTI9_5_IRQHandler
  363. TIM1_BRK_IRQHandler
  364. TIM1_UP_IRQHandler
  365. TIM1_TRG_COM_IRQHandler
  366. TIM1_CC_IRQHandler
  367. TIM2_IRQHandler
  368. TIM3_IRQHandler
  369. TIM4_IRQHandler
  370. I2C1_IRQHandler
  371. I2C2_IRQHandler
  372. SPI1_IRQHandler
  373. SPI2_IRQHandler
  374. UART1_IRQHandler
  375. UART2_IRQHandler
  376. UART3_IRQHandler
  377. EXTI15_10_IRQHandler
  378. RTCAlarm_IRQHandler
  379. OTG_FS_WKUP_IRQHandler
  380. TIM8_BRK_IRQHandler
  381. TIM8_UP_IRQHandler
  382. TIM8_TRG_COM_IRQHandler
  383. TIM8_CC_IRQHandler
  384. ADC3_IRQHandler
  385. SDIO_IRQHandler
  386. TIM5_IRQHandler
  387. SPI3_IRQHandler
  388. UART4_IRQHandler
  389. UART5_IRQHandler
  390. TIM6_IRQHandler
  391. TIM7_IRQHandler
  392. DMA2_Channel1_IRQHandler
  393. DMA2_Channel2_IRQHandler
  394. DMA2_Channel3_IRQHandler
  395. DMA2_Channel4_IRQHandler
  396. DMA2_Channel5_IRQHandler
  397. ETH_IRQHandler
  398. COMP1_2_IRQHandler
  399. OTG_FS_IRQHandler
  400. UART6_IRQHandler
  401. UART7_IRQHandler
  402. UART8_IRQHandler
  403. #endif
 楼主| 为你转身 发表于 2022-7-30 23:58 | 显示全部楼层
main.c文件
  1. /******************************************************************************************************
  2. * @Software                        IAR 8.3 or MDK 5.24
  3. * @Target core                MM32F3277
  4. * @Taobao                        https://seekfree.taobao.com/
  5. * @date                                2021-02-22
  6. ********************************************************************************************************************/

  7. #include "headfile.h"
  8. #include "isr.h"
  9. // **************************** 宏定义 ****************************

  10. // **************************** 宏定义 ****************************

  11. // **************************** 变量定义 ****************************

  12. // **************************** 变量定义 ****************************

  13. // **************************** 代码区域 ****************************
  14. //-------------------------------------------------------------------------------------------------------------------
  15. //  [url=home.php?mod=space&uid=247401]@brief[/url]      线程1入口
  16. //  @param      parameter   参数
  17. //  [url=home.php?mod=space&uid=266161]@return[/url]     void
  18. //  Sample usage:
  19. //-------------------------------------------------------------------------------------------------------------------
  20. void thread1_entry(void *parameter)
  21. {

  22.     while(1)
  23.     {
  24.         rt_kprintf("dynamic thread is running.\n");
  25.         rt_thread_mdelay(1000);
  26.     }
  27. }

  28. //-------------------------------------------------------------------------------------------------------------------
  29. //  @brief      线程2入口
  30. //  @param      parameter   参数
  31. //  @return     void
  32. //  Sample usage:
  33. //-------------------------------------------------------------------------------------------------------------------
  34. void thread2_entry(void *parameter)
  35. {

  36.     while(1)
  37.     {
  38.         rt_kprintf("static thread is running.\n");
  39.         rt_thread_mdelay(500);
  40.     }
  41. }



  42. //-------------------------------------------------------------------------------------------------------------------
  43. //  @brief      动态线程创建以及启动
  44. //  @param      void        空
  45. //  @return     void
  46. //  Sample usage:
  47. //-------------------------------------------------------------------------------------------------------------------
  48. int dynamic_thread_example(void)
  49. {
  50.     //线程控制块指针
  51.     rt_thread_t tid1;
  52.     //创建动态线程
  53.     tid1 = rt_thread_create("thread1",      //线程名称
  54.             thread1_entry,                  //线程入口函数
  55.             RT_NULL,                        //线程参数
  56.             512,                            //512个字节的栈空间
  57.             5,                              //线程优先级为5,数值越小,优先级越高,0为最高优先级。
  58.                                             //可以通过修改rt_config.h中的RT_THREAD_PRIORITY_MAX宏定义(默认值为8)来修改最大支持的优先级
  59.             5);                             //时间片为5

  60.     rt_kprintf("create dynamic thread.\n");
  61.     if(tid1 != RT_NULL)                     //线程创建成功
  62.     {
  63.         rt_kprintf("thread1 dynamic thread create OK.\n");
  64.         rt_thread_startup(tid1);            //运行该线程
  65.     }
  66.     else                                    //线程创建失败
  67.     {
  68.         rt_kprintf("thread1 dynamic thread create ERROR.\n");
  69.         return 1;
  70.     }

  71.     return 0;
  72. }

  73. //-------------------------------------------------------------------------------------------------------------------
  74. //  @brief      静态线程创建以及启动
  75. //  @param      void        空
  76. //  @return     void
  77. //  Sample usage:
  78. //-------------------------------------------------------------------------------------------------------------------
  79. static rt_uint8_t thread2_stack[1024];  //线程栈数组
  80. struct rt_thread thread2_thread;        //线程控制块
  81. int static_thread_example(void)
  82. {
  83.     rt_err_t res;
  84.     //创建静态线程
  85.     res = rt_thread_init(
  86.                 &thread2_thread,                //线程控制块
  87.                 "thread2",                      //线程名称
  88.                 thread2_entry,                  //线程入口函数
  89.                 RT_NULL,                        //线程参数
  90.                 thread2_stack,                  //栈的起始地址
  91.                 sizeof(thread2_stack),          //栈大小
  92.                 3,                              //线程优先级为3,数值越小,优先级越高,0为最高优先级。
  93.                                                 //可以通过修改rt_config.h中的RT_THREAD_PRIORITY_MAX宏定义(默认值为8)来修改最大支持的优先级
  94.                 5                               //时间片为5
  95.             );

  96.     rt_kprintf("create static thread.\n");

  97.     if(res == RT_EOK)                                       //线程创建成功
  98.     {
  99.         rt_kprintf("thread2 static thread create OK\n");
  100.         rt_thread_startup(&thread2_thread);                 //运行该线程

  101.     }
  102.     else                                                    //线程创建失败
  103.     {
  104.         rt_kprintf("thread2 static thread create ERROR\n");
  105.         return 1;
  106.     }
  107.     return 0;
  108. }

  109. //使用INIT_APP_EXPORT宏自动初始化,也可以通过在其他线程内调用dynamic_thread_example函数进行初始化
  110. INIT_APP_EXPORT(dynamic_thread_example);     //应用初始化

  111. //使用INIT_APP_EXPORT宏自动初始化,也可以通过在其他线程内调用static_thread_example函数进行初始化
  112. INIT_APP_EXPORT(static_thread_example);      //应用初始化

  113. //静态创建方法
  114. //当我们没有开启RT_USING_HEAP宏定义我们只能使用静态的方法创建线程、信号量、互斥量等等
  115. //或者当我们想要指定控制块控制块或者栈的位置的时候,也可以用静态创建方法



  116. //动态创建方法
  117. //动态创建务必开启RT_USING_HEAP宏定义
  118. //动态创建好处在于我们不用自己定义控制块或者栈数组,创建的时候填写的参数更加的少非常的方便
  119. //如果HEAP大小不够了,可以在board.c中找到RT_HEAP_SIZE宏进行修改



  120. int main(void)
  121. {
  122.         //此处编写用户代码(例如:外设初始化代码等)
  123.         gpio_init(H2, GPO, 0, GPO_PUSH_PULL);
  124.         //此处编写用户代码(例如:外设初始化代码等)

  125.         while(1)
  126.         {
  127.                 rt_thread_mdelay(100);
  128.     gpio_toggle(H2);
  129.         }
  130. }
  131. // **************************** 代码区域 ****************************

 楼主| 为你转身 发表于 2022-7-31 17:11 | 显示全部楼层
board.c文件:


  1. #include "board.h"
  2. #include "zf_uart.h"
  3. #include <rtthread.h>
  4. #include "mm32_reg_redefine_v1.h"

  5. extern uint32_t SystemCoreClock;

  6. //finsh组件接收串口数据,是通过在串口中断内发送邮件,finsh线程接收邮件进行获取的
  7. rt_mailbox_t uart_mb;

  8. static uint32_t systick_config(rt_uint32_t ticks)
  9. {
  10.     if ((ticks - 1) > 0xFFFFFF)
  11.     {
  12.         return 1;
  13.     }

  14.     SysTick->LOAD = ticks - 1;
  15.     nvic_init(SysTick_IRQn, 3, ENABLE);
  16.     SysTick->VAL  = 0;
  17.     SysTick->CTRL = 0x07;  
  18.    
  19.     return 0;
  20. }

  21. #if defined(RT_USING_USER_MAIN) && defined(RT_USING_HEAP)
  22. #define RT_HEAP_SIZE 700

  23. static uint32_t rt_heap[RT_HEAP_SIZE];     // heap default size: 4K(1024 * 4)
  24. RT_WEAK void *rt_heap_begin_get(void)
  25. {
  26.     return rt_heap;
  27. }

  28. RT_WEAK void *rt_heap_end_get(void)
  29. {
  30.     return rt_heap + RT_HEAP_SIZE;
  31. }
  32. #endif


  33. void rt_hw_board_init()
  34. {
  35.     systick_config(SystemCoreClock / RT_TICK_PER_SECOND);
  36.    
  37.     board_init(1);
  38.    
  39.     /* Call components board initial (use INIT_BOARD_EXPORT()) */
  40. #ifdef RT_USING_COMPONENTS_INIT
  41.     rt_components_board_init();
  42. #endif

  43. #if defined(RT_USING_USER_MAIN) && defined(RT_USING_HEAP)
  44.     rt_system_heap_init(rt_heap_begin_get(), rt_heap_end_get());
  45. #endif
  46.    
  47.     uart_mb = rt_mb_create("uart_mb", 10, RT_IPC_FLAG_FIFO);
  48. }


  49. void SysTick_Handler(void)
  50. {
  51.     rt_interrupt_enter();

  52.     rt_tick_increase();


  53.     rt_interrupt_leave();
  54. }

  55. void rt_hw_console_output(const char *str)
  56. {
  57.     while(RT_NULL != *str)
  58.     {
  59.         if('\n' == *str)
  60.         {
  61.             uart_putchar(DEBUG_UART, '\r');
  62.         }
  63.         uart_putchar(DEBUG_UART, *str++);
  64.     }
  65. }



  66. char rt_hw_console_getchar(void)
  67. {
  68.     uint32 dat;
  69.     //等待邮件
  70.     rt_mb_recv(uart_mb, &dat, RT_WAITING_FOREVER);
  71.     //uart_getchar(DEBUG_UART, &dat);
  72.     return (char)dat;
  73. }

  74. //-------------------------------------------------------------------------------------------------------------------
  75. // @brief                核心板初始化
  76. // @param                debug_enable        是否开启默认 debug 输出 DEBUG_UART 默认 UART1
  77. // @return                void
  78. // Sample usage:                                board_init(TRUE);
  79. //-------------------------------------------------------------------------------------------------------------------
  80. void board_init (bool debug_enable)
  81. {
  82.         if(debug_enable)
  83.     {
  84.         uart_init(DEBUG_UART, DEBUG_UART_BAUD, DEBUG_UART_TX, DEBUG_UART_RX);                                        // 默认初始化 UART1 用以支持 printf 输出
  85.     }

  86.     uart_rx_irq(DEBUG_UART, 1);
  87. }

  88. void UART1_IRQHandler(void)
  89. {
  90.     uint8 dat;
  91.     rt_interrupt_enter();
  92.         if(UART1->ISR & UART_ISR_TX_INTF)                // 串口发送缓冲空中断
  93.         {
  94.                 UART1->ICR |= UART_ICR_TXICLR;                // 清除中断标志位
  95.         }
  96.         if(UART1->ISR & UART_ISR_RX_INTF)                // 串口接收缓冲中断
  97.         {
  98.                 uart_getchar(DEBUG_UART, &dat);
  99.         rt_mb_send(uart_mb, dat);           // 发送邮件
  100.         UART1->ICR |= UART_ICR_RXICLR;                // 清除中断标志位
  101.         }
  102.     rt_interrupt_leave();
  103. }



 楼主| 为你转身 发表于 2022-7-31 17:16 | 显示全部楼层
rtconfig.h文件:
  1. /* RT-Thread config file */

  2. #ifndef __RTTHREAD_CFG_H__
  3. #define __RTTHREAD_CFG_H__

  4. #if defined(__CC_ARM) || defined(__CLANG_ARM)
  5. //#include "RTE_Components.h" // 用来开关 FinSH 组件,仅 MDK 会产生该文件


  6. #if defined(RTE_USING_FINSH)
  7. #define RT_USING_FINSH
  8. #endif //RTE_USING_FINSH

  9. #endif //(__CC_ARM) || (__CLANG_ARM)



  10. // <<< Use Configuration Wizard in Context Menu >>>
  11. // <h>Basic Configuration
  12. // <o>Maximal level of thread priority <8-256>
  13. //  <i>Default: 32
  14. #define RT_THREAD_PRIORITY_MAX  8
  15. // <o>OS tick per second
  16. //  <i>Default: 1000   (1ms)
  17. #define RT_TICK_PER_SECOND  1000
  18. // <o>Alignment size for CPU architecture data access
  19. //  <i>Default: 4
  20. #define RT_ALIGN_SIZE   4
  21. // <o>the max length of object name<2-16>
  22. //  <i>Default: 8
  23. #define RT_NAME_MAX    8
  24. // <c1>Using RT-Thread components initialization
  25. //  <i>Using RT-Thread components initialization
  26. #define RT_USING_COMPONENTS_INIT
  27. // </c>

  28. #define RT_USING_USER_MAIN

  29. // <o>the stack size of main thread<1-4086>
  30. //  <i>Default: 512
  31. #define RT_MAIN_THREAD_STACK_SIZE     512

  32. // </h>

  33. // <h>Debug Configuration
  34. // <c1>enable kernel debug configuration
  35. //  <i>Default: enable kernel debug configuration
  36. //#define RT_DEBUG
  37. // </c>
  38. // <o>enable components initialization debug configuration<0-1>
  39. //  <i>Default: 0
  40. #define RT_DEBUG_INIT 0
  41. // <c1>thread stack over flow detect
  42. //  <i> Diable Thread stack over flow detect
  43. //#define RT_USING_OVERFLOW_CHECK
  44. // </c>
  45. // </h>

  46. // <h>Hook Configuration
  47. // <c1>using hook
  48. //  <i>using hook
  49. //#define RT_USING_HOOK
  50. // </c>
  51. // <c1>using idle hook
  52. //  <i>using idle hook
  53. //#define RT_USING_IDLE_HOOK
  54. // </c>
  55. // </h>

  56. // <e>Software timers Configuration
  57. // <i> Enables user timers
  58. #define RT_USING_TIMER_SOFT         0
  59. #if RT_USING_TIMER_SOFT == 0
  60.     #undef RT_USING_TIMER_SOFT
  61. #endif
  62. // <o>The priority level of timer thread <0-31>
  63. //  <i>Default: 4
  64. #define RT_TIMER_THREAD_PRIO        3
  65. // <o>The stack size of timer thread <0-8192>
  66. //  <i>Default: 512
  67. #define RT_TIMER_THREAD_STACK_SIZE  256
  68. // </e>

  69. // <h>IPC(Inter-process communication) Configuration
  70. // <c1>Using Semaphore
  71. //  <i>Using Semaphore
  72. #define RT_USING_SEMAPHORE
  73. // </c>
  74. // <c1>Using Mutex
  75. //  <i>Using Mutex
  76. //#define RT_USING_MUTEX
  77. // </c>
  78. // <c1>Using Event
  79. //  <i>Using Event
  80. #define RT_USING_EVENT
  81. // </c>
  82. // <c1>Using MailBox
  83. //  <i>Using MailBox
  84. #define RT_USING_MAILBOX
  85. // </c>
  86. // <c1>Using Message Queue
  87. //  <i>Using Message Queue
  88. #define RT_USING_MESSAGEQUEUE
  89. // </c>
  90. // </h>

  91. // <h>Memory Management Configuration
  92. // <c1>Dynamic Heap Management
  93. //  <i>Dynamic Heap Management
  94. #define RT_USING_HEAP
  95. // </c>
  96. // <c1>using small memory
  97. //  <i>using small memory
  98. #define RT_USING_SMALL_MEM
  99. // </c>
  100. // <c1>using tiny size of memory
  101. //  <i>using tiny size of memory
  102. //#define RT_USING_TINY_SIZE
  103. // </c>
  104. // </h>

  105. // <h>Console Configuration
  106. // <c1>Using console
  107. //  <i>Using console
  108. #define RT_USING_CONSOLE
  109. // </c>
  110. // <o>the buffer size of console <1-1024>
  111. //  <i>the buffer size of console
  112. //  <i>Default: 128  (128Byte)
  113. #define RT_CONSOLEBUF_SIZE          128
  114. // </h>

  115. #define RT_USING_FINSH


  116. #if defined(RT_USING_FINSH)
  117.     #define FINSH_USING_MSH
  118.     #define FINSH_USING_MSH_ONLY
  119.     // <h>Finsh Configuration
  120.     // <o>the priority of finsh thread <1-7>
  121.     //  <i>the priority of finsh thread
  122.     //  <i>Default: 6
  123.     #define __FINSH_THREAD_PRIORITY     4
  124.     #define FINSH_THREAD_PRIORITY       (RT_THREAD_PRIORITY_MAX / 8 * __FINSH_THREAD_PRIORITY + 1)
  125.     // <o>the stack of finsh thread <1-4096>
  126.     //  <i>the stack of finsh thread
  127.     //  <i>Default: 4096  (4096Byte)
  128.     #define FINSH_THREAD_STACK_SIZE     768
  129.     // <o>the history lines of finsh thread <1-32>
  130.     //  <i>the history lines of finsh thread
  131.     //  <i>Default: 5
  132.     #define FINSH_HISTORY_LINES         1

  133.     #define FINSH_USING_SYMTAB
  134.     // </h>
  135. #endif

  136. // <<< end of configuration section >>>

  137. #endif

 楼主| 为你转身 发表于 2022-7-31 20:21 | 显示全部楼层
common.c文件:
  1. /*********************************************************************************************************************
  2. * COPYRIGHT NOTICE
  3. * Copyright (c) 2019,逐飞科技
  4. * All rights reserved.
  5. * 技术讨论QQ群:一群:179029047(已满)  二群:244861897
  6. *
  7. * 以下所有内容版权均属逐飞科技所有,未经允许不得用于商业用途,
  8. * 欢迎各位使用并传播本程序,修改内容时必须保留逐飞科技的版权声明。
  9. *
  10. * @file                                common.c
  11. * @company                        成都逐飞科技有限公司
  12. * @author                        逐飞科技(QQ3184284598)
  13. * @version                        查看doc内version文件 版本说明
  14. * @Software                        IAR 8.32.4 or MDK 5.28
  15. * @Target core                MM32F3277
  16. * @Taobao                        https://seekfree.taobao.com/
  17. * @date                                2021-02-22
  18. ********************************************************************************************************************/

  19. #include "common.h"
  20. #include "hal_misc.h"

  21. CAMERA_TYPE_enum camera_type;                                                                                                        // 摄像头类型变量
  22. uint8 *camera_buffer_addr;                                                                                                                // 摄像头缓冲区地址指针

  23. //-------------------------------------------------------------------------------------------------------------------
  24. // @brief                中断初始化
  25. // @param                irqn                        中断号,可以查看 reg_common.h 文件中的 IRQn_Type 枚举体定义
  26. // @param                priority                选择该中断优先级 范围 [0-7]
  27. // @param                status                        使能或者失能
  28. // @return                void
  29. // Sample usage:                                nvic_init(EXTI0_IRQn, 0, ENABLE);                                // 外部中断0使能,抢占优先级最高
  30. //-------------------------------------------------------------------------------------------------------------------
  31. void nvic_init(IRQn_Type irqn, uint8 priority, FunctionalState status)
  32. {
  33.         NVIC_InitTypeDef NVIC_InitStructure;

  34.         NVIC_InitStructure.NVIC_IRQChannel = irqn;                                  // 中断号设置
  35.         NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority= priority & 0x07;                // 抢占优先级值越小,优先级越高
  36.         NVIC_InitStructure.NVIC_IRQChannelSubPriority= 0;                                                        // 响应优先级值越小,优先级越高
  37.         NVIC_InitStructure.NVIC_IRQChannelCmd = status;                                                                // 使能
  38.         NVIC_Init(&NVIC_InitStructure);
  39. }

  40. //-------------------------------------------------------------------------------------------------------------------
  41. // @brief                全局中断使能
  42. // @return                void
  43. // Sample usage:                                nvic_interrput_enable();
  44. //-------------------------------------------------------------------------------------------------------------------
  45. void nvic_interrput_enable (void)
  46. {
  47.         __ASM volatile("cpsie i");
  48. }

  49. //-------------------------------------------------------------------------------------------------------------------
  50. // @brief                全局中断失能
  51. // @return                void
  52. // Sample usage:                                nvic_interrput_disable();
  53. //-------------------------------------------------------------------------------------------------------------------
  54. void nvic_interrput_disable (void)
  55. {
  56.         __ASM volatile("cpsid i");
  57. }

  58. void NMI_Handler(void)
  59. {
  60.         while(1);
  61. }
  62. //void HardFault_Handler(void)
  63. //{
  64. //        //硬件上访  可能是数组越界或者使用了未初始化的设备
  65. //        //这里提示大家一个问题,经常有人说我的外设初始化了怎么就是要进HardFault呢
  66. //        //很多是因为自己开了中断,然后在中断里面使用了外设,然后他的初始化顺序是先初始化中断然后再初始化外设
  67. //        //那么问题就来了,中断初始化完成之后会部分中断直接进入中断函数或者满足调节也会进入中断函数,那么就会造成中断里面使用到的外设还没被初始化
  68. //        //所以大家需要注意这个问题
  69. //        while(1);
  70. //}
  71. void MemManage_Handler(void)
  72. {
  73.         while(1);
  74. }
  75. void BusFault_Handler(void)
  76. {
  77.         while(1);
  78. }
  79. void UsageFault_Handler(void)
  80. {
  81.         while(1);
  82. }
  83. void SVC_Handler(void)
  84. {
  85.         while(1);
  86. }
  87. void DebugMon_Handler(void)
  88. {
  89.         while(1);
  90. }
  91. //void PendSV_Handler(void)
  92. //{
  93. //        while(1);
  94. //}

您需要登录后才可以回帖 登录 | 注册

本版积分规则

快速回复 在线客服 返回列表 返回顶部