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

===07:37:34===
上一时间戳为1777076637
隔日重置时间戳true
隔日清空未同步下发列表true
当前排队号为1,音量为5
初始化产品信息:[{"time_limit_date":"","ticket_category":"0","expiry_date":90,"product_detail":"","time_limit_status":"0","begin_minute":"00","product_uid":"4351590954436789145","use_timer":1,"old_price":"10","end_hour":"23","sale_price":"10","end_minute":"59","begin_hour":"00","sale_status":1,"product_name":"快剪"}]
打印门店标题设置为欢迎光临恒剪（温州塘下大润发）
打印门店凭条广告设置为恒剪（温州塘下大润发）
是否打印二维码设置为1
是否打印紧凑设置为3
当前号显示模式设置为1
当前卡项核销权限设置为0
session_id:a9ecd****49ccd
纸币器设置接收纸币范围为36
欢迎使用天羚自助售票系统[2.8.6]
定时检测未同步订单启用[checkOrderNum=536870969]
2026-04-26 07:36:33>>>cash write=30
2026-04-26 07:36:33>>>cash write=02
2026-04-26 07:36:33>>>cash write=3E
2026-04-26 07:36:33>>>cash read=808F808F808F
系统时间初始化成功，时间为202642673633
2026-04-26 07:36:34>>>cash write=02
2026-04-26 07:36:34 >>>剩余flash空间=1680000,占用RAM为656.2998046875
2026-04-26 07:36:34 >>>回调事件:910,subscribe,10000,连接服务器成功

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

2026-04-26 07:36:37>>>cash write=0C
2026-04-26 07:36:37>>>cash read=3E
流量卡还有308天过期
2026-04-26 07:36:41 >>>当前Ram内存为649.4609375


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


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


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


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


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


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


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


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


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


===08:52:38===
2026-04-26 08:52:07>>>cash read=0A
2026-04-26 08:52:08>>>cash read=3E


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


===12:53:54===
2026-04-26 12:53:42>>>cash read=0A
2026-04-26 12:53:43>>>cash read=3E


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


===14:41:04===
2026-04-26 14:40:06>>>cash read=00
2026-04-26 14:40:07>>>cash read=3E


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


===14:49:05===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 14:48:18 >>>回调事件[910,devices/D0361]
2026-04-26 14:48:18 >>>故障排除日志:上一MQTT订单号缓存列表为2604261442490024824997
2026-04-26 14:48:18 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 14:48:18 开始打印,排队:90,票券:2604261448112689205801,订单:2604261448110024996859,[2026-04-26 14:48:18微信支付10元]
2026-04-26 14:48:18>>>MQTT票号同步场景，创建空订单对象
2026-04-26 14:48:18>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 14:48:20 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261448112689205801","queue_number":90,"trade_uid":"2604261448110024996859"}]}
2026-04-26 14:48:20 >>>故障排除日志:删除未同步下发订单成功2604261448110024996859
2026-04-26 14:48:21 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536875543]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 14:48:22 >>>回调事件[910,devices/D0361]
2026-04-26 14:48:22 >>>故障排除日志:上一MQTT订单号缓存列表为2604261448110024996859
2026-04-26 14:48:22 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 14:48:22 开始打印,排队:91,票券:2604261448131814295201,订单:2604261448130016242857,[2026-04-26 14:48:22支付宝支付10元]
2026-04-26 14:48:22>>>MQTT票号同步场景，创建空订单对象
2026-04-26 14:48:22>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 14:48:24 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261448131814295201","queue_number":91,"trade_uid":"2604261448130016242857"}]}
2026-04-26 14:48:24 >>>故障排除日志:删除未同步下发订单成功2604261448130016242857
2026-04-26 14:48:24 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536875549]


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


===15:58:13===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 15:58:08 >>>回调事件[910,devices/D0361]
2026-04-26 15:58:08 >>>故障排除日志:上一MQTT订单号缓存列表为2604261546520099168467
2026-04-26 15:58:08 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 15:58:08 开始打印,排队:119,票券:2604261558030457605601,订单:2604261558030002617159,[2026-04-26 15:58:08微信支付10元]
2026-04-26 15:58:08 开始打印,排队:120,票券:2604261558030458002502,订单:2604261558030002617159,[2026-04-26 15:58:08微信支付10元]
2026-04-26 15:58:08>>>MQTT票号同步场景，创建空订单对象
2026-04-26 15:58:08>>>合并MQTT票号列表到订单同步请求,共2张票


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


===16:09:14===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 16:08:19 >>>回调事件[910,devices/D0361]
2026-04-26 16:08:19 >>>故障排除日志:上一MQTT订单号缓存列表为2604261603200059689013
2026-04-26 16:08:19 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 16:08:19 开始打印,排队:122,票券:2604261608110657348201,订单:2604261608110004218932,[2026-04-26 16:08:19微信支付10元]
2026-04-26 16:08:19>>>MQTT票号同步场景，创建空订单对象
2026-04-26 16:08:19>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 16:08:21 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261608110657348201","queue_number":122,"trade_uid":"2604261608110004218932"}]}
2026-04-26 16:08:21 >>>故障排除日志:删除未同步下发订单成功2604261608110004218932
2026-04-26 16:08:21 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536876530]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 16:08:31 >>>回调事件[910,devices/D0361]
2026-04-26 16:08:31 >>>故障排除日志:上一MQTT订单号缓存列表为2604261608110004218932
2026-04-26 16:08:31 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 16:08:31 开始打印,排队:123,票券:2604261608248724892301,订单:2604261608240085098357,[2026-04-26 16:08:31微信支付10元]
2026-04-26 16:08:31 开始打印,排队:124,票券:2604261608248725393802,订单:2604261608240085098357,[2026-04-26 16:08:31微信支付10元]
2026-04-26 16:08:32>>>MQTT票号同步场景，创建空订单对象
2026-04-26 16:08:32>>>合并MQTT票号列表到订单同步请求,共2张票
2026-04-26 16:08:35 >>>回调事件[910,devices/D0361]
2026-04-26 16:08:35 >>>故障排除日志:上一MQTT订单号缓存列表为2604261608240085098357|2604261608240085098357
2026-04-26 16:08:35 >>>故障排除日志:终端未同步成功订单列表01232604261608240085098357|01242604261608240085098357
2026-04-26 16:08:35 开始打印,排队:125,票券:2604261608241870669501,订单:2604261608240016673253,[2026-04-26 16:08:33微信支付10元]
已接收过此消息,票券号为2604261608248724892301,排队号为123
已接收过此消息,票券号为2604261608248725393802,排队号为124
2026-04-26 16:08:35>>>HTTP请求进行中，跳过本次同步
2026-04-26 16:08:37 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261608248724892301","queue_number":123,"trade_uid":"2604261608240085098357"},{"ticket_no":"2604261608248725393802","queue_number":124,"trade_uid":"2604261608240085098357"}]}
2026-04-26 16:08:37 >>>故障排除日志:删除未同步下发订单成功2604261608240085098357
2026-04-26 16:08:37 >>>故障排除日志:删除未同步下发订单成功2604261608240085098357
2026-04-26 16:08:37 >>>故障排除日志:终端同步成功后剩余订单列表01252604261608240016673253
定时检测未同步订单启用[checkOrderNum=536876541]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 16:08:55 >>>回调事件[910,devices/D0361]
2026-04-26 16:08:55 >>>故障排除日志:上一MQTT订单号缓存列表为2604261608240016673253|2604261608240085098357|2604261608240085098357
2026-04-26 16:08:55 >>>故障排除日志:终端未同步成功订单列表01252604261608240016673253
已接收过此消息,票券号为2604261608241870669501,排队号为125
2026-04-26 16:08:55 开始打印,排队:126,票券:2604261608478784007401,订单:2604261608470086003875,[2026-04-26 16:08:54微信支付10元]
2026-04-26 16:08:55>>>MQTT票号同步场景，创建空订单对象
2026-04-26 16:08:55>>>合并MQTT票号列表到订单同步请求,共2张票
2026-04-26 16:08:57 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261608241870669501","queue_number":125,"trade_uid":"2604261608240016673253"},{"ticket_no":"2604261608478784007401","queue_number":126,"trade_uid":"2604261608470086003875"}]}
2026-04-26 16:08:57 >>>故障排除日志:删除未同步下发订单成功2604261608240016673253
2026-04-26 16:08:57 >>>故障排除日志:删除未同步下发订单成功2604261608470086003875
2026-04-26 16:08:57 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536876548]


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


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


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


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


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


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


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


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


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


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


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


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


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


