TLClient_JSSCOM_LuatOS-Air_V4010_RDA8910_RFTTS_0xe0000,2.5.4,869701076438798,79971258076835,
poweron reason:0

===07:30:30===
上一时间戳为1727395250
隔日重置时间戳true
隔日清空未同步下发列表true
当前排队号为1,音量为5
初始化产品信息:[{"time_limit_date":"","ticket_category":"0","expiry_date":90,"product_detail":"","time_limit_status":"0","begin_minute":"00","product_uid":"12711098232277568446","use_timer":1,"old_price":"10","end_hour":"23","sale_price":"10","end_minute":"59","begin_hour":"00","sale_status":1,"product_name":"剪发一律10元"}]
打印门店标题设置为欢迎光临平剪（龙港大润发超市）
是否打印二维码设置为1
是否打印紧凑设置为3
session_id:482d9****27a2e
纸币器设置接收纸币范围为36
欢迎使用天羚自助售票系统[2.5.4]
定时检测未同步订单启用
2024-09-28 07:29:29>>>cash write=30
2024-09-28 07:29:29>>>cash write=02
2024-09-28 07:29:29>>>cash write=3E
2024-09-28 07:29:29>>>cash read=808F808F
系统时间初始化成功，时间为202492872929
2024-09-28 07:29:30>>>cash write=02
2024-09-28 07:29:30 >>>剩余flash空间=1680500,占用RAM为625.34765625
2024-09-28 07:29:30 >>>回调事件:910,subscribe,10000,连接服务器成功

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

2024-09-28 07:29:33>>>cash write=0C
2024-09-28 07:29:33>>>cash read=3E
流量卡还有337天过期
2024-09-28 07:29:40 >>>当前Ram内存为643.822265625


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


===07:59:30===
2024-09-28 07:58:44>>>cash read=00
2024-09-28 07:58:45>>>cash read=818F42
2024-09-28 07:58:45>>>cash write=02
2024-09-28 07:58:45 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-09-28 07:58:45>>>cash read=10
2024-09-28 07:58:45 >>>回调事件130,10,10023,finish Money=10,进钞完成
当日首次设置时间戳true为1727481525
2024-09-28 07:58:45 当前产品价格10元，投币10元，打印小票中...
2024-09-28 07:58:45 >>>开始打印,排队号为1,订单号为2409280758450005196532
2024-09-28 07:58:46>>>订单2409280758450005196532写入成功,剩余空间为1679500,占用RAM为607.4482421875
删除未同步订单2409280758450005196532
2024-09-28 07:58:48>>>订单2409280758450005196532删除成功,剩余空间为1680500,占用RAM为617.9150390625
检测订单目录中>>>
无未同步订单>>>
2024-09-28 07:58:48 >>>当前Ram内存为589.9677734375
定时检测未同步订单启用
2024-09-28 07:58:49>>>cash write=0C
2024-09-28 07:58:49>>>cash read=3E


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


===09:03:35===
2024-09-28 09:03:31>>>cash read=00
2024-09-28 09:03:31>>>cash read=818F42
2024-09-28 09:03:31>>>cash write=02
2024-09-28 09:03:31 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-09-28 09:03:32>>>cash read=10
2024-09-28 09:03:32 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-09-28 09:03:32 当前产品价格10元，投币10元，打印小票中...
2024-09-28 09:03:32 >>>开始打印,排队号为19,订单号为2409280903320005191711
2024-09-28 09:03:32>>>订单2409280903320005191711写入成功,剩余空间为1680000,占用RAM为607.9580078125


===09:04:36===
删除未同步订单2409280903320005191711
2024-09-28 09:03:34>>>订单2409280903320005191711删除成功,剩余空间为1681500,占用RAM为623.8720703125
检测订单目录中>>>
无未同步订单>>>
2024-09-28 09:03:34 >>>当前Ram内存为591.7021484375
定时检测未同步订单启用
2024-09-28 09:03:35>>>cash write=0C
2024-09-28 09:03:35>>>cash read=3E


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


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


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


===09:11:36===
2024-09-28 09:11:11>>>cash read=0A
2024-09-28 09:11:12>>>cash read=3E


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


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


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


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


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


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


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


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


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


===09:32:38===
2024-09-28 09:32:34>>>cash read=00
2024-09-28 09:32:36>>>cash read=2F29


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


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


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


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


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


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


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


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


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


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


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


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


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


===10:12:42===
2024-09-28 10:12:00>>>cash read=29
2024-09-28 10:12:00 >>>回调事件130,cash_status,20029,退钞中
2024-09-28 10:12:01>>>cash read=3E
2024-09-28 10:12:02>>>cash read=00
2024-09-28 10:12:03>>>cash read=2F29
2024-09-28 10:12:04>>>cash read=01
2024-09-28 10:12:08>>>cash read=2F
2024-09-28 10:12:09>>>cash read=29
2024-09-28 10:12:09 >>>回调事件130,cash_status,20029,退钞中
2024-09-28 10:12:10>>>cash read=01
2024-09-28 10:12:21>>>cash read=3E
2024-09-28 10:12:29>>>cash read=00
2024-09-28 10:12:30>>>cash read=818F42
2024-09-28 10:12:30>>>cash write=02
2024-09-28 10:12:30 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-09-28 10:12:30>>>cash read=10
2024-09-28 10:12:30 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-09-28 10:12:30 当前产品价格10元，投币10元，打印小票中...
2024-09-28 10:12:30 >>>开始打印,排队号为45,订单号为2409281012300005194650
2024-09-28 10:12:31>>>订单2409281012300005194650写入成功,剩余空间为1679500,占用RAM为612.5087890625
删除未同步订单2409281012300005194650
2024-09-28 10:12:33>>>订单2409281012300005194650删除成功,剩余空间为1680000,占用RAM为623.4873046875
检测订单目录中>>>
无未同步订单>>>
2024-09-28 10:12:33 >>>当前Ram内存为593.037109375
定时检测未同步订单启用
2024-09-28 10:12:34>>>cash write=0C
2024-09-28 10:12:34>>>cash read=3E


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


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


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


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


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


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


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


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


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


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


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


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


===10:50:44===
2024-09-28 10:50:01 >>>回调事件[910,devices/D0519]
2024-09-28 10:50:01 >>>故障排除日志:上一MQTT订单号缓存列表为24092810465426115312
2024-09-28 10:50:01 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 10:50:01 开始打印,排队:55,票券:2409281049496690772901,订单:24092810494966903615,[2024-09-28 10:50:01微信支付10元]
2024-09-28 10:50:03 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281049496690772901","queue_number":55,"trade_uid":"24092810494966903615"}]}
2024-09-28 10:50:03 >>>故障排除日志:删除未同步下发订单成功24092810494966903615
2024-09-28 10:50:03 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 10:50:35 >>>回调事件[910,devices/D0519]
2024-09-28 10:50:35 >>>故障排除日志:上一MQTT订单号缓存列表为24092810494966903615
2024-09-28 10:50:35 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 10:50:35 开始打印,排队:56,票券:2409281050276938109101,订单:24092810502769377051,[2024-09-28 10:50:35微信支付10元]
2024-09-28 10:50:37 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281050276938109101","queue_number":56,"trade_uid":"24092810502769377051"}]}
2024-09-28 10:50:37 >>>故障排除日志:删除未同步下发订单成功24092810502769377051
2024-09-28 10:50:37 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


===12:40:49===
2024-09-28 12:39:55 >>>回调事件[910,devices/D0519]
2024-09-28 12:39:55 >>>故障排除日志:上一MQTT订单号缓存列表为24092812363792166736|24092812363792166736
2024-09-28 12:39:55 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 12:39:55 开始打印,排队:76,票券:2409281239420899350201,订单:24092812394208984938,[2024-09-28 12:39:55微信支付10元]
2024-09-28 12:39:55 开始打印,排队:77,票券:2409281239420899779302,订单:24092812394208984938,[2024-09-28 12:39:55微信支付10元]
2024-09-28 12:39:59 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281239420899350201","queue_number":76,"trade_uid":"24092812394208984938"},{"ticket_no":"2409281239420899779302","queue_number":77,"trade_uid":"24092812394208984938"}]}
2024-09-28 12:39:59 >>>故障排除日志:删除未同步下发订单成功24092812394208984938
2024-09-28 12:39:59 >>>故障排除日志:删除未同步下发订单成功24092812394208984938
2024-09-28 12:39:59 >>>故障排除日志:终端同步成功后剩余订单列表


===12:44:49===
2024-09-28 12:44:09 >>>回调事件[910,devices/D0519]
2024-09-28 12:44:09 >>>故障排除日志:上一MQTT订单号缓存列表为24092812394208984938|24092812394208984938
2024-09-28 12:44:09 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 12:44:09 开始打印,排队:78,票券:2409281243552845071001,订单:24092812435528445631,[2024-09-28 12:44:09支付宝支付10元]
2024-09-28 12:44:09 开始打印,排队:79,票券:2409281243552845280102,订单:24092812435528445631,[2024-09-28 12:44:09支付宝支付10元]
2024-09-28 12:44:13 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281243552845071001","queue_number":78,"trade_uid":"24092812435528445631"},{"ticket_no":"2409281243552845280102","queue_number":79,"trade_uid":"24092812435528445631"}]}
2024-09-28 12:44:13 >>>故障排除日志:删除未同步下发订单成功24092812435528445631
2024-09-28 12:44:13 >>>故障排除日志:删除未同步下发订单成功24092812435528445631
2024-09-28 12:44:13 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


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


