TLClient_JSSCOM_LuatOS-Air_V4010_RDA8910_RFTTS_0xe0000,2.8.6,863482065010916,98767387109236,
poweron reason:0

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

请求下发消息结果为0,Message sent successfully
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 09:11:46 >>>回调事件[910,devices/S3291]
当日首次设置时间戳true为1777165906
2026-04-26 09:11:46 >>>故障排除日志:上一MQTT订单号缓存列表为2604252106140019672564
2026-04-26 09:11:46 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 09:11:46 开始打印,排队:1,票券:2604260902578070391901,订单:2604260902570077867582,[2026-04-26 09:03:04微信支付10元]
2026-04-26 09:11:46>>>MQTT票号同步场景，创建空订单对象
2026-04-26 09:11:46>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 09:11:48 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604260902578070391901","queue_number":1,"trade_uid":"2604260902570077867582"}]}
2026-04-26 09:11:48 >>>故障排除日志:删除未同步下发订单成功2604260902570077867582
2026-04-26 09:11:48 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536870985]
流量卡还有369天过期
2026-04-26 09:11:49>>>cash write=0C
2026-04-26 09:11:49>>>cash read=3E
2026-04-26 09:11:55 >>>当前Ram内存为660.15234375


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


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


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


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


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


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


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


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


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


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


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


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


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


===10:29:49===
2026-04-26 10:29:10>>>cash read=00
2026-04-26 10:29:12>>>cash read=292F29
2026-04-26 10:29:12 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 10:29:13>>>cash read=01
2026-04-26 10:29:13>>>cash read=2F
2026-04-26 10:29:14>>>cash read=3E
2026-04-26 10:29:18>>>cash read=00
2026-04-26 10:29:19>>>cash read=00818F42
2026-04-26 10:29:19>>>cash write=02
2026-04-26 10:29:19 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 10:29:19>>>cash read=10
2026-04-26 10:29:19 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 10:29:19 当前产品价格10元，投币10元，打印小票中...
2026-04-26 10:29:19 >>>开始打印,排队号为16,订单号为2604261029190023291767
2026-04-26 10:29:20>>>订单2604261029190023291767写入成功,剩余空间为1679500,占用RAM为634.8720703125
删除未同步订单2604261029190023291767
2026-04-26 10:29:22>>>订单2604261029190023291767删除成功,剩余空间为1680500,占用RAM为643.99609375
检测订单目录中>>>
无未同步订单>>>
2026-04-26 10:29:22 >>>当前Ram内存为616.9716796875
定时检测未同步订单启用[checkOrderNum=536871799]
2026-04-26 10:29:23>>>cash read=818F42
2026-04-26 10:29:23 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 10:29:23>>>cash read=10
2026-04-26 10:29:23 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 10:29:23 当前产品价格10元，投币10元，打印小票中...
2026-04-26 10:29:24 >>>开始打印,排队号为17,订单号为2604261029240023291078
2026-04-26 10:29:24>>>订单2604261029240023291078写入成功,剩余空间为1678500,占用RAM为642.677734375
删除未同步订单2604261029240023291078
2026-04-26 10:29:26>>>订单2604261029240023291078删除成功,剩余空间为1679500,占用RAM为648.8974609375
检测订单目录中>>>
无未同步订单>>>
2026-04-26 10:29:26 >>>当前Ram内存为618.4140625
定时检测未同步订单启用[checkOrderNum=536871806]
2026-04-26 10:29:27>>>cash write=0C
2026-04-26 10:29:27>>>cash read=3E


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


===13:11:21===
上一时间戳为1777165906
当日首次设置时间戳true为1777180220
今日nvm排队号为39
当前排队号为39,音量为5
初始化产品信息:[{"time_limit_date":null,"ticket_category":"0","expiry_date":1,"product_detail":"","time_limit_status":"0","begin_minute":null,"product_uid":"12566542176648939824","use_timer":1,"old_price":"10","end_hour":null,"sale_price":"10","end_minute":null,"begin_hour":null,"sale_status":1,"product_name":"剪发"}]
是否打印二维码设置为1
是否打印紧凑设置为3
当前号显示模式设置为1
当前卡项核销权限设置为0
session_id:d1b91****2c7f1
纸币器设置接收纸币范围为36
欢迎使用天羚自助售票系统[2.8.6]
定时检测未同步订单启用[checkOrderNum=536870969]
2026-04-26 13:10:20>>>cash write=30
2026-04-26 13:10:20>>>cash write=02
2026-04-26 13:10:20>>>cash write=3E
2026-04-26 13:10:20>>>cash read=808F808F
系统时间初始化成功，时间为2026426131020
2026-04-26 13:10:21>>>cash write=02
2026-04-26 13:10:21 >>>剩余flash空间=1680000,占用RAM为658.794921875
2026-04-26 13:10:21 >>>回调事件:910,subscribe,10000,连接服务器成功

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