===16:44:18===
2026-04-26 16:43:52>>>cash read=00
2026-04-26 16:43:52>>>cash read=818F42
2026-04-26 16:43:52>>>cash write=02
2026-04-26 16:43:52 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 16:43:52>>>cash read=10
2026-04-26 16:43:52 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 16:43:52 当前产品价格10元，投币10元，打印小票中...
2026-04-26 16:43:52 >>>开始打印,排队号为142,订单号为2604261643520040361844
2026-04-26 16:43:53>>>订单2604261643520040361844写入成功,剩余空间为1679500,占用RAM为632.56640625
删除未同步订单2604261643520040361844
2026-04-26 16:43:55>>>订单2604261643520040361844删除成功,剩余空间为1680500,占用RAM为643.279296875
检测订单目录中>>>
无未同步订单>>>
2026-04-26 16:43:55 >>>当前Ram内存为615.55859375
定时检测未同步订单启用[checkOrderNum=536876981]
2026-04-26 16:43:56>>>cash write=0C
2026-04-26 16:43:56>>>cash read=3E


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


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


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


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


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


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


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


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


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


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


===17:15:21===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 17:14:21 >>>回调事件[910,devices/D0361]
2026-04-26 17:14:21 >>>故障排除日志:上一MQTT订单号缓存列表为2604261713500032328075
2026-04-26 17:14:21 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 17:14:21 开始打印,排队:157,票券:2604261714163032233401,订单:2604261714160027509361,[2026-04-26 17:14:21微信支付10元]
2026-04-26 17:14:21>>>MQTT票号同步场景，创建空订单对象
2026-04-26 17:14:21>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 17:14:23 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261714163032233401","queue_number":157,"trade_uid":"2604261714160027509361"}]}
2026-04-26 17:14:23 >>>故障排除日志:删除未同步下发订单成功2604261714160027509361
2026-04-26 17:14:23 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877360]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 17:14:31 >>>回调事件[910,devices/D0361]
2026-04-26 17:14:31 >>>故障排除日志:上一MQTT订单号缓存列表为2604261714160027509361
2026-04-26 17:14:31 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 17:14:31 开始打印,排队:158,票券:2604261714249940426501,订单:2604261714240096790171,[2026-04-26 17:14:31微信支付10元]
2026-04-26 17:14:31 开始打印,排队:159,票券:2604261714249941201602,订单:2604261714240096790171,[2026-04-26 17:14:31微信支付10元]
2026-04-26 17:14:31>>>MQTT票号同步场景，创建空订单对象
2026-04-26 17:14:31>>>合并MQTT票号列表到订单同步请求,共2张票
2026-04-26 17:14:35 >>>回调事件[910,devices/D0361]
2026-04-26 17:14:35 >>>故障排除日志:上一MQTT订单号缓存列表为2604261714240096790171|2604261714240096790171
2026-04-26 17:14:35 >>>故障排除日志:终端未同步成功订单列表01582604261714240096790171|01592604261714240096790171
已接收过此消息,票券号为2604261714249940426501,排队号为158
已接收过此消息,票券号为2604261714249941201602,排队号为159
2026-04-26 17:14:35 开始打印,排队:160,票券:2604261714259989629101,订单:2604261714250097937648,[2026-04-26 17:14:31微信支付10元]
2026-04-26 17:14:35>>>HTTP请求进行中，跳过本次同步
2026-04-26 17:14:37 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261714249940426501","queue_number":158,"trade_uid":"2604261714240096790171"},{"ticket_no":"2604261714249941201602","queue_number":159,"trade_uid":"2604261714240096790171"}]}
2026-04-26 17:14:37 >>>故障排除日志:删除未同步下发订单成功2604261714240096790171
2026-04-26 17:14:37 >>>故障排除日志:删除未同步下发订单成功2604261714240096790171
2026-04-26 17:14:37 >>>故障排除日志:终端同步成功后剩余订单列表01602604261714250097937648
定时检测未同步订单启用[checkOrderNum=536877373]


===17:16:21===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 17:15:51 >>>回调事件[910,devices/D0361]
2026-04-26 17:15:51 >>>故障排除日志:上一MQTT订单号缓存列表为2604261714240096790171|2604261714240096790171|2604261714250097937648
2026-04-26 17:15:51 >>>故障排除日志:终端未同步成功订单列表01602604261714250097937648
已接收过此消息,票券号为2604261714259989629101,排队号为160
2026-04-26 17:15:51 开始打印,排队:161,票券:2604261715453452156401,订单:2604261715450032517573,[2026-04-26 17:15:51微信支付10元]
2026-04-26 17:15:51>>>MQTT票号同步场景，创建空订单对象
2026-04-26 17:15:51>>>合并MQTT票号列表到订单同步请求,共2张票
2026-04-26 17:15:53 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261714259989629101","queue_number":160,"trade_uid":"2604261714250097937648"},{"ticket_no":"2604261715453452156401","queue_number":161,"trade_uid":"2604261715450032517573"}]}
2026-04-26 17:15:53 >>>故障排除日志:删除未同步下发订单成功2604261714250097937648
2026-04-26 17:15:53 >>>故障排除日志:删除未同步下发订单成功2604261715450032517573
2026-04-26 17:15:53 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877391]


===17:20:22===
2026-04-26 17:19:31>>>cash read=0A
2026-04-26 17:19:32>>>cash read=3E


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


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


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


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


