TLClient_JSSCOM_LuatOS-Air_V4002_RDA8910_RFTTS_0xe0000,2.5.4,866250064330701,25966726016712,
poweron reason:0

===08:59:24===
上一时间戳为1727399108
隔日重置时间戳true
隔日清空未同步下发列表true
当前排队号为950,音量为7
初始化产品信息:[{"time_limit_date":"","ticket_category":"0","expiry_date":7,"product_detail":"","time_limit_status":"0","begin_minute":"00","product_uid":"14871571925148490799","use_timer":1,"old_price":"20","end_hour":"23","sale_price":"10","end_minute":"59","begin_hour":"00","sale_status":1,"product_name":"本票当天有效过去作废"}]
打印门店标题设置为韩尚快剪鹏瑞利店
是否打印二维码设置为0
是否打印紧凑设置为3
session_id:d105a****6092e
纸币器设置接收纸币范围为36
欢迎使用天羚自助售票系统[2.5.4]
定时检测未同步订单启用
2024-09-28 08:58:23>>>cash write=30
2024-09-28 08:58:23>>>cash write=02
2024-09-28 08:58:23>>>cash write=3E
2024-09-28 08:58:23>>>cash read=808F808F808F
系统时间初始化成功，时间为202492885823
2024-09-28 08:58:24>>>cash write=02
2024-09-28 08:58:24 >>>剩余flash空间=1680500,占用RAM为628.9541015625
2024-09-28 08:58:24 >>>回调事件:910,subscribe,10000,连接服务器成功

2024-09-28 08:58:25 >>>剩余flash空间=1680000,占用RAM为600.859375
2024-09-28 08:58:25 >>>回调事件:911,GetMqttQueue,500,暂无需要下发的信息，请求类型：ticket

2024-09-28 08:58:27>>>cash write=0C
2024-09-28 08:58:27>>>cash read=3E
流量卡还有33天过期
2024-09-28 08:58:31 >>>当前Ram内存为631.478515625


===09:00:24===
定时检测未同步订单关闭
检测订单目录中>>>
无未同步订单>>>


===09:05:24===
2024-09-28 09:04:59>>>cash read=9E
2024-09-28 09:05:00>>>cash read=3E


===09:07:24===
2024-09-28 09:06:53 >>>回调事件[910,devices/YC0471]
当日首次设置时间戳true为1727485613
2024-09-28 09:06:53 >>>故障排除日志:上一MQTT订单号缓存列表为24092721161977828823
2024-09-28 09:06:53 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 09:06:53 开始打印,排队:950,票券:2409280906438226178601,订单:24092809064382258185,[2024-09-28 09:06:51微信支付10元]
2024-09-28 09:06:53 开始打印,排队:951,票券:2409280906438226315802,订单:24092809064382258185,[2024-09-28 09:06:51微信支付10元]
2024-09-28 09:06:57 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409280906438226178601","queue_number":950,"trade_uid":"24092809064382258185"},{"ticket_no":"2409280906438226315802","queue_number":951,"trade_uid":"24092809064382258185"}]}
2024-09-28 09:06:57 >>>故障排除日志:删除未同步下发订单成功24092809064382258185
2024-09-28 09:06:57 >>>故障排除日志:删除未同步下发订单成功24092809064382258185
2024-09-28 09:06:57 >>>故障排除日志:终端同步成功后剩余订单列表


===09:14:25===
2024-09-28 09:13:45 >>>回调事件[910,devices/YC0471]
2024-09-28 09:13:45 >>>故障排除日志:上一MQTT订单号缓存列表为24092809064382258185|24092809064382258185
2024-09-28 09:13:45 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 09:13:45 开始打印,排队:952,票券:2409280913377562394501,订单:24092809133775620147,[2024-09-28 09:13:44微信支付10元]
2024-09-28 09:13:47 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409280913377562394501","queue_number":952,"trade_uid":"24092809133775620147"}]}
2024-09-28 09:13:47 >>>故障排除日志:删除未同步下发订单成功24092809133775620147
2024-09-28 09:13:47 >>>故障排除日志:终端同步成功后剩余订单列表


===09:23:25===
2024-09-28 09:23:17 >>>回调事件[910,devices/YC0471]
2024-09-28 09:23:17 >>>故障排除日志:上一MQTT订单号缓存列表为24092809133775620147
2024-09-28 09:23:17 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 09:23:17 开始打印,排队:953,票券:2409280923042762581001,订单:24092809230427621421,[2024-09-28 09:23:15微信支付10元]
2024-09-28 09:23:19 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409280923042762581001","queue_number":953,"trade_uid":"24092809230427621421"}]}
2024-09-28 09:23:19 >>>故障排除日志:删除未同步下发订单成功24092809230427621421
2024-09-28 09:23:19 >>>故障排除日志:终端同步成功后剩余订单列表


===09:26:25===
2024-09-28 09:26:02 >>>回调事件[910,devices/YC0471]
2024-09-28 09:26:02 >>>故障排除日志:上一MQTT订单号缓存列表为24092809230427621421
2024-09-28 09:26:02 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 09:26:02 开始打印,排队:954,票券:2409280925541476320101,订单:24092809255414756004,[2024-09-28 09:26:02微信支付10元]
2024-09-28 09:26:04 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409280925541476320101","queue_number":954,"trade_uid":"24092809255414756004"}]}
2024-09-28 09:26:04 >>>故障排除日志:删除未同步下发订单成功24092809255414756004
2024-09-28 09:26:04 >>>故障排除日志:终端同步成功后剩余订单列表


===09:29:26===
2024-09-28 09:28:50 >>>回调事件[910,devices/YC0471]
2024-09-28 09:28:50 >>>故障排除日志:上一MQTT订单号缓存列表为24092809255414756004
2024-09-28 09:28:50 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 09:28:50 开始打印,排队:955,票券:2409280928406168029501,订单:24092809284061675817,[2024-09-28 09:28:48微信支付10元]
2024-09-28 09:28:52 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409280928406168029501","queue_number":955,"trade_uid":"24092809284061675817"}]}
2024-09-28 09:28:52 >>>故障排除日志:删除未同步下发订单成功24092809284061675817
2024-09-28 09:28:52 >>>故障排除日志:终端同步成功后剩余订单列表


===09:34:26===
2024-09-28 09:34:08>>>cash read=9E
2024-09-28 09:34:09>>>cash read=3E


===09:47:26===
2024-09-28 09:46:37 >>>回调事件[910,devices/YC0471]
2024-09-28 09:46:37 >>>故障排除日志:上一MQTT订单号缓存列表为24092809284061675817
2024-09-28 09:46:37 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 09:46:37 开始打印,排队:956,票券:2409280946271865809701,订单:24092809462718652269,[2024-09-28 09:46:36支付宝支付10元]
2024-09-28 09:46:39 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409280946271865809701","queue_number":956,"trade_uid":"24092809462718652269"}]}
2024-09-28 09:46:39 >>>故障排除日志:删除未同步下发订单成功24092809462718652269
2024-09-28 09:46:39 >>>故障排除日志:终端同步成功后剩余订单列表


===09:53:27===
2024-09-28 09:53:15>>>cash read=9E
2024-09-28 09:53:17>>>cash read=3E


===09:54:27===
2024-09-28 09:53:57 >>>回调事件[910,devices/YC0471]
2024-09-28 09:53:57 >>>故障排除日志:上一MQTT订单号缓存列表为24092809462718652269
2024-09-28 09:53:57 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 09:53:57 开始打印,排队:957,票券:2409280953471020109101,订单:24092809534710196197,[2024-09-28 09:53:56微信支付10元]
2024-09-28 09:53:59 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409280953471020109101","queue_number":957,"trade_uid":"24092809534710196197"}]}
2024-09-28 09:53:59 >>>故障排除日志:删除未同步下发订单成功24092809534710196197
2024-09-28 09:53:59 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 09:54:06 >>>回调事件[910,devices/YC0471]
2024-09-28 09:54:06 >>>故障排除日志:上一MQTT订单号缓存列表为24092809534710196197
2024-09-28 09:54:06 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 09:54:06 开始打印,排队:958,票券:2409280954000783412501,订单:24092809540007829754,[2024-09-28 09:54:06微信支付10元]
2024-09-28 09:54:08 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409280954000783412501","queue_number":958,"trade_uid":"24092809540007829754"}]}
2024-09-28 09:54:08 >>>故障排除日志:删除未同步下发订单成功24092809540007829754
2024-09-28 09:54:08 >>>故障排除日志:终端同步成功后剩余订单列表


===09:56:27===
2024-09-28 09:56:16>>>cash read=00
2024-09-28 09:56:16>>>cash read=818F42
2024-09-28 09:56:16>>>cash write=02
2024-09-28 09:56:16 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-09-28 09:56:17>>>cash read=10
2024-09-28 09:56:17 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-09-28 09:56:17 当前产品价格10元，投币10元，打印小票中...
2024-09-28 09:56:17 >>>开始打印,排队号为959,订单号为2409280956170004714009
2024-09-28 09:56:17>>>订单2409280956170004714009写入成功,剩余空间为1680000,占用RAM为607.001953125
删除未同步订单2409280956170004714009
2024-09-28 09:56:19>>>订单2409280956170004714009删除成功,剩余空间为1680500,占用RAM为623.4716796875
检测订单目录中>>>
无未同步订单>>>
2024-09-28 09:56:19 >>>当前Ram内存为590.7822265625
定时检测未同步订单启用
2024-09-28 09:56:20>>>cash write=0C
2024-09-28 09:56:20>>>cash read=3E


===09:57:27===
定时检测未同步订单关闭
检测订单目录中>>>
无未同步订单>>>


===09:59:28===
2024-09-28 09:58:47>>>cash read=29
2024-09-28 09:58:47 >>>回调事件130,cash_status,20029,退钞中
2024-09-28 09:58:48>>>cash read=01
2024-09-28 09:58:50>>>cash read=3E
2024-09-28 09:58:53>>>cash read=00
2024-09-28 09:58:54>>>cash read=29
2024-09-28 09:58:54 >>>回调事件130,cash_status,20029,退钞中
2024-09-28 09:58:54>>>cash read=2F29
2024-09-28 09:58:55>>>cash read=01
2024-09-28 09:58:55>>>cash read=2F
2024-09-28 09:58:57>>>cash read=3E
2024-09-28 09:59:04>>>cash read=00
2024-09-28 09:59:06>>>cash read=818F42
2024-09-28 09:59:06>>>cash write=02
2024-09-28 09:59:06 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-09-28 09:59:06>>>cash read=10
2024-09-28 09:59:06 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-09-28 09:59:06 当前产品价格10元，投币10元，打印小票中...
2024-09-28 09:59:06 >>>开始打印,排队号为960,订单号为2409280959060004713158
2024-09-28 09:59:06>>>订单2409280959060004713158写入成功,剩余空间为1679500,占用RAM为610.9375
删除未同步订单2409280959060004713158
2024-09-28 09:59:09>>>订单2409280959060004713158删除成功,剩余空间为1680000,占用RAM为619.60546875
检测订单目录中>>>
无未同步订单>>>
2024-09-28 09:59:09 >>>当前Ram内存为591.4287109375
定时检测未同步订单启用
2024-09-28 09:59:09>>>cash write=0C
2024-09-28 09:59:10>>>cash read=3E


===10:00:28===
2024-09-28 09:59:53 >>>回调事件[910,devices/YC0471]
2024-09-28 09:59:53 >>>故障排除日志:上一MQTT订单号缓存列表为24092809540007829754
2024-09-28 09:59:53 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 09:59:53 开始打印,排队:961,票券:2409280959455592755601,订单:24092809594555922683,[2024-09-28 09:59:53微信支付10元]
2024-09-28 09:59:55 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409280959455592755601","queue_number":961,"trade_uid":"24092809594555922683"}]}
2024-09-28 09:59:55 >>>故障排除日志:删除未同步下发订单成功24092809594555922683
2024-09-28 09:59:55 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单关闭
检测订单目录中>>>
无未同步订单>>>


===10:01:28===
2024-09-28 10:00:46 >>>回调事件[910,devices/YC0471]
2024-09-28 10:00:46 >>>故障排除日志:上一MQTT订单号缓存列表为24092809594555922683
2024-09-28 10:00:46 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 10:00:46 开始打印,排队:962,票券:2409281000370096251901,订单:24092810003700957283,[2024-09-28 10:00:45微信支付10元]
2024-09-28 10:00:48 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281000370096251901","queue_number":962,"trade_uid":"24092810003700957283"}]}
2024-09-28 10:00:48 >>>故障排除日志:删除未同步下发订单成功24092810003700957283
2024-09-28 10:00:48 >>>故障排除日志:终端同步成功后剩余订单列表


===10:06:29===
2024-09-28 10:05:32 >>>回调事件[910,devices/YC0471]
2024-09-28 10:05:32 >>>故障排除日志:上一MQTT订单号缓存列表为24092810003700957283
2024-09-28 10:05:32 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 10:05:32 开始打印,排队:963,票券:2409281005243073875001,订单:24092810052430734405,[2024-09-28 10:05:31微信支付10元]
2024-09-28 10:05:34 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281005243073875001","queue_number":963,"trade_uid":"24092810052430734405"}]}
2024-09-28 10:05:34 >>>故障排除日志:删除未同步下发订单成功24092810052430734405
2024-09-28 10:05:34 >>>故障排除日志:终端同步成功后剩余订单列表


===10:09:29===
2024-09-28 10:08:35 >>>回调事件[910,devices/YC0471]
2024-09-28 10:08:35 >>>故障排除日志:上一MQTT订单号缓存列表为24092810052430734405
2024-09-28 10:08:35 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 10:08:35 开始打印,排队:964,票券:2409281008288933825301,订单:24092810082889330968,[2024-09-28 10:08:34微信支付10元]
2024-09-28 10:08:37 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281008288933825301","queue_number":964,"trade_uid":"24092810082889330968"}]}
2024-09-28 10:08:37 >>>故障排除日志:删除未同步下发订单成功24092810082889330968
2024-09-28 10:08:37 >>>故障排除日志:终端同步成功后剩余订单列表


===10:10:29===
2024-09-28 10:10:20 >>>回调事件[910,devices/YC0471]
2024-09-28 10:10:20 >>>故障排除日志:上一MQTT订单号缓存列表为24092810082889330968
2024-09-28 10:10:20 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 10:10:20 开始打印,排队:965,票券:2409281010104404699401,订单:24092810101044042298,[2024-09-28 10:10:19微信支付10元]
2024-09-28 10:10:22 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281010104404699401","queue_number":965,"trade_uid":"24092810101044042298"}]}
2024-09-28 10:10:22 >>>故障排除日志:删除未同步下发订单成功24092810101044042298
2024-09-28 10:10:22 >>>故障排除日志:终端同步成功后剩余订单列表


===10:15:29===
2024-09-28 10:14:53 >>>回调事件[910,devices/YC0471]
2024-09-28 10:14:53 >>>故障排除日志:上一MQTT订单号缓存列表为24092810101044042298
2024-09-28 10:14:53 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 10:14:53 开始打印,排队:966,票券:2409281014462588637001,订单:24092810144625881516,[2024-09-28 10:14:52微信支付10元]
2024-09-28 10:14:55 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281014462588637001","queue_number":966,"trade_uid":"24092810144625881516"}]}
2024-09-28 10:14:55 >>>故障排除日志:删除未同步下发订单成功24092810144625881516
2024-09-28 10:14:55 >>>故障排除日志:终端同步成功后剩余订单列表


===10:18:30===
2024-09-28 10:18:12 >>>回调事件[910,devices/YC0471]
2024-09-28 10:18:12 >>>故障排除日志:上一MQTT订单号缓存列表为24092810144625881516
2024-09-28 10:18:12 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 10:18:12 开始打印,排队:967,票券:2409281018058517966001,订单:24092810180585175553,[2024-09-28 10:18:10微信支付10元]
2024-09-28 10:18:14 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281018058517966001","queue_number":967,"trade_uid":"24092810180585175553"}]}
2024-09-28 10:18:14 >>>故障排除日志:删除未同步下发订单成功24092810180585175553
2024-09-28 10:18:14 >>>故障排除日志:终端同步成功后剩余订单列表


===10:21:30===
2024-09-28 10:21:24 >>>回调事件[910,devices/YC0471]
2024-09-28 10:21:24 >>>故障排除日志:上一MQTT订单号缓存列表为24092810180585175553
2024-09-28 10:21:24 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 10:21:24 开始打印,排队:968,票券:2409281021171188841901,订单:24092810211711883080,[2024-09-28 10:21:23微信支付10元]
2024-09-28 10:21:26 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281021171188841901","queue_number":968,"trade_uid":"24092810211711883080"}]}
2024-09-28 10:21:26 >>>故障排除日志:删除未同步下发订单成功24092810211711883080
2024-09-28 10:21:26 >>>故障排除日志:终端同步成功后剩余订单列表


===10:27:30===
2024-09-28 10:26:41 >>>回调事件[910,devices/YC0471]
2024-09-28 10:26:41 >>>故障排除日志:上一MQTT订单号缓存列表为24092810211711883080
2024-09-28 10:26:41 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 10:26:41 开始打印,排队:969,票券:2409281026302091795601,订单:24092810263020912491,[2024-09-28 10:26:41微信支付10元]
2024-09-28 10:26:43 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281026302091795601","queue_number":969,"trade_uid":"24092810263020912491"}]}
2024-09-28 10:26:43 >>>故障排除日志:删除未同步下发订单成功24092810263020912491
2024-09-28 10:26:43 >>>故障排除日志:终端同步成功后剩余订单列表


===10:28:30===
2024-09-28 10:27:57>>>cash read=0A
2024-09-28 10:27:58>>>cash read=3E


===10:31:31===
2024-09-28 10:30:43 >>>回调事件[910,devices/YC0471]
2024-09-28 10:30:43 >>>故障排除日志:上一MQTT订单号缓存列表为24092810263020912491
2024-09-28 10:30:43 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 10:30:43 开始打印,排队:970,票券:2409281030369218087201,订单:24092810303692176381,[2024-09-28 10:30:43支付宝支付10元]
2024-09-28 10:30:43 开始打印,排队:971,票券:2409281030369218267402,订单:24092810303692176381,[2024-09-28 10:30:43支付宝支付10元]
2024-09-28 10:30:47 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281030369218087201","queue_number":970,"trade_uid":"24092810303692176381"},{"ticket_no":"2409281030369218267402","queue_number":971,"trade_uid":"24092810303692176381"}]}
2024-09-28 10:30:47 >>>故障排除日志:删除未同步下发订单成功24092810303692176381
2024-09-28 10:30:47 >>>故障排除日志:删除未同步下发订单成功24092810303692176381
2024-09-28 10:30:47 >>>故障排除日志:终端同步成功后剩余订单列表


===10:38:31===
2024-09-28 10:37:43>>>cash read=9E
2024-09-28 10:37:45>>>cash read=3E
2024-09-28 10:37:46>>>cash read=00
2024-09-28 10:37:47>>>cash read=818F42
2024-09-28 10:37:47>>>cash write=02
2024-09-28 10:37:47 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-09-28 10:37:47>>>cash read=10
2024-09-28 10:37:47 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-09-28 10:37:47 当前产品价格10元，投币10元，打印小票中...
2024-09-28 10:37:47 >>>开始打印,排队号为972,订单号为2409281037470004712282
2024-09-28 10:37:48>>>订单2409281037470004712282写入成功,剩余空间为1679500,占用RAM为610.5615234375
删除未同步订单2409281037470004712282
2024-09-28 10:37:50>>>订单2409281037470004712282删除成功,剩余空间为1680500,占用RAM为619.98046875
检测订单目录中>>>
无未同步订单>>>
2024-09-28 10:37:50 >>>当前Ram内存为592.7490234375
定时检测未同步订单启用
2024-09-28 10:37:51>>>cash write=0C
2024-09-28 10:37:51>>>cash read=3E


