TLClient_JSSCOM_LuatOS-Air_V4010_RDA8910_RFTTS_0xe0000,2.8.7,863013071868730,06097702809890,
poweron reason:0

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

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

2026-05-16 09:03:04>>>cash write=0C
流量卡还有197天过期
2026-05-16 09:03:12 >>>当前Ram内存为651.6259765625


===09:07:02===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-16 09:06:57 >>>回调事件[910,devices/TL4880]
当日首次设置时间戳true为1778893617
2026-05-16 09:06:57 >>>故障排除日志:上一MQTT订单号缓存列表为2605152048040024668872
2026-05-16 09:06:57 >>>故障排除日志:终端未同步成功订单列表
2026-05-16 09:06:57 开始打印,排队:1,票券:2605160906459283147301,订单:2605160906450089972162,[2026-05-16 09:06:55微信支付15元]
2026-05-16 09:06:57>>>MQTT票号同步场景，创建空订单对象
2026-05-16 09:06:57>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-16 09:06:59 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605160906459283147301","queue_number":1,"trade_uid":"2605160906450089972162"}]}
2026-05-16 09:06:59 >>>故障排除日志:删除未同步下发订单成功2605160906450089972162
2026-05-16 09:06:59 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536871020]


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


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


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


===09:35:03===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-16 09:34:25 >>>回调事件[910,devices/TL4880]
2026-05-16 09:34:25 >>>故障排除日志:上一MQTT订单号缓存列表为2605160913470045689815
2026-05-16 09:34:25 >>>故障排除日志:终端未同步成功订单列表
2026-05-16 09:34:25 开始打印,排队:5,票券:2605160934209311693201,订单:2605160934200091295738,[2026-05-16 09:34:25微信支付15元]
2026-05-16 09:34:25>>>MQTT票号同步场景，创建空订单对象
2026-05-16 09:34:25>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-16 09:34:27 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605160934209311693201","queue_number":5,"trade_uid":"2605160934200091295738"}]}
2026-05-16 09:34:27 >>>故障排除日志:删除未同步下发订单成功2605160934200091295738
2026-05-16 09:34:27 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536871298]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-16 09:34:44 >>>回调事件[910,devices/TL4880]
2026-05-16 09:34:44 >>>故障排除日志:上一MQTT订单号缓存列表为2605160934200091295738
2026-05-16 09:34:44 >>>故障排除日志:终端未同步成功订单列表
2026-05-16 09:34:44 开始打印,排队:6,票券:2605160934367273045801,订单:2605160934360070745738,[2026-05-16 09:34:44微信支付15元]
2026-05-16 09:34:44>>>MQTT票号同步场景，创建空订单对象
2026-05-16 09:34:45>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-16 09:34:47 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605160934367273045801","queue_number":6,"trade_uid":"2605160934360070745738"}]}
2026-05-16 09:34:47 >>>故障排除日志:删除未同步下发订单成功2605160934360070745738
2026-05-16 09:34:47 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536871304]


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


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


===09:56:05===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-16 09:55:30 >>>回调事件[910,devices/TL4880]
2026-05-16 09:55:30 >>>故障排除日志:上一MQTT订单号缓存列表为2605160945100094560959
2026-05-16 09:55:30 >>>故障排除日志:终端未同步成功订单列表
2026-05-16 09:55:30 开始打印,排队:11,票券:2605160955254023252601,订单:2605160955250038069283,[2026-05-16 09:55:30支付宝支付15元]
2026-05-16 09:55:30>>>MQTT票号同步场景，创建空订单对象
2026-05-16 09:55:30>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-16 09:55:32 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605160955254023252601","queue_number":11,"trade_uid":"2605160955250038069283"}]}
2026-05-16 09:55:32 >>>故障排除日志:删除未同步下发订单成功2605160955250038069283
2026-05-16 09:55:32 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536871527]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-16 09:55:40 >>>回调事件[910,devices/TL4880]
2026-05-16 09:55:40 >>>故障排除日志:上一MQTT订单号缓存列表为2605160955250038069283
2026-05-16 09:55:40 >>>故障排除日志:终端未同步成功订单列表
2026-05-16 09:55:40 开始打印,排队:12,票券:2605160955261282184801,订单:2605160955260010865975,[2026-05-16 09:55:40微信支付15元]
2026-05-16 09:55:40>>>MQTT票号同步场景，创建空订单对象
2026-05-16 09:55:40>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-16 09:55:42 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605160955261282184801","queue_number":12,"trade_uid":"2605160955260010865975"}]}
2026-05-16 09:55:42 >>>故障排除日志:删除未同步下发订单成功2605160955260010865975
2026-05-16 09:55:42 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536871533]


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


