TLClient_JSSCOM_LuatOS-Air_V4010_RDA8910_RFTTS_0xe0000,2.8.6,869701076438798,79971258076835,
poweron reason:0

===07:55:52===
上一时间戳为1777075486
隔日重置时间戳true
隔日清空未同步下发列表true
当前排队号为1,音量为5
初始化产品信息:[{"time_limit_date":"","ticket_category":"0","expiry_date":90,"product_detail":"","time_limit_status":"0","begin_minute":"00","product_uid":"12711098232277568446","use_timer":1,"old_price":"10","end_hour":"23","sale_price":"10","end_minute":"59","begin_hour":"00","sale_status":1,"product_name":"剪发一律10元"}]
打印门店标题设置为欢迎光临平剪（龙港大润发超市）
打印门店凭条广告设置为平剪（龙港大润发超市）
是否打印二维码设置为1
是否打印紧凑设置为3
当前号显示模式设置为1
当前卡项核销权限设置为0
session_id:887aa****1d7d9
纸币器设置接收纸币范围为36
欢迎使用天羚自助售票系统[2.8.6]
定时检测未同步订单启用[checkOrderNum=536870969]
2026-04-26 07:54:52>>>cash write=30
2026-04-26 07:54:52>>>cash write=02
2026-04-26 07:54:52>>>cash write=3E
2026-04-26 07:54:52>>>cash read=808F808F
系统时间初始化成功，时间为202642675452
2026-04-26 07:54:53>>>cash write=02
2026-04-26 07:54:53 >>>剩余flash空间=1680000,占用RAM为654.080078125
2026-04-26 07:54:53 >>>回调事件:910,subscribe,10000,连接服务器成功

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

2026-04-26 07:54:56>>>cash write=0C
2026-04-26 07:54:56>>>cash read=3E
流量卡还有126天过期
2026-04-26 07:55:04 >>>当前Ram内存为666.87109375


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


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


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


===08:25:53===
2026-04-26 08:25:20>>>cash read=00
2026-04-26 08:25:21>>>cash read=01
2026-04-26 08:25:23>>>cash read=3E
2026-04-26 08:25:31>>>cash read=29
2026-04-26 08:25:31 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 08:25:32>>>cash read=01
2026-04-26 08:25:33>>>cash read=3E
2026-04-26 08:25:36>>>cash read=00
2026-04-26 08:25:37>>>cash read=01
2026-04-26 08:25:41>>>cash read=3E


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


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


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


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


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


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


===08:57:55===
2026-04-26 08:57:24>>>cash read=0A
2026-04-26 08:57:25>>>cash read=3E


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


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


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


===09:18:56===
2026-04-26 09:18:27>>>cash read=00
2026-04-26 09:18:27>>>cash read=818F41
2026-04-26 09:18:27>>>cash write=02
2026-04-26 09:18:27 >>>回调事件130,cash_status,10022,进钞中...read money=5
2026-04-26 09:18:27>>>cash read=10
2026-04-26 09:18:27 >>>回调事件130,5,10023,finish Money=5,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 09:18:29>>>cash write=0C
2026-04-26 09:18:29>>>cash read=3E
2026-04-26 09:18:30>>>cash read=01
2026-04-26 09:18:32>>>cash read=3E
2026-04-26 09:18:34>>>cash read=00
2026-04-26 09:18:35>>>cash read=818F41
2026-04-26 09:18:35>>>cash write=02
2026-04-26 09:18:35 >>>回调事件130,cash_status,10022,进钞中...read money=5
2026-04-26 09:18:36>>>cash read=10
2026-04-26 09:18:36 >>>回调事件130,5,10023,finish Money=5,进钞完成
2026-04-26 09:18:36 当前产品价格10元，投币10元，打印小票中...
2026-04-26 09:18:36 >>>开始打印,排队号为14,订单号为2604260918270040519383
2026-04-26 09:18:36>>>订单2604260918270040519383写入成功,剩余空间为1679000,占用RAM为634.015625
删除未同步订单2604260918270040519383
2026-04-26 09:18:38>>>订单2604260918270040519383删除成功,剩余空间为1680000,占用RAM为646.73828125
检测订单目录中>>>
无未同步订单>>>
2026-04-26 09:18:38 >>>当前Ram内存为618.244140625
定时检测未同步订单启用[checkOrderNum=536871847]
2026-04-26 09:18:39>>>cash write=0C
2026-04-26 09:18:39>>>cash read=3E


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


===11:01:04===
2026-04-26 11:00:26>>>cash read=00
2026-04-26 11:00:27>>>cash read=29
2026-04-26 11:00:27 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 11:00:28>>>cash read=2F29
2026-04-26 11:00:30>>>cash read=3E


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


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


===11:06:04===
2026-04-26 11:05:18>>>cash read=00
2026-04-26 11:05:19>>>cash read=818F41
2026-04-26 11:05:19>>>cash write=02
2026-04-26 11:05:19 >>>回调事件130,cash_status,10022,进钞中...read money=5
2026-04-26 11:05:20>>>cash read=10
2026-04-26 11:05:20 >>>回调事件130,5,10023,finish Money=5,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 11:05:21>>>cash write=0C
2026-04-26 11:05:21>>>cash read=3E
2026-04-26 11:05:22>>>cash read=29
2026-04-26 11:05:22 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 11:05:23>>>cash read=3E
2026-04-26 11:05:25>>>cash read=00
2026-04-26 11:05:25>>>cash read=818F41
2026-04-26 11:05:25>>>cash write=02
2026-04-26 11:05:25 >>>回调事件130,cash_status,10022,进钞中...read money=5
2026-04-26 11:05:26>>>cash read=10
2026-04-26 11:05:26 >>>回调事件130,5,10023,finish Money=5,进钞完成
2026-04-26 11:05:26 当前产品价格10元，投币10元，打印小票中...
2026-04-26 11:05:26 >>>开始打印,排队号为48,订单号为2604261105200040519227
2026-04-26 11:05:26>>>订单2604261105200040519227写入成功,剩余空间为1679000,占用RAM为636.109375
删除未同步订单2604261105200040519227
2026-04-26 11:05:28>>>订单2604261105200040519227删除成功,剩余空间为1680000,占用RAM为646.693359375
检测订单目录中>>>
无未同步订单>>>
2026-04-26 11:05:28 >>>当前Ram内存为618.1025390625
定时检测未同步订单启用[checkOrderNum=536873093]
2026-04-26 11:05:29>>>cash read=818F41
2026-04-26 11:05:29 >>>回调事件130,cash_status,10022,进钞中...read money=5
2026-04-26 11:05:29>>>cash read=10
2026-04-26 11:05:29 >>>回调事件130,5,10023,finish Money=5,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 11:05:31>>>cash write=0C
2026-04-26 11:05:31>>>cash read=29
2026-04-26 11:05:31 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 11:05:31>>>cash read=2F292F
2026-04-26 11:05:32>>>cash read=00
2026-04-26 11:05:32>>>cash read=818F41
2026-04-26 11:05:32>>>cash write=02
2026-04-26 11:05:33 >>>回调事件130,cash_status,10022,进钞中...read money=5
2026-04-26 11:05:33>>>cash read=10
2026-04-26 11:05:33 >>>回调事件130,5,10023,finish Money=5,进钞完成
2026-04-26 11:05:33 当前产品价格10元，投币10元，打印小票中...
2026-04-26 11:05:33 >>>开始打印,排队号为49,订单号为2604261105290040519081
2026-04-26 11:05:33>>>订单2604261105290040519081写入成功,剩余空间为1678000,占用RAM为645.03125
删除未同步订单2604261105290040519081
2026-04-26 11:05:35>>>订单2604261105290040519081删除成功,剩余空间为1678500,占用RAM为653.6845703125
检测订单目录中>>>
无未同步订单>>>
2026-04-26 11:05:36 >>>当前Ram内存为619.8173828125
定时检测未同步订单启用[checkOrderNum=536873105]
2026-04-26 11:05:37>>>cash write=0C
2026-04-26 11:05:37>>>cash read=00
2026-04-26 11:05:38>>>cash read=2F29
2026-04-26 11:05:39>>>cash read=3E
2026-04-26 11:05:41>>>cash read=00
2026-04-26 11:05:42>>>cash read=2F29
2026-04-26 11:05:43>>>cash read=3E
2026-04-26 11:05:46>>>cash read=00
2026-04-26 11:05:47>>>cash read=29
2026-04-26 11:05:47 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 11:05:47>>>cash read=2F29
2026-04-26 11:05:48>>>cash read=3E
2026-04-26 11:05:52>>>cash read=00
2026-04-26 11:05:53>>>cash read=29
2026-04-26 11:05:53 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 11:05:53>>>cash read=2F29
2026-04-26 11:05:55>>>cash read=3E


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


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


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


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


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


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


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


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


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


