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 < )

            {

                Thread.Sleep();

                if (DateTime.Now.Subtract(dt).TotalMilliseconds > ) //超时

                {

                    return new byte[];

                }

            }

            List<byte> recList = new List<byte>();

            byte[] recData = new byte[m_SerialPort.BytesToRead];

            m_SerialPort.Read(recData, , recData.Length);

            recList.AddRange(recData);

            int length = recData[] + ; //报文数据总长度

            while (recList.Count < length)

            {

                if (m_SerialPort.BytesToRead > )

                {

                    recData = new byte[m_SerialPort.BytesToRead];

                    m_SerialPort.Read(recData, , recData.Length);

                    recList.AddRange(recData);

                }

                Thread.Sleep();

            }

            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[] = (byte)sendData.Count;

            sendData[] = 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(), , 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, , Parity.None, , StopBits.One);

                m_SerialPort.ReadBufferSize = ;

                m_SerialPort.WriteBufferSize = ;

                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(); //设置小数点位数

        }

        #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 > ) return null;

                Thread.Sleep();

            }

        }

        /// <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 > ) return null;

                Thread.Sleep();

            }

        }

        #endregion

        #region 判断消息是否发送成功

        /// <summary>

        /// 判断消息是否发送成功

        /// </summary>

        public bool SendSuccess(byte type, byte subtype)

        {

            DateTime time = DateTime.Now;

            while (true)

            {

                if (DateTime.Now.Subtract(time).TotalMinutes > )

                {

                    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();

            }

        }

        #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 > )

                    {

                        WritePort(m_CommandList[], SN);

                        m_CommandList.RemoveAt();

                    }

                    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 > )

                    {

                        m_ReceiveDataCollection.Add(m_WaitResultMTList[].Type, m_WaitResultMTList[].Subtype, receiveData);

                        m_WaitResultMTList.RemoveAt();

                    }

                }

                #endregion

                #region INFO_RPT 数据报告

                if (mt.Type == 0x11)

                {

                    #region 纸币器信息

                    if (mt.Subtype == )

                    {

                        m_ReceiveDataCollection.Add(mt.Type, mt.Subtype, receiveData);

                    }

                    #endregion

                    #region 硬币器信息

                    if (mt.Subtype == )

                    {

                        m_ReceiveDataCollection.Add(mt.Type, mt.Subtype, receiveData);

                    }

                    #endregion

                    #region 用户投币余额

                    if (mt.Subtype == )

                    {

                        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 > )

            {

                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(, 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, ));

            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 = ; i < huodao.Count; i++)

            {

                if (huodao[i] > )

                {

                    huodao[i] = ;

                }

            }

            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, ));

            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, ));

            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 = )

        {

            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, ));

            sendData.AddRange(CommonUtil.Int2ByteArray(Reserved, ));

            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(, new byte[] {  });

            }

            else

            {

                return CONTROL_IND(, new byte[] {  });

            }

        }

        #endregion

        #region 找零

        /// <summary>

        /// 找零

        /// 与手工拨弄物理找零开关相同

        /// </summary>

        public bool MakeChange()

        {

            return CONTROL_IND(, new byte[] {  });

        }

        #endregion

        #region 获取硬币器信息

        /// <summary>

        /// 获取硬币器信息

        /// </summary>

        public InfoRpt_17 GetCoinInfo()

        {

            return new InfoRpt_17(GET_INFO());

        }

        #endregion

        #region 获取纸币器信息

        /// <summary>

        /// 获取纸币器信息

        /// </summary>

        public InfoRpt_16 GetPaperInfo()

        {

            return new InfoRpt_16(GET_INFO());

        }

        #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 = ;

        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 - ; i >= ; 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 = ; 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 = ; 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[].ToString(), pos_st[].ToString(), pos_st[].ToString(), pos_st[].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[].ToString(), tem_st[].ToString(), tem_st[].ToString(), tem_st[].ToString());

            if (this.自动退币 == )

            {

                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[];

                return (CheckSt)CommonUtil.GetFromByte(val, , );

            }

        }

        /// <summary>

        /// 纸币器状态

        /// </summary>

        public DeviceSt bv_st

        {

            get

            {

                byte val = m_data[];

                return (DeviceSt)CommonUtil.GetFromByte(val, , );

            }

        }

        /// <summary>

        /// 硬币器状态

        /// </summary>

        public DeviceSt cc_st

        {

            get

            {

                byte val = m_data[];

                return (DeviceSt)CommonUtil.GetFromByte(val, , );

            }

        }

        /// <summary>

        /// VMC状态

        /// </summary>

        public VmcSt vmc_st

        {

            get

            {

                byte val = m_data[];

                return (VmcSt)CommonUtil.GetFromByte(val, , );

            }

        }

        /// <summary>

        /// 展示位状态

        /// </summary>

        public List<DeviceSt> pos_st

        {

            get

            {

                List<DeviceSt> deviceStList = new List<DeviceSt>();

                byte val = m_data[];

                for (int i = ; i < ; i++)

                {

                    DeviceSt deviceSt = (DeviceSt)CommonUtil.GetFromByte(val, i * , );

                    deviceStList.Add(deviceSt);

                }

                return deviceStList;

            }

        }

        /// <summary>

        /// 机器中，可用的找零量总金额（包括硬币和纸币）

        /// </summary>

        public int change

        {

            get

            {

                return CommonUtil.ByteArray2Int(m_data, , );

            }

        }

        /// <summary>

        /// 货仓1 温度，8 位有符号数，该温度通过货仓内传感器获取，单位：℃

        /// </summary>

        public TemSub tem1

        {

            get

            {

                return new TemSub(m_data[]);

            }

        }

        /// <summary>

        /// 货仓2 温度，8 位有符号数，该温度通过货仓内传感器获取，单位：℃

        /// </summary>

        public TemSub tem2

        {

            get

            {

                return new TemSub(m_data[]);

            }

        }

        /// <summary>

        /// 货仓3 温度，8 位有符号数，该温度通过货仓内传感器获取，单位：℃

        /// </summary>

        public TemSub tem3

        {

            get

            {

                return new TemSub(m_data[]);

            }

        }

        /// <summary>

        /// 货仓4 温度，8 位有符号数，该温度通过货仓内传感器获取，单位：℃

        /// </summary>

        public TemSub tem4

        {

            get

            {

                return new TemSub(m_data[]);

            }

        }

        /// <summary>

        /// 货仓状态设置值，共支持4 个货仓

        /// </summary>

        public List<TemSt> tem_st

        {

            get

            {

                List<TemSt> temStList = new List<TemSt>();

                for (int i = ; i < ; i++)

                {

                    TemSt temSt = (TemSt)CommonUtil.GetFromByte(m_data[], i * , );

                    temStList.Add(temSt);

                }

                return temStList;

            }

        }

        /// <summary>

        /// 自动退币时间。

        /// 0：表示商品出货后，立即自动退币

        /// 255：表示永不自动退币

        /// 1-254：表示商品出货后，自动退币时间（单位：秒）

        /// </summary>

        public int 自动退币

        {

            get

            {

                return m_data[];

            }

        }

        /// <summary>

        /// 找零余量“找零量1#”…“找零量6#”，分别对应硬币器信息INFO_RPT.type=17 的“找零

        /// 1#”…“找零6#”中每种钱币的找零数量；

        /// * 找零量最大为255，超过255 时上报为255；

        /// * 找零量单位为“个”，代表可找零硬币的个数。

        /// </summary>

        public int 找零余量1

        {

            get

            {

                return m_data[];

            }

        }

        /// <summary>

        /// 找零余量“找零量1#”…“找零量6#”，分别对应硬币器信息INFO_RPT.type=17 的“找零

        /// 1#”…“找零6#”中每种钱币的找零数量；

        /// * 找零量最大为255，超过255 时上报为255；

        /// * 找零量单位为“个”，代表可找零硬币的个数。

        /// </summary>

        public int 找零余量2

        {

            get

            {

                return m_data[];

            }

        }

        /// <summary>

        /// 找零余量“找零量1#”…“找零量6#”，分别对应硬币器信息INFO_RPT.type=17 的“找零

        /// 1#”…“找零6#”中每种钱币的找零数量；

        /// * 找零量最大为255，超过255 时上报为255；

        /// * 找零量单位为“个”，代表可找零硬币的个数。

        /// </summary>

        public int 找零余量3

        {

            get

            {

                return m_data[];

            }

        }

        /// <summary>

        /// 找零余量“找零量1#”…“找零量6#”，分别对应硬币器信息INFO_RPT.type=17 的“找零

        /// 1#”…“找零6#”中每种钱币的找零数量；

        /// * 找零量最大为255，超过255 时上报为255；

        /// * 找零量单位为“个”，代表可找零硬币的个数。

        /// </summary>

        public int 找零余量4

        {

            get

            {

                return m_data[];

            }

        }

        /// <summary>

        /// 找零余量“找零量1#”…“找零量6#”，分别对应硬币器信息INFO_RPT.type=17 的“找零

        /// 1#”…“找零6#”中每种钱币的找零数量；

        /// * 找零量最大为255，超过255 时上报为255；

        /// * 找零量单位为“个”，代表可找零硬币的个数。

        /// </summary>

        public int 找零余量5

        {

            get

            {

                return m_data[];

            }

        }

        /// <summary>

        /// 找零余量“找零量1#”…“找零量6#”，分别对应硬币器信息INFO_RPT.type=17 的“找零

        /// 1#”…“找零6#”中每种钱币的找零数量；

        /// * 找零量最大为255，超过255 时上报为255；

        /// * 找零量单位为“个”，代表可找零硬币的个数。

        /// </summary>

        public int 找零余量6

        {

            get

            {

                return m_data[];

            }

        }

    }

}

