TLClient_JSSCOM_LuatOS-Air_V4010_RDA8910_RFTTS_0xe0000,2.5.4,861658061010321,52253373573389,
poweron reason:0

===08:06:54===
上一时间戳为1727743340
隔日重置时间戳true
隔日清空未同步下发列表true
当前排队号为1,音量为5
初始化产品信息:[{"time_limit_date":"","ticket_category":"0","expiry_date":90,"product_detail":"","time_limit_status":"0","begin_minute":"00","product_uid":"12565527731040802892","use_timer":1,"old_price":"10","end_hour":"23","sale_price":"10","end_minute":"59","begin_hour":"00","sale_status":1,"product_name":"快剪"}]
打印门店标题设置为欢迎光临恒剪（宁波骆驼欧尚店）
是否打印二维码设置为1
是否打印紧凑设置为0
session_id:37fcd****7828c
纸币器设置接收纸币范围为36
欢迎使用天羚自助售票系统[2.5.4]
定时检测未同步订单启用
2024-10-02 08:05:54>>>cash write=30
2024-10-02 08:05:54>>>cash write=02
2024-10-02 08:05:54>>>cash write=3E
系统时间初始化成功，时间为20241028554
2024-10-02 08:05:55>>>cash read=818F42
2024-10-02 08:05:55>>>cash write=02
2024-10-02 08:05:55 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-02 08:05:55 >>>剩余flash空间=1680000,占用RAM为586.1591796875
2024-10-02 08:05:55 >>>回调事件:910,subscribe,10000,连接服务器成功

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

2024-10-02 08:05:55>>>cash read=10
2024-10-02 08:05:55 >>>回调事件130,10,10023,finish Money=10,进钞完成
当日首次设置时间戳true为1727827555
2024-10-02 08:05:55 当前产品价格10元，投币10元，打印小票中...
2024-10-02 08:05:56 >>>开始打印,排队号为1,订单号为2410020805560002644012
定时检测未同步订单关闭
2024-10-02 08:05:56>>>订单2410020805560002644012写入成功,剩余空间为1678500,占用RAM为619.3828125
删除未同步订单2410020805560002644012
2024-10-02 08:05:58>>>订单2410020805560002644012删除成功,剩余空间为1679500,占用RAM为625.8193359375
检测订单目录中>>>
无未同步订单>>>
2024-10-02 08:05:58 >>>当前Ram内存为592.1767578125
定时检测未同步订单启用
流量卡还有180天过期
2024-10-02 08:05:59>>>cash write=0C
2024-10-02 08:05:59>>>cash read=3E
2024-10-02 08:06:02 >>>当前Ram内存为640.5634765625


===08:07:55===
定时检测未同步订单关闭
检测订单目录中>>>
无未同步订单>>>


===08:46:55===
2024-10-02 08:45:58 >>>回调事件[910,devices/D0264]
2024-10-02 08:45:58 >>>故障排除日志:上一MQTT订单号缓存列表为24100120572497621263
2024-10-02 08:45:58 >>>故障排除日志:终端未同步成功订单列表
2024-10-02 08:45:58 开始打印,排队:2,票券:2410020845483759699401,订单:24100208454837592361,[2024-10-02 08:45:57微信支付10元]
2024-10-02 08:46:00 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410020845483759699401","queue_number":2,"trade_uid":"24100208454837592361"}]}
2024-10-02 08:46:00 >>>故障排除日志:删除未同步下发订单成功24100208454837592361
2024-10-02 08:46:00 >>>故障排除日志:终端同步成功后剩余订单列表


===08:51:55===
2024-10-02 08:51:34>>>cash read=9E
2024-10-02 08:51:35>>>cash read=3E


===08:57:55===
2024-10-02 08:57:31 >>>回调事件[910,devices/D0264]
2024-10-02 08:57:31 >>>故障排除日志:上一MQTT订单号缓存列表为24100208454837592361
2024-10-02 08:57:31 >>>故障排除日志:终端未同步成功订单列表
2024-10-02 08:57:31 开始打印,排队:3,票券:2410020857219203253601,订单:24100208572192028626,[2024-10-02 08:57:31微信支付10元]
2024-10-02 08:57:33 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410020857219203253601","queue_number":3,"trade_uid":"24100208572192028626"}]}
2024-10-02 08:57:33 >>>故障排除日志:删除未同步下发订单成功24100208572192028626
2024-10-02 08:57:33 >>>故障排除日志:终端同步成功后剩余订单列表


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


===08:59:56===
2024-10-02 08:59:27 >>>回调事件[910,devices/D0264]
2024-10-02 08:59:27 >>>故障排除日志:上一MQTT订单号缓存列表为24100208582930065339
2024-10-02 08:59:27 >>>故障排除日志:终端未同步成功订单列表
2024-10-02 08:59:27 开始打印,排队:5,票券:2410020859207524228201,订单:24100208592075237541,[2024-10-02 08:59:26微信支付10元]
2024-10-02 08:59:29 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410020859207524228201","queue_number":5,"trade_uid":"24100208592075237541"}]}
2024-10-02 08:59:29 >>>故障排除日志:删除未同步下发订单成功24100208592075237541
2024-10-02 08:59:29 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


===09:22:56===
2024-10-02 09:22:12>>>cash read=00
2024-10-02 09:22:12>>>cash read=2F29
2024-10-02 09:22:14>>>cash read=01
2024-10-02 09:22:15>>>cash read=2F
2024-10-02 09:22:16>>>cash read=3E
2024-10-02 09:22:17>>>cash read=00
2024-10-02 09:22:18>>>cash read=29
2024-10-02 09:22:18 >>>回调事件130,cash_status,20029,退钞中
2024-10-02 09:22:19>>>cash read=2F29
2024-10-02 09:22:20>>>cash read=3E
2024-10-02 09:22:22>>>cash read=00
2024-10-02 09:22:22>>>cash read=818F42
2024-10-02 09:22:22>>>cash write=02
2024-10-02 09:22:22 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-02 09:22:23>>>cash read=10
2024-10-02 09:22:23 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-02 09:22:23 当前产品价格10元，投币10元，打印小票中...
2024-10-02 09:22:23 >>>开始打印,排队号为8,订单号为2410020922230002648061
2024-10-02 09:22:23>>>订单2410020922230002648061写入成功,剩余空间为1679500,占用RAM为610.8525390625
删除未同步订单2410020922230002648061
2024-10-02 09:22:25>>>订单2410020922230002648061删除成功,剩余空间为1680000,占用RAM为622.736328125
检测订单目录中>>>
无未同步订单>>>
2024-10-02 09:22:25 >>>当前Ram内存为591.75
定时检测未同步订单启用
2024-10-02 09:22:26>>>cash write=0C
2024-10-02 09:22:26>>>cash read=3E


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


===09:26:56===
2024-10-02 09:26:30>>>cash read=00
2024-10-02 09:26:31>>>cash read=01
2024-10-02 09:26:37>>>cash read=00
2024-10-02 09:26:38>>>cash read=2F29
2024-10-02 09:26:39>>>cash read=3E
2024-10-02 09:26:47>>>cash read=00
2024-10-02 09:26:48>>>cash read=292F292F
2024-10-02 09:26:48 >>>回调事件130,cash_status,20029,退钞中
2024-10-02 09:26:49>>>cash read=3E
2024-10-02 09:26:51>>>cash read=2F29
2024-10-02 09:26:52>>>cash read=01
2024-10-02 09:26:53>>>cash read=2F
2024-10-02 09:26:54>>>cash read=3E


===09:27:57===
2024-10-02 09:26:57>>>cash read=00
2024-10-02 09:26:57>>>cash read=818F42
2024-10-02 09:26:57>>>cash write=02
2024-10-02 09:26:57 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-02 09:26:58>>>cash read=10
2024-10-02 09:26:58 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-02 09:26:58 当前产品价格10元，投币10元，打印小票中...
2024-10-02 09:26:58 >>>开始打印,排队号为9,订单号为2410020926580002649237
2024-10-02 09:26:58>>>订单2410020926580002649237写入成功,剩余空间为1680000,占用RAM为608.408203125
删除未同步订单2410020926580002649237
2024-10-02 09:27:00>>>订单2410020926580002649237删除成功,剩余空间为1680500,占用RAM为621.90234375
检测订单目录中>>>
无未同步订单>>>
2024-10-02 09:27:00 >>>当前Ram内存为591.1396484375
定时检测未同步订单启用
2024-10-02 09:27:01>>>cash write=0C
2024-10-02 09:27:01>>>cash read=3E
2024-10-02 09:27:46 >>>回调事件[910,devices/D0264]
2024-10-02 09:27:46 >>>故障排除日志:上一MQTT订单号缓存列表为24100209185709564021
2024-10-02 09:27:46 >>>故障排除日志:终端未同步成功订单列表
2024-10-02 09:27:47 开始打印,排队:10,票券:2410020927405262234201,订单:24100209274052618027,[2024-10-02 09:27:46微信支付10元]
2024-10-02 09:27:48 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410020927405262234201","queue_number":10,"trade_uid":"24100209274052618027"}]}
2024-10-02 09:27:49 >>>故障排除日志:删除未同步下发订单成功24100209274052618027
2024-10-02 09:27:49 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


===09:44:58===
2024-10-02 09:44:39>>>cash read=00
2024-10-02 09:44:40>>>cash read=2F29
2024-10-02 09:44:41>>>cash read=3E
2024-10-02 09:44:42>>>cash read=29
2024-10-02 09:44:42 >>>回调事件130,cash_status,20029,退钞中
2024-10-02 09:44:43>>>cash read=01
2024-10-02 09:44:44>>>cash read=3E
2024-10-02 09:44:47>>>cash read=29
2024-10-02 09:44:47 >>>回调事件130,cash_status,20029,退钞中
2024-10-02 09:44:48>>>cash read=01
2024-10-02 09:44:49>>>cash read=29
2024-10-02 09:44:49 >>>回调事件130,cash_status,20029,退钞中
2024-10-02 09:44:50>>>cash read=3E
2024-10-02 09:44:54>>>cash read=00
2024-10-02 09:44:55>>>cash read=818F42
2024-10-02 09:44:55>>>cash write=02
2024-10-02 09:44:55 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-02 09:44:55>>>cash read=10
2024-10-02 09:44:55 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-02 09:44:55 当前产品价格10元，投币10元，打印小票中...
2024-10-02 09:44:55 >>>开始打印,排队号为14,订单号为2410020944550002649828
2024-10-02 09:44:55>>>订单2410020944550002649828写入成功,剩余空间为1679000,占用RAM为611.8701171875


