TLClient_JSSCOM_LuatOS-Air_V4010_RDA8910_RFTTS_0xe0000,2.8.6,863013071799349,59690828994701,
poweron reason:0

===08:54:14===
上一时间戳为1777078677
隔日重置时间戳true
隔日清空未同步下发列表true
当前排队号为706,音量为5
初始化产品信息:[{"time_limit_date":null,"ticket_category":"0","expiry_date":90,"product_detail":"","time_limit_status":"0","begin_minute":null,"product_uid":"4280874159397018332","use_timer":1,"old_price":"12","end_hour":null,"sale_price":"12","end_minute":null,"begin_hour":null,"sale_status":1,"product_name":"剪发"}]
是否打印二维码设置为0
是否打印紧凑设置为7
当前号显示模式设置为1
当前卡项核销权限设置为0
session_id:904dd****60687
纸币器设置接收纸币范围为36
欢迎使用天羚自助售票系统[2.8.6]
定时检测未同步订单启用[checkOrderNum=536870969]
2026-04-26 08:53:13>>>cash write=30
2026-04-26 08:53:13>>>cash write=02
2026-04-26 08:53:13>>>cash write=3E
2026-04-26 08:53:13>>>cash read=808F808F
系统时间初始化成功，时间为202642685313
2026-04-26 08:53:14>>>cash write=02
2026-04-26 08:53:14>>>cash read=808F3E
2026-04-26 08:53:14 >>>剩余flash空间=1680000,占用RAM为653.115234375
2026-04-26 08:53:14 >>>回调事件:910,subscribe,10000,连接服务器成功

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

2026-04-26 08:53:16>>>cash write=0C
流量卡还有126天过期
2026-04-26 08:53:25 >>>当前Ram内存为672.591796875
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 08:53:32 >>>回调事件[910,devices/TL4654]
当日首次设置时间戳true为1777164812
2026-04-26 08:53:32 >>>故障排除日志:上一MQTT订单号缓存列表为2604252153470061607828
2026-04-26 08:53:32 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 08:53:32 开始打印,排队:706,票券:2604260853270088807501,订单:2604260853260097920773,[2026-04-26 08:53:32微信支付12元]
2026-04-26 08:53:32>>>MQTT票号同步场景，创建空订单对象
2026-04-26 08:53:32>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 08:53:34 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604260853270088807501","queue_number":706,"trade_uid":"2604260853260097920773"}]}
2026-04-26 08:53:34 >>>故障排除日志:删除未同步下发订单成功2604260853260097920773
2026-04-26 08:53:34 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536870989]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 08:53:58 >>>回调事件[910,devices/TL4654]
2026-04-26 08:53:58 >>>故障排除日志:上一MQTT订单号缓存列表为2604260853260097920773
2026-04-26 08:53:58 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 08:53:58 开始打印,排队:707,票券:2604260853468686187501,订单:2604260853460085146298,[2026-04-26 08:53:58微信支付12元]
2026-04-26 08:53:58>>>MQTT票号同步场景，创建空订单对象
2026-04-26 08:53:59>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 08:54:00 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604260853468686187501","queue_number":707,"trade_uid":"2604260853460085146298"}]}
2026-04-26 08:54:00 >>>故障排除日志:删除未同步下发订单成功2604260853460085146298
2026-04-26 08:54:01 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536870997]


===09:04:14===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 09:03:18 >>>回调事件[910,devices/TL4654]
2026-04-26 09:03:18 >>>故障排除日志:上一MQTT订单号缓存列表为2604260853460085146298
2026-04-26 09:03:18 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 09:03:18 开始打印,排队:708,票券:2604260903129159547601,订单:2604260903120089835551,[2026-04-26 09:03:18微信支付12元]
2026-04-26 09:03:18>>>MQTT票号同步场景，创建空订单对象
2026-04-26 09:03:18>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 09:03:20 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604260903129159547601","queue_number":708,"trade_uid":"2604260903120089835551"}]}
2026-04-26 09:03:20 >>>故障排除日志:删除未同步下发订单成功2604260903120089835551
2026-04-26 09:03:20 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536871093]


===09:08:14===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 09:07:25 >>>回调事件[910,devices/TL4654]
2026-04-26 09:07:25 >>>故障排除日志:上一MQTT订单号缓存列表为2604260903120089835551
2026-04-26 09:07:25 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 09:07:25 开始打印,排队:709,票券:2604260907160021439801,订单:2604260907150098328342,[2026-04-26 09:07:25微信支付12元]
2026-04-26 09:07:25>>>MQTT票号同步场景，创建空订单对象
2026-04-26 09:07:25>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 09:07:27 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604260907160021439801","queue_number":709,"trade_uid":"2604260907150098328342"}]}
2026-04-26 09:07:27 >>>故障排除日志:删除未同步下发订单成功2604260907150098328342
2026-04-26 09:07:27 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536871137]


===09:14:15===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 09:13:29 >>>回调事件[910,devices/TL4654]
2026-04-26 09:13:29 >>>故障排除日志:上一MQTT订单号缓存列表为2604260907150098328342
2026-04-26 09:13:29 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 09:13:29 开始打印,排队:710,票券:2604260913194702116801,订单:2604260913190045205057,[2026-04-26 09:13:28微信支付12元]
2026-04-26 09:13:29>>>MQTT票号同步场景，创建空订单对象
2026-04-26 09:13:29>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 09:13:31 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604260913194702116801","queue_number":710,"trade_uid":"2604260913190045205057"}]}
2026-04-26 09:13:31 >>>故障排除日志:删除未同步下发订单成功2604260913190045205057
2026-04-26 09:13:31 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536871199]


===09:20:15===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 09:19:15 >>>回调事件[910,devices/TL4654]
2026-04-26 09:19:15 >>>故障排除日志:上一MQTT订单号缓存列表为2604260913190045205057
2026-04-26 09:19:15 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 09:19:15 开始打印,排队:711,票券:2604260919077604054901,订单:2604260919070074204091,[2026-04-26 09:19:15微信支付12元]
2026-04-26 09:19:15>>>MQTT票号同步场景，创建空订单对象
2026-04-26 09:19:15>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 09:19:17 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604260919077604054901","queue_number":711,"trade_uid":"2604260919070074204091"}]}
2026-04-26 09:19:17 >>>故障排除日志:删除未同步下发订单成功2604260919070074204091
2026-04-26 09:19:17 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536871260]


===09:21:15===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 09:20:28 >>>回调事件[910,devices/TL4654]
2026-04-26 09:20:28 >>>故障排除日志:上一MQTT订单号缓存列表为2604260919070074204091
2026-04-26 09:20:28 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 09:20:28 开始打印,排队:712,票券:2604260920189815303501,订单:2604260920180096131123,[2026-04-26 09:20:28微信支付12元]
2026-04-26 09:20:28>>>MQTT票号同步场景，创建空订单对象
2026-04-26 09:20:28>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 09:20:30 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604260920189815303501","queue_number":712,"trade_uid":"2604260920180096131123"}]}
2026-04-26 09:20:30 >>>故障排除日志:删除未同步下发订单成功2604260920180096131123
2026-04-26 09:20:30 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536871278]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 09:20:56 >>>回调事件[910,devices/TL4654]
2026-04-26 09:20:56 >>>故障排除日志:上一MQTT订单号缓存列表为2604260920180096131123
2026-04-26 09:20:56 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 09:20:56 开始打印,排队:713,票券:2604260920478779538101,订单:2604260920470085909724,[2026-04-26 09:20:56微信支付12元]
2026-04-26 09:20:56>>>MQTT票号同步场景，创建空订单对象
2026-04-26 09:20:56>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 09:20:58 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604260920478779538101","queue_number":713,"trade_uid":"2604260920470085909724"}]}
2026-04-26 09:20:58 >>>故障排除日志:删除未同步下发订单成功2604260920470085909724
2026-04-26 09:20:58 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536871285]


===09:22:16===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 09:21:32 >>>回调事件[910,devices/TL4654]
2026-04-26 09:21:32 >>>故障排除日志:上一MQTT订单号缓存列表为2604260920470085909724
2026-04-26 09:21:32 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 09:21:32 开始打印,排队:714,票券:2604260921253805425201,订单:2604260921250036333457,[2026-04-26 09:21:32微信支付12元]
2026-04-26 09:21:32>>>MQTT票号同步场景，创建空订单对象
2026-04-26 09:21:32>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 09:21:34 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604260921253805425201","queue_number":714,"trade_uid":"2604260921250036333457"}]}
2026-04-26 09:21:34 >>>故障排除日志:删除未同步下发订单成功2604260921250036333457
2026-04-26 09:21:34 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536871301]


===09:24:16===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 09:24:09 >>>回调事件[910,devices/TL4654]
2026-04-26 09:24:09 >>>故障排除日志:上一MQTT订单号缓存列表为2604260921250036333457
2026-04-26 09:24:09 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 09:24:09 开始打印,排队:715,票券:2604260924022644077401,订单:2604260924020024438847,[2026-04-26 09:24:09微信支付12元]
2026-04-26 09:24:09>>>MQTT票号同步场景，创建空订单对象
2026-04-26 09:24:09>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 09:24:11 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604260924022644077401","queue_number":715,"trade_uid":"2604260924020024438847"}]}
2026-04-26 09:24:11 >>>故障排除日志:删除未同步下发订单成功2604260924020024438847
2026-04-26 09:24:11 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536871335]


===09:36:16===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 09:35:26 >>>回调事件[910,devices/TL4654]
2026-04-26 09:35:26 >>>故障排除日志:上一MQTT订单号缓存列表为2604260924020024438847
2026-04-26 09:35:26 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 09:35:26 开始打印,排队:716,票券:2604260935150383355101,订单:2604260935150001240459,[2026-04-26 09:35:26微信支付12元]
2026-04-26 09:35:26>>>MQTT票号同步场景，创建空订单对象
2026-04-26 09:35:26>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 09:35:28 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604260935150383355101","queue_number":716,"trade_uid":"2604260935150001240459"}]}
2026-04-26 09:35:28 >>>故障排除日志:删除未同步下发订单成功2604260935150001240459
2026-04-26 09:35:28 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536871443]


===09:37:16===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 09:36:38 >>>回调事件[910,devices/TL4654]
2026-04-26 09:36:38 >>>故障排除日志:上一MQTT订单号缓存列表为2604260935150001240459
2026-04-26 09:36:38 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 09:36:38 开始打印,排队:717,票券:2604260936297149233401,订单:2604260936290069497283,[2026-04-26 09:36:38微信支付12元]
2026-04-26 09:36:38>>>MQTT票号同步场景，创建空订单对象
2026-04-26 09:36:38>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 09:36:40 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604260936297149233401","queue_number":717,"trade_uid":"2604260936290069497283"}]}
2026-04-26 09:36:40 >>>故障排除日志:删除未同步下发订单成功2604260936290069497283
2026-04-26 09:36:40 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536871460]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 09:36:56 >>>回调事件[910,devices/TL4654]
2026-04-26 09:36:56 >>>故障排除日志:上一MQTT订单号缓存列表为2604260936290069497283
2026-04-26 09:36:56 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 09:36:56 开始打印,排队:718,票券:2604260936478974004301,订单:2604260936470087908178,[2026-04-26 09:36:55微信支付12元]
2026-04-26 09:36:56>>>MQTT票号同步场景，创建空订单对象
2026-04-26 09:36:56>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 09:36:58 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604260936478974004301","queue_number":718,"trade_uid":"2604260936470087908178"}]}
2026-04-26 09:36:58 >>>故障排除日志:删除未同步下发订单成功2604260936470087908178
2026-04-26 09:36:58 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536871467]


===09:40:17===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 09:39:58 >>>回调事件[910,devices/TL4654]
2026-04-26 09:39:58 >>>故障排除日志:上一MQTT订单号缓存列表为2604260936470087908178
2026-04-26 09:39:58 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 09:39:58 开始打印,排队:719,票券:2604260939490723574101,订单:2604260939490005280654,[2026-04-26 09:39:58微信支付12元]
2026-04-26 09:39:58>>>MQTT票号同步场景，创建空订单对象
2026-04-26 09:39:58>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 09:40:00 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604260939490723574101","queue_number":719,"trade_uid":"2604260939490005280654"}]}
2026-04-26 09:40:00 >>>故障排除日志:删除未同步下发订单成功2604260939490005280654
2026-04-26 09:40:00 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536871502]


===09:43:17===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 09:43:12 >>>回调事件[910,devices/TL4654]
2026-04-26 09:43:12 >>>故障排除日志:上一MQTT订单号缓存列表为2604260939490005280654
2026-04-26 09:43:12 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 09:43:12 开始打印,排队:720,票券:2604260943043031948701,订单:2604260943040028342351,[2026-04-26 09:43:11微信支付12元]
2026-04-26 09:43:12>>>MQTT票号同步场景，创建空订单对象
2026-04-26 09:43:12>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 09:43:14 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604260943043031948701","queue_number":720,"trade_uid":"2604260943040028342351"}]}
2026-04-26 09:43:14 >>>故障排除日志:删除未同步下发订单成功2604260943040028342351
2026-04-26 09:43:14 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536871544]


===09:54:17===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 09:53:28 >>>回调事件[910,devices/TL4654]
2026-04-26 09:53:28 >>>故障排除日志:上一MQTT订单号缓存列表为2604260943040028342351
2026-04-26 09:53:28 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 09:53:28 开始打印,排队:721,票券:2604260953236512939501,订单:2604260953230063362157,[2026-04-26 09:53:27支付宝支付12元]
2026-04-26 09:53:28>>>MQTT票号同步场景，创建空订单对象
2026-04-26 09:53:28>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 09:53:30 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604260953236512939501","queue_number":721,"trade_uid":"2604260953230063362157"}]}
2026-04-26 09:53:30 >>>故障排除日志:删除未同步下发订单成功2604260953230063362157
2026-04-26 09:53:30 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536871642]


===10:00:19===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 10:00:16 >>>回调事件[910,devices/TL4654]
2026-04-26 10:00:16 >>>故障排除日志:上一MQTT订单号缓存列表为2604260953230063362157
2026-04-26 10:00:16 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 10:00:16 开始打印,排队:722,票券:2604261000083551887801,订单:2604261000080033511661,[2026-04-26 10:00:16微信支付12元]
2026-04-26 10:00:16>>>MQTT票号同步场景，创建空订单对象
2026-04-26 10:00:16>>>合并MQTT票号列表到订单同步请求,共1张票


===10:01:19===
2026-04-26 10:00:18 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261000083551887801","queue_number":722,"trade_uid":"2604261000080033511661"}]}
2026-04-26 10:00:18 >>>故障排除日志:删除未同步下发订单成功2604261000080033511661
2026-04-26 10:00:18 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536871715]


===10:04:19===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 10:03:28 >>>回调事件[910,devices/TL4654]
2026-04-26 10:03:28 >>>故障排除日志:上一MQTT订单号缓存列表为2604261000080033511661
2026-04-26 10:03:28 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 10:03:28 开始打印,排队:723,票券:2604261003207964166701,订单:2604261003200077420585,[2026-04-26 10:03:27微信支付12元]
2026-04-26 10:03:29 开始打印,排队:724,票券:2604261003207964549402,订单:2604261003200077420585,[2026-04-26 10:03:27微信支付12元]
2026-04-26 10:03:29>>>MQTT票号同步场景，创建空订单对象
2026-04-26 10:03:29>>>合并MQTT票号列表到订单同步请求,共2张票
2026-04-26 10:03:32 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261003207964166701","queue_number":723,"trade_uid":"2604261003200077420585"},{"ticket_no":"2604261003207964549402","queue_number":724,"trade_uid":"2604261003200077420585"}]}
2026-04-26 10:03:32 >>>故障排除日志:删除未同步下发订单成功2604261003200077420585
2026-04-26 10:03:32 >>>故障排除日志:删除未同步下发订单成功2604261003200077420585
2026-04-26 10:03:32 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536871750]


===10:10:20===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 10:09:47 >>>回调事件[910,devices/TL4654]
2026-04-26 10:09:47 >>>故障排除日志:上一MQTT订单号缓存列表为2604261003200077420585|2604261003200077420585
2026-04-26 10:09:47 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 10:09:47 开始打印,排队:725,票券:2604261009373313908101,订单:2604261009370031135059,[2026-04-26 10:09:47微信支付12元]
2026-04-26 10:09:47>>>MQTT票号同步场景，创建空订单对象
2026-04-26 10:09:47>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 10:09:49 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261009373313908101","queue_number":725,"trade_uid":"2604261009370031135059"}]}
2026-04-26 10:09:49 >>>故障排除日志:删除未同步下发订单成功2604261009370031135059
2026-04-26 10:09:49 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536871813]


===10:11:20===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 10:10:49 >>>回调事件[910,devices/TL4654]
2026-04-26 10:10:49 >>>故障排除日志:上一MQTT订单号缓存列表为2604261009370031135059
2026-04-26 10:10:49 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 10:10:49 开始打印,排队:726,票券:2604261010424111623101,订单:2604261010420039435853,[2026-04-26 10:10:49微信支付12元]
2026-04-26 10:10:50>>>MQTT票号同步场景，创建空订单对象
2026-04-26 10:10:50>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 10:10:52 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261010424111623101","queue_number":726,"trade_uid":"2604261010420039435853"}]}
2026-04-26 10:10:52 >>>故障排除日志:删除未同步下发订单成功2604261010420039435853
2026-04-26 10:10:52 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536871830]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 10:11:03 >>>回调事件[910,devices/TL4654]
2026-04-26 10:11:03 >>>故障排除日志:上一MQTT订单号缓存列表为2604261010420039435853
2026-04-26 10:11:03 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 10:11:03 开始打印,排队:727,票券:2604261010485565727801,订单:2604261010480053585429,[2026-04-26 10:11:03微信支付12元]
2026-04-26 10:11:03>>>MQTT票号同步场景，创建空订单对象
2026-04-26 10:11:03>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 10:11:05 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261010485565727801","queue_number":727,"trade_uid":"2604261010480053585429"}]}
2026-04-26 10:11:05 >>>故障排除日志:删除未同步下发订单成功2604261010480053585429
2026-04-26 10:11:05 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536871838]


===10:23:20===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 10:22:47 >>>回调事件[910,devices/TL4654]
2026-04-26 10:22:47 >>>故障排除日志:上一MQTT订单号缓存列表为2604261010480053585429
2026-04-26 10:22:47 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 10:22:47 开始打印,排队:728,票券:2604261022360066839601,订单:2604261022350098814452,[2026-04-26 10:22:47微信支付12元]
2026-04-26 10:22:47>>>MQTT票号同步场景，创建空订单对象
2026-04-26 10:22:47>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 10:22:49 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261022360066839601","queue_number":728,"trade_uid":"2604261022350098814452"}]}
2026-04-26 10:22:49 >>>故障排除日志:删除未同步下发订单成功2604261022350098814452
2026-04-26 10:22:49 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536871952]


===10:29:21===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 10:28:35 >>>回调事件[910,devices/TL4654]
2026-04-26 10:28:35 >>>故障排除日志:上一MQTT订单号缓存列表为2604261022350098814452
2026-04-26 10:28:35 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 10:28:35 开始打印,排队:729,票券:2604261028273970448101,订单:2604261028270037859139,[2026-04-26 10:28:35微信支付12元]
2026-04-26 10:28:35>>>MQTT票号同步场景，创建空订单对象
2026-04-26 10:28:35>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 10:28:37 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261028273970448101","queue_number":729,"trade_uid":"2604261028270037859139"}]}
2026-04-26 10:28:37 >>>故障排除日志:删除未同步下发订单成功2604261028270037859139
2026-04-26 10:28:38 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536872013]


===10:31:21===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 10:30:39 >>>回调事件[910,devices/TL4654]
2026-04-26 10:30:39 >>>故障排除日志:上一MQTT订单号缓存列表为2604261028270037859139
2026-04-26 10:30:39 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 10:30:39 开始打印,排队:730,票券:2604261030331184101901,订单:2604261030330009964656,[2026-04-26 10:30:39支付宝支付12元]
2026-04-26 10:30:39>>>MQTT票号同步场景，创建空订单对象
2026-04-26 10:30:39>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 10:30:41 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261030331184101901","queue_number":730,"trade_uid":"2604261030330009964656"}]}
2026-04-26 10:30:41 >>>故障排除日志:删除未同步下发订单成功2604261030330009964656
2026-04-26 10:30:41 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536872039]


