TLClient_JSSCOM_LuatOS-Air_V4010_RDA8910_RFTTS_0xe0000,2.8.6,869701072495867,28464262078471,
poweron reason:0

===07:56:41===
上一时间戳为1777075367
隔日重置时间戳true
隔日清空未同步下发列表true
当前排队号为1,音量为5
初始化产品信息:[{"time_limit_date":"","ticket_category":"0","expiry_date":1,"product_detail":"","time_limit_status":"0","begin_minute":"00","product_uid":"16746837930005455541","use_timer":1,"old_price":"10","end_hour":"23","sale_price":"10","end_minute":"59","begin_hour":"00","sale_status":1,"product_name":"男女快剪"}]
打印门店标题设置为十元快剪技术精湛
打印门店凭条广告设置为请按排队号顺序理发
是否打印二维码设置为1
是否打印紧凑设置为3
当前号显示模式设置为1
当前卡项核销权限设置为0
session_id:18719****9318e
纸币器设置接收纸币范围为36
欢迎使用天羚自助售票系统[2.8.6]
定时检测未同步订单启用[checkOrderNum=536870977]
2026-04-26 07:55:41>>>cash write=30
2026-04-26 07:55:41>>>cash write=02
2026-04-26 07:55:41>>>cash write=3E
2026-04-26 07:55:41>>>cash read=808F808F808F
系统时间初始化成功，时间为202642675541
2026-04-26 07:55:42>>>cash write=02
2026-04-26 07:55:42 >>>剩余flash空间=1680000,占用RAM为652.3974609375
2026-04-26 07:55:42 >>>回调事件:910,subscribe,10000,连接服务器成功

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

2026-04-26 07:55:45>>>cash write=0C
2026-04-26 07:55:45>>>cash read=3E
流量卡还有64天过期
2026-04-26 07:55:51 >>>当前Ram内存为637.0283203125
2026-04-26 07:56:34>>>cash read=00
2026-04-26 07:56:35>>>cash read=818F42
2026-04-26 07:56:35>>>cash write=02
2026-04-26 07:56:35 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 07:56:35>>>cash read=10
2026-04-26 07:56:35 >>>回调事件130,10,10023,finish Money=10,进钞完成
当日首次设置时间戳true为1777161395
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 07:56:36 当前产品价格10元，投币10元，打印小票中...
2026-04-26 07:56:36 >>>开始打印,排队号为1,订单号为2604260756360030509458
2026-04-26 07:56:36>>>订单2604260756360030509458写入成功,剩余空间为1678000,占用RAM为644.8251953125
删除未同步订单2604260756360030509458
2026-04-26 07:56:38>>>订单2604260756360030509458删除成功,剩余空间为1679000,占用RAM为647.55078125
检测订单目录中>>>
无未同步订单>>>
2026-04-26 07:56:38 >>>当前Ram内存为617.1982421875
定时检测未同步订单启用[checkOrderNum=536871002]
2026-04-26 07:56:39>>>cash write=0C
2026-04-26 07:56:39>>>cash read=3E


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


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


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


===08:08:42===
2026-04-26 08:07:42>>>cash write=0C
2026-04-26 08:07:42>>>cash read=3E


===08:11:42===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 08:10:45 >>>回调事件[910,devices/A0509]
2026-04-26 08:10:45 >>>故障排除日志:上一MQTT订单号缓存列表为2604260803450062964359
2026-04-26 08:10:45 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 08:10:45 开始打印,排队:5,票券:2604260810384863616401,订单:2604260810380046755116,[2026-04-26 08:10:44支付宝支付10元]
2026-04-26 08:10:45>>>MQTT票号同步场景，创建空订单对象
2026-04-26 08:10:45>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 08:10:47 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604260810384863616401","queue_number":5,"trade_uid":"2604260810380046755116"}]}
2026-04-26 08:10:47 >>>故障排除日志:删除未同步下发订单成功2604260810380046755116
2026-04-26 08:10:47 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536871165]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 08:11:01 >>>回调事件[910,devices/A0509]
2026-04-26 08:11:01 >>>故障排除日志:上一MQTT订单号缓存列表为2604260810380046755116
2026-04-26 08:11:01 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 08:11:01 开始打印,排队:6,票券:2604260810544490315701,订单:2604260810540042997674,[2026-04-26 08:11:00支付宝支付10元]
2026-04-26 08:11:01>>>MQTT票号同步场景，创建空订单对象
2026-04-26 08:11:01>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 08:11:03 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604260810544490315701","queue_number":6,"trade_uid":"2604260810540042997674"}]}
2026-04-26 08:11:03 >>>故障排除日志:删除未同步下发订单成功2604260810540042997674
2026-04-26 08:11:03 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536871173]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 08:11:20 >>>回调事件[910,devices/A0509]
2026-04-26 08:11:20 >>>故障排除日志:上一MQTT订单号缓存列表为2604260810540042997674
2026-04-26 08:11:20 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 08:11:20 开始打印,排队:7,票券:2604260811123303765801,订单:2604260811120031297167,[2026-04-26 08:11:19微信支付10元]
2026-04-26 08:11:20>>>MQTT票号同步场景，创建空订单对象
2026-04-26 08:11:20>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 08:11:22 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604260811123303765801","queue_number":7,"trade_uid":"2604260811120031297167"}]}
2026-04-26 08:11:22 >>>故障排除日志:删除未同步下发订单成功2604260811120031297167
2026-04-26 08:11:22 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536871180]


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


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


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


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


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


===08:29:45===
2026-04-26 08:29:02>>>cash read=00
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 08:29:02 >>>回调事件[910,devices/A0509]
2026-04-26 08:29:03 >>>故障排除日志:上一MQTT订单号缓存列表为2604260821280018193369
2026-04-26 08:29:03 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 08:29:03 开始打印,排队:15,票券:2604260828531174701701,订单:2604260828530009695643,[2026-04-26 08:29:01支付宝支付10元]
2026-04-26 08:29:03>>>MQTT票号同步场景，创建空订单对象
2026-04-26 08:29:03>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 08:29:04>>>cash read=818F42
2026-04-26 08:29:04>>>cash write=02
2026-04-26 08:29:04 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 08:29:05 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604260828531174701701","queue_number":15,"trade_uid":"2604260828530009695643"}]}
2026-04-26 08:29:05 >>>故障排除日志:删除未同步下发订单成功2604260828530009695643
2026-04-26 08:29:05 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536871396]
2026-04-26 08:29:05>>>cash read=10
2026-04-26 08:29:05 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 08:29:05 当前产品价格10元，投币10元，打印小票中...
2026-04-26 08:29:05 >>>开始打印,排队号为16,订单号为2604260829050030509829
2026-04-26 08:29:05>>>订单2604260829050030509829写入成功,剩余空间为1678500,占用RAM为640.67578125
删除未同步订单2604260829050030509829
2026-04-26 08:29:08>>>订单2604260829050030509829删除成功,剩余空间为1679500,占用RAM为650.556640625
检测订单目录中>>>
无未同步订单>>>
2026-04-26 08:29:08 >>>当前Ram内存为621.1484375
定时检测未同步订单启用[checkOrderNum=536871403]
2026-04-26 08:29:09>>>cash write=0C
2026-04-26 08:29:09>>>cash read=3E
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 08:29:42 >>>回调事件[910,devices/A0509]
2026-04-26 08:29:42 >>>故障排除日志:上一MQTT订单号缓存列表为2604260828530009695643
2026-04-26 08:29:42 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 08:29:42 开始打印,排队:17,票券:2604260829321643765701,订单:2604260829320014633286,[2026-04-26 08:29:41微信支付10元]
2026-04-26 08:29:42>>>MQTT票号同步场景，创建空订单对象
2026-04-26 08:29:42>>>合并MQTT票号列表到订单同步请求,共1张票


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


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


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


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


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


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


===08:52:47===
2026-04-26 08:51:46 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604260851344339041901","queue_number":23,"trade_uid":"2604260851340041581179"}]}
2026-04-26 08:51:46 >>>故障排除日志:删除未同步下发订单成功2604260851340041581179
2026-04-26 08:51:47 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536871666]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 08:52:42 收到下发指令:排队号1>>>
2026-04-26 08:52:42 收到下发指令:叫号1>>>


===08:53:47===
2026-04-26 08:52:48 收到下发指令:排队号1>>>
2026-04-26 08:52:48 收到下发指令:叫号1>>>
2026-04-26 08:52:52 收到下发指令:排队号1>>>
2026-04-26 08:52:52 收到下发指令:叫号1>>>
2026-04-26 08:52:56 收到下发指令:排队号1>>>
2026-04-26 08:52:56 收到下发指令:叫号1>>>
2026-04-26 08:53:00 收到下发指令:排队号1>>>
2026-04-26 08:53:00 收到下发指令:叫号1>>>
2026-04-26 08:53:01 >>>回调事件[910,devices/A0509]
2026-04-26 08:53:01 >>>故障排除日志:上一MQTT订单号缓存列表为2604260851340041581179
2026-04-26 08:53:01 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 08:53:01 开始打印,排队:24,票券:2604260852565154447901,订单:2604260852560049772682,[2026-04-26 08:53:00微信支付10元]
2026-04-26 08:53:01 开始打印,排队:25,票券:2604260852565155213702,订单:2604260852560049772682,[2026-04-26 08:53:00微信支付10元]
2026-04-26 08:53:01>>>MQTT票号同步场景，创建空订单对象
2026-04-26 08:53:01>>>合并MQTT票号列表到订单同步请求,共2张票
2026-04-26 08:53:04 收到下发指令:排队号0>>>
2026-04-26 08:53:05 收到下发指令:叫号0>>>
2026-04-26 08:53:06 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604260852565154447901","queue_number":24,"trade_uid":"2604260852560049772682"},{"ticket_no":"2604260852565155213702","queue_number":25,"trade_uid":"2604260852560049772682"}]}
2026-04-26 08:53:06 >>>故障排除日志:删除未同步下发订单成功2604260852560049772682
2026-04-26 08:53:06 >>>故障排除日志:删除未同步下发订单成功2604260852560049772682
2026-04-26 08:53:06 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536871696]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 08:53:07 收到下发指令:排队号1>>>
2026-04-26 08:53:07 收到下发指令:叫号1>>>


===08:54:48===
2026-04-26 08:54:45 >>>回调事件[910,devices/A0509]
2026-04-26 08:54:45 >>>故障排除日志:上一MQTT订单号缓存列表为2604260852560049772682|2604260852560049772682
2026-04-26 08:54:45 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 08:54:46 开始打印,排队:26,票券:2604260854394555631701,订单:2604260854390043681649,[2026-04-26 08:54:44微信支付10元]
2026-04-26 08:54:46>>>MQTT票号同步场景，创建空订单对象
2026-04-26 08:54:46>>>合并MQTT票号列表到订单同步请求,共1张票


===08:55:48===
2026-04-26 08:54:47 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604260854394555631701","queue_number":26,"trade_uid":"2604260854390043681649"}]}
2026-04-26 08:54:47 >>>故障排除日志:删除未同步下发订单成功2604260854390043681649
2026-04-26 08:54:48 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536871726]


===08:57:50===
2026-04-26 08:56:52>>>cash read=29
2026-04-26 08:56:52 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 08:56:52>>>cash read=2F29
2026-04-26 08:56:54>>>cash read=3E
2026-04-26 08:56:56>>>cash read=00
2026-04-26 08:56:57>>>cash read=818F42
2026-04-26 08:56:57>>>cash write=02
2026-04-26 08:56:57 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 08:56:58>>>cash read=10
2026-04-26 08:56:58 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 08:56:58 当前产品价格10元，投币10元，打印小票中...
2026-04-26 08:56:58 >>>开始打印,排队号为27,订单号为2604260856580030509624
2026-04-26 08:56:58>>>订单2604260856580030509624写入成功,剩余空间为1679500,占用RAM为635.86328125
删除未同步订单2604260856580030509624
2026-04-26 08:57:00>>>订单2604260856580030509624删除成功,剩余空间为1680500,占用RAM为647.263671875
检测订单目录中>>>
无未同步订单>>>
2026-04-26 08:57:00 >>>当前Ram内存为617.634765625
定时检测未同步订单启用[checkOrderNum=536871754]
2026-04-26 08:57:01>>>cash write=0C
2026-04-26 08:57:01>>>cash read=3E
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 08:57:47 >>>回调事件[910,devices/A0509]
2026-04-26 08:57:47 >>>故障排除日志:上一MQTT订单号缓存列表为2604260854390043681649
2026-04-26 08:57:47 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 08:57:47 开始打印,排队:28,票券:2604260857423014443601,订单:2604260857420028222095,[2026-04-26 08:57:46支付宝支付10元]
2026-04-26 08:57:47>>>MQTT票号同步场景，创建空订单对象
2026-04-26 08:57:47>>>合并MQTT票号列表到订单同步请求,共1张票


===08:58:50===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 08:58:13 >>>回调事件[910,devices/A0509]
2026-04-26 08:58:13 >>>故障排除日志:上一MQTT订单号缓存列表为2604260857420028222095
2026-04-26 08:58:13 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 08:58:13 开始打印,排队:29,票券:2604260858081024769701,订单:2604260858080008483656,[2026-04-26 08:58:12支付宝支付10元]
2026-04-26 08:58:13>>>MQTT票号同步场景，创建空订单对象
2026-04-26 08:58:13>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 08:58:15 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604260858081024769701","queue_number":29,"trade_uid":"2604260858080008483656"}]}
2026-04-26 08:58:15 >>>故障排除日志:删除未同步下发订单成功2604260858080008483656
2026-04-26 08:58:15 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536871779]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 08:58:30 >>>回调事件[910,devices/A0509]
2026-04-26 08:58:30 >>>故障排除日志:上一MQTT订单号缓存列表为2604260858080008483656
2026-04-26 08:58:30 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 08:58:30 开始打印,排队:30,票券:2604260858229453089401,订单:2604260858220092677817,[2026-04-26 08:58:29支付宝支付10元]
2026-04-26 08:58:30>>>MQTT票号同步场景，创建空订单对象
2026-04-26 08:58:30>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 08:58:32 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604260858229453089401","queue_number":30,"trade_uid":"2604260858220092677817"}]}
2026-04-26 08:58:32 >>>故障排除日志:删除未同步下发订单成功2604260858220092677817
2026-04-26 08:58:32 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536871786]
2026-04-26 08:58:35>>>cash read=00
2026-04-26 08:58:36>>>cash read=818F42
2026-04-26 08:58:36>>>cash write=02
2026-04-26 08:58:36 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 08:58:37>>>cash read=10
2026-04-26 08:58:37 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 08:58:37 当前产品价格10元，投币10元，打印小票中...
2026-04-26 08:58:37 >>>开始打印,排队号为31,订单号为2604260858370030509402
2026-04-26 08:58:37>>>订单2604260858370030509402写入成功,剩余空间为1677500,占用RAM为649.6630859375
删除未同步订单2604260858370030509402
2026-04-26 08:58:39>>>订单2604260858370030509402删除成功,剩余空间为1678500,占用RAM为653.6044921875
检测订单目录中>>>
无未同步订单>>>
2026-04-26 08:58:39 >>>当前Ram内存为620.2275390625
定时检测未同步订单启用[checkOrderNum=536871798]
2026-04-26 08:58:40>>>cash write=0C
2026-04-26 08:58:40>>>cash read=3E


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


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


===09:03:51===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 09:03:05 >>>回调事件[910,devices/A0509]
2026-04-26 09:03:05 >>>故障排除日志:上一MQTT订单号缓存列表为2604260900300047204617
2026-04-26 09:03:05 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 09:03:05 开始打印,排队:34,票券:2604260902536212512701,订单:2604260902530060230973,[2026-04-26 09:03:04微信支付10元]
2026-04-26 09:03:05>>>MQTT票号同步场景，创建空订单对象
2026-04-26 09:03:05>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 09:03:07 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604260902536212512701","queue_number":34,"trade_uid":"2604260902530060230973"}]}
2026-04-26 09:03:07 >>>故障排除日志:删除未同步下发订单成功2604260902530060230973
2026-04-26 09:03:07 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536871862]
2026-04-26 09:03:11>>>cash read=00
2026-04-26 09:03:13>>>cash read=818F42
2026-04-26 09:03:13>>>cash write=02
2026-04-26 09:03:13 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 09:03:13>>>cash read=10
2026-04-26 09:03:13 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 09:03:13 当前产品价格10元，投币10元，打印小票中...
2026-04-26 09:03:13 >>>开始打印,排队号为35,订单号为2604260903130030509299
2026-04-26 09:03:14>>>订单2604260903130030509299写入成功,剩余空间为1678500,占用RAM为639.1435546875
删除未同步订单2604260903130030509299
2026-04-26 09:03:16>>>订单2604260903130030509299删除成功,剩余空间为1679500,占用RAM为649.4150390625
检测订单目录中>>>
无未同步订单>>>
2026-04-26 09:03:16 >>>当前Ram内存为618.646484375
定时检测未同步订单启用[checkOrderNum=536871869]
2026-04-26 09:03:17>>>cash write=0C
2026-04-26 09:03:17>>>cash read=3E


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


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


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


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


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


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


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


===09:18:53===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 09:18:20 收到下发指令:排队号2>>>
2026-04-26 09:18:20 收到下发指令:叫号2>>>
2026-04-26 09:18:21 收到下发指令:排队号3>>>
2026-04-26 09:18:21 收到下发指令:叫号3>>>
2026-04-26 09:18:21 收到下发指令:排队号4>>>
2026-04-26 09:18:22 收到下发指令:叫号4>>>
2026-04-26 09:18:22 收到下发指令:排队号5>>>
2026-04-26 09:18:23 收到下发指令:叫号5>>>
2026-04-26 09:18:23 收到下发指令:排队号6>>>
2026-04-26 09:18:23 收到下发指令:叫号6>>>
2026-04-26 09:18:24 收到下发指令:排队号7>>>
2026-04-26 09:18:24 收到下发指令:叫号7>>>
2026-04-26 09:18:25 收到下发指令:排队号0>>>
2026-04-26 09:18:25 收到下发指令:叫号0>>>
2026-04-26 09:18:26 >>>回调事件[910,devices/A0509]
2026-04-26 09:18:26 >>>故障排除日志:上一MQTT订单号缓存列表为2604260911190006128336
2026-04-26 09:18:26 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 09:18:27 开始打印,排队:44,票券:2604260918164899071601,订单:2604260918160047063193,[2026-04-26 09:18:24微信支付10元]
2026-04-26 09:18:27>>>MQTT票号同步场景，创建空订单对象
2026-04-26 09:18:27>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 09:18:28 收到下发指令:排队号0>>>
2026-04-26 09:18:28 收到下发指令:叫号0>>>
2026-04-26 09:18:29 收到下发指令:排队号0>>>
2026-04-26 09:18:30 收到下发指令:叫号0>>>
2026-04-26 09:18:30 收到下发指令:排队号0>>>
2026-04-26 09:18:30 收到下发指令:叫号0>>>
2026-04-26 09:18:31 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604260918164899071601","queue_number":44,"trade_uid":"2604260918160047063193"}]}
2026-04-26 09:18:31 >>>故障排除日志:删除未同步下发订单成功2604260918160047063193
2026-04-26 09:18:31 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536872077]


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


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


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


