TLClient_JSSCOM_LuatOS-Air_V4010_RDA8910_RFTTS_0xe0000,2.8.7,869701072495867,28464262078471,
poweron reason:0

===08:02:57===
上一时间戳为1777766853
隔日重置时间戳true
隔日清空未同步下发列表true
当前排队号为1,音量为5
初始化产品信息:[{"time_limit_date":"","ticket_category":"0","expiry_date":1,"product_detail":"","time_limit_status":"0","begin_minute":"00","product_uid":"16746837930005455541","use_timer":1,"old_price":"10","end_hour":"23","sale_price":"10","end_minute":"59","begin_hour":"00","sale_status":1,"product_name":"男女快剪"}]
打印门店标题设置为十元快剪技术精湛
打印门店凭条广告设置为请按排队号顺序理发
是否打印二维码设置为1
是否打印紧凑设置为3
当前号显示模式设置为1
当前卡项核销权限设置为0
session_id:cb0c8****f3678
纸币器设置接收纸币范围为36
欢迎使用天羚自助售票系统[2.8.7]
定时检测未同步订单启用[checkOrderNum=536870976]
2026-05-04 08:01:56>>>cash write=30
2026-05-04 08:01:56>>>cash write=02
2026-05-04 08:01:56>>>cash write=3E
2026-05-04 08:01:56>>>cash read=808F808F808F
系统时间初始化成功，时间为2026548156
2026-05-04 08:01:57>>>cash write=02
2026-05-04 08:01:58 >>>剩余flash空间=1680000,占用RAM为650.3935546875
2026-05-04 08:01:58 >>>回调事件:910,subscribe,10000,连接服务器成功

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

2026-05-04 08:02:00>>>cash write=0C
2026-05-04 08:02:00>>>cash read=3E
流量卡还有56天过期
2026-05-04 08:02:06 >>>当前Ram内存为638.349609375
2026-05-04 08:02:45>>>cash read=00
2026-05-04 08:02:46>>>cash read=818F42
2026-05-04 08:02:46>>>cash write=02
2026-05-04 08:02:46 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-05-04 08:02:46>>>cash read=10
2026-05-04 08:02:46 >>>回调事件130,10,10023,finish Money=10,进钞完成
当日首次设置时间戳true为1777852966
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-04 08:02:46 当前产品价格10元，投币10元，打印小票中...
2026-05-04 08:02:46 >>>开始打印,排队号为1,订单号为2605040802460030509724
2026-05-04 08:02:47>>>订单2605040802460030509724写入成功,剩余空间为1678000,占用RAM为643.7841796875
删除未同步订单2605040802460030509724
2026-05-04 08:02:49>>>订单2605040802460030509724删除成功,剩余空间为1679000,占用RAM为646.8037109375
检测订单目录中>>>
无未同步订单>>>
2026-05-04 08:02:49 >>>当前Ram内存为616.2978515625
定时检测未同步订单启用[checkOrderNum=536870997]
2026-05-04 08:02:50>>>cash write=0C
2026-05-04 08:02:50>>>cash read=3E


===08:06:57===
2026-05-04 08:06:38>>>cash read=00
2026-05-04 08:06:39>>>cash read=29
2026-05-04 08:06:39 >>>回调事件130,cash_status,20029,退钞中
2026-05-04 08:06:39>>>cash read=2F29
2026-05-04 08:06:40>>>cash read=3E


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


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


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


===08:13:58===
2026-05-04 08:13:37>>>cash read=00
2026-05-04 08:13:38>>>cash read=2F29
2026-05-04 08:13:40>>>cash read=3E
2026-05-04 08:13:41>>>cash read=00
2026-05-04 08:13:42>>>cash read=29
2026-05-04 08:13:42 >>>回调事件130,cash_status,20029,退钞中
2026-05-04 08:13:43>>>cash read=2F29
2026-05-04 08:13:44>>>cash read=3E
2026-05-04 08:13:53>>>cash read=00
2026-05-04 08:13:54>>>cash read=818F42
2026-05-04 08:13:54>>>cash write=02
2026-05-04 08:13:54 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-05-04 08:13:55>>>cash read=10
2026-05-04 08:13:55 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-04 08:13:55 当前产品价格10元，投币10元，打印小票中...
2026-05-04 08:13:55 >>>开始打印,排队号为5,订单号为2605040813550030509646
2026-05-04 08:13:55>>>订单2605040813550030509646写入成功,剩余空间为1679500,占用RAM为635.0048828125


===08:14:58===
删除未同步订单2605040813550030509646
2026-05-04 08:13:57>>>订单2605040813550030509646删除成功,剩余空间为1681500,占用RAM为648.974609375
检测订单目录中>>>
无未同步订单>>>
2026-05-04 08:13:57 >>>当前Ram内存为616.5703125
定时检测未同步订单启用[checkOrderNum=536871139]
2026-05-04 08:13:58>>>cash write=0C
2026-05-04 08:13:58>>>cash read=3E


===08:15:59===
2026-05-04 08:15:22>>>cash read=00
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-04 08:15:23 >>>回调事件[910,devices/A0509]
2026-05-04 08:15:23 >>>故障排除日志:上一MQTT订单号缓存列表为2605040809580092981443
2026-05-04 08:15:23 >>>故障排除日志:终端未同步成功订单列表
2026-05-04 08:15:23 开始打印,排队:6,票券:2605040815141903606801,订单:2605040815140016118981,[2026-05-04 08:15:22微信支付10元]
2026-05-04 08:15:23>>>MQTT票号同步场景，创建空订单对象
2026-05-04 08:15:23>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-04 08:15:24>>>cash read=818F42
2026-05-04 08:15:24>>>cash write=02
2026-05-04 08:15:24 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-05-04 08:15:25 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605040815141903606801","queue_number":6,"trade_uid":"2605040815140016118981"}]}
2026-05-04 08:15:25 >>>故障排除日志:删除未同步下发订单成功2605040815140016118981
2026-05-04 08:15:25 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536871159]
2026-05-04 08:15:25>>>cash read=10
2026-05-04 08:15:25 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-04 08:15:25 当前产品价格10元，投币10元，打印小票中...
2026-05-04 08:15:25 >>>开始打印,排队号为7,订单号为2605040815250030509314
2026-05-04 08:15:25>>>订单2605040815250030509314写入成功,剩余空间为1678500,占用RAM为640.3798828125
删除未同步订单2605040815250030509314
2026-05-04 08:15:27>>>订单2605040815250030509314删除成功,剩余空间为1679500,占用RAM为651.056640625
检测订单目录中>>>
无未同步订单>>>
2026-05-04 08:15:27 >>>当前Ram内存为620.26953125
定时检测未同步订单启用[checkOrderNum=536871166]
2026-05-04 08:15:29>>>cash write=0C
2026-05-04 08:15:29>>>cash read=3E


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


===08:30:59===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-04 08:30:32 >>>回调事件[910,devices/A0509]
2026-05-04 08:30:32 >>>故障排除日志:上一MQTT订单号缓存列表为2605040820010058544514
2026-05-04 08:30:32 >>>故障排除日志:终端未同步成功订单列表
2026-05-04 08:30:32 开始打印,排队:9,票券:2605040830228333321601,订单:2605040830220081588387,[2026-05-04 08:30:32微信支付10元]
2026-05-04 08:30:32>>>MQTT票号同步场景，创建空订单对象
2026-05-04 08:30:32>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-04 08:30:34 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605040830228333321601","queue_number":9,"trade_uid":"2605040830220081588387"}]}
2026-05-04 08:30:34 >>>故障排除日志:删除未同步下发订单成功2605040830220081588387
2026-05-04 08:30:34 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536871317]
2026-05-04 08:30:43>>>cash read=292F29
2026-05-04 08:30:43 >>>回调事件130,cash_status,20029,退钞中
2026-05-04 08:30:44>>>cash read=01
2026-05-04 08:30:46>>>cash read=2F
2026-05-04 08:30:47>>>cash read=3E
2026-05-04 08:30:49>>>cash read=00
2026-05-04 08:30:50>>>cash read=818F42
2026-05-04 08:30:50>>>cash write=02
2026-05-04 08:30:50 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-05-04 08:30:50>>>cash read=10
2026-05-04 08:30:50 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-04 08:30:50 当前产品价格10元，投币10元，打印小票中...
2026-05-04 08:30:50 >>>开始打印,排队号为10,订单号为2605040830500030509384
2026-05-04 08:30:51>>>订单2605040830500030509384写入成功,剩余空间为1678500,占用RAM为639.9296875
删除未同步订单2605040830500030509384
2026-05-04 08:30:53>>>订单2605040830500030509384删除成功,剩余空间为1679500,占用RAM为647.451171875
检测订单目录中>>>
无未同步订单>>>
2026-05-04 08:30:53 >>>当前Ram内存为617.5029296875
定时检测未同步订单启用[checkOrderNum=536871330]
2026-05-04 08:30:54>>>cash write=0C
2026-05-04 08:30:54>>>cash read=3E


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


===08:35:59===
2026-05-04 08:35:11>>>cash read=2F29
2026-05-04 08:35:13>>>cash read=01
2026-05-04 08:35:16>>>cash read=2F
2026-05-04 08:35:18>>>cash read=00
2026-05-04 08:35:18>>>cash read=818F42
2026-05-04 08:35:18>>>cash write=02
2026-05-04 08:35:18 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-05-04 08:35:18>>>cash read=10
2026-05-04 08:35:18 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-04 08:35:19 当前产品价格10元，投币10元，打印小票中...
2026-05-04 08:35:19 >>>开始打印,排队号为12,订单号为2605040835190030509005
2026-05-04 08:35:19>>>订单2605040835190030509005写入成功,剩余空间为1679500,占用RAM为634.888671875
删除未同步订单2605040835190030509005
2026-05-04 08:35:21>>>订单2605040835190030509005删除成功,剩余空间为1680500,占用RAM为644.9150390625
检测订单目录中>>>
无未同步订单>>>
2026-05-04 08:35:21 >>>当前Ram内存为616.9462890625
定时检测未同步订单启用[checkOrderNum=536871386]
2026-05-04 08:35:22>>>cash write=0C
2026-05-04 08:35:22>>>cash read=3E


===08:38:00===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-04 08:37:17 >>>回调事件[910,devices/A0509]
2026-05-04 08:37:17 >>>故障排除日志:上一MQTT订单号缓存列表为2605040832410004226835
2026-05-04 08:37:17 >>>故障排除日志:终端未同步成功订单列表
2026-05-04 08:37:17 开始打印,排队:13,票券:2605040837129487547901,订单:2605040837120092946263,[2026-05-04 08:37:17支付宝支付10元]
2026-05-04 08:37:17>>>MQTT票号同步场景，创建空订单对象
2026-05-04 08:37:17>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-04 08:37:19 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605040837129487547901","queue_number":13,"trade_uid":"2605040837120092946263"}]}
2026-05-04 08:37:19 >>>故障排除日志:删除未同步下发订单成功2605040837120092946263
2026-05-04 08:37:19 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536871412]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-04 08:37:31 >>>回调事件[910,devices/A0509]
2026-05-04 08:37:31 >>>故障排除日志:上一MQTT订单号缓存列表为2605040837120092946263
2026-05-04 08:37:31 >>>故障排除日志:终端未同步成功订单列表
2026-05-04 08:37:31 开始打印,排队:14,票券:2605040837265697243401,订单:2605040837260054873828,[2026-05-04 08:37:31支付宝支付10元]
2026-05-04 08:37:31>>>MQTT票号同步场景，创建空订单对象
2026-05-04 08:37:31>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-04 08:37:33 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605040837265697243401","queue_number":14,"trade_uid":"2605040837260054873828"}]}
2026-05-04 08:37:33 >>>故障排除日志:删除未同步下发订单成功2605040837260054873828
2026-05-04 08:37:34 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536871418]


===08:40:00===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-04 08:39:18 >>>回调事件[910,devices/A0509]
2026-05-04 08:39:18 >>>故障排除日志:上一MQTT订单号缓存列表为2605040837260054873828
2026-05-04 08:39:18 >>>故障排除日志:终端未同步成功订单列表
2026-05-04 08:39:18 开始打印,排队:15,票券:2605040839052218819501,订单:2605040839050020453135,[2026-05-04 08:39:17微信支付10元]
2026-05-04 08:39:18>>>MQTT票号同步场景，创建空订单对象
2026-05-04 08:39:18>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-04 08:39:20 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605040839052218819501","queue_number":15,"trade_uid":"2605040839050020453135"}]}
2026-05-04 08:39:20 >>>故障排除日志:删除未同步下发订单成功2605040839050020453135
2026-05-04 08:39:20 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536871444]
2026-05-04 08:39:51>>>cash read=00
2026-05-04 08:39:52>>>cash read=2F29
2026-05-04 08:39:53>>>cash read=01
2026-05-04 08:39:54>>>cash read=2F
2026-05-04 08:39:55>>>cash read=00
2026-05-04 08:39:56>>>cash read=818F42
2026-05-04 08:39:56>>>cash write=02
2026-05-04 08:39:56 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-05-04 08:39:57>>>cash read=10
2026-05-04 08:39:57 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-04 08:39:57 当前产品价格10元，投币10元，打印小票中...
2026-05-04 08:39:57 >>>开始打印,排队号为16,订单号为2605040839570030509004
2026-05-04 08:39:57>>>订单2605040839570030509004写入成功,剩余空间为1678500,占用RAM为642.10546875


===08:41:01===
2026-05-04 08:40:00>>>cash write=0C
2026-05-04 08:40:00>>>cash read=3E


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


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


===08:51:05===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-04 08:50:59 收到下发指令:排队号2>>>
2026-05-04 08:50:59 收到下发指令:叫号2>>>
2026-05-04 08:51:00 收到下发指令:排队号3>>>
2026-05-04 08:51:00 收到下发指令:叫号3>>>
2026-05-04 08:51:00 收到下发指令:排队号4>>>
2026-05-04 08:51:00 收到下发指令:叫号4>>>
2026-05-04 08:51:01 收到下发指令:排队号5>>>
2026-05-04 08:51:01 收到下发指令:叫号5>>>
2026-05-04 08:51:02 收到下发指令:排队号6>>>
2026-05-04 08:51:02 收到下发指令:叫号6>>>
2026-05-04 08:51:02 收到下发指令:排队号7>>>
2026-05-04 08:51:02 收到下发指令:叫号7>>>


