TLClient_JSSCOM_LuatOS-Air_V4010_RDA8910_RFTTS_0xe0000,2.8.6,863013071882335,43264516318250,
poweron reason:0

===06:53:46===
硬币脉冲事件 msg=1,io=1,上升沿


===06:54:47===
上一时间戳为1777073275
隔日重置时间戳true
隔日清空未同步下发列表true
当前排队号为1,音量为5
初始化产品信息:[{"time_limit_date":"","ticket_category":"0","expiry_date":365,"product_detail":"","time_limit_status":"0","begin_minute":"00","product_uid":"99053357414028020","use_timer":1,"old_price":"10","end_hour":"23","sale_price":"10","end_minute":"59","begin_hour":"00","sale_status":1,"product_name":"快剪"}]
打印门店凭条广告设置为当天买票请当天使用概不退票，后期作废谢谢
是否打印二维码设置为1
是否打印紧凑设置为7
当前号显示模式设置为1
当前卡项核销权限设置为0
session_id:330d0****f3cc3
纸币器设置接收纸币范围为36
欢迎使用天羚自助售票系统[2.8.6]
定时检测未同步订单启用[checkOrderNum=536870971]
2026-04-26 06:53:46>>>cash write=30
2026-04-26 06:53:46>>>cash write=02
2026-04-26 06:53:46>>>cash write=3E
2026-04-26 06:53:46>>>cash read=808F808F
系统时间初始化成功，时间为202642665346
2026-04-26 06:53:47>>>cash write=02
2026-04-26 06:53:47>>>cash read=808F3E
2026-04-26 06:53:47 >>>剩余flash空间=1680000,占用RAM为657.3671875
2026-04-26 06:53:47 >>>回调事件:910,subscribe,10000,连接服务器成功

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

2026-04-26 06:53:49>>>cash write=0C
流量卡还有248天过期
2026-04-26 06:53:57 >>>当前Ram内存为650.9111328125


===07:43:48===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 07:43:08 >>>回调事件[910,devices/TL4969]
当日首次设置时间戳true为1777160588
2026-04-26 07:43:08 >>>故障排除日志:上一MQTT订单号缓存列表为2604252103040038508274
2026-04-26 07:43:08 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 07:43:08 开始打印,排队:1,票券:2604260742588364418601,订单:2604260742580080593226,[2026-04-26 07:43:07微信支付10元]
2026-04-26 07:43:08>>>MQTT票号同步场景，创建空订单对象
2026-04-26 07:43:08>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 07:43:10 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604260742588364418601","queue_number":1,"trade_uid":"2604260742580080593226"}]}
2026-04-26 07:43:10 >>>故障排除日志:删除未同步下发订单成功2604260742580080593226
2026-04-26 07:43:10 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536871444]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 07:43:19 收到下发指令:排队号nil>>>


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


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


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


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


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


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


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


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


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


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


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


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


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


===08:40:54===
2026-04-26 08:40:15>>>cash read=2F29
2026-04-26 08:40:16>>>cash read=01
2026-04-26 08:40:20>>>cash read=2F
2026-04-26 08:40:21>>>cash read=3E
2026-04-26 08:40:23>>>cash read=00
2026-04-26 08:40:24>>>cash read=2F2901
2026-04-26 08:40:26>>>cash read=3E
2026-04-26 08:40:35>>>cash read=00
2026-04-26 08:40:35>>>cash read=818F42
2026-04-26 08:40:35>>>cash write=02
2026-04-26 08:40:35 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 08:40:36>>>cash read=10
2026-04-26 08:40:36 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 08:40:36 当前产品价格10元，投币10元，打印小票中...
2026-04-26 08:40:36 >>>开始打印,排队号为18,订单号为2604260840360014969775
2026-04-26 08:40:36>>>订单2604260840360014969775写入成功,剩余空间为1679500,占用RAM为638.904296875
删除未同步订单2604260840360014969775
2026-04-26 08:40:38>>>订单2604260840360014969775删除成功,剩余空间为1680500,占用RAM为650.228515625
检测订单目录中>>>
无未同步订单>>>
2026-04-26 08:40:38 >>>当前Ram内存为618.146484375
定时检测未同步订单启用[checkOrderNum=536872113]
2026-04-26 08:40:39>>>cash write=0C
2026-04-26 08:40:39>>>cash read=3E


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


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


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


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


===08:59:57===
2026-04-26 08:59:32>>>cash read=29
2026-04-26 08:59:32 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 08:59:33>>>cash read=3E
2026-04-26 08:59:34>>>cash read=00
2026-04-26 08:59:35>>>cash read=3E
2026-04-26 08:59:38>>>cash read=29
2026-04-26 08:59:39 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 08:59:39>>>cash read=2F29
2026-04-26 08:59:40>>>cash read=01
2026-04-26 08:59:41>>>cash read=2F
2026-04-26 08:59:42>>>cash read=3E
2026-04-26 08:59:44>>>cash read=29
2026-04-26 08:59:44 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 08:59:44>>>cash read=2F29
2026-04-26 08:59:45 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 08:59:47>>>cash read=00
2026-04-26 08:59:48>>>cash read=818F42
2026-04-26 08:59:48>>>cash write=02
2026-04-26 08:59:48 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 08:59:48>>>cash read=10
2026-04-26 08:59:48 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 08:59:48 当前产品价格10元，投币10元，打印小票中...
2026-04-26 08:59:48 >>>开始打印,排队号为24,订单号为2604260859480014969815
2026-04-26 08:59:48>>>订单2604260859480014969815写入成功,剩余空间为1679000,占用RAM为640.80078125
删除未同步订单2604260859480014969815
2026-04-26 08:59:51>>>订单2604260859480014969815删除成功,剩余空间为1680000,占用RAM为652.4521484375
检测订单目录中>>>
无未同步订单>>>
2026-04-26 08:59:51 >>>当前Ram内存为617.7734375
定时检测未同步订单启用[checkOrderNum=536872344]
2026-04-26 08:59:52>>>cash write=0C
2026-04-26 08:59:52>>>cash read=3E


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


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


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


