TLClient_JSSCOM_LuatOS-Air_V4010_RDA8910_RFTTS_0xe0000,2.5.4,865328069257086,70552960922786,
poweron reason:0

===07:33:56===
上一时间戳为1727654699
隔日重置时间戳true
隔日清空未同步下发列表true
当前排队号为1,音量为5
初始化产品信息:[{"time_limit_date":"","ticket_category":"0","expiry_date":90,"product_detail":"","time_limit_status":"0","begin_minute":"00","product_uid":"4351590954436789145","use_timer":1,"old_price":"10","end_hour":"23","sale_price":"10","end_minute":"59","begin_hour":"00","sale_status":1,"product_name":"快剪"}]
打印门店标题设置为欢迎光临恒剪（温州塘下大润发）
是否打印二维码设置为1
是否打印紧凑设置为3
session_id:73ed0****12dc6
纸币器设置接收纸币范围为36
欢迎使用天羚自助售票系统[2.5.4]
定时检测未同步订单启用
2024-10-01 07:32:56>>>cash write=30
2024-10-01 07:32:56>>>cash write=02
2024-10-01 07:32:56>>>cash write=3E
2024-10-01 07:32:56>>>cash read=808F808F808F808F
系统时间初始化成功，时间为202410173256
2024-10-01 07:32:57>>>cash write=02
2024-10-01 07:32:57 >>>剩余flash空间=1680500,占用RAM为628.5087890625
2024-10-01 07:32:57 >>>回调事件:910,subscribe,10000,连接服务器成功

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

2024-10-01 07:33:00>>>cash write=0C
2024-10-01 07:33:00>>>cash read=3E
流量卡还有150天过期
2024-10-01 07:33:04 >>>当前Ram内存为619.05859375


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


===08:00:57===
2024-10-01 08:00:32>>>cash read=00
2024-10-01 08:00:32>>>cash read=818F42
2024-10-01 08:00:32>>>cash write=02
2024-10-01 08:00:32 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-01 08:00:33>>>cash read=10
2024-10-01 08:00:33 >>>回调事件130,10,10023,finish Money=10,进钞完成
当日首次设置时间戳true为1727740833
2024-10-01 08:00:33 当前产品价格10元，投币10元，打印小票中...
2024-10-01 08:00:33 >>>开始打印,排队号为1,订单号为2410010800330003615423
2024-10-01 08:00:33>>>订单2410010800330003615423写入成功,剩余空间为1679500,占用RAM为606.5517578125
2024-10-01 08:00:36>>>cash write=0C
2024-10-01 08:00:36>>>cash read=3E
删除未同步订单2410010800330003615423
2024-10-01 08:00:37>>>订单2410010800330003615423删除成功,剩余空间为1680500,占用RAM为646.796875
检测订单目录中>>>
无未同步订单>>>
2024-10-01 08:00:37 >>>当前Ram内存为588.1064453125
定时检测未同步订单启用


===08:01:57===
2024-10-01 08:01:25 >>>回调事件[910,devices/D0361]
2024-10-01 08:01:25 >>>故障排除日志:上一MQTT订单号缓存列表为24093021433715770891
2024-10-01 08:01:25 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 08:01:25 开始打印,排队:2,票券:2410010801155483154501,订单:24100108011554827367,[2024-10-01 08:01:25微信支付10元]
2024-10-01 08:01:25 开始打印,排队:3,票券:2410010801155483307602,订单:24100108011554827367,[2024-10-01 08:01:25微信支付10元]
2024-10-01 08:01:30 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410010801155483154501","queue_number":2,"trade_uid":"24100108011554827367"},{"ticket_no":"2410010801155483307602","queue_number":3,"trade_uid":"24100108011554827367"}]}
2024-10-01 08:01:30 >>>故障排除日志:删除未同步下发订单成功24100108011554827367
2024-10-01 08:01:30 >>>故障排除日志:删除未同步下发订单成功24100108011554827367
2024-10-01 08:01:30 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单关闭
检测订单目录中>>>
无未同步订单>>>


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


===08:09:58===
2024-10-01 08:09:45 >>>回调事件[910,devices/D0361]
2024-10-01 08:09:45 >>>故障排除日志:上一MQTT订单号缓存列表为24100108042638668017
2024-10-01 08:09:45 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 08:09:45 开始打印,排队:5,票券:2410010809372488706401,订单:24100108093724882021,[2024-10-01 08:09:44微信支付10元]
2024-10-01 08:09:47 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410010809372488706401","queue_number":5,"trade_uid":"24100108093724882021"}]}
2024-10-01 08:09:47 >>>故障排除日志:删除未同步下发订单成功24100108093724882021
2024-10-01 08:09:47 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-01 08:09:48 >>>回调事件[910,devices/D0361]
2024-10-01 08:09:48 >>>故障排除日志:上一MQTT订单号缓存列表为24100108093724882021
2024-10-01 08:09:48 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 08:09:48 开始打印,排队:6,票券:2410010809427783951201,订单:24100108094277834714,[2024-10-01 08:09:48微信支付10元]
2024-10-01 08:09:50 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410010809427783951201","queue_number":6,"trade_uid":"24100108094277834714"}]}
2024-10-01 08:09:50 >>>故障排除日志:删除未同步下发订单成功24100108094277834714
2024-10-01 08:09:50 >>>故障排除日志:终端同步成功后剩余订单列表


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


===08:16:58===
2024-10-01 08:16:36 >>>回调事件[910,devices/D0361]
2024-10-01 08:16:36 >>>故障排除日志:上一MQTT订单号缓存列表为24100108133523686467
2024-10-01 08:16:36 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 08:16:36 开始打印,排队:8,票券:2410010816199845887201,订单:24100108161998454021,[2024-10-01 08:16:25微信支付10元]
2024-10-01 08:16:36 开始打印,排队:9,票券:2410010816199846035102,订单:24100108161998454021,[2024-10-01 08:16:25微信支付10元]
2024-10-01 08:16:39 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410010816199845887201","queue_number":8,"trade_uid":"24100108161998454021"},{"ticket_no":"2410010816199846035102","queue_number":9,"trade_uid":"24100108161998454021"}]}
2024-10-01 08:16:39 >>>故障排除日志:删除未同步下发订单成功24100108161998454021
2024-10-01 08:16:39 >>>故障排除日志:删除未同步下发订单成功24100108161998454021
2024-10-01 08:16:40 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


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


===08:46:00===
2024-10-01 08:45:26 >>>回调事件[910,devices/D0361]
2024-10-01 08:45:26 >>>故障排除日志:上一MQTT订单号缓存列表为24100108434511235589
2024-10-01 08:45:26 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 08:45:26 开始打印,排队:15,票券:2410010845152774998201,订单:24100108451527744087,[2024-10-01 08:45:25微信支付10元]
2024-10-01 08:45:28 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410010845152774998201","queue_number":15,"trade_uid":"24100108451527744087"}]}
2024-10-01 08:45:28 >>>故障排除日志:删除未同步下发订单成功24100108451527744087
2024-10-01 08:45:28 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-01 08:45:34 >>>回调事件[910,devices/D0361]
2024-10-01 08:45:34 >>>故障排除日志:上一MQTT订单号缓存列表为24100108451527744087
2024-10-01 08:45:34 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 08:45:34 开始打印,排队:16,票券:2410010845270602318601,订单:24100108452706018468,[2024-10-01 08:45:33微信支付10元]
2024-10-01 08:45:35 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410010845270602318601","queue_number":16,"trade_uid":"24100108452706018468"}]}
2024-10-01 08:45:36 >>>故障排除日志:删除未同步下发订单成功24100108452706018468
2024-10-01 08:45:36 >>>故障排除日志:终端同步成功后剩余订单列表


===08:49:00===
2024-10-01 08:48:00 >>>回调事件[910,devices/D0361]
2024-10-01 08:48:00 >>>故障排除日志:上一MQTT订单号缓存列表为24100108452706018468
2024-10-01 08:48:00 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 08:48:00 开始打印,排队:17,票券:2410010847502071502401,订单:24100108475020710414,[2024-10-01 08:47:59微信支付10元]
2024-10-01 08:48:02 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410010847502071502401","queue_number":17,"trade_uid":"24100108475020710414"}]}
2024-10-01 08:48:02 >>>故障排除日志:删除未同步下发订单成功24100108475020710414
2024-10-01 08:48:02 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-01 08:48:27 >>>回调事件[910,devices/D0361]
2024-10-01 08:48:27 >>>故障排除日志:上一MQTT订单号缓存列表为24100108475020710414
2024-10-01 08:48:27 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 08:48:27 开始打印,排队:18,票券:2410010848159899797601,订单:24100108481598993882,[2024-10-01 08:48:27微信支付10元]
2024-10-01 08:48:29 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410010848159899797601","queue_number":18,"trade_uid":"24100108481598993882"}]}
2024-10-01 08:48:29 >>>故障排除日志:删除未同步下发订单成功24100108481598993882
2024-10-01 08:48:29 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


===09:06:03===
2024-10-01 09:06:00 >>>回调事件[910,devices/D0361]
2024-10-01 09:06:00 >>>故障排除日志:上一MQTT订单号缓存列表为24100109010336231845|24100109010336231845
2024-10-01 09:06:00 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 09:06:00 开始打印,排队:24,票券:2410010905527545923401,订单:24100109055275455494,[2024-10-01 09:06:00微信支付10元]


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


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


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


===09:19:05===
2024-10-01 09:18:09 >>>回调事件[910,devices/D0361]
2024-10-01 09:18:10 >>>故障排除日志:上一MQTT订单号缓存列表为24100109133380326232
2024-10-01 09:18:10 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 09:18:10 开始打印,排队:28,票券:2410010918033870399101,订单:24100109180338698849,[2024-10-01 09:18:09微信支付10元]
2024-10-01 09:18:11 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410010918033870399101","queue_number":28,"trade_uid":"24100109180338698849"}]}
2024-10-01 09:18:11 >>>故障排除日志:删除未同步下发订单成功24100109180338698849
2024-10-01 09:18:12 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-01 09:18:37>>>cash read=00
2024-10-01 09:18:38>>>cash read=818F42
2024-10-01 09:18:38>>>cash write=02
2024-10-01 09:18:38 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-01 09:18:39>>>cash read=10
2024-10-01 09:18:39 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-01 09:18:39 当前产品价格10元，投币10元，打印小票中...
2024-10-01 09:18:39 >>>开始打印,排队号为29,订单号为2410010918390003615185
2024-10-01 09:18:39>>>订单2410010918390003615185写入成功,剩余空间为1679000,占用RAM为611.9248046875
删除未同步订单2410010918390003615185
2024-10-01 09:18:41>>>订单2410010918390003615185删除成功,剩余空间为1680000,占用RAM为623.48828125
检测订单目录中>>>
无未同步订单>>>
2024-10-01 09:18:41 >>>当前Ram内存为592.728515625
定时检测未同步订单启用
2024-10-01 09:18:42>>>cash write=0C
2024-10-01 09:18:42>>>cash read=3E


===09:20:05===
2024-10-01 09:19:27 >>>回调事件[910,devices/D0361]
2024-10-01 09:19:27 >>>故障排除日志:上一MQTT订单号缓存列表为24100109180338698849
2024-10-01 09:19:27 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 09:19:27 开始打印,排队:30,票券:2410010919148411819101,订单:24100109191484113541,[2024-10-01 09:19:26微信支付10元]
2024-10-01 09:19:29 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410010919148411819101","queue_number":30,"trade_uid":"24100109191484113541"}]}
2024-10-01 09:19:29 >>>故障排除日志:删除未同步下发订单成功24100109191484113541
2024-10-01 09:19:29 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单关闭
检测订单目录中>>>
无未同步订单>>>


===09:22:05===
2024-10-01 09:22:02 >>>回调事件[910,devices/D0361]
2024-10-01 09:22:02 >>>故障排除日志:上一MQTT订单号缓存列表为24100109191484113541
2024-10-01 09:22:02 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 09:22:02 开始打印,排队:31,票券:2410010921555387836801,订单:24100109215553874023,[2024-10-01 09:22:01微信支付10元]


===09:23:05===
2024-10-01 09:22:04 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410010921555387836801","queue_number":31,"trade_uid":"24100109215553874023"}]}
2024-10-01 09:22:04 >>>故障排除日志:删除未同步下发订单成功24100109215553874023
2024-10-01 09:22:04 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


===09:35:07===
2024-10-01 09:34:10 >>>回调事件[910,devices/D0361]
2024-10-01 09:34:10 >>>故障排除日志:上一MQTT订单号缓存列表为24100109305104830424
2024-10-01 09:34:10 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 09:34:10 开始打印,排队:36,票券:2410010934042345571301,订单:24100109340423451115,[2024-10-01 09:34:10微信支付10元]
2024-10-01 09:34:10 开始打印,排队:37,票券:2410010934042345726302,订单:24100109340423451115,[2024-10-01 09:34:10微信支付10元]
2024-10-01 09:34:10 开始打印,排队:38,票券:2410010934042345787503,订单:24100109340423451115,[2024-10-01 09:34:10微信支付10元]
2024-10-01 09:34:16 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410010934042345571301","queue_number":36,"trade_uid":"24100109340423451115"},{"ticket_no":"2410010934042345726302","queue_number":37,"trade_uid":"24100109340423451115"},{"ticket_no":"2410010934042345787503","queue_number":38,"trade_uid":"24100109340423451115"}]}
2024-10-01 09:34:16 >>>故障排除日志:删除未同步下发订单成功24100109340423451115
2024-10-01 09:34:16 >>>故障排除日志:删除未同步下发订单成功24100109340423451115
2024-10-01 09:34:16 >>>故障排除日志:删除未同步下发订单成功24100109340423451115
2024-10-01 09:34:16 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-01 09:34:24 >>>回调事件[910,devices/D0361]
2024-10-01 09:34:24 >>>故障排除日志:上一MQTT订单号缓存列表为24100109340423451115|24100109340423451115|24100109340423451115
2024-10-01 09:34:24 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 09:34:24 开始打印,排队:39,票券:2410010934186504667401,订单:24100109341865042693,[2024-10-01 09:34:24微信支付10元]
2024-10-01 09:34:26 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410010934186504667401","queue_number":39,"trade_uid":"24100109341865042693"}]}
2024-10-01 09:34:26 >>>故障排除日志:删除未同步下发订单成功24100109341865042693
2024-10-01 09:34:26 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-01 09:34:42 >>>回调事件[910,devices/D0361]
2024-10-01 09:34:42 >>>故障排除日志:上一MQTT订单号缓存列表为24100109341865042693
2024-10-01 09:34:42 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 09:34:42 开始打印,排队:40,票券:2410010934298700778501,订单:24100109342987002982,[2024-10-01 09:34:42微信支付10元]
2024-10-01 09:34:45 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410010934298700778501","queue_number":40,"trade_uid":"24100109342987002982"}]}
2024-10-01 09:34:45 >>>故障排除日志:删除未同步下发订单成功24100109342987002982
2024-10-01 09:34:45 >>>故障排除日志:终端同步成功后剩余订单列表


