单片机双工位吹瓶机C程序完整代码

/***双工位吹瓶机自动运行      控制测试通过***/
/***2022 5 28切管机PCB STC15W408AS    ***/
/***2023 3 14 L882 CODE505            ***/
              #include     <REG52.H>                       //
              #include     <intrins.H>                     //
              #include     "stdio.h"
              #include     "stdio.h"
              #include     <math.h>
              #include     <string.h>
              #define      uint unsigned int  
              #define      uchar unsigned char
              typedef      unsigned char   u8;
                            #define      WT_12M   0x83                       //IAP_CONTR
              #define      IAP_ADDRESS 0x0400              //EEPROM首地址
                    #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
              typedef      unsigned char BYTE;
              typedef      unsigned int  WORD;
              sbit         BP=P5^4;                        /***输出LED指示***/
              static       uint   i;                       //串口字节计数器
              uchar        kcounter,kstatus;               //按键计数标志 按键状态标志
              bit          Receive_Flag;                   //串口数据缓冲接收标志
              bit          RUN_Flag;                       //自动运行标志
              bit          S_Flag;                         //计时标志
                            bit          Signauto=0;                  /*退出循环检测*/
              uint         WARNING_Time;                   //报警计时计数器
                            uint         DAT1=0;
              uint         DAT2=0;
              uint         val1,val2,val3,val4,val5;       //左合模,左移模,左顶针,左吹气,右合模
                            uint         val6,val7,val8,val9;            //右移模,右顶针,右吹气,切料
              uint         Receive_Total;
              uint         a[10];                          //定义数组a 存储串口数据串
                          uchar        s;                        
                            uint         Counter;
                            sbit         ledgreen=P5^5;                  //
              sbit         OutPut1=P2^6;                   //
                            sbit         OutPut2=P2^7;                   //
                            sbit         OutPut3=P1^0;                   //
                            sbit         OutPut4=P1^1;                   //
                            sbit         OutPut5=P1^2;                   //
                            sbit         OutPut6=P1^3;                   //
                            sbit         OutPut7=P1^4;                   //
                            sbit         OutPut8=P1^5;                   //
                            sbit         OutPut9=P1^6;                   //
                            sbit         OutPut10=P1^7;                  //
                            sbit         IntPut1=P3^2;                   //
                            sbit         IntPut2=P3^3;                   //
                            sbit         IntPut3=P3^4;                   //
                            sbit         IntPut4=P3^5;                   //
/*---------------延时子程序----------------*/
              void delay1 (uint ms)
              {
              uint i,j;
              for(i=0;i<ms;i++)
              for(j=0;j<200;j++)
              ;
              }    
/*------------------延时子程序------------------------*/
              void delay10ms(uint x)
              {
               uint i, j;
               for (i=0;i<x;i++)
               for (j=0;j<500;j++);
              }
/*-----------延时100ms子程序12MHz --------*/
               void Delay_100ms(uint x)          //
               {
               uint i,j;
                for(i=0;i<x;i++)
                {
                for(j=0;j<18000;j++);
                }
               }
/****************按键计数器状态寄存器归零*************/
              void RstKey()
              {
              kcounter=0;                        //按键计数器归零
              kstatus=0;                         //状态寄存器归零
              }
/*****************按键低电平检测函数*****************/
              void   LowVoltKey(void)            //按键计数器状态标志加一
              {
              kcounter++;                       
              kstatus++;     
              _nop_();                           //延时                  
              }
/*****************按键高电平检测函数*****************/
              void    HighVoltKey(void)          //按键计数器加一 状态标志归零
              {
              kcounter++;                        //按键计数器加一
              kstatus=0;                         //按键状态标志归零
              _nop_();                           //延时
              }
/*-------------关闭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
                            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();
              }
/*************写参数到EEPROM*******************************/
                    void Write_EEprom()
                            {
                            IapEraseSector(IAP_ADDRESS); //扇区擦除
                            IapProgramByte(IAP_ADDRESS+1,val1>>8&0XFF);/*左合模高八位*/    
                          IapProgramByte(IAP_ADDRESS+2,val1&0x00FF); /*左合模低八位*/
                                
              IapProgramByte(IAP_ADDRESS+3,val2>>8&0XFF);/*左移模高八位*/  
                            IapProgramByte(IAP_ADDRESS+4,val2&0x00FF); /*左移模低八位*/
                                
                            IapProgramByte(IAP_ADDRESS+5,val3>>8&0XFF);/*左顶针高八位*/  
                            IapProgramByte(IAP_ADDRESS+6,val3&0x00FF); /*左顶针低八位*/

              IapProgramByte(IAP_ADDRESS+7,val4>>8&0XFF);/*左吹气高八位*/  
                            IapProgramByte(IAP_ADDRESS+8,val4&0x00FF); /*左吹气低八位*/
                                
                            IapProgramByte(IAP_ADDRESS+9,val5>>8&0XFF);/*右合模高八位*/  
                            IapProgramByte(IAP_ADDRESS+10,val5&0x00FF);/*右合模低八位*/

                            IapProgramByte(IAP_ADDRESS+11,val6>>8&0XFF);/*右移模高八位*/  
                            IapProgramByte(IAP_ADDRESS+12,val6&0x00FF); /*右移模低八位*/

              IapProgramByte(IAP_ADDRESS+13,val7>>8&0XFF);/*右顶针高八位*/  
                            IapProgramByte(IAP_ADDRESS+14,val7&0x00FF); /*右顶针低八位*/
                                
                            IapProgramByte(IAP_ADDRESS+15,val8>>8&0XFF);/*右吹气高八位*/  
                            IapProgramByte(IAP_ADDRESS+16,val8&0x00FF); /*右吹气低八位*/
                            
                            IapProgramByte(IAP_ADDRESS+17,val9>>8&0XFF);/*切料时间高八位*/  
                            IapProgramByte(IAP_ADDRESS+18,val9&0x00FF); /*切料时间低八位*/
                          }