===13:31:19===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-16 13:30:27 >>>回调事件[910,devices/TL4880]
2026-05-16 13:30:27 >>>故障排除日志:上一MQTT订单号缓存列表为2605161328470099399147
2026-05-16 13:30:27 >>>故障排除日志:终端未同步成功订单列表
2026-05-16 13:30:27 开始打印,排队:53,票券:2605161330235187821501,订单:2605161330230049977686,[2026-05-16 13:30:27支付宝支付15元]
2026-05-16 13:30:27>>>MQTT票号同步场景，创建空订单对象
2026-05-16 13:30:27>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-16 13:30:29 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605161330235187821501","queue_number":53,"trade_uid":"2605161330230049977686"}]}
2026-05-16 13:30:29 >>>故障排除日志:删除未同步下发订单成功2605161330230049977686
2026-05-16 13:30:29 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536873780]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-16 13:31:11 >>>回调事件[910,devices/TL4880]
2026-05-16 13:31:11 >>>故障排除日志:上一MQTT订单号缓存列表为2605161330230049977686
2026-05-16 13:31:11 >>>故障排除日志:终端未同步成功订单列表
2026-05-16 13:31:11 开始打印,排队:54,票券:2605161331063396934601,订单:2605161331060032047892,[2026-05-16 13:31:11微信支付15元]
2026-05-16 13:31:11>>>MQTT票号同步场景，创建空订单对象
2026-05-16 13:31:11>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-16 13:31:14 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605161331063396934601","queue_number":54,"trade_uid":"2605161331060032047892"}]}
2026-05-16 13:31:14 >>>故障排除日志:删除未同步下发订单成功2605161331060032047892
2026-05-16 13:31:14 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536873795]


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


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


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


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


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


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


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


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


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


===14:25:22===
2026-05-16 14:24:41>>>cash read=00
2026-05-16 14:24:41>>>cash read=818F41
2026-05-16 14:24:41>>>cash write=02
2026-05-16 14:24:41 >>>回调事件130,cash_status,10022,进钞中...read money=5
2026-05-16 14:24:42>>>cash write=0C
2026-05-16 14:24:43>>>cash read=00
2026-05-16 14:24:43>>>cash read=10
2026-05-16 14:24:43 >>>回调事件130,5,10023,finish Money=5,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-16 14:24:44>>>cash read=00
2026-05-16 14:24:44>>>cash read=818F42
2026-05-16 14:24:44>>>cash write=02
2026-05-16 14:24:44 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-05-16 14:24:45>>>cash read=10
2026-05-16 14:24:45 >>>回调事件130,10,10023,finish Money=10,进钞完成
2026-05-16 14:24:45 当前产品价格15元，投币15元，打印小票中...
2026-05-16 14:24:45 >>>开始打印,排队号为64,订单号为2605161424430014880718
2026-05-16 14:24:45>>>订单2605161424430014880718写入成功,剩余空间为1679500,占用RAM为634.1162109375
删除未同步订单2605161424430014880718
2026-05-16 14:24:47>>>订单2605161424430014880718删除成功,剩余空间为1680000,占用RAM为647.099609375
检测订单目录中>>>
无未同步订单>>>
2026-05-16 14:24:47 >>>当前Ram内存为614.740234375
定时检测未同步订单启用[checkOrderNum=536874357]
2026-05-16 14:24:48>>>cash write=0C
2026-05-16 14:24:48>>>cash read=3E


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


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


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


