通过上篇文章对STM32MP1双核机制的分析。我们知道M4内核的程序，不能够下载到FLASH当中。那怎么调试M4的程序呢。下面我们就开始讲一讲。
STM32MP1跟普通M4核MCU开发没有太大的区别，一样调用HAL库，一样可以通过CUBEMX工具生成
初始化代码。当然在能控制的外设方面比真正的M4单片机要少一些，上文已描述过。我们在这里就不多说了。
我们打开CUBEMX工具，选择对应型号，配置工程：
$ |+ s* h0 U8 P  Q3 r$ \  o我们想控制板上一颗LED，并且串口能够收发数据。
" }: n) h, C! i* |  p8 @  s& SLED引脚电路位置：
9 C7 U" ]  c( P3 F& k4 E: A0 X. q
5 j8 y- [  {- D3 @" v2 g1 |( D与STLINK相连的调试串口UART4电路位置：
- n% w, O+ S# M0 w3 H# c3 N
9 B( d& H% z% M3 u) Z# n' \* ~


6 p" u# s: Q) |8 a: ]! f" DCUBEMX配置：
6 M  f0 P+ N9 L# [- W


3 m& O- ^: m2 E' G配置时钟：

" k2 v$ ~, {" o; A
* M; [; s1 U" e7 k  r, u2 M
7 y) b( ]9 O# R/ @" Z% @! |+ \工程配置时，选择让每一个外设生成独立文件：
2 w+ J( J1 t4 _/ a6 t' A. d
4 `3 h' N/ w: l! w- e然后生成代码，我们这里没有官方的STM32CUBEIDE开发，用MDK。
生成的代码，我们不直接用，仅作为参考。
修改自己的led程序：
3 s7 T) N* O% k- ]$ ZC:
' e( n: c# }" X

1. void led_init(void)
   
2. {
   
3.     GPIO_InitTypeDef gpio_init_struct;
   
4.     LED0_GPIO_CLK_ENABLE(); /* LED0时钟使能 */
   2 |7 O: C2 u5 i; u% w" k
5. 
   0 d! h$ b* C: s  _# w. d0 o, j4 [
6. 
   $ E, U! g* C  H& A2 R. j
7.     gpio_init_struct.Pin = LED0_GPIO_PIN;                   /* LED0引脚 */
   * t) X/ A- C* \& j5 x9 N
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;     /* 高速 */
    % u8 A2 f9 p- M5 U+ h  L  c
11.     HAL_GPIO_Init(LED0_GPIO_PORT, &gpio_init_struct);       /* 初始化LED0引脚 */
    
12. 
    , b" Q2 M3 A& @5 F3 I
13. 
    ' |/ E. ~' h4 n% D% z* k* e
14.     LED0(0);    /* 关闭 LED0 */
    ) E: \/ b0 j* p+ J) X
15. 
    3 g, S, U0 `3 f+ E6 e7 t' q
16. }

复制代码

H:

1. #define LED0_GPIO_PORT                  GPIOE
   
2. #define LED0_GPIO_PIN                   GPIO_PIN_12
   ) P, [/ e( K. Z# u+ `
3. #define LED0_GPIO_CLK_ENABLE()          do{ __HAL_RCC_GPIOE_CLK_ENABLE(); }while(0)   /* PE口时钟使能 */
   
4. 
   9 O3 A# j8 H. l2 k  O
5. /******************************************************************************************/
   
6. 
   * a! Y2 M+ l; u" r$ g; E, }2 B
7. 
   
8. /* LED端口定义 */
   # d/ v& \$ z9 q7 p
9. #define LED0(x)   do{ x ? \
   
10.                       HAL_GPIO_WritePin(LED0_GPIO_PORT, LED0_GPIO_PIN, GPIO_PIN_SET) : \
    
11.                       HAL_GPIO_WritePin(LED0_GPIO_PORT, LED0_GPIO_PIN, GPIO_PIN_RESET); \
    
12.                   }while(0)       /* LED0 = RED */
    2 m4 c/ t: ?3 T, J3 X3 K
13. 
    
14. /* LED取反定义 */
    
15. #define LED0_TOGGLE()    do{ HAL_GPIO_TogglePin(LED0_GPIO_PORT, LED0_GPIO_PIN); }while(0)   /* LED0 = !LED0 */
    + x# F* b# N& Y  {$ x" O
16. 
    1 T- u3 s6 c$ k; b" X$ j4 c9 L" b
17. 
    
18. #define LED0_STATION     HAL_GPIO_ReadPin(LED0_GPIO_PORT, LED0_GPIO_PIN)
    ( N- p  R! J# w& H# `4 u) M3 e
19. 
    . N" X4 H$ P4 a% [$ m7 w# b* r' t
20. void led_init(void);    /* 初始化 */

复制代码

UART4.C
主要处理都在接收回传函数里面，此接收函数一直参考正点原子。
1 B+ O$ s, n+ b' |& w$ Q& A/ z

1. * 接收缓冲, 最大USART_REC_LEN个字节. */
   2 R3 R- _- t( r
2. uint8_t g_usart_rx_buf[USART_REC_LEN];
   . ?; U& M. W/ ^: ^, Z9 f! g
3. 
   . T2 S* q. W6 \5 \  D7 Q, G
4. /*  接收状态
   
5. *  bit15，      接收完成标志
   
6. *  bit14，      接收到0x0d
   % D3 ^& ]* D: V; @: G6 f* H: {! h5 a
7. *  bit13~0，    接收到的有效字节数目
   - M" S) Q& C" |, W  u
8. */
   
9. uint16_t g_usart_rx_sta = 0;
   " g5 b& ?. M3 x0 ?* ]& |; `
10. 
    , R# X2 j7 {* n$ @) c. X0 `' l
11. uint8_t g_rx_buffer[RXBUFFERSIZE];    /* HAL库使用的串口接收缓冲 */
      n) Y% Q' x) b7 @0 C+ `6 i7 s+ E, ~
12. 
    1 j5 w- Y5 x* K/ \
13. UART_HandleTypeDef g_uart4_handle;    /* UART句柄 */
    % V! r# p1 U* F
14. 
    
15. 
    " G  w/ W7 q5 L7 c
16. /**
    : G. m& Z; {9 r9 w; l% p
17. * @brief       串口X初始化函数
    . B3 S% E: {2 c
18. * @param       baudrate: 波特率, 根据自己需要设置波特率值
    0 l. @: j& o3 i8 o0 z) U2 z
19. * @note        注意: 必须设置正确的时钟源, 否则串口波特率就会设置异常.
    ; Y% `% V$ x% c2 t! S5 H
20. *              这里的USART的时钟源在sys_stm32_clock_init()函数中已经设置过了.
    9 H  T! v3 A. N1 P& p0 ]" J
21. * @retval      无
    
22. */
    
23. void usart_init(uint32_t baudrate)
    2 I# M* m; i7 m# w! `
24. {
    : J, {" E- W: U5 N: F  x2 G: v- {
25.     g_uart4_handle.Instance = USART_UX;                    /* USART4 */
    
26.     g_uart4_handle.Init.BaudRate = baudrate;               /* 波特率 */
    
27.     g_uart4_handle.Init.WordLength = UART_WORDLENGTH_8B;   /* 字长为8位数据格式 */
    * @3 {9 l6 [: I' _/ x: n; E0 P
28.     g_uart4_handle.Init.StopBits = UART_STOPBITS_1;        /* 一个停止位 */
    2 ?" M" ~0 b; @8 e5 _6 Z
29.     g_uart4_handle.Init.Parity = UART_PARITY_NONE;         /* 无奇偶校验位 */
    , t: e% y$ }; E4 e6 }9 g$ N
30.     g_uart4_handle.Init.HwFlowCtl = UART_HWCONTROL_NONE;   /* 无硬件流控 */
    
31.     g_uart4_handle.Init.Mode = UART_MODE_TX_RX;            /* 收发模式 */
    / x- ~% k! ]4 O/ q7 Z$ r
32.     HAL_UART_Init(&g_uart4_handle);                        /* HAL_UART_Init()会使能UART4 */
    7 D1 j3 K8 G( y2 M5 [: N
33.    
    9 ]( I+ e5 L$ w+ C  S9 G5 _" N/ e
34.     /* 该函数会开启接收中断：标志位UART_IT_RXNE，并且设置接收缓冲以及接收缓冲接收最大数据量 */
    ) L& T3 W" W5 c) e) L6 z6 r
35.     HAL_UART_Receive_IT(&g_uart4_handle, (uint8_t *)g_rx_buffer, RXBUFFERSIZE);
    # }( G" M1 `/ }% {
36. }
    
37. 
      E, J* s' _/ j: {/ p
38. /**
    7 I; |; y9 u/ L9 {2 _0 A3 |( R8 n
39. * @brief       UART底层初始化函数
    
40. * @param       huart: UART句柄类型指针
    * Y  A3 x' P  r% k5 t0 N2 S
41. * @note        此函数会被HAL_UART_Init()调用
    
42. *              完成时钟使能，引脚配置，中断配置
    
43. * @retval      无
    
44. */
    3 `8 c1 Q, `0 {* `% R! [' M* O* u
45. void HAL_UART_MspInit(UART_HandleTypeDef *huart)
    
46. {
    & i) B! M. X3 \% ~: H, N
47.     GPIO_InitTypeDef gpio_init_struct;
    + v8 ]5 k5 W( u7 c
48.         RCC_PeriphCLKInitTypeDef rcc_periphclk_init_struct;
    
49.         
    
50.     if(huart->Instance == UART4)                                   /* 如果是串口4，进行串口4 MSP初始化 */
    9 s! `0 U2 |: R" ~9 Z
51.     {
    
52.         USART_UX_CLK_ENABLE();                                      /* USART4时钟使能 */
    ( T3 C1 h7 h; r" J# c+ h) U
53.         USART_TX_GPIO_CLK_ENABLE();                                 /* 发送引脚时钟使能 */
    
54.         USART_RX_GPIO_CLK_ENABLE();                                 /* 接收引脚时钟使能 */
    
55. 
    ) }3 ?3 x1 p7 I4 n
56.         gpio_init_struct.Pin = USART_TX_GPIO_PIN;                   /* 指定TX引脚 */
    
57.         gpio_init_struct.Mode = GPIO_MODE_AF_PP;                    /* 复用推挽输出 */
    
58.         gpio_init_struct.Pull = GPIO_PULLUP;                        /* 上拉 */
    ( B) P& o3 s, [4 n
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);       /* 初始化发送引脚 */
    + m( B/ i/ F' C  l/ \
62. 
    3 K/ ~8 r; ?  P# G
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  */
    
68.                 rcc_periphclk_init_struct.Uart24ClockSelection = RCC_UART24CLKSOURCE_PLL4;
    / I# X$ `% W- p7 [
69.                 HAL_RCCEx_PeriphCLKConfig(&rcc_periphclk_init_struct);
    
70. 
    5 U5 V6 V" E7 s8 N
71. #if USART_EN_RX
    6 x" e) }' |0 F
72.         HAL_NVIC_EnableIRQ(USART_UX_IRQn);                          /* 使能USART4中断通道 */
      X+ U1 }( U* w4 Y$ v& p; |
73.         HAL_NVIC_SetPriority(USART_UX_IRQn, 3, 3);                  /* 抢占优先级3，子优先级3 */
    
74. #endif
    ; D7 n6 |4 x/ |% C
75.     }
    
76. }
    3 i, A) p- l5 p" T/ ]
77. 
    $ R0 |% Y  l, N% n9 D5 ?* p3 o9 ]! x
78. /**
    4 b& k1 }! [' {1 S' i0 N( O
79. * @brief       Rx传输回调函数
    
80. * @param       huart: UART4句柄类型指针
    
81. * @retval      无
    ( m6 Y; T& e+ y' G; R
82. */
    3 F4 `+ Z* S0 L, S- r
83. void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
    
84. {
    
85.     if(huart->Instance == UART4)                              /* 如果是串口4 */
    
86.     {
    2 \! o, d7 l2 J6 ~5 X3 ~
87.         if((g_usart_rx_sta & 0x8000) == 0)                    /* 接收未完成 */
    
88.         {
    & \- U$ f7 w. @% p6 @4 Q) r( S
89.             if(g_usart_rx_sta & 0x4000)                       /* 接收到了0x0d */
    * {4 `9 C& j1 A, f
90.             {
    * H" D' R  l! G7 r# o5 B
91.                 if(g_rx_buffer[0] != 0x0a)
    + W; s; e! f& x
92.                 {
    
93.                     g_usart_rx_sta = 0;                       /* 接收错误,重新开始 */
    3 [$ D& l1 e- L
94.                 }
      A8 G; d8 F5 }/ s: E& ~9 }3 r5 X
95.                 else
    
96.                 {
      M! _. B( Q1 d3 K6 o" R/ {1 b
97.                     g_usart_rx_sta |= 0x8000;                 /* 接收完成了 */
    % C+ f/ w, J) k) s" U0 B# V( \5 R
98.                 }
    
99.             }
    $ P5 M4 S3 l- k8 m8 L
