@richey 2022-10-27T01:40:31.000000Z 字数 25329 阅读 3367

物联网创新设计实践讲义-第二章-单片机软件设计实践

`物联网创新设计实践` `讲义` `单片机软件设计实践`

物联网创新设计实践讲义-第二章-单片机软件设计实践

2.1 基于协作式调度的单片机软件设计基础

2.1.1 C51基础

https://www.zybuluo.com/richey/note/1262297

2.1.2 中断系统、定时/计数器

https://www.zybuluo.com/richey/note/1263469

2.1.3 协作式调度器

2.1.3.1 考虑这样一个常见的系统

周期性任务：
- 每0.5s发光二极管闪烁一次；
- 每50ms检测是否有键按下；
- 每200ms刷新一次LED数码管显示器；
- 每100ms采集一次开关量输入信号；
- 每100ms采集一次A/D输入信号。
非周期性任务
- 通信处理任务;
- 控制任务。

2.1.3.2 经典方法：前后台系统（超级循环）

前后台系统
- 后台：非中断驱动的任务：如控制任务
- 前台：中断驱动的任务
- 周期性任务都由硬件定时器驱动。
- 周期性任务在中断服务子程序中完成。

2.1.3.4 协作式调度器

问题
- 每个任务需要一个定时器；
- 中断源太多使系统不可靠性降低，某些中断可能会被漏掉；
如何解决以上问题？
- 信号量的使用：
  用一个定时器产生时标，所有周期性任务共用该定时器，当某任务定时时间到，发出信号。
- 协作式调度（将周期性任务也当做后台任务）
  前台任务：中断驱动的任务，如串行数据的接收
  原则：中断尽可能短，只发信号，将业务逻辑处理函数放在后台运行。
  
  2.1.3.5 协作式调度器举例：四个周期性任务的例子

#include <reg51.h>
#include "common.h"
#define FOSC 11059200ul
#define T0_H (65536-(10*FOSC)/(12*1000))/256 
#define T0_L (65536-(10*FOSC)/(12*1000))%256 
uint16_t tick = 0;
bit bFlag1 = 0;
bit bFlag2 = 0;
bit bFlag3 = 0;
bit bFlag4 = 0;
void initSys();
sbit LED0 = P1^0;
sbit LED1 = P1^1;
sbit LED2 = P1^2;
sbit LED3 = P1^3;
void main(){
    initSys();
    while(TRUE){
        if(bFlag1){
            bFlag1 = 0;
            LED0 = !LED0;
        }
        if(bFlag2){
            bFlag2 = 0;
            LED1 = !LED1;
        }
        if(bFlag3){
            bFlag3 = 0;
            LED2 = !LED2;
        }
        if(bFlag4){
            bFlag4 = 0;
            LED3 = !LED3;
        }
    }
}
void initSys(){
    TMOD = 0x01;
    TH0 = T0_H;
    TL0 = T0_L;
    EA = 1;
    ET0 = 1;
    TR0 = 1;
}
void timer0() interrupt 1 {
    TH0 = T0_H;
    TL0 = T0_L;
    tick++;
    if((tick % 100) == 0){
        bFlag1 = 1;
    }
    if((tick % 150) == 3){
        bFlag2 = 1;
    }
    if((tick % 20) == 5){
        bFlag3 = 1;
    }
    if((tick % 300) == 7){
        bFlag4 = 1;
    }    
}

2.1.3.6 课堂作业

要求增加如下功能
每100ms检测一次按键动作（P2.2：KEY1，P2.3:KEY2）
按下KEY1所有灯灭，不再闪烁
按下KEY2所有灯恢复闪烁
完成proteus与keil的联调。

2.2 AD转换及数字电压表应用综合实例

复习4位LED数码管驱动电路原理
P2口输出字型码
P1口输出字位码（位选）
动态扫描，刷新频率大于50Hz时人眼感觉不出闪烁
50Hz，则周期为20mS，每位5mS

image.png-62.5kB

2.2.1 数码管驱动程序设计：固定显示“2022”

d定时器中断产生5m时标（b5MsFlag）
主循环查询b5MsFlag
5ms刷新时间到，P3口输出字型码(查表)，COM0-3输出位选信号

#include "reg51.h"
#include "common.h"
#define FOSC 11059200ul
#define T0_H (65536-(5*FOSC)/(1000*12))/256
#define T0_L (65536-(5*FOSC)/(1000*12))%256
sbit COM0 = P1^0;
sbit COM1 = P1^1;
sbit COM2 = P1^2;
sbit COM3 = P1^3;
uint8_t dispBuf[] = {1,2,3,4};
uint8_t code ledDeg[] = {0xC0, 0xF9, 0xA4, 0xB0, 0x99, 0x92, 0x82,0xF8, 0x80, 0x90};
bit segFlag = 0;
uint16_t counts = 0;
void initSys();
void updateSeg();
void main(){
    initSys();
    while(1){
        if(segFlag){
            segFlag = 0;
            updateSeg();
        }
    }
}
void initSys(){
    TMOD = 0x01;
    TH0 = T0_H;
    TL0 = T0_L;
    EA = 1;
    ET0 = 1;
    TR0 = 1;
}
void timer0() interrupt 1{
    TH0 = T0_H;
    TL0 = T0_L;
    segFlag = 1;
    if(counts++ > 200){
        counts = 0;
        b1sFlag = 1;
    }
}
void updateSeg(){
    static uint8_t i = 0;
    P3 = 0xff; //proteus simulation need
    switch(i){
      case 0: COM0 = 1; COM1 = 0; COM2 = 0; COM3 = 0; break;
        case 1: COM0 = 0; COM1 = 1; COM2 = 0; COM3 = 0; break;
        case 2: COM0 = 0; COM1 = 0; COM2 = 1; COM3 = 0; break;
        case 3: COM0 = 0; COM1 = 0; COM2 = 0; COM3 = 1; break;
    }
    P3 = ledDeg[dispBuf[i]];
    i++;
    if(i >= 4){
      i = 0;
    }   
}

2.1.2 数码管显示从0000-9999的变化数据

dispValue（ABCD）4位十进制数，ABCD分别为千位百位十位个位
怎么取ABCD的千位百位十位个位？
- 取个位： ABCD%10 = D （除10取余）
- 取高3位：ABCD/10 = ABC （除10取整）
- 取十位：ABC % 10
- 取高2位：ABC / 10 = AB
- 取百位：AB % 10 = B
- 取千位 AB /10 = A
  - 增加1秒到标志 b1SFlag
  - 1S时间到，将当前dispValue刷新到dispBuf