===10:39:31===
2024-09-28 10:38:48 >>>回调事件[910,devices/YC0471]
2024-09-28 10:38:48 >>>故障排除日志:上一MQTT订单号缓存列表为24092810303692176381|24092810303692176381
2024-09-28 10:38:48 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 10:38:48 开始打印,排队:973,票券:2409281038407899491301,订单:24092810384078991421,[2024-09-28 10:38:48微信支付10元]
定时检测未同步订单关闭
检测订单目录中>>>
无未同步订单>>>
2024-09-28 10:38:50 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281038407899491301","queue_number":973,"trade_uid":"24092810384078991421"}]}
2024-09-28 10:38:50 >>>故障排除日志:删除未同步下发订单成功24092810384078991421
2024-09-28 10:38:50 >>>故障排除日志:终端同步成功后剩余订单列表


===10:41:32===
2024-09-28 10:40:35>>>cash read=00
2024-09-28 10:40:35>>>cash read=818F42
2024-09-28 10:40:35>>>cash write=02
2024-09-28 10:40:35 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-09-28 10:40:36>>>cash read=10
2024-09-28 10:40:36 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-09-28 10:40:36 当前产品价格10元，投币10元，打印小票中...
2024-09-28 10:40:36 >>>开始打印,排队号为974,订单号为2409281040360004711431
2024-09-28 10:40:36>>>订单2409281040360004711431写入成功,剩余空间为1680000,占用RAM为608.4921875
删除未同步订单2409281040360004711431
2024-09-28 10:40:38>>>订单2409281040360004711431删除成功,剩余空间为1680500,占用RAM为619.8046875
检测订单目录中>>>
无未同步订单>>>
2024-09-28 10:40:38 >>>当前Ram内存为591.1474609375
定时检测未同步订单启用
2024-09-28 10:40:39>>>cash write=0C
2024-09-28 10:40:39>>>cash read=3E
2024-09-28 10:40:42 >>>回调事件[910,devices/YC0471]
2024-09-28 10:40:42 >>>故障排除日志:上一MQTT订单号缓存列表为24092810384078991421
2024-09-28 10:40:42 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 10:40:42 开始打印,排队:975,票券:2409281040334448411901,订单:24092810403344480768,[2024-09-28 10:40:42微信支付10元]
2024-09-28 10:40:44 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281040334448411901","queue_number":975,"trade_uid":"24092810403344480768"}]}
2024-09-28 10:40:44 >>>故障排除日志:删除未同步下发订单成功24092810403344480768
2024-09-28 10:40:44 >>>故障排除日志:终端同步成功后剩余订单列表


===10:42:32===
定时检测未同步订单关闭
检测订单目录中>>>
无未同步订单>>>


===10:49:32===
2024-09-28 10:49:15 >>>回调事件[910,devices/YC0471]
2024-09-28 10:49:15 >>>故障排除日志:上一MQTT订单号缓存列表为24092810403344480768
2024-09-28 10:49:15 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 10:49:15 开始打印,排队:976,票券:2409281049090759736801,订单:24092810490907592807,[2024-09-28 10:49:15微信支付10元]
2024-09-28 10:49:17 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281049090759736801","queue_number":976,"trade_uid":"24092810490907592807"}]}
2024-09-28 10:49:17 >>>故障排除日志:删除未同步下发订单成功24092810490907592807
2024-09-28 10:49:17 >>>故障排除日志:终端同步成功后剩余订单列表


===10:51:33===
2024-09-28 10:51:16>>>cash read=00
2024-09-28 10:51:17>>>cash read=818F42
2024-09-28 10:51:17>>>cash write=02
2024-09-28 10:51:17 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-09-28 10:51:18>>>cash read=10
2024-09-28 10:51:18 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-09-28 10:51:18 当前产品价格10元，投币10元，打印小票中...
2024-09-28 10:51:18 >>>开始打印,排队号为977,订单号为2409281051180004719254
2024-09-28 10:51:18>>>订单2409281051180004719254写入成功,剩余空间为1680000,占用RAM为608.7421875
删除未同步订单2409281051180004719254
2024-09-28 10:51:20>>>订单2409281051180004719254删除成功,剩余空间为1680500,占用RAM为618.61328125
检测订单目录中>>>
无未同步订单>>>
2024-09-28 10:51:20 >>>当前Ram内存为591.3623046875
定时检测未同步订单启用
2024-09-28 10:51:21>>>cash write=0C
2024-09-28 10:51:21>>>cash read=3E
2024-09-28 10:51:23>>>cash read=00
2024-09-28 10:51:24>>>cash read=818F42
2024-09-28 10:51:24>>>cash write=02
2024-09-28 10:51:24 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-09-28 10:51:25>>>cash read=10
2024-09-28 10:51:25 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-09-28 10:51:25 当前产品价格10元，投币10元，打印小票中...
2024-09-28 10:51:25 >>>开始打印,排队号为978,订单号为2409281051250004716763
定时检测未同步订单关闭
2024-09-28 10:51:25>>>订单2409281051250004716763写入成功,剩余空间为1679000,占用RAM为615.2294921875
删除未同步订单2409281051250004716763
2024-09-28 10:51:27>>>订单2409281051250004716763删除成功,剩余空间为1679500,占用RAM为623.5810546875
检测订单目录中>>>
无未同步订单>>>
2024-09-28 10:51:27 >>>当前Ram内存为593.396484375
定时检测未同步订单启用
2024-09-28 10:51:28>>>cash write=0C
2024-09-28 10:51:28>>>cash read=3E


===10:52:33===
2024-09-28 10:52:00>>>cash read=9E
2024-09-28 10:52:01>>>cash read=3E
定时检测未同步订单关闭
检测订单目录中>>>
无未同步订单>>>


===10:56:33===
2024-09-28 10:56:17 >>>回调事件[910,devices/YC0471]
2024-09-28 10:56:17 >>>故障排除日志:上一MQTT订单号缓存列表为24092810490907592807
2024-09-28 10:56:17 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 10:56:17 开始打印,排队:979,票券:2409281056120601114501,订单:24092810561206007146,[2024-09-28 10:56:17微信支付10元]
2024-09-28 10:56:19 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281056120601114501","queue_number":979,"trade_uid":"24092810561206007146"}]}
2024-09-28 10:56:19 >>>故障排除日志:删除未同步下发订单成功24092810561206007146
2024-09-28 10:56:19 >>>故障排除日志:终端同步成功后剩余订单列表


===10:58:34===
2024-09-28 10:58:29 >>>回调事件[910,devices/YC0471]
2024-09-28 10:58:29 >>>故障排除日志:上一MQTT订单号缓存列表为24092810561206007146
2024-09-28 10:58:29 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 10:58:29 开始打印,排队:980,票券:2409281058212978722001,订单:24092810582129782549,[2024-09-28 10:58:27微信支付10元]
2024-09-28 10:58:31 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281058212978722001","queue_number":980,"trade_uid":"24092810582129782549"}]}
2024-09-28 10:58:31 >>>故障排除日志:删除未同步下发订单成功24092810582129782549
2024-09-28 10:58:31 >>>故障排除日志:终端同步成功后剩余订单列表


===11:06:34===
2024-09-28 11:05:58 >>>回调事件[910,devices/YC0471]
2024-09-28 11:05:58 >>>故障排除日志:上一MQTT订单号缓存列表为24092810582129782549
2024-09-28 11:05:58 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 11:05:58 开始打印,排队:981,票券:2409281105502863836201,订单:24092811055028633095,[2024-09-28 11:05:56微信支付10元]
2024-09-28 11:05:58 开始打印,排队:982,票券:2409281105502864032102,订单:24092811055028633095,[2024-09-28 11:05:56微信支付10元]
2024-09-28 11:06:02 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281105502863836201","queue_number":981,"trade_uid":"24092811055028633095"},{"ticket_no":"2409281105502864032102","queue_number":982,"trade_uid":"24092811055028633095"}]}
2024-09-28 11:06:02 >>>故障排除日志:删除未同步下发订单成功24092811055028633095
2024-09-28 11:06:02 >>>故障排除日志:删除未同步下发订单成功24092811055028633095
2024-09-28 11:06:02 >>>故障排除日志:终端同步成功后剩余订单列表


===11:08:34===
2024-09-28 11:07:43 >>>回调事件[910,devices/YC0471]
2024-09-28 11:07:43 >>>故障排除日志:上一MQTT订单号缓存列表为24092811055028633095|24092811055028633095
2024-09-28 11:07:43 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 11:07:43 开始打印,排队:983,票券:2409281107318156708601,订单:24092811073181562952,[2024-09-28 11:07:41微信支付10元]
2024-09-28 11:07:43 开始打印,排队:984,票券:2409281107318156858702,订单:24092811073181562952,[2024-09-28 11:07:41微信支付10元]
2024-09-28 11:07:47 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281107318156708601","queue_number":983,"trade_uid":"24092811073181562952"},{"ticket_no":"2409281107318156858702","queue_number":984,"trade_uid":"24092811073181562952"}]}
2024-09-28 11:07:47 >>>故障排除日志:删除未同步下发订单成功24092811073181562952
2024-09-28 11:07:47 >>>故障排除日志:删除未同步下发订单成功24092811073181562952
2024-09-28 11:07:47 >>>故障排除日志:终端同步成功后剩余订单列表


===11:09:35===
2024-09-28 11:09:15 >>>回调事件[910,devices/YC0471]
2024-09-28 11:09:15 >>>故障排除日志:上一MQTT订单号缓存列表为24092811073181562952|24092811073181562952
2024-09-28 11:09:15 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 11:09:15 开始打印,排队:985,票券:2409281109084152861601,订单:24092811090841524370,[2024-09-28 11:09:14微信支付10元]
2024-09-28 11:09:17 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281109084152861601","queue_number":985,"trade_uid":"24092811090841524370"}]}
2024-09-28 11:09:17 >>>故障排除日志:删除未同步下发订单成功24092811090841524370
2024-09-28 11:09:17 >>>故障排除日志:终端同步成功后剩余订单列表


===11:12:35===
2024-09-28 11:11:48 >>>回调事件[910,devices/YC0471]
2024-09-28 11:11:48 >>>故障排除日志:上一MQTT订单号缓存列表为24092811090841524370
2024-09-28 11:11:48 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 11:11:48 开始打印,排队:986,票券:2409281111415898165701,订单:24092811114158976842,[2024-09-28 11:11:47微信支付10元]
2024-09-28 11:11:50 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281111415898165701","queue_number":986,"trade_uid":"24092811114158976842"}]}
2024-09-28 11:11:50 >>>故障排除日志:删除未同步下发订单成功24092811114158976842
2024-09-28 11:11:50 >>>故障排除日志:终端同步成功后剩余订单列表


===11:28:35===
2024-09-28 11:28:13 >>>回调事件[910,devices/YC0471]
2024-09-28 11:28:13 >>>故障排除日志:上一MQTT订单号缓存列表为24092811114158976842
2024-09-28 11:28:13 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 11:28:13 开始打印,排队:987,票券:2409281128064440344701,订单:24092811280644398943,[2024-09-28 11:28:11微信支付10元]
2024-09-28 11:28:15 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281128064440344701","queue_number":987,"trade_uid":"24092811280644398943"}]}
2024-09-28 11:28:15 >>>故障排除日志:删除未同步下发订单成功24092811280644398943
2024-09-28 11:28:15 >>>故障排除日志:终端同步成功后剩余订单列表


===11:36:36===
2024-09-28 11:36:28 >>>回调事件[910,devices/YC0471]
2024-09-28 11:36:28 >>>故障排除日志:上一MQTT订单号缓存列表为24092811280644398943
2024-09-28 11:36:28 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 11:36:28 开始打印,排队:988,票券:2409281136220260864201,订单:24092811362202604778,[2024-09-28 11:36:28微信支付10元]
2024-09-28 11:36:30 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281136220260864201","queue_number":988,"trade_uid":"24092811362202604778"}]}
2024-09-28 11:36:30 >>>故障排除日志:删除未同步下发订单成功24092811362202604778
2024-09-28 11:36:30 >>>故障排除日志:终端同步成功后剩余订单列表


===11:40:36===
2024-09-28 11:40:13>>>cash read=9E
2024-09-28 11:40:14>>>cash read=3E


===11:41:37===
2024-09-28 11:41:34 >>>回调事件[910,devices/YC0471]
2024-09-28 11:41:34 >>>故障排除日志:上一MQTT订单号缓存列表为24092811362202604778
2024-09-28 11:41:34 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 11:41:34 开始打印,排队:989,票券:2409281141262552227801,订单:24092811412625516537,[2024-09-28 11:41:33微信支付10元]


===11:42:37===
2024-09-28 11:41:36 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281141262552227801","queue_number":989,"trade_uid":"24092811412625516537"}]}
2024-09-28 11:41:36 >>>故障排除日志:删除未同步下发订单成功24092811412625516537
2024-09-28 11:41:36 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 11:42:08 >>>回调事件[910,devices/YC0471]
2024-09-28 11:42:08 >>>故障排除日志:上一MQTT订单号缓存列表为24092811412625516537
2024-09-28 11:42:08 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 11:42:08 开始打印,排队:990,票券:2409281141544872603601,订单:24092811415448721426,[2024-09-28 11:42:07微信支付10元]
2024-09-28 11:42:10 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281141544872603601","queue_number":990,"trade_uid":"24092811415448721426"}]}
2024-09-28 11:42:10 >>>故障排除日志:删除未同步下发订单成功24092811415448721426
2024-09-28 11:42:10 >>>故障排除日志:终端同步成功后剩余订单列表


===11:43:37===
2024-09-28 11:43:10>>>cash read=9E
2024-09-28 11:43:11>>>cash read=3E


===11:46:37===
2024-09-28 11:46:29 >>>回调事件[910,devices/YC0471]
2024-09-28 11:46:29 >>>故障排除日志:上一MQTT订单号缓存列表为24092811415448721426
2024-09-28 11:46:29 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 11:46:29 开始打印,排队:991,票券:2409281146225298506801,订单:24092811462252981331,[2024-09-28 11:46:28支付宝支付10元]
2024-09-28 11:46:31 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281146225298506801","queue_number":991,"trade_uid":"24092811462252981331"}]}
2024-09-28 11:46:31 >>>故障排除日志:删除未同步下发订单成功24092811462252981331
2024-09-28 11:46:31 >>>故障排除日志:终端同步成功后剩余订单列表


===11:55:38===
2024-09-28 11:54:57>>>cash read=9E
2024-09-28 11:54:58>>>cash read=3E


===11:56:38===
2024-09-28 11:56:19 >>>回调事件[910,devices/YC0471]
2024-09-28 11:56:19 >>>故障排除日志:上一MQTT订单号缓存列表为24092811462252981331
2024-09-28 11:56:19 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 11:56:19 开始打印,排队:992,票券:2409281156116115258001,订单:24092811561161148213,[2024-09-28 11:56:18微信支付10元]
2024-09-28 11:56:21 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281156116115258001","queue_number":992,"trade_uid":"24092811561161148213"}]}
2024-09-28 11:56:21 >>>故障排除日志:删除未同步下发订单成功24092811561161148213
2024-09-28 11:56:21 >>>故障排除日志:终端同步成功后剩余订单列表


===12:02:38===
2024-09-28 12:01:54>>>cash read=9E
2024-09-28 12:01:55>>>cash read=3E


===12:07:38===
2024-09-28 12:07:21>>>cash read=BF
2024-09-28 12:07:22>>>cash read=3E


===12:17:39===
2024-09-28 12:17:07>>>cash read=00
2024-09-28 12:17:07>>>cash read=818F42
2024-09-28 12:17:07>>>cash write=02
2024-09-28 12:17:07 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-09-28 12:17:08>>>cash read=10
2024-09-28 12:17:08 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-09-28 12:17:08 当前产品价格10元，投币10元，打印小票中...
2024-09-28 12:17:08 >>>开始打印,排队号为993,订单号为2409281217080004717128
2024-09-28 12:17:08>>>订单2409281217080004717128写入成功,剩余空间为1680000,占用RAM为608.712890625
删除未同步订单2409281217080004717128
2024-09-28 12:17:10>>>订单2409281217080004717128删除成功,剩余空间为1680500,占用RAM为618.587890625
检测订单目录中>>>
无未同步订单>>>
2024-09-28 12:17:10 >>>当前Ram内存为591.3544921875
定时检测未同步订单启用
2024-09-28 12:17:11>>>cash write=0C
2024-09-28 12:17:11>>>cash read=3E


===12:18:39===
定时检测未同步订单关闭
检测订单目录中>>>
无未同步订单>>>


===12:20:40===
2024-09-28 12:20:36 >>>回调事件[910,devices/YC0471]
2024-09-28 12:20:37 >>>故障排除日志:上一MQTT订单号缓存列表为24092811561161148213
2024-09-28 12:20:37 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 12:20:37 开始打印,排队:994,票券:2409281220293029741201,订单:24092812202930292735,[2024-09-28 12:20:35支付宝支付10元]


===12:21:40===
2024-09-28 12:20:39 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281220293029741201","queue_number":994,"trade_uid":"24092812202930292735"}]}
2024-09-28 12:20:39 >>>故障排除日志:删除未同步下发订单成功24092812202930292735
2024-09-28 12:20:39 >>>故障排除日志:终端同步成功后剩余订单列表


===12:24:40===
2024-09-28 12:24:10>>>cash read=9E
2024-09-28 12:24:11>>>cash read=3E


===12:37:40===
2024-09-28 12:37:22 收到下发指令:叫号951>>>
2024-09-28 12:37:23 收到下发指令:叫号952>>>
2024-09-28 12:37:24 收到下发指令:叫号953>>>
2024-09-28 12:37:25 收到下发指令:叫号954>>>
2024-09-28 12:37:26 收到下发指令:叫号955>>>
2024-09-28 12:37:27 收到下发指令:叫号956>>>
2024-09-28 12:37:27 收到下发指令:叫号957>>>
2024-09-28 12:37:28 收到下发指令:叫号958>>>
2024-09-28 12:37:29 收到下发指令:叫号959>>>
2024-09-28 12:37:29 收到下发指令:叫号960>>>
2024-09-28 12:37:31 收到下发指令:叫号961>>>
2024-09-28 12:37:31 收到下发指令:叫号962>>>
2024-09-28 12:37:31 收到下发指令:叫号963>>>
2024-09-28 12:37:32 收到下发指令:叫号964>>>
2024-09-28 12:37:33 收到下发指令:叫号965>>>
2024-09-28 12:37:33 收到下发指令:叫号966>>>
2024-09-28 12:37:34 收到下发指令:叫号967>>>
2024-09-28 12:37:35 收到下发指令:叫号968>>>


===12:39:41===
2024-09-28 12:39:28>>>cash read=9E
2024-09-28 12:39:29>>>cash read=3E


===12:44:41===
2024-09-28 12:44:27>>>cash read=9E
2024-09-28 12:44:28>>>cash read=3E


===12:47:41===
2024-09-28 12:47:22 >>>回调事件[910,devices/YC0471]
2024-09-28 12:47:22 >>>故障排除日志:上一MQTT订单号缓存列表为24092812202930292735
2024-09-28 12:47:22 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 12:47:22 开始打印,排队:995,票券:2409281247144985331501,订单:24092812471449849195,[2024-09-28 12:47:21微信支付10元]
2024-09-28 12:47:24 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281247144985331501","queue_number":995,"trade_uid":"24092812471449849195"}]}
2024-09-28 12:47:24 >>>故障排除日志:删除未同步下发订单成功24092812471449849195
2024-09-28 12:47:24 >>>故障排除日志:终端同步成功后剩余订单列表


===12:53:42===
2024-09-28 12:53:19>>>cash read=00
2024-09-28 12:53:20>>>cash read=818F42
2024-09-28 12:53:20>>>cash write=02
2024-09-28 12:53:20 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-09-28 12:53:20>>>cash read=10
2024-09-28 12:53:20 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-09-28 12:53:20 当前产品价格10元，投币10元，打印小票中...
2024-09-28 12:53:20 >>>开始打印,排队号为996,订单号为2409281253200004717484
2024-09-28 12:53:21>>>订单2409281253200004717484写入成功,剩余空间为1680000,占用RAM为609.060546875
删除未同步订单2409281253200004717484
2024-09-28 12:53:23>>>订单2409281253200004717484删除成功,剩余空间为1680500,占用RAM为623.1044921875
检测订单目录中>>>
无未同步订单>>>
2024-09-28 12:53:23 >>>当前Ram内存为591.5439453125
定时检测未同步订单启用
2024-09-28 12:53:24>>>cash write=0C
2024-09-28 12:53:24>>>cash read=3E


