TLClient_JSSCOM_LuatOS-Air_V4010_RDA8910_RFTTS_0xe0000,2.8.6,863482064707702,91125443275319,
poweron reason:0

===08:15:40===
上一时间戳为1777076595
隔日重置时间戳true
隔日清空未同步下发列表true
当前排队号为1,音量为6
初始化产品信息:[{"time_limit_date":"","ticket_category":"0","expiry_date":90,"product_detail":"","time_limit_status":"0","begin_minute":"00","product_uid":"12566542176649286868","use_timer":1,"old_price":"10","end_hour":"23","sale_price":"10","end_minute":"59","begin_hour":"00","sale_status":1,"product_name":"剪发一律10元"},{"time_limit_date":"","ticket_category":"0","expiry_date":7,"product_detail":"","time_limit_status":"0","begin_minute":"00","product_uid":"12710657366790774979","use_timer":1,"old_price":"15","end_hour":"23","sale_price":"15","end_minute":"59","begin_hour":"00","sale_status":1,"product_name":"洗剪"},{"time_limit_date":"","ticket_category":"0","expiry_date":7,"product_detail":"","time_limit_status":"0","begin_minute":"00","product_uid":"12566542176649286869","use_timer":1,"old_price":"5","end_hour":"23","sale_price":"5","end_minute":"59","begin_hour":"00","sale_status":1,"product_name":"加洗（仅限男士）"},{"time_limit_date":"","ticket_category":"0","expiry_date":7,"product_detail":"","time_limit_status":"0","begin_minute":"00","product_uid":"12710657366790774962","use_timer":1,"old_price":"50","end_hour":"23","sale_price":"50","end_minute":"59","begin_hour":"00","sale_status":1,"product_name":"焗油"}]
打印门店标题设置为合剪（瑞安华泰路店）
打印门店凭条广告设置为合剪（瑞安华泰路店）
是否打印二维码设置为1
是否打印紧凑设置为3
当前号显示模式设置为1
当前卡项核销权限设置为0
session_id:aabfa****bc273
纸币器设置接收纸币范围为36
欢迎使用天羚自助售票系统[2.8.6]
定时检测未同步订单启用[checkOrderNum=536870971]
2026-04-26 08:14:39>>>cash write=30
2026-04-26 08:14:39>>>cash write=02
2026-04-26 08:14:39>>>cash write=3E
2026-04-26 08:14:39>>>cash read=808F808F
系统时间初始化成功，时间为202642681439
2026-04-26 08:14:40>>>cash write=02
2026-04-26 08:14:41 >>>剩余flash空间=1679000,占用RAM为667.1474609375
2026-04-26 08:14:41 >>>回调事件:910,subscribe,10000,连接服务器成功

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

2026-04-26 08:14:43>>>cash write=0C
2026-04-26 08:14:43>>>cash read=3E
流量卡还有34天过期
2026-04-26 08:14:50 >>>当前Ram内存为660.8818359375


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


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


===08:32:41===
2026-04-26 08:31:47>>>cash read=0A
2026-04-26 08:31:48>>>cash read=3E


===08:34:41===
2026-04-26 08:34:02>>>cash read=29
2026-04-26 08:34:02 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 08:34:04>>>cash read=01
2026-04-26 08:34:05>>>cash read=3E
2026-04-26 08:34:16>>>cash read=29
2026-04-26 08:34:16 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 08:34:17>>>cash read=01
2026-04-26 08:34:18>>>cash read=3E
2026-04-26 08:34:22>>>cash read=00
2026-04-26 08:34:23>>>cash read=29
2026-04-26 08:34:23 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 08:34:23>>>cash read=2F29
2026-04-26 08:34:24>>>cash read=01
2026-04-26 08:34:25>>>cash read=2F
2026-04-26 08:34:26>>>cash read=3E
2026-04-26 08:34:29>>>cash read=00
2026-04-26 08:34:30>>>cash read=818F42
2026-04-26 08:34:30>>>cash write=02
2026-04-26 08:34:30 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 08:34:31>>>cash read=10
2026-04-26 08:34:31 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 08:34:31 当前产品价格10元，投币10元，打印小票中...
2026-04-26 08:34:31 >>>开始打印,排队号为4,订单号为2604260834310040480125
2026-04-26 08:34:31>>>订单2604260834310040480125写入成功,剩余空间为1679000,占用RAM为640.1474609375
删除未同步订单2604260834310040480125
2026-04-26 08:34:33>>>订单2604260834310040480125删除成功,剩余空间为1680000,占用RAM为648.4541015625
检测订单目录中>>>
无未同步订单>>>
2026-04-26 08:34:33 >>>当前Ram内存为619.6630859375
定时检测未同步订单启用[checkOrderNum=536871195]
2026-04-26 08:34:34>>>cash write=0C
2026-04-26 08:34:34>>>cash read=3E


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


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


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


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


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


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


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


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