/***********************************/
                    void red_eeprom(void)
              {
                            uint m,n;        
                            m=IapReadByte(IAP_ADDRESS+1);          //左合模高八位
                            n=IapReadByte(IAP_ADDRESS+2);          //左合模低八位
                            val1=(m*256+n)&0X7FFF;                   //左合模 屏蔽最高负位 111 1111
                            m=IapReadByte(IAP_ADDRESS+3);          //左移模高八位
                            n=IapReadByte(IAP_ADDRESS+4);          //左移模低八位
                            val2=(m*256+n)&0X7FFF;                   //左移模  屏蔽最高负位 111 1111
                            m=IapReadByte(IAP_ADDRESS+5);          //左顶针高八位
                            n=IapReadByte(IAP_ADDRESS+6);          //左顶针低八位
                            val3=(m*256+n)&0X7FFF;                   //左顶针 屏蔽最高负位 111 1111
                            m=IapReadByte(IAP_ADDRESS+7);          //左吹气高八位
                            n=IapReadByte(IAP_ADDRESS+8);          //左吹气低八位
                            val4=(m*256+n)&0X7FFF;                   //左吹气  屏蔽最高负位 111 1111    
                            m=IapReadByte(IAP_ADDRESS+9);          //右合模高八位
                            n=IapReadByte(IAP_ADDRESS+10);         //右合模低八位
                            val5=(m*256+n)&0X7FFF;                   //右合模 屏蔽最高负位 111 1111
                            m=IapReadByte(IAP_ADDRESS+11);         //右移模高八位
                            n=IapReadByte(IAP_ADDRESS+12);         //右移模低八位
                            val6=(m*256+n)&0X7FFF;                   //右移模 屏蔽最高负位 111 1111    
                            m=IapReadByte(IAP_ADDRESS+13);         //右顶针高八位
                            n=IapReadByte(IAP_ADDRESS+14);         //右顶针低八位
                            val7=(m*256+n)&0X7FFF;                   //右顶针  屏蔽最高负位 111 1111    
                            m=IapReadByte(IAP_ADDRESS+15);         //设定温度高八位
                            n=IapReadByte(IAP_ADDRESS+16);         //设定温度低八位
                            val8=(m*256+n)&0X7FFF;                   //设定温度 屏蔽最高负位 111 1111
                            m=IapReadByte(IAP_ADDRESS+17);         //切料时间高八位
                            n=IapReadByte(IAP_ADDRESS+18);         //切料时间低八位
                            val9=(m*256+n)&0X7FFF;                   //切料时间  屏蔽最高负位 111 1111        
                            }        
/***********************************/
                    void Dis_Data(void)
              {
                             printf("n0.val=%d\xff\xff\xff",val1);
               printf("n0.val=%d\xff\xff\xff",val1);     //
                             printf("n1.val=%d\xff\xff\xff",val2);
               printf("n2.val=%d\xff\xff\xff",val3);     //    
                             printf("n3.val=%d\xff\xff\xff",val4);
               printf("n4.val=%d\xff\xff\xff",val5);     //
                             printf("n5.val=%d\xff\xff\xff",val6);
               printf("n6.val=%d\xff\xff\xff",val7);     //
                             printf("n7.val=%d\xff\xff\xff",val8);
               printf("n8.val=%d\xff\xff\xff",val9);     //renovate
                            }                
/****************刷新显示*******************/                            
              void Renovate(void)
              {
                             uint mn;
                             mn=0X00;
                             printf("n0.val=%d\xff\xff\xff",mn);
               printf("n0.val=%d\xff\xff\xff",mn);     //
                             printf("n1.val=%d\xff\xff\xff",mn);
               printf("n2.val=%d\xff\xff\xff",mn);     //    
                             printf("n3.val=%d\xff\xff\xff",mn);
               printf("n4.val=%d\xff\xff\xff",mn);     //
                             printf("n5.val=%d\xff\xff\xff",mn);
               printf("n6.val=%d\xff\xff\xff",mn);     //
                             printf("n7.val=%d\xff\xff\xff",mn);
               printf("n8.val=%d\xff\xff\xff",mn);     //renovate
                             red_eeprom();
                             Delay_100ms(10);
                             Dis_Data();
                            }        