===08:52:08===
2026-05-04 08:51:06 收到下发指令:排队号13>>>
2026-05-04 08:51:07 收到下发指令:叫号13>>>
2026-05-04 08:51:07 收到下发指令:排队号14>>>
2026-05-04 08:51:07 收到下发指令:叫号14>>>
2026-05-04 08:51:07 收到下发指令:排队号15>>>
2026-05-04 08:51:07 收到下发指令:叫号15>>>
2026-05-04 08:51:08 收到下发指令:排队号16>>>
2026-05-04 08:51:08 收到下发指令:叫号16>>>
2026-05-04 08:51:09 收到下发指令:排队号15>>>
2026-05-04 08:51:35 收到下发指令:排队号16>>>
2026-05-04 08:51:35 收到下发指令:叫号16>>>
2026-05-04 08:51:40 收到下发指令:排队号15>>>
2026-05-04 08:51:42 收到下发指令:排队号14>>>
2026-05-04 08:51:45 收到下发指令:排队号15>>>
2026-05-04 08:51:45 收到下发指令:叫号15>>>
2026-05-04 08:51:46 收到下发指令:排队号16>>>
2026-05-04 08:51:46 收到下发指令:叫号16>>>
2026-05-04 08:51:47 收到下发指令:排队号17>>>
2026-05-04 08:51:47 收到下发指令:叫号17>>>
2026-05-04 08:51:47 收到下发指令:排队号18>>>
2026-05-04 08:51:48 收到下发指令:叫号18>>>
2026-05-04 08:51:48 收到下发指令:排队号nil>>>


===08:55:08===
2026-05-04 08:54:10>>>cash read=29
2026-05-04 08:54:10 >>>回调事件130,cash_status,20029,退钞中
2026-05-04 08:54:11>>>cash read=3E
2026-05-04 08:54:15>>>cash read=29
2026-05-04 08:54:15 >>>回调事件130,cash_status,20029,退钞中
2026-05-04 08:54:16>>>cash read=01
2026-05-04 08:54:17>>>cash read=3E
2026-05-04 08:54:20>>>cash read=00
2026-05-04 08:54:22>>>cash read=29
2026-05-04 08:54:22 >>>回调事件130,cash_status,20029,退钞中
2026-05-04 08:54:22>>>cash read=2F29
2026-05-04 08:54:23>>>cash read=01
2026-05-04 08:54:24>>>cash read=2F
2026-05-04 08:54:25>>>cash read=3E


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


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


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


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


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


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


===09:19:10===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-04 09:18:36 >>>回调事件[910,devices/A0509]
2026-05-04 09:18:36 >>>故障排除日志:上一MQTT订单号缓存列表为2605040914550081075792
2026-05-04 09:18:36 >>>故障排除日志:终端未同步成功订单列表
2026-05-04 09:18:36 开始打印,排队:25,票券:2605040918257405547901,订单:2605040918250071807053,[2026-05-04 09:18:35微信支付10元]
2026-05-04 09:18:36>>>MQTT票号同步场景，创建空订单对象
2026-05-04 09:18:36>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-04 09:18:38 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605040918257405547901","queue_number":25,"trade_uid":"2605040918250071807053"}]}
2026-05-04 09:18:38 >>>故障排除日志:删除未同步下发订单成功2605040918250071807053
2026-05-04 09:18:38 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536871892]
2026-05-04 09:18:44>>>cash read=00
2026-05-04 09:18:44>>>cash read=818F42
2026-05-04 09:18:44>>>cash write=02
2026-05-04 09:18:44 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-05-04 09:18:45>>>cash read=10
2026-05-04 09:18:45 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-04 09:18:45 当前产品价格10元，投币10元，打印小票中...
2026-05-04 09:18:45 >>>开始打印,排队号为26,订单号为2605040918450030509739
2026-05-04 09:18:45>>>订单2605040918450030509739写入成功,剩余空间为1678500,占用RAM为641.5126953125
删除未同步订单2605040918450030509739
2026-05-04 09:18:47>>>订单2605040918450030509739删除成功,剩余空间为1679500,占用RAM为649.7763671875
检测订单目录中>>>
无未同步订单>>>
2026-05-04 09:18:47 >>>当前Ram内存为619.2060546875
定时检测未同步订单启用[checkOrderNum=536871899]
2026-05-04 09:18:49>>>cash write=0C
2026-05-04 09:18:49>>>cash read=3E


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


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


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


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


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


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


===09:33:11===
2026-05-04 09:32:56>>>cash read=00
2026-05-04 09:32:56>>>cash read=818F42
2026-05-04 09:32:56>>>cash write=02
2026-05-04 09:32:56 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-05-04 09:32:56>>>cash read=10
2026-05-04 09:32:56 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-04 09:32:56 当前产品价格10元，投币10元，打印小票中...
2026-05-04 09:32:56 >>>开始打印,排队号为33,订单号为2605040932560030509513
2026-05-04 09:32:57>>>订单2605040932560030509513写入成功,剩余空间为1679500,占用RAM为634.421875
2026-05-04 09:32:59>>>cash read=818F42
2026-05-04 09:32:59 >>>回调事件130,cash_status,10022,进钞中...read money=10
删除未同步订单2605040932560030509513
2026-05-04 09:32:59>>>订单2605040932560030509513删除成功,剩余空间为1680500,占用RAM为631.3681640625
检测订单目录中>>>
无未同步订单>>>
2026-05-04 09:32:59 >>>当前Ram内存为616.7431640625
定时检测未同步订单启用[checkOrderNum=536872089]
2026-05-04 09:32:59>>>cash read=10
2026-05-04 09:32:59 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-04 09:32:59 当前产品价格10元，投币10元，打印小票中...
2026-05-04 09:32:59 >>>开始打印,排队号为34,订单号为2605040932590030509161
2026-05-04 09:32:59>>>订单2605040932590030509161写入成功,剩余空间为1679000,占用RAM为638.5078125
删除未同步订单2605040932590030509161
2026-05-04 09:33:02>>>订单2605040932590030509161删除成功,剩余空间为1679500,占用RAM为649.4208984375
检测订单目录中>>>
无未同步订单>>>
2026-05-04 09:33:02 >>>当前Ram内存为618.5595703125
定时检测未同步订单启用[checkOrderNum=536872097]
2026-05-04 09:33:03>>>cash write=0C
2026-05-04 09:33:03>>>cash read=00
2026-05-04 09:33:03>>>cash read=818F42
2026-05-04 09:33:03>>>cash write=02
2026-05-04 09:33:03 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-05-04 09:33:04>>>cash read=10
2026-05-04 09:33:04 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-04 09:33:04 当前产品价格10元，投币10元，打印小票中...
2026-05-04 09:33:04 >>>开始打印,排队号为35,订单号为2605040933040030509471
2026-05-04 09:33:04>>>订单2605040933040030509471写入成功,剩余空间为1677500,占用RAM为647.1181640625
删除未同步订单2605040933040030509471
2026-05-04 09:33:06>>>订单2605040933040030509471删除成功,剩余空间为1678500,占用RAM为651.0126953125
检测订单目录中>>>
无未同步订单>>>
2026-05-04 09:33:07 >>>当前Ram内存为620.1025390625
定时检测未同步订单启用[checkOrderNum=536872105]
2026-05-04 09:33:07>>>cash read=818F42
2026-05-04 09:33:07 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-05-04 09:33:07>>>cash read=10
2026-05-04 09:33:08 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-04 09:33:08 当前产品价格10元，投币10元，打印小票中...
2026-05-04 09:33:08 >>>开始打印,排队号为36,订单号为2605040933080030509282
2026-05-04 09:33:08>>>订单2605040933080030509282写入成功,剩余空间为1677000,占用RAM为655.0830078125


===09:34:12===
2026-05-04 09:33:11>>>cash write=0C
2026-05-04 09:33:11>>>cash read=3E
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-04 09:33:39 收到下发指令:排队号19>>>
2026-05-04 09:33:39 收到下发指令:叫号19>>>
2026-05-04 09:33:40 收到下发指令:排队号19>>>
2026-05-04 09:33:40 收到下发指令:叫号19>>>
2026-05-04 09:33:41 收到下发指令:排队号19>>>
2026-05-04 09:33:41 收到下发指令:叫号19>>>
2026-05-04 09:33:42 收到下发指令:排队号19>>>
2026-05-04 09:33:42 收到下发指令:叫号19>>>
2026-05-04 09:33:45 收到下发指令:排队号19>>>
2026-05-04 09:33:45 收到下发指令:叫号19>>>
2026-05-04 09:33:48 收到下发指令:排队号19>>>
2026-05-04 09:33:48 收到下发指令:叫号19>>>
2026-05-04 09:33:54 收到下发指令:排队号19>>>
2026-05-04 09:33:54 收到下发指令:叫号19>>>
2026-05-04 09:33:56 收到下发指令:排队号19>>>
2026-05-04 09:33:56 收到下发指令:叫号19>>>
2026-05-04 09:34:01 收到下发指令:排队号19>>>
2026-05-04 09:34:01 收到下发指令:叫号19>>>
2026-05-04 09:34:05 收到下发指令:排队号19>>>
2026-05-04 09:34:05 收到下发指令:叫号19>>>
2026-05-04 09:34:10 收到下发指令:排队号20>>>
2026-05-04 09:34:10 收到下发指令:叫号20>>>


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


===09:40:16===
2026-05-04 09:39:12>>>cash read=00
2026-05-04 09:39:12>>>cash read=818F42
2026-05-04 09:39:12>>>cash write=02
2026-05-04 09:39:12 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-05-04 09:39:13>>>cash read=10
2026-05-04 09:39:13 >>>回调事件130,10,10023,finish Money=10,进钞完成
2026-05-04 09:39:13 当前产品价格10元，投币10元，打印小票中...
2026-05-04 09:39:13 >>>开始打印,排队号为38,订单号为2605040939130030509472
2026-05-04 09:39:13>>>订单2605040939130030509472写入成功,剩余空间为1680000,占用RAM为631.5849609375
删除未同步订单2605040939130030509472
2026-05-04 09:39:15>>>订单2605040939130030509472删除成功,剩余空间为1680500,占用RAM为642.806640625
检测订单目录中>>>
无未同步订单>>>
2026-05-04 09:39:15 >>>当前Ram内存为615.1201171875
定时检测未同步订单启用[checkOrderNum=536872203]
2026-05-04 09:39:16>>>cash write=0C
2026-05-04 09:39:16>>>cash read=818F4200
2026-05-04 09:39:16>>>cash write=02
2026-05-04 09:39:16 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-05-04 09:39:17>>>cash read=10
2026-05-04 09:39:17 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-04 09:39:17 当前产品价格10元，投币10元，打印小票中...
2026-05-04 09:39:17 >>>开始打印,排队号为39,订单号为2605040939170030509282
2026-05-04 09:39:17>>>订单2605040939170030509282写入成功,剩余空间为1679000,占用RAM为637.5400390625
删除未同步订单2605040939170030509282
2026-05-04 09:39:19>>>订单2605040939170030509282删除成功,剩余空间为1679500,占用RAM为645.7685546875
检测订单目录中>>>
无未同步订单>>>
2026-05-04 09:39:19 >>>当前Ram内存为616.6572265625
定时检测未同步订单启用[checkOrderNum=536872210]
2026-05-04 09:39:20>>>cash write=0C
2026-05-04 09:39:21>>>cash read=00818F41
2026-05-04 09:39:21>>>cash write=02
2026-05-04 09:39:21 >>>回调事件130,cash_status,10022,进钞中...read money=5
2026-05-04 09:39:21>>>cash read=10
2026-05-04 09:39:21 >>>回调事件130,5,10023,finish Money=5,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-04 09:39:22>>>cash write=0C
2026-05-04 09:39:22>>>cash read=00
2026-05-04 09:39:24>>>cash read=818F41
2026-05-04 09:39:24>>>cash write=02
2026-05-04 09:39:24 >>>回调事件130,cash_status,10022,进钞中...read money=5
2026-05-04 09:39:24>>>cash read=10
2026-05-04 09:39:24 >>>回调事件130,5,10023,finish Money=5,进钞完成
2026-05-04 09:39:24 当前产品价格10元，投币10元，打印小票中...
2026-05-04 09:39:24 >>>开始打印,排队号为40,订单号为2605040939210030509331
2026-05-04 09:39:25>>>订单2605040939210030509331写入成功,剩余空间为1677500,占用RAM为642.92578125
删除未同步订单2605040939210030509331
2026-05-04 09:39:27>>>订单2605040939210030509331删除成功,剩余空间为1678500,占用RAM为653.185546875
检测订单目录中>>>
无未同步订单>>>
2026-05-04 09:39:27 >>>当前Ram内存为618.818359375
定时检测未同步订单启用[checkOrderNum=536872222]
2026-05-04 09:39:28>>>cash write=0C
2026-05-04 09:39:28>>>cash read=3E
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-04 09:40:09 收到下发指令:排队号22>>>
2026-05-04 09:40:09 收到下发指令:叫号22>>>
2026-05-04 09:40:09 收到下发指令:排队号25>>>
2026-05-04 09:40:09 收到下发指令:叫号25>>>
2026-05-04 09:40:10 收到下发指令:排队号27>>>
2026-05-04 09:40:10 收到下发指令:叫号27>>>
2026-05-04 09:40:11 收到下发指令:排队号28>>>
2026-05-04 09:40:11 收到下发指令:叫号28>>>
2026-05-04 09:40:12 收到下发指令:排队号30>>>
2026-05-04 09:40:12 收到下发指令:叫号30>>>
2026-05-04 09:40:13 收到下发指令:排队号32>>>
2026-05-04 09:40:13 收到下发指令:叫号32>>>


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


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


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


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


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


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


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


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


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


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


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


