TLClient_JSSCOM_LuatOS-Air_V4010_RDA8910_RFTTS_0xe0000,2.8.6,869701076479974,31297206632602,
poweron reason:0

===08:28:21===
2026-04-25 10:54:20 >>>剩余flash空间=1682000,占用RAM为642.7763671875
2026-04-25 10:54:20 >>>回调异常:911,initSys,30000,nil



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

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

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


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


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


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


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


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


===09:22:23===
2026-04-26 09:22:06>>>cash read=2F29
2026-04-26 09:22:07>>>cash read=01
2026-04-26 09:22:10>>>cash read=2F
2026-04-26 09:22:12>>>cash read=3E
2026-04-26 09:22:15>>>cash read=00
2026-04-26 09:22:15>>>cash read=818F42
2026-04-26 09:22:15>>>cash write=02
2026-04-26 09:22:15 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 09:22:16>>>cash read=10
2026-04-26 09:22:16 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 09:22:17>>>cash write=0C
2026-04-26 09:22:17>>>cash read=3E


===09:23:23===
硬币脉冲事件 msg=1,io=1,上升沿
硬币脉冲事件 msg=2,io=0,下降沿
硬币脉冲事件 msg=1,io=1,上升沿
硬币脉冲事件 msg=2,io=0,下降沿
2026-04-26 09:22:25 >>>回调事件130,1,10023,1个硬币脉冲
硬币脉冲事件 msg=1,io=1,上升沿
硬币脉冲事件 msg=2,io=0,下降沿
硬币脉冲事件 msg=1,io=1,上升沿
硬币脉冲事件 msg=2,io=0,下降沿
2026-04-26 09:22:40 >>>回调事件130,1,10023,1个硬币脉冲
2026-04-26 09:22:40 当前产品价格12元，投币12元，打印小票中...
2026-04-26 09:22:40 >>>开始打印,排队号为9,订单号为2604260922250013882218
2026-04-26 09:22:40>>>订单2604260922250013882218写入成功,剩余空间为1679500,占用RAM为638.298828125
删除未同步订单2604260922250013882218
2026-04-26 09:22:42>>>订单2604260922250013882218删除成功,剩余空间为1680500,占用RAM为645.7392578125
检测订单目录中>>>
无未同步订单>>>
2026-04-26 09:22:43 >>>当前Ram内存为618.9765625
定时检测未同步订单启用[checkOrderNum=536871860]


===09:26:24===
2026-04-26 09:25:51>>>cash read=00
2026-04-26 09:25:51>>>cash read=2F29
2026-04-26 09:25:53>>>cash read=3E
2026-04-26 09:26:01>>>cash read=00
2026-04-26 09:26:02>>>cash read=01
2026-04-26 09:26:03>>>cash read=3E
2026-04-26 09:26:04>>>cash read=00
2026-04-26 09:26:05>>>cash read=2F29
2026-04-26 09:26:06>>>cash read=00
2026-04-26 09:26:07>>>cash read=2F29
2026-04-26 09:26:09>>>cash read=3E
2026-04-26 09:26:15>>>cash read=00
2026-04-26 09:26:16>>>cash read=29
2026-04-26 09:26:16 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 09:26:16>>>cash read=2F29
2026-04-26 09:26:18>>>cash read=3E


===09:27:24===
2026-04-26 09:26:38>>>cash read=00
2026-04-26 09:26:40>>>cash read=29
2026-04-26 09:26:40 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 09:26:40>>>cash read=2F29
2026-04-26 09:26:41>>>cash read=3E
2026-04-26 09:26:55>>>cash read=00
2026-04-26 09:26:56>>>cash read=00818F42
2026-04-26 09:26:56>>>cash write=02
2026-04-26 09:26:56 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 09:26:56>>>cash read=10
2026-04-26 09:26:56 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 09:26:58>>>cash write=0C
2026-04-26 09:26:58>>>cash read=3E
硬币脉冲事件 msg=1,io=1,上升沿
硬币脉冲事件 msg=2,io=0,下降沿
硬币脉冲事件 msg=1,io=1,上升沿
硬币脉冲事件 msg=2,io=0,下降沿
2026-04-26 09:27:00 >>>回调事件130,1,10023,1个硬币脉冲


===09:28:24===
2026-04-26 09:28:01 >>>开始未足额打印,排队号为10,订单号为2604260927000013882730
2026-04-26 09:28:01>>>订单2604260927000013882730写入成功,剩余空间为1680500,占用RAM为645.32421875
删除未同步订单2604260927000013882730
2026-04-26 09:28:02>>>订单2604260927000013882730删除成功,剩余空间为1681500,占用RAM为670.7646484375
检测订单目录中>>>
无未同步订单>>>
2026-04-26 09:28:03 >>>当前Ram内存为617.7177734375
定时检测未同步订单启用[checkOrderNum=536871946]


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


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


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


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


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


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


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


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


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


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


===10:02:27===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 10:02:24 >>>回调事件[910,devices/TL3882]
2026-04-26 10:02:24 >>>故障排除日志:上一MQTT订单号缓存列表为2604260959570012018378|2604260959570012018378
2026-04-26 10:02:24 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 10:02:24 开始打印,排队:23,票券:2604261002182213591701,订单:2604261002180020339378,[2026-04-26 10:02:23支付宝支付12元]
2026-04-26 10:02:24>>>MQTT票号同步场景，创建空订单对象
2026-04-26 10:02:24>>>合并MQTT票号列表到订单同步请求,共1张票


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


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


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


===10:17:28===
2026-04-26 10:17:14>>>cash read=00
2026-04-26 10:17:14>>>cash read=818F42
2026-04-26 10:17:14>>>cash write=02
2026-04-26 10:17:14 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 10:17:15>>>cash read=10
2026-04-26 10:17:15 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
硬币脉冲事件 msg=1,io=1,上升沿
硬币脉冲事件 msg=2,io=0,下降沿
2026-04-26 10:17:16>>>cash write=0C
2026-04-26 10:17:16>>>cash read=3E
硬币脉冲事件 msg=1,io=1,上升沿
硬币脉冲事件 msg=2,io=0,下降沿
2026-04-26 10:17:18 >>>回调事件130,1,10023,1个硬币脉冲


