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

===07:55:53===
上一时间戳为1776988504
隔日重置时间戳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:4c912****09ac4
纸币器设置接收纸币范围为36
欢迎使用天羚自助售票系统[2.8.6]
定时检测未同步订单启用[checkOrderNum=536870969]
2026-04-25 07:54:52>>>cash write=30
2026-04-25 07:54:52>>>cash write=02
2026-04-25 07:54:52>>>cash write=3E
2026-04-25 07:54:52>>>cash read=808F808F
系统时间初始化成功，时间为202642575452
2026-04-25 07:54:53>>>cash write=02
2026-04-25 07:54:53 >>>剩余flash空间=1680000,占用RAM为653.4892578125
2026-04-25 07:54:53 >>>回调事件:910,subscribe,10000,连接服务器成功

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

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


===07:59:53===
2026-04-25 07:59:26>>>cash read=0A
2026-04-25 07:59:27>>>cash read=3E


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


===10:11:05===
2026-04-25 10:10:59>>>cash read=00
2026-04-25 10:11:01>>>cash read=818F42
2026-04-25 10:11:01>>>cash write=02
2026-04-25 10:11:01 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-25 10:11:01>>>cash read=10
2026-04-25 10:11:01 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-25 10:11:01 当前产品价格10元，投币10元，打印小票中...
2026-04-25 10:11:01 >>>开始打印,排队号为37,订单号为2604251011010040519626
2026-04-25 10:11:02>>>订单2604251011010040519626写入成功,剩余空间为1679500,占用RAM为636.470703125


===10:12:05===
删除未同步订单2604251011010040519626
2026-04-25 10:11:04>>>订单2604251011010040519626删除成功,剩余空间为1681500,占用RAM为648.47265625
检测订单目录中>>>
无未同步订单>>>
2026-04-25 10:11:04 >>>当前Ram内存为617.1064453125
定时检测未同步订单启用[checkOrderNum=536872495]
2026-04-25 10:11:05>>>cash write=0C
2026-04-25 10:11:05>>>cash read=3E


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


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


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


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


===10:30:06===
2026-04-25 10:29:50>>>cash read=29
2026-04-25 10:29:50 >>>回调事件130,cash_status,20029,退钞中
2026-04-25 10:29:51>>>cash read=01
2026-04-25 10:29:52>>>cash read=3E
2026-04-25 10:29:58>>>cash read=00
2026-04-25 10:29:59>>>cash read=3E
2026-04-25 10:30:01>>>cash read=00
2026-04-25 10:30:02>>>cash read=2F29
2026-04-25 10:30:04>>>cash read=3E


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


===10:33:07===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-25 10:32:31 >>>回调事件[910,devices/D0519]
2026-04-25 10:32:31 >>>故障排除日志:上一MQTT订单号缓存列表为2604251027190070091559
2026-04-25 10:32:31 >>>故障排除日志:终端未同步成功订单列表
2026-04-25 10:32:31 开始打印,排队:43,票券:2604251032243398399501,订单:2604251032240032047873,[2026-04-25 10:32:30微信支付10元]
2026-04-25 10:32:31>>>MQTT票号同步场景，创建空订单对象
2026-04-25 10:32:31>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-25 10:32:33 >>>回调事件[910,devices/D0519]
2026-04-25 10:32:33 >>>故障排除日志:上一MQTT订单号缓存列表为2604251032240032047873
2026-04-25 10:32:33 >>>故障排除日志:终端未同步成功订单列表00432604251032240032047873
2026-04-25 10:32:33 开始打印,排队:44,票券:2604251032225032026301,订单:2604251032220048371798,[2026-04-25 10:32:30微信支付10元]
已接收过此消息,票券号为2604251032243398399501,排队号为43
2026-04-25 10:32:33>>>HTTP请求进行中，跳过本次同步
2026-04-25 10:32:35 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604251032243398399501","queue_number":43,"trade_uid":"2604251032240032047873"}]}
2026-04-25 10:32:35 >>>故障排除日志:删除未同步下发订单成功2604251032240032047873
2026-04-25 10:32:35 >>>故障排除日志:终端同步成功后剩余订单列表00442604251032220048371798
定时检测未同步订单启用[checkOrderNum=536872736]


===10:34:07===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-25 10:33:23 >>>回调事件[910,devices/D0519]
2026-04-25 10:33:23 >>>故障排除日志:上一MQTT订单号缓存列表为2604251032220048371798|2604251032240032047873
2026-04-25 10:33:23 >>>故障排除日志:终端未同步成功订单列表00442604251032220048371798
已接收过此消息,票券号为2604251032225032026301,排队号为44
2026-04-25 10:33:23 开始打印,排队:45,票券:2604251033150804654301,订单:2604251033150005752715,[2026-04-25 10:33:23支付宝支付10元]
2026-04-25 10:33:23>>>MQTT票号同步场景，创建空订单对象
2026-04-25 10:33:23>>>合并MQTT票号列表到订单同步请求,共2张票
2026-04-25 10:33:25 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604251032225032026301","queue_number":44,"trade_uid":"2604251032220048371798"},{"ticket_no":"2604251033150804654301","queue_number":45,"trade_uid":"2604251033150005752715"}]}
2026-04-25 10:33:25 >>>故障排除日志:删除未同步下发订单成功2604251032220048371798
2026-04-25 10:33:25 >>>故障排除日志:删除未同步下发订单成功2604251033150005752715
2026-04-25 10:33:25 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536872753]


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


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