/******************************************************/                            
              void Data_Set(void )
              {
                                if (a[0]==0XD5&&a[1]==0X00)        //左合模
                                 {
                                 val1=a[3]*256+a[2];                     //
                                 Write_EEprom();
                                 Renovate();                             //刷新显示
                                 }
                                 else if (a[0]==0XD5&&a[1]==0X01)        //左移模
                                 {
                                 val2=a[3]*256+a[2];                     //
                                 Write_EEprom();
                                 Renovate();                             //刷新显示
                                 }
                                 else if (a[0]==0XD5&&a[1]==0X02)          //左顶针
                                 {
                                 val3=a[3]*256+a[2];                     //
                                 Write_EEprom();
                                 Renovate();                             //刷新显示
                                 }
                                 else if (a[0]==0XD5&&a[1]==0X03)          //左吹气
                                 {
                                 val4=a[3]*256+a[2];                     //
                                 Write_EEprom();
                                 Renovate();                             //刷新显示
                                 }
                                 else if (a[0]==0XD5&&a[1]==0X04)          //右合模
                                 {
                                 val5=a[3]*256+a[2];                     //
                                 Write_EEprom();
                                 Renovate();                             //刷新显示
                                 }
                                 else if (a[0]==0XD5&&a[1]==0X05)          //右移模
                                 {
                                 val6=a[3]*256+a[2];                     //
                                 Write_EEprom();
                                 Renovate();                             //刷新显示
                                 }
                                 else if (a[0]==0XD5&&a[1]==0X06)          //右顶针
                                 {
                                 val7=a[3]*256+a[2];                     //
                                 Write_EEprom();
                                 Renovate();                             //刷新显示
                                 }
                                 else if(a[0]==0XD5&&a[1]==0X07)          //右吹气
                                 {
                                 val8=a[3]*256+a[2];                     //
                                 Write_EEprom();
                                 Renovate();                             //刷新显示
                                 }
                                 else if(a[0]==0XD5&&a[1]==0X08)          //切料
                                 {
                                 val9=a[3]*256+a[2];                     //
                                 Write_EEprom();
                                 Renovate();                             //刷新显示
                                 }
                }            
/******************************************************/
              void serve_T0() interrupt 1 using 1
              {
               TH0=0x2f;
               TL0=0x40;
               DAT2++;
               if(DAT2>=100)
               {
               DAT2=0;
               BP=~BP;
               S_Flag=1;
               }
              }
 /*------------初始化串口---------------------*/
              void InitUart(void )
              {
              SCON=0X50;                         //8位数据,可变波特率
              AUXR|=0x01;                        //串口1选择定时器2为波特率发生器
              AUXR|=0X04;                        //定时器2时钟为Fosc,即1T
              T2L=0XE0;                          //设置定时器处置  110592》9600
              T2H=0XFE;                          //设置定时器处置  110592》9600
              AUXR|=0X10;                        //启动定时器2
              TI=1;
              ES=1;                        //
              EA=1;
              }
/*--------UART中断服务程序---串口4接收触摸屏数据---*/
              void Uart() interrupt 4 using 1
              {
               if(RI)
               {
                Receive_Total++;
                a[i]=SBUF;                       //数组下标位置的数据等于SBUF
                i++;
                if(i==9)                         //触摸屏结束码    FRAMELENGTH
                {
                 Receive_Flag=1;                     //接收数据标志置一
                                 if (a[0]==0XF0&&a[1]==0XF1)          //手动
                                 {
                                    i=0;                                     //数组计数器归零
                  Receive_Flag=0;
                                  OutPut10=1;                  //
                                  RUN_Flag=0;                              //自动运行标志
                                  }
                                 }
                RI=0;                             //
               }
                            }
/************************************/                            
                            void OffOut()
                            {
                            OutPut1=1;                   //
                            OutPut2=1;                   //
                            OutPut3=1;                   //
                            OutPut4=1;                   //
                            OutPut5=1;                   //
                            OutPut6=1;                   //
                            OutPut7=1;                   //
                            OutPut8=1;                   //
                            OutPut9=1;                   //
                            }
