TLClient_JSSCOM_LuatOS-Air_V3205_RDA8910_RFTTS_0xe0000,2.5.1,869298054268297,27157487696971,
poweron reason:0

===00:07:25===
2024-07-21 00:07:05>>>cash read=0A
2024-07-21 00:07:06>>>cash read=3E


===00:41:25===
2024-07-21 00:40:51>>>cash read=9E
2024-07-21 00:40:52>>>cash read=3E


===01:11:26===
2024-07-21 01:10:38>>>cash read=0A
2024-07-21 01:10:39>>>cash read=3E


===02:21:26===
2024-07-21 02:20:42>>>cash read=0A
2024-07-21 02:20:43>>>cash read=3E


===02:35:26===
2024-07-21 02:34:26>>>cash read=9E
2024-07-21 02:34:27>>>cash read=3E


===03:15:27===
2024-07-21 03:14:30>>>cash read=9E
2024-07-21 03:14:31>>>cash read=3E


===04:12:27===
2024-07-21 04:11:47>>>cash read=0A
2024-07-21 04:11:49>>>cash read=3E


===06:48:27===
2024-07-21 06:47:48>>>cash read=9E
2024-07-21 06:47:49>>>cash read=3E
2024-07-21 06:48:14>>>cash read=9E
2024-07-21 06:48:15>>>cash read=3E


===07:26:28===
2024-07-21 07:25:44 >>>回调事件[910,devices/S2040]
隔日重置时间戳true
隔日清空未同步下发列表true
2024-07-21 07:25:44 >>>故障排除日志:上一MQTT订单号缓存列表为24072020333060267410
2024-07-21 07:25:44 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 07:25:44 开始打印,排队:1,票券:2407210725362041205401,订单:24072107253620407726,[2024-07-21 07:25:36微信支付10元]
2024-07-21 07:25:47 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407210725362041205401","queue_number":1,"trade_uid":"24072107253620407726"}]}
2024-07-21 07:25:47 >>>故障排除日志:删除未同步下发订单成功24072107253620407726
2024-07-21 07:25:47 >>>故障排除日志:终端同步成功后剩余订单列表
2024-07-21 07:25:47 收到下发指令:叫号1>>>


===07:45:28===
2024-07-21 07:44:55 >>>回调事件[910,devices/S2040]
上一时间戳为1721517944
2024-07-21 07:44:55 >>>故障排除日志:上一MQTT订单号缓存列表为24072107253620407726
2024-07-21 07:44:55 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 07:44:55 开始打印,排队:2,票券:2407210744484068967301,订单:24072107444840685278,[2024-07-21 07:44:48微信支付10元]
2024-07-21 07:44:57 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407210744484068967301","queue_number":2,"trade_uid":"24072107444840685278"}]}
2024-07-21 07:44:57 >>>故障排除日志:删除未同步下发订单成功24072107444840685278
2024-07-21 07:44:57 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


===08:09:29===
2024-07-21 08:08:43>>>cash read=00
2024-07-21 08:08:43>>>cash read=818F42
2024-07-21 08:08:43>>>cash write=02
2024-07-21 08:08:43 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-07-21 08:08:44>>>cash read=10
2024-07-21 08:08:44 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-07-21 08:08:44 >>>开始打印,排队号为5,订单号为2407210808440020403260
2024-07-21 08:08:44>>>订单2407210808440020403260写入成功,剩余空间为1675000,占用RAM为599.828125
删除未同步订单2407210808440020403260
2024-07-21 08:08:46>>>订单2407210808440020403260删除成功,剩余空间为1675000,占用RAM为613.853515625
检测订单目录中>>>
无未同步订单>>>
2024-07-21 08:08:46 >>>当前Ram内存为585.2138671875
定时检测未同步订单启用
2024-07-21 08:08:46>>>cash read=818F42
2024-07-21 08:08:46 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-07-21 08:08:47>>>cash read=10
2024-07-21 08:08:47 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-07-21 08:08:47 >>>开始打印,排队号为6,订单号为2407210808470020408630
定时检测未同步订单关闭
2024-07-21 08:08:47>>>订单2407210808470020408630写入成功,剩余空间为1673500,占用RAM为603.900390625
删除未同步订单2407210808470020408630
2024-07-21 08:08:49>>>订单2407210808470020408630删除成功,剩余空间为1674500,占用RAM为618.162109375
检测订单目录中>>>
无未同步订单>>>
2024-07-21 08:08:49 >>>当前Ram内存为586.91796875
定时检测未同步订单启用
2024-07-21 08:08:50>>>cash write=0C
2024-07-21 08:08:50>>>cash read=3E
2024-07-21 08:08:57 >>>回调事件[910,devices/S2040]
2024-07-21 08:08:58 >>>故障排除日志:上一MQTT订单号缓存列表为24072108053983460885
2024-07-21 08:08:58 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 08:08:58 开始打印,排队:7,票券:2407210808513915458001,订单:24072108085139149789,[2024-07-21 08:08:51微信支付10元]
2024-07-21 08:08:59 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407210808513915458001","queue_number":7,"trade_uid":"24072108085139149789"}]}
2024-07-21 08:09:00 >>>故障排除日志:删除未同步下发订单成功24072108085139149789
2024-07-21 08:09:00 >>>故障排除日志:终端同步成功后剩余订单列表


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


===08:12:30===
2024-07-21 08:12:27 >>>回调事件[910,devices/S2040]
2024-07-21 08:12:27 >>>故障排除日志:上一MQTT订单号缓存列表为24072108085139149789
2024-07-21 08:12:27 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 08:12:27 开始打印,排队:8,票券:2407210812178528618201,订单:24072108121785282361,[2024-07-21 08:12:17微信支付10元]


===08:13:30===
2024-07-21 08:12:29 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407210812178528618201","queue_number":8,"trade_uid":"24072108121785282361"}]}
2024-07-21 08:12:29 >>>故障排除日志:删除未同步下发订单成功24072108121785282361
2024-07-21 08:12:29 >>>故障排除日志:终端同步成功后剩余订单列表


===08:15:30===
2024-07-21 08:14:55 >>>回调事件[910,devices/S2040]
2024-07-21 08:14:55 >>>故障排除日志:上一MQTT订单号缓存列表为24072108121785282361
2024-07-21 08:14:55 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 08:14:55 开始打印,排队:9,票券:2407210814479594874101,订单:24072108144795943063,[2024-07-21 08:14:47微信支付10元]
2024-07-21 08:14:57 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407210814479594874101","queue_number":9,"trade_uid":"24072108144795943063"}]}
2024-07-21 08:14:57 >>>故障排除日志:删除未同步下发订单成功24072108144795943063
2024-07-21 08:14:57 >>>故障排除日志:终端同步成功后剩余订单列表


===08:20:31===
2024-07-21 08:19:39 >>>回调事件[910,devices/S2040]
2024-07-21 08:19:39 >>>故障排除日志:上一MQTT订单号缓存列表为24072108144795943063
2024-07-21 08:19:39 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 08:19:39 开始打印,排队:10,票券:2407210819317212177101,订单:24072108193172117641,[2024-07-21 08:19:31微信支付10元]
2024-07-21 08:19:41 >>>回调事件[910,devices/S2040]
2024-07-21 08:19:41 >>>故障排除日志:上一MQTT订单号缓存列表为24072108193172117641
2024-07-21 08:19:41 >>>故障排除日志:终端未同步成功订单列表001024072108193172117641
已接收过此消息,票券号为2407210819317212177101,排队号为10
2024-07-21 08:19:41 开始打印,排队:11,票券:2407210819330291036701,订单:24072108193302904037,[2024-07-21 08:19:33支付宝支付10元]
2024-07-21 08:19:43 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407210819317212177101","queue_number":10,"trade_uid":"24072108193172117641"}]}
2024-07-21 08:19:43 >>>故障排除日志:删除未同步下发订单成功24072108193172117641
2024-07-21 08:19:43 >>>故障排除日志:终端同步成功后剩余订单列表001124072108193302904037
2024-07-21 08:19:43 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407210819317212177101","queue_number":10,"trade_uid":"24072108193172117641"},{"ticket_no":"2407210819330291036701","queue_number":11,"trade_uid":"24072108193302904037"}]}
2024-07-21 08:19:43 >>>故障排除日志:删除未同步下发订单成功24072108193302904037
2024-07-21 08:19:44 >>>故障排除日志:终端同步成功后剩余订单列表
2024-07-21 08:20:08 >>>回调事件[910,devices/S2040]
2024-07-21 08:20:08 >>>故障排除日志:上一MQTT订单号缓存列表为24072108193172117641|24072108193302904037
2024-07-21 08:20:08 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 08:20:08 开始打印,排队:12,票券:2407210820000648722401,订单:24072108200006482391,[2024-07-21 08:20:00微信支付10元]
2024-07-21 08:20:10 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407210820000648722401","queue_number":12,"trade_uid":"24072108200006482391"}]}
2024-07-21 08:20:10 >>>故障排除日志:删除未同步下发订单成功24072108200006482391
2024-07-21 08:20:10 >>>故障排除日志:终端同步成功后剩余订单列表


===08:28:31===
2024-07-21 08:28:29>>>cash read=00


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


===08:30:31===
定时检测未同步订单关闭
检测订单目录中>>>
无未同步订单>>>
2024-07-21 08:30:04>>>cash read=9E
2024-07-21 08:30:05>>>cash read=3E


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


===08:43:32===
2024-07-21 08:42:56 >>>回调事件[910,devices/S2040]
2024-07-21 08:42:56 >>>故障排除日志:上一MQTT订单号缓存列表为24072108361982742713
2024-07-21 08:42:56 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 08:42:56 开始打印,排队:15,票券:2407210842504467405801,订单:24072108425044669202,[2024-07-21 08:42:50微信支付10元]
2024-07-21 08:42:59 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407210842504467405801","queue_number":15,"trade_uid":"24072108425044669202"}]}
2024-07-21 08:42:59 >>>故障排除日志:删除未同步下发订单成功24072108425044669202
2024-07-21 08:42:59 >>>故障排除日志:终端同步成功后剩余订单列表
2024-07-21 08:43:09 >>>回调事件[910,devices/S2040]
2024-07-21 08:43:09 >>>故障排除日志:上一MQTT订单号缓存列表为24072108425044669202
2024-07-21 08:43:09 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 08:43:09 开始打印,排队:16,票券:2407210843019993050501,订单:24072108430199926884,[2024-07-21 08:43:01微信支付10元]
2024-07-21 08:43:10 >>>回调事件[910,devices/S2040]
2024-07-21 08:43:11 >>>故障排除日志:上一MQTT订单号缓存列表为24072108430199926884
2024-07-21 08:43:11 >>>故障排除日志:终端未同步成功订单列表001624072108430199926884
2024-07-21 08:43:11 开始打印,排队:17,票券:2407210843015406222701,订单:24072108430154057440,[2024-07-21 08:43:01支付宝支付10元]
已接收过此消息,票券号为2407210843019993050501,排队号为16
2024-07-21 08:43:13 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407210843019993050501","queue_number":16,"trade_uid":"24072108430199926884"}]}
2024-07-21 08:43:13 >>>故障排除日志:删除未同步下发订单成功24072108430199926884
2024-07-21 08:43:13 >>>故障排除日志:终端同步成功后剩余订单列表001724072108430154057440
2024-07-21 08:43:13 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407210843015406222701","queue_number":17,"trade_uid":"24072108430154057440"},{"ticket_no":"2407210843019993050501","queue_number":16,"trade_uid":"24072108430199926884"}]}
2024-07-21 08:43:13 >>>故障排除日志:删除未同步下发订单成功24072108430154057440
2024-07-21 08:43:13 >>>故障排除日志:终端同步成功后剩余订单列表


