TLClient_JSSCOM_LuatOS-Air_V4010_RDA8910_RFTTS_0xe0000,2.8.6,869701072496006,95616585442647,
poweron reason:0

===09:14:06===
上一时间戳为1777078373
隔日重置时间戳true
隔日清空未同步下发列表true
当前排队号为666,音量为5
初始化产品信息:[{"time_limit_date":"","ticket_category":"0","expiry_date":7,"product_detail":"","time_limit_status":"0","begin_minute":"00","product_uid":"4280874159397708338","use_timer":1,"old_price":"20","end_hour":"23","sale_price":"10","end_minute":"59","begin_hour":"00","sale_status":1,"product_name":"快 剪（新）"},{"time_limit_date":"","ticket_category":"0","expiry_date":7,"product_detail":"","time_limit_status":"0","begin_minute":"00","product_uid":"4280874159397810085","use_timer":1,"old_price":"30","end_hour":"23","sale_price":"17","end_minute":"59","begin_hour":"00","sale_status":1,"product_name":"快剪+冲洗（限男士）新"}]
打印门店标题设置为韩尚快剪新城市广场店
是否打印二维码设置为0
是否打印紧凑设置为3
当前号显示模式设置为1
当前卡项核销权限设置为0
session_id:be565****6e2c0
纸币器设置接收纸币范围为36
欢迎使用天羚自助售票系统[2.8.6]
定时检测未同步订单启用[checkOrderNum=536870969]
2026-04-26 09:13:05>>>cash write=30
2026-04-26 09:13:05>>>cash write=02
2026-04-26 09:13:05>>>cash write=3E
2026-04-26 09:13:05>>>cash read=808F808F
系统时间初始化成功，时间为20264269135
2026-04-26 09:13:06>>>cash write=02
2026-04-26 09:13:06 >>>剩余flash空间=1680000,占用RAM为657.37109375
2026-04-26 09:13:06 >>>回调事件:910,subscribe,10000,连接服务器成功

请求下发消息结果为0,Message sent successfully
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 09:13:07 >>>回调事件[910,devices/YC0639]
当日首次设置时间戳true为1777165987
2026-04-26 09:13:07 >>>故障排除日志:上一MQTT订单号缓存列表为2604252138570028391019
2026-04-26 09:13:07 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 09:13:07 开始打印,排队:666,票券:2604260912330731407901,订单:2604260912330004253512,[2026-04-26 09:12:41微信支付10元]
2026-04-26 09:13:08>>>MQTT票号同步场景，创建空订单对象
2026-04-26 09:13:08>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 09:13:10 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604260912330731407901","queue_number":666,"trade_uid":"2604260912330004253512"}]}
2026-04-26 09:13:10 >>>故障排除日志:删除未同步下发订单成功2604260912330004253512
2026-04-26 09:13:10 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536870985]
流量卡还有126天过期
2026-04-26 09:13:11>>>cash write=0C
2026-04-26 09:13:11>>>cash read=3E
2026-04-26 09:13:16 >>>当前Ram内存为651.921875


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


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


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


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


===09:52:08===
2026-04-26 09:51:54>>>cash read=0A
2026-04-26 09:51:55>>>cash read=3E


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


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


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


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


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


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


===10:30:10===
2026-04-26 10:29:38>>>cash read=0A
2026-04-26 10:29:39>>>cash read=3E


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


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


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


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


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


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


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


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


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