#include "reg51.h"
#include "common.h"
#define FOSC 11059200ul
#define T0_H (65536-(5*FOSC)/(1000*12))/256
#define T0_L (65536-(5*FOSC)/(1000*12))%256
sbit COM0 = P1^0;
sbit COM1 = P1^1;
sbit COM2 = P1^2;
sbit COM3 = P1^3;
uint16_t dispData = 4567;
uint8_t dispBuf[] = {1,2,3,4};
uint8_t code ledDeg[] = {0xC0, 0xF9, 0xA4, 0xB0, 0x99, 0x92, 0x82,0xF8, 0x80, 0x90};
bit segFlag = 0;
bit b1sFlag = 0;
uint16_t counts = 0;
void initSys();
void updateSeg();
void updateDispBuf();
void main(){
    initSys();
    while(1){
        if(segFlag){
            segFlag = 0;
          updateSeg();
        }
        if(b1sFlag){
          b1sFlag = 0;
            if(dispData++ > 9999){
              dispData = 0;
            }
            updateDispBuf();
        }     
    }
}
void initSys(){
    TMOD = 0x01;
    TH0 = T0_H;
    TL0 = T0_L;
    EA = 1;
    ET0 = 1;
    TR0 = 1;
}
void timer0() interrupt 1{
    TH0 = T0_H;
    TL0 = T0_L;
    segFlag = 1;
    if(counts++ > 200){
        counts = 0;
        b1sFlag = 1;
    }
}
void updateDispBuf(){
    uint8_t i;
    uint16_t tmp = dispData;
    for(i = 0; i < 4 ;i++){
        dispBuf[3-i] = tmp%10;
        tmp = tmp/10;
    }
}
void updateSeg(){
    static uint8_t i = 0;
    P3 = 0xff; //proteus simulation need
    switch(i){
        case 0: COM0 = 1; COM1 = 0; COM2 = 0; COM3 = 0; break;
        case 1: COM0 = 0; COM1 = 1; COM2 = 0; COM3 = 0; break;
        case 2: COM0 = 0; COM1 = 0; COM2 = 1; COM3 = 0; break;
        case 3: COM0 = 0; COM1 = 0; COM2 = 0; COM3 = 1; break;
    }
    P3 = ledDeg[dispBuf[i]];
    i++;
    if(i >= 4){
      i = 0;
    }   
}

2.2.3 AD转换程序设计

2.2.3.1 Tl549串行AD转换芯片

image.png-209.9kB
image.png-53.2kB
image.png-60kB

2.2.3.2 AD转换程序设计

image.png-651.8kB
image.png-37.1kB

sbit TLC549_CS = P1^0;
sbit TLC549_DOUT = P1^1;
sbit TLC549_CLK = P1^6;
uint8_t bdata AdValue;
sbit AIN = AdValue^0;
uint8_t getAdValue(){
    uchar i;
    TLC549_CS = 0;
    TLC549_DOUT = 1;
    TLC549_CLK = 0;
    for(i=0;i<8;i++){
       AdValue = AdValue<<1;
       TLC549_CLK = 1;
       _nop_();
       _nop_();  
       AIN = TLC549_DOUT;
       TLC549_CLK = 0;
       _nop_();
       _nop_();
    }
    TLC549_CS = 1;
    return AdValue;
}

2.2.4 标度变换

$Y_{max}$ :物理量的最大值， $Y_{min}$ :物理量的最小值
$X_{max}$ :AD的最大值， $X_{min}$ :AD的最小值
$z$ 为当前AD返回值
则： $\frac{Y_{max}-Y_{min}}{X_{max}-X_{min}}$ 为1格AD值对应的物理量大小,在本例中为 $\frac{5.0-0.0}{255.0-0.0}$ ，加小数点的原因是将其设为浮点类型，否则计算机会取整，丢失精度。
标度变换后的物理量 = $z \times \frac{Y_{max}-Y_{min}}{X_{max}-X_{min}}$ ,强制转换为float类型
为了便于传输和显示，将其放大100倍取整（保留两位小数）

if(adFlag){                      
  adFlag = 0;
  dispValue = 100*((float)getAdValue()*5.0/255.0);
}

2.2.5 数字电压表软件设计

image.png-32.3kB
image.png-39.3kB

#include <reg51.h>
#include <intrins.h>
#include "common.h"
#define FOSC 11059200ul
#define T0_H (65536-(2*FOSC)/(1000*12))/256
#define T0_L (65536-(2*FOSC)/(1000*12))%256
sbit COM0 = P1^0;
sbit COM1 = P1^1;
sbit COM2 = P1^2;
sbit COM3 = P1^3;
sbit TLC549_CS = P1^6;
sbit TLC549_DOUT = P1^5;
sbit TLC549_CLK = P1^7;
bit flag = 0;
bit flag1 = 0;
uint8_t ADcounts = 0;
uint8_t dispBuf[] = {2,0,1,8};
uint8_t code ledDeg[]={0xC0,0xF9,0xA4,0xB0,0x99,0x92,0x82,0xF8,0x80,0x90};  
uint8_t bdata AdValue;
sbit AIN = AdValue^0;
void initSys();
uint8_t getAdValue(){
    uint8_t i;
    TLC549_CS = 0;
    TLC549_DOUT = 1;
    TLC549_CLK = 0;
    for(i=0;i<8;i++){
       AdValue = AdValue<<1;
       TLC549_CLK = 1;
       _nop_();
       _nop_();  
       AIN = TLC549_DOUT;
       TLC549_CLK = 0;
       _nop_();
       _nop_();     
    }
    TLC549_CS = 1;
    return AdValue;
}
void main(){
   uint8_t i = 0;
   uint8_t j = 0;
   uint8_t ucAdValue=0;
   uint16_t uiAdValue =0;
   float fAdValue = 0.0;
   initSys();
   while(1){
       if(flag1){
          flag1 = 0;
          ucAdValue = getAdValue();
          fAdValue = (float)(ucAdValue*(5.0/255.0));
          uiAdValue= fAdValue * 1000;
          for(j=0;j<4;j++){
             dispBuf[3-j]= uiAdValue%10;
             uiAdValue /=10; 
          }
       }
       if(flag)
       {
           flag = 0;
           switch(i){
               case 0:
                   COM0=0;COM1=1;COM2=1;COM3=1;
                   break;
               case 1:
                   COM0=1;COM1=0;COM2=1;COM3=1;
                   break;
               case 2:
                   COM0=1;COM1=1;COM2=0;COM3=1;
                   break;
               case 3:
                   COM0=1;COM1=1;COM2=1;COM3=0;
                   break;                                          
           }
           P3 = 0xff;
           P3 = ledDeg[dispBuf[i]];
           if(i==0)
               P3 &= 0x7f;
           if(++i>=4){
              i=0;
           }
       }
   }
}
void initSys(){
   TMOD &= 0xF0;
   TMOD |= 0x01;
   EA = 1;
   ET0 =1;
   TH0 = T0_H;
   TL0 = T0_L;
   TR0 = 1;
}
void timer0ISR()interrupt 1{
   TH0 = T0_H;
   TL0 = T0_L;
   flag = 1; 
   if(ADcounts++>=40){
      ADcounts = 0;
      flag1 = 1;
   }       
}

