TLClient_JSSCOM_LuatOS-Air_V4010_RDA8910_RFTTS_0xe0000,2.8.6,863013071869480,13111022001703,
poweron reason:0

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

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

2026-04-26 08:17:07>>>cash write=0C
流量卡还有217天过期
2026-04-26 08:17:14 >>>当前Ram内存为666.3251953125
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 08:17:28 >>>回调事件[910,devices/TL4861]
当日首次设置时间戳true为1777162648
2026-04-26 08:17:28 >>>故障排除日志:上一MQTT订单号缓存列表为2604252119170071533672|2604252119170071533672
2026-04-26 08:17:28 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 08:17:28 开始打印,排队:1,票券:2604260817182042561401,订单:2604260817180017585152,[2026-04-26 08:17:26微信支付12元]
2026-04-26 08:17:28>>>MQTT票号同步场景，创建空订单对象
2026-04-26 08:17:28>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 08:17:30 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604260817182042561401","queue_number":1,"trade_uid":"2604260817180017585152"}]}
2026-04-26 08:17:30 >>>故障排除日志:删除未同步下发订单成功2604260817180017585152
2026-04-26 08:17:30 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536870993]


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


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


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


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


===08:53:06===
2026-04-26 08:52:26>>>cash read=00
2026-04-26 08:52:27>>>cash read=818F42
2026-04-26 08:52:27>>>cash write=02
2026-04-26 08:52:27 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 08:52:27>>>cash read=10
2026-04-26 08:52:27 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 08:52:28>>>cash write=0C
2026-04-26 08:52:29>>>cash read=00
2026-04-26 08:52:29>>>cash read=818F40
2026-04-26 08:52:29>>>cash write=02
2026-04-26 08:52:29 >>>回调事件130,cash_status,10022,进钞中...read money=1
2026-04-26 08:52:30>>>cash write=0C
2026-04-26 08:52:30>>>cash read=00
2026-04-26 08:52:30>>>cash read=10
2026-04-26 08:52:30 >>>回调事件130,1,10023,finish Money=1,进钞完成
2026-04-26 08:52:31>>>cash read=00
2026-04-26 08:52:31>>>cash read=818F40
2026-04-26 08:52:31>>>cash write=02
2026-04-26 08:52:31 >>>回调事件130,cash_status,10022,进钞中...read money=1
2026-04-26 08:52:32>>>cash read=10
2026-04-26 08:52:32 >>>回调事件130,1,10023,finish Money=1,进钞完成
2026-04-26 08:52:32 当前产品价格12元，投币12元，打印小票中...
2026-04-26 08:52:32 >>>开始打印,排队号为6,订单号为2604260852300014861447
2026-04-26 08:52:32>>>订单2604260852300014861447写入成功,剩余空间为1679000,占用RAM为638.0654296875
删除未同步订单2604260852300014861447
2026-04-26 08:52:34>>>订单2604260852300014861447删除成功,剩余空间为1680000,占用RAM为651.859375
检测订单目录中>>>
无未同步订单>>>
2026-04-26 08:52:34 >>>当前Ram内存为618.8583984375
定时检测未同步订单启用[checkOrderNum=536871493]
2026-04-26 08:52:35>>>cash write=0C
2026-04-26 08:52:35>>>cash read=3E


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


===09:00:07===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 08:59:32 >>>回调事件[910,devices/TL4861]
2026-04-26 08:59:32 >>>故障排除日志:上一MQTT订单号缓存列表为2604260854580056293634
2026-04-26 08:59:32 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 08:59:32 开始打印,排队:8,票券:2604260859228300003401,订单:2604260859220081123978,[2026-04-26 08:59:32支付宝支付12元]
2026-04-26 08:59:33>>>MQTT票号同步场景，创建空订单对象
2026-04-26 08:59:33>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 08:59:34 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604260859228300003401","queue_number":8,"trade_uid":"2604260859220081123978"}]}
2026-04-26 08:59:35 >>>故障排除日志:删除未同步下发订单成功2604260859220081123978
2026-04-26 08:59:35 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536871676]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 08:59:53 >>>回调事件[910,devices/TL4861]
2026-04-26 08:59:53 >>>故障排除日志:上一MQTT订单号缓存列表为2604260859220081123978
2026-04-26 08:59:53 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 08:59:53 开始打印,排队:9,票券:2604260859448672923701,订单:2604260859440084639463,[2026-04-26 08:59:53微信支付12元]
2026-04-26 08:59:53>>>MQTT票号同步场景，创建空订单对象
2026-04-26 08:59:53>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 08:59:55 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604260859448672923701","queue_number":9,"trade_uid":"2604260859440084639463"}]}
2026-04-26 08:59:55 >>>故障排除日志:删除未同步下发订单成功2604260859440084639463
2026-04-26 08:59:55 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536871695]


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


