TLClient_JSSCOM_LuatOS-Air_V3205_RDA8910_RFTTS_0xe0000,2.8.6,861714058769609,09450077800333,
poweron reason:0

===09:30:43===
上一时间戳为1777080735
隔日重置时间戳true
隔日清空未同步下发列表true
当前排队号为1,音量为6
初始化产品信息:[{"time_limit_date":null,"ticket_category":"0","expiry_date":90,"product_detail":"此票劵当天有效，过期作废。","time_limit_status":"0","begin_minute":null,"product_uid":"12565527731041229647","use_timer":1,"old_price":"12","end_hour":null,"sale_price":"12","end_minute":null,"begin_hour":null,"sale_status":1,"product_name":"剪发"}]
打印门店标题设置为丰门哲尚理发店
是否打印二维码设置为1
是否打印紧凑设置为3
当前号显示模式设置为1
当前卡项核销权限设置为0
session_id:59e1a****143d7
纸币器设置接收纸币范围为36
欢迎使用天羚自助售票系统[2.8.6]
定时检测未同步订单启用[checkOrderNum=536870969]
2026-04-26 09:29:43>>>cash write=30
2026-04-26 09:29:43>>>cash write=02
2026-04-26 09:29:43>>>cash write=3E
2026-04-26 09:29:43>>>cash read=808F808F808F808F
系统时间初始化成功，时间为202642692943
2026-04-26 09:29:44>>>cash write=02
2026-04-26 09:29:44 >>>剩余flash空间=1671500,占用RAM为655.88671875
2026-04-26 09:29:44 >>>回调事件:910,subscribe,10000,连接服务器成功

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

2026-04-26 09:29:47>>>cash write=0C
2026-04-26 09:29:47>>>cash read=3E
流量卡还有280天过期
2026-04-26 09:29:51 >>>当前Ram内存为637.3291015625
2026-04-26 09:30:09>>>cash read=00
2026-04-26 09:30:10>>>cash read=818F42
2026-04-26 09:30:10>>>cash write=02
2026-04-26 09:30:10 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 09:30:10>>>cash read=10
2026-04-26 09:30:10 >>>回调事件130,10,10023,finish Money=10,进钞完成
当日首次设置时间戳true为1777167010
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 09:30:11>>>cash write=0C
2026-04-26 09:30:11>>>cash read=3E
2026-04-26 09:30:12 >>>开始未足额打印,排队号为1,订单号为2604260930100021754257
2026-04-26 09:30:12 订单投币结束,共投币10元,请取走您的小票
2026-04-26 09:30:12>>>订单2604260930100021754257写入成功,剩余空间为1669500,占用RAM为654.982421875
删除未同步订单2604260930100021754257
2026-04-26 09:30:14>>>订单2604260930100021754257删除成功,剩余空间为1670500,占用RAM为649.6591796875
检测订单目录中>>>
无未同步订单>>>
2026-04-26 09:30:14 >>>当前Ram内存为617.1142578125
定时检测未同步订单启用[checkOrderNum=536870993]


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


===09:34:43===
2026-04-26 09:34:36>>>cash read=00
2026-04-26 09:34:37>>>cash read=818F42
2026-04-26 09:34:37>>>cash write=02
2026-04-26 09:34:37 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 09:34:38>>>cash read=10
2026-04-26 09:34:38 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 09:34:39>>>cash write=0C
2026-04-26 09:34:39>>>cash read=3E
2026-04-26 09:34:39 >>>开始未足额打印,排队号为3,订单号为2604260934380021754836
2026-04-26 09:34:39 订单投币结束,共投币10元,请取走您的小票
2026-04-26 09:34:39>>>订单2604260934380021754836写入成功,剩余空间为1671000,占用RAM为648.392578125
删除未同步订单2604260934380021754836
2026-04-26 09:34:41>>>订单2604260934380021754836删除成功,剩余空间为1672000,占用RAM为646.8046875
检测订单目录中>>>
无未同步订单>>>
2026-04-26 09:34:41 >>>当前Ram内存为618.66796875
定时检测未同步订单启用[checkOrderNum=536871059]


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


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


===09:47:44===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 09:47:27 >>>回调事件[910,devices/S1754]
2026-04-26 09:47:27 >>>故障排除日志:上一MQTT订单号缓存列表为2604260945550058790574
2026-04-26 09:47:27 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 09:47:27 开始打印,排队:6,票券:2604260947199560065601,订单:2604260947190093750014,[2026-04-26 09:47:26微信支付12元]
2026-04-26 09:47:27>>>MQTT票号同步场景，创建空订单对象
2026-04-26 09:47:27>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 09:47:29 >>>回调事件[910,devices/S1754]
2026-04-26 09:47:29 >>>故障排除日志:上一MQTT订单号缓存列表为2604260947190093750014
2026-04-26 09:47:29 >>>故障排除日志:终端未同步成功订单列表00062604260947190093750014
已接收过此消息,票券号为2604260947199560065601,排队号为6
2026-04-26 09:47:29 开始打印,排队:7,票券:2604260947208930843701,订单:2604260947200087482774,[2026-04-26 09:47:27微信支付12元]
2026-04-26 09:47:29>>>HTTP请求进行中，跳过本次同步
2026-04-26 09:47:31 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604260947199560065601","queue_number":6,"trade_uid":"2604260947190093750014"}]}
2026-04-26 09:47:31 >>>故障排除日志:删除未同步下发订单成功2604260947190093750014
2026-04-26 09:47:31 >>>故障排除日志:终端同步成功后剩余订单列表00072604260947200087482774
定时检测未同步订单启用[checkOrderNum=536871201]


