TLClient_JSSCOM_LuatOS-Air_V4010_RDA8910_RFTTS_0xe0000,2.8.6,869701078910257,62712524744082,
poweron reason:0

===08:40:40===
上一时间戳为1777079189
隔日重置时间戳true
隔日清空未同步下发列表true
当前排队号为241,音量为5
初始化产品信息:[{"time_limit_date":null,"ticket_category":"0","expiry_date":90,"product_detail":"","time_limit_status":"0","begin_minute":null,"product_uid":"14872826055362746031","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
当前号显示模式设置为1
当前卡项核销权限设置为0
session_id:5bc2a****c5c76
纸币器设置接收纸币范围为36
欢迎使用天羚自助售票系统[2.8.6]
定时检测未同步订单启用[checkOrderNum=536870969]
2026-04-26 08:39:40>>>cash write=30
2026-04-26 08:39:40>>>cash write=02
2026-04-26 08:39:40>>>cash write=3E
2026-04-26 08:39:40>>>cash read=808F808F
系统时间初始化成功，时间为202642683940
2026-04-26 08:39:41>>>cash write=02
2026-04-26 08:39:41 >>>剩余flash空间=1680000,占用RAM为651.2568359375
2026-04-26 08:39:41 >>>回调事件:910,subscribe,10000,连接服务器成功

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

2026-04-26 08:39:44>>>cash write=0C
2026-04-26 08:39:44>>>cash read=3E
流量卡还有248天过期
2026-04-26 08:39:52 >>>当前Ram内存为676.4765625


===08:42:42===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 08:42:39 >>>回调事件[910,devices/TL3921]
当日首次设置时间戳true为1777164159
2026-04-26 08:42:39 >>>故障排除日志:上一MQTT订单号缓存列表为2604252052520064487839
2026-04-26 08:42:39 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 08:42:39 开始打印,排队:241,票券:2604260842307473023401,订单:2604260842300071848886,[2026-04-26 08:42:38微信支付10元]
2026-04-26 08:42:39>>>MQTT票号同步场景，创建空订单对象
2026-04-26 08:42:39>>>合并MQTT票号列表到订单同步请求,共1张票


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


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


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


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


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


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


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


===09:08:45===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 09:07:54 >>>回调事件[910,devices/TL3921]
2026-04-26 09:07:54 >>>故障排除日志:上一MQTT订单号缓存列表为2604260906310044001697
2026-04-26 09:07:54 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 09:07:54 开始打印,排队:249,票券:2604260907383667955701,订单:2604260907380034725486,[2026-04-26 09:07:52微信支付10元]
2026-04-26 09:07:54>>>MQTT票号同步场景，创建空订单对象
2026-04-26 09:07:54>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 09:07:56 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604260907383667955701","queue_number":249,"trade_uid":"2604260907380034725486"}]}
2026-04-26 09:07:56 >>>故障排除日志:删除未同步下发订单成功2604260907380034725486
2026-04-26 09:07:56 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536871313]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 09:08:24 >>>回调事件[910,devices/TL3921]
2026-04-26 09:08:24 >>>故障排除日志:上一MQTT订单号缓存列表为2604260907380034725486
2026-04-26 09:08:24 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 09:08:24 开始打印,排队:250,票券:2604260908159891355101,订单:2604260908150096975241,[2026-04-26 09:08:22微信支付10元]
2026-04-26 09:08:24>>>MQTT票号同步场景，创建空订单对象
2026-04-26 09:08:24>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 09:08:26 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604260908159891355101","queue_number":250,"trade_uid":"2604260908150096975241"}]}
2026-04-26 09:08:26 >>>故障排除日志:删除未同步下发订单成功2604260908150096975241
2026-04-26 09:08:26 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536871326]
2026-04-26 09:08:35>>>cash read=29
2026-04-26 09:08:35 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 09:08:36>>>cash read=2F29
2026-04-26 09:08:37>>>cash read=01
2026-04-26 09:08:41>>>cash read=2F
2026-04-26 09:08:42>>>cash read=29
2026-04-26 09:08:42 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 09:08:42>>>cash read=2F29
2026-04-26 09:08:43>>>cash read=01


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


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


