motor_state_check.c

这是一个在电动机运行状态的逻辑运算中常用的状态检测原理的例程。它根据电动机负载的大小和外部开关状态共同判断当前电动机的状态。

//========================================
//和电机状态相关的函数
//========================================

//========================================
//头文件
//========================================
#include "sfr16_lb.h"       /*以16位形式定义的特殊寄存器*/
#include "Variable_define.h"
#include "calculate.h"
#include "FRam_read_and_write.h"

//=======================================
//宏定义
#define YX   0.25   //运行的设定值
#define TC   0.10   //停车的设定值

void Check_MotorControl(void);  //检查通过开入对电机的控制
void Check_MotorState_Double(void);    //检查电机的状态(双向方式)
void Judge_MotorState_Double(void);    //判断电机状态，在上电时候和程序平跑飞时用(双向方式)
void Check_MotorState_Single(void);    //检查电机的状态(单向方式)
void Judge_MotorState_Single(void);    //判断电机状态，在上电时候和程序平跑飞时用(单向方式)
void RESET_ADD(void);           //复位次数加1


void Check_MotorControl(void)   //检查通过开入对电机的控制
{
  if(state_channel1)  {motor_positive_contr=0x00;} //IN1打开，电机正转控制无效
  else                {motor_positive_contr=0xff;} //IN1闭合，电机正转控制有效

  if(state_channel2)  {motor_negative_contr=0x00;} //IN2打开，电机反转控制无效
  else                {motor_negative_contr=0xff;} //IN2闭合，电机反转控制有效

  if(state_channel3)  {motor_stop_contr=0x00;}   //IN3打开，电机停止控制无效
  else                {motor_stop_contr=0xff;}   //IN3闭合，电机停止控制有效

  if(state_channel4)  {motor_positive_posit=0xff;}   //IN4打开，电机正转位置输入有效（常闭节点）
  else                {motor_positive_posit=0x00;}   //IN4闭合，电机正转位置输入无效（常闭节点）

  if(state_channel5)  {motor_negative_posit=0xff;} //IN5打开，电机反转位置输入有效（常闭节点）
  else                {motor_negative_posit=0x00;} //IN5闭合，电机反转位置输入无效（常闭节点）

  if(state_channel6)  {remote_local=0x00;} //IN6打开，装置就地有效
  else                {remote_local=0xff;} //IN6闭合，装置远方有效

  if(state_channel7)  {signreturn=0x00;} //IN7打开，信号复归输入无效
  else                {signreturn=0xff;} //IN7打开，信号复归输入有效

  if(inp_mode==1){
     if(state_channel8)  {test_position=0x00;}     //IN8打开，试验位置无效
     else                {test_position=0xff;}     //IN8闭合，试验位置有效
     if(state_channel9)  {extern_link_contr=0x00;} //IN9打开，连锁跳闸控制无效
     else                {extern_link_contr=0xff;} //IN9闭合，连锁跳闸控制有效
  }
  if(inp_mode==2){
     if(state_channel8)  {test_position=0x00;}     //IN8打开，试验位置无效
     else                {test_position=0xff;}     //IN8闭合，试验位置有效
     if(state_channel9)  {click_run_contr=0x00;}   //IN9打开，点击运行控制无效
     else                {click_run_contr=0xff;}   //IN9闭合，点击运行控制有效
  }
  if(inp_mode==3){
     if(state_channel8)  {extern_link_contr=0x00;} //IN9打开，连锁跳闸控制无效
     else                {extern_link_contr=0xff;} //IN9闭合，连锁跳闸控制有效
     if(state_channel9)  {click_run_contr=0x00;}   //IN9打开，点击运行控制无效
     else                {click_run_contr=0xff;}   //IN9闭合，点击运行控制有效
  }
  if(inp_mode==4){
     if(state_channel8)  {test_position=0x00;}     //IN8打开，试验位置无效
     else                {test_position=0xff;}     //IN8闭合，试验位置有效
  }

//以下为外部CT程控选通部分程序
  if((CT_mode==1)||(CT_mode==5)){   //选通第一通道：1A或者超过100A。
     CON_A1=0;
     CON_A0=0;
     CON_A11=0;
     CON_A10=0;
  }
  if(CT_mode==2){   //选通第二通道：6.3A。
     CON_A1=0;
     CON_A0=1;
     CON_A11=0;
     CON_A10=1;
  }
  if(CT_mode==3){   //选通第三通道：25A。
     CON_A1=1;
     CON_A0=0;
     CON_A11=1;
     CON_A10=0;
  }
  if(CT_mode==4){   //选通第四通道：100A。
     CON_A1=1;
     CON_A0=1;
     CON_A11=1;
     CON_A10=1;
  }
}

