STC8G1K08串口通讯

最新推荐文章于 2024-05-31 22:48:21 发布
最新推荐文章于 2024-05-31 22:48:21 发布
阅读量1.3k 收藏 21
点赞数 20
文章标签： c# 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/czhaii/article/details/136594760
版权

 /***豆腐干下位机测试  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

czhaii
关注
  • 20
    点赞
  • 踩
  • 21
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
STC8系列4个串口全双工同时中断收发测试例程.txt
07-09
stc8A8K64S4A12四串口初始化和同时使用的C程序，非常好，希望能帮助到需要的人
STC8G_stc8g1k08a烧录_STC8g串口程序_stc8g1k08apudn_stc8g.zip
10-11
STC8G_stc8g1k08a烧录_STC8g串口程序_stc8g1k08apudn_stc8g.zip
第一次接触8脚单片机STC8G1K08，学习笔记
最新发布
m0_69775830的博客
05-31 1199
STC8G 系列单片机是不需要外部晶振和外部复位的单片机，是以超强抗干扰/超低价/高速/低功耗 为目标的 8051 单片机，在相同的工作频率下，STC8G 系列单片机比传统的 8051 约快 12 倍（速度快 11.2~13.2 倍），依次按顺序执行完全部的 111 条指令，STC8G 系列单片机仅需 147 个时钟，而传统 8051 则需要 1944 个时钟。（兼容8051就很赞）引用头文件参照手册就可以使用了（这里的定时器配置可以自己配置寄存器，也可以使用isp上的定时器计算器生成然后复制就可以了）
【STC8G1K08A串口使用】
m0_47459564的博客
02-25 2822
STC8G1K08A串口打印“Hello world”
【STC8G1K08A】串口收发测试程序——库函数版本
qq_36814408的博客
11-24 6700
串口收发测试
STC8G1K08A 串口无法烧录程序
Argon_Ghost的博客
05-04 5603
STC8G1K08A 串口无法烧录问题 现象描述 STC8G1K08A是不需要外置晶振的，因此只需要飞线出VCC GND TXD RXD 进行数据烧录即可，在首次烧录程序之后后续无法再次烧录。 问题分析 仔细阅读了数据手册后，看到其中一句话： 也就是说默认情况下P3.0和P3.1没有进行内部上拉，因此在下载器为3.3V电平时候不能很好的识别到电平。这里的做法很简单： 解决方法 1.对于已经烧录不进去的单片机，在外部对RXD和TXD进行10K-4.7K的上拉处理，即可烧录成功。 2.对于还未烧录的单片机为了
STC8G1K17A-8PIN(STC8G1K17)串口通讯(串口1),设置自动热加载程序代码(自动下载代码)
SmallWhitee的博客
09-01 1479
【代码】STC8G1K17A-8PIN串口1通讯,设置自动热加载程序代码(自动下载代码)
STC8G1K08_ADC.zip_STC8G1K08A_ad采集
07-14
STC8G1K08ADC.zip是一款与STC8G1K08A单片机相关的资源包，主要涉及的是单片机的模拟到数字（Analog to Digital，简称ADC）转换功能。在这个项目中，单片机将通过内部的ADC模块采集模拟信号，并通过串行通信接口...
stc8g1k08A_STC8G1K08A_stc801k08a_源码
10-02
STC8G1K08A是一款由STC公司生产的8位微控制器，属于STC8G系列。这款MCU以其高效能、低功耗和丰富的内置功能在嵌入式系统设计中广泛应用。本文将详细讲解STC8G1K08A的主要特性、模拟量处理以及与STC801K08A的区别。 ...
STC8G_stc8g1k08a烧录_STC8g串口程序_stc8g1k08apudn_stc8g
09-11
在STC8G_stc8g1k08a烧录项目中，主要涉及的是STC8G1K08APUDN型号的单片机，它具备内部集成的模拟数字转换器（ADC）和串行通信接口（UART），用于数据采集和串口通信。 ADC（模拟数字转换器）是将物理世界中的模拟...
STC8G1K08A芯片使用串口UART1打印调试信息，波特率115200
12-17
STC8G1K08A芯片使用串口UART1打印调试信息，波特率115200，STC8G1K08A是STC8G系列8位单片机芯片，由于其具有高性价比和丰富的外设资源，广泛应用于家电、工业、仪器仪表、通信等领域。 1. CPU内核：STC89C52RC 2. ...
STC8G1K08驱动Si24R1无线模块（1个发送程序1个接收程序）SPI通信
02-24
程序功能如下： 1.发送端发送数据， 2.接收端接收数据并返回响应并且串口输出数据 发送端收到响应点亮小灯 压缩包含2个程序 发送程序，接收程序
STC8G 51单片机 芯片.pdf
11-30
STC新出的STC8G芯片。两种低功耗模式：IDLE 模式和 STOP 模式。；2 个串口、3 个定时器、3 组 PCA 以及 I2C、SPI。
STC8系列参考代码资料
04-09
STC8系列源码分享 火龙电子FD51D_8_V1开发板资料
stc8g官方资源中文自取 stc8g1k08 stc8g1k08
11-04
stc8g官方资源中文自取 stc8g1k08 stc8g1k08
sTC8G1K08+通过串口显示内部电压_51单片机串口通信
weixin_39531374的博客
11-20 2970
物联网STM32入门 - 直播课程 - 创客学院​www.makeru.com.cn本文我们主要讲单片机上串口的工作原理和如何通过程序来对串口进行设置，以及根据所给出的实例实现与PC 机通信。一、原理简介51 单片机内部有一个全双工串行接口。什么叫全双工串口呢？一般来说，只能接受或只能发送的称为单工串行；既可接收又可发送，但不能同时进行的称为半双工；能同时接收和发送的串行口称为全双工串行口。串行通...
sTC8G1K08+通过串口显示内部电压_学电子-Arduino数字电压表的实现
weixin_39990138的博客
11-22 1957
1.硬件原理数字电压表硬件原理和AD采集实验的相同，通过滑动变阻器分压，分到0-5V的电压，然后Arduino的A0口采集这个模拟电压，完成AD转换。这一次我们用面包板和旋转式的滑动变阻器来实现，变阻器可调范围是0-5k。面包板和变阻器原理图2.程序解读算法描述：基本的算法和AD采集的相同，还没明白的AD采集的可以会看我的文章。只不过这个电压表是AD采集函数analogRead()采集到电压后，需...
STC8A串口数据发送与接收
Cymmmy的博客
11-03 2538
STC8A串口数据发送与接受
sTC8G1K08+通过串口显示内部电压_类串口屏，一种更强大的显示方案
weixin_39764379的博客
10-25 859
前两天收到了游芯科技赠的YOXISO显示屏，这是一种类串口屏的显示屏，但比串口屏强大很多。下面我们一起来简单了解一下：串口屏？ 首先先来认识认识串口屏。串口屏是一种很易用的显示方案。可能有些朋友没用过，这里简单介绍一下。串口屏界面的显示是设备内部自己实现的，用户 MCU 只是发送指令，并不需要底层驱动。再次，针对显示的人机界面的布局和大多数的逻辑(比如界面背景，按钮效果，文本显示等)。全...
stc8g1k08a串口中断没反应
08-08
STC8G1K08A是一款常见的单片机芯片，具有强大的功能和广泛的应用范围。当串口中断没有反应时，可能是由于以下几个原因导致的： 1. 硬件问题：首先要检查串口引脚的连接是否正确，包括串口发送引脚和接收引脚。可以使用示波器检测引脚信号是否正常。另外，还需要确保电源供应稳定，芯片工作温度符合要求。 2. 中断配置问题：要确保中断向量表中对应串口中断的中断服务程序是正确编写和配置的。检查中断优先级和中断使能位的设置是否正确。确保串口中断的中断标志位被清除。 3. 软件问题：检查程序中是否正确设置了串口中断的相关寄存器，包括设置中断标志位、配置中断的触发源和优先级等。还要检查是否正确地处理了接收和发送数据，在中断服务程序中进行相应的数据处理操作。 4. 波特率不匹配：在进行串口通信时，要确保发送端和接收端的波特率设置一致。如果波特率不匹配，会导致通信错误或无法收到有效数据。可通过波特率设置寄存器进行调整。 总结起来，解决STC8G1K08A串口中断没有反应的问题，需要仔细检查硬件连接是否正确、中断配置是否正确以及软件程序是否正确设置，并确保波特率匹配。如果以上都没有问题，可能需要进一步检查其他可能的故障原因或参考芯片相关的文档和资料。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值