===11:04:14===
2026-04-26 11:04:02>>>cash read=00
2026-04-26 11:04:03>>>cash read=818F43
2026-04-26 11:04:03>>>cash write=02
2026-04-26 11:04:03 >>>回调事件130,cash_status,10022,进钞中...read money=20
2026-04-26 11:04:03>>>cash read=10
2026-04-26 11:04:03 >>>回调事件130,20,10023,finish Money=20,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 11:04:04 当前产品价格10元，投币20元，打印小票中...
2026-04-26 11:04:04 >>>开始打印,排队号为688,订单号为2604261104040050639625
2026-04-26 11:04:04 >>>开始打印,排队号为689,订单号为2604261104040050639625
2026-04-26 11:04:04>>>订单2604261104040050639625写入成功,剩余空间为1679000,占用RAM为642.091796875
2026-04-26 11:04:07>>>cash read=818F42
2026-04-26 11:04:07 >>>回调事件130,cash_status,10022,进钞中...read money=10
删除未同步订单2604261104040050639625
2026-04-26 11:04:08>>>订单2604261104040050639625删除成功,剩余空间为1680500,占用RAM为644.9248046875
检测订单目录中>>>
无未同步订单>>>
2026-04-26 11:04:08 >>>当前Ram内存为618.5048828125
定时检测未同步订单启用[checkOrderNum=536872147]
2026-04-26 11:04:08>>>cash read=10
2026-04-26 11:04:08 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 11:04:08 当前产品价格10元，投币10元，打印小票中...
2026-04-26 11:04:08 >>>开始打印,排队号为690,订单号为2604261104080050639436
2026-04-26 11:04:09>>>订单2604261104080050639436写入成功,剩余空间为1678500,占用RAM为641.3515625
删除未同步订单2604261104080050639436
2026-04-26 11:04:11>>>订单2604261104080050639436删除成功,剩余空间为1679500,占用RAM为649.517578125
检测订单目录中>>>
无未同步订单>>>
2026-04-26 11:04:11 >>>当前Ram内存为619.353515625
定时检测未同步订单启用[checkOrderNum=536872154]
2026-04-26 11:04:12>>>cash write=0C
2026-04-26 11:04:12>>>cash read=3E


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


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


===11:12:15===
2026-04-26 11:11:57>>>cash read=00
2026-04-26 11:11:58>>>cash read=29
2026-04-26 11:11:58 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 11:11:59>>>cash read=2F29
2026-04-26 11:12:00>>>cash read=3E
2026-04-26 11:12:02>>>cash read=00
2026-04-26 11:12:03>>>cash read=2F29
2026-04-26 11:12:05>>>cash read=3E


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


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


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


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


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


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


===12:10:19===
2026-04-26 12:09:17 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261209068981103801","queue_number":698,"trade_uid":"2604261209060087858067"}]}
2026-04-26 12:09:17 >>>故障排除日志:删除未同步下发订单成功2604261209060087858067
2026-04-26 12:09:17 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536872801]


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


===14:10:27===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 14:09:31 >>>回调事件[910,devices/YC0639]
2026-04-26 14:09:31 >>>故障排除日志:上一MQTT订单号缓存列表为2604261406340020570835
2026-04-26 14:09:31 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 14:09:31 开始打印,排队:719,票券:2604261409233035316901,订单:2604261409230028029414,[2026-04-26 14:09:30支付宝支付10元]
2026-04-26 14:09:31>>>MQTT票号同步场景，创建空订单对象
2026-04-26 14:09:31>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 14:09:33 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261409233035316901","queue_number":719,"trade_uid":"2604261409230028029414"}]}
2026-04-26 14:09:33 >>>故障排除日志:删除未同步下发订单成功2604261409230028029414
2026-04-26 14:09:33 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536874040]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 14:09:47 >>>回调事件[910,devices/YC0639]
2026-04-26 14:09:47 >>>故障排除日志:上一MQTT订单号缓存列表为2604261409230028029414
2026-04-26 14:09:47 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 14:09:47 开始打印,排队:720,票券:2604261409416401088401,订单:2604261409410061418398,[2026-04-26 14:09:45支付宝支付10元]
2026-04-26 14:09:47>>>MQTT票号同步场景，创建空订单对象
2026-04-26 14:09:47>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 14:09:49 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261409416401088401","queue_number":720,"trade_uid":"2604261409410061418398"}]}
2026-04-26 14:09:49 >>>故障排除日志:删除未同步下发订单成功2604261409410061418398
2026-04-26 14:09:49 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536874046]


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