2.2.6 基于“小小调度器”的数字电压表软件设计

2.2.6.1 小小调度器

在本节之前，我们按照协作式调度器的设计思想，通过定时器中断产生时标，在主循环中查询标志为实现驱动不同频度的周期性任务。这种方法需要我们设计不同的flag标志，配合时钟tick计数器完成，那么有没有便捷的方法实现以上功能呢？
答案是操作系统（OS）的思想，其核心是一个任务调度器，可以将不同的任务按照设计需要进行调度。实现一个单片机可用的操作系统相当复杂，同学们可以阅读一下相关的资料，比如usos/II、tiny51等嵌入式操作系统相关的文献。这些操作系统占用系统资源（RAM、ROM、CPU）较多，在51单片机上面使用受限，其学习也相对复杂。本节，我们学习一个轻量级的调度器：“小小调度器”，并应用于数字电压表软件设计。

原作者smset：
小小调度器16位版本小小调度器 V1.1 设计原理 (讨论稿) By smset
前言：
小小调度器是一款基于 C 语言的，协作式多任务编程框架。它基于状态机原理实现，所有任务均采用公共堆栈，具有简单小巧，易于移植的特点，非常适合于资源紧张的单片机编程使用。小小调度器的多任务并行机制和传统的状态机的并行机制原理是想通的。

主要的区别在于：小小调度器利用了 C 语言的LINE宏，这个LINE宏，代表了源文件中代码的行号，通过将代码行号保存到静态变量的方式，来记录程序运行的位置信息，从而使得原来需要人工实现的状态值设计、状态变量赋值以及状态跳转的系列编程工作，大部分均由记录行号的宏自动实现了，使得开发者可以节省很多底层的状态设计和处理的编程工作。基于此核心原理，小小调度器设计了一个框架和宏定义，以极低的 CPU 资源代价，模拟了一个和真实 RTOS 系统相似的多任务编程环境，使得编程者可以用更自然、更优雅、更易于理解的方式，来编写多任务并行代码，把时间和精力，更多的放在应用业务层逻辑的代码实现上。
特点

超级可以移植性，与CPU无关，几乎任何支持C语言编程的CPU都可以用！
小之又小，原理很简单，一看就懂。
省之又省，可以说对RAM和ROM省到极致。
取protothread之精华，将定时器与状态机和伪线程语法融合到一个框架，任务函数可以有两种写法。
基于定时器触发，调度效率高，最大化减少无效的代码运行时间。

#include <stc89c51.h>
/****小小调度器开始**********************************************/
#define MAXTASKS 3
volatile unsigned char timers[MAXTASKS];
#define _SS                                                                    \
  static unsigned char _lc = 0;                                                \
  switch (_lc) {                                                               \
  default:
#define _EE                                                                    \
  ;                                                                            \
  }                                                                            \
  ;                                                                            \
  _lc = 0;                                                                     \
  return 255;
#define WaitX(tickets)                                                         \
  do {                                                                         \
    _lc = (__LINE__ % 255) + 1;                                                \
    return tickets;                                                            \
  } while (0);                                                                 \
  case (__LINE__ % 255) + 1:
#define RunTask(TaskName, TaskID)                                              \
  do {                                                                         \
    if (timers[TaskID] == 0)                                                   \
      timers[TaskID] = TaskName();                                             \
  } while (0);
#define RunTaskA(TaskName, TaskID)                                             \
  {                                                                            \
    if (timers[TaskID] == 0) {                                                 \
      timers[TaskID] = TaskName();                                             \
      continue;                                                                \
    }                                                                          \
  } //前面的任务优先保证执行
#define CallSub(SubTaskName)                                                   \
  do {                                                                         \
    unsigned char currdt;                                                      \
    _lc = (__LINE__ % 255) + 1;                                                \
    return 0;                                                                  \
  case (__LINE__ % 255) + 1:                                                   \
    currdt = SubTaskName();                                                    \
    if (currdt != 255)                                                         \
      return currdt;                                                           \
  } while (0);
#define InitTasks()                                                            \
  {                                                                            \
    unsigned char i;                                                           \
    for (i = MAXTASKS; i > 0; i--)                                             \
      timers[i - 1] = 0;                                                       \
  }
#define UpdateTimers()                                                         \
  {                                                                            \
    unsigned char i;                                                           \
    for (i = MAXTASKS; i > 0; i--) {                                           \
      if ((timers[i - 1] != 0) && (timers[i - 1] != 255))                      \
        timers[i - 1]--;                                                       \
    }                                                                          \
  }
#define SEM unsigned int
//初始化信号量
#define InitSem(sem) sem = 0;
//等待信号量
#define WaitSem(sem)                                                           \
  do {                                                                         \
    sem = 1;                                                                   \
    WaitX(0);                                                                  \
    if (sem > 0)                                                               \
      return 1;                                                                \
  } while (0);
//等待信号量或定时器溢出， 定时器tickets 最大为0xFFFE
#define WaitSemX(sem, tickets)                                                 \
  do {                                                                         \
    sem = tickets + 1;                                                         \
    WaitX(0);                                                                  \
    if (sem > 1) {                                                             \
      sem--;                                                                   \
      return 1;                                                                \
    }                                                                          \
  } while (0);
//发送信号量
#define SendSem(sem)                                                           \
  do {                                                                         \
    sem = 0;                                                                   \
  } while (0);
/*****小小调度器结束*******************************************************/
sbit LED1 = P2 ^ 1;
sbit LED2 = P2 ^ 2;
sbit LED0 = P2 ^ 5;
unsigned char task0() {
  _SS while (1) {
    WaitX(50);
    LED0 = !LED0;
  }
  _EE
}
unsigned char task1() {
  _SS6 while (1) {
    WaitX(100);
    LED1 = !LED1;
  }
  _EE
}
unsigned char task2() {
  _SS while (1) {
    WaitX(100);
    LED2 = !LED2;
  }
  _EE
}
void InitT0() {
  TMOD = 0x21;
  IE |= 0x82;
  TL0 = 0Xff;
  TH0 = 0XDB;
  TR0 = 1;
}
void INTT0(void) interrupt 1 using 1 {
  TL0 = 0Xff; // 10ms 重装
  TH0 = 0XDB;
  UpdateTimers();
  RunTask(task0, 0); //任务0具有精确按时获得执行的权限，要求：task0每次执行消耗时间<0.5个
                     //ticket
}
void main() {
  InitT0();
  InitTasks(); //初始化任务，实际上是给timers清零
  while (1) {
    //      RunTask(task0,0);
    RunTaskA(task1, 1); //任务1具有比任务2高的运行权限
    RunTaskA(task2, 2); //任务2具有低的运行权限
  }
}
复制代码

