TLClient_JSSCOM_LuatOS-Air_V4010_RDA8910_RFTTS_0xe0000,2.8.7,869701076438798,79971258076835,
poweron reason:0

===07:55:50===
上一时间戳为1777506901
隔日重置时间戳true
隔日清空未同步下发列表true
当前排队号为1,音量为5
初始化产品信息:[{"time_limit_date":"","ticket_category":"0","expiry_date":90,"product_detail":"","time_limit_status":"0","begin_minute":"00","product_uid":"12711098232277568446","use_timer":1,"old_price":"10","end_hour":"23","sale_price":"10","end_minute":"59","begin_hour":"00","sale_status":1,"product_name":"剪发一律10元"}]
打印门店标题设置为欢迎光临平剪（龙港大润发超市）
打印门店凭条广告设置为平剪（龙港大润发超市）
是否打印二维码设置为1
是否打印紧凑设置为3
当前号显示模式设置为1
当前卡项核销权限设置为0
session_id:52242****457a5
纸币器设置接收纸币范围为36
欢迎使用天羚自助售票系统[2.8.7]
定时检测未同步订单启用[checkOrderNum=536870969]
2026-05-01 07:54:50>>>cash write=30
2026-05-01 07:54:50>>>cash write=02
2026-05-01 07:54:50>>>cash write=3E
2026-05-01 07:54:50>>>cash read=808F808F
系统时间初始化成功，时间为20265175450
2026-05-01 07:54:51>>>cash write=02
2026-05-01 07:54:51 >>>剩余flash空间=1680000,占用RAM为653.21484375
2026-05-01 07:54:51 >>>回调事件:910,subscribe,10000,连接服务器成功

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

2026-05-01 07:54:54>>>cash write=0C
2026-05-01 07:54:54>>>cash read=3E
流量卡还有121天过期
2026-05-01 07:55:02 >>>当前Ram内存为664.6640625


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


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


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


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


===08:36:53===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-01 08:36:50 >>>回调事件[910,devices/D0519]
2026-05-01 08:36:50 >>>故障排除日志:上一MQTT订单号缓存列表为2605010830200078282583
2026-05-01 08:36:50 >>>故障排除日志:终端未同步成功订单列表
2026-05-01 08:36:50 开始打印,排队:6,票券:2605010836395816983401,订单:2605010836390056319662,[2026-05-01 08:36:49微信支付10元]
2026-05-01 08:36:50>>>MQTT票号同步场景，创建空订单对象
2026-05-01 08:36:50>>>合并MQTT票号列表到订单同步请求,共1张票


===08:37:53===
2026-05-01 08:36:52 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605010836395816983401","queue_number":6,"trade_uid":"2605010836390056319662"}]}
2026-05-01 08:36:52 >>>故障排除日志:删除未同步下发订单成功2605010836390056319662
2026-05-01 08:36:52 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536871412]


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


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


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


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


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


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


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


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


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


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


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


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


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


===09:58:57===
2026-05-01 09:58:03>>>cash read=00
2026-05-01 09:58:04>>>cash read=2F29
2026-05-01 09:58:05>>>cash read=01
2026-05-01 09:58:05>>>cash read=2F
2026-05-01 09:58:06>>>cash read=3E
2026-05-01 09:58:09>>>cash read=00
2026-05-01 09:58:10>>>cash read=2F29
2026-05-01 09:58:12>>>cash read=3E
2026-05-01 09:58:16>>>cash read=00
2026-05-01 09:58:17>>>cash read=29
2026-05-01 09:58:17 >>>回调事件130,cash_status,20029,退钞中
2026-05-01 09:58:18>>>cash read=2F29
2026-05-01 09:58:19>>>cash read=3E
2026-05-01 09:58:22>>>cash read=00
2026-05-01 09:58:23>>>cash read=29
2026-05-01 09:58:23 >>>回调事件130,cash_status,20029,退钞中
2026-05-01 09:58:24>>>cash read=2F29
2026-05-01 09:58:25>>>cash read=3E
2026-05-01 09:58:35>>>cash read=00
2026-05-01 09:58:36>>>cash read=01
2026-05-01 09:58:39>>>cash read=3E
2026-05-01 09:58:40>>>cash read=00
2026-05-01 09:58:40>>>cash read=2F29
2026-05-01 09:58:41>>>cash read=3E
2026-05-01 09:58:42>>>cash read=2F29
2026-05-01 09:58:44>>>cash read=00
2026-05-01 09:58:45>>>cash read=2F29
2026-05-01 09:58:46>>>cash read=3E


===09:59:57===
2026-05-01 09:59:00>>>cash read=00
2026-05-01 09:59:01>>>cash read=29
2026-05-01 09:59:01 >>>回调事件130,cash_status,20029,退钞中
2026-05-01 09:59:01>>>cash read=2F29
2026-05-01 09:59:03>>>cash read=3E
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-01 09:59:29 >>>回调事件[910,devices/D0519]
2026-05-01 09:59:29 >>>故障排除日志:上一MQTT订单号缓存列表为2605010956540010871463
2026-05-01 09:59:29 >>>故障排除日志:终端未同步成功订单列表
2026-05-01 09:59:29 开始打印,排队:22,票券:2605010959214221497301,订单:2605010959210039650614,[2026-05-01 09:59:28支付宝支付10元]
2026-05-01 09:59:29>>>MQTT票号同步场景，创建空订单对象
2026-05-01 09:59:29>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-01 09:59:31 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605010959214221497301","queue_number":22,"trade_uid":"2605010959210039650614"}]}
2026-05-01 09:59:31 >>>故障排除日志:删除未同步下发订单成功2605010959210039650614
2026-05-01 09:59:31 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536872274]


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


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


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


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


===10:17:58===
2026-05-01 10:17:33>>>cash read=00
2026-05-01 10:17:34>>>cash read=2F29
2026-05-01 10:17:36>>>cash read=00
2026-05-01 10:17:37>>>cash read=2F29
2026-05-01 10:17:38>>>cash read=3E
2026-05-01 10:17:41>>>cash read=00
2026-05-01 10:17:42>>>cash read=818F42
2026-05-01 10:17:42>>>cash write=02
2026-05-01 10:17:42 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-05-01 10:17:42>>>cash read=10
2026-05-01 10:17:42 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-01 10:17:42 当前产品价格10元，投币10元，打印小票中...
2026-05-01 10:17:42 >>>开始打印,排队号为28,订单号为2605011017420040519832
2026-05-01 10:17:43>>>订单2605011017420040519832写入成功,剩余空间为1679500,占用RAM为634.9599609375
删除未同步订单2605011017420040519832
2026-05-01 10:17:45>>>订单2605011017420040519832删除成功,剩余空间为1680500,占用RAM为644.3330078125
检测订单目录中>>>
无未同步订单>>>
2026-05-01 10:17:45 >>>当前Ram内存为616.1728515625
定时检测未同步订单启用[checkOrderNum=536872483]
2026-05-01 10:17:46>>>cash write=0C
2026-05-01 10:17:46>>>cash read=3E


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