===09:45:59===
删除未同步订单2410020944550002649828
2024-10-02 09:44:57>>>订单2410020944550002649828删除成功,剩余空间为1681500,占用RAM为627.775390625
检测订单目录中>>>
无未同步订单>>>
2024-10-02 09:44:58 >>>当前Ram内存为590.7822265625
定时检测未同步订单启用
2024-10-02 09:44:58>>>cash write=0C
2024-10-02 09:44:59>>>cash read=3E
定时检测未同步订单关闭
检测订单目录中>>>
无未同步订单>>>


===09:49:59===
2024-10-02 09:49:38>>>cash read=00
2024-10-02 09:49:39>>>cash read=818F42
2024-10-02 09:49:39>>>cash write=02
2024-10-02 09:49:39 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-02 09:49:39 >>>回调事件[910,devices/D0264]
2024-10-02 09:49:39 >>>故障排除日志:上一MQTT订单号缓存列表为24100209381779219074
2024-10-02 09:49:39 >>>故障排除日志:终端未同步成功订单列表
2024-10-02 09:49:39 开始打印,排队:15,票券:2410020949322621191901,订单:24100209493226207983,[2024-10-02 09:49:38微信支付10元]
2024-10-02 09:49:41>>>cash read=10
2024-10-02 09:49:41 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-02 09:49:41 当前产品价格10元，投币10元，打印小票中...
2024-10-02 09:49:41 >>>开始打印,排队号为16,订单号为2410020949410002649653
2024-10-02 09:49:41>>>订单2410020949410002649653写入成功,剩余空间为1679500,占用RAM为625.728515625
2024-10-02 09:49:43 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410020949322621191901","queue_number":15,"trade_uid":"24100209493226207983"}]}
2024-10-02 09:49:43 >>>故障排除日志:删除未同步下发订单成功24100209493226207983
2024-10-02 09:49:43 >>>故障排除日志:终端同步成功后剩余订单列表
删除未同步订单2410020949410002649653
2024-10-02 09:49:43>>>订单2410020949410002649653删除成功,剩余空间为1680000,占用RAM为606.1279296875
检测订单目录中>>>
无未同步订单>>>
2024-10-02 09:49:44 >>>当前Ram内存为593.2822265625
定时检测未同步订单启用
2024-10-02 09:49:45>>>cash write=0C
2024-10-02 09:49:45>>>cash read=3E


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


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


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


===10:03:00===
2024-10-02 10:02:54>>>cash read=0A
2024-10-02 10:02:55>>>cash read=3E


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


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


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


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


===10:25:01===
2024-10-02 10:24:55 >>>回调事件[910,devices/D0264]
2024-10-02 10:24:55 >>>故障排除日志:上一MQTT订单号缓存列表为24100210134400835176
2024-10-02 10:24:55 >>>故障排除日志:终端未同步成功订单列表
2024-10-02 10:24:55 开始打印,排队:22,票券:2410021024470206078401,订单:24100210244702053382,[2024-10-02 10:24:54支付宝支付10元]
2024-10-02 10:24:57 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410021024470206078401","queue_number":22,"trade_uid":"24100210244702053382"}]}
2024-10-02 10:24:57 >>>故障排除日志:删除未同步下发订单成功24100210244702053382
2024-10-02 10:24:57 >>>故障排除日志:终端同步成功后剩余订单列表


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


===10:32:01===
2024-10-02 10:31:21 >>>回调事件[910,devices/D0264]
2024-10-02 10:31:21 >>>故障排除日志:上一MQTT订单号缓存列表为24100210271504736136
2024-10-02 10:31:21 >>>故障排除日志:终端未同步成功订单列表
2024-10-02 10:31:21 开始打印,排队:24,票券:2410021031130274553401,订单:24100210311302740713,[2024-10-02 10:31:20微信支付10元]
2024-10-02 10:31:23 >>>回调事件[910,devices/D0264]
2024-10-02 10:31:23 >>>故障排除日志:上一MQTT订单号缓存列表为24100210311302740713
2024-10-02 10:31:23 >>>故障排除日志:终端未同步成功订单列表002424100210311302740713
已接收过此消息,票券号为2410021031130274553401,排队号为24
2024-10-02 10:31:23 开始打印,排队:25,票券:2410021031156548705401,订单:24100210311565480491,[2024-10-02 10:31:22微信支付10元]
2024-10-02 10:31:25 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410021031130274553401","queue_number":24,"trade_uid":"24100210311302740713"}]}
2024-10-02 10:31:25 >>>故障排除日志:删除未同步下发订单成功24100210311302740713
2024-10-02 10:31:25 >>>故障排除日志:终端同步成功后剩余订单列表002524100210311565480491
2024-10-02 10:31:25 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410021031130274553401","queue_number":24,"trade_uid":"24100210311302740713"},{"ticket_no":"2410021031156548705401","queue_number":25,"trade_uid":"24100210311565480491"}]}
2024-10-02 10:31:25 >>>故障排除日志:删除未同步下发订单成功24100210311565480491
2024-10-02 10:31:25 >>>故障排除日志:终端同步成功后剩余订单列表


===10:43:01===
2024-10-02 10:42:40 >>>回调事件[910,devices/D0264]
2024-10-02 10:42:40 >>>故障排除日志:上一MQTT订单号缓存列表为24100210311302740713|24100210311565480491
2024-10-02 10:42:40 >>>故障排除日志:终端未同步成功订单列表
2024-10-02 10:42:40 开始打印,排队:26,票券:2410021042350368985301,订单:24100210423503685365,[2024-10-02 10:42:39支付宝支付10元]
2024-10-02 10:42:42 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410021042350368985301","queue_number":26,"trade_uid":"24100210423503685365"}]}
2024-10-02 10:42:42 >>>故障排除日志:删除未同步下发订单成功24100210423503685365
2024-10-02 10:42:42 >>>故障排除日志:终端同步成功后剩余订单列表


===11:02:02===
2024-10-02 11:01:51 >>>回调事件[910,devices/D0264]
2024-10-02 11:01:51 >>>故障排除日志:上一MQTT订单号缓存列表为24100210423503685365
2024-10-02 11:01:51 >>>故障排除日志:终端未同步成功订单列表
2024-10-02 11:01:51 开始打印,排队:27,票券:2410021101390001011701,订单:24100211013900005248,[2024-10-02 11:01:49微信支付10元]
2024-10-02 11:01:53 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410021101390001011701","queue_number":27,"trade_uid":"24100211013900005248"}]}
2024-10-02 11:01:53 >>>故障排除日志:删除未同步下发订单成功24100211013900005248
2024-10-02 11:01:53 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


===11:23:02===
2024-10-02 11:22:39 >>>回调事件[910,devices/D0264]
2024-10-02 11:22:39 >>>故障排除日志:上一MQTT订单号缓存列表为24100211092059278197
2024-10-02 11:22:39 >>>故障排除日志:终端未同步成功订单列表
2024-10-02 11:22:39 开始打印,排队:32,票券:2410021122316643166701,订单:24100211223166425912,[2024-10-02 11:22:38微信支付10元]
2024-10-02 11:22:41 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410021122316643166701","queue_number":32,"trade_uid":"24100211223166425912"}]}
2024-10-02 11:22:41 >>>故障排除日志:删除未同步下发订单成功24100211223166425912
2024-10-02 11:22:41 >>>故障排除日志:终端同步成功后剩余订单列表


===11:42:03===
2024-10-02 11:41:18>>>cash read=00
2024-10-02 11:41:18>>>cash read=2F29
2024-10-02 11:41:19>>>cash read=00
2024-10-02 11:41:20>>>cash read=2F29
2024-10-02 11:41:22>>>cash read=3E
2024-10-02 11:41:23>>>cash read=00
2024-10-02 11:41:24>>>cash read=818F42
2024-10-02 11:41:24>>>cash write=02
2024-10-02 11:41:24 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-02 11:41:25>>>cash read=10
2024-10-02 11:41:25 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-02 11:41:25 当前产品价格10元，投币10元，打印小票中...
2024-10-02 11:41:25 >>>开始打印,排队号为33,订单号为2410021141250002644255
2024-10-02 11:41:25>>>订单2410021141250002644255写入成功,剩余空间为1679500,占用RAM为606.267578125
删除未同步订单2410021141250002644255
2024-10-02 11:41:27>>>订单2410021141250002644255删除成功,剩余空间为1680500,占用RAM为620.974609375
检测订单目录中>>>
无未同步订单>>>
2024-10-02 11:41:27 >>>当前Ram内存为589.94921875
定时检测未同步订单启用
2024-10-02 11:41:28>>>cash write=0C
2024-10-02 11:41:28>>>cash read=3E


===11:43:03===
定时检测未同步订单关闭
检测订单目录中>>>
无未同步订单>>>


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


===11:59:03===
2024-10-02 11:58:55 >>>回调事件[910,devices/D0264]
2024-10-02 11:58:55 >>>故障排除日志:上一MQTT订单号缓存列表为24100211482109879263
2024-10-02 11:58:55 >>>故障排除日志:终端未同步成功订单列表
2024-10-02 11:58:55 开始打印,排队:35,票券:2410021158472940289101,订单:24100211584729398118,[2024-10-02 11:58:53微信支付10元]
2024-10-02 11:58:57 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410021158472940289101","queue_number":35,"trade_uid":"24100211584729398118"}]}
2024-10-02 11:58:57 >>>故障排除日志:删除未同步下发订单成功24100211584729398118
2024-10-02 11:58:57 >>>故障排除日志:终端同步成功后剩余订单列表


===12:01:04===
2024-10-02 12:00:50 >>>回调事件[910,devices/D0264]
2024-10-02 12:00:50 >>>故障排除日志:上一MQTT订单号缓存列表为24100211584729398118
2024-10-02 12:00:50 >>>故障排除日志:终端未同步成功订单列表
2024-10-02 12:00:50 开始打印,排队:36,票券:2410021200446567614901,订单:24100212004465672524,[2024-10-02 12:00:49微信支付10元]
2024-10-02 12:00:52 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410021200446567614901","queue_number":36,"trade_uid":"24100212004465672524"}]}
2024-10-02 12:00:52 >>>故障排除日志:删除未同步下发订单成功24100212004465672524
2024-10-02 12:00:52 >>>故障排除日志:终端同步成功后剩余订单列表


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


