TLClient_JSSCOM_LuatOS-Air_V4010_RDA8910_RFTTS_0xe0000,2.8.7,864708068718264,68863929077821,
poweron reason:0

===08:59:06===
上一时间戳为1777511569
隔日重置时间戳true
隔日清空未同步下发列表true
当前排队号为168,音量为5
初始化产品信息:[{"time_limit_date":"","ticket_category":"0","expiry_date":1,"product_detail":"","time_limit_status":"0","begin_minute":"00","product_uid":"12711098232278461416","use_timer":1,"old_price":"18","end_hour":"23","sale_price":"12","end_minute":"59","begin_hour":"00","sale_status":1,"product_name":"纯剪"},{"time_limit_date":"","ticket_category":"0","expiry_date":7,"product_detail":"","time_limit_status":"0","begin_minute":"00","product_uid":"4280874159398048144","use_timer":1,"old_price":"48","end_hour":"23","sale_price":"48","end_minute":"59","begin_hour":"00","sale_status":1,"product_name":"焗黑油"}]
打印门店标题设置为剪发送免费自助洗头
打印门店凭条广告设置为剪发送免费自助洗头
是否打印二维码设置为1
是否打印紧凑设置为3
当前号显示模式设置为1
当前卡项核销权限设置为0
session_id:26df2****56068
纸币器设置接收纸币范围为36
欢迎使用天羚自助售票系统[2.8.7]
定时检测未同步订单启用[checkOrderNum=536870969]
2026-05-01 08:58:06>>>cash write=30
2026-05-01 08:58:06>>>cash write=02
2026-05-01 08:58:06>>>cash write=3E
2026-05-01 08:58:06>>>cash read=808F808F808F808F
系统时间初始化成功，时间为2026518586
2026-05-01 08:58:07>>>cash write=02
2026-05-01 08:58:07 >>>剩余flash空间=1680000,占用RAM为664.2890625
2026-05-01 08:58:07 >>>回调事件:910,subscribe,10000,连接服务器成功

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

2026-05-01 08:58:10>>>cash write=0C
2026-05-01 08:58:10>>>cash read=3E
流量卡还有303天过期
2026-05-01 08:58:14 >>>当前Ram内存为650.591796875


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


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


===09:16:07===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-01 09:15:52 >>>回调事件[910,devices/YC0664]
2026-05-01 09:15:52 >>>故障排除日志:上一MQTT订单号缓存列表为2605010909530091624589
2026-05-01 09:15:52 >>>故障排除日志:终端未同步成功订单列表
2026-05-01 09:15:52 开始打印,排队:171,票券:2605010915430582174701,订单:2605010915430003939419,[2026-05-01 09:15:50微信支付12元]
2026-05-01 09:15:53 开始打印,排队:172,票券:2605010915430582642902,订单:2605010915430003939419,[2026-05-01 09:15:50微信支付12元]
2026-05-01 09:15:53>>>MQTT票号同步场景，创建空订单对象
2026-05-01 09:15:53>>>合并MQTT票号列表到订单同步请求,共2张票
2026-05-01 09:15:56 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605010915430582174701","queue_number":171,"trade_uid":"2605010915430003939419"},{"ticket_no":"2605010915430582642902","queue_number":172,"trade_uid":"2605010915430003939419"}]}
2026-05-01 09:15:56 >>>故障排除日志:删除未同步下发订单成功2605010915430003939419
2026-05-01 09:15:56 >>>故障排除日志:删除未同步下发订单成功2605010915430003939419
2026-05-01 09:15:56 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536871167]


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


