TLClient_JSSCOM_LuatOS-Air_V3205_RDA8910_RFTTS_0xe0000,2.3.3,861714058754320,37438794650599,
poweron reason:0

===08:15:53===
上一时间戳为1719965839
隔日重置时间戳true
隔日清空未同步下发列表true
当前排队号为1,音量为6
初始化产品信息:[{"time_limit_date":"","ticket_category":"0","expiry_date":90,"product_detail":"","time_limit_status":"0","begin_minute":"00","product_uid":"5648114436008088297","use_timer":1,"old_price":"10","end_hour":"23","sale_price":"10","end_minute":"59","begin_hour":"00","sale_status":1,"product_name":"剪发一律10元"}]
打印门店标题设置为欢迎光临合剪（杭州江城店）
是否打印二维码设置为1
是否打印紧凑设置为3
session_id:afb84****095b9
纸币器设置接收纸币范围为36
欢迎使用天羚自助售票系统[2.3.3]
定时检测未同步订单启用
2024-07-04 08:14:52>>>cash write=30
2024-07-04 08:14:52>>>cash write=02
2024-07-04 08:14:52>>>cash write=3E
系统时间初始化成功，时间为20247481452
2024-07-04 08:14:52>>>cash read=808F808F808F
2024-07-04 08:14:53>>>cash write=02
2024-07-04 08:14:53 >>>剩余flash空间=1674500,占用RAM为613.2001953125
2024-07-04 08:14:53 >>>回调事件:910,subscribe,10000,连接服务器成功

2024-07-04 08:14:53 >>>剩余flash空间=1674000,占用RAM为592.22265625
2024-07-04 08:14:54 >>>回调事件:911,GetMqttQueue,500,暂无需要下发的信息，请求类型：ticket

2024-07-04 08:14:56>>>cash write=0C
2024-07-04 08:14:56>>>cash read=3E
流量卡还有270天过期
2024-07-04 08:15:02 >>>当前Ram内存为626.5380859375


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


===08:27:53===
2024-07-04 08:27:19>>>cash read=BF
2024-07-04 08:27:20>>>cash read=3E


===08:38:54===
2024-07-04 08:37:55 >>>回调事件[910,devices/D0309]
当日首次设置时间戳true为1720053475
2024-07-04 08:37:55 >>>故障排除日志:上一MQTT订单号缓存列表为24070321292092831192
2024-07-04 08:37:55 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 08:37:55 开始打印,排队:1,票券:2407040837485238201201,订单:24070408374852378091,[2024-07-04 08:37:48微信支付10元]
2024-07-04 08:37:57 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407040837485238201201","queue_number":1,"trade_uid":"24070408374852378091"}]}
2024-07-04 08:37:57 >>>故障排除日志:删除未同步下发订单成功24070408374852378091
2024-07-04 08:37:57 >>>故障排除日志:终端同步成功后剩余订单列表
2024-07-04 08:37:57 收到下发指令:叫号1>>>


===08:39:54===
2024-07-04 08:39:26 >>>回调事件[910,devices/D0309]
2024-07-04 08:39:26 >>>故障排除日志:上一MQTT订单号缓存列表为24070408374852378091
2024-07-04 08:39:26 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 08:39:26 开始打印,排队:2,票券:2407040839173652850201,订单:24070408391736523872,[2024-07-04 08:39:17支付宝支付10元]
2024-07-04 08:39:28 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407040839173652850201","queue_number":2,"trade_uid":"24070408391736523872"}]}
2024-07-04 08:39:28 >>>故障排除日志:删除未同步下发订单成功24070408391736523872
2024-07-04 08:39:28 >>>故障排除日志:终端同步成功后剩余订单列表


===08:41:54===
2024-07-04 08:41:09>>>cash read=9E
2024-07-04 08:41:10>>>cash read=3E
2024-07-04 08:41:20 >>>回调事件[910,devices/D0309]
2024-07-04 08:41:20 >>>故障排除日志:上一MQTT订单号缓存列表为24070408391736523872
2024-07-04 08:41:20 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 08:41:20 开始打印,排队:3,票券:2407040841095908797901,订单:24070408410959079579,[2024-07-04 08:41:09支付宝支付10元]
2024-07-04 08:41:22 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407040841095908797901","queue_number":3,"trade_uid":"24070408410959079579"}]}
2024-07-04 08:41:22 >>>故障排除日志:删除未同步下发订单成功24070408410959079579
2024-07-04 08:41:22 >>>故障排除日志:终端同步成功后剩余订单列表


===08:43:54===
2024-07-04 08:43:04 >>>回调事件[910,devices/D0309]
2024-07-04 08:43:04 >>>故障排除日志:上一MQTT订单号缓存列表为24070408410959079579
2024-07-04 08:43:04 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 08:43:04 开始打印,排队:4,票券:2407040842555430135801,订单:24070408425554296927,[2024-07-04 08:42:55微信支付10元]
2024-07-04 08:43:06 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407040842555430135801","queue_number":4,"trade_uid":"24070408425554296927"}]}
2024-07-04 08:43:06 >>>故障排除日志:删除未同步下发订单成功24070408425554296927
2024-07-04 08:43:06 >>>故障排除日志:终端同步成功后剩余订单列表
2024-07-04 08:43:10 >>>回调事件[910,devices/D0309]
2024-07-04 08:43:10 >>>故障排除日志:上一MQTT订单号缓存列表为24070408425554296927
2024-07-04 08:43:10 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 08:43:10 开始打印,排队:5,票券:2407040843027619395401,订单:24070408430276189474,[2024-07-04 08:43:02微信支付10元]
2024-07-04 08:43:12 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407040843027619395401","queue_number":5,"trade_uid":"24070408430276189474"}]}
2024-07-04 08:43:12 >>>故障排除日志:删除未同步下发订单成功24070408430276189474
2024-07-04 08:43:12 >>>故障排除日志:终端同步成功后剩余订单列表


===08:49:55===
2024-07-04 08:48:54>>>cash read=9E
2024-07-04 08:48:55>>>cash read=3E


===08:58:55===
2024-07-04 08:58:09 >>>回调事件[910,devices/D0309]
2024-07-04 08:58:09 >>>故障排除日志:上一MQTT订单号缓存列表为24070408430276189474
2024-07-04 08:58:09 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 08:58:09 开始打印,排队:6,票券:2407040858010924525601,订单:24070408580109240889,[2024-07-04 08:58:01支付宝支付10元]
2024-07-04 08:58:11 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407040858010924525601","queue_number":6,"trade_uid":"24070408580109240889"}]}
2024-07-04 08:58:11 >>>故障排除日志:删除未同步下发订单成功24070408580109240889
2024-07-04 08:58:11 >>>故障排除日志:终端同步成功后剩余订单列表


===08:59:55===
2024-07-04 08:59:07>>>cash read=BF
2024-07-04 08:59:08>>>cash read=3E


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


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


===09:07:56===
2024-07-04 09:07:11>>>cash read=00
2024-07-04 09:07:11>>>cash read=818F42
2024-07-04 09:07:11>>>cash write=02
2024-07-04 09:07:11 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-07-04 09:07:12>>>cash write=0C
2024-07-04 09:07:12>>>cash read=00
2024-07-04 09:07:12>>>cash read=10
2024-07-04 09:07:12 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-07-04 09:07:12 >>>开始打印,排队号为9,订单号为2407040907120003096571
2024-07-04 09:07:13>>>订单2407040907120003096571写入成功,剩余空间为1674000,占用RAM为607.2763671875
删除未同步订单2407040907120003096571
2024-07-04 09:07:15>>>订单2407040907120003096571删除成功,剩余空间为1674500,占用RAM为609.9775390625
检测订单目录中>>>
无未同步订单>>>
2024-07-04 09:07:15 >>>当前Ram内存为581.041015625
定时检测未同步订单启用
2024-07-04 09:07:15>>>cash read=818F42
2024-07-04 09:07:15>>>cash write=02
2024-07-04 09:07:15 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-07-04 09:07:16>>>cash read=10
2024-07-04 09:07:16 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-07-04 09:07:16 >>>开始打印,排队号为10,订单号为2407040907160003094731
定时检测未同步订单关闭
2024-07-04 09:07:16>>>订单2407040907160003094731写入成功,剩余空间为1673000,占用RAM为601.9501953125
2024-07-04 09:07:18>>>cash read=818F42
2024-07-04 09:07:18 >>>回调事件130,cash_status,10022,进钞中...read money=10
删除未同步订单2407040907160003094731
2024-07-04 09:07:18>>>订单2407040907160003094731删除成功,剩余空间为1673500,占用RAM为600.576171875
检测订单目录中>>>
无未同步订单>>>
2024-07-04 09:07:18 >>>当前Ram内存为582.474609375
定时检测未同步订单启用
2024-07-04 09:07:19>>>cash read=10
2024-07-04 09:07:19 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-07-04 09:07:19 >>>开始打印,排队号为11,订单号为2407040907190003091100
定时检测未同步订单关闭
2024-07-04 09:07:19>>>订单2407040907190003091100写入成功,剩余空间为1672000,占用RAM为610.5400390625
2024-07-04 09:07:21>>>cash read=818F42
2024-07-04 09:07:21 >>>回调事件130,cash_status,10022,进钞中...read money=10
删除未同步订单2407040907190003091100
2024-07-04 09:07:22>>>订单2407040907190003091100删除成功,剩余空间为1673000,占用RAM为599.412109375
检测订单目录中>>>
无未同步订单>>>
2024-07-04 09:07:22 >>>当前Ram内存为583.140625
定时检测未同步订单启用
2024-07-04 09:07:22>>>cash read=10
2024-07-04 09:07:22 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-07-04 09:07:22 >>>开始打印,排队号为12,订单号为2407040907220003099450
定时检测未同步订单关闭
2024-07-04 09:07:22>>>订单2407040907220003099450写入成功,剩余空间为1671500,占用RAM为608.9033203125
删除未同步订单2407040907220003099450
2024-07-04 09:07:25>>>订单2407040907220003099450删除成功,剩余空间为1672500,占用RAM为617.34765625
检测订单目录中>>>
无未同步订单>>>
2024-07-04 09:07:25 >>>当前Ram内存为584.6767578125
定时检测未同步订单启用
2024-07-04 09:07:26>>>cash write=0C
2024-07-04 09:07:26>>>cash read=29
2024-07-04 09:07:26 >>>回调事件130,cash_status,20029,退钞中
2024-07-04 09:07:26>>>cash read=2F29
2024-07-04 09:07:27>>>cash read=01
2024-07-04 09:07:27>>>cash read=2F
2024-07-04 09:07:29>>>cash read=00
2024-07-04 09:07:29>>>cash read=818F42
2024-07-04 09:07:29>>>cash write=02
2024-07-04 09:07:29 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-07-04 09:07:29>>>cash read=10
2024-07-04 09:07:29 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-07-04 09:07:30 >>>开始打印,排队号为13,订单号为2407040907300003098749
定时检测未同步订单关闭
2024-07-04 09:07:30>>>订单2407040907300003098749写入成功,剩余空间为1670500,占用RAM为616.212890625
2024-07-04 09:07:32>>>cash read=818F42
2024-07-04 09:07:32 >>>回调事件130,cash_status,10022,进钞中...read money=10
删除未同步订单2407040907300003098749
2024-07-04 09:07:32>>>订单2407040907300003098749删除成功,剩余空间为1671000,占用RAM为610.0107421875
检测订单目录中>>>
无未同步订单>>>
2024-07-04 09:07:32 >>>当前Ram内存为586.2294921875
定时检测未同步订单启用
2024-07-04 09:07:33>>>cash read=10
2024-07-04 09:07:33 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-07-04 09:07:33 >>>开始打印,排队号为14,订单号为2407040907330003095119
定时检测未同步订单关闭
2024-07-04 09:07:33>>>订单2407040907330003095119写入成功,剩余空间为1669500,占用RAM为625.40625
删除未同步订单2407040907330003095119
2024-07-04 09:07:36>>>订单2407040907330003095119删除成功,剩余空间为1670500,占用RAM为622.3193359375
检测订单目录中>>>
无未同步订单>>>
2024-07-04 09:07:36 >>>当前Ram内存为587.7666015625
定时检测未同步订单启用


===09:08:56===
2024-07-04 09:08:25>>>cash read=00
2024-07-04 09:08:25>>>cash read=818F43
2024-07-04 09:08:25>>>cash write=02
2024-07-04 09:08:25 >>>回调事件130,cash_status,10022,进钞中...read money=20
2024-07-04 09:08:26>>>cash read=10
2024-07-04 09:08:26 >>>回调事件130,20,10023,finish Money=20,进钞完成
2024-07-04 09:08:26 >>>开始打印,排队号为16,订单号为2407040908260003095382
2024-07-04 09:08:26 >>>开始打印,排队号为17,订单号为2407040908260003095382
定时检测未同步订单关闭
2024-07-04 09:08:27>>>订单2407040908260003095382写入成功,剩余空间为1673000,占用RAM为602.73046875
删除未同步订单2407040908260003095382
2024-07-04 09:08:30>>>订单2407040908260003095382删除成功,剩余空间为1674500,占用RAM为619.912109375
检测订单目录中>>>
无未同步订单>>>
2024-07-04 09:08:30 >>>当前Ram内存为581.8525390625
定时检测未同步订单启用
2024-07-04 09:08:31>>>cash write=0C
2024-07-04 09:08:31>>>cash read=00
2024-07-04 09:08:32>>>cash read=818F42
2024-07-04 09:08:32>>>cash write=02
2024-07-04 09:08:32 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-07-04 09:08:33>>>cash read=10
2024-07-04 09:08:33 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-07-04 09:08:33 >>>开始打印,排队号为18,订单号为2407040908330003092891
定时检测未同步订单关闭
2024-07-04 09:08:33>>>订单2407040908330003092891写入成功,剩余空间为1673000,占用RAM为602.9912109375
删除未同步订单2407040908330003092891
2024-07-04 09:08:35>>>订单2407040908330003092891删除成功,剩余空间为1673500,占用RAM为613.150390625
检测订单目录中>>>
无未同步订单>>>
2024-07-04 09:08:36 >>>当前Ram内存为582.6767578125
定时检测未同步订单启用
2024-07-04 09:08:36>>>cash write=0C
2024-07-04 09:08:36>>>cash read=00
2024-07-04 09:08:37>>>cash read=818F41
2024-07-04 09:08:37>>>cash write=02
2024-07-04 09:08:37 >>>回调事件130,cash_status,10022,进钞中...read money=5
2024-07-04 09:08:38>>>cash read=10
2024-07-04 09:08:38 >>>回调事件130,5,10023,finish Money=5,进钞完成
2024-07-04 09:08:39>>>cash write=0C
2024-07-04 09:08:39>>>cash read=00
2024-07-04 09:08:40>>>cash read=818F
2024-07-04 09:08:40>>>cash write=0f
2024-07-04 09:08:40 >>>回调事件130,cash_status,10024,识别到金额为0,面值不在接收范围内，正在退钞
2024-07-04 09:08:40>>>cash read=29
2024-07-04 09:08:40 >>>回调事件130,cash_status,20029,退钞中
2024-07-04 09:08:41>>>cash read=2F29
2024-07-04 09:08:42>>>cash write=0C
2024-07-04 09:08:42>>>cash read=3E
2024-07-04 09:08:43>>>cash read=2F29
2024-07-04 09:08:45>>>cash read=00
2024-07-04 09:08:45>>>cash read=818F41
2024-07-04 09:08:45>>>cash write=02
2024-07-04 09:08:45 >>>回调事件130,cash_status,10022,进钞中...read money=5
2024-07-04 09:08:46>>>cash read=10
2024-07-04 09:08:46 >>>回调事件130,5,10023,finish Money=5,进钞完成
2024-07-04 09:08:46 >>>开始打印,排队号为19,订单号为2407040908380003092840
定时检测未同步订单关闭
2024-07-04 09:08:46>>>订单2407040908380003092840写入成功,剩余空间为1671000,占用RAM为609.3017578125
删除未同步订单2407040908380003092840
2024-07-04 09:08:48>>>订单2407040908380003092840删除成功,剩余空间为1672000,占用RAM为619.265625
检测订单目录中>>>
无未同步订单>>>
2024-07-04 09:08:48 >>>当前Ram内存为584.2099609375
定时检测未同步订单启用
2024-07-04 09:08:49>>>cash write=0C
2024-07-04 09:08:49>>>cash read=3E


===09:09:56===
2024-07-04 09:09:06>>>cash read=9E
2024-07-04 09:09:07>>>cash read=3E
定时检测未同步订单关闭
检测订单目录中>>>
无未同步订单>>>


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