===12:20:06===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-01 12:19:44 >>>回调事件[910,devices/D0519]
2026-05-01 12:19:44 >>>故障排除日志:上一MQTT订单号缓存列表为2605011214280085045662
2026-05-01 12:19:44 >>>故障排除日志:终端未同步成功订单列表
2026-05-01 12:19:44 开始打印,排队:59,票券:2605011219363974214101,订单:2605011219360037704557,[2026-05-01 12:19:43微信支付10元]
2026-05-01 12:19:44>>>MQTT票号同步场景，创建空订单对象
2026-05-01 12:19:44>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-01 12:19:46 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605011219363974214101","queue_number":59,"trade_uid":"2605011219360037704557"}]}
2026-05-01 12:19:46 >>>故障排除日志:删除未同步下发订单成功2605011219360037704557
2026-05-01 12:19:47 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536873814]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-01 12:20:03 >>>回调事件[910,devices/D0519]
2026-05-01 12:20:03 >>>故障排除日志:上一MQTT订单号缓存列表为2605011219360037704557
2026-05-01 12:20:03 >>>故障排除日志:终端未同步成功订单列表
2026-05-01 12:20:03 开始打印,排队:60,票券:2605011219533404604901,订单:2605011219530031499247,[2026-05-01 12:20:02支付宝支付10元]
2026-05-01 12:20:03>>>MQTT票号同步场景，创建空订单对象
2026-05-01 12:20:03>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-01 12:20:05 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605011219533404604901","queue_number":60,"trade_uid":"2605011219530031499247"}]}
2026-05-01 12:20:05 >>>故障排除日志:删除未同步下发订单成功2605011219530031499247
2026-05-01 12:20:05 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536873823]


===12:22:06===
2026-05-01 12:21:24>>>cash read=00
2026-05-01 12:21:25>>>cash read=818F41
2026-05-01 12:21:25>>>cash write=02
2026-05-01 12:21:25 >>>回调事件130,cash_status,10022,进钞中...read money=5
2026-05-01 12:21:26>>>cash write=0C
2026-05-01 12:21:26>>>cash read=00
2026-05-01 12:21:26>>>cash read=10
2026-05-01 12:21:26 >>>回调事件130,5,10023,finish Money=5,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-01 12:21:27>>>cash read=01
2026-05-01 12:21:30>>>cash read=3E
2026-05-01 12:21:31>>>cash read=00
2026-05-01 12:21:32>>>cash read=818F41
2026-05-01 12:21:32>>>cash write=02
2026-05-01 12:21:32 >>>回调事件130,cash_status,10022,进钞中...read money=5
2026-05-01 12:21:32>>>cash read=10
2026-05-01 12:21:32 >>>回调事件130,5,10023,finish Money=5,进钞完成
2026-05-01 12:21:32 当前产品价格10元，投币10元，打印小票中...
2026-05-01 12:21:32 >>>开始打印,排队号为61,订单号为2605011221260040519840
2026-05-01 12:21:32>>>订单2605011221260040519840写入成功,剩余空间为1679000,占用RAM为631.142578125
删除未同步订单2605011221260040519840
2026-05-01 12:21:34>>>订单2605011221260040519840删除成功,剩余空间为1680000,占用RAM为646.13671875
检测订单目录中>>>
无未同步订单>>>
2026-05-01 12:21:34 >>>当前Ram内存为617.5107421875
定时检测未同步订单启用[checkOrderNum=536873846]
2026-05-01 12:21:35>>>cash write=0C
2026-05-01 12:21:35>>>cash read=3E


===12:25:06===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-01 12:24:15 >>>回调事件[910,devices/D0519]
2026-05-01 12:24:15 >>>故障排除日志:上一MQTT订单号缓存列表为2605011219530031499247
2026-05-01 12:24:15 >>>故障排除日志:终端未同步成功订单列表
2026-05-01 12:24:15 开始打印,排队:62,票券:2605011224091521933701,订单:2605011224090013272783,[2026-05-01 12:24:14微信支付10元]
2026-05-01 12:24:15>>>MQTT票号同步场景，创建空订单对象
2026-05-01 12:24:15>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-01 12:24:17 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605011224091521933701","queue_number":62,"trade_uid":"2605011224090013272783"}]}
2026-05-01 12:24:17 >>>故障排除日志:删除未同步下发订单成功2605011224090013272783
2026-05-01 12:24:17 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536873880]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-01 12:24:29 >>>回调事件[910,devices/D0519]
2026-05-01 12:24:30 >>>故障排除日志:上一MQTT订单号缓存列表为2605011224090013272783
2026-05-01 12:24:30 >>>故障排除日志:终端未同步成功订单列表
2026-05-01 12:24:30 开始打印,排队:63,票券:2605011224248886307401,订单:2605011224240087039845,[2026-05-01 12:24:29支付宝支付10元]
2026-05-01 12:24:30>>>MQTT票号同步场景，创建空订单对象
2026-05-01 12:24:30>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-01 12:24:32 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605011224248886307401","queue_number":63,"trade_uid":"2605011224240087039845"}]}
2026-05-01 12:24:32 >>>故障排除日志:删除未同步下发订单成功2605011224240087039845
2026-05-01 12:24:32 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536873887]


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


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


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


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


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


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


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


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


===13:06:09===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-01 13:05:10 >>>回调事件[910,devices/D0519]
2026-05-01 13:05:10 >>>故障排除日志:上一MQTT订单号缓存列表为2605011301140084996325
2026-05-01 13:05:10 >>>故障排除日志:终端未同步成功订单列表
2026-05-01 13:05:10 开始打印,排队:72,票券:2605011305030654553401,订单:2605011305030004712676,[2026-05-01 13:05:09支付宝支付10元]
2026-05-01 13:05:10>>>MQTT票号同步场景，创建空订单对象
2026-05-01 13:05:10>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-01 13:05:12 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605011305030654553401","queue_number":72,"trade_uid":"2605011305030004712676"}]}
2026-05-01 13:05:12 >>>故障排除日志:删除未同步下发订单成功2605011305030004712676
2026-05-01 13:05:12 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536874327]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-01 13:05:55 >>>回调事件[910,devices/D0519]
2026-05-01 13:05:55 >>>故障排除日志:上一MQTT订单号缓存列表为2605011305030004712676
2026-05-01 13:05:55 >>>故障排除日志:终端未同步成功订单列表
2026-05-01 13:05:55 开始打印,排队:73,票券:2605011305476161539701,订单:2605011305470059666557,[2026-05-01 13:05:54微信支付10元]
2026-05-01 13:05:55>>>MQTT票号同步场景，创建空订单对象
2026-05-01 13:05:55>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-01 13:05:57 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605011305476161539701","queue_number":73,"trade_uid":"2605011305470059666557"}]}
2026-05-01 13:05:57 >>>故障排除日志:删除未同步下发订单成功2605011305470059666557
2026-05-01 13:05:57 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536874339]


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


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


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


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


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


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


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