===14:45:24===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-16 14:44:49 >>>回调事件[910,devices/TL4880]
2026-05-16 14:44:49 >>>故障排除日志:上一MQTT订单号缓存列表为2605161435450087232396
2026-05-16 14:44:49 >>>故障排除日志:终端未同步成功订单列表
2026-05-16 14:44:49 开始打印,排队:68,票券:2605161444442818084101,订单:2605161444440026199826,[2026-05-16 14:44:50支付宝支付15元]
2026-05-16 14:44:50>>>MQTT票号同步场景，创建空订单对象
2026-05-16 14:44:50>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-16 14:44:52 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605161444442818084101","queue_number":68,"trade_uid":"2605161444440026199826"}]}
2026-05-16 14:44:52 >>>故障排除日志:删除未同步下发订单成功2605161444440026199826
2026-05-16 14:44:52 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536874569]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-16 14:45:17 >>>回调事件[910,devices/TL4880]
2026-05-16 14:45:17 >>>故障排除日志:上一MQTT订单号缓存列表为2605161444440026199826
2026-05-16 14:45:17 >>>故障排除日志:终端未同步成功订单列表
2026-05-16 14:45:17 开始打印,排队:69,票券:2605161445110845186801,订单:2605161445110006486129,[2026-05-16 14:45:17微信支付15元]
2026-05-16 14:45:17>>>MQTT票号同步场景，创建空订单对象
2026-05-16 14:45:17>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-16 14:45:19 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605161445110845186801","queue_number":69,"trade_uid":"2605161445110006486129"}]}
2026-05-16 14:45:19 >>>故障排除日志:删除未同步下发订单成功2605161445110006486129
2026-05-16 14:45:20 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536874583]


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


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


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


===15:13:25===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-16 15:12:29 >>>回调事件[910,devices/TL4880]
2026-05-16 15:12:29 >>>故障排除日志:上一MQTT订单号缓存列表为2605161504170092815193
2026-05-16 15:12:29 >>>故障排除日志:终端未同步成功订单列表
2026-05-16 15:12:29 开始打印,排队:73,票券:2605161512213340318601,订单:2605161512210031481948,[2026-05-16 15:12:28微信支付15元]
2026-05-16 15:12:29>>>MQTT票号同步场景，创建空订单对象
2026-05-16 15:12:29>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-16 15:12:31 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605161512213340318601","queue_number":73,"trade_uid":"2605161512210031481948"}]}
2026-05-16 15:12:31 >>>故障排除日志:删除未同步下发订单成功2605161512210031481948
2026-05-16 15:12:31 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536874858]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-16 15:12:47 >>>回调事件[910,devices/TL4880]
2026-05-16 15:12:47 >>>故障排除日志:上一MQTT订单号缓存列表为2605161512210031481948
2026-05-16 15:12:47 >>>故障排除日志:终端未同步成功订单列表
2026-05-16 15:12:47 开始打印,排队:74,票券:2605161512368105543501,订单:2605161512360079106774,[2026-05-16 15:12:46微信支付15元]
2026-05-16 15:12:47>>>MQTT票号同步场景，创建空订单对象
2026-05-16 15:12:47>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-16 15:12:49 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605161512368105543501","queue_number":74,"trade_uid":"2605161512360079106774"}]}
2026-05-16 15:12:49 >>>故障排除日志:删除未同步下发订单成功2605161512360079106774
2026-05-16 15:12:49 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536874864]


===15:15:28===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-16 15:15:24 >>>回调事件[910,devices/TL4880]
2026-05-16 15:15:24 >>>故障排除日志:上一MQTT订单号缓存列表为2605161512360079106774
2026-05-16 15:15:24 >>>故障排除日志:终端未同步成功订单列表
2026-05-16 15:15:24 开始打印,排队:75,票券:2605161515183998481201,订单:2605161515180037892593,[2026-05-16 15:15:23微信支付15元]
2026-05-16 15:15:24>>>MQTT票号同步场景，创建空订单对象
2026-05-16 15:15:24>>>合并MQTT票号列表到订单同步请求,共1张票


===15:16:28===
2026-05-16 15:15:26 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605161515183998481201","queue_number":75,"trade_uid":"2605161515180037892593"}]}
2026-05-16 15:15:26 >>>故障排除日志:删除未同步下发订单成功2605161515180037892593
2026-05-16 15:15:26 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536874900]


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


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


