独闷闷网

标题: 基于STM8的模拟串口接收与发送 [打印本页]
作者: 电子Inc    时间: 2015-1-1 15:34
标题: 基于STM8的模拟串口接收与发送
本帖最后由 电子Inc 于 2015-1-1 15:45 编辑

       前言：在我们日常生活中，为了减少成本，在通信中往往使用串口通信，而我们使用到的单片机，也集成了USART这一模块，但是， 当需要到多个串口工作时，这单片机集成的1个或者两个串口
却远远不够需求，所以，我们得使用模拟得手段来给单片机实现多个串口。
       这里，我们使用STM8来完成这一实验：

1、串口通信的格式：起始位（1）------数据位（8位/7位）-------校验位（0/1）--------停止位（1）
      因为我们很少用到校验位，所以，校验位可有可无
2、波特率， 意思是每秒发送多少个bit，单位是 bit/s， 我们常用bps来表示， 例如 9600bps， 4800bps， 2400bps
3、采样频率， 为了保持精度，减少接收数据和发送数据的误差，我们把采样次数增多，利用多次采样次数中的固定位置采样

思路：以STM8位基准，我们设定此时的波特路为9600bps，利用定时器中断产生时间间隔， 1秒传送9600bit相当于 1bit需要104us，而我们这里采样次数取4次，定时时间是26us
          PS：因为STM8使用内部晶振，难免出现误差，所以在现实使用中，如果使用26us间隔读取，往往出现数据错误，在实际应用中，我采用24~25us的间隔，数据接收发送正确

实验工具：STM8S103FP6最小系统版， ST-linkV2， PL2303转串口模块

步骤1、算出定时初值， STM8内部晶振为16M， 采用8分频后震荡周期 =8/16 = 0.5us，所以发送或接受以为数据的采样定时器初值应为48~52；
下面为定时器初始化代码：void Tim2_Init(void)
{
        TIM2_DeInit();
        TIM2_TimeBaseInit(TIM2_PRESCALER_8, 48);
        TIM2_ClearFlag(TIM2_FLAG_UPDATE);
        TIM2_ITConfig(TIM2_IT_UPDATE, ENABLE);
        TIM2_Cmd(ENABLE);
}

步骤2、RXD和TXD初始化，RXD为上拉输入，TXD位推挽输出高电平
  1. #define Uart_RXD_Init()                       GPIO_Init(GPIOD,GPIO_PIN_6,GPIO_MODE_IN_PU_NO_IT)
  2. #define Uart_RXD_Status()                  GPIO_ReadInputPin(GPIOD,GPIO_PIN_6)

  4. #define Uart_TXD_Init()                        GPIO_Init(GPIOD,GPIO_PIN_5,GPIO_MODE_OUT_PP_HIGH_FAST)
  5. #define Uart_TXD_Out_HIGH()             GPIO_WriteHigh(GPIOD,GPIO_PIN_5)
  6. #define Uart_TXD_Out_LOW()             GPIO_WriteLow(GPIOD,GPIO_PIN_5)
复制代码
步骤3、中断调用函数
void Uart_Interrupt(void)
{
        uint8_t i;

        if(1 == flag_rxd_finish)
        {
                flag_rxd_finish = 0;
                flag_rxd_txd = 0;
                for(i = 0;i < TxXKCnt; i++)
                {
                        UartTxBuff = UartRxBuff;
                }
        }

        if(1 == flag_rxd_txd)         // 为1，接收
        {
                Uart_Rx_Byte();
        }
        else                                        // 为0，发送
        {
                Uart_Tx_Byte();
        }
}


