通过上篇文章对STM32MP1双核机制的分析。我们知道M4内核的程序，不能够下载到FLASH当中。那怎么调试M4的程序呢。下面我们就开始讲一讲。
& M& ?; k6 \2 E$ I1 T, }$ A6 O0 m3 LSTM32MP1跟普通M4核MCU开发没有太大的区别，一样调用HAL库，一样可以通过CUBEMX工具生成
初始化代码。当然在能控制的外设方面比真正的M4单片机要少一些，上文已描述过。我们在这里就不多说了。
我们打开CUBEMX工具，选择对应型号，配置工程：
我们想控制板上一颗LED，并且串口能够收发数据。
& x! F! [! T4 @8 l( t# F) R8 PLED引脚电路位置：

5 \9 j4 N( n9 ?6 f与STLINK相连的调试串口UART4电路位置：




6 O4 Z: Y" _3 A0 D7 ^CUBEMX配置：
2 d% l0 o" P$ E
! B3 Z& l) H( e/ G8 ~
$ x* X% s3 s$ E) g/ L1 p5 p
配置时钟：



" s, ^3 i! {" H0 p8 O工程配置时，选择让每一个外设生成独立文件：
% \+ W! l$ B1 l
然后生成代码，我们这里没有官方的STM32CUBEIDE开发，用MDK。
3 B. P' Q! {! t6 v% m9 O: c生成的代码，我们不直接用，仅作为参考。
/ l3 |% @: F1 D修改自己的led程序：
C:

1. void led_init(void)
     N0 D8 L) l' A# O$ p9 `% U
2. {
   
3.     GPIO_InitTypeDef gpio_init_struct;
   3 L1 \2 T* J1 h* q" y
4.     LED0_GPIO_CLK_ENABLE(); /* LED0时钟使能 */
   4 ]- @' q, E6 {
5. 
   
6. 
   
7.     gpio_init_struct.Pin = LED0_GPIO_PIN;                   /* LED0引脚 */
   ) r8 s; s! E6 N* n  g1 b2 O2 Z
8.     gpio_init_struct.Mode = GPIO_MODE_OUTPUT_PP;            /* 推挽输出 */
   
9.     gpio_init_struct.Pull = GPIO_PULLUP;                    /* 上拉 */
   - g9 h9 ]9 i( O# }
10.     gpio_init_struct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;     /* 高速 */
    7 z% D1 }5 m% O; X% N/ J7 o: K
11.     HAL_GPIO_Init(LED0_GPIO_PORT, &gpio_init_struct);       /* 初始化LED0引脚 */
    + a+ Y# i% Q- C: i
12. 
    $ Y. A+ I$ B: X. v% ^
13. 
    ; V/ u0 O6 a4 U( N- T( @1 v/ x
14.     LED0(0);    /* 关闭 LED0 */
    
15. 
    
16. }

复制代码

H:
. ~6 I- w, K: J8 p/ n; r+ d

1. #define LED0_GPIO_PORT                  GPIOE
   % K1 T! j8 t  M/ d. ?( C% j
2. #define LED0_GPIO_PIN                   GPIO_PIN_12
   $ q/ S1 q4 c; Y
3. #define LED0_GPIO_CLK_ENABLE()          do{ __HAL_RCC_GPIOE_CLK_ENABLE(); }while(0)   /* PE口时钟使能 */
   
4. 
   
5. /******************************************************************************************/
   
6. 
   
7. 
   
8. /* LED端口定义 */
   
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 */
    , w/ L2 V2 _$ Y& U2 J% ?
13. 
    2 Y3 k0 e& w, H9 V0 ?6 m5 h8 U
14. /* LED取反定义 */
    
15. #define LED0_TOGGLE()    do{ HAL_GPIO_TogglePin(LED0_GPIO_PORT, LED0_GPIO_PIN); }while(0)   /* LED0 = !LED0 */
    
16. 
    
17. 
    # n. i7 q+ w0 e9 z% p
18. #define LED0_STATION     HAL_GPIO_ReadPin(LED0_GPIO_PORT, LED0_GPIO_PIN)
    / |" \; O' k: F9 ]# q2 [  J' j; ^* `
19. 
    " S/ `5 S/ M, o$ C
20. void led_init(void);    /* 初始化 */

复制代码

UART4.C
主要处理都在接收回传函数里面，此接收函数一直参考正点原子。
! P/ j( f$ e- Q8 A1 Z

1. * 接收缓冲, 最大USART_REC_LEN个字节. */
   9 U) X/ y* F" g5 y$ r1 @5 e, m( n) _! [
2. uint8_t g_usart_rx_buf[USART_REC_LEN];
   
3. 
   
4. /*  接收状态
   # W, x: r3 L" {
5. *  bit15，      接收完成标志
   , e* X8 v& M4 i0 l) u
6. *  bit14，      接收到0x0d
   
7. *  bit13~0，    接收到的有效字节数目
   
8. */
   + z2 K$ X0 Y/ d* K0 m" ?; `: e
9. uint16_t g_usart_rx_sta = 0;
   ! o# W# b2 Q# _: o+ A! H' ^* {7 |2 O, Q
10. 
    
11. uint8_t g_rx_buffer[RXBUFFERSIZE];    /* HAL库使用的串口接收缓冲 */
    ! o( m& y. U) C9 f2 C: |! E# T
12. 
    
13. UART_HandleTypeDef g_uart4_handle;    /* UART句柄 */
    ( u2 P- z% E) `& ?
14. 
    + |' D! X" [: K
15. 
    0 l" w$ |" Y& D4 G$ |
16. /**
    
17. * @brief       串口X初始化函数
    
18. * @param       baudrate: 波特率, 根据自己需要设置波特率值
    
19. * @note        注意: 必须设置正确的时钟源, 否则串口波特率就会设置异常.
    
20. *              这里的USART的时钟源在sys_stm32_clock_init()函数中已经设置过了.
    
21. * @retval      无
    
22. */
    2 o, J: L) y8 g8 [( S7 z
23. void usart_init(uint32_t baudrate)
    + Y+ y7 ]) l, G4 g5 d6 I9 `; U
24. {
    2 G- u3 s1 Q- f% g2 c
25.     g_uart4_handle.Instance = USART_UX;                    /* USART4 */
    ' ]* m4 A  r' x9 @) ~) h
26.     g_uart4_handle.Init.BaudRate = baudrate;               /* 波特率 */
    
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;   /* 无硬件流控 */
    ) ~8 v% T2 o6 C1 Q* |' b
