TLClient_JSSCOM_LuatOS-Air_V4010_RDA8910_RFTTS_0xe0000,2.8.6,866250064327061,54134564910109,
poweron reason:0

===09:00:12===
上一时间戳为1777080175
隔日重置时间戳true
隔日清空未同步下发列表true
当前排队号为1,音量为6
初始化产品信息:[{"time_limit_date":"","ticket_category":"0","expiry_date":365,"product_detail":"","time_limit_status":"0","begin_minute":"00","product_uid":"14943629519302477042","use_timer":1,"old_price":"15","end_hour":"23","sale_price":"15","end_minute":"59","begin_hour":"00","sale_status":1,"product_name":"快剪"}]
打印门店标题设置为三新快剪
是否打印二维码设置为1
是否打印紧凑设置为3
当前号显示模式设置为1
当前卡项核销权限设置为0
session_id:bda06****5f5fc
纸币器设置接收纸币范围为36
欢迎使用天羚自助售票系统[2.8.6]
定时检测未同步订单启用[checkOrderNum=536870969]
2026-04-26 08:59:12>>>cash write=30
2026-04-26 08:59:12>>>cash write=02
2026-04-26 08:59:12>>>cash write=3E
2026-04-26 08:59:12>>>cash read=808F808F808F808F
系统时间初始化成功，时间为202642685912
2026-04-26 08:59:13>>>cash write=02
2026-04-26 08:59:13 >>>剩余flash空间=1680000,占用RAM为660.9013671875
2026-04-26 08:59:13 >>>回调事件:910,subscribe,10000,连接服务器成功

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

2026-04-26 08:59:16>>>cash write=0C
2026-04-26 08:59:16>>>cash read=3E
流量卡还有126天过期
2026-04-26 08:59:20 >>>当前Ram内存为645.1025390625


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


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


===09:13:13===
2026-04-26 09:12:39>>>cash read=9E
2026-04-26 09:12:40>>>cash read=3E


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


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


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


===09:35:15===
2026-04-26 09:34:26>>>cash read=9E
2026-04-26 09:34:27>>>cash read=3E


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


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


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


===09:45:16===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 09:44:45 >>>回调事件[910,devices/TL1553]
2026-04-26 09:44:45 >>>故障排除日志:上一MQTT订单号缓存列表为2604260943440049914167
2026-04-26 09:44:45 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 09:44:45 开始打印,排队:9,票券:2604260944353964706301,订单:2604260944350037673452,[2026-04-26 09:44:44微信支付15元]
2026-04-26 09:44:46 开始打印,排队:10,票券:2604260944378945578701,订单:2604260944370087637065,[2026-04-26 09:44:44微信支付15元]
2026-04-26 09:44:46>>>MQTT票号同步场景，创建空订单对象
2026-04-26 09:44:46>>>合并MQTT票号列表到订单同步请求,共2张票
2026-04-26 09:44:49 >>>回调事件[910,devices/TL1553]
2026-04-26 09:44:49 >>>故障排除日志:上一MQTT订单号缓存列表为2604260944350037673452|2604260944370087637065
2026-04-26 09:44:49 >>>故障排除日志:终端未同步成功订单列表00092604260944350037673452|00102604260944370087637065
已接收过此消息,票券号为2604260944353964706301,排队号为9
已接收过此消息,票券号为2604260944378945578701,排队号为10
2026-04-26 09:44:49>>>HTTP请求进行中，跳过本次同步
2026-04-26 09:44:49 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604260944353964706301","queue_number":9,"trade_uid":"2604260944350037673452"},{"ticket_no":"2604260944378945578701","queue_number":10,"trade_uid":"2604260944370087637065"}]}
2026-04-26 09:44:49 >>>故障排除日志:删除未同步下发订单成功2604260944350037673452
2026-04-26 09:44:49 >>>故障排除日志:删除未同步下发订单成功2604260944370087637065
2026-04-26 09:44:50 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536871460]


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


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


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


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


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