===09:52:43===
2026-04-26 09:52:08>>>cash read=00
2026-04-26 09:52:09>>>cash read=2F29
2026-04-26 09:52:10>>>cash read=01
2026-04-26 09:52:13>>>cash read=2F
2026-04-26 09:52:14>>>cash read=3E
2026-04-26 09:52:29>>>cash read=00
2026-04-26 09:52:30>>>cash read=2F29
2026-04-26 09:52:31>>>cash read=01
2026-04-26 09:52:35>>>cash read=2F
2026-04-26 09:52:36>>>cash read=00
2026-04-26 09:52:38>>>cash read=292F29
2026-04-26 09:52:38 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 09:52:39>>>cash read=01


===09:53:44===
2026-04-26 09:52:43>>>cash read=3E
2026-04-26 09:52:43>>>cash read=2F
2026-04-26 09:52:45>>>cash read=3E
2026-04-26 09:53:22>>>cash read=00
2026-04-26 09:53:23>>>cash read=29
2026-04-26 09:53:23 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 09:53:24>>>cash read=00
2026-04-26 09:53:24>>>cash read=818F42
2026-04-26 09:53:24>>>cash write=02
2026-04-26 09:53:24 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 09:53:25>>>cash read=10
2026-04-26 09:53:25 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 09:53:25 当前产品价格10元，投币10元，打印小票中...
2026-04-26 09:53:25 >>>开始打印,排队号为14,订单号为2604260953250040480164
2026-04-26 09:53:25>>>订单2604260953250040480164写入成功,剩余空间为1679500,占用RAM为638.4951171875
删除未同步订单2604260953250040480164
2026-04-26 09:53:27>>>订单2604260953250040480164删除成功,剩余空间为1680500,占用RAM为647.6357421875
检测订单目录中>>>
无未同步订单>>>
2026-04-26 09:53:27 >>>当前Ram内存为619.365234375
定时检测未同步订单启用[checkOrderNum=536872024]
2026-04-26 09:53:28>>>cash write=0C
2026-04-26 09:53:28>>>cash read=3E
2026-04-26 09:53:33>>>cash read=00
2026-04-26 09:53:33>>>cash read=818F42
2026-04-26 09:53:33>>>cash write=02
2026-04-26 09:53:33 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 09:53:34>>>cash read=10
2026-04-26 09:53:34 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 09:53:34 当前产品价格10元，投币10元，打印小票中...
2026-04-26 09:53:34 >>>开始打印,排队号为15,订单号为2604260953340040480285
2026-04-26 09:53:34>>>订单2604260953340040480285写入成功,剩余空间为1678500,占用RAM为645.009765625
删除未同步订单2604260953340040480285
2026-04-26 09:53:36>>>订单2604260953340040480285删除成功,剩余空间为1679000,占用RAM为652.361328125
检测订单目录中>>>
无未同步订单>>>
2026-04-26 09:53:36 >>>当前Ram内存为621.4794921875
定时检测未同步订单启用[checkOrderNum=536872036]
2026-04-26 09:53:37>>>cash write=0C
2026-04-26 09:53:37>>>cash read=3E


===09:55:44===
2026-04-26 09:55:12>>>cash read=0A
2026-04-26 09:55:13>>>cash read=3E


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


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


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


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


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


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


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


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


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


===10:59:47===
2026-04-26 10:58:46 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261058355234227101","queue_number":25,"trade_uid":"2604261058350050451191"}]}
2026-04-26 10:58:46 >>>故障排除日志:删除未同步下发订单成功2604261058350050451191
2026-04-26 10:58:46 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536872812]


===11:09:48===
2026-04-26 11:09:34>>>cash read=00
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 11:09:35 >>>回调事件[910,devices/D0480]
2026-04-26 11:09:35 >>>故障排除日志:上一MQTT订单号缓存列表为2604261058350050451191
2026-04-26 11:09:35 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 11:09:35 开始打印,排队:26,票券:2604261109273940183901,订单:2604261109270037557489,[2026-04-26 11:09:34支付宝支付10元]
2026-04-26 11:09:35>>>MQTT票号同步场景，创建空订单对象
2026-04-26 11:09:35>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 11:09:36>>>cash read=2F292F
2026-04-26 11:09:37 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261109273940183901","queue_number":26,"trade_uid":"2604261109270037557489"}]}
2026-04-26 11:09:37 >>>故障排除日志:删除未同步下发订单成功2604261109270037557489
2026-04-26 11:09:37 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536872921]
2026-04-26 11:09:38>>>cash read=3E
2026-04-26 11:09:40>>>cash read=00
2026-04-26 11:09:41>>>cash read=2F29
2026-04-26 11:09:42>>>cash read=01
2026-04-26 11:09:42>>>cash read=2F
2026-04-26 11:09:44>>>cash read=29
2026-04-26 11:09:44 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 11:09:44>>>cash read=2F29
2026-04-26 11:09:45>>>cash read=3E


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


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