===10:18:28===
硬币脉冲事件 msg=1,io=1,上升沿
硬币脉冲事件 msg=2,io=0,下降沿
硬币脉冲事件 msg=1,io=1,上升沿
硬币脉冲事件 msg=2,io=0,下降沿
2026-04-26 10:18:06 >>>回调事件130,1,10023,1个硬币脉冲
2026-04-26 10:18:06 当前产品价格12元，投币12元，打印小票中...
2026-04-26 10:18:06 >>>开始打印,排队号为28,订单号为2604261017180013882932
2026-04-26 10:18:06>>>订单2604261017180013882932写入成功,剩余空间为1680500,占用RAM为657.6953125
删除未同步订单2604261017180013882932
2026-04-26 10:18:08>>>订单2604261017180013882932删除成功,剩余空间为1680500,占用RAM为647.3115234375
检测订单目录中>>>
无未同步订单>>>
2026-04-26 10:18:08 >>>当前Ram内存为619.537109375
定时检测未同步订单启用[checkOrderNum=536872901]
硬币脉冲事件 msg=1,io=1,上升沿
硬币脉冲事件 msg=2,io=0,下降沿
硬币脉冲事件 msg=1,io=1,上升沿
硬币脉冲事件 msg=2,io=0,下降沿
2026-04-26 10:18:24 >>>回调事件130,1,10023,1个硬币脉冲
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]


===10:19:28===
2026-04-26 10:19:24 >>>开始未足额打印,排队号为29,订单号为2604261018240013882270
2026-04-26 10:19:24>>>订单2604261018240013882270写入成功,剩余空间为1680500,占用RAM为652.7333984375
删除未同步订单2604261018240013882270
2026-04-26 10:19:26>>>订单2604261018240013882270删除成功,剩余空间为1681500,占用RAM为645.4150390625
检测订单目录中>>>
无未同步订单>>>
2026-04-26 10:19:26 >>>当前Ram内存为618.15625
定时检测未同步订单启用[checkOrderNum=536872958]


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


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


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


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


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


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


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


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


===11:05:32===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 11:04:35 收到下发指令:排队号1>>>
2026-04-26 11:04:35 收到下发指令:叫号1>>>
2026-04-26 11:04:42 收到下发指令:排队号1>>>
2026-04-26 11:04:42 收到下发指令:叫号1>>>


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


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


===11:19:33===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 11:19:12 >>>回调事件[910,devices/TL3882]
2026-04-26 11:19:12 >>>故障排除日志:上一MQTT订单号缓存列表为2604261111140010447257
2026-04-26 11:19:12 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 11:19:12 开始打印,排队:42,票券:2604261119010076934801,订单:2604261119000098882394,[2026-04-26 11:19:10微信支付12元]
2026-04-26 11:19:12>>>MQTT票号同步场景，创建空订单对象
2026-04-26 11:19:12>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 11:19:13 >>>回调事件[910,devices/TL3882]
2026-04-26 11:19:13 >>>故障排除日志:上一MQTT订单号缓存列表为2604261119000098882394
2026-04-26 11:19:13 >>>故障排除日志:终端未同步成功订单列表00422604261119000098882394
已接收过此消息,票券号为2604261119010076934801,排队号为42
2026-04-26 11:19:14 开始打印,排队:43,票券:2604261119065137973701,订单:2604261119060049499921,[2026-04-26 11:19:11支付宝支付12元]
2026-04-26 11:19:14>>>HTTP请求进行中，跳过本次同步
2026-04-26 11:19:15 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261119010076934801","queue_number":42,"trade_uid":"2604261119000098882394"}]}
2026-04-26 11:19:15 >>>故障排除日志:删除未同步下发订单成功2604261119000098882394
2026-04-26 11:19:16 >>>故障排除日志:终端同步成功后剩余订单列表00432604261119060049499921
定时检测未同步订单启用[checkOrderNum=536873961]


===11:25:33===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 11:25:12 >>>回调事件[910,devices/TL3882]
2026-04-26 11:25:12 >>>故障排除日志:上一MQTT订单号缓存列表为2604261119000098882394|2604261119060049499921
2026-04-26 11:25:13 >>>故障排除日志:终端未同步成功订单列表00432604261119060049499921
已接收过此消息,票券号为2604261119065137973701,排队号为43
2026-04-26 11:25:13 开始打印,排队:44,票券:2604261125007722405601,订单:2604261125000074442815,[2026-04-26 11:25:12微信支付12元]
2026-04-26 11:25:13>>>MQTT票号同步场景，创建空订单对象
2026-04-26 11:25:13>>>合并MQTT票号列表到订单同步请求,共2张票
2026-04-26 11:25:15 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261119065137973701","queue_number":43,"trade_uid":"2604261119060049499921"},{"ticket_no":"2604261125007722405601","queue_number":44,"trade_uid":"2604261125000074442815"}]}
2026-04-26 11:25:15 >>>故障排除日志:删除未同步下发订单成功2604261119060049499921
2026-04-26 11:25:15 >>>故障排除日志:删除未同步下发订单成功2604261125000074442815
2026-04-26 11:25:15 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536874023]


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


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


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


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


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


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


===12:08:35===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 12:07:42 >>>回调事件[910,devices/TL3882]
2026-04-26 12:07:42 >>>故障排除日志:上一MQTT订单号缓存列表为2604261205070097380167
2026-04-26 12:07:42 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 12:07:42 开始打印,排队:52,票券:2604261207359038109301,订单:2604261207350088482023,[2026-04-26 12:07:41微信支付12元]
2026-04-26 12:07:42 开始打印,排队:53,票券:2604261207359038722402,订单:2604261207350088482023,[2026-04-26 12:07:41微信支付12元]
2026-04-26 12:07:42>>>MQTT票号同步场景，创建空订单对象
2026-04-26 12:07:42>>>合并MQTT票号列表到订单同步请求,共2张票
2026-04-26 12:07:46 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261207359038109301","queue_number":52,"trade_uid":"2604261207350088482023"},{"ticket_no":"2604261207359038722402","queue_number":53,"trade_uid":"2604261207350088482023"}]}
2026-04-26 12:07:46 >>>故障排除日志:删除未同步下发订单成功2604261207350088482023
2026-04-26 12:07:46 >>>故障排除日志:删除未同步下发订单成功2604261207350088482023
2026-04-26 12:07:46 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536874590]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 12:08:13 >>>回调事件[910,devices/TL3882]
2026-04-26 12:08:13 >>>故障排除日志:上一MQTT订单号缓存列表为2604261207350088482023|2604261207350088482023
2026-04-26 12:08:13 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 12:08:13 开始打印,排队:54,票券:2604261208066670418601,订单:2604261208060064786865,[2026-04-26 12:08:12支付宝支付12元]
2026-04-26 12:08:13>>>MQTT票号同步场景，创建空订单对象
2026-04-26 12:08:13>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 12:08:15 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261208066670418601","queue_number":54,"trade_uid":"2604261208060064786865"}]}
2026-04-26 12:08:15 >>>故障排除日志:删除未同步下发订单成功2604261208060064786865
2026-04-26 12:08:15 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536874599]


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


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