===13:07:50===
2024-09-28 13:07:10 >>>回调事件[910,devices/D0519]
2024-09-28 13:07:10 >>>故障排除日志:上一MQTT订单号缓存列表为24092813051650992959
2024-09-28 13:07:10 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 13:07:10 开始打印,排队:85,票券:2409281307046941038701,订单:24092813070469406557,[2024-09-28 13:07:10微信支付10元]
2024-09-28 13:07:12 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281307046941038701","queue_number":85,"trade_uid":"24092813070469406557"}]}
2024-09-28 13:07:12 >>>故障排除日志:删除未同步下发订单成功24092813070469406557
2024-09-28 13:07:12 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 13:07:23 >>>回调事件[910,devices/D0519]
2024-09-28 13:07:23 >>>故障排除日志:上一MQTT订单号缓存列表为24092813070469406557
2024-09-28 13:07:23 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 13:07:23 开始打印,排队:86,票券:2409281307137166100101,订单:24092813071371656804,[2024-09-28 13:07:23支付宝支付10元]
2024-09-28 13:07:23 开始打印,排队:87,票券:2409281307137166269602,订单:24092813071371656804,[2024-09-28 13:07:23支付宝支付10元]
2024-09-28 13:07:27 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281307137166100101","queue_number":86,"trade_uid":"24092813071371656804"},{"ticket_no":"2409281307137166269602","queue_number":87,"trade_uid":"24092813071371656804"}]}
2024-09-28 13:07:27 >>>故障排除日志:删除未同步下发订单成功24092813071371656804
2024-09-28 13:07:27 >>>故障排除日志:删除未同步下发订单成功24092813071371656804
2024-09-28 13:07:27 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


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


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


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


===13:35:52===
2024-09-28 13:34:54 >>>回调事件[910,devices/D0519]
2024-09-28 13:34:54 >>>故障排除日志:上一MQTT订单号缓存列表为24092813341543056239
2024-09-28 13:34:54 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 13:34:54 开始打印,排队:95,票券:2409281334424351990901,订单:24092813344243514156,[2024-09-28 13:34:54微信支付10元]
2024-09-28 13:34:56 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281334424351990901","queue_number":95,"trade_uid":"24092813344243514156"}]}
2024-09-28 13:34:56 >>>故障排除日志:删除未同步下发订单成功24092813344243514156
2024-09-28 13:34:56 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 13:35:38 >>>回调事件[910,devices/D0519]
2024-09-28 13:35:38 >>>故障排除日志:上一MQTT订单号缓存列表为24092813344243514156
2024-09-28 13:35:38 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 13:35:38 开始打印,排队:96,票券:2409281335297965614301,订单:24092813352979653110,[2024-09-28 13:35:38微信支付10元]
2024-09-28 13:35:40 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281335297965614301","queue_number":96,"trade_uid":"24092813352979653110"}]}
2024-09-28 13:35:40 >>>故障排除日志:删除未同步下发订单成功24092813352979653110
2024-09-28 13:35:41 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


===13:55:54===
2024-09-28 13:55:09>>>cash read=0A
2024-09-28 13:55:11>>>cash read=3E


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


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


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


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


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


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


===14:11:57===
2024-09-28 14:10:56 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281410471988079401","queue_number":107,"trade_uid":"24092814104719876031"}]}
2024-09-28 14:10:56 >>>故障排除日志:删除未同步下发订单成功24092814104719876031
2024-09-28 14:10:56 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


===15:36:05===
2024-09-28 15:36:02 >>>回调事件[910,devices/D0519]
2024-09-28 15:36:02 >>>故障排除日志:上一MQTT订单号缓存列表为24092815323040263030
2024-09-28 15:36:02 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 15:36:02 开始打印,排队:133,票券:2409281535560237756701,订单:24092815355602373238,[2024-09-28 15:36:02支付宝支付10元]


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


===15:39:06===
2024-09-28 15:38:59>>>cash read=00
2024-09-28 15:39:00>>>cash read=2F29
2024-09-28 15:39:01>>>cash read=01
2024-09-28 15:39:01>>>cash read=2F
2024-09-28 15:39:03>>>cash read=3E


===15:40:06===
2024-09-28 15:39:12>>>cash read=00
2024-09-28 15:39:12>>>cash read=2F29
2024-09-28 15:39:13>>>cash read=012F
2024-09-28 15:39:15>>>cash read=3E
2024-09-28 15:39:17>>>cash read=00
2024-09-28 15:39:19>>>cash read=2F29
2024-09-28 15:39:20>>>cash read=3E
2024-09-28 15:39:24>>>cash read=01
2024-09-28 15:39:27>>>cash read=3E
2024-09-28 15:39:30>>>cash read=00
2024-09-28 15:39:31>>>cash read=818F42
2024-09-28 15:39:31>>>cash write=02
2024-09-28 15:39:31 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-09-28 15:39:32>>>cash read=10
2024-09-28 15:39:32 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-09-28 15:39:32 当前产品价格10元，投币10元，打印小票中...
2024-09-28 15:39:32 >>>开始打印,排队号为135,订单号为2409281539320005193103
2024-09-28 15:39:32>>>订单2409281539320005193103写入成功,剩余空间为1679500,占用RAM为608.0849609375
删除未同步订单2409281539320005193103
2024-09-28 15:39:34>>>订单2409281539320005193103删除成功,剩余空间为1680500,占用RAM为616.03515625
检测订单目录中>>>
无未同步订单>>>
2024-09-28 15:39:34 >>>当前Ram内存为588.9326171875
定时检测未同步订单启用
2024-09-28 15:39:35>>>cash write=0C
2024-09-28 15:39:35>>>cash read=3E


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


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


===15:46:07===
2024-09-28 15:45:57 >>>回调事件[910,devices/D0519]
2024-09-28 15:45:57 >>>故障排除日志:上一MQTT订单号缓存列表为24092815444731319958
2024-09-28 15:45:57 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 15:45:57 开始打印,排队:137,票券:2409281545503916683701,订单:24092815455039162782,[2024-09-28 15:45:57支付宝支付10元]
2024-09-28 15:45:57 开始打印,排队:138,票券:2409281545503916835602,订单:24092815455039162782,[2024-09-28 15:45:57支付宝支付10元]
2024-09-28 15:46:01 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281545503916683701","queue_number":137,"trade_uid":"24092815455039162782"},{"ticket_no":"2409281545503916835602","queue_number":138,"trade_uid":"24092815455039162782"}]}
2024-09-28 15:46:01 >>>故障排除日志:删除未同步下发订单成功24092815455039162782
2024-09-28 15:46:01 >>>故障排除日志:删除未同步下发订单成功24092815455039162782
2024-09-28 15:46:01 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 15:46:02>>>cash read=0A
2024-09-28 15:46:03>>>cash read=3E


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


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


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


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


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


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


TCP://log.tl-self.com:9807@28_16:06:21:connect fail
===16:08:28===
2024-09-28 16:08:24 >>>回调事件[910,devices/D0519]
2024-09-28 16:08:24 >>>故障排除日志:上一MQTT订单号缓存列表为24092816055165153028
2024-09-28 16:08:24 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 16:08:24 开始打印,排队:145,票券:2409281608165419311601,订单:24092816081654187762,[2024-09-28 16:08:23微信支付10元]
2024-09-28 16:08:26 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281608165419311601","queue_number":145,"trade_uid":"24092816081654187762"}]}
2024-09-28 16:08:26 >>>故障排除日志:删除未同步下发订单成功24092816081654187762
2024-09-28 16:08:26 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


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


===16:24:30===
2024-09-28 16:23:38 >>>回调事件[910,devices/D0519]
2024-09-28 16:23:38 >>>故障排除日志:上一MQTT订单号缓存列表为24092816215629954658
2024-09-28 16:23:38 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 16:23:38 开始打印,排队:151,票券:2409281623301556668201,订单:24092816233015562101,[2024-09-28 16:23:37微信支付10元]
2024-09-28 16:23:40 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281623301556668201","queue_number":151,"trade_uid":"24092816233015562101"}]}
2024-09-28 16:23:40 >>>故障排除日志:删除未同步下发订单成功24092816233015562101
2024-09-28 16:23:40 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 16:24:05>>>cash read=00
2024-09-28 16:24:06>>>cash read=01
2024-09-28 16:24:08>>>cash read=3E
2024-09-28 16:24:09>>>cash read=00
2024-09-28 16:24:10>>>cash read=818F42
2024-09-28 16:24:10>>>cash write=02
2024-09-28 16:24:10 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-09-28 16:24:11>>>cash read=10
2024-09-28 16:24:11 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-09-28 16:24:11 当前产品价格10元，投币10元，打印小票中...
2024-09-28 16:24:11 >>>开始打印,排队号为152,订单号为2409281624110005198232
2024-09-28 16:24:11>>>订单2409281624110005198232写入成功,剩余空间为1679000,占用RAM为610.3857421875
删除未同步订单2409281624110005198232
2024-09-28 16:24:13>>>订单2409281624110005198232删除成功,剩余空间为1680000,占用RAM为618.748046875
检测订单目录中>>>
无未同步订单>>>
2024-09-28 16:24:13 >>>当前Ram内存为589.0498046875
定时检测未同步订单启用
2024-09-28 16:24:14>>>cash write=0C
2024-09-28 16:24:14>>>cash read=3E


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


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


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


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


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


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


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


