通过上篇文章对STM32MP1双核机制的分析。我们知道M4内核的程序，不能够下载到FLASH当中。那怎么调试M4的程序呢。下面我们就开始讲一讲。
3 F, k6 J; V/ q( `STM32MP1跟普通M4核MCU开发没有太大的区别，一样调用HAL库，一样可以通过CUBEMX工具生成
初始化代码。当然在能控制的外设方面比真正的M4单片机要少一些，上文已描述过。我们在这里就不多说了。
7 [' q* S) t# x1 f我们打开CUBEMX工具，选择对应型号，配置工程：
" m' L  i2 S7 G; B. j" `我们想控制板上一颗LED，并且串口能够收发数据。
LED引脚电路位置：
' Q. b1 W) V! w
与STLINK相连的调试串口UART4电路位置：



2 u' R" s. k; X  A: w: Z: `
! H5 h% Q8 X( p6 a$ [6 G6 W6 _6 [# ~+ xCUBEMX配置：



7 S. Z+ [* {/ F; o* U( `配置时钟：
4 r' U5 V* e4 D3 m% V. i
7 u5 c* i( b1 X6 |7 o6 ~- @
% A) k& ?4 o6 d# M( b( @1 E
  k! m8 z. h: S; c7 Q" J3 ]工程配置时，选择让每一个外设生成独立文件：

6 V( x. e  s: E# E# D! I然后生成代码，我们这里没有官方的STM32CUBEIDE开发，用MDK。
生成的代码，我们不直接用，仅作为参考。
; ]' ~. g$ m$ B" Q. B修改自己的led程序：
, R- e! l) c5 Z6 N; CC:

1. void led_init(void)
   % ]0 E9 m; |, t: f* S- N- i
2. {
   
3.     GPIO_InitTypeDef gpio_init_struct;
   
4.     LED0_GPIO_CLK_ENABLE(); /* LED0时钟使能 */
   
5. 
   
6. 
   
7.     gpio_init_struct.Pin = LED0_GPIO_PIN;                   /* LED0引脚 */
   
8.     gpio_init_struct.Mode = GPIO_MODE_OUTPUT_PP;            /* 推挽输出 */
   # D# ?. R8 U- @4 a! S3 i+ t4 v8 U* b
9.     gpio_init_struct.Pull = GPIO_PULLUP;                    /* 上拉 */
   0 K0 |3 B0 y1 k) m8 @
10.     gpio_init_struct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;     /* 高速 */
    
11.     HAL_GPIO_Init(LED0_GPIO_PORT, &gpio_init_struct);       /* 初始化LED0引脚 */
    ' k- r) P5 |; e: E* X6 u- l- w
12. 
    ( U. Q: Q7 G0 I6 V: S
13. 
    " \% ^, L9 p+ b/ V2 i" V' R
14.     LED0(0);    /* 关闭 LED0 */
    
15. 
    ( U& Y2 p0 B$ Q. P* `
16. }

复制代码

H:

1. #define LED0_GPIO_PORT                  GPIOE
   
2. #define LED0_GPIO_PIN                   GPIO_PIN_12
   8 ~- A" u1 l; D: J7 E; u' f4 y
3. #define LED0_GPIO_CLK_ENABLE()          do{ __HAL_RCC_GPIOE_CLK_ENABLE(); }while(0)   /* PE口时钟使能 */
   
4. 
   : [. Z" b9 z* R) z6 b; A
5. /******************************************************************************************/
   4 X& @7 r! W9 o. q! n! M' N
6. 
   
7. 
   % X% a5 g5 O: k' g0 L
8. /* LED端口定义 */
   
9. #define LED0(x)   do{ x ? \
   
10.                       HAL_GPIO_WritePin(LED0_GPIO_PORT, LED0_GPIO_PIN, GPIO_PIN_SET) : \
    1 \" q  G5 j  H4 h8 W
11.                       HAL_GPIO_WritePin(LED0_GPIO_PORT, LED0_GPIO_PIN, GPIO_PIN_RESET); \
    / v8 B1 S/ m2 @& I, B
12.                   }while(0)       /* LED0 = RED */
    0 Z2 `: i! a- J; H  J$ F( u4 r* s
13. 
    
14. /* LED取反定义 */
    7 K. `2 C" w9 H/ \3 L! g* `
15. #define LED0_TOGGLE()    do{ HAL_GPIO_TogglePin(LED0_GPIO_PORT, LED0_GPIO_PIN); }while(0)   /* LED0 = !LED0 */
    % }1 k6 l4 _" E" ^
16. 
    3 W4 F9 ~9 S- H, r
17. 
    
18. #define LED0_STATION     HAL_GPIO_ReadPin(LED0_GPIO_PORT, LED0_GPIO_PIN)
    / D8 R4 G: G8 r7 J+ ]& F
19. 
    2 ?# H7 _! V* G) k
20. void led_init(void);    /* 初始化 */

复制代码

UART4.C
主要处理都在接收回传函数里面，此接收函数一直参考正点原子。
# \5 D5 x0 y2 `- ^/ E  n6 q

1. * 接收缓冲, 最大USART_REC_LEN个字节. */
   
2. uint8_t g_usart_rx_buf[USART_REC_LEN];
   4 I9 [, {& U7 X& G
3. 
   
4. /*  接收状态
   
5. *  bit15，      接收完成标志
     D' T4 K( H3 |+ @% [# {
6. *  bit14，      接收到0x0d
   & m3 E1 P/ k0 S/ X
7. *  bit13~0，    接收到的有效字节数目
   
8. */
   
9. uint16_t g_usart_rx_sta = 0;
   
10. 
    $ O( z3 y" ^6 z
11. uint8_t g_rx_buffer[RXBUFFERSIZE];    /* HAL库使用的串口接收缓冲 */
    
12. 
    2 [2 k2 {9 R9 i# H- j# H
13. UART_HandleTypeDef g_uart4_handle;    /* UART句柄 */
    3 H8 c/ i& c# e1 C) W) p
14. 
    3 e8 y$ r, r- P
15. 
    
16. /**
    
17. * @brief       串口X初始化函数
    ( q; z% L7 ~% Z: d3 o
18. * @param       baudrate: 波特率, 根据自己需要设置波特率值
    
19. * @note        注意: 必须设置正确的时钟源, 否则串口波特率就会设置异常.
    
20. *              这里的USART的时钟源在sys_stm32_clock_init()函数中已经设置过了.
    
21. * @retval      无
    8 c. |4 Z% k' y, Y; s' n1 F& _
22. */
    6 _0 {$ [/ [/ A6 r, F
23. void usart_init(uint32_t baudrate)
    
24. {
    
25.     g_uart4_handle.Instance = USART_UX;                    /* USART4 */
    " T# U$ ?4 [" H
26.     g_uart4_handle.Init.BaudRate = baudrate;               /* 波特率 */
    
27.     g_uart4_handle.Init.WordLength = UART_WORDLENGTH_8B;   /* 字长为8位数据格式 */
    % ~: {0 J( t& e2 i6 Z9 `
28.     g_uart4_handle.Init.StopBits = UART_STOPBITS_1;        /* 一个停止位 */
    & `! \9 m* @9 ]! `. V! v
29.     g_uart4_handle.Init.Parity = UART_PARITY_NONE;         /* 无奇偶校验位 */
    
30.     g_uart4_handle.Init.HwFlowCtl = UART_HWCONTROL_NONE;   /* 无硬件流控 */
    7 j+ |" |% O4 T; K( s0 A
31.     g_uart4_handle.Init.Mode = UART_MODE_TX_RX;            /* 收发模式 */
    ; e: ?2 L3 j& s) I2 [7 E& K
32.     HAL_UART_Init(&g_uart4_handle);                        /* HAL_UART_Init()会使能UART4 */
    
33.    
    / R: d- }9 N& }9 M% c: \
34.     /* 该函数会开启接收中断：标志位UART_IT_RXNE，并且设置接收缓冲以及接收缓冲接收最大数据量 */
    ) F  l* h; R6 x
35.     HAL_UART_Receive_IT(&g_uart4_handle, (uint8_t *)g_rx_buffer, RXBUFFERSIZE);
    3 n2 Q6 T0 f& w/ t
36. }
    - S: _. Z% c' f! K+ C, E; }% w, f# H
37. 
    
38. /**
    % E8 D7 W' G8 p/ O, Q
39. * @brief       UART底层初始化函数
    1 l# I' n& N' o$ k( A
40. * @param       huart: UART句柄类型指针
    ( g! \# L9 }( E+ [$ \: _4 `7 p7 R3 h
41. * @note        此函数会被HAL_UART_Init()调用
    
42. *              完成时钟使能，引脚配置，中断配置
    
43. * @retval      无
    
44. */
    
45. void HAL_UART_MspInit(UART_HandleTypeDef *huart)
    
46. {
    
47.     GPIO_InitTypeDef gpio_init_struct;
    ) v* Q% d% e( D! B  k
48.         RCC_PeriphCLKInitTypeDef rcc_periphclk_init_struct;
    + a9 \% F, c, |) L% V2 Q
49.         
    ! H, t2 o! |8 Q. {0 z( c# ~2 a
50.     if(huart->Instance == UART4)                                   /* 如果是串口4，进行串口4 MSP初始化 */
    
51.     {
    
52.         USART_UX_CLK_ENABLE();                                      /* USART4时钟使能 */
    * g0 V: Z! Z! H: Q
53.         USART_TX_GPIO_CLK_ENABLE();                                 /* 发送引脚时钟使能 */
    
54.         USART_RX_GPIO_CLK_ENABLE();                                 /* 接收引脚时钟使能 */
    
55. 
    7 r# L* ^* y- W4 {2 f2 j- L
56.         gpio_init_struct.Pin = USART_TX_GPIO_PIN;                   /* 指定TX引脚 */
    
57.         gpio_init_struct.Mode = GPIO_MODE_AF_PP;                    /* 复用推挽输出 */
    ( R9 `& u: X7 ]0 W3 F0 b
58.         gpio_init_struct.Pull = GPIO_PULLUP;                        /* 上拉 */
    ; v" c- S8 P, {' }" e
59.         gpio_init_struct.Speed = GPIO_SPEED_FREQ_HIGH;              /* 高速 */
    
60.         gpio_init_struct.Alternate = USART_TX_GPIO_AF;              /* 复用为UART4 */
    
61.         HAL_GPIO_Init(USART_TX_GPIO_PORT, &gpio_init_struct);       /* 初始化发送引脚 */
    
62. 
    , `4 u  e. ^( g5 j1 m" c2 R/ n
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);       /* 初始化接收引脚 */
    
66.                
    
67.                 /* 设置UART4时钟源=PLL4Q=74.25MHz  */
    , P" a1 V! E+ o% `( e& ?/ A
68.                 rcc_periphclk_init_struct.Uart24ClockSelection = RCC_UART24CLKSOURCE_PLL4;
    
69.                 HAL_RCCEx_PeriphCLKConfig(&rcc_periphclk_init_struct);
    ! e+ _! f  H- S  b0 i) W+ y
70. 
    1 y$ W" H' ~+ @- c: n# b% h
71. #if USART_EN_RX
    # D6 Q- j( I/ q% J/ ^
72.         HAL_NVIC_EnableIRQ(USART_UX_IRQn);                          /* 使能USART4中断通道 */
    
73.         HAL_NVIC_SetPriority(USART_UX_IRQn, 3, 3);                  /* 抢占优先级3，子优先级3 */
    
74. #endif
    & O2 G4 f# u4 w# h/ O: f
75.     }
      `: E. x) s5 V7 k8 E9 ?0 H# q
76. }
    
77. 
    ' ~( ~# V5 Y+ B4 b& m
78. /**
    $ b# W# }' t/ u0 r, Y; {! j
79. * @brief       Rx传输回调函数
    
80. * @param       huart: UART4句柄类型指针
    7 V2 l5 X/ i8 g
81. * @retval      无
    
82. */
    
83. void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
    
84. {
    
85.     if(huart->Instance == UART4)                              /* 如果是串口4 */
    
86.     {
    0 a: v, M) ?( N5 |0 P, D0 r4 g, l
87.         if((g_usart_rx_sta & 0x8000) == 0)                    /* 接收未完成 */
    
88.         {
    
89.             if(g_usart_rx_sta & 0x4000)                       /* 接收到了0x0d */
    ; R2 y: t/ r3 U3 S0 `
90.             {
    
91.                 if(g_rx_buffer[0] != 0x0a)
    
92.                 {
    ! q* z, E8 m, r  L
93.                     g_usart_rx_sta = 0;                       /* 接收错误,重新开始 */
    + x- x* M8 D( u6 r
94.                 }
    
95.                 else
    
96.                 {
    9 d6 M0 h2 e) }" C5 c2 v* d
97.                     g_usart_rx_sta |= 0x8000;                 /* 接收完成了 */
    4 n, a+ @9 S$ c. B; R
98.                 }
    
99.             }
    
100.             else                                              /* 还没收到0X0D */
     ( G/ Y+ g/ q- q) _) T
101.             {
     
102.                 if(g_rx_buffer[0] == 0x0d)
     
103.                 {
     
104.                     g_usart_rx_sta |= 0x4000;
     1 I: I4 i7 q2 F$ q# d! h5 v
105.                 }
     2 k- A* l* _$ V
106.                 else
     - {6 i) Q8 P+ n7 Q0 G6 e
107.                 {
     
108.                     g_usart_rx_buf[g_usart_rx_sta & 0X3FFF] = g_rx_buffer[0] ;
     5 y4 k. n, a+ A8 X: I# Z
109.                     g_usart_rx_sta++;
     ! R& E3 v/ w) [. V, P$ X
110.                     if(g_usart_rx_sta > (USART_REC_LEN - 1))
     
111.                     {
     
112.                         g_usart_rx_sta = 0;                   /* 接收数据错误,重新开始接收 */
     
113.                     }
     
114.                 }
     2 a7 v% p8 _! W8 L
115.             }
     9 c/ i! C; A: ~3 v' S4 R
116.         }
     : B0 i, S4 X. O5 C
117.     }
     
118. }
     
119. 
     - L3 j* a; {: `$ O& l. I1 D
120. /**
     
121. * @brief       串口4中断服务函数
     
122. * @param       无
     ; M+ R* ^0 u- L( g1 a
123. * @retval      无
     
124. */
     9 D( C6 j% i  Z
125. void USART_UX_IRQHandler(void)
     & h/ \4 P, M1 }* p& l
126. {
     7 t8 v) t/ N- O; D0 R
127.     uint32_t timeout = 0;
     / h# G1 Z- ]; |+ ~8 q+ Y0 m6 c
128.     uint32_t maxDelay = 0x1FFFF;
     
129. 
     
130.     HAL_UART_IRQHandler(&g_uart4_handle); /* 调用HAL库中断处理公用函数 */
     
131. 
     3 h6 J. E) ]3 O) W
132.     timeout = 0;
     ! K0 R7 j% k, f  Z
133.     while (HAL_UART_GetState(&g_uart4_handle) != HAL_UART_STATE_READY) /* 等待就绪 */
     
134.     {
     2 z8 {& R: m9 n! J+ v2 Z
135.         timeout++;                       /* 超时处理 */
     
136.         if(timeout > maxDelay)
     0 ]2 O% v- W3 |+ M# h3 l4 [& U# h
137.         {
     
138.             break;
     % g: {. V/ h9 X5 E  p
139.         }
     8 `; D- d# `8 ?; n- H8 |- D" u
140.     }
     
141.      
     
142.     timeout=0;
     
143.    
     
144.     /* 一次处理完成之后，重新开启中断并设置RxXferCount为1 */
     
145.     while (HAL_UART_Receive_IT(&g_uart4_handle, (uint8_t *)g_rx_buffer, RXBUFFERSIZE) != HAL_OK)
     - y6 o$ ^$ b/ s, d- y. y) l- h
146.     {
     0 k, ]$ {8 \2 O% _, U% F; O
147.         timeout++;                  /* 超时处理 */
     5 ?  y% B! n( y9 N6 ?7 \
148.         if (timeout > maxDelay)
     
149.         {
     
150.             break;
     
151.         }
     ( x4 |. V7 n: m( V1 }
152.     }
     ) X/ n5 I; w4 w+ l1 E+ C3 N
153. 
     
154. }

复制代码

main函数调用：
" v1 \, {% ?8 M2 @6 A6 `

1. if (g_usart_rx_sta & 0x8000)        /* 接收到了数据 */
   . p$ {; N3 D" q7 @
2.                 {
   
3.                                 len = g_usart_rx_sta & 0x3fff;  /* 得到此次接收到的数据长度 */
   
4.                         printf("\r\nYou send message is: \r\n");
   4 R! m) f; _! K* s. v2 s
5.                                 for (t = 0; t < len; t++)
   
6.                                 {
   
7.                                                 USART_UX->TDR = g_usart_rx_buf[t];
   4 O0 F' k" N& j' R% a
8.                                                 while ((USART_UX->ISR & 0X40) == 0);  /* 等待发送结束 */
   7 C. ?; f( k' {5 p
9.                                 }
   
10.                                 printf("\r\n\r\n"); /* 插入换行 */
    * i, j/ L# c! A$ z' n1 y
11.                                 g_usart_rx_sta = 0;
    
12.                 }
    
13.                 else
    
14.                 {
    , w. @4 n* u9 h
15.                                 times++;
      L% b! h1 {* Z0 S
16.                                 if (times % 5000 == 0)
    9 Q/ s' b+ |( C+ a7 S
17.                                 {
    
18.                                                 printf("\r\nSTM32MP1_DK1 UART4 TEST!\r\n");
    
19.                                                 printf("JasonQiu@ST community \r\n\r\n\r\n");
    
20.                                 }
    
21.                                 if (times % 200 == 0) printf("Please putchar!\r\n");
    1 [/ P8 j! X. Z; S
22.                                 if (times % 30  == 0)
    
23.                                 {
    $ n6 Z1 Z6 v4 b: G5 Q+ N0 J5 {
24.                                         LED0_TOGGLE();
    
25.                                         printf("The led station is %d \r\n\r\n\r\n",LED0_STATION);
    
26.                                 }
    
27.                                 delay(10);
    
28.                 }

复制代码

编译无误后，此时我们需要修改MCU的BOOT MODE ：
我们选择从内部RAM启动的模式：
3 q/ [/ t; d+ o& K+ w
( |# l  J  J* r/ P

9 s. u) i; `( a* P% `" wMDK中，有几次配置要注意：
8 G, ^( v; B5 _6 ^0 T3 S
8 Z, R( U& d6 g) U6 P  _$ h6 S
! `% t9 a) J; O8 H  D* o. Z

9 [( p. _2 H  z- x, D' C) I" y" ?+ G
% r/ |6 C+ S7 ^) Q  Z
% N* E4 R. M& w  _下载后直接运行，看下输出的状态：
1 V# ~) J; x- M3 m, O
板子LED状态：
( W( L; L! V6 k+ ?8 a
好了，M4核的裸机开发就到这了。
9 @8 \/ C& m/ M# M" ]" e