TLClient_JSSCOM_LuatOS-Air_V4010_RDA8910_RFTTS_0xe0000,2.8.4,869701076528176,13197324582638,
poweron reason:0

===08:16:55===
上一时间戳为1776816978
隔日重置时间戳true
隔日清空未同步下发列表true
当前排队号为1,音量为5
初始化产品信息:[{"time_limit_date":null,"ticket_category":"0","expiry_date":90,"product_detail":"","time_limit_status":"0","begin_minute":null,"product_uid":"14872826055361617313","use_timer":1,"old_price":"15","end_hour":null,"sale_price":"10","end_minute":null,"begin_hour":null,"sale_status":1,"product_name":"剪发"}]
是否打印二维码设置为1
是否打印紧凑设置为3
当前号显示模式设置为1
当前卡项核销权限设置为0
session_id:61953****1b8a1
纸币器设置接收纸币范围为36
欢迎使用天羚自助售票系统[2.8.4]
定时检测未同步订单启用[checkOrderNum=536870969]
2026-04-23 08:15:55>>>cash write=30
2026-04-23 08:15:55>>>cash write=02
2026-04-23 08:15:55>>>cash write=3E
2026-04-23 08:15:55>>>cash read=808F808F
系统时间初始化成功，时间为202642381555
2026-04-23 08:15:56>>>cash write=02
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
连接服务器成功
2026-04-23 08:15:59>>>cash write=0C
2026-04-23 08:15:59>>>cash read=3E
流量卡还有129天过期
2026-04-23 08:16:06 >>>当前Ram内存为663.0859375


===08:46:56===
2026-04-23 08:46:15 >>>回调事件[910,devices/TL3579]
当日首次设置时间戳true为1776905175
2026-04-23 08:46:15 >>>故障排除日志:上一MQTT订单号缓存列表为2604222042340052397692
2026-04-23 08:46:15 >>>故障排除日志:终端未同步成功订单列表
2026-04-23 08:46:15 开始打印,排队:1,票券:2604230846071452347201,订单:2604230846070010067589,[2026-04-23 08:46:15微信支付10元]
2026-04-23 08:46:15>>>MQTT票号同步场景，创建空订单对象
2026-04-23 08:46:15>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-23 08:46:17 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604230846071452347201","queue_number":1,"trade_uid":"2604230846070010067589"}]}
2026-04-23 08:46:17 >>>故障排除日志:删除未同步下发订单成功2604230846070010067589
2026-04-23 08:46:17 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536871260]


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


===09:01:56===
2026-04-23 09:01:04>>>cash read=29
2026-04-23 09:01:04 >>>回调事件130,cash_status,20029,退钞中
2026-04-23 09:01:04>>>cash read=2F29
2026-04-23 09:01:05>>>cash read=01
2026-04-23 09:01:09>>>cash read=2F
2026-04-23 09:01:10>>>cash read=01
2026-04-23 09:01:11>>>cash read=3E
2026-04-23 09:01:18>>>cash read=00
2026-04-23 09:01:19>>>cash read=818F42
2026-04-23 09:01:19>>>cash write=02
2026-04-23 09:01:19 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-23 09:01:19>>>cash read=10
2026-04-23 09:01:19 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-23 09:01:19 当前产品价格10元，投币10元，打印小票中...
2026-04-23 09:01:19 >>>开始打印,排队号为3,订单号为2604230901190013579711
2026-04-23 09:01:20>>>订单2604230901190013579711写入成功,剩余空间为1679500,占用RAM为633.396484375
删除未同步订单2604230901190013579711
2026-04-23 09:01:22>>>订单2604230901190013579711删除成功,剩余空间为1680000,占用RAM为643.755859375
检测订单目录中>>>
无未同步订单>>>
2026-04-23 09:01:22 >>>当前Ram内存为616.6708984375
定时检测未同步订单启用[checkOrderNum=536871412]
2026-04-23 09:01:23>>>cash write=0C
2026-04-23 09:01:23>>>cash read=3E
2026-04-23 09:01:34>>>cash read=00
2026-04-23 09:01:35>>>cash read=3E
2026-04-23 09:01:36>>>cash read=29
2026-04-23 09:01:36 >>>回调事件130,cash_status,20029,退钞中
2026-04-23 09:01:38>>>cash read=01
2026-04-23 09:01:39>>>cash read=3E
2026-04-23 09:01:44>>>cash read=01
2026-04-23 09:01:48>>>cash read=3E
2026-04-23 09:01:54>>>cash read=00


