TLClient_JSSCOM_LuatOS-Air_V4010_RDA8910_RFTTS_0xe0000,2.8.6,863482065027118,32489835198706,
poweron reason:0

===07:56:23===
上一时间戳为1777247998
隔日重置时间戳true
隔日清空未同步下发列表true
当前排队号为1,音量为5
初始化产品信息:[{"time_limit_date":"","ticket_category":"0","expiry_date":3,"product_detail":"","time_limit_status":"0","begin_minute":"00","product_uid":"12710657366789465785","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:92d98****6f7da
纸币器设置接收纸币范围为36
欢迎使用天羚自助售票系统[2.8.6]
定时检测未同步订单启用[checkOrderNum=536870969]
2026-04-28 07:55:23>>>cash write=30
2026-04-28 07:55:23>>>cash write=02
2026-04-28 07:55:23>>>cash write=3E
2026-04-28 07:55:23>>>cash read=808F808F
系统时间初始化成功，时间为202642875523
2026-04-28 07:55:24>>>cash write=02
2026-04-28 07:55:24 >>>剩余flash空间=1680000,占用RAM为657.7021484375
2026-04-28 07:55:24 >>>回调事件:910,subscribe,10000,连接服务器成功

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

2026-04-28 07:55:27>>>cash write=0C
2026-04-28 07:55:27>>>cash read=3E
流量卡还有337天过期
2026-04-28 07:55:35 >>>当前Ram内存为662.4921875


===08:01:24===
2026-04-28 08:00:32>>>cash read=00
2026-04-28 08:00:33>>>cash read=29
2026-04-28 08:00:33 >>>回调事件130,cash_status,20029,退钞中
2026-04-28 08:00:34>>>cash read=2F29
2026-04-28 08:00:35>>>cash read=01
2026-04-28 08:00:39>>>cash read=2F
2026-04-28 08:00:40>>>cash read=29
2026-04-28 08:00:40 >>>回调事件130,cash_status,20029,退钞中
2026-04-28 08:00:41>>>cash read=3E
2026-04-28 08:00:42>>>cash read=2F29
2026-04-28 08:00:43>>>cash read=01
2026-04-28 08:00:44>>>cash read=2F
2026-04-28 08:00:45>>>cash read=00
2026-04-28 08:00:46>>>cash read=01
2026-04-28 08:00:47>>>cash read=3E
2026-04-28 08:00:49>>>cash read=29
2026-04-28 08:00:49 >>>回调事件130,cash_status,20029,退钞中
2026-04-28 08:00:50>>>cash read=2F29
2026-04-28 08:00:51>>>cash read=01
2026-04-28 08:00:51>>>cash read=2F
2026-04-28 08:00:52>>>cash read=3E
2026-04-28 08:00:56>>>cash read=00
2026-04-28 08:00:56>>>cash read=818F42
2026-04-28 08:00:56>>>cash write=02
2026-04-28 08:00:56 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-28 08:00:56>>>cash read=10
2026-04-28 08:00:56 >>>回调事件130,10,10023,finish Money=10,进钞完成
当日首次设置时间戳true为1777334456
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-28 08:00:56 当前产品价格10元，投币10元，打印小票中...
2026-04-28 08:00:56 >>>开始打印,排队号为1,订单号为2604280800560023222489
2026-04-28 08:00:57>>>订单2604280800560023222489写入成功,剩余空间为1679000,占用RAM为639.544921875
删除未同步订单2604280800560023222489
2026-04-28 08:00:59>>>订单2604280800560023222489删除成功,剩余空间为1679500,占用RAM为645.58203125
检测订单目录中>>>
无未同步订单>>>
2026-04-28 08:00:59 >>>当前Ram内存为616.5439453125
定时检测未同步订单启用[checkOrderNum=536871034]
2026-04-28 08:01:00>>>cash write=0C
2026-04-28 08:01:00>>>cash read=3E


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


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


===08:26:25===
2026-04-28 08:25:43>>>cash read=00
2026-04-28 08:25:44>>>cash read=29
2026-04-28 08:25:44 >>>回调事件130,cash_status,20029,退钞中
2026-04-28 08:25:44>>>cash read=2F29
2026-04-28 08:25:45>>>cash read=01
2026-04-28 08:25:45>>>cash read=2F
2026-04-28 08:25:46>>>cash read=3E
2026-04-28 08:25:48>>>cash read=2F29
2026-04-28 08:25:49>>>cash read=01
2026-04-28 08:25:51>>>cash read=2F
2026-04-28 08:25:52>>>cash read=3E
2026-04-28 08:25:55>>>cash read=00
2026-04-28 08:25:55>>>cash read=818F42
2026-04-28 08:25:55>>>cash write=02
2026-04-28 08:25:55 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-28 08:25:56>>>cash read=10
2026-04-28 08:25:56 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-28 08:25:56 当前产品价格10元，投币10元，打印小票中...
2026-04-28 08:25:56 >>>开始打印,排队号为4,订单号为2604280825560023222738
2026-04-28 08:25:56>>>订单2604280825560023222738写入成功,剩余空间为1679500,占用RAM为638.2529296875
删除未同步订单2604280825560023222738
2026-04-28 08:25:58>>>订单2604280825560023222738删除成功,剩余空间为1680000,占用RAM为646.4423828125
检测订单目录中>>>
无未同步订单>>>
2026-04-28 08:25:58 >>>当前Ram内存为618.09375
定时检测未同步订单启用[checkOrderNum=536871283]
2026-04-28 08:25:59>>>cash write=0C
2026-04-28 08:25:59>>>cash read=3E
2026-04-28 08:26:01>>>cash read=00
2026-04-28 08:26:02>>>cash read=818F42
2026-04-28 08:26:02>>>cash write=02
2026-04-28 08:26:02 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-28 08:26:03>>>cash read=10
2026-04-28 08:26:03 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-28 08:26:03 当前产品价格10元，投币10元，打印小票中...
2026-04-28 08:26:03 >>>开始打印,排队号为5,订单号为2604280826030023222444
2026-04-28 08:26:03>>>订单2604280826030023222444写入成功,剩余空间为1678000,占用RAM为645.404296875
删除未同步订单2604280826030023222444
2026-04-28 08:26:05>>>订单2604280826030023222444删除成功,剩余空间为1679000,占用RAM为649.84765625
检测订单目录中>>>
无未同步订单>>>
2026-04-28 08:26:06 >>>当前Ram内存为618.5458984375
定时检测未同步订单启用[checkOrderNum=536871293]
2026-04-28 08:26:06>>>cash write=0C
2026-04-28 08:26:07>>>cash read=3E


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


===08:33:25===
2026-04-28 08:32:38>>>cash read=00
2026-04-28 08:32:39>>>cash read=01
2026-04-28 08:32:44>>>cash read=2F29
2026-04-28 08:32:45>>>cash read=01
2026-04-28 08:32:50>>>cash read=2F
2026-04-28 08:32:52>>>cash read=3E
2026-04-28 08:32:56>>>cash read=2F29
2026-04-28 08:32:57>>>cash read=01
2026-04-28 08:33:01>>>cash read=2F
2026-04-28 08:33:02>>>cash read=3E
2026-04-28 08:33:04>>>cash read=00
2026-04-28 08:33:05>>>cash read=29
2026-04-28 08:33:05 >>>回调事件130,cash_status,20029,退钞中
2026-04-28 08:33:06>>>cash read=2F29
2026-04-28 08:33:07>>>cash read=01
2026-04-28 08:33:07>>>cash read=2F
2026-04-28 08:33:09>>>cash read=00
2026-04-28 08:33:10>>>cash read=818F42
2026-04-28 08:33:10>>>cash write=02
2026-04-28 08:33:10 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-28 08:33:10>>>cash read=10
2026-04-28 08:33:10 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-28 08:33:10 当前产品价格10元，投币10元，打印小票中...
2026-04-28 08:33:10 >>>开始打印,排队号为7,订单号为2604280833100023222743
2026-04-28 08:33:10>>>订单2604280833100023222743写入成功,剩余空间为1679000,占用RAM为637.4765625
删除未同步订单2604280833100023222743
2026-04-28 08:33:12>>>订单2604280833100023222743删除成功,剩余空间为1680000,占用RAM为646.875
检测订单目录中>>>
无未同步订单>>>
2026-04-28 08:33:13 >>>当前Ram内存为618.158203125
定时检测未同步订单启用[checkOrderNum=536871373]
2026-04-28 08:33:14>>>cash write=0C
2026-04-28 08:33:14>>>cash read=3E


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


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


===08:42:26===
2026-04-28 08:41:40>>>cash read=00
2026-04-28 08:41:41>>>cash read=818F42
2026-04-28 08:41:41>>>cash write=02
2026-04-28 08:41:42 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-28 08:41:42>>>cash read=10
2026-04-28 08:41:42 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-28 08:41:42 当前产品价格10元，投币10元，打印小票中...
2026-04-28 08:41:42 >>>开始打印,排队号为10,订单号为2604280841420023222478
2026-04-28 08:41:42>>>订单2604280841420023222478写入成功,剩余空间为1679500,占用RAM为635.6328125
删除未同步订单2604280841420023222478
2026-04-28 08:41:44>>>订单2604280841420023222478删除成功,剩余空间为1680500,占用RAM为645.20703125
检测订单目录中>>>
无未同步订单>>>
2026-04-28 08:41:44 >>>当前Ram内存为617.5625
定时检测未同步订单启用[checkOrderNum=536871478]
2026-04-28 08:41:45>>>cash write=0C
2026-04-28 08:41:45>>>cash read=3E


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


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


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


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


===09:13:27===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-28 09:12:41 >>>回调事件[910,devices/S3222]
2026-04-28 09:12:41 >>>故障排除日志:上一MQTT订单号缓存列表为2604280901260039120169
2026-04-28 09:12:41 >>>故障排除日志:终端未同步成功订单列表
2026-04-28 09:12:41 开始打印,排队:15,票券:2604280912314456508701,订单:2604280912310042400973,[2026-04-28 09:12:40微信支付10元]
2026-04-28 09:12:41>>>MQTT票号同步场景，创建空订单对象
2026-04-28 09:12:41>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-28 09:12:43 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604280912314456508701","queue_number":15,"trade_uid":"2604280912310042400973"}]}
2026-04-28 09:12:43 >>>故障排除日志:删除未同步下发订单成功2604280912310042400973
2026-04-28 09:12:43 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536871798]
2026-04-28 09:13:15>>>cash read=00
2026-04-28 09:13:16>>>cash read=818F42
2026-04-28 09:13:16>>>cash write=02
2026-04-28 09:13:16 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-28 09:13:16>>>cash read=10
2026-04-28 09:13:16 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-28 09:13:16 当前产品价格10元，投币10元，打印小票中...
2026-04-28 09:13:16 >>>开始打印,排队号为16,订单号为2604280913160023222249
2026-04-28 09:13:17>>>订单2604280913160023222249写入成功,剩余空间为1678500,占用RAM为640.845703125
删除未同步订单2604280913160023222249
2026-04-28 09:13:19>>>订单2604280913160023222249删除成功,剩余空间为1679500,占用RAM为649.3173828125
检测订单目录中>>>
无未同步订单>>>
2026-04-28 09:13:19 >>>当前Ram内存为617.3232421875
定时检测未同步订单启用[checkOrderNum=536871814]
2026-04-28 09:13:20>>>cash write=0C
2026-04-28 09:13:20>>>cash read=3E


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


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


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


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


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


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


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


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


===10:01:29===
2026-04-28 10:00:28>>>cash write=0C
2026-04-28 10:00:28>>>cash read=3E


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


===10:05:30===
2026-04-28 10:05:04>>>cash read=00
2026-04-28 10:05:05>>>cash read=818F42
2026-04-28 10:05:05>>>cash write=02
2026-04-28 10:05:05 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-28 10:05:05>>>cash read=10
2026-04-28 10:05:05 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-28 10:05:05 当前产品价格10元，投币10元，打印小票中...
2026-04-28 10:05:05 >>>开始打印,排队号为26,订单号为2604281005050023222583
2026-04-28 10:05:05>>>订单2604281005050023222583写入成功,剩余空间为1679500,占用RAM为632.0478515625
删除未同步订单2604281005050023222583
2026-04-28 10:05:07>>>订单2604281005050023222583删除成功,剩余空间为1680500,占用RAM为644.0859375
检测订单目录中>>>
无未同步订单>>>
2026-04-28 10:05:07 >>>当前Ram内存为616.4892578125
定时检测未同步订单启用[checkOrderNum=536872365]
2026-04-28 10:05:08>>>cash write=0C
2026-04-28 10:05:08>>>cash read=3E
2026-04-28 10:05:20>>>cash read=00
2026-04-28 10:05:21>>>cash read=818F4200
2026-04-28 10:05:21>>>cash write=02
2026-04-28 10:05:21 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-28 10:05:21>>>cash read=10
2026-04-28 10:05:21 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-28 10:05:21 当前产品价格10元，投币10元，打印小票中...
2026-04-28 10:05:21 >>>开始打印,排队号为27,订单号为2604281005210023222401
2026-04-28 10:05:22>>>订单2604281005210023222401写入成功,剩余空间为1678500,占用RAM为639.96484375
删除未同步订单2604281005210023222401
2026-04-28 10:05:24>>>订单2604281005210023222401删除成功,剩余空间为1679500,占用RAM为650.87890625
检测订单目录中>>>
无未同步订单>>>
2026-04-28 10:05:24 >>>当前Ram内存为618.07421875
定时检测未同步订单启用[checkOrderNum=536872377]
2026-04-28 10:05:25>>>cash write=0C
2026-04-28 10:05:25>>>cash read=3E


===10:15:30===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-28 10:14:31 >>>回调事件[910,devices/S3222]
2026-04-28 10:14:31 >>>故障排除日志:上一MQTT订单号缓存列表为2604281003300037553989
2026-04-28 10:14:31 >>>故障排除日志:终端未同步成功订单列表
2026-04-28 10:14:31 开始打印,排队:28,票券:2604281014214615534801,订单:2604281014210041964857,[2026-04-28 10:14:30微信支付10元]
2026-04-28 10:14:31>>>MQTT票号同步场景，创建空订单对象
2026-04-28 10:14:31>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-28 10:14:33 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604281014214615534801","queue_number":28,"trade_uid":"2604281014210041964857"}]}
2026-04-28 10:14:33 >>>故障排除日志:删除未同步下发订单成功2604281014210041964857
2026-04-28 10:14:33 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536872466]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-28 10:15:02 >>>回调事件[910,devices/S3222]
2026-04-28 10:15:02 >>>故障排除日志:上一MQTT订单号缓存列表为2604281014210041964857
2026-04-28 10:15:02 >>>故障排除日志:终端未同步成功订单列表
2026-04-28 10:15:02 开始打印,排队:29,票券:2604281014527842704201,订单:2604281014520076661021,[2026-04-28 10:15:01微信支付10元]
2026-04-28 10:15:02>>>MQTT票号同步场景，创建空订单对象
2026-04-28 10:15:02>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-28 10:15:04 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604281014527842704201","queue_number":29,"trade_uid":"2604281014520076661021"}]}
2026-04-28 10:15:04 >>>故障排除日志:删除未同步下发订单成功2604281014520076661021
2026-04-28 10:15:04 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536872475]
2026-04-28 10:15:19>>>cash read=00
2026-04-28 10:15:19>>>cash read=818F42
2026-04-28 10:15:19>>>cash write=02
2026-04-28 10:15:19 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-28 10:15:20>>>cash read=10
2026-04-28 10:15:20 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-28 10:15:20 当前产品价格10元，投币10元，打印小票中...
2026-04-28 10:15:20 >>>开始打印,排队号为30,订单号为2604281015200023222184
2026-04-28 10:15:20>>>订单2604281015200023222184写入成功,剩余空间为1677500,占用RAM为648.6494140625
删除未同步订单2604281015200023222184
2026-04-28 10:15:22>>>订单2604281015200023222184删除成功,剩余空间为1678500,占用RAM为653.8271484375
检测订单目录中>>>
无未同步订单>>>
2026-04-28 10:15:22 >>>当前Ram内存为619.1640625
定时检测未同步订单启用[checkOrderNum=536872488]
2026-04-28 10:15:23>>>cash write=0C
2026-04-28 10:15:23>>>cash read=3E


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


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


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


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


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


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


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