===13:32:13===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-01 13:31:17 >>>回调事件[910,devices/D0519]
2026-05-01 13:31:17 >>>故障排除日志:上一MQTT订单号缓存列表为2605011327370038391039
2026-05-01 13:31:17 >>>故障排除日志:终端未同步成功订单列表
2026-05-01 13:31:17 开始打印,排队:81,票券:2605011331034098334801,订单:2605011331030038935535,[2026-05-01 13:31:16支付宝支付10元]
2026-05-01 13:31:17>>>MQTT票号同步场景，创建空订单对象
2026-05-01 13:31:17>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-01 13:31:19 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605011331034098334801","queue_number":81,"trade_uid":"2605011331030038935535"}]}
2026-05-01 13:31:19 >>>故障排除日志:删除未同步下发订单成功2605011331030038935535
2026-05-01 13:31:19 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536874630]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-01 13:31:32 >>>回调事件[910,devices/D0519]
2026-05-01 13:31:32 >>>故障排除日志:上一MQTT订单号缓存列表为2605011331030038935535
2026-05-01 13:31:32 >>>故障排除日志:终端未同步成功订单列表
2026-05-01 13:31:32 开始打印,排队:82,票券:2605011331226044378101,订单:2605011331220058154268,[2026-05-01 13:31:30微信支付10元]
2026-05-01 13:31:32>>>MQTT票号同步场景，创建空订单对象
2026-05-01 13:31:32>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-01 13:31:34 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605011331226044378101","queue_number":82,"trade_uid":"2605011331220058154268"}]}
2026-05-01 13:31:34 >>>故障排除日志:删除未同步下发订单成功2605011331220058154268
2026-05-01 13:31:34 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536874637]


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


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


===13:47:14===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-01 13:46:40 >>>回调事件[910,devices/D0519]
2026-05-01 13:46:40 >>>故障排除日志:上一MQTT订单号缓存列表为2605011340070042023231|2605011340070042023231
2026-05-01 13:46:40 >>>故障排除日志:终端未同步成功订单列表
2026-05-01 13:46:40 开始打印,排队:86,票券:2605011346281743737401,订单:2605011346280015552227,[2026-05-01 13:46:38支付宝支付10元]
2026-05-01 13:46:40>>>MQTT票号同步场景，创建空订单对象
2026-05-01 13:46:40>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-01 13:46:42 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605011346281743737401","queue_number":86,"trade_uid":"2605011346280015552227"}]}
2026-05-01 13:46:42 >>>故障排除日志:删除未同步下发订单成功2605011346280015552227
2026-05-01 13:46:42 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536874796]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-01 13:46:50 >>>回调事件[910,devices/D0519]
2026-05-01 13:46:50 >>>故障排除日志:上一MQTT订单号缓存列表为2605011346280015552227
2026-05-01 13:46:50 >>>故障排除日志:终端未同步成功订单列表
2026-05-01 13:46:50 开始打印,排队:87,票券:2605011346428656881301,订单:2605011346420084502295,[2026-05-01 13:46:49微信支付10元]
2026-05-01 13:46:50>>>MQTT票号同步场景，创建空订单对象
2026-05-01 13:46:50>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-01 13:46:52 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605011346428656881301","queue_number":87,"trade_uid":"2605011346420084502295"}]}
2026-05-01 13:46:52 >>>故障排除日志:删除未同步下发订单成功2605011346420084502295
2026-05-01 13:46:52 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536874807]


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


===13:56:15===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-01 13:55:17 >>>回调事件[910,devices/D0519]
2026-05-01 13:55:17 >>>故障排除日志:上一MQTT订单号缓存列表为2605011350090079389231
2026-05-01 13:55:17 >>>故障排除日志:终端未同步成功订单列表
2026-05-01 13:55:17 开始打印,排队:89,票券:2605011355086686814301,订单:2605011355080064970437,[2026-05-01 13:55:16微信支付10元]
2026-05-01 13:55:17 开始打印,排队:90,票券:2605011355086687267802,订单:2605011355080064970437,[2026-05-01 13:55:16微信支付10元]
2026-05-01 13:55:17>>>MQTT票号同步场景，创建空订单对象
2026-05-01 13:55:18>>>合并MQTT票号列表到订单同步请求,共2张票
2026-05-01 13:55:21 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605011355086686814301","queue_number":89,"trade_uid":"2605011355080064970437"},{"ticket_no":"2605011355086687267802","queue_number":90,"trade_uid":"2605011355080064970437"}]}
2026-05-01 13:55:21 >>>故障排除日志:删除未同步下发订单成功2605011355080064970437
2026-05-01 13:55:21 >>>故障排除日志:删除未同步下发订单成功2605011355080064970437
2026-05-01 13:55:21 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536874898]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-01 13:55:22 >>>回调事件[910,devices/D0519]
2026-05-01 13:55:23 >>>故障排除日志:上一MQTT订单号缓存列表为2605011355080064970437|2605011355080064970437
2026-05-01 13:55:23 >>>故障排除日志:终端未同步成功订单列表
2026-05-01 13:55:23 开始打印,排队:91,票券:2605011355157917928101,订单:2605011355150077118389,[2026-05-01 13:55:22微信支付10元]
2026-05-01 13:55:23>>>MQTT票号同步场景，创建空订单对象
2026-05-01 13:55:23>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-01 13:55:25 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605011355157917928101","queue_number":91,"trade_uid":"2605011355150077118389"}]}
2026-05-01 13:55:25 >>>故障排除日志:删除未同步下发订单成功2605011355150077118389
2026-05-01 13:55:25 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536874904]


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


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


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


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


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


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


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


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


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


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