2.2.6.2 基于“小小调度器”的数字电压表软件设计

//xxsch.h
#ifndef __XXSCH_H
#define __XXSCH_H
#define MAXTASKS 16          
#define BITS 16             
#define SEM unsigned int    
#if (BITS==8)
#define TASK unsigned char
#define TICKET_MAX 0xFF
#endif
#if (BITS==16)
#define TASK unsigned short
#define TICKET_MAX 0xFFFF
#endif
#if (BITS==32)
#define TASK unsigned long
#define TICKET_MAX 0xFFFFFFFF
#endif
#define _SS static unsigned char _lc=0; switch(_lc){default:
#define _EE ;}; _lc=0; return TICKET_MAX;
#define WaitX(tickets)  do { _lc=(__LINE__%255)+1; return (tickets) ;case (__LINE__%255)+1:;} while(0);
#define WaitUntil(A)    do { while(!(A)) WaitX(1);} while(0);
#define WAITUNTIL(A,VAL)  do { WaitX(1);} while((A)!=VAL);
#define WaitUntilR(A)    do { while(!(A)) WaitX(0);} while(0);
#define WAITUNTILR(A,VAL)  do { WaitX(0);} while((A)!=VAL);
#define RunTask(TaskName,TaskID)  do { if (timers[TaskID]==0) { TASK d=TaskName(); while(timers[TaskID]!=d) timers[TaskID]=d;} }  while(0);
#define RunTaskA(TaskName,TaskID) do { if (timers[TaskID]==0) {TASK d=TaskName(); while(timers[TaskID]!=d) timers[TaskID]=d;   continue;} }while(0);
#define CallSub(SubTaskName) do {TASK currdt; _lc=(__LINE__%255)+1; return 0; case (__LINE__%255)+1:  currdt=SubTaskName(); if(currdt!=TICKET_MAX) return currdt;} while(0);
#define CallSub1(SubTaskName,p1) do {TASK currdt; _lc=(__LINE__%255)+1; return 0; case (__LINE__%255)+1:  currdt=SubTaskName(p1); if(currdt!=TICKET_MAX) return currdt;} while(0);
#define CallSub2(SubTaskName,p1,p2) do {TASK currdt; _lc=(__LINE__%255)+1; return 0; case (__LINE__%255)+1:  currdt=SubTaskName(p1,p2); if(currdt!=TICKET_MAX) return currdt;} while(0);
#define InitTasks() do {unsigned char i; for(i=MAXTASKS;i>0 ;i--) timers[i-1]=0; } while(0);
#define UpdateTimers() do{unsigned char i; for(i=MAXTASKS;i>0 ;i--){if((timers[i-1]!=0)&&(timers[i-1]!=TICKET_MAX)) timers[i-1]--;}} while(0);
#define InitSem(sem) do{sem=0;}while(0);
#define WaitSem(sem) do{ sem=1; WaitX(0); if (sem>0) return 1;} while(0);
#define SendSem(sem)  do {sem=0;} while(0);
#define WaitSemX(sem, tickets) do{sem=tickets+1;WaitX(0);if(sem>1){sem--;return 1;}}while (0);
#endif

//main.h
#ifndef __MAIN_H
#define __MAIN_H
#include "STC15Fxxxx.h"
#define OSC_FREQ (11059200UL)
#define OSC_PER_INST (12)
#define BAUD 9600
#define T1_H (256-OSC_FREQ/12/32/BAUD) 
#define T0_H (65536-(5*OSC_FREQ)/(1000*12))/256
#define T0_L (65536-(5*OSC_FREQ)/(1000*12))%256
typedef unsigned char uint8_t;
typedef unsigned int  uint16_t;
typedef unsigned long uint32_t;
typedef char int8_t;
typedef int  int16_t;
typedef long int32_t;
    // Misc #defines
    #ifndef TRUE
    #define FALSE 0
    #define TRUE (!FALSE)
    #endif
#include "xxsch.h"  
#endif

//main.c
#include "main.h"
#include "adc.h"
#include "ledseg.h"
#include "xxsch.h"
#include "key.h"
volatile TASK timers[MAXTASKS];
//TASK ledseg_task();
//TASK adc_task();
TASK update_disp_buf_task();
float g_temperature = 25.2;
float g_humidity = 57.3;
float g_voltage = 3.234;
extern void update_ledseg_buf(float dispData, uint8_t pointsNum);
void initSys();
extern uint8_t key_value;
void main(void) {
  initSys();
  InitTasks();
  while (1) {
    RunTaskA(ledseg_task, 8);
    RunTaskA(adc_task, 6);
    RunTaskA(key_scan_task, 2);
    RunTaskA(update_disp_buf_task, 4);
  }
}
void initSys() {
  TMOD = 0x21;
  TH0 = T0_H;
  TL0 = T0_L;
  TH1 = T1_H;
  TL1 = T1_H;
  EA = 1;
  ET0 = 1;
  SCON = 0x50;
  EA = 1;
  ET0 = 1;
  ES = 1;
  TR0 = 1;
  TR1 = 1;
}
void timer0_isr(void) interrupt 1 using 1 {
  TL0 = T0_L;
  TH0 = T0_H;
  UpdateTimers();
}
void update_disp_buf() {
  switch (key_value) {
  case 0:
    update_ledseg_buf(g_voltage, 3);
    break;
  case 1:
    update_ledseg_buf(g_temperature, 1);
    break;
  case 2:
    update_ledseg_buf(g_humidity, 1);
    break;
  }
}
TASK update_disp_buf_task() {
  _SS while (1) {
    WaitX(100);
    update_disp_buf();
  }
  _EE
}

//port.h
#ifndef __PORT_H
#define __PORT_H
// ------ ledseg.c------------------------------------------------
// LED connection requires 12 port pins
#define LED_DATA_PORT (P2)
/* Connections to LED_DATA_PORT - See Figure 21.6 for details
     DP   G    F    E    D    C    B    A    =   LED display pins
     |    |    |    |    |    |    |    |
    x.7  x.6  x.5  x.4  x.3  x.2  x.1  x.0   =   Port pins
    x.7 == LED_DATA_PORT^7, etc
   LED codes (NB - positive logic assumed here)
   0  = abcdef  => 00111111 = 0x3F
   1  = bc      => 00000110 = 0x06
   2  = abdeg   => 01011011 = 0x5B
   3  = abcdg   => 01001111 = 0x4F
   4  = bcfg    => 01100110 = 0x66
   5  = acdfg   => 01101101 = 0x6D
   6  = acdefg  => 01111101 = 0x7D
   7  = abc     => 00000111 = 0x07
   8  = abcdefg => 01111111 = 0x7F
   9  = abcdfg  => 01101111 = 0x6F
   To display decimal point, add 10 (decimal) to the above values  */
