普通IO口模拟串口通信

• 串口通信协议　　
• 
  5 ^8 _# a9 t2 R

• 串口传输 默认 波特率9600 1起始位 1停止位 其他0 数据位是8位（注意图上的给错了）。
• 传输时，从起始位开始，从一个数据的低位（LSB）开始发送，如图从左向右的顺序，对电平拉高或拉低，最后停止位时拉高。
• 波特率大小，改变延时时间即可。例如9600 波特率    根据公式 ： 1/9600=0.000104s（大致） 也就是说每发送1bit延时104us （下面我用9600波特率来说，代码用的是19200）
• 串口发送       将电平拉低 延时104us（视为 起始位 0   传输数据正式开始）  其中数据我发送的是16进制数据（8bit  一字节  例如10001000）  将想要发的数据按照二进制的‘0’‘1’高低电平的方式，每发送1bit 延时104us   直到发送完到终止位 将电平拉高视为一包数据传输结束。（根据需求更改即可）
• 串口接收    （稍微麻烦一些） 两种方法：第一种可以用定时中断，每隔104us开启一次定时中断，中断函数内进行高低电平判断，将这些bit存储最后转换成需要的数据。第二种，用外部中断处理函数，外部中断设置同时开启上升沿下降沿，思路：根据上升下降的电平跳变分析。比如说，触发外部中断后检测电平高低，记录一下当前时间，然后再进入外部中断后 计算出总共几个bit   （两个沿跳变之间的时间 =现在记录的时间 — 之前记录的时间        bit=这个时间/104us）  ，知道这个就可以转换数据了。
• 定时中断逻辑相对外部中断而言简单好写，但是数据多的时候准确率下降很多，容易丢数据（因为定时中断毕竟用计时开启中断，不可能时间准确每104us开启一次，数据一多时间误差大，自然丢包。可以尝试每发一串数据，重新计时校准一次）。外部中断较为准确，检测的高低电平跳变较为明显唯一，一个跳变就是一个数据，只是分析情况比较多。
  

1. //IO模拟串口初始化 1 void IRrec_Init(){
   , g, X# }/ n/ [! Z6 h! |) `1 C
2. 2
   
3. 3
   
4. 4     EXTI_InitTypeDef EXTI_InitStructure;
   " @0 \9 x3 I8 f' X% v( u" n
5. 5     NVIC_InitTypeDef NVIC_InitStructure;
   1 h) r$ w( \: R/ U- v" V
6. 6     GPIO_InitTypeDef GPIO_InitStructure;
   
7. 7
   
8. 8     RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC,ENABLE); //使能GPIOC时钟
   ; _# K, e+ T. a. k/ f( a
9. 9
   
10. 10
    ) @6 d1 x; k; m
11. 11     //IR TX C9 使能
    & _' z# X# S- z
12. 12     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;
    
13. 13     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;   
    - j: S/ J, v, a- e, S
14. 14     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    
15. 15     GPIO_Init(GPIOC, &GPIO_InitStructure);
    
16. 16     GPIO_SetBits(GPIOC, GPIO_Pin_9);//  引脚拉高
    
17. 17            
    ' m1 ]- s! \. P0 ]" ^* l
18. 18
    
19. 19     //IR RX C8
    ' K2 C. h/ `1 M& F& h6 @
20. 20     RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO,ENABLE);
    - n! P8 E# p$ [
21. 21     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_8;
    & T$ h5 y; y; w. }
22. 22     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
    2 N1 P" C) @1 d$ ~. @: x4 |" l
23. 23     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    
24. 24     GPIO_Init(GPIOC, &GPIO_InitStructure);
    
25. 25     GPIO_EXTILineConfig(GPIO_PortSourceGPIOC,GPIO_PinSource8);
    4 g* d2 D$ n7 J9 D4 _. O. o
