1. 树莓派

树莓派端我们需要找到USB端口设备，我的树莓派上是CHASSIS_SERIAL_PORT = '/dev/ttyUSB0'，获得了端口设备之后就可以开始调库了，这也是python语言的拿手好戏。这次我们用的库是serial，我们需要这个库里的函数

$ v. L, P$ W, c& @) `* z7 c串口初始化：self.port_chassis = serial.Serial(CHASSIS_SERIAL_PORT, 9600, timeout=1)

; l$ o2 U2 Z  {; |* e6 C- n5 |发送数据：self.port_chassis.write((direction + str(distance)).encode())

1 f! b0 m- _( M/ l读取数据：self.port_chassis.readline().decode()

流初始化：
" _0 T! r  a4 J& x& pself.port_chassis.flushInput();self.port_chassis.flushOutput()
3 B( m2 N% {  l# L- i; j
有了上面几个函数之后，就可以开始写python脚本啦，结合代码来进行分析
. g. ~8 V* u! W) I1 m7 U4 z首先是类的初始化函数，目的主要是初始化USART(UART)的波特率

1. <font face="微软雅黑" size="3">def __init__(self):
   
2.         print("move init finish")
   
3.         self.time1 = time.time()
   + H& L" p2 U: J: v" c
4.         self.time2 = time.time()
   $ V1 w, D" T9 v2 d; q
5.         self.flag = False
   
6.         self.port_chassis = serial.Serial(CHASSIS_SERIAL_PORT, 9600, timeout=1)
   
7.         # print('port_chassis is :' + self.port_chassis.is_Open())
   
8.         self.port_chassis.flushInput()
   5 i* Y; B% D6 \$ o* ]& ]7 j
9.         self.port_chassis.flushOutput()</font>

复制代码

接下来就是发送数据，我们的购物机器人是通过树莓派做为整个的 “大脑”，是由树莓派里的python脚本给底盘发送指令，所以这个函数就是python让底盘移动distance个格子的函数，这个函数里面也是通过USART(UART)给底盘发送指令的，所用函数就是self.port_chassis.write((direction + str(distance)).encode())
: e9 B- e; {$ C2 u5 \

1. <font face="微软雅黑" size="3"> def move_by_grid(self, direction, distance=''):
   
2.         # print('move by grid')
   
3.         self.port_chassis.write((direction + str(distance)).encode())
   " [  y5 r/ b) Y2 h2 {- q, {; ^
4.         self.time1 = time.time()
   
5.         print(direction + str(distance))
   
6.         self.wait_for_act_end_signal_chassis(direction, distance)</font>

复制代码

最后是接收数据，既然树莓派要控制底盘，树莓派自然也要接收到底盘回传的数据，这里用到的USART(UART)接收数据函数是self.port_chassis.readline().decode()，sig就是树莓派接收到的USART(UART)数据，用户就可以对其做处理啦。

1. <font face="微软雅黑" size="3">def wait_for_act_end_signal_chassis(self, ret=None, distance=0):
   . F6 L7 l* T8 f
2.         print('waiting chassis...')
   1 N+ ?4 P7 ]" T2 N/ x
3.         while True:
   
4.             sig = self.port_chassis.readline().decode()
   
5. 
   
6.             # print(self.time2 - self.time1)
   
7. 
   
8.             sig = sig[0:2]
   - b9 U6 T  _) U: p& M  b
9.             print(sig)
   
10.             #
    9 X2 U! z* E! q. `( W+ |
11.             if sig == 'HI':
    5 `3 [' ]$ r7 `( w. N8 G/ k) P
12.                 self.time2 = time.time()
    / i( m6 g$ [  t' h8 F
13.                 print(self.time2 - self.time1)
    
14.                 if self.time2 - self.time1 < 1.0 and self.flag == False and distance == 1:
    
15.                     print('1 step deal error')
    
16.                     self.flag = True
    ' |" n3 J/ o' n  z; N7 T
17.                     if (ret == dir_up or ret == dir_back):
    & Q9 f( S9 W8 W/ R7 S& b& @" q4 C
18.                         self.move_by_grid(ret, 1)
    
19.                     else:</font>

复制代码

2. STM32F427IIH6
7 E, G1 R! V7 W
4 I- W/ I8 `9 n2 W( p4 b  h
: \; r9 V. M( v  W+ k在嵌入式芯片STM32F427IIH6里，我们首先要打开芯片的DMA功能，然后进行USART(UART)的初始化，最后设置USART(UART)的回调函数即可。


9 H8 F9 t. T. k首先进行DMA的初始化，在这些初始化里面完成的就是DMA时钟的使能和DMA中断的使能。
7 K* N. P" M- B! K

1. <font face="微软雅黑" size="3">void MX_DMA_Init(void)
   
2. {
   
3. 
   ( `& S4 ~4 O1 U
4.   /* DMA controller clock enable */
   
5.   __HAL_RCC_DMA1_CLK_ENABLE();
   * @; T* l, F) [
6.   __HAL_RCC_DMA2_CLK_ENABLE();
   
7. 
   " ~+ D+ ~0 `# Y( ^' f
8.   /* DMA interrupt init */
   
9.   /* DMA1_Stream0_IRQn interrupt configuration */
   
10.   HAL_NVIC_SetPriority(DMA1_Stream0_IRQn, 0, 0);
    8 R5 b+ |7 r. K$ D+ A! _
11.   HAL_NVIC_EnableIRQ(DMA1_Stream0_IRQn);
    ; X% J$ I2 {; O9 k/ r" G
12.   /* DMA1_Stream1_IRQn interrupt configuration */
    
13.   HAL_NVIC_SetPriority(DMA1_Stream1_IRQn, 0, 0);
    
14.   HAL_NVIC_EnableIRQ(DMA1_Stream1_IRQn);
    3 A4 X. y5 W. ?: _, ?; y# G
15.   /* DMA1_Stream3_IRQn interrupt configuration */
    
16.   HAL_NVIC_SetPriority(DMA1_Stream3_IRQn, 0, 0);
    " M( L1 [% h  y( `- O
17.   HAL_NVIC_EnableIRQ(DMA1_Stream3_IRQn);
    / T) @! O+ L$ B: ~2 P: J
18.   /* DMA1_Stream6_IRQn interrupt configuration */
    
19.   HAL_NVIC_SetPriority(DMA1_Stream6_IRQn, 0, 0);
    3 R; h; q3 m+ h$ F: }
20.   HAL_NVIC_EnableIRQ(DMA1_Stream6_IRQn);
    
21.   /* DMA2_Stream1_IRQn interrupt configuration */
    
22.   HAL_NVIC_SetPriority(DMA2_Stream1_IRQn, 0, 0);
    
23.   HAL_NVIC_EnableIRQ(DMA2_Stream1_IRQn);
    
24.   /* DMA2_Stream6_IRQn interrupt configuration */
    , F0 {' n" B' i6 a
25.   HAL_NVIC_SetPriority(DMA2_Stream6_IRQn, 0, 0);
    
26.   HAL_NVIC_EnableIRQ(DMA2_Stream6_IRQn);
    
27. 
    0 {9 H  x' M6 a& c
28. }
    3 g& P+ l$ \' ]6 g% B3 ^
29. </font>

复制代码

DMA使能完成之后就要进行USART(UART)的基本配置了，这里我设置的就是波特率9600(各个USART(UART)波特率初始化大同小异，因此在这里只放了usart6的初始化，其他类似，不做赘述)。

1. <font face="微软雅黑" size="3">void MX_USART6_UART_Init(void)
   6 j0 ?6 W  T3 l+ @, s9 q
2. {
   ) p; P* G+ N4 m4 P5 c3 Q9 l
3. 
   " ~4 E" A) Q% y, L
4.   huart6.Instance = USART6;
   
5.   huart6.Init.BaudRate = 9600;
   
6.   huart6.Init.WordLength = UART_WORDLENGTH_8B;
   
7.   huart6.Init.StopBits = UART_STOPBITS_1;
   0 X5 e* z, H0 G" @1 R
8.   huart6.Init.Parity = UART_PARITY_NONE;
   
9.   huart6.Init.Mode = UART_MODE_TX_RX;
   4 }# F2 j7 d! q% T" \
10.   huart6.Init.HwFlowCtl = UART_HWCONTROL_NONE;
    * p! y+ W( G- K- l8 W  @; D
11.   huart6.Init.OverSampling = UART_OVERSAMPLING_16;
    
12.   if (HAL_UART_Init(&huart6) != HAL_OK)
    
13.   {
    
14.     Error_Handler();
    
15.   }
    9 L, X; G- w0 D! X( ~3 N# `0 ?
16. 
    6 f, S; Q4 [% j2 ~2 L
17. }</font>

复制代码

完成了芯片级的配置之后，就要开始配置用户自己需求的USART(UART)功能了，简单点来说就是就是设置回调函数，并且编写回调函数内容。

; ]/ c& m, v0 A0 ]: k% [


) Y; ?& r$ T5 `! U在void USR_UartInit(void)中主要是打开USART(UART)的DMA接收功能，并且开启USART(UART)接收中断，HAL_UART_IdleCpltCallback(UART_HandleTypeDef *huart)就是我们的回调函数，uart6Rx[1024]，uart7Rx[1024]，uart8Rx[1024]这3个数组就是STM32F427IIH6的3个(USART6,UART7,UART8)USART(UART)接收到的数组数据 啦，接下来用户就可以对其做处理啦。

1. <font face="微软雅黑" size="3">
   * f4 l! A' U* T
2. void USR_UartInit(void)
   
3. {
   
4.     test1++;
   
5. 
   
6.     uart8RxLength = 0;   
   
7.     HAL_UART_Receive_DMA(&huart8, uart8Rx, buffer_size);
   . _% k3 o/ E3 S" F6 i! }3 Y9 }
8.     uart7RxLength = 0;   
   
9.     HAL_UART_Receive_DMA(&huart7, uart7Rx, buffer_size);
   5 D! E$ r) ]. |+ E
10.     uart6RxLength = 0;   
    ( @# C4 p5 ^* g5 X5 _& r: J3 ?
11.     HAL_UART_Receive_DMA(&huart6, uart6Rx, buffer_size);   
    0 W  l/ v% k* a1 Y4 ~1 F
12. 
    7 w' X: n! ]) N- O1 {2 Y. h8 B
13.     __HAL_UART_ENABLE_IT(&huart8, UART_IT_IDLE);     
    ! e7 c) {* u* l: N4 x
14.     __HAL_UART_ENABLE_IT(&huart7, UART_IT_IDLE);   
    
15.     __HAL_UART_ENABLE_IT(&huart6, UART_IT_IDLE);   
    . r- V; ?2 n0 {* M) \  N
16. }
    
17. void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
    0 |* _( }( |3 T# R
18. {
    , s: b) h) e7 k: s
19. 
    9 a% C& J) K/ y4 Y, J7 }
20.     HAL_UART_Receive_DMA(&huart8, uart8Rx, buffer_size);
    3 t2 i6 x+ ]3 b4 Q/ e
21.     HAL_UART_Receive_DMA(&huart7, uart7Rx, buffer_size);
      p9 E- U+ \4 j  w. j9 |) ^1 v
22.     HAL_UART_Receive_DMA(&huart6, uart6Rx, buffer_size);
    
23.     __HAL_DMA_ENABLE(&hdma_uart8_rx);
    9 t3 B/ V: s$ ~! E- J
24.     __HAL_DMA_ENABLE(&hdma_uart7_rx);
    
25.     __HAL_DMA_ENABLE(&hdma_usart6_rx);
    8 A( M" _- Y% V/ p
26.     test2++;
    - L. b/ v7 J; G. ^8 F
27. }
    
28. uint8_t RxLenHi, RxLenlo;  
    % l! h: B8 W( U( X% C4 v
29. void HAL_UART_IdleCpltCallback(UART_HandleTypeDef *huart)
    
30. {
    
31.     __HAL_UART_CLEAR_IDLEFLAG(huart);
    1 B# u( [$ X9 X, q& d% w) @
32. 
    
33.         if( huart == &huart8)
    
34.         {
    
35.             test3++;
    
36.             HAL_UART_Receive_DMA(&huart8, uart8Rx, buffer_size);  
    
37. 
    
38.             uart8RxLength = buffer_size-__HAL_DMA_GET_COUNTER(&hdma_uart8_rx);     
    / T7 e0 P, k8 `% q
39.             if(uart8Rx[0]=='@'
    7 m  W- p$ E9 P& m+ _2 P+ w3 @
40.             &&uart8Rx[1]=='c'
    / |7 M0 _1 Y: e1 z" r
41.             &&uart8Rx[2]=='m'
    - f1 _3 J0 F: E9 C& d7 f' `3 t5 A
42.             &&uart8Rx[3]=='d')
    
43.             {
    
44.                 if(!SERDEB_CmdValid())
    
45.                     SERDEB_PushCmd(uart8Rx, uart8RxLength);
    8 R7 q9 j0 a& [  E4 O1 y
46.             }
    
47.             __HAL_DMA_DISABLE(&hdma_uart8_rx);
    $ x! {$ P4 ^3 I  M# p; ?
48.             HAL_GPIO_TogglePin(GPIOG,GPIO_PIN_8);   
    
49.         }
    & r0 r& T. f) ]0 V) B) C( M
50. 
    % b3 @7 @( l- J4 d
51.           if( huart == &huart7)
    
52.         {        
    
53.             __HAL_DMA_DISABLE(&hdma_uart7_rx);  
    , X% M2 u3 g  t  S9 C, M( O& |! x6 |
54.             HAL_UART_Receive_DMA(&huart7, uart7Rx, buffer_size);
    
55.             __HAL_DMA_DISABLE(&hdma_uart7_rx);
    $ u! b) s/ I* B
56.         }
    4 z  V0 v9 G5 k8 W; P
57. 
    0 H4 b' u1 w8 v# V9 }4 u2 E
58.         if( huart == &huart6)
    8 A# g; |  U6 C5 c5 `! J
59.         {
    2 f3 s- T: L! l1 X2 c- p
60.             __HAL_DMA_DISABLE(&hdma_usart6_rx);
    
61.             HAL_UART_Receive_DMA(&huart6, uart6Rx, buffer_size);
    
62.             __HAL_DMA_DISABLE(&hdma_usart6_rx);
    8 D* Y3 e+ \2 y
63.         }
    
64. 
    
65. }</font>

复制代码

至此完成了双工通信的基本配置。

9 t3 R5 N( ^, Z& t/ i0 H0 K

! U5 g# f* A/ X4 s  ^3 o6 S! c