STC8G1K08串口通讯

2024-03-10 08:04
文章标签 串口 通讯 stc8g1k08

本文主要是介绍STC8G1K08串口通讯，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

 /***豆腐干下位机测试  L573 CODE 3919 2021 1 25***/    
/***STC8G1K08   三段时间控制程序 电机自动启停***/    
              #include     <REG52.H>          //下降一段设置
              #include     <intrins.h>        //保压时间
              #include     <string.h>
              #define      FOSC 11059200UL             //晶振频率
              #define      BRT  (256-FOSC/9600/32)   //波特率除/32  9600/32  或者115200/32
              #include     "stdio.h"
              #include     <stdlib.h>
              #define      uint unsigned int
              #define      uchar unsigned char
              uchar        data_i=0;
              sbit         INTPUT1=P5^4;         //启动信号
              sbit         DOWN=P3^2;             //下降
              sbit         UP=P3^3;                 //上升
              sbit         LED=P5^5;             //EEPROM写指示
              uint         FLAG_S;
              #define      CMD_IDLE    0         //空闲模式
              #define      CMD_READ    1         //IAP字节读命令
              #define      CMD_PROGRAM 2         //IAP字节编程命令
              #define      CMD_ERASE   3         //IAP扇区擦除命令
              #define      ENABLE_IAP  0x82      //if SYSCLK<20MHz
              #define      IAP_ADDRESS 0x0000    //时间 EEPROM首地址
              typedef      unsigned char BYTE;
              typedef      unsigned int WORD;
/**********************/
              static uint  RUN_TIME;   //运行总时间     累计
/*************周期一*********/              
              static uint  RunTime_A;  //停顿时间  第一段
              static uint  Wait_A;     //停顿时间
              static uint  Press_A;    //压榨时间
/*************周期二*********/
              static uint  RunTime_B;  //停顿时间  第二段
              static uint  Wait_B;     //停顿时间
              static uint  Press_B;    //压榨时间
/*************周期二*********/
              static uint  RunTime_C;  //停顿时间  第三段
              static uint  Wait_C;     //停顿时间
              static uint  Press_C;    //压榨时间

/*************系统参数*******/
              static uint  Back_Time;  //回程时间
              static uint  Down_Time;  //下降一时间
              static uint  Press_Time; //保压时间
/**********************/
              bit           Receive_Flag;
              bit          Run_Flag;
              bit          Dataa_Flag;
              bit          Datab_Flag;
              uchar        kcounter,kstatus;     //按键计数标志 按键状态标志
              uint         a[8];             //定义数组a 存储串口数据串
/*------------------------------------------*/
              void delay(uint t)
              {
              uint i,j;
              for(i=0;i<t;i++)
              for(j=0;j<100;j++);
              }
/*-----------(1)延时子程序12MHz 加千百十个显示--------*/
               void Delay100ms(uint x)              //
               {
               uint i,j;
               for(i=0;i<x;i++)
               for(j=0;j<11000;j++);
               }
/*-----------(1)延时子程序12MHz 加千百十个显示--------*/
               void Delay_100ms(uint x)          //page 5 保压，上升计时  Delay100ms
               {
               uint i,j;
                for(i=0;i<x;i++)
                {
                for(j=0;j<9200;j++);
                printf("n6.val=%d\xff\xff\xff",i);//
                }
               }    
/*----关闭IAP----------------------------*/
              void IapIdle()
              {
              IAP_CONTR = 0;                  //关闭IAP功能
              IAP_CMD = 0;                    //清除命令寄存器
              IAP_TRIG = 0;                   //清除触发寄存器
              IAP_ADDRH = 0x80;               //将地址设置到非IAP区域
              IAP_ADDRL = 0;
              }