===09:44:59===
2026-04-26 09:44:11>>>cash read=29
2026-04-26 09:44:11 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 09:44:12>>>cash read=01
2026-04-26 09:44:13>>>cash read=3E
2026-04-26 09:44:14>>>cash read=29
2026-04-26 09:44:14 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 09:44:15>>>cash read=2F29
2026-04-26 09:44:16>>>cash read=01
2026-04-26 09:44:18>>>cash read=2F
2026-04-26 09:44:19>>>cash read=3E
2026-04-26 09:44:26>>>cash read=00
2026-04-26 09:44:27>>>cash read=818F42
2026-04-26 09:44:27>>>cash write=02
2026-04-26 09:44:27 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 09:44:27>>>cash read=10
2026-04-26 09:44:27 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 09:44:27 当前产品价格10元，投币10元，打印小票中...
2026-04-26 09:44:27 >>>开始打印,排队号为28,订单号为2604260944270014969438
2026-04-26 09:44:27>>>订单2604260944270014969438写入成功,剩余空间为1679500,占用RAM为637.4560546875
删除未同步订单2604260944270014969438
2026-04-26 09:44:30>>>订单2604260944270014969438删除成功,剩余空间为1680000,占用RAM为650.0927734375
检测订单目录中>>>
无未同步订单>>>
2026-04-26 09:44:30 >>>当前Ram内存为617.6875
定时检测未同步订单启用[checkOrderNum=536872776]
2026-04-26 09:44:31>>>cash write=0C
2026-04-26 09:44:31>>>cash read=3E


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


===12:22:14===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 12:21:37 收到下发指令:排队号2>>>
2026-04-26 12:21:37 收到下发指令:叫号2>>>
2026-04-26 12:21:56 收到下发指令:排队号2>>>
2026-04-26 12:21:56 收到下发指令:叫号2>>>
2026-04-26 12:22:05 收到下发指令:排队号2>>>
2026-04-26 12:22:05 收到下发指令:叫号2>>>


===12:23:15===
2026-04-26 12:22:27 收到下发指令:排队号2>>>
2026-04-26 12:22:27 收到下发指令:叫号2>>>
2026-04-26 12:22:37 收到下发指令:排队号2>>>
2026-04-26 12:22:37 收到下发指令:叫号2>>>
2026-04-26 12:22:51 收到下发指令:排队号2>>>
2026-04-26 12:22:51 收到下发指令:叫号2>>>
2026-04-26 12:23:12 收到下发指令:排队号2>>>
2026-04-26 12:23:12 收到下发指令:叫号2>>>


===12:24:15===
2026-04-26 12:23:25 收到下发指令:排队号2>>>
2026-04-26 12:23:25 收到下发指令:叫号2>>>
2026-04-26 12:23:37 收到下发指令:排队号2>>>
2026-04-26 12:23:37 收到下发指令:叫号2>>>
2026-04-26 12:23:54 收到下发指令:排队号2>>>
2026-04-26 12:23:54 收到下发指令:叫号2>>>
2026-04-26 12:24:06 收到下发指令:排队号2>>>
2026-04-26 12:24:06 收到下发指令:叫号2>>>


===12:25:16===
2026-04-26 12:24:15 收到下发指令:排队号2>>>
2026-04-26 12:24:15 收到下发指令:叫号2>>>
2026-04-26 12:24:27 收到下发指令:排队号2>>>
2026-04-26 12:24:27 收到下发指令:叫号2>>>
2026-04-26 12:24:48 收到下发指令:排队号3>>>
2026-04-26 12:24:48 收到下发指令:叫号3>>>
2026-04-26 12:25:01 收到下发指令:排队号3>>>
2026-04-26 12:25:01 收到下发指令:叫号3>>>
2026-04-26 12:25:14 收到下发指令:排队号3>>>
2026-04-26 12:25:14 收到下发指令:叫号3>>>


===12:26:16===
2026-04-26 12:25:35 收到下发指令:排队号3>>>
2026-04-26 12:25:35 收到下发指令:叫号3>>>
2026-04-26 12:25:45 收到下发指令:排队号3>>>
2026-04-26 12:25:45 收到下发指令:叫号3>>>
2026-04-26 12:25:53 收到下发指令:排队号3>>>
2026-04-26 12:25:53 收到下发指令:叫号3>>>
2026-04-26 12:26:04 收到下发指令:排队号3>>>
2026-04-26 12:26:04 收到下发指令:叫号3>>>


===12:27:17===
2026-04-26 12:26:27 收到下发指令:排队号3>>>
2026-04-26 12:26:27 收到下发指令:叫号3>>>
2026-04-26 12:26:40 收到下发指令:排队号3>>>
2026-04-26 12:26:40 收到下发指令:叫号3>>>
2026-04-26 12:26:49 收到下发指令:排队号3>>>
2026-04-26 12:26:49 收到下发指令:叫号3>>>
2026-04-26 12:27:03 收到下发指令:排队号3>>>
2026-04-26 12:27:03 收到下发指令:叫号3>>>
2026-04-26 12:27:14 收到下发指令:排队号3>>>
2026-04-26 12:27:14 收到下发指令:叫号3>>>


===12:28:17===
2026-04-26 12:27:30 收到下发指令:排队号3>>>
2026-04-26 12:27:30 收到下发指令:叫号3>>>
2026-04-26 12:27:50 收到下发指令:排队号3>>>
2026-04-26 12:27:50 收到下发指令:叫号3>>>
2026-04-26 12:28:07 收到下发指令:排队号3>>>
2026-04-26 12:28:07 收到下发指令:叫号3>>>


===12:29:17===
2026-04-26 12:28:25 收到下发指令:排队号3>>>
2026-04-26 12:28:25 收到下发指令:叫号3>>>
2026-04-26 12:28:46 收到下发指令:排队号3>>>
2026-04-26 12:28:46 收到下发指令:叫号3>>>
2026-04-26 12:29:02 收到下发指令:排队号3>>>
2026-04-26 12:29:02 收到下发指令:叫号3>>>
2026-04-26 12:29:15 收到下发指令:排队号3>>>
2026-04-26 12:29:15 收到下发指令:叫号3>>>


===12:30:18===
2026-04-26 12:29:39 收到下发指令:排队号3>>>
2026-04-26 12:29:39 收到下发指令:叫号3>>>
2026-04-26 12:29:53 收到下发指令:排队号4>>>
2026-04-26 12:29:53 收到下发指令:叫号4>>>
2026-04-26 12:30:08 收到下发指令:排队号4>>>
2026-04-26 12:30:08 收到下发指令:叫号4>>>