// Any combination of (4) pins on any ports may be used here
sbit LED_DIGIT_0 = P1^0;
sbit LED_DIGIT_1 = P1^1;
sbit LED_DIGIT_2 = P1^2;
sbit LED_DIGIT_3 = P1^3;
#endif

//ledseg.c
#include "main.h" 
#include "port.h"
#include "ledseg.h"
// ------ Public variable definitions ------------------------------
// Lookup table - stored in code area
// See Port.H for connections and code details
uint8_t code LED_Table_G[20] = 
// 0     1     2     3     4     5     6     7     8     9
{0x3F, 0x06, 0x5B, 0x4F, 0x66, 0x6D, 0x7D, 0x07, 0x7F, 0x6F,
// 0.    1.    2.    3.    4.    5.    6.    7.    8.    9.
 0xBF, 0x86, 0xDB, 0xCF, 0xE6, 0xED, 0xFD, 0x87, 0xFF, 0xEF};
// Global data formatted for display (initially 0,0,0,0)
uint8_t  LED_Mx4_Data_G[4] = {0x3F,0x3F,0x3F,0x3F};
uint8_t idata point_pos = 0;
static uint8_t idata Digit_G;
void update_ledseg(void)
   {
     //only proteus simulation need the following line!!!
     LED_DATA_PORT = 0xff;
         // Increment the digit to be displayed
   if (++Digit_G == LED_NUM_DIGITS)
      {
      Digit_G = 0;
      }
   // Allows any pins to be used
   switch (Digit_G)
      {
      case 0:
         {      
         LED_DIGIT_0 = 0;
         LED_DIGIT_1 = 0;
         LED_DIGIT_2 = 0;
         LED_DIGIT_3 = 1;
         break;
         }
      case 1:
         {      
         LED_DIGIT_0 = 0;
         LED_DIGIT_1 = 0;
         LED_DIGIT_2 = 1;
         LED_DIGIT_3 = 0;
         break;
         }
      case 2:
         {      
         LED_DIGIT_0 = 0;
         LED_DIGIT_1 = 1;
         LED_DIGIT_2 = 0;
         LED_DIGIT_3 = 0;
         break;
         }
      case 3:
         {      
         LED_DIGIT_0 = 1;
         LED_DIGIT_1 = 0;
         LED_DIGIT_2 = 0;
         LED_DIGIT_3 = 0;
         }
      }
   LED_DATA_PORT = 255 - LED_Mx4_Data_G[Digit_G];
     if(Digit_G == (point_pos) && Digit_G !=0){
            LED_DATA_PORT &= 0x7f;      
   }
  }
void update_ledseg_buf(float dispData, uint8_t pointsNum){
    uint16_t u16Value;
    uint8_t j;
    switch(pointsNum){  
        case 0:
            u16Value = (uint16_t)dispData;
            break;
        case 1:
            u16Value = (uint16_t)(dispData * 10);
            break;
        case 2:
            u16Value = (uint16_t)(dispData *100);
            break;
        case 3:
            u16Value = (uint16_t)(dispData *1000);
            break;          
    }
    for( j=0;j<4;j++){
        LED_Mx4_Data_G[j]= LED_Table_G[u16Value%10];
        u16Value /=10; 
    }   
    point_pos = pointsNum;
}
TASK ledseg_task() {
  _SS while (1) {
    WaitX(1);
    update_ledseg();
  }
  _EE
}

//adc.c
#include "Main.h"
#include "Port.h"
#include <intrins.h>
#include "adc.h"
sbit TLC549_DOUT = P1 ^ 5;
sbit TLC549_CS = P1 ^ 6;
sbit TLC549_CLK = P1 ^ 7;
uint8_t bdata ad_value;
sbit AIN = ad_value ^ 0;
extern updateLed(float dispData, uint8_t pointsNum);
extern float g_voltage;
// uint8_t current_ad_value;
uint8_t tlc549_adc() {
  uint8_t i;
  TLC549_CS = 0;
  TLC549_DOUT = 1;
  TLC549_CLK = 0;
  for (i = 0; i < 8; i++) {
    ad_value = ad_value << 1;
    TLC549_CLK = 1;
    _nop_();
    _nop_();
    AIN = TLC549_DOUT;
    TLC549_CLK = 0;
    _nop_();
    _nop_();
  }
  TLC549_CS = 1;
  return ad_value;
}
void get_ad(void) {
  uint8_t value;
  value = tlc549_adc();
  g_voltage = (float)(value * (5.0 / 255.0));
}
TASK adc_task() {
  _SS while (1) {
    WaitX(20);
    get_ad();
  }
  _EE
}

//key.c
#include "main.h"
#include "key.h"
sbit KEY1 = P3 ^ 5;
uint8_t key_value = 0;
void key_scan() ;
TASK key_scan_task() {
  _SS while (1) {
    WaitX(5);
    key_scan(); 
  }
  _EE
}
static void key_scan() {
  static uint8_t _status = 0;
  switch (_status) {
  case 0:
    if (KEY1 == 0) {
      _status = 1;
    }
    break;
  case 1:
    if (KEY1 == 0) {
      _status = 2;
    } else {
      _status = 0;
    }
    break;
  case 2:
    if (KEY1 == 1) {
      _status = 3;
    }
    break;
  case 3:
    if (KEY1 == 1) {
      _status = 0;
      if (++key_value >= 3) {
        key_value = 0;
      }
    } else {
      _status = 0;
    }
    break;
  }
}

2.3 串口通信协议设计

2.3.1 串行通信与UART

根据CPU与外设之间连线结构和数据发送方式的不同，可将通信分为并行通信和串行通信两种基本方式。

2.3.1.1 串行通信的种类

根据数据传输方式的不同，可将串行通信分为同步通信和异步通信。
同步通信
是一种数据连续传输的串行通信方式。在这种通信方式中，数据块内各字节数据之间没有间隙，传输效率高，但发送、接收双方必须保持同步(使用同一时钟信号)，且数据块的长度越大，对同步的要求就越高。典型的同步通信数据帧格式如下所示：
异步通信
异步通信的特点是每次只传送一个字，每个字由起始位(规定为0电平)、数据位、奇偶校验位和停止位(规定为1电平)组成，典型的异步通信数据帧格式如下所示：

2.3.1.2. 波特率

在串行通信系统中常用波特率来衡量通信的快慢。波特率的含义是每秒中传送的二进制数码的位数，单位是bps,位/秒(b/s或Kb/s)，简称“波特”。

2.3.1.3 串行通信数据的传输方向

根据串行通信数据的传输方向，可将串行通信系统分为单工方式、半双工方式和全双工方式。

