TLClient_JSSCOM_LuatOS-Air_V4010_RDA8910_RFTTS_0xe0000,2.8.6,863482065029569,25647156641022,
poweron reason:0

===08:31:00===
上一时间戳为1777080398
隔日重置时间戳true
隔日清空未同步下发列表true
当前排队号为1,音量为5
初始化产品信息:[{"time_limit_date":"","ticket_category":"0","expiry_date":90,"product_detail":"","time_limit_status":"0","begin_minute":"00","product_uid":"12710657366789927967","use_timer":1,"old_price":"10","end_hour":"23","sale_price":"10","end_minute":"59","begin_hour":"00","sale_status":1,"product_name":"剪发"},{"time_limit_date":"","ticket_category":"0","expiry_date":7,"product_detail":"","time_limit_status":"0","begin_minute":"00","product_uid":"12710657366789941344","use_timer":1,"old_price":"15","end_hour":"23","sale_price":"15","end_minute":"59","begin_hour":"00","sale_status":1,"product_name":"精剪"}]
打印门店标题设置为沙宣快剪
是否打印二维码设置为1
是否打印紧凑设置为3
当前号显示模式设置为1
当前卡项核销权限设置为0
session_id:0b2f4****a6eb3
纸币器设置接收纸币范围为36
欢迎使用天羚自助售票系统[2.8.6]
定时检测未同步订单启用[checkOrderNum=536870971]
2026-04-26 08:29:59>>>cash write=30
2026-04-26 08:29:59>>>cash write=02
2026-04-26 08:29:59>>>cash write=3E
系统时间初始化成功，时间为202642682959
2026-04-26 08:29:59>>>cash read=808F808F
2026-04-26 08:30:00>>>cash write=02
2026-04-26 08:30:00 >>>剩余flash空间=1680000,占用RAM为655.6171875
2026-04-26 08:30:00 >>>回调事件:910,subscribe,10000,连接服务器成功

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

2026-04-26 08:30:03>>>cash write=0C
2026-04-26 08:30:03>>>cash read=3E
流量卡还有369天过期
2026-04-26 08:30:11 >>>当前Ram内存为668.380859375


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


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


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


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


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


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


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


===09:32:02===
2026-04-26 09:31:17>>>cash read=00
2026-04-26 09:31:17>>>cash read=818F42
2026-04-26 09:31:17>>>cash write=02
2026-04-26 09:31:17 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 09:31:18>>>cash read=10
2026-04-26 09:31:18 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 09:31:18 当前产品价格10元，投币10元，打印小票中...
2026-04-26 09:31:18 >>>开始打印,排队号为8,订单号为2604260931180023275754
2026-04-26 09:31:18>>>订单2604260931180023275754写入成功,剩余空间为1679500,占用RAM为635.4619140625
删除未同步订单2604260931180023275754
2026-04-26 09:31:20>>>订单2604260931180023275754删除成功,剩余空间为1680500,占用RAM为645.0869140625
检测订单目录中>>>
无未同步订单>>>
2026-04-26 09:31:20 >>>当前Ram内存为618.486328125
定时检测未同步订单启用[checkOrderNum=536871628]
2026-04-26 09:31:21>>>cash read=818F41
2026-04-26 09:31:21 >>>回调事件130,cash_status,10022,进钞中...read money=5
2026-04-26 09:31:22>>>cash read=10
2026-04-26 09:31:22 >>>回调事件130,5,10023,finish Money=5,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 09:31:23>>>cash write=0C
2026-04-26 09:31:23>>>cash read=00
2026-04-26 09:31:24>>>cash read=818F41
2026-04-26 09:31:24>>>cash write=02
2026-04-26 09:31:24 >>>回调事件130,cash_status,10022,进钞中...read money=5
2026-04-26 09:31:24>>>cash read=10
2026-04-26 09:31:24 >>>回调事件130,5,10023,finish Money=5,进钞完成
2026-04-26 09:31:24 当前产品价格10元，投币10元，打印小票中...
2026-04-26 09:31:24 >>>开始打印,排队号为9,订单号为2604260931220023275812
2026-04-26 09:31:24>>>订单2604260931220023275812写入成功,剩余空间为1678500,占用RAM为638.716796875
删除未同步订单2604260931220023275812
2026-04-26 09:31:26>>>订单2604260931220023275812删除成功,剩余空间为1679500,占用RAM为650.40625
检测订单目录中>>>
无未同步订单>>>
2026-04-26 09:31:27 >>>当前Ram内存为620.318359375
定时检测未同步订单启用[checkOrderNum=536871640]
2026-04-26 09:31:28>>>cash write=0C
2026-04-26 09:31:28>>>cash read=3E


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