===09:02:56===
2026-04-23 09:01:55>>>cash read=818F42
2026-04-23 09:01:55>>>cash write=02
2026-04-23 09:01:55 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-23 09:01:56>>>cash read=10
2026-04-23 09:01:56 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-23 09:01:56 当前产品价格10元，投币10元，打印小票中...
2026-04-23 09:01:56 >>>开始打印,排队号为4,订单号为2604230901560013579308
2026-04-23 09:01:56>>>订单2604230901560013579308写入成功,剩余空间为1679500,占用RAM为633.890625
删除未同步订单2604230901560013579308
2026-04-23 09:01:58>>>订单2604230901560013579308删除成功,剩余空间为1680500,占用RAM为642.5068359375
检测订单目录中>>>
无未同步订单>>>
2026-04-23 09:01:58 >>>当前Ram内存为615.994140625
定时检测未同步订单启用[checkOrderNum=536871427]
2026-04-23 09:01:59>>>cash write=0C
2026-04-23 09:01:59>>>cash read=3E


===09:10:56===
2026-04-23 09:09:56>>>cash read=00
2026-04-23 09:09:56>>>cash read=2F29
2026-04-23 09:09:58>>>cash read=3E
2026-04-23 09:09:58>>>cash read=2F29
2026-04-23 09:10:00>>>cash read=01
2026-04-23 09:10:03>>>cash read=2F
2026-04-23 09:10:05>>>cash read=00818F42
2026-04-23 09:10:05>>>cash write=02
2026-04-23 09:10:05 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-23 09:10:05>>>cash read=10
2026-04-23 09:10:05 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-23 09:10:05 当前产品价格10元，投币10元，打印小票中...
2026-04-23 09:10:05 >>>开始打印,排队号为5,订单号为2604230910050013579969
2026-04-23 09:10:06>>>订单2604230910050013579969写入成功,剩余空间为1679500,占用RAM为636.1982421875
删除未同步订单2604230910050013579969
2026-04-23 09:10:08>>>订单2604230910050013579969删除成功,剩余空间为1680500,占用RAM为644.6923828125
检测订单目录中>>>
无未同步订单>>>
2026-04-23 09:10:08 >>>当前Ram内存为616.5517578125
定时检测未同步订单启用[checkOrderNum=536871516]
2026-04-23 09:10:09>>>cash write=0C
2026-04-23 09:10:09>>>cash read=3E
2026-04-23 09:10:28>>>cash read=00
2026-04-23 09:10:29>>>cash read=818F42
2026-04-23 09:10:29>>>cash write=02
2026-04-23 09:10:29 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-23 09:10:29>>>cash read=10
2026-04-23 09:10:29 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-23 09:10:30 当前产品价格10元，投币10元，打印小票中...
2026-04-23 09:10:30 >>>开始打印,排队号为6,订单号为2604230910300013579908
2026-04-23 09:10:30>>>订单2604230910300013579908写入成功,剩余空间为1678500,占用RAM为641.943359375
删除未同步订单2604230910300013579908
2026-04-23 09:10:32>>>订单2604230910300013579908删除成功,剩余空间为1679500,占用RAM为636.0244140625
检测订单目录中>>>
无未同步订单>>>
2026-04-23 09:10:32 >>>当前Ram内存为618.6396484375
定时检测未同步订单启用[checkOrderNum=536871526]
2026-04-23 09:10:33>>>cash write=0C
2026-04-23 09:10:33>>>cash read=3E