===09:21:08===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-01 09:20:28 >>>回调事件[910,devices/YC0664]
2026-05-01 09:20:28 >>>故障排除日志:上一MQTT订单号缓存列表为2605010918020030050914
2026-05-01 09:20:28 >>>故障排除日志:终端未同步成功订单列表
2026-05-01 09:20:28 开始打印,排队:174,票券:2605010920181470219201,订单:2605010920180012865698,[2026-05-01 09:20:26微信支付12元]
2026-05-01 09:20:28>>>MQTT票号同步场景，创建空订单对象
2026-05-01 09:20:28>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-01 09:20:30 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605010920181470219201","queue_number":174,"trade_uid":"2605010920180012865698"}]}
2026-05-01 09:20:30 >>>故障排除日志:删除未同步下发订单成功2605010920180012865698
2026-05-01 09:20:30 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536871227]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-01 09:20:33 >>>回调事件[910,devices/YC0664]
2026-05-01 09:20:33 >>>故障排除日志:上一MQTT订单号缓存列表为2605010920180012865698
2026-05-01 09:20:34 >>>故障排除日志:终端未同步成功订单列表
2026-05-01 09:20:34 开始打印,排队:175,票券:2605010920234097346801,订单:2605010920230039014249,[2026-05-01 09:20:33微信支付12元]
2026-05-01 09:20:34>>>MQTT票号同步场景，创建空订单对象
2026-05-01 09:20:34>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-01 09:20:36 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605010920234097346801","queue_number":175,"trade_uid":"2605010920230039014249"}]}
2026-05-01 09:20:36 >>>故障排除日志:删除未同步下发订单成功2605010920230039014249
2026-05-01 09:20:36 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536871233]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-01 09:20:41 >>>回调事件[910,devices/YC0664]
2026-05-01 09:20:41 >>>故障排除日志:上一MQTT订单号缓存列表为2605010920230039014249
2026-05-01 09:20:42 >>>故障排除日志:终端未同步成功订单列表
2026-05-01 09:20:42 开始打印,排队:176,票券:2605010920333626257601,订单:2605010920330034591392,[2026-05-01 09:20:41微信支付12元]
2026-05-01 09:20:42>>>MQTT票号同步场景，创建空订单对象
2026-05-01 09:20:42>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-01 09:20:44 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605010920333626257601","queue_number":176,"trade_uid":"2605010920330034591392"}]}
2026-05-01 09:20:44 >>>故障排除日志:删除未同步下发订单成功2605010920330034591392
2026-05-01 09:20:44 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536871239]


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


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


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


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


===09:44:10===
2026-05-01 09:43:09 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605010942584943949801","queue_number":180,"trade_uid":"2605010942580046847237"}]}
2026-05-01 09:43:09 >>>故障排除日志:删除未同步下发订单成功2605010942580046847237
2026-05-01 09:43:09 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536871479]


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


===10:51:18===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-01 10:50:32 >>>回调事件[910,devices/YC0664]
2026-05-01 10:50:32 >>>故障排除日志:上一MQTT订单号缓存列表为2605011048300081340275
2026-05-01 10:50:32 >>>故障排除日志:终端未同步成功订单列表
2026-05-01 10:50:32 开始打印,排队:201,票券:2605011050234133462901,订单:2605011050230039489019,[2026-05-01 10:50:30微信支付12元]
2026-05-01 10:50:32>>>MQTT票号同步场景，创建空订单对象
2026-05-01 10:50:32>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-01 10:50:34 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605011050234133462901","queue_number":201,"trade_uid":"2605011050230039489019"}]}
2026-05-01 10:50:34 >>>故障排除日志:删除未同步下发订单成功2605011050230039489019
2026-05-01 10:50:34 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536872252]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-01 10:50:51 >>>回调事件[910,devices/YC0664]
2026-05-01 10:50:51 >>>故障排除日志:上一MQTT订单号缓存列表为2605011050230039489019
2026-05-01 10:50:51 >>>故障排除日志:终端未同步成功订单列表
2026-05-01 10:50:51 开始打印,排队:202,票券:2605011050429029037101,订单:2605011050420088428882,[2026-05-01 10:50:49微信支付12元]
2026-05-01 10:50:51>>>MQTT票号同步场景，创建空订单对象
2026-05-01 10:50:51>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-01 10:50:53 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605011050429029037101","queue_number":202,"trade_uid":"2605011050420088428882"}]}
2026-05-01 10:50:53 >>>故障排除日志:删除未同步下发订单成功2605011050420088428882
2026-05-01 10:50:53 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536872259]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-01 10:51:15 >>>回调事件[910,devices/YC0664]
2026-05-01 10:51:15 >>>故障排除日志:上一MQTT订单号缓存列表为2605011050420088428882
2026-05-01 10:51:15 >>>故障排除日志:终端未同步成功订单列表
2026-05-01 10:51:15 开始打印,排队:203,票券:2605011051044995635801,订单:2605011051040047882763,[2026-05-01 10:51:13微信支付12元]
2026-05-01 10:51:15>>>MQTT票号同步场景，创建空订单对象
2026-05-01 10:51:15>>>合并MQTT票号列表到订单同步请求,共1张票


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


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


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


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


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


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


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


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


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