/*-从ISP/IAP/EEPROM区域读取一字节-*/
              BYTE IapReadByte(WORD addr)
              {
              BYTE dat;                       //数据缓冲区
              IAP_CONTR = ENABLE_IAP;         //使能IAP
              IAP_CMD = CMD_READ;             //设置IAP命令
              IAP_ADDRL = addr;               //设置IAP低地址
              IAP_ADDRH = addr >> 8;          //设置IAP高地址
              IAP_TRIG = 0x5a;                //写触发命令(0x5a)
              IAP_TRIG = 0xa5;                //写触发命令(0xa5)
              _nop_();                        //等待ISP/IAP/EEPROM操作完成
              dat = IAP_DATA;                 //读ISP/IAP/EEPROM数据
              IapIdle();                      //关闭IAP功能
              return dat;                     //返回
              }
/*-写一字节数据到ISP/IAP/EEPROM区域-*/
              void IapProgramByte(WORD addr, BYTE dat)
              {
              IAP_CONTR = ENABLE_IAP;         //使能IAP
              IAP_CMD = CMD_PROGRAM;          //设置IAP命令
              IAP_ADDRL = addr;               //设置IAP低地址
              IAP_ADDRH = addr >> 8;          //设置IAP高地址
              IAP_DATA = dat;                 //写ISP/IAP/EEPROM数据
              IAP_TRIG = 0x5a;                //写触发命令(0x5a)
              IAP_TRIG = 0xa5;                //写触发命令(0xa5)
              _nop_();                        //等待ISP/IAP/EEPROM操作完成
              IapIdle();
              }
/*---扇区擦除---------------*/
              void IapEraseSector(WORD addr)
              {
              IAP_CONTR = ENABLE_IAP;         //使能IAP val=IapReadByte(IAP_ADDRESS+1);
              IAP_CMD = CMD_ERASE;            //设置IAP命令
              IAP_ADDRL = addr;               //设置IAP低地址
              IAP_ADDRH = addr >> 8;          //设置IAP高地址
              IAP_TRIG = 0x5a;                //写触发命令(0x5a)
              IAP_TRIG = 0xa5;                //写触发命令(0xa5)
              _nop_();                        //等待ISP/IAP/EEPROM操作完成
              IapIdle();
              }
/***********************************/
              void red_eeprom(void)
              {
              uint m,n;        
              m=IapReadByte(IAP_ADDRESS+0);  //时间前八位
              n=IapReadByte(IAP_ADDRESS+1);  //时间后八位
              RunTime_A=m*256+n;             //周期一压榨总时
              m=IapReadByte(IAP_ADDRESS+2);  //时间前八位
              n=IapReadByte(IAP_ADDRESS+3);  //时间后八位
              Wait_A=m*256+n;                 //周期一停顿时间
              m=IapReadByte(IAP_ADDRESS+4);  //时间前八位
              n=IapReadByte(IAP_ADDRESS+5);  //时间后八位
              Press_A=m*256+n;                 //周期一压榨时间
              m=IapReadByte(IAP_ADDRESS+6);  //时间前八位
              n=IapReadByte(IAP_ADDRESS+7);  //时间后八位
              RunTime_B=m*256+n;             //周期二压榨总时
              m=IapReadByte(IAP_ADDRESS+8);  //时间前八位
              n=IapReadByte(IAP_ADDRESS+9);  //时间后八位
              Wait_B=m*256+n;                 //周期二停顿时间
              m=IapReadByte(IAP_ADDRESS+10); //时间前八位
              n=IapReadByte(IAP_ADDRESS+11); //时间后八位
              Press_B=m*256+n;                 //周期二压榨时间

              Back_Time=IapReadByte(IAP_ADDRESS+12);  //回程时间时间后八位
              Down_Time=IapReadByte(IAP_ADDRESS+13); //下降一时间后八位
              m=IapReadByte(IAP_ADDRESS+14); //时间前八位
              n=IapReadByte(IAP_ADDRESS+15); //时间后八位
              Press_Time=m*256+n;             //保压时间

              RunTime_C=IapReadByte(IAP_ADDRESS+16);             //周期三压榨总时
              Wait_C=IapReadByte(IAP_ADDRESS+17);                 //周期三停顿时间
              Press_C=IapReadByte(IAP_ADDRESS+18);             //周期三压榨时间
              }
