TLClient_JSSCOM_LuatOS-Air_V4010_RDA8910_RFTTS_0xe0000,2.8.6,869701076494239,70763087053710,
poweron reason:0

===08:53:08===
上一时间戳为1777086778
隔日重置时间戳true
隔日清空未同步下发列表true
当前排队号为1,音量为5
初始化产品信息:[{"time_limit_date":null,"ticket_category":"0","expiry_date":90,"product_detail":"","time_limit_status":"0","begin_minute":null,"product_uid":"14872826055361668618","use_timer":1,"old_price":"10","end_hour":null,"sale_price":"10","end_minute":null,"begin_hour":null,"sale_status":1,"product_name":"剪 发"}]
打印门店凭条广告设置为剪发时 请出示小票
是否打印二维码设置为1
是否打印紧凑设置为3
当前号显示模式设置为1
当前卡项核销权限设置为0
session_id:29314****b9680
纸币器设置接收纸币范围为36
欢迎使用天羚自助售票系统[2.8.6]
定时检测未同步订单启用[checkOrderNum=536870969]
2026-04-26 08:52:08>>>cash write=30
2026-04-26 08:52:08>>>cash write=02
2026-04-26 08:52:08>>>cash write=3E
2026-04-26 08:52:08>>>cash read=808F808F
系统时间初始化成功，时间为20264268528
2026-04-26 08:52:09>>>cash write=02
2026-04-26 08:52:09 >>>剩余flash空间=1680000,占用RAM为654.2490234375
2026-04-26 08:52:09 >>>回调事件:910,subscribe,10000,连接服务器成功

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

2026-04-26 08:52:12>>>cash write=0C
2026-04-26 08:52:12>>>cash read=3E
流量卡还有126天过期
2026-04-26 08:52:20 >>>当前Ram内存为676.3603515625


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


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


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


===09:18:10===
2026-04-26 09:17:21>>>cash read=0A
2026-04-26 09:17:22>>>cash read=3E


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


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


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


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


===09:48:12===
2026-04-26 09:47:47>>>cash read=00
2026-04-26 09:47:48>>>cash read=818F42
2026-04-26 09:47:48>>>cash write=02
2026-04-26 09:47:48 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 09:47:48>>>cash read=10
2026-04-26 09:47:48 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 09:47:48 当前产品价格10元，投币10元，打印小票中...
2026-04-26 09:47:48 >>>开始打印,排队号为8,订单号为2604260947480023648562
2026-04-26 09:47:49>>>订单2604260947480023648562写入成功,剩余空间为1679500,占用RAM为635.453125
2026-04-26 09:47:50 >>>回调事件[910,devices/S3648]
2026-04-26 09:47:50 >>>故障排除日志:上一MQTT订单号缓存列表为2604260942150077633969
2026-04-26 09:47:50 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 09:47:51 开始打印,排队:9,票券:2604260947242568243901,订单:2604260947240023766679,[2026-04-26 09:47:47微信支付10元]
2026-04-26 09:47:51>>>HTTP请求进行中，跳过本次同步
删除未同步订单2604260947480023648562
2026-04-26 09:47:53>>>订单2604260947480023648562删除成功,剩余空间为1680000,占用RAM为651.7216796875
检测订单目录中>>>
无未同步订单>>>
2026-04-26 09:47:53 >>>当前Ram内存为620.703125
定时检测未同步订单启用[checkOrderNum=536871559]
2026-04-26 09:47:54>>>cash write=0C
2026-04-26 09:47:54>>>cash read=3E


