TLClient_JSSCOM_LuatOS-Air_V4010_RDA8910_RFTTS_0xe0000,2.8.6,869701078910422,85805052472562,
poweron reason:0

===08:42:44===
上一时间戳为1777077520
隔日重置时间戳true
隔日清空未同步下发列表true
当前排队号为1,音量为5
初始化产品信息:[{"time_limit_date":null,"ticket_category":"0","expiry_date":90,"product_detail":"","time_limit_status":"0","begin_minute":null,"product_uid":"12711098232278654954","use_timer":1,"old_price":"10","end_hour":null,"sale_price":"10","end_minute":null,"begin_hour":null,"sale_status":1,"product_name":"剪发"}]
是否打印二维码设置为1
是否打印紧凑设置为3
当前号显示模式设置为2
当前卡项核销权限设置为0
session_id:9b74b****22271
纸币器设置接收纸币范围为36
欢迎使用天羚自助售票系统[2.8.6]
定时检测未同步订单启用[checkOrderNum=536870969]
2026-04-26 08:41:43>>>cash write=30
2026-04-26 08:41:43>>>cash write=02
2026-04-26 08:41:43>>>cash write=3E
2026-04-26 08:41:43>>>cash read=808F808F
系统时间初始化成功，时间为202642684143
2026-04-26 08:41:44>>>cash write=02
2026-04-26 08:41:44 >>>剩余flash空间=1680000,占用RAM为656.607421875
2026-04-26 08:41:44 >>>回调事件:910,subscribe,10000,连接服务器成功

请求下发消息结果为0,Message sent successfully
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 08:41:45 >>>回调事件[910,devices/TL3919]
当日首次设置时间戳true为1777164105
2026-04-26 08:41:45 >>>故障排除日志:上一MQTT订单号缓存列表为2604252122270062226337
2026-04-26 08:41:45 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 08:41:45 开始打印,排队:1,票券:2604260834125831737401,订单:2604260834120055639556,[2026-04-26 08:34:20微信支付10元]
2026-04-26 08:41:45 开始打印,排队:2,票券:2604260839026008229701,订单:2604260839020057912069,[2026-04-26 08:39:10微信支付10元]
2026-04-26 08:41:45 开始打印,排队:3,票券:2604260839070887408301,订单:2604260839070006979161,[2026-04-26 08:39:14微信支付10元]
2026-04-26 08:41:45>>>MQTT票号同步场景，创建空订单对象
2026-04-26 08:41:45>>>合并MQTT票号列表到订单同步请求,共3张票
流量卡还有248天过期
2026-04-26 08:41:51 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604260834125831737401","queue_number":1,"trade_uid":"2604260834120055639556"},{"ticket_no":"2604260839026008229701","queue_number":2,"trade_uid":"2604260839020057912069"},{"ticket_no":"2604260839070887408301","queue_number":3,"trade_uid":"2604260839070006979161"}]}
2026-04-26 08:41:51 >>>故障排除日志:删除未同步下发订单成功2604260834120055639556
2026-04-26 08:41:51 >>>故障排除日志:删除未同步下发订单成功2604260839020057912069
2026-04-26 08:41:51 >>>故障排除日志:删除未同步下发订单成功2604260839070006979161
2026-04-26 08:41:51 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536870985]
2026-04-26 08:41:52>>>cash write=0C
2026-04-26 08:41:52>>>cash read=3E
2026-04-26 08:41:54 >>>当前Ram内存为664.439453125
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 08:42:26 >>>回调事件[910,devices/TL3919]
2026-04-26 08:42:26 >>>故障排除日志:上一MQTT订单号缓存列表为2604260834120055639556|2604260839020057912069|2604260839070006979161
2026-04-26 08:42:26 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 08:42:26 开始打印,排队:4,票券:2604260842148427648201,订单:2604260842140082333347,[2026-04-26 08:42:25微信支付10元]
2026-04-26 08:42:26>>>MQTT票号同步场景，创建空订单对象
2026-04-26 08:42:26>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 08:42:28 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604260842148427648201","queue_number":4,"trade_uid":"2604260842140082333347"}]}
2026-04-26 08:42:28 >>>故障排除日志:删除未同步下发订单成功2604260842140082333347
2026-04-26 08:42:28 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536870994]
2026-04-26 08:42:37>>>cash read=00
2026-04-26 08:42:38>>>cash read=818F42
2026-04-26 08:42:38>>>cash write=02
2026-04-26 08:42:38 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 08:42:38>>>cash read=10
2026-04-26 08:42:38 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 08:42:38 当前产品价格10元，投币10元，打印小票中...
2026-04-26 08:42:39 >>>开始打印,排队号为5,订单号为2604260842390013919093
2026-04-26 08:42:39>>>订单2604260842390013919093写入成功,剩余空间为1675500,占用RAM为660.6591796875
删除未同步订单2604260842390013919093
2026-04-26 08:42:41>>>订单2604260842390013919093删除成功,剩余空间为1676500,占用RAM为656.763671875
检测订单目录中>>>
无未同步订单>>>


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


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


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


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


