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

===09:18:27===
上一时间戳为1777251978
隔日重置时间戳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:ea5ce****5583c
纸币器设置接收纸币范围为36
欢迎使用天羚自助售票系统[2.8.6]
定时检测未同步订单启用[checkOrderNum=536870969]
2026-04-28 09:17:27>>>cash write=30
2026-04-28 09:17:27>>>cash write=02
2026-04-28 09:17:27>>>cash write=3E
2026-04-28 09:17:27>>>cash read=808F808F808F
系统时间初始化成功，时间为202642891727
2026-04-28 09:17:28>>>cash write=02
2026-04-28 09:17:29 >>>剩余flash空间=1680000,占用RAM为655.45703125
2026-04-28 09:17:29 >>>回调事件:910,subscribe,10000,连接服务器成功

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

2026-04-28 09:17:31>>>cash write=0C
2026-04-28 09:17:31>>>cash read=3E
流量卡还有306天过期
2026-04-28 09:17:35 >>>当前Ram内存为640.9091796875


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


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


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


===09:33:29===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-28 09:32:31 >>>回调事件[910,devices/YC0664]
2026-04-28 09:32:31 >>>故障排除日志:上一MQTT订单号缓存列表为2604280928470024894414
2026-04-28 09:32:31 >>>故障排除日志:终端未同步成功订单列表
2026-04-28 09:32:31 开始打印,排队:171,票券:2604280932227876859601,订单:2604280932220077107376,[2026-04-28 09:32:30微信支付12元]
2026-04-28 09:32:31>>>MQTT票号同步场景，创建空订单对象
2026-04-28 09:32:31>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-28 09:32:33 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604280932227876859601","queue_number":171,"trade_uid":"2604280932220077107376"}]}
2026-04-28 09:32:33 >>>故障排除日志:删除未同步下发订单成功2604280932220077107376
2026-04-28 09:32:33 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536871149]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-28 09:32:36 >>>回调事件[910,devices/YC0664]
2026-04-28 09:32:36 >>>故障排除日志:上一MQTT订单号缓存列表为2604280932220077107376
2026-04-28 09:32:36 >>>故障排除日志:终端未同步成功订单列表
2026-04-28 09:32:36 开始打印,排队:172,票券:2604280932277752258501,订单:2604280932270075718497,[2026-04-28 09:32:35微信支付12元]
2026-04-28 09:32:36>>>MQTT票号同步场景，创建空订单对象
2026-04-28 09:32:36>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-28 09:32:38 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604280932277752258501","queue_number":172,"trade_uid":"2604280932270075718497"}]}
2026-04-28 09:32:38 >>>故障排除日志:删除未同步下发订单成功2604280932270075718497
2026-04-28 09:32:38 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536871156]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-28 09:33:18 >>>回调事件[910,devices/YC0664]
2026-04-28 09:33:18 >>>故障排除日志:上一MQTT订单号缓存列表为2604280932270075718497
2026-04-28 09:33:18 >>>故障排除日志:终端未同步成功订单列表
2026-04-28 09:33:18 开始打印,排队:173,票券:2604280933063960786101,订单:2604280933060037780293,[2026-04-28 09:33:17微信支付12元]
2026-04-28 09:33:18>>>MQTT票号同步场景，创建空订单对象
2026-04-28 09:33:18>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-28 09:33:20 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604280933063960786101","queue_number":173,"trade_uid":"2604280933060037780293"}]}
2026-04-28 09:33:20 >>>故障排除日志:删除未同步下发订单成功2604280933060037780293
2026-04-28 09:33:20 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536871170]


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


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


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


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


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


===10:28:30===
2026-04-28 10:28:14>>>cash read=0A
2026-04-28 10:28:15>>>cash read=3E


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


===10:31:31===
2026-04-28 10:31:14>>>cash read=0A
2026-04-28 10:31:16>>>cash read=3E


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


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


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


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


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


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


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


===12:30:33===
2026-04-28 12:29:57>>>cash read=00
2026-04-28 12:29:57>>>cash read=2F29
2026-04-28 12:29:58>>>cash read=01
2026-04-28 12:30:02>>>cash read=2F
2026-04-28 12:30:03>>>cash read=3E
2026-04-28 12:30:04>>>cash read=2F29
2026-04-28 12:30:05>>>cash read=00
2026-04-28 12:30:06>>>cash read=818F42
2026-04-28 12:30:06>>>cash write=02
2026-04-28 12:30:06 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-28 12:30:07>>>cash read=10
2026-04-28 12:30:07 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-28 12:30:08>>>cash write=0C
2026-04-28 12:30:08>>>cash read=3E
2026-04-28 12:30:14>>>cash read=00
2026-04-28 12:30:15>>>cash read=2F29
2026-04-28 12:30:16>>>cash read=01
2026-04-28 12:30:16>>>cash read=2F
2026-04-28 12:30:17>>>cash read=00
2026-04-28 12:30:18>>>cash read=2F29
2026-04-28 12:30:20>>>cash read=3E
2026-04-28 12:30:23>>>cash read=00
2026-04-28 12:30:25>>>cash read=29
2026-04-28 12:30:25 >>>回调事件130,cash_status,20029,退钞中
2026-04-28 12:30:25>>>cash read=2F29
2026-04-28 12:30:26>>>cash read=01
2026-04-28 12:30:26>>>cash read=2F
2026-04-28 12:30:28>>>cash read=3E