===09:18:58===
2026-04-23 09:18:31>>>cash read=29
2026-04-23 09:18:31 >>>回调事件130,cash_status,20029,退钞中
2026-04-23 09:18:32>>>cash read=01
2026-04-23 09:18:46>>>cash read=3E
2026-04-23 09:18:47>>>cash read=00
2026-04-23 09:18:48>>>cash read=2F29
2026-04-23 09:18:49>>>cash read=01
2026-04-23 09:18:53>>>cash read=2F
2026-04-23 09:18:54>>>cash read=00
2026-04-23 09:18:54>>>cash read=818F42
2026-04-23 09:18:54>>>cash write=02
2026-04-23 09:18:54 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-23 09:18:54>>>cash read=10
2026-04-23 09:18:54 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-23 09:18:54 当前产品价格10元，投币10元，打印小票中...
2026-04-23 09:18:54 >>>开始打印,排队号为7,订单号为2604230918540013579604
2026-04-23 09:18:55>>>订单2604230918540013579604写入成功,剩余空间为1679500,占用RAM为636.6708984375


===09:19:58===
2026-04-23 09:18:58>>>cash write=0C
2026-04-23 09:18:58>>>cash read=3E


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


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


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


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


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


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


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


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


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


===10:45:00===
2026-04-23 10:44:38>>>cash read=00
2026-04-23 10:44:39>>>cash read=818F42
2026-04-23 10:44:39>>>cash write=02
2026-04-23 10:44:39 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-23 10:44:40>>>cash read=10
2026-04-23 10:44:40 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-23 10:44:40 当前产品价格10元，投币10元，打印小票中...
2026-04-23 10:44:40 >>>开始打印,排队号为18,订单号为2604231044400013579902
2026-04-23 10:44:40>>>订单2604231044400013579902写入成功,剩余空间为1679500,占用RAM为634.1728515625
删除未同步订单2604231044400013579902
2026-04-23 10:44:42>>>订单2604231044400013579902删除成功,剩余空间为1680500,占用RAM为642.943359375
检测订单目录中>>>
无未同步订单>>>
2026-04-23 10:44:42 >>>当前Ram内存为616.3408203125
定时检测未同步订单启用[checkOrderNum=536872487]
2026-04-23 10:44:43>>>cash write=0C
2026-04-23 10:44:43>>>cash read=3E


===10:54:01===
2026-04-23 10:53:27>>>cash read=00
2026-04-23 10:53:28>>>cash read=2F29
2026-04-23 10:53:29>>>cash read=01
2026-04-23 10:53:32>>>cash read=2F
2026-04-23 10:53:33>>>cash read=29
2026-04-23 10:53:33 >>>回调事件130,cash_status,20029,退钞中
2026-04-23 10:53:34>>>cash read=01
2026-04-23 10:53:38>>>cash read=3E
2026-04-23 10:53:41>>>cash read=00
2026-04-23 10:53:43>>>cash read=818F42
2026-04-23 10:53:43>>>cash write=02
2026-04-23 10:53:43 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-23 10:53:43>>>cash read=10
2026-04-23 10:53:43 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-23 10:53:43 当前产品价格10元，投币10元，打印小票中...
2026-04-23 10:53:43 >>>开始打印,排队号为19,订单号为2604231053430013579893
2026-04-23 10:53:43>>>订单2604231053430013579893写入成功,剩余空间为1679500,占用RAM为636.640625
删除未同步订单2604231053430013579893
2026-04-23 10:53:45>>>订单2604231053430013579893删除成功,剩余空间为1680000,占用RAM为643.9091796875
检测订单目录中>>>
无未同步订单>>>
2026-04-23 10:53:46 >>>当前Ram内存为616.7294921875
定时检测未同步订单启用[checkOrderNum=536872577]
2026-04-23 10:53:47>>>cash write=0C
2026-04-23 10:53:47>>>cash read=3E