===09:36:07===
2024-10-01 09:35:10 >>>回调事件[910,devices/D0361]
2024-10-01 09:35:10 >>>故障排除日志:上一MQTT订单号缓存列表为24100109342987002982
2024-10-01 09:35:10 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 09:35:10 开始打印,排队:41,票券:2410010935002720347401,订单:24100109350027198357,[2024-10-01 09:35:09支付宝支付10元]
2024-10-01 09:35:12 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410010935002720347401","queue_number":41,"trade_uid":"24100109350027198357"}]}
2024-10-01 09:35:12 >>>故障排除日志:删除未同步下发订单成功24100109350027198357
2024-10-01 09:35:12 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-01 09:35:39 >>>回调事件[910,devices/D0361]
2024-10-01 09:35:39 >>>故障排除日志:上一MQTT订单号缓存列表为24100109350027198357
2024-10-01 09:35:39 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 09:35:39 开始打印,排队:42,票券:2410010935321708636101,订单:24100109353217081631,[2024-10-01 09:35:37微信支付10元]
2024-10-01 09:35:41 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410010935321708636101","queue_number":42,"trade_uid":"24100109353217081631"}]}
2024-10-01 09:35:41 >>>故障排除日志:删除未同步下发订单成功24100109353217081631
2024-10-01 09:35:41 >>>故障排除日志:终端同步成功后剩余订单列表


===09:39:07===
2024-10-01 09:38:20 >>>回调事件[910,devices/D0361]
2024-10-01 09:38:20 >>>故障排除日志:上一MQTT订单号缓存列表为24100109353217081631
2024-10-01 09:38:20 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 09:38:20 开始打印,排队:43,票券:2410010938123867049101,订单:24100109381238664131,[2024-10-01 09:38:20微信支付10元]
2024-10-01 09:38:20 开始打印,排队:44,票券:2410010938123867242402,订单:24100109381238664131,[2024-10-01 09:38:20微信支付10元]
2024-10-01 09:38:23 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410010938123867049101","queue_number":43,"trade_uid":"24100109381238664131"},{"ticket_no":"2410010938123867242402","queue_number":44,"trade_uid":"24100109381238664131"}]}
2024-10-01 09:38:24 >>>故障排除日志:删除未同步下发订单成功24100109381238664131
2024-10-01 09:38:24 >>>故障排除日志:删除未同步下发订单成功24100109381238664131
2024-10-01 09:38:24 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-01 09:38:38 >>>回调事件[910,devices/D0361]
2024-10-01 09:38:38 >>>故障排除日志:上一MQTT订单号缓存列表为24100109381238664131|24100109381238664131
2024-10-01 09:38:38 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 09:38:38 开始打印,排队:45,票券:2410010938318293875801,订单:24100109383182934213,[2024-10-01 09:38:38微信支付10元]
2024-10-01 09:38:39 开始打印,排队:46,票券:2410010938318294012902,订单:24100109383182934213,[2024-10-01 09:38:38微信支付10元]
2024-10-01 09:38:42 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410010938318293875801","queue_number":45,"trade_uid":"24100109383182934213"},{"ticket_no":"2410010938318294012902","queue_number":46,"trade_uid":"24100109383182934213"}]}
2024-10-01 09:38:42 >>>故障排除日志:删除未同步下发订单成功24100109383182934213
2024-10-01 09:38:42 >>>故障排除日志:删除未同步下发订单成功24100109383182934213
2024-10-01 09:38:42 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-01 09:38:44 >>>回调事件[910,devices/D0361]
2024-10-01 09:38:44 >>>故障排除日志:上一MQTT订单号缓存列表为24100109383182934213|24100109383182934213
2024-10-01 09:38:44 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 09:38:44 开始打印,排队:47,票券:2410010938389166737301,订单:24100109383891663232,[2024-10-01 09:38:44微信支付10元]
2024-10-01 09:38:46 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410010938389166737301","queue_number":47,"trade_uid":"24100109383891663232"}]}
2024-10-01 09:38:46 >>>故障排除日志:删除未同步下发订单成功24100109383891663232
2024-10-01 09:38:46 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


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


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


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


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


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


===10:01:12===
2024-10-01 10:01:08 >>>回调事件[910,devices/D0361]
2024-10-01 10:01:08 >>>故障排除日志:上一MQTT订单号缓存列表为24100109592965309834
2024-10-01 10:01:08 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 10:01:08 开始打印,排队:58,票券:2410011001038127643101,订单:24100110010381272951,[2024-10-01 10:01:08微信支付10元]


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


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


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


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


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


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


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


===10:47:14===
2024-10-01 10:46:38 >>>回调事件[910,devices/D0361]
2024-10-01 10:46:38 >>>故障排除日志:上一MQTT订单号缓存列表为24100110424986509442|24100110424986509442
2024-10-01 10:46:38 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 10:46:38 开始打印,排队:67,票券:2410011046287398722701,订单:24100110462873982185,[2024-10-01 10:46:38微信支付10元]
2024-10-01 10:46:38 开始打印,排队:68,票券:2410011046287398881602,订单:24100110462873982185,[2024-10-01 10:46:38微信支付10元]
2024-10-01 10:46:38 开始打印,排队:69,票券:2410011046287398943103,订单:24100110462873982185,[2024-10-01 10:46:38微信支付10元]
2024-10-01 10:46:44 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011046287398722701","queue_number":67,"trade_uid":"24100110462873982185"},{"ticket_no":"2410011046287398881602","queue_number":68,"trade_uid":"24100110462873982185"},{"ticket_no":"2410011046287398943103","queue_number":69,"trade_uid":"24100110462873982185"}]}
2024-10-01 10:46:44 >>>故障排除日志:删除未同步下发订单成功24100110462873982185
2024-10-01 10:46:44 >>>故障排除日志:删除未同步下发订单成功24100110462873982185
2024-10-01 10:46:44 >>>故障排除日志:删除未同步下发订单成功24100110462873982185
2024-10-01 10:46:44 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


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


===11:13:16===
2024-10-01 11:13:13 >>>回调事件[910,devices/D0361]
2024-10-01 11:13:13 >>>故障排除日志:上一MQTT订单号缓存列表为24100110595662675738
2024-10-01 11:13:13 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 11:13:13 开始打印,排队:75,票券:2410011113065976887801,订单:24100111130659765093,[2024-10-01 11:13:12微信支付10元]


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


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


===11:24:17===
2024-10-01 11:23:40 >>>回调事件[910,devices/D0361]
2024-10-01 11:23:40 >>>故障排除日志:上一MQTT订单号缓存列表为24100111211181917772
2024-10-01 11:23:40 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 11:23:40 开始打印,排队:78,票券:2410011123347219947201,订单:24100111233472194959,[2024-10-01 11:23:40微信支付10元]
2024-10-01 11:23:40 开始打印,排队:79,票券:2410011123347220117402,订单:24100111233472194959,[2024-10-01 11:23:40微信支付10元]
2024-10-01 11:23:44 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011123347219947201","queue_number":78,"trade_uid":"24100111233472194959"},{"ticket_no":"2410011123347220117402","queue_number":79,"trade_uid":"24100111233472194959"}]}
2024-10-01 11:23:44 >>>故障排除日志:删除未同步下发订单成功24100111233472194959
2024-10-01 11:23:44 >>>故障排除日志:删除未同步下发订单成功24100111233472194959
2024-10-01 11:23:44 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


===11:35:19===
2024-10-01 11:34:40 >>>回调事件[910,devices/D0361]
2024-10-01 11:34:40 >>>故障排除日志:上一MQTT订单号缓存列表为24100111330482563923
2024-10-01 11:34:40 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 11:34:40 开始打印,排队:85,票券:2410011134344072284201,订单:24100111343440717674,[2024-10-01 11:34:39微信支付10元]
2024-10-01 11:34:40 开始打印,排队:86,票券:2410011134344072504602,订单:24100111343440717674,[2024-10-01 11:34:39微信支付10元]
2024-10-01 11:34:43 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011134344072284201","queue_number":85,"trade_uid":"24100111343440717674"},{"ticket_no":"2410011134344072504602","queue_number":86,"trade_uid":"24100111343440717674"}]}
2024-10-01 11:34:44 >>>故障排除日志:删除未同步下发订单成功24100111343440717674
2024-10-01 11:34:44 >>>故障排除日志:删除未同步下发订单成功24100111343440717674
2024-10-01 11:34:44 >>>故障排除日志:终端同步成功后剩余订单列表


===11:37:19===
2024-10-01 11:37:00 >>>回调事件[910,devices/D0361]
2024-10-01 11:37:00 >>>故障排除日志:上一MQTT订单号缓存列表为24100111343440717674|24100111343440717674
2024-10-01 11:37:00 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 11:37:00 开始打印,排队:87,票券:2410011136533755402701,订单:24100111365337549876,[2024-10-01 11:36:58支付宝支付10元]
2024-10-01 11:37:02 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011136533755402701","queue_number":87,"trade_uid":"24100111365337549876"}]}
2024-10-01 11:37:02 >>>故障排除日志:删除未同步下发订单成功24100111365337549876
2024-10-01 11:37:02 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


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


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


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


===12:12:21===
2024-10-01 12:11:23 >>>回调事件[910,devices/D0361]
2024-10-01 12:11:23 >>>故障排除日志:上一MQTT订单号缓存列表为24100112082224258637
2024-10-01 12:11:23 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 12:11:23 开始打印,排队:96,票券:2410011211189847915401,订单:24100112111898474196,[2024-10-01 12:11:23微信支付10元]
2024-10-01 12:11:23 开始打印,排队:97,票券:2410011211189848116502,订单:24100112111898474196,[2024-10-01 12:11:23微信支付10元]
2024-10-01 12:11:23 开始打印,排队:98,票券:2410011211189848207403,订单:24100112111898474196,[2024-10-01 12:11:23微信支付10元]
2024-10-01 12:11:29 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011211189847915401","queue_number":96,"trade_uid":"24100112111898474196"},{"ticket_no":"2410011211189848116502","queue_number":97,"trade_uid":"24100112111898474196"},{"ticket_no":"2410011211189848207403","queue_number":98,"trade_uid":"24100112111898474196"}]}
2024-10-01 12:11:29 >>>故障排除日志:删除未同步下发订单成功24100112111898474196
2024-10-01 12:11:29 >>>故障排除日志:删除未同步下发订单成功24100112111898474196
2024-10-01 12:11:29 >>>故障排除日志:删除未同步下发订单成功24100112111898474196
2024-10-01 12:11:29 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


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


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


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


===12:46:27===
2024-10-01 12:45:41 >>>回调事件[910,devices/D0361]
2024-10-01 12:45:41 >>>故障排除日志:上一MQTT订单号缓存列表为24100112380232527024
2024-10-01 12:45:41 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 12:45:41 开始打印,排队:106,票券:2410011245358771131701,订单:24100112453587706779,[2024-10-01 12:45:41支付宝支付10元]
2024-10-01 12:45:43 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011245358771131701","queue_number":106,"trade_uid":"24100112453587706779"}]}
2024-10-01 12:45:43 >>>故障排除日志:删除未同步下发订单成功24100112453587706779
2024-10-01 12:45:43 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


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


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


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


===13:15:29===
2024-10-01 13:14:33 >>>回调事件[910,devices/D0361]
2024-10-01 13:14:33 >>>故障排除日志:上一MQTT订单号缓存列表为24100113125896321078
2024-10-01 13:14:33 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 13:14:33 开始打印,排队:114,票券:2410011314275850856801,订单:24100113142758503517,[2024-10-01 13:14:34微信支付10元]
2024-10-01 13:14:36 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011314275850856801","queue_number":114,"trade_uid":"24100113142758503517"}]}
2024-10-01 13:14:36 >>>故障排除日志:删除未同步下发订单成功24100113142758503517
2024-10-01 13:14:36 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-01 13:14:39 >>>回调事件[910,devices/D0361]
2024-10-01 13:14:39 >>>故障排除日志:上一MQTT订单号缓存列表为24100113142758503517
2024-10-01 13:14:39 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 13:14:39 开始打印,排队:115,票券:2410011314326852534201,订单:24100113143268521296,[2024-10-01 13:14:39微信支付10元]
2024-10-01 13:14:41 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011314326852534201","queue_number":115,"trade_uid":"24100113143268521296"}]}
2024-10-01 13:14:41 >>>故障排除日志:删除未同步下发订单成功24100113143268521296
2024-10-01 13:14:41 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-01 13:15:01 >>>回调事件[910,devices/D0361]
2024-10-01 13:15:01 >>>故障排除日志:上一MQTT订单号缓存列表为24100113143268521296
2024-10-01 13:15:01 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 13:15:01 开始打印,排队:116,票券:2410011314500456557201,订单:24100113145004560479,[2024-10-01 13:15:01微信支付10元]
2024-10-01 13:15:03 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011314500456557201","queue_number":116,"trade_uid":"24100113145004560479"}]}
2024-10-01 13:15:03 >>>故障排除日志:删除未同步下发订单成功24100113145004560479
2024-10-01 13:15:03 >>>故障排除日志:终端同步成功后剩余订单列表


===13:17:31===
2024-10-01 13:17:26 >>>回调事件[910,devices/D0361]
2024-10-01 13:17:26 >>>故障排除日志:上一MQTT订单号缓存列表为24100113145004560479
2024-10-01 13:17:26 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 13:17:26 开始打印,排队:117,票券:2410011317153917098401,订单:24100113171539167142,[2024-10-01 13:17:26支付宝支付10元]
2024-10-01 13:17:26 开始打印,排队:118,票券:2410011317153917247902,订单:24100113171539167142,[2024-10-01 13:17:26支付宝支付10元]