===09:11:57===
2024-07-04 09:11:33 >>>回调事件[910,devices/D0309]
2024-07-04 09:11:33 >>>故障排除日志:上一MQTT订单号缓存列表为24070409100844648927
2024-07-04 09:11:33 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 09:11:33 开始打印,排队:21,票券:2407040911236681527101,订单:24070409112366811526,[2024-07-04 09:11:23支付宝支付10元]
2024-07-04 09:11:35 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407040911236681527101","queue_number":21,"trade_uid":"24070409112366811526"}]}
2024-07-04 09:11:35 >>>故障排除日志:删除未同步下发订单成功24070409112366811526
2024-07-04 09:11:35 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


===09:19:58===
2024-07-04 09:19:28 >>>回调事件[910,devices/D0309]
2024-07-04 09:19:28 >>>故障排除日志:上一MQTT订单号缓存列表为24070409184057036309
2024-07-04 09:19:28 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 09:19:28 开始打印,排队:25,票券:2407040919155091945201,订单:24070409191550915693,[2024-07-04 09:19:15微信支付10元]
2024-07-04 09:19:30 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407040919155091945201","queue_number":25,"trade_uid":"24070409191550915693"}]}
2024-07-04 09:19:30 >>>故障排除日志:删除未同步下发订单成功24070409191550915693
2024-07-04 09:19:30 >>>故障排除日志:终端同步成功后剩余订单列表
2024-07-04 09:19:35 >>>回调事件[910,devices/D0309]
2024-07-04 09:19:35 >>>故障排除日志:上一MQTT订单号缓存列表为24070409191550915693
2024-07-04 09:19:35 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 09:19:35 开始打印,排队:26,票券:2407040919316367576301,订单:24070409193163670925,[2024-07-04 09:19:31支付宝支付10元]
2024-07-04 09:19:37 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407040919316367576301","queue_number":26,"trade_uid":"24070409193163670925"}]}
2024-07-04 09:19:37 >>>故障排除日志:删除未同步下发订单成功24070409193163670925
2024-07-04 09:19:37 >>>故障排除日志:终端同步成功后剩余订单列表


===09:20:58===
2024-07-04 09:20:23 >>>回调事件[910,devices/D0309]
2024-07-04 09:20:23 >>>故障排除日志:上一MQTT订单号缓存列表为24070409193163670925
2024-07-04 09:20:23 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 09:20:23 开始打印,排队:27,票券:2407040920152261271201,订单:24070409201522608059,[2024-07-04 09:20:15微信支付10元]
2024-07-04 09:20:25 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407040920152261271201","queue_number":27,"trade_uid":"24070409201522608059"}]}
2024-07-04 09:20:25 >>>故障排除日志:删除未同步下发订单成功24070409201522608059
2024-07-04 09:20:25 >>>故障排除日志:终端同步成功后剩余订单列表
2024-07-04 09:20:52>>>cash read=9E
2024-07-04 09:20:53>>>cash read=3E


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


===09:28:59===
2024-07-04 09:27:57>>>cash read=9E
2024-07-04 09:27:58>>>cash read=3E


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


===09:37:59===
2024-07-04 09:37:00>>>cash read=9E
2024-07-04 09:37:01>>>cash read=3E


===09:41:59===
2024-07-04 09:41:27>>>cash read=9E
2024-07-04 09:41:28>>>cash read=3E


===09:42:59===
2024-07-04 09:42:39>>>cash read=00
2024-07-04 09:42:39>>>cash read=818F42
2024-07-04 09:42:39>>>cash write=02
2024-07-04 09:42:39 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-07-04 09:42:40>>>cash read=10
2024-07-04 09:42:40 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-07-04 09:42:40 >>>开始打印,排队号为30,订单号为2407040942400003094773
2024-07-04 09:42:40>>>订单2407040942400003094773写入成功,剩余空间为1674500,占用RAM为596.130859375
删除未同步订单2407040942400003094773
2024-07-04 09:42:42>>>订单2407040942400003094773删除成功,剩余空间为1674500,占用RAM为608.7041015625
检测订单目录中>>>
无未同步订单>>>
2024-07-04 09:42:42 >>>当前Ram内存为581.5087890625
定时检测未同步订单启用
2024-07-04 09:42:43>>>cash write=0C
2024-07-04 09:42:43>>>cash read=3E


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


===09:46:00===
2024-07-04 09:45:32 >>>回调事件[910,devices/D0309]
2024-07-04 09:45:32 >>>故障排除日志:上一MQTT订单号缓存列表为24070409330999810273
2024-07-04 09:45:32 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 09:45:32 开始打印,排队:31,票券:2407040945224120167801,订单:24070409452241196720,[2024-07-04 09:45:22支付宝支付10元]
2024-07-04 09:45:34 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407040945224120167801","queue_number":31,"trade_uid":"24070409452241196720"}]}
2024-07-04 09:45:34 >>>故障排除日志:删除未同步下发订单成功24070409452241196720
2024-07-04 09:45:34 >>>故障排除日志:终端同步成功后剩余订单列表
2024-07-04 09:45:46 >>>回调事件[910,devices/D0309]
2024-07-04 09:45:46 >>>故障排除日志:上一MQTT订单号缓存列表为24070409452241196720
2024-07-04 09:45:46 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 09:45:46 开始打印,排队:32,票券:2407040945400945705701,订单:24070409454009452898,[2024-07-04 09:45:40支付宝支付10元]
2024-07-04 09:45:48 >>>回调事件[910,devices/D0309]
2024-07-04 09:45:48 >>>故障排除日志:上一MQTT订单号缓存列表为24070409454009452898
2024-07-04 09:45:48 >>>故障排除日志:终端未同步成功订单列表003224070409454009452898
2024-07-04 09:45:48 开始打印,排队:33,票券:2407040945355624969001,订单:24070409453556239612,[2024-07-04 09:45:35支付宝支付10元]
已接收过此消息,票券号为2407040945400945705701,排队号为32
2024-07-04 09:45:50 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407040945400945705701","queue_number":32,"trade_uid":"24070409454009452898"}]}
2024-07-04 09:45:50 >>>故障排除日志:删除未同步下发订单成功24070409454009452898
2024-07-04 09:45:50 >>>故障排除日志:终端同步成功后剩余订单列表003324070409453556239612
2024-07-04 09:45:51 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407040945355624969001","queue_number":33,"trade_uid":"24070409453556239612"},{"ticket_no":"2407040945400945705701","queue_number":32,"trade_uid":"24070409454009452898"}]}
2024-07-04 09:45:51 >>>故障排除日志:删除未同步下发订单成功24070409453556239612
2024-07-04 09:45:51 >>>故障排除日志:终端同步成功后剩余订单列表


===09:47:00===
2024-07-04 09:46:19 >>>回调事件[910,devices/D0309]
2024-07-04 09:46:19 >>>故障排除日志:上一MQTT订单号缓存列表为24070409453556239612|24070409454009452898
2024-07-04 09:46:19 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 09:46:19 开始打印,排队:34,票券:2407040946128674101801,订单:24070409461286737329,[2024-07-04 09:46:12微信支付10元]
2024-07-04 09:46:21 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407040946128674101801","queue_number":34,"trade_uid":"24070409461286737329"}]}
2024-07-04 09:46:21 >>>故障排除日志:删除未同步下发订单成功24070409461286737329
2024-07-04 09:46:21 >>>故障排除日志:终端同步成功后剩余订单列表
2024-07-04 09:46:31>>>cash read=9E
2024-07-04 09:46:32>>>cash read=3E
2024-07-04 09:46:53 >>>回调事件[910,devices/D0309]
2024-07-04 09:46:53 >>>故障排除日志:上一MQTT订单号缓存列表为24070409461286737329
2024-07-04 09:46:54 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 09:46:54 开始打印,排队:35,票券:2407040946452587977201,订单:24070409464525875514,[2024-07-04 09:46:45支付宝支付10元]
2024-07-04 09:46:56 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407040946452587977201","queue_number":35,"trade_uid":"24070409464525875514"}]}
2024-07-04 09:46:56 >>>故障排除日志:删除未同步下发订单成功24070409464525875514
2024-07-04 09:46:56 >>>故障排除日志:终端同步成功后剩余订单列表


===09:48:00===
2024-07-04 09:47:34>>>cash read=1F
2024-07-04 09:47:35>>>cash read=3E


===09:49:01===
2024-07-04 09:48:06>>>cash read=9E
2024-07-04 09:48:07>>>cash read=3E
2024-07-04 09:48:31 >>>回调事件[910,devices/D0309]
2024-07-04 09:48:31 >>>故障排除日志:上一MQTT订单号缓存列表为24070409464525875514
2024-07-04 09:48:31 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 09:48:31 开始打印,排队:36,票券:2407040948239281809301,订单:24070409482392811951,[2024-07-04 09:48:23微信支付10元]
2024-07-04 09:48:33 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407040948239281809301","queue_number":36,"trade_uid":"24070409482392811951"}]}
2024-07-04 09:48:33 >>>故障排除日志:删除未同步下发订单成功24070409482392811951
2024-07-04 09:48:33 >>>故障排除日志:终端同步成功后剩余订单列表


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


===09:55:01===
2024-07-04 09:54:43>>>cash read=9E
2024-07-04 09:54:44>>>cash read=3E


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


===10:01:01===
2024-07-04 10:00:44>>>cash read=9E
2024-07-04 10:00:45>>>cash read=3E


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


===10:04:02===
2024-07-04 10:03:25 >>>回调事件[910,devices/D0309]
2024-07-04 10:03:25 >>>故障排除日志:上一MQTT订单号缓存列表为24070410024686835843
2024-07-04 10:03:25 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 10:03:25 开始打印,排队:40,票券:2407041003131732053401,订单:24070410031317315023,[2024-07-04 10:03:13支付宝支付10元]
2024-07-04 10:03:27 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407041003131732053401","queue_number":40,"trade_uid":"24070410031317315023"}]}
2024-07-04 10:03:27 >>>故障排除日志:删除未同步下发订单成功24070410031317315023
2024-07-04 10:03:27 >>>故障排除日志:终端同步成功后剩余订单列表
2024-07-04 10:03:47 >>>回调事件[910,devices/D0309]
2024-07-04 10:03:47 >>>故障排除日志:上一MQTT订单号缓存列表为24070410031317315023
2024-07-04 10:03:47 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 10:03:47 开始打印,排队:41,票券:2407041003299321610201,订单:24070410032993211757,[2024-07-04 10:03:29微信支付10元]
2024-07-04 10:03:49 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407041003299321610201","queue_number":41,"trade_uid":"24070410032993211757"}]}
2024-07-04 10:03:49 >>>故障排除日志:删除未同步下发订单成功24070410032993211757
2024-07-04 10:03:49 >>>故障排除日志:终端同步成功后剩余订单列表
2024-07-04 10:03:55>>>cash read=9E
2024-07-04 10:03:56>>>cash read=3E


===10:06:02===
2024-07-04 10:05:50 >>>回调事件[910,devices/D0309]
2024-07-04 10:05:50 >>>故障排除日志:上一MQTT订单号缓存列表为24070410032993211757
2024-07-04 10:05:50 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 10:05:50 开始打印,排队:42,票券:2407041005391033210901,订单:24070410053910327793,[2024-07-04 10:05:39支付宝支付10元]
2024-07-04 10:05:53 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407041005391033210901","queue_number":42,"trade_uid":"24070410053910327793"}]}
2024-07-04 10:05:53 >>>故障排除日志:删除未同步下发订单成功24070410053910327793
2024-07-04 10:05:53 >>>故障排除日志:终端同步成功后剩余订单列表


===10:10:02===
2024-07-04 10:09:17>>>cash read=1F
2024-07-04 10:09:19>>>cash read=3E


===10:11:02===
2024-07-04 10:10:56>>>cash read=9E
2024-07-04 10:10:57>>>cash read=3E


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


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


===10:19:03===
2024-07-04 10:18:28>>>cash read=9E
2024-07-04 10:18:29>>>cash read=3E


===10:20:03===
2024-07-04 10:19:47>>>cash read=9E
2024-07-04 10:19:48>>>cash read=3E


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


===10:23:06===
2024-07-04 10:22:56>>>cash read=00
2024-07-04 10:22:57>>>cash read=818F42
2024-07-04 10:22:57>>>cash write=02
2024-07-04 10:22:57 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-07-04 10:22:57>>>cash read=10
2024-07-04 10:22:57 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-07-04 10:22:57 >>>开始打印,排队号为46,订单号为2407041022570003095191
2024-07-04 10:22:57>>>订单2407041022570003095191写入成功,剩余空间为1674500,占用RAM为595.6689453125
2024-07-04 10:22:59>>>cash read=818F43
2024-07-04 10:22:59 >>>回调事件130,cash_status,10022,进钞中...read money=20
删除未同步订单2407041022570003095191
2024-07-04 10:23:00>>>订单2407041022570003095191删除成功,剩余空间为1674500,占用RAM为591.2548828125
检测订单目录中>>>
无未同步订单>>>
2024-07-04 10:23:00 >>>当前Ram内存为580.7275390625
定时检测未同步订单启用
2024-07-04 10:23:00>>>cash read=10
2024-07-04 10:23:00 >>>回调事件130,20,10023,finish Money=20,进钞完成
2024-07-04 10:23:00 >>>开始打印,排队号为47,订单号为2407041023000003094541
2024-07-04 10:23:00 >>>开始打印,排队号为48,订单号为2407041023000003094541
定时检测未同步订单关闭
2024-07-04 10:23:01>>>订单2407041023000003094541写入成功,剩余空间为1672500,占用RAM为601.02734375
2024-07-04 10:23:04>>>cash read=818F43
2024-07-04 10:23:04 >>>回调事件130,cash_status,10022,进钞中...read money=20


===10:24:06===
删除未同步订单2407041023000003094541
2024-07-04 10:23:04>>>订单2407041023000003094541删除成功,剩余空间为1675500,占用RAM为605.259765625
检测订单目录中>>>
无未同步订单>>>
2024-07-04 10:23:05 >>>当前Ram内存为581.8408203125
定时检测未同步订单启用
2024-07-04 10:23:05>>>cash read=10
2024-07-04 10:23:05 >>>回调事件130,20,10023,finish Money=20,进钞完成
2024-07-04 10:23:05 >>>开始打印,排队号为49,订单号为2407041023050003094490
2024-07-04 10:23:05 >>>开始打印,排队号为50,订单号为2407041023050003094490
定时检测未同步订单关闭
2024-07-04 10:23:05>>>订单2407041023050003094490写入成功,剩余空间为1673000,占用RAM为600.123046875
删除未同步订单2407041023050003094490
2024-07-04 10:23:09>>>订单2407041023050003094490删除成功,剩余空间为1674500,占用RAM为621.427734375
检测订单目录中>>>
无未同步订单>>>
2024-07-04 10:23:09 >>>当前Ram内存为583.29296875
定时检测未同步订单启用
2024-07-04 10:23:10>>>cash write=0C
2024-07-04 10:23:10>>>cash read=3E
2024-07-04 10:23:50>>>cash read=00
2024-07-04 10:23:51>>>cash read=818F42
2024-07-04 10:23:51>>>cash write=02
2024-07-04 10:23:51 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-07-04 10:23:52>>>cash read=10
2024-07-04 10:23:52 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-07-04 10:23:52 >>>开始打印,排队号为51,订单号为2407041023520003093013
定时检测未同步订单关闭
2024-07-04 10:23:52>>>订单2407041023520003093013写入成功,剩余空间为1672500,占用RAM为602.6748046875
删除未同步订单2407041023520003093013
2024-07-04 10:23:54>>>订单2407041023520003093013删除成功,剩余空间为1673500,占用RAM为614.77734375
检测订单目录中>>>
无未同步订单>>>
2024-07-04 10:23:54 >>>当前Ram内存为581.849609375
定时检测未同步订单启用
2024-07-04 10:23:55>>>cash write=0C
2024-07-04 10:23:55>>>cash read=3E


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


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


===10:28:07===
2024-07-04 10:27:40>>>cash read=9E
2024-07-04 10:27:42>>>cash read=3E


===10:29:07===
2024-07-04 10:28:39>>>cash read=9E
2024-07-04 10:28:40>>>cash read=3E


===10:30:07===
2024-07-04 10:29:10>>>cash read=9E
2024-07-04 10:29:11>>>cash read=3E


===10:31:07===
2024-07-04 10:31:01 >>>回调事件[910,devices/D0309]
2024-07-04 10:31:01 >>>故障排除日志:上一MQTT订单号缓存列表为24070410263860317370
2024-07-04 10:31:01 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 10:31:01 开始打印,排队:53,票券:2407041030496171999701,订单:24070410304961716102,[2024-07-04 10:30:49支付宝支付10元]
2024-07-04 10:31:03 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407041030496171999701","queue_number":53,"trade_uid":"24070410304961716102"}]}
2024-07-04 10:31:03 >>>故障排除日志:删除未同步下发订单成功24070410304961716102
2024-07-04 10:31:03 >>>故障排除日志:终端同步成功后剩余订单列表