===10:43:32===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-28 10:42:48 >>>回调事件[910,devices/S3222]
2026-04-28 10:42:48 >>>故障排除日志:上一MQTT订单号缓存列表为2604281040070067305621
2026-04-28 10:42:48 >>>故障排除日志:终端未同步成功订单列表
2026-04-28 10:42:48 开始打印,排队:39,票券:2604281042385510884201,订单:2604281042380053212515,[2026-04-28 10:42:47微信支付10元]
2026-04-28 10:42:48>>>MQTT票号同步场景，创建空订单对象
2026-04-28 10:42:48>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-28 10:42:50 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604281042385510884201","queue_number":39,"trade_uid":"2604281042380053212515"}]}
2026-04-28 10:42:50 >>>故障排除日志:删除未同步下发订单成功2604281042380053212515
2026-04-28 10:42:50 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536872804]
2026-04-28 10:43:14>>>cash read=00
2026-04-28 10:43:15>>>cash read=818F4200
2026-04-28 10:43:15>>>cash write=02
2026-04-28 10:43:15 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-28 10:43:15>>>cash read=10
2026-04-28 10:43:15 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-28 10:43:15 当前产品价格10元，投币10元，打印小票中...
2026-04-28 10:43:15 >>>开始打印,排队号为40,订单号为2604281043150023222496
2026-04-28 10:43:15>>>订单2604281043150023222496写入成功,剩余空间为1678500,占用RAM为637.998046875
删除未同步订单2604281043150023222496
2026-04-28 10:43:18>>>订单2604281043150023222496删除成功,剩余空间为1679500,占用RAM为645.990234375
检测订单目录中>>>
无未同步订单>>>
2026-04-28 10:43:18 >>>当前Ram内存为616.552734375
定时检测未同步订单启用[checkOrderNum=536872814]
2026-04-28 10:43:19>>>cash write=0C
2026-04-28 10:43:19>>>cash read=3E


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


