TLClient_JSSCOM_LuatOS-Air_V4010_RDA8910_RFTTS_0xe0000,2.8.6,863013071870009,76106559787267,
poweron reason:0

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

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

2026-04-28 08:56:02>>>cash write=0C
流量卡还有154天过期
2026-04-28 08:56:10 >>>当前Ram内存为663.0810546875


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


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


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


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


===10:05:01===
2026-04-28 10:04:51>>>cash read=00
2026-04-28 10:04:52>>>cash read=818F42
2026-04-28 10:04:52>>>cash write=02
2026-04-28 10:04:52 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-28 10:04:52>>>cash read=10
2026-04-28 10:04:52 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-28 10:04:53>>>cash write=0C
2026-04-28 10:04:54>>>cash read=00
2026-04-28 10:04:54>>>cash read=2F29
2026-04-28 10:04:56>>>cash read=3E
2026-04-28 10:04:57>>>cash read=29
2026-04-28 10:04:57 >>>回调事件130,cash_status,20029,退钞中
2026-04-28 10:04:58>>>cash read=3E
2026-04-28 10:04:59>>>cash read=00818F40
2026-04-28 10:04:59>>>cash write=02
2026-04-28 10:04:59 >>>回调事件130,cash_status,10022,进钞中...read money=1


===10:06:02===
2026-04-28 10:05:00>>>cash read=10
2026-04-28 10:05:00 >>>回调事件130,1,10023,finish Money=1,进钞完成
2026-04-28 10:05:01>>>cash write=0C
2026-04-28 10:05:01>>>cash read=00
2026-04-28 10:05:02>>>cash read=818F40
2026-04-28 10:05:02>>>cash write=02
2026-04-28 10:05:02 >>>回调事件130,cash_status,10022,进钞中...read money=1
2026-04-28 10:05:03>>>cash read=10
2026-04-28 10:05:03 >>>回调事件130,1,10023,finish Money=1,进钞完成
2026-04-28 10:05:03 当前产品价格12元，投币12元，打印小票中...
2026-04-28 10:05:03 >>>开始打印,排队号为72,订单号为2604281005000014753529
2026-04-28 10:05:03>>>订单2604281005000014753529写入成功,剩余空间为1679500,占用RAM为636.56640625
删除未同步订单2604281005000014753529
2026-04-28 10:05:05>>>订单2604281005000014753529删除成功,剩余空间为1680500,占用RAM为652.1865234375
检测订单目录中>>>
无未同步订单>>>
2026-04-28 10:05:05 >>>当前Ram内存为618.7607421875
定时检测未同步订单启用[checkOrderNum=536871726]
2026-04-28 10:05:06>>>cash write=0C
2026-04-28 10:05:06>>>cash read=29
2026-04-28 10:05:06 >>>回调事件130,cash_status,20029,退钞中
2026-04-28 10:05:07>>>cash read=3E
2026-04-28 10:05:09>>>cash read=818F40
2026-04-28 10:05:09>>>cash write=02
2026-04-28 10:05:09 >>>回调事件130,cash_status,10022,进钞中...read money=1
2026-04-28 10:05:10>>>cash read=10
2026-04-28 10:05:10 >>>回调事件130,1,10023,finish Money=1,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-28 10:05:11>>>cash write=0C
2026-04-28 10:05:11>>>cash read=00
2026-04-28 10:05:12>>>cash read=2F29
2026-04-28 10:05:14>>>cash read=00
2026-04-28 10:05:15>>>cash read=2F29
2026-04-28 10:05:16>>>cash read=3E
2026-04-28 10:05:19>>>cash read=00
2026-04-28 10:05:20>>>cash read=2F29
2026-04-28 10:05:22 >>>回调事件130,cash_status,20029,退钞中
2026-04-28 10:05:24>>>cash read=3E
2026-04-28 10:05:26>>>cash read=29
2026-04-28 10:05:26 >>>回调事件130,cash_status,20029,退钞中
2026-04-28 10:05:27>>>cash read=3E
2026-04-28 10:05:29>>>cash read=00
2026-04-28 10:05:30>>>cash read=818F42
2026-04-28 10:05:30>>>cash write=02
2026-04-28 10:05:30 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-28 10:05:31>>>cash read=10
2026-04-28 10:05:31 >>>回调事件130,10,10023,finish Money=10,进钞完成
2026-04-28 10:05:32>>>cash write=0C
2026-04-28 10:05:32>>>cash read=3E
2026-04-28 10:05:33>>>cash read=00
2026-04-28 10:05:34>>>cash read=29
2026-04-28 10:05:34 >>>回调事件130,cash_status,20029,退钞中
2026-04-28 10:05:34>>>cash read=2F29
2026-04-28 10:05:36>>>cash read=3E
2026-04-28 10:05:39>>>cash read=00
2026-04-28 10:05:40>>>cash read=292F29
2026-04-28 10:05:40 >>>回调事件130,cash_status,20029,退钞中
2026-04-28 10:05:42>>>cash read=00
2026-04-28 10:05:43>>>cash read=22
2026-04-28 10:05:43 >>>回调事件130,cash_status,30022,卡钞
2026-04-28 10:05:49>>>cash read=3E
2026-04-28 10:05:52>>>cash read=2F29
2026-04-28 10:05:53 >>>回调事件130,cash_status,20029,退钞中
2026-04-28 10:05:55>>>cash read=3E


