TLClient_JSSCOM_LuatOS-Air_V4010_RDA8910_RFTTS_0xe0000,2.8.0,869701076562381,57721868793793,
poweron reason:0

===09:39:48===
mqttTask.mqttMsgRecv.proc error
2026-04-25 22:27:59 >>>剩余flash空间=1681000,占用RAM为649.39453125
2026-04-25 22:27:59 >>>回调异常:910,mqtt_tl,30000,mqtt_stop

2026-04-25 22:28:00 >>>MQTT连接断开，尝试重连中
cannot resume dead coroutine
stack traceback:
2026-04-25 22:28:11 >>>剩余flash空间=1681000,占用RAM为671.34765625
2026-04-25 22:28:11 >>>回调事件:910,subscribe,10000,连接服务器成功

2026-04-25 22:28:11 >>>剩余flash空间=1680500,占用RAM为619.7333984375
2026-04-25 22:28:11 >>>回调异常:911,GetMqttQueue,30000,nil

mqttTask.mqttMsgRecv.proc error
2026-04-25 22:51:59 >>>剩余flash空间=1680000,占用RAM为663.4501953125
2026-04-25 22:51:59 >>>回调异常:910,mqtt_tl,30000,mqtt_stop

2026-04-25 22:51:59 >>>MQTT连接断开，尝试重连中
2026-04-25 22:52:09 >>>剩余flash空间=1680000,占用RAM为666.7119140625
2026-04-25 22:52:09 >>>回调异常:910,connect,30006,fail

2026-04-25 22:52:09 >>>MQTT连接断开，尝试重连中
2026-04-25 22:52:19 >>>剩余flash空间=1679500,占用RAM为640.3154296875
2026-04-25 22:52:19 >>>回调异常:910,connect,30006,fail

2026-04-25 22:52:19 >>>MQTT连接断开，尝试重连中
2026-04-25 22:52:29 >>>剩余flash空间=1679500,占用RAM为644.294921875
2026-04-25 22:52:29 >>>回调异常:910,connect,30006,fail

2026-04-25 22:52:29 >>>MQTT连接断开，尝试重连中
2026-04-25 22:52:39 >>>剩余flash空间=1679500,占用RAM为689.3251953125
2026-04-25 22:52:39 >>>回调异常:910,connect,30006,fail

2026-04-25 22:52:39 >>>MQTT连接断开，尝试重连中
2026-04-25 22:52:49 >>>剩余flash空间=1679000,占用RAM为683.244140625
2026-04-25 22:52:49 >>>回调异常:910,connect,30006,fail

2026-04-25 22:52:49 >>>MQTT连接断开，尝试重连中
2026-04-25 22:52:59 >>>剩余flash空间=1679000,占用RAM为652.50390625
2026-04-25 22:52:59 >>>回调异常:910,connect,30006,fail

2026-04-25 22:52:59 >>>MQTT连接断开，尝试重连中
2026-04-25 22:53:09 >>>剩余flash空间=1679000,占用RAM为683.6748046875
2026-04-25 22:53:09 >>>回调异常:910,connect,30006,fail

2026-04-25 22:53:09 >>>MQTT连接断开，尝试重连中
2026-04-25 22:53:19 >>>剩余flash空间=1678500,占用RAM为653.3515625
2026-04-25 22:53:19 >>>回调异常:910,connect,30006,fail

2026-04-25 22:53:19 >>>MQTT连接断开，尝试重连中
2026-04-25 22:53:29 >>>剩余flash空间=1678500,占用RAM为647.3193359375
2026-04-25 22:53:29 >>>回调异常:910,connect,30006,fail

2026-04-25 22:53:29 >>>MQTT连接断开，尝试重连中
2026-04-25 22:53:39 >>>剩余flash空间=1678000,占用RAM为669.8662109375
2026-04-25 22:53:39 >>>回调异常:910,connect,30006,fail

2026-04-25 22:53:39 >>>MQTT连接断开，尝试重连中
2026-04-25 22:53:49 >>>剩余flash空间=1678000,占用RAM为654.2822265625
2026-04-25 22:53:49 >>>回调异常:910,connect,30006,fail

