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

===07:38:11===
上一时间戳为1779147584
隔日重置时间戳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:0d0a5****1d821
纸币器设置接收纸币范围为36
欢迎使用天羚自助售票系统[2.8.7]
定时检测未同步订单启用[checkOrderNum=536870969]
2026-05-20 07:37:11>>>cash write=30
2026-05-20 07:37:11>>>cash write=02
2026-05-20 07:37:11>>>cash write=3E
2026-05-20 07:37:11>>>cash read=808F808F808F
系统时间初始化成功，时间为202652073711
2026-05-20 07:37:12>>>cash write=02
2026-05-20 07:37:12 >>>剩余flash空间=1288500,占用RAM为783.0810546875
2026-05-20 07:37:12 >>>回调事件:910,subscribe,10000,连接服务器成功

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

2026-05-20 07:37:15>>>cash write=0C
2026-05-20 07:37:15>>>cash read=3E
流量卡还有193天过期
2026-05-20 07:37:21 >>>当前Ram内存为787.07421875


===07:43:12===
2026-05-20 07:42:47>>>cash read=00
2026-05-20 07:42:47>>>cash read=818F42
2026-05-20 07:42:47>>>cash write=02
2026-05-20 07:42:47 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-05-20 07:42:47>>>cash read=10
2026-05-20 07:42:47 >>>回调事件130,10,10023,finish Money=10,进钞完成
当日首次设置时间戳true为1779234167
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-20 07:42:47 当前产品价格10元，投币10元，打印小票中...
2026-05-20 07:42:47 >>>开始打印,排队号为66,订单号为2605200742470011086953
2026-05-20 07:42:48>>>订单2605200742470011086953写入成功,剩余空间为1288000,占用RAM为760.3251953125
删除未同步订单2605200742470011086953
2026-05-20 07:42:50>>>订单2605200742470011086953删除成功,剩余空间为1289000,占用RAM为771.943359375
检测订单目录中>>>
无未同步订单>>>
2026-05-20 07:42:50 >>>当前Ram内存为742.908203125
定时检测未同步订单启用[checkOrderNum=536871034]
2026-05-20 07:42:51>>>cash write=0C
2026-05-20 07:42:51>>>cash read=3E


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


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


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


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


===08:37:14===
2026-05-20 08:37:04>>>cash read=00
2026-05-20 08:37:04>>>cash read=818F43
2026-05-20 08:37:04>>>cash write=02
2026-05-20 08:37:05 >>>回调事件130,cash_status,10022,进钞中...read money=20
2026-05-20 08:37:05>>>cash read=10
2026-05-20 08:37:05 >>>回调事件130,20,10023,finish Money=20,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-20 08:37:05 当前产品价格10元，投币20元，打印小票中...
2026-05-20 08:37:05 >>>开始打印,排队号为71,订单号为2605200837050011086621
2026-05-20 08:37:05 >>>开始打印,排队号为72,订单号为2605200837050011086621
2026-05-20 08:37:06>>>订单2605200837050011086621写入成功,剩余空间为1287500,占用RAM为768.9287109375
删除未同步订单2605200837050011086621
2026-05-20 08:37:09>>>订单2605200837050011086621删除成功,剩余空间为1289000,占用RAM为790.4609375
检测订单目录中>>>
无未同步订单>>>
2026-05-20 08:37:09 >>>当前Ram内存为744.580078125
定时检测未同步订单启用[checkOrderNum=536871568]
2026-05-20 08:37:10>>>cash write=0C
2026-05-20 08:37:10>>>cash read=3E
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-20 08:37:11 >>>回调事件[910,devices/TL1086]
2026-05-20 08:37:11 >>>故障排除日志:上一MQTT订单号缓存列表为2605200817490050233448
2026-05-20 08:37:11 >>>故障排除日志:终端未同步成功订单列表
2026-05-20 08:37:11 开始打印,排队:73,票券:2605200837028528385401,订单:2605200837020083450263,[2026-05-20 08:37:10微信支付10元]
2026-05-20 08:37:11>>>MQTT票号同步场景，创建空订单对象
2026-05-20 08:37:11>>>合并MQTT票号列表到订单同步请求,共1张票


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


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


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


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


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


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


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


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


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


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


