首页 > 编程 > C# > 正文

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

2019-10-29 21:39:45
字体：大 中 小
来源：转载
供稿：网友

这篇文章主要介绍了通过C#实现自动售货机接口,需要的朋友可以参考下

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

MachineJP类：

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

 

 
  1. using System; 
  2. using System.Collections.Generic; 
  3. using System.IO.Ports; 
  4. using System.Linq; 
  5. using System.Text; 
  6. using System.Threading; 
  7. using System.Threading.Tasks; 
  8. using System.Windows.Forms; 
  9. using MachineJPDll.Models; 
  10. using MachineJPDll.Utils; 
  11.  
  12. namespace MachineJPDll 
  13. { 
  14. /// <summary> 
  15. /// 售货机接口(接口) 
  16. /// </summary> 
  17. public partial class MachineJP 
  18. { 
  19. #region 变量 
  20. /// <summary> 
  21. /// 串口资源 
  22. /// </summary> 
  23. private SerialPort m_SerialPort = null; 
  24. /// <summary> 
  25. /// 待发送给串口的命令列表 
  26. /// </summary> 
  27. private List<Cmd> m_CommandList = new List<Cmd>(); 
  28. /// <summary> 
  29. /// 等待ACK_RPT或NAK_RPT的PC端向VMC端发送的消息列表 
  30. /// </summary> 
  31. private List<MT> m_WaitResultMTList = new List<MT>(); 
  32. /// <summary> 
  33. /// 从串口接收的数据集合(数据已通过验证) 
  34. /// </summary> 
  35. private ReceiveDataCollection m_ReceiveDataCollection = new ReceiveDataCollection(); 
  36. #endregion 
  37.  
  38. #region 构造函数与析构函数 
  39. /// <summary> 
  40. /// 售货机接口(接口) 
  41. /// </summary> 
  42. public MachineJP() 
  43. { 
  44.  
  45. } 
  46.  
  47. ~MachineJP() 
  48. { 
  49. if (m_SerialPort != null) 
  50. { 
  51. m_SerialPort.Close(); 
  52. m_SerialPort.Dispose(); 
  53. m_SerialPort = null; 
  54. } 
  55. } 
  56. #endregion 
  57.  
  58. #region 读取串口数据 
  59. /// <summary> 
  60. /// 读取串口数据 
  61. /// </summary> 
  62. /// <returns>从串口读取的数据</returns> 
  63. private byte[] ReadPort() 
  64. { 
  65. //读取串口数据 
  66. DateTime dt = DateTime.Now; 
  67. while (m_SerialPort.BytesToRead < 2) 
  68. { 
  69. Thread.Sleep(1); 
  70.  
  71. if (DateTime.Now.Subtract(dt).TotalMilliseconds > 1500) //超时 
  72. { 
  73. return new byte[0]; 
  74. } 
  75. } 
  76. List<byte> recList = new List<byte>(); 
  77. byte[] recData = new byte[m_SerialPort.BytesToRead]; 
  78. m_SerialPort.Read(recData, 0, recData.Length); 
  79. recList.AddRange(recData); 
  80. int length = recData[1] + 2; //报文数据总长度 
  81. while (recList.Count < length) 
  82. { 
  83. if (m_SerialPort.BytesToRead > 0) 
  84. { 
  85. recData = new byte[m_SerialPort.BytesToRead]; 
  86. m_SerialPort.Read(recData, 0, recData.Length); 
  87. recList.AddRange(recData); 
  88. } 
  89. Thread.Sleep(1); 
  90. } 
  91.  
  92. return recList.ToArray(); 
  93. } 
  94. #endregion 
  95.  
  96. #region 向串口发送数据 
  97. /// <summary> 
  98. /// 向串口发送数据 
  99. /// </summary> 
  100. /// <param name="cmd">待发送的命令</param> 
  101. /// <param name="SN">序列号</param> 
  102. private void WritePort(Cmd cmd, byte SN) 
  103. { 
  104. //发送数据 
  105. List<byte> sendData = cmd.Data; 
  106. sendData[1] = (byte)sendData.Count; 
  107. sendData[2] = SN; 
  108. byte[] checkCode = CommonUtil.CalCheckCode(sendData, sendData.Count); 
  109. sendData.AddRange(checkCode); 
  110. if (cmd.Mt != null) 
  111. { 
  112. m_WaitResultMTList.Add(cmd.Mt); 
  113. } 
  114. m_SerialPort.Write(sendData.ToArray(), 0, sendData.Count); 
  115. LogHelper.Log(LogMsgType.Info, true, sendData.ToArray()); 
  116. } 
  117. #endregion 
  118.  
  119. #region 发送ACK消息 
  120. /// <summary> 
  121. /// 发送ACK消息 
  122. /// </summary> 
  123. /// <param name="SN">序列号</param> 
  124. private void SendACK(byte SN) 
  125. { 
  126. List<byte> sendData = new List<byte>() { 0xE5, 0x00, 0x00, 0x40, 0x80 }; 
  127. WritePort(new Cmd(sendData), SN); 
  128. } 
  129. #endregion 
  130.  
  131. #region Init 初始化 
  132. /// <summary> 
  133. /// 初始化 
  134. /// </summary> 
  135. /// <param name="com">串口号(例：COM1)</param> 
  136. public void Init(string com) 
  137. { 
  138. if (m_SerialPort == null) 
  139. { 
  140. m_SerialPort = new SerialPort(com, 9600, Parity.None, 8, StopBits.One); 
  141. m_SerialPort.ReadBufferSize = 1024; 
  142. m_SerialPort.WriteBufferSize = 1024; 
  143. m_SerialPort.DataReceived += new SerialDataReceivedEventHandler(serialPort_DataReceived); 
  144. } 
  145.  
  146. if (!m_SerialPort.IsOpen) 
  147. { 
  148. m_SerialPort.Open(); 
  149. } 
  150.  
  151. GET_SETUP(); 
  152. CONTROL_IND(0x13, new byte[] { 0x00 }); //初始化完成标志 
  153. GET_STATUS(); 
  154.  
  155. SetDecimalPlaces(2); //设置小数点位数 
  156. } 
  157. #endregion 
  158.  
  159. #region Close 关闭连接 
  160. /// <summary> 
  161. /// 关闭连接 
  162. /// </summary> 
  163. public void Close() 
  164. { 
  165. m_SerialPort.Close(); 
  166. } 
  167. #endregion 
  168.  
  169. #region 接收串口数据 
  170. /// <summary> 
  171. /// 接收串口数据 
  172. /// </summary> 
  173. /// <param name="type">消息类型</param> 
  174. /// <param name="subtype">消息子类型</param> 
  175. public byte[] Receive(byte type, byte subtype) 
  176. { 
  177. return m_ReceiveDataCollection.Get(type, subtype); 
  178. } 
  179.  
  180. /// <summary> 
  181. /// 接收串口数据 
  182. /// </summary> 
  183. /// <param name="type">消息类型</param> 
  184. /// <param name="subtype">消息子类型</param> 
  185. public byte[] WaitReceive(byte type, byte subtype) 
  186. { 
  187. DateTime time = DateTime.Now; 
  188. while (true) 
  189. { 
  190. byte[] receiveData = m_ReceiveDataCollection.Get(type, subtype); 
  191. if (receiveData != null) return receiveData; 
  192.  
  193. if (DateTime.Now.Subtract(time).TotalMinutes > 3) return null; 
  194.  
  195. Thread.Sleep(50); 
  196. } 
  197. } 
  198.  
  199. /// <summary> 
  200. /// 接收串口数据 
  201. /// </summary> 
  202. /// <param name="type">消息类型</param> 
  203. public byte[] WaitReceive(byte type) 
  204. { 
  205. DateTime time = DateTime.Now; 
  206. while (true) 
  207. { 
  208. byte[] receiveData = m_ReceiveDataCollection.Get(type); 
  209. if (receiveData != null) return receiveData; 
  210.  
  211. if (DateTime.Now.Subtract(time).TotalMinutes > 3) return null; 
  212.  
  213. Thread.Sleep(50); 
  214. } 
  215. } 
  216. #endregion 
  217.  
  218. #region 判断消息是否发送成功 
  219. /// <summary> 
  220. /// 判断消息是否发送成功 
  221. /// </summary> 
  222. public bool SendSuccess(byte type, byte subtype) 
  223. { 
  224. DateTime time = DateTime.Now; 
  225. while (true) 
  226. { 
  227. if (DateTime.Now.Subtract(time).TotalMinutes > 3) 
  228. { 
  229. return false; 
  230. } 
  231. byte[] ack = m_ReceiveDataCollection.Get(type, subtype); 
  232. byte[] nak = m_ReceiveDataCollection.Get(type, subtype); 
  233. if (ack != null) return true; 
  234. if (nak != null) return false; 
  235.  
  236. Thread.Sleep(1); 
  237. } 
  238. } 
  239. #endregion 
  240.  
  241. } 
  242. } 

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

 

 
  1. using System; 
  2. using System.Collections.Generic; 
  3. using System.IO.Ports; 
  4. using System.Linq; 
  5. using System.Text; 
  6. using MachineJPDll.Models; 
  7. using MachineJPDll.Utils; 
  8.  
  9. /* 
  10. * VMC->PC数据的接收,货机事件的分发 
  11. */ 
  12.  
  13. namespace MachineJPDll 
  14. { 
  15. partial class MachineJP 
  16. { 
  17. #region serialPort_DataReceived 
  18. /// <summary> 
  19. /// 数据接收事件的方法 
  20. /// </summary> 
  21. public void serialPort_DataReceived(object obj, SerialDataReceivedEventArgs args) 
  22. { 
  23. byte[] receiveData = ReadPort(); 
  24.  
  25. if (CommonUtil.ValidReceiveData(receiveData)) //只处理验证正确的数据，不正确的数据抛弃不处理 
  26. { 
  27. LogHelper.Log(LogMsgType.Info, false, receiveData); 
  28. byte SN = CommonUtil.GetSN(receiveData); 
  29. MT mt = new MT(receiveData); 
  30.  
  31. #region 轮询(POLL) 
  32. if (mt.Type == 0x03) 
  33. { 
  34. if (m_CommandList.Count > 0) 
  35. { 
  36. WritePort(m_CommandList[0], SN); 
  37. m_CommandList.RemoveAt(0); 
  38. } 
  39. else 
  40. { 
  41. //发送ACK消息 
  42. SendACK(SN); 
  43. } 
  44. } 
  45. #endregion 
  46.  
  47. #region 发送ACK消息 
  48. if (CommonUtil.NeedACK(receiveData)) 
  49. { 
  50. SendACK(SN); //发送ACK消息 
  51. } 
  52. #endregion 
  53.  
  54. #region VMC系统参数 
  55. if (mt.Type == 0x05) 
  56. { 
  57. m_ReceiveDataCollection.Add(mt.Type, mt.Subtype, receiveData); 
  58. } 
  59. #endregion 
  60.  
  61. #region ACK_RPT或NAK_RPT 
  62. if (mt.Type == 0x01 //ACK_RPT 
  63. || mt.Type == 0x02) //NAK_RPT 
  64. { 
  65. if (m_WaitResultMTList.Count > 0) 
  66. { 
  67. m_ReceiveDataCollection.Add(m_WaitResultMTList[0].Type, m_WaitResultMTList[0].Subtype, receiveData); 
  68. m_WaitResultMTList.RemoveAt(0); 
  69. } 
  70. } 
  71. #endregion 
  72.  
  73. #region INFO_RPT 数据报告 
  74. if (mt.Type == 0x11) 
  75. { 
  76. #region 纸币器信息 
  77. if (mt.Subtype == 16) 
  78. { 
  79. m_ReceiveDataCollection.Add(mt.Type, mt.Subtype, receiveData); 
  80. } 
  81. #endregion 
  82.  
  83. #region 硬币器信息 
  84. if (mt.Subtype == 17) 
  85. { 
  86. m_ReceiveDataCollection.Add(mt.Type, mt.Subtype, receiveData); 
  87. } 
  88. #endregion 
  89.  
  90. #region 用户投币余额 
  91. if (mt.Subtype == 3) 
  92. { 
  93. m_ReceiveDataCollection.Add(mt.Type, mt.Subtype, receiveData); 
  94. } 
  95. #endregion 
  96. } 
  97. #endregion 
  98.  
  99. #region VENDOUT_RPT 出货报告 
  100. if (mt.Type == 0x08) 
  101. { 
  102. m_ReceiveDataCollection.Add(mt.Type, mt.Subtype, receiveData); 
  103. } 
  104. #endregion 
  105.  
  106. #region STATUS_RPT VMC整机状态报告 
  107. if (mt.Type == 0x0D) 
  108. { 
  109. m_ReceiveDataCollection.Add(mt.Type, mt.Subtype, receiveData); 
  110. } 
  111. #endregion 
  112.  
  113. #region SALEPRICE_IND 设置当前商品售价 
  114. if (mt.Type == 0x8E) 
  115. { 
  116. m_ReceiveDataCollection.Add(mt.Type, mt.Subtype, receiveData); 
  117. } 
  118. #endregion 
  119.  
  120. #region PAYIN_RPT VMC发送现金投币报告给PC 
  121. if (mt.Type == 0x06) 
  122. { 
  123. m_ReceiveDataCollection.Add(mt.Type, mt.Subtype, receiveData); 
  124. } 
  125. #endregion 
  126.  
  127. #region PAYOUT_RPT 出币报告 
  128. if (mt.Type == 0x07) 
  129. { 
  130. m_ReceiveDataCollection.Add(mt.Type, mt.Subtype, receiveData); 
  131. } 
  132. #endregion 
  133.  
  134. #region COST_RPT VMC扣款报告 
  135. if (mt.Type == 0x10) 
  136. { 
  137. m_ReceiveDataCollection.Add(mt.Type, mt.Subtype, receiveData); 
  138. } 
  139. #endregion 
  140.  
  141. #region ACTION_RPT 售货机行为报告 
  142. if (mt.Type == 0x0B) 
  143. { 
  144. m_ReceiveDataCollection.Add(mt.Type, mt.Subtype, receiveData); 
  145. } 
  146. #endregion 
  147.  
  148. #region HUODAO_RPT VMC货道报告 
  149. if (mt.Type == 0x0E) 
  150. { 
  151. m_ReceiveDataCollection.Add(mt.Type, mt.Subtype, receiveData); 
  152. } 
  153. #endregion 
  154. } 
  155. else //接收到的数据没有验证通过 
  156. { 
  157. LogHelper.LogException(LogMsgType.Error, false, "数据异常", receiveData); 
  158. } 
  159. } 
  160. #endregion 
  161.  
  162. } 
  163. } 

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

 

 
  1. using System; 
  2. using System.Collections.Generic; 
  3. using System.Linq; 
  4. using System.Text; 
  5. using System.Threading; 
  6. using MachineJPDll.Enums; 
  7. using MachineJPDll.Models; 
  8. using MachineJPDll.Utils; 
  9.  
  10. /* 
  11. * PC->VMC数据的发送(并非直接发送,只是添加到发送列表) 
  12. */ 
  13.  
  14. namespace MachineJPDll 
  15. { 
  16. partial class MachineJP 
  17. { 
  18. #region GET_SETUP 
  19. /// <summary> 
  20. /// PC通知VMC发送VMC_SETUP 
  21. /// </summary> 
  22. public VmcSetup GET_SETUP() 
  23. { 
  24. List<byte> sendData = new List<byte>() { 0xE5, 0x00, 0x00, 0x40, 0x90 }; 
  25. m_CommandList.Add(new Cmd(sendData)); 
  26.  
  27. byte[] receiveData = WaitReceive(0x05); 
  28. if (receiveData != null) 
  29. { 
  30. return new VmcSetup(receiveData); 
  31. } 
  32. return null; 
  33. } 
  34. #endregion 
  35.  
  36. #region CONTROL_IND PC控制售货机完成对应的动作 
  37. /// <summary> 
  38. /// PC控制VMC 
  39. /// </summary> 
  40. public bool CONTROL_IND(byte subtype, byte[] value) 
  41. { 
  42. List<byte> sendData = new List<byte>() { 0xE5, 0x00, 0x00, 0x41, 0x85 }; 
  43. sendData.Add(subtype); 
  44. if (value != null && value.Length > 0) 
  45. { 
  46. sendData.AddRange(value); 
  47. } 
  48. m_CommandList.Add(new Cmd(sendData, new MT(sendData))); 
  49.  
  50. return SendSuccess(0x85, subtype); 
  51. } 
  52. #endregion 
  53.  
  54. #region 设置小数点位数 
  55. /// <summary> 
  56. /// 设置小数点位数 
  57. /// 用于PC 通知VMC，双方的金额数据比例系数关系，PC 每次启动时，都会给 
  58. /// VMC 下发一次type=18 的消息，VMC 需要自己永久保存该数据，直到被PC 再 
  59. /// 次更新。 
  60. /// 取值范围：0、1、2 分别表示以 元、 角 、分 为单位 
  61. /// </summary> 
  62. public bool SetDecimalPlaces(int data) 
  63. { 
  64. return CONTROL_IND(18, new byte[] { (byte)data }); 
  65. } 
  66. #endregion 
  67.  
  68. #region GET_STATUS PC通知VMC发送STATUS_RPT 
  69. /// <summary> 
  70. /// PC通知VMC发送STATUS_RPT 
  71. /// </summary> 
  72. public StatusRpt GET_STATUS() 
  73. { 
  74. List<byte> sendData = new List<byte>() { 0xE5, 0x00, 0x00, 0x40, 0x86 }; 
  75. m_CommandList.Add(new Cmd(sendData)); 
  76.  
  77. byte[] receiveData = WaitReceive(0x0D); 
  78. if (receiveData != null) 
  79. { 
  80. return new StatusRpt(receiveData); 
  81. } 
  82. return null; 
  83. } 
  84. #endregion 
  85.  
  86. #region GET_INFO PC通知VMC发送INFO_RPT 
  87. /// <summary> 
  88. /// PC通知VMC发送INFO_RPT 
  89. /// </summary> 
  90. public byte[] GET_INFO(byte subtype) 
  91. { 
  92. List<byte> sendData = new List<byte>() { 0xE5, 0x00, 0x00, 0x40, 0x8C }; 
  93. sendData.Add(subtype); 
  94. m_CommandList.Add(new Cmd(sendData)); 
  95.  
  96. return WaitReceive(0x11); 
  97. } 
  98. #endregion 
  99.  
  100. #region VENDOUT_IND 出货 
  101. /// <summary> 
  102. /// PC出货指示 
  103. /// </summary> 
  104. /// <param name="device">售货机的箱体号 例如柜1 为 0x01 以此类推</param> 
  105. /// <param name="method">method =1：VMC 通过商品ID 指示出货，如果商品ID 不存在，回复NAK_RPT method =2：VMC 通过货道ID 指示VMC 出货，如果货道ID 不存在，回复NAK_RPT</param> 
  106. /// <param name="sp_id_hd_id">sp_id：通过商品ID 指示VMC 出货 hd_id：通过货道ID 指示VMC 出货</param> 
  107. /// <param name="type">如果type=0，cost 代表本次出货扣款金额 如果TYPE 不为0，则COST 必须为0</param> 
  108. /// <param name="cost">cost 代表本次出货扣款金额</param> 
  109. public VendoutRpt VENDOUT_IND(byte device, byte method, byte sp_id_hd_id, byte type, int cost) 
  110. { 
  111. List<byte> sendData = new List<byte>() { 0xE5, 0x00, 0x00, 0x41, 0x83 }; 
  112. sendData.AddRange(new byte[] { device, method, sp_id_hd_id, type }); 
  113. sendData.AddRange(CommonUtil.Int2ByteArray(cost, 2)); 
  114. m_CommandList.Add(new Cmd(sendData, new MT(sendData))); 
  115.  
  116. if (SendSuccess(0x83, 0x00)) 
  117. { 
  118. byte[] receiveData = WaitReceive(0x08); 
  119. if (receiveData != null) 
  120. { 
  121. return new VendoutRpt(receiveData); 
  122. } 
  123. } 
  124. return null; 
  125. } 
  126. #endregion 
  127.  
  128. #region HUODAO_SET_IND 设置货道商品数量 
  129. /// <summary> 
  130. /// PC通知VMC，当前货道对应商品的数量等信息 
  131. /// </summary> 
  132. /// <param name="device">表示箱柜号</param> 
  133. /// <param name="huodao">zyxxxxxx “z”固定填0 “y”固定填0 “xxxxxx”，表示商品余量，如果商品余量大于63，则统一为63</param> 
  134. public bool HUODAO_SET_IND(byte device, List<int> huodao) 
  135. { 
  136. List<byte> sendData = new List<byte>() { 0xE5, 0x00, 0x00, 0x41, 0x8F }; 
  137. sendData.Add(device); 
  138. for (int i = 0; i < huodao.Count; i++) 
  139. { 
  140. if (huodao[i] > 63) 
  141. { 
  142. huodao[i] = 63; 
  143. } 
  144. } 
  145. sendData.AddRange(huodao.ConvertAll<byte>(a => (byte)a)); 
  146. m_CommandList.Add(new Cmd(sendData, new MT(sendData))); 
  147.  
  148. return SendSuccess(0x8F, 0x00); 
  149. } 
  150. #endregion 
  151.  
  152. #region SALEPRICE_IND 设置当前商品售价 
  153. /// <summary> 
  154. /// PC通知VMC，当前商品售价 
  155. /// </summary> 
  156. /// <param name="device">表示箱柜号</param> 
  157. /// <param name="type">表示设置单价的方式；Type = 0：为按商品ID 发送单价，可以变长发送，商品种类最大不超过80 个；Type = 1: 为按货道号发送，固定发送80 个货道的单价信息</param> 
  158. /// <param name="sp_price">商品售价</param> 
  159. public bool SALEPRICE_IND(byte device, byte type, List<int> sp_price) 
  160. { 
  161. List<byte> sendData = new List<byte>() { 0xE5, 0x00, 0x00, 0x41, 0x8E }; 
  162. sendData.Add(device); 
  163. sendData.Add(type); 
  164. sendData.AddRange(sp_price.ConvertAll<byte>(a => (byte)a)); 
  165. m_CommandList.Add(new Cmd(sendData, new MT(sendData))); 
  166.  
  167. return SendSuccess(0x8E, 0x00); 
  168. } 
  169. #endregion 
  170.  
  171. #region PAYOUT_IND PC指示VMC出币 
  172. /// <summary> 
  173. /// PC指示VMC出币 
  174. /// </summary> 
  175. /// <param name="device">出币设备</param> 
  176. /// <param name="value">本次出币总金额</param> 
  177. /// <param name="type">出币类型 无需理解type 的含义，只需要在出币完成后的PAYOUT_RPT 中将该type 值回传给PC 即可</param> 
  178. public PayoutRpt PAYOUT_IND(PayoutType device, int value, byte type) 
  179. { 
  180. List<byte> sendData = new List<byte>() { 0xE5, 0x00, 0x00, 0x41, 0x89 }; 
  181. sendData.Add((byte)device); 
  182. sendData.AddRange(CommonUtil.Int2ByteArray(value, 2)); 
  183. sendData.Add(type); 
  184. m_CommandList.Add(new Cmd(sendData, new MT(sendData))); 
  185.  
  186. if (SendSuccess(0x89, 0x00)) 
  187. { 
  188. byte[] receiveData = WaitReceive(0x07); 
  189. if (receiveData != null) 
  190. { 
  191. return new PayoutRpt(receiveData); 
  192. } 
  193. } 
  194. return null; 
  195. } 
  196. #endregion 
  197.  
  198. #region COST_IND PC扣款指示 
  199. /// <summary> 
  200. /// PC扣款指示 
  201. /// </summary> 
  202. /// <param name="device">device=0，从用户投币总额中扣款；优先从用户非暂存金额中扣除（纸币尽量滞后压钞），参见《现金扣款顺序》</param> 
  203. /// <param name="value">扣款金额</param> 
  204. /// <param name="type">VMC 不用理解type 的含义，只需上报对应的COST_RPT 时回传即可</param> 
  205. public CostRpt COST_IND(byte device, int value, byte type) 
  206. { 
  207. List<byte> sendData = new List<byte>() { 0xE5, 0x00, 0x00, 0x41, 0x8B }; 
  208. sendData.Add(device); 
  209. sendData.AddRange(CommonUtil.Int2ByteArray(value, 2)); 
  210. sendData.Add(type); 
  211. m_CommandList.Add(new Cmd(sendData, new MT(sendData))); 
  212.  
  213. if (SendSuccess(0x8B, 0x00)) 
  214. { 
  215. byte[] receiveData = WaitReceive(0x10); 
  216. if (receiveData != null) 
  217. { 
  218. return new CostRpt(receiveData); 
  219. } 
  220. } 
  221. return null; 
  222. } 
  223. #endregion 
  224.  
  225. #region GET_HUODAO PC通知VMC上报HUODAO_RPT 
  226. /// <summary> 
  227. /// PC通知VMC上报HUODAO_RPT 
  228. /// </summary> 
  229. /// <param name="device">箱柜号</param> 
  230. public HuoDaoRpt GET_HUODAO(byte device) 
  231. { 
  232. List<byte> sendData = new List<byte>() { 0xE5, 0x00, 0x00, 0x40, 0x8A }; 
  233. sendData.Add(device); 
  234. m_CommandList.Add(new Cmd(sendData)); 
  235.  
  236. byte[] receiveData = WaitReceive(0x0E); 
  237. if (receiveData != null) 
  238. { 
  239. return new HuoDaoRpt(receiveData); 
  240. } 
  241. return null; 
  242. } 
  243. #endregion 
  244.  
  245. #region SET_HUODAO PC发送配置货道信息 
  246. /// <summary> 
  247. /// PC发送配置货道信息 
  248. /// </summary> 
  249. /// <param name="Cabinet">箱柜号</param> 
  250. /// <param name="hd_no">货道逻辑编号，十进制</param> 
  251. /// <param name="Hd_id">商品ID号</param> 
  252. /// <param name="Hd_count">货道剩余量</param> 
  253. /// <param name="Hd_price">货道单价</param> 
  254. /// <param name="Reserved">保留字段VMC忽略此字段，PC最好将此字段置为0</param> 
  255. public bool SET_HUODAO(byte Cabinet, int hd_no, int Hd_id, int Hd_count, int Hd_price, int Reserved = 0) 
  256. { 
  257. List<byte> sendData = new List<byte>() { 0xE5, 0x00, 0x00, 0x41, 0x93 }; 
  258. sendData.Add(Cabinet); 
  259. sendData.Add((byte)hd_no); 
  260. sendData.Add((byte)Hd_id); 
  261. sendData.Add((byte)Hd_count); 
  262. sendData.AddRange(CommonUtil.Int2ByteArray(Hd_price, 2)); 
  263. sendData.AddRange(CommonUtil.Int2ByteArray(Reserved, 2)); 
  264. m_CommandList.Add(new Cmd(sendData, new MT(sendData))); 
  265.  
  266. return SendSuccess(0x93, 0x00); 
  267. } 
  268. #endregion 
  269.  
  270. #region 开启纸硬币器 
  271. /// <summary> 
  272. /// 现金收银模组（纸币器、硬币器）开关 
  273. /// </summary> 
  274. /// <param name="open">true:开,false:关</param> 
  275. public bool CtrlCoinPaper(bool open) 
  276. { 
  277. if (open) 
  278. { 
  279. return CONTROL_IND(2, new byte[] { 1 }); 
  280. } 
  281. else 
  282. { 
  283. return CONTROL_IND(2, new byte[] { 0 }); 
  284. } 
  285. } 
  286. #endregion 
  287.  
  288. #region 找零 
  289. /// <summary> 
  290. /// 找零 
  291. /// 与手工拨弄物理找零开关相同 
  292. /// </summary> 
  293. public bool MakeChange() 
  294. { 
  295. return CONTROL_IND(6, new byte[] { 0 }); 
  296. } 
  297. #endregion 
  298.  
  299. #region 获取硬币器信息 
  300. /// <summary> 
  301. /// 获取硬币器信息 
  302. /// </summary> 
  303. public InfoRpt_17 GetCoinInfo() 
  304. { 
  305. return new InfoRpt_17(GET_INFO(17)); 
  306. } 
  307. #endregion 
  308.  
  309. #region 获取纸币器信息 
  310. /// <summary> 
  311. /// 获取纸币器信息 
  312. /// </summary> 
  313. public InfoRpt_16 GetPaperInfo() 
  314. { 
  315. return new InfoRpt_16(GET_INFO(16)); 
  316. } 
  317. #endregion 
  318.  
  319. #region 获取现金投币报告 
  320. /// <summary> 
  321. /// 获取现金投币报告 
  322. /// </summary> 
  323. public PayinRpt GetPayinRpt() 
  324. { 
  325. byte[] receiveData = Receive(0x06, 0x00); 
  326. if (receiveData != null) 
  327. { 
  328. return new PayinRpt(receiveData); 
  329. } 
  330. return null; 
  331. } 
  332. #endregion 
  333.  
  334. #region 获取用户投币余额 
  335. /// <summary> 
  336. /// 获取用户投币余额 
  337. /// </summary> 
  338. public InfoRpt_3 GetRemaiderAmount() 
  339. { 
  340. byte[] receiveData = WaitReceive(0x11, 0x003); 
  341. if (receiveData != null) 
  342. { 
  343. return new InfoRpt_3(receiveData); 
  344. } 
  345. return null; 
  346. } 
  347. #endregion 
  348.  
  349. } 
  350. } 