===15:21:29===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-16 15:21:07 >>>回调事件[910,devices/TL4880]
2026-05-16 15:21:07 >>>故障排除日志:上一MQTT订单号缓存列表为2605161520160092990618
2026-05-16 15:21:07 >>>故障排除日志:终端未同步成功订单列表
2026-05-16 15:21:07 开始打印,排队:78,票券:2605161521029892118601,订单:2605161521020096972646,[2026-05-16 15:21:07支付宝支付15元]
2026-05-16 15:21:07 开始打印,排队:79,票券:2605161521029892568402,订单:2605161521020096972646,[2026-05-16 15:21:07支付宝支付15元]
2026-05-16 15:21:07>>>MQTT票号同步场景，创建空订单对象
2026-05-16 15:21:07>>>合并MQTT票号列表到订单同步请求,共2张票
2026-05-16 15:21:11 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605161521029892118601","queue_number":78,"trade_uid":"2605161521020096972646"},{"ticket_no":"2605161521029892568402","queue_number":79,"trade_uid":"2605161521020096972646"}]}
2026-05-16 15:21:11 >>>故障排除日志:删除未同步下发订单成功2605161521020096972646
2026-05-16 15:21:11 >>>故障排除日志:删除未同步下发订单成功2605161521020096972646
2026-05-16 15:21:11 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536874978]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-16 15:21:17 >>>回调事件[910,devices/TL4880]
2026-05-16 15:21:17 >>>故障排除日志:上一MQTT订单号缓存列表为2605161521020096972646|2605161521020096972646
2026-05-16 15:21:17 >>>故障排除日志:终端未同步成功订单列表
2026-05-16 15:21:17 开始打印,排队:80,票券:2605161521093931187401,订单:2605161521090036284121,[2026-05-16 15:21:17支付宝支付15元]
2026-05-16 15:21:17>>>MQTT票号同步场景，创建空订单对象
2026-05-16 15:21:17>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-16 15:21:19 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605161521093931187401","queue_number":80,"trade_uid":"2605161521090036284121"}]}
2026-05-16 15:21:19 >>>故障排除日志:删除未同步下发订单成功2605161521090036284121
2026-05-16 15:21:20 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536874984]


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


===16:25:35===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-16 16:24:34 >>>回调事件[910,devices/TL4880]
2026-05-16 16:24:34 >>>故障排除日志:上一MQTT订单号缓存列表为2605161623160051259116
2026-05-16 16:24:34 >>>故障排除日志:终端未同步成功订单列表
2026-05-16 16:24:34 开始打印,排队:98,票券:2605161624276765458701,订单:2605161624270065680527,[2026-05-16 16:24:34微信支付15元]
2026-05-16 16:24:34>>>MQTT票号同步场景，创建空订单对象
2026-05-16 16:24:34>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-16 16:24:36 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605161624276765458701","queue_number":98,"trade_uid":"2605161624270065680527"}]}
2026-05-16 16:24:36 >>>故障排除日志:删除未同步下发订单成功2605161624270065680527
2026-05-16 16:24:36 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536875685]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-16 16:25:02 >>>回调事件[910,devices/TL4880]
2026-05-16 16:25:02 >>>故障排除日志:上一MQTT订单号缓存列表为2605161624270065680527
2026-05-16 16:25:02 >>>故障排除日志:终端未同步成功订单列表
2026-05-16 16:25:02 开始打印,排队:99,票券:2605161624510432039101,订单:2605161624510002279749,[2026-05-16 16:25:02支付宝支付15元]
2026-05-16 16:25:02>>>MQTT票号同步场景，创建空订单对象
2026-05-16 16:25:02>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-16 16:25:04 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605161624510432039101","queue_number":99,"trade_uid":"2605161624510002279749"}]}
2026-05-16 16:25:04 >>>故障排除日志:删除未同步下发订单成功2605161624510002279749
2026-05-16 16:25:04 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536875699]


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


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


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


===16:36:37===
2026-05-16 16:36:12>>>cash read=00
2026-05-16 16:36:13>>>cash read=3E
2026-05-16 16:36:14>>>cash read=00
2026-05-16 16:36:15>>>cash read=818F42
2026-05-16 16:36:15>>>cash write=02
2026-05-16 16:36:15 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-05-16 16:36:15>>>cash read=10
2026-05-16 16:36:15 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-16 16:36:17>>>cash write=0C
2026-05-16 16:36:17>>>cash read=3E
2026-05-16 16:36:19>>>cash read=00
2026-05-16 16:36:20>>>cash read=29
2026-05-16 16:36:20 >>>回调事件130,cash_status,20029,退钞中
2026-05-16 16:36:21>>>cash read=3E