2026-04-25 22:53:49 >>>MQTT连接断开，尝试重连中
2026-04-25 22:53:59 >>>剩余flash空间=1678000,占用RAM为653.7578125
2026-04-25 22:53:59 >>>回调异常:910,connect,30006,fail

2026-04-25 22:53:59 >>>MQTT连接断开，尝试重连中
2026-04-25 22:54:09 >>>剩余flash空间=1677500,占用RAM为668.58203125
2026-04-25 22:54:09 >>>回调异常:910,connect,30006,fail

2026-04-25 22:54:09 >>>MQTT连接断开，尝试重连中
2026-04-25 22:54:19 >>>剩余flash空间=1677500,占用RAM为644.275390625
2026-04-25 22:54:19 >>>回调异常:910,connect,30006,fail

2026-04-25 22:54:19 >>>MQTT连接断开，尝试重连中
2026-04-25 22:54:29 >>>剩余flash空间=1677000,占用RAM为648.6640625
2026-04-25 22:54:29 >>>回调异常:910,connect,30006,fail

2026-04-25 22:54:29 >>>MQTT连接断开，尝试重连中
2026-04-25 22:54:39 >>>剩余flash空间=1677000,占用RAM为656.892578125
2026-04-25 22:54:40 >>>回调异常:910,connect,30006,fail

2026-04-25 22:54:40 >>>MQTT连接断开，尝试重连中
2026-04-25 22:54:50 >>>剩余flash空间=1677000,占用RAM为682.78125
2026-04-25 22:54:50 >>>回调异常:910,connect,30006,fail

2026-04-25 22:54:50 >>>MQTT连接断开，尝试重连中
2026-04-25 22:55:00 >>>剩余flash空间=1676500,占用RAM为644.0439453125
2026-04-25 22:55:00 >>>回调异常:910,connect,30006,fail

2026-04-25 22:55:00 >>>MQTT连接断开，尝试重连中
2026-04-25 22:55:10 >>>剩余flash空间=1676500,占用RAM为644.375
2026-04-25 22:55:10 >>>回调异常:910,connect,30006,fail

2026-04-25 22:55:10 >>>MQTT连接断开，尝试重连中
2026-04-25 22:55:20 >>>剩余flash空间=1676000,占用RAM为670.7783203125
2026-04-25 22:55:20 >>>回调异常:910,connect,30006,fail

2026-04-25 22:55:20 >>>MQTT连接断开，尝试重连中
2026-04-25 22:55:30 >>>剩余flash空间=1676000,占用RAM为649.8740234375
2026-04-25 22:55:30 >>>回调异常:910,connect,30006,fail

2026-04-25 22:55:30 >>>MQTT连接断开，尝试重连中
2026-04-25 22:55:40 >>>剩余flash空间=1676000,占用RAM为655.03125
2026-04-25 22:55:40 >>>回调异常:910,connect,30006,fail

2026-04-25 22:55:40 >>>MQTT连接断开，尝试重连中


TCP://post-cn-09k20cnrl07.mqtt.aliyuncs.com:1883 closed@25_22:51:59
TCP://post-cn-09k20cnrl07.mqtt.aliyuncs.com:1883@25_22:51:59:send fail
PDP_DEACT_IND@25_22:27:59
===09:40:01===
上一时间戳为1777166930
当日首次设置时间戳true为1777167587
今日nvm排队号为4
当前排队号为4,音量为6
初始化产品信息:[{"time_limit_date":"","ticket_category":"0","expiry_date":7,"product_detail":"","time_limit_status":"0","begin_minute":"00","product_uid":"14872826055361677916","use_timer":1,"old_price":"12","end_hour":"23","sale_price":"12","end_minute":"59","begin_hour":"00","sale_status":1,"product_name":"快剪"}]
是否打印二维码设置为1
是否打印紧凑设置为3
当前号显示模式设置为1
当前卡项核销权限设置为0
session_id:b8846****a1179
纸币器设置接收纸币范围为36
欢迎使用天羚自助售票系统[2.8.0]
定时检测未同步订单启用
2026-04-26 09:39:48>>>cash write=30
2026-04-26 09:39:48>>>cash write=02
2026-04-26 09:39:48>>>cash write=3E
2026-04-26 09:39:48>>>cash read=808F808F
系统时间初始化成功，时间为202642693948
2026-04-26 09:39:49>>>cash write=02
2026-04-26 09:39:49 >>>剩余flash空间=1542000,占用RAM为647.19921875
2026-04-26 09:39:49 >>>回调事件:910,subscribe,10000,连接服务器成功