===10:17:20===
2026-05-04 10:16:40>>>cash read=29
2026-05-04 10:16:40 >>>回调事件130,cash_status,20029,退钞中
2026-05-04 10:16:40>>>cash read=2F29
2026-05-04 10:16:41>>>cash read=01
2026-05-04 10:16:42>>>cash read=2F
2026-05-04 10:16:43>>>cash read=3E
2026-05-04 10:16:44>>>cash read=00
2026-05-04 10:16:45>>>cash read=818F42
2026-05-04 10:16:45>>>cash write=02
2026-05-04 10:16:45 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-05-04 10:16:46>>>cash read=10
2026-05-04 10:16:46 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-04 10:16:46 当前产品价格10元，投币10元，打印小票中...
2026-05-04 10:16:46 >>>开始打印,排队号为53,订单号为2605041016460030509441
2026-05-04 10:16:46>>>订单2605041016460030509441写入成功,剩余空间为1679500,占用RAM为631.7158203125
删除未同步订单2605041016460030509441
2026-05-04 10:16:48>>>订单2605041016460030509441删除成功,剩余空间为1680500,占用RAM为642.98046875
检测订单目录中>>>
无未同步订单>>>
2026-05-04 10:16:48 >>>当前Ram内存为614.9130859375
定时检测未同步订单启用[checkOrderNum=536872667]
2026-05-04 10:16:49>>>cash write=0C
2026-05-04 10:16:49>>>cash read=3E


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


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


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


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


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


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


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


===10:58:23===
2026-05-04 10:58:04>>>cash read=0A
2026-05-04 10:58:05>>>cash read=3E


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


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


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


===11:19:25===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-04 11:19:21 >>>回调事件[910,devices/A0509]
2026-05-04 11:19:21 >>>故障排除日志:上一MQTT订单号缓存列表为2605041111100027622496
2026-05-04 11:19:21 >>>故障排除日志:终端未同步成功订单列表
2026-05-04 11:19:21 开始打印,排队:66,票券:2605041119156986556701,订单:2605041119150067965334,[2026-05-04 11:19:21支付宝支付10元]
2026-05-04 11:19:21>>>MQTT票号同步场景，创建空订单对象
2026-05-04 11:19:21>>>合并MQTT票号列表到订单同步请求,共1张票


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


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


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


===11:42:26===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-04 11:41:43 >>>回调事件[910,devices/A0509]
2026-05-04 11:41:43 >>>故障排除日志:上一MQTT订单号缓存列表为2605041131540099990985
2026-05-04 11:41:43 >>>故障排除日志:终端未同步成功订单列表
2026-05-04 11:41:43 开始打印,排队:71,票券:2605041141354818312101,订单:2605041141350046368886,[2026-05-04 11:41:43微信支付10元]
2026-05-04 11:41:44>>>MQTT票号同步场景，创建空订单对象
2026-05-04 11:41:44>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-04 11:41:45 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605041141354818312101","queue_number":71,"trade_uid":"2605041141350046368886"}]}
2026-05-04 11:41:45 >>>故障排除日志:删除未同步下发订单成功2605041141350046368886
2026-05-04 11:41:45 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536873566]
2026-05-04 11:41:53>>>cash read=00
2026-05-04 11:41:53>>>cash read=818F42
2026-05-04 11:41:53>>>cash write=02
2026-05-04 11:41:53 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-05-04 11:41:53>>>cash read=10
2026-05-04 11:41:53 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-04 11:41:53 当前产品价格10元，投币10元，打印小票中...
2026-05-04 11:41:53 >>>开始打印,排队号为72,订单号为2605041141530030509769
2026-05-04 11:41:54>>>订单2605041141530030509769写入成功,剩余空间为1678500,占用RAM为635.6005859375
删除未同步订单2605041141530030509769
2026-05-04 11:41:56>>>订单2605041141530030509769删除成功,剩余空间为1679500,占用RAM为651.337890625
检测订单目录中>>>
无未同步订单>>>
2026-05-04 11:41:56 >>>当前Ram内存为618.1298828125
定时检测未同步订单启用[checkOrderNum=536873578]
2026-05-04 11:41:57>>>cash write=0C
2026-05-04 11:41:57>>>cash read=3E


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


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


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


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


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


===12:15:27===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-04 12:15:05 收到下发指令:排队号41>>>
2026-05-04 12:15:05 收到下发指令:叫号41>>>
2026-05-04 12:15:08 收到下发指令:排队号41>>>
2026-05-04 12:15:08 收到下发指令:叫号41>>>
2026-05-04 12:15:13 收到下发指令:排队号41>>>
2026-05-04 12:15:13 收到下发指令:叫号41>>>


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


===12:19:27===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-04 12:18:35 >>>回调事件[910,devices/A0509]
2026-05-04 12:18:35 >>>故障排除日志:上一MQTT订单号缓存列表为2605041217230011288296
2026-05-04 12:18:35 >>>故障排除日志:终端未同步成功订单列表
2026-05-04 12:18:35 开始打印,排队:79,票券:2605041218273654738501,订单:2605041218270034621726,[2026-05-04 12:18:34微信支付10元]
2026-05-04 12:18:35 开始打印,排队:80,票券:2605041218273655171302,订单:2605041218270034621726,[2026-05-04 12:18:34微信支付10元]
2026-05-04 12:18:35>>>MQTT票号同步场景，创建空订单对象
2026-05-04 12:18:35>>>合并MQTT票号列表到订单同步请求,共2张票
2026-05-04 12:18:38 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605041218273654738501","queue_number":79,"trade_uid":"2605041218270034621726"},{"ticket_no":"2605041218273655171302","queue_number":80,"trade_uid":"2605041218270034621726"}]}
2026-05-04 12:18:38 >>>故障排除日志:删除未同步下发订单成功2605041218270034621726
2026-05-04 12:18:38 >>>故障排除日志:删除未同步下发订单成功2605041218270034621726
2026-05-04 12:18:39 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536873973]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-04 12:19:18 >>>回调事件[910,devices/A0509]
2026-05-04 12:19:18 >>>故障排除日志:上一MQTT订单号缓存列表为2605041218270034621726|2605041218270034621726
2026-05-04 12:19:18 >>>故障排除日志:终端未同步成功订单列表
2026-05-04 12:19:18 开始打印,排队:81,票券:2605041219116471825301,订单:2605041219110062903595,[2026-05-04 12:19:18微信支付10元]
2026-05-04 12:19:18>>>MQTT票号同步场景，创建空订单对象
2026-05-04 12:19:18>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-04 12:19:20 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605041219116471825301","queue_number":81,"trade_uid":"2605041219110062903595"}]}
2026-05-04 12:19:20 >>>故障排除日志:删除未同步下发订单成功2605041219110062903595
2026-05-04 12:19:20 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536873987]


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


===12:22:29===
2026-05-04 12:21:27 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605041221179610594701","queue_number":82,"trade_uid":"2605041221170094237578"}]}
2026-05-04 12:21:27 >>>故障排除日志:删除未同步下发订单成功2605041221170094237578
2026-05-04 12:21:28 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536874015]


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


===12:27:29===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-04 12:26:35 收到下发指令:排队号41>>>
2026-05-04 12:26:35 收到下发指令:叫号41>>>
2026-05-04 12:26:38 收到下发指令:排队号41>>>
2026-05-04 12:26:38 收到下发指令:叫号41>>>
2026-05-04 12:26:42 收到下发指令:排队号41>>>
2026-05-04 12:26:42 收到下发指令:叫号41>>>
2026-05-04 12:26:48 收到下发指令:排队号41>>>
2026-05-04 12:26:48 收到下发指令:叫号41>>>
2026-05-04 12:26:50>>>cash read=00
2026-05-04 12:26:51>>>cash read=29
2026-05-04 12:26:51 >>>回调事件130,cash_status,20029,退钞中
2026-05-04 12:26:51>>>cash read=2F29
2026-05-04 12:26:52 收到下发指令:排队号41>>>
2026-05-04 12:26:52 收到下发指令:叫号41>>>
2026-05-04 12:26:52>>>cash read=01
2026-05-04 12:26:53>>>cash read=2F
2026-05-04 12:26:54>>>cash read=3E
2026-05-04 12:26:56 收到下发指令:排队号41>>>
2026-05-04 12:26:56 收到下发指令:叫号41>>>
2026-05-04 12:26:59 收到下发指令:排队号41>>>
2026-05-04 12:26:59 收到下发指令:叫号41>>>
2026-05-04 12:27:03 收到下发指令:排队号41>>>
2026-05-04 12:27:03 收到下发指令:叫号41>>>
2026-05-04 12:27:07 收到下发指令:排队号41>>>
2026-05-04 12:27:07 收到下发指令:叫号41>>>
2026-05-04 12:27:10 收到下发指令:排队号41>>>
2026-05-04 12:27:10 收到下发指令:叫号41>>>
2026-05-04 12:27:14 收到下发指令:排队号41>>>
2026-05-04 12:27:14 收到下发指令:叫号41>>>
2026-05-04 12:27:18 收到下发指令:排队号41>>>
2026-05-04 12:27:18 收到下发指令:叫号41>>>
2026-05-04 12:27:22 收到下发指令:排队号41>>>
2026-05-04 12:27:22 收到下发指令:叫号41>>>
2026-05-04 12:27:25 收到下发指令:排队号41>>>
2026-05-04 12:27:26 收到下发指令:叫号41>>>


===12:28:30===
2026-05-04 12:27:29 收到下发指令:排队号41>>>
2026-05-04 12:27:29 收到下发指令:叫号41>>>
2026-05-04 12:27:33 收到下发指令:排队号41>>>
2026-05-04 12:27:33 收到下发指令:叫号41>>>
2026-05-04 12:27:36 收到下发指令:排队号41>>>
2026-05-04 12:27:36 收到下发指令:叫号41>>>
2026-05-04 12:27:45 收到下发指令:排队号41>>>
2026-05-04 12:27:45 收到下发指令:叫号41>>>
2026-05-04 12:27:57>>>cash read=00
2026-05-04 12:27:58>>>cash read=818F42
2026-05-04 12:27:58>>>cash write=02
2026-05-04 12:27:58 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-05-04 12:27:58>>>cash read=10
2026-05-04 12:27:58 >>>回调事件130,10,10023,finish Money=10,进钞完成
2026-05-04 12:27:58 当前产品价格10元，投币10元，打印小票中...
2026-05-04 12:27:58 >>>开始打印,排队号为84,订单号为2605041227580030509112
2026-05-04 12:27:59>>>订单2605041227580030509112写入成功,剩余空间为1679500,占用RAM为632.2158203125
删除未同步订单2605041227580030509112
2026-05-04 12:28:01>>>订单2605041227580030509112删除成功,剩余空间为1680000,占用RAM为643.6484375
检测订单目录中>>>
无未同步订单>>>
2026-05-04 12:28:01 >>>当前Ram内存为615.3134765625
定时检测未同步订单启用[checkOrderNum=536874138]
2026-05-04 12:28:02>>>cash write=0C
2026-05-04 12:28:02>>>cash read=3E
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-04 12:28:05 收到下发指令:排队号41>>>
2026-05-04 12:28:05 收到下发指令:叫号41>>>


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


===12:31:30===
2026-05-04 12:30:56 收到下发指令:排队号43>>>
2026-05-04 12:30:56 收到下发指令:叫号43>>>
2026-05-04 12:30:56 收到下发指令:排队号45>>>
2026-05-04 12:30:56 收到下发指令:叫号45>>>
2026-05-04 12:30:57 收到下发指令:排队号48>>>
2026-05-04 12:30:57 收到下发指令:叫号48>>>
2026-05-04 12:30:58 收到下发指令:排队号51>>>
2026-05-04 12:30:58 收到下发指令:叫号51>>>
2026-05-04 12:30:59 收到下发指令:排队号52>>>
2026-05-04 12:30:59 收到下发指令:叫号52>>>
2026-05-04 12:31:00 收到下发指令:排队号54>>>
2026-05-04 12:31:00 收到下发指令:叫号54>>>
2026-05-04 12:31:00 收到下发指令:排队号56>>>
2026-05-04 12:31:00 收到下发指令:叫号56>>>
2026-05-04 12:31:01 收到下发指令:排队号58>>>
2026-05-04 12:31:01 收到下发指令:叫号58>>>
2026-05-04 12:31:01 收到下发指令:排队号60>>>
2026-05-04 12:31:01 收到下发指令:叫号60>>>
2026-05-04 12:31:02 收到下发指令:排队号62>>>
2026-05-04 12:31:02 收到下发指令:叫号62>>>
2026-05-04 12:31:02 收到下发指令:排队号64>>>
2026-05-04 12:31:02 收到下发指令:叫号64>>>
2026-05-04 12:31:03 收到下发指令:排队号66>>>
2026-05-04 12:31:04 收到下发指令:叫号66>>>
2026-05-04 12:31:04 收到下发指令:排队号67>>>
2026-05-04 12:31:04 收到下发指令:叫号67>>>
2026-05-04 12:31:04 收到下发指令:排队号68>>>
2026-05-04 12:31:04 收到下发指令:叫号68>>>
2026-05-04 12:31:06 收到下发指令:排队号69>>>
2026-05-04 12:31:06 收到下发指令:叫号69>>>
2026-05-04 12:31:06 收到下发指令:排队号72>>>
2026-05-04 12:31:06 收到下发指令:叫号72>>>
2026-05-04 12:31:06 收到下发指令:排队号74>>>
2026-05-04 12:31:06 收到下发指令:叫号74>>>
2026-05-04 12:31:07 收到下发指令:排队号76>>>
2026-05-04 12:31:07 收到下发指令:叫号76>>>
2026-05-04 12:31:08 收到下发指令:排队号78>>>
2026-05-04 12:31:08 收到下发指令:叫号78>>>
2026-05-04 12:31:08 收到下发指令:排队号80>>>
2026-05-04 12:31:08 收到下发指令:叫号80>>>
2026-05-04 12:31:09 收到下发指令:排队号82>>>
2026-05-04 12:31:09 收到下发指令:叫号82>>>
2026-05-04 12:31:09 收到下发指令:排队号nil>>>


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


===12:39:31===
2026-05-04 12:38:33>>>cash read=00
2026-05-04 12:38:35>>>cash read=00818F42
2026-05-04 12:38:35>>>cash write=02
2026-05-04 12:38:35 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-05-04 12:38:35>>>cash read=10
2026-05-04 12:38:35 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-04 12:38:35 当前产品价格10元，投币10元，打印小票中...
2026-05-04 12:38:35 >>>开始打印,排队号为87,订单号为2605041238350030509636
2026-05-04 12:38:35>>>订单2605041238350030509636写入成功,剩余空间为1679500,占用RAM为633.119140625
删除未同步订单2605041238350030509636
2026-05-04 12:38:38>>>订单2605041238350030509636删除成功,剩余空间为1680500,占用RAM为643.3486328125
检测订单目录中>>>
无未同步订单>>>
2026-05-04 12:38:38 >>>当前Ram内存为615.673828125
定时检测未同步订单启用[checkOrderNum=536874266]
2026-05-04 12:38:39>>>cash write=0C
2026-05-04 12:38:39>>>cash read=3E
2026-05-04 12:39:11>>>cash read=29
2026-05-04 12:39:11 >>>回调事件130,cash_status,20029,退钞中
2026-05-04 12:39:12>>>cash read=00
2026-05-04 12:39:14>>>cash read=29
2026-05-04 12:39:14 >>>回调事件130,cash_status,20029,退钞中
2026-05-04 12:39:14>>>cash read=2F29
2026-05-04 12:39:15>>>cash read=01
2026-05-04 12:39:15>>>cash read=2F
2026-05-04 12:39:16>>>cash read=3E