===16:37:37===
2026-05-16 16:36:44>>>cash read=00
2026-05-16 16:36:44>>>cash read=818F41
2026-05-16 16:36:44>>>cash write=02
2026-05-16 16:36:44 >>>回调事件130,cash_status,10022,进钞中...read money=5
2026-05-16 16:36:45>>>cash read=10
2026-05-16 16:36:45 >>>回调事件130,5,10023,finish Money=5,进钞完成
2026-05-16 16:36:45 当前产品价格15元，投币15元，打印小票中...
2026-05-16 16:36:45 >>>开始打印,排队号为103,订单号为2605161636150014880581
2026-05-16 16:36:45>>>订单2605161636150014880581写入成功,剩余空间为1680000,占用RAM为631.662109375
删除未同步订单2605161636150014880581
2026-05-16 16:36:47>>>订单2605161636150014880581删除成功,剩余空间为1680500,占用RAM为645.814453125
检测订单目录中>>>
无未同步订单>>>
2026-05-16 16:36:47 >>>当前Ram内存为615.0576171875
定时检测未同步订单启用[checkOrderNum=536875840]
2026-05-16 16:36:48>>>cash write=0C
2026-05-16 16:36:48>>>cash read=3E
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-16 16:37:26 >>>回调事件[910,devices/TL4880]
2026-05-16 16:37:26 >>>故障排除日志:上一MQTT订单号缓存列表为2605161634270059401856
2026-05-16 16:37:26 >>>故障排除日志:终端未同步成功订单列表
2026-05-16 16:37:26 开始打印,排队:104,票券:2605161637201094646801,订单:2605161637200005340629,[2026-05-16 16:37:25微信支付15元]
2026-05-16 16:37:26>>>MQTT票号同步场景，创建空订单对象
2026-05-16 16:37:26>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-16 16:37:28 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605161637201094646801","queue_number":104,"trade_uid":"2605161637200005340629"}]}
2026-05-16 16:37:28 >>>故障排除日志:删除未同步下发订单成功2605161637200005340629
2026-05-16 16:37:28 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536875854]


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


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


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


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


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


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


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


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


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


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


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


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


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


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


===17:38:44===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-16 17:38:40 >>>回调事件[910,devices/TL4880]
2026-05-16 17:38:40 >>>故障排除日志:上一MQTT订单号缓存列表为2605161733130056027797
2026-05-16 17:38:40 >>>故障排除日志:终端未同步成功订单列表
2026-05-16 17:38:40 开始打印,排队:120,票券:2605161738355073668501,订单:2605161738350048779937,[2026-05-16 17:38:40微信支付15元]
2026-05-16 17:38:41>>>MQTT票号同步场景，创建空订单对象
2026-05-16 17:38:41>>>合并MQTT票号列表到订单同步请求,共1张票


===17:39:44===
2026-05-16 17:38:43 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605161738355073668501","queue_number":120,"trade_uid":"2605161738350048779937"}]}
2026-05-16 17:38:43 >>>故障排除日志:删除未同步下发订单成功2605161738350048779937
2026-05-16 17:38:43 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536876525]


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


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


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


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


===18:15:46===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-16 18:15:10 >>>回调事件[910,devices/TL4880]
2026-05-16 18:15:10 >>>故障排除日志:上一MQTT订单号缓存列表为2605161814230081507965
2026-05-16 18:15:10 >>>故障排除日志:终端未同步成功订单列表
2026-05-16 18:15:10 开始打印,排队:126,票券:2605161815063126756901,订单:2605161815060027582581,[2026-05-16 18:15:09支付宝支付15元]
2026-05-16 18:15:10>>>MQTT票号同步场景，创建空订单对象
2026-05-16 18:15:10>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-16 18:15:12 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605161815063126756901","queue_number":126,"trade_uid":"2605161815060027582581"}]}
2026-05-16 18:15:12 >>>故障排除日志:删除未同步下发订单成功2605161815060027582581
2026-05-16 18:15:12 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536876902]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-16 18:15:35 >>>回调事件[910,devices/TL4880]
2026-05-16 18:15:36 >>>故障排除日志:上一MQTT订单号缓存列表为2605161815060027582581
2026-05-16 18:15:36 >>>故障排除日志:终端未同步成功订单列表
2026-05-16 18:15:36 开始打印,排队:127,票券:2605161815292698948401,订单:2605161815290024614428,[2026-05-16 18:15:35微信支付15元]
2026-05-16 18:15:36>>>MQTT票号同步场景，创建空订单对象
2026-05-16 18:15:36>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-16 18:15:38 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605161815292698948401","queue_number":127,"trade_uid":"2605161815290024614428"}]}
2026-05-16 18:15:38 >>>故障排除日志:删除未同步下发订单成功2605161815290024614428
2026-05-16 18:15:38 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536876909]


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


