单片机双工位吹瓶机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。

相关文章

HTML5的input标签的`type`属性值详解和代码示例

HTML5的input标签的`type`属性值详解和代码示例

《HTML5的input标签的`type`属性值详解和代码示例》HTML5的`input`标签提供了多种`type`属性值,用于创建不同类型的输入控件,满足用户输入的多样化需求,从文本输入、密码输入、... 目录一、引言二、文本类输入类型2.1 text2.2 password2.3 textarea（严格
阅读更多...
Python+FFmpeg实现视频自动化处理的完整指南

Python+FFmpeg实现视频自动化处理的完整指南

《Python+FFmpeg实现视频自动化处理的完整指南》本文总结了一套在Python中使用subprocess.run调用FFmpeg进行视频自动化处理的解决方案,涵盖了跨平台硬件加速、中间素材处理... 目录一、 跨平台硬件加速：统一接口设计1. 核心映射逻辑2. python 实现代码二、 中间素材处
阅读更多...
JAVA项目swing转javafx语法规则以及示例代码

JAVA项目swing转javafx语法规则以及示例代码

《JAVA项目swing转javafx语法规则以及示例代码》：本文主要介绍JAVA项目swing转javafx语法规则以及示例代码的相关资料,文中详细讲解了主类继承、窗口创建、布局管理、控件替换、... 目录最常用的“一行换一行”速查表（直接全局替换）实际转换示例（JFramejs → JavaFX）迁移建
阅读更多...
Go异常处理、泛型和文件操作实例代码

Go异常处理、泛型和文件操作实例代码

《Go异常处理、泛型和文件操作实例代码》Go语言的异常处理机制与传统的面向对象语言（如Java、C#）所使用的try-catch结构有所不同,它采用了自己独特的设计理念和方法,：本文主要介绍Go异... 目录一：异常处理常见的异常处理向上抛中断程序恢复程序二：泛型泛型函数泛型结构体泛型切片泛型 map三：文
阅读更多...
MyBatis中的两种参数传递类型详解(示例代码)

MyBatis中的两种参数传递类型详解(示例代码)

《MyBatis中的两种参数传递类型详解(示例代码)》文章介绍了MyBatis中传递多个参数的两种方式,使用Map和使用@Param注解或封装POJO,Map方式适用于动态、不固定的参数,但可读性和安... 目录✅ android方式一：使用Map<String, Object>✅ 方式二：使用@Param
阅读更多...
SpringBoot实现图形验证码的示例代码

SpringBoot实现图形验证码的示例代码

《SpringBoot实现图形验证码的示例代码》验证码的实现方式有很多,可以由前端实现,也可以由后端进行实现,也有很多的插件和工具包可以使用,在这里,我们使用Hutool提供的小工具实现,本文介绍Sp... 目录项目创建前端代码实现约定前后端交互接口需求分析接口定义Hutool工具实现服务器端代码引入依赖获
阅读更多...
利用Python在万圣节实现比心弹窗告白代码

利用Python在万圣节实现比心弹窗告白代码

《利用Python在万圣节实现比心弹窗告白代码》：本文主要介绍关于利用Python在万圣节实现比心弹窗告白代码的相关资料,每个弹窗会显示一条温馨提示,程序通过参数方程绘制爱心形状,并使用多线程技术... 目录前言效果预览要点1. 爱心曲线方程2. 显示温馨弹窗函数（详细拆解）2.1 函数定义和延迟机制2.2
阅读更多...
C#实现插入与删除Word文档目录的完整指南

C#实现插入与删除Word文档目录的完整指南

《C#实现插入与删除Word文档目录的完整指南》在日常的办公自动化或文档处理场景中,Word文档的目录扮演着至关重要的角色,本文将深入探讨如何利用强大的第三方库Spire.Docfor.NET,在C#... 目录Spire.Doc for .NET 库：Word 文档处理利器自动化生成：C# 插入 Word
阅读更多...
Springmvc常用的注解代码示例

Springmvc常用的注解代码示例

《Springmvc常用的注解代码示例》本文介绍了SpringMVC中常用的控制器和请求映射注解,包括@Controller、@RequestMapping等,以及请求参数绑定注解,如@Request... 目录一、控制器与请求映射注解二、请求参数绑定注解三、其他常用注解（扩展）四、注解使用注意事项一、控制
阅读更多...
使用C#导出Excel数据并保存多种格式的完整示例

使用C#导出Excel数据并保存多种格式的完整示例

《使用C#导出Excel数据并保存多种格式的完整示例》在现代企业信息化管理中,Excel已经成为最常用的数据存储和分析工具,从员工信息表、销售数据报表到财务分析表,几乎所有部门都离不开Excel,本文... 目录引言1. 安装 Spire.XLS2. 创建工作簿和填充数据3. 保存为不同格式4. 效果展示5
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2