2026-04-26 13:10:24>>>cash write=0C
2026-04-26 13:10:24>>>cash read=3E
流量卡还有369天过期
2026-04-26 13:10:31 >>>当前Ram内存为664.841796875


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


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


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


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


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


===14:08:22===
2026-04-26 14:07:38>>>cash read=00
2026-04-26 14:07:38>>>cash read=818F42
2026-04-26 14:07:38>>>cash write=02
2026-04-26 14:07:38 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 14:07:39>>>cash read=10
2026-04-26 14:07:39 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 14:07:39 当前产品价格10元，投币10元，打印小票中...
2026-04-26 14:07:39 >>>开始打印,排队号为44,订单号为2604261407390023291132
2026-04-26 14:07:39>>>订单2604261407390023291132写入成功,剩余空间为1679500,占用RAM为633.6806640625
删除未同步订单2604261407390023291132
2026-04-26 14:07:41>>>订单2604261407390023291132删除成功,剩余空间为1680500,占用RAM为643.78515625
检测订单目录中>>>
无未同步订单>>>
2026-04-26 14:07:41 >>>当前Ram内存为617.2109375
定时检测未同步订单启用[checkOrderNum=536871544]
2026-04-26 14:07:42>>>cash read=818F42
2026-04-26 14:07:42 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 14:07:42>>>cash read=10
2026-04-26 14:07:42 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 14:07:42 当前产品价格10元，投币10元，打印小票中...
2026-04-26 14:07:42 >>>开始打印,排队号为45,订单号为2604261407420023291048
2026-04-26 14:07:43>>>订单2604261407420023291048写入成功,剩余空间为1679000,占用RAM为639.638671875
删除未同步订单2604261407420023291048
2026-04-26 14:07:45>>>订单2604261407420023291048删除成功,剩余空间为1679500,占用RAM为648.3115234375
检测订单目录中>>>
无未同步订单>>>
2026-04-26 14:07:45 >>>当前Ram内存为618.666015625
定时检测未同步订单启用[checkOrderNum=536871551]
2026-04-26 14:07:46>>>cash write=0C
2026-04-26 14:07:46>>>cash read=3E


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


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


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


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


===14:27:24===
2026-04-26 14:26:23>>>cash write=0C
2026-04-26 14:26:23>>>cash read=3E


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


===14:32:25===
2026-04-26 14:31:24 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261431174838242701","queue_number":50,"trade_uid":"2604261431170046411314"}]}
2026-04-26 14:31:24 >>>故障排除日志:删除未同步下发订单成功2604261431170046411314
2026-04-26 14:31:24 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536871812]


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


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


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


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


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


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


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


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


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


===15:44:28===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 15:43:34 >>>回调事件[910,devices/S3291]
2026-04-26 15:43:34 >>>故障排除日志:上一MQTT订单号缓存列表为2604261539150063550813
2026-04-26 15:43:34 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 15:43:34 开始打印,排队:63,票券:2604261543266784046701,订单:2604261543260065903328,[2026-04-26 15:43:34微信支付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":"2604261543266784046701","queue_number":63,"trade_uid":"2604261543260065903328"}]}
2026-04-26 15:43:36 >>>故障排除日志:删除未同步下发订单成功2604261543260065903328
2026-04-26 15:43:36 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536872547]


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


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


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


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


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


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


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


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


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