===10:07:02===
2026-04-28 10:06:08>>>cash read=00
2026-04-28 10:06:08>>>cash read=818F40
2026-04-28 10:06:08>>>cash write=02
2026-04-28 10:06:08 >>>回调事件130,cash_status,10022,进钞中...read money=1
2026-04-28 10:06:09>>>cash read=10
2026-04-28 10:06:09 >>>回调事件130,1,10023,finish Money=1,进钞完成
2026-04-28 10:06:09 当前产品价格12元，投币12元，打印小票中...
2026-04-28 10:06:09 >>>开始打印,排队号为73,订单号为2604281005310014753775
2026-04-28 10:06:09>>>订单2604281005310014753775写入成功,剩余空间为1680000,占用RAM为633.828125
删除未同步订单2604281005310014753775
2026-04-28 10:06:11>>>订单2604281005310014753775删除成功,剩余空间为1680500,占用RAM为650.900390625
检测订单目录中>>>
无未同步订单>>>
2026-04-28 10:06:11 >>>当前Ram内存为618.8837890625
定时检测未同步订单启用[checkOrderNum=536871766]
2026-04-28 10:06:12>>>cash write=0C
2026-04-28 10:06:12>>>cash read=3E


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


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


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


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


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


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


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


===11:31:05===
2026-04-28 11:30:08 >>>剩余flash空间=1682000,占用RAM为658.2685546875
2026-04-28 11:30:08 >>>回调事件:901,netChange,1,4G LTE网络



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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


===18:58:20===
mqttTask.mqttMsgRecv.proc error
2026-04-28 18:57:44 >>>剩余flash空间=1681000,占用RAM为659.751953125
2026-04-28 18:57:44 >>>回调异常:910,mqtt_tl,30000,mqtt_stop

2026-04-28 18:57:44 >>>MQTT连接断开，尝试重连中
2026-04-28 18:58:06 >>>剩余flash空间=1681000,占用RAM为635.5859375
2026-04-28 18:58:06 >>>回调事件:910,subscribe,10000,连接服务器成功

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



TCP://post-cn-09k20cnrl07.mqtt.aliyuncs.com:1883 closed@28_18:57:44
TCP://post-cn-09k20cnrl07.mqtt.aliyuncs.com:1883@28_18:57:44:send fail
===19:02:24===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-28 19:01:47 >>>回调事件[910,devices/TL4753]
2026-04-28 19:01:47 >>>故障排除日志:上一MQTT订单号缓存列表为2604281856220019329656
2026-04-28 19:01:47 >>>故障排除日志:终端未同步成功订单列表
2026-04-28 19:01:47 开始打印,排队:129,票券:2604281901386113895801,订单:2604281901380059279635,[2026-04-28 19:01:47微信支付12元]
2026-04-28 19:01:47>>>MQTT票号同步场景，创建空订单对象
2026-04-28 19:01:47>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-28 19:01:49 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604281901386113895801","queue_number":129,"trade_uid":"2604281901380059279635"}]}
2026-04-28 19:01:49 >>>故障排除日志:删除未同步下发订单成功2604281901380059279635
2026-04-28 19:01:49 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877870]


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


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


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


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


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


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


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


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


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