===10:49:08===
2026-04-25 10:48:31>>>cash read=00
2026-04-25 10:48:32>>>cash read=818F42
2026-04-25 10:48:32>>>cash write=02
2026-04-25 10:48:32 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-25 10:48:32>>>cash read=10
2026-04-25 10:48:32 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-25 10:48:32 当前产品价格10元，投币10元，打印小票中...
2026-04-25 10:48:32 >>>开始打印,排队号为48,订单号为2604251048320040519516
2026-04-25 10:48:33>>>订单2604251048320040519516写入成功,剩余空间为1679500,占用RAM为635.015625
删除未同步订单2604251048320040519516
2026-04-25 10:48:35>>>订单2604251048320040519516删除成功,剩余空间为1680500,占用RAM为644.98828125
检测订单目录中>>>
无未同步订单>>>
2026-04-25 10:48:35 >>>当前Ram内存为617.2353515625
定时检测未同步订单启用[checkOrderNum=536872913]
2026-04-25 10:48:36>>>cash write=0C
2026-04-25 10:48:36>>>cash read=3E
2026-04-25 10:48:44>>>cash read=00
2026-04-25 10:48:45>>>cash read=818F43
2026-04-25 10:48:45>>>cash write=02
2026-04-25 10:48:45 >>>回调事件130,cash_status,10022,进钞中...read money=20
2026-04-25 10:48:45>>>cash read=10
2026-04-25 10:48:45 >>>回调事件130,20,10023,finish Money=20,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-25 10:48:45 当前产品价格10元，投币20元，打印小票中...
2026-04-25 10:48:45 >>>开始打印,排队号为49,订单号为2604251048450040519438
2026-04-25 10:48:45 >>>开始打印,排队号为50,订单号为2604251048450040519438
2026-04-25 10:48:46>>>订单2604251048450040519438写入成功,剩余空间为1678000,占用RAM为647.19140625
删除未同步订单2604251048450040519438
2026-04-25 10:48:49>>>订单2604251048450040519438删除成功,剩余空间为1679500,占用RAM为662.1953125
检测订单目录中>>>
无未同步订单>>>
2026-04-25 10:48:49 >>>当前Ram内存为620.59375
定时检测未同步订单启用[checkOrderNum=536872923]
2026-04-25 10:48:50>>>cash write=0C
2026-04-25 10:48:50>>>cash read=3E


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


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


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


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


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


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


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


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


===11:20:10===
2026-04-25 11:19:13>>>cash read=0A
2026-04-25 11:19:15>>>cash read=3E


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


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


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


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


===11:48:11===
2026-04-25 11:47:24>>>cash read=00
2026-04-25 11:47:25>>>cash read=01
2026-04-25 11:47:30>>>cash read=00
2026-04-25 11:47:31>>>cash read=818F43
2026-04-25 11:47:31>>>cash write=02
2026-04-25 11:47:31 >>>回调事件130,cash_status,10022,进钞中...read money=20
2026-04-25 11:47:31>>>cash read=10
2026-04-25 11:47:31 >>>回调事件130,20,10023,finish Money=20,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-25 11:47:32 当前产品价格10元，投币20元，打印小票中...
2026-04-25 11:47:32 >>>开始打印,排队号为64,订单号为2604251147320040519276
2026-04-25 11:47:32 >>>开始打印,排队号为65,订单号为2604251147320040519276
2026-04-25 11:47:32>>>订单2604251147320040519276写入成功,剩余空间为1679000,占用RAM为642.4609375
删除未同步订单2604251147320040519276
2026-04-25 11:47:36>>>订单2604251147320040519276删除成功,剩余空间为1680500,占用RAM为658.103515625
检测订单目录中>>>
无未同步订单>>>
2026-04-25 11:47:36 >>>当前Ram内存为618.560546875
定时检测未同步订单启用[checkOrderNum=536873564]
2026-04-25 11:47:37>>>cash write=0C
2026-04-25 11:47:37>>>cash read=3E


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


===11:51:12===
2026-04-25 11:50:10 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604251150020396199601","queue_number":66,"trade_uid":"2604251150020002173591"}]}
2026-04-25 11:50:10 >>>故障排除日志:删除未同步下发订单成功2604251150020002173591
2026-04-25 11:50:11 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536873600]


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


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


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


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


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


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


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


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


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


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


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


===12:44:19===
2026-04-25 12:43:18>>>cash read=00
2026-04-25 12:43:19>>>cash read=818F42
2026-04-25 12:43:19>>>cash write=02
2026-04-25 12:43:19 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-25 12:43:19>>>cash read=10
2026-04-25 12:43:19 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-25 12:43:19 当前产品价格10元，投币10元，打印小票中...
2026-04-25 12:43:19 >>>开始打印,排队号为82,订单号为2604251243190040519116
2026-04-25 12:43:19>>>订单2604251243190040519116写入成功,剩余空间为1679500,占用RAM为636.9365234375
删除未同步订单2604251243190040519116
2026-04-25 12:43:21>>>订单2604251243190040519116删除成功,剩余空间为1680500,占用RAM为647.9794921875
检测订单目录中>>>
无未同步订单>>>
2026-04-25 12:43:21 >>>当前Ram内存为618.673828125
定时检测未同步订单启用[checkOrderNum=536874189]
2026-04-25 12:43:22>>>cash write=0C
2026-04-25 12:43:23>>>cash read=3E
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-25 12:43:43 >>>回调事件[910,devices/D0519]
2026-04-25 12:43:43 >>>故障排除日志:上一MQTT订单号缓存列表为2604251240560077684635|2604251240560077684635
2026-04-25 12:43:43 >>>故障排除日志:终端未同步成功订单列表
2026-04-25 12:43:43 开始打印,排队:83,票券:2604251243353383964201,订单:2604251243350031855391,[2026-04-25 12:43:42微信支付10元]
2026-04-25 12:43:43>>>MQTT票号同步场景，创建空订单对象
2026-04-25 12:43:43>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-25 12:43:45 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604251243353383964201","queue_number":83,"trade_uid":"2604251243350031855391"}]}
2026-04-25 12:43:45 >>>故障排除日志:删除未同步下发订单成功2604251243350031855391
2026-04-25 12:43:45 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536874196]


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


===14:20:27===
2026-04-25 14:19:26 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604251419157709642101","queue_number":113,"trade_uid":"2604251419150075121382"}]}
2026-04-25 14:19:26 >>>故障排除日志:删除未同步下发订单成功2604251419150075121382
2026-04-25 14:19:26 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536875283]


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