===12:15:07===
2026-04-26 12:14:52>>>cash read=0A
2026-04-26 12:14:53>>>cash read=3E


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


===12:18:07===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 12:17:30 >>>回调事件[910,devices/D0519]
2026-04-26 12:17:30 >>>故障排除日志:上一MQTT订单号缓存列表为2604261216070069860026
2026-04-26 12:17:30 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 12:17:30 开始打印,排队:62,票券:2604261217240909368601,订单:2604261217240007193929,[2026-04-26 12:17:29微信支付10元]
2026-04-26 12:17:30>>>MQTT票号同步场景，创建空订单对象
2026-04-26 12:17:30>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 12:17:32 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261217240909368601","queue_number":62,"trade_uid":"2604261217240007193929"}]}
2026-04-26 12:17:32 >>>故障排除日志:删除未同步下发订单成功2604261217240007193929
2026-04-26 12:17:32 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536873859]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 12:17:56 >>>回调事件[910,devices/D0519]
2026-04-26 12:17:56 >>>故障排除日志:上一MQTT订单号缓存列表为2604261217240007193929
2026-04-26 12:17:56 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 12:17:56 开始打印,排队:63,票券:2604261217478407796701,订单:2604261217470081104548,[2026-04-26 12:17:55微信支付10元]
2026-04-26 12:17:56 开始打印,排队:64,票券:2604261217478408209102,订单:2604261217470081104548,[2026-04-26 12:17:55微信支付10元]
2026-04-26 12:17:56>>>MQTT票号同步场景，创建空订单对象
2026-04-26 12:17:56>>>合并MQTT票号列表到订单同步请求,共2张票
2026-04-26 12:17:59 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261217478407796701","queue_number":63,"trade_uid":"2604261217470081104548"},{"ticket_no":"2604261217478408209102","queue_number":64,"trade_uid":"2604261217470081104548"}]}
2026-04-26 12:17:59 >>>故障排除日志:删除未同步下发订单成功2604261217470081104548
2026-04-26 12:18:00 >>>故障排除日志:删除未同步下发订单成功2604261217470081104548
2026-04-26 12:18:00 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536873870]


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


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


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


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


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


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


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


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


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


===12:49:10===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 12:48:12 >>>回调事件[910,devices/D0519]
2026-04-26 12:48:12 >>>故障排除日志:上一MQTT订单号缓存列表为2604261245070046162789
2026-04-26 12:48:12 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 12:48:12 开始打印,排队:77,票券:2604261248022606533701,订单:2604261248020024058941,[2026-04-26 12:48:12微信支付10元]
2026-04-26 12:48:13>>>MQTT票号同步场景，创建空订单对象
2026-04-26 12:48:13>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 12:48:15 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261248022606533701","queue_number":77,"trade_uid":"2604261248020024058941"}]}
2026-04-26 12:48:15 >>>故障排除日志:删除未同步下发订单成功2604261248020024058941
2026-04-26 12:48:15 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536874223]
2026-04-26 12:48:28>>>cash read=00
2026-04-26 12:48:29>>>cash read=2F29
2026-04-26 12:48:30>>>cash read=01
2026-04-26 12:48:32>>>cash read=2F
2026-04-26 12:48:33>>>cash read=3E
2026-04-26 12:48:34>>>cash read=00
2026-04-26 12:48:36>>>cash read=2F29
2026-04-26 12:48:37>>>cash read=3E
2026-04-26 12:48:42>>>cash read=00
2026-04-26 12:48:43>>>cash read=29
2026-04-26 12:48:43 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 12:48:43>>>cash read=2F29
2026-04-26 12:48:44>>>cash read=3E
2026-04-26 12:48:48>>>cash read=00
2026-04-26 12:48:50>>>cash read=2F29
2026-04-26 12:48:51>>>cash read=01
2026-04-26 12:48:52>>>cash read=2F
2026-04-26 12:48:53>>>cash read=3E
2026-04-26 12:48:56>>>cash read=00
2026-04-26 12:48:57>>>cash read=2F29
2026-04-26 12:48:58>>>cash read=3E
2026-04-26 12:48:59>>>cash read=00
2026-04-26 12:49:01>>>cash read=29
2026-04-26 12:49:01 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 12:49:01>>>cash read=2F29
2026-04-26 12:49:02>>>cash read=01
2026-04-26 12:49:05>>>cash read=2F
2026-04-26 12:49:06>>>cash read=3E


===12:55:10===
2026-04-26 12:54:38>>>cash read=00
2026-04-26 12:54:40>>>cash read=2F29
2026-04-26 12:54:41>>>cash read=3E
2026-04-26 12:54:42>>>cash read=00
2026-04-26 12:54:43>>>cash read=29
2026-04-26 12:54:43 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 12:54:44>>>cash read=2F292F
2026-04-26 12:54:45>>>cash read=00
2026-04-26 12:54:47>>>cash read=2F29
2026-04-26 12:54:48>>>cash read=00
2026-04-26 12:54:49>>>cash read=29
2026-04-26 12:54:49 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 12:54:50>>>cash read=2F29
2026-04-26 12:54:51>>>cash read=3E
2026-04-26 12:54:56>>>cash read=00
2026-04-26 12:54:57>>>cash read=818F42
2026-04-26 12:54:57>>>cash write=02
2026-04-26 12:54:57 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 12:54:57>>>cash read=10
2026-04-26 12:54:57 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 12:54:58 当前产品价格10元，投币10元，打印小票中...
2026-04-26 12:54:58 >>>开始打印,排队号为78,订单号为2604261254580040519627
2026-04-26 12:54:58>>>订单2604261254580040519627写入成功,剩余空间为1679000,占用RAM为637.1533203125
删除未同步订单2604261254580040519627
2026-04-26 12:55:00>>>订单2604261254580040519627删除成功,剩余空间为1680000,占用RAM为644.7900390625
检测订单目录中>>>
无未同步订单>>>
2026-04-26 12:55:00 >>>当前Ram内存为616.080078125
定时检测未同步订单启用[checkOrderNum=536874295]
2026-04-26 12:55:01>>>cash write=0C
2026-04-26 12:55:01>>>cash read=3E