===17:35:43===
2026-04-26 17:35:11>>>cash read=00
2026-04-26 17:35:13>>>cash read=29
2026-04-26 17:35:13 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 17:35:13>>>cash read=2F29
2026-04-26 17:35:14>>>cash read=01
2026-04-26 17:35:14>>>cash read=2F
2026-04-26 17:35:15>>>cash read=3E
2026-04-26 17:35:21>>>cash read=00
2026-04-26 17:35:22>>>cash read=818F42
2026-04-26 17:35:22>>>cash write=02
2026-04-26 17:35:22 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 17:35:22>>>cash read=10
2026-04-26 17:35:22 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 17:35:22 当前产品价格10元，投币10元，打印小票中...
2026-04-26 17:35:22 >>>开始打印,排队号为761,订单号为2604261735220050639937
2026-04-26 17:35:23>>>订单2604261735220050639937写入成功,剩余空间为1679500,占用RAM为636.6005859375
删除未同步订单2604261735220050639937
2026-04-26 17:35:25>>>订单2604261735220050639937删除成功,剩余空间为1680000,占用RAM为645.1494140625
检测订单目录中>>>
无未同步订单>>>
2026-04-26 17:35:25 >>>当前Ram内存为617.1005859375
定时检测未同步订单启用[checkOrderNum=536876199]
2026-04-26 17:35:26>>>cash write=0C
2026-04-26 17:35:26>>>cash read=3E


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


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


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


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


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


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


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


===18:02:47===
2026-04-26 18:02:26>>>cash read=00
2026-04-26 18:02:26>>>cash read=818F43
2026-04-26 18:02:26>>>cash write=02
2026-04-26 18:02:26 >>>回调事件130,cash_status,10022,进钞中...read money=20
2026-04-26 18:02:27>>>cash read=10
2026-04-26 18:02:27 >>>回调事件130,20,10023,finish Money=20,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 18:02:27 当前产品价格10元，投币20元，打印小票中...
2026-04-26 18:02:27 >>>开始打印,排队号为769,订单号为2604261802270050639810
2026-04-26 18:02:27 >>>开始打印,排队号为770,订单号为2604261802270050639810
2026-04-26 18:02:27>>>订单2604261802270050639810写入成功,剩余空间为1679000,占用RAM为641.4921875
删除未同步订单2604261802270050639810
2026-04-26 18:02:31>>>订单2604261802270050639810删除成功,剩余空间为1680500,占用RAM为657.232421875
检测订单目录中>>>
无未同步订单>>>
2026-04-26 18:02:31 >>>当前Ram内存为617.9736328125
定时检测未同步订单启用[checkOrderNum=536876506]
2026-04-26 18:02:32>>>cash write=0C
2026-04-26 18:02:32>>>cash read=3E


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


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


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


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


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


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


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


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


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


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


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


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


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


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


===19:04:53===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:04:18 >>>回调事件[910,devices/YC0639]
2026-04-26 19:04:18 >>>故障排除日志:上一MQTT订单号缓存列表为2604261901000062334267
2026-04-26 19:04:18 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 19:04:18 开始打印,排队:789,票券:2604261904094920931901,订单:2604261904090047280351,[2026-04-26 19:04:17微信支付10元]
2026-04-26 19:04:18>>>MQTT票号同步场景，创建空订单对象
2026-04-26 19:04:19>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 19:04:21 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261904094920931901","queue_number":789,"trade_uid":"2604261904090047280351"}]}
2026-04-26 19:04:21 >>>故障排除日志:删除未同步下发订单成功2604261904090047280351
2026-04-26 19:04:21 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877195]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:04:26 >>>回调事件[910,devices/YC0639]
2026-04-26 19:04:27 >>>故障排除日志:上一MQTT订单号缓存列表为2604261904090047280351
2026-04-26 19:04:27 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 19:04:27 开始打印,排队:790,票券:2604261904193700911301,订单:2604261904190034810513,[2026-04-26 19:04:26微信支付10元]
2026-04-26 19:04:27>>>MQTT票号同步场景，创建空订单对象
2026-04-26 19:04:27>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 19:04:29 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261904193700911301","queue_number":790,"trade_uid":"2604261904190034810513"}]}
2026-04-26 19:04:29 >>>故障排除日志:删除未同步下发订单成功2604261904190034810513
2026-04-26 19:04:29 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877201]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:04:41 >>>回调事件[910,devices/YC0639]
2026-04-26 19:04:41 >>>故障排除日志:上一MQTT订单号缓存列表为2604261904190034810513
2026-04-26 19:04:41 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 19:04:41 开始打印,排队:791,票券:2604261904339238468101,订单:2604261904330090362797,[2026-04-26 19:04:40微信支付10元]
2026-04-26 19:04:41>>>MQTT票号同步场景，创建空订单对象
2026-04-26 19:04:41>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 19:04:43 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261904339238468101","queue_number":791,"trade_uid":"2604261904330090362797"}]}
2026-04-26 19:04:43 >>>故障排除日志:删除未同步下发订单成功2604261904330090362797
2026-04-26 19:04:43 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877208]


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


