TLClient_JSSCOM_LuatOS-Air_V4010_RDA8910_RFTTS_0xe0000,2.5.1,865328069332467,01366681667420,
poweron reason:0

===00:54:25===
2024-09-28 00:54:07>>>cash read=0A
2024-09-28 00:54:08>>>cash read=3E


===01:35:25===
2024-09-28 01:34:47>>>cash read=0A
2024-09-28 01:34:48>>>cash read=3E


===02:55:26===
2024-09-28 02:55:08>>>cash read=0A
2024-09-28 02:55:09>>>cash read=3E


===03:55:26===
2024-09-28 03:54:23>>>cash read=0A
2024-09-28 03:54:24>>>cash read=3E


===04:12:26===
2024-09-28 04:11:58>>>cash read=0A
2024-09-28 04:11:59>>>cash read=3E


===07:36:27===
2024-09-28 07:35:38>>>cash read=0A
2024-09-28 07:35:39>>>cash read=3E


===08:58:27===
2024-09-28 08:58:10 >>>回调事件[910,devices/D0362]
隔日重置时间戳true
隔日清空未同步下发列表true
2024-09-28 08:58:10 >>>故障排除日志:上一MQTT订单号缓存列表为24092721585843315623
2024-09-28 08:58:10 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 08:58:10 开始打印,排队:1,票券:2409280858054686065601,订单:24092808580546856421,[2024-09-28 08:58:11微信支付15元]
2024-09-28 08:58:12 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409280858054686065601","queue_number":1,"trade_uid":"24092808580546856421"}]}
2024-09-28 08:58:12 >>>故障排除日志:删除未同步下发订单成功24092808580546856421
2024-09-28 08:58:12 >>>故障排除日志:终端同步成功后剩余订单列表


===09:00:27===
2024-09-28 08:59:59 >>>回调事件[910,devices/D0362]
上一时间戳为1727485090
2024-09-28 08:59:59 >>>故障排除日志:上一MQTT订单号缓存列表为24092808580546856421
2024-09-28 08:59:59 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 08:59:59 开始打印,排队:2,票券:2409280859548908768101,订单:24092808595489083084,[2024-09-28 09:00:00微信支付10元]
2024-09-28 09:00:01 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409280859548908768101","queue_number":2,"trade_uid":"24092808595489083084"}]}
2024-09-28 09:00:01 >>>故障排除日志:删除未同步下发订单成功24092808595489083084
2024-09-28 09:00:01 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


===09:32:28===
2024-09-28 09:32:15>>>cash read=00
2024-09-28 09:32:16>>>cash read=818F42
2024-09-28 09:32:16>>>cash write=02
2024-09-28 09:32:16 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-09-28 09:32:16>>>cash read=10
2024-09-28 09:32:16 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-09-28 09:32:16 >>>开始打印,排队号为9,订单号为2409280932160003626623
2024-09-28 09:32:17>>>订单2409280932160003626623写入成功,剩余空间为1680500,占用RAM为609.4306640625
删除未同步订单2409280932160003626623
2024-09-28 09:32:19>>>订单2409280932160003626623删除成功,剩余空间为1680500,占用RAM为622.146484375
检测订单目录中>>>
无未同步订单>>>
2024-09-28 09:32:19 >>>当前Ram内存为594.734375
定时检测未同步订单启用
2024-09-28 09:32:20>>>cash write=0C
2024-09-28 09:32:20>>>cash read=3E


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


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


===09:44:30===
2024-09-28 09:44:25 >>>回调事件[910,devices/D0362]
2024-09-28 09:44:25 >>>故障排除日志:上一MQTT订单号缓存列表为24092809400441429468
2024-09-28 09:44:25 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 09:44:26 开始打印,排队:11,票券:2409280944229870356101,订单:24092809442298699652,[2024-09-28 09:44:27微信支付10元]


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


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


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


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


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


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


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


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


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


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


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