===10:34:08===
2024-07-04 10:33:10 >>>回调事件[910,devices/D0309]
2024-07-04 10:33:10 >>>故障排除日志:上一MQTT订单号缓存列表为24070410304961716102
2024-07-04 10:33:10 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 10:33:10 开始打印,排队:54,票券:2407041033032487377601,订单:24070410330324868265,[2024-07-04 10:33:03支付宝支付10元]
2024-07-04 10:33:12 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407041033032487377601","queue_number":54,"trade_uid":"24070410330324868265"}]}
2024-07-04 10:33:12 >>>故障排除日志:删除未同步下发订单成功24070410330324868265
2024-07-04 10:33:12 >>>故障排除日志:终端同步成功后剩余订单列表


===10:38:08===
2024-07-04 10:37:29>>>cash read=00
2024-07-04 10:37:30>>>cash read=818F42
2024-07-04 10:37:30>>>cash write=02
2024-07-04 10:37:30 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-07-04 10:37:30>>>cash read=10
2024-07-04 10:37:30 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-07-04 10:37:30 >>>开始打印,排队号为55,订单号为2407041037300003095349
2024-07-04 10:37:30>>>订单2407041037300003095349写入成功,剩余空间为1674500,占用RAM为595.3583984375
删除未同步订单2407041037300003095349
2024-07-04 10:37:33>>>订单2407041037300003095349删除成功,剩余空间为1674500,占用RAM为609.5546875
检测订单目录中>>>
无未同步订单>>>
2024-07-04 10:37:33 >>>当前Ram内存为580.7529296875
定时检测未同步订单启用
2024-07-04 10:37:34>>>cash write=0C
2024-07-04 10:37:34>>>cash read=3E


===10:39:08===
定时检测未同步订单关闭
检测订单目录中>>>
无未同步订单>>>
2024-07-04 10:38:35>>>cash read=00
2024-07-04 10:38:36>>>cash read=818F42
2024-07-04 10:38:36>>>cash write=02
2024-07-04 10:38:36 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-07-04 10:38:36>>>cash read=10
2024-07-04 10:38:36 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-07-04 10:38:36 >>>开始打印,排队号为56,订单号为2407041038360003094861
2024-07-04 10:38:36>>>订单2407041038360003094861写入成功,剩余空间为1674000,占用RAM为595.505859375
删除未同步订单2407041038360003094861
2024-07-04 10:38:39>>>订单2407041038360003094861删除成功,剩余空间为1674500,占用RAM为611.068359375
检测订单目录中>>>
无未同步订单>>>
2024-07-04 10:38:39 >>>当前Ram内存为580.5751953125
定时检测未同步订单启用
2024-07-04 10:38:40>>>cash write=0C
2024-07-04 10:38:40>>>cash read=3E


===10:40:09===
2024-07-04 10:39:12>>>cash read=BF
2024-07-04 10:39:13>>>cash read=3E
定时检测未同步订单关闭
检测订单目录中>>>
无未同步订单>>>


===10:42:09===
2024-07-04 10:41:39>>>cash read=9E
2024-07-04 10:41:40>>>cash read=3E


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


===10:51:09===
2024-07-04 10:50:19>>>cash read=9E
2024-07-04 10:50:20>>>cash read=3E


===10:52:10===
2024-07-04 10:51:18 >>>回调事件[910,devices/D0309]
2024-07-04 10:51:19 >>>故障排除日志:上一MQTT订单号缓存列表为24070410461452615495
2024-07-04 10:51:19 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 10:51:19 开始打印,排队:58,票券:2407041051079428342601,订单:24070410510794279290,[2024-07-04 10:51:07支付宝支付10元]
2024-07-04 10:51:21 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407041051079428342601","queue_number":58,"trade_uid":"24070410510794279290"}]}
2024-07-04 10:51:21 >>>故障排除日志:删除未同步下发订单成功24070410510794279290
2024-07-04 10:51:21 >>>故障排除日志:终端同步成功后剩余订单列表


===10:53:10===
2024-07-04 10:53:02>>>cash read=9E
2024-07-04 10:53:03>>>cash read=3E


===10:56:10===
2024-07-04 10:55:22>>>cash read=9E
2024-07-04 10:55:23>>>cash read=3E


===10:57:10===
2024-07-04 10:57:03>>>cash read=9E
2024-07-04 10:57:04>>>cash read=3E


===10:58:11===
2024-07-04 10:58:03>>>cash read=9E
2024-07-04 10:58:04>>>cash read=3E


===11:00:03===
上一时间戳为1720053475
当日首次设置时间戳true为1720061942
今日nvm排队号为59
当前排队号为59,音量为6
初始化产品信息:[{"time_limit_date":"","ticket_category":"0","expiry_date":90,"product_detail":"","time_limit_status":"0","begin_minute":"00","product_uid":"5648114436008088297","use_timer":1,"old_price":"10","end_hour":"23","sale_price":"10","end_minute":"59","begin_hour":"00","sale_status":1,"product_name":"剪发一律10元"}]
打印门店标题设置为欢迎光临合剪（杭州江城店）
是否打印二维码设置为1
是否打印紧凑设置为3
session_id:0c4b4****2812a
纸币器设置接收纸币范围为36
欢迎使用天羚自助售票系统[2.3.3]
定时检测未同步订单启用
2024-07-04 10:59:03>>>cash write=30
2024-07-04 10:59:03>>>cash write=02
2024-07-04 10:59:03>>>cash write=3E
2024-07-04 10:59:03>>>cash read=808F808F808F
系统时间初始化成功，时间为20247410593
2024-07-04 10:59:04>>>cash write=02
2024-07-04 10:59:04 >>>剩余flash空间=1674500,占用RAM为619.314453125
2024-07-04 10:59:04 >>>回调事件:910,subscribe,10000,连接服务器成功

2024-07-04 10:59:04 >>>剩余flash空间=1674000,占用RAM为592.2158203125
2024-07-04 10:59:04 >>>回调事件:911,GetMqttQueue,500,暂无需要下发的信息，请求类型：ticket

2024-07-04 10:59:07>>>cash write=0C
2024-07-04 10:59:07>>>cash read=3E
流量卡还有270天过期
2024-07-04 10:59:13 >>>当前Ram内存为629.8525390625


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


===11:03:04===
2024-07-04 11:03:00>>>cash read=BF
2024-07-04 11:03:01>>>cash read=3E


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


===11:07:04===
2024-07-04 11:06:25>>>cash read=00
2024-07-04 11:06:26>>>cash read=818F43
2024-07-04 11:06:26>>>cash write=02
2024-07-04 11:06:26 >>>回调事件130,cash_status,10022,进钞中...read money=20
2024-07-04 11:06:26>>>cash read=10
2024-07-04 11:06:26 >>>回调事件130,20,10023,finish Money=20,进钞完成
2024-07-04 11:06:26 >>>开始打印,排队号为60,订单号为2407041106260003097720
2024-07-04 11:06:26 >>>开始打印,排队号为61,订单号为2407041106260003097720
2024-07-04 11:06:27>>>订单2407041106260003097720写入成功,剩余空间为1673500,占用RAM为600.509765625
删除未同步订单2407041106260003097720
2024-07-04 11:06:30>>>订单2407041106260003097720删除成功,剩余空间为1674500,占用RAM为620.1318359375
检测订单目录中>>>
无未同步订单>>>
2024-07-04 11:06:31 >>>当前Ram内存为582.001953125
定时检测未同步订单启用
2024-07-04 11:06:31>>>cash write=0C
2024-07-04 11:06:31>>>cash read=00
2024-07-04 11:06:36>>>cash read=29
2024-07-04 11:06:36 >>>回调事件130,cash_status,20029,退钞中
2024-07-04 11:06:37>>>cash read=2F29
2024-07-04 11:06:39>>>cash read=00
2024-07-04 11:06:39>>>cash read=818F41
2024-07-04 11:06:39>>>cash write=02
2024-07-04 11:06:39 >>>回调事件130,cash_status,10022,进钞中...read money=5
2024-07-04 11:06:40>>>cash read=10
2024-07-04 11:06:40 >>>回调事件130,5,10023,finish Money=5,进钞完成
2024-07-04 11:06:41>>>cash write=0C
2024-07-04 11:06:41>>>cash read=00
2024-07-04 11:06:42>>>cash read=818F41
2024-07-04 11:06:42>>>cash write=02
2024-07-04 11:06:42 >>>回调事件130,cash_status,10022,进钞中...read money=5
2024-07-04 11:06:43>>>cash read=10
2024-07-04 11:06:43 >>>回调事件130,5,10023,finish Money=5,进钞完成
2024-07-04 11:06:43 >>>开始打印,排队号为62,订单号为2407041106400003091236
定时检测未同步订单关闭
2024-07-04 11:06:43>>>订单2407041106400003091236写入成功,剩余空间为1672500,占用RAM为601.634765625
删除未同步订单2407041106400003091236
2024-07-04 11:06:45>>>订单2407041106400003091236删除成功,剩余空间为1673000,占用RAM为612.908203125
检测订单目录中>>>
无未同步订单>>>
2024-07-04 11:06:45 >>>当前Ram内存为582.0947265625
定时检测未同步订单启用
2024-07-04 11:06:46>>>cash write=0C
2024-07-04 11:06:46>>>cash read=3E


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


===11:17:05===
2024-07-04 11:16:28>>>cash read=9E
2024-07-04 11:16:29>>>cash read=3E


===11:19:05===
2024-07-04 11:18:33>>>cash read=9E
2024-07-04 11:18:34>>>cash read=3E


===11:21:05===
2024-07-04 11:20:09>>>cash read=9E
2024-07-04 11:20:11>>>cash read=3E
2024-07-04 11:20:51 >>>回调事件[910,devices/D0309]
2024-07-04 11:20:51 >>>故障排除日志:上一MQTT订单号缓存列表为24070411025779001313
2024-07-04 11:20:51 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 11:20:51 开始打印,排队:63,票券:2407041120423397499701,订单:24070411204233970905,[2024-07-04 11:20:42微信支付10元]
2024-07-04 11:20:53 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407041120423397499701","queue_number":63,"trade_uid":"24070411204233970905"}]}
2024-07-04 11:20:53 >>>故障排除日志:删除未同步下发订单成功24070411204233970905
2024-07-04 11:20:54 >>>故障排除日志:终端同步成功后剩余订单列表


===11:23:06===
2024-07-04 11:23:03 >>>回调事件[910,devices/D0309]
2024-07-04 11:23:03 >>>故障排除日志:上一MQTT订单号缓存列表为24070411204233970905
2024-07-04 11:23:03 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 11:23:03 开始打印,排队:64,票券:2407041122551867403001,订单:24070411225518669641,[2024-07-04 11:22:55支付宝支付10元]


===11:24:06===
2024-07-04 11:23:05 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407041122551867403001","queue_number":64,"trade_uid":"24070411225518669641"}]}
2024-07-04 11:23:05 >>>故障排除日志:删除未同步下发订单成功24070411225518669641
2024-07-04 11:23:05 >>>故障排除日志:终端同步成功后剩余订单列表


===11:30:06===
2024-07-04 11:29:13>>>cash read=9E
2024-07-04 11:29:14>>>cash read=3E


===11:32:07===
2024-07-04 11:31:54>>>cash read=9E
2024-07-04 11:31:56>>>cash read=3E


===11:33:07===
2024-07-04 11:32:52>>>cash read=BF
2024-07-04 11:32:53>>>cash read=3E


===11:35:07===
2024-07-04 11:34:07 >>>回调事件[910,devices/D0309]
2024-07-04 11:34:07 >>>故障排除日志:上一MQTT订单号缓存列表为24070411225518669641
2024-07-04 11:34:07 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 11:34:07 开始打印,排队:65,票券:2407041133576976848601,订单:24070411335769764517,[2024-07-04 11:33:57微信支付10元]
2024-07-04 11:34:09 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407041133576976848601","queue_number":65,"trade_uid":"24070411335769764517"}]}
2024-07-04 11:34:09 >>>故障排除日志:删除未同步下发订单成功24070411335769764517
2024-07-04 11:34:09 >>>故障排除日志:终端同步成功后剩余订单列表
2024-07-04 11:34:23>>>cash read=1F
2024-07-04 11:34:24>>>cash read=3E


===11:45:07===
2024-07-04 11:44:09>>>cash read=9E
2024-07-04 11:44:10>>>cash read=3E
2024-07-04 11:44:18>>>cash read=1F
2024-07-04 11:44:19>>>cash read=3E


===11:48:08===
2024-07-04 11:48:04>>>cash read=9E
2024-07-04 11:48:06>>>cash read=3E


===11:51:08===
2024-07-04 11:50:40 >>>回调事件[910,devices/D0309]
2024-07-04 11:50:40 >>>故障排除日志:上一MQTT订单号缓存列表为24070411335769764517
2024-07-04 11:50:40 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 11:50:40 开始打印,排队:66,票券:2407041150320166421801,订单:24070411503201659180,[2024-07-04 11:50:32支付宝支付10元]
2024-07-04 11:50:42 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407041150320166421801","queue_number":66,"trade_uid":"24070411503201659180"}]}
2024-07-04 11:50:42 >>>故障排除日志:删除未同步下发订单成功24070411503201659180
2024-07-04 11:50:42 >>>故障排除日志:终端同步成功后剩余订单列表
2024-07-04 11:50:52 >>>回调事件[910,devices/D0309]
2024-07-04 11:50:52 >>>故障排除日志:上一MQTT订单号缓存列表为24070411503201659180
2024-07-04 11:50:52 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 11:50:52 开始打印,排队:67,票券:2407041150447217426501,订单:24070411504472168828,[2024-07-04 11:50:44微信支付10元]
2024-07-04 11:50:52 开始打印,排队:68,票券:2407041150447217587202,订单:24070411504472168828,[2024-07-04 11:50:44微信支付10元]
2024-07-04 11:50:52 开始打印,排队:69,票券:2407041150447217649603,订单:24070411504472168828,[2024-07-04 11:50:44微信支付10元]
2024-07-04 11:50:57 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407041150447217426501","queue_number":67,"trade_uid":"24070411504472168828"},{"ticket_no":"2407041150447217587202","queue_number":68,"trade_uid":"24070411504472168828"},{"ticket_no":"2407041150447217649603","queue_number":69,"trade_uid":"24070411504472168828"}]}
2024-07-04 11:50:57 >>>故障排除日志:删除未同步下发订单成功24070411504472168828
2024-07-04 11:50:57 >>>故障排除日志:删除未同步下发订单成功24070411504472168828
2024-07-04 11:50:57 >>>故障排除日志:删除未同步下发订单成功24070411504472168828
2024-07-04 11:50:57 >>>故障排除日志:终端同步成功后剩余订单列表


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


===12:03:08===
2024-07-04 12:02:26>>>cash read=9E
2024-07-04 12:02:27>>>cash read=3E


===12:14:09===
2024-07-04 12:13:56>>>cash read=1F
2024-07-04 12:13:57>>>cash read=3E


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


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


===12:32:11===
2024-07-04 12:31:31>>>cash read=BF
2024-07-04 12:31:33>>>cash read=3E


===12:34:11===
2024-07-04 12:34:00>>>cash read=1F
2024-07-04 12:34:02>>>cash read=3E


===12:37:11===
2024-07-04 12:37:02>>>cash read=1F
2024-07-04 12:37:03>>>cash read=3E


===12:38:11===
2024-07-04 12:37:41 >>>回调事件[910,devices/D0309]
2024-07-04 12:37:41 >>>故障排除日志:上一MQTT订单号缓存列表为24070412232357259320
2024-07-04 12:37:41 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 12:37:41 开始打印,排队:73,票券:2407041237338908644301,订单:24070412373389082843,[2024-07-04 12:37:33微信支付10元]
2024-07-04 12:37:43 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407041237338908644301","queue_number":73,"trade_uid":"24070412373389082843"}]}
2024-07-04 12:37:43 >>>故障排除日志:删除未同步下发订单成功24070412373389082843
2024-07-04 12:37:43 >>>故障排除日志:终端同步成功后剩余订单列表
2024-07-04 12:37:53 >>>回调事件[910,devices/D0309]
2024-07-04 12:37:53 >>>故障排除日志:上一MQTT订单号缓存列表为24070412373389082843
2024-07-04 12:37:54 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 12:37:54 开始打印,排队:74,票券:2407041237415695892501,订单:24070412374156955030,[2024-07-04 12:37:41微信支付10元]
2024-07-04 12:37:56 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407041237415695892501","queue_number":74,"trade_uid":"24070412374156955030"}]}
2024-07-04 12:37:56 >>>故障排除日志:删除未同步下发订单成功24070412374156955030
2024-07-04 12:37:56 >>>故障排除日志:终端同步成功后剩余订单列表