请求下发消息结果为0,Message sent successfully
2026-04-26 09:39:50 >>>回调事件[910,devices/S3650]
2026-04-26 09:39:50 >>>故障排除日志:上一MQTT订单号缓存列表为2604252151100037438873
2026-04-26 09:39:50 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 09:39:50 开始打印,排队:4,票券:2604260923421214735701,订单:2604260923420009149058,[2026-04-26 09:23:49微信支付12元]
2026-04-26 09:39:53 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604260923421214735701","queue_number":4,"trade_uid":"2604260923420009149058"}]}
2026-04-26 09:39:53 >>>故障排除日志:删除未同步下发订单成功2604260923420009149058
2026-04-26 09:39:53 >>>故障排除日志:终端同步成功后剩余订单列表
流量卡还有126天过期
restart[UPDATE_DOWNLOAD_SUCCESS];


===09:41:02===
上一时间戳为1777167587
当日首次设置时间戳true为1777167600
今日nvm排队号为5
当前排队号为5,音量为6
初始化产品信息:[{"time_limit_date":"","ticket_category":"0","expiry_date":7,"product_detail":"","time_limit_status":"0","begin_minute":"00","product_uid":"14872826055361677916","use_timer":1,"old_price":"12","end_hour":"23","sale_price":"12","end_minute":"59","begin_hour":"00","sale_status":1,"product_name":"快剪"}]
是否打印二维码设置为1
是否打印紧凑设置为3
当前号显示模式设置为1
当前卡项核销权限设置为0
session_id:28842****0432c
纸币器设置接收纸币范围为36
欢迎使用天羚自助售票系统[2.8.6]
定时检测未同步订单启用[checkOrderNum=536870972]
2026-04-26 09:40:01>>>cash write=30
2026-04-26 09:40:01>>>cash write=02
2026-04-26 09:40:01>>>cash write=3E
系统时间初始化成功，时间为20264269401
2026-04-26 09:40:02>>>cash write=0C
2026-04-26 09:40:02>>>cash read=3E
2026-04-26 09:40:02 >>>剩余flash空间=1677500,占用RAM为655.736328125
2026-04-26 09:40:02 >>>回调事件:910,subscribe,10000,连接服务器成功

2026-04-26 09:40:02 >>>剩余flash空间=1677000,占用RAM为626.302734375
2026-04-26 09:40:03 >>>回调事件:911,GetMqttQueue,500,暂无需要下发的信息，请求类型：ticket

2026-04-26 09:40:03>>>cash read=808F
2026-04-26 09:40:04>>>cash write=02
2026-04-26 09:40:05>>>cash write=0C
2026-04-26 09:40:05>>>cash read=3E
流量卡还有126天过期
2026-04-26 09:40:13 >>>当前Ram内存为677.4404296875


===09:42:02===
检测到未同步订单[1]:2604260928500023650036
定时检测未同步订单关闭[lastTableNumForSync=1][lastOrderCheckTime=1]
删除未同步订单2604260928500023650036
2026-04-26 09:41:01>>>订单2604260928500023650036删除成功,剩余空间为1679500,占用RAM为643.623046875
2026-04-26 09:41:01 >>>当前Ram内存为612.470703125
定时检测未同步订单启用[checkOrderNum=536870996]


===09:43:03===
检测到未同步订单[1]:2604260929220023650434
定时检测未同步订单关闭[lastTableNumForSync=1][lastOrderCheckTime=2]
删除未同步订单2604260929220023650434
2026-04-26 09:42:01>>>订单2604260929220023650434删除成功,剩余空间为1680500,占用RAM为671.0185546875
2026-04-26 09:42:01 >>>当前Ram内存为611.7109375
定时检测未同步订单启用[checkOrderNum=536871011]