===12:40:31===
2026-05-04 12:39:53>>>cash read=00
2026-05-04 12:39:55>>>cash read=29
2026-05-04 12:39:55 >>>回调事件130,cash_status,20029,退钞中
2026-05-04 12:39:55>>>cash read=2F29
2026-05-04 12:39:56>>>cash read=01
2026-05-04 12:39:56>>>cash read=2F
2026-05-04 12:39:57>>>cash read=3E
2026-05-04 12:40:09>>>cash read=00
2026-05-04 12:40:10>>>cash read=818F42
2026-05-04 12:40:10>>>cash write=02
2026-05-04 12:40:10 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-05-04 12:40:10>>>cash read=10
2026-05-04 12:40:10 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-04 12:40:10 当前产品价格10元，投币10元，打印小票中...
2026-05-04 12:40:10 >>>开始打印,排队号为88,订单号为2605041240100030509615
2026-05-04 12:40:10>>>订单2605041240100030509615写入成功,剩余空间为1679500,占用RAM为636.0234375
删除未同步订单2605041240100030509615
2026-05-04 12:40:13>>>订单2605041240100030509615删除成功,剩余空间为1680500,占用RAM为644.9990234375
检测订单目录中>>>
无未同步订单>>>
2026-05-04 12:40:13 >>>当前Ram内存为616.8603515625
定时检测未同步订单启用[checkOrderNum=536874292]
2026-05-04 12:40:14>>>cash write=0C
2026-05-04 12:40:14>>>cash read=3E
2026-05-04 12:40:21>>>cash read=00
2026-05-04 12:40:21>>>cash read=818F41
2026-05-04 12:40:21>>>cash write=02
2026-05-04 12:40:21 >>>回调事件130,cash_status,10022,进钞中...read money=5
2026-05-04 12:40:21>>>cash read=10
2026-05-04 12:40:21 >>>回调事件130,5,10023,finish Money=5,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-04 12:40:22>>>cash write=0C
2026-05-04 12:40:22>>>cash read=3E
2026-05-04 12:40:25>>>cash read=00
2026-05-04 12:40:25>>>cash read=818F41
2026-05-04 12:40:25>>>cash write=02
2026-05-04 12:40:25 >>>回调事件130,cash_status,10022,进钞中...read money=5
2026-05-04 12:40:25>>>cash read=10
2026-05-04 12:40:25 >>>回调事件130,5,10023,finish Money=5,进钞完成
2026-05-04 12:40:25 当前产品价格10元，投币10元，打印小票中...
2026-05-04 12:40:25 >>>开始打印,排队号为89,订单号为2605041240210030509121
2026-05-04 12:40:26>>>订单2605041240210030509121写入成功,剩余空间为1678000,占用RAM为642.5810546875
删除未同步订单2605041240210030509121
2026-05-04 12:40:28>>>订单2605041240210030509121删除成功,剩余空间为1679000,占用RAM为648.369140625
检测订单目录中>>>
无未同步订单>>>
2026-05-04 12:40:28 >>>当前Ram内存为617.7822265625
定时检测未同步订单启用[checkOrderNum=536874304]
2026-05-04 12:40:29>>>cash write=0C
2026-05-04 12:40:29>>>cash read=3E


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


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


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


===12:50:32===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-04 12:49:39 收到下发指令:排队号86>>>
2026-05-04 12:49:40 收到下发指令:叫号86>>>
2026-05-04 12:49:43 收到下发指令:排队号86>>>
2026-05-04 12:49:43 收到下发指令:叫号86>>>
2026-05-04 12:49:46 收到下发指令:排队号86>>>
2026-05-04 12:49:46 收到下发指令:叫号86>>>
2026-05-04 12:49:50 收到下发指令:排队号86>>>
2026-05-04 12:49:50 收到下发指令:叫号86>>>


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


===13:57:37===
2026-05-04 13:56:36 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605041356280419863701","queue_number":121,"trade_uid":"2605041356280002410253"}]}
2026-05-04 13:56:36 >>>故障排除日志:删除未同步下发订单成功2605041356280002410253
2026-05-04 13:56:36 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536875239]


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


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


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


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


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


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


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


===14:31:42===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-04 14:31:37 >>>回调事件[910,devices/A0509]
2026-05-04 14:31:37 >>>故障排除日志:上一MQTT订单号缓存列表为2605041428490068986551
2026-05-04 14:31:37 >>>故障排除日志:终端未同步成功订单列表
2026-05-04 14:31:37 开始打印,排队:130,票券:2605041431302399307101,订单:2605041431300022086641,[2026-05-04 14:31:36支付宝支付10元]
2026-05-04 14:31:37 开始打印,排队:131,票券:2605041431302399871402,订单:2605041431300022086641,[2026-05-04 14:31:36支付宝支付10元]
2026-05-04 14:31:37>>>MQTT票号同步场景，创建空订单对象
2026-05-04 14:31:37>>>合并MQTT票号列表到订单同步请求,共2张票


===14:32:42===
2026-05-04 14:31:40 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605041431302399307101","queue_number":130,"trade_uid":"2605041431300022086641"},{"ticket_no":"2605041431302399871402","queue_number":131,"trade_uid":"2605041431300022086641"}]}
2026-05-04 14:31:40 >>>故障排除日志:删除未同步下发订单成功2605041431300022086641
2026-05-04 14:31:40 >>>故障排除日志:删除未同步下发订单成功2605041431300022086641
2026-05-04 14:31:40 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536875620]


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


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


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


===14:42:43===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-04 14:41:49 >>>回调事件[910,devices/A0509]
2026-05-04 14:41:49 >>>故障排除日志:上一MQTT订单号缓存列表为2605041441120075343394
2026-05-04 14:41:49 >>>故障排除日志:终端未同步成功订单列表
2026-05-04 14:41:49 开始打印,排队:135,票券:2605041441441342112901,订单:2605041441440011287816,[2026-05-04 14:41:49微信支付10元]
2026-05-04 14:41:49>>>MQTT票号同步场景，创建空订单对象
2026-05-04 14:41:49>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-04 14:41:51 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605041441441342112901","queue_number":135,"trade_uid":"2605041441440011287816"}]}
2026-05-04 14:41:51 >>>故障排除日志:删除未同步下发订单成功2605041441440011287816
2026-05-04 14:41:51 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536875742]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-04 14:42:22 >>>回调事件[910,devices/A0509]
2026-05-04 14:42:23 >>>故障排除日志:上一MQTT订单号缓存列表为2605041441440011287816
2026-05-04 14:42:23 >>>故障排除日志:终端未同步成功订单列表
2026-05-04 14:42:23 开始打印,排队:136,票券:2605041442173068061901,订单:2605041442170028855415,[2026-05-04 14:42:22微信支付10元]
2026-05-04 14:42:23 开始打印,排队:137,票券:2605041442173068551302,订单:2605041442170028855415,[2026-05-04 14:42:22微信支付10元]
2026-05-04 14:42:23>>>MQTT票号同步场景，创建空订单对象
2026-05-04 14:42:23>>>合并MQTT票号列表到订单同步请求,共2张票
2026-05-04 14:42:26 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605041442173068061901","queue_number":136,"trade_uid":"2605041442170028855415"},{"ticket_no":"2605041442173068551302","queue_number":137,"trade_uid":"2605041442170028855415"}]}
2026-05-04 14:42:26 >>>故障排除日志:删除未同步下发订单成功2605041442170028855415
2026-05-04 14:42:26 >>>故障排除日志:删除未同步下发订单成功2605041442170028855415
2026-05-04 14:42:26 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536875757]


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


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


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


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


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


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


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


===15:09:45===
2026-05-04 15:09:33>>>cash read=0A
2026-05-04 15:09:34>>>cash read=3E


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


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


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


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


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


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


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


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


===15:31:47===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-04 15:31:01 >>>回调事件[910,devices/A0509]
2026-05-04 15:31:02 >>>故障排除日志:上一MQTT订单号缓存列表为2605041528500078381683
2026-05-04 15:31:02 >>>故障排除日志:终端未同步成功订单列表
2026-05-04 15:31:02 开始打印,排队:157,票券:2605041530481761602101,订单:2605041530480015639292,[2026-05-04 15:31:01支付宝支付10元]
2026-05-04 15:31:02>>>MQTT票号同步场景，创建空订单对象
2026-05-04 15:31:02>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-04 15:31:03 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605041530481761602101","queue_number":157,"trade_uid":"2605041530480015639292"}]}
2026-05-04 15:31:03 >>>故障排除日志:删除未同步下发订单成功2605041530480015639292
2026-05-04 15:31:04 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536876338]
2026-05-04 15:31:05>>>cash read=00
2026-05-04 15:31:05>>>cash read=818F41
2026-05-04 15:31:05>>>cash write=02
2026-05-04 15:31:05 >>>回调事件130,cash_status,10022,进钞中...read money=5
2026-05-04 15:31:06>>>cash read=10
2026-05-04 15:31:06 >>>回调事件130,5,10023,finish Money=5,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-04 15:31:07>>>cash write=0C
2026-05-04 15:31:07>>>cash read=00
2026-05-04 15:31:08>>>cash read=818F41
2026-05-04 15:31:08>>>cash write=02
2026-05-04 15:31:08 >>>回调事件130,cash_status,10022,进钞中...read money=5
2026-05-04 15:31:08>>>cash read=10
2026-05-04 15:31:08 >>>回调事件130,5,10023,finish Money=5,进钞完成
2026-05-04 15:31:08 当前产品价格10元，投币10元，打印小票中...
2026-05-04 15:31:08 >>>开始打印,排队号为158,订单号为2605041531060030509532
2026-05-04 15:31:09>>>订单2605041531060030509532写入成功,剩余空间为1678500,占用RAM为639.791015625
删除未同步订单2605041531060030509532
2026-05-04 15:31:11>>>订单2605041531060030509532删除成功,剩余空间为1679000,占用RAM为648.966796875
检测订单目录中>>>
无未同步订单>>>
2026-05-04 15:31:11 >>>当前Ram内存为617.75
定时检测未同步订单启用[checkOrderNum=536876350]
2026-05-04 15:31:12>>>cash write=0C
2026-05-04 15:31:12>>>cash read=3E


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


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


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


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


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


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


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


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


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


===15:58:48===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-04 15:57:49 >>>回调事件[910,devices/A0509]
2026-05-04 15:57:49 >>>故障排除日志:上一MQTT订单号缓存列表为2605041555240012341945
2026-05-04 15:57:49 >>>故障排除日志:终端未同步成功订单列表
2026-05-04 15:57:49 开始打印,排队:169,票券:2605041557435218037801,订单:2605041557430050391942,[2026-05-04 15:57:49微信支付10元]
2026-05-04 15:57:49>>>MQTT票号同步场景，创建空订单对象
2026-05-04 15:57:49>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-04 15:57:51 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605041557435218037801","queue_number":169,"trade_uid":"2605041557430050391942"}]}
2026-05-04 15:57:51 >>>故障排除日志:删除未同步下发订单成功2605041557430050391942
2026-05-04 15:57:51 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536876666]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-04 15:58:11 >>>回调事件[910,devices/A0509]
2026-05-04 15:58:11 >>>故障排除日志:上一MQTT订单号缓存列表为2605041557430050391942
2026-05-04 15:58:11 >>>故障排除日志:终端未同步成功订单列表
2026-05-04 15:58:11 开始打印,排队:170,票券:2605041558043830126901,订单:2605041558040035855084,[2026-05-04 15:58:11微信支付10元]
2026-05-04 15:58:11>>>MQTT票号同步场景，创建空订单对象
2026-05-04 15:58:11>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-04 15:58:13 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605041558043830126901","queue_number":170,"trade_uid":"2605041558040035855084"}]}
2026-05-04 15:58:13 >>>故障排除日志:删除未同步下发订单成功2605041558040035855084
2026-05-04 15:58:13 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536876679]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-04 15:58:24 >>>回调事件[910,devices/A0509]
2026-05-04 15:58:24 >>>故障排除日志:上一MQTT订单号缓存列表为2605041558040035855084
2026-05-04 15:58:24 >>>故障排除日志:终端未同步成功订单列表
2026-05-04 15:58:24 开始打印,排队:171,票券:2605041558160875568601,订单:2605041558160006901798,[2026-05-04 15:58:24微信支付10元]
2026-05-04 15:58:24>>>MQTT票号同步场景，创建空订单对象
2026-05-04 15:58:24>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-04 15:58:26 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605041558160875568601","queue_number":171,"trade_uid":"2605041558160006901798"}]}
2026-05-04 15:58:26 >>>故障排除日志:删除未同步下发订单成功2605041558160006901798
2026-05-04 15:58:26 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536876686]


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


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


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


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


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