===12:31:34===
2026-04-28 12:30:40>>>cash read=00
2026-04-28 12:30:42>>>cash read=2F29
2026-04-28 12:30:43>>>cash read=01
2026-04-28 12:30:43>>>cash read=2F
2026-04-28 12:30:44>>>cash read=3E
2026-04-28 12:30:45>>>cash read=2F29
2026-04-28 12:30:47>>>cash read=00
2026-04-28 12:30:47>>>cash read=818F40
2026-04-28 12:30:47>>>cash write=02
2026-04-28 12:30:47 >>>回调事件130,cash_status,10022,进钞中...read money=1
2026-04-28 12:30:48>>>cash read=10
2026-04-28 12:30:48 >>>回调事件130,1,10023,finish Money=1,进钞完成
2026-04-28 12:30:49>>>cash write=0C
2026-04-28 12:30:49>>>cash read=3E
2026-04-28 12:30:50>>>cash read=00
2026-04-28 12:30:51>>>cash read=818F40
2026-04-28 12:30:51>>>cash write=02
2026-04-28 12:30:51 >>>回调事件130,cash_status,10022,进钞中...read money=1
2026-04-28 12:30:51>>>cash read=10
2026-04-28 12:30:51 >>>回调事件130,1,10023,finish Money=1,进钞完成
2026-04-28 12:30:51 当前产品价格12元，投币12元，打印小票中...
2026-04-28 12:30:51 >>>开始打印,排队号为188,订单号为2604281230480050664239
2026-04-28 12:30:52>>>订单2604281230480050664239写入成功,剩余空间为1679000,占用RAM为637.7578125
删除未同步订单2604281230480050664239
2026-04-28 12:30:54>>>订单2604281230480050664239删除成功,剩余空间为1680000,占用RAM为649.267578125
检测订单目录中>>>
无未同步订单>>>
2026-04-28 12:30:54 >>>当前Ram内存为617.9404296875
定时检测未同步订单启用[checkOrderNum=536872911]
2026-04-28 12:30:55>>>cash write=0C
2026-04-28 12:30:55>>>cash read=3E


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


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


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


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


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


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


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


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


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


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


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


===14:40:38===
2026-04-28 14:39:37 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604281439277654676901","queue_number":200,"trade_uid":"2604281439270074597895"}]}
2026-04-28 14:39:37 >>>故障排除日志:删除未同步下发订单成功2604281439270074597895
2026-04-28 14:39:37 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536874185]


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


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


===15:52:41===
2026-04-28 15:52:04>>>cash read=0A
2026-04-28 15:52:05>>>cash read=3E
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-28 15:52:38 >>>回调事件[910,devices/YC0664]
2026-04-28 15:52:38 >>>故障排除日志:上一MQTT订单号缓存列表为2604281504440066034294
2026-04-28 15:52:38 >>>故障排除日志:终端未同步成功订单列表
2026-04-28 15:52:38 开始打印,排队:203,票券:2604281552314533036101,订单:2604281552310043373523,[2026-04-28 15:52:37微信支付12元]
2026-04-28 15:52:38>>>MQTT票号同步场景，创建空订单对象
2026-04-28 15:52:38>>>合并MQTT票号列表到订单同步请求,共1张票


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


===18:35:51===
2026-04-28 18:35:30>>>cash read=0A
2026-04-28 18:35:31>>>cash read=3E


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


===20:10:00===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-28 20:09:57 >>>回调事件[910,devices/YC0664]
2026-04-28 20:09:57 >>>故障排除日志:上一MQTT订单号缓存列表为2604282003030069244115|2604282003030069244115
2026-04-28 20:09:57 >>>故障排除日志:终端未同步成功订单列表
2026-04-28 20:09:57 开始打印,排队:260,票券:2604282009512129191401,订单:2604282009510019211513,[2026-04-28 20:09:56支付宝支付12元]
2026-04-28 20:09:57>>>MQTT票号同步场景，创建空订单对象
2026-04-28 20:09:57>>>合并MQTT票号列表到订单同步请求,共1张票


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


