TLClient_JSSCOM_LuatOS-Air_V4010_RDA8910_RFTTS_0xe0000,2.8.6,865328069307741,86187078413418,
poweron reason:0

===08:46:09===
2026-04-27 21:11:07 >>>剩余flash空间=1682000,占用RAM为644.4892578125
2026-04-27 21:11:07 >>>回调异常:911,initSys,30000,nil



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

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

2026-04-28 08:46:19>>>cash write=0C
2026-04-28 08:46:19>>>cash read=3E
流量卡还有337天过期
2026-04-28 08:46:27 >>>当前Ram内存为663.9404296875


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


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


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


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


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


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


===11:06:13===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-28 11:05:34 >>>回调事件[910,devices/S2381]
2026-04-28 11:05:34 >>>故障排除日志:上一MQTT订单号缓存列表为2604281039370085286798
2026-04-28 11:05:34 >>>故障排除日志:终端未同步成功订单列表
2026-04-28 11:05:34 开始打印,排队:7,票券:2604281105264438747901,订单:2604281105260042565227,[2026-04-28 11:05:33微信支付10元]
2026-04-28 11:05:34>>>MQTT票号同步场景，创建空订单对象
2026-04-28 11:05:34>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-28 11:05:36 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604281105264438747901","queue_number":7,"trade_uid":"2604281105260042565227"}]}
2026-04-28 11:05:36 >>>故障排除日志:删除未同步下发订单成功2604281105260042565227
2026-04-28 11:05:36 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536874222]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-28 11:05:54 >>>回调事件[910,devices/S2381]
2026-04-28 11:05:54 >>>故障排除日志:上一MQTT订单号缓存列表为2604281105260042565227
2026-04-28 11:05:54 >>>故障排除日志:终端未同步成功订单列表
2026-04-28 11:05:54 开始打印,排队:8,票券:2604281105486069194301,订单:2604281105480058809697,[2026-04-28 11:05:53支付宝支付10元]
2026-04-28 11:05:55>>>MQTT票号同步场景，创建空订单对象
2026-04-28 11:05:55>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-28 11:05:56 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604281105486069194301","queue_number":8,"trade_uid":"2604281105480058809697"}]}
2026-04-28 11:05:56 >>>故障排除日志:删除未同步下发订单成功2604281105480058809697
2026-04-28 11:05:57 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536874229]


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


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


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


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


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


===13:46:15===
2026-04-28 13:46:10>>>cash read=0A
2026-04-28 13:46:11>>>cash read=3E


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


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


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


===15:01:16===
2026-04-28 15:00:22>>>cash read=0A
2026-04-28 15:00:23>>>cash read=3E


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


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


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


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


===16:13:18===
2026-04-28 16:13:04>>>cash read=0A
2026-04-28 16:13:05>>>cash read=3E


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


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


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


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


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


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


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


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


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


===17:21:22===
2026-04-28 17:20:38>>>cash read=9E
2026-04-28 17:20:39>>>cash read=3E


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


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


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


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


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


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


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


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


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


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


===18:13:25===
2026-04-28 18:13:16>>>cash read=00
2026-04-28 18:13:17>>>cash read=3E


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


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


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


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


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


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