===09:44:03===
检测到未同步订单[1]:2604260939190023650465
定时检测未同步订单关闭[lastTableNumForSync=1][lastOrderCheckTime=3]
删除未同步订单2604260939190023650465
2026-04-26 09:43:02>>>订单2604260939190023650465删除成功,剩余空间为1681500,占用RAM为638.5712890625
检测订单目录中>>>
无未同步订单>>>
2026-04-26 09:43:02 >>>当前Ram内存为612.2109375
定时检测未同步订单启用[checkOrderNum=536871027]


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


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


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


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


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


===10:12:07===
2026-04-26 10:11:05 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261010568886829201","queue_number":9,"trade_uid":"2604261010560086791591"}]}
2026-04-26 10:11:05 >>>故障排除日志:删除未同步下发订单成功2604261010560086791591
2026-04-26 10:11:05 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536871329]


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


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


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


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


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


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


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


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


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


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


===11:48:10===
2026-04-26 11:47:38>>>cash read=0A
2026-04-26 11:47:40>>>cash read=3E


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


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


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


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


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


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


===12:56:12===
2026-04-26 12:55:41>>>cash read=00
2026-04-26 12:55:42>>>cash read=818F42
2026-04-26 12:55:42>>>cash write=02
2026-04-26 12:55:42 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 12:55:42>>>cash read=10
2026-04-26 12:55:42 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 12:55:43>>>cash write=0C
2026-04-26 12:55:43>>>cash read=3E
2026-04-26 12:55:44 >>>开始未足额打印,排队号为26,订单号为2604261255420023650921
2026-04-26 12:55:44 订单投币结束,共投币10元,请取走您的小票
2026-04-26 12:55:44>>>订单2604261255420023650921写入成功,剩余空间为1679500,占用RAM为662.2978515625
删除未同步订单2604261255420023650921
2026-04-26 12:55:46>>>订单2604261255420023650921删除成功,剩余空间为1680500,占用RAM为647.048828125
检测订单目录中>>>
无未同步订单>>>
2026-04-26 12:55:46 >>>当前Ram内存为617.25
定时检测未同步订单启用[checkOrderNum=536872960]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 12:56:02 >>>回调事件[910,devices/S3650]
2026-04-26 12:56:02 >>>故障排除日志:上一MQTT订单号缓存列表为2604261251100082024165
2026-04-26 12:56:02 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 12:56:02 开始打印,排队:27,票券:2604261255583825127901,订单:2604261255580036396786,[2026-04-26 12:56:01支付宝支付12元]
2026-04-26 12:56:02>>>MQTT票号同步场景，创建空订单对象
2026-04-26 12:56:02>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 12:56:04 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261255583825127901","queue_number":27,"trade_uid":"2604261255580036396786"}]}
2026-04-26 12:56:04 >>>故障排除日志:删除未同步下发订单成功2604261255580036396786
2026-04-26 12:56:04 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536872973]


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


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


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


===13:15:13===
2026-04-26 13:14:34>>>cash read=0A
2026-04-26 13:14:35>>>cash read=3E


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


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


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


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


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


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


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


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


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


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


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


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


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


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