===09:17:45===
2026-04-26 09:16:45>>>cash write=0C
2026-04-26 09:16:45>>>cash read=3E
2026-04-26 09:17:09>>>cash read=0A
2026-04-26 09:17:10>>>cash read=3E


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


===10:31:50===
2026-04-26 10:30:54>>>cash read=29
2026-04-26 10:30:54 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 10:30:55>>>cash read=01
2026-04-26 10:30:56>>>cash read=3E
2026-04-26 10:30:57>>>cash read=00
2026-04-26 10:30:58>>>cash read=2F29
2026-04-26 10:30:59>>>cash read=01
2026-04-26 10:31:00>>>cash read=2F
2026-04-26 10:31:01>>>cash read=3E
2026-04-26 10:31:04>>>cash read=00
2026-04-26 10:31:05>>>cash read=818F42
2026-04-26 10:31:05>>>cash write=02
2026-04-26 10:31:05 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 10:31:05>>>cash read=10
2026-04-26 10:31:05 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 10:31:05 当前产品价格10元，投币10元，打印小票中...
2026-04-26 10:31:05 >>>开始打印,排队号为273,订单号为2604261031050013921352
2026-04-26 10:31:06>>>订单2604261031050013921352写入成功,剩余空间为1679500,占用RAM为637.71484375
删除未同步订单2604261031050013921352
2026-04-26 10:31:08>>>订单2604261031050013921352删除成功,剩余空间为1680000,占用RAM为646.5595703125
检测订单目录中>>>
无未同步订单>>>
2026-04-26 10:31:08 >>>当前Ram内存为617.7626953125
定时检测未同步订单启用[checkOrderNum=536872286]
2026-04-26 10:31:09>>>cash write=0C
2026-04-26 10:31:09>>>cash read=3E


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


===10:40:51===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 10:39:55 >>>回调事件[910,devices/TL3921]
2026-04-26 10:39:55 >>>故障排除日志:上一MQTT订单号缓存列表为2604261034210093501731
2026-04-26 10:39:55 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 10:39:55 开始打印,排队:275,票券:2604261039477476907301,订单:2604261039470072889525,[2026-04-26 10:39:54微信支付10元]
2026-04-26 10:39:56>>>MQTT票号同步场景，创建空订单对象
2026-04-26 10:39:56>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 10:39:57 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261039477476907301","queue_number":275,"trade_uid":"2604261039470072889525"}]}
2026-04-26 10:39:57 >>>故障排除日志:删除未同步下发订单成功2604261039470072889525
2026-04-26 10:39:58 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536872381]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 10:40:36 >>>回调事件[910,devices/TL3921]
2026-04-26 10:40:36 >>>故障排除日志:上一MQTT订单号缓存列表为2604261039470072889525
2026-04-26 10:40:36 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 10:40:36 开始打印,排队:276,票券:2604261040294091647501,订单:2604261040290038948498,[2026-04-26 10:40:35微信支付10元]
2026-04-26 10:40:36>>>MQTT票号同步场景，创建空订单对象
2026-04-26 10:40:36>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 10:40:38 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261040294091647501","queue_number":276,"trade_uid":"2604261040290038948498"}]}
2026-04-26 10:40:38 >>>故障排除日志:删除未同步下发订单成功2604261040290038948498
2026-04-26 10:40:38 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536872395]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 10:40:48 >>>回调事件[910,devices/TL3921]
2026-04-26 10:40:48 >>>故障排除日志:上一MQTT订单号缓存列表为2604261040290038948498
2026-04-26 10:40:48 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 10:40:48 开始打印,排队:277,票券:2604261040444821558101,订单:2604261040440046181487,[2026-04-26 10:40:47支付宝支付10元]
2026-04-26 10:40:48>>>MQTT票号同步场景，创建空订单对象
2026-04-26 10:40:48>>>合并MQTT票号列表到订单同步请求,共1张票


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


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


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


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


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


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


