TLClient_JSSCOM_LuatOS-Air_V4010_RDA8910_RFTTS_0xe0000,2.8.6,866250069008492,61498311252067,
poweron reason:0

===08:59:44===
上一时间戳为1777079039
隔日重置时间戳true
隔日清空未同步下发列表true
当前排队号为1,音量为0
初始化产品信息:[{"time_limit_date":null,"ticket_category":"0","expiry_date":90,"product_detail":"此票券当天有效，过期作废。","time_limit_status":"0","begin_minute":null,"product_uid":"6803180199228943530","use_timer":1,"old_price":"15","end_hour":null,"sale_price":"15","end_minute":null,"begin_hour":null,"sale_status":1,"product_name":"剪发"}]
打印门店标题设置为快剪
是否打印二维码设置为1
是否打印紧凑设置为3
当前号显示模式设置为1
当前卡项核销权限设置为0
session_id:546f9****7a04f
纸币器设置接收纸币范围为36
欢迎使用天羚自助售票系统[2.8.6]
定时检测未同步订单启用[checkOrderNum=536870969]
2026-04-26 08:58:43>>>cash write=30
2026-04-26 08:58:43>>>cash write=02
2026-04-26 08:58:43>>>cash write=3E
2026-04-26 08:58:43>>>cash read=808F808F808F808F
系统时间初始化成功，时间为202642685843
2026-04-26 08:58:44>>>cash write=02
2026-04-26 08:58:44 >>>剩余flash空间=1680000,占用RAM为658.46484375
2026-04-26 08:58:44 >>>回调事件:910,subscribe,10000,连接服务器成功

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

2026-04-26 08:58:47>>>cash write=0C
2026-04-26 08:58:47>>>cash read=3E
流量卡还有217天过期
2026-04-26 08:58:51 >>>当前Ram内存为644.1845703125
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 08:59:18 >>>回调事件[910,devices/S4737]
当日首次设置时间戳true为1777165158
2026-04-26 08:59:18 >>>故障排除日志:上一MQTT订单号缓存列表为2604252142230014450671
2026-04-26 08:59:18 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 08:59:18 开始打印,排队:1,票券:2604260859108614064901,订单:2604260859100083418163,[2026-04-26 08:59:18微信支付15元]
2026-04-26 08:59:18>>>MQTT票号同步场景，创建空订单对象
2026-04-26 08:59:18>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 08:59:20 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604260859108614064901","queue_number":1,"trade_uid":"2604260859100083418163"}]}
2026-04-26 08:59:20 >>>故障排除日志:删除未同步下发订单成功2604260859100083418163
2026-04-26 08:59:20 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536870986]


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


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


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


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


===09:22:45===
2026-04-26 09:22:38>>>cash read=9E
2026-04-26 09:22:40>>>cash read=3E


===09:27:45===
2026-04-26 09:27:02>>>cash read=9E
2026-04-26 09:27:03>>>cash read=3E


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


===12:30:53===
2026-04-26 12:30:46>>>cash read=9E
2026-04-26 12:30:47>>>cash read=3E


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


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


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


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


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


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


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


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


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


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


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


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


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


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


===13:51:56===
2026-04-26 13:51:12>>>cash read=9E
2026-04-26 13:51:13>>>cash read=3E


===13:55:56===
2026-04-26 13:55:40>>>cash read=9E
2026-04-26 13:55:41>>>cash read=3E


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


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


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


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


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


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


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


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


===14:39:58===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 14:39:43 >>>回调事件[910,devices/S4737]
2026-04-26 14:39:43 >>>故障排除日志:上一MQTT订单号缓存列表为2604261429140076832754
2026-04-26 14:39:43 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 14:39:43 开始打印,排队:59,票券:2604261439329738548701,订单:2604261439320094874729,[2026-04-26 14:39:42微信支付15元]
2026-04-26 14:39:43>>>MQTT票号同步场景，创建空订单对象
2026-04-26 14:39:43>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 14:39:45 >>>回调事件[910,devices/S4737]
2026-04-26 14:39:45 >>>故障排除日志:上一MQTT订单号缓存列表为2604261439320094874729
2026-04-26 14:39:45 >>>故障排除日志:终端未同步成功订单列表00592604261439320094874729
已接收过此消息,票券号为2604261439329738548701,排队号为59
2026-04-26 14:39:45 开始打印,排队:60,票券:2604261439369696984301,订单:2604261439360094943596,[2026-04-26 14:39:44微信支付15元]
2026-04-26 14:39:45>>>HTTP请求进行中，跳过本次同步
2026-04-26 14:39:47 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261439329738548701","queue_number":59,"trade_uid":"2604261439320094874729"}]}
2026-04-26 14:39:47 >>>故障排除日志:删除未同步下发订单成功2604261439320094874729
2026-04-26 14:39:47 >>>故障排除日志:终端同步成功后剩余订单列表00602604261439360094943596
定时检测未同步订单启用[checkOrderNum=536874438]
2026-04-26 14:39:50>>>cash read=0A
2026-04-26 14:39:51>>>cash read=3E