100.             else                                              /* 还没收到0X0D */
     
101.             {
     ! b; m, N, l% {" _; A5 ~
102.                 if(g_rx_buffer[0] == 0x0d)
     
103.                 {
     , D( n: v% D; U6 b. @+ a
104.                     g_usart_rx_sta |= 0x4000;
     ; O% g' P3 k& b- Z$ U. I& v4 Z& W" C
105.                 }
     8 I* N( c; d0 m; w) R
106.                 else
     * u, _% L3 q" I" n
107.                 {
     $ i( |8 c9 n2 a+ x
108.                     g_usart_rx_buf[g_usart_rx_sta & 0X3FFF] = g_rx_buffer[0] ;
     5 n5 Q2 R2 y# O
109.                     g_usart_rx_sta++;
     
110.                     if(g_usart_rx_sta > (USART_REC_LEN - 1))
     
111.                     {
     
112.                         g_usart_rx_sta = 0;                   /* 接收数据错误,重新开始接收 */
     
113.                     }
     
114.                 }
     8 H- A) U' ^; \2 J2 t; [" J
115.             }
     
116.         }
     $ G8 g4 L3 C; u7 v4 H
117.     }
     8 R9 W! e! A9 f8 m: Y
118. }
     . d# o( z4 k$ N) I. B6 f