===09:51:12===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 09:50:37 >>>回调事件[910,devices/S3648]
2026-04-26 09:50:37 >>>故障排除日志:上一MQTT订单号缓存列表为2604260947240023766679
2026-04-26 09:50:37 >>>故障排除日志:终端未同步成功订单列表00092604260947240023766679
已接收过此消息,票券号为2604260947242568243901,排队号为9
2026-04-26 09:50:37 开始打印,排队:10,票券:2604260950310208046401,订单:2604260950310000278548,[2026-04-26 09:50:36支付宝支付10元]
2026-04-26 09:50:37>>>MQTT票号同步场景，创建空订单对象
2026-04-26 09:50:37>>>合并MQTT票号列表到订单同步请求,共2张票
2026-04-26 09:50:39 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604260947242568243901","queue_number":9,"trade_uid":"2604260947240023766679"},{"ticket_no":"2604260950310208046401","queue_number":10,"trade_uid":"2604260950310000278548"}]}
2026-04-26 09:50:39 >>>故障排除日志:删除未同步下发订单成功2604260947240023766679
2026-04-26 09:50:39 >>>故障排除日志:删除未同步下发订单成功2604260950310000278548
2026-04-26 09:50:39 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536871594]


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


===15:36:26===
2026-04-26 15:35:38>>>cash read=0A
2026-04-26 15:35:39>>>cash read=3E


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


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


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


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


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


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


===16:17:29===
2026-04-26 16:17:03>>>cash read=00
2026-04-26 16:17:04>>>cash read=29
2026-04-26 16:17:04 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 16:17:04>>>cash read=2F29
2026-04-26 16:17:06>>>cash read=3E
2026-04-26 16:17:10>>>cash read=00
2026-04-26 16:17:11>>>cash read=818F42
2026-04-26 16:17:12>>>cash write=02
2026-04-26 16:17:12 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 16:17:12>>>cash read=10
2026-04-26 16:17:12 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 16:17:12 当前产品价格10元，投币10元，打印小票中...
2026-04-26 16:17:12 >>>开始打印,排队号为56,订单号为2604261617120023648845
2026-04-26 16:17:12>>>订单2604261617120023648845写入成功,剩余空间为1679500,占用RAM为636.2314453125
删除未同步订单2604261617120023648845
2026-04-26 16:17:14>>>订单2604261617120023648845删除成功,剩余空间为1680500,占用RAM为647.02734375
检测订单目录中>>>
无未同步订单>>>
2026-04-26 16:17:15 >>>当前Ram内存为617.2529296875
定时检测未同步订单启用[checkOrderNum=536875529]
2026-04-26 16:17:15>>>cash write=0C
2026-04-26 16:17:15>>>cash read=3E


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


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


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


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


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


===17:20:31===
2026-04-26 17:19:41>>>cash read=00
2026-04-26 17:19:42>>>cash read=818F42
2026-04-26 17:19:42>>>cash write=02
2026-04-26 17:19:42 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 17:19:42>>>cash read=10
2026-04-26 17:19:42 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 17:19:42 当前产品价格10元，投币10元，打印小票中...
2026-04-26 17:19:42 >>>开始打印,排队号为63,订单号为2604261719420023648751
2026-04-26 17:19:43>>>订单2604261719420023648751写入成功,剩余空间为1679500,占用RAM为636.4248046875
删除未同步订单2604261719420023648751
2026-04-26 17:19:45>>>订单2604261719420023648751删除成功,剩余空间为1680500,占用RAM为647.76953125
检测订单目录中>>>
无未同步订单>>>
2026-04-26 17:19:45 >>>当前Ram内存为618.5068359375
定时检测未同步订单启用[checkOrderNum=536876152]
2026-04-26 17:19:46>>>cash write=0C
2026-04-26 17:19:46>>>cash read=3E


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


===18:35:38===
2026-04-26 18:34:37 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261834256486134501","queue_number":81,"trade_uid":"2604261834250062736317"}]}
2026-04-26 18:34:37 >>>故障排除日志:删除未同步下发订单成功2604261834250062736317
2026-04-26 18:34:37 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536876988]


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