===08:47:32===
2024-07-21 08:46:40>>>cash read=0A
2024-07-21 08:46:41>>>cash read=3E


===08:54:32===
2024-07-21 08:53:58 >>>回调事件[910,devices/S2040]
2024-07-21 08:53:58 >>>故障排除日志:上一MQTT订单号缓存列表为24072108430154057440|24072108430199926884
2024-07-21 08:53:58 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 08:53:58 开始打印,排队:18,票券:2407210853533909725901,订单:24072108535339090492,[2024-07-21 08:53:53微信支付10元]
2024-07-21 08:54:00 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407210853533909725901","queue_number":18,"trade_uid":"24072108535339090492"}]}
2024-07-21 08:54:00 >>>故障排除日志:删除未同步下发订单成功24072108535339090492
2024-07-21 08:54:00 >>>故障排除日志:终端同步成功后剩余订单列表


===08:59:33===
2024-07-21 08:59:03 >>>回调事件[910,devices/S2040]
2024-07-21 08:59:03 >>>故障排除日志:上一MQTT订单号缓存列表为24072108535339090492
2024-07-21 08:59:03 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 08:59:03 开始打印,排队:19,票券:2407210858568570259701,订单:24072108585685697852,[2024-07-21 08:58:56微信支付10元]
2024-07-21 08:59:03 开始打印,排队:20,票券:2407210858568570408402,订单:24072108585685697852,[2024-07-21 08:58:56微信支付10元]
2024-07-21 08:59:07 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407210858568570259701","queue_number":19,"trade_uid":"24072108585685697852"},{"ticket_no":"2407210858568570408402","queue_number":20,"trade_uid":"24072108585685697852"}]}
2024-07-21 08:59:07 >>>故障排除日志:删除未同步下发订单成功24072108585685697852
2024-07-21 08:59:07 >>>故障排除日志:删除未同步下发订单成功24072108585685697852
2024-07-21 08:59:07 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


===09:10:33===
2024-07-21 09:10:15>>>cash read=00
2024-07-21 09:10:15>>>cash read=818F42
2024-07-21 09:10:15>>>cash write=02
2024-07-21 09:10:15 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-07-21 09:10:15>>>cash read=10
2024-07-21 09:10:15 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-07-21 09:10:15 >>>开始打印,排队号为24,订单号为2407210910150020405023
2024-07-21 09:10:16>>>订单2407210910150020405023写入成功,剩余空间为1675000,占用RAM为599.7783203125
删除未同步订单2407210910150020405023
2024-07-21 09:10:18>>>订单2407210910150020405023删除成功,剩余空间为1675000,占用RAM为617.0029296875
检测订单目录中>>>
无未同步订单>>>
2024-07-21 09:10:18 >>>当前Ram内存为585.1865234375
定时检测未同步订单启用
2024-07-21 09:10:19>>>cash write=0C
2024-07-21 09:10:19>>>cash read=3E


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


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


===09:26:34===
2024-07-21 09:25:57>>>cash read=00
2024-07-21 09:25:58>>>cash read=29
2024-07-21 09:25:58 >>>回调事件130,cash_status,20029,退钞中
2024-07-21 09:25:59>>>cash read=22
2024-07-21 09:25:59 >>>回调事件130,cash_status,30022,卡钞
2024-07-21 09:26:19>>>cash read=2222


===09:30:34===
2024-07-21 09:29:39>>>cash read=2F
2024-07-21 09:29:40>>>cash read=3E
2024-07-21 09:29:49>>>cash read=00
2024-07-21 09:29:50>>>cash read=818F43
2024-07-21 09:29:50>>>cash write=02
2024-07-21 09:29:50 >>>回调事件130,cash_status,10022,进钞中...read money=20
2024-07-21 09:29:51>>>cash read=10
2024-07-21 09:29:51 >>>回调事件130,20,10023,finish Money=20,进钞完成
2024-07-21 09:29:51 >>>开始打印,排队号为26,订单号为2407210929510020404111
2024-07-21 09:29:51 >>>开始打印,排队号为27,订单号为2407210929510020404111
2024-07-21 09:29:52>>>订单2407210929510020404111写入成功,剩余空间为1673500,占用RAM为606.01953125
删除未同步订单2407210929510020404111
2024-07-21 09:29:55>>>订单2407210929510020404111删除成功,剩余空间为1675000,占用RAM为627.5888671875
检测订单目录中>>>
无未同步订单>>>
2024-07-21 09:29:55 >>>当前Ram内存为584.2431640625
定时检测未同步订单启用
2024-07-21 09:29:56>>>cash write=0C
2024-07-21 09:29:56>>>cash read=3E


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


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


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


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


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


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


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


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


===10:21:36===
2024-07-21 10:20:35 >>>回调事件[910,devices/S2040]
2024-07-21 10:20:35 >>>故障排除日志:上一MQTT订单号缓存列表为24072110192267603710
2024-07-21 10:20:35 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 10:20:35 开始打印,排队:35,票券:2407211020293795186101,订单:24072110202937948314,[2024-07-21 10:20:29微信支付10元]
2024-07-21 10:20:37 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407211020293795186101","queue_number":35,"trade_uid":"24072110202937948314"}]}
2024-07-21 10:20:37 >>>故障排除日志:删除未同步下发订单成功24072110202937948314
2024-07-21 10:20:37 >>>故障排除日志:终端同步成功后剩余订单列表
2024-07-21 10:21:19 >>>回调事件[910,devices/S2040]
2024-07-21 10:21:19 >>>故障排除日志:上一MQTT订单号缓存列表为24072110202937948314
2024-07-21 10:21:19 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 10:21:19 开始打印,排队:36,票券:2407211021132846847901,订单:24072110211328463183,[2024-07-21 10:21:13微信支付10元]
2024-07-21 10:21:21 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407211021132846847901","queue_number":36,"trade_uid":"24072110211328463183"}]}
2024-07-21 10:21:21 >>>故障排除日志:删除未同步下发订单成功24072110211328463183
2024-07-21 10:21:21 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


===10:34:37===
2024-07-21 10:34:18>>>cash read=29
2024-07-21 10:34:18 >>>回调事件130,cash_status,20029,退钞中
2024-07-21 10:34:19>>>cash read=00
2024-07-21 10:34:20>>>cash read=818F42
2024-07-21 10:34:20>>>cash write=02
2024-07-21 10:34:20 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-07-21 10:34:20>>>cash read=10
2024-07-21 10:34:20 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-07-21 10:34:21 >>>开始打印,排队号为39,订单号为2407211034210020407902
2024-07-21 10:34:21>>>订单2407211034210020407902写入成功,剩余空间为1674000,占用RAM为600.919921875
删除未同步订单2407211034210020407902
2024-07-21 10:34:23>>>订单2407211034210020407902删除成功,剩余空间为1675000,占用RAM为615.5654296875
检测订单目录中>>>
无未同步订单>>>
2024-07-21 10:34:23 >>>当前Ram内存为585.30859375
定时检测未同步订单启用
2024-07-21 10:34:24>>>cash write=0C
2024-07-21 10:34:24>>>cash read=3E


===10:35:37===
定时检测未同步订单关闭
检测订单目录中>>>
无未同步订单>>>
2024-07-21 10:35:23 >>>回调事件[910,devices/S2040]
2024-07-21 10:35:23 >>>故障排除日志:上一MQTT订单号缓存列表为24072110265323532470
2024-07-21 10:35:23 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 10:35:23 开始打印,排队:40,票券:2407211035051639283201,订单:24072110350516388239,[2024-07-21 10:35:05支付宝支付10元]
2024-07-21 10:35:25 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407211035051639283201","queue_number":40,"trade_uid":"24072110350516388239"}]}
2024-07-21 10:35:25 >>>故障排除日志:删除未同步下发订单成功24072110350516388239
2024-07-21 10:35:26 >>>故障排除日志:终端同步成功后剩余订单列表


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


===10:48:37===
2024-07-21 10:48:04>>>cash read=0A
2024-07-21 10:48:05>>>cash read=3E


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


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


===10:52:38===
2024-07-21 10:51:38 >>>回调事件[910,devices/S2040]
2024-07-21 10:51:38 >>>故障排除日志:上一MQTT订单号缓存列表为24072110511843095018
2024-07-21 10:51:38 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 10:51:38 开始打印,排队:44,票券:2407211051337270582601,订单:24072110513372701279,[2024-07-21 10:51:33微信支付10元]
2024-07-21 10:51:40 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407211051337270582601","queue_number":44,"trade_uid":"24072110513372701279"}]}
2024-07-21 10:51:40 >>>故障排除日志:删除未同步下发订单成功24072110513372701279
2024-07-21 10:51:40 >>>故障排除日志:终端同步成功后剩余订单列表
2024-07-21 10:52:03 >>>回调事件[910,devices/S2040]
2024-07-21 10:52:03 >>>故障排除日志:上一MQTT订单号缓存列表为24072110513372701279
2024-07-21 10:52:03 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 10:52:03 开始打印,排队:45,票券:2407211051563767852101,订单:24072110515637674527,[2024-07-21 10:51:56微信支付10元]
2024-07-21 10:52:05 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407211051563767852101","queue_number":45,"trade_uid":"24072110515637674527"}]}
2024-07-21 10:52:05 >>>故障排除日志:删除未同步下发订单成功24072110515637674527
2024-07-21 10:52:05 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


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


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


===11:47:39===
2024-07-21 11:47:23>>>cash read=9E
2024-07-21 11:47:24>>>cash read=3E


===11:48:40===
2024-07-21 11:47:40 >>>回调事件[910,devices/S2040]
2024-07-21 11:47:40 >>>故障排除日志:上一MQTT订单号缓存列表为24072111273657354261
2024-07-21 11:47:40 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 11:47:40 开始打印,排队:52,票券:2407211147335133453201,订单:24072111473351330731,[2024-07-21 11:47:33微信支付10元]
2024-07-21 11:47:42 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407211147335133453201","queue_number":52,"trade_uid":"24072111473351330731"}]}
2024-07-21 11:47:42 >>>故障排除日志:删除未同步下发订单成功24072111473351330731
2024-07-21 11:47:42 >>>故障排除日志:终端同步成功后剩余订单列表


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


===12:07:40===
2024-07-21 12:06:56 >>>回调事件[910,devices/S2040]
2024-07-21 12:06:56 >>>故障排除日志:上一MQTT订单号缓存列表为24072112050512599015
2024-07-21 12:06:56 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 12:06:56 开始打印,排队:54,票券:2407211206506940235201,订单:24072112065069398871,[2024-07-21 12:06:50支付宝支付10元]
2024-07-21 12:06:58 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407211206506940235201","queue_number":54,"trade_uid":"24072112065069398871"}]}
2024-07-21 12:06:58 >>>故障排除日志:删除未同步下发订单成功24072112065069398871
2024-07-21 12:06:58 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


