TLClient_JSSCOM_Luat_V3037_RDA8910_RBTTSQRLLSDFT,2.8.7,861714057139903,58963428288912,
poweron reason:0

===07:27:20===
上一时间戳为1778282668
隔日重置时间戳true
隔日清空未同步下发列表true
当前排队号为66,音量为5
初始化产品信息:[{"time_limit_date":null,"ticket_category":"0","expiry_date":90,"product_detail":"小票当日有效，谢谢惠顾，欢迎下次光临","time_limit_status":"0","begin_minute":null,"product_uid":"12565527731040733488","use_timer":1,"old_price":"10","end_hour":null,"sale_price":"10","end_minute":null,"begin_hour":null,"sale_status":1,"product_name":"理发"}]
是否打印二维码设置为1
是否打印紧凑设置为3
当前号显示模式设置为1
当前卡项核销权限设置为0
session_id:b032f****c0dbc
纸币器设置接收纸币范围为36
欢迎使用天羚自助售票系统[2.8.7]
定时检测未同步订单启用[checkOrderNum=536870969]
2026-05-10 07:26:19>>>cash write=30
2026-05-10 07:26:19>>>cash write=02
2026-05-10 07:26:19>>>cash write=3E
2026-05-10 07:26:19>>>cash read=808F808F808F
系统时间初始化成功，时间为202651072619
2026-05-10 07:26:20>>>cash write=02
2026-05-10 07:26:20 >>>剩余flash空间=1288500,占用RAM为787.4833984375
2026-05-10 07:26:20 >>>回调事件:910,subscribe,10000,连接服务器成功

2026-05-10 07:26:21 >>>剩余flash空间=1288500,占用RAM为762.486328125
2026-05-10 07:26:21 >>>回调事件:911,GetMqttQueue,500,暂无需要下发的信息，请求类型：ticket

2026-05-10 07:26:23>>>cash write=0C
2026-05-10 07:26:23>>>cash read=3E
流量卡还有203天过期
2026-05-10 07:26:29 >>>当前Ram内存为784.0830078125
2026-05-10 07:26:44>>>cash read=00
2026-05-10 07:26:44>>>cash read=818F42
2026-05-10 07:26:45>>>cash write=02
2026-05-10 07:26:45 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-05-10 07:26:45>>>cash read=10
2026-05-10 07:26:45 >>>回调事件130,10,10023,finish Money=10,进钞完成
当日首次设置时间戳true为1778369205
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-10 07:26:45 当前产品价格10元，投币10元，打印小票中...
2026-05-10 07:26:45 >>>开始打印,排队号为66,订单号为2605100726450011086100
2026-05-10 07:26:46>>>订单2605100726450011086100写入成功,剩余空间为1286500,占用RAM为770.828125
删除未同步订单2605100726450011086100
2026-05-10 07:26:48>>>订单2605100726450011086100删除成功,剩余空间为1287500,占用RAM为773.53125
检测订单目录中>>>
无未同步订单>>>
2026-05-10 07:26:48 >>>当前Ram内存为743.1025390625
定时检测未同步订单启用[checkOrderNum=536870986]
2026-05-10 07:26:49>>>cash write=0C
2026-05-10 07:26:49>>>cash read=3E


===07:28:20===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-10 07:27:36 >>>回调事件[910,devices/TL1086]
2026-05-10 07:27:36 >>>故障排除日志:上一MQTT订单号缓存列表为2605092051570086571418
2026-05-10 07:27:36 >>>故障排除日志:终端未同步成功订单列表
2026-05-10 07:27:36 开始打印,排队:67,票券:2605100727275520378101,订单:2605100727270051880658,[2026-05-10 07:27:34微信支付10元]
2026-05-10 07:27:36>>>MQTT票号同步场景，创建空订单对象
2026-05-10 07:27:36>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-10 07:27:38 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605100727275520378101","queue_number":67,"trade_uid":"2605100727270051880658"}]}
2026-05-10 07:27:38 >>>故障排除日志:删除未同步下发订单成功2605100727270051880658
2026-05-10 07:27:38 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536871003]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-10 07:27:53 >>>回调事件[910,devices/TL1086]
2026-05-10 07:27:53 >>>故障排除日志:上一MQTT订单号缓存列表为2605100727270051880658
2026-05-10 07:27:53 >>>故障排除日志:终端未同步成功订单列表
2026-05-10 07:27:53 开始打印,排队:68,票券:2605100727443732236101,订单:2605100727440035170485,[2026-05-10 07:27:52微信支付10元]
2026-05-10 07:27:53>>>MQTT票号同步场景，创建空订单对象
2026-05-10 07:27:53>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-10 07:27:55 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605100727443732236101","queue_number":68,"trade_uid":"2605100727440035170485"}]}
2026-05-10 07:27:55 >>>故障排除日志:删除未同步下发订单成功2605100727440035170485
2026-05-10 07:27:55 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536871010]


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


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


