TLClient_JSSCOM_LuatOS-Air_V4010_RDA8910_RFTTS_0xe0000,2.8.6,863013071869902,81207061129955,
poweron reason:0

===09:49:18===
2026-04-25 21:48:44>>>cash read=3E


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

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

2026-04-26 09:49:21>>>cash write=0C
流量卡还有217天过期
2026-04-26 09:49:29 >>>当前Ram内存为658.0556640625


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


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


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


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


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


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


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


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


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


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


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


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


===12:22:23===
2026-04-26 12:21:59>>>cash read=00
2026-04-26 12:21:59>>>cash read=818F43
2026-04-26 12:21:59>>>cash write=02
2026-04-26 12:21:59 >>>回调事件130,cash_status,10022,进钞中...read money=20
2026-04-26 12:22:00>>>cash read=10
2026-04-26 12:22:00 >>>回调事件130,20,10023,finish Money=20,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 12:22:01>>>cash write=0C
2026-04-26 12:22:01>>>cash read=00
2026-04-26 12:22:01>>>cash read=818F40
2026-04-26 12:22:01>>>cash write=02
2026-04-26 12:22:01 >>>回调事件130,cash_status,10022,进钞中...read money=1
2026-04-26 12:22:02>>>cash write=0C
2026-04-26 12:22:02>>>cash read=00
2026-04-26 12:22:02>>>cash read=10
2026-04-26 12:22:02 >>>回调事件130,1,10023,finish Money=1,进钞完成
2026-04-26 12:22:04>>>cash read=3E
2026-04-26 12:22:05>>>cash read=00
2026-04-26 12:22:05>>>cash read=818F41
2026-04-26 12:22:05>>>cash write=02
2026-04-26 12:22:05 >>>回调事件130,cash_status,10022,进钞中...read money=5
2026-04-26 12:22:06>>>cash read=10
2026-04-26 12:22:06 >>>回调事件130,5,10023,finish Money=5,进钞完成
2026-04-26 12:22:06 当前产品价格13元，投币26元，打印小票中...
2026-04-26 12:22:06 >>>开始打印,排队号为15,订单号为2604261222060014833858
2026-04-26 12:22:06 >>>开始打印,排队号为16,订单号为2604261222060014833858
2026-04-26 12:22:06>>>订单2604261222060014833858写入成功,剩余空间为1678500,占用RAM为646.0478515625
删除未同步订单2604261222060014833858
2026-04-26 12:22:10>>>订单2604261222060014833858删除成功,剩余空间为1679500,占用RAM为665.619140625
检测订单目录中>>>
无未同步订单>>>
2026-04-26 12:22:10 >>>当前Ram内存为620.564453125
定时检测未同步订单启用[checkOrderNum=536872471]
2026-04-26 12:22:11>>>cash write=0C
2026-04-26 12:22:11>>>cash read=3E