===10:46:33===
2024-09-28 10:45:44 >>>回调事件[910,devices/D0362]
2024-09-28 10:45:44 >>>故障排除日志:上一MQTT订单号缓存列表为24092810395937986826
2024-09-28 10:45:44 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 10:45:44 开始打印,排队:25,票券:2409281045400645795401,订单:24092810454006453584,[2024-09-28 10:45:46微信支付10元]
2024-09-28 10:45:46 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281045400645795401","queue_number":25,"trade_uid":"24092810454006453584"}]}
2024-09-28 10:45:46 >>>故障排除日志:删除未同步下发订单成功24092810454006453584
2024-09-28 10:45:46 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 10:46:11>>>cash read=9E
2024-09-28 10:46:12>>>cash read=3E
2024-09-28 10:46:16 >>>回调事件[910,devices/D0362]
2024-09-28 10:46:16 >>>故障排除日志:上一MQTT订单号缓存列表为24092810454006453584
2024-09-28 10:46:16 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 10:46:16 开始打印,排队:26,票券:2409281046090281766801,订单:24092810460902812580,[2024-09-28 10:46:18微信支付10元]
2024-09-28 10:46:16 开始打印,排队:27,票券:2409281046090281951602,订单:24092810460902812580,[2024-09-28 10:46:18微信支付10元]
2024-09-28 10:46:20 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281046090281766801","queue_number":26,"trade_uid":"24092810460902812580"},{"ticket_no":"2409281046090281951602","queue_number":27,"trade_uid":"24092810460902812580"}]}
2024-09-28 10:46:20 >>>故障排除日志:删除未同步下发订单成功24092810460902812580
2024-09-28 10:46:20 >>>故障排除日志:删除未同步下发订单成功24092810460902812580
2024-09-28 10:46:20 >>>故障排除日志:终端同步成功后剩余订单列表


===10:50:33===
2024-09-28 10:50:30>>>cash read=0A


===10:51:34===
2024-09-28 10:50:31>>>cash read=3E


===10:56:34===
2024-09-28 10:55:50 >>>回调事件[910,devices/D0362]
2024-09-28 10:55:51 >>>故障排除日志:上一MQTT订单号缓存列表为24092810460902812580|24092810460902812580
2024-09-28 10:55:51 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 10:55:51 开始打印,排队:28,票券:2409281055474717639101,订单:24092810554747172424,[2024-09-28 10:55:52微信支付10元]
2024-09-28 10:55:52 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281055474717639101","queue_number":28,"trade_uid":"24092810554747172424"}]}
2024-09-28 10:55:52 >>>故障排除日志:删除未同步下发订单成功24092810554747172424
2024-09-28 10:55:53 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 10:56:09 >>>回调事件[910,devices/D0362]
2024-09-28 10:56:09 >>>故障排除日志:上一MQTT订单号缓存列表为24092810554747172424
2024-09-28 10:56:09 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 10:56:09 开始打印,排队:29,票券:2409281056047063022801,订单:24092810560470626664,[2024-09-28 10:56:10微信支付10元]
2024-09-28 10:56:09 开始打印,排队:30,票券:2409281056047063159702,订单:24092810560470626664,[2024-09-28 10:56:10微信支付10元]
2024-09-28 10:56:13 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281056047063022801","queue_number":29,"trade_uid":"24092810560470626664"},{"ticket_no":"2409281056047063159702","queue_number":30,"trade_uid":"24092810560470626664"}]}
2024-09-28 10:56:13 >>>故障排除日志:删除未同步下发订单成功24092810560470626664
2024-09-28 10:56:13 >>>故障排除日志:删除未同步下发订单成功24092810560470626664
2024-09-28 10:56:13 >>>故障排除日志:终端同步成功后剩余订单列表


===10:59:34===
2024-09-28 10:59:27>>>cash read=00
2024-09-28 10:59:28>>>cash read=292F29
2024-09-28 10:59:28 >>>回调事件130,cash_status,20029,退钞中
2024-09-28 10:59:29>>>cash read=01
2024-09-28 10:59:29>>>cash read=2F
2024-09-28 10:59:30>>>cash read=00


===11:00:34===
2024-09-28 10:59:32>>>cash read=818F42
2024-09-28 10:59:32>>>cash write=02
2024-09-28 10:59:32 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-09-28 10:59:32>>>cash read=10
2024-09-28 10:59:32 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-09-28 10:59:32 >>>开始打印,排队号为31,订单号为2409281059320003627003
2024-09-28 10:59:32>>>订单2409281059320003627003写入成功,剩余空间为1680500,占用RAM为609.00390625
删除未同步订单2409281059320003627003
2024-09-28 10:59:34>>>订单2409281059320003627003删除成功,剩余空间为1680500,占用RAM为621.826171875
检测订单目录中>>>
无未同步订单>>>
2024-09-28 10:59:34 >>>当前Ram内存为594.455078125
定时检测未同步订单启用
2024-09-28 10:59:35>>>cash write=0C
2024-09-28 10:59:35>>>cash read=3E


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


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


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