===08:06:21===
2026-05-10 08:05:33>>>cash read=00
2026-05-10 08:05:34>>>cash read=818F42
2026-05-10 08:05:34>>>cash write=02
2026-05-10 08:05:34 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-05-10 08:05:34>>>cash read=10
2026-05-10 08:05:34 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-10 08:05:34 当前产品价格10元，投币10元，打印小票中...
2026-05-10 08:05:34 >>>开始打印,排队号为71,订单号为2605100805340011086285
2026-05-10 08:05:35>>>订单2605100805340011086285写入成功,剩余空间为1288000,占用RAM为762.05078125
删除未同步订单2605100805340011086285
2026-05-10 08:05:37>>>订单2605100805340011086285删除成功,剩余空间为1289000,占用RAM为772.2001953125
检测订单目录中>>>
无未同步订单>>>
2026-05-10 08:05:37 >>>当前Ram内存为744.216796875
定时检测未同步订单启用[checkOrderNum=536871376]
2026-05-10 08:05:38>>>cash write=0C
2026-05-10 08:05:38>>>cash read=3E


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


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


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


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


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


===08:33:24===
2026-05-10 08:33:09>>>cash read=2F29
2026-05-10 08:33:10>>>cash read=01
2026-05-10 08:33:11>>>cash read=2F
2026-05-10 08:33:12>>>cash read=29
2026-05-10 08:33:12 >>>回调事件130,cash_status,20029,退钞中
2026-05-10 08:33:13>>>cash read=3E
2026-05-10 08:33:14>>>cash read=00
2026-05-10 08:33:15>>>cash read=01
2026-05-10 08:33:18>>>cash read=3E
2026-05-10 08:33:19>>>cash read=00
2026-05-10 08:33:20>>>cash read=818F42
2026-05-10 08:33:20>>>cash write=02
2026-05-10 08:33:20 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-05-10 08:33:20>>>cash read=10
2026-05-10 08:33:20 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-10 08:33:20 当前产品价格10元，投币10元，打印小票中...
2026-05-10 08:33:20 >>>开始打印,排队号为77,订单号为2605100833200011086521
2026-05-10 08:33:21>>>订单2605100833200011086521写入成功,剩余空间为1288000,占用RAM为764.2060546875


===08:34:24===
删除未同步订单2605100833200011086521
2026-05-10 08:33:23>>>订单2605100833200011086521删除成功,剩余空间为1290000,占用RAM为775.94921875
检测订单目录中>>>
无未同步订单>>>
2026-05-10 08:33:23 >>>当前Ram内存为743.267578125
定时检测未同步订单启用[checkOrderNum=536871672]
2026-05-10 08:33:24>>>cash write=0C
2026-05-10 08:33:24>>>cash read=3E


===08:38:24===
2026-05-10 08:37:55>>>cash read=00
2026-05-10 08:37:56>>>cash read=818F42
2026-05-10 08:37:56>>>cash write=02
2026-05-10 08:37:56 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-05-10 08:37:56>>>cash read=10
2026-05-10 08:37:56 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-10 08:37:56 当前产品价格10元，投币10元，打印小票中...
2026-05-10 08:37:56 >>>开始打印,排队号为78,订单号为2605100837560011086060
2026-05-10 08:37:57>>>订单2605100837560011086060写入成功,剩余空间为1288000,占用RAM为762.6171875
删除未同步订单2605100837560011086060
2026-05-10 08:37:59>>>订单2605100837560011086060删除成功,剩余空间为1289000,占用RAM为772.421875
检测订单目录中>>>
无未同步订单>>>
2026-05-10 08:37:59 >>>当前Ram内存为744.4169921875
定时检测未同步订单启用[checkOrderNum=536871718]
2026-05-10 08:38:00>>>cash write=0C
2026-05-10 08:38:00>>>cash read=3E


===08:40:25===
2026-05-10 08:40:08>>>cash read=00
2026-05-10 08:40:08>>>cash read=818F42
2026-05-10 08:40:08>>>cash write=02
2026-05-10 08:40:08 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-05-10 08:40:09>>>cash read=10
2026-05-10 08:40:09 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-10 08:40:09 当前产品价格10元，投币10元，打印小票中...
2026-05-10 08:40:09 >>>开始打印,排队号为79,订单号为2605100840090011086431
2026-05-10 08:40:09>>>订单2605100840090011086431写入成功,剩余空间为1288000,占用RAM为762.544921875
删除未同步订单2605100840090011086431
2026-05-10 08:40:11>>>订单2605100840090011086431删除成功,剩余空间为1289000,占用RAM为772.392578125
检测订单目录中>>>
无未同步订单>>>
2026-05-10 08:40:11 >>>当前Ram内存为744.44140625
定时检测未同步订单启用[checkOrderNum=536871747]
2026-05-10 08:40:12>>>cash write=0C
2026-05-10 08:40:12>>>cash read=3E


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


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


