TLClient_JSSCOM_LuatOS-Air_V4010_RDA8910_RFTTS_0xe0000,2.8.6,863013071893290,05108351503103,
poweron reason:0

===07:57:21===
上一时间戳为1777077625
隔日重置时间戳true
隔日清空未同步下发列表true
当前排队号为300,音量为5
初始化产品信息:[{"time_limit_date":"","ticket_category":"0","expiry_date":90,"product_detail":"小票当天有效，过期作废，请当天使用。","time_limit_status":"0","begin_minute":"00","product_uid":"821841461694738351","use_timer":1,"old_price":"10","end_hour":"23","sale_price":"10","end_minute":"59","begin_hour":"00","sale_status":1,"product_name":"快剪"}]
是否打印二维码设置为0
是否打印紧凑设置为3
当前号显示模式设置为2
当前卡项核销权限设置为0
session_id:2b68e****3fcb2
纸币器设置接收纸币范围为36
欢迎使用天羚自助售票系统[2.8.6]
定时检测未同步订单启用[checkOrderNum=536870969]
2026-04-26 07:56:21>>>cash write=30
2026-04-26 07:56:21>>>cash write=02
2026-04-26 07:56:21>>>cash write=3E
2026-04-26 07:56:21>>>cash read=808F808F
系统时间初始化成功，时间为202642675621
2026-04-26 07:56:22>>>cash write=02
2026-04-26 07:56:22 >>>剩余flash空间=1680000,占用RAM为651.751953125
2026-04-26 07:56:22 >>>回调事件:910,subscribe,10000,连接服务器成功

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

2026-04-26 07:56:25>>>cash write=0C
2026-04-26 07:56:25>>>cash read=29
2026-04-26 07:56:25 >>>回调事件130,cash_status,20029,退钞中
流量卡还有308天过期
2026-04-26 07:56:26>>>cash read=01
2026-04-26 07:56:27>>>cash read=3E
2026-04-26 07:56:28>>>cash read=00
2026-04-26 07:56:29>>>cash read=818F42
2026-04-26 07:56:29>>>cash write=02
2026-04-26 07:56:30 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 07:56:30>>>cash read=10
2026-04-26 07:56:30 >>>回调事件130,10,10023,finish Money=10,进钞完成
当日首次设置时间戳true为1777161390
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 07:56:30 当前产品价格10元，投币10元，打印小票中...
2026-04-26 07:56:30 >>>开始打印,排队号为300,订单号为2604260756300014046242
2026-04-26 07:56:30>>>订单2604260756300014046242写入成功,剩余空间为1678000,占用RAM为646.7724609375
删除未同步订单2604260756300014046242
2026-04-26 07:56:32>>>订单2604260756300014046242删除成功,剩余空间为1679000,占用RAM为648.0478515625
检测订单目录中>>>
无未同步订单>>>
2026-04-26 07:56:33 >>>当前Ram内存为618.6201171875
定时检测未同步订单启用[checkOrderNum=536870986]
2026-04-26 07:56:33 >>>当前Ram内存为626.529296875
2026-04-26 07:56:34>>>cash write=0C
2026-04-26 07:56:34>>>cash read=3E


===08:32:22===
2026-04-26 08:32:21 >>>剩余flash空间=1682000,占用RAM为642.84765625
2026-04-26 08:32:21 >>>回调异常:911,initSys,30000,nil



===08:33:22===
上一时间戳为1777161390
当日首次设置时间戳true为1777163549
今日nvm排队号为301
当前排队号为301,音量为5
初始化产品信息:[{"time_limit_date":"","ticket_category":"0","expiry_date":90,"product_detail":"小票当天有效，过期作废，请当天使用。","time_limit_status":"0","begin_minute":"00","product_uid":"821841461694738351","use_timer":1,"old_price":"10","end_hour":"23","sale_price":"10","end_minute":"59","begin_hour":"00","sale_status":1,"product_name":"快剪"}]
是否打印二维码设置为0
是否打印紧凑设置为3
当前号显示模式设置为2
当前卡项核销权限设置为0
session_id:35fef****6f742
纸币器设置接收纸币范围为36
欢迎使用天羚自助售票系统[2.8.6]
定时检测未同步订单启用[checkOrderNum=536870971]
2026-04-26 08:32:30>>>cash write=30
2026-04-26 08:32:30>>>cash write=02
2026-04-26 08:32:30>>>cash write=3E
2026-04-26 08:32:30>>>cash read=808F808F808F808F808F808F808F808F
系统时间初始化成功，时间为202642683230
2026-04-26 08:32:31>>>cash write=02
2026-04-26 08:32:31 >>>剩余flash空间=1680000,占用RAM为651.939453125
2026-04-26 08:32:31 >>>回调事件:910,subscribe,10000,连接服务器成功

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