===12:31:17===
2026-04-26 12:30:16 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261230059527705701","queue_number":37,"trade_uid":"2604261230050092882519"}]}
2026-04-26 12:30:16 >>>故障排除日志:删除未同步下发订单成功2604261230050092882519
2026-04-26 12:30:16 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536875818]


===12:52:18===
2026-04-26 12:51:52>>>cash read=00
2026-04-26 12:51:52>>>cash read=818F42
2026-04-26 12:51:52>>>cash write=02
2026-04-26 12:51:52 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 12:51:53>>>cash read=10
2026-04-26 12:51:53 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 12:51:54>>>cash write=0C
2026-04-26 12:51:54>>>cash read=3E
2026-04-26 12:51:55>>>cash read=00
2026-04-26 12:51:55>>>cash read=818F40
2026-04-26 12:51:55>>>cash write=02
2026-04-26 12:51:55 >>>回调事件130,cash_status,10022,进钞中...read money=1
2026-04-26 12:51:56>>>cash read=10
2026-04-26 12:51:56 >>>回调事件130,1,10023,finish Money=1,进钞完成
2026-04-26 12:51:57>>>cash write=0C
2026-04-26 12:51:57>>>cash read=3E
2026-04-26 12:52:00>>>cash read=00
2026-04-26 12:52:00>>>cash read=818F40
2026-04-26 12:52:00>>>cash write=02
2026-04-26 12:52:00 >>>回调事件130,cash_status,10022,进钞中...read money=1
2026-04-26 12:52:00>>>cash read=10
2026-04-26 12:52:00 >>>回调事件130,1,10023,finish Money=1,进钞完成
2026-04-26 12:52:00 当前产品价格12元，投币12元，打印小票中...
2026-04-26 12:52:00 >>>开始打印,排队号为38,订单号为2604261251560014861666
2026-04-26 12:52:01>>>订单2604261251560014861666写入成功,剩余空间为1679000,占用RAM为637.7548828125
删除未同步订单2604261251560014861666
2026-04-26 12:52:03>>>订单2604261251560014861666删除成功,剩余空间为1680000,占用RAM为657.6953125
检测订单目录中>>>
无未同步订单>>>
2026-04-26 12:52:03 >>>当前Ram内存为618.39453125
定时检测未同步订单启用[checkOrderNum=536876273]
2026-04-26 12:52:04>>>cash write=0C
2026-04-26 12:52:04>>>cash read=3E


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


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


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


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


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


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


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


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


===13:52:23===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 13:52:18 >>>回调事件[910,devices/TL4861]
2026-04-26 13:52:18 >>>故障排除日志:上一MQTT订单号缓存列表为2604261339130072374242
2026-04-26 13:52:18 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 13:52:18 开始打印,排队:48,票券:2604261352112476537401,订单:2604261352110022792551,[2026-04-26 13:52:17微信支付12元]
2026-04-26 13:52:18>>>MQTT票号同步场景，创建空订单对象
2026-04-26 13:52:18>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 13:52:20 >>>回调事件[910,devices/TL4861]
2026-04-26 13:52:20 >>>故障排除日志:上一MQTT订单号缓存列表为2604261352110022792551
2026-04-26 13:52:20 >>>故障排除日志:终端未同步成功订单列表00482604261352110022792551
2026-04-26 13:52:20 开始打印,排队:49,票券:2604261352099058069501,订单:2604261352090088438415,[2026-04-26 13:52:18微信支付12元]
已接收过此消息,票券号为2604261352112476537401,排队号为48
2026-04-26 13:52:20>>>HTTP请求进行中，跳过本次同步


===13:53:23===
2026-04-26 13:52:22 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261352112476537401","queue_number":48,"trade_uid":"2604261352110022792551"}]}
2026-04-26 13:52:22 >>>故障排除日志:删除未同步下发订单成功2604261352110022792551
2026-04-26 13:52:22 >>>故障排除日志:终端同步成功后剩余订单列表00492604261352090088438415
定时检测未同步订单启用[checkOrderNum=536877235]


===13:56:24===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 13:55:54 >>>回调事件[910,devices/TL4861]
2026-04-26 13:55:54 >>>故障排除日志:上一MQTT订单号缓存列表为2604261352090088438415|2604261352110022792551
2026-04-26 13:55:54 >>>故障排除日志:终端未同步成功订单列表00492604261352090088438415
已接收过此消息,票券号为2604261352099058069501,排队号为49
2026-04-26 13:55:54 开始打印,排队:50,票券:2604261355468845258301,订单:2604261355460086499193,[2026-04-26 13:55:53微信支付12元]
2026-04-26 13:55:54>>>MQTT票号同步场景，创建空订单对象
2026-04-26 13:55:54>>>合并MQTT票号列表到订单同步请求,共2张票
2026-04-26 13:55:56 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261352099058069501","queue_number":49,"trade_uid":"2604261352090088438415"},{"ticket_no":"2604261355468845258301","queue_number":50,"trade_uid":"2604261355460086499193"}]}
2026-04-26 13:55:56 >>>故障排除日志:删除未同步下发订单成功2604261352090088438415
2026-04-26 13:55:56 >>>故障排除日志:删除未同步下发订单成功2604261355460086499193
2026-04-26 13:55:56 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877315]


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


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


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


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


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


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


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


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


