TLClient_JSSCOM_LuatOS-Air_V4010_RDA8910_RFTTS_0xe0000,2.8.6,863013071893951,91394405316217,
poweron reason:0

===08:56:34===
上一时间戳为1777089841
当日首次设置时间戳true为1777121857
今日nvm排队号为166
当前排队号为166,音量为5
初始化产品信息:[{"time_limit_date":"","ticket_category":"0","expiry_date":1,"product_detail":"","time_limit_status":"0","begin_minute":"00","product_uid":"16746837930008974196","use_timer":1,"old_price":"15","end_hour":"23","sale_price":"15","end_minute":"59","begin_hour":"00","sale_status":1,"product_name":"精致快剪"}]
是否打印二维码设置为1
是否打印紧凑设置为7
当前号显示模式设置为2
当前卡项核销权限设置为0
session_id:265eb****118e1
纸币器设置接收纸币范围为186
欢迎使用天羚自助售票系统[2.8.6]
定时检测未同步订单启用[checkOrderNum=536870969]
2026-04-25 20:57:37>>>cash write=30
2026-04-25 20:57:37>>>cash write=02
2026-04-25 20:57:37>>>cash write=3E
2026-04-25 20:57:37>>>cash read=808F808F
系统时间初始化成功，时间为2026425205737
2026-04-25 20:57:38>>>cash write=02
2026-04-25 20:57:38>>>cash read=808F3E
2026-04-25 20:57:38 >>>剩余flash空间=1680000,占用RAM为655.4892578125
2026-04-25 20:57:38 >>>回调事件:910,subscribe,10000,连接服务器成功

请求下发消息结果为0,Message sent successfully
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-25 20:57:39 >>>回调事件[910,devices/TL4957]
2026-04-25 20:57:39 >>>故障排除日志:上一MQTT订单号缓存列表为2604252041310048417846
2026-04-25 20:57:39 >>>故障排除日志:终端未同步成功订单列表
2026-04-25 20:57:39 开始打印,排队:166,票券:2604252057313947132701,订单:2604252057310037506142,[2026-04-25 20:57:38微信支付15元]
2026-04-25 20:57:39>>>MQTT票号同步场景，创建空订单对象
2026-04-25 20:57:39>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-25 20:57:41 >>>回调事件[910,devices/TL4957]
2026-04-25 20:57:41 >>>故障排除日志:上一MQTT订单号缓存列表为2604252057310037506142
2026-04-25 20:57:41 >>>故障排除日志:终端未同步成功订单列表01662604252057310037506142
已接收过此消息,票券号为2604252057313947132701,排队号为166
2026-04-25 20:57:41>>>HTTP请求进行中，跳过本次同步
2026-04-25 20:57:42 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604252057313947132701","queue_number":166,"trade_uid":"2604252057310037506142"}]}
2026-04-25 20:57:42 >>>故障排除日志:删除未同步下发订单成功2604252057310037506142
2026-04-25 20:57:42 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536870985]
流量卡还有249天过期
2026-04-25 20:57:42>>>cash write=0C
2026-04-25 20:57:48 >>>当前Ram内存为658.3564453125


===08:57:34===
上一时间戳为1777121857
隔日重置时间戳true
隔日清空未同步下发列表true
当前排队号为51,音量为5
初始化产品信息:[{"time_limit_date":"","ticket_category":"0","expiry_date":1,"product_detail":"","time_limit_status":"0","begin_minute":"00","product_uid":"16746837930008974196","use_timer":1,"old_price":"15","end_hour":"23","sale_price":"15","end_minute":"59","begin_hour":"00","sale_status":1,"product_name":"精致快剪"}]
是否打印二维码设置为1
是否打印紧凑设置为7
当前号显示模式设置为2
当前卡项核销权限设置为0
session_id:5cd55****3d4f8
纸币器设置接收纸币范围为186
欢迎使用天羚自助售票系统[2.8.6]
定时检测未同步订单启用[checkOrderNum=536870971]
2026-04-26 08:56:33>>>cash write=30
2026-04-26 08:56:33>>>cash write=02
2026-04-26 08:56:33>>>cash write=3E
2026-04-26 08:56:33>>>cash read=808F808F
系统时间初始化成功，时间为202642685633
2026-04-26 08:56:34>>>cash write=02
2026-04-26 08:56:34>>>cash read=808F3E
2026-04-26 08:56:34 >>>剩余flash空间=1680000,占用RAM为654.658203125
2026-04-26 08:56:34 >>>回调事件:910,subscribe,10000,连接服务器成功

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