===18:26:46===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-16 18:26:27 >>>回调事件[910,devices/TL4880]
2026-05-16 18:26:27 >>>故障排除日志:上一MQTT订单号缓存列表为2605161825190071902712
2026-05-16 18:26:27 >>>故障排除日志:终端未同步成功订单列表
2026-05-16 18:26:27 开始打印,排队:129,票券:2605161826088293614501,订单:2605161826080080872931,[2026-05-16 18:26:27微信支付15元]
2026-05-16 18:26:27>>>MQTT票号同步场景，创建空订单对象
2026-05-16 18:26:27>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-16 18:26:29 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605161826088293614501","queue_number":129,"trade_uid":"2605161826080080872931"}]}
2026-05-16 18:26:29 >>>故障排除日志:删除未同步下发订单成功2605161826080080872931
2026-05-16 18:26:29 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877024]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-16 18:26:36 >>>回调事件[910,devices/TL4880]
2026-05-16 18:26:36 >>>故障排除日志:上一MQTT订单号缓存列表为2605161826080080872931
2026-05-16 18:26:36 >>>故障排除日志:终端未同步成功订单列表
2026-05-16 18:26:36 开始打印,排队:130,票券:2605161826304164975201,订单:2605161826300039757343,[2026-05-16 18:26:36微信支付15元]
2026-05-16 18:26:36>>>MQTT票号同步场景，创建空订单对象
2026-05-16 18:26:36>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-16 18:26:38 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605161826304164975201","queue_number":130,"trade_uid":"2605161826300039757343"}]}
2026-05-16 18:26:39 >>>故障排除日志:删除未同步下发订单成功2605161826300039757343
2026-05-16 18:26:39 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877030]


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


===20:16:57===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-16 20:16:19 >>>回调事件[910,devices/TL4880]
2026-05-16 20:16:19 >>>故障排除日志:上一MQTT订单号缓存列表为2605162013220081258298
2026-05-16 20:16:19 >>>故障排除日志:终端未同步成功订单列表
2026-05-16 20:16:19 开始打印,排队:166,票券:2605162016137682501401,订单:2605162016130074984954,[2026-05-16 20:16:19微信支付15元]
2026-05-16 20:16:19>>>MQTT票号同步场景，创建空订单对象
2026-05-16 20:16:19>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-16 20:16:21 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605162016137682501401","queue_number":166,"trade_uid":"2605162016130074984954"}]}
2026-05-16 20:16:21 >>>故障排除日志:删除未同步下发订单成功2605162016130074984954
2026-05-16 20:16:21 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878283]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-16 20:16:49 >>>回调事件[910,devices/TL4880]
2026-05-16 20:16:49 >>>故障排除日志:上一MQTT订单号缓存列表为2605162016130074984954
2026-05-16 20:16:49 >>>故障排除日志:终端未同步成功订单列表
2026-05-16 20:16:49 开始打印,排队:167,票券:2605162016420938131301,订单:2605162016420007151941,[2026-05-16 20:16:49微信支付15元]
2026-05-16 20:16:49>>>MQTT票号同步场景，创建空订单对象
2026-05-16 20:16:49>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-16 20:16:51 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605162016420938131301","queue_number":167,"trade_uid":"2605162016420007151941"}]}
2026-05-16 20:16:51 >>>故障排除日志:删除未同步下发订单成功2605162016420007151941
2026-05-16 20:16:51 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878290]


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


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


===20:21:58===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-16 20:21:49 >>>回调事件[910,devices/TL4880]
2026-05-16 20:21:49 >>>故障排除日志:上一MQTT订单号缓存列表为2605162019390039275776
2026-05-16 20:21:49 >>>故障排除日志:终端未同步成功订单列表
2026-05-16 20:21:49 开始打印,排队:170,票券:2605162021421713307901,订单:2605162021420015250723,[2026-05-16 20:21:48微信支付15元]
2026-05-16 20:21:49 开始打印,排队:171,票券:2605162021421713928502,订单:2605162021420015250723,[2026-05-16 20:21:48微信支付15元]
2026-05-16 20:21:49>>>MQTT票号同步场景，创建空订单对象
2026-05-16 20:21:49>>>合并MQTT票号列表到订单同步请求,共2张票
2026-05-16 20:21:52 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605162021421713307901","queue_number":170,"trade_uid":"2605162021420015250723"},{"ticket_no":"2605162021421713928502","queue_number":171,"trade_uid":"2605162021420015250723"}]}
2026-05-16 20:21:52 >>>故障排除日志:删除未同步下发订单成功2605162021420015250723
2026-05-16 20:21:52 >>>故障排除日志:删除未同步下发订单成功2605162021420015250723
2026-05-16 20:21:53 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878359]