/*************写时间参数到EEPROM*******************************/
               void Write_EepromTime()
              {
               LED=0;
               IapEraseSector(IAP_ADDRESS); //扇区擦除
               IapProgramByte(IAP_ADDRESS+0,RunTime_A/256);   /*周期一压榨总时高八位*/    
               IapProgramByte(IAP_ADDRESS+1,RunTime_A%256);   /*周期一压榨总时低八位*/

               IapProgramByte(IAP_ADDRESS+2,Wait_A/256);      /*周期一停顿时间高八位*/  
               IapProgramByte(IAP_ADDRESS+3,Wait_A%256);      /*周期一停顿时间低八位*/

               IapProgramByte(IAP_ADDRESS+4,Press_A/256);     /*周期一压榨时间高八位*/
               IapProgramByte(IAP_ADDRESS+5,Press_A%256);     /*周期一压榨时间低八位*/

               IapProgramByte(IAP_ADDRESS+6,RunTime_B/256);   /*周期二压榨总时高八位*/    
               IapProgramByte(IAP_ADDRESS+7,RunTime_B%256);   /*周期二压榨总时低八位*/

               IapProgramByte(IAP_ADDRESS+8,Wait_B/256);      /*周期二停顿时间高八位*/  
               IapProgramByte(IAP_ADDRESS+9,Wait_B%256);      /*周期二停顿时间低八位*/

               IapProgramByte(IAP_ADDRESS+10,Press_B/256);    /*周期二压榨时间高八位*/
               IapProgramByte(IAP_ADDRESS+11,Press_B%256);    /*周期二压榨时间低八位*/

               IapProgramByte(IAP_ADDRESS+12,Back_Time);      /*写入回程时间*/
               IapProgramByte(IAP_ADDRESS+13,Down_Time);      /*下降一时间*/
               IapProgramByte(IAP_ADDRESS+14,Press_Time/256); /*写入保压时间高八位*/
               IapProgramByte(IAP_ADDRESS+15,Press_Time%256); /*写入保压时间低八位*/

               IapProgramByte(IAP_ADDRESS+16,RunTime_C);      /*周期三压榨总时*/    
               IapProgramByte(IAP_ADDRESS+17,Wait_C);         /*周期三停顿时间*/  
               IapProgramByte(IAP_ADDRESS+18,Press_C);        /*周期三压榨时间*/
               
               }
/*************关所有输出*******************************/             
               void reset_io()
               {
               P3M0=0X00;
               P3M1=0X00;
               P5M0=0;    
               P5M1=0;
               DOWN=1;                           //气缸下降
               UP=1;                             //气缸上升
               INTPUT1=1;                         //
               }
/****************按键计数器状态寄存器归零*************/
               void RstKey()
               {
               kcounter=0;                       //按键计数器归零
               kstatus=0;                        //状态寄存器归零
               }
/*****************按键低电平检测函数*****************/
               void   LowVoltKey(void)           //按键计数器状态标志加一
               {
               kcounter++;                       
               kstatus++;     
               delay(5);                         //延时                  
               }
/*****************按键高电平检测函数*****************/
               void    HighVoltKey(void)         //按键计数器加一 状态标志归零
               {
               kcounter++;                       //按键计数器加一
               kstatus=0;                        //按键状态标志归零
               Delay100ms(5);                         //延时
               }
/*------------page 0页面显示---------------------*/
               void disdata_a()//周期一参数    周期二参数
               {
                red_eeprom();
                printf("n0.val=%d\xff\xff\xff",RunTime_A);    //第一段周期总时
                printf("n0.val=%d\xff\xff\xff",RunTime_A);    //第一段周期总时
                printf("n1.val=%d\xff\xff\xff",Wait_A);        //第一段停顿时间
                printf("n2.val=%d\xff\xff\xff",Press_A);    //第一段压榨时间
                printf("n3.val=%d\xff\xff\xff",RunTime_B);    //第二段周期总时
                printf("n4.val=%d\xff\xff\xff",Wait_B);        //第二段停顿时间
                printf("n5.val=%d\xff\xff\xff",Press_B);    //第二段压榨时间
                LED=1;
               }