/*----------------------------------*/                        
                            void Run_start()
                            {
                             Counter=0X00;
               printf("n0.val=%d\xff\xff\xff",Counter);
                             DAT1=0X0A;                                 //显示自动
               printf("va0.val=%d\xff\xff\xff",DAT1);
                             do
                              {
                              Signauto=1;                        //行程开关循环标志
                    while(Signauto)                    /**/
                {
                               RstKey();
                               for(;kcounter<10;)                //按键循环10
                 {
                  if(!IntPut1)                     //按键低电平
                  {
                  LowVoltKey();                    //按键低电平 计数器加一状态标志加一
                  }
                  else if(~!IntPut1)               //按键高电平
                  {
                  HighVoltKey();                   //按键计数器加一    状态标志归零
                  }
                                  delay1(2);                        //2023
                 }
                 if(kstatus>=8)                    /*按键状态标志大于等于8为有效值*/
                 {     
                                  Signauto=0;                      /*行程输入信号连续检测到3次Signauto=0退出循环*/
                                  }
                                  if(RUN_Flag==0)                //手动标志
                        {
                                   Signauto=0;                       //Signauto=0退出循环
                         break;
                        }
                               }
                                if(RUN_Flag==0)                //手动标志
                      {
                                 Signauto=0;                       //Signauto=0退出循环
                       break;
                       }
                                else
                {                
                if(Receive_Flag==1)
                {
                                i=0;                                     //数组计数器归零
                Receive_Flag=0;
                                Data_Set();
                                }    
                                OutPut1=1;                                                 //左合模开
                                DAT1=0X01;                                 //显示左合模
                printf("va0.val=%d\xff\xff\xff",DAT1);
                                Delay_100ms(val1);
//2023 3 10            
                if(Receive_Flag==1)
                {
                                i=0;                                     //数组计数器归零
                Receive_Flag=0;
                                Data_Set();
                                }    
                                
                OutPut3=1;                                 //关闭左顶针
                                DAT1=0X03;                                 //显示左顶针
                printf("va0.val=%d\xff\xff\xff",DAT1);
                                Delay_100ms(val3);                                       
                                
                if(Receive_Flag==1)
                {
                                i=0;                                     //数组计数器归零
                Receive_Flag=0;
                                Data_Set();
                                }                                    
                                OutPut2=0;                                 //左移模
                                DAT1=0X02;                                 //显示左移模
                printf("va0.val=%d\xff\xff\xff",DAT1);
                                Delay_100ms(val2);
                                
                                if(Receive_Flag==1)
                {
                                i=0;                                     //数组计数器归零
                Receive_Flag=0;
                                Data_Set();
                                }    
                OutPut1=0;
                                DAT1=0X01;                                 //显示左合模
                printf("va0.val=%d\xff\xff\xff",DAT1);
                                Delay_100ms(val1);  
                                
                                if(Receive_Flag==1)
                {
                                i=0;                                     //数组计数器归零
                Receive_Flag=0;
                                Data_Set();
                                }    
                                OutPut9=~OutPut9;                          //左切料
                                DAT1=0X09;                                 //显示左切料
                printf("va0.val=%d\xff\xff\xff",DAT1);
                                Delay_100ms(val9);
                                
                                if(Receive_Flag==1)
                {
                                i=0;                                     //数组计数器归零
                Receive_Flag=0;
                                Data_Set();
                                }    
                OutPut2=1;                                 //左移模回程
                                DAT1=0X02;                                 //显示左移模
                printf("va0.val=%d\xff\xff\xff",DAT1);
                                Delay_100ms(val2);
                                }
                                RstKey();
                              Signauto=1;                                             //行程开关循环标志
                      while(Signauto)                    
                {
//位置检测                                    
                                 RstKey();                                       //左移模回 限位
                                 for(;kcounter<5;)                         //按键循环5次
                                 {
                                    if(!IntPut2)                     //按键低电平
                                    {
                                    LowVoltKey();                    //按键低电平 计数器加一状态标志加一
                                    }
                                    else if(~!IntPut2)               //按键高电平
                                    {
                                    HighVoltKey();                   //按键计数器加一    状态标志归零
                                    }
                                 }
                                  if(kstatus>=3)                    /*按键状态标志大于等于3为有效值*/
                                  {                                 //左移模退位置打退出循环转下一个动作
                                  Signauto=0;                       /*行程输入信号连续检测到3次Signauto=0退出循环*/
                                  }
//转手动按键检测
                        if(RUN_Flag==0)                   /**/
                  {
                        Signauto=0;                       //Signauto=0退出循环
                        break;
                  }
                     }
                if(RUN_Flag==0)                //手动标志
                      {
                                 Signauto=0;                       //Signauto=0退出循环
                       break;
                       }
                                else
                {        
                if(Receive_Flag==1)
                {
                                i=0;                                     //数组计数器归零
                Receive_Flag=0;
                                Data_Set();
                                }        
                    //            Delay_100ms(val2);                  //左移模回程加延时
                                if(Receive_Flag==1)
                {
                                i=0;                                     //数组计数器归零
                Receive_Flag=0;
                                Data_Set();
                                }    
                                OutPut3=0;                                 //左顶针
                                DAT1=0X03;                                 //显示左顶针
                printf("va0.val=%d\xff\xff\xff",DAT1);
                                Delay_100ms(val3);
                                
                                if(Receive_Flag==1)
                {
                                i=0;                                     //数组计数器归零
                Receive_Flag=0;
                                Data_Set();
                                }    
                                OutPut4=0;                                 //左吹气
                                DAT1=0X04;                                 //显示左吹气
                printf("va0.val=%d\xff\xff\xff",DAT1);
                                Delay_100ms(val4);
                                
                                OutPut4=1;                                   //关闭左吹气
//                                OutPut3=1;                                 //关闭左顶针
//                                DAT1=0X03;                                 //显示左顶针
//                printf("va0.val=%d\xff\xff\xff",DAT1);
//                                Delay_100ms(val3);   
                                Counter++;
                                printf("n0.val=%d\xff\xff\xff",Counter);    
/*********************************************/                            

                                if(Receive_Flag==1)
                {
                                i=0;                                     //数组计数器归零
                Receive_Flag=0;
                                Data_Set();
                                }    
                OutPut5=1;                                 //右开模
                                DAT1=0X05;                                 //显示右合模
                printf("va0.val=%d\xff\xff\xff",DAT1);
                                Delay_100ms(val5);  

//2023 3 10                                
                if(Receive_Flag==1)
                {
                                i=0;                                     //数组计数器归零
                Receive_Flag=0;
                                Data_Set();
                                }    
                                OutPut7=1;                                 //关闭右顶针
                              DAT1=0X07;                                 //显示右顶针
                printf("va0.val=%d\xff\xff\xff",DAT1);
                              Delay_100ms(val7);

                                if(Receive_Flag==1)
                {
                                i=0;                                     //数组计数器归零
                Receive_Flag=0;
                                Data_Set();
                                }    
                                OutPut6=0;                                 //右移模
                                DAT1=0X06;                                 //显示右移模
                printf("va0.val=%d\xff\xff\xff",DAT1);
                                Delay_100ms(val6);

                if(Receive_Flag==1)
                {
                                i=0;                                     //数组计数器归零
                Receive_Flag=0;
                                Data_Set();
                                }    
                                OutPut5=0;
                                DAT1=0X05;                                 //显示右合模
                printf("va0.val=%d\xff\xff\xff",DAT1);
                                Delay_100ms(val7);  //IntPut4
                                
                                for(;kcounter<8;)                 //按键循环5次
                                 {
                                    if(!IntPut4)                     //按键低电平
                                    {
                                    LowVoltKey();                    //按键低电平 计数器加一状态标志加一
                                    }
                                    else if(~!IntPut4)               //按键高电平
                                    {
                                    HighVoltKey();                   //按键计数器加一    状态标志归零
                                    }
                                 }
                                 if(kstatus>=5)                    /*按键状态标志大于等于3为有效值*/
                                 {
                                    OutPut9=~OutPut9;                                 //右切料
                                    DAT1=0X09;                                 //
                                    printf("va0.val=%d\xff\xff\xff",DAT1);
                                    Delay_100ms(val9);                                        
                                 }
                                
                                if(Receive_Flag==1)
                {
                                i=0;                                     //数组计数器归零
                Receive_Flag=0;
                                Data_Set();
                                }    
                                
                                OutPut6=1;                                 //右移模回程
                                DAT1=0X06;                                 //显示右移模
                printf("va0.val=%d\xff\xff\xff",DAT1);
                                Delay_100ms(val6);
                                }
                                Signauto=1;
                      while(Signauto)                    
                {
                                 RstKey();                               //右移模回 限位
                                 for(;kcounter<8;)                 //按键循环5次
                                 {
                                    if(!IntPut3)                     //按键低电平
                                    {
                                    LowVoltKey();                    //按键低电平 计数器加一状态标志加一
                                    }
                                    else if(~!IntPut3)               //按键高电平
                                    {
                                    HighVoltKey();                   //按键计数器加一    状态标志归零
                                    }
                                 }
                                  if(kstatus>=5)                    /*按键状态标志大于等于3为有效值*/
                                  {                                 //左移模退位置打退出循环转下一个动作
                                    OutPut1=1;                        //左开模
                                  Signauto=0;                       /*行程输入信号连续检测到3次Signauto=0退出循环*/
                                  }
//转手动按键检测
                        if(RUN_Flag==0)                   /**/
                  {
                        Signauto=0;                       //Signauto=0退出循环
                        break;
                  }
                     }    
                                if(RUN_Flag==0)                //手动标志
                      {
                                 Signauto=0;                       //Signauto=0退出循环
                       break;
                       }
                                else
                {    

                                if(Receive_Flag==1)
                {
                                i=0;                                     //数组计数器归零
                Receive_Flag=0;
                                Data_Set();
                                }        
                    //            Delay_100ms(val6);                  //右移模回程加延时
                                
                                OutPut7=0;                                 //右顶针
                                DAT1=0X07;                                 //显示右顶针
                printf("va0.val=%d\xff\xff\xff",DAT1);
                                Delay_100ms(val7);
                                OutPut8=0;                                 //右吹气
                                DAT1=0X08;                                 //显示右吹气
                printf("va0.val=%d\xff\xff\xff",DAT1);
                                Delay_100ms(val8);
                                OutPut8=1;                                 //关闭右吹气
//右顶针                                
                                Counter++;
                                printf("n0.val=%d\xff\xff\xff",Counter);    
                                }
                             }
                             while(RUN_Flag);
                             OffOut();
                             Delay_100ms(20);
                             DAT1=0X0B;                                 //显示待机
               printf("va0.val=%d\xff\xff\xff",DAT1);
                             }