===10:05:18===
2026-04-26 10:05:13>>>cash read=9E
2026-04-26 10:05:14>>>cash read=3E


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


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


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


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


===10:27:19===
2026-04-26 10:26:27>>>cash read=9E
2026-04-26 10:26:28>>>cash read=3E


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


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


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


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


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


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


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


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


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


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


===11:09:23===
2026-04-26 11:09:14>>>cash read=9E
2026-04-26 11:09:15>>>cash read=3E


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


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


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


===11:37:25===
2026-04-26 11:36:46>>>cash read=0A
2026-04-26 11:36:47>>>cash read=3E


===11:42:25===
2026-04-26 11:42:05>>>cash read=9E
2026-04-26 11:42:06>>>cash read=3E


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


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


===12:06:26===
2026-04-26 12:05:30>>>cash read=9E
2026-04-26 12:05:31>>>cash read=3E


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


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


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


===12:31:27===
2026-04-26 12:31:05>>>cash read=9E
2026-04-26 12:31:07>>>cash read=3E


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


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


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


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


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


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


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


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


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


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


===13:36:33===
2026-04-26 13:36:12>>>cash read=0A
2026-04-26 13:36:13>>>cash read=3E
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 13:36:29 >>>回调事件[910,devices/TL1553]
2026-04-26 13:36:29 >>>故障排除日志:上一MQTT订单号缓存列表为2604261323040016783097
2026-04-26 13:36:29 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 13:36:29 开始打印,排队:53,票券:2604261336202985969401,订单:2604261336200027823541,[2026-04-26 13:36:26微信支付15元]
2026-04-26 13:36:29 开始打印,排队:54,票券:2604261336202986468302,订单:2604261336200027823541,[2026-04-26 13:36:26微信支付15元]
2026-04-26 13:36:29>>>MQTT票号同步场景，创建空订单对象
2026-04-26 13:36:29>>>合并MQTT票号列表到订单同步请求,共2张票


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


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


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


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


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


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


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


===14:14:37===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 14:13:40 >>>回调事件[910,devices/TL1553]
2026-04-26 14:13:40 >>>故障排除日志:上一MQTT订单号缓存列表为2604261406080026741974
2026-04-26 14:13:40 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 14:13:40 开始打印,排队:62,票券:2604261413333829631201,订单:2604261413330036511524,[2026-04-26 14:13:38微信支付15元]
2026-04-26 14:13:40 开始打印,排队:63,票券:2604261413333830041502,订单:2604261413330036511524,[2026-04-26 14:13:38微信支付15元]
2026-04-26 14:13:40>>>MQTT票号同步场景，创建空订单对象
2026-04-26 14:13:40>>>合并MQTT票号列表到订单同步请求,共2张票
2026-04-26 14:13:43 >>>回调事件[910,devices/TL1553]
2026-04-26 14:13:43 >>>故障排除日志:上一MQTT订单号缓存列表为2604261413330036511524|2604261413330036511524
2026-04-26 14:13:43 >>>故障排除日志:终端未同步成功订单列表00622604261413330036511524|00632604261413330036511524
已接收过此消息,票券号为2604261413333829631201,排队号为62
已接收过此消息,票券号为2604261413333830041502,排队号为63
2026-04-26 14:13:43 开始打印,排队:64,票券:2604261413365681856801,订单:2604261413360054726558,[2026-04-26 14:13:42微信支付15元]
2026-04-26 14:13:44>>>HTTP请求进行中，跳过本次同步
2026-04-26 14:13:45 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261413333829631201","queue_number":62,"trade_uid":"2604261413330036511524"},{"ticket_no":"2604261413333830041502","queue_number":63,"trade_uid":"2604261413330036511524"}]}
2026-04-26 14:13:45 >>>故障排除日志:删除未同步下发订单成功2604261413330036511524
2026-04-26 14:13:45 >>>故障排除日志:删除未同步下发订单成功2604261413330036511524
2026-04-26 14:13:46 >>>故障排除日志:终端同步成功后剩余订单列表00642604261413360054726558
定时检测未同步订单启用[checkOrderNum=536874284]