//=========================================
//电机运行状态的检查,对应电机的状态转换图
//=========================================
bit   reset_change=0;       //复位标志
bit   startcount_permit=0;  //启动延时
float start_counter=0;      //计时器
float jitter_counter=0;     //去抖定时器
float Temp_Imax=0;          //Imax的暂时寄存器
unsigned char err_counter=0;//辅助触点失灵计数器
void Check_MotorState_Double(void)    //检查电机的状态,motor_state:0x00=停止,0xff=运行,0xaa=启动,0x55=停车
{
  if(test_position==0xff){ //如果在试验状态下有开关位置，则电流置为额定值，这样方便调试
     if((motor_positive_posit==0xff)||(motor_negative_posit==0xff))
	 i_over=In;
  }
  //motor_state
  //0x00=停止,0x88=停车错误态(停车错误态的处理未写)
  //0x01=正启动,0x02=正运行,0x03=正停车
  //0xff=反启动,0xfe=反运行,0xfd=反停车
  switch(motor_state)  //根据运行状态分别检查电机的运行情况
    {
      case(0x00):  //停止
                if(startmode==2)  //双向电平控制方式
                {
                  //如果启动失败，不进行以下程序处理，直到启动失败的处理完成(start_fail==0x00)
                  if(start_fail==0xff)   //启动失败,退RL2,投RL1
                    {
                      motor_state=0x00;
                      startcount_permit=0;    
                      start_counter=0;
                      jitter_counter=0;       //去抖定时器
                      run_count_permit=0x00;  //运行计数器屏蔽
                      return;                 //返回
                    }

				  //正转继电器有效&&正转位置有效&&反转位置无效=正启动态
                  if((run_count_permit==0x01)&&(motor_positive_posit==0xff)&&(motor_negative_posit==0x00)) 
                    {
                      motor_state=0x01;
                      startcount_permit=0;
                      start_counter=0;
                      reset_change=1;                   //复位标志置1
                      start_fail=0x00;                  //启动失败清零
                      jitter_counter=0;                 //去抖定时器
                      run_count_permit=0x00;            //运行计数器屏蔽
                      return;
                    }

                  //反转继电器有效&&正转位置无效&&反转位置有效=反启动态
                  if((run_count_permit==0xff)&&(motor_positive_posit==0x00)&&(motor_negative_posit==0xff)) 
                    {
                      motor_state=0xff;
                      startcount_permit=0;
                      start_counter=0;
                      reset_change=1;                   //复位标志置1
                      start_fail=0x00;                  //启动失败清零
                      jitter_counter=0;                 //去抖定时器
                      run_count_permit=0x00;            //运行计数器屏蔽
                      return;
                    }

				  //正转继电器有效&&正转位置无效=等待15秒后判断,如无位置,出口返回,如有位置,正向启动
                  if((run_count_permit==0x01)&&(motor_positive_posit==0x00)) 
                     {
                       start_counter=start_counter+0.000833; //去抖定时器
                       if(start_counter>=15)  run_count_permit=0xaa; //如果15秒钟内,开入还没有进入启动态,关闭该继电器
                       return;                //直接返回
                     }

				  //反转继电器有效&&反转位置无效=等待15秒后判断，如无位置，出口返回，如有位置，反向启动
                  if((run_count_permit==0xff)&&(motor_negative_posit==0x00)) 
                     {
                       start_counter=start_counter+0.000833; //去抖定时器
                       if(start_counter>=15)  run_count_permit=0xaa; //如果15秒钟内,开入还没有进入启动态,关闭该继电器
                       return;                //直接返回
                     }

				  //继电器无效&&正转位置无效&&反转位置无效&&iMax<0.25In=停止态
                  if((run_count_permit==0x00)&&(motor_positive_posit==0x00)&&(motor_negative_posit==0x00)&&(i_over<=TC)) 
                    {
                      motor_state=0x00;
                      start_counter=0;
                      start_fail=0x00;                  //启动失败清零
                      jitter_counter=0;                 //去抖定时器
                      run_count_permit=0x00;            //运行计数器屏蔽
                      return;
                    }

                   //其他情况进入停止错误态
                   motor_state=0x88;
                   start_counter=0;
                   start_fail=0x00;                  //启动失败清零
                   jitter_counter=0;                 //去抖定时器
                   run_count_permit=0x00;            //运行计数器屏蔽
                }
				else{  //双向脉冲控制方式
                  //如果启动失败，不进行以下程序处理，直到启动失败的处理完成(start_fail==0x00)
                  if(start_fail==0xff)   //启动失败,退RL2,投RL1
                    {
                      motor_state=0x00;
                      startcount_permit=0;    
                      start_counter=0;
                      jitter_counter=0;       //去抖定时器
                      run_count_permit=0x00;  //运行计数器屏蔽
                      return;                 //返回
                    }

				  //正转位置有效&&反转位置无效=正启动态
                  if((motor_positive_posit==0xff)&&(motor_negative_posit==0x00)) 
                    {
                      motor_state=0x01;
                      startcount_permit=0;
                      start_counter=0;
                      reset_change=1;                   //复位标志置1
                      start_fail=0x00;                  //启动失败清零
                      jitter_counter=0;                 //去抖定时器
                      run_count_permit=0x00;            //运行计数器屏蔽
                      return;
                    }

                  //正转位置无效&&反转位置有效=反启动态
                  if((motor_positive_posit==0x00)&&(motor_negative_posit==0xff)) 
                    {
                      motor_state=0xff;
                      startcount_permit=0;
                      start_counter=0;
                      reset_change=1;                   //复位标志置1
                      start_fail=0x00;                  //启动失败清零
                      jitter_counter=0;                 //去抖定时器
                      run_count_permit=0x00;            //运行计数器屏蔽
                      return;
                    }

				  //正转位置无效&&反转位置无效&&iMax<0.25In=停止态
                  if((run_count_permit==0x00)&&(motor_positive_posit==0x00)&&(motor_negative_posit==0x00)&&(i_over<=TC)) 
                    {
                      motor_state=0x00;
                      start_counter=0;
                      start_fail=0x00;                  //启动失败清零
                      jitter_counter=0;                 //去抖定时器
                      run_count_permit=0x00;            //运行计数器屏蔽
                      return;
                    }

                   //其他情况进入停止错误态
                   motor_state=0x88;
                   start_counter=0;
                   start_fail=0x00;                  //启动失败清零
                   jitter_counter=0;                 //去抖定时器
                   run_count_permit=0x00;            //运行计数器屏蔽
				}
				break;
      case(0x01):  //正启动
                {
                  //如果启动失败，不进行以下程序处理，知道启动失败的处理完成(start_fail==0x00)
                  if(start_fail==0xff)   //启动失败，出口返回
                    {
                      motor_state=0x00;
                      start_counter=0;
                      startcount_permit=0;    
                      return;            //返回
                    }

                  if(i_over<YX*In) //如果Imax<=0.25In
                    {
                      jitter_counter=jitter_counter+0.000833; //去抖定时器
                      if(jitter_counter>=start_time) //如果一直小于0.25In,进入停止态
                        {
                          motor_state=0x00;    //回到停止态
                          start_counter=0;
                          jitter_counter=0;                 //去抖定时器
                          startcount_permit=0;
                          start_fail=0xff;   //启动失败，出口返回
                          return;
                        }
                    }
                  else   //如果Imax>0.25In,去抖时间置零
                    {
                      jitter_counter=0;                 //去抖定时器
                    }

                  start_counter=start_counter+0.000833; //延时833us
                  if(start_counter>=start_time)
                    {
                      motor_state=0x02;                 //正运行态
                      start_fail=0x00;                  //启动失败清零