===14:44:29===
2026-04-26 14:43:27 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261443199534391701","queue_number":59,"trade_uid":"2604261443190093533881"}]}
2026-04-26 14:43:27 >>>故障排除日志:删除未同步下发订单成功2604261443190093533881
2026-04-26 14:43:28 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877941]


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


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


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


===15:10:31===
2026-04-26 15:10:24>>>cash read=00
2026-04-26 15:10:25>>>cash read=818F42
2026-04-26 15:10:25>>>cash write=02
2026-04-26 15:10:25 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 15:10:25>>>cash read=10
2026-04-26 15:10:25 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 15:10:26>>>cash write=0C
2026-04-26 15:10:26>>>cash read=3E
2026-04-26 15:10:28>>>cash read=2F29


===15:11:31===
2026-04-26 15:10:29>>>cash read=00
2026-04-26 15:10:31>>>cash read=29
2026-04-26 15:10:31 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 15:10:31>>>cash read=2F29
2026-04-26 15:10:33>>>cash read=3E
2026-04-26 15:10:37>>>cash read=2F29
2026-04-26 15:10:38>>>cash read=01
2026-04-26 15:10:42>>>cash read=2F
2026-04-26 15:10:43>>>cash read=3E
2026-04-26 15:10:46>>>cash read=818F40
2026-04-26 15:10:46>>>cash write=02
2026-04-26 15:10:46 >>>回调事件130,cash_status,10022,进钞中...read money=1
2026-04-26 15:10:46>>>cash read=10
2026-04-26 15:10:46 >>>回调事件130,1,10023,finish Money=1,进钞完成
2026-04-26 15:10:47>>>cash write=0C
2026-04-26 15:10:47>>>cash read=3E
2026-04-26 15:10:50>>>cash read=00
2026-04-26 15:10:50>>>cash read=818F40
2026-04-26 15:10:50>>>cash write=02
2026-04-26 15:10:50 >>>回调事件130,cash_status,10022,进钞中...read money=1
2026-04-26 15:10:51>>>cash read=10
2026-04-26 15:10:51 >>>回调事件130,1,10023,finish Money=1,进钞完成
2026-04-26 15:10:51 当前产品价格12元，投币12元，打印小票中...
2026-04-26 15:10:51 >>>开始打印,排队号为65,订单号为2604261510460014861546
2026-04-26 15:10:51>>>订单2604261510460014861546写入成功,剩余空间为1679000,占用RAM为638.4873046875
删除未同步订单2604261510460014861546
2026-04-26 15:10:53>>>订单2604261510460014861546删除成功,剩余空间为1680000,占用RAM为648.87890625
检测订单目录中>>>
无未同步订单>>>
2026-04-26 15:10:53 >>>当前Ram内存为617.2216796875
定时检测未同步订单启用[checkOrderNum=536878533]
2026-04-26 15:10:54>>>cash write=0C
2026-04-26 15:10:54>>>cash read=3E


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


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


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


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


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


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


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


===15:45:34===
2026-04-26 15:45:22>>>cash read=00
2026-04-26 15:45:23>>>cash read=818F42
2026-04-26 15:45:23>>>cash write=02
2026-04-26 15:45:23 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 15:45:24>>>cash write=0C
2026-04-26 15:45:24>>>cash read=00
2026-04-26 15:45:24>>>cash read=10
2026-04-26 15:45:24 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 15:45:25>>>cash read=3E
2026-04-26 15:45:27>>>cash read=00
2026-04-26 15:45:27>>>cash read=818F40
2026-04-26 15:45:27>>>cash write=02
2026-04-26 15:45:27 >>>回调事件130,cash_status,10022,进钞中...read money=1
2026-04-26 15:45:28>>>cash write=0C
2026-04-26 15:45:28>>>cash read=00
2026-04-26 15:45:28>>>cash read=10
2026-04-26 15:45:28 >>>回调事件130,1,10023,finish Money=1,进钞完成
2026-04-26 15:45:29>>>cash read=00
2026-04-26 15:45:29>>>cash read=818F40
2026-04-26 15:45:29>>>cash write=02
2026-04-26 15:45:29 >>>回调事件130,cash_status,10022,进钞中...read money=1
2026-04-26 15:45:30>>>cash read=10
2026-04-26 15:45:30 >>>回调事件130,1,10023,finish Money=1,进钞完成
2026-04-26 15:45:30 当前产品价格12元，投币12元，打印小票中...
2026-04-26 15:45:30 >>>开始打印,排队号为73,订单号为2604261545280014861598
2026-04-26 15:45:30>>>订单2604261545280014861598写入成功,剩余空间为1679000,占用RAM为637.9990234375