===17:26:24===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 17:26:02 >>>回调事件[910,devices/D0361]
2026-04-26 17:26:02 >>>故障排除日志:上一MQTT订单号缓存列表为2604261724580024443218
2026-04-26 17:26:02 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 17:26:02 开始打印,排队:167,票券:2604261725538221979801,订单:2604261725530079762526,[2026-04-26 17:26:02支付宝支付10元]
2026-04-26 17:26:02>>>MQTT票号同步场景，创建空订单对象
2026-04-26 17:26:02>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 17:26:04 >>>回调事件[910,devices/D0361]
2026-04-26 17:26:04 >>>故障排除日志:上一MQTT订单号缓存列表为2604261725530079762526
2026-04-26 17:26:04 >>>故障排除日志:终端未同步成功订单列表01672604261725530079762526
已接收过此消息,票券号为2604261725538221979801,排队号为167
2026-04-26 17:26:04 开始打印,排队:168,票券:2604261725580592257801,订单:2604261725580003971379,[2026-04-26 17:26:03微信支付10元]
2026-04-26 17:26:04>>>HTTP请求进行中，跳过本次同步
2026-04-26 17:26:06 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261725538221979801","queue_number":167,"trade_uid":"2604261725530079762526"}]}
2026-04-26 17:26:06 >>>故障排除日志:删除未同步下发订单成功2604261725530079762526
2026-04-26 17:26:06 >>>故障排除日志:终端同步成功后剩余订单列表01682604261725580003971379
定时检测未同步订单启用[checkOrderNum=536877533]


===17:27:24===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 17:26:26 >>>回调事件[910,devices/D0361]
2026-04-26 17:26:26 >>>故障排除日志:上一MQTT订单号缓存列表为2604261725530079762526|2604261725580003971379
2026-04-26 17:26:26 >>>故障排除日志:终端未同步成功订单列表01682604261725580003971379
已接收过此消息,票券号为2604261725580592257801,排队号为168
2026-04-26 17:26:26 开始打印,排队:169,票券:2604261726205156556801,订单:2604261726200049456676,[2026-04-26 17:26:26支付宝支付10元]
2026-04-26 17:26:27>>>MQTT票号同步场景，创建空订单对象
2026-04-26 17:26:27>>>合并MQTT票号列表到订单同步请求,共2张票
2026-04-26 17:26:28 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261725580592257801","queue_number":168,"trade_uid":"2604261725580003971379"},{"ticket_no":"2604261726205156556801","queue_number":169,"trade_uid":"2604261726200049456676"}]}
2026-04-26 17:26:29 >>>故障排除日志:删除未同步下发订单成功2604261725580003971379
2026-04-26 17:26:29 >>>故障排除日志:删除未同步下发订单成功2604261726200049456676
2026-04-26 17:26:29 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877542]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 17:26:33 >>>回调事件[910,devices/D0361]
2026-04-26 17:26:34 >>>故障排除日志:上一MQTT订单号缓存列表为2604261725580003971379|2604261726200049456676
2026-04-26 17:26:34 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 17:26:34 开始打印,排队:170,票券:2604261726242658251801,订单:2604261726240024311547,[2026-04-26 17:26:34微信支付10元]
2026-04-26 17:26:34>>>MQTT票号同步场景，创建空订单对象
2026-04-26 17:26:34>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 17:26:36 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261726242658251801","queue_number":170,"trade_uid":"2604261726240024311547"}]}
2026-04-26 17:26:36 >>>故障排除日志:删除未同步下发订单成功2604261726240024311547
2026-04-26 17:26:36 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877553]


===17:28:24===
2026-04-26 17:28:04>>>cash read=00
2026-04-26 17:28:04>>>cash read=818F43
2026-04-26 17:28:04>>>cash write=02
2026-04-26 17:28:04 >>>回调事件130,cash_status,10022,进钞中...read money=20
2026-04-26 17:28:05>>>cash read=10
2026-04-26 17:28:05 >>>回调事件130,20,10023,finish Money=20,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 17:28:05 当前产品价格10元，投币20元，打印小票中...
2026-04-26 17:28:05 >>>开始打印,排队号为171,订单号为2604261728050040361496
2026-04-26 17:28:05 >>>开始打印,排队号为172,订单号为2604261728050040361496
2026-04-26 17:28:06>>>订单2604261728050040361496写入成功,剩余空间为1679000,占用RAM为640.048828125
删除未同步订单2604261728050040361496
2026-04-26 17:28:09>>>订单2604261728050040361496删除成功,剩余空间为1680500,占用RAM为656.056640625
检测订单目录中>>>
无未同步订单>>>
2026-04-26 17:28:09 >>>当前Ram内存为616.630859375
定时检测未同步订单启用[checkOrderNum=536877574]
2026-04-26 17:28:10>>>cash write=0C
2026-04-26 17:28:10>>>cash read=3E


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


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


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


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


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


===17:39:26===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 17:38:49 >>>回调事件[910,devices/D0361]
2026-04-26 17:38:49 >>>故障排除日志:上一MQTT订单号缓存列表为2604261735280075851812
2026-04-26 17:38:49 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 17:38:49 开始打印,排队:178,票券:2604261738432375124701,订单:2604261738430021713678,[2026-04-26 17:38:48微信支付10元]
2026-04-26 17:38:49>>>MQTT票号同步场景，创建空订单对象
2026-04-26 17:38:49>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 17:38:51 >>>回调事件[910,devices/D0361]
2026-04-26 17:38:51 >>>故障排除日志:上一MQTT订单号缓存列表为2604261738430021713678
2026-04-26 17:38:51 >>>故障排除日志:终端未同步成功订单列表01782604261738430021713678
2026-04-26 17:38:51 开始打印,排队:179,票券:2604261738425566675401,订单:2604261738420053400134,[2026-04-26 17:38:50微信支付10元]
已接收过此消息,票券号为2604261738432375124701,排队号为178
2026-04-26 17:38:51>>>HTTP请求进行中，跳过本次同步
2026-04-26 17:38:53 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261738432375124701","queue_number":178,"trade_uid":"2604261738430021713678"}]}
2026-04-26 17:38:53 >>>故障排除日志:删除未同步下发订单成功2604261738430021713678
2026-04-26 17:38:53 >>>故障排除日志:终端同步成功后剩余订单列表01792604261738420053400134
定时检测未同步订单启用[checkOrderNum=536877718]


===17:40:27===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 17:40:02 >>>回调事件[910,devices/D0361]
2026-04-26 17:40:02 >>>故障排除日志:上一MQTT订单号缓存列表为2604261738420053400134|2604261738430021713678
2026-04-26 17:40:02 >>>故障排除日志:终端未同步成功订单列表01792604261738420053400134
已接收过此消息,票券号为2604261738425566675401,排队号为179
2026-04-26 17:40:02 开始打印,排队:180,票券:2604261739567310949501,订单:2604261739560069939238,[2026-04-26 17:40:02微信支付10元]
2026-04-26 17:40:02>>>MQTT票号同步场景，创建空订单对象
2026-04-26 17:40:02>>>合并MQTT票号列表到订单同步请求,共2张票
2026-04-26 17:40:04 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261738425566675401","queue_number":179,"trade_uid":"2604261738420053400134"},{"ticket_no":"2604261739567310949501","queue_number":180,"trade_uid":"2604261739560069939238"}]}
2026-04-26 17:40:04 >>>故障排除日志:删除未同步下发订单成功2604261738420053400134
2026-04-26 17:40:04 >>>故障排除日志:删除未同步下发订单成功2604261739560069939238
2026-04-26 17:40:04 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877738]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 17:40:15 >>>回调事件[910,devices/D0361]
2026-04-26 17:40:15 >>>故障排除日志:上一MQTT订单号缓存列表为2604261738420053400134|2604261739560069939238
2026-04-26 17:40:15 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 17:40:15 开始打印,排队:181,票券:2604261740090190287601,订单:2604261740080099450937,[2026-04-26 17:40:14微信支付10元]
2026-04-26 17:40:15>>>MQTT票号同步场景，创建空订单对象
2026-04-26 17:40:15>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 17:40:17 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261740090190287601","queue_number":181,"trade_uid":"2604261740080099450937"}]}
2026-04-26 17:40:17 >>>故障排除日志:删除未同步下发订单成功2604261740080099450937
2026-04-26 17:40:17 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877744]


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


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


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


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


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


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


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


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