===12:56:11===
2026-04-26 12:55:11>>>cash read=29
2026-04-26 12:55:11 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 12:55:12>>>cash read=01
2026-04-26 12:55:13>>>cash read=3E
2026-04-26 12:55:15>>>cash read=00
2026-04-26 12:55:15>>>cash read=2F29
2026-04-26 12:55:17>>>cash read=3E
2026-04-26 12:55:30>>>cash read=00
2026-04-26 12:55:31>>>cash read=29
2026-04-26 12:55:31 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 12:55:32>>>cash read=2F29
2026-04-26 12:55:33>>>cash read=3E
2026-04-26 12:55:41>>>cash read=00
2026-04-26 12:55:42>>>cash read=29
2026-04-26 12:55:42 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 12:55:42>>>cash read=2F29
2026-04-26 12:55:43>>>cash read=00
2026-04-26 12:55:44>>>cash read=818F42
2026-04-26 12:55:44>>>cash write=02
2026-04-26 12:55:44 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 12:55:44>>>cash read=10
2026-04-26 12:55:44 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 12:55:44 当前产品价格10元，投币10元，打印小票中...
2026-04-26 12:55:45 >>>开始打印,排队号为79,订单号为2604261255450040519589
2026-04-26 12:55:45>>>订单2604261255450040519589写入成功,剩余空间为1679000,占用RAM为636.0400390625
删除未同步订单2604261255450040519589
2026-04-26 12:55:47>>>订单2604261255450040519589删除成功,剩余空间为1680000,占用RAM为648.3466796875
检测订单目录中>>>
无未同步订单>>>
2026-04-26 12:55:47 >>>当前Ram内存为617.7958984375
定时检测未同步订单启用[checkOrderNum=536874308]
2026-04-26 12:55:48>>>cash write=0C
2026-04-26 12:55:48>>>cash read=3E


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


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


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


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


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


===13:34:12===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 13:33:13 >>>回调事件[910,devices/D0519]
2026-04-26 13:33:13 >>>故障排除日志:上一MQTT订单号缓存列表为2604261330590000416482
2026-04-26 13:33:13 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 13:33:13 开始打印,排队:85,票券:2604261333055905513401,订单:2604261333050057171769,[2026-04-26 13:33:12微信支付10元]
2026-04-26 13:33:13>>>MQTT票号同步场景，创建空订单对象
2026-04-26 13:33:13>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 13:33:15 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261333055905513401","queue_number":85,"trade_uid":"2604261333050057171769"}]}
2026-04-26 13:33:15 >>>故障排除日志:删除未同步下发订单成功2604261333050057171769
2026-04-26 13:33:15 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536874696]
2026-04-26 13:33:45>>>cash read=00
2026-04-26 13:33:46>>>cash read=818F42
2026-04-26 13:33:46>>>cash write=02
2026-04-26 13:33:46 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 13:33:46>>>cash read=10
2026-04-26 13:33:46 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 13:33:46 当前产品价格10元，投币10元，打印小票中...
2026-04-26 13:33:46 >>>开始打印,排队号为86,订单号为2604261333460040519347
2026-04-26 13:33:47>>>订单2604261333460040519347写入成功,剩余空间为1678500,占用RAM为637.9404296875
删除未同步订单2604261333460040519347
2026-04-26 13:33:49>>>订单2604261333460040519347删除成功,剩余空间为1679500,占用RAM为647.244140625
检测订单目录中>>>
无未同步订单>>>
2026-04-26 13:33:49 >>>当前Ram内存为616.1123046875
定时检测未同步订单启用[checkOrderNum=536874704]
2026-04-26 13:33:50>>>cash write=0C
2026-04-26 13:33:50>>>cash read=3E


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


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


===13:39:13===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 13:38:52 >>>回调事件[910,devices/D0519]
2026-04-26 13:38:52 >>>故障排除日志:上一MQTT订单号缓存列表为2604261336010038469135
2026-04-26 13:38:52 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 13:38:52 开始打印,排队:89,票券:2604261338452437437101,订单:2604261338450022074258,[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":"2604261338452437437101","queue_number":89,"trade_uid":"2604261338450022074258"}]}
2026-04-26 13:38:54 >>>故障排除日志:删除未同步下发订单成功2604261338450022074258
2026-04-26 13:38:54 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536874778]


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


===15:19:24===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 15:18:39 >>>回调事件[910,devices/D0519]
2026-04-26 15:18:39 >>>故障排除日志:上一MQTT订单号缓存列表为2604261514130088939127
2026-04-26 15:18:39 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 15:18:39 开始打印,排队:125,票券:2604261518336977973401,订单:2604261518330067135675,[2026-04-26 15:18:39微信支付10元]
2026-04-26 15:18:40>>>MQTT票号同步场景，创建空订单对象
2026-04-26 15:18:40>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 15:18:41>>>cash read=2F292F
2026-04-26 15:18:42 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261518336977973401","queue_number":125,"trade_uid":"2604261518330067135675"}]}
2026-04-26 15:18:42 >>>故障排除日志:删除未同步下发订单成功2604261518330067135675
2026-04-26 15:18:42 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536876017]
2026-04-26 15:18:43>>>cash read=3E
2026-04-26 15:18:45>>>cash read=00
2026-04-26 15:18:46>>>cash read=29
2026-04-26 15:18:46 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 15:18:47>>>cash read=2F29
2026-04-26 15:18:48>>>cash read=3E
2026-04-26 15:18:51>>>cash read=00
2026-04-26 15:18:53>>>cash read=29
2026-04-26 15:18:53 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 15:18:53>>>cash read=2F29
2026-04-26 15:18:54>>>cash read=3E