===12:54:42===
定时检测未同步订单关闭
检测订单目录中>>>
无未同步订单>>>


===12:56:42===
2024-09-28 12:55:51 >>>回调事件[910,devices/YC0471]
2024-09-28 12:55:51 >>>故障排除日志:上一MQTT订单号缓存列表为24092812471449849195
2024-09-28 12:55:51 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 12:55:51 开始打印,排队:997,票券:2409281255445764026101,订单:24092812554457636625,[2024-09-28 12:55:50微信支付10元]
2024-09-28 12:55:51 开始打印,排队:998,票券:2409281255445764179202,订单:24092812554457636625,[2024-09-28 12:55:50微信支付10元]
2024-09-28 12:55:55 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281255445764026101","queue_number":997,"trade_uid":"24092812554457636625"},{"ticket_no":"2409281255445764179202","queue_number":998,"trade_uid":"24092812554457636625"}]}
2024-09-28 12:55:55 >>>故障排除日志:删除未同步下发订单成功24092812554457636625
2024-09-28 12:55:55 >>>故障排除日志:删除未同步下发订单成功24092812554457636625
2024-09-28 12:55:55 >>>故障排除日志:终端同步成功后剩余订单列表


===13:00:43===
2024-09-28 13:00:12 >>>回调事件[910,devices/YC0471]
2024-09-28 13:00:12 >>>故障排除日志:上一MQTT订单号缓存列表为24092812554457636625|24092812554457636625
2024-09-28 13:00:12 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 13:00:12 开始打印,排队:999,票券:2409281300030428970501,订单:24092813000304284496,[2024-09-28 13:00:11微信支付10元]
2024-09-28 13:00:14 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281300030428970501","queue_number":999,"trade_uid":"24092813000304284496"}]}
2024-09-28 13:00:14 >>>故障排除日志:删除未同步下发订单成功24092813000304284496
2024-09-28 13:00:14 >>>故障排除日志:终端同步成功后剩余订单列表


===13:03:43===
2024-09-28 13:03:18 >>>回调事件[910,devices/YC0471]
2024-09-28 13:03:18 >>>故障排除日志:上一MQTT订单号缓存列表为24092813000304284496
2024-09-28 13:03:18 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 13:03:18 开始打印,排队:1000,票券:2409281303116846621801,订单:24092813031168460895,[2024-09-28 13:03:17微信支付10元]
2024-09-28 13:03:20 >>>回调事件[910,devices/YC0471]
2024-09-28 13:03:20 >>>故障排除日志:上一MQTT订单号缓存列表为24092813031168460895
2024-09-28 13:03:20 >>>故障排除日志:终端未同步成功订单列表100024092813031168460895
已接收过此消息,票券号为2409281303116846621801,排队号为1000
2024-09-28 13:03:20 开始打印,排队:1001,票券:2409281303124963410301,订单:24092813031249629392,[2024-09-28 13:03:19微信支付10元]
2024-09-28 13:03:22 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281303116846621801","queue_number":1000,"trade_uid":"24092813031168460895"}]}
2024-09-28 13:03:22 >>>故障排除日志:删除未同步下发订单成功24092813031168460895
2024-09-28 13:03:22 >>>故障排除日志:终端同步成功后剩余订单列表100124092813031249629392
2024-09-28 13:03:22 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281303116846621801","queue_number":1000,"trade_uid":"24092813031168460895"},{"ticket_no":"2409281303124963410301","queue_number":1001,"trade_uid":"24092813031249629392"}]}
2024-09-28 13:03:22 >>>故障排除日志:删除未同步下发订单成功24092813031249629392
2024-09-28 13:03:22 >>>故障排除日志:终端同步成功后剩余订单列表


===13:06:44===
2024-09-28 13:06:22 >>>回调事件[910,devices/YC0471]
2024-09-28 13:06:22 >>>故障排除日志:上一MQTT订单号缓存列表为24092813031168460895|24092813031249629392
2024-09-28 13:06:22 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 13:06:22 开始打印,排队:1002,票券:2409281306136916090201,订单:24092813061369157050,[2024-09-28 13:06:22微信支付10元]
2024-09-28 13:06:24 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281306136916090201","queue_number":1002,"trade_uid":"24092813061369157050"}]}
2024-09-28 13:06:24 >>>故障排除日志:删除未同步下发订单成功24092813061369157050
2024-09-28 13:06:24 >>>故障排除日志:终端同步成功后剩余订单列表


===13:19:45===
2024-09-28 13:19:01 >>>回调事件[910,devices/YC0471]
2024-09-28 13:19:01 >>>故障排除日志:上一MQTT订单号缓存列表为24092813061369157050
2024-09-28 13:19:01 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 13:19:01 开始打印,排队:1003,票券:2409281318531121782401,订单:24092813185311214438,[2024-09-28 13:19:01微信支付10元]
2024-09-28 13:19:03 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281318531121782401","queue_number":1003,"trade_uid":"24092813185311214438"}]}
2024-09-28 13:19:03 >>>故障排除日志:删除未同步下发订单成功24092813185311214438
2024-09-28 13:19:03 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 13:19:23 收到下发指令:叫号969>>>


===13:24:45===
2024-09-28 13:24:35 >>>回调事件[910,devices/YC0471]
2024-09-28 13:24:35 >>>故障排除日志:上一MQTT订单号缓存列表为24092813185311214438
2024-09-28 13:24:35 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 13:24:35 开始打印,排队:1004,票券:2409281324282641084001,订单:24092813242826406345,[2024-09-28 13:24:34微信支付10元]
2024-09-28 13:24:37 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281324282641084001","queue_number":1004,"trade_uid":"24092813242826406345"}]}
2024-09-28 13:24:37 >>>故障排除日志:删除未同步下发订单成功24092813242826406345
2024-09-28 13:24:37 >>>故障排除日志:终端同步成功后剩余订单列表


===13:28:45===
2024-09-28 13:28:09>>>cash read=9E
2024-09-28 13:28:10>>>cash read=3E


===13:29:45===
2024-09-28 13:28:45 收到下发指令:叫号970>>>
2024-09-28 13:28:46 收到下发指令:叫号971>>>
2024-09-28 13:28:47 收到下发指令:叫号972>>>
2024-09-28 13:28:48 收到下发指令:叫号973>>>
2024-09-28 13:28:49 收到下发指令:叫号974>>>
2024-09-28 13:28:49 收到下发指令:叫号975>>>
2024-09-28 13:28:50 收到下发指令:叫号976>>>
2024-09-28 13:28:51 收到下发指令:叫号977>>>
2024-09-28 13:28:51 收到下发指令:叫号978>>>
2024-09-28 13:28:52 收到下发指令:叫号979>>>
2024-09-28 13:28:53 收到下发指令:叫号980>>>
2024-09-28 13:28:53 收到下发指令:叫号981>>>
2024-09-28 13:28:53 收到下发指令:叫号982>>>
2024-09-28 13:28:55 收到下发指令:叫号983>>>
2024-09-28 13:28:55 收到下发指令:叫号984>>>
2024-09-28 13:28:56 收到下发指令:叫号985>>>
2024-09-28 13:29:18 >>>回调事件[910,devices/YC0471]
2024-09-28 13:29:18 >>>故障排除日志:上一MQTT订单号缓存列表为24092813242826406345
2024-09-28 13:29:18 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 13:29:18 开始打印,排队:1005,票券:2409281329120013357301,订单:24092813291200077175,[2024-09-28 13:29:17支付宝支付10元]
2024-09-28 13:29:20 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281329120013357301","queue_number":1005,"trade_uid":"24092813291200077175"}]}
2024-09-28 13:29:20 >>>故障排除日志:删除未同步下发订单成功24092813291200077175
2024-09-28 13:29:20 >>>故障排除日志:终端同步成功后剩余订单列表


===13:32:46===
2024-09-28 13:32:25 >>>回调事件[910,devices/YC0471]
2024-09-28 13:32:25 >>>故障排除日志:上一MQTT订单号缓存列表为24092813291200077175
2024-09-28 13:32:25 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 13:32:25 开始打印,排队:1006,票券:2409281332180806549701,订单:24092813321808060504,[2024-09-28 13:32:23微信支付10元]
2024-09-28 13:32:27 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281332180806549701","queue_number":1006,"trade_uid":"24092813321808060504"}]}
2024-09-28 13:32:27 >>>故障排除日志:删除未同步下发订单成功24092813321808060504
2024-09-28 13:32:27 >>>故障排除日志:终端同步成功后剩余订单列表


===13:33:46===
2024-09-28 13:33:18 >>>回调事件[910,devices/YC0471]
2024-09-28 13:33:18 >>>故障排除日志:上一MQTT订单号缓存列表为24092813321808060504
2024-09-28 13:33:18 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 13:33:18 开始打印,排队:1007,票券:2409281333083977701801,订单:24092813330839767754,[2024-09-28 13:33:18微信支付10元]
2024-09-28 13:33:20 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281333083977701801","queue_number":1007,"trade_uid":"24092813330839767754"}]}
2024-09-28 13:33:20 >>>故障排除日志:删除未同步下发订单成功24092813330839767754
2024-09-28 13:33:20 >>>故障排除日志:终端同步成功后剩余订单列表


===13:39:46===
2024-09-28 13:39:15 >>>回调事件[910,devices/YC0471]
2024-09-28 13:39:15 >>>故障排除日志:上一MQTT订单号缓存列表为24092813330839767754
2024-09-28 13:39:15 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 13:39:15 开始打印,排队:1008,票券:2409281339019435214201,订单:24092813390194345986,[2024-09-28 13:39:15微信支付10元]
2024-09-28 13:39:17 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281339019435214201","queue_number":1008,"trade_uid":"24092813390194345986"}]}
2024-09-28 13:39:17 >>>故障排除日志:删除未同步下发订单成功24092813390194345986
2024-09-28 13:39:17 >>>故障排除日志:终端同步成功后剩余订单列表


===13:40:46===
2024-09-28 13:40:40 >>>回调事件[910,devices/YC0471]
2024-09-28 13:40:40 >>>故障排除日志:上一MQTT订单号缓存列表为24092813390194345986
2024-09-28 13:40:40 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 13:40:40 开始打印,排队:1009,票券:2409281340341557140501,订单:24092813403415566991,[2024-09-28 13:40:39微信支付10元]
2024-09-28 13:40:42 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281340341557140501","queue_number":1009,"trade_uid":"24092813403415566991"}]}
2024-09-28 13:40:42 >>>故障排除日志:删除未同步下发订单成功24092813403415566991
2024-09-28 13:40:42 >>>故障排除日志:终端同步成功后剩余订单列表


===13:41:46===
2024-09-28 13:41:05>>>cash read=00
2024-09-28 13:41:06>>>cash read=818F42
2024-09-28 13:41:06>>>cash write=02
2024-09-28 13:41:06 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-09-28 13:41:06>>>cash read=10
2024-09-28 13:41:06 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-09-28 13:41:06 当前产品价格10元，投币10元，打印小票中...
2024-09-28 13:41:06 >>>开始打印,排队号为1010,订单号为2409281341060004719594
2024-09-28 13:41:07>>>订单2409281341060004719594写入成功,剩余空间为1680000,占用RAM为606.95703125
删除未同步订单2409281341060004719594
2024-09-28 13:41:09>>>订单2409281341060004719594删除成功,剩余空间为1680500,占用RAM为616.830078125
检测订单目录中>>>
无未同步订单>>>
2024-09-28 13:41:09 >>>当前Ram内存为589.5380859375
定时检测未同步订单启用
2024-09-28 13:41:10>>>cash write=0C
2024-09-28 13:41:10>>>cash read=3E


===13:42:46===
2024-09-28 13:41:48>>>cash read=9E
2024-09-28 13:41:49>>>cash read=3E
定时检测未同步订单关闭
检测订单目录中>>>
无未同步订单>>>
2024-09-28 13:42:34>>>cash read=00
2024-09-28 13:42:35>>>cash read=818F42
2024-09-28 13:42:35>>>cash write=02
2024-09-28 13:42:35 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-09-28 13:42:35>>>cash read=10
2024-09-28 13:42:35 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-09-28 13:42:35 当前产品价格10元，投币10元，打印小票中...
2024-09-28 13:42:35 >>>开始打印,排队号为1011,订单号为2409281342350004715213
2024-09-28 13:42:35>>>订单2409281342350004715213写入成功,剩余空间为1679500,占用RAM为608.1064453125
删除未同步订单2409281342350004715213
2024-09-28 13:42:38>>>订单2409281342350004715213删除成功,剩余空间为1680500,占用RAM为617.5625
检测订单目录中>>>
无未同步订单>>>
2024-09-28 13:42:38 >>>当前Ram内存为589.9951171875
定时检测未同步订单启用
2024-09-28 13:42:39>>>cash write=0C
2024-09-28 13:42:39>>>cash read=3E


===13:43:47===
2024-09-28 13:43:11 >>>回调事件[910,devices/YC0471]
2024-09-28 13:43:11 >>>故障排除日志:上一MQTT订单号缓存列表为24092813403415566991
2024-09-28 13:43:11 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 13:43:11 开始打印,排队:1012,票券:2409281343025418386501,订单:24092813430254179131,[2024-09-28 13:43:11支付宝支付10元]
2024-09-28 13:43:13 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281343025418386501","queue_number":1012,"trade_uid":"24092813430254179131"}]}
2024-09-28 13:43:13 >>>故障排除日志:删除未同步下发订单成功24092813430254179131
2024-09-28 13:43:13 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单关闭
检测订单目录中>>>
无未同步订单>>>


===13:44:47===
2024-09-28 13:44:29 >>>回调事件[910,devices/YC0471]
2024-09-28 13:44:29 >>>故障排除日志:上一MQTT订单号缓存列表为24092813430254179131
2024-09-28 13:44:29 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 13:44:29 开始打印,排队:1013,票券:2409281344199465409501,订单:24092813441994649710,[2024-09-28 13:44:28微信支付10元]
2024-09-28 13:44:32 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281344199465409501","queue_number":1013,"trade_uid":"24092813441994649710"}]}
2024-09-28 13:44:32 >>>故障排除日志:删除未同步下发订单成功24092813441994649710
2024-09-28 13:44:32 >>>故障排除日志:终端同步成功后剩余订单列表


===13:47:47===
2024-09-28 13:46:53>>>cash read=00
2024-09-28 13:46:54>>>cash read=818F42
2024-09-28 13:46:54>>>cash write=02
2024-09-28 13:46:54 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-09-28 13:46:55>>>cash read=10
2024-09-28 13:46:55 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-09-28 13:46:55 当前产品价格10元，投币10元，打印小票中...
2024-09-28 13:46:55 >>>开始打印,排队号为1014,订单号为2409281346550004713561
2024-09-28 13:46:55>>>订单2409281346550004713561写入成功,剩余空间为1680000,占用RAM为607.20703125
删除未同步订单2409281346550004713561
2024-09-28 13:46:57>>>订单2409281346550004713561删除成功,剩余空间为1680500,占用RAM为617.060546875
检测订单目录中>>>
无未同步订单>>>
2024-09-28 13:46:57 >>>当前Ram内存为589.8037109375
定时检测未同步订单启用
2024-09-28 13:46:58>>>cash write=0C
2024-09-28 13:46:58>>>cash read=3E
2024-09-28 13:47:02>>>cash read=00
2024-09-28 13:47:03>>>cash read=818F42
2024-09-28 13:47:03>>>cash write=02
2024-09-28 13:47:03 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-09-28 13:47:04>>>cash read=10
2024-09-28 13:47:04 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-09-28 13:47:04 当前产品价格10元，投币10元，打印小票中...
2024-09-28 13:47:04 >>>开始打印,排队号为1015,订单号为2409281347040004714650
定时检测未同步订单关闭
2024-09-28 13:47:04>>>订单2409281347040004714650写入成功,剩余空间为1679000,占用RAM为613.62890625
删除未同步订单2409281347040004714650
2024-09-28 13:47:06>>>订单2409281347040004714650删除成功,剩余空间为1679500,占用RAM为619.18359375
检测订单目录中>>>
无未同步订单>>>
2024-09-28 13:47:06 >>>当前Ram内存为590.2099609375
定时检测未同步订单启用
2024-09-28 13:47:07>>>cash write=0C
2024-09-28 13:47:07>>>cash read=3E
2024-09-28 13:47:12>>>cash read=00
2024-09-28 13:47:12>>>cash read=818F42
2024-09-28 13:47:12>>>cash write=02
2024-09-28 13:47:12 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-09-28 13:47:12>>>cash read=10
2024-09-28 13:47:13 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-09-28 13:47:13 当前产品价格10元，投币10元，打印小票中...
2024-09-28 13:47:13 >>>开始打印,排队号为1016,订单号为2409281347130004715739
定时检测未同步订单关闭
2024-09-28 13:47:13>>>订单2409281347130004715739写入成功,剩余空间为1678000,占用RAM为620.478515625
删除未同步订单2409281347130004715739
2024-09-28 13:47:15>>>订单2409281347130004715739删除成功,剩余空间为1678500,占用RAM为622.373046875
检测订单目录中>>>
无未同步订单>>>
2024-09-28 13:47:15 >>>当前Ram内存为591.7119140625
定时检测未同步订单启用
2024-09-28 13:47:16>>>cash write=0C
2024-09-28 13:47:16>>>cash read=3E


===13:48:48===
2024-09-28 13:48:01 >>>回调事件[910,devices/YC0471]
2024-09-28 13:48:01 >>>故障排除日志:上一MQTT订单号缓存列表为24092813441994649710
2024-09-28 13:48:01 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 13:48:01 开始打印,排队:1017,票券:2409281347517117507301,订单:24092813475171168902,[2024-09-28 13:47:59微信支付10元]
2024-09-28 13:48:03 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281347517117507301","queue_number":1017,"trade_uid":"24092813475171168902"}]}
2024-09-28 13:48:03 >>>故障排除日志:删除未同步下发订单成功24092813475171168902
2024-09-28 13:48:03 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单关闭
检测订单目录中>>>
无未同步订单>>>


===13:51:48===
2024-09-28 13:51:36 >>>回调事件[910,devices/YC0471]
2024-09-28 13:51:36 >>>故障排除日志:上一MQTT订单号缓存列表为24092813475171168902
2024-09-28 13:51:36 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 13:51:36 开始打印,排队:1018,票券:2409281351268761131901,订单:24092813512687605685,[2024-09-28 13:51:35支付宝支付10元]
2024-09-28 13:51:38 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281351268761131901","queue_number":1018,"trade_uid":"24092813512687605685"}]}
2024-09-28 13:51:38 >>>故障排除日志:删除未同步下发订单成功24092813512687605685
2024-09-28 13:51:38 >>>故障排除日志:终端同步成功后剩余订单列表


===13:53:48===
2024-09-28 13:53:22 >>>回调事件[910,devices/YC0471]
2024-09-28 13:53:22 >>>故障排除日志:上一MQTT订单号缓存列表为24092813512687605685
2024-09-28 13:53:22 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 13:53:22 开始打印,排队:1019,票券:2409281353148205206701,订单:24092813531482047409,[2024-09-28 13:53:22微信支付10元]
2024-09-28 13:53:24 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281353148205206701","queue_number":1019,"trade_uid":"24092813531482047409"}]}
2024-09-28 13:53:24 >>>故障排除日志:删除未同步下发订单成功24092813531482047409
2024-09-28 13:53:24 >>>故障排除日志:终端同步成功后剩余订单列表


===13:56:49===
2024-09-28 13:56:17 >>>回调事件[910,devices/YC0471]
2024-09-28 13:56:17 >>>故障排除日志:上一MQTT订单号缓存列表为24092813531482047409
2024-09-28 13:56:17 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 13:56:17 开始打印,排队:1020,票券:2409281356095429350701,订单:24092813560954289250,[2024-09-28 13:56:17微信支付10元]
2024-09-28 13:56:19 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281356095429350701","queue_number":1020,"trade_uid":"24092813560954289250"}]}
2024-09-28 13:56:19 >>>故障排除日志:删除未同步下发订单成功24092813560954289250
2024-09-28 13:56:19 >>>故障排除日志:终端同步成功后剩余订单列表