===11:17:50===
mqttTask.mqttMsgRecv.proc error
2026-04-26 11:17:37 >>>剩余flash空间=1681000,占用RAM为670.955078125
2026-04-26 11:17:37 >>>回调异常:910,mqtt_tl,30000,mqtt_stop

2026-04-26 11:17:37 >>>MQTT连接断开，尝试重连中


TCP://post-cn-09k20cnrl07.mqtt.aliyuncs.com:1883 closed@26_11:17:37
TCP://post-cn-09k20cnrl07.mqtt.aliyuncs.com:1883@26_11:17:37:send fail
===11:18:50===
2026-04-26 11:17:49 >>>剩余flash空间=1682000,占用RAM为662.0673828125
2026-04-26 11:17:49 >>>回调事件:910,subscribe,10000,连接服务器成功

请求下发消息结果为0,Message sent successfully
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 11:17:50 >>>回调事件[910,devices/D0480]
2026-04-26 11:17:50 >>>故障排除日志:上一MQTT订单号缓存列表为2604261116090017286297
2026-04-26 11:17:50 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 11:17:50 开始打印,排队:29,票券:2604261117301371795801,订单:2604261117300011787874,[2026-04-26 11:17:36微信支付10元]
2026-04-26 11:17:50>>>MQTT票号同步场景，创建空订单对象
2026-04-26 11:17:50>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 11:17:52 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261117301371795801","queue_number":29,"trade_uid":"2604261117300011787874"}]}
2026-04-26 11:17:52 >>>故障排除日志:删除未同步下发订单成功2604261117300011787874
2026-04-26 11:17:52 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536873077]


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


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


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


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


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


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


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


===12:09:29===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 12:08:28 >>>回调事件[910,devices/D0480]
2026-04-26 12:08:28 >>>故障排除日志:上一MQTT订单号缓存列表为2604261207090099975542
2026-04-26 12:08:28 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 12:08:28 开始打印,排队:37,票券:2604261208215390725701,订单:2604261208210051830593,[2026-04-26 12:08:27微信支付10元]
2026-04-26 12:08:28>>>MQTT票号同步场景，创建空订单对象
2026-04-26 12:08:28>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 12:08:30 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261208215390725701","queue_number":37,"trade_uid":"2604261208210051830593"}]}
2026-04-26 12:08:30 >>>故障排除日志:删除未同步下发订单成功2604261208210051830593
2026-04-26 12:08:30 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536873634]
mqttTask.mqttMsgRecv.proc error
2026-04-26 12:09:27 >>>剩余flash空间=1679500,占用RAM为677.81640625
2026-04-26 12:09:27 >>>回调异常:910,mqtt_tl,30000,mqtt_stop

2026-04-26 12:09:27 >>>MQTT连接断开，尝试重连中


TCP://post-cn-09k20cnrl07.mqtt.aliyuncs.com:1883 closed@26_12:09:27
TCP://post-cn-09k20cnrl07.mqtt.aliyuncs.com:1883@26_12:09:27:send fail
TCP://log.tl-self.com:9807@26_12:09:11:connect fail
===12:10:29===
2026-04-26 12:09:38 >>>剩余flash空间=1682000,占用RAM为643.8330078125
2026-04-26 12:09:38 >>>回调事件:910,subscribe,10000,连接服务器成功

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



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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


===13:39:40===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 13:38:52 >>>回调事件[910,devices/D0480]
2026-04-26 13:38:52 >>>故障排除日志:上一MQTT订单号缓存列表为2604261338150033155628
2026-04-26 13:38:52 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 13:38:52 开始打印,排队:57,票券:2604261338444609556701,订单:2604261338440044230325,[2026-04-26 13:38:52微信支付10元]
2026-04-26 13:38:52>>>MQTT票号同步场景，创建空订单对象
2026-04-26 13:38:52>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 13:38:55 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261338444609556701","queue_number":57,"trade_uid":"2604261338440044230325"}]}
2026-04-26 13:38:55 >>>故障排除日志:删除未同步下发订单成功2604261338440044230325
2026-04-26 13:38:55 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536874851]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 13:39:08 >>>回调事件[910,devices/D0480]
2026-04-26 13:39:08 >>>故障排除日志:上一MQTT订单号缓存列表为2604261338440044230325
2026-04-26 13:39:08 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 13:39:08 开始打印,排队:58,票券:2604261339027284154201,订单:2604261339020069622127,[2026-04-26 13:39:07微信支付15元]
2026-04-26 13:39:08>>>MQTT票号同步场景，创建空订单对象
2026-04-26 13:39:08>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 13:39:10 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261339027284154201","queue_number":58,"trade_uid":"2604261339020069622127"}]}
2026-04-26 13:39:10 >>>故障排除日志:删除未同步下发订单成功2604261339020069622127
2026-04-26 13:39:11 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536874871]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 13:39:20 >>>回调事件[910,devices/D0480]
2026-04-26 13:39:20 >>>故障排除日志:上一MQTT订单号缓存列表为2604261339020069622127
2026-04-26 13:39:20 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 13:39:20 开始打印,排队:59,票券:2604261339126184657301,订单:2604261339120059838242,[2026-04-26 13:39:19微信支付10元]
2026-04-26 13:39:20>>>MQTT票号同步场景，创建空订单对象
2026-04-26 13:39:20>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 13:39:22 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261339126184657301","queue_number":59,"trade_uid":"2604261339120059838242"}]}
2026-04-26 13:39:22 >>>故障排除日志:删除未同步下发订单成功2604261339120059838242
2026-04-26 13:39:22 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536874886]


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


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