===16:17:49===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-04 16:16:56 >>>回调事件[910,devices/A0509]
2026-05-04 16:16:56 >>>故障排除日志:上一MQTT订单号缓存列表为2605041615480010636842
2026-05-04 16:16:56 >>>故障排除日志:终端未同步成功订单列表
2026-05-04 16:16:56 开始打印,排队:177,票券:2605041616481305086801,订单:2605041616480011263139,[2026-05-04 16:16:56微信支付10元]
2026-05-04 16:16:56>>>MQTT票号同步场景，创建空订单对象
2026-05-04 16:16:56>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-04 16:16:58 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605041616481305086801","queue_number":177,"trade_uid":"2605041616480011263139"}]}
2026-05-04 16:16:58 >>>故障排除日志:删除未同步下发订单成功2605041616480011263139
2026-05-04 16:16:58 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536876902]
2026-05-04 16:17:27>>>cash read=0A
2026-05-04 16:17:28>>>cash read=3E
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-04 16:17:36 >>>回调事件[910,devices/A0509]
2026-05-04 16:17:36 >>>故障排除日志:上一MQTT订单号缓存列表为2605041616480011263139
2026-05-04 16:17:36 >>>故障排除日志:终端未同步成功订单列表
2026-05-04 16:17:36 开始打印,排队:178,票券:2605041617300531524801,订单:2605041617300003404548,[2026-05-04 16:17:35支付宝支付10元]
2026-05-04 16:17:36>>>MQTT票号同步场景，创建空订单对象
2026-05-04 16:17:36>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-04 16:17:38 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605041617300531524801","queue_number":178,"trade_uid":"2605041617300003404548"}]}
2026-05-04 16:17:38 >>>故障排除日志:删除未同步下发订单成功2605041617300003404548
2026-05-04 16:17:38 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536876911]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-04 16:17:41 >>>回调事件[910,devices/A0509]
2026-05-04 16:17:41 >>>故障排除日志:上一MQTT订单号缓存列表为2605041617300003404548
2026-05-04 16:17:41 >>>故障排除日志:终端未同步成功订单列表
2026-05-04 16:17:42 开始打印,排队:179,票券:2605041617343272117201,订单:2605041617340030785391,[2026-05-04 16:17:41微信支付10元]
2026-05-04 16:17:42>>>MQTT票号同步场景，创建空订单对象
2026-05-04 16:17:42>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-04 16:17:44 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605041617343272117201","queue_number":179,"trade_uid":"2605041617340030785391"}]}
2026-05-04 16:17:44 >>>故障排除日志:删除未同步下发订单成功2605041617340030785391
2026-05-04 16:17:44 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536876917]


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


===16:21:50===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-04 16:20:53 >>>回调事件[910,devices/A0509]
2026-05-04 16:20:53 >>>故障排除日志:上一MQTT订单号缓存列表为2605041619180098255972
2026-05-04 16:20:53 >>>故障排除日志:终端未同步成功订单列表
2026-05-04 16:20:53 开始打印,排队:181,票券:2605041620460782597901,订单:2605041620460005665382,[2026-05-04 16:20:52支付宝支付10元]
2026-05-04 16:20:53>>>MQTT票号同步场景，创建空订单对象
2026-05-04 16:20:53>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-04 16:20:55 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605041620460782597901","queue_number":181,"trade_uid":"2605041620460005665382"}]}
2026-05-04 16:20:55 >>>故障排除日志:删除未同步下发订单成功2605041620460005665382
2026-05-04 16:20:56 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536876961]
2026-05-04 16:21:14>>>cash read=00
2026-05-04 16:21:15>>>cash read=818F42
2026-05-04 16:21:15>>>cash write=02
2026-05-04 16:21:15 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-05-04 16:21:15>>>cash read=10
2026-05-04 16:21:15 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-04 16:21:15 当前产品价格10元，投币10元，打印小票中...
2026-05-04 16:21:15 >>>开始打印,排队号为182,订单号为2605041621150030509956
2026-05-04 16:21:16>>>订单2605041621150030509956写入成功,剩余空间为1678500,占用RAM为636.8056640625
删除未同步订单2605041621150030509956
2026-05-04 16:21:18>>>订单2605041621150030509956删除成功,剩余空间为1679500,占用RAM为645.0712890625
检测订单目录中>>>
无未同步订单>>>
2026-05-04 16:21:18 >>>当前Ram内存为615.474609375
定时检测未同步订单启用[checkOrderNum=536876975]
2026-05-04 16:21:19>>>cash write=0C
2026-05-04 16:21:19>>>cash read=3E


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


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


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


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


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


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


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


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


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


===16:48:52===
2026-05-04 16:48:36>>>cash read=0A
2026-05-04 16:48:37>>>cash read=3E


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


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


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


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


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


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


===17:15:54===
2026-05-04 17:15:39>>>cash read=00
2026-05-04 17:15:39>>>cash read=818F42
2026-05-04 17:15:39>>>cash write=02
2026-05-04 17:15:39 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-05-04 17:15:40>>>cash read=10
2026-05-04 17:15:40 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-04 17:15:40 当前产品价格10元，投币10元，打印小票中...
2026-05-04 17:15:40 >>>开始打印,排队号为202,订单号为2605041715400030509138
2026-05-04 17:15:40>>>订单2605041715400030509138写入成功,剩余空间为1679500,占用RAM为631.7109375
删除未同步订单2605041715400030509138
2026-05-04 17:15:42>>>订单2605041715400030509138删除成功,剩余空间为1680500,占用RAM为643.7421875
检测订单目录中>>>
无未同步订单>>>
2026-05-04 17:15:42 >>>当前Ram内存为614.470703125
定时检测未同步订单启用[checkOrderNum=536877611]
2026-05-04 17:15:43>>>cash write=0C
2026-05-04 17:15:43>>>cash read=00
2026-05-04 17:15:44>>>cash read=818F42
2026-05-04 17:15:44>>>cash write=02
2026-05-04 17:15:44 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-05-04 17:15:45>>>cash read=10
2026-05-04 17:15:45 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-04 17:15:45 当前产品价格10元，投币10元，打印小票中...
2026-05-04 17:15:45 >>>开始打印,排队号为203,订单号为2605041715450030509192
2026-05-04 17:15:45>>>订单2605041715450030509192写入成功,剩余空间为1678500,占用RAM为639.787109375
删除未同步订单2605041715450030509192
2026-05-04 17:15:47>>>订单2605041715450030509192删除成功,剩余空间为1679500,占用RAM为645.58984375
检测订单目录中>>>
无未同步订单>>>
2026-05-04 17:15:47 >>>当前Ram内存为616.3271484375
定时检测未同步订单启用[checkOrderNum=536877618]
2026-05-04 17:15:48>>>cash write=0C
2026-05-04 17:15:48>>>cash read=3E


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


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


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


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


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


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


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


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


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


===17:57:55===
2026-05-04 17:56:59>>>cash read=00
2026-05-04 17:57:00>>>cash read=818F41
2026-05-04 17:57:00>>>cash write=02
2026-05-04 17:57:00 >>>回调事件130,cash_status,10022,进钞中...read money=5
2026-05-04 17:57:00>>>cash read=10
2026-05-04 17:57:00 >>>回调事件130,5,10023,finish Money=5,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-04 17:57:01>>>cash write=0C
2026-05-04 17:57:01>>>cash read=3E
2026-05-04 17:57:03>>>cash read=00
2026-05-04 17:57:03>>>cash read=818F41
2026-05-04 17:57:03>>>cash write=02
2026-05-04 17:57:03 >>>回调事件130,cash_status,10022,进钞中...read money=5
2026-05-04 17:57:04>>>cash read=10
2026-05-04 17:57:04 >>>回调事件130,5,10023,finish Money=5,进钞完成
2026-05-04 17:57:04 当前产品价格10元，投币10元，打印小票中...
2026-05-04 17:57:04 >>>开始打印,排队号为213,订单号为2605041757000030509831
2026-05-04 17:57:04>>>订单2605041757000030509831写入成功,剩余空间为1679500,占用RAM为632.580078125
删除未同步订单2605041757000030509831
2026-05-04 17:57:06>>>订单2605041757000030509831删除成功,剩余空间为1680000,占用RAM为644.71875
检测订单目录中>>>
无未同步订单>>>
2026-05-04 17:57:06 >>>当前Ram内存为615.25
定时检测未同步订单启用[checkOrderNum=536878080]
2026-05-04 17:57:07>>>cash write=0C
2026-05-04 17:57:07>>>cash read=3E


===18:00:58===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-04 18:00:22 收到下发指令:排队号88>>>
2026-05-04 18:00:22 收到下发指令:叫号88>>>
2026-05-04 18:00:23 收到下发指令:排队号91>>>
2026-05-04 18:00:23 收到下发指令:叫号91>>>
2026-05-04 18:00:24 收到下发指令:排队号93>>>
2026-05-04 18:00:24 收到下发指令:叫号93>>>
2026-05-04 18:00:24 收到下发指令:排队号94>>>
2026-05-04 18:00:25 收到下发指令:叫号94>>>
2026-05-04 18:00:25 收到下发指令:排队号95>>>
2026-05-04 18:00:25 收到下发指令:叫号95>>>
2026-05-04 18:00:25 收到下发指令:排队号96>>>
2026-05-04 18:00:25 收到下发指令:叫号96>>>
2026-05-04 18:00:26 收到下发指令:排队号97>>>
2026-05-04 18:00:26 收到下发指令:叫号97>>>
2026-05-04 18:00:27 收到下发指令:排队号98>>>
2026-05-04 18:00:27 收到下发指令:叫号98>>>
2026-05-04 18:00:27 收到下发指令:排队号99>>>
2026-05-04 18:00:27 收到下发指令:叫号99>>>
2026-05-04 18:00:28 收到下发指令:排队号100>>>
2026-05-04 18:00:28 收到下发指令:叫号100>>>
2026-05-04 18:00:29 收到下发指令:排队号101>>>
2026-05-04 18:00:29 收到下发指令:叫号101>>>
2026-05-04 18:00:29 收到下发指令:排队号102>>>
2026-05-04 18:00:29 收到下发指令:叫号102>>>
2026-05-04 18:00:29 收到下发指令:排队号103>>>
2026-05-04 18:00:29 收到下发指令:叫号103>>>
2026-05-04 18:00:30 收到下发指令:排队号104>>>
2026-05-04 18:00:30 收到下发指令:叫号104>>>
2026-05-04 18:00:31 收到下发指令:排队号105>>>
2026-05-04 18:00:31 收到下发指令:叫号105>>>
2026-05-04 18:00:31 收到下发指令:排队号106>>>
2026-05-04 18:00:31 收到下发指令:叫号106>>>
2026-05-04 18:00:32 收到下发指令:排队号107>>>
2026-05-04 18:00:32 收到下发指令:叫号107>>>
2026-05-04 18:00:33 收到下发指令:排队号108>>>
2026-05-04 18:00:33 收到下发指令:叫号108>>>
2026-05-04 18:00:33 收到下发指令:排队号109>>>
2026-05-04 18:00:33 收到下发指令:叫号109>>>
2026-05-04 18:00:34 收到下发指令:排队号110>>>
2026-05-04 18:00:34 收到下发指令:叫号110>>>
2026-05-04 18:00:35 收到下发指令:排队号111>>>
2026-05-04 18:00:35 收到下发指令:叫号111>>>
2026-05-04 18:00:36 收到下发指令:排队号112>>>
2026-05-04 18:00:36 收到下发指令:叫号112>>>
2026-05-04 18:00:37 收到下发指令:排队号113>>>
2026-05-04 18:00:37 收到下发指令:叫号113>>>
2026-05-04 18:00:38 收到下发指令:排队号114>>>
2026-05-04 18:00:38 收到下发指令:叫号114>>>
2026-05-04 18:00:39 收到下发指令:排队号115>>>
2026-05-04 18:00:39 收到下发指令:叫号115>>>
2026-05-04 18:00:40 收到下发指令:排队号116>>>
2026-05-04 18:00:40 收到下发指令:叫号116>>>
2026-05-04 18:00:40 收到下发指令:排队号117>>>
2026-05-04 18:00:40 收到下发指令:叫号117>>>
2026-05-04 18:00:41 收到下发指令:排队号118>>>
2026-05-04 18:00:41 收到下发指令:叫号118>>>
2026-05-04 18:00:42 收到下发指令:排队号119>>>
2026-05-04 18:00:42 收到下发指令:叫号119>>>
2026-05-04 18:00:42 收到下发指令:排队号120>>>
2026-05-04 18:00:42 收到下发指令:叫号120>>>
2026-05-04 18:00:43 收到下发指令:排队号121>>>
2026-05-04 18:00:43 收到下发指令:叫号121>>>
2026-05-04 18:00:44 收到下发指令:排队号122>>>
2026-05-04 18:00:44 收到下发指令:叫号122>>>
2026-05-04 18:00:44 收到下发指令:排队号123>>>
2026-05-04 18:00:44 收到下发指令:叫号123>>>
2026-05-04 18:00:45 收到下发指令:排队号124>>>
2026-05-04 18:00:46 收到下发指令:叫号124>>>
2026-05-04 18:00:46 收到下发指令:排队号125>>>
2026-05-04 18:00:46 收到下发指令:叫号125>>>
2026-05-04 18:00:46 收到下发指令:排队号126>>>
2026-05-04 18:00:46 收到下发指令:叫号126>>>
2026-05-04 18:00:48 收到下发指令:排队号127>>>
2026-05-04 18:00:48 收到下发指令:叫号127>>>
2026-05-04 18:00:48 收到下发指令:排队号128>>>
2026-05-04 18:00:48 收到下发指令:叫号128>>>
2026-05-04 18:00:49 收到下发指令:排队号129>>>
2026-05-04 18:00:49 收到下发指令:叫号129>>>
2026-05-04 18:00:49 收到下发指令:排队号130>>>
2026-05-04 18:00:49 收到下发指令:叫号130>>>
2026-05-04 18:00:50 收到下发指令:排队号131>>>
2026-05-04 18:00:50 收到下发指令:叫号131>>>
2026-05-04 18:00:50 收到下发指令:排队号132>>>
2026-05-04 18:00:50 收到下发指令:叫号132>>>
2026-05-04 18:00:51 收到下发指令:排队号133>>>
2026-05-04 18:00:51 收到下发指令:叫号133>>>
2026-05-04 18:00:51 收到下发指令:排队号134>>>
2026-05-04 18:00:51 收到下发指令:叫号134>>>
2026-05-04 18:00:52 收到下发指令:排队号135>>>
2026-05-04 18:00:52 收到下发指令:叫号135>>>
2026-05-04 18:00:52 收到下发指令:排队号136>>>
2026-05-04 18:00:53 收到下发指令:叫号136>>>


===18:02:00===
2026-05-04 18:00:59 收到下发指令:排队号147>>>
2026-05-04 18:00:59 收到下发指令:叫号147>>>
2026-05-04 18:01:00 收到下发指令:排队号148>>>
2026-05-04 18:01:00 收到下发指令:叫号148>>>
2026-05-04 18:01:01 收到下发指令:排队号149>>>
2026-05-04 18:01:01 收到下发指令:叫号149>>>
2026-05-04 18:01:02 收到下发指令:排队号150>>>
2026-05-04 18:01:02 收到下发指令:叫号150>>>
2026-05-04 18:01:09 收到下发指令:排队号151>>>
2026-05-04 18:01:09 收到下发指令:叫号151>>>
2026-05-04 18:01:31 收到下发指令:排队号150>>>