===18:42:27===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-28 18:41:55 >>>回调事件[910,devices/S2381]
2026-04-28 18:41:55 >>>故障排除日志:上一MQTT订单号缓存列表为2604281840370059540686
2026-04-28 18:41:55 >>>故障排除日志:终端未同步成功订单列表
2026-04-28 18:41:55 开始打印,排队:48,票券:2604281841513010605801,订单:2604281841510028176593,[2026-04-28 18:41:55支付宝支付10元]
2026-04-28 18:41:55>>>MQTT票号同步场景，创建空订单对象
2026-04-28 18:41:55>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-28 18:41:57 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604281841513010605801","queue_number":48,"trade_uid":"2604281841510028176593"}]}
2026-04-28 18:41:57 >>>故障排除日志:删除未同步下发订单成功2604281841510028176593
2026-04-28 18:41:57 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536884342]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-28 18:42:20 >>>回调事件[910,devices/S2381]
2026-04-28 18:42:20 >>>故障排除日志:上一MQTT订单号缓存列表为2604281841510028176593
2026-04-28 18:42:20 >>>故障排除日志:终端未同步成功订单列表
2026-04-28 18:42:20 开始打印,排队:49,票券:2604281842120099406301,订单:2604281842110098882256,[2026-04-28 18:42:19微信支付10元]
2026-04-28 18:42:20>>>MQTT票号同步场景，创建空订单对象
2026-04-28 18:42:20>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-28 18:42:22 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604281842120099406301","queue_number":49,"trade_uid":"2604281842110098882256"}]}
2026-04-28 18:42:22 >>>故障排除日志:删除未同步下发订单成功2604281842110098882256
2026-04-28 18:42:22 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536884356]


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


===18:49:28===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-28 18:48:32 >>>回调事件[910,devices/S2381]
2026-04-28 18:48:32 >>>故障排除日志:上一MQTT订单号缓存列表为2604281846140090357098
2026-04-28 18:48:32 >>>故障排除日志:终端未同步成功订单列表
2026-04-28 18:48:32 开始打印,排队:51,票券:2604281848255122727301,订单:2604281848250049266963,[2026-04-28 18:48:32微信支付10元]
2026-04-28 18:48:32>>>MQTT票号同步场景，创建空订单对象
2026-04-28 18:48:32>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-28 18:48:34 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604281848255122727301","queue_number":51,"trade_uid":"2604281848250049266963"}]}
2026-04-28 18:48:34 >>>故障排除日志:删除未同步下发订单成功2604281848250049266963
2026-04-28 18:48:34 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536884534]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-28 18:49:14 >>>回调事件[910,devices/S2381]
2026-04-28 18:49:15 >>>故障排除日志:上一MQTT订单号缓存列表为2604281848250049266963
2026-04-28 18:49:15 >>>故障排除日志:终端未同步成功订单列表
2026-04-28 18:49:15 开始打印,排队:52,票券:2604281849005110594701,订单:2604281849000048925373,[2026-04-28 18:49:14支付宝支付10元]
2026-04-28 18:49:15>>>MQTT票号同步场景，创建空订单对象
2026-04-28 18:49:15>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-28 18:49:17 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604281849005110594701","queue_number":52,"trade_uid":"2604281849000048925373"}]}
2026-04-28 18:49:17 >>>故障排除日志:删除未同步下发订单成功2604281849000048925373
2026-04-28 18:49:17 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536884556]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-28 18:49:21 >>>回调事件[910,devices/S2381]
2026-04-28 18:49:21 >>>故障排除日志:上一MQTT订单号缓存列表为2604281849000048925373
2026-04-28 18:49:21 >>>故障排除日志:终端未同步成功订单列表
2026-04-28 18:49:21 开始打印,排队:53,票券:2604281849116750036501,订单:2604281849110065454882,[2026-04-28 18:49:21微信支付10元]
2026-04-28 18:49:21>>>MQTT票号同步场景，创建空订单对象
2026-04-28 18:49:21>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-28 18:49:23 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604281849116750036501","queue_number":53,"trade_uid":"2604281849110065454882"}]}
2026-04-28 18:49:23 >>>故障排除日志:删除未同步下发订单成功2604281849110065454882
2026-04-28 18:49:23 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536884566]


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


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


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


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


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


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


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


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


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