2026-04-26 08:56:36>>>cash write=0C
流量卡还有248天过期
2026-04-26 08:56:44 >>>当前Ram内存为658.6591796875


===08:58:34===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 08:58:04 >>>回调事件[910,devices/TL4957]
当日首次设置时间戳true为1777165084
2026-04-26 08:58:04 >>>故障排除日志:上一MQTT订单号缓存列表为2604252057310037506142
2026-04-26 08:58:04 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 08:58:04 开始打印,排队:51,票券:2604260857561194567601,订单:2604260857560009247572,[2026-04-26 08:58:03微信支付15元]
2026-04-26 08:58:04>>>MQTT票号同步场景，创建空订单对象
2026-04-26 08:58:04>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 08:58:06 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604260857561194567601","queue_number":51,"trade_uid":"2604260857560009247572"}]}
2026-04-26 08:58:06 >>>故障排除日志:删除未同步下发订单成功2604260857560009247572
2026-04-26 08:58:06 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536871001]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 08:58:24 >>>回调事件[910,devices/TL4957]
2026-04-26 08:58:24 >>>故障排除日志:上一MQTT订单号缓存列表为2604260857560009247572
2026-04-26 08:58:24 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 08:58:24 开始打印,排队:52,票券:2604260858177422591201,订单:2604260858170072510435,[2026-04-26 08:58:24支付宝支付15元]
2026-04-26 08:58:25>>>MQTT票号同步场景，创建空订单对象
2026-04-26 08:58:25>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 08:58:27 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604260858177422591201","queue_number":52,"trade_uid":"2604260858170072510435"}]}
2026-04-26 08:58:27 >>>故障排除日志:删除未同步下发订单成功2604260858170072510435
2026-04-26 08:58:27 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536871007]


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


===10:54:43===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 10:54:38 >>>回调事件[910,devices/TL4957]
2026-04-26 10:54:38 >>>故障排除日志:上一MQTT订单号缓存列表为2604261050030019168089
2026-04-26 10:54:38 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 10:54:38 开始打印,排队:73,票券:2604261054308991887601,订单:2604261054300087821127,[2026-04-26 10:54:37支付宝支付15元]
2026-04-26 10:54:38 开始打印,排队:74,票券:2604261054308992431602,订单:2604261054300087821127,[2026-04-26 10:54:37支付宝支付15元]
2026-04-26 10:54:38>>>MQTT票号同步场景，创建空订单对象
2026-04-26 10:54:38>>>合并MQTT票号列表到订单同步请求,共2张票


===10:55:43===
2026-04-26 10:54:42 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261054308991887601","queue_number":73,"trade_uid":"2604261054300087821127"},{"ticket_no":"2604261054308992431602","queue_number":74,"trade_uid":"2604261054300087821127"}]}
2026-04-26 10:54:42 >>>故障排除日志:删除未同步下发订单成功2604261054300087821127
2026-04-26 10:54:42 >>>故障排除日志:删除未同步下发订单成功2604261054300087821127
2026-04-26 10:54:42 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536872235]


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


===13:04:48===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 13:04:00 >>>回调事件[910,devices/TL4957]
2026-04-26 13:04:00 >>>故障排除日志:上一MQTT订单号缓存列表为2604261247160002180178
2026-04-26 13:04:00 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 13:04:00 开始打印,排队:91,票券:2604261303531388453901,订单:2604261303530011944551,[2026-04-26 13:03:58微信支付15元]
2026-04-26 13:04:00 开始打印,排队:92,票券:2604261303531388874802,订单:2604261303530011944551,[2026-04-26 13:03:58微信支付15元]
2026-04-26 13:04:00>>>MQTT票号同步场景，创建空订单对象
2026-04-26 13:04:00>>>合并MQTT票号列表到订单同步请求,共2张票
2026-04-26 13:04:04 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261303531388453901","queue_number":91,"trade_uid":"2604261303530011944551"},{"ticket_no":"2604261303531388874802","queue_number":92,"trade_uid":"2604261303530011944551"}]}
2026-04-26 13:04:04 >>>故障排除日志:删除未同步下发订单成功2604261303530011944551
2026-04-26 13:04:04 >>>故障排除日志:删除未同步下发订单成功2604261303530011944551
2026-04-26 13:04:04 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536873529]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 13:04:11 >>>回调事件[910,devices/TL4957]
2026-04-26 13:04:11 >>>故障排除日志:上一MQTT订单号缓存列表为2604261303530011944551|2604261303530011944551
2026-04-26 13:04:11 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 13:04:11 开始打印,排队:93,票券:2604261304058425865901,订单:2604261304050082611741,[2026-04-26 13:04:11支付宝支付15元]
2026-04-26 13:04:11>>>MQTT票号同步场景，创建空订单对象
2026-04-26 13:04:11>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 13:04:13 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261304058425865901","queue_number":93,"trade_uid":"2604261304050082611741"}]}
2026-04-26 13:04:13 >>>故障排除日志:删除未同步下发订单成功2604261304050082611741
2026-04-26 13:04:14 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536873537]


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


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