===16:28:37===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-25 16:27:40 >>>回调事件[910,devices/D0519]
2026-04-25 16:27:40 >>>故障排除日志:上一MQTT订单号缓存列表为2604251622480002587863
2026-04-25 16:27:40 >>>故障排除日志:终端未同步成功订单列表
2026-04-25 16:27:40 开始打印,排队:153,票券:2604251627338252271601,订单:2604251627330080612071,[2026-04-25 16:27:39微信支付10元]
2026-04-25 16:27:40>>>MQTT票号同步场景，创建空订单对象
2026-04-25 16:27:40>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-25 16:27:42 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604251627338252271601","queue_number":153,"trade_uid":"2604251627330080612071"}]}
2026-04-25 16:27:42 >>>故障排除日志:删除未同步下发订单成功2604251627330080612071
2026-04-25 16:27:42 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536876747]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-25 16:27:46 >>>回调事件[910,devices/D0519]
2026-04-25 16:27:46 >>>故障排除日志:上一MQTT订单号缓存列表为2604251627330080612071
2026-04-25 16:27:46 >>>故障排除日志:终端未同步成功订单列表
2026-04-25 16:27:46 开始打印,排队:154,票券:2604251627395262079301,订单:2604251627390050927351,[2026-04-25 16:27:46微信支付10元]
2026-04-25 16:27:46>>>MQTT票号同步场景，创建空订单对象
2026-04-25 16:27:46>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-25 16:27:48 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604251627395262079301","queue_number":154,"trade_uid":"2604251627390050927351"}]}
2026-04-25 16:27:48 >>>故障排除日志:删除未同步下发订单成功2604251627390050927351
2026-04-25 16:27:48 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536876753]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-25 16:28:28 >>>回调事件[910,devices/D0519]
2026-04-25 16:28:28 >>>故障排除日志:上一MQTT订单号缓存列表为2604251627390050927351
2026-04-25 16:28:28 >>>故障排除日志:终端未同步成功订单列表
2026-04-25 16:28:28 开始打印,排队:155,票券:2604251628214076711801,订单:2604251628210038256618,[2026-04-25 16:28:28微信支付10元]
2026-04-25 16:28:28 开始打印,排队:156,票券:2604251628214078249202,订单:2604251628210038256618,[2026-04-25 16:28:28微信支付10元]
2026-04-25 16:28:28>>>MQTT票号同步场景，创建空订单对象
2026-04-25 16:28:28>>>合并MQTT票号列表到订单同步请求,共2张票
2026-04-25 16:28:32 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604251628214076711801","queue_number":155,"trade_uid":"2604251628210038256618"},{"ticket_no":"2604251628214078249202","queue_number":156,"trade_uid":"2604251628210038256618"}]}
2026-04-25 16:28:32 >>>故障排除日志:删除未同步下发订单成功2604251628210038256618
2026-04-25 16:28:32 >>>故障排除日志:删除未同步下发订单成功2604251628210038256618
2026-04-25 16:28:32 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536876768]


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


===16:43:38===
2026-04-25 16:42:40>>>cash read=29
2026-04-25 16:42:40 >>>回调事件130,cash_status,20029,退钞中
2026-04-25 16:42:41>>>cash read=3E
2026-04-25 16:42:42>>>cash read=29
2026-04-25 16:42:42 >>>回调事件130,cash_status,20029,退钞中
2026-04-25 16:42:43>>>cash read=2F29
2026-04-25 16:42:44>>>cash read=00
2026-04-25 16:42:44>>>cash read=818F42
2026-04-25 16:42:44>>>cash write=02
2026-04-25 16:42:44 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-25 16:42:45>>>cash read=10
2026-04-25 16:42:45 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-25 16:42:45 当前产品价格10元，投币10元，打印小票中...
2026-04-25 16:42:45 >>>开始打印,排队号为158,订单号为2604251642450040519843
2026-04-25 16:42:45>>>订单2604251642450040519843写入成功,剩余空间为1679500,占用RAM为635.4130859375
删除未同步订单2604251642450040519843
2026-04-25 16:42:47>>>订单2604251642450040519843删除成功,剩余空间为1680500,占用RAM为647.6123046875
检测订单目录中>>>
无未同步订单>>>
2026-04-25 16:42:47 >>>当前Ram内存为617.53125
定时检测未同步订单启用[checkOrderNum=536876912]
2026-04-25 16:42:48>>>cash write=0C
2026-04-25 16:42:48>>>cash read=3E


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


===16:50:38===
2026-04-25 16:49:44>>>cash read=00
2026-04-25 16:49:45>>>cash read=2F29
2026-04-25 16:49:46>>>cash read=01
2026-04-25 16:49:50>>>cash read=2F
2026-04-25 16:49:51>>>cash read=00
2026-04-25 16:49:52>>>cash read=2F29
2026-04-25 16:49:54>>>cash read=3E
2026-04-25 16:49:57>>>cash read=00
2026-04-25 16:49:58>>>cash read=292F29
2026-04-25 16:49:58 >>>回调事件130,cash_status,20029,退钞中
2026-04-25 16:49:59>>>cash read=01
2026-04-25 16:50:00>>>cash read=2F
2026-04-25 16:50:01>>>cash read=29
2026-04-25 16:50:01 >>>回调事件130,cash_status,20029,退钞中
2026-04-25 16:50:03>>>cash read=01
2026-04-25 16:50:06>>>cash read=3E
2026-04-25 16:50:10>>>cash read=00
2026-04-25 16:50:12>>>cash read=2F29
2026-04-25 16:50:13>>>cash read=012F
2026-04-25 16:50:14>>>cash read=3E


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


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


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


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


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


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


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


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


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


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


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


