状态机

最新推荐文章于 2021-09-18 19:45:00 发布
最新推荐文章于 2021-09-18 19:45:00 发布
阅读量659 收藏
点赞数
文章标签： byte string command exception session cmd
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wu_jing_sheng0/article/details/6419594
版权

1.发送数据和接收数据用2个状态机实现;

2. 增加了当数据发送以后指定的间隔内连续发送3次,如果没有收到下位机的回复则放弃;

3.取消使用定时器Timer类,自己写定时器;

using System;
using System.Collections;
using System.Threading;
using System.Xml;
using NLog;
using System.Timers;
using System.IO;
using System.Runtime.InteropServices;
using MSCommLib;

namespace equipment
{
 /// <summary>
 /// Desc:还书箱模块(用2个状态机实现)
 /// Author:周陶
 /// Date:2006-9-11
 /// Version:1.0
 /// </summary>
 public class RestoreBook : ThreadBase,EquipmentIF
 { 
  #region 配置文件
  private const string m_config_file = "..//configure//equipment//RestoreBook_config.xml";
  private const string m_const_node_name = "/configure/restorebooks/restorebook";
  private const string m_const_comport = "/configure/restorebooks/restorebook/communication";
  private static Logger logger = LogManager.GetCurrentClassLogger();
  #endregion

  #region 指令
  private const string TCU_BOX_STATUS = "41";
  private const string TCU_BOOK_STATUS = "40";
  private const string TCU_CHECKMAG_STATUS = "42";
  private const string TCU_DOOR_STATUS = "43";
  private const string TCU_BOOK_MOVE = "23";
  private const string TCU_RUN = "22";
  private const string TCU_RESET = "21";
  private const string TCU_END = "26";
  private const string TCU_CHECK_STATE = "24";
  #endregion

  #region 响应码
  private const string CE_OK = "0";
  private const string CE_CHECKERROR = "1";
  private const string CE_BADCOMMAND = "2"; //命令错误
  private const string CE_BADPARAM = "3"; //参数错误
  private const string CE_EXECUTE = "4";  //执行命令条件不足
  private const string CE_UNKNOWN = "5";
  private const string CE_NOCOMM = "6";
  #endregion

  #region 维护门状态
  private const string TCU_DOOR_OPENED = "1";
  private const string TCU_DOOR_CLOSED = "0";
  #endregion

  #region 检磁
  private const string E_ERROR = "1";
  private const string E_OK = "0";
  #endregion

  #region 书运行位置状态
  private const string E_READER_POSITION = "1";
  private const string E_WITHDRAW = "2";
  private const string E_READY_WITHDRAW = "3";
  private const string E_FORWARD = "4";
  private const string E_BOOK_ENTRY_ALL = "5";
  private const string E_BLOCK_BEFORE_READER = "11";
  private const string E_BLOCK_BEFORE_BOX = "12";
  private const string E_TIMEOUT_READER_POSITION = "13";
  private const string E_TIMEOUT_WAITING_ENTRY = "14";
  private const string E_TIMEOUT_ENTRY = "15";
  #endregion

  #region 还书箱状态
  private const string E_BOX_FULL = "1";
  private const string E_BOX_OK = "0";
  #endregion

  /*****************************************************************************/
  MSCommLib.MSCommClass mc = new MSCommLib.MSCommClass();

  ArrayList m_bytelist = new ArrayList();
  byte[] m_data = new byte[11];
  /*****************************************************************************/

  /*****************************系统定时器**************************************/
  private bool IS_RESPONSED = true;    //是否已经应答
  private int m_counter = 0;      //用于计算3次消息发送
  private string m_name = "";      //响应指令名称
  /*****************************************************************************/

  /******************************自定义定时器***********************************/
  BatchTimer t_time = null;      //分片定时器
  ResponseTimer m_responsetimer = null;   //响应定时器
  /*****************************************************************************/

  /****************************状态机*******************************************/
  #region 接收数据状态机
  private const string R_WAITING = "等待";
  private const string R_RECEIVING = "接收中";
  private const string R_RECEIVEALL = "全部接收";
  private const string R_BATCHTIMEOUT = "分片超时";
  private const string R_RESPONSETIMEOUT = "响应超时";
  private const string R_ERRORCOMMAND = "错误命令";
  private const string R_ERRORSTATUS = "错误状态";
  #endregion

  #region 发送数据状态机
  private const string S_WAITING = "等待";
  private const string S_RECEIVEALL = "全部接收";  
  private const string S_RESPONSETIMEOUT = "响应超时"; 
  private const string S_SEND = "已发送";
  private const string S_RESEND = "重复发送";
  private const string S_SENDCOUNT = "超过3次发送次数";
  private const string S_BATCHTIMEOUT = "分片超时";
  #endregion
  /*****************************************************************************/

  /****************************初始化状态机状态*********************************/
  string state1=S_WAITING,state2=R_WAITING;
  byte [] m_byte = new byte[11];
  /*****************************************************************************/


  [DllImport("user32.dll",EntryPoint="MessageBox")]
  public static extern void MsgBox(int hWnd,String text,String caption,uint type);

  /// <summary>
  /// 构造函数
  /// </summary>
  /// <param name="i_name"></param>
  public RestoreBook(string i_name):base(i_name)
  {
   this.InitCommonPort();
   t_time = new BatchTimer();
   m_responsetimer = new ResponseTimer();
  }


  /// <summary>
  /// 从配置文件中读取配置端口号
  /// </summary>
  /// <param name="t_config"></param>
  /// <returns></returns>
  private string getComPortConfig(string t_config)
  {
   XmlTextReader reader = new XmlTextReader(m_config_file);
   XmlDocument xmldoc = new XmlDocument();
   xmldoc.Load(reader);
   reader.Close();

   XmlNode t_node = xmldoc.SelectSingleNode(t_config);

   string port = t_node.InnerText;
   return port;
  }
 
  /// <summary>
  /// 取出指定长度的数据
  /// </summary>
  /// <param name="o_bytelist"></param>
  /// <param name="length"></param>
  private void GetReceiveData(ref byte[] o_bytelist,int length)
  {
   for(int i=0;i<length;i++)
   {
    o_bytelist[i] = (byte)m_bytelist[i];
   }
   m_bytelist.RemoveRange(0,length);
  }