===09:36:02===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 09:35:02 >>>回调事件[910,devices/S3275]
2026-04-26 09:35:02 >>>故障排除日志:上一MQTT订单号缓存列表为2604260933320009589472
2026-04-26 09:35:02 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 09:35:02 开始打印,排队:11,票券:2604260934358889083601,订单:2604260934350086978093,[2026-04-26 09:35:02微信支付10元]
2026-04-26 09:35:02>>>MQTT票号同步场景，创建空订单对象
2026-04-26 09:35:02>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 09:35:04 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604260934358889083601","queue_number":11,"trade_uid":"2604260934350086978093"}]}
2026-04-26 09:35:04 >>>故障排除日志:删除未同步下发订单成功2604260934350086978093
2026-04-26 09:35:04 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536871691]
2026-04-26 09:35:13>>>cash read=29
2026-04-26 09:35:13 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 09:35:13>>>cash read=2F29
2026-04-26 09:35:15>>>cash read=3E
2026-04-26 09:35:16>>>cash read=00
2026-04-26 09:35:17>>>cash read=818F43
2026-04-26 09:35:17>>>cash write=02
2026-04-26 09:35:17 >>>回调事件130,cash_status,10022,进钞中...read money=20
2026-04-26 09:35:17>>>cash read=10
2026-04-26 09:35:17 >>>回调事件130,20,10023,finish Money=20,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 09:35:17 当前产品价格10元，投币20元，打印小票中...
2026-04-26 09:35:18 >>>开始打印,排队号为12,订单号为2604260935180023275972
2026-04-26 09:35:18 >>>开始打印,排队号为13,订单号为2604260935180023275972
2026-04-26 09:35:18>>>订单2604260935180023275972写入成功,剩余空间为1678000,占用RAM为651.6787109375
删除未同步订单2604260935180023275972
2026-04-26 09:35:22>>>订单2604260935180023275972删除成功,剩余空间为1679000,占用RAM为661.34765625
检测订单目录中>>>
无未同步订单>>>
2026-04-26 09:35:22 >>>当前Ram内存为621.9384765625
定时检测未同步订单启用[checkOrderNum=536871698]
2026-04-26 09:35:23>>>cash write=0C
2026-04-26 09:35:23>>>cash read=3E


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


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


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


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


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


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


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


===10:10:04===
2026-04-26 10:09:29>>>cash read=29
2026-04-26 10:09:29 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 10:09:30>>>cash read=2F29
2026-04-26 10:09:32>>>cash read=3E
2026-04-26 10:09:34>>>cash read=00
2026-04-26 10:09:34>>>cash read=818F42
2026-04-26 10:09:34>>>cash write=02
2026-04-26 10:09:35 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 10:09:35>>>cash read=10
2026-04-26 10:09:35 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 10:09:35 当前产品价格10元，投币10元，打印小票中...
2026-04-26 10:09:35 >>>开始打印,排队号为21,订单号为2604261009350023275464
2026-04-26 10:09:35>>>订单2604261009350023275464写入成功,剩余空间为1679500,占用RAM为638.998046875
删除未同步订单2604261009350023275464
2026-04-26 10:09:37>>>订单2604261009350023275464删除成功,剩余空间为1680500,占用RAM为646.8603515625
检测订单目录中>>>
无未同步订单>>>
2026-04-26 10:09:38 >>>当前Ram内存为619.794921875
定时检测未同步订单启用[checkOrderNum=536872069]
2026-04-26 10:09:38>>>cash write=0C
2026-04-26 10:09:39>>>cash read=3E


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