===12:23:23===
2026-04-26 12:22:35>>>cash read=00
2026-04-26 12:22:36>>>cash read=818F42
2026-04-26 12:22:36>>>cash write=02
2026-04-26 12:22:36 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 12:22:36>>>cash read=10
2026-04-26 12:22:36 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 12:22:37>>>cash write=0C
2026-04-26 12:22:37>>>cash read=00
2026-04-26 12:22:38>>>cash read=818F42
2026-04-26 12:22:38>>>cash write=02
2026-04-26 12:22:38 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 12:22:39>>>cash read=10
2026-04-26 12:22:39 >>>回调事件130,10,10023,finish Money=10,进钞完成
2026-04-26 12:22:40>>>cash write=0C
2026-04-26 12:22:40>>>cash read=00
2026-04-26 12:22:40>>>cash read=818F40
2026-04-26 12:22:40>>>cash write=02
2026-04-26 12:22:40 >>>回调事件130,cash_status,10022,进钞中...read money=1
2026-04-26 12:22:41>>>cash write=0C
2026-04-26 12:22:41>>>cash read=00
2026-04-26 12:22:41>>>cash read=10
2026-04-26 12:22:42 >>>回调事件130,1,10023,finish Money=1,进钞完成
2026-04-26 12:22:43>>>cash read=00
2026-04-26 12:22:43>>>cash read=818F41
2026-04-26 12:22:43>>>cash write=02
2026-04-26 12:22:43 >>>回调事件130,cash_status,10022,进钞中...read money=5
2026-04-26 12:22:44>>>cash read=10
2026-04-26 12:22:44 >>>回调事件130,5,10023,finish Money=5,进钞完成
2026-04-26 12:22:44 当前产品价格13元，投币26元，打印小票中...
2026-04-26 12:22:44 >>>开始打印,排队号为17,订单号为2604261222360014833851
2026-04-26 12:22:44 >>>开始打印,排队号为18,订单号为2604261222360014833851
2026-04-26 12:22:44>>>订单2604261222360014833851写入成功,剩余空间为1678000,占用RAM为647.2138671875
删除未同步订单2604261222360014833851
2026-04-26 12:22:48>>>订单2604261222360014833851删除成功,剩余空间为1679500,占用RAM为663.7548828125
检测订单目录中>>>
无未同步订单>>>
2026-04-26 12:22:48 >>>当前Ram内存为618.5869140625
定时检测未同步订单启用[checkOrderNum=536872499]
2026-04-26 12:22:49>>>cash write=0C
2026-04-26 12:22:49>>>cash read=3E


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


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


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


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


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


===13:22:25===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 13:21:31 >>>回调事件[910,devices/TL4833]
2026-04-26 13:21:31 >>>故障排除日志:上一MQTT订单号缓存列表为2604261320420083297349
2026-04-26 13:21:31 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 13:21:31 开始打印,排队:24,票券:2604261321219860933901,订单:2604261321210096633026,[2026-04-26 13:21:30微信支付13元]
2026-04-26 13:21:31 开始打印,排队:25,票券:2604261321235337333901,订单:2604261321230051612646,[2026-04-26 13:21:30微信支付13元]
2026-04-26 13:21:31>>>MQTT票号同步场景，创建空订单对象
2026-04-26 13:21:31>>>合并MQTT票号列表到订单同步请求,共2张票
2026-04-26 13:21:31 >>>回调事件[910,devices/TL4833]
2026-04-26 13:21:31 >>>故障排除日志:上一MQTT订单号缓存列表为2604261321210096633026|2604261321230051612646
2026-04-26 13:21:31 >>>故障排除日志:终端未同步成功订单列表00242604261321210096633026|00252604261321230051612646
已接收过此消息,票券号为2604261321219860933901,排队号为24
已接收过此消息,票券号为2604261321235337333901,排队号为25
2026-04-26 13:21:31>>>HTTP请求进行中，跳过本次同步
2026-04-26 13:21:35 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261321219860933901","queue_number":24,"trade_uid":"2604261321210096633026"},{"ticket_no":"2604261321235337333901","queue_number":25,"trade_uid":"2604261321230051612646"}]}
2026-04-26 13:21:35 >>>故障排除日志:删除未同步下发订单成功2604261321210096633026
2026-04-26 13:21:35 >>>故障排除日志:删除未同步下发订单成功2604261321230051612646
2026-04-26 13:21:35 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536873076]


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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

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

2026-04-26 15:06:58>>>cash write=0C
流量卡还有217天过期
2026-04-26 15:07:06 >>>当前Ram内存为660.44140625


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