===11:03:33===
2026-04-28 11:02:54>>>cash read=0A
2026-04-28 11:02:56>>>cash read=3E


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


===15:14:39===
2026-04-28 15:14:25>>>cash read=2F29
2026-04-28 15:14:27>>>cash read=01
2026-04-28 15:14:30>>>cash read=2F
2026-04-28 15:14:32>>>cash read=29
2026-04-28 15:14:32 >>>回调事件130,cash_status,20029,退钞中
2026-04-28 15:14:33>>>cash read=00
2026-04-28 15:14:34>>>cash read=818F41
2026-04-28 15:14:34>>>cash write=02
2026-04-28 15:14:34 >>>回调事件130,cash_status,10022,进钞中...read money=5
2026-04-28 15:14:34>>>cash read=10
2026-04-28 15:14:34 >>>回调事件130,5,10023,finish Money=5,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-28 15:14:35>>>cash write=0C
2026-04-28 15:14:35>>>cash read=3E


===15:15:39===
2026-04-28 15:14:40>>>cash read=00
2026-04-28 15:14:41>>>cash read=818F41
2026-04-28 15:14:41>>>cash write=02
2026-04-28 15:14:41 >>>回调事件130,cash_status,10022,进钞中...read money=5
2026-04-28 15:14:41>>>cash read=10
2026-04-28 15:14:41 >>>回调事件130,5,10023,finish Money=5,进钞完成
2026-04-28 15:14:41 当前产品价格10元，投币10元，打印小票中...
2026-04-28 15:14:41 >>>开始打印,排队号为65,订单号为2604281514340023222365
2026-04-28 15:14:42>>>订单2604281514340023222365写入成功,剩余空间为1680000,占用RAM为631.8388671875
删除未同步订单2604281514340023222365
2026-04-28 15:14:44>>>订单2604281514340023222365删除成功,剩余空间为1680500,占用RAM为644.111328125
检测订单目录中>>>
无未同步订单>>>
2026-04-28 15:14:44 >>>当前Ram内存为616.6171875
定时检测未同步订单启用[checkOrderNum=536875468]
2026-04-28 15:14:45>>>cash write=0C
2026-04-28 15:14:45>>>cash read=3E


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


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


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


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


