TLClient_JSSCOM_LuatOS-Air_V4010_RDA8910_RFTTS_0xe0000,2.8.6,863013071887045,21114206654850,
poweron reason:0

===10:07:50===
上一时间戳为1777083154
隔日重置时间戳true
隔日清空未同步下发列表true
当前排队号为1,音量为5
初始化产品信息:[{"time_limit_date":"","ticket_category":"0","expiry_date":1,"product_detail":"","time_limit_status":"0","begin_minute":"00","product_uid":"4280823941834157370","use_timer":1,"old_price":"15","end_hour":"23","sale_price":"15","end_minute":"59","begin_hour":"00","sale_status":1,"product_name":"剪发"}]
是否打印二维码设置为1
是否打印紧凑设置为7
当前号显示模式设置为1
当前卡项核销权限设置为0
session_id:8e635****f9642
纸币器设置接收纸币范围为36
欢迎使用天羚自助售票系统[2.8.6]
定时检测未同步订单启用[checkOrderNum=536870969]
2026-04-26 10:06:48>>>cash write=30
2026-04-26 10:06:48>>>cash write=02
2026-04-26 10:06:48>>>cash write=3E
2026-04-26 10:06:48>>>cash read=808F808F
系统时间初始化成功，时间为202642610648
2026-04-26 10:06:49>>>cash write=02
2026-04-26 10:06:49 >>>剩余flash空间=1680000,占用RAM为656.943359375
2026-04-26 10:06:49 >>>回调事件:910,subscribe,10000,连接服务器成功

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

2026-04-26 10:06:52>>>cash write=0C
2026-04-26 10:06:52>>>cash read=3E
流量卡还有95天过期
2026-04-26 10:06:59 >>>当前Ram内存为659.2265625
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 10:07:01 >>>回调事件[910,devices/TL4586]
当日首次设置时间戳true为1777169221
2026-04-26 10:07:01 >>>故障排除日志:上一MQTT订单号缓存列表为2604252127230037472647|2604252127230037472647
2026-04-26 10:07:01 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 10:07:01 开始打印,排队:1,票券:2604261006523149878501,订单:2604261006520028240279,[2026-04-26 10:07:00微信支付15元]
2026-04-26 10:07:01>>>MQTT票号同步场景，创建空订单对象
2026-04-26 10:07:01>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 10:07:03 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261006523149878501","queue_number":1,"trade_uid":"2604261006520028240279"}]}
2026-04-26 10:07:03 >>>故障排除日志:删除未同步下发订单成功2604261006520028240279
2026-04-26 10:07:03 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536870987]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 10:07:47 >>>回调事件[910,devices/TL4586]
2026-04-26 10:07:47 >>>故障排除日志:上一MQTT订单号缓存列表为2604261006520028240279
2026-04-26 10:07:47 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 10:07:47 开始打印,排队:2,票券:2604261007374651145401,订单:2604261007370044475535,[2026-04-26 10:07:45微信支付15元]
2026-04-26 10:07:47>>>MQTT票号同步场景，创建空订单对象
2026-04-26 10:07:47>>>合并MQTT票号列表到订单同步请求,共1张票


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


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


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


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


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


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


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


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


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


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


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


