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

2024-04-26 23:52
文章标签 代码 程序 单片机 完整 工位 吹瓶机

本文主要是介绍单片机双工位吹瓶机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

这篇关于单片机双工位吹瓶机C程序完整代码的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


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

相关文章

SpringBoot基于MyBatis-Plus实现Lambda Query查询的示例代码

SpringBoot基于MyBatis-Plus实现Lambda Query查询的示例代码

《SpringBoot基于MyBatis-Plus实现LambdaQuery查询的示例代码》MyBatis-Plus是MyBatis的增强工具,简化了数据库操作,并提高了开发效率,它提供了多种查询方... 目录引言基础环境配置依赖配置（Maven）application.yml 配置表结构设计demo_st
阅读更多...
SpringCloud集成AlloyDB的示例代码

SpringCloud集成AlloyDB的示例代码

《SpringCloud集成AlloyDB的示例代码》AlloyDB是GoogleCloud提供的一种高度可扩展、强性能的关系型数据库服务,它兼容PostgreSQL,并提供了更快的查询性能... 目录1.AlloyDBjavascript是什么？AlloyDB 的工作原理2.搭建测试环境3.代码工程1.
阅读更多...
Java调用Python代码的几种方法小结

Java调用Python代码的几种方法小结

《Java调用Python代码的几种方法小结》Python语言有丰富的系统管理、数据处理、统计类软件包,因此从java应用中调用Python代码的需求很常见、实用,本文介绍几种方法从java调用Pyt... 目录引言Java core使用ProcessBuilder使用Java脚本引擎总结引言python
阅读更多...
Java中ArrayList的8种浅拷贝方式示例代码

Java中ArrayList的8种浅拷贝方式示例代码

《Java中ArrayList的8种浅拷贝方式示例代码》：本文主要介绍Java中ArrayList的8种浅拷贝方式的相关资料,讲解了Java中ArrayList的浅拷贝概念,并详细分享了八种实现浅... 目录引言什么是浅拷贝？ArrayList 浅拷贝的重要性方法一：使用构造函数方法二：使用 addAll(
阅读更多...
JAVA利用顺序表实现“杨辉三角”的思路及代码示例

JAVA利用顺序表实现“杨辉三角”的思路及代码示例

《JAVA利用顺序表实现“杨辉三角”的思路及代码示例》杨辉三角形是中国古代数学的杰出研究成果之一,是我国北宋数学家贾宪于1050年首先发现并使用的,：本文主要介绍JAVA利用顺序表实现杨辉三角的思... 目录一：“杨辉三角”题目链接二：题解代码：三：题解思路：总结一：“杨辉三角”题目链接题目链接：点击这里
阅读更多...
SpringBoot使用注解集成Redis缓存的示例代码

SpringBoot使用注解集成Redis缓存的示例代码

《SpringBoot使用注解集成Redis缓存的示例代码》：本文主要介绍在SpringBoot中使用注解集成Redis缓存的步骤,包括添加依赖、创建相关配置类、需要缓存数据的类（Tes... 目录一、创建 Caching 配置类二、创建需要缓存数据的类三、测试方法Spring Boot 熟悉后，集成一个外
阅读更多...
mysql重置root密码的完整步骤(适用于5.7和8.0)

mysql重置root密码的完整步骤(适用于5.7和8.0)

《mysql重置root密码的完整步骤(适用于5.7和8.0)》：本文主要介绍mysql重置root密码的完整步骤,文中描述了如何停止MySQL服务、以管理员身份打开命令行、替换配置文件路径、修改... 目录第一步：先停止mysql服务，一定要停止！方式一：通过命令行关闭mysql服务方式二：通过服务项关闭
阅读更多...
轻松掌握python的dataclass让你的代码更简洁优雅

轻松掌握python的dataclass让你的代码更简洁优雅

《轻松掌握python的dataclass让你的代码更简洁优雅》本文总结了几个我在使用Python的dataclass时常用的技巧,dataclass装饰器可以帮助我们简化数据类的定义过程,包括设置默... 目录1. 传统的类定义方式2. dataclass装饰器定义类2.1. 默认值2.2. 隐藏敏感信息
阅读更多...
opencv实现像素统计的示例代码

opencv实现像素统计的示例代码

《opencv实现像素统计的示例代码》本文介绍了OpenCV中统计图像像素信息的常用方法和函数,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一... 目录1. 统计像素值的基本信息2. 统计像素值的直方图3. 统计像素值的总和4. 统计非零像素的数量
阅读更多...
IDEA常用插件之代码扫描SonarLint详解

IDEA常用插件之代码扫描SonarLint详解

《IDEA常用插件之代码扫描SonarLint详解》SonarLint是一款用于代码扫描的插件,可以帮助查找隐藏的bug,下载并安装插件后,右键点击项目并选择“Analyze”、“Analyzewit... 目录SonajavascriptrLint 查找隐藏的bug下载安装插件扫描代码查看结果总结Sona
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2