===09:09:25===
2026-05-10 09:09:13>>>cash read=2F29
2026-05-10 09:09:14>>>cash read=01
2026-05-10 09:09:18>>>cash read=2F
2026-05-10 09:09:19>>>cash read=3E
2026-05-10 09:09:20>>>cash read=00
2026-05-10 09:09:20>>>cash read=2F29
2026-05-10 09:09:22>>>cash read=01
2026-05-10 09:09:22>>>cash read=2F
2026-05-10 09:09:23>>>cash read=3E


===09:10:25===
2026-05-10 09:09:25>>>cash read=00
2026-05-10 09:09:27>>>cash read=29
2026-05-10 09:09:27 >>>回调事件130,cash_status,20029,退钞中
2026-05-10 09:09:27>>>cash read=2F29
2026-05-10 09:09:28>>>cash read=01
2026-05-10 09:09:29>>>cash read=2F
2026-05-10 09:09:31>>>cash read=3E
2026-05-10 09:09:33>>>cash read=00
2026-05-10 09:09:34>>>cash read=292F29
2026-05-10 09:09:34 >>>回调事件130,cash_status,20029,退钞中
2026-05-10 09:09:36>>>cash read=3E
2026-05-10 09:09:38>>>cash read=00
2026-05-10 09:09:39>>>cash read=2F29
2026-05-10 09:09:40>>>cash read=3E
2026-05-10 09:09:45>>>cash read=00
2026-05-10 09:09:46>>>cash read=818F41
2026-05-10 09:09:46>>>cash write=02
2026-05-10 09:09:46 >>>回调事件130,cash_status,10022,进钞中...read money=5
2026-05-10 09:09:46>>>cash read=10
2026-05-10 09:09:46 >>>回调事件130,5,10023,finish Money=5,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-10 09:09:47>>>cash write=0C
2026-05-10 09:09:47>>>cash read=00
2026-05-10 09:09:48>>>cash read=818F41
2026-05-10 09:09:48>>>cash write=02
2026-05-10 09:09:48 >>>回调事件130,cash_status,10022,进钞中...read money=5
2026-05-10 09:09:49>>>cash read=10
2026-05-10 09:09:49 >>>回调事件130,5,10023,finish Money=5,进钞完成
2026-05-10 09:09:49 当前产品价格10元，投币10元，打印小票中...
2026-05-10 09:09:49 >>>开始打印,排队号为82,订单号为2605100909460011086537
2026-05-10 09:09:49>>>订单2605100909460011086537写入成功,剩余空间为1287500,占用RAM为763.814453125
删除未同步订单2605100909460011086537
2026-05-10 09:09:51>>>订单2605100909460011086537删除成功,剩余空间为1288000,占用RAM为775.65625
检测订单目录中>>>
无未同步订单>>>
2026-05-10 09:09:51 >>>当前Ram内存为745.0849609375
定时检测未同步订单启用[checkOrderNum=536872045]
2026-05-10 09:09:52>>>cash write=0C
2026-05-10 09:09:52>>>cash read=3E


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


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


===09:26:26===
2026-05-10 09:25:44>>>cash read=00
2026-05-10 09:25:46>>>cash read=818F42
2026-05-10 09:25:46>>>cash write=02
2026-05-10 09:25:46 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-05-10 09:25:46>>>cash read=10
2026-05-10 09:25:46 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-10 09:25:46 当前产品价格10元，投币10元，打印小票中...
2026-05-10 09:25:46 >>>开始打印,排队号为85,订单号为2605100925460011086352
2026-05-10 09:25:46>>>订单2605100925460011086352写入成功,剩余空间为1288000,占用RAM为759.3916015625
删除未同步订单2605100925460011086352
2026-05-10 09:25:48>>>订单2605100925460011086352删除成功,剩余空间为1289000,占用RAM为773.314453125
检测订单目录中>>>
无未同步订单>>>
2026-05-10 09:25:49 >>>当前Ram内存为743.720703125
定时检测未同步订单启用[checkOrderNum=536872214]
2026-05-10 09:25:50>>>cash write=0C
2026-05-10 09:25:50>>>cash read=3E


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


===10:52:32===
2026-05-10 10:51:31 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605101051211234388901","queue_number":104,"trade_uid":"2605101051210010075128"}]}
2026-05-10 10:51:31 >>>故障排除日志:删除未同步下发订单成功2605101051210010075128
2026-05-10 10:51:31 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536873141]


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


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


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


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