===09:58:19===
2026-05-20 09:57:17 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605200956597273296501","queue_number":84,"trade_uid":"2605200956590070772321"}]}
2026-05-20 09:57:17 >>>故障排除日志:删除未同步下发订单成功2605200956590070772321
2026-05-20 09:57:18 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536872386]


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


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


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


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


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


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


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


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


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


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


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


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


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


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


===11:27:22===
2026-05-20 11:26:21>>>cash read=3E


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


===14:37:28===
2026-05-20 14:36:32>>>cash read=9E
2026-05-20 14:36:34>>>cash read=3E


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


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


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


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


===15:06:29===
2026-05-20 15:05:43>>>cash read=00
2026-05-20 15:05:44>>>cash read=818F42
2026-05-20 15:05:44>>>cash write=02
2026-05-20 15:05:44 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-05-20 15:05:45>>>cash read=10
2026-05-20 15:05:45 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-20 15:05:45 当前产品价格10元，投币10元，打印小票中...
2026-05-20 15:05:45 >>>开始打印,排队号为122,订单号为2605201505450011086691
2026-05-20 15:05:45>>>订单2605201505450011086691写入成功,剩余空间为1288000,占用RAM为761.71484375
删除未同步订单2605201505450011086691
2026-05-20 15:05:47>>>订单2605201505450011086691删除成功,剩余空间为1289000,占用RAM为772.5703125
检测订单目录中>>>
无未同步订单>>>
2026-05-20 15:05:47 >>>当前Ram内存为743.53125
定时检测未同步订单启用[checkOrderNum=536875470]
2026-05-20 15:05:48>>>cash write=0C
2026-05-20 15:05:48>>>cash read=3E


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


===15:10:29===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-20 15:09:51 >>>回调事件[910,devices/TL1086]
2026-05-20 15:09:51 >>>故障排除日志:上一MQTT订单号缓存列表为2605201459040099467836
2026-05-20 15:09:51 >>>故障排除日志:终端未同步成功订单列表
2026-05-20 15:09:51 开始打印,排队:124,票券:2605201509439327266401,订单:2605201509430091397761,[2026-05-20 15:09:50微信支付10元]
2026-05-20 15:09:51>>>MQTT票号同步场景，创建空订单对象
2026-05-20 15:09:51>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-20 15:09:53 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605201509439327266401","queue_number":124,"trade_uid":"2605201509430091397761"}]}
2026-05-20 15:09:53 >>>故障排除日志:删除未同步下发订单成功2605201509430091397761
2026-05-20 15:09:53 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536875523]
2026-05-20 15:10:15>>>cash read=00
2026-05-20 15:10:16>>>cash read=29
2026-05-20 15:10:16 >>>回调事件130,cash_status,20029,退钞中
2026-05-20 15:10:17>>>cash read=3E


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


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


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


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


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


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


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


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


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


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


===16:46:34===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-20 16:46:27 >>>回调事件[910,devices/TL1086]
2026-05-20 16:46:27 >>>故障排除日志:上一MQTT订单号缓存列表为2605201638370032488438
2026-05-20 16:46:27 >>>故障排除日志:终端未同步成功订单列表
2026-05-20 16:46:27 开始打印,排队:135,票券:2605201645583498064201,订单:2605201645580033172565,[2026-05-20 16:46:27微信支付10元]
2026-05-20 16:46:27 开始打印,排队:136,票券:2605201645583498521302,订单:2605201645580033172565,[2026-05-20 16:46:27微信支付10元]
2026-05-20 16:46:27 开始打印,排队:137,票券:2605201645583498665103,订单:2605201645580033172565,[2026-05-20 16:46:27微信支付10元]
2026-05-20 16:46:28>>>MQTT票号同步场景，创建空订单对象
2026-05-20 16:46:28>>>合并MQTT票号列表到订单同步请求,共3张票


===16:47:34===
2026-05-20 16:46:33 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605201645583498064201","queue_number":135,"trade_uid":"2605201645580033172565"},{"ticket_no":"2605201645583498521302","queue_number":136,"trade_uid":"2605201645580033172565"},{"ticket_no":"2605201645583498665103","queue_number":137,"trade_uid":"2605201645580033172565"}]}
2026-05-20 16:46:33 >>>故障排除日志:删除未同步下发订单成功2605201645580033172565
2026-05-20 16:46:33 >>>故障排除日志:删除未同步下发订单成功2605201645580033172565
2026-05-20 16:46:33 >>>故障排除日志:删除未同步下发订单成功2605201645580033172565
2026-05-20 16:46:33 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536876485]


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


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


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


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


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


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


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


