橡胶硫化机的单片机控制

2024-04-27 08:52
文章标签 单片机 控制 橡胶 硫化机

本文主要是介绍橡胶硫化机的单片机控制，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

/*** 2020 10 16 21:21硫化机控制程序 ***/    
/****L971 CODE5035*********************/          
              #include     <REG52.H>  
              #include     <intrins.h>
              #include     <string.h>
              #include     "stdio.h"
              #include     <stdlib.h>
              #define      uint unsigned int
              #define      uchar unsigned char
              #define      IAP_ADDRESS_Time  0x0000   //时间 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
              #define      IAP_ADDRESS 0x0000    //时间 EEPROM首地址
              typedef      unsigned char BYTE;
              typedef      unsigned int WORD;
              bit          Signauto=0;              /*退出循环检测*/
              bit           Rst_Bit=0;            /**/
              sbit         OUT0=P2^6;             //前闸前进  光耦输出    
              sbit         OUT1=P2^7;              //前闸后退  光耦输出    
              sbit         OUT2=P1^0;              //后闸前进
              sbit         OUT3=P1^1;            //后闸后退
              sbit         OUT4=P1^2;              //
              sbit         M_Pump=P1^3;             //大泵溢流
              sbit         PRESS=P1^4;             //辅助压力
              sbit         Model_merge=P1^5;      //并流输出
              sbit         Model_close=P1^6;     //合模     下降
              sbit         Model_open=P1^7;         //开模     上升
              sbit         ALARM=P5^4;              //警报
              sbit         MOTOR=P5^5;             //电机
              sbit         INTPUT1=P3^2;
              sbit         INTPUT2=P3^3;
              sbit         INTPUT3=P3^4;
              sbit         INTPUT4=P3^5;
              sbit         INTPUT5=P3^6;
              sbit         INTPUT6=P3^7;
              sbit         INTPUT7=P2^0;
              sbit         INTPUT8=P2^1;
              sbit         INTPUT9=P2^2;
              sbit         INTPUT10=P2^3;
              sbit         INTPUT11=P2^4;
              sbit         INTPUT12=P2^5;
              uint         Ad_data;
              uint         DELAY_A;              //排气一段延时时间
              uint         DELAY_B;              //排气二段延时时间
              uint         DELAY_C;              //排气三段延时时间
              uint         DELAY_D;              //排气四段延时时间
              uint         DELAY_E;              //排气一段停顿延时时间
              uint         DELAY_F;              //排气二段停顿延时时间
              uint         DELAY_G;              //排气三段停顿延时时间
              uint         DELAY_H;              //排气四段停顿延时时间
              uint         DELAY_I;              //硫化开模延时时间
              uint         DELAY_J;              //合模电磁阀延时
              uint         DELAY_K;              //开模电磁阀延时
              uint         a[10];                //定义数组a  
              uchar        i;                    //串口接收计数器
              uchar        k;                    //信号输入高电平计数器
              uint         counter;              //产量计数器
              uint         RUN_TIM;
              bit           Receive_Flag;
              bit          Run_Flag;
              uint         FLAG_S;                 //触摸屏显示标志
              uchar        kcounter,kstatus;     //按键计数标志 按键状态标志
/*----关闭IAP----------------------------*/
              void IapIdle()
              {
              IAP_CONTR = 0;                  //关闭IAP功能
              IAP_CMD = 0;                    //清除命令寄存器
              IAP_TRIG = 0;                   //清除触发寄存器
              IAP_ADDRH = 0x80;               //将地址设置到非IAP区域
              IAP_ADDRL = 0;
              }
/*-从ISP/IAP/EEPROM区域读取一字节-*/
              BYTE IapReadByte(WORD addr)
              {
              BYTE dat;                       //数据缓冲区
              IAP_CONTR = ENABLE_IAP;         //使能IAP
              IAP_CMD = CMD_READ;             //设置IAP命令
              IAP_ADDRL = addr;               //设置IAP低地址
              IAP_ADDRH = addr >> 8;          //设置IAP高地址
              IAP_TRIG = 0x5a;                //写触发命令(0x5a)
              IAP_TRIG = 0xa5;                //写触发命令(0xa5)
              _nop_();                        //等待ISP/IAP/EEPROM操作完成
              dat = IAP_DATA;                 //读ISP/IAP/EEPROM数据
              IapIdle();                      //关闭IAP功能
              return dat;                     //返回
              }
/*-写一字节数据到ISP/IAP/EEPROM区域-*/
              void IapProgramByte(WORD addr, BYTE dat)
              {
              IAP_CONTR = ENABLE_IAP;         //使能IAP
              IAP_CMD = CMD_PROGRAM;          //设置IAP命令
              IAP_ADDRL = addr;               //设置IAP低地址
              IAP_ADDRH = addr >> 8;          //设置IAP高地址
              IAP_DATA = dat;                 //写ISP/IAP/EEPROM数据
              IAP_TRIG = 0x5a;                //写触发命令(0x5a)
              IAP_TRIG = 0xa5;                //写触发命令(0xa5)
              _nop_();                        //等待ISP/IAP/EEPROM操作完成
              IapIdle();
              }
/*---扇区擦除---------------*/
              void IapEraseSector(WORD addr)
              {
              IAP_CONTR = ENABLE_IAP;         //使能IAP val=IapReadByte(IAP_ADDRESS+1);
              IAP_CMD = CMD_ERASE;            //设置IAP命令
              IAP_ADDRL = addr;               //设置IAP低地址
              IAP_ADDRH = addr >> 8;          //设置IAP高地址
              IAP_TRIG = 0x5a;                //写触发命令(0x5a)
              IAP_TRIG = 0xa5;                //写触发命令(0xa5)
              _nop_();                        //等待ISP/IAP/EEPROM操作完成
              IapIdle();
              }
/*------------------------------------------*/
              void delay(uint t)
              {
              uint i,j;
              for(i=0;i<t;i++)
              for(j=0;j<1000;j++);
              }