===12:19:36===
2026-04-26 12:18:34 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261218249831788201","queue_number":56,"trade_uid":"2604261218240096323286"}]}
2026-04-26 12:18:35 >>>故障排除日志:删除未同步下发订单成功2604261218240096323286
2026-04-26 12:18:35 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536874745]


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


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


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


===12:35:37===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 12:34:53 >>>回调事件[910,devices/TL3882]
2026-04-26 12:34:53 >>>故障排除日志:上一MQTT订单号缓存列表为2604261233230072355691
2026-04-26 12:34:53 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 12:34:53 开始打印,排队:61,票券:2604261234468061626701,订单:2604261234460078411985,[2026-04-26 12:34:52微信支付12元]
2026-04-26 12:34:53>>>MQTT票号同步场景，创建空订单对象
2026-04-26 12:34:53>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 12:34:55 >>>回调事件[910,devices/TL3882]
2026-04-26 12:34:55 >>>故障排除日志:上一MQTT订单号缓存列表为2604261234460078411985
2026-04-26 12:34:55 >>>故障排除日志:终端未同步成功订单列表00612604261234460078411985
已接收过此消息,票券号为2604261234468061626701,排队号为61
2026-04-26 12:34:55 开始打印,排队:62,票券:2604261234474318813501,订单:2604261234470041370757,[2026-04-26 12:34:54微信支付12元]
2026-04-26 12:34:55 开始打印,排队:63,票券:2604261234474319323602,订单:2604261234470041370757,[2026-04-26 12:34:54微信支付12元]
2026-04-26 12:34:55>>>HTTP请求进行中，跳过本次同步
2026-04-26 12:34:58 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261234468061626701","queue_number":61,"trade_uid":"2604261234460078411985"}]}
2026-04-26 12:34:58 >>>故障排除日志:删除未同步下发订单成功2604261234460078411985
2026-04-26 12:34:59 >>>故障排除日志:终端同步成功后剩余订单列表00622604261234470041370757|00632604261234470041370757
定时检测未同步订单启用[checkOrderNum=536874965]


===12:39:37===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 12:39:22 >>>回调事件[910,devices/TL3882]
2026-04-26 12:39:23 >>>故障排除日志:上一MQTT订单号缓存列表为2604261234460078411985|2604261234470041370757|2604261234470041370757
2026-04-26 12:39:23 >>>故障排除日志:终端未同步成功订单列表00622604261234470041370757|00632604261234470041370757
已接收过此消息,票券号为2604261234474318813501,排队号为62
已接收过此消息,票券号为2604261234474319323602,排队号为63
2026-04-26 12:39:23 开始打印,排队:64,票券:2604261239168350042401,订单:2604261239160081443082,[2026-04-26 12:39:21微信支付12元]
2026-04-26 12:39:23>>>MQTT票号同步场景，创建空订单对象
2026-04-26 12:39:23>>>合并MQTT票号列表到订单同步请求,共3张票
2026-04-26 12:39:25 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261234474318813501","queue_number":62,"trade_uid":"2604261234470041370757"},{"ticket_no":"2604261234474319323602","queue_number":63,"trade_uid":"2604261234470041370757"},{"ticket_no":"2604261239168350042401","queue_number":64,"trade_uid":"2604261239160081443082"}]}
2026-04-26 12:39:25 >>>故障排除日志:删除未同步下发订单成功2604261234470041370757
2026-04-26 12:39:25 >>>故障排除日志:删除未同步下发订单成功2604261234470041370757
2026-04-26 12:39:25 >>>故障排除日志:删除未同步下发订单成功2604261239160081443082
2026-04-26 12:39:25 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536875069]


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


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


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


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


===12:58:39===
2026-04-26 12:57:38 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261257279798962901","queue_number":69,"trade_uid":"2604261257270095911686"}]}
2026-04-26 12:57:38 >>>故障排除日志:删除未同步下发订单成功2604261257270095911686
2026-04-26 12:57:38 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536875341]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 12:58:11 >>>回调事件[910,devices/TL3882]
2026-04-26 12:58:11 >>>故障排除日志:上一MQTT订单号缓存列表为2604261257270095911686
2026-04-26 12:58:11 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 12:58:11 开始打印,排队:70,票券:2604261258068131064801,订单:2604261258060079420585,[2026-04-26 12:58:10支付宝支付12元]
2026-04-26 12:58:11>>>MQTT票号同步场景，创建空订单对象
2026-04-26 12:58:11>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 12:58:13 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261258068131064801","queue_number":70,"trade_uid":"2604261258060079420585"}]}
2026-04-26 12:58:13 >>>故障排除日志:删除未同步下发订单成功2604261258060079420585
2026-04-26 12:58:13 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536875350]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 12:58:27 >>>回调事件[910,devices/TL3882]
2026-04-26 12:58:27 >>>故障排除日志:上一MQTT订单号缓存列表为2604261258060079420585
2026-04-26 12:58:27 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 12:58:27 开始打印,排队:71,票券:2604261258208922298201,订单:2604261258200087352428,[2026-04-26 12:58:26支付宝支付12元]
2026-04-26 12:58:27>>>MQTT票号同步场景，创建空订单对象
2026-04-26 12:58:27>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 12:58:29 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261258208922298201","queue_number":71,"trade_uid":"2604261258200087352428"}]}
2026-04-26 12:58:29 >>>故障排除日志:删除未同步下发订单成功2604261258200087352428
2026-04-26 12:58:29 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536875362]


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


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


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


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


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


