TLClient_JSSCOM_LuatOS-Air_V3205_RDA8910_RFTTS_0xe0000,2.7.9,861714058769609,09450077800333,
poweron reason:0

===09:34:56===
上一时间戳为1776822268
隔日重置时间戳true
隔日清空未同步下发列表true
当前排队号为1,音量为6
初始化产品信息:[{"time_limit_date":null,"ticket_category":"0","expiry_date":90,"product_detail":"此票劵当天有效，过期作废。","time_limit_status":"0","begin_minute":null,"product_uid":"12565527731041229647","use_timer":1,"old_price":"12","end_hour":null,"sale_price":"12","end_minute":null,"begin_hour":null,"sale_status":1,"product_name":"剪发"}]
打印门店标题设置为丰门哲尚理发店
是否打印二维码设置为1
是否打印紧凑设置为3
当前号显示模式设置为1
当前卡项核销权限设置为0
session_id:feddd****96118
纸币器设置接收纸币范围为36
欢迎使用天羚自助售票系统[2.7.9]
定时检测未同步订单启用
2026-04-23 09:33:55>>>cash write=30
2026-04-23 09:33:55>>>cash write=02
2026-04-23 09:33:55>>>cash write=3E
2026-04-23 09:33:55>>>cash read=808F808F808F808F
系统时间初始化成功，时间为202642393355
2026-04-23 09:33:56>>>cash write=02
2026-04-23 09:33:56 >>>剩余flash空间=1671500,占用RAM为651.22265625
2026-04-23 09:33:56 >>>回调事件:910,subscribe,10000,连接服务器成功

2026-04-23 09:33:57 >>>剩余flash空间=1671500,占用RAM为620.34375
2026-04-23 09:33:57 >>>回调事件:911,GetMqttQueue,500,暂无需要下发的信息，请求类型：ticket

2026-04-23 09:33:59>>>cash write=0C
2026-04-23 09:33:59>>>cash read=3E
流量卡还有283天过期
2026-04-23 09:34:03 >>>当前Ram内存为627.91796875
2026-04-23 09:34:09 >>>回调事件[910,devices/S1754]
当日首次设置时间戳true为1776908049
2026-04-23 09:34:09 >>>故障排除日志:上一MQTT订单号缓存列表为2604222313340096867639
2026-04-23 09:34:09 >>>故障排除日志:终端未同步成功订单列表
2026-04-23 09:34:09 开始打印,排队:1,票券:2604230933589275719801,订单:2604230933580089926458,[2026-04-23 09:34:08微信支付12元]
2026-04-23 09:34:11 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604230933589275719801","queue_number":1,"trade_uid":"2604230933580089926458"}]}
2026-04-23 09:34:11 >>>故障排除日志:删除未同步下发订单成功2604230933580089926458
2026-04-23 09:34:11 >>>故障排除日志:终端同步成功后剩余订单列表
2026-04-23 09:34:52 >>>回调事件[910,devices/S1754]
2026-04-23 09:34:52 >>>故障排除日志:上一MQTT订单号缓存列表为2604230933580089926458
2026-04-23 09:34:52 >>>故障排除日志:终端未同步成功订单列表
2026-04-23 09:34:52 开始打印,排队:2,票券:2604230934358966956301,订单:2604230934350087834183,[2026-04-23 09:34:51微信支付12元]
2026-04-23 09:34:54 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604230934358966956301","queue_number":2,"trade_uid":"2604230934350087834183"}]}
2026-04-23 09:34:54 >>>故障排除日志:删除未同步下发订单成功2604230934350087834183
2026-04-23 09:34:54 >>>故障排除日志:终端同步成功后剩余订单列表


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


===09:36:14===
restart[UPDATE_DOWNLOAD_SUCCESS];