===11:24:01===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-23 11:23:24 >>>回调事件[910,devices/TL3579]
2026-04-23 11:23:24 >>>故障排除日志:上一MQTT订单号缓存列表为2604231038370053886435
2026-04-23 11:23:24 >>>故障排除日志:终端未同步成功订单列表
2026-04-23 11:23:24 开始打印,排队:20,票券:2604231123185510259501,订单:2604231123180053090372,[2026-04-23 11:23:23支付宝支付10元]
2026-04-23 11:23:24>>>MQTT票号同步场景，创建空订单对象
2026-04-23 11:23:24>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-23 11:23:26 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604231123185510259501","queue_number":20,"trade_uid":"2604231123180053090372"}]}
2026-04-23 11:23:26 >>>故障排除日志:删除未同步下发订单成功2604231123180053090372
2026-04-23 11:23:26 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536872854]
2026-04-23 11:23:40>>>cash read=00
2026-04-23 11:23:41>>>cash read=818F42
2026-04-23 11:23:41>>>cash write=02
2026-04-23 11:23:41 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-23 11:23:42>>>cash read=10
2026-04-23 11:23:42 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-23 11:23:42 当前产品价格10元，投币10元，打印小票中...
2026-04-23 11:23:42 >>>开始打印,排队号为21,订单号为2604231123420013579712
2026-04-23 11:23:42>>>订单2604231123420013579712写入成功,剩余空间为1678500,占用RAM为640.158203125
删除未同步订单2604231123420013579712
2026-04-23 11:23:44>>>订单2604231123420013579712删除成功,剩余空间为1679500,占用RAM为646.8173828125
检测订单目录中>>>
无未同步订单>>>
2026-04-23 11:23:44 >>>当前Ram内存为618.4423828125
定时检测未同步订单启用[checkOrderNum=536872861]
2026-04-23 11:23:45>>>cash write=0C
2026-04-23 11:23:45>>>cash read=3E


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


===12:03:03===
2026-04-23 12:02:04>>>cash read=2F29
2026-04-23 12:02:05>>>cash read=01
2026-04-23 12:02:08>>>cash read=2F
2026-04-23 12:02:09>>>cash read=3E
2026-04-23 12:02:12>>>cash read=00
2026-04-23 12:02:12>>>cash read=818F42
2026-04-23 12:02:12>>>cash write=02
2026-04-23 12:02:12 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-23 12:02:13>>>cash read=10
2026-04-23 12:02:13 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-23 12:02:13 当前产品价格10元，投币10元，打印小票中...
2026-04-23 12:02:13 >>>开始打印,排队号为23,订单号为2604231202130013579687
2026-04-23 12:02:13>>>订单2604231202130013579687写入成功,剩余空间为1679500,占用RAM为635.6005859375
删除未同步订单2604231202130013579687
2026-04-23 12:02:15>>>订单2604231202130013579687删除成功,剩余空间为1680500,占用RAM为643.810546875
检测订单目录中>>>
无未同步订单>>>
2026-04-23 12:02:15 >>>当前Ram内存为616.958984375
定时检测未同步订单启用[checkOrderNum=536873228]
2026-04-23 12:02:16>>>cash write=0C
2026-04-23 12:02:16>>>cash read=3E
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-23 12:03:00 >>>回调事件[910,devices/TL3579]
2026-04-23 12:03:00 >>>故障排除日志:上一MQTT订单号缓存列表为2604231137260032822778
2026-04-23 12:03:00 >>>故障排除日志:终端未同步成功订单列表
2026-04-23 12:03:00 开始打印,排队:24,票券:2604231202519063153401,订单:2604231202510088717987,[2026-04-23 12:03:00微信支付10元]
2026-04-23 12:03:00>>>MQTT票号同步场景，创建空订单对象
2026-04-23 12:03:00>>>合并MQTT票号列表到订单同步请求,共1张票


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


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


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


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


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


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


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


===13:32:05===
2026-04-23 13:31:16>>>cash read=00
2026-04-23 13:31:17>>>cash read=818F42
2026-04-23 13:31:17>>>cash write=02
2026-04-23 13:31:17 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-23 13:31:18>>>cash read=10
2026-04-23 13:31:18 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-23 13:31:18 当前产品价格10元，投币10元，打印小票中...
2026-04-23 13:31:18 >>>开始打印,排队号为32,订单号为2604231331180013579277
2026-04-23 13:31:18>>>订单2604231331180013579277写入成功,剩余空间为1679500,占用RAM为632.2978515625
删除未同步订单2604231331180013579277
2026-04-23 13:31:20>>>订单2604231331180013579277删除成功,剩余空间为1680500,占用RAM为644.6318359375
检测订单目录中>>>
无未同步订单>>>
2026-04-23 13:31:20 >>>当前Ram内存为616.3427734375
定时检测未同步订单启用[checkOrderNum=536874100]
2026-04-23 13:31:21>>>cash write=0C
2026-04-23 13:31:21>>>cash read=3E


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