/*-----------(1)延时子程序12MHz 加千百十个显示--------*/
               void Delay100ms(uint x)
               {
               int i,j;
                for(i=0;i<x;i++)
                {
                for(j=0;j<9200;j++);
                printf("n8.val=%d\xff\xff\xff",i);//
                }
               }
/*-----------(1)延时子程序12MHz 加千百十个显示--------*/
               void Delay_100ms(uint x)
               {
               int i,j;
                for(i=0;i<x;i++)
                {
                for(j=0;j<9200;j++);
                printf("n8.val=%d\xff\xff\xff",i);//
                }
               }               
/********************************************/             
              void resrt_io()
              {
              OUT0=1;
              OUT1=1;
              OUT2=1;
              OUT3=1;
              OUT4=1;
              M_Pump=1;           //大泵溢流
              PRESS=1;
              Model_close=1;
              Model_merge=1;
              Model_open=1;
              ALARM=1;        //警报
              MOTOR=1;       //电机
              }
/****************按键计数器状态寄存器归零*************/
               void RstKey()
               {
               kcounter=0;                       //按键计数器归零
               kstatus=0;                        //状态寄存器归零
               }
/*****************按键低电平检测函数*****************/
               void   LowVoltKey(void)           //按键计数器状态标志加一
               {
               kcounter++;                       
               kstatus++;     
               delay(5);                         //延时                  
               }
/*****************按键高电平检测函数*****************/
               void    HighVoltKey(void)         //按键计数器加一 状态标志归零
               {
               kcounter++;                       //按键计数器加一
               kstatus=0;                        //按键状态标志归零
               delay(5);                         //延时
               }
/******************************************/
              void red_eeprom(void)
              {
              uint m,n;        
              m=IapReadByte(IAP_ADDRESS);    //时间前八位
              n=IapReadByte(IAP_ADDRESS+1);  //时间后八位
              DELAY_A=m*256+n;                 //排气一段延时时间
              m=IapReadByte(IAP_ADDRESS+2);  //时间前八位
              n=IapReadByte(IAP_ADDRESS+3);  //时间后八位
              DELAY_B=m*256+n;                 //排气二段延时时间
              m=IapReadByte(IAP_ADDRESS+4);  //时间前八位
              n=IapReadByte(IAP_ADDRESS+5);  //时间后八位
              DELAY_C=m*256+n;                 //排气三段延时时间
              m=IapReadByte(IAP_ADDRESS+6);  //时间前八位
              n=IapReadByte(IAP_ADDRESS+7);  //时间后八位
              DELAY_D=m*256+n;                 //排气四段延时时间
              m=IapReadByte(IAP_ADDRESS+8);  //时间前八位
              n=IapReadByte(IAP_ADDRESS+9);  //时间后八位
              DELAY_E=m*256+n;                 //排气一段停顿延时时间
              m=IapReadByte(IAP_ADDRESS+10); //时间前八位
              n=IapReadByte(IAP_ADDRESS+11); //时间后八位
              DELAY_F=m*256+n;                 //排气二段停顿延时时间
              m=IapReadByte(IAP_ADDRESS+12); //时间前八位
              n=IapReadByte(IAP_ADDRESS+13); //时间后八位
              DELAY_G=m*256+n;                 //排气三段停顿延时时间
              m=IapReadByte(IAP_ADDRESS+14); //时间前八位
              n=IapReadByte(IAP_ADDRESS+15); //时间后八位
              DELAY_H=m*256+n;                 //排气四段停顿延时时间
              m=IapReadByte(IAP_ADDRESS+16); //时间前八位
              n=IapReadByte(IAP_ADDRESS+17); //时间后八位
              DELAY_I=m*256+n;                 //硫化开模延时时间
              m=IapReadByte(IAP_ADDRESS+18); //时间前八位
              n=IapReadByte(IAP_ADDRESS+19); //时间后八位
              DELAY_J=m*256+n;                 //合模电磁阀延时
              m=IapReadByte(IAP_ADDRESS+20); //时间前八位
              n=IapReadByte(IAP_ADDRESS+21); //时间后八位
              DELAY_K=m*256+n;                 //开模电磁阀延时
              }
/******************************************/
              void Write_EepromTime()
              {
               IapEraseSector(IAP_ADDRESS);                 //扇区擦除
               IapProgramByte(IAP_ADDRESS,DELAY_A/256);     // 排气一段延时时间高位
               IapProgramByte(IAP_ADDRESS+1,DELAY_A%256);   // 排气一段延时时间低位
               IapProgramByte(IAP_ADDRESS+2,DELAY_B/256);   // 排气二段延时时间高位
               IapProgramByte(IAP_ADDRESS+3,DELAY_B%256);   // 排气二段延时时间低位
               IapProgramByte(IAP_ADDRESS+4,DELAY_C/256);   // 排气三段延时时间高位
               IapProgramByte(IAP_ADDRESS+5,DELAY_C%256);   // 排气三段延时时间低位
               IapProgramByte(IAP_ADDRESS+6,DELAY_D/256);   // 排气四段延时时间高位
               IapProgramByte(IAP_ADDRESS+7,DELAY_D%256);   // 排气四段延时时间低位
               IapProgramByte(IAP_ADDRESS+8,DELAY_E/256);   // 排气一段停顿延时时间高位
               IapProgramByte(IAP_ADDRESS+9,DELAY_E%256);   // 排气一段停顿延时时间低位
               IapProgramByte(IAP_ADDRESS+10,DELAY_F/256);  // 排气二段停顿延时时间高位
               IapProgramByte(IAP_ADDRESS+11,DELAY_F%256);  // 排气二段停顿延时时间低位
               IapProgramByte(IAP_ADDRESS+12,DELAY_G/256);  // 排气三段停顿延时时间高位
               IapProgramByte(IAP_ADDRESS+13,DELAY_G%256);  // 排气三段停顿延时时间低位
               IapProgramByte(IAP_ADDRESS+14,DELAY_H/256);  // 排气四段停顿延时时间高位
               IapProgramByte(IAP_ADDRESS+15,DELAY_H%256);  // 排气四段停顿延时时间低位
               IapProgramByte(IAP_ADDRESS+16,DELAY_I/256);  // 硫化开模延时时间高位
               IapProgramByte(IAP_ADDRESS+17,DELAY_I%256);  // 硫化开模延时时间低位
               IapProgramByte(IAP_ADDRESS+18,DELAY_J/256);  // 合模电磁阀延时高位
               IapProgramByte(IAP_ADDRESS+19,DELAY_J%256);  // 合模电磁阀延时低位
               IapProgramByte(IAP_ADDRESS+20,DELAY_K/256);  // 开模电磁阀延时高位
               IapProgramByte(IAP_ADDRESS+21,DELAY_K%256);  // 开模电磁阀延时低位
              }