===12:37:41===
2024-07-21 12:37:03 >>>回调事件[910,devices/S2040]
2024-07-21 12:37:03 >>>故障排除日志:上一MQTT订单号缓存列表为24072112334270914398
2024-07-21 12:37:03 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 12:37:03 开始打印,排队:58,票券:2407211236580398481801,订单:24072112365803981156,[2024-07-21 12:36:58微信支付10元]
2024-07-21 12:37:03 开始打印,排队:59,票券:2407211236580398627502,订单:24072112365803981156,[2024-07-21 12:36:58微信支付10元]
2024-07-21 12:37:07 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407211236580398481801","queue_number":58,"trade_uid":"24072112365803981156"},{"ticket_no":"2407211236580398627502","queue_number":59,"trade_uid":"24072112365803981156"}]}
2024-07-21 12:37:07 >>>故障排除日志:删除未同步下发订单成功24072112365803981156
2024-07-21 12:37:07 >>>故障排除日志:删除未同步下发订单成功24072112365803981156
2024-07-21 12:37:07 >>>故障排除日志:终端同步成功后剩余订单列表
2024-07-21 12:37:32 >>>回调事件[910,devices/S2040]
2024-07-21 12:37:32 >>>故障排除日志:上一MQTT订单号缓存列表为24072112365803981156|24072112365803981156
2024-07-21 12:37:32 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 12:37:32 开始打印,排队:60,票券:2407211237256571858101,订单:24072112372565714340,[2024-07-21 12:37:25支付宝支付10元]
2024-07-21 12:37:34 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407211237256571858101","queue_number":60,"trade_uid":"24072112372565714340"}]}
2024-07-21 12:37:34 >>>故障排除日志:删除未同步下发订单成功24072112372565714340
2024-07-21 12:37:34 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


===12:59:42===
2024-07-21 12:58:50 >>>回调事件[910,devices/S2040]
2024-07-21 12:58:50 >>>故障排除日志:上一MQTT订单号缓存列表为24072112422546347905
2024-07-21 12:58:50 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 12:58:50 开始打印,排队:63,票券:2407211258393424062501,订单:24072112583934235638,[2024-07-21 12:58:39微信支付10元]
2024-07-21 12:58:52 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407211258393424062501","queue_number":63,"trade_uid":"24072112583934235638"}]}
2024-07-21 12:58:52 >>>故障排除日志:删除未同步下发订单成功24072112583934235638
2024-07-21 12:58:52 >>>故障排除日志:终端同步成功后剩余订单列表


===13:03:42===
2024-07-21 13:03:32 >>>回调事件[910,devices/S2040]
2024-07-21 13:03:32 >>>故障排除日志:上一MQTT订单号缓存列表为24072112583934235638
2024-07-21 13:03:32 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 13:03:32 开始打印,排队:64,票券:2407211303262304802601,订单:24072113032623041909,[2024-07-21 13:03:26微信支付10元]
2024-07-21 13:03:34 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407211303262304802601","queue_number":64,"trade_uid":"24072113032623041909"}]}
2024-07-21 13:03:34 >>>故障排除日志:删除未同步下发订单成功24072113032623041909
2024-07-21 13:03:34 >>>故障排除日志:终端同步成功后剩余订单列表


===13:06:42===
2024-07-21 13:05:58 >>>回调事件[910,devices/S2040]
2024-07-21 13:05:58 >>>故障排除日志:上一MQTT订单号缓存列表为24072113032623041909
2024-07-21 13:05:58 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 13:05:58 开始打印,排队:65,票券:2407211305502203372601,订单:24072113055022023109,[2024-07-21 13:05:50微信支付10元]
2024-07-21 13:06:00 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407211305502203372601","queue_number":65,"trade_uid":"24072113055022023109"}]}
2024-07-21 13:06:00 >>>故障排除日志:删除未同步下发订单成功24072113055022023109
2024-07-21 13:06:00 >>>故障排除日志:终端同步成功后剩余订单列表
2024-07-21 13:06:02 >>>回调事件[910,devices/S2040]
2024-07-21 13:06:02 >>>故障排除日志:上一MQTT订单号缓存列表为24072113055022023109
2024-07-21 13:06:02 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 13:06:02 开始打印,排队:66,票券:2407211305567477284001,订单:24072113055674769205,[2024-07-21 13:05:56微信支付10元]
2024-07-21 13:06:04 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407211305567477284001","queue_number":66,"trade_uid":"24072113055674769205"}]}
2024-07-21 13:06:04 >>>故障排除日志:删除未同步下发订单成功24072113055674769205
2024-07-21 13:06:04 >>>故障排除日志:终端同步成功后剩余订单列表


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


===13:12:42===
2024-07-21 13:11:45 >>>回调事件[910,devices/S2040]
2024-07-21 13:11:45 >>>故障排除日志:上一MQTT订单号缓存列表为24072113070296331851
2024-07-21 13:11:45 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 13:11:45 开始打印,排队:68,票券:2407211311358591756001,订单:24072113113585913006,[2024-07-21 13:11:35支付宝支付10元]
2024-07-21 13:11:47 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407211311358591756001","queue_number":68,"trade_uid":"24072113113585913006"}]}
2024-07-21 13:11:47 >>>故障排除日志:删除未同步下发订单成功24072113113585913006
2024-07-21 13:11:47 >>>故障排除日志:终端同步成功后剩余订单列表
2024-07-21 13:12:07 >>>回调事件[910,devices/S2040]
2024-07-21 13:12:07 >>>故障排除日志:上一MQTT订单号缓存列表为24072113113585913006
2024-07-21 13:12:07 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 13:12:07 开始打印,排队:69,票券:2407211312008937026401,订单:24072113120089365489,[2024-07-21 13:12:00微信支付10元]
2024-07-21 13:12:09 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407211312008937026401","queue_number":69,"trade_uid":"24072113120089365489"}]}
2024-07-21 13:12:09 >>>故障排除日志:删除未同步下发订单成功24072113120089365489
2024-07-21 13:12:09 >>>故障排除日志:终端同步成功后剩余订单列表


===13:17:43===
2024-07-21 13:16:55 >>>回调事件[910,devices/S2040]
2024-07-21 13:16:55 >>>故障排除日志:上一MQTT订单号缓存列表为24072113120089365489
2024-07-21 13:16:55 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 13:16:55 开始打印,排队:70,票券:2407211316505150977001,订单:24072113165051503730,[2024-07-21 13:16:50微信支付10元]
2024-07-21 13:16:57 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407211316505150977001","queue_number":70,"trade_uid":"24072113165051503730"}]}
2024-07-21 13:16:57 >>>故障排除日志:删除未同步下发订单成功24072113165051503730
2024-07-21 13:16:57 >>>故障排除日志:终端同步成功后剩余订单列表


===13:23:43===
2024-07-21 13:23:26 >>>回调事件[910,devices/S2040]
2024-07-21 13:23:26 >>>故障排除日志:上一MQTT订单号缓存列表为24072113165051503730
2024-07-21 13:23:26 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 13:23:26 开始打印,排队:71,票券:2407211323209728590201,订单:24072113232097281934,[2024-07-21 13:23:20微信支付10元]
2024-07-21 13:23:26 开始打印,排队:72,票券:2407211323209728745902,订单:24072113232097281934,[2024-07-21 13:23:20微信支付10元]
2024-07-21 13:23:30 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407211323209728590201","queue_number":71,"trade_uid":"24072113232097281934"},{"ticket_no":"2407211323209728745902","queue_number":72,"trade_uid":"24072113232097281934"}]}
2024-07-21 13:23:30 >>>故障排除日志:删除未同步下发订单成功24072113232097281934
2024-07-21 13:23:30 >>>故障排除日志:删除未同步下发订单成功24072113232097281934
2024-07-21 13:23:31 >>>故障排除日志:终端同步成功后剩余订单列表


===13:29:43===
2024-07-21 13:29:32 >>>回调事件[910,devices/S2040]
2024-07-21 13:29:33 >>>故障排除日志:上一MQTT订单号缓存列表为24072113232097281934|24072113232097281934
2024-07-21 13:29:33 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 13:29:33 开始打印,排队:73,票券:2407211329187861681601,订单:24072113291878611559,[2024-07-21 13:29:18支付宝支付10元]
2024-07-21 13:29:35 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407211329187861681601","queue_number":73,"trade_uid":"24072113291878611559"}]}
2024-07-21 13:29:35 >>>故障排除日志:删除未同步下发订单成功24072113291878611559
2024-07-21 13:29:35 >>>故障排除日志:终端同步成功后剩余订单列表


===13:31:43===
2024-07-21 13:30:43 >>>回调事件[910,devices/S2040]
2024-07-21 13:30:43 >>>故障排除日志:上一MQTT订单号缓存列表为24072113291878611559
2024-07-21 13:30:43 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 13:30:43 开始打印,排队:74,票券:2407211330370394009101,订单:24072113303703934870,[2024-07-21 13:30:37微信支付10元]
2024-07-21 13:30:45 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407211330370394009101","queue_number":74,"trade_uid":"24072113303703934870"}]}
2024-07-21 13:30:45 >>>故障排除日志:删除未同步下发订单成功24072113303703934870
2024-07-21 13:30:45 >>>故障排除日志:终端同步成功后剩余订单列表


===13:37:43===
2024-07-21 13:37:38 >>>回调事件[910,devices/S2040]
2024-07-21 13:37:38 >>>故障排除日志:上一MQTT订单号缓存列表为24072113303703934870
2024-07-21 13:37:38 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 13:37:38 开始打印,排队:75,票券:2407211337343979479801,订单:24072113373439790117,[2024-07-21 13:37:34微信支付10元]
2024-07-21 13:37:40 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407211337343979479801","queue_number":75,"trade_uid":"24072113373439790117"}]}
2024-07-21 13:37:40 >>>故障排除日志:删除未同步下发订单成功24072113373439790117
2024-07-21 13:37:40 >>>故障排除日志:终端同步成功后剩余订单列表


===13:48:44===
2024-07-21 13:48:38>>>cash read=9E
2024-07-21 13:48:39>>>cash read=3E


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


===13:50:44===
2024-07-21 13:49:53>>>cash read=00
2024-07-21 13:49:54>>>cash read=818F42
2024-07-21 13:49:54>>>cash write=02
2024-07-21 13:49:54 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-07-21 13:49:54>>>cash read=10
2024-07-21 13:49:54 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-07-21 13:49:54 >>>开始打印,排队号为77,订单号为2407211349540020406751
2024-07-21 13:49:55>>>订单2407211349540020406751写入成功,剩余空间为1675000,占用RAM为599.81640625
删除未同步订单2407211349540020406751
2024-07-21 13:49:57>>>订单2407211349540020406751删除成功,剩余空间为1675000,占用RAM为613.6650390625
检测订单目录中>>>
无未同步订单>>>
2024-07-21 13:49:57 >>>当前Ram内存为585.0029296875
定时检测未同步订单启用
2024-07-21 13:49:58>>>cash write=0C
2024-07-21 13:49:58>>>cash read=3E


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


===13:55:45===
2024-07-21 13:55:28 >>>回调事件[910,devices/S2040]
2024-07-21 13:55:28 >>>故障排除日志:上一MQTT订单号缓存列表为24072113484651264864
2024-07-21 13:55:28 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 13:55:28 开始打印,排队:78,票券:2407211355223780909101,订单:24072113552237805496,[2024-07-21 13:55:22微信支付10元]
2024-07-21 13:55:28 开始打印,排队:79,票券:2407211355223781056202,订单:24072113552237805496,[2024-07-21 13:55:22微信支付10元]
2024-07-21 13:55:32 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407211355223780909101","queue_number":78,"trade_uid":"24072113552237805496"},{"ticket_no":"2407211355223781056202","queue_number":79,"trade_uid":"24072113552237805496"}]}
2024-07-21 13:55:32 >>>故障排除日志:删除未同步下发订单成功24072113552237805496
2024-07-21 13:55:32 >>>故障排除日志:删除未同步下发订单成功24072113552237805496
2024-07-21 13:55:32 >>>故障排除日志:终端同步成功后剩余订单列表


