예제 #1
0
        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());
        }
예제 #2
0
        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;
            }
        }