===09:49:45===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 09:49:12 >>>回调事件[910,devices/S1754]
2026-04-26 09:49:12 >>>故障排除日志:上一MQTT订单号缓存列表为2604260947190093750014|2604260947200087482774
2026-04-26 09:49:12 >>>故障排除日志:终端未同步成功订单列表00072604260947200087482774
已接收过此消息,票券号为2604260947208930843701,排队号为7
2026-04-26 09:49:12 开始打印,排队:8,票券:2604260949010560841601,订单:2604260949010003463124,[2026-04-26 09:49:11微信支付12元]
2026-04-26 09:49:12>>>MQTT票号同步场景，创建空订单对象
2026-04-26 09:49:12>>>合并MQTT票号列表到订单同步请求,共2张票
2026-04-26 09:49:14 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604260947208930843701","queue_number":7,"trade_uid":"2604260947200087482774"},{"ticket_no":"2604260949010560841601","queue_number":8,"trade_uid":"2604260949010003463124"}]}
2026-04-26 09:49:14 >>>故障排除日志:删除未同步下发订单成功2604260947200087482774
2026-04-26 09:49:14 >>>故障排除日志:删除未同步下发订单成功2604260949010003463124
2026-04-26 09:49:14 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536871226]


===10:15:45===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 10:15:29 >>>回调事件[910,devices/S1754]
2026-04-26 10:15:29 >>>故障排除日志:上一MQTT订单号缓存列表为2604260947200087482774|2604260949010003463124
2026-04-26 10:15:29 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 10:15:29 开始打印,排队:9,票券:2604261015215926146701,订单:2604261015210057542519,[2026-04-26 10:15:28微信支付12元]
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":"2604261015215926146701","queue_number":9,"trade_uid":"2604261015210057542519"}]}
2026-04-26 10:15:31 >>>故障排除日志:删除未同步下发订单成功2604261015210057542519
2026-04-26 10:15:31 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536871473]


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


===12:43:52===
2026-04-26 12:43:07>>>cash read=00
2026-04-26 12:43:08>>>cash read=818F42
2026-04-26 12:43:08>>>cash write=02
2026-04-26 12:43:08 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 12:43:09>>>cash read=10
2026-04-26 12:43:09 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 12:43:10 >>>开始未足额打印,排队号为37,订单号为2604261243090021754547
2026-04-26 12:43:10 订单投币结束,共投币10元,请取走您的小票
2026-04-26 12:43:10>>>订单2604261243090021754547写入成功,剩余空间为1671000,占用RAM为639.57421875
2026-04-26 12:43:12>>>cash write=0C
删除未同步订单2604261243090021754547
2026-04-26 12:43:12>>>订单2604261243090021754547删除成功,剩余空间为1672000,占用RAM为648.6015625
检测订单目录中>>>
无未同步订单>>>
2026-04-26 12:43:12 >>>当前Ram内存为617.7255859375
定时检测未同步订单启用[checkOrderNum=536873033]
2026-04-26 12:43:12>>>cash read=3E
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 12:43:41 >>>回调事件[910,devices/S1754]
2026-04-26 12:43:41 >>>故障排除日志:上一MQTT订单号缓存列表为2604261232030070354028
2026-04-26 12:43:41 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 12:43:41 开始打印,排队:38,票券:2604261243331124623601,订单:2604261243330009278618,[2026-04-26 12:43:40微信支付12元]
2026-04-26 12:43:41>>>MQTT票号同步场景，创建空订单对象
2026-04-26 12:43:41>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 12:43:43 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261243331124623601","queue_number":38,"trade_uid":"2604261243330009278618"}]}
2026-04-26 12:43:43 >>>故障排除日志:删除未同步下发订单成功2604261243330009278618
2026-04-26 12:43:43 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536873045]


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


===12:57:53===
2026-04-26 12:57:21>>>cash read=00
2026-04-26 12:57:21>>>cash read=818F42
2026-04-26 12:57:21>>>cash write=02
2026-04-26 12:57:21 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 12:57:22>>>cash read=10
2026-04-26 12:57:22 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 12:57:22 >>>开始未足额打印,排队号为40,订单号为2604261257220021754962
2026-04-26 12:57:22 订单投币结束,共投币10元,请取走您的小票
2026-04-26 12:57:22>>>订单2604261257220021754962写入成功,剩余空间为1671000,占用RAM为628.5439453125
删除未同步订单2604261257220021754962
2026-04-26 12:57:24>>>订单2604261257220021754962删除成功,剩余空间为1672000,占用RAM为648.765625
检测订单目录中>>>
无未同步订单>>>
2026-04-26 12:57:24 >>>当前Ram内存为617.9755859375
定时检测未同步订单启用[checkOrderNum=536873186]
2026-04-26 12:57:25>>>cash write=0C
2026-04-26 12:57:25>>>cash read=3E


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


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


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


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


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


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


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


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


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


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


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