===19:19:54===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:19:14 >>>回调事件[910,devices/YC0639]
2026-04-26 19:19:14 >>>故障排除日志:上一MQTT订单号缓存列表为2604261914460024198728
2026-04-26 19:19:14 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 19:19:14 开始打印,排队:793,票券:2604261919062770634801,订单:2604261919060025851146,[2026-04-26 19:19:13微信支付10元]
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":"2604261919062770634801","queue_number":793,"trade_uid":"2604261919060025851146"}]}
2026-04-26 19:19:17 >>>故障排除日志:删除未同步下发订单成功2604261919060025851146
2026-04-26 19:19:17 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877358]


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


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


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


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


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


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


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


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


===19:48:57===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:48:02 >>>回调事件[910,devices/YC0639]
2026-04-26 19:48:02 >>>故障排除日志:上一MQTT订单号缓存列表为2604261944240022489534
2026-04-26 19:48:02 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 19:48:02 开始打印,排队:804,票券:2604261947559035379301,订单:2604261947550088404998,[2026-04-26 19:48:01微信支付10元]
2026-04-26 19:48:02>>>MQTT票号同步场景，创建空订单对象
2026-04-26 19:48:02>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 19:48:04 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261947559035379301","queue_number":804,"trade_uid":"2604261947550088404998"}]}
2026-04-26 19:48:04 >>>故障排除日志:删除未同步下发订单成功2604261947550088404998
2026-04-26 19:48:04 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877691]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:48:30 >>>回调事件[910,devices/YC0639]
2026-04-26 19:48:30 >>>故障排除日志:上一MQTT订单号缓存列表为2604261947550088404998
2026-04-26 19:48:30 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 19:48:30 开始打印,排队:805,票券:2604261948207771703201,订单:2604261948200075614662,[2026-04-26 19:48:30微信支付10元]
2026-04-26 19:48:30>>>MQTT票号同步场景，创建空订单对象
2026-04-26 19:48:30>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 19:48:32 >>>回调事件[910,devices/YC0639]
2026-04-26 19:48:32 >>>故障排除日志:上一MQTT订单号缓存列表为2604261948200075614662
2026-04-26 19:48:32 >>>故障排除日志:终端未同步成功订单列表08052604261948200075614662
已接收过此消息,票券号为2604261948207771703201,排队号为805
2026-04-26 19:48:32 开始打印,排队:806,票券:2604261948235798241601,订单:2604261948230056064557,[2026-04-26 19:48:30微信支付10元]
2026-04-26 19:48:32>>>HTTP请求进行中，跳过本次同步
2026-04-26 19:48:34 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261948207771703201","queue_number":805,"trade_uid":"2604261948200075614662"}]}
2026-04-26 19:48:34 >>>故障排除日志:删除未同步下发订单成功2604261948200075614662
2026-04-26 19:48:34 >>>故障排除日志:终端同步成功后剩余订单列表08062604261948230056064557
定时检测未同步订单启用[checkOrderNum=536877705]