===13:20:41===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 13:20:07 >>>回调事件[910,devices/TL3882]
2026-04-26 13:20:07 >>>故障排除日志:上一MQTT订单号缓存列表为2604261319040034958213
2026-04-26 13:20:07 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 13:20:07 开始打印,排队:77,票券:2604261320010939654901,订单:2604261320010006832184,[2026-04-26 13:20:06微信支付12元]
2026-04-26 13:20:08>>>MQTT票号同步场景，创建空订单对象
2026-04-26 13:20:08>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 13:20:09 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261320010939654901","queue_number":77,"trade_uid":"2604261320010006832184"}]}
2026-04-26 13:20:09 >>>故障排除日志:删除未同步下发订单成功2604261320010006832184
2026-04-26 13:20:09 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536875742]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 13:20:34 >>>回调事件[910,devices/TL3882]
2026-04-26 13:20:34 >>>故障排除日志:上一MQTT订单号缓存列表为2604261320010006832184
2026-04-26 13:20:34 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 13:20:34 开始打印,排队:78,票券:2604261320262743198401,订单:2604261320260025516326,[2026-04-26 13:20:32微信支付12元]
2026-04-26 13:20:34 开始打印,排队:79,票券:2604261320262743661202,订单:2604261320260025516326,[2026-04-26 13:20:32微信支付12元]
2026-04-26 13:20:34>>>MQTT票号同步场景，创建空订单对象
2026-04-26 13:20:34>>>合并MQTT票号列表到订单同步请求,共2张票
2026-04-26 13:20:37 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261320262743198401","queue_number":78,"trade_uid":"2604261320260025516326"},{"ticket_no":"2604261320262743661202","queue_number":79,"trade_uid":"2604261320260025516326"}]}
2026-04-26 13:20:37 >>>故障排除日志:删除未同步下发订单成功2604261320260025516326
2026-04-26 13:20:37 >>>故障排除日志:删除未同步下发订单成功2604261320260025516326
2026-04-26 13:20:37 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536875757]


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


===13:27:41===
2026-04-26 13:27:40>>>cash read=0A


===13:28:42===
2026-04-26 13:27:41>>>cash read=3E


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


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


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


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


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


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


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


===14:04:44===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 14:03:48 >>>回调事件[910,devices/TL3882]
2026-04-26 14:03:48 >>>故障排除日志:上一MQTT订单号缓存列表为2604261403110060511031
2026-04-26 14:03:48 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 14:03:48 开始打印,排队:89,票券:2604261403424247772401,订单:2604261403420040616067,[2026-04-26 14:03:47微信支付12元]
2026-04-26 14:03:48 开始打印,排队:90,票券:2604261403424248556702,订单:2604261403420040616067,[2026-04-26 14:03:47微信支付12元]
2026-04-26 14:03:48>>>MQTT票号同步场景，创建空订单对象
2026-04-26 14:03:48>>>合并MQTT票号列表到订单同步请求,共2张票
2026-04-26 14:03:52 >>>回调事件[910,devices/TL3882]
2026-04-26 14:03:52 >>>故障排除日志:上一MQTT订单号缓存列表为2604261403420040616067|2604261403420040616067
2026-04-26 14:03:52 >>>故障排除日志:终端未同步成功订单列表00892604261403420040616067|00902604261403420040616067
已接收过此消息,票券号为2604261403424247772401,排队号为89
已接收过此消息,票券号为2604261403424248556702,排队号为90
2026-04-26 14:03:52 开始打印,排队:91,票券:2604261403456102137501,订单:2604261403450059169194,[2026-04-26 14:03:51微信支付12元]
2026-04-26 14:03:52>>>HTTP请求进行中，跳过本次同步
2026-04-26 14:03:54 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261403424247772401","queue_number":89,"trade_uid":"2604261403420040616067"},{"ticket_no":"2604261403424248556702","queue_number":90,"trade_uid":"2604261403420040616067"}]}
2026-04-26 14:03:54 >>>故障排除日志:删除未同步下发订单成功2604261403420040616067
2026-04-26 14:03:54 >>>故障排除日志:删除未同步下发订单成功2604261403420040616067
2026-04-26 14:03:54 >>>故障排除日志:终端同步成功后剩余订单列表00912604261403450059169194
定时检测未同步订单启用[checkOrderNum=536876464]


===14:06:44===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 14:06:06 >>>回调事件[910,devices/TL3882]
2026-04-26 14:06:06 >>>故障排除日志:上一MQTT订单号缓存列表为2604261403420040616067|2604261403420040616067|2604261403450059169194
2026-04-26 14:06:06 >>>故障排除日志:终端未同步成功订单列表00912604261403450059169194
已接收过此消息,票券号为2604261403456102137501,排队号为91
2026-04-26 14:06:06 开始打印,排队:92,票券:2604261405570110338601,订单:2604261405560098688278,[2026-04-26 14:06:05微信支付12元]
2026-04-26 14:06:06>>>MQTT票号同步场景，创建空订单对象
2026-04-26 14:06:06>>>合并MQTT票号列表到订单同步请求,共2张票
2026-04-26 14:06:08 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261403456102137501","queue_number":91,"trade_uid":"2604261403450059169194"},{"ticket_no":"2604261405570110338601","queue_number":92,"trade_uid":"2604261405560098688278"}]}
2026-04-26 14:06:08 >>>故障排除日志:删除未同步下发订单成功2604261403450059169194
2026-04-26 14:06:08 >>>故障排除日志:删除未同步下发订单成功2604261405560098688278
2026-04-26 14:06:08 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536876508]


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


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


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


===14:19:45===
2026-04-26 14:19:25>>>cash read=00
2026-04-26 14:19:26>>>cash read=29
2026-04-26 14:19:26 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 14:19:27>>>cash read=22
2026-04-26 14:19:27 >>>回调事件130,cash_status,30022,卡钞
2026-04-26 14:19:31>>>cash read=3E
2026-04-26 14:19:37>>>cash read=00
2026-04-26 14:19:38>>>cash read=29
2026-04-26 14:19:38 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 14:19:40>>>cash read=22
2026-04-26 14:19:40 >>>回调事件130,cash_status,30022,卡钞
2026-04-26 14:19:41>>>cash read=3E


