登录
当前位置： 首页 > 编程笔记 >

通过C#实现自动售货机接口

海宁
2023-03-14
本文向大家介绍通过C#实现自动售货机接口，包括了通过C#实现自动售货机接口的使用技巧和注意事项，需要的朋友参考一下

下面分几部分介绍C#实现自动售货机接口的方法，代码写的非常详细，不懂的地方有注释可以参考下。

MachineJP类：

第1部分：串口初始化，串口数据读写

using System;
using System.Collections.Generic;
using System.IO.Ports;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Forms;
using MachineJPDll.Models;
using MachineJPDll.Utils;

namespace MachineJPDll
{
  /// <summary>
  /// 售货机接口(接口)
  /// </summary>
  public partial class MachineJP
  {
    #region 变量
    /// <summary>
    /// 串口资源
    /// </summary>
    private SerialPort m_SerialPort = null;
    /// <summary>
    /// 待发送给串口的命令列表
    /// </summary>
    private List<Cmd> m_CommandList = new List<Cmd>();
    /// <summary>
    /// 等待ACK_RPT或NAK_RPT的PC端向VMC端发送的消息列表
    /// </summary>
    private List<MT> m_WaitResultMTList = new List<MT>();
    /// <summary>
    /// 从串口接收的数据集合(数据已通过验证)
    /// </summary>
    private ReceiveDataCollection m_ReceiveDataCollection = new ReceiveDataCollection();
    #endregion

    #region 构造函数与析构函数
    /// <summary>
    /// 售货机接口(接口)
    /// </summary>
    public MachineJP()
    {

    }

    ~MachineJP()
    {
      if (m_SerialPort != null)
      {
        m_SerialPort.Close();
        m_SerialPort.Dispose();
        m_SerialPort = null;
      }
    }
    #endregion

    #region 读取串口数据
    /// <summary>
    /// 读取串口数据
    /// </summary>
    /// <returns>从串口读取的数据</returns>
    private byte[] ReadPort()
    {
      //读取串口数据
      DateTime dt = DateTime.Now;
      while (m_SerialPort.BytesToRead < 2)
      {
        Thread.Sleep(1);

        if (DateTime.Now.Subtract(dt).TotalMilliseconds > 1500) //超时
        {
          return new byte[0];
        }
      }
      List<byte> recList = new List<byte>();
      byte[] recData = new byte[m_SerialPort.BytesToRead];
      m_SerialPort.Read(recData, 0, recData.Length);
      recList.AddRange(recData);
      int length = recData[1] + 2; //报文数据总长度
      while (recList.Count < length)
      {
        if (m_SerialPort.BytesToRead > 0)
        {
          recData = new byte[m_SerialPort.BytesToRead];
          m_SerialPort.Read(recData, 0, recData.Length);
          recList.AddRange(recData);
        }
        Thread.Sleep(1);
      }

      return recList.ToArray();
    }
    #endregion

    #region 向串口发送数据
    /// <summary>
    /// 向串口发送数据
    /// </summary>
    /// <param name="cmd">待发送的命令</param>
    /// <param name="SN">序列号</param>
    private void WritePort(Cmd cmd, byte SN)
    {
      //发送数据
      List<byte> sendData = cmd.Data;
      sendData[1] = (byte)sendData.Count;
      sendData[2] = SN;
      byte[] checkCode = CommonUtil.CalCheckCode(sendData, sendData.Count);
      sendData.AddRange(checkCode);
      if (cmd.Mt != null)
      {
        m_WaitResultMTList.Add(cmd.Mt);
      }
      m_SerialPort.Write(sendData.ToArray(), 0, sendData.Count);
      LogHelper.Log(LogMsgType.Info, true, sendData.ToArray());
    }
    #endregion

    #region 发送ACK消息
    /// <summary>
    /// 发送ACK消息
    /// </summary>
    /// <param name="SN">序列号</param>
    private void SendACK(byte SN)
    {
      List<byte> sendData = new List<byte>() { 0xE5, 0x00, 0x00, 0x40, 0x80 };
      WritePort(new Cmd(sendData), SN);
    }
    #endregion

    #region Init 初始化
    /// <summary>
    /// 初始化
    /// </summary>
    /// <param name="com">串口号(例：COM1)</param>
    public void Init(string com)
    {
      if (m_SerialPort == null)
      {
        m_SerialPort = new SerialPort(com, 9600, Parity.None, 8, StopBits.One);
        m_SerialPort.ReadBufferSize = 1024;
        m_SerialPort.WriteBufferSize = 1024;
        m_SerialPort.DataReceived += new SerialDataReceivedEventHandler(serialPort_DataReceived);
      }

      if (!m_SerialPort.IsOpen)
      {
        m_SerialPort.Open();
      }

      GET_SETUP();
      CONTROL_IND(0x13, new byte[] { 0x00 }); //初始化完成标志
      GET_STATUS();

      SetDecimalPlaces(2); //设置小数点位数
    }
    #endregion

    #region Close 关闭连接
    /// <summary>
    /// 关闭连接
    /// </summary>
    public void Close()
    {
      m_SerialPort.Close();
    }
    #endregion