===14:39:17===
2026-04-26 14:38:22>>>cash read=00
2026-04-26 14:38:22>>>cash read=818F42
2026-04-26 14:38:22>>>cash write=02
2026-04-26 14:38:22 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 14:38:23>>>cash read=10
2026-04-26 14:38:23 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 14:38:24>>>cash write=0C
2026-04-26 14:38:24>>>cash read=3E
2026-04-26 14:38:26 >>>开始未足额打印,排队号为46,订单号为2604261438230023650418
2026-04-26 14:38:26 订单投币结束,共投币10元,请取走您的小票
2026-04-26 14:38:26>>>订单2604261438230023650418写入成功,剩余空间为1679500,占用RAM为640.859375
删除未同步订单2604261438230023650418
2026-04-26 14:38:28>>>订单2604261438230023650418删除成功,剩余空间为1680500,占用RAM为647.1962890625
检测订单目录中>>>
无未同步订单>>>
2026-04-26 14:38:28 >>>当前Ram内存为617.55859375
定时检测未同步订单启用[checkOrderNum=536874058]
2026-04-26 14:38:29>>>cash read=00
2026-04-26 14:38:31>>>cash read=29
2026-04-26 14:38:31 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 14:38:31>>>cash read=2F29
2026-04-26 14:38:33>>>cash read=3E
2026-04-26 14:38:36>>>cash read=00
2026-04-26 14:38:37>>>cash read=818F42
2026-04-26 14:38:37>>>cash write=02
2026-04-26 14:38:37 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 14:38:37>>>cash read=10
2026-04-26 14:38:37 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 14:38:39>>>cash write=0C
2026-04-26 14:38:39>>>cash read=3E
2026-04-26 14:38:40 >>>开始未足额打印,排队号为47,订单号为2604261438370023650683
2026-04-26 14:38:40 订单投币结束,共投币10元,请取走您的小票
2026-04-26 14:38:40>>>订单2604261438370023650683写入成功,剩余空间为1678500,占用RAM为672.685546875
删除未同步订单2604261438370023650683
2026-04-26 14:38:42>>>订单2604261438370023650683删除成功,剩余空间为1679000,占用RAM为650.443359375
检测订单目录中>>>
无未同步订单>>>
2026-04-26 14:38:42 >>>当前Ram内存为618.25390625
定时检测未同步订单启用[checkOrderNum=536874069]


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


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


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


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


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


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


===15:01:20===
2026-04-26 15:00:38>>>cash read=0A
2026-04-26 15:00:39>>>cash read=3E


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


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


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


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


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


===15:36:21===
2026-04-26 15:35:35>>>cash read=00
2026-04-26 15:35:36>>>cash read=29
2026-04-26 15:35:36 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 15:35:37>>>cash read=2F29
2026-04-26 15:35:38>>>cash read=3E
2026-04-26 15:35:40>>>cash read=29
2026-04-26 15:35:40 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 15:35:42>>>cash read=3E
2026-04-26 15:35:43>>>cash read=00
2026-04-26 15:35:44>>>cash read=29
2026-04-26 15:35:44 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 15:35:44>>>cash read=2F29
2026-04-26 15:35:45>>>cash read=3E
2026-04-26 15:35:48>>>cash read=00
2026-04-26 15:35:49>>>cash read=29
2026-04-26 15:35:49 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 15:35:49>>>cash read=2F29
2026-04-26 15:35:51>>>cash read=3E
2026-04-26 15:35:55>>>cash read=00
2026-04-26 15:35:56>>>cash read=2F29
2026-04-26 15:35:57>>>cash read=3E
2026-04-26 15:35:58>>>cash read=00
2026-04-26 15:36:00>>>cash read=29
2026-04-26 15:36:00 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 15:36:00>>>cash read=2F29
2026-04-26 15:36:01>>>cash read=3E
2026-04-26 15:36:02>>>cash read=00
2026-04-26 15:36:04>>>cash read=29
2026-04-26 15:36:04 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 15:36:04>>>cash read=2F29
2026-04-26 15:36:05>>>cash read=3E
2026-04-26 15:36:06>>>cash read=00
2026-04-26 15:36:07>>>cash read=2F29
2026-04-26 15:36:08>>>cash read=00
2026-04-26 15:36:09>>>cash read=29
2026-04-26 15:36:09 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 15:36:10>>>cash read=2F29
2026-04-26 15:36:11>>>cash read=3E
2026-04-26 15:36:12>>>cash read=00
2026-04-26 15:36:13>>>cash read=2F29
2026-04-26 15:36:15>>>cash read=3E


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


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


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


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


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


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


===16:11:24===
2026-04-26 16:11:18>>>cash read=0A
2026-04-26 16:11:19>>>cash read=3E


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


===17:01:32===
2026-04-26 17:01:01>>>cash read=0A
2026-04-26 17:01:02>>>cash read=3E


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


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


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


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


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


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