===12:31:18===
2026-04-26 12:30:19 收到下发指令:排队号4>>>
2026-04-26 12:30:19 收到下发指令:叫号4>>>
2026-04-26 12:30:40 收到下发指令:排队号4>>>
2026-04-26 12:30:40 收到下发指令:叫号4>>>
2026-04-26 12:30:54 收到下发指令:排队号4>>>
2026-04-26 12:30:54 收到下发指令:叫号4>>>
2026-04-26 12:31:09 收到下发指令:排队号4>>>
2026-04-26 12:31:09 收到下发指令:叫号4>>>


===12:32:18===
2026-04-26 12:31:33 收到下发指令:排队号4>>>
2026-04-26 12:31:33 收到下发指令:叫号4>>>
2026-04-26 12:31:42 收到下发指令:排队号4>>>
2026-04-26 12:31:42 收到下发指令:叫号4>>>
2026-04-26 12:32:07 收到下发指令:排队号4>>>
2026-04-26 12:32:07 收到下发指令:叫号4>>>


===12:33:19===
2026-04-26 12:32:27 收到下发指令:排队号4>>>
2026-04-26 12:32:27 收到下发指令:叫号4>>>
2026-04-26 12:32:40 收到下发指令:排队号4>>>
2026-04-26 12:32:40 收到下发指令:叫号4>>>
2026-04-26 12:32:51 收到下发指令:排队号4>>>
2026-04-26 12:32:51 收到下发指令:叫号4>>>
2026-04-26 12:33:03 收到下发指令:排队号4>>>
2026-04-26 12:33:03 收到下发指令:叫号4>>>
2026-04-26 12:33:17 收到下发指令:排队号4>>>
2026-04-26 12:33:17 收到下发指令:叫号4>>>


===12:34:19===
2026-04-26 12:33:50 收到下发指令:排队号18>>>
2026-04-26 12:33:50 收到下发指令:叫号18>>>
2026-04-26 12:34:06 收到下发指令:排队号18>>>
2026-04-26 12:34:07 收到下发指令:叫号18>>>


===12:35:19===
2026-04-26 12:34:23 收到下发指令:排队号46>>>
2026-04-26 12:34:23 收到下发指令:叫号46>>>
2026-04-26 12:34:51 收到下发指令:排队号46>>>
2026-04-26 12:34:51 收到下发指令:叫号46>>>


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


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


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


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


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


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


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


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


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


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


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


===13:23:25===
2026-04-26 13:23:00>>>cash read=29
2026-04-26 13:23:00 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 13:23:01>>>cash read=3E


===13:24:25===
2026-04-26 13:24:02>>>cash read=00
2026-04-26 13:24:04>>>cash read=29
2026-04-26 13:24:04 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 13:24:04>>>cash read=2F29
2026-04-26 13:24:06>>>cash read=3E
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 13:24:08 >>>回调事件[910,devices/TL4969]
2026-04-26 13:24:08 >>>故障排除日志:上一MQTT订单号缓存列表为2604261320170069346498
2026-04-26 13:24:08 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 13:24:08 开始打印,排队:78,票券:2604261323574036991201,订单:2604261323570037931127,[2026-04-26 13:24:06微信支付10元]
2026-04-26 13:24:08>>>MQTT票号同步场景，创建空订单对象
2026-04-26 13:24:08>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 13:24:10 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261323574036991201","queue_number":78,"trade_uid":"2604261323570037931127"}]}
2026-04-26 13:24:10 >>>故障排除日志:删除未同步下发订单成功2604261323570037931127
2026-04-26 13:24:10 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536875332]


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


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


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


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


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


===14:11:28===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 14:10:54 >>>回调事件[910,devices/TL4969]
2026-04-26 14:10:54 >>>故障排除日志:上一MQTT订单号缓存列表为2604261354310001798671
2026-04-26 14:10:54 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 14:10:54 开始打印,排队:85,票券:2604261410473768623401,订单:2604261410470035542076,[2026-04-26 14:10:53微信支付10元]
2026-04-26 14:10:54>>>MQTT票号同步场景，创建空订单对象
2026-04-26 14:10:54>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 14:10:56 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261410473768623401","queue_number":85,"trade_uid":"2604261410470035542076"}]}
2026-04-26 14:10:56 >>>故障排除日志:删除未同步下发订单成功2604261410470035542076
2026-04-26 14:10:56 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536875799]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 14:11:06 >>>回调事件[910,devices/TL4969]
2026-04-26 14:11:06 >>>故障排除日志:上一MQTT订单号缓存列表为2604261410470035542076
2026-04-26 14:11:06 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 14:11:06 开始打印,排队:86,票券:2604261410542646209601,订单:2604261410540024603574,[2026-04-26 14:11:06微信支付10元]
2026-04-26 14:11:07>>>MQTT票号同步场景，创建空订单对象
2026-04-26 14:11:07>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 14:11:08 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261410542646209601","queue_number":86,"trade_uid":"2604261410540024603574"}]}
2026-04-26 14:11:08 >>>故障排除日志:删除未同步下发订单成功2604261410540024603574
2026-04-26 14:11:09 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536875808]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 14:11:18 >>>回调事件[910,devices/TL4969]
2026-04-26 14:11:18 >>>故障排除日志:上一MQTT订单号缓存列表为2604261410540024603574
2026-04-26 14:11:18 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 14:11:18 开始打印,排队:87,票券:2604261411086330021401,订单:2604261411080061298667,[2026-04-26 14:11:17微信支付10元]
2026-04-26 14:11:18>>>MQTT票号同步场景，创建空订单对象
2026-04-26 14:11:18>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 14:11:20 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261411086330021401","queue_number":87,"trade_uid":"2604261411080061298667"}]}
2026-04-26 14:11:20 >>>故障排除日志:删除未同步下发订单成功2604261411080061298667
2026-04-26 14:11:20 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536875814]


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