===14:20:45===
2026-04-26 14:19:53>>>cash read=00
2026-04-26 14:19:53>>>cash read=818F42
2026-04-26 14:19:53>>>cash write=02
2026-04-26 14:19:53 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 14:19:54>>>cash read=10
2026-04-26 14:19:54 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 14:19:55>>>cash write=0C
2026-04-26 14:19:55>>>cash read=3E
硬币脉冲事件 msg=1,io=1,上升沿
硬币脉冲事件 msg=2,io=0,下降沿
硬币脉冲事件 msg=1,io=1,上升沿
硬币脉冲事件 msg=2,io=0,下降沿
2026-04-26 14:19:57 >>>回调事件130,1,10023,1个硬币脉冲
硬币脉冲事件 msg=1,io=1,上升沿
硬币脉冲事件 msg=2,io=0,下降沿
硬币脉冲事件 msg=1,io=1,上升沿
硬币脉冲事件 msg=2,io=0,下降沿
2026-04-26 14:20:34 >>>回调事件130,1,10023,1个硬币脉冲
2026-04-26 14:20:34 当前产品价格12元，投币12元，打印小票中...
2026-04-26 14:20:34 >>>开始打印,排队号为96,订单号为2604261419570013882962
2026-04-26 14:20:35>>>订单2604261419570013882962写入成功,剩余空间为1679000,占用RAM为678.6201171875
删除未同步订单2604261419570013882962
2026-04-26 14:20:37>>>订单2604261419570013882962删除成功,剩余空间为1680000,占用RAM为646.0078125
检测订单目录中>>>
无未同步订单>>>
2026-04-26 14:20:37 >>>当前Ram内存为618.25390625
定时检测未同步订单启用[checkOrderNum=536876753]


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


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


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


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


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


===15:01:48===
硬币脉冲事件 msg=1,io=1,上升沿
硬币脉冲事件 msg=2,io=0,下降沿
硬币脉冲事件 msg=1,io=1,上升沿
硬币脉冲事件 msg=2,io=0,下降沿
2026-04-26 15:01:38 >>>回调事件130,1,10023,1个硬币脉冲
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 15:01:39>>>cash read=00
2026-04-26 15:01:40>>>cash read=818F42
2026-04-26 15:01:40>>>cash write=02
2026-04-26 15:01:40 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 15:01:40>>>cash read=10
2026-04-26 15:01:40 >>>回调事件130,10,10023,finish Money=10,进钞完成
2026-04-26 15:01:41>>>cash write=0C
2026-04-26 15:01:42>>>cash read=3E


===15:02:48===
硬币脉冲事件 msg=1,io=1,上升沿
硬币脉冲事件 msg=2,io=0,下降沿
硬币脉冲事件 msg=1,io=1,上升沿
硬币脉冲事件 msg=2,io=0,下降沿
2026-04-26 15:02:04 >>>回调事件130,1,10023,1个硬币脉冲
2026-04-26 15:02:04 当前产品价格12元，投币12元，打印小票中...
2026-04-26 15:02:04 >>>开始打印,排队号为103,订单号为2604261501400013882177
2026-04-26 15:02:04>>>订单2604261501400013882177写入成功,剩余空间为1680500,占用RAM为645.7861328125
删除未同步订单2604261501400013882177
2026-04-26 15:02:06>>>订单2604261501400013882177删除成功,剩余空间为1680500,占用RAM为643.873046875
检测订单目录中>>>
无未同步订单>>>
2026-04-26 15:02:06 >>>当前Ram内存为617.412109375
定时检测未同步订单启用[checkOrderNum=536877426]


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


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


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


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


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


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


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


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


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


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


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


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


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


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


===15:51:52===
硬币脉冲事件 msg=1,io=1,上升沿
硬币脉冲事件 msg=2,io=0,下降沿
硬币脉冲事件 msg=1,io=1,上升沿
硬币脉冲事件 msg=2,io=0,下降沿
2026-04-26 15:51:26 >>>回调事件130,1,10023,1个硬币脉冲
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 15:51:37>>>cash read=00
2026-04-26 15:51:38>>>cash read=29
2026-04-26 15:51:38 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 15:51:40>>>cash read=01
2026-04-26 15:51:44>>>cash read=3E
2026-04-26 15:51:49>>>cash read=29
2026-04-26 15:51:49 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 15:51:50>>>cash read=01


===15:52:52===
2026-04-26 15:51:52>>>cash read=3E
硬币脉冲事件 msg=1,io=1,上升沿
硬币脉冲事件 msg=2,io=0,下降沿
2026-04-26 15:52:09>>>cash read=29
2026-04-26 15:52:09 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 15:52:09>>>cash read=2F29
2026-04-26 15:52:10>>>cash read=00
2026-04-26 15:52:11>>>cash read=818F42
2026-04-26 15:52:11>>>cash write=02
2026-04-26 15:52:11 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 15:52:12>>>cash read=10
2026-04-26 15:52:12 >>>回调事件130,10,10023,finish Money=10,进钞完成
2026-04-26 15:52:13>>>cash write=0C
2026-04-26 15:52:13>>>cash read=3E
硬币脉冲事件 msg=1,io=1,上升沿
硬币脉冲事件 msg=2,io=0,下降沿
2026-04-26 15:52:15 >>>回调事件130,1,10023,1个硬币脉冲
2026-04-26 15:52:15 当前产品价格12元，投币12元，打印小票中...
2026-04-26 15:52:15 >>>开始打印,排队号为120,订单号为2604261552120013882792
2026-04-26 15:52:15>>>订单2604261552120013882792写入成功,剩余空间为1679500,占用RAM为651.615234375
删除未同步订单2604261552120013882792
2026-04-26 15:52:17>>>订单2604261552120013882792删除成功,剩余空间为1680000,占用RAM为646.5419921875
检测订单目录中>>>
无未同步订单>>>
2026-04-26 15:52:17 >>>当前Ram内存为617.935546875
定时检测未同步订单启用[checkOrderNum=536878161]


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


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


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