===16:42:32===
2024-09-28 16:41:53 >>>回调事件[910,devices/D0519]
2024-09-28 16:41:53 >>>故障排除日志:上一MQTT订单号缓存列表为24092816364376758254
2024-09-28 16:41:53 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 16:41:53 开始打印,排队:159,票券:2409281641458800591601,订单:24092816414588001561,[2024-09-28 16:41:53微信支付10元]
2024-09-28 16:41:55 >>>回调事件[910,devices/D0519]
2024-09-28 16:41:55 >>>故障排除日志:上一MQTT订单号缓存列表为24092816414588001561
2024-09-28 16:41:55 >>>故障排除日志:终端未同步成功订单列表015924092816414588001561
已接收过此消息,票券号为2409281641458800591601,排队号为159
2024-09-28 16:41:55 开始打印,排队:160,票券:2409281641493758903101,订单:24092816414937584961,[2024-09-28 16:41:54微信支付10元]
2024-09-28 16:41:57 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281641458800591601","queue_number":159,"trade_uid":"24092816414588001561"}]}
2024-09-28 16:41:57 >>>故障排除日志:删除未同步下发订单成功24092816414588001561
2024-09-28 16:41:57 >>>故障排除日志:终端同步成功后剩余订单列表016024092816414937584961
2024-09-28 16:41:57 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281641458800591601","queue_number":159,"trade_uid":"24092816414588001561"},{"ticket_no":"2409281641493758903101","queue_number":160,"trade_uid":"24092816414937584961"}]}
2024-09-28 16:41:57 >>>故障排除日志:删除未同步下发订单成功24092816414937584961
2024-09-28 16:41:57 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 16:42:00 >>>回调事件[910,devices/D0519]
2024-09-28 16:42:00 >>>故障排除日志:上一MQTT订单号缓存列表为24092816414588001561|24092816414937584961
2024-09-28 16:42:00 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 16:42:00 开始打印,排队:161,票券:2409281641550418405901,订单:24092816415504178375,[2024-09-28 16:42:00支付宝支付10元]
2024-09-28 16:42:02 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281641550418405901","queue_number":161,"trade_uid":"24092816415504178375"}]}
2024-09-28 16:42:02 >>>故障排除日志:删除未同步下发订单成功24092816415504178375
2024-09-28 16:42:02 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


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


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


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


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


===17:03:34===
2024-09-28 17:02:40 >>>回调事件[910,devices/D0519]
2024-09-28 17:02:40 >>>故障排除日志:上一MQTT订单号缓存列表为24092817004151855197|24092817004151855197
2024-09-28 17:02:40 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 17:02:40 开始打印,排队:171,票券:2409281702335069015201,订单:24092817023350681730,[2024-09-28 17:02:39微信支付10元]
2024-09-28 17:02:40 开始打印,排队:172,票券:2409281702335069444902,订单:24092817023350681730,[2024-09-28 17:02:39微信支付10元]
2024-09-28 17:02:44 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281702335069015201","queue_number":171,"trade_uid":"24092817023350681730"},{"ticket_no":"2409281702335069444902","queue_number":172,"trade_uid":"24092817023350681730"}]}
2024-09-28 17:02:44 >>>故障排除日志:删除未同步下发订单成功24092817023350681730
2024-09-28 17:02:44 >>>故障排除日志:删除未同步下发订单成功24092817023350681730
2024-09-28 17:02:44 >>>故障排除日志:终端同步成功后剩余订单列表


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


===17:05:34===
2024-09-28 17:05:13 >>>回调事件[910,devices/D0519]
2024-09-28 17:05:13 >>>故障排除日志:上一MQTT订单号缓存列表为24092817041745294073|24092817041745294073
2024-09-28 17:05:13 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 17:05:13 开始打印,排队:175,票券:2409281705034358370701,订单:24092817050343579765,[2024-09-28 17:05:12支付宝支付10元]
2024-09-28 17:05:15 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281705034358370701","queue_number":175,"trade_uid":"24092817050343579765"}]}
2024-09-28 17:05:15 >>>故障排除日志:删除未同步下发订单成功24092817050343579765
2024-09-28 17:05:15 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 17:05:19 >>>回调事件[910,devices/D0519]
2024-09-28 17:05:19 >>>故障排除日志:上一MQTT订单号缓存列表为24092817050343579765
2024-09-28 17:05:19 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 17:05:19 开始打印,排队:176,票券:2409281705118714318101,订单:24092817051187139221,[2024-09-28 17:05:19微信支付10元]
2024-09-28 17:05:21 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281705118714318101","queue_number":176,"trade_uid":"24092817051187139221"}]}
2024-09-28 17:05:21 >>>故障排除日志:删除未同步下发订单成功24092817051187139221
2024-09-28 17:05:21 >>>故障排除日志:终端同步成功后剩余订单列表


===17:10:34===
2024-09-28 17:09:41>>>cash read=00
2024-09-28 17:09:42>>>cash read=29
2024-09-28 17:09:42 >>>回调事件130,cash_status,20029,退钞中
2024-09-28 17:09:43>>>cash read=01
2024-09-28 17:09:47>>>cash read=3E
2024-09-28 17:09:50>>>cash read=00
2024-09-28 17:09:51>>>cash read=00818F42
2024-09-28 17:09:51>>>cash write=02
2024-09-28 17:09:51 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-09-28 17:09:51>>>cash read=10
2024-09-28 17:09:51 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-09-28 17:09:51 当前产品价格10元，投币10元，打印小票中...
2024-09-28 17:09:51 >>>开始打印,排队号为177,订单号为2409281709510005193671
2024-09-28 17:09:52>>>订单2409281709510005193671写入成功,剩余空间为1679500,占用RAM为605.4189453125
删除未同步订单2409281709510005193671
2024-09-28 17:09:53>>>订单2409281709510005193671删除成功,剩余空间为1680500,占用RAM为614.7744140625
检测订单目录中>>>
无未同步订单>>>
2024-09-28 17:09:54 >>>当前Ram内存为588.62109375
定时检测未同步订单启用
2024-09-28 17:09:55>>>cash write=0C
2024-09-28 17:09:55>>>cash read=3E
2024-09-28 17:10:03 >>>回调事件[910,devices/D0519]
2024-09-28 17:10:03 >>>故障排除日志:上一MQTT订单号缓存列表为24092817051187139221
2024-09-28 17:10:03 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 17:10:03 开始打印,排队:178,票券:2409281709559258481901,订单:24092817095592580070,[2024-09-28 17:10:03支付宝支付10元]
2024-09-28 17:10:05 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281709559258481901","queue_number":178,"trade_uid":"24092817095592580070"}]}
2024-09-28 17:10:05 >>>故障排除日志:删除未同步下发订单成功24092817095592580070
2024-09-28 17:10:05 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


===17:19:35===
2024-09-28 17:18:45 >>>回调事件[910,devices/D0519]
2024-09-28 17:18:45 >>>故障排除日志:上一MQTT订单号缓存列表为24092817165294222561
2024-09-28 17:18:45 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 17:18:45 开始打印,排队:182,票券:2409281718397105456101,订单:24092817183971048146,[2024-09-28 17:18:44微信支付10元]
2024-09-28 17:18:47 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281718397105456101","queue_number":182,"trade_uid":"24092817183971048146"}]}
2024-09-28 17:18:47 >>>故障排除日志:删除未同步下发订单成功24092817183971048146
2024-09-28 17:18:47 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 17:18:52 >>>回调事件[910,devices/D0519]
2024-09-28 17:18:52 >>>故障排除日志:上一MQTT订单号缓存列表为24092817183971048146
2024-09-28 17:18:52 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 17:18:52 开始打印,排队:183,票券:2409281718472369396501,订单:24092817184723689667,[2024-09-28 17:18:52微信支付10元]
2024-09-28 17:18:55 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281718472369396501","queue_number":183,"trade_uid":"24092817184723689667"}]}
2024-09-28 17:18:55 >>>故障排除日志:删除未同步下发订单成功24092817184723689667
2024-09-28 17:18:55 >>>故障排除日志:终端同步成功后剩余订单列表


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


===17:31:36===
2024-09-28 17:30:37 >>>回调事件[910,devices/D0519]
2024-09-28 17:30:37 >>>故障排除日志:上一MQTT订单号缓存列表为24092817290002464105
2024-09-28 17:30:37 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 17:30:37 开始打印,排队:185,票券:2409281730285923064701,订单:24092817302859226961,[2024-09-28 17:30:36微信支付10元]
2024-09-28 17:30:37 开始打印,排队:186,票券:2409281730285923218202,订单:24092817302859226961,[2024-09-28 17:30:36微信支付10元]
2024-09-28 17:30:41 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281730285923064701","queue_number":185,"trade_uid":"24092817302859226961"},{"ticket_no":"2409281730285923218202","queue_number":186,"trade_uid":"24092817302859226961"}]}
2024-09-28 17:30:41 >>>故障排除日志:删除未同步下发订单成功24092817302859226961
2024-09-28 17:30:41 >>>故障排除日志:删除未同步下发订单成功24092817302859226961
2024-09-28 17:30:41 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 17:30:51 >>>回调事件[910,devices/D0519]
2024-09-28 17:30:51 >>>故障排除日志:上一MQTT订单号缓存列表为24092817302859226961|24092817302859226961
2024-09-28 17:30:51 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 17:30:51 开始打印,排队:187,票券:2409281730397328699701,订单:24092817303973280856,[2024-09-28 17:30:50支付宝支付10元]
2024-09-28 17:30:53 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281730397328699701","queue_number":187,"trade_uid":"24092817303973280856"}]}
2024-09-28 17:30:53 >>>故障排除日志:删除未同步下发订单成功24092817303973280856
2024-09-28 17:30:53 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


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


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


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


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