    #region 接收串口数据
    /// <summary>
    /// 接收串口数据
    /// </summary>
    /// <param name="type">消息类型</param>
    /// <param name="subtype">消息子类型</param>
    public byte[] Receive(byte type, byte subtype)
    {
      return m_ReceiveDataCollection.Get(type, subtype);
    }

    /// <summary>
    /// 接收串口数据
    /// </summary>
    /// <param name="type">消息类型</param>
    /// <param name="subtype">消息子类型</param>
    public byte[] WaitReceive(byte type, byte subtype)
    {
      DateTime time = DateTime.Now;
      while (true)
      {
        byte[] receiveData = m_ReceiveDataCollection.Get(type, subtype);
        if (receiveData != null) return receiveData;

        if (DateTime.Now.Subtract(time).TotalMinutes > 3) return null;

        Thread.Sleep(50);
      }
    }

    /// <summary>
    /// 接收串口数据
    /// </summary>
    /// <param name="type">消息类型</param>
    public byte[] WaitReceive(byte type)
    {
      DateTime time = DateTime.Now;
      while (true)
      {
        byte[] receiveData = m_ReceiveDataCollection.Get(type);
        if (receiveData != null) return receiveData;

        if (DateTime.Now.Subtract(time).TotalMinutes > 3) return null;

        Thread.Sleep(50);
      }
    }
    #endregion

    #region 判断消息是否发送成功
    /// <summary>
    /// 判断消息是否发送成功
    /// </summary>
    public bool SendSuccess(byte type, byte subtype)
    {
      DateTime time = DateTime.Now;
      while (true)
      {
        if (DateTime.Now.Subtract(time).TotalMinutes > 3)
        {
          return false;
        }
        byte[] ack = m_ReceiveDataCollection.Get(type, subtype);
        byte[] nak = m_ReceiveDataCollection.Get(type, subtype);
        if (ack != null) return true;
        if (nak != null) return false;

        Thread.Sleep(1);
      }
    }
    #endregion

  }
}

第2部分：接收串口数据，并响应货机，向货机发送数据 

 

using System;
using System.Collections.Generic;
using System.IO.Ports;
using System.Linq;
using System.Text;
using MachineJPDll.Models;
using MachineJPDll.Utils;

/*
 * VMC->PC数据的接收,货机事件的分发
 */

namespace MachineJPDll
{
  partial class MachineJP
  {
    #region serialPort_DataReceived
    /// <summary>
    /// 数据接收事件的方法
    /// </summary>
    public void serialPort_DataReceived(object obj, SerialDataReceivedEventArgs args)
    {
      byte[] receiveData = ReadPort();

      if (CommonUtil.ValidReceiveData(receiveData)) //只处理验证正确的数据，不正确的数据抛弃不处理
      {
        LogHelper.Log(LogMsgType.Info, false, receiveData);
        byte SN = CommonUtil.GetSN(receiveData);
        MT mt = new MT(receiveData);

        #region 轮询(POLL)
        if (mt.Type == 0x03)
        {
          if (m_CommandList.Count > 0)
          {
            WritePort(m_CommandList[0], SN);
            m_CommandList.RemoveAt(0);
          }
          else
          {
            //发送ACK消息
            SendACK(SN);
          }
        }
        #endregion

        #region 发送ACK消息
        if (CommonUtil.NeedACK(receiveData))
        {
          SendACK(SN); //发送ACK消息
        }
        #endregion

        #region VMC系统参数
        if (mt.Type == 0x05)
        {
          m_ReceiveDataCollection.Add(mt.Type, mt.Subtype, receiveData);
        }
        #endregion

        #region ACK_RPT或NAK_RPT
        if (mt.Type == 0x01 //ACK_RPT
          || mt.Type == 0x02) //NAK_RPT
        {
          if (m_WaitResultMTList.Count > 0)
          {
            m_ReceiveDataCollection.Add(m_WaitResultMTList[0].Type, m_WaitResultMTList[0].Subtype, receiveData);
            m_WaitResultMTList.RemoveAt(0);
          }
        }
        #endregion

        #region INFO_RPT 数据报告
        if (mt.Type == 0x11)
        {
          #region 纸币器信息
          if (mt.Subtype == 16)
          {
            m_ReceiveDataCollection.Add(mt.Type, mt.Subtype, receiveData);
          }
          #endregion

          #region 硬币器信息
          if (mt.Subtype == 17)
          {
            m_ReceiveDataCollection.Add(mt.Type, mt.Subtype, receiveData);
          }
          #endregion

          #region 用户投币余额
          if (mt.Subtype == 3)
          {
            m_ReceiveDataCollection.Add(mt.Type, mt.Subtype, receiveData);
          }
          #endregion
        }
        #endregion

        #region VENDOUT_RPT 出货报告
        if (mt.Type == 0x08)
        {
          m_ReceiveDataCollection.Add(mt.Type, mt.Subtype, receiveData);
        }
        #endregion

        #region STATUS_RPT VMC整机状态报告
        if (mt.Type == 0x0D)
        {
          m_ReceiveDataCollection.Add(mt.Type, mt.Subtype, receiveData);
        }
        #endregion

        #region SALEPRICE_IND 设置当前商品售价
        if (mt.Type == 0x8E)
        {
          m_ReceiveDataCollection.Add(mt.Type, mt.Subtype, receiveData);
        }
        #endregion

        #region PAYIN_RPT VMC发送现金投币报告给PC
        if (mt.Type == 0x06)
        {
          m_ReceiveDataCollection.Add(mt.Type, mt.Subtype, receiveData);
        }
        #endregion

        #region PAYOUT_RPT 出币报告
        if (mt.Type == 0x07)
        {
          m_ReceiveDataCollection.Add(mt.Type, mt.Subtype, receiveData);
        }
        #endregion

        #region COST_RPT VMC扣款报告
        if (mt.Type == 0x10)
        {
          m_ReceiveDataCollection.Add(mt.Type, mt.Subtype, receiveData);
        }
        #endregion

        #region ACTION_RPT 售货机行为报告
        if (mt.Type == 0x0B)
        {
          m_ReceiveDataCollection.Add(mt.Type, mt.Subtype, receiveData);
        }
        #endregion

        #region HUODAO_RPT VMC货道报告
        if (mt.Type == 0x0E)
        {
          m_ReceiveDataCollection.Add(mt.Type, mt.Subtype, receiveData);
        }
        #endregion
      }
      else //接收到的数据没有验证通过
      {
        LogHelper.LogException(LogMsgType.Error, false, "数据异常", receiveData);
      }
    }
    #endregion

  }
}

 第3部分：货机状态、投币、出货等接口

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using MachineJPDll.Enums;
using MachineJPDll.Models;
using MachineJPDll.Utils;