2.3.1.4 串行通信接口的种类

根据串行通信格式及约定(如同步方式、通信速率、信号电平等)的不同，派生出不同的串行通信接口标准，如常见的RS-232、RS-422、RS-485、IEEE1394、I2C、SPI(同步通信)、USB(通用串行总线接口)和CAN总线接口等。

2.3.2 MCS-51单片机的串行口

image_1cnlmv75a1fb14dm152e4j38an4d.png-125.1kB

在MCS-51芯片中，串行接收缓冲器和串行发送缓冲器使用同一特殊功能寄存器名SBUF(字节地址为99H)，但它们是两个不同的寄存器。由于串行接收缓冲器只能读出，不能写入，因此读SBUF寄存器时，操作对象是串行接收缓冲器；而串行发送缓冲器正好相反，即只能写入，不能读出，因此写SBUF寄存器时，操作对象是串行发送缓冲器。

2.3.2.1 串行通信接口控制寄存器SCON

字节地址98H，可位寻址
SM0、SM1——串行口4种工作方式的选择位

SM0	SM1	方式	功能说明
0	0	0	同步移位寄存器方式（用于扩展I/O口）
0	1	1	8位异步收发，波特率可变（由定时器控制）
1	0	2	9位异步收发，波特率为fosc/64或fosc/32
1	1	3	9位异步收发，波特率可变（由定时器控制）

SM2 多机通信控制位
REN——允许串行接收位由软件置“1”或清“0”。 REN=1 允许串行口接收数据。N=0 禁止串行口接收数据。
TB8——发送的第9位数据
RB8——接收到的第9位数据
TI——发送中断标志位
方式0时，串行发送第8位数据结束时由硬件置“1”，
其它工作方式，串行口发送停止位的开始时置“1”。TI=1，表示一帧数据发送结束，可供软件查询，也可申请中断。CPU响应中断后,向SBUF写入要发送的下一帧数据。TI必须由软件清0。
RI——接收中断标志位
方式0时，接收完第8位数据时，RI由硬件置1。其它工作方式，串行接收到停止位时，该位置“1”。RI=1，表示一帧数据接收完毕，并申请中断。该位状态也可软件查询。RI必须由软件清“0”。

2.3.2.2 特殊功能寄存器PCON（波特率倍增SMOD）

image.png-49.2kB

2.3.2.3 串口工作方式

2.3.2.3.1 方式0：同步方式

同步移位寄存器输入/输出方式，常用于外接移位寄存器，以扩展并行I/O口。8位数据为一帧，不设起始位和停止位，先发送或接收最低位。波特率固定为fosc/12。帧格式如下：
image_1cnlo4ndq193k1lom1oov14nc1pv48g.png-10.2kB
image_1cnlo5bii8tfmhsdsp1kkhbso8t.png-76.3kB

2.3.2.3.2 方式1：8位异步方式（最常用）

方式1发送
方式1接收
数据从RXD（P3.0）脚输入。当检测到起始位的负跳变时，开始接收数据。定时控制信号有两种：接收移位时钟（RX时钟，频率和波特率相同）和位检测器采样脉冲（频率是RX时钟的16倍，1位数据期间，有16个采样脉冲），当采样到RXD端从1到0的跳变时就启动检测器，接收的值是3次连续采样（第7、8、9个脉冲时采样）进行表决以确认是否是真正的起始位（负跳变）的开始。当一帧数据接收完，须同时满足两个条件，接收才真正有效。

2.3.2.3.3 方式2：9位异步方式

2.3.2.3.3 方式2：9位异步方式（波特率不可调）

2.3.2.4 波特率

一、方式0波特率
方式0波特率=振荡器频率/12；
二、方式2波特率
方式2波特率= $2^{SMOD} \times 振荡器频率/64$ ；
三、方式1和方式3的波特率
串行口方式1和方式3的波特率由定时器T1或T2的溢出率和SMOD所确定。
- 用定时器T1产生波特率
  方式1和方式3波特率= $2^{SMOD} \times （T1溢出率）/32$
  定时器T1作波特率发生器时，应禁止T1中断，T1工作于定时方式，一般工作于方式2，此时波特率计算公式为：
  方式1和方式3波特率= $2^{SMOD} \times 振荡器频率/[32\cdot12(256-(TH1))]$

2.3.3 串口驱动程序设计

串口初始化

#define FOSC 11059200ul
#define BAUD 9600
#define T1_H 256-FOSC/12/32/BAUD
#define T1_L 256-FOSC/12/32/BAUD
#define T0_H (65536-(FOSC*50)/(12*1000))/256
#define T0_L (65536-(FOSC*50)/(12*1000))%256 
void initSys(){
    SCON = 0x50; //8位异步方式，允许接收
    TMOD = 0x21; //T0方式1，T1方式2
    TH1  = T1_H;
    TL1  = T1_L;
    TH0  = T0_H;
    TL0  = T0_L;
    EA   = 1;
    ET0  = 1;
    ES   = 1;
    TR0  = 1;
    TR1  = 1;
}

串口收发数据
一般来说，程序员知道什么时候发送数据，但是不知道什么时候会接收到数据，因此，一般采用查询方式发送，中断方式接收

//串口查询方式发送1个字节数据
void SendChar(uint8_t u8Data){
    SBUF = u8Data;   //启动发送（注意串口是低速设备，只是启动发送并没有发送完成！）
    while(!TI);//等待发送完成
    TI = 0; //只要执行到此处，说明发送完成了（TI为1），将TI清零以免下次无法发送。
} 
uint8_t buf;
bit bRecvFalg = 0 ;
//中断方式接收
void serialIsr() interrupt 4{
    if(RI){  //如果是接收引起的中断执行这里
        RI = 0；//手工清零
        buf = SBUF;
        bRecvFalg = 1;//置接收标志为1
    }
}

串口通信示例
每隔1S钟发送字符串"Hello MCS-51!\r\n"
当收到字符'A'时，应答'B'