/*****************************************/
              void start()
              {
              Run_Flag=1;               //运行标志置一
              M_Pump=1;                   //大泵溢流 关
              Model_merge=1;            //并流输出 关
              ALARM=0;
              Delay100ms(5);           //警报提示
              ALARM=1;    
              Delay100ms(5);           //警报提示
              ALARM=0;
              Delay100ms(5);           //警报提示
              ALARM=1;
              Delay100ms(5);           //警报提示
              ALARM=0;
              Delay100ms(5);           //警报提示
              ALARM=1;               
              FLAG_S=5;                //1模板下降2模板上升3硫化计时4待机停止5开启6停止
              printf("va1.val=%d\xff\xff\xff",FLAG_S);    //
              MOTOR=0;                   //电机开
              PRESS=0;                  //辅助压力
              Model_close=0;           //合模  小缸下降开
              Delay100ms(DELAY_J);       //合模电磁阀延时
              printf("n10.val=%d\xff\xff\xff",DELAY_J);// 显示合模电磁阀延时设置值
              Model_close=1;           //合模 小缸下降关
              PRESS=1;                  //辅助压力关
              M_Pump=0;                   //大泵溢流 开
              Model_merge=0;            //并流输出 开
              FLAG_S=2;                //1模板下降2模板上升3硫化计时4待机停止5开启6停止
              printf("va1.val=%d\xff\xff\xff",FLAG_S);    //
              Signauto=1;               /*电接点压力表输入信号检测标志无输入为1,永久循环*/
                while(Signauto)           //压力表检测1
                {
                RstKey();
                for(;kcounter<5;)      //输入信号检测循环5次
                {
                 if(!INTPUT2)            //电接点压力表低电平
                 {
                  LowVoltKey();
                 }
                 else if(~!INTPUT2)    //电接点压力表高电平
                 {
                  HighVoltKey();   
                 }
                }
               if(kstatus>=3)          /*按键状态标志大于等于3为有效值*/
                {     
                Signauto=0;            /*行程输入信号连续检测到五次Signauto=0退出循环*/   
                }
               }
//电接点压力表检测
               M_Pump=1;                //大泵溢流关
               Model_merge=1;            //并流输出关
               printf("n10.val=%d\xff\xff\xff",DELAY_E);// 显示一段硫化设置值
               Delay100ms(DELAY_E); //    一段硫化停顿计时
//第一段硫化停顿
               FLAG_S=1;               //1模板下降2模板上升3硫化计时4待机停止5开启6停止
               printf("va1.val=%d\xff\xff\xff",FLAG_S);    //
               PRESS=0;                   //辅助压力开
               Model_open=0;           //开模    小缸 上升
               printf("n10.val=%d\xff\xff\xff",DELAY_A);// 显示设置值
               Delay100ms(DELAY_A);    //第一段排气计时
               Model_open=1;           //开模电磁阀关
//第一段循环结束
//第二段合模开始
              Model_close=0;           //合模  小缸下降开
              Delay100ms(DELAY_J);       //合模电磁阀延时
              printf("n10.val=%d\xff\xff\xff",DELAY_J);// 显示合模电磁阀延时设置值
              Model_close=1;           //合模 小缸下降关
              PRESS=1;                  //辅助压力关
              M_Pump=0;                   //大泵溢流 开
              Model_merge=0;            //并流输出 开
              FLAG_S=2;                //1模板下降2模板上升3硫化计时4待机停止5开启6停止
              printf("va1.val=%d\xff\xff\xff",FLAG_S);    //
              Signauto=1;               /*电接点压力表输入信号检测标志无输入为1,永久循环*/
                 while(Signauto)           //压力表检测2
                {
                RstKey();
                for(;kcounter<5;)      //输入信号检测循环5次
                {
                 if(!INTPUT2)            //电接点压力表低电平
                 {
                  LowVoltKey();
                 }
                 else if(~!INTPUT2)    //电接点压力表高电平
                 {
                  HighVoltKey();   
                 }
                }
               if(kstatus>=3)          /*按键状态标志大于等于3为有效值*/
                {     
                Signauto=0;            /*行程输入信号连续检测到五次Signauto=0退出循环*/   
                }
                }
//电接点压力表检测
               M_Pump=1;                //大泵溢流关
               Model_merge=1;            //并流输出关
               printf("n10.val=%d\xff\xff\xff",DELAY_F);//显示一段硫化设置值
               Delay100ms(DELAY_F);                     //    二段硫化停顿计时    
//第二段硫化停顿
               FLAG_S=1;               //1模板下降2模板上升3硫化计时4待机停止5开启6停止
               printf("va1.val=%d\xff\xff\xff",FLAG_S);    //
               PRESS=0;                   //辅助压力开
               Model_open=0;           //开模    小缸 上升
               printf("n10.val=%d\xff\xff\xff",DELAY_B);// 显示第二段排气计时设置值
               Delay100ms(DELAY_B);    //第二段排气计时
               Model_open=1;           //开模电磁阀关
//第二段循环结束
//第三段合模开始
               Model_close=0;          //合模  小缸下降开
               Delay100ms(DELAY_J);       //合模电磁阀延时
               printf("n10.val=%d\xff\xff\xff",DELAY_J);// 显示合模电磁阀延时设置值
               Model_close=1;           //合模 小缸下降关
               PRESS=1;                  //辅助压力关
               M_Pump=0;               //大泵溢流 开
               Model_merge=0;            //并流输出 开
               FLAG_S=2;               //1模板下降2模板上升3硫化计时4待机停止5开启6停止
               printf("va1.val=%d\xff\xff\xff",FLAG_S);    //
               Signauto=1;               /*电接点压力表输入信号检测标志无输入为1,永久循环*/
               while(Signauto)           //压力表检测3
                {
                RstKey();
                for(;kcounter<5;)      //输入信号检测循环5次
                {
                 if(!INTPUT2)            //电接点压力表低电平
                 {
                  LowVoltKey();
                 }
                 else if(~!INTPUT2)    //电接点压力表高电平
                 {
                  HighVoltKey();   
                 }
                }
               if(kstatus>=3)          /*按键状态标志大于等于3为有效值*/
                {     
                Signauto=0;            /*行程输入信号连续检测到五次Signauto=0退出循环*/   
                }
                }
//电接点压力表检测
               M_Pump=1;                //大泵溢流关
               Model_merge=1;            //并流输出关
               printf("n10.val=%d\xff\xff\xff",DELAY_G);// 显示三段硫化设置值
               Delay100ms(DELAY_G);    //三段硫化停顿计时
//第三段硫化停顿
               FLAG_S=1;               //1模板下降2模板上升3硫化计时4待机停止5开启6停止
               printf("va1.val=%d\xff\xff\xff",FLAG_S);    //
               PRESS=0;                   //辅助压力开
               Model_open=0;           //开模    小缸 上升
               printf("n10.val=%d\xff\xff\xff",DELAY_C);// 显示第三段排气计时设置值
               Delay100ms(DELAY_C);    //第三段排气计时
               Model_open=1;           //开模电磁阀关
//第三段循环结束
//第四段合模开始
               Model_close=0;          //合模  小缸下降开
               Delay100ms(DELAY_J);       //合模电磁阀延时
               printf("n10.val=%d\xff\xff\xff",DELAY_J);// 显示合模电磁阀延时设置值
               Model_close=1;           //合模 小缸下降关
               PRESS=1;                  //辅助压力关
               M_Pump=0;               //大泵溢流 开
               Model_merge=0;            //并流输出 开
               FLAG_S=2;               //1模板下降2模板上升3硫化计时4待机停止5开启6停止
               printf("va1.val=%d\xff\xff\xff",FLAG_S);    //
               Signauto=1;               /*电接点压力表输入信号检测标志无输入为1,永久循环*/
               while(Signauto)           //压力表检测4
                {
                RstKey();
                for(;kcounter<5;)      //输入信号检测循环5次
                {
                 if(!INTPUT2)            //电接点压力表低电平
                 {
                  LowVoltKey();
                 }
                 else if(~!INTPUT2)    //电接点压力表高电平
                 {
                  HighVoltKey();   
                 }
                }
               if(kstatus>=3)          /*按键状态标志大于等于3为有效值*/
                {     
                Signauto=0;            /*行程输入信号连续检测到五次Signauto=0退出循环*/   
                }
                }
//电接点压力表检测
               M_Pump=1;                //大泵溢流关
               Model_merge=1;            //并流输出关
               printf("n10.val=%d\xff\xff\xff",DELAY_H);// 显示四段硫化设置值
               Delay100ms(DELAY_H);    //四段硫化停顿计时
//第四段硫化停顿
               FLAG_S=1;               //1模板下降2模板上升3硫化计时4待机停止5开启6停止
               printf("va1.val=%d\xff\xff\xff",FLAG_S);    //
               PRESS=0;                   //辅助压力开
               Model_open=0;           //开模    小缸 上升
               printf("n10.val=%d\xff\xff\xff",DELAY_D);// 显示第四段排气计时设置值
               Delay100ms(DELAY_D);    //第四段排气计时
               Model_open=1;           //开模电磁阀关
//第五段合模开始
               Model_close=0;          //合模  小缸下降开
               Delay100ms(DELAY_J);       //合模电磁阀延时
               printf("n10.val=%d\xff\xff\xff",DELAY_J);// 显示合模电磁阀延时设置值
               Model_close=1;           //合模 小缸下降关
               PRESS=1;                  //辅助压力关
               M_Pump=0;               //大泵溢流 开
               Model_merge=0;            //并流输出 开
               FLAG_S=2;               //1模板下降2模板上升3硫化计时4待机停止5开启6停止
               printf("va1.val=%d\xff\xff\xff",FLAG_S);    //
               Signauto=1;               /*电接点压力表输入信号检测标志无输入为1,永久循环*/
               while(Signauto)           //压力表检测5
                {
                RstKey();
                for(;kcounter<5;)      //输入信号检测循环5次
                {
                 if(!INTPUT2)            //电接点压力表低电平
                 {
                  LowVoltKey();
                 }
                 else if(~!INTPUT2)    //电接点压力表高电平
                 {
                  HighVoltKey();   
                 }
                }
               if(kstatus>=3)          /*按键状态标志大于等于3为有效值*/
                {  
                Signauto=0;            /*行程输入信号连续检测到五次Signauto=0退出循环*/  
                MOTOR=1;               /*关电机*/   
                FLAG_S=6;              //1模板下降2模板上升3硫化计时4待机停止5开启6停止
                printf("va1.val=%d\xff\xff\xff",FLAG_S);    //
                }
               }
               M_Pump=1;               //大泵溢流关
               PRESS=1;                   //辅助压力关
               Model_merge=1;            //并流输出关
               Model_close=1;           //合模主油缸电磁阀关
               Delay100ms(10);           //时间缓冲
               FLAG_S=3;               //1模板下降2模板上升3硫化计时4待机停止5开启6停止
               printf("va1.val=%d\xff\xff\xff",FLAG_S);    //
               printf("n10.val=%d\xff\xff\xff",DELAY_I);// 显示设置值
               Delay_100ms(DELAY_I*10); //硫化延时计时
               ALARM=0;
               Delay100ms(5);           //警报提示
               ALARM=1;    
               Delay100ms(5);           //警报提示
               ALARM=0;
               Delay100ms(5);           //警报提示
               ALARM=1;
               Delay100ms(5);           //警报提示
               ALARM=0;
               Delay100ms(5);           //警报提示
               ALARM=1;    
               MOTOR=0;                 /*开电机*/
               PRESS=0;                   //辅助压力开
               Model_open=0;            //开模电磁阀开
               FLAG_S=1;                //
               printf("va1.val=%d\xff\xff\xff",FLAG_S);    //
               printf("n10.val=%d\xff\xff\xff",DELAY_K);// 显示设置值
               Delay100ms(DELAY_K);    //开模电磁阀延时
               Model_open=1;           //开模电磁阀关
               PRESS=1;                  //辅助压力关
               MOTOR=1;               /*关电机*/
               counter++;
               printf("n0.val=%d\xff\xff\xff",counter);    // 开模计数
               FLAG_S=4;                //1模板下降2模板上升3硫化计时4待机停止5开启6停止
               printf("va1.val=%d\xff\xff\xff",FLAG_S);    //
              }