119. 
     ! o3 Y! `9 S* y" P! Y1 x, r
120. /**
     
121. * @brief       串口4中断服务函数
     ( L; s$ ]6 @% P# T5 ]
122. * @param       无
     : \9 b8 _6 I1 j% E) r) J$ X
123. * @retval      无
     ! c  i$ r( X3 E8 {) h3 n; T
124. */
     5 r& t  h$ c$ p  J& y7 h
125. void USART_UX_IRQHandler(void)
     
126. {
     / K- W' Q4 P1 T& V7 w  c6 F. P
127.     uint32_t timeout = 0;
     
128.     uint32_t maxDelay = 0x1FFFF;
     1 u- g/ c5 O. [
129. 
     
130.     HAL_UART_IRQHandler(&g_uart4_handle); /* 调用HAL库中断处理公用函数 */
     
131. 
     
132.     timeout = 0;
     6 p* Y+ R/ @8 I2 X, O5 Z, @
133.     while (HAL_UART_GetState(&g_uart4_handle) != HAL_UART_STATE_READY) /* 等待就绪 */
     
134.     {
       i; W% K; X& ~  ]: r9 g
135.         timeout++;                       /* 超时处理 */
     ; M2 ^( C  i3 X1 h0 t6 g0 U
136.         if(timeout > maxDelay)
     
137.         {
     2 u$ m+ }" L$ P0 @( c$ K: x
138.             break;
     ( M' Q3 U: }4 }3 P5 H" N. r$ m
139.         }
     
140.     }
     
141.      
     9 P* M5 H; W; w! {: Q
142.     timeout=0;
     
143.    
     
144.     /* 一次处理完成之后，重新开启中断并设置RxXferCount为1 */
     
145.     while (HAL_UART_Receive_IT(&g_uart4_handle, (uint8_t *)g_rx_buffer, RXBUFFERSIZE) != HAL_OK)
     ! `' x$ D$ I# N6 U" Y( V6 W