===17:30:41===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-25 17:29:46 >>>回调事件[910,devices/D0519]
2026-04-25 17:29:46 >>>故障排除日志:上一MQTT订单号缓存列表为2604251721110056309281
2026-04-25 17:29:46 >>>故障排除日志:终端未同步成功订单列表
2026-04-25 17:29:46 开始打印,排队:174,票券:2604251729384851895401,订单:2604251729380046460434,[2026-04-25 17:29:46微信支付10元]
2026-04-25 17:29:46 开始打印,排队:175,票券:2604251729384852319702,订单:2604251729380046460434,[2026-04-25 17:29:46微信支付10元]
2026-04-25 17:29:47>>>MQTT票号同步场景，创建空订单对象
2026-04-25 17:29:47>>>合并MQTT票号列表到订单同步请求,共2张票
2026-04-25 17:29:50 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604251729384851895401","queue_number":174,"trade_uid":"2604251729380046460434"},{"ticket_no":"2604251729384852319702","queue_number":175,"trade_uid":"2604251729380046460434"}]}
2026-04-25 17:29:50 >>>故障排除日志:删除未同步下发订单成功2604251729380046460434
2026-04-25 17:29:50 >>>故障排除日志:删除未同步下发订单成功2604251729380046460434
2026-04-25 17:29:50 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877454]
2026-04-25 17:30:13>>>cash read=2F29
2026-04-25 17:30:15>>>cash read=00
2026-04-25 17:30:15>>>cash read=818F41
2026-04-25 17:30:15>>>cash write=02
2026-04-25 17:30:16 >>>回调事件130,cash_status,10022,进钞中...read money=5
2026-04-25 17:30:16>>>cash read=10
2026-04-25 17:30:16 >>>回调事件130,5,10023,finish Money=5,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-25 17:30:17>>>cash write=0C
2026-04-25 17:30:17>>>cash read=3E
2026-04-25 17:30:26>>>cash read=00
2026-04-25 17:30:28>>>cash read=29
2026-04-25 17:30:28 >>>回调事件130,cash_status,20029,退钞中
2026-04-25 17:30:28>>>cash read=2F29
2026-04-25 17:30:29>>>cash read=3E
2026-04-25 17:30:31>>>cash read=00
2026-04-25 17:30:32>>>cash read=818F41
2026-04-25 17:30:32>>>cash write=02
2026-04-25 17:30:32 >>>回调事件130,cash_status,10022,进钞中...read money=5
2026-04-25 17:30:33>>>cash read=10
2026-04-25 17:30:33 >>>回调事件130,5,10023,finish Money=5,进钞完成
2026-04-25 17:30:33 当前产品价格10元，投币10元，打印小票中...
2026-04-25 17:30:33 >>>开始打印,排队号为176,订单号为2604251730160040519759
2026-04-25 17:30:33>>>订单2604251730160040519759写入成功,剩余空间为1677500,占用RAM为645.8505859375
删除未同步订单2604251730160040519759
2026-04-25 17:30:35>>>订单2604251730160040519759删除成功,剩余空间为1678500,占用RAM为652.6953125
检测订单目录中>>>
无未同步订单>>>
2026-04-25 17:30:35 >>>当前Ram内存为620.34375
定时检测未同步订单启用[checkOrderNum=536877475]
2026-04-25 17:30:36>>>cash write=0C
2026-04-25 17:30:36>>>cash read=3E


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


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


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


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


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


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


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


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


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


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


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


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


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


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


===18:26:45===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-25 18:26:07 >>>回调事件[910,devices/D0519]
2026-04-25 18:26:07 >>>故障排除日志:上一MQTT订单号缓存列表为2604251825180018529356
2026-04-25 18:26:07 >>>故障排除日志:终端未同步成功订单列表
2026-04-25 18:26:07 开始打印,排队:193,票券:2604251825597939565901,订单:2604251825590076457525,[2026-04-25 18:26:06微信支付10元]
2026-04-25 18:26:07>>>MQTT票号同步场景，创建空订单对象
2026-04-25 18:26:07>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-25 18:26:09 >>>回调事件[910,devices/D0519]
2026-04-25 18:26:09 >>>故障排除日志:上一MQTT订单号缓存列表为2604251825590076457525
2026-04-25 18:26:09 >>>故障排除日志:终端未同步成功订单列表01932604251825590076457525
2026-04-25 18:26:09 开始打印,排队:194,票券:2604251825577875707801,订单:2604251825570076622317,[2026-04-25 18:26:07微信支付10元]
已接收过此消息,票券号为2604251825597939565901,排队号为193
2026-04-25 18:26:09>>>HTTP请求进行中，跳过本次同步
2026-04-25 18:26:11 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604251825597939565901","queue_number":193,"trade_uid":"2604251825590076457525"}]}
2026-04-25 18:26:11 >>>故障排除日志:删除未同步下发订单成功2604251825590076457525
2026-04-25 18:26:11 >>>故障排除日志:终端同步成功后剩余订单列表01942604251825570076622317
定时检测未同步订单启用[checkOrderNum=536878110]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-25 18:26:14 >>>回调事件[910,devices/D0519]
2026-04-25 18:26:14 >>>故障排除日志:上一MQTT订单号缓存列表为2604251825570076622317|2604251825590076457525
2026-04-25 18:26:14 >>>故障排除日志:终端未同步成功订单列表01942604251825570076622317
已接收过此消息,票券号为2604251825577875707801,排队号为194
2026-04-25 18:26:14 开始打印,排队:195,票券:2604251826057115846901,订单:2604251826050067376232,[2026-04-25 18:26:14支付宝支付10元]
2026-04-25 18:26:14>>>MQTT票号同步场景，创建空订单对象
2026-04-25 18:26:14>>>合并MQTT票号列表到订单同步请求,共2张票
2026-04-25 18:26:16 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604251825577875707801","queue_number":194,"trade_uid":"2604251825570076622317"},{"ticket_no":"2604251826057115846901","queue_number":195,"trade_uid":"2604251826050067376232"}]}
2026-04-25 18:26:16 >>>故障排除日志:删除未同步下发订单成功2604251825570076622317
2026-04-25 18:26:16 >>>故障排除日志:删除未同步下发订单成功2604251826050067376232
2026-04-25 18:26:17 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878116]


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


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


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


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


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


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


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


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


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


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