===11:23:22===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-01 11:22:37 >>>回调事件[910,devices/YC0664]
2026-05-01 11:22:37 >>>故障排除日志:上一MQTT订单号缓存列表为2605011117380022453998
2026-05-01 11:22:37 >>>故障排除日志:终端未同步成功订单列表
2026-05-01 11:22:37 开始打印,排队:214,票券:2605011122316960493501,订单:2605011122310067719632,[2026-05-01 11:22:37微信支付12元]
2026-05-01 11:22:38>>>MQTT票号同步场景，创建空订单对象
2026-05-01 11:22:38>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-01 11:22:40 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605011122316960493501","queue_number":214,"trade_uid":"2605011122310067719632"}]}
2026-05-01 11:22:40 >>>故障排除日志:删除未同步下发订单成功2605011122310067719632
2026-05-01 11:22:40 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536872654]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-01 11:22:48 >>>回调事件[910,devices/YC0664]
2026-05-01 11:22:48 >>>故障排除日志:上一MQTT订单号缓存列表为2605011122310067719632
2026-05-01 11:22:48 >>>故障排除日志:终端未同步成功订单列表
2026-05-01 11:22:48 开始打印,排队:215,票券:2605011122436663973401,订单:2605011122430064800332,[2026-05-01 11:22:47微信支付12元]
2026-05-01 11:22:49>>>MQTT票号同步场景，创建空订单对象
2026-05-01 11:22:49>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-01 11:22:50 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605011122436663973401","queue_number":215,"trade_uid":"2605011122430064800332"}]}
2026-05-01 11:22:50 >>>故障排除日志:删除未同步下发订单成功2605011122430064800332
2026-05-01 11:22:51 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536872660]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-01 11:23:10 >>>回调事件[910,devices/YC0664]
2026-05-01 11:23:10 >>>故障排除日志:上一MQTT订单号缓存列表为2605011122430064800332
2026-05-01 11:23:10 >>>故障排除日志:终端未同步成功订单列表
2026-05-01 11:23:10 开始打印,排队:216,票券:2605011123030598865601,订单:2605011123030004136175,[2026-05-01 11:23:09微信支付12元]
2026-05-01 11:23:10>>>MQTT票号同步场景，创建空订单对象
2026-05-01 11:23:10>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-01 11:23:12 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605011123030598865601","queue_number":216,"trade_uid":"2605011123030004136175"}]}
2026-05-01 11:23:12 >>>故障排除日志:删除未同步下发订单成功2605011123030004136175
2026-05-01 11:23:12 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536872674]


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


===13:26:28===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-01 13:25:51 >>>回调事件[910,devices/YC0664]
2026-05-01 13:25:51 >>>故障排除日志:上一MQTT订单号缓存列表为2605011319230060588119
2026-05-01 13:25:51 >>>故障排除日志:终端未同步成功订单列表
2026-05-01 13:25:51 开始打印,排队:241,票券:2605011325443973039601,订单:2605011325440037897668,[2026-05-01 13:25:49支付宝支付12元]
2026-05-01 13:25:51>>>MQTT票号同步场景，创建空订单对象
2026-05-01 13:25:51>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-01 13:25:53 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605011325443973039601","queue_number":241,"trade_uid":"2605011325440037897668"}]}
2026-05-01 13:25:53 >>>故障排除日志:删除未同步下发订单成功2605011325440037897668
2026-05-01 13:25:54 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536873975]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-01 13:26:11 >>>回调事件[910,devices/YC0664]
2026-05-01 13:26:11 >>>故障排除日志:上一MQTT订单号缓存列表为2605011325440037897668
2026-05-01 13:26:11 >>>故障排除日志:终端未同步成功订单列表
2026-05-01 13:26:11 开始打印,排队:242,票券:2605011326028277219201,订单:2605011326020080438327,[2026-05-01 13:26:09微信支付12元]
2026-05-01 13:26:11>>>MQTT票号同步场景，创建空订单对象
2026-05-01 13:26:11>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-01 13:26:13 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605011326028277219201","queue_number":242,"trade_uid":"2605011326020080438327"}]}
2026-05-01 13:26:13 >>>故障排除日志:删除未同步下发订单成功2605011326020080438327
2026-05-01 13:26:13 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536873989]


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


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


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


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


===13:47:30===
2026-05-01 13:46:31>>>cash read=0A
2026-05-01 13:46:32>>>cash read=3E
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-01 13:47:06 >>>回调事件[910,devices/YC0664]
2026-05-01 13:47:06 >>>故障排除日志:上一MQTT订单号缓存列表为2605011341470087559915
2026-05-01 13:47:06 >>>故障排除日志:终端未同步成功订单列表
2026-05-01 13:47:06 开始打印,排队:247,票券:2605011346583651582101,订单:2605011346580034528946,[2026-05-01 13:47:05微信支付12元]
2026-05-01 13:47:07>>>MQTT票号同步场景，创建空订单对象
2026-05-01 13:47:07>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-01 13:47:08 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605011346583651582101","queue_number":247,"trade_uid":"2605011346580034528946"}]}
2026-05-01 13:47:08 >>>故障排除日志:删除未同步下发订单成功2605011346580034528946
2026-05-01 13:47:08 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536874218]


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


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


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


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


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


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


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


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


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


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


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


