TLClient_JSSCOM_LuatOS-Air_V4010_RDA8910_RFTTS_0xe0000,2.8.6,863013071892474,42216079318460,
poweron reason:0

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

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

2026-04-26 09:46:17>>>cash write=0C
2026-04-26 09:46:17>>>cash read=3E
流量卡还有279天过期
2026-04-26 09:46:25 >>>当前Ram内存为668.3583984375


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


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


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


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


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


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


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


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


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


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


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


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


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


===11:33:17===
2026-04-26 11:32:32>>>cash read=0A
2026-04-26 11:32:33>>>cash read=3E


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


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


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


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


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


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


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


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


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


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


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


===12:51:20===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 12:50:38 >>>回调事件[910,devices/TL3968]
2026-04-26 12:50:38 >>>故障排除日志:上一MQTT订单号缓存列表为2604261237480038162282|2604261237480038162282
2026-04-26 12:50:38 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 12:50:38 开始打印,排队:30,票券:2604261250281752108701,订单:2604261250280015618446,[2026-04-26 12:50:36微信支付15元]
2026-04-26 12:50:38>>>MQTT票号同步场景，创建空订单对象
2026-04-26 12:50:38>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 12:50:40 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261250281752108701","queue_number":30,"trade_uid":"2604261250280015618446"}]}
2026-04-26 12:50:40 >>>故障排除日志:删除未同步下发订单成功2604261250280015618446
2026-04-26 12:50:40 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536872930]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 12:51:08 >>>回调事件[910,devices/TL3968]
2026-04-26 12:51:08 >>>故障排除日志:上一MQTT订单号缓存列表为2604261250280015618446
2026-04-26 12:51:08 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 12:51:08 开始打印,排队:31,票券:2604261250568850692301,订单:2604261250560086724794,[2026-04-26 12:51:08支付宝支付15元]
2026-04-26 12:51:08 开始打印,排队:32,票券:2604261250568851242602,订单:2604261250560086724794,[2026-04-26 12:51:08支付宝支付15元]
2026-04-26 12:51:08>>>MQTT票号同步场景，创建空订单对象
2026-04-26 12:51:08>>>合并MQTT票号列表到订单同步请求,共2张票
2026-04-26 12:51:12 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261250568850692301","queue_number":31,"trade_uid":"2604261250560086724794"},{"ticket_no":"2604261250568851242602","queue_number":32,"trade_uid":"2604261250560086724794"}]}
2026-04-26 12:51:12 >>>故障排除日志:删除未同步下发订单成功2604261250560086724794
2026-04-26 12:51:12 >>>故障排除日志:删除未同步下发订单成功2604261250560086724794
2026-04-26 12:51:12 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536872944]


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


===16:04:26===
2026-04-26 16:04:24>>>cash read=0A


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


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


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


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


===16:36:27===
2026-04-26 16:35:48>>>cash read=00
2026-04-26 16:35:49>>>cash read=01
2026-04-26 16:35:52>>>cash read=3E


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


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


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


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


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


===16:51:29===
2026-04-26 16:51:17>>>cash read=0A
2026-04-26 16:51:19>>>cash read=3E


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


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


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


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


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


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


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


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


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


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


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


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


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


===17:51:32===
2026-04-26 17:50:37>>>cash read=29
2026-04-26 17:50:37 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 17:50:38>>>cash read=3E
2026-04-26 17:50:40>>>cash read=00
2026-04-26 17:50:40>>>cash read=818F41
2026-04-26 17:50:40>>>cash write=02
2026-04-26 17:50:40 >>>回调事件130,cash_status,10022,进钞中...read money=5
2026-04-26 17:50:41>>>cash read=10
2026-04-26 17:50:41 >>>回调事件130,5,10023,finish Money=5,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 17:50:42>>>cash write=0C
2026-04-26 17:50:42>>>cash read=3E
2026-04-26 17:50:43>>>cash read=00
2026-04-26 17:50:44>>>cash read=818F42
2026-04-26 17:50:44>>>cash write=02
2026-04-26 17:50:44 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 17:50:45>>>cash read=10
2026-04-26 17:50:45 >>>回调事件130,10,10023,finish Money=10,进钞完成
2026-04-26 17:50:45 当前产品价格15元，投币15元，打印小票中...
2026-04-26 17:50:45 >>>开始打印,排队号为84,订单号为2604261750410013968454
2026-04-26 17:50:45>>>订单2604261750410013968454写入成功,剩余空间为1679000,占用RAM为635.79296875
删除未同步订单2604261750410013968454
2026-04-26 17:50:47>>>订单2604261750410013968454删除成功,剩余空间为1680000,占用RAM为649.2060546875
检测订单目录中>>>
无未同步订单>>>
2026-04-26 17:50:47 >>>当前Ram内存为617.2421875
定时检测未同步订单启用[checkOrderNum=536878986]
2026-04-26 17:50:48>>>cash write=0C
2026-04-26 17:50:48>>>cash read=3E


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