===18:06:32===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 18:05:39 >>>回调事件[910,devices/D0361]
2026-04-26 18:05:39 >>>故障排除日志:上一MQTT订单号缓存列表为2604261804380023215258
2026-04-26 18:05:39 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 18:05:39 开始打印,排队:190,票券:2604261805339233785301,订单:2604261805330090486821,[2026-04-26 18:05:39支付宝支付10元]
2026-04-26 18:05:40>>>MQTT票号同步场景，创建空订单对象
2026-04-26 18:05:40>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 18:05:42 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261805339233785301","queue_number":190,"trade_uid":"2604261805330090486821"}]}
2026-04-26 18:05:42 >>>故障排除日志:删除未同步下发订单成功2604261805330090486821
2026-04-26 18:05:42 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878047]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 18:06:13 >>>回调事件[910,devices/D0361]
2026-04-26 18:06:13 >>>故障排除日志:上一MQTT订单号缓存列表为2604261805330090486821
2026-04-26 18:06:13 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 18:06:13 开始打印,排队:191,票券:2604261806057608655401,订单:2604261806050073644263,[2026-04-26 18:06:13微信支付10元]
2026-04-26 18:06:13 开始打印,排队:192,票券:2604261806057609201602,订单:2604261806050073644263,[2026-04-26 18:06:13微信支付10元]
2026-04-26 18:06:13>>>MQTT票号同步场景，创建空订单对象
2026-04-26 18:06:13>>>合并MQTT票号列表到订单同步请求,共2张票
2026-04-26 18:06:17 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261806057608655401","queue_number":191,"trade_uid":"2604261806050073644263"},{"ticket_no":"2604261806057609201602","queue_number":192,"trade_uid":"2604261806050073644263"}]}
2026-04-26 18:06:17 >>>故障排除日志:删除未同步下发订单成功2604261806050073644263
2026-04-26 18:06:17 >>>故障排除日志:删除未同步下发订单成功2604261806050073644263
2026-04-26 18:06:17 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878056]


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


===18:09:36===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 18:09:28 >>>回调事件[910,devices/D0361]
2026-04-26 18:09:28 >>>故障排除日志:上一MQTT订单号缓存列表为2604261808150078505723
2026-04-26 18:09:28 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 18:09:28 开始打印,排队:194,票券:2604261809226330672401,订单:2604261809220060809271,[2026-04-26 18:09:28微信支付10元]
2026-04-26 18:09:29>>>MQTT票号同步场景，创建空订单对象
2026-04-26 18:09:29>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 18:09:30 >>>回调事件[910,devices/D0361]
2026-04-26 18:09:30 >>>故障排除日志:上一MQTT订单号缓存列表为2604261809220060809271
2026-04-26 18:09:30 >>>故障排除日志:终端未同步成功订单列表01942604261809220060809271
已接收过此消息,票券号为2604261809226330672401,排队号为194
2026-04-26 18:09:30 开始打印,排队:195,票券:2604261809229517497201,订单:2604261809220093403242,[2026-04-26 18:09:29微信支付10元]
2026-04-26 18:09:30 开始打印,排队:196,票券:2604261809229517998602,订单:2604261809220093403242,[2026-04-26 18:09:29微信支付10元]
2026-04-26 18:09:31>>>HTTP请求进行中，跳过本次同步


===18:20:36===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 18:19:38 >>>回调事件[910,devices/D0361]
2026-04-26 18:19:38 >>>故障排除日志:上一MQTT订单号缓存列表为2604261809220060809271|2604261809220093403242|2604261809220093403242
2026-04-26 18:19:38 >>>故障排除日志:终端未同步成功订单列表01952604261809220093403242|01962604261809220093403242
已接收过此消息,票券号为2604261809229517497201,排队号为195
已接收过此消息,票券号为2604261809229517998602,排队号为196
2026-04-26 18:19:38 开始打印,排队:197,票券:2604261819281400214601,订单:2604261819280011744623,[2026-04-26 18:19:37微信支付10元]
2026-04-26 18:19:38>>>MQTT票号同步场景，创建空订单对象
2026-04-26 18:19:38>>>合并MQTT票号列表到订单同步请求,共3张票
2026-04-26 18:19:40 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261809229517497201","queue_number":195,"trade_uid":"2604261809220093403242"},{"ticket_no":"2604261809229517998602","queue_number":196,"trade_uid":"2604261809220093403242"},{"ticket_no":"2604261819281400214601","queue_number":197,"trade_uid":"2604261819280011744623"}]}
2026-04-26 18:19:40 >>>故障排除日志:删除未同步下发订单成功2604261809220093403242
2026-04-26 18:19:40 >>>故障排除日志:删除未同步下发订单成功2604261809220093403242
2026-04-26 18:19:40 >>>故障排除日志:删除未同步下发订单成功2604261819280011744623
2026-04-26 18:19:40 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878212]


===18:30:37===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 18:29:55 >>>回调事件[910,devices/D0361]
2026-04-26 18:29:55 >>>故障排除日志:上一MQTT订单号缓存列表为2604261809220093403242|2604261809220093403242|2604261819280011744623
2026-04-26 18:29:55 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 18:29:56 开始打印,排队:198,票券:2604261829486255756701,订单:2604261829480060436965,[2026-04-26 18:29:56微信支付10元]
2026-04-26 18:29:56>>>MQTT票号同步场景，创建空订单对象
2026-04-26 18:29:56>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 18:29:58 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261829486255756701","queue_number":198,"trade_uid":"2604261829480060436965"}]}
2026-04-26 18:29:58 >>>故障排除日志:删除未同步下发订单成功2604261829480060436965
2026-04-26 18:29:58 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878311]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 18:30:14 >>>回调事件[910,devices/D0361]
2026-04-26 18:30:14 >>>故障排除日志:上一MQTT订单号缓存列表为2604261829480060436965
2026-04-26 18:30:14 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 18:30:14 开始打印,排队:199,票券:2604261830114624854101,订单:2604261830110044375375,[2026-04-26 18:30:14支付宝支付10元]
2026-04-26 18:30:15>>>MQTT票号同步场景，创建空订单对象
2026-04-26 18:30:15>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 18:30:17 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261830114624854101","queue_number":199,"trade_uid":"2604261830110044375375"}]}
2026-04-26 18:30:17 >>>故障排除日志:删除未同步下发订单成功2604261830110044375375
2026-04-26 18:30:17 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878319]


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