===14:55:34===
2026-05-01 14:54:33 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605011454209743499801","queue_number":258,"trade_uid":"2605011454200095531254"}]}
2026-05-01 14:54:33 >>>故障排除日志:删除未同步下发订单成功2605011454200095531254
2026-05-01 14:54:33 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536874915]


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


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


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


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


===15:06:36===
2026-05-01 15:05:35 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605011505251270104301","queue_number":262,"trade_uid":"2605011505250010838129"}]}
2026-05-01 15:05:35 >>>故障排除日志:删除未同步下发订单成功2605011505250010838129
2026-05-01 15:05:35 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536875048]


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


===15:24:37===
2026-05-01 15:24:17>>>cash read=0A
2026-05-01 15:24:19>>>cash read=3E
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-01 15:24:24 >>>回调事件[910,devices/YC0664]
2026-05-01 15:24:24 >>>故障排除日志:上一MQTT订单号缓存列表为2605011510110052158369
2026-05-01 15:24:24 >>>故障排除日志:终端未同步成功订单列表
2026-05-01 15:24:24 开始打印,排队:264,票券:2605011524176340951301,订单:2605011524170061609725,[2026-05-01 15:24:23支付宝支付12元]
2026-05-01 15:24:24>>>MQTT票号同步场景，创建空订单对象
2026-05-01 15:24:24>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-01 15:24:26 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605011524176340951301","queue_number":264,"trade_uid":"2605011524170061609725"}]}
2026-05-01 15:24:26 >>>故障排除日志:删除未同步下发订单成功2605011524170061609725
2026-05-01 15:24:26 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536875242]


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


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


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


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


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


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


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


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


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


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


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


===16:25:40===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-01 16:24:40 >>>回调事件[910,devices/YC0664]
2026-05-01 16:24:40 >>>故障排除日志:上一MQTT订单号缓存列表为2605011617520031715861
2026-05-01 16:24:40 >>>故障排除日志:终端未同步成功订单列表
2026-05-01 16:24:40 开始打印,排队:277,票券:2605011624343577102401,订单:2605011624340033883872,[2026-05-01 16:24:39支付宝支付12元]
2026-05-01 16:24:40>>>MQTT票号同步场景，创建空订单对象
2026-05-01 16:24:40>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-01 16:24:42 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605011624343577102401","queue_number":277,"trade_uid":"2605011624340033883872"}]}
2026-05-01 16:24:42 >>>故障排除日志:删除未同步下发订单成功2605011624340033883872
2026-05-01 16:24:42 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536875884]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-01 16:24:49 >>>回调事件[910,devices/YC0664]
2026-05-01 16:24:49 >>>故障排除日志:上一MQTT订单号缓存列表为2605011624340033883872
2026-05-01 16:24:49 >>>故障排除日志:终端未同步成功订单列表
2026-05-01 16:24:49 开始打印,排队:278,票券:2605011624421899147401,订单:2605011624420016696832,[2026-05-01 16:24:48微信支付12元]
2026-05-01 16:24:49>>>MQTT票号同步场景，创建空订单对象
2026-05-01 16:24:49>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-01 16:24:52 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605011624421899147401","queue_number":278,"trade_uid":"2605011624420016696832"}]}
2026-05-01 16:24:52 >>>故障排除日志:删除未同步下发订单成功2605011624420016696832
2026-05-01 16:24:52 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536875890]


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


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


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


===16:32:41===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-01 16:31:40 >>>回调事件[910,devices/YC0664]
2026-05-01 16:31:40 >>>故障排除日志:上一MQTT订单号缓存列表为2605011629020013435139
2026-05-01 16:31:40 >>>故障排除日志:终端未同步成功订单列表
2026-05-01 16:31:40 开始打印,排队:282,票券:2605011631298887481701,订单:2605011631290086772096,[2026-05-01 16:31:39微信支付12元]
2026-05-01 16:31:40>>>MQTT票号同步场景，创建空订单对象
2026-05-01 16:31:40>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-01 16:31:42 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605011631298887481701","queue_number":282,"trade_uid":"2605011631290086772096"}]}
2026-05-01 16:31:42 >>>故障排除日志:删除未同步下发订单成功2605011631290086772096
2026-05-01 16:31:42 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536875985]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-01 16:31:52 >>>回调事件[910,devices/YC0664]
2026-05-01 16:31:52 >>>故障排除日志:上一MQTT订单号缓存列表为2605011631290086772096
2026-05-01 16:31:52 >>>故障排除日志:终端未同步成功订单列表
2026-05-01 16:31:52 开始打印,排队:283,票券:2605011631378690767601,订单:2605011631370085048743,[2026-05-01 16:31:50微信支付12元]
2026-05-01 16:31:52>>>MQTT票号同步场景，创建空订单对象
2026-05-01 16:31:52>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-01 16:31:54 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605011631378690767601","queue_number":283,"trade_uid":"2605011631370085048743"}]}
2026-05-01 16:31:54 >>>故障排除日志:删除未同步下发订单成功2605011631370085048743
2026-05-01 16:31:54 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536875991]


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


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


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


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


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


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


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