26. 26
    - Z. q/ j1 N6 V  p- W: `* k, r
27. 27     EXTI_InitStructure.EXTI_Line=EXTI_Line8;
    
28. 28     EXTI_InitStructure.EXTI_Mode=EXTI_Mode_Interrupt;
    , s9 Y# G1 f1 g8 E/ A
29. 29     EXTI_InitStructure.EXTI_Trigger=      
    
30. 30     EXTI_Trigger_Rising_Falling;
    
31. 31     EXTI_InitStructure.EXTI_LineCmd=ENABLE;
    
32. 32     EXTI_Init(&EXTI_InitStructure);
    
33. 33     
    
34. 34     NVIC_InitStructure.NVIC_IRQChannel=EXTI9_5_IRQn;
    7 k. _' a- p+ T3 G) B) V/ V! K- T8 D
35. 35     NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=2;
    
36. 36     NVIC_InitStructure.NVIC_IRQChannelSubPriority=2;
    
37. 37     NVIC_InitStructure.NVIC_IRQChannelCmd=ENABLE;
    % m9 a6 H: g  d% L: X! p/ U
38. 38     NVIC_Init(&NVIC_InitStructure);
    
39. 39         
    
40. 40 }

复制代码

1. void IR_SendByte(u8 val)//发送bit位
   - {; O5 S1 {1 Y7 k
2. {
   
3.     u16 i;
   4 q, ]6 o& D& ^1 i+ L7 [. H
4. 
   1 ~7 ~9 ^- q0 c  [7 f
5.     IRSEND=0;//拉低 开始传输
   
6.     SysTick_Delay_Us(53);//波特率根据延时在设置  19200波特率
   
7. 
   % R1 y5 [! ~+ ~6 s) v) E( Q
8.     for(i=0;i<8;i++)
   " m# A/ ~! L0 k  [) }& w  J
9.     {
   0 |' c/ R! a3 {9 Q
10.         if(val&0x1)
    
11.         {
    ! F/ N7 g0 [: W
12.             IRSEND=1;
    
13.         }
    ! V) u, g( m6 i% V" L7 ]; D
14.         else
    ; [8 J( I% ?# [* v5 Q8 c- r
15.         {
    
16.             IRSEND=0;
    
17.         }
    % P1 M- H* Q4 L& o. ?
18. 
    * p1 g5 L, f- r6 f
19.         val>>=1;
    ' g. K, t- A" v3 ^( x' Y
20.         SysTick_Delay_Us(53);
    
21.     }
    # j" a( a$ `2 d4 E
22. 
    / S4 |# K; X0 W4 z3 K/ X
23.     IRSEND=1;
    * e2 C9 i$ ^5 F+ ^; N3 I, o
24.     SysTick_Delay_Us(53);
    & n3 W5 N2 x# o+ d9 O
25. }
    
26. 
    