===11:36:53===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 11:35:59 >>>回调事件[910,devices/TL3921]
2026-04-26 11:35:59 >>>故障排除日志:上一MQTT订单号缓存列表为2604261126310012664594|2604261126310012664594
2026-04-26 11:35:59 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 11:35:59 开始打印,排队:285,票券:2604261135508710612101,订单:2604261135500085188812,[2026-04-26 11:35:58支付宝支付10元]
2026-04-26 11:36:00>>>MQTT票号同步场景，创建空订单对象
2026-04-26 11:36:00>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 11:36:01 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261135508710612101","queue_number":285,"trade_uid":"2604261135500085188812"}]}
2026-04-26 11:36:01 >>>故障排除日志:删除未同步下发订单成功2604261135500085188812
2026-04-26 11:36:02 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536872967]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 11:36:26 >>>回调事件[910,devices/TL3921]
2026-04-26 11:36:26 >>>故障排除日志:上一MQTT订单号缓存列表为2604261135500085188812
2026-04-26 11:36:26 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 11:36:26 开始打印,排队:286,票券:2604261136183436758401,订单:2604261136180032458369,[2026-04-26 11:36:24微信支付10元]
2026-04-26 11:36:26 开始打印,排队:287,票券:2604261136183437335902,订单:2604261136180032458369,[2026-04-26 11:36:24微信支付10元]
2026-04-26 11:36:26>>>MQTT票号同步场景，创建空订单对象
2026-04-26 11:36:26>>>合并MQTT票号列表到订单同步请求,共2张票
2026-04-26 11:36:29 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261136183436758401","queue_number":286,"trade_uid":"2604261136180032458369"},{"ticket_no":"2604261136183437335902","queue_number":287,"trade_uid":"2604261136180032458369"}]}
2026-04-26 11:36:29 >>>故障排除日志:删除未同步下发订单成功2604261136180032458369
2026-04-26 11:36:29 >>>故障排除日志:删除未同步下发订单成功2604261136180032458369
2026-04-26 11:36:30 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536872978]


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


===12:11:54===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 12:11:04 >>>回调事件[910,devices/TL3921]
2026-04-26 12:11:04 >>>故障排除日志:上一MQTT订单号缓存列表为2604261150570077605864
2026-04-26 12:11:04 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 12:11:04 开始打印,排队:289,票券:2604261210569262426101,订单:2604261210560090455213,[2026-04-26 12:11:02微信支付10元]
2026-04-26 12:11:04>>>MQTT票号同步场景，创建空订单对象
2026-04-26 12:11:04>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 12:11:06 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261210569262426101","queue_number":289,"trade_uid":"2604261210560090455213"}]}
2026-04-26 12:11:06 >>>故障排除日志:删除未同步下发订单成功2604261210560090455213
2026-04-26 12:11:06 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536873308]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 12:11:34 >>>回调事件[910,devices/TL3921]
2026-04-26 12:11:34 >>>故障排除日志:上一MQTT订单号缓存列表为2604261210560090455213
2026-04-26 12:11:34 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 12:11:34 开始打印,排队:290,票券:2604261211289053056401,订单:2604261211280088764859,[2026-04-26 12:11:33支付宝支付10元]
2026-04-26 12:11:34 开始打印,排队:291,票券:2604261211289053615402,订单:2604261211280088764859,[2026-04-26 12:11:33支付宝支付10元]
2026-04-26 12:11:34>>>MQTT票号同步场景，创建空订单对象
2026-04-26 12:11:34>>>合并MQTT票号列表到订单同步请求,共2张票
2026-04-26 12:11:38 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261211289053056401","queue_number":290,"trade_uid":"2604261211280088764859"},{"ticket_no":"2604261211289053615402","queue_number":291,"trade_uid":"2604261211280088764859"}]}
2026-04-26 12:11:38 >>>故障排除日志:删除未同步下发订单成功2604261211280088764859
2026-04-26 12:11:38 >>>故障排除日志:删除未同步下发订单成功2604261211280088764859
2026-04-26 12:11:38 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536873315]


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