===09:00:45===
2026-04-26 08:59:55>>>cash read=0A
2026-04-26 08:59:56>>>cash read=3E


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


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


===09:21:12===
上一时间戳为1777164105
当日首次设置时间戳true为1777166411
今日nvm排队号为13
当前排队号为13,音量为5
初始化产品信息:[{"time_limit_date":null,"ticket_category":"0","expiry_date":90,"product_detail":"","time_limit_status":"0","begin_minute":null,"product_uid":"12711098232278654954","use_timer":1,"old_price":"10","end_hour":null,"sale_price":"10","end_minute":null,"begin_hour":null,"sale_status":1,"product_name":"剪发"}]
是否打印二维码设置为1
是否打印紧凑设置为3
当前号显示模式设置为2
当前卡项核销权限设置为0
session_id:8cd9f****70921
纸币器设置接收纸币范围为36
欢迎使用天羚自助售票系统[2.8.6]
定时检测未同步订单启用[checkOrderNum=536870969]
2026-04-26 09:20:12>>>cash write=30
2026-04-26 09:20:12>>>cash write=02
2026-04-26 09:20:12>>>cash write=3E
2026-04-26 09:20:12>>>cash read=808F808F
系统时间初始化成功，时间为202642692012
2026-04-26 09:20:13>>>cash write=02
2026-04-26 09:20:13 >>>剩余flash空间=1680000,占用RAM为657.2236328125
2026-04-26 09:20:13 >>>回调事件:910,subscribe,10000,连接服务器成功

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


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


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


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


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


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


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


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


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


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


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


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


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


===10:51:16===
2026-04-26 10:50:16 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261049551509556401","queue_number":27,"trade_uid":"2604261049550012672778"},{"ticket_no":"2604261049551509958302","queue_number":28,"trade_uid":"2604261049550012672778"}]}
2026-04-26 10:50:16 >>>故障排除日志:删除未同步下发订单成功2604261049550012672778
2026-04-26 10:50:16 >>>故障排除日志:删除未同步下发订单成功2604261049550012672778
2026-04-26 10:50:16 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536871908]


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


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


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


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


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


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


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


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


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


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


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


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


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


===12:05:19===
2026-04-26 12:04:18 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261204040684344701","queue_number":42,"trade_uid":"2604261204040004940084"},{"ticket_no":"2604261204040684909402","queue_number":43,"trade_uid":"2604261204040004940084"}]}
2026-04-26 12:04:18 >>>故障排除日志:删除未同步下发订单成功2604261204040004940084
2026-04-26 12:04:18 >>>故障排除日志:删除未同步下发订单成功2604261204040004940084
2026-04-26 12:04:18 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536872680]


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


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


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


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


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


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


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


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


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


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


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


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


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


===13:55:22===
2026-04-26 13:54:34>>>cash read=00
2026-04-26 13:54:34>>>cash read=818F42
2026-04-26 13:54:35>>>cash write=02
2026-04-26 13:54:35 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 13:54:35>>>cash read=10
2026-04-26 13:54:35 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 13:54:35 当前产品价格10元，投币10元，打印小票中...
2026-04-26 13:54:35 >>>开始打印,排队号为57,订单号为2604261354350013919961
2026-04-26 13:54:35>>>订单2604261354350013919961写入成功,剩余空间为1679500,占用RAM为634.5703125
删除未同步订单2604261354350013919961
2026-04-26 13:54:37>>>订单2604261354350013919961删除成功,剩余空间为1680500,占用RAM为643.3671875
检测订单目录中>>>
无未同步订单>>>
2026-04-26 13:54:37 >>>当前Ram内存为616.7138671875
定时检测未同步订单启用[checkOrderNum=536873778]
2026-04-26 13:54:38>>>cash write=0C
2026-04-26 13:54:38>>>cash read=3E
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 13:54:54 >>>回调事件[910,devices/TL3919]
2026-04-26 13:54:54 >>>故障排除日志:上一MQTT订单号缓存列表为2604261311080044716296
2026-04-26 13:54:54 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 13:54:54 开始打印,排队:58,票券:2604261354469783735801,订单:2604261354460096092038,[2026-04-26 13:54:53微信支付10元]
2026-04-26 13:54:54>>>MQTT票号同步场景，创建空订单对象
2026-04-26 13:54:54>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 13:54:56 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261354469783735801","queue_number":58,"trade_uid":"2604261354460096092038"}]}
2026-04-26 13:54:56 >>>故障排除日志:删除未同步下发订单成功2604261354460096092038
2026-04-26 13:54:56 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536873784]


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