===18:03:02===
2026-05-04 18:02:50 收到下发指令:排队号151>>>
2026-05-04 18:02:50 收到下发指令:叫号151>>>
2026-05-04 18:02:50 收到下发指令:排队号152>>>
2026-05-04 18:02:50 收到下发指令:叫号152>>>
2026-05-04 18:02:51 收到下发指令:排队号153>>>
2026-05-04 18:02:51 收到下发指令:叫号153>>>
2026-05-04 18:02:52 收到下发指令:排队号154>>>
2026-05-04 18:02:52 收到下发指令:叫号154>>>
2026-05-04 18:02:53 收到下发指令:排队号155>>>
2026-05-04 18:02:53 收到下发指令:叫号155>>>
2026-05-04 18:02:54 收到下发指令:排队号156>>>
2026-05-04 18:02:54 收到下发指令:叫号156>>>
2026-05-04 18:02:55 收到下发指令:排队号157>>>
2026-05-04 18:02:55 收到下发指令:叫号157>>>
2026-05-04 18:02:55 收到下发指令:排队号158>>>
2026-05-04 18:02:55 收到下发指令:叫号158>>>
2026-05-04 18:02:56 收到下发指令:排队号159>>>
2026-05-04 18:02:56 收到下发指令:叫号159>>>
2026-05-04 18:02:57 收到下发指令:排队号160>>>
2026-05-04 18:02:57 收到下发指令:叫号160>>>
2026-05-04 18:02:57 收到下发指令:排队号161>>>
2026-05-04 18:02:57 收到下发指令:叫号161>>>
2026-05-04 18:02:57 收到下发指令:排队号162>>>
2026-05-04 18:02:57 收到下发指令:叫号162>>>
2026-05-04 18:02:59 收到下发指令:排队号163>>>
2026-05-04 18:02:59 收到下发指令:叫号163>>>
2026-05-04 18:02:59 收到下发指令:排队号164>>>
2026-05-04 18:02:59 收到下发指令:叫号164>>>
2026-05-04 18:03:00 收到下发指令:排队号165>>>
2026-05-04 18:03:00 收到下发指令:叫号165>>>


===18:04:04===
2026-05-04 18:03:03 收到下发指令:排队号168>>>
2026-05-04 18:03:03 收到下发指令:叫号168>>>
2026-05-04 18:03:04 收到下发指令:排队号169>>>
2026-05-04 18:03:04 收到下发指令:叫号169>>>
2026-05-04 18:03:04 收到下发指令:排队号170>>>
2026-05-04 18:03:05 收到下发指令:叫号170>>>
2026-05-04 18:03:05 收到下发指令:排队号171>>>
2026-05-04 18:03:05 收到下发指令:叫号171>>>
2026-05-04 18:03:06 收到下发指令:排队号172>>>
2026-05-04 18:03:06 收到下发指令:叫号172>>>
2026-05-04 18:03:06 收到下发指令:排队号173>>>
2026-05-04 18:03:06 收到下发指令:叫号173>>>
2026-05-04 18:03:08 收到下发指令:排队号174>>>
2026-05-04 18:03:08 收到下发指令:叫号174>>>
2026-05-04 18:03:08 收到下发指令:排队号175>>>
2026-05-04 18:03:08 收到下发指令:叫号175>>>
2026-05-04 18:03:08 收到下发指令:排队号176>>>
2026-05-04 18:03:09 收到下发指令:叫号176>>>
2026-05-04 18:03:10 收到下发指令:排队号177>>>
2026-05-04 18:03:10 收到下发指令:叫号177>>>
2026-05-04 18:03:10 收到下发指令:排队号178>>>
2026-05-04 18:03:10 收到下发指令:叫号178>>>
2026-05-04 18:03:11 收到下发指令:排队号179>>>
2026-05-04 18:03:11 收到下发指令:叫号179>>>
2026-05-04 18:03:12 收到下发指令:排队号180>>>
2026-05-04 18:03:12 收到下发指令:叫号180>>>
2026-05-04 18:03:12 收到下发指令:排队号181>>>
2026-05-04 18:03:12 收到下发指令:叫号181>>>
2026-05-04 18:03:13 收到下发指令:排队号182>>>
2026-05-04 18:03:13 收到下发指令:叫号182>>>
2026-05-04 18:03:13 收到下发指令:排队号183>>>
2026-05-04 18:03:13 收到下发指令:叫号183>>>
2026-05-04 18:03:14 收到下发指令:排队号184>>>
2026-05-04 18:03:14 收到下发指令:叫号184>>>
2026-05-04 18:03:15 收到下发指令:排队号185>>>
2026-05-04 18:03:15 收到下发指令:叫号185>>>
2026-05-04 18:03:15 收到下发指令:排队号186>>>
2026-05-04 18:03:15 收到下发指令:叫号186>>>
2026-05-04 18:03:16 收到下发指令:排队号187>>>
2026-05-04 18:03:16 收到下发指令:叫号187>>>
2026-05-04 18:03:17 收到下发指令:排队号188>>>
2026-05-04 18:03:17 收到下发指令:叫号188>>>
2026-05-04 18:03:17 收到下发指令:排队号189>>>
2026-05-04 18:03:17 收到下发指令:叫号189>>>
2026-05-04 18:03:18 收到下发指令:排队号190>>>
2026-05-04 18:03:18 收到下发指令:叫号190>>>
2026-05-04 18:03:18 收到下发指令:排队号191>>>
2026-05-04 18:03:18 收到下发指令:叫号191>>>
2026-05-04 18:03:19 收到下发指令:排队号192>>>
2026-05-04 18:03:19 收到下发指令:叫号192>>>
2026-05-04 18:03:19 收到下发指令:排队号193>>>
2026-05-04 18:03:19 收到下发指令:叫号193>>>
2026-05-04 18:03:20 收到下发指令:排队号194>>>
2026-05-04 18:03:20 收到下发指令:叫号194>>>
2026-05-04 18:03:20 收到下发指令:排队号195>>>
2026-05-04 18:03:21 收到下发指令:叫号195>>>
2026-05-04 18:03:21 收到下发指令:排队号196>>>
2026-05-04 18:03:21 收到下发指令:叫号196>>>
2026-05-04 18:03:21 收到下发指令:排队号197>>>
2026-05-04 18:03:21 收到下发指令:叫号197>>>
2026-05-04 18:03:23 收到下发指令:排队号198>>>
2026-05-04 18:03:23 收到下发指令:叫号198>>>
2026-05-04 18:03:23 收到下发指令:排队号199>>>
2026-05-04 18:03:23 收到下发指令:叫号199>>>
2026-05-04 18:03:24 收到下发指令:排队号200>>>
2026-05-04 18:03:24 收到下发指令:叫号200>>>
2026-05-04 18:03:24 收到下发指令:排队号201>>>
2026-05-04 18:03:24 收到下发指令:叫号201>>>
2026-05-04 18:03:25 收到下发指令:排队号202>>>
2026-05-04 18:03:25 收到下发指令:叫号202>>>
2026-05-04 18:03:26 收到下发指令:排队号203>>>
2026-05-04 18:03:26 收到下发指令:叫号203>>>
2026-05-04 18:03:26 收到下发指令:排队号204>>>
2026-05-04 18:03:26 收到下发指令:叫号204>>>
2026-05-04 18:03:26 收到下发指令:排队号205>>>
2026-05-04 18:03:26 收到下发指令:叫号205>>>
2026-05-04 18:03:27 收到下发指令:排队号206>>>
2026-05-04 18:03:27 收到下发指令:叫号206>>>
2026-05-04 18:03:28 收到下发指令:排队号207>>>
2026-05-04 18:03:28 收到下发指令:叫号207>>>
2026-05-04 18:03:28 收到下发指令:排队号208>>>
2026-05-04 18:03:28 收到下发指令:叫号208>>>
2026-05-04 18:03:28 收到下发指令:排队号209>>>
2026-05-04 18:03:28 收到下发指令:叫号209>>>
2026-05-04 18:03:30 收到下发指令:排队号210>>>
2026-05-04 18:03:30 收到下发指令:叫号210>>>
2026-05-04 18:03:30 收到下发指令:排队号211>>>
2026-05-04 18:03:30 收到下发指令:叫号211>>>
2026-05-04 18:03:30 收到下发指令:排队号212>>>
2026-05-04 18:03:30 收到下发指令:叫号212>>>
2026-05-04 18:03:30 收到下发指令:排队号213>>>
2026-05-04 18:03:30 收到下发指令:叫号213>>>
2026-05-04 18:03:30 收到下发指令:排队号nil>>>


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


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


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


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


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


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


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


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


===18:23:06===
2026-05-04 18:22:44>>>cash read=29
2026-05-04 18:22:44 >>>回调事件130,cash_status,20029,退钞中
2026-05-04 18:22:45>>>cash read=00
2026-05-04 18:22:46>>>cash read=3E
2026-05-04 18:22:47>>>cash read=29
2026-05-04 18:22:47 >>>回调事件130,cash_status,20029,退钞中
2026-05-04 18:22:48>>>cash read=3E
2026-05-04 18:22:50>>>cash read=00
2026-05-04 18:22:52>>>cash read=818F42
2026-05-04 18:22:52>>>cash write=02
2026-05-04 18:22:52 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-05-04 18:22:52>>>cash read=10
2026-05-04 18:22:52 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-04 18:22:52 当前产品价格10元，投币10元，打印小票中...
2026-05-04 18:22:52 >>>开始打印,排队号为222,订单号为2605041822520030509911
2026-05-04 18:22:53>>>订单2605041822520030509911写入成功,剩余空间为1679500,占用RAM为634.3916015625
删除未同步订单2605041822520030509911
2026-05-04 18:22:55>>>订单2605041822520030509911删除成功,剩余空间为1680000,占用RAM为643.525390625
检测订单目录中>>>
无未同步订单>>>
2026-05-04 18:22:55 >>>当前Ram内存为615.3095703125
定时检测未同步订单启用[checkOrderNum=536878397]
2026-05-04 18:22:56>>>cash write=0C
2026-05-04 18:22:56>>>cash read=3E


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


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


===18:31:06===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-04 18:30:44 >>>回调事件[910,devices/A0509]
2026-05-04 18:30:44 >>>故障排除日志:上一MQTT订单号缓存列表为2605041829300014676869
2026-05-04 18:30:44 >>>故障排除日志:终端未同步成功订单列表
2026-05-04 18:30:44 开始打印,排队:226,票券:2605041830377591718501,订单:2605041830370073904621,[2026-05-04 18:30:43支付宝支付10元]
2026-05-04 18:30:44>>>MQTT票号同步场景，创建空订单对象
2026-05-04 18:30:44>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-04 18:30:46 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605041830377591718501","queue_number":226,"trade_uid":"2605041830370073904621"}]}
2026-05-04 18:30:46 >>>故障排除日志:删除未同步下发订单成功2605041830370073904621
2026-05-04 18:30:46 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878500]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-04 18:30:59 >>>回调事件[910,devices/A0509]
2026-05-04 18:31:00 >>>故障排除日志:上一MQTT订单号缓存列表为2605041830370073904621
2026-05-04 18:31:00 >>>故障排除日志:终端未同步成功订单列表
2026-05-04 18:31:00 开始打印,排队:227,票券:2605041830559595651801,订单:2605041830550093964436,[2026-05-04 18:30:59支付宝支付10元]
2026-05-04 18:31:00>>>MQTT票号同步场景，创建空订单对象
2026-05-04 18:31:00>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-04 18:31:02 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605041830559595651801","queue_number":227,"trade_uid":"2605041830550093964436"}]}
2026-05-04 18:31:02 >>>故障排除日志:删除未同步下发订单成功2605041830550093964436
2026-05-04 18:31:02 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878512]


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


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


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


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


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


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


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


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


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


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


===19:00:09===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-04 18:59:14 >>>回调事件[910,devices/A0509]
2026-05-04 18:59:14 >>>故障排除日志:上一MQTT订单号缓存列表为2605041857230024902594|2605041857230024902594
2026-05-04 18:59:14 >>>故障排除日志:终端未同步成功订单列表
2026-05-04 18:59:14 开始打印,排队:241,票券:2605041859091692877301,订单:2605041859090014859715,[2026-05-04 18:59:14微信支付10元]
2026-05-04 18:59:14>>>MQTT票号同步场景，创建空订单对象
2026-05-04 18:59:14>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-04 18:59:16 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605041859091692877301","queue_number":241,"trade_uid":"2605041859090014859715"}]}
2026-05-04 18:59:16 >>>故障排除日志:删除未同步下发订单成功2605041859090014859715
2026-05-04 18:59:16 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878866]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-04 18:59:42 >>>回调事件[910,devices/A0509]
2026-05-04 18:59:42 >>>故障排除日志:上一MQTT订单号缓存列表为2605041859090014859715
2026-05-04 18:59:42 >>>故障排除日志:终端未同步成功订单列表
2026-05-04 18:59:42 开始打印,排队:242,票券:2605041859347072841901,订单:2605041859340068120438,[2026-05-04 18:59:42支付宝支付10元]
2026-05-04 18:59:42>>>MQTT票号同步场景，创建空订单对象
2026-05-04 18:59:42>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-04 18:59:44 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605041859347072841901","queue_number":242,"trade_uid":"2605041859340068120438"}]}
2026-05-04 18:59:44 >>>故障排除日志:删除未同步下发订单成功2605041859340068120438
2026-05-04 18:59:44 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878873]


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


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


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


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


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


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


===19:16:10===
2026-05-04 19:15:58>>>cash read=29
2026-05-04 19:15:58 >>>回调事件130,cash_status,20029,退钞中
2026-05-04 19:15:59>>>cash read=01
2026-05-04 19:16:00>>>cash read=3E


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


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


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


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