===12:39:11===
2024-07-04 12:38:11>>>cash read=00
2024-07-04 12:38:12>>>cash read=818F42
2024-07-04 12:38:12>>>cash write=02
2024-07-04 12:38:12 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-07-04 12:38:13>>>cash read=10
2024-07-04 12:38:13 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-07-04 12:38:13 >>>开始打印,排队号为75,订单号为2407041238130003092313
2024-07-04 12:38:13>>>订单2407041238130003092313写入成功,剩余空间为1674500,占用RAM为592.4951171875
删除未同步订单2407041238130003092313
2024-07-04 12:38:15>>>订单2407041238130003092313删除成功,剩余空间为1674500,占用RAM为605.0146484375
检测订单目录中>>>
无未同步订单>>>
2024-07-04 12:38:15 >>>当前Ram内存为577.837890625
定时检测未同步订单启用
2024-07-04 12:38:16>>>cash write=0C
2024-07-04 12:38:16>>>cash read=3E


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


===12:43:12===
2024-07-04 12:42:50 >>>回调事件[910,devices/D0309]
2024-07-04 12:42:50 >>>故障排除日志:上一MQTT订单号缓存列表为24070412374156955030
2024-07-04 12:42:50 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 12:42:50 开始打印,排队:76,票券:2407041242436231388501,订单:24070412424362309894,[2024-07-04 12:42:43微信支付10元]
2024-07-04 12:42:52 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407041242436231388501","queue_number":76,"trade_uid":"24070412424362309894"}]}
2024-07-04 12:42:52 >>>故障排除日志:删除未同步下发订单成功24070412424362309894
2024-07-04 12:42:52 >>>故障排除日志:终端同步成功后剩余订单列表
2024-07-04 12:43:08>>>cash read=9E
2024-07-04 12:43:09>>>cash read=3E


===12:46:12===
2024-07-04 12:45:46>>>cash read=9E
2024-07-04 12:45:47>>>cash read=3E


===12:48:12===
2024-07-04 12:47:19 >>>回调事件[910,devices/D0309]
2024-07-04 12:47:19 >>>故障排除日志:上一MQTT订单号缓存列表为24070412424362309894
2024-07-04 12:47:19 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 12:47:19 开始打印,排队:77,票券:2407041247108102446201,订单:24070412471081019852,[2024-07-04 12:47:10支付宝支付10元]
2024-07-04 12:47:21 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407041247108102446201","queue_number":77,"trade_uid":"24070412471081019852"}]}
2024-07-04 12:47:21 >>>故障排除日志:删除未同步下发订单成功24070412471081019852
2024-07-04 12:47:21 >>>故障排除日志:终端同步成功后剩余订单列表


===12:52:12===
2024-07-04 12:51:25 >>>回调事件[910,devices/D0309]
2024-07-04 12:51:25 >>>故障排除日志:上一MQTT订单号缓存列表为24070412471081019852
2024-07-04 12:51:25 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 12:51:25 开始打印,排队:78,票券:2407041251189705779801,订单:24070412511897052624,[2024-07-04 12:51:18支付宝支付10元]
2024-07-04 12:51:27 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407041251189705779801","queue_number":78,"trade_uid":"24070412511897052624"}]}
2024-07-04 12:51:27 >>>故障排除日志:删除未同步下发订单成功24070412511897052624
2024-07-04 12:51:27 >>>故障排除日志:终端同步成功后剩余订单列表


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


===12:58:12===
2024-07-04 12:57:34>>>cash read=BF
2024-07-04 12:57:35>>>cash read=3E


===13:00:12===
2024-07-04 12:59:48>>>cash read=1F
2024-07-04 12:59:49>>>cash read=3E


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


===13:04:13===
2024-07-04 13:03:31>>>cash read=9E
2024-07-04 13:03:32>>>cash read=3E


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


===13:08:13===
2024-07-04 13:07:22>>>cash read=9E
2024-07-04 13:07:23>>>cash read=3E


===13:13:14===
2024-07-04 13:12:39>>>cash read=9E
2024-07-04 13:12:40>>>cash read=3E
2024-07-04 13:12:59 >>>回调事件[910,devices/D0309]
2024-07-04 13:12:59 >>>故障排除日志:上一MQTT订单号缓存列表为24070413045901794220
2024-07-04 13:12:59 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 13:12:59 开始打印,排队:82,票券:2407041312524068838001,订单:24070413125240683457,[2024-07-04 13:12:52支付宝支付10元]
2024-07-04 13:13:01 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407041312524068838001","queue_number":82,"trade_uid":"24070413125240683457"}]}
2024-07-04 13:13:01 >>>故障排除日志:删除未同步下发订单成功24070413125240683457
2024-07-04 13:13:01 >>>故障排除日志:终端同步成功后剩余订单列表


===13:14:14===
2024-07-04 13:13:19>>>cash read=00
2024-07-04 13:13:20>>>cash read=818F43
2024-07-04 13:13:20>>>cash write=02
2024-07-04 13:13:20 >>>回调事件130,cash_status,10022,进钞中...read money=20
2024-07-04 13:13:21>>>cash read=10
2024-07-04 13:13:21 >>>回调事件130,20,10023,finish Money=20,进钞完成
2024-07-04 13:13:21 >>>开始打印,排队号为83,订单号为2407041313210003099110
2024-07-04 13:13:21 >>>开始打印,排队号为84,订单号为2407041313210003099110
2024-07-04 13:13:21>>>订单2407041313210003099110写入成功,剩余空间为1673500,占用RAM为598.9990234375
删除未同步订单2407041313210003099110
2024-07-04 13:13:25>>>订单2407041313210003099110删除成功,剩余空间为1674500,占用RAM为582.373046875
检测订单目录中>>>
无未同步订单>>>
2024-07-04 13:13:25 >>>当前Ram内存为578.357421875
定时检测未同步订单启用
2024-07-04 13:13:26>>>cash write=0C
2024-07-04 13:13:26>>>cash read=3E


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


===13:16:16===
2024-07-04 13:15:15 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407041315046744142501","queue_number":85,"trade_uid":"24070413150467436450"}]}
2024-07-04 13:15:15 >>>故障排除日志:删除未同步下发订单成功24070413150467436450
2024-07-04 13:15:15 >>>故障排除日志:终端同步成功后剩余订单列表


===13:22:16===
2024-07-04 13:21:19>>>cash read=1F
2024-07-04 13:21:20>>>cash read=3E


===13:23:16===
2024-07-04 13:22:47>>>cash read=9E
2024-07-04 13:22:48>>>cash read=3E


===13:24:17===
2024-07-04 13:23:31>>>cash read=00
2024-07-04 13:23:32>>>cash read=818F42
2024-07-04 13:23:32>>>cash write=02
2024-07-04 13:23:32 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-07-04 13:23:33>>>cash read=10
2024-07-04 13:23:33 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-07-04 13:23:33 >>>开始打印,排队号为86,订单号为2407041323330003098296
2024-07-04 13:23:33>>>订单2407041323330003098296写入成功,剩余空间为1674500,占用RAM为593.65234375
删除未同步订单2407041323330003098296
2024-07-04 13:23:35>>>订单2407041323330003098296删除成功,剩余空间为1674500,占用RAM为605.8818359375
检测订单目录中>>>
无未同步订单>>>
2024-07-04 13:23:35 >>>当前Ram内存为578.54296875
定时检测未同步订单启用
2024-07-04 13:23:36>>>cash write=0C
2024-07-04 13:23:36>>>cash read=3E
2024-07-04 13:24:01>>>cash read=9E
2024-07-04 13:24:02>>>cash read=3E


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


===13:29:17===
2024-07-04 13:28:44>>>cash read=9E
2024-07-04 13:28:45>>>cash read=3E


===13:34:17===
2024-07-04 13:33:32>>>cash read=1F
2024-07-04 13:33:33>>>cash read=3E


===13:35:18===
2024-07-04 13:34:17 >>>回调事件[910,devices/D0309]
2024-07-04 13:34:17 >>>故障排除日志:上一MQTT订单号缓存列表为24070413150467436450
2024-07-04 13:34:17 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 13:34:17 开始打印,排队:87,票券:2407041334099558935001,订单:24070413340995585186,[2024-07-04 13:34:09微信支付10元]
2024-07-04 13:34:19 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407041334099558935001","queue_number":87,"trade_uid":"24070413340995585186"}]}
2024-07-04 13:34:19 >>>故障排除日志:删除未同步下发订单成功24070413340995585186
2024-07-04 13:34:19 >>>故障排除日志:终端同步成功后剩余订单列表
2024-07-04 13:34:43 >>>回调事件[910,devices/D0309]
2024-07-04 13:34:43 >>>故障排除日志:上一MQTT订单号缓存列表为24070413340995585186
2024-07-04 13:34:43 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 13:34:43 开始打印,排队:88,票券:2407041334355129872701,订单:24070413343551293987,[2024-07-04 13:34:35微信支付10元]
2024-07-04 13:34:43 开始打印,排队:89,票券:2407041334355130045002,订单:24070413343551293987,[2024-07-04 13:34:35微信支付10元]
2024-07-04 13:34:46 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407041334355129872701","queue_number":88,"trade_uid":"24070413343551293987"},{"ticket_no":"2407041334355130045002","queue_number":89,"trade_uid":"24070413343551293987"}]}
2024-07-04 13:34:46 >>>故障排除日志:删除未同步下发订单成功24070413343551293987
2024-07-04 13:34:46 >>>故障排除日志:删除未同步下发订单成功24070413343551293987
2024-07-04 13:34:46 >>>故障排除日志:终端同步成功后剩余订单列表


===13:40:18===
2024-07-04 13:39:56 >>>回调事件[910,devices/D0309]
2024-07-04 13:39:56 >>>故障排除日志:上一MQTT订单号缓存列表为24070413343551293987|24070413343551293987
2024-07-04 13:39:56 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 13:39:56 开始打印,排队:90,票券:2407041339509745657001,订单:24070413395097452065,[2024-07-04 13:39:50微信支付10元]
2024-07-04 13:39:58 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407041339509745657001","queue_number":90,"trade_uid":"24070413395097452065"}]}
2024-07-04 13:39:58 >>>故障排除日志:删除未同步下发订单成功24070413395097452065
2024-07-04 13:39:59 >>>故障排除日志:终端同步成功后剩余订单列表


===13:43:18===
2024-07-04 13:43:15 >>>回调事件[910,devices/D0309]
2024-07-04 13:43:15 >>>故障排除日志:上一MQTT订单号缓存列表为24070413395097452065
2024-07-04 13:43:15 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 13:43:15 开始打印,排队:91,票券:2407041343087302318601,订单:24070413430873019191,[2024-07-04 13:43:08微信支付10元]


===13:44:18===
2024-07-04 13:43:17 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407041343087302318601","queue_number":91,"trade_uid":"24070413430873019191"}]}
2024-07-04 13:43:17 >>>故障排除日志:删除未同步下发订单成功24070413430873019191
2024-07-04 13:43:17 >>>故障排除日志:终端同步成功后剩余订单列表


===13:48:18===
2024-07-04 13:48:09>>>cash read=1F
2024-07-04 13:48:10>>>cash read=3E


===13:51:19===
2024-07-04 13:50:35>>>cash read=9E
2024-07-04 13:50:36>>>cash read=3E
2024-07-04 13:50:38>>>cash read=9E
2024-07-04 13:50:39>>>cash read=3E


===13:53:19===
2024-07-04 13:52:37>>>cash read=9E
2024-07-04 13:52:38>>>cash read=3E


===13:54:19===
2024-07-04 13:53:41>>>cash read=1F
2024-07-04 13:53:42>>>cash read=3E


===13:57:19===
2024-07-04 13:57:06>>>cash read=00
2024-07-04 13:57:07>>>cash read=818F43
2024-07-04 13:57:07>>>cash write=02
2024-07-04 13:57:07 >>>回调事件130,cash_status,10022,进钞中...read money=20
2024-07-04 13:57:07>>>cash read=10
2024-07-04 13:57:07 >>>回调事件130,20,10023,finish Money=20,进钞完成
2024-07-04 13:57:07 >>>开始打印,排队号为92,订单号为2407041357070003092193
2024-07-04 13:57:07 >>>开始打印,排队号为93,订单号为2407041357070003092193
2024-07-04 13:57:08>>>订单2407041357070003092193写入成功,剩余空间为1673500,占用RAM为599.76953125
删除未同步订单2407041357070003092193
2024-07-04 13:57:11>>>订单2407041357070003092193删除成功,剩余空间为1674500,占用RAM为619.267578125
检测订单目录中>>>
无未同步订单>>>
2024-07-04 13:57:11 >>>当前Ram内存为579.619140625
定时检测未同步订单启用
2024-07-04 13:57:12>>>cash write=0C
2024-07-04 13:57:12>>>cash read=3E


===13:58:20===
2024-07-04 13:57:49>>>cash read=9E
2024-07-04 13:57:52>>>cash read=3E
定时检测未同步订单关闭
检测订单目录中>>>
无未同步订单>>>


===14:03:20===
2024-07-04 14:03:03 >>>回调事件[910,devices/D0309]
2024-07-04 14:03:03 >>>故障排除日志:上一MQTT订单号缓存列表为24070413430873019191
2024-07-04 14:03:03 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 14:03:03 开始打印,排队:94,票券:2407041402554913671801,订单:24070414025549133004,[2024-07-04 14:02:55支付宝支付10元]
2024-07-04 14:03:05 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407041402554913671801","queue_number":94,"trade_uid":"24070414025549133004"}]}
2024-07-04 14:03:05 >>>故障排除日志:删除未同步下发订单成功24070414025549133004
2024-07-04 14:03:05 >>>故障排除日志:终端同步成功后剩余订单列表


===14:04:20===
2024-07-04 14:03:25>>>cash read=9E
2024-07-04 14:03:26>>>cash read=3E


===14:05:20===
2024-07-04 14:04:52>>>cash read=9E
2024-07-04 14:04:53>>>cash read=3E


===14:07:21===
2024-07-04 14:06:55 >>>回调事件[910,devices/D0309]
2024-07-04 14:06:56 >>>故障排除日志:上一MQTT订单号缓存列表为24070414025549133004
2024-07-04 14:06:56 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 14:06:56 开始打印,排队:95,票券:2407041406481743363201,订单:24070414064817429874,[2024-07-04 14:06:48微信支付10元]
2024-07-04 14:06:57 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407041406481743363201","queue_number":95,"trade_uid":"24070414064817429874"}]}
2024-07-04 14:06:57 >>>故障排除日志:删除未同步下发订单成功24070414064817429874
2024-07-04 14:06:58 >>>故障排除日志:终端同步成功后剩余订单列表


===14:08:21===
2024-07-04 14:07:35 >>>回调事件[910,devices/D0309]
2024-07-04 14:07:35 >>>故障排除日志:上一MQTT订单号缓存列表为24070414064817429874
2024-07-04 14:07:35 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 14:07:35 开始打印,排队:96,票券:2407041407275014041201,订单:24070414072750135796,[2024-07-04 14:07:27微信支付10元]
2024-07-04 14:07:37 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407041407275014041201","queue_number":96,"trade_uid":"24070414072750135796"}]}
2024-07-04 14:07:37 >>>故障排除日志:删除未同步下发订单成功24070414072750135796
2024-07-04 14:07:37 >>>故障排除日志:终端同步成功后剩余订单列表


===14:12:21===
2024-07-04 14:11:26>>>cash read=BF
2024-07-04 14:11:27>>>cash read=3E
2024-07-04 14:12:15>>>cash read=1F
2024-07-04 14:12:16>>>cash read=3E


===14:13:21===
2024-07-04 14:12:32>>>cash read=00
2024-07-04 14:12:32>>>cash read=818F43
2024-07-04 14:12:32>>>cash write=02
2024-07-04 14:12:32 >>>回调事件130,cash_status,10022,进钞中...read money=20
2024-07-04 14:12:33>>>cash read=10
2024-07-04 14:12:33 >>>回调事件130,20,10023,finish Money=20,进钞完成
2024-07-04 14:12:33 >>>开始打印,排队号为97,订单号为2407041412330003094311
2024-07-04 14:12:33 >>>开始打印,排队号为98,订单号为2407041412330003094311
2024-07-04 14:12:33>>>订单2407041412330003094311写入成功,剩余空间为1673500,占用RAM为600.1630859375
删除未同步订单2407041412330003094311
2024-07-04 14:12:37>>>订单2407041412330003094311删除成功,剩余空间为1674500,占用RAM为621.16015625
检测订单目录中>>>
无未同步订单>>>
2024-07-04 14:12:37 >>>当前Ram内存为581.462890625
定时检测未同步订单启用
2024-07-04 14:12:38>>>cash write=0C
2024-07-04 14:12:38>>>cash read=3E


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