===14:41:18===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-01 14:41:06 >>>回调事件[910,devices/D0519]
2026-05-01 14:41:06 >>>故障排除日志:上一MQTT订单号缓存列表为2605011431160026363159
2026-05-01 14:41:06 >>>故障排除日志:终端未同步成功订单列表
2026-05-01 14:41:06 开始打印,排队:105,票券:2605011440594540089401,订单:2605011440590043496386,[2026-05-01 14:41:05微信支付10元]
2026-05-01 14:41:06>>>MQTT票号同步场景，创建空订单对象
2026-05-01 14:41:06>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-01 14:41:08 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605011440594540089401","queue_number":105,"trade_uid":"2605011440590043496386"}]}
2026-05-01 14:41:08 >>>故障排除日志:删除未同步下发订单成功2605011440590043496386
2026-05-01 14:41:08 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536875418]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-01 14:41:11 >>>回调事件[910,devices/D0519]
2026-05-01 14:41:11 >>>故障排除日志:上一MQTT订单号缓存列表为2605011440590043496386
2026-05-01 14:41:11 >>>故障排除日志:终端未同步成功订单列表
2026-05-01 14:41:11 开始打印,排队:106,票券:2605011441060747942701,订单:2605011441060005545852,[2026-05-01 14:41:10支付宝支付10元]
2026-05-01 14:41:11>>>MQTT票号同步场景，创建空订单对象
2026-05-01 14:41:11>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-01 14:41:13 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605011441060747942701","queue_number":106,"trade_uid":"2605011441060005545852"}]}
2026-05-01 14:41:13 >>>故障排除日志:删除未同步下发订单成功2605011441060005545852
2026-05-01 14:41:13 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536875424]


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


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


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


===14:53:19===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-01 14:52:30 >>>回调事件[910,devices/D0519]
2026-05-01 14:52:30 >>>故障排除日志:上一MQTT订单号缓存列表为2605011451480078724671
2026-05-01 14:52:30 >>>故障排除日志:终端未同步成功订单列表
2026-05-01 14:52:30 开始打印,排队:110,票券:2605011452203775135601,订单:2605011452200035997245,[2026-05-01 14:52:29支付宝支付10元]
2026-05-01 14:52:30>>>MQTT票号同步场景，创建空订单对象
2026-05-01 14:52:30>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-01 14:52:32 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605011452203775135601","queue_number":110,"trade_uid":"2605011452200035997245"}]}
2026-05-01 14:52:32 >>>故障排除日志:删除未同步下发订单成功2605011452200035997245
2026-05-01 14:52:32 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536875557]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-01 14:52:37 >>>回调事件[910,devices/D0519]
2026-05-01 14:52:37 >>>故障排除日志:上一MQTT订单号缓存列表为2605011452200035997245
2026-05-01 14:52:37 >>>故障排除日志:终端未同步成功订单列表
2026-05-01 14:52:37 开始打印,排队:111,票券:2605011452281939826301,订单:2605011452280017556482,[2026-05-01 14:52:36微信支付10元]
2026-05-01 14:52:37>>>MQTT票号同步场景，创建空订单对象
2026-05-01 14:52:37>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-01 14:52:39 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605011452281939826301","queue_number":111,"trade_uid":"2605011452280017556482"}]}
2026-05-01 14:52:39 >>>故障排除日志:删除未同步下发订单成功2605011452280017556482
2026-05-01 14:52:39 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536875563]


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


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


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


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


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


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


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


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


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


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


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


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


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


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


===15:40:24===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-01 15:39:31 >>>回调事件[910,devices/D0519]
2026-05-01 15:39:31 >>>故障排除日志:上一MQTT订单号缓存列表为2605011537430084501329
2026-05-01 15:39:31 >>>故障排除日志:终端未同步成功订单列表
2026-05-01 15:39:31 开始打印,排队:126,票券:2605011539234346714201,订单:2605011539230039990456,[2026-05-01 15:39:30微信支付10元]
2026-05-01 15:39:32>>>MQTT票号同步场景，创建空订单对象
2026-05-01 15:39:32>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-01 15:39:34 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605011539234346714201","queue_number":126,"trade_uid":"2605011539230039990456"}]}
2026-05-01 15:39:34 >>>故障排除日志:删除未同步下发订单成功2605011539230039990456
2026-05-01 15:39:34 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536876105]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-01 15:39:53 >>>回调事件[910,devices/D0519]
2026-05-01 15:39:53 >>>故障排除日志:上一MQTT订单号缓存列表为2605011539230039990456
2026-05-01 15:39:53 >>>故障排除日志:终端未同步成功订单列表
2026-05-01 15:39:53 开始打印,排队:127,票券:2605011539432243059301,订单:2605011539430020667994,[2026-05-01 15:39:52微信支付10元]
2026-05-01 15:39:53>>>MQTT票号同步场景，创建空订单对象
2026-05-01 15:39:53>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-01 15:39:55 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605011539432243059301","queue_number":127,"trade_uid":"2605011539430020667994"}]}
2026-05-01 15:39:55 >>>故障排除日志:删除未同步下发订单成功2605011539430020667994
2026-05-01 15:39:55 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536876117]


===15:43:25===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-01 15:42:46 >>>回调事件[910,devices/D0519]
2026-05-01 15:42:46 >>>故障排除日志:上一MQTT订单号缓存列表为2605011539430020667994
2026-05-01 15:42:46 >>>故障排除日志:终端未同步成功订单列表
2026-05-01 15:42:46 开始打印,排队:128,票券:2605011542396950028901,订单:2605011542390067524781,[2026-05-01 15:42:45微信支付10元]
2026-05-01 15:42:46>>>MQTT票号同步场景，创建空订单对象
2026-05-01 15:42:46>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-01 15:42:48 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605011542396950028901","queue_number":128,"trade_uid":"2605011542390067524781"}]}
2026-05-01 15:42:48 >>>故障排除日志:删除未同步下发订单成功2605011542390067524781
2026-05-01 15:42:48 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536876147]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-01 15:43:09 >>>回调事件[910,devices/D0519]
2026-05-01 15:43:09 >>>故障排除日志:上一MQTT订单号缓存列表为2605011542390067524781
2026-05-01 15:43:09 >>>故障排除日志:终端未同步成功订单列表
2026-05-01 15:43:09 开始打印,排队:129,票券:2605011543009388178501,订单:2605011543000091966428,[2026-05-01 15:43:09微信支付10元]
2026-05-01 15:43:10>>>MQTT票号同步场景，创建空订单对象
2026-05-01 15:43:10>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-01 15:43:12 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605011543009388178501","queue_number":129,"trade_uid":"2605011543000091966428"}]}
2026-05-01 15:43:12 >>>故障排除日志:删除未同步下发订单成功2605011543000091966428
2026-05-01 15:43:12 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536876161]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-01 15:43:19 >>>回调事件[910,devices/D0519]
2026-05-01 15:43:19 >>>故障排除日志:上一MQTT订单号缓存列表为2605011543000091966428
2026-05-01 15:43:19 >>>故障排除日志:终端未同步成功订单列表
2026-05-01 15:43:19 开始打印,排队:130,票券:2605011543094424177201,订单:2605011543090042312462,[2026-05-01 15:43:18微信支付10元]
2026-05-01 15:43:19>>>MQTT票号同步场景，创建空订单对象
2026-05-01 15:43:19>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-01 15:43:21 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605011543094424177201","queue_number":130,"trade_uid":"2605011543090042312462"}]}
2026-05-01 15:43:21 >>>故障排除日志:删除未同步下发订单成功2605011543090042312462
2026-05-01 15:43:21 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536876167]


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


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


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


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


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


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


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


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


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


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


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