===09:25:54===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 09:25:05 收到下发指令:排队号13>>>
2026-04-26 09:25:05 收到下发指令:叫号13>>>
2026-04-26 09:25:08 收到下发指令:排队号13>>>
2026-04-26 09:25:08 收到下发指令:叫号13>>>
2026-04-26 09:25:12 收到下发指令:排队号13>>>
2026-04-26 09:25:12 收到下发指令:叫号13>>>
2026-04-26 09:25:15 收到下发指令:排队号13>>>
2026-04-26 09:25:15 收到下发指令:叫号13>>>
2026-04-26 09:25:19 收到下发指令:排队号13>>>
2026-04-26 09:25:19 收到下发指令:叫号13>>>
2026-04-26 09:25:22 收到下发指令:排队号13>>>
2026-04-26 09:25:22 收到下发指令:叫号13>>>
2026-04-26 09:25:26 收到下发指令:排队号13>>>
2026-04-26 09:25:26 收到下发指令:叫号13>>>
2026-04-26 09:25:30 收到下发指令:排队号13>>>
2026-04-26 09:25:30 收到下发指令:叫号13>>>
2026-04-26 09:25:35 收到下发指令:排队号13>>>
2026-04-26 09:25:35 收到下发指令:叫号13>>>
2026-04-26 09:25:39 收到下发指令:排队号13>>>
2026-04-26 09:25:39 收到下发指令:叫号13>>>
2026-04-26 09:25:42 收到下发指令:排队号13>>>
2026-04-26 09:25:42 收到下发指令:叫号13>>>


===09:26:55===
2026-04-26 09:26:12 收到下发指令:排队号13>>>
2026-04-26 09:26:12 收到下发指令:叫号13>>>
2026-04-26 09:26:24 >>>回调事件[910,devices/A0509]
2026-04-26 09:26:24 >>>故障排除日志:上一MQTT订单号缓存列表为2604260921070080213635
2026-04-26 09:26:24 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 09:26:24 开始打印,排队:48,票券:2604260926167871466501,订单:2604260926160076676764,[2026-04-26 09:26:22支付宝支付10元]
2026-04-26 09:26:24>>>MQTT票号同步场景，创建空订单对象
2026-04-26 09:26:24>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 09:26:26 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604260926167871466501","queue_number":48,"trade_uid":"2604260926160076676764"}]}
2026-04-26 09:26:26 >>>故障排除日志:删除未同步下发订单成功2604260926160076676764
2026-04-26 09:26:26 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536872207]


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


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


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


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


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


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


===09:36:56===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 09:36:11 >>>回调事件[910,devices/A0509]
2026-04-26 09:36:11 >>>故障排除日志:上一MQTT订单号缓存列表为2604260933450002013393
2026-04-26 09:36:11 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 09:36:11 开始打印,排队:57,票券:2604260935513594801401,订单:2604260935510034066297,[2026-04-26 09:36:09微信支付10元]
2026-04-26 09:36:11>>>MQTT票号同步场景，创建空订单对象
2026-04-26 09:36:11>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 09:36:13 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604260935513594801401","queue_number":57,"trade_uid":"2604260935510034066297"}]}
2026-04-26 09:36:13 >>>故障排除日志:删除未同步下发订单成功2604260935510034066297
2026-04-26 09:36:13 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536872359]
2026-04-26 09:36:30>>>cash read=29
2026-04-26 09:36:30 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 09:36:31>>>cash read=3E
2026-04-26 09:36:33>>>cash read=00
2026-04-26 09:36:34>>>cash read=818F42
2026-04-26 09:36:34>>>cash write=02
2026-04-26 09:36:34 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 09:36:35>>>cash read=10
2026-04-26 09:36:35 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 09:36:35 当前产品价格10元，投币10元，打印小票中...
2026-04-26 09:36:35 >>>开始打印,排队号为58,订单号为2604260936350030509848
2026-04-26 09:36:35>>>订单2604260936350030509848写入成功,剩余空间为1678500,占用RAM为641.689453125
2026-04-26 09:36:37 >>>回调事件[910,devices/A0509]
2026-04-26 09:36:37 >>>故障排除日志:上一MQTT订单号缓存列表为2604260935510034066297
2026-04-26 09:36:37 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 09:36:37 开始打印,排队:59,票券:2604260936299502963801,订单:2604260936290093132398,[2026-04-26 09:36:35微信支付10元]
2026-04-26 09:36:37>>>HTTP请求进行中，跳过本次同步
删除未同步订单2604260936350030509848
2026-04-26 09:36:39>>>订单2604260936350030509848删除成功,剩余空间为1679000,占用RAM为648.2587890625
检测订单目录中>>>
无未同步订单>>>
2026-04-26 09:36:39 >>>当前Ram内存为619.9326171875
定时检测未同步订单启用[checkOrderNum=536872368]
2026-04-26 09:36:40>>>cash write=0C
2026-04-26 09:36:40>>>cash read=3E


===09:37:56===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 09:37:33 >>>回调事件[910,devices/A0509]
2026-04-26 09:37:33 >>>故障排除日志:上一MQTT订单号缓存列表为2604260936290093132398
2026-04-26 09:37:33 >>>故障排除日志:终端未同步成功订单列表00592604260936290093132398
已接收过此消息,票券号为2604260936299502963801,排队号为59
2026-04-26 09:37:33 开始打印,排队:60,票券:2604260937237977801901,订单:2604260937230077476264,[2026-04-26 09:37:31微信支付10元]
2026-04-26 09:37:33 开始打印,排队:61,票券:2604260937237978239602,订单:2604260937230077476264,[2026-04-26 09:37:31微信支付10元]
2026-04-26 09:37:33>>>MQTT票号同步场景，创建空订单对象
2026-04-26 09:37:33>>>合并MQTT票号列表到订单同步请求,共3张票
2026-04-26 09:37:36 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604260936299502963801","queue_number":59,"trade_uid":"2604260936290093132398"},{"ticket_no":"2604260937237977801901","queue_number":60,"trade_uid":"2604260937230077476264"},{"ticket_no":"2604260937237978239602","queue_number":61,"trade_uid":"2604260937230077476264"}]}
2026-04-26 09:37:36 >>>故障排除日志:删除未同步下发订单成功2604260936290093132398
2026-04-26 09:37:36 >>>故障排除日志:删除未同步下发订单成功2604260937230077476264
2026-04-26 09:37:37 >>>故障排除日志:删除未同步下发订单成功2604260937230077476264
2026-04-26 09:37:37 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536872385]


===09:45:57===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 09:45:11 收到下发指令:排队号13>>>
2026-04-26 09:45:11 收到下发指令:叫号13>>>
2026-04-26 09:45:14 收到下发指令:排队号13>>>
2026-04-26 09:45:14 收到下发指令:叫号13>>>
2026-04-26 09:45:22 收到下发指令:排队号13>>>
2026-04-26 09:45:22 收到下发指令:叫号13>>>
2026-04-26 09:45:27 收到下发指令:排队号13>>>
2026-04-26 09:45:27 收到下发指令:叫号13>>>
2026-04-26 09:45:30 收到下发指令:排队号13>>>
2026-04-26 09:45:30 收到下发指令:叫号13>>>
2026-04-26 09:45:34 收到下发指令:排队号13>>>
2026-04-26 09:45:34 收到下发指令:叫号13>>>


===09:46:59===
2026-04-26 09:46:08 >>>回调事件[910,devices/A0509]
2026-04-26 09:46:08 >>>故障排除日志:上一MQTT订单号缓存列表为2604260936290093132398|2604260937230077476264|2604260937230077476264
2026-04-26 09:46:08 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 09:46:09 开始打印,排队:62,票券:2604260946015617011901,订单:2604260946010054181121,[2026-04-26 09:46:07微信支付10元]
2026-04-26 09:46:09>>>MQTT票号同步场景，创建空订单对象
2026-04-26 09:46:09>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 09:46:11 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604260946015617011901","queue_number":62,"trade_uid":"2604260946010054181121"}]}
2026-04-26 09:46:11 >>>故障排除日志:删除未同步下发订单成功2604260946010054181121
2026-04-26 09:46:11 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536872487]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 09:46:21 >>>回调事件[910,devices/A0509]
2026-04-26 09:46:21 >>>故障排除日志:上一MQTT订单号缓存列表为2604260946010054181121
2026-04-26 09:46:21 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 09:46:21 开始打印,排队:63,票券:2604260946080435465901,订单:2604260946080002320239,[2026-04-26 09:46:20微信支付10元]
2026-04-26 09:46:21>>>MQTT票号同步场景，创建空订单对象
2026-04-26 09:46:21>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 09:46:23 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604260946080435465901","queue_number":63,"trade_uid":"2604260946080002320239"}]}
2026-04-26 09:46:23 >>>故障排除日志:删除未同步下发订单成功2604260946080002320239
2026-04-26 09:46:23 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536872494]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 09:46:37 收到下发指令:排队号13>>>
2026-04-26 09:46:37 收到下发指令:叫号13>>>


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


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


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


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


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


===09:56:01===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 09:55:10 >>>回调事件[910,devices/A0509]
2026-04-26 09:55:10 >>>故障排除日志:上一MQTT订单号缓存列表为2604260954010062178856
2026-04-26 09:55:10 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 09:55:10 开始打印,排队:71,票券:2604260954594694589201,订单:2604260954590044258081,[2026-04-26 09:55:09微信支付10元]
2026-04-26 09:55:10>>>MQTT票号同步场景，创建空订单对象
2026-04-26 09:55:10>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 09:55:12 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604260954594694589201","queue_number":71,"trade_uid":"2604260954590044258081"}]}
2026-04-26 09:55:12 >>>故障排除日志:删除未同步下发订单成功2604260954590044258081
2026-04-26 09:55:12 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536872632]
2026-04-26 09:55:37>>>cash read=00
2026-04-26 09:55:38>>>cash read=2F29
2026-04-26 09:55:40>>>cash read=3E
2026-04-26 09:55:41>>>cash read=00
2026-04-26 09:55:42>>>cash read=818F42
2026-04-26 09:55:42>>>cash write=02
2026-04-26 09:55:42 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 09:55:43>>>cash read=10
2026-04-26 09:55:43 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 09:55:43 当前产品价格10元，投币10元，打印小票中...
2026-04-26 09:55:43 >>>开始打印,排队号为72,订单号为2604260955430030509067
2026-04-26 09:55:43>>>订单2604260955430030509067写入成功,剩余空间为1678500,占用RAM为641.814453125
删除未同步订单2604260955430030509067
2026-04-26 09:55:45>>>订单2604260955430030509067删除成功,剩余空间为1679500,占用RAM为651.0078125
检测订单目录中>>>
无未同步订单>>>
2026-04-26 09:55:45 >>>当前Ram内存为617.7568359375
定时检测未同步订单启用[checkOrderNum=536872645]
2026-04-26 09:55:46>>>cash write=0C
2026-04-26 09:55:46>>>cash read=3E


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


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


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


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


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


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


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


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


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


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


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


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


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


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


===10:23:08===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 10:22:45 收到下发指令:排队号16>>>
2026-04-26 10:22:45 收到下发指令:叫号16>>>
2026-04-26 10:22:46 收到下发指令:排队号18>>>
2026-04-26 10:22:46 收到下发指令:叫号18>>>
2026-04-26 10:22:47 收到下发指令:排队号20>>>
2026-04-26 10:22:47 收到下发指令:叫号20>>>
2026-04-26 10:22:48 收到下发指令:排队号23>>>
2026-04-26 10:22:48 收到下发指令:叫号23>>>
2026-04-26 10:22:49 收到下发指令:排队号25>>>
2026-04-26 10:22:49 收到下发指令:叫号25>>>
2026-04-26 10:22:50 收到下发指令:排队号27>>>
2026-04-26 10:22:50 收到下发指令:叫号27>>>
2026-04-26 10:22:51 收到下发指令:排队号29>>>
2026-04-26 10:22:51 收到下发指令:叫号29>>>
2026-04-26 10:22:52 收到下发指令:排队号31>>>
2026-04-26 10:22:52 收到下发指令:叫号31>>>
2026-04-26 10:22:53 收到下发指令:排队号33>>>
2026-04-26 10:22:53 收到下发指令:叫号33>>>
2026-04-26 10:22:53 收到下发指令:排队号35>>>
2026-04-26 10:22:53 收到下发指令:叫号35>>>
2026-04-26 10:22:54 收到下发指令:排队号36>>>
2026-04-26 10:22:54 收到下发指令:叫号36>>>
2026-04-26 10:22:55 收到下发指令:排队号39>>>
2026-04-26 10:22:55 收到下发指令:叫号39>>>
2026-04-26 10:22:55 收到下发指令:排队号41>>>
2026-04-26 10:22:55 收到下发指令:叫号41>>>
2026-04-26 10:22:57 收到下发指令:排队号43>>>
2026-04-26 10:22:57 收到下发指令:叫号43>>>
2026-04-26 10:22:57 收到下发指令:排队号45>>>
2026-04-26 10:22:57 收到下发指令:叫号45>>>
2026-04-26 10:22:57 收到下发指令:排队号47>>>
2026-04-26 10:22:57 收到下发指令:叫号47>>>
2026-04-26 10:22:59 收到下发指令:排队号48>>>
2026-04-26 10:22:59 收到下发指令:叫号48>>>
2026-04-26 10:22:59 收到下发指令:排队号50>>>
2026-04-26 10:22:59 收到下发指令:叫号50>>>
2026-04-26 10:22:59 收到下发指令:排队号51>>>
2026-04-26 10:22:59 收到下发指令:叫号51>>>
2026-04-26 10:23:01 收到下发指令:排队号54>>>
2026-04-26 10:23:01 收到下发指令:叫号54>>>
2026-04-26 10:23:01 收到下发指令:排队号55>>>
2026-04-26 10:23:01 收到下发指令:叫号55>>>
2026-04-26 10:23:02 收到下发指令:排队号57>>>
2026-04-26 10:23:02 收到下发指令:叫号57>>>
2026-04-26 10:23:02 收到下发指令:排队号58>>>
2026-04-26 10:23:02 收到下发指令:叫号58>>>
2026-04-26 10:23:03 收到下发指令:排队号59>>>
2026-04-26 10:23:03 收到下发指令:叫号59>>>
2026-04-26 10:23:04 收到下发指令:排队号61>>>
2026-04-26 10:23:04 收到下发指令:叫号61>>>
2026-04-26 10:23:04 收到下发指令:排队号63>>>
2026-04-26 10:23:04 收到下发指令:叫号63>>>
2026-04-26 10:23:05 收到下发指令:排队号64>>>
2026-04-26 10:23:05 收到下发指令:叫号64>>>
2026-04-26 10:23:06 收到下发指令:排队号65>>>
2026-04-26 10:23:06 收到下发指令:叫号65>>>
2026-04-26 10:23:06 收到下发指令:排队号66>>>
2026-04-26 10:23:06 收到下发指令:叫号66>>>


===10:24:11===
2026-04-26 10:23:10 收到下发指令:排队号73>>>
2026-04-26 10:23:10 收到下发指令:叫号73>>>
2026-04-26 10:23:11 收到下发指令:排队号74>>>
2026-04-26 10:23:11 收到下发指令:叫号74>>>
2026-04-26 10:23:11 收到下发指令:排队号75>>>
2026-04-26 10:23:11 收到下发指令:叫号75>>>


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


===10:27:12===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 10:26:12 >>>回调事件[910,devices/A0509]
2026-04-26 10:26:12 >>>故障排除日志:上一MQTT订单号缓存列表为2604261024410020046129
2026-04-26 10:26:12 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 10:26:12 开始打印,排队:89,票券:2604261026030423607901,订单:2604261026030002236039,[2026-04-26 10:26:10微信支付10元]
2026-04-26 10:26:12>>>MQTT票号同步场景，创建空订单对象
2026-04-26 10:26:12>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 10:26:14 收到下发指令:排队号0>>>
2026-04-26 10:26:14 收到下发指令:叫号0>>>
2026-04-26 10:26:15 收到下发指令:排队号0>>>
2026-04-26 10:26:15 收到下发指令:叫号0>>>
2026-04-26 10:26:15 收到下发指令:排队号0>>>
2026-04-26 10:26:15 收到下发指令:叫号0>>>
2026-04-26 10:26:16 收到下发指令:排队号0>>>
2026-04-26 10:26:16 收到下发指令:叫号0>>>
2026-04-26 10:26:16 收到下发指令:排队号0>>>
2026-04-26 10:26:16 收到下发指令:叫号0>>>
2026-04-26 10:26:18 收到下发指令:排队号0>>>
2026-04-26 10:26:18 收到下发指令:叫号0>>>
2026-04-26 10:26:18 收到下发指令:排队号82>>>
2026-04-26 10:26:18 收到下发指令:叫号82>>>
2026-04-26 10:26:18 收到下发指令:排队号83>>>
2026-04-26 10:26:18 收到下发指令:叫号83>>>
2026-04-26 10:26:20 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261026030423607901","queue_number":89,"trade_uid":"2604261026030002236039"}]}
2026-04-26 10:26:20 >>>故障排除日志:删除未同步下发订单成功2604261026030002236039
2026-04-26 10:26:20 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536873050]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 10:26:20 收到下发指令:排队号84>>>
2026-04-26 10:26:20 收到下发指令:叫号84>>>
2026-04-26 10:26:21 收到下发指令:排队号85>>>
2026-04-26 10:26:21 收到下发指令:叫号85>>>
2026-04-26 10:26:21 收到下发指令:排队号86>>>
2026-04-26 10:26:21 收到下发指令:叫号86>>>
2026-04-26 10:26:22 收到下发指令:排队号87>>>
2026-04-26 10:26:22 收到下发指令:叫号87>>>
2026-04-26 10:26:23 收到下发指令:排队号88>>>
2026-04-26 10:26:23 收到下发指令:叫号88>>>
2026-04-26 10:26:24 收到下发指令:排队号89>>>
2026-04-26 10:26:24 收到下发指令:叫号89>>>
2026-04-26 10:26:35 收到下发指令:排队号88>>>