===10:33:21===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 10:32:50 >>>回调事件[910,devices/TL4654]
2026-04-26 10:32:50 >>>故障排除日志:上一MQTT订单号缓存列表为2604261030330009964656
2026-04-26 10:32:50 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 10:32:50 开始打印,排队:731,票券:2604261032443436721801,订单:2604261032440031261032,[2026-04-26 10:32:50微信支付12元]
2026-04-26 10:32:50>>>MQTT票号同步场景，创建空订单对象
2026-04-26 10:32:50>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 10:32:52 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261032443436721801","queue_number":731,"trade_uid":"2604261032440031261032"}]}
2026-04-26 10:32:52 >>>故障排除日志:删除未同步下发订单成功2604261032440031261032
2026-04-26 10:32:52 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536872066]


===10:34:21===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 10:34:06 >>>回调事件[910,devices/TL4654]
2026-04-26 10:34:06 >>>故障排除日志:上一MQTT订单号缓存列表为2604261032440031261032
2026-04-26 10:34:06 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 10:34:06 开始打印,排队:732,票券:2604261033548772653101,订单:2604261033540085785978,[2026-04-26 10:34:05微信支付12元]
2026-04-26 10:34:06>>>MQTT票号同步场景，创建空订单对象
2026-04-26 10:34:06>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 10:34:08 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261033548772653101","queue_number":732,"trade_uid":"2604261033540085785978"}]}
2026-04-26 10:34:08 >>>故障排除日志:删除未同步下发订单成功2604261033540085785978
2026-04-26 10:34:08 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536872085]


===10:41:22===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 10:40:42 >>>回调事件[910,devices/TL4654]
2026-04-26 10:40:42 >>>故障排除日志:上一MQTT订单号缓存列表为2604261033540085785978
2026-04-26 10:40:42 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 10:40:42 开始打印,排队:733,票券:2604261040368398733701,订单:2604261040360081585391,[2026-04-26 10:40:42微信支付12元]
2026-04-26 10:40:42>>>MQTT票号同步场景，创建空订单对象
2026-04-26 10:40:42>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 10:40:44 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261040368398733701","queue_number":733,"trade_uid":"2604261040360081585391"}]}
2026-04-26 10:40:44 >>>故障排除日志:删除未同步下发订单成功2604261040360081585391
2026-04-26 10:40:44 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536872153]


===10:45:22===
2026-04-26 10:45:04>>>cash read=00
2026-04-26 10:45:05>>>cash read=818F42
2026-04-26 10:45:05>>>cash write=02
2026-04-26 10:45:05 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 10:45:05>>>cash read=10
2026-04-26 10:45:05 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 10:45:07>>>cash write=0C
2026-04-26 10:45:07>>>cash read=3E
2026-04-26 10:45:08>>>cash read=00
2026-04-26 10:45:09>>>cash read=00818F40
2026-04-26 10:45:09>>>cash write=02
2026-04-26 10:45:09 >>>回调事件130,cash_status,10022,进钞中...read money=1
2026-04-26 10:45:10>>>cash read=10
2026-04-26 10:45:10 >>>回调事件130,1,10023,finish Money=1,进钞完成
2026-04-26 10:45:11>>>cash write=0C
2026-04-26 10:45:11>>>cash read=00
2026-04-26 10:45:12>>>cash read=29
2026-04-26 10:45:12 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 10:45:13>>>cash read=2F29
2026-04-26 10:45:15>>>cash read=3E
2026-04-26 10:45:17>>>cash read=00
2026-04-26 10:45:17>>>cash read=818F40
2026-04-26 10:45:17>>>cash write=02
2026-04-26 10:45:17 >>>回调事件130,cash_status,10022,进钞中...read money=1
2026-04-26 10:45:18>>>cash read=10
2026-04-26 10:45:18 >>>回调事件130,1,10023,finish Money=1,进钞完成
2026-04-26 10:45:18 当前产品价格12元，投币12元，打印小票中...
2026-04-26 10:45:18 >>>开始打印,排队号为734,订单号为2604261045100014654718
2026-04-26 10:45:18>>>订单2604261045100014654718写入成功,剩余空间为1678500,占用RAM为640.1259765625
删除未同步订单2604261045100014654718
2026-04-26 10:45:20>>>订单2604261045100014654718删除成功,剩余空间为1679500,占用RAM为651.115234375
检测订单目录中>>>
无未同步订单>>>
2026-04-26 10:45:20 >>>当前Ram内存为618.54296875
定时检测未同步订单启用[checkOrderNum=536872215]


===10:46:23===
2026-04-26 10:45:21>>>cash write=0C
2026-04-26 10:45:21>>>cash read=3E
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 10:45:38 >>>回调事件[910,devices/TL4654]
2026-04-26 10:45:38 >>>故障排除日志:上一MQTT订单号缓存列表为2604261040360081585391
2026-04-26 10:45:38 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 10:45:38 开始打印,排队:735,票券:2604261045304518917601,订单:2604261045300043327584,[2026-04-26 10:45:37微信支付12元]
2026-04-26 10:45:39>>>MQTT票号同步场景，创建空订单对象
2026-04-26 10:45:39>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 10:45:41 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261045304518917601","queue_number":735,"trade_uid":"2604261045300043327584"}]}
2026-04-26 10:45:41 >>>故障排除日志:删除未同步下发订单成功2604261045300043327584
2026-04-26 10:45:41 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536872223]


===10:51:23===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 10:50:49 >>>回调事件[910,devices/TL4654]
2026-04-26 10:50:50 >>>故障排除日志:上一MQTT订单号缓存列表为2604261045300043327584
2026-04-26 10:50:50 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 10:50:50 开始打印,排队:736,票券:2604261050429597286301,订单:2604261050420094109464,[2026-04-26 10:50:49微信支付12元]
2026-04-26 10:50:50>>>MQTT票号同步场景，创建空订单对象
2026-04-26 10:50:50>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 10:50:52 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261050429597286301","queue_number":736,"trade_uid":"2604261050420094109464"}]}
2026-04-26 10:50:52 >>>故障排除日志:删除未同步下发订单成功2604261050420094109464
2026-04-26 10:50:52 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536872276]


===11:10:23===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 11:10:11 >>>回调事件[910,devices/TL4654]
2026-04-26 11:10:11 >>>故障排除日志:上一MQTT订单号缓存列表为2604261050420094109464
2026-04-26 11:10:11 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 11:10:11 开始打印,排队:737,票券:2604261110031426149601,订单:2604261110030012389074,[2026-04-26 11:10:11微信支付12元]
2026-04-26 11:10:12>>>MQTT票号同步场景，创建空订单对象
2026-04-26 11:10:12>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 11:10:13 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261110031426149601","queue_number":737,"trade_uid":"2604261110030012389074"}]}
2026-04-26 11:10:13 >>>故障排除日志:删除未同步下发订单成功2604261110030012389074
2026-04-26 11:10:14 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536872463]


===11:11:24===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 11:10:41 >>>回调事件[910,devices/TL4654]
2026-04-26 11:10:41 >>>故障排除日志:上一MQTT订单号缓存列表为2604261110030012389074
2026-04-26 11:10:41 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 11:10:41 开始打印,排队:738,票券:2604261110355767949301,订单:2604261110350055879378,[2026-04-26 11:10:42微信支付12元]
2026-04-26 11:10:42>>>MQTT票号同步场景，创建空订单对象
2026-04-26 11:10:42>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 11:10:43 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261110355767949301","queue_number":738,"trade_uid":"2604261110350055879378"}]}
2026-04-26 11:10:44 >>>故障排除日志:删除未同步下发订单成功2604261110350055879378
2026-04-26 11:10:44 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536872472]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 11:10:57 >>>回调事件[910,devices/TL4654]
2026-04-26 11:10:57 >>>故障排除日志:上一MQTT订单号缓存列表为2604261110350055879378
2026-04-26 11:10:57 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 11:10:57 开始打印,排队:739,票券:2604261110492532496101,订单:2604261110490023401039,[2026-04-26 11:10:57微信支付12元]
2026-04-26 11:10:57>>>MQTT票号同步场景，创建空订单对象
2026-04-26 11:10:57>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 11:10:59 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261110492532496101","queue_number":739,"trade_uid":"2604261110490023401039"}]}
2026-04-26 11:10:59 >>>故障排除日志:删除未同步下发订单成功2604261110490023401039
2026-04-26 11:10:59 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536872479]


===11:24:24===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 11:24:04 >>>回调事件[910,devices/TL4654]
2026-04-26 11:24:04 >>>故障排除日志:上一MQTT订单号缓存列表为2604261110490023401039
2026-04-26 11:24:04 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 11:24:04 开始打印,排队:740,票券:2604261123573137464901,订单:2604261123570029514224,[2026-04-26 11:24:04支付宝支付12元]
2026-04-26 11:24:04>>>MQTT票号同步场景，创建空订单对象
2026-04-26 11:24:04>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 11:24:06 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261123573137464901","queue_number":740,"trade_uid":"2604261123570029514224"}]}
2026-04-26 11:24:06 >>>故障排除日志:删除未同步下发订单成功2604261123570029514224
2026-04-26 11:24:06 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536872606]


===11:32:24===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 11:31:37 >>>回调事件[910,devices/TL4654]
2026-04-26 11:31:37 >>>故障排除日志:上一MQTT订单号缓存列表为2604261123570029514224
2026-04-26 11:31:37 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 11:31:37 开始打印,排队:741,票券:2604261131311636825701,订单:2604261131310014170212,[2026-04-26 11:31:37支付宝支付12元]
2026-04-26 11:31:37>>>MQTT票号同步场景，创建空订单对象
2026-04-26 11:31:37>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 11:31:39 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261131311636825701","queue_number":741,"trade_uid":"2604261131310014170212"}]}
2026-04-26 11:31:39 >>>故障排除日志:删除未同步下发订单成功2604261131310014170212
2026-04-26 11:31:39 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536872683]


===11:41:24===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 11:40:33 >>>回调事件[910,devices/TL4654]
2026-04-26 11:40:33 >>>故障排除日志:上一MQTT订单号缓存列表为2604261131310014170212
2026-04-26 11:40:33 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 11:40:33 开始打印,排队:742,票券:2604261140193991124601,订单:2604261140190037751613,[2026-04-26 11:40:32支付宝支付12元]
2026-04-26 11:40:33>>>MQTT票号同步场景，创建空订单对象
2026-04-26 11:40:33>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 11:40:35 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261140193991124601","queue_number":742,"trade_uid":"2604261140190037751613"}]}
2026-04-26 11:40:35 >>>故障排除日志:删除未同步下发订单成功2604261140190037751613
2026-04-26 11:40:35 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536872772]


===11:42:25===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 11:41:37 >>>回调事件[910,devices/TL4654]
2026-04-26 11:41:37 >>>故障排除日志:上一MQTT订单号缓存列表为2604261140190037751613
2026-04-26 11:41:37 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 11:41:37 开始打印,排队:743,票券:2604261141291808676401,订单:2604261141290016097452,[2026-04-26 11:41:37微信支付12元]
2026-04-26 11:41:37>>>MQTT票号同步场景，创建空订单对象
2026-04-26 11:41:37>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 11:41:39 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261141291808676401","queue_number":743,"trade_uid":"2604261141290016097452"}]}
2026-04-26 11:41:39 >>>故障排除日志:删除未同步下发订单成功2604261141290016097452
2026-04-26 11:41:39 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536872789]


===11:46:25===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 11:45:31 >>>回调事件[910,devices/TL4654]
2026-04-26 11:45:32 >>>故障排除日志:上一MQTT订单号缓存列表为2604261141290016097452
2026-04-26 11:45:32 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 11:45:32 开始打印,排队:744,票券:2604261145220742385901,订单:2604261145220005451373,[2026-04-26 11:45:31微信支付12元]
2026-04-26 11:45:32>>>MQTT票号同步场景，创建空订单对象
2026-04-26 11:45:32>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 11:45:34 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261145220742385901","queue_number":744,"trade_uid":"2604261145220005451373"}]}
2026-04-26 11:45:34 >>>故障排除日志:删除未同步下发订单成功2604261145220005451373
2026-04-26 11:45:34 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536872832]


===11:52:25===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 11:52:13 >>>回调事件[910,devices/TL4654]
2026-04-26 11:52:13 >>>故障排除日志:上一MQTT订单号缓存列表为2604261145220005451373
2026-04-26 11:52:13 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 11:52:13 开始打印,排队:745,票券:2604261152033812092801,订单:2604261152030036368194,[2026-04-26 11:52:13微信支付12元]
2026-04-26 11:52:13>>>MQTT票号同步场景，创建空订单对象
2026-04-26 11:52:13>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 11:52:16 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261152033812092801","queue_number":745,"trade_uid":"2604261152030036368194"}]}
2026-04-26 11:52:16 >>>故障排除日志:删除未同步下发订单成功2604261152030036368194
2026-04-26 11:52:16 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536872903]


===12:04:26===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 12:03:29 >>>回调事件[910,devices/TL4654]
2026-04-26 12:03:29 >>>故障排除日志:上一MQTT订单号缓存列表为2604261152030036368194
2026-04-26 12:03:29 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 12:03:29 开始打印,排队:746,票券:2604261203190200146501,订单:2604261203190000021215,[2026-04-26 12:03:29微信支付12元]
2026-04-26 12:03:29 开始打印,排队:747,票券:2604261203190200627102,订单:2604261203190000021215,[2026-04-26 12:03:29微信支付12元]
2026-04-26 12:03:29>>>MQTT票号同步场景，创建空订单对象
2026-04-26 12:03:29>>>合并MQTT票号列表到订单同步请求,共2张票
2026-04-26 12:03:33 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261203190200146501","queue_number":746,"trade_uid":"2604261203190000021215"},{"ticket_no":"2604261203190200627102","queue_number":747,"trade_uid":"2604261203190000021215"}]}
2026-04-26 12:03:33 >>>故障排除日志:删除未同步下发订单成功2604261203190000021215
2026-04-26 12:03:33 >>>故障排除日志:删除未同步下发订单成功2604261203190000021215
2026-04-26 12:03:33 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536873010]


===12:12:26===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 12:12:13 >>>回调事件[910,devices/TL4654]
2026-04-26 12:12:13 >>>故障排除日志:上一MQTT订单号缓存列表为2604261203190000021215|2604261203190000021215
2026-04-26 12:12:13 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 12:12:13 开始打印,排队:748,票券:2604261212061439638901,订单:2604261212060011991219,[2026-04-26 12:12:12微信支付12元]
2026-04-26 12:12:13>>>MQTT票号同步场景，创建空订单对象
2026-04-26 12:12:13>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 12:12:15 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261212061439638901","queue_number":748,"trade_uid":"2604261212060011991219"}]}
2026-04-26 12:12:15 >>>故障排除日志:删除未同步下发订单成功2604261212060011991219
2026-04-26 12:12:15 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536873098]


===12:19:26===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 12:18:59 >>>回调事件[910,devices/TL4654]
2026-04-26 12:18:59 >>>故障排除日志:上一MQTT订单号缓存列表为2604261212060011991219
2026-04-26 12:18:59 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 12:19:00 开始打印,排队:749,票券:2604261218502428454301,订单:2604261218500022285049,[2026-04-26 12:18:59微信支付12元]
2026-04-26 12:19:00>>>MQTT票号同步场景，创建空订单对象
2026-04-26 12:19:00>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 12:19:02 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261218502428454301","queue_number":749,"trade_uid":"2604261218500022285049"}]}
2026-04-26 12:19:02 >>>故障排除日志:删除未同步下发订单成功2604261218500022285049
2026-04-26 12:19:02 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536873163]


===12:58:26===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 12:57:49 >>>回调事件[910,devices/TL4654]
2026-04-26 12:57:49 >>>故障排除日志:上一MQTT订单号缓存列表为2604261218500022285049
2026-04-26 12:57:49 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 12:57:49 开始打印,排队:750,票券:2604261257432287564201,订单:2604261257430020829984,[2026-04-26 12:57:49微信支付12元]
2026-04-26 12:57:49>>>MQTT票号同步场景，创建空订单对象
2026-04-26 12:57:49>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 12:57:51 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261257432287564201","queue_number":750,"trade_uid":"2604261257430020829984"}]}
2026-04-26 12:57:51 >>>故障排除日志:删除未同步下发订单成功2604261257430020829984
2026-04-26 12:57:52 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536873520]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 12:58:08 >>>回调事件[910,devices/TL4654]
2026-04-26 12:58:08 >>>故障排除日志:上一MQTT订单号缓存列表为2604261257430020829984
2026-04-26 12:58:08 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 12:58:08 开始打印,排队:751,票券:2604261257494558437601,订单:2604261257490043441986,[2026-04-26 12:58:08微信支付12元]
2026-04-26 12:58:08>>>MQTT票号同步场景，创建空订单对象
2026-04-26 12:58:08>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 12:58:10 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261257494558437601","queue_number":751,"trade_uid":"2604261257490043441986"}]}
2026-04-26 12:58:10 >>>故障排除日志:删除未同步下发订单成功2604261257490043441986
2026-04-26 12:58:10 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536873534]


===13:17:27===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 13:16:44 >>>回调事件[910,devices/TL4654]
2026-04-26 13:16:44 >>>故障排除日志:上一MQTT订单号缓存列表为2604261257490043441986
2026-04-26 13:16:44 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 13:16:44 开始打印,排队:752,票券:2604261316395639101701,订单:2604261316390054464535,[2026-04-26 13:16:44微信支付12元]
2026-04-26 13:16:45>>>MQTT票号同步场景，创建空订单对象
2026-04-26 13:16:45>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 13:16:47 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261316395639101701","queue_number":752,"trade_uid":"2604261316390054464535"}]}
2026-04-26 13:16:47 >>>故障排除日志:删除未同步下发订单成功2604261316390054464535
2026-04-26 13:16:47 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536873705]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 13:16:56 >>>回调事件[910,devices/TL4654]
2026-04-26 13:16:56 >>>故障排除日志:上一MQTT订单号缓存列表为2604261316390054464535
2026-04-26 13:16:56 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 13:16:56 开始打印,排队:753,票券:2604261316442880638201,订单:2604261316440026404958,[2026-04-26 13:16:56微信支付12元]
2026-04-26 13:16:56>>>MQTT票号同步场景，创建空订单对象
2026-04-26 13:16:56>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 13:16:58 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261316442880638201","queue_number":753,"trade_uid":"2604261316440026404958"}]}
2026-04-26 13:16:58 >>>故障排除日志:删除未同步下发订单成功2604261316440026404958
2026-04-26 13:16:59 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536873711]


===13:32:27===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 13:31:41 >>>回调事件[910,devices/TL4654]
2026-04-26 13:31:41 >>>故障排除日志:上一MQTT订单号缓存列表为2604261316440026404958
2026-04-26 13:31:41 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 13:31:41 开始打印,排队:754,票券:2604261331359500825901,订单:2604261331350092920751,[2026-04-26 13:31:40支付宝支付12元]
2026-04-26 13:31:41>>>MQTT票号同步场景，创建空订单对象
2026-04-26 13:31:41>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 13:31:43 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261331359500825901","queue_number":754,"trade_uid":"2604261331350092920751"}]}
2026-04-26 13:31:43 >>>故障排除日志:删除未同步下发订单成功2604261331350092920751
2026-04-26 13:31:43 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536873853]


===13:34:27===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 13:34:16 >>>回调事件[910,devices/TL4654]
2026-04-26 13:34:16 >>>故障排除日志:上一MQTT订单号缓存列表为2604261331350092920751
2026-04-26 13:34:16 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 13:34:16 开始打印,排队:755,票券:2604261334101940104701,订单:2604261334100017489857,[2026-04-26 13:34:16支付宝支付12元]
2026-04-26 13:34:16>>>MQTT票号同步场景，创建空订单对象
2026-04-26 13:34:16>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 13:34:18 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261334101940104701","queue_number":755,"trade_uid":"2604261334100017489857"}]}
2026-04-26 13:34:18 >>>故障排除日志:删除未同步下发订单成功2604261334100017489857
2026-04-26 13:34:18 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536873888]


===13:48:28===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 13:47:54 >>>回调事件[910,devices/TL4654]
2026-04-26 13:47:54 >>>故障排除日志:上一MQTT订单号缓存列表为2604261334100017489857
2026-04-26 13:47:54 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 13:47:54 开始打印,排队:756,票券:2604261347405254178101,订单:2604261347400050629882,[2026-04-26 13:47:54微信支付12元]
2026-04-26 13:47:54>>>MQTT票号同步场景，创建空订单对象
2026-04-26 13:47:54>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 13:47:56 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261347405254178101","queue_number":756,"trade_uid":"2604261347400050629882"}]}
2026-04-26 13:47:56 >>>故障排除日志:删除未同步下发订单成功2604261347400050629882
2026-04-26 13:47:56 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536874014]


