Vending machine interface through C
- 2021-07-18 08:55:19
- OfStack
The following several parts of the introduction of C # to achieve the vending machine interface method, the code is written in great detail, do not understand where there are comments can refer to the following.
Class MachineJP:
Part 1: Serial port initialization, serial port data reading and writing
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>
/// Vending machine interface ( Interface )
/// </summary>
public partial class MachineJP
{
#region Variable
/// <summary>
/// Serial port resource
/// </summary>
private SerialPort m_SerialPort = null;
/// <summary>
/// List of commands to be sent to serial port
/// </summary>
private List<Cmd> m_CommandList = new List<Cmd>();
/// <summary>
/// Wait ACK_RPT Or NAK_RPT Adj. PC End orientation VMC List of messages sent by end
/// </summary>
private List<MT> m_WaitResultMTList = new List<MT>();
/// <summary>
/// Data set received from serial port ( The data has been verified )
/// </summary>
private ReceiveDataCollection m_ReceiveDataCollection = new ReceiveDataCollection();
#endregion
#region Constructor and destructor
/// <summary>
/// Vending machine interface ( Interface )
/// </summary>
public MachineJP()
{
}
~MachineJP()
{
if (m_SerialPort != null)
{
m_SerialPort.Close();
m_SerialPort.Dispose();
m_SerialPort = null;
}
}
#endregion
#region Read serial port data
/// <summary>
/// Read serial port data
/// </summary>
/// <returns> Data read from serial port </returns>
private byte[] ReadPort()
{
// Read serial port data
DateTime dt = DateTime.Now;
while (m_SerialPort.BytesToRead < 2)
{
Thread.Sleep(1);
if (DateTime.Now.Subtract(dt).TotalMilliseconds > 1500) // Timeout
{
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; // Total length of message data
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 Send data to serial port
/// <summary>
/// Send data to serial port
/// </summary>
/// <param name="cmd"> Commands to be sent </param>
/// <param name="SN"> Serial number </param>
private void WritePort(Cmd cmd, byte SN)
{
// Send data
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 Send ACK Message
/// <summary>
/// Send ACK Message
/// </summary>
/// <param name="SN"> Serial number </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 Initialization
/// <summary>
/// Initialization
/// </summary>
/// <param name="com"> String number ( Example: 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 }); // Initialization completion flag
GET_STATUS();
SetDecimalPlaces(2); // Set the number of decimal points
}
#endregion
#region Close Close the connection
/// <summary>
/// Close the connection
/// </summary>
public void Close()
{
m_SerialPort.Close();
}
#endregion
#region Receive serial port data
/// <summary>
/// Receive serial port data
/// </summary>
/// <param name="type"> Message type </param>
/// <param name="subtype"> Message subtype </param>
public byte[] Receive(byte type, byte subtype)
{
return m_ReceiveDataCollection.Get(type, subtype);
}
/// <summary>
/// Receive serial port data
/// </summary>
/// <param name="type"> Message type </param>
/// <param name="subtype"> Message 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>
/// Receive serial port data
/// </summary>
/// <param name="type"> Message 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 Determining whether the message was sent successfully
/// <summary>
/// Determining whether the message was sent successfully
/// </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
}
}
Part 2: Receiving serial port data, responding to cargo plane and sending data to cargo plane
using System;
using System.Collections.Generic;
using System.IO.Ports;
using System.Linq;
using System.Text;
using MachineJPDll.Models;
using MachineJPDll.Utils;
/*
* VMC->PC Reception of data , Distribution of cargo plane incidents
*/
namespace MachineJPDll
{
partial class MachineJP
{
#region serialPort_DataReceived
/// <summary>
/// Method of data reception event
/// </summary>
public void serialPort_DataReceived(object obj, SerialDataReceivedEventArgs args)
{
byte[] receiveData = ReadPort();
if (CommonUtil.ValidReceiveData(receiveData)) // Only the data that is verified to be correct is processed, and the incorrect data is discarded without processing
{
LogHelper.Log(LogMsgType.Info, false, receiveData);
byte SN = CommonUtil.GetSN(receiveData);
MT mt = new MT(receiveData);
#region Polling (POLL)
if (mt.Type == 0x03)
{
if (m_CommandList.Count > 0)
{
WritePort(m_CommandList[0], SN);
m_CommandList.RemoveAt(0);
}
else
{
// Send ACK Message
SendACK(SN);
}
}
#endregion
#region Send ACK Message
if (CommonUtil.NeedACK(receiveData))
{
SendACK(SN); // Send ACK Message
}
#endregion
#region VMC System parameters
if (mt.Type == 0x05)
{
m_ReceiveDataCollection.Add(mt.Type, mt.Subtype, receiveData);
}
#endregion
#region ACK_RPT Or 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 Data report
if (mt.Type == 0x11)
{
#region Banknote information
if (mt.Subtype == 16)
{
m_ReceiveDataCollection.Add(mt.Type, mt.Subtype, receiveData);
}
#endregion
#region Coiner information
if (mt.Subtype == 17)
{
m_ReceiveDataCollection.Add(mt.Type, mt.Subtype, receiveData);
}
#endregion
#region User coin balance
if (mt.Subtype == 3)
{
m_ReceiveDataCollection.Add(mt.Type, mt.Subtype, receiveData);
}
#endregion
}
#endregion
#region VENDOUT_RPT Shipment report
if (mt.Type == 0x08)
{
m_ReceiveDataCollection.Add(mt.Type, mt.Subtype, receiveData);
}
#endregion
#region STATUS_RPT VMC Complete machine status report
if (mt.Type == 0x0D)
{
m_ReceiveDataCollection.Add(mt.Type, mt.Subtype, receiveData);
}
#endregion
#region SALEPRICE_IND Set the current commodity price
if (mt.Type == 0x8E)
{
m_ReceiveDataCollection.Add(mt.Type, mt.Subtype, receiveData);
}
#endregion
#region PAYIN_RPT VMC Send cash coin report to PC
if (mt.Type == 0x06)
{
m_ReceiveDataCollection.Add(mt.Type, mt.Subtype, receiveData);
}
#endregion
#region PAYOUT_RPT Currency issue report
if (mt.Type == 0x07)
{
m_ReceiveDataCollection.Add(mt.Type, mt.Subtype, receiveData);
}
#endregion
#region COST_RPT VMC Deduction report
if (mt.Type == 0x10)
{
m_ReceiveDataCollection.Add(mt.Type, mt.Subtype, receiveData);
}
#endregion
#region ACTION_RPT Vending machine behavior report
if (mt.Type == 0x0B)
{
m_ReceiveDataCollection.Add(mt.Type, mt.Subtype, receiveData);
}
#endregion
#region HUODAO_RPT VMC Cargo lane report
if (mt.Type == 0x0E)
{
m_ReceiveDataCollection.Add(mt.Type, mt.Subtype, receiveData);
}
#endregion
}
else // The received data was not verified
{
LogHelper.LogException(LogMsgType.Error, false, " Data anomaly ", receiveData);
}
}
#endregion
}
}
Part 3: Cargo plane status, coin-in, shipment interface, etc.
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 下发1次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,则统1为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">货道逻辑编号,10进制</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
}
}
Class ReceiveDataCollection and Class ReceiveData:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace MachineJPDll.Models
{
/// <summary>
/// Data received from serial port ( The data has been verified )
/// </summary>
public class ReceiveData
{
/// <summary>
/// Data received from serial port ( The data has been verified )
/// </summary>
public byte[] Data { get; set; }
/// <summary>
/// Add to Collection ReceiveDataCollection Time of
/// </summary>
public DateTime AddTime { get; set; }
/// <summary>
/// Message type
/// </summary>
public byte Type { get; set; }
/// <summary>
/// Message subtype
/// </summary>
public byte Subtype { get; set; }
/// <summary>
/// Data received from serial port ( The data has been verified )
/// </summary>
/// <param name="type"> Message type </param>
/// <param name="subtype"> Message subtype </param>
/// <param name="data"> Data received from serial port ( The data has been verified )</param>
/// <param name="addTime"> Add to Collection ReceiveDataCollection Time of </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>
/// Data set received from serial port ( The data has been verified )
/// </summary>
public class ReceiveDataCollection
{
/// <summary>
/// Data set received from serial port ( The data has been verified )
/// </summary>
private List<ReceiveData> m_ReceiveDataList = new List<ReceiveData>();
/// <summary>
/// Data expiration time
/// </summary>
private int m_Timeout = 3;
private static object _lock = new object();
/// <summary>
/// Add to Collection
/// </summary>
/// <param name="type"> Message type </param>
/// <param name="subtype"> Message subtype </param>
/// <param name="data"> Data received from serial port ( The data has been verified )</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>
/// Get the data received by serial port from the collection ( The data has been verified )
/// </summary>
/// <param name="type"> Message type </param>
/// <param name="subtype"> Message subtype </param>
/// <returns> Data received from serial port ( The data has been verified )</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>
/// Get the data received by serial port from the collection ( The data has been verified )
/// </summary>
/// <param name="type"> Message type </param>
/// <returns> Data received from serial port ( The data has been verified )</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:
Class 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 Status report
/// </summary>
public class StatusRpt
{
/// <summary>
/// Verified data read from serial port
/// </summary>
private byte[] m_data;
/// <summary>
/// VMC Status report
/// </summary>
/// <param name="data"> Verified data read from serial port </param>
public StatusRpt(byte[] data)
{
m_data = data;
}
public override string ToString()
{
StringBuilder sb = new StringBuilder();
sb.AppendFormat(" Status of shipping inspection equipment: {0}\r\n", check_st.ToString());
sb.AppendFormat(" Money holder status: {0}\r\n", bv_st.ToString());
sb.AppendFormat(" Coiner status: {0}\r\n", cc_st.ToString());
sb.AppendFormat("VMC Status: {0}\r\n", vmc_st.ToString());
sb.AppendFormat(" Show bit status: {0} {1} {2} {3}\r\n", pos_st[0].ToString(), pos_st[1].ToString(), pos_st[2].ToString(), pos_st[3].ToString());
sb.AppendFormat(" Total amount of change available in the machine ( Including coins and paper money ) : {0}\r\n", change.ToString());
sb.AppendFormat(" Warehouse 1 Warehouse 2 Warehouse 3 Warehouse 4 Temperature: {0} {1} {2} {3}\r\n", tem1.ToString(), tem2.ToString(), tem3.ToString(), tem4.ToString());
sb.AppendFormat(" Warehouse status setting value: {0} {1} {2} {3}\r\n", tem_st[0].ToString(), tem_st[1].ToString(), tem_st[2].ToString(), tem_st[3].ToString());
if (this. Automatic refund == 255)
{
sb.AppendFormat(" Automatic coin refund time: never automatic coin refund \r\n");
}
else
{
sb.AppendFormat(" Automatic refund time: {0}\r\n", Automatic refund .ToString());
}
sb.AppendFormat(" Change margin (1#--6#) : {0} {1} {2} {3} {4} {5}\r\n", this. Change margin 1, this. Change margin 2, this. Change margin 3, this. Change margin 4, this. Change margin 5, this. Change margin 6);
return sb.ToString();
}
/// <summary>
/// Shipment inspection equipment status
/// </summary>
public CheckSt check_st
{
get
{
byte val = m_data[5];
return (CheckSt)CommonUtil.GetFromByte(val, 0, 2);
}
}
/// <summary>
/// Banknote container status
/// </summary>
public DeviceSt bv_st
{
get
{
byte val = m_data[5];
return (DeviceSt)CommonUtil.GetFromByte(val, 2, 2);
}
}
/// <summary>
/// Coiner status
/// </summary>
public DeviceSt cc_st
{
get
{
byte val = m_data[5];
return (DeviceSt)CommonUtil.GetFromByte(val, 4, 2);
}
}
/// <summary>
/// VMC Status
/// </summary>
public VmcSt vmc_st
{
get
{
byte val = m_data[5];
return (VmcSt)CommonUtil.GetFromByte(val, 6, 2);
}
}
/// <summary>
/// Show bit status
/// </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>
/// The total amount of change available in the machine (including coins and banknotes)
/// </summary>
public int change
{
get
{
return CommonUtil.ByteArray2Int(m_data, 7, 2);
}
}
/// <summary>
/// Warehouse 1 Temperature, 8 Bit has a signed number, and the temperature is obtained by the sensor in the warehouse. The unit is ℃
/// </summary>
public TemSub tem1
{
get
{
return new TemSub(m_data[9]);
}
}
/// <summary>
/// Warehouse 2 Temperature, 8 Bit has a signed number, and the temperature is obtained by the sensor in the warehouse. The unit is ℃
/// </summary>
public TemSub tem2
{
get
{
return new TemSub(m_data[10]);
}
}
/// <summary>
/// Warehouse 3 Temperature, 8 Bit has a signed number, and the temperature is obtained by the sensor in the warehouse. The unit is ℃
/// </summary>
public TemSub tem3
{
get
{
return new TemSub(m_data[11]);
}
}
/// <summary>
/// Warehouse 4 Temperature, 8 Bit has a signed number, and the temperature is obtained by the sensor in the warehouse. The unit is ℃
/// </summary>
public TemSub tem4
{
get
{
return new TemSub(m_data[12]);
}
}
/// <summary>
/// Warehouse status setting value, supported altogether 4 Warehouse
/// </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>
/// Automatic refund time.
/// 0 : Indicates that the currency will be automatically refunded immediately after the goods are shipped
/// 255 : Indicates that money will never be refunded automatically
/// 1-254 : Indicates the automatic currency refund time after the goods are shipped (unit: seconds)
/// </summary>
public int Automatic refund
{
get
{
return m_data[14];
}
}
/// <summary>
/// Change allowance 1# "..." Change 6# ", corresponding to coin machine information respectively INFO_RPT.type=17 Change of "
/// 1# "..." Change 6# The change amount of each coin in ";
/// * Maximum change 255 , more than 255 Report to 255 ;
/// * The unit of change is "pieces", which represents the number of coins that can be changed.
/// </summary>
public int Change margin 1
{
get
{
return m_data[15];
}
}
/// <summary>
/// Change allowance 1# "..." Change 6# ", corresponding to coin machine information respectively INFO_RPT.type=17 Change of "
/// 1# "..." Change 6# The change amount of each coin in ";
/// * Maximum change 255 , more than 255 Report to 255 ;
/// * The unit of change is "pieces", which represents the number of coins that can be changed.
/// </summary>
public int Change margin 2
{
get
{
return m_data[16];
}
}
/// <summary>
/// Change allowance 1# "..." Change 6# ", corresponding to coin machine information respectively INFO_RPT.type=17 Change of "
/// 1# "..." Change 6# The change amount of each coin in ";
/// * Maximum change 255 , more than 255 Report to 255 ;
/// * The unit of change is "pieces", which represents the number of coins that can be changed.
/// </summary>
public int Change margin 3
{
get
{
return m_data[17];
}
}
/// <summary>
/// Change allowance 1# "..." Change 6# ", corresponding to coin machine information respectively INFO_RPT.type=17 Change of "
/// 1# "..." Change 6# The change amount of each coin in ";
/// * Maximum change 255 , more than 255 Report to 255 ;
/// * The unit of change is "pieces", which represents the number of coins that can be changed.
/// </summary>
public int Change margin 4
{
get
{
return m_data[18];
}
}
/// <summary>
/// Change allowance 1# "..." Change 6# ", corresponding to coin machine information respectively INFO_RPT.type=17 Change of "
/// 1# "..." Change 6# The change amount of each coin in ";
/// * Maximum change 255 , more than 255 Report to 255 ;
/// * The unit of change is "pieces", which represents the number of coins that can be changed.
/// </summary>
public int Change margin 5
{
get
{
return m_data[19];
}
}
/// <summary>
/// Change allowance 1# "..." Change 6# ", corresponding to coin machine information respectively INFO_RPT.type=17 Change of "
/// 1# "..." Change 6# The change amount of each coin in ";
/// * Maximum change 255 , more than 255 Report to 255 ;
/// * The unit of change is "pieces", which represents the number of coins that can be changed.
/// </summary>
public int Change margin 6
{
get
{
return m_data[20];
}
}
}
}
The above is the C # implementation of the vending machine interface code, the need for friends to learn.