===14:41:59===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 14:41:19 >>>回调事件[910,devices/S4737]
2026-04-26 14:41:19 >>>故障排除日志:上一MQTT订单号缓存列表为2604261439320094874729|2604261439360094943596
2026-04-26 14:41:19 >>>故障排除日志:终端未同步成功订单列表00602604261439360094943596
已接收过此消息,票券号为2604261439369696984301,排队号为60
2026-04-26 14:41:19 开始打印,排队:61,票券:2604261441086582395201,订单:2604261441080064074632,[2026-04-26 14:41:19微信支付15元]
2026-04-26 14:41:19>>>MQTT票号同步场景，创建空订单对象
2026-04-26 14:41:19>>>合并MQTT票号列表到订单同步请求,共2张票
2026-04-26 14:41:21 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261439369696984301","queue_number":60,"trade_uid":"2604261439360094943596"},{"ticket_no":"2604261441086582395201","queue_number":61,"trade_uid":"2604261441080064074632"}]}
2026-04-26 14:41:21 >>>故障排除日志:删除未同步下发订单成功2604261439360094943596
2026-04-26 14:41:21 >>>故障排除日志:删除未同步下发订单成功2604261441080064074632
2026-04-26 14:41:21 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536874457]


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


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


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


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


===15:09:00===
2026-04-26 15:07:59 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261507488798334301","queue_number":65,"trade_uid":"2604261507480085531925"}]}
2026-04-26 15:07:59 >>>故障排除日志:删除未同步下发订单成功2604261507480085531925
2026-04-26 15:07:59 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536874730]


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


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


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


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


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


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


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


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


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


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


===16:20:05===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 16:19:06 >>>回调事件[910,devices/S4737]
2026-04-26 16:19:06 >>>故障排除日志:上一MQTT订单号缓存列表为2604261617020013560878
2026-04-26 16:19:06 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 16:19:06 开始打印,排队:77,票券:2604261619008754075201,订单:2604261619000085604491,[2026-04-26 16:19:06支付宝支付15元]
2026-04-26 16:19:06>>>MQTT票号同步场景，创建空订单对象
2026-04-26 16:19:06>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 16:19:08 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261619008754075201","queue_number":77,"trade_uid":"2604261619000085604491"}]}
2026-04-26 16:19:08 >>>故障排除日志:删除未同步下发订单成功2604261619000085604491
2026-04-26 16:19:08 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536875453]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 16:19:49 >>>回调事件[910,devices/S4737]
2026-04-26 16:19:49 >>>故障排除日志:上一MQTT订单号缓存列表为2604261619000085604491
2026-04-26 16:19:49 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 16:19:49 开始打印,排队:78,票券:2604261619421371961201,订单:2604261619420011512782,[2026-04-26 16:19:48微信支付15元]
2026-04-26 16:19:49>>>MQTT票号同步场景，创建空订单对象
2026-04-26 16:19:49>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 16:19:51 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261619421371961201","queue_number":78,"trade_uid":"2604261619420011512782"}]}
2026-04-26 16:19:51 >>>故障排除日志:删除未同步下发订单成功2604261619420011512782
2026-04-26 16:19:51 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536875464]


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


===19:19:13===
2026-04-26 19:18:54>>>cash read=00
2026-04-26 19:18:55>>>cash read=29
2026-04-26 19:18:55 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 19:18:56>>>cash read=2F29
2026-04-26 19:18:57>>>cash read=01
2026-04-26 19:19:01>>>cash read=2F
2026-04-26 19:19:02>>>cash read=29
2026-04-26 19:19:02 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 19:19:03>>>cash read=01
2026-04-26 19:19:06>>>cash read=3E
2026-04-26 19:19:10>>>cash read=00
2026-04-26 19:19:10>>>cash read=2F29


===19:20:13===
2026-04-26 19:19:12>>>cash read=00
2026-04-26 19:19:13>>>cash read=29
2026-04-26 19:19:13 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 19:19:13>>>cash read=2F29
2026-04-26 19:19:15>>>cash read=3E
2026-04-26 19:19:16>>>cash read=00
2026-04-26 19:19:17>>>cash read=29
2026-04-26 19:19:17 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 19:19:17>>>cash read=2F29
2026-04-26 19:19:19>>>cash read=3E
2026-04-26 19:19:20>>>cash read=29
2026-04-26 19:19:20 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 19:19:21>>>cash read=00
2026-04-26 19:19:22>>>cash read=29
2026-04-26 19:19:22 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 19:19:23>>>cash read=2F29
2026-04-26 19:19:24>>>cash read=3E


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


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


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


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


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