===10:28:05===
2026-04-26 10:27:50>>>cash read=29
2026-04-26 10:27:50 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 10:27:51>>>cash read=2F29
2026-04-26 10:27:53>>>cash read=00
2026-04-26 10:27:54>>>cash read=29
2026-04-26 10:27:54 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 10:27:54>>>cash read=2F29
2026-04-26 10:27:56>>>cash read=00
2026-04-26 10:27:57>>>cash read=818F42
2026-04-26 10:27:57>>>cash write=02
2026-04-26 10:27:57 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 10:27:57>>>cash read=10
2026-04-26 10:27:57 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 10:27:57 当前产品价格10元，投币10元，打印小票中...
2026-04-26 10:27:57 >>>开始打印,排队号为23,订单号为2604261027570023275959
2026-04-26 10:27:58>>>订单2604261027570023275959写入成功,剩余空间为1679500,占用RAM为638.8837890625
删除未同步订单2604261027570023275959
2026-04-26 10:28:00>>>订单2604261027570023275959删除成功,剩余空间为1680000,占用RAM为646.1923828125
检测订单目录中>>>
无未同步订单>>>
2026-04-26 10:28:00 >>>当前Ram内存为619.064453125
定时检测未同步订单启用[checkOrderNum=536872254]
2026-04-26 10:28:00>>>cash read=2F29
2026-04-26 10:28:01>>>cash write=0C
2026-04-26 10:28:01>>>cash read=3E


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


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


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


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


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


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


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


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


===11:10:07===
2026-04-26 11:09:06 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261108558249164301","queue_number":31,"trade_uid":"2604261108550080213862"}]}
2026-04-26 11:09:06 >>>故障排除日志:删除未同步下发订单成功2604261108550080213862
2026-04-26 11:09:06 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536872692]


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


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


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


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


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


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


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


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


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


===12:10:10===
2026-04-26 12:09:45>>>cash read=00
2026-04-26 12:09:46>>>cash read=2F29
2026-04-26 12:09:47>>>cash read=01
2026-04-26 12:09:48>>>cash read=2F
2026-04-26 12:09:49>>>cash read=3E
2026-04-26 12:09:51>>>cash read=00
2026-04-26 12:09:52>>>cash read=818F42
2026-04-26 12:09:52>>>cash write=02
2026-04-26 12:09:52 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 12:09:52>>>cash read=10
2026-04-26 12:09:52 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 12:09:52 当前产品价格10元，投币10元，打印小票中...
2026-04-26 12:09:52 >>>开始打印,排队号为42,订单号为2604261209520023275208
2026-04-26 12:09:52>>>订单2604261209520023275208写入成功,剩余空间为1679500,占用RAM为637.7744140625
删除未同步订单2604261209520023275208
2026-04-26 12:09:54>>>订单2604261209520023275208删除成功,剩余空间为1680500,占用RAM为647.4404296875
检测订单目录中>>>
无未同步订单>>>
2026-04-26 12:09:55 >>>当前Ram内存为618.94140625
定时检测未同步订单启用[checkOrderNum=536873319]
2026-04-26 12:09:55>>>cash write=0C
2026-04-26 12:09:55>>>cash read=3E


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