===13:48:42===
2026-04-26 13:47:40 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261347247191394101","queue_number":61,"trade_uid":"2604261347240070064145"}]}
2026-04-26 13:47:40 >>>故障排除日志:删除未同步下发订单成功2604261347240070064145
2026-04-26 13:47:40 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536874985]


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


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


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


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


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


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


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


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


===14:44:54===
2026-04-26 14:44:43 >>>剩余flash空间=1682000,占用RAM为672.876953125
2026-04-26 14:44:43 >>>回调事件:901,netChange,1,4G LTE网络



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


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


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


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


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


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


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


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


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


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


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


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


===15:45:10===
2026-04-26 15:44:11>>>订单同步异常:30000,nil
2026-04-26 15:44:11>>>添加1个票号到未同步列表
2026-04-26 15:44:11>>>异常订单信息为{"dev_id":"D0480","ticket_no_list":[{"add_time":"2026-04-26 15:44:05","ticket_no":"2604261543556180287101","queue_number":83,"trade_uid":"2604261543550059670479"}],"enterprise_uid":"98628273991938809","version_uid":"23","store_uid":"12566542176649275942","sign":"FA34EA0B543A9885FEAA263B5ECF35C1","time_stamp":"1777189446769","random":"88884283","dev_sn":"863482064707702"}
2026-04-26 15:44:11 >>>剩余flash空间=1679000,占用RAM为692.001953125
2026-04-26 15:44:11 >>>回调异常:911,ticketList,30000,nil

定时检测未同步订单关闭[lastTableNumForSync=2][lastOrderCheckTime=0]
2026-04-26 15:44:11>>>开始同步未成功的票号列表,共1张票
定时检测未同步订单启用[checkOrderNum=536876445]
2026-04-26 15:44:11 >>>剩余flash空间=1679000,占用RAM为629.712890625
2026-04-26 15:44:11 >>>回调异常:911,initSys,30000,nil

2026-04-26 15:44:15>>>从未同步列表移除1个票号
定时检测已在运行，无需重复启动[checkOrderNum=536876445]


TCP://api5.tl-self.com:80@26_15:44:11:connect fail
===15:46:10===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 15:45:28 >>>回调事件[910,devices/D0480]
2026-04-26 15:45:28 >>>故障排除日志:上一MQTT订单号缓存列表为2604261543550059670479
2026-04-26 15:45:28 >>>故障排除日志:终端未同步成功订单列表00832604261543550059670479
2026-04-26 15:45:28 开始打印,排队:84,票券:2604261545229246312101,订单:2604261545220090558029,[2026-04-26 15:45:28微信支付10元]
2026-04-26 15:45:29>>>MQTT票号同步场景，创建空订单对象
2026-04-26 15:45:29>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 15:45:31 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261545229246312101","queue_number":84,"trade_uid":"2604261545220090558029"}]}
2026-04-26 15:45:31 >>>故障排除日志:删除未同步下发订单成功2604261545220090558029
2026-04-26 15:45:31 >>>故障排除日志:终端同步成功后剩余订单列表00832604261543550059670479
定时检测未同步订单启用[checkOrderNum=536876473]


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


===15:48:12===
2026-04-26 15:47:11 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261547021455156401","queue_number":85,"trade_uid":"2604261547020012384324"}]}
2026-04-26 15:47:11 >>>故障排除日志:删除未同步下发订单成功2604261547020012384324
2026-04-26 15:47:11 >>>故障排除日志:终端同步成功后剩余订单列表00832604261543550059670479
定时检测未同步订单启用[checkOrderNum=536876504]