146.     {
     
147.         timeout++;                  /* 超时处理 */
     # x$ J& J( T. ^1 u
148.         if (timeout > maxDelay)
     
149.         {
     
150.             break;
     $ g7 E2 V  K4 T
151.         }
     
152.     }
     3 [* B( E1 Z; r2 V/ C" R
153. 
     
154. }

复制代码

main函数调用：

1. if (g_usart_rx_sta & 0x8000)        /* 接收到了数据 */
   
2.                 {
   8 y; ?# N5 {0 K- u* p) Q/ l' E: T
3.                                 len = g_usart_rx_sta & 0x3fff;  /* 得到此次接收到的数据长度 */
   3 Z4 e6 j9 Z# h* q$ n- t' r5 F- g
4.                         printf("\r\nYou send message is: \r\n");
   
5.                                 for (t = 0; t < len; t++)
   8 V( C& J. W3 b- U2 [2 C2 |  q
6.                                 {
   
7.                                                 USART_UX->TDR = g_usart_rx_buf[t];
   
8.                                                 while ((USART_UX->ISR & 0X40) == 0);  /* 等待发送结束 */
   
9.                                 }
   
10.                                 printf("\r\n\r\n"); /* 插入换行 */
    # s9 t2 H! Q" N7 m. e4 O% h
11.                                 g_usart_rx_sta = 0;
    + U! U8 Z" a4 d- h- I. ]. L) z
12.                 }
    
13.                 else
    
14.                 {
    
15.                                 times++;
      w7 q* H7 A% [' Z3 a
16.                                 if (times % 5000 == 0)
    & ~" b4 N# f3 A- d( f" k7 e
17.                                 {
    
18.                                                 printf("\r\nSTM32MP1_DK1 UART4 TEST!\r\n");
    . J$ R2 j' g* R7 g: i7 i0 |6 H
19.                                                 printf("JasonQiu@ST community \r\n\r\n\r\n");
    : a7 g. o$ l9 m! _  k
20.                                 }
    $ H1 e; ]" o) D8 y/ X" a4 I
21.                                 if (times % 200 == 0) printf("Please putchar!\r\n");
    
22.                                 if (times % 30  == 0)
    
23.                                 {
    : N! p5 O# x# y" }- e7 _$ u7 k
24.                                         LED0_TOGGLE();
    
25.                                         printf("The led station is %d \r\n\r\n\r\n",LED0_STATION);
    & }) o- ?& s# }: o: {# O( z; P
26.                                 }
    
27.                                 delay(10);
    ( h, i. o8 M. w0 s
28.                 }

复制代码

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

4 L& J, Z: r3 C7 X2 X5 t+ B% B+ ^& B
- P5 V7 d+ v5 }( U: V& z5 U& P
3 h5 ~& g2 a: J* O2 |* {/ pMDK中，有几次配置要注意：
3 Y/ g1 o$ |  h- ^/ A) A2 H) @& C




! `& Q6 b, S: S8 \* D, K9 ?3 d
0 ]: p7 h. o& V6 l! k: B下载后直接运行，看下输出的状态：

板子LED状态：
6 Y9 }4 t' |6 Q5 s9 i
好了，M4核的裸机开发就到这了。
# `" H& m* N, O% j/ K