===14:06:45===
2024-07-21 14:06:24 >>>回调事件[910,devices/S2040]
2024-07-21 14:06:24 >>>故障排除日志:上一MQTT订单号缓存列表为24072113552237805496|24072113552237805496
2024-07-21 14:06:24 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 14:06:24 开始打印,排队:80,票券:2407211406196493911601,订单:24072114061964934929,[2024-07-21 14:06:19支付宝支付10元]
2024-07-21 14:06:26 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407211406196493911601","queue_number":80,"trade_uid":"24072114061964934929"}]}
2024-07-21 14:06:26 >>>故障排除日志:删除未同步下发订单成功24072114061964934929
2024-07-21 14:06:26 >>>故障排除日志:终端同步成功后剩余订单列表


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


===14:11:45===
2024-07-21 14:11:27>>>cash read=00
2024-07-21 14:11:28>>>cash read=818F42
2024-07-21 14:11:28>>>cash write=02
2024-07-21 14:11:28 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-07-21 14:11:28>>>cash read=10
2024-07-21 14:11:28 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-07-21 14:11:28 >>>开始打印,排队号为82,订单号为2407211411280020401874
2024-07-21 14:11:28>>>订单2407211411280020401874写入成功,剩余空间为1675000,占用RAM为600.0244140625
删除未同步订单2407211411280020401874
2024-07-21 14:11:31>>>订单2407211411280020401874删除成功,剩余空间为1675000,占用RAM为590.0400390625
检测订单目录中>>>
无未同步订单>>>
2024-07-21 14:11:31 >>>当前Ram内存为585.3154296875
定时检测未同步订单启用
2024-07-21 14:11:31>>>cash write=0C
2024-07-21 14:11:32>>>cash read=3E


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


===14:15:48===
2024-07-21 14:15:43 >>>回调事件[910,devices/S2040]
2024-07-21 14:15:43 >>>故障排除日志:上一MQTT订单号缓存列表为24072114064370675012
2024-07-21 14:15:43 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 14:15:43 开始打印,排队:83,票券:2407211415366297832701,订单:24072114153662975092,[2024-07-21 14:15:36微信支付10元]
2024-07-21 14:15:43 开始打印,排队:84,票券:2407211415366297968602,订单:24072114153662975092,[2024-07-21 14:15:36微信支付10元]


===14:16:49===
2024-07-21 14:15:47 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407211415366297832701","queue_number":83,"trade_uid":"24072114153662975092"},{"ticket_no":"2407211415366297968602","queue_number":84,"trade_uid":"24072114153662975092"}]}
2024-07-21 14:15:47 >>>故障排除日志:删除未同步下发订单成功24072114153662975092
2024-07-21 14:15:47 >>>故障排除日志:删除未同步下发订单成功24072114153662975092
2024-07-21 14:15:47 >>>故障排除日志:终端同步成功后剩余订单列表


===14:29:49===
2024-07-21 14:29:11 >>>回调事件[910,devices/S2040]
2024-07-21 14:29:11 >>>故障排除日志:上一MQTT订单号缓存列表为24072114153662975092|24072114153662975092
2024-07-21 14:29:11 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 14:29:11 开始打印,排队:85,票券:2407211429049482446301,订单:24072114290494820935,[2024-07-21 14:29:04微信支付10元]
2024-07-21 14:29:13 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407211429049482446301","queue_number":85,"trade_uid":"24072114290494820935"}]}
2024-07-21 14:29:13 >>>故障排除日志:删除未同步下发订单成功24072114290494820935
2024-07-21 14:29:14 >>>故障排除日志:终端同步成功后剩余订单列表


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


===14:50:49===
2024-07-21 14:50:44 >>>回调事件[910,devices/S2040]
2024-07-21 14:50:44 >>>故障排除日志:上一MQTT订单号缓存列表为24072114321045791147
2024-07-21 14:50:44 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 14:50:44 开始打印,排队:87,票券:2407211450395969154201,订单:24072114503959685695,[2024-07-21 14:50:39支付宝支付10元]
2024-07-21 14:50:46 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407211450395969154201","queue_number":87,"trade_uid":"24072114503959685695"}]}
2024-07-21 14:50:46 >>>故障排除日志:删除未同步下发订单成功24072114503959685695
2024-07-21 14:50:46 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


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


===15:20:50===
2024-07-21 15:20:37>>>cash read=00
2024-07-21 15:20:38>>>cash read=29
2024-07-21 15:20:38 >>>回调事件130,cash_status,20029,退钞中
2024-07-21 15:20:39>>>cash read=22
2024-07-21 15:20:39 >>>回调事件130,cash_status,30022,卡钞


===15:21:51===
2024-07-21 15:20:52>>>cash read=3E
2024-07-21 15:21:04>>>cash read=00
2024-07-21 15:21:05>>>cash read=818F42
2024-07-21 15:21:05>>>cash write=02
2024-07-21 15:21:05 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-07-21 15:21:05>>>cash read=10
2024-07-21 15:21:05 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-07-21 15:21:05 >>>开始打印,排队号为93,订单号为2407211521050020404037
2024-07-21 15:21:05>>>订单2407211521050020404037写入成功,剩余空间为1674500,占用RAM为600.2587890625
删除未同步订单2407211521050020404037
2024-07-21 15:21:08>>>订单2407211521050020404037删除成功,剩余空间为1675000,占用RAM为614.185546875
检测订单目录中>>>
无未同步订单>>>
2024-07-21 15:21:08 >>>当前Ram内存为585.53125
定时检测未同步订单启用
2024-07-21 15:21:08>>>cash write=0C
2024-07-21 15:21:09>>>cash read=3E


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


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


===15:33:51===
2024-07-21 15:33:09>>>cash read=00
2024-07-21 15:33:10>>>cash read=818F42
2024-07-21 15:33:10>>>cash write=02
2024-07-21 15:33:10 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-07-21 15:33:11>>>cash read=10
2024-07-21 15:33:11 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-07-21 15:33:11 >>>开始打印,排队号为95,订单号为2407211533110020405579
2024-07-21 15:33:11>>>订单2407211533110020405579写入成功,剩余空间为1675000,占用RAM为598.2685546875
删除未同步订单2407211533110020405579
2024-07-21 15:33:13>>>订单2407211533110020405579删除成功,剩余空间为1675000,占用RAM为615.58203125
检测订单目录中>>>
无未同步订单>>>
2024-07-21 15:33:13 >>>当前Ram内存为585.2578125
定时检测未同步订单启用
2024-07-21 15:33:14>>>cash write=0C
2024-07-21 15:33:14>>>cash read=3E
2024-07-21 15:33:15>>>cash read=29
2024-07-21 15:33:15 >>>回调事件130,cash_status,20029,退钞中
2024-07-21 15:33:16>>>cash read=2F29
2024-07-21 15:33:17>>>cash read=3E
2024-07-21 15:33:21>>>cash read=00
2024-07-21 15:33:21>>>cash read=818F42
2024-07-21 15:33:21>>>cash write=02
2024-07-21 15:33:21 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-07-21 15:33:22>>>cash read=10
2024-07-21 15:33:22 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-07-21 15:33:22 >>>开始打印,排队号为96,订单号为2407211533220020408746
定时检测未同步订单关闭
2024-07-21 15:33:22>>>订单2407211533220020408746写入成功,剩余空间为1673500,占用RAM为605.998046875
删除未同步订单2407211533220020408746
2024-07-21 15:33:24>>>订单2407211533220020408746删除成功,剩余空间为1674000,占用RAM为621.3916015625
检测订单目录中>>>
无未同步订单>>>
2024-07-21 15:33:24 >>>当前Ram内存为587.40625
定时检测未同步订单启用
2024-07-21 15:33:25>>>cash write=0C
2024-07-21 15:33:25>>>cash read=3E


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


===15:41:53===
2024-07-21 15:41:03>>>cash read=00
2024-07-21 15:41:04>>>cash read=29
2024-07-21 15:41:04 >>>回调事件130,cash_status,20029,退钞中
2024-07-21 15:41:05>>>cash read=2F29
2024-07-21 15:41:06>>>cash read=01
2024-07-21 15:41:09>>>cash read=012F
2024-07-21 15:41:10>>>cash read=3E
2024-07-21 15:41:15>>>cash read=00
2024-07-21 15:41:16>>>cash read=01
2024-07-21 15:41:22>>>cash read=00
2024-07-21 15:41:23>>>cash read=29
2024-07-21 15:41:23 >>>回调事件130,cash_status,20029,退钞中
2024-07-21 15:41:23>>>cash read=2F29
2024-07-21 15:41:24>>>cash read=01
2024-07-21 15:41:29>>>cash read=2F
2024-07-21 15:41:30>>>cash read=3E
2024-07-21 15:41:38>>>cash read=29
2024-07-21 15:41:38 >>>回调事件130,cash_status,20029,退钞中
2024-07-21 15:41:39>>>cash read=3E
2024-07-21 15:41:44>>>cash read=00
2024-07-21 15:41:45>>>cash read=2F29
2024-07-21 15:41:46>>>cash read=3E
2024-07-21 15:41:48>>>cash read=00
2024-07-21 15:41:49>>>cash read=818F42
2024-07-21 15:41:49>>>cash write=02
2024-07-21 15:41:49 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-07-21 15:41:49>>>cash read=10
2024-07-21 15:41:49 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-07-21 15:41:49 >>>开始打印,排队号为97,订单号为2407211541490020404715
2024-07-21 15:41:50>>>订单2407211541490020404715写入成功,剩余空间为1673500,占用RAM为602.7724609375


===15:42:53===
删除未同步订单2407211541490020404715
2024-07-21 15:41:52>>>订单2407211541490020404715删除成功,剩余空间为1676000,占用RAM为619.7275390625
检测订单目录中>>>
无未同步订单>>>
2024-07-21 15:41:52 >>>当前Ram内存为585.03125
定时检测未同步订单启用
2024-07-21 15:41:53>>>cash write=0C
2024-07-21 15:41:53>>>cash read=3E


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


===15:46:54===
2024-07-21 15:46:10 >>>回调事件[910,devices/S2040]
2024-07-21 15:46:10 >>>故障排除日志:上一MQTT订单号缓存列表为24072115232620910419
2024-07-21 15:46:10 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 15:46:10 开始打印,排队:98,票券:2407211546045937002801,订单:24072115460459365132,[2024-07-21 15:46:04微信支付10元]
2024-07-21 15:46:12 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407211546045937002801","queue_number":98,"trade_uid":"24072115460459365132"}]}
2024-07-21 15:46:12 >>>故障排除日志:删除未同步下发订单成功24072115460459365132
2024-07-21 15:46:12 >>>故障排除日志:终端同步成功后剩余订单列表
2024-07-21 15:46:26 >>>回调事件[910,devices/S2040]
2024-07-21 15:46:26 >>>故障排除日志:上一MQTT订单号缓存列表为24072115460459365132
2024-07-21 15:46:26 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 15:46:26 开始打印,排队:99,票券:2407211546196720079501,订单:24072115461967197146,[2024-07-21 15:46:19微信支付10元]
2024-07-21 15:46:28 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407211546196720079501","queue_number":99,"trade_uid":"24072115461967197146"}]}
2024-07-21 15:46:28 >>>故障排除日志:删除未同步下发订单成功24072115461967197146
2024-07-21 15:46:28 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


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