#include <reg51.h>
#include "common.h"
#define FOSC 11059200ul
#define BAUD 9600
#define T1_H 256-FOSC/12/32/BAUD
#define T1_L 256-FOSC/12/32/BAUD
#define T0_H (65536-(50*FOSC)/(12*1000))/256
#define T0_L (65536-(50*FOSC)/(12*1000))%256
bit b1sFlag = 0;
bit bRecvFlag = 0;
uint8_t u8SendData[]="Hello MCS-51\r\n";
void SendChar(uint8_t u8Data);
void initSys();
void main(){
    uint8_t i;
    initSys();
    while(1){
        if(b1sFlag){
            b1sFlag = 0;
            for(i=0;i<(sizeof(u8SendData)-1);i++){
                SendChar(u8SendData[i]);            
            }
        }
        if(bRecvFlag){
            bRecvFlag= 0;
            SendChar('B');      
        }
    }
}
void initSys(){
    TMOD = 0x21;
    SCON = 0x50;
    TH0 = T0_H;
    TL0 = T0_L;
    TH1 = T1_H;
    TL1 = T1_L;
    EA  = 1;
    ET0 = 1;
    ES  = 1;
    TR0 = 1;
    TR1 = 1;
}
void Timer0Isr() interrupt 1{
    static uint8_t counts = 0;
    TH0 = T0_H;
    TL0 = T0_L;
    if(counts++>=20){
        counts = 0;
        b1sFlag =1;
    }
}
void uartIsr()interrupt 4{
   uint8_t recvData;
   if(RI){
       RI = 0 ;
       recvData = SBUF;
       if(recvData == 'A'){
           bRecvFlag = 1; 
       }   
   }
}
//串口查询方式发送1个字节数据
void SendChar(uint8_t u8Data){
    SBUF = u8Data;   //启动发送（注意串口是低速设备，只是启动发送并没有发送完成！）
    while(!TI);//等待发送完成
    TI = 0;//只要执行到此处，说明发送完成了（TI为1），将TI清零以免下次无法发送。
}

image_1cnmbjv611942pq493q96k6sf13.png-25kB
image_1cnmbikmcsm013r1bjcut21og6m.png-39kB

2.3.4 串口通信协议设计

2.3.4.1 MCS-51串口及其驱动程序设计要点及其存在的问题

上一讲我们学习了MCS-51单片机的串行口及其驱动程序设计，其要点如下
- MCS-51单片机串口每次只能收发1个字节数据（硬件决定）
- 虽然都叫SBUF，地址也相同，但是它们是两个不同的寄存器。
  - 写串口 MOV SBUF,A
  - 读串口 MOV A,SBUF
- 串口的四种工作方式（方式1最常用，8位异步通信方式）
- 串口初始化
  - 配置SCON（工作方式，允许接收）
  - 配置TMOD，设置T1为方式2，T1作波特率发生器用，根据波特率计算T1初值，给TH1、TL1赋初值
  - 串口开中断,T1关中断
  - 启动T1
- 串口中断标志TI、RI，它们是或的关系，是接收还是发送引发的中断？需要在中断服务程序中查询，TI、RI需要手工清零
- 串口收发数据驱动程序
  - 采用查询方式发送（程序员知道什么时候发送数据）
  - 采用中断方式接收（程序员并不知道什么时候会收到数据）
- 目前这个驱动程序存在的问题
  在计算机之间通信时，1个字节所能表达的信息有限，一般都由多个字节组成1帧数据，这个数据帧中每个字节代表的意义就是通信协议。

2.3.4.2 通信协议的成帧机制

通信协议最关键要解决的问题是成帧机制
成帧机制：决定论一帧数据是否接收完整？最重要的是卡住一帧数据的头和尾。
典型的数据帧，包括帧头head、地址码addr、命令码cmd、数据域data0-datan、校验和以及帧尾，如下表所示：

帧头	地址	命令码	数据域	校验和	帧尾
head	addr	cmd	data0-datan	checksum	end
'@'	'0''1'	'D'	'1''2''3''4'	'1''0'	'\r''\n'
40H	30H31H	44H	31H32H33H34H	31H30H	0D0A

"@01D123410\r\n"

2.3.4.2 串口通信协议示例

考虑这样的功能，单片机1发送查询电压值命令帧，单片机2接收到查询命令后将当前电压数据发送给单片机1
查询帧"@01m000101\r\n"
应答帧"@01MXXXXCC\r\n"(CCCC为电压值，16进制表达，CC为校验和)
- 要点：如何判断成帧?
- 当收到帧头'@'，让recvIndex = 0；
- 接收到的数据存入缓冲区recvBuf[32]
- 当收到帧尾'\n',成帧，让bRecvFlag = 1;
- 主循环反复查询让bRecvFlag进行相应处理

#include <reg51.h>
#include <stdlib.h>
#include <stdio.h>
#include <intrins.h>
#include "common.h"
#define FOSC 11059200ul
#define BAUD 9600
#define T1_H (256-FOSC/12/32/BAUD) 
#define T0_H (65536-(50*FOSC)/(12*1000))/256
#define T0_L (65536-(50*FOSC)/(12*1000))%256
uint16_t sendData = 3124;
uint8_t u8SendData1[]="@01D000000\r\n";
uint8_t recvBuf[32] = {0};
uint8_t recvIndex = 0;
void initSys();
void SendChar(uint8_t u8Data);
bit b1sFlag = 0;
bit bRecvFlag = 0;
sbit TLC549_CS = P1^1;
sbit TLC549_DOUT = P1^0;
sbit TLC549_CLK = P1^2;
uint8_t bdata AdValue;
sbit AIN = AdValue^0;
uint8_t getAdValue(){
    uint8_t i;
    TLC549_CS = 0;
    TLC549_DOUT = 1;
    TLC549_CLK = 0;
    for(i=0;i<8;i++){
       TLC549_CLK = 1;
       _nop_();
       _nop_();  
       AdValue = AdValue<<1;
       AIN = TLC549_DOUT;
       TLC549_CLK = 0;
       _nop_();
       _nop_();
    }
    TLC549_CS = 1;
    return AdValue;
}
 void main(){
     uint8_t i;
     int8_t i8Buf[5];
     initSys();
     while(1){
        if(b1sFlag){
            b1sFlag = 0;
            sendData = (uint16_t)((5.0/255.0) * (float)getAdValue()*1000);
        }
        if(bRecvFlag){
            bRecvFlag = 0;
            sprintf(i8Buf,"%04x",sendData);
            u8SendData1[4] =  i8Buf[0];
            u8SendData1[5] =  i8Buf[1];
            u8SendData1[6] =  i8Buf[2];
            u8SendData1[7] =  i8Buf[3];
            for(i=0; i<(sizeof(u8SendData1)-1);i++){
                SendChar(u8SendData1[i]);
            }
        }
     }
 }                        
 void initSys(){
    TMOD = 0x21;
    TH0 = T0_H;
    TL0 = T0_L;
    TH1 = T1_H;
    TL1 = T1_H;
    SCON = 0x50;
    EA = 1;
    ET0 = 1;
    ES = 1;
    TR0 = 1;
    TR1 = 1;
 }
 void timer0Isr() interrupt 1{
    static uint8_t counts = 0;
    TH0 = T0_H;
    TL0 = T0_L;
    if(counts++ >= 20){
        counts =0;
        b1sFlag = 1;
    }
 }
 void serialIsr()interrupt 4{
    uint8_t recvData;
    if(RI){
        RI = 0;
        recvData = SBUF;
        if(recvData == '@'){
            recvIndex = 0;
        }
        if(recvIndex <31){ 
            recvBuf[recvIndex++] =  recvData;
        }
        else{
           recvIndex = 0;
        }
        if(recvData == '\n'){
           bRecvFlag = 1;
        }
    }
 }
 //串口查询方式发送1个字节数据