===10:29:12===
2026-04-26 10:28:41>>>cash read=00
2026-04-26 10:28:41>>>cash read=818F42
2026-04-26 10:28:41>>>cash write=02
2026-04-26 10:28:41 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 10:28:42>>>cash read=10
2026-04-26 10:28:42 >>>回调事件130,10,10023,finish Money=10,进钞完成
2026-04-26 10:28:42 当前产品价格10元，投币10元，打印小票中...
2026-04-26 10:28:42 >>>开始打印,排队号为90,订单号为2604261028420030509406
2026-04-26 10:28:42>>>订单2604261028420030509406写入成功,剩余空间为1680000,占用RAM为628.755859375
删除未同步订单2604261028420030509406
2026-04-26 10:28:44>>>订单2604261028420030509406删除成功,剩余空间为1680500,占用RAM为642.5810546875
检测订单目录中>>>
无未同步订单>>>
2026-04-26 10:28:44 >>>当前Ram内存为614.1845703125
定时检测未同步订单启用[checkOrderNum=536873086]
2026-04-26 10:28:45>>>cash read=818F42
2026-04-26 10:28:45 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 10:28:45>>>cash read=10
2026-04-26 10:28:45 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 10:28:45 当前产品价格10元，投币10元，打印小票中...
2026-04-26 10:28:45 >>>开始打印,排队号为91,订单号为2604261028450030509964
2026-04-26 10:28:46>>>订单2604261028450030509964写入成功,剩余空间为1679000,占用RAM为638.0166015625
删除未同步订单2604261028450030509964
2026-04-26 10:28:48>>>订单2604261028450030509964删除成功,剩余空间为1679500,占用RAM为648.1171875
检测订单目录中>>>
无未同步订单>>>
2026-04-26 10:28:48 >>>当前Ram内存为615.4423828125
定时检测未同步订单启用[checkOrderNum=536873093]
2026-04-26 10:28:49>>>cash write=0C
2026-04-26 10:28:49>>>cash read=3E
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 10:28:52 收到下发指令:排队号88>>>
2026-04-26 10:28:52 收到下发指令:叫号88>>>
2026-04-26 10:28:53 收到下发指令:排队号88>>>
2026-04-26 10:28:53 收到下发指令:叫号88>>>


===10:30:12===
2026-04-26 10:29:29 >>>回调事件[910,devices/A0509]
2026-04-26 10:29:29 >>>故障排除日志:上一MQTT订单号缓存列表为2604261026030002236039
2026-04-26 10:29:29 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 10:29:29 开始打印,排队:92,票券:2604261029195467254201,订单:2604261029190052908412,[2026-04-26 10:29:28微信支付10元]
2026-04-26 10:29:29 开始打印,排队:93,票券:2604261029207801294301,订单:2604261029200076060747,[2026-04-26 10:29:28微信支付10元]
2026-04-26 10:29:30>>>MQTT票号同步场景，创建空订单对象
2026-04-26 10:29:30>>>合并MQTT票号列表到订单同步请求,共2张票
2026-04-26 10:29:30 >>>回调事件[910,devices/A0509]
2026-04-26 10:29:30 >>>故障排除日志:上一MQTT订单号缓存列表为2604261029190052908412|2604261029200076060747
2026-04-26 10:29:30 >>>故障排除日志:终端未同步成功订单列表00922604261029190052908412|00932604261029200076060747
已接收过此消息,票券号为2604261029195467254201,排队号为92
已接收过此消息,票券号为2604261029207801294301,排队号为93
2026-04-26 10:29:30>>>HTTP请求进行中，跳过本次同步
2026-04-26 10:29:33 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261029195467254201","queue_number":92,"trade_uid":"2604261029190052908412"},{"ticket_no":"2604261029207801294301","queue_number":93,"trade_uid":"2604261029200076060747"}]}
2026-04-26 10:29:33 >>>故障排除日志:删除未同步下发订单成功2604261029190052908412
2026-04-26 10:29:33 >>>故障排除日志:删除未同步下发订单成功2604261029200076060747
2026-04-26 10:29:34 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536873108]


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


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


===10:37:13===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 10:36:33 收到下发指令:排队号88>>>
2026-04-26 10:36:33 收到下发指令:叫号88>>>


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


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


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


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


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


===10:58:14===
2026-04-26 10:58:09>>>cash read=29
2026-04-26 10:58:09 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 10:58:10>>>cash read=3E


===10:59:14===
2026-04-26 10:58:17>>>cash read=00
2026-04-26 10:58:18>>>cash read=01
2026-04-26 10:58:20>>>cash read=3E
2026-04-26 10:58:28>>>cash read=29
2026-04-26 10:58:28 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 10:58:29>>>cash read=01
2026-04-26 10:58:31>>>cash read=29
2026-04-26 10:58:31 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 10:58:32>>>cash read=3E
2026-04-26 10:58:36>>>cash read=00
2026-04-26 10:58:36>>>cash read=818F42
2026-04-26 10:58:36>>>cash write=02
2026-04-26 10:58:36 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 10:58:37>>>cash read=10
2026-04-26 10:58:37 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 10:58:37 当前产品价格10元，投币10元，打印小票中...
2026-04-26 10:58:37 >>>开始打印,排队号为106,订单号为2604261058370030509276
2026-04-26 10:58:37>>>订单2604261058370030509276写入成功,剩余空间为1679500,占用RAM为635.3720703125
删除未同步订单2604261058370030509276
2026-04-26 10:58:39>>>订单2604261058370030509276删除成功,剩余空间为1680000,占用RAM为646.2646484375
检测订单目录中>>>
无未同步订单>>>
2026-04-26 10:58:39 >>>当前Ram内存为617.798828125
定时检测未同步订单启用[checkOrderNum=536873461]
2026-04-26 10:58:40>>>cash write=0C
2026-04-26 10:58:40>>>cash read=3E


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


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


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


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


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


===11:14:15===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 11:13:47 收到下发指令:排队号88>>>
2026-04-26 11:13:47 收到下发指令:叫号88>>>
2026-04-26 11:13:59 收到下发指令:排队号88>>>
2026-04-26 11:13:59 收到下发指令:叫号88>>>
2026-04-26 11:14:07 收到下发指令:排队号88>>>
2026-04-26 11:14:07 收到下发指令:叫号88>>>
2026-04-26 11:14:12 收到下发指令:排队号88>>>
2026-04-26 11:14:12 收到下发指令:叫号88>>>


===11:15:15===
2026-04-26 11:14:16 收到下发指令:排队号88>>>
2026-04-26 11:14:16 收到下发指令:叫号88>>>
2026-04-26 11:14:28 >>>回调事件[910,devices/A0509]
2026-04-26 11:14:28 >>>故障排除日志:上一MQTT订单号缓存列表为2604261111170077588369
2026-04-26 11:14:28 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 11:14:28 开始打印,排队:112,票券:2604261114201978184501,订单:2604261114200017786389,[2026-04-26 11:14:27微信支付10元]
2026-04-26 11:14:28>>>MQTT票号同步场景，创建空订单对象
2026-04-26 11:14:28>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 11:14:30 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261114201978184501","queue_number":112,"trade_uid":"2604261114200017786389"}]}
2026-04-26 11:14:30 >>>故障排除日志:删除未同步下发订单成功2604261114200017786389
2026-04-26 11:14:30 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536873682]


===11:18:15===
2026-04-26 11:17:38>>>cash read=0A
2026-04-26 11:17:39>>>cash read=3E


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


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


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


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


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


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


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


===11:39:17===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 11:38:51 收到下发指令:排队号88>>>
2026-04-26 11:38:51 收到下发指令:叫号88>>>
2026-04-26 11:38:53 收到下发指令:排队号88>>>
2026-04-26 11:38:53 收到下发指令:叫号88>>>
2026-04-26 11:38:57 收到下发指令:排队号88>>>
2026-04-26 11:38:57 收到下发指令:叫号88>>>
2026-04-26 11:39:01 收到下发指令:排队号88>>>
2026-04-26 11:39:01 收到下发指令:叫号88>>>
2026-04-26 11:39:05 收到下发指令:排队号88>>>
2026-04-26 11:39:05 收到下发指令:叫号88>>>
2026-04-26 11:39:09 收到下发指令:排队号88>>>
2026-04-26 11:39:09 收到下发指令:叫号88>>>


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


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


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


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


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


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


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


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


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


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


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


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


===12:25:20===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 12:24:22 收到下发指令:排队号88>>>
2026-04-26 12:24:22 收到下发指令:叫号88>>>
2026-04-26 12:24:25 收到下发指令:排队号88>>>
2026-04-26 12:24:25 收到下发指令:叫号88>>>
2026-04-26 12:24:29 收到下发指令:排队号88>>>
2026-04-26 12:24:29 收到下发指令:叫号88>>>
2026-04-26 12:24:32 收到下发指令:排队号88>>>
2026-04-26 12:24:32 收到下发指令:叫号88>>>
2026-04-26 12:24:52>>>cash read=00
2026-04-26 12:24:53>>>cash read=00818F42
2026-04-26 12:24:53>>>cash write=02
2026-04-26 12:24:53 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 12:24:54>>>cash read=10
2026-04-26 12:24:54 >>>回调事件130,10,10023,finish Money=10,进钞完成
2026-04-26 12:24:54 当前产品价格10元，投币10元，打印小票中...
2026-04-26 12:24:54 >>>开始打印,排队号为133,订单号为2604261224540030509744
2026-04-26 12:24:54>>>订单2604261224540030509744写入成功,剩余空间为1679500,占用RAM为633.7998046875
删除未同步订单2604261224540030509744
2026-04-26 12:24:56>>>订单2604261224540030509744删除成功,剩余空间为1680000,占用RAM为643.2861328125
检测订单目录中>>>
无未同步订单>>>
2026-04-26 12:24:56 >>>当前Ram内存为614.919921875
定时检测未同步订单启用[checkOrderNum=536874505]
2026-04-26 12:24:57>>>cash write=0C
2026-04-26 12:24:57>>>cash read=3E


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


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


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


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


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


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


===12:43:22===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 12:43:04 收到下发指令:排队号88>>>
2026-04-26 12:43:04 收到下发指令:叫号88>>>
2026-04-26 12:43:07 收到下发指令:排队号88>>>
2026-04-26 12:43:07 收到下发指令:叫号88>>>
2026-04-26 12:43:11 收到下发指令:排队号88>>>
2026-04-26 12:43:11 收到下发指令:叫号88>>>
2026-04-26 12:43:14 收到下发指令:排队号88>>>
2026-04-26 12:43:14 收到下发指令:叫号88>>>
2026-04-26 12:43:18 收到下发指令:排队号88>>>
2026-04-26 12:43:18 收到下发指令:叫号88>>>


===12:44:22===
2026-04-26 12:43:35 收到下发指令:排队号88>>>
2026-04-26 12:43:35 收到下发指令:叫号88>>>
2026-04-26 12:43:39 收到下发指令:排队号88>>>
2026-04-26 12:43:39 收到下发指令:叫号88>>>
2026-04-26 12:43:43 收到下发指令:排队号88>>>
2026-04-26 12:43:43 收到下发指令:叫号88>>>
2026-04-26 12:43:46 收到下发指令:排队号88>>>
2026-04-26 12:43:46 收到下发指令:叫号88>>>
2026-04-26 12:43:50 >>>回调事件[910,devices/A0509]
2026-04-26 12:43:50 >>>故障排除日志:上一MQTT订单号缓存列表为2604261241530053864694
2026-04-26 12:43:50 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 12:43:50 开始打印,排队:142,票券:2604261243413806626201,订单:2604261243410036288875,[2026-04-26 12:43:49微信支付10元]
2026-04-26 12:43:50>>>MQTT票号同步场景，创建空订单对象
2026-04-26 12:43:50>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 12:43:52 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261243413806626201","queue_number":142,"trade_uid":"2604261243410036288875"}]}
2026-04-26 12:43:52 >>>故障排除日志:删除未同步下发订单成功2604261243410036288875
2026-04-26 12:43:52 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536874755]


===12:47:22===
2026-04-26 12:46:37>>>cash read=0A
2026-04-26 12:46:38>>>cash read=3E


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


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


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


===13:08:23===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 13:07:37 收到下发指令:排队号88>>>
2026-04-26 13:07:37 收到下发指令:叫号88>>>
2026-04-26 13:07:41 收到下发指令:排队号88>>>
2026-04-26 13:07:41 收到下发指令:叫号88>>>
2026-04-26 13:07:44 收到下发指令:排队号88>>>
2026-04-26 13:07:44 收到下发指令:叫号88>>>
2026-04-26 13:07:48 收到下发指令:排队号88>>>
2026-04-26 13:07:48 收到下发指令:叫号88>>>


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


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


===13:13:24===
2026-04-26 13:13:17>>>cash read=00
2026-04-26 13:13:18>>>cash read=2F29
2026-04-26 13:13:19>>>cash read=01
2026-04-26 13:13:19>>>cash read=2F
2026-04-26 13:13:21>>>cash read=00
2026-04-26 13:13:21>>>cash read=2F29


===13:14:24===
2026-04-26 13:13:23>>>cash read=3E
2026-04-26 13:13:27>>>cash read=00
2026-04-26 13:13:28>>>cash read=818F42
2026-04-26 13:13:28>>>cash write=02
2026-04-26 13:13:28 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 13:13:29>>>cash read=10
2026-04-26 13:13:29 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 13:13:29 当前产品价格10元，投币10元，打印小票中...
2026-04-26 13:13:29 >>>开始打印,排队号为149,订单号为2604261313290030509112
2026-04-26 13:13:29>>>订单2604261313290030509112写入成功,剩余空间为1679500,占用RAM为633.080078125
删除未同步订单2604261313290030509112
2026-04-26 13:13:31>>>订单2604261313290030509112删除成功,剩余空间为1680500,占用RAM为643.3447265625
检测订单目录中>>>
无未同步订单>>>
2026-04-26 13:13:31 >>>当前Ram内存为615.6455078125
定时检测未同步订单启用[checkOrderNum=536875083]
2026-04-26 13:13:32>>>cash write=0C
2026-04-26 13:13:32>>>cash read=3E
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 13:14:19 >>>回调事件[910,devices/A0509]
2026-04-26 13:14:19 >>>故障排除日志:上一MQTT订单号缓存列表为2604261310210047178926
2026-04-26 13:14:19 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 13:14:19 开始打印,排队:150,票券:2604261314118534352301,订单:2604261314110083163574,[2026-04-26 13:14:18微信支付10元]
2026-04-26 13:14:19>>>MQTT票号同步场景，创建空订单对象
2026-04-26 13:14:19>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 13:14:21 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261314118534352301","queue_number":150,"trade_uid":"2604261314110083163574"}]}
2026-04-26 13:14:21 >>>故障排除日志:删除未同步下发订单成功2604261314110083163574
2026-04-26 13:14:21 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536875098]


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


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


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


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


===13:29:25===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 13:28:34 >>>回调事件[910,devices/A0509]
2026-04-26 13:28:34 >>>故障排除日志:上一MQTT订单号缓存列表为2604261327270076801237
2026-04-26 13:28:34 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 13:28:34 开始打印,排队:156,票券:2604261328268272043801,订单:2604261328260080467932,[2026-04-26 13:28:33微信支付10元]
2026-04-26 13:28:34 开始打印,排队:157,票券:2604261328268272489502,订单:2604261328260080467932,[2026-04-26 13:28:33微信支付10元]
2026-04-26 13:28:34>>>MQTT票号同步场景，创建空订单对象
2026-04-26 13:28:34>>>合并MQTT票号列表到订单同步请求,共2张票
2026-04-26 13:28:37 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261328268272043801","queue_number":156,"trade_uid":"2604261328260080467932"},{"ticket_no":"2604261328268272489502","queue_number":157,"trade_uid":"2604261328260080467932"}]}
2026-04-26 13:28:37 >>>故障排除日志:删除未同步下发订单成功2604261328260080467932
2026-04-26 13:28:37 >>>故障排除日志:删除未同步下发订单成功2604261328260080467932
2026-04-26 13:28:37 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536875271]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 13:29:08 >>>回调事件[910,devices/A0509]
2026-04-26 13:29:08 >>>故障排除日志:上一MQTT订单号缓存列表为2604261328260080467932|2604261328260080467932
2026-04-26 13:29:08 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 13:29:08 开始打印,排队:158,票券:2604261328599585482801,订单:2604261328590093883124,[2026-04-26 13:29:07微信支付10元]
2026-04-26 13:29:09>>>MQTT票号同步场景，创建空订单对象
2026-04-26 13:29:09>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 13:29:10 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261328599585482801","queue_number":158,"trade_uid":"2604261328590093883124"}]}
2026-04-26 13:29:11 >>>故障排除日志:删除未同步下发订单成功2604261328590093883124
2026-04-26 13:29:11 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536875285]


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


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


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


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


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


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


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


===13:51:27===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 13:50:58 收到下发指令:排队号88>>>
2026-04-26 13:50:58 收到下发指令:叫号88>>>
2026-04-26 13:51:02 收到下发指令:排队号88>>>
2026-04-26 13:51:02 收到下发指令:叫号88>>>
2026-04-26 13:51:06 收到下发指令:排队号88>>>
2026-04-26 13:51:06 收到下发指令:叫号88>>>
2026-04-26 13:51:10 收到下发指令:排队号88>>>
2026-04-26 13:51:10 收到下发指令:叫号88>>>
2026-04-26 13:51:14 收到下发指令:排队号88>>>
2026-04-26 13:51:14 收到下发指令:叫号88>>>
2026-04-26 13:51:18 收到下发指令:排队号88>>>
2026-04-26 13:51:18 收到下发指令:叫号88>>>
2026-04-26 13:51:21 收到下发指令:排队号88>>>
2026-04-26 13:51:21 收到下发指令:叫号88>>>
2026-04-26 13:51:25 收到下发指令:排队号88>>>
2026-04-26 13:51:25 收到下发指令:叫号88>>>


===13:52:27===
2026-04-26 13:51:28 收到下发指令:排队号88>>>
2026-04-26 13:51:28 收到下发指令:叫号88>>>
2026-04-26 13:51:57 >>>回调事件[910,devices/A0509]
2026-04-26 13:51:57 >>>故障排除日志:上一MQTT订单号缓存列表为2604261350100093868039
2026-04-26 13:51:57 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 13:51:57 开始打印,排队:167,票券:2604261351484898478901,订单:2604261351480047116885,[2026-04-26 13:51:56微信支付10元]
2026-04-26 13:51:57>>>MQTT票号同步场景，创建空订单对象
2026-04-26 13:51:57>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 13:51:59 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261351484898478901","queue_number":167,"trade_uid":"2604261351480047116885"}]}
2026-04-26 13:51:59 >>>故障排除日志:删除未同步下发订单成功2604261351480047116885
2026-04-26 13:51:59 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536875586]


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


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


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


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


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


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


===14:03:31===
2026-04-26 14:02:42>>>cash read=00
2026-04-26 14:02:42>>>cash read=818F42
2026-04-26 14:02:42>>>cash write=02
2026-04-26 14:02:42 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 14:02:43>>>cash read=10
2026-04-26 14:02:43 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 14:02:43 当前产品价格10元，投币10元，打印小票中...
2026-04-26 14:02:43 >>>开始打印,排队号为176,订单号为2604261402430030509186
2026-04-26 14:02:43>>>订单2604261402430030509186写入成功,剩余空间为1679500,占用RAM为633.732421875
删除未同步订单2604261402430030509186
2026-04-26 14:02:45>>>订单2604261402430030509186删除成功,剩余空间为1680500,占用RAM为643.974609375
检测订单目录中>>>
无未同步订单>>>
2026-04-26 14:02:45 >>>当前Ram内存为616.3349609375
定时检测未同步订单启用[checkOrderNum=536875737]
2026-04-26 14:02:46>>>cash write=0C
2026-04-26 14:02:46>>>cash read=3E
2026-04-26 14:02:48>>>cash read=00
2026-04-26 14:02:49>>>cash read=818F42
2026-04-26 14:02:49>>>cash write=02
2026-04-26 14:02:49 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 14:02:49>>>cash read=10
2026-04-26 14:02:49 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 14:02:49 当前产品价格10元，投币10元，打印小票中...
2026-04-26 14:02:50 >>>开始打印,排队号为177,订单号为2604261402500030509892
2026-04-26 14:02:50>>>订单2604261402500030509892写入成功,剩余空间为1678500,占用RAM为642.0400390625
删除未同步订单2604261402500030509892
2026-04-26 14:02:52>>>订单2604261402500030509892删除成功,剩余空间为1679500,占用RAM为652.3388671875
检测订单目录中>>>
无未同步订单>>>
2026-04-26 14:02:52 >>>当前Ram内存为617.8857421875
定时检测未同步订单启用[checkOrderNum=536875749]
2026-04-26 14:02:53>>>cash write=0C
2026-04-26 14:02:53>>>cash read=3E


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