===19:49:59===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:49:43 >>>回调事件[910,devices/YC0639]
2026-04-26 19:49:44 >>>故障排除日志:上一MQTT订单号缓存列表为2604261948200075614662|2604261948230056064557
2026-04-26 19:49:44 >>>故障排除日志:终端未同步成功订单列表08062604261948230056064557
已接收过此消息,票券号为2604261948235798241601,排队号为806
2026-04-26 19:49:44 开始打印,排队:807,票券:2604261949359073076301,订单:2604261949350088886152,[2026-04-26 19:49:42微信支付10元]
2026-04-26 19:49:44>>>MQTT票号同步场景，创建空订单对象
2026-04-26 19:49:44>>>合并MQTT票号列表到订单同步请求,共2张票
2026-04-26 19:49:46 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261948235798241601","queue_number":806,"trade_uid":"2604261948230056064557"},{"ticket_no":"2604261949359073076301","queue_number":807,"trade_uid":"2604261949350088886152"}]}
2026-04-26 19:49:46 >>>故障排除日志:删除未同步下发订单成功2604261948230056064557
2026-04-26 19:49:46 >>>故障排除日志:删除未同步下发订单成功2604261949350088886152
2026-04-26 19:49:46 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877722]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:49:56 >>>回调事件[910,devices/YC0639]
2026-04-26 19:49:56 >>>故障排除日志:上一MQTT订单号缓存列表为2604261948230056064557|2604261949350088886152
2026-04-26 19:49:56 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 19:49:56 开始打印,排队:808,票券:2604261949445796365401,订单:2604261949440055643746,[2026-04-26 19:49:56微信支付10元]
2026-04-26 19:49:56>>>MQTT票号同步场景，创建空订单对象
2026-04-26 19:49:56>>>合并MQTT票号列表到订单同步请求,共1张票


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


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


===19:59:01===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:58:04 >>>回调事件[910,devices/YC0639]
2026-04-26 19:58:04 >>>故障排除日志:上一MQTT订单号缓存列表为2604261952560056613824
2026-04-26 19:58:04 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 19:58:04 开始打印,排队:811,票券:2604261957568808682801,订单:2604261957560085511712,[2026-04-26 19:58:03微信支付10元]
2026-04-26 19:58:04>>>MQTT票号同步场景，创建空订单对象
2026-04-26 19:58:04>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 19:58:06 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261957568808682801","queue_number":811,"trade_uid":"2604261957560085511712"}]}
2026-04-26 19:58:06 >>>故障排除日志:删除未同步下发订单成功2604261957560085511712
2026-04-26 19:58:06 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877827]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:58:26 >>>回调事件[910,devices/YC0639]
2026-04-26 19:58:26 >>>故障排除日志:上一MQTT订单号缓存列表为2604261957560085511712
2026-04-26 19:58:26 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 19:58:26 开始打印,排队:812,票券:2604261958151666169601,订单:2604261958150014230576,[2026-04-26 19:58:25微信支付10元]
2026-04-26 19:58:26 开始打印,排队:813,票券:2604261958151666735802,订单:2604261958150014230576,[2026-04-26 19:58:25微信支付10元]
2026-04-26 19:58:26 开始打印,排队:814,票券:2604261958151666941203,订单:2604261958150014230576,[2026-04-26 19:58:25微信支付10元]
2026-04-26 19:58:26>>>MQTT票号同步场景，创建空订单对象
2026-04-26 19:58:26>>>合并MQTT票号列表到订单同步请求,共3张票
2026-04-26 19:58:31 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261958151666169601","queue_number":812,"trade_uid":"2604261958150014230576"},{"ticket_no":"2604261958151666735802","queue_number":813,"trade_uid":"2604261958150014230576"},{"ticket_no":"2604261958151666941203","queue_number":814,"trade_uid":"2604261958150014230576"}]}
2026-04-26 19:58:31 >>>故障排除日志:删除未同步下发订单成功2604261958150014230576
2026-04-26 19:58:31 >>>故障排除日志:删除未同步下发订单成功2604261958150014230576
2026-04-26 19:58:31 >>>故障排除日志:删除未同步下发订单成功2604261958150014230576
2026-04-26 19:58:32 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877838]


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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