步骤4、接收函数
  1. static void Uart_Rx_Byte(void)
  2. {
  3.         static uint8_t RxBitNum;        //接收位计数
  4.         static uint8_t OverTime;         //接收超时计时器
  5.         static uint8_t RxByteBuff;         //一字节数据接收缓存

  7.         if(1 == Uart_RXD_Status())
  8.         {
  9.                 OverTime++;
  10.         }
  11.         else
  12.         {
  13.                 OverTime = 0;
  14.         }

  16.         if(OverTime > 44)
  17.         {
  18.                 OverTime = 0;
  19.                 RxByteIndex = 0;
  20.                 RxBitNum = 0;
  21.         }

  23.         if((1 == Uart_RXD_Status()) && (0 == RxBitNum))
  24.         {
  25.                 RxSampFreq = 0;
  26.         }
  27.         else
  28.         {
  29.                 RxSampFreq++;
  30.         }

  32.         if(1 == RxSampFreq)
  33.         {
  34.                 if(0 == RxBitNum)
  35.                 {
  36.                         if(0 == Uart_RXD_Status())
  37.                         {
  38.                                 RxByteBuff = 0;
  39.                                 RxBitNum++;
  40.                         }
  41.                 }
  42.                 else if((RxBitNum > 0) && (RxBitNum < 9))
  43.                 {
  44.                         if(1 == Uart_RXD_Status())
  45.                         {
  46.                                 RxByteBuff = RxByteBuff | (1 << (RxBitNum - 1));
  47.                         }
  48.                         RxBitNum++;
  49.                 }
  50.                 else if(9 == RxBitNum)
  51.                 {
  52.                         if(1 == Uart_RXD_Status())
  53.                         {
  54.                                 RxBitNum = 0;
  55.                                 if(0x0d != RxByteBuff && 0x0a != RxByteBuff)
  56.                                 {
  57.                                         UartRxBuff[RxByteIndex] = RxByteBuff;
  58.                                         RxByteIndex++;
  59.                                         if(RxByteIndex > 63)
  60.                                         {
  61.                                                 RxByteIndex = 0;
  62.                                         }
  63.                                 }
  64.                                 else
  65.                                 {
  66.                                         TxXKCnt = RxByteIndex;
  67.                                         RxByteIndex = 0;
  68.                                         flag_rxd_finish = 1;
  69.                                 }
  70.                         }
  71.                 }
  72.                 else
  73.                 {
  74.                         RxBitNum = 0;
  75.                 }
  76.         }
  77.         else if(RxSampFreq > 3)
  78.         {
  79.                 RxSampFreq = 0;
  80.         }
  81. }
复制代码
步骤5、发送函数
  1. static void Uart_Tx_Byte(void)
  2. {
  3.         static bool SendFinish = 1;        //发送完成标志
  4.         static u8 TxSampFreq = 0;                //发送计数        采样4次
  5.         static u8 BitNum = 0;                        //位计数
  6.         static u8 ByteLock;                         //发送字节锁定（防止在发送途中 发送数字被改变）
  7.         static u8 TxIndex = 0;                        //当前发送索引

  9.         if(SendFinish)
  10.     {
  11.        SendFinish = 0;
  12.        RxSampFreq = 0;
  13.        BitNum = 0;

  15.        if(TxIndex < TxXKCnt)        //控制发送的字节
  16.        {
  17.           ByteLock = UartTxBuff[TxIndex];
  18.           TxIndex++;
  19.           RxByteIndex = 0;
  20.        }
  21.        else if(TxIndex == TxXKCnt)
  22.        {
  23.           ByteLock = '\n';
  24.           TxIndex++;
  25.           RxByteIndex = 0;
  26.        }
  27.        else
  28.        {
  29.           flag_rxd_txd = 1;
  30.           SendFinish = 0;
  31.           TxIndex = 0;
  32.        }
  33.     }

  35.     if(++TxSampFreq > 3)
  36.     {
  37.         if(BitNum == 0)                             //起始位
  38.         {
  39.             Uart_TXD_Out_LOW();
  40.             BitNum++;
  41.         }
  42.         else if((BitNum >0) && (BitNum < 9))        //数据位
  43.         {
  44.             if(0x01 & (ByteLock >> (BitNum-1)))     //先发低位
  45.             {
  46.                 Uart_TXD_Out_HIGH();
  47.             }
  48.             else
  49.             {
  50.                 Uart_TXD_Out_LOW();
  51.             }
  52.             BitNum++;
  53.         }
  54.         else if(BitNum == 9)                        //结束码
  55.         {
  56.             Uart_TXD_Out_HIGH();
  57.             SendFinish = 1;
  58.             BitNum = 0;
  59.         }
  60.         TxSampFreq = 0;
  61.     }
  62. }
复制代码



作者: jianhong_wu    时间: 2015-1-1 18:01
非常漂亮。我仔细看了这个思路，利用定时器控制时序应该比delay延时更加精确，果断加精。
作者: 电子Inc    时间: 2015-1-1 18:06
jianhong_wu 发表于 2015-1-1 18:01
非常漂亮。我仔细看了这个思路，利用定时器控制时序应该比delay延时更加精确，果断加精。

基本我对delay产生非常大的厌恶感，如非必要，绝对不用，我的裸编程思想都是：前后台



欢迎光临 独闷闷网 (http://dumenmen.com/) Powered by Discuz! X3.2