===20:00:41===
2026-04-26 19:59:41>>>cash read=0A
2026-04-26 19:59:42>>>cash read=3E


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


===20:06:41===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 20:05:53 >>>回调事件[910,devices/TL3968]
2026-04-26 20:05:53 >>>故障排除日志:上一MQTT订单号缓存列表为2604262005140080640676
2026-04-26 20:05:53 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 20:05:53 开始打印,排队:120,票券:2604262005452869119301,订单:2604262005450026328813,[2026-04-26 20:05:52微信支付15元]
2026-04-26 20:05:53>>>MQTT票号同步场景，创建空订单对象
2026-04-26 20:05:53>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 20:05:55 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604262005452869119301","queue_number":120,"trade_uid":"2604262005450026328813"}]}
2026-04-26 20:05:55 >>>故障排除日志:删除未同步下发订单成功2604262005450026328813
2026-04-26 20:05:55 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536881675]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 20:06:36 >>>回调事件[910,devices/TL3968]
2026-04-26 20:06:36 >>>故障排除日志:上一MQTT订单号缓存列表为2604262005450026328813
2026-04-26 20:06:36 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 20:06:36 开始打印,排队:121,票券:2604262006284365276101,订单:2604262006280041199059,[2026-04-26 20:06:35微信支付15元]
2026-04-26 20:06:36>>>MQTT票号同步场景，创建空订单对象
2026-04-26 20:06:36>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 20:06:38 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604262006284365276101","queue_number":121,"trade_uid":"2604262006280041199059"}]}
2026-04-26 20:06:38 >>>故障排除日志:删除未同步下发订单成功2604262006280041199059
2026-04-26 20:06:38 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536881702]


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


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


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


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


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


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


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


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


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


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


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


===21:27:44===
2026-04-26 21:27:16>>>cash read=00
2026-04-26 21:27:16>>>cash read=818F41
2026-04-26 21:27:16>>>cash write=02
2026-04-26 21:27:16 >>>回调事件130,cash_status,10022,进钞中...read money=5
2026-04-26 21:27:17>>>cash read=10
2026-04-26 21:27:17 >>>回调事件130,5,10023,finish Money=5,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 21:27:18>>>cash write=0C
2026-04-26 21:27:18>>>cash read=00
2026-04-26 21:27:19>>>cash read=29
2026-04-26 21:27:19 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 21:27:19>>>cash read=2F
2026-04-26 21:27:21>>>cash read=3E
2026-04-26 21:27:22>>>cash read=00
2026-04-26 21:27:24>>>cash read=818F42
2026-04-26 21:27:24>>>cash write=02
2026-04-26 21:27:24 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 21:27:25>>>cash read=10
2026-04-26 21:27:25 >>>回调事件130,10,10023,finish Money=10,进钞完成
2026-04-26 21:27:25 当前产品价格15元，投币15元，打印小票中...
2026-04-26 21:27:25 >>>开始打印,排队号为138,订单号为2604262127170013968484
2026-04-26 21:27:25>>>订单2604262127170013968484写入成功,剩余空间为1679000,占用RAM为634.9296875
删除未同步订单2604262127170013968484
2026-04-26 21:27:27>>>订单2604262127170013968484删除成功,剩余空间为1680000,占用RAM为644.26953125
检测订单目录中>>>
无未同步订单>>>
2026-04-26 21:27:27 >>>当前Ram内存为616.70703125
定时检测未同步订单启用[checkOrderNum=536883649]
2026-04-26 21:27:28>>>cash write=0C
2026-04-26 21:27:28>>>cash read=00
2026-04-26 21:27:28>>>cash read=818F41
2026-04-26 21:27:28>>>cash write=02
2026-04-26 21:27:28 >>>回调事件130,cash_status,10022,进钞中...read money=5
2026-04-26 21:27:29>>>cash read=10
2026-04-26 21:27:29 >>>回调事件130,5,10023,finish Money=5,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 21:27:30>>>cash write=0C
2026-04-26 21:27:30>>>cash read=00
2026-04-26 21:27:31>>>cash read=818F42
2026-04-26 21:27:31>>>cash write=02
2026-04-26 21:27:31 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 21:27:32>>>cash read=10
2026-04-26 21:27:32 >>>回调事件130,10,10023,finish Money=10,进钞完成
2026-04-26 21:27:32 当前产品价格15元，投币15元，打印小票中...
2026-04-26 21:27:32 >>>开始打印,排队号为139,订单号为2604262127290013968253
2026-04-26 21:27:32>>>订单2604262127290013968253写入成功,剩余空间为1678000,占用RAM为642.642578125
删除未同步订单2604262127290013968253
2026-04-26 21:27:34>>>订单2604262127290013968253删除成功,剩余空间为1678500,占用RAM为650.3349609375
检测订单目录中>>>
无未同步订单>>>
2026-04-26 21:27:34 >>>当前Ram内存为619.2158203125
定时检测未同步订单启用[checkOrderNum=536883660]
2026-04-26 21:27:35>>>cash write=0C
2026-04-26 21:27:35>>>cash read=3E