/*------------------主循环程序----------------*/      
              void   main( )                     /*主程序开始*/
              {                                  /**加一**/
              P0M0 = 0x00;
              P0M1 = 0x00;
                            P1M0 = 0x00;
              P1M1 = 0x00;
                            P2M0 = 0x00;
              P2M1 = 0x00;
              P3M0 = 0x00;
              P3M1 = 0x00;
              P5M0 = 0x00;
              P5M1 = 0x00;
              AUXR=0X80;                         //STC系列的1T 设置
              i=0;                             //数组计数器归零
              Receive_Total=0;
              TH0=0x2f;
              TL0=0x40;                             //ledred=P5^4;
              ET0=1;                             //使能定时器中
              TR0=1;                             //启动定时器
              BP=1;  
              delay1(2000);
              BP=0;
              delay1(2000);
              BP=1;  
              delay1(2000);
              BP=0;
              delay1(2000);
              BP=1;  
              red_eeprom();
              InitUart();                        //初始化串口
              P_SW1=0x00;                        //RXD_2/P3.0, TXD_2/P3.1
              delay10ms(100);
              printf("0XFF,0XFF,0XFF");          //向串口屏发启动信号
              delay10ms(50);
              Counter=0X00;
              printf("n0.val=%d\xff\xff\xff",Counter);
              printf("n0.val=%d\xff\xff\xff",Counter);     //
              Receive_Flag=0;                     //接收数据标志置零
              S_Flag=0;                             //秒计时标志
              ET0=1;
              TR0=1;
              WARNING_Time=0;                          //报警计时计数器
              RUN_Flag=0;                              //自动运行标志
                            OffOut();
              while(1)
              {
              // ledred=~ledred;
               ledgreen=1;
               delay10ms(100);
                             if(Receive_Flag==1)
                {
                                i=0;                                     //数组计数器归零
                Receive_Flag=0;
                                 if (a[0]==0XB5&&a[1]==0X01)             //左合模
                                 {
                                    if (a[2]==0X01)
                                    OutPut1=0;                              //     
                                    else if(a[2]==0X00)
                                    OutPut1=1;                              //     
                                 }
                                 else if(a[0]==0XB5&&a[1]==0X02)         //左移模
                                 {
                                    if (a[2]==0X01)
                                    OutPut2=0;                              //     
                                    else if(a[2]==0X00)
                                    OutPut2=1;                              //     
                                 }
                                 else if(a[0]==0XB5&&a[1]==0X03)         //左顶针
                                 {
                                    if (a[2]==0X01)
                                    OutPut3=0;                              //     
                                    else if(a[2]==0X00)
                                    OutPut3=1;                              //     
                                 }
                                 else if(a[0]==0XB5&&a[1]==0X04)         //左吹气
                                 {
                                    if (a[2]==0X01)
                                    OutPut4=0;                              //     
                                    else if(a[2]==0X00)
                                    OutPut4=1;                              //     
                                 }
                                 else if(a[0]==0XB5&&a[1]==0X05)         //右合模
                                 {
                                    if (a[2]==0X01)
                                    OutPut5=0;                              //     
                                    else if(a[2]==0X00)
                                    OutPut5=1;                              //     
                                 }
                                 else if(a[0]==0XB5&&a[1]==0X06)         //右移模
                                 {
                                    if (a[2]==0X01)
                                    OutPut6=0;                              //     
                                    else if(a[2]==0X00)
                                    OutPut6=1;                              //     
                                 }
                                 else if(a[0]==0XB5&&a[1]==0X07)         //右顶针
                                 {
                                    if (a[2]==0X01)
                                    OutPut7=0;                              //     
                                    else if(a[2]==0X00)
                                    OutPut7=1;                              //     
                                 }
                                 else if(a[0]==0XB5&&a[1]==0X08)         //右吹气
                                 {
                                    if (a[2]==0X01)
                                    OutPut8=0;                              //     
                                    else if(a[2]==0X00)
                                    OutPut8=1;                              //     
                                 }
                                 else if(a[0]==0XB5&&a[1]==0X09)         //切料 按下
                                 {
                                    if (a[2]==0X01)
                                    OutPut9=0;                              //     
                                    else if(a[2]==0X00)
                                    OutPut9=1;                              //     
                                 }
                                 else if (a[0]==0XF5&&a[1]==0X05)          //
                                 {
                                 Dis_Data();                             //参数显示
                                 }
                                 else if (a[0]==0XF5&&a[1]==0XC5)          //page0 产量显示
                                 {
                                 Delay_100ms(20);
                                 printf("n0.val=%d\xff\xff\xff",Counter);
                                 printf("n0.val=%d\xff\xff\xff",Counter);     //                            
                                 }
                                 else if (a[0]==0XD5&&a[1]==0X00)        //左合模
                                 {
                                 val1=a[3]*256+a[2];                     //
                                 Write_EEprom();
                                 Renovate();                             //刷新显示
                                 }
                                 else if (a[0]==0XD5&&a[1]==0X01)        //左移模
                                 {
                                 val2=a[3]*256+a[2];                     //
                                 Write_EEprom();
                                 Renovate();                             //刷新显示
                                 }
                                 else if (a[0]==0XD5&&a[1]==0X02)          //左顶针
                                 {
                                 val3=a[3]*256+a[2];                     //
                                 Write_EEprom();
                                 Renovate();                             //刷新显示
                                 }
                                 else if (a[0]==0XD5&&a[1]==0X03)          //左吹气
                                 {
                                 val4=a[3]*256+a[2];                     //
                                 Write_EEprom();
                                 Renovate();                             //刷新显示
                                 }
                                 else if (a[0]==0XD5&&a[1]==0X04)          //右合模
                                 {
                                 val5=a[3]*256+a[2];                     //
                                 Write_EEprom();
                                 Renovate();                             //刷新显示
                                 }
                                 else if (a[0]==0XD5&&a[1]==0X05)          //右移模
                                 {
                                 val6=a[3]*256+a[2];                     //
                                 Write_EEprom();
                                 Renovate();                             //刷新显示
                                 }
                                 else if (a[0]==0XD5&&a[1]==0X06)          //右顶针
                                 {
                                 val7=a[3]*256+a[2];                     //
                                 Write_EEprom();
                                 Renovate();                             //刷新显示
                                 }
                                 else if(a[0]==0XD5&&a[1]==0X07)          //右吹气
                                 {
                                 val8=a[3]*256+a[2];                     //
                                 Write_EEprom();
                                 Renovate();                             //刷新显示
                                 }
                                 else if(a[0]==0XD5&&a[1]==0X08)          //切料
                                 {
                                 val9=a[3]*256+a[2];                     //
                                 Write_EEprom();
                                 Renovate();                             //刷新显示
                                 }
                                 else if (a[0]==0XF0&&a[1]==0X1F)          //自动
                                 {
                                 OutPut10=0;                  //
                                 RUN_Flag=1;                              //自动运行标志
                                 }
                
                if(RUN_Flag==1)        
                {
                                Run_start();
                                }                                    
                ledgreen=0;
                delay10ms(20);     //等待上一个数据发送完成
                                Delay_100ms(2);
                RstKey();
                LowVoltKey();
                HighVoltKey();
                                }
                             }
              }                                     //2023 3 10 L882 CODE5054

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.mfbz.cn/a/576566.html