===12:19:10===
2026-04-26 12:18:57>>>cash read=00
2026-04-26 12:18:59>>>cash read=2F29
2026-04-26 12:19:00>>>cash read=3E
2026-04-26 12:19:04>>>cash read=00
2026-04-26 12:19:05>>>cash read=29
2026-04-26 12:19:05 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 12:19:05>>>cash read=2F29
2026-04-26 12:19:07>>>cash read=3E


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


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


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


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


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


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


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


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


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


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


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


===14:08:13===
2026-04-26 14:07:16>>>cash read=00
2026-04-26 14:07:16>>>cash read=818F42
2026-04-26 14:07:16>>>cash write=02
2026-04-26 14:07:16 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 14:07:16>>>cash read=10
2026-04-26 14:07:16 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 14:07:16 当前产品价格10元，投币10元，打印小票中...
2026-04-26 14:07:16 >>>开始打印,排队号为56,订单号为2604261407160023275856
2026-04-26 14:07:17>>>订单2604261407160023275856写入成功,剩余空间为1679500,占用RAM为636.0791015625
删除未同步订单2604261407160023275856
2026-04-26 14:07:19>>>订单2604261407160023275856删除成功,剩余空间为1680500,占用RAM为644.4931640625
检测订单目录中>>>
无未同步订单>>>
2026-04-26 14:07:19 >>>当前Ram内存为617.912109375
定时检测未同步订单启用[checkOrderNum=536874488]
2026-04-26 14:07:20>>>cash write=0C
2026-04-26 14:07:20>>>cash read=3E
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 14:07:25 >>>回调事件[910,devices/S3275]
2026-04-26 14:07:25 >>>故障排除日志:上一MQTT订单号缓存列表为2604261346250083502814
2026-04-26 14:07:25 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 14:07:25 开始打印,排队:57,票券:2604261407195200022301,订单:2604261407190050203552,[2026-04-26 14:07:25微信支付15元]
2026-04-26 14:07:25>>>MQTT票号同步场景，创建空订单对象
2026-04-26 14:07:25>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 14:07:27 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261407195200022301","queue_number":57,"trade_uid":"2604261407190050203552"}]}
2026-04-26 14:07:27 >>>故障排除日志:删除未同步下发订单成功2604261407190050203552
2026-04-26 14:07:27 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536874494]


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


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


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


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


===14:47:15===
2026-04-26 14:46:44>>>cash read=0A
2026-04-26 14:46:45>>>cash read=3E


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


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


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


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


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


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


===15:11:16===
2026-04-26 15:10:53>>>cash read=0A
2026-04-26 15:10:54>>>cash read=3E


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


===17:20:24===
2026-04-26 17:19:22 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261719123814249401","queue_number":99,"trade_uid":"2604261719120036207685"}]}
2026-04-26 17:19:22 >>>故障排除日志:删除未同步下发订单成功2604261719120036207685
2026-04-26 17:19:22 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536876660]


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


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


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


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


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


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


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


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


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


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


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


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


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


===18:39:27===
2026-04-26 18:38:35>>>cash read=00
2026-04-26 18:38:36>>>cash read=818F42
2026-04-26 18:38:36>>>cash write=02
2026-04-26 18:38:36 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 18:38:36>>>cash read=10
2026-04-26 18:38:36 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 18:38:36 当前产品价格10元，投币10元，打印小票中...
2026-04-26 18:38:36 >>>开始打印,排队号为115,订单号为2604261838360023275991
2026-04-26 18:38:36>>>订单2604261838360023275991写入成功,剩余空间为1679500,占用RAM为636.080078125
删除未同步订单2604261838360023275991
2026-04-26 18:38:39>>>订单2604261838360023275991删除成功,剩余空间为1680500,占用RAM为644.8427734375
检测订单目录中>>>
无未同步订单>>>
2026-04-26 18:38:39 >>>当前Ram内存为618.224609375
定时检测未同步订单启用[checkOrderNum=536877491]
2026-04-26 18:38:40>>>cash write=0C
2026-04-26 18:38:40>>>cash read=3E


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


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


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