/*
 * PC->VMC数据的发送(并非直接发送,只是添加到发送列表)
 */

namespace MachineJPDll
{
  partial class MachineJP
  {
    #region GET_SETUP
    /// <summary>
    /// PC通知VMC发送VMC_SETUP
    /// </summary>
    public VmcSetup GET_SETUP()
    {
      List<byte> sendData = new List<byte>() { 0xE5, 0x00, 0x00, 0x40, 0x90 };
      m_CommandList.Add(new Cmd(sendData));

      byte[] receiveData = WaitReceive(0x05);
      if (receiveData != null)
      {
        return new VmcSetup(receiveData);
      }
      return null;
    }
    #endregion

    #region CONTROL_IND PC控制售货机完成对应的动作
    /// <summary>
    /// PC控制VMC
    /// </summary>
    public bool CONTROL_IND(byte subtype, byte[] value)
    {
      List<byte> sendData = new List<byte>() { 0xE5, 0x00, 0x00, 0x41, 0x85 };
      sendData.Add(subtype);
      if (value != null && value.Length > 0)
      {
        sendData.AddRange(value);
      }
      m_CommandList.Add(new Cmd(sendData, new MT(sendData)));

      return SendSuccess(0x85, subtype);
    }
    #endregion

    #region 设置小数点位数
    /// <summary>
    /// 设置小数点位数
    /// 用于PC 通知VMC，双方的金额数据比例系数关系，PC 每次启动时，都会给
    /// VMC 下发一次type=18 的消息，VMC 需要自己永久保存该数据，直到被PC 再
    /// 次更新。
    /// 取值范围：0、1、2 分别表示以 元、 角 、分 为单位
    /// </summary>
    public bool SetDecimalPlaces(int data)
    {
      return CONTROL_IND(18, new byte[] { (byte)data });
    }
    #endregion

    #region GET_STATUS PC通知VMC发送STATUS_RPT
    /// <summary>
    /// PC通知VMC发送STATUS_RPT
    /// </summary>
    public StatusRpt GET_STATUS()
    {
      List<byte> sendData = new List<byte>() { 0xE5, 0x00, 0x00, 0x40, 0x86 };
      m_CommandList.Add(new Cmd(sendData));

      byte[] receiveData = WaitReceive(0x0D);
      if (receiveData != null)
      {
        return new StatusRpt(receiveData);
      }
      return null;
    }
    #endregion

    #region GET_INFO PC通知VMC发送INFO_RPT
    /// <summary>
    /// PC通知VMC发送INFO_RPT
    /// </summary>
    public byte[] GET_INFO(byte subtype)
    {
      List<byte> sendData = new List<byte>() { 0xE5, 0x00, 0x00, 0x40, 0x8C };
      sendData.Add(subtype);
      m_CommandList.Add(new Cmd(sendData));

      return WaitReceive(0x11);
    }
    #endregion