===19:24:31===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-28 19:23:35 >>>回调事件[910,devices/S2381]
2026-04-28 19:23:35 >>>故障排除日志:上一MQTT订单号缓存列表为2604281919040004776436
2026-04-28 19:23:35 >>>故障排除日志:终端未同步成功订单列表
2026-04-28 19:23:35 开始打印,排队:63,票券:2604281923277680854601,订单:2604281923270074886519,[2026-04-28 19:23:34微信支付10元]
2026-04-28 19:23:35>>>MQTT票号同步场景，创建空订单对象
2026-04-28 19:23:35>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-28 19:23:37 >>>回调事件[910,devices/S2381]
2026-04-28 19:23:37 >>>故障排除日志:上一MQTT订单号缓存列表为2604281923270074886519
2026-04-28 19:23:37 >>>故障排除日志:终端未同步成功订单列表00632604281923270074886519
2026-04-28 19:23:37 开始打印,排队:64,票券:2604281923277290023501,订单:2604281923270070969626,[2026-04-28 19:23:37微信支付10元]
已接收过此消息,票券号为2604281923277680854601,排队号为63
2026-04-28 19:23:37>>>HTTP请求进行中，跳过本次同步
2026-04-28 19:23:39 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604281923277680854601","queue_number":63,"trade_uid":"2604281923270074886519"}]}
2026-04-28 19:23:39 >>>故障排除日志:删除未同步下发订单成功2604281923270074886519
2026-04-28 19:23:39 >>>故障排除日志:终端同步成功后剩余订单列表00642604281923270070969626
定时检测未同步订单启用[checkOrderNum=536885417]


===19:25:31===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-28 19:25:20 >>>回调事件[910,devices/S2381]
2026-04-28 19:25:20 >>>故障排除日志:上一MQTT订单号缓存列表为2604281923270070969626|2604281923270074886519
2026-04-28 19:25:20 >>>故障排除日志:终端未同步成功订单列表00642604281923270070969626
已接收过此消息,票券号为2604281923277290023501,排队号为64
2026-04-28 19:25:20 开始打印,排队:65,票券:2604281925116447027901,订单:2604281925110062439091,[2026-04-28 19:25:19微信支付10元]
2026-04-28 19:25:20>>>MQTT票号同步场景，创建空订单对象
2026-04-28 19:25:20>>>合并MQTT票号列表到订单同步请求,共2张票
2026-04-28 19:25:22 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604281923277290023501","queue_number":64,"trade_uid":"2604281923270070969626"},{"ticket_no":"2604281925116447027901","queue_number":65,"trade_uid":"2604281925110062439091"}]}
2026-04-28 19:25:22 >>>故障排除日志:删除未同步下发订单成功2604281923270070969626
2026-04-28 19:25:22 >>>故障排除日志:删除未同步下发订单成功2604281925110062439091
2026-04-28 19:25:22 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536885458]


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