===15:46:34===
2026-04-26 15:45:33>>>cash write=0C
2026-04-26 15:45:33>>>cash read=3E
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 15:45:56 >>>回调事件[910,devices/TL4861]
2026-04-26 15:45:56 >>>故障排除日志:上一MQTT订单号缓存列表为2604261541390040871317
2026-04-26 15:45:56 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 15:45:56 开始打印,排队:74,票券:2604261545507801236701,订单:2604261545500076085064,[2026-04-26 15:45:56微信支付12元]
2026-04-26 15:45:56>>>MQTT票号同步场景，创建空订单对象
2026-04-26 15:45:56>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 15:45:59 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261545507801236701","queue_number":74,"trade_uid":"2604261545500076085064"}]}
2026-04-26 15:45:59 >>>故障排除日志:删除未同步下发订单成功2604261545500076085064
2026-04-26 15:45:59 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536879198]


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


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


===16:04:35===
2026-04-26 16:04:08>>>cash read=00
2026-04-26 16:04:08>>>cash read=818F42
2026-04-26 16:04:08>>>cash write=02
2026-04-26 16:04:08 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 16:04:09>>>cash read=10
2026-04-26 16:04:09 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 16:04:10>>>cash write=0C
2026-04-26 16:04:10>>>cash read=3E
2026-04-26 16:04:12>>>cash read=29
2026-04-26 16:04:12 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 16:04:13>>>cash read=2F29
2026-04-26 16:04:14>>>cash read=01
2026-04-26 16:04:14>>>cash read=2F
2026-04-26 16:04:16>>>cash read=3E
2026-04-26 16:04:20>>>cash read=29
2026-04-26 16:04:20 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 16:04:20>>>cash read=2F29
2026-04-26 16:04:24>>>cash read=3E
2026-04-26 16:04:30>>>cash read=00
2026-04-26 16:04:30>>>cash read=818F40
2026-04-26 16:04:30>>>cash write=02
2026-04-26 16:04:30 >>>回调事件130,cash_status,10022,进钞中...read money=1
2026-04-26 16:04:31>>>cash read=10
2026-04-26 16:04:31 >>>回调事件130,1,10023,finish Money=1,进钞完成
2026-04-26 16:04:32>>>cash write=0C
2026-04-26 16:04:32>>>cash read=3E


===16:05:36===
2026-04-26 16:04:35>>>cash read=00
2026-04-26 16:04:36>>>cash read=818F40
2026-04-26 16:04:36>>>cash write=02
2026-04-26 16:04:36 >>>回调事件130,cash_status,10022,进钞中...read money=1
2026-04-26 16:04:36>>>cash read=10
2026-04-26 16:04:36 >>>回调事件130,1,10023,finish Money=1,进钞完成
2026-04-26 16:04:36 当前产品价格12元，投币12元，打印小票中...
2026-04-26 16:04:36 >>>开始打印,排队号为77,订单号为2604261604310014861850
2026-04-26 16:04:37>>>订单2604261604310014861850写入成功,剩余空间为1680000,占用RAM为631.6806640625
删除未同步订单2604261604310014861850
2026-04-26 16:04:39>>>订单2604261604310014861850删除成功,剩余空间为1680500,占用RAM为646.2275390625
检测订单目录中>>>
无未同步订单>>>
2026-04-26 16:04:39 >>>当前Ram内存为615.6171875
定时检测未同步订单启用[checkOrderNum=536879612]
2026-04-26 16:04:40>>>cash write=0C
2026-04-26 16:04:40>>>cash read=3E
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 16:05:25 >>>回调事件[910,devices/TL4861]
2026-04-26 16:05:25 >>>故障排除日志:上一MQTT订单号缓存列表为2604261555140017717625
2026-04-26 16:05:25 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 16:05:25 开始打印,排队:78,票券:2604261605156774705201,订单:2604261605150065600819,[2026-04-26 16:05:24微信支付12元]
2026-04-26 16:05:25>>>MQTT票号同步场景，创建空订单对象
2026-04-26 16:05:25>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 16:05:27 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261605156774705201","queue_number":78,"trade_uid":"2604261605150065600819"}]}
2026-04-26 16:05:27 >>>故障排除日志:删除未同步下发订单成功2604261605150065600819
2026-04-26 16:05:27 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536879639]


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