===13:57:49===
2024-09-28 13:56:55 >>>回调事件[910,devices/YC0471]
2024-09-28 13:56:55 >>>故障排除日志:上一MQTT订单号缓存列表为24092813560954289250
2024-09-28 13:56:55 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 13:56:55 开始打印,排队:1021,票券:2409281356455931007301,订单:24092813564559305529,[2024-09-28 13:56:54微信支付10元]
2024-09-28 13:56:57 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281356455931007301","queue_number":1021,"trade_uid":"24092813564559305529"}]}
2024-09-28 13:56:57 >>>故障排除日志:删除未同步下发订单成功24092813564559305529
2024-09-28 13:56:57 >>>故障排除日志:终端同步成功后剩余订单列表


===14:01:49===
2024-09-28 14:00:51>>>cash read=1F
2024-09-28 14:00:52>>>cash read=3E


===14:06:50===
2024-09-28 14:06:18 >>>回调事件[910,devices/YC0471]
2024-09-28 14:06:18 >>>故障排除日志:上一MQTT订单号缓存列表为24092813564559305529
2024-09-28 14:06:18 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 14:06:18 开始打印,排队:1022,票券:2409281406110358195601,订单:24092814061103577959,[2024-09-28 14:06:17支付宝支付10元]
2024-09-28 14:06:20 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281406110358195601","queue_number":1022,"trade_uid":"24092814061103577959"}]}
2024-09-28 14:06:20 >>>故障排除日志:删除未同步下发订单成功24092814061103577959
2024-09-28 14:06:20 >>>故障排除日志:终端同步成功后剩余订单列表


===14:16:50===
2024-09-28 14:16:48>>>cash read=00
2024-09-28 14:16:49>>>cash read=818F42
2024-09-28 14:16:49>>>cash write=02
2024-09-28 14:16:49 >>>回调事件130,cash_status,10022,进钞中...read money=10


===14:17:50===
2024-09-28 14:16:49>>>cash read=10
2024-09-28 14:16:49 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-09-28 14:16:49 当前产品价格10元，投币10元，打印小票中...
2024-09-28 14:16:49 >>>开始打印,排队号为1023,订单号为2409281416490004719123
2024-09-28 14:16:49>>>订单2409281416490004719123写入成功,剩余空间为1680500,占用RAM为609.9111328125
删除未同步订单2409281416490004719123
2024-09-28 14:16:51>>>订单2409281416490004719123删除成功,剩余空间为1681000,占用RAM为616.7578125
检测订单目录中>>>
无未同步订单>>>
2024-09-28 14:16:52 >>>当前Ram内存为589.74609375
定时检测未同步订单启用
2024-09-28 14:16:52>>>cash write=0C
2024-09-28 14:16:52>>>cash read=3E


===14:18:51===
定时检测未同步订单关闭
检测订单目录中>>>
无未同步订单>>>


===14:21:51===
2024-09-28 14:21:17 >>>回调事件[910,devices/YC0471]
2024-09-28 14:21:18 >>>故障排除日志:上一MQTT订单号缓存列表为24092814061103577959
2024-09-28 14:21:18 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 14:21:18 开始打印,排队:1024,票券:2409281421109452122401,订单:24092814211094517478,[2024-09-28 14:21:16微信支付10元]
2024-09-28 14:21:19 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281421109452122401","queue_number":1024,"trade_uid":"24092814211094517478"}]}
2024-09-28 14:21:19 >>>故障排除日志:删除未同步下发订单成功24092814211094517478
2024-09-28 14:21:20 >>>故障排除日志:终端同步成功后剩余订单列表


===14:24:51===
2024-09-28 14:24:42 >>>回调事件[910,devices/YC0471]
2024-09-28 14:24:42 >>>故障排除日志:上一MQTT订单号缓存列表为24092814211094517478
2024-09-28 14:24:42 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 14:24:42 开始打印,排队:1025,票券:2409281424319130324301,订单:24092814243191299270,[2024-09-28 14:24:41微信支付10元]
2024-09-28 14:24:44 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281424319130324301","queue_number":1025,"trade_uid":"24092814243191299270"}]}
2024-09-28 14:24:44 >>>故障排除日志:删除未同步下发订单成功24092814243191299270
2024-09-28 14:24:44 >>>故障排除日志:终端同步成功后剩余订单列表


===14:26:51===
2024-09-28 14:26:45>>>cash read=29
2024-09-28 14:26:45 >>>回调事件130,cash_status,20029,退钞中
2024-09-28 14:26:46>>>cash read=01
2024-09-28 14:26:47>>>cash read=3E


===14:27:52===
2024-09-28 14:27:01>>>cash read=00
2024-09-28 14:27:02>>>cash read=01
2024-09-28 14:27:06>>>cash read=3E
2024-09-28 14:27:22>>>cash read=2F29
2024-09-28 14:27:23>>>cash read=01
2024-09-28 14:27:24>>>cash read=2F
2024-09-28 14:27:26>>>cash read=3E
2024-09-28 14:27:27>>>cash read=00
2024-09-28 14:27:27>>>cash read=818F42
2024-09-28 14:27:27>>>cash write=02
2024-09-28 14:27:27 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-09-28 14:27:27>>>cash read=10
2024-09-28 14:27:27 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-09-28 14:27:27 当前产品价格10元，投币10元，打印小票中...
2024-09-28 14:27:27 >>>开始打印,排队号为1026,订单号为2409281427270004719787
2024-09-28 14:27:28>>>订单2409281427270004719787写入成功,剩余空间为1679500,占用RAM为609.0478515625
删除未同步订单2409281427270004719787
2024-09-28 14:27:30>>>订单2409281427270004719787删除成功,剩余空间为1680500,占用RAM为618.126953125
检测订单目录中>>>
无未同步订单>>>
2024-09-28 14:27:30 >>>当前Ram内存为590.4345703125
定时检测未同步订单启用
2024-09-28 14:27:31>>>cash write=0C
2024-09-28 14:27:31>>>cash read=3E
2024-09-28 14:27:32 >>>回调事件[910,devices/YC0471]
2024-09-28 14:27:32 >>>故障排除日志:上一MQTT订单号缓存列表为24092814243191299270
2024-09-28 14:27:32 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 14:27:32 开始打印,排队:1027,票券:2409281427170277532901,订单:24092814271702770014,[2024-09-28 14:27:32支付宝支付10元]
2024-09-28 14:27:34 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281427170277532901","queue_number":1027,"trade_uid":"24092814271702770014"}]}
2024-09-28 14:27:34 >>>故障排除日志:删除未同步下发订单成功24092814271702770014
2024-09-28 14:27:34 >>>故障排除日志:终端同步成功后剩余订单列表


===14:28:52===
定时检测未同步订单关闭
检测订单目录中>>>
无未同步订单>>>


===14:37:53===
2024-09-28 14:37:49 >>>回调事件[910,devices/YC0471]
2024-09-28 14:37:50 >>>故障排除日志:上一MQTT订单号缓存列表为24092814271702770014
2024-09-28 14:37:50 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 14:37:50 开始打印,排队:1028,票券:2409281437353742750701,订单:24092814373537421457,[2024-09-28 14:37:48支付宝支付10元]


===14:38:53===
2024-09-28 14:37:51 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281437353742750701","queue_number":1028,"trade_uid":"24092814373537421457"}]}
2024-09-28 14:37:51 >>>故障排除日志:删除未同步下发订单成功24092814373537421457
2024-09-28 14:37:52 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 14:38:10 >>>回调事件[910,devices/YC0471]
2024-09-28 14:38:10 >>>故障排除日志:上一MQTT订单号缓存列表为24092814373537421457
2024-09-28 14:38:10 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 14:38:10 开始打印,排队:1029,票券:2409281438046372833101,订单:24092814380463724615,[2024-09-28 14:38:09微信支付10元]
2024-09-28 14:38:12 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281438046372833101","queue_number":1029,"trade_uid":"24092814380463724615"}]}
2024-09-28 14:38:12 >>>故障排除日志:删除未同步下发订单成功24092814380463724615
2024-09-28 14:38:12 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 14:38:47 >>>回调事件[910,devices/YC0471]
2024-09-28 14:38:47 >>>故障排除日志:上一MQTT订单号缓存列表为24092814380463724615
2024-09-28 14:38:47 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 14:38:47 开始打印,排队:1030,票券:2409281438400867248401,订单:24092814384008666131,[2024-09-28 14:38:46微信支付10元]
2024-09-28 14:38:47 开始打印,排队:1031,票券:2409281438400867438302,订单:24092814384008666131,[2024-09-28 14:38:46微信支付10元]
2024-09-28 14:38:51 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281438400867248401","queue_number":1030,"trade_uid":"24092814384008666131"},{"ticket_no":"2409281438400867438302","queue_number":1031,"trade_uid":"24092814384008666131"}]}
2024-09-28 14:38:51 >>>故障排除日志:删除未同步下发订单成功24092814384008666131
2024-09-28 14:38:51 >>>故障排除日志:删除未同步下发订单成功24092814384008666131
2024-09-28 14:38:51 >>>故障排除日志:终端同步成功后剩余订单列表


===14:48:53===
2024-09-28 14:48:36 >>>回调事件[910,devices/YC0471]
2024-09-28 14:48:36 >>>故障排除日志:上一MQTT订单号缓存列表为24092814384008666131|24092814384008666131
2024-09-28 14:48:36 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 14:48:36 开始打印,排队:1032,票券:2409281447556577789401,订单:24092814475565774140,[2024-09-28 14:48:34微信支付10元]
2024-09-28 14:48:38 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281447556577789401","queue_number":1032,"trade_uid":"24092814475565774140"}]}
2024-09-28 14:48:38 >>>故障排除日志:删除未同步下发订单成功24092814475565774140
2024-09-28 14:48:38 >>>故障排除日志:终端同步成功后剩余订单列表


===14:51:54===
2024-09-28 14:51:17 >>>回调事件[910,devices/YC0471]
2024-09-28 14:51:17 >>>故障排除日志:上一MQTT订单号缓存列表为24092814475565774140
2024-09-28 14:51:17 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 14:51:17 开始打印,排队:1033,票券:2409281450584846434601,订单:24092814505848459125,[2024-09-28 14:51:17支付宝支付10元]
2024-09-28 14:51:19 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281450584846434601","queue_number":1033,"trade_uid":"24092814505848459125"}]}
2024-09-28 14:51:19 >>>故障排除日志:删除未同步下发订单成功24092814505848459125
2024-09-28 14:51:19 >>>故障排除日志:终端同步成功后剩余订单列表


===14:56:54===
2024-09-28 14:56:03 >>>回调事件[910,devices/YC0471]
2024-09-28 14:56:03 >>>故障排除日志:上一MQTT订单号缓存列表为24092814505848459125
2024-09-28 14:56:03 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 14:56:03 开始打印,排队:1034,票券:2409281455554757471301,订单:24092814555547568789,[2024-09-28 14:56:02微信支付10元]
2024-09-28 14:56:05 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281455554757471301","queue_number":1034,"trade_uid":"24092814555547568789"}]}
2024-09-28 14:56:05 >>>故障排除日志:删除未同步下发订单成功24092814555547568789
2024-09-28 14:56:05 >>>故障排除日志:终端同步成功后剩余订单列表


===14:59:54===
2024-09-28 14:58:57>>>cash read=1F
2024-09-28 14:58:58>>>cash read=3E
2024-09-28 14:59:21 >>>回调事件[910,devices/YC0471]
2024-09-28 14:59:21 >>>故障排除日志:上一MQTT订单号缓存列表为24092814555547568789
2024-09-28 14:59:21 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 14:59:21 开始打印,排队:1035,票券:2409281459147683906301,订单:24092814591476835775,[2024-09-28 14:59:21微信支付10元]
2024-09-28 14:59:23 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281459147683906301","queue_number":1035,"trade_uid":"24092814591476835775"}]}
2024-09-28 14:59:23 >>>故障排除日志:删除未同步下发订单成功24092814591476835775
2024-09-28 14:59:23 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 14:59:29>>>cash read=9E
2024-09-28 14:59:30>>>cash read=3E


===15:04:55===
2024-09-28 15:04:29 >>>回调事件[910,devices/YC0471]
2024-09-28 15:04:29 >>>故障排除日志:上一MQTT订单号缓存列表为24092814591476835775
2024-09-28 15:04:29 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 15:04:29 开始打印,排队:1036,票券:2409281504213274984701,订单:24092815042132746246,[2024-09-28 15:04:28微信支付10元]
2024-09-28 15:04:31 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281504213274984701","queue_number":1036,"trade_uid":"24092815042132746246"}]}
2024-09-28 15:04:31 >>>故障排除日志:删除未同步下发订单成功24092815042132746246
2024-09-28 15:04:32 >>>故障排除日志:终端同步成功后剩余订单列表


===15:08:55===
2024-09-28 15:08:51 >>>回调事件[910,devices/YC0471]
2024-09-28 15:08:51 >>>故障排除日志:上一MQTT订单号缓存列表为24092815042132746246
2024-09-28 15:08:51 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 15:08:51 开始打印,排队:1037,票券:2409281508441255655601,订单:24092815084412552591,[2024-09-28 15:08:51微信支付10元]
2024-09-28 15:08:53 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281508441255655601","queue_number":1037,"trade_uid":"24092815084412552591"}]}
2024-09-28 15:08:53 >>>故障排除日志:删除未同步下发订单成功24092815084412552591
2024-09-28 15:08:53 >>>故障排除日志:终端同步成功后剩余订单列表


===15:13:55===
2024-09-28 15:13:03 >>>回调事件[910,devices/YC0471]
2024-09-28 15:13:03 >>>故障排除日志:上一MQTT订单号缓存列表为24092815084412552591
2024-09-28 15:13:03 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 15:13:03 开始打印,排队:1038,票券:2409281512457056025201,订单:24092815124570555557,[2024-09-28 15:13:02微信支付10元]
2024-09-28 15:13:05 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281512457056025201","queue_number":1038,"trade_uid":"24092815124570555557"}]}
2024-09-28 15:13:05 >>>故障排除日志:删除未同步下发订单成功24092815124570555557
2024-09-28 15:13:05 >>>故障排除日志:终端同步成功后剩余订单列表


===15:18:55===
2024-09-28 15:18:18 >>>回调事件[910,devices/YC0471]
2024-09-28 15:18:18 >>>故障排除日志:上一MQTT订单号缓存列表为24092815124570555557
2024-09-28 15:18:18 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 15:18:18 开始打印,排队:1039,票券:2409281518120726412801,订单:24092815181207259590,[2024-09-28 15:18:18微信支付10元]
2024-09-28 15:18:20 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281518120726412801","queue_number":1039,"trade_uid":"24092815181207259590"}]}
2024-09-28 15:18:20 >>>故障排除日志:删除未同步下发订单成功24092815181207259590
2024-09-28 15:18:20 >>>故障排除日志:终端同步成功后剩余订单列表


===15:19:55===
2024-09-28 15:19:30>>>cash read=0A
2024-09-28 15:19:31>>>cash read=3E


===15:21:56===
2024-09-28 15:21:18 >>>回调事件[910,devices/YC0471]
2024-09-28 15:21:18 >>>故障排除日志:上一MQTT订单号缓存列表为24092815181207259590
2024-09-28 15:21:18 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 15:21:18 开始打印,排队:1040,票券:2409281521098555710301,订单:24092815210985548241,[2024-09-28 15:21:17支付宝支付10元]
2024-09-28 15:21:20 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281521098555710301","queue_number":1040,"trade_uid":"24092815210985548241"}]}
2024-09-28 15:21:20 >>>故障排除日志:删除未同步下发订单成功24092815210985548241
2024-09-28 15:21:20 >>>故障排除日志:终端同步成功后剩余订单列表


===15:23:56===
2024-09-28 15:23:39 >>>回调事件[910,devices/YC0471]
2024-09-28 15:23:39 >>>故障排除日志:上一MQTT订单号缓存列表为24092815210985548241
2024-09-28 15:23:39 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 15:23:39 开始打印,排队:1041,票券:2409281523316159734301,订单:24092815233161593780,[2024-09-28 15:23:37微信支付10元]
2024-09-28 15:23:41 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281523316159734301","queue_number":1041,"trade_uid":"24092815233161593780"}]}
2024-09-28 15:23:41 >>>故障排除日志:删除未同步下发订单成功24092815233161593780
2024-09-28 15:23:41 >>>故障排除日志:终端同步成功后剩余订单列表


===15:24:56===
2024-09-28 15:24:24 >>>回调事件[910,devices/YC0471]
2024-09-28 15:24:24 >>>故障排除日志:上一MQTT订单号缓存列表为24092815233161593780
2024-09-28 15:24:24 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 15:24:24 开始打印,排队:1042,票券:2409281524140668409601,订单:24092815241406675250,[2024-09-28 15:24:24支付宝支付10元]
2024-09-28 15:24:26 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281524140668409601","queue_number":1042,"trade_uid":"24092815241406675250"}]}
2024-09-28 15:24:26 >>>故障排除日志:删除未同步下发订单成功24092815241406675250
2024-09-28 15:24:26 >>>故障排除日志:终端同步成功后剩余订单列表


===15:28:56===
2024-09-28 15:27:58 >>>回调事件[910,devices/YC0471]
2024-09-28 15:27:58 >>>故障排除日志:上一MQTT订单号缓存列表为24092815241406675250
2024-09-28 15:27:58 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 15:27:58 开始打印,排队:1043,票券:2409281527541041382301,订单:24092815275410407451,[2024-09-28 15:27:58支付宝支付10元]
2024-09-28 15:28:00 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281527541041382301","queue_number":1043,"trade_uid":"24092815275410407451"}]}
2024-09-28 15:28:00 >>>故障排除日志:删除未同步下发订单成功24092815275410407451
2024-09-28 15:28:00 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 15:28:40 >>>回调事件[910,devices/YC0471]
2024-09-28 15:28:40 >>>故障排除日志:上一MQTT订单号缓存列表为24092815275410407451
2024-09-28 15:28:40 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 15:28:40 开始打印,排队:1044,票券:2409281528332485368701,订单:24092815283324848409,[2024-09-28 15:28:38微信支付10元]
2024-09-28 15:28:40 开始打印,排队:1045,票券:2409281528332485593802,订单:24092815283324848409,[2024-09-28 15:28:38微信支付10元]
2024-09-28 15:28:43 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281528332485368701","queue_number":1044,"trade_uid":"24092815283324848409"},{"ticket_no":"2409281528332485593802","queue_number":1045,"trade_uid":"24092815283324848409"}]}
2024-09-28 15:28:43 >>>故障排除日志:删除未同步下发订单成功24092815283324848409
2024-09-28 15:28:44 >>>故障排除日志:删除未同步下发订单成功24092815283324848409
2024-09-28 15:28:44 >>>故障排除日志:终端同步成功后剩余订单列表


===15:29:57===
2024-09-28 15:29:37 >>>回调事件[910,devices/YC0471]
2024-09-28 15:29:37 >>>故障排除日志:上一MQTT订单号缓存列表为24092815283324848409|24092815283324848409
2024-09-28 15:29:37 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 15:29:37 开始打印,排队:1046,票券:2409281529299722935301,订单:24092815292997224687,[2024-09-28 15:29:36支付宝支付10元]
2024-09-28 15:29:39 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281529299722935301","queue_number":1046,"trade_uid":"24092815292997224687"}]}
2024-09-28 15:29:39 >>>故障排除日志:删除未同步下发订单成功24092815292997224687
2024-09-28 15:29:39 >>>故障排除日志:终端同步成功后剩余订单列表


===15:39:57===
2024-09-28 15:39:44 >>>回调事件[910,devices/YC0471]
2024-09-28 15:39:44 >>>故障排除日志:上一MQTT订单号缓存列表为24092815292997224687
2024-09-28 15:39:44 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 15:39:44 开始打印,排队:1047,票券:2409281539369480659401,订单:24092815393694802394,[2024-09-28 15:39:43微信支付10元]
2024-09-28 15:39:46 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281539369480659401","queue_number":1047,"trade_uid":"24092815393694802394"}]}
2024-09-28 15:39:46 >>>故障排除日志:删除未同步下发订单成功24092815393694802394
2024-09-28 15:39:46 >>>故障排除日志:终端同步成功后剩余订单列表