===17:29:34===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 17:28:43 >>>回调事件[910,devices/S3650]
2026-04-26 17:28:43 >>>故障排除日志:上一MQTT订单号缓存列表为2604261728110000592113
2026-04-26 17:28:43 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 17:28:43 开始打印,排队:86,票券:2604261728353205159601,订单:2604261728350030092159,[2026-04-26 17:28:43支付宝支付12元]
2026-04-26 17:28:43>>>MQTT票号同步场景，创建空订单对象
2026-04-26 17:28:43>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 17:28:45 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261728353205159601","queue_number":86,"trade_uid":"2604261728350030092159"}]}
2026-04-26 17:28:45 >>>故障排除日志:删除未同步下发订单成功2604261728350030092159
2026-04-26 17:28:45 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536876095]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 17:28:53 >>>回调事件[910,devices/S3650]
2026-04-26 17:28:53 >>>故障排除日志:上一MQTT订单号缓存列表为2604261728350030092159
2026-04-26 17:28:53 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 17:28:53 开始打印,排队:87,票券:2604261728493474276201,订单:2604261728490032662531,[2026-04-26 17:28:53支付宝支付12元]
2026-04-26 17:28:53>>>MQTT票号同步场景，创建空订单对象
2026-04-26 17:28:53>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 17:28:55 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261728493474276201","queue_number":87,"trade_uid":"2604261728490032662531"}]}
2026-04-26 17:28:55 >>>故障排除日志:删除未同步下发订单成功2604261728490032662531
2026-04-26 17:28:55 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536876101]
2026-04-26 17:29:00>>>cash read=00
2026-04-26 17:29:01>>>cash read=2F29
2026-04-26 17:29:02>>>cash read=3E
2026-04-26 17:29:08>>>cash read=00
2026-04-26 17:29:09>>>cash read=29
2026-04-26 17:29:09 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 17:29:09>>>cash read=2F292F
2026-04-26 17:29:10>>>cash read=00
2026-04-26 17:29:11>>>cash read=3E


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


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


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


===17:40:35===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 17:39:42 >>>回调事件[910,devices/S3650]
2026-04-26 17:39:42 >>>故障排除日志:上一MQTT订单号缓存列表为2604261738020088055587
2026-04-26 17:39:42 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 17:39:42 开始打印,排队:92,票券:2604261739357005056701,订单:2604261739350068031669,[2026-04-26 17:39:42微信支付12元]
2026-04-26 17:39:42 开始打印,排队:93,票券:2604261739357005633502,订单:2604261739350068031669,[2026-04-26 17:39:42微信支付12元]
2026-04-26 17:39:42>>>MQTT票号同步场景，创建空订单对象
2026-04-26 17:39:42>>>合并MQTT票号列表到订单同步请求,共2张票
2026-04-26 17:39:45 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261739357005056701","queue_number":92,"trade_uid":"2604261739350068031669"},{"ticket_no":"2604261739357005633502","queue_number":93,"trade_uid":"2604261739350068031669"}]}
2026-04-26 17:39:45 >>>故障排除日志:删除未同步下发订单成功2604261739350068031669
2026-04-26 17:39:45 >>>故障排除日志:删除未同步下发订单成功2604261739350068031669
2026-04-26 17:39:46 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536876246]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 17:39:55 >>>回调事件[910,devices/S3650]
2026-04-26 17:39:55 >>>故障排除日志:上一MQTT订单号缓存列表为2604261739350068031669|2604261739350068031669
2026-04-26 17:39:55 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 17:39:55 开始打印,排队:94,票券:2604261739489725425601,订单:2604261739480094821115,[2026-04-26 17:39:55微信支付12元]
2026-04-26 17:39:55 开始打印,排队:95,票券:2604261739489725831502,订单:2604261739480094821115,[2026-04-26 17:39:55微信支付12元]
2026-04-26 17:39:55>>>MQTT票号同步场景，创建空订单对象
2026-04-26 17:39:55>>>合并MQTT票号列表到订单同步请求,共2张票
2026-04-26 17:39:59 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261739489725425601","queue_number":94,"trade_uid":"2604261739480094821115"},{"ticket_no":"2604261739489725831502","queue_number":95,"trade_uid":"2604261739480094821115"}]}
2026-04-26 17:39:59 >>>故障排除日志:删除未同步下发订单成功2604261739480094821115
2026-04-26 17:39:59 >>>故障排除日志:删除未同步下发订单成功2604261739480094821115
2026-04-26 17:39:59 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536876252]


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