===13:53:28===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 13:52:35 >>>回调事件[910,devices/TL4654]
2026-04-26 13:52:35 >>>故障排除日志:上一MQTT订单号缓存列表为2604261347400050629882
2026-04-26 13:52:35 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 13:52:35 开始打印,排队:757,票券:2604261352268489793601,订单:2604261352260082805542,[2026-04-26 13:52:34微信支付12元]
2026-04-26 13:52:35>>>MQTT票号同步场景，创建空订单对象
2026-04-26 13:52:35>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 13:52:37 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261352268489793601","queue_number":757,"trade_uid":"2604261352260082805542"}]}
2026-04-26 13:52:37 >>>故障排除日志:删除未同步下发订单成功2604261352260082805542
2026-04-26 13:52:37 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536874066]


===13:55:28===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 13:55:18 >>>回调事件[910,devices/TL4654]
2026-04-26 13:55:18 >>>故障排除日志:上一MQTT订单号缓存列表为2604261352260082805542
2026-04-26 13:55:18 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 13:55:18 开始打印,排队:758,票券:2604261355113417627601,订单:2604261355110032387192,[2026-04-26 13:55:18微信支付12元]
2026-04-26 13:55:18>>>MQTT票号同步场景，创建空订单对象
2026-04-26 13:55:18>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 13:55:20 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261355113417627601","queue_number":758,"trade_uid":"2604261355110032387192"}]}
2026-04-26 13:55:20 >>>故障排除日志:删除未同步下发订单成功2604261355110032387192
2026-04-26 13:55:20 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536874101]


===13:56:29===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 13:55:51 >>>回调事件[910,devices/TL4654]
2026-04-26 13:55:51 >>>故障排除日志:上一MQTT订单号缓存列表为2604261355110032387192
2026-04-26 13:55:52 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 13:55:52 开始打印,排队:759,票券:2604261355347543864501,订单:2604261355340073461563,[2026-04-26 13:55:52微信支付12元]
2026-04-26 13:55:52>>>MQTT票号同步场景，创建空订单对象
2026-04-26 13:55:52>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 13:55:53 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261355347543864501","queue_number":759,"trade_uid":"2604261355340073461563"}]}
2026-04-26 13:55:54 >>>故障排除日志:删除未同步下发订单成功2604261355340073461563
2026-04-26 13:55:54 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536874110]


===13:59:29===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 13:58:56 >>>回调事件[910,devices/TL4654]
2026-04-26 13:58:56 >>>故障排除日志:上一MQTT订单号缓存列表为2604261355340073461563
2026-04-26 13:58:56 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 13:58:56 开始打印,排队:760,票券:2604261358490021146401,订单:2604261358480097596564,[2026-04-26 13:58:56微信支付12元]
2026-04-26 13:58:56>>>MQTT票号同步场景，创建空订单对象
2026-04-26 13:58:56>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 13:58:58 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261358490021146401","queue_number":760,"trade_uid":"2604261358480097596564"}]}
2026-04-26 13:58:58 >>>故障排除日志:删除未同步下发订单成功2604261358480097596564
2026-04-26 13:58:58 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536874145]


===14:02:29===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 14:01:44 >>>回调事件[910,devices/TL4654]
2026-04-26 14:01:44 >>>故障排除日志:上一MQTT订单号缓存列表为2604261358480097596564
2026-04-26 14:01:44 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 14:01:44 开始打印,排队:761,票券:2604261401375627908301,订单:2604261401370054569213,[2026-04-26 14:01:44微信支付12元]
2026-04-26 14:01:44>>>MQTT票号同步场景，创建空订单对象
2026-04-26 14:01:44>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 14:01:46 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261401375627908301","queue_number":761,"trade_uid":"2604261401370054569213"}]}
2026-04-26 14:01:46 >>>故障排除日志:删除未同步下发订单成功2604261401370054569213
2026-04-26 14:01:46 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536874179]


===14:08:29===
2026-04-26 14:08:12>>>cash read=00
2026-04-26 14:08:13>>>cash read=818F42
2026-04-26 14:08:13>>>cash write=02
2026-04-26 14:08:13 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 14:08:13>>>cash read=10
2026-04-26 14:08:13 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 14:08:15>>>cash write=0C
2026-04-26 14:08:15>>>cash read=3E
2026-04-26 14:08:17>>>cash read=00
2026-04-26 14:08:17>>>cash read=818F42
2026-04-26 14:08:17>>>cash write=02
2026-04-26 14:08:17 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 14:08:18>>>cash read=10
2026-04-26 14:08:18 >>>回调事件130,10,10023,finish Money=10,进钞完成
2026-04-26 14:08:19>>>cash write=0C
2026-04-26 14:08:19>>>cash read=00
2026-04-26 14:08:20>>>cash read=818F40
2026-04-26 14:08:20>>>cash write=02
2026-04-26 14:08:20 >>>回调事件130,cash_status,10022,进钞中...read money=1
2026-04-26 14:08:20>>>cash read=10
2026-04-26 14:08:21 >>>回调事件130,1,10023,finish Money=1,进钞完成
2026-04-26 14:08:22>>>cash write=0C
2026-04-26 14:08:22>>>cash read=00
2026-04-26 14:08:23>>>cash read=01
2026-04-26 14:08:24>>>cash read=3E
2026-04-26 14:08:25>>>cash read=29
2026-04-26 14:08:25 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 14:08:27>>>cash read=01


===14:09:29===
2026-04-26 14:08:28>>>cash read=00
2026-04-26 14:08:29>>>cash read=818F40
2026-04-26 14:08:29>>>cash write=02
2026-04-26 14:08:29 >>>回调事件130,cash_status,10022,进钞中...read money=1
2026-04-26 14:08:29>>>cash read=10
2026-04-26 14:08:29 >>>回调事件130,1,10023,finish Money=1,进钞完成
2026-04-26 14:08:31>>>cash write=0C
2026-04-26 14:08:31>>>cash read=00
2026-04-26 14:08:31>>>cash read=818F40
2026-04-26 14:08:31>>>cash write=02
2026-04-26 14:08:31 >>>回调事件130,cash_status,10022,进钞中...read money=1
2026-04-26 14:08:32>>>cash read=10
2026-04-26 14:08:32 >>>回调事件130,1,10023,finish Money=1,进钞完成
2026-04-26 14:08:33>>>cash write=0C
2026-04-26 14:08:33>>>cash read=00
2026-04-26 14:08:33>>>cash read=818F40
2026-04-26 14:08:33>>>cash write=02
2026-04-26 14:08:33 >>>回调事件130,cash_status,10022,进钞中...read money=1
2026-04-26 14:08:34>>>cash read=10
2026-04-26 14:08:34 >>>回调事件130,1,10023,finish Money=1,进钞完成
2026-04-26 14:08:34 当前产品价格12元，投币24元，打印小票中...
2026-04-26 14:08:34 >>>开始打印,排队号为762,订单号为2604261408140014654346
2026-04-26 14:08:34 >>>开始打印,排队号为763,订单号为2604261408140014654346
2026-04-26 14:08:34>>>订单2604261408140014654346写入成功,剩余空间为1678500,占用RAM为646.326171875
删除未同步订单2604261408140014654346
2026-04-26 14:08:38>>>订单2604261408140014654346删除成功,剩余空间为1680000,占用RAM为662.6904296875
检测订单目录中>>>
无未同步订单>>>
2026-04-26 14:08:38 >>>当前Ram内存为619.3544921875
定时检测未同步订单启用[checkOrderNum=536874273]
2026-04-26 14:08:39>>>cash write=0C
2026-04-26 14:08:39>>>cash read=3E
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 14:08:54 >>>回调事件[910,devices/TL4654]
2026-04-26 14:08:54 >>>故障排除日志:上一MQTT订单号缓存列表为2604261401370054569213
2026-04-26 14:08:54 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 14:08:54 开始打印,排队:764,票券:2604261408478350393501,订单:2604261408470081739553,[2026-04-26 14:08:54微信支付12元]
2026-04-26 14:08:54>>>MQTT票号同步场景，创建空订单对象
2026-04-26 14:08:54>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 14:08:56 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261408478350393501","queue_number":764,"trade_uid":"2604261408470081739553"}]}
2026-04-26 14:08:57 >>>故障排除日志:删除未同步下发订单成功2604261408470081739553
2026-04-26 14:08:57 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536874280]


===14:18:30===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 14:18:10 >>>回调事件[910,devices/TL4654]
2026-04-26 14:18:10 >>>故障排除日志:上一MQTT订单号缓存列表为2604261408470081739553
2026-04-26 14:18:10 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 14:18:10 开始打印,排队:765,票券:2604261418014290663801,订单:2604261418010041161261,[2026-04-26 14:18:10微信支付12元]
2026-04-26 14:18:10>>>MQTT票号同步场景，创建空订单对象
2026-04-26 14:18:10>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 14:18:12 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261418014290663801","queue_number":765,"trade_uid":"2604261418010041161261"}]}
2026-04-26 14:18:12 >>>故障排除日志:删除未同步下发订单成功2604261418010041161261
2026-04-26 14:18:12 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536874376]


===14:26:30===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 14:25:46 >>>回调事件[910,devices/TL4654]
2026-04-26 14:25:46 >>>故障排除日志:上一MQTT订单号缓存列表为2604261418010041161261
2026-04-26 14:25:46 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 14:25:46 开始打印,排队:766,票券:2604261425406682699101,订单:2604261425400064984754,[2026-04-26 14:25:46微信支付12元]
2026-04-26 14:25:46>>>MQTT票号同步场景，创建空订单对象
2026-04-26 14:25:46>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 14:25:48 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261425406682699101","queue_number":766,"trade_uid":"2604261425400064984754"}]}
2026-04-26 14:25:48 >>>故障排除日志:删除未同步下发订单成功2604261425400064984754
2026-04-26 14:25:48 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536874448]


===14:37:30===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 14:36:44 >>>回调事件[910,devices/TL4654]
2026-04-26 14:36:44 >>>故障排除日志:上一MQTT订单号缓存列表为2604261425400064984754
2026-04-26 14:36:44 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 14:36:44 开始打印,排队:767,票券:2604261436358705911401,订单:2604261436350085303613,[2026-04-26 14:36:44微信支付12元]
2026-04-26 14:36:44>>>MQTT票号同步场景，创建空订单对象
2026-04-26 14:36:44>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 14:36:46 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261436358705911401","queue_number":767,"trade_uid":"2604261436350085303613"}]}
2026-04-26 14:36:46 >>>故障排除日志:删除未同步下发订单成功2604261436350085303613
2026-04-26 14:36:46 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536874555]


===14:53:31===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 14:53:01 >>>回调事件[910,devices/TL4654]
2026-04-26 14:53:01 >>>故障排除日志:上一MQTT订单号缓存列表为2604261436350085303613
2026-04-26 14:53:01 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 14:53:01 开始打印,排队:768,票券:2604261452554858128401,订单:2604261452550046755841,[2026-04-26 14:53:01微信支付12元]
2026-04-26 14:53:01>>>MQTT票号同步场景，创建空订单对象
2026-04-26 14:53:01>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 14:53:03 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261452554858128401","queue_number":768,"trade_uid":"2604261452550046755841"}]}
2026-04-26 14:53:03 >>>故障排除日志:删除未同步下发订单成功2604261452550046755841
2026-04-26 14:53:04 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536874709]


===15:00:31===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 15:00:16 >>>回调事件[910,devices/TL4654]
2026-04-26 15:00:16 >>>故障排除日志:上一MQTT订单号缓存列表为2604261452550046755841
2026-04-26 15:00:16 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 15:00:16 开始打印,排队:769,票券:2604261500101798415801,订单:2604261500100016103298,[2026-04-26 15:00:16微信支付12元]
2026-04-26 15:00:17>>>MQTT票号同步场景，创建空订单对象
2026-04-26 15:00:17>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 15:00:19 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261500101798415801","queue_number":769,"trade_uid":"2604261500100016103298"}]}
2026-04-26 15:00:19 >>>故障排除日志:删除未同步下发订单成功2604261500100016103298
2026-04-26 15:00:19 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536874786]


===15:02:31===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 15:02:25 >>>回调事件[910,devices/TL4654]
2026-04-26 15:02:25 >>>故障排除日志:上一MQTT订单号缓存列表为2604261500100016103298
2026-04-26 15:02:25 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 15:02:25 开始打印,排队:770,票券:2604261502174758917201,订单:2604261502170045659745,[2026-04-26 15:02:25微信支付12元]
2026-04-26 15:02:26>>>MQTT票号同步场景，创建空订单对象
2026-04-26 15:02:26>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 15:02:27 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261502174758917201","queue_number":770,"trade_uid":"2604261502170045659745"}]}
2026-04-26 15:02:27 >>>故障排除日志:删除未同步下发订单成功2604261502170045659745
2026-04-26 15:02:28 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536874812]


===15:05:31===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 15:04:44 >>>回调事件[910,devices/TL4654]
2026-04-26 15:04:44 >>>故障排除日志:上一MQTT订单号缓存列表为2604261502170045659745
2026-04-26 15:04:44 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 15:04:44 开始打印,排队:771,票券:2604261504382590207101,订单:2604261504380023851037,[2026-04-26 15:04:44支付宝支付12元]
2026-04-26 15:04:44>>>MQTT票号同步场景，创建空订单对象
2026-04-26 15:04:44>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 15:04:46 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261504382590207101","queue_number":771,"trade_uid":"2604261504380023851037"}]}
2026-04-26 15:04:46 >>>故障排除日志:删除未同步下发订单成功2604261504380023851037
2026-04-26 15:04:46 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536874839]


===15:06:32===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 15:06:14 >>>回调事件[910,devices/TL4654]
2026-04-26 15:06:14 >>>故障排除日志:上一MQTT订单号缓存列表为2604261504380023851037
2026-04-26 15:06:14 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 15:06:14 开始打印,排队:772,票券:2604261506069191033601,订单:2604261506060090001021,[2026-04-26 15:06:13微信支付12元]
2026-04-26 15:06:14>>>MQTT票号同步场景，创建空订单对象
2026-04-26 15:06:14>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 15:06:16 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261506069191033601","queue_number":772,"trade_uid":"2604261506060090001021"}]}
2026-04-26 15:06:16 >>>故障排除日志:删除未同步下发订单成功2604261506060090001021
2026-04-26 15:06:16 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536874864]


===15:20:32===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 15:19:36 >>>回调事件[910,devices/TL4654]
2026-04-26 15:19:36 >>>故障排除日志:上一MQTT订单号缓存列表为2604261506060090001021
2026-04-26 15:19:36 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 15:19:36 开始打印,排队:773,票券:2604261519263505944601,订单:2604261519260032650731,[2026-04-26 15:19:35微信支付12元]
2026-04-26 15:19:36>>>MQTT票号同步场景，创建空订单对象
2026-04-26 15:19:36>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 15:19:38 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261519263505944601","queue_number":773,"trade_uid":"2604261519260032650731"}]}
2026-04-26 15:19:38 >>>故障排除日志:删除未同步下发订单成功2604261519260032650731
2026-04-26 15:19:38 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536874989]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 15:20:05 >>>回调事件[910,devices/TL4654]
2026-04-26 15:20:05 >>>故障排除日志:上一MQTT订单号缓存列表为2604261519260032650731
2026-04-26 15:20:05 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 15:20:05 开始打印,排队:774,票券:2604261519549691163201,订单:2604261519540095080431,[2026-04-26 15:20:05微信支付12元]
2026-04-26 15:20:05>>>MQTT票号同步场景，创建空订单对象
2026-04-26 15:20:05>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 15:20:07 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261519549691163201","queue_number":774,"trade_uid":"2604261519540095080431"}]}
2026-04-26 15:20:07 >>>故障排除日志:删除未同步下发订单成功2604261519540095080431
2026-04-26 15:20:07 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536874998]


===15:25:32===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 15:24:31 >>>回调事件[910,devices/TL4654]
2026-04-26 15:24:31 >>>故障排除日志:上一MQTT订单号缓存列表为2604261519540095080431
2026-04-26 15:24:31 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 15:24:31 开始打印,排队:775,票券:2604261524237542757201,订单:2604261524230073690416,[2026-04-26 15:24:31微信支付12元]
2026-04-26 15:24:31>>>MQTT票号同步场景，创建空订单对象
2026-04-26 15:24:31>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 15:24:33 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261524237542757201","queue_number":775,"trade_uid":"2604261524230073690416"}]}
2026-04-26 15:24:33 >>>故障排除日志:删除未同步下发订单成功2604261524230073690416
2026-04-26 15:24:33 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536875048]


===15:33:32===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 15:32:40 >>>回调事件[910,devices/TL4654]
2026-04-26 15:32:40 >>>故障排除日志:上一MQTT订单号缓存列表为2604261524230073690416
2026-04-26 15:32:40 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 15:32:40 开始打印,排队:776,票券:2604261532336326996401,订单:2604261532330060782896,[2026-04-26 15:32:40微信支付12元]
2026-04-26 15:32:40>>>MQTT票号同步场景，创建空订单对象
2026-04-26 15:32:40>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 15:32:42 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261532336326996401","queue_number":776,"trade_uid":"2604261532330060782896"}]}
2026-04-26 15:32:42 >>>故障排除日志:删除未同步下发订单成功2604261532330060782896
2026-04-26 15:32:42 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536875128]


===15:49:33===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 15:48:33 >>>回调事件[910,devices/TL4654]
2026-04-26 15:48:33 >>>故障排除日志:上一MQTT订单号缓存列表为2604261532330060782896
2026-04-26 15:48:33 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 15:48:33 开始打印,排队:777,票券:2604261548262659538601,订单:2604261548260024523885,[2026-04-26 15:48:33微信支付12元]
2026-04-26 15:48:33>>>MQTT票号同步场景，创建空订单对象
2026-04-26 15:48:33>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 15:48:35 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261548262659538601","queue_number":777,"trade_uid":"2604261548260024523885"}]}
2026-04-26 15:48:36 >>>故障排除日志:删除未同步下发订单成功2604261548260024523885
2026-04-26 15:48:36 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536875280]
2026-04-26 15:48:37>>>cash read=9E
2026-04-26 15:48:38>>>cash read=3E


===15:50:33===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 15:49:56 >>>回调事件[910,devices/TL4654]
2026-04-26 15:49:56 >>>故障排除日志:上一MQTT订单号缓存列表为2604261548260024523885
2026-04-26 15:49:56 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 15:49:56 开始打印,排队:778,票券:2604261549506554989501,订单:2604261549500063468464,[2026-04-26 15:49:56微信支付12元]
2026-04-26 15:49:57>>>MQTT票号同步场景，创建空订单对象
2026-04-26 15:49:57>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 15:49:58 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261549506554989501","queue_number":778,"trade_uid":"2604261549500063468464"}]}
2026-04-26 15:49:58 >>>故障排除日志:删除未同步下发订单成功2604261549500063468464
2026-04-26 15:49:59 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536875297]


===15:55:33===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 15:55:19 >>>回调事件[910,devices/TL4654]
2026-04-26 15:55:19 >>>故障排除日志:上一MQTT订单号缓存列表为2604261549500063468464
2026-04-26 15:55:19 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 15:55:19 开始打印,排队:779,票券:2604261555124675003501,订单:2604261555120043840759,[2026-04-26 15:55:18微信支付12元]
2026-04-26 15:55:19 开始打印,排队:780,票券:2604261555124675598202,订单:2604261555120043840759,[2026-04-26 15:55:18微信支付12元]
2026-04-26 15:55:19>>>MQTT票号同步场景，创建空订单对象
2026-04-26 15:55:19>>>合并MQTT票号列表到订单同步请求,共2张票
2026-04-26 15:55:23 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261555124675003501","queue_number":779,"trade_uid":"2604261555120043840759"},{"ticket_no":"2604261555124675598202","queue_number":780,"trade_uid":"2604261555120043840759"}]}
2026-04-26 15:55:23 >>>故障排除日志:删除未同步下发订单成功2604261555120043840759
2026-04-26 15:55:23 >>>故障排除日志:删除未同步下发订单成功2604261555120043840759
2026-04-26 15:55:23 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536875358]