===14:10:31===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 14:10:24 收到下发指令:排队号88>>>
2026-04-26 14:10:24 收到下发指令:叫号88>>>
2026-04-26 14:10:27 收到下发指令:排队号88>>>
2026-04-26 14:10:27 收到下发指令:叫号88>>>
2026-04-26 14:10:30 收到下发指令:排队号88>>>
2026-04-26 14:10:30 收到下发指令:叫号88>>>


===14:11:32===
2026-04-26 14:10:34 收到下发指令:排队号88>>>
2026-04-26 14:10:34 收到下发指令:叫号88>>>
2026-04-26 14:10:38 收到下发指令:排队号88>>>
2026-04-26 14:10:38 收到下发指令:叫号88>>>


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


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


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


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


===14:20:33===
2026-04-26 14:20:30>>>cash read=00
2026-04-26 14:20:32>>>cash read=818F41
2026-04-26 14:20:32>>>cash write=02
2026-04-26 14:20:32 >>>回调事件130,cash_status,10022,进钞中...read money=5
2026-04-26 14:20:32>>>cash read=10
2026-04-26 14:20:32 >>>回调事件130,5,10023,finish Money=5,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]


===14:21:34===
2026-04-26 14:20:34>>>cash write=0C
2026-04-26 14:20:34>>>cash read=3E
2026-04-26 14:20:35>>>cash read=00
2026-04-26 14:20:35>>>cash read=818F41
2026-04-26 14:20:35>>>cash write=02
2026-04-26 14:20:35 >>>回调事件130,cash_status,10022,进钞中...read money=5
2026-04-26 14:20:36>>>cash read=10
2026-04-26 14:20:36 >>>回调事件130,5,10023,finish Money=5,进钞完成
2026-04-26 14:20:36 当前产品价格10元，投币10元，打印小票中...
2026-04-26 14:20:36 >>>开始打印,排队号为184,订单号为2604261420320030509144
2026-04-26 14:20:36>>>订单2604261420320030509144写入成功,剩余空间为1679500,占用RAM为629.5107421875
删除未同步订单2604261420320030509144
2026-04-26 14:20:38>>>订单2604261420320030509144删除成功,剩余空间为1680500,占用RAM为644.845703125
检测订单目录中>>>
无未同步订单>>>
2026-04-26 14:20:38 >>>当前Ram内存为615.861328125
定时检测未同步订单启用[checkOrderNum=536875979]
2026-04-26 14:20:39>>>cash write=0C
2026-04-26 14:20:39>>>cash read=3E
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 14:20:52 收到下发指令:排队号88>>>
2026-04-26 14:20:52 收到下发指令:叫号88>>>


===14:22:34===
2026-04-26 14:21:40 收到下发指令:排队号88>>>
2026-04-26 14:21:40 收到下发指令:叫号88>>>
2026-04-26 14:21:44 收到下发指令:排队号88>>>
2026-04-26 14:21:44 收到下发指令:叫号88>>>
2026-04-26 14:22:19 >>>回调事件[910,devices/A0509]
2026-04-26 14:22:19 >>>故障排除日志:上一MQTT订单号缓存列表为2604261419070099939579
2026-04-26 14:22:19 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 14:22:19 开始打印,排队:185,票券:2604261422099560064801,订单:2604261422090093200747,[2026-04-26 14:22:18微信支付10元]
2026-04-26 14:22:19>>>MQTT票号同步场景，创建空订单对象
2026-04-26 14:22:19>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 14:22:21 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261422099560064801","queue_number":185,"trade_uid":"2604261422090093200747"}]}
2026-04-26 14:22:21 >>>故障排除日志:删除未同步下发订单成功2604261422090093200747
2026-04-26 14:22:21 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536876014]


===14:23:34===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 14:22:33 收到下发指令:排队号88>>>
2026-04-26 14:22:33 收到下发指令:叫号88>>>


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


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


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


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


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


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


===14:36:36===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 14:35:42 收到下发指令:排队号88>>>
2026-04-26 14:35:42 收到下发指令:叫号88>>>
2026-04-26 14:35:46 收到下发指令:排队号88>>>
2026-04-26 14:35:46 收到下发指令:叫号88>>>
2026-04-26 14:35:49 收到下发指令:排队号88>>>
2026-04-26 14:35:49 收到下发指令:叫号88>>>
2026-04-26 14:35:55 收到下发指令:排队号88>>>
2026-04-26 14:35:55 收到下发指令:叫号88>>>
2026-04-26 14:36:00 >>>回调事件[910,devices/A0509]
2026-04-26 14:36:00 >>>故障排除日志:上一MQTT订单号缓存列表为2604261431180010616958
2026-04-26 14:36:00 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 14:36:00 开始打印,排队:194,票券:2604261435541085551501,订单:2604261435540009139189,[2026-04-26 14:35:59微信支付10元]
2026-04-26 14:36:00>>>MQTT票号同步场景，创建空订单对象
2026-04-26 14:36:00>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 14:36:02 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261435541085551501","queue_number":194,"trade_uid":"2604261435540009139189"}]}
2026-04-26 14:36:02 >>>故障排除日志:删除未同步下发订单成功2604261435540009139189
2026-04-26 14:36:02 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536876223]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 14:36:18 >>>回调事件[910,devices/A0509]
2026-04-26 14:36:18 >>>故障排除日志:上一MQTT订单号缓存列表为2604261435540009139189
2026-04-26 14:36:18 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 14:36:18 开始打印,排队:195,票券:2604261436073252516401,订单:2604261436070030129892,[2026-04-26 14:36:17微信支付10元]
2026-04-26 14:36:18>>>MQTT票号同步场景，创建空订单对象
2026-04-26 14:36:18>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 14:36:20 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261436073252516401","queue_number":195,"trade_uid":"2604261436070030129892"}]}
2026-04-26 14:36:20 >>>故障排除日志:删除未同步下发订单成功2604261436070030129892
2026-04-26 14:36:20 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536876231]


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


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


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


===14:46:37===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 14:45:40 >>>回调事件[910,devices/A0509]
2026-04-26 14:45:40 >>>故障排除日志:上一MQTT订单号缓存列表为2604261441490067439323
2026-04-26 14:45:40 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 14:45:40 开始打印,排队:199,票券:2604261445321884599501,订单:2604261445320015700891,[2026-04-26 14:45:39微信支付10元]
2026-04-26 14:45:40>>>MQTT票号同步场景，创建空订单对象
2026-04-26 14:45:40>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 14:45:42 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261445321884599501","queue_number":199,"trade_uid":"2604261445320015700891"}]}
2026-04-26 14:45:42 >>>故障排除日志:删除未同步下发订单成功2604261445320015700891
2026-04-26 14:45:42 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536876344]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 14:45:48 >>>回调事件[910,devices/A0509]
2026-04-26 14:45:48 >>>故障排除日志:上一MQTT订单号缓存列表为2604261445320015700891
2026-04-26 14:45:48 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 14:45:49 开始打印,排队:200,票券:2604261445298199902501,订单:2604261445290079805884,[2026-04-26 14:45:48支付宝支付10元]
2026-04-26 14:45:49>>>MQTT票号同步场景，创建空订单对象
2026-04-26 14:45:49>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 14:45:50 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261445298199902501","queue_number":200,"trade_uid":"2604261445290079805884"}]}
2026-04-26 14:45:50 >>>故障排除日志:删除未同步下发订单成功2604261445290079805884
2026-04-26 14:45:51 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536876356]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 14:45:53 >>>回调事件[910,devices/A0509]
2026-04-26 14:45:53 >>>故障排除日志:上一MQTT订单号缓存列表为2604261445290079805884
2026-04-26 14:45:53 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 14:45:53 开始打印,排队:201,票券:2604261445419817635801,订单:2604261445410095630941,[2026-04-26 14:45:52支付宝支付10元]
2026-04-26 14:45:53>>>MQTT票号同步场景，创建空订单对象
2026-04-26 14:45:53>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 14:45:55 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261445419817635801","queue_number":201,"trade_uid":"2604261445410095630941"}]}
2026-04-26 14:45:55 >>>故障排除日志:删除未同步下发订单成功2604261445410095630941
2026-04-26 14:45:55 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536876362]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 14:46:13 >>>回调事件[910,devices/A0509]
2026-04-26 14:46:13 >>>故障排除日志:上一MQTT订单号缓存列表为2604261445410095630941
2026-04-26 14:46:13 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 14:46:13 开始打印,排队:202,票券:2604261446055117399301,订单:2604261446050049291915,[2026-04-26 14:46:12微信支付10元]
2026-04-26 14:46:13>>>MQTT票号同步场景，创建空订单对象
2026-04-26 14:46:13>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 14:46:15 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261446055117399301","queue_number":202,"trade_uid":"2604261446050049291915"}]}
2026-04-26 14:46:15 >>>故障排除日志:删除未同步下发订单成功2604261446050049291915
2026-04-26 14:46:15 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536876370]


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


===14:55:37===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 14:55:01 收到下发指令:排队号88>>>
2026-04-26 14:55:01 收到下发指令:叫号88>>>
2026-04-26 14:55:04 收到下发指令:排队号88>>>
2026-04-26 14:55:04 收到下发指令:叫号88>>>
2026-04-26 14:55:08 收到下发指令:排队号88>>>
2026-04-26 14:55:08 收到下发指令:叫号88>>>
2026-04-26 14:55:11 收到下发指令:排队号88>>>
2026-04-26 14:55:11 收到下发指令:叫号88>>>
2026-04-26 14:55:21 收到下发指令:排队号88>>>
2026-04-26 14:55:21 收到下发指令:叫号88>>>
2026-04-26 14:55:24 收到下发指令:排队号88>>>
2026-04-26 14:55:24 收到下发指令:叫号88>>>
2026-04-26 14:55:27 收到下发指令:排队号88>>>
2026-04-26 14:55:27 收到下发指令:叫号88>>>
2026-04-26 14:55:32 收到下发指令:排队号88>>>
2026-04-26 14:55:32 收到下发指令:叫号88>>>
2026-04-26 14:55:36 收到下发指令:排队号88>>>
2026-04-26 14:55:36 收到下发指令:叫号88>>>


===14:56:38===
2026-04-26 14:55:39 收到下发指令:排队号88>>>
2026-04-26 14:55:39 收到下发指令:叫号88>>>
2026-04-26 14:55:43 收到下发指令:排队号88>>>
2026-04-26 14:55:43 收到下发指令:叫号88>>>
2026-04-26 14:55:47 收到下发指令:排队号88>>>
2026-04-26 14:55:47 收到下发指令:叫号88>>>
2026-04-26 14:55:50 收到下发指令:排队号88>>>
2026-04-26 14:55:50 收到下发指令:叫号88>>>
2026-04-26 14:55:53 收到下发指令:排队号88>>>
2026-04-26 14:55:53 收到下发指令:叫号88>>>
2026-04-26 14:55:57 收到下发指令:排队号88>>>
2026-04-26 14:55:57 收到下发指令:叫号88>>>
2026-04-26 14:56:02 收到下发指令:排队号88>>>
2026-04-26 14:56:02 收到下发指令:叫号88>>>
2026-04-26 14:56:05 收到下发指令:排队号88>>>
2026-04-26 14:56:05 收到下发指令:叫号88>>>
2026-04-26 14:56:08 收到下发指令:排队号88>>>
2026-04-26 14:56:08 收到下发指令:叫号88>>>
2026-04-26 14:56:12 收到下发指令:排队号88>>>
2026-04-26 14:56:12 收到下发指令:叫号88>>>
2026-04-26 14:56:15 收到下发指令:排队号88>>>
2026-04-26 14:56:15 收到下发指令:叫号88>>>
2026-04-26 14:56:19 收到下发指令:排队号88>>>
2026-04-26 14:56:19 收到下发指令:叫号88>>>
2026-04-26 14:56:22 收到下发指令:排队号88>>>
2026-04-26 14:56:22 收到下发指令:叫号88>>>
2026-04-26 14:56:30 收到下发指令:排队号88>>>
2026-04-26 14:56:30 收到下发指令:叫号88>>>
2026-04-26 14:56:34 收到下发指令:排队号88>>>
2026-04-26 14:56:34 收到下发指令:叫号88>>>


===14:57:39===
2026-04-26 14:57:02 收到下发指令:排队号88>>>
2026-04-26 14:57:02 收到下发指令:叫号88>>>
2026-04-26 14:57:05 收到下发指令:排队号88>>>
2026-04-26 14:57:05 收到下发指令:叫号88>>>
2026-04-26 14:57:09 收到下发指令:排队号88>>>
2026-04-26 14:57:09 收到下发指令:叫号88>>>
2026-04-26 14:57:12 收到下发指令:排队号88>>>
2026-04-26 14:57:12 收到下发指令:叫号88>>>
2026-04-26 14:57:24>>>cash read=00
2026-04-26 14:57:24>>>cash read=818F43
2026-04-26 14:57:24>>>cash write=02
2026-04-26 14:57:24 >>>回调事件130,cash_status,10022,进钞中...read money=20
2026-04-26 14:57:25>>>cash read=10
2026-04-26 14:57:25 >>>回调事件130,20,10023,finish Money=20,进钞完成
2026-04-26 14:57:25 当前产品价格10元，投币20元，打印小票中...
2026-04-26 14:57:25 >>>开始打印,排队号为204,订单号为2604261457250030509284
2026-04-26 14:57:25 >>>开始打印,排队号为205,订单号为2604261457250030509284
2026-04-26 14:57:25>>>订单2604261457250030509284写入成功,剩余空间为1679000,占用RAM为638.19140625
删除未同步订单2604261457250030509284
2026-04-26 14:57:29>>>订单2604261457250030509284删除成功,剩余空间为1680000,占用RAM为655.8369140625
检测订单目录中>>>
无未同步订单>>>
2026-04-26 14:57:29 >>>当前Ram内存为615.9111328125
定时检测未同步订单启用[checkOrderNum=536876552]
2026-04-26 14:57:30>>>cash write=0C
2026-04-26 14:57:30>>>cash read=3E
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 14:57:35 收到下发指令:排队号88>>>
2026-04-26 14:57:35 收到下发指令:叫号88>>>
2026-04-26 14:57:37 收到下发指令:排队号88>>>
2026-04-26 14:57:37 收到下发指令:叫号88>>>


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


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


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


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


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


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


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


===15:14:41===
2026-04-26 15:13:54 收到下发指令:排队号88>>>
2026-04-26 15:13:54 收到下发指令:叫号88>>>
2026-04-26 15:13:57 收到下发指令:排队号88>>>
2026-04-26 15:13:57 收到下发指令:叫号88>>>
2026-04-26 15:14:00 收到下发指令:排队号88>>>
2026-04-26 15:14:00 收到下发指令:叫号88>>>
2026-04-26 15:14:03 收到下发指令:排队号88>>>
2026-04-26 15:14:03 收到下发指令:叫号88>>>
2026-04-26 15:14:07 收到下发指令:排队号88>>>
2026-04-26 15:14:07 收到下发指令:叫号88>>>


===15:17:41===
2026-04-26 15:17:23 >>>回调事件[910,devices/A0509]
2026-04-26 15:17:24 >>>故障排除日志:上一MQTT订单号缓存列表为2604261509410071730298
2026-04-26 15:17:24 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 15:17:24 开始打印,排队:214,票券:2604261517080845579801,订单:2604261517080005966815,[2026-04-26 15:17:22支付宝支付10元]
2026-04-26 15:17:24 开始打印,排队:215,票券:2604261517080846132102,订单:2604261517080005966815,[2026-04-26 15:17:22支付宝支付10元]
2026-04-26 15:17:24>>>MQTT票号同步场景，创建空订单对象
2026-04-26 15:17:24>>>合并MQTT票号列表到订单同步请求,共2张票
2026-04-26 15:17:27 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261517080845579801","queue_number":214,"trade_uid":"2604261517080005966815"},{"ticket_no":"2604261517080846132102","queue_number":215,"trade_uid":"2604261517080005966815"}]}
2026-04-26 15:17:27 >>>故障排除日志:删除未同步下发订单成功2604261517080005966815
2026-04-26 15:17:27 >>>故障排除日志:删除未同步下发订单成功2604261517080005966815
2026-04-26 15:17:27 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536876819]


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


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


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


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


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


===15:26:43===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 15:25:46 >>>回调事件[910,devices/A0509]
2026-04-26 15:25:46 >>>故障排除日志:上一MQTT订单号缓存列表为2604261525030050394261
2026-04-26 15:25:46 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 15:25:46 开始打印,排队:222,票券:2604261525383726329801,订单:2604261525380035236442,[2026-04-26 15:25:45微信支付10元]
2026-04-26 15:25:46>>>MQTT票号同步场景，创建空订单对象
2026-04-26 15:25:46>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 15:25:48 >>>回调事件[910,devices/A0509]
2026-04-26 15:25:48 >>>故障排除日志:上一MQTT订单号缓存列表为2604261525380035236442
2026-04-26 15:25:48 >>>故障排除日志:终端未同步成功订单列表02222604261525380035236442
已接收过此消息,票券号为2604261525383726329801,排队号为222
2026-04-26 15:25:48 开始打印,排队:223,票券:2604261525414241313201,订单:2604261525410040233142,[2026-04-26 15:25:47微信支付10元]
2026-04-26 15:25:48>>>HTTP请求进行中，跳过本次同步
2026-04-26 15:25:50 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261525383726329801","queue_number":222,"trade_uid":"2604261525380035236442"}]}
2026-04-26 15:25:50 >>>故障排除日志:删除未同步下发订单成功2604261525380035236442
2026-04-26 15:25:50 >>>故障排除日志:终端同步成功后剩余订单列表02232604261525410040233142
定时检测未同步订单启用[checkOrderNum=536876956]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 15:26:12 >>>回调事件[910,devices/A0509]
2026-04-26 15:26:12 >>>故障排除日志:上一MQTT订单号缓存列表为2604261525380035236442|2604261525410040233142
2026-04-26 15:26:12 >>>故障排除日志:终端未同步成功订单列表02232604261525410040233142
已接收过此消息,票券号为2604261525414241313201,排队号为223
2026-04-26 15:26:12 开始打印,排队:224,票券:2604261525569917568601,订单:2604261525560097121563,[2026-04-26 15:26:10微信支付10元]
2026-04-26 15:26:12>>>MQTT票号同步场景，创建空订单对象
2026-04-26 15:26:12>>>合并MQTT票号列表到订单同步请求,共2张票
2026-04-26 15:26:14 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261525414241313201","queue_number":223,"trade_uid":"2604261525410040233142"},{"ticket_no":"2604261525569917568601","queue_number":224,"trade_uid":"2604261525560097121563"}]}
2026-04-26 15:26:14 >>>故障排除日志:删除未同步下发订单成功2604261525410040233142
2026-04-26 15:26:14 >>>故障排除日志:删除未同步下发订单成功2604261525560097121563
2026-04-26 15:26:14 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536876970]