===09:37:14===
上一时间戳为1776908049
当日首次设置时间戳true为1776908173
今日nvm排队号为3
当前排队号为3,音量为6
初始化产品信息:[{"time_limit_date":null,"ticket_category":"0","expiry_date":90,"product_detail":"此票劵当天有效，过期作废。","time_limit_status":"0","begin_minute":null,"product_uid":"12565527731041229647","use_timer":1,"old_price":"12","end_hour":null,"sale_price":"12","end_minute":null,"begin_hour":null,"sale_status":1,"product_name":"剪发"}]
打印门店标题设置为丰门哲尚理发店
是否打印二维码设置为1
是否打印紧凑设置为3
当前号显示模式设置为1
当前卡项核销权限设置为0
session_id:6bc8d****f1adb
纸币器设置接收纸币范围为36
欢迎使用天羚自助售票系统[2.8.4]
定时检测未同步订单启用[checkOrderNum=536870971]
2026-04-23 09:36:13>>>cash write=30
2026-04-23 09:36:13>>>cash write=02
2026-04-23 09:36:13>>>cash write=3E
系统时间初始化成功，时间为202642393613
2026-04-23 09:36:14>>>cash write=0C
2026-04-23 09:36:14>>>cash read=3E
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
连接服务器成功
2026-04-23 09:36:14>>>cash read=808F
2026-04-23 09:36:15>>>cash write=02
2026-04-23 09:36:17>>>cash write=0C
2026-04-23 09:36:17>>>cash read=3E
流量卡还有283天过期
2026-04-23 09:36:22 >>>当前Ram内存为675.1953125


===09:38:14===
2026-04-23 09:37:41 >>>回调事件[910,devices/S1754]
2026-04-23 09:37:41 >>>故障排除日志:上一MQTT订单号缓存列表为2604230934350087834183
2026-04-23 09:37:41 >>>故障排除日志:终端未同步成功订单列表
2026-04-23 09:37:41 开始打印,排队:3,票券:2604230937322492271301,订单:2604230937320022953656,[2026-04-23 09:37:40微信支付12元]
2026-04-23 09:37:41>>>MQTT票号同步场景，创建空订单对象
2026-04-23 09:37:41>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-23 09:37:43 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604230937322492271301","queue_number":3,"trade_uid":"2604230937320022953656"}]}
2026-04-23 09:37:43 >>>故障排除日志:删除未同步下发订单成功2604230937320022953656
2026-04-23 09:37:43 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536871000]


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


===13:00:24===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-23 13:00:19 >>>回调事件[910,devices/S1754]
2026-04-23 13:00:19 >>>故障排除日志:上一MQTT订单号缓存列表为2604231254520080997292
2026-04-23 13:00:19 >>>故障排除日志:终端未同步成功订单列表
2026-04-23 13:00:19 开始打印,排队:31,票券:2604231300115356903901,订单:2604231300110051537115,[2026-04-23 13:00:17支付宝支付12元]
2026-04-23 13:00:19 开始打印,排队:32,票券:2604231300115357539802,订单:2604231300110051537115,[2026-04-23 13:00:17支付宝支付12元]
2026-04-23 13:00:19>>>MQTT票号同步场景，创建空订单对象
2026-04-23 13:00:19>>>合并MQTT票号列表到订单同步请求,共2张票


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


===14:38:30===
2026-04-23 14:37:51>>>cash read=0A
2026-04-23 14:37:52>>>cash read=3E


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


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


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


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


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


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


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


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


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


===15:32:34===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-23 15:32:31 >>>回调事件[910,devices/S1754]
2026-04-23 15:32:31 >>>故障排除日志:上一MQTT订单号缓存列表为2604231530180081085519
2026-04-23 15:32:31 >>>故障排除日志:终端未同步成功订单列表
2026-04-23 15:32:31 开始打印,排队:59,票券:2604231532165265689501,订单:2604231532160050846553,[2026-04-23 15:32:30微信支付12元]
2026-04-23 15:32:31>>>MQTT票号同步场景，创建空订单对象
2026-04-23 15:32:31>>>合并MQTT票号列表到订单同步请求,共1张票


===15:33:34===
2026-04-23 15:32:33 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604231532165265689501","queue_number":59,"trade_uid":"2604231532160050846553"}]}
2026-04-23 15:32:33 >>>故障排除日志:删除未同步下发订单成功2604231532160050846553
2026-04-23 15:32:33 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536874650]


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


===16:50:38===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-23 16:49:43 >>>回调事件[910,devices/S1754]
2026-04-23 16:49:43 >>>故障排除日志:上一MQTT订单号缓存列表为2604231647590063490983
2026-04-23 16:49:43 >>>故障排除日志:终端未同步成功订单列表
2026-04-23 16:49:43 开始打印,排队:78,票券:2604231649319959645101,订单:2604231649310097769564,[2026-04-23 16:49:44微信支付12元]
2026-04-23 16:49:43>>>MQTT票号同步场景，创建空订单对象
2026-04-23 16:49:44>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-23 16:49:45 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604231649319959645101","queue_number":78,"trade_uid":"2604231649310097769564"}]}
2026-04-23 16:49:45 >>>故障排除日志:删除未同步下发订单成功2604231649310097769564
2026-04-23 16:49:46 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536875482]
2026-04-23 16:50:02>>>cash read=0A
2026-04-23 16:50:03>>>cash read=3E


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


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


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


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


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


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


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