===13:44:58===
2026-04-26 13:43:56 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261343467023816701","queue_number":54,"trade_uid":"2604261343460068337147"}]}
2026-04-26 13:43:56 >>>故障排除日志:删除未同步下发订单成功2604261343460068337147
2026-04-26 13:43:57 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536873735]


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


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


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


===13:52:00===
2026-04-26 13:50:59 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261350496574772701","queue_number":57,"trade_uid":"2604261350490063870881"}]}
2026-04-26 13:50:59 >>>故障排除日志:删除未同步下发订单成功2604261350490063870881
2026-04-26 13:50:59 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536873828]


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


===13:56:00===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 13:55:28 >>>回调事件[910,devices/S1754]
2026-04-26 13:55:28 >>>故障排除日志:上一MQTT订单号缓存列表为2604261354510006497047
2026-04-26 13:55:28 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 13:55:28 开始打印,排队:60,票券:2604261355204499766401,订单:2604261355200042000665,[2026-04-26 13:55:27微信支付12元]
2026-04-26 13:55:28>>>MQTT票号同步场景，创建空订单对象
2026-04-26 13:55:28>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 13:55:30 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261355204499766401","queue_number":60,"trade_uid":"2604261355200042000665"}]}
2026-04-26 13:55:30 >>>故障排除日志:删除未同步下发订单成功2604261355200042000665
2026-04-26 13:55:30 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536873889]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 13:55:50 >>>回调事件[910,devices/S1754]
2026-04-26 13:55:50 >>>故障排除日志:上一MQTT订单号缓存列表为2604261355200042000665
2026-04-26 13:55:50 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 13:55:50 开始打印,排队:61,票券:2604261355418287409201,订单:2604261355410080446846,[2026-04-26 13:55:49支付宝支付12元]
2026-04-26 13:55:51>>>MQTT票号同步场景，创建空订单对象
2026-04-26 13:55:51>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 13:55:53 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261355418287409201","queue_number":61,"trade_uid":"2604261355410080446846"}]}
2026-04-26 13:55:53 >>>故障排除日志:删除未同步下发订单成功2604261355410080446846
2026-04-26 13:55:53 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536873901]


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


===14:05:01===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 14:04:03 >>>回调事件[910,devices/S1754]
2026-04-26 14:04:03 >>>故障排除日志:上一MQTT订单号缓存列表为2604261359200042548836
2026-04-26 14:04:03 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 14:04:03 开始打印,排队:63,票券:2604261403550334316901,订单:2604261403550001490187,[2026-04-26 14:04:02微信支付12元]
2026-04-26 14:04:03>>>MQTT票号同步场景，创建空订单对象
2026-04-26 14:04:03>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 14:04:05 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261403550334316901","queue_number":63,"trade_uid":"2604261403550001490187"}]}
2026-04-26 14:04:05 >>>故障排除日志:删除未同步下发订单成功2604261403550001490187
2026-04-26 14:04:05 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536873991]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 14:04:08 >>>回调事件[910,devices/S1754]
2026-04-26 14:04:08 >>>故障排除日志:上一MQTT订单号缓存列表为2604261403550001490187
2026-04-26 14:04:08 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 14:04:08 开始打印,排队:64,票券:2604261404036733197801,订单:2604261404030065460821,[2026-04-26 14:04:07支付宝支付12元]
2026-04-26 14:04:08>>>MQTT票号同步场景，创建空订单对象
2026-04-26 14:04:08>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 14:04:10 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261404036733197801","queue_number":64,"trade_uid":"2604261404030065460821"}]}
2026-04-26 14:04:10 >>>故障排除日志:删除未同步下发订单成功2604261404030065460821
2026-04-26 14:04:10 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536873998]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 14:04:23 >>>回调事件[910,devices/S1754]
2026-04-26 14:04:23 >>>故障排除日志:上一MQTT订单号缓存列表为2604261404030065460821
2026-04-26 14:04:23 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 14:04:23 开始打印,排队:65,票券:2604261404140841923201,订单:2604261404140006562494,[2026-04-26 14:04:22微信支付12元]
2026-04-26 14:04:23>>>MQTT票号同步场景，创建空订单对象
2026-04-26 14:04:23>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 14:04:25 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261404140841923201","queue_number":65,"trade_uid":"2604261404140006562494"}]}
2026-04-26 14:04:25 >>>故障排除日志:删除未同步下发订单成功2604261404140006562494
2026-04-26 14:04:25 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536874004]