27. 
    3 ^9 [2 J! y+ Z
28. void IR_SendStr(u8*st,u16 len){//在这填入16位数据即可
    
29.     int i=0;
    
30.     while ((len--)!=0)
    
31.     {
    # Q" h) L$ U; g& V( \4 ^! _" Q
32.         IR_SendByte(st[i]);
    
33.         i++;
    
34.     }
    
35. 
    
36. }

复制代码

1. u8 IRREC_RX_BUF[64]={0};    //接收缓冲,最大64个字节.
   
2.     //接收到的数据长度
   
3.     u8 IRREC_RX_CNT=0;
   
4. 
   
5. char rebit=stopbit;//记录接收一个字节的二进制位所处何种位置
   1 k& G5 b( _0 r& e9 T- b
6. u8 Recev[8]={0};//记录接收的一个字节的二进制流
   
7. 
   
8. static volatile unsigned long long m_rx_previous_time = 0;//上一次进入中断时间
   5 I' g1 K8 `2 U( Y" c& u
9. static volatile unsigned char m_rx_begin_f = 0;//开始一个字节的接收标志 0-无数据开始接收 1-有数据开始接收
   
10. void EXTI9_5_IRQHandler(void){
    
11. 
    
12.     if(EXTI_GetITStatus(EXTI_Line8)!=RESET)
    ! j" v1 ]' u! B- k1 M- q" M
13.     {
    - o& s* k; W/ {  [( E2 V/ [, Y
14.         unsigned char skip_index = 0;
    
15.         unsigned char i = 0;
    
16.         unsigned char temp_bin = 0;//用于记录二进制值
    
17.         unsigned long long current_time = sys_micros();//记下此刻时间
    , P2 e; k. j0 S8 x7 l+ s/ X
18.         unsigned short interval_time = current_time - m_rx_previous_time;//计算一个状态持续的时长
    0 l, B/ b7 S3 ^: e; W
19.         m_rx_previous_time = current_time;//为下次计算时长做准备
    
20. 
    
21.         //当前未开始一个字节的接收且此时为下降沿
    
22.         if(rebit == 10)//10 当数据不合法时或者结束传输时 rebit值设为10
    
23.         {
    
24.             if(!PCin(8))//下降沿
    
25.             {
    # e: \0 m0 k& R. v5 K$ v
26.                 rebit = 0;//记下开始接收
    1 D% l  }+ w# |" @
27.                 m_rx_begin_f = 1;
    
28.                 debug_led(1,LED_TOGGLE);
    
29.             }
    $ [; w* Y$ y7 O6 J* E) F7 \
30.         }
    1 ~, _) Z' r+ S. o
31.         //已经开始接收
    1 z, h; }5 p1 L5 T
32.         else
    
33.         {
    
34.             //上一状态为起始位
    
35.             if(!rebit)//起始位0
    - V- k* X: v9 R5 n9 B2 r
36.             {
    
37.                 //计算二进制数据的个数
    1 b. M9 @- u" d  s) A
38.                 skip_index = (interval_time/50)-1;
    ! @! h7 B# O$ V$ p4 C+ q; `5 p+ p
39. 
    5 A- D; \9 w% w4 P! z5 X+ j
40.                 //个数合法
    
41.                 if(skip_index <= 9)
    
42.                 {
    
43.                     //根据状态保持时间更新接收值
    ( b' |" G3 B( w' o" w" s" [! n5 j
44.                     for(i = 0;i < skip_index;i++)
    
45.                     {
    ) {5 j( H# Q0 R! Z0 p: ?/ i/ I
46.                         Recev[i] = 0;
    $ a( ~# h- K% l$ n6 t
47. 
    
48.                     }
    2 ~8 H# h  r5 ]+ Y# n' x
49. 
    . u: w5 p, `. o) J
50.                     //更新接收二进制位的下标
    
51.                     rebit = skip_index;
    ; q( n8 x/ ]! }: z, W. H
52. 
    / o$ d* P5 e- @  S
53.                 }
    7 G+ O6 \3 [# x6 d) `
54.                 //不合法-重新接收
    & L4 Q" |$ `; D$ r# L
55.                 else
    5 ]+ c2 s, ~; @  J. o* d& d
56.                 {
    
57.                     rebit = 10;
    
58.                     m_rx_begin_f = 0;
    
59. 
    
60. 
    8 ^' u3 q, \: r
61.                 }
    
62.             }
    / a! r) a7 Q( o. }- N0 [' V; `. W
63.             //上一状态为数据位
    + j1 e, D$ C/ p
64.             else
    
65.             {
    
66.                 //计算二进制数据的个数
    * M7 n% h7 O+ d5 d6 L0 V
67.                 skip_index = interval_time/50;
    
68. 
    9 E' q1 O4 I; b$ K6 T* }9 l
69.                 //数据不合法-重新接收
    3 n* |# K& W% n/ E' F: d2 x
70.                 if((skip_index+rebit) > 9)//所处位置+数据个数 判断数据是否超10 合法判断
    
71.                 {
    
72.                     //printf("skip_index %d   rebit=%d \r\n",skip_index,rebit);
    
73.                     rebit = 10;
    
74.                     m_rx_begin_f = 0;
    
75.                     debug_led(3,LED_TOGGLE);
    
76.                 }
    2 G) @1 y; e# p4 T! W' h
77.                 //数据合法
    
78.                 else
    
79.                 {
    
80.                     //当前为高电平
    : Q2 N0 `( W3 M4 _
81.                     if(PCin(8))
    ) a( \8 O0 O: I; y- o
82.                     {
    
83.                      temp_bin = 1;//0
    , }; K: A8 C" f
84.                     }
    
85.                     else
    
86.                     {
    " f0 r0 Z3 M' E+ V& y8 p
87.                      temp_bin = 0;//1 change
    ) \9 _( b0 ]% Y
88.                     }
    
89.                     debug_led(2,LED_TOGGLE);
    2 d1 F, r' h! j# a& V! B& {8 O
90.                     for(i = 0;i < skip_index ;i++)//根据几个数据 给予相应的位
    
91.                     {
    / q! W: x. A+ g8 J  s- J
92.                         Recev[rebit+i+1] = temp_bin;//change +1
    % N) e2 |/ d% |# @  H
93.                         rebit++;
    
94. 
    
95.                     }
    
96.                 }
    
97. 
    
98.                 //数据已接收至结束位
    
99.                 if(rebit >= 8 )//=8>?
    - `! I+ M- s9 }' A
100.                 {
     
101.                     if(IRREC_RX_CNT < 64)
     7 v, O) V. h/ |5 {
102.                     {
     
103.                         IRREC_RX_BUF[IRREC_RX_CNT++]     = (Recev[7] << 7) |(Recev[6] << 6)| (Recev[5] << 5)| (Recev[4] << 4)| (Recev[3] << 3) |(Recev[2] << 2) |(Recev[1] << 1) |Recev[0];
     
104. 
     
105.                     }
     
106.                     rebit = 10;
     
107.                     m_rx_begin_f = 0;
     
108. 
     - I% B/ m5 R1 Q, x. S: m$ V" ]4 g
109. 
     ( X1 T& _& y/ u/ v& F
110.                 }
     ( X" ^3 [: n1 \2 H. T" w6 ]
111. 
     
112.             }
     
113.         }
     
114. 
     0 W# T# C" l$ \7 m+ i4 K( ^; d, D- d) C
115. 
     
116.         #endif
     1 W1 U8 {2 s8 B& s; a1 E
117.         EXTI_ClearITPendingBit(EXTI_Line8);//清除中断挂起标志位
     2 M( V& o6 ?) H% A
118. 
     - G9 R8 ?8 e( a! Q# U& O5 J; _/ P; f
119.     }
     ( V/ `1 ~# g6 N* u' A# ]  ?1 P
120. 
     
121. }

复制代码