===16:33:27===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-01 16:32:33 >>>回调事件[910,devices/D0519]
2026-05-01 16:32:33 >>>故障排除日志:上一MQTT订单号缓存列表为2605011632090012815721
2026-05-01 16:32:33 >>>故障排除日志:终端未同步成功订单列表
2026-05-01 16:32:33 开始打印,排队:144,票券:2605011632275373758301,订单:2605011632270051787025,[2026-05-01 16:32:32支付宝支付10元]
2026-05-01 16:32:33>>>MQTT票号同步场景，创建空订单对象
2026-05-01 16:32:33>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-01 16:32:35 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605011632275373758301","queue_number":144,"trade_uid":"2605011632270051787025"}]}
2026-05-01 16:32:35 >>>故障排除日志:删除未同步下发订单成功2605011632270051787025
2026-05-01 16:32:35 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536876704]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-01 16:32:48 >>>回调事件[910,devices/D0519]
2026-05-01 16:32:48 >>>故障排除日志:上一MQTT订单号缓存列表为2605011632270051787025
2026-05-01 16:32:48 >>>故障排除日志:终端未同步成功订单列表
2026-05-01 16:32:48 开始打印,排队:145,票券:2605011632364209875701,订单:2605011632360039761728,[2026-05-01 16:32:47支付宝支付10元]
2026-05-01 16:32:48 开始打印,排队:146,票券:2605011632364210523502,订单:2605011632360039761728,[2026-05-01 16:32:47支付宝支付10元]
2026-05-01 16:32:48>>>MQTT票号同步场景，创建空订单对象
2026-05-01 16:32:48>>>合并MQTT票号列表到订单同步请求,共2张票
2026-05-01 16:32:52 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605011632364209875701","queue_number":145,"trade_uid":"2605011632360039761728"},{"ticket_no":"2605011632364210523502","queue_number":146,"trade_uid":"2605011632360039761728"}]}
2026-05-01 16:32:52 >>>故障排除日志:删除未同步下发订单成功2605011632360039761728
2026-05-01 16:32:52 >>>故障排除日志:删除未同步下发订单成功2605011632360039761728
2026-05-01 16:32:52 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536876715]


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


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


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


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


===16:59:30===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-01 16:59:27 >>>回调事件[910,devices/D0519]
2026-05-01 16:59:27 >>>故障排除日志:上一MQTT订单号缓存列表为2605011657500008997158
2026-05-01 16:59:27 >>>故障排除日志:终端未同步成功订单列表
2026-05-01 16:59:27 开始打印,排队:152,票券:2605011659179642852601,订单:2605011659170094505729,[2026-05-01 16:59:25微信支付10元]
2026-05-01 16:59:27>>>MQTT票号同步场景，创建空订单对象
2026-05-01 16:59:27>>>合并MQTT票号列表到订单同步请求,共1张票


===17:00:30===
2026-05-01 16:59:29 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605011659179642852601","queue_number":152,"trade_uid":"2605011659170094505729"}]}
2026-05-01 16:59:29 >>>故障排除日志:删除未同步下发订单成功2605011659170094505729
2026-05-01 16:59:29 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877000]


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


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


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


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


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


===17:26:32===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-01 17:25:53 >>>回调事件[910,devices/D0519]
2026-05-01 17:25:53 >>>故障排除日志:上一MQTT订单号缓存列表为2605011716420063024878
2026-05-01 17:25:53 >>>故障排除日志:终端未同步成功订单列表
2026-05-01 17:25:53 开始打印,排队:158,票券:2605011725442811781601,订单:2605011725440026219376,[2026-05-01 17:25:52微信支付10元]
2026-05-01 17:25:53>>>MQTT票号同步场景，创建空订单对象
2026-05-01 17:25:53>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-01 17:25:55 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605011725442811781601","queue_number":158,"trade_uid":"2605011725440026219376"}]}
2026-05-01 17:25:55 >>>故障排除日志:删除未同步下发订单成功2605011725440026219376
2026-05-01 17:25:55 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877288]
2026-05-01 17:26:12>>>cash read=0A
2026-05-01 17:26:13>>>cash read=3E


===17:29:32===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-01 17:28:41 >>>回调事件[910,devices/D0519]
2026-05-01 17:28:41 >>>故障排除日志:上一MQTT订单号缓存列表为2605011725440026219376
2026-05-01 17:28:41 >>>故障排除日志:终端未同步成功订单列表
2026-05-01 17:28:41 开始打印,排队:159,票券:2605011728349423007501,订单:2605011728340092481047,[2026-05-01 17:28:40支付宝支付10元]
2026-05-01 17:28:41>>>MQTT票号同步场景，创建空订单对象
2026-05-01 17:28:41>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-01 17:28:43 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605011728349423007501","queue_number":159,"trade_uid":"2605011728340092481047"}]}
2026-05-01 17:28:43 >>>故障排除日志:删除未同步下发订单成功2605011728340092481047
2026-05-01 17:28:43 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877317]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-01 17:29:01 >>>回调事件[910,devices/D0519]
2026-05-01 17:29:01 >>>故障排除日志:上一MQTT订单号缓存列表为2605011728340092481047
2026-05-01 17:29:01 >>>故障排除日志:终端未同步成功订单列表
2026-05-01 17:29:01 开始打印,排队:160,票券:2605011728518067623701,订单:2605011728510078869657,[2026-05-01 17:29:00微信支付10元]
2026-05-01 17:29:01>>>MQTT票号同步场景，创建空订单对象
2026-05-01 17:29:01>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-01 17:29:03 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605011728518067623701","queue_number":160,"trade_uid":"2605011728510078869657"}]}
2026-05-01 17:29:03 >>>故障排除日志:删除未同步下发订单成功2605011728510078869657
2026-05-01 17:29:03 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877331]