===16:27:03===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 16:26:47 >>>回调事件[910,devices/TL4833]
2026-04-26 16:26:47 >>>故障排除日志:上一MQTT订单号缓存列表为2604261621450091921493
2026-04-26 16:26:47 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 16:26:47 开始打印,排队:66,票券:2604261626394445667501,订单:2604261626390042586626,[2026-04-26 16:26:46微信支付13元]
2026-04-26 16:26:47 开始打印,排队:67,票券:2604261626394446067502,订单:2604261626390042586626,[2026-04-26 16:26:46微信支付13元]
2026-04-26 16:26:47 开始打印,排队:68,票券:2604261626394446187903,订单:2604261626390042586626,[2026-04-26 16:26:46微信支付13元]
2026-04-26 16:26:47>>>MQTT票号同步场景，创建空订单对象
2026-04-26 16:26:47>>>合并MQTT票号列表到订单同步请求,共3张票
2026-04-26 16:26:53 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261626394445667501","queue_number":66,"trade_uid":"2604261626390042586626"},{"ticket_no":"2604261626394446067502","queue_number":67,"trade_uid":"2604261626390042586626"},{"ticket_no":"2604261626394446187903","queue_number":68,"trade_uid":"2604261626390042586626"}]}
2026-04-26 16:26:53 >>>故障排除日志:删除未同步下发订单成功2604261626390042586626
2026-04-26 16:26:53 >>>故障排除日志:删除未同步下发订单成功2604261626390042586626
2026-04-26 16:26:53 >>>故障排除日志:删除未同步下发订单成功2604261626390042586626
2026-04-26 16:26:53 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536871866]


===16:30:04===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 16:29:50 >>>回调事件[910,devices/TL4833]
2026-04-26 16:29:50 >>>故障排除日志:上一MQTT订单号缓存列表为2604261626390042586626|2604261626390042586626|2604261626390042586626
2026-04-26 16:29:50 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 16:29:50 开始打印,排队:69,票券:2604261629422593074601,订单:2604261629420023284631,[2026-04-26 16:29:48微信支付13元]
2026-04-26 16:29:50 开始打印,排队:70,票券:2604261629422593848302,订单:2604261629420023284631,[2026-04-26 16:29:48微信支付13元]
2026-04-26 16:29:50 开始打印,排队:71,票券:2604261629422594053503,订单:2604261629420023284631,[2026-04-26 16:29:48微信支付13元]
2026-04-26 16:29:50>>>MQTT票号同步场景，创建空订单对象
2026-04-26 16:29:50>>>合并MQTT票号列表到订单同步请求,共3张票
2026-04-26 16:29:55 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261629422593074601","queue_number":69,"trade_uid":"2604261629420023284631"},{"ticket_no":"2604261629422593848302","queue_number":70,"trade_uid":"2604261629420023284631"},{"ticket_no":"2604261629422594053503","queue_number":71,"trade_uid":"2604261629420023284631"}]}
2026-04-26 16:29:55 >>>故障排除日志:删除未同步下发订单成功2604261629420023284631
2026-04-26 16:29:55 >>>故障排除日志:删除未同步下发订单成功2604261629420023284631
2026-04-26 16:29:55 >>>故障排除日志:删除未同步下发订单成功2604261629420023284631
2026-04-26 16:29:55 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536871901]


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


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


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


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


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


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


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


===16:57:08===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 16:57:03 >>>回调事件[910,devices/TL4833]
2026-04-26 16:57:03 >>>故障排除日志:上一MQTT订单号缓存列表为2604261655180000530113
2026-04-26 16:57:03 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 16:57:03 开始打印,排队:79,票券:2604261656537115216401,订单:2604261656530069290385,[2026-04-26 16:57:02微信支付13元]
2026-04-26 16:57:03 开始打印,排队:80,票券:2604261656537115714502,订单:2604261656530069290385,[2026-04-26 16:57:02微信支付13元]
2026-04-26 16:57:03>>>MQTT票号同步场景，创建空订单对象
2026-04-26 16:57:03>>>合并MQTT票号列表到订单同步请求,共2张票


===16:58:08===
2026-04-26 16:57:07 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261656537115216401","queue_number":79,"trade_uid":"2604261656530069290385"},{"ticket_no":"2604261656537115714502","queue_number":80,"trade_uid":"2604261656530069290385"}]}
2026-04-26 16:57:07 >>>故障排除日志:删除未同步下发订单成功2604261656530069290385
2026-04-26 16:57:07 >>>故障排除日志:删除未同步下发订单成功2604261656530069290385
2026-04-26 16:57:07 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536872212]


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