===11:49:35===
2026-05-10 11:49:28>>>cash read=0A
2026-05-10 11:49:30>>>cash read=3E


===11:55:36===
2026-05-10 11:55:00>>>cash read=0A
2026-05-10 11:55:01>>>cash read=3E


===12:10:36===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-10 12:09:45 >>>回调事件[910,devices/TL1086]
2026-05-10 12:09:45 >>>故障排除日志:上一MQTT订单号缓存列表为2605101145390060337128
2026-05-10 12:09:45 >>>故障排除日志:终端未同步成功订单列表
2026-05-10 12:09:45 开始打印,排队:110,票券:2605101209355585176501,订单:2605101209350053365027,[2026-05-10 12:09:44微信支付10元]
2026-05-10 12:09:45>>>MQTT票号同步场景，创建空订单对象
2026-05-10 12:09:45>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-10 12:09:47 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605101209355585176501","queue_number":110,"trade_uid":"2605101209350053365027"}]}
2026-05-10 12:09:47 >>>故障排除日志:删除未同步下发订单成功2605101209350053365027
2026-05-10 12:09:47 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536873892]
2026-05-10 12:10:00>>>cash read=00
2026-05-10 12:10:00>>>cash read=818F42
2026-05-10 12:10:00>>>cash write=02
2026-05-10 12:10:00 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-05-10 12:10:00>>>cash read=10
2026-05-10 12:10:00 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-10 12:10:01 当前产品价格10元，投币10元，打印小票中...
2026-05-10 12:10:01 >>>开始打印,排队号为111,订单号为2605101210010011086018
2026-05-10 12:10:01>>>订单2605101210010011086018写入成功,剩余空间为1287000,占用RAM为766.6318359375
删除未同步订单2605101210010011086018
2026-05-10 12:10:03>>>订单2605101210010011086018删除成功,剩余空间为1288000,占用RAM为772.3662109375
检测订单目录中>>>
无未同步订单>>>
2026-05-10 12:10:03 >>>当前Ram内存为742.7392578125
定时检测未同步订单启用[checkOrderNum=536873902]
2026-05-10 12:10:04>>>cash write=0C
2026-05-10 12:10:04>>>cash read=3E


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


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


===12:34:37===
2026-05-10 12:34:14>>>cash read=00
2026-05-10 12:34:14>>>cash read=818F42
2026-05-10 12:34:14>>>cash write=02
2026-05-10 12:34:14 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-05-10 12:34:15>>>cash write=0C
2026-05-10 12:34:15>>>cash read=00
2026-05-10 12:34:15>>>cash read=10
2026-05-10 12:34:15 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-10 12:34:15 当前产品价格10元，投币10元，打印小票中...
2026-05-10 12:34:15 >>>开始打印,排队号为114,订单号为2605101234150011086768
2026-05-10 12:34:16>>>订单2605101234150011086768写入成功,剩余空间为1288000,占用RAM为775.2548828125
2026-05-10 12:34:17>>>cash read=818F42
2026-05-10 12:34:17>>>cash write=02
2026-05-10 12:34:17 >>>回调事件130,cash_status,10022,进钞中...read money=10
删除未同步订单2605101234150011086768
2026-05-10 12:34:18>>>订单2605101234150011086768删除成功,剩余空间为1289000,占用RAM为756.765625
检测订单目录中>>>
无未同步订单>>>
2026-05-10 12:34:18 >>>当前Ram内存为741.9111328125
定时检测未同步订单启用[checkOrderNum=536874148]
2026-05-10 12:34:18>>>cash read=10
2026-05-10 12:34:18 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-10 12:34:18 当前产品价格10元，投币10元，打印小票中...
2026-05-10 12:34:18 >>>开始打印,排队号为115,订单号为2605101234180011086316
2026-05-10 12:34:18>>>订单2605101234180011086316写入成功,剩余空间为1287000,占用RAM为764.892578125
删除未同步订单2605101234180011086316
2026-05-10 12:34:20>>>订单2605101234180011086316删除成功,剩余空间为1288000,占用RAM为773.416015625
检测订单目录中>>>
无未同步订单>>>
2026-05-10 12:34:21 >>>当前Ram内存为743.74609375
定时检测未同步订单启用[checkOrderNum=536874155]
2026-05-10 12:34:22>>>cash write=0C
2026-05-10 12:34:22>>>cash read=3E


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


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


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