===19:01:28===
2026-04-26 19:00:44>>>cash read=00
2026-04-26 19:00:45>>>cash read=2F29
2026-04-26 19:00:47>>>cash read=3E
2026-04-26 19:00:53>>>cash read=00
2026-04-26 19:00:54>>>cash read=818F42
2026-04-26 19:00:54>>>cash write=02
2026-04-26 19:00:54 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 19:00:55>>>cash read=10
2026-04-26 19:00:55 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:00:55 当前产品价格10元，投币10元，打印小票中...
2026-04-26 19:00:55 >>>开始打印,排队号为119,订单号为2604261900550023275844
2026-04-26 19:00:55>>>订单2604261900550023275844写入成功,剩余空间为1679500,占用RAM为634.236328125
删除未同步订单2604261900550023275844
2026-04-26 19:00:57>>>订单2604261900550023275844删除成功,剩余空间为1680500,占用RAM为646.466796875
检测订单目录中>>>
无未同步订单>>>
2026-04-26 19:00:57 >>>当前Ram内存为617.9638671875
定时检测未同步订单启用[checkOrderNum=536877723]
2026-04-26 19:00:58>>>cash write=0C
2026-04-26 19:00:58>>>cash read=3E


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


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


===19:07:29===
2026-04-26 19:06:28 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261906176928254101","queue_number":121,"trade_uid":"2604261906170066975219"}]}
2026-04-26 19:06:28 >>>故障排除日志:删除未同步下发订单成功2604261906170066975219
2026-04-26 19:06:28 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877794]


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


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


===19:21:30===
2026-04-26 19:20:58>>>cash read=00
2026-04-26 19:20:58>>>cash read=818F42
2026-04-26 19:20:58>>>cash write=02
2026-04-26 19:20:58 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 19:20:59>>>cash read=10
2026-04-26 19:20:59 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:20:59 当前产品价格10元，投币10元，打印小票中...
2026-04-26 19:20:59 >>>开始打印,排队号为124,订单号为2604261920590023275890
2026-04-26 19:20:59>>>订单2604261920590023275890写入成功,剩余空间为1679500,占用RAM为635.3671875
删除未同步订单2604261920590023275890
2026-04-26 19:21:01>>>订单2604261920590023275890删除成功,剩余空间为1680500,占用RAM为645.88671875
检测订单目录中>>>
无未同步订单>>>
2026-04-26 19:21:01 >>>当前Ram内存为617.5439453125
定时检测未同步订单启用[checkOrderNum=536877947]
2026-04-26 19:21:02>>>cash write=0C
2026-04-26 19:21:02>>>cash read=3E
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:21:23 >>>回调事件[910,devices/S3275]
2026-04-26 19:21:23 >>>故障排除日志:上一MQTT订单号缓存列表为2604261919070030702751
2026-04-26 19:21:23 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 19:21:23 开始打印,排队:125,票券:2604261921159179658101,订单:2604261921150089328431,[2026-04-26 19:21:22微信支付10元]
2026-04-26 19:21:23>>>MQTT票号同步场景，创建空订单对象
2026-04-26 19:21:23>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 19:21:25 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261921159179658101","queue_number":125,"trade_uid":"2604261921150089328431"}]}
2026-04-26 19:21:25 >>>故障排除日志:删除未同步下发订单成功2604261921150089328431
2026-04-26 19:21:25 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877959]