===16:09:39===
2026-04-26 16:08:48>>>cash read=29
2026-04-26 16:08:48 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 16:08:49>>>cash read=2F29
2026-04-26 16:08:50>>>cash read=01
2026-04-26 16:08:52>>>cash read=2F
2026-04-26 16:08:54>>>cash read=3E
2026-04-26 16:09:05>>>cash read=00
2026-04-26 16:09:06>>>cash read=01
2026-04-26 16:09:09>>>cash read=3E
2026-04-26 16:09:16>>>cash read=00
2026-04-26 16:09:17>>>cash read=29
2026-04-26 16:09:17 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 16:09:18>>>cash read=01
2026-04-26 16:09:23>>>cash read=00
2026-04-26 16:09:23>>>cash read=818F42
2026-04-26 16:09:24>>>cash write=02
2026-04-26 16:09:24 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 16:09:24>>>cash read=10
2026-04-26 16:09:24 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 16:09:24 当前产品价格10元，投币10元，打印小票中...
2026-04-26 16:09:24 >>>开始打印,排队号为112,订单号为2604261609240014969258
2026-04-26 16:09:24>>>订单2604261609240014969258写入成功,剩余空间为1679000,占用RAM为639.1962890625
删除未同步订单2604261609240014969258
2026-04-26 16:09:26>>>订单2604261609240014969258删除成功,剩余空间为1680000,占用RAM为651.048828125
检测订单目录中>>>
无未同步订单>>>
2026-04-26 16:09:27 >>>当前Ram内存为618.4677734375
定时检测未同步订单启用[checkOrderNum=536877055]
2026-04-26 16:09:27>>>cash write=0C
2026-04-26 16:09:27>>>cash read=3E


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


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


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


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


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


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


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


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


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


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


===16:40:45===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 16:39:59 >>>回调事件[910,devices/TL4969]
2026-04-26 16:39:59 >>>故障排除日志:上一MQTT订单号缓存列表为2604261638570032923195
2026-04-26 16:39:59 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 16:39:59 开始打印,排队:125,票券:2604261639524837155601,订单:2604261639520045584131,[2026-04-26 16:39:58微信支付10元]
2026-04-26 16:39:59>>>MQTT票号同步场景，创建空订单对象
2026-04-26 16:39:59>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 16:40:01 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261639524837155601","queue_number":125,"trade_uid":"2604261639520045584131"}]}
2026-04-26 16:40:01 >>>故障排除日志:删除未同步下发订单成功2604261639520045584131
2026-04-26 16:40:02 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877449]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 16:40:29 >>>回调事件[910,devices/TL4969]
2026-04-26 16:40:29 >>>故障排除日志:上一MQTT订单号缓存列表为2604261639520045584131
2026-04-26 16:40:29 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 16:40:29 开始打印,排队:126,票券:2604261640203383525801,订单:2604261640200032118821,[2026-04-26 16:40:28微信支付10元]
2026-04-26 16:40:29>>>MQTT票号同步场景，创建空订单对象
2026-04-26 16:40:29>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 16:40:31 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261640203383525801","queue_number":126,"trade_uid":"2604261640200032118821"}]}
2026-04-26 16:40:31 >>>故障排除日志:删除未同步下发订单成功2604261640200032118821
2026-04-26 16:40:31 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877457]


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


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


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


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


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


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


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


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


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


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


===17:11:53===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 17:11:09 >>>回调事件[910,devices/TL4969]
2026-04-26 17:11:09 >>>故障排除日志:上一MQTT订单号缓存列表为2604261707320047269558
2026-04-26 17:11:09 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 17:11:09 开始打印,排队:140,票券:2604261711022548357901,订单:2604261711020023675534,[2026-04-26 17:11:09微信支付10元]
2026-04-26 17:11:09 开始打印,排队:141,票券:2604261711055593117101,订单:2604261711050051466958,[2026-04-26 17:11:08支付宝支付10元]
2026-04-26 17:11:09>>>MQTT票号同步场景，创建空订单对象
2026-04-26 17:11:09>>>合并MQTT票号列表到订单同步请求,共2张票
2026-04-26 17:11:09 >>>回调事件[910,devices/TL4969]
2026-04-26 17:11:10 >>>故障排除日志:上一MQTT订单号缓存列表为2604261711020023675534|2604261711050051466958
2026-04-26 17:11:10 >>>故障排除日志:终端未同步成功订单列表01402604261711020023675534|01412604261711050051466958
已接收过此消息,票券号为2604261711022548357901,排队号为140
已接收过此消息,票券号为2604261711055593117101,排队号为141
2026-04-26 17:11:10>>>HTTP请求进行中，跳过本次同步
2026-04-26 17:11:13 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261711022548357901","queue_number":140,"trade_uid":"2604261711020023675534"},{"ticket_no":"2604261711055593117101","queue_number":141,"trade_uid":"2604261711050051466958"}]}
2026-04-26 17:11:13 >>>故障排除日志:删除未同步下发订单成功2604261711020023675534
2026-04-26 17:11:13 >>>故障排除日志:删除未同步下发订单成功2604261711050051466958
2026-04-26 17:11:13 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877836]


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


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


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


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


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


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


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


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


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


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


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