===15:20:24===
2026-04-26 15:19:40>>>cash read=00
2026-04-26 15:19:42>>>cash read=292F29
2026-04-26 15:19:42 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 15:19:43>>>cash read=3E
2026-04-26 15:19:44>>>cash read=00
2026-04-26 15:19:46>>>cash read=2F29
2026-04-26 15:19:47>>>cash read=00
2026-04-26 15:19:48>>>cash read=29
2026-04-26 15:19:48 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 15:19:48>>>cash read=2F29
2026-04-26 15:19:50>>>cash read=00
2026-04-26 15:19:51>>>cash read=29
2026-04-26 15:19:51 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 15:19:51>>>cash read=2F29
2026-04-26 15:19:52>>>cash read=3E
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 15:20:17 >>>回调事件[910,devices/D0519]
2026-04-26 15:20:17 >>>故障排除日志:上一MQTT订单号缓存列表为2604261518330067135675
2026-04-26 15:20:17 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 15:20:17 开始打印,排队:126,票券:2604261520062102555801,订单:2604261520060018703118,[2026-04-26 15:20:16微信支付10元]
2026-04-26 15:20:17>>>MQTT票号同步场景，创建空订单对象
2026-04-26 15:20:17>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 15:20:19 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261520062102555801","queue_number":126,"trade_uid":"2604261520060018703118"}]}
2026-04-26 15:20:19 >>>故障排除日志:删除未同步下发订单成功2604261520060018703118
2026-04-26 15:20:19 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536876042]


===15:24:24===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 15:23:40 >>>回调事件[910,devices/D0519]
2026-04-26 15:23:40 >>>故障排除日志:上一MQTT订单号缓存列表为2604261520060018703118
2026-04-26 15:23:40 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 15:23:40 开始打印,排队:127,票券:2604261523335989222601,订单:2604261523330057602532,[2026-04-26 15:23:40微信支付10元]
2026-04-26 15:23:40>>>MQTT票号同步场景，创建空订单对象
2026-04-26 15:23:40>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 15:23:42 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261523335989222601","queue_number":127,"trade_uid":"2604261523330057602532"}]}
2026-04-26 15:23:42 >>>故障排除日志:删除未同步下发订单成功2604261523330057602532
2026-04-26 15:23:42 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536876078]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 15:24:00 >>>回调事件[910,devices/D0519]
2026-04-26 15:24:00 >>>故障排除日志:上一MQTT订单号缓存列表为2604261523330057602532
2026-04-26 15:24:00 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 15:24:00 开始打印,排队:128,票券:2604261523508946355901,订单:2604261523500087541259,[2026-04-26 15:23:59微信支付10元]
2026-04-26 15:24:00>>>MQTT票号同步场景，创建空订单对象
2026-04-26 15:24:00>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 15:24:02 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261523508946355901","queue_number":128,"trade_uid":"2604261523500087541259"}]}
2026-04-26 15:24:02 >>>故障排除日志:删除未同步下发订单成功2604261523500087541259
2026-04-26 15:24:02 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536876090]
2026-04-26 15:24:19>>>cash read=00
2026-04-26 15:24:20>>>cash read=2F2901
2026-04-26 15:24:21>>>cash read=3E
2026-04-26 15:24:22>>>cash read=29
2026-04-26 15:24:22 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 15:24:23>>>cash read=2F29


===15:25:25===
2026-04-26 15:24:24>>>cash read=00
2026-04-26 15:24:25>>>cash read=2F29
2026-04-26 15:24:26>>>cash read=3E


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


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


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


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


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


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


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


===15:42:27===
2026-04-26 15:41:34>>>cash read=00
2026-04-26 15:41:35>>>cash read=29
2026-04-26 15:41:35 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 15:41:35>>>cash read=2F292F
2026-04-26 15:41:36>>>cash read=3E
2026-04-26 15:41:37>>>cash read=00
2026-04-26 15:41:38>>>cash read=292F29
2026-04-26 15:41:38 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 15:41:40>>>cash read=3E
2026-04-26 15:41:41>>>cash read=00
2026-04-26 15:41:42>>>cash read=2F29
2026-04-26 15:41:43>>>cash read=00
2026-04-26 15:41:45>>>cash read=2F29
2026-04-26 15:41:46>>>cash read=00
2026-04-26 15:41:47>>>cash read=29
2026-04-26 15:41:47 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 15:41:48>>>cash read=2F29
2026-04-26 15:41:49>>>cash read=00
2026-04-26 15:41:50>>>cash read=29
2026-04-26 15:41:50 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 15:41:51>>>cash read=2F29
2026-04-26 15:41:52>>>cash read=3E
2026-04-26 15:41:53>>>cash read=00
2026-04-26 15:41:54>>>cash read=2F29
2026-04-26 15:41:55>>>cash read=00
2026-04-26 15:41:56>>>cash read=29
2026-04-26 15:41:56 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 15:41:57>>>cash read=2F29
2026-04-26 15:41:58>>>cash read=00
2026-04-26 15:41:59>>>cash read=29
2026-04-26 15:41:59 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 15:42:00>>>cash read=2F29
2026-04-26 15:42:01>>>cash read=00
2026-04-26 15:42:02>>>cash read=29
2026-04-26 15:42:02 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 15:42:03>>>cash read=2F29
2026-04-26 15:42:04>>>cash read=00
2026-04-26 15:42:05>>>cash read=29
2026-04-26 15:42:05 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 15:42:05>>>cash read=2F29
2026-04-26 15:42:07>>>cash read=3E
2026-04-26 15:42:14>>>cash read=00
2026-04-26 15:42:15>>>cash read=29
2026-04-26 15:42:15 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 15:42:15>>>cash read=2F29
2026-04-26 15:42:16>>>cash read=00
2026-04-26 15:42:17>>>cash read=29
2026-04-26 15:42:17 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 15:42:18>>>cash read=2F29
2026-04-26 15:42:19>>>cash read=00
2026-04-26 15:42:20>>>cash read=29
2026-04-26 15:42:20 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 15:42:20>>>cash read=2F29
2026-04-26 15:42:22>>>cash read=00
2026-04-26 15:42:23>>>cash read=29
2026-04-26 15:42:23 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 15:42:23>>>cash read=2F292F
2026-04-26 15:42:24>>>cash read=00
2026-04-26 15:42:25>>>cash read=29
2026-04-26 15:42:25 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 15:42:26>>>cash read=2F29


===15:43:27===
2026-04-26 15:42:27>>>cash read=00
2026-04-26 15:42:28>>>cash read=29
2026-04-26 15:42:28 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 15:42:28>>>cash read=2F29
2026-04-26 15:42:29>>>cash read=00
2026-04-26 15:42:31>>>cash read=29
2026-04-26 15:42:31 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 15:42:31>>>cash read=2F29
2026-04-26 15:42:32>>>cash read=3E


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


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


===15:48:28===
2026-04-26 15:48:08>>>cash read=00
2026-04-26 15:48:09>>>cash read=292F29
2026-04-26 15:48:09 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 15:48:10>>>cash read=01
2026-04-26 15:48:14>>>cash read=2F
2026-04-26 15:48:15>>>cash read=29
2026-04-26 15:48:15 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 15:48:17>>>cash read=01