===14:06:01===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 14:05:33 >>>回调事件[910,devices/S1754]
2026-04-26 14:05:33 >>>故障排除日志:上一MQTT订单号缓存列表为2604261404140006562494
2026-04-26 14:05:34 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 14:05:34 开始打印,排队:66,票券:2604261405251140956401,订单:2604261405250009449053,[2026-04-26 14:05:32支付宝支付12元]
2026-04-26 14:05:34>>>MQTT票号同步场景，创建空订单对象
2026-04-26 14:05:34>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 14:05:36 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261405251140956401","queue_number":66,"trade_uid":"2604261405250009449053"}]}
2026-04-26 14:05:36 >>>故障排除日志:删除未同步下发订单成功2604261405250009449053
2026-04-26 14:05:36 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536874021]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 14:05:41 >>>回调事件[910,devices/S1754]
2026-04-26 14:05:41 >>>故障排除日志:上一MQTT订单号缓存列表为2604261405250009449053
2026-04-26 14:05:41 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 14:05:41 开始打印,排队:67,票券:2604261405330739907101,订单:2604261405330005614015,[2026-04-26 14:05:40微信支付12元]
2026-04-26 14:05:41>>>MQTT票号同步场景，创建空订单对象
2026-04-26 14:05:41>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 14:05:43 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261405330739907101","queue_number":67,"trade_uid":"2604261405330005614015"}]}
2026-04-26 14:05:43 >>>故障排除日志:删除未同步下发订单成功2604261405330005614015
2026-04-26 14:05:43 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536874033]
2026-04-26 14:05:51>>>cash read=0A
2026-04-26 14:05:52>>>cash read=3E


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


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


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


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


===14:31:03===
2026-04-26 14:30:53>>>cash read=00
2026-04-26 14:30:54>>>cash read=818F42
2026-04-26 14:30:54>>>cash write=02
2026-04-26 14:30:54 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 14:30:55>>>cash read=10
2026-04-26 14:30:55 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 14:30:56>>>cash write=0C
2026-04-26 14:30:56>>>cash read=3E


===14:32:03===
2026-04-26 14:31:14 >>>开始未足额打印,排队号为72,订单号为2604261430550021754367
2026-04-26 14:31:14 订单投币结束,共投币10元,请取走您的小票
2026-04-26 14:31:14>>>订单2604261430550021754367写入成功,剩余空间为1672000,占用RAM为650.34375
删除未同步订单2604261430550021754367
2026-04-26 14:31:16>>>订单2604261430550021754367删除成功,剩余空间为1673000,占用RAM为645.2109375
检测订单目录中>>>
无未同步订单>>>
2026-04-26 14:31:16 >>>当前Ram内存为617.62109375
定时检测未同步订单启用[checkOrderNum=536874309]


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


===16:17:12===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 16:16:30 >>>回调事件[910,devices/S1754]
2026-04-26 16:16:30 >>>故障排除日志:上一MQTT订单号缓存列表为2604261608480029502778
2026-04-26 16:16:30 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 16:16:30 开始打印,排队:99,票券:2604261616243646994201,订单:2604261616240034149125,[2026-04-26 16:16:29支付宝支付12元]
2026-04-26 16:16:31>>>MQTT票号同步场景，创建空订单对象
2026-04-26 16:16:31>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 16:16:33 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261616243646994201","queue_number":99,"trade_uid":"2604261616240034149125"}]}
2026-04-26 16:16:33 >>>故障排除日志:删除未同步下发订单成功2604261616240034149125
2026-04-26 16:16:33 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536875456]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 16:17:07 >>>回调事件[910,devices/S1754]
2026-04-26 16:17:07 >>>故障排除日志:上一MQTT订单号缓存列表为2604261616240034149125
2026-04-26 16:17:07 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 16:17:07 开始打印,排队:100,票券:2604261616591531527201,订单:2604261616590012894892,[2026-04-26 16:17:06微信支付12元]
2026-04-26 16:17:07>>>MQTT票号同步场景，创建空订单对象
2026-04-26 16:17:07>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 16:17:09 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261616591531527201","queue_number":100,"trade_uid":"2604261616590012894892"}]}
2026-04-26 16:17:09 >>>故障排除日志:删除未同步下发订单成功2604261616590012894892
2026-04-26 16:17:09 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536875470]


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


===17:44:21===
2026-04-26 17:43:22>>>cash read=00
2026-04-26 17:43:23>>>cash read=818F42
2026-04-26 17:43:23>>>cash write=02
2026-04-26 17:43:23 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 17:43:23>>>cash read=10
2026-04-26 17:43:23 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 17:43:25>>>cash write=0C
2026-04-26 17:43:25>>>cash read=3E
2026-04-26 17:43:31 >>>开始未足额打印,排队号为129,订单号为2604261743230021754648
2026-04-26 17:43:31 订单投币结束,共投币10元,请取走您的小票
2026-04-26 17:43:31>>>订单2604261743230021754648写入成功,剩余空间为1671000,占用RAM为633.9794921875
删除未同步订单2604261743230021754648
2026-04-26 17:43:33>>>订单2604261743230021754648删除成功,剩余空间为1672000,占用RAM为644.376953125
检测订单目录中>>>
无未同步订单>>>
2026-04-26 17:43:33 >>>当前Ram内存为616.189453125
定时检测未同步订单启用[checkOrderNum=536876535]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 17:43:43 >>>回调事件[910,devices/S1754]
2026-04-26 17:43:43 >>>故障排除日志:上一MQTT订单号缓存列表为2604261740190000259196
2026-04-26 17:43:43 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 17:43:43 开始打印,排队:130,票券:2604261743358928112301,订单:2604261743350086610931,[2026-04-26 17:43:42支付宝支付12元]
2026-04-26 17:43:43>>>MQTT票号同步场景，创建空订单对象
2026-04-26 17:43:43>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 17:43:45 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261743358928112301","queue_number":130,"trade_uid":"2604261743350086610931"}]}
2026-04-26 17:43:45 >>>故障排除日志:删除未同步下发订单成功2604261743350086610931
2026-04-26 17:43:45 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536876546]


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