===14:16:37===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 14:15:45 >>>回调事件[910,devices/TL1553]
2026-04-26 14:15:45 >>>故障排除日志:上一MQTT订单号缓存列表为2604261413330036511524|2604261413330036511524|2604261413360054726558
2026-04-26 14:15:45 >>>故障排除日志:终端未同步成功订单列表00642604261413360054726558
已接收过此消息,票券号为2604261413365681856801,排队号为64
2026-04-26 14:15:45 开始打印,排队:65,票券:2604261415402766182601,订单:2604261415400025540912,[2026-04-26 14:15:44支付宝支付15元]
2026-04-26 14:15:45>>>MQTT票号同步场景，创建空订单对象
2026-04-26 14:15:45>>>合并MQTT票号列表到订单同步请求,共2张票
2026-04-26 14:15:47 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261413365681856801","queue_number":64,"trade_uid":"2604261413360054726558"},{"ticket_no":"2604261415402766182601","queue_number":65,"trade_uid":"2604261415400025540912"}]}
2026-04-26 14:15:47 >>>故障排除日志:删除未同步下发订单成功2604261413360054726558
2026-04-26 14:15:47 >>>故障排除日志:删除未同步下发订单成功2604261415400025540912
2026-04-26 14:15:48 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536874310]


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


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


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


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


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


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


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


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


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


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


===15:03:41===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 15:03:08 >>>回调事件[910,devices/TL1553]
2026-04-26 15:03:08 >>>故障排除日志:上一MQTT订单号缓存列表为2604261501590093757052
2026-04-26 15:03:08 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 15:03:08 开始打印,排队:77,票券:2604261502519011072701,订单:2604261502510088198276,[2026-04-26 15:03:06微信支付15元]
2026-04-26 15:03:08>>>MQTT票号同步场景，创建空订单对象
2026-04-26 15:03:08>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 15:03:10 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261502519011072701","queue_number":77,"trade_uid":"2604261502510088198276"}]}
2026-04-26 15:03:10 >>>故障排除日志:删除未同步下发订单成功2604261502510088198276
2026-04-26 15:03:10 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536874833]
2026-04-26 15:03:15>>>cash read=29
2026-04-26 15:03:15 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 15:03:16>>>cash read=01
2026-04-26 15:03:17>>>cash read=3E
2026-04-26 15:03:32>>>cash read=00
2026-04-26 15:03:32>>>cash read=818F42
2026-04-26 15:03:32>>>cash write=02
2026-04-26 15:03:32 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 15:03:33>>>cash read=10
2026-04-26 15:03:33 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 15:03:34>>>cash write=0C
2026-04-26 15:03:34>>>cash read=3E


===15:04:42===
2026-04-26 15:03:43>>>cash read=292F29
2026-04-26 15:03:43 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 15:03:45>>>cash read=3E
2026-04-26 15:03:46>>>cash read=29
2026-04-26 15:03:46 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 15:03:47>>>cash read=00
2026-04-26 15:03:49>>>cash read=00818F41
2026-04-26 15:03:49>>>cash write=02
2026-04-26 15:03:49 >>>回调事件130,cash_status,10022,进钞中...read money=5
2026-04-26 15:03:49>>>cash read=10
2026-04-26 15:03:49 >>>回调事件130,5,10023,finish Money=5,进钞完成
2026-04-26 15:03:49 当前产品价格15元，投币15元，打印小票中...
2026-04-26 15:03:49 >>>开始打印,排队号为78,订单号为2604261503330011553849
2026-04-26 15:03:49>>>订单2604261503330011553849写入成功,剩余空间为1679500,占用RAM为633.5380859375
删除未同步订单2604261503330011553849
2026-04-26 15:03:52>>>订单2604261503330011553849删除成功,剩余空间为1680500,占用RAM为647.8125
检测订单目录中>>>
无未同步订单>>>
2026-04-26 15:03:52 >>>当前Ram内存为616.5625
定时检测未同步订单启用[checkOrderNum=536874850]
2026-04-26 15:03:53>>>cash write=0C
2026-04-26 15:03:53>>>cash read=3E


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


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


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


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


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


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


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


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


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


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


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