===11:31:35===
2024-09-28 11:30:49>>>cash read=00
2024-09-28 11:30:49>>>cash read=818F42
2024-09-28 11:30:49>>>cash write=02
2024-09-28 11:30:49 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-09-28 11:30:49>>>cash read=10
2024-09-28 11:30:49 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-09-28 11:30:49 >>>开始打印,排队号为34,订单号为2409281130490003623466
2024-09-28 11:30:50>>>订单2409281130490003623466写入成功,剩余空间为1680500,占用RAM为606.5400390625
删除未同步订单2409281130490003623466
2024-09-28 11:30:52>>>订单2409281130490003623466删除成功,剩余空间为1680500,占用RAM为620.6904296875
检测订单目录中>>>
无未同步订单>>>
2024-09-28 11:30:52 >>>当前Ram内存为593.4560546875
定时检测未同步订单启用
2024-09-28 11:30:53>>>cash write=0C
2024-09-28 11:30:53>>>cash read=3E


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


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


===11:39:36===
2024-09-28 11:39:12>>>cash read=00
2024-09-28 11:39:13>>>cash read=818F42
2024-09-28 11:39:13>>>cash write=02
2024-09-28 11:39:13 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-09-28 11:39:13>>>cash read=10
2024-09-28 11:39:13 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-09-28 11:39:13 >>>开始打印,排队号为37,订单号为2409281139130003626045
2024-09-28 11:39:14>>>订单2409281139130003626045写入成功,剩余空间为1680500,占用RAM为608.33203125
删除未同步订单2409281139130003626045
2024-09-28 11:39:16>>>订单2409281139130003626045删除成功,剩余空间为1680500,占用RAM为620.9306640625
检测订单目录中>>>
无未同步订单>>>
2024-09-28 11:39:16 >>>当前Ram内存为593.66015625
定时检测未同步订单启用
2024-09-28 11:39:17>>>cash write=0C
2024-09-28 11:39:17>>>cash read=3E


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


===11:49:36===
2024-09-28 11:48:43 >>>回调事件[910,devices/D0362]
2024-09-28 11:48:43 >>>故障排除日志:上一MQTT订单号缓存列表为24092811342889035320
2024-09-28 11:48:43 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 11:48:43 开始打印,排队:38,票券:2409281148387324020501,订单:24092811483873233228,[2024-09-28 11:48:43支付宝支付10元]
2024-09-28 11:48:43 开始打印,排队:39,票券:2409281148387324271702,订单:24092811483873233228,[2024-09-28 11:48:43支付宝支付10元]
2024-09-28 11:48:47 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281148387324020501","queue_number":38,"trade_uid":"24092811483873233228"},{"ticket_no":"2409281148387324271702","queue_number":39,"trade_uid":"24092811483873233228"}]}
2024-09-28 11:48:47 >>>故障排除日志:删除未同步下发订单成功24092811483873233228
2024-09-28 11:48:47 >>>故障排除日志:删除未同步下发订单成功24092811483873233228
2024-09-28 11:48:47 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 11:48:49 >>>回调事件[910,devices/D0362]
2024-09-28 11:48:49 >>>故障排除日志:上一MQTT订单号缓存列表为24092811483873233228|24092811483873233228
2024-09-28 11:48:49 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 11:48:49 开始打印,排队:40,票券:2409281148442617163601,订单:24092811484426166626,[2024-09-28 11:48:51微信支付10元]
2024-09-28 11:48:51 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281148442617163601","queue_number":40,"trade_uid":"24092811484426166626"}]}
2024-09-28 11:48:51 >>>故障排除日志:删除未同步下发订单成功24092811484426166626
2024-09-28 11:48:51 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 11:49:30 >>>回调事件[910,devices/D0362]
2024-09-28 11:49:30 >>>故障排除日志:上一MQTT订单号缓存列表为24092811484426166626
2024-09-28 11:49:30 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 11:49:30 开始打印,排队:41,票券:2409281149249228196101,订单:24092811492492275194,[2024-09-28 11:49:31微信支付10元]
2024-09-28 11:49:32 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281149249228196101","queue_number":41,"trade_uid":"24092811492492275194"}]}
2024-09-28 11:49:32 >>>故障排除日志:删除未同步下发订单成功24092811492492275194
2024-09-28 11:49:32 >>>故障排除日志:终端同步成功后剩余订单列表