===16:05:33===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 16:04:39 >>>回调事件[910,devices/TL4654]
2026-04-26 16:04:39 >>>故障排除日志:上一MQTT订单号缓存列表为2604261555120043840759|2604261555120043840759
2026-04-26 16:04:39 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 16:04:39 开始打印,排队:781,票券:2604261604305697235901,订单:2604261604300054759819,[2026-04-26 16:04:39微信支付12元]
2026-04-26 16:04:39>>>MQTT票号同步场景，创建空订单对象
2026-04-26 16:04:39>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 16:04:41 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261604305697235901","queue_number":781,"trade_uid":"2604261604300054759819"}]}
2026-04-26 16:04:41 >>>故障排除日志:删除未同步下发订单成功2604261604300054759819
2026-04-26 16:04:41 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536875448]


===16:07:34===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 16:07:22 >>>回调事件[910,devices/TL4654]
2026-04-26 16:07:22 >>>故障排除日志:上一MQTT订单号缓存列表为2604261604300054759819
2026-04-26 16:07:22 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 16:07:22 开始打印,排队:782,票券:2604261607142329011601,订单:2604261607140021043061,[2026-04-26 16:07:22微信支付12元]
2026-04-26 16:07:22>>>MQTT票号同步场景，创建空订单对象
2026-04-26 16:07:22>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 16:07:24 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261607142329011601","queue_number":782,"trade_uid":"2604261607140021043061"}]}
2026-04-26 16:07:24 >>>故障排除日志:删除未同步下发订单成功2604261607140021043061
2026-04-26 16:07:24 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536875482]


===16:08:34===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 16:07:36 >>>回调事件[910,devices/TL4654]
2026-04-26 16:07:36 >>>故障排除日志:上一MQTT订单号缓存列表为2604261607140021043061
2026-04-26 16:07:36 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 16:07:36 开始打印,排队:783,票券:2604261607292217604201,订单:2604261607290020247571,[2026-04-26 16:07:36微信支付12元]
2026-04-26 16:07:36>>>MQTT票号同步场景，创建空订单对象
2026-04-26 16:07:36>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 16:07:38 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261607292217604201","queue_number":783,"trade_uid":"2604261607290020247571"}]}
2026-04-26 16:07:38 >>>故障排除日志:删除未同步下发订单成功2604261607290020247571
2026-04-26 16:07:38 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536875491]


===16:11:34===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 16:10:57 >>>回调事件[910,devices/TL4654]
2026-04-26 16:10:57 >>>故障排除日志:上一MQTT订单号缓存列表为2604261607290020247571
2026-04-26 16:10:57 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 16:10:57 开始打印,排队:784,票券:2604261610426974988601,订单:2604261610420067085058,[2026-04-26 16:10:57支付宝支付12元]
2026-04-26 16:10:57>>>MQTT票号同步场景，创建空订单对象
2026-04-26 16:10:57>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 16:10:59 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261610426974988601","queue_number":784,"trade_uid":"2604261610420067085058"}]}
2026-04-26 16:10:59 >>>故障排除日志:删除未同步下发订单成功2604261610420067085058
2026-04-26 16:10:59 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536875526]


===16:13:34===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 16:12:40 >>>回调事件[910,devices/TL4654]
2026-04-26 16:12:40 >>>故障排除日志:上一MQTT订单号缓存列表为2604261610420067085058
2026-04-26 16:12:40 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 16:12:40 开始打印,排队:785,票券:2604261612339290746101,订单:2604261612330091208881,[2026-04-26 16:12:40微信支付12元]
2026-04-26 16:12:40>>>MQTT票号同步场景，创建空订单对象
2026-04-26 16:12:40>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 16:12:42 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261612339290746101","queue_number":785,"trade_uid":"2604261612330091208881"}]}
2026-04-26 16:12:42 >>>故障排除日志:删除未同步下发订单成功2604261612330091208881
2026-04-26 16:12:42 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536875552]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 16:13:01 >>>回调事件[910,devices/TL4654]
2026-04-26 16:13:01 >>>故障排除日志:上一MQTT订单号缓存列表为2604261612330091208881
2026-04-26 16:13:01 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 16:13:01 开始打印,排队:786,票券:2604261612525727058401,订单:2604261612520055301698,[2026-04-26 16:13:00微信支付12元]
2026-04-26 16:13:01>>>MQTT票号同步场景，创建空订单对象
2026-04-26 16:13:01>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 16:13:03 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261612525727058401","queue_number":786,"trade_uid":"2604261612520055301698"}]}
2026-04-26 16:13:03 >>>故障排除日志:删除未同步下发订单成功2604261612520055301698
2026-04-26 16:13:03 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536875560]


===16:18:36===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 16:18:33 >>>回调事件[910,devices/TL4654]
2026-04-26 16:18:33 >>>故障排除日志:上一MQTT订单号缓存列表为2604261612520055301698
2026-04-26 16:18:33 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 16:18:33 开始打印,排队:787,票券:2604261618267257009401,订单:2604261618260070304515,[2026-04-26 16:18:32微信支付12元]
2026-04-26 16:18:33>>>MQTT票号同步场景，创建空订单对象
2026-04-26 16:18:33>>>合并MQTT票号列表到订单同步请求,共1张票


===16:19:37===
2026-04-26 16:18:35 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261618267257009401","queue_number":787,"trade_uid":"2604261618260070304515"}]}
2026-04-26 16:18:35 >>>故障排除日志:删除未同步下发订单成功2604261618260070304515
2026-04-26 16:18:35 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536875621]


===16:22:37===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 16:22:05 >>>回调事件[910,devices/TL4654]
2026-04-26 16:22:05 >>>故障排除日志:上一MQTT订单号缓存列表为2604261618260070304515
2026-04-26 16:22:05 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 16:22:05 开始打印,排队:788,票券:2604261621584892627801,订单:2604261621580045709773,[2026-04-26 16:22:05微信支付12元]
2026-04-26 16:22:05>>>MQTT票号同步场景，创建空订单对象
2026-04-26 16:22:05>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 16:22:07 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261621584892627801","queue_number":788,"trade_uid":"2604261621580045709773"}]}
2026-04-26 16:22:07 >>>故障排除日志:删除未同步下发订单成功2604261621580045709773
2026-04-26 16:22:07 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536875659]


===16:23:37===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 16:23:09 >>>回调事件[910,devices/TL4654]
2026-04-26 16:23:09 >>>故障排除日志:上一MQTT订单号缓存列表为2604261621580045709773
2026-04-26 16:23:09 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 16:23:09 开始打印,排队:789,票券:2604261623004293117301,订单:2604261623000040904857,[2026-04-26 16:23:08微信支付12元]
2026-04-26 16:23:09>>>MQTT票号同步场景，创建空订单对象
2026-04-26 16:23:09>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 16:23:11 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261623004293117301","queue_number":789,"trade_uid":"2604261623000040904857"}]}
2026-04-26 16:23:11 >>>故障排除日志:删除未同步下发订单成功2604261623000040904857
2026-04-26 16:23:11 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536875676]


===16:29:37===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 16:28:49 >>>回调事件[910,devices/TL4654]
2026-04-26 16:28:49 >>>故障排除日志:上一MQTT订单号缓存列表为2604261623000040904857
2026-04-26 16:28:49 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 16:28:49 开始打印,排队:790,票券:2604261628444812641201,订单:2604261628440044741949,[2026-04-26 16:28:49支付宝支付12元]
2026-04-26 16:28:49>>>MQTT票号同步场景，创建空订单对象
2026-04-26 16:28:49>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 16:28:51 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261628444812641201","queue_number":790,"trade_uid":"2604261628440044741949"}]}
2026-04-26 16:28:51 >>>故障排除日志:删除未同步下发订单成功2604261628440044741949
2026-04-26 16:28:51 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536875736]


===16:33:38===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 16:33:08 >>>回调事件[910,devices/TL4654]
2026-04-26 16:33:08 >>>故障排除日志:上一MQTT订单号缓存列表为2604261628440044741949
2026-04-26 16:33:08 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 16:33:08 开始打印,排队:791,票券:2604261633004602522801,订单:2604261633000042611272,[2026-04-26 16:33:07微信支付12元]
2026-04-26 16:33:08>>>MQTT票号同步场景，创建空订单对象
2026-04-26 16:33:08>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 16:33:10 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261633004602522801","queue_number":791,"trade_uid":"2604261633000042611272"}]}
2026-04-26 16:33:10 >>>故障排除日志:删除未同步下发订单成功2604261633000042611272
2026-04-26 16:33:10 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536875782]


===16:39:38===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 16:38:51 >>>回调事件[910,devices/TL4654]
2026-04-26 16:38:51 >>>故障排除日志:上一MQTT订单号缓存列表为2604261633000042611272
2026-04-26 16:38:51 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 16:38:51 开始打印,排队:792,票券:2604261638435291441301,订单:2604261638430051022232,[2026-04-26 16:38:51微信支付12元]
2026-04-26 16:38:51>>>MQTT票号同步场景，创建空订单对象
2026-04-26 16:38:51>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 16:38:53 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261638435291441301","queue_number":792,"trade_uid":"2604261638430051022232"}]}
2026-04-26 16:38:53 >>>故障排除日志:删除未同步下发订单成功2604261638430051022232
2026-04-26 16:38:53 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536875842]


===16:40:40===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 16:40:36 >>>回调事件[910,devices/TL4654]
2026-04-26 16:40:36 >>>故障排除日志:上一MQTT订单号缓存列表为2604261638430051022232
2026-04-26 16:40:36 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 16:40:36 开始打印,排队:793,票券:2604261640250807347501,订单:2604261640250006189885,[2026-04-26 16:40:36微信支付12元]
2026-04-26 16:40:37>>>MQTT票号同步场景，创建空订单对象
2026-04-26 16:40:37>>>合并MQTT票号列表到订单同步请求,共1张票


===16:41:40===
2026-04-26 16:40:38 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261640250807347501","queue_number":793,"trade_uid":"2604261640250006189885"}]}
2026-04-26 16:40:38 >>>故障排除日志:删除未同步下发订单成功2604261640250006189885
2026-04-26 16:40:39 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536875869]


===16:43:40===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 16:43:00 >>>回调事件[910,devices/TL4654]
2026-04-26 16:43:00 >>>故障排除日志:上一MQTT订单号缓存列表为2604261640250006189885
2026-04-26 16:43:00 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 16:43:00 开始打印,排队:794,票券:2604261642523514375901,订单:2604261642520032968845,[2026-04-26 16:43:00微信支付12元]
2026-04-26 16:43:00>>>MQTT票号同步场景，创建空订单对象
2026-04-26 16:43:00>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 16:43:02 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261642523514375901","queue_number":794,"trade_uid":"2604261642520032968845"}]}
2026-04-26 16:43:02 >>>故障排除日志:删除未同步下发订单成功2604261642520032968845
2026-04-26 16:43:02 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536875898]


===16:44:41===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 16:44:06 >>>回调事件[910,devices/TL4654]
2026-04-26 16:44:06 >>>故障排除日志:上一MQTT订单号缓存列表为2604261642520032968845
2026-04-26 16:44:06 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 16:44:06 开始打印,排队:795,票券:2604261643584611007501,订单:2604261643580042560683,[2026-04-26 16:44:06微信支付12元]
2026-04-26 16:44:06>>>MQTT票号同步场景，创建空订单对象
2026-04-26 16:44:06>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 16:44:08 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261643584611007501","queue_number":795,"trade_uid":"2604261643580042560683"}]}
2026-04-26 16:44:08 >>>故障排除日志:删除未同步下发订单成功2604261643580042560683
2026-04-26 16:44:09 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536875915]


===16:49:41===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 16:48:52 >>>回调事件[910,devices/TL4654]
2026-04-26 16:48:52 >>>故障排除日志:上一MQTT订单号缓存列表为2604261643580042560683
2026-04-26 16:48:52 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 16:48:52 开始打印,排队:796,票券:2604261648427456808501,订单:2604261648420072491389,[2026-04-26 16:48:51微信支付12元]
2026-04-26 16:48:52 开始打印,排队:797,票券:2604261648427457382702,订单:2604261648420072491389,[2026-04-26 16:48:51微信支付12元]
2026-04-26 16:48:52>>>MQTT票号同步场景，创建空订单对象
2026-04-26 16:48:52>>>合并MQTT票号列表到订单同步请求,共2张票
2026-04-26 16:48:55 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261648427456808501","queue_number":796,"trade_uid":"2604261648420072491389"},{"ticket_no":"2604261648427457382702","queue_number":797,"trade_uid":"2604261648420072491389"}]}
2026-04-26 16:48:55 >>>故障排除日志:删除未同步下发订单成功2604261648420072491389
2026-04-26 16:48:55 >>>故障排除日志:删除未同步下发订单成功2604261648420072491389
2026-04-26 16:48:56 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536875966]


===17:08:41===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 17:07:54 >>>回调事件[910,devices/TL4654]
2026-04-26 17:07:54 >>>故障排除日志:上一MQTT订单号缓存列表为2604261648420072491389|2604261648420072491389
2026-04-26 17:07:54 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 17:07:54 开始打印,排队:798,票券:2604261707481070161501,订单:2604261707480008486451,[2026-04-26 17:07:54微信支付12元]
2026-04-26 17:07:54>>>MQTT票号同步场景，创建空订单对象
2026-04-26 17:07:54>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 17:07:56 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261707481070161501","queue_number":798,"trade_uid":"2604261707480008486451"}]}
2026-04-26 17:07:56 >>>故障排除日志:删除未同步下发订单成功2604261707480008486451
2026-04-26 17:07:56 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536876145]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 17:08:11 >>>回调事件[910,devices/TL4654]
2026-04-26 17:08:11 >>>故障排除日志:上一MQTT订单号缓存列表为2604261707480008486451
2026-04-26 17:08:11 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 17:08:11 开始打印,排队:799,票券:2604261708038594192901,订单:2604261708030084042358,[2026-04-26 17:08:11微信支付12元]
2026-04-26 17:08:11>>>MQTT票号同步场景，创建空订单对象
2026-04-26 17:08:11>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 17:08:13 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261708038594192901","queue_number":799,"trade_uid":"2604261708030084042358"}]}
2026-04-26 17:08:13 >>>故障排除日志:删除未同步下发订单成功2604261708030084042358
2026-04-26 17:08:13 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536876158]


===17:09:42===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 17:09:36 >>>回调事件[910,devices/TL4654]
2026-04-26 17:09:36 >>>故障排除日志:上一MQTT订单号缓存列表为2604261708030084042358
2026-04-26 17:09:36 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 17:09:36 开始打印,排队:800,票券:2604261709251654573201,订单:2604261709250014532164,[2026-04-26 17:09:36微信支付12元]
2026-04-26 17:09:36>>>MQTT票号同步场景，创建空订单对象
2026-04-26 17:09:36>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 17:09:38 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261709251654573201","queue_number":800,"trade_uid":"2604261709250014532164"}]}
2026-04-26 17:09:38 >>>故障排除日志:删除未同步下发订单成功2604261709250014532164
2026-04-26 17:09:38 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536876176]


===17:11:42===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 17:11:14 >>>回调事件[910,devices/TL4654]
2026-04-26 17:11:15 >>>故障排除日志:上一MQTT订单号缓存列表为2604261709250014532164
2026-04-26 17:11:15 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 17:11:15 开始打印,排队:801,票券:2604261711081404209301,订单:2604261711080012141093,[2026-04-26 17:11:14微信支付12元]
2026-04-26 17:11:15>>>MQTT票号同步场景，创建空订单对象
2026-04-26 17:11:15>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 17:11:17 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261711081404209301","queue_number":801,"trade_uid":"2604261711080012141093"}]}
2026-04-26 17:11:17 >>>故障排除日志:删除未同步下发订单成功2604261711080012141093
2026-04-26 17:11:17 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536876201]


===17:13:45===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 17:13:07 >>>回调事件[910,devices/TL4654]
2026-04-26 17:13:07 >>>故障排除日志:上一MQTT订单号缓存列表为2604261711080012141093
2026-04-26 17:13:07 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 17:13:07 开始打印,排队:802,票券:2604261712578342262401,订单:2604261712570081183682,[2026-04-26 17:13:07微信支付12元]
2026-04-26 17:13:07>>>MQTT票号同步场景，创建空订单对象
2026-04-26 17:13:07>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 17:13:09 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261712578342262401","queue_number":802,"trade_uid":"2604261712570081183682"}]}
2026-04-26 17:13:09 >>>故障排除日志:删除未同步下发订单成功2604261712570081183682
2026-04-26 17:13:09 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536876222]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 17:13:40 >>>回调事件[910,devices/TL4654]
2026-04-26 17:13:40 >>>故障排除日志:上一MQTT订单号缓存列表为2604261712570081183682
2026-04-26 17:13:40 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 17:13:40 开始打印,排队:803,票券:2604261713319523102101,订单:2604261713310093393353,[2026-04-26 17:13:40微信支付12元]
2026-04-26 17:13:40 开始打印,排队:804,票券:2604261713319523566902,订单:2604261713310093393353,[2026-04-26 17:13:40微信支付12元]
2026-04-26 17:13:40>>>MQTT票号同步场景，创建空订单对象
2026-04-26 17:13:40>>>合并MQTT票号列表到订单同步请求,共2张票


===17:16:46===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 17:16:20 >>>回调事件[910,devices/TL4654]
2026-04-26 17:16:20 >>>故障排除日志:上一MQTT订单号缓存列表为2604261713310093393353|2604261713310093393353
2026-04-26 17:16:20 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 17:16:20 开始打印,排队:805,票券:2604261716139369586501,订单:2604261716130090478258,[2026-04-26 17:16:19微信支付12元]
2026-04-26 17:16:20>>>MQTT票号同步场景，创建空订单对象
2026-04-26 17:16:20>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 17:16:22 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261716139369586501","queue_number":805,"trade_uid":"2604261716130090478258"}]}
2026-04-26 17:16:22 >>>故障排除日志:删除未同步下发订单成功2604261716130090478258
2026-04-26 17:16:22 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536876268]


===17:19:46===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 17:19:18 >>>回调事件[910,devices/TL4654]
2026-04-26 17:19:18 >>>故障排除日志:上一MQTT订单号缓存列表为2604261716130090478258
2026-04-26 17:19:18 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 17:19:18 开始打印,排队:806,票券:2604261719103650801601,订单:2604261719100034114665,[2026-04-26 17:19:17微信支付12元]
2026-04-26 17:19:18>>>MQTT票号同步场景，创建空订单对象
2026-04-26 17:19:18>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 17:19:20 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261719103650801601","queue_number":806,"trade_uid":"2604261719100034114665"}]}
2026-04-26 17:19:20 >>>故障排除日志:删除未同步下发订单成功2604261719100034114665
2026-04-26 17:19:20 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536876303]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 17:19:39 >>>回调事件[910,devices/TL4654]
2026-04-26 17:19:39 >>>故障排除日志:上一MQTT订单号缓存列表为2604261719100034114665
2026-04-26 17:19:39 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 17:19:39 开始打印,排队:807,票券:2604261719325153572501,订单:2604261719320049685567,[2026-04-26 17:19:39微信支付12元]
2026-04-26 17:19:39>>>MQTT票号同步场景，创建空订单对象
2026-04-26 17:19:39>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 17:19:41 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261719325153572501","queue_number":807,"trade_uid":"2604261719320049685567"}]}
2026-04-26 17:19:41 >>>故障排除日志:删除未同步下发订单成功2604261719320049685567
2026-04-26 17:19:41 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536876310]


===17:20:46===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 17:20:29 >>>回调事件[910,devices/TL4654]
2026-04-26 17:20:29 >>>故障排除日志:上一MQTT订单号缓存列表为2604261719320049685567
2026-04-26 17:20:29 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 17:20:29 开始打印,排队:808,票券:2604261720222167829301,订单:2604261720220019108772,[2026-04-26 17:20:28微信支付12元]
2026-04-26 17:20:29>>>MQTT票号同步场景，创建空订单对象
2026-04-26 17:20:29>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 17:20:31 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261720222167829301","queue_number":808,"trade_uid":"2604261720220019108772"}]}
2026-04-26 17:20:31 >>>故障排除日志:删除未同步下发订单成功2604261720220019108772
2026-04-26 17:20:31 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536876327]