===13:44:05===
2026-04-23 13:43:15>>>cash read=00
2026-04-23 13:43:16>>>cash read=29
2026-04-23 13:43:16 >>>回调事件130,cash_status,20029,退钞中
2026-04-23 13:43:16>>>cash read=2F29
2026-04-23 13:43:18>>>cash read=01
2026-04-23 13:43:18>>>cash read=2F
2026-04-23 13:43:19>>>cash read=3E
2026-04-23 13:43:23>>>cash read=00
2026-04-23 13:43:25>>>cash read=292F29
2026-04-23 13:43:25 >>>回调事件130,cash_status,20029,退钞中
2026-04-23 13:43:26>>>cash read=01
2026-04-23 13:43:26>>>cash read=2F
2026-04-23 13:43:27>>>cash read=3E
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-23 13:43:35 >>>回调事件[910,devices/TL3579]
2026-04-23 13:43:35 >>>故障排除日志:上一MQTT订单号缓存列表为2604231342160003870893
2026-04-23 13:43:35 >>>故障排除日志:终端未同步成功订单列表
2026-04-23 13:43:35 开始打印,排队:34,票券:2604231343025289975801,订单:2604231343020051060271,[2026-04-23 13:43:35微信支付10元]
2026-04-23 13:43:35>>>MQTT票号同步场景，创建空订单对象
2026-04-23 13:43:35>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-23 13:43:37 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604231343025289975801","queue_number":34,"trade_uid":"2604231343020051060271"}]}
2026-04-23 13:43:37 >>>故障排除日志:删除未同步下发订单成功2604231343020051060271
2026-04-23 13:43:37 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536874224]
2026-04-23 13:43:38>>>cash read=00
2026-04-23 13:43:38>>>cash read=818F42
2026-04-23 13:43:38>>>cash write=02
2026-04-23 13:43:38 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-23 13:43:39>>>cash read=10
2026-04-23 13:43:39 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-23 13:43:39 当前产品价格10元，投币10元，打印小票中...
2026-04-23 13:43:39 >>>开始打印,排队号为35,订单号为2604231343390013579533
2026-04-23 13:43:39>>>订单2604231343390013579533写入成功,剩余空间为1678000,占用RAM为646.2783203125
删除未同步订单2604231343390013579533
2026-04-23 13:43:41>>>订单2604231343390013579533删除成功,剩余空间为1679000,占用RAM为650.322265625
检测订单目录中>>>
无未同步订单>>>
2026-04-23 13:43:41 >>>当前Ram内存为619.5234375
定时检测未同步订单启用[checkOrderNum=536874231]
2026-04-23 13:43:42>>>cash write=0C
2026-04-23 13:43:42>>>cash read=3E


===13:55:06===
2026-04-23 13:54:30>>>cash read=00
2026-04-23 13:54:31>>>cash read=818F42
2026-04-23 13:54:31>>>cash write=02
2026-04-23 13:54:31 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-23 13:54:31>>>cash read=10
2026-04-23 13:54:31 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-23 13:54:31 当前产品价格10元，投币10元，打印小票中...
2026-04-23 13:54:31 >>>开始打印,排队号为36,订单号为2604231354310013579136
2026-04-23 13:54:32>>>订单2604231354310013579136写入成功,剩余空间为1679500,占用RAM为634.7822265625
删除未同步订单2604231354310013579136
2026-04-23 13:54:34>>>订单2604231354310013579136删除成功,剩余空间为1680500,占用RAM为643.2666015625
检测订单目录中>>>
无未同步订单>>>
2026-04-23 13:54:34 >>>当前Ram内存为616.6123046875
定时检测未同步订单启用[checkOrderNum=536874339]
2026-04-23 13:54:35>>>cash write=0C
2026-04-23 13:54:35>>>cash read=3E


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


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


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


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