/*------------初始化串口---------------------*/
              void InitUart()
              {
              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 中断服务程序-------------------**/
/**×**把接收到的数据存进数组a[i]**i开机初始化****/
/***×*接收到触摸屏结束码Receive_Flag标志位置1****/
/****×主程序检测到标志码=1判断指令功能***********/
/****第一个字节E0存储时间 第一个字节E1存储气压***/
/****第二个字节01,02,03,04为模式1A B C D段参数***/
/****第二个字节11,12,13,14为模式2A B C D段参数***/
/****第二个字节21,22,23,24为模式3A B C D段参数***/
/****第二个字节31,32,33,34为模式4A B C D段参数***/
              void Uart() interrupt 4 using 1
              {
               if(RI)
               {
                if(SBUF==0XFA)                     //触摸屏结束码
                {
                Receive_Flag=1;                     //接收数据标志置一
                RI=0;                             //
                i=0;                             //数组计数器归零
                }
                else
                {
                a[i]=SBUF;                       //数组下标位置的数据等于SBUF
                RI=0;                             //
                i++;
                }
               }
              }
/*************************************************/
              void   main( )                     /*主程序开始*/
              {
               resrt_io();
               AUXR=0X80;                        //STC系列的1T 设置
               TMOD=0X01;
               P_SW1=0x00;                       //RXD/P3.0, TXD/P3.1
               Receive_Flag=0;    
               InitUart();                       //初始化串口
               Delay100ms(20);
               red_eeprom();                     //
               printf("0XFF,0XFF,0XFF");
               i=0;                              //数据接收计数器等于0
               Run_Flag=0;
               counter=0;                        //产量归零
               FLAG_S=4;                //1模板下降2模板上升3硫化计时4待机停止5开启6停止
               printf("va1.val=%d\xff\xff\xff",FLAG_S);    //
               FLAG_S=6;                //
               printf("va1.val=%d\xff\xff\xff",FLAG_S);    //
               printf("n7.val=%d\xff\xff\xff",DELAY_I);    // 硫化时间
               printf("n0.val=%d\xff\xff\xff",counter);    // 开模计数
               while(1)                             //INTPUT1
               {
                 delay(5);                      //运行指示
                 OUT1=0;                          //
/***************模板上升检测*************/
                 RstKey();                         //按键复位
                 for(;kcounter<5;)               //按键循环5次
                 {
                  if(!INTPUT3)                      //模退 按键低电平
                  {
                  LowVoltKey();
                  }
                  else if(~!INTPUT3)             //模退 按键高电平
                  {
                  HighVoltKey();                     //高电平检测
                  }
                 }
                 if(kstatus>=3)                  /*按键状态标志大于等于3为有效值*/
                 {  
                 FLAG_S=2;                       //1模板下降2模板上升3硫化计时4待机停止5开启6停止
                 printf("va1.val=%d\xff\xff\xff",FLAG_S);    //
                 ALARM=0;
                 Delay100ms(5);           //警报提示
                 ALARM=1;    
                 Delay100ms(5);           //警报提示
                 ALARM=0;
                 Delay100ms(5);           //警报提示
                 ALARM=1;
                 Delay100ms(5);           //警报提示
                 ALARM=0;
                 Delay100ms(5);           //警报提示
                 ALARM=1;
                 M_Pump=1;               //大泵溢流 关
                 Model_merge=1;        //并流输出 关
                 delay(5);
                 FLAG_S=5;                      //1模板下降2模板上升3硫化计时4待机停止5开启6停止
                 printf("va1.val=%d\xff\xff\xff",FLAG_S);    //           
                 MOTOR=0;               //开电机
                 PRESS=0;               //辅助压力
                    Model_close=0;        //合模     小缸下降开
                 Delay100ms(DELAY_J);  //合模电磁阀延时
                 M_Pump=0;               //大泵溢流 开
                 Model_merge=0;        //并流输出 开
                 Model_close=1;        //合模     小缸下降关               
                 PRESS=1;               //辅助压力 关
                 delay(50);
                 k=0;  
                 for(;k<=5;)                     /*寄存器复位*/
                  {
                  if(~!INTPUT3)                  /*检测模退按键为高电平？*/
                   {                     
                   k++;
                   delay(10);
                   }
                  else if(!INTPUT3)              /*检测合模按键为低电平？*/
                  k=0;                           /*寄存器复位*/                 
                  }   
                  delay(50);
                  MOTOR=1;                         //关电机
                  M_Pump=1;                         //大泵溢流 关
                  Model_merge=1;                  //并流输出 关
                  Model_close=1;                 //关模板上升
                  PRESS=1;                         //关辅助压力
                  FLAG_S=4;                      //1模板下降2模板上升3硫化计时4待机停止5开启6停止
                  printf("va1.val=%d\xff\xff\xff",FLAG_S);    //
                  delay(5);
                  FLAG_S=6;                      //1模板下降2模板上升3硫化计时4待机停止5开启6停止
                  printf("va1.val=%d\xff\xff\xff",FLAG_S);    //
                  delay(50);
                  FLAG_S=6;               //1模板下降2模板上升3硫化计时4待机停止5开启6停止
                  printf("va1.val=%d\xff\xff\xff",FLAG_S);    //
                 }
//模板上升
/***************模板下降检测*************/
                 RstKey();                         //按键复位
                 for(;kcounter<5;)               //按键循环5次
                 {
                  if(!INTPUT4)                      //模退 按键低电平
                  {
                  LowVoltKey();
                  }
                  else if(~!INTPUT4)             //模退 按键高电平
                  {
                  HighVoltKey();                 //高电平检测
                  }
                 }
                 if(kstatus>=3)                  /*按键状态标志大于等于3为有效值*/
                 {   
                 FLAG_S=1;                       //1模板下降2模板上升3硫化计时4待机停止5开启6停止
                 printf("va1.val=%d\xff\xff\xff",FLAG_S);    //
                 ALARM=0;
                 Delay100ms(5);           //警报提示
                 ALARM=1;    
                 Delay100ms(5);           //警报提示
                 ALARM=0;
                 Delay100ms(5);           //警报提示
                 ALARM=1;
                 Delay100ms(5);           //警报提示
                 ALARM=0;
                 Delay100ms(5);           //警报提示
                 ALARM=1;    
                 M_Pump=1;               //大泵溢流 关
                 Model_merge=1;        //并流输出 关
                 delay(5);
                 FLAG_S=5;                       //1模板下降2模板上升3硫化计时4待机停止5开启6停止
                 printf("va1.val=%d\xff\xff\xff",FLAG_S);    //       
                 MOTOR=0;                         //开电机  
                 Model_open=0;                   //模板下降
                 PRESS=0;                         //开辅助压力
                 Delay100ms(DELAY_K);  //开模电磁阀延时
                 delay(50);
                 FLAG_S=5;                      //1模板下降2模板上升3硫化计时4待机停止5开启6停止
                 printf("va1.val=%d\xff\xff\xff",FLAG_S);    //
                 k=0;  
                 for(;k<=5;)                     /*寄存器复位*/
                  {
                  if(~!INTPUT4)                  /*检测模退按键为高电平？*/
                   {                     
                   k++;
                   delay(10);
                   }
                  else if(!INTPUT4)              /*检测合模按键为低电平？*/
                  k=0;                           /*寄存器复位*/                 
                  }   
                  delay(50);
                  MOTOR=1;                         //关电机
                  Model_open=1;                  //关模板下降
                  PRESS=1;                         //关辅助压力
                  FLAG_S=4;                      //1模板下降2模板上升3硫化计时4待机停止5开启6停止
                  printf("va1.val=%d\xff\xff\xff",FLAG_S);    //
                  delay(50);
                  FLAG_S=6;               //1模板下降2模板上升3硫化计时4待机停止5开启6停止
                  printf("va1.val=%d\xff\xff\xff",FLAG_S);    //
                 }
//模板下降
/***************开机键检测*************/
                 RstKey();                         //按键复位
                 if(!INTPUT1)                     //启动信号键
                 {
                  for(;kcounter<5;)              //按键循环5次
                  {
                   if(!INTPUT1)                  //按键低电平
                   {
                   LowVoltKey();
                   }
                   else if(~!INTPUT1)            //按键高电平
                   {
                   HighVoltKey();
                   }
                  }
                  if(kstatus>=4)                 /*按键状态标志大于等于3为有效值*/
                  {                              /*循环检测 */
                   start();
                  }
                 }

               if(Receive_Flag==1)
               {
               Receive_Flag=0;
                if(a[0]==0XE0)            //EEPROM参数存储
                {
                   OUT0=0;                    //写EEPROM指示
                 if(a[1]==0X00)            
                  {                                      
                  DELAY_I=a[3]*256+a[2];//硫化开模延时时间
                  }
                  else if(a[1]==0X01)    
                  {
                  DELAY_A=a[3]*256+a[2];//排气一段延时时间
                  }
                  else if(a[1]==0X02)
                  {
                  DELAY_B=a[3]*256+a[2];//排气二段延时时间
                  }
                  else if(a[1]==0X03)
                  {
                  DELAY_C=a[3]*256+a[2];//排气三段延时时间
                  }
                  else if(a[1]==0X04)
                  {
                  DELAY_D=a[3]*256+a[2];//排气四段延时时间
                  }
                  else if(a[1]==0X05)
                  {
                  DELAY_E=a[3]*256+a[2];//排气一段停顿延时
                  }
                  else if(a[1]==0X06)
                  {
                  DELAY_F=a[3]*256+a[2];//排气二段停顿延时
                  }
                  else if(a[1]==0X07)
                  {
                  DELAY_G=a[3]*256+a[2];//排气三段停顿延时
                  }
                  else if(a[1]==0X08)
                  {
                  DELAY_H=a[3]*256+a[2];//排气四段停顿延时
                  }
                  else if(a[1]==0X09)
                  {
                  DELAY_J=a[3]*256+a[2];//合模导通延时
                  }
                  else if(a[1]==0X10)
                  {
                  DELAY_K=a[3]*256+a[2];//开模导通延时
                  }
                  Write_EepromTime();
                  delay(10);
                  OUT0=1;               //写EEPROM指示
                 }
                 else if(a[0]==0XD0)   //动作测试
                 {
                  if(a[1]==0X00)       //电机开
                  {
                  MOTOR=0;
                  }
                  else if(a[1]==0X01)  //后闸前进
                  {
                  OUT2=0;
                  }
                  else if(a[1]==0X02)  //后闸后退
                  {
                  OUT3=0;
                  }
                  else if(a[1]==0X03)  //备用
                  {
                  OUT4=0;
                  }
                  else if(a[1]==0X04)  //
                  {
                  M_Pump=0;               //大泵溢流
                  }
                  else if(a[1]==0X05)  //合模输出
                  {
                  Model_close=0;
                  }
                  else if(a[1]==0X06)  //开模输出
                  {
                  Model_open=0;                    
                  }
                  else if(a[1]==0X07)  //辅助压力
                  {
                  PRESS=0;
                  }
                  else if(a[1]==0X08)  //并流输出
                  {
                  Model_close=0;
                  }
                  else if(a[1]==0X09)  //前闸前进
                  {
                  OUT1=0;
                  }
                  else if(a[1]==0X10)  //前闸后退
                  {
                  OUT2=0;
                  }
                  else if(a[1]==0X11)  //警报输出
                  {
                  ALARM=0;
                  }
                 }
                else if(a[0]==0XD1)    //动作测试
                 {
                   if(a[1]==0X00)              //电机关
                  {
                  MOTOR=1;
                  }
                  else if(a[1]==0X01)  //后闸前进
                  {
                  OUT2=1;
                  }
                  else if(a[1]==0X02)  //后闸后退
                  {
                  OUT3=1;
                  }
                  else if(a[1]==0X03)  //备用
                  {
                  OUT4=1;
                  }
                  else if(a[1]==0X04)  //
                  {
                  M_Pump=1;               //大泵溢流
                  }
                  else if(a[1]==0X05)  //合模输出
                  {
                  Model_close=1;
                  }
                  else if(a[1]==0X06)  //开模输出
                  {
                  Model_open=1;                    
                  }
                  else if(a[1]==0X07)  //辅助压力
                  {
                  PRESS=1;
                  }
                  else if(a[1]==0X08)  //并流输出
                  {
                  Model_close=1;
                  }
                  else if(a[1]==0X09)  //前闸前进
                  {
                  OUT1=1;
                  }
                  else if(a[1]==0X10)  //前闸后退
                  {
                  OUT2=1;
                  }
                  else if(a[1]==0X11)  //警报输出
                  {
                  ALARM=1;
                  }
                 }
                else if(a[0]==0XB0)       //  B0 00发送主画面 内容
                 {
                 if(a[1]==0X00)          //
                  {
                   red_eeprom();
                   printf("n7.val=%d\xff\xff\xff",DELAY_I);    // 硫化时间
                   printf("n0.val=%d\xff\xff\xff",counter);    // 开模计数
                  }
                 else if(a[1]==0X01)       //发送参数设置页面内容
                  {
                   red_eeprom();
                   printf("n0.val=%d\xff\xff\xff",DELAY_A);    //排气一段延时时间
                   printf("n1.val=%d\xff\xff\xff",DELAY_B);    //排气二段延时时间
                   printf("n2.val=%d\xff\xff\xff",DELAY_C);    //排气三段延时时间
                   printf("n3.val=%d\xff\xff\xff",DELAY_D);    //排气四段延时时间
                   printf("n4.val=%d\xff\xff\xff",DELAY_E);    //排气一段停顿延时时间
                   printf("n5.val=%d\xff\xff\xff",DELAY_F);    //排气二段停顿延时时间
                   printf("n6.val=%d\xff\xff\xff",DELAY_G);    //排气三段停顿延时时间
                   printf("n7.val=%d\xff\xff\xff",DELAY_H);    //排气四段停顿延时时间
                   printf("n8.val=%d\xff\xff\xff",DELAY_J);    //合模电磁阀延时
                   printf("n9.val=%d\xff\xff\xff",DELAY_K);    //开模电磁阀延时
                  }
                 }
                 else if(a[0]==0XC0)             //手动操作
                 {
                 if(a[1]==0X10)                     //合模
                  {
                   FLAG_S=2;                       //1模板下降2模板上升3硫化计时4待机停止5开启6停止
                   printf("va1.val=%d\xff\xff\xff",FLAG_S);    //    
                   delay(5);
                   FLAG_S=5;                       //1模板下降2模板上升3硫化计时4待机停止5开启6停止
                   printf("va1.val=%d\xff\xff\xff",FLAG_S);    //
                   Model_close=0;                 //合模 小油缸下开
                   PRESS=0;                         //辅助压力开
                   Delay100ms(DELAY_J);             //合模电磁阀延时
                   PRESS=1;                         //辅助压力关
                   Model_close=1;                 //合模    小油缸下关
                   M_Pump=0;                     //大泵溢流开
                   Model_merge=0;                  //并流输出开
                  }
                  else if(a[1]==0X11)             //开模
                  {
                   FLAG_S=1;                       //1模板下降2模板上升3硫化计时4待机停止5开启6停止
                   printf("va1.val=%d\xff\xff\xff",FLAG_S);    //    
                   delay(5);
                   FLAG_S=5;                       //1模板下降2模板上升3硫化计时4待机停止5开启6停止
                   printf("va1.val=%d\xff\xff\xff",FLAG_S);    //
                   M_Pump=1;                     //大泵溢流关
                   Model_merge=1;                  //并流输出关
                   PRESS=0;                         //辅助压力开
                   Model_open=0;                 //开模 小油缸上开
                  }
                  else if(a[1]==0X12)             //
                  {
                   ALARM=0;
                   Delay100ms(5);                 //警报提示
                   ALARM=1;
                   ALARM=0;
                   Delay100ms(5);                 //警报提示
                   ALARM=1;
                   MOTOR=0;                         //电机开
                  }
                  }
                  else if(a[0]==0XC1)
                  {
                   if(a[1]==0X10)           
                   {
                   FLAG_S=4;                     //1模板下降2模板上升3硫化计时4待机停止5开启6停止
                   printf("va1.val=%d\xff\xff\xff",FLAG_S);    //    
                   PRESS=1;                         //辅助压力关
                   Model_close=1;                 //合模关
                   M_Pump=1;                     //大泵溢流关
                   Model_merge=1;                  //并流输出关
                   }
                   else if(a[1]==0X11)             
                   {
                   FLAG_S=4;                       //1模板下降2模板上升3硫化计时4待机停止5开启6停止
                   printf("va1.val=%d\xff\xff\xff",FLAG_S);    //    
                   PRESS=1;                         //辅助压力关
                   Model_open=1;                 //开模关
                   M_Pump=1;                     //大泵溢流关
                   Model_merge=1;                  //并流输出关
                   }
                   else if(a[1]==0X12)             //
                   {
                   MOTOR=1;                         //电机关
                   }
                 }
               }  
               delay(5);
               OUT1=1;                    //
              }     
            }                    //L971 CODE5035
            

这篇关于橡胶硫化机的单片机控制的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


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

相关文章

Python实现局域网远程控制电脑

Python实现局域网远程控制电脑

《Python实现局域网远程控制电脑》这篇文章主要为大家详细介绍了如何利用Python编写一个工具,可以实现远程控制局域网电脑关机,重启,注销等功能,感兴趣的小伙伴可以参考一下... 目录1.简介2. 运行效果3. 1.0版本相关源码服务端server.py客户端client.py4. 2.0版本相关源码1
阅读更多...
Spring Security 基于表达式的权限控制

Spring Security 基于表达式的权限控制

前言 spring security 3.0已经可以使用spring el表达式来控制授权，允许在表达式中使用复杂的布尔逻辑来控制访问的权限。 常见的表达式 Spring Security可用表达式对象的基类是SecurityExpressionRoot。 表达式描述hasRole([role])用户拥有制定的角色时返回true （Spring security默认会带有ROLE_前缀）,去
阅读更多...
基于51单片机的自动转向修复系统的设计与实现

基于51单片机的自动转向修复系统的设计与实现

文章目录 前言资料获取设计介绍功能介绍设计清单具体实现截图参考文献设计获取 前言 💗博主介绍：✌全网粉丝10W+,CSDN特邀作者、博客专家、CSDN新星计划导师，一名热衷于单片机技术探索与分享的博主、专注于 精通51/STM32/MSP430/AVR等单片机设计 主要对象是咱们电子相关专业的大学生，希望您们都共创辉煌！✌💗 👇🏻 精彩专栏 推荐订阅👇🏻 单片机
阅读更多...
控制反转 的种类

控制反转 的种类

之前对控制反转的定义和解释都不是很清晰。最近翻书发现在《Pro Spring 5》（免费电子版在文章最后）有一段非常不错的解释。记录一下，有道翻译贴出来方便查看。如有请直接跳过中文，看后面的原文。 控制反转的类型 控制反转的类型您可能想知道为什么有两种类型的IoC，以及为什么这些类型被进一步划分为不同的实现。这个问题似乎没有明确的答案;当然，不同的类型提供了一定程度的灵活性，但
阅读更多...
单片机毕业设计基于单片机的智能门禁系统的设计与实现

单片机毕业设计基于单片机的智能门禁系统的设计与实现

文章目录 前言资料获取设计介绍功能介绍程序代码部分参考 设计清单具体实现截图参考文献设计获取 前言 💗博主介绍：✌全网粉丝10W+,CSDN特邀作者、博客专家、CSDN新星计划导师，一名热衷于单片机技术探索与分享的博主、专注于 精通51/STM32/MSP430/AVR等单片机设计 主要对象是咱们电子相关专业的大学生，希望您们都共创辉煌！✌💗 👇🏻 精彩专栏 推荐订
阅读更多...
深入解析秒杀业务中的核心问题 —— 从并发控制到事务管理

深入解析秒杀业务中的核心问题 —— 从并发控制到事务管理

深入解析秒杀业务中的核心问题 —— 从并发控制到事务管理 秒杀系统是应对高并发、高压力下的典型业务场景，涉及到并发控制、库存管理、事务管理等多个关键技术点。本文将深入剖析秒杀商品业务中常见的几个核心问题，包括 AOP 事务管理、同步锁机制、乐观锁、CAS 操作，以及用户限购策略。通过这些技术的结合，确保秒杀系统在高并发场景下的稳定性和一致性。 1. AOP 代理对象与事务管理 在秒杀商品
阅读更多...
PostgreSQL中的多版本并发控制（MVCC）深入解析

PostgreSQL中的多版本并发控制（MVCC）深入解析

引言 PostgreSQL作为一款强大的开源关系数据库管理系统，以其高性能、高可靠性和丰富的功能特性而广受欢迎。在并发控制方面，PostgreSQL采用了多版本并发控制（MVCC）机制，该机制为数据库提供了高效的数据访问和更新能力，同时保证了数据的一致性和隔离性。本文将深入解析PostgreSQL中的MVCC功能，探讨其工作原理、使用场景，并通过具体SQL示例来展示其在实际应用中的表现。 一、
阅读更多...
vue2实践：el-table实现由用户自己控制行数的动态表格

vue2实践：el-table实现由用户自己控制行数的动态表格

需求 项目中需要提供一个动态表单，如图： 当我点击添加时，便添加一行；点击右边的删除时，便删除这一行。 至少要有一行数据，但是没有上限。 思路 这种每一行的数据固定，但是不定行数的，很容易想到使用el-table来实现，它可以循环读取:data所绑定的数组，来生成行数据，不同的是： 1、table里面的每一个cell，需要放置一个input来支持用户编辑。 2、最后一列放置两个b
阅读更多...
【电机控制】数字滤波算法（持续更新）

【电机控制】数字滤波算法（持续更新）

文章目录 前言1. 数字低通滤波 前言 各种数字滤波原理，离散化公式及代码。 1. 数字低通滤波 滤波器公式 一阶低通滤波器的输出 y [ n ] y[n] y[n] 可以通过以下公式计算得到： y [ n ] = α x [ n ] + ( 1 − α ) y [ n − 1 ] y[n] = \alpha x[n] + (1 - \alpha) y[n-1]
阅读更多...
OpenStack离线Train版安装系列—3控制节点-Keystone认证服务组件

OpenStack离线Train版安装系列—3控制节点-Keystone认证服务组件

本系列文章包含从OpenStack离线源制作到完成OpenStack安装的全部过程。 在本系列教程中使用的OpenStack的安装版本为第20个版本Train（简称T版本），2020年5月13日，OpenStack社区发布了第21个版本Ussuri（简称U版本）。 OpenStack部署系列文章 OpenStack Victoria版 安装部署系列教程 OpenStack Ussuri版
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2