===18:51:31===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 18:50:41 >>>回调事件[910,devices/S1754]
2026-04-26 18:50:41 >>>故障排除日志:上一MQTT订单号缓存列表为2604261849500071956631|2604261849500071956631
2026-04-26 18:50:41 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 18:50:41 开始打印,排队:163,票券:2604261850311152623801,订单:2604261850310009819492,[2026-04-26 18:50:40微信支付12元]
2026-04-26 18:50:41>>>MQTT票号同步场景，创建空订单对象
2026-04-26 18:50:41>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 18:50:43 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261850311152623801","queue_number":163,"trade_uid":"2604261850310009819492"}]}
2026-04-26 18:50:43 >>>故障排除日志:删除未同步下发订单成功2604261850310009819492
2026-04-26 18:50:43 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877405]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 18:50:52 >>>回调事件[910,devices/S1754]
2026-04-26 18:50:52 >>>故障排除日志:上一MQTT订单号缓存列表为2604261850310009819492
2026-04-26 18:50:52 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 18:50:52 开始打印,排队:164,票券:2604261850372783702601,订单:2604261850370025842568,[2026-04-26 18:50:51支付宝支付12元]
2026-04-26 18:50:52>>>MQTT票号同步场景，创建空订单对象
2026-04-26 18:50:52>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 18:50:54 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261850372783702601","queue_number":164,"trade_uid":"2604261850370025842568"}]}
2026-04-26 18:50:54 >>>故障排除日志:删除未同步下发订单成功2604261850370025842568
2026-04-26 18:50:54 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877411]


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


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


===19:00:32===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 18:59:36 >>>回调事件[910,devices/S1754]
2026-04-26 18:59:36 >>>故障排除日志:上一MQTT订单号缓存列表为2604261857480017242974
2026-04-26 18:59:36 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 18:59:36 开始打印,排队:167,票券:2604261859301573064801,订单:2604261859300013279093,[2026-04-26 18:59:36微信支付12元]
2026-04-26 18:59:37>>>MQTT票号同步场景，创建空订单对象
2026-04-26 18:59:37>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 18:59:39 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261859301573064801","queue_number":167,"trade_uid":"2604261859300013279093"}]}
2026-04-26 18:59:39 >>>故障排除日志:删除未同步下发订单成功2604261859300013279093
2026-04-26 18:59:39 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877511]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 18:59:41 >>>回调事件[910,devices/S1754]
2026-04-26 18:59:41 >>>故障排除日志:上一MQTT订单号缓存列表为2604261859300013279093
2026-04-26 18:59:41 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 18:59:41 开始打印,排队:168,票券:2604261859356660545901,订单:2604261859350064587417,[2026-04-26 18:59:40支付宝支付12元]
2026-04-26 18:59:41>>>MQTT票号同步场景，创建空订单对象
2026-04-26 18:59:41>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 18:59:43 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261859356660545901","queue_number":168,"trade_uid":"2604261859350064587417"}]}
2026-04-26 18:59:43 >>>故障排除日志:删除未同步下发订单成功2604261859350064587417
2026-04-26 18:59:43 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877522]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:00:10 >>>回调事件[910,devices/S1754]
2026-04-26 19:00:10 >>>故障排除日志:上一MQTT订单号缓存列表为2604261859350064587417
2026-04-26 19:00:10 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 19:00:10 开始打印,排队:169,票券:2604261900006474891301,订单:2604261900000062104495,[2026-04-26 19:00:10微信支付12元]
2026-04-26 19:00:10>>>MQTT票号同步场景，创建空订单对象
2026-04-26 19:00:10>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 19:00:12 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261900006474891301","queue_number":169,"trade_uid":"2604261900000062104495"}]}
2026-04-26 19:00:12 >>>故障排除日志:删除未同步下发订单成功2604261900000062104495
2026-04-26 19:00:12 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877531]


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


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


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


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


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


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


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


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


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


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


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


===19:23:35===
2026-04-26 19:23:15>>>cash read=00
2026-04-26 19:23:17>>>cash read=818F42
2026-04-26 19:23:17>>>cash write=02
2026-04-26 19:23:17 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 19:23:17>>>cash read=10
2026-04-26 19:23:17 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:23:18>>>cash write=0C
2026-04-26 19:23:18>>>cash read=3E
2026-04-26 19:23:19 >>>开始未足额打印,排队号为185,订单号为2604261923170021754783
2026-04-26 19:23:19 订单投币结束,共投币10元,请取走您的小票
2026-04-26 19:23:19>>>订单2604261923170021754783写入成功,剩余空间为1671000,占用RAM为655.2900390625
删除未同步订单2604261923170021754783
2026-04-26 19:23:21>>>订单2604261923170021754783删除成功,剩余空间为1672000,占用RAM为631.41796875
检测订单目录中>>>
无未同步订单>>>
2026-04-26 19:23:21 >>>当前Ram内存为615.587890625
定时检测未同步订单启用[checkOrderNum=536877865]


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


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


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


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


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


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


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


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


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