    #region VENDOUT_IND 出货
    /// <summary>
    /// PC出货指示
    /// </summary>
    /// <param name="device">售货机的箱体号 例如柜1 为 0x01 以此类推</param>
    /// <param name="method">method =1：VMC 通过商品ID 指示出货，如果商品ID 不存在，回复NAK_RPT method =2：VMC 通过货道ID 指示VMC 出货，如果货道ID 不存在，回复NAK_RPT</param>
    /// <param name="sp_id_hd_id">sp_id：通过商品ID 指示VMC 出货 hd_id：通过货道ID 指示VMC 出货</param>
    /// <param name="type">如果type=0，cost 代表本次出货扣款金额 如果TYPE 不为0，则COST 必须为0</param>
    /// <param name="cost">cost 代表本次出货扣款金额</param>
    public VendoutRpt VENDOUT_IND(byte device, byte method, byte sp_id_hd_id, byte type, int cost)
    {
      List<byte> sendData = new List<byte>() { 0xE5, 0x00, 0x00, 0x41, 0x83 };
      sendData.AddRange(new byte[] { device, method, sp_id_hd_id, type });
      sendData.AddRange(CommonUtil.Int2ByteArray(cost, 2));
      m_CommandList.Add(new Cmd(sendData, new MT(sendData)));

      if (SendSuccess(0x83, 0x00))
      {
        byte[] receiveData = WaitReceive(0x08);
        if (receiveData != null)
        {
          return new VendoutRpt(receiveData);
        }
      }
      return null;
    }
    #endregion

    #region HUODAO_SET_IND 设置货道商品数量
    /// <summary>
    /// PC通知VMC，当前货道对应商品的数量等信息
    /// </summary>
    /// <param name="device">表示箱柜号</param>
    /// <param name="huodao">zyxxxxxx “z”固定填0 “y”固定填0 “xxxxxx”，表示商品余量，如果商品余量大于63，则统一为63</param>
    public bool HUODAO_SET_IND(byte device, List<int> huodao)
    {
      List<byte> sendData = new List<byte>() { 0xE5, 0x00, 0x00, 0x41, 0x8F };
      sendData.Add(device);
      for (int i = 0; i < huodao.Count; i++)
      {
        if (huodao[i] > 63)
        {
          huodao[i] = 63;
        }
      }
      sendData.AddRange(huodao.ConvertAll<byte>(a => (byte)a));
      m_CommandList.Add(new Cmd(sendData, new MT(sendData)));

      return SendSuccess(0x8F, 0x00);
    }
    #endregion

    #region SALEPRICE_IND 设置当前商品售价
    /// <summary>
    /// PC通知VMC，当前商品售价
    /// </summary>
    /// <param name="device">表示箱柜号</param>
    /// <param name="type">表示设置单价的方式；Type = 0：为按商品ID 发送单价，可以变长发送，商品种类最大不超过80 个；Type = 1: 为按货道号发送，固定发送80 个货道的单价信息</param>
    /// <param name="sp_price">商品售价</param>
    public bool SALEPRICE_IND(byte device, byte type, List<int> sp_price)
    {
      List<byte> sendData = new List<byte>() { 0xE5, 0x00, 0x00, 0x41, 0x8E };
      sendData.Add(device);
      sendData.Add(type);
      sendData.AddRange(sp_price.ConvertAll<byte>(a => (byte)a));
      m_CommandList.Add(new Cmd(sendData, new MT(sendData)));

      return SendSuccess(0x8E, 0x00);
    }
    #endregion

    #region PAYOUT_IND PC指示VMC出币
    /// <summary>
    /// PC指示VMC出币
    /// </summary>
    /// <param name="device">出币设备</param>
    /// <param name="value">本次出币总金额</param>
    /// <param name="type">出币类型 无需理解type 的含义，只需要在出币完成后的PAYOUT_RPT 中将该type 值回传给PC 即可</param>
    public PayoutRpt PAYOUT_IND(PayoutType device, int value, byte type)
    {
      List<byte> sendData = new List<byte>() { 0xE5, 0x00, 0x00, 0x41, 0x89 };
      sendData.Add((byte)device);
      sendData.AddRange(CommonUtil.Int2ByteArray(value, 2));
      sendData.Add(type);
      m_CommandList.Add(new Cmd(sendData, new MT(sendData)));

      if (SendSuccess(0x89, 0x00))
      {
        byte[] receiveData = WaitReceive(0x07);
        if (receiveData != null)
        {
          return new PayoutRpt(receiveData);
        }
      }
      return null;
    }
    #endregion

    #region COST_IND PC扣款指示
    /// <summary>
    /// PC扣款指示
    /// </summary>
    /// <param name="device">device=0，从用户投币总额中扣款；优先从用户非暂存金额中扣除（纸币尽量滞后压钞），参见《现金扣款顺序》</param>
    /// <param name="value">扣款金额</param>
    /// <param name="type">VMC 不用理解type 的含义，只需上报对应的COST_RPT 时回传即可</param>
    public CostRpt COST_IND(byte device, int value, byte type)
    {
      List<byte> sendData = new List<byte>() { 0xE5, 0x00, 0x00, 0x41, 0x8B };
      sendData.Add(device);
      sendData.AddRange(CommonUtil.Int2ByteArray(value, 2));
      sendData.Add(type);
      m_CommandList.Add(new Cmd(sendData, new MT(sendData)));

      if (SendSuccess(0x8B, 0x00))
      {
        byte[] receiveData = WaitReceive(0x10);
        if (receiveData != null)
        {
          return new CostRpt(receiveData);
        }
      }
      return null;
    }
    #endregion