===19:31:12===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-04 19:30:23 >>>回调事件[910,devices/A0509]
2026-05-04 19:30:23 >>>故障排除日志:上一MQTT订单号缓存列表为2605041925370090542338
2026-05-04 19:30:24 >>>故障排除日志:终端未同步成功订单列表
2026-05-04 19:30:24 开始打印,排队:254,票券:2605041930182064345401,订单:2605041930180018679832,[2026-05-04 19:30:23微信支付10元]
2026-05-04 19:30:24>>>MQTT票号同步场景，创建空订单对象
2026-05-04 19:30:24>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-04 19:30:25 >>>回调事件[910,devices/A0509]
2026-05-04 19:30:25 >>>故障排除日志:上一MQTT订单号缓存列表为2605041930180018679832
2026-05-04 19:30:25 >>>故障排除日志:终端未同步成功订单列表02542605041930180018679832
2026-05-04 19:30:25 开始打印,排队:255,票券:2605041930122374375301,订单:2605041930120021921697,[2026-05-04 19:30:25支付宝支付10元]
已接收过此消息,票券号为2605041930182064345401,排队号为254
2026-05-04 19:30:26>>>MQTT票号同步场景，创建空订单对象
2026-05-04 19:30:26>>>合并MQTT票号列表到订单同步请求,共2张票
2026-05-04 19:30:27 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605041930182064345401","queue_number":254,"trade_uid":"2605041930180018679832"}]}
2026-05-04 19:30:27 >>>故障排除日志:删除未同步下发订单成功2605041930180018679832
2026-05-04 19:30:28 >>>故障排除日志:终端同步成功后剩余订单列表02552605041930120021921697
定时检测未同步订单启用[checkOrderNum=536879250]
2026-05-04 19:30:28>>>删除订单异常:order_uid为空
2026-05-04 19:30:28 >>>当前Ram内存为632.892578125
定时检测已在运行，无需重复启动[checkOrderNum=536879250]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-04 19:31:03 >>>回调事件[910,devices/A0509]
2026-05-04 19:31:03 >>>故障排除日志:上一MQTT订单号缓存列表为2605041930120021921697|2605041930180018679832
2026-05-04 19:31:03 >>>故障排除日志:终端未同步成功订单列表02552605041930120021921697
2026-05-04 19:31:03 开始打印,排队:256,票券:2605041930562375958701,订单:2605041930560021842787,[2026-05-04 19:31:03支付宝支付10元]
2026-05-04 19:31:03>>>MQTT票号同步场景，创建空订单对象
2026-05-04 19:31:04>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-04 19:31:05 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605041930562375958701","queue_number":256,"trade_uid":"2605041930560021842787"}]}
2026-05-04 19:31:05 >>>故障排除日志:删除未同步下发订单成功2605041930560021842787
2026-05-04 19:31:06 >>>故障排除日志:终端同步成功后剩余订单列表02552605041930120021921697
定时检测未同步订单启用[checkOrderNum=536879264]


===19:34:12===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-04 19:33:38 >>>回调事件[910,devices/A0509]
2026-05-04 19:33:38 >>>故障排除日志:上一MQTT订单号缓存列表为2605041930560021842787
2026-05-04 19:33:38 >>>故障排除日志:终端未同步成功订单列表02552605041930120021921697
2026-05-04 19:33:38 开始打印,排队:257,票券:2605041933311739677501,订单:2605041933310015647391,[2026-05-04 19:33:37微信支付10元]
2026-05-04 19:33:38 开始打印,排队:258,票券:2605041933311740333702,订单:2605041933310015647391,[2026-05-04 19:33:37微信支付10元]
2026-05-04 19:33:38>>>MQTT票号同步场景，创建空订单对象
2026-05-04 19:33:38>>>合并MQTT票号列表到订单同步请求,共2张票
2026-05-04 19:33:42 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605041933311739677501","queue_number":257,"trade_uid":"2605041933310015647391"},{"ticket_no":"2605041933311740333702","queue_number":258,"trade_uid":"2605041933310015647391"}]}
2026-05-04 19:33:42 >>>故障排除日志:删除未同步下发订单成功2605041933310015647391
2026-05-04 19:33:42 >>>故障排除日志:删除未同步下发订单成功2605041933310015647391
2026-05-04 19:33:42 >>>故障排除日志:终端同步成功后剩余订单列表02552605041930120021921697
定时检测未同步订单启用[checkOrderNum=536879291]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-04 19:34:02 >>>回调事件[910,devices/A0509]
2026-05-04 19:34:02 >>>故障排除日志:上一MQTT订单号缓存列表为2605041933310015647391|2605041933310015647391
2026-05-04 19:34:02 >>>故障排除日志:终端未同步成功订单列表02552605041930120021921697
2026-05-04 19:34:02 开始打印,排队:259,票券:2605041933534290345701,订单:2605041933530041053129,[2026-05-04 19:34:02微信支付10元]
2026-05-04 19:34:02>>>MQTT票号同步场景，创建空订单对象
2026-05-04 19:34:02>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-04 19:34:04 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605041933534290345701","queue_number":259,"trade_uid":"2605041933530041053129"}]}
2026-05-04 19:34:04 >>>故障排除日志:删除未同步下发订单成功2605041933530041053129
2026-05-04 19:34:04 >>>故障排除日志:终端同步成功后剩余订单列表02552605041930120021921697
定时检测未同步订单启用[checkOrderNum=536879305]


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


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


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


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


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


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


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


===19:53:14===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-04 19:52:49 >>>回调事件[910,devices/A0509]
2026-05-04 19:52:49 >>>故障排除日志:上一MQTT订单号缓存列表为2605041943520036236412
2026-05-04 19:52:49 >>>故障排除日志:终端未同步成功订单列表02552605041930120021921697
2026-05-04 19:52:49 开始打印,排队:268,票券:2605041952432499139201,订单:2605041952430022726132,[2026-05-04 19:52:48微信支付10元]
2026-05-04 19:52:49>>>MQTT票号同步场景，创建空订单对象
2026-05-04 19:52:49>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-04 19:52:51 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605041952432499139201","queue_number":268,"trade_uid":"2605041952430022726132"}]}
2026-05-04 19:52:51 >>>故障排除日志:删除未同步下发订单成功2605041952430022726132
2026-05-04 19:52:51 >>>故障排除日志:终端同步成功后剩余订单列表02552605041930120021921697
定时检测未同步订单启用[checkOrderNum=536879532]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-04 19:52:51 >>>回调事件[910,devices/A0509]
2026-05-04 19:52:51 >>>故障排除日志:上一MQTT订单号缓存列表为2605041952430022726132
2026-05-04 19:52:51 >>>故障排除日志:终端未同步成功订单列表02552605041930120021921697
2026-05-04 19:52:51 开始打印,排队:269,票券:2605041952444802478301,订单:2605041952440046136364,[2026-05-04 19:52:51微信支付10元]
2026-05-04 19:52:51>>>MQTT票号同步场景，创建空订单对象
2026-05-04 19:52:51>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-04 19:52:53 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605041952444802478301","queue_number":269,"trade_uid":"2605041952440046136364"}]}
2026-05-04 19:52:53 >>>故障排除日志:删除未同步下发订单成功2605041952440046136364
2026-05-04 19:52:53 >>>故障排除日志:终端同步成功后剩余订单列表02552605041930120021921697
定时检测未同步订单启用[checkOrderNum=536879538]


===19:57:15===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-04 19:56:41 收到下发指令:排队号214>>>
2026-05-04 19:56:41 收到下发指令:叫号214>>>
2026-05-04 19:56:45 收到下发指令:排队号214>>>
2026-05-04 19:56:45 收到下发指令:叫号214>>>
2026-05-04 19:56:49 收到下发指令:排队号214>>>
2026-05-04 19:56:49 收到下发指令:叫号214>>>
2026-05-04 19:56:53 收到下发指令:排队号214>>>
2026-05-04 19:56:53 收到下发指令:叫号214>>>
2026-05-04 19:56:57 收到下发指令:排队号214>>>
2026-05-04 19:56:57 收到下发指令:叫号214>>>
2026-05-04 19:57:01 收到下发指令:排队号214>>>
2026-05-04 19:57:01 收到下发指令:叫号214>>>
2026-05-04 19:57:05 收到下发指令:排队号214>>>
2026-05-04 19:57:05 收到下发指令:叫号214>>>
2026-05-04 19:57:09 收到下发指令:排队号214>>>
2026-05-04 19:57:09 收到下发指令:叫号214>>>
2026-05-04 19:57:12 收到下发指令:排队号214>>>
2026-05-04 19:57:12 收到下发指令:叫号214>>>


===19:58:15===
2026-05-04 19:57:16 收到下发指令:排队号214>>>
2026-05-04 19:57:16 收到下发指令:叫号214>>>
2026-05-04 19:57:19 收到下发指令:排队号214>>>
2026-05-04 19:57:19 收到下发指令:叫号214>>>
2026-05-04 19:57:24 收到下发指令:排队号214>>>
2026-05-04 19:57:24 收到下发指令:叫号214>>>
2026-05-04 19:57:27 收到下发指令:排队号214>>>
2026-05-04 19:57:27 收到下发指令:叫号214>>>
2026-05-04 19:57:32 收到下发指令:排队号214>>>
2026-05-04 19:57:32 收到下发指令:叫号214>>>
2026-05-04 19:57:36 收到下发指令:排队号214>>>
2026-05-04 19:57:36 收到下发指令:叫号214>>>
2026-05-04 19:57:41 收到下发指令:排队号214>>>
2026-05-04 19:57:41 收到下发指令:叫号214>>>
2026-05-04 19:57:45 收到下发指令:排队号214>>>
2026-05-04 19:57:45 收到下发指令:叫号214>>>
2026-05-04 19:57:49 收到下发指令:排队号214>>>
2026-05-04 19:57:49 收到下发指令:叫号214>>>
2026-05-04 19:57:54 收到下发指令:排队号214>>>
2026-05-04 19:57:54 收到下发指令:叫号214>>>
2026-05-04 19:57:57 收到下发指令:排队号214>>>
2026-05-04 19:57:57 收到下发指令:叫号214>>>
2026-05-04 19:58:01 收到下发指令:排队号214>>>
2026-05-04 19:58:01 收到下发指令:叫号214>>>
2026-05-04 19:58:05 收到下发指令:排队号214>>>
2026-05-04 19:58:05 收到下发指令:叫号214>>>
2026-05-04 19:58:09 收到下发指令:排队号214>>>
2026-05-04 19:58:09 收到下发指令:叫号214>>>
2026-05-04 19:58:12 收到下发指令:排队号214>>>
2026-05-04 19:58:13 收到下发指令:叫号214>>>


===19:59:15===
2026-05-04 19:58:17 收到下发指令:排队号214>>>
2026-05-04 19:58:17 收到下发指令:叫号214>>>
2026-05-04 19:58:21 收到下发指令:排队号214>>>
2026-05-04 19:58:21 收到下发指令:叫号214>>>
2026-05-04 19:58:24 收到下发指令:排队号214>>>
2026-05-04 19:58:24 收到下发指令:叫号214>>>
2026-05-04 19:58:36 收到下发指令:排队号214>>>
2026-05-04 19:58:36 收到下发指令:叫号214>>>
2026-05-04 19:59:10 >>>回调事件[910,devices/A0509]
2026-05-04 19:59:10 >>>故障排除日志:上一MQTT订单号缓存列表为2605041952440046136364
2026-05-04 19:59:10 >>>故障排除日志:终端未同步成功订单列表02552605041930120021921697
2026-05-04 19:59:10 开始打印,排队:270,票券:2605041959031027549401,订单:2605041959030008237681,[2026-05-04 19:59:10微信支付10元]
2026-05-04 19:59:10>>>MQTT票号同步场景，创建空订单对象
2026-05-04 19:59:10>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-04 19:59:12 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605041959031027549401","queue_number":270,"trade_uid":"2605041959030008237681"}]}
2026-05-04 19:59:12 >>>故障排除日志:删除未同步下发订单成功2605041959030008237681
2026-05-04 19:59:12 >>>故障排除日志:终端同步成功后剩余订单列表02552605041930120021921697
定时检测未同步订单启用[checkOrderNum=536879690]


===20:00:15===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-04 19:59:23 收到下发指令:排队号216>>>
2026-05-04 19:59:23 收到下发指令:叫号216>>>
2026-05-04 19:59:24 收到下发指令:排队号218>>>
2026-05-04 19:59:24 收到下发指令:叫号218>>>
2026-05-04 19:59:25 收到下发指令:排队号220>>>
2026-05-04 19:59:25 收到下发指令:叫号220>>>
2026-05-04 19:59:26 收到下发指令:排队号222>>>
2026-05-04 19:59:26 收到下发指令:叫号222>>>
2026-05-04 19:59:27 收到下发指令:排队号224>>>
2026-05-04 19:59:27 收到下发指令:叫号224>>>
2026-05-04 19:59:28 收到下发指令:排队号226>>>
2026-05-04 19:59:28 收到下发指令:叫号226>>>
2026-05-04 19:59:28 收到下发指令:排队号228>>>
2026-05-04 19:59:28 收到下发指令:叫号228>>>
2026-05-04 19:59:29 收到下发指令:排队号230>>>
2026-05-04 19:59:29 收到下发指令:叫号230>>>
2026-05-04 19:59:30 收到下发指令:排队号232>>>
2026-05-04 19:59:30 收到下发指令:叫号232>>>
2026-05-04 19:59:30 收到下发指令:排队号234>>>
2026-05-04 19:59:30 收到下发指令:叫号234>>>
2026-05-04 19:59:31 收到下发指令:排队号236>>>
2026-05-04 19:59:31 收到下发指令:叫号236>>>
2026-05-04 19:59:32 收到下发指令:排队号238>>>
2026-05-04 19:59:32 收到下发指令:叫号238>>>
2026-05-04 19:59:32 收到下发指令:排队号239>>>
2026-05-04 19:59:32 收到下发指令:叫号239>>>
2026-05-04 19:59:33 收到下发指令:排队号243>>>
2026-05-04 19:59:33 收到下发指令:叫号243>>>
2026-05-04 19:59:34 收到下发指令:排队号245>>>
2026-05-04 19:59:34 收到下发指令:叫号245>>>
2026-05-04 19:59:34 收到下发指令:排队号246>>>
2026-05-04 19:59:34 收到下发指令:叫号246>>>
2026-05-04 19:59:35 收到下发指令:排队号250>>>
2026-05-04 19:59:35 收到下发指令:叫号250>>>
2026-05-04 19:59:35 收到下发指令:排队号252>>>
2026-05-04 19:59:35 收到下发指令:叫号252>>>
2026-05-04 19:59:35 收到下发指令:排队号255>>>
2026-05-04 19:59:35 收到下发指令:叫号255>>>
2026-05-04 19:59:35 收到下发指令:排队号256>>>
2026-05-04 19:59:35 收到下发指令:叫号256>>>
2026-05-04 19:59:36 收到下发指令:排队号259>>>
2026-05-04 19:59:36 收到下发指令:叫号259>>>
2026-05-04 19:59:37 收到下发指令:排队号262>>>
2026-05-04 19:59:37 收到下发指令:叫号262>>>
2026-05-04 19:59:38 收到下发指令:排队号263>>>
2026-05-04 19:59:38 收到下发指令:叫号263>>>
2026-05-04 19:59:38 收到下发指令:排队号264>>>
2026-05-04 19:59:38 收到下发指令:叫号264>>>
2026-05-04 19:59:40 收到下发指令:排队号266>>>
2026-05-04 19:59:40 收到下发指令:叫号266>>>
2026-05-04 19:59:40 收到下发指令:排队号267>>>
2026-05-04 19:59:40 收到下发指令:叫号267>>>
2026-05-04 19:59:40 收到下发指令:排队号269>>>
2026-05-04 19:59:40 收到下发指令:叫号269>>>
2026-05-04 19:59:41 收到下发指令:排队号270>>>
2026-05-04 19:59:41 收到下发指令:叫号270>>>