===19:31:32===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-28 19:30:38 >>>回调事件[910,devices/S2381]
2026-04-28 19:30:38 >>>故障排除日志:上一MQTT订单号缓存列表为2604281928250071235642
2026-04-28 19:30:38 >>>故障排除日志:终端未同步成功订单列表
2026-04-28 19:30:38 开始打印,排队:67,票券:2604281930321573237401,订单:2604281930320013786896,[2026-04-28 19:30:38微信支付10元]
2026-04-28 19:30:38>>>MQTT票号同步场景，创建空订单对象
2026-04-28 19:30:38>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-28 19:30:40 >>>回调事件[910,devices/S2381]
2026-04-28 19:30:40 >>>故障排除日志:上一MQTT订单号缓存列表为2604281930320013786896
2026-04-28 19:30:40 >>>故障排除日志:终端未同步成功订单列表00672604281930320013786896
2026-04-28 19:30:40 开始打印,排队:68,票券:2604281930305256881201,订单:2604281930300050416482,[2026-04-28 19:30:39支付宝支付10元]
已接收过此消息,票券号为2604281930321573237401,排队号为67
2026-04-28 19:30:40>>>HTTP请求进行中，跳过本次同步
2026-04-28 19:30:42 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604281930321573237401","queue_number":67,"trade_uid":"2604281930320013786896"}]}
2026-04-28 19:30:42 >>>故障排除日志:删除未同步下发订单成功2604281930320013786896
2026-04-28 19:30:42 >>>故障排除日志:终端同步成功后剩余订单列表00682604281930300050416482
定时检测未同步订单启用[checkOrderNum=536885568]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-28 19:30:49 >>>回调事件[910,devices/S2381]
2026-04-28 19:30:49 >>>故障排除日志:上一MQTT订单号缓存列表为2604281930300050416482|2604281930320013786896
2026-04-28 19:30:49 >>>故障排除日志:终端未同步成功订单列表00682604281930300050416482
已接收过此消息,票券号为2604281930305256881201,排队号为68
2026-04-28 19:30:49 开始打印,排队:69,票券:2604281930342143429101,订单:2604281930340019403093,[2026-04-28 19:30:49微信支付10元]
2026-04-28 19:30:49>>>MQTT票号同步场景，创建空订单对象
2026-04-28 19:30:49>>>合并MQTT票号列表到订单同步请求,共2张票
2026-04-28 19:30:51 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604281930305256881201","queue_number":68,"trade_uid":"2604281930300050416482"},{"ticket_no":"2604281930342143429101","queue_number":69,"trade_uid":"2604281930340019403093"}]}
2026-04-28 19:30:51 >>>故障排除日志:删除未同步下发订单成功2604281930300050416482
2026-04-28 19:30:51 >>>故障排除日志:删除未同步下发订单成功2604281930340019403093
2026-04-28 19:30:51 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536885574]
2026-04-28 19:31:15>>>cash read=29
2026-04-28 19:31:15 >>>回调事件130,cash_status,20029,退钞中
2026-04-28 19:31:17>>>cash read=01
2026-04-28 19:31:18>>>cash read=3E
2026-04-28 19:31:20>>>cash read=00
2026-04-28 19:31:21>>>cash read=818F42
2026-04-28 19:31:21>>>cash write=02
2026-04-28 19:31:21 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-28 19:31:22>>>cash read=10
2026-04-28 19:31:22 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-28 19:31:22 当前产品价格10元，投币10元，打印小票中...
2026-04-28 19:31:22 >>>开始打印,排队号为70,订单号为2604281931220022381958
2026-04-28 19:31:22>>>订单2604281931220022381958写入成功,剩余空间为1676500,占用RAM为655.962890625
删除未同步订单2604281931220022381958
2026-04-28 19:31:24>>>订单2604281931220022381958删除成功,剩余空间为1677500,占用RAM为654.697265625
检测订单目录中>>>
无未同步订单>>>
2026-04-28 19:31:24 >>>当前Ram内存为621.123046875
定时检测未同步订单启用[checkOrderNum=536885597]
2026-04-28 19:31:25>>>cash write=0C
2026-04-28 19:31:25>>>cash read=3E


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


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


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


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


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


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


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


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


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


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


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


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


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


===20:20:40===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-28 20:19:42 >>>回调事件[910,devices/S2381]
2026-04-28 20:19:42 >>>故障排除日志:上一MQTT订单号缓存列表为2604282018220009103147
2026-04-28 20:19:42 >>>故障排除日志:终端未同步成功订单列表
2026-04-28 20:19:42 开始打印,排队:87,票券:2604282019358362975801,订单:2604282019350081745283,[2026-04-28 20:19:41支付宝支付10元]
2026-04-28 20:19:42>>>MQTT票号同步场景，创建空订单对象
2026-04-28 20:19:42>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-28 20:19:44 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604282019358362975801","queue_number":87,"trade_uid":"2604282019350081745283"}]}
2026-04-28 20:19:44 >>>故障排除日志:删除未同步下发订单成功2604282019350081745283
2026-04-28 20:19:44 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536886982]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-28 20:19:58 >>>回调事件[910,devices/S2381]
2026-04-28 20:19:58 >>>故障排除日志:上一MQTT订单号缓存列表为2604282019350081745283
2026-04-28 20:19:58 >>>故障排除日志:终端未同步成功订单列表
2026-04-28 20:19:58 开始打印,排队:88,票券:2604282019486238914501,订单:2604282019480060371757,[2026-04-28 20:19:57微信支付10元]
2026-04-28 20:19:58>>>MQTT票号同步场景，创建空订单对象
2026-04-28 20:19:58>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-28 20:20:00 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604282019486238914501","queue_number":88,"trade_uid":"2604282019480060371757"}]}
2026-04-28 20:20:01 >>>故障排除日志:删除未同步下发订单成功2604282019480060371757
2026-04-28 20:20:01 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536886990]


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


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


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


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


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


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


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


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


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


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