===13:38:00===
2026-04-26 13:37:34>>>cash read=00
2026-04-26 13:37:35>>>cash read=818F42
2026-04-26 13:37:35>>>cash write=02
2026-04-26 13:37:35 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 13:37:36>>>cash read=10
2026-04-26 13:37:36 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 13:37:36 当前产品价格10元，投币10元，打印小票中...
2026-04-26 13:37:36 >>>开始打印,排队号为311,订单号为2604261337360013921303
2026-04-26 13:37:36>>>订单2604261337360013921303写入成功,剩余空间为1679500,占用RAM为634.123046875
删除未同步订单2604261337360013921303
2026-04-26 13:37:38>>>订单2604261337360013921303删除成功,剩余空间为1680500,占用RAM为644.5361328125
检测订单目录中>>>
无未同步订单>>>
2026-04-26 13:37:38 >>>当前Ram内存为616.263671875
定时检测未同步订单启用[checkOrderNum=536874268]
2026-04-26 13:37:39>>>cash write=0C
2026-04-26 13:37:39>>>cash read=3E
2026-04-26 13:37:44>>>cash read=00
2026-04-26 13:37:44>>>cash read=818F42
2026-04-26 13:37:44>>>cash write=02
2026-04-26 13:37:44 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 13:37:45>>>cash read=10
2026-04-26 13:37:45 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 13:37:45 当前产品价格10元，投币10元，打印小票中...
2026-04-26 13:37:45 >>>开始打印,排队号为312,订单号为2604261337450013921424
2026-04-26 13:37:45>>>订单2604261337450013921424写入成功,剩余空间为1678500,占用RAM为640.685546875
删除未同步订单2604261337450013921424
2026-04-26 13:37:47>>>订单2604261337450013921424删除成功,剩余空间为1679500,占用RAM为646.685546875
检测订单目录中>>>
无未同步订单>>>
2026-04-26 13:37:47 >>>当前Ram内存为618.2734375
定时检测未同步订单启用[checkOrderNum=536874280]
2026-04-26 13:37:48>>>cash write=0C
2026-04-26 13:37:48>>>cash read=3E


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


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


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


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


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


===14:02:02===
2026-04-26 14:01:29>>>cash read=29
2026-04-26 14:01:29 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 14:01:29>>>cash read=2F29
2026-04-26 14:01:30>>>cash read=01
2026-04-26 14:01:34>>>cash read=2F
2026-04-26 14:01:35>>>cash read=29
2026-04-26 14:01:35 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 14:01:36>>>cash read=3E
2026-04-26 14:01:40>>>cash read=00
2026-04-26 14:01:41>>>cash read=01
2026-04-26 14:01:46>>>cash read=00
2026-04-26 14:01:47>>>cash read=818F42
2026-04-26 14:01:47>>>cash write=02
2026-04-26 14:01:47 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 14:01:47>>>cash read=10
2026-04-26 14:01:47 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 14:01:47 当前产品价格10元，投币10元，打印小票中...
2026-04-26 14:01:47 >>>开始打印,排队号为318,订单号为2604261401470013921001
2026-04-26 14:01:48>>>订单2604261401470013921001写入成功,剩余空间为1679500,占用RAM为637.3583984375
删除未同步订单2604261401470013921001
2026-04-26 14:01:50>>>订单2604261401470013921001删除成功,剩余空间为1680000,占用RAM为644.4033203125
检测订单目录中>>>
无未同步订单>>>
2026-04-26 14:01:50 >>>当前Ram内存为617.0537109375
定时检测未同步订单启用[checkOrderNum=536874545]
2026-04-26 14:01:51>>>cash write=0C
2026-04-26 14:01:51>>>cash read=3E


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


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


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


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


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


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


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


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


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


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


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


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


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