===18:04:46===
2026-04-26 18:04:08>>>cash read=818F42
2026-04-26 18:04:08>>>cash write=02
2026-04-26 18:04:08 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 18:04:09>>>cash read=10
2026-04-26 18:04:09 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 18:04:10>>>cash write=0C
2026-04-26 18:04:10>>>cash read=3E
2026-04-26 18:04:13>>>cash read=00
2026-04-26 18:04:14>>>cash read=2F29
2026-04-26 18:04:16>>>cash read=00
2026-04-26 18:04:16>>>cash read=818F40
2026-04-26 18:04:16>>>cash write=02
2026-04-26 18:04:16 >>>回调事件130,cash_status,10022,进钞中...read money=1
2026-04-26 18:04:17>>>cash read=10
2026-04-26 18:04:17 >>>回调事件130,1,10023,finish Money=1,进钞完成
2026-04-26 18:04:18>>>cash write=0C
2026-04-26 18:04:18>>>cash read=3E
2026-04-26 18:04:21>>>cash read=00
2026-04-26 18:04:21>>>cash read=818F40
2026-04-26 18:04:21>>>cash write=02
2026-04-26 18:04:21 >>>回调事件130,cash_status,10022,进钞中...read money=1
2026-04-26 18:04:22>>>cash read=10
2026-04-26 18:04:22 >>>回调事件130,1,10023,finish Money=1,进钞完成
2026-04-26 18:04:22 当前产品价格12元，投币12元，打印小票中...
2026-04-26 18:04:22 >>>开始打印,排队号为106,订单号为2604261804170014861125
2026-04-26 18:04:22>>>订单2604261804170014861125写入成功,剩余空间为1679000,占用RAM为637.572265625
删除未同步订单2604261804170014861125
2026-04-26 18:04:24>>>订单2604261804170014861125删除成功,剩余空间为1679500,占用RAM为648.642578125
检测订单目录中>>>
无未同步订单>>>
2026-04-26 18:04:24 >>>当前Ram内存为616.6953125
定时检测未同步订单启用[checkOrderNum=536881413]
2026-04-26 18:04:25>>>cash write=0C
2026-04-26 18:04:25>>>cash read=3E


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


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


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


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


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


===18:32:48===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 18:32:18 >>>回调事件[910,devices/TL4861]
2026-04-26 18:32:18 >>>故障排除日志:上一MQTT订单号缓存列表为2604261827370045889796
2026-04-26 18:32:18 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 18:32:18 开始打印,排队:113,票券:2604261832084542958901,订单:2604261832080043338682,[2026-04-26 18:32:15微信支付12元]
2026-04-26 18:32:18>>>MQTT票号同步场景，创建空订单对象
2026-04-26 18:32:18>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 18:32:20 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261832084542958901","queue_number":113,"trade_uid":"2604261832080043338682"}]}
2026-04-26 18:32:20 >>>故障排除日志:删除未同步下发订单成功2604261832080043338682
2026-04-26 18:32:20 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536881874]
2026-04-26 18:32:33>>>cash read=00
2026-04-26 18:32:34>>>cash read=818F42
2026-04-26 18:32:34>>>cash write=02
2026-04-26 18:32:34 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 18:32:34>>>cash read=10
2026-04-26 18:32:34 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 18:32:36>>>cash write=0C
2026-04-26 18:32:36>>>cash read=3E
2026-04-26 18:32:37>>>cash read=2F29
2026-04-26 18:32:38>>>cash read=01
2026-04-26 18:32:42>>>cash read=2F
2026-04-26 18:32:43>>>cash read=2F29
2026-04-26 18:32:45>>>cash read=00
2026-04-26 18:32:47>>>cash read=29
2026-04-26 18:32:47 >>>回调事件130,cash_status,20029,退钞中


===18:33:49===
2026-04-26 18:32:48>>>cash read=3E
2026-04-26 18:32:51>>>cash read=00
2026-04-26 18:32:52>>>cash read=818F40
2026-04-26 18:32:52>>>cash write=02
2026-04-26 18:32:52 >>>回调事件130,cash_status,10022,进钞中...read money=1
2026-04-26 18:32:52>>>cash read=10
2026-04-26 18:32:52 >>>回调事件130,1,10023,finish Money=1,进钞完成
2026-04-26 18:32:54>>>cash write=0C
2026-04-26 18:32:54>>>cash read=3E
2026-04-26 18:32:55>>>cash read=00
2026-04-26 18:32:55>>>cash read=818F40
2026-04-26 18:32:55>>>cash write=02
2026-04-26 18:32:55 >>>回调事件130,cash_status,10022,进钞中...read money=1
2026-04-26 18:32:56>>>cash read=10
2026-04-26 18:32:56 >>>回调事件130,1,10023,finish Money=1,进钞完成
2026-04-26 18:32:56 当前产品价格12元，投币12元，打印小票中...
2026-04-26 18:32:56 >>>开始打印,排队号为114,订单号为2604261832520014861931
2026-04-26 18:32:56>>>订单2604261832520014861931写入成功,剩余空间为1679500,占用RAM为632.951171875
删除未同步订单2604261832520014861931
2026-04-26 18:32:58>>>订单2604261832520014861931删除成功,剩余空间为1680000,占用RAM为655.1943359375
检测订单目录中>>>
无未同步订单>>>
2026-04-26 18:32:59 >>>当前Ram内存为615.607421875
定时检测未同步订单启用[checkOrderNum=536881935]
2026-04-26 18:32:59>>>cash write=0C
2026-04-26 18:32:59>>>cash read=3E
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 18:33:19 >>>回调事件[910,devices/TL4861]
2026-04-26 18:33:19 >>>故障排除日志:上一MQTT订单号缓存列表为2604261832080043338682
2026-04-26 18:33:19 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 18:33:19 开始打印,排队:115,票券:2604261833127101751601,订单:2604261833120068956451,[2026-04-26 18:33:16支付宝支付12元]
2026-04-26 18:33:19>>>MQTT票号同步场景，创建空订单对象
2026-04-26 18:33:19>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 18:33:21 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261833127101751601","queue_number":115,"trade_uid":"2604261833120068956451"}]}
2026-04-26 18:33:21 >>>故障排除日志:删除未同步下发订单成功2604261833120068956451
2026-04-26 18:33:22 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536881952]


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


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


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


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