===12:24:04===
2024-10-02 12:23:12 >>>回调事件[910,devices/D0264]
2024-10-02 12:23:12 >>>故障排除日志:上一MQTT订单号缓存列表为24100212161854557835
2024-10-02 12:23:12 >>>故障排除日志:终端未同步成功订单列表
2024-10-02 12:23:12 开始打印,排队:38,票券:2410021223043855775101,订单:24100212230438553427,[2024-10-02 12:23:11微信支付10元]
2024-10-02 12:23:14 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410021223043855775101","queue_number":38,"trade_uid":"24100212230438553427"}]}
2024-10-02 12:23:14 >>>故障排除日志:删除未同步下发订单成功24100212230438553427
2024-10-02 12:23:14 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-02 12:23:46 >>>回调事件[910,devices/D0264]
2024-10-02 12:23:46 >>>故障排除日志:上一MQTT订单号缓存列表为24100212230438553427
2024-10-02 12:23:46 >>>故障排除日志:终端未同步成功订单列表
2024-10-02 12:23:47 开始打印,排队:39,票券:2410021223324744165301,订单:24100212233247437785,[2024-10-02 12:23:46微信支付10元]
2024-10-02 12:23:48 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410021223324744165301","queue_number":39,"trade_uid":"24100212233247437785"}]}
2024-10-02 12:23:48 >>>故障排除日志:删除未同步下发订单成功24100212233247437785
2024-10-02 12:23:49 >>>故障排除日志:终端同步成功后剩余订单列表


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


===12:33:05===
2024-10-02 12:32:43 >>>回调事件[910,devices/D0264]
2024-10-02 12:32:43 >>>故障排除日志:上一MQTT订单号缓存列表为24100212292034326885
2024-10-02 12:32:43 >>>故障排除日志:终端未同步成功订单列表
2024-10-02 12:32:43 开始打印,排队:41,票券:2410021232375334919101,订单:24100212323753345184,[2024-10-02 12:32:42微信支付10元]
2024-10-02 12:32:45 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410021232375334919101","queue_number":41,"trade_uid":"24100212323753345184"}]}
2024-10-02 12:32:45 >>>故障排除日志:删除未同步下发订单成功24100212323753345184
2024-10-02 12:32:45 >>>故障排除日志:终端同步成功后剩余订单列表


===12:35:05===
2024-10-02 12:34:34 >>>回调事件[910,devices/D0264]
2024-10-02 12:34:34 >>>故障排除日志:上一MQTT订单号缓存列表为24100212323753345184
2024-10-02 12:34:34 >>>故障排除日志:终端未同步成功订单列表
2024-10-02 12:34:34 开始打印,排队:42,票券:2410021234281452475701,订单:24100212342814520923,[2024-10-02 12:34:34微信支付10元]
2024-10-02 12:34:36 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410021234281452475701","queue_number":42,"trade_uid":"24100212342814520923"}]}
2024-10-02 12:34:36 >>>故障排除日志:删除未同步下发订单成功24100212342814520923
2024-10-02 12:34:36 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


===12:43:05===
2024-10-02 12:42:21 >>>回调事件[910,devices/D0264]
2024-10-02 12:42:21 >>>故障排除日志:上一MQTT订单号缓存列表为24100212363386348512
2024-10-02 12:42:21 >>>故障排除日志:终端未同步成功订单列表
2024-10-02 12:42:21 开始打印,排队:45,票券:2410021242146237052101,订单:24100212421462365572,[2024-10-02 12:42:20微信支付10元]
2024-10-02 12:42:21 开始打印,排队:46,票券:2410021242146237203802,订单:24100212421462365572,[2024-10-02 12:42:20微信支付10元]
2024-10-02 12:42:25 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410021242146237052101","queue_number":45,"trade_uid":"24100212421462365572"},{"ticket_no":"2410021242146237203802","queue_number":46,"trade_uid":"24100212421462365572"}]}
2024-10-02 12:42:25 >>>故障排除日志:删除未同步下发订单成功24100212421462365572
2024-10-02 12:42:25 >>>故障排除日志:删除未同步下发订单成功24100212421462365572
2024-10-02 12:42:25 >>>故障排除日志:终端同步成功后剩余订单列表


===12:53:06===
2024-10-02 12:52:53 >>>回调事件[910,devices/D0264]
2024-10-02 12:52:53 >>>故障排除日志:上一MQTT订单号缓存列表为24100212421462365572|24100212421462365572
2024-10-02 12:52:53 >>>故障排除日志:终端未同步成功订单列表
2024-10-02 12:52:53 开始打印,排队:47,票券:2410021252439727381601,订单:24100212524397267638,[2024-10-02 12:52:52微信支付10元]
2024-10-02 12:52:53 开始打印,排队:48,票券:2410021252439727536502,订单:24100212524397267638,[2024-10-02 12:52:52微信支付10元]
2024-10-02 12:52:57 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410021252439727381601","queue_number":47,"trade_uid":"24100212524397267638"},{"ticket_no":"2410021252439727536502","queue_number":48,"trade_uid":"24100212524397267638"}]}
2024-10-02 12:52:57 >>>故障排除日志:删除未同步下发订单成功24100212524397267638
2024-10-02 12:52:57 >>>故障排除日志:删除未同步下发订单成功24100212524397267638
2024-10-02 12:52:57 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-02 12:53:00 >>>回调事件[910,devices/D0264]
2024-10-02 12:53:00 >>>故障排除日志:上一MQTT订单号缓存列表为24100212524397267638|24100212524397267638
2024-10-02 12:53:00 >>>故障排除日志:终端未同步成功订单列表
2024-10-02 12:53:00 开始打印,排队:49,票券:2410021252538511154601,订单:24100212525385104462,[2024-10-02 12:52:59支付宝支付10元]
2024-10-02 12:53:02 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410021252538511154601","queue_number":49,"trade_uid":"24100212525385104462"}]}
2024-10-02 12:53:02 >>>故障排除日志:删除未同步下发订单成功24100212525385104462
2024-10-02 12:53:02 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


===13:05:06===
2024-10-02 13:04:13 >>>回调事件[910,devices/D0264]
2024-10-02 13:04:13 >>>故障排除日志:上一MQTT订单号缓存列表为24100213030084330243
2024-10-02 13:04:13 >>>故障排除日志:终端未同步成功订单列表
2024-10-02 13:04:13 开始打印,排队:52,票券:2410021304037322226501,订单:24100213040373218649,[2024-10-02 13:04:12微信支付10元]
2024-10-02 13:04:14 >>>回调事件[910,devices/D0264]
2024-10-02 13:04:14 >>>故障排除日志:上一MQTT订单号缓存列表为24100213040373218649
2024-10-02 13:04:15 >>>故障排除日志:终端未同步成功订单列表005224100213040373218649
已接收过此消息,票券号为2410021304037322226501,排队号为52
2024-10-02 13:04:15 开始打印,排队:53,票券:2410021304085907837901,订单:24100213040859073868,[2024-10-02 13:04:13微信支付10元]
2024-10-02 13:04:16 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410021304037322226501","queue_number":52,"trade_uid":"24100213040373218649"}]}
2024-10-02 13:04:16 >>>故障排除日志:删除未同步下发订单成功24100213040373218649
2024-10-02 13:04:17 >>>故障排除日志:终端同步成功后剩余订单列表005324100213040859073868
2024-10-02 13:04:17 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410021304037322226501","queue_number":52,"trade_uid":"24100213040373218649"},{"ticket_no":"2410021304085907837901","queue_number":53,"trade_uid":"24100213040859073868"}]}
2024-10-02 13:04:17 >>>故障排除日志:删除未同步下发订单成功24100213040859073868
2024-10-02 13:04:17 >>>故障排除日志:终端同步成功后剩余订单列表


===13:11:06===
2024-10-02 13:10:56 >>>回调事件[910,devices/D0264]
2024-10-02 13:10:56 >>>故障排除日志:上一MQTT订单号缓存列表为24100213040373218649|24100213040859073868
2024-10-02 13:10:56 >>>故障排除日志:终端未同步成功订单列表
2024-10-02 13:10:56 开始打印,排队:54,票券:2410021310478699717401,订单:24100213104786991893,[2024-10-02 13:10:55微信支付10元]
2024-10-02 13:10:58 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410021310478699717401","queue_number":54,"trade_uid":"24100213104786991893"}]}
2024-10-02 13:10:58 >>>故障排除日志:删除未同步下发订单成功24100213104786991893
2024-10-02 13:10:58 >>>故障排除日志:终端同步成功后剩余订单列表


===13:24:06===
2024-10-02 13:23:37 >>>回调事件[910,devices/D0264]
2024-10-02 13:23:37 >>>故障排除日志:上一MQTT订单号缓存列表为24100213104786991893
2024-10-02 13:23:37 >>>故障排除日志:终端未同步成功订单列表
2024-10-02 13:23:37 开始打印,排队:55,票券:2410021323288712886901,订单:24100213232887124429,[2024-10-02 13:23:37微信支付10元]
2024-10-02 13:23:39 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410021323288712886901","queue_number":55,"trade_uid":"24100213232887124429"}]}
2024-10-02 13:23:39 >>>故障排除日志:删除未同步下发订单成功24100213232887124429
2024-10-02 13:23:39 >>>故障排除日志:终端同步成功后剩余订单列表


===13:31:07===
2024-10-02 13:30:11 >>>回调事件[910,devices/D0264]
2024-10-02 13:30:11 >>>故障排除日志:上一MQTT订单号缓存列表为24100213232887124429
2024-10-02 13:30:11 >>>故障排除日志:终端未同步成功订单列表
2024-10-02 13:30:11 开始打印,排队:56,票券:2410021330050711429201,订单:24100213300507107149,[2024-10-02 13:30:10微信支付10元]
2024-10-02 13:30:13 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410021330050711429201","queue_number":56,"trade_uid":"24100213300507107149"}]}
2024-10-02 13:30:13 >>>故障排除日志:删除未同步下发订单成功24100213300507107149
2024-10-02 13:30:13 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-02 13:30:35 >>>回调事件[910,devices/D0264]
2024-10-02 13:30:35 >>>故障排除日志:上一MQTT订单号缓存列表为24100213300507107149
2024-10-02 13:30:35 >>>故障排除日志:终端未同步成功订单列表
2024-10-02 13:30:35 开始打印,排队:57,票券:2410021330280081407101,订单:24100213302800810074,[2024-10-02 13:30:33微信支付10元]
2024-10-02 13:30:37 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410021330280081407101","queue_number":57,"trade_uid":"24100213302800810074"}]}
2024-10-02 13:30:37 >>>故障排除日志:删除未同步下发订单成功24100213302800810074
2024-10-02 13:30:37 >>>故障排除日志:终端同步成功后剩余订单列表