===20:05:46===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 20:05:31 >>>回调事件[910,devices/S3648]
2026-04-26 20:05:31 >>>故障排除日志:上一MQTT订单号缓存列表为2604262004270018089285
2026-04-26 20:05:31 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 20:05:31 开始打印,排队:107,票券:2604262005224649963901,订单:2604262005220044380523,[2026-04-26 20:05:29微信支付10元]
2026-04-26 20:05:31>>>MQTT票号同步场景，创建空订单对象
2026-04-26 20:05:31>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 20:05:33 >>>回调事件[910,devices/S3648]
2026-04-26 20:05:33 >>>故障排除日志:上一MQTT订单号缓存列表为2604262005220044380523
2026-04-26 20:05:33 >>>故障排除日志:终端未同步成功订单列表01072604262005220044380523
2026-04-26 20:05:33 开始打印,排队:108,票券:2604262005219720971301,订单:2604262005210095311493,[2026-04-26 20:05:32微信支付10元]
已接收过此消息,票券号为2604262005224649963901,排队号为107
2026-04-26 20:05:33>>>HTTP请求进行中，跳过本次同步
2026-04-26 20:05:35 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604262005224649963901","queue_number":107,"trade_uid":"2604262005220044380523"}]}
2026-04-26 20:05:35 >>>故障排除日志:删除未同步下发订单成功2604262005220044380523
2026-04-26 20:05:35 >>>故障排除日志:终端同步成功后剩余订单列表01082604262005210095311493
定时检测未同步订单启用[checkOrderNum=536878045]


===20:09:46===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 20:09:31 >>>回调事件[910,devices/S3648]
2026-04-26 20:09:31 >>>故障排除日志:上一MQTT订单号缓存列表为2604262005210095311493|2604262005220044380523
2026-04-26 20:09:31 >>>故障排除日志:终端未同步成功订单列表01082604262005210095311493
已接收过此消息,票券号为2604262005219720971301,排队号为108
2026-04-26 20:09:31 开始打印,排队:109,票券:2604262009192010957201,订单:2604262009190017630267,[2026-04-26 20:09:29微信支付10元]
2026-04-26 20:09:31>>>MQTT票号同步场景，创建空订单对象
2026-04-26 20:09:31>>>合并MQTT票号列表到订单同步请求,共2张票
2026-04-26 20:09:33 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604262005219720971301","queue_number":108,"trade_uid":"2604262005210095311493"},{"ticket_no":"2604262009192010957201","queue_number":109,"trade_uid":"2604262009190017630267"}]}
2026-04-26 20:09:33 >>>故障排除日志:删除未同步下发订单成功2604262005210095311493
2026-04-26 20:09:33 >>>故障排除日志:删除未同步下发订单成功2604262009190017630267
2026-04-26 20:09:33 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878089]


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


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


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


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


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


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


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


===20:29:49===
2026-04-26 20:29:24>>>cash read=00
2026-04-26 20:29:25>>>cash read=818F42
2026-04-26 20:29:25>>>cash write=02
2026-04-26 20:29:25 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 20:29:25>>>cash read=10
2026-04-26 20:29:25 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 20:29:25 当前产品价格10元，投币10元，打印小票中...
2026-04-26 20:29:25 >>>开始打印,排队号为117,订单号为2604262029250023648884
2026-04-26 20:29:25>>>订单2604262029250023648884写入成功,剩余空间为1679500,占用RAM为634.94140625
删除未同步订单2604262029250023648884
2026-04-26 20:29:27>>>订单2604262029250023648884删除成功,剩余空间为1680500,占用RAM为646.59765625
检测订单目录中>>>
无未同步订单>>>
2026-04-26 20:29:28 >>>当前Ram内存为617.1923828125
定时检测未同步订单启用[checkOrderNum=536878346]
2026-04-26 20:29:28>>>cash write=0C
2026-04-26 20:29:29>>>cash read=3E


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


===20:31:50===
2026-04-26 20:31:29>>>cash read=0A
2026-04-26 20:31:30>>>cash read=3E


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


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


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


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


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


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


===20:57:54===
2026-04-26 20:57:38>>>cash read=0A
2026-04-26 20:57:40>>>cash read=3E


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


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


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


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


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


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


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


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


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


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


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