2026-04-26 08:32:34>>>cash write=0C
2026-04-26 08:32:34>>>cash read=3E
流量卡还有308天过期
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 08:32:40 >>>回调事件[910,devices/TL4046]
2026-04-26 08:32:40 >>>故障排除日志:上一MQTT订单号缓存列表为2604252117120019656081
2026-04-26 08:32:40 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 08:32:40 开始打印,排队:301,票券:2604260832301587378901,订单:2604260832300012927252,[2026-04-26 08:32:38微信支付10元]
2026-04-26 08:32:40>>>MQTT票号同步场景，创建空订单对象
2026-04-26 08:32:40>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 08:32:42 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604260832301587378901","queue_number":301,"trade_uid":"2604260832300012927252"}]}
2026-04-26 08:32:42 >>>故障排除日志:删除未同步下发订单成功2604260832300012927252
2026-04-26 08:32:42 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536870987]
2026-04-26 08:32:42 >>>当前Ram内存为624.5126953125


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


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


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


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


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


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


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


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


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


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


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


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


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


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


===10:05:28===
2026-04-26 10:05:17>>>cash read=2F29
2026-04-26 10:05:18>>>cash read=01
2026-04-26 10:05:20>>>cash read=2F
2026-04-26 10:05:21>>>cash read=3E
2026-04-26 10:05:23>>>cash read=00
2026-04-26 10:05:24>>>cash read=818F42
2026-04-26 10:05:24>>>cash write=02
2026-04-26 10:05:24 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 10:05:25>>>cash read=10
2026-04-26 10:05:25 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 10:05:25 当前产品价格10元，投币10元，打印小票中...
2026-04-26 10:05:25 >>>开始打印,排队号为318,订单号为2604261005250014046760
2026-04-26 10:05:25>>>订单2604261005250014046760写入成功,剩余空间为1679500,占用RAM为636.7255859375


===10:06:28===
删除未同步订单2604261005250014046760
2026-04-26 10:05:27>>>订单2604261005250014046760删除成功,剩余空间为1681500,占用RAM为648.404296875
检测订单目录中>>>
无未同步订单>>>
2026-04-26 10:05:27 >>>当前Ram内存为617.2783203125
定时检测未同步订单启用[checkOrderNum=536872414]
2026-04-26 10:05:28>>>cash write=0C
2026-04-26 10:05:28>>>cash read=3E


===10:15:29===
2026-04-26 10:14:36>>>cash read=00
2026-04-26 10:14:36>>>cash read=818F42
2026-04-26 10:14:36>>>cash write=02
2026-04-26 10:14:36 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 10:14:37>>>cash read=10
2026-04-26 10:14:37 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 10:14:37 当前产品价格10元，投币10元，打印小票中...
2026-04-26 10:14:37 >>>开始打印,排队号为319,订单号为2604261014370014046974
2026-04-26 10:14:37>>>订单2604261014370014046974写入成功,剩余空间为1679500,占用RAM为636.0615234375
删除未同步订单2604261014370014046974
2026-04-26 10:14:39>>>订单2604261014370014046974删除成功,剩余空间为1680500,占用RAM为646.42578125
检测订单目录中>>>
无未同步订单>>>
2026-04-26 10:14:39 >>>当前Ram内存为617.9521484375
定时检测未同步订单启用[checkOrderNum=536872533]
2026-04-26 10:14:40>>>cash write=0C
2026-04-26 10:14:40>>>cash read=3E
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 10:14:57 >>>回调事件[910,devices/TL4046]
2026-04-26 10:14:57 >>>故障排除日志:上一MQTT订单号缓存列表为2604261000460096615972
2026-04-26 10:14:57 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 10:14:57 开始打印,排队:320,票券:2604261014505196118601,订单:2604261014500050009076,[2026-04-26 10:14:56微信支付10元]
2026-04-26 10:14:57>>>MQTT票号同步场景，创建空订单对象
2026-04-26 10:14:57>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 10:14:59 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261014505196118601","queue_number":320,"trade_uid":"2604261014500050009076"}]}
2026-04-26 10:14:59 >>>故障排除日志:删除未同步下发订单成功2604261014500050009076
2026-04-26 10:14:59 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536872539]


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


===12:56:35===
2026-04-26 12:56:00>>>cash read=0A
2026-04-26 12:56:01>>>cash read=3E


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


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


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


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