===16:01:53===
2026-04-26 16:01:13>>>cash read=00
2026-04-26 16:01:15>>>cash read=01
2026-04-26 16:01:19>>>cash read=3E
2026-04-26 16:01:24>>>cash read=00
2026-04-26 16:01:25>>>cash read=818F41
2026-04-26 16:01:25>>>cash write=02
2026-04-26 16:01:25 >>>回调事件130,cash_status,10022,进钞中...read money=5
2026-04-26 16:01:25>>>cash read=10
2026-04-26 16:01:25 >>>回调事件130,5,10023,finish Money=5,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 16:01:27>>>cash write=0C
2026-04-26 16:01:27>>>cash read=3E
2026-04-26 16:01:29>>>cash read=00
2026-04-26 16:01:30>>>cash read=818F41
2026-04-26 16:01:30>>>cash write=02
2026-04-26 16:01:30 >>>回调事件130,cash_status,10022,进钞中...read money=5
2026-04-26 16:01:30>>>cash read=10
2026-04-26 16:01:30 >>>回调事件130,5,10023,finish Money=5,进钞完成
2026-04-26 16:01:31>>>cash write=0C
硬币脉冲事件 msg=1,io=1,上升沿
硬币脉冲事件 msg=2,io=0,下降沿
2026-04-26 16:01:32>>>cash read=3E
硬币脉冲事件 msg=1,io=1,上升沿
硬币脉冲事件 msg=2,io=0,下降沿
2026-04-26 16:01:33 >>>回调事件130,1,10023,1个硬币脉冲


===16:02:53===
硬币脉冲事件 msg=1,io=1,上升沿
硬币脉冲事件 msg=2,io=0,下降沿
硬币脉冲事件 msg=1,io=1,上升沿
硬币脉冲事件 msg=2,io=0,下降沿
2026-04-26 16:02:10 >>>回调事件130,1,10023,1个硬币脉冲
2026-04-26 16:02:10 当前产品价格12元，投币12元，打印小票中...
2026-04-26 16:02:10 >>>开始打印,排队号为125,订单号为2604261601330013882811
2026-04-26 16:02:11>>>订单2604261601330013882811写入成功,剩余空间为1680500,占用RAM为660.37890625
删除未同步订单2604261601330013882811
2026-04-26 16:02:13>>>订单2604261601330013882811删除成功,剩余空间为1680500,占用RAM为646.8623046875
检测订单目录中>>>
无未同步订单>>>
2026-04-26 16:02:13 >>>当前Ram内存为618.697265625
定时检测未同步订单启用[checkOrderNum=536878364]


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


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


===16:19:54===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 16:18:58 >>>回调事件[910,devices/TL3882]
2026-04-26 16:18:58 >>>故障排除日志:上一MQTT订单号缓存列表为2604261610090053882971
2026-04-26 16:18:58 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 16:18:58 开始打印,排队:128,票券:2604261618442183867401,订单:2604261618440019327092,[2026-04-26 16:18:57微信支付12元]
2026-04-26 16:18:58>>>MQTT票号同步场景，创建空订单对象
2026-04-26 16:18:58>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 16:19:00 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261618442183867401","queue_number":128,"trade_uid":"2604261618440019327092"}]}
2026-04-26 16:19:00 >>>故障排除日志:删除未同步下发订单成功2604261618440019327092
2026-04-26 16:19:00 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878626]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 16:19:43 >>>回调事件[910,devices/TL3882]
2026-04-26 16:19:43 >>>故障排除日志:上一MQTT订单号缓存列表为2604261618440019327092
2026-04-26 16:19:43 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 16:19:43 开始打印,排队:129,票券:2604261619285923654701,订单:2604261619280054116742,[2026-04-26 16:19:36微信支付12元]
2026-04-26 16:19:43>>>MQTT票号同步场景，创建空订单对象
2026-04-26 16:19:43>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 16:19:45 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261619285923654701","queue_number":129,"trade_uid":"2604261619280054116742"}]}
2026-04-26 16:19:45 >>>故障排除日志:删除未同步下发订单成功2604261619280054116742
2026-04-26 16:19:45 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878644]
2026-04-26 16:19:48>>>cash read=2F29
2026-04-26 16:19:50>>>cash read=01
2026-04-26 16:19:52>>>cash read=2F
2026-04-26 16:19:53>>>cash read=3E


===16:20:54===
2026-04-26 16:19:58>>>cash read=00
2026-04-26 16:19:59>>>cash read=818F42
2026-04-26 16:19:59>>>cash write=02
2026-04-26 16:19:59 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 16:19:59>>>cash read=10
2026-04-26 16:19:59 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
硬币脉冲事件 msg=1,io=1,上升沿
硬币脉冲事件 msg=2,io=0,下降沿
2026-04-26 16:20:01>>>cash write=0C
2026-04-26 16:20:01>>>cash read=3E
硬币脉冲事件 msg=1,io=1,上升沿
硬币脉冲事件 msg=2,io=0,下降沿
2026-04-26 16:20:02 >>>回调事件130,1,10023,1个硬币脉冲
硬币脉冲事件 msg=1,io=1,上升沿
硬币脉冲事件 msg=2,io=0,下降沿
硬币脉冲事件 msg=1,io=1,上升沿
硬币脉冲事件 msg=2,io=0,下降沿
2026-04-26 16:20:20 >>>回调事件130,1,10023,1个硬币脉冲
2026-04-26 16:20:20 当前产品价格12元，投币12元，打印小票中...
2026-04-26 16:20:20 >>>开始打印,排队号为130,订单号为2604261620020013882925
2026-04-26 16:20:20>>>订单2604261620020013882925写入成功,剩余空间为1679000,占用RAM为644.998046875
删除未同步订单2604261620020013882925
2026-04-26 16:20:22>>>订单2604261620020013882925删除成功,剩余空间为1680000,占用RAM为650.888671875
检测订单目录中>>>
无未同步订单>>>
2026-04-26 16:20:22 >>>当前Ram内存为617.767578125
定时检测未同步订单启用[checkOrderNum=536878678]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 16:20:47 >>>回调事件[910,devices/TL3882]
2026-04-26 16:20:48 >>>故障排除日志:上一MQTT订单号缓存列表为2604261619280054116742
2026-04-26 16:20:48 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 16:20:48 开始打印,排队:131,票券:2604261620401940284801,订单:2604261620400017630945,[2026-04-26 16:20:46支付宝支付12元]
2026-04-26 16:20:48>>>MQTT票号同步场景，创建空订单对象
2026-04-26 16:20:48>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 16:20:50 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261620401940284801","queue_number":131,"trade_uid":"2604261620400017630945"}]}
2026-04-26 16:20:50 >>>故障排除日志:删除未同步下发订单成功2604261620400017630945
2026-04-26 16:20:50 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878685]


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


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


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