===19:40:33===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-28 19:39:35 >>>回调事件[910,devices/TL4753]
2026-04-28 19:39:35 >>>故障排除日志:上一MQTT订单号缓存列表为2604281937570008636391
2026-04-28 19:39:35 >>>故障排除日志:终端未同步成功订单列表
2026-04-28 19:39:35 开始打印,排队:139,票券:2604281939266006812901,订单:2604281939260058196138,[2026-04-28 19:39:34微信支付12元]
2026-04-28 19:39:35>>>MQTT票号同步场景，创建空订单对象
2026-04-28 19:39:35>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-28 19:39:36 >>>回调事件[910,devices/TL4753]
2026-04-28 19:39:36 >>>故障排除日志:上一MQTT订单号缓存列表为2604281939260058196138
2026-04-28 19:39:36 >>>故障排除日志:终端未同步成功订单列表01392604281939260058196138
已接收过此消息,票券号为2604281939266006812901,排队号为139
2026-04-28 19:39:37 开始打印,排队:140,票券:2604281939291547726901,订单:2604281939290013599612,[2026-04-28 19:39:36微信支付12元]
2026-04-28 19:39:37 开始打印,排队:141,票券:2604281939291548272302,订单:2604281939290013599612,[2026-04-28 19:39:36微信支付12元]
2026-04-28 19:39:37>>>HTTP请求进行中，跳过本次同步
2026-04-28 19:39:41 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604281939266006812901","queue_number":139,"trade_uid":"2604281939260058196138"}]}
2026-04-28 19:39:41 >>>故障排除日志:删除未同步下发订单成功2604281939260058196138
2026-04-28 19:39:41 >>>故障排除日志:终端同步成功后剩余订单列表01402604281939290013599612|01412604281939290013599612
定时检测未同步订单启用[checkOrderNum=536878453]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-28 19:40:01 >>>回调事件[910,devices/TL4753]
2026-04-28 19:40:01 >>>故障排除日志:上一MQTT订单号缓存列表为2604281939260058196138|2604281939290013599612|2604281939290013599612
2026-04-28 19:40:02 >>>故障排除日志:终端未同步成功订单列表01402604281939290013599612|01412604281939290013599612
已接收过此消息,票券号为2604281939291547726901,排队号为140
已接收过此消息,票券号为2604281939291548272302,排队号为141
2026-04-28 19:40:02 开始打印,排队:142,票券:2604281939486144945201,订单:2604281939480059552434,[2026-04-28 19:40:00微信支付12元]
2026-04-28 19:40:02>>>MQTT票号同步场景，创建空订单对象
2026-04-28 19:40:02>>>合并MQTT票号列表到订单同步请求,共3张票
2026-04-28 19:40:04 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604281939291547726901","queue_number":140,"trade_uid":"2604281939290013599612"},{"ticket_no":"2604281939291548272302","queue_number":141,"trade_uid":"2604281939290013599612"},{"ticket_no":"2604281939486144945201","queue_number":142,"trade_uid":"2604281939480059552434"}]}
2026-04-28 19:40:04 >>>故障排除日志:删除未同步下发订单成功2604281939290013599612
2026-04-28 19:40:04 >>>故障排除日志:删除未同步下发订单成功2604281939290013599612
2026-04-28 19:40:04 >>>故障排除日志:删除未同步下发订单成功2604281939480059552434
2026-04-28 19:40:04 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878475]


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