===14:15:22===
2024-07-04 14:15:03>>>cash read=9E
2024-07-04 14:15:04>>>cash read=3E


===14:16:22===
2024-07-04 14:15:43>>>cash read=00
2024-07-04 14:15:43>>>cash read=818F42
2024-07-04 14:15:43>>>cash write=02
2024-07-04 14:15:43 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-07-04 14:15:43>>>cash read=10
2024-07-04 14:15:43 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-07-04 14:15:43 >>>开始打印,排队号为99,订单号为2407041415430003092007
2024-07-04 14:15:44>>>订单2407041415430003092007写入成功,剩余空间为1674500,占用RAM为595.4921875
删除未同步订单2407041415430003092007
2024-07-04 14:15:46>>>订单2407041415430003092007删除成功,剩余空间为1674500,占用RAM为609.197265625
检测订单目录中>>>
无未同步订单>>>
2024-07-04 14:15:46 >>>当前Ram内存为580.3818359375
定时检测未同步订单启用
2024-07-04 14:15:47>>>cash write=0C
2024-07-04 14:15:47>>>cash read=3E


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


===14:24:23===
2024-07-04 14:24:22>>>cash read=9E


===14:25:23===
2024-07-04 14:24:23>>>cash read=3E
2024-07-04 14:24:54>>>cash read=9E
2024-07-04 14:24:56>>>cash read=3E


===14:37:23===
2024-07-04 14:37:11 >>>回调事件[910,devices/D0309]
2024-07-04 14:37:11 >>>故障排除日志:上一MQTT订单号缓存列表为24070414072750135796
2024-07-04 14:37:11 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 14:37:11 开始打印,排队:100,票券:2407041437034207651901,订单:24070414370342071636,[2024-07-04 14:37:03支付宝支付10元]
2024-07-04 14:37:13 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407041437034207651901","queue_number":100,"trade_uid":"24070414370342071636"}]}
2024-07-04 14:37:13 >>>故障排除日志:删除未同步下发订单成功24070414370342071636
2024-07-04 14:37:13 >>>故障排除日志:终端同步成功后剩余订单列表
2024-07-04 14:37:19>>>cash read=BF
2024-07-04 14:37:20>>>cash read=3E


===14:39:23===
2024-07-04 14:38:30>>>cash read=9E
2024-07-04 14:38:32>>>cash read=3E


===14:40:23===
2024-07-04 14:39:25>>>cash read=9E
2024-07-04 14:39:27>>>cash read=3E
2024-07-04 14:39:52>>>cash read=9E
2024-07-04 14:39:53>>>cash read=3E


===14:42:24===
2024-07-04 14:41:34>>>cash read=00
2024-07-04 14:41:35>>>cash read=29
2024-07-04 14:41:35 >>>回调事件130,cash_status,20029,退钞中
2024-07-04 14:41:36>>>cash read=2F29
2024-07-04 14:41:38>>>cash read=3E


===14:44:24===
2024-07-04 14:43:56 >>>回调事件[910,devices/D0309]
2024-07-04 14:43:56 >>>故障排除日志:上一MQTT订单号缓存列表为24070414370342071636
2024-07-04 14:43:56 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 14:43:56 开始打印,排队:101,票券:2407041443505547100801,订单:24070414435055466781,[2024-07-04 14:43:50支付宝支付10元]
2024-07-04 14:43:58 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407041443505547100801","queue_number":101,"trade_uid":"24070414435055466781"}]}
2024-07-04 14:43:58 >>>故障排除日志:删除未同步下发订单成功24070414435055466781
2024-07-04 14:43:58 >>>故障排除日志:终端同步成功后剩余订单列表


===14:45:24===
2024-07-04 14:44:35>>>cash read=BF
2024-07-04 14:44:36>>>cash read=3E


===14:50:24===
2024-07-04 14:49:47>>>cash read=00
2024-07-04 14:49:47>>>cash read=818F42
2024-07-04 14:49:47>>>cash write=02
2024-07-04 14:49:47 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-07-04 14:49:48>>>cash read=10
2024-07-04 14:49:48 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-07-04 14:49:48 >>>开始打印,排队号为102,订单号为2407041449480003096331
2024-07-04 14:49:48>>>订单2407041449480003096331写入成功,剩余空间为1674500,占用RAM为595.1806640625
删除未同步订单2407041449480003096331
2024-07-04 14:49:50>>>订单2407041449480003096331删除成功,剩余空间为1674500,占用RAM为607.642578125
检测订单目录中>>>
无未同步订单>>>
2024-07-04 14:49:50 >>>当前Ram内存为578.71484375
定时检测未同步订单启用
2024-07-04 14:49:51>>>cash write=0C
2024-07-04 14:49:51>>>cash read=3E


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


===14:55:25===
2024-07-04 14:54:33>>>cash read=9E
2024-07-04 14:54:34>>>cash read=3E


===14:57:25===
2024-07-04 14:56:46>>>cash read=BF
2024-07-04 14:56:47>>>cash read=3E


===15:02:25===
2024-07-04 15:01:44 >>>回调事件[910,devices/D0309]
2024-07-04 15:01:44 >>>故障排除日志:上一MQTT订单号缓存列表为24070414435055466781
2024-07-04 15:01:44 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 15:01:44 开始打印,排队:103,票券:2407041501370458332601,订单:24070415013704579386,[2024-07-04 15:01:37支付宝支付10元]
2024-07-04 15:01:46 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407041501370458332601","queue_number":103,"trade_uid":"24070415013704579386"}]}
2024-07-04 15:01:46 >>>故障排除日志:删除未同步下发订单成功24070415013704579386
2024-07-04 15:01:46 >>>故障排除日志:终端同步成功后剩余订单列表
2024-07-04 15:02:17>>>cash read=9E
2024-07-04 15:02:19>>>cash read=3E


===15:06:25===
2024-07-04 15:05:39>>>cash read=9E
2024-07-04 15:05:40>>>cash read=3E


===15:07:25===
2024-07-04 15:06:36>>>cash read=BF
2024-07-04 15:06:37>>>cash read=3E


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


===15:11:25===
2024-07-04 15:10:31>>>cash read=BF
2024-07-04 15:10:32>>>cash read=3E


===15:15:26===
2024-07-04 15:14:51>>>cash read=9E
2024-07-04 15:14:52>>>cash read=3E
2024-07-04 15:15:21>>>cash read=9E
2024-07-04 15:15:22>>>cash read=3E


===15:22:26===
2024-07-04 15:21:39 >>>回调事件[910,devices/D0309]
2024-07-04 15:21:39 >>>故障排除日志:上一MQTT订单号缓存列表为24070415091962089096
2024-07-04 15:21:39 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 15:21:39 开始打印,排队:105,票券:2407041521284930105801,订单:24070415212849296659,[2024-07-04 15:21:28支付宝支付10元]
2024-07-04 15:21:41 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407041521284930105801","queue_number":105,"trade_uid":"24070415212849296659"}]}
2024-07-04 15:21:41 >>>故障排除日志:删除未同步下发订单成功24070415212849296659
2024-07-04 15:21:41 >>>故障排除日志:终端同步成功后剩余订单列表


===15:23:26===
2024-07-04 15:22:30>>>cash read=9E
2024-07-04 15:22:31>>>cash read=3E


===15:25:26===
2024-07-04 15:25:06>>>cash read=BF
2024-07-04 15:25:07>>>cash read=3E


===15:30:27===
2024-07-04 15:30:05 >>>回调事件[910,devices/D0309]
2024-07-04 15:30:05 >>>故障排除日志:上一MQTT订单号缓存列表为24070415212849296659
2024-07-04 15:30:05 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 15:30:05 开始打印,排队:106,票券:2407041529591323524801,订单:24070415295913227928,[2024-07-04 15:29:59微信支付10元]
2024-07-04 15:30:07 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407041529591323524801","queue_number":106,"trade_uid":"24070415295913227928"}]}
2024-07-04 15:30:07 >>>故障排除日志:删除未同步下发订单成功24070415295913227928
2024-07-04 15:30:07 >>>故障排除日志:终端同步成功后剩余订单列表


===15:34:27===
2024-07-04 15:33:39 >>>回调事件[910,devices/D0309]
2024-07-04 15:33:39 >>>故障排除日志:上一MQTT订单号缓存列表为24070415295913227928
2024-07-04 15:33:39 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 15:33:39 开始打印,排队:107,票券:2407041533316935987501,订单:24070415333169355136,[2024-07-04 15:33:31支付宝支付10元]
2024-07-04 15:33:41 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407041533316935987501","queue_number":107,"trade_uid":"24070415333169355136"}]}
2024-07-04 15:33:41 >>>故障排除日志:删除未同步下发订单成功24070415333169355136
2024-07-04 15:33:41 >>>故障排除日志:终端同步成功后剩余订单列表


===15:35:27===
2024-07-04 15:35:07 >>>回调事件[910,devices/D0309]
2024-07-04 15:35:08 >>>故障排除日志:上一MQTT订单号缓存列表为24070415333169355136
2024-07-04 15:35:08 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 15:35:08 开始打印,排队:108,票券:2407041535018462970901,订单:24070415350184625740,[2024-07-04 15:35:01支付宝支付10元]
2024-07-04 15:35:09 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407041535018462970901","queue_number":108,"trade_uid":"24070415350184625740"}]}
2024-07-04 15:35:09 >>>故障排除日志:删除未同步下发订单成功24070415350184625740
2024-07-04 15:35:10 >>>故障排除日志:终端同步成功后剩余订单列表


===15:36:27===
2024-07-04 15:36:19>>>cash read=BF
2024-07-04 15:36:20>>>cash read=3E


===15:40:27===
2024-07-04 15:39:56>>>cash read=9E
2024-07-04 15:39:57>>>cash read=3E


===15:50:28===
2024-07-04 15:50:04>>>cash read=00
2024-07-04 15:50:05>>>cash read=818F43
2024-07-04 15:50:05>>>cash write=02
2024-07-04 15:50:05 >>>回调事件130,cash_status,10022,进钞中...read money=20
2024-07-04 15:50:05>>>cash read=10
2024-07-04 15:50:05 >>>回调事件130,20,10023,finish Money=20,进钞完成
2024-07-04 15:50:05 >>>开始打印,排队号为109,订单号为2407041550050003097780
2024-07-04 15:50:06 >>>开始打印,排队号为110,订单号为2407041550050003097780
2024-07-04 15:50:06>>>订单2407041550050003097780写入成功,剩余空间为1673500,占用RAM为600.2109375
2024-07-04 15:50:09>>>cash read=818F42
2024-07-04 15:50:09 >>>回调事件130,cash_status,10022,进钞中...read money=10
删除未同步订单2407041550050003097780
2024-07-04 15:50:10>>>订单2407041550050003097780删除成功,剩余空间为1674500,占用RAM为593.1943359375
检测订单目录中>>>
无未同步订单>>>
2024-07-04 15:50:10 >>>当前Ram内存为579.0625
定时检测未同步订单启用
2024-07-04 15:50:10>>>cash read=10
2024-07-04 15:50:10 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-07-04 15:50:10 >>>开始打印,排队号为111,订单号为2407041550100003091710
定时检测未同步订单关闭
2024-07-04 15:50:10>>>订单2407041550100003091710写入成功,剩余空间为1673000,占用RAM为593.6962890625
2024-07-04 15:50:12>>>cash read=818F42
2024-07-04 15:50:12 >>>回调事件130,cash_status,10022,进钞中...read money=10
删除未同步订单2407041550100003091710
2024-07-04 15:50:13>>>订单2407041550100003091710删除成功,剩余空间为1673500,占用RAM为594.8828125
检测订单目录中>>>
无未同步订单>>>
2024-07-04 15:50:13 >>>当前Ram内存为579.9072265625
定时检测未同步订单启用
2024-07-04 15:50:13>>>cash read=10
2024-07-04 15:50:13 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-07-04 15:50:13 >>>开始打印,排队号为112,订单号为2407041550130003097079
定时检测未同步订单关闭
2024-07-04 15:50:13>>>订单2407041550130003097079写入成功,剩余空间为1672000,占用RAM为602.0234375
删除未同步订单2407041550130003097079
2024-07-04 15:50:16>>>订单2407041550130003097079删除成功,剩余空间为1673000,占用RAM为612.76953125
检测订单目录中>>>
无未同步订单>>>
2024-07-04 15:50:16 >>>当前Ram内存为581.4453125
定时检测未同步订单启用
2024-07-04 15:50:17>>>cash write=0C
2024-07-04 15:50:18>>>cash read=3E


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


===16:00:28===
2024-07-04 16:00:15>>>cash read=9E
2024-07-04 16:00:16>>>cash read=3E


===16:03:29===
2024-07-04 16:02:45>>>cash read=1F
2024-07-04 16:02:46>>>cash read=3E


===16:10:29===
2024-07-04 16:09:46 >>>回调事件[910,devices/D0309]
2024-07-04 16:09:46 >>>故障排除日志:上一MQTT订单号缓存列表为24070415350184625740
2024-07-04 16:09:46 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 16:09:46 开始打印,排队:113,票券:2407041609366647619601,订单:24070416093666472290,[2024-07-04 16:09:36支付宝支付10元]
2024-07-04 16:09:48 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407041609366647619601","queue_number":113,"trade_uid":"24070416093666472290"}]}
2024-07-04 16:09:48 >>>故障排除日志:删除未同步下发订单成功24070416093666472290
2024-07-04 16:09:48 >>>故障排除日志:终端同步成功后剩余订单列表


===16:11:29===
2024-07-04 16:10:39>>>cash read=9E
2024-07-04 16:10:40>>>cash read=3E


===16:15:29===
2024-07-04 16:14:59 >>>回调事件[910,devices/D0309]
2024-07-04 16:14:59 >>>故障排除日志:上一MQTT订单号缓存列表为24070416093666472290
2024-07-04 16:14:59 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 16:14:59 开始打印,排队:114,票券:2407041614512603947801,订单:24070416145126034691,[2024-07-04 16:14:51微信支付10元]
2024-07-04 16:15:01 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407041614512603947801","queue_number":114,"trade_uid":"24070416145126034691"}]}
2024-07-04 16:15:01 >>>故障排除日志:删除未同步下发订单成功24070416145126034691
2024-07-04 16:15:01 >>>故障排除日志:终端同步成功后剩余订单列表


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


===16:17:30===
2024-07-04 16:16:37>>>cash read=9E
2024-07-04 16:16:38>>>cash read=3E
2024-07-04 16:17:17 >>>回调事件[910,devices/D0309]
2024-07-04 16:17:17 >>>故障排除日志:上一MQTT订单号缓存列表为24070416153568593056
2024-07-04 16:17:17 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 16:17:17 开始打印,排队:116,票券:2407041617072183648401,订单:24070416170721830126,[2024-07-04 16:17:07支付宝支付10元]
2024-07-04 16:17:19 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407041617072183648401","queue_number":116,"trade_uid":"24070416170721830126"}]}
2024-07-04 16:17:19 >>>故障排除日志:删除未同步下发订单成功24070416170721830126
2024-07-04 16:17:19 >>>故障排除日志:终端同步成功后剩余订单列表


===16:19:30===
2024-07-04 16:18:34>>>cash read=0A
2024-07-04 16:18:35>>>cash read=3E


===16:25:30===
2024-07-04 16:24:49>>>cash read=9E
2024-07-04 16:24:50>>>cash read=3E


===16:30:31===
2024-07-04 16:29:50>>>cash read=9E
2024-07-04 16:29:51>>>cash read=3E