===13:18:31===
2024-10-01 13:17:30 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011317153917098401","queue_number":117,"trade_uid":"24100113171539167142"},{"ticket_no":"2410011317153917247902","queue_number":118,"trade_uid":"24100113171539167142"}]}
2024-10-01 13:17:30 >>>故障排除日志:删除未同步下发订单成功24100113171539167142
2024-10-01 13:17:30 >>>故障排除日志:删除未同步下发订单成功24100113171539167142
2024-10-01 13:17:30 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


===13:21:32===
2024-10-01 13:20:44 >>>回调事件[910,devices/D0361]
2024-10-01 13:20:44 >>>故障排除日志:上一MQTT订单号缓存列表为24100113200654206727|24100113200654206727
2024-10-01 13:20:44 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 13:20:44 开始打印,排队:122,票券:2410011320385004234901,订单:24100113203850037396,[2024-10-01 13:20:43支付宝支付10元]
2024-10-01 13:20:46 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011320385004234901","queue_number":122,"trade_uid":"24100113203850037396"}]}
2024-10-01 13:20:46 >>>故障排除日志:删除未同步下发订单成功24100113203850037396
2024-10-01 13:20:46 >>>故障排除日志:终端同步成功后剩余订单列表


===13:25:32===
2024-10-01 13:25:04 >>>回调事件[910,devices/D0361]
2024-10-01 13:25:04 >>>故障排除日志:上一MQTT订单号缓存列表为24100113203850037396
2024-10-01 13:25:04 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 13:25:04 开始打印,排队:123,票券:2410011324580963663501,订单:24100113245809631281,[2024-10-01 13:25:04微信支付10元]
2024-10-01 13:25:06 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011324580963663501","queue_number":123,"trade_uid":"24100113245809631281"}]}
2024-10-01 13:25:06 >>>故障排除日志:删除未同步下发订单成功24100113245809631281
2024-10-01 13:25:06 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-01 13:25:21 >>>回调事件[910,devices/D0361]
2024-10-01 13:25:21 >>>故障排除日志:上一MQTT订单号缓存列表为24100113245809631281
2024-10-01 13:25:21 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 13:25:21 开始打印,排队:124,票券:2410011325141262151901,订单:24100113251412617617,[2024-10-01 13:25:21微信支付10元]
2024-10-01 13:25:23 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011325141262151901","queue_number":124,"trade_uid":"24100113251412617617"}]}
2024-10-01 13:25:24 >>>故障排除日志:删除未同步下发订单成功24100113251412617617
2024-10-01 13:25:24 >>>故障排除日志:终端同步成功后剩余订单列表


===13:26:32===
2024-10-01 13:26:16 >>>回调事件[910,devices/D0361]
2024-10-01 13:26:16 >>>故障排除日志:上一MQTT订单号缓存列表为24100113251412617617
2024-10-01 13:26:16 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 13:26:16 开始打印,排队:125,票券:2410011325482118873501,订单:24100113254821184148,[2024-10-01 13:26:15微信支付10元]
2024-10-01 13:26:18 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011325482118873501","queue_number":125,"trade_uid":"24100113254821184148"}]}
2024-10-01 13:26:18 >>>故障排除日志:删除未同步下发订单成功24100113254821184148
2024-10-01 13:26:18 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-01 13:26:27 >>>回调事件[910,devices/D0361]
2024-10-01 13:26:27 >>>故障排除日志:上一MQTT订单号缓存列表为24100113254821184148
2024-10-01 13:26:27 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 13:26:27 开始打印,排队:126,票券:2410011326201211118701,订单:24100113262012105852,[2024-10-01 13:26:27微信支付10元]
2024-10-01 13:26:29 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011326201211118701","queue_number":126,"trade_uid":"24100113262012105852"}]}
2024-10-01 13:26:29 >>>故障排除日志:删除未同步下发订单成功24100113262012105852
2024-10-01 13:26:29 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


===13:42:33===
2024-10-01 13:41:55 >>>回调事件[910,devices/D0361]
2024-10-01 13:41:55 >>>故障排除日志:上一MQTT订单号缓存列表为24100113310547048796
2024-10-01 13:41:55 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 13:41:55 开始打印,排队:129,票券:2410011341489633681601,订单:24100113414896332262,[2024-10-01 13:41:55微信支付10元]
2024-10-01 13:41:57 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011341489633681601","queue_number":129,"trade_uid":"24100113414896332262"}]}
2024-10-01 13:41:57 >>>故障排除日志:删除未同步下发订单成功24100113414896332262
2024-10-01 13:41:57 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-01 13:42:29 >>>回调事件[910,devices/D0361]
2024-10-01 13:42:29 >>>故障排除日志:上一MQTT订单号缓存列表为24100113414896332262
2024-10-01 13:42:29 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 13:42:29 开始打印,排队:130,票券:2410011342237676003901,订单:24100113422376754767,[2024-10-01 13:42:29微信支付10元]
2024-10-01 13:42:31 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011342237676003901","queue_number":130,"trade_uid":"24100113422376754767"}]}
2024-10-01 13:42:31 >>>故障排除日志:删除未同步下发订单成功24100113422376754767
2024-10-01 13:42:32 >>>故障排除日志:终端同步成功后剩余订单列表


===13:45:34===
2024-10-01 13:45:30 >>>回调事件[910,devices/D0361]
2024-10-01 13:45:30 >>>故障排除日志:上一MQTT订单号缓存列表为24100113422376754767
2024-10-01 13:45:30 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 13:45:30 开始打印,排队:131,票券:2410011345228765732901,订单:24100113452287651581,[2024-10-01 13:45:30微信支付10元]


===13:46:34===
2024-10-01 13:45:41 >>>回调事件[910,devices/D0361]
2024-10-01 13:45:41 >>>故障排除日志:上一MQTT订单号缓存列表为24100113452287651581
2024-10-01 13:45:41 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 13:45:41 开始打印,排队:132,票券:2410011345333301611301,订单:24100113453333011358,[2024-10-01 13:45:41支付宝支付10元]
2024-10-01 13:45:43 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011345333301611301","queue_number":132,"trade_uid":"24100113453333011358"}]}
2024-10-01 13:45:43 >>>故障排除日志:删除未同步下发订单成功24100113453333011358
2024-10-01 13:45:43 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-01 13:45:48 >>>回调事件[910,devices/D0361]
2024-10-01 13:45:48 >>>故障排除日志:上一MQTT订单号缓存列表为24100113453333011358
2024-10-01 13:45:48 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 13:45:48 开始打印,排队:133,票券:2410011345425404711501,订单:24100113454254041662,[2024-10-01 13:45:48微信支付10元]
2024-10-01 13:45:48 开始打印,排队:134,票券:2410011345425404906402,订单:24100113454254041662,[2024-10-01 13:45:48微信支付10元]
2024-10-01 13:45:52 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011345425404711501","queue_number":133,"trade_uid":"24100113454254041662"},{"ticket_no":"2410011345425404906402","queue_number":134,"trade_uid":"24100113454254041662"}]}
2024-10-01 13:45:52 >>>故障排除日志:删除未同步下发订单成功24100113454254041662
2024-10-01 13:45:52 >>>故障排除日志:删除未同步下发订单成功24100113454254041662
2024-10-01 13:45:52 >>>故障排除日志:终端同步成功后剩余订单列表


===13:47:35===
2024-10-01 13:46:57 >>>回调事件[910,devices/D0361]
2024-10-01 13:46:57 >>>故障排除日志:上一MQTT订单号缓存列表为24100113454254041662|24100113454254041662
2024-10-01 13:46:57 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 13:46:57 开始打印,排队:135,票券:2410011346488107029101,订单:24100113464881065687,[2024-10-01 13:46:56支付宝支付10元]
2024-10-01 13:46:59 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011346488107029101","queue_number":135,"trade_uid":"24100113464881065687"}]}
2024-10-01 13:46:59 >>>故障排除日志:删除未同步下发订单成功24100113464881065687
2024-10-01 13:46:59 >>>故障排除日志:终端同步成功后剩余订单列表


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


===13:51:35===
2024-10-01 13:51:29 >>>回调事件[910,devices/D0361]
2024-10-01 13:51:29 >>>故障排除日志:上一MQTT订单号缓存列表为24100113492823444438
2024-10-01 13:51:29 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 13:51:29 开始打印,排队:137,票券:2410011351148131797101,订单:24100113511481312986,[2024-10-01 13:51:29支付宝支付10元]
2024-10-01 13:51:31 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011351148131797101","queue_number":137,"trade_uid":"24100113511481312986"}]}
2024-10-01 13:51:31 >>>故障排除日志:删除未同步下发订单成功24100113511481312986
2024-10-01 13:51:32 >>>故障排除日志:终端同步成功后剩余订单列表


===13:53:35===
2024-10-01 13:52:42 >>>回调事件[910,devices/D0361]
2024-10-01 13:52:42 >>>故障排除日志:上一MQTT订单号缓存列表为24100113511481312986
2024-10-01 13:52:42 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 13:52:42 开始打印,排队:138,票券:2410011352347337821701,订单:24100113523473373792,[2024-10-01 13:52:42微信支付10元]
2024-10-01 13:52:44 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011352347337821701","queue_number":138,"trade_uid":"24100113523473373792"}]}
2024-10-01 13:52:44 >>>故障排除日志:删除未同步下发订单成功24100113523473373792
2024-10-01 13:52:44 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-01 13:53:26 >>>回调事件[910,devices/D0361]
2024-10-01 13:53:26 >>>故障排除日志:上一MQTT订单号缓存列表为24100113523473373792
2024-10-01 13:53:26 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 13:53:26 开始打印,排队:139,票券:2410011353209842963101,订单:24100113532098424439,[2024-10-01 13:53:25微信支付10元]
2024-10-01 13:53:26 开始打印,排队:140,票券:2410011353209843161802,订单:24100113532098424439,[2024-10-01 13:53:25微信支付10元]
2024-10-01 13:53:30 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011353209842963101","queue_number":139,"trade_uid":"24100113532098424439"},{"ticket_no":"2410011353209843161802","queue_number":140,"trade_uid":"24100113532098424439"}]}
2024-10-01 13:53:30 >>>故障排除日志:删除未同步下发订单成功24100113532098424439
2024-10-01 13:53:30 >>>故障排除日志:删除未同步下发订单成功24100113532098424439
2024-10-01 13:53:30 >>>故障排除日志:终端同步成功后剩余订单列表


===13:56:36===
2024-10-01 13:55:47 >>>回调事件[910,devices/D0361]
2024-10-01 13:55:47 >>>故障排除日志:上一MQTT订单号缓存列表为24100113532098424439|24100113532098424439
2024-10-01 13:55:47 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 13:55:47 开始打印,排队:141,票券:2410011355404946266401,订单:24100113554049457617,[2024-10-01 13:55:47微信支付10元]
2024-10-01 13:55:49 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011355404946266401","queue_number":141,"trade_uid":"24100113554049457617"}]}
2024-10-01 13:55:49 >>>故障排除日志:删除未同步下发订单成功24100113554049457617
2024-10-01 13:55:49 >>>故障排除日志:终端同步成功后剩余订单列表


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


===14:08:36===
2024-10-01 14:07:43 >>>回调事件[910,devices/D0361]
2024-10-01 14:07:43 >>>故障排除日志:上一MQTT订单号缓存列表为24100114021209624317
2024-10-01 14:07:43 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 14:07:43 开始打印,排队:143,票券:2410011407367635426301,订单:24100114073676349878,[2024-10-01 14:07:43微信支付10元]
2024-10-01 14:07:45 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011407367635426301","queue_number":143,"trade_uid":"24100114073676349878"}]}
2024-10-01 14:07:45 >>>故障排除日志:删除未同步下发订单成功24100114073676349878
2024-10-01 14:07:45 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-01 14:08:28 >>>回调事件[910,devices/D0361]
2024-10-01 14:08:28 >>>故障排除日志:上一MQTT订单号缓存列表为24100114073676349878
2024-10-01 14:08:28 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 14:08:28 开始打印,排队:144,票券:2410011408207665235801,订单:24100114082076647457,[2024-10-01 14:08:27微信支付10元]
2024-10-01 14:08:30 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011408207665235801","queue_number":144,"trade_uid":"24100114082076647457"}]}
2024-10-01 14:08:30 >>>故障排除日志:删除未同步下发订单成功24100114082076647457
2024-10-01 14:08:30 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


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


===14:23:39===
2024-10-01 14:22:43 >>>回调事件[910,devices/D0361]
2024-10-01 14:22:43 >>>故障排除日志:上一MQTT订单号缓存列表为24100114171569067325
2024-10-01 14:22:43 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 14:22:43 开始打印,排队:150,票券:2410011422358136015301,订单:24100114223581356183,[2024-10-01 14:22:42微信支付10元]
2024-10-01 14:22:47 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011422358136015301","queue_number":150,"trade_uid":"24100114223581356183"}]}
2024-10-01 14:22:47 >>>故障排除日志:删除未同步下发订单成功24100114223581356183
2024-10-01 14:22:47 >>>故障排除日志:终端同步成功后剩余订单列表


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


===14:28:39===
2024-10-01 14:28:36 >>>回调事件[910,devices/D0361]
2024-10-01 14:28:36 >>>故障排除日志:上一MQTT订单号缓存列表为24100114241591091051
2024-10-01 14:28:36 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 14:28:36 开始打印,排队:152,票券:2410011428295553937801,订单:24100114282955535245,[2024-10-01 14:28:35微信支付10元]


===14:29:40===
2024-10-01 14:28:38 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011428295553937801","queue_number":152,"trade_uid":"24100114282955535245"}]}
2024-10-01 14:28:38 >>>故障排除日志:删除未同步下发订单成功24100114282955535245
2024-10-01 14:28:38 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


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