===15:28:43===
2026-04-26 15:27:44>>>cash read=29
2026-04-26 15:27:44 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 15:27:44>>>cash read=2F29
2026-04-26 15:27:45>>>cash read=01
2026-04-26 15:27:49>>>cash read=2F
2026-04-26 15:27:50>>>cash read=2F29
2026-04-26 15:27:51>>>cash read=01
2026-04-26 15:27:58>>>cash read=2F
2026-04-26 15:28:00>>>cash read=3E


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


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


===15:33:43===
2026-04-26 15:33:01>>>cash read=00
2026-04-26 15:33:01>>>cash read=818F42
2026-04-26 15:33:01>>>cash write=02
2026-04-26 15:33:01 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 15:33:02>>>cash read=10
2026-04-26 15:33:02 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 15:33:02 当前产品价格10元，投币10元，打印小票中...
2026-04-26 15:33:02 >>>开始打印,排队号为227,订单号为2604261533020030509278
2026-04-26 15:33:02>>>订单2604261533020030509278写入成功,剩余空间为1679500,占用RAM为634.0869140625
删除未同步订单2604261533020030509278
2026-04-26 15:33:04>>>订单2604261533020030509278删除成功,剩余空间为1680500,占用RAM为645.57421875
检测订单目录中>>>
无未同步订单>>>
2026-04-26 15:33:04 >>>当前Ram内存为616.26171875
定时检测未同步订单启用[checkOrderNum=536877060]
2026-04-26 15:33:05>>>cash write=0C
2026-04-26 15:33:05>>>cash read=3E
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 15:33:25 >>>回调事件[910,devices/A0509]
2026-04-26 15:33:25 >>>故障排除日志:上一MQTT订单号缓存列表为2604261530220045960648
2026-04-26 15:33:25 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 15:33:25 开始打印,排队:228,票券:2604261533157505119301,订单:2604261533150070446141,[2026-04-26 15:33:23微信支付10元]
2026-04-26 15:33:25>>>MQTT票号同步场景，创建空订单对象
2026-04-26 15:33:25>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 15:33:27 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261533157505119301","queue_number":228,"trade_uid":"2604261533150070446141"}]}
2026-04-26 15:33:27 >>>故障排除日志:删除未同步下发订单成功2604261533150070446141
2026-04-26 15:33:27 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877066]


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


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


===15:42:44===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 15:41:59 收到下发指令:排队号88>>>
2026-04-26 15:41:59 收到下发指令:叫号88>>>
2026-04-26 15:42:02 收到下发指令:排队号88>>>
2026-04-26 15:42:02 收到下发指令:叫号88>>>
2026-04-26 15:42:06 收到下发指令:排队号88>>>
2026-04-26 15:42:06 收到下发指令:叫号88>>>
2026-04-26 15:42:10 收到下发指令:排队号88>>>
2026-04-26 15:42:10 收到下发指令:叫号88>>>
2026-04-26 15:42:14 收到下发指令:排队号88>>>
2026-04-26 15:42:14 收到下发指令:叫号88>>>
2026-04-26 15:42:38>>>cash read=00
2026-04-26 15:42:39>>>cash read=818F42
2026-04-26 15:42:39>>>cash write=02
2026-04-26 15:42:39 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 15:42:39>>>cash read=10
2026-04-26 15:42:39 >>>回调事件130,10,10023,finish Money=10,进钞完成
2026-04-26 15:42:39 当前产品价格10元，投币10元，打印小票中...
2026-04-26 15:42:39 >>>开始打印,排队号为231,订单号为2604261542390030509671
2026-04-26 15:42:39>>>订单2604261542390030509671写入成功,剩余空间为1679000,占用RAM为634.5224609375
删除未同步订单2604261542390030509671
2026-04-26 15:42:41>>>订单2604261542390030509671删除成功,剩余空间为1680000,占用RAM为643.76171875
检测订单目录中>>>
无未同步订单>>>
2026-04-26 15:42:42 >>>当前Ram内存为615.197265625
定时检测未同步订单启用[checkOrderNum=536877182]
2026-04-26 15:42:43>>>cash write=0C
2026-04-26 15:42:43>>>cash read=3E


===15:43:44===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 15:42:45 收到下发指令:排队号88>>>
2026-04-26 15:42:45 收到下发指令:叫号88>>>


===15:44:45===
2026-04-26 15:44:41 >>>回调事件[910,devices/A0509]
2026-04-26 15:44:41 >>>故障排除日志:上一MQTT订单号缓存列表为2604261540440068652371
2026-04-26 15:44:41 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 15:44:41 开始打印,排队:232,票券:2604261544346215476901,订单:2604261544340060077569,[2026-04-26 15:44:40支付宝支付10元]
2026-04-26 15:44:41 开始打印,排队:233,票券:2604261544346215957902,订单:2604261544340060077569,[2026-04-26 15:44:40支付宝支付10元]
2026-04-26 15:44:41>>>MQTT票号同步场景，创建空订单对象
2026-04-26 15:44:41>>>合并MQTT票号列表到订单同步请求,共2张票


===15:45:45===
2026-04-26 15:44:44 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261544346215476901","queue_number":232,"trade_uid":"2604261544340060077569"},{"ticket_no":"2604261544346215957902","queue_number":233,"trade_uid":"2604261544340060077569"}]}
2026-04-26 15:44:44 >>>故障排除日志:删除未同步下发订单成功2604261544340060077569
2026-04-26 15:44:44 >>>故障排除日志:删除未同步下发订单成功2604261544340060077569
2026-04-26 15:44:44 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877215]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 15:45:00 >>>回调事件[910,devices/A0509]
2026-04-26 15:45:00 >>>故障排除日志:上一MQTT订单号缓存列表为2604261544340060077569|2604261544340060077569
2026-04-26 15:45:00 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 15:45:00 开始打印,排队:234,票券:2604261544428060623401,订单:2604261544420078382993,[2026-04-26 15:44:59微信支付10元]
2026-04-26 15:45:00>>>MQTT票号同步场景，创建空订单对象
2026-04-26 15:45:00>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 15:45:02 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261544428060623401","queue_number":234,"trade_uid":"2604261544420078382993"}]}
2026-04-26 15:45:02 >>>故障排除日志:删除未同步下发订单成功2604261544420078382993
2026-04-26 15:45:02 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877227]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 15:45:16 >>>回调事件[910,devices/A0509]
2026-04-26 15:45:16 >>>故障排除日志:上一MQTT订单号缓存列表为2604261544420078382993
2026-04-26 15:45:16 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 15:45:16 开始打印,排队:235,票券:2604261545099717672501,订单:2604261545090095209458,[2026-04-26 15:45:15微信支付10元]
2026-04-26 15:45:16>>>MQTT票号同步场景，创建空订单对象
2026-04-26 15:45:16>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 15:45:18 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261545099717672501","queue_number":235,"trade_uid":"2604261545090095209458"}]}
2026-04-26 15:45:18 >>>故障排除日志:删除未同步下发订单成功2604261545090095209458
2026-04-26 15:45:18 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877235]


===15:49:45===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 15:49:18 >>>回调事件[910,devices/A0509]
2026-04-26 15:49:18 >>>故障排除日志:上一MQTT订单号缓存列表为2604261545090095209458
2026-04-26 15:49:18 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 15:49:18 开始打印,排队:236,票券:2604261549103832196801,订单:2604261549100036229134,[2026-04-26 15:49:17微信支付10元]
2026-04-26 15:49:18>>>MQTT票号同步场景，创建空订单对象
2026-04-26 15:49:18>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 15:49:20 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261549103832196801","queue_number":236,"trade_uid":"2604261549100036229134"}]}
2026-04-26 15:49:20 >>>故障排除日志:删除未同步下发订单成功2604261549100036229134
2026-04-26 15:49:20 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877279]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 15:49:26 >>>回调事件[910,devices/A0509]
2026-04-26 15:49:26 >>>故障排除日志:上一MQTT订单号缓存列表为2604261549100036229134
2026-04-26 15:49:26 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 15:49:26 开始打印,排队:237,票券:2604261549198231695601,订单:2604261549190079126525,[2026-04-26 15:49:25微信支付10元]
2026-04-26 15:49:27>>>MQTT票号同步场景，创建空订单对象
2026-04-26 15:49:27>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 15:49:29 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261549198231695601","queue_number":237,"trade_uid":"2604261549190079126525"}]}
2026-04-26 15:49:29 >>>故障排除日志:删除未同步下发订单成功2604261549190079126525
2026-04-26 15:49:29 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877285]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 15:49:36 >>>回调事件[910,devices/A0509]
2026-04-26 15:49:36 >>>故障排除日志:上一MQTT订单号缓存列表为2604261549190079126525
2026-04-26 15:49:36 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 15:49:36 开始打印,排队:238,票券:2604261549255984856101,订单:2604261549250057738152,[2026-04-26 15:49:35微信支付10元]
2026-04-26 15:49:36>>>MQTT票号同步场景，创建空订单对象
2026-04-26 15:49:36>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 15:49:38 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261549255984856101","queue_number":238,"trade_uid":"2604261549250057738152"}]}
2026-04-26 15:49:38 >>>故障排除日志:删除未同步下发订单成功2604261549250057738152
2026-04-26 15:49:38 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877291]


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


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


===15:58:46===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 15:58:04 收到下发指令:排队号88>>>
2026-04-26 15:58:04 收到下发指令:叫号88>>>
2026-04-26 15:58:08 收到下发指令:排队号88>>>
2026-04-26 15:58:08 收到下发指令:叫号88>>>
2026-04-26 15:58:11 收到下发指令:排队号88>>>
2026-04-26 15:58:11 收到下发指令:叫号88>>>


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


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


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


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


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


===16:10:47===
2026-04-26 16:10:07 >>>回调事件[910,devices/A0509]
2026-04-26 16:10:07 >>>故障排除日志:上一MQTT订单号缓存列表为2604261609040028246579
2026-04-26 16:10:07 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 16:10:07 开始打印,排队:249,票券:2604261610030918065101,订单:2604261610030006943738,[2026-04-26 16:10:06支付宝支付10元]
2026-04-26 16:10:07 开始打印,排队:250,票券:2604261610030918517202,订单:2604261610030006943738,[2026-04-26 16:10:06支付宝支付10元]
2026-04-26 16:10:07>>>MQTT票号同步场景，创建空订单对象
2026-04-26 16:10:07>>>合并MQTT票号列表到订单同步请求,共2张票
2026-04-26 16:10:11 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261610030918065101","queue_number":249,"trade_uid":"2604261610030006943738"},{"ticket_no":"2604261610030918517202","queue_number":250,"trade_uid":"2604261610030006943738"}]}
2026-04-26 16:10:11 >>>故障排除日志:删除未同步下发订单成功2604261610030006943738
2026-04-26 16:10:11 >>>故障排除日志:删除未同步下发订单成功2604261610030006943738
2026-04-26 16:10:11 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877572]


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


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


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


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


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


===16:18:49===
2026-04-26 16:17:56>>>cash read=00
2026-04-26 16:17:57>>>cash read=01
2026-04-26 16:17:58>>>cash read=3E
2026-04-26 16:18:00>>>cash read=00
2026-04-26 16:18:01>>>cash read=29
2026-04-26 16:18:01 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 16:18:01>>>cash read=2F29
2026-04-26 16:18:03>>>cash read=3E
2026-04-26 16:18:04>>>cash read=00
2026-04-26 16:18:04>>>cash read=818F42
2026-04-26 16:18:04>>>cash write=02
2026-04-26 16:18:04 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 16:18:04>>>cash read=10
2026-04-26 16:18:04 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 16:18:04 当前产品价格10元，投币10元，打印小票中...
2026-04-26 16:18:04 >>>开始打印,排队号为255,订单号为2604261618040030509872
2026-04-26 16:18:05>>>订单2604261618040030509872写入成功,剩余空间为1679500,占用RAM为633.5537109375
删除未同步订单2604261618040030509872
2026-04-26 16:18:07>>>订单2604261618040030509872删除成功,剩余空间为1680000,占用RAM为644.5234375
检测订单目录中>>>
无未同步订单>>>
2026-04-26 16:18:07 >>>当前Ram内存为616.2578125
定时检测未同步订单启用[checkOrderNum=536877687]
2026-04-26 16:18:08>>>cash write=0C
2026-04-26 16:18:08>>>cash read=3E


===16:19:49===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 16:18:48 收到下发指令:排队号88>>>
2026-04-26 16:18:48 收到下发指令:叫号88>>>
2026-04-26 16:18:55 收到下发指令:排队号88>>>
2026-04-26 16:18:55 收到下发指令:叫号88>>>
2026-04-26 16:19:17 收到下发指令:排队号88>>>
2026-04-26 16:19:17 收到下发指令:叫号88>>>
2026-04-26 16:19:21 收到下发指令:排队号88>>>
2026-04-26 16:19:21 收到下发指令:叫号88>>>
2026-04-26 16:19:25 收到下发指令:排队号88>>>
2026-04-26 16:19:25 收到下发指令:叫号88>>>
2026-04-26 16:19:27 >>>回调事件[910,devices/A0509]
2026-04-26 16:19:27 >>>故障排除日志:上一MQTT订单号缓存列表为2604261616570068797249
2026-04-26 16:19:27 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 16:19:27 开始打印,排队:256,票券:2604261619198955565301,订单:2604261619190087655848,[2026-04-26 16:19:26微信支付10元]
2026-04-26 16:19:27 开始打印,排队:257,票券:2604261619198956085302,订单:2604261619190087655848,[2026-04-26 16:19:26微信支付10元]
2026-04-26 16:19:27>>>MQTT票号同步场景，创建空订单对象
2026-04-26 16:19:27>>>合并MQTT票号列表到订单同步请求,共2张票
2026-04-26 16:19:30 收到下发指令:排队号0>>>
2026-04-26 16:19:31 收到下发指令:叫号0>>>
2026-04-26 16:19:32 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261619198955565301","queue_number":256,"trade_uid":"2604261619190087655848"},{"ticket_no":"2604261619198956085302","queue_number":257,"trade_uid":"2604261619190087655848"}]}
2026-04-26 16:19:32 >>>故障排除日志:删除未同步下发订单成功2604261619190087655848
2026-04-26 16:19:32 >>>故障排除日志:删除未同步下发订单成功2604261619190087655848
2026-04-26 16:19:32 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877718]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 16:19:33 收到下发指令:排队号88>>>
2026-04-26 16:19:33 收到下发指令:叫号88>>>
2026-04-26 16:19:39 收到下发指令:排队号88>>>
2026-04-26 16:19:39 收到下发指令:叫号88>>>
2026-04-26 16:19:39 收到下发指令:排队号88>>>
2026-04-26 16:19:39 收到下发指令:叫号88>>>


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


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


===16:26:50===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 16:25:59 >>>回调事件[910,devices/A0509]
2026-04-26 16:25:59 >>>故障排除日志:上一MQTT订单号缓存列表为2604261625170063631657
2026-04-26 16:25:59 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 16:25:59 开始打印,排队:262,票券:2604261625537060959601,订单:2604261625530068591331,[2026-04-26 16:25:59微信支付10元]
2026-04-26 16:25:59>>>MQTT票号同步场景，创建空订单对象
2026-04-26 16:25:59>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 16:26:01 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261625537060959601","queue_number":262,"trade_uid":"2604261625530068591331"}]}
2026-04-26 16:26:01 >>>故障排除日志:删除未同步下发订单成功2604261625530068591331
2026-04-26 16:26:01 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877823]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 16:26:08 >>>回调事件[910,devices/A0509]
2026-04-26 16:26:08 >>>故障排除日志:上一MQTT订单号缓存列表为2604261625530068591331
2026-04-26 16:26:08 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 16:26:08 开始打印,排队:263,票券:2604261625597909677401,订单:2604261625590076811454,[2026-04-26 16:26:07微信支付10元]
2026-04-26 16:26:08>>>MQTT票号同步场景，创建空订单对象
2026-04-26 16:26:08>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 16:26:10 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261625597909677401","queue_number":263,"trade_uid":"2604261625590076811454"}]}
2026-04-26 16:26:10 >>>故障排除日志:删除未同步下发订单成功2604261625590076811454
2026-04-26 16:26:10 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877830]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 16:26:40 >>>回调事件[910,devices/A0509]
2026-04-26 16:26:40 >>>故障排除日志:上一MQTT订单号缓存列表为2604261625590076811454
2026-04-26 16:26:41 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 16:26:41 开始打印,排队:264,票券:2604261626315846308601,订单:2604261626310056271962,[2026-04-26 16:26:39微信支付10元]
2026-04-26 16:26:41>>>MQTT票号同步场景，创建空订单对象
2026-04-26 16:26:41>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 16:26:43 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261626315846308601","queue_number":264,"trade_uid":"2604261626310056271962"}]}
2026-04-26 16:26:43 >>>故障排除日志:删除未同步下发订单成功2604261626310056271962
2026-04-26 16:26:43 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877837]


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


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


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


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


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


===16:42:51===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 16:42:10 收到下发指令:排队号88>>>
2026-04-26 16:42:10 收到下发指令:叫号88>>>
2026-04-26 16:42:14 收到下发指令:排队号88>>>
2026-04-26 16:42:14 收到下发指令:叫号88>>>
2026-04-26 16:42:17 收到下发指令:排队号88>>>
2026-04-26 16:42:17 收到下发指令:叫号88>>>
2026-04-26 16:42:21 收到下发指令:排队号88>>>
2026-04-26 16:42:21 收到下发指令:叫号88>>>
2026-04-26 16:42:25 收到下发指令:排队号88>>>
2026-04-26 16:42:25 收到下发指令:叫号88>>>
2026-04-26 16:42:28 收到下发指令:排队号88>>>
2026-04-26 16:42:28 收到下发指令:叫号88>>>


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


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


===16:47:52===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 16:47:26 收到下发指令:排队号88>>>
2026-04-26 16:47:26 收到下发指令:叫号88>>>


===16:48:52===
2026-04-26 16:48:28 收到下发指令:排队号88>>>
2026-04-26 16:48:28 收到下发指令:叫号88>>>
2026-04-26 16:48:32 收到下发指令:排队号88>>>
2026-04-26 16:48:32 收到下发指令:叫号88>>>
2026-04-26 16:48:36 收到下发指令:排队号88>>>
2026-04-26 16:48:36 收到下发指令:叫号88>>>
2026-04-26 16:48:40 收到下发指令:排队号88>>>
2026-04-26 16:48:40 收到下发指令:叫号88>>>
2026-04-26 16:48:45 收到下发指令:排队号88>>>
2026-04-26 16:48:45 收到下发指令:叫号88>>>
2026-04-26 16:48:49 收到下发指令:排队号88>>>
2026-04-26 16:48:49 收到下发指令:叫号88>>>