===10:31:00===
2026-04-26 10:29:54 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261029417578435201","queue_number":14,"trade_uid":"2604261029410073907625"}]}
2026-04-26 10:29:54 >>>故障排除日志:删除未同步下发订单成功2604261029410073907625
2026-04-26 10:29:54 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536871451]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 10:30:54 >>>回调事件[910,devices/TL4586]
2026-04-26 10:30:54 >>>故障排除日志:上一MQTT订单号缓存列表为2604261029410073907625
2026-04-26 10:30:54 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 10:30:54 开始打印,排队:15,票券:2604261030460930561401,订单:2604261030460007549193,[2026-04-26 10:30:52微信支付15元]
2026-04-26 10:30:54>>>MQTT票号同步场景，创建空订单对象
2026-04-26 10:30:54>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 10:30:59>>>订单同步异常:30000,nil
2026-04-26 10:30:59>>>添加1个票号到未同步列表
2026-04-26 10:30:59>>>异常订单信息为{"dev_id":"TL4586","ticket_no_list":[{"ticket_no":"2604261030460930561401","queue_number":15,"trade_uid":"2604261030460007549193"}],"enterprise_uid":"12566542176647414917","version_uid":"23","store_uid":"822059426285555975","sign":"A2EE9CA97F4B86DE113D6934B8758993","time_stamp":"1777170654811","random":"47934915","dev_sn":"863013071887045"}
2026-04-26 10:30:59 >>>剩余flash空间=1678000,占用RAM为669.369140625
2026-04-26 10:30:59 >>>回调异常:911,printUpload,30000,nil

订单排队号更新异常30000
2026-04-26 10:30:59>>>开始同步未成功的票号列表,共1张票
定时检测未同步订单启用[checkOrderNum=536871475]


TCP://api5.tl-self.com:80@26_10:30:59:connect fail
===10:32:01===
2026-04-26 10:31:00>>>从未同步列表移除1个票号
定时检测已在运行，无需重复启动[checkOrderNum=536871475]
定时检测已在运行，无需重复启动[checkOrderNum=536871475]
2026-04-26 10:31:00 >>>初始化异常:sessionID变更664a9****9d33c


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


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


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


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


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


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


===12:35:04===
2026-04-26 12:34:29>>>cash read=0A
2026-04-26 12:34:31>>>cash read=3E


===12:44:04===
2026-04-26 12:43:08>>>cash read=00
2026-04-26 12:43:09>>>cash read=818F42
2026-04-26 12:43:09>>>cash write=02
2026-04-26 12:43:09 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 12:43:09>>>cash read=10
2026-04-26 12:43:09 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 12:43:10>>>cash write=0C
2026-04-26 12:43:10>>>cash read=3E
2026-04-26 12:43:12>>>cash read=29
2026-04-26 12:43:12 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 12:43:13>>>cash read=01
2026-04-26 12:43:14>>>cash read=3E
2026-04-26 12:43:15>>>cash read=00
2026-04-26 12:43:15>>>cash read=818F41
2026-04-26 12:43:15>>>cash write=02
2026-04-26 12:43:15 >>>回调事件130,cash_status,10022,进钞中...read money=5
2026-04-26 12:43:16>>>cash read=10
2026-04-26 12:43:16 >>>回调事件130,5,10023,finish Money=5,进钞完成
2026-04-26 12:43:16 当前产品价格15元，投币15元，打印小票中...
2026-04-26 12:43:16 >>>开始打印,排队号为22,订单号为2604261243090014586547
2026-04-26 12:43:16>>>订单2604261243090014586547写入成功,剩余空间为1679000,占用RAM为635.9150390625
删除未同步订单2604261243090014586547
2026-04-26 12:43:18>>>订单2604261243090014586547删除成功,剩余空间为1680000,占用RAM为635.076171875
检测订单目录中>>>
无未同步订单>>>
2026-04-26 12:43:19 >>>当前Ram内存为617.59375
定时检测未同步订单启用[checkOrderNum=536873456]
2026-04-26 12:43:19>>>cash write=0C
2026-04-26 12:43:20>>>cash read=3E


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