===15:49:28===
2026-04-26 15:48:40>>>cash read=3E
2026-04-26 15:48:46>>>cash read=00
2026-04-26 15:48:46>>>cash read=818F42
2026-04-26 15:48:46>>>cash write=02
2026-04-26 15:48:47 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 15:48:47>>>cash read=10
2026-04-26 15:48:47 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 15:48:47 当前产品价格10元，投币10元，打印小票中...
2026-04-26 15:48:47 >>>开始打印,排队号为139,订单号为2604261548470040519318
2026-04-26 15:48:47>>>订单2604261548470040519318写入成功,剩余空间为1679500,占用RAM为634.0244140625
删除未同步订单2604261548470040519318
2026-04-26 15:48:49>>>订单2604261548470040519318删除成功,剩余空间为1680500,占用RAM为643.80859375
检测订单目录中>>>
无未同步订单>>>
2026-04-26 15:48:49 >>>当前Ram内存为616.0390625
定时检测未同步订单启用[checkOrderNum=536876404]
2026-04-26 15:48:50>>>cash read=2F29
2026-04-26 15:48:51>>>cash write=0C
2026-04-26 15:48:51>>>cash read=01
2026-04-26 15:48:51>>>cash read=2F
2026-04-26 15:48:52>>>cash read=3E
2026-04-26 15:48:55>>>cash read=00
2026-04-26 15:48:55>>>cash read=818F42
2026-04-26 15:48:55>>>cash write=02
2026-04-26 15:48:55 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 15:48:55>>>cash read=10
2026-04-26 15:48:55 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 15:48:55 当前产品价格10元，投币10元，打印小票中...
2026-04-26 15:48:55 >>>开始打印,排队号为140,订单号为2604261548550040519387
2026-04-26 15:48:56>>>订单2604261548550040519387写入成功,剩余空间为1678500,占用RAM为642.9423828125
删除未同步订单2604261548550040519387
2026-04-26 15:48:58>>>订单2604261548550040519387删除成功,剩余空间为1679500,占用RAM为650.1259765625
检测订单目录中>>>
无未同步订单>>>
2026-04-26 15:48:58 >>>当前Ram内存为616.6142578125
定时检测未同步订单启用[checkOrderNum=536876416]
2026-04-26 15:48:59>>>cash write=0C
2026-04-26 15:48:59>>>cash read=3E
2026-04-26 15:49:00>>>cash read=00
2026-04-26 15:49:01>>>cash read=818F42
2026-04-26 15:49:01>>>cash write=02
2026-04-26 15:49:01 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 15:49:01>>>cash read=10
2026-04-26 15:49:01 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 15:49:01 当前产品价格10元，投币10元，打印小票中...
2026-04-26 15:49:01 >>>开始打印,排队号为141,订单号为2604261549010040519831
2026-04-26 15:49:01>>>订单2604261549010040519831写入成功,剩余空间为1677500,占用RAM为647.439453125
删除未同步订单2604261549010040519831
2026-04-26 15:49:04>>>订单2604261549010040519831删除成功,剩余空间为1678500,占用RAM为652.625
检测订单目录中>>>
无未同步订单>>>
2026-04-26 15:49:04 >>>当前Ram内存为618.193359375
定时检测未同步订单启用[checkOrderNum=536876425]
2026-04-26 15:49:05>>>cash write=0C
2026-04-26 15:49:05>>>cash read=3E


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


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


===15:56:29===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 15:55:28 >>>回调事件[910,devices/D0519]
2026-04-26 15:55:28 >>>故障排除日志:上一MQTT订单号缓存列表为2604261549200064310374
2026-04-26 15:55:28 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 15:55:28 开始打印,排队:144,票券:2604261555006852903201,订单:2604261555000066564434,[2026-04-26 15:55:27支付宝支付10元]
2026-04-26 15:55:28>>>MQTT票号同步场景，创建空订单对象
2026-04-26 15:55:28>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 15:55:30 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261555006852903201","queue_number":144,"trade_uid":"2604261555000066564434"}]}
2026-04-26 15:55:30 >>>故障排除日志:删除未同步下发订单成功2604261555000066564434
2026-04-26 15:55:30 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536876505]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 15:55:41 >>>回调事件[910,devices/D0519]
2026-04-26 15:55:41 >>>故障排除日志:上一MQTT订单号缓存列表为2604261555000066564434
2026-04-26 15:55:41 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 15:55:41 开始打印,排队:145,票券:2604261555343855188501,订单:2604261555340036256247,[2026-04-26 15:55:40微信支付10元]
2026-04-26 15:55:41>>>MQTT票号同步场景，创建空订单对象
2026-04-26 15:55:41>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 15:55:43 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261555343855188501","queue_number":145,"trade_uid":"2604261555340036256247"}]}
2026-04-26 15:55:43 >>>故障排除日志:删除未同步下发订单成功2604261555340036256247
2026-04-26 15:55:43 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536876511]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 15:56:18 >>>回调事件[910,devices/D0519]
2026-04-26 15:56:18 >>>故障排除日志:上一MQTT订单号缓存列表为2604261555340036256247
2026-04-26 15:56:18 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 15:56:18 开始打印,排队:146,票券:2604261556100192024901,订单:2604261556100000092195,[2026-04-26 15:56:16微信支付10元]
2026-04-26 15:56:18>>>MQTT票号同步场景，创建空订单对象
2026-04-26 15:56:18>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 15:56:20 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261556100192024901","queue_number":146,"trade_uid":"2604261556100000092195"}]}
2026-04-26 15:56:20 >>>故障排除日志:删除未同步下发订单成功2604261556100000092195
2026-04-26 15:56:20 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536876526]


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


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


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


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


===16:10:30===
2026-04-26 16:10:16>>>cash read=00
2026-04-26 16:10:17>>>cash read=29
2026-04-26 16:10:17 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 16:10:17>>>cash read=2F29
2026-04-26 16:10:19>>>cash read=3E
2026-04-26 16:10:25>>>cash read=29
2026-04-26 16:10:25 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 16:10:26>>>cash read=01


===16:11:30===
2026-04-26 16:10:30>>>cash read=3E
2026-04-26 16:10:32>>>cash read=00
2026-04-26 16:10:32>>>cash read=2F29
2026-04-26 16:10:34>>>cash read=3E
2026-04-26 16:10:43>>>cash read=00
2026-04-26 16:10:44>>>cash read=29
2026-04-26 16:10:44 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 16:10:45>>>cash read=2F29
2026-04-26 16:10:46>>>cash read=012F
2026-04-26 16:10:47>>>cash read=3E
2026-04-26 16:10:48>>>cash read=00
2026-04-26 16:10:49>>>cash read=2F29
2026-04-26 16:10:50>>>cash read=012F
2026-04-26 16:10:51>>>cash read=3E
2026-04-26 16:11:04>>>cash read=29
2026-04-26 16:11:04 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 16:11:05>>>cash read=01
2026-04-26 16:11:09>>>cash read=00
2026-04-26 16:11:11>>>cash read=29
2026-04-26 16:11:11 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 16:11:11>>>cash read=2F29
2026-04-26 16:11:12>>>cash read=01
2026-04-26 16:11:13>>>cash read=2F
2026-04-26 16:11:15>>>cash read=00
2026-04-26 16:11:15>>>cash read=818F42
2026-04-26 16:11:15>>>cash write=02
2026-04-26 16:11:15 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 16:11:16>>>cash read=10
2026-04-26 16:11:16 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 16:11:16 当前产品价格10元，投币10元，打印小票中...
2026-04-26 16:11:16 >>>开始打印,排队号为152,订单号为2604261611160040519767
2026-04-26 16:11:16>>>订单2604261611160040519767写入成功,剩余空间为1679000,占用RAM为639.2431640625
删除未同步订单2604261611160040519767
2026-04-26 16:11:18>>>订单2604261611160040519767删除成功,剩余空间为1679500,占用RAM为645.6279296875
检测订单目录中>>>
无未同步订单>>>
2026-04-26 16:11:18 >>>当前Ram内存为616.197265625
定时检测未同步订单启用[checkOrderNum=536876709]
2026-04-26 16:11:19>>>cash write=0C
2026-04-26 16:11:20>>>cash read=3E