===18:33:37===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 18:32:44 >>>回调事件[910,devices/D0361]
2026-04-26 18:32:44 >>>故障排除日志:上一MQTT订单号缓存列表为2604261830440015429938
2026-04-26 18:32:44 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 18:32:44 开始打印,排队:201,票券:2604261832343101812501,订单:2604261832340029005558,[2026-04-26 18:32:44支付宝支付10元]
2026-04-26 18:32:44 开始打印,排队:202,票券:2604261832343102269102,订单:2604261832340029005558,[2026-04-26 18:32:44支付宝支付10元]
2026-04-26 18:32:44>>>MQTT票号同步场景，创建空订单对象
2026-04-26 18:32:45>>>合并MQTT票号列表到订单同步请求,共2张票
2026-04-26 18:32:48 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261832343101812501","queue_number":201,"trade_uid":"2604261832340029005558"},{"ticket_no":"2604261832343102269102","queue_number":202,"trade_uid":"2604261832340029005558"}]}
2026-04-26 18:32:48 >>>故障排除日志:删除未同步下发订单成功2604261832340029005558
2026-04-26 18:32:48 >>>故障排除日志:删除未同步下发订单成功2604261832340029005558
2026-04-26 18:32:48 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878359]


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


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


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


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


===18:44:39===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 18:43:38 >>>回调事件[910,devices/D0361]
2026-04-26 18:43:38 >>>故障排除日志:上一MQTT订单号缓存列表为2604261841500092969745
2026-04-26 18:43:38 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 18:43:38 开始打印,排队:208,票券:2604261843310920597101,订单:2604261843310007103926,[2026-04-26 18:43:37微信支付10元]
2026-04-26 18:43:38>>>MQTT票号同步场景，创建空订单对象
2026-04-26 18:43:38>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 18:43:40 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261843310920597101","queue_number":208,"trade_uid":"2604261843310007103926"}]}
2026-04-26 18:43:40 >>>故障排除日志:删除未同步下发订单成功2604261843310007103926
2026-04-26 18:43:41 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878498]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 18:43:55 >>>回调事件[910,devices/D0361]
2026-04-26 18:43:55 >>>故障排除日志:上一MQTT订单号缓存列表为2604261843310007103926
2026-04-26 18:43:55 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 18:43:55 开始打印,排队:209,票券:2604261843503208682401,订单:2604261843500029738721,[2026-04-26 18:43:55微信支付10元]
2026-04-26 18:43:55>>>MQTT票号同步场景，创建空订单对象
2026-04-26 18:43:55>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 18:43:57 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261843503208682401","queue_number":209,"trade_uid":"2604261843500029738721"}]}
2026-04-26 18:43:57 >>>故障排除日志:删除未同步下发订单成功2604261843500029738721
2026-04-26 18:43:57 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878505]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 18:44:11 >>>回调事件[910,devices/D0361]
2026-04-26 18:44:11 >>>故障排除日志:上一MQTT订单号缓存列表为2604261843500029738721
2026-04-26 18:44:11 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 18:44:11 开始打印,排队:210,票券:2604261844047804494801,订单:2604261844040075488585,[2026-04-26 18:44:10微信支付10元]
2026-04-26 18:44:11>>>MQTT票号同步场景，创建空订单对象
2026-04-26 18:44:11>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 18:44:13 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261844047804494801","queue_number":210,"trade_uid":"2604261844040075488585"}]}
2026-04-26 18:44:13 >>>故障排除日志:删除未同步下发订单成功2604261844040075488585
2026-04-26 18:44:14 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878513]


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


===18:51:42===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 18:50:46 >>>回调事件[910,devices/D0361]
2026-04-26 18:50:46 >>>故障排除日志:上一MQTT订单号缓存列表为2604261847020027550325
2026-04-26 18:50:46 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 18:50:46 开始打印,排队:212,票券:2604261850418747609701,订单:2604261850410085521992,[2026-04-26 18:50:46微信支付10元]
2026-04-26 18:50:47>>>MQTT票号同步场景，创建空订单对象
2026-04-26 18:50:47>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 18:50:48 >>>回调事件[910,devices/D0361]
2026-04-26 18:50:48 >>>故障排除日志:上一MQTT订单号缓存列表为2604261850410085521992
2026-04-26 18:50:48 >>>故障排除日志:终端未同步成功订单列表02122604261850410085521992
2026-04-26 18:50:48 开始打印,排队:213,票券:2604261850415902074301,订单:2604261850410056709062,[2026-04-26 18:50:47微信支付10元]
2026-04-26 18:50:48 开始打印,排队:214,票券:2604261850415902579302,订单:2604261850410056709062,[2026-04-26 18:50:47微信支付10元]
已接收过此消息,票券号为2604261850418747609701,排队号为212
2026-04-26 18:50:49>>>HTTP请求进行中，跳过本次同步
2026-04-26 18:50:52 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261850418747609701","queue_number":212,"trade_uid":"2604261850410085521992"}]}
2026-04-26 18:50:52 >>>故障排除日志:删除未同步下发订单成功2604261850410085521992
2026-04-26 18:50:52 >>>故障排除日志:终端同步成功后剩余订单列表02132604261850410056709062|02142604261850410056709062
定时检测未同步订单启用[checkOrderNum=536878589]


===18:52:43===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 18:51:46 >>>回调事件[910,devices/D0361]
2026-04-26 18:51:46 >>>故障排除日志:上一MQTT订单号缓存列表为2604261850410056709062|2604261850410056709062|2604261850410085521992
2026-04-26 18:51:46 >>>故障排除日志:终端未同步成功订单列表02132604261850410056709062|02142604261850410056709062
已接收过此消息,票券号为2604261850415902074301,排队号为213
已接收过此消息,票券号为2604261850415902579302,排队号为214
2026-04-26 18:51:46 开始打印,排队:215,票券:2604261851398484424501,订单:2604261851390082889535,[2026-04-26 18:51:46微信支付10元]
2026-04-26 18:51:46>>>MQTT票号同步场景，创建空订单对象
2026-04-26 18:51:46>>>合并MQTT票号列表到订单同步请求,共3张票
2026-04-26 18:51:48 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261850415902074301","queue_number":213,"trade_uid":"2604261850410056709062"},{"ticket_no":"2604261850415902579302","queue_number":214,"trade_uid":"2604261850410056709062"},{"ticket_no":"2604261851398484424501","queue_number":215,"trade_uid":"2604261851390082889535"}]}
2026-04-26 18:51:48 >>>故障排除日志:删除未同步下发订单成功2604261850410056709062
2026-04-26 18:51:48 >>>故障排除日志:删除未同步下发订单成功2604261850410056709062
2026-04-26 18:51:48 >>>故障排除日志:删除未同步下发订单成功2604261851390082889535
2026-04-26 18:51:48 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878606]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 18:52:19 >>>回调事件[910,devices/D0361]
2026-04-26 18:52:19 >>>故障排除日志:上一MQTT订单号缓存列表为2604261850410056709062|2604261850410056709062|2604261851390082889535
2026-04-26 18:52:19 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 18:52:19 开始打印,排队:216,票券:2604261852145268092401,订单:2604261852140050630038,[2026-04-26 18:52:19微信支付10元]
2026-04-26 18:52:19>>>MQTT票号同步场景，创建空订单对象
2026-04-26 18:52:19>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 18:52:21 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261852145268092401","queue_number":216,"trade_uid":"2604261852140050630038"}]}
2026-04-26 18:52:21 >>>故障排除日志:删除未同步下发订单成功2604261852140050630038
2026-04-26 18:52:21 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878615]