===15:19:07===
删除未同步订单2604261518040013921543
2026-04-26 15:18:06>>>订单2604261518040013921543删除成功,剩余空间为1681500,占用RAM为645.931640625
检测订单目录中>>>
无未同步订单>>>
2026-04-26 15:18:06 >>>当前Ram内存为615.439453125
定时检测未同步订单启用[checkOrderNum=536875343]
2026-04-26 15:18:07>>>cash write=0C
2026-04-26 15:18:07>>>cash read=3E
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 15:18:58 >>>回调事件[910,devices/TL3921]
2026-04-26 15:18:58 >>>故障排除日志:上一MQTT订单号缓存列表为2604261514360044137148
2026-04-26 15:18:58 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 15:18:58 开始打印,排队:333,票券:2604261518490223118401,订单:2604261518490000398734,[2026-04-26 15:18:57支付宝支付10元]
2026-04-26 15:18:58>>>MQTT票号同步场景，创建空订单对象
2026-04-26 15:18:58>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 15:19:00 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261518490223118401","queue_number":333,"trade_uid":"2604261518490000398734"}]}
2026-04-26 15:19:00 >>>故障排除日志:删除未同步下发订单成功2604261518490000398734
2026-04-26 15:19:00 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536875357]


===15:20:08===
2026-04-26 15:19:15>>>cash read=00
2026-04-26 15:19:16>>>cash read=818F42
2026-04-26 15:19:16>>>cash write=02
2026-04-26 15:19:16 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 15:19:17>>>cash read=10
2026-04-26 15:19:17 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 15:19:17 当前产品价格10元，投币10元，打印小票中...
2026-04-26 15:19:17 >>>开始打印,排队号为334,订单号为2604261519170013921230
2026-04-26 15:19:17>>>订单2604261519170013921230写入成功,剩余空间为1679500,占用RAM为632.4873046875
删除未同步订单2604261519170013921230
2026-04-26 15:19:19>>>订单2604261519170013921230删除成功,剩余空间为1680500,占用RAM为644.67578125
检测订单目录中>>>
无未同步订单>>>
2026-04-26 15:19:19 >>>当前Ram内存为616.51953125
定时检测未同步订单启用[checkOrderNum=536875368]
2026-04-26 15:19:20>>>cash write=0C
2026-04-26 15:19:20>>>cash read=3E
2026-04-26 15:19:21>>>cash read=00
2026-04-26 15:19:21>>>cash read=818F42
2026-04-26 15:19:21>>>cash write=02
2026-04-26 15:19:21 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 15:19:22>>>cash read=10
2026-04-26 15:19:22 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 15:19:22 当前产品价格10元，投币10元，打印小票中...
2026-04-26 15:19:22 >>>开始打印,排队号为335,订单号为2604261519220013921541
2026-04-26 15:19:22>>>订单2604261519220013921541写入成功,剩余空间为1678500,占用RAM为639.181640625
删除未同步订单2604261519220013921541
2026-04-26 15:19:24>>>订单2604261519220013921541删除成功,剩余空间为1679500,占用RAM为646.728515625
检测订单目录中>>>
无未同步订单>>>
2026-04-26 15:19:24 >>>当前Ram内存为618.435546875
定时检测未同步订单启用[checkOrderNum=536875375]
2026-04-26 15:19:25>>>cash write=0C
2026-04-26 15:19:25>>>cash read=3E


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


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


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


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


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


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


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


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


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


===16:22:10===
2026-04-26 16:21:20>>>cash read=0A
2026-04-26 16:21:21>>>cash read=3E
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 16:21:22 >>>回调事件[910,devices/TL3921]
2026-04-26 16:21:22 >>>故障排除日志:上一MQTT订单号缓存列表为2604261616500017478979
2026-04-26 16:21:22 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 16:21:22 开始打印,排队:346,票券:2604261621113509086801,订单:2604261621110033062786,[2026-04-26 16:21:21微信支付10元]
2026-04-26 16:21:23>>>MQTT票号同步场景，创建空订单对象
2026-04-26 16:21:23>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 16:21:25 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261621113509086801","queue_number":346,"trade_uid":"2604261621110033062786"}]}
2026-04-26 16:21:25 >>>故障排除日志:删除未同步下发订单成功2604261621110033062786
2026-04-26 16:21:25 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536876013]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 16:22:07 >>>回调事件[910,devices/TL3921]
2026-04-26 16:22:07 >>>故障排除日志:上一MQTT订单号缓存列表为2604261621110033062786
2026-04-26 16:22:07 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 16:22:07 开始打印,排队:347,票券:2604261622020901072501,订单:2604261622020007034682,[2026-04-26 16:22:06支付宝支付10元]
2026-04-26 16:22:07>>>MQTT票号同步场景，创建空订单对象
2026-04-26 16:22:07>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 16:22:09 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261622020901072501","queue_number":347,"trade_uid":"2604261622020007034682"}]}
2026-04-26 16:22:09 >>>故障排除日志:删除未同步下发订单成功2604261622020007034682
2026-04-26 16:22:09 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536876028]


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


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


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


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


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


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


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


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


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