===17:56:39===
2024-09-28 17:56:34 >>>回调事件[910,devices/D0519]
2024-09-28 17:56:34 >>>故障排除日志:上一MQTT订单号缓存列表为24092817532690605158
2024-09-28 17:56:34 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 17:56:34 开始打印,排队:196,票券:2409281756248304393801,订单:24092817562483038512,[2024-09-28 17:56:32支付宝支付10元]
2024-09-28 17:56:34 开始打印,排队:197,票券:2409281756248304612602,订单:24092817562483038512,[2024-09-28 17:56:32支付宝支付10元]
2024-09-28 17:56:37 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281756248304393801","queue_number":196,"trade_uid":"24092817562483038512"},{"ticket_no":"2409281756248304612602","queue_number":197,"trade_uid":"24092817562483038512"}]}
2024-09-28 17:56:37 >>>故障排除日志:删除未同步下发订单成功24092817562483038512
2024-09-28 17:56:37 >>>故障排除日志:删除未同步下发订单成功24092817562483038512
2024-09-28 17:56:37 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


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


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


===18:20:44===
2024-09-28 18:20:21 >>>回调事件[910,devices/D0519]
2024-09-28 18:20:21 >>>故障排除日志:上一MQTT订单号缓存列表为24092818190554314668
2024-09-28 18:20:21 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 18:20:21 开始打印,排队:204,票券:2409281820047896772801,订单:24092818200478961246,[2024-09-28 18:20:19微信支付10元]
2024-09-28 18:20:23 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281820047896772801","queue_number":204,"trade_uid":"24092818200478961246"}]}
2024-09-28 18:20:23 >>>故障排除日志:删除未同步下发订单成功24092818200478961246
2024-09-28 18:20:23 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 18:20:30 >>>回调事件[910,devices/D0519]
2024-09-28 18:20:30 >>>故障排除日志:上一MQTT订单号缓存列表为24092818200478961246
2024-09-28 18:20:30 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 18:20:30 开始打印,排队:205,票券:2409281820112398658501,订单:24092818201123983268,[2024-09-28 18:20:30微信支付10元]
2024-09-28 18:20:32 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281820112398658501","queue_number":205,"trade_uid":"24092818201123983268"}]}
2024-09-28 18:20:32 >>>故障排除日志:删除未同步下发订单成功24092818201123983268
2024-09-28 18:20:32 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 18:20:33 >>>回调事件[910,devices/D0519]
2024-09-28 18:20:33 >>>故障排除日志:上一MQTT订单号缓存列表为24092818201123983268
2024-09-28 18:20:33 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 18:20:33 开始打印,排队:206,票券:2409281820262772102401,订单:24092818202627717238,[2024-09-28 18:20:33微信支付10元]
2024-09-28 18:20:35 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281820262772102401","queue_number":206,"trade_uid":"24092818202627717238"}]}
2024-09-28 18:20:35 >>>故障排除日志:删除未同步下发订单成功24092818202627717238
2024-09-28 18:20:35 >>>故障排除日志:终端同步成功后剩余订单列表


===18:24:45===
2024-09-28 18:24:06 >>>回调事件[910,devices/D0519]
2024-09-28 18:24:06 >>>故障排除日志:上一MQTT订单号缓存列表为24092818202627717238
2024-09-28 18:24:06 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 18:24:06 开始打印,排队:207,票券:2409281823561213602701,订单:24092818235612131969,[2024-09-28 18:24:06支付宝支付10元]
2024-09-28 18:24:08 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281823561213602701","queue_number":207,"trade_uid":"24092818235612131969"}]}
2024-09-28 18:24:08 >>>故障排除日志:删除未同步下发订单成功24092818235612131969
2024-09-28 18:24:08 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 18:24:28 >>>回调事件[910,devices/D0519]
2024-09-28 18:24:28 >>>故障排除日志:上一MQTT订单号缓存列表为24092818235612131969
2024-09-28 18:24:28 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 18:24:28 开始打印,排队:208,票券:2409281824219727533901,订单:24092818242197269906,[2024-09-28 18:24:27微信支付10元]
2024-09-28 18:24:30 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281824219727533901","queue_number":208,"trade_uid":"24092818242197269906"}]}
2024-09-28 18:24:30 >>>故障排除日志:删除未同步下发订单成功24092818242197269906
2024-09-28 18:24:30 >>>故障排除日志:终端同步成功后剩余订单列表


===18:25:45===
2024-09-28 18:25:36>>>cash read=0A
2024-09-28 18:25:38>>>cash read=3E


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


===18:30:45===
2024-09-28 18:30:27 >>>回调事件[910,devices/D0519]
2024-09-28 18:30:27 >>>故障排除日志:上一MQTT订单号缓存列表为24092818254182549719
2024-09-28 18:30:27 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 18:30:27 开始打印,排队:210,票券:2409281830189891588901,订单:24092818301898911341,[2024-09-28 18:30:26微信支付10元]
2024-09-28 18:30:29 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281830189891588901","queue_number":210,"trade_uid":"24092818301898911341"}]}
2024-09-28 18:30:29 >>>故障排除日志:删除未同步下发订单成功24092818301898911341
2024-09-28 18:30:29 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 18:30:35 >>>回调事件[910,devices/D0519]
2024-09-28 18:30:35 >>>故障排除日志:上一MQTT订单号缓存列表为24092818301898911341
2024-09-28 18:30:35 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 18:30:35 开始打印,排队:211,票券:2409281830297888255901,订单:24092818302978877957,[2024-09-28 18:30:35微信支付10元]
2024-09-28 18:30:37 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281830297888255901","queue_number":211,"trade_uid":"24092818302978877957"}]}
2024-09-28 18:30:37 >>>故障排除日志:删除未同步下发订单成功24092818302978877957
2024-09-28 18:30:37 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


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


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


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


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


===18:47:51===
2024-09-28 18:47:17 >>>回调事件[910,devices/D0519]
2024-09-28 18:47:17 >>>故障排除日志:上一MQTT订单号缓存列表为24092818460013230437
2024-09-28 18:47:17 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 18:47:17 开始打印,排队:221,票券:2409281847101097248401,订单:24092818471010968597,[2024-09-28 18:47:17支付宝支付10元]
2024-09-28 18:47:19 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281847101097248401","queue_number":221,"trade_uid":"24092818471010968597"}]}
2024-09-28 18:47:19 >>>故障排除日志:删除未同步下发订单成功24092818471010968597
2024-09-28 18:47:19 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 18:47:37 >>>回调事件[910,devices/D0519]
2024-09-28 18:47:37 >>>故障排除日志:上一MQTT订单号缓存列表为24092818471010968597
2024-09-28 18:47:37 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 18:47:37 开始打印,排队:222,票券:2409281847308677830801,订单:24092818473086773582,[2024-09-28 18:47:36微信支付10元]
2024-09-28 18:47:39 >>>回调事件[910,devices/D0519]
2024-09-28 18:47:39 >>>故障排除日志:上一MQTT订单号缓存列表为24092818473086773582
2024-09-28 18:47:39 >>>故障排除日志:终端未同步成功订单列表022224092818473086773582
已接收过此消息,票券号为2409281847308677830801,排队号为222
2024-09-28 18:47:39 开始打印,排队:223,票券:2409281847319416749001,订单:24092818473194160661,[2024-09-28 18:47:37微信支付10元]
2024-09-28 18:47:41 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281847308677830801","queue_number":222,"trade_uid":"24092818473086773582"}]}
2024-09-28 18:47:41 >>>故障排除日志:删除未同步下发订单成功24092818473086773582
2024-09-28 18:47:41 >>>故障排除日志:终端同步成功后剩余订单列表022324092818473194160661
2024-09-28 18:47:42 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281847308677830801","queue_number":222,"trade_uid":"24092818473086773582"},{"ticket_no":"2409281847319416749001","queue_number":223,"trade_uid":"24092818473194160661"}]}
2024-09-28 18:47:42 >>>故障排除日志:删除未同步下发订单成功24092818473194160661
2024-09-28 18:47:42 >>>故障排除日志:终端同步成功后剩余订单列表


===18:49:51===
2024-09-28 18:49:02>>>cash read=00
2024-09-28 18:49:04>>>cash read=01
2024-09-28 18:49:08>>>cash read=3E
2024-09-28 18:49:13>>>cash read=00
2024-09-28 18:49:13>>>cash read=818F42
2024-09-28 18:49:13>>>cash write=02
2024-09-28 18:49:13 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-09-28 18:49:14>>>cash read=10
2024-09-28 18:49:14 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-09-28 18:49:14 当前产品价格10元，投币10元，打印小票中...
2024-09-28 18:49:14 >>>开始打印,排队号为224,订单号为2409281849140005192903
2024-09-28 18:49:14>>>订单2409281849140005192903写入成功,剩余空间为1679500,占用RAM为608.931640625
删除未同步订单2409281849140005192903
2024-09-28 18:49:16>>>订单2409281849140005192903删除成功,剩余空间为1680500,占用RAM为619.4716796875
检测订单目录中>>>
无未同步订单>>>
2024-09-28 18:49:16 >>>当前Ram内存为591.0244140625
定时检测未同步订单启用
2024-09-28 18:49:17>>>cash write=0C
2024-09-28 18:49:17>>>cash read=3E
2024-09-28 18:49:27 >>>回调事件[910,devices/D0519]
2024-09-28 18:49:27 >>>故障排除日志:上一MQTT订单号缓存列表为24092818473086773582|24092818473194160661
2024-09-28 18:49:27 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 18:49:27 开始打印,排队:225,票券:2409281849206100150301,订单:24092818492060995829,[2024-09-28 18:49:27支付宝支付10元]
2024-09-28 18:49:29 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281849206100150301","queue_number":225,"trade_uid":"24092818492060995829"}]}
2024-09-28 18:49:29 >>>故障排除日志:删除未同步下发订单成功24092818492060995829
2024-09-28 18:49:29 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


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


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


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