===11:53:36===
2024-09-28 11:52:54 >>>回调事件[910,devices/D0362]
2024-09-28 11:52:54 >>>故障排除日志:上一MQTT订单号缓存列表为24092811492492275194
2024-09-28 11:52:54 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 11:52:54 开始打印,排队:42,票券:2409281152502973786801,订单:24092811525029732912,[2024-09-28 11:52:55微信支付10元]
2024-09-28 11:52:54 开始打印,排队:43,票券:2409281152502973952402,订单:24092811525029732912,[2024-09-28 11:52:55微信支付10元]
2024-09-28 11:52:57 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281152502973786801","queue_number":42,"trade_uid":"24092811525029732912"},{"ticket_no":"2409281152502973952402","queue_number":43,"trade_uid":"24092811525029732912"}]}
2024-09-28 11:52:58 >>>故障排除日志:删除未同步下发订单成功24092811525029732912
2024-09-28 11:52:58 >>>故障排除日志:删除未同步下发订单成功24092811525029732912
2024-09-28 11:52:58 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


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


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


===12:57:38===
2024-09-28 12:57:03 >>>回调事件[910,devices/D0362]
2024-09-28 12:57:03 >>>故障排除日志:上一MQTT订单号缓存列表为24092812514892453794
2024-09-28 12:57:03 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 12:57:03 开始打印,排队:50,票券:2409281256533602456301,订单:24092812565336019845,[2024-09-28 12:57:04微信支付10元]
2024-09-28 12:57:05 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281256533602456301","queue_number":50,"trade_uid":"24092812565336019845"}]}
2024-09-28 12:57:05 >>>故障排除日志:删除未同步下发订单成功24092812565336019845
2024-09-28 12:57:05 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 12:57:17 >>>回调事件[910,devices/D0362]
2024-09-28 12:57:17 >>>故障排除日志:上一MQTT订单号缓存列表为24092812565336019845
2024-09-28 12:57:17 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 12:57:17 开始打印,排队:51,票券:2409281257129744429801,订单:24092812571297440184,[2024-09-28 12:57:18微信支付10元]
2024-09-28 12:57:19 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281257129744429801","queue_number":51,"trade_uid":"24092812571297440184"}]}
2024-09-28 12:57:19 >>>故障排除日志:删除未同步下发订单成功24092812571297440184
2024-09-28 12:57:19 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


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


===13:57:42===
2024-09-28 13:57:35 >>>回调事件[910,devices/D0362]
2024-09-28 13:57:35 >>>故障排除日志:上一MQTT订单号缓存列表为24092813460749414687|24092813460749414687
2024-09-28 13:57:35 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 13:57:35 开始打印,排队:59,票券:2409281357299064476201,订单:24092813572990640649,[2024-09-28 13:57:37支付宝支付10元]
2024-09-28 13:57:35 开始打印,排队:60,票券:2409281357299064613102,订单:24092813572990640649,[2024-09-28 13:57:37支付宝支付10元]


===13:58:42===
2024-09-28 13:57:39 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281357299064476201","queue_number":59,"trade_uid":"24092813572990640649"},{"ticket_no":"2409281357299064613102","queue_number":60,"trade_uid":"24092813572990640649"}]}
2024-09-28 13:57:39 >>>故障排除日志:删除未同步下发订单成功24092813572990640649
2024-09-28 13:57:39 >>>故障排除日志:删除未同步下发订单成功24092813572990640649
2024-09-28 13:57:39 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


===14:55:43===
2024-09-28 14:54:43>>>cash read=0A
2024-09-28 14:54:44>>>cash read=3E


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


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


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


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


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


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


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


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


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


===15:58:45===
2024-09-28 15:57:51>>>cash read=00
2024-09-28 15:57:51>>>cash read=818F42
2024-09-28 15:57:51>>>cash write=02
2024-09-28 15:57:51 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-09-28 15:57:51>>>cash read=10
2024-09-28 15:57:51 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-09-28 15:57:51 >>>开始打印,排队号为75,订单号为2409281557510003622334
2024-09-28 15:57:52>>>订单2409281557510003622334写入成功,剩余空间为1680500,占用RAM为608.19140625
删除未同步订单2409281557510003622334
2024-09-28 15:57:54>>>订单2409281557510003622334删除成功,剩余空间为1680500,占用RAM为620.771484375
检测订单目录中>>>
无未同步订单>>>
2024-09-28 15:57:54 >>>当前Ram内存为593.5185546875
定时检测未同步订单启用
2024-09-28 15:57:55>>>cash write=0C
2024-09-28 15:57:55>>>cash read=3E


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


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


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


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