===18:49:14===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 18:48:31 >>>回调事件[910,devices/TL4833]
2026-04-26 18:48:31 >>>故障排除日志:上一MQTT订单号缓存列表为2604261845490063626014
2026-04-26 18:48:31 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 18:48:31 开始打印,排队:108,票券:2604261848222305045101,订单:2604261848220019987454,[2026-04-26 18:48:30微信支付13元]
2026-04-26 18:48:32>>>MQTT票号同步场景，创建空订单对象
2026-04-26 18:48:32>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 18:48:34 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261848222305045101","queue_number":108,"trade_uid":"2604261848220019987454"}]}
2026-04-26 18:48:34 >>>故障排除日志:删除未同步下发订单成功2604261848220019987454
2026-04-26 18:48:34 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536873416]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 18:48:38 >>>回调事件[910,devices/TL4833]
2026-04-26 18:48:38 >>>故障排除日志:上一MQTT订单号缓存列表为2604261848220019987454
2026-04-26 18:48:38 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 18:48:38 开始打印,排队:109,票券:2604261848296531958301,订单:2604261848290063221289,[2026-04-26 18:48:37微信支付13元]
2026-04-26 18:48:38>>>MQTT票号同步场景，创建空订单对象
2026-04-26 18:48:38>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 18:48:40 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261848296531958301","queue_number":109,"trade_uid":"2604261848290063221289"}]}
2026-04-26 18:48:40 >>>故障排除日志:删除未同步下发订单成功2604261848290063221289
2026-04-26 18:48:40 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536873422]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 18:48:49 >>>回调事件[910,devices/TL4833]
2026-04-26 18:48:49 >>>故障排除日志:上一MQTT订单号缓存列表为2604261848290063221289
2026-04-26 18:48:49 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 18:48:49 开始打印,排队:110,票券:2604261848407963589301,订单:2604261848400077644128,[2026-04-26 18:48:48微信支付13元]
2026-04-26 18:48:49>>>MQTT票号同步场景，创建空订单对象
2026-04-26 18:48:49>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 18:48:51 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261848407963589301","queue_number":110,"trade_uid":"2604261848400077644128"}]}
2026-04-26 18:48:51 >>>故障排除日志:删除未同步下发订单成功2604261848400077644128
2026-04-26 18:48:51 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536873429]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 18:49:06 >>>回调事件[910,devices/TL4833]
2026-04-26 18:49:06 >>>故障排除日志:上一MQTT订单号缓存列表为2604261848400077644128
2026-04-26 18:49:06 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 18:49:06 开始打印,排队:111,票券:2604261848564201569201,订单:2604261848560038909893,[2026-04-26 18:49:05微信支付13元]
2026-04-26 18:49:06>>>MQTT票号同步场景，创建空订单对象
2026-04-26 18:49:06>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 18:49:08 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261848564201569201","queue_number":111,"trade_uid":"2604261848560038909893"}]}
2026-04-26 18:49:08 >>>故障排除日志:删除未同步下发订单成功2604261848560038909893
2026-04-26 18:49:08 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536873442]


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


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


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


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


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


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


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


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


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


===19:26:17===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:25:30 >>>回调事件[910,devices/TL4833]
2026-04-26 19:25:30 >>>故障排除日志:上一MQTT订单号缓存列表为2604261924000003074193
2026-04-26 19:25:30 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 19:25:30 开始打印,排队:122,票券:2604261925214291788701,订单:2604261925210041144878,[2026-04-26 19:25:29微信支付13元]
2026-04-26 19:25:30>>>MQTT票号同步场景，创建空订单对象
2026-04-26 19:25:30>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 19:25:32 >>>回调事件[910,devices/TL4833]
2026-04-26 19:25:32 >>>故障排除日志:上一MQTT订单号缓存列表为2604261925210041144878
2026-04-26 19:25:32 >>>故障排除日志:终端未同步成功订单列表01222604261925210041144878
已接收过此消息,票券号为2604261925214291788701,排队号为122
2026-04-26 19:25:32 开始打印,排队:123,票券:2604261925235417754901,订单:2604261925230050787113,[2026-04-26 19:25:30微信支付13元]
2026-04-26 19:25:32>>>HTTP请求进行中，跳过本次同步
2026-04-26 19:25:34 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261925214291788701","queue_number":122,"trade_uid":"2604261925210041144878"}]}
2026-04-26 19:25:34 >>>故障排除日志:删除未同步下发订单成功2604261925210041144878
2026-04-26 19:25:34 >>>故障排除日志:终端同步成功后剩余订单列表01232604261925230050787113
定时检测未同步订单启用[checkOrderNum=536873855]