    #region GET_HUODAO PC通知VMC上报HUODAO_RPT
    /// <summary>
    /// PC通知VMC上报HUODAO_RPT
    /// </summary>
    /// <param name="device">箱柜号</param>
    public HuoDaoRpt GET_HUODAO(byte device)
    {
      List<byte> sendData = new List<byte>() { 0xE5, 0x00, 0x00, 0x40, 0x8A };
      sendData.Add(device);
      m_CommandList.Add(new Cmd(sendData));

      byte[] receiveData = WaitReceive(0x0E);
      if (receiveData != null)
      {
        return new HuoDaoRpt(receiveData);
      }
      return null;
    }
    #endregion

    #region SET_HUODAO PC发送配置货道信息
    /// <summary>
    /// PC发送配置货道信息
    /// </summary>
    /// <param name="Cabinet">箱柜号</param>
    /// <param name="hd_no">货道逻辑编号，十进制</param>
    /// <param name="Hd_id">商品ID号</param>
    /// <param name="Hd_count">货道剩余量</param>
    /// <param name="Hd_price">货道单价</param>
    /// <param name="Reserved">保留字段VMC忽略此字段，PC最好将此字段置为0</param>
    public bool SET_HUODAO(byte Cabinet, int hd_no, int Hd_id, int Hd_count, int Hd_price, int Reserved = 0)
    {
      List<byte> sendData = new List<byte>() { 0xE5, 0x00, 0x00, 0x41, 0x93 };
      sendData.Add(Cabinet);
      sendData.Add((byte)hd_no);
      sendData.Add((byte)Hd_id);
      sendData.Add((byte)Hd_count);
      sendData.AddRange(CommonUtil.Int2ByteArray(Hd_price, 2));
      sendData.AddRange(CommonUtil.Int2ByteArray(Reserved, 2));
      m_CommandList.Add(new Cmd(sendData, new MT(sendData)));

      return SendSuccess(0x93, 0x00);
    }
    #endregion

    #region 开启纸硬币器
    /// <summary>
    /// 现金收银模组（纸币器、硬币器）开关
    /// </summary>
    /// <param name="open">true:开,false:关</param>
    public bool CtrlCoinPaper(bool open)
    {
      if (open)
      {
        return CONTROL_IND(2, new byte[] { 1 });
      }
      else
      {
        return CONTROL_IND(2, new byte[] { 0 });
      }
    }
    #endregion

    #region 找零
    /// <summary>
    /// 找零
    /// 与手工拨弄物理找零开关相同
    /// </summary>
    public bool MakeChange()
    {
      return CONTROL_IND(6, new byte[] { 0 });
    }
    #endregion

    #region 获取硬币器信息
    /// <summary>
    /// 获取硬币器信息
    /// </summary>
    public InfoRpt_17 GetCoinInfo()
    {
      return new InfoRpt_17(GET_INFO(17));
    }
    #endregion

    #region 获取纸币器信息
    /// <summary>
    /// 获取纸币器信息
    /// </summary>
    public InfoRpt_16 GetPaperInfo()
    {
      return new InfoRpt_16(GET_INFO(16));
    }
    #endregion

    #region 获取现金投币报告
    /// <summary>
    /// 获取现金投币报告
    /// </summary>
    public PayinRpt GetPayinRpt()
    {
      byte[] receiveData = Receive(0x06, 0x00);
      if (receiveData != null)
      {
        return new PayinRpt(receiveData);
      }
      return null;
    }
    #endregion

    #region 获取用户投币余额
    /// <summary>
    /// 获取用户投币余额
    /// </summary>
    public InfoRpt_3 GetRemaiderAmount()
    {
      byte[] receiveData = WaitReceive(0x11, 0x003);
      if (receiveData != null)
      {
        return new InfoRpt_3(receiveData);
      }
      return null;
    }
    #endregion

  }
}