===13:29:36===
2026-04-26 13:29:34>>>cash read=00


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


===13:38:36===
2026-04-26 13:38:26>>>cash read=00
2026-04-26 13:38:27>>>cash read=818F41
2026-04-26 13:38:27>>>cash write=02
2026-04-26 13:38:27 >>>回调事件130,cash_status,10022,进钞中...read money=5
2026-04-26 13:38:27>>>cash read=10
2026-04-26 13:38:27 >>>回调事件130,5,10023,finish Money=5,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 13:38:28>>>cash write=0C
2026-04-26 13:38:28>>>cash read=3E


===13:39:36===
硬币脉冲事件 msg=2,io=0,下降沿
硬币脉冲事件 msg=1,io=1,上升沿
2026-04-26 13:38:45 >>>回调事件130,1,10023,1个硬币脉冲
硬币脉冲事件 msg=2,io=0,下降沿
硬币脉冲事件 msg=1,io=1,上升沿
2026-04-26 13:38:47 >>>回调事件130,1,10023,1个硬币脉冲
硬币脉冲事件 msg=2,io=0,下降沿
硬币脉冲事件 msg=1,io=1,上升沿
2026-04-26 13:38:49 >>>回调事件130,1,10023,1个硬币脉冲
硬币脉冲事件 msg=2,io=0,下降沿
硬币脉冲事件 msg=1,io=1,上升沿
2026-04-26 13:38:51 >>>回调事件130,1,10023,1个硬币脉冲
硬币脉冲事件 msg=2,io=0,下降沿
硬币脉冲事件 msg=1,io=1,上升沿
2026-04-26 13:38:52 >>>回调事件130,1,10023,1个硬币脉冲
2026-04-26 13:38:52 当前产品价格10元，投币10元，打印小票中...
2026-04-26 13:38:53 >>>开始打印,排队号为346,订单号为2604261338510014046752
2026-04-26 13:38:53>>>订单2604261338510014046752写入成功,剩余空间为1679500,占用RAM为655.0703125
删除未同步订单2604261338510014046752
2026-04-26 13:38:55>>>订单2604261338510014046752删除成功,剩余空间为1680000,占用RAM为644.119140625
检测订单目录中>>>
无未同步订单>>>
2026-04-26 13:38:55 >>>当前Ram内存为616.5419921875
定时检测未同步订单启用[checkOrderNum=536874980]


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


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


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


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


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


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


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


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


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


===14:59:39===
硬币脉冲事件 msg=2,io=0,下降沿
硬币脉冲事件 msg=1,io=1,上升沿
2026-04-26 14:59:08 >>>回调事件130,1,10023,1个硬币脉冲
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
硬币脉冲事件 msg=2,io=0,下降沿
硬币脉冲事件 msg=1,io=1,上升沿
2026-04-26 14:59:10 >>>回调事件130,1,10023,1个硬币脉冲
硬币脉冲事件 msg=2,io=0,下降沿
硬币脉冲事件 msg=1,io=1,上升沿
2026-04-26 14:59:12 >>>回调事件130,1,10023,1个硬币脉冲
硬币脉冲事件 msg=2,io=0,下降沿
硬币脉冲事件 msg=1,io=1,上升沿
2026-04-26 14:59:15 >>>回调事件130,1,10023,1个硬币脉冲
硬币脉冲事件 msg=2,io=0,下降沿
硬币脉冲事件 msg=1,io=1,上升沿
2026-04-26 14:59:18 >>>回调事件130,1,10023,1个硬币脉冲
2026-04-26 14:59:21>>>cash read=00
2026-04-26 14:59:21>>>cash read=818F41
2026-04-26 14:59:21>>>cash write=02
2026-04-26 14:59:21 >>>回调事件130,cash_status,10022,进钞中...read money=5
2026-04-26 14:59:22>>>cash read=10
2026-04-26 14:59:22 >>>回调事件130,5,10023,finish Money=5,进钞完成
2026-04-26 14:59:22 当前产品价格10元，投币10元，打印小票中...
2026-04-26 14:59:22 >>>开始打印,排队号为356,订单号为2604261459180014046247
2026-04-26 14:59:22>>>订单2604261459180014046247写入成功,剩余空间为1679000,占用RAM为635.8544921875
删除未同步订单2604261459180014046247
2026-04-26 14:59:24>>>订单2604261459180014046247删除成功,剩余空间为1680000,占用RAM为645.71484375
检测订单目录中>>>
无未同步订单>>>
2026-04-26 14:59:24 >>>当前Ram内存为616.462890625
定时检测未同步订单启用[checkOrderNum=536875887]
2026-04-26 14:59:25>>>cash write=0C
2026-04-26 14:59:25>>>cash read=3E