===14:39:41===
2024-10-01 14:38:46 >>>回调事件[910,devices/D0361]
2024-10-01 14:38:46 >>>故障排除日志:上一MQTT订单号缓存列表为24100114371808607413
2024-10-01 14:38:46 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 14:38:46 开始打印,排队:158,票券:2410011438375104543401,订单:24100114383751042335,[2024-10-01 14:38:45微信支付10元]
2024-10-01 14:38:48 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011438375104543401","queue_number":158,"trade_uid":"24100114383751042335"}]}
2024-10-01 14:38:48 >>>故障排除日志:删除未同步下发订单成功24100114383751042335
2024-10-01 14:38:48 >>>故障排除日志:终端同步成功后剩余订单列表


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


===14:43:42===
2024-10-01 14:43:00 >>>回调事件[910,devices/D0361]
2024-10-01 14:43:00 >>>故障排除日志:上一MQTT订单号缓存列表为24100114414060567613
2024-10-01 14:43:00 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 14:43:00 开始打印,排队:160,票券:2410011442535498312701,订单:24100114425354977353,[2024-10-01 14:43:00微信支付10元]
2024-10-01 14:43:02 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011442535498312701","queue_number":160,"trade_uid":"24100114425354977353"}]}
2024-10-01 14:43:02 >>>故障排除日志:删除未同步下发订单成功24100114425354977353
2024-10-01 14:43:02 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-01 14:43:12 >>>回调事件[910,devices/D0361]
2024-10-01 14:43:12 >>>故障排除日志:上一MQTT订单号缓存列表为24100114425354977353
2024-10-01 14:43:12 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 14:43:12 开始打印,排队:161,票券:2410011443058302702701,订单:24100114430583020921,[2024-10-01 14:43:12微信支付10元]
2024-10-01 14:43:14 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011443058302702701","queue_number":161,"trade_uid":"24100114430583020921"}]}
2024-10-01 14:43:14 >>>故障排除日志:删除未同步下发订单成功24100114430583020921
2024-10-01 14:43:14 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-01 14:43:35 >>>回调事件[910,devices/D0361]
2024-10-01 14:43:35 >>>故障排除日志:上一MQTT订单号缓存列表为24100114430583020921
2024-10-01 14:43:35 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 14:43:35 开始打印,排队:162,票券:2410011443300944908901,订单:24100114433009443338,[2024-10-01 14:43:35支付宝支付10元]
2024-10-01 14:43:37 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011443300944908901","queue_number":162,"trade_uid":"24100114433009443338"}]}
2024-10-01 14:43:37 >>>故障排除日志:删除未同步下发订单成功24100114433009443338
2024-10-01 14:43:37 >>>故障排除日志:终端同步成功后剩余订单列表


===14:45:43===
2024-10-01 14:44:58 >>>回调事件[910,devices/D0361]
2024-10-01 14:44:58 >>>故障排除日志:上一MQTT订单号缓存列表为24100114433009443338
2024-10-01 14:44:58 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 14:44:58 开始打印,排队:163,票券:2410011444531282954801,订单:24100114445312825446,[2024-10-01 14:44:57微信支付10元]
2024-10-01 14:44:58 开始打印,排队:164,票券:2410011444531283092102,订单:24100114445312825446,[2024-10-01 14:44:57微信支付10元]
2024-10-01 14:45:02 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011444531282954801","queue_number":163,"trade_uid":"24100114445312825446"},{"ticket_no":"2410011444531283092102","queue_number":164,"trade_uid":"24100114445312825446"}]}
2024-10-01 14:45:02 >>>故障排除日志:删除未同步下发订单成功24100114445312825446
2024-10-01 14:45:02 >>>故障排除日志:删除未同步下发订单成功24100114445312825446
2024-10-01 14:45:02 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-01 14:45:27 >>>回调事件[910,devices/D0361]
2024-10-01 14:45:27 >>>故障排除日志:上一MQTT订单号缓存列表为24100114445312825446|24100114445312825446
2024-10-01 14:45:27 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 14:45:27 开始打印,排队:165,票券:2410011445209517837101,订单:24100114452095173479,[2024-10-01 14:45:27微信支付10元]
2024-10-01 14:45:29 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011445209517837101","queue_number":165,"trade_uid":"24100114452095173479"}]}
2024-10-01 14:45:29 >>>故障排除日志:删除未同步下发订单成功24100114452095173479
2024-10-01 14:45:29 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


===14:55:43===
2024-10-01 14:54:51 >>>回调事件[910,devices/D0361]
2024-10-01 14:54:51 >>>故障排除日志:上一MQTT订单号缓存列表为24100114534992519212
2024-10-01 14:54:51 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 14:54:51 开始打印,排队:170,票券:2410011454464458545201,订单:24100114544644581573,[2024-10-01 14:54:51微信支付10元]
2024-10-01 14:54:53 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011454464458545201","queue_number":170,"trade_uid":"24100114544644581573"}]}
2024-10-01 14:54:53 >>>故障排除日志:删除未同步下发订单成功24100114544644581573
2024-10-01 14:54:53 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-01 14:55:06 >>>回调事件[910,devices/D0361]
2024-10-01 14:55:06 >>>故障排除日志:上一MQTT订单号缓存列表为24100114544644581573
2024-10-01 14:55:06 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 14:55:06 开始打印,排队:171,票券:2410011454559297843701,订单:24100114545592973659,[2024-10-01 14:55:07支付宝支付10元]
2024-10-01 14:55:08 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011454559297843701","queue_number":171,"trade_uid":"24100114545592973659"}]}
2024-10-01 14:55:08 >>>故障排除日志:删除未同步下发订单成功24100114545592973659
2024-10-01 14:55:09 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-01 14:55:20 >>>回调事件[910,devices/D0361]
2024-10-01 14:55:20 >>>故障排除日志:上一MQTT订单号缓存列表为24100114545592973659
2024-10-01 14:55:20 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 14:55:20 开始打印,排队:172,票券:2410011455136281947601,订单:24100114551362815383,[2024-10-01 14:55:19微信支付10元]
2024-10-01 14:55:22 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011455136281947601","queue_number":172,"trade_uid":"24100114551362815383"}]}
2024-10-01 14:55:22 >>>故障排除日志:删除未同步下发订单成功24100114551362815383
2024-10-01 14:55:22 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


===14:59:44===
2024-10-01 14:58:44 >>>回调事件[910,devices/D0361]
2024-10-01 14:58:44 >>>故障排除日志:上一MQTT订单号缓存列表为24100114570641380448|24100114570641380448
2024-10-01 14:58:44 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 14:58:44 开始打印,排队:176,票券:2410011458384451675201,订单:24100114583844512814,[2024-10-01 14:58:44微信支付10元]
2024-10-01 14:58:44 开始打印,排队:177,票券:2410011458384451818202,订单:24100114583844512814,[2024-10-01 14:58:44微信支付10元]
2024-10-01 14:58:48 >>>回调事件[910,devices/D0361]
2024-10-01 14:58:48 >>>故障排除日志:上一MQTT订单号缓存列表为24100114583844512814|24100114583844512814
2024-10-01 14:58:48 >>>故障排除日志:终端未同步成功订单列表017624100114583844512814|017724100114583844512814
已接收过此消息,票券号为2410011458384451675201,排队号为176
已接收过此消息,票券号为2410011458384451818202,排队号为177
2024-10-01 14:58:48 开始打印,排队:178,票券:2410011458406337391901,订单:24100114584063370142,[2024-10-01 14:58:47微信支付10元]
2024-10-01 14:58:50 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011458384451675201","queue_number":176,"trade_uid":"24100114583844512814"},{"ticket_no":"2410011458384451818202","queue_number":177,"trade_uid":"24100114583844512814"}]}
2024-10-01 14:58:50 >>>故障排除日志:删除未同步下发订单成功24100114583844512814
2024-10-01 14:58:50 >>>故障排除日志:删除未同步下发订单成功24100114583844512814
2024-10-01 14:58:50 >>>故障排除日志:终端同步成功后剩余订单列表017824100114584063370142
2024-10-01 14:58:50 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011458384451675201","queue_number":176,"trade_uid":"24100114583844512814"},{"ticket_no":"2410011458384451818202","queue_number":177,"trade_uid":"24100114583844512814"},{"ticket_no":"2410011458406337391901","queue_number":178,"trade_uid":"24100114584063370142"}]}
2024-10-01 14:58:50 >>>故障排除日志:删除未同步下发订单成功24100114584063370142
2024-10-01 14:58:50 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


===15:13:45===
2024-10-01 15:12:54 >>>回调事件[910,devices/D0361]
2024-10-01 15:12:54 >>>故障排除日志:上一MQTT订单号缓存列表为24100115103147151814
2024-10-01 15:12:54 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 15:12:54 开始打印,排队:181,票券:2410011512481274413801,订单:24100115124812739297,[2024-10-01 15:12:53微信支付10元]
2024-10-01 15:12:56 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011512481274413801","queue_number":181,"trade_uid":"24100115124812739297"}]}
2024-10-01 15:12:56 >>>故障排除日志:删除未同步下发订单成功24100115124812739297
2024-10-01 15:12:56 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-01 15:12:58 >>>回调事件[910,devices/D0361]
2024-10-01 15:12:58 >>>故障排除日志:上一MQTT订单号缓存列表为24100115124812739297
2024-10-01 15:12:58 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 15:12:58 开始打印,排队:182,票券:2410011512450021667901,订单:24100115124500211446,[2024-10-01 15:12:58微信支付10元]
2024-10-01 15:12:58 开始打印,排队:183,票券:2410011512450021823502,订单:24100115124500211446,[2024-10-01 15:12:58微信支付10元]
2024-10-01 15:13:02 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011512450021667901","queue_number":182,"trade_uid":"24100115124500211446"},{"ticket_no":"2410011512450021823502","queue_number":183,"trade_uid":"24100115124500211446"}]}
2024-10-01 15:13:02 >>>故障排除日志:删除未同步下发订单成功24100115124500211446
2024-10-01 15:13:02 >>>故障排除日志:删除未同步下发订单成功24100115124500211446
2024-10-01 15:13:02 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


===15:29:46===
2024-10-01 15:28:55 >>>回调事件[910,devices/D0361]
2024-10-01 15:28:55 >>>故障排除日志:上一MQTT订单号缓存列表为24100115192401670924
2024-10-01 15:28:55 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 15:28:55 开始打印,排队:187,票券:2410011528506266608101,订单:24100115285062662268,[2024-10-01 15:28:55支付宝支付10元]
2024-10-01 15:28:57 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011528506266608101","queue_number":187,"trade_uid":"24100115285062662268"}]}
2024-10-01 15:28:57 >>>故障排除日志:删除未同步下发订单成功24100115285062662268
2024-10-01 15:28:57 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-01 15:29:20 >>>回调事件[910,devices/D0361]
2024-10-01 15:29:20 >>>故障排除日志:上一MQTT订单号缓存列表为24100115285062662268
2024-10-01 15:29:20 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 15:29:20 开始打印,排队:188,票券:2410011529018207739401,订单:24100115290182073797,[2024-10-01 15:29:20支付宝支付10元]
2024-10-01 15:29:22 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011529018207739401","queue_number":188,"trade_uid":"24100115290182073797"}]}
2024-10-01 15:29:22 >>>故障排除日志:删除未同步下发订单成功24100115290182073797
2024-10-01 15:29:22 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


===15:46:48===
2024-10-01 15:46:36>>>cash read=00
2024-10-01 15:46:36>>>cash read=818F42
2024-10-01 15:46:36>>>cash write=02
2024-10-01 15:46:36 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-01 15:46:37>>>cash read=10
2024-10-01 15:46:37 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-01 15:46:37 当前产品价格10元，投币10元，打印小票中...
2024-10-01 15:46:37 >>>开始打印,排队号为193,订单号为2410011546370003611185
2024-10-01 15:46:37>>>订单2410011546370003611185写入成功,剩余空间为1680000,占用RAM为606.408203125
删除未同步订单2410011546370003611185
2024-10-01 15:46:39>>>订单2410011546370003611185删除成功,剩余空间为1680500,占用RAM为617.0009765625
检测订单目录中>>>
无未同步订单>>>
2024-10-01 15:46:39 >>>当前Ram内存为589.08203125
定时检测未同步订单启用
2024-10-01 15:46:40>>>cash write=0C
2024-10-01 15:46:40>>>cash read=3E


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


===15:49:48===
2024-10-01 15:49:24 >>>回调事件[910,devices/D0361]
2024-10-01 15:49:24 >>>故障排除日志:上一MQTT订单号缓存列表为24100115453791650965
2024-10-01 15:49:24 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 15:49:24 开始打印,排队:194,票券:2410011549145337713501,订单:24100115491453372564,[2024-10-01 15:49:23微信支付10元]
2024-10-01 15:49:24 开始打印,排队:195,票券:2410011549145337918202,订单:24100115491453372564,[2024-10-01 15:49:23微信支付10元]
2024-10-01 15:49:28 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011549145337713501","queue_number":194,"trade_uid":"24100115491453372564"},{"ticket_no":"2410011549145337918202","queue_number":195,"trade_uid":"24100115491453372564"}]}
2024-10-01 15:49:28 >>>故障排除日志:删除未同步下发订单成功24100115491453372564
2024-10-01 15:49:28 >>>故障排除日志:删除未同步下发订单成功24100115491453372564
2024-10-01 15:49:28 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


===15:55:49===
2024-10-01 15:55:34 >>>回调事件[910,devices/D0361]
2024-10-01 15:55:34 >>>故障排除日志:上一MQTT订单号缓存列表为24100115525060101139
2024-10-01 15:55:34 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 15:55:34 开始打印,排队:198,票券:2410011555281958877201,订单:24100115552819584918,[2024-10-01 15:55:33支付宝支付10元]
2024-10-01 15:55:36 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011555281958877201","queue_number":198,"trade_uid":"24100115552819584918"}]}
2024-10-01 15:55:36 >>>故障排除日志:删除未同步下发订单成功24100115552819584918
2024-10-01 15:55:36 >>>故障排除日志:终端同步成功后剩余订单列表