===16:33:27===
2026-04-26 16:33:14>>>cash read=00
2026-04-26 16:33:15>>>cash read=29
2026-04-26 16:33:15 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 16:33:16>>>cash read=3E
2026-04-26 16:33:18>>>cash read=00
2026-04-26 16:33:19>>>cash read=818F43
2026-04-26 16:33:19>>>cash write=02
2026-04-26 16:33:19 >>>回调事件130,cash_status,10022,进钞中...read money=20
2026-04-26 16:33:20>>>cash read=10
2026-04-26 16:33:20 >>>回调事件130,20,10023,finish Money=20,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 16:33:20 当前产品价格10元，投币20元，打印小票中...
2026-04-26 16:33:20 >>>开始打印,排队号为87,订单号为2604261633200013919519
2026-04-26 16:33:20 >>>开始打印,排队号为88,订单号为2604261633200013919519
2026-04-26 16:33:20>>>订单2604261633200013919519写入成功,剩余空间为1679000,占用RAM为643.01953125
删除未同步订单2604261633200013919519
2026-04-26 16:33:24>>>订单2604261633200013919519删除成功,剩余空间为1680500,占用RAM为656.0087890625
检测订单目录中>>>
无未同步订单>>>
2026-04-26 16:33:24 >>>当前Ram内存为618.3974609375
定时检测未同步订单启用[checkOrderNum=536875432]
2026-04-26 16:33:25>>>cash write=0C
2026-04-26 16:33:25>>>cash read=3E


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


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


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


===16:51:28===
2026-04-26 16:50:27 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261650156231361301","queue_number":91,"trade_uid":"2604261650150060212332"}]}
2026-04-26 16:50:27 >>>故障排除日志:删除未同步下发订单成功2604261650150060212332
2026-04-26 16:50:27 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536875611]
2026-04-26 16:50:51>>>cash read=00
2026-04-26 16:50:51>>>cash read=818F42
2026-04-26 16:50:51>>>cash write=02
2026-04-26 16:50:51 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 16:50:52>>>cash read=10
2026-04-26 16:50:52 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 16:50:52 当前产品价格10元，投币10元，打印小票中...
2026-04-26 16:50:52 >>>开始打印,排队号为92,订单号为2604261650520013919628
2026-04-26 16:50:52>>>订单2604261650520013919628写入成功,剩余空间为1679500,占用RAM为637.431640625
删除未同步订单2604261650520013919628
2026-04-26 16:50:54>>>订单2604261650520013919628删除成功,剩余空间为1680000,占用RAM为647.6962890625
检测订单目录中>>>
无未同步订单>>>
2026-04-26 16:50:54 >>>当前Ram内存为618.6533203125
定时检测未同步订单启用[checkOrderNum=536875619]
2026-04-26 16:50:55>>>cash write=0C
2026-04-26 16:50:55>>>cash read=3E


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


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


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


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


===17:08:29===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 17:07:33 >>>回调事件[910,devices/TL3919]
2026-04-26 17:07:33 >>>故障排除日志:上一MQTT订单号缓存列表为2604261658460042760447
2026-04-26 17:07:33 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 17:07:33 开始打印,排队:98,票券:2604261707266452835101,订单:2604261707260062521946,[2026-04-26 17:07:32微信支付10元]
2026-04-26 17:07:33>>>MQTT票号同步场景，创建空订单对象
2026-04-26 17:07:33>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 17:07:35 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261707266452835101","queue_number":98,"trade_uid":"2604261707260062521946"}]}
2026-04-26 17:07:35 >>>故障排除日志:删除未同步下发订单成功2604261707260062521946
2026-04-26 17:07:35 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536875811]
2026-04-26 17:07:57>>>cash read=00
2026-04-26 17:07:58>>>cash read=818F42
2026-04-26 17:07:58>>>cash write=02
2026-04-26 17:07:58 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 17:07:58>>>cash read=10
2026-04-26 17:07:58 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 17:07:58 当前产品价格10元，投币10元，打印小票中...
2026-04-26 17:07:59 >>>开始打印,排队号为99,订单号为2604261707590013919787
2026-04-26 17:07:59>>>订单2604261707590013919787写入成功,剩余空间为1678500,占用RAM为639.33203125
删除未同步订单2604261707590013919787
2026-04-26 17:08:01>>>订单2604261707590013919787删除成功,剩余空间为1679500,占用RAM为647.7744140625
检测订单目录中>>>
无未同步订单>>>
2026-04-26 17:08:01 >>>当前Ram内存为619.296875
定时检测未同步订单启用[checkOrderNum=536875820]
2026-04-26 17:08:02>>>cash write=0C
2026-04-26 17:08:02>>>cash read=3E


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


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


