通过上篇文章对STM32MP1双核机制的分析。我们知道M4内核的程序，不能够下载到FLASH当中。那怎么调试M4的程序呢。下面我们就开始讲一讲。
STM32MP1跟普通M4核MCU开发没有太大的区别，一样调用HAL库，一样可以通过CUBEMX工具生成
初始化代码。当然在能控制的外设方面比真正的M4单片机要少一些，上文已描述过。我们在这里就不多说了。
, H+ x7 t5 w* c; i( S我们打开CUBEMX工具，选择对应型号，配置工程：
我们想控制板上一颗LED，并且串口能够收发数据。
; o/ `7 {2 o( b) u9 P+ z7 j8 W% u5 aLED引脚电路位置：
+ P, w7 h. L+ p( \
与STLINK相连的调试串口UART4电路位置：

, M- Z2 r0 I6 P+ `7 H
; m: k5 p* w- `; S. d" l' q6 [( {

, O5 t4 c. j" ~; H+ H% Z; R% U/ KCUBEMX配置：
2 }% p6 ?9 x" h3 w
4 D( @6 F+ T! ~4 d' l* L( L
  C0 E: s+ N' K3 F, T( \& C
配置时钟：
' X1 ^! K6 l& N7 Y# p' }  c' ?


) s! B7 L0 P" d! h; G工程配置时，选择让每一个外设生成独立文件：
% O/ H2 F7 r/ p& k" g
然后生成代码，我们这里没有官方的STM32CUBEIDE开发，用MDK。
生成的代码，我们不直接用，仅作为参考。
修改自己的led程序：
C:

1. void led_init(void)
   % s, S# A8 b8 `0 d; S6 M5 m
2. {
   : ]9 Q7 ^' w6 z4 S" B+ S
3.     GPIO_InitTypeDef gpio_init_struct;
   1 O8 J. p& k/ W
4.     LED0_GPIO_CLK_ENABLE(); /* LED0时钟使能 */
   
5. 
   ! i/ \4 t8 M0 }) F- a
6. 
   
7.     gpio_init_struct.Pin = LED0_GPIO_PIN;                   /* LED0引脚 */
   
8.     gpio_init_struct.Mode = GPIO_MODE_OUTPUT_PP;            /* 推挽输出 */
   
9.     gpio_init_struct.Pull = GPIO_PULLUP;                    /* 上拉 */
   
10.     gpio_init_struct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;     /* 高速 */
    
11.     HAL_GPIO_Init(LED0_GPIO_PORT, &gpio_init_struct);       /* 初始化LED0引脚 */
    
12. 
    
13. 
    
14.     LED0(0);    /* 关闭 LED0 */
    & p$ v4 s& V5 b/ ~9 z
15. 
    
16. }

复制代码

H:
( n; {3 N4 _* d" J8 V! q8 @/ g

1. #define LED0_GPIO_PORT                  GPIOE
   
2. #define LED0_GPIO_PIN                   GPIO_PIN_12
   
3. #define LED0_GPIO_CLK_ENABLE()          do{ __HAL_RCC_GPIOE_CLK_ENABLE(); }while(0)   /* PE口时钟使能 */
     g1 E7 q: K9 F, ~  @+ _0 R! X/ Q
4. 
   ' z7 q' p9 n8 r) D
5. /******************************************************************************************/
   
6. 
   
7. 
   # u5 v7 ?# {6 i$ ~7 C
8. /* LED端口定义 */
   - d4 \5 h- ^4 |
9. #define LED0(x)   do{ x ? \
   
10.                       HAL_GPIO_WritePin(LED0_GPIO_PORT, LED0_GPIO_PIN, GPIO_PIN_SET) : \
    8 Q7 r  a! @5 I: q/ ^1 R% y
11.                       HAL_GPIO_WritePin(LED0_GPIO_PORT, LED0_GPIO_PIN, GPIO_PIN_RESET); \
    - Z" D0 o! g5 y  `8 Y; p
12.                   }while(0)       /* LED0 = RED */
    ; y- q; ^( z* F
13. 
    
14. /* LED取反定义 */
    0 ?3 N& ], q( ]0 L% C9 a& R
15. #define LED0_TOGGLE()    do{ HAL_GPIO_TogglePin(LED0_GPIO_PORT, LED0_GPIO_PIN); }while(0)   /* LED0 = !LED0 */
    + Z2 k7 u" F, G3 d  K% J2 X$ r- d. U
16. 
    $ r- r  {9 x7 L  e" \
17. 
    ) Z$ N' X! j& W4 _% I
18. #define LED0_STATION     HAL_GPIO_ReadPin(LED0_GPIO_PORT, LED0_GPIO_PIN)
    
19. 
    
20. void led_init(void);    /* 初始化 */

复制代码