===20:24:00===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-16 20:23:55 >>>回调事件[910,devices/TL4880]
2026-05-16 20:23:55 >>>故障排除日志:上一MQTT订单号缓存列表为2605162021420015250723|2605162021420015250723
2026-05-16 20:23:55 >>>故障排除日志:终端未同步成功订单列表
2026-05-16 20:23:55 开始打印,排队:172,票券:2605162023452948258501,订单:2605162023450027217465,[2026-05-16 20:23:54微信支付15元]
2026-05-16 20:23:55 开始打印,排队:173,票券:2605162023452948605402,订单:2605162023450027217465,[2026-05-16 20:23:54微信支付15元]
2026-05-16 20:23:55>>>MQTT票号同步场景，创建空订单对象
2026-05-16 20:23:55>>>合并MQTT票号列表到订单同步请求,共2张票


===20:25:00===
2026-05-16 20:23:59 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605162023452948258501","queue_number":172,"trade_uid":"2605162023450027217465"},{"ticket_no":"2605162023452948605402","queue_number":173,"trade_uid":"2605162023450027217465"}]}
2026-05-16 20:23:59 >>>故障排除日志:删除未同步下发订单成功2605162023450027217465
2026-05-16 20:23:59 >>>故障排除日志:删除未同步下发订单成功2605162023450027217465
2026-05-16 20:23:59 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878388]


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


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


===20:36:01===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-16 20:35:39 >>>回调事件[910,devices/TL4880]
2026-05-16 20:35:39 >>>故障排除日志:上一MQTT订单号缓存列表为2605162030330049067717
2026-05-16 20:35:39 >>>故障排除日志:终端未同步成功订单列表
2026-05-16 20:35:39 开始打印,排队:176,票券:2605162035326796746401,订单:2605162035320066102639,[2026-05-16 20:35:39支付宝支付15元]
2026-05-16 20:35:39 开始打印,排队:177,票券:2605162035326797096902,订单:2605162035320066102639,[2026-05-16 20:35:39支付宝支付15元]
2026-05-16 20:35:39>>>MQTT票号同步场景，创建空订单对象
2026-05-16 20:35:39>>>合并MQTT票号列表到订单同步请求,共2张票
2026-05-16 20:35:43 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605162035326796746401","queue_number":176,"trade_uid":"2605162035320066102639"},{"ticket_no":"2605162035326797096902","queue_number":177,"trade_uid":"2605162035320066102639"}]}
2026-05-16 20:35:43 >>>故障排除日志:删除未同步下发订单成功2605162035320066102639
2026-05-16 20:35:43 >>>故障排除日志:删除未同步下发订单成功2605162035320066102639
2026-05-16 20:35:43 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878519]


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


===20:41:02===
2026-05-16 20:40:52>>>cash read=00
2026-05-16 20:40:52>>>cash read=818F43
2026-05-16 20:40:52>>>cash write=02
2026-05-16 20:40:52 >>>回调事件130,cash_status,10022,进钞中...read money=20
2026-05-16 20:40:53>>>cash read=10
2026-05-16 20:40:53 >>>回调事件130,20,10023,finish Money=20,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-16 20:40:54>>>cash write=0C
2026-05-16 20:40:54>>>cash read=3E


===20:42:02===
2026-05-16 20:41:09 >>>开始找零打印,排队号为179,订单号为2605162041090014880401
2026-05-16 20:41:09>>>订单2605162041090014880401写入成功,剩余空间为1680500,占用RAM为654.9658203125
删除未同步订单2605162041090014880401
2026-05-16 20:41:11>>>订单2605162041090014880401删除成功,剩余空间为1681500,占用RAM为643.4853515625
检测订单目录中>>>
无未同步订单>>>
2026-05-16 20:41:11 >>>当前Ram内存为613.76171875
定时检测未同步订单启用[checkOrderNum=536878597]


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