===13:41:07===
2024-10-02 13:40:49 >>>回调事件[910,devices/D0264]
2024-10-02 13:40:49 >>>故障排除日志:上一MQTT订单号缓存列表为24100213302800810074
2024-10-02 13:40:49 >>>故障排除日志:终端未同步成功订单列表
2024-10-02 13:40:49 开始打印,排队:58,票券:2410021340392781281701,订单:24100213403927809484,[2024-10-02 13:40:48微信支付10元]
2024-10-02 13:40:51 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410021340392781281701","queue_number":58,"trade_uid":"24100213403927809484"}]}
2024-10-02 13:40:51 >>>故障排除日志:删除未同步下发订单成功24100213403927809484
2024-10-02 13:40:51 >>>故障排除日志:终端同步成功后剩余订单列表


===13:42:07===
2024-10-02 13:41:50>>>cash read=00
2024-10-02 13:41:50>>>cash read=2F29
2024-10-02 13:41:52>>>cash read=01
2024-10-02 13:41:53>>>cash read=012F
2024-10-02 13:41:54>>>cash read=29
2024-10-02 13:41:54 >>>回调事件130,cash_status,20029,退钞中
2024-10-02 13:41:55>>>cash read=01
2024-10-02 13:41:57>>>cash read=00
2024-10-02 13:41:58>>>cash read=01
2024-10-02 13:42:01>>>cash read=3E
2024-10-02 13:42:03>>>cash read=29
2024-10-02 13:42:03 >>>回调事件130,cash_status,20029,退钞中
2024-10-02 13:42:03>>>cash read=2F29
2024-10-02 13:42:04>>>cash read=01
2024-10-02 13:42:06>>>cash read=2F


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


===13:44:08===
定时检测未同步订单关闭
检测订单目录中>>>
无未同步订单>>>


===13:54:08===
2024-10-02 13:54:00 >>>回调事件[910,devices/D0264]
2024-10-02 13:54:00 >>>故障排除日志:上一MQTT订单号缓存列表为24100213403927809484
2024-10-02 13:54:00 >>>故障排除日志:终端未同步成功订单列表
2024-10-02 13:54:00 开始打印,排队:60,票券:2410021353532309304501,订单:24100213535323086432,[2024-10-02 13:53:59支付宝支付10元]
2024-10-02 13:54:00 开始打印,排队:61,票券:2410021353532309506802,订单:24100213535323086432,[2024-10-02 13:53:59支付宝支付10元]
2024-10-02 13:54:04 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410021353532309304501","queue_number":60,"trade_uid":"24100213535323086432"},{"ticket_no":"2410021353532309506802","queue_number":61,"trade_uid":"24100213535323086432"}]}
2024-10-02 13:54:04 >>>故障排除日志:删除未同步下发订单成功24100213535323086432
2024-10-02 13:54:04 >>>故障排除日志:删除未同步下发订单成功24100213535323086432
2024-10-02 13:54:04 >>>故障排除日志:终端同步成功后剩余订单列表


===13:57:08===
2024-10-02 13:56:59 >>>回调事件[910,devices/D0264]
2024-10-02 13:56:59 >>>故障排除日志:上一MQTT订单号缓存列表为24100213535323086432|24100213535323086432
2024-10-02 13:56:59 >>>故障排除日志:终端未同步成功订单列表
2024-10-02 13:56:59 开始打印,排队:62,票券:2410021356525778585201,订单:24100213565257781942,[2024-10-02 13:56:58微信支付10元]
2024-10-02 13:57:01 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410021356525778585201","queue_number":62,"trade_uid":"24100213565257781942"}]}
2024-10-02 13:57:01 >>>故障排除日志:删除未同步下发订单成功24100213565257781942
2024-10-02 13:57:01 >>>故障排除日志:终端同步成功后剩余订单列表


===14:02:08===
2024-10-02 14:01:40 >>>回调事件[910,devices/D0264]
2024-10-02 14:01:40 >>>故障排除日志:上一MQTT订单号缓存列表为24100213565257781942
2024-10-02 14:01:40 >>>故障排除日志:终端未同步成功订单列表
2024-10-02 14:01:40 开始打印,排队:63,票券:2410021401334897884101,订单:24100214013348973587,[2024-10-02 14:01:39微信支付10元]
2024-10-02 14:01:42 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410021401334897884101","queue_number":63,"trade_uid":"24100214013348973587"}]}
2024-10-02 14:01:42 >>>故障排除日志:删除未同步下发订单成功24100214013348973587
2024-10-02 14:01:42 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-02 14:02:04 >>>回调事件[910,devices/D0264]
2024-10-02 14:02:04 >>>故障排除日志:上一MQTT订单号缓存列表为24100214013348973587
2024-10-02 14:02:04 >>>故障排除日志:终端未同步成功订单列表
2024-10-02 14:02:04 开始打印,排队:64,票券:2410021401517097827301,订单:24100214015170934248,[2024-10-02 14:02:03微信支付10元]
2024-10-02 14:02:06 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410021401517097827301","queue_number":64,"trade_uid":"24100214015170934248"}]}
2024-10-02 14:02:06 >>>故障排除日志:删除未同步下发订单成功24100214015170934248
2024-10-02 14:02:06 >>>故障排除日志:终端同步成功后剩余订单列表


===14:06:08===
2024-10-02 14:05:19 >>>回调事件[910,devices/D0264]
2024-10-02 14:05:19 >>>故障排除日志:上一MQTT订单号缓存列表为24100214015170934248
2024-10-02 14:05:19 >>>故障排除日志:终端未同步成功订单列表
2024-10-02 14:05:19 开始打印,排队:65,票券:2410021405094021035801,订单:24100214050940202772,[2024-10-02 14:05:18支付宝支付10元]
2024-10-02 14:05:21 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410021405094021035801","queue_number":65,"trade_uid":"24100214050940202772"}]}
2024-10-02 14:05:21 >>>故障排除日志:删除未同步下发订单成功24100214050940202772
2024-10-02 14:05:21 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


===14:33:09===
2024-10-02 14:32:59 >>>回调事件[910,devices/D0264]
2024-10-02 14:32:59 >>>故障排除日志:上一MQTT订单号缓存列表为24100214301007496795
2024-10-02 14:32:59 >>>故障排除日志:终端未同步成功订单列表
2024-10-02 14:32:59 开始打印,排队:70,票券:2410021432504745883601,订单:24100214325047455486,[2024-10-02 14:32:59支付宝支付10元]
2024-10-02 14:33:01 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410021432504745883601","queue_number":70,"trade_uid":"24100214325047455486"}]}
2024-10-02 14:33:01 >>>故障排除日志:删除未同步下发订单成功24100214325047455486
2024-10-02 14:33:01 >>>故障排除日志:终端同步成功后剩余订单列表


===14:38:11===
2024-10-02 14:38:08 >>>回调事件[910,devices/D0264]
2024-10-02 14:38:08 >>>故障排除日志:上一MQTT订单号缓存列表为24100214325047455486
2024-10-02 14:38:08 >>>故障排除日志:终端未同步成功订单列表
2024-10-02 14:38:08 开始打印,排队:71,票券:2410021438005131143201,订单:24100214380051306527,[2024-10-02 14:38:07微信支付10元]


===14:39:11===
2024-10-02 14:38:10 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410021438005131143201","queue_number":71,"trade_uid":"24100214380051306527"}]}
2024-10-02 14:38:10 >>>故障排除日志:删除未同步下发订单成功24100214380051306527
2024-10-02 14:38:10 >>>故障排除日志:终端同步成功后剩余订单列表


===14:40:11===
2024-10-02 14:40:02 >>>回调事件[910,devices/D0264]
2024-10-02 14:40:02 >>>故障排除日志:上一MQTT订单号缓存列表为24100214380051306527
2024-10-02 14:40:02 >>>故障排除日志:终端未同步成功订单列表
2024-10-02 14:40:02 开始打印,排队:72,票券:2410021439556285277401,订单:24100214395562848417,[2024-10-02 14:40:01微信支付10元]
2024-10-02 14:40:02 开始打印,排队:73,票券:2410021439556285433402,订单:24100214395562848417,[2024-10-02 14:40:01微信支付10元]
2024-10-02 14:40:05 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410021439556285277401","queue_number":72,"trade_uid":"24100214395562848417"},{"ticket_no":"2410021439556285433402","queue_number":73,"trade_uid":"24100214395562848417"}]}
2024-10-02 14:40:05 >>>故障排除日志:删除未同步下发订单成功24100214395562848417
2024-10-02 14:40:05 >>>故障排除日志:删除未同步下发订单成功24100214395562848417
2024-10-02 14:40:05 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


===14:49:12===
2024-10-02 14:48:28>>>cash read=00
2024-10-02 14:48:30>>>cash read=2F29
2024-10-02 14:48:31>>>cash read=01
2024-10-02 14:48:31>>>cash read=2F
2024-10-02 14:48:32>>>cash read=3E
2024-10-02 14:48:37>>>cash read=00
2024-10-02 14:48:38>>>cash read=29
2024-10-02 14:48:38 >>>回调事件130,cash_status,20029,退钞中
2024-10-02 14:48:38>>>cash read=2F29
2024-10-02 14:48:39>>>cash read=01
2024-10-02 14:48:43>>>cash read=2F
2024-10-02 14:48:44>>>cash read=3E
2024-10-02 14:48:46>>>cash read=00
2024-10-02 14:48:46>>>cash read=2F29
2024-10-02 14:48:48>>>cash read=01
2024-10-02 14:48:48>>>cash read=2F
2024-10-02 14:48:50>>>cash read=00
2024-10-02 14:48:51>>>cash read=818F4200
2024-10-02 14:48:51>>>cash write=02
2024-10-02 14:48:51 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-02 14:48:51>>>cash read=10
2024-10-02 14:48:51 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-02 14:48:51 当前产品价格10元，投币10元，打印小票中...
2024-10-02 14:48:51 >>>开始打印,排队号为77,订单号为2410021448510002642586
2024-10-02 14:48:52>>>订单2410021448510002642586写入成功,剩余空间为1679000,占用RAM为609.6201171875
删除未同步订单2410021448510002642586
2024-10-02 14:48:53>>>订单2410021448510002642586删除成功,剩余空间为1680000,占用RAM为622.7451171875
检测订单目录中>>>
无未同步订单>>>
2024-10-02 14:48:54 >>>当前Ram内存为590.638671875
定时检测未同步订单启用
2024-10-02 14:48:55>>>cash write=0C
2024-10-02 14:48:55>>>cash read=3E


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


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