===17:07:45===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-01 17:07:42 >>>回调事件[910,devices/YC0664]
2026-05-01 17:07:42 >>>故障排除日志:上一MQTT订单号缓存列表为2605011700380062245385
2026-05-01 17:07:42 >>>故障排除日志:终端未同步成功订单列表
2026-05-01 17:07:42 开始打印,排队:291,票券:2605011707347548701301,订单:2605011707340073650847,[2026-05-01 17:07:41微信支付12元]
2026-05-01 17:07:42>>>MQTT票号同步场景，创建空订单对象
2026-05-01 17:07:42>>>合并MQTT票号列表到订单同步请求,共1张票


===17:08:45===
2026-05-01 17:07:44 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605011707347548701301","queue_number":291,"trade_uid":"2605011707340073650847"}]}
2026-05-01 17:07:44 >>>故障排除日志:删除未同步下发订单成功2605011707340073650847
2026-05-01 17:07:44 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536876380]


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


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


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


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


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


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


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


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


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


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


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


===17:46:49===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-01 17:45:52 >>>回调事件[910,devices/YC0664]
2026-05-01 17:45:52 >>>故障排除日志:上一MQTT订单号缓存列表为2605011742440021185228
2026-05-01 17:45:52 >>>故障排除日志:终端未同步成功订单列表
2026-05-01 17:45:52 开始打印,排队:304,票券:2605011745422521528501,订单:2605011745420023281291,[2026-05-01 17:45:51微信支付12元]
2026-05-01 17:45:52>>>MQTT票号同步场景，创建空订单对象
2026-05-01 17:45:52>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-01 17:45:54 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605011745422521528501","queue_number":304,"trade_uid":"2605011745420023281291"}]}
2026-05-01 17:45:54 >>>故障排除日志:删除未同步下发订单成功2605011745420023281291
2026-05-01 17:45:54 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536876824]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-01 17:45:57 >>>回调事件[910,devices/YC0664]
2026-05-01 17:45:57 >>>故障排除日志:上一MQTT订单号缓存列表为2605011745420023281291
2026-05-01 17:45:57 >>>故障排除日志:终端未同步成功订单列表
2026-05-01 17:45:57 开始打印,排队:305,票券:2605011745423133588301,订单:2605011745420028982025,[2026-05-01 17:45:56支付宝支付12元]
2026-05-01 17:45:57>>>MQTT票号同步场景，创建空订单对象
2026-05-01 17:45:57>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-01 17:45:59 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605011745423133588301","queue_number":305,"trade_uid":"2605011745420028982025"}]}
2026-05-01 17:45:59 >>>故障排除日志:删除未同步下发订单成功2605011745420028982025
2026-05-01 17:46:00 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536876830]


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


===17:54:50===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-01 17:54:01 >>>回调事件[910,devices/YC0664]
2026-05-01 17:54:01 >>>故障排除日志:上一MQTT订单号缓存列表为2605011748040055022784
2026-05-01 17:54:01 >>>故障排除日志:终端未同步成功订单列表
2026-05-01 17:54:01 开始打印,排队:307,票券:2605011753557612425201,订单:2605011753550074056986,[2026-05-01 17:53:59支付宝支付12元]
2026-05-01 17:54:01>>>MQTT票号同步场景，创建空订单对象
2026-05-01 17:54:01>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-01 17:54:03 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605011753557612425201","queue_number":307,"trade_uid":"2605011753550074056986"}]}
2026-05-01 17:54:03 >>>故障排除日志:删除未同步下发订单成功2605011753550074056986
2026-05-01 17:54:03 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536876925]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-01 17:54:14 >>>回调事件[910,devices/YC0664]
2026-05-01 17:54:14 >>>故障排除日志:上一MQTT订单号缓存列表为2605011753550074056986
2026-05-01 17:54:14 >>>故障排除日志:终端未同步成功订单列表
2026-05-01 17:54:14 开始打印,排队:308,票券:2605011754088570602101,订单:2605011754080083641439,[2026-05-01 17:54:13微信支付12元]
2026-05-01 17:54:14>>>MQTT票号同步场景，创建空订单对象
2026-05-01 17:54:14>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-01 17:54:16 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605011754088570602101","queue_number":308,"trade_uid":"2605011754080083641439"}]}
2026-05-01 17:54:16 >>>故障排除日志:删除未同步下发订单成功2605011754080083641439
2026-05-01 17:54:16 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536876931]


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