===19:51:39===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:51:06 >>>回调事件[910,devices/S1754]
2026-04-26 19:51:06 >>>故障排除日志:上一MQTT订单号缓存列表为2604261950010058675052
2026-04-26 19:51:06 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 19:51:06 开始打印,排队:198,票券:2604261951002389126301,订单:2604261951000021953886,[2026-04-26 19:51:06支付宝支付12元]
2026-04-26 19:51:06>>>MQTT票号同步场景，创建空订单对象
2026-04-26 19:51:06>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 19:51:08 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261951002389126301","queue_number":198,"trade_uid":"2604261951000021953886"}]}
2026-04-26 19:51:08 >>>故障排除日志:删除未同步下发订单成功2604261951000021953886
2026-04-26 19:51:09 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878208]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:51:23 >>>回调事件[910,devices/S1754]
2026-04-26 19:51:23 >>>故障排除日志:上一MQTT订单号缓存列表为2604261951000021953886
2026-04-26 19:51:23 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 19:51:23 开始打印,排队:199,票券:2604261951144068992601,订单:2604261951140038738918,[2026-04-26 19:51:22微信支付12元]
2026-04-26 19:51:24>>>MQTT票号同步场景，创建空订单对象
2026-04-26 19:51:24>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 19:51:26 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261951144068992601","queue_number":199,"trade_uid":"2604261951140038738918"}]}
2026-04-26 19:51:26 >>>故障排除日志:删除未同步下发订单成功2604261951140038738918
2026-04-26 19:51:26 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878214]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:51:28 >>>回调事件[910,devices/S1754]
2026-04-26 19:51:28 >>>故障排除日志:上一MQTT订单号缓存列表为2604261951140038738918
2026-04-26 19:51:28 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 19:51:28 开始打印,排队:200,票券:2604261951222175268201,订单:2604261951220019937878,[2026-04-26 19:51:27微信支付12元]
2026-04-26 19:51:28>>>MQTT票号同步场景，创建空订单对象
2026-04-26 19:51:28>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 19:51:30 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261951222175268201","queue_number":200,"trade_uid":"2604261951220019937878"}]}
2026-04-26 19:51:30 >>>故障排除日志:删除未同步下发订单成功2604261951220019937878
2026-04-26 19:51:31 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878221]


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


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


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


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


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


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


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


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


===20:30:41===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 20:29:43 >>>回调事件[910,devices/S1754]
2026-04-26 20:29:43 >>>故障排除日志:上一MQTT订单号缓存列表为2604262026560043045476
2026-04-26 20:29:43 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 20:29:43 开始打印,排队:209,票券:2604262029337715548701,订单:2604262029330074698036,[2026-04-26 20:29:42微信支付12元]
2026-04-26 20:29:43>>>MQTT票号同步场景，创建空订单对象
2026-04-26 20:29:43>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 20:29:45 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604262029337715548701","queue_number":209,"trade_uid":"2604262029330074698036"}]}
2026-04-26 20:29:45 >>>故障排除日志:删除未同步下发订单成功2604262029330074698036
2026-04-26 20:29:45 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878640]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 20:30:05 >>>回调事件[910,devices/S1754]
2026-04-26 20:30:05 >>>故障排除日志:上一MQTT订单号缓存列表为2604262029330074698036
2026-04-26 20:30:05 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 20:30:05 开始打印,排队:210,票券:2604262029563846444701,订单:2604262029560036522952,[2026-04-26 20:30:04微信支付12元]
2026-04-26 20:30:05>>>MQTT票号同步场景，创建空订单对象
2026-04-26 20:30:05>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 20:30:07 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604262029563846444701","queue_number":210,"trade_uid":"2604262029560036522952"}]}
2026-04-26 20:30:08 >>>故障排除日志:删除未同步下发订单成功2604262029560036522952
2026-04-26 20:30:08 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878648]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 20:30:16 >>>回调事件[910,devices/S1754]
2026-04-26 20:30:16 >>>故障排除日志:上一MQTT订单号缓存列表为2604262029560036522952
2026-04-26 20:30:16 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 20:30:16 开始打印,排队:211,票券:2604262030096943213401,订单:2604262030090067609681,[2026-04-26 20:30:16微信支付12元]
2026-04-26 20:30:17>>>MQTT票号同步场景，创建空订单对象
2026-04-26 20:30:17>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 20:30:18 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604262030096943213401","queue_number":211,"trade_uid":"2604262030090067609681"}]}
2026-04-26 20:30:19 >>>故障排除日志:删除未同步下发订单成功2604262030090067609681
2026-04-26 20:30:19 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878655]


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


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


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


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


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


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


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


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


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