===15:03:12===
2024-10-02 15:03:01 >>>回调事件[910,devices/D0264]
2024-10-02 15:03:01 >>>故障排除日志:上一MQTT订单号缓存列表为24100215005526381414
2024-10-02 15:03:01 >>>故障排除日志:终端未同步成功订单列表
2024-10-02 15:03:01 开始打印,排队:79,票券:2410021502543986099401,订单:24100215025439857018,[2024-10-02 15:03:00微信支付10元]
2024-10-02 15:03:01 开始打印,排队:80,票券:2410021502543986234702,订单:24100215025439857018,[2024-10-02 15:03:00微信支付10元]
2024-10-02 15:03:05 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410021502543986099401","queue_number":79,"trade_uid":"24100215025439857018"},{"ticket_no":"2410021502543986234702","queue_number":80,"trade_uid":"24100215025439857018"}]}
2024-10-02 15:03:05 >>>故障排除日志:删除未同步下发订单成功24100215025439857018
2024-10-02 15:03:05 >>>故障排除日志:删除未同步下发订单成功24100215025439857018
2024-10-02 15:03:05 >>>故障排除日志:终端同步成功后剩余订单列表


===15:06:12===
2024-10-02 15:05:38 >>>回调事件[910,devices/D0264]
2024-10-02 15:05:38 >>>故障排除日志:上一MQTT订单号缓存列表为24100215025439857018|24100215025439857018
2024-10-02 15:05:38 >>>故障排除日志:终端未同步成功订单列表
2024-10-02 15:05:38 开始打印,排队:81,票券:2410021505264903023601,订单:24100215052649026571,[2024-10-02 15:05:36支付宝支付10元]
2024-10-02 15:05:40 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410021505264903023601","queue_number":81,"trade_uid":"24100215052649026571"}]}
2024-10-02 15:05:40 >>>故障排除日志:删除未同步下发订单成功24100215052649026571
2024-10-02 15:05:40 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


===15:20:13===
2024-10-02 15:19:39 >>>回调事件[910,devices/D0264]
2024-10-02 15:19:39 >>>故障排除日志:上一MQTT订单号缓存列表为24100215175637498512
2024-10-02 15:19:39 >>>故障排除日志:终端未同步成功订单列表
2024-10-02 15:19:39 开始打印,排队:85,票券:2410021519258989637501,订单:24100215192589891484,[2024-10-02 15:19:37微信支付10元]
2024-10-02 15:19:41 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410021519258989637501","queue_number":85,"trade_uid":"24100215192589891484"}]}
2024-10-02 15:19:41 >>>故障排除日志:删除未同步下发订单成功24100215192589891484
2024-10-02 15:19:41 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-02 15:20:07 >>>回调事件[910,devices/D0264]
2024-10-02 15:20:07 >>>故障排除日志:上一MQTT订单号缓存列表为24100215192589891484
2024-10-02 15:20:07 >>>故障排除日志:终端未同步成功订单列表
2024-10-02 15:20:07 开始打印,排队:86,票券:2410021519597443456201,订单:24100215195974429715,[2024-10-02 15:20:06微信支付10元]
2024-10-02 15:20:07 开始打印,排队:87,票券:2410021519597443586102,订单:24100215195974429715,[2024-10-02 15:20:06微信支付10元]
2024-10-02 15:20:11 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410021519597443456201","queue_number":86,"trade_uid":"24100215195974429715"},{"ticket_no":"2410021519597443586102","queue_number":87,"trade_uid":"24100215195974429715"}]}
2024-10-02 15:20:11 >>>故障排除日志:删除未同步下发订单成功24100215195974429715
2024-10-02 15:20:11 >>>故障排除日志:删除未同步下发订单成功24100215195974429715
2024-10-02 15:20:11 >>>故障排除日志:终端同步成功后剩余订单列表


===15:21:13===
2024-10-02 15:20:25 >>>回调事件[910,devices/D0264]
2024-10-02 15:20:25 >>>故障排除日志:上一MQTT订单号缓存列表为24100215195974429715|24100215195974429715
2024-10-02 15:20:25 >>>故障排除日志:终端未同步成功订单列表
2024-10-02 15:20:25 开始打印,排队:88,票券:2410021520188272804201,订单:24100215201882724419,[2024-10-02 15:20:25支付宝支付10元]
2024-10-02 15:20:27 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410021520188272804201","queue_number":88,"trade_uid":"24100215201882724419"}]}
2024-10-02 15:20:27 >>>故障排除日志:删除未同步下发订单成功24100215201882724419
2024-10-02 15:20:28 >>>故障排除日志:终端同步成功后剩余订单列表


===15:27:14===
2024-10-02 15:26:43>>>cash read=00
2024-10-02 15:26:44>>>cash read=818F42
2024-10-02 15:26:44>>>cash write=02
2024-10-02 15:26:44 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-02 15:26:45>>>cash read=10
2024-10-02 15:26:45 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-02 15:26:45 当前产品价格10元，投币10元，打印小票中...
2024-10-02 15:26:45 >>>开始打印,排队号为89,订单号为2410021526450002641880
2024-10-02 15:26:45>>>订单2410021526450002641880写入成功,剩余空间为1680000,占用RAM为607.041015625
删除未同步订单2410021526450002641880
2024-10-02 15:26:47>>>订单2410021526450002641880删除成功,剩余空间为1680500,占用RAM为621.9658203125
检测订单目录中>>>
无未同步订单>>>
2024-10-02 15:26:47 >>>当前Ram内存为589.7294921875
定时检测未同步订单启用
2024-10-02 15:26:48>>>cash write=0C
2024-10-02 15:26:48>>>cash read=3E


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


===15:32:14===
2024-10-02 15:31:34 >>>回调事件[910,devices/D0264]
2024-10-02 15:31:34 >>>故障排除日志:上一MQTT订单号缓存列表为24100215274565103974
2024-10-02 15:31:34 >>>故障排除日志:终端未同步成功订单列表
2024-10-02 15:31:34 开始打印,排队:91,票券:2410021531253360538601,订单:24100215312533600691,[2024-10-02 15:31:33微信支付10元]
2024-10-02 15:31:34 开始打印,排队:92,票券:2410021531253360726802,订单:24100215312533600691,[2024-10-02 15:31:33微信支付10元]
2024-10-02 15:31:37 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410021531253360538601","queue_number":91,"trade_uid":"24100215312533600691"},{"ticket_no":"2410021531253360726802","queue_number":92,"trade_uid":"24100215312533600691"}]}
2024-10-02 15:31:37 >>>故障排除日志:删除未同步下发订单成功24100215312533600691
2024-10-02 15:31:37 >>>故障排除日志:删除未同步下发订单成功24100215312533600691
2024-10-02 15:31:37 >>>故障排除日志:终端同步成功后剩余订单列表


===15:39:14===
2024-10-02 15:38:58 >>>回调事件[910,devices/D0264]
2024-10-02 15:38:59 >>>故障排除日志:上一MQTT订单号缓存列表为24100215312533600691|24100215312533600691
2024-10-02 15:38:59 >>>故障排除日志:终端未同步成功订单列表
2024-10-02 15:38:59 开始打印,排队:93,票券:2410021538514003874701,订单:24100215385140032839,[2024-10-02 15:38:57微信支付10元]
2024-10-02 15:39:00 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410021538514003874701","queue_number":93,"trade_uid":"24100215385140032839"}]}
2024-10-02 15:39:00 >>>故障排除日志:删除未同步下发订单成功24100215385140032839
2024-10-02 15:39:01 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


===15:57:15===
2024-10-02 15:56:30 >>>回调事件[910,devices/D0264]
2024-10-02 15:56:30 >>>故障排除日志:上一MQTT订单号缓存列表为24100215540087513332
2024-10-02 15:56:30 >>>故障排除日志:终端未同步成功订单列表
2024-10-02 15:56:30 开始打印,排队:96,票券:2410021556213498991801,订单:24100215562134985091,[2024-10-02 15:56:29支付宝支付10元]
2024-10-02 15:56:31 >>>回调事件[910,devices/D0264]
2024-10-02 15:56:32 >>>故障排除日志:上一MQTT订单号缓存列表为24100215562134985091
2024-10-02 15:56:32 >>>故障排除日志:终端未同步成功订单列表009624100215562134985091
已接收过此消息,票券号为2410021556213498991801,排队号为96
2024-10-02 15:56:32 开始打印,排队:97,票券:2410021556239710426101,订单:24100215562397099453,[2024-10-02 15:56:30微信支付10元]
2024-10-02 15:56:34 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410021556213498991801","queue_number":96,"trade_uid":"24100215562134985091"}]}
2024-10-02 15:56:34 >>>故障排除日志:删除未同步下发订单成功24100215562134985091
2024-10-02 15:56:34 >>>故障排除日志:终端同步成功后剩余订单列表009724100215562397099453
2024-10-02 15:56:34 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410021556213498991801","queue_number":96,"trade_uid":"24100215562134985091"},{"ticket_no":"2410021556239710426101","queue_number":97,"trade_uid":"24100215562397099453"}]}
2024-10-02 15:56:34 >>>故障排除日志:删除未同步下发订单成功24100215562397099453
2024-10-02 15:56:34 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-02 15:56:50>>>cash read=0A
2024-10-02 15:56:52>>>cash read=3E


===15:58:15===
2024-10-02 15:57:47 >>>回调事件[910,devices/D0264]
2024-10-02 15:57:47 >>>故障排除日志:上一MQTT订单号缓存列表为24100215562134985091|24100215562397099453
2024-10-02 15:57:47 >>>故障排除日志:终端未同步成功订单列表
2024-10-02 15:57:47 开始打印,排队:98,票券:2410021557395312586201,订单:24100215573953121261,[2024-10-02 15:57:46微信支付10元]
2024-10-02 15:57:49 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410021557395312586201","queue_number":98,"trade_uid":"24100215573953121261"}]}
2024-10-02 15:57:49 >>>故障排除日志:删除未同步下发订单成功24100215573953121261
2024-10-02 15:57:49 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-02 15:58:12 >>>回调事件[910,devices/D0264]
2024-10-02 15:58:12 >>>故障排除日志:上一MQTT订单号缓存列表为24100215573953121261
2024-10-02 15:58:12 >>>故障排除日志:终端未同步成功订单列表
2024-10-02 15:58:12 开始打印,排队:99,票券:2410021558065707516701,订单:24100215580657071553,[2024-10-02 15:58:11微信支付10元]