===16:05:46===
2026-04-26 16:04:59>>>cash read=9E
2026-04-26 16:05:00>>>cash read=3E


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


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


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


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


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


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


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


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


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


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


===16:53:50===
2026-04-26 16:53:15>>>cash read=9E
2026-04-26 16:53:16>>>cash read=3E


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


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


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


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


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


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


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


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


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


===17:27:54===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 17:27:00 >>>回调事件[910,devices/TL1553]
2026-04-26 17:27:00 >>>故障排除日志:上一MQTT订单号缓存列表为2604261715280034107553
2026-04-26 17:27:00 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 17:27:00 开始打印,排队:115,票券:2604261726501439017301,订单:2604261726500012289458,[2026-04-26 17:26:59微信支付15元]
2026-04-26 17:27:01>>>MQTT票号同步场景，创建空订单对象
2026-04-26 17:27:01>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 17:27:02 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261726501439017301","queue_number":115,"trade_uid":"2604261726500012289458"}]}
2026-04-26 17:27:02 >>>故障排除日志:删除未同步下发订单成功2604261726500012289458
2026-04-26 17:27:03 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536876412]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 17:27:06 >>>回调事件[910,devices/TL1553]
2026-04-26 17:27:06 >>>故障排除日志:上一MQTT订单号缓存列表为2604261726500012289458
2026-04-26 17:27:06 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 17:27:06 开始打印,排队:116,票券:2604261726566188529301,订单:2604261726560059265068,[2026-04-26 17:27:05微信支付15元]
2026-04-26 17:27:06 开始打印,排队:117,票券:2604261726566189197502,订单:2604261726560059265068,[2026-04-26 17:27:05微信支付15元]
2026-04-26 17:27:06>>>MQTT票号同步场景，创建空订单对象
2026-04-26 17:27:06>>>合并MQTT票号列表到订单同步请求,共2张票
2026-04-26 17:27:09 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261726566188529301","queue_number":116,"trade_uid":"2604261726560059265068"},{"ticket_no":"2604261726566189197502","queue_number":117,"trade_uid":"2604261726560059265068"}]}
2026-04-26 17:27:09 >>>故障排除日志:删除未同步下发订单成功2604261726560059265068
2026-04-26 17:27:09 >>>故障排除日志:删除未同步下发订单成功2604261726560059265068
2026-04-26 17:27:10 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536876424]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 17:27:28 >>>回调事件[910,devices/TL1553]
2026-04-26 17:27:29 >>>故障排除日志:上一MQTT订单号缓存列表为2604261726560059265068|2604261726560059265068
2026-04-26 17:27:29 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 17:27:29 开始打印,排队:118,票券:2604261727211513461401,订单:2604261727210012734972,[2026-04-26 17:27:27微信支付15元]
2026-04-26 17:27:29>>>MQTT票号同步场景，创建空订单对象
2026-04-26 17:27:29>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 17:27:31 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261727211513461401","queue_number":118,"trade_uid":"2604261727210012734972"}]}
2026-04-26 17:27:31 >>>故障排除日志:删除未同步下发订单成功2604261727210012734972
2026-04-26 17:27:31 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536876430]


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


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


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


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


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


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


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