void SendChar(uint8_t u8Data){
    SBUF = u8Data;   //启动发送（注意串口是低速设备，只是启动发送并没有发送完成！）
    while(!TI);//等待发送完成
    TI = 0; //只要执行到此处，说明发送完成了（TI为1），将TI清零以免下次无法发送。
}

image_1cnob9ina1u7g7qbe5ns9u1b1u9.png-34.1kB
image_1cnobe38rt1r6jm1gleggb16282m.png-10.3kB image_1cnobi0c5mmj1e9c1u2hkhd1od633.png-35.1kB

2.3.4.3 课堂作业

给该程序增加4位LED数码管显示当前电压值的功能，注意：不能影响串口通信！

image.png-87.5kB
image.png-61.4kB

#include "reg51.h"
#include <intrins.h>
#include <stdlib.h>
#include <stdio.h>
#include "common.h"
#define FOSC 11059200ul
#define BAUD 9600
#define T1_H (256-FOSC/12/32/BAUD) 
#define T0_H (65536-(2*FOSC)/(1000*12))/256
#define T0_L (65536-(2*FOSC)/(1000*12))%256
sbit COM0 = P1^0;
sbit COM1 = P1^1;
sbit COM2 = P1^2;
sbit COM3 = P1^3;
sbit DO1 = P3^2;
sbit TLC549_CS = P1^6;
sbit TLC549_DOUT = P1^5;
sbit TLC549_CLK = P1^7;
bit flag = 0;
bit flag1 = 0;
uint8_t ADcounts = 0;
uint8_t dispBuf[] = {2,0,1,8};
uint8_t code ledDeg[]={0xC0,0xF9,0xA4,0xB0,0x99,0x92,0x82,0xF8,0x80,0x90};  
uint8_t bdata AdValue;
sbit AIN = AdValue^0;
uint16_t sendData = 3124;
uint8_t u8SendData1[]="@12D00001111222200\r\n";
uint8_t code u8SendData2[]="$12$\r\n";
uint8_t idata recvBuf[16] = {0};
uint8_t recvIndex = 0;
void initSys();
void SendChar(uint8_t u8Data);
bit bRecvFlag = 0;
uint8_t getAdValue(){
    uint8_t i;
    TLC549_CS = 0;
    TLC549_DOUT = 1;
    TLC549_CLK = 0;
    for(i=0;i<8;i++){
       AdValue = AdValue<<1;
       TLC549_CLK = 1;
       _nop_();
       _nop_();  
       AIN = TLC549_DOUT;
       TLC549_CLK = 0;
       _nop_();
       _nop_();     
    }
    TLC549_CS = 1;
    return AdValue;
}
void main(){
    uint8_t i = 0;
    uint8_t j = 0;
    uint8_t ucAdValue=0;
    uint16_t uiAdValue =0;
    float fAdValue = 0.0;
    int8_t i8Buf[5];
    initSys();
   while(1){
       if(flag1){
          flag1 = 0;
          ucAdValue = getAdValue();
          fAdValue = (float)(ucAdValue*(5.0/255.0));
          uiAdValue= fAdValue * 1000;
                  sendData = uiAdValue;
          for(j=0;j<4;j++){
             dispBuf[3-j]= uiAdValue%10;
             uiAdValue /=10; 
          }
       }
       if(flag)
       {
           flag = 0;
                   P2 = 0xff;
           switch(i){
               case 0:
                   COM0=1;COM1=0;COM2=0;COM3=0;
                   break;
               case 1:
                   COM0=0;COM1=1;COM2=0;COM3=0;
                   break;
               case 2:
                   COM0=0;COM1=0;COM2=1;COM3=0;
                   break;
               case 3:
                   COM0=0;COM1=0;COM2=0;COM3=1;
                   break;                                          
           }
           P2 = ledDeg[dispBuf[i]];
           if(i==0)
               P2 &= 0x7f;
           if(++i>=4){
              i=0;
           }
       }
              if(bRecvFlag){
                        bRecvFlag = 0;
                      if(recvBuf[0] == '$'){ 
                                for(i=0; i<(sizeof(u8SendData2)-1);i++){
                                    SendChar(u8SendData2[i]);
                            }                       
                        }
                        if(recvBuf[0] == '@'){
                            if(recvBuf[3] == 'd'){
                                sprintf(i8Buf,"%04x",sendData);
                                u8SendData1[4] =  i8Buf[0];
                                u8SendData1[5] =  i8Buf[1];
                                u8SendData1[6] =  i8Buf[2];
                                u8SendData1[7] =  i8Buf[3];
                                u8SendData1[8] =  i8Buf[0];
                                u8SendData1[9] =  i8Buf[1];
                                u8SendData1[10] =  i8Buf[2];
                                u8SendData1[11] =  i8Buf[3];
                                u8SendData1[12] =  i8Buf[0];
                                u8SendData1[13] =  i8Buf[1];
                                u8SendData1[14] =  i8Buf[2];
                                u8SendData1[15] =  i8Buf[3];                            
                                for(i=0; i<(sizeof(u8SendData1)-1);i++){
                                        SendChar(u8SendData1[i]);
                                }
                            }
                            if(recvBuf[3] == 'f'){
                                if(recvBuf[7] == '1'){
                                    DO1 = 0;                                  
                                }
                                if(recvBuf[7] == '0'){
                                    DO1 = 1;                                  
                                }                               
                            }
                        }
             }
   }
}
void initSys(){
    TMOD = 0x21;
    TH0 = T0_H;
    TL0 = T0_L;
    TH1 = T1_H;
    TL1 = T1_H; 
    EA = 1;
    ET0 =1;
    SCON = 0x50;
    EA = 1;
    ET0 = 1;
    ES = 1;
    TR0 = 1;
    TR1 = 1;
}
void timer0ISR()interrupt 1{
   TH0 = T0_H;
   TL0 = T0_L;
   flag = 1; 
   if(ADcounts++>=40){
      ADcounts = 0;
      flag1 = 1;
   }       
}
 void serialIsr()interrupt 4{
    uint8_t recvData;
    if(RI){
        RI = 0;
        recvData = SBUF;
        if(recvData == '@' || recvData == '$'){
            recvIndex = 0;
        }
        if(recvIndex <31){ 
            recvBuf[recvIndex++] =  recvData;
        }
        else{
           recvIndex = 0;
        }
        if(recvData == '\n'){
           bRecvFlag = 1;
        }
    }
 }
void SendChar(uint8_t u8Data){
    SBUF = u8Data;  
    while(!TI);
    TI = 0; 
}