===13:01:05===
2026-04-26 13:00:10>>>cash read=00
2026-04-26 13:00:11>>>cash read=00818F42
2026-04-26 13:00:11>>>cash write=02
2026-04-26 13:00:11 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 13:00:11>>>cash read=10
2026-04-26 13:00:11 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 13:00:12>>>cash write=0C
2026-04-26 13:00:12>>>cash read=3E
2026-04-26 13:00:15>>>cash read=00
2026-04-26 13:00:15>>>cash read=818F41
2026-04-26 13:00:15>>>cash write=02
2026-04-26 13:00:15 >>>回调事件130,cash_status,10022,进钞中...read money=5
2026-04-26 13:00:16>>>cash read=10
2026-04-26 13:00:16 >>>回调事件130,5,10023,finish Money=5,进钞完成
2026-04-26 13:00:16 当前产品价格15元，投币15元，打印小票中...
2026-04-26 13:00:16 >>>开始打印,排队号为24,订单号为2604261300110014586889
2026-04-26 13:00:16>>>订单2604261300110014586889写入成功,剩余空间为1679500,占用RAM为632.916015625
删除未同步订单2604261300110014586889
2026-04-26 13:00:18>>>订单2604261300110014586889删除成功,剩余空间为1680000,占用RAM为648.9365234375
检测订单目录中>>>
无未同步订单>>>
2026-04-26 13:00:18 >>>当前Ram内存为617.8779296875
定时检测未同步订单启用[checkOrderNum=536873650]
2026-04-26 13:00:19>>>cash write=0C
2026-04-26 13:00:19>>>cash read=3E


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


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


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


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


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


===13:46:07===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 13:45:09 >>>回调事件[910,devices/TL4586]
2026-04-26 13:45:09 >>>故障排除日志:上一MQTT订单号缓存列表为2604261342070027352049
2026-04-26 13:45:09 >>>故障排除日志:终端未同步成功订单列表00152604261030460007549193
2026-04-26 13:45:09 开始打印,排队:31,票券:2604261344565200215601,订单:2604261344560050006791,[2026-04-26 13:45:08微信支付15元]
2026-04-26 13:45:09>>>MQTT票号同步场景，创建空订单对象
2026-04-26 13:45:09>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 13:45:11 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261344565200215601","queue_number":31,"trade_uid":"2604261344560050006791"}]}
2026-04-26 13:45:11 >>>故障排除日志:删除未同步下发订单成功2604261344560050006791
2026-04-26 13:45:11 >>>故障排除日志:终端同步成功后剩余订单列表00152604261030460007549193
定时检测未同步订单启用[checkOrderNum=536874276]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 13:45:28 >>>回调事件[910,devices/TL4586]
2026-04-26 13:45:28 >>>故障排除日志:上一MQTT订单号缓存列表为2604261344560050006791
2026-04-26 13:45:28 >>>故障排除日志:终端未同步成功订单列表00152604261030460007549193
2026-04-26 13:45:28 开始打印,排队:32,票券:2604261345210216325201,订单:2604261345210000337315,[2026-04-26 13:45:27微信支付15元]
2026-04-26 13:45:28>>>MQTT票号同步场景，创建空订单对象
2026-04-26 13:45:28>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 13:45:30 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261345210216325201","queue_number":32,"trade_uid":"2604261345210000337315"}]}
2026-04-26 13:45:30 >>>故障排除日志:删除未同步下发订单成功2604261345210000337315
2026-04-26 13:45:30 >>>故障排除日志:终端同步成功后剩余订单列表00152604261030460007549193
定时检测未同步订单启用[checkOrderNum=536874283]


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


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


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


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


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


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


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


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


===14:35:09===
2026-04-26 14:34:10>>>cash read=0A
2026-04-26 14:34:11>>>cash read=3E


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


