通过上篇文章对STM32MP1双核机制的分析。我们知道M4内核的程序，不能够下载到FLASH当中。那怎么调试M4的程序呢。下面我们就开始讲一讲。
% n- o% z8 o* l$ Y0 ySTM32MP1跟普通M4核MCU开发没有太大的区别，一样调用HAL库，一样可以通过CUBEMX工具生成
$ t( W  L3 R; W. b初始化代码。当然在能控制的外设方面比真正的M4单片机要少一些，上文已描述过。我们在这里就不多说了。
我们打开CUBEMX工具，选择对应型号，配置工程：
我们想控制板上一颗LED，并且串口能够收发数据。
3 r" R- A* _! Z: mLED引脚电路位置：

6 ]7 g4 u' y: @) x1 n0 b7 q与STLINK相连的调试串口UART4电路位置：

8 o0 e4 w6 e! w
: v9 f& L' [2 I: O
2 u, I* U9 i/ a
" z* m, D' P4 F) }$ [CUBEMX配置：
' ~6 z8 d" F1 b4 Z: K# t; d
" Z$ b3 P! o( i7 C6 W

配置时钟：
( @6 Q2 n( `0 P9 o* m& ~
( W# |$ V! k8 I5 z
" k" ?( y' b6 t
工程配置时，选择让每一个外设生成独立文件：
5 {; `2 ^7 n7 `( |; i; r& a" L0 n! ^
然后生成代码，我们这里没有官方的STM32CUBEIDE开发，用MDK。
# ~, |& i1 _4 ~: W! U1 o0 A生成的代码，我们不直接用，仅作为参考。
修改自己的led程序：
. r# r+ E( q6 z1 _) Q! f3 t0 K( N1 uC:

1. void led_init(void)
   4 R/ K. d4 E) U7 z- l  ]8 \$ N
2. {
   
3.     GPIO_InitTypeDef gpio_init_struct;
   
4.     LED0_GPIO_CLK_ENABLE(); /* LED0时钟使能 */
   
5. 
     o( C/ U. v6 w1 @/ n
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;     /* 高速 */
    ' F% N; e/ c9 N5 {, p7 g# W
11.     HAL_GPIO_Init(LED0_GPIO_PORT, &gpio_init_struct);       /* 初始化LED0引脚 */
    , g" F) w. ]+ r4 s" w
12. 
    4 G$ t7 l  @) G0 A& z0 K; w% X/ i
13. 
    + S: `5 I  m$ j1 X
14.     LED0(0);    /* 关闭 LED0 */
    
15. 
    % j+ O# O. o) q5 ]0 |/ l" ~. G' Z
16. }

复制代码

H:

1. #define LED0_GPIO_PORT                  GPIOE
   , M9 Z8 \) ?, p8 n) u8 |
2. #define LED0_GPIO_PIN                   GPIO_PIN_12
   
3. #define LED0_GPIO_CLK_ENABLE()          do{ __HAL_RCC_GPIOE_CLK_ENABLE(); }while(0)   /* PE口时钟使能 */
   
4. 
   4 N$ f. K2 l3 ?  l1 U5 ]
5. /******************************************************************************************/
   