===15:43:57===
2024-09-28 15:43:13 >>>回调事件[910,devices/YC0471]
2024-09-28 15:43:13 >>>故障排除日志:上一MQTT订单号缓存列表为24092815393694802394
2024-09-28 15:43:13 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 15:43:13 开始打印,排队:1048,票券:2409281543044112009001,订单:24092815430441114286,[2024-09-28 15:43:12微信支付10元]
2024-09-28 15:43:15 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281543044112009001","queue_number":1048,"trade_uid":"24092815430441114286"}]}
2024-09-28 15:43:15 >>>故障排除日志:删除未同步下发订单成功24092815430441114286
2024-09-28 15:43:15 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 15:43:38 >>>回调事件[910,devices/YC0471]
2024-09-28 15:43:38 >>>故障排除日志:上一MQTT订单号缓存列表为24092815430441114286
2024-09-28 15:43:38 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 15:43:38 开始打印,排队:1049,票券:2409281543310629366401,订单:24092815433106289386,[2024-09-28 15:43:37微信支付10元]
2024-09-28 15:43:40 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281543310629366401","queue_number":1049,"trade_uid":"24092815433106289386"}]}
2024-09-28 15:43:40 >>>故障排除日志:删除未同步下发订单成功24092815433106289386
2024-09-28 15:43:40 >>>故障排除日志:终端同步成功后剩余订单列表


===15:46:58===
2024-09-28 15:46:21 >>>回调事件[910,devices/YC0471]
2024-09-28 15:46:21 >>>故障排除日志:上一MQTT订单号缓存列表为24092815433106289386
2024-09-28 15:46:21 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 15:46:21 开始打印,排队:1050,票券:2409281546118840992301,订单:24092815461188405778,[2024-09-28 15:46:20微信支付10元]
2024-09-28 15:46:23 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281546118840992301","queue_number":1050,"trade_uid":"24092815461188405778"}]}
2024-09-28 15:46:23 >>>故障排除日志:删除未同步下发订单成功24092815461188405778
2024-09-28 15:46:23 >>>故障排除日志:终端同步成功后剩余订单列表


===15:47:58===
2024-09-28 15:47:03 >>>回调事件[910,devices/YC0471]
2024-09-28 15:47:03 >>>故障排除日志:上一MQTT订单号缓存列表为24092815461188405778
2024-09-28 15:47:03 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 15:47:03 开始打印,排队:1051,票券:2409281546566144109501,订单:24092815465661436369,[2024-09-28 15:47:03微信支付10元]
2024-09-28 15:47:05 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281546566144109501","queue_number":1051,"trade_uid":"24092815465661436369"}]}
2024-09-28 15:47:05 >>>故障排除日志:删除未同步下发订单成功24092815465661436369
2024-09-28 15:47:05 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 15:47:22 >>>回调事件[910,devices/YC0471]
2024-09-28 15:47:22 >>>故障排除日志:上一MQTT订单号缓存列表为24092815465661436369
2024-09-28 15:47:22 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 15:47:22 开始打印,排队:1052,票券:2409281547145951028301,订单:24092815471459506071,[2024-09-28 15:47:21微信支付10元]
2024-09-28 15:47:24 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281547145951028301","queue_number":1052,"trade_uid":"24092815471459506071"}]}
2024-09-28 15:47:24 >>>故障排除日志:删除未同步下发订单成功24092815471459506071
2024-09-28 15:47:24 >>>故障排除日志:终端同步成功后剩余订单列表


===15:50:58===
2024-09-28 15:50:33 >>>回调事件[910,devices/YC0471]
2024-09-28 15:50:33 >>>故障排除日志:上一MQTT订单号缓存列表为24092815471459506071
2024-09-28 15:50:33 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 15:50:33 开始打印,排队:1053,票券:2409281550255303124601,订单:24092815502553027728,[2024-09-28 15:50:32微信支付10元]
2024-09-28 15:50:35 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281550255303124601","queue_number":1053,"trade_uid":"24092815502553027728"}]}
2024-09-28 15:50:35 >>>故障排除日志:删除未同步下发订单成功24092815502553027728
2024-09-28 15:50:35 >>>故障排除日志:终端同步成功后剩余订单列表


===15:54:59===
2024-09-28 15:54:02 >>>回调事件[910,devices/YC0471]
2024-09-28 15:54:02 >>>故障排除日志:上一MQTT订单号缓存列表为24092815502553027728
2024-09-28 15:54:02 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 15:54:02 开始打印,排队:1054,票券:2409281553520965095701,订单:24092815535209645361,[2024-09-28 15:54:01微信支付10元]
2024-09-28 15:54:04 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281553520965095701","queue_number":1054,"trade_uid":"24092815535209645361"}]}
2024-09-28 15:54:04 >>>故障排除日志:删除未同步下发订单成功24092815535209645361
2024-09-28 15:54:04 >>>故障排除日志:终端同步成功后剩余订单列表


===16:00:59===
2024-09-28 16:00:08>>>cash read=9E
2024-09-28 16:00:09>>>cash read=3E


===16:03:59===
2024-09-28 16:03:39>>>cash read=9E
2024-09-28 16:03:41>>>cash read=3E


===16:07:00===
2024-09-28 16:06:10 >>>回调事件[910,devices/YC0471]
2024-09-28 16:06:10 >>>故障排除日志:上一MQTT订单号缓存列表为24092815535209645361
2024-09-28 16:06:10 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 16:06:10 开始打印,排队:1055,票券:2409281606033299818301,订单:24092816060332993687,[2024-09-28 16:06:10微信支付10元]
2024-09-28 16:06:12 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281606033299818301","queue_number":1055,"trade_uid":"24092816060332993687"}]}
2024-09-28 16:06:12 >>>故障排除日志:删除未同步下发订单成功24092816060332993687
2024-09-28 16:06:12 >>>故障排除日志:终端同步成功后剩余订单列表


===16:10:00===
2024-09-28 16:09:07>>>cash read=9E
2024-09-28 16:09:08>>>cash read=3E


===16:14:00===
2024-09-28 16:13:47 >>>回调事件[910,devices/YC0471]
2024-09-28 16:13:47 >>>故障排除日志:上一MQTT订单号缓存列表为24092816060332993687
2024-09-28 16:13:47 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 16:13:47 开始打印,排队:1056,票券:2409281613236203549601,订单:24092816132362030098,[2024-09-28 16:13:47支付宝支付10元]
2024-09-28 16:13:49 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281613236203549601","queue_number":1056,"trade_uid":"24092816132362030098"}]}
2024-09-28 16:13:49 >>>故障排除日志:删除未同步下发订单成功24092816132362030098
2024-09-28 16:13:49 >>>故障排除日志:终端同步成功后剩余订单列表


===16:17:01===
2024-09-28 16:16:05 >>>回调事件[910,devices/YC0471]
2024-09-28 16:16:05 >>>故障排除日志:上一MQTT订单号缓存列表为24092816132362030098
2024-09-28 16:16:05 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 16:16:05 开始打印,排队:1057,票券:2409281615561089002801,订单:24092816155610885610,[2024-09-28 16:16:04微信支付10元]
2024-09-28 16:16:07 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281615561089002801","queue_number":1057,"trade_uid":"24092816155610885610"}]}
2024-09-28 16:16:07 >>>故障排除日志:删除未同步下发订单成功24092816155610885610
2024-09-28 16:16:07 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 16:16:21>>>cash read=9E
2024-09-28 16:16:22>>>cash read=3E


===16:20:01===
2024-09-28 16:19:50 >>>回调事件[910,devices/YC0471]
2024-09-28 16:19:50 >>>故障排除日志:上一MQTT订单号缓存列表为24092816155610885610
2024-09-28 16:19:50 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 16:19:50 开始打印,排队:1058,票券:2409281619419221776701,订单:24092816194192212951,[2024-09-28 16:19:50微信支付10元]
2024-09-28 16:19:52 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281619419221776701","queue_number":1058,"trade_uid":"24092816194192212951"}]}
2024-09-28 16:19:52 >>>故障排除日志:删除未同步下发订单成功24092816194192212951
2024-09-28 16:19:52 >>>故障排除日志:终端同步成功后剩余订单列表


===16:21:01===
2024-09-28 16:20:24>>>cash read=9E
2024-09-28 16:20:25>>>cash read=3E


===16:22:01===
2024-09-28 16:21:42>>>cash read=00
2024-09-28 16:21:44>>>cash read=00818F42
2024-09-28 16:21:44>>>cash write=02
2024-09-28 16:21:44 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-09-28 16:21:44>>>cash read=10
2024-09-28 16:21:44 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-09-28 16:21:44 当前产品价格10元，投币10元，打印小票中...
2024-09-28 16:21:44 >>>开始打印,排队号为1059,订单号为2409281621440004717919
2024-09-28 16:21:44>>>订单2409281621440004717919写入成功,剩余空间为1680000,占用RAM为605.373046875
删除未同步订单2409281621440004717919
2024-09-28 16:21:46>>>订单2409281621440004717919删除成功,剩余空间为1680500,占用RAM为618.48828125
检测订单目录中>>>
无未同步订单>>>
2024-09-28 16:21:47 >>>当前Ram内存为589.55859375
定时检测未同步订单启用
2024-09-28 16:21:47>>>cash write=0C
2024-09-28 16:21:47>>>cash read=3E
2024-09-28 16:21:53 >>>回调事件[910,devices/YC0471]
2024-09-28 16:21:53 >>>故障排除日志:上一MQTT订单号缓存列表为24092816194192212951
2024-09-28 16:21:53 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 16:21:53 开始打印,排队:1060,票券:2409281621433733745301,订单:24092816214337333730,[2024-09-28 16:21:53支付宝支付10元]
2024-09-28 16:21:55 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281621433733745301","queue_number":1060,"trade_uid":"24092816214337333730"}]}
2024-09-28 16:21:55 >>>故障排除日志:删除未同步下发订单成功24092816214337333730
2024-09-28 16:21:55 >>>故障排除日志:终端同步成功后剩余订单列表


===16:23:02===
定时检测未同步订单关闭
检测订单目录中>>>
无未同步订单>>>


===16:24:02===
2024-09-28 16:23:40 >>>回调事件[910,devices/YC0471]
2024-09-28 16:23:40 >>>故障排除日志:上一MQTT订单号缓存列表为24092816214337333730
2024-09-28 16:23:40 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 16:23:40 开始打印,排队:1061,票券:2409281623319046910301,订单:24092816233190465473,[2024-09-28 16:23:38微信支付10元]
2024-09-28 16:23:42 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281623319046910301","queue_number":1061,"trade_uid":"24092816233190465473"}]}
2024-09-28 16:23:42 >>>故障排除日志:删除未同步下发订单成功24092816233190465473
2024-09-28 16:23:42 >>>故障排除日志:终端同步成功后剩余订单列表


===16:28:02===
2024-09-28 16:27:36 >>>回调事件[910,devices/YC0471]
2024-09-28 16:27:36 >>>故障排除日志:上一MQTT订单号缓存列表为24092816233190465473
2024-09-28 16:27:36 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 16:27:36 开始打印,排队:1062,票券:2409281627286693536501,订单:24092816272866928443,[2024-09-28 16:27:36微信支付10元]
2024-09-28 16:27:38 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281627286693536501","queue_number":1062,"trade_uid":"24092816272866928443"}]}
2024-09-28 16:27:38 >>>故障排除日志:删除未同步下发订单成功24092816272866928443
2024-09-28 16:27:38 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 16:27:45>>>cash read=0A
2024-09-28 16:27:46>>>cash read=3E


===16:31:03===
2024-09-28 16:30:33 >>>回调事件[910,devices/YC0471]
2024-09-28 16:30:33 >>>故障排除日志:上一MQTT订单号缓存列表为24092816272866928443
2024-09-28 16:30:33 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 16:30:33 开始打印,排队:1063,票券:2409281630254346058101,订单:24092816302543456665,[2024-09-28 16:30:32微信支付10元]
2024-09-28 16:30:35 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281630254346058101","queue_number":1063,"trade_uid":"24092816302543456665"}]}
2024-09-28 16:30:35 >>>故障排除日志:删除未同步下发订单成功24092816302543456665
2024-09-28 16:30:35 >>>故障排除日志:终端同步成功后剩余订单列表


===16:32:03===
2024-09-28 16:31:04 >>>回调事件[910,devices/YC0471]
2024-09-28 16:31:04 >>>故障排除日志:上一MQTT订单号缓存列表为24092816302543456665
2024-09-28 16:31:04 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 16:31:04 开始打印,排队:1064,票券:2409281630577602455101,订单:24092816305776019787,[2024-09-28 16:31:03微信支付10元]
2024-09-28 16:31:06 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281630577602455101","queue_number":1064,"trade_uid":"24092816305776019787"}]}
2024-09-28 16:31:06 >>>故障排除日志:删除未同步下发订单成功24092816305776019787
2024-09-28 16:31:06 >>>故障排除日志:终端同步成功后剩余订单列表


===16:39:03===
2024-09-28 16:38:44 >>>回调事件[910,devices/YC0471]
2024-09-28 16:38:44 >>>故障排除日志:上一MQTT订单号缓存列表为24092816305776019787
2024-09-28 16:38:44 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 16:38:44 开始打印,排队:1065,票券:2409281638380273136801,订单:24092816383802727861,[2024-09-28 16:38:43支付宝支付10元]
2024-09-28 16:38:46 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281638380273136801","queue_number":1065,"trade_uid":"24092816383802727861"}]}
2024-09-28 16:38:46 >>>故障排除日志:删除未同步下发订单成功24092816383802727861
2024-09-28 16:38:47 >>>故障排除日志:终端同步成功后剩余订单列表


===16:43:04===
2024-09-28 16:42:28 >>>回调事件[910,devices/YC0471]
2024-09-28 16:42:28 >>>故障排除日志:上一MQTT订单号缓存列表为24092816383802727861
2024-09-28 16:42:28 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 16:42:28 开始打印,排队:1066,票券:2409281642207791690201,订单:24092816422077911014,[2024-09-28 16:42:28微信支付10元]
2024-09-28 16:42:30 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281642207791690201","queue_number":1066,"trade_uid":"24092816422077911014"}]}
2024-09-28 16:42:30 >>>故障排除日志:删除未同步下发订单成功24092816422077911014
2024-09-28 16:42:30 >>>故障排除日志:终端同步成功后剩余订单列表


===16:44:05===
2024-09-28 16:43:26 >>>回调事件[910,devices/YC0471]
2024-09-28 16:43:26 >>>故障排除日志:上一MQTT订单号缓存列表为24092816422077911014
2024-09-28 16:43:26 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 16:43:26 开始打印,排队:1067,票券:2409281643185435030501,订单:24092816431854345842,[2024-09-28 16:43:25支付宝支付10元]
2024-09-28 16:43:28 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281643185435030501","queue_number":1067,"trade_uid":"24092816431854345842"}]}
2024-09-28 16:43:28 >>>故障排除日志:删除未同步下发订单成功24092816431854345842
2024-09-28 16:43:28 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 16:44:00 >>>回调事件[910,devices/YC0471]
2024-09-28 16:44:00 >>>故障排除日志:上一MQTT订单号缓存列表为24092816431854345842
2024-09-28 16:44:00 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 16:44:00 开始打印,排队:1068,票券:2409281643528309633501,订单:24092816435283091768,[2024-09-28 16:44:00微信支付10元]
2024-09-28 16:44:00 开始打印,排队:1069,票券:2409281643528309834702,订单:24092816435283091768,[2024-09-28 16:44:00微信支付10元]


===16:45:06===
2024-09-28 16:44:38 >>>回调事件[910,devices/YC0471]
2024-09-28 16:44:38 >>>故障排除日志:上一MQTT订单号缓存列表为24092816435283091768|24092816435283091768
2024-09-28 16:44:38 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 16:44:38 开始打印,排队:1070,票券:2409281644283524524901,订单:24092816442835239696,[2024-09-28 16:44:36微信支付10元]
2024-09-28 16:44:40 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281644283524524901","queue_number":1070,"trade_uid":"24092816442835239696"}]}
2024-09-28 16:44:40 >>>故障排除日志:删除未同步下发订单成功24092816442835239696
2024-09-28 16:44:40 >>>故障排除日志:终端同步成功后剩余订单列表


===16:46:06===
2024-09-28 16:45:49>>>cash read=0A
2024-09-28 16:45:50>>>cash read=3E


===16:50:06===
2024-09-28 16:49:32 >>>回调事件[910,devices/YC0471]
2024-09-28 16:49:32 >>>故障排除日志:上一MQTT订单号缓存列表为24092816442835239696
2024-09-28 16:49:32 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 16:49:32 开始打印,排队:1071,票券:2409281649257511654301,订单:24092816492575112038,[2024-09-28 16:49:32微信支付10元]
2024-09-28 16:49:34 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281649257511654301","queue_number":1071,"trade_uid":"24092816492575112038"}]}
2024-09-28 16:49:34 >>>故障排除日志:删除未同步下发订单成功24092816492575112038
2024-09-28 16:49:34 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 16:49:47 >>>回调事件[910,devices/YC0471]
2024-09-28 16:49:48 >>>故障排除日志:上一MQTT订单号缓存列表为24092816492575112038
2024-09-28 16:49:48 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 16:49:48 开始打印,排队:1072,票券:2409281649414116419601,订单:24092816494141158616,[2024-09-28 16:49:47微信支付10元]
2024-09-28 16:49:50 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281649414116419601","queue_number":1072,"trade_uid":"24092816494141158616"}]}
2024-09-28 16:49:50 >>>故障排除日志:删除未同步下发订单成功24092816494141158616
2024-09-28 16:49:50 >>>故障排除日志:终端同步成功后剩余订单列表


===16:52:06===
2024-09-28 16:51:13 >>>回调事件[910,devices/YC0471]
2024-09-28 16:51:13 >>>故障排除日志:上一MQTT订单号缓存列表为24092816494141158616
2024-09-28 16:51:13 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 16:51:13 开始打印,排队:1073,票券:2409281651043146450301,订单:24092816510431457790,[2024-09-28 16:51:12微信支付10元]
2024-09-28 16:51:15 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281651043146450301","queue_number":1073,"trade_uid":"24092816510431457790"}]}
2024-09-28 16:51:15 >>>故障排除日志:删除未同步下发订单成功24092816510431457790
2024-09-28 16:51:15 >>>故障排除日志:终端同步成功后剩余订单列表


===16:58:06===
2024-09-28 16:57:11>>>cash read=9E
2024-09-28 16:57:12>>>cash read=3E


===17:01:07===
2024-09-28 17:00:24 >>>回调事件[910,devices/YC0471]
2024-09-28 17:00:24 >>>故障排除日志:上一MQTT订单号缓存列表为24092816510431457790
2024-09-28 17:00:24 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 17:00:24 开始打印,排队:1074,票券:2409281700158550685301,订单:24092817001585501606,[2024-09-28 17:00:22微信支付10元]
2024-09-28 17:00:26 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281700158550685301","queue_number":1074,"trade_uid":"24092817001585501606"}]}
2024-09-28 17:00:26 >>>故障排除日志:删除未同步下发订单成功24092817001585501606
2024-09-28 17:00:26 >>>故障排除日志:终端同步成功后剩余订单列表


===17:04:07===
2024-09-28 17:03:40 >>>回调事件[910,devices/YC0471]
2024-09-28 17:03:40 >>>故障排除日志:上一MQTT订单号缓存列表为24092817001585501606
2024-09-28 17:03:40 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 17:03:40 开始打印,排队:1075,票券:2409281703348974142901,订单:24092817033489737623,[2024-09-28 17:03:40微信支付10元]
2024-09-28 17:03:42 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281703348974142901","queue_number":1075,"trade_uid":"24092817033489737623"}]}
2024-09-28 17:03:42 >>>故障排除日志:删除未同步下发订单成功24092817033489737623
2024-09-28 17:03:42 >>>故障排除日志:终端同步成功后剩余订单列表