===18:56:46===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 18:56:41 >>>回调事件[910,devices/D0361]
2026-04-26 18:56:41 >>>故障排除日志:上一MQTT订单号缓存列表为2604261852140050630038
2026-04-26 18:56:41 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 18:56:41 开始打印,排队:217,票券:2604261856359482641801,订单:2604261856350092891123,[2026-04-26 18:56:41微信支付10元]
2026-04-26 18:56:41 开始打印,排队:218,票券:2604261856359483226202,订单:2604261856350092891123,[2026-04-26 18:56:41微信支付10元]
2026-04-26 18:56:41>>>MQTT票号同步场景，创建空订单对象
2026-04-26 18:56:41>>>合并MQTT票号列表到订单同步请求,共2张票


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


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


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


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


===19:04:50===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:04:26 >>>回调事件[910,devices/D0361]
2026-04-26 19:04:26 >>>故障排除日志:上一MQTT订单号缓存列表为2604261902480038779318|2604261902480038779318
2026-04-26 19:04:26 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 19:04:26 开始打印,排队:224,票券:2604261904154993642601,订单:2604261904150046128531,[2026-04-26 19:04:25微信支付10元]
2026-04-26 19:04:26>>>MQTT票号同步场景，创建空订单对象
2026-04-26 19:04:26>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 19:04:29 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261904154993642601","queue_number":224,"trade_uid":"2604261904150046128531"}]}
2026-04-26 19:04:29 >>>故障排除日志:删除未同步下发订单成功2604261904150046128531
2026-04-26 19:04:29 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878771]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:04:36 >>>回调事件[910,devices/D0361]
2026-04-26 19:04:36 >>>故障排除日志:上一MQTT订单号缓存列表为2604261904150046128531
2026-04-26 19:04:36 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 19:04:36 开始打印,排队:225,票券:2604261904297025983201,订单:2604261904290067933942,[2026-04-26 19:04:36微信支付10元]
2026-04-26 19:04:36>>>MQTT票号同步场景，创建空订单对象
2026-04-26 19:04:36>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 19:04:38 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261904297025983201","queue_number":225,"trade_uid":"2604261904290067933942"}]}
2026-04-26 19:04:38 >>>故障排除日志:删除未同步下发订单成功2604261904290067933942
2026-04-26 19:04:38 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878783]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:04:43 >>>回调事件[910,devices/D0361]
2026-04-26 19:04:43 >>>故障排除日志:上一MQTT订单号缓存列表为2604261904290067933942
2026-04-26 19:04:43 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 19:04:43 开始打印,排队:226,票券:2604261904378604589801,订单:2604261904370084241916,[2026-04-26 19:04:43微信支付10元]
2026-04-26 19:04:43>>>MQTT票号同步场景，创建空订单对象
2026-04-26 19:04:44>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 19:04:45 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261904378604589801","queue_number":226,"trade_uid":"2604261904370084241916"}]}
2026-04-26 19:04:46 >>>故障排除日志:删除未同步下发订单成功2604261904370084241916
2026-04-26 19:04:46 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878789]


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


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


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


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


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


===19:14:52===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:13:53 >>>回调事件[910,devices/D0361]
2026-04-26 19:13:53 >>>故障排除日志:上一MQTT订单号缓存列表为2604261913020015921231
2026-04-26 19:13:53 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 19:13:53 开始打印,排队:235,票券:2604261913468914384201,订单:2604261913460087326228,[2026-04-26 19:13:53微信支付10元]
2026-04-26 19:13:53 开始打印,排队:236,票券:2604261913468914917802,订单:2604261913460087326228,[2026-04-26 19:13:53微信支付10元]
2026-04-26 19:13:53 开始打印,排队:237,票券:2604261913468915127403,订单:2604261913460087326228,[2026-04-26 19:13:53微信支付10元]
2026-04-26 19:13:53>>>MQTT票号同步场景，创建空订单对象
2026-04-26 19:13:53>>>合并MQTT票号列表到订单同步请求,共3张票
2026-04-26 19:13:58 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261913468914384201","queue_number":235,"trade_uid":"2604261913460087326228"},{"ticket_no":"2604261913468914917802","queue_number":236,"trade_uid":"2604261913460087326228"},{"ticket_no":"2604261913468915127403","queue_number":237,"trade_uid":"2604261913460087326228"}]}
2026-04-26 19:13:58 >>>故障排除日志:删除未同步下发订单成功2604261913460087326228
2026-04-26 19:13:58 >>>故障排除日志:删除未同步下发订单成功2604261913460087326228
2026-04-26 19:13:58 >>>故障排除日志:删除未同步下发订单成功2604261913460087326228
2026-04-26 19:13:58 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878924]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:14:27 >>>回调事件[910,devices/D0361]
2026-04-26 19:14:27 >>>故障排除日志:上一MQTT订单号缓存列表为2604261913460087326228|2604261913460087326228|2604261913460087326228
2026-04-26 19:14:27 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 19:14:27 开始打印,排队:238,票券:2604261914216167369701,订单:2604261914210059540889,[2026-04-26 19:14:27微信支付10元]
2026-04-26 19:14:27>>>MQTT票号同步场景，创建空订单对象
2026-04-26 19:14:27>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 19:14:29 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261914216167369701","queue_number":238,"trade_uid":"2604261914210059540889"}]}
2026-04-26 19:14:29 >>>故障排除日志:删除未同步下发订单成功2604261914210059540889
2026-04-26 19:14:30 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878933]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:14:38 >>>回调事件[910,devices/D0361]
2026-04-26 19:14:38 >>>故障排除日志:上一MQTT订单号缓存列表为2604261914210059540889
2026-04-26 19:14:38 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 19:14:39 开始打印,排队:239,票券:2604261914316628236701,订单:2604261914310063927168,[2026-04-26 19:14:39微信支付10元]
2026-04-26 19:14:39>>>MQTT票号同步场景，创建空订单对象
2026-04-26 19:14:39>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 19:14:41 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261914316628236701","queue_number":239,"trade_uid":"2604261914310063927168"}]}
2026-04-26 19:14:41 >>>故障排除日志:删除未同步下发订单成功2604261914310063927168
2026-04-26 19:14:41 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878945]


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