/*------------page 2页面显示---------------------*/
               void disdata_b()//                            //周期三参数  系统参数
               {
                red_eeprom();
                printf("n0.val=%d\xff\xff\xff",RunTime_C);    //第三段周期总时
                printf("n0.val=%d\xff\xff\xff",RunTime_C);    //第三段周期总时
                printf("n1.val=%d\xff\xff\xff",Wait_C);        //第三段停顿时间
                printf("n2.val=%d\xff\xff\xff",Press_C);    //第三段压榨时间
                printf("n3.val=%d\xff\xff\xff",Down_Time);    //下降一时间
                printf("n4.val=%d\xff\xff\xff",Press_Time);    //保压时间
                printf("n5.val=%d\xff\xff\xff",Back_Time);    //回程时间
                LED=1;
               }
/*------------自动压榨开始---------------------*/
              void start()
              {        
              uint t1;    
              RUN_TIME=0;                        //压榨总时间清零
              printf("page 4\XFF\XFF\XFF");         //第三段周期界面显示
              disdata_a();
              FLAG_S=1;                          //1 下降 2上升 3停止 4结束      5保压      6待机       7周期一 8周期二
              printf("va0.val=%d\xff\xff\xff",FLAG_S);    //触摸屏变量va0，用于定时器判断变量显示中文内容
              Delay100ms(5);                     //延时(5);
              DOWN=0;                             //
              UP=1;                                 //
              Delay_100ms(Down_Time*10);         //下降一时间
              RUN_TIME+=Down_Time*10;             //
              DOWN=1;    
              FLAG_S=3;                          //1 下降 2上升 3停止  4结束   5保压 6待机      7周期一 8周期二
              printf("va0.val=%d\xff\xff\xff",FLAG_S);//
              Run_Flag=1;                         //自动运行标志
              while(Run_Flag)
               {
                Delay100ms(Wait_A*10);             //周期一停顿时间
                RUN_TIME+=Wait_A*10;
                DOWN=0;                             //下降
                FLAG_S=1;                        //1 下降 2上升 3停止 4结束      5保压    6待机      7周期一 8周期二
                printf("va0.val=%d\xff\xff\xff",FLAG_S);    //
                Delay100ms(Press_A);           //压榨时间
                RUN_TIME+=Press_A;
                DOWN=1;                             //停止
                FLAG_S=3;                        //1 下降 2上升 3停止  4结束   5保压  6待机       7周期一 8周期二
                printf("va0.val=%d\xff\xff\xff",FLAG_S);    //
                if(RUN_TIME>=RunTime_A*10)         //总时间大于等于设定值
                Run_Flag=0;                         //自动运行标志 结束周期一循环
                printf("n7.val=%d\xff\xff\xff",RUN_TIME/10);    //
               }
//周期一结束
               FLAG_S=8;                         //1 下降 2上升 3停止  4结束   5保压   6待机  7周期一 8周期二
               printf("va0.val=%d\xff\xff\xff",FLAG_S);    //
               Delay100ms(5);                    //延时(5);
               RUN_TIME=0;                         //计时器归零
               printf("n7.val=%d\xff\xff\xff",RUN_TIME);    //
               Run_Flag=1;                         //自动运行标志，启动周期二循环
               while(Run_Flag)
               {
                Delay100ms(Wait_B*10);             //周期二停顿时间
                RUN_TIME+=Wait_B*10;
                DOWN=0;                             //下降
                FLAG_S=1;                        //1 下降 2上升 3停止 4结束     5保压  6待机  7周期一 8周期二
                printf("va0.val=%d\xff\xff\xff",FLAG_S);    //
                Delay100ms(Press_B);             //压榨时间
                RUN_TIME+=Press_B;
                DOWN=1;                             //停止
                FLAG_S=3;                        //1 下降 2上升 3停止  4结束   5保压  6待机      7周期一 8周期二
                printf("va0.val=%d\xff\xff\xff",FLAG_S);    //
                if(RUN_TIME>=RunTime_B*10)         //总时间大于等于设定值
                Run_Flag=0;                         //自动运行标志 结束周期二循环
                printf("n7.val=%d\xff\xff\xff",RUN_TIME/10);    //
               }
//周期二结束
               FLAG_S=9;                          //1 下降 2上升 3停止 4结束      5保压      6待机       7周期一 8周期二
               printf("va0.val=%d\xff\xff\xff",FLAG_S);    //
               printf("page 5\XFF\XFF\XFF");                //第三段周期界面显示
               disdata_b();
                  RUN_TIME=0;                                    //计时器归零
               printf("n7.val=%d\xff\xff\xff",RUN_TIME);    //时间运行显示
               Run_Flag=1;                         //自动运行标志，启动周期三循环
               while(Run_Flag)
               {                                  //Delay100ms
                for(t1=0;t1<Wait_C*60;t1++)          //
                {
                Delay100ms(10);                      //1ms
                printf("n7.val=%d\xff\xff\xff",t1);//
                }
                RUN_TIME+=Wait_C;
                DOWN=0;                             //下降
                FLAG_S=1;                        //1 下降 2上升 3停止 4结束     5保压  6待机    7周期一 8周期二
                printf("va0.val=%d\xff\xff\xff",FLAG_S);    //
                for(t1=0;t1<Press_C*60;t1++)
                {
                Delay100ms(10);                      //1ms
                printf("n7.val=%d\xff\xff\xff",t1);//
                }
                RUN_TIME+=Press_C;
                DOWN=1;                             //停止
                FLAG_S=3;                        //1 下降 2上升 3停止  4结束   5保压  6待机      7周期一8周期二9周期三
                printf("va0.val=%d\xff\xff\xff",FLAG_S);    //
                if(RUN_TIME>=RunTime_C)             //总时间大于等于设定值
                Run_Flag=0;                         //自动运行标志 结束周期三循环
                printf("n7.val=%d\xff\xff\xff",RUN_TIME);    //总时间显示
               }
//周期三结束
               DOWN=0;
               FLAG_S=5;                         //1 下降 2上升 3停止  4结束   5保压   6待机  7周期一 8周期二 9周期三
               printf("va0.val=%d\xff\xff\xff",FLAG_S);    //
               RUN_TIME=0;                         //计时器归零
               printf("n7.val=%d\xff\xff\xff",RUN_TIME/10);    //
               Delay_100ms(Press_Time*10);         //保压        
               DOWN=1;                           //关下降
               FLAG_S=2;                         //1 下降 2上升 3停止  4结束    5保压  6待机   7周期一 8周期二 9周期三
               printf("va0.val=%d\xff\xff\xff",FLAG_S);    //
               UP=0;                             //开上升
               Delay_100ms(Back_Time*10);         //
               UP=1;                             //关上升
               FLAG_S=4;                         //1 下降 2上升 3停止 4结束     5保压      6待机       7周期一 8周期二    9周期三
               printf("va0.val=%d\xff\xff\xff",FLAG_S);    //
               printf("page 0\XFF\XFF\XFF");                //第三段周期界面显示
               Delay100ms(10);                    //延时(10);
               disdata_a();
               }