GitHub地址：https://github.com/0611163/Machine.git

最新文章

  1. iOS多线程到底不安全在哪里？
  2. Canvas里绘制矩阵文字
  3. label正确显示多行数据
  4. zabbix通过sendmail进行邮箱警报
  5. Linux下Sublime Text 2的安装
  6. Java 执行 SQL 脚本文件
  7. poj 3667 Hotel (线段树)
  8. Adjacent Bit Counts（动态规划 三维的）
  9. POJ 2524 并查集
  10. php中数字和字母生成随机字符串
  11. java获得平台相关的行分隔符和java路径分隔符的方法
  12. Singleton模式线程相关的（C\C++）
  13. IOS7学习之路三（UISpriteKit游戏开发SKNode）
  14. 性能测试分享：Jmeter的api监控工具解决方案
  15. netty编程一：快速入门
  16. java代码之美（1）---Lambda
  17. Git知识
  18. CarbonData-1：common
  19. CLOUD设置过滤方案不共享
  20. 100道Java基础面试题收集整理（附答案）

热门文章

  1. 程序员必须知道的几个Git代码托管平台
  2. 欢迎访问我的快站fbengine.kuaizhan.com
  3. 开发者最常用的 8 款 Sublime Text 3 插件
  4. css 文本溢出显示省略号
  5. 过滤器中的chain.doFilter(request,response)
  6. cordova添加platform
  7. CCNA网络工程师学习进程（2）基本的网络设备
  8. C语言数组空间的初始化详解
  9. C#相关
  10. java生成excel文件