===15:59:15===
2024-10-02 15:58:14 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410021558065707516701","queue_number":99,"trade_uid":"24100215580657071553"}]}
2024-10-02 15:58:14 >>>故障排除日志:删除未同步下发订单成功24100215580657071553
2024-10-02 15:58:15 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-02 15:58:49 >>>回调事件[910,devices/D0264]
2024-10-02 15:58:49 >>>故障排除日志:上一MQTT订单号缓存列表为24100215580657071553
2024-10-02 15:58:49 >>>故障排除日志:终端未同步成功订单列表
2024-10-02 15:58:49 开始打印,排队:100,票券:2410021558447035188401,订单:24100215584470347263,[2024-10-02 15:58:49微信支付10元]
2024-10-02 15:58:51 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410021558447035188401","queue_number":100,"trade_uid":"24100215584470347263"}]}
2024-10-02 15:58:51 >>>故障排除日志:删除未同步下发订单成功24100215584470347263
2024-10-02 15:58:51 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


===16:12:16===
2024-10-02 16:11:23 >>>回调事件[910,devices/D0264]
2024-10-02 16:11:23 >>>故障排除日志:上一MQTT订单号缓存列表为24100216105041000852
2024-10-02 16:11:23 >>>故障排除日志:终端未同步成功订单列表
2024-10-02 16:11:23 开始打印,排队:103,票券:2410021611155189751301,订单:24100216111551893934,[2024-10-02 16:11:22微信支付10元]
2024-10-02 16:11:25 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410021611155189751301","queue_number":103,"trade_uid":"24100216111551893934"}]}
2024-10-02 16:11:25 >>>故障排除日志:删除未同步下发订单成功24100216111551893934
2024-10-02 16:11:25 >>>故障排除日志:终端同步成功后剩余订单列表


===16:15:16===
2024-10-02 16:15:10>>>cash read=00
2024-10-02 16:15:11>>>cash read=2F29
2024-10-02 16:15:13>>>cash read=3E


===16:16:16===
2024-10-02 16:15:21>>>cash read=00
2024-10-02 16:15:22>>>cash read=01
2024-10-02 16:15:24>>>cash read=00
2024-10-02 16:15:25>>>cash read=3E
2024-10-02 16:15:29>>>cash read=00
2024-10-02 16:15:30>>>cash read=818F42
2024-10-02 16:15:30>>>cash write=02
2024-10-02 16:15:30 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-02 16:15:31>>>cash read=10
2024-10-02 16:15:31 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-02 16:15:31 当前产品价格10元，投币10元，打印小票中...
2024-10-02 16:15:31 >>>开始打印,排队号为104,订单号为2410021615310002647806
2024-10-02 16:15:31>>>订单2410021615310002647806写入成功,剩余空间为1679500,占用RAM为607.990234375
删除未同步订单2410021615310002647806
2024-10-02 16:15:33>>>订单2410021615310002647806删除成功,剩余空间为1680500,占用RAM为620.7998046875
检测订单目录中>>>
无未同步订单>>>
2024-10-02 16:15:33 >>>当前Ram内存为589.96875
定时检测未同步订单启用
2024-10-02 16:15:34>>>cash write=0C
2024-10-02 16:15:34>>>cash read=3E


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


===16:25:17===
2024-10-02 16:24:36 >>>回调事件[910,devices/D0264]
2024-10-02 16:24:36 >>>故障排除日志:上一MQTT订单号缓存列表为24100216111551893934
2024-10-02 16:24:36 >>>故障排除日志:终端未同步成功订单列表
2024-10-02 16:24:36 开始打印,排队:105,票券:2410021624260996135701,订单:24100216242609955945,[2024-10-02 16:24:35支付宝支付10元]
2024-10-02 16:24:38 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410021624260996135701","queue_number":105,"trade_uid":"24100216242609955945"}]}
2024-10-02 16:24:38 >>>故障排除日志:删除未同步下发订单成功24100216242609955945
2024-10-02 16:24:38 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-02 16:24:39 >>>回调事件[910,devices/D0264]
2024-10-02 16:24:39 >>>故障排除日志:上一MQTT订单号缓存列表为24100216242609955945
2024-10-02 16:24:39 >>>故障排除日志:终端未同步成功订单列表
2024-10-02 16:24:39 开始打印,排队:106,票券:2410021624318254593901,订单:24100216243182542325,[2024-10-02 16:24:38微信支付10元]
2024-10-02 16:24:41 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410021624318254593901","queue_number":106,"trade_uid":"24100216243182542325"}]}
2024-10-02 16:24:41 >>>故障排除日志:删除未同步下发订单成功24100216243182542325
2024-10-02 16:24:41 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


===16:33:18===
2024-10-02 16:33:12>>>cash read=29
2024-10-02 16:33:12 >>>回调事件130,cash_status,20029,退钞中
2024-10-02 16:33:13>>>cash read=3E
2024-10-02 16:33:15>>>cash read=00
2024-10-02 16:33:17>>>cash read=3E


===16:34:18===
2024-10-02 16:33:18>>>cash read=29
2024-10-02 16:33:18 >>>回调事件130,cash_status,20029,退钞中
2024-10-02 16:33:19>>>cash read=01
2024-10-02 16:33:20>>>cash read=3E


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


===16:48:18===
2024-10-02 16:47:39 >>>回调事件[910,devices/D0264]
2024-10-02 16:47:39 >>>故障排除日志:上一MQTT订单号缓存列表为24100216372773053256
2024-10-02 16:47:39 >>>故障排除日志:终端未同步成功订单列表
2024-10-02 16:47:39 开始打印,排队:111,票券:2410021647290794227101,订单:24100216472907938238,[2024-10-02 16:47:37微信支付10元]
2024-10-02 16:47:41 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410021647290794227101","queue_number":111,"trade_uid":"24100216472907938238"}]}
2024-10-02 16:47:41 >>>故障排除日志:删除未同步下发订单成功24100216472907938238
2024-10-02 16:47:41 >>>故障排除日志:终端同步成功后剩余订单列表


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


===16:51:19===
2024-10-02 16:50:53 >>>回调事件[910,devices/D0264]
2024-10-02 16:50:53 >>>故障排除日志:上一MQTT订单号缓存列表为24100216500628367073
2024-10-02 16:50:53 >>>故障排除日志:终端未同步成功订单列表
2024-10-02 16:50:53 开始打印,排队:113,票券:2410021650457989981801,订单:24100216504579895168,[2024-10-02 16:50:52微信支付10元]
2024-10-02 16:50:55 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410021650457989981801","queue_number":113,"trade_uid":"24100216504579895168"}]}
2024-10-02 16:50:55 >>>故障排除日志:删除未同步下发订单成功24100216504579895168
2024-10-02 16:50:55 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-02 16:51:16 >>>回调事件[910,devices/D0264]
2024-10-02 16:51:16 >>>故障排除日志:上一MQTT订单号缓存列表为24100216504579895168
2024-10-02 16:51:16 >>>故障排除日志:终端未同步成功订单列表
2024-10-02 16:51:16 开始打印,排队:114,票券:2410021651099765951601,订单:24100216510997655436,[2024-10-02 16:51:16微信支付10元]


===16:52:19===
2024-10-02 16:51:18 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410021651099765951601","queue_number":114,"trade_uid":"24100216510997655436"}]}
2024-10-02 16:51:18 >>>故障排除日志:删除未同步下发订单成功24100216510997655436
2024-10-02 16:51:18 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-02 16:51:53 >>>回调事件[910,devices/D0264]
2024-10-02 16:51:54 >>>故障排除日志:上一MQTT订单号缓存列表为24100216510997655436
2024-10-02 16:51:54 >>>故障排除日志:终端未同步成功订单列表
2024-10-02 16:51:54 开始打印,排队:115,票券:2410021651465735476201,订单:24100216514657350283,[2024-10-02 16:51:52微信支付10元]
2024-10-02 16:51:54 开始打印,排队:116,票券:2410021651465735664702,订单:24100216514657350283,[2024-10-02 16:51:52微信支付10元]
2024-10-02 16:51:57 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410021651465735476201","queue_number":115,"trade_uid":"24100216514657350283"},{"ticket_no":"2410021651465735664702","queue_number":116,"trade_uid":"24100216514657350283"}]}
2024-10-02 16:51:57 >>>故障排除日志:删除未同步下发订单成功24100216514657350283
2024-10-02 16:51:57 >>>故障排除日志:删除未同步下发订单成功24100216514657350283
2024-10-02 16:51:57 >>>故障排除日志:终端同步成功后剩余订单列表


===16:55:19===
2024-10-02 16:54:38 >>>回调事件[910,devices/D0264]
2024-10-02 16:54:38 >>>故障排除日志:上一MQTT订单号缓存列表为24100216514657350283|24100216514657350283
2024-10-02 16:54:38 >>>故障排除日志:终端未同步成功订单列表
2024-10-02 16:54:38 开始打印,排队:117,票券:2410021654310317641201,订单:24100216543103172046,[2024-10-02 16:54:37微信支付10元]
2024-10-02 16:54:40 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410021654310317641201","queue_number":117,"trade_uid":"24100216543103172046"}]}
2024-10-02 16:54:40 >>>故障排除日志:删除未同步下发订单成功24100216543103172046
2024-10-02 16:54:40 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


===17:30:20===
2024-10-02 17:29:45 >>>回调事件[910,devices/D0264]
2024-10-02 17:29:45 >>>故障排除日志:上一MQTT订单号缓存列表为24100217221920481893
2024-10-02 17:29:45 >>>故障排除日志:终端未同步成功订单列表
2024-10-02 17:29:45 开始打印,排队:121,票券:2410021729343152746701,订单:24100217293431523078,[2024-10-02 17:29:44支付宝支付10元]
2024-10-02 17:29:45 开始打印,排队:122,票券:2410021729343152888502,订单:24100217293431523078,[2024-10-02 17:29:44支付宝支付10元]
2024-10-02 17:29:49 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410021729343152746701","queue_number":121,"trade_uid":"24100217293431523078"},{"ticket_no":"2410021729343152888502","queue_number":122,"trade_uid":"24100217293431523078"}]}
2024-10-02 17:29:49 >>>故障排除日志:删除未同步下发订单成功24100217293431523078
2024-10-02 17:29:49 >>>故障排除日志:删除未同步下发订单成功24100217293431523078
2024-10-02 17:29:49 >>>故障排除日志:终端同步成功后剩余订单列表


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


===17:33:21===
2024-10-02 17:33:18 >>>回调事件[910,devices/D0264]
2024-10-02 17:33:18 >>>故障排除日志:上一MQTT订单号缓存列表为24100217310444215836
2024-10-02 17:33:18 >>>故障排除日志:终端未同步成功订单列表
2024-10-02 17:33:18 开始打印,排队:124,票券:2410021733129871235101,订单:24100217331298708417,[2024-10-02 17:33:17支付宝支付10元]