===15:58:41===
2026-04-28 15:57:46>>>cash read=00
2026-04-28 15:57:47>>>cash read=29
2026-04-28 15:57:47 >>>回调事件130,cash_status,20029,退钞中
2026-04-28 15:57:47>>>cash read=2F29
2026-04-28 15:57:48>>>cash read=01
2026-04-28 15:57:52>>>cash read=2F
2026-04-28 15:57:53>>>cash read=3E
2026-04-28 15:57:56>>>cash read=00
2026-04-28 15:57:57>>>cash read=2F29
2026-04-28 15:57:58>>>cash read=00
2026-04-28 15:57:59>>>cash read=818F42
2026-04-28 15:57:59>>>cash write=02
2026-04-28 15:57:59 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-28 15:57:59>>>cash read=10
2026-04-28 15:57:59 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-28 15:57:59 当前产品价格10元，投币10元，打印小票中...
2026-04-28 15:57:59 >>>开始打印,排队号为70,订单号为2604281557590023222599
2026-04-28 15:57:59>>>订单2604281557590023222599写入成功,剩余空间为1679500,占用RAM为636.935546875
删除未同步订单2604281557590023222599
2026-04-28 15:58:01>>>订单2604281557590023222599删除成功,剩余空间为1680000,占用RAM为645.5087890625
检测订单目录中>>>
无未同步订单>>>
2026-04-28 15:58:02 >>>当前Ram内存为617.138671875
定时检测未同步订单启用[checkOrderNum=536875897]
2026-04-28 15:58:03>>>cash write=0C
2026-04-28 15:58:03>>>cash read=3E


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