===16:49:52===
2026-04-26 16:48:52 收到下发指令:排队号88>>>
2026-04-26 16:48:52 收到下发指令:叫号88>>>
2026-04-26 16:48:56 收到下发指令:排队号88>>>
2026-04-26 16:48:56 收到下发指令:叫号88>>>
2026-04-26 16:49:00 收到下发指令:排队号88>>>
2026-04-26 16:49:00 收到下发指令:叫号88>>>
2026-04-26 16:49:05 收到下发指令:排队号88>>>
2026-04-26 16:49:05 收到下发指令:叫号88>>>
2026-04-26 16:49:09 收到下发指令:排队号88>>>
2026-04-26 16:49:09 收到下发指令:叫号88>>>
2026-04-26 16:49:13 收到下发指令:排队号88>>>
2026-04-26 16:49:13 收到下发指令:叫号88>>>
2026-04-26 16:49:17 收到下发指令:排队号88>>>
2026-04-26 16:49:17 收到下发指令:叫号88>>>
2026-04-26 16:49:21 收到下发指令:排队号88>>>
2026-04-26 16:49:21 收到下发指令:叫号88>>>
2026-04-26 16:49:25 收到下发指令:排队号88>>>
2026-04-26 16:49:25 收到下发指令:叫号88>>>
2026-04-26 16:49:29 收到下发指令:排队号88>>>
2026-04-26 16:49:29 收到下发指令:叫号88>>>
2026-04-26 16:49:33 收到下发指令:排队号88>>>
2026-04-26 16:49:33 收到下发指令:叫号88>>>
2026-04-26 16:49:37 收到下发指令:排队号88>>>
2026-04-26 16:49:37 收到下发指令:叫号88>>>
2026-04-26 16:49:42 收到下发指令:排队号88>>>
2026-04-26 16:49:42 收到下发指令:叫号88>>>
2026-04-26 16:49:49 收到下发指令:排队号88>>>
2026-04-26 16:49:49 收到下发指令:叫号88>>>


===16:50:52===
2026-04-26 16:49:53 收到下发指令:排队号101>>>
2026-04-26 16:49:53 收到下发指令:叫号101>>>
2026-04-26 16:50:05 收到下发指令:排队号101>>>
2026-04-26 16:50:05 收到下发指令:叫号101>>>


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


===16:53:53===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 16:53:43 收到下发指令:排队号101>>>
2026-04-26 16:53:43 收到下发指令:叫号101>>>
2026-04-26 16:53:46 收到下发指令:排队号101>>>
2026-04-26 16:53:46 收到下发指令:叫号101>>>
2026-04-26 16:53:51 收到下发指令:排队号101>>>
2026-04-26 16:53:51 收到下发指令:叫号101>>>


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


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


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


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


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


===17:00:54===
2026-04-26 16:59:53 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261659435537822101","queue_number":280,"trade_uid":"2604261659430053149391"}]}
2026-04-26 16:59:53 >>>故障排除日志:删除未同步下发订单成功2604261659430053149391
2026-04-26 16:59:53 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878368]


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


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


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


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


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


===17:16:56===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 17:16:27 >>>回调事件[910,devices/A0509]
2026-04-26 17:16:27 >>>故障排除日志:上一MQTT订单号缓存列表为2604261711030085744282
2026-04-26 17:16:27 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 17:16:27 开始打印,排队:288,票券:2604261716192242455601,订单:2604261716190020444587,[2026-04-26 17:16:26微信支付10元]
2026-04-26 17:16:27 开始打印,排队:289,票券:2604261716192242828102,订单:2604261716190020444587,[2026-04-26 17:16:26微信支付10元]
2026-04-26 17:16:27>>>MQTT票号同步场景，创建空订单对象
2026-04-26 17:16:27>>>合并MQTT票号列表到订单同步请求,共2张票
2026-04-26 17:16:31 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261716192242455601","queue_number":288,"trade_uid":"2604261716190020444587"},{"ticket_no":"2604261716192242828102","queue_number":289,"trade_uid":"2604261716190020444587"}]}
2026-04-26 17:16:31 >>>故障排除日志:删除未同步下发订单成功2604261716190020444587
2026-04-26 17:16:31 >>>故障排除日志:删除未同步下发订单成功2604261716190020444587
2026-04-26 17:16:31 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878570]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 17:16:46 >>>回调事件[910,devices/A0509]
2026-04-26 17:16:46 >>>故障排除日志:上一MQTT订单号缓存列表为2604261716190020444587|2604261716190020444587
2026-04-26 17:16:46 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 17:16:46 开始打印,排队:290,票券:2604261716383377267401,订单:2604261716380031702498,[2026-04-26 17:16:45支付宝支付10元]
2026-04-26 17:16:47>>>MQTT票号同步场景，创建空订单对象
2026-04-26 17:16:47>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 17:16:48 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261716383377267401","queue_number":290,"trade_uid":"2604261716380031702498"}]}
2026-04-26 17:16:48 >>>故障排除日志:删除未同步下发订单成功2604261716380031702498
2026-04-26 17:16:49 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878576]


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


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


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


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


===17:29:59===
2026-04-26 17:29:53>>>cash read=00
2026-04-26 17:29:54>>>cash read=818F43
2026-04-26 17:29:54>>>cash write=02
2026-04-26 17:29:54 >>>回调事件130,cash_status,10022,进钞中...read money=20
2026-04-26 17:29:54>>>cash read=10
2026-04-26 17:29:54 >>>回调事件130,20,10023,finish Money=20,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 17:29:54 当前产品价格10元，投币20元，打印小票中...
2026-04-26 17:29:54 >>>开始打印,排队号为295,订单号为2604261729540030509649
2026-04-26 17:29:55 >>>开始打印,排队号为296,订单号为2604261729540030509649
2026-04-26 17:29:55>>>订单2604261729540030509649写入成功,剩余空间为1679000,占用RAM为640.2294921875


===17:30:59===
删除未同步订单2604261729540030509649
2026-04-26 17:29:58>>>订单2604261729540030509649删除成功,剩余空间为1681500,占用RAM为661.2197265625
检测订单目录中>>>
无未同步订单>>>
2026-04-26 17:29:59 >>>当前Ram内存为615.2353515625
定时检测未同步订单启用[checkOrderNum=536878741]
2026-04-26 17:29:59>>>cash write=0C
2026-04-26 17:30:00>>>cash read=3E
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 17:30:26 收到下发指令:排队号101>>>
2026-04-26 17:30:26 收到下发指令:叫号101>>>
2026-04-26 17:30:29 收到下发指令:排队号101>>>
2026-04-26 17:30:29 收到下发指令:叫号101>>>
2026-04-26 17:30:30 收到下发指令:排队号101>>>
2026-04-26 17:30:30 收到下发指令:叫号101>>>
2026-04-26 17:30:31 收到下发指令:排队号101>>>
2026-04-26 17:30:31 收到下发指令:叫号101>>>
2026-04-26 17:30:32 收到下发指令:排队号101>>>
2026-04-26 17:30:32 收到下发指令:叫号101>>>
2026-04-26 17:30:36 收到下发指令:排队号101>>>
2026-04-26 17:30:36 收到下发指令:叫号101>>>
2026-04-26 17:30:40 收到下发指令:排队号101>>>
2026-04-26 17:30:40 收到下发指令:叫号101>>>
2026-04-26 17:30:44 收到下发指令:排队号101>>>
2026-04-26 17:30:44 收到下发指令:叫号101>>>
2026-04-26 17:30:46 收到下发指令:排队号101>>>
2026-04-26 17:30:46 收到下发指令:叫号101>>>
2026-04-26 17:30:48 收到下发指令:排队号101>>>
2026-04-26 17:30:48 收到下发指令:叫号101>>>
2026-04-26 17:30:50 收到下发指令:排队号101>>>
2026-04-26 17:30:50 收到下发指令:叫号101>>>
2026-04-26 17:30:52 收到下发指令:排队号101>>>
2026-04-26 17:30:52 收到下发指令:叫号101>>>
2026-04-26 17:30:53 收到下发指令:排队号101>>>
2026-04-26 17:30:53 收到下发指令:叫号101>>>
2026-04-26 17:30:56 收到下发指令:排队号101>>>
2026-04-26 17:30:56 收到下发指令:叫号101>>>


===17:32:00===
2026-04-26 17:30:59 收到下发指令:排队号101>>>
2026-04-26 17:30:59 收到下发指令:叫号101>>>
2026-04-26 17:31:00 收到下发指令:排队号101>>>
2026-04-26 17:31:00 收到下发指令:叫号101>>>
2026-04-26 17:31:03 收到下发指令:排队号101>>>
2026-04-26 17:31:03 收到下发指令:叫号101>>>
2026-04-26 17:31:03 收到下发指令:排队号101>>>
2026-04-26 17:31:03 收到下发指令:叫号101>>>
2026-04-26 17:31:07 收到下发指令:排队号101>>>
2026-04-26 17:31:07 收到下发指令:叫号101>>>
2026-04-26 17:31:11 收到下发指令:排队号101>>>
2026-04-26 17:31:11 收到下发指令:叫号101>>>
2026-04-26 17:31:14 收到下发指令:排队号101>>>
2026-04-26 17:31:14 收到下发指令:叫号101>>>
2026-04-26 17:31:17 收到下发指令:排队号101>>>
2026-04-26 17:31:17 收到下发指令:叫号101>>>
2026-04-26 17:31:21 收到下发指令:排队号101>>>
2026-04-26 17:31:21 收到下发指令:叫号101>>>
2026-04-26 17:31:24 收到下发指令:排队号101>>>
2026-04-26 17:31:24 收到下发指令:叫号101>>>
2026-04-26 17:31:29 收到下发指令:排队号101>>>
2026-04-26 17:31:29 收到下发指令:叫号101>>>
2026-04-26 17:31:33 收到下发指令:排队号101>>>
2026-04-26 17:31:33 收到下发指令:叫号101>>>
2026-04-26 17:31:36 收到下发指令:排队号101>>>
2026-04-26 17:31:36 收到下发指令:叫号101>>>
2026-04-26 17:31:41 收到下发指令:排队号101>>>
2026-04-26 17:31:41 收到下发指令:叫号101>>>
2026-04-26 17:31:45 收到下发指令:排队号101>>>
2026-04-26 17:31:45 收到下发指令:叫号101>>>
2026-04-26 17:31:49 收到下发指令:排队号101>>>
2026-04-26 17:31:49 收到下发指令:叫号101>>>
2026-04-26 17:31:55 收到下发指令:排队号101>>>
2026-04-26 17:31:55 收到下发指令:叫号101>>>
2026-04-26 17:31:58 收到下发指令:排队号101>>>
2026-04-26 17:31:58 收到下发指令:叫号101>>>


===17:33:00===
2026-04-26 17:32:02 收到下发指令:排队号101>>>
2026-04-26 17:32:02 收到下发指令:叫号101>>>
2026-04-26 17:32:06 收到下发指令:排队号101>>>
2026-04-26 17:32:06 收到下发指令:叫号101>>>
2026-04-26 17:32:10 收到下发指令:排队号101>>>
2026-04-26 17:32:10 收到下发指令:叫号101>>>
2026-04-26 17:32:14 收到下发指令:排队号101>>>
2026-04-26 17:32:14 收到下发指令:叫号101>>>
2026-04-26 17:32:20 收到下发指令:排队号101>>>
2026-04-26 17:32:20 收到下发指令:叫号101>>>
2026-04-26 17:32:24 收到下发指令:排队号101>>>
2026-04-26 17:32:24 收到下发指令:叫号101>>>


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


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


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


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


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


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


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


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


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


===17:59:02===
2026-04-26 17:58:44>>>cash read=0A
2026-04-26 17:58:45>>>cash read=3E


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


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


===18:06:03===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 18:05:33 收到下发指令:排队号101>>>
2026-04-26 18:05:33 收到下发指令:叫号101>>>
2026-04-26 18:05:36 收到下发指令:排队号101>>>
2026-04-26 18:05:36 收到下发指令:叫号101>>>
2026-04-26 18:05:44 收到下发指令:排队号101>>>
2026-04-26 18:05:44 收到下发指令:叫号101>>>
2026-04-26 18:05:48 收到下发指令:排队号101>>>
2026-04-26 18:05:48 收到下发指令:叫号101>>>
2026-04-26 18:05:59 收到下发指令:排队号101>>>
2026-04-26 18:05:59 收到下发指令:叫号101>>>


===18:07:03===
2026-04-26 18:06:38>>>cash read=00
2026-04-26 18:06:38>>>cash read=818F42
2026-04-26 18:06:38>>>cash write=02
2026-04-26 18:06:38 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 18:06:39>>>cash read=10
2026-04-26 18:06:39 >>>回调事件130,10,10023,finish Money=10,进钞完成
2026-04-26 18:06:39 当前产品价格10元，投币10元，打印小票中...
2026-04-26 18:06:39 >>>开始打印,排队号为311,订单号为2604261806390030509929
2026-04-26 18:06:39>>>订单2604261806390030509929写入成功,剩余空间为1680000,占用RAM为630.9091796875
删除未同步订单2604261806390030509929
2026-04-26 18:06:41>>>订单2604261806390030509929删除成功,剩余空间为1680500,占用RAM为641.7060546875
检测订单目录中>>>
无未同步订单>>>
2026-04-26 18:06:41 >>>当前Ram内存为614.037109375
定时检测未同步订单启用[checkOrderNum=536879251]
2026-04-26 18:06:42>>>cash write=0C
2026-04-26 18:06:42>>>cash read=3E


===18:09:03===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 18:08:13 >>>回调事件[910,devices/A0509]
2026-04-26 18:08:13 >>>故障排除日志:上一MQTT订单号缓存列表为2604261802310025521792
2026-04-26 18:08:13 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 18:08:13 开始打印,排队:312,票券:2604261808046478193101,订单:2604261808040062323429,[2026-04-26 18:08:12微信支付10元]
2026-04-26 18:08:13>>>MQTT票号同步场景，创建空订单对象
2026-04-26 18:08:13>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 18:08:15 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261808046478193101","queue_number":312,"trade_uid":"2604261808040062323429"}]}
2026-04-26 18:08:15 >>>故障排除日志:删除未同步下发订单成功2604261808040062323429
2026-04-26 18:08:15 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536879276]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 18:08:30 >>>回调事件[910,devices/A0509]
2026-04-26 18:08:30 >>>故障排除日志:上一MQTT订单号缓存列表为2604261808040062323429
2026-04-26 18:08:30 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 18:08:30 开始打印,排队:313,票券:2604261808236490953801,订单:2604261808230062870436,[2026-04-26 18:08:29微信支付10元]
2026-04-26 18:08:31>>>MQTT票号同步场景，创建空订单对象
2026-04-26 18:08:31>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 18:08:32 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261808236490953801","queue_number":313,"trade_uid":"2604261808230062870436"}]}
2026-04-26 18:08:32 >>>故障排除日志:删除未同步下发订单成功2604261808230062870436
2026-04-26 18:08:32 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536879283]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 18:08:56 >>>回调事件[910,devices/A0509]
2026-04-26 18:08:56 >>>故障排除日志:上一MQTT订单号缓存列表为2604261808230062870436
2026-04-26 18:08:56 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 18:08:56 开始打印,排队:314,票券:2604261808505840653401,订单:2604261808500055313638,[2026-04-26 18:08:55微信支付10元]
2026-04-26 18:08:56>>>MQTT票号同步场景，创建空订单对象
2026-04-26 18:08:56>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 18:08:58 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261808505840653401","queue_number":314,"trade_uid":"2604261808500055313638"}]}
2026-04-26 18:08:58 >>>故障排除日志:删除未同步下发订单成功2604261808500055313638
2026-04-26 18:08:58 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536879295]


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


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


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


===18:19:04===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 18:18:06 >>>回调事件[910,devices/A0509]
2026-04-26 18:18:06 >>>故障排除日志:上一MQTT订单号缓存列表为2604261812460010148591
2026-04-26 18:18:06 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 18:18:06 开始打印,排队:320,票券:2604261817569265685401,订单:2604261817560090886683,[2026-04-26 18:18:04微信支付10元]
2026-04-26 18:18:07>>>MQTT票号同步场景，创建空订单对象
2026-04-26 18:18:07>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 18:18:08 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261817569265685401","queue_number":320,"trade_uid":"2604261817560090886683"}]}
2026-04-26 18:18:08 >>>故障排除日志:删除未同步下发订单成功2604261817560090886683
2026-04-26 18:18:08 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536879416]
2026-04-26 18:18:45>>>cash read=00
2026-04-26 18:18:45>>>cash read=818F42
2026-04-26 18:18:45>>>cash write=02
2026-04-26 18:18:45 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 18:18:46>>>cash read=10
2026-04-26 18:18:46 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 18:18:46 当前产品价格10元，投币10元，打印小票中...
2026-04-26 18:18:46 >>>开始打印,排队号为321,订单号为2604261818460030509111
2026-04-26 18:18:46>>>订单2604261818460030509111写入成功,剩余空间为1678500,占用RAM为639.94140625
删除未同步订单2604261818460030509111
2026-04-26 18:18:48>>>订单2604261818460030509111删除成功,剩余空间为1679500,占用RAM为646.3916015625
检测订单目录中>>>
无未同步订单>>>
2026-04-26 18:18:48 >>>当前Ram内存为616.80078125
定时检测未同步订单启用[checkOrderNum=536879424]
2026-04-26 18:18:49>>>cash write=0C
2026-04-26 18:18:49>>>cash read=3E


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


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


===18:24:05===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 18:23:22 >>>回调事件[910,devices/A0509]
2026-04-26 18:23:22 >>>故障排除日志:上一MQTT订单号缓存列表为2604261821470099997848
2026-04-26 18:23:22 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 18:23:22 开始打印,排队:324,票券:2604261823136052755901,订单:2604261823130058175161,[2026-04-26 18:23:21微信支付10元]
2026-04-26 18:23:22>>>MQTT票号同步场景，创建空订单对象
2026-04-26 18:23:22>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 18:23:24 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261823136052755901","queue_number":324,"trade_uid":"2604261823130058175161"}]}
2026-04-26 18:23:24 >>>故障排除日志:删除未同步下发订单成功2604261823130058175161
2026-04-26 18:23:24 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536879493]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 18:23:45 >>>回调事件[910,devices/A0509]
2026-04-26 18:23:45 >>>故障排除日志:上一MQTT订单号缓存列表为2604261823130058175161
2026-04-26 18:23:45 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 18:23:45 开始打印,排队:325,票券:2604261823299040942401,订单:2604261823290088343425,[2026-04-26 18:23:43微信支付10元]
2026-04-26 18:23:45>>>MQTT票号同步场景，创建空订单对象
2026-04-26 18:23:45>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 18:23:47 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261823299040942401","queue_number":325,"trade_uid":"2604261823290088343425"}]}
2026-04-26 18:23:47 >>>故障排除日志:删除未同步下发订单成功2604261823290088343425
2026-04-26 18:23:47 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536879499]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 18:23:56 >>>回调事件[910,devices/A0509]
2026-04-26 18:23:56 >>>故障排除日志:上一MQTT订单号缓存列表为2604261823290088343425
2026-04-26 18:23:56 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 18:23:56 开始打印,排队:326,票券:2604261823505753795901,订单:2604261823500055648883,[2026-04-26 18:23:55微信支付10元]
2026-04-26 18:23:56 开始打印,排队:327,票券:2604261823505754187502,订单:2604261823500055648883,[2026-04-26 18:23:55微信支付10元]
2026-04-26 18:23:56>>>MQTT票号同步场景，创建空订单对象
2026-04-26 18:23:56>>>合并MQTT票号列表到订单同步请求,共2张票
2026-04-26 18:23:59 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261823505753795901","queue_number":326,"trade_uid":"2604261823500055648883"},{"ticket_no":"2604261823505754187502","queue_number":327,"trade_uid":"2604261823500055648883"}]}
2026-04-26 18:23:59 >>>故障排除日志:删除未同步下发订单成功2604261823500055648883
2026-04-26 18:23:59 >>>故障排除日志:删除未同步下发订单成功2604261823500055648883
2026-04-26 18:24:00 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536879511]


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


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


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


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