===19:28:17===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:27:26 >>>回调事件[910,devices/TL4833]
2026-04-26 19:27:26 >>>故障排除日志:上一MQTT订单号缓存列表为2604261925210041144878|2604261925230050787113
2026-04-26 19:27:26 >>>故障排除日志:终端未同步成功订单列表01232604261925230050787113
已接收过此消息,票券号为2604261925235417754901,排队号为123
2026-04-26 19:27:26 开始打印,排队:124,票券:2604261927156621699101,订单:2604261927150064413346,[2026-04-26 19:27:25微信支付13元]
2026-04-26 19:27:26 开始打印,排队:125,票券:2604261927156628764602,订单:2604261927150064413346,[2026-04-26 19:27:25微信支付13元]
2026-04-26 19:27:26>>>MQTT票号同步场景，创建空订单对象
2026-04-26 19:27:26>>>合并MQTT票号列表到订单同步请求,共3张票
2026-04-26 19:27:30 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261925235417754901","queue_number":123,"trade_uid":"2604261925230050787113"},{"ticket_no":"2604261927156621699101","queue_number":124,"trade_uid":"2604261927150064413346"},{"ticket_no":"2604261927156628764602","queue_number":125,"trade_uid":"2604261927150064413346"}]}
2026-04-26 19:27:30 >>>故障排除日志:删除未同步下发订单成功2604261925230050787113
2026-04-26 19:27:30 >>>故障排除日志:删除未同步下发订单成功2604261927150064413346
2026-04-26 19:27:30 >>>故障排除日志:删除未同步下发订单成功2604261927150064413346
2026-04-26 19:27:30 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536873881]


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


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


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


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


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


===19:47:19===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:46:55 >>>回调事件[910,devices/TL4833]
2026-04-26 19:46:55 >>>故障排除日志:上一MQTT订单号缓存列表为2604261942170066350087
2026-04-26 19:46:55 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 19:46:55 开始打印,排队:132,票券:2604261946458000248901,订单:2604261946450077282168,[2026-04-26 19:46:54微信支付13元]
2026-04-26 19:46:55>>>MQTT票号同步场景，创建空订单对象
2026-04-26 19:46:55>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 19:46:57 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261946458000248901","queue_number":132,"trade_uid":"2604261946450077282168"}]}
2026-04-26 19:46:57 >>>故障排除日志:删除未同步下发订单成功2604261946450077282168
2026-04-26 19:46:57 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536874105]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:47:06 >>>回调事件[910,devices/TL4833]
2026-04-26 19:47:06 >>>故障排除日志:上一MQTT订单号缓存列表为2604261946450077282168
2026-04-26 19:47:06 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 19:47:06 开始打印,排队:133,票券:2604261947005784442101,订单:2604261947000054756838,[2026-04-26 19:47:05支付宝支付13元]
2026-04-26 19:47:06 开始打印,排队:134,票券:2604261947005785074502,订单:2604261947000054756838,[2026-04-26 19:47:05支付宝支付13元]
2026-04-26 19:47:06>>>MQTT票号同步场景，创建空订单对象
2026-04-26 19:47:06>>>合并MQTT票号列表到订单同步请求,共2张票
2026-04-26 19:47:10 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261947005784442101","queue_number":133,"trade_uid":"2604261947000054756838"},{"ticket_no":"2604261947005785074502","queue_number":134,"trade_uid":"2604261947000054756838"}]}
2026-04-26 19:47:10 >>>故障排除日志:删除未同步下发订单成功2604261947000054756838
2026-04-26 19:47:10 >>>故障排除日志:删除未同步下发订单成功2604261947000054756838
2026-04-26 19:47:10 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536874114]


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