===18:13:52===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-01 18:12:54 >>>回调事件[910,devices/YC0664]
2026-05-01 18:12:54 >>>故障排除日志:上一MQTT订单号缓存列表为2605011806030095810331
2026-05-01 18:12:54 >>>故障排除日志:终端未同步成功订单列表
2026-05-01 18:12:54 开始打印,排队:310,票券:2605011812470591025301,订单:2605011812470004045125,[2026-05-01 18:12:52微信支付12元]
2026-05-01 18:12:54>>>MQTT票号同步场景，创建空订单对象
2026-05-01 18:12:54>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-01 18:12:56 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605011812470591025301","queue_number":310,"trade_uid":"2605011812470004045125"}]}
2026-05-01 18:12:56 >>>故障排除日志:删除未同步下发订单成功2605011812470004045125
2026-05-01 18:12:56 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877111]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-01 18:13:15 >>>回调事件[910,devices/YC0664]
2026-05-01 18:13:15 >>>故障排除日志:上一MQTT订单号缓存列表为2605011812470004045125
2026-05-01 18:13:16 >>>故障排除日志:终端未同步成功订单列表
2026-05-01 18:13:16 开始打印,排队:311,票券:2605011812569274046201,订单:2605011812560090692682,[2026-05-01 18:13:14微信支付12元]
2026-05-01 18:13:16>>>MQTT票号同步场景，创建空订单对象
2026-05-01 18:13:16>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-01 18:13:18 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605011812569274046201","queue_number":311,"trade_uid":"2605011812560090692682"}]}
2026-05-01 18:13:18 >>>故障排除日志:删除未同步下发订单成功2605011812560090692682
2026-05-01 18:13:18 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877124]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-01 18:13:49 >>>回调事件[910,devices/YC0664]
2026-05-01 18:13:49 >>>故障排除日志:上一MQTT订单号缓存列表为2605011812560090692682
2026-05-01 18:13:49 >>>故障排除日志:终端未同步成功订单列表
2026-05-01 18:13:49 开始打印,排队:312,票券:2605011813410403919801,订单:2605011813410002121992,[2026-05-01 18:13:47微信支付12元]
2026-05-01 18:13:49>>>MQTT票号同步场景，创建空订单对象
2026-05-01 18:13:49>>>合并MQTT票号列表到订单同步请求,共1张票


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


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


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


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


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


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


===18:45:54===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-01 18:45:13 >>>回调事件[910,devices/YC0664]
2026-05-01 18:45:13 >>>故障排除日志:上一MQTT订单号缓存列表为2605011840510043836185
2026-05-01 18:45:13 >>>故障排除日志:终端未同步成功订单列表
2026-05-01 18:45:13 开始打印,排队:319,票券:2605011845037355773901,订单:2605011845030071567585,[2026-05-01 18:45:11微信支付12元]
2026-05-01 18:45:13>>>MQTT票号同步场景，创建空订单对象
2026-05-01 18:45:13>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-01 18:45:15 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605011845037355773901","queue_number":319,"trade_uid":"2605011845030071567585"}]}
2026-05-01 18:45:15 >>>故障排除日志:删除未同步下发订单成功2605011845030071567585
2026-05-01 18:45:15 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877474]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-01 18:45:49 >>>回调事件[910,devices/YC0664]
2026-05-01 18:45:49 >>>故障排除日志:上一MQTT订单号缓存列表为2605011845030071567585
2026-05-01 18:45:49 >>>故障排除日志:终端未同步成功订单列表
2026-05-01 18:45:49 开始打印,排队:320,票券:2605011845402362895901,订单:2605011845400021188342,[2026-05-01 18:45:48微信支付12元]
2026-05-01 18:45:49>>>MQTT票号同步场景，创建空订单对象
2026-05-01 18:45:49>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-01 18:45:51 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605011845402362895901","queue_number":320,"trade_uid":"2605011845400021188342"}]}
2026-05-01 18:45:51 >>>故障排除日志:删除未同步下发订单成功2605011845400021188342
2026-05-01 18:45:51 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877481]


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


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


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


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