===19:05:55===
2024-09-28 19:05:39 >>>回调事件[910,devices/D0519]
2024-09-28 19:05:39 >>>故障排除日志:上一MQTT订单号缓存列表为24092819020096098215
2024-09-28 19:05:39 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 19:05:39 开始打印,排队:235,票券:2409281905282166500501,订单:24092819052821661592,[2024-09-28 19:05:39支付宝支付10元]
2024-09-28 19:05:40 开始打印,排队:236,票券:2409281905282166635602,订单:24092819052821661592,[2024-09-28 19:05:39支付宝支付10元]
2024-09-28 19:05:44 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281905282166500501","queue_number":235,"trade_uid":"24092819052821661592"},{"ticket_no":"2409281905282166635602","queue_number":236,"trade_uid":"24092819052821661592"}]}
2024-09-28 19:05:44 >>>故障排除日志:删除未同步下发订单成功24092819052821661592
2024-09-28 19:05:44 >>>故障排除日志:删除未同步下发订单成功24092819052821661592
2024-09-28 19:05:44 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 19:05:44 >>>回调事件[910,devices/D0519]
2024-09-28 19:05:44 >>>故障排除日志:上一MQTT订单号缓存列表为24092819052821661592|24092819052821661592
2024-09-28 19:05:44 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 19:05:44 开始打印,排队:237,票券:2409281905347273796901,订单:24092819053472732902,[2024-09-28 19:05:44支付宝支付10元]
2024-09-28 19:05:46 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281905347273796901","queue_number":237,"trade_uid":"24092819053472732902"}]}
2024-09-28 19:05:46 >>>故障排除日志:删除未同步下发订单成功24092819053472732902
2024-09-28 19:05:46 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


===19:19:59===
2024-09-28 19:19:25 >>>回调事件[910,devices/D0519]
2024-09-28 19:19:25 >>>故障排除日志:上一MQTT订单号缓存列表为24092819184607373675
2024-09-28 19:19:25 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 19:19:25 开始打印,排队:242,票券:2409281919207456615801,订单:24092819192074559762,[2024-09-28 19:19:25微信支付10元]
2024-09-28 19:19:27 >>>回调事件[910,devices/D0519]
2024-09-28 19:19:27 >>>故障排除日志:上一MQTT订单号缓存列表为24092819192074559762
2024-09-28 19:19:27 >>>故障排除日志:终端未同步成功订单列表024224092819192074559762
2024-09-28 19:19:27 开始打印,排队:243,票券:2409281919161355044601,订单:24092819191613545597,[2024-09-28 19:19:26微信支付10元]
已接收过此消息,票券号为2409281919207456615801,排队号为242
2024-09-28 19:19:29 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281919207456615801","queue_number":242,"trade_uid":"24092819192074559762"}]}
2024-09-28 19:19:29 >>>故障排除日志:删除未同步下发订单成功24092819192074559762
2024-09-28 19:19:29 >>>故障排除日志:终端同步成功后剩余订单列表024324092819191613545597
2024-09-28 19:19:29 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281919161355044601","queue_number":243,"trade_uid":"24092819191613545597"},{"ticket_no":"2409281919207456615801","queue_number":242,"trade_uid":"24092819192074559762"}]}
2024-09-28 19:19:29 >>>故障排除日志:删除未同步下发订单成功24092819191613545597
2024-09-28 19:19:29 >>>故障排除日志:终端同步成功后剩余订单列表


===19:23:01===
2024-09-28 19:22:00 >>>回调事件[910,devices/D0519]
2024-09-28 19:22:00 >>>故障排除日志:上一MQTT订单号缓存列表为24092819191613545597|24092819192074559762
2024-09-28 19:22:00 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 19:22:00 开始打印,排队:244,票券:2409281921529380150701,订单:24092819215293796460,[2024-09-28 19:21:59支付宝支付10元]
2024-09-28 19:22:02 >>>回调事件[910,devices/D0519]
2024-09-28 19:22:02 >>>故障排除日志:上一MQTT订单号缓存列表为24092819215293796460
2024-09-28 19:22:02 >>>故障排除日志:终端未同步成功订单列表024424092819215293796460
已接收过此消息,票券号为2409281921529380150701,排队号为244
2024-09-28 19:22:02 开始打印,排队:245,票券:2409281921552819514501,订单:24092819215528190306,[2024-09-28 19:22:00支付宝支付10元]
2024-09-28 19:22:04 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281921529380150701","queue_number":244,"trade_uid":"24092819215293796460"}]}
2024-09-28 19:22:04 >>>故障排除日志:删除未同步下发订单成功24092819215293796460
2024-09-28 19:22:04 >>>故障排除日志:终端同步成功后剩余订单列表024524092819215528190306
2024-09-28 19:22:04 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281921529380150701","queue_number":244,"trade_uid":"24092819215293796460"},{"ticket_no":"2409281921552819514501","queue_number":245,"trade_uid":"24092819215528190306"}]}
2024-09-28 19:22:04 >>>故障排除日志:删除未同步下发订单成功24092819215528190306
2024-09-28 19:22:04 >>>故障排除日志:终端同步成功后剩余订单列表


===19:25:04===
2024-09-28 19:24:12 >>>回调事件[910,devices/D0519]
2024-09-28 19:24:12 >>>故障排除日志:上一MQTT订单号缓存列表为24092819215293796460|24092819215528190306
2024-09-28 19:24:12 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 19:24:12 开始打印,排队:246,票券:2409281924069732498601,订单:24092819240697318559,[2024-09-28 19:24:12微信支付10元]
2024-09-28 19:24:14 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281924069732498601","queue_number":246,"trade_uid":"24092819240697318559"}]}
2024-09-28 19:24:14 >>>故障排除日志:删除未同步下发订单成功24092819240697318559
2024-09-28 19:24:14 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 19:24:14 >>>回调事件[910,devices/D0519]
2024-09-28 19:24:14 >>>故障排除日志:上一MQTT订单号缓存列表为24092819240697318559
2024-09-28 19:24:14 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 19:24:14 开始打印,排队:247,票券:2409281924026976968001,订单:24092819240269764128,[2024-09-28 19:24:14微信支付10元]
2024-09-28 19:24:16 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281924026976968001","queue_number":247,"trade_uid":"24092819240269764128"}]}
2024-09-28 19:24:16 >>>故障排除日志:删除未同步下发订单成功24092819240269764128
2024-09-28 19:24:17 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 19:24:23 >>>回调事件[910,devices/D0519]
2024-09-28 19:24:23 >>>故障排除日志:上一MQTT订单号缓存列表为24092819240269764128
2024-09-28 19:24:23 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 19:24:23 开始打印,排队:248,票券:2409281924178063203501,订单:24092819241780628447,[2024-09-28 19:24:23微信支付10元]
2024-09-28 19:24:25 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281924178063203501","queue_number":248,"trade_uid":"24092819241780628447"}]}
2024-09-28 19:24:25 >>>故障排除日志:删除未同步下发订单成功24092819241780628447
2024-09-28 19:24:25 >>>故障排除日志:终端同步成功后剩余订单列表


===19:29:05===
2024-09-28 19:28:21 >>>回调事件[910,devices/D0519]
2024-09-28 19:28:21 >>>故障排除日志:上一MQTT订单号缓存列表为24092819241780628447
2024-09-28 19:28:21 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 19:28:21 开始打印,排队:249,票券:2409281928029923462501,订单:24092819280299231168,[2024-09-28 19:28:21微信支付10元]
2024-09-28 19:28:23 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281928029923462501","queue_number":249,"trade_uid":"24092819280299231168"}]}
2024-09-28 19:28:23 >>>故障排除日志:删除未同步下发订单成功24092819280299231168
2024-09-28 19:28:23 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 19:28:44 >>>回调事件[910,devices/D0519]
2024-09-28 19:28:44 >>>故障排除日志:上一MQTT订单号缓存列表为24092819280299231168
2024-09-28 19:28:44 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 19:28:44 开始打印,排队:250,票券:2409281928401925463001,订单:24092819284019250875,[2024-09-28 19:28:44微信支付10元]
2024-09-28 19:28:44 开始打印,排队:251,票券:2409281928401925591802,订单:24092819284019250875,[2024-09-28 19:28:44微信支付10元]
2024-09-28 19:28:48 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281928401925463001","queue_number":250,"trade_uid":"24092819284019250875"},{"ticket_no":"2409281928401925591802","queue_number":251,"trade_uid":"24092819284019250875"}]}
2024-09-28 19:28:48 >>>故障排除日志:删除未同步下发订单成功24092819284019250875
2024-09-28 19:28:48 >>>故障排除日志:删除未同步下发订单成功24092819284019250875
2024-09-28 19:28:48 >>>故障排除日志:终端同步成功后剩余订单列表


