public Recv机头地址动态分配(FrameData data)
{
try
{
RecvData = data;
if (data.commandData.Length >= 8)
{
List <byte> mid = new List <byte>(data.commandData);
UInt64 ui64 = BitConverter.ToUInt64(mid.ToArray(), 0);
MCUID = Convert.ToString((long)ui64, 16).ToUpper().Substring(0, 14);
//if (!SecrityHeadInfo.CheckHead(MCUID)) return;
Ask.Ask机头地址动态分配 ask = new Command.Ask.Ask机头地址动态分配(data.Code, MCUID);
机头地址 = PubLib.Hex2String(ask.机头地址);
byte[] readyToSend = PubLib.GetBytesByObject(ask);
SendData = PubLib.GetFrameDataBytes(data, readyToSend, CommandType.机头地址动态分配应答);
SendDataTime = DateTime.Now;
LogHelper.WriteLogSpacail(string.Format("{0} 申请地址 {1}", MCUID, 机头地址));
}
}
catch
{
throw;
}
}
public string GetSendData()
{
StringBuilder sb = new StringBuilder();
sb = new StringBuilder();
if (!IsDevice)
{
Ask.Ask终端参数申请 AskData = 应答数据 as Ask.Ask终端参数申请;
sb.Append("=============================================\r\n");
sb.AppendFormat("{0:yyyy-MM-dd HH:mm:ss.fff} 发送数据\r\n", SendDataTime);
sb.Append(PubLib.BytesToString(SendData) + Environment.NewLine);
sb.Append("当前是机头在获取参数\r\n");
sb.AppendFormat("机头地址：{0}\r\n", PubLib.Hex2String(AskData.机头地址));
sb.AppendFormat("单次退币限额：{0}\r\n", AskData.单次退币限额);
sb.AppendFormat("退币时接收游戏机数币数：{0}\r\n", AskData.退币时给游戏机脉冲数比例因子);
sb.AppendFormat("退币时卡上增加币数：{0}\r\n", AskData.退币时卡上增加币数比例因子);
sb.AppendFormat("本店卡校验密码：{0}\r\n", AskData.本店卡校验密码);
sb.AppendFormat("开关1：{0}\r\n", PubLib.Hex2BitString(AskData.开关1));
sb.AppendFormat("开关2：{0}\r\n", PubLib.Hex2BitString(AskData.开关2));
sb.AppendFormat("首次投币启动间隔：{0}\r\n", AskData.首次投币启动间隔);
sb.AppendFormat("退币速度：{0}\r\n", AskData.退币速度);
sb.AppendFormat("退币脉宽：{0}\r\n", AskData.退币脉宽);
sb.AppendFormat("投币速度：{0}\r\n", AskData.投币速度);
sb.AppendFormat("投币脉宽：{0}\r\n", AskData.投币脉宽);
sb.AppendFormat("第二路上分线上分脉宽：{0}\r\n", AskData.第二路上分线上分脉宽);
sb.AppendFormat("第二路上分线上分启动间隔：{0}\r\n", AskData.第二路上分线首次上分启动间隔);
sb.AppendFormat("第二路上分线上分速度：{0}\r\n", AskData.第二路上分线上分速度);
}
else
{
Ask.Ask设备参数申请 AskData = 应答数据 as Ask.Ask设备参数申请;
sb.Append("=============================================\r\n");
sb.AppendFormat("{0:yyyy-MM-dd HH:mm:ss.fff} 发送数据\r\n", SendDataTime);
sb.Append(PubLib.BytesToString(SendData) + Environment.NewLine);
sb.Append("当前是存币机在获取参数\r\n");
sb.AppendFormat("机头地址：{0}\r\n", PubLib.Hex2String(AskData.机头地址));
sb.AppendFormat("马达配置：{0}\r\n", PubLib.Hex2BitString(AskData.马达配置));
sb.AppendFormat("马达1比例：{0}\r\n", AskData.马达1比例);
sb.AppendFormat("马达2比例：{0}\r\n", AskData.马达2比例);
sb.AppendFormat("存币箱最大存币数：{0}\r\n", AskData.存币箱最大存币数);
}
return(sb.ToString());
}
public Recv游戏机参数申请(FrameData data)
{
try
{
机头地址 = PubLib.Hex2String(data.commandData[0]);
CloudRS232Server.Info.HeadInfo.机头绑定信息 bind = new Info.HeadInfo.机头绑定信息();
bind.控制器令牌 = data.Code;
bind.短地址 = 机头地址;
Info.HeadInfo.机头信息 head = Info.HeadInfo.GetHeadInfoByShort(bind);
if (head != null)
{
switch (head.类型)
{
case Info.HeadInfo.设备类型.存币机:
case Info.HeadInfo.设备类型.提_售币机:
IsDevice = true;
Ask.Ask设备参数申请 askData1 = new Ask.Ask设备参数申请(bind);
应答数据 = askData1;
break;
default:
IsDevice = false;
Ask.Ask终端参数申请 askData2 = new Command.Ask.Ask终端参数申请(bind);
应答数据 = askData2;
break;
}
byte[] dataBuf = PubLib.GetBytesByObject(应答数据);
SendData = PubLib.GetFrameDataBytes(data, dataBuf, CommandType.游戏机参数申请应答);
RecvData = data;
}
}
catch
{
throw;
}
}
public Recv卡头进出币数据(FrameData f, DateTime RecvDateTime)
{
try
{
RecvData = f;
if (f.commandData.Length >= 15)
{
机头地址 = PubLib.Hex2String(f.commandData[0]);
for (int i = 0; i < 8; i++)
{
if (f.commandData[i + 1] < 0x30 || f.commandData[i + 1] > 0x39)
{
f.commandData[i + 1] = 32;
}
}
IC卡号码 = Encoding.ASCII.GetString(f.commandData, 1, 8);
IC卡号码 = IC卡号码.Trim();
动态密码 = f.commandData[9];
控制类型 = (CoinType)f.commandData[10];
币数 = (int)BitConverter.ToUInt16(f.commandData, 11);
测试数据 = BitConverter.ToUInt16(f.commandData, 13);
流水号 = BitConverter.ToUInt16(f.commandData, 15);
高速投币标志 = (测试数据 / 256 == 1);
投币目标地址 = PubLib.Hex2String((byte)(测试数据 % 256));
Info.HeadInfo.机头绑定信息 bind = new Info.HeadInfo.机头绑定信息();
bind.控制器令牌 = f.Code;
bind.短地址 = 机头地址;
Info.HeadInfo.机头信息 head = Info.HeadInfo.GetHeadInfoByShort(bind);
if (head != null)
{
if (IC卡号码 == "") IC卡号码 = head.常规.当前卡片号;
if (IC卡号码 == "") IC卡号码 = "0";
if (控制类型 == CoinType.实物投币) IC卡号码 = "0"; //实物投币过滤卡号，有可能是卡头没有清缓存导致
head.临时错误计数 = 测试数据;
head.状态.出币机或存币机正在数币 = false;
object obj = null;
int res = UDPServerHelper.CheckRepeat(f.Code, 机头地址, IC卡号码, CommandType.IC卡模式投币数据, ref obj, 流水号);
if (res == 0)
{
//if (高速投币标志)
// Ask.Ask远程投币上分数据 ask = new Ask.Ask远程投币上分数据(投币目标地址, 币数, "刷卡", 流水号);
string msg = "";
应答数据 = new Ask.Ask卡头进出币数据应答(head, IC卡号码, 币数, 控制类型, 动态密码, (UInt16)流水号, f, 高速投币标志, 投币目标地址, ref msg);
if (f.commandType == CommandType.IC卡模式投币数据)
{
UDPServerHelper.InsertRepeat(f.routeAddress, 机头地址, IC卡号码, CommandType.IC卡模式投币数据, CommandType.IC卡模式投币数据应答, 应答数据, 流水号, RecvDateTime);
if (应答数据.脉冲数 == 0)
{
LogHelper.WriteLog("IC卡进出币数据有误\r\n" + msg, f.commandData);
}
}
else
UDPServerHelper.InsertRepeat(f.routeAddress, 机头地址, IC卡号码, CommandType.IC卡模式退币数据, CommandType.IC卡模式退币数据应答, 应答数据, 流水号, RecvDateTime);
}
else if (res == 1)
{
应答数据 = (Ask.Ask卡头进出币数据应答)obj;
PubLib.当前IC卡进出币指令重复数++;
}
else
{
//重复性检查错误
return;
}
byte[] dataBuf = PubLib.GetBytesByObject(应答数据);
if (f.commandType == CommandType.IC卡模式投币数据)
SendData = PubLib.GetFrameDataBytes(f, dataBuf, CommandType.IC卡模式投币数据应答);
else
{
SendData = PubLib.GetFrameDataBytes(f, dataBuf, CommandType.IC卡模式退币数据应答);
LogHelper.WriteTBLog(PubLib.BytesToString(f.recvData));
}
}
}
}
catch
{
//LogHelper.WriteLog("IC卡进出币数据有误", f.commandData);
throw;
}
}
public Recv机头卡片报警指令(FrameData f, DateTime RecvDateTime)
{
RecvData = f;
机头地址 = PubLib.Hex2String(f.commandData[0]);
if (f.commandLength < 12)
{
return;
}
IC卡号码 = Encoding.ASCII.GetString(f.commandData, 1, 8);
IC卡号码 = IC卡号码.Replace("\0", "");
int cardid = 0;
if (!int.TryParse(IC卡号码, out cardid))
{
IC卡号码 = "0";
}
卡片类型 = f.commandData[9];
报警类别 = f.commandData[10];
处理结果 = f.commandData[11];
AlertType = "";
switch (报警类别)
{
case 0:
AlertType = "用户异常退币报警";
break;
case 1:
AlertType = "非法专卡专用解锁";
break;
case 2:
AlertType = "专卡专用解锁";
break;
case 3:
AlertType = "非法送分券解锁";
break;
case 4:
AlertType = "常规解锁";
break;
case 5:
AlertType = "退币锁定";
break;
default:
AlertType = "未知错误报警";
break;
}
流水号 = BitConverter.ToUInt16(f.commandData, 12);
Info.HeadInfo.机头绑定信息 bind = new Info.HeadInfo.机头绑定信息();
bind.控制器令牌 = f.Code;
bind.短地址 = 机头地址;
Info.HeadInfo.机头信息 机头 = Info.HeadInfo.GetHeadInfoByShort(bind);
string 管理卡号 = "0";
if (机头 != null)
{
管理卡号 = 机头.常规.管理卡号;
}
if (!int.TryParse(管理卡号, out cardid))
{
管理卡号 = "0";
}
object obj = null;
//DataAccess ac = new DataAccess();
int res = UDPServerHelper.CheckRepeat(f.Code, 机头地址, IC卡号码, CommandType.机头卡片报警指令, ref obj, 流水号);
if (res == 0)
{
switch (报警类别)
{
case 0:
case 1:
int d = 0;
if (!int.TryParse(管理卡号, out d))
{
管理卡号 = "0";
}
if (!int.TryParse(IC卡号码, out d))
{
IC卡号码 = "0";
}
string sql = string.Format("INSERT INTO flw_game_alarm VALUES ('{0}','{1}','{2}','{3}',GETDATE(),null,0,0,0,'会员卡号：{4}')",
管理卡号, 机头.商户号, 机头.常规.机头编号, AlertType, IC卡号码);
//ac.Execute(sql);
XCCloudRS232BLL.ExecuteSql(sql);
break;
case 2:
{
//if (卡片类型 == 1) //管理卡
{
if (机头.状态.超级解锁卡标识)
{
AlertType = "超级卡解锁专卡专用解锁";
}
string dbsql = "";
if (!机头.状态.超级解锁卡标识 && 处理结果 == 1) //普通卡，处理结果成功的直接写2
{
dbsql = string.Format("INSERT INTO flw_game_alarm VALUES ('{0}','{1}','{2}','{3}',GETDATE(),GETDATE(),2,0,0,'会员卡号：{4}')",
管理卡号, 机头.商户号, 机头.常规.机头编号, AlertType, IC卡号码);
}
else
{
dbsql = string.Format("INSERT INTO flw_game_alarm VALUES ('{0}','{1}','{2}','{3}',GETDATE(),null,0,0,0,'会员卡号：{4}')",
管理卡号, 机头.商户号, 机头.常规.机头编号, AlertType, IC卡号码);
}
//ac.Execute(dbsql);
XCCloudRS232BLL.ExecuteSql(dbsql);
}
string IC = 机头.常规.当前卡片号;
//if (Info.CoinInfo.被动退分解锁队列.ContainsKey(IC))
//{
// if (处理结果 == 0)
// {
// Info.CoinInfo.被动退分解锁队列[IC].是否允许退分标识 = false;
// Info.CoinInfo.被动退分解锁队列[IC].错误信息 = string.Format("机头编号：{0} 有分；", 机头.常规.机头长地址);
// }
// else
// {
// 机头.常规.当前卡片号 = "";
// }
// Info.CoinInfo.被动退分解锁队列[IC].当前序号++;
// if (Info.CoinInfo.被动退分解锁队列[IC].当前序号 >= Info.CoinInfo.被动退分解锁队列[IC].机头列表.Count)
// {
// //发送完毕
// //ServiceDll.ClientCall.远程强制退分应答(Info.CoinInfo.被动退分解锁队列[IC].错误信息, IC, (Info.CoinInfo.被动退分解锁队列[IC].错误信息 == ""));
// //StringBuilder sb1 = new StringBuilder();
// //sb1.Append("=============================================\r\n");
// //sb1.AppendFormat("{0:yyyy-MM-dd HH:mm:ss.fff} 远程强制退分应答\r\n", DateTime.Now);
// //sb1.AppendFormat("IC卡号：{0}\r\n", IC);
// //sb1.AppendFormat("结果：{0}\r\n", Info.CoinInfo.被动退分解锁队列[IC].错误信息);
// //UIClass.接收内容 = sb1.ToString();
// }
//}
}
break;
case 3:
{
机头.状态.是否正在使用限时送分优惠 = (处理结果 == 1);
机头.常规.是否为首次投币 = (处理结果 == 1);
if (处理结果 == 0)
{
string qsql = string.Format("INSERT INTO flw_game_alarm VALUES ('{0}','{1}','{2}','{3}',GETDATE(),null,0,0,0,'会员卡号：{4}')",
管理卡号, 机头.商户号, 机头.常规.机头编号, AlertType, IC卡号码);
//ac.Execute(qsql);
XCCloudRS232BLL.ExecuteSql(qsql);
}
else
{
if (机头.状态.超级解锁卡标识) //超级管理卡
{
string dbsql = string.Format("INSERT INTO flw_game_alarm VALUES ('{0}','{1}','{2}','{3}',GETDATE(),null,0,0,0,'会员卡号：{4}')",
管理卡号, 机头.商户号, 机头.常规.机头编号, AlertType, IC卡号码);
//ac.Execute(dbsql);
XCCloudRS232BLL.ExecuteSql(dbsql);
}
else
{
AlertType = "解锁限时送分";
string dbsql = string.Format("INSERT INTO flw_game_alarm VALUES ('{0}','{1}','{2}','{3}',GETDATE(),GETDATE(),2,0,0,'会员卡号：{4}')",
管理卡号, 机头.商户号, 机头.常规.机头编号, AlertType, IC卡号码);
//ac.Execute(dbsql);
XCCloudRS232BLL.ExecuteSql(dbsql);
}
}
}
break;
case 4: //常规解锁，解除报警，修改数据库
{
if (机头.状态.超级解锁卡标识) //超级管理卡
{
AlertType = "超级卡解锁常规锁定";
string dbsql = string.Format("INSERT INTO flw_game_alarm VALUES ('{0}','{1}','{2}','{3}',GETDATE(),null,0,0,0,'会员卡号：{4}')",
管理卡号, 机头.商户号, 机头.常规.机头编号, AlertType, IC卡号码);
//ac.Execute(dbsql);
XCCloudRS232BLL.ExecuteSql(dbsql);
}
string usql = string.Format("update flw_game_alarm set EndTime=GETDATE(),ICCardID='{2}',`state`=1 where `state`=0 and LockGame=1 and MerchID='{0}' and DeviceID='{1}'", 机头.商户号, 机头.常规.机头编号, 管理卡号);
//ac.Execute(usql);
XCCloudRS232BLL.ExecuteSql(usql);
}
break;
case 5:
{
if (机头.状态.超级解锁卡标识) //超级管理卡
{
AlertType = "超级卡解锁退币锁定";
string dbsql = string.Format("INSERT INTO flw_game_alarm VALUES ('{0}','{1}','{2}','{3}',GETDATE(),null,0,0,0,'会员卡号：{4}')",
管理卡号, 机头.商户号, 机头.常规.机头编号, AlertType, IC卡号码);
//ac.Execute(dbsql);
XCCloudRS232BLL.ExecuteSql(dbsql);
}
}
break;
default:
break;
}
if (处理结果 == 1)
{
机头.常规.当前卡片号 = "";
}
应答数据 = new Ask.Ask机头卡片报警指令(机头地址, 流水号);
UDPServerHelper.InsertRepeat(f.routeAddress, 机头地址, IC卡号码, CommandType.机头卡片报警指令, CommandType.机头卡片报警指令应答, 应答数据, 流水号, RecvDateTime);
}
else if (res == 1)
{
应答数据 = (Ask.Ask机头卡片报警指令)obj;
}
else
{
//重复性检查出错
return;
}
byte[] dataBuf = PubLib.GetBytesByObject(应答数据);
SendData = PubLib.GetFrameDataBytes(f, dataBuf, CommandType.机头卡片报警指令应答);
SendDataTime = DateTime.Now;
}
public void Run(FrameData data)
{
try
{
登记用户数 = data.commandData[0];
for (int i = 1; i < data.commandLength; i++)
{
bool changed = false; //状态是否改变
bool isAlert = false;
bool isLock = false;
int gInCoin, gOutCoin, headCount;
int alertCount = 0;
string 机头地址 = PubLib.Hex2String(data.commandData[i]);
Info.HeadInfo.机头绑定信息 bind = new Info.HeadInfo.机头绑定信息();
bind.控制器令牌 = data.Code;
bind.短地址 = 机头地址;
Info.HeadInfo.机头信息 机头 = Info.HeadInfo.GetHeadInfoByShort(bind);
if (机头 != null)
{
机头.是否从雷达获取到状态 = true;
Info.HeadInfo.机头干扰开关 报警 = new Info.HeadInfo.机头干扰开关();
i++;
if (i < data.commandLength)
{
string status = PubLib.Hex2BitString(data.commandData[i]);
bool OnlineFlag = (status.Substring(7, 1) == "1");
changed = (机头.状态.在线状态 != OnlineFlag);
if (OnlineFlag)
{
机头.在线检测计数 = 0;
机头.状态.在线状态 = true;
}
else
{
机头.在线检测计数++;
if (机头.在线检测计数 > 2)
{
机头.状态.在线状态 = false;
}
}
if (机头.状态.在线状态)
{
机头.状态.打印机故障 = (status.Substring(6, 1) == "1");
if (机头.报警回调数据.打印机故障 != 机头.状态.打印机故障)
{
机头.报警回调数据.打印机故障 = 机头.状态.打印机故障;
UpdateAlertDB(机头地址, 机头.状态.打印机故障, "打印机故障", 0, bind.控制器令牌);
alertCount++;
isAlert = true;
}
机头.状态.打印设置错误 = (status.Substring(5, 1) == "1");
if (机头.报警回调数据.打印设置错误 != 机头.状态.打印设置错误)
{
机头.报警回调数据.打印设置错误 = 机头.状态.打印设置错误;
UpdateAlertDB(机头地址, 机头.状态.打印设置错误, "打印设置错误", 0, bind.控制器令牌);
alertCount++;
isAlert = true;
}
机头.状态.读币器故障 = (status.Substring(3, 1) == "1");
if (机头.报警回调数据.读币器故障 != 机头.状态.读币器故障)
{
机头.报警回调数据.读币器故障 = 机头.状态.读币器故障;
UpdateAlertDB(机头地址, 机头.状态.读币器故障, "读币器故障", 0, bind.控制器令牌);
alertCount++;
isAlert = true;
}
机头.状态.锁定机头 = (status.Substring(0, 1) == "1");
isLock = 机头.状态.锁定机头;
}
}
i++;
if (i < data.commandLength)
{
if (机头.状态.在线状态)
{
string status = PubLib.Hex2BitString(data.commandData[i]);
报警.高频干扰报警 = (status.Substring(7, 1) == "1");
if (机头.报警回调数据.高频干扰报警 != 报警.高频干扰报警)
{
机头.报警回调数据.高频干扰报警 = 报警.高频干扰报警;
if (报警.高频干扰报警)
{
UpdateAlertDB(机头地址, 报警.高频干扰报警, "高频干扰报警", 1, bind.控制器令牌);
alertCount++;
}
isAlert = true;
isLock = true;
}
报警.高压干扰报警 = (status.Substring(6, 1) == "1");
if (机头.报警回调数据.高压干扰报警 != 报警.高压干扰报警)
{
机头.报警回调数据.高压干扰报警 = 报警.高压干扰报警;
if (报警.高压干扰报警 && alertCount < 4)
{
UpdateAlertDB(机头地址, 报警.高压干扰报警, "高压干扰报警", 1, bind.控制器令牌);
alertCount++;
}
isAlert = true;
isLock = true;
}
报警.SSR信号异常 = (status.Substring(5, 1) == "1");
if (机头.报警回调数据.SSR信号异常 != 报警.SSR信号异常)
{
机头.报警回调数据.SSR信号异常 = 报警.SSR信号异常;
if (报警.SSR信号异常 && alertCount < 4)
{
UpdateAlertDB(机头地址, 报警.SSR信号异常, "SSR信号异常", 1, bind.控制器令牌);
alertCount++;
}
isAlert = true;
isLock = true;
}
报警.CO信号异常 = (status.Substring(4, 1) == "1");
if (机头.报警回调数据.CO信号异常 != 报警.CO信号异常)
{
机头.报警回调数据.CO信号异常 = 报警.CO信号异常;
if (报警.CO信号异常 && alertCount < 4)
{
UpdateAlertDB(机头地址, 报警.CO信号异常, "CO信号异常", 1, bind.控制器令牌);
alertCount++;
}
isAlert = true;
isLock = true;
}
报警.CO2信号异常 = (status.Substring(3, 1) == "1");
if (机头.报警回调数据.CO2信号异常 != 报警.CO2信号异常)
{
机头.报警回调数据.CO2信号异常 = 报警.CO2信号异常;
if (报警.CO2信号异常 && alertCount < 4)
{
UpdateAlertDB(机头地址, 报警.CO2信号异常, "CO2信号异常", 1, bind.控制器令牌);
alertCount++;
}
isAlert = true;
isLock = true;
}
if (机头.类型 == Info.HeadInfo.设备类型.存币机)
{
机头.状态.存币箱是否满 = (status.Substring(2, 1) == "1");
if (机头.报警回调数据.存币箱满报警 != 机头.状态.存币箱是否满)
{
机头.报警回调数据.存币箱满报警 = 机头.状态.存币箱是否满;
if (alertCount < 4)
{
UpdateAlertDB(机头地址, 机头.状态.存币箱是否满, "存币箱满报警", 0, bind.控制器令牌);
alertCount++;
}
isAlert = true;
}
}
else
{
机头.状态.是否正在使用限时送分优惠 = (status.Substring(2, 1) == "1");
}
机头.状态.锁定机头 = isLock;
}
}
//if (!changed && alertCount > 0)
//changed = true;
//if (changed)
//{
// if (状态.在线状态)
// {
// if (isAlert)
// FrmMain.GetInterface.ChangeDeviceStatus(机头.常规.机头长地址, XCSocketService.DeviceStatusEnum.故障);
// else
// {
// if (状态.锁定机头)
// FrmMain.GetInterface.ChangeDeviceStatus(机头.常规.机头长地址, XCSocketService.DeviceStatusEnum.锁定);
// else
// {
// if (状态.出币机或存币机正在数币)
// FrmMain.GetInterface.ChangeDeviceStatus(机头.常规.机头长地址, XCSocketService.DeviceStatusEnum.出币中);
// else
// FrmMain.GetInterface.ChangeDeviceStatus(机头.常规.机头长地址, XCSocketService.DeviceStatusEnum.在线);
// }
// }
// }
// else
// FrmMain.GetInterface.ChangeDeviceStatus(机头.常规.机头长地址, XCSocketService.DeviceStatusEnum.离线);
//}
//Info.HeadInfo.GetCoinByGame(机头.常规.游戏机编号, out gInCoin, out gOutCoin, out headCount);
//h.hAddress = 机头地址;
//h.InCoins = 机头.投币.投币数;
//h.OutCoins = 机头.投币.退币数;
//h.WinCoins = 机头.投币.盈利数;
//h.IsInCoin = false;
//h.IsOnline = 状态.在线状态;
//h.IsOutCoin = false;
//h.IsLock = isLock;
//h.IsOver = (0 - 机头.投币.盈利数 > 机头.投币.每天净退币上限);
//h.GameInCoins = gInCoin;
//h.GameOutCoins = gOutCoin;
//h.GameWinCoins = gInCoin - gOutCoin;
//if (机头.状态.锁定机头)
//{
// h.IsLock = true;
//}
//else
//{
// if (机头.开关.退币超限标志 && !机头.状态.是否忽略超分报警)
// {
// h.IsOver = true;
// }
//}
//h.rAddress = PubLib.路由器段号;
//listStatus.Add(h);
//Info.HeadInfo.Update(PubLib.路由器段号, 机头地址, 状态, 报警);
}
}
//ServiceDll.ClientCall.机头状态汇报(listStatus.ToArray());
}
catch
{
throw;
}
}