===16:32:31===
2024-07-04 16:31:31>>>cash read=01
2024-07-04 16:31:32>>>cash read=3E
2024-07-04 16:31:40 >>>回调事件[910,devices/D0309]
2024-07-04 16:31:40 >>>故障排除日志:上一MQTT订单号缓存列表为24070416170721830126
2024-07-04 16:31:40 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 16:31:40 开始打印,排队:117,票券:2407041631333566245201,订单:24070416313335658164,[2024-07-04 16:31:33微信支付10元]
2024-07-04 16:31:42 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407041631333566245201","queue_number":117,"trade_uid":"24070416313335658164"}]}
2024-07-04 16:31:42 >>>故障排除日志:删除未同步下发订单成功24070416313335658164
2024-07-04 16:31:42 >>>故障排除日志:终端同步成功后剩余订单列表
2024-07-04 16:32:09>>>cash read=292F29
2024-07-04 16:32:09 >>>回调事件130,cash_status,20029,退钞中
2024-07-04 16:32:10>>>cash read=01
2024-07-04 16:32:11>>>cash read=2F
2024-07-04 16:32:12>>>cash read=3E
2024-07-04 16:32:14>>>cash read=00
2024-07-04 16:32:15>>>cash read=292F29
2024-07-04 16:32:15 >>>回调事件130,cash_status,20029,退钞中
2024-07-04 16:32:17>>>cash read=3E
2024-07-04 16:32:20>>>cash read=29
2024-07-04 16:32:20 >>>回调事件130,cash_status,20029,退钞中
2024-07-04 16:32:21>>>cash read=2F29
2024-07-04 16:32:22>>>cash read=3E


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


===16:34:32===
2024-07-04 16:34:14>>>cash read=0A
2024-07-04 16:34:15>>>cash read=3E


===16:38:32===
2024-07-04 16:38:18 >>>回调事件[910,devices/D0309]
2024-07-04 16:38:18 >>>故障排除日志:上一MQTT订单号缓存列表为24070416325370997646
2024-07-04 16:38:18 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 16:38:18 开始打印,排队:119,票券:2407041638129240828001,订单:24070416381292404578,[2024-07-04 16:38:12支付宝支付10元]
2024-07-04 16:38:20 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407041638129240828001","queue_number":119,"trade_uid":"24070416381292404578"}]}
2024-07-04 16:38:20 >>>故障排除日志:删除未同步下发订单成功24070416381292404578
2024-07-04 16:38:20 >>>故障排除日志:终端同步成功后剩余订单列表


===16:47:32===
2024-07-04 16:46:59>>>cash read=1F
2024-07-04 16:47:00>>>cash read=3E


===16:49:32===
2024-07-04 16:49:23 >>>回调事件[910,devices/D0309]
2024-07-04 16:49:23 >>>故障排除日志:上一MQTT订单号缓存列表为24070416381292404578
2024-07-04 16:49:23 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 16:49:23 开始打印,排队:120,票券:2407041649057909644201,订单:24070416490579091792,[2024-07-04 16:49:05支付宝支付10元]
2024-07-04 16:49:25 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407041649057909644201","queue_number":120,"trade_uid":"24070416490579091792"}]}
2024-07-04 16:49:25 >>>故障排除日志:删除未同步下发订单成功24070416490579091792
2024-07-04 16:49:25 >>>故障排除日志:终端同步成功后剩余订单列表


===16:54:32===
2024-07-04 16:54:02>>>cash read=29
2024-07-04 16:54:02 >>>回调事件130,cash_status,20029,退钞中
2024-07-04 16:54:03>>>cash read=00
2024-07-04 16:54:04>>>cash read=818F42
2024-07-04 16:54:04>>>cash write=02
2024-07-04 16:54:05 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-07-04 16:54:05>>>cash read=10
2024-07-04 16:54:05 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-07-04 16:54:05 >>>开始打印,排队号为121,订单号为2407041654050003094241
2024-07-04 16:54:05>>>订单2407041654050003094241写入成功,剩余空间为1673500,占用RAM为595.4130859375
删除未同步订单2407041654050003094241
2024-07-04 16:54:07>>>订单2407041654050003094241删除成功,剩余空间为1674500,占用RAM为607.8701171875
检测订单目录中>>>
无未同步订单>>>
2024-07-04 16:54:08 >>>当前Ram内存为578.8427734375
定时检测未同步订单启用
2024-07-04 16:54:08>>>cash write=0C
2024-07-04 16:54:08>>>cash read=3E


===16:55:32===
2024-07-04 16:55:00>>>cash read=BF
2024-07-04 16:55:01>>>cash read=3E
定时检测未同步订单关闭
检测订单目录中>>>
无未同步订单>>>


===16:58:32===
2024-07-04 16:58:13 >>>回调事件[910,devices/D0309]
2024-07-04 16:58:13 >>>故障排除日志:上一MQTT订单号缓存列表为24070416490579091792
2024-07-04 16:58:13 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 16:58:13 开始打印,排队:122,票券:2407041658057290902301,订单:24070416580572903206,[2024-07-04 16:58:05微信支付10元]
2024-07-04 16:58:15 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407041658057290902301","queue_number":122,"trade_uid":"24070416580572903206"}]}
2024-07-04 16:58:15 >>>故障排除日志:删除未同步下发订单成功24070416580572903206
2024-07-04 16:58:15 >>>故障排除日志:终端同步成功后剩余订单列表
2024-07-04 16:58:26>>>cash read=9E
2024-07-04 16:58:27>>>cash read=3E


===17:00:33===
2024-07-04 17:00:17 >>>回调事件[910,devices/D0309]
2024-07-04 17:00:17 >>>故障排除日志:上一MQTT订单号缓存列表为24070416580572903206
2024-07-04 17:00:17 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 17:00:17 开始打印,排队:123,票券:2407041700110119454001,订单:24070417001101190353,[2024-07-04 17:00:11支付宝支付10元]
2024-07-04 17:00:19 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407041700110119454001","queue_number":123,"trade_uid":"24070417001101190353"}]}
2024-07-04 17:00:19 >>>故障排除日志:删除未同步下发订单成功24070417001101190353
2024-07-04 17:00:20 >>>故障排除日志:终端同步成功后剩余订单列表


===17:02:33===
2024-07-04 17:02:29>>>cash read=9E
2024-07-04 17:02:30>>>cash read=3E


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


===17:12:33===
2024-07-04 17:11:41>>>cash read=9E
2024-07-04 17:11:42>>>cash read=3E
2024-07-04 17:12:12 >>>回调事件[910,devices/D0309]
2024-07-04 17:12:12 >>>故障排除日志:上一MQTT订单号缓存列表为24070417073074316092
2024-07-04 17:12:12 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 17:12:12 开始打印,排队:125,票券:2407041712040550394301,订单:24070417120405498196,[2024-07-04 17:12:04微信支付10元]
2024-07-04 17:12:14 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407041712040550394301","queue_number":125,"trade_uid":"24070417120405498196"}]}
2024-07-04 17:12:14 >>>故障排除日志:删除未同步下发订单成功24070417120405498196
2024-07-04 17:12:14 >>>故障排除日志:终端同步成功后剩余订单列表


===17:13:34===
2024-07-04 17:13:25>>>cash read=BF
2024-07-04 17:13:26>>>cash read=3E


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


===17:16:34===
2024-07-04 17:16:20>>>cash read=9E
2024-07-04 17:16:21>>>cash read=3E


===17:19:34===
2024-07-04 17:19:25>>>cash read=9E
2024-07-04 17:19:26>>>cash read=3E


===17:20:34===
2024-07-04 17:19:46>>>cash read=9E
2024-07-04 17:19:47>>>cash read=3E


===17:23:35===
2024-07-04 17:23:32 >>>回调事件[910,devices/D0309]
2024-07-04 17:23:32 >>>故障排除日志:上一MQTT订单号缓存列表为24070417142770858692
2024-07-04 17:23:32 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 17:23:32 开始打印,排队:127,票券:2407041723236905311901,订单:24070417232369048264,[2024-07-04 17:23:23微信支付10元]


===17:24:35===
2024-07-04 17:23:34 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407041723236905311901","queue_number":127,"trade_uid":"24070417232369048264"}]}
2024-07-04 17:23:34 >>>故障排除日志:删除未同步下发订单成功24070417232369048264
2024-07-04 17:23:34 >>>故障排除日志:终端同步成功后剩余订单列表
2024-07-04 17:24:20 >>>回调事件[910,devices/D0309]
2024-07-04 17:24:20 >>>故障排除日志:上一MQTT订单号缓存列表为24070417232369048264
2024-07-04 17:24:20 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 17:24:20 开始打印,排队:128,票券:2407041724123304650801,订单:24070417241233040129,[2024-07-04 17:24:12支付宝支付10元]
2024-07-04 17:24:22 >>>回调事件[910,devices/D0309]
2024-07-04 17:24:22 >>>故障排除日志:上一MQTT订单号缓存列表为24070417241233040129
2024-07-04 17:24:22 >>>故障排除日志:终端未同步成功订单列表012824070417241233040129
已接收过此消息,票券号为2407041724123304650801,排队号为128
2024-07-04 17:24:22 开始打印,排队:129,票券:2407041724135533840901,订单:24070417241355334963,[2024-07-04 17:24:13支付宝支付10元]
2024-07-04 17:24:24 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407041724123304650801","queue_number":128,"trade_uid":"24070417241233040129"}]}
2024-07-04 17:24:24 >>>故障排除日志:删除未同步下发订单成功24070417241233040129
2024-07-04 17:24:24 >>>故障排除日志:终端同步成功后剩余订单列表012924070417241355334963
2024-07-04 17:24:24 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407041724123304650801","queue_number":128,"trade_uid":"24070417241233040129"},{"ticket_no":"2407041724135533840901","queue_number":129,"trade_uid":"24070417241355334963"}]}
2024-07-04 17:24:24 >>>故障排除日志:删除未同步下发订单成功24070417241355334963
2024-07-04 17:24:24 >>>故障排除日志:终端同步成功后剩余订单列表


===17:32:35===
2024-07-04 17:31:58 >>>回调事件[910,devices/D0309]
2024-07-04 17:31:58 >>>故障排除日志:上一MQTT订单号缓存列表为24070417241233040129|24070417241355334963
2024-07-04 17:31:58 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 17:31:58 开始打印,排队:130,票券:2407041731501333539501,订单:24070417315013331326,[2024-07-04 17:31:50支付宝支付10元]
2024-07-04 17:32:00 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407041731501333539501","queue_number":130,"trade_uid":"24070417315013331326"}]}
2024-07-04 17:32:00 >>>故障排除日志:删除未同步下发订单成功24070417315013331326
2024-07-04 17:32:00 >>>故障排除日志:终端同步成功后剩余订单列表


===17:33:36===
2024-07-04 17:33:31>>>cash read=9E
2024-07-04 17:33:32>>>cash read=3E


===17:40:36===
2024-07-04 17:39:50 >>>回调事件[910,devices/D0309]
2024-07-04 17:39:50 >>>故障排除日志:上一MQTT订单号缓存列表为24070417315013331326
2024-07-04 17:39:50 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 17:39:50 开始打印,排队:131,票券:2407041739438065466201,订单:24070417394380650576,[2024-07-04 17:39:43微信支付10元]
2024-07-04 17:39:52 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407041739438065466201","queue_number":131,"trade_uid":"24070417394380650576"}]}
2024-07-04 17:39:52 >>>故障排除日志:删除未同步下发订单成功24070417394380650576
2024-07-04 17:39:53 >>>故障排除日志:终端同步成功后剩余订单列表


===17:41:36===
2024-07-04 17:41:18>>>cash read=BF
2024-07-04 17:41:19>>>cash read=3E


===17:46:36===
2024-07-04 17:45:38>>>cash read=9E
2024-07-04 17:45:39>>>cash read=3E


===17:49:36===
2024-07-04 17:49:13>>>cash read=9E
2024-07-04 17:49:14>>>cash read=3E


===17:51:37===
2024-07-04 17:51:21 >>>回调事件[910,devices/D0309]
2024-07-04 17:51:21 >>>故障排除日志:上一MQTT订单号缓存列表为24070417394380650576
2024-07-04 17:51:21 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 17:51:21 开始打印,排队:132,票券:2407041751100855734001,订单:24070417511008551041,[2024-07-04 17:51:10支付宝支付10元]
2024-07-04 17:51:23 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407041751100855734001","queue_number":132,"trade_uid":"24070417511008551041"}]}
2024-07-04 17:51:23 >>>故障排除日志:删除未同步下发订单成功24070417511008551041
2024-07-04 17:51:23 >>>故障排除日志:终端同步成功后剩余订单列表


===17:52:37===
2024-07-04 17:51:42 >>>回调事件[910,devices/D0309]
2024-07-04 17:51:42 >>>故障排除日志:上一MQTT订单号缓存列表为24070417511008551041
2024-07-04 17:51:42 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 17:51:42 开始打印,排队:133,票券:2407041751319524481801,订单:24070417513195240519,[2024-07-04 17:51:31支付宝支付10元]
2024-07-04 17:51:44 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407041751319524481801","queue_number":133,"trade_uid":"24070417513195240519"}]}
2024-07-04 17:51:44 >>>故障排除日志:删除未同步下发订单成功24070417513195240519
2024-07-04 17:51:44 >>>故障排除日志:终端同步成功后剩余订单列表


===17:54:37===
2024-07-04 17:54:08>>>cash read=9E
2024-07-04 17:54:10>>>cash read=3E


===17:55:37===
2024-07-04 17:54:47>>>cash read=BF
2024-07-04 17:54:48>>>cash read=3E
2024-07-04 17:55:15>>>cash read=BF
2024-07-04 17:55:16>>>cash read=3E
2024-07-04 17:55:24>>>cash read=BF
2024-07-04 17:55:25>>>cash read=3E


===17:56:37===
2024-07-04 17:56:14 >>>回调事件[910,devices/D0309]
2024-07-04 17:56:14 >>>故障排除日志:上一MQTT订单号缓存列表为24070417513195240519
2024-07-04 17:56:14 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 17:56:14 开始打印,排队:134,票券:2407041756060487739701,订单:24070417560604873813,[2024-07-04 17:56:06支付宝支付10元]
2024-07-04 17:56:16 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407041756060487739701","queue_number":134,"trade_uid":"24070417560604873813"}]}
2024-07-04 17:56:16 >>>故障排除日志:删除未同步下发订单成功24070417560604873813
2024-07-04 17:56:16 >>>故障排除日志:终端同步成功后剩余订单列表


===17:58:38===
2024-07-04 17:57:37>>>cash read=9E
2024-07-04 17:57:38>>>cash read=3E


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


===18:04:38===
2024-07-04 18:04:22>>>cash read=BF
2024-07-04 18:04:23>>>cash read=3E


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


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


===18:10:39===
2024-07-04 18:10:23>>>cash read=BF
2024-07-04 18:10:24>>>cash read=3E


===18:13:39===
2024-07-04 18:13:19>>>cash read=BF
2024-07-04 18:13:20>>>cash read=3E


===18:17:39===
2024-07-04 18:16:54 >>>回调事件[910,devices/D0309]
2024-07-04 18:16:54 >>>故障排除日志:上一MQTT订单号缓存列表为24070418080736543615
2024-07-04 18:16:54 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 18:16:54 开始打印,排队:138,票券:2407041816431587638601,订单:24070418164315868839,[2024-07-04 18:16:43支付宝支付10元]
2024-07-04 18:16:56 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407041816431587638601","queue_number":138,"trade_uid":"24070418164315868839"}]}
2024-07-04 18:16:56 >>>故障排除日志:删除未同步下发订单成功24070418164315868839
2024-07-04 18:16:56 >>>故障排除日志:终端同步成功后剩余订单列表


===18:22:40===
2024-07-04 18:21:41 >>>回调事件[910,devices/D0309]
2024-07-04 18:21:41 >>>故障排除日志:上一MQTT订单号缓存列表为24070418164315868839
2024-07-04 18:21:41 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 18:21:41 开始打印,排队:139,票券:2407041821318979339001,订单:24070418213189789542,[2024-07-04 18:21:31支付宝支付10元]
2024-07-04 18:21:43 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407041821318979339001","queue_number":139,"trade_uid":"24070418213189789542"}]}
2024-07-04 18:21:43 >>>故障排除日志:删除未同步下发订单成功24070418213189789542
2024-07-04 18:21:43 >>>故障排除日志:终端同步成功后剩余订单列表
2024-07-04 18:22:37 >>>回调事件[910,devices/D0309]
2024-07-04 18:22:37 >>>故障排除日志:上一MQTT订单号缓存列表为24070418213189789542
2024-07-04 18:22:37 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 18:22:37 开始打印,排队:140,票券:2407041822268892726801,订单:24070418222688922451,[2024-07-04 18:22:26支付宝支付10元]


===18:23:40===
2024-07-04 18:22:39 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407041822268892726801","queue_number":140,"trade_uid":"24070418222688922451"}]}
2024-07-04 18:22:39 >>>故障排除日志:删除未同步下发订单成功24070418222688922451
2024-07-04 18:22:39 >>>故障排除日志:终端同步成功后剩余订单列表


===18:32:40===
2024-07-04 18:31:39>>>cash read=9E
2024-07-04 18:31:41>>>cash read=3E


===18:33:40===
2024-07-04 18:33:32>>>cash read=BF
2024-07-04 18:33:33>>>cash read=3E
2024-07-04 18:33:37>>>cash read=9E
2024-07-04 18:33:38>>>cash read=3E