===18:31:06===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 18:30:28 >>>回调事件[910,devices/A0509]
2026-04-26 18:30:28 >>>故障排除日志:上一MQTT订单号缓存列表为2604261829460011650048
2026-04-26 18:30:28 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 18:30:28 开始打印,排队:332,票券:2604261830209297732501,订单:2604261830200090690012,[2026-04-26 18:30:27微信支付10元]
2026-04-26 18:30:28>>>MQTT票号同步场景，创建空订单对象
2026-04-26 18:30:28>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 18:30:30 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261830209297732501","queue_number":332,"trade_uid":"2604261830200090690012"}]}
2026-04-26 18:30:30 >>>故障排除日志:删除未同步下发订单成功2604261830200090690012
2026-04-26 18:30:30 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536879608]
2026-04-26 18:30:51>>>cash read=00
2026-04-26 18:30:51>>>cash read=818F42
2026-04-26 18:30:51>>>cash write=02
2026-04-26 18:30:51 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 18:30:52>>>cash read=10
2026-04-26 18:30:52 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 18:30:52 当前产品价格10元，投币10元，打印小票中...
2026-04-26 18:30:52 >>>开始打印,排队号为333,订单号为2604261830520030509261
2026-04-26 18:30:52>>>订单2604261830520030509261写入成功,剩余空间为1678500,占用RAM为639.4228515625
删除未同步订单2604261830520030509261
2026-04-26 18:30:54>>>订单2604261830520030509261删除成功,剩余空间为1679500,占用RAM为650.927734375
检测订单目录中>>>
无未同步订单>>>
2026-04-26 18:30:55 >>>当前Ram内存为618.240234375
定时检测未同步订单启用[checkOrderNum=536879616]
2026-04-26 18:30:56>>>cash write=0C
2026-04-26 18:30:56>>>cash read=3E


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


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


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


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


===18:39:07===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 18:38:45 >>>回调事件[910,devices/A0509]
2026-04-26 18:38:45 >>>故障排除日志:上一MQTT订单号缓存列表为2604261836360056863861
2026-04-26 18:38:45 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 18:38:46 开始打印,排队:339,票券:2604261838419443222501,订单:2604261838410092286773,[2026-04-26 18:38:44支付宝支付10元]
2026-04-26 18:38:46>>>MQTT票号同步场景，创建空订单对象
2026-04-26 18:38:46>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 18:38:47 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261838419443222501","queue_number":339,"trade_uid":"2604261838410092286773"}]}
2026-04-26 18:38:47 >>>故障排除日志:删除未同步下发订单成功2604261838410092286773
2026-04-26 18:38:48 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536879733]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 18:38:59 >>>回调事件[910,devices/A0509]
2026-04-26 18:38:59 >>>故障排除日志:上一MQTT订单号缓存列表为2604261838410092286773
2026-04-26 18:38:59 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 18:38:59 开始打印,排队:340,票券:2604261838528075034601,订单:2604261838520078283839,[2026-04-26 18:38:58微信支付10元]
2026-04-26 18:38:59>>>MQTT票号同步场景，创建空订单对象
2026-04-26 18:38:59>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 18:39:01 >>>回调事件[910,devices/A0509]
2026-04-26 18:39:01 >>>故障排除日志:上一MQTT订单号缓存列表为2604261838520078283839
2026-04-26 18:39:01 >>>故障排除日志:终端未同步成功订单列表03402604261838520078283839
已接收过此消息,票券号为2604261838528075034601,排队号为340
2026-04-26 18:39:01 开始打印,排队:341,票券:2604261838538186785301,订单:2604261838530079395578,[2026-04-26 18:38:59支付宝支付10元]
2026-04-26 18:39:01>>>HTTP请求进行中，跳过本次同步
2026-04-26 18:39:03 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261838528075034601","queue_number":340,"trade_uid":"2604261838520078283839"}]}
2026-04-26 18:39:03 >>>故障排除日志:删除未同步下发订单成功2604261838520078283839
2026-04-26 18:39:03 >>>故障排除日志:终端同步成功后剩余订单列表03412604261838530079395578
定时检测未同步订单启用[checkOrderNum=536879749]


===18:42:07===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 18:42:00 >>>回调事件[910,devices/A0509]
2026-04-26 18:42:00 >>>故障排除日志:上一MQTT订单号缓存列表为2604261838520078283839|2604261838530079395578
2026-04-26 18:42:00 >>>故障排除日志:终端未同步成功订单列表03412604261838530079395578
已接收过此消息,票券号为2604261838538186785301,排队号为341
2026-04-26 18:42:00 开始打印,排队:342,票券:2604261841531850416801,订单:2604261841530015204654,[2026-04-26 18:42:00微信支付10元]
2026-04-26 18:42:01>>>MQTT票号同步场景，创建空订单对象
2026-04-26 18:42:01>>>合并MQTT票号列表到订单同步请求,共2张票
2026-04-26 18:42:03 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261838538186785301","queue_number":341,"trade_uid":"2604261838530079395578"},{"ticket_no":"2604261841531850416801","queue_number":342,"trade_uid":"2604261841530015204654"}]}
2026-04-26 18:42:03 >>>故障排除日志:删除未同步下发订单成功2604261838530079395578
2026-04-26 18:42:03 >>>故障排除日志:删除未同步下发订单成功2604261841530015204654
2026-04-26 18:42:03 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536879784]


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


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


===18:46:08===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 18:45:36 >>>回调事件[910,devices/A0509]
2026-04-26 18:45:36 >>>故障排除日志:上一MQTT订单号缓存列表为2604261844310093928642
2026-04-26 18:45:36 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 18:45:36 开始打印,排队:345,票券:2604261845291047727501,订单:2604261845290008484748,[2026-04-26 18:45:35微信支付10元]
2026-04-26 18:45:36>>>MQTT票号同步场景，创建空订单对象
2026-04-26 18:45:36>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 18:45:38 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261845291047727501","queue_number":345,"trade_uid":"2604261845290008484748"}]}
2026-04-26 18:45:38 >>>故障排除日志:删除未同步下发订单成功2604261845290008484748
2026-04-26 18:45:38 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536879836]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 18:45:39 >>>回调事件[910,devices/A0509]
2026-04-26 18:45:39 >>>故障排除日志:上一MQTT订单号缓存列表为2604261845290008484748
2026-04-26 18:45:39 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 18:45:39 开始打印,排队:346,票券:2604261845303818998101,订单:2604261845300036103734,[2026-04-26 18:45:38微信支付10元]
2026-04-26 18:45:39>>>MQTT票号同步场景，创建空订单对象
2026-04-26 18:45:39>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 18:45:41 >>>回调事件[910,devices/A0509]
2026-04-26 18:45:41 >>>故障排除日志:上一MQTT订单号缓存列表为2604261845300036103734
2026-04-26 18:45:41 >>>故障排除日志:终端未同步成功订单列表03462604261845300036103734
已接收过此消息,票券号为2604261845303818998101,排队号为346
2026-04-26 18:45:41 开始打印,排队:347,票券:2604261845351596372401,订单:2604261845350013041679,[2026-04-26 18:45:40微信支付10元]
2026-04-26 18:45:41>>>HTTP请求进行中，跳过本次同步
2026-04-26 18:45:43 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261845303818998101","queue_number":346,"trade_uid":"2604261845300036103734"}]}
2026-04-26 18:45:43 >>>故障排除日志:删除未同步下发订单成功2604261845300036103734
2026-04-26 18:45:43 >>>故障排除日志:终端同步成功后剩余订单列表03472604261845350013041679
定时检测未同步订单启用[checkOrderNum=536879844]


===18:47:08===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 18:46:36 >>>回调事件[910,devices/A0509]
2026-04-26 18:46:36 >>>故障排除日志:上一MQTT订单号缓存列表为2604261845300036103734|2604261845350013041679
2026-04-26 18:46:36 >>>故障排除日志:终端未同步成功订单列表03472604261845350013041679
已接收过此消息,票券号为2604261845351596372401,排队号为347
2026-04-26 18:46:36 开始打印,排队:348,票券:2604261846293302681801,订单:2604261846290031103612,[2026-04-26 18:46:36微信支付10元]
2026-04-26 18:46:36>>>MQTT票号同步场景，创建空订单对象
2026-04-26 18:46:36>>>合并MQTT票号列表到订单同步请求,共2张票
2026-04-26 18:46:38 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261845351596372401","queue_number":347,"trade_uid":"2604261845350013041679"},{"ticket_no":"2604261846293302681801","queue_number":348,"trade_uid":"2604261846290031103612"}]}
2026-04-26 18:46:38 >>>故障排除日志:删除未同步下发订单成功2604261845350013041679
2026-04-26 18:46:38 >>>故障排除日志:删除未同步下发订单成功2604261846290031103612
2026-04-26 18:46:38 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536879861]


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


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


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


===18:55:09===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 18:54:54 >>>回调事件[910,devices/A0509]
2026-04-26 18:54:54 >>>故障排除日志:上一MQTT订单号缓存列表为2604261851430038120392
2026-04-26 18:54:54 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 18:54:54 开始打印,排队:355,票券:2604261854460716289301,订单:2604261854460005435494,[2026-04-26 18:54:53支付宝支付10元]
2026-04-26 18:54:54>>>MQTT票号同步场景，创建空订单对象
2026-04-26 18:54:54>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 18:54:56 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261854460716289301","queue_number":355,"trade_uid":"2604261854460005435494"}]}
2026-04-26 18:54:56 >>>故障排除日志:删除未同步下发订单成功2604261854460005435494
2026-04-26 18:54:56 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536879977]
2026-04-26 18:55:01>>>cash read=00
2026-04-26 18:55:01>>>cash read=818F42
2026-04-26 18:55:01>>>cash write=02
2026-04-26 18:55:01 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 18:55:02>>>cash read=10
2026-04-26 18:55:02 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 18:55:02 当前产品价格10元，投币10元，打印小票中...
2026-04-26 18:55:02 >>>开始打印,排队号为356,订单号为2604261855020030509843
2026-04-26 18:55:02>>>订单2604261855020030509843写入成功,剩余空间为1678500,占用RAM为640.7353515625
删除未同步订单2604261855020030509843
2026-04-26 18:55:04>>>订单2604261855020030509843删除成功,剩余空间为1679500,占用RAM为647.4189453125
检测订单目录中>>>
无未同步订单>>>
2026-04-26 18:55:04 >>>当前Ram内存为616.6552734375
定时检测未同步订单启用[checkOrderNum=536879992]
2026-04-26 18:55:05>>>cash write=0C
2026-04-26 18:55:05>>>cash read=3E


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


===19:22:13===
2026-04-26 19:22:12>>>cash read=0A


===19:23:14===
2026-04-26 19:22:14>>>cash read=3E


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


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


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


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


===19:32:15===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:31:24 收到下发指令:排队号101>>>
2026-04-26 19:31:24 收到下发指令:叫号101>>>
2026-04-26 19:31:28 收到下发指令:排队号101>>>
2026-04-26 19:31:28 收到下发指令:叫号101>>>
2026-04-26 19:31:32 >>>回调事件[910,devices/A0509]
2026-04-26 19:31:32 >>>故障排除日志:上一MQTT订单号缓存列表为2604261928550058163769
2026-04-26 19:31:32 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 19:31:32 开始打印,排队:386,票券:2604261931268060194701,订单:2604261931260078892247,[2026-04-26 19:31:32微信支付10元]
2026-04-26 19:31:32>>>MQTT票号同步场景，创建空订单对象
2026-04-26 19:31:32>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 19:31:34 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261931268060194701","queue_number":386,"trade_uid":"2604261931260078892247"}]}
2026-04-26 19:31:34 >>>故障排除日志:删除未同步下发订单成功2604261931260078892247
2026-04-26 19:31:35 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536880544]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:31:41 收到下发指令:排队号101>>>
2026-04-26 19:31:41 收到下发指令:叫号101>>>
2026-04-26 19:31:45 收到下发指令:排队号101>>>
2026-04-26 19:31:45 收到下发指令:叫号101>>>
2026-04-26 19:31:48 收到下发指令:排队号101>>>
2026-04-26 19:31:48 收到下发指令:叫号101>>>
2026-04-26 19:31:52 收到下发指令:排队号101>>>
2026-04-26 19:31:52 收到下发指令:叫号101>>>
2026-04-26 19:31:56 收到下发指令:排队号101>>>
2026-04-26 19:31:56 收到下发指令:叫号101>>>
2026-04-26 19:32:00 收到下发指令:排队号101>>>
2026-04-26 19:32:00 收到下发指令:叫号101>>>
2026-04-26 19:32:05 收到下发指令:排队号101>>>
2026-04-26 19:32:05 收到下发指令:叫号101>>>
2026-04-26 19:32:09 收到下发指令:排队号101>>>
2026-04-26 19:32:09 收到下发指令:叫号101>>>
2026-04-26 19:32:12 收到下发指令:排队号101>>>
2026-04-26 19:32:12 收到下发指令:叫号101>>>


===19:33:15===
2026-04-26 19:32:16 收到下发指令:排队号101>>>
2026-04-26 19:32:16 收到下发指令:叫号101>>>
2026-04-26 19:32:33 收到下发指令:排队号101>>>
2026-04-26 19:32:33 收到下发指令:叫号101>>>
2026-04-26 19:32:39 收到下发指令:排队号101>>>
2026-04-26 19:32:39 收到下发指令:叫号101>>>
2026-04-26 19:32:43 收到下发指令:排队号101>>>
2026-04-26 19:32:43 收到下发指令:叫号101>>>
2026-04-26 19:32:48 收到下发指令:排队号101>>>
2026-04-26 19:32:48 收到下发指令:叫号101>>>
2026-04-26 19:32:53 收到下发指令:排队号101>>>
2026-04-26 19:32:53 收到下发指令:叫号101>>>
2026-04-26 19:32:56 收到下发指令:排队号101>>>
2026-04-26 19:32:56 收到下发指令:叫号101>>>
2026-04-26 19:33:00 收到下发指令:排队号101>>>
2026-04-26 19:33:00 收到下发指令:叫号101>>>
2026-04-26 19:33:04 收到下发指令:排队号101>>>
2026-04-26 19:33:04 收到下发指令:叫号101>>>
2026-04-26 19:33:10 收到下发指令:排队号101>>>
2026-04-26 19:33:10 收到下发指令:叫号101>>>
2026-04-26 19:33:13 收到下发指令:排队号101>>>
2026-04-26 19:33:13 收到下发指令:叫号101>>>


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


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


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


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


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


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


===19:41:18===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:40:26 收到下发指令:排队号101>>>
2026-04-26 19:40:26 收到下发指令:叫号101>>>
2026-04-26 19:40:30 收到下发指令:排队号101>>>
2026-04-26 19:40:30 收到下发指令:叫号101>>>


===19:42:19===
2026-04-26 19:41:23>>>cash read=00
2026-04-26 19:41:23>>>cash read=818F42
2026-04-26 19:41:23>>>cash write=02
2026-04-26 19:41:23 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 19:41:24>>>cash read=10
2026-04-26 19:41:24 >>>回调事件130,10,10023,finish Money=10,进钞完成
2026-04-26 19:41:24 当前产品价格10元，投币10元，打印小票中...
2026-04-26 19:41:24 >>>开始打印,排队号为392,订单号为2604261941240030509975
2026-04-26 19:41:24>>>订单2604261941240030509975写入成功,剩余空间为1680000,占用RAM为631.2021484375
删除未同步订单2604261941240030509975
2026-04-26 19:41:26>>>订单2604261941240030509975删除成功,剩余空间为1680500,占用RAM为642.21875
检测订单目录中>>>
无未同步订单>>>
2026-04-26 19:41:26 >>>当前Ram内存为614.7255859375
定时检测未同步订单启用[checkOrderNum=536880746]
2026-04-26 19:41:27>>>cash write=0C
2026-04-26 19:41:27>>>cash read=3E
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:41:47 >>>回调事件[910,devices/A0509]
2026-04-26 19:41:47 >>>故障排除日志:上一MQTT订单号缓存列表为2604261938580096959865
2026-04-26 19:41:47 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 19:41:47 开始打印,排队:393,票券:2604261941383177695401,订单:2604261941380028673341,[2026-04-26 19:41:46支付宝支付10元]
2026-04-26 19:41:47>>>MQTT票号同步场景，创建空订单对象
2026-04-26 19:41:47>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 19:41:49 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261941383177695401","queue_number":393,"trade_uid":"2604261941380028673341"}]}
2026-04-26 19:41:49 >>>故障排除日志:删除未同步下发订单成功2604261941380028673341
2026-04-26 19:41:49 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536880753]


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


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


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


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


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


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


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