===17:57:45===
2026-04-28 17:57:36>>>cash read=29
2026-04-28 17:57:36 >>>回调事件130,cash_status,20029,退钞中
2026-04-28 17:57:38>>>cash read=01
2026-04-28 17:57:39>>>cash read=3E
2026-04-28 17:57:40>>>cash read=00
2026-04-28 17:57:40>>>cash read=818F42
2026-04-28 17:57:40>>>cash write=02
2026-04-28 17:57:40 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-28 17:57:41>>>cash read=10
2026-04-28 17:57:41 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-28 17:57:41 当前产品价格10元，投币10元，打印小票中...
2026-04-28 17:57:41 >>>开始打印,排队号为91,订单号为2604281757410023222387
2026-04-28 17:57:41>>>订单2604281757410023222387写入成功,剩余空间为1679500,占用RAM为634.037109375
删除未同步订单2604281757410023222387
2026-04-28 17:57:43>>>订单2604281757410023222387删除成功,剩余空间为1680500,占用RAM为643.1474609375
检测订单目录中>>>
无未同步订单>>>
2026-04-28 17:57:43 >>>当前Ram内存为615.2177734375
定时检测未同步订单启用[checkOrderNum=536877143]


===17:58:46===
2026-04-28 17:57:44>>>cash write=0C
2026-04-28 17:57:45>>>cash read=3E


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