===20:01:38===
2026-04-28 20:00:40>>>cash read=00
2026-04-28 20:00:41>>>cash read=2F29
2026-04-28 20:00:43>>>cash read=3E
2026-04-28 20:00:44>>>cash read=00
2026-04-28 20:00:45>>>cash read=818F41
2026-04-28 20:00:45>>>cash write=02
2026-04-28 20:00:45 >>>回调事件130,cash_status,10022,进钞中...read money=5
2026-04-28 20:00:45>>>cash read=10
2026-04-28 20:00:45 >>>回调事件130,5,10023,finish Money=5,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-28 20:00:47>>>cash write=0C
2026-04-28 20:00:47>>>cash read=3E
2026-04-28 20:00:48>>>cash read=00
2026-04-28 20:00:48>>>cash read=818F41
2026-04-28 20:00:48>>>cash write=02
2026-04-28 20:00:48 >>>回调事件130,cash_status,10022,进钞中...read money=5
2026-04-28 20:00:48>>>cash read=10
2026-04-28 20:00:48 >>>回调事件130,5,10023,finish Money=5,进钞完成
2026-04-28 20:00:50>>>cash write=0C
2026-04-28 20:00:50>>>cash read=3E
2026-04-28 20:00:51>>>cash read=00
2026-04-28 20:00:51>>>cash read=818F40
2026-04-28 20:00:51>>>cash write=02
2026-04-28 20:00:51 >>>回调事件130,cash_status,10022,进钞中...read money=1
2026-04-28 20:00:52>>>cash read=10
2026-04-28 20:00:52 >>>回调事件130,1,10023,finish Money=1,进钞完成
2026-04-28 20:00:53>>>cash write=0C
2026-04-28 20:00:53>>>cash read=3E
2026-04-28 20:00:57>>>cash read=00
2026-04-28 20:00:58>>>cash read=818F40
2026-04-28 20:00:58>>>cash write=02
2026-04-28 20:00:58 >>>回调事件130,cash_status,10022,进钞中...read money=1
2026-04-28 20:00:58>>>cash read=10
2026-04-28 20:00:58 >>>回调事件130,1,10023,finish Money=1,进钞完成
2026-04-28 20:00:58 当前产品价格12元，投币12元，打印小票中...
2026-04-28 20:00:58 >>>开始打印,排队号为144,订单号为2604282000520014753136
2026-04-28 20:00:58>>>订单2604282000520014753136写入成功,剩余空间为1678500,占用RAM为642.48046875
2026-04-28 20:01:01>>>cash write=0C
2026-04-28 20:01:01>>>cash read=3E
删除未同步订单2604282000520014753136
2026-04-28 20:01:02>>>订单2604282000520014753136删除成功,剩余空间为1679000,占用RAM为651.478515625
检测订单目录中>>>
无未同步订单>>>
2026-04-28 20:01:02 >>>当前Ram内存为619.1630859375
定时检测未同步订单启用[checkOrderNum=536878852]


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


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