  /// <summary>
  /// 接收MCU主动发送的消息、解析、封装成对象消息发送给Session层
  /// </summary>
  protected override void process()
  {
   //以40,41,42,43开头的指令属于主动上报状态的命令
   int count = 0;

   lock(state2) //接收数据状态机
   {
    switch(state2)
    {
     #region 接收中
     case R_RECEIVING: 
     {
      count = m_bytelist.Count; //计算缓冲区中接收到的数据长度

      if(count == 0)
      {
       state2 = R_WAITING;
      }
      else if(count < 11) //如果长度<11 接收不完整,启动分片定时器
      {
       #region 分片定时器       
       if(!t_time.IsStart)
       {
        t_time.Start();
        t_time.Intenal = 2000;
        logger.Debug("/n分片定时器已启动!");
       }
       else
       {
        if(t_time.IsTimeOut)
        {
         state1 = S_BATCHTIMEOUT;
        }
       }
       #endregion       
      }
      else if(count >= 11)
      {
       this.GetReceiveData(ref m_byte,11);

       byte t_command = m_byte[2];  //获得消息的命令用来判断是主动上报消息还是响应消息

       if(m_byte[0] == 0x82)
       {
        if(m_byte[10] == 0x83)
        {
         if(verifyCRC(m_byte))
         {
          if(t_command == 0x40 || t_command == 0x41 || t_command == 0x42 || t_command == 0x43)
          {
           logger.Debug("/n正确的状态指令 : [" + Utilities.ByteArrayToHexString(m_byte) + "]");
          }
          else
          {
           logger.Debug("/n正确的响应指令 : [" + Utilities.ByteArrayToHexString(m_byte) + "]");
           m_counter = 0;
           m_responsetimer.Stop(); 
          }
          state1 = S_RECEIVEALL;  //将发送状态机状态改为全部接收
          state2 = R_RECEIVING;  //将接收状态机状态改为接收中
         }
         else
         {
          if(t_command == 0x40 || t_command == 0x41 || t_command == 0x42 || t_command == 0x43)
          {
           state2 = R_ERRORSTATUS;
          }
          else
          {
           state2 = R_ERRORCOMMAND;
          }
         }
        }
        else
        {
         if(t_command == 0x40 || t_command == 0x41 || t_command == 0x42 || t_command == 0x43)
         {
          state2 = R_ERRORSTATUS;
         }
         else
         {
          state2 = R_ERRORCOMMAND;
         }
        }
       }
       else
       {
        if(t_command == 0x40 || t_command == 0x41 || t_command == 0x42 || t_command == 0x43)
        {
         state2 = R_ERRORSTATUS;
        }
        else
        {
         state2 = R_ERRORCOMMAND;
        }
       }
      }      
      break;
     }
     #endregion

     #region 接收命令错误
     case R_ERRORCOMMAND:
     {
      state2 = R_RECEIVING;  //接收中
      logger.Debug("/n响应命令格式错误![" + Utilities.ByteArrayToHexString(m_byte) + "]");
      this.clearArray(ref m_byte);
      break;
     }
     #endregion

     #region 接收状态错误
     case R_ERRORSTATUS:
     {
      state2 = R_RECEIVING;  //接收中
      logger.Debug("/n接收状态格式错误! [" + Utilities.ByteArrayToHexString(m_byte) + "]");
      this.clearArray(ref m_byte);
      break;
     }
     #endregion
    }
   }

   lock(state1) //发送数据状态机
   {
    switch(state1)
    {
     #region 已发送
     case S_SEND:
     {      
      if(!m_responsetimer.IsStart)
      {
       m_responsetimer.Start();
       m_responsetimer.Intenal = 3000;
       IS_RESPONSED = false;
       logger.Debug("/n响应超时定时器已启动!");
      }
      break;
     }
     #endregion

     #region 接收完毕并通过验证
     case S_RECEIVEALL:
     {
      sendMail(m_byte);   //通知上层
      state1 = S_WAITING;
      logger.Debug("/n已接收 : " + Utilities.ByteArrayToHexString(m_byte) + "]");
      this.clearArray(ref m_byte);
      break;
     }
     #endregion
     
     #region 重复发送3次
     case S_RESEND:
     {
      Thread.Sleep(1000);
      mc.Output = m_data;

      state1 = S_WAITING;
      logger.Debug("/n重复发送指令 : [" + Utilities.ByteArrayToHexString(m_data) + "] "+m_counter+"次!");
      break;
     }
     #endregion
     
     #region 响应超时
     case S_RESPONSETIMEOUT:
     {      
      state1 = S_WAITING;
      m_responsetimer.Stop();
      m_counter = 0;
      IS_RESPONSED = true;
      this.clearArray(ref m_data);
      logger.Debug("/n响应已超时!");
      break;
     }
     #endregion

     #region 发送次数超过3次
     case S_SENDCOUNT:
     {      
      m_counter = 0;
      m_responsetimer.Stop(); 
      IS_RESPONSED = true;
      state1 = S_WAITING;  //将状态设为等待状态
      logger.Debug("命令无应答,定时器已停止!");
      MsgBox(0,"命令无应答!","提醒",0);
      break;
     }
     #endregion

     #region 分片超时
     case S_BATCHTIMEOUT:
     {
      state1 = S_WAITING;  //将接收状态机改为等待状态
      this.GetReceiveData(ref m_byte,count);
      //m_bytelist.RemoveRange(0,count); //清除缓冲区
      IS_RESPONSED = true;
      t_time.Stop();
      logger.Debug("/n不完整的"+m_name+"响应指令 : ["+Utilities.ByteArrayToHexString(m_byte) + "],分片定时器已停止!");
      this.clearArray(ref m_byte);
      break;
     }
     #endregion
    }
   }

   #region 响应定时器
   if(IS_RESPONSED == false)     //没有响应
   {
    if(m_responsetimer.IsStart)    //超时定时器已启动
    {
     if(m_counter < 3)     //发送次数小于3
     {
      if(m_responsetimer.IsTimeOut) //超时
      {
       state1 = S_RESPONSETIMEOUT; //通知发送状态机响应超时
      }
      else       //没有超时但没有收到响应
      {
       state1 = S_RESEND;   //通知发送状态机再发一次
       m_counter ++;    //次数＋1
      }
     }
     else        //超过3次
     {
      state1 = S_SENDCOUNT;   //通知发送状态机停止发送，关闭定时器
     }
    }
   }
   #endregion

  }
 