===16:11:46===
2024-09-28 16:11:02 >>>回调事件[910,devices/D0362]
2024-09-28 16:11:02 >>>故障排除日志:上一MQTT订单号缓存列表为24092816090878291190
2024-09-28 16:11:02 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 16:11:02 开始打印,排队:79,票券:2409281610582029412101,订单:24092816105820290595,[2024-09-28 16:11:03支付宝支付10元]
2024-09-28 16:11:04 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281610582029412101","queue_number":79,"trade_uid":"24092816105820290595"}]}
2024-09-28 16:11:04 >>>故障排除日志:删除未同步下发订单成功24092816105820290595
2024-09-28 16:11:04 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 16:11:22 >>>回调事件[910,devices/D0362]
2024-09-28 16:11:22 >>>故障排除日志:上一MQTT订单号缓存列表为24092816105820290595
2024-09-28 16:11:22 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 16:11:22 开始打印,排队:80,票券:2409281611170021163401,订单:24092816111700207138,[2024-09-28 16:11:23微信支付10元]
2024-09-28 16:11:24 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281611170021163401","queue_number":80,"trade_uid":"24092816111700207138"}]}
2024-09-28 16:11:24 >>>故障排除日志:删除未同步下发订单成功24092816111700207138
2024-09-28 16:11:24 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


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


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


===16:43:47===
2024-09-28 16:42:47 >>>回调事件[910,devices/D0362]
2024-09-28 16:42:47 >>>故障排除日志:上一MQTT订单号缓存列表为24092816411769234835
2024-09-28 16:42:47 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 16:42:48 开始打印,排队:87,票券:2409281642430642360601,订单:24092816424306418837,[2024-09-28 16:42:49支付宝支付10元]
2024-09-28 16:42:48 开始打印,排队:88,票券:2409281642430642519002,订单:24092816424306418837,[2024-09-28 16:42:49支付宝支付10元]
2024-09-28 16:42:51 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281642430642360601","queue_number":87,"trade_uid":"24092816424306418837"},{"ticket_no":"2409281642430642519002","queue_number":88,"trade_uid":"24092816424306418837"}]}
2024-09-28 16:42:51 >>>故障排除日志:删除未同步下发订单成功24092816424306418837
2024-09-28 16:42:51 >>>故障排除日志:删除未同步下发订单成功24092816424306418837
2024-09-28 16:42:51 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


===17:07:50===
2024-09-28 17:06:59>>>cash read=29
2024-09-28 17:06:59 >>>回调事件130,cash_status,20029,退钞中
2024-09-28 17:07:00>>>cash read=01
2024-09-28 17:07:04>>>cash read=3E
2024-09-28 17:07:14>>>cash read=00
2024-09-28 17:07:15>>>cash read=29
2024-09-28 17:07:15 >>>回调事件130,cash_status,20029,退钞中
2024-09-28 17:07:17>>>cash read=22
2024-09-28 17:07:17 >>>回调事件130,cash_status,30022,卡钞
2024-09-28 17:07:26>>>cash read=3E
2024-09-28 17:07:29>>>cash read=00
2024-09-28 17:07:30>>>cash read=818F41
2024-09-28 17:07:30>>>cash write=02
2024-09-28 17:07:30 >>>回调事件130,cash_status,10022,进钞中...read money=5
2024-09-28 17:07:30>>>cash read=10
2024-09-28 17:07:30 >>>回调事件130,5,10023,finish Money=5,进钞完成
2024-09-28 17:07:31>>>cash write=0C
2024-09-28 17:07:31>>>cash read=3E
2024-09-28 17:07:32>>>cash read=29
2024-09-28 17:07:32 >>>回调事件130,cash_status,20029,退钞中
2024-09-28 17:07:33>>>cash read=2F29
2024-09-28 17:07:34>>>cash read=3E
2024-09-28 17:07:36>>>cash read=00
2024-09-28 17:07:36>>>cash read=2F29
2024-09-28 17:07:37>>>cash read=01
2024-09-28 17:07:39>>>cash read=2F
2024-09-28 17:07:40>>>cash read=00
2024-09-28 17:07:41>>>cash read=818F41
2024-09-28 17:07:41>>>cash write=02
2024-09-28 17:07:41 >>>回调事件130,cash_status,10022,进钞中...read money=5
2024-09-28 17:07:41>>>cash read=10
2024-09-28 17:07:41 >>>回调事件130,5,10023,finish Money=5,进钞完成
2024-09-28 17:07:41 >>>开始打印,排队号为92,订单号为2409281707300003628077
2024-09-28 17:07:42>>>订单2409281707300003628077写入成功,剩余空间为1678500,占用RAM为610.8408203125
2024-09-28 17:07:43>>>cash read=2F292F
删除未同步订单2409281707300003628077
2024-09-28 17:07:44>>>订单2409281707300003628077删除成功,剩余空间为1679500,占用RAM为626.4892578125
检测订单目录中>>>
无未同步订单>>>
2024-09-28 17:07:44 >>>当前Ram内存为594.8349609375
定时检测未同步订单启用
2024-09-28 17:07:44>>>cash read=818F42
2024-09-28 17:07:44 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-09-28 17:07:45>>>cash read=10
2024-09-28 17:07:45 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-09-28 17:07:45 >>>开始打印,排队号为93,订单号为2409281707450003621906
定时检测未同步订单关闭
2024-09-28 17:07:45>>>订单2409281707450003621906写入成功,剩余空间为1678000,占用RAM为620.2333984375