===18:47:48===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-25 18:46:57 >>>回调事件[910,devices/D0519]
2026-04-25 18:46:57 >>>故障排除日志:上一MQTT订单号缓存列表为2604251846230071512864
2026-04-25 18:46:57 >>>故障排除日志:终端未同步成功订单列表
2026-04-25 18:46:57 开始打印,排队:209,票券:2604251846513320405201,订单:2604251846510031175065,[2026-04-25 18:46:57微信支付10元]
2026-04-25 18:46:57 开始打印,排队:210,票券:2604251846513320968402,订单:2604251846510031175065,[2026-04-25 18:46:57微信支付10元]
2026-04-25 18:46:57>>>MQTT票号同步场景，创建空订单对象
2026-04-25 18:46:57>>>合并MQTT票号列表到订单同步请求,共2张票
2026-04-25 18:47:00 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604251846513320405201","queue_number":209,"trade_uid":"2604251846510031175065"},{"ticket_no":"2604251846513320968402","queue_number":210,"trade_uid":"2604251846510031175065"}]}
2026-04-25 18:47:00 >>>故障排除日志:删除未同步下发订单成功2604251846510031175065
2026-04-25 18:47:00 >>>故障排除日志:删除未同步下发订单成功2604251846510031175065
2026-04-25 18:47:01 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878409]
2026-04-25 18:47:31>>>cash read=0A
2026-04-25 18:47:32>>>cash read=3E


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


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


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


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


===18:55:50===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-25 18:55:08 >>>回调事件[910,devices/D0519]
2026-04-25 18:55:08 >>>故障排除日志:上一MQTT订单号缓存列表为2604251852460071744793
2026-04-25 18:55:08 >>>故障排除日志:终端未同步成功订单列表
2026-04-25 18:55:08 开始打印,排队:215,票券:2604251855036757816201,订单:2604251855030064552992,[2026-04-25 18:55:08微信支付10元]
2026-04-25 18:55:09 开始打印,排队:216,票券:2604251855036758361202,订单:2604251855030064552992,[2026-04-25 18:55:08微信支付10元]
2026-04-25 18:55:09>>>MQTT票号同步场景，创建空订单对象
2026-04-25 18:55:09>>>合并MQTT票号列表到订单同步请求,共2张票
2026-04-25 18:55:12 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604251855036757816201","queue_number":215,"trade_uid":"2604251855030064552992"},{"ticket_no":"2604251855036758361202","queue_number":216,"trade_uid":"2604251855030064552992"}]}
2026-04-25 18:55:12 >>>故障排除日志:删除未同步下发订单成功2604251855030064552992
2026-04-25 18:55:12 >>>故障排除日志:删除未同步下发订单成功2604251855030064552992
2026-04-25 18:55:12 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878523]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-25 18:55:33 >>>回调事件[910,devices/D0519]
2026-04-25 18:55:33 >>>故障排除日志:上一MQTT订单号缓存列表为2604251855030064552992|2604251855030064552992
2026-04-25 18:55:33 >>>故障排除日志:终端未同步成功订单列表
2026-04-25 18:55:33 开始打印,排队:217,票券:2604251855256120845101,订单:2604251855250058822294,[2026-04-25 18:55:32微信支付10元]
2026-04-25 18:55:33>>>MQTT票号同步场景，创建空订单对象
2026-04-25 18:55:33>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-25 18:55:35 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604251855256120845101","queue_number":217,"trade_uid":"2604251855250058822294"}]}
2026-04-25 18:55:35 >>>故障排除日志:删除未同步下发订单成功2604251855250058822294
2026-04-25 18:55:35 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878530]


===18:59:50===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-25 18:58:57 >>>回调事件[910,devices/D0519]
2026-04-25 18:58:57 >>>故障排除日志:上一MQTT订单号缓存列表为2604251855250058822294
2026-04-25 18:58:57 >>>故障排除日志:终端未同步成功订单列表
2026-04-25 18:58:57 开始打印,排队:218,票券:2604251858503442798601,订单:2604251858500032187423,[2026-04-25 18:58:57微信支付10元]
2026-04-25 18:58:58>>>MQTT票号同步场景，创建空订单对象
2026-04-25 18:58:58>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-25 18:58:59 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604251858503442798601","queue_number":218,"trade_uid":"2604251858500032187423"}]}
2026-04-25 18:58:59 >>>故障排除日志:删除未同步下发订单成功2604251858500032187423
2026-04-25 18:59:00 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878570]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-25 18:59:12 >>>回调事件[910,devices/D0519]
2026-04-25 18:59:13 >>>故障排除日志:上一MQTT订单号缓存列表为2604251858500032187423
2026-04-25 18:59:13 >>>故障排除日志:终端未同步成功订单列表
2026-04-25 18:59:13 开始打印,排队:219,票券:2604251859079454969501,订单:2604251859070092448297,[2026-04-25 18:59:12微信支付10元]
2026-04-25 18:59:13>>>MQTT票号同步场景，创建空订单对象
2026-04-25 18:59:13>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-25 18:59:15 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604251859079454969501","queue_number":219,"trade_uid":"2604251859070092448297"}]}
2026-04-25 18:59:15 >>>故障排除日志:删除未同步下发订单成功2604251859070092448297
2026-04-25 18:59:15 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878579]
2026-04-25 18:59:28>>>cash read=00
2026-04-25 18:59:30>>>cash read=2F29
2026-04-25 18:59:31>>>cash read=01
2026-04-25 18:59:31>>>cash read=2F
2026-04-25 18:59:33>>>cash read=3E
2026-04-25 18:59:35>>>cash read=00
2026-04-25 18:59:36>>>cash read=29
2026-04-25 18:59:36 >>>回调事件130,cash_status,20029,退钞中
2026-04-25 18:59:36>>>cash read=2F29
2026-04-25 18:59:38>>>cash read=3E
2026-04-25 18:59:43>>>cash read=00
2026-04-25 18:59:44>>>cash read=29
2026-04-25 18:59:44 >>>回调事件130,cash_status,20029,退钞中
2026-04-25 18:59:45>>>cash read=2F29
2026-04-25 18:59:46>>>cash read=3E