===15:56:50===
2024-10-01 15:56:00>>>cash read=00
2024-10-01 15:56:01>>>cash read=818F42
2024-10-01 15:56:01>>>cash write=02
2024-10-01 15:56:01 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-01 15:56:02>>>cash read=10
2024-10-01 15:56:02 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-01 15:56:02 当前产品价格10元，投币10元，打印小票中...
2024-10-01 15:56:02 >>>开始打印,排队号为199,订单号为2410011556020003611375
2024-10-01 15:56:02>>>订单2410011556020003611375写入成功,剩余空间为1680000,占用RAM为606.900390625
删除未同步订单2410011556020003611375
2024-10-01 15:56:04>>>订单2410011556020003611375删除成功,剩余空间为1680500,占用RAM为617.7197265625
检测订单目录中>>>
无未同步订单>>>
2024-10-01 15:56:04 >>>当前Ram内存为589.630859375
定时检测未同步订单启用
2024-10-01 15:56:05>>>cash write=0C
2024-10-01 15:56:05>>>cash read=3E
2024-10-01 15:56:46 >>>回调事件[910,devices/D0361]
2024-10-01 15:56:46 >>>故障排除日志:上一MQTT订单号缓存列表为24100115552819584918
2024-10-01 15:56:46 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 15:56:46 开始打印,排队:200,票券:2410011556386329845801,订单:24100115563863294621,[2024-10-01 15:56:46微信支付10元]


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


===15:58:51===
2024-10-01 15:58:22 >>>回调事件[910,devices/D0361]
2024-10-01 15:58:22 >>>故障排除日志:上一MQTT订单号缓存列表为24100115563863294621
2024-10-01 15:58:22 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 15:58:22 开始打印,排队:201,票券:2410011558151027238401,订单:24100115581510266691,[2024-10-01 15:58:21微信支付10元]
2024-10-01 15:58:22 开始打印,排队:202,票券:2410011558151027381802,订单:24100115581510266691,[2024-10-01 15:58:21微信支付10元]
2024-10-01 15:58:25 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011558151027238401","queue_number":201,"trade_uid":"24100115581510266691"},{"ticket_no":"2410011558151027381802","queue_number":202,"trade_uid":"24100115581510266691"}]}
2024-10-01 15:58:25 >>>故障排除日志:删除未同步下发订单成功24100115581510266691
2024-10-01 15:58:25 >>>故障排除日志:删除未同步下发订单成功24100115581510266691
2024-10-01 15:58:25 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


===16:12:52===
2024-10-01 16:12:48 >>>回调事件[910,devices/D0361]
2024-10-01 16:12:48 >>>故障排除日志:上一MQTT订单号缓存列表为24100116055603915735
2024-10-01 16:12:48 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 16:12:48 开始打印,排队:205,票券:2410011612359864983601,订单:24100116123598644862,[2024-10-01 16:12:48微信支付10元]


===16:13:52===
2024-10-01 16:12:50 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011612359864983601","queue_number":205,"trade_uid":"24100116123598644862"}]}
2024-10-01 16:12:50 >>>故障排除日志:删除未同步下发订单成功24100116123598644862
2024-10-01 16:12:50 >>>故障排除日志:终端同步成功后剩余订单列表


===16:16:52===
2024-10-01 16:16:29 >>>回调事件[910,devices/D0361]
2024-10-01 16:16:29 >>>故障排除日志:上一MQTT订单号缓存列表为24100116123598644862
2024-10-01 16:16:29 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 16:16:29 开始打印,排队:206,票券:2410011616228740118901,订单:24100116162287397476,[2024-10-01 16:16:28支付宝支付10元]
2024-10-01 16:16:31 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011616228740118901","queue_number":206,"trade_uid":"24100116162287397476"}]}
2024-10-01 16:16:31 >>>故障排除日志:删除未同步下发订单成功24100116162287397476
2024-10-01 16:16:31 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-01 16:16:38 >>>回调事件[910,devices/D0361]
2024-10-01 16:16:38 >>>故障排除日志:上一MQTT订单号缓存列表为24100116162287397476
2024-10-01 16:16:38 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 16:16:38 开始打印,排队:207,票券:2410011616313899737901,订单:24100116163138993553,[2024-10-01 16:16:38微信支付10元]
2024-10-01 16:16:40 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011616313899737901","queue_number":207,"trade_uid":"24100116163138993553"}]}
2024-10-01 16:16:40 >>>故障排除日志:删除未同步下发订单成功24100116163138993553
2024-10-01 16:16:40 >>>故障排除日志:终端同步成功后剩余订单列表


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


===16:18:53===
2024-10-01 16:18:06 >>>回调事件[910,devices/D0361]
2024-10-01 16:18:06 >>>故障排除日志:上一MQTT订单号缓存列表为24100116171552098254
2024-10-01 16:18:06 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 16:18:06 开始打印,排队:209,票券:2410011617562043709701,订单:24100116175620432687,[2024-10-01 16:18:05微信支付10元]
2024-10-01 16:18:08 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011617562043709701","queue_number":209,"trade_uid":"24100116175620432687"}]}
2024-10-01 16:18:08 >>>故障排除日志:删除未同步下发订单成功24100116175620432687
2024-10-01 16:18:08 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-01 16:18:34 >>>回调事件[910,devices/D0361]
2024-10-01 16:18:34 >>>故障排除日志:上一MQTT订单号缓存列表为24100116175620432687
2024-10-01 16:18:34 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 16:18:34 开始打印,排队:210,票券:2410011618270124337601,订单:24100116182701237559,[2024-10-01 16:18:33微信支付10元]
2024-10-01 16:18:36 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011618270124337601","queue_number":210,"trade_uid":"24100116182701237559"}]}
2024-10-01 16:18:36 >>>故障排除日志:删除未同步下发订单成功24100116182701237559
2024-10-01 16:18:36 >>>故障排除日志:终端同步成功后剩余订单列表


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


===16:26:54===
2024-10-01 16:26:06 >>>回调事件[910,devices/D0361]
2024-10-01 16:26:06 >>>故障排除日志:上一MQTT订单号缓存列表为24100116214243284326
2024-10-01 16:26:06 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 16:26:06 开始打印,排队:212,票券:2410011626012702234601,订单:24100116260127018036,[2024-10-01 16:26:06微信支付10元]
2024-10-01 16:26:08 >>>回调事件[910,devices/D0361]
2024-10-01 16:26:08 >>>故障排除日志:上一MQTT订单号缓存列表为24100116260127018036
2024-10-01 16:26:08 >>>故障排除日志:终端未同步成功订单列表021224100116260127018036
2024-10-01 16:26:08 开始打印,排队:213,票券:2410011625593562189301,订单:24100116255935616736,[2024-10-01 16:26:06支付宝支付10元]
2024-10-01 16:26:08 开始打印,排队:214,票券:2410011625593562376802,订单:24100116255935616736,[2024-10-01 16:26:06支付宝支付10元]
已接收过此消息,票券号为2410011626012702234601,排队号为212
2024-10-01 16:26:12 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011626012702234601","queue_number":212,"trade_uid":"24100116260127018036"}]}
2024-10-01 16:26:12 >>>故障排除日志:删除未同步下发订单成功24100116260127018036
2024-10-01 16:26:12 >>>故障排除日志:终端同步成功后剩余订单列表021324100116255935616736|021424100116255935616736
2024-10-01 16:26:12 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011625593562189301","queue_number":213,"trade_uid":"24100116255935616736"},{"ticket_no":"2410011625593562376802","queue_number":214,"trade_uid":"24100116255935616736"},{"ticket_no":"2410011626012702234601","queue_number":212,"trade_uid":"24100116260127018036"}]}
2024-10-01 16:26:12 >>>故障排除日志:删除未同步下发订单成功24100116255935616736
2024-10-01 16:26:12 >>>故障排除日志:删除未同步下发订单成功24100116255935616736
2024-10-01 16:26:12 >>>故障排除日志:终端同步成功后剩余订单列表


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


===16:31:54===
2024-10-01 16:30:59 >>>回调事件[910,devices/D0361]
2024-10-01 16:30:59 >>>故障排除日志:上一MQTT订单号缓存列表为24100116301931680821
2024-10-01 16:30:59 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 16:30:59 开始打印,排队:216,票券:2410011630500680608301,订单:24100116305006800349,[2024-10-01 16:30:59支付宝支付10元]
2024-10-01 16:31:01 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011630500680608301","queue_number":216,"trade_uid":"24100116305006800349"}]}
2024-10-01 16:31:01 >>>故障排除日志:删除未同步下发订单成功24100116305006800349
2024-10-01 16:31:01 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-01 16:31:09 >>>回调事件[910,devices/D0361]
2024-10-01 16:31:09 >>>故障排除日志:上一MQTT订单号缓存列表为24100116305006800349
2024-10-01 16:31:09 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 16:31:09 开始打印,排队:217,票券:2410011631040193974301,订单:24100116310401935017,[2024-10-01 16:31:09微信支付10元]
2024-10-01 16:31:09 开始打印,排队:218,票券:2410011631040194157502,订单:24100116310401935017,[2024-10-01 16:31:09微信支付10元]
2024-10-01 16:31:13 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011631040193974301","queue_number":217,"trade_uid":"24100116310401935017"},{"ticket_no":"2410011631040194157502","queue_number":218,"trade_uid":"24100116310401935017"}]}
2024-10-01 16:31:13 >>>故障排除日志:删除未同步下发订单成功24100116310401935017
2024-10-01 16:31:13 >>>故障排除日志:删除未同步下发订单成功24100116310401935017
2024-10-01 16:31:13 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


===16:38:55===
2024-10-01 16:38:45 >>>回调事件[910,devices/D0361]
2024-10-01 16:38:45 >>>故障排除日志:上一MQTT订单号缓存列表为24100116350073669569
2024-10-01 16:38:45 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 16:38:45 开始打印,排队:221,票券:2410011638391685577201,订单:24100116383916850791,[2024-10-01 16:38:45微信支付10元]
2024-10-01 16:38:45 开始打印,排队:222,票券:2410011638391685774102,订单:24100116383916850791,[2024-10-01 16:38:45微信支付10元]
2024-10-01 16:38:48 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011638391685577201","queue_number":221,"trade_uid":"24100116383916850791"},{"ticket_no":"2410011638391685774102","queue_number":222,"trade_uid":"24100116383916850791"}]}
2024-10-01 16:38:48 >>>故障排除日志:删除未同步下发订单成功24100116383916850791
2024-10-01 16:38:48 >>>故障排除日志:删除未同步下发订单成功24100116383916850791
2024-10-01 16:38:48 >>>故障排除日志:终端同步成功后剩余订单列表


===16:40:55===
2024-10-01 16:40:22 >>>回调事件[910,devices/D0361]
2024-10-01 16:40:22 >>>故障排除日志:上一MQTT订单号缓存列表为24100116383916850791|24100116383916850791
2024-10-01 16:40:22 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 16:40:22 开始打印,排队:223,票券:2410011640155422995201,订单:24100116401554224851,[2024-10-01 16:40:22微信支付10元]
2024-10-01 16:40:24 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011640155422995201","queue_number":223,"trade_uid":"24100116401554224851"}]}
2024-10-01 16:40:24 >>>故障排除日志:删除未同步下发订单成功24100116401554224851
2024-10-01 16:40:24 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-01 16:40:43 >>>回调事件[910,devices/D0361]
2024-10-01 16:40:43 >>>故障排除日志:上一MQTT订单号缓存列表为24100116401554224851
2024-10-01 16:40:43 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 16:40:43 开始打印,排队:224,票券:2410011640358185468401,订单:24100116403581848429,[2024-10-01 16:40:43支付宝支付10元]
2024-10-01 16:40:45 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011640358185468401","queue_number":224,"trade_uid":"24100116403581848429"}]}
2024-10-01 16:40:45 >>>故障排除日志:删除未同步下发订单成功24100116403581848429
2024-10-01 16:40:45 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


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


===17:04:57===
2024-10-01 17:04:23 >>>回调事件[910,devices/D0361]
2024-10-01 17:04:23 >>>故障排除日志:上一MQTT订单号缓存列表为24100116504879221168
2024-10-01 17:04:23 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 17:04:23 开始打印,排队:230,票券:2410011704173389759301,订单:24100117041733893565,[2024-10-01 17:04:22微信支付10元]
2024-10-01 17:04:24 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011704173389759301","queue_number":230,"trade_uid":"24100117041733893565"}]}
2024-10-01 17:04:24 >>>故障排除日志:删除未同步下发订单成功24100117041733893565
2024-10-01 17:04:25 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-01 17:04:44 >>>回调事件[910,devices/D0361]
2024-10-01 17:04:44 >>>故障排除日志:上一MQTT订单号缓存列表为24100117041733893565
2024-10-01 17:04:44 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 17:04:44 开始打印,排队:231,票券:2410011704369595858701,订单:24100117043695954471,[2024-10-01 17:04:43微信支付10元]
2024-10-01 17:04:46 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011704369595858701","queue_number":231,"trade_uid":"24100117043695954471"}]}
2024-10-01 17:04:46 >>>故障排除日志:删除未同步下发订单成功24100117043695954471
2024-10-01 17:04:46 >>>故障排除日志:终端同步成功后剩余订单列表


===17:06:57===
2024-10-01 17:06:17 >>>回调事件[910,devices/D0361]
2024-10-01 17:06:17 >>>故障排除日志:上一MQTT订单号缓存列表为24100117043695954471
2024-10-01 17:06:17 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 17:06:17 开始打印,排队:232,票券:2410011706083253754701,订单:24100117060832533235,[2024-10-01 17:06:17微信支付10元]
2024-10-01 17:06:19 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011706083253754701","queue_number":232,"trade_uid":"24100117060832533235"}]}
2024-10-01 17:06:19 >>>故障排除日志:删除未同步下发订单成功24100117060832533235
2024-10-01 17:06:19 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-01 17:06:43 >>>回调事件[910,devices/D0361]
2024-10-01 17:06:43 >>>故障排除日志:上一MQTT订单号缓存列表为24100117060832533235
2024-10-01 17:06:43 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 17:06:43 开始打印,排队:233,票券:2410011706375827634201,订单:24100117063758272741,[2024-10-01 17:06:43微信支付10元]
2024-10-01 17:06:45 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011706375827634201","queue_number":233,"trade_uid":"24100117063758272741"}]}
2024-10-01 17:06:45 >>>故障排除日志:删除未同步下发订单成功24100117063758272741
2024-10-01 17:06:45 >>>故障排除日志:终端同步成功后剩余订单列表


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