===16:15:30===
2026-04-26 16:14:35>>>cash read=00
2026-04-26 16:14:36>>>cash read=292F29
2026-04-26 16:14:36 >>>回调事件130,cash_status,20029,退钞中
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 16:14:36 >>>回调事件[910,devices/D0519]
2026-04-26 16:14:36 >>>故障排除日志:上一MQTT订单号缓存列表为2604261606300095621472
2026-04-26 16:14:36 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 16:14:36 开始打印,排队:153,票券:2604261614296436511501,订单:2604261614290062264526,[2026-04-26 16:14:35微信支付10元]
2026-04-26 16:14:36>>>MQTT票号同步场景，创建空订单对象
2026-04-26 16:14:36>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 16:14:38 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261614296436511501","queue_number":153,"trade_uid":"2604261614290062264526"}]}
2026-04-26 16:14:38 >>>故障排除日志:删除未同步下发订单成功2604261614290062264526
2026-04-26 16:14:38 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536876745]
2026-04-26 16:14:39>>>cash read=3E
2026-04-26 16:14:40>>>cash read=00
2026-04-26 16:14:42>>>cash read=2F29
2026-04-26 16:14:44>>>cash read=3E
2026-04-26 16:14:46>>>cash read=00
2026-04-26 16:14:47>>>cash read=2F29
2026-04-26 16:14:48>>>cash read=3E
2026-04-26 16:14:55>>>cash read=00
2026-04-26 16:14:56>>>cash read=2F29
2026-04-26 16:14:57>>>cash read=01
2026-04-26 16:14:58>>>cash read=2F
2026-04-26 16:15:00>>>cash read=00
2026-04-26 16:15:01>>>cash read=29
2026-04-26 16:15:01 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 16:15:01>>>cash read=2F29
2026-04-26 16:15:02>>>cash read=00
2026-04-26 16:15:03>>>cash read=2F29
2026-04-26 16:15:04>>>cash read=3E
2026-04-26 16:15:05>>>cash read=00
2026-04-26 16:15:06>>>cash read=01
2026-04-26 16:15:08>>>cash read=00
2026-04-26 16:15:09>>>cash read=29
2026-04-26 16:15:09 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 16:15:09>>>cash read=2F29
2026-04-26 16:15:10>>>cash read=3E
2026-04-26 16:15:16>>>cash read=00
2026-04-26 16:15:18>>>cash read=2F29
2026-04-26 16:15:20>>>cash read=3E
2026-04-26 16:15:22>>>cash read=00
2026-04-26 16:15:23>>>cash read=2F29
2026-04-26 16:15:24>>>cash read=01
2026-04-26 16:15:24>>>cash read=2F
2026-04-26 16:15:25>>>cash read=3E
2026-04-26 16:15:26>>>cash read=00
2026-04-26 16:15:28>>>cash read=29
2026-04-26 16:15:28 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 16:15:28>>>cash read=2F29


===16:16:30===
2026-04-26 16:15:30>>>cash read=3E
2026-04-26 16:15:33>>>cash read=00
2026-04-26 16:15:35>>>cash read=2F29
2026-04-26 16:15:37>>>cash read=3E
2026-04-26 16:15:46>>>cash read=00
2026-04-26 16:15:46>>>cash read=2F29
2026-04-26 16:15:47>>>cash read=01
2026-04-26 16:15:51>>>cash read=2F3E
2026-04-26 16:15:53>>>cash read=29
2026-04-26 16:15:53 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 16:15:54>>>cash read=2F29
2026-04-26 16:15:55>>>cash read=3E


===16:23:30===
2026-04-26 16:23:14>>>cash read=00
2026-04-26 16:23:16>>>cash read=2F29
2026-04-26 16:23:18>>>cash read=00
2026-04-26 16:23:19>>>cash read=29
2026-04-26 16:23:19 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 16:23:19>>>cash read=2F29
2026-04-26 16:23:20>>>cash read=3E
2026-04-26 16:23:23>>>cash read=00
2026-04-26 16:23:24>>>cash read=2F29
2026-04-26 16:23:25>>>cash read=3E


===16:24:31===
2026-04-26 16:23:33>>>cash read=00
2026-04-26 16:23:34>>>cash read=818F42
2026-04-26 16:23:34>>>cash write=02
2026-04-26 16:23:34 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 16:23:34>>>cash read=10
2026-04-26 16:23:34 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 16:23:34 当前产品价格10元，投币10元，打印小票中...
2026-04-26 16:23:34 >>>开始打印,排队号为154,订单号为2604261623340040519668
2026-04-26 16:23:34>>>订单2604261623340040519668写入成功,剩余空间为1679500,占用RAM为632.982421875
删除未同步订单2604261623340040519668
2026-04-26 16:23:36>>>订单2604261623340040519668删除成功,剩余空间为1680500,占用RAM为642.9384765625
检测订单目录中>>>
无未同步订单>>>
2026-04-26 16:23:37 >>>当前Ram内存为615.2001953125
定时检测未同步订单启用[checkOrderNum=536876842]
2026-04-26 16:23:37>>>cash write=0C
2026-04-26 16:23:38>>>cash read=3E
2026-04-26 16:23:40>>>cash read=00
2026-04-26 16:23:41>>>cash read=29
2026-04-26 16:23:41 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 16:23:41>>>cash read=2F29
2026-04-26 16:23:43>>>cash read=3E
2026-04-26 16:23:46>>>cash read=00
2026-04-26 16:23:47>>>cash read=818F42
2026-04-26 16:23:47>>>cash write=02
2026-04-26 16:23:47 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 16:23:47>>>cash read=10
2026-04-26 16:23:47 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 16:23:47 当前产品价格10元，投币10元，打印小票中...
2026-04-26 16:23:47 >>>开始打印,排队号为155,订单号为2604261623470040519680
2026-04-26 16:23:48>>>订单2604261623470040519680写入成功,剩余空间为1678500,占用RAM为641.283203125
删除未同步订单2604261623470040519680
2026-04-26 16:23:50>>>订单2604261623470040519680删除成功,剩余空间为1679000,占用RAM为646.0009765625
检测订单目录中>>>
无未同步订单>>>
2026-04-26 16:23:50 >>>当前Ram内存为615.923828125
定时检测未同步订单启用[checkOrderNum=536876849]
2026-04-26 16:23:51>>>cash write=0C
2026-04-26 16:23:51>>>cash read=3E


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


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


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


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


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


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