===15:06:07===
2026-04-23 15:05:40>>>cash read=00
2026-04-23 15:05:41>>>cash read=29
2026-04-23 15:05:41 >>>回调事件130,cash_status,20029,退钞中
2026-04-23 15:05:42>>>cash read=2F29
2026-04-23 15:05:43>>>cash read=01
2026-04-23 15:05:43>>>cash read=2F
2026-04-23 15:05:44>>>cash read=3E
2026-04-23 15:05:46>>>cash read=00
2026-04-23 15:05:48>>>cash read=2F29
2026-04-23 15:05:50>>>cash read=01
2026-04-23 15:05:52>>>cash read=2F
2026-04-23 15:05:53>>>cash read=3E
2026-04-23 15:05:57>>>cash read=00
2026-04-23 15:05:58>>>cash read=818F42
2026-04-23 15:05:58>>>cash write=02
2026-04-23 15:05:58 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-23 15:05:59>>>cash read=10
2026-04-23 15:05:59 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-23 15:05:59 当前产品价格10元，投币10元，打印小票中...
2026-04-23 15:05:59 >>>开始打印,排队号为41,订单号为2604231505590013579511
2026-04-23 15:05:59>>>订单2604231505590013579511写入成功,剩余空间为1679000,占用RAM为637.37109375
删除未同步订单2604231505590013579511
2026-04-23 15:06:01>>>订单2604231505590013579511删除成功,剩余空间为1680000,占用RAM为646.0029296875
检测订单目录中>>>
无未同步订单>>>
2026-04-23 15:06:01 >>>当前Ram内存为616.91015625
定时检测未同步订单启用[checkOrderNum=536875025]
2026-04-23 15:06:02>>>cash write=0C
2026-04-23 15:06:02>>>cash read=3E


===15:07:07===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-23 15:06:22 >>>回调事件[910,devices/TL3579]
2026-04-23 15:06:22 >>>故障排除日志:上一MQTT订单号缓存列表为2604231504100077572185
2026-04-23 15:06:22 >>>故障排除日志:终端未同步成功订单列表
2026-04-23 15:06:22 开始打印,排队:42,票券:2604231506121442648901,订单:2604231506120012256263,[2026-04-23 15:06:21微信支付10元]
2026-04-23 15:06:22>>>MQTT票号同步场景，创建空订单对象
2026-04-23 15:06:22>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-23 15:06:24 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604231506121442648901","queue_number":42,"trade_uid":"2604231506120012256263"}]}
2026-04-23 15:06:24 >>>故障排除日志:删除未同步下发订单成功2604231506120012256263
2026-04-23 15:06:24 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536875035]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-23 15:06:30 >>>回调事件[910,devices/TL3579]
2026-04-23 15:06:30 >>>故障排除日志:上一MQTT订单号缓存列表为2604231506120012256263
2026-04-23 15:06:30 >>>故障排除日志:终端未同步成功订单列表
2026-04-23 15:06:30 开始打印,排队:43,票券:2604231506228481651201,订单:2604231506220082887775,[2026-04-23 15:06:30微信支付10元]
2026-04-23 15:06:30>>>MQTT票号同步场景，创建空订单对象
2026-04-23 15:06:30>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-23 15:06:32 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604231506228481651201","queue_number":43,"trade_uid":"2604231506220082887775"}]}
2026-04-23 15:06:32 >>>故障排除日志:删除未同步下发订单成功2604231506220082887775
2026-04-23 15:06:32 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536875041]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-23 15:06:45 >>>回调事件[910,devices/TL3579]
2026-04-23 15:06:45 >>>故障排除日志:上一MQTT订单号缓存列表为2604231506220082887775
2026-04-23 15:06:45 >>>故障排除日志:终端未同步成功订单列表
2026-04-23 15:06:45 开始打印,排队:44,票券:2604231506385062465301,订单:2604231506380048754078,[2026-04-23 15:06:44微信支付10元]
2026-04-23 15:06:45>>>MQTT票号同步场景，创建空订单对象
2026-04-23 15:06:45>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-23 15:06:47 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604231506385062465301","queue_number":44,"trade_uid":"2604231506380048754078"}]}
2026-04-23 15:06:47 >>>故障排除日志:删除未同步下发订单成功2604231506380048754078
2026-04-23 15:06:47 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536875048]


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