===16:46:14===
2026-04-26 16:46:13>>>cash read=00


===16:47:15===
2026-04-26 16:46:14>>>cash read=29
2026-04-26 16:46:14 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 16:46:14>>>cash read=2F29
2026-04-26 16:46:15>>>cash read=3E
2026-04-26 16:46:19>>>cash read=00
2026-04-26 16:46:20>>>cash read=29
2026-04-26 16:46:20 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 16:46:20>>>cash read=2F29
2026-04-26 16:46:22>>>cash read=3E
2026-04-26 16:46:26>>>cash read=29
2026-04-26 16:46:26 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 16:46:27>>>cash read=2F29
2026-04-26 16:46:29>>>cash read=3E
2026-04-26 16:46:31>>>cash read=00
2026-04-26 16:46:32>>>cash read=292F29
2026-04-26 16:46:32 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 16:46:34>>>cash read=3E
2026-04-26 16:46:36>>>cash read=00
2026-04-26 16:46:38>>>cash read=2F29
2026-04-26 16:46:40>>>cash read=3E
2026-04-26 16:46:42>>>cash read=00
2026-04-26 16:46:43>>>cash read=29
2026-04-26 16:46:43 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 16:46:43>>>cash read=2F29
2026-04-26 16:46:45>>>cash read=3E
2026-04-26 16:46:47>>>cash read=00
2026-04-26 16:46:48>>>cash read=29
2026-04-26 16:46:48 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 16:46:49>>>cash read=2F29
2026-04-26 16:46:50>>>cash read=3E
2026-04-26 16:47:08>>>cash read=00
2026-04-26 16:47:09>>>cash read=818F42
2026-04-26 16:47:09>>>cash write=02
2026-04-26 16:47:09 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 16:47:09>>>cash read=10
2026-04-26 16:47:09 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 16:47:10 当前产品价格10元，投币10元，打印小票中...
2026-04-26 16:47:10 >>>开始打印,排队号为358,订单号为2604261647100013921511
2026-04-26 16:47:10>>>订单2604261647100013921511写入成功,剩余空间为1678500,占用RAM为643.177734375
删除未同步订单2604261647100013921511
2026-04-26 16:47:12>>>订单2604261647100013921511删除成功,剩余空间为1679000,占用RAM为646.78125
检测订单目录中>>>
无未同步订单>>>
2026-04-26 16:47:12 >>>当前Ram内存为617.9892578125
定时检测未同步订单启用[checkOrderNum=536876351]
2026-04-26 16:47:13>>>cash write=0C
2026-04-26 16:47:13>>>cash read=3E


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


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


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


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


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


===17:15:16===
2026-04-26 17:15:12>>>cash read=29
2026-04-26 17:15:12 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 17:15:13>>>cash read=01


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


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


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