===14:55:10===
2026-04-26 14:54:21>>>cash read=29
2026-04-26 14:54:21 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 14:54:21>>>cash read=2F29
2026-04-26 14:54:22>>>cash read=01
2026-04-26 14:54:24>>>cash read=2F
2026-04-26 14:54:25>>>cash read=00
2026-04-26 14:54:26>>>cash read=818F41
2026-04-26 14:54:26>>>cash write=02
2026-04-26 14:54:26 >>>回调事件130,cash_status,10022,进钞中...read money=5
2026-04-26 14:54:27>>>cash write=0C
2026-04-26 14:54:27>>>cash read=00
2026-04-26 14:54:27>>>cash read=10
2026-04-26 14:54:27 >>>回调事件130,5,10023,finish Money=5,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 14:54:28>>>cash read=01
2026-04-26 14:54:33>>>cash read=00
2026-04-26 14:54:33>>>cash read=818F42
2026-04-26 14:54:33>>>cash write=02
2026-04-26 14:54:33 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 14:54:34>>>cash read=10
2026-04-26 14:54:34 >>>回调事件130,10,10023,finish Money=10,进钞完成
2026-04-26 14:54:34 当前产品价格15元，投币15元，打印小票中...
2026-04-26 14:54:34 >>>开始打印,排队号为43,订单号为2604261454270014586245
2026-04-26 14:54:34>>>订单2604261454270014586245写入成功,剩余空间为1679000,占用RAM为636.3271484375
删除未同步订单2604261454270014586245
2026-04-26 14:54:36>>>订单2604261454270014586245删除成功,剩余空间为1680000,占用RAM为649.748046875
检测订单目录中>>>
无未同步订单>>>
2026-04-26 14:54:36 >>>当前Ram内存为618.244140625
定时检测未同步订单启用[checkOrderNum=536875226]
2026-04-26 14:54:37>>>cash write=0C
2026-04-26 14:54:37>>>cash read=3E


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


===17:09:18===
2026-04-26 17:08:53 >>>剩余flash空间=1682000,占用RAM为647.5078125
2026-04-26 17:08:53 >>>回调事件:901,netChange,1,4G LTE网络



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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


===19:19:24===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:19:00 >>>回调事件[910,devices/TL4586]
2026-04-26 19:19:00 >>>故障排除日志:上一MQTT订单号缓存列表为2604261855500062283361
2026-04-26 19:19:00 >>>故障排除日志:终端未同步成功订单列表00152604261030460007549193
2026-04-26 19:19:00 开始打印,排队:92,票券:2604261918501080025901,订单:2604261918500008197746,[2026-04-26 19:18:57微信支付15元]
2026-04-26 19:19:00 开始打印,排队:93,票券:2604261918501080527202,订单:2604261918500008197746,[2026-04-26 19:18:57微信支付15元]
2026-04-26 19:19:00>>>MQTT票号同步场景，创建空订单对象
2026-04-26 19:19:00>>>合并MQTT票号列表到订单同步请求,共2张票
2026-04-26 19:19:04 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261918501080025901","queue_number":92,"trade_uid":"2604261918500008197746"},{"ticket_no":"2604261918501080527202","queue_number":93,"trade_uid":"2604261918500008197746"}]}
2026-04-26 19:19:04 >>>故障排除日志:删除未同步下发订单成功2604261918500008197746
2026-04-26 19:19:04 >>>故障排除日志:删除未同步下发订单成功2604261918500008197746
2026-04-26 19:19:04 >>>故障排除日志:终端同步成功后剩余订单列表00152604261030460007549193
定时检测未同步订单启用[checkOrderNum=536879858]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:19:15 >>>回调事件[910,devices/TL4586]
2026-04-26 19:19:15 >>>故障排除日志:上一MQTT订单号缓存列表为2604261918500008197746|2604261918500008197746
2026-04-26 19:19:15 >>>故障排除日志:终端未同步成功订单列表00152604261030460007549193
2026-04-26 19:19:15 开始打印,排队:94,票券:2604261919091873001501,订单:2604261919090016613873,[2026-04-26 19:19:14微信支付15元]
2026-04-26 19:19:15>>>MQTT票号同步场景，创建空订单对象
2026-04-26 19:19:15>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 19:19:17 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261919091873001501","queue_number":94,"trade_uid":"2604261919090016613873"}]}
2026-04-26 19:19:17 >>>故障排除日志:删除未同步下发订单成功2604261919090016613873
2026-04-26 19:19:18 >>>故障排除日志:终端同步成功后剩余订单列表00152604261030460007549193
定时检测未同步订单启用[checkOrderNum=536879865]


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


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


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


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