===16:12:57===
2024-07-21 16:12:03 >>>回调事件[910,devices/S2040]
2024-07-21 16:12:03 >>>故障排除日志:上一MQTT订单号缓存列表为24072116084580081910
2024-07-21 16:12:03 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 16:12:03 开始打印,排队:105,票券:2407211611572291435801,订单:24072116115722908749,[2024-07-21 16:11:57微信支付10元]
2024-07-21 16:12:05 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407211611572291435801","queue_number":105,"trade_uid":"24072116115722908749"}]}
2024-07-21 16:12:05 >>>故障排除日志:删除未同步下发订单成功24072116115722908749
2024-07-21 16:12:05 >>>故障排除日志:终端同步成功后剩余订单列表
2024-07-21 16:12:53 >>>回调事件[910,devices/S2040]
2024-07-21 16:12:53 >>>故障排除日志:上一MQTT订单号缓存列表为24072116115722908749
2024-07-21 16:12:53 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 16:12:53 开始打印,排队:106,票券:2407211612476118859201,订单:24072116124761185161,[2024-07-21 16:12:47微信支付10元]


===16:13:57===
2024-07-21 16:12:55 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407211612476118859201","queue_number":106,"trade_uid":"24072116124761185161"}]}
2024-07-21 16:12:55 >>>故障排除日志:删除未同步下发订单成功24072116124761185161
2024-07-21 16:12:56 >>>故障排除日志:终端同步成功后剩余订单列表


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


===16:18:59===
2024-07-21 16:18:55 >>>回调事件[910,devices/S2040]
2024-07-21 16:18:55 >>>故障排除日志:上一MQTT订单号缓存列表为24072116160561032930
2024-07-21 16:18:55 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 16:18:55 开始打印,排队:108,票券:2407211618493851354301,订单:24072116184938510138,[2024-07-21 16:18:49微信支付10元]


===16:19:59===
2024-07-21 16:18:57 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407211618493851354301","queue_number":108,"trade_uid":"24072116184938510138"}]}
2024-07-21 16:18:57 >>>故障排除日志:删除未同步下发订单成功24072116184938510138
2024-07-21 16:18:57 >>>故障排除日志:终端同步成功后剩余订单列表


===16:28:59===
2024-07-21 16:28:45 >>>回调事件[910,devices/S2040]
2024-07-21 16:28:45 >>>故障排除日志:上一MQTT订单号缓存列表为24072116184938510138
2024-07-21 16:28:45 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 16:28:45 开始打印,排队:109,票券:2407211628390319929801,订单:24072116283903194230,[2024-07-21 16:28:39支付宝支付10元]
2024-07-21 16:28:47 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407211628390319929801","queue_number":109,"trade_uid":"24072116283903194230"}]}
2024-07-21 16:28:47 >>>故障排除日志:删除未同步下发订单成功24072116283903194230
2024-07-21 16:28:47 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


===16:36:00===
2024-07-21 16:35:28 >>>回调事件[910,devices/S2040]
2024-07-21 16:35:28 >>>故障排除日志:上一MQTT订单号缓存列表为24072116335375865596
2024-07-21 16:35:28 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 16:35:28 开始打印,排队:112,票券:2407211635207550717401,订单:24072116352075501481,[2024-07-21 16:35:20微信支付10元]
2024-07-21 16:35:30 >>>回调事件[910,devices/S2040]
2024-07-21 16:35:30 >>>故障排除日志:上一MQTT订单号缓存列表为24072116352075501481
2024-07-21 16:35:30 >>>故障排除日志:终端未同步成功订单列表011224072116352075501481
2024-07-21 16:35:30 开始打印,排队:113,票券:2407211635205012048401,订单:24072116352050112437,[2024-07-21 16:35:20微信支付10元]
已接收过此消息,票券号为2407211635207550717401,排队号为112
2024-07-21 16:35:32 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407211635207550717401","queue_number":112,"trade_uid":"24072116352075501481"}]}
2024-07-21 16:35:32 >>>故障排除日志:删除未同步下发订单成功24072116352075501481
2024-07-21 16:35:32 >>>故障排除日志:终端同步成功后剩余订单列表011324072116352050112437
2024-07-21 16:35:32 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407211635205012048401","queue_number":113,"trade_uid":"24072116352050112437"},{"ticket_no":"2407211635207550717401","queue_number":112,"trade_uid":"24072116352075501481"}]}
2024-07-21 16:35:32 >>>故障排除日志:删除未同步下发订单成功24072116352050112437
2024-07-21 16:35:32 >>>故障排除日志:终端同步成功后剩余订单列表


===16:37:00===
2024-07-21 16:36:05>>>cash read=00
2024-07-21 16:36:05>>>cash read=818F42
2024-07-21 16:36:05>>>cash write=02
2024-07-21 16:36:05 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-07-21 16:36:06>>>cash read=10
2024-07-21 16:36:06 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-07-21 16:36:06 >>>开始打印,排队号为114,订单号为2407211636060020401786
2024-07-21 16:36:06>>>订单2407211636060020401786写入成功,剩余空间为1675000,占用RAM为598.7314453125
删除未同步订单2407211636060020401786
2024-07-21 16:36:08>>>订单2407211636060020401786删除成功,剩余空间为1675000,占用RAM为589.197265625
检测订单目录中>>>
无未同步订单>>>
2024-07-21 16:36:08 >>>当前Ram内存为583.892578125
定时检测未同步订单启用
2024-07-21 16:36:09>>>cash write=0C
2024-07-21 16:36:09>>>cash read=3E


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


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


===16:46:01===
2024-07-21 16:45:44>>>cash read=9E
2024-07-21 16:45:45>>>cash read=3E


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


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


===17:07:01===
2024-07-21 17:06:06 >>>回调事件[910,devices/S2040]
2024-07-21 17:06:06 >>>故障排除日志:上一MQTT订单号缓存列表为24072117032260115852
2024-07-21 17:06:06 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 17:06:06 开始打印,排队:118,票券:2407211705580149919301,订单:24072117055801493889,[2024-07-21 17:05:58微信支付10元]
2024-07-21 17:06:08 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407211705580149919301","queue_number":118,"trade_uid":"24072117055801493889"}]}
2024-07-21 17:06:08 >>>故障排除日志:删除未同步下发订单成功24072117055801493889
2024-07-21 17:06:08 >>>故障排除日志:终端同步成功后剩余订单列表
2024-07-21 17:06:17>>>cash read=29
2024-07-21 17:06:17 >>>回调事件130,cash_status,20029,退钞中
2024-07-21 17:06:18>>>cash read=01
2024-07-21 17:06:20>>>cash read=3E
2024-07-21 17:06:25>>>cash read=00
2024-07-21 17:06:26>>>cash read=818F42
2024-07-21 17:06:26>>>cash write=02
2024-07-21 17:06:26 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-07-21 17:06:26>>>cash read=10
2024-07-21 17:06:26 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-07-21 17:06:26 >>>开始打印,排队号为119,订单号为2407211706260020408826
2024-07-21 17:06:27>>>订单2407211706260020408826写入成功,剩余空间为1673500,占用RAM为603.775390625
删除未同步订单2407211706260020408826
2024-07-21 17:06:29>>>订单2407211706260020408826删除成功,剩余空间为1674500,占用RAM为619.0283203125
检测订单目录中>>>
无未同步订单>>>
2024-07-21 17:06:29 >>>当前Ram内存为585.7412109375
定时检测未同步订单启用
2024-07-21 17:06:30>>>cash write=0C
2024-07-21 17:06:30>>>cash read=3E
2024-07-21 17:06:46 >>>回调事件[910,devices/S2040]
2024-07-21 17:06:46 >>>故障排除日志:上一MQTT订单号缓存列表为24072117055801493889
2024-07-21 17:06:46 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 17:06:46 开始打印,排队:120,票券:2407211706410574566501,订单:24072117064105742120,[2024-07-21 17:06:41微信支付10元]
2024-07-21 17:06:48 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407211706410574566501","queue_number":120,"trade_uid":"24072117064105742120"}]}
2024-07-21 17:06:48 >>>故障排除日志:删除未同步下发订单成功24072117064105742120
2024-07-21 17:06:48 >>>故障排除日志:终端同步成功后剩余订单列表


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


===17:10:02===
2024-07-21 17:09:00>>>cash read=00
2024-07-21 17:09:00>>>cash read=818F42
2024-07-21 17:09:00>>>cash write=02
2024-07-21 17:09:01 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-07-21 17:09:01>>>cash read=10
2024-07-21 17:09:01 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-07-21 17:09:01 >>>开始打印,排队号为121,订单号为2407211709010020406936
2024-07-21 17:09:01>>>订单2407211709010020406936写入成功,剩余空间为1675000,占用RAM为600.07421875
删除未同步订单2407211709010020406936
2024-07-21 17:09:04>>>订单2407211709010020406936删除成功,剩余空间为1675000,占用RAM为617.1328125
检测订单目录中>>>
无未同步订单>>>
2024-07-21 17:09:04 >>>当前Ram内存为585.44921875
定时检测未同步订单启用
2024-07-21 17:09:04>>>cash write=0C
2024-07-21 17:09:04>>>cash read=3E


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


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


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


===17:22:02===
2024-07-21 17:21:22 >>>回调事件[910,devices/S2040]
2024-07-21 17:21:22 >>>故障排除日志:上一MQTT订单号缓存列表为24072117201194249321
2024-07-21 17:21:22 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 17:21:22 开始打印,排队:124,票券:2407211721058684976401,订单:24072117210586845572,[2024-07-21 17:21:05支付宝支付10元]
2024-07-21 17:21:24 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407211721058684976401","queue_number":124,"trade_uid":"24072117210586845572"}]}
2024-07-21 17:21:24 >>>故障排除日志:删除未同步下发订单成功24072117210586845572
2024-07-21 17:21:24 >>>故障排除日志:终端同步成功后剩余订单列表
2024-07-21 17:21:58 >>>回调事件[910,devices/S2040]
2024-07-21 17:21:58 >>>故障排除日志:上一MQTT订单号缓存列表为24072117210586845572
2024-07-21 17:21:58 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 17:21:58 开始打印,排队:125,票券:2407211721524447752901,订单:24072117215244473839,[2024-07-21 17:21:52支付宝支付10元]
2024-07-21 17:22:00 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407211721524447752901","queue_number":125,"trade_uid":"24072117215244473839"}]}
2024-07-21 17:22:00 >>>故障排除日志:删除未同步下发订单成功24072117215244473839
2024-07-21 17:22:00 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


===17:37:03===
2024-07-21 17:36:03 >>>回调事件[910,devices/S2040]
2024-07-21 17:36:03 >>>故障排除日志:上一MQTT订单号缓存列表为24072117242414624470
2024-07-21 17:36:03 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 17:36:03 开始打印,排队:128,票券:2407211735569128293001,订单:24072117355691279364,[2024-07-21 17:35:56微信支付10元]
2024-07-21 17:36:05 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407211735569128293001","queue_number":128,"trade_uid":"24072117355691279364"}]}
2024-07-21 17:36:05 >>>故障排除日志:删除未同步下发订单成功24072117355691279364
2024-07-21 17:36:05 >>>故障排除日志:终端同步成功后剩余订单列表