如若内容造成侵权/违法违规/事实不符,请联系我们进行投诉反馈qq邮箱809451989@qq.com,一经查实,立即删除!

相关文章

怎么把图片转换为二维码?3个步骤轻松制作图片二维码

图片的二维码是怎么做成的呢&#xff1f;现在很多场景下的二维码&#xff0c;用手机扫码可以展现出对应的图片信息。通过这种方式来传递图片对于用户体验与很好的效果&#xff0c;而且也方便制作者通过这种方式来快速完成图片信息的传递&#xff0c;与传统方式相比成本更低&…

客服专用的宝藏快捷回复软件

提起客服&#xff0c;很多人会觉得现在智能机器人的自动回复功能就可以将其替代。我始终不是这么认为的。人工客服始终能为一家店铺乃至一个企业起着非常关键重要的作用。今天就来给大家推荐一个客服专用的宝藏软件——客服宝聊天助手。感兴趣的话&#xff0c;可以发给你的客服…

面向对象开发技术(第三周)

回顾 上一堂课主要学习了面向对象编程与非面向对象编程&#xff08;面向功能、过程编程&#xff09;&#xff0c;本节课就重点来看看面向对象编程中的一个具体思想——抽象 面向对象编程的特性&#xff1a;1、封装性 2、继承性 3、多态性 封装&#xff1a;意味着提供服务接口…