===19:47:57===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:47:03 >>>回调事件[910,devices/D0361]
2026-04-26 19:47:03 >>>故障排除日志:上一MQTT订单号缓存列表为2604261945440085067215
2026-04-26 19:47:03 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 19:47:03 开始打印,排队:256,票券:2604261946569499943201,订单:2604261946560091949329,[2026-04-26 19:47:03支付宝支付10元]
2026-04-26 19:47:03>>>MQTT票号同步场景，创建空订单对象
2026-04-26 19:47:03>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 19:47:06 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261946569499943201","queue_number":256,"trade_uid":"2604261946560091949329"}]}
2026-04-26 19:47:06 >>>故障排除日志:删除未同步下发订单成功2604261946560091949329
2026-04-26 19:47:06 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536879369]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:47:12 >>>回调事件[910,devices/D0361]
2026-04-26 19:47:12 >>>故障排除日志:上一MQTT订单号缓存列表为2604261946560091949329
2026-04-26 19:47:12 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 19:47:12 开始打印,排队:257,票券:2604261947056135059501,订单:2604261947050058660096,[2026-04-26 19:47:12微信支付10元]
2026-04-26 19:47:12>>>MQTT票号同步场景，创建空订单对象
2026-04-26 19:47:12>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 19:47:14 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261947056135059501","queue_number":257,"trade_uid":"2604261947050058660096"}]}
2026-04-26 19:47:14 >>>故障排除日志:删除未同步下发订单成功2604261947050058660096
2026-04-26 19:47:14 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536879375]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:47:21 >>>回调事件[910,devices/D0361]
2026-04-26 19:47:21 >>>故障排除日志:上一MQTT订单号缓存列表为2604261947050058660096
2026-04-26 19:47:21 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 19:47:21 开始打印,排队:258,票券:2604261947138863543501,订单:2604261947130085388617,[2026-04-26 19:47:21支付宝支付10元]
2026-04-26 19:47:21>>>MQTT票号同步场景，创建空订单对象
2026-04-26 19:47:21>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 19:47:23 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261947138863543501","queue_number":258,"trade_uid":"2604261947130085388617"}]}
2026-04-26 19:47:23 >>>故障排除日志:删除未同步下发订单成功2604261947130085388617
2026-04-26 19:47:23 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536879382]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:47:48 >>>回调事件[910,devices/D0361]
2026-04-26 19:47:48 >>>故障排除日志:上一MQTT订单号缓存列表为2604261947130085388617
2026-04-26 19:47:48 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 19:47:49 开始打印,排队:259,票券:2604261947422709817401,订单:2604261947420025039376,[2026-04-26 19:47:48微信支付10元]
2026-04-26 19:47:49>>>MQTT票号同步场景，创建空订单对象
2026-04-26 19:47:49>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 19:47:51 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261947422709817401","queue_number":259,"trade_uid":"2604261947420025039376"}]}
2026-04-26 19:47:51 >>>故障排除日志:删除未同步下发订单成功2604261947420025039376
2026-04-26 19:47:51 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536879394]


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


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


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


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


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


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


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


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


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


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


===20:11:00===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 20:10:06 >>>回调事件[910,devices/D0361]
2026-04-26 20:10:06 >>>故障排除日志:上一MQTT订单号缓存列表为2604262007410056639246
2026-04-26 20:10:06 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 20:10:06 开始打印,排队:273,票券:2604262010004169355301,订单:2604262010000038953684,[2026-04-26 20:10:06微信支付10元]
2026-04-26 20:10:06>>>MQTT票号同步场景，创建空订单对象
2026-04-26 20:10:06>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 20:10:08 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604262010004169355301","queue_number":273,"trade_uid":"2604262010000038953684"}]}
2026-04-26 20:10:08 >>>故障排除日志:删除未同步下发订单成功2604262010000038953684
2026-04-26 20:10:08 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536879694]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 20:10:21 >>>回调事件[910,devices/D0361]
2026-04-26 20:10:21 >>>故障排除日志:上一MQTT订单号缓存列表为2604262010000038953684
2026-04-26 20:10:22 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 20:10:22 开始打印,排队:274,票券:2604262010160680545901,订单:2604262010160003768084,[2026-04-26 20:10:21微信支付10元]
2026-04-26 20:10:22 开始打印,排队:275,票券:2604262010160681131902,订单:2604262010160003768084,[2026-04-26 20:10:21微信支付10元]
2026-04-26 20:10:22>>>MQTT票号同步场景，创建空订单对象
2026-04-26 20:10:22>>>合并MQTT票号列表到订单同步请求,共2张票
2026-04-26 20:10:25 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604262010160680545901","queue_number":274,"trade_uid":"2604262010160003768084"},{"ticket_no":"2604262010160681131902","queue_number":275,"trade_uid":"2604262010160003768084"}]}
2026-04-26 20:10:25 >>>故障排除日志:删除未同步下发订单成功2604262010160003768084
2026-04-26 20:10:26 >>>故障排除日志:删除未同步下发订单成功2604262010160003768084
2026-04-26 20:10:26 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536879700]


===20:12:00===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 20:11:01 >>>回调事件[910,devices/D0361]
2026-04-26 20:11:01 >>>故障排除日志:上一MQTT订单号缓存列表为2604262010160003768084|2604262010160003768084
2026-04-26 20:11:01 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 20:11:01 开始打印,排队:276,票券:2604262010543980317501,订单:2604262010540037944364,[2026-04-26 20:11:01微信支付10元]
2026-04-26 20:11:01 开始打印,排队:277,票券:2604262010543980785302,订单:2604262010540037944364,[2026-04-26 20:11:01微信支付10元]
2026-04-26 20:11:01>>>MQTT票号同步场景，创建空订单对象
2026-04-26 20:11:01>>>合并MQTT票号列表到订单同步请求,共2张票
2026-04-26 20:11:05 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604262010543980317501","queue_number":276,"trade_uid":"2604262010540037944364"},{"ticket_no":"2604262010543980785302","queue_number":277,"trade_uid":"2604262010540037944364"}]}
2026-04-26 20:11:05 >>>故障排除日志:删除未同步下发订单成功2604262010540037944364
2026-04-26 20:11:05 >>>故障排除日志:删除未同步下发订单成功2604262010540037944364
2026-04-26 20:11:05 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536879717]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 20:11:26 >>>回调事件[910,devices/D0361]
2026-04-26 20:11:26 >>>故障排除日志:上一MQTT订单号缓存列表为2604262010540037944364|2604262010540037944364
2026-04-26 20:11:26 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 20:11:26 开始打印,排队:278,票券:2604262011169414592101,订单:2604262011160092136426,[2026-04-26 20:11:24微信支付10元]
2026-04-26 20:11:26 开始打印,排队:279,票券:2604262011169415275602,订单:2604262011160092136426,[2026-04-26 20:11:24微信支付10元]
2026-04-26 20:11:26>>>MQTT票号同步场景，创建空订单对象
2026-04-26 20:11:26>>>合并MQTT票号列表到订单同步请求,共2张票
2026-04-26 20:11:30 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604262011169414592101","queue_number":278,"trade_uid":"2604262011160092136426"},{"ticket_no":"2604262011169415275602","queue_number":279,"trade_uid":"2604262011160092136426"}]}
2026-04-26 20:11:30 >>>故障排除日志:删除未同步下发订单成功2604262011160092136426
2026-04-26 20:11:30 >>>故障排除日志:删除未同步下发订单成功2604262011160092136426
2026-04-26 20:11:30 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536879724]


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


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


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


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


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


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


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


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


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


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


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


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


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