/*------------初始化串口---------------------*/
              void InitUart()
              {
              SCON = 0x50;
              TMOD = 0x20;
              TL1 = BRT;
              TH1 = BRT;
              TR1 = 1;
              AUXR = 0x40;
              TI=1;                                 //
              ES=1;                                 //
              EA=1;                                 //
              }
/*×--------UART 中断服务程序-------------------**/
/**×**把接收到的数据存进数组a[i]**i开机初始化****/
/***×*接收到触摸屏结束码Receive_Flag标志位置1****/
/****×主程序检测到标志码=1判断指令功能***********/
              void Uart() interrupt 4 using 1
              {
               if(RI)
               {
                if(SBUF==0XFA)                     //触摸屏结束码
                {
                Receive_Flag=1;                     //接收数据标志置一
                RI=0;                             //
                data_i=0;                             //数组计数器归零
                }
                else
                {
                a[data_i]=SBUF;                        //数组下标位置的数据等于SBUF
                RI=0;                              //
                data_i++;
                }
               }
              }
/*************************************************/
              void   main( )                      /*主程序开始*/
              {
               reset_io();
               P_SW1=0x00;                       //RXD/P3.0, TXD/P3.1
               Receive_Flag=0;    
               InitUart();                        //初始化串口
               printf("0XFF,0XFF,0XFF");
               Delay100ms(10);                    //延时(10);
               disdata_a();
               Run_Flag=0;
               Delay100ms(10);                    //延时(10);
               Dataa_Flag=0;
               Datab_Flag=0;
               data_i=0;
               while(1)            //INTPUT1
               {
                if(Dataa_Flag==1)
                {
                Dataa_Flag=0;
                disdata_a();
                }
                if(Datab_Flag==1)
                {
                Datab_Flag=0;
                disdata_b();
                }

               if(Receive_Flag==1)
               {
                Receive_Flag=0;                           //重新接收
/*************周期一*********/
                 if(a[0]==0XE0)            
                 {
                  if(a[1]==0X00)                   //周期一
                  {
                  RunTime_A=a[3]*256+a[2];       //周期一压榨总时
                  Dataa_Flag=1;
                  printf("n6.val=%d\xff\xff\xff",RunTime_A);//数据校对
                  }
                  else if(a[1]==0X01)
                  {
                  Wait_A=a[3]*256+a[2];          //周期一停顿时间
                  Dataa_Flag=1;
                  printf("n6.val=%d\xff\xff\xff",Wait_A);    //
                  }
                  else if(a[1]==0X02)       
                  {
                  Press_A=a[3]*256+a[2];         //周期一压榨时间
                  Dataa_Flag=1;
                  printf("n6.val=%d\xff\xff\xff",Press_A);    //
                  }
/*************周期二*********/
                  else if(a[1]==0X03)
                  {
                  RunTime_B=a[3]*256+a[2];       //周期二压榨总时
                  Dataa_Flag=1;
                  printf("n6.val=%d\xff\xff\xff",RunTime_B);    //
                  }                        
                  else if(a[1]==0X04)
                  {
                  Wait_B=a[3]*256+a[2];          //周期二停顿时间
                  Dataa_Flag=1;
                  printf("n6.val=%d\xff\xff\xff",Wait_B);    //
                  }                          
                  else if(a[1]==0X05)
                  {
                  Press_B=a[3]*256+a[2];         //周期二压榨时间
                  Dataa_Flag=1;
                  printf("n6.val=%d\xff\xff\xff",Press_B);    //
                  }    
/*************周期三*********/
                  else if(a[1]==0X06)
                  {
                  RunTime_C=a[2];       //周期三压榨总时
                  Datab_Flag=1;
                  printf("n6.val=%d\xff\xff\xff",RunTime_C);    //
                  }                        
                  else if(a[1]==0X07)
                  {
                  Wait_C=a[2];          //周期三停顿时间
                  Datab_Flag=1;
                  printf("n6.val=%d\xff\xff\xff",Wait_C);    //
                  }                          
                  else if(a[1]==0X08)
                  {
                  Press_C=a[2];         //周期三压榨时间
                  Datab_Flag=1;
                  printf("n6.val=%d\xff\xff\xff",Press_C);    //
                  }    
//系统参数
/*************系统参数*******/
                  else if(a[1]==0X09)
                  {
                  Down_Time=a[2];                //下降一时间
                  Datab_Flag=1;
                  printf("n6.val=%d\xff\xff\xff",Down_Time);    //
                  }    
                  else if(a[1]==0X0A)
                  {
                  Press_Time=a[3]*256+a[2];      //保压时间
                  Datab_Flag=1;
                  printf("n6.val=%d\xff\xff\xff",Press_Time);    //
                  }    
                  else if(a[1]==0X0B)
                  {
                  Back_Time=a[2];                //回程时间
                  Datab_Flag=1;
                  printf("n6.val=%d\xff\xff\xff",Back_Time);    //
                  }    
                 Write_EepromTime();
                }
                else  if(a[0]==0XE2)                     //主画面后初始化事件
                {
                  if(a[1]==0X20)             //
                  {
                  UP=0;                          //气缸上升
                  }
                  else  if(a[1]==0X21)               //
                  {
                  DOWN=0;                        //气缸下降
                  }
                  else  if(a[1]==0X22)             //
                  {
                  DOWN=1;                        //关闭气缸下降
                  UP=1;                          //关闭气缸上升
                  }
                  else  if(a[1]==0XA1)             //    周期一参数    周期二参数
                  {
                   LED=0;
                   Delay100ms(20);                    //延时(10);
                   Dataa_Flag=1;
                  // disdata_a();                  //
                  }
                  else  if(a[1]==0XA2)             //周期三参数     系统参数
                  {
                   LED=0;
                   Delay100ms(20);                    //延时(10);
                   Datab_Flag=1;
                   //disdata_b();                  //周期一参数
                  }
                  if(a[1]==0XE2)               //数据全部删除
                  {
                  RUN_TIME=0;   //运行总时间     累计
/*************周期一*********/              
                  RunTime_A=0; //停顿时间  第一段
                  Wait_A=0;    //停顿时间
                  Press_A=0;    //压榨时间
/*************周期二*********/
                  RunTime_B=0;  //停顿时间  第二段
                  Wait_B=0;    //停顿时间
                  Press_B=0;   //压榨时间
/*************周期二*********/
                  RunTime_C=0;  //停顿时间  第三段
                  Wait_C=0;    //停顿时间
                  Press_C=0;    //压榨时间
/*************系统参数*******/
                  Back_Time=0;  //回程时间
                  Down_Time=0;  //下降一时间
                  Press_Time=0; //保压时间
                  Write_EepromTime();
                  }
                 }
                }  
///
               RstKey();
               for(;kcounter<5;)                //按键循环5次
               {
                if(!INTPUT1)                    //按键低电平
                {
                LowVoltKey();                   //按键低电平 计数器加一状态标志加一
                }
                else if(~!INTPUT1)              //按键高电平
                {
                HighVoltKey();                    //按键计数器加一    状态标志归零
                }
               }
               if(kstatus>=3)                   /*按键状态标志大于等于3为有效值*/
               {  
               start();
               }
             }     
            }                    //L573 CODE 3919 2021 1 25