===17:39:36===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-20 17:39:11 >>>回调事件[910,devices/TL1086]
2026-05-20 17:39:11 >>>故障排除日志:上一MQTT订单号缓存列表为2605201732230037771794
2026-05-20 17:39:11 >>>故障排除日志:终端未同步成功订单列表
2026-05-20 17:39:11 开始打印,排队:145,票券:2605201739050541787901,订单:2605201739050003503225,[2026-05-20 17:39:11支付宝支付10元]
2026-05-20 17:39:12>>>MQTT票号同步场景，创建空订单对象
2026-05-20 17:39:12>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-20 17:39:13 >>>回调事件[910,devices/TL1086]
2026-05-20 17:39:13 >>>故障排除日志:上一MQTT订单号缓存列表为2605201739050003503225
2026-05-20 17:39:13 >>>故障排除日志:终端未同步成功订单列表01452605201739050003503225
2026-05-20 17:39:13 开始打印,排队:146,票券:2605201739023456124501,订单:2605201739020032499426,[2026-05-20 17:39:12微信支付10元]
已接收过此消息,票券号为2605201739050541787901,排队号为145
2026-05-20 17:39:14>>>MQTT票号同步场景，创建空订单对象
2026-05-20 17:39:14>>>合并MQTT票号列表到订单同步请求,共2张票
2026-05-20 17:39:15 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605201739050541787901","queue_number":145,"trade_uid":"2605201739050003503225"}]}
2026-05-20 17:39:15 >>>故障排除日志:删除未同步下发订单成功2605201739050003503225
2026-05-20 17:39:16 >>>故障排除日志:终端同步成功后剩余订单列表01462605201739020032499426
定时检测未同步订单启用[checkOrderNum=536877028]
2026-05-20 17:39:16>>>删除订单异常:order_uid为空
2026-05-20 17:39:16 >>>当前Ram内存为766.65234375
定时检测已在运行，无需重复启动[checkOrderNum=536877028]


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


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


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


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


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


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


===18:37:38===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-20 18:37:10 >>>回调事件[910,devices/TL1086]
2026-05-20 18:37:10 >>>故障排除日志:上一MQTT订单号缓存列表为2605201835200027426813
2026-05-20 18:37:10 >>>故障排除日志:终端未同步成功订单列表01462605201739020032499426
2026-05-20 18:37:10 开始打印,排队:154,票券:2605201837009297289301,订单:2605201837000090576837,[2026-05-20 18:37:09支付宝支付10元]
2026-05-20 18:37:10>>>MQTT票号同步场景，创建空订单对象
2026-05-20 18:37:10>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-20 18:37:12 >>>回调事件[910,devices/TL1086]
2026-05-20 18:37:12 >>>故障排除日志:上一MQTT订单号缓存列表为2605201837000090576837
2026-05-20 18:37:12 >>>故障排除日志:终端未同步成功订单列表01462605201739020032499426|01542605201837000090576837
已接收过此消息,票券号为2605201837009297289301,排队号为154
2026-05-20 18:37:12 开始打印,排队:155,票券:2605201837074230994201,订单:2605201837070040446965,[2026-05-20 18:37:12微信支付10元]
2026-05-20 18:37:12>>>MQTT票号同步场景，创建空订单对象
2026-05-20 18:37:12>>>合并MQTT票号列表到订单同步请求,共2张票
2026-05-20 18:37:14 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605201837009297289301","queue_number":154,"trade_uid":"2605201837000090576837"}]}
2026-05-20 18:37:14 >>>故障排除日志:删除未同步下发订单成功2605201837000090576837
2026-05-20 18:37:14 >>>故障排除日志:终端同步成功后剩余订单列表01462605201739020032499426|01552605201837070040446965
定时检测未同步订单启用[checkOrderNum=536877616]
2026-05-20 18:37:14>>>删除订单异常:order_uid为空
2026-05-20 18:37:14 >>>当前Ram内存为761.7177734375
定时检测已在运行，无需重复启动[checkOrderNum=536877616]
2026-05-20 18:37:21>>>cash read=00
2026-05-20 18:37:21>>>cash read=818F42
2026-05-20 18:37:21>>>cash write=02
2026-05-20 18:37:21 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-05-20 18:37:22>>>cash read=10
2026-05-20 18:37:22 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-20 18:37:22 当前产品价格10元，投币10元，打印小票中...
2026-05-20 18:37:22 >>>开始打印,排队号为156,订单号为2605201837220011086372
2026-05-20 18:37:22>>>订单2605201837220011086372写入成功,剩余空间为1285500,占用RAM为774.83203125
删除未同步订单2605201837220011086372
2026-05-20 18:37:24>>>订单2605201837220011086372删除成功,剩余空间为1286500,占用RAM为780.6650390625
检测订单目录中>>>
无未同步订单>>>
2026-05-20 18:37:24 >>>当前Ram内存为745.98828125
定时检测未同步订单启用[checkOrderNum=536877623]
2026-05-20 18:37:25>>>cash write=0C
2026-05-20 18:37:25>>>cash read=3E


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


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