===19:02:41===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:01:44 >>>回调事件[910,devices/S3650]
2026-04-26 19:01:44 >>>故障排除日志:上一MQTT订单号缓存列表为2604261852480072739629
2026-04-26 19:01:44 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 19:01:44 开始打印,排队:114,票券:2604261901368707151901,订单:2604261901360085203228,[2026-04-26 19:01:44微信支付12元]
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":"2604261901368707151901","queue_number":114,"trade_uid":"2604261901360085203228"}]}
2026-04-26 19:01:46 >>>故障排除日志:删除未同步下发订单成功2604261901360085203228
2026-04-26 19:01:46 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877187]


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


===20:21:47===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 20:20:53 >>>回调事件[910,devices/S3650]
2026-04-26 20:20:53 >>>故障排除日志:上一MQTT订单号缓存列表为2604262018580078655097
2026-04-26 20:20:53 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 20:20:53 开始打印,排队:137,票券:2604262020462239316201,订单:2604262020460020439192,[2026-04-26 20:20:53微信支付12元]
2026-04-26 20:20:53>>>MQTT票号同步场景，创建空订单对象
2026-04-26 20:20:53>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 20:20:55 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604262020462239316201","queue_number":137,"trade_uid":"2604262020460020439192"}]}
2026-04-26 20:20:55 >>>故障排除日志:删除未同步下发订单成功2604262020460020439192
2026-04-26 20:20:55 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878119]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 20:21:16 >>>回调事件[910,devices/S3650]
2026-04-26 20:21:16 >>>故障排除日志:上一MQTT订单号缓存列表为2604262020460020439192
2026-04-26 20:21:16 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 20:21:16 开始打印,排队:138,票券:2604262021112436127801,订单:2604262021110022554492,[2026-04-26 20:21:16微信支付12元]
2026-04-26 20:21:16>>>MQTT票号同步场景，创建空订单对象
2026-04-26 20:21:16>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 20:21:18 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604262021112436127801","queue_number":138,"trade_uid":"2604262021110022554492"}]}
2026-04-26 20:21:18 >>>故障排除日志:删除未同步下发订单成功2604262021110022554492
2026-04-26 20:21:18 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878133]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 20:21:43 >>>回调事件[910,devices/S3650]
2026-04-26 20:21:43 >>>故障排除日志:上一MQTT订单号缓存列表为2604262021110022554492
2026-04-26 20:21:43 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 20:21:43 开始打印,排队:139,票券:2604262021370399846101,订单:2604262021370001507267,[2026-04-26 20:21:43微信支付12元]
2026-04-26 20:21:44>>>MQTT票号同步场景，创建空订单对象
2026-04-26 20:21:44>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 20:21:45 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604262021370399846101","queue_number":139,"trade_uid":"2604262021370001507267"}]}
2026-04-26 20:21:45 >>>故障排除日志:删除未同步下发订单成功2604262021370001507267
2026-04-26 20:21:46 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878140]


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


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


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


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


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


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


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


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


===20:58:52===
2026-04-26 20:57:50 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604262057386188037901","queue_number":148,"trade_uid":"2604262057380059894641"}]}
2026-04-26 20:57:50 >>>故障排除日志:删除未同步下发订单成功2604262057380059894641
2026-04-26 20:57:50 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878553]


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


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


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


===21:04:54===
2026-04-26 21:03:52 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604262103372590847301","queue_number":151,"trade_uid":"2604262103370024195956"}]}
2026-04-26 21:03:52 >>>故障排除日志:删除未同步下发订单成功2604262103370024195956
2026-04-26 21:03:52 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878633]


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


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


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


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