===21:11:08===
2026-04-28 21:10:55>>>cash read=0A
2026-04-28 21:10:57>>>cash read=3E


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


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


===21:19:09===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-28 21:18:56 >>>回调事件[910,devices/YC0664]
2026-04-28 21:18:56 >>>故障排除日志:上一MQTT订单号缓存列表为2604282112340069258327
2026-04-28 21:18:56 >>>故障排除日志:终端未同步成功订单列表
2026-04-28 21:18:56 开始打印,排队:282,票券:2604282118460454061301,订单:2604282118460002655673,[2026-04-28 21:18:55微信支付12元]
2026-04-28 21:18:57>>>MQTT票号同步场景，创建空订单对象
2026-04-28 21:18:57>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-28 21:18:59 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604282118460454061301","queue_number":282,"trade_uid":"2604282118460002655673"}]}
2026-04-28 21:18:59 >>>故障排除日志:删除未同步下发订单成功2604282118460002655673
2026-04-28 21:18:59 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878447]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-28 21:18:59 >>>回调事件[910,devices/YC0664]
2026-04-28 21:18:59 >>>故障排除日志:上一MQTT订单号缓存列表为2604282118460002655673
2026-04-28 21:18:59 >>>故障排除日志:终端未同步成功订单列表
2026-04-28 21:18:59 开始打印,排队:283,票券:2604282118561508573401,订单:2604282118560013339575,[2026-04-28 21:18:58支付宝支付12元]
2026-04-28 21:18:59>>>MQTT票号同步场景，创建空订单对象
2026-04-28 21:18:59>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-28 21:19:01 >>>回调事件[910,devices/YC0664]
2026-04-28 21:19:01 >>>故障排除日志:上一MQTT订单号缓存列表为2604282118560013339575
2026-04-28 21:19:01 >>>故障排除日志:终端未同步成功订单列表02832604282118560013339575
2026-04-28 21:19:01 开始打印,排队:284,票券:2604282118512907752101,订单:2604282118510027256527,[2026-04-28 21:19:00微信支付12元]
已接收过此消息,票券号为2604282118561508573401,排队号为283
2026-04-28 21:19:01>>>HTTP请求进行中，跳过本次同步
2026-04-28 21:19:03 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604282118561508573401","queue_number":283,"trade_uid":"2604282118560013339575"}]}
2026-04-28 21:19:03 >>>故障排除日志:删除未同步下发订单成功2604282118560013339575
2026-04-28 21:19:03 >>>故障排除日志:终端同步成功后剩余订单列表02842604282118510027256527
定时检测未同步订单启用[checkOrderNum=536878455]


===21:22:10===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-28 21:21:30 >>>回调事件[910,devices/YC0664]
2026-04-28 21:21:30 >>>故障排除日志:上一MQTT订单号缓存列表为2604282118510027256527|2604282118560013339575
2026-04-28 21:21:30 >>>故障排除日志:终端未同步成功订单列表02842604282118510027256527
已接收过此消息,票券号为2604282118512907752101,排队号为284
2026-04-28 21:21:30 开始打印,排队:285,票券:2604282121194366401601,订单:2604282121190041089063,[2026-04-28 21:21:28微信支付12元]
2026-04-28 21:21:30>>>MQTT票号同步场景，创建空订单对象
2026-04-28 21:21:30>>>合并MQTT票号列表到订单同步请求,共2张票
2026-04-28 21:21:32 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604282118512907752101","queue_number":284,"trade_uid":"2604282118510027256527"},{"ticket_no":"2604282121194366401601","queue_number":285,"trade_uid":"2604282121190041089063"}]}
2026-04-28 21:21:32 >>>故障排除日志:删除未同步下发订单成功2604282118510027256527
2026-04-28 21:21:32 >>>故障排除日志:删除未同步下发订单成功2604282121190041089063
2026-04-28 21:21:32 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878487]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-28 21:22:07 >>>回调事件[910,devices/YC0664]
2026-04-28 21:22:07 >>>故障排除日志:上一MQTT订单号缓存列表为2604282118510027256527|2604282121190041089063
2026-04-28 21:22:07 >>>故障排除日志:终端未同步成功订单列表
2026-04-28 21:22:07 开始打印,排队:286,票券:2604282121539344884901,订单:2604282121530091098865,[2026-04-28 21:22:06支付宝支付12元]
2026-04-28 21:22:07>>>MQTT票号同步场景，创建空订单对象
2026-04-28 21:22:07>>>合并MQTT票号列表到订单同步请求,共1张票


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


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


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


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


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


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


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