TLClient_JSSCOM_LuatOS-Air_V4010_RDA8910_RFTTS_0xe0000,2.8.6,869701076558520,21140722005333,
poweron reason:0

===09:24:42===
上一时间戳为1777104317
隔日重置时间戳true
隔日清空未同步下发列表true
当前排队号为1,音量为5
初始化产品信息:[{"time_limit_date":null,"ticket_category":"0","expiry_date":7,"product_detail":"","time_limit_status":"0","begin_minute":null,"product_uid":"14872826055362719774","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:6dab1****a9bce
纸币器设置接收纸币范围为186
欢迎使用天羚自助售票系统[2.8.6]
定时检测未同步订单启用[checkOrderNum=536870969]
2026-04-26 09:23:42>>>cash write=30
2026-04-26 09:23:42>>>cash write=02
2026-04-26 09:23:42>>>cash write=3E
2026-04-26 09:23:42>>>cash read=808F808F
系统时间初始化成功，时间为202642692342
2026-04-26 09:23:43>>>cash write=02
2026-04-26 09:23:43 >>>剩余flash空间=1680000,占用RAM为651.1376953125
2026-04-26 09:23:43 >>>回调事件:910,subscribe,10000,连接服务器成功

请求下发消息结果为0,Message sent successfully
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 09:23:44 >>>回调事件[910,devices/S3829]
当日首次设置时间戳true为1777166624
2026-04-26 09:23:44 >>>故障排除日志:上一MQTT订单号缓存列表为2604252149570047367231
2026-04-26 09:23:44 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 09:23:44 开始打印,排队:1,票券:2604260902496839938201,订单:2604260902490065553662,[2026-04-26 09:03:28微信支付10元]
2026-04-26 09:23:44>>>MQTT票号同步场景，创建空订单对象
2026-04-26 09:23:44>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 09:23:46 >>>回调事件[910,devices/S3829]
2026-04-26 09:23:46 >>>故障排除日志:上一MQTT订单号缓存列表为2604260902490065553662
2026-04-26 09:23:46 >>>故障排除日志:终端未同步成功订单列表00012604260902490065553662
已接收过此消息,票券号为2604260902496839938201,排队号为1
2026-04-26 09:23:46 开始打印,排队:2,票券:2604260923368496452301,订单:2604260923360083114959,[2026-04-26 09:23:45微信支付10元]
2026-04-26 09:23:46>>>HTTP请求进行中，跳过本次同步
流量卡还有156天过期
2026-04-26 09:23:48 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604260902496839938201","queue_number":1,"trade_uid":"2604260902490065553662"}]}
2026-04-26 09:23:48 >>>故障排除日志:删除未同步下发订单成功2604260902490065553662
2026-04-26 09:23:48 >>>故障排除日志:终端同步成功后剩余订单列表00022604260923360083114959
定时检测未同步订单启用[checkOrderNum=536870991]
2026-04-26 09:23:49>>>cash write=0C
2026-04-26 09:23:49>>>cash read=3E
2026-04-26 09:23:54 >>>当前Ram内存为648.693359375
2026-04-26 09:23:56>>>cash read=00
2026-04-26 09:23:56>>>cash read=818F42
2026-04-26 09:23:56>>>cash write=02
2026-04-26 09:23:56 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 09:23:57>>>cash read=10
2026-04-26 09:23:57 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 09:23:57 当前产品价格10元，投币10元，打印小票中...
2026-04-26 09:23:57 >>>开始打印,排队号为3,订单号为2604260923570023829390
2026-04-26 09:23:57>>>订单2604260923570023829390写入成功,剩余空间为1676500,占用RAM为654.5146484375
删除未同步订单2604260923570023829390
2026-04-26 09:23:59>>>订单2604260923570023829390删除成功,剩余空间为1677500,占用RAM为638.716796875
检测订单目录中>>>
无未同步订单>>>
2026-04-26 09:23:59 >>>当前Ram内存为622.1064453125
定时检测未同步订单启用[checkOrderNum=536871010]
2026-04-26 09:24:00>>>cash write=0C
2026-04-26 09:24:00>>>cash read=3E
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 09:24:04 >>>回调事件[910,devices/S3829]
2026-04-26 09:24:04 >>>故障排除日志:上一MQTT订单号缓存列表为2604260902490065553662|2604260923360083114959
2026-04-26 09:24:04 >>>故障排除日志:终端未同步成功订单列表00022604260923360083114959
已接收过此消息,票券号为2604260923368496452301,排队号为2
2026-04-26 09:24:05 开始打印,排队:4,票券:2604260923531455614301,订单:2604260923530012492879,[2026-04-26 09:24:04微信支付10元]
2026-04-26 09:24:05>>>MQTT票号同步场景，创建空订单对象
2026-04-26 09:24:05>>>合并MQTT票号列表到订单同步请求,共2张票
2026-04-26 09:24:07 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604260923368496452301","queue_number":2,"trade_uid":"2604260923360083114959"},{"ticket_no":"2604260923531455614301","queue_number":4,"trade_uid":"2604260923530012492879"}]}


===09:25:42===
2026-04-26 09:25:16>>>cash read=00
2026-04-26 09:25:16>>>cash read=2F29
2026-04-26 09:25:17>>>cash read=01
2026-04-26 09:25:19>>>cash read=2F
2026-04-26 09:25:20>>>cash read=3E
2026-04-26 09:25:26>>>cash read=00
2026-04-26 09:25:26>>>cash read=818F42
2026-04-26 09:25:26>>>cash write=02
2026-04-26 09:25:26 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 09:25:27>>>cash read=10
2026-04-26 09:25:27 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 09:25:27 当前产品价格10元，投币10元，打印小票中...
2026-04-26 09:25:27 >>>开始打印,排队号为6,订单号为2604260925270023829067
2026-04-26 09:25:27>>>订单2604260925270023829067写入成功,剩余空间为1679500,占用RAM为635.296875
删除未同步订单2604260925270023829067
2026-04-26 09:25:29>>>订单2604260925270023829067删除成功,剩余空间为1680500,占用RAM为645.259765625
检测订单目录中>>>
无未同步订单>>>
2026-04-26 09:25:29 >>>当前Ram内存为618.3935546875
定时检测未同步订单启用[checkOrderNum=536871047]
2026-04-26 09:25:30>>>cash write=0C
2026-04-26 09:25:30>>>cash read=3E


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


===16:34:57===
2026-04-26 16:34:32>>>cash read=00
2026-04-26 16:34:33>>>cash read=818F42
2026-04-26 16:34:33>>>cash write=02
2026-04-26 16:34:33 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 16:34:34>>>cash read=10
2026-04-26 16:34:34 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 16:34:34 当前产品价格10元，投币10元，打印小票中...
2026-04-26 16:34:34 >>>开始打印,排队号为60,订单号为2604261634340023829580
2026-04-26 16:34:34>>>订单2604261634340023829580写入成功,剩余空间为1679500,占用RAM为634.6171875
删除未同步订单2604261634340023829580
2026-04-26 16:34:36>>>订单2604261634340023829580删除成功,剩余空间为1680500,占用RAM为644.96484375
检测订单目录中>>>
无未同步订单>>>
2026-04-26 16:34:36 >>>当前Ram内存为616.78125
定时检测未同步订单启用[checkOrderNum=536875959]
2026-04-26 16:34:37>>>cash write=0C
2026-04-26 16:34:37>>>cash read=3E


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


===18:46:05===
2026-04-26 18:45:29>>>cash read=29
2026-04-26 18:45:29 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 18:45:30>>>cash read=01
2026-04-26 18:45:31>>>cash read=3E
2026-04-26 18:45:36>>>cash read=2F29
2026-04-26 18:45:37>>>cash read=01
2026-04-26 18:45:40>>>cash read=2F
2026-04-26 18:45:41>>>cash read=3E
2026-04-26 18:45:45>>>cash read=00
2026-04-26 18:45:46>>>cash read=818F42
2026-04-26 18:45:46>>>cash write=02
2026-04-26 18:45:46 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 18:45:46>>>cash read=10
2026-04-26 18:45:46 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 18:45:46 当前产品价格10元，投币10元，打印小票中...
2026-04-26 18:45:46 >>>开始打印,排队号为90,订单号为2604261845460023829792
2026-04-26 18:45:47>>>订单2604261845460023829792写入成功,剩余空间为1679500,占用RAM为636.275390625
删除未同步订单2604261845460023829792
2026-04-26 18:45:49>>>订单2604261845460023829792删除成功,剩余空间为1680000,占用RAM为645.37109375
检测订单目录中>>>
无未同步订单>>>
2026-04-26 18:45:49 >>>当前Ram内存为616.6171875
定时检测未同步订单启用[checkOrderNum=536877767]
2026-04-26 18:45:50>>>cash write=0C
2026-04-26 18:45:50>>>cash read=3E


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


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


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


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


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


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


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


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


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


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


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


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


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


===19:19:09===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:18:36 >>>回调事件[910,devices/S3829]
2026-04-26 19:18:36 >>>故障排除日志:上一MQTT订单号缓存列表为2604261916100053495957
2026-04-26 19:18:36 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 19:18:36 开始打印,排队:105,票券:2604261918275130135201,订单:2604261918270049265851,[2026-04-26 19:18:35微信支付10元]
2026-04-26 19:18:36>>>MQTT票号同步场景，创建空订单对象
2026-04-26 19:18:36>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 19:18:37 >>>回调事件[910,devices/S3829]
2026-04-26 19:18:38 >>>故障排除日志:上一MQTT订单号缓存列表为2604261918270049265851
2026-04-26 19:18:38 >>>故障排除日志:终端未同步成功订单列表01052604261918270049265851
已接收过此消息,票券号为2604261918275130135201,排队号为105
2026-04-26 19:18:38 开始打印,排队:106,票券:2604261918285076865801,订单:2604261918280047151197,[2026-04-26 19:18:36微信支付10元]
2026-04-26 19:18:38>>>HTTP请求进行中，跳过本次同步
2026-04-26 19:18:40 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261918275130135201","queue_number":105,"trade_uid":"2604261918270049265851"}]}
2026-04-26 19:18:40 >>>故障排除日志:删除未同步下发订单成功2604261918270049265851
2026-04-26 19:18:40 >>>故障排除日志:终端同步成功后剩余订单列表01062604261918280047151197
定时检测未同步订单启用[checkOrderNum=536878415]


===19:27:09===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:26:35 >>>回调事件[910,devices/S3829]
2026-04-26 19:26:35 >>>故障排除日志:上一MQTT订单号缓存列表为2604261918270049265851|2604261918280047151197
2026-04-26 19:26:35 >>>故障排除日志:终端未同步成功订单列表01062604261918280047151197
已接收过此消息,票券号为2604261918285076865801,排队号为106
2026-04-26 19:26:35 开始打印,排队:107,票券:2604261926272836795901,订单:2604261926270025401698,[2026-04-26 19:26:33微信支付10元]
2026-04-26 19:26:35 开始打印,排队:108,票券:2604261926272837631802,订单:2604261926270025401698,[2026-04-26 19:26:33微信支付10元]
2026-04-26 19:26:35>>>MQTT票号同步场景，创建空订单对象
2026-04-26 19:26:35>>>合并MQTT票号列表到订单同步请求,共3张票
2026-04-26 19:26:38 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261918285076865801","queue_number":106,"trade_uid":"2604261918280047151197"},{"ticket_no":"2604261926272836795901","queue_number":107,"trade_uid":"2604261926270025401698"},{"ticket_no":"2604261926272837631802","queue_number":108,"trade_uid":"2604261926270025401698"}]}
2026-04-26 19:26:38 >>>故障排除日志:删除未同步下发订单成功2604261918280047151197
2026-04-26 19:26:38 >>>故障排除日志:删除未同步下发订单成功2604261926270025401698
2026-04-26 19:26:38 >>>故障排除日志:删除未同步下发订单成功2604261926270025401698
2026-04-26 19:26:39 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878547]


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


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


===19:47:10===
2026-04-26 19:46:20>>>cash read=29
2026-04-26 19:46:20 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 19:46:21>>>cash read=2F29
2026-04-26 19:46:22>>>cash read=01
2026-04-26 19:46:26>>>cash read=2F
2026-04-26 19:46:27>>>cash read=3E
2026-04-26 19:46:29>>>cash read=00
2026-04-26 19:46:30>>>cash read=29
2026-04-26 19:46:30 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 19:46:30>>>cash read=2F29
2026-04-26 19:46:32>>>cash read=01
2026-04-26 19:46:32>>>cash read=2F
2026-04-26 19:46:33>>>cash read=3E
2026-04-26 19:46:35>>>cash read=00
2026-04-26 19:46:35>>>cash read=818F42
2026-04-26 19:46:35>>>cash write=02
2026-04-26 19:46:35 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 19:46:36>>>cash read=10
2026-04-26 19:46:36 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:46:36 当前产品价格10元，投币10元，打印小票中...
2026-04-26 19:46:36 >>>开始打印,排队号为112,订单号为2604261946360023829859
2026-04-26 19:46:36>>>订单2604261946360023829859写入成功,剩余空间为1679000,占用RAM为638.3115234375
删除未同步订单2604261946360023829859
2026-04-26 19:46:38>>>订单2604261946360023829859删除成功,剩余空间为1680000,占用RAM为644.9375
检测订单目录中>>>
无未同步订单>>>
2026-04-26 19:46:38 >>>当前Ram内存为617.3935546875
定时检测未同步订单启用[checkOrderNum=536878842]
2026-04-26 19:46:39>>>cash write=0C
2026-04-26 19:46:39>>>cash read=3E


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


===19:52:12===
2026-04-26 19:51:11 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261951001020334501","queue_number":113,"trade_uid":"2604261951000008171128"}]}
2026-04-26 19:51:11 >>>故障排除日志:删除未同步下发订单成功2604261951000008171128
2026-04-26 19:51:11 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878896]


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


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


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