===17:08:57===
2024-10-01 17:08:17 >>>回调事件[910,devices/D0361]
2024-10-01 17:08:17 >>>故障排除日志:上一MQTT订单号缓存列表为24100117072797595121
2024-10-01 17:08:17 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 17:08:17 开始打印,排队:235,票券:2410011708083400469401,订单:24100117080834000028,[2024-10-01 17:08:17微信支付10元]
2024-10-01 17:08:19 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011708083400469401","queue_number":235,"trade_uid":"24100117080834000028"}]}
2024-10-01 17:08:19 >>>故障排除日志:删除未同步下发订单成功24100117080834000028
2024-10-01 17:08:20 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-01 17:08:53 >>>回调事件[910,devices/D0361]
2024-10-01 17:08:53 >>>故障排除日志:上一MQTT订单号缓存列表为24100117080834000028
2024-10-01 17:08:53 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 17:08:53 开始打印,排队:236,票券:2410011708483811689701,订单:24100117084838112037,[2024-10-01 17:08:53微信支付10元]
2024-10-01 17:08:55 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011708483811689701","queue_number":236,"trade_uid":"24100117084838112037"}]}
2024-10-01 17:08:55 >>>故障排除日志:删除未同步下发订单成功24100117084838112037
2024-10-01 17:08:55 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


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


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


===17:32:01===
2024-10-01 17:31:05 >>>回调事件[910,devices/D0361]
2024-10-01 17:31:05 >>>故障排除日志:上一MQTT订单号缓存列表为24100117303195261617
2024-10-01 17:31:05 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 17:31:05 开始打印,排队:242,票券:2410011730599583727201,订单:24100117305995833469,[2024-10-01 17:31:05微信支付10元]
2024-10-01 17:31:07 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011730599583727201","queue_number":242,"trade_uid":"24100117305995833469"}]}
2024-10-01 17:31:07 >>>故障排除日志:删除未同步下发订单成功24100117305995833469
2024-10-01 17:31:07 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-01 17:31:29 >>>回调事件[910,devices/D0361]
2024-10-01 17:31:29 >>>故障排除日志:上一MQTT订单号缓存列表为24100117305995833469
2024-10-01 17:31:29 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 17:31:29 开始打印,排队:243,票券:2410011731246549363101,订单:24100117312465488982,[2024-10-01 17:31:28支付宝支付10元]
2024-10-01 17:31:31 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011731246549363101","queue_number":243,"trade_uid":"24100117312465488982"}]}
2024-10-01 17:31:31 >>>故障排除日志:删除未同步下发订单成功24100117312465488982
2024-10-01 17:31:31 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-01 17:31:54 >>>回调事件[910,devices/D0361]
2024-10-01 17:31:54 >>>故障排除日志:上一MQTT订单号缓存列表为24100117312465488982
2024-10-01 17:31:54 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 17:31:54 开始打印,排队:244,票券:2410011731474917085601,订单:24100117314749165813,[2024-10-01 17:31:53微信支付10元]
2024-10-01 17:31:54 开始打印,排队:245,票券:2410011731474917243502,订单:24100117314749165813,[2024-10-01 17:31:53微信支付10元]
2024-10-01 17:31:57 >>>回调事件[910,devices/D0361]
2024-10-01 17:31:57 >>>故障排除日志:上一MQTT订单号缓存列表为24100117314749165813|24100117314749165813
2024-10-01 17:31:57 >>>故障排除日志:终端未同步成功订单列表024424100117314749165813|024524100117314749165813
已接收过此消息,票券号为2410011731474917085601,排队号为244
已接收过此消息,票券号为2410011731474917243502,排队号为245
2024-10-01 17:31:57 开始打印,排队:246,票券:2410011731497985523501,订单:24100117314979851295,[2024-10-01 17:31:56支付宝支付10元]


===17:33:01===
2024-10-01 17:32:00 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011731474917085601","queue_number":244,"trade_uid":"24100117314749165813"},{"ticket_no":"2410011731474917243502","queue_number":245,"trade_uid":"24100117314749165813"},{"ticket_no":"2410011731497985523501","queue_number":246,"trade_uid":"24100117314979851295"}]}
2024-10-01 17:32:00 >>>故障排除日志:删除未同步下发订单成功24100117314979851295
2024-10-01 17:32:00 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-01 17:32:27 >>>回调事件[910,devices/D0361]
2024-10-01 17:32:27 >>>故障排除日志:上一MQTT订单号缓存列表为24100117314749165813|24100117314749165813|24100117314979851295
2024-10-01 17:32:27 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 17:32:27 开始打印,排队:247,票券:2410011732214461316501,订单:24100117322144608574,[2024-10-01 17:32:27微信支付10元]
2024-10-01 17:32:29 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011732214461316501","queue_number":247,"trade_uid":"24100117322144608574"}]}
2024-10-01 17:32:29 >>>故障排除日志:删除未同步下发订单成功24100117322144608574
2024-10-01 17:32:29 >>>故障排除日志:终端同步成功后剩余订单列表


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


===17:43:02===
2024-10-01 17:42:37 >>>回调事件[910,devices/D0361]
2024-10-01 17:42:37 >>>故障排除日志:上一MQTT订单号缓存列表为24100117350286693015
2024-10-01 17:42:37 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 17:42:37 开始打印,排队:249,票券:2410011742306470683101,订单:24100117423064702795,[2024-10-01 17:42:36微信支付10元]
2024-10-01 17:42:39 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011742306470683101","queue_number":249,"trade_uid":"24100117423064702795"}]}
2024-10-01 17:42:39 >>>故障排除日志:删除未同步下发订单成功24100117423064702795
2024-10-01 17:42:39 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-01 17:42:40 >>>回调事件[910,devices/D0361]
2024-10-01 17:42:40 >>>故障排除日志:上一MQTT订单号缓存列表为24100117423064702795
2024-10-01 17:42:40 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 17:42:40 开始打印,排队:250,票券:2410011742348206621801,订单:24100117423482060862,[2024-10-01 17:42:40微信支付10元]
2024-10-01 17:42:42 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011742348206621801","queue_number":250,"trade_uid":"24100117423482060862"}]}
2024-10-01 17:42:42 >>>故障排除日志:删除未同步下发订单成功24100117423482060862
2024-10-01 17:42:42 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-01 17:42:52 >>>回调事件[910,devices/D0361]
2024-10-01 17:42:52 >>>故障排除日志:上一MQTT订单号缓存列表为24100117423482060862
2024-10-01 17:42:52 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 17:42:52 开始打印,排队:251,票券:2410011742449077148201,订单:24100117424490764564,[2024-10-01 17:42:52微信支付10元]
2024-10-01 17:42:55 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011742449077148201","queue_number":251,"trade_uid":"24100117424490764564"}]}
2024-10-01 17:42:55 >>>故障排除日志:删除未同步下发订单成功24100117424490764564
2024-10-01 17:42:55 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


===17:57:03===
2024-10-01 17:56:10 >>>回调事件[910,devices/D0361]
2024-10-01 17:56:10 >>>故障排除日志:上一MQTT订单号缓存列表为24100117552767844152
2024-10-01 17:56:10 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 17:56:10 开始打印,排队:256,票券:2410011756036631652601,订单:24100117560366312486,[2024-10-01 17:56:10微信支付10元]
2024-10-01 17:56:12 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011756036631652601","queue_number":256,"trade_uid":"24100117560366312486"}]}
2024-10-01 17:56:12 >>>故障排除日志:删除未同步下发订单成功24100117560366312486
2024-10-01 17:56:12 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-01 17:56:40 >>>回调事件[910,devices/D0361]
2024-10-01 17:56:40 >>>故障排除日志:上一MQTT订单号缓存列表为24100117560366312486
2024-10-01 17:56:40 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 17:56:40 开始打印,排队:257,票券:2410011756358354257301,订单:24100117563583537778,[2024-10-01 17:56:40支付宝支付10元]
2024-10-01 17:56:42 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011756358354257301","queue_number":257,"trade_uid":"24100117563583537778"}]}
2024-10-01 17:56:42 >>>故障排除日志:删除未同步下发订单成功24100117563583537778
2024-10-01 17:56:42 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


===18:04:04===
2024-10-01 18:03:29 >>>回调事件[910,devices/D0361]
2024-10-01 18:03:29 >>>故障排除日志:上一MQTT订单号缓存列表为24100117592506934525
2024-10-01 18:03:29 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 18:03:29 开始打印,排队:260,票券:2410011803218485626201,订单:24100118032184852039,[2024-10-01 18:03:29微信支付10元]
2024-10-01 18:03:31 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011803218485626201","queue_number":260,"trade_uid":"24100118032184852039"}]}
2024-10-01 18:03:31 >>>故障排除日志:删除未同步下发订单成功24100118032184852039
2024-10-01 18:03:31 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-01 18:03:41 >>>回调事件[910,devices/D0361]
2024-10-01 18:03:41 >>>故障排除日志:上一MQTT订单号缓存列表为24100118032184852039
2024-10-01 18:03:41 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 18:03:41 开始打印,排队:261,票券:2410011803371262607601,订单:24100118033712620867,[2024-10-01 18:03:41支付宝支付10元]
2024-10-01 18:03:43 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011803371262607601","queue_number":261,"trade_uid":"24100118033712620867"}]}
2024-10-01 18:03:43 >>>故障排除日志:删除未同步下发订单成功24100118033712620867
2024-10-01 18:03:43 >>>故障排除日志:终端同步成功后剩余订单列表


===18:06:04===
2024-10-01 18:05:44 >>>回调事件[910,devices/D0361]
2024-10-01 18:05:44 >>>故障排除日志:上一MQTT订单号缓存列表为24100118033712620867
2024-10-01 18:05:44 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 18:05:44 开始打印,排队:262,票券:2410011805347102482801,订单:24100118053471019896,[2024-10-01 18:05:44支付宝支付10元]
2024-10-01 18:05:46 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011805347102482801","queue_number":262,"trade_uid":"24100118053471019896"}]}
2024-10-01 18:05:46 >>>故障排除日志:删除未同步下发订单成功24100118053471019896
2024-10-01 18:05:47 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


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


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


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


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


===18:39:06===
2024-10-01 18:38:11 >>>回调事件[910,devices/D0361]
2024-10-01 18:38:11 >>>故障排除日志:上一MQTT订单号缓存列表为24100118373247044345
2024-10-01 18:38:11 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 18:38:11 开始打印,排队:271,票券:2410011838064649166501,订单:24100118380646488015,[2024-10-01 18:38:11微信支付10元]
2024-10-01 18:38:13 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011838064649166501","queue_number":271,"trade_uid":"24100118380646488015"}]}
2024-10-01 18:38:13 >>>故障排除日志:删除未同步下发订单成功24100118380646488015
2024-10-01 18:38:13 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-01 18:38:49 >>>回调事件[910,devices/D0361]
2024-10-01 18:38:49 >>>故障排除日志:上一MQTT订单号缓存列表为24100118380646488015
2024-10-01 18:38:49 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 18:38:49 开始打印,排队:272,票券:2410011838436937933101,订单:24100118384369374854,[2024-10-01 18:38:49微信支付10元]
2024-10-01 18:38:51 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011838436937933101","queue_number":272,"trade_uid":"24100118384369374854"}]}
2024-10-01 18:38:51 >>>故障排除日志:删除未同步下发订单成功24100118384369374854
2024-10-01 18:38:51 >>>故障排除日志:终端同步成功后剩余订单列表


===18:40:08===
2024-10-01 18:39:34 >>>回调事件[910,devices/D0361]
2024-10-01 18:39:34 >>>故障排除日志:上一MQTT订单号缓存列表为24100118384369374854
2024-10-01 18:39:34 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 18:39:34 开始打印,排队:273,票券:2410011839264443152101,订单:24100118392644426873,[2024-10-01 18:39:33微信支付10元]
2024-10-01 18:39:36 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011839264443152101","queue_number":273,"trade_uid":"24100118392644426873"}]}
2024-10-01 18:39:36 >>>故障排除日志:删除未同步下发订单成功24100118392644426873
2024-10-01 18:39:36 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-01 18:40:03 >>>回调事件[910,devices/D0361]
2024-10-01 18:40:03 >>>故障排除日志:上一MQTT订单号缓存列表为24100118392644426873
2024-10-01 18:40:03 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 18:40:03 开始打印,排队:274,票券:2410011839550829358501,订单:24100118395508286275,[2024-10-01 18:40:02微信支付10元]
2024-10-01 18:40:03 开始打印,排队:275,票券:2410011839550829524702,订单:24100118395508286275,[2024-10-01 18:40:02微信支付10元]


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


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


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


===18:47:09===
2024-10-01 18:46:34 >>>回调事件[910,devices/D0361]
2024-10-01 18:46:34 >>>故障排除日志:上一MQTT订单号缓存列表为24100118434846957941
2024-10-01 18:46:34 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 18:46:34 开始打印,排队:279,票券:2410011846276215934101,订单:24100118462762155463,[2024-10-01 18:46:33微信支付10元]
2024-10-01 18:46:36 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011846276215934101","queue_number":279,"trade_uid":"24100118462762155463"}]}
2024-10-01 18:46:36 >>>故障排除日志:删除未同步下发订单成功24100118462762155463
2024-10-01 18:46:36 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-01 18:46:37 >>>回调事件[910,devices/D0361]
2024-10-01 18:46:37 >>>故障排除日志:上一MQTT订单号缓存列表为24100118462762155463
2024-10-01 18:46:37 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 18:46:37 开始打印,排队:280,票券:2410011846294256742301,订单:24100118462942563174,[2024-10-01 18:46:37微信支付10元]
2024-10-01 18:46:39 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011846294256742301","queue_number":280,"trade_uid":"24100118462942563174"}]}
2024-10-01 18:46:39 >>>故障排除日志:删除未同步下发订单成功24100118462942563174
2024-10-01 18:46:39 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-01 18:47:04 >>>回调事件[910,devices/D0361]
2024-10-01 18:47:04 >>>故障排除日志:上一MQTT订单号缓存列表为24100118462942563174
2024-10-01 18:47:04 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 18:47:04 开始打印,排队:281,票券:2410011846569039892401,订单:24100118465690394619,[2024-10-01 18:47:01支付宝支付10元]
2024-10-01 18:47:04 开始打印,排队:282,票券:2410011846569040035202,订单:24100118465690394619,[2024-10-01 18:47:01支付宝支付10元]