===19:31:06===
2024-09-28 19:30:12 >>>回调事件[910,devices/D0519]
2024-09-28 19:30:12 >>>故障排除日志:上一MQTT订单号缓存列表为24092819284019250875|24092819284019250875
2024-09-28 19:30:12 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 19:30:12 开始打印,排队:252,票券:2409281930068102005201,订单:24092819300681014332,[2024-09-28 19:30:12支付宝支付10元]
2024-09-28 19:30:14 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281930068102005201","queue_number":252,"trade_uid":"24092819300681014332"}]}
2024-09-28 19:30:14 >>>故障排除日志:删除未同步下发订单成功24092819300681014332
2024-09-28 19:30:14 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 19:30:42 >>>回调事件[910,devices/D0519]
2024-09-28 19:30:42 >>>故障排除日志:上一MQTT订单号缓存列表为24092819300681014332
2024-09-28 19:30:42 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 19:30:42 开始打印,排队:253,票券:2409281930254486047101,订单:24092819302544857057,[2024-09-28 19:30:42微信支付10元]
2024-09-28 19:30:45 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281930254486047101","queue_number":253,"trade_uid":"24092819302544857057"}]}
2024-09-28 19:30:45 >>>故障排除日志:删除未同步下发订单成功24092819302544857057
2024-09-28 19:30:45 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


===19:34:08===
2024-09-28 19:33:08 >>>回调事件[910,devices/D0519]
2024-09-28 19:33:08 >>>故障排除日志:上一MQTT订单号缓存列表为24092819324930360525
2024-09-28 19:33:08 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 19:33:08 开始打印,排队:257,票券:2409281932587231521001,订单:24092819325872311294,[2024-09-28 19:33:08微信支付10元]
2024-09-28 19:33:11 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281932587231521001","queue_number":257,"trade_uid":"24092819325872311294"}]}
2024-09-28 19:33:11 >>>故障排除日志:删除未同步下发订单成功24092819325872311294
2024-09-28 19:33:11 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 19:33:31 >>>回调事件[910,devices/D0519]
2024-09-28 19:33:31 >>>故障排除日志:上一MQTT订单号缓存列表为24092819325872311294
2024-09-28 19:33:31 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 19:33:31 开始打印,排队:258,票券:2409281933250617296101,订单:24092819332506167298,[2024-09-28 19:33:30微信支付10元]
2024-09-28 19:33:35 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281933250617296101","queue_number":258,"trade_uid":"24092819332506167298"}]}
2024-09-28 19:33:35 >>>故障排除日志:删除未同步下发订单成功24092819332506167298
2024-09-28 19:33:35 >>>故障排除日志:终端同步成功后剩余订单列表


===19:35:08===
2024-09-28 19:35:05 >>>回调事件[910,devices/D0519]
2024-09-28 19:35:05 >>>故障排除日志:上一MQTT订单号缓存列表为24092819332506167298
2024-09-28 19:35:05 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 19:35:05 开始打印,排队:259,票券:2409281934582068698701,订单:24092819345820682089,[2024-09-28 19:35:04微信支付10元]


===19:36:08===
2024-09-28 19:35:07 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281934582068698701","queue_number":259,"trade_uid":"24092819345820682089"}]}
2024-09-28 19:35:07 >>>故障排除日志:删除未同步下发订单成功24092819345820682089
2024-09-28 19:35:07 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


===19:40:10===
2024-09-28 19:40:07 >>>回调事件[910,devices/D0519]
2024-09-28 19:40:07 >>>故障排除日志:上一MQTT订单号缓存列表为24092819375590013956
2024-09-28 19:40:07 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 19:40:07 开始打印,排队:262,票券:2409281939596018734201,订单:24092819395960179391,[2024-09-28 19:40:05微信支付10元]


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


===19:45:11===
2024-09-28 19:44:30 >>>回调事件[910,devices/D0519]
2024-09-28 19:44:30 >>>故障排除日志:上一MQTT订单号缓存列表为24092819402084046105
2024-09-28 19:44:30 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 19:44:30 开始打印,排队:264,票券:2409281944244452857801,订单:24092819442444524721,[2024-09-28 19:44:30微信支付10元]
2024-09-28 19:44:32 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281944244452857801","queue_number":264,"trade_uid":"24092819442444524721"}]}
2024-09-28 19:44:32 >>>故障排除日志:删除未同步下发订单成功24092819442444524721
2024-09-28 19:44:32 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 19:45:07 >>>回调事件[910,devices/D0519]
2024-09-28 19:45:07 >>>故障排除日志:上一MQTT订单号缓存列表为24092819442444524721
2024-09-28 19:45:07 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 19:45:07 开始打印,排队:265,票券:2409281945005258260801,订单:24092819450052573385,[2024-09-28 19:45:07微信支付10元]


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


===19:48:13===
2024-09-28 19:48:09 >>>回调事件[910,devices/D0519]
2024-09-28 19:48:09 >>>故障排除日志:上一MQTT订单号缓存列表为24092819461715913870
2024-09-28 19:48:09 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 19:48:09 开始打印,排队:267,票券:2409281947595993054901,订单:24092819475959926969,[2024-09-28 19:48:08支付宝支付10元]


===19:49:13===
2024-09-28 19:48:12 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281947595993054901","queue_number":267,"trade_uid":"24092819475959926969"}]}
2024-09-28 19:48:12 >>>故障排除日志:删除未同步下发订单成功24092819475959926969
2024-09-28 19:48:12 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


===19:53:15===
2024-09-28 19:52:38 >>>回调事件[910,devices/D0519]
2024-09-28 19:52:38 >>>故障排除日志:上一MQTT订单号缓存列表为24092819512093581117|24092819512093581117
2024-09-28 19:52:38 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 19:52:38 开始打印,排队:272,票券:2409281952289020377401,订单:24092819522890197715,[2024-09-28 19:52:37支付宝支付10元]
2024-09-28 19:52:40 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281952289020377401","queue_number":272,"trade_uid":"24092819522890197715"}]}
2024-09-28 19:52:40 >>>故障排除日志:删除未同步下发订单成功24092819522890197715
2024-09-28 19:52:40 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 19:52:59 >>>回调事件[910,devices/D0519]
2024-09-28 19:52:59 >>>故障排除日志:上一MQTT订单号缓存列表为24092819522890197715
2024-09-28 19:52:59 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 19:52:59 开始打印,排队:273,票券:2409281952534306741701,订单:24092819525343061462,[2024-09-28 19:52:59微信支付10元]
2024-09-28 19:52:59 开始打印,排队:274,票券:2409281952534306974302,订单:24092819525343061462,[2024-09-28 19:52:59微信支付10元]
2024-09-28 19:52:59 开始打印,排队:275,票券:2409281952534307075903,订单:24092819525343061462,[2024-09-28 19:52:59微信支付10元]
2024-09-28 19:53:04 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281952534306741701","queue_number":273,"trade_uid":"24092819525343061462"},{"ticket_no":"2409281952534306974302","queue_number":274,"trade_uid":"24092819525343061462"},{"ticket_no":"2409281952534307075903","queue_number":275,"trade_uid":"24092819525343061462"}]}
2024-09-28 19:53:04 >>>故障排除日志:删除未同步下发订单成功24092819525343061462
2024-09-28 19:53:04 >>>故障排除日志:删除未同步下发订单成功24092819525343061462
2024-09-28 19:53:04 >>>故障排除日志:删除未同步下发订单成功24092819525343061462
2024-09-28 19:53:04 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 19:53:08 >>>回调事件[910,devices/D0519]
2024-09-28 19:53:08 >>>故障排除日志:上一MQTT订单号缓存列表为24092819525343061462|24092819525343061462|24092819525343061462
2024-09-28 19:53:08 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 19:53:08 开始打印,排队:276,票券:2409281953025923060301,订单:24092819530259220430,[2024-09-28 19:53:09微信支付10元]
2024-09-28 19:53:08 开始打印,排队:277,票券:2409281953025923238902,订单:24092819530259220430,[2024-09-28 19:53:09微信支付10元]
2024-09-28 19:53:12 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281953025923060301","queue_number":276,"trade_uid":"24092819530259220430"},{"ticket_no":"2409281953025923238902","queue_number":277,"trade_uid":"24092819530259220430"}]}
2024-09-28 19:53:12 >>>故障排除日志:删除未同步下发订单成功24092819530259220430
2024-09-28 19:53:12 >>>故障排除日志:删除未同步下发订单成功24092819530259220430
2024-09-28 19:53:12 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