===17:08:51===
2024-09-28 17:07:48>>>cash write=0C
2024-09-28 17:07:48>>>cash read=3E
定时检测未同步订单关闭
检测订单目录中>>>
无未同步订单>>>


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


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


===17:15:51===
2024-09-28 17:14:49>>>cash read=0A
2024-09-28 17:14:50>>>cash read=3E


===17:16:52===
2024-09-28 17:16:38>>>cash read=00
2024-09-28 17:16:39>>>cash read=818F42
2024-09-28 17:16:39>>>cash write=02
2024-09-28 17:16:39 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-09-28 17:16:39>>>cash read=10
2024-09-28 17:16:39 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-09-28 17:16:39 >>>开始打印,排队号为96,订单号为2409281716390003621142
2024-09-28 17:16:39>>>订单2409281716390003621142写入成功,剩余空间为1680500,占用RAM为608.1220703125
删除未同步订单2409281716390003621142
2024-09-28 17:16:42>>>订单2409281716390003621142删除成功,剩余空间为1680500,占用RAM为620.8857421875
检测订单目录中>>>
无未同步订单>>>
2024-09-28 17:16:42 >>>当前Ram内存为593.48828125
定时检测未同步订单启用
2024-09-28 17:16:42>>>cash write=0C
2024-09-28 17:16:42>>>cash read=3E


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


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


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


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


===17:41:54===
2024-09-28 17:41:07 >>>回调事件[910,devices/D0362]
2024-09-28 17:41:07 >>>故障排除日志:上一MQTT订单号缓存列表为24092817272572810350
2024-09-28 17:41:07 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 17:41:07 开始打印,排队:101,票券:2409281741034027792701,订单:24092817410340274284,[2024-09-28 17:41:09微信支付10元]
2024-09-28 17:41:09 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281741034027792701","queue_number":101,"trade_uid":"24092817410340274284"}]}
2024-09-28 17:41:09 >>>故障排除日志:删除未同步下发订单成功24092817410340274284
2024-09-28 17:41:10 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 17:41:17 >>>回调事件[910,devices/D0362]
2024-09-28 17:41:17 >>>故障排除日志:上一MQTT订单号缓存列表为24092817410340274284
2024-09-28 17:41:17 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 17:41:17 开始打印,排队:102,票券:2409281741124247772901,订单:24092817411242473802,[2024-09-28 17:41:19微信支付10元]
2024-09-28 17:41:19 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281741124247772901","queue_number":102,"trade_uid":"24092817411242473802"}]}
2024-09-28 17:41:19 >>>故障排除日志:删除未同步下发订单成功24092817411242473802
2024-09-28 17:41:19 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 17:41:37 >>>回调事件[910,devices/D0362]
2024-09-28 17:41:37 >>>故障排除日志:上一MQTT订单号缓存列表为24092817411242473802
2024-09-28 17:41:37 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 17:41:37 开始打印,排队:103,票券:2409281741331754445201,订单:24092817413317540724,[2024-09-28 17:41:38微信支付10元]
2024-09-28 17:41:39 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281741331754445201","queue_number":103,"trade_uid":"24092817413317540724"}]}
2024-09-28 17:41:39 >>>故障排除日志:删除未同步下发订单成功24092817413317540724
2024-09-28 17:41:39 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


===18:10:56===
2024-09-28 18:10:51 >>>回调事件[910,devices/D0362]
2024-09-28 18:10:51 >>>故障排除日志:上一MQTT订单号缓存列表为24092818045824036671
2024-09-28 18:10:51 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 18:10:51 开始打印,排队:107,票券:2409281810468958807001,订单:24092818104689583453,[2024-09-28 18:10:52微信支付10元]


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


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


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