===17:24:46===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 17:23:51 >>>回调事件[910,devices/TL4654]
2026-04-26 17:23:51 >>>故障排除日志:上一MQTT订单号缓存列表为2604261720220019108772
2026-04-26 17:23:51 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 17:23:51 开始打印,排队:809,票券:2604261723437311119201,订单:2604261723430071076274,[2026-04-26 17:23:51微信支付12元]
2026-04-26 17:23:51 开始打印,排队:810,票券:2604261723437311536802,订单:2604261723430071076274,[2026-04-26 17:23:51微信支付12元]
2026-04-26 17:23:51 开始打印,排队:811,票券:2604261723437311673103,订单:2604261723430071076274,[2026-04-26 17:23:51微信支付12元]
2026-04-26 17:23:51>>>MQTT票号同步场景，创建空订单对象
2026-04-26 17:23:51>>>合并MQTT票号列表到订单同步请求,共3张票
2026-04-26 17:23:56 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261723437311119201","queue_number":809,"trade_uid":"2604261723430071076274"},{"ticket_no":"2604261723437311536802","queue_number":810,"trade_uid":"2604261723430071076274"},{"ticket_no":"2604261723437311673103","queue_number":811,"trade_uid":"2604261723430071076274"}]}
2026-04-26 17:23:56 >>>故障排除日志:删除未同步下发订单成功2604261723430071076274
2026-04-26 17:23:56 >>>故障排除日志:删除未同步下发订单成功2604261723430071076274
2026-04-26 17:23:56 >>>故障排除日志:删除未同步下发订单成功2604261723430071076274
2026-04-26 17:23:56 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536876362]


===17:32:47===
2026-04-26 17:32:14>>>cash read=00
2026-04-26 17:32:15>>>cash read=818F42
2026-04-26 17:32:15>>>cash write=02
2026-04-26 17:32:15 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 17:32:15>>>cash read=10
2026-04-26 17:32:15 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 17:32:17>>>cash write=0C
2026-04-26 17:32:17>>>cash read=3E
2026-04-26 17:32:18>>>cash read=00
2026-04-26 17:32:19>>>cash read=2F29
2026-04-26 17:32:21>>>cash read=3E
2026-04-26 17:32:22>>>cash read=00
2026-04-26 17:32:22>>>cash read=818F40
2026-04-26 17:32:22>>>cash write=02
2026-04-26 17:32:22 >>>回调事件130,cash_status,10022,进钞中...read money=1
2026-04-26 17:32:23>>>cash read=10
2026-04-26 17:32:23 >>>回调事件130,1,10023,finish Money=1,进钞完成
2026-04-26 17:32:24>>>cash write=0C
2026-04-26 17:32:24>>>cash read=3E
2026-04-26 17:32:27>>>cash read=00
2026-04-26 17:32:28>>>cash read=818F40
2026-04-26 17:32:28>>>cash write=02
2026-04-26 17:32:28 >>>回调事件130,cash_status,10022,进钞中...read money=1
2026-04-26 17:32:28>>>cash read=10
2026-04-26 17:32:28 >>>回调事件130,1,10023,finish Money=1,进钞完成
2026-04-26 17:32:28 当前产品价格12元，投币12元，打印小票中...
2026-04-26 17:32:28 >>>开始打印,排队号为812,订单号为2604261732230014654938
2026-04-26 17:32:29>>>订单2604261732230014654938写入成功,剩余空间为1679000,占用RAM为641.0498046875
删除未同步订单2604261732230014654938
2026-04-26 17:32:31>>>订单2604261732230014654938删除成功,剩余空间为1679500,占用RAM为650.31640625
检测订单目录中>>>
无未同步订单>>>
2026-04-26 17:32:31 >>>当前Ram内存为619.5322265625
定时检测未同步订单启用[checkOrderNum=536876459]
2026-04-26 17:32:32>>>cash write=0C
2026-04-26 17:32:32>>>cash read=3E


===17:35:47===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 17:34:57 >>>回调事件[910,devices/TL4654]
2026-04-26 17:34:57 >>>故障排除日志:上一MQTT订单号缓存列表为2604261723430071076274|2604261723430071076274|2604261723430071076274
2026-04-26 17:34:57 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 17:34:57 开始打印,排队:813,票券:2604261734497223082701,订单:2604261734490069457327,[2026-04-26 17:34:57微信支付12元]
2026-04-26 17:34:57>>>MQTT票号同步场景，创建空订单对象
2026-04-26 17:34:57>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 17:34:59 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261734497223082701","queue_number":813,"trade_uid":"2604261734490069457327"}]}
2026-04-26 17:34:59 >>>故障排除日志:删除未同步下发订单成功2604261734490069457327
2026-04-26 17:34:59 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536876486]


===17:37:47===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 17:37:07 >>>回调事件[910,devices/TL4654]
2026-04-26 17:37:07 >>>故障排除日志:上一MQTT订单号缓存列表为2604261734490069457327
2026-04-26 17:37:07 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 17:37:07 开始打印,排队:814,票券:2604261736559503382801,订单:2604261736550092367136,[2026-04-26 17:37:07微信支付12元]
2026-04-26 17:37:07>>>MQTT票号同步场景，创建空订单对象
2026-04-26 17:37:07>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 17:37:09 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261736559503382801","queue_number":814,"trade_uid":"2604261736550092367136"}]}
2026-04-26 17:37:09 >>>故障排除日志:删除未同步下发订单成功2604261736550092367136
2026-04-26 17:37:09 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536876515]


===17:39:48===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 17:39:42 >>>回调事件[910,devices/TL4654]
2026-04-26 17:39:42 >>>故障排除日志:上一MQTT订单号缓存列表为2604261736550092367136
2026-04-26 17:39:42 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 17:39:42 开始打印,排队:815,票券:2604261739369207602601,订单:2604261739360090224882,[2026-04-26 17:39:41支付宝支付12元]
2026-04-26 17:39:42>>>MQTT票号同步场景，创建空订单对象
2026-04-26 17:39:42>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 17:39:44 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261739369207602601","queue_number":815,"trade_uid":"2604261739360090224882"}]}
2026-04-26 17:39:44 >>>故障排除日志:删除未同步下发订单成功2604261739360090224882
2026-04-26 17:39:44 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536876547]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 17:39:44 >>>回调事件[910,devices/TL4654]
2026-04-26 17:39:44 >>>故障排除日志:上一MQTT订单号缓存列表为2604261739360090224882
2026-04-26 17:39:44 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 17:39:44 开始打印,排队:816,票券:2604261739359447813701,订单:2604261739350092446772,[2026-04-26 17:39:44微信支付12元]
2026-04-26 17:39:44>>>MQTT票号同步场景，创建空订单对象
2026-04-26 17:39:44>>>合并MQTT票号列表到订单同步请求,共1张票


===17:45:48===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 17:45:01 >>>回调事件[910,devices/TL4654]
2026-04-26 17:45:01 >>>故障排除日志:上一MQTT订单号缓存列表为2604261739350092446772
2026-04-26 17:45:01 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 17:45:01 开始打印,排队:817,票券:2604261744546201521601,订单:2604261744540060028574,[2026-04-26 17:45:00微信支付12元]
2026-04-26 17:45:01>>>MQTT票号同步场景，创建空订单对象
2026-04-26 17:45:01>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 17:45:03 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261744546201521601","queue_number":817,"trade_uid":"2604261744540060028574"}]}
2026-04-26 17:45:03 >>>故障排除日志:删除未同步下发订单成功2604261744540060028574
2026-04-26 17:45:03 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536876608]


===17:48:48===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 17:48:43 >>>回调事件[910,devices/TL4654]
2026-04-26 17:48:43 >>>故障排除日志:上一MQTT订单号缓存列表为2604261744540060028574
2026-04-26 17:48:43 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 17:48:43 开始打印,排队:818,票券:2604261748372448512501,订单:2604261748370022552143,[2026-04-26 17:48:43微信支付12元]
2026-04-26 17:48:43 开始打印,排队:819,票券:2604261748372449013602,订单:2604261748370022552143,[2026-04-26 17:48:43微信支付12元]
2026-04-26 17:48:43>>>MQTT票号同步场景，创建空订单对象
2026-04-26 17:48:43>>>合并MQTT票号列表到订单同步请求,共2张票
2026-04-26 17:48:46 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261748372448512501","queue_number":818,"trade_uid":"2604261748370022552143"},{"ticket_no":"2604261748372449013602","queue_number":819,"trade_uid":"2604261748370022552143"}]}
2026-04-26 17:48:46 >>>故障排除日志:删除未同步下发订单成功2604261748370022552143
2026-04-26 17:48:46 >>>故障排除日志:删除未同步下发订单成功2604261748370022552143
2026-04-26 17:48:47 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536876650]


===17:55:49===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 17:55:29 >>>回调事件[910,devices/TL4654]
2026-04-26 17:55:29 >>>故障排除日志:上一MQTT订单号缓存列表为2604261748370022552143|2604261748370022552143
2026-04-26 17:55:29 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 17:55:29 开始打印,排队:820,票券:2604261755162167564601,订单:2604261755160019065065,[2026-04-26 17:55:28微信支付12元]
2026-04-26 17:55:29>>>MQTT票号同步场景，创建空订单对象
2026-04-26 17:55:29>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 17:55:31 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261755162167564601","queue_number":820,"trade_uid":"2604261755160019065065"}]}
2026-04-26 17:55:31 >>>故障排除日志:删除未同步下发订单成功2604261755160019065065
2026-04-26 17:55:31 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536876720]


===17:59:49===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 17:59:01 >>>回调事件[910,devices/TL4654]
2026-04-26 17:59:01 >>>故障排除日志:上一MQTT订单号缓存列表为2604261755160019065065
2026-04-26 17:59:01 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 17:59:01 开始打印,排队:821,票券:2604261758541929224301,订单:2604261758540017336228,[2026-04-26 17:59:01微信支付12元]
2026-04-26 17:59:01>>>MQTT票号同步场景，创建空订单对象
2026-04-26 17:59:01>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 17:59:03 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261758541929224301","queue_number":821,"trade_uid":"2604261758540017336228"}]}
2026-04-26 17:59:03 >>>故障排除日志:删除未同步下发订单成功2604261758540017336228
2026-04-26 17:59:03 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536876758]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 17:59:39 >>>回调事件[910,devices/TL4654]
2026-04-26 17:59:39 >>>故障排除日志:上一MQTT订单号缓存列表为2604261758540017336228
2026-04-26 17:59:39 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 17:59:39 开始打印,排队:822,票券:2604261759315999855401,订单:2604261759310058054982,[2026-04-26 17:59:39微信支付12元]
2026-04-26 17:59:40>>>MQTT票号同步场景，创建空订单对象
2026-04-26 17:59:40>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 17:59:42 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261759315999855401","queue_number":822,"trade_uid":"2604261759310058054982"}]}
2026-04-26 17:59:42 >>>故障排除日志:删除未同步下发订单成功2604261759310058054982
2026-04-26 17:59:42 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536876770]


===18:00:49===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 18:00:00 >>>回调事件[910,devices/TL4654]
2026-04-26 18:00:00 >>>故障排除日志:上一MQTT订单号缓存列表为2604261759310058054982
2026-04-26 18:00:00 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 18:00:00 开始打印,排队:823,票券:2604261759511254715601,订单:2604261759510010575996,[2026-04-26 17:59:59微信支付12元]
2026-04-26 18:00:00>>>MQTT票号同步场景，创建空订单对象
2026-04-26 18:00:00>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 18:00:02 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261759511254715601","queue_number":823,"trade_uid":"2604261759510010575996"}]}
2026-04-26 18:00:02 >>>故障排除日志:删除未同步下发订单成功2604261759510010575996
2026-04-26 18:00:02 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536876780]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 18:00:33 >>>回调事件[910,devices/TL4654]
2026-04-26 18:00:33 >>>故障排除日志:上一MQTT订单号缓存列表为2604261759510010575996
2026-04-26 18:00:33 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 18:00:33 开始打印,排队:824,票券:2604261800180498107601,订单:2604261800180001633641,[2026-04-26 18:00:32微信支付12元]
2026-04-26 18:00:33>>>MQTT票号同步场景，创建空订单对象
2026-04-26 18:00:34>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 18:00:35 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261800180498107601","queue_number":824,"trade_uid":"2604261800180001633641"}]}
2026-04-26 18:00:35 >>>故障排除日志:删除未同步下发订单成功2604261800180001633641
2026-04-26 18:00:36 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536876793]


===18:05:50===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 18:05:05 >>>回调事件[910,devices/TL4654]
2026-04-26 18:05:05 >>>故障排除日志:上一MQTT订单号缓存列表为2604261800180001633641
2026-04-26 18:05:05 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 18:05:05 开始打印,排队:825,票券:2604261804463553045401,订单:2604261804460033630143,[2026-04-26 18:05:04微信支付12元]
2026-04-26 18:05:05>>>MQTT票号同步场景，创建空订单对象
2026-04-26 18:05:05>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 18:05:07 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261804463553045401","queue_number":825,"trade_uid":"2604261804460033630143"}]}
2026-04-26 18:05:07 >>>故障排除日志:删除未同步下发订单成功2604261804460033630143
2026-04-26 18:05:07 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536876840]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 18:05:46 >>>回调事件[910,devices/TL4654]
2026-04-26 18:05:46 >>>故障排除日志:上一MQTT订单号缓存列表为2604261804460033630143
2026-04-26 18:05:46 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 18:05:46 开始打印,排队:826,票券:2604261805419246312701,订单:2604261805410090277029,[2026-04-26 18:05:46微信支付12元]
2026-04-26 18:05:46>>>MQTT票号同步场景，创建空订单对象
2026-04-26 18:05:46>>>合并MQTT票号列表到订单同步请求,共1张票


===18:07:50===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 18:07:30 >>>回调事件[910,devices/TL4654]
2026-04-26 18:07:31 >>>故障排除日志:上一MQTT订单号缓存列表为2604261805410090277029
2026-04-26 18:07:31 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 18:07:31 开始打印,排队:827,票券:2604261807234686602701,订单:2604261807230044688457,[2026-04-26 18:07:30微信支付12元]
2026-04-26 18:07:31>>>MQTT票号同步场景，创建空订单对象
2026-04-26 18:07:31>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 18:07:33 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261807234686602701","queue_number":827,"trade_uid":"2604261807230044688457"}]}
2026-04-26 18:07:33 >>>故障排除日志:删除未同步下发订单成功2604261807230044688457
2026-04-26 18:07:33 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536876878]


===18:09:50===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 18:09:15 >>>回调事件[910,devices/TL4654]
2026-04-26 18:09:15 >>>故障排除日志:上一MQTT订单号缓存列表为2604261807230044688457
2026-04-26 18:09:15 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 18:09:15 开始打印,排队:828,票券:2604261809060414586501,订单:2604261809060002140029,[2026-04-26 18:09:14微信支付12元]
2026-04-26 18:09:15>>>MQTT票号同步场景，创建空订单对象
2026-04-26 18:09:15>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 18:09:17 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261809060414586501","queue_number":828,"trade_uid":"2604261809060002140029"}]}
2026-04-26 18:09:17 >>>故障排除日志:删除未同步下发订单成功2604261809060002140029
2026-04-26 18:09:17 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536876904]


===18:10:50===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 18:10:10 >>>回调事件[910,devices/TL4654]
2026-04-26 18:10:10 >>>故障排除日志:上一MQTT订单号缓存列表为2604261809060002140029
2026-04-26 18:10:10 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 18:10:10 开始打印,排队:829,票券:2604261809591028392901,订单:2604261809590007419373,[2026-04-26 18:10:09微信支付12元]
2026-04-26 18:10:10>>>MQTT票号同步场景，创建空订单对象
2026-04-26 18:10:10>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 18:10:12 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261809591028392901","queue_number":829,"trade_uid":"2604261809590007419373"}]}
2026-04-26 18:10:12 >>>故障排除日志:删除未同步下发订单成功2604261809590007419373
2026-04-26 18:10:12 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536876915]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 18:10:22 >>>回调事件[910,devices/TL4654]
2026-04-26 18:10:22 >>>故障排除日志:上一MQTT订单号缓存列表为2604261809590007419373
2026-04-26 18:10:22 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 18:10:22 开始打印,排队:830,票券:2604261810171103215301,订单:2604261810170009161486,[2026-04-26 18:10:22支付宝支付12元]
2026-04-26 18:10:22>>>MQTT票号同步场景，创建空订单对象
2026-04-26 18:10:22>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 18:10:24 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261810171103215301","queue_number":830,"trade_uid":"2604261810170009161486"}]}
2026-04-26 18:10:24 >>>故障排除日志:删除未同步下发订单成功2604261810170009161486
2026-04-26 18:10:25 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536876927]


===18:16:51===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 18:16:43 >>>回调事件[910,devices/TL4654]
2026-04-26 18:16:43 >>>故障排除日志:上一MQTT订单号缓存列表为2604261810170009161486
2026-04-26 18:16:43 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 18:16:43 开始打印,排队:831,票券:2604261816340169993701,订单:2604261816330099901363,[2026-04-26 18:16:42微信支付12元]
2026-04-26 18:16:43>>>MQTT票号同步场景，创建空订单对象
2026-04-26 18:16:43>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 18:16:45 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261816340169993701","queue_number":831,"trade_uid":"2604261816330099901363"}]}
2026-04-26 18:16:45 >>>故障排除日志:删除未同步下发订单成功2604261816330099901363
2026-04-26 18:16:45 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536876989]


===18:17:53===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 18:17:49 >>>回调事件[910,devices/TL4654]
2026-04-26 18:17:49 >>>故障排除日志:上一MQTT订单号缓存列表为2604261816330099901363
2026-04-26 18:17:49 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 18:17:49 开始打印,排队:832,票券:2604261817419400462701,订单:2604261817410092105267,[2026-04-26 18:17:49微信支付12元]
2026-04-26 18:17:49>>>MQTT票号同步场景，创建空订单对象
2026-04-26 18:17:49>>>合并MQTT票号列表到订单同步请求,共1张票


===18:18:53===
2026-04-26 18:17:51 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261817419400462701","queue_number":832,"trade_uid":"2604261817410092105267"}]}
2026-04-26 18:17:51 >>>故障排除日志:删除未同步下发订单成功2604261817410092105267
2026-04-26 18:17:51 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877009]


===18:20:53===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 18:20:19 >>>回调事件[910,devices/TL4654]
2026-04-26 18:20:19 >>>故障排除日志:上一MQTT订单号缓存列表为2604261817410092105267
2026-04-26 18:20:19 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 18:20:19 开始打印,排队:833,票券:2604261820127538088601,订单:2604261820120073548156,[2026-04-26 18:20:18微信支付12元]
2026-04-26 18:20:19>>>MQTT票号同步场景，创建空订单对象
2026-04-26 18:20:19>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 18:20:21 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261820127538088601","queue_number":833,"trade_uid":"2604261820120073548156"}]}
2026-04-26 18:20:21 >>>故障排除日志:删除未同步下发订单成功2604261820120073548156
2026-04-26 18:20:21 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877043]


===18:21:53===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 18:21:27 >>>回调事件[910,devices/TL4654]
2026-04-26 18:21:27 >>>故障排除日志:上一MQTT订单号缓存列表为2604261820120073548156
2026-04-26 18:21:27 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 18:21:27 开始打印,排队:834,票券:2604261821196747634601,订单:2604261821190065425845,[2026-04-26 18:21:27微信支付12元]
2026-04-26 18:21:27>>>MQTT票号同步场景，创建空订单对象
2026-04-26 18:21:27>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 18:21:29 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261821196747634601","queue_number":834,"trade_uid":"2604261821190065425845"}]}
2026-04-26 18:21:29 >>>故障排除日志:删除未同步下发订单成功2604261821190065425845
2026-04-26 18:21:29 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877060]


===18:26:54===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 18:26:16 >>>回调事件[910,devices/TL4654]
2026-04-26 18:26:16 >>>故障排除日志:上一MQTT订单号缓存列表为2604261821190065425845
2026-04-26 18:26:16 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 18:26:16 开始打印,排队:835,票券:2604261826070263313401,订单:2604261826060099700171,[2026-04-26 18:26:15微信支付12元]
2026-04-26 18:26:16>>>MQTT票号同步场景，创建空订单对象
2026-04-26 18:26:16>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 18:26:18 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261826070263313401","queue_number":835,"trade_uid":"2604261826060099700171"}]}
2026-04-26 18:26:18 >>>故障排除日志:删除未同步下发订单成功2604261826060099700171
2026-04-26 18:26:18 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877112]


===18:27:54===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 18:27:34 >>>回调事件[910,devices/TL4654]
2026-04-26 18:27:34 >>>故障排除日志:上一MQTT订单号缓存列表为2604261826060099700171
2026-04-26 18:27:34 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 18:27:34 开始打印,排队:836,票券:2604261827230826205101,订单:2604261827230006065779,[2026-04-26 18:27:33微信支付12元]
2026-04-26 18:27:34>>>MQTT票号同步场景，创建空订单对象
2026-04-26 18:27:34>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 18:27:36 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261827230826205101","queue_number":836,"trade_uid":"2604261827230006065779"}]}
2026-04-26 18:27:36 >>>故障排除日志:删除未同步下发订单成功2604261827230006065779
2026-04-26 18:27:36 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877130]