===17:26:41===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-23 17:25:58 >>>回调事件[910,devices/S1754]
2026-04-23 17:25:58 >>>故障排除日志:上一MQTT订单号缓存列表为2604231724370077047535
2026-04-23 17:25:58 >>>故障排除日志:终端未同步成功订单列表
2026-04-23 17:25:58 开始打印,排队:86,票券:2604231725498001528501,订单:2604231725490077404847,[2026-04-23 17:25:58微信支付12元]
2026-04-23 17:25:58>>>MQTT票号同步场景，创建空订单对象
2026-04-23 17:25:58>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-23 17:26:00 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604231725498001528501","queue_number":86,"trade_uid":"2604231725490077404847"}]}
2026-04-23 17:26:00 >>>故障排除日志:删除未同步下发订单成功2604231725490077404847
2026-04-23 17:26:00 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536875870]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-23 17:26:04 >>>回调事件[910,devices/S1754]
2026-04-23 17:26:04 >>>故障排除日志:上一MQTT订单号缓存列表为2604231725490077404847
2026-04-23 17:26:04 >>>故障排除日志:终端未同步成功订单列表
2026-04-23 17:26:04 开始打印,排队:87,票券:2604231725585969053901,订单:2604231725580057549085,[2026-04-23 17:26:04微信支付12元]
2026-04-23 17:26:04>>>MQTT票号同步场景，创建空订单对象
2026-04-23 17:26:04>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-23 17:26:06 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604231725585969053901","queue_number":87,"trade_uid":"2604231725580057549085"}]}
2026-04-23 17:26:06 >>>故障排除日志:删除未同步下发订单成功2604231725580057549085
2026-04-23 17:26:06 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536875878]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-23 17:26:10 >>>回调事件[910,devices/S1754]
2026-04-23 17:26:10 >>>故障排除日志:上一MQTT订单号缓存列表为2604231725580057549085
2026-04-23 17:26:10 >>>故障排除日志:终端未同步成功订单列表
2026-04-23 17:26:10 开始打印,排队:88,票券:2604231726038396907201,订单:2604231726030081973321,[2026-04-23 17:26:10支付宝支付12元]
2026-04-23 17:26:10>>>MQTT票号同步场景，创建空订单对象
2026-04-23 17:26:10>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-23 17:26:12 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604231726038396907201","queue_number":88,"trade_uid":"2604231726030081973321"}]}
2026-04-23 17:26:12 >>>故障排除日志:删除未同步下发订单成功2604231726030081973321
2026-04-23 17:26:12 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536875884]


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


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


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


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


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


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


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


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


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


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


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


===18:14:44===
2026-04-23 18:14:28>>>cash read=0A
2026-04-23 18:14:29>>>cash read=3E


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


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


===18:19:44===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-23 18:18:44 >>>回调事件[910,devices/S1754]
2026-04-23 18:18:45 >>>故障排除日志:上一MQTT订单号缓存列表为2604231816280009477079
2026-04-23 18:18:45 >>>故障排除日志:终端未同步成功订单列表
2026-04-23 18:18:45 开始打印,排队:103,票券:2604231818373334023701,订单:2604231818370031351861,[2026-04-23 18:18:44微信支付12元]
2026-04-23 18:18:45>>>MQTT票号同步场景，创建空订单对象
2026-04-23 18:18:45>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-23 18:18:47 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604231818373334023701","queue_number":103,"trade_uid":"2604231818370031351861"}]}
2026-04-23 18:18:47 >>>故障排除日志:删除未同步下发订单成功2604231818370031351861
2026-04-23 18:18:47 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536876485]
2026-04-23 18:18:59>>>cash read=0A
2026-04-23 18:19:00>>>cash read=3E
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-23 18:19:17 >>>回调事件[910,devices/S1754]
2026-04-23 18:19:17 >>>故障排除日志:上一MQTT订单号缓存列表为2604231818370031351861
2026-04-23 18:19:17 >>>故障排除日志:终端未同步成功订单列表
2026-04-23 18:19:17 开始打印,排队:104,票券:2604231819097077975701,订单:2604231819090068509373,[2026-04-23 18:19:16支付宝支付12元]
2026-04-23 18:19:17>>>MQTT票号同步场景，创建空订单对象
2026-04-23 18:19:17>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-23 18:19:19 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604231819097077975701","queue_number":104,"trade_uid":"2604231819090068509373"}]}
2026-04-23 18:19:19 >>>故障排除日志:删除未同步下发订单成功2604231819090068509373
2026-04-23 18:19:19 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536876500]


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


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


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


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


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


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


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


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