UART4.C
6 o+ D. v( o; _% _主要处理都在接收回传函数里面，此接收函数一直参考正点原子。
$ C: w) ]& W+ t3 Y- D1 [& \( H: g

1. * 接收缓冲, 最大USART_REC_LEN个字节. */
   ( D" H+ s9 y1 X& u% ?  K
2. uint8_t g_usart_rx_buf[USART_REC_LEN];
   ) ?; L  v2 T1 d5 T5 u& w0 s
3. 
   
4. /*  接收状态
   
5. *  bit15，      接收完成标志
   
6. *  bit14，      接收到0x0d
   8 [, |7 i: ^0 p/ H) F
7. *  bit13~0，    接收到的有效字节数目
   
8. */
   
9. uint16_t g_usart_rx_sta = 0;
   . B; ^  G8 T; [* f' M+ N0 _5 T
10. 
    
11. uint8_t g_rx_buffer[RXBUFFERSIZE];    /* HAL库使用的串口接收缓冲 */
    
12. 
    
13. UART_HandleTypeDef g_uart4_handle;    /* UART句柄 */
    
14. 
    
15. 
    
16. /**
    ' C) l. V; z% j+ \7 J
17. * @brief       串口X初始化函数
    2 M" f6 u6 a, X" f2 y
18. * @param       baudrate: 波特率, 根据自己需要设置波特率值
    
19. * @note        注意: 必须设置正确的时钟源, 否则串口波特率就会设置异常.
    
20. *              这里的USART的时钟源在sys_stm32_clock_init()函数中已经设置过了.
    - U9 f$ A) B4 B- s0 X9 R/ f& K3 k
21. * @retval      无
    
22. */
    / E. Y+ ^* x# K" N* s' }5 w
23. void usart_init(uint32_t baudrate)
    
24. {
    
25.     g_uart4_handle.Instance = USART_UX;                    /* USART4 */
    ( h: D+ h& I* X* Z
26.     g_uart4_handle.Init.BaudRate = baudrate;               /* 波特率 */
    $ T1 {" e3 _; [( M5 Y& N! A- ?
27.     g_uart4_handle.Init.WordLength = UART_WORDLENGTH_8B;   /* 字长为8位数据格式 */
    
28.     g_uart4_handle.Init.StopBits = UART_STOPBITS_1;        /* 一个停止位 */
    
29.     g_uart4_handle.Init.Parity = UART_PARITY_NONE;         /* 无奇偶校验位 */
    
30.     g_uart4_handle.Init.HwFlowCtl = UART_HWCONTROL_NONE;   /* 无硬件流控 */
    - l; e. @/ m9 V! L; |- I- ?5 U6 A* f
31.     g_uart4_handle.Init.Mode = UART_MODE_TX_RX;            /* 收发模式 */
    7 D# Z6 t* z8 {7 C( c
32.     HAL_UART_Init(&g_uart4_handle);                        /* HAL_UART_Init()会使能UART4 */
    ) p8 x# C' O% |, b
33.    
    ' a! x, u% e5 y' U- ?) z; b
34.     /* 该函数会开启接收中断：标志位UART_IT_RXNE，并且设置接收缓冲以及接收缓冲接收最大数据量 */
    4 w- T- H. K/ n- c
35.     HAL_UART_Receive_IT(&g_uart4_handle, (uint8_t *)g_rx_buffer, RXBUFFERSIZE);
    ( q4 P) O! E! n% k  N( R8 s& X; m
36. }
    
37. 
    3 a3 u3 P1 o- J- m# l7 q$ |
38. /**
    
39. * @brief       UART底层初始化函数
    " Y! p1 ~7 u4 g% J4 v! R
40. * @param       huart: UART句柄类型指针
    : y; S* E0 \2 E
41. * @note        此函数会被HAL_UART_Init()调用
    
42. *              完成时钟使能，引脚配置，中断配置
    % A0 E1 J& p8 F$ ?- y
43. * @retval      无
    1 H  b2 g' ^8 @0 n' R
44. */
    
45. void HAL_UART_MspInit(UART_HandleTypeDef *huart)
    
46. {
    
47.     GPIO_InitTypeDef gpio_init_struct;
    % i2 p* b. O2 ^* l
48.         RCC_PeriphCLKInitTypeDef rcc_periphclk_init_struct;
    
49.         
    / t5 y/ n+ D6 T7 t" }7 _  Q' T
50.     if(huart->Instance == UART4)                                   /* 如果是串口4，进行串口4 MSP初始化 */
    
51.     {
    
52.         USART_UX_CLK_ENABLE();                                      /* USART4时钟使能 */
    
53.         USART_TX_GPIO_CLK_ENABLE();                                 /* 发送引脚时钟使能 */
    ( X0 D- n! A6 a1 v
54.         USART_RX_GPIO_CLK_ENABLE();                                 /* 接收引脚时钟使能 */
    " f  Z# V! x% ?+ A
55. 
    
56.         gpio_init_struct.Pin = USART_TX_GPIO_PIN;                   /* 指定TX引脚 */
    ' G+ {" P0 J- B! K7 y
57.         gpio_init_struct.Mode = GPIO_MODE_AF_PP;                    /* 复用推挽输出 */
    
58.         gpio_init_struct.Pull = GPIO_PULLUP;                        /* 上拉 */
    ( P' T3 F$ F) H3 a. \- @
59.         gpio_init_struct.Speed = GPIO_SPEED_FREQ_HIGH;              /* 高速 */
    - N3 F3 f5 ]" Q
60.         gpio_init_struct.Alternate = USART_TX_GPIO_AF;              /* 复用为UART4 */
    
61.         HAL_GPIO_Init(USART_TX_GPIO_PORT, &gpio_init_struct);       /* 初始化发送引脚 */
    1 a1 ^9 `0 _. v/ H; x, Z
62. 
    ! [& a% o) p9 L- r0 \
63.         gpio_init_struct.Pin = USART_RX_GPIO_PIN;                   /* 指定RX引脚 */
    
64.         gpio_init_struct.Alternate = USART_RX_GPIO_AF;              /* 复用为UART4 */
    
65.         HAL_GPIO_Init(USART_RX_GPIO_PORT, &gpio_init_struct);       /* 初始化接收引脚 */
    - D5 n/ X& |  T/ N+ m
66.                
    
67.                 /* 设置UART4时钟源=PLL4Q=74.25MHz  */
    
68.                 rcc_periphclk_init_struct.Uart24ClockSelection = RCC_UART24CLKSOURCE_PLL4;
    , U* H+ S4 c- `
69.                 HAL_RCCEx_PeriphCLKConfig(&rcc_periphclk_init_struct);
    8 T& Z. a2 W2 f! s4 G% y
70. 
    7 U5 H& v) H' M. k1 Z2 h3 ]5 S
71. #if USART_EN_RX
    2 V: }. @4 V( r1 }6 C
72.         HAL_NVIC_EnableIRQ(USART_UX_IRQn);                          /* 使能USART4中断通道 */
    
73.         HAL_NVIC_SetPriority(USART_UX_IRQn, 3, 3);                  /* 抢占优先级3，子优先级3 */
    
74. #endif
    
75.     }
    
76. }
    
77. 
    4 |3 J5 k2 l$ s  p9 Z
78. /**
    % V( P5 O& T$ @! {8 R
79. * @brief       Rx传输回调函数
    
80. * @param       huart: UART4句柄类型指针
    2 ^* x9 [' W& \4 M- N: e& @
81. * @retval      无
    7 \% R3 c4 E6 x
82. */
    
83. void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
    ! ?' K. t+ d& Z" O7 x% V6 O( `
84. {
    
85.     if(huart->Instance == UART4)                              /* 如果是串口4 */
    
86.     {
    
87.         if((g_usart_rx_sta & 0x8000) == 0)                    /* 接收未完成 */
    
88.         {
    
89.             if(g_usart_rx_sta & 0x4000)                       /* 接收到了0x0d */
    5 e( n, h- ~# S# K$ R  p
90.             {
    " r: p! j* t2 j( w  e( v( |
91.                 if(g_rx_buffer[0] != 0x0a)
    1 n- J8 l: l. o, v  I3 I' a
92.                 {
    
93.                     g_usart_rx_sta = 0;                       /* 接收错误,重新开始 */
    
94.                 }
    
95.                 else
    
96.                 {
    
97.                     g_usart_rx_sta |= 0x8000;                 /* 接收完成了 */
    ) D/ l  O$ Z5 q# F
98.                 }
    3 Y5 g* y7 e1 S8 |7 V
99.             }
    
100.             else                                              /* 还没收到0X0D */
     & R. T4 k1 A- e' {" B7 V
101.             {
     
102.                 if(g_rx_buffer[0] == 0x0d)
     4 Q) h$ R! A1 D+ E" X4 e' f" x
103.                 {
     
104.                     g_usart_rx_sta |= 0x4000;
     
105.                 }
     : @# J7 k6 K1 y
106.                 else
     
107.                 {
     
108.                     g_usart_rx_buf[g_usart_rx_sta & 0X3FFF] = g_rx_buffer[0] ;
     ( N; C/ k1 b" l9 n$ J' J) I
109.                     g_usart_rx_sta++;
     
110.                     if(g_usart_rx_sta > (USART_REC_LEN - 1))
     
111.                     {
     
112.                         g_usart_rx_sta = 0;                   /* 接收数据错误,重新开始接收 */
     
113.                     }
     9 _: ~2 J" L; b
114.                 }
     
115.             }
     
116.         }
     
117.     }
     
118. }
     " \. T8 R2 C. u( B. u" t. m
119. 
     
120. /**
     
121. * @brief       串口4中断服务函数
     8 W. P# V6 D& Y: E$ b4 Y: r' N
122. * @param       无
     
123. * @retval      无
     
124. */
     2 p+ [5 H! z2 `/ v9 Z. D
125. void USART_UX_IRQHandler(void)
     
126. {
     8 p- H+ D3 P: N  w/ c, x
127.     uint32_t timeout = 0;
     
128.     uint32_t maxDelay = 0x1FFFF;
     
129. 
     
130.     HAL_UART_IRQHandler(&g_uart4_handle); /* 调用HAL库中断处理公用函数 */
     
131. 
     " X, G1 I2 Z0 u- a" s; i
132.     timeout = 0;
     
133.     while (HAL_UART_GetState(&g_uart4_handle) != HAL_UART_STATE_READY) /* 等待就绪 */
     2 E0 C4 M8 {  s; U
134.     {
     
135.         timeout++;                       /* 超时处理 */
     / P! I( R* K8 L+ m  s4 m- ^
136.         if(timeout > maxDelay)
     
137.         {
     
138.             break;
     3 b- k: u* G$ f1 W9 M" S* V% G+ Y
139.         }
     
140.     }
     
141.      
     / X" p# ^) @6 S1 D! L
142.     timeout=0;
     
143.    
     
144.     /* 一次处理完成之后，重新开启中断并设置RxXferCount为1 */
     . W# Y0 H7 v  i0 }7 E" \
145.     while (HAL_UART_Receive_IT(&g_uart4_handle, (uint8_t *)g_rx_buffer, RXBUFFERSIZE) != HAL_OK)
     
146.     {
     
147.         timeout++;                  /* 超时处理 */
     ) V" S" M8 c' }+ m9 ~4 c. J$ _* s  o
148.         if (timeout > maxDelay)
     
149.         {
     
150.             break;
     
151.         }
     
152.     }
     
153. 
     3 i* y( j1 ]& ~& W, O1 S
154. }

复制代码

main函数调用：

1. if (g_usart_rx_sta & 0x8000)        /* 接收到了数据 */
   
2.                 {
   
3.                                 len = g_usart_rx_sta & 0x3fff;  /* 得到此次接收到的数据长度 */
   8 ^! e  e0 U1 C( M5 r
4.                         printf("\r\nYou send message is: \r\n");
   
5.                                 for (t = 0; t < len; t++)
   7 V' o2 J+ |1 p( K
6.                                 {
   4 e5 B- u( d/ T$ w! N6 S3 p
7.                                                 USART_UX->TDR = g_usart_rx_buf[t];
   
8.                                                 while ((USART_UX->ISR & 0X40) == 0);  /* 等待发送结束 */
   
9.                                 }
   $ g  R5 @/ W( j* e' Y
10.                                 printf("\r\n\r\n"); /* 插入换行 */
    
11.                                 g_usart_rx_sta = 0;
    
12.                 }
    
13.                 else
    
14.                 {
    
15.                                 times++;
    
16.                                 if (times % 5000 == 0)
    0 Q* S( O- K6 c) A9 G9 z* f1 D
17.                                 {
    
18.                                                 printf("\r\nSTM32MP1_DK1 UART4 TEST!\r\n");
    
19.                                                 printf("JasonQiu@ST community \r\n\r\n\r\n");
    * o8 j1 S" l. R
20.                                 }
    
21.                                 if (times % 200 == 0) printf("Please putchar!\r\n");
    # J6 |, I+ V7 @: o) A6 ^7 g9 x# o
22.                                 if (times % 30  == 0)
    
23.                                 {
    * e/ h" P8 {+ T' P0 V7 r
24.                                         LED0_TOGGLE();
    
25.                                         printf("The led station is %d \r\n\r\n\r\n",LED0_STATION);
    
26.                                 }
    
27.                                 delay(10);
    7 U. C& B2 n9 o* J% w2 M# f
28.                 }

复制代码

编译无误后，此时我们需要修改MCU的BOOT MODE ：
我们选择从内部RAM启动的模式：


0 _* I3 W: g- ?7 V
MDK中，有几次配置要注意：
7 z3 A, J* }) B& P9 K* X  Q
2 d; C  G/ x" j  R! d3 r: Q


# ]" I/ }. z  J4 `5 y; G* n1 J1 w
: j3 h  ~, m( G) u2 U- n2 t
下载后直接运行，看下输出的状态：

板子LED状态：
7 k$ y+ d$ L1 N; ?( y
  Q' k7 ]$ u4 Y2 ~好了，M4核的裸机开发就到这了。
* t! G; `+ N* D- B; D