===18:31:54===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 18:31:13 >>>回调事件[910,devices/TL4654]
2026-04-26 18:31:13 >>>故障排除日志:上一MQTT订单号缓存列表为2604261827230006065779
2026-04-26 18:31:13 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 18:31:13 开始打印,排队:837,票券:2604261831006815372301,订单:2604261831000066124297,[2026-04-26 18:31:12微信支付12元]
2026-04-26 18:31:13>>>MQTT票号同步场景，创建空订单对象
2026-04-26 18:31:13>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 18:31:15 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261831006815372301","queue_number":837,"trade_uid":"2604261831000066124297"}]}
2026-04-26 18:31:15 >>>故障排除日志:删除未同步下发订单成功2604261831000066124297
2026-04-26 18:31:15 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877173]


===18:33:54===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 18:32:56 >>>回调事件[910,devices/TL4654]
2026-04-26 18:32:56 >>>故障排除日志:上一MQTT订单号缓存列表为2604261831000066124297
2026-04-26 18:32:56 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 18:32:56 开始打印,排队:838,票券:2604261832451837805901,订单:2604261832450016113726,[2026-04-26 18:32:57微信支付12元]
2026-04-26 18:32:57>>>MQTT票号同步场景，创建空订单对象
2026-04-26 18:32:57>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 18:32:59 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261832451837805901","queue_number":838,"trade_uid":"2604261832450016113726"}]}
2026-04-26 18:32:59 >>>故障排除日志:删除未同步下发订单成功2604261832450016113726
2026-04-26 18:32:59 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877192]


===18:40:55===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 18:40:33 >>>回调事件[910,devices/TL4654]
2026-04-26 18:40:33 >>>故障排除日志:上一MQTT订单号缓存列表为2604261832450016113726
2026-04-26 18:40:33 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 18:40:33 开始打印,排队:839,票券:2604261840254516714701,订单:2604261840250043496664,[2026-04-26 18:40:33微信支付12元]
2026-04-26 18:40:34>>>MQTT票号同步场景，创建空订单对象
2026-04-26 18:40:34>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 18:40:36 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261840254516714701","queue_number":839,"trade_uid":"2604261840250043496664"}]}
2026-04-26 18:40:36 >>>故障排除日志:删除未同步下发订单成功2604261840250043496664
2026-04-26 18:40:36 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877271]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 18:40:43 >>>回调事件[910,devices/TL4654]
2026-04-26 18:40:43 >>>故障排除日志:上一MQTT订单号缓存列表为2604261840250043496664
2026-04-26 18:40:43 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 18:40:43 开始打印,排队:840,票券:2604261840347497232801,订单:2604261840340072189468,[2026-04-26 18:40:43微信支付12元]
2026-04-26 18:40:43>>>MQTT票号同步场景，创建空订单对象
2026-04-26 18:40:43>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 18:40:45 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261840347497232801","queue_number":840,"trade_uid":"2604261840340072189468"}]}
2026-04-26 18:40:45 >>>故障排除日志:删除未同步下发订单成功2604261840340072189468
2026-04-26 18:40:45 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877277]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 18:40:48 >>>回调事件[910,devices/TL4654]
2026-04-26 18:40:48 >>>故障排除日志:上一MQTT订单号缓存列表为2604261840340072189468
2026-04-26 18:40:48 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 18:40:48 开始打印,排队:841,票券:2604261840392974238101,订单:2604261840390025926365,[2026-04-26 18:40:48微信支付12元]
2026-04-26 18:40:48>>>MQTT票号同步场景，创建空订单对象
2026-04-26 18:40:48>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 18:40:50 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261840392974238101","queue_number":841,"trade_uid":"2604261840390025926365"}]}
2026-04-26 18:40:50 >>>故障排除日志:删除未同步下发订单成功2604261840390025926365
2026-04-26 18:40:50 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877283]


===18:45:55===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 18:45:10 >>>回调事件[910,devices/TL4654]
2026-04-26 18:45:10 >>>故障排除日志:上一MQTT订单号缓存列表为2604261840390025926365
2026-04-26 18:45:10 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 18:45:10 开始打印,排队:842,票券:2604261845017814025101,订单:2604261845010076023857,[2026-04-26 18:45:10微信支付12元]
2026-04-26 18:45:10>>>MQTT票号同步场景，创建空订单对象
2026-04-26 18:45:10>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 18:45:12 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261845017814025101","queue_number":842,"trade_uid":"2604261845010076023857"}]}
2026-04-26 18:45:12 >>>故障排除日志:删除未同步下发订单成功2604261845010076023857
2026-04-26 18:45:12 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877330]


===18:48:55===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 18:48:25 >>>回调事件[910,devices/TL4654]
2026-04-26 18:48:25 >>>故障排除日志:上一MQTT订单号缓存列表为2604261845010076023857
2026-04-26 18:48:25 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 18:48:26 开始打印,排队:843,票券:2604261847534371195801,订单:2604261847530041972675,[2026-04-26 18:48:25微信支付12元]
2026-04-26 18:48:26>>>MQTT票号同步场景，创建空订单对象
2026-04-26 18:48:26>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 18:48:28 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261847534371195801","queue_number":843,"trade_uid":"2604261847530041972675"}]}
2026-04-26 18:48:28 >>>故障排除日志:删除未同步下发订单成功2604261847530041972675
2026-04-26 18:48:28 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877370]


===18:49:56===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 18:49:00 >>>回调事件[910,devices/TL4654]
2026-04-26 18:49:00 >>>故障排除日志:上一MQTT订单号缓存列表为2604261847530041972675
2026-04-26 18:49:00 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 18:49:00 开始打印,排队:844,票券:2604261848528310785101,订单:2604261848520081210643,[2026-04-26 18:49:00微信支付12元]
2026-04-26 18:49:00>>>MQTT票号同步场景，创建空订单对象
2026-04-26 18:49:00>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 18:49:02 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261848528310785101","queue_number":844,"trade_uid":"2604261848520081210643"}]}
2026-04-26 18:49:02 >>>故障排除日志:删除未同步下发订单成功2604261848520081210643
2026-04-26 18:49:02 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877381]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 18:49:18 >>>回调事件[910,devices/TL4654]
2026-04-26 18:49:18 >>>故障排除日志:上一MQTT订单号缓存列表为2604261848520081210643
2026-04-26 18:49:18 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 18:49:18 开始打印,排队:845,票券:2604261849110026117501,订单:2604261849100098017118,[2026-04-26 18:49:18微信支付12元]
2026-04-26 18:49:18>>>MQTT票号同步场景，创建空订单对象
2026-04-26 18:49:18>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 18:49:20 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261849110026117501","queue_number":845,"trade_uid":"2604261849100098017118"}]}
2026-04-26 18:49:20 >>>故障排除日志:删除未同步下发订单成功2604261849100098017118
2026-04-26 18:49:20 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877393]


===18:50:56===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 18:50:11 >>>回调事件[910,devices/TL4654]
2026-04-26 18:50:11 >>>故障排除日志:上一MQTT订单号缓存列表为2604261849100098017118
2026-04-26 18:50:11 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 18:50:11 开始打印,排队:846,票券:2604261850036616124501,订单:2604261850030062980925,[2026-04-26 18:50:11微信支付12元]
2026-04-26 18:50:11>>>MQTT票号同步场景，创建空订单对象
2026-04-26 18:50:11>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 18:50:13 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261850036616124501","queue_number":846,"trade_uid":"2604261850030062980925"}]}
2026-04-26 18:50:13 >>>故障排除日志:删除未同步下发订单成功2604261850030062980925
2026-04-26 18:50:13 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877405]


===18:51:56===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 18:51:36 >>>回调事件[910,devices/TL4654]
2026-04-26 18:51:36 >>>故障排除日志:上一MQTT订单号缓存列表为2604261850030062980925
2026-04-26 18:51:36 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 18:51:36 开始打印,排队:847,票券:2604261851296811148701,订单:2604261851290066230921,[2026-04-26 18:51:36微信支付12元]
2026-04-26 18:51:36>>>MQTT票号同步场景，创建空订单对象
2026-04-26 18:51:36>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 18:51:38 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261851296811148701","queue_number":847,"trade_uid":"2604261851290066230921"}]}
2026-04-26 18:51:38 >>>故障排除日志:删除未同步下发订单成功2604261851290066230921
2026-04-26 18:51:38 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877428]


===18:54:56===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 18:54:24 >>>回调事件[910,devices/TL4654]
2026-04-26 18:54:24 >>>故障排除日志:上一MQTT订单号缓存列表为2604261851290066230921
2026-04-26 18:54:24 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 18:54:24 开始打印,排队:848,票券:2604261854151493013201,订单:2604261854150012963592,[2026-04-26 18:54:23支付宝支付12元]
2026-04-26 18:54:24>>>MQTT票号同步场景，创建空订单对象
2026-04-26 18:54:24>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 18:54:26 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261854151493013201","queue_number":848,"trade_uid":"2604261854150012963592"}]}
2026-04-26 18:54:26 >>>故障排除日志:删除未同步下发订单成功2604261854150012963592
2026-04-26 18:54:26 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877462]


===18:57:57===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 18:57:36 >>>回调事件[910,devices/TL4654]
2026-04-26 18:57:36 >>>故障排除日志:上一MQTT订单号缓存列表为2604261854150012963592
2026-04-26 18:57:36 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 18:57:36 开始打印,排队:849,票券:2604261857312732002901,订单:2604261857310025405664,[2026-04-26 18:57:36微信支付12元]
2026-04-26 18:57:37>>>MQTT票号同步场景，创建空订单对象
2026-04-26 18:57:37>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 18:57:39 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261857312732002901","queue_number":849,"trade_uid":"2604261857310025405664"}]}
2026-04-26 18:57:39 >>>故障排除日志:删除未同步下发订单成功2604261857310025405664
2026-04-26 18:57:39 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877498]


===19:00:57===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:00:54 >>>回调事件[910,devices/TL4654]
2026-04-26 19:00:54 >>>故障排除日志:上一MQTT订单号缓存列表为2604261857310025405664
2026-04-26 19:00:54 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 19:00:54 开始打印,排队:850,票券:2604261900455548753801,订单:2604261900450053402473,[2026-04-26 19:00:53微信支付12元]
2026-04-26 19:00:54>>>MQTT票号同步场景，创建空订单对象
2026-04-26 19:00:54>>>合并MQTT票号列表到订单同步请求,共1张票


===19:01:58===
2026-04-26 19:00:56 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261900455548753801","queue_number":850,"trade_uid":"2604261900450053402473"}]}
2026-04-26 19:00:56 >>>故障排除日志:删除未同步下发订单成功2604261900450053402473
2026-04-26 19:00:56 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877535]


===19:02:58===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:02:25 >>>回调事件[910,devices/TL4654]
2026-04-26 19:02:25 >>>故障排除日志:上一MQTT订单号缓存列表为2604261900450053402473
2026-04-26 19:02:25 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 19:02:25 开始打印,排队:851,票券:2604261902185107311601,订单:2604261902180048962635,[2026-04-26 19:02:25微信支付12元]
2026-04-26 19:02:25>>>MQTT票号同步场景，创建空订单对象
2026-04-26 19:02:25>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 19:02:27 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261902185107311601","queue_number":851,"trade_uid":"2604261902180048962635"}]}
2026-04-26 19:02:27 >>>故障排除日志:删除未同步下发订单成功2604261902180048962635
2026-04-26 19:02:27 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877560]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:02:49 >>>回调事件[910,devices/TL4654]
2026-04-26 19:02:49 >>>故障排除日志:上一MQTT订单号缓存列表为2604261902180048962635
2026-04-26 19:02:49 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 19:02:49 开始打印,排队:852,票券:2604261902432631435701,订单:2604261902430024481296,[2026-04-26 19:02:49微信支付12元]
2026-04-26 19:02:49>>>MQTT票号同步场景，创建空订单对象
2026-04-26 19:02:49>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 19:02:51 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261902432631435701","queue_number":852,"trade_uid":"2604261902430024481296"}]}
2026-04-26 19:02:51 >>>故障排除日志:删除未同步下发订单成功2604261902430024481296
2026-04-26 19:02:51 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877567]


===19:03:58===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:03:24 >>>回调事件[910,devices/TL4654]
2026-04-26 19:03:24 >>>故障排除日志:上一MQTT订单号缓存列表为2604261902430024481296
2026-04-26 19:03:24 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 19:03:24 开始打印,排队:853,票券:2604261903156718772601,订单:2604261903150064575936,[2026-04-26 19:03:24微信支付12元]
2026-04-26 19:03:24>>>MQTT票号同步场景，创建空订单对象
2026-04-26 19:03:24>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 19:03:26 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261903156718772601","queue_number":853,"trade_uid":"2604261903150064575936"}]}
2026-04-26 19:03:26 >>>故障排除日志:删除未同步下发订单成功2604261903150064575936
2026-04-26 19:03:26 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877583]


===19:04:58===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:04:36 >>>回调事件[910,devices/TL4654]
2026-04-26 19:04:36 >>>故障排除日志:上一MQTT订单号缓存列表为2604261903150064575936
2026-04-26 19:04:36 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 19:04:36 开始打印,排队:854,票券:2604261904251799725401,订单:2604261904250015544763,[2026-04-26 19:04:36微信支付12元]
2026-04-26 19:04:36>>>MQTT票号同步场景，创建空订单对象
2026-04-26 19:04:36>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 19:04:38 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261904251799725401","queue_number":854,"trade_uid":"2604261904250015544763"}]}
2026-04-26 19:04:38 >>>故障排除日志:删除未同步下发订单成功2604261904250015544763
2026-04-26 19:04:38 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877601]


===19:05:59===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:05:28 >>>回调事件[910,devices/TL4654]
2026-04-26 19:05:28 >>>故障排除日志:上一MQTT订单号缓存列表为2604261904250015544763
2026-04-26 19:05:28 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 19:05:28 开始打印,排队:855,票券:2604261905197607956701,订单:2604261905190074335347,[2026-04-26 19:05:28微信支付12元]
2026-04-26 19:05:28>>>MQTT票号同步场景，创建空订单对象
2026-04-26 19:05:28>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 19:05:30 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261905197607956701","queue_number":855,"trade_uid":"2604261905190074335347"}]}
2026-04-26 19:05:30 >>>故障排除日志:删除未同步下发订单成功2604261905190074335347
2026-04-26 19:05:30 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877617]


===19:07:59===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:07:32 >>>回调事件[910,devices/TL4654]
2026-04-26 19:07:32 >>>故障排除日志:上一MQTT订单号缓存列表为2604261905190074335347
2026-04-26 19:07:32 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 19:07:32 开始打印,排队:856,票券:2604261907222654772501,订单:2604261907220024696368,[2026-04-26 19:07:32微信支付12元]
2026-04-26 19:07:33>>>MQTT票号同步场景，创建空订单对象
2026-04-26 19:07:33>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 19:07:34 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261907222654772501","queue_number":856,"trade_uid":"2604261907220024696368"}]}
2026-04-26 19:07:34 >>>故障排除日志:删除未同步下发订单成功2604261907220024696368
2026-04-26 19:07:35 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877643]


===19:10:00===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:09:31 >>>回调事件[910,devices/TL4654]
2026-04-26 19:09:31 >>>故障排除日志:上一MQTT订单号缓存列表为2604261907220024696368
2026-04-26 19:09:31 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 19:09:31 开始打印,排队:857,票券:2604261909237958347801,订单:2604261909230077348254,[2026-04-26 19:09:31微信支付12元]
2026-04-26 19:09:32>>>MQTT票号同步场景，创建空订单对象
2026-04-26 19:09:32>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 19:09:33 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261909237958347801","queue_number":857,"trade_uid":"2604261909230077348254"}]}
2026-04-26 19:09:33 >>>故障排除日志:删除未同步下发订单成功2604261909230077348254
2026-04-26 19:09:34 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877669]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:09:56 >>>回调事件[910,devices/TL4654]
2026-04-26 19:09:56 >>>故障排除日志:上一MQTT订单号缓存列表为2604261909230077348254
2026-04-26 19:09:56 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 19:09:56 开始打印,排队:858,票券:2604261909451964458601,订单:2604261909450016270263,[2026-04-26 19:09:56微信支付12元]
2026-04-26 19:09:56>>>MQTT票号同步场景，创建空订单对象
2026-04-26 19:09:57>>>合并MQTT票号列表到订单同步请求,共1张票


===19:11:00===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:10:26 >>>回调事件[910,devices/TL4654]
2026-04-26 19:10:26 >>>故障排除日志:上一MQTT订单号缓存列表为2604261909450016270263
2026-04-26 19:10:26 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 19:10:26 开始打印,排队:859,票券:2604261910198020141501,订单:2604261910190078183586,[2026-04-26 19:10:26微信支付12元]
2026-04-26 19:10:26>>>MQTT票号同步场景，创建空订单对象
2026-04-26 19:10:26>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 19:10:28 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261910198020141501","queue_number":859,"trade_uid":"2604261910190078183586"}]}
2026-04-26 19:10:28 >>>故障排除日志:删除未同步下发订单成功2604261910190078183586
2026-04-26 19:10:28 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877692]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:10:46 >>>回调事件[910,devices/TL4654]
2026-04-26 19:10:46 >>>故障排除日志:上一MQTT订单号缓存列表为2604261910190078183586
2026-04-26 19:10:46 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 19:10:46 开始打印,排队:860,票券:2604261910399450594101,订单:2604261910390092490674,[2026-04-26 19:10:46微信支付12元]
2026-04-26 19:10:47>>>MQTT票号同步场景，创建空订单对象
2026-04-26 19:10:47>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 19:10:49 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261910399450594101","queue_number":860,"trade_uid":"2604261910390092490674"}]}
2026-04-26 19:10:49 >>>故障排除日志:删除未同步下发订单成功2604261910390092490674
2026-04-26 19:10:49 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877699]


===19:20:01===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:19:30 >>>回调事件[910,devices/TL4654]
2026-04-26 19:19:30 >>>故障排除日志:上一MQTT订单号缓存列表为2604261910390092490674
2026-04-26 19:19:30 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 19:19:30 开始打印,排队:861,票券:2604261919216821259501,订单:2604261919210064580346,[2026-04-26 19:19:29微信支付12元]
2026-04-26 19:19:30>>>MQTT票号同步场景，创建空订单对象
2026-04-26 19:19:30>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 19:19:32 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261919216821259501","queue_number":861,"trade_uid":"2604261919210064580346"}]}
2026-04-26 19:19:32 >>>故障排除日志:删除未同步下发订单成功2604261919210064580346
2026-04-26 19:19:32 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877787]


===19:21:01===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:20:18 >>>回调事件[910,devices/TL4654]
2026-04-26 19:20:18 >>>故障排除日志:上一MQTT订单号缓存列表为2604261919210064580346
2026-04-26 19:20:18 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 19:20:18 开始打印,排队:862,票券:2604261920106836134201,订单:2604261920100066447092,[2026-04-26 19:20:17微信支付12元]
2026-04-26 19:20:18>>>MQTT票号同步场景，创建空订单对象
2026-04-26 19:20:18>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 19:20:20 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261920106836134201","queue_number":862,"trade_uid":"2604261920100066447092"}]}
2026-04-26 19:20:20 >>>故障排除日志:删除未同步下发订单成功2604261920100066447092
2026-04-26 19:20:20 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877804]


===19:22:01===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:21:13 >>>回调事件[910,devices/TL4654]
2026-04-26 19:21:13 >>>故障排除日志:上一MQTT订单号缓存列表为2604261920100066447092
2026-04-26 19:21:13 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 19:21:13 开始打印,排队:863,票券:2604261921065544275601,订单:2604261921060053023661,[2026-04-26 19:21:13微信支付12元]
2026-04-26 19:21:13>>>MQTT票号同步场景，创建空订单对象
2026-04-26 19:21:13>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 19:21:15 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261921065544275601","queue_number":863,"trade_uid":"2604261921060053023661"}]}
2026-04-26 19:21:15 >>>故障排除日志:删除未同步下发订单成功2604261921060053023661
2026-04-26 19:21:15 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877821]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:21:43 >>>回调事件[910,devices/TL4654]
2026-04-26 19:21:43 >>>故障排除日志:上一MQTT订单号缓存列表为2604261921060053023661
2026-04-26 19:21:43 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 19:21:43 开始打印,排队:864,票券:2604261921340174705201,订单:2604261921330099434154,[2026-04-26 19:21:43微信支付12元]
2026-04-26 19:21:43>>>MQTT票号同步场景，创建空订单对象
2026-04-26 19:21:43>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 19:21:45 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261921340174705201","queue_number":864,"trade_uid":"2604261921330099434154"}]}
2026-04-26 19:21:45 >>>故障排除日志:删除未同步下发订单成功2604261921330099434154
2026-04-26 19:21:45 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877828]