===19:40:14===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:39:55 >>>回调事件[910,devices/S4737]
2026-04-26 19:39:55 >>>故障排除日志:上一MQTT订单号缓存列表为2604261936200011399052
2026-04-26 19:39:55 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 19:39:55 开始打印,排队:122,票券:2604261939481598979201,订单:2604261939480014176213,[2026-04-26 19:39:55微信支付15元]
2026-04-26 19:39:56>>>MQTT票号同步场景，创建空订单对象
2026-04-26 19:39:56>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 19:39:57 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261939481598979201","queue_number":122,"trade_uid":"2604261939480014176213"}]}
2026-04-26 19:39:57 >>>故障排除日志:删除未同步下发订单成功2604261939480014176213
2026-04-26 19:39:58 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877551]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:40:09 >>>回调事件[910,devices/S4737]
2026-04-26 19:40:09 >>>故障排除日志:上一MQTT订单号缓存列表为2604261939480014176213
2026-04-26 19:40:09 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 19:40:09 开始打印,排队:123,票券:2604261940017730787801,订单:2604261940010075470734,[2026-04-26 19:40:09微信支付15元]
2026-04-26 19:40:09>>>MQTT票号同步场景，创建空订单对象
2026-04-26 19:40:09>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 19:40:11 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261940017730787801","queue_number":123,"trade_uid":"2604261940010075470734"}]}
2026-04-26 19:40:11 >>>故障排除日志:删除未同步下发订单成功2604261940010075470734
2026-04-26 19:40:11 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877559]


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


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


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


===19:55:15===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:54:27 >>>回调事件[910,devices/S4737]
2026-04-26 19:54:27 >>>故障排除日志:上一MQTT订单号缓存列表为2604261952100087293119
2026-04-26 19:54:27 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 19:54:27 开始打印,排队:127,票券:2604261954180459099101,订单:2604261954180002656189,[2026-04-26 19:54:26微信支付15元]
2026-04-26 19:54:27>>>MQTT票号同步场景，创建空订单对象
2026-04-26 19:54:27>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 19:54:29 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261954180459099101","queue_number":127,"trade_uid":"2604261954180002656189"}]}
2026-04-26 19:54:29 >>>故障排除日志:删除未同步下发订单成功2604261954180002656189
2026-04-26 19:54:29 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877713]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:54:47 >>>回调事件[910,devices/S4737]
2026-04-26 19:54:47 >>>故障排除日志:上一MQTT订单号缓存列表为2604261954180002656189
2026-04-26 19:54:47 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 19:54:48 开始打印,排队:128,票券:2604261954390400633601,订单:2604261954390002068459,[2026-04-26 19:54:47微信支付15元]
2026-04-26 19:54:48>>>MQTT票号同步场景，创建空订单对象
2026-04-26 19:54:48>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 19:54:50 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261954390400633601","queue_number":128,"trade_uid":"2604261954390002068459"}]}
2026-04-26 19:54:50 >>>故障排除日志:删除未同步下发订单成功2604261954390002068459
2026-04-26 19:54:50 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877724]


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


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


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


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


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


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


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


===20:25:17===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 20:24:38 >>>回调事件[910,devices/S4737]
2026-04-26 20:24:38 >>>故障排除日志:上一MQTT订单号缓存列表为2604262019350006161428
2026-04-26 20:24:38 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 20:24:38 开始打印,排队:136,票券:2604262024172191112501,订单:2604262024170020257423,[2026-04-26 20:24:38支付宝支付15元]
2026-04-26 20:24:38>>>MQTT票号同步场景，创建空订单对象
2026-04-26 20:24:38>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 20:24:40 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604262024172191112501","queue_number":136,"trade_uid":"2604262024170020257423"}]}
2026-04-26 20:24:40 >>>故障排除日志:删除未同步下发订单成功2604262024170020257423
2026-04-26 20:24:40 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878049]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 20:25:04 >>>回调事件[910,devices/S4737]
2026-04-26 20:25:04 >>>故障排除日志:上一MQTT订单号缓存列表为2604262024170020257423
2026-04-26 20:25:04 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 20:25:04 开始打印,排队:137,票券:2604262024565178792501,订单:2604262024560049983219,[2026-04-26 20:25:03微信支付15元]
2026-04-26 20:25:04>>>MQTT票号同步场景，创建空订单对象
2026-04-26 20:25:04>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 20:25:06 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604262024565178792501","queue_number":137,"trade_uid":"2604262024560049983219"}]}
2026-04-26 20:25:06 >>>故障排除日志:删除未同步下发订单成功2604262024560049983219
2026-04-26 20:25:06 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878057]


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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