===20:51:45===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 20:51:42 >>>回调事件[910,devices/S1754]
2026-04-26 20:51:42 >>>故障排除日志:上一MQTT订单号缓存列表为2604262047290095582089
2026-04-26 20:51:42 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 20:51:42 开始打印,排队:222,票券:2604262051336466729601,订单:2604262051330062676347,[2026-04-26 20:51:41支付宝支付12元]
2026-04-26 20:51:42>>>MQTT票号同步场景，创建空订单对象
2026-04-26 20:51:42>>>合并MQTT票号列表到订单同步请求,共1张票


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


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


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


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


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


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


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


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


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


===21:19:49===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 21:19:04 >>>回调事件[910,devices/S1754]
2026-04-26 21:19:04 >>>故障排除日志:上一MQTT订单号缓存列表为2604262115050072167793
2026-04-26 21:19:04 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 21:19:04 开始打印,排队:236,票券:2604262118560775798101,订单:2604262118560004823046,[2026-04-26 21:19:03微信支付12元]
2026-04-26 21:19:04>>>MQTT票号同步场景，创建空订单对象
2026-04-26 21:19:04>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 21:19:06 >>>回调事件[910,devices/S1754]
2026-04-26 21:19:06 >>>故障排除日志:上一MQTT订单号缓存列表为2604262118560004823046
2026-04-26 21:19:06 >>>故障排除日志:终端未同步成功订单列表02362604262118560004823046
2026-04-26 21:19:06 开始打印,排队:237,票券:2604262118537700619401,订单:2604262118530074151853,[2026-04-26 21:19:05微信支付12元]
已接收过此消息,票券号为2604262118560775798101,排队号为236
2026-04-26 21:19:06>>>HTTP请求进行中，跳过本次同步
2026-04-26 21:19:08 >>>回调事件[910,devices/S1754]
2026-04-26 21:19:08 >>>故障排除日志:上一MQTT订单号缓存列表为2604262118530074151853|2604262118560004823046
2026-04-26 21:19:08 >>>故障排除日志:终端未同步成功订单列表02362604262118560004823046|02372604262118530074151853
已接收过此消息,票券号为2604262118537700619401,排队号为237
已接收过此消息,票券号为2604262118560775798101,排队号为236
2026-04-26 21:19:08 开始打印,排队:238,票券:2604262118579071678501,订单:2604262118570088962383,[2026-04-26 21:19:05微信支付12元]
2026-04-26 21:19:08 开始打印,排队:239,票券:2604262118579072062602,订单:2604262118570088962383,[2026-04-26 21:19:05微信支付12元]
2026-04-26 21:19:08>>>HTTP请求进行中，跳过本次同步
2026-04-26 21:19:12 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604262118560775798101","queue_number":236,"trade_uid":"2604262118560004823046"}]}
2026-04-26 21:19:12 >>>故障排除日志:删除未同步下发订单成功2604262118560004823046
2026-04-26 21:19:12 >>>故障排除日志:终端同步成功后剩余订单列表02372604262118530074151853|02382604262118570088962383|02392604262118570088962383
定时检测未同步订单启用[checkOrderNum=536879281]


===21:20:49===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 21:20:08 >>>回调事件[910,devices/S1754]
2026-04-26 21:20:08 >>>故障排除日志:上一MQTT订单号缓存列表为2604262118530074151853|2604262118560004823046|2604262118570088962383|2604262118570088962383
2026-04-26 21:20:08 >>>故障排除日志:终端未同步成功订单列表02372604262118530074151853|02382604262118570088962383|02392604262118570088962383
已接收过此消息,票券号为2604262118537700619401,排队号为237
已接收过此消息,票券号为2604262118579071678501,排队号为238
已接收过此消息,票券号为2604262118579072062602,排队号为239
2026-04-26 21:20:08 开始打印,排队:240,票券:2604262120017653115901,订单:2604262120010074423658,[2026-04-26 21:20:07微信支付12元]
2026-04-26 21:20:08>>>MQTT票号同步场景，创建空订单对象
2026-04-26 21:20:08>>>合并MQTT票号列表到订单同步请求,共4张票
2026-04-26 21:20:10 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604262118537700619401","queue_number":237,"trade_uid":"2604262118530074151853"},{"ticket_no":"2604262118579071678501","queue_number":238,"trade_uid":"2604262118570088962383"},{"ticket_no":"2604262118579072062602","queue_number":239,"trade_uid":"2604262118570088962383"},{"ticket_no":"2604262120017653115901","queue_number":240,"trade_uid":"2604262120010074423658"}]}
2026-04-26 21:20:10 >>>故障排除日志:删除未同步下发订单成功2604262118530074151853
2026-04-26 21:20:10 >>>故障排除日志:删除未同步下发订单成功2604262118570088962383
2026-04-26 21:20:10 >>>故障排除日志:删除未同步下发订单成功2604262118570088962383
2026-04-26 21:20:10 >>>故障排除日志:删除未同步下发订单成功2604262120010074423658
2026-04-26 21:20:10 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536879298]


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


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


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


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


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


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


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


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


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


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


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


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