===16:32:55===
2026-04-26 16:32:31>>>cash read=00
2026-04-26 16:32:32>>>cash read=818F42
2026-04-26 16:32:32>>>cash write=02
2026-04-26 16:32:32 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 16:32:32>>>cash read=10
2026-04-26 16:32:33 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 16:32:34>>>cash write=0C
2026-04-26 16:32:34>>>cash read=3E
硬币脉冲事件 msg=1,io=1,上升沿
硬币脉冲事件 msg=2,io=0,下降沿
硬币脉冲事件 msg=1,io=1,上升沿
硬币脉冲事件 msg=2,io=0,下降沿
2026-04-26 16:32:36 >>>回调事件130,1,10023,1个硬币脉冲


===16:33:56===
2026-04-26 16:32:54 >>>开始未足额打印,排队号为135,订单号为2604261632360013882315
2026-04-26 16:32:54 订单投币结束,共投币11元,请取走您的小票
2026-04-26 16:32:54>>>订单2604261632360013882315写入成功,剩余空间为1680500,占用RAM为640.6435546875
删除未同步订单2604261632360013882315
2026-04-26 16:32:56>>>订单2604261632360013882315删除成功,剩余空间为1681500,占用RAM为644.166015625
检测订单目录中>>>
无未同步订单>>>
2026-04-26 16:32:56 >>>当前Ram内存为616.5263671875
定时检测未同步订单启用[checkOrderNum=536878863]


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


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


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


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


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


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


===16:58:57===
2026-04-26 16:58:34>>>cash read=0A
2026-04-26 16:58:35>>>cash read=3E


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


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


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


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


===17:08:00===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 17:07:19 >>>回调事件[910,devices/TL3882]
2026-04-26 17:07:19 >>>故障排除日志:上一MQTT订单号缓存列表为2604261704380064182436
2026-04-26 17:07:19 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 17:07:19 开始打印,排队:146,票券:2604261707113029202401,订单:2604261707110026334465,[2026-04-26 17:07:18微信支付12元]
2026-04-26 17:07:19>>>MQTT票号同步场景，创建空订单对象
2026-04-26 17:07:19>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 17:07:21 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261707113029202401","queue_number":146,"trade_uid":"2604261707110026334465"}]}
2026-04-26 17:07:21 >>>故障排除日志:删除未同步下发订单成功2604261707110026334465
2026-04-26 17:07:21 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536879386]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 17:07:24 >>>回调事件[910,devices/TL3882]
2026-04-26 17:07:24 >>>故障排除日志:上一MQTT订单号缓存列表为2604261707110026334465
2026-04-26 17:07:24 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 17:07:24 开始打印,排队:147,票券:2604261707190024987201,订单:2604261707180098246861,[2026-04-26 17:07:24微信支付12元]
2026-04-26 17:07:24>>>MQTT票号同步场景，创建空订单对象
2026-04-26 17:07:25>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 17:07:26 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261707190024987201","queue_number":147,"trade_uid":"2604261707180098246861"}]}
2026-04-26 17:07:26 >>>故障排除日志:删除未同步下发订单成功2604261707180098246861
2026-04-26 17:07:27 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536879392]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 17:07:34 >>>回调事件[910,devices/TL3882]
2026-04-26 17:07:34 >>>故障排除日志:上一MQTT订单号缓存列表为2604261707180098246861
2026-04-26 17:07:34 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 17:07:34 开始打印,排队:148,票券:2604261707276123042901,订单:2604261707270059143385,[2026-04-26 17:07:34微信支付12元]
2026-04-26 17:07:34 开始打印,排队:149,票券:2604261707276123443102,订单:2604261707270059143385,[2026-04-26 17:07:34微信支付12元]
2026-04-26 17:07:34 开始打印,排队:150,票券:2604261707276123588103,订单:2604261707270059143385,[2026-04-26 17:07:34微信支付12元]
2026-04-26 17:07:34>>>MQTT票号同步场景，创建空订单对象
2026-04-26 17:07:34>>>合并MQTT票号列表到订单同步请求,共3张票
2026-04-26 17:07:40 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261707276123042901","queue_number":148,"trade_uid":"2604261707270059143385"},{"ticket_no":"2604261707276123443102","queue_number":149,"trade_uid":"2604261707270059143385"},{"ticket_no":"2604261707276123588103","queue_number":150,"trade_uid":"2604261707270059143385"}]}
2026-04-26 17:07:40 >>>故障排除日志:删除未同步下发订单成功2604261707270059143385
2026-04-26 17:07:40 >>>故障排除日志:删除未同步下发订单成功2604261707270059143385
2026-04-26 17:07:40 >>>故障排除日志:删除未同步下发订单成功2604261707270059143385
2026-04-26 17:07:40 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536879399]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 17:07:56 >>>回调事件[910,devices/TL3882]
2026-04-26 17:07:56 >>>故障排除日志:上一MQTT订单号缓存列表为2604261707270059143385|2604261707270059143385|2604261707270059143385
2026-04-26 17:07:56 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 17:07:56 开始打印,排队:151,票券:2604261707467172894101,订单:2604261707460069656539,[2026-04-26 17:07:55微信支付12元]
2026-04-26 17:07:57>>>MQTT票号同步场景，创建空订单对象
2026-04-26 17:07:57>>>合并MQTT票号列表到订单同步请求,共1张票