===18:36:41===
2024-07-04 18:36:15>>>cash read=9E
2024-07-04 18:36:16>>>cash read=3E
2024-07-04 18:36:31 >>>回调事件[910,devices/D0309]
2024-07-04 18:36:31 >>>故障排除日志:上一MQTT订单号缓存列表为24070418222688922451
2024-07-04 18:36:31 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 18:36:31 开始打印,排队:141,票券:2407041836251362327501,订单:24070418362513617840,[2024-07-04 18:36:25微信支付10元]
2024-07-04 18:36:33 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407041836251362327501","queue_number":141,"trade_uid":"24070418362513617840"}]}
2024-07-04 18:36:33 >>>故障排除日志:删除未同步下发订单成功24070418362513617840
2024-07-04 18:36:33 >>>故障排除日志:终端同步成功后剩余订单列表


===18:37:41===
2024-07-04 18:36:46>>>cash read=1F
2024-07-04 18:36:48>>>cash read=3E
2024-07-04 18:36:58>>>cash read=BF
2024-07-04 18:36:59>>>cash read=3E


===18:38:41===
2024-07-04 18:37:48 >>>回调事件[910,devices/D0309]
2024-07-04 18:37:48 >>>故障排除日志:上一MQTT订单号缓存列表为24070418362513617840
2024-07-04 18:37:48 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 18:37:48 开始打印,排队:142,票券:2407041837388346158201,订单:24070418373883456057,[2024-07-04 18:37:38支付宝支付10元]
2024-07-04 18:37:50 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407041837388346158201","queue_number":142,"trade_uid":"24070418373883456057"}]}
2024-07-04 18:37:50 >>>故障排除日志:删除未同步下发订单成功24070418373883456057
2024-07-04 18:37:50 >>>故障排除日志:终端同步成功后剩余订单列表


===18:40:42===
2024-07-04 18:40:21>>>cash read=9E
2024-07-04 18:40:23>>>cash read=3E


===18:44:42===
2024-07-04 18:43:59>>>cash read=00
2024-07-04 18:44:00>>>cash read=818F4200
2024-07-04 18:44:00>>>cash write=02
2024-07-04 18:44:00 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-07-04 18:44:00>>>cash read=10
2024-07-04 18:44:00 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-07-04 18:44:00 >>>开始打印,排队号为143,订单号为2407041844000003092591
2024-07-04 18:44:01>>>订单2407041844000003092591写入成功,剩余空间为1674500,占用RAM为592.62890625
删除未同步订单2407041844000003092591
2024-07-04 18:44:03>>>订单2407041844000003092591删除成功,剩余空间为1674500,占用RAM为606.1943359375
检测订单目录中>>>
无未同步订单>>>
2024-07-04 18:44:03 >>>当前Ram内存为578.6298828125
定时检测未同步订单启用
2024-07-04 18:44:04>>>cash write=0C
2024-07-04 18:44:04>>>cash read=3E


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


===18:46:46===
2024-07-04 18:46:19>>>cash read=9E
2024-07-04 18:46:21>>>cash read=3E
2024-07-04 18:46:25 >>>回调事件[910,devices/D0309]
2024-07-04 18:46:25 >>>故障排除日志:上一MQTT订单号缓存列表为24070418373883456057
2024-07-04 18:46:25 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 18:46:25 开始打印,排队:144,票券:2407041846159823111501,订单:24070418461598227409,[2024-07-04 18:46:15支付宝支付10元]
2024-07-04 18:46:27 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407041846159823111501","queue_number":144,"trade_uid":"24070418461598227409"}]}
2024-07-04 18:46:27 >>>故障排除日志:删除未同步下发订单成功24070418461598227409
2024-07-04 18:46:27 >>>故障排除日志:终端同步成功后剩余订单列表


===18:48:46===
2024-07-04 18:47:54 >>>回调事件[910,devices/D0309]
2024-07-04 18:47:54 >>>故障排除日志:上一MQTT订单号缓存列表为24070418461598227409
2024-07-04 18:47:54 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 18:47:54 开始打印,排队:145,票券:2407041847491457379601,订单:24070418474914566810,[2024-07-04 18:47:49支付宝支付10元]
2024-07-04 18:47:56 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407041847491457379601","queue_number":145,"trade_uid":"24070418474914566810"}]}
2024-07-04 18:47:56 >>>故障排除日志:删除未同步下发订单成功24070418474914566810
2024-07-04 18:47:56 >>>故障排除日志:终端同步成功后剩余订单列表
2024-07-04 18:48:22>>>cash read=9E
2024-07-04 18:48:23>>>cash read=3E


===18:49:46===
2024-07-04 18:48:56 >>>回调事件[910,devices/D0309]
2024-07-04 18:48:56 >>>故障排除日志:上一MQTT订单号缓存列表为24070418474914566810
2024-07-04 18:48:56 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 18:48:56 开始打印,排队:146,票券:2407041848500540978901,订单:24070418485005405667,[2024-07-04 18:48:50微信支付10元]
2024-07-04 18:48:58 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407041848500540978901","queue_number":146,"trade_uid":"24070418485005405667"}]}
2024-07-04 18:48:58 >>>故障排除日志:删除未同步下发订单成功24070418485005405667
2024-07-04 18:48:58 >>>故障排除日志:终端同步成功后剩余订单列表


===18:51:46===
2024-07-04 18:50:51 >>>回调事件[910,devices/D0309]
2024-07-04 18:50:51 >>>故障排除日志:上一MQTT订单号缓存列表为24070418485005405667
2024-07-04 18:50:51 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 18:50:51 开始打印,排队:147,票券:2407041850452799421401,订单:24070418504527989321,[2024-07-04 18:50:45微信支付10元]
2024-07-04 18:50:54 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407041850452799421401","queue_number":147,"trade_uid":"24070418504527989321"}]}
2024-07-04 18:50:54 >>>故障排除日志:删除未同步下发订单成功24070418504527989321
2024-07-04 18:50:54 >>>故障排除日志:终端同步成功后剩余订单列表


===18:54:47===
2024-07-04 18:54:03 >>>回调事件[910,devices/D0309]
2024-07-04 18:54:03 >>>故障排除日志:上一MQTT订单号缓存列表为24070418504527989321
2024-07-04 18:54:04 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 18:54:04 开始打印,排队:148,票券:2407041853516423282801,订单:24070418535164229563,[2024-07-04 18:53:51微信支付10元]
2024-07-04 18:54:06 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407041853516423282801","queue_number":148,"trade_uid":"24070418535164229563"}]}
2024-07-04 18:54:06 >>>故障排除日志:删除未同步下发订单成功24070418535164229563
2024-07-04 18:54:06 >>>故障排除日志:终端同步成功后剩余订单列表
2024-07-04 18:54:18>>>cash read=9E
2024-07-04 18:54:19>>>cash read=3E
2024-07-04 18:54:42 >>>回调事件[910,devices/D0309]
2024-07-04 18:54:42 >>>故障排除日志:上一MQTT订单号缓存列表为24070418535164229563
2024-07-04 18:54:42 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 18:54:42 开始打印,排队:149,票券:2407041854334280209301,订单:24070418543342798356,[2024-07-04 18:54:33支付宝支付10元]
2024-07-04 18:54:44 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407041854334280209301","queue_number":149,"trade_uid":"24070418543342798356"}]}
2024-07-04 18:54:44 >>>故障排除日志:删除未同步下发订单成功24070418543342798356
2024-07-04 18:54:44 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


===19:05:47===
2024-07-04 19:05:12 >>>回调事件[910,devices/D0309]
2024-07-04 19:05:12 >>>故障排除日志:上一MQTT订单号缓存列表为24070419014323274358
2024-07-04 19:05:12 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 19:05:12 开始打印,排队:153,票券:2407041905030901387501,订单:24070419050309008626,[2024-07-04 19:05:03支付宝支付10元]
2024-07-04 19:05:14 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407041905030901387501","queue_number":153,"trade_uid":"24070419050309008626"}]}
2024-07-04 19:05:14 >>>故障排除日志:删除未同步下发订单成功24070419050309008626
2024-07-04 19:05:14 >>>故障排除日志:终端同步成功后剩余订单列表


===19:14:47===
2024-07-04 19:13:58 >>>回调事件[910,devices/D0309]
2024-07-04 19:13:58 >>>故障排除日志:上一MQTT订单号缓存列表为24070419050309008626
2024-07-04 19:13:58 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 19:13:58 开始打印,排队:154,票券:2407041913452034763701,订单:24070419134520341583,[2024-07-04 19:13:45支付宝支付10元]
2024-07-04 19:14:00 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407041913452034763701","queue_number":154,"trade_uid":"24070419134520341583"}]}
2024-07-04 19:14:00 >>>故障排除日志:删除未同步下发订单成功24070419134520341583
2024-07-04 19:14:00 >>>故障排除日志:终端同步成功后剩余订单列表


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


===19:19:48===
2024-07-04 19:18:51>>>cash read=9E
2024-07-04 19:18:53>>>cash read=3E


===19:20:48===
2024-07-04 19:19:55 >>>回调事件[910,devices/D0309]
2024-07-04 19:19:56 >>>故障排除日志:上一MQTT订单号缓存列表为24070419151360939995
2024-07-04 19:19:56 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 19:19:56 开始打印,排队:156,票券:2407041919477950468101,订单:24070419194779499726,[2024-07-04 19:19:47微信支付10元]
2024-07-04 19:19:58 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407041919477950468101","queue_number":156,"trade_uid":"24070419194779499726"}]}
2024-07-04 19:19:58 >>>故障排除日志:删除未同步下发订单成功24070419194779499726
2024-07-04 19:19:58 >>>故障排除日志:终端同步成功后剩余订单列表


===19:21:49===
2024-07-04 19:20:55 >>>回调事件[910,devices/D0309]
2024-07-04 19:20:55 >>>故障排除日志:上一MQTT订单号缓存列表为24070419194779499726
2024-07-04 19:20:55 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 19:20:55 开始打印,排队:157,票券:2407041920465846488101,订单:24070419204658460174,[2024-07-04 19:20:46支付宝支付10元]
2024-07-04 19:20:57 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407041920465846488101","queue_number":157,"trade_uid":"24070419204658460174"}]}
2024-07-04 19:20:57 >>>故障排除日志:删除未同步下发订单成功24070419204658460174
2024-07-04 19:20:57 >>>故障排除日志:终端同步成功后剩余订单列表


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


===19:28:49===
2024-07-04 19:28:04>>>cash read=BF
2024-07-04 19:28:05>>>cash read=3E
2024-07-04 19:28:29 >>>回调事件[910,devices/D0309]
2024-07-04 19:28:29 >>>故障排除日志:上一MQTT订单号缓存列表为24070419261651516203
2024-07-04 19:28:29 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 19:28:29 开始打印,排队:159,票券:2407041928220539373501,订单:24070419282205389369,[2024-07-04 19:28:22微信支付10元]
2024-07-04 19:28:31 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407041928220539373501","queue_number":159,"trade_uid":"24070419282205389369"}]}
2024-07-04 19:28:31 >>>故障排除日志:删除未同步下发订单成功24070419282205389369
2024-07-04 19:28:31 >>>故障排除日志:终端同步成功后剩余订单列表


===19:29:49===
2024-07-04 19:29:13>>>cash read=BF
2024-07-04 19:29:14>>>cash read=3E


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


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


===19:33:50===
2024-07-04 19:33:17 >>>回调事件[910,devices/D0309]
2024-07-04 19:33:17 >>>故障排除日志:上一MQTT订单号缓存列表为24070419320522419650
2024-07-04 19:33:17 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 19:33:17 开始打印,排队:162,票券:2407041933113188541701,订单:24070419331131880856,[2024-07-04 19:33:11支付宝支付10元]
2024-07-04 19:33:19 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407041933113188541701","queue_number":162,"trade_uid":"24070419331131880856"}]}
2024-07-04 19:33:19 >>>故障排除日志:删除未同步下发订单成功24070419331131880856
2024-07-04 19:33:20 >>>故障排除日志:终端同步成功后剩余订单列表


===19:34:50===
2024-07-04 19:34:11>>>cash read=BF
2024-07-04 19:34:12>>>cash read=3E


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


===19:38:51===
2024-07-04 19:38:27>>>cash read=1F
2024-07-04 19:38:28>>>cash read=3E


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


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


===19:46:51===
2024-07-04 19:46:25>>>cash read=1F
2024-07-04 19:46:27>>>cash read=3E


===19:49:52===
2024-07-04 19:49:14>>>cash read=9E
2024-07-04 19:49:15>>>cash read=3E


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


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


===19:53:52===
2024-07-04 19:53:29>>>cash read=9E
2024-07-04 19:53:30>>>cash read=3E


===19:54:53===
2024-07-04 19:53:56 >>>回调事件[910,devices/D0309]
2024-07-04 19:53:56 >>>故障排除日志:上一MQTT订单号缓存列表为24070419515889161830
2024-07-04 19:53:56 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 19:53:56 开始打印,排队:168,票券:2407041953468307670701,订单:24070419534683073081,[2024-07-04 19:53:46支付宝支付10元]
2024-07-04 19:53:58 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407041953468307670701","queue_number":168,"trade_uid":"24070419534683073081"}]}
2024-07-04 19:53:58 >>>故障排除日志:删除未同步下发订单成功24070419534683073081
2024-07-04 19:53:58 >>>故障排除日志:终端同步成功后剩余订单列表
2024-07-04 19:54:42 >>>回调事件[910,devices/D0309]
2024-07-04 19:54:43 >>>故障排除日志:上一MQTT订单号缓存列表为24070419534683073081
2024-07-04 19:54:43 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 19:54:43 开始打印,排队:169,票券:2407041954374223970801,订单:24070419543742234982,[2024-07-04 19:54:37支付宝支付10元]
2024-07-04 19:54:45 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407041954374223970801","queue_number":169,"trade_uid":"24070419543742234982"}]}
2024-07-04 19:54:45 >>>故障排除日志:删除未同步下发订单成功24070419543742234982
2024-07-04 19:54:45 >>>故障排除日志:终端同步成功后剩余订单列表


===19:55:53===
2024-07-04 19:54:59>>>cash read=BF
2024-07-04 19:55:00>>>cash read=3E
2024-07-04 19:55:09 >>>回调事件[910,devices/D0309]
2024-07-04 19:55:09 >>>故障排除日志:上一MQTT订单号缓存列表为24070419543742234982
2024-07-04 19:55:09 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 19:55:09 开始打印,排队:170,票券:2407041954525357127501,订单:24070419545253566024,[2024-07-04 19:54:52支付宝支付10元]
2024-07-04 19:55:11 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407041954525357127501","queue_number":170,"trade_uid":"24070419545253566024"}]}
2024-07-04 19:55:11 >>>故障排除日志:删除未同步下发订单成功24070419545253566024
2024-07-04 19:55:11 >>>故障排除日志:终端同步成功后剩余订单列表


===19:57:53===
2024-07-04 19:57:46 >>>回调事件[910,devices/D0309]
2024-07-04 19:57:46 >>>故障排除日志:上一MQTT订单号缓存列表为24070419545253566024
2024-07-04 19:57:46 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 19:57:46 开始打印,排队:171,票券:2407041957279416853801,订单:24070419572794165084,[2024-07-04 19:57:27支付宝支付10元]
2024-07-04 19:57:48 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407041957279416853801","queue_number":171,"trade_uid":"24070419572794165084"}]}
2024-07-04 19:57:48 >>>故障排除日志:删除未同步下发订单成功24070419572794165084
2024-07-04 19:57:48 >>>故障排除日志:终端同步成功后剩余订单列表


===20:00:53===
2024-07-04 19:59:56>>>cash read=9E
2024-07-04 19:59:58>>>cash read=3E


===20:08:53===
2024-07-04 20:08:39 >>>回调事件[910,devices/D0309]
2024-07-04 20:08:39 >>>故障排除日志:上一MQTT订单号缓存列表为24070419572794165084
2024-07-04 20:08:39 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 20:08:39 开始打印,排队:172,票券:2407042008223017888401,订单:24070420082230175456,[2024-07-04 20:08:22支付宝支付10元]
2024-07-04 20:08:41 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407042008223017888401","queue_number":172,"trade_uid":"24070420082230175456"}]}
2024-07-04 20:08:41 >>>故障排除日志:删除未同步下发订单成功24070420082230175456
2024-07-04 20:08:41 >>>故障排除日志:终端同步成功后剩余订单列表


===20:12:54===
2024-07-04 20:12:30>>>cash read=9E
2024-07-04 20:12:31>>>cash read=3E