===15:49:12===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 15:48:29 >>>回调事件[910,devices/D0480]
2026-04-26 15:48:29 >>>故障排除日志:上一MQTT订单号缓存列表为2604261547020012384324
2026-04-26 15:48:29 >>>故障排除日志:终端未同步成功订单列表00832604261543550059670479
2026-04-26 15:48:29 开始打印,排队:86,票券:2604261548235630262901,订单:2604261548230052798975,[2026-04-26 15:48:29微信支付10元]
2026-04-26 15:48:29>>>MQTT票号同步场景，创建空订单对象
2026-04-26 15:48:29>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 15:48:31 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261548235630262901","queue_number":86,"trade_uid":"2604261548230052798975"}]}
2026-04-26 15:48:31 >>>故障排除日志:删除未同步下发订单成功2604261548230052798975
2026-04-26 15:48:31 >>>故障排除日志:终端同步成功后剩余订单列表00832604261543550059670479
定时检测未同步订单启用[checkOrderNum=536876522]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 15:48:46 >>>回调事件[910,devices/D0480]
2026-04-26 15:48:46 >>>故障排除日志:上一MQTT订单号缓存列表为2604261548230052798975
2026-04-26 15:48:46 >>>故障排除日志:终端未同步成功订单列表00832604261543550059670479
2026-04-26 15:48:46 开始打印,排队:87,票券:2604261548397827752701,订单:2604261548390075535013,[2026-04-26 15:48:46微信支付10元]
2026-04-26 15:48:46>>>MQTT票号同步场景，创建空订单对象
2026-04-26 15:48:46>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 15:48:48 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261548397827752701","queue_number":87,"trade_uid":"2604261548390075535013"}]}
2026-04-26 15:48:48 >>>故障排除日志:删除未同步下发订单成功2604261548390075535013
2026-04-26 15:48:48 >>>故障排除日志:终端同步成功后剩余订单列表00832604261543550059670479
定时检测未同步订单启用[checkOrderNum=536876533]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 15:49:04 >>>回调事件[910,devices/D0480]
2026-04-26 15:49:05 >>>故障排除日志:上一MQTT订单号缓存列表为2604261548390075535013
2026-04-26 15:49:05 >>>故障排除日志:终端未同步成功订单列表00832604261543550059670479
2026-04-26 15:49:05 开始打印,排队:88,票券:2604261548581181582501,订单:2604261548580009438442,[2026-04-26 15:49:04微信支付10元]
2026-04-26 15:49:05>>>MQTT票号同步场景，创建空订单对象
2026-04-26 15:49:05>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 15:49:07 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261548581181582501","queue_number":88,"trade_uid":"2604261548580009438442"}]}
2026-04-26 15:49:07 >>>故障排除日志:删除未同步下发订单成功2604261548580009438442
2026-04-26 15:49:07 >>>故障排除日志:终端同步成功后剩余订单列表00832604261543550059670479
定时检测未同步订单启用[checkOrderNum=536876542]


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


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


===16:11:14===
2026-04-26 16:10:16 >>>开始未足额打印,排队号为90,订单号为2604261610080040480913
2026-04-26 16:10:16 订单投币结束,共投币10元,请取走您的小票
2026-04-26 16:10:16>>>订单2604261610080040480913写入成功,剩余空间为1680500,占用RAM为653.919921875
删除未同步订单2604261610080040480913
2026-04-26 16:10:18>>>订单2604261610080040480913删除成功,剩余空间为1681500,占用RAM为643.853515625
检测订单目录中>>>
无未同步订单>>>
2026-04-26 16:10:19 >>>当前Ram内存为623.638671875
定时检测未同步订单启用[checkOrderNum=536876844]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 16:11:02 >>>回调事件[910,devices/D0480]
2026-04-26 16:11:02 >>>故障排除日志:上一MQTT订单号缓存列表为2604261600140044240547
2026-04-26 16:11:02 >>>故障排除日志:终端未同步成功订单列表00832604261543550059670479
2026-04-26 16:11:02 开始打印,排队:91,票券:2604261610569747788701,订单:2604261610560095486147,[2026-04-26 16:11:02微信支付10元]
2026-04-26 16:11:03>>>MQTT票号同步场景，创建空订单对象
2026-04-26 16:11:03>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 16:11:04 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261610569747788701","queue_number":91,"trade_uid":"2604261610560095486147"}]}
2026-04-26 16:11:04 >>>故障排除日志:删除未同步下发订单成功2604261610560095486147
2026-04-26 16:11:05 >>>故障排除日志:终端同步成功后剩余订单列表00832604261543550059670479
定时检测未同步订单启用[checkOrderNum=536876859]


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


===16:17:16===
2026-04-26 16:16:15 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261616028898994501","queue_number":92,"trade_uid":"2604261616020086514559"}]}
2026-04-26 16:16:15 >>>故障排除日志:删除未同步下发订单成功2604261616020086514559
2026-04-26 16:16:15 >>>故障排除日志:终端同步成功后剩余订单列表00832604261543550059670479
定时检测未同步订单启用[checkOrderNum=536876922]


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


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


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