===17:27:17===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 17:26:25 >>>回调事件[910,devices/TL3921]
2026-04-26 17:26:25 >>>故障排除日志:上一MQTT订单号缓存列表为2604261717250098543652
2026-04-26 17:26:25 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 17:26:25 开始打印,排队:369,票券:2604261726151450612901,订单:2604261726150012638552,[2026-04-26 17:26:24微信支付10元]
2026-04-26 17:26:25 开始打印,排队:370,票券:2604261726151451205802,订单:2604261726150012638552,[2026-04-26 17:26:24微信支付10元]
2026-04-26 17:26:25>>>MQTT票号同步场景，创建空订单对象
2026-04-26 17:26:25>>>合并MQTT票号列表到订单同步请求,共2张票
2026-04-26 17:26:29 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261726151450612901","queue_number":369,"trade_uid":"2604261726150012638552"},{"ticket_no":"2604261726151451205802","queue_number":370,"trade_uid":"2604261726150012638552"}]}
2026-04-26 17:26:29 >>>故障排除日志:删除未同步下发订单成功2604261726150012638552
2026-04-26 17:26:29 >>>故障排除日志:删除未同步下发订单成功2604261726150012638552
2026-04-26 17:26:29 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536876792]
2026-04-26 17:26:52>>>cash read=00
2026-04-26 17:26:54>>>cash read=818F42
2026-04-26 17:26:54>>>cash write=02
2026-04-26 17:26:54 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 17:26:54>>>cash read=10
2026-04-26 17:26:54 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 17:26:54 当前产品价格10元，投币10元，打印小票中...
2026-04-26 17:26:54 >>>开始打印,排队号为371,订单号为2604261726540013921083
2026-04-26 17:26:55>>>订单2604261726540013921083写入成功,剩余空间为1678500,占用RAM为644.7373046875
删除未同步订单2604261726540013921083
2026-04-26 17:26:57>>>订单2604261726540013921083删除成功,剩余空间为1679000,占用RAM为649.6708984375
检测订单目录中>>>
无未同步订单>>>
2026-04-26 17:26:57 >>>当前Ram内存为618.9677734375
定时检测未同步订单启用[checkOrderNum=536876805]
2026-04-26 17:26:58>>>cash write=0C
2026-04-26 17:26:58>>>cash read=3E


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


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


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


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


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


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


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


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


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


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


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


===18:25:22===
2026-04-26 18:24:21 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261824110838878701","queue_number":385,"trade_uid":"2604261824110006473512"}]}
2026-04-26 18:24:21 >>>故障排除日志:删除未同步下发订单成功2604261824110006473512
2026-04-26 18:24:21 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877439]


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


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


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


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


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


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


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


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


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


===19:28:25===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:27:33 >>>回调事件[910,devices/TL3921]
2026-04-26 19:27:33 >>>故障排除日志:上一MQTT订单号缓存列表为2604261918560051032776|2604261918560051032776
2026-04-26 19:27:33 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 19:27:33 开始打印,排队:396,票券:2604261927246724746801,订单:2604261927240065492591,[2026-04-26 19:27:32微信支付10元]
2026-04-26 19:27:33 开始打印,排队:397,票券:2604261927260560479501,订单:2604261927260003290818,[2026-04-26 19:27:32微信支付10元]
2026-04-26 19:27:33>>>MQTT票号同步场景，创建空订单对象
2026-04-26 19:27:33>>>合并MQTT票号列表到订单同步请求,共2张票
2026-04-26 19:27:37 >>>回调事件[910,devices/TL3921]
2026-04-26 19:27:37 >>>故障排除日志:上一MQTT订单号缓存列表为2604261927240065492591|2604261927260003290818
2026-04-26 19:27:37 >>>故障排除日志:终端未同步成功订单列表03962604261927240065492591|03972604261927260003290818
已接收过此消息,票券号为2604261927246724746801,排队号为396
已接收过此消息,票券号为2604261927260560479501,排队号为397
2026-04-26 19:27:37>>>HTTP请求进行中，跳过本次同步
2026-04-26 19:27:38 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261927246724746801","queue_number":396,"trade_uid":"2604261927240065492591"},{"ticket_no":"2604261927260560479501","queue_number":397,"trade_uid":"2604261927260003290818"}]}
2026-04-26 19:27:38 >>>故障排除日志:删除未同步下发订单成功2604261927240065492591
2026-04-26 19:27:38 >>>故障排除日志:删除未同步下发订单成功2604261927260003290818
2026-04-26 19:27:38 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878100]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:27:59 >>>回调事件[910,devices/TL3921]
2026-04-26 19:27:59 >>>故障排除日志:上一MQTT订单号缓存列表为2604261927240065492591|2604261927260003290818
2026-04-26 19:27:59 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 19:27:59 开始打印,排队:398,票券:2604261927526396242901,订单:2604261927520061907841,[2026-04-26 19:27:59支付宝支付10元]
2026-04-26 19:27:59>>>MQTT票号同步场景，创建空订单对象
2026-04-26 19:27:59>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 19:28:01 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261927526396242901","queue_number":398,"trade_uid":"2604261927520061907841"}]}
2026-04-26 19:28:01 >>>故障排除日志:删除未同步下发订单成功2604261927520061907841
2026-04-26 19:28:01 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878113]