===17:30:33===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-01 17:29:40 >>>回调事件[910,devices/D0519]
2026-05-01 17:29:40 >>>故障排除日志:上一MQTT订单号缓存列表为2605011728510078869657
2026-05-01 17:29:40 >>>故障排除日志:终端未同步成功订单列表
2026-05-01 17:29:40 开始打印,排队:161,票券:2605011729337544497101,订单:2605011729330073547786,[2026-05-01 17:29:39微信支付10元]
2026-05-01 17:29:40>>>MQTT票号同步场景，创建空订单对象
2026-05-01 17:29:40>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-01 17:29:42 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605011729337544497101","queue_number":161,"trade_uid":"2605011729330073547786"}]}
2026-05-01 17:29:42 >>>故障排除日志:删除未同步下发订单成功2605011729330073547786
2026-05-01 17:29:42 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877340]
2026-05-01 17:29:47>>>cash read=00
2026-05-01 17:29:48>>>cash read=29
2026-05-01 17:29:48 >>>回调事件130,cash_status,20029,退钞中
2026-05-01 17:29:48>>>cash read=2F29
2026-05-01 17:29:50>>>cash read=3E
2026-05-01 17:29:58>>>cash read=29
2026-05-01 17:29:58 >>>回调事件130,cash_status,20029,退钞中
2026-05-01 17:29:59>>>cash read=01
2026-05-01 17:30:02>>>cash read=3E
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-01 17:30:04 >>>回调事件[910,devices/D0519]
2026-05-01 17:30:04 >>>故障排除日志:上一MQTT订单号缓存列表为2605011729330073547786
2026-05-01 17:30:04 >>>故障排除日志:终端未同步成功订单列表
2026-05-01 17:30:04 开始打印,排队:162,票券:2605011729571022144901,订单:2605011729570008260589,[2026-05-01 17:30:02微信支付10元]
2026-05-01 17:30:04 开始打印,排队:163,票券:2605011729571022841802,订单:2605011729570008260589,[2026-05-01 17:30:02微信支付10元]
2026-05-01 17:30:04>>>MQTT票号同步场景，创建空订单对象
2026-05-01 17:30:04>>>合并MQTT票号列表到订单同步请求,共2张票
2026-05-01 17:30:07>>>cash read=2F29
2026-05-01 17:30:08 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605011729571022144901","queue_number":162,"trade_uid":"2605011729570008260589"},{"ticket_no":"2605011729571022841802","queue_number":163,"trade_uid":"2605011729570008260589"}]}
2026-05-01 17:30:08 >>>故障排除日志:删除未同步下发订单成功2605011729570008260589
2026-05-01 17:30:08 >>>故障排除日志:删除未同步下发订单成功2605011729570008260589
2026-05-01 17:30:08 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877354]
2026-05-01 17:30:09>>>cash read=01
2026-05-01 17:30:12>>>cash read=2F
2026-05-01 17:30:13>>>cash read=00
2026-05-01 17:30:14>>>cash read=2F29
2026-05-01 17:30:16>>>cash read=3E
2026-05-01 17:30:18>>>cash read=29
2026-05-01 17:30:18 >>>回调事件130,cash_status,20029,退钞中
2026-05-01 17:30:19>>>cash read=3E
2026-05-01 17:30:28>>>cash read=00
2026-05-01 17:30:30>>>cash read=2F29
2026-05-01 17:30:32>>>cash read=3E


===17:31:33===
2026-05-01 17:30:35>>>cash read=29
2026-05-01 17:30:35 >>>回调事件130,cash_status,20029,退钞中
2026-05-01 17:30:36>>>cash read=3E
2026-05-01 17:30:40>>>cash read=29
2026-05-01 17:30:40 >>>回调事件130,cash_status,20029,退钞中
2026-05-01 17:30:41>>>cash read=01
2026-05-01 17:30:42>>>cash read=3E
2026-05-01 17:30:45>>>cash read=00
2026-05-01 17:30:47>>>cash read=29
2026-05-01 17:30:47 >>>回调事件130,cash_status,20029,退钞中
2026-05-01 17:30:47>>>cash read=2F29
2026-05-01 17:30:48>>>cash read=3E


===17:41:33===
2026-05-01 17:40:57>>>cash read=00
2026-05-01 17:40:58>>>cash read=2F29
2026-05-01 17:40:59>>>cash read=3E
2026-05-01 17:41:00>>>cash read=00
2026-05-01 17:41:02>>>cash read=29
2026-05-01 17:41:02 >>>回调事件130,cash_status,20029,退钞中
2026-05-01 17:41:02>>>cash read=2F29
2026-05-01 17:41:04>>>cash read=3E
2026-05-01 17:41:07>>>cash read=00
2026-05-01 17:41:08>>>cash read=29
2026-05-01 17:41:08 >>>回调事件130,cash_status,20029,退钞中
2026-05-01 17:41:09>>>cash read=2F29
2026-05-01 17:41:10>>>cash read=3E
2026-05-01 17:41:11>>>cash read=00
2026-05-01 17:41:12>>>cash read=29
2026-05-01 17:41:12 >>>回调事件130,cash_status,20029,退钞中
2026-05-01 17:41:13>>>cash read=2F29
2026-05-01 17:41:14>>>cash read=3E
2026-05-01 17:41:23>>>cash read=00
2026-05-01 17:41:23>>>cash read=818F42
2026-05-01 17:41:23>>>cash write=02
2026-05-01 17:41:23 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-05-01 17:41:23>>>cash read=10
2026-05-01 17:41:24 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-01 17:41:24 当前产品价格10元，投币10元，打印小票中...
2026-05-01 17:41:24 >>>开始打印,排队号为164,订单号为2605011741240040519470
2026-05-01 17:41:24>>>订单2605011741240040519470写入成功,剩余空间为1679000,占用RAM为636.68359375
删除未同步订单2605011741240040519470
2026-05-01 17:41:26>>>订单2605011741240040519470删除成功,剩余空间为1680000,占用RAM为645.37890625
检测订单目录中>>>
无未同步订单>>>
2026-05-01 17:41:26 >>>当前Ram内存为616.3896484375
定时检测未同步订单启用[checkOrderNum=536877465]
2026-05-01 17:41:27>>>cash write=0C
2026-05-01 17:41:27>>>cash read=3E


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


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


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


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


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


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


===18:19:35===
2026-05-01 18:19:05>>>cash read=0A
2026-05-01 18:19:06>>>cash read=3E


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


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


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


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


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