===18:01:56===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 18:01:37 >>>回调事件[910,devices/TL1553]
2026-04-26 18:01:37 >>>故障排除日志:上一MQTT订单号缓存列表为2604261800140081457394
2026-04-26 18:01:37 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 18:01:37 开始打印,排队:127,票券:2604261801277780417301,订单:2604261801270075346567,[2026-04-26 18:01:35微信支付15元]
2026-04-26 18:01:37>>>MQTT票号同步场景，创建空订单对象
2026-04-26 18:01:37>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 18:01:39 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261801277780417301","queue_number":127,"trade_uid":"2604261801270075346567"}]}
2026-04-26 18:01:39 >>>故障排除日志:删除未同步下发订单成功2604261801270075346567
2026-04-26 18:01:39 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536876800]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 18:01:44 >>>回调事件[910,devices/TL1553]
2026-04-26 18:01:44 >>>故障排除日志:上一MQTT订单号缓存列表为2604261801270075346567
2026-04-26 18:01:44 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 18:01:44 开始打印,排队:128,票券:2604261801373036733701,订单:2604261801370028173976,[2026-04-26 18:01:43微信支付15元]
2026-04-26 18:01:45>>>MQTT票号同步场景，创建空订单对象
2026-04-26 18:01:45>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 18:01:47 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261801373036733701","queue_number":128,"trade_uid":"2604261801370028173976"}]}
2026-04-26 18:01:47 >>>故障排除日志:删除未同步下发订单成功2604261801370028173976
2026-04-26 18:01:47 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536876806]


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


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


===18:24:57===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 18:24:06 >>>回调事件[910,devices/TL1553]
2026-04-26 18:24:06 >>>故障排除日志:上一MQTT订单号缓存列表为2604261819030090480963
2026-04-26 18:24:06 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 18:24:06 开始打印,排队:131,票券:2604261823583968398601,订单:2604261823580037445792,[2026-04-26 18:24:05支付宝支付15元]
2026-04-26 18:24:07>>>MQTT票号同步场景，创建空订单对象
2026-04-26 18:24:07>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 18:24:09 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261823583968398601","queue_number":131,"trade_uid":"2604261823580037445792"}]}
2026-04-26 18:24:09 >>>故障排除日志:删除未同步下发订单成功2604261823580037445792
2026-04-26 18:24:09 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877031]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 18:24:25 >>>回调事件[910,devices/TL1553]
2026-04-26 18:24:25 >>>故障排除日志:上一MQTT订单号缓存列表为2604261823580037445792
2026-04-26 18:24:25 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 18:24:25 开始打印,排队:132,票券:2604261824199057926101,订单:2604261824190088797035,[2026-04-26 18:24:23支付宝支付15元]
2026-04-26 18:24:25>>>MQTT票号同步场景，创建空订单对象
2026-04-26 18:24:25>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 18:24:27 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261824199057926101","queue_number":132,"trade_uid":"2604261824190088797035"}]}
2026-04-26 18:24:27 >>>故障排除日志:删除未同步下发订单成功2604261824190088797035
2026-04-26 18:24:27 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877042]


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


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


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


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


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


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


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


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


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


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


===18:47:03===
删除未同步订单2604261845550011553804
2026-04-26 18:46:02>>>订单2604261845550011553804删除成功,剩余空间为1681500,占用RAM为649.177734375
检测订单目录中>>>
无未同步订单>>>
2026-04-26 18:46:02 >>>当前Ram内存为616.021484375
定时检测未同步订单启用[checkOrderNum=536877333]
2026-04-26 18:46:03>>>cash write=0C
2026-04-26 18:46:03>>>cash read=3E


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


===19:56:11===
2026-04-26 19:55:29>>>cash read=29
2026-04-26 19:55:29 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 19:55:30>>>cash read=22
2026-04-26 19:55:30 >>>回调事件130,cash_status,30022,卡钞
2026-04-26 19:55:31>>>cash read=3E
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:55:31 >>>回调事件[910,devices/TL1553]
2026-04-26 19:55:31 >>>故障排除日志:上一MQTT订单号缓存列表为2604261953190048825421
2026-04-26 19:55:31 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 19:55:31 开始打印,排队:168,票券:2604261955217968969801,订单:2604261955210077235175,[2026-04-26 19:55:30微信支付15元]
2026-04-26 19:55:31>>>MQTT票号同步场景，创建空订单对象
2026-04-26 19:55:31>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 19:55:33 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261955217968969801","queue_number":168,"trade_uid":"2604261955210077235175"}]}
2026-04-26 19:55:33 >>>故障排除日志:删除未同步下发订单成功2604261955210077235175
2026-04-26 19:55:33 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878126]


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