===15:04:39===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 15:04:26 >>>回调事件[910,devices/TL4046]
2026-04-26 15:04:26 >>>故障排除日志:上一MQTT订单号缓存列表为2604261451000099695212
2026-04-26 15:04:26 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 15:04:26 开始打印,排队:357,票券:2604261504156597102501,订单:2604261504150064147046,[2026-04-26 15:04:25微信支付10元]
2026-04-26 15:04:26>>>MQTT票号同步场景，创建空订单对象
2026-04-26 15:04:26>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 15:04:28 >>>回调事件[910,devices/TL4046]
2026-04-26 15:04:28 >>>故障排除日志:上一MQTT订单号缓存列表为2604261504150064147046
2026-04-26 15:04:28 >>>故障排除日志:终端未同步成功订单列表03572604261504150064147046
已接收过此消息,票券号为2604261504156597102501,排队号为357
2026-04-26 15:04:28 开始打印,排队:358,票券:2604261504207112381501,订单:2604261504200069295021,[2026-04-26 15:04:26微信支付10元]
2026-04-26 15:04:28>>>HTTP请求进行中，跳过本次同步
2026-04-26 15:04:30 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261504156597102501","queue_number":357,"trade_uid":"2604261504150064147046"}]}
2026-04-26 15:04:30 >>>故障排除日志:删除未同步下发订单成功2604261504150064147046
2026-04-26 15:04:30 >>>故障排除日志:终端同步成功后剩余订单列表03582604261504200069295021
定时检测未同步订单启用[checkOrderNum=536875950]


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


===15:26:40===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 15:26:06 >>>回调事件[910,devices/TL4046]
2026-04-26 15:26:06 >>>故障排除日志:上一MQTT订单号缓存列表为2604261504150064147046|2604261504200069295021
2026-04-26 15:26:06 >>>故障排除日志:终端未同步成功订单列表03582604261504200069295021
已接收过此消息,票券号为2604261504207112381501,排队号为358
2026-04-26 15:26:06 开始打印,排队:360,票券:2604261525569851456801,订单:2604261525560096706967,[2026-04-26 15:26:04微信支付10元]
2026-04-26 15:26:06>>>MQTT票号同步场景，创建空订单对象
2026-04-26 15:26:06>>>合并MQTT票号列表到订单同步请求,共2张票
2026-04-26 15:26:08 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261504207112381501","queue_number":358,"trade_uid":"2604261504200069295021"},{"ticket_no":"2604261525569851456801","queue_number":360,"trade_uid":"2604261525560096706967"}]}
2026-04-26 15:26:08 >>>故障排除日志:删除未同步下发订单成功2604261504200069295021
2026-04-26 15:26:08 >>>故障排除日志:删除未同步下发订单成功2604261525560096706967
2026-04-26 15:26:08 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536876187]


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


===15:33:55===
mqttTask.mqttMsgRecv.proc error
2026-04-26 15:32:59 >>>剩余flash空间=1681000,占用RAM为663.85546875
2026-04-26 15:32:59 >>>回调异常:910,mqtt_tl,30000,mqtt_stop

2026-04-26 15:32:59 >>>MQTT连接断开，尝试重连中
2026-04-26 15:33:11 >>>剩余flash空间=1681000,占用RAM为655.900390625
2026-04-26 15:33:11 >>>回调事件:910,subscribe,10000,连接服务器成功

请求下发消息结果为0,Message sent successfully
2026-04-26 15:33:12 >>>回调事件[910,devices/TL4046]
2026-04-26 15:33:12 >>>故障排除日志:上一MQTT订单号缓存列表为2604261532160046339647
2026-04-26 15:33:12 >>>故障排除日志:终端未同步成功订单列表03612604261532160046339647
已接收过此消息,票券号为2604261532164840902501,排队号为361
2026-04-26 15:33:12>>>HTTP请求进行中，跳过本次同步
2026-04-26 15:33:16 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261532164840902501","queue_number":361,"trade_uid":"2604261532160046339647"}]}
2026-04-26 15:33:16 >>>故障排除日志:删除未同步下发订单成功2604261532160046339647
2026-04-26 15:33:16 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536876277]