===19:30:26===
2026-04-26 19:29:46>>>cash read=29
2026-04-26 19:29:46 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 19:29:47>>>cash read=01
2026-04-26 19:29:50>>>cash read=3E
2026-04-26 19:29:53>>>cash read=00
2026-04-26 19:29:54>>>cash read=2F29
2026-04-26 19:29:55>>>cash read=3E
2026-04-26 19:29:58>>>cash read=29
2026-04-26 19:29:58 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 19:29:59>>>cash read=2F29
2026-04-26 19:30:00>>>cash read=00
2026-04-26 19:30:00>>>cash read=2F29
2026-04-26 19:30:02>>>cash read=3E
2026-04-26 19:30:03>>>cash read=00
2026-04-26 19:30:04>>>cash read=29
2026-04-26 19:30:04 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 19:30:05>>>cash read=2F29
2026-04-26 19:30:06>>>cash read=00
2026-04-26 19:30:07>>>cash read=818F42
2026-04-26 19:30:07>>>cash write=02
2026-04-26 19:30:07 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 19:30:07>>>cash read=10
2026-04-26 19:30:07 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:30:07 当前产品价格10元，投币10元，打印小票中...
2026-04-26 19:30:07 >>>开始打印,排队号为399,订单号为2604261930070013921890
2026-04-26 19:30:07>>>订单2604261930070013921890写入成功,剩余空间为1679000,占用RAM为639.3193359375
删除未同步订单2604261930070013921890
2026-04-26 19:30:09>>>订单2604261930070013921890删除成功,剩余空间为1680000,占用RAM为646.806640625
检测订单目录中>>>
无未同步订单>>>
2026-04-26 19:30:10 >>>当前Ram内存为617.3935546875
定时检测未同步订单启用[checkOrderNum=536878141]
2026-04-26 19:30:11>>>cash write=0C
2026-04-26 19:30:11>>>cash read=3E
2026-04-26 19:30:24>>>cash read=00


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


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


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


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


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


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


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


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


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


===20:14:28===
2026-04-26 20:13:47>>>cash read=00
2026-04-26 20:13:47>>>cash read=818F42
2026-04-26 20:13:47>>>cash write=02
2026-04-26 20:13:47 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 20:13:48>>>cash read=10
2026-04-26 20:13:48 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 20:13:48 当前产品价格10元，投币10元，打印小票中...
2026-04-26 20:13:48 >>>开始打印,排队号为409,订单号为2604262013480013921044
2026-04-26 20:13:48>>>订单2604262013480013921044写入成功,剩余空间为1679500,占用RAM为634.740234375
2026-04-26 20:13:50 >>>回调事件[910,devices/TL3921]
2026-04-26 20:13:50 >>>故障排除日志:上一MQTT订单号缓存列表为2604261958110096045472
2026-04-26 20:13:50 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 20:13:50 开始打印,排队:410,票券:2604262013368854001801,订单:2604262013360086591016,[2026-04-26 20:13:47微信支付10元]
2026-04-26 20:13:50>>>HTTP请求进行中，跳过本次同步
删除未同步订单2604262013480013921044
2026-04-26 20:13:52>>>订单2604262013480013921044删除成功,剩余空间为1680000,占用RAM为648.9833984375
检测订单目录中>>>
无未同步订单>>>
2026-04-26 20:13:52 >>>当前Ram内存为619.0966796875
定时检测未同步订单启用[checkOrderNum=536878630]
2026-04-26 20:13:53>>>cash write=0C
2026-04-26 20:13:53>>>cash read=3E