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 void RunCallBack(IAsyncResult ar)
//{
// AsyncResult result = (AsyncResult)ar;
// DelegRun d = (DelegRun)result.AsyncDelegate;
// d.EndInvoke(ar);
//}
public Recv机头网络状态报告(FrameData data)
{
//RecvData = data;
//DelegRun a = Run;
//a.BeginInvoke(data, new AsyncCallback(RunCallBack), null);
Run(data);
SendData = PubLib.GetFrameDataBytes(data, null, CommandType.机头网络状态报告应答);
SendDate = DateTime.Now;
}
public string GetRecvData(DateTime printDate)
{
StringBuilder sb = new StringBuilder();
//sb.Append("=============================================\r\n");
sb.AppendFormat("{0:yyyy-MM-dd HH:mm:ss.fff} 收到数据\r\n", printDate);
sb.Append(PubLib.BytesToString(RecvData.recvData) + Environment.NewLine);
sb.AppendFormat("指令类别：{0}\r\n", RecvData.commandType);
return(sb.ToString());
}
public string GetSendData()
{
StringBuilder sb = new StringBuilder();
//sb.Append("=============================================\r\n");
sb.AppendFormat("{0:yyyy-MM-dd HH:mm:ss.fff} 发送数据\r\n", SendDate);
sb.Append(PubLib.BytesToString(SendData) + Environment.NewLine);
sb.AppendFormat("指令类别：{0}\r\n", RecvData.commandType);
sb.AppendFormat("路由器地址：{0}\r\n", RecvData.routeAddress);
return(sb.ToString());
}
public string GetSendData()
{
StringBuilder sb = new StringBuilder();
sb = new StringBuilder();
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.AppendFormat("机头地址：{0}\r\n", 机头地址);
sb.AppendFormat("长地址：{0}\r\n", MCUID);
return(sb.ToString());
}
public string GetSendData()
{
StringBuilder sb = new StringBuilder();
if (SendData != null)
{
//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.AppendFormat("指令类别：{0}\r\n", CommandType.机头卡片报警指令应答);
sb.AppendFormat("机头地址：{0}\r\n", 机头地址);
sb.AppendFormat("流水号：{0}\r\n", 流水号);
}
return(sb.ToString());
}
public string GetRecvData(DateTime printDate)
{
StringBuilder sb = new StringBuilder();
//sb.Append("=============================================\r\n");
sb.AppendFormat("{0:yyyy-MM-dd HH:mm:ss.fff} 收到数据\r\n", DateTime.Now);
sb.AppendFormat("{0}\r\n", PubLib.BytesToString(RecvData.recvData));
sb.AppendFormat("指令类别：{0}\r\n", RecvData.commandType);
sb.AppendFormat("IC卡号码：{0}\r\n", IC卡号码);
sb.AppendFormat("卡片类型：{0}\r\n", 卡片类型);
sb.AppendFormat("报警类别：{0}\r\n", AlertType);
sb.AppendFormat("处理结果：{0}\r\n", 处理结果 == 1 ? "是" : "否");
sb.AppendFormat("流水号：{0}\r\n", 流水号);
return(sb.ToString());
}
public string GetRecvData(DateTime printDate)
{
StringBuilder sb = new StringBuilder();
//sb.Append("=============================================\r\n");
sb.AppendFormat("{0:yyyy-MM-dd HH:mm:ss.fff} 收到数据\r\n", DateTime.Now);
sb.AppendFormat("{0}\r\n", PubLib.BytesToString(RecvData.recvData));
sb.AppendFormat("指令类别：{0}\r\n", RecvData.commandType);
sb.AppendFormat("IC卡号码：{0}\r\n", IC卡号码);
sb.AppendFormat("动态密码：{0}\r\n", 动态密码);
sb.AppendFormat("控制类型：{0}\r\n", 控制类型.ToDescription());
sb.AppendFormat("币数：{0}\r\n", 币数);
sb.AppendFormat("流水号：{0}\r\n", 流水号);
sb.AppendFormat("机头地址：{0}\r\n", 机头地址);
return(sb.ToString());
}
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 Ask卡头进出币数据应答(Info.HeadInfo.机头信息 head, string IC, int Coins, CoinType cType, byte checkCode, UInt16 SN, FrameData frame, bool isPush, string PushAddr, ref string msg)
{
try
{
Info.HeadInfo.IC卡进出币控制信号结构 信号 = new Info.HeadInfo.IC卡进出币控制信号结构();
机头地址 = Convert.ToByte(head.常规.机头地址, 16);
流水号 = SN;
控制类型 = (byte)cType;
#region 内存查询方法
Info.HeadInfo.IC卡模式进出币应答结构 投币 = 卡头进出币(head, IC, Coins, SN, cType, checkCode, ref msg, isPush, PushAddr);
if (投币 != null)
{
信号.保留0当前卡是否允许上分 = 投币.机头能上分;
信号.保留1当前卡是否允许退分 = 投币.机头能打票;
信号.保留2是否启用卡片专卡专用功能 = 投币.是否启用卡片专卡专用;
信号.保留3超出当日机头最大净退币上线 = 投币.超出当日机头最大净退币上线;
信号.保留4是否将退币上回游戏机 = 投币.是否将退币上回游戏机;
信号.保留5是否正在使用限时送分优惠券 = 投币.是否正在使用限时送分优惠券;
币余额 = 投币.币余额;
冲数 = (short)投币.发脉冲数;
}
else
{
LogHelper.WriteLog("IC卡进出币数据有误\r\n" + msg, frame.recvData);
}
#endregion
控制信号 = PubLib.GetBitByObject(信号);
}
catch
{
//LogHelper.WriteLog("IC卡进出币数据有误\r\n" + msg, frame.recvData);
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;
}
}
public Ask终端参数申请(Info.HeadInfo.机头绑定信息 Bind)
{
try
{
游戏机机头编号 = "0000A";
Info.HeadInfo.机头信息 机头 = Info.HeadInfo.GetHeadInfoByShort(Bind);
机头地址 = Convert.ToByte(Bind.短地址, 16);
//DataAccess ac = new DataAccess();
//DataTable dt = ac.ExecuteQueryReturnTable(string.Format("select g.* from Data_MerchSegment s,Base_DeviceInfo d,Data_GameInfo g where d.ID=s.DeviceID and g.GroupID=s.GroupID and d.SN='{0}'", 机头.常规.机头长地址));
DataTable dt = XCCloudRS232BLL.ExecuterSqlToTable(string.Format("select g.* from Data_MerchSegment s,Base_DeviceInfo d,Data_GameInfo g where d.ID=s.DeviceID and g.GroupID=s.GroupID and d.SN='{0}'", 机头.常规.机头长地址));
if (dt.Rows.Count > 0)
{
DataRow row = dt.Rows[0];
效期天数 = (byte)机头.打印小票有效天数;
机头.彩票模式 = (row["LotteryMode"].ToString() == "1");
单次退币限额 = Convert.ToUInt16(row["OnceOutLimit"]);
机头.参数.单次退币限额 = 单次退币限额;
机头.参数.投币时扣卡上币数 = Convert.ToByte(row["PushReduceFromCard"]);
//扣卡里币基数 = (byte)机头.参数.投币时扣卡上币数;
机头.参数.投币时给游戏机信号数 = Convert.ToUInt16(row["PushAddToGame"]);
机头.参数.第二路上分线投币时扣卡上币数 = Convert.ToInt32(row["SecondReduceFromCard"]);
机头.参数.第二路上分线投币时给游戏机信号数 = Convert.ToInt32(row["SecondAddToGame"]);
退币时给游戏机脉冲数比例因子 = Convert.ToByte(row["OutReduceFromGame"]);
机头.参数.退币时给游戏机脉冲数比例因子 = 退币时给游戏机脉冲数比例因子;
退币时卡上增加币数比例因子 = Convert.ToByte(row["OutAddToCard"]);
机头.参数.退币时卡上增加币数比例因子 = 退币时卡上增加币数比例因子;
退币按钮脉宽 = Convert.ToUInt16(row["BOPulse"]);
机头.参数.退币按钮脉宽 = 退币按钮脉宽;
游戏机维修开关信号1 开关信号1 = new 游戏机维修开关信号1();
开关信号1.bit0允许电子退币或允许打票 = Convert.ToBoolean(row["AllowElecOut"]);
机头.开关.允许电子退币或允许打票 = 开关信号1.bit0允许电子退币或允许打票;
开关信号1.bit1允许电子投币 = Convert.ToBoolean(row["AllowElecPush"]);
机头.开关.允许电子投币 = 开关信号1.bit1允许电子投币;
开关信号1.bit2允许十倍投币 = Convert.ToBoolean(row["AllowDecuplePush"]);
机头.开关.允许十倍投币 = 开关信号1.bit2允许十倍投币;
开关信号1.bit3允许实物退币 = Convert.ToBoolean(row["AllowRealOut"]);
机头.开关.允许实物退币 = 开关信号1.bit3允许实物退币;
开关信号1.bit4转发实物投币 = Convert.ToBoolean(row["AllowRealPush"]);
机头.开关.转发实物投币 = 开关信号1.bit4转发实物投币;
//开关信号1.bit5硬件投币控制 = Convert.ToBoolean(row["PushControl"]);
//机头.开关.硬件投币控制 = 开关信号1.bit5硬件投币控制;
开关信号1.bit6投币脉冲电平 = Convert.ToBoolean(row["PushLevel"]);
机头.开关.投币脉冲电平 = 开关信号1.bit6投币脉冲电平;
开关信号1.bit7第二路上分线上分电平 = Convert.ToBoolean(row["SecondLevel"]);
机头.开关.第二路上分线上分电平 = 开关信号1.bit7第二路上分线上分电平;
开关信号1.bit8SSR退币驱动脉冲电平 = Convert.ToBoolean(row["OutLevel"]);
机头.开关.SSR退币驱动脉冲电平 = 开关信号1.bit8SSR退币驱动脉冲电平;
开关信号1.bit9数币脉冲电平 = Convert.ToBoolean(row["CountLevel"]);
机头.开关.数币脉冲电平 = 开关信号1.bit9数币脉冲电平;
开关信号1.bit10启用第二路上分信号 = Convert.ToBoolean(row["UseSecondPush"]);
机头.开关.启用第二路上分信号 = 开关信号1.bit10启用第二路上分信号;
开关1 = PubLib.GetBit16ByObject(开关信号1);
游戏机维修开关信号2 开关信号2 = new 游戏机维修开关信号2();
开关信号2.bit0退币超限标志 = ((机头.投币.盈利数 > 机头.投币.每天净退币上限) && !机头.状态.是否忽略超分报警);
机头.开关.退币超限标志 = 开关信号2.bit0退币超限标志;
开关信号2.bit1启用专卡专用 = Convert.ToBoolean(row["GuardConvertCard"]);
机头.开关.启用专卡专用 = 开关信号2.bit1启用专卡专用;
开关信号2.bit2BO按钮是否维持 = Convert.ToBoolean(row["BOKeep"]);
机头.开关.BO按钮是否维持 = 开关信号2.bit2BO按钮是否维持;
开关信号2.bit3退分锁定标志 = Convert.ToBoolean(row["BOLock"]);
机头.开关.退分锁定标志 = 开关信号2.bit3退分锁定标志;
开关信号2.bit4启用异常退币检测 = Convert.ToBoolean(row["ExceptOutTest"]);
机头.开关.启用异常退币检测 = 开关信号2.bit4启用异常退币检测;
开关信号2.bit5启用即中即退模式 = Convert.ToBoolean(row["NowExit"]);
机头.开关.启用即中即退模式 = 开关信号2.bit5启用即中即退模式;
开关信号2.bit6启用外部报警检测 = Convert.ToBoolean(row["OutsideAlertCheck"]);
机头.开关.启用外部报警检测 = 开关信号2.bit6启用外部报警检测;
开关信号2.bit7启用回路报警检测 = Convert.ToBoolean(row["ReturnCheck"]);
机头.开关.启用回路报警检测 = 开关信号2.bit7启用回路报警检测;
开关信号2.bit8启用增强防止转卡 = Convert.ToBoolean(row["StrongGuardConvertCard"]);
机头.开关.增强防止转卡 = 开关信号2.bit8启用增强防止转卡;
开关信号2.bit9启用刷卡即扣 = Convert.ToBoolean(row["ReadCat"]);
机头.开关.启动刷卡即扣 = 开关信号2.bit9启用刷卡即扣;
开关信号2.bit10启用刷卡版彩票功能 = Convert.ToBoolean(row["ICTicketOperation"]);
机头.开关.启用刷卡版彩票 = 开关信号2.bit10启用刷卡版彩票功能;
开关信号2.bit11启用防霸位功能 = Convert.ToBoolean(row["BanOccupy"]);
机头.开关.启用防霸位功能 = 开关信号2.bit11启用防霸位功能;
开关信号2.bit12只退实物彩票 = Convert.ToBoolean(row["OnlyExitLottery"]);
机头.开关.只退实物彩票 = 开关信号2.bit12只退实物彩票;
开关信号2.bit13启用彩票模式 = 机头.彩票模式;
开关信号2.bit14小票是否打印二维码 = 机头.开关.小票是否打印二维码;
开关2 = PubLib.GetBit16ByObject(开关信号2);
首次投币启动间隔 = Convert.ToByte(row["PushStartInterval"]);
机头.参数.首次投币启动间隔 = 首次投币启动间隔;
投币速度 = Convert.ToUInt16(row["PushSpeed"]);
机头.参数.投币速度 = 投币速度;
投币脉宽 = Convert.ToByte(row["PushPulse"]);
机头.参数.投币脉宽 = 投币脉宽;
第二路上分线首次上分启动间隔 = Convert.ToByte(row["SecondStartInterval"]);
机头.参数.第二路上分线首次上分启动间隔 = 第二路上分线首次上分启动间隔;
第二路上分线上分速度 = Convert.ToUInt16(row["SecondSpeed"]);
机头.参数.第二路上分线上分速度 = 第二路上分线上分速度;
第二路上分线上分脉宽 = Convert.ToByte(row["SecondPulse"]);
机头.参数.第二路上分线上分脉宽 = 第二路上分线上分脉宽;
退币速度 = Convert.ToUInt16(row["OutSpeed"]);
机头.参数.退币速度 = 退币速度;
退币脉宽 = Convert.ToByte(row["OutPulse"]);
机头.参数.退币脉宽 = 退币脉宽;
机头.投币.单次退币上限 = 单次退币限额;
机头.投币.每天净退币上限 = Convert.ToInt32(row["OneDayPureOutLimit"]);
//游戏机机头编号 = 机头.常规.机头编号;
异常检测时间 = Convert.ToByte(row["ExceptOutSpeed"]);
机头.参数.异常SSR退币检测速度 = 异常检测时间;
异常检测次数 = Convert.ToByte(row["Frequency"]);
机头.参数.异常SSR退币检测次数 = 异常检测次数;
if (机头.开关.启用第二路上分信号)
{
扣卡里币基数 = (byte)机头.参数.第二路上分线投币时扣卡上币数;
}
else
{
扣卡里币基数 = (byte)机头.参数.投币时扣卡上币数;
}
本店卡校验密码 = 机头.店密码;
}
}
catch
{
throw;
}
}