===18:15:57===
2024-09-28 18:15:25 >>>回调事件[910,devices/D0362]
2024-09-28 18:15:26 >>>故障排除日志:上一MQTT订单号缓存列表为24092818140467715641
2024-09-28 18:15:26 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 18:15:26 开始打印,排队:111,票券:2409281815198942820501,订单:24092818151989423829,[2024-09-28 18:15:27支付宝支付10元]
2024-09-28 18:15:28 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281815198942820501","queue_number":111,"trade_uid":"24092818151989423829"}]}
2024-09-28 18:15:28 >>>故障排除日志:删除未同步下发订单成功24092818151989423829
2024-09-28 18:15:28 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 18:15:38>>>cash read=00
2024-09-28 18:15:38>>>cash read=818F42
2024-09-28 18:15:38>>>cash write=02
2024-09-28 18:15:39 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-09-28 18:15:39>>>cash read=10
2024-09-28 18:15:39 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-09-28 18:15:39 >>>开始打印,排队号为112,订单号为2409281815390003624432
2024-09-28 18:15:39 >>>开始打印,排队号为113,订单号为2409281815390003624432
2024-09-28 18:15:40>>>订单2409281815390003624432写入成功,剩余空间为1678500,占用RAM为618.2685546875
删除未同步订单2409281815390003624432
2024-09-28 18:15:43>>>订单2409281815390003624432删除成功,剩余空间为1680000,占用RAM为637.4775390625
检测订单目录中>>>
无未同步订单>>>
2024-09-28 18:15:43 >>>当前Ram内存为596.5068359375
定时检测未同步订单启用
2024-09-28 18:15:44>>>cash write=0C
2024-09-28 18:15:44>>>cash read=3E


===18:16:57===
定时检测未同步订单关闭
检测订单目录中>>>
无未同步订单>>>
2024-09-28 18:16:52>>>cash read=0A
2024-09-28 18:16:53>>>cash read=3E


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


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


===18:28:57===
2024-09-28 18:28:25>>>cash read=0A
2024-09-28 18:28:26>>>cash read=3E


===18:32:58===
2024-09-28 18:32:14>>>cash read=00
2024-09-28 18:32:15 >>>回调事件[910,devices/D0362]
2024-09-28 18:32:15 >>>故障排除日志:上一MQTT订单号缓存列表为24092818243188068365
2024-09-28 18:32:15 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 18:32:15 开始打印,排队:116,票券:2409281832104493082001,订单:24092818321044926523,[2024-09-28 18:32:17微信支付10元]
2024-09-28 18:32:17>>>cash read=818F42
2024-09-28 18:32:17>>>cash write=02
2024-09-28 18:32:17 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-09-28 18:32:17 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281832104493082001","queue_number":116,"trade_uid":"24092818321044926523"}]}
2024-09-28 18:32:17 >>>故障排除日志:删除未同步下发订单成功24092818321044926523
2024-09-28 18:32:17 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 18:32:18>>>cash read=10
2024-09-28 18:32:18 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-09-28 18:32:18 >>>开始打印,排队号为117,订单号为2409281832180003623571
2024-09-28 18:32:18>>>订单2409281832180003623571写入成功,剩余空间为1679000,占用RAM为613.013671875
删除未同步订单2409281832180003623571
2024-09-28 18:32:20>>>订单2409281832180003623571删除成功,剩余空间为1680000,占用RAM为624.4111328125
检测订单目录中>>>
无未同步订单>>>
2024-09-28 18:32:20 >>>当前Ram内存为595.935546875
定时检测未同步订单启用
2024-09-28 18:32:21>>>cash write=0C
2024-09-28 18:32:21>>>cash read=3E


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


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


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


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


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


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


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


===18:56:02===
2024-09-28 18:55:55 >>>回调事件[910,devices/D0362]
2024-09-28 18:55:55 >>>故障排除日志:上一MQTT订单号缓存列表为24092818531958583136|24092818531958583136
2024-09-28 18:55:55 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 18:55:55 开始打印,排队:126,票券:2409281855457208946701,订单:24092818554572082771,[2024-09-28 18:55:57微信支付10元]
2024-09-28 18:55:55 开始打印,排队:127,票券:2409281855457209128202,订单:24092818554572082771,[2024-09-28 18:55:57微信支付10元]


===18:57:02===
2024-09-28 18:55:59 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281855457208946701","queue_number":126,"trade_uid":"24092818554572082771"},{"ticket_no":"2409281855457209128202","queue_number":127,"trade_uid":"24092818554572082771"}]}
2024-09-28 18:55:59 >>>故障排除日志:删除未同步下发订单成功24092818554572082771
2024-09-28 18:55:59 >>>故障排除日志:删除未同步下发订单成功24092818554572082771
2024-09-28 18:55:59 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