===19:10:57===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-01 19:09:57 >>>回调事件[910,devices/YC0664]
2026-05-01 19:09:57 >>>故障排除日志:上一MQTT订单号缓存列表为2605011905510057242876
2026-05-01 19:09:57 >>>故障排除日志:终端未同步成功订单列表
2026-05-01 19:09:57 开始打印,排队:326,票券:2605011909492876323601,订单:2605011909490026837358,[2026-05-01 19:09:57微信支付12元]
2026-05-01 19:09:58>>>MQTT票号同步场景，创建空订单对象
2026-05-01 19:09:58>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-01 19:09:59 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605011909492876323601","queue_number":326,"trade_uid":"2605011909490026837358"}]}
2026-05-01 19:10:00 >>>故障排除日志:删除未同步下发订单成功2605011909490026837358
2026-05-01 19:10:00 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877743]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-01 19:10:39 >>>回调事件[910,devices/YC0664]
2026-05-01 19:10:39 >>>故障排除日志:上一MQTT订单号缓存列表为2605011909490026837358
2026-05-01 19:10:39 >>>故障排除日志:终端未同步成功订单列表
2026-05-01 19:10:39 开始打印,排队:327,票券:2605011910308034038901,订单:2605011910300077728339,[2026-05-01 19:10:37微信支付12元]
2026-05-01 19:10:39>>>MQTT票号同步场景，创建空订单对象
2026-05-01 19:10:39>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-01 19:10:41 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605011910308034038901","queue_number":327,"trade_uid":"2605011910300077728339"}]}
2026-05-01 19:10:41 >>>故障排除日志:删除未同步下发订单成功2605011910300077728339
2026-05-01 19:10:41 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877757]


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


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


===19:22:00===
2026-05-01 19:20:59 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605011920497729286101","queue_number":330,"trade_uid":"2605011920490075009532"}]}
2026-05-01 19:20:59 >>>故障排除日志:删除未同步下发订单成功2605011920490075009532
2026-05-01 19:20:59 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877872]


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


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


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


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


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


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


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


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


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


===20:10:03===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-01 20:09:11 >>>回调事件[910,devices/YC0664]
2026-05-01 20:09:11 >>>故障排除日志:上一MQTT订单号缓存列表为2605011959380067363065
2026-05-01 20:09:11 >>>故障排除日志:终端未同步成功订单列表
2026-05-01 20:09:11 开始打印,排队:342,票券:2605012009020936517901,订单:2605012009020007378725,[2026-05-01 20:09:09支付宝支付12元]
2026-05-01 20:09:11>>>MQTT票号同步场景，创建空订单对象
2026-05-01 20:09:11>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-01 20:09:13 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605012009020936517901","queue_number":342,"trade_uid":"2605012009020007378725"}]}
2026-05-01 20:09:13 >>>故障排除日志:删除未同步下发订单成功2605012009020007378725
2026-05-01 20:09:13 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878396]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-01 20:09:31 >>>回调事件[910,devices/YC0664]
2026-05-01 20:09:32 >>>故障排除日志:上一MQTT订单号缓存列表为2605012009020007378725
2026-05-01 20:09:32 >>>故障排除日志:终端未同步成功订单列表
2026-05-01 20:09:32 开始打印,排队:343,票券:2605012009236049335301,订单:2605012009230058446029,[2026-05-01 20:09:30微信支付12元]
2026-05-01 20:09:32>>>MQTT票号同步场景，创建空订单对象
2026-05-01 20:09:32>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-01 20:09:34 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605012009236049335301","queue_number":343,"trade_uid":"2605012009230058446029"}]}
2026-05-01 20:09:34 >>>故障排除日志:删除未同步下发订单成功2605012009230058446029
2026-05-01 20:09:34 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878403]


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


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


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


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


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


===20:22:05===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-01 20:21:40 >>>回调事件[910,devices/YC0664]
2026-05-01 20:21:40 >>>故障排除日志:上一MQTT订单号缓存列表为2605012019200008424632
2026-05-01 20:21:40 >>>故障排除日志:终端未同步成功订单列表
2026-05-01 20:21:40 开始打印,排队:349,票券:2605012021293900052401,订单:2605012021290036621786,[2026-05-01 20:21:38微信支付12元]
2026-05-01 20:21:40>>>MQTT票号同步场景，创建空订单对象
2026-05-01 20:21:40>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-01 20:21:42 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605012021293900052401","queue_number":349,"trade_uid":"2605012021290036621786"}]}
2026-05-01 20:21:42 >>>故障排除日志:删除未同步下发订单成功2605012021290036621786
2026-05-01 20:21:42 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878559]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-01 20:21:47 >>>回调事件[910,devices/YC0664]
2026-05-01 20:21:47 >>>故障排除日志:上一MQTT订单号缓存列表为2605012021290036621786
2026-05-01 20:21:47 >>>故障排除日志:终端未同步成功订单列表
2026-05-01 20:21:47 开始打印,排队:350,票券:2605012021386317019801,订单:2605012021380060203942,[2026-05-01 20:21:46微信支付12元]
2026-05-01 20:21:47>>>MQTT票号同步场景，创建空订单对象
2026-05-01 20:21:47>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-01 20:21:49 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605012021386317019801","queue_number":350,"trade_uid":"2605012021380060203942"}]}
2026-05-01 20:21:49 >>>故障排除日志:删除未同步下发订单成功2605012021380060203942
2026-05-01 20:21:49 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878565]


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


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


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


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


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