  /// <summary>
  /// check the data CRC
  /// </summary>
  /// <returns></returns>
  private bool verifyCRC(byte[] i_byte)
  {
   #region 接收

   byte t1 = i_byte[8];
   byte t2 = i_byte[9];
   byte [] data = {0x08,i_byte[2],i_byte[4],i_byte[5],i_byte[6],i_byte[7]};
   byte [] crcData = Utilities.CRC(data,data.Length);
   if(t1==crcData[0] && t2==crcData[1])
   {
    return true;
   }
   else
   {
    return false;
   }

   #endregion
  }

    
  /// <summary>
  /// clear array
  /// </summary>
  /// <param name="o_data"></param>
  private void clearArray(ref byte[]o_data)
  {
   for(int i=0;i<o_data.Length;i++)
   {
    o_data[i] =0;
   }
  }

  
  /// <summary>
  /// send mail to session
  /// </summary>
  /// <param name="inData"></param>
  private void sendMail(byte[] inData)
  {
   //构造命令
   Mail t_mail = null;

   MailHandlerIF t_mail_handler = new RestoreBookMailHandler();

   string t_cmd = inData[2].ToString("X");   //指令
    
   string t_paramter = inData[7].ToString("X"); //参数

   #region
   switch(t_cmd)
   {
    case TCU_BOX_STATUS:        //主 动 上 报 回 收 箱 状 态
    {
     #region
      
     switch(t_paramter)
     {
      case E_BOX_FULL:
      {
       //箱满

       t_mail = t_mail_handler.CreateMail(MailInfo.Type.RestoreBook,MailInfo.Name.E_TCU_BOX_STATUS,this.m_send_mailbox,this.m_receive_mailbox,MailInfo.E_TCU_Parameter.E_BOX_FULL);
                
       response("BOX",E_BOX_FULL);        
        
       break;
      }
      case E_BOX_OK:
      {
       //正常

       t_mail = t_mail_handler.CreateMail(MailInfo.Type.RestoreBook,MailInfo.Name.E_TCU_BOX_STATUS,this.m_send_mailbox,this.m_receive_mailbox,MailInfo.E_TCU_Parameter.E_BOX_OK);
       
       response("BOX",E_BOX_OK);

       break;
      }
     }
      
     this.m_send_mailbox.delivery(t_mail);

     break;

     #endregion
    }
    case TCU_BOOK_STATUS:       //TCU 主 动 上 报 书 运 行 位 置 状 态
    {
     #region
      
     switch(t_paramter)
     {
      case E_READER_POSITION:
      {
       //书已到读卡位置

       t_mail = t_mail_handler.CreateMail(MailInfo.Type.RestoreBook,MailInfo.Name.E_TCU_BOOK_STATUS,this.m_send_mailbox,this.m_receive_mailbox,MailInfo.E_TCU_Parameter.E_READER_POSITION);

       response("BOOK_STATUS",E_READER_POSITION);

       break;
      }
      case E_WITHDRAW:
      {
       //书已经从入口被取走
     
       t_mail = t_mail_handler.CreateMail(MailInfo.Type.RestoreBook,MailInfo.Name.E_TCU_BOOK_STATUS,this.m_send_mailbox,this.m_receive_mailbox,MailInfo.E_TCU_Parameter.E_WITHDRAW);
       
       response("BOOK_STATUS",E_WITHDRAW);

       break;
      }
      case E_READY_WITHDRAW:
      {
       //书已在入口处等待被取走

       t_mail = t_mail_handler.CreateMail(MailInfo.Type.RestoreBook,MailInfo.Name.E_TCU_BOOK_STATUS,this.m_send_mailbox,this.m_receive_mailbox,MailInfo.E_TCU_Parameter.E_READY_WITHDRAW);
        
       response("BOOK_STATUS",E_READY_WITHDRAW);

       break;
      }
      case E_FORWARD:
      {
       //书已收入回收箱
        
       t_mail = t_mail_handler.CreateMail(MailInfo.Type.RestoreBook,MailInfo.Name.E_TCU_BOOK_STATUS,this.m_send_mailbox,this.m_receive_mailbox,MailInfo.E_TCU_Parameter.E_FORWARD);
       
       response("BOOK_STATUS",E_FORWARD);

       break;
      }
      case E_BOOK_ENTRY_ALL:
      {
       //书完全进入
        
       t_mail = t_mail_handler.CreateMail(MailInfo.Type.RestoreBook,MailInfo.Name.E_TCU_BOOK_STATUS,this.m_send_mailbox,this.m_receive_mailbox,MailInfo.E_TCU_Parameter.E_BOOK_ENTRY_ALL);
       
       response("BOOK_STATUS",E_BOOK_ENTRY_ALL);

       break;
      }
      case E_BLOCK_BEFORE_READER:
      {
       //读卡位置到入口之间发生堵塞故障

       t_mail = t_mail_handler.CreateMail(MailInfo.Type.RestoreBook,MailInfo.Name.E_TCU_BOOK_STATUS,this.m_send_mailbox,this.m_receive_mailbox,MailInfo.E_TCU_Parameter.E_BLOCK_BEFORE_READER);
       
       response("BOOK_STATUS",E_BLOCK_BEFORE_READER);

       break;
      }
      case E_BLOCK_BEFORE_BOX:
      {
       //读卡位置到回收箱之间发生堵塞故障

       t_mail = t_mail_handler.CreateMail(MailInfo.Type.RestoreBook,MailInfo.Name.E_TCU_BOOK_STATUS,this.m_send_mailbox,this.m_receive_mailbox,MailInfo.E_TCU_Parameter.E_BLOCK_BEFORE_BOX);
       
       response("BOOK_STATUS",E_BLOCK_BEFORE_BOX);

       break;
      }
      case E_TIMEOUT_READER_POSITION:
      {
       //读卡位置等待超时

       t_mail = t_mail_handler.CreateMail(MailInfo.Type.RestoreBook,MailInfo.Name.E_TCU_BOOK_STATUS,this.m_send_mailbox,this.m_receive_mailbox,MailInfo.E_TCU_Parameter.E_TIMEOUT_READER_POSITION);
       
       response("BOOK_STATUS",E_TIMEOUT_READER_POSITION);

       break;
      }
      case E_TIMEOUT_WAITING_ENTRY:
      {
       //书等待进入超时

       t_mail = t_mail_handler.CreateMail(MailInfo.Type.RestoreBook,MailInfo.Name.E_TCU_BOOK_STATUS,this.m_send_mailbox,this.m_receive_mailbox,MailInfo.E_TCU_Parameter.E_TIMEOUT_WAITING_ENTRY);
       
       response("BOOK_STATUS",E_TIMEOUT_WAITING_ENTRY);

       break;
      }
      case E_TIMEOUT_ENTRY:
      {
       //书在入口处等待超时

       t_mail = t_mail_handler.CreateMail(MailInfo.Type.RestoreBook,MailInfo.Name.E_TCU_BOOK_STATUS,this.m_send_mailbox,this.m_receive_mailbox,MailInfo.E_TCU_Parameter.E_TIMEOUT_ENTRY);
       
       response("BOOK_STATUS",E_TIMEOUT_ENTRY);

       break;
      }
     }
      
     this.m_send_mailbox.delivery(t_mail);

     break;

     #endregion
    }
    case TCU_CHECKMAG_STATUS:   //主 动 上 报 检 磁 状 态
    {
     #region
      
     switch(t_paramter)
     {
      case E_ERROR:
      {
       //检磁失败

       t_mail = t_mail_handler.CreateMail(MailInfo.Type.RestoreBook,MailInfo.Name.E_TCU_CHECKMAG_STATUS,this.m_send_mailbox,this.m_receive_mailbox,MailInfo.E_TCU_Parameter.E_ERROR);
      
       response("CHECKMAG",E_ERROR);

       break;
      }
      case E_OK:
      {
       //检磁成功
        
       t_mail = t_mail_handler.CreateMail(MailInfo.Type.RestoreBook,MailInfo.Name.E_TCU_CHECKMAG_STATUS,this.m_send_mailbox,this.m_receive_mailbox,MailInfo.E_TCU_Parameter.E_OK);
       
       response("CHECKMAG",E_OK);

       break;
      }
     }

     this.m_send_mailbox.delivery(t_mail);

     break;
      
     #endregion
    }
    case TCU_DOOR_STATUS:       //主 动 上 报 维 护 门 状 态
    {
     #region
      
     switch(t_paramter)
     {
      case TCU_DOOR_OPENED:
      {
       //门被打开

       t_mail = t_mail_handler.CreateMail(MailInfo.Type.RestoreBook,MailInfo.Name.E_TCU_DOOR_STATUS,this.m_send_mailbox,this.m_receive_mailbox,MailInfo.E_TCU_Parameter.E_DOOR_OPEN);
       
       response("DOOR_STATUS",TCU_DOOR_OPENED);

       break;
      }
      case TCU_DOOR_CLOSED:
      {
       //门关闭

       t_mail = t_mail_handler.CreateMail(MailInfo.Type.RestoreBook,MailInfo.Name.E_TCU_DOOR_STATUS,this.m_send_mailbox,this.m_receive_mailbox,MailInfo.E_TCU_Parameter.E_DOOR_CLOSE);
       
       response("DOOR_STATUS",TCU_DOOR_CLOSED);

       break;
      }
     }

     this.m_send_mailbox.delivery(t_mail);

     break;
      
     #endregion
    }
    case TCU_BOOK_MOVE:         //指 导 书 运 行 状 态
    {
     #region
     switch(t_paramter)
     {
      case CE_OK://正常
      {
       t_mail = t_mail_handler.CreateMail(MailInfo.Type.RestoreBook,MailInfo.Name.E_TCU_BOOK_MOVE,this.m_send_mailbox,this.m_receive_mailbox,MailInfo.ErrorParameter.E_TCU_OK);
       
       break;
      }
      case CE_CHECKERROR://校验错误
      {
       t_mail = t_mail_handler.CreateMail(MailInfo.Type.RestoreBook,MailInfo.Name.E_TCU_BOOK_MOVE,this.m_send_mailbox,this.m_receive_mailbox,MailInfo.ErrorParameter.E_TCU_CHECKERROR);
       
       break;
      }
      case CE_BADCOMMAND://命令错误
      {
       t_mail = t_mail_handler.CreateMail(MailInfo.Type.RestoreBook,MailInfo.Name.E_TCU_BOOK_MOVE,this.m_send_mailbox,this.m_receive_mailbox,MailInfo.ErrorParameter.E_TCU_BADCOMMAND);
       
       break;
      }
      case CE_BADPARAM://参数错误
      {
       t_mail = t_mail_handler.CreateMail(MailInfo.Type.RestoreBook,MailInfo.Name.E_TCU_BOOK_MOVE,this.m_send_mailbox,this.m_receive_mailbox,MailInfo.ErrorParameter.E_TCU_BADPARAM);
       
       break;
      }
      case CE_EXECUTE://命令执行条件不足
      {
       t_mail = t_mail_handler.CreateMail(MailInfo.Type.RestoreBook,MailInfo.Name.E_TCU_BOOK_MOVE,this.m_send_mailbox,this.m_receive_mailbox,MailInfo.ErrorParameter.E_TCU_EXECUTE);
       
       break;
      }
      case CE_UNKNOWN://其他错误
      {
       t_mail = t_mail_handler.CreateMail(MailInfo.Type.RestoreBook,MailInfo.Name.E_TCU_BOOK_MOVE,this.m_send_mailbox,this.m_receive_mailbox,MailInfo.ErrorParameter.E_TCU_UNKNOWN);
       
       break;
      }
      case CE_NOCOMM://通讯故障
      {
       t_mail = t_mail_handler.CreateMail(MailInfo.Type.RestoreBook,MailInfo.Name.E_TCU_BOOK_MOVE,this.m_send_mailbox,this.m_receive_mailbox,MailInfo.ErrorParameter.E_TCU_NOCOMM);
       
       break;
      }
     }

     this.m_send_mailbox.delivery(t_mail);

     break;
     #endregion
    }
    case TCU_RUN:               //登 陆 成 功
    {
     #region
     switch(t_paramter)
     {
      case CE_OK://正常
      {
       t_mail = t_mail_handler.CreateMail(MailInfo.Type.RestoreBook,MailInfo.Name.E_TCU_RUN,this.m_send_mailbox,this.m_receive_mailbox,MailInfo.ErrorParameter.E_TCU_OK);
       
       this.m_send_mailbox.delivery(t_mail);

       break;
      }
     }
     break;
     #endregion
    }
    case TCU_RESET:             //复 位
    {
     #region
     switch(t_paramter)
     {
      case CE_OK://正常
      {
       t_mail = t_mail_handler.CreateMail(MailInfo.Type.RestoreBook,MailInfo.Name.E_TCU_RESET,this.m_send_mailbox,this.m_receive_mailbox,MailInfo.ErrorParameter.E_TCU_OK);
       
       this.m_send_mailbox.delivery(t_mail);

       break;
      }
     }     
     break;
     #endregion
    }
    case TCU_END:               //结 束
    {
     #region
     switch(t_paramter)
     {
      case CE_OK://正常
      {
       t_mail = t_mail_handler.CreateMail(MailInfo.Type.RestoreBook,MailInfo.Name.E_TCU_END,this.m_send_mailbox,this.m_receive_mailbox,MailInfo.ErrorParameter.E_TCU_OK);
       
       this.m_send_mailbox.delivery(t_mail);

       break;
      }
     }     
     break;
     #endregion
    }
    case TCU_CHECK_STATE:  //检 查 设 备 状 态
    {
     byte p4 = inData[7];

     if((p4 & 0x02) == 0)
     {
      t_mail = t_mail_handler.CreateMail(MailInfo.Type.RestoreBook,MailInfo.Name.E_TCU_CHECK_STATE,this.m_send_mailbox,this.m_receive_mailbox,MailInfo.E_TCU_Parameter.E_BOX_COVER);
     
      this.m_send_mailbox.delivery(t_mail);
     }
     if((p4 & 0x04) == 0)
     {
      t_mail = t_mail_handler.CreateMail(MailInfo.Type.RestoreBook,MailInfo.Name.E_TCU_CHECK_STATE,this.m_send_mailbox,this.m_receive_mailbox,MailInfo.E_TCU_Parameter.E_DOOR_COVER);
     
      this.m_send_mailbox.delivery(t_mail);
     }
     if((p4 & 0x08) == 0)
     {
      t_mail = t_mail_handler.CreateMail(MailInfo.Type.RestoreBook,MailInfo.Name.E_TCU_CHECK_STATE,this.m_send_mailbox,this.m_receive_mailbox,MailInfo.E_TCU_Parameter.E_CHECKMAG_CONVER);
     
      this.m_send_mailbox.delivery(t_mail);
     }
     if((p4 & 0x10) == 0)
     {
      t_mail = t_mail_handler.CreateMail(MailInfo.Type.RestoreBook,MailInfo.Name.E_TCU_CHECK_STATE,this.m_send_mailbox,this.m_receive_mailbox,MailInfo.E_TCU_Parameter.E_READER_CONVER);
     
      this.m_send_mailbox.delivery(t_mail);
     }
     if((p4 & 0x20) == 0)
     {
      t_mail = t_mail_handler.CreateMail(MailInfo.Type.RestoreBook,MailInfo.Name.E_TCU_CHECK_STATE,this.m_send_mailbox,this.m_receive_mailbox,MailInfo.E_TCU_Parameter.E_BOX_ENTRY1_CONVER);
     
      this.m_send_mailbox.delivery(t_mail);
     }
     if((p4 & 0x40) == 0)
     {
      t_mail = t_mail_handler.CreateMail(MailInfo.Type.RestoreBook,MailInfo.Name.E_TCU_CHECK_STATE,this.m_send_mailbox,this.m_receive_mailbox,MailInfo.E_TCU_Parameter.E_BOX_ENTRY2_COVER);
     
      this.m_send_mailbox.delivery(t_mail);
     }

     break;
    }
   }
   #endregion

   //发送命令
   //this.m_send_mailbox.delivery(t_mail);
  }