===22:02:53===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 22:02:19 >>>回调事件[910,devices/S1754]
2026-04-26 22:02:19 >>>故障排除日志:上一MQTT订单号缓存列表为2604262200550071428576
2026-04-26 22:02:19 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 22:02:19 开始打印,排队:256,票券:2604262202125509194901,订单:2604262202120053260236,[2026-04-26 22:02:19微信支付12元]
2026-04-26 22:02:19>>>MQTT票号同步场景，创建空订单对象
2026-04-26 22:02:19>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 22:02:21 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604262202125509194901","queue_number":256,"trade_uid":"2604262202120053260236"}]}
2026-04-26 22:02:21 >>>故障排除日志:删除未同步下发订单成功2604262202120053260236
2026-04-26 22:02:21 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536879798]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 22:02:32 >>>回调事件[910,devices/S1754]
2026-04-26 22:02:32 >>>故障排除日志:上一MQTT订单号缓存列表为2604262202120053260236
2026-04-26 22:02:32 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 22:02:32 开始打印,排队:257,票券:2604262202283084887501,订单:2604262202280028978695,[2026-04-26 22:02:31支付宝支付12元]
2026-04-26 22:02:32>>>MQTT票号同步场景，创建空订单对象
2026-04-26 22:02:32>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 22:02:34 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604262202283084887501","queue_number":257,"trade_uid":"2604262202280028978695"}]}
2026-04-26 22:02:34 >>>故障排除日志:删除未同步下发订单成功2604262202280028978695
2026-04-26 22:02:34 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536879804]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 22:02:47 >>>回调事件[910,devices/S1754]
2026-04-26 22:02:47 >>>故障排除日志:上一MQTT订单号缓存列表为2604262202280028978695
2026-04-26 22:02:47 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 22:02:47 开始打印,排队:258,票券:2604262202383928755801,订单:2604262202380037284274,[2026-04-26 22:02:46微信支付12元]
2026-04-26 22:02:47>>>MQTT票号同步场景，创建空订单对象
2026-04-26 22:02:47>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 22:02:49 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604262202383928755801","queue_number":258,"trade_uid":"2604262202380037284274"}]}
2026-04-26 22:02:49 >>>故障排除日志:删除未同步下发订单成功2604262202380037284274
2026-04-26 22:02:49 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536879815]


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


===23:06:58===
2026-04-26 23:06:36>>>cash read=00
2026-04-26 23:06:37>>>cash read=3E
2026-04-26 23:06:39>>>cash read=00
2026-04-26 23:06:40>>>cash read=818F4200
2026-04-26 23:06:40>>>cash write=02
2026-04-26 23:06:40 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 23:06:41>>>cash read=10
2026-04-26 23:06:41 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 23:06:42>>>cash write=0C
2026-04-26 23:06:42>>>cash read=3E
2026-04-26 23:06:42 >>>开始未足额打印,排队号为279,订单号为2604262306410021754928
2026-04-26 23:06:43 订单投币结束,共投币10元,请取走您的小票
2026-04-26 23:06:43>>>订单2604262306410021754928写入成功,剩余空间为1671000,占用RAM为650.4521484375
删除未同步订单2604262306410021754928
2026-04-26 23:06:44>>>订单2604262306410021754928删除成功,剩余空间为1672000,占用RAM为646.3203125
检测订单目录中>>>
无未同步订单>>>
2026-04-26 23:06:45 >>>当前Ram内存为617.158203125
定时检测未同步订单启用[checkOrderNum=536880557]
2026-04-26 23:06:46>>>cash read=00
2026-04-26 23:06:46>>>cash read=818F42
2026-04-26 23:06:46>>>cash write=02
2026-04-26 23:06:46 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 23:06:46>>>cash read=10
2026-04-26 23:06:47 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 23:06:47 >>>开始未足额打印,排队号为280,订单号为2604262306470021754134
2026-04-26 23:06:47 订单投币结束,共投币10元,请取走您的小票
2026-04-26 23:06:48>>>订单2604262306470021754134写入成功,剩余空间为1670000,占用RAM为634.3544921875
删除未同步订单2604262306470021754134
2026-04-26 23:06:50>>>订单2604262306470021754134删除成功,剩余空间为1671000,占用RAM为655.6630859375
检测订单目录中>>>
无未同步订单>>>
2026-04-26 23:06:50 >>>当前Ram内存为617.28515625
定时检测未同步订单启用[checkOrderNum=536880569]
2026-04-26 23:06:50>>>cash write=0C
2026-04-26 23:06:50>>>cash read=3E


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


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


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


===23:18:59===
2026-04-26 23:17:58 >>>开始未足额打印,排队号为284,订单号为2604262317540021754954
2026-04-26 23:17:58 订单投币结束,共投币10元,请取走您的小票
2026-04-26 23:17:58>>>订单2604262317540021754954写入成功,剩余空间为1672000,占用RAM为653.7890625
删除未同步订单2604262317540021754954
2026-04-26 23:18:00>>>订单2604262317540021754954删除成功,剩余空间为1673000,占用RAM为644.6083984375
检测订单目录中>>>
无未同步订单>>>
2026-04-26 23:18:00 >>>当前Ram内存为615.6015625
定时检测未同步订单启用[checkOrderNum=536880706]


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