===18:59:50===
2026-04-26 18:59:03>>>cash read=00
2026-04-26 18:59:04>>>cash read=818F40
2026-04-26 18:59:04>>>cash write=02
2026-04-26 18:59:04 >>>回调事件130,cash_status,10022,进钞中...read money=1
2026-04-26 18:59:04>>>cash read=10
2026-04-26 18:59:04 >>>回调事件130,1,10023,finish Money=1,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 18:59:05>>>cash write=0C
2026-04-26 18:59:05>>>cash read=00
2026-04-26 18:59:06>>>cash read=818F40
2026-04-26 18:59:06>>>cash write=02
2026-04-26 18:59:06 >>>回调事件130,cash_status,10022,进钞中...read money=1
2026-04-26 18:59:07>>>cash read=10
2026-04-26 18:59:07 >>>回调事件130,1,10023,finish Money=1,进钞完成
2026-04-26 18:59:08>>>cash write=0C
2026-04-26 18:59:08>>>cash read=00
2026-04-26 18:59:09>>>cash read=3E
2026-04-26 18:59:10>>>cash read=00
2026-04-26 18:59:11>>>cash read=818F40
2026-04-26 18:59:11>>>cash write=02
2026-04-26 18:59:11 >>>回调事件130,cash_status,10022,进钞中...read money=1
2026-04-26 18:59:11>>>cash read=10
2026-04-26 18:59:11 >>>回调事件130,1,10023,finish Money=1,进钞完成
2026-04-26 18:59:12>>>cash write=0C
2026-04-26 18:59:13>>>cash read=00
2026-04-26 18:59:14>>>cash read=818F40
2026-04-26 18:59:14>>>cash write=02
2026-04-26 18:59:14 >>>回调事件130,cash_status,10022,进钞中...read money=1
2026-04-26 18:59:14>>>cash read=10
2026-04-26 18:59:14 >>>回调事件130,1,10023,finish Money=1,进钞完成
2026-04-26 18:59:15>>>cash write=0C
2026-04-26 18:59:15>>>cash read=3E
2026-04-26 18:59:19>>>cash read=00
2026-04-26 18:59:19>>>cash read=818F42
2026-04-26 18:59:19>>>cash write=02
2026-04-26 18:59:19 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 18:59:20>>>cash read=10
2026-04-26 18:59:20 >>>回调事件130,10,10023,finish Money=10,进钞完成
2026-04-26 18:59:21>>>cash write=0C
2026-04-26 18:59:21>>>cash read=3E
2026-04-26 18:59:28>>>cash read=00
2026-04-26 18:59:28>>>cash read=818F42
2026-04-26 18:59:28>>>cash write=02
2026-04-26 18:59:28 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 18:59:29>>>cash read=10
2026-04-26 18:59:29 >>>回调事件130,10,10023,finish Money=10,进钞完成
2026-04-26 18:59:29 当前产品价格12元，投币24元，打印小票中...
2026-04-26 18:59:29 >>>开始打印,排队号为120,订单号为2604261859140014861650
2026-04-26 18:59:29 >>>开始打印,排队号为121,订单号为2604261859140014861650
2026-04-26 18:59:29>>>订单2604261859140014861650写入成功,剩余空间为1677000,占用RAM为650.8076171875
删除未同步订单2604261859140014861650
2026-04-26 18:59:33>>>订单2604261859140014861650删除成功,剩余空间为1678500,占用RAM为664.38671875
检测订单目录中>>>
无未同步订单>>>
2026-04-26 18:59:33 >>>当前Ram内存为618.7666015625
定时检测未同步订单启用[checkOrderNum=536882371]
2026-04-26 18:59:34>>>cash write=0C
2026-04-26 18:59:34>>>cash read=3E


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