===18:49:09===
2024-10-01 18:48:54>>>cash read=00
2024-10-01 18:48:55>>>cash read=818F42
2024-10-01 18:48:55>>>cash write=02
2024-10-01 18:48:55 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-01 18:48:56>>>cash read=10
2024-10-01 18:48:56 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-01 18:48:56 当前产品价格10元，投币10元，打印小票中...
2024-10-01 18:48:56 >>>开始打印,排队号为283,订单号为2410011848560003611143
2024-10-01 18:48:56>>>订单2410011848560003611143写入成功,剩余空间为1680000,占用RAM为607.9248046875
删除未同步订单2410011848560003611143
2024-10-01 18:48:58>>>订单2410011848560003611143删除成功,剩余空间为1680500,占用RAM为622.1787109375
检测订单目录中>>>
无未同步订单>>>
2024-10-01 18:48:58 >>>当前Ram内存为590.5498046875
定时检测未同步订单启用
2024-10-01 18:48:59>>>cash write=0C
2024-10-01 18:48:59>>>cash read=3E
2024-10-01 18:49:04 >>>回调事件[910,devices/D0361]
2024-10-01 18:49:04 >>>故障排除日志:上一MQTT订单号缓存列表为24100118465690394619|24100118465690394619
2024-10-01 18:49:04 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 18:49:04 开始打印,排队:284,票券:2410011848565707872501,订单:24100118485657074072,[2024-10-01 18:49:04微信支付10元]
2024-10-01 18:49:06 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011848565707872501","queue_number":284,"trade_uid":"24100118485657074072"}]}
2024-10-01 18:49:06 >>>故障排除日志:删除未同步下发订单成功24100118485657074072
2024-10-01 18:49:06 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


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


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


===19:07:11===
2024-10-01 19:06:22 >>>回调事件[910,devices/D0361]
2024-10-01 19:06:22 >>>故障排除日志:上一MQTT订单号缓存列表为24100119022901248969
2024-10-01 19:06:22 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 19:06:22 开始打印,排队:290,票券:2410011906151902099101,订单:24100119061519017114,[2024-10-01 19:06:22微信支付10元]
2024-10-01 19:06:24 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011906151902099101","queue_number":290,"trade_uid":"24100119061519017114"}]}
2024-10-01 19:06:24 >>>故障排除日志:删除未同步下发订单成功24100119061519017114
2024-10-01 19:06:24 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-01 19:07:04 >>>回调事件[910,devices/D0361]
2024-10-01 19:07:04 >>>故障排除日志:上一MQTT订单号缓存列表为24100119061519017114
2024-10-01 19:07:04 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 19:07:04 开始打印,排队:291,票券:2410011906575809068701,订单:24100119065758085248,[2024-10-01 19:07:04微信支付10元]
2024-10-01 19:07:08 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011906575809068701","queue_number":291,"trade_uid":"24100119065758085248"}]}
2024-10-01 19:07:08 >>>故障排除日志:删除未同步下发订单成功24100119065758085248
2024-10-01 19:07:08 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


===19:12:13===
2024-10-01 19:11:21 >>>回调事件[910,devices/D0361]
2024-10-01 19:11:21 >>>故障排除日志:上一MQTT订单号缓存列表为24100119092313443941|24100119092313443941
2024-10-01 19:11:21 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 19:11:21 开始打印,排队:295,票券:2410011911139399054601,订单:24100119111393986189,[2024-10-01 19:11:21支付宝支付10元]
2024-10-01 19:11:21 开始打印,排队:296,票券:2410011911139399204702,订单:24100119111393986189,[2024-10-01 19:11:21支付宝支付10元]
2024-10-01 19:11:25 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011911139399054601","queue_number":295,"trade_uid":"24100119111393986189"},{"ticket_no":"2410011911139399204702","queue_number":296,"trade_uid":"24100119111393986189"}]}
2024-10-01 19:11:25 >>>故障排除日志:删除未同步下发订单成功24100119111393986189
2024-10-01 19:11:25 >>>故障排除日志:删除未同步下发订单成功24100119111393986189
2024-10-01 19:11:25 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


===19:19:14===
2024-10-01 19:18:13 >>>回调事件[910,devices/D0361]
2024-10-01 19:18:13 >>>故障排除日志:上一MQTT订单号缓存列表为24100119172345229553
2024-10-01 19:18:13 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 19:18:13 开始打印,排队:299,票券:2410011918075684007101,订单:24100119180756835783,[2024-10-01 19:18:13微信支付10元]
2024-10-01 19:18:15 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011918075684007101","queue_number":299,"trade_uid":"24100119180756835783"}]}
2024-10-01 19:18:15 >>>故障排除日志:删除未同步下发订单成功24100119180756835783
2024-10-01 19:18:15 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-01 19:18:55 >>>回调事件[910,devices/D0361]
2024-10-01 19:18:55 >>>故障排除日志:上一MQTT订单号缓存列表为24100119180756835783
2024-10-01 19:18:55 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 19:18:55 开始打印,排队:300,票券:2410011918497112675901,订单:24100119184971123221,[2024-10-01 19:18:55微信支付10元]
2024-10-01 19:18:57 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011918497112675901","queue_number":300,"trade_uid":"24100119184971123221"}]}
2024-10-01 19:18:57 >>>故障排除日志:删除未同步下发订单成功24100119184971123221
2024-10-01 19:18:57 >>>故障排除日志:终端同步成功后剩余订单列表


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


===19:21:15===
2024-10-01 19:20:36 >>>回调事件[910,devices/D0361]
2024-10-01 19:20:36 >>>故障排除日志:上一MQTT订单号缓存列表为24100119195775730161
2024-10-01 19:20:36 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 19:20:36 开始打印,排队:302,票券:2410011920297530114201,订单:24100119202975296696,[2024-10-01 19:20:36微信支付10元]
2024-10-01 19:20:36 开始打印,排队:303,票券:2410011920297530309602,订单:24100119202975296696,[2024-10-01 19:20:36微信支付10元]
2024-10-01 19:20:40 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011920297530114201","queue_number":302,"trade_uid":"24100119202975296696"},{"ticket_no":"2410011920297530309602","queue_number":303,"trade_uid":"24100119202975296696"}]}
2024-10-01 19:20:40 >>>故障排除日志:删除未同步下发订单成功24100119202975296696
2024-10-01 19:20:40 >>>故障排除日志:删除未同步下发订单成功24100119202975296696
2024-10-01 19:20:40 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-01 19:20:47 >>>回调事件[910,devices/D0361]
2024-10-01 19:20:47 >>>故障排除日志:上一MQTT订单号缓存列表为24100119202975296696|24100119202975296696
2024-10-01 19:20:47 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 19:20:47 开始打印,排队:304,票券:2410011920393559689701,订单:24100119203935591397,[2024-10-01 19:20:47微信支付10元]
2024-10-01 19:20:49 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011920393559689701","queue_number":304,"trade_uid":"24100119203935591397"}]}
2024-10-01 19:20:49 >>>故障排除日志:删除未同步下发订单成功24100119203935591397
2024-10-01 19:20:49 >>>故障排除日志:终端同步成功后剩余订单列表


===19:24:17===
2024-10-01 19:23:18 >>>回调事件[910,devices/D0361]
2024-10-01 19:23:19 >>>故障排除日志:上一MQTT订单号缓存列表为24100119203935591397
2024-10-01 19:23:19 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 19:23:19 开始打印,排队:305,票券:2410011923122498168901,订单:24100119231224976018,[2024-10-01 19:23:18支付宝支付10元]
2024-10-01 19:23:19 开始打印,排队:306,票券:2410011923122498379302,订单:24100119231224976018,[2024-10-01 19:23:18支付宝支付10元]
2024-10-01 19:23:22 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011923122498168901","queue_number":305,"trade_uid":"24100119231224976018"},{"ticket_no":"2410011923122498379302","queue_number":306,"trade_uid":"24100119231224976018"}]}
2024-10-01 19:23:22 >>>故障排除日志:删除未同步下发订单成功24100119231224976018
2024-10-01 19:23:22 >>>故障排除日志:删除未同步下发订单成功24100119231224976018
2024-10-01 19:23:23 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-01 19:24:14 >>>回调事件[910,devices/D0361]
2024-10-01 19:24:14 >>>故障排除日志:上一MQTT订单号缓存列表为24100119231224976018|24100119231224976018
2024-10-01 19:24:14 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 19:24:14 开始打印,排队:307,票券:2410011924064542371301,订单:24100119240645418978,[2024-10-01 19:24:13支付宝支付10元]


===19:25:17===
2024-10-01 19:24:16 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011924064542371301","queue_number":307,"trade_uid":"24100119240645418978"}]}
2024-10-01 19:24:16 >>>故障排除日志:删除未同步下发订单成功24100119240645418978
2024-10-01 19:24:16 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-01 19:24:49 >>>回调事件[910,devices/D0361]
2024-10-01 19:24:49 >>>故障排除日志:上一MQTT订单号缓存列表为24100119240645418978
2024-10-01 19:24:49 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 19:24:49 开始打印,排队:308,票券:2410011924429758729101,订单:24100119244297581135,[2024-10-01 19:24:48微信支付10元]
2024-10-01 19:24:49 开始打印,排队:309,票券:2410011924429758924702,订单:24100119244297581135,[2024-10-01 19:24:48微信支付10元]
2024-10-01 19:24:54 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011924429758729101","queue_number":308,"trade_uid":"24100119244297581135"},{"ticket_no":"2410011924429758924702","queue_number":309,"trade_uid":"24100119244297581135"}]}
2024-10-01 19:24:54 >>>故障排除日志:删除未同步下发订单成功24100119244297581135
2024-10-01 19:24:54 >>>故障排除日志:删除未同步下发订单成功24100119244297581135
2024-10-01 19:24:54 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-01 19:24:58 >>>回调事件[910,devices/D0361]
2024-10-01 19:24:58 >>>故障排除日志:上一MQTT订单号缓存列表为24100119244297581135|24100119244297581135
2024-10-01 19:24:58 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 19:24:58 开始打印,排队:310,票券:2410011924540923007601,订单:24100119245409226872,[2024-10-01 19:24:58微信支付10元]
2024-10-01 19:25:00 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011924540923007601","queue_number":310,"trade_uid":"24100119245409226872"}]}
2024-10-01 19:25:00 >>>故障排除日志:删除未同步下发订单成功24100119245409226872
2024-10-01 19:25:01 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


===19:34:18===
2024-10-01 19:34:09>>>cash read=0A
2024-10-01 19:34:10>>>cash read=3E


===19:35:19===
2024-10-01 19:34:50 >>>回调事件[910,devices/D0361]
2024-10-01 19:34:50 >>>故障排除日志:上一MQTT订单号缓存列表为24100119303679141932
2024-10-01 19:34:50 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 19:34:50 开始打印,排队:313,票券:2410011934364012835601,订单:24100119343640124639,[2024-10-01 19:34:50微信支付10元]
2024-10-01 19:34:53 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011934364012835601","queue_number":313,"trade_uid":"24100119343640124639"}]}
2024-10-01 19:34:53 >>>故障排除日志:删除未同步下发订单成功24100119343640124639
2024-10-01 19:34:53 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-01 19:35:13 >>>回调事件[910,devices/D0361]
2024-10-01 19:35:13 >>>故障排除日志:上一MQTT订单号缓存列表为24100119343640124639
2024-10-01 19:35:13 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 19:35:13 开始打印,排队:314,票券:2410011935070177428301,订单:24100119350701769915,[2024-10-01 19:35:12微信支付10元]
2024-10-01 19:35:13 开始打印,排队:315,票券:2410011935070177563402,订单:24100119350701769915,[2024-10-01 19:35:12微信支付10元]
2024-10-01 19:35:16 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011935070177428301","queue_number":314,"trade_uid":"24100119350701769915"},{"ticket_no":"2410011935070177563402","queue_number":315,"trade_uid":"24100119350701769915"}]}
2024-10-01 19:35:17 >>>故障排除日志:删除未同步下发订单成功24100119350701769915
2024-10-01 19:35:17 >>>故障排除日志:删除未同步下发订单成功24100119350701769915
2024-10-01 19:35:17 >>>故障排除日志:终端同步成功后剩余订单列表


===19:40:21===
2024-10-01 19:39:56 >>>回调事件[910,devices/D0361]
2024-10-01 19:39:56 >>>故障排除日志:上一MQTT订单号缓存列表为24100119350701769915|24100119350701769915
2024-10-01 19:39:56 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 19:39:56 开始打印,排队:316,票券:2410011939484415496301,订单:24100119394844150289,[2024-10-01 19:39:55微信支付10元]
2024-10-01 19:39:56 开始打印,排队:317,票券:2410011939484415677902,订单:24100119394844150289,[2024-10-01 19:39:55微信支付10元]
2024-10-01 19:39:56 开始打印,排队:318,票券:2410011939484415772803,订单:24100119394844150289,[2024-10-01 19:39:55微信支付10元]
2024-10-01 19:40:01 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011939484415496301","queue_number":316,"trade_uid":"24100119394844150289"},{"ticket_no":"2410011939484415677902","queue_number":317,"trade_uid":"24100119394844150289"},{"ticket_no":"2410011939484415772803","queue_number":318,"trade_uid":"24100119394844150289"}]}
2024-10-01 19:40:01 >>>故障排除日志:删除未同步下发订单成功24100119394844150289
2024-10-01 19:40:01 >>>故障排除日志:删除未同步下发订单成功24100119394844150289
2024-10-01 19:40:01 >>>故障排除日志:删除未同步下发订单成功24100119394844150289
2024-10-01 19:40:01 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-01 19:40:17 >>>回调事件[910,devices/D0361]
2024-10-01 19:40:17 >>>故障排除日志:上一MQTT订单号缓存列表为24100119394844150289|24100119394844150289|24100119394844150289
2024-10-01 19:40:17 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 19:40:17 开始打印,排队:319,票券:2410011940115175525901,订单:24100119401151751782,[2024-10-01 19:40:17支付宝支付10元]


===19:41:21===
2024-10-01 19:40:19 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011940115175525901","queue_number":319,"trade_uid":"24100119401151751782"}]}
2024-10-01 19:40:19 >>>故障排除日志:删除未同步下发订单成功24100119401151751782
2024-10-01 19:40:19 >>>故障排除日志:终端同步成功后剩余订单列表