31.     g_uart4_handle.Init.Mode = UART_MODE_TX_RX;            /* 收发模式 */
    3 _* ]- F( G% Q1 I& |% H
32.     HAL_UART_Init(&g_uart4_handle);                        /* HAL_UART_Init()会使能UART4 */
    
33.    
    / V0 ^  c" {9 A# B
34.     /* 该函数会开启接收中断：标志位UART_IT_RXNE，并且设置接收缓冲以及接收缓冲接收最大数据量 */
    ; S8 y# s2 Q3 u1 E0 d
35.     HAL_UART_Receive_IT(&g_uart4_handle, (uint8_t *)g_rx_buffer, RXBUFFERSIZE);
    ! j) C0 K# f  S% L
36. }
    - I) i* U( ~0 L6 @& O9 [
37. 
    
38. /**
    - b- |, a+ J- w6 T
39. * @brief       UART底层初始化函数
    0 S" F0 K0 D  n' |" s
40. * @param       huart: UART句柄类型指针
    
41. * @note        此函数会被HAL_UART_Init()调用
    / h% O& n) W; t7 n, i
42. *              完成时钟使能，引脚配置，中断配置
    
43. * @retval      无
    
44. */
    
45. void HAL_UART_MspInit(UART_HandleTypeDef *huart)
    + S( K4 {; x; P# }' w( g* p0 }
46. {
    
47.     GPIO_InitTypeDef gpio_init_struct;
    
48.         RCC_PeriphCLKInitTypeDef rcc_periphclk_init_struct;
    ! H* C: }! h1 u" _. W
49.         
    
50.     if(huart->Instance == UART4)                                   /* 如果是串口4，进行串口4 MSP初始化 */
    
51.     {
    
52.         USART_UX_CLK_ENABLE();                                      /* USART4时钟使能 */
    3 Q/ D' X' q2 G. ?% S0 X! H
53.         USART_TX_GPIO_CLK_ENABLE();                                 /* 发送引脚时钟使能 */
    
54.         USART_RX_GPIO_CLK_ENABLE();                                 /* 接收引脚时钟使能 */
    ! I5 g% X, L3 G4 S$ q
55. 
    
56.         gpio_init_struct.Pin = USART_TX_GPIO_PIN;                   /* 指定TX引脚 */
    
57.         gpio_init_struct.Mode = GPIO_MODE_AF_PP;                    /* 复用推挽输出 */
    7 [0 l8 I2 Z! i7 K( F8 r  \9 F
58.         gpio_init_struct.Pull = GPIO_PULLUP;                        /* 上拉 */
    , D+ t, }) N& `; X1 ]1 y
59.         gpio_init_struct.Speed = GPIO_SPEED_FREQ_HIGH;              /* 高速 */
    , E" q+ {6 }/ `8 I0 S8 `6 y
60.         gpio_init_struct.Alternate = USART_TX_GPIO_AF;              /* 复用为UART4 */
    
61.         HAL_GPIO_Init(USART_TX_GPIO_PORT, &gpio_init_struct);       /* 初始化发送引脚 */
    
62. 
    " c* F( Q$ Z7 T. f0 |
63.         gpio_init_struct.Pin = USART_RX_GPIO_PIN;                   /* 指定RX引脚 */
    2 z5 ^  t- D# t! G7 \/ ?
64.         gpio_init_struct.Alternate = USART_RX_GPIO_AF;              /* 复用为UART4 */
    4 X) o; R& w2 X7 Q6 ?+ e3 A- S
65.         HAL_GPIO_Init(USART_RX_GPIO_PORT, &gpio_init_struct);       /* 初始化接收引脚 */
    : J7 M! i) s6 W' D$ c0 C
66.                
    2 b0 m# [3 f6 Q$ N4 \# C) x
67.                 /* 设置UART4时钟源=PLL4Q=74.25MHz  */
    
68.                 rcc_periphclk_init_struct.Uart24ClockSelection = RCC_UART24CLKSOURCE_PLL4;
    
69.                 HAL_RCCEx_PeriphCLKConfig(&rcc_periphclk_init_struct);
    
70. 
    
71. #if USART_EN_RX
    
72.         HAL_NVIC_EnableIRQ(USART_UX_IRQn);                          /* 使能USART4中断通道 */
    1 Y" M- f6 `# m  X* k
73.         HAL_NVIC_SetPriority(USART_UX_IRQn, 3, 3);                  /* 抢占优先级3，子优先级3 */
    
74. #endif
    
75.     }
    ) _9 ?$ e/ Y' v. m
76. }
    
77. 
    
78. /**
    
79. * @brief       Rx传输回调函数
    
80. * @param       huart: UART4句柄类型指针
    
81. * @retval      无
    
82. */
    
83. void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
    ' W! a$ K* i& L( X( W
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 */
    
90.             {
    
91.                 if(g_rx_buffer[0] != 0x0a)
    
92.                 {
    ( e" ?! C) x: S& r3 {+ f6 Z3 W; F
93.                     g_usart_rx_sta = 0;                       /* 接收错误,重新开始 */
    
94.                 }
    
95.                 else
    
96.                 {
    
97.                     g_usart_rx_sta |= 0x8000;                 /* 接收完成了 */
    4 l' }+ l( s$ ~0 {& W2 U! d- w
98.                 }
      ?( q/ A/ M4 X
99.             }
    
100.             else                                              /* 还没收到0X0D */
       N4 h# D* [2 U5 b1 K# X
101.             {
     
102.                 if(g_rx_buffer[0] == 0x0d)
     9 c' k+ _$ E3 n
103.                 {
     
104.                     g_usart_rx_sta |= 0x4000;
     
105.                 }
     + W4 K- o# C9 @- F  i$ [4 `& L4 q2 }
106.                 else
     
107.                 {
     9 ]( s0 y2 j( V8 s$ [2 B' ]9 P
108.                     g_usart_rx_buf[g_usart_rx_sta & 0X3FFF] = g_rx_buffer[0] ;
     
109.                     g_usart_rx_sta++;
     7 k! S4 e( X0 i1 C0 c- Z
110.                     if(g_usart_rx_sta > (USART_REC_LEN - 1))
     
111.                     {
     - q8 ?! T, `1 b: x2 A
112.                         g_usart_rx_sta = 0;                   /* 接收数据错误,重新开始接收 */
     2 n+ C4 C2 w- T- S% s
113.                     }
     - h% Q6 W/ M# O% U
114.                 }
     
115.             }
     
116.         }
     $ O: C& P/ y2 b4 f+ t8 ^, _
117.     }
     3 U; G; p' p; W5 `# T- R2 @
118. }
     6 _8 C! B$ K% H4 b+ W
119. 
     
120. /**
     + w  @5 K% |6 j% \( P' c
121. * @brief       串口4中断服务函数
     : v9 d* U$ T/ v+ H( ^5 A
122. * @param       无
     
123. * @retval      无
     ) N) Q& O" H7 R/ o+ n( w; X) z# r
124. */
     
125. void USART_UX_IRQHandler(void)
     
126. {
     
127.     uint32_t timeout = 0;
     
128.     uint32_t maxDelay = 0x1FFFF;
     " W. M$ g3 N, l$ B
129. 
     
130.     HAL_UART_IRQHandler(&g_uart4_handle); /* 调用HAL库中断处理公用函数 */
     7 t- Y& k" W4 W
131. 
     * f" i) d% {$ T5 F; v. A# o9 C* i& x0 B
132.     timeout = 0;
     
133.     while (HAL_UART_GetState(&g_uart4_handle) != HAL_UART_STATE_READY) /* 等待就绪 */
     
134.     {
     
135.         timeout++;                       /* 超时处理 */
     ( D# \6 T' [8 `0 z0 \$ f
136.         if(timeout > maxDelay)
       k& G0 {! @9 Z, L
137.         {
     * K6 W) F/ ~7 w. b; A. f. ~7 n: Z& @
138.             break;
     
139.         }
     % V2 c+ `+ q* r% G5 F: o0 c7 z
140.     }
     
141.      
     " [' B5 Z6 Q; U4 ?- v- a5 Q1 g
142.     timeout=0;
     
143.    
     
144.     /* 一次处理完成之后，重新开启中断并设置RxXferCount为1 */
     
145.     while (HAL_UART_Receive_IT(&g_uart4_handle, (uint8_t *)g_rx_buffer, RXBUFFERSIZE) != HAL_OK)
     ! ]8 M' t4 B4 O1 z, P! `
146.     {
     
147.         timeout++;                  /* 超时处理 */
     7 L* h( t* T5 b* H
148.         if (timeout > maxDelay)
     $ g2 d" B' |/ w  w0 C5 V
149.         {
     ; I3 W2 ?. X! @6 ]$ u5 l' j
150.             break;
       s" z1 Z3 p$ L8 _2 H7 N) S* f
151.         }
     : d/ A$ G& [9 f$ \# b
152.     }
     
153. 
     
154. }

复制代码

main函数调用：
& \7 t. o5 V8 j0 X7 E5 z

1. if (g_usart_rx_sta & 0x8000)        /* 接收到了数据 */
   
2.                 {
   
3.                                 len = g_usart_rx_sta & 0x3fff;  /* 得到此次接收到的数据长度 */
   6 }' I* q1 G9 |3 ]# j
4.                         printf("\r\nYou send message is: \r\n");
   2 `% F$ A/ M0 @7 y' ^& }  P" b7 b) u
5.                                 for (t = 0; t < len; t++)
   : o6 l/ N+ H9 A) e/ w
6.                                 {
   
7.                                                 USART_UX->TDR = g_usart_rx_buf[t];
   
8.                                                 while ((USART_UX->ISR & 0X40) == 0);  /* 等待发送结束 */
   
9.                                 }
   
10.                                 printf("\r\n\r\n"); /* 插入换行 */
    ! o& I3 b- {1 {5 r  M  t* B
11.                                 g_usart_rx_sta = 0;
    
12.                 }
    
13.                 else
    ( S! f3 n: V; R+ a
14.                 {
    0 c$ v) G4 c( G, A- |: [8 f
15.                                 times++;
    # t% o8 H; Q; E# g& e; K: X' Q' t( G
16.                                 if (times % 5000 == 0)
    3 u! d! N. ~( M% j' }
17.                                 {
    
18.                                                 printf("\r\nSTM32MP1_DK1 UART4 TEST!\r\n");
    ! p$ l. e/ M# E! Z- _5 S. z
19.                                                 printf("JasonQiu@ST community \r\n\r\n\r\n");
    " K: x$ \$ s: x8 a" l2 K" l  P
20.                                 }
    0 O: C6 Q, J7 [5 S. @
21.                                 if (times % 200 == 0) printf("Please putchar!\r\n");
    3 i# {, G$ d9 X7 {6 l3 O# a6 H
22.                                 if (times % 30  == 0)
    
23.                                 {
    
24.                                         LED0_TOGGLE();
    7 @- F# L# ?, h9 V
25.                                         printf("The led station is %d \r\n\r\n\r\n",LED0_STATION);
    
26.                                 }
    2 g6 S1 i: w6 L) L3 Z$ s; b2 ^
27.                                 delay(10);
    
28.                 }

复制代码

编译无误后，此时我们需要修改MCU的BOOT MODE ：
/ p; E) i3 s6 W1 L. t; a2 E5 o我们选择从内部RAM启动的模式：

7 W+ h. |3 V: w' c( F" ?4 w
0 U% A# z, g8 U8 I) u
" V! M0 ~3 H) d! Z  PMDK中，有几次配置要注意：
( v+ c( u! k. o; a, {* M# ~
- d% j5 w5 B( B! t

, Z8 d0 e2 V; g. W

4 G9 E3 L/ R9 n9 {' [% B
" {" _1 G) j8 J+ Z$ B1 m下载后直接运行，看下输出的状态：

板子LED状态：

好了，M4核的裸机开发就到这了。