===12:50:38===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-10 12:50:35 >>>回调事件[910,devices/TL1086]
2026-05-10 12:50:35 >>>故障排除日志:上一MQTT订单号缓存列表为2605101247510092547036
2026-05-10 12:50:35 >>>故障排除日志:终端未同步成功订单列表
2026-05-10 12:50:35 开始打印,排队:119,票券:2605101250177082768101,订单:2605101250170068795313,[2026-05-10 12:50:34微信支付10元]
2026-05-10 12:50:35>>>MQTT票号同步场景，创建空订单对象
2026-05-10 12:50:35>>>合并MQTT票号列表到订单同步请求,共1张票


===12:51:39===
2026-05-10 12:50:37 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605101250177082768101","queue_number":119,"trade_uid":"2605101250170068795313"}]}
2026-05-10 12:50:37 >>>故障排除日志:删除未同步下发订单成功2605101250170068795313
2026-05-10 12:50:37 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536874333]


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


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


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


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


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


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


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


===14:30:40===
2026-05-10 14:30:31>>>cash read=00
2026-05-10 14:30:32>>>cash read=818F42
2026-05-10 14:30:32>>>cash write=02
2026-05-10 14:30:32 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-05-10 14:30:33>>>cash read=10
2026-05-10 14:30:33 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-10 14:30:33 当前产品价格10元，投币10元，打印小票中...
2026-05-10 14:30:33 >>>开始打印,排队号为127,订单号为2605101430330011086324
2026-05-10 14:30:33>>>订单2605101430330011086324写入成功,剩余空间为1288000,占用RAM为757.724609375
删除未同步订单2605101430330011086324
2026-05-10 14:30:35>>>订单2605101430330011086324删除成功,剩余空间为1289000,占用RAM为771.1201171875
检测订单目录中>>>
无未同步订单>>>
2026-05-10 14:30:35 >>>当前Ram内存为742.0478515625
定时检测未同步订单启用[checkOrderNum=536875297]
2026-05-10 14:30:36>>>cash write=0C
2026-05-10 14:30:36>>>cash read=3E


===14:40:41===
2026-05-10 14:40:28>>>cash read=0A
2026-05-10 14:40:30>>>cash read=3E


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


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


===14:50:41===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-10 14:50:28 >>>回调事件[910,devices/TL1086]
2026-05-10 14:50:28 >>>故障排除日志:上一MQTT订单号缓存列表为2605101445380077283458
2026-05-10 14:50:28 >>>故障排除日志:终端未同步成功订单列表
2026-05-10 14:50:28 开始打印,排队:130,票券:2605101450224069985201,订单:2605101450220038406843,[2026-05-10 14:50:29微信支付10元]
2026-05-10 14:50:29>>>MQTT票号同步场景，创建空订单对象
2026-05-10 14:50:29>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-10 14:50:31 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605101450224069985201","queue_number":130,"trade_uid":"2605101450220038406843"}]}
2026-05-10 14:50:31 >>>故障排除日志:删除未同步下发订单成功2605101450220038406843
2026-05-10 14:50:31 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536875503]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-10 14:50:36 >>>回调事件[910,devices/TL1086]
2026-05-10 14:50:36 >>>故障排除日志:上一MQTT订单号缓存列表为2605101450220038406843
2026-05-10 14:50:36 >>>故障排除日志:终端未同步成功订单列表
2026-05-10 14:50:36 开始打印,排队:131,票券:2605101450292303536101,订单:2605101450290021205762,[2026-05-10 14:50:36微信支付10元]
2026-05-10 14:50:36 开始打印,排队:132,票券:2605101450292303926402,订单:2605101450290021205762,[2026-05-10 14:50:36微信支付10元]
2026-05-10 14:50:36>>>MQTT票号同步场景，创建空订单对象
2026-05-10 14:50:36>>>合并MQTT票号列表到订单同步请求,共2张票


===14:51:42===
2026-05-10 14:50:40 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605101450292303536101","queue_number":131,"trade_uid":"2605101450290021205762"},{"ticket_no":"2605101450292303926402","queue_number":132,"trade_uid":"2605101450290021205762"}]}
2026-05-10 14:50:40 >>>故障排除日志:删除未同步下发订单成功2605101450290021205762
2026-05-10 14:50:40 >>>故障排除日志:删除未同步下发订单成功2605101450290021205762
2026-05-10 14:50:40 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536875511]