===18:02:46===
2026-04-28 18:01:54>>>cash read=01
2026-04-28 18:01:56>>>cash read=3E
2026-04-28 18:01:57>>>cash read=29
2026-04-28 18:01:57 >>>回调事件130,cash_status,20029,退钞中
2026-04-28 18:01:58>>>cash read=3E
2026-04-28 18:02:05>>>cash read=00
2026-04-28 18:02:06>>>cash read=818F41
2026-04-28 18:02:06>>>cash write=02
2026-04-28 18:02:06 >>>回调事件130,cash_status,10022,进钞中...read money=5
2026-04-28 18:02:06>>>cash read=10
2026-04-28 18:02:06 >>>回调事件130,5,10023,finish Money=5,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-28 18:02:07>>>cash write=0C
2026-04-28 18:02:07>>>cash read=3E
2026-04-28 18:02:12>>>cash read=29
2026-04-28 18:02:12 >>>回调事件130,cash_status,20029,退钞中
2026-04-28 18:02:13>>>cash read=01
2026-04-28 18:02:17>>>cash read=3E
2026-04-28 18:02:22>>>cash read=00
2026-04-28 18:02:23>>>cash read=818F41
2026-04-28 18:02:23>>>cash write=02
2026-04-28 18:02:23 >>>回调事件130,cash_status,10022,进钞中...read money=5
2026-04-28 18:02:23>>>cash read=10
2026-04-28 18:02:23 >>>回调事件130,5,10023,finish Money=5,进钞完成
2026-04-28 18:02:23 当前产品价格10元，投币10元，打印小票中...
2026-04-28 18:02:23 >>>开始打印,排队号为93,订单号为2604281802060023222198
2026-04-28 18:02:24>>>订单2604281802060023222198写入成功,剩余空间为1679000,占用RAM为635.546875
删除未同步订单2604281802060023222198
2026-04-28 18:02:26>>>订单2604281802060023222198删除成功,剩余空间为1680000,占用RAM为651.12109375
检测订单目录中>>>
无未同步订单>>>
2026-04-28 18:02:26 >>>当前Ram内存为615.8935546875
定时检测未同步订单启用[checkOrderNum=536877212]
2026-04-28 18:02:27>>>cash write=0C
2026-04-28 18:02:27>>>cash read=3E


===18:08:46===
2026-04-28 18:08:11>>>cash read=00
2026-04-28 18:08:12>>>cash read=818F43
2026-04-28 18:08:12>>>cash write=02
2026-04-28 18:08:12 >>>回调事件130,cash_status,10022,进钞中...read money=20
2026-04-28 18:08:12>>>cash read=10
2026-04-28 18:08:12 >>>回调事件130,20,10023,finish Money=20,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-28 18:08:12 当前产品价格10元，投币20元，打印小票中...
2026-04-28 18:08:12 >>>开始打印,排队号为94,订单号为2604281808120023222751
2026-04-28 18:08:12 >>>开始打印,排队号为95,订单号为2604281808120023222751
2026-04-28 18:08:13>>>订单2604281808120023222751写入成功,剩余空间为1679000,占用RAM为639.95703125
删除未同步订单2604281808120023222751
2026-04-28 18:08:16>>>订单2604281808120023222751删除成功,剩余空间为1680500,占用RAM为656.74609375
检测订单目录中>>>
无未同步订单>>>
2026-04-28 18:08:16 >>>当前Ram内存为616.2216796875
定时检测未同步订单启用[checkOrderNum=536877270]
2026-04-28 18:08:17>>>cash write=0C
2026-04-28 18:08:17>>>cash read=3E


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


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


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


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


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