===20:03:22===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 20:02:35 收到下发指令:排队号101>>>
2026-04-26 20:02:35 收到下发指令:叫号101>>>
2026-04-26 20:02:39 收到下发指令:排队号101>>>
2026-04-26 20:02:39 收到下发指令:叫号101>>>
2026-04-26 20:02:43 收到下发指令:排队号101>>>
2026-04-26 20:02:43 收到下发指令:叫号101>>>
2026-04-26 20:02:44 >>>回调事件[910,devices/A0509]
2026-04-26 20:02:44 >>>故障排除日志:上一MQTT订单号缓存列表为2604261957280007636352
2026-04-26 20:02:44 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 20:02:44 开始打印,排队:405,票券:2604262002353365208401,订单:2604262002350031615538,[2026-04-26 20:02:43微信支付10元]
2026-04-26 20:02:44>>>MQTT票号同步场景，创建空订单对象
2026-04-26 20:02:44>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 20:02:46 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604262002353365208401","queue_number":405,"trade_uid":"2604262002350031615538"}]}
2026-04-26 20:02:46 >>>故障排除日志:删除未同步下发订单成功2604262002350031615538
2026-04-26 20:02:46 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536881035]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 20:02:47 收到下发指令:排队号101>>>
2026-04-26 20:02:47 收到下发指令:叫号101>>>
2026-04-26 20:02:51 收到下发指令:排队号101>>>
2026-04-26 20:02:51 收到下发指令:叫号101>>>
2026-04-26 20:02:52 >>>回调事件[910,devices/A0509]
2026-04-26 20:02:52 >>>故障排除日志:上一MQTT订单号缓存列表为2604262002350031615538
2026-04-26 20:02:52 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 20:02:52 开始打印,排队:406,票券:2604262002423506573901,订单:2604262002420033131534,[2026-04-26 20:02:51微信支付10元]
2026-04-26 20:02:52>>>MQTT票号同步场景，创建空订单对象
2026-04-26 20:02:52>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 20:02:54 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604262002423506573901","queue_number":406,"trade_uid":"2604262002420033131534"}]}
2026-04-26 20:02:54 >>>故障排除日志:删除未同步下发订单成功2604262002420033131534
2026-04-26 20:02:54 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536881044]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 20:02:55 收到下发指令:排队号101>>>
2026-04-26 20:02:55 收到下发指令:叫号101>>>
2026-04-26 20:02:58 收到下发指令:排队号101>>>
2026-04-26 20:02:58 收到下发指令:叫号101>>>
2026-04-26 20:03:03 收到下发指令:排队号101>>>
2026-04-26 20:03:03 收到下发指令:叫号101>>>
2026-04-26 20:03:07 收到下发指令:排队号101>>>
2026-04-26 20:03:07 收到下发指令:叫号101>>>
2026-04-26 20:03:11 收到下发指令:排队号101>>>
2026-04-26 20:03:11 收到下发指令:叫号101>>>
2026-04-26 20:03:15 收到下发指令:排队号101>>>
2026-04-26 20:03:15 收到下发指令:叫号101>>>
2026-04-26 20:03:19 收到下发指令:排队号101>>>
2026-04-26 20:03:19 收到下发指令:叫号101>>>


===20:04:23===
2026-04-26 20:03:22 收到下发指令:排队号101>>>
2026-04-26 20:03:22 收到下发指令:叫号101>>>
2026-04-26 20:03:26 收到下发指令:排队号101>>>
2026-04-26 20:03:26 收到下发指令:叫号101>>>
2026-04-26 20:03:33 收到下发指令:排队号101>>>
2026-04-26 20:03:33 收到下发指令:叫号101>>>


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


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


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


===20:11:24===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 20:11:19 收到下发指令:排队号101>>>
2026-04-26 20:11:19 收到下发指令:叫号101>>>
2026-04-26 20:11:22 收到下发指令:排队号101>>>
2026-04-26 20:11:22 收到下发指令:叫号101>>>


===20:12:24===
2026-04-26 20:11:26 收到下发指令:排队号101>>>
2026-04-26 20:11:26 收到下发指令:叫号101>>>
2026-04-26 20:11:31 收到下发指令:排队号101>>>
2026-04-26 20:11:31 收到下发指令:叫号101>>>
2026-04-26 20:11:35 收到下发指令:排队号101>>>
2026-04-26 20:11:35 收到下发指令:叫号101>>>


===20:17:24===
2026-04-26 20:17:19 收到下发指令:排队号101>>>
2026-04-26 20:17:19 收到下发指令:叫号101>>>
2026-04-26 20:17:22 收到下发指令:排队号101>>>
2026-04-26 20:17:22 收到下发指令:叫号101>>>


===20:18:24===
2026-04-26 20:17:25 收到下发指令:排队号101>>>
2026-04-26 20:17:25 收到下发指令:叫号101>>>
2026-04-26 20:17:29 收到下发指令:排队号101>>>
2026-04-26 20:17:29 收到下发指令:叫号101>>>
2026-04-26 20:17:42 收到下发指令:排队号101>>>
2026-04-26 20:17:42 收到下发指令:叫号101>>>
2026-04-26 20:17:46 收到下发指令:排队号101>>>
2026-04-26 20:17:47 收到下发指令:叫号101>>>
2026-04-26 20:17:50 收到下发指令:排队号101>>>
2026-04-26 20:17:50 收到下发指令:叫号101>>>
2026-04-26 20:17:56 收到下发指令:排队号101>>>
2026-04-26 20:17:56 收到下发指令:叫号101>>>
2026-04-26 20:18:02 收到下发指令:排队号101>>>
2026-04-26 20:18:02 收到下发指令:叫号101>>>
2026-04-26 20:18:09 收到下发指令:排队号105>>>
2026-04-26 20:18:09 收到下发指令:叫号105>>>
2026-04-26 20:18:13 收到下发指令:排队号105>>>
2026-04-26 20:18:13 收到下发指令:叫号105>>>
2026-04-26 20:18:17 收到下发指令:排队号105>>>
2026-04-26 20:18:17 收到下发指令:叫号105>>>
2026-04-26 20:18:21 收到下发指令:排队号105>>>
2026-04-26 20:18:21 收到下发指令:叫号105>>>


===20:19:25===
2026-04-26 20:18:27 收到下发指令:排队号105>>>
2026-04-26 20:18:27 收到下发指令:叫号105>>>
2026-04-26 20:18:31 收到下发指令:排队号105>>>
2026-04-26 20:18:31 收到下发指令:叫号105>>>
2026-04-26 20:18:35 收到下发指令:排队号105>>>
2026-04-26 20:18:35 收到下发指令:叫号105>>>
2026-04-26 20:18:40 收到下发指令:排队号105>>>
2026-04-26 20:18:40 收到下发指令:叫号105>>>
2026-04-26 20:18:45 收到下发指令:排队号105>>>
2026-04-26 20:18:45 收到下发指令:叫号105>>>
2026-04-26 20:18:50 收到下发指令:排队号105>>>
2026-04-26 20:18:50 收到下发指令:叫号105>>>
2026-04-26 20:18:56 收到下发指令:排队号105>>>
2026-04-26 20:18:56 收到下发指令:叫号105>>>
2026-04-26 20:19:01 收到下发指令:排队号105>>>
2026-04-26 20:19:02 收到下发指令:叫号105>>>
2026-04-26 20:19:06 收到下发指令:排队号105>>>
2026-04-26 20:19:06 收到下发指令:叫号105>>>
2026-04-26 20:19:10 收到下发指令:排队号105>>>
2026-04-26 20:19:10 收到下发指令:叫号105>>>
2026-04-26 20:19:15 收到下发指令:排队号105>>>
2026-04-26 20:19:15 收到下发指令:叫号105>>>
2026-04-26 20:19:21 收到下发指令:排队号105>>>
2026-04-26 20:19:21 收到下发指令:叫号105>>>


===20:20:25===
2026-04-26 20:19:27 收到下发指令:排队号105>>>
2026-04-26 20:19:27 收到下发指令:叫号105>>>
2026-04-26 20:19:32 收到下发指令:排队号105>>>
2026-04-26 20:19:32 收到下发指令:叫号105>>>
2026-04-26 20:19:36 收到下发指令:排队号105>>>
2026-04-26 20:19:36 收到下发指令:叫号105>>>
2026-04-26 20:19:40 收到下发指令:排队号105>>>
2026-04-26 20:19:40 收到下发指令:叫号105>>>
2026-04-26 20:19:58 收到下发指令:排队号105>>>
2026-04-26 20:19:58 收到下发指令:叫号105>>>
2026-04-26 20:20:03 收到下发指令:排队号105>>>
2026-04-26 20:20:03 收到下发指令:叫号105>>>
2026-04-26 20:20:06 >>>回调事件[910,devices/A0509]
2026-04-26 20:20:06 >>>故障排除日志:上一MQTT订单号缓存列表为2604262008440099224792
2026-04-26 20:20:06 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 20:20:06 开始打印,排队:410,票券:2604262019593796298701,订单:2604262019590036035881,[2026-04-26 20:20:05微信支付10元]
2026-04-26 20:20:06>>>MQTT票号同步场景，创建空订单对象
2026-04-26 20:20:06>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 20:20:08 收到下发指令:排队号0>>>
2026-04-26 20:20:08 收到下发指令:叫号0>>>
2026-04-26 20:20:09 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604262019593796298701","queue_number":410,"trade_uid":"2604262019590036035881"}]}
2026-04-26 20:20:09 >>>故障排除日志:删除未同步下发订单成功2604262019590036035881
2026-04-26 20:20:09 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536881375]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 20:20:11 >>>回调事件[910,devices/A0509]
2026-04-26 20:20:11 >>>故障排除日志:上一MQTT订单号缓存列表为2604262019590036035881
2026-04-26 20:20:11 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 20:20:11 开始打印,排队:411,票券:2604262020051491895401,订单:2604262020050013312263,[2026-04-26 20:20:10微信支付10元]
2026-04-26 20:20:11>>>MQTT票号同步场景，创建空订单对象
2026-04-26 20:20:11>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 20:20:13 收到下发指令:排队号0>>>
2026-04-26 20:20:13 收到下发指令:叫号0>>>
2026-04-26 20:20:13 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604262020051491895401","queue_number":411,"trade_uid":"2604262020050013312263"}]}
2026-04-26 20:20:13 >>>故障排除日志:删除未同步下发订单成功2604262020050013312263
2026-04-26 20:20:13 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536881381]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 20:20:21 收到下发指令:排队号105>>>
2026-04-26 20:20:21 收到下发指令:叫号105>>>


===20:21:25===
2026-04-26 20:20:27 收到下发指令:排队号105>>>
2026-04-26 20:20:27 收到下发指令:叫号105>>>
2026-04-26 20:20:30 收到下发指令:排队号105>>>
2026-04-26 20:20:30 收到下发指令:叫号105>>>
2026-04-26 20:20:34 收到下发指令:排队号105>>>
2026-04-26 20:20:34 收到下发指令:叫号105>>>
2026-04-26 20:20:39 收到下发指令:排队号105>>>
2026-04-26 20:20:39 收到下发指令:叫号105>>>
2026-04-26 20:20:43 收到下发指令:排队号105>>>
2026-04-26 20:20:43 收到下发指令:叫号105>>>
2026-04-26 20:20:47 收到下发指令:排队号105>>>
2026-04-26 20:20:47 收到下发指令:叫号105>>>
2026-04-26 20:20:52 收到下发指令:排队号275>>>
2026-04-26 20:20:52 收到下发指令:叫号275>>>
2026-04-26 20:21:04 >>>回调事件[910,devices/A0509]
2026-04-26 20:21:04 >>>故障排除日志:上一MQTT订单号缓存列表为2604262020050013312263
2026-04-26 20:21:04 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 20:21:04 开始打印,排队:412,票券:2604262020577012773901,订单:2604262020570067941931,[2026-04-26 20:21:03支付宝支付10元]
2026-04-26 20:21:05>>>MQTT票号同步场景，创建空订单对象
2026-04-26 20:21:05>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 20:21:06 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604262020577012773901","queue_number":412,"trade_uid":"2604262020570067941931"}]}
2026-04-26 20:21:07 >>>故障排除日志:删除未同步下发订单成功2604262020570067941931
2026-04-26 20:21:07 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536881425]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 20:21:16 收到下发指令:排队号297>>>
2026-04-26 20:21:16 收到下发指令:叫号297>>>


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


===20:25:30===
2026-04-26 20:24:58 收到下发指令:排队号297>>>
2026-04-26 20:24:58 收到下发指令:叫号297>>>
2026-04-26 20:25:05 收到下发指令:排队号299>>>
2026-04-26 20:25:05 收到下发指令:叫号299>>>
2026-04-26 20:25:06 收到下发指令:排队号302>>>
2026-04-26 20:25:06 收到下发指令:叫号302>>>
2026-04-26 20:25:07 收到下发指令:排队号303>>>
2026-04-26 20:25:07 收到下发指令:叫号303>>>
2026-04-26 20:25:08 收到下发指令:排队号305>>>
2026-04-26 20:25:08 收到下发指令:叫号305>>>
2026-04-26 20:25:09 收到下发指令:排队号306>>>
2026-04-26 20:25:09 收到下发指令:叫号306>>>
2026-04-26 20:25:10 收到下发指令:排队号311>>>
2026-04-26 20:25:10 收到下发指令:叫号311>>>
2026-04-26 20:25:11 收到下发指令:排队号314>>>
2026-04-26 20:25:11 收到下发指令:叫号314>>>
2026-04-26 20:25:12 收到下发指令:排队号315>>>
2026-04-26 20:25:12 收到下发指令:叫号315>>>
2026-04-26 20:25:13 收到下发指令:排队号320>>>
2026-04-26 20:25:13 收到下发指令:叫号320>>>
2026-04-26 20:25:14 收到下发指令:排队号328>>>
2026-04-26 20:25:14 收到下发指令:叫号328>>>
2026-04-26 20:25:14 收到下发指令:排队号328>>>
2026-04-26 20:25:14 收到下发指令:叫号328>>>
2026-04-26 20:25:15 收到下发指令:排队号329>>>
2026-04-26 20:25:15 收到下发指令:叫号329>>>
2026-04-26 20:25:15 收到下发指令:排队号330>>>
2026-04-26 20:25:15 收到下发指令:叫号330>>>
2026-04-26 20:25:16 收到下发指令:排队号333>>>
2026-04-26 20:25:16 收到下发指令:叫号333>>>
2026-04-26 20:25:16 收到下发指令:排队号336>>>
2026-04-26 20:25:16 收到下发指令:叫号336>>>
2026-04-26 20:25:17 收到下发指令:排队号340>>>
2026-04-26 20:25:17 收到下发指令:叫号340>>>
2026-04-26 20:25:18 收到下发指令:排队号341>>>
2026-04-26 20:25:18 收到下发指令:叫号341>>>
2026-04-26 20:25:18 收到下发指令:排队号344>>>
2026-04-26 20:25:18 收到下发指令:叫号344>>>
2026-04-26 20:25:19 收到下发指令:排队号347>>>
2026-04-26 20:25:19 收到下发指令:叫号347>>>
2026-04-26 20:25:19 收到下发指令:排队号349>>>
2026-04-26 20:25:19 收到下发指令:叫号349>>>
2026-04-26 20:25:20 收到下发指令:排队号353>>>
2026-04-26 20:25:20 收到下发指令:叫号353>>>
2026-04-26 20:25:20 收到下发指令:排队号354>>>
2026-04-26 20:25:20 收到下发指令:叫号354>>>
2026-04-26 20:25:21 收到下发指令:排队号359>>>
2026-04-26 20:25:21 收到下发指令:叫号359>>>
2026-04-26 20:25:22 收到下发指令:排队号364>>>
2026-04-26 20:25:22 收到下发指令:叫号364>>>
2026-04-26 20:25:22 收到下发指令:排队号367>>>
2026-04-26 20:25:22 收到下发指令:叫号367>>>
2026-04-26 20:25:24 收到下发指令:排队号368>>>
2026-04-26 20:25:24 收到下发指令:叫号368>>>
2026-04-26 20:25:24 收到下发指令:排队号370>>>
2026-04-26 20:25:24 收到下发指令:叫号370>>>
2026-04-26 20:25:24 收到下发指令:排队号374>>>
2026-04-26 20:25:25 收到下发指令:叫号374>>>
2026-04-26 20:25:25 收到下发指令:排队号378>>>
2026-04-26 20:25:25 收到下发指令:叫号378>>>
2026-04-26 20:25:26 收到下发指令:排队号379>>>
2026-04-26 20:25:26 收到下发指令:叫号379>>>
2026-04-26 20:25:26 收到下发指令:排队号381>>>
2026-04-26 20:25:26 收到下发指令:叫号381>>>
2026-04-26 20:25:27 收到下发指令:排队号391>>>
2026-04-26 20:25:27 收到下发指令:叫号391>>>
2026-04-26 20:25:28 收到下发指令:排队号394>>>
2026-04-26 20:25:28 收到下发指令:叫号394>>>


===20:26:30===
2026-04-26 20:25:47 收到下发指令:排队号396>>>
2026-04-26 20:25:47 收到下发指令:叫号396>>>
2026-04-26 20:25:55 收到下发指令:排队号410>>>
2026-04-26 20:25:55 收到下发指令:叫号410>>>
2026-04-26 20:26:24 收到下发指令:排队号nil>>>


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


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


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


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


===20:38:31===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 20:38:12 >>>回调事件[910,devices/A0509]
2026-04-26 20:38:12 >>>故障排除日志:上一MQTT订单号缓存列表为2604262036020021882671
2026-04-26 20:38:12 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 20:38:12 开始打印,排队:417,票券:2604262038053082406101,订单:2604262038050028503231,[2026-04-26 20:38:12微信支付10元]
2026-04-26 20:38:12 开始打印,排队:418,票券:2604262038053082966802,订单:2604262038050028503231,[2026-04-26 20:38:12微信支付10元]
2026-04-26 20:38:13>>>MQTT票号同步场景，创建空订单对象
2026-04-26 20:38:13>>>合并MQTT票号列表到订单同步请求,共2张票
2026-04-26 20:38:16 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604262038053082406101","queue_number":417,"trade_uid":"2604262038050028503231"},{"ticket_no":"2604262038053082966802","queue_number":418,"trade_uid":"2604262038050028503231"}]}
2026-04-26 20:38:16 >>>故障排除日志:删除未同步下发订单成功2604262038050028503231
2026-04-26 20:38:16 >>>故障排除日志:删除未同步下发订单成功2604262038050028503231
2026-04-26 20:38:16 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536881645]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 20:38:24 >>>回调事件[910,devices/A0509]
2026-04-26 20:38:24 >>>故障排除日志:上一MQTT订单号缓存列表为2604262038050028503231|2604262038050028503231
2026-04-26 20:38:24 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 20:38:24 开始打印,排队:419,票券:2604262038133672695201,订单:2604262038130034895168,[2026-04-26 20:38:23微信支付10元]
2026-04-26 20:38:24>>>MQTT票号同步场景，创建空订单对象
2026-04-26 20:38:24>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 20:38:26 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604262038133672695201","queue_number":419,"trade_uid":"2604262038130034895168"}]}
2026-04-26 20:38:26 >>>故障排除日志:删除未同步下发订单成功2604262038130034895168
2026-04-26 20:38:26 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536881651]


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


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


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


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


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


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


===20:53:32===
2026-04-26 20:52:33 收到下发指令:排队号414>>>
2026-04-26 20:52:33 收到下发指令:叫号414>>>
2026-04-26 20:52:36 收到下发指令:排队号414>>>
2026-04-26 20:52:36 收到下发指令:叫号414>>>
2026-04-26 20:52:40 收到下发指令:排队号414>>>
2026-04-26 20:52:40 收到下发指令:叫号414>>>


===20:54:32===
2026-04-26 20:54:25 收到下发指令:排队号414>>>
2026-04-26 20:54:25 收到下发指令:叫号414>>>
2026-04-26 20:54:29 收到下发指令:排队号414>>>
2026-04-26 20:54:29 收到下发指令:叫号414>>>


===20:55:33===
2026-04-26 20:54:32 收到下发指令:排队号414>>>
2026-04-26 20:54:32 收到下发指令:叫号414>>>
2026-04-26 20:54:36 收到下发指令:排队号420>>>
2026-04-26 20:54:36 收到下发指令:叫号420>>>


===20:57:33===
2026-04-26 20:56:50 收到下发指令:排队号420>>>
2026-04-26 20:56:50 收到下发指令:叫号420>>>