===16:35:32===
2026-04-26 16:34:52>>>cash read=29
2026-04-26 16:34:52 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 16:34:53>>>cash read=01
2026-04-26 16:34:56>>>cash read=00
2026-04-26 16:34:57>>>cash read=01
2026-04-26 16:34:59>>>cash read=3E
2026-04-26 16:35:00>>>cash read=00
2026-04-26 16:35:01>>>cash read=01
2026-04-26 16:35:07>>>cash read=3E
2026-04-26 16:35:10>>>cash read=00
2026-04-26 16:35:12>>>cash read=818F42
2026-04-26 16:35:12>>>cash write=02
2026-04-26 16:35:12 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 16:35:12>>>cash read=10
2026-04-26 16:35:12 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 16:35:12 当前产品价格10元，投币10元，打印小票中...
2026-04-26 16:35:12 >>>开始打印,排队号为163,订单号为2604261635120040519320
2026-04-26 16:35:12>>>订单2604261635120040519320写入成功,剩余空间为1679500,占用RAM为633.529296875
删除未同步订单2604261635120040519320
2026-04-26 16:35:14>>>订单2604261635120040519320删除成功,剩余空间为1680000,占用RAM为645.5556640625
检测订单目录中>>>
无未同步订单>>>
2026-04-26 16:35:14 >>>当前Ram内存为615.623046875
定时检测未同步订单启用[checkOrderNum=536877019]
2026-04-26 16:35:15>>>cash write=0C
2026-04-26 16:35:15>>>cash read=3E


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


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


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


===16:44:33===
2026-04-26 16:44:03>>>cash read=0A
2026-04-26 16:44:04>>>cash read=3E


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


===18:09:40===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 18:08:52 >>>回调事件[910,devices/D0519]
2026-04-26 18:08:52 >>>故障排除日志:上一MQTT订单号缓存列表为2604261807510010414751
2026-04-26 18:08:52 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 18:08:52 开始打印,排队:191,票券:2604261808429032816701,订单:2604261808420084449461,[2026-04-26 18:08:52支付宝支付10元]
2026-04-26 18:08:52>>>MQTT票号同步场景，创建空订单对象
2026-04-26 18:08:52>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 18:08:54 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261808429032816701","queue_number":191,"trade_uid":"2604261808420084449461"}]}
2026-04-26 18:08:54 >>>故障排除日志:删除未同步下发订单成功2604261808420084449461
2026-04-26 18:08:54 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878074]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 18:09:00 >>>回调事件[910,devices/D0519]
2026-04-26 18:09:00 >>>故障排除日志:上一MQTT订单号缓存列表为2604261808420084449461
2026-04-26 18:09:00 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 18:09:00 开始打印,排队:192,票券:2604261808458181315101,订单:2604261808450079820721,[2026-04-26 18:09:00微信支付10元]
2026-04-26 18:09:00>>>MQTT票号同步场景，创建空订单对象
2026-04-26 18:09:00>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 18:09:02 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261808458181315101","queue_number":192,"trade_uid":"2604261808450079820721"}]}
2026-04-26 18:09:02 >>>故障排除日志:删除未同步下发订单成功2604261808450079820721
2026-04-26 18:09:02 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878086]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 18:09:19 >>>回调事件[910,devices/D0519]
2026-04-26 18:09:19 >>>故障排除日志:上一MQTT订单号缓存列表为2604261808450079820721
2026-04-26 18:09:19 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 18:09:19 开始打印,排队:193,票券:2604261809123131702501,订单:2604261809120026013369,[2026-04-26 18:09:18微信支付10元]
2026-04-26 18:09:19>>>MQTT票号同步场景，创建空订单对象
2026-04-26 18:09:19>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 18:09:21 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261809123131702501","queue_number":193,"trade_uid":"2604261809120026013369"}]}
2026-04-26 18:09:21 >>>故障排除日志:删除未同步下发订单成功2604261809120026013369
2026-04-26 18:09:21 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878094]


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


===18:46:45===
2026-04-26 18:45:45>>>cash read=00
2026-04-26 18:45:46>>>cash read=292F29
2026-04-26 18:45:46 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 18:45:47>>>cash read=3E
2026-04-26 18:45:51>>>cash read=00
2026-04-26 18:45:52>>>cash read=2F29
2026-04-26 18:45:53>>>cash read=3E
2026-04-26 18:45:55>>>cash read=00
2026-04-26 18:45:56>>>cash read=29
2026-04-26 18:45:56 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 18:45:56>>>cash read=2F29
2026-04-26 18:45:57>>>cash read=3E
2026-04-26 18:46:03>>>cash read=00
2026-04-26 18:46:04>>>cash read=2F29
2026-04-26 18:46:05>>>cash read=3E
2026-04-26 18:46:07>>>cash read=00
2026-04-26 18:46:09>>>cash read=2F29
2026-04-26 18:46:11>>>cash read=3E
2026-04-26 18:46:14>>>cash read=00
2026-04-26 18:46:15>>>cash read=2F29
2026-04-26 18:46:17>>>cash read=3E
2026-04-26 18:46:19>>>cash read=00
2026-04-26 18:46:19>>>cash read=818F42
2026-04-26 18:46:19>>>cash write=02
2026-04-26 18:46:19 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 18:46:20>>>cash read=10
2026-04-26 18:46:20 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 18:46:20 当前产品价格10元，投币10元，打印小票中...
2026-04-26 18:46:20 >>>开始打印,排队号为216,订单号为2604261846200040519743
2026-04-26 18:46:20>>>订单2604261846200040519743写入成功,剩余空间为1679000,占用RAM为639.09375
删除未同步订单2604261846200040519743
2026-04-26 18:46:22>>>订单2604261846200040519743删除成功,剩余空间为1679500,占用RAM为646.8662109375
检测订单目录中>>>
无未同步订单>>>
2026-04-26 18:46:22 >>>当前Ram内存为616.4599609375
定时检测未同步订单启用[checkOrderNum=536878598]
2026-04-26 18:46:23>>>cash write=0C
2026-04-26 18:46:23>>>cash read=3E


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


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


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


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


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


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


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


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


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


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


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


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


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


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


===19:19:49===
2026-04-26 19:18:58>>>cash read=29
2026-04-26 19:18:58 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 19:18:59>>>cash read=01
2026-04-26 19:19:03>>>cash read=3E
2026-04-26 19:19:05>>>cash read=00
2026-04-26 19:19:06>>>cash read=01
2026-04-26 19:19:12>>>cash read=00
2026-04-26 19:19:13>>>cash read=2F29
2026-04-26 19:19:14 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 19:19:15>>>cash read=01
2026-04-26 19:19:17>>>cash read=3E
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:19:41 >>>回调事件[910,devices/D0519]
2026-04-26 19:19:41 >>>故障排除日志:上一MQTT订单号缓存列表为2604261917150053754218
2026-04-26 19:19:41 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 19:19:41 开始打印,排队:234,票券:2604261919316194431701,订单:2604261919310058448792,[2026-04-26 19:19:39微信支付10元]
2026-04-26 19:19:41>>>MQTT票号同步场景，创建空订单对象
2026-04-26 19:19:41>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 19:19:43 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261919316194431701","queue_number":234,"trade_uid":"2604261919310058448792"}]}
2026-04-26 19:19:43 >>>故障排除日志:删除未同步下发订单成功2604261919310058448792
2026-04-26 19:19:43 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536879027]


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


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


