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

相关文章

在React中引入Tailwind CSS的完整指南

在React中引入Tailwind CSS的完整指南

《在React中引入TailwindCSS的完整指南》在现代前端开发中,使用UI库可以显著提高开发效率,TailwindCSS是一个功能类优先的CSS框架,本文将详细介绍如何在Reac... 目录前言一、Tailwind css 简介二、创建 React 项目使用 Create React App 创建项目
阅读更多...
springboot循环依赖问题案例代码及解决办法

springboot循环依赖问题案例代码及解决办法

《springboot循环依赖问题案例代码及解决办法》在SpringBoot中,如果两个或多个Bean之间存在循环依赖（即BeanA依赖BeanB,而BeanB又依赖BeanA）,会导致Spring的... 目录1. 什么是循环依赖？2. 循环依赖的场景案例3. 解决循环依赖的常见方法方法 1：使用 @La
阅读更多...
使用C#代码在PDF文档中添加、删除和替换图片

使用C#代码在PDF文档中添加、删除和替换图片

《使用C#代码在PDF文档中添加、删除和替换图片》在当今数字化文档处理场景中,动态操作PDF文档中的图像已成为企业级应用开发的核心需求之一,本文将介绍如何在.NET平台使用C#代码在PDF文档中添加、... 目录引言用C#添加图片到PDF文档用C#删除PDF文档中的图片用C#替换PDF文档中的图片引言在当
阅读更多...
C#使用SQLite进行大数据量高效处理的代码示例

C#使用SQLite进行大数据量高效处理的代码示例

《C#使用SQLite进行大数据量高效处理的代码示例》在软件开发中,高效处理大数据量是一个常见且具有挑战性的任务,SQLite因其零配置、嵌入式、跨平台的特性,成为许多开发者的首选数据库,本文将深入探... 目录前言准备工作数据实体核心技术批量插入：从乌龟到猎豹的蜕变分页查询：加载百万数据异步处理：拒绝界面
阅读更多...
用js控制视频播放进度基本示例代码

用js控制视频播放进度基本示例代码

《用js控制视频播放进度基本示例代码》写前端的时候,很多的时候是需要支持要网页视频播放的功能,下面这篇文章主要给大家介绍了关于用js控制视频播放进度的相关资料,文中通过代码介绍的非常详细,需要的朋友可... 目录前言html部分:JavaScript部分:注意：总结前言在javascript中控制视频播放
阅读更多...
Spring Boot 3.4.3 基于 Spring WebFlux 实现 SSE 功能(代码示例)

Spring Boot 3.4.3 基于 Spring WebFlux 实现 SSE 功能(代码示例)

《SpringBoot3.4.3基于SpringWebFlux实现SSE功能(代码示例)》SpringBoot3.4.3结合SpringWebFlux实现SSE功能,为实时数据推送提供... 目录1. SSE 简介1.1 什么是 SSE？1.2 SSE 的优点1.3 适用场景2. Spring WebFlu
阅读更多...
java之Objects.nonNull用法代码解读

java之Objects.nonNull用法代码解读

《java之Objects.nonNull用法代码解读》：本文主要介绍java之Objects.nonNull用法代码,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐... 目录Java之Objects.nonwww.chinasem.cnNull用法代码Objects.nonN
阅读更多...
SpringBoot实现MD5加盐算法的示例代码

SpringBoot实现MD5加盐算法的示例代码

《SpringBoot实现MD5加盐算法的示例代码》加盐算法是一种用于增强密码安全性的技术,本文主要介绍了SpringBoot实现MD5加盐算法的示例代码,文中通过示例代码介绍的非常详细,对大家的学习... 目录一、什么是加盐算法二、如何实现加盐算法2.1 加盐算法代码实现2.2 注册页面中进行密码加盐2.
阅读更多...
python+opencv处理颜色之将目标颜色转换实例代码

python+opencv处理颜色之将目标颜色转换实例代码

《python+opencv处理颜色之将目标颜色转换实例代码》OpenCV是一个的跨平台计算机视觉库,可以运行在Linux、Windows和MacOS操作系统上,：本文主要介绍python+ope... 目录下面是代码+ 效果 + 解释转HSV： 关于颜色总是要转HSV的掩膜再标注总结 目标：将红色的部分滤
阅读更多...
在C#中调用Python代码的两种实现方式

在C#中调用Python代码的两种实现方式

《在C#中调用Python代码的两种实现方式》：本文主要介绍在C#中调用Python代码的两种实现方式,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教... 目录C#调用python代码的方式1. 使用 Python.NET2. 使用外部进程调用 Python 脚本总结C#调
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2