===19:57:17===
2024-09-28 19:56:26 >>>回调事件[910,devices/D0519]
2024-09-28 19:56:26 >>>故障排除日志:上一MQTT订单号缓存列表为24092819544825236826
2024-09-28 19:56:26 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 19:56:26 开始打印,排队:280,票券:2409281956205717704101,订单:24092819562057172424,[2024-09-28 19:56:26支付宝支付10元]
2024-09-28 19:56:28 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281956205717704101","queue_number":280,"trade_uid":"24092819562057172424"}]}
2024-09-28 19:56:28 >>>故障排除日志:删除未同步下发订单成功24092819562057172424
2024-09-28 19:56:28 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 19:57:04 >>>回调事件[910,devices/D0519]
2024-09-28 19:57:04 >>>故障排除日志:上一MQTT订单号缓存列表为24092819562057172424
2024-09-28 19:57:04 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 19:57:04 开始打印,排队:281,票券:2409281956585976241001,订单:24092819565859757475,[2024-09-28 19:57:04微信支付10元]
2024-09-28 19:57:04 开始打印,排队:282,票券:2409281956585976459102,订单:24092819565859757475,[2024-09-28 19:57:
===19:57:23===
2024-09-28 19:56:26 >>>回调事件[910,devices/D0519]
2024-09-28 19:56:26 >>>故障排除日志:上一MQTT订单号缓存列表为24092819544825236826
2024-09-28 19:56:26 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 19:56:26 开始打印,排队:280,票券:2409281956205717704101,订单:24092819562057172424,[2024-09-28 19:56:26支付宝支付10元]
2024-09-28 19:56:28 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281956205717704101","queue_number":280,"trade_uid":"24092819562057172424"}]}
2024-09-28 19:56:28 >>>故障排除日志:删除未同步下发订单成功24092819562057172424
2024-09-28 19:56:28 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 19:57:04 >>>回调事件[910,devices/D0519]
2024-09-28 19:57:04 >>>故障排除日志:上一MQTT订单号缓存列表为24092819562057172424
2024-09-28 19:57:04 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 19:57:04 开始打印,排队:281,票券:2409281956585976241001,订单:24092819565859757475,[2024-09-28 19:57:04微信支付10元]
2024-09-28 19:57:04 开始打印,排队:282,票券:2409281956585976459102,订单:24092819565859757475,[2024-09-28 19:57:04微信支付10元]
2024-09-28 19:57:08 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281956585976241001","queue_number":281,"trade_uid":"24092819565859757475"},{"ticket_no":"2409281956585976459102","queue_number":282,"trade_uid":"24092819565859757475"}]}
2024-09-28 19:57:08 >>>故障排除日志:删除未同步下发订单成功24092819565859757475
2024-09-28 19:57:08 >>>故障排除日志:删除未同步下发订单成功24092819565859757475
2024-09-28 19:57:08 >>>故障排除日志:终端同步成功后剩余订单列表


TCP://log.tl-self.com:9807@28_19:57:17:send fail
TCP://log.tl-self.com:9807 closed@28_19:57:17
===19:59:24===
2024-09-28 19:58:25 >>>回调事件[910,devices/D0519]
2024-09-28 19:58:25 >>>故障排除日志:上一MQTT订单号缓存列表为24092819565859757475|24092819565859757475
2024-09-28 19:58:25 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 19:58:25 开始打印,排队:283,票券:2409281958199278367901,订单:24092819581992777606,[2024-09-28 19:58:25微信支付10元]
2024-09-28 19:58:27 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281958199278367901","queue_number":283,"trade_uid":"24092819581992777606"}]}
2024-09-28 19:58:27 >>>故障排除日志:删除未同步下发订单成功24092819581992777606
2024-09-28 19:58:27 >>>故障排除日志:终端同步成功后剩余订单列表


===20:01:25===
2024-09-28 20:00:40 >>>回调事件[910,devices/D0519]
2024-09-28 20:00:40 >>>故障排除日志:上一MQTT订单号缓存列表为24092819581992777606
2024-09-28 20:00:41 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 20:00:41 开始打印,排队:284,票券:2409282000354478941501,订单:24092820003544784163,[2024-09-28 20:00:39微信支付10元]
2024-09-28 20:00:43 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409282000354478941501","queue_number":284,"trade_uid":"24092820003544784163"}]}
2024-09-28 20:00:43 >>>故障排除日志:删除未同步下发订单成功24092820003544784163
2024-09-28 20:00:43 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 20:01:22 >>>回调事件[910,devices/D0519]
2024-09-28 20:01:22 >>>故障排除日志:上一MQTT订单号缓存列表为24092820003544784163
2024-09-28 20:01:22 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 20:01:22 开始打印,排队:285,票券:2409282001163639134501,订单:24092820011636387580,[2024-09-28 20:01:21微信支付10元]
2024-09-28 20:01:24 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409282001163639134501","queue_number":285,"trade_uid":"24092820011636387580"}]}
2024-09-28 20:01:24 >>>故障排除日志:删除未同步下发订单成功24092820011636387580
2024-09-28 20:01:24 >>>故障排除日志:终端同步成功后剩余订单列表


===20:03:27===
2024-09-28 20:02:51 >>>回调事件[910,devices/D0519]
2024-09-28 20:02:51 >>>故障排除日志:上一MQTT订单号缓存列表为24092820011636387580
2024-09-28 20:02:51 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 20:02:51 开始打印,排队:286,票券:2409282002458259320701,订单:24092820024582589362,[2024-09-28 20:02:50微信支付10元]
2024-09-28 20:02:54 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409282002458259320701","queue_number":286,"trade_uid":"24092820024582589362"}]}
2024-09-28 20:02:54 >>>故障排除日志:删除未同步下发订单成功24092820024582589362
2024-09-28 20:02:54 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 20:03:23 >>>回调事件[910,devices/D0519]
2024-09-28 20:03:23 >>>故障排除日志:上一MQTT订单号缓存列表为24092820024582589362
2024-09-28 20:03:23 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 20:03:23 开始打印,排队:287,票券:2409282003162121325801,订单:24092820031621207390,[2024-09-28 20:03:23微信支付10元]


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


===20:08:28===
2024-09-28 20:07:55 >>>回调事件[910,devices/D0519]
2024-09-28 20:07:55 >>>故障排除日志:上一MQTT订单号缓存列表为24092820031621207390
2024-09-28 20:07:55 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 20:07:55 开始打印,排队:288,票券:2409282007476316298201,订单:24092820074763158286,[2024-09-28 20:07:53微信支付10元]
2024-09-28 20:07:57 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409282007476316298201","queue_number":288,"trade_uid":"24092820074763158286"}]}
2024-09-28 20:07:57 >>>故障排除日志:删除未同步下发订单成功24092820074763158286
2024-09-28 20:07:57 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 20:08:05 >>>回调事件[910,devices/D0519]
2024-09-28 20:08:05 >>>故障排除日志:上一MQTT订单号缓存列表为24092820074763158286
2024-09-28 20:08:05 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 20:08:05 开始打印,排队:289,票券:2409282007589820229101,订单:24092820075898196887,[2024-09-28 20:08:05微信支付10元]
2024-09-28 20:08:07 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409282007589820229101","queue_number":289,"trade_uid":"24092820075898196887"}]}
2024-09-28 20:08:07 >>>故障排除日志:删除未同步下发订单成功24092820075898196887
2024-09-28 20:08:07 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


===20:13:29===
2024-09-28 20:12:40 >>>回调事件[910,devices/D0519]
2024-09-28 20:12:40 >>>故障排除日志:上一MQTT订单号缓存列表为24092820113345756227
2024-09-28 20:12:40 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 20:12:40 开始打印,排队:292,票券:2409282012345563296301,订单:24092820123455629192,[2024-09-28 20:12:40微信支付10元]
2024-09-28 20:12:42 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409282012345563296301","queue_number":292,"trade_uid":"24092820123455629192"}]}
2024-09-28 20:12:42 >>>故障排除日志:删除未同步下发订单成功24092820123455629192
2024-09-28 20:12:42 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 20:13:13 >>>回调事件[910,devices/D0519]
2024-09-28 20:13:13 >>>故障排除日志:上一MQTT订单号缓存列表为24092820123455629192
2024-09-28 20:13:13 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 20:13:13 开始打印,排队:293,票券:2409282012597049056001,订单:24092820125970485893,[2024-09-28 20:13:13微信支付10元]
2024-09-28 20:13:15 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409282012597049056001","queue_number":293,"trade_uid":"24092820125970485893"}]}
2024-09-28 20:13:15 >>>故障排除日志:删除未同步下发订单成功24092820125970485893
2024-09-28 20:13:15 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


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


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


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


===20:29:33===
2024-09-28 20:28:34 >>>回调事件[910,devices/D0519]
2024-09-28 20:28:34 >>>故障排除日志:上一MQTT订单号缓存列表为24092820273239202529
2024-09-28 20:28:34 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 20:28:34 开始打印,排队:301,票券:2409282028290432689401,订单:24092820282904322451,[2024-09-28 20:28:34微信支付10元]
2024-09-28 20:28:36 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409282028290432689401","queue_number":301,"trade_uid":"24092820282904322451"}]}
2024-09-28 20:28:36 >>>故障排除日志:删除未同步下发订单成功24092820282904322451
2024-09-28 20:28:36 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 20:28:41 >>>回调事件[910,devices/D0519]
2024-09-28 20:28:41 >>>故障排除日志:上一MQTT订单号缓存列表为24092820282904322451
2024-09-28 20:28:42 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 20:28:42 开始打印,排队:302,票券:2409282028372045160801,订单:24092820283720445401,[2024-09-28 20:28:42微信支付10元]
2024-09-28 20:28:42 开始打印,排队:303,票券:2409282028379015495701,订单:24092820283790151038,[2024-09-28 20:28:42微信支付10元]
2024-09-28 20:28:45 >>>回调事件[910,devices/D0519]
2024-09-28 20:28:45 >>>故障排除日志:上一MQTT订单号缓存列表为24092820283720445401|24092820283790151038
2024-09-28 20:28:45 >>>故障排除日志:终端未同步成功订单列表030224092820283720445401|030324092820283790151038
已接收过此消息,票券号为2409282028372045160801,排队号为302
已接收过此消息,票券号为2409282028379015495701,排队号为303
2024-09-28 20:28:45 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409282028372045160801","queue_number":302,"trade_uid":"24092820283720445401"},{"ticket_no":"2409282028379015495701","queue_number":303,"trade_uid":"24092820283790151038"}]}
2024-09-28 20:28:46 >>>故障排除日志:删除未同步下发订单成功24092820283720445401
2024-09-28 20:28:46 >>>故障排除日志:删除未同步下发订单成功24092820283790151038
2024-09-28 20:28:46 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 20:28:46 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409282028372045160801","queue_number":302,"trade_uid":"24092820283720445401"},{"ticket_no":"2409282028379015495701","queue_number":303,"trade_uid":"24092820283790151038"}]}
2024-09-28 20:28:46 >>>故障排除日志:终端同步成功后剩余订单列表


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


===20:46:34===
2024-09-28 20:45:40 >>>回调事件[910,devices/D0519]
2024-09-28 20:45:40 >>>故障排除日志:上一MQTT订单号缓存列表为24092820322178469846
2024-09-28 20:45:40 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 20:45:40 开始打印,排队:305,票券:2409282045330935312001,订单:24092820453309348684,[2024-09-28 20:45:40支付宝支付10元]
2024-09-28 20:45:42 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409282045330935312001","queue_number":305,"trade_uid":"24092820453309348684"}]}
2024-09-28 20:45:42 >>>故障排除日志:删除未同步下发订单成功24092820453309348684
2024-09-28 20:45:42 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 20:45:53 >>>回调事件[910,devices/D0519]
2024-09-28 20:45:53 >>>故障排除日志:上一MQTT订单号缓存列表为24092820453309348684
2024-09-28 20:45:53 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 20:45:53 开始打印,排队:306,票券:2409282045452344040501,订单:24092820454523435165,[2024-09-28 20:45:53微信支付10元]
2024-09-28 20:45:55 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409282045452344040501","queue_number":306,"trade_uid":"24092820454523435165"}]}
2024-09-28 20:45:55 >>>故障排除日志:删除未同步下发订单成功24092820454523435165
2024-09-28 20:45:55 >>>故障排除日志:终端同步成功后剩余订单列表


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


===20:49:37===
2024-09-28 20:48:53 >>>回调事件[910,devices/D0519]
2024-09-28 20:48:53 >>>故障排除日志:上一MQTT订单号缓存列表为24092820472788471667
2024-09-28 20:48:53 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 20:48:53 开始打印,排队:308,票券:2409282048487150007501,订单:24092820484871495407,[2024-09-28 20:48:53微信支付10元]
2024-09-28 20:48:55 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409282048487150007501","queue_number":308,"trade_uid":"24092820484871495407"}]}
2024-09-28 20:48:55 >>>故障排除日志:删除未同步下发订单成功24092820484871495407
2024-09-28 20:48:55 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 20:49:20 >>>回调事件[910,devices/D0519]
2024-09-28 20:49:20 >>>故障排除日志:上一MQTT订单号缓存列表为24092820484871495407
2024-09-28 20:49:20 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 20:49:20 开始打印,排队:309,票券:2409282049100136701501,订单:24092820491001362183,[2024-09-28 20:49:20微信支付10元]
2024-09-28 20:49:22 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409282049100136701501","queue_number":309,"trade_uid":"24092820491001362183"}]}
2024-09-28 20:49:22 >>>故障排除日志:删除未同步下发订单成功24092820491001362183
2024-09-28 20:49:22 >>>故障排除日志:终端同步成功后剩余订单列表


===20:56:38===
2024-09-28 20:56:10 >>>回调事件[910,devices/D0519]
2024-09-28 20:56:10 >>>故障排除日志:上一MQTT订单号缓存列表为24092820491001362183
2024-09-28 20:56:10 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 20:56:10 开始打印,排队:310,票券:2409282055431150144601,订单:24092820554311496858,[2024-09-28 20:56:09微信支付10元]
2024-09-28 20:56:12 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409282055431150144601","queue_number":310,"trade_uid":"24092820554311496858"}]}
2024-09-28 20:56:12 >>>故障排除日志:删除未同步下发订单成功24092820554311496858
2024-09-28 20:56:12 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 20:56:17 >>>回调事件[910,devices/D0519]
2024-09-28 20:56:17 >>>故障排除日志:上一MQTT订单号缓存列表为24092820554311496858
2024-09-28 20:56:17 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 20:56:17 开始打印,排队:311,票券:2409282056122433184101,订单:24092820561224327615,[2024-09-28 20:56:17微信支付10元]
2024-09-28 20:56:17 开始打印,排队:312,票券:2409282056122433343802,订单:24092820561224327615,[2024-09-28 20:56:17微信支付10元]
2024-09-28 20:56:17 开始打印,排队:313,票券:2409282056122433400603,订单:24092820561224327615,[2024-09-28 20:56:17微信支付10元]
2024-09-28 20:56:22 >>>回调事件[910,devices/D0519]
2024-09-28 20:56:22 >>>故障排除日志:上一MQTT订单号缓存列表为24092820561224327615|24092820561224327615|24092820561224327615
2024-09-28 20:56:22 >>>故障排除日志:终端未同步成功订单列表031124092820561224327615|031224092820561224327615|031324092820561224327615
2024-09-28 20:56:22 开始打印,排队:314,票券:2409282056086433256301,订单:24092820560864328379,[2024-09-28 20:56:19支付宝支付10元]
已接收过此消息,票券号为2409282056122433184101,排队号为311
已接收过此消息,票券号为2409282056122433343802,排队号为312
已接收过此消息,票券号为2409282056122433400603,排队号为313
2024-09-28 20:56:24 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409282056122433184101","queue_number":311,"trade_uid":"24092820561224327615"},{"ticket_no":"2409282056122433343802","queue_number":312,"trade_uid":"24092820561224327615"},{"ticket_no":"2409282056122433400603","queue_number":313,"trade_uid":"24092820561224327615"}]}
2024-09-28 20:56:25 >>>故障排除日志:删除未同步下发订单成功24092820561224327615
2024-09-28 20:56:25 >>>故障排除日志:删除未同步下发订单成功24092820561224327615
2024-09-28 20:56:25 >>>故障排除日志:删除未同步下发订单成功24092820561224327615
2024-09-28 20:56:25 >>>故障排除日志:终端同步成功后剩余订单列表031424092820560864328379
2024-09-28 20:56:25 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409282056086433256301","queue_number":314,"trade_uid":"24092820560864328379"},{"ticket_no":"2409282056122433184101","queue_number":311,"trade_uid":"24092820561224327615"},{"ticket_no":"2409282056122433343802","queue_number":312,"trade_uid":"24092820561224327615"},{"ticket_no":"2409282056122433400603","queue_number":313,"trade_uid":"24092820561224327615"}]}
2024-09-28 20:56:25 >>>故障排除日志:删除未同步下发订单成功24092820560864328379
2024-09-28 20:56:25 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


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


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


===21:22:39===
2024-09-28 21:22:12 >>>回调事件[910,devices/D0519]
2024-09-28 21:22:12 >>>故障排除日志:上一MQTT订单号缓存列表为24092821203497818075
2024-09-28 21:22:12 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 21:22:12 开始打印,排队:320,票券:2409282122075122716101,订单:24092821220751222096,[2024-09-28 21:22:12支付宝支付10元]
2024-09-28 21:22:13 开始打印,排队:321,票券:2409282122075123079602,订单:24092821220751222096,[2024-09-28 21:22:12支付宝支付10元]
2024-09-28 21:22:16 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409282122075122716101","queue_number":320,"trade_uid":"24092821220751222096"},{"ticket_no":"2409282122075123079602","queue_number":321,"trade_uid":"24092821220751222096"}]}
2024-09-28 21:22:16 >>>故障排除日志:删除未同步下发订单成功24092821220751222096
2024-09-28 21:22:16 >>>故障排除日志:删除未同步下发订单成功24092821220751222096
2024-09-28 21:22:16 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


===21:49:42===
2024-09-28 21:48:42 >>>回调事件[910,devices/D0519]
2024-09-28 21:48:42 >>>故障排除日志:上一MQTT订单号缓存列表为24092821284909268596
2024-09-28 21:48:42 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 21:48:42 开始打印,排队:325,票券:2409282148358837889501,订单:24092821483588374781,[2024-09-28 21:48:42微信支付10元]
2024-09-28 21:48:44 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409282148358837889501","queue_number":325,"trade_uid":"24092821483588374781"}]}
2024-09-28 21:48:44 >>>故障排除日志:删除未同步下发订单成功24092821483588374781
2024-09-28 21:48:45 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 21:49:04 >>>回调事件[910,devices/D0519]
2024-09-28 21:49:04 >>>故障排除日志:上一MQTT订单号缓存列表为24092821483588374781
2024-09-28 21:49:04 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 21:49:04 开始打印,排队:326,票券:2409282148566056378701,订单:24092821485660559828,[2024-09-28 21:49:03微信支付10元]
2024-09-28 21:49:06 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409282148566056378701","queue_number":326,"trade_uid":"24092821485660559828"}]}
2024-09-28 21:49:06 >>>故障排除日志:删除未同步下发订单成功24092821485660559828
2024-09-28 21:49:06 >>>故障排除日志:终端同步成功后剩余订单列表


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