1、串口通信的格式：起始位（1）------数据位（8位/7位）-------校验位（0/1）--------停止位（1）
/ j6 I1 g* h/ f: N      因为我们很少用到校验位，所以，校验位可有可无
2、波特率， 意思是每秒发送多少个bit，单位是 bit/s， 我们常用bps来表示， 例如 9600bps， 4800bps， 2400bps

中断调用函数
void Uart_Interrupt(void)
{
8 h+ _  Z* }: |# b! j1 n0 |2 _        uint8_t i;

  u: j9 Y# a. ~1 _9 Z        if(1 == flag_rxd_finish)
        {
" _9 d8 B$ Q: \  o                flag_rxd_finish = 0;
                flag_rxd_txd = 0;
0 @# c* _1 t# W4 U. j                for(i = 0;i < TxXKCnt; i++)
0 g" a7 c. H5 m) [6 p$ t$ H+ M                {
                        UartTxBuff = UartRxBuff;
                }
        }
8 g7 E: @% {/ [9 A
: x! G3 n. n. O2 d6 \4 ?& }5 m, Y& M        if(1 == flag_rxd_txd)         // 为1，接收
- [+ p+ t' z( D  n2 i$ j        {
                Uart_Rx_Byte();
' u. _2 K! H3 s5 i( N7 I        }
        else                                        // 为0，发送
- T) l) V& N$ ^        {
                Uart_Tx_Byte();
: t0 p3 D  }4 p  p        }
3 `, L) q* t$ ?! s. ?}


- X# z& R3 V: M8 _6 q接收函数

• static void Uart_Rx_Byte(void)
• {
•         static uint8_t RxBitNum;        //接收位计数
•         static uint8_t OverTime;         //接收超时计时器
•         static uint8_t RxByteBuff;         //一字节数据接收缓存
•         if(1 == Uart_RXD_Status())
•         {
•                 OverTime++;
•         }
•         else
•         {
•                 OverTime = 0;
•         }
•         if(OverTime > 44)
•         {
•                 OverTime = 0;
•                 RxByteIndex = 0;
•                 RxBitNum = 0;
•         }
•         if((1 == Uart_RXD_Status()) && (0 == RxBitNum))
•         {
•                 RxSampFreq = 0;
•         }
•         else
•         {
•                 RxSampFreq++;
•         }
•         if(1 == RxSampFreq)
•         {
•                 if(0 == RxBitNum)
•                 {
•                         if(0 == Uart_RXD_Status())
•                         {
•                                 RxByteBuff = 0;
•                                 RxBitNum++;
•                         }
•                 }
•                 else if((RxBitNum > 0) && (RxBitNum < 9))
•                 {
•                         if(1 == Uart_RXD_Status())
•                         {
•                                 RxByteBuff = RxByteBuff | (1 << (RxBitNum - 1));
•                         }
•                         RxBitNum++;
•                 }
•                 else if(9 == RxBitNum)
•                 {
•                         if(1 == Uart_RXD_Status())
•                         {
•                                 RxBitNum = 0;
•                                 if(0x0d != RxByteBuff && 0x0a != RxByteBuff)
•                                 {
•                                         UartRxBuff[RxByteIndex] = RxByteBuff;
•                                         RxByteIndex++;
•                                         if(RxByteIndex > 63)
•                                         {
•                                                 RxByteIndex = 0;
•                                         }
•                                 }
•                                 else
•                                 {
•                                         TxXKCnt = RxByteIndex;
•                                         RxByteIndex = 0;
•                                         flag_rxd_finish = 1;
•                                 }
•                         }
•                 }
•                 else
•                 {
•                         RxBitNum = 0;
•                 }
•         }
•         else if(RxSampFreq > 3)
•         {
•                 RxSampFreq = 0;
•         }
• }
  

$ `$ q. n- G% u$ J$ I% E8 a发送函数

• static void Uart_Tx_Byte(void)
• {
•         static bool SendFinish = 1;        //发送完成标志
•         static u8 TxSampFreq = 0;                //发送计数        采样4次
•         static u8 BitNum = 0;                        //位计数
•         static u8 ByteLock;                         //发送字节锁定（防止在发送途中 发送数字被改变）
•         static u8 TxIndex = 0;                        //当前发送索引
•         if(SendFinish)
•     {
•        SendFinish = 0;
•        RxSampFreq = 0;
•        BitNum = 0;
•        if(TxIndex < TxXKCnt)        //控制发送的字节
•        {
•           ByteLock = UartTxBuff[TxIndex];
•           TxIndex++;
•           RxByteIndex = 0;
•        }
•        else if(TxIndex == TxXKCnt)
•        {
•           ByteLock = '\n';
•           TxIndex++;
•           RxByteIndex = 0;
•        }
•        else
•        {
•           flag_rxd_txd = 1;
•           SendFinish = 0;
•           TxIndex = 0;
•        }
•     }
•     if(++TxSampFreq > 3)
•     {
•         if(BitNum == 0)                             //起始位
•         {
•             Uart_TXD_Out_LOW();
•             BitNum++;
•         }
•         else if((BitNum >0) && (BitNum < 9))        //数据位
•         {
•             if(0x01 & (ByteLock >> (BitNum-1)))     //先发低位
•             {
•                 Uart_TXD_Out_HIGH();
•             }
•             else
•             {
•                 Uart_TXD_Out_LOW();
•             }
•             BitNum++;
•         }
•         else if(BitNum == 9)                        //结束码
•         {
•             Uart_TXD_Out_HIGH();
•             SendFinish = 1;
•             BitNum = 0;
•         }
•         TxSampFreq = 0;
•     }
• }
  

% I9 @0 `) r% H2 G3 J# ^
: w- ~1 ^, l4 y+ |  B7 O. }

0 X5 x  |, `8 @" T
- |9 M0 K: G2 l2 Y' d

! [3 }8 r- Q& r

自顶                        

谢谢

顶起。。。

我试了一下此函数，只能发不能收，是不是中断函数放错了位置？

ranran2014 发表于 2015-7-28 10:44
( m& f5 m) n7 N: [7 B/ p, A0 y我试了一下此函数，只能发不能收，是不是中断函数放错了位置？

* f' k! g. Z' O0 B& H& R我的不能发也不能收。请问你的发送是怎么调的

这是GPIO模拟串口？感觉不是的。。。

有硬件也不用？

楼主不错。
+ D4 |2 m& K# n$ k% R/ D

JackieLaura 发表于 2015-11-18 14:16
这是GPIO模拟串口？感觉不是的。。。

是GPIO模拟串口，楼主说明得不够详细，第一个函数UART_Interrupt给人造成了误解

zhoupxa 发表于 2015-11-24 08:50
是GPIO模拟串口，楼主说明得不够详细，第一个函数UART_Interrupt给人造成了误解 ...

我觉得这并不会误解，第一，这个不是stm8的中断函数规则命令，自然不会跟stm8本身的中断硬件冲突，
% E5 v: P* s) [第二，这个的确是我的模拟串口需要运行的interrupt函数，所以，我觉得这是个人理解的问题