===20:53:43===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-28 20:52:47 >>>回调事件[910,devices/S2381]
2026-04-28 20:52:47 >>>故障排除日志:上一MQTT订单号缓存列表为2604282046190096358328
2026-04-28 20:52:47 >>>故障排除日志:终端未同步成功订单列表
2026-04-28 20:52:47 开始打印,排队:100,票券:2604282052407453868101,订单:2604282052400072663515,[2026-04-28 20:52:47微信支付10元]
2026-04-28 20:52:48>>>MQTT票号同步场景，创建空订单对象
2026-04-28 20:52:48>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-28 20:52:50 >>>回调事件[910,devices/S2381]
2026-04-28 20:52:50 >>>故障排除日志:上一MQTT订单号缓存列表为2604282052400072663515
2026-04-28 20:52:50 >>>故障排除日志:终端未同步成功订单列表01002604282052400072663515
已接收过此消息,票券号为2604282052407453868101,排队号为100
2026-04-28 20:52:50 开始打印,排队:101,票券:2604282052430081628301,订单:2604282052420099116318,[2026-04-28 20:52:48微信支付10元]
2026-04-28 20:52:50>>>HTTP请求进行中，跳过本次同步
2026-04-28 20:52:52 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604282052407453868101","queue_number":100,"trade_uid":"2604282052400072663515"}]}
2026-04-28 20:52:52 >>>故障排除日志:删除未同步下发订单成功2604282052400072663515
2026-04-28 20:52:52 >>>故障排除日志:终端同步成功后剩余订单列表01012604282052420099116318
定时检测未同步订单启用[checkOrderNum=536887877]


===21:03:44===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-28 21:02:51 >>>回调事件[910,devices/S2381]
2026-04-28 21:02:51 >>>故障排除日志:上一MQTT订单号缓存列表为2604282052400072663515|2604282052420099116318
2026-04-28 21:02:51 >>>故障排除日志:终端未同步成功订单列表01012604282052420099116318
已接收过此消息,票券号为2604282052430081628301,排队号为101
2026-04-28 21:02:51 开始打印,排队:102,票券:2604282102438049179301,订单:2604282102430078628037,[2026-04-28 21:02:51微信支付10元]
2026-04-28 21:02:51>>>MQTT票号同步场景，创建空订单对象
2026-04-28 21:02:51>>>合并MQTT票号列表到订单同步请求,共2张票
2026-04-28 21:02:53 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604282052430081628301","queue_number":101,"trade_uid":"2604282052420099116318"},{"ticket_no":"2604282102438049179301","queue_number":102,"trade_uid":"2604282102430078628037"}]}
2026-04-28 21:02:53 >>>故障排除日志:删除未同步下发订单成功2604282052420099116318
2026-04-28 21:02:53 >>>故障排除日志:删除未同步下发订单成功2604282102430078628037
2026-04-28 21:02:53 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536888195]