  /// <summary>
  /// init com
  /// </summary>
  private void InitCommonPort()
  { 
   try
   {
    string [] t_comport = this.getComPortConfig(m_const_comport).Split(':');
    mc.CommPort = Convert.ToInt16( t_comport[0].Substring(3,1) ); //4
    mc.Settings = t_comport[1] ;     //38400,n,8,1
    mc.RThreshold = 1;        //每接收一个字符则激发OnComm()事件
    mc.DTREnable = true;
    mc.Handshaking = MSCommLib.HandshakeConstants.comNone;    
    mc.InputMode = MSCommLib.InputModeConstants.comInputModeBinary;   //二进制
    mc.InBufferSize = 1024;
    mc.InputLen = 0;        //决定每次Input读入的字符个数，缺省为0，表示读取接收缓冲区的全部内容
    //mc.InputLen = 1;        //一次读取一个
    mc.NullDiscard = false;
    mc.OnComm +=new MSCommLib.DMSCommEvents_OnCommEventHandler(mc_OnComm);  //注册一个OnComm事件
   
    try
    {
     mc.PortOpen = true;  //打开串口
     
     logger.Debug("串口已打开!");
    }
    catch
    {
     logger.Debug("串口打开失败!");
    }
   }
   catch(Exception ex)
   {
    logger.Debug(ex.Message);
   }
  }