这篇关于STC8G1K08串口通讯的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/793582。

相关文章

Java Websocket实例【服务端与客户端实现全双工通讯】

Java Websocket实例【服务端与客户端实现全双工通讯】

Java Websocket实例【服务端与客户端实现全双工通讯】 现很多网站为了实现即时通讯，所用的技术都是轮询(polling)。轮询是在特定的的时间间隔（如每1秒），由浏览器对服务器发 出HTTP request，然后由服务器返回最新的数据给客服端的浏览器。这种传统的HTTP request 的模式带来很明显的缺点 – 浏 览器需要不断的向服务器发出请求，然而HTTP
阅读更多...
安卓开发板_联发科MTK开发评估套件串口调试

安卓开发板_联发科MTK开发评估套件串口调试

串口调试 如果正在进行lk(little kernel ) 或内核开发，USB 串口适配器（ USB 转串口 TTL 适配器的简称）对于检查系统启动日志非常有用，特别是在没有图形桌面显示的情况下。 1.选购适配器 常用的许多 USB 转串口的适配器，按芯片来分，有以下几种： CH340PL2303CP2104FT232 一般来说，采用 CH340 芯片的适配器，性能比较稳定，价
阅读更多...
STM32 HAL CAN通讯 实操

STM32 HAL CAN通讯 实操