===19:29:05===
2024-09-28 19:28:59 >>>回调事件[910,devices/D0362]
2024-09-28 19:29:00 >>>故障排除日志:上一MQTT订单号缓存列表为24092819174146613318
2024-09-28 19:29:00 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 19:29:00 开始打印,排队:132,票券:2409281928533646837501,订单:24092819285336464006,[2024-09-28 19:29:01微信支付10元]


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


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


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


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


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


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


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


===19:58:06===
2024-09-28 19:57:23 >>>回调事件[910,devices/D0362]
2024-09-28 19:57:23 >>>故障排除日志:上一MQTT订单号缓存列表为24092819565537694297
2024-09-28 19:57:23 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 19:57:23 开始打印,排队:142,票券:2409281957179118663401,订单:24092819571791180738,[2024-09-28 19:57:24支付宝支付10元]
2024-09-28 19:57:25 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281957179118663401","queue_number":142,"trade_uid":"24092819571791180738"}]}
2024-09-28 19:57:25 >>>故障排除日志:删除未同步下发订单成功24092819571791180738
2024-09-28 19:57:25 >>>故障排除日志:终端同步成功后剩余订单列表


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


===20:13:07===
2024-09-28 20:13:02 >>>回调事件[910,devices/D0362]
2024-09-28 20:13:02 >>>故障排除日志:上一MQTT订单号缓存列表为24092820112543568407
2024-09-28 20:13:02 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 20:13:02 开始打印,排队:144,票券:2409282012534723069501,订单:24092820125347227113,[2024-09-28 20:13:03微信支付10元]


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


===20:18:07===
2024-09-28 20:17:06>>>cash read=00
2024-09-28 20:17:07>>>cash read=2F29
2024-09-28 20:17:09>>>cash read=3E


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


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


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


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


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


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


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


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


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


===21:22:09===
2024-09-28 21:21:15>>>cash read=00
2024-09-28 21:21:16>>>cash read=29
2024-09-28 21:21:16 >>>回调事件130,cash_status,20029,退钞中
2024-09-28 21:21:16>>>cash read=2F29
2024-09-28 21:21:17>>>cash read=01
2024-09-28 21:21:18>>>cash read=2F
2024-09-28 21:21:19>>>cash read=3E
2024-09-28 21:21:26>>>cash read=00
2024-09-28 21:21:26>>>cash read=818F42
2024-09-28 21:21:26>>>cash write=02
2024-09-28 21:21:26 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-09-28 21:21:26>>>cash read=10
2024-09-28 21:21:26 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-09-28 21:21:26 >>>开始打印,排队号为155,订单号为2409282121260003625767
2024-09-28 21:21:27>>>订单2409282121260003625767写入成功,剩余空间为1679500,占用RAM为610.400390625
删除未同步订单2409282121260003625767
2024-09-28 21:21:29>>>订单2409282121260003625767删除成功,剩余空间为1680500,占用RAM为622.33984375
检测订单目录中>>>
无未同步订单>>>
2024-09-28 21:21:29 >>>当前Ram内存为594.7109375
定时检测未同步订单启用
2024-09-28 21:21:30>>>cash write=0C
2024-09-28 21:21:30>>>cash read=3E


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


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


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


===21:36:10===
2024-09-28 21:35:47 >>>回调事件[910,devices/D0362]
2024-09-28 21:35:47 >>>故障排除日志:上一MQTT订单号缓存列表为24092821332540953228|24092821332540953228
2024-09-28 21:35:47 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 21:35:47 开始打印,排队:159,票券:2409282135435225203401,订单:24092821354352247898,[2024-09-28 21:35:49支付宝支付15元]
2024-09-28 21:35:49 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409282135435225203401","queue_number":159,"trade_uid":"24092821354352247898"}]}
2024-09-28 21:35:49 >>>故障排除日志:删除未同步下发订单成功24092821354352247898
2024-09-28 21:35:50 >>>故障排除日志:终端同步成功后剩余订单列表


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


===21:53:11===
2024-09-28 21:53:06 >>>回调事件[910,devices/D0362]
2024-09-28 21:53:07 >>>故障排除日志:上一MQTT订单号缓存列表为24092821512834261292
2024-09-28 21:53:07 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 21:53:07 开始打印,排队:161,票券:2409282153015089722801,订单:24092821530150893580,[2024-09-28 21:53:08支付宝支付30元]


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


===22:08:12===
2024-09-28 22:08:05>>>cash read=0A
2024-09-28 22:08:06>>>cash read=3E


===22:09:12===
2024-09-28 22:08:22>>>cash read=0A
2024-09-28 22:08:23>>>cash read=3E


===23:32:13===
2024-09-28 23:31:44>>>cash read=0A
2024-09-28 23:31:45>>>cash read=3E