  /// <summary>
  /// release resource
  /// </summary>
  public override void shutDown()
  {
   if(mc.PortOpen)
    mc.PortOpen = false;
  }


  /// <summary>
  /// receive the data from session layer then parse、create com data and send to MCU
  /// </summary>
  /// <param name="i_mail"></param>
  protected override void commonMailArriveProcess(Mail i_mail)
  {
   MailInfo.Name t_mail_name = i_mail.m_mail_name;         //mail name(command)
   
   string t_book_parameter = (string)i_mail.m_parameter;   //parameter

   byte [] data = {0x08,0x00,0x00,0x00,0x00,0x00};
   byte [] outData = {0x02,0x08,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x03};
   byte [] crcData = null;
   byte [] cData = null;

   #region
   switch(t_mail_name)
   {
    case MailInfo.Name.E_TCU_RESET:         //复位
    {
     #region
     
     data[1] = 0x21;
     crcData = Utilities.CRC(data,data.Length);   
     outData[2] = 0x21;
     outData[8] = crcData[0];
     outData[9] = crcData[1];
   
     mc.Output = outData;

     logger.Debug("/n复位 : [" + Utilities.ByteArrayToHexString(outData) + "]");

     break;
     
     #endregion
    }
    case MailInfo.Name.E_TCU_RUN:           //登陆成功
    {
     #region
     
     data[1] = 0x22;
     crcData = Utilities.CRC(data,data.Length);
     outData[2] = 0x22;
     outData[8] = crcData[0];
     outData[9] = crcData[1];

     mc.Output = outData;

     m_name = "登陆成功";
     logger.Debug("/n发送登陆成功指令 : [" + Utilities.ByteArrayToHexString(outData) + "]");

     /***********************************************************************************/
     outData.CopyTo(m_data,0); //将消息复制到全局变量数组中，以后用来判断改消息是否回复
     
     state1 = S_SEND;   //将发送状态机的状态改为已发送
     /***********************************************************************************/

     break;

     #endregion
    }
    case MailInfo.Name.E_TCU_CHECK_STATE:   //检查设备状态
    {
     #region
     
     data[1] = 0x24;
     crcData = Utilities.CRC(data,data.Length);
     outData[2] = 0x24;
     outData[8] = crcData[0];
     outData[9] = crcData[1];
   
     mc.Output = outData;

     m_name = "检查设备状态";
     logger.Debug("/n检查设备状态 : [" + Utilities.ByteArrayToHexString(outData) + "]");

     /************************************************************************************/
     outData.CopyTo(m_data,0); //将消息复制到全局变量数组中，以后用来判断改消息是否回复
     
     state1 = S_SEND;   //将发送状态机的状态改为已发送
     /************************************************************************************/

     break;
     
     #endregion
    }
    case MailInfo.Name.E_TCU_BOOK_MOVE:     //指导书运动
    {
     #region
     
     switch(t_book_parameter)
     {
      case "E_BACK":      //书已退到入口
      {
       #region
       
       data[1] = 0x23;
       data[5] = 0x01;
       crcData = Utilities.CRC(data,data.Length);
       outData[2] = 0x23;
       outData[7] = 0x01;
       outData[8] = crcData[0];
       outData[9] = crcData[1];

       logger.Debug("/n书已退到入口 : ["+ Utilities.ByteArrayToHexString(outData) + "]");

       break;
       #endregion
      }
      case "E_FORWARD":   //收入回收箱
      {
       #region
          
       data[1] = 0x23;
       data[5] = 0x02;
       crcData = Utilities.CRC(data,data.Length);
       outData[2] = 0x23;
       outData[7] = 0x02;
       outData[8] = crcData[0];
       outData[9] = crcData[1];

       logger.Debug("/n收入回收箱 : ["+ Utilities.ByteArrayToHexString(outData) + "]");

       break;
       #endregion
      }
     }
     
     mc.Output = outData;

     /************************************************************************************/
     outData.CopyTo(m_data,0); //将消息复制到全局变量数组中，以后用来判断改消息是否回复

     state1 = S_SEND;   //将发送状态机的状态改为已发送
     /************************************************************************************/

     break;

     #endregion
    }
    case MailInfo.Name.E_TCU_BOOK_STATUS:   //主动上报书运行位置状态
    {
     #region
     
     switch(t_book_parameter)
     {
      case "E_READER_POSITION":   //书已到读卡位置
      {
       #region
      
       data[1] = 0x40;
       data[5] = 0x01;
       cData = Utilities.CRC(data,data.Length);

       outData[0] = 0x82;
       outData[2] = 0x40;
       outData[7] = 0x01;
       outData[8] = cData[0];
       outData[9] = cData[1];
       outData[10] = 0x83;

       logger.Debug("/n书已到读卡位置 : [" + Utilities.ByteArrayToHexString(outData)  + "]");

       break;
       #endregion
      }
      case "E_WITHDRAW":     //书已从入口被取走
      {
       #region
       
       data[1] = 0x40;
       data[5] = 0x02;
       cData = Utilities.CRC(data,data.Length);

       outData[0] = 0x82;
       outData[2] = 0x40;
       outData[7] = 0x02;
       outData[8] = cData[0];
       outData[9] = cData[1];
       outData[10] = 0x83;

       logger.Debug("/n书已从入口被取走 : [" + Utilities.ByteArrayToHexString(outData) + "]");

       break;
       #endregion
      }
      case "E_READY_WITHDRAW":   //书已在入口处等待被取走
      {
       #region
       
       data[1] = 0x40;
       data[5] = 0x03;
       cData = Utilities.CRC(data,data.Length);

       outData[0] = 0x82;
       outData[2] = 0x40;
       outData[7] = 0x03;
       outData[8] = cData[0];
       outData[9] = cData[1];
       outData[10] = 0x83;

       logger.Debug("/n书已在入口处等待被取走 : [" + Utilities.ByteArrayToHexString(outData) +"]");

       break;
       #endregion
      }
      case "E_FORWARD":     //书已收入回收箱
      {
       #region
      
       data[1] = 0x40;
       data[5] = 0x04;
       cData = Utilities.CRC(data,data.Length);

       outData[0] = 0x82;
       outData[2] = 0x40;
       outData[7] = 0x04;
       outData[8] = cData[0];
       outData[9] = cData[1];
       outData[10] = 0x83;

       logger.Debug("/n书已收入回收箱 : [" + Utilities.ByteArrayToHexString(outData) +"]");

       break;
       #endregion
      }
      case "E_BLOCK_BEFORE_READER":  //读卡位置到入口之间发生堵塞故障
      {
       #region
       
       data[1] = 0x40;
       data[5] = 0x011;
       cData = Utilities.CRC(data,data.Length);

       outData[0] = 0x82;
       outData[2] = 0x40;
       outData[7] = 0x11;
       outData[8] = cData[0];
       outData[9] = cData[1];
       outData[10] = 0x83;

       logger.Debug("/n读卡位置到入口之间发生堵塞故障 : [" + Utilities.ByteArrayToHexString(outData) +"]");
 
       break;
       #endregion
      }
      case "E_BLOCK_BEFORE_BOX":   //读卡位置到回收箱之间发生堵塞故障
      {
       #region
              
       data[1] = 0x40;
       data[5] = 0x12;
       cData = Utilities.CRC(data,data.Length);

       outData[0] = 0x82;
       outData[2] = 0x40;
       outData[7] = 0x12;
       outData[8] = cData[0];
       outData[9] = cData[1];
       outData[10] = 0x83;

       logger.Debug("/n读卡位置到回收箱之间发生堵塞故障 : [" + Utilities.ByteArrayToHexString(outData) +"]");

       break;
       #endregion
      }
      case "E_TIMEOUT_READER_POSITION":   //读卡位置等待超时
      {
       #region
       
       data[1] = 0x40;
       data[5] = 0x13;
       cData = Utilities.CRC(data,data.Length);

       outData[0] = 0x82;
       outData[2] = 0x40;
       outData[7] = 0x13;
       outData[8] = cData[0];
       outData[9] = cData[1];
       outData[10] = 0x83;

       logger.Debug("/n读卡位置等待超时 : [" + Utilities.ByteArrayToHexString(outData)+"]");

       break;
       #endregion
      }
      case "E_TIMEOUT_WAITING_ENTRY":  //书等待进入超时
      {
       #region
       
       data[1] = 0x40;
       data[5] = 0x14;
       cData = Utilities.CRC(data,data.Length);

       outData[0] = 0x82;
       outData[2] = 0x40;
       outData[7] = 0x14;
       outData[8] = cData[0];
       outData[9] = cData[1];
       outData[10] = 0x83;

       logger.Debug("/n书等待进入超时 : [" + Utilities.ByteArrayToHexString(outData)+"]");

       break;
       #endregion
      }
      case "E_TIMEOUT_ENTRY":    //书在入口处等待超时
      {
       #region
       
       data[1] = 0x40;
       data[5] = 0x15;
       cData = Utilities.CRC(data,data.Length);

       outData[0] = 0x82;
       outData[2] = 0x40;
       outData[7] = 0x15;
       outData[8] = cData[0];
       outData[9] = cData[1];
       outData[10] = 0x83;

       logger.Debug("/n书在入口处等待超时 : [" + Utilities.ByteArrayToHexString(outData) + "]");

       break;
       #endregion
      }
      default:       //书已进入还书箱
      {
       #region
          
       data[1] = 0x23;
       cData = Utilities.CRC(data,data.Length);

       outData[2] = 0x23;
       outData[8] = cData[0];
       outData[9] = cData[1];

       logger.Debug("/n书已进入还书箱 : [" + Utilities.ByteArrayToHexString(outData) + "]");

       break;
       #endregion
      }
     }

     mc.Output = outData;
     
     break;

     #endregion     
    }
    case MailInfo.Name.E_TCU_END:           //结束
    {
     #region

     data[1] = 0x26;
     crcData = Utilities.CRC(data,data.Length);
     outData[2] = 0x26;
     outData[8] = crcData[0];
     outData[9] = crcData[1];

     mc.Output = outData;

     m_name = "结束";     
     logger.Debug("/n结束 : [" + Utilities.ByteArrayToHexString(outData) + "]");

     /*************************************************************************************/
     outData.CopyTo(m_data,0); //将消息复制到全局变量数组中，以后用来判断改消息是否回复
     
     state1 = S_SEND;   //将发送状态机的状态改为已发送
     /*************************************************************************************/

     break;

     #endregion
    }
   }
   #endregion
  }