===20:27:57===
2026-04-26 20:26:56>>>cash read=00
2026-04-26 20:26:56>>>cash read=818F40
2026-04-26 20:26:56>>>cash write=02
2026-04-26 20:26:56 >>>回调事件130,cash_status,10022,进钞中...read money=1
2026-04-26 20:26:57>>>cash read=10
2026-04-26 20:26:57 >>>回调事件130,1,10023,finish Money=1,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 20:26:58>>>cash write=0C
2026-04-26 20:26:58>>>cash read=3E
2026-04-26 20:27:03>>>cash read=00
2026-04-26 20:27:03>>>cash read=818F42
2026-04-26 20:27:03>>>cash write=02
2026-04-26 20:27:03 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 20:27:03>>>cash read=10
2026-04-26 20:27:03 >>>回调事件130,10,10023,finish Money=10,进钞完成
2026-04-26 20:27:05>>>cash write=0C
2026-04-26 20:27:05>>>cash read=3E
2026-04-26 20:27:06>>>cash read=818F42
2026-04-26 20:27:06>>>cash write=02
2026-04-26 20:27:06 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 20:27:06>>>cash read=10
2026-04-26 20:27:06 >>>回调事件130,10,10023,finish Money=10,进钞完成
2026-04-26 20:27:07>>>cash write=0C
2026-04-26 20:27:08>>>cash read=00
2026-04-26 20:27:08>>>cash read=818F40
2026-04-26 20:27:08>>>cash write=02
2026-04-26 20:27:08 >>>回调事件130,cash_status,10022,进钞中...read money=1
2026-04-26 20:27:09>>>cash read=10
2026-04-26 20:27:09 >>>回调事件130,1,10023,finish Money=1,进钞完成
2026-04-26 20:27:10>>>cash write=0C
2026-04-26 20:27:10>>>cash read=00
2026-04-26 20:27:10>>>cash read=818F40
2026-04-26 20:27:10>>>cash write=02
2026-04-26 20:27:10 >>>回调事件130,cash_status,10022,进钞中...read money=1
2026-04-26 20:27:11>>>cash read=10
2026-04-26 20:27:11 >>>回调事件130,1,10023,finish Money=1,进钞完成
2026-04-26 20:27:12>>>cash write=0C
2026-04-26 20:27:12>>>cash read=00
2026-04-26 20:27:13>>>cash read=818F40
2026-04-26 20:27:13>>>cash write=02
2026-04-26 20:27:13 >>>回调事件130,cash_status,10022,进钞中...read money=1
2026-04-26 20:27:13>>>cash read=10
2026-04-26 20:27:13 >>>回调事件130,1,10023,finish Money=1,进钞完成
2026-04-26 20:27:13 当前产品价格12元，投币24元，打印小票中...
2026-04-26 20:27:14 >>>开始打印,排队号为145,订单号为2604262027030014861180
2026-04-26 20:27:14 >>>开始打印,排队号为146,订单号为2604262027030014861180
2026-04-26 20:27:14>>>订单2604262027030014861180写入成功,剩余空间为1677500,占用RAM为651.951171875
删除未同步订单2604262027030014861180
2026-04-26 20:27:18>>>订单2604262027030014861180删除成功,剩余空间为1678500,占用RAM为665.431640625
检测订单目录中>>>
无未同步订单>>>
2026-04-26 20:27:18 >>>当前Ram内存为620.1513671875
定时检测未同步订单启用[checkOrderNum=536883822]
2026-04-26 20:27:19>>>cash write=0C
2026-04-26 20:27:19>>>cash read=3E


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


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


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


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


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


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


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


===21:12:00===
2026-04-26 21:11:58>>>cash read=00
2026-04-26 21:11:58>>>cash read=818F42
2026-04-26 21:11:58>>>cash write=02
2026-04-26 21:11:58 >>>回调事件130,cash_status,10022,进钞中...read money=10