===17:34:21===
2024-10-02 17:33:20 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410021733129871235101","queue_number":124,"trade_uid":"24100217331298708417"}]}
2024-10-02 17:33:20 >>>故障排除日志:删除未同步下发订单成功24100217331298708417
2024-10-02 17:33:20 >>>故障排除日志:终端同步成功后剩余订单列表


===17:36:21===
2024-10-02 17:35:47 >>>回调事件[910,devices/D0264]
2024-10-02 17:35:47 >>>故障排除日志:上一MQTT订单号缓存列表为24100217331298708417
2024-10-02 17:35:47 >>>故障排除日志:终端未同步成功订单列表
2024-10-02 17:35:47 开始打印,排队:125,票券:2410021735417480805901,订单:24100217354174804142,[2024-10-02 17:35:46微信支付10元]
2024-10-02 17:35:49 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410021735417480805901","queue_number":125,"trade_uid":"24100217354174804142"}]}
2024-10-02 17:35:49 >>>故障排除日志:删除未同步下发订单成功24100217354174804142
2024-10-02 17:35:49 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


===17:55:22===
2024-10-02 17:54:32>>>cash read=0A
2024-10-02 17:54:33>>>cash read=3E


===18:05:22===
2024-10-02 18:04:57 >>>回调事件[910,devices/D0264]
2024-10-02 18:04:57 >>>故障排除日志:上一MQTT订单号缓存列表为24100217484365245691
2024-10-02 18:04:57 >>>故障排除日志:终端未同步成功订单列表
2024-10-02 18:04:58 开始打印,排队:128,票券:2410021804507636377501,订单:24100218045076360017,[2024-10-02 18:04:56支付宝支付10元]
2024-10-02 18:04:59 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410021804507636377501","queue_number":128,"trade_uid":"24100218045076360017"}]}
2024-10-02 18:04:59 >>>故障排除日志:删除未同步下发订单成功24100218045076360017
2024-10-02 18:05:00 >>>故障排除日志:终端同步成功后剩余订单列表


===18:15:22===
2024-10-02 18:15:11 >>>回调事件[910,devices/D0264]
2024-10-02 18:15:11 >>>故障排除日志:上一MQTT订单号缓存列表为24100218045076360017
2024-10-02 18:15:11 >>>故障排除日志:终端未同步成功订单列表
2024-10-02 18:15:11 开始打印,排队:129,票券:2410021815055372219401,订单:24100218150553718113,[2024-10-02 18:15:10支付宝支付10元]
2024-10-02 18:15:12 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410021815055372219401","queue_number":129,"trade_uid":"24100218150553718113"}]}
2024-10-02 18:15:12 >>>故障排除日志:删除未同步下发订单成功24100218150553718113
2024-10-02 18:15:13 >>>故障排除日志:终端同步成功后剩余订单列表


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


===18:21:23===
2024-10-02 18:20:45 >>>回调事件[910,devices/D0264]
2024-10-02 18:20:45 >>>故障排除日志:上一MQTT订单号缓存列表为24100218200279089683
2024-10-02 18:20:45 >>>故障排除日志:终端未同步成功订单列表
2024-10-02 18:20:45 开始打印,排队:131,票券:2410021820351433659601,订单:24100218203514330327,[2024-10-02 18:20:44支付宝支付10元]
2024-10-02 18:20:47 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410021820351433659601","queue_number":131,"trade_uid":"24100218203514330327"}]}
2024-10-02 18:20:47 >>>故障排除日志:删除未同步下发订单成功24100218203514330327
2024-10-02 18:20:47 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


===18:41:23===
2024-10-02 18:40:45 >>>回调事件[910,devices/D0264]
2024-10-02 18:40:45 >>>故障排除日志:上一MQTT订单号缓存列表为24100218345270105228
2024-10-02 18:40:45 >>>故障排除日志:终端未同步成功订单列表
2024-10-02 18:40:45 开始打印,排队:134,票券:2410021840396086639301,订单:24100218403960862073,[2024-10-02 18:40:44微信支付10元]
2024-10-02 18:40:45 开始打印,排队:135,票券:2410021840396086785302,订单:24100218403960862073,[2024-10-02 18:40:44微信支付10元]
2024-10-02 18:40:49 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410021840396086639301","queue_number":134,"trade_uid":"24100218403960862073"},{"ticket_no":"2410021840396086785302","queue_number":135,"trade_uid":"24100218403960862073"}]}
2024-10-02 18:40:49 >>>故障排除日志:删除未同步下发订单成功24100218403960862073
2024-10-02 18:40:49 >>>故障排除日志:删除未同步下发订单成功24100218403960862073
2024-10-02 18:40:49 >>>故障排除日志:终端同步成功后剩余订单列表


===18:43:23===
2024-10-02 18:43:05 >>>回调事件[910,devices/D0264]
2024-10-02 18:43:05 >>>故障排除日志:上一MQTT订单号缓存列表为24100218403960862073|24100218403960862073
2024-10-02 18:43:05 >>>故障排除日志:终端未同步成功订单列表
2024-10-02 18:43:05 开始打印,排队:136,票券:2410021842554542586401,订单:24100218425545419691,[2024-10-02 18:43:05微信支付10元]
2024-10-02 18:43:07 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410021842554542586401","queue_number":136,"trade_uid":"24100218425545419691"}]}
2024-10-02 18:43:07 >>>故障排除日志:删除未同步下发订单成功24100218425545419691
2024-10-02 18:43:08 >>>故障排除日志:终端同步成功后剩余订单列表


===18:44:23===
2024-10-02 18:43:32 >>>回调事件[910,devices/D0264]
2024-10-02 18:43:32 >>>故障排除日志:上一MQTT订单号缓存列表为24100218425545419691
2024-10-02 18:43:32 >>>故障排除日志:终端未同步成功订单列表
2024-10-02 18:43:32 开始打印,排队:137,票券:2410021843200245812401,订单:24100218432002454676,[2024-10-02 18:43:32微信支付10元]
2024-10-02 18:43:34 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410021843200245812401","queue_number":137,"trade_uid":"24100218432002454676"}]}
2024-10-02 18:43:34 >>>故障排除日志:删除未同步下发订单成功24100218432002454676
2024-10-02 18:43:34 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-02 18:43:53 >>>回调事件[910,devices/D0264]
2024-10-02 18:43:53 >>>故障排除日志:上一MQTT订单号缓存列表为24100218432002454676
2024-10-02 18:43:53 >>>故障排除日志:终端未同步成功订单列表
2024-10-02 18:43:53 开始打印,排队:138,票券:2410021843443167935601,订单:24100218434431674642,[2024-10-02 18:43:52微信支付10元]
2024-10-02 18:43:55 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410021843443167935601","queue_number":138,"trade_uid":"24100218434431674642"}]}
2024-10-02 18:43:55 >>>故障排除日志:删除未同步下发订单成功24100218434431674642
2024-10-02 18:43:55 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-02 18:44:15 >>>回调事件[910,devices/D0264]
2024-10-02 18:44:15 >>>故障排除日志:上一MQTT订单号缓存列表为24100218434431674642
2024-10-02 18:44:15 >>>故障排除日志:终端未同步成功订单列表
2024-10-02 18:44:15 开始打印,排队:139,票券:2410021844043655039401,订单:24100218440436545072,[2024-10-02 18:44:14微信支付10元]
2024-10-02 18:44:17 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410021844043655039401","queue_number":139,"trade_uid":"24100218440436545072"}]}
2024-10-02 18:44:17 >>>故障排除日志:删除未同步下发订单成功24100218440436545072
2024-10-02 18:44:17 >>>故障排除日志:终端同步成功后剩余订单列表


===18:48:24===
2024-10-02 18:47:28 >>>回调事件[910,devices/D0264]
2024-10-02 18:47:28 >>>故障排除日志:上一MQTT订单号缓存列表为24100218440436545072
2024-10-02 18:47:28 >>>故障排除日志:终端未同步成功订单列表
2024-10-02 18:47:28 开始打印,排队:140,票券:2410021847221506179701,订单:24100218472215057956,[2024-10-02 18:47:27支付宝支付10元]
2024-10-02 18:47:30 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410021847221506179701","queue_number":140,"trade_uid":"24100218472215057956"}]}
2024-10-02 18:47:30 >>>故障排除日志:删除未同步下发订单成功24100218472215057956
2024-10-02 18:47:30 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


===19:15:25===
2024-10-02 19:14:30 >>>回调事件[910,devices/D0264]
2024-10-02 19:14:30 >>>故障排除日志:上一MQTT订单号缓存列表为24100219093742301367
2024-10-02 19:14:30 >>>故障排除日志:终端未同步成功订单列表
2024-10-02 19:14:30 开始打印,排队:145,票券:2410021914234535532801,订单:24100219142345350591,[2024-10-02 19:14:29微信支付10元]
2024-10-02 19:14:32 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410021914234535532801","queue_number":145,"trade_uid":"24100219142345350591"}]}
2024-10-02 19:14:32 >>>故障排除日志:删除未同步下发订单成功24100219142345350591
2024-10-02 19:14:32 >>>故障排除日志:终端同步成功后剩余订单列表


===19:16:25===
2024-10-02 19:15:39 >>>回调事件[910,devices/D0264]
2024-10-02 19:15:39 >>>故障排除日志:上一MQTT订单号缓存列表为24100219142345350591
2024-10-02 19:15:39 >>>故障排除日志:终端未同步成功订单列表
2024-10-02 19:15:39 开始打印,排队:146,票券:2410021915324343893201,订单:24100219153243433931,[2024-10-02 19:15:38微信支付10元]
2024-10-02 19:15:41 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410021915324343893201","queue_number":146,"trade_uid":"24100219153243433931"}]}
2024-10-02 19:15:41 >>>故障排除日志:删除未同步下发订单成功24100219153243433931
2024-10-02 19:15:41 >>>故障排除日志:终端同步成功后剩余订单列表


===19:23:26===
2024-10-02 19:23:11 >>>回调事件[910,devices/D0264]
2024-10-02 19:23:11 >>>故障排除日志:上一MQTT订单号缓存列表为24100219153243433931
2024-10-02 19:23:11 >>>故障排除日志:终端未同步成功订单列表
2024-10-02 19:23:11 开始打印,排队:147,票券:2410021923049684094201,订单:24100219230496837279,[2024-10-02 19:23:10支付宝支付10元]
2024-10-02 19:23:13 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410021923049684094201","queue_number":147,"trade_uid":"24100219230496837279"}]}
2024-10-02 19:23:13 >>>故障排除日志:删除未同步下发订单成功24100219230496837279
2024-10-02 19:23:13 >>>故障排除日志:终端同步成功后剩余订单列表


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