===17:43:00===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 17:42:21 >>>回调事件[910,devices/TL4969]
2026-04-26 17:42:21 >>>故障排除日志:上一MQTT订单号缓存列表为2604261738280092032114
2026-04-26 17:42:21 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 17:42:21 开始打印,排队:154,票券:2604261742149563251401,订单:2604261742140093125913,[2026-04-26 17:42:20微信支付10元]
2026-04-26 17:42:21>>>MQTT票号同步场景，创建空订单对象
2026-04-26 17:42:21>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 17:42:23 >>>回调事件[910,devices/TL4969]
2026-04-26 17:42:23 >>>故障排除日志:上一MQTT订单号缓存列表为2604261742140093125913
2026-04-26 17:42:23 >>>故障排除日志:终端未同步成功订单列表01542604261742140093125913
已接收过此消息,票券号为2604261742149563251401,排队号为154
2026-04-26 17:42:23 开始打印,排队:155,票券:2604261742162364588101,订单:2604261742160021300956,[2026-04-26 17:42:21微信支付10元]
2026-04-26 17:42:23 开始打印,排队:156,票券:2604261742162365034202,订单:2604261742160021300956,[2026-04-26 17:42:21微信支付10元]
2026-04-26 17:42:23>>>HTTP请求进行中，跳过本次同步
2026-04-26 17:42:27 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261742149563251401","queue_number":154,"trade_uid":"2604261742140093125913"}]}
2026-04-26 17:42:27 >>>故障排除日志:删除未同步下发订单成功2604261742140093125913
2026-04-26 17:42:27 >>>故障排除日志:终端同步成功后剩余订单列表01552604261742160021300956|01562604261742160021300956
定时检测未同步订单启用[checkOrderNum=536878230]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 17:42:48 >>>回调事件[910,devices/TL4969]
2026-04-26 17:42:48 >>>故障排除日志:上一MQTT订单号缓存列表为2604261742140093125913|2604261742160021300956|2604261742160021300956
2026-04-26 17:42:48 >>>故障排除日志:终端未同步成功订单列表01552604261742160021300956|01562604261742160021300956
已接收过此消息,票券号为2604261742162364588101,排队号为155
已接收过此消息,票券号为2604261742162365034202,排队号为156
2026-04-26 17:42:48 开始打印,排队:157,票券:2604261742373923952401,订单:2604261742370037245551,[2026-04-26 17:42:45微信支付10元]
2026-04-26 17:42:48>>>MQTT票号同步场景，创建空订单对象
2026-04-26 17:42:48>>>合并MQTT票号列表到订单同步请求,共3张票
2026-04-26 17:42:50 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261742162364588101","queue_number":155,"trade_uid":"2604261742160021300956"},{"ticket_no":"2604261742162365034202","queue_number":156,"trade_uid":"2604261742160021300956"},{"ticket_no":"2604261742373923952401","queue_number":157,"trade_uid":"2604261742370037245551"}]}
2026-04-26 17:42:50 >>>故障排除日志:删除未同步下发订单成功2604261742160021300956
2026-04-26 17:42:50 >>>故障排除日志:删除未同步下发订单成功2604261742160021300956
2026-04-26 17:42:51 >>>故障排除日志:删除未同步下发订单成功2604261742370037245551
2026-04-26 17:42:51 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878246]


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


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


===18:00:01===
2026-04-26 17:59:00 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261758470988307201","queue_number":159,"trade_uid":"2604261758470007421769"}]}
2026-04-26 17:59:00 >>>故障排除日志:删除未同步下发订单成功2604261758470007421769
2026-04-26 17:59:00 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878408]
2026-04-26 17:59:23>>>cash read=00
2026-04-26 17:59:24>>>cash read=01
2026-04-26 17:59:25>>>cash read=3E
2026-04-26 17:59:30>>>cash read=00
2026-04-26 17:59:30>>>cash read=818F42
2026-04-26 17:59:30>>>cash write=02
2026-04-26 17:59:30 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 17:59:30>>>cash read=10
2026-04-26 17:59:30 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 17:59:30 当前产品价格10元，投币10元，打印小票中...
2026-04-26 17:59:30 >>>开始打印,排队号为160,订单号为2604261759300014969371
2026-04-26 17:59:31>>>订单2604261759300014969371写入成功,剩余空间为1679000,占用RAM为636.220703125
删除未同步订单2604261759300014969371
2026-04-26 17:59:33>>>订单2604261759300014969371删除成功,剩余空间为1680000,占用RAM为648.29296875
检测订单目录中>>>
无未同步订单>>>
2026-04-26 17:59:33 >>>当前Ram内存为615.6865234375
定时检测未同步订单启用[checkOrderNum=536878418]
2026-04-26 17:59:34>>>cash write=0C
2026-04-26 17:59:34>>>cash read=3E


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


===18:53:09===
2026-04-26 18:52:14>>>cash read=00
2026-04-26 18:52:15>>>cash read=818F42
2026-04-26 18:52:15>>>cash write=02
2026-04-26 18:52:15 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 18:52:16>>>cash read=10
2026-04-26 18:52:16 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 18:52:16 当前产品价格10元，投币10元，打印小票中...
2026-04-26 18:52:16 >>>开始打印,排队号为180,订单号为2604261852160014969574
2026-04-26 18:52:16>>>订单2604261852160014969574写入成功,剩余空间为1679500,占用RAM为634.13671875
删除未同步订单2604261852160014969574
2026-04-26 18:52:18>>>订单2604261852160014969574删除成功,剩余空间为1680500,占用RAM为647.1708984375
检测订单目录中>>>
无未同步订单>>>
2026-04-26 18:52:18 >>>当前Ram内存为615.7958984375
定时检测未同步订单启用[checkOrderNum=536879067]
2026-04-26 18:52:19>>>cash write=0C
2026-04-26 18:52:19>>>cash read=3E
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 18:53:04 >>>回调事件[910,devices/TL4969]
2026-04-26 18:53:04 >>>故障排除日志:上一MQTT订单号缓存列表为2604261845180045558987
2026-04-26 18:53:04 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 18:53:04 开始打印,排队:181,票券:2604261852558549741501,订单:2604261852550082997213,[2026-04-26 18:53:03微信支付10元]
2026-04-26 18:53:04>>>MQTT票号同步场景，创建空订单对象
2026-04-26 18:53:04>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 18:53:06 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261852558549741501","queue_number":181,"trade_uid":"2604261852550082997213"}]}
2026-04-26 18:53:06 >>>故障排除日志:删除未同步下发订单成功2604261852550082997213
2026-04-26 18:53:06 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536879082]


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