===21:11:32===
2026-04-26 21:11:05>>>cash read=00
2026-04-26 21:11:05>>>cash read=818F40
2026-04-26 21:11:05>>>cash write=02
2026-04-26 21:11:05 >>>回调事件130,cash_status,10022,进钞中...read money=1
2026-04-26 21:11:06>>>cash write=0C
2026-04-26 21:11:06>>>cash read=00
2026-04-26 21:11:07>>>cash read=10
2026-04-26 21:11:07 >>>回调事件130,1,10023,finish Money=1,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 21:11:08>>>cash read=00
2026-04-26 21:11:08>>>cash read=818F40
2026-04-26 21:11:08>>>cash write=02
2026-04-26 21:11:08 >>>回调事件130,cash_status,10022,进钞中...read money=1
2026-04-26 21:11:09>>>cash read=10
2026-04-26 21:11:09 >>>回调事件130,1,10023,finish Money=1,进钞完成
2026-04-26 21:11:10>>>cash write=0C
2026-04-26 21:11:10>>>cash read=3E
2026-04-26 21:11:12>>>cash read=00
2026-04-26 21:11:13>>>cash read=818F42
2026-04-26 21:11:13>>>cash write=02
2026-04-26 21:11:13 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 21:11:13>>>cash read=10
2026-04-26 21:11:13 >>>回调事件130,10,10023,finish Money=10,进钞完成
2026-04-26 21:11:14>>>cash write=0C
2026-04-26 21:11:15>>>cash read=00
2026-04-26 21:11:15>>>cash read=818F42
2026-04-26 21:11:15>>>cash write=02
2026-04-26 21:11:15 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 21:11:15>>>cash read=10
2026-04-26 21:11:15 >>>回调事件130,10,10023,finish Money=10,进钞完成
2026-04-26 21:11:17>>>cash write=0C
2026-04-26 21:11:17>>>cash read=00
2026-04-26 21:11:17>>>cash read=818F42
2026-04-26 21:11:17>>>cash write=02
2026-04-26 21:11:17 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 21:11:18>>>cash write=0C
2026-04-26 21:11:18>>>cash read=00
2026-04-26 21:11:18>>>cash read=10
2026-04-26 21:11:18 >>>回调事件130,10,10023,finish Money=10,进钞完成
2026-04-26 21:11:19>>>cash read=818F42
2026-04-26 21:11:19>>>cash write=02
2026-04-26 21:11:19 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 21:11:20>>>cash write=0C
2026-04-26 21:11:21>>>cash read=00
2026-04-26 21:11:21>>>cash read=10
2026-04-26 21:11:21 >>>回调事件130,10,10023,finish Money=10,进钞完成
2026-04-26 21:11:22>>>cash read=00
2026-04-26 21:11:23>>>cash read=818F42
2026-04-26 21:11:23>>>cash write=02
2026-04-26 21:11:23 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 21:11:23>>>cash read=10
2026-04-26 21:11:23 >>>回调事件130,10,10023,finish Money=10,进钞完成
2026-04-26 21:11:23 当前产品价格13元，投币52元，打印小票中...
2026-04-26 21:11:23 >>>开始打印,排队号为155,订单号为2604262111130014833882
2026-04-26 21:11:24 >>>开始打印,排队号为156,订单号为2604262111130014833882
2026-04-26 21:11:24 >>>开始打印,排队号为157,订单号为2604262111130014833882
2026-04-26 21:11:24 >>>开始打印,排队号为158,订单号为2604262111130014833882
2026-04-26 21:11:24>>>订单2604262111130014833882写入成功,剩余空间为1676000,占用RAM为671.6748046875


===21:12:33===
2026-04-26 21:11:32>>>cash write=0C
2026-04-26 21:11:32>>>cash read=3E


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


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


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