1、简介 相比于串口通讯，对于刚接触CAN通讯的小白来说，CAN通讯相对复杂，看各种视频、帖子理论，总是一知半解。本次通过傻瓜式操作，先实现CAN通讯的交互，以提高小白的信心，也便于自己复习观看。本次以STM32CubeMX进行初始化配置，通过Keil 5软件进行软件设计，通过CAN盒实现进行数据的交互。该流程实际以STM32F0、F1、F3、F4、F7实测好用（理论上都适用），这三种型号单片机
阅读更多...
VB和51单片机串口通信讲解（只针对VB部分）

VB和51单片机串口通信讲解（只针对VB部分）

标记：该篇文章全部搬自如下网址：http://www.crystalradio.cn/thread-321839-1-1.html，谢谢啦            里面关于中文接收的部分，大家可以好好学习下，题主也在研究中................... Commport；设置或返回串口号。 SettingS：以字符串的形式设置或返回串口通信参数。 Portopen：设置或返回串口
阅读更多...
关于Qt在子线程中使用通讯时发生无法接收数据的情况

关于Qt在子线程中使用通讯时发生无法接收数据的情况

在多线程应用中，串口通讯或TCP通讯的场景常常涉及到持续的读写操作，如果子线程处理不当，可能会导致信号阻塞问题。本文将通过串口通讯或TCP通讯为例，详细解释如何在多线程环境中避免信号阻塞，并提供代码示例。 1. 问题背景 假设我们在一个应用程序中使用多线程处理串口或TCP通讯，通常会在子线程中实现持续的数据读取。为了确保实时处理数据，常见的做法是在子线程的 run() 方法中使用 while
阅读更多...
java RXTXcomm 串口通信