===19:30:16===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:29:25 >>>回调事件[910,devices/TL4969]
2026-04-26 19:29:25 >>>故障排除日志:上一MQTT订单号缓存列表为2604261926080056149648
2026-04-26 19:29:25 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 19:29:25 开始打印,排队:202,票券:2604261929172792892801,订单:2604261929170026098859,[2026-04-26 19:29:25微信支付10元]
2026-04-26 19:29:25>>>MQTT票号同步场景，创建空订单对象
2026-04-26 19:29:25>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 19:29:27 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261929172792892801","queue_number":202,"trade_uid":"2604261929170026098859"}]}
2026-04-26 19:29:27 >>>故障排除日志:删除未同步下发订单成功2604261929170026098859
2026-04-26 19:29:27 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536879560]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:29:49 >>>回调事件[910,devices/TL4969]
2026-04-26 19:29:49 >>>故障排除日志:上一MQTT订单号缓存列表为2604261929170026098859
2026-04-26 19:29:49 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 19:29:49 开始打印,排队:203,票券:2604261929386836346801,订单:2604261929380066313696,[2026-04-26 19:29:48微信支付10元]
2026-04-26 19:29:49>>>MQTT票号同步场景，创建空订单对象
2026-04-26 19:29:49>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 19:29:51 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261929386836346801","queue_number":203,"trade_uid":"2604261929380066313696"}]}
2026-04-26 19:29:51 >>>故障排除日志:删除未同步下发订单成功2604261929380066313696
2026-04-26 19:29:52 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536879571]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:29:52 >>>回调事件[910,devices/TL4969]
2026-04-26 19:29:52 >>>故障排除日志:上一MQTT订单号缓存列表为2604261929380066313696
2026-04-26 19:29:52 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 19:29:52 开始打印,排队:204,票券:2604261929395485379601,订单:2604261929390053153597,[2026-04-26 19:29:51微信支付10元]
2026-04-26 19:29:52>>>MQTT票号同步场景，创建空订单对象
2026-04-26 19:29:52>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 19:29:54 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261929395485379601","queue_number":204,"trade_uid":"2604261929390053153597"}]}
2026-04-26 19:29:54 >>>故障排除日志:删除未同步下发订单成功2604261929390053153597
2026-04-26 19:29:54 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536879578]


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


===21:00:26===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 21:00:17 收到下发指令:排队号46>>>
2026-04-26 21:00:17 收到下发指令:叫号46>>>
2026-04-26 21:00:20 收到下发指令:排队号46>>>
2026-04-26 21:00:20 收到下发指令:叫号46>>>


===21:01:27===
2026-04-26 21:00:27 收到下发指令:排队号46>>>
2026-04-26 21:00:27 收到下发指令:叫号46>>>
2026-04-26 21:00:31 收到下发指令:排队号46>>>
2026-04-26 21:00:31 收到下发指令:叫号46>>>
2026-04-26 21:00:35 收到下发指令:排队号46>>>
2026-04-26 21:00:35 收到下发指令:叫号46>>>
2026-04-26 21:00:40 收到下发指令:排队号46>>>
2026-04-26 21:00:40 收到下发指令:叫号46>>>
2026-04-26 21:00:44 收到下发指令:排队号46>>>
2026-04-26 21:00:44 收到下发指令:叫号46>>>
2026-04-26 21:00:48 收到下发指令:排队号46>>>
2026-04-26 21:00:48 收到下发指令:叫号46>>>
2026-04-26 21:00:51 收到下发指令:排队号46>>>
2026-04-26 21:00:51 收到下发指令:叫号46>>>
2026-04-26 21:00:56 收到下发指令:排队号46>>>
2026-04-26 21:00:56 收到下发指令:叫号46>>>
2026-04-26 21:01:01 收到下发指令:排队号46>>>
2026-04-26 21:01:01 收到下发指令:叫号46>>>
2026-04-26 21:01:04 收到下发指令:排队号46>>>
2026-04-26 21:01:04 收到下发指令:叫号46>>>
2026-04-26 21:01:08 收到下发指令:排队号46>>>
2026-04-26 21:01:08 收到下发指令:叫号46>>>
2026-04-26 21:01:13 收到下发指令:排队号46>>>
2026-04-26 21:01:13 收到下发指令:叫号46>>>
2026-04-26 21:01:17 收到下发指令:排队号46>>>
2026-04-26 21:01:17 收到下发指令:叫号46>>>
2026-04-26 21:01:21 收到下发指令:排队号46>>>
2026-04-26 21:01:21 收到下发指令:叫号46>>>
2026-04-26 21:01:24 收到下发指令:排队号46>>>
2026-04-26 21:01:24 收到下发指令:叫号46>>>


===21:02:27===
2026-04-26 21:01:28 收到下发指令:排队号46>>>
2026-04-26 21:01:28 收到下发指令:叫号46>>>
2026-04-26 21:01:32 收到下发指令:排队号46>>>
2026-04-26 21:01:32 收到下发指令:叫号46>>>
2026-04-26 21:01:36 收到下发指令:排队号46>>>
2026-04-26 21:01:36 收到下发指令:叫号46>>>
2026-04-26 21:01:40 收到下发指令:排队号46>>>
2026-04-26 21:01:40 收到下发指令:叫号46>>>
2026-04-26 21:01:44 收到下发指令:排队号46>>>
2026-04-26 21:01:44 收到下发指令:叫号46>>>
2026-04-26 21:01:48 收到下发指令:排队号46>>>
2026-04-26 21:01:48 收到下发指令:叫号46>>>
2026-04-26 21:01:58 收到下发指令:排队号46>>>
2026-04-26 21:01:58 收到下发指令:叫号46>>>
2026-04-26 21:02:00 收到下发指令:排队号46>>>
2026-04-26 21:02:00 收到下发指令:叫号46>>>
2026-04-26 21:02:04 收到下发指令:排队号46>>>
2026-04-26 21:02:04 收到下发指令:叫号46>>>
2026-04-26 21:02:09 收到下发指令:排队号46>>>
2026-04-26 21:02:09 收到下发指令:叫号46>>>
2026-04-26 21:02:13 收到下发指令:排队号46>>>
2026-04-26 21:02:13 收到下发指令:叫号46>>>
2026-04-26 21:02:16 收到下发指令:排队号46>>>
2026-04-26 21:02:16 收到下发指令:叫号46>>>
2026-04-26 21:02:23 收到下发指令:排队号46>>>
2026-04-26 21:02:23 收到下发指令:叫号46>>>