===21:13:00===
2026-04-26 21:11:59>>>cash read=10
2026-04-26 21:11:59 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 21:12:00>>>cash write=0C
2026-04-26 21:12:00>>>cash read=3E
2026-04-26 21:12:01>>>cash read=818F40
2026-04-26 21:12:01>>>cash write=02
2026-04-26 21:12:01 >>>回调事件130,cash_status,10022,进钞中...read money=1
2026-04-26 21:12:02>>>cash read=10
2026-04-26 21:12:02 >>>回调事件130,1,10023,finish Money=1,进钞完成
2026-04-26 21:12:03>>>cash write=0C
2026-04-26 21:12:03>>>cash read=00
2026-04-26 21:12:03>>>cash read=818F40
2026-04-26 21:12:03>>>cash write=02
2026-04-26 21:12:03 >>>回调事件130,cash_status,10022,进钞中...read money=1
2026-04-26 21:12:04>>>cash read=10
2026-04-26 21:12:04 >>>回调事件130,1,10023,finish Money=1,进钞完成
2026-04-26 21:12:04 当前产品价格12元，投币12元，打印小票中...
2026-04-26 21:12:04 >>>开始打印,排队号为155,订单号为2604262112020014861149
2026-04-26 21:12:04>>>订单2604262112020014861149写入成功,剩余空间为1679000,占用RAM为634.8173828125
删除未同步订单2604262112020014861149
2026-04-26 21:12:06>>>订单2604262112020014861149删除成功,剩余空间为1680000,占用RAM为654.5244140625
检测订单目录中>>>
无未同步订单>>>
2026-04-26 21:12:06 >>>当前Ram内存为616.244140625
定时检测未同步订单启用[checkOrderNum=536884509]
2026-04-26 21:12:07>>>cash write=0C
2026-04-26 21:12:07>>>cash read=3E
2026-04-26 21:12:23>>>cash read=00
2026-04-26 21:12:23>>>cash read=818F42
2026-04-26 21:12:23>>>cash write=02
2026-04-26 21:12:23 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 21:12:23>>>cash read=10
2026-04-26 21:12:24 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 21:12:25>>>cash write=0C
2026-04-26 21:12:25>>>cash read=00
2026-04-26 21:12:25>>>cash read=818F42
2026-04-26 21:12:25>>>cash write=02
2026-04-26 21:12:25 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 21:12:26>>>cash read=10
2026-04-26 21:12:26 >>>回调事件130,10,10023,finish Money=10,进钞完成
2026-04-26 21:12:27>>>cash write=0C
2026-04-26 21:12:27>>>cash read=00
2026-04-26 21:12:28>>>cash read=818F42
2026-04-26 21:12:28>>>cash write=02
2026-04-26 21:12:28 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 21:12:28>>>cash read=10
2026-04-26 21:12:28 >>>回调事件130,10,10023,finish Money=10,进钞完成
2026-04-26 21:12:29>>>cash write=0C
2026-04-26 21:12:30>>>cash read=00
2026-04-26 21:12:30>>>cash read=818F42
2026-04-26 21:12:30>>>cash write=02
2026-04-26 21:12:30 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 21:12:30>>>cash read=10
2026-04-26 21:12:30 >>>回调事件130,10,10023,finish Money=10,进钞完成
2026-04-26 21:12:32>>>cash write=0C
2026-04-26 21:12:32>>>cash read=3E
2026-04-26 21:12:35>>>cash read=00
2026-04-26 21:12:35>>>cash read=818F42
2026-04-26 21:12:35>>>cash write=02
2026-04-26 21:12:35 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 21:12:36>>>cash read=10
2026-04-26 21:12:36 >>>回调事件130,10,10023,finish Money=10,进钞完成
2026-04-26 21:12:37>>>cash write=0C
2026-04-26 21:12:37>>>cash read=00
2026-04-26 21:12:38>>>cash read=818F43
2026-04-26 21:12:38>>>cash write=02
2026-04-26 21:12:38 >>>回调事件130,cash_status,10022,进钞中...read money=20
2026-04-26 21:12:38>>>cash read=10
2026-04-26 21:12:38 >>>回调事件130,20,10023,finish Money=20,进钞完成
2026-04-26 21:12:40>>>cash write=0C
2026-04-26 21:12:40>>>cash read=00
2026-04-26 21:12:40>>>cash read=818F40
2026-04-26 21:12:40>>>cash write=02
2026-04-26 21:12:40 >>>回调事件130,cash_status,10022,进钞中...read money=1
2026-04-26 21:12:41>>>cash read=10
2026-04-26 21:12:41 >>>回调事件130,1,10023,finish Money=1,进钞完成
2026-04-26 21:12:42>>>cash write=0C
2026-04-26 21:12:42>>>cash read=00818F40
2026-04-26 21:12:42>>>cash write=02
2026-04-26 21:12:42 >>>回调事件130,cash_status,10022,进钞中...read money=1
2026-04-26 21:12:43>>>cash read=10
2026-04-26 21:12:43 >>>回调事件130,1,10023,finish Money=1,进钞完成
2026-04-26 21:12:43 当前产品价格12元，投币72元，打印小票中...
2026-04-26 21:12:43 >>>开始打印,排队号为156,订单号为2604262112240014861173
2026-04-26 21:12:43 >>>开始打印,排队号为157,订单号为2604262112240014861173
2026-04-26 21:12:43 >>>开始打印,排队号为158,订单号为2604262112240014861173
2026-04-26 21:12:44 >>>开始打印,排队号为159,订单号为2604262112240014861173
2026-04-26 21:12:44 >>>开始打印,排队号为160,订单号为2604262112240014861173
2026-04-26 21:12:44 >>>开始打印,排队号为161,订单号为2604262112240014861173
2026-04-26 21:12:44>>>订单2604262112240014861173写入成功,剩余空间为1674500,占用RAM为672.103515625


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