===19:24:49===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:24:11 >>>回调事件[910,devices/D0519]
2026-04-26 19:24:11 >>>故障排除日志:上一MQTT订单号缓存列表为2604261923360067882851
2026-04-26 19:24:11 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 19:24:11 开始打印,排队:238,票券:2604261924046573153401,订单:2604261924040063702265,[2026-04-26 19:24:10微信支付10元]
2026-04-26 19:24:11>>>MQTT票号同步场景，创建空订单对象
2026-04-26 19:24:11>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 19:24:13 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261924046573153401","queue_number":238,"trade_uid":"2604261924040063702265"}]}
2026-04-26 19:24:13 >>>故障排除日志:删除未同步下发订单成功2604261924040063702265
2026-04-26 19:24:13 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536879101]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:24:39 >>>回调事件[910,devices/D0519]
2026-04-26 19:24:39 >>>故障排除日志:上一MQTT订单号缓存列表为2604261924040063702265
2026-04-26 19:24:39 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 19:24:40 开始打印,排队:239,票券:2604261924346682767301,订单:2604261924340064965358,[2026-04-26 19:24:39微信支付10元]
2026-04-26 19:24:40 开始打印,排队:240,票券:2604261924346683184702,订单:2604261924340064965358,[2026-04-26 19:24:39微信支付10元]
2026-04-26 19:24:40>>>MQTT票号同步场景，创建空订单对象
2026-04-26 19:24:40>>>合并MQTT票号列表到订单同步请求,共2张票
2026-04-26 19:24:43 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261924346682767301","queue_number":239,"trade_uid":"2604261924340064965358"},{"ticket_no":"2604261924346683184702","queue_number":240,"trade_uid":"2604261924340064965358"}]}
2026-04-26 19:24:43 >>>故障排除日志:删除未同步下发订单成功2604261924340064965358
2026-04-26 19:24:43 >>>故障排除日志:删除未同步下发订单成功2604261924340064965358
2026-04-26 19:24:43 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536879108]


===19:25:50===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:24:58 >>>回调事件[910,devices/D0519]
2026-04-26 19:24:58 >>>故障排除日志:上一MQTT订单号缓存列表为2604261924340064965358|2604261924340064965358
2026-04-26 19:24:58 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 19:24:58 开始打印,排队:241,票券:2604261924510447825201,订单:2604261924510002278713,[2026-04-26 19:24:58微信支付10元]
2026-04-26 19:24:58 开始打印,排队:242,票券:2604261924510448437202,订单:2604261924510002278713,[2026-04-26 19:24:58微信支付10元]
2026-04-26 19:24:58>>>MQTT票号同步场景，创建空订单对象
2026-04-26 19:24:58>>>合并MQTT票号列表到订单同步请求,共2张票
2026-04-26 19:25:02 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261924510447825201","queue_number":241,"trade_uid":"2604261924510002278713"},{"ticket_no":"2604261924510448437202","queue_number":242,"trade_uid":"2604261924510002278713"}]}
2026-04-26 19:25:02 >>>故障排除日志:删除未同步下发订单成功2604261924510002278713
2026-04-26 19:25:02 >>>故障排除日志:删除未同步下发订单成功2604261924510002278713
2026-04-26 19:25:02 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536879123]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:25:40 >>>回调事件[910,devices/D0519]
2026-04-26 19:25:40 >>>故障排除日志:上一MQTT订单号缓存列表为2604261924510002278713|2604261924510002278713
2026-04-26 19:25:40 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 19:25:40 开始打印,排队:243,票券:2604261925329947584301,订单:2604261925320097239757,[2026-04-26 19:25:39微信支付10元]
2026-04-26 19:25:40>>>MQTT票号同步场景，创建空订单对象
2026-04-26 19:25:40>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 19:25:42 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261925329947584301","queue_number":243,"trade_uid":"2604261925320097239757"}]}
2026-04-26 19:25:43 >>>故障排除日志:删除未同步下发订单成功2604261925320097239757
2026-04-26 19:25:43 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536879131]


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


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


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


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


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


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


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


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


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


===19:48:53===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:48:20 >>>回调事件[910,devices/D0519]
2026-04-26 19:48:20 >>>故障排除日志:上一MQTT订单号缓存列表为2604261943100048554732
2026-04-26 19:48:20 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 19:48:20 开始打印,排队:256,票券:2604261948109814322801,订单:2604261948100096180036,[2026-04-26 19:48:19支付宝支付10元]
2026-04-26 19:48:20>>>MQTT票号同步场景，创建空订单对象
2026-04-26 19:48:20>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 19:48:22 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261948109814322801","queue_number":256,"trade_uid":"2604261948100096180036"}]}
2026-04-26 19:48:22 >>>故障排除日志:删除未同步下发订单成功2604261948100096180036
2026-04-26 19:48:22 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536879432]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:48:23 >>>回调事件[910,devices/D0519]
2026-04-26 19:48:23 >>>故障排除日志:上一MQTT订单号缓存列表为2604261948100096180036
2026-04-26 19:48:23 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 19:48:23 开始打印,排队:257,票券:2604261948142083723601,订单:2604261948140019071847,[2026-04-26 19:48:22微信支付10元]
2026-04-26 19:48:23>>>MQTT票号同步场景，创建空订单对象
2026-04-26 19:48:23>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 19:48:25 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261948142083723601","queue_number":257,"trade_uid":"2604261948140019071847"}]}
2026-04-26 19:48:25 >>>故障排除日志:删除未同步下发订单成功2604261948140019071847
2026-04-26 19:48:25 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536879438]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:48:30 >>>回调事件[910,devices/D0519]
2026-04-26 19:48:30 >>>故障排除日志:上一MQTT订单号缓存列表为2604261948140019071847
2026-04-26 19:48:30 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 19:48:30 开始打印,排队:258,票券:2604261948232741832901,订单:2604261948230025386568,[2026-04-26 19:48:29微信支付10元]
2026-04-26 19:48:30 开始打印,排队:259,票券:2604261948232742369302,订单:2604261948230025386568,[2026-04-26 19:48:29微信支付10元]
2026-04-26 19:48:30>>>MQTT票号同步场景，创建空订单对象
2026-04-26 19:48:30>>>合并MQTT票号列表到订单同步请求,共2张票
2026-04-26 19:48:34 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261948232741832901","queue_number":258,"trade_uid":"2604261948230025386568"},{"ticket_no":"2604261948232742369302","queue_number":259,"trade_uid":"2604261948230025386568"}]}
2026-04-26 19:48:34 >>>故障排除日志:删除未同步下发订单成功2604261948230025386568
2026-04-26 19:48:34 >>>故障排除日志:删除未同步下发订单成功2604261948230025386568
2026-04-26 19:48:34 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536879444]


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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