===14:55:42===
2026-05-10 14:55:24>>>cash read=00
2026-05-10 14:55:25>>>cash read=818F43
2026-05-10 14:55:25>>>cash write=02
2026-05-10 14:55:25 >>>回调事件130,cash_status,10022,进钞中...read money=20
2026-05-10 14:55:26>>>cash read=10
2026-05-10 14:55:26 >>>回调事件130,20,10023,finish Money=20,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-10 14:55:26 当前产品价格10元，投币20元，打印小票中...
2026-05-10 14:55:26 >>>开始打印,排队号为133,订单号为2605101455260011086785
2026-05-10 14:55:26 >>>开始打印,排队号为134,订单号为2605101455260011086785
2026-05-10 14:55:26>>>订单2605101455260011086785写入成功,剩余空间为1287500,占用RAM为768.0693359375
删除未同步订单2605101455260011086785
2026-05-10 14:55:30>>>订单2605101455260011086785删除成功,剩余空间为1289000,占用RAM为784.08203125
检测订单目录中>>>
无未同步订单>>>
2026-05-10 14:55:30 >>>当前Ram内存为744.44140625
定时检测未同步订单启用[checkOrderNum=536875565]
2026-05-10 14:55:31>>>cash write=0C
2026-05-10 14:55:31>>>cash read=3E


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


===15:02:42===
2026-05-10 15:02:07>>>cash read=0A
2026-05-10 15:02:08>>>cash read=3E


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


===15:16:43===
2026-05-10 15:15:55>>>cash read=00
2026-05-10 15:15:56>>>cash read=818F42
2026-05-10 15:15:56>>>cash write=02
2026-05-10 15:15:56 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-05-10 15:15:57>>>cash read=10
2026-05-10 15:15:57 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-10 15:15:57 当前产品价格10元，投币10元，打印小票中...
2026-05-10 15:15:57 >>>开始打印,排队号为138,订单号为2605101515570011086076
2026-05-10 15:15:57>>>订单2605101515570011086076写入成功,剩余空间为1288000,占用RAM为760.5234375
删除未同步订单2605101515570011086076
2026-05-10 15:15:59>>>订单2605101515570011086076删除成功,剩余空间为1289000,占用RAM为770.099609375
检测订单目录中>>>
无未同步订单>>>
2026-05-10 15:15:59 >>>当前Ram内存为742.33203125
定时检测未同步订单启用[checkOrderNum=536875778]
2026-05-10 15:16:00>>>cash write=0C
2026-05-10 15:16:00>>>cash read=3E


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


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


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


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


===16:03:44===
2026-05-10 16:03:32>>>cash read=00
2026-05-10 16:03:32>>>cash read=818F42
2026-05-10 16:03:32>>>cash write=02
2026-05-10 16:03:33 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-05-10 16:03:33>>>cash read=10
2026-05-10 16:03:33 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-10 16:03:33 当前产品价格10元，投币10元，打印小票中...
2026-05-10 16:03:33 >>>开始打印,排队号为144,订单号为2605101603330011086147
2026-05-10 16:03:33>>>订单2605101603330011086147写入成功,剩余空间为1288000,占用RAM为757.7314453125
删除未同步订单2605101603330011086147
2026-05-10 16:03:35>>>订单2605101603330011086147删除成功,剩余空间为1289000,占用RAM为771.0927734375
检测订单目录中>>>
无未同步订单>>>
2026-05-10 16:03:35 >>>当前Ram内存为742.037109375
定时检测未同步订单启用[checkOrderNum=536876256]
2026-05-10 16:03:36>>>cash write=0C
2026-05-10 16:03:36>>>cash read=3E


===16:07:45===
2026-05-10 16:07:19>>>cash read=00
2026-05-10 16:07:20>>>cash read=818F42
2026-05-10 16:07:20>>>cash write=02
2026-05-10 16:07:20 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-05-10 16:07:20>>>cash read=10
2026-05-10 16:07:20 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-10 16:07:20 当前产品价格10元，投币10元，打印小票中...
2026-05-10 16:07:20 >>>开始打印,排队号为145,订单号为2605101607200011086555
2026-05-10 16:07:21>>>订单2605101607200011086555写入成功,剩余空间为1288000,占用RAM为758.4169921875
删除未同步订单2605101607200011086555
2026-05-10 16:07:23>>>订单2605101607200011086555删除成功,剩余空间为1289000,占用RAM为769.9375
检测订单目录中>>>
无未同步订单>>>
2026-05-10 16:07:23 >>>当前Ram内存为742.1044921875
定时检测未同步订单启用[checkOrderNum=536876301]
2026-05-10 16:07:24>>>cash write=0C
2026-05-10 16:07:24>>>cash read=3E


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


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


===16:24:45===
2026-05-10 16:24:05>>>cash read=0A
2026-05-10 16:24:07>>>cash read=3E


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


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


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


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


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


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


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


===17:24:49===
2026-05-10 17:24:23>>>cash read=0A
2026-05-10 17:24:24>>>cash read=3E


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


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


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


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


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


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


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


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


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