===16:35:30===
2026-04-26 16:34:42>>>cash read=29
2026-04-26 16:34:42 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 16:34:43>>>cash read=3E
2026-04-26 16:34:46>>>cash read=00
2026-04-26 16:34:47>>>cash read=818F42
2026-04-26 16:34:47>>>cash write=02
2026-04-26 16:34:47 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 16:34:48>>>cash read=10
2026-04-26 16:34:48 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 16:34:48 当前产品价格10元，投币10元，打印小票中...
2026-04-26 16:34:48 >>>开始打印,排队号为74,订单号为2604261634480023291755
2026-04-26 16:34:48>>>订单2604261634480023291755写入成功,剩余空间为1679500,占用RAM为637.0322265625
删除未同步订单2604261634480023291755
2026-04-26 16:34:50>>>订单2604261634480023291755删除成功,剩余空间为1680500,占用RAM为645.671875
检测订单目录中>>>
无未同步订单>>>
2026-04-26 16:34:50 >>>当前Ram内存为618.8193359375
定时检测未同步订单启用[checkOrderNum=536873088]
2026-04-26 16:34:51>>>cash write=0C
2026-04-26 16:34:51>>>cash read=3E


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


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


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


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


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


===17:23:32===
2026-04-26 17:22:46>>>cash read=29
2026-04-26 17:22:46 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 17:22:47>>>cash read=01
2026-04-26 17:22:48>>>cash read=3E
2026-04-26 17:23:02>>>cash read=00
2026-04-26 17:23:03>>>cash read=01
2026-04-26 17:23:04>>>cash read=3E
2026-04-26 17:23:08>>>cash read=00
2026-04-26 17:23:09>>>cash read=2F29
2026-04-26 17:23:10>>>cash read=3E
2026-04-26 17:23:10>>>cash read=2F
2026-04-26 17:23:12>>>cash read=3E
2026-04-26 17:23:17>>>cash read=00
2026-04-26 17:23:18>>>cash read=818F42
2026-04-26 17:23:18>>>cash write=02
2026-04-26 17:23:18 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 17:23:18>>>cash read=10
2026-04-26 17:23:18 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 17:23:18 当前产品价格10元，投币10元，打印小票中...
2026-04-26 17:23:18 >>>开始打印,排队号为81,订单号为2604261723180023291304
2026-04-26 17:23:19>>>订单2604261723180023291304写入成功,剩余空间为1679000,占用RAM为637.849609375
删除未同步订单2604261723180023291304
2026-04-26 17:23:21>>>订单2604261723180023291304删除成功,剩余空间为1680000,占用RAM为651.2021484375
检测订单目录中>>>
无未同步订单>>>
2026-04-26 17:23:21 >>>当前Ram内存为617.9345703125
定时检测未同步订单启用[checkOrderNum=536873584]
2026-04-26 17:23:22>>>cash write=0C
2026-04-26 17:23:22>>>cash read=3E


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


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


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


===17:43:26===
上一时间戳为1777180220
当日首次设置时间戳true为1777196545
今日nvm排队号为86
当前排队号为86,音量为5
初始化产品信息:[{"time_limit_date":null,"ticket_category":"0","expiry_date":1,"product_detail":"","time_limit_status":"0","begin_minute":null,"product_uid":"12566542176648939824","use_timer":1,"old_price":"10","end_hour":null,"sale_price":"10","end_minute":null,"begin_hour":null,"sale_status":1,"product_name":"剪发"}]
是否打印二维码设置为1
是否打印紧凑设置为3
当前号显示模式设置为1
当前卡项核销权限设置为0
session_id:60af6****53b16
纸币器设置接收纸币范围为36
欢迎使用天羚自助售票系统[2.8.6]
定时检测未同步订单启用[checkOrderNum=536870969]
2026-04-26 17:42:25>>>cash write=30
2026-04-26 17:42:25>>>cash write=02
2026-04-26 17:42:25>>>cash write=3E
2026-04-26 17:42:25>>>cash read=808F808F
系统时间初始化成功，时间为2026426174225
2026-04-26 17:42:26>>>cash write=02
2026-04-26 17:42:26 >>>剩余flash空间=1680000,占用RAM为656.9677734375
2026-04-26 17:42:26 >>>回调事件:910,subscribe,10000,连接服务器成功

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

2026-04-26 17:42:29>>>cash write=0C
2026-04-26 17:42:29>>>cash read=3E
流量卡还有369天过期
2026-04-26 17:42:36 >>>当前Ram内存为665.212890625


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


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


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


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


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


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


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