===17:43:03===
2024-07-21 17:42:20 >>>回调事件[910,devices/S2040]
2024-07-21 17:42:20 >>>故障排除日志:上一MQTT订单号缓存列表为24072117355691279364
2024-07-21 17:42:20 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 17:42:20 开始打印,排队:129,票券:2407211742148548174001,订单:24072117421485477143,[2024-07-21 17:42:14微信支付10元]
2024-07-21 17:42:22 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407211742148548174001","queue_number":129,"trade_uid":"24072117421485477143"}]}
2024-07-21 17:42:22 >>>故障排除日志:删除未同步下发订单成功24072117421485477143
2024-07-21 17:42:22 >>>故障排除日志:终端同步成功后剩余订单列表


===17:48:04===
2024-07-21 17:47:54>>>cash read=9E
2024-07-21 17:47:55>>>cash read=3E


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


===17:50:04===
2024-07-21 17:49:31>>>cash read=BF
2024-07-21 17:49:32>>>cash read=3E


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


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


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


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


===18:02:05===
2024-07-21 18:01:44>>>cash read=9E
2024-07-21 18:01:45>>>cash read=3E


===18:06:05===
2024-07-21 18:05:54>>>cash read=29
2024-07-21 18:05:54 >>>回调事件130,cash_status,20029,退钞中
2024-07-21 18:05:55>>>cash read=3E
2024-07-21 18:05:57>>>cash read=00
2024-07-21 18:05:57>>>cash read=818F42
2024-07-21 18:05:57>>>cash write=02
2024-07-21 18:05:57 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-07-21 18:05:58>>>cash read=10
2024-07-21 18:05:58 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-07-21 18:05:58 >>>开始打印,排队号为135,订单号为2407211805580020406333
2024-07-21 18:05:58>>>订单2407211805580020406333写入成功,剩余空间为1674000,占用RAM为600.861328125
删除未同步订单2407211805580020406333
2024-07-21 18:06:00>>>订单2407211805580020406333删除成功,剩余空间为1675000,占用RAM为615.8759765625
检测订单目录中>>>
无未同步订单>>>
2024-07-21 18:06:00 >>>当前Ram内存为585.6640625
定时检测未同步订单启用
2024-07-21 18:06:01>>>cash write=0C
2024-07-21 18:06:01>>>cash read=3E


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


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


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


===18:12:06===
2024-07-21 18:11:30 >>>回调事件[910,devices/S2040]
2024-07-21 18:11:30 >>>故障排除日志:上一MQTT订单号缓存列表为24072118102077052518
2024-07-21 18:11:30 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 18:11:30 开始打印,排队:138,票券:2407211811250708204301,订单:24072118112507076568,[2024-07-21 18:11:25微信支付10元]
2024-07-21 18:11:32 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407211811250708204301","queue_number":138,"trade_uid":"24072118112507076568"}]}
2024-07-21 18:11:32 >>>故障排除日志:删除未同步下发订单成功24072118112507076568
2024-07-21 18:11:32 >>>故障排除日志:终端同步成功后剩余订单列表
2024-07-21 18:11:51 >>>回调事件[910,devices/S2040]
2024-07-21 18:11:51 >>>故障排除日志:上一MQTT订单号缓存列表为24072118112507076568
2024-07-21 18:11:51 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 18:11:51 开始打印,排队:139,票券:2407211811421001338301,订单:24072118114210007940,[2024-07-21 18:11:42微信支付10元]
2024-07-21 18:11:53 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407211811421001338301","queue_number":139,"trade_uid":"24072118114210007940"}]}
2024-07-21 18:11:53 >>>故障排除日志:删除未同步下发订单成功24072118114210007940
2024-07-21 18:11:53 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


===18:19:08===
2024-07-21 18:19:05 >>>回调事件[910,devices/S2040]
2024-07-21 18:19:05 >>>故障排除日志:上一MQTT订单号缓存列表为24072118175537650642
2024-07-21 18:19:05 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 18:19:05 开始打印,排队:144,票券:2407211818586640705101,订单:24072118185866403587,[2024-07-21 18:18:58微信支付10元]


===18:20:08===
2024-07-21 18:19:07 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407211818586640705101","queue_number":144,"trade_uid":"24072118185866403587"}]}
2024-07-21 18:19:07 >>>故障排除日志:删除未同步下发订单成功24072118185866403587
2024-07-21 18:19:07 >>>故障排除日志:终端同步成功后剩余订单列表
2024-07-21 18:19:37 >>>回调事件[910,devices/S2040]
2024-07-21 18:19:37 >>>故障排除日志:上一MQTT订单号缓存列表为24072118185866403587
2024-07-21 18:19:37 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 18:19:37 开始打印,排队:145,票券:2407211819301216965001,订单:24072118193012164490,[2024-07-21 18:19:30微信支付10元]
2024-07-21 18:19:39 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407211819301216965001","queue_number":145,"trade_uid":"24072118193012164490"}]}
2024-07-21 18:19:39 >>>故障排除日志:删除未同步下发订单成功24072118193012164490
2024-07-21 18:19:39 >>>故障排除日志:终端同步成功后剩余订单列表


===18:22:09===
2024-07-21 18:21:07 >>>回调事件[910,devices/S2040]
2024-07-21 18:21:07 >>>故障排除日志:上一MQTT订单号缓存列表为24072118193012164490
2024-07-21 18:21:07 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 18:21:07 开始打印,排队:146,票券:2407211821024676702001,订单:24072118210246762690,[2024-07-21 18:21:02微信支付10元]
2024-07-21 18:21:09 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407211821024676702001","queue_number":146,"trade_uid":"24072118210246762690"}]}
2024-07-21 18:21:09 >>>故障排除日志:删除未同步下发订单成功24072118210246762690
2024-07-21 18:21:10 >>>故障排除日志:终端同步成功后剩余订单列表
2024-07-21 18:21:17 >>>回调事件[910,devices/S2040]
2024-07-21 18:21:17 >>>故障排除日志:上一MQTT订单号缓存列表为24072118210246762690
2024-07-21 18:21:17 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 18:21:17 开始打印,排队:147,票券:2407211821119446795901,订单:24072118211194464963,[2024-07-21 18:21:11微信支付10元]
2024-07-21 18:21:19 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407211821119446795901","queue_number":147,"trade_uid":"24072118211194464963"}]}
2024-07-21 18:21:19 >>>故障排除日志:删除未同步下发订单成功24072118211194464963
2024-07-21 18:21:19 >>>故障排除日志:终端同步成功后剩余订单列表


===18:31:09===
2024-07-21 18:31:06 >>>回调事件[910,devices/S2040]
2024-07-21 18:31:06 >>>故障排除日志:上一MQTT订单号缓存列表为24072118211194464963
2024-07-21 18:31:06 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 18:31:06 开始打印,排队:148,票券:2407211830575587862901,订单:24072118305755873195,[2024-07-21 18:30:57微信支付10元]


===18:32:10===
2024-07-21 18:31:08 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407211830575587862901","queue_number":148,"trade_uid":"24072118305755873195"}]}
2024-07-21 18:31:08 >>>故障排除日志:删除未同步下发订单成功24072118305755873195
2024-07-21 18:31:08 >>>故障排除日志:终端同步成功后剩余订单列表


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


===18:49:10===
2024-07-21 18:48:20>>>cash read=29
2024-07-21 18:48:20 >>>回调事件130,cash_status,20029,退钞中
2024-07-21 18:48:21>>>cash read=01
2024-07-21 18:48:23>>>cash read=00
2024-07-21 18:48:24>>>cash read=3E
2024-07-21 18:48:46>>>cash read=00
2024-07-21 18:48:46>>>cash read=818F42
2024-07-21 18:48:46>>>cash write=02
2024-07-21 18:48:46 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-07-21 18:48:47>>>cash read=10
2024-07-21 18:48:47 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-07-21 18:48:47 >>>开始打印,排队号为150,订单号为2407211848470020408491
2024-07-21 18:48:47>>>订单2407211848470020408491写入成功,剩余空间为1674000,占用RAM为599.2236328125
删除未同步订单2407211848470020408491
2024-07-21 18:48:49>>>订单2407211848470020408491删除成功,剩余空间为1675000,占用RAM为615.8583984375
检测订单目录中>>>
无未同步订单>>>
2024-07-21 18:48:49 >>>当前Ram内存为585.396484375
定时检测未同步订单启用
2024-07-21 18:48:50>>>cash write=0C
2024-07-21 18:48:50>>>cash read=3E


===18:50:10===
2024-07-21 18:49:13 >>>回调事件[910,devices/S2040]
2024-07-21 18:49:13 >>>故障排除日志:上一MQTT订单号缓存列表为24072118405870872129
2024-07-21 18:49:13 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 18:49:13 开始打印,排队:151,票券:2407211849074933625901,订单:24072118490749332890,[2024-07-21 18:49:07支付宝支付10元]
2024-07-21 18:49:15 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407211849074933625901","queue_number":151,"trade_uid":"24072118490749332890"}]}
2024-07-21 18:49:15 >>>故障排除日志:删除未同步下发订单成功24072118490749332890
2024-07-21 18:49:15 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单关闭
检测订单目录中>>>
无未同步订单>>>


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


===18:55:11===
2024-07-21 18:54:45 >>>回调事件[910,devices/S2040]
2024-07-21 18:54:45 >>>故障排除日志:上一MQTT订单号缓存列表为24072118524973318563
2024-07-21 18:54:45 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 18:54:45 开始打印,排队:153,票券:2407211854388093948501,订单:24072118543880935097,[2024-07-21 18:54:38微信支付10元]
2024-07-21 18:54:47 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407211854388093948501","queue_number":153,"trade_uid":"24072118543880935097"}]}
2024-07-21 18:54:47 >>>故障排除日志:删除未同步下发订单成功24072118543880935097
2024-07-21 18:54:47 >>>故障排除日志:终端同步成功后剩余订单列表


===18:58:11===
2024-07-21 18:57:29 >>>回调事件[910,devices/S2040]
2024-07-21 18:57:29 >>>故障排除日志:上一MQTT订单号缓存列表为24072118543880935097
2024-07-21 18:57:29 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 18:57:29 开始打印,排队:154,票券:2407211857243973650201,订单:24072118572439733223,[2024-07-21 18:57:24微信支付10元]
2024-07-21 18:57:31 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407211857243973650201","queue_number":154,"trade_uid":"24072118572439733223"}]}
2024-07-21 18:57:31 >>>故障排除日志:删除未同步下发订单成功24072118572439733223
2024-07-21 18:57:31 >>>故障排除日志:终端同步成功后剩余订单列表


===19:03:13===
2024-07-21 19:02:18 >>>回调事件[910,devices/S2040]
2024-07-21 19:02:18 >>>故障排除日志:上一MQTT订单号缓存列表为24072118572439733223
2024-07-21 19:02:18 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 19:02:18 开始打印,排队:155,票券:2407211902128791818401,订单:24072119021287914790,[2024-07-21 19:02:12微信支付10元]
2024-07-21 19:02:21 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407211902128791818401","queue_number":155,"trade_uid":"24072119021287914790"}]}
2024-07-21 19:02:21 >>>故障排除日志:删除未同步下发订单成功24072119021287914790
2024-07-21 19:02:21 >>>故障排除日志:终端同步成功后剩余订单列表
2024-07-21 19:02:48 >>>回调事件[910,devices/S2040]
2024-07-21 19:02:48 >>>故障排除日志:上一MQTT订单号缓存列表为24072119021287914790
2024-07-21 19:02:48 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 19:02:48 开始打印,排队:156,票券:2407211902416960789801,订单:24072119024169604553,[2024-07-21 19:02:41微信支付10元]
2024-07-21 19:02:50 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407211902416960789801","queue_number":156,"trade_uid":"24072119024169604553"}]}
2024-07-21 19:02:50 >>>故障排除日志:删除未同步下发订单成功24072119024169604553
2024-07-21 19:02:50 >>>故障排除日志:终端同步成功后剩余订单列表
2024-07-21 19:03:09 >>>回调事件[910,devices/S2040]
2024-07-21 19:03:09 >>>故障排除日志:上一MQTT订单号缓存列表为24072119024169604553
2024-07-21 19:03:09 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 19:03:09 开始打印,排队:157,票券:2407211902449961299201,订单:24072119024499608936,[2024-07-21 19:02:44微信支付10元]


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