===18:23:51===
2026-05-10 18:23:21>>>cash read=00
2026-05-10 18:23:21>>>cash read=818F42
2026-05-10 18:23:21>>>cash write=02
2026-05-10 18:23:21 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-05-10 18:23:22>>>cash read=10
2026-05-10 18:23:22 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-10 18:23:22 当前产品价格10元，投币10元，打印小票中...
2026-05-10 18:23:22 >>>开始打印,排队号为164,订单号为2605101823220011086553
2026-05-10 18:23:22>>>订单2605101823220011086553写入成功,剩余空间为1288000,占用RAM为759.7333984375
删除未同步订单2605101823220011086553
2026-05-10 18:23:24>>>订单2605101823220011086553删除成功,剩余空间为1289000,占用RAM为769.68359375
检测订单目录中>>>
无未同步订单>>>
2026-05-10 18:23:24 >>>当前Ram内存为741.890625
定时检测未同步订单启用[checkOrderNum=536877686]
2026-05-10 18:23:25>>>cash write=0C
2026-05-10 18:23:26>>>cash read=3E


===18:25:52===
2026-05-10 18:25:01>>>cash read=00
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-10 18:25:01 >>>回调事件[910,devices/TL1086]
2026-05-10 18:25:01 >>>故障排除日志:上一MQTT订单号缓存列表为2605101817500000215648
2026-05-10 18:25:01 >>>故障排除日志:终端未同步成功订单列表
2026-05-10 18:25:01 开始打印,排队:165,票券:2605101824541595087201,订单:2605101824540013636718,[2026-05-10 18:25:00微信支付10元]
2026-05-10 18:25:01>>>MQTT票号同步场景，创建空订单对象
2026-05-10 18:25:01>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-10 18:25:03>>>cash read=818F42
2026-05-10 18:25:03>>>cash write=02
2026-05-10 18:25:03 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-05-10 18:25:03 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605101824541595087201","queue_number":165,"trade_uid":"2605101824540013636718"}]}
2026-05-10 18:25:03 >>>故障排除日志:删除未同步下发订单成功2605101824540013636718
2026-05-10 18:25:03 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877706]
2026-05-10 18:25:04>>>cash read=10
2026-05-10 18:25:04 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-10 18:25:04 当前产品价格10元，投币10元，打印小票中...
2026-05-10 18:25:04 >>>开始打印,排队号为166,订单号为2605101825040011086990
2026-05-10 18:25:04>>>订单2605101825040011086990写入成功,剩余空间为1287000,占用RAM为765.498046875
删除未同步订单2605101825040011086990
2026-05-10 18:25:06>>>订单2605101825040011086990删除成功,剩余空间为1288000,占用RAM为774.3310546875
检测订单目录中>>>
无未同步订单>>>
2026-05-10 18:25:06 >>>当前Ram内存为744.830078125
定时检测未同步订单启用[checkOrderNum=536877713]
2026-05-10 18:25:07>>>cash write=0C
2026-05-10 18:25:07>>>cash read=3E


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


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


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


===18:41:53===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-10 18:40:55 >>>回调事件[910,devices/TL1086]
2026-05-10 18:40:55 >>>故障排除日志:上一MQTT订单号缓存列表为2605101833320015145336
2026-05-10 18:40:55 >>>故障排除日志:终端未同步成功订单列表
2026-05-10 18:40:55 开始打印,排队:170,票券:2605101840450844874901,订单:2605101840450005840286,[2026-05-10 18:40:55微信支付10元]
2026-05-10 18:40:55>>>MQTT票号同步场景，创建空订单对象
2026-05-10 18:40:55>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-10 18:40:57 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605101840450844874901","queue_number":170,"trade_uid":"2605101840450005840286"}]}
2026-05-10 18:40:57 >>>故障排除日志:删除未同步下发订单成功2605101840450005840286
2026-05-10 18:40:57 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877887]
2026-05-10 18:41:28>>>cash read=00
2026-05-10 18:41:29>>>cash read=01
2026-05-10 18:41:31>>>cash read=3E
2026-05-10 18:41:32>>>cash read=29
2026-05-10 18:41:32 >>>回调事件130,cash_status,20029,退钞中
2026-05-10 18:41:33>>>cash read=01
2026-05-10 18:41:37>>>cash read=00
2026-05-10 18:41:39>>>cash read=29
2026-05-10 18:41:39 >>>回调事件130,cash_status,20029,退钞中
2026-05-10 18:41:39>>>cash read=2F29
2026-05-10 18:41:40>>>cash read=01
2026-05-10 18:41:43>>>cash read=2F
2026-05-10 18:41:44>>>cash read=3E
2026-05-10 18:41:47>>>cash read=00
2026-05-10 18:41:47>>>cash read=818F42
2026-05-10 18:41:47>>>cash write=02
2026-05-10 18:41:47 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-05-10 18:41:48>>>cash read=10
2026-05-10 18:41:48 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-10 18:41:48 当前产品价格10元，投币10元，打印小票中...
2026-05-10 18:41:48 >>>开始打印,排队号为171,订单号为2605101841480011086883
2026-05-10 18:41:48>>>订单2605101841480011086883写入成功,剩余空间为1286500,占用RAM为768.5224609375
删除未同步订单2605101841480011086883
2026-05-10 18:41:50>>>订单2605101841480011086883删除成功,剩余空间为1287500,占用RAM为774.4638671875
检测订单目录中>>>
无未同步订单>>>
2026-05-10 18:41:50 >>>当前Ram内存为743.931640625
定时检测未同步订单启用[checkOrderNum=536877903]