===21:23:20===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 21:22:44 >>>回调事件[910,devices/TL1553]
2026-04-26 21:22:44 >>>故障排除日志:上一MQTT订单号缓存列表为2604262117280035658764
2026-04-26 21:22:44 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 21:22:45 开始打印,排队:194,票券:2604262122391753373501,订单:2604262122390015133484,[2026-04-26 21:22:44支付宝支付15元]
2026-04-26 21:22:45 开始打印,排队:195,票券:2604262122391753891802,订单:2604262122390015133484,[2026-04-26 21:22:44支付宝支付15元]
2026-04-26 21:22:45>>>MQTT票号同步场景，创建空订单对象
2026-04-26 21:22:45>>>合并MQTT票号列表到订单同步请求,共2张票
2026-04-26 21:22:48 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604262122391753373501","queue_number":194,"trade_uid":"2604262122390015133484"},{"ticket_no":"2604262122391753891802","queue_number":195,"trade_uid":"2604262122390015133484"}]}
2026-04-26 21:22:48 >>>故障排除日志:删除未同步下发订单成功2604262122390015133484
2026-04-26 21:22:48 >>>故障排除日志:删除未同步下发订单成功2604262122390015133484
2026-04-26 21:22:48 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536879082]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 21:23:16 >>>回调事件[910,devices/TL1553]
2026-04-26 21:23:17 >>>故障排除日志:上一MQTT订单号缓存列表为2604262122390015133484|2604262122390015133484
2026-04-26 21:23:17 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 21:23:17 开始打印,排队:196,票券:2604262123092631816901,订单:2604262123090023067195,[2026-04-26 21:23:15微信支付15元]
2026-04-26 21:23:17>>>MQTT票号同步场景，创建空订单对象
2026-04-26 21:23:17>>>合并MQTT票号列表到订单同步请求,共1张票


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


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


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


===21:48:21===
2026-04-26 21:48:18>>>cash read=9E
2026-04-26 21:48:20>>>cash read=3E


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


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