===18:22:30===
2026-04-26 18:21:54>>>cash read=00
2026-04-26 18:21:54>>>cash read=2F29
2026-04-26 18:21:56>>>cash read=01
2026-04-26 18:21:56>>>cash read=2F
2026-04-26 18:21:57>>>cash read=3E
2026-04-26 18:22:09>>>cash read=00
2026-04-26 18:22:10>>>cash read=818F42
2026-04-26 18:22:10>>>cash write=02
2026-04-26 18:22:10 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 18:22:11>>>cash read=10
2026-04-26 18:22:11 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 18:22:11 当前产品价格10元，投币10元，打印小票中...
2026-04-26 18:22:11 >>>开始打印,排队号为94,订单号为2604261822110023291494
2026-04-26 18:22:11>>>订单2604261822110023291494写入成功,剩余空间为1679500,占用RAM为634.794921875
删除未同步订单2604261822110023291494
2026-04-26 18:22:13>>>订单2604261822110023291494删除成功,剩余空间为1680500,占用RAM为644.2041015625
检测订单目录中>>>
无未同步订单>>>
2026-04-26 18:22:13 >>>当前Ram内存为617.3232421875
定时检测未同步订单启用[checkOrderNum=536871403]
2026-04-26 18:22:14>>>cash write=0C
2026-04-26 18:22:14>>>cash read=3E


===18:33:36===
上一时间戳为1777196545
当日首次设置时间戳true为1777199555
今日nvm排队号为95
当前排队号为95,音量为5
初始化产品信息:[{"time_limit_date":null,"ticket_category":"0","expiry_date":1,"product_detail":"","time_limit_status":"0","begin_minute":null,"product_uid":"12566542176648939824","use_timer":1,"old_price":"10","end_hour":null,"sale_price":"10","end_minute":null,"begin_hour":null,"sale_status":1,"product_name":"剪发"}]
是否打印二维码设置为1
是否打印紧凑设置为3
当前号显示模式设置为1
当前卡项核销权限设置为0
session_id:9dd9f****f659c
纸币器设置接收纸币范围为36
欢迎使用天羚自助售票系统[2.8.6]
定时检测未同步订单启用[checkOrderNum=536870969]
2026-04-26 18:32:36>>>cash write=30
2026-04-26 18:32:36>>>cash write=02
2026-04-26 18:32:36>>>cash write=3E
2026-04-26 18:32:36>>>cash read=808F808F
系统时间初始化成功，时间为2026426183236
2026-04-26 18:32:37>>>cash write=02
2026-04-26 18:32:37 >>>剩余flash空间=1680000,占用RAM为656.9736328125
2026-04-26 18:32:37 >>>回调事件:910,subscribe,10000,连接服务器成功

请求下发消息结果为0,Message sent successfully
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 18:32:38 >>>回调事件[910,devices/S3291]
2026-04-26 18:32:38 >>>故障排除日志:上一MQTT订单号缓存列表为2604261820180072551319
2026-04-26 18:32:38 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 18:32:38 开始打印,排队:95,票券:2604261832077224855201,订单:2604261832070070132374,[2026-04-26 18:32:12微信支付10元]
2026-04-26 18:32:38>>>MQTT票号同步场景，创建空订单对象
2026-04-26 18:32:38>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 18:32:40 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261832077224855201","queue_number":95,"trade_uid":"2604261832070070132374"}]}
2026-04-26 18:32:40 >>>故障排除日志:删除未同步下发订单成功2604261832070070132374
2026-04-26 18:32:40 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536870985]
流量卡还有369天过期
2026-04-26 18:32:41>>>cash write=0C
2026-04-26 18:32:41>>>cash read=3E
2026-04-26 18:32:47 >>>当前Ram内存为669.1318359375
2026-04-26 18:33:29>>>cash read=00
2026-04-26 18:33:29>>>cash read=818F42
2026-04-26 18:33:29>>>cash write=02
2026-04-26 18:33:29 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 18:33:30>>>cash read=10
2026-04-26 18:33:30 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 18:33:30 当前产品价格10元，投币10元，打印小票中...
2026-04-26 18:33:30 >>>开始打印,排队号为96,订单号为2604261833300023291671
2026-04-26 18:33:30>>>订单2604261833300023291671写入成功,剩余空间为1677500,占用RAM为646.7197265625
删除未同步订单2604261833300023291671
2026-04-26 18:33:32>>>订单2604261833300023291671删除成功,剩余空间为1678000,占用RAM为650.40625
检测订单目录中>>>
无未同步订单>>>
2026-04-26 18:33:32 >>>当前Ram内存为618.7841796875
定时检测未同步订单启用[checkOrderNum=536871004]
2026-04-26 18:33:33>>>cash write=0C
2026-04-26 18:33:34>>>cash read=3E


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


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


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


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


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