===21:14:44===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-28 21:14:31 >>>回调事件[910,devices/S2381]
2026-04-28 21:14:31 >>>故障排除日志:上一MQTT订单号缓存列表为2604282052420099116318|2604282102430078628037
2026-04-28 21:14:31 >>>故障排除日志:终端未同步成功订单列表
2026-04-28 21:14:31 开始打印,排队:103,票券:2604282114243091549501,订单:2604282114240028961719,[2026-04-28 21:14:30微信支付10元]
2026-04-28 21:14:31>>>MQTT票号同步场景，创建空订单对象
2026-04-28 21:14:31>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-28 21:14:33 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604282114243091549501","queue_number":103,"trade_uid":"2604282114240028961719"}]}
2026-04-28 21:14:33 >>>故障排除日志:删除未同步下发订单成功2604282114240028961719
2026-04-28 21:14:33 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536888574]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-28 21:14:39 >>>回调事件[910,devices/S2381]
2026-04-28 21:14:39 >>>故障排除日志:上一MQTT订单号缓存列表为2604282114240028961719
2026-04-28 21:14:39 >>>故障排除日志:终端未同步成功订单列表
2026-04-28 21:14:39 开始打印,排队:104,票券:2604282114317200831901,订单:2604282114310069957753,[2026-04-28 21:14:39微信支付10元]
2026-04-28 21:14:39>>>MQTT票号同步场景，创建空订单对象
2026-04-28 21:14:39>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-28 21:14:41 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604282114317200831901","queue_number":104,"trade_uid":"2604282114310069957753"}]}
2026-04-28 21:14:41 >>>故障排除日志:删除未同步下发订单成功2604282114310069957753
2026-04-28 21:14:41 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536888580]


===21:19:44===
2026-04-28 21:19:03>>>cash read=0A
2026-04-28 21:19:04>>>cash read=3E


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


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


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


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


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


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


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


===21:38:47===
2026-04-28 21:38:40 >>>剩余flash空间=1682000,占用RAM为638.8447265625
2026-04-28 21:38:40 >>>回调事件:905,callUart,10001,code(E349FC)


2026-04-28 21:38:40 >>>当前Ram内存为642.7353515625
2026-04-28 21:38:44 >>>剩余flash空间=1681500,占用RAM为674.166015625
2026-04-28 21:38:44 >>>回调事件:905,callUart,10001,code(E349FC)


2026-04-28 21:38:44 >>>当前Ram内存为635.2783203125


===21:43:47===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-28 21:42:56 >>>回调事件[910,devices/S2381]
2026-04-28 21:42:56 >>>故障排除日志:上一MQTT订单号缓存列表为2604282137110021882384
2026-04-28 21:42:56 >>>故障排除日志:终端未同步成功订单列表
2026-04-28 21:42:56 开始打印,排队:112,票券:2604282142490862665301,订单:2604282142490006755667,[2026-04-28 21:42:56微信支付10元]
2026-04-28 21:42:56>>>MQTT票号同步场景，创建空订单对象
2026-04-28 21:42:56>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-28 21:42:58 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604282142490862665301","queue_number":112,"trade_uid":"2604282142490006755667"}]}
2026-04-28 21:42:58 >>>故障排除日志:删除未同步下发订单成功2604282142490006755667
2026-04-28 21:42:58 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536889326]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-28 21:43:07 >>>回调事件[910,devices/S2381]
2026-04-28 21:43:07 >>>故障排除日志:上一MQTT订单号缓存列表为2604282142490006755667
2026-04-28 21:43:07 >>>故障排除日志:终端未同步成功订单列表
2026-04-28 21:43:07 开始打印,排队:113,票券:2604282142587022021701,订单:2604282142580068205592,[2026-04-28 21:43:07微信支付10元]
2026-04-28 21:43:07>>>MQTT票号同步场景，创建空订单对象
2026-04-28 21:43:07>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-28 21:43:09 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604282142587022021701","queue_number":113,"trade_uid":"2604282142580068205592"}]}
2026-04-28 21:43:09 >>>故障排除日志:删除未同步下发订单成功2604282142580068205592
2026-04-28 21:43:09 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536889340]


===21:48:48===
2026-04-28 21:48:08>>>cash read=0A
2026-04-28 21:48:09>>>cash read=3E


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


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