===22:16:22===
2026-04-26 22:15:36>>>cash read=00
2026-04-26 22:15:36>>>cash read=818F43
2026-04-26 22:15:36>>>cash write=02
2026-04-26 22:15:36 >>>回调事件130,cash_status,10022,进钞中...read money=20
2026-04-26 22:15:37>>>cash read=10
2026-04-26 22:15:37 >>>回调事件130,20,10023,finish Money=20,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 22:15:38>>>cash write=0C
2026-04-26 22:15:38>>>cash read=3E
2026-04-26 22:15:39>>>cash read=00
2026-04-26 22:15:40>>>cash read=818F42
2026-04-26 22:15:40>>>cash write=02
2026-04-26 22:15:40 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 22:15:41>>>cash read=10
2026-04-26 22:15:41 >>>回调事件130,10,10023,finish Money=10,进钞完成
2026-04-26 22:15:41 当前产品价格15元，投币30元，打印小票中...
2026-04-26 22:15:41 >>>开始打印,排队号为205,订单号为2604262215410011553119
2026-04-26 22:15:41 >>>开始打印,排队号为206,订单号为2604262215410011553119
2026-04-26 22:15:41>>>订单2604262215410011553119写入成功,剩余空间为1678500,占用RAM为643.09765625
删除未同步订单2604262215410011553119
2026-04-26 22:15:45>>>订单2604262215410011553119删除成功,剩余空间为1680000,占用RAM为659.05859375
检测订单目录中>>>
无未同步订单>>>
2026-04-26 22:15:45 >>>当前Ram内存为618.2001953125
定时检测未同步订单启用[checkOrderNum=536879619]
2026-04-26 22:15:46>>>cash write=0C
2026-04-26 22:15:46>>>cash read=3E
2026-04-26 22:15:54>>>cash read=00
2026-04-26 22:15:55>>>cash read=29
2026-04-26 22:15:55 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 22:15:56>>>cash read=00
2026-04-26 22:15:57>>>cash read=818F42
2026-04-26 22:15:57>>>cash write=02
2026-04-26 22:15:57 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 22:15:58>>>cash read=10
2026-04-26 22:15:58 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 22:15:59>>>cash write=0C
2026-04-26 22:15:59>>>cash read=00
2026-04-26 22:16:00>>>cash read=818F42
2026-04-26 22:16:00>>>cash write=02
2026-04-26 22:16:00 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 22:16:00>>>cash read=10
2026-04-26 22:16:00 >>>回调事件130,10,10023,finish Money=10,进钞完成
2026-04-26 22:16:01>>>cash write=0C
2026-04-26 22:16:02>>>cash read=00
2026-04-26 22:16:02>>>cash read=818F41
2026-04-26 22:16:03>>>cash write=02
2026-04-26 22:16:03 >>>回调事件130,cash_status,10022,进钞中...read money=5
2026-04-26 22:16:03>>>cash read=10
2026-04-26 22:16:03 >>>回调事件130,5,10023,finish Money=5,进钞完成
2026-04-26 22:16:04>>>cash write=0C
2026-04-26 22:16:04>>>cash read=00
2026-04-26 22:16:05>>>cash read=818F41
2026-04-26 22:16:05>>>cash write=02
2026-04-26 22:16:05 >>>回调事件130,cash_status,10022,进钞中...read money=5
2026-04-26 22:16:05>>>cash read=10
2026-04-26 22:16:05 >>>回调事件130,5,10023,finish Money=5,进钞完成
2026-04-26 22:16:05 当前产品价格15元，投币30元，打印小票中...
2026-04-26 22:16:05 >>>开始打印,排队号为207,订单号为2604262215580011553842
2026-04-26 22:16:05 >>>开始打印,排队号为208,订单号为2604262215580011553842
2026-04-26 22:16:06>>>订单2604262215580011553842写入成功,剩余空间为1676500,占用RAM为656.3291015625
2026-04-26 22:16:09>>>cash read=818F42
2026-04-26 22:16:09 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 22:16:10>>>cash read=10
2026-04-26 22:16:10 >>>回调事件130,10,10023,finish Money=10,进钞完成
删除未同步订单2604262215580011553842
2026-04-26 22:16:10>>>订单2604262215580011553842删除成功,剩余空间为1677500,占用RAM为633.6552734375
检测订单目录中>>>
无未同步订单>>>
2026-04-26 22:16:10 >>>当前Ram内存为620.3466796875
定时检测未同步订单启用[checkOrderNum=536879645]
2026-04-26 22:16:11>>>cash write=0C
2026-04-26 22:16:11>>>cash read=00
2026-04-26 22:16:12>>>cash read=818F41
2026-04-26 22:16:12>>>cash write=02
2026-04-26 22:16:12 >>>回调事件130,cash_status,10022,进钞中...read money=5
2026-04-26 22:16:12>>>cash read=10
2026-04-26 22:16:12 >>>回调事件130,5,10023,finish Money=5,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 22:16:12 当前产品价格15元，投币15元，打印小票中...
2026-04-26 22:16:12 >>>开始打印,排队号为209,订单号为2604262216100011553859
2026-04-26 22:16:13>>>订单2604262216100011553859写入成功,剩余空间为1675500,占用RAM为660.8759765625
删除未同步订单2604262216100011553859
2026-04-26 22:16:15>>>订单2604262216100011553859删除成功,剩余空间为1676500,占用RAM为638.255859375
检测订单目录中>>>
无未同步订单>>>
2026-04-26 22:16:15 >>>当前Ram内存为620.6953125
定时检测未同步订单启用[checkOrderNum=536879657]
2026-04-26 22:16:16>>>cash write=0C