===18:51:38===
2026-04-26 18:50:37>>>cash write=0C
2026-04-26 18:50:37>>>cash read=3E


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


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


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


===19:06:39===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:05:57 >>>回调事件[910,devices/S3291]
2026-04-26 19:05:57 >>>故障排除日志:上一MQTT订单号缓存列表为2604261900160006102229
2026-04-26 19:05:57 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 19:05:57 开始打印,排队:105,票券:2604261905471261105901,订单:2604261905470010241051,[2026-04-26 19:05:56支付宝支付10元]
2026-04-26 19:05:57>>>MQTT票号同步场景，创建空订单对象
2026-04-26 19:05:57>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 19:05:59 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261905471261105901","queue_number":105,"trade_uid":"2604261905470010241051"}]}
2026-04-26 19:05:59 >>>故障排除日志:删除未同步下发订单成功2604261905470010241051
2026-04-26 19:05:59 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536871393]
2026-04-26 19:06:20>>>cash read=00
2026-04-26 19:06:21>>>cash read=29
2026-04-26 19:06:21 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 19:06:21>>>cash read=2F29
2026-04-26 19:06:23>>>cash read=3E


===19:07:39===
2026-04-26 19:06:49>>>cash read=00
2026-04-26 19:06:49>>>cash read=818F42
2026-04-26 19:06:49>>>cash write=02
2026-04-26 19:06:49 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 19:06:49>>>cash read=10
2026-04-26 19:06:49 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:06:50 当前产品价格10元，投币10元，打印小票中...
2026-04-26 19:06:50 >>>开始打印,排队号为106,订单号为2604261906500023291760
2026-04-26 19:06:50>>>订单2604261906500023291760写入成功,剩余空间为1679500,占用RAM为634.818359375
删除未同步订单2604261906500023291760
2026-04-26 19:06:52>>>订单2604261906500023291760删除成功,剩余空间为1680500,占用RAM为644.03125
检测订单目录中>>>
无未同步订单>>>
2026-04-26 19:06:52 >>>当前Ram内存为617.4345703125
定时检测未同步订单启用[checkOrderNum=536871411]
2026-04-26 19:06:53>>>cash write=0C
2026-04-26 19:06:53>>>cash read=3E
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:07:08 >>>回调事件[910,devices/S3291]
2026-04-26 19:07:08 >>>故障排除日志:上一MQTT订单号缓存列表为2604261905470010241051
2026-04-26 19:07:08 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 19:07:08 开始打印,排队:107,票券:2604261906581285439701,订单:2604261906580010526759,[2026-04-26 19:07:06微信支付10元]
2026-04-26 19:07:08>>>MQTT票号同步场景，创建空订单对象
2026-04-26 19:07:08>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 19:07:10 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261906581285439701","queue_number":107,"trade_uid":"2604261906580010526759"}]}
2026-04-26 19:07:10 >>>故障排除日志:删除未同步下发订单成功2604261906580010526759
2026-04-26 19:07:10 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536871419]


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


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


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


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


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


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


===19:28:43===
2026-04-26 19:28:37>>>cash read=00
2026-04-26 19:28:39>>>cash read=818F42
2026-04-26 19:28:39>>>cash write=02
2026-04-26 19:28:39 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 19:28:39>>>cash read=10
2026-04-26 19:28:39 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:28:39 当前产品价格10元，投币10元，打印小票中...
2026-04-26 19:28:39 >>>开始打印,排队号为114,订单号为2604261928390023291710
2026-04-26 19:28:40>>>订单2604261928390023291710写入成功,剩余空间为1679500,占用RAM为635.076171875


===19:29:43===
删除未同步订单2604261928390023291710
2026-04-26 19:28:42>>>订单2604261928390023291710删除成功,剩余空间为1681500,占用RAM为649.0185546875
检测订单目录中>>>
无未同步订单>>>
2026-04-26 19:28:42 >>>当前Ram内存为616.9111328125
定时检测未同步订单启用[checkOrderNum=536871673]
2026-04-26 19:28:43>>>cash write=0C
2026-04-26 19:28:43>>>cash read=3E


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


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


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


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


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


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


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


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


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