通过上篇文章对STM32MP1双核机制的分析。我们知道M4内核的程序，不能够下载到FLASH当中。那怎么调试M4的程序呢。下面我们就开始讲一讲。
6 j" U9 i' R* ~1 ~3 U2 S# u* lSTM32MP1跟普通M4核MCU开发没有太大的区别，一样调用HAL库，一样可以通过CUBEMX工具生成
初始化代码。当然在能控制的外设方面比真正的M4单片机要少一些，上文已描述过。我们在这里就不多说了。
我们打开CUBEMX工具，选择对应型号，配置工程：
( |/ f" s3 `) d! \8 U3 _' l/ R我们想控制板上一颗LED，并且串口能够收发数据。
LED引脚电路位置：
* c& Y0 Y4 u. j: s2 E6 s
与STLINK相连的调试串口UART4电路位置：
: d% [8 v' s5 n: c' v: x8 U


+ j- s+ O# \( H) a% U$ o  a
CUBEMX配置：



9 t4 J) j8 p9 q1 i0 W7 [  P/ P配置时钟：
4 ?, H6 S% Y, I# A7 g

, T0 I6 S5 a- B3 ~7 v2 D0 y. j% w
工程配置时，选择让每一个外设生成独立文件：
, q" ~  T/ m& a5 Q. k
5 P# H: R, g- a; T然后生成代码，我们这里没有官方的STM32CUBEIDE开发，用MDK。
% D  q, k% Q; o; q. x2 J生成的代码，我们不直接用，仅作为参考。
& q7 Q* C+ u2 X7 M修改自己的led程序：
C:
* z/ k7 Z0 G( O- j9 w! [+ f" q/ l8 I" O

1. void led_init(void)
   8 x6 n; ?, F1 H+ H8 j, S3 A
2. {
   
3.     GPIO_InitTypeDef gpio_init_struct;
   
4.     LED0_GPIO_CLK_ENABLE(); /* LED0时钟使能 */
   
5. 
   
6. 
   
7.     gpio_init_struct.Pin = LED0_GPIO_PIN;                   /* LED0引脚 */
   & t, h# g. x) c0 o6 B% _$ |
8.     gpio_init_struct.Mode = GPIO_MODE_OUTPUT_PP;            /* 推挽输出 */
   ! _6 V* k3 d0 ]* h0 U8 l8 z# z2 L6 V& q
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. 
    ! q( I7 J" A9 S( z$ _5 w" L
13. 
    
14.     LED0(0);    /* 关闭 LED0 */
    
15. 
    / |4 ^' o" ]( g. N4 l8 b* j
16. }

复制代码

H:

1. #define LED0_GPIO_PORT                  GPIOE
   , K+ m0 T4 p, ~5 [7 N1 c
2. #define LED0_GPIO_PIN                   GPIO_PIN_12
   9 I( H' V6 g/ r8 E
3. #define LED0_GPIO_CLK_ENABLE()          do{ __HAL_RCC_GPIOE_CLK_ENABLE(); }while(0)   /* PE口时钟使能 */
   
4. 
   
5. /******************************************************************************************/
   
6. 
   7 J' J& p5 H0 G. \0 u
7. 
   6 L5 j! A6 V1 w+ O; Y6 A! f5 M
8. /* LED端口定义 */
   % ^$ O$ X( A1 u  q' S! i
9. #define LED0(x)   do{ x ? \
   
10.                       HAL_GPIO_WritePin(LED0_GPIO_PORT, LED0_GPIO_PIN, GPIO_PIN_SET) : \
    + N! X5 L. S' c& C" p
11.                       HAL_GPIO_WritePin(LED0_GPIO_PORT, LED0_GPIO_PIN, GPIO_PIN_RESET); \
    : ^7 i% a; f1 ~; [1 _
12.                   }while(0)       /* LED0 = RED */
    0 \- G* r( {5 |0 y& X6 j/ ~: X
13. 
    
14. /* LED取反定义 */
    9 i  a+ A6 ]: H- R+ Z- y
15. #define LED0_TOGGLE()    do{ HAL_GPIO_TogglePin(LED0_GPIO_PORT, LED0_GPIO_PIN); }while(0)   /* LED0 = !LED0 */
    - j% ^) [; J- C0 x
16. 
    ; q0 ^0 ~1 E; Q4 S( b8 P! P
17. 
    
18. #define LED0_STATION     HAL_GPIO_ReadPin(LED0_GPIO_PORT, LED0_GPIO_PIN)
    0 k6 _! l) J9 c* @& C: {, f$ X3 W
19. 
    : @/ c2 a% E$ [7 k6 V8 Q/ m' N2 v
20. void led_init(void);    /* 初始化 */

复制代码

UART4.C
主要处理都在接收回传函数里面，此接收函数一直参考正点原子。
; t$ n  K/ ]: m$ L0 ]

1. * 接收缓冲, 最大USART_REC_LEN个字节. */
   2 a( X4 L! |9 q! x4 `2 P2 b( Z
2. uint8_t g_usart_rx_buf[USART_REC_LEN];
   / q& t5 T: X5 U& C& ^
3. 
   , t% k3 q$ U5 t6 R* Q  s; L
4. /*  接收状态
   : ~) _1 S5 q# Y0 u& c
5. *  bit15，      接收完成标志
   7 n* F2 T, z0 G& e3 a
6. *  bit14，      接收到0x0d
   
7. *  bit13~0，    接收到的有效字节数目
   
8. */
   1 e2 P+ B2 ?# ^& [* R8 q
9. uint16_t g_usart_rx_sta = 0;
   / C9 ?9 Q2 O/ o: @: L# p! M
10. 
    
11. uint8_t g_rx_buffer[RXBUFFERSIZE];    /* HAL库使用的串口接收缓冲 */
    
12. 
    
13. UART_HandleTypeDef g_uart4_handle;    /* UART句柄 */
    
14. 
    " q; }1 g: S) z4 I5 U6 k3 c4 F( r+ G
15. 
    
16. /**
    
17. * @brief       串口X初始化函数
    
18. * @param       baudrate: 波特率, 根据自己需要设置波特率值
    4 b2 U9 v7 A" z. s3 K, f- |9 I7 I
19. * @note        注意: 必须设置正确的时钟源, 否则串口波特率就会设置异常.
    
20. *              这里的USART的时钟源在sys_stm32_clock_init()函数中已经设置过了.
    
21. * @retval      无
    1 I* r  p1 ?: {+ s
22. */
    
23. void usart_init(uint32_t baudrate)
    
24. {
    & x$ j( d# z! |# P; g
25.     g_uart4_handle.Instance = USART_UX;                    /* USART4 */
    
26.     g_uart4_handle.Init.BaudRate = baudrate;               /* 波特率 */
    ( v7 H5 c4 j& y4 d. R9 u
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;   /* 无硬件流控 */
    4 G& E& f' D3 B
31.     g_uart4_handle.Init.Mode = UART_MODE_TX_RX;            /* 收发模式 */
    
32.     HAL_UART_Init(&g_uart4_handle);                        /* HAL_UART_Init()会使能UART4 */
    
33.    
    7 m7 c# {. @2 ~8 z- C
34.     /* 该函数会开启接收中断：标志位UART_IT_RXNE，并且设置接收缓冲以及接收缓冲接收最大数据量 */
    & j6 N% i; G" `: e
35.     HAL_UART_Receive_IT(&g_uart4_handle, (uint8_t *)g_rx_buffer, RXBUFFERSIZE);
    4 Y  m+ j" z+ p5 ?0 c2 v
36. }
    * `  o: B1 d; r! s8 M+ ]
37. 
    5 D4 V2 O* \* w2 o/ `
38. /**
    0 x+ Y' y3 ~9 z( d* j2 J3 q! D- \
39. * @brief       UART底层初始化函数
    3 q. i$ s+ x; r
40. * @param       huart: UART句柄类型指针
    " \% H0 U/ Z3 u* d
41. * @note        此函数会被HAL_UART_Init()调用
    
42. *              完成时钟使能，引脚配置，中断配置
    
43. * @retval      无
    
44. */
    % v# Z7 `' s+ u
45. void HAL_UART_MspInit(UART_HandleTypeDef *huart)
    - v# h) B2 V  s7 Z* h' D' ]4 q0 E
46. {
    
47.     GPIO_InitTypeDef gpio_init_struct;
    
48.         RCC_PeriphCLKInitTypeDef rcc_periphclk_init_struct;
    
49.         
    # K/ f8 ?5 `3 B7 W# W
50.     if(huart->Instance == UART4)                                   /* 如果是串口4，进行串口4 MSP初始化 */
    4 G- o2 O2 q6 w6 C2 m9 C0 a8 }
51.     {
    6 C; Y3 I) k/ Z( A. n5 H: b
52.         USART_UX_CLK_ENABLE();                                      /* USART4时钟使能 */
    
53.         USART_TX_GPIO_CLK_ENABLE();                                 /* 发送引脚时钟使能 */
    
54.         USART_RX_GPIO_CLK_ENABLE();                                 /* 接收引脚时钟使能 */
    $ Z, M7 I4 W) s4 x& Y( q' k$ f
55. 
    8 O9 Q7 j) A1 e! Y' Z* v' g& P
56.         gpio_init_struct.Pin = USART_TX_GPIO_PIN;                   /* 指定TX引脚 */
    & g- H) i* p% {+ ]
57.         gpio_init_struct.Mode = GPIO_MODE_AF_PP;                    /* 复用推挽输出 */
    
58.         gpio_init_struct.Pull = GPIO_PULLUP;                        /* 上拉 */
    & k: O6 v1 Y7 D
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. 
    
63.         gpio_init_struct.Pin = USART_RX_GPIO_PIN;                   /* 指定RX引脚 */
    
64.         gpio_init_struct.Alternate = USART_RX_GPIO_AF;              /* 复用为UART4 */
    " e7 o9 U7 z) E9 u4 U0 r
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;
    # ?; t  [* L- C9 p" K0 v9 m0 n1 B) Q
69.                 HAL_RCCEx_PeriphCLKConfig(&rcc_periphclk_init_struct);
    $ m' [0 t3 |; P  Z2 S3 f# o' J
70. 
    
71. #if USART_EN_RX
    
72.         HAL_NVIC_EnableIRQ(USART_UX_IRQn);                          /* 使能USART4中断通道 */
    1 x% e6 w. D' y" @8 B  ]3 \
73.         HAL_NVIC_SetPriority(USART_UX_IRQn, 3, 3);                  /* 抢占优先级3，子优先级3 */
    
74. #endif
    
75.     }
    
76. }
    * D1 Q. t8 i+ M
77. 
    
78. /**
    
79. * @brief       Rx传输回调函数
    - K" |( D5 ^5 T4 m8 o
80. * @param       huart: UART4句柄类型指针
    , r0 N2 W2 L4 C1 ?( U& D" K2 g: ~9 x
81. * @retval      无
    
82. */
    
83. void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
    ( S# u! X( U  j
84. {
    7 f% u3 O) m/ {( v, z+ Z% k) @! k# ^2 T
85.     if(huart->Instance == UART4)                              /* 如果是串口4 */
    
86.     {
    " K6 g+ a2 J- k1 [+ t
87.         if((g_usart_rx_sta & 0x8000) == 0)                    /* 接收未完成 */
    0 s2 f# N5 \% a5 c9 A6 z7 B
88.         {
    : ?+ H4 A  I  @' C
89.             if(g_usart_rx_sta & 0x4000)                       /* 接收到了0x0d */
    ! t1 C2 b. _  F7 |
90.             {
    3 C( [+ h. w1 t# R
91.                 if(g_rx_buffer[0] != 0x0a)
    
92.                 {
    ' e  j6 J3 n* k
93.                     g_usart_rx_sta = 0;                       /* 接收错误,重新开始 */
    
94.                 }
    
95.                 else
    3 j0 J; ]) u6 z( c
96.                 {
    
97.                     g_usart_rx_sta |= 0x8000;                 /* 接收完成了 */
    
98.                 }
    
99.             }
    
100.             else                                              /* 还没收到0X0D */
     0 I9 K3 @: n3 q
101.             {
     : B* j! J8 P* ~6 T; `4 K
102.                 if(g_rx_buffer[0] == 0x0d)
     : \9 q5 y3 J) n6 R. \
103.                 {
     ! d0 O2 Q& V( Z9 c" @+ o
104.                     g_usart_rx_sta |= 0x4000;
     
105.                 }
     / A7 {  }, h5 G5 H5 [& F- L
106.                 else
     
107.                 {
     
108.                     g_usart_rx_buf[g_usart_rx_sta & 0X3FFF] = g_rx_buffer[0] ;
     # A) r1 d( d) ^& Y! y7 y
109.                     g_usart_rx_sta++;
     8 K- D( h. v/ U0 }7 |, E
110.                     if(g_usart_rx_sta > (USART_REC_LEN - 1))
     
111.                     {
     
112.                         g_usart_rx_sta = 0;                   /* 接收数据错误,重新开始接收 */
     
113.                     }
     ! n# j- B% b9 [$ C" h4 \! T1 s
114.                 }
     8 r7 u$ z, [2 u7 E7 ?6 g
115.             }
     
116.         }
     7 x1 b% w0 k( G1 [; w% B
117.     }
     
118. }
     7 \8 C  a  P: J$ I) ^! ~/ _
119. 
     
120. /**
     
121. * @brief       串口4中断服务函数
     4 ?) M9 w/ D% t+ a
122. * @param       无
     
123. * @retval      无
       V: ?& g0 v1 a1 }- G
124. */
     
125. void USART_UX_IRQHandler(void)
     3 d' I. C* d1 v! h1 _. F. c" l
126. {
     
127.     uint32_t timeout = 0;
     
128.     uint32_t maxDelay = 0x1FFFF;
     
129. 
     
130.     HAL_UART_IRQHandler(&g_uart4_handle); /* 调用HAL库中断处理公用函数 */
     
131. 
     / e# n- A& W# h( `
132.     timeout = 0;
     
133.     while (HAL_UART_GetState(&g_uart4_handle) != HAL_UART_STATE_READY) /* 等待就绪 */
       o+ @. S, |. h; K; c1 U( B6 P
134.     {
     
135.         timeout++;                       /* 超时处理 */
     ! l# D! z, J* F) T
136.         if(timeout > maxDelay)
     5 d; f% g! g$ e" M' ^
137.         {
     
138.             break;
     
139.         }
     8 T  N3 b6 p8 p- D, o' v/ G
140.     }
     1 z7 S, a! E, `" m+ D" D8 y
141.      
     6 P" ]5 `9 Z7 E) V$ B
142.     timeout=0;
     
143.    
     1 R' u9 I! M4 u5 `* A" G
144.     /* 一次处理完成之后，重新开启中断并设置RxXferCount为1 */
     & X9 X, }6 y4 U, N! x
145.     while (HAL_UART_Receive_IT(&g_uart4_handle, (uint8_t *)g_rx_buffer, RXBUFFERSIZE) != HAL_OK)
     3 {. m; L5 {% X, u5 {( p3 |* m, D
146.     {
     4 c+ h0 S. }9 v* z( I
147.         timeout++;                  /* 超时处理 */
     9 U+ K, p9 t# e) L7 \, ~/ j! B, i
148.         if (timeout > maxDelay)
     
149.         {
     
150.             break;
     9 U! M# ^6 h# `- T! N! {; u
151.         }
     4 E! w. S+ Q2 U& }/ k
152.     }
     
153. 
     
154. }

复制代码

main函数调用：

1. if (g_usart_rx_sta & 0x8000)        /* 接收到了数据 */
   & T2 U/ ?# `5 d) l# R
2.                 {
   . g' a4 Y1 k- B
3.                                 len = g_usart_rx_sta & 0x3fff;  /* 得到此次接收到的数据长度 */
   8 z3 i5 \5 _# u
4.                         printf("\r\nYou send message is: \r\n");
   1 ?4 Y, Y8 c6 \1 b- M
5.                                 for (t = 0; t < len; t++)
   7 _; G+ e4 M7 O
6.                                 {
   & D( ]: Q- N' `7 @; q  x
7.                                                 USART_UX->TDR = g_usart_rx_buf[t];
   
8.                                                 while ((USART_UX->ISR & 0X40) == 0);  /* 等待发送结束 */
   
9.                                 }
   
10.                                 printf("\r\n\r\n"); /* 插入换行 */
    4 z+ C( K, A1 k" ]
11.                                 g_usart_rx_sta = 0;
    
12.                 }
    . N' R8 `8 f/ [' y8 ^
13.                 else
    4 W1 X$ `4 ]( j: G
14.                 {
    % o! D  Q$ W9 b7 L* S& D9 A
15.                                 times++;
    
16.                                 if (times % 5000 == 0)
    5 A- E+ X/ R5 O# t$ A* [3 [
17.                                 {
    
18.                                                 printf("\r\nSTM32MP1_DK1 UART4 TEST!\r\n");
    3 |1 r  ~3 N, f3 _, W7 ~. p7 \
19.                                                 printf("JasonQiu@ST community \r\n\r\n\r\n");
    0 ~1 J9 w- ~3 m) l: x; `: M
20.                                 }
    9 l" E! d  ?, L: b( n; |
21.                                 if (times % 200 == 0) printf("Please putchar!\r\n");
    5 X$ I/ k& b' M
22.                                 if (times % 30  == 0)
    
23.                                 {
    $ d/ Z3 G9 g' [' [5 F& n5 a6 n
24.                                         LED0_TOGGLE();
    
25.                                         printf("The led station is %d \r\n\r\n\r\n",LED0_STATION);
    
26.                                 }
    3 d0 V, Q2 |! j' y! T0 j
27.                                 delay(10);
    
28.                 }

复制代码

编译无误后，此时我们需要修改MCU的BOOT MODE ：
我们选择从内部RAM启动的模式：
5 O7 X- ^% F) C


9 H3 t- W3 M$ r# Y/ g  V4 FMDK中，有几次配置要注意：


" z6 B/ `$ y2 M4 I$ c7 Y: s

; W$ I. D+ p! ]5 m; e1 T4 s
* O5 C2 e# ^6 A
下载后直接运行，看下输出的状态：
6 h. V+ j! C" F$ D# ~: O9 r
板子LED状态：
9 G6 q1 d' c: a; ?- \9 C. W; y! P
7 \5 `& ]! `6 [  p7 P3 Q好了，M4核的裸机开发就到这了。