===19:23:30===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:22:29 >>>回调事件[910,devices/S3275]
2026-04-26 19:22:29 >>>故障排除日志:上一MQTT订单号缓存列表为2604261921150089328431
2026-04-26 19:22:29 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 19:22:29 开始打印,排队:126,票券:2604261922241105734301,订单:2604261922240009258016,[2026-04-26 19:22:29微信支付10元]
2026-04-26 19:22:29>>>MQTT票号同步场景，创建空订单对象
2026-04-26 19:22:29>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 19:22:31 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261922241105734301","queue_number":126,"trade_uid":"2604261922240009258016"}]}
2026-04-26 19:22:31 >>>故障排除日志:删除未同步下发订单成功2604261922240009258016
2026-04-26 19:22:32 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877977]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:22:43 >>>回调事件[910,devices/S3275]
2026-04-26 19:22:43 >>>故障排除日志:上一MQTT订单号缓存列表为2604261922240009258016
2026-04-26 19:22:43 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 19:22:43 开始打印,排队:127,票券:2604261922355891585101,订单:2604261922350056846386,[2026-04-26 19:22:42微信支付10元]
2026-04-26 19:22:44>>>MQTT票号同步场景，创建空订单对象
2026-04-26 19:22:44>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 19:22:45 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261922355891585101","queue_number":127,"trade_uid":"2604261922350056846386"}]}
2026-04-26 19:22:45 >>>故障排除日志:删除未同步下发订单成功2604261922350056846386
2026-04-26 19:22:46 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877983]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:22:59 >>>回调事件[910,devices/S3275]
2026-04-26 19:22:59 >>>故障排除日志:上一MQTT订单号缓存列表为2604261922350056846386
2026-04-26 19:22:59 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 19:22:59 开始打印,排队:128,票券:2604261922522848134501,订单:2604261922520026403536,[2026-04-26 19:22:58微信支付10元]
2026-04-26 19:22:59>>>MQTT票号同步场景，创建空订单对象
2026-04-26 19:22:59>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 19:23:01 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261922522848134501","queue_number":128,"trade_uid":"2604261922520026403536"}]}
2026-04-26 19:23:01 >>>故障排除日志:删除未同步下发订单成功2604261922520026403536
2026-04-26 19:23:01 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877991]


===19:41:31===
2026-04-26 19:41:28>>>cash read=0A


===19:42:31===
2026-04-26 19:41:30>>>cash read=3E


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


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


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


===20:03:32===
2026-04-26 20:02:57>>>cash read=00
2026-04-26 20:02:58>>>cash read=818F42
2026-04-26 20:02:58>>>cash write=02
2026-04-26 20:02:58 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 20:02:58>>>cash read=10
2026-04-26 20:02:58 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 20:02:59 当前产品价格10元，投币10元，打印小票中...
2026-04-26 20:02:59 >>>开始打印,排队号为133,订单号为2604262002590023275850
2026-04-26 20:02:59>>>订单2604262002590023275850写入成功,剩余空间为1679500,占用RAM为636.240234375
删除未同步订单2604262002590023275850
2026-04-26 20:03:01>>>订单2604262002590023275850删除成功,剩余空间为1680500,占用RAM为644.861328125
检测订单目录中>>>
无未同步订单>>>
2026-04-26 20:03:01 >>>当前Ram内存为618.2041015625
定时检测未同步订单启用[checkOrderNum=536878393]
2026-04-26 20:03:02>>>cash write=0C
2026-04-26 20:03:02>>>cash read=3E
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 20:03:14 >>>回调事件[910,devices/S3275]
2026-04-26 20:03:14 >>>故障排除日志:上一MQTT订单号缓存列表为2604261950240096065021
2026-04-26 20:03:14 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 20:03:14 开始打印,排队:134,票券:2604262003063826175401,订单:2604262003060036460275,[2026-04-26 20:03:14微信支付10元]
2026-04-26 20:03:14>>>MQTT票号同步场景，创建空订单对象
2026-04-26 20:03:14>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 20:03:16 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604262003063826175401","queue_number":134,"trade_uid":"2604262003060036460275"}]}
2026-04-26 20:03:16 >>>故障排除日志:删除未同步下发订单成功2604262003060036460275
2026-04-26 20:03:16 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878406]


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


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


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


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


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


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


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


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


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


===20:46:37===
2026-04-26 20:45:51>>>cash read=0A
2026-04-26 20:45:52>>>cash read=3E


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


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