1. 树莓派

树莓派端我们需要找到USB端口设备，我的树莓派上是CHASSIS_SERIAL_PORT = '/dev/ttyUSB0'，获得了端口设备之后就可以开始调库了，这也是python语言的拿手好戏。这次我们用的库是serial，我们需要这个库里的函数
, z) U# w3 ^) D1 n: Q! R: m
9 z8 O2 d* I( e. Y5 p6 N串口初始化：self.port_chassis = serial.Serial(CHASSIS_SERIAL_PORT, 9600, timeout=1)
  g. O% X( v3 L# e4 F: }9 v
$ X. M1 e/ i2 {4 l- e3 a+ r发送数据：self.port_chassis.write((direction + str(distance)).encode())

读取数据：self.port_chassis.readline().decode()

流初始化：
3 v$ E6 `, G0 E; O8 Wself.port_chassis.flushInput();self.port_chassis.flushOutput()

6 J: }% q) x0 q, v9 Z  D有了上面几个函数之后，就可以开始写python脚本啦，结合代码来进行分析
9 \6 e8 e% \: Z首先是类的初始化函数，目的主要是初始化USART(UART)的波特率
2 J9 P0 R: q$ d' Y! J* m

1. <font face="微软雅黑" size="3">def __init__(self):
   
2.         print("move init finish")
   ' _. ~! G/ L/ `7 G1 k4 _  s. o
3.         self.time1 = time.time()
   . n& K0 T0 f& G. {( F& D0 {
4.         self.time2 = time.time()
   
5.         self.flag = False
   , }$ ^5 M& S# {8 Z6 r9 g" h
6.         self.port_chassis = serial.Serial(CHASSIS_SERIAL_PORT, 9600, timeout=1)
   ) L" Z) G6 A' Z) F
7.         # print('port_chassis is :' + self.port_chassis.is_Open())
   
8.         self.port_chassis.flushInput()
   
9.         self.port_chassis.flushOutput()</font>

复制代码

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

1. <font face="微软雅黑" size="3"> def move_by_grid(self, direction, distance=''):
   9 M$ L# F6 |6 n8 n( y3 f5 t
2.         # print('move by grid')
   6 H+ P8 c4 E, N4 m( N
3.         self.port_chassis.write((direction + str(distance)).encode())
   
4.         self.time1 = time.time()
   
5.         print(direction + str(distance))
   + j, o, O+ J6 O& U! I& V
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):
   
2.         print('waiting chassis...')
   
3.         while True:
   & J0 i1 x, ~( W5 t$ ]) K6 `% F
4.             sig = self.port_chassis.readline().decode()
   6 T% R% F0 m. _
5. 
   
6.             # print(self.time2 - self.time1)
   
7. 
   
8.             sig = sig[0:2]
   
9.             print(sig)
   
10.             #
    
11.             if sig == 'HI':
    * ?" r2 a; }1 P7 k4 I8 j
12.                 self.time2 = time.time()
    + z! n( n' T7 S, ?0 r
13.                 print(self.time2 - self.time1)
    
14.                 if self.time2 - self.time1 < 1.0 and self.flag == False and distance == 1:
    0 P# J5 J9 Z- P
15.                     print('1 step deal error')
    : D" n! l( `  Z* @
16.                     self.flag = True
    , H6 u! _- u3 T5 E0 g+ x% f2 _
17.                     if (ret == dir_up or ret == dir_back):
    
18.                         self.move_by_grid(ret, 1)
    
19.                     else:</font>

复制代码

( H$ w9 A/ V& a2 H; ]  d, s$ R/ j
2. STM32F427IIH6
# E, R. V% l, e' H* a* \6 E

在嵌入式芯片STM32F427IIH6里，我们首先要打开芯片的DMA功能，然后进行USART(UART)的初始化，最后设置USART(UART)的回调函数即可。


首先进行DMA的初始化，在这些初始化里面完成的就是DMA时钟的使能和DMA中断的使能。

+ a) p. B2 J: V4 G% K, j

1. <font face="微软雅黑" size="3">void MX_DMA_Init(void)
   
2. {
   : b  ~' ~9 d+ s7 k, Q: e) c
3. 
   6 o' K% |! m! k- o; P# y
4.   /* DMA controller clock enable */
   
5.   __HAL_RCC_DMA1_CLK_ENABLE();
   % R! D" ~: Z" `) |6 v9 ]& y- J% A- P
6.   __HAL_RCC_DMA2_CLK_ENABLE();
   3 N: L4 ~8 M" h# {; v5 z, r+ {; ]
7. 
   
8.   /* DMA interrupt init */
   
9.   /* DMA1_Stream0_IRQn interrupt configuration */
   
10.   HAL_NVIC_SetPriority(DMA1_Stream0_IRQn, 0, 0);
    
11.   HAL_NVIC_EnableIRQ(DMA1_Stream0_IRQn);
    
12.   /* DMA1_Stream1_IRQn interrupt configuration */
    
13.   HAL_NVIC_SetPriority(DMA1_Stream1_IRQn, 0, 0);
    
14.   HAL_NVIC_EnableIRQ(DMA1_Stream1_IRQn);
    
15.   /* DMA1_Stream3_IRQn interrupt configuration */
    
16.   HAL_NVIC_SetPriority(DMA1_Stream3_IRQn, 0, 0);
    
17.   HAL_NVIC_EnableIRQ(DMA1_Stream3_IRQn);
    
18.   /* DMA1_Stream6_IRQn interrupt configuration */
    
19.   HAL_NVIC_SetPriority(DMA1_Stream6_IRQn, 0, 0);
    
20.   HAL_NVIC_EnableIRQ(DMA1_Stream6_IRQn);
    : h3 ]" D7 @$ F( K; ^
21.   /* DMA2_Stream1_IRQn interrupt configuration */
    # c2 P, Y+ d# X5 e& j, i# x
22.   HAL_NVIC_SetPriority(DMA2_Stream1_IRQn, 0, 0);
    
23.   HAL_NVIC_EnableIRQ(DMA2_Stream1_IRQn);
    
24.   /* DMA2_Stream6_IRQn interrupt configuration */
    / Z$ {7 {8 Z7 q& X5 ^6 ^0 X- |
25.   HAL_NVIC_SetPriority(DMA2_Stream6_IRQn, 0, 0);
    
26.   HAL_NVIC_EnableIRQ(DMA2_Stream6_IRQn);
    0 [( a, ]0 i% z3 |/ }
27. 
    6 A0 ]( y9 r0 P- Z8 A
28. }
    
29. </font>

复制代码

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

1. <font face="微软雅黑" size="3">void MX_USART6_UART_Init(void)
   
2. {
   ! M9 r  X4 I8 D4 ]6 l5 ~! z, i
3. 
   
4.   huart6.Instance = USART6;
   8 k; B2 x! U! p* P& H  P
5.   huart6.Init.BaudRate = 9600;
     w- A8 u% ^+ Q! e; k' l' {0 a
6.   huart6.Init.WordLength = UART_WORDLENGTH_8B;
   # @2 R* R  {8 |
7.   huart6.Init.StopBits = UART_STOPBITS_1;
   0 a; V( }! f& z1 a: p% |9 T* T
8.   huart6.Init.Parity = UART_PARITY_NONE;
   , m- D* v2 l% D' H! a, L
9.   huart6.Init.Mode = UART_MODE_TX_RX;
   
10.   huart6.Init.HwFlowCtl = UART_HWCONTROL_NONE;
    : C) E1 q7 ?8 g/ T$ t, M
11.   huart6.Init.OverSampling = UART_OVERSAMPLING_16;
    
12.   if (HAL_UART_Init(&huart6) != HAL_OK)
    ( ]+ O% R, `6 j; D% F6 m7 O* {
13.   {
    ' Y5 F/ u. i2 |" f0 c/ l) c; ^
14.     Error_Handler();
    
15.   }
    7 F" I2 }1 \1 j, o7 l- F! M
16. 
    5 S1 \: `5 h) [0 X& `
17. }</font>

复制代码

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

2 u( o+ y( L. U
2 d* h  i, S3 A; `
+ i0 o% T$ t- R% z在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">
   
2. void USR_UartInit(void)
   
3. {
   * W0 {/ d4 x  r  F% z% |
4.     test1++;
   0 Z: ]* C* C1 T, A- N
5. 
   
6.     uart8RxLength = 0;   
   9 a5 S% A, z" g! w  v' a
7.     HAL_UART_Receive_DMA(&huart8, uart8Rx, buffer_size);
   
8.     uart7RxLength = 0;   
   
9.     HAL_UART_Receive_DMA(&huart7, uart7Rx, buffer_size);
   & U. a$ Q" {1 }* w
10.     uart6RxLength = 0;   
    
11.     HAL_UART_Receive_DMA(&huart6, uart6Rx, buffer_size);   
    ; u' S* R1 q6 \# F/ ~
12. 
    
13.     __HAL_UART_ENABLE_IT(&huart8, UART_IT_IDLE);     
    - Y6 j, q) l4 Z+ G( Y1 u
14.     __HAL_UART_ENABLE_IT(&huart7, UART_IT_IDLE);   
    
15.     __HAL_UART_ENABLE_IT(&huart6, UART_IT_IDLE);   
    
16. }
    
17. void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
    1 X7 h# J. Z! t
18. {
    
19. 
    
20.     HAL_UART_Receive_DMA(&huart8, uart8Rx, buffer_size);
    , p$ w* u: h8 `5 K! M6 |
21.     HAL_UART_Receive_DMA(&huart7, uart7Rx, buffer_size);
    3 t0 s% z+ G3 A/ h) L0 W/ I% T( m
22.     HAL_UART_Receive_DMA(&huart6, uart6Rx, buffer_size);
    
23.     __HAL_DMA_ENABLE(&hdma_uart8_rx);
    
24.     __HAL_DMA_ENABLE(&hdma_uart7_rx);
    
25.     __HAL_DMA_ENABLE(&hdma_usart6_rx);
    
26.     test2++;
    
27. }
    
28. uint8_t RxLenHi, RxLenlo;  
    9 E% u' ]/ r$ P  N# s
29. void HAL_UART_IdleCpltCallback(UART_HandleTypeDef *huart)
    
30. {
    
31.     __HAL_UART_CLEAR_IDLEFLAG(huart);
    
32. 
    
33.         if( huart == &huart8)
    3 B$ D0 N* t8 w, y
34.         {
    
35.             test3++;
    
36.             HAL_UART_Receive_DMA(&huart8, uart8Rx, buffer_size);  
    7 A* @. \7 J6 E! _; E8 i' c
37. 
    5 k8 F2 a/ I- E
38.             uart8RxLength = buffer_size-__HAL_DMA_GET_COUNTER(&hdma_uart8_rx);     
    
39.             if(uart8Rx[0]=='@'
    
40.             &&uart8Rx[1]=='c'
    0 J2 J, J: Y9 f7 `
41.             &&uart8Rx[2]=='m'
    3 ^0 ~2 d4 O' o4 k
42.             &&uart8Rx[3]=='d')
    $ a* e4 l: y, {  v$ _" r
43.             {
    
44.                 if(!SERDEB_CmdValid())
    7 H6 I) Y' I0 N4 q5 a+ r
45.                     SERDEB_PushCmd(uart8Rx, uart8RxLength);
    ) B3 k2 q0 x6 y( V( F) A- n
46.             }
    4 a: l+ A9 H3 J
47.             __HAL_DMA_DISABLE(&hdma_uart8_rx);
    & _% c0 e4 V$ k8 T0 T  U
48.             HAL_GPIO_TogglePin(GPIOG,GPIO_PIN_8);   
    ! Q/ f) S* T2 k6 H( C( l
49.         }
    
50. 
    
51.           if( huart == &huart7)
    
52.         {        
    
53.             __HAL_DMA_DISABLE(&hdma_uart7_rx);  
    
54.             HAL_UART_Receive_DMA(&huart7, uart7Rx, buffer_size);
    3 l0 @6 A9 e0 G0 N! ~8 p
55.             __HAL_DMA_DISABLE(&hdma_uart7_rx);
    
56.         }
    ' ?0 i3 m5 y, s) u$ ^3 Z+ T5 A
57. 
    
58.         if( huart == &huart6)
    
59.         {
    
60.             __HAL_DMA_DISABLE(&hdma_usart6_rx);
    , b0 _& C: Y0 L+ G/ Z/ E# h" _8 n2 j/ l$ \
61.             HAL_UART_Receive_DMA(&huart6, uart6Rx, buffer_size);
    1 \( Q9 L2 D; N3 h7 Z
62.             __HAL_DMA_DISABLE(&hdma_usart6_rx);
    0 J8 h3 P5 s" ^% c% i3 `- h$ g7 |* ]
63.         }
    
64. 
    " b/ y% C0 x2 v2 j8 d3 ?" u9 c8 w
65. }</font>

复制代码

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

: |5 @8 \  q' W+ h( Z( V$ B

$ X" g; @; s2 o: S, ~+ ?$ |4 ^% ^