===20:15:41===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-28 20:15:02 >>>回调事件[910,devices/TL4753]
2026-04-28 20:15:02 >>>故障排除日志:上一MQTT订单号缓存列表为2604282012320027174723
2026-04-28 20:15:02 >>>故障排除日志:终端未同步成功订单列表
2026-04-28 20:15:02 开始打印,排队:147,票券:2604282014530115484601,订单:2604282014520099360929,[2026-04-28 20:15:01微信支付12元]
2026-04-28 20:15:02>>>MQTT票号同步场景，创建空订单对象
2026-04-28 20:15:02>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-28 20:15:04 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604282014530115484601","queue_number":147,"trade_uid":"2604282014520099360929"}]}
2026-04-28 20:15:04 >>>故障排除日志:删除未同步下发订单成功2604282014520099360929
2026-04-28 20:15:04 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536879078]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-28 20:15:07 >>>回调事件[910,devices/TL4753]
2026-04-28 20:15:07 >>>故障排除日志:上一MQTT订单号缓存列表为260428
===20:15:48===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-28 20:15:02 >>>回调事件[910,devices/TL4753]
2026-04-28 20:15:02 >>>故障排除日志:上一MQTT订单号缓存列表为2604282012320027174723
2026-04-28 20:15:02 >>>故障排除日志:终端未同步成功订单列表
2026-04-28 20:15:02 开始打印,排队:147,票券:2604282014530115484601,订单:2604282014520099360929,[2026-04-28 20:15:01微信支付12元]
2026-04-28 20:15:02>>>MQTT票号同步场景，创建空订单对象
2026-04-28 20:15:02>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-28 20:15:04 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604282014530115484601","queue_number":147,"trade_uid":"2604282014520099360929"}]}
2026-04-28 20:15:04 >>>故障排除日志:删除未同步下发订单成功2604282014520099360929
2026-04-28 20:15:04 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536879078]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-28 20:15:07 >>>回调事件[910,devices/TL4753]
2026-04-28 20:15:07 >>>故障排除日志:上一MQTT订单号缓存列表为2604282014520099360929
2026-04-28 20:15:07 >>>故障排除日志:终端未同步成功订单列表
2026-04-28 20:15:07 开始打印,排队:148,票券:2604282014595826423901,订单:2604282014590056133376,[2026-04-28 20:15:07微信支付12元]
2026-04-28 20:15:07>>>MQTT票号同步场景，创建空订单对象
2026-04-28 20:15:07>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-28 20:15:09 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604282014595826423901","queue_number":148,"trade_uid":"2604282014590056133376"}]}
2026-04-28 20:15:09 >>>故障排除日志:删除未同步下发订单成功2604282014590056133376
2026-04-28 20:15:09 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536879085]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-28 20:15:30 >>>回调事件[910,devices/TL4753]
2026-04-28 20:15:30 >>>故障排除日志:上一MQTT订单号缓存列表为2604282014590056133376
2026-04-28 20:15:30 >>>故障排除日志:终端未同步成功订单列表
2026-04-28 20:15:30 开始打印,排队:149,票券:2604282015250874989401,订单:2604282015250006379226,[2026-04-28 20:15:29支付宝支付12元]
2026-04-28 20:15:30>>>MQTT票号同步场景，创建空订单对象
2026-04-28 20:15:30
===20:15:54===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-28 20:15:02 >>>回调事件[910,devices/TL4753]
2026-04-28 20:15:02 >>>故障排除日志:上一MQTT订单号缓存列表为2604282012320027174723
2026-04-28 20:15:02 >>>故障排除日志:终端未同步成功订单列表
2026-04-28 20:15:02 开始打印,排队:147,票券:2604282014530115484601,订单:2604282014520099360929,[2026-04-28 20:15:01微信支付12元]
2026-04-28 20:15:02>>>MQTT票号同步场景，创建空订单对象
2026-04-28 20:15:02>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-28 20:15:04 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604282014530115484601","queue_number":147,"trade_uid":"2604282014520099360929"}]}
2026-04-28 20:15:04 >>>故障排除日志:删除未同步下发订单成功2604282014520099360929
2026-04-28 20:15:04 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536879078]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-28 20:15:07 >>>回调事件[910,devices/TL4753]
2026-04-28 20:15:07 >>>故障排除日志:上一MQTT订单号缓存列表为2604282014520099360929
2026-04-28 20:15:07 >>>故障排除日志:终端未同步成功订单列表
2026-04-28 20:15:07 开始打印,排队:148,票券:2604282014595826423901,订单:2604282014590056133376,[2026-04-28 20:15:07微信支付12元]
2026-04-28 20:15:07>>>MQTT票号同步场景，创建空订单对象
2026-04-28 20:15:07>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-28 20:15:09 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604282014595826423901","queue_number":148,"trade_uid":"2604282014590056133376"}]}
2026-04-28 20:15:09 >>>故障排除日志:删除未同步下发订单成功2604282014590056133376
2026-04-28 20:15:09 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536879085]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-28 20:15:30 >>>回调事件[910,devices/TL4753]
2026-04-28 20:15:30 >>>故障排除日志:上一MQTT订单号缓存列表为2604282014590056133376
2026-04-28 20:15:30 >>>故障排除日志:终端未同步成功订单列表
2026-04-28 20:15:30 开始打印,排队:149,票券:2604282015250874989401,订单:2604282015250006379226,[2026-04-28 20:15:29支付宝支付12元]
2026-04-28 20:15:30>>>MQTT票号同步场景，创建空订单对象
2026-04-28 20:15:30>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-28 20:15:32 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604282015250874989401","queue_number":149,"trade_uid":"2604282015250006379226"}]}
2026-04-28 20:15:32 >>>故障排除日志:删除未同步下发订单成功2604282015250006379226
2026-04-28 20:15:32 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536879103]