===19:00:50===
2026-04-25 18:59:55>>>cash read=00
2026-04-25 18:59:56>>>cash read=29
2026-04-25 18:59:57 >>>回调事件130,cash_status,20029,退钞中
2026-04-25 18:59:57>>>cash read=2F29
2026-04-25 18:59:58>>>cash read=00
2026-04-25 18:59:59>>>cash read=29
2026-04-25 18:59:59 >>>回调事件130,cash_status,20029,退钞中
2026-04-25 19:00:00>>>cash read=2F29
2026-04-25 19:00:01>>>cash read=3E
2026-04-25 19:00:03>>>cash read=00
2026-04-25 19:00:05>>>cash read=29
2026-04-25 19:00:05 >>>回调事件130,cash_status,20029,退钞中
2026-04-25 19:00:05>>>cash read=2F29
2026-04-25 19:00:06>>>cash read=3E
2026-04-25 19:00:08>>>cash read=00
2026-04-25 19:00:10>>>cash read=01
2026-04-25 19:00:11>>>cash read=3E
2026-04-25 19:00:12>>>cash read=00
2026-04-25 19:00:12>>>cash read=818F42
2026-04-25 19:00:12>>>cash write=02
2026-04-25 19:00:12 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-25 19:00:13>>>cash read=10
2026-04-25 19:00:13 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-25 19:00:13 当前产品价格10元，投币10元，打印小票中...
2026-04-25 19:00:13 >>>开始打印,排队号为220,订单号为2604251900130040519794
2026-04-25 19:00:13>>>订单2604251900130040519794写入成功,剩余空间为1679000,占用RAM为638.119140625
删除未同步订单2604251900130040519794
2026-04-25 19:00:15>>>订单2604251900130040519794删除成功,剩余空间为1680000,占用RAM为646.9453125
检测订单目录中>>>
无未同步订单>>>
2026-04-25 19:00:15 >>>当前Ram内存为616.2685546875
定时检测未同步订单启用[checkOrderNum=536878597]
2026-04-25 19:00:16>>>cash write=0C
2026-04-25 19:00:16>>>cash read=3E


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


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


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


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


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


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


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


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


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


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


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


===19:29:53===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-25 19:28:53 >>>回调事件[910,devices/D0519]
2026-04-25 19:28:54 >>>故障排除日志:上一MQTT订单号缓存列表为2604251928030042404356
2026-04-25 19:28:54 >>>故障排除日志:终端未同步成功订单列表
2026-04-25 19:28:54 开始打印,排队:236,票券:2604251928475718203901,订单:2604251928470054176974,[2026-04-25 19:28:53微信支付10元]
2026-04-25 19:28:54>>>MQTT票号同步场景，创建空订单对象
2026-04-25 19:28:54>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-25 19:28:56 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604251928475718203901","queue_number":236,"trade_uid":"2604251928470054176974"}]}
2026-04-25 19:28:56 >>>故障排除日志:删除未同步下发订单成功2604251928470054176974
2026-04-25 19:28:56 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878958]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-25 19:28:59 >>>回调事件[910,devices/D0519]
2026-04-25 19:28:59 >>>故障排除日志:上一MQTT订单号缓存列表为2604251928470054176974
2026-04-25 19:28:59 >>>故障排除日志:终端未同步成功订单列表
2026-04-25 19:28:59 开始打印,排队:237,票券:2604251928538345649101,订单:2604251928530081272452,[2026-04-25 19:29:00微信支付10元]
2026-04-25 19:29:00 开始打印,排队:238,票券:2604251928538346072602,订单:2604251928530081272452,[2026-04-25 19:29:00微信支付10元]
2026-04-25 19:29:00>>>MQTT票号同步场景，创建空订单对象
2026-04-25 19:29:00>>>合并MQTT票号列表到订单同步请求,共2张票
2026-04-25 19:29:03 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604251928538345649101","queue_number":237,"trade_uid":"2604251928530081272452"},{"ticket_no":"2604251928538346072602","queue_number":238,"trade_uid":"2604251928530081272452"}]}
2026-04-25 19:29:03 >>>故障排除日志:删除未同步下发订单成功2604251928530081272452
2026-04-25 19:29:03 >>>故障排除日志:删除未同步下发订单成功2604251928530081272452
2026-04-25 19:29:03 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878970]


===19:30:53===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-25 19:30:11 >>>回调事件[910,devices/D0519]
2026-04-25 19:30:11 >>>故障排除日志:上一MQTT订单号缓存列表为2604251928530081272452|2604251928530081272452
2026-04-25 19:30:11 >>>故障排除日志:终端未同步成功订单列表
2026-04-25 19:30:11 开始打印,排队:239,票券:2604251930050513601301,订单:2604251930050003067251,[2026-04-25 19:30:11支付宝支付10元]
2026-04-25 19:30:11>>>MQTT票号同步场景，创建空订单对象
2026-04-25 19:30:11>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-25 19:30:13 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604251930050513601301","queue_number":239,"trade_uid":"2604251930050003067251"}]}
2026-04-25 19:30:13 >>>故障排除日志:删除未同步下发订单成功2604251930050003067251
2026-04-25 19:30:14 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878988]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-25 19:30:30 >>>回调事件[910,devices/D0519]
2026-04-25 19:30:30 >>>故障排除日志:上一MQTT订单号缓存列表为2604251930050003067251
2026-04-25 19:30:30 >>>故障排除日志:终端未同步成功订单列表
2026-04-25 19:30:30 开始打印,排队:240,票券:2604251930244516931901,订单:2604251930240042466258,[2026-04-25 19:30:30微信支付10元]
2026-04-25 19:30:30>>>MQTT票号同步场景，创建空订单对象
2026-04-25 19:30:30>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-25 19:30:32 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604251930244516931901","queue_number":240,"trade_uid":"2604251930240042466258"}]}
2026-04-25 19:30:32 >>>故障排除日志:删除未同步下发订单成功2604251930240042466258
2026-04-25 19:30:32 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878995]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-25 19:30:39 >>>回调事件[910,devices/D0519]
2026-04-25 19:30:39 >>>故障排除日志:上一MQTT订单号缓存列表为2604251930240042466258
2026-04-25 19:30:39 >>>故障排除日志:终端未同步成功订单列表
2026-04-25 19:30:39 开始打印,排队:241,票券:2604251930329245461901,订单:2604251930320090251557,[2026-04-25 19:30:39微信支付10元]
2026-04-25 19:30:39>>>MQTT票号同步场景，创建空订单对象
2026-04-25 19:30:39>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-25 19:30:41 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604251930329245461901","queue_number":241,"trade_uid":"2604251930320090251557"}]}
2026-04-25 19:30:41 >>>故障排除日志:删除未同步下发订单成功2604251930320090251557
2026-04-25 19:30:41 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536879001]


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


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


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


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


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


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