TCP://post-cn-09k20cnrl07.mqtt.aliyuncs.com:1883 closed@26_15:32:59
TCP://post-cn-09k20cnrl07.mqtt.aliyuncs.com:1883@26_15:32:59:send fail
===15:37:55===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 15:37:20 >>>回调事件[910,devices/TL4046]
2026-04-26 15:37:20 >>>故障排除日志:上一MQTT订单号缓存列表为2604261532160046339647
2026-04-26 15:37:20 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 15:37:20 开始打印,排队:362,票券:2604261537112711658401,订单:2604261537110025097078,[2026-04-26 15:37:19微信支付10元]
2026-04-26 15:37:21>>>MQTT票号同步场景，创建空订单对象
2026-04-26 15:37:21>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 15:37:22 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261537112711658401","queue_number":362,"trade_uid":"2604261537110025097078"}]}
2026-04-26 15:37:22 >>>故障排除日志:删除未同步下发订单成功2604261537110025097078
2026-04-26 15:37:23 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536876321]


===15:39:55===
2026-04-26 15:39:07>>>cash read=00
2026-04-26 15:39:08>>>cash read=818F42
2026-04-26 15:39:08>>>cash write=02
2026-04-26 15:39:08 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 15:39:08>>>cash read=10
2026-04-26 15:39:08 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 15:39:08 当前产品价格10元，投币10元，打印小票中...
2026-04-26 15:39:08 >>>开始打印,排队号为363,订单号为2604261539080014046081
2026-04-26 15:39:08>>>订单2604261539080014046081写入成功,剩余空间为1679500,占用RAM为636.68359375
删除未同步订单2604261539080014046081
2026-04-26 15:39:11>>>订单2604261539080014046081删除成功,剩余空间为1680500,占用RAM为645.7470703125
检测订单目录中>>>
无未同步订单>>>
2026-04-26 15:39:11 >>>当前Ram内存为618.9140625
定时检测未同步订单启用[checkOrderNum=536876358]
2026-04-26 15:39:12>>>cash write=0C
2026-04-26 15:39:12>>>cash read=3E
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 15:39:46 >>>回调事件[910,devices/TL4046]
2026-04-26 15:39:47 >>>故障排除日志:上一MQTT订单号缓存列表为2604261537110025097078
2026-04-26 15:39:47 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 15:39:47 开始打印,排队:364,票券:2604261539404102709301,订单:2604261539400038940686,[2026-04-26 15:39:46微信支付10元]
2026-04-26 15:39:47>>>MQTT票号同步场景，创建空订单对象
2026-04-26 15:39:47>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 15:39:49 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261539404102709301","queue_number":364,"trade_uid":"2604261539400038940686"}]}
2026-04-26 15:39:49 >>>故障排除日志:删除未同步下发订单成功2604261539400038940686
2026-04-26 15:39:49 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536876375]


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


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


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


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


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


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


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


===16:51:57===
2026-04-26 16:51:26>>>cash read=00
2026-04-26 16:51:27>>>cash read=818F41
2026-04-26 16:51:27>>>cash write=02
2026-04-26 16:51:27 >>>回调事件130,cash_status,10022,进钞中...read money=5
2026-04-26 16:51:27>>>cash read=10
2026-04-26 16:51:27 >>>回调事件130,5,10023,finish Money=5,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 16:51:28>>>cash write=0C
2026-04-26 16:51:28>>>cash read=3E
2026-04-26 16:51:29>>>cash read=00
2026-04-26 16:51:30>>>cash read=818F41
2026-04-26 16:51:30>>>cash write=02
2026-04-26 16:51:30 >>>回调事件130,cash_status,10022,进钞中...read money=5
2026-04-26 16:51:31>>>cash read=10
2026-04-26 16:51:31 >>>回调事件130,5,10023,finish Money=5,进钞完成
2026-04-26 16:51:31 当前产品价格10元，投币10元，打印小票中...
2026-04-26 16:51:31 >>>开始打印,排队号为373,订单号为2604261651270014046674
2026-04-26 16:51:31>>>订单2604261651270014046674写入成功,剩余空间为1679500,占用RAM为637.740234375
删除未同步订单2604261651270014046674
2026-04-26 16:51:33>>>订单2604261651270014046674删除成功,剩余空间为1680000,占用RAM为651.529296875
检测订单目录中>>>
无未同步订单>>>
2026-04-26 16:51:33 >>>当前Ram内存为619.8818359375
定时检测未同步订单启用[checkOrderNum=536877351]
2026-04-26 16:51:34>>>cash write=0C
2026-04-26 16:51:34>>>cash read=3E


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


===21:44:11===
2026-04-26 21:43:55>>>cash read=0A
2026-04-26 21:43:56>>>cash read=3E