===13:18:51===
2026-04-26 13:17:49 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261317380639954901","queue_number":95,"trade_uid":"2604261317380004503225"}]}
2026-04-26 13:17:49 >>>故障排除日志:删除未同步下发订单成功2604261317380004503225
2026-04-26 13:17:49 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536873678]


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


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


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


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


===13:56:52===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 13:56:06 >>>回调事件[910,devices/TL4957]
2026-04-26 13:56:06 >>>故障排除日志:上一MQTT订单号缓存列表为2604261338400043019264
2026-04-26 13:56:06 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 13:56:06 开始打印,排队:102,票券:2604261355558753081501,订单:2604261355550085021048,[2026-04-26 13:56:05微信支付15元]
2026-04-26 13:56:06>>>MQTT票号同步场景，创建空订单对象
2026-04-26 13:56:06>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 13:56:07 >>>回调事件[910,devices/TL4957]
2026-04-26 13:56:07 >>>故障排除日志:上一MQTT订单号缓存列表为2604261355550085021048
2026-04-26 13:56:08 >>>故障排除日志:终端未同步成功订单列表01022604261355550085021048
已接收过此消息,票券号为2604261355558753081501,排队号为102
2026-04-26 13:56:08 开始打印,排队:103,票券:2604261356000415486101,订单:2604261356000002226169,[2026-04-26 13:56:06支付宝支付15元]
2026-04-26 13:56:08>>>HTTP请求进行中，跳过本次同步
2026-04-26 13:56:09 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261355558753081501","queue_number":102,"trade_uid":"2604261355550085021048"}]}
2026-04-26 13:56:09 >>>故障排除日志:删除未同步下发订单成功2604261355550085021048
2026-04-26 13:56:10 >>>故障排除日志:终端同步成功后剩余订单列表01032604261356000002226169
定时检测未同步订单启用[checkOrderNum=536874064]


===13:58:56===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 13:58:49 >>>回调事件[910,devices/TL4957]
2026-04-26 13:58:49 >>>故障排除日志:上一MQTT订单号缓存列表为2604261355550085021048|2604261356000002226169
2026-04-26 13:58:49 >>>故障排除日志:终端未同步成功订单列表01032604261356000002226169
已接收过此消息,票券号为2604261356000415486101,排队号为103
2026-04-26 13:58:49 开始打印,排队:104,票券:2604261358436903216901,订单:2604261358430067094215,[2026-04-26 13:58:49微信支付15元]
2026-04-26 13:58:50>>>MQTT票号同步场景，创建空订单对象
2026-04-26 13:58:50>>>合并MQTT票号列表到订单同步请求,共2张票
2026-04-26 13:58:51 >>>回调事件[910,devices/TL4957]
2026-04-26 13:58:51 >>>故障排除日志:上一MQTT订单号缓存列表为2604261356000002226169|2604261358430067094215
2026-04-26 13:58:51 >>>故障排除日志:终端未同步成功订单列表01032604261356000002226169|01042604261358430067094215
已接收过此消息,票券号为2604261356000415486101,排队号为103
已接收过此消息,票券号为2604261358436903216901,排队号为104
2026-04-26 13:58:51 开始打印,排队:105,票券:2604261358445795686301,订单:2604261358440055331864,[2026-04-26 13:58:51微信支付15元]
2026-04-26 13:58:51 开始打印,排队:106,票券:2604261358445796256502,订单:2604261358440055331864,[2026-04-26 13:58:51微信支付15元]
2026-04-26 13:58:52>>>HTTP请求进行中，跳过本次同步