===21:03:27===
2026-04-26 21:02:26 收到下发指令:排队号46>>>
2026-04-26 21:02:26 收到下发指令:叫号46>>>
2026-04-26 21:02:35 收到下发指令:排队号46>>>
2026-04-26 21:02:35 收到下发指令:叫号46>>>
2026-04-26 21:02:39 收到下发指令:排队号46>>>
2026-04-26 21:02:39 收到下发指令:叫号46>>>
2026-04-26 21:02:42 收到下发指令:排队号46>>>
2026-04-26 21:02:42 收到下发指令:叫号46>>>
2026-04-26 21:02:46 收到下发指令:排队号46>>>
2026-04-26 21:02:46 收到下发指令:叫号46>>>
2026-04-26 21:02:49 收到下发指令:排队号46>>>
2026-04-26 21:02:49 收到下发指令:叫号46>>>
2026-04-26 21:02:53 收到下发指令:排队号46>>>
2026-04-26 21:02:53 收到下发指令:叫号46>>>
2026-04-26 21:02:57 收到下发指令:排队号46>>>
2026-04-26 21:02:57 收到下发指令:叫号46>>>
2026-04-26 21:03:01 收到下发指令:排队号46>>>
2026-04-26 21:03:01 收到下发指令:叫号46>>>
2026-04-26 21:03:04 收到下发指令:排队号46>>>
2026-04-26 21:03:04 收到下发指令:叫号46>>>
2026-04-26 21:03:08 收到下发指令:排队号46>>>
2026-04-26 21:03:08 收到下发指令:叫号46>>>
2026-04-26 21:03:12 收到下发指令:排队号46>>>
2026-04-26 21:03:12 收到下发指令:叫号46>>>
2026-04-26 21:03:16 收到下发指令:排队号46>>>
2026-04-26 21:03:16 收到下发指令:叫号46>>>
2026-04-26 21:03:22 收到下发指令:排队号46>>>
2026-04-26 21:03:22 收到下发指令:叫号46>>>


===21:04:28===
2026-04-26 21:03:39 收到下发指令:排队号46>>>
2026-04-26 21:03:39 收到下发指令:叫号46>>>
2026-04-26 21:03:47 收到下发指令:排队号46>>>
2026-04-26 21:03:47 收到下发指令:叫号46>>>
2026-04-26 21:03:50 收到下发指令:排队号46>>>
2026-04-26 21:03:50 收到下发指令:叫号46>>>
2026-04-26 21:03:54 收到下发指令:排队号46>>>
2026-04-26 21:03:54 收到下发指令:叫号46>>>
2026-04-26 21:03:58 收到下发指令:排队号46>>>
2026-04-26 21:03:58 收到下发指令:叫号46>>>
2026-04-26 21:04:01 收到下发指令:排队号46>>>
2026-04-26 21:04:01 收到下发指令:叫号46>>>
2026-04-26 21:04:05 收到下发指令:排队号46>>>
2026-04-26 21:04:05 收到下发指令:叫号46>>>
2026-04-26 21:04:08 收到下发指令:排队号46>>>
2026-04-26 21:04:08 收到下发指令:叫号46>>>
2026-04-26 21:04:12 收到下发指令:排队号46>>>
2026-04-26 21:04:12 收到下发指令:叫号46>>>
2026-04-26 21:04:16 收到下发指令:排队号46>>>
2026-04-26 21:04:16 收到下发指令:叫号46>>>
2026-04-26 21:04:19 收到下发指令:排队号46>>>
2026-04-26 21:04:19 收到下发指令:叫号46>>>
2026-04-26 21:04:23 收到下发指令:排队号46>>>
2026-04-26 21:04:23 收到下发指令:叫号46>>>


===21:05:28===
2026-04-26 21:04:30 收到下发指令:排队号46>>>
2026-04-26 21:04:30 收到下发指令:叫号46>>>
2026-04-26 21:04:34 收到下发指令:排队号46>>>
2026-04-26 21:04:34 收到下发指令:叫号46>>>
2026-04-26 21:04:38 收到下发指令:排队号46>>>
2026-04-26 21:04:38 收到下发指令:叫号46>>>
2026-04-26 21:04:42 收到下发指令:排队号46>>>
2026-04-26 21:04:42 收到下发指令:叫号46>>>
2026-04-26 21:04:45 收到下发指令:排队号46>>>
2026-04-26 21:04:45 收到下发指令:叫号46>>>
2026-04-26 21:04:51 收到下发指令:排队号46>>>
2026-04-26 21:04:51 收到下发指令:叫号46>>>
2026-04-26 21:04:55 收到下发指令:排队号46>>>
2026-04-26 21:04:55 收到下发指令:叫号46>>>
2026-04-26 21:04:58 收到下发指令:排队号46>>>
2026-04-26 21:04:58 收到下发指令:叫号46>>>
2026-04-26 21:05:03 收到下发指令:排队号48>>>
2026-04-26 21:05:03 收到下发指令:叫号48>>>
2026-04-26 21:05:07 收到下发指令:排队号48>>>
2026-04-26 21:05:07 收到下发指令:叫号48>>>
2026-04-26 21:05:11 收到下发指令:排队号48>>>
2026-04-26 21:05:11 收到下发指令:叫号48>>>
2026-04-26 21:05:14 收到下发指令:排队号48>>>
2026-04-26 21:05:14 收到下发指令:叫号48>>>
2026-04-26 21:05:18 收到下发指令:排队号48>>>
2026-04-26 21:05:18 收到下发指令:叫号48>>>
2026-04-26 21:05:22 收到下发指令:排队号48>>>
2026-04-26 21:05:22 收到下发指令:叫号48>>>
2026-04-26 21:05:26 收到下发指令:排队号48>>>
2026-04-26 21:05:26 收到下发指令:叫号48>>>