===19:42:21===
2024-10-01 19:41:51 >>>回调事件[910,devices/D0361]
2024-10-01 19:41:51 >>>故障排除日志:上一MQTT订单号缓存列表为24100119401151751782
2024-10-01 19:41:51 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 19:41:51 开始打印,排队:320,票券:2410011941437112225701,订单:24100119414371117534,[2024-10-01 19:41:51微信支付10元]
2024-10-01 19:41:53 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011941437112225701","queue_number":320,"trade_uid":"24100119414371117534"}]}
2024-10-01 19:41:53 >>>故障排除日志:删除未同步下发订单成功24100119414371117534
2024-10-01 19:41:53 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-01 19:42:03 >>>回调事件[910,devices/D0361]
2024-10-01 19:42:03 >>>故障排除日志:上一MQTT订单号缓存列表为24100119414371117534
2024-10-01 19:42:03 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 19:42:03 开始打印,排队:321,票券:2410011941580042684501,订单:24100119415800422657,[2024-10-01 19:42:03支付宝支付10元]
2024-10-01 19:42:05 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011941580042684501","queue_number":321,"trade_uid":"24100119415800422657"}]}
2024-10-01 19:42:05 >>>故障排除日志:删除未同步下发订单成功24100119415800422657
2024-10-01 19:42:05 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


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


===19:59:23===
2024-10-01 19:58:43 >>>回调事件[910,devices/D0361]
2024-10-01 19:58:43 >>>故障排除日志:上一MQTT订单号缓存列表为24100119565048169759
2024-10-01 19:58:43 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 19:58:43 开始打印,排队:328,票券:2410011958379675446201,订单:24100119583796749865,[2024-10-01 19:58:43微信支付10元]
2024-10-01 19:58:45 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011958379675446201","queue_number":328,"trade_uid":"24100119583796749865"}]}
2024-10-01 19:58:45 >>>故障排除日志:删除未同步下发订单成功24100119583796749865
2024-10-01 19:58:45 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-01 19:59:13 >>>回调事件[910,devices/D0361]
2024-10-01 19:59:14 >>>故障排除日志:上一MQTT订单号缓存列表为24100119583796749865
2024-10-01 19:59:14 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 19:59:14 开始打印,排队:329,票券:2410011959085119307201,订单:24100119590851189586,[2024-10-01 19:59:14微信支付10元]
2024-10-01 19:59:16 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011959085119307201","queue_number":329,"trade_uid":"24100119590851189586"}]}
2024-10-01 19:59:16 >>>故障排除日志:删除未同步下发订单成功24100119590851189586
2024-10-01 19:59:16 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


===20:08:27===
2024-10-01 20:08:22 >>>回调事件[910,devices/D0361]
2024-10-01 20:08:22 >>>故障排除日志:上一MQTT订单号缓存列表为24100120052537400385
2024-10-01 20:08:22 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 20:08:22 开始打印,排队:334,票券:2410012008182147704301,订单:24100120081821472524,[2024-10-01 20:08:23微信支付10元]


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


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


===20:14:27===
2024-10-01 20:13:41 >>>回调事件[910,devices/D0361]
2024-10-01 20:13:41 >>>故障排除日志:上一MQTT订单号缓存列表为24100120124874628757
2024-10-01 20:13:41 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 20:13:41 开始打印,排队:337,票券:2410012013300767821501,订单:24100120133007673623,[2024-10-01 20:13:41微信支付10元]
2024-10-01 20:13:41 开始打印,排队:338,票券:2410012013300767962502,订单:24100120133007673623,[2024-10-01 20:13:41微信支付10元]
2024-10-01 20:13:45 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410012013300767821501","queue_number":337,"trade_uid":"24100120133007673623"},{"ticket_no":"2410012013300767962502","queue_number":338,"trade_uid":"24100120133007673623"}]}
2024-10-01 20:13:45 >>>故障排除日志:删除未同步下发订单成功24100120133007673623
2024-10-01 20:13:45 >>>故障排除日志:删除未同步下发订单成功24100120133007673623
2024-10-01 20:13:45 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


===20:30:28===
2024-10-01 20:29:39 >>>回调事件[910,devices/D0361]
2024-10-01 20:29:39 >>>故障排除日志:上一MQTT订单号缓存列表为24100120200159843696
2024-10-01 20:29:39 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 20:29:39 开始打印,排队:341,票券:2410012029335171564901,订单:24100120293351712051,[2024-10-01 20:29:39微信支付10元]
2024-10-01 20:29:39 开始打印,排队:342,票券:2410012029335171711902,订单:24100120293351712051,[2024-10-01 20:29:39微信支付10元]
2024-10-01 20:29:42 >>>回调事件[910,devices/D0361]
2024-10-01 20:29:42 >>>故障排除日志:上一MQTT订单号缓存列表为24100120293351712051|24100120293351712051
2024-10-01 20:29:42 >>>故障排除日志:终端未同步成功订单列表034124100120293351712051|034224100120293351712051
已接收过此消息,票券号为2410012029335171564901,排队号为341
已接收过此消息,票券号为2410012029335171711902,排队号为342
2024-10-01 20:29:42 开始打印,排队:343,票券:2410012029365336685201,订单:24100120293653363082,[2024-10-01 20:29:41微信支付10元]
2024-10-01 20:29:44 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410012029335171564901","queue_number":341,"trade_uid":"24100120293351712051"},{"ticket_no":"2410012029335171711902","queue_number":342,"trade_uid":"24100120293351712051"}]}
2024-10-01 20:29:44 >>>故障排除日志:删除未同步下发订单成功24100120293351712051
2024-10-01 20:29:44 >>>故障排除日志:删除未同步下发订单成功24100120293351712051
2024-10-01 20:29:44 >>>故障排除日志:终端同步成功后剩余订单列表034324100120293653363082
2024-10-01 20:29:44 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410012029335171564901","queue_number":341,"trade_uid":"24100120293351712051"},{"ticket_no":"2410012029335171711902","queue_number":342,"trade_uid":"24100120293351712051"},{"ticket_no":"2410012029365336685201","queue_number":343,"trade_uid":"24100120293653363082"}]}
2024-10-01 20:29:44 >>>故障排除日志:删除未同步下发订单成功24100120293653363082
2024-10-01 20:29:45 >>>故障排除日志:终端同步成功后剩余订单列表


===20:35:29===
2024-10-01 20:34:54 >>>回调事件[910,devices/D0361]
2024-10-01 20:34:54 >>>故障排除日志:上一MQTT订单号缓存列表为24100120293351712051|24100120293351712051|24100120293653363082
2024-10-01 20:34:54 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 20:34:54 开始打印,排队:344,票券:2410012034482437201601,订单:24100120344824367587,[2024-10-01 20:34:54支付宝支付10元]
2024-10-01 20:34:56 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410012034482437201601","queue_number":344,"trade_uid":"24100120344824367587"}]}
2024-10-01 20:34:56 >>>故障排除日志:删除未同步下发订单成功24100120344824367587
2024-10-01 20:34:56 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


===20:39:30===
2024-10-01 20:39:14>>>cash read=00
2024-10-01 20:39:14>>>cash read=818F42
2024-10-01 20:39:14>>>cash write=02
2024-10-01 20:39:14 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-01 20:39:15>>>cash read=10
2024-10-01 20:39:15 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-01 20:39:15 当前产品价格10元，投币10元，打印小票中...
2024-10-01 20:39:15 >>>开始打印,排队号为347,订单号为2410012039150003611265
2024-10-01 20:39:15>>>订单2410012039150003611265写入成功,剩余空间为1680000,占用RAM为607.1396484375
删除未同步订单2410012039150003611265
2024-10-01 20:39:17>>>订单2410012039150003611265删除成功,剩余空间为1680500,占用RAM为619.4443359375
检测订单目录中>>>
无未同步订单>>>
2024-10-01 20:39:17 >>>当前Ram内存为589.8388671875
定时检测未同步订单启用
2024-10-01 20:39:18>>>cash write=0C
2024-10-01 20:39:18>>>cash read=3E


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


===20:44:30===
2024-10-01 20:43:54 >>>回调事件[910,devices/D0361]
2024-10-01 20:43:54 >>>故障排除日志:上一MQTT订单号缓存列表为24100120372759398648
2024-10-01 20:43:54 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 20:43:54 开始打印,排队:348,票券:2410012043488570697901,订单:24100120434885703542,[2024-10-01 20:43:54微信支付10元]
2024-10-01 20:43:54 开始打印,排队:349,票券:2410012043488570819302,订单:24100120434885703542,[2024-10-01 20:43:54微信支付10元]
2024-10-01 20:43:58 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410012043488570697901","queue_number":348,"trade_uid":"24100120434885703542"},{"ticket_no":"2410012043488570819302","queue_number":349,"trade_uid":"24100120434885703542"}]}
2024-10-01 20:43:58 >>>故障排除日志:删除未同步下发订单成功24100120434885703542
2024-10-01 20:43:58 >>>故障排除日志:删除未同步下发订单成功24100120434885703542
2024-10-01 20:43:58 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


===20:52:31===
2024-10-01 20:51:57>>>cash read=00
2024-10-01 20:51:58>>>cash read=2F29
2024-10-01 20:52:00>>>cash read=3E
2024-10-01 20:52:04>>>cash read=00
2024-10-01 20:52:05>>>cash read=01
2024-10-01 20:52:07>>>cash read=3E
2024-10-01 20:52:10>>>cash read=00
2024-10-01 20:52:11>>>cash read=01
2024-10-01 20:52:13>>>cash read=3E
2024-10-01 20:52:16>>>cash read=00
2024-10-01 20:52:16>>>cash read=818F42
2024-10-01 20:52:16>>>cash write=02
2024-10-01 20:52:16 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-01 20:52:17>>>cash read=10
2024-10-01 20:52:17 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-01 20:52:17 当前产品价格10元，投币10元，打印小票中...
2024-10-01 20:52:17 >>>开始打印,排队号为353,订单号为2410012052170003618440
2024-10-01 20:52:17>>>订单2410012052170003618440写入成功,剩余空间为1679500,占用RAM为609.2177734375
删除未同步订单2410012052170003618440
2024-10-01 20:52:19>>>订单2410012052170003618440删除成功,剩余空间为1680500,占用RAM为618.984375
检测订单目录中>>>
无未同步订单>>>
2024-10-01 20:52:19 >>>当前Ram内存为590.4130859375
定时检测未同步订单启用
2024-10-01 20:52:20>>>cash write=0C
2024-10-01 20:52:20>>>cash read=3E


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


===20:59:32===
2024-10-01 20:58:57 >>>回调事件[910,devices/D0361]
2024-10-01 20:58:57 >>>故障排除日志:上一MQTT订单号缓存列表为24100120491165512664
2024-10-01 20:58:57 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 20:58:57 开始打印,排队:354,票券:2410012058492662966701,订单:24100120584926624959,[2024-10-01 20:58:57微信支付10元]
2024-10-01 20:58:59 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410012058492662966701","queue_number":354,"trade_uid":"24100120584926624959"}]}
2024-10-01 20:59:00 >>>故障排除日志:删除未同步下发订单成功24100120584926624959
2024-10-01 20:59:00 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-01 20:59:02 >>>回调事件[910,devices/D0361]
2024-10-01 20:59:02 >>>故障排除日志:上一MQTT订单号缓存列表为24100120584926624959
2024-10-01 20:59:02 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 20:59:02 开始打印,排队:355,票券:2410012058561165606201,订单:24100120585611646714,[2024-10-01 20:59:02微信支付10元]
2024-10-01 20:59:02 开始打印,排队:356,票券:2410012058561165814702,订单:24100120585611646714,[2024-10-01 20:59:02微信支付10元]
2024-10-01 20:59:06 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410012058561165606201","queue_number":355,"trade_uid":"24100120585611646714"},{"ticket_no":"2410012058561165814702","queue_number":356,"trade_uid":"24100120585611646714"}]}
2024-10-01 20:59:06 >>>故障排除日志:删除未同步下发订单成功24100120585611646714
2024-10-01 20:59:06 >>>故障排除日志:删除未同步下发订单成功24100120585611646714
2024-10-01 20:59:06 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


===21:24:35===
2024-10-01 21:24:06 >>>回调事件[910,devices/D0361]
2024-10-01 21:24:06 >>>故障排除日志:上一MQTT订单号缓存列表为24100121051109982197
2024-10-01 21:24:06 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 21:24:06 开始打印,排队:359,票券:2410012124005487061801,订单:24100121240054864697,[2024-10-01 21:24:06微信支付10元]
2024-10-01 21:24:08 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410012124005487061801","queue_number":359,"trade_uid":"24100121240054864697"}]}
2024-10-01 21:24:09 >>>故障排除日志:删除未同步下发订单成功24100121240054864697
2024-10-01 21:24:09 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-01 21:24:29 >>>回调事件[910,devices/D0361]
2024-10-01 21:24:29 >>>故障排除日志:上一MQTT订单号缓存列表为24100121240054864697
2024-10-01 21:24:30 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 21:24:30 开始打印,排队:360,票券:2410012124253846342401,订单:24100121242538457662,[2024-10-01 21:24:29微信支付10元]
2024-10-01 21:24:31 >>>回调事件[910,devices/D0361]
2024-10-01 21:24:31 >>>故障排除日志:上一MQTT订单号缓存列表为24100121242538457662
2024-10-01 21:24:32 >>>故障排除日志:终端未同步成功订单列表036024100121242538457662
已接收过此消息,票券号为2410012124253846342401,排队号为360
2024-10-01 21:24:32 开始打印,排队:361,票券:2410012124268877467901,订单:24100121242688771236,[2024-10-01 21:24:32微信支付10元]


===21:25:35===
2024-10-01 21:24:34 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410012124253846342401","queue_number":360,"trade_uid":"24100121242538457662"},{"ticket_no":"2410012124268877467901","queue_number":361,"trade_uid":"24100121242688771236"}]}
2024-10-01 21:24:34 >>>故障排除日志:删除未同步下发订单成功24100121242688771236
2024-10-01 21:24:34 >>>故障排除日志:终端同步成功后剩余订单列表


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