异常风云:解码 Java 异常机制

哈喽&#xff0c;各位小伙伴们&#xff0c;你们好呀&#xff0c;我是喵手。 今天我要给大家分享一些自己日常学习到的一些知识点&#xff0c;并以文字的形式跟大家一起交流&#xff0c;互相学习&#xff0c;一个人虽可以走的更快&#xff0c;但一群人可以走的更远。 我是一名后…

【论文阅读】《Octopus v2: On-device language model for super agent》,端侧大模型的应用案例

今年LLM的发展趋势之一&#xff0c;就是端侧LLM快速发展&#xff0c;超级APP入口之争异常激烈。不过&#xff0c;端侧LLM如何应用&#xff0c;不知道细节就很难理解。正好&#xff0c;《Octopus v2: On-device language model for super agent》这篇文章可以解惑。 对比部署在…

JTAG访问xilinx FPGA的IDCODE

之前调试过xilinx的XVC&#xff08;Xilinx virtual cable&#xff09;&#xff0c;突然看到有人搞wifi-JTAG&#xff08;感兴趣可以参考https://github.com/kholia/xvc-esp8266&#xff09;&#xff0c;也挺有趣的。就突然想了解一下JTAG是如何运作的&#xff0c;例如器件识别&…

普通话水平测试用朗读作品60篇-(练习版)

普通话考试题型有读单音节字词、读多音节字词、朗读作品和命题说话。 具体分值如下&#xff1a; 1、读单音节字词100个&#xff0c;占10分&#xff1b;目的考查应试人普通话声母、韵母和声调的发音。 2、读双音节词语50个&#xff0c;占20分&#xff1b;目的是除了考查应试人声…

骨传导耳机怎么选?精心挑选热销排行前五的骨传导耳机推荐!

近几年&#xff0c;骨传导耳机作为新型蓝牙耳机款式&#xff0c;已经得到大家有效认可&#xff0c;可以说已经适用于日常中的各种场景中&#xff0c;比如运动场景&#xff0c;凭借舒适的佩戴体验和保护运动安全的特点深受到运动爱好者的欢迎&#xff0c;作为一个经验丰富的数码…