===18:49:49===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-28 18:49:03 收到下发指令:排队号1>>>
2026-04-28 18:49:03 收到下发指令:叫号1>>>
2026-04-28 18:49:07 收到下发指令:排队号1>>>
2026-04-28 18:49:07 收到下发指令:叫号1>>>
2026-04-28 18:49:12 收到下发指令:排队号1>>>
2026-04-28 18:49:12 收到下发指令:叫号1>>>
2026-04-28 18:49:17 收到下发指令:排队号1>>>
2026-04-28 18:49:17 收到下发指令:叫号1>>>
2026-04-28 18:49:23 收到下发指令:排队号1>>>
2026-04-28 18:49:23 收到下发指令:叫号1>>>
2026-04-28 18:49:26 收到下发指令:排队号1>>>
2026-04-28 18:49:26 收到下发指令:叫号1>>>
2026-04-28 18:49:31 收到下发指令:排队号1>>>
2026-04-28 18:49:31 收到下发指令:叫号1>>>
2026-04-28 18:49:37 收到下发指令:排队号1>>>
2026-04-28 18:49:37 收到下发指令:叫号1>>>
2026-04-28 18:49:46 收到下发指令:排队号1>>>
2026-04-28 18:49:46 收到下发指令:叫号1>>>


===18:50:50===
2026-04-28 18:49:50 收到下发指令:排队号1>>>
2026-04-28 18:49:50 收到下发指令:叫号1>>>
2026-04-28 18:49:55 收到下发指令:排队号1>>>
2026-04-28 18:49:55 收到下发指令:叫号1>>>
2026-04-28 18:50:03 收到下发指令:排队号1>>>
2026-04-28 18:50:03 收到下发指令:叫号1>>>
2026-04-28 18:50:07 收到下发指令:排队号1>>>
2026-04-28 18:50:07 收到下发指令:叫号1>>>
2026-04-28 18:50:12 收到下发指令:排队号1>>>
2026-04-28 18:50:12 收到下发指令:叫号1>>>
2026-04-28 18:50:21 收到下发指令:排队号1>>>
2026-04-28 18:50:21 收到下发指令:叫号1>>>
2026-04-28 18:50:28 收到下发指令:排队号1>>>
2026-04-28 18:50:28 收到下发指令:叫号1>>>
2026-04-28 18:50:34 收到下发指令:排队号1>>>
2026-04-28 18:50:34 收到下发指令:叫号1>>>
2026-04-28 18:50:40 收到下发指令:排队号1>>>
2026-04-28 18:50:40 收到下发指令:叫号1>>>
2026-04-28 18:50:43 收到下发指令:排队号1>>>
2026-04-28 18:50:43 收到下发指令:叫号1>>>


===18:51:50===
2026-04-28 18:50:49 收到下发指令:排队号1>>>
2026-04-28 18:50:49 收到下发指令:叫号1>>>
2026-04-28 18:50:55 收到下发指令:排队号1>>>
2026-04-28 18:50:55 收到下发指令:叫号1>>>
2026-04-28 18:51:02 收到下发指令:排队号1>>>
2026-04-28 18:51:02 收到下发指令:叫号1>>>
2026-04-28 18:51:06 收到下发指令:排队号1>>>
2026-04-28 18:51:06 收到下发指令:叫号1>>>
2026-04-28 18:51:11 收到下发指令:排队号1>>>
2026-04-28 18:51:11 收到下发指令:叫号1>>>
2026-04-28 18:51:16 收到下发指令:排队号1>>>
2026-04-28 18:51:16 收到下发指令:叫号1>>>
2026-04-28 18:51:20 收到下发指令:排队号1>>>
2026-04-28 18:51:20 收到下发指令:叫号1>>>
2026-04-28 18:51:27 收到下发指令:排队号1>>>
2026-04-28 18:51:27 收到下发指令:叫号1>>>
2026-04-28 18:51:36 收到下发指令:排队号1>>>
2026-04-28 18:51:36 收到下发指令:叫号1>>>
2026-04-28 18:51:44 收到下发指令:排队号1>>>
2026-04-28 18:51:44 收到下发指令:叫号1>>>