===18:51:38===
2026-05-20 18:51:17>>>cash read=0A
2026-05-20 18:51:18>>>cash read=3E


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


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


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


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


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


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


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


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


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


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


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


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


===20:09:42===
2026-05-20 20:09:14>>>cash read=00
2026-05-20 20:09:15>>>cash read=818F42
2026-05-20 20:09:15>>>cash write=02
2026-05-20 20:09:15 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-05-20 20:09:16>>>cash read=10
2026-05-20 20:09:16 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-20 20:09:16 当前产品价格10元，投币10元，打印小票中...
2026-05-20 20:09:16 >>>开始打印,排队号为171,订单号为2605202009160011086195
2026-05-20 20:09:16>>>订单2605202009160011086195写入成功,剩余空间为1288000,占用RAM为763.4765625
删除未同步订单2605202009160011086195
2026-05-20 20:09:18>>>订单2605202009160011086195删除成功,剩余空间为1288500,占用RAM为770.251953125
检测订单目录中>>>
无未同步订单>>>
2026-05-20 20:09:18 >>>当前Ram内存为742.447265625
定时检测未同步订单启用[checkOrderNum=536878573]
2026-05-20 20:09:19>>>cash write=0C
2026-05-20 20:09:19>>>cash read=3E


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


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


===20:14:44===
2026-05-20 20:13:42 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605202013318467871401","queue_number":173,"trade_uid":"2605202013310082741084"}]}
2026-05-20 20:13:42 >>>故障排除日志:删除未同步下发订单成功2605202013310082741084
2026-05-20 20:13:42 >>>故障排除日志:终端同步成功后剩余订单列表01462605201739020032499426|01552605201837070040446965
定时检测未同步订单启用[checkOrderNum=536878628]


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


===20:18:46===
2026-05-20 20:17:44 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605202017348812426101","queue_number":174,"trade_uid":"2605202017340086123261"}]}
2026-05-20 20:17:44 >>>故障排除日志:删除未同步下发订单成功2605202017340086123261
2026-05-20 20:17:44 >>>故障排除日志:终端同步成功后剩余订单列表01462605201739020032499426|01552605201837070040446965
定时检测未同步订单启用[checkOrderNum=536878674]


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


===20:32:47===
2026-05-20 20:32:25>>>cash read=00
2026-05-20 20:32:26>>>cash read=818F42
2026-05-20 20:32:26>>>cash write=02
2026-05-20 20:32:26 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-05-20 20:32:26>>>cash read=10
2026-05-20 20:32:26 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-20 20:32:26 当前产品价格10元，投币10元，打印小票中...
2026-05-20 20:32:26 >>>开始打印,排队号为176,订单号为2605202032260011086732
2026-05-20 20:32:27>>>订单2605202032260011086732写入成功,剩余空间为1288000,占用RAM为760.32421875
删除未同步订单2605202032260011086732
2026-05-20 20:32:29>>>订单2605202032260011086732删除成功,剩余空间为1288500,占用RAM为770.1083984375
检测订单目录中>>>
无未同步订单>>>
2026-05-20 20:32:29 >>>当前Ram内存为742.2861328125
定时检测未同步订单启用[checkOrderNum=536878825]
2026-05-20 20:32:30>>>cash write=0C
2026-05-20 20:32:30>>>cash read=3E


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


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