ReceiveDataCollection类和ReceiveData类：

 

 
  1. using System; 
  2. using System.Collections.Generic; 
  3. using System.Linq; 
  4. using System.Text; 
  5.  
  6. namespace MachineJPDll.Models 
  7. { 
  8. /// <summary> 
  9. /// 从串口接收到的数据(数据已通过验证) 
  10. /// </summary> 
  11. public class ReceiveData 
  12. { 
  13. /// <summary> 
  14. /// 从串口接收到的数据(数据已通过验证) 
  15. /// </summary> 
  16. public byte[] Data { get; set; } 
  17. /// <summary> 
  18. /// 添加到集合ReceiveDataCollection的时间 
  19. /// </summary> 
  20. public DateTime AddTime { get; set; } 
  21. /// <summary> 
  22. /// 消息类型 
  23. /// </summary> 
  24. public byte Type { get; set; } 
  25. /// <summary> 
  26. /// 消息子类型 
  27. /// </summary> 
  28. public byte Subtype { get; set; } 
  29.  
  30. /// <summary> 
  31. /// 从串口接收到的数据(数据已通过验证) 
  32. /// </summary> 
  33. /// <param name="type">消息类型</param> 
  34. /// <param name="subtype">消息子类型</param> 
  35. /// <param name="data">从串口接收到的数据(数据已通过验证)</param> 
  36. /// <param name="addTime">添加到集合ReceiveDataCollection的时间</param> 
  37. public ReceiveData(byte type, byte subtype, byte[] data, DateTime addTime) 
  38. { 
  39. this.Type = type; 
  40. this.Subtype = subtype; 
  41. this.Data = data; 
  42. this.AddTime = addTime; 
  43. } 
  44. } 
  45. } 

 

 
  1. using System; 
  2. using System.Collections.Generic; 
  3. using System.Linq; 
  4. using System.Text; 
  5.  
  6. namespace MachineJPDll.Models 
  7. { 
  8. /// <summary> 
  9. /// 从串口接收到的数据集合(数据已通过验证) 
  10. /// </summary> 
  11. public class ReceiveDataCollection 
  12. { 
  13. /// <summary> 
  14. /// 从串口接收到的数据集合(数据已通过验证) 
  15. /// </summary> 
  16. private List<ReceiveData> m_ReceiveDataList = new List<ReceiveData>(); 
  17. /// <summary> 
  18. /// 数据过期时间 
  19. /// </summary> 
  20. private int m_Timeout = 3; 
  21. private static object _lock = new object(); 
  22.  
  23. /// <summary> 
  24. /// 添加到集合 
  25. /// </summary> 
  26. /// <param name="type">消息类型</param> 
  27. /// <param name="subtype">消息子类型</param> 
  28. /// <param name="data">从串口接收到的数据(数据已通过验证)</param> 
  29. public void Add(byte type, byte subtype, byte[] data) 
  30. { 
  31. lock (_lock) 
  32. { 
  33. ReceiveData receiveData = new ReceiveData(type, subtype, data, DateTime.Now); 
  34. m_ReceiveDataList.Add(receiveData); 
  35. for (int i = m_ReceiveDataList.Count - 1; i >= 0; i--) 
  36. { 
  37. if (DateTime.Now.Subtract(m_ReceiveDataList[i].AddTime).TotalMinutes > m_Timeout) 
  38. { 
  39. m_ReceiveDataList.RemoveAt(i); 
  40. } 
  41. } 
  42. } 
  43. } 
  44.  
  45. /// <summary> 
  46. /// 从集合中获取串口接收到的数据(数据已通过验证) 
  47. /// </summary> 
  48. /// <param name="type">消息类型</param> 
  49. /// <param name="subtype">消息子类型</param> 
  50. /// <returns>从串口接收到的数据(数据已通过验证)</returns> 
  51. public byte[] Get(byte type, byte subtype) 
  52. { 
  53. lock (_lock) 
  54. { 
  55. ReceiveData receiveData = null; 
  56. for (int i = 0; i < m_ReceiveDataList.Count; i++) 
  57. { 
  58. if (m_ReceiveDataList[i].Type == type && m_ReceiveDataList[i].Subtype == subtype) 
  59. { 
  60. receiveData = m_ReceiveDataList[i]; 
  61. m_ReceiveDataList.RemoveAt(i); 
  62. return receiveData.Data; 
  63. } 
  64. } 
  65. return null; 
  66. } 
  67. } 
  68.  
  69. /// <summary> 
  70. /// 从集合中获取串口接收到的数据(数据已通过验证) 
  71. /// </summary> 
  72. /// <param name="type">消息类型</param> 
  73. /// <returns>从串口接收到的数据(数据已通过验证)</returns> 
  74. public byte[] Get(byte type) 
  75. { 
  76. lock (_lock) 
  77. { 
  78. ReceiveData receiveData = null; 
  79. for (int i = 0; i < m_ReceiveDataList.Count; i++) 
  80. { 
  81. if (m_ReceiveDataList[i].Type == type) 
  82. { 
  83. receiveData = m_ReceiveDataList[i]; 
  84. m_ReceiveDataList.RemoveAt(i); 
  85. return receiveData.Data; 
  86. } 
  87. } 
  88. return null; 
  89. } 
  90. } 
  91. } 
  92. } 