===18:58:36===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-01 18:57:49 >>>回调事件[910,devices/D0519]
2026-05-01 18:57:49 >>>故障排除日志:上一MQTT订单号缓存列表为2605011852570058682589
2026-05-01 18:57:49 >>>故障排除日志:终端未同步成功订单列表
2026-05-01 18:57:49 开始打印,排队:176,票券:2605011857415974522401,订单:2605011857410057960817,[2026-05-01 18:57:48微信支付10元]
2026-05-01 18:57:49>>>MQTT票号同步场景，创建空订单对象
2026-05-01 18:57:49>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-01 18:57:51 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605011857415974522401","queue_number":176,"trade_uid":"2605011857410057960817"}]}
2026-05-01 18:57:51 >>>故障排除日志:删除未同步下发订单成功2605011857410057960817
2026-05-01 18:57:51 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878247]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-01 18:58:26 >>>回调事件[910,devices/D0519]
2026-05-01 18:58:26 >>>故障排除日志:上一MQTT订单号缓存列表为2605011857410057960817
2026-05-01 18:58:26 >>>故障排除日志:终端未同步成功订单列表
2026-05-01 18:58:26 开始打印,排队:177,票券:2605011858192903964501,订单:2605011858190026790767,[2026-05-01 18:58:25微信支付10元]
2026-05-01 18:58:26 开始打印,排队:178,票券:2605011858192904454302,订单:2605011858190026790767,[2026-05-01 18:58:25微信支付10元]
2026-05-01 18:58:26>>>MQTT票号同步场景，创建空订单对象
2026-05-01 18:58:26>>>合并MQTT票号列表到订单同步请求,共2张票
2026-05-01 18:58:30 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605011858192903964501","queue_number":177,"trade_uid":"2605011858190026790767"},{"ticket_no":"2605011858192904454302","queue_number":178,"trade_uid":"2605011858190026790767"}]}
2026-05-01 18:58:30 >>>故障排除日志:删除未同步下发订单成功2605011858190026790767
2026-05-01 18:58:30 >>>故障排除日志:删除未同步下发订单成功2605011858190026790767
2026-05-01 18:58:30 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878261]


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


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


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


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


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


===19:17:38===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-01 19:17:08 >>>回调事件[910,devices/D0519]
2026-05-01 19:17:08 >>>故障排除日志:上一MQTT订单号缓存列表为2605011911300072081926
2026-05-01 19:17:08 >>>故障排除日志:终端未同步成功订单列表
2026-05-01 19:17:08 开始打印,排队:185,票券:2605011917006974385801,订单:2605011917000067776379,[2026-05-01 19:17:07微信支付10元]
2026-05-01 19:17:08>>>MQTT票号同步场景，创建空订单对象
2026-05-01 19:17:08>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-01 19:17:10 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605011917006974385801","queue_number":185,"trade_uid":"2605011917000067776379"}]}
2026-05-01 19:17:10 >>>故障排除日志:删除未同步下发订单成功2605011917000067776379
2026-05-01 19:17:10 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878479]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-01 19:17:34 >>>回调事件[910,devices/D0519]
2026-05-01 19:17:34 >>>故障排除日志:上一MQTT订单号缓存列表为2605011917000067776379
2026-05-01 19:17:34 >>>故障排除日志:终端未同步成功订单列表
2026-05-01 19:17:34 开始打印,排队:186,票券:2605011917227130352401,订单:2605011917220069573717,[2026-05-01 19:17:32微信支付10元]
2026-05-01 19:17:34>>>MQTT票号同步场景，创建空订单对象
2026-05-01 19:17:34>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-01 19:17:36 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605011917227130352401","queue_number":186,"trade_uid":"2605011917220069573717"}]}
2026-05-01 19:17:36 >>>故障排除日志:删除未同步下发订单成功2605011917220069573717
2026-05-01 19:17:36 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878486]


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


===19:20:38===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-01 19:20:03 >>>回调事件[910,devices/D0519]
2026-05-01 19:20:03 >>>故障排除日志:上一MQTT订单号缓存列表为2605011918540058006823
2026-05-01 19:20:03 >>>故障排除日志:终端未同步成功订单列表
2026-05-01 19:20:03 开始打印,排队:188,票券:2605011919541663347501,订单:2605011919540014711662,[2026-05-01 19:20:02微信支付10元]
2026-05-01 19:20:03 开始打印,排队:189,票券:2605011919541663752402,订单:2605011919540014711662,[2026-05-01 19:20:02微信支付10元]
2026-05-01 19:20:04>>>MQTT票号同步场景，创建空订单对象
2026-05-01 19:20:04>>>合并MQTT票号列表到订单同步请求,共2张票
2026-05-01 19:20:07 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605011919541663347501","queue_number":188,"trade_uid":"2605011919540014711662"},{"ticket_no":"2605011919541663752402","queue_number":189,"trade_uid":"2605011919540014711662"}]}
2026-05-01 19:20:07 >>>故障排除日志:删除未同步下发订单成功2605011919540014711662
2026-05-01 19:20:07 >>>故障排除日志:删除未同步下发订单成功2605011919540014711662
2026-05-01 19:20:07 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878528]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-01 19:20:29 >>>回调事件[910,devices/D0519]
2026-05-01 19:20:29 >>>故障排除日志:上一MQTT订单号缓存列表为2605011919540014711662|2605011919540014711662
2026-05-01 19:20:29 >>>故障排除日志:终端未同步成功订单列表
2026-05-01 19:20:29 开始打印,排队:190,票券:2605011920215346717601,订单:2605011920210051430496,[2026-05-01 19:20:28微信支付10元]
2026-05-01 19:20:29>>>MQTT票号同步场景，创建空订单对象
2026-05-01 19:20:29>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-01 19:20:31 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605011920215346717601","queue_number":190,"trade_uid":"2605011920210051430496"}]}
2026-05-01 19:20:31 >>>故障排除日志:删除未同步下发订单成功2605011920210051430496
2026-05-01 19:20:31 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878535]


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


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


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


===19:27:41===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-01 19:27:38 >>>回调事件[910,devices/D0519]
2026-05-01 19:27:38 >>>故障排除日志:上一MQTT订单号缓存列表为2605011925400044805243
2026-05-01 19:27:38 >>>故障排除日志:终端未同步成功订单列表
2026-05-01 19:27:38 开始打印,排队:194,票券:2605011927314857752501,订单:2605011927310046167563,[2026-05-01 19:27:37微信支付10元]
2026-05-01 19:27:38>>>MQTT票号同步场景，创建空订单对象
2026-05-01 19:27:38>>>合并MQTT票号列表到订单同步请求,共1张票


===19:31:42===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-01 19:31:39 >>>回调事件[910,devices/D0519]
2026-05-01 19:31:39 >>>故障排除日志:上一MQTT订单号缓存列表为2605011927310046167563
2026-05-01 19:31:39 >>>故障排除日志:终端未同步成功订单列表
2026-05-01 19:31:39 开始打印,排队:195,票券:2605011931292206836301,订单:2605011931290020292923,[2026-05-01 19:31:38微信支付10元]
2026-05-01 19:31:39>>>MQTT票号同步场景，创建空订单对象
2026-05-01 19:31:39>>>合并MQTT票号列表到订单同步请求,共1张票


===19:32:42===
2026-05-01 19:31:41 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605011931292206836301","queue_number":195,"trade_uid":"2605011931290020292923"}]}
2026-05-01 19:31:41 >>>故障排除日志:删除未同步下发订单成功2605011931290020292923
2026-05-01 19:31:41 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878679]


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


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


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


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


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


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


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


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