  /// <summary>
  /// 对下位机主动发送的命令的响应
  /// </summary>
  /// <param name="command">命令</param>
  /// <param name="parameter">参数</param>
  private void response(string command,string parameter)
  {
   byte [] crcData = null; //校验码
   byte [] data = null; //参与计算校验码值参数
   byte [] outData = null; //响应消息

   switch(command)
   {
    case "BOX":    //还书箱状态
    {
     switch(parameter)
     {
       #region
      case E_BOX_FULL: //还书箱已满
      {
       data = new byte[]{0x08,0x41,0x00,0x00,0x00,0x00};
       crcData = Utilities.CRC(data,data.Length);
       outData = new byte[]{0x02,0x08,0x41,0x00,0x00,0x00,0x00,0x00,crcData[0],crcData[1],0x03};
       break;
      }
      case E_BOX_OK:  //还书箱正常
      {
       data = new byte[]{0x08,0x41,0x00,0x00,0x00,0x00};
       crcData = Utilities.CRC(data,data.Length);
       outData = new byte[]{0x02,0x08,0x41,0x00,0x00,0x00,0x00,0x00,crcData[0],crcData[1],0x03};
       break;
      }
       #endregion
     }

     break;
    }

    case "BOOK_STATUS":  //书运行状态
    {
     switch(parameter)
     {
       #region

      case E_READER_POSITION://书已到读卡位置
      {
       data = new byte[]{0x08,0x40,0x00,0x00,0x00,0x00};
       crcData = Utilities.CRC(data,data.Length);
       outData = new byte[]{0x02,0x08,0x40,0x00,0x00,0x00,0x00,0x00,crcData[0],crcData[1],0x03};
       break;
      }
      case E_WITHDRAW: //书从入口被取走
      {
       data = new byte[]{0x08,0x40,0x00,0x00,0x00,0x00};
       crcData = Utilities.CRC(data,data.Length);
       outData = new byte[]{0x02,0x08,0x40,0x00,0x00,0x00,0x00,0x00,crcData[0],crcData[1],0x03};
       break;
      }
      case E_READY_WITHDRAW:  //书已在入口处被等待取走
      {
       data = new byte[]{0x08,0x40,0x00,0x00,0x00,0x00};
       crcData = Utilities.CRC(data,data.Length);
       outData = new byte[]{0x02,0x08,0x40,0x00,0x00,0x00,0x00,0x00,crcData[0],crcData[1],0x03};
       break;
      }
      case E_FORWARD:  //书已进入回收箱
      {
       data = new byte[]{0x08,0x40,0x00,0x00,0x00,0x00};
       crcData = Utilities.CRC(data,data.Length);
       outData = new byte[]{0x02,0x08,0x40,0x00,0x00,0x00,0x00,0x00,crcData[0],crcData[1],0x03};
       break;
      }
      case E_BOOK_ENTRY_ALL:  //书已完全进入
      {
       data = new byte[]{0x08,0x40,0x00,0x00,0x00,0x00};
       crcData = Utilities.CRC(data,data.Length);
       outData = new byte[]{0x02,0x08,0x40,0x00,0x00,0x00,0x00,0x00,crcData[0],crcData[1],0x03};
       break;
      }
      case E_BLOCK_BEFORE_READER:  //读卡位置到入口之间发生堵塞故障
      {
       data = new byte[]{0x08,0x40,0x00,0x00,0x00,0x00};
       crcData = Utilities.CRC(data,data.Length);
       outData = new byte[]{0x02,0x08,0x40,0x00,0x00,0x00,0x00,0x00,crcData[0],crcData[1],0x03};
       break;
      }
      case E_BLOCK_BEFORE_BOX: //读卡位置到回收箱之间发生堵塞故障
      {
       data = new byte[]{0x08,0x40,0x00,0x00,0x00,0x00};
       crcData = Utilities.CRC(data,data.Length);
       outData = new byte[]{0x02,0x08,0x40,0x00,0x00,0x00,0x00,0x00,crcData[0],crcData[1],0x03};
       break;
      }
      case E_TIMEOUT_READER_POSITION:  //读卡位置等待超时
      {
       data = new byte[]{0x08,0x40,0x00,0x00,0x00,0x00};
       crcData = Utilities.CRC(data,data.Length);
       outData = new byte[]{0x02,0x08,0x40,0x00,0x00,0x00,0x00,0x00,crcData[0],crcData[1],0x03};
       break;
      }
      case E_TIMEOUT_WAITING_ENTRY: //书等待进入超时
      {
       data = new byte[]{0x08,0x40,0x00,0x00,0x00,0x00};
       crcData = Utilities.CRC(data,data.Length);
       outData = new byte[]{0x02,0x08,0x40,0x00,0x00,0x00,0x00,0x00,crcData[0],crcData[1],0x03};
       break;
      }
      case E_TIMEOUT_ENTRY: //书在入口处等待超时
      {
       data = new byte[]{0x08,0x40,0x00,0x00,0x00,0x00};
       crcData = Utilities.CRC(data,data.Length);
       outData = new byte[]{0x02,0x08,0x40,0x00,0x00,0x00,0x00,0x00,crcData[0],crcData[1],0x03};
       break;
      }

       #endregion
     }

     break;
    }

    case "CHECKMAG":  //检磁状态
    {
     switch(parameter)
     {
       #region
      case E_ERROR:
      {
       data = new byte[]{0x08,0x42,0x00,0x00,0x00,0x00};
       crcData = Utilities.CRC(data,data.Length);
       outData = new byte[]{0x02,0x08,0x42,0x00,0x00,0x00,0x00,0x00,crcData[0],crcData[1],0x03};
       break;
      }
      case E_OK:
      {
       data = new byte[]{0x08,0x42,0x00,0x00,0x00,0x00};
       crcData = Utilities.CRC(data,data.Length);
       outData = new byte[]{0x02,0x08,0x42,0x00,0x00,0x00,0x00,0x00,crcData[0],crcData[1],0x03};
       break;
      }
       #endregion
     }

     break;
    }
     
    case "DOOR_STATUS":  //维护门状态
    {
     switch(parameter)
     {
       #region
      case TCU_DOOR_OPENED:
      {
       data = new byte[]{0x08,0x43,0x00,0x00,0x00,0x00};
       crcData = Utilities.CRC(data,data.Length);
       outData = new byte[]{0x02,0x08,0x43,0x00,0x00,0x00,0x00,0x00,crcData[0],crcData[1],0x03};
       break;
      }

      case TCU_DOOR_CLOSED:
      {
       data = new byte[]{0x08,0x43,0x00,0x00,0x00,0x00};
       crcData = Utilities.CRC(data,data.Length);
       outData = new byte[]{0x02,0x08,0x43,0x00,0x00,0x00,0x00,0x00,crcData[0],crcData[1],0x03};
       break;
      }
       #endregion
     }

     break;
    }
   }

   mc.Output = outData;

  }

  
   /// <summary>
  /// receive data from com
  /// </summary>
  private void mc_OnComm()
  {
   byte [] t_byte = (byte[])mc.Input;  //接收数据清空缓冲区

   for(int i = 0;i<t_byte.Length;i++)
   {
    Monitor.Enter(m_bytelist);
    m_bytelist.Add(t_byte[i]);
    Monitor.Exit(m_bytelist);
   }

   lock(state2)
   {
    if(t_byte.Length > 0)
    {
     state2 = R_RECEIVING; //有数据到达把状态改成正在接收
    }
   }
  }
 }
}