===19:46:26===
2026-04-26 19:45:25 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261945040905917901","queue_number":98,"trade_uid":"2604261945040006352912"},{"ticket_no":"2604261945040906544902","queue_number":99,"trade_uid":"2604261945040006352912"}]}
2026-04-26 19:45:25 >>>故障排除日志:删除未同步下发订单成功2604261945040006352912
2026-04-26 19:45:25 >>>故障排除日志:删除未同步下发订单成功2604261945040006352912
2026-04-26 19:45:25 >>>故障排除日志:终端同步成功后剩余订单列表00152604261030460007549193
定时检测未同步订单启用[checkOrderNum=536880265]
2026-04-26 19:45:32>>>cash read=00
2026-04-26 19:45:33>>>cash read=29
2026-04-26 19:45:33 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 19:45:34>>>cash read=2F29
2026-04-26 19:45:35>>>cash read=3E
2026-04-26 19:45:40>>>cash read=00
2026-04-26 19:45:40>>>cash read=818F41
2026-04-26 19:45:40>>>cash write=02
2026-04-26 19:45:41 >>>回调事件130,cash_status,10022,进钞中...read money=5
2026-04-26 19:45:41>>>cash read=10
2026-04-26 19:45:41 >>>回调事件130,5,10023,finish Money=5,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:45:42>>>cash write=0C
2026-04-26 19:45:42>>>cash read=3E
2026-04-26 19:45:49>>>cash read=2F29
2026-04-26 19:45:50>>>cash read=01
2026-04-26 19:45:50>>>cash read=2F
2026-04-26 19:45:51>>>cash read=3E
2026-04-26 19:45:52>>>cash read=00
2026-04-26 19:45:53>>>cash read=818F42
2026-04-26 19:45:53>>>cash write=02
2026-04-26 19:45:53 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 19:45:53>>>cash read=10
2026-04-26 19:45:53 >>>回调事件130,10,10023,finish Money=10,进钞完成
2026-04-26 19:45:53 当前产品价格15元，投币15元，打印小票中...
2026-04-26 19:45:53 >>>开始打印,排队号为100,订单号为2604261945410014586274
2026-04-26 19:45:54>>>订单2604261945410014586274写入成功,剩余空间为1678500,占用RAM为642.6083984375
删除未同步订单2604261945410014586274
2026-04-26 19:45:56>>>订单2604261945410014586274删除成功,剩余空间为1678500,占用RAM为653.421875
检测订单目录中>>>
无未同步订单>>>
2026-04-26 19:45:56 >>>当前Ram内存为620.734375
定时检测未同步订单启用[checkOrderNum=536880282]
2026-04-26 19:45:57>>>cash write=0C
2026-04-26 19:45:57>>>cash read=3E


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


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


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