===14:05:57===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 14:05:02 >>>回调事件[910,devices/TL4957]
2026-04-26 14:05:02 >>>故障排除日志:上一MQTT订单号缓存列表为2604261356000002226169|2604261358430067094215|2604261358440055331864|2604261358440055331864
2026-04-26 14:05:02 >>>故障排除日志:终端未同步成功订单列表01052604261358440055331864|01062604261358440055331864
已接收过此消息,票券号为2604261358445795686301,排队号为105
已接收过此消息,票券号为2604261358445796256502,排队号为106
2026-04-26 14:05:02 开始打印,排队:107,票券:2604261404553881189601,订单:2604261404550036717741,[2026-04-26 14:05:02微信支付15元]
2026-04-26 14:05:02>>>MQTT票号同步场景，创建空订单对象
2026-04-26 14:05:02>>>合并MQTT票号列表到订单同步请求,共3张票
2026-04-26 14:05:04 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261358445795686301","queue_number":105,"trade_uid":"2604261358440055331864"},{"ticket_no":"2604261358445796256502","queue_number":106,"trade_uid":"2604261358440055331864"},{"ticket_no":"2604261404553881189601","queue_number":107,"trade_uid":"2604261404550036717741"}]}
2026-04-26 14:05:04 >>>故障排除日志:删除未同步下发订单成功2604261358440055331864
2026-04-26 14:05:04 >>>故障排除日志:删除未同步下发订单成功2604261358440055331864
2026-04-26 14:05:04 >>>故障排除日志:删除未同步下发订单成功2604261404550036717741
2026-04-26 14:05:04 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536874163]


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


===16:30:04===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 16:29:16 >>>回调事件[910,devices/TL4957]
2026-04-26 16:29:16 >>>故障排除日志:上一MQTT订单号缓存列表为2604261624330031321787
2026-04-26 16:29:16 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 16:29:16 开始打印,排队:133,票券:2604261629097708406301,订单:2604261629090073393857,[2026-04-26 16:29:14支付宝支付15元]
2026-04-26 16:29:16 开始打印,排队:134,票券:2604261629097709147202,订单:2604261629090073393857,[2026-04-26 16:29:14支付宝支付15元]
2026-04-26 16:29:16>>>MQTT票号同步场景，创建空订单对象
2026-04-26 16:29:16>>>合并MQTT票号列表到订单同步请求,共2张票
2026-04-26 16:29:20 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261629097708406301","queue_number":133,"trade_uid":"2604261629090073393857"},{"ticket_no":"2604261629097709147202","queue_number":134,"trade_uid":"2604261629090073393857"}]}
2026-04-26 16:29:20 >>>故障排除日志:删除未同步下发订单成功2604261629090073393857
2026-04-26 16:29:20 >>>故障排除日志:删除未同步下发订单成功2604261629090073393857
2026-04-26 16:29:20 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536875660]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 16:29:41 >>>回调事件[910,devices/TL4957]
2026-04-26 16:29:42 >>>故障排除日志:上一MQTT订单号缓存列表为2604261629090073393857|2604261629090073393857
2026-04-26 16:29:42 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 16:29:42 开始打印,排队:135,票券:2604261629349416726801,订单:2604261629340091596879,[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":"2604261629349416726801","queue_number":135,"trade_uid":"2604261629340091596879"}]}
2026-04-26 16:29:44 >>>故障排除日志:删除未同步下发订单成功2604261629340091596879
2026-04-26 16:29:44 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536875672]


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


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


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


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


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


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


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


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


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