wu_jing_sheng0
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
状态机学习资料
09-22
总结整理的状态机学习资料，几个经典文档、C、C++实例demo代码。看了这个基本上能够搞明白了。后期我会整理个关于状态机的博客。
FPGA串口发送学习
weixin_44558238的博客
09-20 1397
因为串口通信协议只能完成8位比特的发送（8bit=1byte），因此发送5个字节的数据需要将5个字节的数据拆分成一个字节一个字节来依次发送。状态1：该模块接收到发送数据请求信号（Trans_Go）,开始发送数据的第一个字节，第一个字节发送完成后，转移到状态2。状态5：发送数据[39:32]，发送完数据的最后一个字节后，回到零状态，等待数据请求信号（Trans_Go）的来临。状态1：空闲状态，没有发送数据，当数据请求信号Trans_Go来临时，转为状态1。板级测试文件，实现1分钟发送一个数据。
TCP状态机与定时器
suyang001的专栏
07-28 478
本文中部分内容引用自以下文章列表： https://blog.csdn.net/wdscq1234/article/details/52505191https://blog.csdn.net/whgtheone/article/details/80970292https://blog.csdn.net/u013929635/article/details/82623611https://blog.csdn.net/xiaofei0859/article/details/52794576https://ww
状态机（一）
来啊 快活啊
07-18 2478
状态机概念术语State Machine：状态机，驱动带有region、transition和event信息的状态集合。 State：一个状态模拟一个具体的情况，在这个情况发生的期间，会保持一些不变的条件。State是状态机中主要的实体，事件驱动状态的改变。 Extended State：扩展状态是保存在状态机中的一个特别的变量集合，用来减少必要的状态枚举的数量。 Transition：Tra
状态机编程介绍
12-28
状态机的概念；状态机的要素；状态迁移图（STD）；状态迁移表；用状态机思路实现一个时钟程序
有限状态机
03-04
在实际的应用中根据状态机的输出是否与输入条件相关，可将状态机分为两大类，即摩尔(Moore)型状态机和米勒(Mealy)型状态机。图1　Mealy型状态转移图状态机的描述方法多种多样，将整个状态机写到１个always模块里，在...
状态机举例
12-09
你可以指定状态寄存器和状态机的状态。以下是一个有四种状态的普通状态机。 // These are the symbolic names for states// 定义状态的符号名称parameter [1:0] S0 = 2'h0, S1 = 2'h1, S2 = 2'h2, S3 = 2'h3;// ...
C语言状态机
08-08
C语言状态机，解压打开即可解压打开即可解压打开即可解压打开即可
层次状态机
热门推荐
自由的天空
11-30 1万+
出处：http://xlambda.com/blog/2014/11/04/hierarchical-state-machine/ 计算机程序是写给人看的，只是顺便能运行。 —— 《计算机程序的构造和解释》 [1] FSM 在计算机领域，FSM(有限状态机)是一个在自动机理论和程序设计实践中很常见的术语，简单来说，有限状态机表示的是系统根不同输入/不
Verilog有限状态机三段式描述方法【原创*改进】
weixin_34345560的博客
06-17 6679
1、好的状态机标准 好的状态机的标准很多，最重要的几个方面如下： 第一，状态机要安全，是指FSM不会进入死循环，特别是不会进入非预知的状态，而且由于某些扰动进入非设计状态，也能很快的恢复到正常的状态循环中来。这里面有两层含义：其一要求该FSM的综合实现结果无毛刺等异常扰动；其二要求FSM要完备，即使受到异常扰动进入非设计状态，也能很快恢复到正常状态。 第二，状态机的设计要满足设计的面积和速度...
如何处理串口通讯数据重合与分批到达的问题 2
滔滔不绝's Blog
01-19 2231
这次代码做了以下的改进:1.发送数据和接收数据用2个状态机实现;2. 增加了当数据发送以后指定的间隔内连续发送3次,如果没有收到下位机的回复则放弃;3.取消使用定时器Timer类,自己写定时器;using System;using System.Collections;using System.Threading;using System.Xml;using NLog;using
状态机模式接受命令解析指令（modbus、AT指令）
ARM_FLYING的博客
06-20 9101
状态机模式接受命令解析指令（modbus、AT指令） 状态机模式接受命令解析指令（modbus、AT指令） 状态机介绍 串口介绍 接收数据核心模块详解 代码实现 实际应用 状态机介绍 串口介绍 接收数据核心模块详解 代码实现 实际应用 状态机介绍 所谓的状态机，重点在状态两字。一个LED灯有两种状态：亮S0或灭S1；如果是一个按键的话根据不同的定义可能会...
Linux编程之有限状态机FSM的理解与实现
weixin_33755557的博客
06-23 1066
有限状态机（finite state machine）简称FSM，表示有限个状态及在这些状态之间的转移和动作等行为的数学模型，在计算机领域有着广泛的应用。FSM是一种逻辑单元内部的一种高效编程方法，在服务器编程中，服务器可以根据不同状态或者消息类型进行相应的处理逻辑，使得程序逻辑清晰易懂。 那有限状态机通常在什么地方被用到？ 处理程序语言或者自然语言的 tokenizer,自底向上解析语法的par...
状态机的三种骚操作，值得你了解
一名热爱技术的工程师的博客。分享技术干货，记录美好生活。永远相信美好的事情即将发生。
09-18 784
点击上方“小麦大叔”，选择“置顶/星标公众号”福利干货，第一时间送达大家好，我是小麦，这次我们一起来学习C语言实现状态机的三种方法解析。状态机的实现无非就是 3 个要素：状态、事件、响应。...
状态机相关 编程 资料 收集
abc
12-14 237
状态机 QP 写状态机时，还是很烦的，觉得PT在这个方面最直观，但在一些特定领域并不合适。 QP也是大家比较推崇的，但是感觉有点大（至少我觉得），刚好逛github碰到一个叫SM的库， 据说是模仿QP的，看起来感觉不错，就改写了一点，在windows下写了个demo，觉得在arm下也应该是一样的， 原作者地址 https://github.com/leijian001/sm 源码 之前用过不少pt...
variant状态机
最新发布
11-21
Variant状态机是一种特殊类型的状态机，它允许在每个状态转换中选择多个不同的路径。在传统状态机中，每个状态转换只有一个确定的下一个状态，而在Variant状态机中，根据特定的条件或规则，可以有多个可能的下一个...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值