===20:41:11===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-01 20:40:43 >>>回调事件[910,devices/YC0664]
2026-05-01 20:40:43 >>>故障排除日志:上一MQTT订单号缓存列表为2605012038340039853593
2026-05-01 20:40:43 >>>故障排除日志:终端未同步成功订单列表
2026-05-01 20:40:43 开始打印,排队:358,票券:2605012040322261491801,订单:2605012040320020503574,[2026-05-01 20:40:41微信支付12元]
2026-05-01 20:40:43>>>MQTT票号同步场景，创建空订单对象
2026-05-01 20:40:43>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-01 20:40:45 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605012040322261491801","queue_number":358,"trade_uid":"2605012040320020503574"}]}
2026-05-01 20:40:45 >>>故障排除日志:删除未同步下发订单成功2605012040320020503574
2026-05-01 20:40:45 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878796]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-01 20:40:50 >>>回调事件[910,devices/YC0664]
2026-05-01 20:40:50 >>>故障排除日志:上一MQTT订单号缓存列表为2605012040320020503574
2026-05-01 20:40:50 >>>故障排除日志:终端未同步成功订单列表
2026-05-01 20:40:50 开始打印,排队:359,票券:2605012040423700351901,订单:2605012040420034592151,[2026-05-01 20:40:49微信支付12元]
2026-05-01 20:40:50>>>MQTT票号同步场景，创建空订单对象
2026-05-01 20:40:50>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-01 20:40:52 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605012040423700351901","queue_number":359,"trade_uid":"2605012040420034592151"}]}
2026-05-01 20:40:52 >>>故障排除日志:删除未同步下发订单成功2605012040420034592151
2026-05-01 20:40:52 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878802]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-01 20:40:56 >>>回调事件[910,devices/YC0664]
2026-05-01 20:40:56 >>>故障排除日志:上一MQTT订单号缓存列表为2605012040420034592151
2026-05-01 20:40:56 >>>故障排除日志:终端未同步成功订单列表
2026-05-01 20:40:56 开始打印,排队:360,票券:2605012040480345884801,订单:2605012040480001436356,[2026-05-01 20:40:55微信支付12元]
2026-05-01 20:40:56>>>MQTT票号同步场景，创建空订单对象
2026-05-01 20:40:56>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-01 20:40:58 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605012040480345884801","queue_number":360,"trade_uid":"2605012040480001436356"}]}
2026-05-01 20:40:58 >>>故障排除日志:删除未同步下发订单成功2605012040480001436356
2026-05-01 20:40:58 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878808]


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


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


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


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


===21:08:12===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-01 21:07:15 >>>回调事件[910,devices/YC0664]
2026-05-01 21:07:15 >>>故障排除日志:上一MQTT订单号缓存列表为2605012104030015690695
2026-05-01 21:07:15 >>>故障排除日志:终端未同步成功订单列表
2026-05-01 21:07:15 开始打印,排队:365,票券:2605012107026333026101,订单:2605012107020060799842,[2026-05-01 21:07:13微信支付12元]
2026-05-01 21:07:15>>>MQTT票号同步场景，创建空订单对象
2026-05-01 21:07:15>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-01 21:07:17 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605012107026333026101","queue_number":365,"trade_uid":"2605012107020060799842"}]}
2026-05-01 21:07:17 >>>故障排除日志:删除未同步下发订单成功2605012107020060799842
2026-05-01 21:07:17 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536879094]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-01 21:07:38 >>>回调事件[910,devices/YC0664]
2026-05-01 21:07:38 >>>故障排除日志:上一MQTT订单号缓存列表为2605012107020060799842
2026-05-01 21:07:38 >>>故障排除日志:终端未同步成功订单列表
2026-05-01 21:07:38 开始打印,排队:366,票券:2605012107284499329701,订单:2605012107280043080454,[2026-05-01 21:07:36微信支付12元]
2026-05-01 21:07:38>>>MQTT票号同步场景，创建空订单对象
2026-05-01 21:07:38>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-01 21:07:40 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605012107284499329701","queue_number":366,"trade_uid":"2605012107280043080454"}]}
2026-05-01 21:07:40 >>>故障排除日志:删除未同步下发订单成功2605012107280043080454
2026-05-01 21:07:41 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536879100]


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


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


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


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


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


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


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


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


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


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


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


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


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


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