===16:37:20===
2026-04-26 16:37:10>>>cash read=29
2026-04-26 16:37:10 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 16:37:10>>>cash read=2F29
2026-04-26 16:37:12>>>cash read=3E
2026-04-26 16:37:13>>>cash read=00
2026-04-26 16:37:13>>>cash read=818F42
2026-04-26 16:37:13>>>cash write=02
2026-04-26 16:37:13 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 16:37:14>>>cash read=10
2026-04-26 16:37:14 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 16:37:14 当前产品价格5元，投币10元，打印小票中...
2026-04-26 16:37:14 >>>开始打印,排队号为96,订单号为2604261637140040480395
2026-04-26 16:37:14 >>>开始打印,排队号为97,订单号为2604261637140040480395
2026-04-26 16:37:14>>>订单2604261637140040480395写入成功,剩余空间为1679000,占用RAM为649.77734375
删除未同步订单2604261637140040480395
2026-04-26 16:37:18>>>订单2604261637140040480395删除成功,剩余空间为1680500,占用RAM为636.119140625
检测订单目录中>>>
无未同步订单>>>
2026-04-26 16:37:18 >>>当前Ram内存为624.6416015625
定时检测未同步订单启用[checkOrderNum=536877220]


===16:38:20===
2026-04-26 16:37:19>>>cash write=0C
2026-04-26 16:37:19>>>cash read=3E


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


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


===16:48:30===
2026-04-26 16:47:48 >>>剩余flash空间=1682000,占用RAM为644.8173828125
2026-04-26 16:47:48 >>>回调事件:901,netChange,1,4G LTE网络



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


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


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


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


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


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


===17:07:34===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 17:06:48 >>>回调事件[910,devices/D0480]
2026-04-26 17:06:48 >>>故障排除日志:上一MQTT订单号缓存列表为2604261702440018405645
2026-04-26 17:06:48 >>>故障排除日志:终端未同步成功订单列表00832604261543550059670479
2026-04-26 17:06:48 开始打印,排队:106,票券:2604261706422995422401,订单:2604261706420028031614,[2026-04-26 17:06:47微信支付10元]
2026-04-26 17:06:48 开始打印,排队:107,票券:2604261706422995946702,订单:2604261706420028031614,[2026-04-26 17:06:47微信支付10元]
2026-04-26 17:06:48>>>MQTT票号同步场景，创建空订单对象
2026-04-26 17:06:48>>>合并MQTT票号列表到订单同步请求,共2张票
2026-04-26 17:06:51 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261706422995422401","queue_number":106,"trade_uid":"2604261706420028031614"},{"ticket_no":"2604261706422995946702","queue_number":107,"trade_uid":"2604261706420028031614"}]}
2026-04-26 17:06:52 >>>故障排除日志:删除未同步下发订单成功2604261706420028031614
2026-04-26 17:06:52 >>>故障排除日志:删除未同步下发订单成功2604261706420028031614
2026-04-26 17:06:52 >>>故障排除日志:终端同步成功后剩余订单列表00832604261543550059670479
定时检测未同步订单启用[checkOrderNum=536877653]


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


===17:18:43===
2026-04-26 17:18:12>>>cash read=0A
2026-04-26 17:18:14>>>cash read=3E


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


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


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


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


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


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


===18:15:46===
mqttTask.mqttMsgRecv.proc error
2026-04-26 18:14:52 >>>剩余flash空间=1681000,占用RAM为666.9375
2026-04-26 18:14:52 >>>回调异常:910,mqtt_tl,30000,mqtt_stop

2026-04-26 18:14:52 >>>MQTT连接断开，尝试重连中
2026-04-26 18:15:03 >>>剩余flash空间=1681000,占用RAM为661.1318359375
2026-04-26 18:15:03 >>>回调事件:910,subscribe,10000,连接服务器成功

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



TCP://post-cn-09k20cnrl07.mqtt.aliyuncs.com:1883 closed@26_18:14:52
TCP://post-cn-09k20cnrl07.mqtt.aliyuncs.com:1883@26_18:14:52:send fail
===18:18:46===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 18:18:03 >>>回调事件[910,devices/D0480]
2026-04-26 18:18:03 >>>故障排除日志:上一MQTT订单号缓存列表为2604261809340047258483
2026-04-26 18:18:03 >>>故障排除日志:终端未同步成功订单列表00832604261543550059670479
2026-04-26 18:18:03 开始打印,排队:115,票券:2604261817586715355301,订单:2604261817580065266286,[2026-04-26 18:18:03微信支付10元]
2026-04-26 18:18:04>>>MQTT票号同步场景，创建空订单对象
2026-04-26 18:18:04>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 18:18:05 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261817586715355301","queue_number":115,"trade_uid":"2604261817580065266286"}]}
2026-04-26 18:18:05 >>>故障排除日志:删除未同步下发订单成功2604261817580065266286
2026-04-26 18:18:05 >>>故障排除日志:终端同步成功后剩余订单列表00832604261543550059670479
定时检测未同步订单启用[checkOrderNum=536878548]


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


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


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


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


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


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


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


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