TCP://log.tl-self.com:9807@28_20:15:47:send fail
TCP://log.tl-self.com:9807 closed@28_20:15:47
===20:22:55===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-28 20:22:14 >>>回调事件[910,devices/TL4753]
2026-04-28 20:22:14 >>>故障排除日志:上一MQTT订单号缓存列表为2604282015250006379226
2026-04-28 20:22:14 >>>故障排除日志:终端未同步成功订单列表
2026-04-28 20:22:14 开始打印,排队:150,票券:2604282022081185327901,订单:2604282022080010066475,[2026-04-28 20:22:14微信支付12元]
2026-04-28 20:22:14>>>MQTT票号同步场景，创建空订单对象
2026-04-28 20:22:15>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-28 20:22:16 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604282022081185327901","queue_number":150,"trade_uid":"2604282022080010066475"}]}
2026-04-28 20:22:16 >>>故障排除日志:删除未同步下发订单成功2604282022080010066475
2026-04-28 20:22:16 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536879190]


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


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


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


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


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


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


===20:48:03===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-28 20:47:34 >>>回调事件[910,devices/TL4753]
2026-04-28 20:47:34 >>>故障排除日志:上一MQTT订单号缓存列表为2604282036140005233763
2026-04-28 20:47:34 >>>故障排除日志:终端未同步成功订单列表
2026-04-28 20:47:34 开始打印,排队:158,票券:2604282047261596256101,订单:2604282047260014161054,[2026-04-28 20:47:34微信支付12元]
2026-04-28 20:47:35>>>MQTT票号同步场景，创建空订单对象
2026-04-28 20:47:35>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-28 20:47:36 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604282047261596256101","queue_number":158,"trade_uid":"2604282047260014161054"}]}
2026-04-28 20:47:36 >>>故障排除日志:删除未同步下发订单成功2604282047260014161054
2026-04-28 20:47:37 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536879633]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-28 20:47:54 >>>回调事件[910,devices/TL4753]
2026-04-28 20:47:54 >>>故障排除日志:上一MQTT订单号缓存列表为260428
===20:49:04===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-28 20:48:56 >>>回调事件[910,devices/TL4753]
2026-04-28 20:48:56 >>>故障排除日志:上一MQTT订单号缓存列表为2604282047460021029872
2026-04-28 20:48:56 >>>故障排除日志:终端未同步成功订单列表
2026-04-28 20:48:56 开始打印,排队:160,票券:2604282048485951781401,订单:2604282048480057516067,[2026-04-28 20:48:55微信支付12元]
2026-04-28 20:48:56>>>MQTT票号同步场景，创建空订单对象
2026-04-28 20:48:56>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-28 20:48:58 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604282048485951781401","queue_number":160,"trade_uid":"2604282048480057516067"}]}
2026-04-28 20:48:58 >>>故障排除日志:删除未同步下发订单成功2604282048480057516067
2026-04-28 20:48:58 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536879664]


===20:51:04===
2026-04-28 20:50:27>>>cash read=00
2026-04-28 20:50:28>>>cash read=2F29
2026-04-28 20:50:29>>>cash read=3E
2026-04-28 20:50:31>>>cash read=00
2026-04-28 20:50:32>>>cash read=2F29
2026-04-28 20:50:33>>>cash read=3E
2026-04-28 20:50:35>>>cash read=29
2026-04-28 20:50:35 >>>回调事件130,cash_status,20029,退钞中
2026-04-28 20:50:36>>>cash read=2F29
2026-04-28 20:50:37>>>cash read=3E


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


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


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


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


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


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


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


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


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


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