===20:46:05===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 20:45:15 >>>回调事件[910,devices/D0361]
2026-04-26 20:45:15 >>>故障排除日志:上一MQTT订单号缓存列表为2604262043410014880358
2026-04-26 20:45:15 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 20:45:15 开始打印,排队:296,票券:2604262045059454158301,订单:2604262045050092041332,[2026-04-26 20:45:15微信支付10元]
2026-04-26 20:45:15>>>MQTT票号同步场景，创建空订单对象
2026-04-26 20:45:15>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 20:45:16 >>>回调事件[910,devices/D0361]
2026-04-26 20:45:16 >>>故障排除日志:上一MQTT订单号缓存列表为2604262045050092041332
2026-04-26 20:45:17 >>>故障排除日志:终端未同步成功订单列表02962604262045050092041332
已接收过此消息,票券号为2604262045059454158301,排队号为296
2026-04-26 20:45:17 开始打印,排队:297,票券:2604262045103512493101,订单:2604262045100033257735,[2026-04-26 20:45:15支付宝支付10元]
2026-04-26 20:45:17>>>HTTP请求进行中，跳过本次同步
2026-04-26 20:45:19 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604262045059454158301","queue_number":296,"trade_uid":"2604262045050092041332"}]}
2026-04-26 20:45:19 >>>故障排除日志:删除未同步下发订单成功2604262045050092041332
2026-04-26 20:45:19 >>>故障排除日志:终端同步成功后剩余订单列表02972604262045100033257735
定时检测未同步订单启用[checkOrderNum=536880149]


===20:47:05===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 20:46:20 >>>回调事件[910,devices/D0361]
2026-04-26 20:46:21 >>>故障排除日志:上一MQTT订单号缓存列表为2604262045050092041332|2604262045100033257735
2026-04-26 20:46:21 >>>故障排除日志:终端未同步成功订单列表02972604262045100033257735
已接收过此消息,票券号为2604262045103512493101,排队号为297
2026-04-26 20:46:21 开始打印,排队:298,票券:2604262046144738423701,订单:2604262046140045374016,[2026-04-26 20:46:21微信支付10元]
2026-04-26 20:46:21>>>MQTT票号同步场景，创建空订单对象
2026-04-26 20:46:21>>>合并MQTT票号列表到订单同步请求,共2张票
2026-04-26 20:46:23 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604262045103512493101","queue_number":297,"trade_uid":"2604262045100033257735"},{"ticket_no":"2604262046144738423701","queue_number":298,"trade_uid":"2604262046140045374016"}]}
2026-04-26 20:46:23 >>>故障排除日志:删除未同步下发订单成功2604262045100033257735
2026-04-26 20:46:23 >>>故障排除日志:删除未同步下发订单成功2604262046140045374016
2026-04-26 20:46:23 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536880166]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 20:46:31 >>>回调事件[910,devices/D0361]
2026-04-26 20:46:31 >>>故障排除日志:上一MQTT订单号缓存列表为2604262045100033257735|2604262046140045374016
2026-04-26 20:46:31 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 20:46:32 开始打印,排队:299,票券:2604262046257364094901,订单:2604262046250071830272,[2026-04-26 20:46:32微信支付10元]
2026-04-26 20:46:32>>>MQTT票号同步场景，创建空订单对象
2026-04-26 20:46:32>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 20:46:33 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604262046257364094901","queue_number":299,"trade_uid":"2604262046250071830272"}]}
2026-04-26 20:46:34 >>>故障排除日志:删除未同步下发订单成功2604262046250071830272
2026-04-26 20:46:34 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536880172]
2026-04-26 20:46:37>>>cash read=00
2026-04-26 20:46:38>>>cash read=818F42
2026-04-26 20:46:38>>>cash write=02
2026-04-26 20:46:38 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 20:46:39>>>cash read=10
2026-04-26 20:46:39 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 20:46:39 当前产品价格10元，投币10元，打印小票中...
2026-04-26 20:46:39 >>>开始打印,排队号为300,订单号为2604262046390040361669
2026-04-26 20:46:39>>>订单2604262046390040361669写入成功,剩余空间为1677500,占用RAM为648.974609375
删除未同步订单2604262046390040361669
2026-04-26 20:46:41>>>订单2604262046390040361669删除成功,剩余空间为1678000,占用RAM为653.8671875
检测订单目录中>>>
无未同步订单>>>
2026-04-26 20:46:41 >>>当前Ram内存为619.416015625
定时检测未同步订单启用[checkOrderNum=536880185]
2026-04-26 20:46:42>>>cash write=0C
2026-04-26 20:46:42>>>cash read=3E
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 20:46:57 >>>回调事件[910,devices/D0361]
2026-04-26 20:46:57 >>>故障排除日志:上一MQTT订单号缓存列表为2604262046250071830272
2026-04-26 20:46:57 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 20:46:57 开始打印,排队:301,票券:2604262046506141759801,订单:2604262046500059328978,[2026-04-26 20:46:56微信支付10元]
2026-04-26 20:46:57>>>MQTT票号同步场景，创建空订单对象
2026-04-26 20:46:57>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 20:46:59 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604262046506141759801","queue_number":301,"trade_uid":"2604262046500059328978"}]}
2026-04-26 20:46:59 >>>故障排除日志:删除未同步下发订单成功2604262046500059328978
2026-04-26 20:46:59 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536880191]


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


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


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


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


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


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


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


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


===21:19:08===
2026-04-26 21:18:36>>>cash read=00
2026-04-26 21:18:37>>>cash read=29
2026-04-26 21:18:37 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 21:18:37>>>cash read=2F29
2026-04-26 21:18:39>>>cash read=3E
2026-04-26 21:18:41>>>cash read=00
2026-04-26 21:18:42>>>cash read=29
2026-04-26 21:18:42 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 21:18:43>>>cash read=2F29
2026-04-26 21:18:44>>>cash read=3E
2026-04-26 21:18:45>>>cash read=00
2026-04-26 21:18:46>>>cash read=2F29
2026-04-26 21:18:47>>>cash read=00
2026-04-26 21:18:48>>>cash read=29
2026-04-26 21:18:48 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 21:18:49>>>cash read=2F29
2026-04-26 21:18:50>>>cash read=00
2026-04-26 21:18:51>>>cash read=292F29
2026-04-26 21:18:51 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 21:18:52>>>cash read=3E


===21:20:08===
2026-04-26 21:19:33>>>cash read=00
2026-04-26 21:19:34>>>cash read=2F29
2026-04-26 21:19:35>>>cash read=3E
2026-04-26 21:19:44>>>cash read=00
2026-04-26 21:19:44>>>cash read=818F42
2026-04-26 21:19:45>>>cash write=02
2026-04-26 21:19:45 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 21:19:45>>>cash read=10
2026-04-26 21:19:45 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 21:19:45 当前产品价格10元，投币10元，打印小票中...
2026-04-26 21:19:45 >>>开始打印,排队号为310,订单号为2604262119450040361739
2026-04-26 21:19:45>>>订单2604262119450040361739写入成功,剩余空间为1679500,占用RAM为637.5791015625
删除未同步订单2604262119450040361739
2026-04-26 21:19:47>>>订单2604262119450040361739删除成功,剩余空间为1680500,占用RAM为626.884765625
检测订单目录中>>>
无未同步订单>>>
2026-04-26 21:19:48 >>>当前Ram内存为614.9189453125
定时检测未同步订单启用[checkOrderNum=536880562]
2026-04-26 21:19:49>>>cash write=0C
2026-04-26 21:19:49>>>cash read=3E


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


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