===18:46:43===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 18:45:55 >>>回调事件[910,devices/D0480]
2026-04-26 18:45:55 >>>故障排除日志:上一MQTT订单号缓存列表为2604261840400007413948
2026-04-26 18:45:55 >>>故障排除日志:终端未同步成功订单列表00832604261543550059670479
2026-04-26 18:45:55 开始打印,排队:128,票券:2604261845348538039601,订单:2604261845340083040552,[2026-04-26 18:45:54支付宝支付10元]
2026-04-26 18:45:56>>>MQTT票号同步场景，创建空订单对象
2026-04-26 18:45:56>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 18:45:58 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261845348538039601","queue_number":128,"trade_uid":"2604261845340083040552"}]}
2026-04-26 18:45:58 >>>故障排除日志:删除未同步下发订单成功2604261845340083040552
2026-04-26 18:45:58 >>>故障排除日志:终端同步成功后剩余订单列表00832604261543550059670479
定时检测未同步订单启用[checkOrderNum=536878954]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 18:46:37 >>>回调事件[910,devices/D0480]
2026-04-26 18:46:38 >>>故障排除日志:上一MQTT订单号缓存列表为2604261845340083040552
2026-04-26 18:46:38 >>>故障排除日志:终端未同步成功订单列表00832604261543550059670479
2026-04-26 18:46:38 开始打印,排队:129,票券:2604261846222289405801,订单:2604261846220020534415,[2026-04-26 18:46:38微信支付10元]
2026-04-26 18:46:38>>>MQTT票号同步场景，创建空订单对象
2026-04-26 18:46:38>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 18:46:40 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261846222289405801","queue_number":129,"trade_uid":"2604261846220020534415"}]}
2026-04-26 18:46:40 >>>故障排除日志:删除未同步下发订单成功2604261846220020534415
2026-04-26 18:46:40 >>>故障排除日志:终端同步成功后剩余订单列表00832604261543550059670479
定时检测未同步订单启用[checkOrderNum=536878963]


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


===18:51:45===
2026-04-26 18:51:37>>>cash read=0A
2026-04-26 18:51:38>>>cash read=3E


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


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


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


===19:09:46===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:08:58 >>>回调事件[910,devices/D0480]
2026-04-26 19:08:58 >>>故障排除日志:上一MQTT订单号缓存列表为2604261907300033636997
2026-04-26 19:08:58 >>>故障排除日志:终端未同步成功订单列表00832604261543550059670479
2026-04-26 19:08:58 开始打印,排队:136,票券:2604261908432948175801,订单:2604261908430027348573,[2026-04-26 19:08:57支付宝支付10元]
2026-04-26 19:08:58 开始打印,排队:137,票券:2604261908432948885202,订单:2604261908430027348573,[2026-04-26 19:08:57支付宝支付10元]
2026-04-26 19:08:58>>>MQTT票号同步场景，创建空订单对象
2026-04-26 19:08:58>>>合并MQTT票号列表到订单同步请求,共2张票
2026-04-26 19:09:02 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261908432948175801","queue_number":136,"trade_uid":"2604261908430027348573"},{"ticket_no":"2604261908432948885202","queue_number":137,"trade_uid":"2604261908430027348573"}]}
2026-04-26 19:09:02 >>>故障排除日志:删除未同步下发订单成功2604261908430027348573
2026-04-26 19:09:02 >>>故障排除日志:删除未同步下发订单成功2604261908430027348573
2026-04-26 19:09:02 >>>故障排除日志:终端同步成功后剩余订单列表00832604261543550059670479
定时检测未同步订单启用[checkOrderNum=536879249]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:09:04 >>>回调事件[910,devices/D0480]
2026-04-26 19:09:04 >>>故障排除日志:上一MQTT订单号缓存列表为2604261908430027348573|2604261908430027348573
2026-04-26 19:09:04 >>>故障排除日志:终端未同步成功订单列表00832604261543550059670479
2026-04-26 19:09:04 开始打印,排队:138,票券:2604261908538491755901,订单:2604261908530081699212,[2026-04-26 19:09:04微信支付10元]
2026-04-26 19:09:04>>>MQTT票号同步场景，创建空订单对象
2026-04-26 19:09:04>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 19:09:06 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261908538491755901","queue_number":138,"trade_uid":"2604261908530081699212"}]}
2026-04-26 19:09:06 >>>故障排除日志:删除未同步下发订单成功2604261908530081699212
2026-04-26 19:09:06 >>>故障排除日志:终端同步成功后剩余订单列表00832604261543550059670479
定时检测未同步订单启用[checkOrderNum=536879256]


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


===19:20:47===
mqttTask.mqttMsgRecv.proc error
2026-04-26 19:20:12 >>>剩余flash空间=1681000,占用RAM为673.6572265625
2026-04-26 19:20:12 >>>回调异常:910,mqtt_tl,30000,mqtt_stop

2026-04-26 19:20:12 >>>MQTT连接断开，尝试重连中
2026-04-26 19:20:24 >>>剩余flash空间=1681000,占用RAM为664.099609375
2026-04-26 19:20:24 >>>回调事件:910,subscribe,10000,连接服务器成功

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

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


TCP://post-cn-09k20cnrl07.mqtt.aliyuncs.com:1883 closed@26_19:20:12
TCP://post-cn-09k20cnrl07.mqtt.aliyuncs.com:1883@26_19:20:12:send fail
===19:25:52===
2026-04-26 19:25:44>>>cash read=0A
2026-04-26 19:25:45>>>cash read=3E


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


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


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


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


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


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


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