===19:07:13===
2024-07-21 19:06:30 >>>回调事件[910,devices/S2040]
2024-07-21 19:06:31 >>>故障排除日志:上一MQTT订单号缓存列表为24072119040341734513
2024-07-21 19:06:31 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 19:06:31 开始打印,排队:159,票券:2407211906253769611501,订单:24072119062537692925,[2024-07-21 19:06:25微信支付10元]
2024-07-21 19:06:33 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407211906253769611501","queue_number":159,"trade_uid":"24072119062537692925"}]}
2024-07-21 19:06:33 >>>故障排除日志:删除未同步下发订单成功24072119062537692925
2024-07-21 19:06:33 >>>故障排除日志:终端同步成功后剩余订单列表


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


===19:17:14===
2024-07-21 19:16:56 >>>回调事件[910,devices/S2040]
2024-07-21 19:16:56 >>>故障排除日志:上一MQTT订单号缓存列表为24072119122596568619
2024-07-21 19:16:56 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 19:16:56 开始打印,排队:161,票券:2407211916503704243501,订单:24072119165037037025,[2024-07-21 19:16:50微信支付10元]
2024-07-21 19:16:56 开始打印,排队:162,票券:2407211916503704445102,订单:24072119165037037025,[2024-07-21 19:16:50微信支付10元]
2024-07-21 19:17:00 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407211916503704243501","queue_number":161,"trade_uid":"24072119165037037025"},{"ticket_no":"2407211916503704445102","queue_number":162,"trade_uid":"24072119165037037025"}]}
2024-07-21 19:17:00 >>>故障排除日志:删除未同步下发订单成功24072119165037037025
2024-07-21 19:17:00 >>>故障排除日志:删除未同步下发订单成功24072119165037037025
2024-07-21 19:17:00 >>>故障排除日志:终端同步成功后剩余订单列表


===19:21:14===
2024-07-21 19:20:44 >>>回调事件[910,devices/S2040]
2024-07-21 19:20:44 >>>故障排除日志:上一MQTT订单号缓存列表为24072119165037037025|24072119165037037025
2024-07-21 19:20:44 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 19:20:44 开始打印,排队:163,票券:2407211920376281229101,订单:24072119203762808892,[2024-07-21 19:20:37微信支付10元]
2024-07-21 19:20:44 开始打印,排队:164,票券:2407211920376281354502,订单:24072119203762808892,[2024-07-21 19:20:37微信支付10元]
2024-07-21 19:20:48 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407211920376281229101","queue_number":163,"trade_uid":"24072119203762808892"},{"ticket_no":"2407211920376281354502","queue_number":164,"trade_uid":"24072119203762808892"}]}
2024-07-21 19:20:48 >>>故障排除日志:删除未同步下发订单成功24072119203762808892
2024-07-21 19:20:48 >>>故障排除日志:删除未同步下发订单成功24072119203762808892
2024-07-21 19:20:48 >>>故障排除日志:终端同步成功后剩余订单列表


===19:25:14===
2024-07-21 19:24:36 >>>回调事件[910,devices/S2040]
2024-07-21 19:24:36 >>>故障排除日志:上一MQTT订单号缓存列表为24072119203762808892|24072119203762808892
2024-07-21 19:24:36 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 19:24:36 开始打印,排队:165,票券:2407211924305789758401,订单:24072119243057893208,[2024-07-21 19:24:30微信支付10元]
2024-07-21 19:24:38 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407211924305789758401","queue_number":165,"trade_uid":"24072119243057893208"}]}
2024-07-21 19:24:38 >>>故障排除日志:删除未同步下发订单成功24072119243057893208
2024-07-21 19:24:38 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


===19:36:16===
2024-07-21 19:35:35 >>>回调事件[910,devices/S2040]
2024-07-21 19:35:35 >>>故障排除日志:上一MQTT订单号缓存列表为24072119322707316920
2024-07-21 19:35:35 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 19:35:35 开始打印,排队:170,票券:2407211935288195722001,订单:24072119352881953625,[2024-07-21 19:35:28微信支付10元]
2024-07-21 19:35:35 开始打印,排队:171,票券:2407211935288195853902,订单:24072119352881953625,[2024-07-21 19:35:28微信支付10元]
2024-07-21 19:35:38 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407211935288195722001","queue_number":170,"trade_uid":"24072119352881953625"},{"ticket_no":"2407211935288195853902","queue_number":171,"trade_uid":"24072119352881953625"}]}
2024-07-21 19:35:38 >>>故障排除日志:删除未同步下发订单成功24072119352881953625
2024-07-21 19:35:38 >>>故障排除日志:删除未同步下发订单成功24072119352881953625
2024-07-21 19:35:38 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


===19:47:16===
2024-07-21 19:47:06 >>>回调事件[910,devices/S2040]
2024-07-21 19:47:06 >>>故障排除日志:上一MQTT订单号缓存列表为24072119452976968009
2024-07-21 19:47:06 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 19:47:06 开始打印,排队:174,票券:2407211947010142640901,订单:24072119470101423097,[2024-07-21 19:47:01微信支付10元]
2024-07-21 19:47:06 开始打印,排队:175,票券:2407211947010142781902,订单:24072119470101423097,[2024-07-21 19:47:01微信支付10元]
2024-07-21 19:47:10 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407211947010142640901","queue_number":174,"trade_uid":"24072119470101423097"},{"ticket_no":"2407211947010142781902","queue_number":175,"trade_uid":"24072119470101423097"}]}
2024-07-21 19:47:10 >>>故障排除日志:删除未同步下发订单成功24072119470101423097
2024-07-21 19:47:10 >>>故障排除日志:删除未同步下发订单成功24072119470101423097
2024-07-21 19:47:10 >>>故障排除日志:终端同步成功后剩余订单列表


===19:52:16===
2024-07-21 19:51:24 >>>回调事件[910,devices/S2040]
2024-07-21 19:51:24 >>>故障排除日志:上一MQTT订单号缓存列表为24072119470101423097|24072119470101423097
2024-07-21 19:51:24 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 19:51:24 开始打印,排队:176,票券:2407211951170458539601,订单:24072119511704580875,[2024-07-21 19:51:17微信支付10元]
2024-07-21 19:51:26 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407211951170458539601","queue_number":176,"trade_uid":"24072119511704580875"}]}
2024-07-21 19:51:26 >>>故障排除日志:删除未同步下发订单成功24072119511704580875
2024-07-21 19:51:26 >>>故障排除日志:终端同步成功后剩余订单列表
2024-07-21 19:52:00 >>>回调事件[910,devices/S2040]
2024-07-21 19:52:00 >>>故障排除日志:上一MQTT订单号缓存列表为24072119511704580875
2024-07-21 19:52:00 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 19:52:00 开始打印,排队:177,票券:2407211951545559204201,订单:24072119515455585335,[2024-07-21 19:51:54支付宝支付10元]
2024-07-21 19:52:02 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407211951545559204201","queue_number":177,"trade_uid":"24072119515455585335"}]}
2024-07-21 19:52:02 >>>故障排除日志:删除未同步下发订单成功24072119515455585335
2024-07-21 19:52:02 >>>故障排除日志:终端同步成功后剩余订单列表


===19:55:16===
2024-07-21 19:54:43>>>cash read=00
2024-07-21 19:54:43>>>cash read=818F42
2024-07-21 19:54:43>>>cash write=02
2024-07-21 19:54:43 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-07-21 19:54:44>>>cash read=10
2024-07-21 19:54:44 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-07-21 19:54:44 >>>开始打印,排队号为178,订单号为2407211954440020405627
2024-07-21 19:54:44>>>订单2407211954440020405627写入成功,剩余空间为1675000,占用RAM为600.357421875
删除未同步订单2407211954440020405627
2024-07-21 19:54:46>>>订单2407211954440020405627删除成功,剩余空间为1675000,占用RAM为615.6787109375
检测订单目录中>>>
无未同步订单>>>
2024-07-21 19:54:46 >>>当前Ram内存为585.609375
定时检测未同步订单启用
2024-07-21 19:54:47>>>cash write=0C
2024-07-21 19:54:47>>>cash read=3E
2024-07-21 19:55:09 >>>回调事件[910,devices/S2040]
2024-07-21 19:55:09 >>>故障排除日志:上一MQTT订单号缓存列表为24072119515455585335
2024-07-21 19:55:09 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 19:55:09 开始打印,排队:179,票券:2407211955049045281501,订单:24072119550490447153,[2024-07-21 19:55:04微信支付10元]
2024-07-21 19:55:11 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407211955049045281501","queue_number":179,"trade_uid":"24072119550490447153"}]}
2024-07-21 19:55:11 >>>故障排除日志:删除未同步下发订单成功24072119550490447153
2024-07-21 19:55:11 >>>故障排除日志:终端同步成功后剩余订单列表


===19:56:17===
2024-07-21 19:55:22 >>>回调事件[910,devices/S2040]
2024-07-21 19:55:22 >>>故障排除日志:上一MQTT订单号缓存列表为24072119550490447153
2024-07-21 19:55:22 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 19:55:22 开始打印,排队:180,票券:2407211955126070000701,订单:24072119551260695497,[2024-07-21 19:55:12支付宝支付10元]
2024-07-21 19:55:24 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407211955126070000701","queue_number":180,"trade_uid":"24072119551260695497"}]}
2024-07-21 19:55:24 >>>故障排除日志:删除未同步下发订单成功24072119551260695497
2024-07-21 19:55:24 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单关闭
检测订单目录中>>>
无未同步订单>>>


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


===20:02:17===
2024-07-21 20:01:45 >>>回调事件[910,devices/S2040]
2024-07-21 20:01:45 >>>故障排除日志:上一MQTT订单号缓存列表为24072119590318523968
2024-07-21 20:01:45 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 20:01:45 开始打印,排队:182,票券:2407212001389899900601,订单:24072120013898995612,[2024-07-21 20:01:38微信支付10元]
2024-07-21 20:01:47 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407212001389899900601","queue_number":182,"trade_uid":"24072120013898995612"}]}
2024-07-21 20:01:47 >>>故障排除日志:删除未同步下发订单成功24072120013898995612
2024-07-21 20:01:47 >>>故障排除日志:终端同步成功后剩余订单列表
2024-07-21 20:01:55 >>>回调事件[910,devices/S2040]
2024-07-21 20:01:55 >>>故障排除日志:上一MQTT订单号缓存列表为24072120013898995612
2024-07-21 20:01:55 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 20:01:55 开始打印,排队:183,票券:2407212001452716324901,订单:24072120014527157342,[2024-07-21 20:01:45微信支付10元]
2024-07-21 20:01:57 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407212001452716324901","queue_number":183,"trade_uid":"24072120014527157342"}]}
2024-07-21 20:01:57 >>>故障排除日志:删除未同步下发订单成功24072120014527157342
2024-07-21 20:01:57 >>>故障排除日志:终端同步成功后剩余订单列表


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