===20:18:17===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 20:18:11 >>>回调事件[910,devices/S3829]
2026-04-26 20:18:11 >>>故障排除日志:上一MQTT订单号缓存列表为2604262016130091017372
2026-04-26 20:18:11 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 20:18:11 开始打印,排队:117,票券:2604262018020218846301,订单:2604262018020000298464,[2026-04-26 20:18:10微信支付10元]
2026-04-26 20:18:11>>>MQTT票号同步场景，创建空订单对象
2026-04-26 20:18:11>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 20:18:13 >>>回调事件[910,devices/S3829]
2026-04-26 20:18:13 >>>故障排除日志:上一MQTT订单号缓存列表为2604262018020000298464
2026-04-26 20:18:13 >>>故障排除日志:终端未同步成功订单列表01172604262018020000298464
已接收过此消息,票券号为2604262018020218846301,排队号为117
2026-04-26 20:18:13 开始打印,排队:118,票券:2604262018053457937401,订单:2604262018050032351656,[2026-04-26 20:18:11微信支付10元]
2026-04-26 20:18:13 开始打印,排队:119,票券:2604262018053458374202,订单:2604262018050032351656,[2026-04-26 20:18:11微信支付10元]
2026-04-26 20:18:13>>>HTTP请求进行中，跳过本次同步