===21:06:29===
2026-04-26 21:05:30 收到下发指令:排队号48>>>
2026-04-26 21:05:30 收到下发指令:叫号48>>>
2026-04-26 21:05:33 收到下发指令:排队号48>>>
2026-04-26 21:05:33 收到下发指令:叫号48>>>
2026-04-26 21:05:37 收到下发指令:排队号48>>>
2026-04-26 21:05:37 收到下发指令:叫号48>>>
2026-04-26 21:05:40 收到下发指令:排队号48>>>
2026-04-26 21:05:40 收到下发指令:叫号48>>>
2026-04-26 21:05:44 收到下发指令:排队号48>>>
2026-04-26 21:05:44 收到下发指令:叫号48>>>
2026-04-26 21:05:48 收到下发指令:排队号48>>>
2026-04-26 21:05:48 收到下发指令:叫号48>>>
2026-04-26 21:05:52 收到下发指令:排队号48>>>
2026-04-26 21:05:52 收到下发指令:叫号48>>>
2026-04-26 21:05:56 收到下发指令:排队号48>>>
2026-04-26 21:05:56 收到下发指令:叫号48>>>
2026-04-26 21:06:03 收到下发指令:排队号48>>>
2026-04-26 21:06:03 收到下发指令:叫号48>>>
2026-04-26 21:06:06 收到下发指令:排队号48>>>
2026-04-26 21:06:06 收到下发指令:叫号48>>>
2026-04-26 21:06:10 收到下发指令:排队号48>>>
2026-04-26 21:06:10 收到下发指令:叫号48>>>
2026-04-26 21:06:14 收到下发指令:排队号48>>>
2026-04-26 21:06:14 收到下发指令:叫号48>>>
2026-04-26 21:06:18 收到下发指令:排队号48>>>
2026-04-26 21:06:18 收到下发指令:叫号48>>>
2026-04-26 21:06:23 收到下发指令:排队号48>>>
2026-04-26 21:06:23 收到下发指令:叫号48>>>
2026-04-26 21:06:26 收到下发指令:排队号48>>>
2026-04-26 21:06:26 收到下发指令:叫号48>>>


===21:07:30===
2026-04-26 21:06:30 收到下发指令:排队号48>>>
2026-04-26 21:06:30 收到下发指令:叫号48>>>
2026-04-26 21:06:33 收到下发指令:排队号48>>>
2026-04-26 21:06:33 收到下发指令:叫号48>>>
2026-04-26 21:06:37 收到下发指令:排队号48>>>
2026-04-26 21:06:37 收到下发指令:叫号48>>>
2026-04-26 21:06:41 收到下发指令:排队号48>>>
2026-04-26 21:06:41 收到下发指令:叫号48>>>
2026-04-26 21:06:44 收到下发指令:排队号48>>>
2026-04-26 21:06:44 收到下发指令:叫号48>>>
2026-04-26 21:06:48 收到下发指令:排队号48>>>
2026-04-26 21:06:48 收到下发指令:叫号48>>>
2026-04-26 21:06:51 收到下发指令:排队号48>>>
2026-04-26 21:06:51 收到下发指令:叫号48>>>
2026-04-26 21:06:55 收到下发指令:排队号48>>>
2026-04-26 21:06:55 收到下发指令:叫号48>>>
2026-04-26 21:06:58 收到下发指令:排队号48>>>
2026-04-26 21:06:58 收到下发指令:叫号48>>>
2026-04-26 21:07:02 收到下发指令:排队号48>>>
2026-04-26 21:07:02 收到下发指令:叫号48>>>
2026-04-26 21:07:06 收到下发指令:排队号48>>>
2026-04-26 21:07:06 收到下发指令:叫号48>>>
2026-04-26 21:07:12 收到下发指令:排队号48>>>
2026-04-26 21:07:12 收到下发指令:叫号48>>>
2026-04-26 21:07:16 收到下发指令:排队号48>>>
2026-04-26 21:07:16 收到下发指令:叫号48>>>
2026-04-26 21:07:19 收到下发指令:排队号48>>>
2026-04-26 21:07:19 收到下发指令:叫号48>>>
2026-04-26 21:07:24 收到下发指令:排队号48>>>
2026-04-26 21:07:24 收到下发指令:叫号48>>>
2026-04-26 21:07:27 收到下发指令:排队号48>>>
2026-04-26 21:07:27 收到下发指令:叫号48>>>


===21:08:30===
2026-04-26 21:07:31 收到下发指令:排队号48>>>
2026-04-26 21:07:31 收到下发指令:叫号48>>>
2026-04-26 21:07:34 收到下发指令:排队号48>>>
2026-04-26 21:07:34 收到下发指令:叫号48>>>
2026-04-26 21:07:38 收到下发指令:排队号48>>>
2026-04-26 21:07:38 收到下发指令:叫号48>>>
2026-04-26 21:07:41 收到下发指令:排队号48>>>
2026-04-26 21:07:41 收到下发指令:叫号48>>>
2026-04-26 21:07:45 收到下发指令:排队号48>>>
2026-04-26 21:07:45 收到下发指令:叫号48>>>
2026-04-26 21:07:49 收到下发指令:排队号48>>>
2026-04-26 21:07:49 收到下发指令:叫号48>>>
2026-04-26 21:07:53 收到下发指令:排队号48>>>
2026-04-26 21:07:53 收到下发指令:叫号48>>>
2026-04-26 21:07:58 收到下发指令:排队号48>>>
2026-04-26 21:07:58 收到下发指令:叫号48>>>


===21:11:31===
2026-04-26 21:10:30 收到下发指令:排队号48>>>
2026-04-26 21:10:30 收到下发指令:叫号48>>>
2026-04-26 21:10:33 收到下发指令:排队号48>>>
2026-04-26 21:10:33 收到下发指令:叫号48>>>
2026-04-26 21:10:36 收到下发指令:排队号48>>>
2026-04-26 21:10:36 收到下发指令:叫号48>>>
2026-04-26 21:10:40 收到下发指令:排队号48>>>
2026-04-26 21:10:40 收到下发指令:叫号48>>>
2026-04-26 21:10:44 收到下发指令:排队号48>>>
2026-04-26 21:10:44 收到下发指令:叫号48>>>
2026-04-26 21:10:47 收到下发指令:排队号48>>>
2026-04-26 21:10:47 收到下发指令:叫号48>>>
2026-04-26 21:10:51 收到下发指令:排队号48>>>
2026-04-26 21:10:51 收到下发指令:叫号48>>>
2026-04-26 21:10:55 收到下发指令:排队号48>>>
2026-04-26 21:10:55 收到下发指令:叫号48>>>
2026-04-26 21:10:59 收到下发指令:排队号48>>>
2026-04-26 21:10:59 收到下发指令:叫号48>>>
2026-04-26 21:11:02 收到下发指令:排队号48>>>
2026-04-26 21:11:02 收到下发指令:叫号48>>>
2026-04-26 21:11:06 收到下发指令:排队号48>>>
2026-04-26 21:11:06 收到下发指令:叫号48>>>


===21:12:31===
2026-04-26 21:11:41 收到下发指令:排队号48>>>
2026-04-26 21:11:41 收到下发指令:叫号48>>>