Models：

StatusRpt类：

 

 
  1. using System; 
  2. using System.Collections.Generic; 
  3. using System.Linq; 
  4. using System.Text; 
  5. using MachineJPDll; 
  6. using MachineJPDll.Enums; 
  7. using MachineJPDll.Utils; 
  8.  
  9. namespace MachineJPDll.Models 
  10. { 
  11. /// <summary> 
  12. /// VMC状态报告 
  13. /// </summary> 
  14. public class StatusRpt 
  15. { 
  16. /// <summary> 
  17. /// 从串口读取的通过验证的数据 
  18. /// </summary> 
  19. private byte[] m_data; 
  20.  
  21. /// <summary> 
  22. /// VMC状态报告 
  23. /// </summary> 
  24. /// <param name="data">从串口读取的通过验证的数据</param> 
  25. public StatusRpt(byte[] data) 
  26. { 
  27. m_data = data; 
  28. } 
  29.  
  30. public override string ToString() 
  31. { 
  32. StringBuilder sb = new StringBuilder(); 
  33. sb.AppendFormat("出货检测设备状态：{0}/r/n", check_st.ToString()); 
  34. sb.AppendFormat("纸币器状态：{0}/r/n", bv_st.ToString()); 
  35. sb.AppendFormat("硬币器状态：{0}/r/n", cc_st.ToString()); 
  36. sb.AppendFormat("VMC状态：{0}/r/n", vmc_st.ToString()); 
  37. sb.AppendFormat("展示位状态：{0} {1} {2} {3}/r/n", pos_st[0].ToString(), pos_st[1].ToString(), pos_st[2].ToString(), pos_st[3].ToString()); 
  38. sb.AppendFormat("机器中可用的找零量总金额(包括硬币和纸币)：{0}/r/n", change.ToString()); 
  39. sb.AppendFormat("货仓1货仓2货仓3货仓4温度：{0} {1} {2} {3}/r/n", tem1.ToString(), tem2.ToString(), tem3.ToString(), tem4.ToString()); 
  40. sb.AppendFormat("货仓状态设置值：{0} {1} {2} {3}/r/n", tem_st[0].ToString(), tem_st[1].ToString(), tem_st[2].ToString(), tem_st[3].ToString()); 
  41. if (this.自动退币 == 255) 
  42. { 
  43. sb.AppendFormat("自动退币时间：永不自动退币/r/n"); 
  44. } 
  45. else 
  46. { 
  47. sb.AppendFormat("自动退币时间：{0}/r/n", 自动退币.ToString()); 
  48. } 
  49. sb.AppendFormat("找零余量(1#--6#)：{0} {1} {2} {3} {4} {5}/r/n", this.找零余量1, this.找零余量2, this.找零余量3, this.找零余量4, this.找零余量5, this.找零余量6); 
  50.  
  51. return sb.ToString(); 
  52. } 
  53.  
  54. /// <summary> 
  55. /// 出货检测设备状态 
  56. /// </summary> 
  57. public CheckSt check_st 
  58. { 
  59. get 
  60. { 
  61. byte val = m_data[5]; 
  62. return (CheckSt)CommonUtil.GetFromByte(val, 0, 2); 
  63. } 
  64. } 
  65.  
  66. /// <summary> 
  67. /// 纸币器状态 
  68. /// </summary> 
  69. public DeviceSt bv_st 
  70. { 
  71. get 
  72. { 
  73. byte val = m_data[5]; 
  74. return (DeviceSt)CommonUtil.GetFromByte(val, 2, 2); 
  75. } 
  76. } 
  77.  
  78. /// <summary> 
  79. /// 硬币器状态 
  80. /// </summary> 
  81. public DeviceSt cc_st 
  82. { 
  83. get 
  84. { 
  85. byte val = m_data[5]; 
  86. return (DeviceSt)CommonUtil.GetFromByte(val, 4, 2); 
  87. } 
  88. } 
  89.  
  90. /// <summary> 
  91. /// VMC状态 
  92. /// </summary> 
  93. public VmcSt vmc_st 
  94. { 
  95. get 
  96. { 
  97. byte val = m_data[5]; 
  98. return (VmcSt)CommonUtil.GetFromByte(val, 6, 2); 
  99. } 
  100. } 
  101.  
  102. /// <summary> 
  103. /// 展示位状态 
  104. /// </summary> 
  105. public List<DeviceSt> pos_st 
  106. { 
  107. get 
  108. { 
  109. List<DeviceSt> deviceStList = new List<DeviceSt>(); 
  110.  
  111. byte val = m_data[6]; 
  112. for (int i = 0; i < 4; i++) 
  113. { 
  114. DeviceSt deviceSt = (DeviceSt)CommonUtil.GetFromByte(val, i * 2, 2); 
  115. deviceStList.Add(deviceSt); 
  116. } 
  117.  
  118. return deviceStList; 
  119. } 
  120. } 
  121.  
  122. /// <summary> 
  123. /// 机器中，可用的找零量总金额（包括硬币和纸币） 
  124. /// </summary> 
  125. public int change 
  126. { 
  127. get 
  128. { 
  129. return CommonUtil.ByteArray2Int(m_data, 7, 2); 
  130. } 
  131. } 
  132.  
  133. /// <summary> 
  134. /// 货仓1 温度，8 位有符号数，该温度通过货仓内传感器获取，单位：℃ 
  135. /// </summary> 
  136. public TemSub tem1 
  137. { 
  138. get 
  139. { 
  140. return new TemSub(m_data[9]); 
  141. } 
  142. } 
  143.  
  144. /// <summary> 
  145. /// 货仓2 温度，8 位有符号数，该温度通过货仓内传感器获取，单位：℃ 
  146. /// </summary> 
  147. public TemSub tem2 
  148. { 
  149. get 
  150. { 
  151. return new TemSub(m_data[10]); 
  152. } 
  153. } 
  154.  
  155. /// <summary> 
  156. /// 货仓3 温度，8 位有符号数，该温度通过货仓内传感器获取，单位：℃ 
  157. /// </summary> 
  158. public TemSub tem3 
  159. { 
  160. get 
  161. { 
  162. return new TemSub(m_data[11]); 
  163. } 
  164. } 
  165.  
  166. /// <summary> 
  167. /// 货仓4 温度，8 位有符号数，该温度通过货仓内传感器获取，单位：℃ 
  168. /// </summary> 
  169. public TemSub tem4 
  170. { 
  171. get 
  172. { 
  173. return new TemSub(m_data[12]); 
  174. } 
  175. } 
  176.  
  177. /// <summary> 
  178. /// 货仓状态设置值，共支持4 个货仓 
  179. /// </summary> 
  180. public List<TemSt> tem_st 
  181. { 
  182. get 
  183. { 
  184. List<TemSt> temStList = new List<TemSt>(); 
  185. for (int i = 0; i < 4; i++) 
  186. { 
  187. TemSt temSt = (TemSt)CommonUtil.GetFromByte(m_data[13], i * 2, 2); 
  188. temStList.Add(temSt); 
  189. } 
  190. return temStList; 
  191. } 
  192. } 
  193.  
  194. /// <summary> 
  195. /// 自动退币时间。 
  196. /// 0：表示商品出货后，立即自动退币 
  197. /// 255：表示永不自动退币 
  198. /// 1-254：表示商品出货后，自动退币时间（单位：秒） 
  199. /// </summary> 
  200. public int 自动退币 
  201. { 
  202. get 
  203. { 
  204. return m_data[14]; 
  205. } 
  206. } 
  207.  
  208. /// <summary> 
  209. /// 找零余量“找零量1#”…“找零量6#”，分别对应硬币器信息INFO_RPT.type=17 的“找零 
  210. /// 1#”…“找零6#”中每种钱币的找零数量； 
  211. /// * 找零量最大为255，超过255 时上报为255； 
  212. /// * 找零量单位为“个”，代表可找零硬币的个数。 
  213. /// </summary> 
  214. public int 找零余量1 
  215. { 
  216. get 
  217. { 
  218. return m_data[15]; 
  219. } 
  220. } 
  221.  
  222. /// <summary> 
  223. /// 找零余量“找零量1#”…“找零量6#”，分别对应硬币器信息INFO_RPT.type=17 的“找零 
  224. /// 1#”…“找零6#”中每种钱币的找零数量； 
  225. /// * 找零量最大为255，超过255 时上报为255； 
  226. /// * 找零量单位为“个”，代表可找零硬币的个数。 
  227. /// </summary> 
  228. public int 找零余量2 
  229. { 
  230. get 
  231. { 
  232. return m_data[16]; 
  233. } 
  234. } 
  235.  
  236. /// <summary> 
  237. /// 找零余量“找零量1#”…“找零量6#”，分别对应硬币器信息INFO_RPT.type=17 的“找零 
  238. /// 1#”…“找零6#”中每种钱币的找零数量； 
  239. /// * 找零量最大为255，超过255 时上报为255； 
  240. /// * 找零量单位为“个”，代表可找零硬币的个数。 
  241. /// </summary> 
  242. public int 找零余量3 
  243. { 
  244. get 
  245. { 
  246. return m_data[17]; 
  247. } 
  248. } 
  249.  
  250. /// <summary> 
  251. /// 找零余量“找零量1#”…“找零量6#”，分别对应硬币器信息INFO_RPT.type=17 的“找零 
  252. /// 1#”…“找零6#”中每种钱币的找零数量； 
  253. /// * 找零量最大为255，超过255 时上报为255； 
  254. /// * 找零量单位为“个”，代表可找零硬币的个数。 
  255. /// </summary> 
  256. public int 找零余量4 
  257. { 
  258. get 
  259. { 
  260. return m_data[18]; 
  261. } 
  262. } 
  263.  
  264. /// <summary> 
  265. /// 找零余量“找零量1#”…“找零量6#”，分别对应硬币器信息INFO_RPT.type=17 的“找零 
  266. /// 1#”…“找零6#”中每种钱币的找零数量； 
  267. /// * 找零量最大为255，超过255 时上报为255； 
  268. /// * 找零量单位为“个”，代表可找零硬币的个数。 
  269. /// </summary> 
  270. public int 找零余量5 
  271. { 
  272. get 
  273. { 
  274. return m_data[19]; 
  275. } 
  276. } 
  277.  
  278. /// <summary> 
  279. /// 找零余量“找零量1#”…“找零量6#”，分别对应硬币器信息INFO_RPT.type=17 的“找零 
  280. /// 1#”…“找零6#”中每种钱币的找零数量； 
  281. /// * 找零量最大为255，超过255 时上报为255； 
  282. /// * 找零量单位为“个”，代表可找零硬币的个数。 
  283. /// </summary> 
  284. public int 找零余量6 
  285. { 
  286. get 
  287. { 
  288. return m_data[20]; 
  289. } 
  290. } 
  291.  
  292. } 
  293. } 

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

上一篇：C#实现12306自动登录的方法

下一篇：C#如何对多线程、多任务管理（demo）

发表评论 共有条评论
用户名: 密码:
验证码: 匿名发表
学习交流
更多

索泰发布一款GTX 1070 Mini迷你版本:小机

索泰发布一款GTX 1070 Mini迷你版本:小机箱大爱...
热门图片
更多
猜你喜欢的新闻
猜你喜欢的关注

新闻热点

荣耀总裁赵明乌镇演讲：荣耀首款5G手机V30下月发布
2019-10-23 09:17:05
搜狐张朝阳：回归媒体是搜狐重新崛起的关键
2019-10-21 09:20:02
华为轮值董事长郭平：虚拟技术创造现实价值
2019-10-21 09:00:12
滴滴英文服务上线两周年 用户已超200万
2019-09-26 08:57:12
华为推出全球至快AI训练集群Atlas900
2019-09-25 08:46:36
马斯克：特斯拉正组建中国技术团队
2019-09-25 08:15:43

疑难解答

图片精选

网友关注

关于本站 - 网上投稿 - 商务合作 - 隐私政策 - 网站地图
Copyright © 2008 - 2019 VEVB.COM. All Rights Reserved.武林网 版权所有