6. 
   9 ~! B. E/ }) {8 i
7. 
   
8. /* LED端口定义 */
   
9. #define LED0(x)   do{ x ? \
   
10.                       HAL_GPIO_WritePin(LED0_GPIO_PORT, LED0_GPIO_PIN, GPIO_PIN_SET) : \
    & S& o4 Q4 {6 A( t' [/ L
11.                       HAL_GPIO_WritePin(LED0_GPIO_PORT, LED0_GPIO_PIN, GPIO_PIN_RESET); \
    
12.                   }while(0)       /* LED0 = RED */
    
13. 
    
14. /* LED取反定义 */
    , {" }$ g# _/ _9 D* Q
15. #define LED0_TOGGLE()    do{ HAL_GPIO_TogglePin(LED0_GPIO_PORT, LED0_GPIO_PIN); }while(0)   /* LED0 = !LED0 */
    
16. 
    
17. 
    2 Q; Q& {" ?; T% l$ [
18. #define LED0_STATION     HAL_GPIO_ReadPin(LED0_GPIO_PORT, LED0_GPIO_PIN)
    9 P4 @8 Y4 s1 S& B+ L2 Z" D# A  Z
19. 
    8 e3 K* I% g5 D8 U5 F4 H6 @
20. void led_init(void);    /* 初始化 */

复制代码

UART4.C
7 ]0 N& {  w) i# y6 c! E主要处理都在接收回传函数里面，此接收函数一直参考正点原子。
5 V* z# W' S$ Z

1. * 接收缓冲, 最大USART_REC_LEN个字节. */
   
2. uint8_t g_usart_rx_buf[USART_REC_LEN];
   
3. 
   " s' \9 X, E: {9 L' M
4. /*  接收状态
   
5. *  bit15，      接收完成标志
   
6. *  bit14，      接收到0x0d
   $ b7 S4 e( u& z, l; r
7. *  bit13~0，    接收到的有效字节数目
   0 i3 }, F, z4 R5 a6 {3 T
8. */
   / `) A$ N6 Y3 u3 l
9. uint16_t g_usart_rx_sta = 0;
     z% j- H: V7 `* ^6 C
10. 
    5 A7 d0 \) d6 S8 x, U0 ^( F) E
11. uint8_t g_rx_buffer[RXBUFFERSIZE];    /* HAL库使用的串口接收缓冲 */
    & n6 o( J5 x* j7 G8 P
12. 
    
13. UART_HandleTypeDef g_uart4_handle;    /* UART句柄 */
    ' J& s6 X( Y6 a) H
14. 
    
15. 
    8 B/ |/ ]" k  }
16. /**
    : ~( H1 A% J" @: h9 P
17. * @brief       串口X初始化函数
    ( p( @' h1 `6 m! F- w! r
18. * @param       baudrate: 波特率, 根据自己需要设置波特率值
    3 n. R( q) C$ ]* r8 v
19. * @note        注意: 必须设置正确的时钟源, 否则串口波特率就会设置异常.
    , Z! _. m" {3 Y) t# ~1 Z% w+ G
20. *              这里的USART的时钟源在sys_stm32_clock_init()函数中已经设置过了.
    
21. * @retval      无
    
22. */
    
23. void usart_init(uint32_t baudrate)
    
24. {
    
25.     g_uart4_handle.Instance = USART_UX;                    /* USART4 */
    ! I, K0 K- E) X
26.     g_uart4_handle.Init.BaudRate = baudrate;               /* 波特率 */
    " i1 C  ~4 l$ w3 n
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;         /* 无奇偶校验位 */
    1 h- [2 t3 h4 J, Y2 S
30.     g_uart4_handle.Init.HwFlowCtl = UART_HWCONTROL_NONE;   /* 无硬件流控 */
    
31.     g_uart4_handle.Init.Mode = UART_MODE_TX_RX;            /* 收发模式 */
    
32.     HAL_UART_Init(&g_uart4_handle);                        /* HAL_UART_Init()会使能UART4 */
    
33.    
    ! a% a; `9 z( M& Q; v6 {0 X7 W
34.     /* 该函数会开启接收中断：标志位UART_IT_RXNE，并且设置接收缓冲以及接收缓冲接收最大数据量 */
    
35.     HAL_UART_Receive_IT(&g_uart4_handle, (uint8_t *)g_rx_buffer, RXBUFFERSIZE);
    
36. }
    
37. 
    + K4 c, D3 H: C
38. /**
    ' z- A+ p' @$ t2 @- i
39. * @brief       UART底层初始化函数
    
40. * @param       huart: UART句柄类型指针
    8 O. ~6 [; \6 o& }# x1 A6 h
41. * @note        此函数会被HAL_UART_Init()调用
    5 T* ~5 d6 m/ q& }8 o) e: q0 Z7 F" s
42. *              完成时钟使能，引脚配置，中断配置
    # D  N  n% N) @- \9 B
43. * @retval      无
    - a! c* L; [/ n- l5 m
44. */
    
45. void HAL_UART_MspInit(UART_HandleTypeDef *huart)
    
46. {
    , c% L0 B$ F% S+ R) n
47.     GPIO_InitTypeDef gpio_init_struct;
    
48.         RCC_PeriphCLKInitTypeDef rcc_periphclk_init_struct;
    " s8 f4 V8 W8 `1 ?4 J: P! v0 ~
49.         
    & ^& f- K- k. K" M5 C
50.     if(huart->Instance == UART4)                                   /* 如果是串口4，进行串口4 MSP初始化 */
    8 O, p- e2 q5 L4 A2 y
51.     {
    
52.         USART_UX_CLK_ENABLE();                                      /* USART4时钟使能 */
    
53.         USART_TX_GPIO_CLK_ENABLE();                                 /* 发送引脚时钟使能 */
    
54.         USART_RX_GPIO_CLK_ENABLE();                                 /* 接收引脚时钟使能 */
    / p+ |- F) f) y3 u6 D: W( {
55. 
    
56.         gpio_init_struct.Pin = USART_TX_GPIO_PIN;                   /* 指定TX引脚 */
    3 R& X5 y: [. _$ ^% ~" T: L: a
57.         gpio_init_struct.Mode = GPIO_MODE_AF_PP;                    /* 复用推挽输出 */
    9 O# |  u- ?8 u& y5 ?6 D
58.         gpio_init_struct.Pull = GPIO_PULLUP;                        /* 上拉 */
    
59.         gpio_init_struct.Speed = GPIO_SPEED_FREQ_HIGH;              /* 高速 */
    
60.         gpio_init_struct.Alternate = USART_TX_GPIO_AF;              /* 复用为UART4 */
    4 y! _9 [0 s3 Z& S
61.         HAL_GPIO_Init(USART_TX_GPIO_PORT, &gpio_init_struct);       /* 初始化发送引脚 */
    
62. 
    2 S0 O$ s& y+ B2 B4 R& `$ n' L
63.         gpio_init_struct.Pin = USART_RX_GPIO_PIN;                   /* 指定RX引脚 */
    
64.         gpio_init_struct.Alternate = USART_RX_GPIO_AF;              /* 复用为UART4 */
    * N7 u3 |1 G8 O3 `
65.         HAL_GPIO_Init(USART_RX_GPIO_PORT, &gpio_init_struct);       /* 初始化接收引脚 */
    " g' ?* I6 r; e- v
66.                
    
67.                 /* 设置UART4时钟源=PLL4Q=74.25MHz  */
    9 x* |' y2 D. f: x2 k9 G
68.                 rcc_periphclk_init_struct.Uart24ClockSelection = RCC_UART24CLKSOURCE_PLL4;
    
69.                 HAL_RCCEx_PeriphCLKConfig(&rcc_periphclk_init_struct);
    & @6 Z4 o0 p. _  z
70. 
    
71. #if USART_EN_RX
    
72.         HAL_NVIC_EnableIRQ(USART_UX_IRQn);                          /* 使能USART4中断通道 */
      g8 a! F, _  w% l9 l8 J) u; p
73.         HAL_NVIC_SetPriority(USART_UX_IRQn, 3, 3);                  /* 抢占优先级3，子优先级3 */
    & T& t# T0 X; a3 ^# d3 D
74. #endif
    
75.     }
    ) E6 Q. q( A. c7 q2 O' @
76. }
    
77. 
    
78. /**
    
79. * @brief       Rx传输回调函数
    4 Y  p! E4 H! B/ b
80. * @param       huart: UART4句柄类型指针
    
81. * @retval      无
    
82. */
    8 ?# Z) j7 g$ @! e# Y
83. void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
    
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.             {
    9 U8 `+ |6 Y+ S: K
91.                 if(g_rx_buffer[0] != 0x0a)
    
92.                 {
    ; t2 {1 e) F% @* w/ P& K& V7 ~
93.                     g_usart_rx_sta = 0;                       /* 接收错误,重新开始 */
    
94.                 }
    0 C* r1 C8 J# r
95.                 else
    
96.                 {
    ' X! ?' _! A0 F7 h# e
97.                     g_usart_rx_sta |= 0x8000;                 /* 接收完成了 */
    
98.                 }
    * g9 I% G* F7 I
99.             }
    6 ~% r# x& K4 S$ j+ I4 H8 W
100.             else                                              /* 还没收到0X0D */
     
101.             {
     
102.                 if(g_rx_buffer[0] == 0x0d)
     " f- @8 s9 ]$ U
103.                 {
     
104.                     g_usart_rx_sta |= 0x4000;
     ! s* A+ r2 Z8 r- R& [
105.                 }
     
106.                 else
     0 a: c2 s7 J' `1 W7 L
107.                 {
     * s7 g, d4 ~2 p# l
108.                     g_usart_rx_buf[g_usart_rx_sta & 0X3FFF] = g_rx_buffer[0] ;
     
109.                     g_usart_rx_sta++;
     
110.                     if(g_usart_rx_sta > (USART_REC_LEN - 1))
     
111.                     {
     
112.                         g_usart_rx_sta = 0;                   /* 接收数据错误,重新开始接收 */
     
113.                     }
     2 n0 M; R7 a$ Q* T( t( u
114.                 }
     
115.             }
     $ f3 m1 d! |' \% h& h
116.         }
     
117.     }
     5 q9 }" V& ^% e. k' T  N9 u
118. }
     ) A3 o) v. G  ^: [" N# d+ B4 r
119. 
     * h2 y" ?( B' Q3 b* D5 J
120. /**
     5 I8 [  J% V3 h1 S+ w" C6 U3 H
121. * @brief       串口4中断服务函数
     7 |7 z# W) d& }
122. * @param       无
     3 h  W# P# d# R# g1 {" L% p6 S, z0 i0 ]
123. * @retval      无
     # Z- R+ `3 m+ k! {( l) M
124. */
     
125. void USART_UX_IRQHandler(void)
     5 G+ Z9 f9 n3 N
126. {
     
127.     uint32_t timeout = 0;
     
128.     uint32_t maxDelay = 0x1FFFF;
     
129. 
     
130.     HAL_UART_IRQHandler(&g_uart4_handle); /* 调用HAL库中断处理公用函数 */
     
131. 
     
132.     timeout = 0;
     $ F* g7 O& y4 j1 H  C
133.     while (HAL_UART_GetState(&g_uart4_handle) != HAL_UART_STATE_READY) /* 等待就绪 */
     ( {- m8 v5 l7 P: O  c! }
134.     {
     $ O( c4 c$ A5 C4 d' F7 ^8 n
135.         timeout++;                       /* 超时处理 */
     
136.         if(timeout > maxDelay)
     4 S% x$ E+ Q6 [0 }) [- _$ b
137.         {
     
138.             break;
     
139.         }
     
140.     }
     
141.      
     
142.     timeout=0;
     
143.    
     / n0 U# {: \& `# r; H
144.     /* 一次处理完成之后，重新开启中断并设置RxXferCount为1 */
     % x6 s+ ?" Z/ M: N/ A
145.     while (HAL_UART_Receive_IT(&g_uart4_handle, (uint8_t *)g_rx_buffer, RXBUFFERSIZE) != HAL_OK)
     " E" _5 C: o! X( t! O8 F' U- z
146.     {
     0 R" f0 I8 i. C* r) ^5 W7 k, S, n, J
147.         timeout++;                  /* 超时处理 */
     / d0 x! \& R6 B& P5 n
148.         if (timeout > maxDelay)
     % [5 Z' T2 S+ U1 E
149.         {
     
150.             break;
     + Y- ^7 S; Y$ h* s* V- S
151.         }
     
152.     }
     
153. 
     
154. }

复制代码

main函数调用：
8 W) o9 ~& ?' P7 n

1. if (g_usart_rx_sta & 0x8000)        /* 接收到了数据 */
   
2.                 {
   5 ]! ^: C, F- u; J
3.                                 len = g_usart_rx_sta & 0x3fff;  /* 得到此次接收到的数据长度 */
   # r  `% i* T4 E. t$ k, c# O2 s9 a
4.                         printf("\r\nYou send message is: \r\n");
   
5.                                 for (t = 0; t < len; t++)
   $ E6 p( G- S9 b! Z
6.                                 {
   
7.                                                 USART_UX->TDR = g_usart_rx_buf[t];
   
8.                                                 while ((USART_UX->ISR & 0X40) == 0);  /* 等待发送结束 */
   
9.                                 }
   
10.                                 printf("\r\n\r\n"); /* 插入换行 */
    
11.                                 g_usart_rx_sta = 0;
    . p' S1 A/ ^! e" A5 }
12.                 }
    0 q! U! @( o. p+ E, }  ?& X
13.                 else
    
14.                 {
    
15.                                 times++;
    
16.                                 if (times % 5000 == 0)
    
17.                                 {
    
18.                                                 printf("\r\nSTM32MP1_DK1 UART4 TEST!\r\n");
    
19.                                                 printf("JasonQiu@ST community \r\n\r\n\r\n");
    
20.                                 }
    + F! x. w( H. c, q
21.                                 if (times % 200 == 0) printf("Please putchar!\r\n");
    / E' k/ N) u# B4 a: }8 L* L
22.                                 if (times % 30  == 0)
    
23.                                 {
    
24.                                         LED0_TOGGLE();
    
25.                                         printf("The led station is %d \r\n\r\n\r\n",LED0_STATION);
    
26.                                 }
    / I- H0 ^" R% Z# ^  k+ E; r6 r: E) W
27.                                 delay(10);
    % T0 C: H4 Z* P' ?5 y. R7 ~
28.                 }

复制代码

编译无误后，此时我们需要修改MCU的BOOT MODE ：
5 r# J1 K# K, @% A. k' l+ `我们选择从内部RAM启动的模式：
# W/ T3 E) r9 J% e" w

3 h& e0 Q5 u/ `  y6 |! d$ N8 Z
MDK中，有几次配置要注意：
, V& A; Y; E$ A+ t8 R' h





3 ?# K& R% Y% B下载后直接运行，看下输出的状态：
7 q, v& P  y8 A; K( G5 s) ]
板子LED状态：
0 o! j) a& j' p: `; O, A% B
& {* L1 O5 T" Z8 `好了，M4核的裸机开发就到这了。