===19:49:59===
2026-04-25 19:48:58 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604251948446904322901","queue_number":251,"trade_uid":"2604251948440066911873"}]}
2026-04-25 19:48:58 >>>故障排除日志:删除未同步下发订单成功2604251948440066911873
2026-04-25 19:48:58 >>>故障排除日志:终端同步成功后剩余订单列表02522604251948410054569056
定时检测未同步订单启用[checkOrderNum=536879237]


===19:50:59===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-25 19:50:36 >>>回调事件[910,devices/D0519]
2026-04-25 19:50:36 >>>故障排除日志:上一MQTT订单号缓存列表为2604251948410054569056|2604251948440066911873
2026-04-25 19:50:36 >>>故障排除日志:终端未同步成功订单列表02522604251948410054569056
已接收过此消息,票券号为2604251948415663889601,排队号为252
2026-04-25 19:50:36 开始打印,排队:253,票券:2604251950312279635301,订单:2604251950310020765312,[2026-04-25 19:50:36支付宝支付10元]
2026-04-25 19:50:36>>>MQTT票号同步场景，创建空订单对象
2026-04-25 19:50:36>>>合并MQTT票号列表到订单同步请求,共2张票
2026-04-25 19:50:38 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604251948415663889601","queue_number":252,"trade_uid":"2604251948410054569056"},{"ticket_no":"2604251950312279635301","queue_number":253,"trade_uid":"2604251950310020765312"}]}
2026-04-25 19:50:38 >>>故障排除日志:删除未同步下发订单成功2604251948410054569056
2026-04-25 19:50:38 >>>故障排除日志:删除未同步下发订单成功2604251950310020765312
2026-04-25 19:50:38 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536879257]


===19:56:00===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-25 19:55:06 >>>回调事件[910,devices/D0519]
2026-04-25 19:55:06 >>>故障排除日志:上一MQTT订单号缓存列表为2604251948410054569056|2604251950310020765312
2026-04-25 19:55:06 >>>故障排除日志:终端未同步成功订单列表
2026-04-25 19:55:06 开始打印,排队:254,票券:2604251954588686269301,订单:2604251954580084664421,[2026-04-25 19:55:06微信支付10元]
2026-04-25 19:55:06>>>MQTT票号同步场景，创建空订单对象
2026-04-25 19:55:06>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-25 19:55:08 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604251954588686269301","queue_number":254,"trade_uid":"2604251954580084664421"}]}
2026-04-25 19:55:08 >>>故障排除日志:删除未同步下发订单成功2604251954580084664421
2026-04-25 19:55:08 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536879309]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-25 19:55:09 >>>回调事件[910,devices/D0519]
2026-04-25 19:55:09 >>>故障排除日志:上一MQTT订单号缓存列表为2604251954580084664421
2026-04-25 19:55:09 >>>故障排除日志:终端未同步成功订单列表
2026-04-25 19:55:09 开始打印,排队:255,票券:2604251955040025918501,订单:2604251955030098300054,[2026-04-25 19:55:08支付宝支付10元]
2026-04-25 19:55:09 开始打印,排队:256,票券:2604251955040026472602,订单:2604251955030098300054,[2026-04-25 19:55:08支付宝支付10元]
2026-04-25 19:55:09>>>MQTT票号同步场景，创建空订单对象
2026-04-25 19:55:09>>>合并MQTT票号列表到订单同步请求,共2张票
2026-04-25 19:55:12 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604251955040025918501","queue_number":255,"trade_uid":"2604251955030098300054"},{"ticket_no":"2604251955040026472602","queue_number":256,"trade_uid":"2604251955030098300054"}]}
2026-04-25 19:55:12 >>>故障排除日志:删除未同步下发订单成功2604251955030098300054
2026-04-25 19:55:12 >>>故障排除日志:删除未同步下发订单成功2604251955030098300054
2026-04-25 19:55:13 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536879315]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-25 19:55:54 >>>回调事件[910,devices/D0519]
2026-04-25 19:55:54 >>>故障排除日志:上一MQTT订单号缓存列表为2604251955030098300054|2604251955030098300054
2026-04-25 19:55:54 >>>故障排除日志:终端未同步成功订单列表
2026-04-25 19:55:54 开始打印,排队:257,票券:2604251955472875836401,订单:2604251955470026385665,[2026-04-25 19:55:53微信支付10元]
2026-04-25 19:55:54>>>MQTT票号同步场景，创建空订单对象
2026-04-25 19:55:54>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-25 19:55:56 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604251955472875836401","queue_number":257,"trade_uid":"2604251955470026385665"}]}
2026-04-25 19:55:56 >>>故障排除日志:删除未同步下发订单成功2604251955470026385665
2026-04-25 19:55:56 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536879322]


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


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


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


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


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