===17:23:08===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 17:22:41 >>>回调事件[910,devices/TL4957]
2026-04-26 17:22:41 >>>故障排除日志:上一MQTT订单号缓存列表为2604261721100049759571|2604261721100049759571
2026-04-26 17:22:41 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 17:22:41 开始打印,排队:147,票券:2604261722317437648301,订单:2604261722310071496831,[2026-04-26 17:22:41微信支付15元]
2026-04-26 17:22:41>>>MQTT票号同步场景，创建空订单对象
2026-04-26 17:22:41>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 17:22:43 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261722317437648301","queue_number":147,"trade_uid":"2604261722310071496831"}]}
2026-04-26 17:22:43 >>>故障排除日志:删除未同步下发订单成功2604261722310071496831
2026-04-26 17:22:43 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536876234]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 17:22:55 >>>回调事件[910,devices/TL4957]
2026-04-26 17:22:55 >>>故障排除日志:上一MQTT订单号缓存列表为2604261722310071496831
2026-04-26 17:22:55 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 17:22:55 开始打印,排队:148,票券:2604261722390124485801,订单:2604261722380099353237,[2026-04-26 17:22:54微信支付15元]
2026-04-26 17:22:55 开始打印,排队:149,票券:2604261722390124851602,订单:2604261722380099353237,[2026-04-26 17:22:54微信支付15元]
2026-04-26 17:22:55>>>MQTT票号同步场景，创建空订单对象
2026-04-26 17:22:55>>>合并MQTT票号列表到订单同步请求,共2张票
2026-04-26 17:22:59 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261722390124485801","queue_number":148,"trade_uid":"2604261722380099353237"},{"ticket_no":"2604261722390124851602","queue_number":149,"trade_uid":"2604261722380099353237"}]}
2026-04-26 17:22:59 >>>故障排除日志:删除未同步下发订单成功2604261722380099353237
2026-04-26 17:22:59 >>>故障排除日志:删除未同步下发订单成功2604261722380099353237
2026-04-26 17:22:59 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536876241]


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


===19:28:15===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:28:09 >>>回调事件[910,devices/TL4957]
2026-04-26 19:28:09 >>>故障排除日志:上一MQTT订单号缓存列表为2604261926290012092647
2026-04-26 19:28:09 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 19:28:09 开始打印,排队:175,票券:2604261928006479618401,订单:2604261928000062634392,[2026-04-26 19:28:08支付宝支付15元]
2026-04-26 19:28:09>>>MQTT票号同步场景，创建空订单对象
2026-04-26 19:28:09>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 19:28:11 >>>回调事件[910,devices/TL4957]
2026-04-26 19:28:11 >>>故障排除日志:上一MQTT订单号缓存列表为2604261928000062634392
2026-04-26 19:28:11 >>>故障排除日志:终端未同步成功订单列表01752604261928000062634392
已接收过此消息,票券号为2604261928006479618401,排队号为175
2026-04-26 19:28:11 开始打印,排队:176,票券:2604261928007558237901,订单:2604261928000073451958,[2026-04-26 19:28:08微信支付15元]
2026-04-26 19:28:11>>>HTTP请求进行中，跳过本次同步
2026-04-26 19:28:13 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261928006479618401","queue_number":175,"trade_uid":"2604261928000062634392"}]}
2026-04-26 19:28:13 >>>故障排除日志:删除未同步下发订单成功2604261928000062634392
2026-04-26 19:28:13 >>>故障排除日志:终端同步成功后剩余订单列表01762604261928000073451958
定时检测未同步订单启用[checkOrderNum=536877576]