===19:23:02===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:22:16 >>>回调事件[910,devices/TL4654]
2026-04-26 19:22:16 >>>故障排除日志:上一MQTT订单号缓存列表为2604261921330099434154
2026-04-26 19:22:16 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 19:22:16 开始打印,排队:865,票券:2604261922064289144601,订单:2604261922060040734574,[2026-04-26 19:22:16微信支付12元]
2026-04-26 19:22:16>>>MQTT票号同步场景，创建空订单对象
2026-04-26 19:22:16>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 19:22:18 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261922064289144601","queue_number":865,"trade_uid":"2604261922060040734574"}]}
2026-04-26 19:22:18 >>>故障排除日志:删除未同步下发订单成功2604261922060040734574
2026-04-26 19:22:18 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877844]


===19:24:02===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:23:31 >>>回调事件[910,devices/TL4654]
2026-04-26 19:23:31 >>>故障排除日志:上一MQTT订单号缓存列表为2604261922060040734574
2026-04-26 19:23:31 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 19:23:31 开始打印,排队:866,票券:2604261923233400301501,订单:2604261923230032200461,[2026-04-26 19:23:30微信支付12元]
2026-04-26 19:23:31>>>MQTT票号同步场景，创建空订单对象
2026-04-26 19:23:31>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 19:23:33 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261923233400301501","queue_number":866,"trade_uid":"2604261923230032200461"}]}
2026-04-26 19:23:33 >>>故障排除日志:删除未同步下发订单成功2604261923230032200461
2026-04-26 19:23:33 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877861]


===19:25:02===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:24:09 >>>回调事件[910,devices/TL4654]
2026-04-26 19:24:09 >>>故障排除日志:上一MQTT订单号缓存列表为2604261923230032200461
2026-04-26 19:24:09 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 19:24:09 开始打印,排队:867,票券:2604261924019106252301,订单:2604261924010083133491,[2026-04-26 19:24:08微信支付12元]
2026-04-26 19:24:09>>>MQTT票号同步场景，创建空订单对象
2026-04-26 19:24:09>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 19:24:11 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261924019106252301","queue_number":867,"trade_uid":"2604261924010083133491"}]}
2026-04-26 19:24:11 >>>故障排除日志:删除未同步下发订单成功2604261924010083133491
2026-04-26 19:24:11 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877873]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:24:33 >>>回调事件[910,devices/TL4654]
2026-04-26 19:24:33 >>>故障排除日志:上一MQTT订单号缓存列表为2604261924010083133491
2026-04-26 19:24:33 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 19:24:33 开始打印,排队:868,票券:2604261924275782901901,订单:2604261924270056066712,[2026-04-26 19:24:33微信支付12元]
2026-04-26 19:24:33>>>MQTT票号同步场景，创建空订单对象
2026-04-26 19:24:33>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 19:24:35 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261924275782901901","queue_number":868,"trade_uid":"2604261924270056066712"}]}
2026-04-26 19:24:35 >>>故障排除日志:删除未同步下发订单成功2604261924270056066712
2026-04-26 19:24:35 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877884]


===19:29:03===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:28:02 >>>回调事件[910,devices/TL4654]
2026-04-26 19:28:02 >>>故障排除日志:上一MQTT订单号缓存列表为2604261924270056066712
2026-04-26 19:28:02 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 19:28:02 开始打印,排队:869,票券:2604261927555094094801,订单:2604261927550049083814,[2026-04-26 19:28:01支付宝支付12元]
2026-04-26 19:28:02>>>MQTT票号同步场景，创建空订单对象
2026-04-26 19:28:02>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 19:28:04 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261927555094094801","queue_number":869,"trade_uid":"2604261927550049083814"}]}
2026-04-26 19:28:04 >>>故障排除日志:删除未同步下发订单成功2604261927550049083814
2026-04-26 19:28:04 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877922]


===19:34:03===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:33:06 >>>回调事件[910,devices/TL4654]
2026-04-26 19:33:06 >>>故障排除日志:上一MQTT订单号缓存列表为2604261927550049083814
2026-04-26 19:33:06 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 19:33:06 开始打印,排队:870,票券:2604261932586951337601,订单:2604261932580067468668,[2026-04-26 19:33:06支付宝支付12元]
2026-04-26 19:33:07>>>MQTT票号同步场景，创建空订单对象
2026-04-26 19:33:07>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 19:33:09 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261932586951337601","queue_number":870,"trade_uid":"2604261932580067468668"}]}
2026-04-26 19:33:09 >>>故障排除日志:删除未同步下发订单成功2604261932580067468668
2026-04-26 19:33:09 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877975]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:33:29 >>>回调事件[910,devices/TL4654]
2026-04-26 19:33:29 >>>故障排除日志:上一MQTT订单号缓存列表为2604261932580067468668
2026-04-26 19:33:29 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 19:33:29 开始打印,排队:871,票券:2604261933222139224901,订单:2604261933220019278825,[2026-04-26 19:33:28微信支付12元]
2026-04-26 19:33:29>>>MQTT票号同步场景，创建空订单对象
2026-04-26 19:33:29>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 19:33:31 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261933222139224901","queue_number":871,"trade_uid":"2604261933220019278825"}]}
2026-04-26 19:33:31 >>>故障排除日志:删除未同步下发订单成功2604261933220019278825
2026-04-26 19:33:31 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877987]


===19:39:04===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:38:38 >>>回调事件[910,devices/TL4654]
2026-04-26 19:38:38 >>>故障排除日志:上一MQTT订单号缓存列表为2604261933220019278825
2026-04-26 19:38:38 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 19:38:38 开始打印,排队:872,票券:2604261938286027078201,订单:2604261938280058288161,[2026-04-26 19:38:37微信支付12元]
2026-04-26 19:38:38>>>MQTT票号同步场景，创建空订单对象
2026-04-26 19:38:38>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 19:38:40 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261938286027078201","queue_number":872,"trade_uid":"2604261938280058288161"}]}
2026-04-26 19:38:40 >>>故障排除日志:删除未同步下发订单成功2604261938280058288161
2026-04-26 19:38:40 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878040]


===19:40:04===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:39:44 >>>回调事件[910,devices/TL4654]
2026-04-26 19:39:44 >>>故障排除日志:上一MQTT订单号缓存列表为2604261938280058288161
2026-04-26 19:39:44 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 19:39:44 开始打印,排队:873,票券:2604261939360381964301,订单:2604261939360001441945,[2026-04-26 19:39:44微信支付12元]
2026-04-26 19:39:44>>>MQTT票号同步场景，创建空订单对象
2026-04-26 19:39:44>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 19:39:46 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261939360381964301","queue_number":873,"trade_uid":"2604261939360001441945"}]}
2026-04-26 19:39:46 >>>故障排除日志:删除未同步下发订单成功2604261939360001441945
2026-04-26 19:39:46 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878058]


===19:41:04===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:40:45 >>>回调事件[910,devices/TL4654]
2026-04-26 19:40:45 >>>故障排除日志:上一MQTT订单号缓存列表为2604261939360001441945
2026-04-26 19:40:45 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 19:40:45 开始打印,排队:874,票券:2604261940369177187201,订单:2604261940360088203684,[2026-04-26 19:40:45微信支付12元]
2026-04-26 19:40:45>>>MQTT票号同步场景，创建空订单对象
2026-04-26 19:40:45>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 19:40:47 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261940369177187201","queue_number":874,"trade_uid":"2604261940360088203684"}]}
2026-04-26 19:40:47 >>>故障排除日志:删除未同步下发订单成功2604261940360088203684
2026-04-26 19:40:47 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878074]


===19:42:05===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:41:17 >>>回调事件[910,devices/TL4654]
2026-04-26 19:41:17 >>>故障排除日志:上一MQTT订单号缓存列表为2604261940360088203684
2026-04-26 19:41:17 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 19:41:17 开始打印,排队:875,票券:2604261941092436438701,订单:2604261941090020442228,[2026-04-26 19:41:17微信支付12元]
2026-04-26 19:41:17>>>MQTT票号同步场景，创建空订单对象
2026-04-26 19:41:17>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 19:41:19 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261941092436438701","queue_number":875,"trade_uid":"2604261941090020442228"}]}
2026-04-26 19:41:19 >>>故障排除日志:删除未同步下发订单成功2604261941090020442228
2026-04-26 19:41:19 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878091]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:41:59 >>>回调事件[910,devices/TL4654]
2026-04-26 19:41:59 >>>故障排除日志:上一MQTT订单号缓存列表为2604261941090020442228
2026-04-26 19:41:59 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 19:41:59 开始打印,排队:876,票券:2604261941512368401601,订单:2604261941510021619938,[2026-04-26 19:41:59微信支付12元]
2026-04-26 19:41:59 开始打印,排队:877,票券:2604261941512368829302,订单:2604261941510021619938,[2026-04-26 19:41:59微信支付12元]
2026-04-26 19:42:00>>>MQTT票号同步场景，创建空订单对象
2026-04-26 19:42:00>>>合并MQTT票号列表到订单同步请求,共2张票


===19:44:05===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:43:07 >>>回调事件[910,devices/TL4654]
2026-04-26 19:43:07 >>>故障排除日志:上一MQTT订单号缓存列表为2604261941510021619938|2604261941510021619938
2026-04-26 19:43:07 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 19:43:07 开始打印,排队:878,票券:2604261943005634904701,订单:2604261943000050540848,[2026-04-26 19:43:06微信支付12元]
2026-04-26 19:43:07>>>MQTT票号同步场景，创建空订单对象
2026-04-26 19:43:07>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 19:43:09 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261943005634904701","queue_number":878,"trade_uid":"2604261943000050540848"}]}
2026-04-26 19:43:09 >>>故障排除日志:删除未同步下发订单成功2604261943000050540848
2026-04-26 19:43:09 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878117]


===19:49:05===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:48:53 >>>回调事件[910,devices/TL4654]
2026-04-26 19:48:53 >>>故障排除日志:上一MQTT订单号缓存列表为2604261943000050540848
2026-04-26 19:48:53 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 19:48:53 开始打印,排队:879,票券:2604261948438537294301,订单:2604261948430083268325,[2026-04-26 19:48:53微信支付12元]
2026-04-26 19:48:53>>>MQTT票号同步场景，创建空订单对象
2026-04-26 19:48:53>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 19:48:55 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261948438537294301","queue_number":879,"trade_uid":"2604261948430083268325"}]}
2026-04-26 19:48:55 >>>故障排除日志:删除未同步下发订单成功2604261948430083268325
2026-04-26 19:48:55 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878177]


===19:51:06===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:50:55 >>>回调事件[910,devices/TL4654]
2026-04-26 19:50:55 >>>故障排除日志:上一MQTT订单号缓存列表为2604261948430083268325
2026-04-26 19:50:55 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 19:50:55 开始打印,排队:880,票券:2604261950496608583601,订单:2604261950490063057063,[2026-04-26 19:50:55微信支付12元]
2026-04-26 19:50:55>>>MQTT票号同步场景，创建空订单对象
2026-04-26 19:50:55>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 19:50:57 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261950496608583601","queue_number":880,"trade_uid":"2604261950490063057063"}]}
2026-04-26 19:50:57 >>>故障排除日志:删除未同步下发订单成功2604261950490063057063
2026-04-26 19:50:57 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878203]


===19:57:07===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:56:12 >>>回调事件[910,devices/TL4654]
2026-04-26 19:56:12 >>>故障排除日志:上一MQTT订单号缓存列表为2604261950490063057063
2026-04-26 19:56:12 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 19:56:12 开始打印,排队:881,票券:2604261956047445382801,订单:2604261956040071953768,[2026-04-26 19:56:11微信支付12元]
2026-04-26 19:56:12 开始打印,排队:882,票券:2604261956047445962302,订单:2604261956040071953768,[2026-04-26 19:56:11微信支付12元]
2026-04-26 19:56:12>>>MQTT票号同步场景，创建空订单对象
2026-04-26 19:56:12>>>合并MQTT票号列表到订单同步请求,共2张票
2026-04-26 19:56:16 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261956047445382801","queue_number":881,"trade_uid":"2604261956040071953768"},{"ticket_no":"2604261956047445962302","queue_number":882,"trade_uid":"2604261956040071953768"}]}
2026-04-26 19:56:16 >>>故障排除日志:删除未同步下发订单成功2604261956040071953768
2026-04-26 19:56:16 >>>故障排除日志:删除未同步下发订单成功2604261956040071953768
2026-04-26 19:56:16 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878263]


===19:59:07===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:58:48 >>>回调事件[910,devices/TL4654]
2026-04-26 19:58:48 >>>故障排除日志:上一MQTT订单号缓存列表为2604261956040071953768|2604261956040071953768
2026-04-26 19:58:48 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 19:58:48 开始打印,排队:883,票券:2604261958388542564301,订单:2604261958380083105852,[2026-04-26 19:58:47微信支付12元]
2026-04-26 19:58:48>>>MQTT票号同步场景，创建空订单对象
2026-04-26 19:58:48>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 19:58:50 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261958388542564301","queue_number":883,"trade_uid":"2604261958380083105852"}]}
2026-04-26 19:58:50 >>>故障排除日志:删除未同步下发订单成功2604261958380083105852
2026-04-26 19:58:50 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878290]


===20:00:07===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:59:33 >>>回调事件[910,devices/TL4654]
2026-04-26 19:59:33 >>>故障排除日志:上一MQTT订单号缓存列表为2604261958380083105852
2026-04-26 19:59:33 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 19:59:33 开始打印,排队:884,票券:2604261959258880528401,订单:2604261959250086773494,[2026-04-26 19:59:33微信支付12元]
2026-04-26 19:59:33>>>MQTT票号同步场景，创建空订单对象
2026-04-26 19:59:33>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 19:59:35 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261959258880528401","queue_number":884,"trade_uid":"2604261959250086773494"}]}
2026-04-26 19:59:35 >>>故障排除日志:删除未同步下发订单成功2604261959250086773494
2026-04-26 19:59:36 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878307]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:59:56 >>>回调事件[910,devices/TL4654]
2026-04-26 19:59:56 >>>故障排除日志:上一MQTT订单号缓存列表为2604261959250086773494
2026-04-26 19:59:56 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 19:59:56 开始打印,排队:885,票券:2604261959476597998501,订单:2604261959470062770142,[2026-04-26 19:59:56支付宝支付12元]
2026-04-26 19:59:56>>>MQTT票号同步场景，创建空订单对象
2026-04-26 19:59:56>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 19:59:58 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261959476597998501","queue_number":885,"trade_uid":"2604261959470062770142"}]}
2026-04-26 19:59:58 >>>故障排除日志:删除未同步下发订单成功2604261959470062770142
2026-04-26 19:59:58 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878314]


===20:07:07===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 20:06:44 >>>回调事件[910,devices/TL4654]
2026-04-26 20:06:44 >>>故障排除日志:上一MQTT订单号缓存列表为2604261959470062770142
2026-04-26 20:06:44 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 20:06:44 开始打印,排队:886,票券:2604262006382990118701,订单:2604262006380025608342,[2026-04-26 20:06:43支付宝支付12元]
2026-04-26 20:06:44>>>MQTT票号同步场景，创建空订单对象
2026-04-26 20:06:44>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 20:06:46 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604262006382990118701","queue_number":886,"trade_uid":"2604262006380025608342"}]}
2026-04-26 20:06:46 >>>故障排除日志:删除未同步下发订单成功2604262006380025608342
2026-04-26 20:06:46 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878384]


===20:10:08===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 20:09:26 >>>回调事件[910,devices/TL4654]
2026-04-26 20:09:26 >>>故障排除日志:上一MQTT订单号缓存列表为2604262006380025608342
2026-04-26 20:09:26 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 20:09:26 开始打印,排队:887,票券:2604262009199944207901,订单:2604262009190097525618,[2026-04-26 20:09:26微信支付12元]
2026-04-26 20:09:26>>>MQTT票号同步场景，创建空订单对象
2026-04-26 20:09:26>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 20:09:28 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604262009199944207901","queue_number":887,"trade_uid":"2604262009190097525618"}]}
2026-04-26 20:09:28 >>>故障排除日志:删除未同步下发订单成功2604262009190097525618
2026-04-26 20:09:29 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878419]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 20:09:49 >>>回调事件[910,devices/TL4654]
2026-04-26 20:09:49 >>>故障排除日志:上一MQTT订单号缓存列表为2604262009190097525618
2026-04-26 20:09:49 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 20:09:49 开始打印,排队:888,票券:2604262009407516278601,订单:2604262009400072821958,[2026-04-26 20:09:48微信支付12元]
2026-04-26 20:09:49>>>MQTT票号同步场景，创建空订单对象
2026-04-26 20:09:49>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 20:09:51 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604262009407516278601","queue_number":888,"trade_uid":"2604262009400072821958"}]}
2026-04-26 20:09:51 >>>故障排除日志:删除未同步下发订单成功2604262009400072821958
2026-04-26 20:09:51 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878425]


===20:19:08===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 20:18:43 >>>回调事件[910,devices/TL4654]
2026-04-26 20:18:43 >>>故障排除日志:上一MQTT订单号缓存列表为2604262009400072821958
2026-04-26 20:18:43 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 20:18:43 开始打印,排队:889,票券:2604262018401604016101,订单:2604262018400014226753,[2026-04-26 20:18:43支付宝支付12元]
2026-04-26 20:18:43>>>MQTT票号同步场景，创建空订单对象
2026-04-26 20:18:43>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 20:18:45 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604262018401604016101","queue_number":889,"trade_uid":"2604262018400014226753"}]}
2026-04-26 20:18:45 >>>故障排除日志:删除未同步下发订单成功2604262018400014226753
2026-04-26 20:18:45 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878514]


===20:24:08===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 20:23:25 >>>回调事件[910,devices/TL4654]
2026-04-26 20:23:25 >>>故障排除日志:上一MQTT订单号缓存列表为2604262018400014226753
2026-04-26 20:23:25 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 20:23:25 开始打印,排队:890,票券:2604262023185587463401,订单:2604262023180053993287,[2026-04-26 20:23:25微信支付12元]
2026-04-26 20:23:25>>>MQTT票号同步场景，创建空订单对象
2026-04-26 20:23:25>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 20:23:27 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604262023185587463401","queue_number":890,"trade_uid":"2604262023180053993287"}]}
2026-04-26 20:23:27 >>>故障排除日志:删除未同步下发订单成功2604262023180053993287
2026-04-26 20:23:28 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878566]


===20:25:08===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 20:24:53 >>>回调事件[910,devices/TL4654]
2026-04-26 20:24:53 >>>故障排除日志:上一MQTT订单号缓存列表为2604262023180053993287
2026-04-26 20:24:53 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 20:24:53 开始打印,排队:891,票券:2604262024430426806501,订单:2604262024430002266996,[2026-04-26 20:24:53微信支付12元]
2026-04-26 20:24:53>>>MQTT票号同步场景，创建空订单对象
2026-04-26 20:24:53>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 20:24:55 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604262024430426806501","queue_number":891,"trade_uid":"2604262024430002266996"}]}
2026-04-26 20:24:55 >>>故障排除日志:删除未同步下发订单成功2604262024430002266996
2026-04-26 20:24:55 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878584]


===20:26:09===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 20:25:56 >>>回调事件[910,devices/TL4654]
2026-04-26 20:25:56 >>>故障排除日志:上一MQTT订单号缓存列表为2604262024430002266996
2026-04-26 20:25:56 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 20:25:56 开始打印,排队:892,票券:2604262025466140576101,订单:2604262025460059544578,[2026-04-26 20:25:55微信支付12元]
2026-04-26 20:25:56>>>MQTT票号同步场景，创建空订单对象
2026-04-26 20:25:56>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 20:25:58 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604262025466140576101","queue_number":892,"trade_uid":"2604262025460059544578"}]}
2026-04-26 20:25:58 >>>故障排除日志:删除未同步下发订单成功2604262025460059544578
2026-04-26 20:25:58 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878601]