Linux网络—DNS域名解析服务

目录 一、BIND域名服务基础 1、DNS系统的作用及类型 DNS系统的作用 DNS系统类型 DNS域名解析工作原理&#xff1a; DNS域名解析查询方式&#xff1a; 2、BIND服务 二、使用BIND构建域名服务器 1、构建主、从域名服务器 1&#xff09;主服务器配置&#xff1a; 2&…

Windows主机入侵检测与防御内核技术深入解析

第2章 模块防御的设计思想 2.1 执行与模块执行 本章内容为介绍模块执行防御。在此我将先介绍“执行”分类&#xff0c;以及“模块执行”在“执行”中的位置和重要性。 2.1.1 初次执行 恶意代码&#xff08;或者行为&#xff09;要在被攻击的机器上执行起来&#xff0c;看起…

C语言----单链表的实现

前面向大家介绍了顺序表以及它的实现&#xff0c;今天我们再来向大家介绍链表中的单链表。 1.链表的概念和结构 1.1 链表的概念 链表是一种在物理结构上非连续&#xff0c;非顺序的一种存储结构。链表中的数据的逻辑结构是由链表中的指针链接起来的。 1.2 链表的结构 链表…

茴香豆:搭建你的RAG智能助理-笔记三

本次课程由书生浦语社区贡献者【北辰】老师讲解【茴香豆&#xff1a;搭建你的 RAG 智能助理】课程 课程视频&#xff1a;https://www.bilibili.com/video/BV1QA4m1F7t4/ 课程文档&#xff1a;Tutorial/huixiangdou/readme.md at camp2 InternLM/Tutorial GitHub 该课程&…

江苏开放大学2024年春《会计基础 050266》第二次任务:第二次过程性考核参考答案

电大搜题 多的用不完的题库&#xff0c;支持文字、图片搜题&#xff0c;包含国家开放大学、广东开放大学、超星等等多个平台题库&#xff0c;考试作业必备神器。 公众号 答案&#xff1a;更多答案&#xff0c;请关注【电大搜题】微信公众号 答案&#xff1a;更多答案&#…

记账本React案例(Redux管理状态)

文章目录 整体架构流程 环境搭建 创建项目 技术细节 一、别名路径配置 1.路径解析配置&#xff08;webpack&#xff09; &#xff0c;将/解析为src/ 2.路径联想配置&#xff08;vsCode&#xff09;&#xff0c;使用vscode编辑器时&#xff0c;自动联想出来src文件夹下的…

【java数据结构-优先级队列向下调整Topk问题,堆的常用的接口详解】

&#x1f308;个人主页&#xff1a;努力学编程’ ⛅个人推荐&#xff1a;基于java提供的ArrayList实现的扑克牌游戏 |C贪吃蛇详解 ⚡学好数据结构&#xff0c;刷题刻不容缓&#xff1a;点击一起刷题 &#x1f319;心灵鸡汤&#xff1a;总有人要赢&#xff0c;为什么不能是我呢 …

SCI一区级 | Matlab实现BES-CNN-GRU-Mutilhead-Attention多变量时间序列预测

SCI一区级 | Matlab实现BES-CNN-GRU-Mutilhead-Attention秃鹰算法优化卷积门控循环单元融合多头注意力机制多变量时间序列预测 目录 SCI一区级 | Matlab实现BES-CNN-GRU-Mutilhead-Attention秃鹰算法优化卷积门控循环单元融合多头注意力机制多变量时间序列预测预测效果基本介绍…

【C++杂货铺】多态

目录 &#x1f308;前言&#x1f308; &#x1f4c1;多态的概念 &#x1f4c1; 多态的定义及实现 &#x1f4c2; 多态的构成条件 &#x1f4c2; 虚函数 &#x1f4c2; 虚函数重写 &#x1f4c2; C11 override 和 final &#x1f4c2; 重载&#xff0c;覆盖&#xff08;重写…

力扣-1832.判断句子是否全为字母句

思路: 首先&#xff0c;我们初始化了一个长度为 26 的布尔值列表 exist&#xff0c;所有值都为 False&#xff0c;表示所有字母初始都未出现过。然后&#xff0c;我们遍历输入的字符串 sentence 中的每个字符。对于每个字符&#xff0c;我们通过计算其 ASCII 码值减去字母 a 的…

微信小程序关于主包大小不能超过1.5MB的问题

常规的解决办法有以下几种 1、把资源文件改成远程服务器的&#xff0c;比如png这些 2、进入如图的分析页面&#xff0c;能明确知道你哪个插件包太大&#xff0c;我这里之前echart的包就1mb&#xff0c;现在给他缩减到了500kb的样子 3、解决vant等npm包太大的问题&#xff0c…

用过最佳的wordpress模板

西瓜红&#xff0c;作为一种充满活力和激情的颜色&#xff0c;总是能给人留下深刻的印象。当这种鲜艳的色彩与经典的设计元素相结合时&#xff0c;就能打造出一款既时尚又实用的WordPress企业模板。今天&#xff0c;我们向您隆重推荐这款西瓜红经典配色WordPress企业模板。 这…
最新文章