===15:12:07===
2026-04-23 15:11:47>>>cash read=0A
2026-04-23 15:11:48>>>cash read=3E


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


===15:28:08===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-23 15:27:10 >>>回调事件[910,devices/TL3579]
2026-04-23 15:27:10 >>>故障排除日志:上一MQTT订单号缓存列表为2604231522230079902597
2026-04-23 15:27:10 >>>故障排除日志:终端未同步成功订单列表
2026-04-23 15:27:10 开始打印,排队:47,票券:2604231526594920658101,订单:2604231526590047244476,[2026-04-23 15:27:08微信支付10元]
2026-04-23 15:27:10>>>MQTT票号同步场景，创建空订单对象
2026-04-23 15:27:10>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-23 15:27:12 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604231526594920658101","queue_number":47,"trade_uid":"2604231526590047244476"}]}
2026-04-23 15:27:12 >>>故障排除日志:删除未同步下发订单成功2604231526590047244476
2026-04-23 15:27:12 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536875261]
2026-04-23 15:27:16>>>cash read=00
2026-04-23 15:27:17>>>cash read=818F42
2026-04-23 15:27:17>>>cash write=02
2026-04-23 15:27:17 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-23 15:27:17>>>cash read=10
2026-04-23 15:27:17 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-23 15:27:17 当前产品价格10元，投币10元，打印小票中...
2026-04-23 15:27:17 >>>开始打印,排队号为48,订单号为2604231527170013579572
2026-04-23 15:27:18>>>订单2604231527170013579572写入成功,剩余空间为1678500,占用RAM为641.365234375
删除未同步订单2604231527170013579572
2026-04-23 15:27:20>>>订单2604231527170013579572删除成功,剩余空间为1679500,占用RAM为649.6689453125
检测订单目录中>>>
无未同步订单>>>
2026-04-23 15:27:20 >>>当前Ram内存为619.59375
定时检测未同步订单启用[checkOrderNum=536875269]
2026-04-23 15:27:21>>>cash write=0C
2026-04-23 15:27:21>>>cash read=3E
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-23 15:27:43 >>>回调事件[910,devices/TL3579]
2026-04-23 15:27:43 >>>故障排除日志:上一MQTT订单号缓存列表为2604231526590047244476
2026-04-23 15:27:43 >>>故障排除日志:终端未同步成功订单列表
2026-04-23 15:27:43 开始打印,排队:49,票券:2604231527396085095901,订单:2604231527390059029981,[2026-04-23 15:27:42支付宝支付10元]
2026-04-23 15:27:43>>>MQTT票号同步场景，创建空订单对象
2026-04-23 15:27:43>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-23 15:27:45 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604231527396085095901","queue_number":49,"trade_uid":"2604231527390059029981"}]}
2026-04-23 15:27:45 >>>故障排除日志:删除未同步下发订单成功2604231527390059029981
2026-04-23 15:27:45 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536875275]


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


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


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