===20:28:10===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 20:27:34 >>>回调事件[910,devices/TL4654]
2026-04-26 20:27:34 >>>故障排除日志:上一MQTT订单号缓存列表为2604262025460059544578
2026-04-26 20:27:34 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 20:27:34 开始打印,排队:893,票券:2604262027292254085401,订单:2604262027290020767434,[2026-04-26 20:27:34支付宝支付12元]
2026-04-26 20:27:34>>>MQTT票号同步场景，创建空订单对象
2026-04-26 20:27:34>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 20:27:36 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604262027292254085401","queue_number":893,"trade_uid":"2604262027290020767434"}]}
2026-04-26 20:27:36 >>>故障排除日志:删除未同步下发订单成功2604262027290020767434
2026-04-26 20:27:37 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878627]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 20:27:47 >>>回调事件[910,devices/TL4654]
2026-04-26 20:27:47 >>>故障排除日志:上一MQTT订单号缓存列表为2604262027290020767434
2026-04-26 20:27:47 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 20:27:47 开始打印,排队:894,票券:2604262027424841108601,订单:2604262027420046616283,[2026-04-26 20:27:47微信支付12元]
2026-04-26 20:27:47 开始打印,排队:895,票券:2604262027424841631702,订单:2604262027420046616283,[2026-04-26 20:27:47微信支付12元]
2026-04-26 20:27:47>>>MQTT票号同步场景，创建空订单对象
2026-04-26 20:27:47>>>合并MQTT票号列表到订单同步请求,共2张票
2026-04-26 20:27:51 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604262027424841108601","queue_number":894,"trade_uid":"2604262027420046616283"},{"ticket_no":"2604262027424841631702","queue_number":895,"trade_uid":"2604262027420046616283"}]}
2026-04-26 20:27:51 >>>故障排除日志:删除未同步下发订单成功2604262027420046616283
2026-04-26 20:27:51 >>>故障排除日志:删除未同步下发订单成功2604262027420046616283
2026-04-26 20:27:51 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878633]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 20:28:06 >>>回调事件[910,devices/TL4654]
2026-04-26 20:28:06 >>>故障排除日志:上一MQTT订单号缓存列表为2604262027420046616283|2604262027420046616283
2026-04-26 20:28:06 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 20:28:06 开始打印,排队:896,票券:2604262027583981798901,订单:2604262027580037953253,[2026-04-26 20:28:06支付宝支付12元]
2026-04-26 20:28:06>>>MQTT票号同步场景，创建空订单对象
2026-04-26 20:28:06>>>合并MQTT票号列表到订单同步请求,共1张票


===20:36:10===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 20:35:50 >>>回调事件[910,devices/TL4654]
2026-04-26 20:35:50 >>>故障排除日志:上一MQTT订单号缓存列表为2604262027580037953253
2026-04-26 20:35:50 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 20:35:50 开始打印,排队:897,票券:2604262035410412447901,订单:2604262035410001751317,[2026-04-26 20:35:50微信支付12元]
2026-04-26 20:35:50>>>MQTT票号同步场景，创建空订单对象
2026-04-26 20:35:50>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 20:35:52 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604262035410412447901","queue_number":897,"trade_uid":"2604262035410001751317"}]}
2026-04-26 20:35:52 >>>故障排除日志:删除未同步下发订单成功2604262035410001751317
2026-04-26 20:35:52 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878719]


===20:38:11===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 20:37:34 >>>回调事件[910,devices/TL4654]
2026-04-26 20:37:34 >>>故障排除日志:上一MQTT订单号缓存列表为2604262035410001751317
2026-04-26 20:37:34 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 20:37:34 开始打印,排队:898,票券:2604262037152947361201,订单:2604262037150027728531,[2026-04-26 20:37:34微信支付12元]
2026-04-26 20:37:34>>>MQTT票号同步场景，创建空订单对象
2026-04-26 20:37:34>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 20:37:36 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604262037152947361201","queue_number":898,"trade_uid":"2604262037150027728531"}]}
2026-04-26 20:37:36 >>>故障排除日志:删除未同步下发订单成功2604262037150027728531
2026-04-26 20:37:36 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878744]


===20:41:11===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 20:40:42 >>>回调事件[910,devices/TL4654]
2026-04-26 20:40:42 >>>故障排除日志:上一MQTT订单号缓存列表为2604262037150027728531
2026-04-26 20:40:42 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 20:40:42 开始打印,排队:899,票券:2604262040355505435301,订单:2604262040350053200769,[2026-04-26 20:40:42微信支付12元]
2026-04-26 20:40:42>>>MQTT票号同步场景，创建空订单对象
2026-04-26 20:40:42>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 20:40:44 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604262040355505435301","queue_number":899,"trade_uid":"2604262040350053200769"}]}
2026-04-26 20:40:44 >>>故障排除日志:删除未同步下发订单成功2604262040350053200769
2026-04-26 20:40:44 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878780]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 20:41:00 >>>回调事件[910,devices/TL4654]
2026-04-26 20:41:00 >>>故障排除日志:上一MQTT订单号缓存列表为2604262040350053200769
2026-04-26 20:41:00 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 20:41:00 开始打印,排队:900,票券:2604262040524338829201,订单:2604262040520041627945,[2026-04-26 20:41:00微信支付12元]
2026-04-26 20:41:00>>>MQTT票号同步场景，创建空订单对象
2026-04-26 20:41:00>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 20:41:02 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604262040524338829201","queue_number":900,"trade_uid":"2604262040520041627945"}]}
2026-04-26 20:41:02 >>>故障排除日志:删除未同步下发订单成功2604262040520041627945
2026-04-26 20:41:02 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878788]


===20:43:11===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 20:42:23 >>>回调事件[910,devices/TL4654]
2026-04-26 20:42:23 >>>故障排除日志:上一MQTT订单号缓存列表为2604262040520041627945
2026-04-26 20:42:23 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 20:42:23 开始打印,排队:901,票券:2604262042165504217401,订单:2604262042160053119895,[2026-04-26 20:42:23微信支付12元]
2026-04-26 20:42:23>>>MQTT票号同步场景，创建空订单对象
2026-04-26 20:42:23>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 20:42:25 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604262042165504217401","queue_number":901,"trade_uid":"2604262042160053119895"}]}
2026-04-26 20:42:25 >>>故障排除日志:删除未同步下发订单成功2604262042160053119895
2026-04-26 20:42:25 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878811]


===20:52:11===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 20:51:34 >>>回调事件[910,devices/TL4654]
2026-04-26 20:51:34 >>>故障排除日志:上一MQTT订单号缓存列表为2604262042160053119895
2026-04-26 20:51:34 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 20:51:34 开始打印,排队:902,票券:2604262051275698204901,订单:2604262051270054506264,[2026-04-26 20:51:34微信支付12元]
2026-04-26 20:51:34 开始打印,排队:903,票券:2604262051275698774902,订单:2604262051270054506264,[2026-04-26 20:51:34微信支付12元]
2026-04-26 20:51:34>>>MQTT票号同步场景，创建空订单对象
2026-04-26 20:51:34>>>合并MQTT票号列表到订单同步请求,共2张票
2026-04-26 20:51:38 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604262051275698204901","queue_number":902,"trade_uid":"2604262051270054506264"},{"ticket_no":"2604262051275698774902","queue_number":903,"trade_uid":"2604262051270054506264"}]}
2026-04-26 20:51:38 >>>故障排除日志:删除未同步下发订单成功2604262051270054506264
2026-04-26 20:51:38 >>>故障排除日志:删除未同步下发订单成功2604262051270054506264
2026-04-26 20:51:38 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878900]


===20:54:12===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 20:53:12 >>>回调事件[910,devices/TL4654]
2026-04-26 20:53:12 >>>故障排除日志:上一MQTT订单号缓存列表为2604262051270054506264|2604262051270054506264
2026-04-26 20:53:12 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 20:53:12 开始打印,排队:904,票券:2604262053023736967101,订单:2604262053020035378156,[2026-04-26 20:53:11微信支付12元]
2026-04-26 20:53:12>>>MQTT票号同步场景，创建空订单对象
2026-04-26 20:53:12>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 20:53:14 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604262053023736967101","queue_number":904,"trade_uid":"2604262053020035378156"}]}
2026-04-26 20:53:14 >>>故障排除日志:删除未同步下发订单成功2604262053020035378156
2026-04-26 20:53:14 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878921]


===20:59:12===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 20:58:22 >>>回调事件[910,devices/TL4654]
2026-04-26 20:58:22 >>>故障排除日志:上一MQTT订单号缓存列表为2604262053020035378156
2026-04-26 20:58:22 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 20:58:22 开始打印,排队:905,票券:2604262058136404563901,订单:2604262058130062098045,[2026-04-26 20:58:22微信支付12元]
2026-04-26 20:58:22>>>MQTT票号同步场景，创建空订单对象
2026-04-26 20:58:22>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 20:58:24 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604262058136404563901","queue_number":905,"trade_uid":"2604262058130062098045"}]}
2026-04-26 20:58:24 >>>故障排除日志:删除未同步下发订单成功2604262058130062098045
2026-04-26 20:58:24 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878979]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 20:58:37 >>>回调事件[910,devices/TL4654]
2026-04-26 20:58:37 >>>故障排除日志:上一MQTT订单号缓存列表为2604262058130062098045
2026-04-26 20:58:37 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 20:58:37 开始打印,排队:906,票券:2604262058293963423101,订单:2604262058290035968641,[2026-04-26 20:58:37微信支付12元]
2026-04-26 20:58:37>>>MQTT票号同步场景，创建空订单对象
2026-04-26 20:58:37>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 20:58:39 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604262058293963423101","queue_number":906,"trade_uid":"2604262058290035968641"}]}
2026-04-26 20:58:39 >>>故障排除日志:删除未同步下发订单成功2604262058290035968641
2026-04-26 20:58:39 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878985]


===21:04:12===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 21:03:29 >>>回调事件[910,devices/TL4654]
2026-04-26 21:03:29 >>>故障排除日志:上一MQTT订单号缓存列表为2604262058290035968641
2026-04-26 21:03:29 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 21:03:29 开始打印,排队:907,票券:2604262103202323713501,订单:2604262103200021180192,[2026-04-26 21:03:29微信支付12元]
2026-04-26 21:03:30>>>MQTT票号同步场景，创建空订单对象
2026-04-26 21:03:30>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 21:03:32 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604262103202323713501","queue_number":907,"trade_uid":"2604262103200021180192"}]}
2026-04-26 21:03:32 >>>故障排除日志:删除未同步下发订单成功2604262103200021180192
2026-04-26 21:03:32 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536879038]


===21:06:13===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 21:06:07 >>>回调事件[910,devices/TL4654]
2026-04-26 21:06:07 >>>故障排除日志:上一MQTT订单号缓存列表为2604262103200021180192
2026-04-26 21:06:07 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 21:06:07 开始打印,排队:908,票券:2604262106010194514801,订单:2604262106010000177284,[2026-04-26 21:06:06微信支付12元]
2026-04-26 21:06:07>>>MQTT票号同步场景，创建空订单对象
2026-04-26 21:06:07>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 21:06:09 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604262106010194514801","queue_number":908,"trade_uid":"2604262106010000177284"}]}
2026-04-26 21:06:09 >>>故障排除日志:删除未同步下发订单成功2604262106010000177284
2026-04-26 21:06:09 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536879067]


===21:10:13===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 21:10:03 >>>回调事件[910,devices/TL4654]
2026-04-26 21:10:03 >>>故障排除日志:上一MQTT订单号缓存列表为2604262106010000177284
2026-04-26 21:10:03 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 21:10:03 开始打印,排队:909,票券:2604262109544609238601,订单:2604262109540044223968,[2026-04-26 21:10:02微信支付12元]
2026-04-26 21:10:03>>>MQTT票号同步场景，创建空订单对象
2026-04-26 21:10:03>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 21:10:05 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604262109544609238601","queue_number":909,"trade_uid":"2604262109540044223968"}]}
2026-04-26 21:10:05 >>>故障排除日志:删除未同步下发订单成功2604262109540044223968
2026-04-26 21:10:05 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536879111]


===21:11:13===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 21:10:48 >>>回调事件[910,devices/TL4654]
2026-04-26 21:10:48 >>>故障排除日志:上一MQTT订单号缓存列表为2604262109540044223968
2026-04-26 21:10:48 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 21:10:48 开始打印,排队:910,票券:2604262110371517184901,订单:2604262110370013140945,[2026-04-26 21:10:48支付宝支付12元]
2026-04-26 21:10:48>>>MQTT票号同步场景，创建空订单对象
2026-04-26 21:10:48>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 21:10:50 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604262110371517184901","queue_number":910,"trade_uid":"2604262110370013140945"}]}
2026-04-26 21:10:50 >>>故障排除日志:删除未同步下发订单成功2604262110370013140945
2026-04-26 21:10:50 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536879126]


===21:14:13===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 21:13:14 >>>回调事件[910,devices/TL4654]
2026-04-26 21:13:14 >>>故障排除日志:上一MQTT订单号缓存列表为2604262110370013140945
2026-04-26 21:13:14 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 21:13:14 开始打印,排队:911,票券:2604262112547288168401,订单:2604262112540070813689,[2026-04-26 21:13:14微信支付12元]
2026-04-26 21:13:14>>>MQTT票号同步场景，创建空订单对象
2026-04-26 21:13:14>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 21:13:16 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604262112547288168401","queue_number":911,"trade_uid":"2604262112540070813689"}]}
2026-04-26 21:13:16 >>>故障排除日志:删除未同步下发订单成功2604262112540070813689
2026-04-26 21:13:16 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536879159]


===21:20:14===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 21:19:23 >>>回调事件[910,devices/TL4654]
2026-04-26 21:19:23 >>>故障排除日志:上一MQTT订单号缓存列表为2604262112540070813689
2026-04-26 21:19:23 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 21:19:23 开始打印,排队:912,票券:2604262119168858268501,订单:2604262119160086303621,[2026-04-26 21:19:23支付宝支付12元]
2026-04-26 21:19:23>>>MQTT票号同步场景，创建空订单对象
2026-04-26 21:19:23>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 21:19:25 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604262119168858268501","queue_number":912,"trade_uid":"2604262119160086303621"}]}
2026-04-26 21:19:25 >>>故障排除日志:删除未同步下发订单成功2604262119160086303621
2026-04-26 21:19:25 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536879222]


===21:24:14===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 21:23:23 >>>回调事件[910,devices/TL4654]
2026-04-26 21:23:23 >>>故障排除日志:上一MQTT订单号缓存列表为2604262119160086303621
2026-04-26 21:23:23 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 21:23:23 开始打印,排队:913,票券:2604262123161266958101,订单:2604262123160010768585,[2026-04-26 21:23:23微信支付12元]
2026-04-26 21:23:23>>>MQTT票号同步场景，创建空订单对象
2026-04-26 21:23:23>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 21:23:25 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604262123161266958101","queue_number":913,"trade_uid":"2604262123160010768585"}]}
2026-04-26 21:23:25 >>>故障排除日志:删除未同步下发订单成功2604262123160010768585
2026-04-26 21:23:25 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536879266]
2026-04-26 21:23:29>>>cash read=00
2026-04-26 21:23:30>>>cash read=818F42
2026-04-26 21:23:30>>>cash write=02
2026-04-26 21:23:30 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 21:23:30>>>cash read=10
2026-04-26 21:23:30 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 21:23:32>>>cash write=0C
2026-04-26 21:23:32>>>cash read=3E
2026-04-26 21:23:34>>>cash read=29
2026-04-26 21:23:34 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 21:23:35>>>cash read=00
2026-04-26 21:23:36>>>cash read=818F40
2026-04-26 21:23:36>>>cash write=02
2026-04-26 21:23:36 >>>回调事件130,cash_status,10022,进钞中...read money=1
2026-04-26 21:23:36>>>cash read=10
2026-04-26 21:23:36 >>>回调事件130,1,10023,finish Money=1,进钞完成
2026-04-26 21:23:38>>>cash write=0C
2026-04-26 21:23:38>>>cash read=00818F40
2026-04-26 21:23:38>>>cash write=02
2026-04-26 21:23:38 >>>回调事件130,cash_status,10022,进钞中...read money=1
2026-04-26 21:23:38>>>cash read=10
2026-04-26 21:23:38 >>>回调事件130,1,10023,finish Money=1,进钞完成
2026-04-26 21:23:38 当前产品价格12元，投币12元，打印小票中...
2026-04-26 21:23:38 >>>开始打印,排队号为914,订单号为2604262123360014654846
2026-04-26 21:23:39>>>订单2604262123360014654846写入成功,剩余空间为1678000,占用RAM为643.322265625
删除未同步订单2604262123360014654846
2026-04-26 21:23:41>>>订单2604262123360014654846删除成功,剩余空间为1678500,占用RAM为649.7841796875
检测订单目录中>>>
无未同步订单>>>
2026-04-26 21:23:41 >>>当前Ram内存为617.439453125
定时检测未同步订单启用[checkOrderNum=536879281]
2026-04-26 21:23:42>>>cash write=0C
2026-04-26 21:23:42>>>cash read=3E


===21:28:14===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 21:28:08 >>>回调事件[910,devices/TL4654]
2026-04-26 21:28:08 >>>故障排除日志:上一MQTT订单号缓存列表为2604262123160010768585
2026-04-26 21:28:08 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 21:28:08 开始打印,排队:915,票券:2604262128007680904301,订单:2604262128000074890764,[2026-04-26 21:28:07微信支付12元]
2026-04-26 21:28:08>>>MQTT票号同步场景，创建空订单对象
2026-04-26 21:28:08>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 21:28:10 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604262128007680904301","queue_number":915,"trade_uid":"2604262128000074890764"}]}
2026-04-26 21:28:10 >>>故障排除日志:删除未同步下发订单成功2604262128000074890764
2026-04-26 21:28:10 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536879328]


===21:30:14===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 21:29:51 >>>回调事件[910,devices/TL4654]
2026-04-26 21:29:51 >>>故障排除日志:上一MQTT订单号缓存列表为2604262128000074890764
2026-04-26 21:29:51 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 21:29:51 开始打印,排队:916,票券:2604262129298947524701,订单:2604262129290087639469,[2026-04-26 21:29:50微信支付12元]
2026-04-26 21:29:51>>>MQTT票号同步场景，创建空订单对象
2026-04-26 21:29:51>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 21:29:53 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604262129298947524701","queue_number":916,"trade_uid":"2604262129290087639469"}]}
2026-04-26 21:29:53 >>>故障排除日志:删除未同步下发订单成功2604262129290087639469
2026-04-26 21:29:53 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536879352]


===21:34:15===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 21:33:43 >>>回调事件[910,devices/TL4654]
2026-04-26 21:33:43 >>>故障排除日志:上一MQTT订单号缓存列表为2604262129290087639469
2026-04-26 21:33:43 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 21:33:43 开始打印,排队:917,票券:2604262133354788079101,订单:2604262133350045331861,[2026-04-26 21:33:42微信支付12元]
2026-04-26 21:33:43>>>MQTT票号同步场景，创建空订单对象
2026-04-26 21:33:43>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 21:33:45 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604262133354788079101","queue_number":917,"trade_uid":"2604262133350045331861"}]}
2026-04-26 21:33:45 >>>故障排除日志:删除未同步下发订单成功2604262133350045331861
2026-04-26 21:33:45 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536879395]


===21:39:15===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 21:38:22 >>>回调事件[910,devices/TL4654]
2026-04-26 21:38:22 >>>故障排除日志:上一MQTT订单号缓存列表为2604262133350045331861
2026-04-26 21:38:22 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 21:38:22 开始打印,排队:918,票券:2604262138163774888101,订单:2604262138160035755559,[2026-04-26 21:38:22支付宝支付12元]
2026-04-26 21:38:22>>>MQTT票号同步场景，创建空订单对象
2026-04-26 21:38:22>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 21:38:24 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604262138163774888101","queue_number":918,"trade_uid":"2604262138160035755559"}]}
2026-04-26 21:38:24 >>>故障排除日志:删除未同步下发订单成功2604262138160035755559
2026-04-26 21:38:24 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536879447]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 21:38:24 >>>回调事件[910,devices/TL4654]
2026-04-26 21:38:24 >>>故障排除日志:上一MQTT订单号缓存列表为2604262138160035755559
2026-04-26 21:38:24 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 21:38:24 开始打印,排队:919,票券:2604262138146982192701,订单:2604262138140066675629,[2026-04-26 21:38:24支付宝支付12元]
已接收过此消息,且为空,票券号为2604262138163774888101,排队号为-1
2026-04-26 21:38:24>>>MQTT票号同步场景，创建空订单对象
2026-04-26 21:38:24>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 21:38:26 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604262138146982192701","queue_number":919,"trade_uid":"2604262138140066675629"}]}
2026-04-26 21:38:26 >>>故障排除日志:删除未同步下发订单成功2604262138140066675629
2026-04-26 21:38:27 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536879452]