ReceiveDataCollection类和ReceiveData类： 

 

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace MachineJPDll.Models
{
  /// <summary>
  /// 从串口接收到的数据(数据已通过验证)
  /// </summary>
  public class ReceiveData
  {
    /// <summary>
    /// 从串口接收到的数据(数据已通过验证)
    /// </summary>
    public byte[] Data { get; set; }
    /// <summary>
    /// 添加到集合ReceiveDataCollection的时间
    /// </summary>
    public DateTime AddTime { get; set; }
    /// <summary>
    /// 消息类型
    /// </summary>
    public byte Type { get; set; }
    /// <summary>
    /// 消息子类型
    /// </summary>
    public byte Subtype { get; set; }

    /// <summary>
    /// 从串口接收到的数据(数据已通过验证)
    /// </summary>
    /// <param name="type">消息类型</param>
    /// <param name="subtype">消息子类型</param>
    /// <param name="data">从串口接收到的数据(数据已通过验证)</param>
    /// <param name="addTime">添加到集合ReceiveDataCollection的时间</param>
    public ReceiveData(byte type, byte subtype, byte[] data, DateTime addTime)
    {
      this.Type = type;
      this.Subtype = subtype;
      this.Data = data;
      this.AddTime = addTime;
    }
  }
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace MachineJPDll.Models
{
  /// <summary>
  /// 从串口接收到的数据集合(数据已通过验证)
  /// </summary>
  public class ReceiveDataCollection
  {
    /// <summary>
    /// 从串口接收到的数据集合(数据已通过验证)
    /// </summary>
    private List<ReceiveData> m_ReceiveDataList = new List<ReceiveData>();
    /// <summary>
    /// 数据过期时间
    /// </summary>
    private int m_Timeout = 3;
    private static object _lock = new object();

    /// <summary>
    /// 添加到集合
    /// </summary>
    /// <param name="type">消息类型</param>
    /// <param name="subtype">消息子类型</param>
    /// <param name="data">从串口接收到的数据(数据已通过验证)</param>
    public void Add(byte type, byte subtype, byte[] data)
    {
      lock (_lock)
      {
        ReceiveData receiveData = new ReceiveData(type, subtype, data, DateTime.Now);
        m_ReceiveDataList.Add(receiveData);
        for (int i = m_ReceiveDataList.Count - 1; i >= 0; i--)
        {
          if (DateTime.Now.Subtract(m_ReceiveDataList[i].AddTime).TotalMinutes > m_Timeout)
          {
            m_ReceiveDataList.RemoveAt(i);
          }
        }
      }
    }

    /// <summary>
    /// 从集合中获取串口接收到的数据(数据已通过验证)
    /// </summary>
    /// <param name="type">消息类型</param>
    /// <param name="subtype">消息子类型</param>
    /// <returns>从串口接收到的数据(数据已通过验证)</returns>
    public byte[] Get(byte type, byte subtype)
    {
      lock (_lock)
      {
        ReceiveData receiveData = null;
        for (int i = 0; i < m_ReceiveDataList.Count; i++)
        {
          if (m_ReceiveDataList[i].Type == type && m_ReceiveDataList[i].Subtype == subtype)
          {
            receiveData = m_ReceiveDataList[i];
            m_ReceiveDataList.RemoveAt(i);
            return receiveData.Data;
          }
        }
        return null;
      }
    }

    /// <summary>
    /// 从集合中获取串口接收到的数据(数据已通过验证)
    /// </summary>
    /// <param name="type">消息类型</param>
    /// <returns>从串口接收到的数据(数据已通过验证)</returns>
    public byte[] Get(byte type)
    {
      lock (_lock)
      {
        ReceiveData receiveData = null;
        for (int i = 0; i < m_ReceiveDataList.Count; i++)
        {
          if (m_ReceiveDataList[i].Type == type)
          {
            receiveData = m_ReceiveDataList[i];
            m_ReceiveDataList.RemoveAt(i);
            return receiveData.Data;
          }
        }
        return null;
      }
    }
  }
}

Models：

StatusRpt类：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using MachineJPDll;
using MachineJPDll.Enums;
using MachineJPDll.Utils;

namespace MachineJPDll.Models
{
  /// <summary>
  /// VMC状态报告
  /// </summary>
  public class StatusRpt
  {
    /// <summary>
    /// 从串口读取的通过验证的数据
    /// </summary>
    private byte[] m_data;

    /// <summary>
    /// VMC状态报告
    /// </summary>
    /// <param name="data">从串口读取的通过验证的数据</param>
    public StatusRpt(byte[] data)
    {
      m_data = data;
    }

    public override string ToString()
    {
      StringBuilder sb = new StringBuilder();
      sb.AppendFormat("出货检测设备状态：{0}\r\n", check_st.ToString());
      sb.AppendFormat("纸币器状态：{0}\r\n", bv_st.ToString());
      sb.AppendFormat("硬币器状态：{0}\r\n", cc_st.ToString());
      sb.AppendFormat("VMC状态：{0}\r\n", vmc_st.ToString());
      sb.AppendFormat("展示位状态：{0} {1} {2} {3}\r\n", pos_st[0].ToString(), pos_st[1].ToString(), pos_st[2].ToString(), pos_st[3].ToString());
      sb.AppendFormat("机器中可用的找零量总金额(包括硬币和纸币)：{0}\r\n", change.ToString());
      sb.AppendFormat("货仓1货仓2货仓3货仓4温度：{0} {1} {2} {3}\r\n", tem1.ToString(), tem2.ToString(), tem3.ToString(), tem4.ToString());
      sb.AppendFormat("货仓状态设置值：{0} {1} {2} {3}\r\n", tem_st[0].ToString(), tem_st[1].ToString(), tem_st[2].ToString(), tem_st[3].ToString());
      if (this.自动退币 == 255)
      {
        sb.AppendFormat("自动退币时间：永不自动退币\r\n");
      }
      else
      {
        sb.AppendFormat("自动退币时间：{0}\r\n", 自动退币.ToString());
      }
      sb.AppendFormat("找零余量(1#--6#)：{0} {1} {2} {3} {4} {5}\r\n", this.找零余量1, this.找零余量2, this.找零余量3, this.找零余量4, this.找零余量5, this.找零余量6);

      return sb.ToString();
    }

    /// <summary>
    /// 出货检测设备状态
    /// </summary>
    public CheckSt check_st
    {
      get
      {
        byte val = m_data[5];
        return (CheckSt)CommonUtil.GetFromByte(val, 0, 2);
      }
    }

    /// <summary>
    /// 纸币器状态
    /// </summary>
    public DeviceSt bv_st
    {
      get
      {
        byte val = m_data[5];
        return (DeviceSt)CommonUtil.GetFromByte(val, 2, 2);
      }
    }

    /// <summary>
    /// 硬币器状态
    /// </summary>
    public DeviceSt cc_st
    {
      get
      {
        byte val = m_data[5];
        return (DeviceSt)CommonUtil.GetFromByte(val, 4, 2);
      }
    }

    /// <summary>
    /// VMC状态
    /// </summary>
    public VmcSt vmc_st
    {
      get
      {
        byte val = m_data[5];
        return (VmcSt)CommonUtil.GetFromByte(val, 6, 2);
      }
    }

    /// <summary>
    /// 展示位状态
    /// </summary>
    public List<DeviceSt> pos_st
    {
      get
      {
        List<DeviceSt> deviceStList = new List<DeviceSt>();

        byte val = m_data[6];
        for (int i = 0; i < 4; i++)
        {
          DeviceSt deviceSt = (DeviceSt)CommonUtil.GetFromByte(val, i * 2, 2);
          deviceStList.Add(deviceSt);
        }

        return deviceStList;
      }
    }

    /// <summary>
    /// 机器中，可用的找零量总金额（包括硬币和纸币）
    /// </summary>
    public int change
    {
      get
      {
        return CommonUtil.ByteArray2Int(m_data, 7, 2);
      }
    }

    /// <summary>
    /// 货仓1 温度，8 位有符号数，该温度通过货仓内传感器获取，单位：℃
    /// </summary>
    public TemSub tem1
    {
      get
      {
        return new TemSub(m_data[9]);
      }
    }

    /// <summary>
    /// 货仓2 温度，8 位有符号数，该温度通过货仓内传感器获取，单位：℃
    /// </summary>
    public TemSub tem2
    {
      get
      {
        return new TemSub(m_data[10]);
      }
    }

    /// <summary>
    /// 货仓3 温度，8 位有符号数，该温度通过货仓内传感器获取，单位：℃
    /// </summary>
    public TemSub tem3
    {
      get
      {
        return new TemSub(m_data[11]);
      }
    }

    /// <summary>
    /// 货仓4 温度，8 位有符号数，该温度通过货仓内传感器获取，单位：℃
    /// </summary>
    public TemSub tem4
    {
      get
      {
        return new TemSub(m_data[12]);
      }
    }

    /// <summary>
    /// 货仓状态设置值，共支持4 个货仓
    /// </summary>
    public List<TemSt> tem_st
    {
      get
      {
        List<TemSt> temStList = new List<TemSt>();
        for (int i = 0; i < 4; i++)
        {
          TemSt temSt = (TemSt)CommonUtil.GetFromByte(m_data[13], i * 2, 2);
          temStList.Add(temSt);
        }
        return temStList;
      }
    }

    /// <summary>
    /// 自动退币时间。
    /// 0：表示商品出货后，立即自动退币
    /// 255：表示永不自动退币
    /// 1-254：表示商品出货后，自动退币时间（单位：秒）
    /// </summary>
    public int 自动退币
    {
      get
      {
        return m_data[14];
      }
    }

    /// <summary>
    /// 找零余量“找零量1#”…“找零量6#”，分别对应硬币器信息INFO_RPT.type=17 的“找零
    /// 1#”…“找零6#”中每种钱币的找零数量；
    /// * 找零量最大为255，超过255 时上报为255；
    /// * 找零量单位为“个”，代表可找零硬币的个数。
    /// </summary>
    public int 找零余量1
    {
      get
      {
        return m_data[15];
      }
    }

    /// <summary>
    /// 找零余量“找零量1#”…“找零量6#”，分别对应硬币器信息INFO_RPT.type=17 的“找零
    /// 1#”…“找零6#”中每种钱币的找零数量；
    /// * 找零量最大为255，超过255 时上报为255；
    /// * 找零量单位为“个”，代表可找零硬币的个数。
    /// </summary>
    public int 找零余量2
    {
      get
      {
        return m_data[16];
      }
    }

    /// <summary>
    /// 找零余量“找零量1#”…“找零量6#”，分别对应硬币器信息INFO_RPT.type=17 的“找零
    /// 1#”…“找零6#”中每种钱币的找零数量；
    /// * 找零量最大为255，超过255 时上报为255；
    /// * 找零量单位为“个”，代表可找零硬币的个数。
    /// </summary>
    public int 找零余量3
    {
      get
      {
        return m_data[17];
      }
    }

    /// <summary>
    /// 找零余量“找零量1#”…“找零量6#”，分别对应硬币器信息INFO_RPT.type=17 的“找零
    /// 1#”…“找零6#”中每种钱币的找零数量；
    /// * 找零量最大为255，超过255 时上报为255；
    /// * 找零量单位为“个”，代表可找零硬币的个数。
    /// </summary>
    public int 找零余量4
    {
      get
      {
        return m_data[18];
      }
    }

    /// <summary>
    /// 找零余量“找零量1#”…“找零量6#”，分别对应硬币器信息INFO_RPT.type=17 的“找零
    /// 1#”…“找零6#”中每种钱币的找零数量；
    /// * 找零量最大为255，超过255 时上报为255；
    /// * 找零量单位为“个”，代表可找零硬币的个数。
    /// </summary>
    public int 找零余量5
    {
      get
      {
        return m_data[19];
      }
    }

    /// <summary>
    /// 找零余量“找零量1#”…“找零量6#”，分别对应硬币器信息INFO_RPT.type=17 的“找零
    /// 1#”…“找零6#”中每种钱币的找零数量；
    /// * 找零量最大为255，超过255 时上报为255；
    /// * 找零量单位为“个”，代表可找零硬币的个数。
    /// </summary>
    public int 找零余量6
    {
      get
      {
        return m_data[20];
      }
    }

  }
}

以上就是C#实现自动售货机接口的代码，需要的朋友可以来学习。

 类似资料：
  • Python自动化xpath实现自动抢票抢货

    本文向大家介绍Python自动化xpath实现自动抢票抢货，包括了Python自动化xpath实现自动抢票抢货的使用技巧和注意事项，需要的朋友参考一下 小伙伴们，这次推文讲的是‘xpath‘，掌握起来不难的哦。而且，熟悉了这套路，别说pubmed，任何你能在浏览器实现的操作，都基本能通过selenium自动化进行。 总代码： 代码1 for i in range(1,50+1): printg('

  • 通用接口的Spring自动布线通用实现

    我有个小问题。这可能微不足道，但我以前从未面对过。 我有一个通用接口和它的通用实现。我想自动连线，但发生了错误。以下是详细情况: 接口 实施 自动布线尝试 错误 我想让它尽可能简单。我已经检查了网络，但是我只发现了在配置中定义我的确切bean。如果可能的话，我更喜欢避免它。

  • C语言实现程序开机自启动

    本文向大家介绍C语言实现程序开机自启动，包括了C语言实现程序开机自启动的使用技巧和注意事项，需要的朋友参考一下 程序比较简单，用到了C语言获得自身路径和系统路径，修改注册表项等，某些函数不理解可以查看MSDN

  • c# 实现自动扫雷

    本文向大家介绍c# 实现自动扫雷，包括了c# 实现自动扫雷的使用技巧和注意事项，需要的朋友参考一下     年前无意看到一个用Python写的小桌面程序，可以自动玩扫雷的游戏，觉得挺有意思，决定用C#也做一个。【真实情况是：我知道Python最近比较火，非常适合搞爬虫、大数据、机器学习之类的，但现在连桌面程序都用Python做了吗？还给不给.NET程序员活路了？简直不能忍！】    春节期间正好有

  • C#实现开机自动启动设置代码分享

    本文向大家介绍C#实现开机自动启动设置代码分享，包括了C#实现开机自动启动设置代码分享的使用技巧和注意事项，需要的朋友参考一下

  • 售后通知接口

    使用场景 针对兑吧后台，开发者自有加钱购商品的售后处理处理操作之后的结果状态通知（仅支持开发者自有商品）。售后完成之后，兑吧通过该接口将售后的结果通知给开发者，开发者跟进售后通知的结果处理判定是否给用户返还积分 接口说明 请求方式 （get请求） 接口地址由开发者提供，当有售后完成订单时兑吧通过接口请求开发者，开发者通过接口接收请求数据并处理请求。 请求参数 参数 参数类型 是否必须 参数说明 a

相关阅读

C#实现影院售票系统C#自动实现的属性C#通过IComparable实现ListT.sort()排序python实现电脑自动关机C# .net实现货币转换示例

相关文章

软通动力 C++ 已挂序列自动机概述什么是AC自动机？货拉拉java实习京东零售实习offer

相关问答

所有实现都会自动通过吗？这是谁干的？从Java客户机通过使用Spring4实现的WebSockets连接到Stomp通过更改菜单选项实现程序的GUI自动化代表我与Twilio实现通话自动化UIView通过uitextfield键盘自动移动

相关工具

面包虚拟化自动开通平台php 实现数据库连接池、直播平台数据库自动更新及自动赋值工具Android 自动更新Demo单片机实时时钟

相关文档

通过实例学习 C 语言自己动手做聊天机器人机器学习算法 Python 实现如何实现自己的 jQueryPython 自动化测试之实操
快捷导航： 新手教程 算法原理 架构设计 Java进阶 数据库进阶 大厂专栏 面试经验 编程笔记 编程问答 所有专题 文档资料 工具软件 电子书籍 小牛导航
在线工具： 房贷计算器 个税计算器 Linux命令查询 Json格式化 正则表达式 颜色转换 AES加解密 SHA1加密 MD5加密 毒鸡汤 字数统计 随机密码生成 进制转换 Base64编解码 励志句子
Copyright © 2019-2024 小牛知识库@xnip.cn. All Rights Reserved.