===17:12:07===
2024-09-28 17:11:31 >>>回调事件[910,devices/YC0471]
2024-09-28 17:11:31 >>>故障排除日志:上一MQTT订单号缓存列表为24092817033489737623
2024-09-28 17:11:31 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 17:11:31 开始打印,排队:1076,票券:2409281711230254212701,订单:24092817112302537765,[2024-09-28 17:11:29微信支付10元]
2024-09-28 17:11:33 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281711230254212701","queue_number":1076,"trade_uid":"24092817112302537765"}]}
2024-09-28 17:11:33 >>>故障排除日志:删除未同步下发订单成功24092817112302537765
2024-09-28 17:11:33 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 17:11:51 >>>回调事件[910,devices/YC0471]
2024-09-28 17:11:51 >>>故障排除日志:上一MQTT订单号缓存列表为24092817112302537765
2024-09-28 17:11:51 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 17:11:51 开始打印,排队:1077,票券:2409281711436159435401,订单:24092817114361588984,[2024-09-28 17:11:50支付宝支付10元]
2024-09-28 17:11:53 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281711436159435401","queue_number":1077,"trade_uid":"24092817114361588984"}]}
2024-09-28 17:11:53 >>>故障排除日志:删除未同步下发订单成功24092817114361588984
2024-09-28 17:11:53 >>>故障排除日志:终端同步成功后剩余订单列表


===17:16:08===
2024-09-28 17:15:55>>>cash read=0A
2024-09-28 17:15:57>>>cash read=3E


===17:17:08===
2024-09-28 17:16:56 >>>回调事件[910,devices/YC0471]
2024-09-28 17:16:56 >>>故障排除日志:上一MQTT订单号缓存列表为24092817114361588984
2024-09-28 17:16:56 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 17:16:56 开始打印,排队:1078,票券:2409281716473136050501,订单:24092817164731356773,[2024-09-28 17:16:54微信支付10元]
2024-09-28 17:16:58 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281716473136050501","queue_number":1078,"trade_uid":"24092817164731356773"}]}
2024-09-28 17:16:58 >>>故障排除日志:删除未同步下发订单成功24092817164731356773
2024-09-28 17:16:58 >>>故障排除日志:终端同步成功后剩余订单列表


===17:18:08===
2024-09-28 17:17:17 >>>回调事件[910,devices/YC0471]
2024-09-28 17:17:17 >>>故障排除日志:上一MQTT订单号缓存列表为24092817164731356773
2024-09-28 17:17:17 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 17:17:17 开始打印,排队:1079,票券:2409281717103059457001,订单:24092817171030589447,[2024-09-28 17:17:17微信支付10元]
2024-09-28 17:17:19 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281717103059457001","queue_number":1079,"trade_uid":"24092817171030589447"}]}
2024-09-28 17:17:19 >>>故障排除日志:删除未同步下发订单成功24092817171030589447
2024-09-28 17:17:19 >>>故障排除日志:终端同步成功后剩余订单列表


===17:20:09===
2024-09-28 17:19:22 >>>回调事件[910,devices/YC0471]
2024-09-28 17:19:22 >>>故障排除日志:上一MQTT订单号缓存列表为24092817171030589447
2024-09-28 17:19:22 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 17:19:22 开始打印,排队:1080,票券:2409281719160911319301,订单:24092817191609104402,[2024-09-28 17:19:21微信支付10元]
2024-09-28 17:19:24 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281719160911319301","queue_number":1080,"trade_uid":"24092817191609104402"}]}
2024-09-28 17:19:24 >>>故障排除日志:删除未同步下发订单成功24092817191609104402
2024-09-28 17:19:24 >>>故障排除日志:终端同步成功后剩余订单列表


===17:21:09===
2024-09-28 17:20:39 >>>回调事件[910,devices/YC0471]
2024-09-28 17:20:39 >>>故障排除日志:上一MQTT订单号缓存列表为24092817191609104402
2024-09-28 17:20:39 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 17:20:39 开始打印,排队:1081,票券:2409281720310370491801,订单:24092817203103699909,[2024-09-28 17:20:38微信支付10元]
2024-09-28 17:20:41 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281720310370491801","queue_number":1081,"trade_uid":"24092817203103699909"}]}
2024-09-28 17:20:41 >>>故障排除日志:删除未同步下发订单成功24092817203103699909
2024-09-28 17:20:41 >>>故障排除日志:终端同步成功后剩余订单列表


===17:25:09===
2024-09-28 17:24:48>>>cash read=BF
2024-09-28 17:24:49>>>cash read=3E


===17:34:10===
2024-09-28 17:33:11 >>>回调事件[910,devices/YC0471]
2024-09-28 17:33:11 >>>故障排除日志:上一MQTT订单号缓存列表为24092817203103699909
2024-09-28 17:33:11 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 17:33:11 开始打印,排队:1082,票券:2409281733027365969701,订单:24092817330273655584,[2024-09-28 17:33:10支付宝支付10元]
2024-09-28 17:33:13 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281733027365969701","queue_number":1082,"trade_uid":"24092817330273655584"}]}
2024-09-28 17:33:13 >>>故障排除日志:删除未同步下发订单成功24092817330273655584
2024-09-28 17:33:13 >>>故障排除日志:终端同步成功后剩余订单列表


===17:37:10===
2024-09-28 17:36:43 >>>回调事件[910,devices/YC0471]
2024-09-28 17:36:43 >>>故障排除日志:上一MQTT订单号缓存列表为24092817330273655584
2024-09-28 17:36:43 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 17:36:43 开始打印,排队:1083,票券:2409281736350663605301,订单:24092817363506631389,[2024-09-28 17:36:43微信支付10元]
2024-09-28 17:36:45 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281736350663605301","queue_number":1083,"trade_uid":"24092817363506631389"}]}
2024-09-28 17:36:46 >>>故障排除日志:删除未同步下发订单成功24092817363506631389
2024-09-28 17:36:46 >>>故障排除日志:终端同步成功后剩余订单列表


===17:42:10===
2024-09-28 17:41:10 >>>回调事件[910,devices/YC0471]
2024-09-28 17:41:10 >>>故障排除日志:上一MQTT订单号缓存列表为24092817363506631389
2024-09-28 17:41:10 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 17:41:10 开始打印,排队:1084,票券:2409281741002969708201,订单:24092817410029691785,[2024-09-28 17:41:08支付宝支付10元]
2024-09-28 17:41:12 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281741002969708201","queue_number":1084,"trade_uid":"24092817410029691785"}]}
2024-09-28 17:41:12 >>>故障排除日志:删除未同步下发订单成功24092817410029691785
2024-09-28 17:41:12 >>>故障排除日志:终端同步成功后剩余订单列表


===17:43:12===
2024-09-28 17:43:09 >>>回调事件[910,devices/YC0471]
2024-09-28 17:43:09 >>>故障排除日志:上一MQTT订单号缓存列表为24092817410029691785
2024-09-28 17:43:09 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 17:43:09 开始打印,排队:1085,票券:2409281742595731000501,订单:24092817425957302723,[2024-09-28 17:43:07微信支付10元]


===17:44:12===
2024-09-28 17:43:11 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281742595731000501","queue_number":1085,"trade_uid":"24092817425957302723"}]}
2024-09-28 17:43:11 >>>故障排除日志:删除未同步下发订单成功24092817425957302723
2024-09-28 17:43:11 >>>故障排除日志:终端同步成功后剩余订单列表


===17:46:13===
2024-09-28 17:45:33 >>>回调事件[910,devices/YC0471]
2024-09-28 17:45:33 >>>故障排除日志:上一MQTT订单号缓存列表为24092817425957302723
2024-09-28 17:45:33 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 17:45:33 开始打印,排队:1086,票券:2409281745222220964201,订单:24092817452222201283,[2024-09-28 17:45:32微信支付10元]
2024-09-28 17:45:35 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281745222220964201","queue_number":1086,"trade_uid":"24092817452222201283"}]}
2024-09-28 17:45:35 >>>故障排除日志:删除未同步下发订单成功24092817452222201283
2024-09-28 17:45:35 >>>故障排除日志:终端同步成功后剩余订单列表


===17:55:13===
2024-09-28 17:54:53>>>cash read=9E
2024-09-28 17:54:54>>>cash read=3E


===18:01:13===
2024-09-28 18:01:02 >>>回调事件[910,devices/YC0471]
2024-09-28 18:01:02 >>>故障排除日志:上一MQTT订单号缓存列表为24092817452222201283
2024-09-28 18:01:02 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 18:01:02 开始打印,排队:1087,票券:2409281800549859181601,订单:24092818005498587761,[2024-09-28 18:01:02微信支付10元]
2024-09-28 18:01:04 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281800549859181601","queue_number":1087,"trade_uid":"24092818005498587761"}]}
2024-09-28 18:01:04 >>>故障排除日志:删除未同步下发订单成功24092818005498587761
2024-09-28 18:01:04 >>>故障排除日志:终端同步成功后剩余订单列表


===18:07:13===
2024-09-28 18:06:52 >>>回调事件[910,devices/YC0471]
2024-09-28 18:06:52 >>>故障排除日志:上一MQTT订单号缓存列表为24092818005498587761
2024-09-28 18:06:52 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 18:06:52 开始打印,排队:1088,票券:2409281806447903559301,订单:24092818064479029220,[2024-09-28 18:06:51微信支付10元]
2024-09-28 18:06:54 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281806447903559301","queue_number":1088,"trade_uid":"24092818064479029220"}]}
2024-09-28 18:06:54 >>>故障排除日志:删除未同步下发订单成功24092818064479029220
2024-09-28 18:06:54 >>>故障排除日志:终端同步成功后剩余订单列表


===18:10:14===
2024-09-28 18:09:25 >>>剩余flash空间=1682000,占用RAM为610.8857421875
2024-09-28 18:09:25 >>>回调事件:901,netChange,1,4G LTE网络

2024-09-28 18:09:47 >>>回调事件[910,devices/YC0471]
2024-09-28 18:09:47 >>>故障排除日志:上一MQTT订单号缓存列表为24092818064479029220
2024-09-28 18:09:48 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 18:09:48 开始打印,排队:1089,票券:2409281809420428097101,订单:24092818094204274876,[2024-09-28 18:09:47微信支付10元]
2024-09-28 18:09:50 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281809420428097101","queue_number":1089,"trade_uid":"24092818094204274876"}]}
2024-09-28 18:09:50 >>>故障排除日志:删除未同步下发订单成功24092818094204274876
2024-09-28 18:09:50 >>>故障排除日志:终端同步成功后剩余订单列表


===18:11:14===
2024-09-28 18:10:33 >>>回调事件[910,devices/YC0471]
2024-09-28 18:10:33 >>>故障排除日志:上一MQTT订单号缓存列表为24092818094204274876
2024-09-28 18:10:33 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 18:10:33 开始打印,排队:1090,票券:2409281810269431018601,订单:24092818102694302314,[2024-09-28 18:10:33微信支付10元]
2024-09-28 18:10:36 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281810269431018601","queue_number":1090,"trade_uid":"24092818102694302314"}]}
2024-09-28 18:10:36 >>>故障排除日志:删除未同步下发订单成功24092818102694302314
2024-09-28 18:10:36 >>>故障排除日志:终端同步成功后剩余订单列表


===18:14:16===
2024-09-28 18:14:12 >>>回调事件[910,devices/YC0471]
2024-09-28 18:14:12 >>>故障排除日志:上一MQTT订单号缓存列表为24092818102694302314
2024-09-28 18:14:12 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 18:14:12 开始打印,排队:1091,票券:2409281814030497807301,订单:24092818140304972695,[2024-09-28 18:14:11微信支付10元]


===18:15:16===
2024-09-28 18:14:14 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281814030497807301","queue_number":1091,"trade_uid":"24092818140304972695"}]}
2024-09-28 18:14:14 >>>故障排除日志:删除未同步下发订单成功24092818140304972695
2024-09-28 18:14:14 >>>故障排除日志:终端同步成功后剩余订单列表


===18:22:16===
2024-09-28 18:21:56 >>>回调事件[910,devices/YC0471]
2024-09-28 18:21:56 >>>故障排除日志:上一MQTT订单号缓存列表为24092818140304972695
2024-09-28 18:21:56 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 18:21:56 开始打印,排队:1092,票券:2409281821501701806001,订单:24092818215017014127,[2024-09-28 18:21:56支付宝支付10元]
2024-09-28 18:21:58 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281821501701806001","queue_number":1092,"trade_uid":"24092818215017014127"}]}
2024-09-28 18:21:58 >>>故障排除日志:删除未同步下发订单成功24092818215017014127
2024-09-28 18:21:59 >>>故障排除日志:终端同步成功后剩余订单列表


===18:29:16===
2024-09-28 18:28:31 >>>回调事件[910,devices/YC0471]
2024-09-28 18:28:31 >>>故障排除日志:上一MQTT订单号缓存列表为24092818215017014127
2024-09-28 18:28:31 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 18:28:31 开始打印,排队:1093,票券:2409281828230746783201,订单:24092818282307463521,[2024-09-28 18:28:30微信支付10元]
2024-09-28 18:28:31 开始打印,排队:1094,票券:2409281828230746925102,订单:24092818282307463521,[2024-09-28 18:28:30微信支付10元]
2024-09-28 18:28:35 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281828230746783201","queue_number":1093,"trade_uid":"24092818282307463521"},{"ticket_no":"2409281828230746925102","queue_number":1094,"trade_uid":"24092818282307463521"}]}
2024-09-28 18:28:35 >>>故障排除日志:删除未同步下发订单成功24092818282307463521
2024-09-28 18:28:35 >>>故障排除日志:删除未同步下发订单成功24092818282307463521
2024-09-28 18:28:35 >>>故障排除日志:终端同步成功后剩余订单列表


===18:30:17===
2024-09-28 18:29:41>>>cash read=00
2024-09-28 18:29:41>>>cash read=2F29
2024-09-28 18:29:43>>>cash read=3E
2024-09-28 18:29:44>>>cash read=00
2024-09-28 18:29:45>>>cash read=01
2024-09-28 18:29:47>>>cash read=3E
2024-09-28 18:29:50>>>cash read=00
2024-09-28 18:29:52>>>cash read=2F29
2024-09-28 18:29:53>>>cash read=3E
2024-09-28 18:29:55>>>cash read=00
2024-09-28 18:29:56>>>cash read=818F42
2024-09-28 18:29:56>>>cash write=02
2024-09-28 18:29:56 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-09-28 18:29:56>>>cash read=10
2024-09-28 18:29:56 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-09-28 18:29:56 当前产品价格10元，投币10元，打印小票中...
2024-09-28 18:29:56 >>>开始打印,排队号为1095,订单号为2409281829560004717689
2024-09-28 18:29:56>>>订单2409281829560004717689写入成功,剩余空间为1679500,占用RAM为609.2470703125
删除未同步订单2409281829560004717689
2024-09-28 18:29:58>>>订单2409281829560004717689删除成功,剩余空间为1680500,占用RAM为618.33984375
检测订单目录中>>>
无未同步订单>>>
2024-09-28 18:29:59 >>>当前Ram内存为590.57421875
定时检测未同步订单启用
2024-09-28 18:29:59>>>cash write=0C
2024-09-28 18:29:59>>>cash read=3E
2024-09-28 18:30:03>>>cash read=00
2024-09-28 18:30:04>>>cash read=818F42
2024-09-28 18:30:04>>>cash write=02
2024-09-28 18:30:04 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-09-28 18:30:04>>>cash read=10
2024-09-28 18:30:04 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-09-28 18:30:04 当前产品价格10元，投币10元，打印小票中...
2024-09-28 18:30:04 >>>开始打印,排队号为1096,订单号为2409281830040004715486
定时检测未同步订单关闭
2024-09-28 18:30:04>>>订单2409281830040004715486写入成功,剩余空间为1678500,占用RAM为616.67578125
删除未同步订单2409281830040004715486
2024-09-28 18:30:06>>>订单2409281830040004715486删除成功,剩余空间为1679500,占用RAM为624.8408203125
检测订单目录中>>>
无未同步订单>>>
2024-09-28 18:30:07 >>>当前Ram内存为592.0732421875
定时检测未同步订单启用
2024-09-28 18:30:07>>>cash write=0C
2024-09-28 18:30:07>>>cash read=3E


===18:31:17===
定时检测未同步订单关闭
检测订单目录中>>>
无未同步订单>>>


===18:36:17===
2024-09-28 18:35:29 >>>回调事件[910,devices/YC0471]
2024-09-28 18:35:29 >>>故障排除日志:上一MQTT订单号缓存列表为24092818282307463521|24092818282307463521
2024-09-28 18:35:29 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 18:35:29 开始打印,排队:1097,票券:2409281835215484246401,订单:24092818352154838907,[2024-09-28 18:35:27微信支付10元]
2024-09-28 18:35:31 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281835215484246401","queue_number":1097,"trade_uid":"24092818352154838907"}]}
2024-09-28 18:35:31 >>>故障排除日志:删除未同步下发订单成功24092818352154838907
2024-09-28 18:35:31 >>>故障排除日志:终端同步成功后剩余订单列表


===18:38:17===
2024-09-28 18:37:46 >>>回调事件[910,devices/YC0471]
2024-09-28 18:37:46 >>>故障排除日志:上一MQTT订单号缓存列表为24092818352154838907
2024-09-28 18:37:46 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 18:37:46 开始打印,排队:1098,票券:2409281837402504371301,订单:24092818374025039050,[2024-09-28 18:37:46微信支付10元]
2024-09-28 18:37:48 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281837402504371301","queue_number":1098,"trade_uid":"24092818374025039050"}]}
2024-09-28 18:37:48 >>>故障排除日志:删除未同步下发订单成功24092818374025039050
2024-09-28 18:37:48 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 18:37:55 >>>回调事件[910,devices/YC0471]
2024-09-28 18:37:55 >>>故障排除日志:上一MQTT订单号缓存列表为24092818374025039050
2024-09-28 18:37:55 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 18:37:55 开始打印,排队:1099,票券:2409281837487444979301,订单:24092818374874444963,[2024-09-28 18:37:54微信支付10元]
2024-09-28 18:37:57 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281837487444979301","queue_number":1099,"trade_uid":"24092818374874444963"}]}
2024-09-28 18:37:57 >>>故障排除日志:删除未同步下发订单成功24092818374874444963
2024-09-28 18:37:57 >>>故障排除日志:终端同步成功后剩余订单列表


===18:39:18===
2024-09-28 18:39:02 >>>回调事件[910,devices/YC0471]
2024-09-28 18:39:02 >>>故障排除日志:上一MQTT订单号缓存列表为24092818374874444963
2024-09-28 18:39:02 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 18:39:02 开始打印,排队:1100,票券:2409281838557233888901,订单:24092818385572334286,[2024-09-28 18:39:02微信支付10元]
2024-09-28 18:39:02 开始打印,排队:1101,票券:2409281838557234081502,订单:24092818385572334286,[2024-09-28 18:39:02微信支付10元]
2024-09-28 18:39:06 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281838557233888901","queue_number":1100,"trade_uid":"24092818385572334286"},{"ticket_no":"2409281838557234081502","queue_number":1101,"trade_uid":"24092818385572334286"}]}
2024-09-28 18:39:06 >>>故障排除日志:删除未同步下发订单成功24092818385572334286
2024-09-28 18:39:06 >>>故障排除日志:删除未同步下发订单成功24092818385572334286
2024-09-28 18:39:06 >>>故障排除日志:终端同步成功后剩余订单列表


===18:42:18===
2024-09-28 18:41:23 >>>回调事件[910,devices/YC0471]
2024-09-28 18:41:23 >>>故障排除日志:上一MQTT订单号缓存列表为24092818385572334286|24092818385572334286
2024-09-28 18:41:23 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 18:41:23 开始打印,排队:1102,票券:2409281841147338277801,订单:24092818411473378427,[2024-09-28 18:41:22微信支付10元]
2024-09-28 18:41:25 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281841147338277801","queue_number":1102,"trade_uid":"24092818411473378427"}]}
2024-09-28 18:41:25 >>>故障排除日志:删除未同步下发订单成功24092818411473378427
2024-09-28 18:41:25 >>>故障排除日志:终端同步成功后剩余订单列表


===18:48:18===
2024-09-28 18:47:33 >>>回调事件[910,devices/YC0471]
2024-09-28 18:47:33 >>>故障排除日志:上一MQTT订单号缓存列表为24092818411473378427
2024-09-28 18:47:33 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 18:47:33 开始打印,排队:1103,票券:2409281847262054741401,订单:24092818472620543458,[2024-09-28 18:47:32微信支付10元]
2024-09-28 18:47:35 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281847262054741401","queue_number":1103,"trade_uid":"24092818472620543458"}]}
2024-09-28 18:47:35 >>>故障排除日志:删除未同步下发订单成功24092818472620543458
2024-09-28 18:47:35 >>>故障排除日志:终端同步成功后剩余订单列表