===19:09:47===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-23 19:08:52 >>>回调事件[910,devices/S1754]
2026-04-23 19:08:52 >>>故障排除日志:上一MQTT订单号缓存列表为2604231904480039544227
2026-04-23 19:08:52 >>>故障排除日志:终端未同步成功订单列表
2026-04-23 19:08:52 开始打印,排队:113,票券:2604231908438177221701,订单:2604231908430080018943,[2026-04-23 19:08:52微信支付12元]
2026-04-23 19:08:53>>>MQTT票号同步场景，创建空订单对象
2026-04-23 19:08:53>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-23 19:08:55 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604231908438177221701","queue_number":113,"trade_uid":"2604231908430080018943"}]}
2026-04-23 19:08:55 >>>故障排除日志:删除未同步下发订单成功2604231908430080018943
2026-04-23 19:08:55 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877013]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-23 19:09:28 >>>回调事件[910,devices/S1754]
2026-04-23 19:09:28 >>>故障排除日志:上一MQTT订单号缓存列表为2604231908430080018943
2026-04-23 19:09:28 >>>故障排除日志:终端未同步成功订单列表
2026-04-23 19:09:28 开始打印,排队:114,票券:2604231909209699768501,订单:2604231909200095135738,[2026-04-23 19:09:27微信支付12元]
2026-04-23 19:09:28>>>MQTT票号同步场景，创建空订单对象
2026-04-23 19:09:28>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-23 19:09:30 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604231909209699768501","queue_number":114,"trade_uid":"2604231909200095135738"}]}
2026-04-23 19:09:30 >>>故障排除日志:删除未同步下发订单成功2604231909200095135738
2026-04-23 19:09:30 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877027]


===19:14:48===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-23 19:14:45 >>>回调事件[910,devices/S1754]
2026-04-23 19:14:45 >>>故障排除日志:上一MQTT订单号缓存列表为2604231909200095135738
2026-04-23 19:14:45 >>>故障排除日志:终端未同步成功订单列表
2026-04-23 19:14:45 开始打印,排队:115,票券:2604231914413810554301,订单:2604231914410036232278,[2026-04-23 19:14:45支付宝支付12元]
2026-04-23 19:14:45>>>MQTT票号同步场景，创建空订单对象
2026-04-23 19:14:45>>>合并MQTT票号列表到订单同步请求,共1张票


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


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


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


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


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


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


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


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


===19:38:51===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-23 19:37:56 >>>回调事件[910,devices/S1754]
2026-04-23 19:37:56 >>>故障排除日志:上一MQTT订单号缓存列表为2604231937330069665753
2026-04-23 19:37:56 >>>故障排除日志:终端未同步成功订单列表
2026-04-23 19:37:56 开始打印,排队:125,票券:2604231937529649301801,订单:2604231937520094592145,[2026-04-23 19:37:56支付宝支付12元]
2026-04-23 19:37:56>>>MQTT票号同步场景，创建空订单对象
2026-04-23 19:37:56>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-23 19:37:58 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604231937529649301801","queue_number":125,"trade_uid":"2604231937520094592145"}]}
2026-04-23 19:37:58 >>>故障排除日志:删除未同步下发订单成功2604231937520094592145
2026-04-23 19:37:58 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877366]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-23 19:38:28 >>>回调事件[910,devices/S1754]
2026-04-23 19:38:29 >>>故障排除日志:上一MQTT订单号缓存列表为2604231937520094592145
2026-04-23 19:38:29 >>>故障排除日志:终端未同步成功订单列表
2026-04-23 19:38:29 开始打印,排队:126,票券:2604231938197672659701,订单:2604231938190074868678,[2026-04-23 19:38:29微信支付12元]
2026-04-23 19:38:29>>>MQTT票号同步场景，创建空订单对象
2026-04-23 19:38:29>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-23 19:38:31 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604231938197672659701","queue_number":126,"trade_uid":"2604231938190074868678"}]}
2026-04-23 19:38:31 >>>故障排除日志:删除未同步下发订单成功2604231938190074868678
2026-04-23 19:38:31 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877380]


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


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