===19:27:26===
2024-10-02 19:27:04 >>>回调事件[910,devices/D0264]
2024-10-02 19:27:04 >>>故障排除日志:上一MQTT订单号缓存列表为24100219260513611353
2024-10-02 19:27:04 >>>故障排除日志:终端未同步成功订单列表
2024-10-02 19:27:04 开始打印,排队:149,票券:2410021926578866606301,订单:24100219265788662314,[2024-10-02 19:27:04支付宝支付10元]
2024-10-02 19:27:04 开始打印,排队:150,票券:2410021926578866757602,订单:24100219265788662314,[2024-10-02 19:27:04支付宝支付10元]
2024-10-02 19:27:08 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410021926578866606301","queue_number":149,"trade_uid":"24100219265788662314"},{"ticket_no":"2410021926578866757602","queue_number":150,"trade_uid":"24100219265788662314"}]}
2024-10-02 19:27:08 >>>故障排除日志:删除未同步下发订单成功24100219265788662314
2024-10-02 19:27:08 >>>故障排除日志:删除未同步下发订单成功24100219265788662314
2024-10-02 19:27:08 >>>故障排除日志:终端同步成功后剩余订单列表


===19:31:26===
2024-10-02 19:30:30 >>>回调事件[910,devices/D0264]
2024-10-02 19:30:30 >>>故障排除日志:上一MQTT订单号缓存列表为24100219265788662314|24100219265788662314
2024-10-02 19:30:30 >>>故障排除日志:终端未同步成功订单列表
2024-10-02 19:30:30 开始打印,排队:151,票券:2410021930240643781201,订单:24100219302406432189,[2024-10-02 19:30:29微信支付10元]
2024-10-02 19:30:32 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410021930240643781201","queue_number":151,"trade_uid":"24100219302406432189"}]}
2024-10-02 19:30:32 >>>故障排除日志:删除未同步下发订单成功24100219302406432189
2024-10-02 19:30:32 >>>故障排除日志:终端同步成功后剩余订单列表


===19:42:26===
2024-10-02 19:41:48>>>cash read=00
2024-10-02 19:41:49>>>cash read=818F42
2024-10-02 19:41:49>>>cash write=02
2024-10-02 19:41:49 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-02 19:41:50>>>cash read=10
2024-10-02 19:41:50 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-02 19:41:50 当前产品价格10元，投币10元，打印小票中...
2024-10-02 19:41:50 >>>开始打印,排队号为152,订单号为2410021941500002641410
2024-10-02 19:41:50>>>订单2410021941500002641410写入成功,剩余空间为1680000,占用RAM为606.255859375
删除未同步订单2410021941500002641410
2024-10-02 19:41:52>>>订单2410021941500002641410删除成功,剩余空间为1680500,占用RAM为619.5048828125
检测订单目录中>>>
无未同步订单>>>
2024-10-02 19:41:52 >>>当前Ram内存为588.9013671875
定时检测未同步订单启用
2024-10-02 19:41:53>>>cash write=0C
2024-10-02 19:41:53>>>cash read=3E


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


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


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


===19:50:27===
2024-10-02 19:50:00 >>>回调事件[910,devices/D0264]
2024-10-02 19:50:00 >>>故障排除日志:上一MQTT订单号缓存列表为24100219461527551995
2024-10-02 19:50:00 >>>故障排除日志:终端未同步成功订单列表
2024-10-02 19:50:00 开始打印,排队:155,票券:2410021949502636183901,订单:24100219495026358774,[2024-10-02 19:49:59支付宝支付10元]
2024-10-02 19:50:02 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410021949502636183901","queue_number":155,"trade_uid":"24100219495026358774"}]}
2024-10-02 19:50:02 >>>故障排除日志:删除未同步下发订单成功24100219495026358774
2024-10-02 19:50:02 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


===20:01:28===
2024-10-02 20:00:45 >>>回调事件[910,devices/D0264]
2024-10-02 20:00:45 >>>故障排除日志:上一MQTT订单号缓存列表为24100219594163682161
2024-10-02 20:00:45 >>>故障排除日志:终端未同步成功订单列表
2024-10-02 20:00:45 开始打印,排队:160,票券:2410022000362405157801,订单:24100220003624044395,[2024-10-02 20:00:44支付宝支付10元]
2024-10-02 20:00:47 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410022000362405157801","queue_number":160,"trade_uid":"24100220003624044395"}]}
2024-10-02 20:00:47 >>>故障排除日志:删除未同步下发订单成功24100220003624044395
2024-10-02 20:00:47 >>>故障排除日志:终端同步成功后剩余订单列表


===20:03:29===
2024-10-02 20:02:42 >>>回调事件[910,devices/D0264]
2024-10-02 20:02:42 >>>故障排除日志:上一MQTT订单号缓存列表为24100220003624044395
2024-10-02 20:02:42 >>>故障排除日志:终端未同步成功订单列表
2024-10-02 20:02:42 开始打印,排队:161,票券:2410022002252920751301,订单:24100220022529202743,[2024-10-02 20:02:41微信支付10元]
2024-10-02 20:02:44 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410022002252920751301","queue_number":161,"trade_uid":"24100220022529202743"}]}
2024-10-02 20:02:44 >>>故障排除日志:删除未同步下发订单成功24100220022529202743
2024-10-02 20:02:44 >>>故障排除日志:终端同步成功后剩余订单列表


===20:08:29===
2024-10-02 20:08:06 >>>回调事件[910,devices/D0264]
2024-10-02 20:08:06 >>>故障排除日志:上一MQTT订单号缓存列表为24100220022529202743
2024-10-02 20:08:06 >>>故障排除日志:终端未同步成功订单列表
2024-10-02 20:08:06 开始打印,排队:162,票券:2410022007575564404701,订单:24100220075755638073,[2024-10-02 20:08:05微信支付10元]
2024-10-02 20:08:07 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410022007575564404701","queue_number":162,"trade_uid":"24100220075755638073"}]}
2024-10-02 20:08:07 >>>故障排除日志:删除未同步下发订单成功24100220075755638073
2024-10-02 20:08:08 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-02 20:08:22 >>>回调事件[910,devices/D0264]
2024-10-02 20:08:22 >>>故障排除日志:上一MQTT订单号缓存列表为24100220075755638073
2024-10-02 20:08:22 >>>故障排除日志:终端未同步成功订单列表
2024-10-02 20:08:22 开始打印,排队:163,票券:2410022008160909112501,订单:24100220081609087563,[2024-10-02 20:08:21微信支付10元]
2024-10-02 20:08:24 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410022008160909112501","queue_number":163,"trade_uid":"24100220081609087563"}]}
2024-10-02 20:08:24 >>>故障排除日志:删除未同步下发订单成功24100220081609087563
2024-10-02 20:08:24 >>>故障排除日志:终端同步成功后剩余订单列表


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


===20:17:29===
2024-10-02 20:16:50 >>>回调事件[910,devices/D0264]
2024-10-02 20:16:50 >>>故障排除日志:上一MQTT订单号缓存列表为24100220093496005718
2024-10-02 20:16:50 >>>故障排除日志:终端未同步成功订单列表
2024-10-02 20:16:50 开始打印,排队:165,票券:2410022016410564191401,订单:24100220164105637381,[2024-10-02 20:16:50微信支付10元]
2024-10-02 20:16:50 开始打印,排队:166,票券:2410022016410564399402,订单:24100220164105637381,[2024-10-02 20:16:50微信支付10元]
2024-10-02 20:16:54 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410022016410564191401","queue_number":165,"trade_uid":"24100220164105637381"},{"ticket_no":"2410022016410564399402","queue_number":166,"trade_uid":"24100220164105637381"}]}
2024-10-02 20:16:54 >>>故障排除日志:删除未同步下发订单成功24100220164105637381
2024-10-02 20:16:54 >>>故障排除日志:删除未同步下发订单成功24100220164105637381
2024-10-02 20:16:54 >>>故障排除日志:终端同步成功后剩余订单列表


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


===20:23:30===
2024-10-02 20:22:46 >>>回调事件[910,devices/D0264]
2024-10-02 20:22:46 >>>故障排除日志:上一MQTT订单号缓存列表为24100220175912982312
2024-10-02 20:22:46 >>>故障排除日志:终端未同步成功订单列表
2024-10-02 20:22:46 开始打印,排队:168,票券:2410022022405952473201,订单:24100220224059520147,[2024-10-02 20:22:45微信支付10元]
2024-10-02 20:22:48 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410022022405952473201","queue_number":168,"trade_uid":"24100220224059520147"}]}
2024-10-02 20:22:48 >>>故障排除日志:删除未同步下发订单成功24100220224059520147
2024-10-02 20:22:48 >>>故障排除日志:终端同步成功后剩余订单列表


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


===20:40:30===
2024-10-02 20:40:13>>>cash read=00
2024-10-02 20:40:15>>>cash read=2F29
2024-10-02 20:40:16>>>cash read=3E
2024-10-02 20:40:19>>>cash read=29
2024-10-02 20:40:19 >>>回调事件130,cash_status,20029,退钞中
2024-10-02 20:40:20>>>cash read=3E
2024-10-02 20:40:21>>>cash read=00
2024-10-02 20:40:22>>>cash read=01
2024-10-02 20:40:26>>>cash read=3E


===20:41:30===
2024-10-02 20:40:30>>>cash read=00
2024-10-02 20:40:31>>>cash read=00818F42
2024-10-02 20:40:31>>>cash write=02
2024-10-02 20:40:31 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-02 20:40:32>>>cash read=10
2024-10-02 20:40:32 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-02 20:40:32 当前产品价格10元，投币10元，打印小票中...
2024-10-02 20:40:32 >>>开始打印,排队号为170,订单号为2410022040320002645778
2024-10-02 20:40:32>>>订单2410022040320002645778写入成功,剩余空间为1680000,占用RAM为606
删除未同步订单2410022040320002645778
2024-10-02 20:40:34>>>订单2410022040320002645778删除成功,剩余空间为1680500,占用RAM为619.1962890625
检测订单目录中>>>
无未同步订单>>>
2024-10-02 20:40:34 >>>当前Ram内存为588.6171875
定时检测未同步订单启用
2024-10-02 20:40:35>>>cash write=0C
2024-10-02 20:40:35>>>cash read=3E


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


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


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