===18:49:18===
2024-09-28 18:48:52 >>>回调事件[910,devices/YC0471]
2024-09-28 18:48:52 >>>故障排除日志:上一MQTT订单号缓存列表为24092818472620543458
2024-09-28 18:48:52 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 18:48:52 开始打印,排队:1104,票券:2409281848411685117501,订单:24092818484116847367,[2024-09-28 18:48:52微信支付10元]
2024-09-28 18:48:54 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281848411685117501","queue_number":1104,"trade_uid":"24092818484116847367"}]}
2024-09-28 18:48:54 >>>故障排除日志:删除未同步下发订单成功24092818484116847367
2024-09-28 18:48:54 >>>故障排除日志:终端同步成功后剩余订单列表


===18:53:18===
2024-09-28 18:52:30 >>>回调事件[910,devices/YC0471]
2024-09-28 18:52:30 >>>故障排除日志:上一MQTT订单号缓存列表为24092818484116847367
2024-09-28 18:52:30 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 18:52:30 开始打印,排队:1105,票券:2409281852214012272101,订单:24092818522140115127,[2024-09-28 18:52:28微信支付10元]
2024-09-28 18:52:30 开始打印,排队:1106,票券:2409281852214012469102,订单:24092818522140115127,[2024-09-28 18:52:28微信支付10元]
2024-09-28 18:52:34 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281852214012272101","queue_number":1105,"trade_uid":"24092818522140115127"},{"ticket_no":"2409281852214012469102","queue_number":1106,"trade_uid":"24092818522140115127"}]}
2024-09-28 18:52:34 >>>故障排除日志:删除未同步下发订单成功24092818522140115127
2024-09-28 18:52:34 >>>故障排除日志:删除未同步下发订单成功24092818522140115127
2024-09-28 18:52:34 >>>故障排除日志:终端同步成功后剩余订单列表


===18:55:19===
2024-09-28 18:55:14 >>>回调事件[910,devices/YC0471]
2024-09-28 18:55:14 >>>故障排除日志:上一MQTT订单号缓存列表为24092818522140115127|24092818522140115127
2024-09-28 18:55:14 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 18:55:14 开始打印,排队:1107,票券:2409281855055834614501,订单:24092818550558342373,[2024-09-28 18:55:13微信支付10元]
2024-09-28 18:55:16 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281855055834614501","queue_number":1107,"trade_uid":"24092818550558342373"}]}
2024-09-28 18:55:16 >>>故障排除日志:删除未同步下发订单成功24092818550558342373
2024-09-28 18:55:16 >>>故障排除日志:终端同步成功后剩余订单列表


===19:00:19===
2024-09-28 19:00:13 >>>回调事件[910,devices/YC0471]
2024-09-28 19:00:13 >>>故障排除日志:上一MQTT订单号缓存列表为24092818550558342373
2024-09-28 19:00:13 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 19:00:13 开始打印,排队:1108,票券:2409281900047054118301,订单:24092819000470536320,[2024-09-28 19:00:12微信支付10元]
2024-09-28 19:00:15 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281900047054118301","queue_number":1108,"trade_uid":"24092819000470536320"}]}
2024-09-28 19:00:15 >>>故障排除日志:删除未同步下发订单成功24092819000470536320
2024-09-28 19:00:15 >>>故障排除日志:终端同步成功后剩余订单列表


===19:01:19===
2024-09-28 19:01:07 >>>回调事件[910,devices/YC0471]
2024-09-28 19:01:07 >>>故障排除日志:上一MQTT订单号缓存列表为24092819000470536320
2024-09-28 19:01:07 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 19:01:07 开始打印,排队:1109,票券:2409281900587934517201,订单:24092819005879341598,[2024-09-28 19:01:04微信支付10元]
2024-09-28 19:01:09 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281900587934517201","queue_number":1109,"trade_uid":"24092819005879341598"}]}
2024-09-28 19:01:09 >>>故障排除日志:删除未同步下发订单成功24092819005879341598
2024-09-28 19:01:09 >>>故障排除日志:终端同步成功后剩余订单列表


===19:09:19===
2024-09-28 19:09:14 >>>回调事件[910,devices/YC0471]
2024-09-28 19:09:14 >>>故障排除日志:上一MQTT订单号缓存列表为24092819005879341598
2024-09-28 19:09:14 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 19:09:14 开始打印,排队:1110,票券:2409281908502944999001,订单:24092819085029445504,[2024-09-28 19:09:13微信支付10元]
2024-09-28 19:09:14 开始打印,排队:1111,票券:2409281908502945155002,订单:24092819085029445504,[2024-09-28 19:09:13微信支付10元]
2024-09-28 19:09:17 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281908502944999001","queue_number":1110,"trade_uid":"24092819085029445504"},{"ticket_no":"2409281908502945155002","queue_number":1111,"trade_uid":"24092819085029445504"}]}
2024-09-28 19:09:17 >>>故障排除日志:删除未同步下发订单成功24092819085029445504
2024-09-28 19:09:17 >>>故障排除日志:删除未同步下发订单成功24092819085029445504
2024-09-28 19:09:18 >>>故障排除日志:终端同步成功后剩余订单列表


===19:16:20===
2024-09-28 19:15:59 >>>回调事件[910,devices/YC0471]
2024-09-28 19:15:59 >>>故障排除日志:上一MQTT订单号缓存列表为24092819085029445504|24092819085029445504
2024-09-28 19:15:59 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 19:15:59 开始打印,排队:1112,票券:2409281915519199065401,订单:24092819155191985775,[2024-09-28 19:15:59微信支付10元]
2024-09-28 19:16:01 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281915519199065401","queue_number":1112,"trade_uid":"24092819155191985775"}]}
2024-09-28 19:16:01 >>>故障排除日志:删除未同步下发订单成功24092819155191985775
2024-09-28 19:16:02 >>>故障排除日志:终端同步成功后剩余订单列表


===19:17:20===
2024-09-28 19:16:53 >>>回调事件[910,devices/YC0471]
2024-09-28 19:16:53 >>>故障排除日志:上一MQTT订单号缓存列表为24092819155191985775
2024-09-28 19:16:53 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 19:16:53 开始打印,排队:1113,票券:2409281916458752233501,订单:24092819164587517058,[2024-09-28 19:16:52微信支付10元]
2024-09-28 19:16:53 开始打印,排队:1114,票券:2409281916458752427302,订单:24092819164587517058,[2024-09-28 19:16:52微信支付10元]
2024-09-28 19:16:53 开始打印,排队:1115,票券:2409281916458752513503,订单:24092819164587517058,[2024-09-28 19:16:52微信支付10元]
2024-09-28 19:16:58 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281916458752233501","queue_number":1113,"trade_uid":"24092819164587517058"},{"ticket_no":"2409281916458752427302","queue_number":1114,"trade_uid":"24092819164587517058"},{"ticket_no":"2409281916458752513503","queue_number":1115,"trade_uid":"24092819164587517058"}]}
2024-09-28 19:16:58 >>>故障排除日志:删除未同步下发订单成功24092819164587517058
2024-09-28 19:16:58 >>>故障排除日志:删除未同步下发订单成功24092819164587517058
2024-09-28 19:16:58 >>>故障排除日志:删除未同步下发订单成功24092819164587517058
2024-09-28 19:16:59 >>>故障排除日志:终端同步成功后剩余订单列表


===19:24:22===
2024-09-28 19:24:18 >>>回调事件[910,devices/YC0471]
2024-09-28 19:24:19 >>>故障排除日志:上一MQTT订单号缓存列表为24092819164587517058|24092819164587517058|24092819164587517058
2024-09-28 19:24:19 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 19:24:19 开始打印,排队:1116,票券:2409281924111407481801,订单:24092819241114070198,[2024-09-28 19:24:18支付宝支付10元]


===19:26:22===
2024-09-28 19:25:25 >>>回调事件[910,devices/YC0471]
2024-09-28 19:25:25 >>>故障排除日志:上一MQTT订单号缓存列表为24092819241114070198
2024-09-28 19:25:25 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 19:25:25 开始打印,排队:1117,票券:2409281925168888640301,订单:24092819251688879938,[2024-09-28 19:25:24微信支付10元]
2024-09-28 19:25:27 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281925168888640301","queue_number":1117,"trade_uid":"24092819251688879938"}]}
2024-09-28 19:25:27 >>>故障排除日志:删除未同步下发订单成功24092819251688879938
2024-09-28 19:25:27 >>>故障排除日志:终端同步成功后剩余订单列表


===19:28:24===
2024-09-28 19:27:29 >>>回调事件[910,devices/YC0471]
2024-09-28 19:27:29 >>>故障排除日志:上一MQTT订单号缓存列表为24092819251688879938
2024-09-28 19:27:29 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 19:27:29 开始打印,排队:1118,票券:2409281927223100598301,订单:24092819272231002585,[2024-09-28 19:27:29微信支付10元]
2024-09-28 19:27:29 开始打印,排队:1119,票券:2409281927223100728302,订单:24092819272231002585,[2024-09-28 19:27:29微信支付10元]
2024-09-28 19:27:33 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281927223100598301","queue_number":1118,"trade_uid":"24092819272231002585"},{"ticket_no":"2409281927223100728302","queue_number":1119,"trade_uid":"24092819272231002585"}]}
2024-09-28 19:27:33 >>>故障排除日志:删除未同步下发订单成功24092819272231002585
2024-09-28 19:27:33 >>>故障排除日志:删除未同步下发订单成功24092819272231002585
2024-09-28 19:27:33 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 19:28:18>>>cash read=00
2024-09-28 19:28:20>>>cash read=818F42
2024-09-28 19:28:20>>>cash write=02
2024-09-28 19:28:20 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-09-28 19:28:20>>>cash read=10
2024-09-28 19:28:20 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-09-28 19:28:20 当前产品价格10元，投币10元，打印小票中...
2024-09-28 19:28:20 >>>开始打印,排队号为1120,订单号为2409281928200004712357
2024-09-28 19:28:21>>>订单2409281928200004712357写入成功,剩余空间为1678500,占用RAM为613.869140625


===19:29:25===
2024-09-28 19:28:24>>>cash write=0C
2024-09-28 19:28:24>>>cash read=3E
2024-09-28 19:28:26>>>cash read=00
2024-09-28 19:28:27>>>cash read=818F42
2024-09-28 19:28:27>>>cash write=02
2024-09-28 19:28:27 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-09-28 19:28:27>>>cash read=10
2024-09-28 19:28:27 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-09-28 19:28:27 当前产品价格10元，投币10元，打印小票中...
2024-09-28 19:28:27 >>>开始打印,排队号为1121,订单号为2409281928270004715887
定时检测未同步订单关闭
2024-09-28 19:28:27>>>订单2409281928270004715887写入成功,剩余空间为1679500,占用RAM为609.3203125
删除未同步订单2409281928270004715887
2024-09-28 19:28:29>>>订单2409281928270004715887删除成功,剩余空间为1680500,占用RAM为619.048828125
检测订单目录中>>>
无未同步订单>>>
2024-09-28 19:28:30 >>>当前Ram内存为590.48828125
定时检测未同步订单启用
2024-09-28 19:28:30>>>cash write=0C
2024-09-28 19:28:31>>>cash read=3E
2024-09-28 19:29:17>>>cash read=9E
2024-09-28 19:29:18>>>cash read=3E


===19:30:25===
定时检测未同步订单关闭
检测订单目录中>>>
无未同步订单>>>


===19:35:26===
2024-09-28 19:34:44 >>>回调事件[910,devices/YC0471]
2024-09-28 19:34:44 >>>故障排除日志:上一MQTT订单号缓存列表为24092819272231002585|24092819272231002585
2024-09-28 19:34:44 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 19:34:44 开始打印,排队:1122,票券:2409281934390713910901,订单:24092819343907134073,[2024-09-28 19:34:44微信支付10元]
2024-09-28 19:34:46 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281934390713910901","queue_number":1122,"trade_uid":"24092819343907134073"}]}
2024-09-28 19:34:46 >>>故障排除日志:删除未同步下发订单成功24092819343907134073
2024-09-28 19:34:46 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 19:35:00>>>cash read=9E
2024-09-28 19:35:02>>>cash read=3E


===19:37:26===
2024-09-28 19:36:56>>>cash read=BF
2024-09-28 19:36:57>>>cash read=3E


===19:40:26===
2024-09-28 19:39:48 >>>回调事件[910,devices/YC0471]
2024-09-28 19:39:48 >>>故障排除日志:上一MQTT订单号缓存列表为24092819343907134073
2024-09-28 19:39:48 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 19:39:48 开始打印,排队:1123,票券:2409281939425453634901,订单:24092819394254532692,[2024-09-28 19:39:47微信支付10元]
2024-09-28 19:39:50 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281939425453634901","queue_number":1123,"trade_uid":"24092819394254532692"}]}
2024-09-28 19:39:50 >>>故障排除日志:删除未同步下发订单成功24092819394254532692
2024-09-28 19:39:50 >>>故障排除日志:终端同步成功后剩余订单列表


===19:41:27===
2024-09-28 19:40:38 >>>回调事件[910,devices/YC0471]
2024-09-28 19:40:38 >>>故障排除日志:上一MQTT订单号缓存列表为24092819394254532692
2024-09-28 19:40:38 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 19:40:38 开始打印,排队:1124,票券:2409281940326523080801,订单:24092819403265225896,[2024-09-28 19:40:37微信支付10元]
2024-09-28 19:40:40 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281940326523080801","queue_number":1124,"trade_uid":"24092819403265225896"}]}
2024-09-28 19:40:40 >>>故障排除日志:删除未同步下发订单成功24092819403265225896
2024-09-28 19:40:40 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 19:41:24 >>>回调事件[910,devices/YC0471]
2024-09-28 19:41:24 >>>故障排除日志:上一MQTT订单号缓存列表为24092819403265225896
2024-09-28 19:41:24 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 19:41:24 开始打印,排队:1125,票券:2409281941134974452401,订单:24092819411349740764,[2024-09-28 19:41:23微信支付10元]


===19:42:27===
2024-09-28 19:41:26 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281941134974452401","queue_number":1125,"trade_uid":"24092819411349740764"}]}
2024-09-28 19:41:26 >>>故障排除日志:删除未同步下发订单成功24092819411349740764
2024-09-28 19:41:26 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 19:42:24 >>>回调事件[910,devices/YC0471]
2024-09-28 19:42:24 >>>故障排除日志:上一MQTT订单号缓存列表为24092819411349740764
2024-09-28 19:42:24 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 19:42:24 开始打印,排队:1126,票券:2409281942162859846401,订单:24092819421628594103,[2024-09-28 19:42:22微信支付10元]


===19:43:27===
2024-09-28 19:42:26 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281942162859846401","queue_number":1126,"trade_uid":"24092819421628594103"}]}
2024-09-28 19:42:26 >>>故障排除日志:删除未同步下发订单成功24092819421628594103
2024-09-28 19:42:26 >>>故障排除日志:终端同步成功后剩余订单列表


===19:45:28===
2024-09-28 19:44:52 >>>回调事件[910,devices/YC0471]
2024-09-28 19:44:53 >>>故障排除日志:上一MQTT订单号缓存列表为24092819421628594103
2024-09-28 19:44:53 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 19:44:53 开始打印,排队:1127,票券:2409281944455305473501,订单:24092819444553048107,[2024-09-28 19:44:52微信支付10元]
2024-09-28 19:44:53 开始打印,排队:1128,票券:2409281944455305690602,订单:24092819444553048107,[2024-09-28 19:44:52微信支付10元]
2024-09-28 19:44:56 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281944455305473501","queue_number":1127,"trade_uid":"24092819444553048107"},{"ticket_no":"2409281944455305690602","queue_number":1128,"trade_uid":"24092819444553048107"}]}
2024-09-28 19:44:56 >>>故障排除日志:删除未同步下发订单成功24092819444553048107
2024-09-28 19:44:56 >>>故障排除日志:删除未同步下发订单成功24092819444553048107
2024-09-28 19:44:56 >>>故障排除日志:终端同步成功后剩余订单列表


===19:47:28===
2024-09-28 19:47:04 >>>回调事件[910,devices/YC0471]
2024-09-28 19:47:04 >>>故障排除日志:上一MQTT订单号缓存列表为24092819444553048107|24092819444553048107
2024-09-28 19:47:04 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 19:47:04 开始打印,排队:1129,票券:2409281946522209408601,订单:24092819465222089634,[2024-09-28 19:47:03微信支付10元]
2024-09-28 19:47:06 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281946522209408601","queue_number":1129,"trade_uid":"24092819465222089634"}]}
2024-09-28 19:47:06 >>>故障排除日志:删除未同步下发订单成功24092819465222089634
2024-09-28 19:47:06 >>>故障排除日志:终端同步成功后剩余订单列表


===19:48:29===
2024-09-28 19:47:39>>>cash read=0A
2024-09-28 19:47:41>>>cash read=3E


===19:50:29===
2024-09-28 19:49:49 >>>回调事件[910,devices/YC0471]
2024-09-28 19:49:50 >>>故障排除日志:上一MQTT订单号缓存列表为24092819465222089634
2024-09-28 19:49:50 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 19:49:50 开始打印,排队:1130,票券:2409281949433752240201,订单:24092819494337518927,[2024-09-28 19:49:49微信支付10元]
2024-09-28 19:49:51 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281949433752240201","queue_number":1130,"trade_uid":"24092819494337518927"}]}
2024-09-28 19:49:52 >>>故障排除日志:删除未同步下发订单成功24092819494337518927
2024-09-28 19:49:52 >>>故障排除日志:终端同步成功后剩余订单列表


===19:55:29===
2024-09-28 19:54:35 >>>回调事件[910,devices/YC0471]
2024-09-28 19:54:35 >>>故障排除日志:上一MQTT订单号缓存列表为24092819494337518927
2024-09-28 19:54:35 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 19:54:35 开始打印,排队:1131,票券:2409281954260133772701,订单:24092819542601333261,[2024-09-28 19:54:33微信支付10元]
2024-09-28 19:54:37 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281954260133772701","queue_number":1131,"trade_uid":"24092819542601333261"}]}
2024-09-28 19:54:37 >>>故障排除日志:删除未同步下发订单成功24092819542601333261
2024-09-28 19:54:37 >>>故障排除日志:终端同步成功后剩余订单列表


===20:00:30===
2024-09-28 20:00:00 >>>回调事件[910,devices/YC0471]
2024-09-28 20:00:00 >>>故障排除日志:上一MQTT订单号缓存列表为24092819542601333261
2024-09-28 20:00:00 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 20:00:00 开始打印,排队:1132,票券:2409281959510812507201,订单:24092819595108120589,[2024-09-28 19:59:59微信支付10元]
2024-09-28 20:00:02 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281959510812507201","queue_number":1132,"trade_uid":"24092819595108120589"}]}
2024-09-28 20:00:02 >>>故障排除日志:删除未同步下发订单成功24092819595108120589
2024-09-28 20:00:02 >>>故障排除日志:终端同步成功后剩余订单列表


===20:03:30===
2024-09-28 20:03:18 >>>回调事件[910,devices/YC0471]
2024-09-28 20:03:18 >>>故障排除日志:上一MQTT订单号缓存列表为24092819595108120589
2024-09-28 20:03:18 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 20:03:19 开始打印,排队:1133,票券:2409282003132384826001,订单:24092820031323841140,[2024-09-28 20:03:18支付宝支付10元]
2024-09-28 20:03:21 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409282003132384826001","queue_number":1133,"trade_uid":"24092820031323841140"}]}
2024-09-28 20:03:21 >>>故障排除日志:删除未同步下发订单成功24092820031323841140
2024-09-28 20:03:21 >>>故障排除日志:终端同步成功后剩余订单列表


===20:16:30===
2024-09-28 20:16:16>>>cash read=0A
2024-09-28 20:16:17>>>cash read=3E