===19:33:16===
2026-04-26 19:32:33>>>cash read=00
2026-04-26 19:32:34>>>cash read=818F42
2026-04-26 19:32:34>>>cash write=02
2026-04-26 19:32:34 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 19:32:35>>>cash read=10
2026-04-26 19:32:35 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:32:36>>>cash write=0C
2026-04-26 19:32:36>>>cash read=3E
2026-04-26 19:32:38 >>>回调事件[910,devices/TL4957]
2026-04-26 19:32:38 >>>故障排除日志:上一MQTT订单号缓存列表为2604261928000062634392|2604261928000073451958
2026-04-26 19:32:38 >>>故障排除日志:终端未同步成功订单列表01762604261928000073451958
已接收过此消息,票券号为2604261928007558237901,排队号为176
2026-04-26 19:32:38 开始打印,排队:177,票券:2604261932320492102601,订单:2604261932320003137197,[2026-04-26 19:32:37微信支付15元]
2026-04-26 19:32:38>>>MQTT票号同步场景，创建空订单对象
2026-04-26 19:32:38>>>合并MQTT票号列表到订单同步请求,共2张票
2026-04-26 19:32:40 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261928007558237901","queue_number":176,"trade_uid":"2604261928000073451958"},{"ticket_no":"2604261932320492102601","queue_number":177,"trade_uid":"2604261932320003137197"}]}
2026-04-26 19:32:40 >>>故障排除日志:删除未同步下发订单成功2604261928000073451958
2026-04-26 19:32:40 >>>故障排除日志:删除未同步下发订单成功2604261932320003137197
2026-04-26 19:32:40 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877629]
2026-04-26 19:32:40>>>cash read=2F29
2026-04-26 19:32:42>>>cash read=3E
2026-04-26 19:32:45>>>cash read=00
2026-04-26 19:32:46>>>cash read=818F41
2026-04-26 19:32:46>>>cash write=02
2026-04-26 19:32:46 >>>回调事件130,cash_status,10022,进钞中...read money=5
2026-04-26 19:32:46>>>cash read=10
2026-04-26 19:32:46 >>>回调事件130,5,10023,finish Money=5,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:32:46 当前产品价格15元，投币15元，打印小票中...
2026-04-26 19:32:46 >>>开始打印,排队号为178,订单号为2604261932350014957057
2026-04-26 19:32:47>>>订单2604261932350014957057写入成功,剩余空间为1678000,占用RAM为647.021484375
删除未同步订单2604261932350014957057
2026-04-26 19:32:49>>>订单2604261932350014957057删除成功,剩余空间为1678500,占用RAM为653.16796875
检测订单目录中>>>
无未同步订单>>>
2026-04-26 19:32:49 >>>当前Ram内存为617.7021484375
定时检测未同步订单启用[checkOrderNum=536877637]
2026-04-26 19:32:50>>>cash write=0C
2026-04-26 19:32:50>>>cash read=3E


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


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


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


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


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


===19:46:18===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:46:13 >>>回调事件[910,devices/TL4957]
2026-04-26 19:46:13 >>>故障排除日志:上一MQTT订单号缓存列表为2604261943200038531443
2026-04-26 19:46:13 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 19:46:13 开始打印,排队:185,票券:2604261946058963616801,订单:2604261946050087662461,[2026-04-26 19:46:11微信支付15元]
2026-04-26 19:46:13>>>MQTT票号同步场景，创建空订单对象
2026-04-26 19:46:13>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 19:46:15 >>>回调事件[910,devices/TL4957]
2026-04-26 19:46:15 >>>故障排除日志:上一MQTT订单号缓存列表为2604261946050087662461
2026-04-26 19:46:15 >>>故障排除日志:终端未同步成功订单列表01852604261946050087662461
已接收过此消息,票券号为2604261946058963616801,排队号为185
2026-04-26 19:46:15 开始打印,排队:186,票券:2604261946066668441401,订单:2604261946060064823626,[2026-04-26 19:46:13微信支付15元]
2026-04-26 19:46:15>>>HTTP请求进行中，跳过本次同步
2026-04-26 19:46:17 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261946058963616801","queue_number":185,"trade_uid":"2604261946050087662461"}]}
2026-04-26 19:46:17 >>>故障排除日志:删除未同步下发订单成功2604261946050087662461
2026-04-26 19:46:17 >>>故障排除日志:终端同步成功后剩余订单列表01862604261946060064823626
定时检测未同步订单启用[checkOrderNum=536877813]


===19:47:19===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:46:50 >>>回调事件[910,devices/TL4957]
2026-04-26 19:46:50 >>>故障排除日志:上一MQTT订单号缓存列表为2604261946050087662461|2604261946060064823626
2026-04-26 19:46:50 >>>故障排除日志:终端未同步成功订单列表01862604261946060064823626
已接收过此消息,票券号为2604261946066668441401,排队号为186
2026-04-26 19:46:50 开始打印,排队:187,票券:2604261946442576806401,订单:2604261946440023644118,[2026-04-26 19:46:50微信支付15元]
2026-04-26 19:46:50>>>MQTT票号同步场景，创建空订单对象
2026-04-26 19:46:50>>>合并MQTT票号列表到订单同步请求,共2张票
2026-04-26 19:46:52 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261946066668441401","queue_number":186,"trade_uid":"2604261946060064823626"},{"ticket_no":"2604261946442576806401","queue_number":187,"trade_uid":"2604261946440023644118"}]}
2026-04-26 19:46:52 >>>故障排除日志:删除未同步下发订单成功2604261946060064823626
2026-04-26 19:46:52 >>>故障排除日志:删除未同步下发订单成功2604261946440023644118
2026-04-26 19:46:52 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877827]


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


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


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


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


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


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


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


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