===20:08:55===
2026-04-26 20:08:25>>>cash read=0A
2026-04-26 20:08:26>>>cash read=3E
mqttTask.mqttMsgRecv.proc error
2026-04-26 20:08:53 >>>剩余flash空间=1681000,占用RAM为687.66796875
2026-04-26 20:08:53 >>>回调异常:910,mqtt_tl,30000,mqtt_stop

2026-04-26 20:08:53 >>>MQTT连接断开，尝试重连中


TCP://post-cn-09k20cnrl07.mqtt.aliyuncs.com:1883 closed@26_20:08:53
TCP://post-cn-09k20cnrl07.mqtt.aliyuncs.com:1883@26_20:08:53:send fail
===20:09:55===
2026-04-26 20:09:04 >>>剩余flash空间=1682000,占用RAM为681.7265625
2026-04-26 20:09:04 >>>回调事件:910,subscribe,10000,连接服务器成功

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



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


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


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


===20:40:58===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 20:40:08 >>>回调事件[910,devices/D0480]
2026-04-26 20:40:08 >>>故障排除日志:上一MQTT订单号缓存列表为2604262034490073674338|2604262034490073674338
2026-04-26 20:40:08 >>>故障排除日志:终端未同步成功订单列表00832604261543550059670479
2026-04-26 20:40:08 开始打印,排队:153,票券:2604262040009829197401,订单:2604262040000096491041,[2026-04-26 20:40:08微信支付15元]
2026-04-26 20:40:08>>>MQTT票号同步场景，创建空订单对象
2026-04-26 20:40:08>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 20:40:10 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604262040009829197401","queue_number":153,"trade_uid":"2604262040000096491041"}]}
2026-04-26 20:40:10 >>>故障排除日志:删除未同步下发订单成功2604262040000096491041
2026-04-26 20:40:10 >>>故障排除日志:终端同步成功后剩余订单列表00832604261543550059670479
定时检测未同步订单启用[checkOrderNum=536880328]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 20:40:33 >>>回调事件[910,devic
===20:42:59===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 20:42:22 >>>回调事件[910,devices/D0480]
2026-04-26 20:42:22 >>>故障排除日志:上一MQTT订单号缓存列表为2604262040230096080312
2026-04-26 20:42:22 >>>故障排除日志:终端未同步成功订单列表00832604261543550059670479
2026-04-26 20:42:23 开始打印,排队:155,票券:2604262042052051287601,订单:2604262042050018461185,[2026-04-26 20:42:22微信支付10元]
2026-04-26 20:42:23>>>MQTT票号同步场景，创建空订单对象
2026-04-26 20:42:23>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 20:42:25 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604262042052051287601","queue_number":155,"trade_uid":"2604262042050018461185"}]}
2026-04-26 20:42:25 >>>故障排除日志:删除未同步下发订单成功2604262042050018461185
2026-04-26 20:42:25 >>>故障排除日志:终端同步成功后剩余订单列表00832604261543550059670479
定时检测未同步订单启用[checkOrderNum=536880377]


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


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


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


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


===21:10:25===
2026-04-26 21:09:20>>>cash read=00
2026-04-26 21:09:21>>>cash read=3E
2026-04-26 21:09:28>>>cash read=00
2026-04-26 21:09:29>>>cash read=29
2026-04-26 21:09:29 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 21:09:30>>>cash read=3E
2026-04-26 21:09:33>>>cash read=00
2026-04-26 21:09:34>>>cash read=01
2026-04-26 21:09:35>>>cash read=3E
2026-04-26 21:09:38>>>cash read=00
2026-04-26 21:09:39>>>cash read=29
2026-04-26 21:09:39 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 21:09:41>>>cash read=3E


TCP://log.tl-self.com:9807@26_21:10:13:connect fail
===21:20:25===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 21:20:09 >>>回调事件[910,devices/D0480]
2026-04-26 21:20:09 >>>故障排除日志:上一MQTT订单号缓存列表为2604262103250015448624
2026-04-26 21:20:09 >>>故障排除日志:终端未同步成功订单列表00832604261543550059670479
2026-04-26 21:20:09 开始打印,排队:160,票券:2604262120026489186301,订单:2604262120020061742098,[2026-04-26 21:20:09微信支付10元]
2026-04-26 21:20:09>>>MQTT票号同步场景，创建空订单对象
2026-04-26 21:20:09>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 21:20:11 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604262120026489186301","queue_number":160,"trade_uid":"2604262120020061742098"}]}
2026-04-26 21:20:11 >>>故障排除日志:删除未同步下发订单成功2604262120020061742098
2026-04-26 21:20:11 >>>故障排除日志:终端同步成功后剩余订单列表00832604261543550059670479
定时检测未同步订单启用[checkOrderNum=536880859]


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


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