===19:48:51===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-23 19:47:55 >>>回调事件[910,devices/S1754]
2026-04-23 19:47:55 >>>故障排除日志:上一MQTT订单号缓存列表为2604231946130024024251
2026-04-23 19:47:55 >>>故障排除日志:终端未同步成功订单列表
2026-04-23 19:47:55 开始打印,排队:129,票券:2604231947464597452701,订单:2604231947460044178223,[2026-04-23 19:47:54微信支付12元]
2026-04-23 19:47:55>>>MQTT票号同步场景，创建空订单对象
2026-04-23 19:47:55>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-23 19:47:57 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604231947464597452701","queue_number":129,"trade_uid":"2604231947460044178223"}]}
2026-04-23 19:47:57 >>>故障排除日志:删除未同步下发订单成功2604231947460044178223
2026-04-23 19:47:57 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877486]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-23 19:48:40 >>>回调事件[910,devices/S1754]
2026-04-23 19:48:40 >>>故障排除日志:上一MQTT订单号缓存列表为2604231947460044178223
2026-04-23 19:48:40 >>>故障排除日志:终端未同步成功订单列表
2026-04-23 19:48:40 开始打印,排队:130,票券:2604231948304694791501,订单:2604231948300044532897,[2026-04-23 19:48:39微信支付12元]
2026-04-23 19:48:40>>>MQTT票号同步场景，创建空订单对象
2026-04-23 19:48:40>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-23 19:48:42 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604231948304694791501","queue_number":130,"trade_uid":"2604231948300044532897"}]}
2026-04-23 19:48:42 >>>故障排除日志:删除未同步下发订单成功2604231948300044532897
2026-04-23 19:48:42 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877500]


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


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


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


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


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


===20:11:53===
2026-04-23 20:11:04>>>cash read=0A
2026-04-23 20:11:05>>>cash read=3E


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


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


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


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


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


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


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


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


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


===20:51:56===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-23 20:51:04 >>>回调事件[910,devices/S1754]
2026-04-23 20:51:04 >>>故障排除日志:上一MQTT订单号缓存列表为2604232045080082638264
2026-04-23 20:51:04 >>>故障排除日志:终端未同步成功订单列表
2026-04-23 20:51:04 开始打印,排队:149,票券:2604232050563482897401,订单:2604232050560032929297,[2026-04-23 20:51:04微信支付12元]
2026-04-23 20:51:04>>>MQTT票号同步场景，创建空订单对象
2026-04-23 20:51:04>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-23 20:51:06 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604232050563482897401","queue_number":149,"trade_uid":"2604232050560032929297"}]}
2026-04-23 20:51:06 >>>故障排除日志:删除未同步下发订单成功2604232050560032929297
2026-04-23 20:51:07 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878216]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-23 20:51:10 >>>回调事件[910,devices/S1754]
2026-04-23 20:51:10 >>>故障排除日志:上一MQTT订单号缓存列表为2604232050560032929297
2026-04-23 20:51:10 >>>故障排除日志:终端未同步成功订单列表
2026-04-23 20:51:10 开始打印,排队:150,票券:2604232051012653662101,订单:2604232051010024506354,[2026-04-23 20:51:10微信支付12元]
2026-04-23 20:51:10>>>MQTT票号同步场景，创建空订单对象
2026-04-23 20:51:10>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-23 20:51:12 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604232051012653662101","queue_number":150,"trade_uid":"2604232051010024506354"}]}
2026-04-23 20:51:12 >>>故障排除日志:删除未同步下发订单成功2604232051010024506354
2026-04-23 20:51:12 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878222]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-23 20:51:20 >>>回调事件[910,devices/S1754]
2026-04-23 20:51:20 >>>故障排除日志:上一MQTT订单号缓存列表为2604232051010024506354
2026-04-23 20:51:20 >>>故障排除日志:终端未同步成功订单列表
2026-04-23 20:51:20 开始打印,排队:151,票券:2604232051117098166101,订单:2604232051110068824089,[2026-04-23 20:51:20微信支付12元]
2026-04-23 20:51:20>>>MQTT票号同步场景，创建空订单对象
2026-04-23 20:51:20>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-23 20:51:22 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604232051117098166101","queue_number":151,"trade_uid":"2604232051110068824089"}]}
2026-04-23 20:51:22 >>>故障排除日志:删除未同步下发订单成功2604232051110068824089
2026-04-23 20:51:22 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878234]


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


===22:14:03===
2026-04-23 22:13:11>>>cash read=0A
2026-04-23 22:13:12>>>cash read=3E


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


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


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


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


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


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


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


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


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


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


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


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


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


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


===23:11:08===
2026-04-23 23:10:29>>>cash read=0A
2026-04-23 23:10:30>>>cash read=3E