===20:17:30===
2024-09-28 20:16:54 >>>回调事件[910,devices/YC0471]
2024-09-28 20:16:54 >>>故障排除日志:上一MQTT订单号缓存列表为24092820031323841140
2024-09-28 20:16:54 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 20:16:54 开始打印,排队:1134,票券:2409282016492538112401,订单:24092820164925373998,[2024-09-28 20:16:54微信支付10元]
2024-09-28 20:16:56 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409282016492538112401","queue_number":1134,"trade_uid":"24092820164925373998"}]}
2024-09-28 20:16:56 >>>故障排除日志:删除未同步下发订单成功24092820164925373998
2024-09-28 20:16:56 >>>故障排除日志:终端同步成功后剩余订单列表


===20:20:31===
2024-09-28 20:20:28 >>>回调事件[910,devices/YC0471]
2024-09-28 20:20:28 >>>故障排除日志:上一MQTT订单号缓存列表为24092820164925373998
2024-09-28 20:20:28 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 20:20:28 开始打印,排队:1135,票券:2409282020206560029501,订单:24092820202065595934,[2024-09-28 20:20:27微信支付10元]


===20:25:31===
2024-09-28 20:24:50 >>>回调事件[910,devices/YC0471]
2024-09-28 20:24:50 >>>故障排除日志:上一MQTT订单号缓存列表为24092820202065595934
2024-09-28 20:24:50 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 20:24:50 开始打印,排队:1136,票券:2409282024440687166901,订单:24092820244406864845,[2024-09-28 20:24:49微信支付10元]
2024-09-28 20:24:52 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409282024440687166901","queue_number":1136,"trade_uid":"24092820244406864845"}]}
2024-09-28 20:24:52 >>>故障排除日志:删除未同步下发订单成功24092820244406864845
2024-09-28 20:24:52 >>>故障排除日志:终端同步成功后剩余订单列表


===20:27:32===
2024-09-28 20:27:11>>>cash read=9E
2024-09-28 20:27:12>>>cash read=3E


===20:28:32===
2024-09-28 20:27:34 >>>回调事件[910,devices/YC0471]
2024-09-28 20:27:34 >>>故障排除日志:上一MQTT订单号缓存列表为24092820244406864845
2024-09-28 20:27:34 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 20:27:34 开始打印,排队:1137,票券:2409282027286101373801,订单:24092820272861009729,[2024-09-28 20:27:34微信支付10元]
2024-09-28 20:27:36 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409282027286101373801","queue_number":1137,"trade_uid":"24092820272861009729"}]}
2024-09-28 20:27:36 >>>故障排除日志:删除未同步下发订单成功24092820272861009729
2024-09-28 20:27:36 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 20:28:11 >>>回调事件[910,devices/YC0471]
2024-09-28 20:28:11 >>>故障排除日志:上一MQTT订单号缓存列表为24092820272861009729
2024-09-28 20:28:11 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 20:28:11 开始打印,排队:1138,票券:2409282028049536305401,订单:24092820280495349870,[2024-09-28 20:28:10微信支付10元]
2024-09-28 20:28:13 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409282028049536305401","queue_number":1138,"trade_uid":"24092820280495349870"}]}
2024-09-28 20:28:13 >>>故障排除日志:删除未同步下发订单成功24092820280495349870
2024-09-28 20:28:13 >>>故障排除日志:终端同步成功后剩余订单列表


===20:30:32===
2024-09-28 20:29:59 >>>回调事件[910,devices/YC0471]
2024-09-28 20:29:59 >>>故障排除日志:上一MQTT订单号缓存列表为24092820280495349870
2024-09-28 20:29:59 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 20:29:59 开始打印,排队:1139,票券:2409282029535091582801,订单:24092820295350909770,[2024-09-28 20:29:59微信支付10元]
2024-09-28 20:30:01 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409282029535091582801","queue_number":1139,"trade_uid":"24092820295350909770"}]}
2024-09-28 20:30:01 >>>故障排除日志:删除未同步下发订单成功24092820295350909770
2024-09-28 20:30:01 >>>故障排除日志:终端同步成功后剩余订单列表


===20:33:32===
2024-09-28 20:33:02 >>>回调事件[910,devices/YC0471]
2024-09-28 20:33:02 >>>故障排除日志:上一MQTT订单号缓存列表为24092820295350909770
2024-09-28 20:33:02 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 20:33:02 开始打印,排队:1140,票券:2409282032570878372601,订单:24092820325708779798,[2024-09-28 20:33:02微信支付10元]
2024-09-28 20:33:04 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409282032570878372601","queue_number":1140,"trade_uid":"24092820325708779798"}]}
2024-09-28 20:33:04 >>>故障排除日志:删除未同步下发订单成功24092820325708779798
2024-09-28 20:33:04 >>>故障排除日志:终端同步成功后剩余订单列表


===20:34:32===
2024-09-28 20:34:28 >>>回调事件[910,devices/YC0471]
2024-09-28 20:34:28 >>>故障排除日志:上一MQTT订单号缓存列表为24092820325708779798
2024-09-28 20:34:28 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 20:34:28 开始打印,排队:1141,票券:2409282034186963641301,订单:24092820341869632950,[2024-09-28 20:34:28微信支付10元]
2024-09-28 20:34:30 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409282034186963641301","queue_number":1141,"trade_uid":"24092820341869632950"}]}
2024-09-28 20:34:30 >>>故障排除日志:删除未同步下发订单成功24092820341869632950
2024-09-28 20:34:31 >>>故障排除日志:终端同步成功后剩余订单列表


===20:39:33===
2024-09-28 20:39:06 >>>回调事件[910,devices/YC0471]
2024-09-28 20:39:06 >>>故障排除日志:上一MQTT订单号缓存列表为24092820341869632950
2024-09-28 20:39:06 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 20:39:07 开始打印,排队:1142,票券:2409282039009125483701,订单:24092820390091250276,[2024-09-28 20:39:06微信支付10元]
2024-09-28 20:39:08 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409282039009125483701","queue_number":1142,"trade_uid":"24092820390091250276"}]}
2024-09-28 20:39:08 >>>故障排除日志:删除未同步下发订单成功24092820390091250276
2024-09-28 20:39:09 >>>故障排除日志:终端同步成功后剩余订单列表


===20:50:33===
2024-09-28 20:50:26 >>>回调事件[910,devices/YC0471]
2024-09-28 20:50:26 >>>故障排除日志:上一MQTT订单号缓存列表为24092820390091250276
2024-09-28 20:50:26 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 20:50:26 开始打印,排队:1143,票券:2409282050176518367001,订单:24092820501765179554,[2024-09-28 20:50:25微信支付10元]
2024-09-28 20:50:28 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409282050176518367001","queue_number":1143,"trade_uid":"24092820501765179554"}]}
2024-09-28 20:50:28 >>>故障排除日志:删除未同步下发订单成功24092820501765179554
2024-09-28 20:50:28 >>>故障排除日志:终端同步成功后剩余订单列表


===20:52:33===
2024-09-28 20:51:32 >>>回调事件[910,devices/YC0471]
2024-09-28 20:51:32 >>>故障排除日志:上一MQTT订单号缓存列表为24092820501765179554
2024-09-28 20:51:33 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 20:51:33 开始打印,排队:1144,票券:2409282051227923568501,订单:24092820512279230976,[2024-09-28 20:51:31微信支付10元]
2024-09-28 20:51:34 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409282051227923568501","queue_number":1144,"trade_uid":"24092820512279230976"}]}
2024-09-28 20:51:34 >>>故障排除日志:删除未同步下发订单成功24092820512279230976
2024-09-28 20:51:35 >>>故障排除日志:终端同步成功后剩余订单列表


===20:53:34===
2024-09-28 20:53:21 >>>回调事件[910,devices/YC0471]
2024-09-28 20:53:21 >>>故障排除日志:上一MQTT订单号缓存列表为24092820512279230976
2024-09-28 20:53:21 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 20:53:21 开始打印,排队:1145,票券:2409282053131578067501,订单:24092820531315776876,[2024-09-28 20:53:20微信支付10元]
2024-09-28 20:53:23 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409282053131578067501","queue_number":1145,"trade_uid":"24092820531315776876"}]}
2024-09-28 20:53:23 >>>故障排除日志:删除未同步下发订单成功24092820531315776876
2024-09-28 20:53:23 >>>故障排除日志:终端同步成功后剩余订单列表


===21:02:34===
2024-09-28 21:02:19 >>>回调事件[910,devices/YC0471]
2024-09-28 21:02:19 >>>故障排除日志:上一MQTT订单号缓存列表为24092820531315776876
2024-09-28 21:02:19 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 21:02:19 开始打印,排队:1146,票券:2409282102117071411701,订单:24092821021170704885,[2024-09-28 21:02:18微信支付10元]
2024-09-28 21:02:21 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409282102117071411701","queue_number":1146,"trade_uid":"24092821021170704885"}]}
2024-09-28 21:02:21 >>>故障排除日志:删除未同步下发订单成功24092821021170704885
2024-09-28 21:02:21 >>>故障排除日志:终端同步成功后剩余订单列表


===21:09:34===
2024-09-28 21:08:35>>>cash read=1F
2024-09-28 21:08:36>>>cash read=3E


===21:19:35===
2024-09-28 21:19:28>>>cash read=0A
2024-09-28 21:19:30>>>cash read=3E


===21:23:35===
2024-09-28 21:22:45>>>cash read=9E
2024-09-28 21:22:46>>>cash read=3E


===21:31:35===
2024-09-28 21:31:22>>>cash read=9E
2024-09-28 21:31:23>>>cash read=3E


===21:32:39===
2024-09-28 21:32:18 收到下发指令:叫号986>>>
2024-09-28 21:32:19 收到下发指令:叫号987>>>
2024-09-28 21:32:20 收到下发指令:叫号988>>>
2024-09-28 21:32:21 收到下发指令:叫号989>>>
2024-09-28 21:32:22 收到下发指令:叫号990>>>
2024-09-28 21:32:23 收到下发指令:叫号991>>>
2024-09-28 21:32:23 收到下发指令:叫号992>>>
2024-09-28 21:32:24 收到下发指令:叫号993>>>
2024-09-28 21:32:25 收到下发指令:叫号994>>>
2024-09-28 21:32:26 收到下发指令:叫号995>>>
2024-09-28 21:32:27 收到下发指令:叫号996>>>
2024-09-28 21:32:27 收到下发指令:叫号997>>>
2024-09-28 21:32:28 收到下发指令:叫号998>>>
2024-09-28 21:32:29 收到下发指令:叫号999>>>
2024-09-28 21:32:30 收到下发指令:叫号1000>>>
2024-09-28 21:32:31 收到下发指令:叫号1001>>>
2024-09-28 21:32:32 收到下发指令:叫号1002>>>
2024-09-28 21:32:33 收到下发指令:叫号1003>>>
2024-09-28 21:32:34 收到下发指令:叫号1004>>>
2024-09-28 21:32:35 收到下发指令:叫号1005>>>
2024-09-28 21:32:36 收到下发指令:叫号1006>>>
2024-09-28 21:32:37 收到下发指令:叫号1007>>>


===21:33:42===
2024-09-28 21:32:40 收到下发指令:叫号1011>>>
2024-09-28 21:32:41 收到下发指令:叫号1012>>>
2024-09-28 21:32:42 收到下发指令:叫号1013>>>
2024-09-28 21:32:43 收到下发指令:叫号1014>>>
2024-09-28 21:32:44 收到下发指令:叫号1015>>>
2024-09-28 21:32:44 收到下发指令:叫号1016>>>
2024-09-28 21:32:45 收到下发指令:叫号1017>>>
2024-09-28 21:32:46 收到下发指令:叫号1018>>>
2024-09-28 21:32:47 收到下发指令:叫号1019>>>
2024-09-28 21:32:48 收到下发指令:叫号1020>>>
2024-09-28 21:32:48 收到下发指令:叫号1021>>>
2024-09-28 21:32:49 收到下发指令:叫号1022>>>
2024-09-28 21:32:50 收到下发指令:叫号1023>>>
2024-09-28 21:32:50 收到下发指令:叫号1024>>>
2024-09-28 21:32:52 收到下发指令:叫号1025>>>
2024-09-28 21:32:52 收到下发指令:叫号1026>>>
2024-09-28 21:32:52 收到下发指令:叫号1027>>>
2024-09-28 21:32:54 收到下发指令:叫号1028>>>
2024-09-28 21:32:54 收到下发指令:叫号1029>>>
2024-09-28 21:32:54 收到下发指令:叫号1030>>>
2024-09-28 21:32:55 收到下发指令:叫号1031>>>
2024-09-28 21:32:56 收到下发指令:叫号1032>>>
2024-09-28 21:32:57 收到下发指令:叫号1033>>>
2024-09-28 21:32:58 收到下发指令:叫号1034>>>


===21:34:42===
2024-09-28 21:33:45>>>cash read=1F
2024-09-28 21:33:46>>>cash read=3E


===21:38:42===
2024-09-28 21:37:56 收到下发指令:叫号1035>>>
2024-09-28 21:37:57 收到下发指令:叫号1036>>>
2024-09-28 21:37:58 收到下发指令:叫号1037>>>
2024-09-28 21:38:01 收到下发指令:叫号1038>>>
2024-09-28 21:38:02 收到下发指令:叫号1039>>>
2024-09-28 21:38:03 收到下发指令:叫号1040>>>
2024-09-28 21:38:04 收到下发指令:叫号1041>>>
2024-09-28 21:38:05 收到下发指令:叫号1042>>>
2024-09-28 21:38:06 收到下发指令:叫号1043>>>
2024-09-28 21:38:08 收到下发指令:叫号1044>>>
2024-09-28 21:38:09 收到下发指令:叫号1045>>>
2024-09-28 21:38:10 收到下发指令:叫号1046>>>
2024-09-28 21:38:12 收到下发指令:叫号1047>>>
2024-09-28 21:38:12 收到下发指令:叫号1048>>>
2024-09-28 21:38:13 收到下发指令:叫号1049>>>
2024-09-28 21:38:14 收到下发指令:叫号1050>>>
2024-09-28 21:38:19 收到下发指令:叫号1051>>>
2024-09-28 21:38:20 收到下发指令:叫号1052>>>
2024-09-28 21:38:21 收到下发指令:叫号1053>>>
2024-09-28 21:38:24 收到下发指令:叫号1054>>>
2024-09-28 21:38:25 收到下发指令:叫号1055>>>
2024-09-28 21:38:26 收到下发指令:叫号1056>>>
2024-09-28 21:38:32 收到下发指令:叫号1057>>>
2024-09-28 21:38:36 收到下发指令:叫号1058>>>
2024-09-28 21:38:39 收到下发指令:叫号1059>>>


===21:39:45===
2024-09-28 21:38:46 收到下发指令:叫号1060>>>
2024-09-28 21:38:47 收到下发指令:叫号1061>>>
2024-09-28 21:38:48 收到下发指令:叫号1062>>>
2024-09-28 21:38:49 收到下发指令:叫号1063>>>
2024-09-28 21:38:53 收到下发指令:叫号1064>>>
2024-09-28 21:39:01 收到下发指令:叫号1065>>>
2024-09-28 21:39:05 收到下发指令:叫号1066>>>
2024-09-28 21:39:07 收到下发指令:叫号1067>>>
2024-09-28 21:39:08 收到下发指令:叫号1068>>>
2024-09-28 21:39:09 收到下发指令:叫号1069>>>
2024-09-28 21:39:10 收到下发指令:叫号1070>>>
2024-09-28 21:39:11 收到下发指令:叫号1071>>>
2024-09-28 21:39:12 收到下发指令:叫号1072>>>
2024-09-28 21:39:13 收到下发指令:叫号1073>>>
2024-09-28 21:39:14 收到下发指令:叫号1074>>>
2024-09-28 21:39:15 收到下发指令:叫号1075>>>
2024-09-28 21:39:16 收到下发指令:叫号1076>>>
2024-09-28 21:39:17 收到下发指令:叫号1077>>>
2024-09-28 21:39:18 收到下发指令:叫号1078>>>
2024-09-28 21:39:30 收到下发指令:叫号1079>>>
2024-09-28 21:39:31 收到下发指令:叫号1080>>>
2024-09-28 21:39:32 收到下发指令:叫号1081>>>
2024-09-28 21:39:33 收到下发指令:叫号1082>>>
2024-09-28 21:39:34 收到下发指令:叫号1083>>>
2024-09-28 21:39:35 收到下发指令:叫号1084>>>
2024-09-28 21:39:36 收到下发指令:叫号1085>>>
2024-09-28 21:39:36 收到下发指令:叫号1086>>>
2024-09-28 21:39:36 收到下发指令:叫号1087>>>
2024-09-28 21:39:38 收到下发指令:叫号1088>>>
2024-09-28 21:39:38 收到下发指令:叫号1089>>>
2024-09-28 21:39:40 收到下发指令:叫号1090>>>
2024-09-28 21:39:41 收到下发指令:叫号1091>>>
2024-09-28 21:39:42 收到下发指令:叫号1092>>>
2024-09-28 21:39:43 收到下发指令:叫号1093>>>


===21:40:49===
2024-09-28 21:39:47 收到下发指令:叫号1099>>>
2024-09-28 21:39:48 收到下发指令:叫号1100>>>
2024-09-28 21:39:48 收到下发指令:叫号1101>>>
2024-09-28 21:39:49 收到下发指令:叫号1102>>>
2024-09-28 21:39:49 收到下发指令:叫号1103>>>
2024-09-28 21:39:50 收到下发指令:叫号1104>>>
2024-09-28 21:39:50 收到下发指令:叫号1105>>>
2024-09-28 21:39:51 收到下发指令:叫号1106>>>
2024-09-28 21:39:52 收到下发指令:叫号1107>>>
2024-09-28 21:39:52 收到下发指令:叫号1108>>>
2024-09-28 21:39:53 收到下发指令:叫号1109>>>
2024-09-28 21:39:54 收到下发指令:叫号1110>>>
2024-09-28 21:39:55 收到下发指令:叫号1111>>>
2024-09-28 21:39:55 收到下发指令:叫号1112>>>
2024-09-28 21:39:56 收到下发指令:叫号1113>>>
2024-09-28 21:39:56 收到下发指令:叫号1114>>>
2024-09-28 21:39:57 收到下发指令:叫号1115>>>
2024-09-28 21:39:57 收到下发指令:叫号1116>>>
2024-09-28 21:39:58 收到下发指令:叫号1117>>>
2024-09-28 21:39:59 收到下发指令:叫号1118>>>
2024-09-28 21:39:59 收到下发指令:叫号1119>>>
2024-09-28 21:40:00 收到下发指令:叫号1120>>>
2024-09-28 21:40:01 收到下发指令:叫号1121>>>
2024-09-28 21:40:01 收到下发指令:叫号1122>>>
2024-09-28 21:40:01 收到下发指令:叫号1123>>>
2024-09-28 21:40:02 收到下发指令:叫号1124>>>
2024-09-28 21:40:03 收到下发指令:叫号1125>>>
2024-09-28 21:40:03 收到下发指令:叫号1126>>>
2024-09-28 21:40:04 收到下发指令:叫号1127>>>
2024-09-28 21:40:04 收到下发指令:叫号1128>>>
2024-09-28 21:40:05 收到下发指令:叫号1129>>>
2024-09-28 21:40:05 收到下发指令:叫号1130>>>
2024-09-28 21:40:06 收到下发指令:叫号1131>>>
2024-09-28 21:40:07 收到下发指令:叫号1132>>>
2024-09-28 21:40:07 收到下发指令:叫号1133>>>
2024-09-28 21:40:08 收到下发指令:叫号1134>>>
2024-09-28 21:40:09 收到下发指令:叫号1135>>>
2024-09-28 21:40:09 收到下发指令:叫号1136>>>
2024-09-28 21:40:10 收到下发指令:叫号1137>>>
2024-09-28 21:40:10 收到下发指令:叫号1138>>>
2024-09-28 21:40:11 收到下发指令:叫号1139>>>
2024-09-28 21:40:11 收到下发指令:叫号1140>>>
2024-09-28 21:40:12 收到下发指令:叫号1141>>>
2024-09-28 21:40:12 收到下发指令:叫号1142>>>
2024-09-28 21:40:13 收到下发指令:叫号1143>>>
2024-09-28 21:40:13 收到下发指令:叫号1144>>>
2024-09-28 21:40:13 收到下发指令:叫号1145>>>
2024-09-28 21:40:15 收到下发指令:叫号1146>>>