===20:14:54===
2024-07-04 20:14:27 >>>回调事件[910,devices/D0309]
2024-07-04 20:14:27 >>>故障排除日志:上一MQTT订单号缓存列表为24070420082230175456
2024-07-04 20:14:27 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 20:14:27 开始打印,排队:173,票券:2407042014182376087901,订单:24070420141823756246,[2024-07-04 20:14:18微信支付10元]
2024-07-04 20:14:29 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407042014182376087901","queue_number":173,"trade_uid":"24070420141823756246"}]}
2024-07-04 20:14:29 >>>故障排除日志:删除未同步下发订单成功24070420141823756246
2024-07-04 20:14:29 >>>故障排除日志:终端同步成功后剩余订单列表
2024-07-04 20:14:42>>>cash read=9E
2024-07-04 20:14:43>>>cash read=3E


===20:17:54===
2024-07-04 20:17:26 >>>回调事件[910,devices/D0309]
2024-07-04 20:17:26 >>>故障排除日志:上一MQTT订单号缓存列表为24070420141823756246
2024-07-04 20:17:26 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 20:17:26 开始打印,排队:174,票券:2407042017187590782701,订单:24070420171875903912,[2024-07-04 20:17:18微信支付10元]
2024-07-04 20:17:28>>>cash read=818F43
2024-07-04 20:17:28>>>cash write=02
2024-07-04 20:17:28 >>>回调事件130,cash_status,10022,进钞中...read money=20
2024-07-04 20:17:28 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407042017187590782701","queue_number":174,"trade_uid":"24070420171875903912"}]}
2024-07-04 20:17:28 >>>故障排除日志:删除未同步下发订单成功24070420171875903912
2024-07-04 20:17:28 >>>故障排除日志:终端同步成功后剩余订单列表
2024-07-04 20:17:28>>>cash read=10
2024-07-04 20:17:28 >>>回调事件130,20,10023,finish Money=20,进钞完成
2024-07-04 20:17:28 >>>开始打印,排队号为175,订单号为2407042017280003093137
2024-07-04 20:17:28 >>>开始打印,排队号为176,订单号为2407042017280003093137
2024-07-04 20:17:29>>>订单2407042017280003093137写入成功,剩余空间为1672500,占用RAM为598.2939453125
删除未同步订单2407042017280003093137
2024-07-04 20:17:32>>>订单2407042017280003093137删除成功,剩余空间为1674000,占用RAM为621.95703125
检测订单目录中>>>
无未同步订单>>>
2024-07-04 20:17:32 >>>当前Ram内存为581.38671875
定时检测未同步订单启用
2024-07-04 20:17:33>>>cash write=0C
2024-07-04 20:17:33>>>cash read=3E
2024-07-04 20:17:37>>>cash read=00
2024-07-04 20:17:37>>>cash read=818F43
2024-07-04 20:17:37>>>cash write=02
2024-07-04 20:17:37 >>>回调事件130,cash_status,10022,进钞中...read money=20
2024-07-04 20:17:38>>>cash read=10
2024-07-04 20:17:38 >>>回调事件130,20,10023,finish Money=20,进钞完成
2024-07-04 20:17:38 >>>开始打印,排队号为177,订单号为2407042017380003096016
2024-07-04 20:17:38 >>>开始打印,排队号为178,订单号为2407042017380003096016
定时检测未同步订单关闭
2024-07-04 20:17:39>>>订单2407042017380003096016写入成功,剩余空间为1671500,占用RAM为614.181640625
删除未同步订单2407042017380003096016
2024-07-04 20:17:42>>>订单2407042017380003096016删除成功,剩余空间为1673000,占用RAM为626.5693359375
检测订单目录中>>>
无未同步订单>>>
2024-07-04 20:17:42 >>>当前Ram内存为583.087890625
定时检测未同步订单启用
2024-07-04 20:17:43>>>cash write=0C
2024-07-04 20:17:43>>>cash read=00
2024-07-04 20:17:44>>>cash read=818F43
2024-07-04 20:17:44>>>cash write=02
2024-07-04 20:17:44 >>>回调事件130,cash_status,10022,进钞中...read money=20
2024-07-04 20:17:45>>>cash read=10
2024-07-04 20:17:45 >>>回调事件130,20,10023,finish Money=20,进钞完成
2024-07-04 20:17:45 >>>开始打印,排队号为179,订单号为2407042017450003093525
2024-07-04 20:17:45 >>>开始打印,排队号为180,订单号为2407042017450003093525
定时检测未同步订单关闭
2024-07-04 20:17:45>>>订单2407042017450003093525写入成功,剩余空间为1670500,占用RAM为620.7841796875
删除未同步订单2407042017450003093525
2024-07-04 20:17:49>>>订单2407042017450003093525删除成功,剩余空间为1672000,占用RAM为627.994140625
检测订单目录中>>>
无未同步订单>>>
2024-07-04 20:17:49 >>>当前Ram内存为584.2734375
定时检测未同步订单启用
2024-07-04 20:17:50>>>cash write=0C
2024-07-04 20:17:50>>>cash read=3E


===20:18:54===
2024-07-04 20:18:21>>>cash read=1F
2024-07-04 20:18:22>>>cash read=3E
2024-07-04 20:18:49>>>cash read=BF
定时检测未同步订单关闭
检测订单目录中>>>
无未同步订单>>>
2024-07-04 20:18:50>>>cash read=3E


===20:21:55===
2024-07-04 20:21:30>>>cash read=29
2024-07-04 20:21:30 >>>回调事件130,cash_status,20029,退钞中
2024-07-04 20:21:31>>>cash read=3E
2024-07-04 20:21:32>>>cash read=00818F42
2024-07-04 20:21:32>>>cash write=02
2024-07-04 20:21:32 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-07-04 20:21:33>>>cash read=10
2024-07-04 20:21:33 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-07-04 20:21:33 >>>开始打印,排队号为181,订单号为2407042021330003099158
2024-07-04 20:21:33>>>订单2407042021330003099158写入成功,剩余空间为1673500,占用RAM为594.115234375
删除未同步订单2407042021330003099158
2024-07-04 20:21:35>>>订单2407042021330003099158删除成功,剩余空间为1674500,占用RAM为605.7412109375
检测订单目录中>>>
无未同步订单>>>
2024-07-04 20:21:36 >>>当前Ram内存为578.4794921875
定时检测未同步订单启用
2024-07-04 20:21:36>>>cash read=818F42
2024-07-04 20:21:36 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-07-04 20:21:37>>>cash read=10
2024-07-04 20:21:37 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-07-04 20:21:37 >>>开始打印,排队号为182,订单号为2407042021370003097318
定时检测未同步订单关闭
2024-07-04 20:21:37>>>订单2407042021370003097318写入成功,剩余空间为1673000,占用RAM为599.3330078125
删除未同步订单2407042021370003097318
2024-07-04 20:21:39>>>订单2407042021370003097318删除成功,剩余空间为1674000,占用RAM为610.3095703125
检测订单目录中>>>
无未同步订单>>>
2024-07-04 20:21:39 >>>当前Ram内存为580.1904296875
定时检测未同步订单启用
2024-07-04 20:21:40>>>cash write=0C
2024-07-04 20:21:40>>>cash read=3E


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


===20:24:55===
2024-07-04 20:24:10>>>cash read=BF
2024-07-04 20:24:11>>>cash read=3E


===20:33:56===
2024-07-04 20:33:53 >>>回调事件[910,devices/D0309]
2024-07-04 20:33:53 >>>故障排除日志:上一MQTT订单号缓存列表为24070420171875903912
2024-07-04 20:33:53 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 20:33:53 开始打印,排队:183,票券:2407042033443650538401,订单:24070420334436500516,[2024-07-04 20:33:44支付宝支付10元]


===20:34:56===
2024-07-04 20:34:24>>>cash read=BF
2024-07-04 20:34:25>>>cash read=3E


===20:36:56===
2024-07-04 20:36:04 >>>回调事件[910,devices/D0309]
2024-07-04 20:36:04 >>>故障排除日志:上一MQTT订单号缓存列表为24070420334436500516
2024-07-04 20:36:04 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 20:36:04 开始打印,排队:184,票券:2407042035559378255401,订单:24070420355593778765,[2024-07-04 20:35:55微信支付10元]
2024-07-04 20:36:06 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407042035559378255401","queue_number":184,"trade_uid":"24070420355593778765"}]}
2024-07-04 20:36:06 >>>故障排除日志:删除未同步下发订单成功24070420355593778765
2024-07-04 20:36:06 >>>故障排除日志:终端同步成功后剩余订单列表
2024-07-04 20:36:23>>>cash read=9E
2024-07-04 20:36:25>>>cash read=3E


===20:39:56===
2024-07-04 20:39:07 >>>回调事件[910,devices/D0309]
2024-07-04 20:39:07 >>>故障排除日志:上一MQTT订单号缓存列表为24070420355593778765
2024-07-04 20:39:07 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 20:39:07 开始打印,排队:185,票券:2407042038583825632901,订单:24070420385838251287,[2024-07-04 20:38:58微信支付10元]
2024-07-04 20:39:09 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407042038583825632901","queue_number":185,"trade_uid":"24070420385838251287"}]}
2024-07-04 20:39:09 >>>故障排除日志:删除未同步下发订单成功24070420385838251287
2024-07-04 20:39:09 >>>故障排除日志:终端同步成功后剩余订单列表
2024-07-04 20:39:55>>>cash read=9E


===20:40:57===
2024-07-04 20:39:56>>>cash read=3E


===20:50:57===
2024-07-04 20:49:56 >>>回调事件[910,devices/D0309]
2024-07-04 20:49:56 >>>故障排除日志:上一MQTT订单号缓存列表为24070420385838251287
2024-07-04 20:49:56 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 20:49:56 开始打印,排队:186,票券:2407042049502455115901,订单:24070420495024547520,[2024-07-04 20:49:50微信支付10元]
2024-07-04 20:49:58 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407042049502455115901","queue_number":186,"trade_uid":"24070420495024547520"}]}
2024-07-04 20:49:58 >>>故障排除日志:删除未同步下发订单成功24070420495024547520
2024-07-04 20:49:58 >>>故障排除日志:终端同步成功后剩余订单列表


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


===20:52:57===
2024-07-04 20:52:14 >>>回调事件[910,devices/D0309]
2024-07-04 20:52:14 >>>故障排除日志:上一MQTT订单号缓存列表为24070420511086400932
2024-07-04 20:52:14 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 20:52:14 开始打印,排队:188,票券:2407042051565708167101,订单:24070420515657078134,[2024-07-04 20:51:56微信支付10元]
2024-07-04 20:52:17 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407042051565708167101","queue_number":188,"trade_uid":"24070420515657078134"}]}
2024-07-04 20:52:17 >>>故障排除日志:删除未同步下发订单成功24070420515657078134
2024-07-04 20:52:17 >>>故障排除日志:终端同步成功后剩余订单列表
2024-07-04 20:52:18>>>cash read=1F
2024-07-04 20:52:19>>>cash read=3E


===20:54:58===
2024-07-04 20:54:23>>>cash read=BF
2024-07-04 20:54:24>>>cash read=3E


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


===20:56:58===
2024-07-04 20:55:58>>>cash read=9E
2024-07-04 20:55:59>>>cash read=3E
2024-07-04 20:56:11 >>>回调事件[910,devices/D0309]
2024-07-04 20:56:11 >>>故障排除日志:上一MQTT订单号缓存列表为24070420545424169102
2024-07-04 20:56:11 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 20:56:12 开始打印,排队:190,票券:2407042056030826183901,订单:24070420560308255780,[2024-07-04 20:56:03微信支付10元]
2024-07-04 20:56:13 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407042056030826183901","queue_number":190,"trade_uid":"24070420560308255780"}]}
2024-07-04 20:56:13 >>>故障排除日志:删除未同步下发订单成功24070420560308255780
2024-07-04 20:56:14 >>>故障排除日志:终端同步成功后剩余订单列表
2024-07-04 20:56:26>>>cash read=9E
2024-07-04 20:56:27>>>cash read=3E
2024-07-04 20:56:36 >>>回调事件[910,devices/D0309]
2024-07-04 20:56:36 >>>故障排除日志:上一MQTT订单号缓存列表为24070420560308255780
2024-07-04 20:56:36 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 20:56:36 开始打印,排队:191,票券:2407042056253833238101,订单:24070420562538328561,[2024-07-04 20:56:25微信支付10元]
2024-07-04 20:56:38 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407042056253833238101","queue_number":191,"trade_uid":"24070420562538328561"}]}
2024-07-04 20:56:38 >>>故障排除日志:删除未同步下发订单成功24070420562538328561
2024-07-04 20:56:38 >>>故障排除日志:终端同步成功后剩余订单列表


===21:01:58===
2024-07-04 21:01:51>>>cash read=BF
2024-07-04 21:01:52>>>cash read=3E


===21:03:59===
2024-07-04 21:03:04>>>cash read=1F
2024-07-04 21:03:05>>>cash read=3E


===21:05:59===
2024-07-04 21:05:17>>>cash read=BF
2024-07-04 21:05:19>>>cash read=3E


===21:06:59===
2024-07-04 21:06:57>>>cash read=9E


===21:07:59===
2024-07-04 21:06:58>>>cash read=3E
2024-07-04 21:07:26 >>>回调事件[910,devices/D0309]
2024-07-04 21:07:26 >>>故障排除日志:上一MQTT订单号缓存列表为24070420562538328561
2024-07-04 21:07:26 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 21:07:26 开始打印,排队:192,票券:2407042107203899615301,订单:24070421072038991368,[2024-07-04 21:07:20微信支付10元]
2024-07-04 21:07:28 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407042107203899615301","queue_number":192,"trade_uid":"24070421072038991368"}]}
2024-07-04 21:07:28 >>>故障排除日志:删除未同步下发订单成功24070421072038991368
2024-07-04 21:07:28 >>>故障排除日志:终端同步成功后剩余订单列表
2024-07-04 21:07:42>>>cash read=9E
2024-07-04 21:07:43>>>cash read=3E


===21:14:59===
2024-07-04 21:13:59>>>cash read=9E
2024-07-04 21:14:00>>>cash read=3E


===21:19:00===
2024-07-04 21:18:47>>>cash read=9E
2024-07-04 21:18:48>>>cash read=3E


===21:21:00===
2024-07-04 21:20:28>>>cash read=00
2024-07-04 21:20:29>>>cash read=818F42
2024-07-04 21:20:29>>>cash write=02
2024-07-04 21:20:29 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-07-04 21:20:29>>>cash read=10
2024-07-04 21:20:29 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-07-04 21:20:29 >>>开始打印,排队号为193,订单号为2407042120290003092308
2024-07-04 21:20:30>>>订单2407042120290003092308写入成功,剩余空间为1674500,占用RAM为593.05859375
删除未同步订单2407042120290003092308
2024-07-04 21:20:32>>>订单2407042120290003092308删除成功,剩余空间为1674500,占用RAM为607.4423828125
检测订单目录中>>>
无未同步订单>>>
2024-07-04 21:20:32 >>>当前Ram内存为578.5185546875
定时检测未同步订单启用
2024-07-04 21:20:33>>>cash write=0C
2024-07-04 21:20:33>>>cash read=00
2024-07-04 21:20:34>>>cash read=3E
2024-07-04 21:20:35>>>cash read=00
2024-07-04 21:20:36>>>cash read=818F42
2024-07-04 21:20:36>>>cash write=02
2024-07-04 21:20:36 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-07-04 21:20:37>>>cash read=10
2024-07-04 21:20:37 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-07-04 21:20:37 >>>开始打印,排队号为194,订单号为2407042120370003091607
定时检测未同步订单关闭
2024-07-04 21:20:37>>>订单2407042120370003091607写入成功,剩余空间为1673000,占用RAM为598.853515625
删除未同步订单2407042120370003091607
2024-07-04 21:20:39>>>订单2407042120370003091607删除成功,剩余空间为1673500,占用RAM为610.947265625
检测订单目录中>>>
无未同步订单>>>
2024-07-04 21:20:39 >>>当前Ram内存为580.984375
定时检测未同步订单启用
2024-07-04 21:20:40>>>cash write=0C
2024-07-04 21:20:40>>>cash read=3E


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


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


===21:25:00===
2024-07-04 21:24:05>>>cash read=BF
2024-07-04 21:24:06>>>cash read=3E


===21:26:01===
2024-07-04 21:25:11>>>cash read=BF
2024-07-04 21:25:12>>>cash read=3E


===21:29:01===
2024-07-04 21:28:35>>>cash read=1F
2024-07-04 21:28:36>>>cash read=3E


===21:33:01===
2024-07-04 21:32:19>>>cash read=BF
2024-07-04 21:32:21>>>cash read=3E