===20:07:18===
2024-07-21 20:07:04>>>cash read=00
2024-07-21 20:07:05>>>cash read=818F42
2024-07-21 20:07:05>>>cash write=02
2024-07-21 20:07:05 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-07-21 20:07:05>>>cash read=10
2024-07-21 20:07:05 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-07-21 20:07:05 >>>开始打印,排队号为185,订单号为2407212007050020408496
2024-07-21 20:07:05>>>订单2407212007050020408496写入成功,剩余空间为1675000,占用RAM为600.2763671875
删除未同步订单2407212007050020408496
2024-07-21 20:07:08>>>订单2407212007050020408496删除成功,剩余空间为1675000,占用RAM为615.8701171875
检测订单目录中>>>
无未同步订单>>>
2024-07-21 20:07:08 >>>当前Ram内存为585.6572265625
定时检测未同步订单启用
2024-07-21 20:07:09>>>cash write=0C
2024-07-21 20:07:09>>>cash read=3E


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


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


===20:14:18===
2024-07-21 20:13:22 >>>回调事件[910,devices/S2040]
2024-07-21 20:13:22 >>>故障排除日志:上一MQTT订单号缓存列表为24072120125270183153
2024-07-21 20:13:22 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 20:13:22 开始打印,排队:187,票券:2407212013162155691901,订单:24072120131621553109,[2024-07-21 20:13:16支付宝支付10元]
2024-07-21 20:13:25 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407212013162155691901","queue_number":187,"trade_uid":"24072120131621553109"}]}
2024-07-21 20:13:25 >>>故障排除日志:删除未同步下发订单成功24072120131621553109
2024-07-21 20:13:25 >>>故障排除日志:终端同步成功后剩余订单列表


===20:15:19===
2024-07-21 20:14:51 >>>回调事件[910,devices/S2040]
2024-07-21 20:14:51 >>>故障排除日志:上一MQTT订单号缓存列表为24072120131621553109
2024-07-21 20:14:51 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 20:14:51 开始打印,排队:188,票券:2407212014450557407801,订单:24072120144505569413,[2024-07-21 20:14:45微信支付10元]
2024-07-21 20:14:51 开始打印,排队:189,票券:2407212014450557656202,订单:24072120144505569413,[2024-07-21 20:14:45微信支付10元]
2024-07-21 20:14:51 开始打印,排队:190,票券:2407212014450557777103,订单:24072120144505569413,[2024-07-21 20:14:45微信支付10元]
2024-07-21 20:14:56 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407212014450557407801","queue_number":188,"trade_uid":"24072120144505569413"},{"ticket_no":"2407212014450557656202","queue_number":189,"trade_uid":"24072120144505569413"},{"ticket_no":"2407212014450557777103","queue_number":190,"trade_uid":"24072120144505569413"}]}
2024-07-21 20:14:56 >>>故障排除日志:删除未同步下发订单成功24072120144505569413
2024-07-21 20:14:56 >>>故障排除日志:删除未同步下发订单成功24072120144505569413
2024-07-21 20:14:56 >>>故障排除日志:删除未同步下发订单成功24072120144505569413
2024-07-21 20:14:56 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


===21:22:19===
2024-07-21 21:22:09 收到下发指令:叫号1>>>
2024-07-21 21:22:12 收到下发指令:叫号1>>>
2024-07-21 21:22:15 收到下发指令:叫号1>>>


===21:23:19===
2024-07-21 21:22:19 收到下发指令:叫号1>>>
2024-07-21 21:22:25 收到下发指令:叫号1>>>
2024-07-21 21:22:28 收到下发指令:叫号1>>>
2024-07-21 21:22:31 收到下发指令:叫号1>>>
2024-07-21 21:22:35 收到下发指令:叫号1>>>
2024-07-21 21:22:38 收到下发指令:叫号1>>>
2024-07-21 21:22:41 收到下发指令:叫号1>>>
2024-07-21 21:22:44 收到下发指令:叫号1>>>
2024-07-21 21:22:50 收到下发指令:叫号1>>>
2024-07-21 21:22:53 收到下发指令:叫号1>>>
2024-07-21 21:22:56 收到下发指令:叫号1>>>
2024-07-21 21:22:59 收到下发指令:叫号1>>>
2024-07-21 21:23:02 收到下发指令:叫号1>>>
2024-07-21 21:23:05 收到下发指令:叫号1>>>
2024-07-21 21:23:09 收到下发指令:叫号1>>>
2024-07-21 21:23:12 收到下发指令:叫号1>>>
2024-07-21 21:23:16 收到下发指令:叫号1>>>


===21:24:20===
2024-07-21 21:23:19 收到下发指令:叫号1>>>
2024-07-21 21:23:23 收到下发指令:叫号1>>>
2024-07-21 21:23:29 收到下发指令:叫号1>>>
2024-07-21 21:23:32 收到下发指令:叫号1>>>
2024-07-21 21:23:36 收到下发指令:叫号1>>>
2024-07-21 21:23:39 收到下发指令:叫号1>>>
2024-07-21 21:23:43 收到下发指令:叫号1>>>
2024-07-21 21:23:47 收到下发指令:叫号1>>>
2024-07-21 21:23:50 收到下发指令:叫号1>>>
2024-07-21 21:23:54 收到下发指令:叫号1>>>
2024-07-21 21:23:57 收到下发指令:叫号1>>>
2024-07-21 21:24:00 收到下发指令:叫号1>>>
2024-07-21 21:24:04 收到下发指令:叫号1>>>
2024-07-21 21:24:07 收到下发指令:叫号1>>>
2024-07-21 21:24:11 收到下发指令:叫号1>>>
2024-07-21 21:24:14 收到下发指令:叫号1>>>


===21:25:20===
2024-07-21 21:24:20 收到下发指令:叫号1>>>
2024-07-21 21:24:24 收到下发指令:叫号1>>>
2024-07-21 21:24:27 收到下发指令:叫号1>>>
2024-07-21 21:24:31 收到下发指令:叫号1>>>
2024-07-21 21:24:34 收到下发指令:叫号1>>>
2024-07-21 21:24:37 收到下发指令:叫号1>>>
2024-07-21 21:24:41 收到下发指令:叫号1>>>
2024-07-21 21:24:49 收到下发指令:叫号1>>>


===21:26:20===
2024-07-21 21:25:22 收到下发指令:叫号1>>>
2024-07-21 21:25:25 收到下发指令:叫号1>>>
2024-07-21 21:25:29 收到下发指令:叫号1>>>
2024-07-21 21:25:33 收到下发指令:叫号1>>>
2024-07-21 21:25:36 收到下发指令:叫号1>>>
2024-07-21 21:25:39 收到下发指令:叫号1>>>
2024-07-21 21:25:42 收到下发指令:叫号1>>>
2024-07-21 21:25:45 收到下发指令:叫号1>>>
2024-07-21 21:25:48 收到下发指令:叫号1>>>
2024-07-21 21:25:52 收到下发指令:叫号1>>>
2024-07-21 21:25:56 收到下发指令:叫号1>>>
2024-07-21 21:25:59 收到下发指令:叫号1>>>
2024-07-21 21:26:03 收到下发指令:叫号1>>>
2024-07-21 21:26:08 收到下发指令:叫号1>>>
2024-07-21 21:26:11 收到下发指令:叫号1>>>
2024-07-21 21:26:14 收到下发指令:叫号1>>>
2024-07-21 21:26:18 收到下发指令:叫号1>>>


===21:27:20===
2024-07-21 21:26:22 收到下发指令:叫号1>>>
2024-07-21 21:26:25 收到下发指令:叫号1>>>
2024-07-21 21:26:29 收到下发指令:叫号1>>>
2024-07-21 21:26:33 收到下发指令:叫号1>>>
2024-07-21 21:26:37 收到下发指令:叫号1>>>
2024-07-21 21:26:40 收到下发指令:叫号1>>>
2024-07-21 21:26:44 收到下发指令:叫号1>>>
2024-07-21 21:26:47 收到下发指令:叫号1>>>
2024-07-21 21:26:52 收到下发指令:叫号1>>>
2024-07-21 21:27:01 收到下发指令:叫号1>>>
2024-07-21 21:27:04 收到下发指令:叫号1>>>
2024-07-21 21:27:09 收到下发指令:叫号1>>>
2024-07-21 21:27:13 收到下发指令:叫号1>>>
2024-07-21 21:27:17 收到下发指令:叫号1>>>


===21:28:20===
2024-07-21 21:27:21 收到下发指令:叫号1>>>
2024-07-21 21:27:24 收到下发指令:叫号1>>>
2024-07-21 21:27:29 收到下发指令:叫号1>>>
2024-07-21 21:27:33 收到下发指令:叫号1>>>
2024-07-21 21:27:36 收到下发指令:叫号1>>>
2024-07-21 21:27:40 收到下发指令:叫号1>>>
2024-07-21 21:27:46 收到下发指令:叫号1>>>
2024-07-21 21:27:51 收到下发指令:叫号1>>>
2024-07-21 21:27:54 收到下发指令:叫号1>>>
2024-07-21 21:28:02 收到下发指令:叫号1>>>
2024-07-21 21:28:09 收到下发指令:叫号1>>>
2024-07-21 21:28:12 收到下发指令:叫号3>>>
2024-07-21 21:28:15 收到下发指令:叫号3>>>


===21:29:20===
2024-07-21 21:28:19 收到下发指令:叫号3>>>
2024-07-21 21:28:22 收到下发指令:叫号3>>>
2024-07-21 21:28:25 收到下发指令:叫号3>>>
2024-07-21 21:28:28 收到下发指令:叫号3>>>
2024-07-21 21:28:31 收到下发指令:叫号3>>>
2024-07-21 21:28:35 收到下发指令:叫号3>>>
2024-07-21 21:28:38 收到下发指令:叫号3>>>
2024-07-21 21:28:41 收到下发指令:叫号3>>>
2024-07-21 21:28:44 收到下发指令:叫号3>>>
2024-07-21 21:28:48 收到下发指令:叫号3>>>
2024-07-21 21:28:51 收到下发指令:叫号3>>>
2024-07-21 21:28:56 收到下发指令:叫号3>>>
2024-07-21 21:29:00 收到下发指令:叫号3>>>
2024-07-21 21:29:04 收到下发指令:叫号3>>>
2024-07-21 21:29:07 收到下发指令:叫号3>>>
2024-07-21 21:29:10 收到下发指令:叫号3>>>
2024-07-21 21:29:13 收到下发指令:叫号3>>>
2024-07-21 21:29:17 收到下发指令:叫号3>>>


===21:30:20===
2024-07-21 21:29:20 收到下发指令:叫号3>>>
2024-07-21 21:29:23 收到下发指令:叫号6>>>
2024-07-21 21:29:28 收到下发指令:叫号8>>>
2024-07-21 21:29:32 收到下发指令:叫号12>>>
2024-07-21 21:29:36 收到下发指令:叫号12>>>
2024-07-21 21:29:44 收到下发指令:叫号12>>>
2024-07-21 21:29:48 收到下发指令:叫号12>>>
2024-07-21 21:29:51 收到下发指令:叫号12>>>
2024-07-21 21:29:54 收到下发指令:叫号12>>>
2024-07-21 21:30:02 收到下发指令:叫号12>>>


===23:03:21===
2024-07-21 23:02:37>>>cash read=9E
2024-07-21 23:02:38>>>cash read=3E