===18:52:50===
2026-04-28 18:51:50 收到下发指令:排队号1>>>
2026-04-28 18:51:50 收到下发指令:叫号1>>>
2026-04-28 18:51:56 收到下发指令:排队号1>>>
2026-04-28 18:51:56 收到下发指令:叫号1>>>
2026-04-28 18:52:04 收到下发指令:排队号1>>>
2026-04-28 18:52:04 收到下发指令:叫号1>>>
2026-04-28 18:52:10 收到下发指令:排队号2>>>
2026-04-28 18:52:10 收到下发指令:叫号2>>>
2026-04-28 18:52:15 收到下发指令:排队号2>>>
2026-04-28 18:52:15 收到下发指令:叫号2>>>
2026-04-28 18:52:19 收到下发指令:排队号2>>>
2026-04-28 18:52:19 收到下发指令:叫号2>>>
2026-04-28 18:52:25 收到下发指令:排队号2>>>
2026-04-28 18:52:25 收到下发指令:叫号2>>>


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


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


===19:14:27===
上一时间戳为1777334456
当日首次设置时间戳true为1777374806
今日nvm排队号为105
当前排队号为105,音量为5
初始化产品信息:[{"time_limit_date":"","ticket_category":"0","expiry_date":3,"product_detail":"","time_limit_status":"0","begin_minute":"00","product_uid":"12710657366789465785","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:8c49c****9c9e5
纸币器设置接收纸币范围为36
欢迎使用天羚自助售票系统[2.8.6]
定时检测未同步订单启用[checkOrderNum=536870969]
2026-04-28 19:13:26>>>cash write=30
2026-04-28 19:13:26>>>cash write=02
2026-04-28 19:13:26>>>cash write=3E
2026-04-28 19:13:26>>>cash read=808F808F
系统时间初始化成功，时间为2026428191326
2026-04-28 19:13:27>>>cash write=02
2026-04-28 19:13:27 >>>剩余flash空间=1680000,占用RAM为657.5224609375
2026-04-28 19:13:27 >>>回调事件:910,subscribe,10000,连接服务器成功

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

2026-04-28 19:13:30>>>cash write=0C
2026-04-28 19:13:30>>>cash read=00
2026-04-28 19:13:30>>>cash read=818F42
2026-04-28 19:13:30>>>cash write=02
2026-04-28 19:13:30 >>>回调事件130,cash_status,10022,进钞中...read money=10
流量卡还有337天过期
2026-04-28 19:13:31>>>cash read=10
2026-04-28 19:13:31 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-28 19:13:31 当前产品价格10元，投币10元，打印小票中...
2026-04-28 19:13:31 >>>开始打印,排队号为105,订单号为2604281913310023222373
2026-04-28 19:13:31>>>订单2604281913310023222373写入成功,剩余空间为1678000,占用RAM为644.3857421875
删除未同步订单2604281913310023222373
2026-04-28 19:13:33>>>订单2604281913310023222373删除成功,剩余空间为1679000,占用RAM为648.4814453125
检测订单目录中>>>
无未同步订单>>>
2026-04-28 19:13:33 >>>当前Ram内存为618.5654296875
定时检测未同步订单启用[checkOrderNum=536870986]
2026-04-28 19:13:34>>>cash write=0C
2026-04-28 19:13:35>>>cash read=3E
2026-04-28 19:13:38 >>>当前Ram内存为665.6103515625


===19:16:27===
2026-04-28 19:15:31>>>cash read=0A
2026-04-28 19:15:32>>>cash read=3E


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


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


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


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


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


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


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


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


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


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


===20:35:30===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-28 20:35:20 收到下发指令:排队号2>>>
2026-04-28 20:35:20 收到下发指令:叫号2>>>
2026-04-28 20:35:23 收到下发指令:排队号2>>>
2026-04-28 20:35:23 收到下发指令:叫号2>>>
2026-04-28 20:35:28 收到下发指令:排队号2>>>
2026-04-28 20:35:28 收到下发指令:叫号2>>>


===20:36:30===
2026-04-28 20:35:31 收到下发指令:排队号2>>>
2026-04-28 20:35:31 收到下发指令:叫号2>>>


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