===20:25:18===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 20:24:44 >>>回调事件[910,devices/S3829]
2026-04-26 20:24:44 >>>故障排除日志:上一MQTT订单号缓存列表为2604262018020000298464|2604262018050032351656|2604262018050032351656
2026-04-26 20:24:44 >>>故障排除日志:终端未同步成功订单列表01182604262018050032351656|01192604262018050032351656
已接收过此消息,票券号为2604262018053457937401,排队号为118
已接收过此消息,票券号为2604262018053458374202,排队号为119
2026-04-26 20:24:44 开始打印,排队:120,票券:2604262024354357336501,订单:2604262024350041726526,[2026-04-26 20:24:43微信支付10元]
2026-04-26 20:24:44>>>MQTT票号同步场景，创建空订单对象
2026-04-26 20:24:44>>>合并MQTT票号列表到订单同步请求,共3张票
2026-04-26 20:24:46 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604262018053457937401","queue_number":118,"trade_uid":"2604262018050032351656"},{"ticket_no":"2604262018053458374202","queue_number":119,"trade_uid":"2604262018050032351656"},{"ticket_no":"2604262024354357336501","queue_number":120,"trade_uid":"2604262024350041726526"}]}
2026-04-26 20:24:46 >>>故障排除日志:删除未同步下发订单成功2604262018050032351656
2026-04-26 20:24:46 >>>故障排除日志:删除未同步下发订单成功2604262018050032351656
2026-04-26 20:24:46 >>>故障排除日志:删除未同步下发订单成功2604262024350041726526
2026-04-26 20:24:46 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536879289]


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


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


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


===20:38:22===
2026-04-26 20:37:22 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604262037102638241201","queue_number":125,"trade_uid":"2604262037100024571424"},{"ticket_no":"2604262037102638633902","queue_number":126,"trade_uid":"2604262037100024571424"}]}
2026-04-26 20:37:22 >>>故障排除日志:删除未同步下发订单成功2604262037100024571424
2026-04-26 20:37:22 >>>故障排除日志:删除未同步下发订单成功2604262037100024571424
2026-04-26 20:37:22 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536879478]


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


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


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


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


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


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


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


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


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


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


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