===20:09:02===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-25 20:08:03 >>>回调事件[910,devices/D0519]
2026-04-25 20:08:03 >>>故障排除日志:上一MQTT订单号缓存列表为2604252005510016859589
2026-04-25 20:08:03 >>>故障排除日志:终端未同步成功订单列表
2026-04-25 20:08:03 开始打印,排队:266,票券:2604252007579657643601,订单:2604252007570094431419,[2026-04-25 20:08:03微信支付10元]
2026-04-25 20:08:03>>>MQTT票号同步场景，创建空订单对象
2026-04-25 20:08:03>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-25 20:08:05 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604252007579657643601","queue_number":266,"trade_uid":"2604252007570094431419"}]}
2026-04-25 20:08:05 >>>故障排除日志:删除未同步下发订单成功2604252007570094431419
2026-04-25 20:08:05 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536879503]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-25 20:08:15 >>>回调事件[910,devices/D0519]
2026-04-25 20:08:15 >>>故障排除日志:上一MQTT订单号缓存列表为2604252007570094431419
2026-04-25 20:08:15 >>>故障排除日志:终端未同步成功订单列表
2026-04-25 20:08:15 开始打印,排队:267,票券:2604252008099688463701,订单:2604252008090094588935,[2026-04-25 20:08:15微信支付10元]
2026-04-25 20:08:15>>>MQTT票号同步场景，创建空订单对象
2026-04-25 20:08:15>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-25 20:08:17 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604252008099688463701","queue_number":267,"trade_uid":"2604252008090094588935"}]}
2026-04-25 20:08:17 >>>故障排除日志:删除未同步下发订单成功2604252008090094588935
2026-04-25 20:08:17 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536879510]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-25 20:08:51 >>>回调事件[910,devices/D0519]
2026-04-25 20:08:51 >>>故障排除日志:上一MQTT订单号缓存列表为2604252008090094588935
2026-04-25 20:08:51 >>>故障排除日志:终端未同步成功订单列表
2026-04-25 20:08:51 开始打印,排队:268,票券:2604252008420678959401,订单:2604252008420004529221,[2026-04-25 20:08:50微信支付10元]
2026-04-25 20:08:51>>>MQTT票号同步场景，创建空订单对象
2026-04-25 20:08:51>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-25 20:08:53 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604252008420678959401","queue_number":268,"trade_uid":"2604252008420004529221"}]}
2026-04-25 20:08:53 >>>故障排除日志:删除未同步下发订单成功2604252008420004529221
2026-04-25 20:08:53 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536879517]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-25 20:08:56 >>>回调事件[910,devices/D0519]
2026-04-25 20:08:56 >>>故障排除日志:上一MQTT订单号缓存列表为2604252008420004529221
2026-04-25 20:08:56 >>>故障排除日志:终端未同步成功订单列表
2026-04-25 20:08:56 开始打印,排队:269,票券:2604252008496656663201,订单:2604252008490064604396,[2026-04-25 20:08:56微信支付10元]
2026-04-25 20:08:56>>>MQTT票号同步场景，创建空订单对象
2026-04-25 20:08:56>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-25 20:08:58 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604252008496656663201","queue_number":269,"trade_uid":"2604252008490064604396"}]}
2026-04-25 20:08:58 >>>故障排除日志:删除未同步下发订单成功2604252008490064604396
2026-04-25 20:08:58 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536879528]


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


===21:02:06===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-25 21:01:23 >>>回调事件[910,devices/D0519]
2026-04-25 21:01:23 >>>故障排除日志:上一MQTT订单号缓存列表为2604252057210071091127
2026-04-25 21:01:23 >>>故障排除日志:终端未同步成功订单列表
2026-04-25 21:01:23 开始打印,排队:290,票券:2604252101149873844301,订单:2604252101140095528453,[2026-04-25 21:01:23微信支付10元]
2026-04-25 21:01:23>>>MQTT票号同步场景，创建空订单对象
2026-04-25 21:01:23>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-25 21:01:25 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604252101149873844301","queue_number":290,"trade_uid":"2604252101140095528453"}]}
2026-04-25 21:01:25 >>>故障排除日志:删除未同步下发订单成功2604252101140095528453
2026-04-25 21:01:25 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536880146]
2026-04-25 21:01:29>>>cash read=00
2026-04-25 21:01:30>>>cash read=818F42
2026-04-25 21:01:30>>>cash write=02
2026-04-25 21:01:31 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-25 21:01:31>>>cash read=10
2026-04-25 21:01:31 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-25 21:01:31 当前产品价格10元，投币10元，打印小票中...
2026-04-25 21:01:31 >>>开始打印,排队号为291,订单号为2604252101310040519484
2026-04-25 21:01:31>>>订单2604252101310040519484写入成功,剩余空间为1678500,占用RAM为638.373046875
删除未同步订单2604252101310040519484
2026-04-25 21:01:33>>>订单2604252101310040519484删除成功,剩余空间为1679500,占用RAM为648.1923828125
检测订单目录中>>>
无未同步订单>>>
2026-04-25 21:01:33 >>>当前Ram内存为617.3720703125
定时检测未同步订单启用[checkOrderNum=536880154]
2026-04-25 21:01:35>>>cash write=0C
2026-04-25 21:01:35>>>cash read=3E
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-25 21:01:47 >>>回调事件[910,devices/D0519]
2026-04-25 21:01:47 >>>故障排除日志:上一MQTT订单号缓存列表为2604252101140095528453
2026-04-25 21:01:47 >>>故障排除日志:终端未同步成功订单列表
2026-04-25 21:01:47 开始打印,排队:292,票券:2604252101435946379701,订单:2604252101430057452758,[2026-04-25 21:01:47支付宝支付10元]
2026-04-25 21:01:47>>>MQTT票号同步场景，创建空订单对象
2026-04-25 21:01:47>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-25 21:01:49 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604252101435946379701","queue_number":292,"trade_uid":"2604252101430057452758"}]}
2026-04-25 21:01:49 >>>故障排除日志:删除未同步下发订单成功2604252101430057452758
2026-04-25 21:01:49 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536880160]


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


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


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


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


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


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


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


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


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


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


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


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


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


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