===17:20:01===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 17:19:04 >>>回调事件[910,devices/TL3882]
2026-04-26 17:19:04 >>>故障排除日志:上一MQTT订单号缓存列表为2604261707460069656539
2026-04-26 17:19:04 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 17:19:04 开始打印,排队:152,票券:2604261718580296185901,订单:2604261718580000391981,[2026-04-26 17:19:03支付宝支付12元]
2026-04-26 17:19:04>>>MQTT票号同步场景，创建空订单对象
2026-04-26 17:19:04>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 17:19:06 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261718580296185901","queue_number":152,"trade_uid":"2604261718580000391981"}]}
2026-04-26 17:19:06 >>>故障排除日志:删除未同步下发订单成功2604261718580000391981
2026-04-26 17:19:06 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536879615]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 17:19:37 >>>回调事件[910,devices/TL3882]
2026-04-26 17:19:37 >>>故障排除日志:上一MQTT订单号缓存列表为2604261718580000391981
2026-04-26 17:19:37 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 17:19:37 开始打印,排队:153,票券:2604261719265234815301,订单:2604261719260050506542,[2026-04-26 17:19:36微信支付12元]
2026-04-26 17:19:37>>>MQTT票号同步场景，创建空订单对象
2026-04-26 17:19:37>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 17:19:39 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261719265234815301","queue_number":153,"trade_uid":"2604261719260050506542"}]}
2026-04-26 17:19:39 >>>故障排除日志:删除未同步下发订单成功2604261719260050506542
2026-04-26 17:19:39 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536879631]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 17:19:58 >>>回调事件[910,devices/TL3882]
2026-04-26 17:19:58 >>>故障排除日志:上一MQTT订单号缓存列表为2604261719260050506542
2026-04-26 17:19:58 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 17:19:58 开始打印,排队:154,票券:2604261719522663355601,订单:2604261719520024078385,[2026-04-26 17:19:57微信支付12元]
2026-04-26 17:19:58>>>MQTT票号同步场景，创建空订单对象
2026-04-26 17:19:58>>>合并MQTT票号列表到订单同步请求,共1张票


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


===17:23:03===
2026-04-26 17:22:02 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261721500556016201","queue_number":155,"trade_uid":"2604261721500003758967"}]}
2026-04-26 17:22:02 >>>故障排除日志:删除未同步下发订单成功2604261721500003758967
2026-04-26 17:22:02 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536879678]


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


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


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


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


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


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


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


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


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


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


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


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


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


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


===18:08:08===
2026-04-26 18:07:57>>>cash read=0A
2026-04-26 18:07:58>>>cash read=3E


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


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


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


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


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


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


===18:32:10===
2026-04-26 18:31:09 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261830557594232801","queue_number":177,"trade_uid":"2604261830550074062098"}]}
2026-04-26 18:31:09 >>>故障排除日志:删除未同步下发订单成功2604261830550074062098
2026-04-26 18:31:09 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536881032]


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


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


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


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


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


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


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


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


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


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


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


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


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


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


===19:12:14===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:11:40 >>>回调事件[910,devices/TL3882]
2026-04-26 19:11:40 >>>故障排除日志:上一MQTT订单号缓存列表为2604261906410090593184
2026-04-26 19:11:40 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 19:11:40 开始打印,排队:197,票券:2604261911334701152701,订单:2604261911330044940592,[2026-04-26 19:11:39微信支付12元]
2026-04-26 19:11:40>>>MQTT票号同步场景，创建空订单对象
2026-04-26 19:11:40>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 19:11:42 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261911334701152701","queue_number":197,"trade_uid":"2604261911330044940592"}]}
2026-04-26 19:11:42 >>>故障排除日志:删除未同步下发订单成功2604261911330044940592
2026-04-26 19:11:42 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536881849]
2026-04-26 19:12:01>>>cash read=29
2026-04-26 19:12:01 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 19:12:02>>>cash read=01
2026-04-26 19:12:05>>>cash read=3E


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


===20:45:18===
硬币脉冲事件 msg=1,io=1,上升沿
硬币脉冲事件 msg=2,io=0,下降沿
硬币脉冲事件 msg=1,io=1,上升沿
硬币脉冲事件 msg=2,io=0,下降沿
2026-04-26 20:44:36 >>>回调事件130,1,10023,1个硬币脉冲
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 20:44:42 >>>开始未足额打印,排队号为220,订单号为2604262044360013882431
2026-04-26 20:44:42 订单投币结束,共投币1元,请取走您的小票
2026-04-26 20:44:42>>>订单2604262044360013882431写入成功,剩余空间为1680000,占用RAM为677.6142578125
硬币脉冲事件 msg=1,io=1,上升沿
删除未同步订单2604262044360013882431
2026-04-26 20:44:44>>>订单2604262044360013882431删除成功,剩余空间为1680500,占用RAM为650.0986328125
检测订单目录中>>>
无未同步订单>>>
2026-04-26 20:44:44 >>>当前Ram内存为618.1142578125
定时检测未同步订单启用[checkOrderNum=536883705]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 20:45:09 收到下发指令:排队号1>>>
2026-04-26 20:45:09 收到下发指令:叫号1>>>
硬币脉冲事件 msg=2,io=0,下降沿


===20:46:18===
2026-04-26 20:45:20 收到下发指令:排队号1>>>
2026-04-26 20:45:20 收到下发指令:叫号1>>>


===20:49:18===
硬币脉冲事件 msg=1,io=1,上升沿
硬币脉冲事件 msg=2,io=0,下降沿
硬币脉冲事件 msg=1,io=1,上升沿
2026-04-26 20:48:52 >>>回调事件130,1,10023,2个硬币脉冲
硬币脉冲事件 msg=2,io=0,下降沿
硬币脉冲事件 msg=1,io=1,上升沿
硬币脉冲事件 msg=2,io=0,下降沿
2026-04-26 20:48:55 >>>回调事件130,1,10023,1个硬币脉冲
硬币脉冲事件 msg=1,io=1,上升沿
硬币脉冲事件 msg=2,io=0,下降沿
硬币脉冲事件 msg=1,io=1,上升沿
硬币脉冲事件 msg=2,io=0,下降沿
2026-04-26 20:49:01 >>>回调事件130,1,10023,1个硬币脉冲
硬币脉冲事件 msg=1,io=1,上升沿
硬币脉冲事件 msg=2,io=0,下降沿


===20:50:18===
2026-04-26 20:49:32 >>>开始未足额打印,排队号为221,订单号为2604262049010013882590
2026-04-26 20:49:32 订单投币结束,共投币3元,请取走您的小票
2026-04-26 20:49:32>>>订单2604262049010013882590写入成功,剩余空间为1680500,占用RAM为668.5751953125
删除未同步订单2604262049010013882590
2026-04-26 20:49:34>>>订单2604262049010013882590删除成功,剩余空间为1681500,占用RAM为644.4189453125
检测订单目录中>>>
无未同步订单>>>
2026-04-26 20:49:34 >>>当前Ram内存为616.6015625
定时检测未同步订单启用[checkOrderNum=536883808]


===20:51:19===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 20:50:43 收到下发指令:排队号1>>>
2026-04-26 20:50:43 收到下发指令:叫号1>>>