===20:03:16===
2026-05-04 20:02:25 收到下发指令:排队号nil>>>


===20:04:16===
2026-05-04 20:03:34 >>>回调事件[910,devices/A0509]
2026-05-04 20:03:34 >>>故障排除日志:上一MQTT订单号缓存列表为2605041959030008237681
2026-05-04 20:03:34 >>>故障排除日志:终端未同步成功订单列表02552605041930120021921697
2026-05-04 20:03:34 开始打印,排队:271,票券:2605042003279089936101,订单:2605042003270088857397,[2026-05-04 20:03:34微信支付10元]
2026-05-04 20:03:34>>>MQTT票号同步场景，创建空订单对象
2026-05-04 20:03:34>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-04 20:03:36 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605042003279089936101","queue_number":271,"trade_uid":"2605042003270088857397"}]}
2026-05-04 20:03:36 >>>故障排除日志:删除未同步下发订单成功2605042003270088857397
2026-05-04 20:03:36 >>>故障排除日志:终端同步成功后剩余订单列表02552605041930120021921697
定时检测未同步订单启用[checkOrderNum=536879739]


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


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


===20:14:16===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-04 20:13:29 >>>回调事件[910,devices/A0509]
2026-05-04 20:13:29 >>>故障排除日志:上一MQTT订单号缓存列表为2605042012110067152342
2026-05-04 20:13:29 >>>故障排除日志:终端未同步成功订单列表02552605041930120021921697
2026-05-04 20:13:29 开始打印,排队:275,票券:2605042013229276963801,订单:2605042013220090730252,[2026-05-04 20:13:29微信支付10元]
2026-05-04 20:13:29>>>MQTT票号同步场景，创建空订单对象
2026-05-04 20:13:29>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-04 20:13:31 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605042013229276963801","queue_number":275,"trade_uid":"2605042013220090730252"}]}
2026-05-04 20:13:31 >>>故障排除日志:删除未同步下发订单成功2605042013220090730252
2026-05-04 20:13:31 >>>故障排除日志:终端同步成功后剩余订单列表02552605041930120021921697
定时检测未同步订单启用[checkOrderNum=536879858]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-04 20:13:46 >>>回调事件[910,devices/A0509]
2026-05-04 20:13:46 >>>故障排除日志:上一MQTT订单号缓存列表为2605042013220090730252
2026-05-04 20:13:46 >>>故障排除日志:终端未同步成功订单列表02552605041930120021921697
2026-05-04 20:13:46 开始打印,排队:276,票券:2605042013391652114701,订单:2605042013390014715815,[2026-05-04 20:13:46微信支付10元]
2026-05-04 20:13:47>>>MQTT票号同步场景，创建空订单对象
2026-05-04 20:13:47>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-04 20:13:48 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605042013391652114701","queue_number":276,"trade_uid":"2605042013390014715815"}]}
2026-05-04 20:13:48 >>>故障排除日志:删除未同步下发订单成功2605042013390014715815
2026-05-04 20:13:48 >>>故障排除日志:终端同步成功后剩余订单列表02552605041930120021921697
定时检测未同步订单启用[checkOrderNum=536879865]


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


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


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


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


===20:32:17===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-04 20:31:21 >>>回调事件[910,devices/A0509]
2026-05-04 20:31:22 >>>故障排除日志:上一MQTT订单号缓存列表为2605042023230035815079
2026-05-04 20:31:22 >>>故障排除日志:终端未同步成功订单列表02552605041930120021921697
2026-05-04 20:31:22 开始打印,排队:283,票券:2605042031119775466401,订单:2605042031110095401286,[2026-05-04 20:31:21微信支付10元]
2026-05-04 20:31:22>>>MQTT票号同步场景，创建空订单对象
2026-05-04 20:31:22>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-04 20:31:23 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605042031119775466401","queue_number":283,"trade_uid":"2605042031110095401286"}]}
2026-05-04 20:31:23 >>>故障排除日志:删除未同步下发订单成功2605042031110095401286
2026-05-04 20:31:24 >>>故障排除日志:终端同步成功后剩余订单列表02552605041930120021921697
定时检测未同步订单启用[checkOrderNum=536880078]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-04 20:31:38 收到下发指令:排队号271>>>
2026-05-04 20:31:38 收到下发指令:叫号271>>>
2026-05-04 20:31:42 收到下发指令:排队号271>>>
2026-05-04 20:31:42 收到下发指令:叫号271>>>
2026-05-04 20:31:47 收到下发指令:排队号271>>>
2026-05-04 20:31:47 收到下发指令:叫号271>>>
2026-05-04 20:31:51 收到下发指令:排队号271>>>
2026-05-04 20:31:51 收到下发指令:叫号271>>>
2026-05-04 20:31:55 收到下发指令:排队号271>>>
2026-05-04 20:31:55 收到下发指令:叫号271>>>
2026-05-04 20:31:59 收到下发指令:排队号271>>>
2026-05-04 20:31:59 收到下发指令:叫号271>>>


===20:34:17===
2026-05-04 20:33:56 >>>回调事件[910,devices/A0509]
2026-05-04 20:33:56 >>>故障排除日志:上一MQTT订单号缓存列表为2605042031110095401286
2026-05-04 20:33:56 >>>故障排除日志:终端未同步成功订单列表02552605041930120021921697
2026-05-04 20:33:56 开始打印,排队:284,票券:2605042033478881119601,订单:2605042033470086907027,[2026-05-04 20:33:56微信支付10元]
2026-05-04 20:33:56>>>MQTT票号同步场景，创建空订单对象
2026-05-04 20:33:56>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-04 20:33:58 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605042033478881119601","queue_number":284,"trade_uid":"2605042033470086907027"}]}
2026-05-04 20:33:58 >>>故障排除日志:删除未同步下发订单成功2605042033470086907027
2026-05-04 20:33:58 >>>故障排除日志:终端同步成功后剩余订单列表02552605041930120021921697
定时检测未同步订单启用[checkOrderNum=536880123]


===20:35:18===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-04 20:35:08 收到下发指令:排队号273>>>
2026-05-04 20:35:08 收到下发指令:叫号273>>>
2026-05-04 20:35:08 收到下发指令:排队号275>>>
2026-05-04 20:35:09 收到下发指令:叫号275>>>
2026-05-04 20:35:09 收到下发指令:排队号276>>>
2026-05-04 20:35:09 收到下发指令:叫号276>>>
2026-05-04 20:35:10 收到下发指令:排队号279>>>
2026-05-04 20:35:10 收到下发指令:叫号279>>>
2026-05-04 20:35:11 收到下发指令:排队号281>>>
2026-05-04 20:35:11 收到下发指令:叫号281>>>
2026-05-04 20:35:12 收到下发指令:排队号283>>>
2026-05-04 20:35:12 收到下发指令:叫号283>>>
2026-05-04 20:35:12 收到下发指令:排队号284>>>
2026-05-04 20:35:12 收到下发指令:叫号284>>>


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


===20:39:18===
2026-05-04 20:38:51 收到下发指令:排队号nil>>>


===20:44:18===
2026-05-04 20:43:30 >>>回调事件[910,devices/A0509]
2026-05-04 20:43:30 >>>故障排除日志:上一MQTT订单号缓存列表为2605042035460048545336
2026-05-04 20:43:30 >>>故障排除日志:终端未同步成功订单列表02552605041930120021921697
2026-05-04 20:43:30 开始打印,排队:286,票券:2605042043271591625101,订单:2605042043270013672838,[2026-05-04 20:43:30支付宝支付10元]
2026-05-04 20:43:30>>>MQTT票号同步场景，创建空订单对象
2026-05-04 20:43:30>>>合并MQTT票号列表到订单同步请求,共1张票
2026-05-04 20:43:32 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2605042043271591625101","queue_number":286,"trade_uid":"2605042043270013672838"}]}
2026-05-04 20:43:32 >>>故障排除日志:删除未同步下发订单成功2605042043270013672838
2026-05-04 20:43:32 >>>故障排除日志:终端同步成功后剩余订单列表02552605041930120021921697
定时检测未同步订单启用[checkOrderNum=536880235]


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


===20:55:19===
2026-05-04 20:54:33>>>cash read=00
2026-05-04 20:54:34>>>cash read=818F42
2026-05-04 20:54:34>>>cash write=02
2026-05-04 20:54:34 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-05-04 20:54:34>>>cash read=10
2026-05-04 20:54:34 >>>回调事件130,10,10023,finish Money=10,进钞完成
2026-05-04 20:54:34 当前产品价格10元，投币10元，打印小票中...
2026-05-04 20:54:34 >>>开始打印,排队号为288,订单号为2605042054340030509217
2026-05-04 20:54:34>>>订单2605042054340030509217写入成功,剩余空间为1680000,占用RAM为628.287109375
2026-05-04 20:54:36>>>cash read=818F42
2026-05-04 20:54:36 >>>回调事件130,cash_status,10022,进钞中...read money=10
删除未同步订单2605042054340030509217
2026-05-04 20:54:36>>>订单2605042054340030509217删除成功,剩余空间为1680500,占用RAM为627.4208984375
检测订单目录中>>>
无未同步订单>>>
2026-05-04 20:54:37 >>>当前Ram内存为613.21484375
定时检测未同步订单启用[checkOrderNum=536880354]
2026-05-04 20:54:37>>>cash read=10
2026-05-04 20:54:37 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-04 20:54:37 当前产品价格10元，投币10元，打印小票中...
2026-05-04 20:54:37 >>>开始打印,排队号为289,订单号为2605042054370030509875
2026-05-04 20:54:37>>>订单2605042054370030509875写入成功,剩余空间为1679000,占用RAM为634.6474609375
2026-05-04 20:54:39>>>cash read=818F42
2026-05-04 20:54:39 >>>回调事件130,cash_status,10022,进钞中...read money=10
删除未同步订单2605042054370030509875
2026-05-04 20:54:39>>>订单2605042054370030509875删除成功,剩余空间为1679500,占用RAM为632.09765625
检测订单目录中>>>
无未同步订单>>>
2026-05-04 20:54:39 >>>当前Ram内存为614.6552734375
定时检测未同步订单启用[checkOrderNum=536880361]
2026-05-04 20:54:40>>>cash read=10
2026-05-04 20:54:40 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-04 20:54:40 当前产品价格10元，投币10元，打印小票中...
2026-05-04 20:54:40 >>>开始打印,排队号为290,订单号为2605042054400030509770
2026-05-04 20:54:40>>>订单2605042054400030509770写入成功,剩余空间为1678000,占用RAM为642.2353515625
删除未同步订单2605042054400030509770
2026-05-04 20:54:42>>>订单2605042054400030509770删除成功,剩余空间为1679000,占用RAM为646.7783203125
检测订单目录中>>>
无未同步订单>>>
2026-05-04 20:54:42 >>>当前Ram内存为616.16015625
定时检测未同步订单启用[checkOrderNum=536880368]
2026-05-04 20:54:43>>>cash write=0C
2026-05-04 20:54:43>>>cash read=00
2026-05-04 20:54:44>>>cash read=818F42
2026-05-04 20:54:44>>>cash write=02
2026-05-04 20:54:44 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-05-04 20:54:45>>>cash read=10
2026-05-04 20:54:45 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-04 20:54:45 当前产品价格10元，投币10元，打印小票中...
2026-05-04 20:54:45 >>>开始打印,排队号为291,订单号为2605042054450030509734
2026-05-04 20:54:45>>>订单2605042054450030509734写入成功,剩余空间为1677000,占用RAM为649.599609375
删除未同步订单2605042054450030509734
2026-05-04 20:54:47>>>订单2605042054450030509734删除成功,剩余空间为1677500,占用RAM为651.5908203125
检测订单目录中>>>
无未同步订单>>>
2026-05-04 20:54:47 >>>当前Ram内存为617.701171875
定时检测未同步订单启用[checkOrderNum=536880375]
2026-05-04 20:54:48>>>cash write=0C
2026-05-04 20:54:49>>>cash read=00818F42
2026-05-04 20:54:49>>>cash write=02
2026-05-04 20:54:49 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-05-04 20:54:49>>>cash read=10
2026-05-04 20:54:49 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-05-04 20:54:49 当前产品价格10元，投币10元，打印小票中...
2026-05-04 20:54:49 >>>开始打印,排队号为292,订单号为2605042054490030509544
2026-05-04 20:54:50>>>订单2605042054490030509544写入成功,剩余空间为1676000,占用RAM为657.9521484375
2026-05-04 20:54:51>>>cash read=818F42
2026-05-04 20:54:51 >>>回调事件130,cash_status,10022,进钞中...read money=10
删除未同步订单2605042054490030509544
2026-05-04 20:54:52>>>订单2605042054490030509544删除成功,剩余空间为1676500,占用RAM为640.9521484375
检测订单目录中>>>
无未同步订单>>>
2026-05-04 20:54:52 >>>当前Ram内存为618.5458984375
定时检测未同步订单启用[checkOrderNum=536880383]
2026-05-04 20:54:52>>>cash read=10
2026-05-04 20:54:52 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]