===18:42:53===
2026-05-10 18:41:51>>>cash write=0C
2026-05-10 18:41:51>>>cash read=3E


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


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


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


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


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


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


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


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


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


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


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


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


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


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


===19:55:58===
2026-05-10 19:55:54>>>cash read=00
2026-05-10 19:55:54>>>cash read=818F42
2026-05-10 19:55:54>>>cash write=02
2026-05-10 19:55:54 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-05-10 19:55:54>>>cash read=10
2026-05-10 19:55:54 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-10 19:55:54 当前产品价格10元，投币10元，打印小票中...
2026-05-10 19:55:54 >>>开始打印,排队号为187,订单号为2605101955540011086922
2026-05-10 19:55:55>>>订单2605101955540011086922写入成功,剩余空间为1288000,占用RAM为757.7548828125


===19:56:59===
删除未同步订单2605101955540011086922
2026-05-10 19:55:57>>>订单2605101955540011086922删除成功,剩余空间为1290000,占用RAM为772.7548828125
检测订单目录中>>>
无未同步订单>>>
2026-05-10 19:55:57 >>>当前Ram内存为741.0546875
定时检测未同步订单启用[checkOrderNum=536878693]
2026-05-10 19:55:57>>>cash read=818F42
2026-05-10 19:55:57 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-05-10 19:55:58>>>cash read=10
2026-05-10 19:55:58 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-10 19:55:58 当前产品价格10元，投币10元，打印小票中...
2026-05-10 19:55:58 >>>开始打印,排队号为188,订单号为2605101955580011086732
2026-05-10 19:55:58>>>订单2605101955580011086732写入成功,剩余空间为1288000,占用RAM为761.9599609375
删除未同步订单2605101955580011086732
2026-05-10 19:56:00>>>订单2605101955580011086732删除成功,剩余空间为1289000,占用RAM为770.5966796875
检测订单目录中>>>
无未同步订单>>>
2026-05-10 19:56:00 >>>当前Ram内存为742.3564453125
定时检测未同步订单启用[checkOrderNum=536878701]
2026-05-10 19:56:01>>>cash write=0C
2026-05-10 19:56:02>>>cash read=3E


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


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


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


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


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


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


===21:03:01===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-10 21:02:20 >>>回调事件[910,devices/TL1086]
2026-05-10 21:02:20 >>>故障排除日志:上一MQTT订单号缓存列表为2605102029330097635582
2026-05-10 21:02:20 >>>故障排除日志:终端未同步成功订单列表
2026-05-10 21:02:20 开始打印,排队:196,票券:2605102102151966514701,订单:2605102102150017309996,[2026-05-10 21:02:19支付宝支付10元]
2026-05-10 21:02:20>>>MQTT票号同步场景，创建空订单对象
2026-05-10 21:02:20>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-10 21:02:22 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605102102151966514701","queue_number":196,"trade_uid":"2605102102150017309996"}]}
2026-05-10 21:02:22 >>>故障排除日志:删除未同步下发订单成功2605102102150017309996
2026-05-10 21:02:22 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536879357]
2026-05-10 21:02:53>>>cash read=00
2026-05-10 21:02:54>>>cash read=818F42
2026-05-10 21:02:54>>>cash write=02
2026-05-10 21:02:54 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-05-10 21:02:54>>>cash read=10
2026-05-10 21:02:54 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-10 21:02:54 当前产品价格10元，投币10元，打印小票中...
2026-05-10 21:02:54 >>>开始打印,排队号为197,订单号为2605102102540011086059
2026-05-10 21:02:54>>>订单2605102102540011086059写入成功,剩余空间为1287000,占用RAM为766.3505859375
删除未同步订单2605102102540011086059
2026-05-10 21:02:57>>>订单2605102102540011086059删除成功,剩余空间为1288000,占用RAM为772.2451171875
检测订单目录中>>>
无未同步订单>>>
2026-05-10 21:02:57 >>>当前Ram内存为742.6220703125
定时检测未同步订单启用[checkOrderNum=536879365]
2026-05-10 21:02:58>>>cash write=0C
2026-05-10 21:02:58>>>cash read=3E