===19:57:26===
2026-04-26 19:56:39>>>cash read=00
2026-04-26 19:56:41>>>cash read=818F42
2026-04-26 19:56:41>>>cash write=02
2026-04-26 19:56:41 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 19:56:41>>>cash read=10
2026-04-26 19:56:41 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:56:42>>>cash write=0C
2026-04-26 19:56:42>>>cash read=3E
2026-04-26 19:56:48>>>cash read=29
2026-04-26 19:56:48 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 19:56:49>>>cash read=00
2026-04-26 19:56:50>>>cash read=818F41
2026-04-26 19:56:50>>>cash write=02
2026-04-26 19:56:50 >>>回调事件130,cash_status,10022,进钞中...read money=5
2026-04-26 19:56:51>>>cash read=10
2026-04-26 19:56:51 >>>回调事件130,5,10023,finish Money=5,进钞完成
2026-04-26 19:56:51 当前产品价格15元，投币15元，打印小票中...
2026-04-26 19:56:51 >>>开始打印,排队号为104,订单号为2604261956410014586975
2026-04-26 19:56:51>>>订单2604261956410014586975写入成功,剩余空间为1679000,占用RAM为634.0732421875
删除未同步订单2604261956410014586975
2026-04-26 19:56:53>>>订单2604261956410014586975删除成功,剩余空间为1680000,占用RAM为649.634765625
检测订单目录中>>>
无未同步订单>>>
2026-04-26 19:56:53 >>>当前Ram内存为618.5185546875
定时检测未同步订单启用[checkOrderNum=536880473]
2026-04-26 19:56:54>>>cash write=0C
2026-04-26 19:56:54>>>cash read=3E
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:57:13 >>>回调事件[910,devices/TL4586]
2026-04-26 19:57:13 >>>故障排除日志:上一MQTT订单号缓存列表为2604261952290012292692
2026-04-26 19:57:13 >>>故障排除日志:终端未同步成功订单列表00152604261030460007549193
2026-04-26 19:57:13 开始打印,排队:105,票券:2604261957041258857101,订单:2604261957040010353652,[2026-04-26 19:57:12微信支付15元]
2026-04-26 19:57:13>>>MQTT票号同步场景，创建空订单对象
2026-04-26 19:57:13>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 19:57:15 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261957041258857101","queue_number":105,"trade_uid":"2604261957040010353652"}]}
2026-04-26 19:57:15 >>>故障排除日志:删除未同步下发订单成功2604261957040010353652
2026-04-26 19:57:15 >>>故障排除日志:终端同步成功后剩余订单列表00152604261030460007549193
定时检测未同步订单启用[checkOrderNum=536880498]


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


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


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


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


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


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


===20:25:29===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 20:25:04 >>>回调事件[910,devices/TL4586]
2026-04-26 20:25:04 >>>故障排除日志:上一MQTT订单号缓存列表为2604262015320010611241
2026-04-26 20:25:04 >>>故障排除日志:终端未同步成功订单列表00152604261030460007549193
2026-04-26 20:25:04 开始打印,排队:112,票券:2604262024445296328601,订单:2604262024440050760832,[2026-04-26 20:25:03微信支付15元]
2026-04-26 20:25:04>>>MQTT票号同步场景，创建空订单对象
2026-04-26 20:25:04>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 20:25:06 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604262024445296328601","queue_number":112,"trade_uid":"2604262024440050760832"}]}
2026-04-26 20:25:06 >>>故障排除日志:删除未同步下发订单成功2604262024440050760832
2026-04-26 20:25:06 >>>故障排除日志:终端同步成功后剩余订单列表00152604261030460007549193
定时检测未同步订单启用[checkOrderNum=536880946]
2026-04-26 20:25:14>>>cash read=00
2026-04-26 20:25:14>>>cash read=818F43
2026-04-26 20:25:14>>>cash write=02
2026-04-26 20:25:14 >>>回调事件130,cash_status,10022,进钞中...read money=20
2026-04-26 20:25:14>>>cash read=10
2026-04-26 20:25:14 >>>回调事件130,20,10023,finish Money=20,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 20:25:16>>>cash write=0C
2026-04-26 20:25:16>>>cash read=3E


===20:26:29===
2026-04-26 20:26:11 >>>开始找零打印,排队号为113,订单号为2604262026110014586264
2026-04-26 20:26:11>>>订单2604262026110014586264写入成功,剩余空间为1680500,占用RAM为659.197265625
删除未同步订单2604262026110014586264
2026-04-26 20:26:13>>>订单2604262026110014586264删除成功,剩余空间为1681500,占用RAM为644.1318359375
检测订单目录中>>>
无未同步订单>>>
2026-04-26 20:26:13 >>>当前Ram内存为615.927734375
定时检测未同步订单启用[checkOrderNum=536880978]


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


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


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


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


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


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


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


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


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


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


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