===19:53:44===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-01 19:52:58 >>>回调事件[910,devices/D0519]
2026-05-01 19:52:59 >>>故障排除日志:上一MQTT订单号缓存列表为2605011947350067693659
2026-05-01 19:52:59 >>>故障排除日志:终端未同步成功订单列表
2026-05-01 19:52:59 开始打印,排队:204,票券:2605011952523655301701,订单:2605011952520034590043,[2026-05-01 19:52:57微信支付10元]
2026-05-01 19:52:59>>>MQTT票号同步场景，创建空订单对象
2026-05-01 19:52:59>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-01 19:53:01 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605011952523655301701","queue_number":204,"trade_uid":"2605011952520034590043"}]}
2026-05-01 19:53:01 >>>故障排除日志:删除未同步下发订单成功2605011952520034590043
2026-05-01 19:53:01 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878946]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-01 19:53:31 >>>回调事件[910,devices/D0519]
2026-05-01 19:53:31 >>>故障排除日志:上一MQTT订单号缓存列表为2605011952520034590043
2026-05-01 19:53:31 >>>故障排除日志:终端未同步成功订单列表
2026-05-01 19:53:31 开始打印,排队:205,票券:2605011953265877587801,订单:2605011953260056926416,[2026-05-01 19:53:30支付宝支付10元]
2026-05-01 19:53:31>>>MQTT票号同步场景，创建空订单对象
2026-05-01 19:53:31>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-01 19:53:33 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605011953265877587801","queue_number":205,"trade_uid":"2605011953260056926416"}]}
2026-05-01 19:53:33 >>>故障排除日志:删除未同步下发订单成功2605011953260056926416
2026-05-01 19:53:33 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878954]


===19:56:46===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-01 19:56:43 >>>回调事件[910,devices/D0519]
2026-05-01 19:56:43 >>>故障排除日志:上一MQTT订单号缓存列表为2605011953260056926416
2026-05-01 19:56:43 >>>故障排除日志:终端未同步成功订单列表
2026-05-01 19:56:43 开始打印,排队:206,票券:2605011956355000691401,订单:2605011956350047802246,[2026-05-01 19:56:43微信支付10元]
2026-05-01 19:56:43>>>MQTT票号同步场景，创建空订单对象
2026-05-01 19:56:43>>>合并MQTT票号列表到订单同步请求,共1张票


===19:57:46===
2026-05-01 19:56:45 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605011956355000691401","queue_number":206,"trade_uid":"2605011956350047802246"}]}
2026-05-01 19:56:45 >>>故障排除日志:删除未同步下发订单成功2605011956350047802246
2026-05-01 19:56:45 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878992]


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


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


===20:11:46===
2026-05-01 20:10:47>>>cash read=00
2026-05-01 20:10:48>>>cash read=2F29
2026-05-01 20:10:50>>>cash read=3E
2026-05-01 20:10:51>>>cash read=29
2026-05-01 20:10:51 >>>回调事件130,cash_status,20029,退钞中
2026-05-01 20:10:51>>>cash read=2F29
2026-05-01 20:10:53>>>cash read=00
2026-05-01 20:10:54>>>cash read=818F42
2026-05-01 20:10:54>>>cash write=02
2026-05-01 20:10:54 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-05-01 20:10:55>>>cash read=10
2026-05-01 20:10:55 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-01 20:10:55 当前产品价格10元，投币10元，打印小票中...
2026-05-01 20:10:55 >>>开始打印,排队号为209,订单号为2605012010550040519675
2026-05-01 20:10:55>>>订单2605012010550040519675写入成功,剩余空间为1679500,占用RAM为634.13671875
删除未同步订单2605012010550040519675
2026-05-01 20:10:57>>>订单2605012010550040519675删除成功,剩余空间为1680500,占用RAM为643.953125
检测订单目录中>>>
无未同步订单>>>
2026-05-01 20:10:57 >>>当前Ram内存为614.9052734375
定时检测未同步订单启用[checkOrderNum=536879148]
2026-05-01 20:10:58>>>cash write=0C
2026-05-01 20:10:58>>>cash read=3E


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


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


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


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


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


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


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


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


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


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


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


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


===20:47:49===
2026-05-01 20:46:50>>>cash read=0A
2026-05-01 20:46:51>>>cash read=3E


===20:51:50===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-01 20:51:47 >>>回调事件[910,devices/D0519]
2026-05-01 20:51:48 >>>故障排除日志:上一MQTT订单号缓存列表为2605012045280039866958
2026-05-01 20:51:48 >>>故障排除日志:终端未同步成功订单列表
2026-05-01 20:51:48 开始打印,排队:222,票券:2605012051384154817201,订单:2605012051380038487297,[2026-05-01 20:51:46支付宝支付10元]
2026-05-01 20:51:48>>>MQTT票号同步场景，创建空订单对象
2026-05-01 20:51:48>>>合并MQTT票号列表到订单同步请求,共1张票


===20:52:50===
2026-05-01 20:51:49 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605012051384154817201","queue_number":222,"trade_uid":"2605012051380038487297"}]}
2026-05-01 20:51:49 >>>故障排除日志:删除未同步下发订单成功2605012051380038487297
2026-05-01 20:51:50 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536879619]


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


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


===21:00:51===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-01 21:00:11 >>>回调事件[910,devices/D0519]
2026-05-01 21:00:11 >>>故障排除日志:上一MQTT订单号缓存列表为2605012059190084977178
2026-05-01 21:00:11 >>>故障排除日志:终端未同步成功订单列表
2026-05-01 21:00:11 开始打印,排队:225,票券:2605012100001787852801,订单:2605012100000015244524,[2026-05-01 21:00:10微信支付10元]
2026-05-01 21:00:11>>>MQTT票号同步场景，创建空订单对象
2026-05-01 21:00:11>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-01 21:00:13 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605012100001787852801","queue_number":225,"trade_uid":"2605012100000015244524"}]}
2026-05-01 21:00:13 >>>故障排除日志:删除未同步下发订单成功2605012100000015244524
2026-05-01 21:00:13 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536879723]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-01 21:00:38 >>>回调事件[910,devices/D0519]
2026-05-01 21:00:38 >>>故障排除日志:上一MQTT订单号缓存列表为2605012100000015244524
2026-05-01 21:00:38 >>>故障排除日志:终端未同步成功订单列表
2026-05-01 21:00:38 开始打印,排队:226,票券:2605012100293944863101,订单:2605012100290037352146,[2026-05-01 21:00:37微信支付10元]
2026-05-01 21:00:38>>>MQTT票号同步场景，创建空订单对象
2026-05-01 21:00:38>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-01 21:00:40 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605012100293944863101","queue_number":226,"trade_uid":"2605012100290037352146"}]}
2026-05-01 21:00:40 >>>故障排除日志:删除未同步下发订单成功2605012100290037352146
2026-05-01 21:00:40 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536879730]


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


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


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