===15:49:08===
2026-04-23 15:48:16>>>cash read=00
2026-04-23 15:48:17>>>cash read=818F42
2026-04-23 15:48:17>>>cash write=02
2026-04-23 15:48:17 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-23 15:48:17>>>cash read=10
2026-04-23 15:48:17 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-23 15:48:17 当前产品价格10元，投币10元，打印小票中...
2026-04-23 15:48:17 >>>开始打印,排队号为53,订单号为2604231548170013579598
2026-04-23 15:48:18>>>订单2604231548170013579598写入成功,剩余空间为1679500,占用RAM为634.1767578125
删除未同步订单2604231548170013579598
2026-04-23 15:48:19>>>订单2604231548170013579598删除成功,剩余空间为1680500,占用RAM为642.9658203125
检测订单目录中>>>
无未同步订单>>>
2026-04-23 15:48:20 >>>当前Ram内存为616.330078125
定时检测未同步订单启用[checkOrderNum=536875496]
2026-04-23 15:48:21>>>cash write=0C
2026-04-23 15:48:21>>>cash read=3E
2026-04-23 15:48:24>>>cash read=00
2026-04-23 15:48:24>>>cash read=818F42
2026-04-23 15:48:24>>>cash write=02
2026-04-23 15:48:24 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-23 15:48:25>>>cash read=10
2026-04-23 15:48:25 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-23 15:48:25 当前产品价格10元，投币10元，打印小票中...
2026-04-23 15:48:25 >>>开始打印,排队号为54,订单号为2604231548250013579346
2026-04-23 15:48:25>>>订单2604231548250013579346写入成功,剩余空间为1678500,占用RAM为641.0546875
删除未同步订单2604231548250013579346
2026-04-23 15:48:27>>>订单2604231548250013579346删除成功,剩余空间为1679500,占用RAM为649.68359375
检测订单目录中>>>
无未同步订单>>>
2026-04-23 15:48:27 >>>当前Ram内存为618.47265625
定时检测未同步订单启用[checkOrderNum=536875504]
2026-04-23 15:48:28>>>cash write=0C
2026-04-23 15:48:28>>>cash read=3E


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


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


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


===16:41:11===
2026-04-23 16:40:09 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604231639592311859101","queue_number":57,"trade_uid":"2604231639590021248457"}]}
2026-04-23 16:40:09 >>>故障排除日志:删除未同步下发订单成功2604231639590021248457
2026-04-23 16:40:09 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536875996]


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


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


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


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


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


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


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


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


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


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


===17:54:13===
2026-04-23 17:53:50>>>cash read=00
2026-04-23 17:53:52>>>cash read=818F42
2026-04-23 17:53:52>>>cash write=02
2026-04-23 17:53:52 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-23 17:53:52>>>cash read=10
2026-04-23 17:53:52 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-23 17:53:52 当前产品价格10元，投币10元，打印小票中...
2026-04-23 17:53:52 >>>开始打印,排队号为68,订单号为2604231753520013579381
2026-04-23 17:53:52>>>订单2604231753520013579381写入成功,剩余空间为1679500,占用RAM为634.693359375
删除未同步订单2604231753520013579381
2026-04-23 17:53:54>>>订单2604231753520013579381删除成功,剩余空间为1680500,占用RAM为643.4775390625
检测订单目录中>>>
无未同步订单>>>
2026-04-23 17:53:54 >>>当前Ram内存为616.861328125
定时检测未同步订单启用[checkOrderNum=536876743]
2026-04-23 17:53:55>>>cash write=0C
2026-04-23 17:53:55>>>cash read=3E


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


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


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


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


===18:22:14===
2026-04-23 18:21:22>>>cash read=0A
2026-04-23 18:21:24>>>cash read=3E


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


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


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


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


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


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


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


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


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


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


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


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


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


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


===20:10:17===
2026-04-23 20:09:22>>>cash read=00
2026-04-23 20:09:22>>>cash read=818F42
2026-04-23 20:09:22>>>cash write=02
2026-04-23 20:09:22 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-23 20:09:23>>>cash read=10
2026-04-23 20:09:23 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-23 20:09:23 当前产品价格10元，投币10元，打印小票中...
2026-04-23 20:09:23 >>>开始打印,排队号为88,订单号为2604232009230013579341
2026-04-23 20:09:23>>>订单2604232009230013579341写入成功,剩余空间为1679500,占用RAM为633.498046875
删除未同步订单2604232009230013579341
2026-04-23 20:09:25>>>订单2604232009230013579341删除成功,剩余空间为1680500,占用RAM为643.203125
检测订单目录中>>>
无未同步订单>>>
2026-04-23 20:09:25 >>>当前Ram内存为615.8203125
定时检测未同步订单启用[checkOrderNum=536878132]
2026-04-23 20:09:26>>>cash write=0C
2026-04-23 20:09:26>>>cash read=3E


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


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


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


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


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