===17:12:30===
2026-04-26 17:11:46>>>cash read=00
2026-04-26 17:11:47>>>cash read=01
2026-04-26 17:11:49>>>cash read=3E
2026-04-26 17:11:54>>>cash read=29
2026-04-26 17:11:54 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 17:11:54>>>cash read=2F29
2026-04-26 17:11:55>>>cash read=00
2026-04-26 17:11:56>>>cash read=818F42
2026-04-26 17:11:56>>>cash write=02
2026-04-26 17:11:56 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 17:11:56>>>cash read=10
2026-04-26 17:11:56 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 17:11:56 当前产品价格10元，投币10元，打印小票中...
2026-04-26 17:11:56 >>>开始打印,排队号为102,订单号为2604261711560013919358
2026-04-26 17:11:56>>>订单2604261711560013919358写入成功,剩余空间为1679500,占用RAM为637.2080078125
删除未同步订单2604261711560013919358
2026-04-26 17:11:58>>>订单2604261711560013919358删除成功,剩余空间为1680500,占用RAM为644.7001953125
检测订单目录中>>>
无未同步订单>>>
2026-04-26 17:11:58 >>>当前Ram内存为617.6533203125
定时检测未同步订单启用[checkOrderNum=536875881]
2026-04-26 17:11:59>>>cash write=0C
2026-04-26 17:11:59>>>cash read=3E


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


===18:45:37===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 18:45:32 >>>回调事件[910,devices/TL3919]
2026-04-26 18:45:32 >>>故障排除日志:上一MQTT订单号缓存列表为2604261842260014648661
2026-04-26 18:45:32 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 18:45:32 开始打印,排队:123,票券:2604261845254023176201,订单:2604261845250037146768,[2026-04-26 18:45:32微信支付10元]
2026-04-26 18:45:32 开始打印,排队:124,票券:2604261845254023586802,订单:2604261845250037146768,[2026-04-26 18:45:32微信支付10元]
2026-04-26 18:45:33>>>MQTT票号同步场景，创建空订单对象
2026-04-26 18:45:33>>>合并MQTT票号列表到订单同步请求,共2张票


===18:46:37===
2026-04-26 18:45:36 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261845254023176201","queue_number":123,"trade_uid":"2604261845250037146768"},{"ticket_no":"2604261845254023586802","queue_number":124,"trade_uid":"2604261845250037146768"}]}
2026-04-26 18:45:36 >>>故障排除日志:删除未同步下发订单成功2604261845250037146768
2026-04-26 18:45:36 >>>故障排除日志:删除未同步下发订单成功2604261845250037146768
2026-04-26 18:45:36 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536876895]


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


===20:32:46===
2026-04-26 20:31:45 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604262031352111755601","queue_number":150,"trade_uid":"2604262031350019181523"}]}
2026-04-26 20:31:45 >>>故障排除日志:删除未同步下发订单成功2604262031350019181523
2026-04-26 20:31:45 >>>故障排除日志:终端同步成功后剩余订单列表01512604262031350094234997
定时检测未同步订单启用[checkOrderNum=536878042]


===20:39:46===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 20:39:31 >>>回调事件[910,devices/TL3919]
2026-04-26 20:39:31 >>>故障排除日志:上一MQTT订单号缓存列表为2604262031350019181523|2604262031350094234997
2026-04-26 20:39:31 >>>故障排除日志:终端未同步成功订单列表01512604262031350094234997
已接收过此消息,票券号为2604262031359622957801,排队号为151
2026-04-26 20:39:31 开始打印,排队:152,票券:2604262039259962771901,订单:2604262039250095125582,[2026-04-26 20:39:30支付宝支付10元]
2026-04-26 20:39:31>>>MQTT票号同步场景，创建空订单对象
2026-04-26 20:39:31>>>合并MQTT票号列表到订单同步请求,共2张票
2026-04-26 20:39:33 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604262031359622957801","queue_number":151,"trade_uid":"2604262031350094234997"},{"ticket_no":"2604262039259962771901","queue_number":152,"trade_uid":"2604262039250095125582"}]}
2026-04-26 20:39:33 >>>故障排除日志:删除未同步下发订单成功2604262031350094234997
2026-04-26 20:39:33 >>>故障排除日志:删除未同步下发订单成功2604262039250095125582
2026-04-26 20:39:33 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878122]


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


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


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