java RXTXcomm 串口通信

RXTXcomm：提供了 Windows x64, x86, ia64 and Linux x86, x86_64等操作系统支持。 下载地址 http://fizzed.com/oss/rxtx-for-java 使用RXTXcomm首先要安排JRE环境，开发IED可能eclipse. 1.下载系统相应的RXTXcomm。 2.将rxtxSerial.dll、rxtxParallel.dl
阅读更多...
Nodejs 串口通信 ： websocket , serialport

Nodejs 串口通信 ： websocket , serialport

最近在学习如何实现web页面和串口间通信，网页请求使用websocket，实现的基本功能如下： 1、基本需求：硬件：有两个信号灯（TLA-505-1T），一个485继电器（开关），电压转换器，工业触屏一体机。 2、原理图：                  3工作原理： 首先一体机中采用node开发服务器，网页请求采用websocket协议，直接放代码了： var express
阅读更多...
C# WPF燃气报警器记录读取串口工具

C# WPF燃气报警器记录读取串口工具

C# WPF燃气报警器记录读取串口工具 概要串口帧数据布局文件代码文件运行效果源码下载 概要 符合国标文件《GB+15322.2-2019.pdf》串口通信协议定义；可读取燃气报警器家用版设备历史记录信息等信息； 串口帧数据 串口通信如何确定一帧数据接收完成是个麻烦事，本文采用最后一次数据接收完成后再过多少毫秒认为一帧数据接收完成，开始解析出来。每次接收到数据更新一次re
阅读更多...
QQ通讯协议

QQ通讯协议

不管UDP还是TCP，最终登陆成功之后，QQ都会有一个TCP连接来保持在线状态。这个TCP连接的远程端口一般是80，采用UDP方式登陆的时候，端口是8000。因此，假如你所在的网络开放了80端口（80端口是最常用端口。。就是通常访问Web的端口，禁掉它的话，你的网络对你来说价值已经不大了），但没有屏蔽腾讯的服务器IP，恭喜你，你是可以登陆成功QQ的。 二、聊天消息通信。       采用UDP协
阅读更多...
ubuntu14下Arduino IDE无法打开串口的问题

ubuntu14下Arduino IDE无法打开串口的问题

ubuntu版本是14.04 LTS，arduino版本是1.8.1。使用arduino的串口工具时无法打开串口，串口是USB转的，用的cp2102 。 google了一下，发现可能是权限的问题，执行以下语句，即可解决： sudo chown username /dev/ttyUSB0将username改成自己的用户名就行了。
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2