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

===08:10:52===
上一时间戳为1727437667
隔日重置时间戳true
隔日清空未同步下发列表true
当前排队号为1,音量为5
初始化产品信息:[{"time_limit_date":"","ticket_category":"0","expiry_date":7,"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
session_id:c9485****96ce9
纸币器设置接收纸币范围为36
欢迎使用天羚自助售票系统[2.5.4]
定时检测未同步订单启用
2024-09-28 08:09:52>>>cash write=30
2024-09-28 08:09:52>>>cash write=02
2024-09-28 08:09:52>>>cash write=3E
2024-09-28 08:09:52>>>cash read=808F808F
系统时间初始化成功，时间为20249288952
2024-09-28 08:09:53>>>cash write=02
2024-09-28 08:09:53 >>>剩余flash空间=1680500,占用RAM为622.888671875
2024-09-28 08:09:53 >>>回调事件:910,subscribe,10000,连接服务器成功

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

2024-09-28 08:09:56>>>cash write=0C
2024-09-28 08:09:56>>>cash read=3E
流量卡还有183天过期
2024-09-28 08:10:04 >>>当前Ram内存为613.818359375


===08:11:52===
定时检测未同步订单关闭
检测订单目录中>>>
无未同步订单>>>


===08:25:53===
2024-09-28 08:25:23>>>cash read=00
2024-09-28 08:25:23>>>cash read=818F42
2024-09-28 08:25:23>>>cash write=02
2024-09-28 08:25:23 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-09-28 08:25:24>>>cash read=10
2024-09-28 08:25:24 >>>回调事件130,10,10023,finish Money=10,进钞完成
当日首次设置时间戳true为1727483124
2024-09-28 08:25:24 当前产品价格10元，投币10元，打印小票中...
2024-09-28 08:25:24 >>>开始打印,排队号为1,订单号为2409280825240032225449
2024-09-28 08:25:24>>>订单2409280825240032225449写入成功,剩余空间为1679500,占用RAM为606.8037109375
删除未同步订单2409280825240032225449
2024-09-28 08:25:26>>>订单2409280825240032225449删除成功,剩余空间为1680500,占用RAM为618.8779296875
检测订单目录中>>>
无未同步订单>>>
2024-09-28 08:25:26 >>>当前Ram内存为589.3984375
定时检测未同步订单启用
2024-09-28 08:25:27>>>cash write=0C
2024-09-28 08:25:27>>>cash read=3E


===08:26:53===
定时检测未同步订单关闭
检测订单目录中>>>
无未同步订单>>>


===08:27:53===
2024-09-28 08:27:24 >>>回调事件[910,devices/S3222]
2024-09-28 08:27:24 >>>故障排除日志:上一MQTT订单号缓存列表为24092720242056012783
2024-09-28 08:27:24 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 08:27:24 开始打印,排队:2,票券:2409280827090006892701,订单:24092808270900064792,[2024-09-28 08:27:23微信支付10元]
2024-09-28 08:27:26 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409280827090006892701","queue_number":2,"trade_uid":"24092808270900064792"}]}
2024-09-28 08:27:26 >>>故障排除日志:删除未同步下发订单成功24092808270900064792
2024-09-28 08:27:26 >>>故障排除日志:终端同步成功后剩余订单列表


===08:36:54===
2024-09-28 08:36:12 >>>回调事件[910,devices/S3222]
2024-09-28 08:36:12 >>>故障排除日志:上一MQTT订单号缓存列表为24092808270900064792
2024-09-28 08:36:12 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 08:36:12 开始打印,排队:3,票券:2409280836065289872701,订单:24092808360652893850,[2024-09-28 08:36:11微信支付10元]
2024-09-28 08:36:14 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409280836065289872701","queue_number":3,"trade_uid":"24092808360652893850"}]}
2024-09-28 08:36:14 >>>故障排除日志:删除未同步下发订单成功24092808360652893850
2024-09-28 08:36:14 >>>故障排除日志:终端同步成功后剩余订单列表


===08:44:54===
2024-09-28 08:43:59 >>>回调事件[910,devices/S3222]
2024-09-28 08:43:59 >>>故障排除日志:上一MQTT订单号缓存列表为24092808360652893850
2024-09-28 08:43:59 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 08:43:59 开始打印,排队:4,票券:2409280843491547126501,订单:24092808434915466543,[2024-09-28 08:43:58支付宝支付10元]
2024-09-28 08:44:01 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409280843491547126501","queue_number":4,"trade_uid":"24092808434915466543"}]}
2024-09-28 08:44:01 >>>故障排除日志:删除未同步下发订单成功24092808434915466543
2024-09-28 08:44:01 >>>故障排除日志:终端同步成功后剩余订单列表


===08:49:54===
2024-09-28 08:49:48 >>>回调事件[910,devices/S3222]
2024-09-28 08:49:48 >>>故障排除日志:上一MQTT订单号缓存列表为24092808434915466543
2024-09-28 08:49:48 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 08:49:48 开始打印,排队:5,票券:2409280849293891361201,订单:24092808492938909327,[2024-09-28 08:49:46微信支付10元]
2024-09-28 08:49:50 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409280849293891361201","queue_number":5,"trade_uid":"24092808492938909327"}]}
2024-09-28 08:49:50 >>>故障排除日志:删除未同步下发订单成功24092808492938909327
2024-09-28 08:49:50 >>>故障排除日志:终端同步成功后剩余订单列表


===08:51:54===
2024-09-28 08:51:01>>>cash read=00
2024-09-28 08:51:01>>>cash read=818F42
2024-09-28 08:51:01>>>cash write=02
2024-09-28 08:51:01 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-09-28 08:51:01>>>cash read=10
2024-09-28 08:51:01 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-09-28 08:51:01 当前产品价格10元，投币10元，打印小票中...
2024-09-28 08:51:01 >>>开始打印,排队号为6,订单号为2409280851010032224963
2024-09-28 08:51:02>>>订单2409280851010032224963写入成功,剩余空间为1680000,占用RAM为608.4111328125
删除未同步订单2409280851010032224963
2024-09-28 08:51:04>>>订单2409280851010032224963删除成功,剩余空间为1680500,占用RAM为624.740234375
检测订单目录中>>>
无未同步订单>>>
2024-09-28 08:51:04 >>>当前Ram内存为591.11328125
定时检测未同步订单启用
2024-09-28 08:51:05>>>cash write=0C
2024-09-28 08:51:05>>>cash read=3E
2024-09-28 08:51:40>>>cash read=00
2024-09-28 08:51:40>>>cash read=818F42
2024-09-28 08:51:40>>>cash write=02
2024-09-28 08:51:40 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-09-28 08:51:40>>>cash read=10
2024-09-28 08:51:40 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-09-28 08:51:40 当前产品价格10元，投币10元，打印小票中...
2024-09-28 08:51:40 >>>开始打印,排队号为7,订单号为2409280851400032224187
定时检测未同步订单关闭
2024-09-28 08:51:41>>>订单2409280851400032224187写入成功,剩余空间为1679000,占用RAM为615.9033203125
删除未同步订单2409280851400032224187
2024-09-28 08:51:43>>>订单2409280851400032224187删除成功,剩余空间为1679500,占用RAM为622.2783203125
检测订单目录中>>>
无未同步订单>>>
2024-09-28 08:51:43 >>>当前Ram内存为592.611328125
定时检测未同步订单启用
2024-09-28 08:51:44>>>cash write=0C
2024-09-28 08:51:44>>>cash read=3E


===08:52:55===
定时检测未同步订单关闭
检测订单目录中>>>
无未同步订单>>>


===09:01:55===
2024-09-28 09:01:40>>>cash read=00
2024-09-28 09:01:41>>>cash read=818F42
2024-09-28 09:01:41>>>cash write=02
2024-09-28 09:01:41 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-09-28 09:01:42>>>cash read=10
2024-09-28 09:01:42 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-09-28 09:01:42 当前产品价格10元，投币10元，打印小票中...
2024-09-28 09:01:42 >>>开始打印,排队号为8,订单号为2409280901420032227544
2024-09-28 09:01:42>>>订单2409280901420032227544写入成功,剩余空间为1680000,占用RAM为608.638671875
删除未同步订单2409280901420032227544
2024-09-28 09:01:44>>>订单2409280901420032227544删除成功,剩余空间为1680500,占用RAM为619.296875
检测订单目录中>>>
无未同步订单>>>
2024-09-28 09:01:44 >>>当前Ram内存为591.37109375
定时检测未同步订单启用
2024-09-28 09:01:45>>>cash write=0C
2024-09-28 09:01:45>>>cash read=3E


===09:02:55===
定时检测未同步订单关闭
检测订单目录中>>>
无未同步订单>>>


===09:04:55===
2024-09-28 09:04:41>>>cash read=00
2024-09-28 09:04:42>>>cash read=818F42
2024-09-28 09:04:42>>>cash write=02
2024-09-28 09:04:42 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-09-28 09:04:43>>>cash read=10
2024-09-28 09:04:43 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-09-28 09:04:43 当前产品价格10元，投币10元，打印小票中...
2024-09-28 09:04:43 >>>开始打印,排队号为9,订单号为2409280904430032225654
2024-09-28 09:04:43>>>订单2409280904430032225654写入成功,剩余空间为1680000,占用RAM为608.74609375
删除未同步订单2409280904430032225654
2024-09-28 09:04:45>>>订单2409280904430032225654删除成功,剩余空间为1680500,占用RAM为619.4013671875
检测订单目录中>>>
无未同步订单>>>
2024-09-28 09:04:45 >>>当前Ram内存为591.5
定时检测未同步订单启用
2024-09-28 09:04:46>>>cash write=0C
2024-09-28 09:04:46>>>cash read=3E


===09:05:55===
2024-09-28 09:05:40 >>>回调事件[910,devices/S3222]
2024-09-28 09:05:40 >>>故障排除日志:上一MQTT订单号缓存列表为24092808492938909327
2024-09-28 09:05:40 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 09:05:40 开始打印,排队:10,票券:2409280905305302588501,订单:24092809053053019020,[2024-09-28 09:05:39微信支付10元]
2024-09-28 09:05:42 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409280905305302588501","queue_number":10,"trade_uid":"24092809053053019020"}]}
2024-09-28 09:05:42 >>>故障排除日志:删除未同步下发订单成功24092809053053019020
2024-09-28 09:05:43 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单关闭
检测订单目录中>>>
无未同步订单>>>


===09:07:56===
2024-09-28 09:06:58>>>cash read=00
2024-09-28 09:06:58>>>cash read=818F42
2024-09-28 09:06:58>>>cash write=02
2024-09-28 09:06:58 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-09-28 09:06:59>>>cash read=10
2024-09-28 09:06:59 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-09-28 09:06:59 当前产品价格10元，投币10元，打印小票中...
2024-09-28 09:06:59 >>>开始打印,排队号为11,订单号为2409280906590032225816
2024-09-28 09:06:59>>>订单2409280906590032225816写入成功,剩余空间为1680000,占用RAM为607.865234375
删除未同步订单2409280906590032225816
2024-09-28 09:07:01>>>订单2409280906590032225816删除成功,剩余空间为1680500,占用RAM为618.76171875
检测订单目录中>>>
无未同步订单>>>
2024-09-28 09:07:01 >>>当前Ram内存为590.5966796875
定时检测未同步订单启用
2024-09-28 09:07:02>>>cash write=0C
2024-09-28 09:07:02>>>cash read=3E


===09:08:56===
定时检测未同步订单关闭
检测订单目录中>>>
无未同步订单>>>


===09:16:56===
2024-09-28 09:15:56>>>cash read=00
2024-09-28 09:15:57>>>cash read=818F42
2024-09-28 09:15:57>>>cash write=02
2024-09-28 09:15:57 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-09-28 09:15:58>>>cash read=10
2024-09-28 09:15:58 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-09-28 09:15:58 当前产品价格10元，投币10元，打印小票中...
2024-09-28 09:15:58 >>>开始打印,排队号为12,订单号为2409280915580032226032
2024-09-28 09:15:58>>>订单2409280915580032226032写入成功,剩余空间为1680000,占用RAM为608.421875
删除未同步订单2409280915580032226032
2024-09-28 09:16:00>>>订单2409280915580032226032删除成功,剩余空间为1680500,占用RAM为619.3056640625
检测订单目录中>>>
无未同步订单>>>
2024-09-28 09:16:00 >>>当前Ram内存为591.12890625
定时检测未同步订单启用
2024-09-28 09:16:01>>>cash write=0C
2024-09-28 09:16:01>>>cash read=3E


===09:17:56===
定时检测未同步订单关闭
检测订单目录中>>>
无未同步订单>>>


===09:24:57===
2024-09-28 09:24:38>>>cash read=00
2024-09-28 09:24:39>>>cash read=818F42
2024-09-28 09:24:39>>>cash write=02
2024-09-28 09:24:39 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-09-28 09:24:39>>>cash read=10
2024-09-28 09:24:39 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-09-28 09:24:39 当前产品价格10元，投币10元，打印小票中...
2024-09-28 09:24:39 >>>开始打印,排队号为13,订单号为2409280924390032226019
2024-09-28 09:24:39>>>订单2409280924390032226019写入成功,剩余空间为1680000,占用RAM为609.3447265625
删除未同步订单2409280924390032226019
2024-09-28 09:24:42>>>订单2409280924390032226019删除成功,剩余空间为1680500,占用RAM为619.59765625
检测订单目录中>>>
无未同步订单>>>
2024-09-28 09:24:42 >>>当前Ram内存为590.986328125
定时检测未同步订单启用
2024-09-28 09:24:42>>>cash write=0C
2024-09-28 09:24:43>>>cash read=3E


===09:25:57===
定时检测未同步订单关闭
检测订单目录中>>>
无未同步订单>>>
2024-09-28 09:25:53 >>>回调事件[910,devices/S3222]
2024-09-28 09:25:53 >>>故障排除日志:上一MQTT订单号缓存列表为24092809053053019020
2024-09-28 09:25:53 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 09:25:53 开始打印,排队:14,票券:2409280925475223977201,订单:24092809254752234352,[2024-09-28 09:25:52微信支付10元]
2024-09-28 09:25:55 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409280925475223977201","queue_number":14,"trade_uid":"24092809254752234352"}]}
2024-09-28 09:25:55 >>>故障排除日志:删除未同步下发订单成功24092809254752234352
2024-09-28 09:25:55 >>>故障排除日志:终端同步成功后剩余订单列表


===09:32:57===
2024-09-28 09:32:36 >>>回调事件[910,devices/S3222]
2024-09-28 09:32:36 >>>故障排除日志:上一MQTT订单号缓存列表为24092809254752234352
2024-09-28 09:32:36 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 09:32:36 开始打印,排队:15,票券:2409280932272645032501,订单:24092809322726445493,[2024-09-28 09:32:35微信支付10元]
2024-09-28 09:32:38 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409280932272645032501","queue_number":15,"trade_uid":"24092809322726445493"}]}
2024-09-28 09:32:38 >>>故障排除日志:删除未同步下发订单成功24092809322726445493
2024-09-28 09:32:38 >>>故障排除日志:终端同步成功后剩余订单列表


===09:36:57===
2024-09-28 09:35:59 >>>回调事件[910,devices/S3222]
2024-09-28 09:35:59 >>>故障排除日志:上一MQTT订单号缓存列表为24092809322726445493
2024-09-28 09:35:59 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 09:36:00 开始打印,排队:16,票券:2409280935490066449201,订单:24092809354900659869,[2024-09-28 09:35:58支付宝支付10元]
2024-09-28 09:36:01 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409280935490066449201","queue_number":16,"trade_uid":"24092809354900659869"}]}
2024-09-28 09:36:01 >>>故障排除日志:删除未同步下发订单成功24092809354900659869
2024-09-28 09:36:02 >>>故障排除日志:终端同步成功后剩余订单列表


===09:39:00===
2024-09-28 09:38:19 >>>回调事件[910,devices/S3222]
2024-09-28 09:38:19 >>>故障排除日志:上一MQTT订单号缓存列表为24092809354900659869
2024-09-28 09:38:19 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 09:38:19 开始打印,排队:17,票券:2409280938133615018301,订单:24092809381336146234,[2024-09-28 09:38:18微信支付10元]
2024-09-28 09:38:21 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409280938133615018301","queue_number":17,"trade_uid":"24092809381336146234"}]}
2024-09-28 09:38:21 >>>故障排除日志:删除未同步下发订单成功24092809381336146234
2024-09-28 09:38:21 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 09:38:39 >>>回调事件[910,devices/S3222]
2024-09-28 09:38:39 >>>故障排除日志:上一MQTT订单号缓存列表为24092809381336146234
2024-09-28 09:38:39 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 09:38:39 开始打印,排队:18,票券:2409280938297589860701,订单:24092809382975893017,[2024-09-28 09:38:38微信支付10元]
2024-09-28 09:38:41 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409280938297589860701","queue_number":18,"trade_uid":"24092809382975893017"}]}
2024-09-28 09:38:41 >>>故障排除日志:删除未同步下发订单成功24092809382975893017
2024-09-28 09:38:41 >>>故障排除日志:终端同步成功后剩余订单列表


===09:53:01===
2024-09-28 09:52:20>>>cash read=00
2024-09-28 09:52:21>>>cash read=00818F42
2024-09-28 09:52:21>>>cash write=02
2024-09-28 09:52:21 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-09-28 09:52:21>>>cash read=10
2024-09-28 09:52:21 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-09-28 09:52:21 当前产品价格10元，投币10元，打印小票中...
2024-09-28 09:52:21 >>>开始打印,排队号为19,订单号为2409280952210032222056
2024-09-28 09:52:22>>>订单2409280952210032222056写入成功,剩余空间为1680000,占用RAM为608.28125
删除未同步订单2409280952210032222056
2024-09-28 09:52:24>>>订单2409280952210032222056删除成功,剩余空间为1680500,占用RAM为619.041015625
检测订单目录中>>>
无未同步订单>>>
2024-09-28 09:52:24 >>>当前Ram内存为590.9716796875
定时检测未同步订单启用
2024-09-28 09:52:25>>>cash write=0C
2024-09-28 09:52:25>>>cash read=3E


===09:54:01===
定时检测未同步订单关闭
检测订单目录中>>>
无未同步订单>>>


===09:56:01===
2024-09-28 09:55:43 >>>回调事件[910,devices/S3222]
2024-09-28 09:55:43 >>>故障排除日志:上一MQTT订单号缓存列表为24092809382975893017
2024-09-28 09:55:44 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 09:55:44 开始打印,排队:20,票券:2409280955355767107601,订单:24092809553557666514,[2024-09-28 09:55:42微信支付10元]
2024-09-28 09:55:45 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409280955355767107601","queue_number":20,"trade_uid":"24092809553557666514"}]}
2024-09-28 09:55:45 >>>故障排除日志:删除未同步下发订单成功24092809553557666514
2024-09-28 09:55:46 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 09:55:57>>>cash read=29
2024-09-28 09:55:57 >>>回调事件130,cash_status,20029,退钞中
2024-09-28 09:55:57>>>cash read=2F29
2024-09-28 09:55:58>>>cash read=01


===09:57:01===
2024-09-28 09:56:00>>>cash read=2F
2024-09-28 09:56:02>>>cash read=3E
2024-09-28 09:56:18>>>cash read=00
2024-09-28 09:56:19 >>>回调事件[910,devices/S3222]
2024-09-28 09:56:19 >>>故障排除日志:上一MQTT订单号缓存列表为24092809553557666514
2024-09-28 09:56:19 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 09:56:19 开始打印,排队:21,票券:2409280956050689264201,订单:24092809560506887986,[2024-09-28 09:56:17支付宝支付10元]
2024-09-28 09:56:20>>>cash read=2F292F
2024-09-28 09:56:21 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409280956050689264201","queue_number":21,"trade_uid":"24092809560506887986"}]}
2024-09-28 09:56:21 >>>故障排除日志:删除未同步下发订单成功24092809560506887986
2024-09-28 09:56:21 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 09:56:22>>>cash read=3E
2024-09-28 09:56:23>>>cash read=00
2024-09-28 09:56:24>>>cash read=818F42
2024-09-28 09:56:24>>>cash write=02
2024-09-28 09:56:24 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-09-28 09:56:24>>>cash read=10
2024-09-28 09:56:24 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-09-28 09:56:24 当前产品价格10元，投币10元，打印小票中...
2024-09-28 09:56:25 >>>开始打印,排队号为22,订单号为2409280956240032221518
2024-09-28 09:56:25>>>订单2409280956240032221518写入成功,剩余空间为1679000,占用RAM为615.19921875
删除未同步订单2409280956240032221518
2024-09-28 09:56:27>>>订单2409280956240032221518删除成功,剩余空间为1679500,占用RAM为623.80078125
检测订单目录中>>>
无未同步订单>>>
2024-09-28 09:56:27 >>>当前Ram内存为593.1318359375
定时检测未同步订单启用
2024-09-28 09:56:28>>>cash write=0C
2024-09-28 09:56:28>>>cash read=3E


===09:58:01===
定时检测未同步订单关闭
检测订单目录中>>>
无未同步订单>>>


===10:00:01===
2024-09-28 09:59:42 >>>回调事件[910,devices/S3222]
2024-09-28 09:59:42 >>>故障排除日志:上一MQTT订单号缓存列表为24092809560506887986
2024-09-28 09:59:42 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 09:59:42 开始打印,排队:23,票券:2409280959321372856401,订单:24092809593213722736,[2024-09-28 09:59:41微信支付10元]
2024-09-28 09:59:42 开始打印,排队:24,票券:2409280959321372997802,订单:24092809593213722736,[2024-09-28 09:59:41微信支付10元]
2024-09-28 09:59:46 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409280959321372856401","queue_number":23,"trade_uid":"24092809593213722736"},{"ticket_no":"2409280959321372997802","queue_number":24,"trade_uid":"24092809593213722736"}]}
2024-09-28 09:59:46 >>>故障排除日志:删除未同步下发订单成功24092809593213722736
2024-09-28 09:59:46 >>>故障排除日志:删除未同步下发订单成功24092809593213722736
2024-09-28 09:59:46 >>>故障排除日志:终端同步成功后剩余订单列表


===10:01:02===
2024-09-28 10:00:48>>>cash read=00
2024-09-28 10:00:48>>>cash read=818F42
2024-09-28 10:00:48>>>cash write=02
2024-09-28 10:00:48 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-09-28 10:00:49>>>cash read=10
2024-09-28 10:00:49 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-09-28 10:00:49 当前产品价格10元，投币10元，打印小票中...
2024-09-28 10:00:49 >>>开始打印,排队号为25,订单号为2409281000490032228816
2024-09-28 10:00:49>>>订单2409281000490032228816写入成功,剩余空间为1680000,占用RAM为605.40625
删除未同步订单2409281000490032228816
2024-09-28 10:00:51>>>订单2409281000490032228816删除成功,剩余空间为1680500,占用RAM为625.3896484375
检测订单目录中>>>
无未同步订单>>>
2024-09-28 10:00:51 >>>当前Ram内存为591.8125
定时检测未同步订单启用
2024-09-28 10:00:52>>>cash write=0C
2024-09-28 10:00:52>>>cash read=3E


===10:02:02===
定时检测未同步订单关闭
检测订单目录中>>>
无未同步订单>>>


===10:06:02===
2024-09-28 10:05:24 >>>回调事件[910,devices/S3222]
2024-09-28 10:05:24 >>>故障排除日志:上一MQTT订单号缓存列表为24092809593213722736|24092809593213722736
2024-09-28 10:05:24 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 10:05:24 开始打印,排队:26,票券:2409281005154912302801,订单:24092810051549117753,[2024-09-28 10:05:23微信支付10元]
2024-09-28 10:05:26 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281005154912302801","queue_number":26,"trade_uid":"24092810051549117753"}]}
2024-09-28 10:05:26 >>>故障排除日志:删除未同步下发订单成功24092810051549117753
2024-09-28 10:05:26 >>>故障排除日志:终端同步成功后剩余订单列表


===10:08:02===
2024-09-28 10:07:24 >>>回调事件[910,devices/S3222]
2024-09-28 10:07:24 >>>故障排除日志:上一MQTT订单号缓存列表为24092810051549117753
2024-09-28 10:07:24 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 10:07:25 开始打印,排队:27,票券:2409281007150575161701,订单:24092810071505745893,[2024-09-28 10:07:24支付宝支付10元]
2024-09-28 10:07:27 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281007150575161701","queue_number":27,"trade_uid":"24092810071505745893"}]}
2024-09-28 10:07:27 >>>故障排除日志:删除未同步下发订单成功24092810071505745893
2024-09-28 10:07:27 >>>故障排除日志:终端同步成功后剩余订单列表


===10:10:02===
2024-09-28 10:09:42 >>>回调事件[910,devices/S3222]
2024-09-28 10:09:43 >>>故障排除日志:上一MQTT订单号缓存列表为24092810071505745893
2024-09-28 10:09:43 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 10:09:43 开始打印,排队:28,票券:2409281009336218899801,订单:24092810093362157017,[2024-09-28 10:09:41微信支付10元]
2024-09-28 10:09:44 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281009336218899801","queue_number":28,"trade_uid":"24092810093362157017"}]}
2024-09-28 10:09:44 >>>故障排除日志:删除未同步下发订单成功24092810093362157017
2024-09-28 10:09:44 >>>故障排除日志:终端同步成功后剩余订单列表


===10:11:04===
2024-09-28 10:11:00>>>cash read=00
2024-09-28 10:11:00>>>cash read=818F42
2024-09-28 10:11:01>>>cash write=02
2024-09-28 10:11:01 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-09-28 10:11:01>>>cash read=10
2024-09-28 10:11:01 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-09-28 10:11:01 当前产品价格10元，投币10元，打印小票中...
2024-09-28 10:11:01 >>>开始打印,排队号为29,订单号为2409281011010032229031
2024-09-28 10:11:01>>>订单2409281011010032229031写入成功,剩余空间为1680000,占用RAM为608.666015625


===10:12:04===
删除未同步订单2409281011010032229031
2024-09-28 10:11:03>>>订单2409281011010032229031删除成功,剩余空间为1681500,占用RAM为622.7587890625
检测订单目录中>>>
无未同步订单>>>
2024-09-28 10:11:03 >>>当前Ram内存为590.8291015625
定时检测未同步订单启用
2024-09-28 10:11:04>>>cash write=0C
2024-09-28 10:11:04>>>cash read=3E


===10:13:04===
定时检测未同步订单关闭
检测订单目录中>>>
无未同步订单>>>


===10:17:04===
2024-09-28 10:16:53 >>>回调事件[910,devices/S3222]
2024-09-28 10:16:53 >>>故障排除日志:上一MQTT订单号缓存列表为24092810093362157017
2024-09-28 10:16:53 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 10:16:53 开始打印,排队:30,票券:2409281016463790098101,订单:24092810164637896657,[2024-09-28 10:16:52微信支付10元]
2024-09-28 10:16:54 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281016463790098101","queue_number":30,"trade_uid":"24092810164637896657"}]}
2024-09-28 10:16:54 >>>故障排除日志:删除未同步下发订单成功24092810164637896657
2024-09-28 10:16:55 >>>故障排除日志:终端同步成功后剩余订单列表


===10:18:05===
2024-09-28 10:17:26 >>>回调事件[910,devices/S3222]
2024-09-28 10:17:26 >>>故障排除日志:上一MQTT订单号缓存列表为24092810164637896657
2024-09-28 10:17:26 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 10:17:26 开始打印,排队:31,票券:2409281017173621828001,订单:24092810171736212157,[2024-09-28 10:17:25微信支付10元]
2024-09-28 10:17:28 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281017173621828001","queue_number":31,"trade_uid":"24092810171736212157"}]}
2024-09-28 10:17:28 >>>故障排除日志:删除未同步下发订单成功24092810171736212157
2024-09-28 10:17:28 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 10:17:56 >>>回调事件[910,devices/S3222]
2024-09-28 10:17:57 >>>故障排除日志:上一MQTT订单号缓存列表为24092810171736212157
2024-09-28 10:17:57 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 10:17:57 开始打印,排队:32,票券:2409281017503025117201,订单:24092810175030247728,[2024-09-28 10:17:55微信支付10元]
2024-09-28 10:17:59 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281017503025117201","queue_number":32,"trade_uid":"24092810175030247728"}]}
2024-09-28 10:17:59 >>>故障排除日志:删除未同步下发订单成功24092810175030247728
2024-09-28 10:17:59 >>>故障排除日志:终端同步成功后剩余订单列表


===10:35:05===
2024-09-28 10:34:22>>>cash read=00
2024-09-28 10:34:24>>>cash read=01
2024-09-28 10:34:25>>>cash read=3E
2024-09-28 10:34:27>>>cash read=29
2024-09-28 10:34:27 >>>回调事件130,cash_status,20029,退钞中
2024-09-28 10:34:28>>>cash read=3E
2024-09-28 10:34:36>>>cash read=00
2024-09-28 10:34:38>>>cash read=2F29
2024-09-28 10:34:39>>>cash read=01
2024-09-28 10:34:41>>>cash read=2F
2024-09-28 10:34:42 >>>回调事件[910,devices/S3222]
2024-09-28 10:34:42 >>>故障排除日志:上一MQTT订单号缓存列表为24092810175030247728
2024-09-28 10:34:42 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 10:34:43 开始打印,排队:33,票券:2409281034304005769301,订单:24092810343040053082,[2024-09-28 10:34:42微信支付10元]
2024-09-28 10:34:44>>>cash read=00
2024-09-28 10:34:45 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281034304005769301","queue_number":33,"trade_uid":"24092810343040053082"}]}
2024-09-28 10:34:45 >>>故障排除日志:删除未同步下发订单成功24092810343040053082
2024-09-28 10:34:45 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 10:34:46>>>cash read=29
2024-09-28 10:34:46 >>>回调事件130,cash_status,20029,退钞中
2024-09-28 10:34:47>>>cash read=01
2024-09-28 10:34:48>>>cash read=3E


===10:36:05===
2024-09-28 10:35:12>>>cash read=00
2024-09-28 10:35:13>>>cash read=29
2024-09-28 10:35:13 >>>回调事件130,cash_status,20029,退钞中
2024-09-28 10:35:13>>>cash read=2F29
2024-09-28 10:35:15>>>cash read=3E
2024-09-28 10:35:21>>>cash read=00
2024-09-28 10:35:22>>>cash read=818F42
2024-09-28 10:35:22>>>cash write=02
2024-09-28 10:35:22 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-09-28 10:35:22>>>cash read=10
2024-09-28 10:35:22 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-09-28 10:35:22 当前产品价格10元，投币10元，打印小票中...
2024-09-28 10:35:22 >>>开始打印,排队号为34,订单号为2409281035220032221478
2024-09-28 10:35:23>>>订单2409281035220032221478写入成功,剩余空间为1679500,占用RAM为609.30078125
删除未同步订单2409281035220032221478
2024-09-28 10:35:25>>>订单2409281035220032221478删除成功,剩余空间为1680500,占用RAM为619.43359375
检测订单目录中>>>
无未同步订单>>>
2024-09-28 10:35:25 >>>当前Ram内存为590.998046875
定时检测未同步订单启用
2024-09-28 10:35:26>>>cash write=0C
2024-09-28 10:35:26>>>cash read=3E
2024-09-28 10:35:41 >>>回调事件[910,devices/S3222]
2024-09-28 10:35:41 >>>故障排除日志:上一MQTT订单号缓存列表为24092810343040053082
2024-09-28 10:35:41 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 10:35:41 开始打印,排队:35,票券:2409281035353293643801,订单:24092810353532930692,[2024-09-28 10:35:40微信支付10元]
2024-09-28 10:35:43 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281035353293643801","queue_number":35,"trade_uid":"24092810353532930692"}]}
2024-09-28 10:35:43 >>>故障排除日志:删除未同步下发订单成功24092810353532930692
2024-09-28 10:35:43 >>>故障排除日志:终端同步成功后剩余订单列表


===10:37:06===
定时检测未同步订单关闭
检测订单目录中>>>
无未同步订单>>>


===10:50:06===
2024-09-28 10:50:00>>>cash read=00
2024-09-28 10:50:01>>>cash read=818F42
2024-09-28 10:50:01>>>cash write=02
2024-09-28 10:50:01 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-09-28 10:50:01>>>cash read=10
2024-09-28 10:50:01 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-09-28 10:50:01 当前产品价格10元，投币10元，打印小票中...
2024-09-28 10:50:01 >>>开始打印,排队号为36,订单号为2409281050010032223571
2024-09-28 10:50:02>>>订单2409281050010032223571写入成功,剩余空间为1680000,占用RAM为606.3779296875
删除未同步订单2409281050010032223571
2024-09-28 10:50:04>>>订单2409281050010032223571删除成功,剩余空间为1680500,占用RAM为618.91796875
检测订单目录中>>>
无未同步订单>>>
2024-09-28 10:50:04 >>>当前Ram内存为590.908203125
定时检测未同步订单启用
2024-09-28 10:50:05>>>cash write=0C
2024-09-28 10:50:05>>>cash read=3E


===10:51:06===
定时检测未同步订单关闭
检测订单目录中>>>
无未同步订单>>>


===10:57:06===
2024-09-28 10:56:22 >>>回调事件[910,devices/S3222]
2024-09-28 10:56:22 >>>故障排除日志:上一MQTT订单号缓存列表为24092810353532930692
2024-09-28 10:56:22 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 10:56:22 开始打印,排队:37,票券:2409281056138415540201,订单:24092810561384150751,[2024-09-28 10:56:21支付宝支付10元]
2024-09-28 10:56:24 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281056138415540201","queue_number":37,"trade_uid":"24092810561384150751"}]}
2024-09-28 10:56:24 >>>故障排除日志:删除未同步下发订单成功24092810561384150751
2024-09-28 10:56:24 >>>故障排除日志:终端同步成功后剩余订单列表


===10:58:07===
2024-09-28 10:57:44 >>>回调事件[910,devices/S3222]
2024-09-28 10:57:44 >>>故障排除日志:上一MQTT订单号缓存列表为24092810561384150751
2024-09-28 10:57:44 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 10:57:44 开始打印,排队:38,票券:2409281057359050483601,订单:24092810573590498157,[2024-09-28 10:57:43微信支付10元]
2024-09-28 10:57:46 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281057359050483601","queue_number":38,"trade_uid":"24092810573590498157"}]}
2024-09-28 10:57:46 >>>故障排除日志:删除未同步下发订单成功24092810573590498157
2024-09-28 10:57:46 >>>故障排除日志:终端同步成功后剩余订单列表


===10:59:07===
2024-09-28 10:58:16 >>>回调事件[910,devices/S3222]
2024-09-28 10:58:16 >>>故障排除日志:上一MQTT订单号缓存列表为24092810573590498157
2024-09-28 10:58:16 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 10:58:16 开始打印,排队:39,票券:2409281058025228751701,订单:24092810580252282358,[2024-09-28 10:58:15支付宝支付10元]
2024-09-28 10:58:18 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281058025228751701","queue_number":39,"trade_uid":"24092810580252282358"}]}
2024-09-28 10:58:18 >>>故障排除日志:删除未同步下发订单成功24092810580252282358
2024-09-28 10:58:18 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 10:58:27>>>cash read=00
2024-09-28 10:58:28>>>cash read=29
2024-09-28 10:58:28 >>>回调事件130,cash_status,20029,退钞中
2024-09-28 10:58:30>>>cash read=22
2024-09-28 10:58:30 >>>回调事件130,cash_status,30022,卡钞
2024-09-28 10:58:31>>>cash read=3E
2024-09-28 10:58:36>>>cash read=00
2024-09-28 10:58:37>>>cash read=818F42
2024-09-28 10:58:37>>>cash write=02
2024-09-28 10:58:37 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-09-28 10:58:37>>>cash read=10
2024-09-28 10:58:37 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-09-28 10:58:37 当前产品价格10元，投币10元，打印小票中...
2024-09-28 10:58:38 >>>开始打印,排队号为40,订单号为2409281058380032229469
2024-09-28 10:58:38>>>订单2409281058380032229469写入成功,剩余空间为1678500,占用RAM为613.267578125
删除未同步订单2409281058380032229469
2024-09-28 10:58:40>>>订单2409281058380032229469删除成功,剩余空间为1679500,占用RAM为621.0673828125
检测订单目录中>>>
无未同步订单>>>
2024-09-28 10:58:40 >>>当前Ram内存为591.41796875
定时检测未同步订单启用
2024-09-28 10:58:41>>>cash write=0C
2024-09-28 10:58:41>>>cash read=3E


===11:00:07===
定时检测未同步订单关闭
检测订单目录中>>>
无未同步订单>>>
2024-09-28 10:59:50 >>>回调事件[910,devices/S3222]
2024-09-28 10:59:50 >>>故障排除日志:上一MQTT订单号缓存列表为24092810580252282358
2024-09-28 10:59:50 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 10:59:50 开始打印,排队:41,票券:2409281059417319642801,订单:24092810594173191778,[2024-09-28 10:59:49微信支付10元]
2024-09-28 10:59:52 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281059417319642801","queue_number":41,"trade_uid":"24092810594173191778"}]}
2024-09-28 10:59:52 >>>故障排除日志:删除未同步下发订单成功24092810594173191778
2024-09-28 10:59:52 >>>故障排除日志:终端同步成功后剩余订单列表


===11:10:08===
2024-09-28 11:10:04 >>>回调事件[910,devices/S3222]
2024-09-28 11:10:04 >>>故障排除日志:上一MQTT订单号缓存列表为24092810594173191778
2024-09-28 11:10:04 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 11:10:04 开始打印,排队:42,票券:2409281109549136232701,订单:24092811095491356998,[2024-09-28 11:10:03微信支付10元]
2024-09-28 11:10:06 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281109549136232701","queue_number":42,"trade_uid":"24092811095491356998"}]}
2024-09-28 11:10:06 >>>故障排除日志:删除未同步下发订单成功24092811095491356998
2024-09-28 11:10:06 >>>故障排除日志:终端同步成功后剩余订单列表


===11:18:08===
2024-09-28 11:17:50>>>cash read=0A
2024-09-28 11:17:51>>>cash read=3E


===11:24:08===
2024-09-28 11:23:23 >>>回调事件[910,devices/S3222]
2024-09-28 11:23:23 >>>故障排除日志:上一MQTT订单号缓存列表为24092811095491356998
2024-09-28 11:23:23 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 11:23:23 开始打印,排队:43,票券:2409281123150825862901,订单:24092811231508254572,[2024-09-28 11:23:22微信支付10元]
2024-09-28 11:23:25 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281123150825862901","queue_number":43,"trade_uid":"24092811231508254572"}]}
2024-09-28 11:23:25 >>>故障排除日志:删除未同步下发订单成功24092811231508254572
2024-09-28 11:23:25 >>>故障排除日志:终端同步成功后剩余订单列表


===11:33:08===
2024-09-28 11:32:36 >>>回调事件[910,devices/S3222]
2024-09-28 11:32:36 >>>故障排除日志:上一MQTT订单号缓存列表为24092811231508254572
2024-09-28 11:32:36 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 11:32:36 开始打印,排队:44,票券:2409281132039923623001,订单:24092811320399232015,[2024-09-28 11:32:34支付宝支付10元]
2024-09-28 11:32:38 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281132039923623001","queue_number":44,"trade_uid":"24092811320399232015"}]}
2024-09-28 11:32:38 >>>故障排除日志:删除未同步下发订单成功24092811320399232015
2024-09-28 11:32:38 >>>故障排除日志:终端同步成功后剩余订单列表


===11:35:09===
2024-09-28 11:34:38 >>>回调事件[910,devices/S3222]
2024-09-28 11:34:38 >>>故障排除日志:上一MQTT订单号缓存列表为24092811320399232015
2024-09-28 11:34:38 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 11:34:38 开始打印,排队:45,票券:2409281134312077746401,订单:24092811343120772984,[2024-09-28 11:34:37微信支付10元]
2024-09-28 11:34:40 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281134312077746401","queue_number":45,"trade_uid":"24092811343120772984"}]}
2024-09-28 11:34:40 >>>故障排除日志:删除未同步下发订单成功24092811343120772984
2024-09-28 11:34:40 >>>故障排除日志:终端同步成功后剩余订单列表


===11:53:15===
上一时间戳为1727483124
当日首次设置时间戳true为1727495540
今日nvm排队号为46
当前排队号为46,音量为5
初始化产品信息:[{"time_limit_date":"","ticket_category":"0","expiry_date":7,"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
session_id:be065****4668d
纸币器设置接收纸币范围为36
欢迎使用天羚自助售票系统[2.5.4]
定时检测未同步订单启用
2024-09-28 11:52:21>>>cash write=30
2024-09-28 11:52:21>>>cash write=02
2024-09-28 11:52:21>>>cash write=3E
2024-09-28 11:52:21>>>cash read=808F808F
系统时间初始化成功，时间为2024928115221
2024-09-28 11:52:22>>>cash write=02
2024-09-28 11:52:22 >>>剩余flash空间=1680500,占用RAM为624.7080078125
2024-09-28 11:52:22 >>>回调事件:910,subscribe,10000,连接服务器成功

2024-09-28 11:52:22 >>>剩余flash空间=1680000,占用RAM为598.541015625
2024-09-28 11:52:22 >>>回调事件:911,GetMqttQueue,500,暂无需要下发的信息，请求类型：ticket

2024-09-28 11:52:25>>>cash write=0C
2024-09-28 11:52:25>>>cash read=3E
流量卡还有183天过期
2024-09-28 11:52:33 >>>当前Ram内存为613.4736328125


===11:54:15===
上一时间戳为1727495540
当日首次设置时间戳true为1727495594
今日nvm排队号为46
当前排队号为46,音量为5
初始化产品信息:[{"time_limit_date":"","ticket_category":"0","expiry_date":7,"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
session_id:586df****e63ee
纸币器设置接收纸币范围为36
欢迎使用天羚自助售票系统[2.5.4]
定时检测未同步订单启用
2024-09-28 11:53:15>>>cash write=30
2024-09-28 11:53:15>>>cash write=02
2024-09-28 11:53:15>>>cash write=3E
2024-09-28 11:53:15>>>cash read=808F808F
系统时间初始化成功，时间为2024928115315
2024-09-28 11:53:16>>>cash write=02
2024-09-28 11:53:16 >>>剩余flash空间=1680500,占用RAM为625.140625
2024-09-28 11:53:16 >>>回调事件:910,subscribe,10000,连接服务器成功

2024-09-28 11:53:16 >>>剩余flash空间=1680000,占用RAM为598.869140625
2024-09-28 11:53:16 >>>回调事件:911,GetMqttQueue,500,暂无需要下发的信息，请求类型：ticket

2024-09-28 11:53:19>>>cash write=0C
2024-09-28 11:53:19>>>cash read=3E
流量卡还有183天过期
2024-09-28 11:53:27 >>>当前Ram内存为614.6884765625


===12:01:16===
2024-09-28 12:00:37 >>>回调事件[910,devices/S3222]
2024-09-28 12:00:37 >>>故障排除日志:上一MQTT订单号缓存列表为24092811343120772984
2024-09-28 12:00:37 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 12:00:37 开始打印,排队:46,票券:2409281200266546282501,订单:24092812002665458839,[2024-09-28 12:00:36微信支付10元]
2024-09-28 12:00:39 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281200266546282501","queue_number":46,"trade_uid":"24092812002665458839"}]}
2024-09-28 12:00:39 >>>故障排除日志:删除未同步下发订单成功24092812002665458839
2024-09-28 12:00:39 >>>故障排除日志:终端同步成功后剩余订单列表


===12:08:16===
2024-09-28 12:07:47 >>>回调事件[910,devices/S3222]
2024-09-28 12:07:47 >>>故障排除日志:上一MQTT订单号缓存列表为24092812002665458839
2024-09-28 12:07:47 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 12:07:47 开始打印,排队:47,票券:2409281207415849182801,订单:24092812074158487849,[2024-09-28 12:07:46微信支付10元]
2024-09-28 12:07:49 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281207415849182801","queue_number":47,"trade_uid":"24092812074158487849"}]}
2024-09-28 12:07:49 >>>故障排除日志:删除未同步下发订单成功24092812074158487849
2024-09-28 12:07:49 >>>故障排除日志:终端同步成功后剩余订单列表


===12:21:16===
2024-09-28 12:20:32 >>>回调事件[910,devices/S3222]
2024-09-28 12:20:32 >>>故障排除日志:上一MQTT订单号缓存列表为24092812074158487849
2024-09-28 12:20:32 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 12:20:32 开始打印,排队:48,票券:2409281220246848268101,订单:24092812202468477446,[2024-09-28 12:20:31微信支付10元]
2024-09-28 12:20:32 开始打印,排队:49,票券:2409281220246848534102,订单:24092812202468477446,[2024-09-28 12:20:31微信支付10元]
2024-09-28 12:20:35 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281220246848268101","queue_number":48,"trade_uid":"24092812202468477446"},{"ticket_no":"2409281220246848534102","queue_number":49,"trade_uid":"24092812202468477446"}]}
2024-09-28 12:20:35 >>>故障排除日志:删除未同步下发订单成功24092812202468477446
2024-09-28 12:20:35 >>>故障排除日志:删除未同步下发订单成功24092812202468477446
2024-09-28 12:20:36 >>>故障排除日志:终端同步成功后剩余订单列表


===12:26:16===
2024-09-28 12:25:25 >>>回调事件[910,devices/S3222]
2024-09-28 12:25:25 >>>故障排除日志:上一MQTT订单号缓存列表为24092812202468477446|24092812202468477446
2024-09-28 12:25:26 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 12:25:26 开始打印,排队:50,票券:2409281225175624181201,订单:24092812251756237512,[2024-09-28 12:25:25微信支付10元]
2024-09-28 12:25:28 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281225175624181201","queue_number":50,"trade_uid":"24092812251756237512"}]}
2024-09-28 12:25:28 >>>故障排除日志:删除未同步下发订单成功24092812251756237512
2024-09-28 12:25:28 >>>故障排除日志:终端同步成功后剩余订单列表


===12:27:17===
2024-09-28 12:26:27>>>cash read=0A
2024-09-28 12:26:29>>>cash read=3E


===12:43:17===
2024-09-28 12:42:28 >>>回调事件[910,devices/S3222]
2024-09-28 12:42:28 >>>故障排除日志:上一MQTT订单号缓存列表为24092812251756237512
2024-09-28 12:42:28 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 12:42:28 开始打印,排队:51,票券:2409281242182450037401,订单:24092812421824494264,[2024-09-28 12:42:27微信支付10元]
2024-09-28 12:42:30 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281242182450037401","queue_number":51,"trade_uid":"24092812421824494264"}]}
2024-09-28 12:42:30 >>>故障排除日志:删除未同步下发订单成功24092812421824494264
2024-09-28 12:42:30 >>>故障排除日志:终端同步成功后剩余订单列表


===12:45:17===
2024-09-28 12:45:09 >>>回调事件[910,devices/S3222]
2024-09-28 12:45:09 >>>故障排除日志:上一MQTT订单号缓存列表为24092812421824494264
2024-09-28 12:45:09 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 12:45:09 开始打印,排队:52,票券:2409281245026805842801,订单:24092812450268054007,[2024-09-28 12:45:08支付宝支付10元]
2024-09-28 12:45:10 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281245026805842801","queue_number":52,"trade_uid":"24092812450268054007"}]}
2024-09-28 12:45:10 >>>故障排除日志:删除未同步下发订单成功24092812450268054007
2024-09-28 12:45:11 >>>故障排除日志:终端同步成功后剩余订单列表


===12:46:17===
2024-09-28 12:46:10 >>>回调事件[910,devices/S3222]
2024-09-28 12:46:10 >>>故障排除日志:上一MQTT订单号缓存列表为24092812450268054007
2024-09-28 12:46:10 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 12:46:10 开始打印,排队:53,票券:2409281246041375677401,订单:24092812460413752207,[2024-09-28 12:46:10微信支付10元]
2024-09-28 12:46:12 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281246041375677401","queue_number":53,"trade_uid":"24092812460413752207"}]}
2024-09-28 12:46:12 >>>故障排除日志:删除未同步下发订单成功24092812460413752207
2024-09-28 12:46:13 >>>故障排除日志:终端同步成功后剩余订单列表


===12:54:18===
2024-09-28 12:54:04 >>>回调事件[910,devices/S3222]
2024-09-28 12:54:05 >>>故障排除日志:上一MQTT订单号缓存列表为24092812460413752207
2024-09-28 12:54:05 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 12:54:05 开始打印,排队:54,票券:2409281253565617508401,订单:24092812535656169619,[2024-09-28 12:54:03支付宝支付10元]
2024-09-28 12:54:07 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281253565617508401","queue_number":54,"trade_uid":"24092812535656169619"}]}
2024-09-28 12:54:07 >>>故障排除日志:删除未同步下发订单成功24092812535656169619
2024-09-28 12:54:07 >>>故障排除日志:终端同步成功后剩余订单列表


===13:06:18===
2024-09-28 13:05:35 >>>回调事件[910,devices/S3222]
2024-09-28 13:05:35 >>>故障排除日志:上一MQTT订单号缓存列表为24092812535656169619
2024-09-28 13:05:35 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 13:05:35 开始打印,排队:55,票券:2409281305273960574701,订单:24092813052739601496,[2024-09-28 13:05:33微信支付10元]
2024-09-28 13:05:37 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281305273960574701","queue_number":55,"trade_uid":"24092813052739601496"}]}
2024-09-28 13:05:37 >>>故障排除日志:删除未同步下发订单成功24092813052739601496
2024-09-28 13:05:37 >>>故障排除日志:终端同步成功后剩余订单列表


===13:07:18===
2024-09-28 13:07:02 收到下发指令:叫号1>>>
2024-09-28 13:07:05 收到下发指令:叫号1>>>
2024-09-28 13:07:08 收到下发指令:叫号1>>>
2024-09-28 13:07:12 收到下发指令:叫号1>>>


===13:08:18===
2024-09-28 13:07:19 收到下发指令:叫号1>>>
2024-09-28 13:07:24 收到下发指令:叫号1>>>
2024-09-28 13:07:28 收到下发指令:叫号1>>>
2024-09-28 13:07:32 收到下发指令:叫号1>>>
2024-09-28 13:07:36 收到下发指令:叫号1>>>
2024-09-28 13:07:44 收到下发指令:叫号1>>>
2024-09-28 13:07:48 收到下发指令:叫号1>>>
2024-09-28 13:07:53 收到下发指令:叫号1>>>
2024-09-28 13:08:01 收到下发指令:叫号1>>>
2024-09-28 13:08:05 收到下发指令:叫号1>>>
2024-09-28 13:08:09 收到下发指令:叫号1>>>
2024-09-28 13:08:13 收到下发指令:叫号1>>>


===13:09:18===
2024-09-28 13:08:18 收到下发指令:叫号1>>>
2024-09-28 13:08:22 收到下发指令:叫号1>>>
2024-09-28 13:08:34 收到下发指令:叫号1>>>
2024-09-28 13:08:37 收到下发指令:叫号1>>>
2024-09-28 13:08:44 收到下发指令:叫号1>>>
2024-09-28 13:08:49 收到下发指令:叫号1>>>
2024-09-28 13:08:52 收到下发指令:叫号1>>>
2024-09-28 13:08:56 收到下发指令:叫号1>>>
2024-09-28 13:09:00 收到下发指令:叫号1>>>
2024-09-28 13:09:04 收到下发指令:叫号1>>>
2024-09-28 13:09:07 收到下发指令:叫号1>>>
2024-09-28 13:09:14 收到下发指令:叫号1>>>
2024-09-28 13:09:17 收到下发指令:叫号1>>>


===13:10:18===
2024-09-28 13:09:21 收到下发指令:叫号1>>>
2024-09-28 13:09:28 收到下发指令:叫号1>>>
2024-09-28 13:09:36 收到下发指令:叫号1>>>
2024-09-28 13:09:41 收到下发指令:叫号1>>>


===13:19:19===
2024-09-28 13:19:13 >>>回调事件[910,devices/S3222]
2024-09-28 13:19:13 >>>故障排除日志:上一MQTT订单号缓存列表为24092813052739601496
2024-09-28 13:19:13 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 13:19:13 开始打印,排队:56,票券:2409281319028795459801,订单:24092813190287950523,[2024-09-28 13:19:12微信支付10元]
2024-09-28 13:19:15 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281319028795459801","queue_number":56,"trade_uid":"24092813190287950523"}]}
2024-09-28 13:19:15 >>>故障排除日志:删除未同步下发订单成功24092813190287950523
2024-09-28 13:19:15 >>>故障排除日志:终端同步成功后剩余订单列表


===13:21:19===
2024-09-28 13:20:19 >>>回调事件[910,devices/S3222]
2024-09-28 13:20:19 >>>故障排除日志:上一MQTT订单号缓存列表为24092813190287950523
2024-09-28 13:20:19 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 13:20:19 开始打印,排队:57,票券:2409281320121972511601,订单:24092813201219718868,[2024-09-28 13:20:19微信支付10元]
2024-09-28 13:20:21 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281320121972511601","queue_number":57,"trade_uid":"24092813201219718868"}]}
2024-09-28 13:20:21 >>>故障排除日志:删除未同步下发订单成功24092813201219718868
2024-09-28 13:20:22 >>>故障排除日志:终端同步成功后剩余订单列表


===13:25:19===
2024-09-28 13:25:15 >>>回调事件[910,devices/S3222]
2024-09-28 13:25:15 >>>故障排除日志:上一MQTT订单号缓存列表为24092813201219718868
2024-09-28 13:25:15 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 13:25:15 开始打印,排队:58,票券:2409281325071780186201,订单:24092813250717798036,[2024-09-28 13:25:14微信支付10元]
2024-09-28 13:25:17 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281325071780186201","queue_number":58,"trade_uid":"24092813250717798036"}]}
2024-09-28 13:25:17 >>>故障排除日志:删除未同步下发订单成功24092813250717798036
2024-09-28 13:25:17 >>>故障排除日志:终端同步成功后剩余订单列表


===13:36:19===
2024-09-28 13:35:54>>>cash read=00
2024-09-28 13:35:55>>>cash read=00818F42
2024-09-28 13:35:55>>>cash write=02
2024-09-28 13:35:55 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-09-28 13:35:56>>>cash read=10
2024-09-28 13:35:56 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-09-28 13:35:56 当前产品价格10元，投币10元，打印小票中...
2024-09-28 13:35:56 >>>开始打印,排队号为59,订单号为2409281335560032227801
2024-09-28 13:35:56>>>订单2409281335560032227801写入成功,剩余空间为1680000,占用RAM为606.1025390625
删除未同步订单2409281335560032227801
2024-09-28 13:35:58>>>订单2409281335560032227801删除成功,剩余空间为1680500,占用RAM为618.326171875
检测订单目录中>>>
无未同步订单>>>
2024-09-28 13:35:58 >>>当前Ram内存为590.26953125
定时检测未同步订单启用
2024-09-28 13:35:59>>>cash write=0C
2024-09-28 13:35:59>>>cash read=3E


===13:37:19===
定时检测未同步订单关闭
检测订单目录中>>>
无未同步订单>>>


===13:39:20===
2024-09-28 13:38:28 收到下发指令:叫号1>>>
2024-09-28 13:38:30 收到下发指令:叫号1>>>


===13:52:20===
2024-09-28 13:51:56 收到下发指令:叫号1>>>
2024-09-28 13:52:08 收到下发指令:叫号1>>>


===13:53:20===
2024-09-28 13:52:39 收到下发指令:叫号1>>>
2024-09-28 13:52:57 收到下发指令:叫号1>>>


===13:54:20===
2024-09-28 13:53:28 收到下发指令:叫号1>>>
2024-09-28 13:53:29 >>>回调事件[910,devices/S3222]
2024-09-28 13:53:29 >>>故障排除日志:上一MQTT订单号缓存列表为24092813250717798036
2024-09-28 13:53:29 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 13:53:29 开始打印,排队:60,票券:2409281353220239280601,订单:24092813532202386069,[2024-09-28 13:53:28微信支付10元]
2024-09-28 13:53:31 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281353220239280601","queue_number":60,"trade_uid":"24092813532202386069"}]}
2024-09-28 13:53:31 >>>故障排除日志:删除未同步下发订单成功24092813532202386069
2024-09-28 13:53:31 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 13:53:41 收到下发指令:叫号1>>>


===14:05:21===
2024-09-28 14:04:27 >>>回调事件[910,devices/S3222]
2024-09-28 14:04:27 >>>故障排除日志:上一MQTT订单号缓存列表为24092813532202386069
2024-09-28 14:04:27 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 14:04:27 开始打印,排队:61,票券:2409281404196603288901,订单:24092814041966029456,[2024-09-28 14:04:26微信支付10元]
2024-09-28 14:04:27 开始打印,排队:62,票券:2409281404196603414202,订单:24092814041966029456,[2024-09-28 14:04:26微信支付10元]
2024-09-28 14:04:30 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281404196603288901","queue_number":61,"trade_uid":"24092814041966029456"},{"ticket_no":"2409281404196603414202","queue_number":62,"trade_uid":"24092814041966029456"}]}
2024-09-28 14:04:30 >>>故障排除日志:删除未同步下发订单成功24092814041966029456
2024-09-28 14:04:30 >>>故障排除日志:删除未同步下发订单成功24092814041966029456
2024-09-28 14:04:30 >>>故障排除日志:终端同步成功后剩余订单列表


===14:12:21===
2024-09-28 14:12:06>>>cash read=00
2024-09-28 14:12:07>>>cash read=00818F41
2024-09-28 14:12:07>>>cash write=02
2024-09-28 14:12:07 >>>回调事件130,cash_status,10022,进钞中...read money=5
2024-09-28 14:12:07>>>cash read=10
2024-09-28 14:12:07 >>>回调事件130,5,10023,finish Money=5,进钞完成
2024-09-28 14:12:09>>>cash write=0C
2024-09-28 14:12:09>>>cash read=3E
2024-09-28 14:12:11>>>cash read=00
2024-09-28 14:12:12>>>cash read=29
2024-09-28 14:12:12 >>>回调事件130,cash_status,20029,退钞中
2024-09-28 14:12:12>>>cash read=2F29
2024-09-28 14:12:13>>>cash read=3E
2024-09-28 14:12:15>>>cash read=00
2024-09-28 14:12:15>>>cash read=818F41
2024-09-28 14:12:15>>>cash write=02
2024-09-28 14:12:15 >>>回调事件130,cash_status,10022,进钞中...read money=5
2024-09-28 14:12:16>>>cash read=10
2024-09-28 14:12:16 >>>回调事件130,5,10023,finish Money=5,进钞完成
2024-09-28 14:12:16 当前产品价格10元，投币10元，打印小票中...
2024-09-28 14:12:16 >>>开始打印,排队号为63,订单号为2409281412070032223388
2024-09-28 14:12:16>>>订单2409281412070032223388写入成功,剩余空间为1679000,占用RAM为607.529296875
删除未同步订单2409281412070032223388
2024-09-28 14:12:18>>>订单2409281412070032223388删除成功,剩余空间为1680000,占用RAM为624.7744140625
检测订单目录中>>>
无未同步订单>>>
2024-09-28 14:12:18 >>>当前Ram内存为592.158203125
定时检测未同步订单启用
2024-09-28 14:12:19>>>cash write=0C
2024-09-28 14:12:19>>>cash read=3E


===14:13:21===
定时检测未同步订单关闭
检测订单目录中>>>
无未同步订单>>>


===14:18:22===
2024-09-28 14:17:51 >>>回调事件[910,devices/S3222]
2024-09-28 14:17:51 >>>故障排除日志:上一MQTT订单号缓存列表为24092814041966029456|24092814041966029456
2024-09-28 14:17:51 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 14:17:51 开始打印,排队:64,票券:2409281417458273370501,订单:24092814174582730046,[2024-09-28 14:17:50支付宝支付10元]
2024-09-28 14:17:51 开始打印,排队:65,票券:2409281417458273511702,订单:24092814174582730046,[2024-09-28 14:17:50支付宝支付10元]
2024-09-28 14:17:54 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281417458273370501","queue_number":64,"trade_uid":"24092814174582730046"},{"ticket_no":"2409281417458273511702","queue_number":65,"trade_uid":"24092814174582730046"}]}
2024-09-28 14:17:54 >>>故障排除日志:删除未同步下发订单成功24092814174582730046
2024-09-28 14:17:54 >>>故障排除日志:删除未同步下发订单成功24092814174582730046
2024-09-28 14:17:54 >>>故障排除日志:终端同步成功后剩余订单列表


===14:30:22===
2024-09-28 14:29:48 >>>回调事件[910,devices/S3222]
2024-09-28 14:29:48 >>>故障排除日志:上一MQTT订单号缓存列表为24092814174582730046|24092814174582730046
2024-09-28 14:29:48 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 14:29:48 开始打印,排队:66,票券:2409281429409243510401,订单:24092814294092431778,[2024-09-28 14:29:46微信支付10元]
2024-09-28 14:29:50 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281429409243510401","queue_number":66,"trade_uid":"24092814294092431778"}]}
2024-09-28 14:29:50 >>>故障排除日志:删除未同步下发订单成功24092814294092431778
2024-09-28 14:29:50 >>>故障排除日志:终端同步成功后剩余订单列表


===14:34:22===
2024-09-28 14:33:50>>>cash read=00
2024-09-28 14:33:51>>>cash read=01
2024-09-28 14:33:53>>>cash read=3E
2024-09-28 14:33:57>>>cash read=00
2024-09-28 14:33:58>>>cash read=01
2024-09-28 14:34:00>>>cash read=3E
2024-09-28 14:34:01>>>cash read=00
2024-09-28 14:34:02>>>cash read=01
2024-09-28 14:34:04>>>cash read=3E
2024-09-28 14:34:06>>>cash read=00
2024-09-28 14:34:07>>>cash read=01
2024-09-28 14:34:08>>>cash read=3E
2024-09-28 14:34:10>>>cash read=00
2024-09-28 14:34:11>>>cash read=818F41
2024-09-28 14:34:11>>>cash write=02
2024-09-28 14:34:11 >>>回调事件130,cash_status,10022,进钞中...read money=5
2024-09-28 14:34:11>>>cash read=10
2024-09-28 14:34:11 >>>回调事件130,5,10023,finish Money=5,进钞完成
2024-09-28 14:34:13>>>cash write=0C
2024-09-28 14:34:13>>>cash read=3E
2024-09-28 14:34:15>>>cash read=29
2024-09-28 14:34:15 >>>回调事件130,cash_status,20029,退钞中
2024-09-28 14:34:16>>>cash read=01
2024-09-28 14:34:18>>>cash read=3E
2024-09-28 14:34:21>>>cash read=00
2024-09-28 14:34:21>>>cash read=818F41
2024-09-28 14:34:21>>>cash write=02
2024-09-28 14:34:21 >>>回调事件130,cash_status,10022,进钞中...read money=5


===14:35:22===
2024-09-28 14:34:22>>>cash read=10
2024-09-28 14:34:22 >>>回调事件130,5,10023,finish Money=5,进钞完成
2024-09-28 14:34:22 当前产品价格10元，投币10元，打印小票中...
2024-09-28 14:34:22 >>>开始打印,排队号为67,订单号为2409281434110032221127
2024-09-28 14:34:22>>>订单2409281434110032221127写入成功,剩余空间为1680500,占用RAM为609.8583984375
删除未同步订单2409281434110032221127
2024-09-28 14:34:24>>>订单2409281434110032221127删除成功,剩余空间为1681000,占用RAM为617.841796875
检测订单目录中>>>
无未同步订单>>>
2024-09-28 14:34:24 >>>当前Ram内存为590.037109375
定时检测未同步订单启用
2024-09-28 14:34:25>>>cash write=0C
2024-09-28 14:34:25>>>cash read=3E


===14:36:23===
定时检测未同步订单关闭
检测订单目录中>>>
无未同步订单>>>


===14:39:23===
2024-09-28 14:38:57 >>>回调事件[910,devices/S3222]
2024-09-28 14:38:57 >>>故障排除日志:上一MQTT订单号缓存列表为24092814294092431778
2024-09-28 14:38:57 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 14:38:57 开始打印,排队:68,票券:2409281438499206975901,订单:24092814384992064020,[2024-09-28 14:38:56支付宝支付10元]
2024-09-28 14:38:59 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281438499206975901","queue_number":68,"trade_uid":"24092814384992064020"}]}
2024-09-28 14:38:59 >>>故障排除日志:删除未同步下发订单成功24092814384992064020
2024-09-28 14:38:59 >>>故障排除日志:终端同步成功后剩余订单列表


===14:45:24===
2024-09-28 14:45:16>>>cash read=00
2024-09-28 14:45:17>>>cash read=818F42
2024-09-28 14:45:17>>>cash write=02
2024-09-28 14:45:17 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-09-28 14:45:17>>>cash read=10
2024-09-28 14:45:17 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-09-28 14:45:17 当前产品价格10元，投币10元，打印小票中...
2024-09-28 14:45:17 >>>开始打印,排队号为69,订单号为2409281445170032222366
2024-09-28 14:45:17>>>订单2409281445170032222366写入成功,剩余空间为1680000,占用RAM为607.689453125
删除未同步订单2409281445170032222366
2024-09-28 14:45:19>>>订单2409281445170032222366删除成功,剩余空间为1680500,占用RAM为618.48828125
检测订单目录中>>>
无未同步订单>>>
2024-09-28 14:45:20 >>>当前Ram内存为590.37890625
定时检测未同步订单启用
2024-09-28 14:45:20>>>cash write=0C
2024-09-28 14:45:20>>>cash read=3E


===14:46:24===
定时检测未同步订单关闭
检测订单目录中>>>
无未同步订单>>>


===14:55:24===
2024-09-28 14:54:59 >>>回调事件[910,devices/S3222]
2024-09-28 14:54:59 >>>故障排除日志:上一MQTT订单号缓存列表为24092814384992064020
2024-09-28 14:54:59 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 14:54:59 开始打印,排队:70,票券:2409281454476719260901,订单:24092814544767187154,[2024-09-28 14:54:58微信支付10元]
2024-09-28 14:55:01 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281454476719260901","queue_number":70,"trade_uid":"24092814544767187154"}]}
2024-09-28 14:55:01 >>>故障排除日志:删除未同步下发订单成功24092814544767187154
2024-09-28 14:55:01 >>>故障排除日志:终端同步成功后剩余订单列表


===15:07:25===
2024-09-28 15:06:47>>>cash read=2F29
2024-09-28 15:06:48>>>cash read=01
2024-09-28 15:06:48>>>cash read=2F
2024-09-28 15:06:49>>>cash read=3E
2024-09-28 15:06:54>>>cash read=00
2024-09-28 15:06:55>>>cash read=818F42
2024-09-28 15:06:55>>>cash write=02
2024-09-28 15:06:55 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-09-28 15:06:55>>>cash read=10
2024-09-28 15:06:55 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-09-28 15:06:55 当前产品价格10元，投币10元，打印小票中...
2024-09-28 15:06:55 >>>开始打印,排队号为71,订单号为2409281506550032227629
2024-09-28 15:06:56>>>订单2409281506550032227629写入成功,剩余空间为1679500,占用RAM为608.8359375
删除未同步订单2409281506550032227629
2024-09-28 15:06:58>>>订单2409281506550032227629删除成功,剩余空间为1680500,占用RAM为619.0205078125
检测订单目录中>>>
无未同步订单>>>
2024-09-28 15:06:58 >>>当前Ram内存为590.849609375
定时检测未同步订单启用
2024-09-28 15:06:59>>>cash write=0C
2024-09-28 15:06:59>>>cash read=3E


===15:08:25===
定时检测未同步订单关闭
检测订单目录中>>>
无未同步订单>>>


===15:11:25===
2024-09-28 15:10:51 >>>回调事件[910,devices/S3222]
2024-09-28 15:10:51 >>>故障排除日志:上一MQTT订单号缓存列表为24092814544767187154
2024-09-28 15:10:51 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 15:10:51 开始打印,排队:72,票券:2409281510248556107401,订单:24092815102485553593,[2024-09-28 15:10:50微信支付10元]
2024-09-28 15:10:53 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281510248556107401","queue_number":72,"trade_uid":"24092815102485553593"}]}
2024-09-28 15:10:53 >>>故障排除日志:删除未同步下发订单成功24092815102485553593
2024-09-28 15:10:53 >>>故障排除日志:终端同步成功后剩余订单列表


===15:17:25===
2024-09-28 15:16:37>>>cash read=29
2024-09-28 15:16:37 >>>回调事件130,cash_status,20029,退钞中
2024-09-28 15:16:39>>>cash read=01
2024-09-28 15:16:42>>>cash read=00
2024-09-28 15:16:43>>>cash read=01
2024-09-28 15:16:48>>>cash read=3E
2024-09-28 15:16:59>>>cash read=29
2024-09-28 15:16:59 >>>回调事件130,cash_status,20029,退钞中
2024-09-28 15:17:00>>>cash read=01
2024-09-28 15:17:02>>>cash read=3E
2024-09-28 15:17:03>>>cash read=00
2024-09-28 15:17:04>>>cash read=818F42
2024-09-28 15:17:04>>>cash write=02
2024-09-28 15:17:04 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-09-28 15:17:04>>>cash read=10
2024-09-28 15:17:04 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-09-28 15:17:04 当前产品价格10元，投币10元，打印小票中...
2024-09-28 15:17:04 >>>开始打印,排队号为73,订单号为2409281517040032221445
2024-09-28 15:17:05>>>订单2409281517040032221445写入成功,剩余空间为1679500,占用RAM为610.3837890625
删除未同步订单2409281517040032221445
2024-09-28 15:17:07>>>订单2409281517040032221445删除成功,剩余空间为1680000,占用RAM为619.6982421875
检测订单目录中>>>
无未同步订单>>>
2024-09-28 15:17:07 >>>当前Ram内存为591.06640625
定时检测未同步订单启用
2024-09-28 15:17:08>>>cash write=0C
2024-09-28 15:17:08>>>cash read=3E


===15:18:25===
2024-09-28 15:17:27 >>>回调事件[910,devices/S3222]
2024-09-28 15:17:27 >>>故障排除日志:上一MQTT订单号缓存列表为24092815102485553593
2024-09-28 15:17:27 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 15:17:27 开始打印,排队:74,票券:2409281517181575902301,订单:24092815171815754309,[2024-09-28 15:17:26微信支付10元]
2024-09-28 15:17:29 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281517181575902301","queue_number":74,"trade_uid":"24092815171815754309"}]}
2024-09-28 15:17:29 >>>故障排除日志:删除未同步下发订单成功24092815171815754309
2024-09-28 15:17:29 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单关闭
检测订单目录中>>>
无未同步订单>>>


===15:23:26===
2024-09-28 15:23:23 >>>回调事件[910,devices/S3222]
2024-09-28 15:23:23 >>>故障排除日志:上一MQTT订单号缓存列表为24092815171815754309
2024-09-28 15:23:23 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 15:23:23 开始打印,排队:75,票券:2409281523103230272501,订单:24092815231032298629,[2024-09-28 15:23:22支付宝支付10元]
2024-09-28 15:23:25 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281523103230272501","queue_number":75,"trade_uid":"24092815231032298629"}]}
2024-09-28 15:23:25 >>>故障排除日志:删除未同步下发订单成功24092815231032298629
2024-09-28 15:23:25 >>>故障排除日志:终端同步成功后剩余订单列表


===15:26:26===
2024-09-28 15:26:12>>>cash read=0A
2024-09-28 15:26:14>>>cash read=3E


===15:30:26===
2024-09-28 15:29:43>>>cash read=29
2024-09-28 15:29:43 >>>回调事件130,cash_status,20029,退钞中
2024-09-28 15:29:44>>>cash read=2F29
2024-09-28 15:29:46>>>cash read=3E
2024-09-28 15:29:51>>>cash read=00
2024-09-28 15:29:52>>>cash read=818F43
2024-09-28 15:29:52>>>cash write=02
2024-09-28 15:29:52 >>>回调事件130,cash_status,10022,进钞中...read money=20
2024-09-28 15:29:53>>>cash read=10
2024-09-28 15:29:53 >>>回调事件130,20,10023,finish Money=20,进钞完成
2024-09-28 15:29:53 当前产品价格10元，投币20元，打印小票中...
2024-09-28 15:29:53 >>>开始打印,排队号为76,订单号为2409281529530032221873
2024-09-28 15:29:53 >>>开始打印,排队号为77,订单号为2409281529530032221873
2024-09-28 15:29:53>>>订单2409281529530032221873写入成功,剩余空间为1679000,占用RAM为616.201171875
删除未同步订单2409281529530032221873
2024-09-28 15:29:57>>>订单2409281529530032221873删除成功,剩余空间为1680500,占用RAM为631.4375
检测订单目录中>>>
无未同步订单>>>
2024-09-28 15:29:57 >>>当前Ram内存为592.3779296875
定时检测未同步订单启用
2024-09-28 15:29:58>>>cash write=0C
2024-09-28 15:29:58>>>cash read=3E
2024-09-28 15:30:05 >>>回调事件[910,devices/S3222]
2024-09-28 15:30:05 >>>故障排除日志:上一MQTT订单号缓存列表为24092815231032298629
2024-09-28 15:30:05 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 15:30:05 开始打印,排队:78,票券:2409281529545951246101,订单:24092815295459508704,[2024-09-28 15:30:04微信支付10元]
2024-09-28 15:30:07 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281529545951246101","queue_number":78,"trade_uid":"24092815295459508704"}]}
2024-09-28 15:30:07 >>>故障排除日志:删除未同步下发订单成功24092815295459508704
2024-09-28 15:30:07 >>>故障排除日志:终端同步成功后剩余订单列表


===15:31:26===
2024-09-28 15:30:26 >>>回调事件[910,devices/S3222]
2024-09-28 15:30:26 >>>故障排除日志:上一MQTT订单号缓存列表为24092815295459508704
2024-09-28 15:30:26 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 15:30:26 开始打印,排队:79,票券:2409281530188521079701,订单:24092815301885206292,[2024-09-28 15:30:25微信支付10元]
2024-09-28 15:30:28 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281530188521079701","queue_number":79,"trade_uid":"24092815301885206292"}]}
2024-09-28 15:30:28 >>>故障排除日志:删除未同步下发订单成功24092815301885206292
2024-09-28 15:30:28 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单关闭
检测订单目录中>>>
无未同步订单>>>


===15:34:27===
2024-09-28 15:33:38 >>>回调事件[910,devices/S3222]
2024-09-28 15:33:38 >>>故障排除日志:上一MQTT订单号缓存列表为24092815301885206292
2024-09-28 15:33:38 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 15:33:38 开始打印,排队:80,票券:2409281533301644045201,订单:24092815333016436348,[2024-09-28 15:33:37微信支付10元]
2024-09-28 15:33:40 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281533301644045201","queue_number":80,"trade_uid":"24092815333016436348"}]}
2024-09-28 15:33:40 >>>故障排除日志:删除未同步下发订单成功24092815333016436348
2024-09-28 15:33:40 >>>故障排除日志:终端同步成功后剩余订单列表


===15:42:27===
2024-09-28 15:42:00 >>>回调事件[910,devices/S3222]
2024-09-28 15:42:00 >>>故障排除日志:上一MQTT订单号缓存列表为24092815333016436348
2024-09-28 15:42:00 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 15:42:00 开始打印,排队:81,票券:2409281541530225489301,订单:24092815415302247936,[2024-09-28 15:41:59微信支付10元]
2024-09-28 15:42:02 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281541530225489301","queue_number":81,"trade_uid":"24092815415302247936"}]}
2024-09-28 15:42:02 >>>故障排除日志:删除未同步下发订单成功24092815415302247936
2024-09-28 15:42:02 >>>故障排除日志:终端同步成功后剩余订单列表


===15:43:27===
2024-09-28 15:43:09 >>>回调事件[910,devices/S3222]
2024-09-28 15:43:10 >>>故障排除日志:上一MQTT订单号缓存列表为24092815415302247936
2024-09-28 15:43:10 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 15:43:10 开始打印,排队:82,票券:2409281543011571799201,订单:24092815430115713191,[2024-09-28 15:43:08微信支付10元]
2024-09-28 15:43:12 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281543011571799201","queue_number":82,"trade_uid":"24092815430115713191"}]}
2024-09-28 15:43:12 >>>故障排除日志:删除未同步下发订单成功24092815430115713191
2024-09-28 15:43:12 >>>故障排除日志:终端同步成功后剩余订单列表


===15:48:27===
2024-09-28 15:47:36 >>>回调事件[910,devices/S3222]
2024-09-28 15:47:36 >>>故障排除日志:上一MQTT订单号缓存列表为24092815430115713191
2024-09-28 15:47:36 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 15:47:36 开始打印,排队:83,票券:2409281547284753480901,订单:24092815472847530691,[2024-09-28 15:47:35微信支付10元]
2024-09-28 15:47:38 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281547284753480901","queue_number":83,"trade_uid":"24092815472847530691"}]}
2024-09-28 15:47:38 >>>故障排除日志:删除未同步下发订单成功24092815472847530691
2024-09-28 15:47:38 >>>故障排除日志:终端同步成功后剩余订单列表


===16:01:28===
2024-09-28 16:00:51 >>>回调事件[910,devices/S3222]
2024-09-28 16:00:51 >>>故障排除日志:上一MQTT订单号缓存列表为24092815472847530691
2024-09-28 16:00:51 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 16:00:51 开始打印,排队:84,票券:2409281600449874478201,订单:24092816004498738973,[2024-09-28 16:00:50微信支付10元]
2024-09-28 16:00:53 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281600449874478201","queue_number":84,"trade_uid":"24092816004498738973"}]}
2024-09-28 16:00:53 >>>故障排除日志:删除未同步下发订单成功24092816004498738973
2024-09-28 16:00:53 >>>故障排除日志:终端同步成功后剩余订单列表


===16:02:28===
2024-09-28 16:02:10 >>>回调事件[910,devices/S3222]
2024-09-28 16:02:10 >>>故障排除日志:上一MQTT订单号缓存列表为24092816004498738973
2024-09-28 16:02:10 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 16:02:10 开始打印,排队:85,票券:2409281602043651688901,订单:24092816020436512974,[2024-09-28 16:02:09微信支付10元]
2024-09-28 16:02:12 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281602043651688901","queue_number":85,"trade_uid":"24092816020436512974"}]}
2024-09-28 16:02:12 >>>故障排除日志:删除未同步下发订单成功24092816020436512974
2024-09-28 16:02:12 >>>故障排除日志:终端同步成功后剩余订单列表


===16:03:28===
2024-09-28 16:03:09 >>>回调事件[910,devices/S3222]
2024-09-28 16:03:09 >>>故障排除日志:上一MQTT订单号缓存列表为24092816020436512974
2024-09-28 16:03:09 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 16:03:09 开始打印,排队:86,票券:2409281603008826035801,订单:24092816030088254309,[2024-09-28 16:03:08支付宝支付10元]
2024-09-28 16:03:11 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281603008826035801","queue_number":86,"trade_uid":"24092816030088254309"}]}
2024-09-28 16:03:11 >>>故障排除日志:删除未同步下发订单成功24092816030088254309
2024-09-28 16:03:11 >>>故障排除日志:终端同步成功后剩余订单列表


===16:05:29===
2024-09-28 16:05:26>>>cash read=00
2024-09-28 16:05:26>>>cash read=818F42
2024-09-28 16:05:26>>>cash write=02
2024-09-28 16:05:26 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-09-28 16:05:26>>>cash read=10
2024-09-28 16:05:26 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-09-28 16:05:26 当前产品价格10元，投币10元，打印小票中...
2024-09-28 16:05:26 >>>开始打印,排队号为87,订单号为2409281605260032227329
2024-09-28 16:05:26>>>订单2409281605260032227329写入成功,剩余空间为1680000,占用RAM为608.3388671875


===16:06:29===
删除未同步订单2409281605260032227329
2024-09-28 16:05:28>>>订单2409281605260032227329删除成功,剩余空间为1681500,占用RAM为623.400390625
检测订单目录中>>>
无未同步订单>>>
2024-09-28 16:05:29 >>>当前Ram内存为589.966796875
定时检测未同步订单启用
2024-09-28 16:05:29>>>cash write=0C
2024-09-28 16:05:30>>>cash read=3E


===16:07:29===
2024-09-28 16:06:59>>>cash read=00
2024-09-28 16:07:00>>>cash read=818F42
2024-09-28 16:07:00>>>cash write=02
2024-09-28 16:07:00 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-09-28 16:07:00>>>cash read=10
2024-09-28 16:07:00 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-09-28 16:07:00 当前产品价格10元，投币10元，打印小票中...
2024-09-28 16:07:00 >>>开始打印,排队号为88,订单号为2409281607000032225877
2024-09-28 16:07:01>>>订单2409281607000032225877写入成功,剩余空间为1680000,占用RAM为607.5048828125
删除未同步订单2409281607000032225877
2024-09-28 16:07:03>>>订单2409281607000032225877删除成功,剩余空间为1680500,占用RAM为618.314453125
检测订单目录中>>>
无未同步订单>>>
2024-09-28 16:07:03 >>>当前Ram内存为590.1611328125
定时检测未同步订单启用
2024-09-28 16:07:04>>>cash write=0C
2024-09-28 16:07:04>>>cash read=3E
2024-09-28 16:07:18 >>>回调事件[910,devices/S3222]
2024-09-28 16:07:18 >>>故障排除日志:上一MQTT订单号缓存列表为24092816030088254309
2024-09-28 16:07:18 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 16:07:18 开始打印,排队:89,票券:2409281607121444115801,订单:24092816071214434553,[2024-09-28 16:07:17微信支付10元]
2024-09-28 16:07:20 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281607121444115801","queue_number":89,"trade_uid":"24092816071214434553"}]}
2024-09-28 16:07:21 >>>故障排除日志:删除未同步下发订单成功24092816071214434553
2024-09-28 16:07:21 >>>故障排除日志:终端同步成功后剩余订单列表


===16:08:30===
定时检测未同步订单关闭
检测订单目录中>>>
无未同步订单>>>


===16:09:30===
2024-09-28 16:09:23>>>cash read=00818F42
2024-09-28 16:09:23>>>cash write=02
2024-09-28 16:09:23 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-09-28 16:09:23>>>cash read=10
2024-09-28 16:09:23 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-09-28 16:09:23 当前产品价格10元，投币10元，打印小票中...
2024-09-28 16:09:23 >>>开始打印,排队号为90,订单号为2409281609230032225051
2024-09-28 16:09:23>>>订单2409281609230032225051写入成功,剩余空间为1680000,占用RAM为604.0927734375
删除未同步订单2409281609230032225051
2024-09-28 16:09:25>>>订单2409281609230032225051删除成功,剩余空间为1680500,占用RAM为617.0478515625
检测订单目录中>>>
无未同步订单>>>
2024-09-28 16:09:26 >>>当前Ram内存为588.8388671875
定时检测未同步订单启用
2024-09-28 16:09:26>>>cash write=0C
2024-09-28 16:09:27>>>cash read=3E


===16:10:30===
定时检测未同步订单关闭
检测订单目录中>>>
无未同步订单>>>


===16:23:31===
2024-09-28 16:22:51 >>>回调事件[910,devices/S3222]
2024-09-28 16:22:51 >>>故障排除日志:上一MQTT订单号缓存列表为24092816071214434553
2024-09-28 16:22:51 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 16:22:51 开始打印,排队:91,票券:2409281622398432266301,订单:24092816223984318778,[2024-09-28 16:22:50支付宝支付10元]
2024-09-28 16:22:53 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281622398432266301","queue_number":91,"trade_uid":"24092816223984318778"}]}
2024-09-28 16:22:53 >>>故障排除日志:删除未同步下发订单成功24092816223984318778
2024-09-28 16:22:53 >>>故障排除日志:终端同步成功后剩余订单列表


===16:25:31===
2024-09-28 16:24:54 >>>回调事件[910,devices/S3222]
2024-09-28 16:24:54 >>>故障排除日志:上一MQTT订单号缓存列表为24092816223984318778
2024-09-28 16:24:54 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 16:24:54 开始打印,排队:92,票券:2409281624470417325201,订单:24092816244704167235,[2024-09-28 16:24:52微信支付10元]
2024-09-28 16:24:56 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281624470417325201","queue_number":92,"trade_uid":"24092816244704167235"}]}
2024-09-28 16:24:56 >>>故障排除日志:删除未同步下发订单成功24092816244704167235
2024-09-28 16:24:56 >>>故障排除日志:终端同步成功后剩余订单列表


===16:28:31===
2024-09-28 16:27:56 >>>回调事件[910,devices/S3222]
2024-09-28 16:27:56 >>>故障排除日志:上一MQTT订单号缓存列表为24092816244704167235
2024-09-28 16:27:56 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 16:27:56 开始打印,排队:93,票券:2409281627465888525101,订单:24092816274658881026,[2024-09-28 16:27:54支付宝支付10元]
2024-09-28 16:27:58 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281627465888525101","queue_number":93,"trade_uid":"24092816274658881026"}]}
2024-09-28 16:27:58 >>>故障排除日志:删除未同步下发订单成功24092816274658881026
2024-09-28 16:27:58 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 16:28:00 >>>回调事件[910,devices/S3222]
2024-09-28 16:28:00 >>>故障排除日志:上一MQTT订单号缓存列表为24092816274658881026
2024-09-28 16:28:00 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 16:28:00 开始打印,排队:94,票券:2409281627520813650501,订单:24092816275207714590,[2024-09-28 16:27:59微信支付10元]
2024-09-28 16:28:02 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281627520813650501","queue_number":94,"trade_uid":"24092816275207714590"}]}
2024-09-28 16:28:02 >>>故障排除日志:删除未同步下发订单成功24092816275207714590
2024-09-28 16:28:02 >>>故障排除日志:终端同步成功后剩余订单列表


===16:30:31===
2024-09-28 16:29:58 >>>回调事件[910,devices/S3222]
2024-09-28 16:29:58 >>>故障排除日志:上一MQTT订单号缓存列表为24092816275207714590
2024-09-28 16:29:58 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 16:29:58 开始打印,排队:95,票券:2409281629337336523601,订单:24092816293373359950,[2024-09-28 16:29:57微信支付10元]
2024-09-28 16:30:00 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281629337336523601","queue_number":95,"trade_uid":"24092816293373359950"}]}
2024-09-28 16:30:00 >>>故障排除日志:删除未同步下发订单成功24092816293373359950
2024-09-28 16:30:00 >>>故障排除日志:终端同步成功后剩余订单列表


===16:32:32===
2024-09-28 16:31:56 >>>回调事件[910,devices/S3222]
2024-09-28 16:31:56 >>>故障排除日志:上一MQTT订单号缓存列表为24092816293373359950
2024-09-28 16:31:56 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 16:31:56 开始打印,排队:96,票券:2409281631499080756301,订单:24092816314990803179,[2024-09-28 16:31:55微信支付10元]
2024-09-28 16:31:58 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281631499080756301","queue_number":96,"trade_uid":"24092816314990803179"}]}
2024-09-28 16:31:58 >>>故障排除日志:删除未同步下发订单成功24092816314990803179
2024-09-28 16:31:58 >>>故障排除日志:终端同步成功后剩余订单列表


===16:36:32===
2024-09-28 16:35:42 >>>回调事件[910,devices/S3222]
2024-09-28 16:35:42 >>>故障排除日志:上一MQTT订单号缓存列表为24092816314990803179
2024-09-28 16:35:42 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 16:35:42 开始打印,排队:97,票券:2409281635300650331201,订单:24092816353006499230,[2024-09-28 16:35:41支付宝支付10元]
2024-09-28 16:35:44 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281635300650331201","queue_number":97,"trade_uid":"24092816353006499230"}]}
2024-09-28 16:35:44 >>>故障排除日志:删除未同步下发订单成功24092816353006499230
2024-09-28 16:35:44 >>>故障排除日志:终端同步成功后剩余订单列表


===16:39:34===
2024-09-28 16:39:31 >>>回调事件[910,devices/S3222]
2024-09-28 16:39:31 >>>故障排除日志:上一MQTT订单号缓存列表为24092816353006499230
2024-09-28 16:39:31 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 16:39:31 开始打印,排队:98,票券:2409281639149101959701,订单:24092816391491004340,[2024-09-28 16:39:30微信支付10元]


===16:40:34===
2024-09-28 16:39:33 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281639149101959701","queue_number":98,"trade_uid":"24092816391491004340"}]}
2024-09-28 16:39:33 >>>故障排除日志:删除未同步下发订单成功24092816391491004340
2024-09-28 16:39:33 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 16:39:42 >>>回调事件[910,devices/S3222]
2024-09-28 16:39:42 >>>故障排除日志:上一MQTT订单号缓存列表为24092816391491004340
2024-09-28 16:39:42 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 16:39:42 开始打印,排队:99,票券:2409281639354232875201,订单:24092816393542325298,[2024-09-28 16:39:41微信支付10元]
2024-09-28 16:39:44 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281639354232875201","queue_number":99,"trade_uid":"24092816393542325298"}]}
2024-09-28 16:39:44 >>>故障排除日志:删除未同步下发订单成功24092816393542325298
2024-09-28 16:39:44 >>>故障排除日志:终端同步成功后剩余订单列表


===16:55:34===
2024-09-28 16:55:02 >>>回调事件[910,devices/S3222]
2024-09-28 16:55:02 >>>故障排除日志:上一MQTT订单号缓存列表为24092816393542325298
2024-09-28 16:55:02 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 16:55:02 开始打印,排队:100,票券:2409281654539287954301,订单:24092816545392875241,[2024-09-28 16:55:01微信支付10元]
2024-09-28 16:55:04 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281654539287954301","queue_number":100,"trade_uid":"24092816545392875241"}]}
2024-09-28 16:55:04 >>>故障排除日志:删除未同步下发订单成功24092816545392875241
2024-09-28 16:55:04 >>>故障排除日志:终端同步成功后剩余订单列表


===16:58:35===
2024-09-28 16:58:21>>>cash read=0A
2024-09-28 16:58:22>>>cash read=3E
2024-09-28 16:58:23 >>>回调事件[910,devices/S3222]
2024-09-28 16:58:23 >>>故障排除日志:上一MQTT订单号缓存列表为24092816545392875241
2024-09-28 16:58:23 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 16:58:23 开始打印,排队:101,票券:2409281658105801697201,订单:24092816581058013340,[2024-09-28 16:58:22微信支付10元]
2024-09-28 16:58:25 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281658105801697201","queue_number":101,"trade_uid":"24092816581058013340"}]}
2024-09-28 16:58:25 >>>故障排除日志:删除未同步下发订单成功24092816581058013340
2024-09-28 16:58:25 >>>故障排除日志:终端同步成功后剩余订单列表


===16:59:35===
2024-09-28 16:59:26 >>>回调事件[910,devices/S3222]
2024-09-28 16:59:26 >>>故障排除日志:上一MQTT订单号缓存列表为24092816581058013340
2024-09-28 16:59:26 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 16:59:26 开始打印,排队:102,票券:2409281659212763340601,订单:24092816592127627647,[2024-09-28 16:59:25微信支付10元]
2024-09-28 16:59:28 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281659212763340601","queue_number":102,"trade_uid":"24092816592127627647"}]}
2024-09-28 16:59:28 >>>故障排除日志:删除未同步下发订单成功24092816592127627647
2024-09-28 16:59:28 >>>故障排除日志:终端同步成功后剩余订单列表


===17:01:35===
2024-09-28 17:00:43 >>>回调事件[910,devices/S3222]
2024-09-28 17:00:43 >>>故障排除日志:上一MQTT订单号缓存列表为24092816592127627647
2024-09-28 17:00:43 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 17:00:43 开始打印,排队:103,票券:2409281700366861480801,订单:24092817003668611376,[2024-09-28 17:00:43微信支付10元]
2024-09-28 17:00:45 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281700366861480801","queue_number":103,"trade_uid":"24092817003668611376"}]}
2024-09-28 17:00:45 >>>故障排除日志:删除未同步下发订单成功24092817003668611376
2024-09-28 17:00:46 >>>故障排除日志:终端同步成功后剩余订单列表


===17:04:35===
2024-09-28 17:03:56 >>>回调事件[910,devices/S3222]
2024-09-28 17:03:56 >>>故障排除日志:上一MQTT订单号缓存列表为24092817003668611376
2024-09-28 17:03:56 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 17:03:56 开始打印,排队:104,票券:2409281703485350597001,订单:24092817034853500745,[2024-09-28 17:03:55微信支付10元]
2024-09-28 17:03:58 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281703485350597001","queue_number":104,"trade_uid":"24092817034853500745"}]}
2024-09-28 17:03:58 >>>故障排除日志:删除未同步下发订单成功24092817034853500745
2024-09-28 17:03:58 >>>故障排除日志:终端同步成功后剩余订单列表


===17:14:35===
2024-09-28 17:14:19 >>>回调事件[910,devices/S3222]
2024-09-28 17:14:19 >>>故障排除日志:上一MQTT订单号缓存列表为24092817034853500745
2024-09-28 17:14:19 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 17:14:19 开始打印,排队:105,票券:2409281714132087847901,订单:24092817141320872925,[2024-09-28 17:14:18微信支付10元]
2024-09-28 17:14:21 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281714132087847901","queue_number":105,"trade_uid":"24092817141320872925"}]}
2024-09-28 17:14:21 >>>故障排除日志:删除未同步下发订单成功24092817141320872925
2024-09-28 17:14:21 >>>故障排除日志:终端同步成功后剩余订单列表


===17:16:36===
2024-09-28 17:16:30 >>>回调事件[910,devices/S3222]
2024-09-28 17:16:30 >>>故障排除日志:上一MQTT订单号缓存列表为24092817141320872925
2024-09-28 17:16:30 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 17:16:30 开始打印,排队:106,票券:2409281716230459738601,订单:24092817162304580840,[2024-09-28 17:16:29支付宝支付10元]
2024-09-28 17:16:32 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281716230459738601","queue_number":106,"trade_uid":"24092817162304580840"}]}
2024-09-28 17:16:32 >>>故障排除日志:删除未同步下发订单成功24092817162304580840
2024-09-28 17:16:32 >>>故障排除日志:终端同步成功后剩余订单列表


===17:17:36===
2024-09-28 17:17:13 >>>回调事件[910,devices/S3222]
2024-09-28 17:17:13 >>>故障排除日志:上一MQTT订单号缓存列表为24092817162304580840
2024-09-28 17:17:13 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 17:17:13 开始打印,排队:107,票券:2409281717050246675401,订单:24092817170502463282,[2024-09-28 17:17:11微信支付10元]
2024-09-28 17:17:15 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281717050246675401","queue_number":107,"trade_uid":"24092817170502463282"}]}
2024-09-28 17:17:15 >>>故障排除日志:删除未同步下发订单成功24092817170502463282
2024-09-28 17:17:15 >>>故障排除日志:终端同步成功后剩余订单列表


===17:30:36===
2024-09-28 17:29:40 >>>回调事件[910,devices/S3222]
2024-09-28 17:29:40 >>>故障排除日志:上一MQTT订单号缓存列表为24092817170502463282
2024-09-28 17:29:40 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 17:29:41 开始打印,排队:108,票券:2409281729324560995901,订单:24092817293245602559,[2024-09-28 17:29:39微信支付10元]
2024-09-28 17:29:43 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281729324560995901","queue_number":108,"trade_uid":"24092817293245602559"}]}
2024-09-28 17:29:43 >>>故障排除日志:删除未同步下发订单成功24092817293245602559
2024-09-28 17:29:43 >>>故障排除日志:终端同步成功后剩余订单列表


===17:33:36===
2024-09-28 17:33:07 >>>回调事件[910,devices/S3222]
2024-09-28 17:33:07 >>>故障排除日志:上一MQTT订单号缓存列表为24092817293245602559
2024-09-28 17:33:07 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 17:33:07 开始打印,排队:109,票券:2409281732568523120201,订单:24092817325685227117,[2024-09-28 17:33:06支付宝支付10元]
2024-09-28 17:33:09 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281732568523120201","queue_number":109,"trade_uid":"24092817325685227117"}]}
2024-09-28 17:33:09 >>>故障排除日志:删除未同步下发订单成功24092817325685227117
2024-09-28 17:33:09 >>>故障排除日志:终端同步成功后剩余订单列表


===17:34:37===
2024-09-28 17:33:46 >>>回调事件[910,devices/S3222]
2024-09-28 17:33:46 >>>故障排除日志:上一MQTT订单号缓存列表为24092817325685227117
2024-09-28 17:33:46 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 17:33:46 开始打印,排队:110,票券:2409281733369629693801,订单:24092817333696290973,[2024-09-28 17:33:45微信支付10元]
2024-09-28 17:33:48 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281733369629693801","queue_number":110,"trade_uid":"24092817333696290973"}]}
2024-09-28 17:33:48 >>>故障排除日志:删除未同步下发订单成功24092817333696290973
2024-09-28 17:33:48 >>>故障排除日志:终端同步成功后剩余订单列表


===17:42:37===
2024-09-28 17:42:28 收到下发指令:叫号1>>>


===17:43:37===
2024-09-28 17:42:47 收到下发指令:叫号1>>>
2024-09-28 17:43:09 收到下发指令:叫号1>>>
2024-09-28 17:43:18 收到下发指令:叫号1>>>
2024-09-28 17:43:24 收到下发指令:叫号1>>>
2024-09-28 17:43:28 收到下发指令:叫号1>>>
2024-09-28 17:43:34 收到下发指令:叫号1>>>


===17:44:37===
2024-09-28 17:43:39 收到下发指令:叫号1>>>
2024-09-28 17:43:44 收到下发指令:叫号1>>>
2024-09-28 17:43:52 收到下发指令:叫号1>>>
2024-09-28 17:43:56 收到下发指令:叫号1>>>
2024-09-28 17:44:05 收到下发指令:叫号1>>>
2024-09-28 17:44:17 收到下发指令:叫号1>>>


===17:45:38===
2024-09-28 17:44:37 收到下发指令:叫号1>>>
2024-09-28 17:44:41 收到下发指令:叫号1>>>
2024-09-28 17:44:55 收到下发指令:叫号1>>>
2024-09-28 17:45:06 收到下发指令:叫号1>>>
2024-09-28 17:45:17 收到下发指令:叫号1>>>
2024-09-28 17:45:24 收到下发指令:叫号1>>>
2024-09-28 17:45:28 收到下发指令:叫号1>>>
2024-09-28 17:45:34 收到下发指令:叫号1>>>


===17:46:38===
2024-09-28 17:45:40 收到下发指令:叫号1>>>
2024-09-28 17:45:58 收到下发指令:叫号1>>>
2024-09-28 17:46:13 收到下发指令:叫号1>>>
2024-09-28 17:46:19 收到下发指令:叫号1>>>
2024-09-28 17:46:24 收到下发指令:叫号1>>>
2024-09-28 17:46:34 >>>回调事件[910,devices/S3222]
2024-09-28 17:46:34 >>>故障排除日志:上一MQTT订单号缓存列表为24092817333696290973
2024-09-28 17:46:34 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 17:46:34 开始打印,排队:111,票券:2409281746263659221401,订单:24092817462636588610,[2024-09-28 17:46:33微信支付10元]
2024-09-28 17:46:36 收到下发指令:叫号0>>>
2024-09-28 17:46:36 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281746263659221401","queue_number":111,"trade_uid":"24092817462636588610"}]}
2024-09-28 17:46:36 >>>故障排除日志:删除未同步下发订单成功24092817462636588610
2024-09-28 17:46:36 >>>故障排除日志:终端同步成功后剩余订单列表


===17:47:38===
2024-09-28 17:46:41 收到下发指令:叫号1>>>
2024-09-28 17:46:46 收到下发指令:叫号1>>>
2024-09-28 17:46:51 收到下发指令:叫号1>>>
2024-09-28 17:46:59 收到下发指令:叫号1>>>
2024-09-28 17:47:05 收到下发指令:叫号1>>>
2024-09-28 17:47:10 收到下发指令:叫号1>>>
2024-09-28 17:47:19 收到下发指令:叫号1>>>
2024-09-28 17:47:36 收到下发指令:叫号1>>>


===17:48:38===
2024-09-28 17:47:51 收到下发指令:叫号1>>>
2024-09-28 17:47:59 收到下发指令:叫号1>>>
2024-09-28 17:48:06 收到下发指令:叫号1>>>
2024-09-28 17:48:18 收到下发指令:叫号1>>>


===17:49:38===
2024-09-28 17:49:32 >>>回调事件[910,devices/S3222]
2024-09-28 17:49:32 >>>故障排除日志:上一MQTT订单号缓存列表为24092817462636588610
2024-09-28 17:49:32 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 17:49:32 开始打印,排队:112,票券:2409281749251207141901,订单:24092817492512066406,[2024-09-28 17:49:32微信支付10元]
2024-09-28 17:49:34 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281749251207141901","queue_number":112,"trade_uid":"24092817492512066406"}]}
2024-09-28 17:49:34 >>>故障排除日志:删除未同步下发订单成功24092817492512066406
2024-09-28 17:49:34 >>>故障排除日志:终端同步成功后剩余订单列表


===17:59:39===
2024-09-28 17:59:27 >>>回调事件[910,devices/S3222]
2024-09-28 17:59:27 >>>故障排除日志:上一MQTT订单号缓存列表为24092817492512066406
2024-09-28 17:59:27 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 17:59:27 开始打印,排队:113,票券:2409281759162767858001,订单:24092817591627673990,[2024-09-28 17:59:26微信支付10元]
2024-09-28 17:59:29 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281759162767858001","queue_number":113,"trade_uid":"24092817591627673990"}]}
2024-09-28 17:59:29 >>>故障排除日志:删除未同步下发订单成功24092817591627673990
2024-09-28 17:59:29 >>>故障排除日志:终端同步成功后剩余订单列表


===18:02:39===
2024-09-28 18:02:06 >>>回调事件[910,devices/S3222]
2024-09-28 18:02:07 >>>故障排除日志:上一MQTT订单号缓存列表为24092817591627673990
2024-09-28 18:02:07 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 18:02:07 开始打印,排队:114,票券:2409281801585351527101,订单:24092818015853510435,[2024-09-28 18:02:05微信支付10元]
2024-09-28 18:02:09 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281801585351527101","queue_number":114,"trade_uid":"24092818015853510435"}]}
2024-09-28 18:02:09 >>>故障排除日志:删除未同步下发订单成功24092818015853510435
2024-09-28 18:02:09 >>>故障排除日志:终端同步成功后剩余订单列表


===18:10:39===
2024-09-28 18:09:45 >>>回调事件[910,devices/S3222]
2024-09-28 18:09:45 >>>故障排除日志:上一MQTT订单号缓存列表为24092818015853510435
2024-09-28 18:09:45 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 18:09:45 开始打印,排队:115,票券:2409281809374918566501,订单:24092818093749179828,[2024-09-28 18:09:45微信支付10元]
2024-09-28 18:09:47 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281809374918566501","queue_number":115,"trade_uid":"24092818093749179828"}]}
2024-09-28 18:09:47 >>>故障排除日志:删除未同步下发订单成功24092818093749179828
2024-09-28 18:09:48 >>>故障排除日志:终端同步成功后剩余订单列表


===18:12:39===
2024-09-28 18:12:34 >>>回调事件[910,devices/S3222]
2024-09-28 18:12:34 >>>故障排除日志:上一MQTT订单号缓存列表为24092818093749179828
2024-09-28 18:12:34 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 18:12:34 开始打印,排队:116,票券:2409281812249290753001,订单:24092818122492903565,[2024-09-28 18:12:33微信支付10元]
2024-09-28 18:12:36 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281812249290753001","queue_number":116,"trade_uid":"24092818122492903565"}]}
2024-09-28 18:12:36 >>>故障排除日志:删除未同步下发订单成功24092818122492903565
2024-09-28 18:12:36 >>>故障排除日志:终端同步成功后剩余订单列表


===18:14:39===
2024-09-28 18:13:51 >>>回调事件[910,devices/S3222]
2024-09-28 18:13:51 >>>故障排除日志:上一MQTT订单号缓存列表为24092818122492903565
2024-09-28 18:13:51 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 18:13:51 开始打印,排队:117,票券:2409281813445555783001,订单:24092818134455553529,[2024-09-28 18:13:50支付宝支付10元]
2024-09-28 18:13:53 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281813445555783001","queue_number":117,"trade_uid":"24092818134455553529"}]}
2024-09-28 18:13:53 >>>故障排除日志:删除未同步下发订单成功24092818134455553529
2024-09-28 18:13:53 >>>故障排除日志:终端同步成功后剩余订单列表


===18:19:40===
2024-09-28 18:18:52 >>>回调事件[910,devices/S3222]
2024-09-28 18:18:52 >>>故障排除日志:上一MQTT订单号缓存列表为24092818134455553529
2024-09-28 18:18:52 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 18:18:52 开始打印,排队:118,票券:2409281818454876908101,订单:24092818184548764246,[2024-09-28 18:18:51微信支付10元]
2024-09-28 18:18:54 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281818454876908101","queue_number":118,"trade_uid":"24092818184548764246"}]}
2024-09-28 18:18:54 >>>故障排除日志:删除未同步下发订单成功24092818184548764246
2024-09-28 18:18:54 >>>故障排除日志:终端同步成功后剩余订单列表


===18:24:40===
2024-09-28 18:24:22>>>cash read=00
2024-09-28 18:24:23>>>cash read=818F42
2024-09-28 18:24:23>>>cash write=02
2024-09-28 18:24:23 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-09-28 18:24:23>>>cash read=10
2024-09-28 18:24:23 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-09-28 18:24:23 当前产品价格10元，投币10元，打印小票中...
2024-09-28 18:24:23 >>>开始打印,排队号为119,订单号为2409281824230032221819
2024-09-28 18:24:23>>>订单2409281824230032221819写入成功,剩余空间为1680000,占用RAM为608.0126953125
删除未同步订单2409281824230032221819
2024-09-28 18:24:25>>>订单2409281824230032221819删除成功,剩余空间为1680500,占用RAM为618.791015625
检测订单目录中>>>
无未同步订单>>>
2024-09-28 18:24:25 >>>当前Ram内存为590.71875
定时检测未同步订单启用
2024-09-28 18:24:26>>>cash write=0C
2024-09-28 18:24:26>>>cash read=3E


===18:25:40===
定时检测未同步订单关闭
检测订单目录中>>>
无未同步订单>>>


===18:31:40===
2024-09-28 18:31:20 >>>回调事件[910,devices/S3222]
2024-09-28 18:31:20 >>>故障排除日志:上一MQTT订单号缓存列表为24092818184548764246
2024-09-28 18:31:20 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 18:31:20 开始打印,排队:120,票券:2409281831146498626301,订单:24092818311464981356,[2024-09-28 18:31:20微信支付10元]
2024-09-28 18:31:22 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281831146498626301","queue_number":120,"trade_uid":"24092818311464981356"}]}
2024-09-28 18:31:22 >>>故障排除日志:删除未同步下发订单成功24092818311464981356
2024-09-28 18:31:22 >>>故障排除日志:终端同步成功后剩余订单列表


===18:33:40===
2024-09-28 18:33:21 >>>回调事件[910,devices/S3222]
2024-09-28 18:33:21 >>>故障排除日志:上一MQTT订单号缓存列表为24092818311464981356
2024-09-28 18:33:21 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 18:33:21 开始打印,排队:121,票券:2409281833162105064101,订单:24092818331621044293,[2024-09-28 18:33:20支付宝支付10元]
2024-09-28 18:33:21 开始打印,排队:122,票券:2409281833162105259702,订单:24092818331621044293,[2024-09-28 18:33:20支付宝支付10元]
2024-09-28 18:33:25 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281833162105064101","queue_number":121,"trade_uid":"24092818331621044293"},{"ticket_no":"2409281833162105259702","queue_number":122,"trade_uid":"24092818331621044293"}]}
2024-09-28 18:33:25 >>>故障排除日志:删除未同步下发订单成功24092818331621044293
2024-09-28 18:33:25 >>>故障排除日志:删除未同步下发订单成功24092818331621044293
2024-09-28 18:33:25 >>>故障排除日志:终端同步成功后剩余订单列表


===18:37:41===
2024-09-28 18:36:52>>>cash read=00
2024-09-28 18:36:53>>>cash read=818F42
2024-09-28 18:36:53>>>cash write=02
2024-09-28 18:36:53 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-09-28 18:36:54>>>cash read=10
2024-09-28 18:36:54 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-09-28 18:36:54 当前产品价格10元，投币10元，打印小票中...
2024-09-28 18:36:54 >>>开始打印,排队号为123,订单号为2409281836540032229517
2024-09-28 18:36:54>>>订单2409281836540032229517写入成功,剩余空间为1680000,占用RAM为609.326171875
删除未同步订单2409281836540032229517
2024-09-28 18:36:56>>>订单2409281836540032229517删除成功,剩余空间为1680500,占用RAM为619.9091796875
检测订单目录中>>>
无未同步订单>>>
2024-09-28 18:36:56 >>>当前Ram内存为591.982421875
定时检测未同步订单启用
2024-09-28 18:36:57>>>cash write=0C
2024-09-28 18:36:57>>>cash read=3E


===18:38:41===
定时检测未同步订单关闭
检测订单目录中>>>
无未同步订单>>>


===18:40:41===
2024-09-28 18:39:58 >>>回调事件[910,devices/S3222]
2024-09-28 18:39:58 >>>故障排除日志:上一MQTT订单号缓存列表为24092818331621044293|24092818331621044293
2024-09-28 18:39:58 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 18:39:58 开始打印,排队:124,票券:2409281839501048322001,订单:24092818395010479423,[2024-09-28 18:39:57微信支付10元]
2024-09-28 18:40:00 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281839501048322001","queue_number":124,"trade_uid":"24092818395010479423"}]}
2024-09-28 18:40:00 >>>故障排除日志:删除未同步下发订单成功24092818395010479423
2024-09-28 18:40:00 >>>故障排除日志:终端同步成功后剩余订单列表


===18:41:41===
2024-09-28 18:41:26 >>>回调事件[910,devices/S3222]
2024-09-28 18:41:26 >>>故障排除日志:上一MQTT订单号缓存列表为24092818395010479423
2024-09-28 18:41:26 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 18:41:26 开始打印,排队:125,票券:2409281841195425060701,订单:24092818411954246567,[2024-09-28 18:41:24微信支付10元]
2024-09-28 18:41:26 开始打印,排队:126,票券:2409281841195425226402,订单:24092818411954246567,[2024-09-28 18:41:24微信支付10元]
2024-09-28 18:41:29 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281841195425060701","queue_number":125,"trade_uid":"24092818411954246567"},{"ticket_no":"2409281841195425226402","queue_number":126,"trade_uid":"24092818411954246567"}]}
2024-09-28 18:41:29 >>>故障排除日志:删除未同步下发订单成功24092818411954246567
2024-09-28 18:41:29 >>>故障排除日志:删除未同步下发订单成功24092818411954246567
2024-09-28 18:41:30 >>>故障排除日志:终端同步成功后剩余订单列表


===18:45:42===
2024-09-28 18:45:15 >>>回调事件[910,devices/S3222]
2024-09-28 18:45:15 >>>故障排除日志:上一MQTT订单号缓存列表为24092818411954246567|24092818411954246567
2024-09-28 18:45:15 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 18:45:15 开始打印,排队:127,票券:2409281845078767809401,订单:24092818450787672946,[2024-09-28 18:45:15支付宝支付10元]
2024-09-28 18:45:17 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281845078767809401","queue_number":127,"trade_uid":"24092818450787672946"}]}
2024-09-28 18:45:17 >>>故障排除日志:删除未同步下发订单成功24092818450787672946
2024-09-28 18:45:17 >>>故障排除日志:终端同步成功后剩余订单列表


===18:51:42===
2024-09-28 18:50:49 >>>回调事件[910,devices/S3222]
2024-09-28 18:50:49 >>>故障排除日志:上一MQTT订单号缓存列表为24092818450787672946
2024-09-28 18:50:49 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 18:50:49 开始打印,排队:128,票券:2409281850418234532601,订单:24092818504182340080,[2024-09-28 18:50:48支付宝支付10元]
2024-09-28 18:50:51 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281850418234532601","queue_number":128,"trade_uid":"24092818504182340080"}]}
2024-09-28 18:50:51 >>>故障排除日志:删除未同步下发订单成功24092818504182340080
2024-09-28 18:50:51 >>>故障排除日志:终端同步成功后剩余订单列表


===18:55:42===
2024-09-28 18:55:10 >>>回调事件[910,devices/S3222]
2024-09-28 18:55:10 >>>故障排除日志:上一MQTT订单号缓存列表为24092818504182340080
2024-09-28 18:55:10 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 18:55:10 开始打印,排队:129,票券:2409281855029295398301,订单:24092818550292949202,[2024-09-28 18:55:09支付宝支付10元]
2024-09-28 18:55:12 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281855029295398301","queue_number":129,"trade_uid":"24092818550292949202"}]}
2024-09-28 18:55:12 >>>故障排除日志:删除未同步下发订单成功24092818550292949202
2024-09-28 18:55:12 >>>故障排除日志:终端同步成功后剩余订单列表


===19:00:42===
2024-09-28 18:59:56 >>>回调事件[910,devices/S3222]
2024-09-28 18:59:56 >>>故障排除日志:上一MQTT订单号缓存列表为24092818550292949202
2024-09-28 18:59:56 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 18:59:56 开始打印,排队:130,票券:2409281859484676969201,订单:24092818594846765161,[2024-09-28 18:59:55微信支付10元]
2024-09-28 18:59:58 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281859484676969201","queue_number":130,"trade_uid":"24092818594846765161"}]}
2024-09-28 18:59:58 >>>故障排除日志:删除未同步下发订单成功24092818594846765161
2024-09-28 18:59:58 >>>故障排除日志:终端同步成功后剩余订单列表


===19:11:43===
2024-09-28 19:10:59 >>>回调事件[910,devices/S3222]
2024-09-28 19:10:59 >>>故障排除日志:上一MQTT订单号缓存列表为24092818594846765161
2024-09-28 19:10:59 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 19:10:59 开始打印,排队:131,票券:2409281910538075370801,订单:24092819105380748936,[2024-09-28 19:10:58微信支付10元]
2024-09-28 19:11:01 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281910538075370801","queue_number":131,"trade_uid":"24092819105380748936"}]}
2024-09-28 19:11:01 >>>故障排除日志:删除未同步下发订单成功24092819105380748936
2024-09-28 19:11:01 >>>故障排除日志:终端同步成功后剩余订单列表


===19:19:43===
2024-09-28 19:19:24 >>>回调事件[910,devices/S3222]
2024-09-28 19:19:24 >>>故障排除日志:上一MQTT订单号缓存列表为24092819105380748936
2024-09-28 19:19:24 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 19:19:24 开始打印,排队:132,票券:2409281919151630538701,订单:24092819191516298996,[2024-09-28 19:19:23支付宝支付10元]
2024-09-28 19:19:26 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281919151630538701","queue_number":132,"trade_uid":"24092819191516298996"}]}
2024-09-28 19:19:26 >>>故障排除日志:删除未同步下发订单成功24092819191516298996
2024-09-28 19:19:26 >>>故障排除日志:终端同步成功后剩余订单列表


===19:21:43===
2024-09-28 19:20:46 收到下发指令:叫号1>>>
2024-09-28 19:20:53 收到下发指令:叫号1>>>
2024-09-28 19:20:57 收到下发指令:叫号1>>>
2024-09-28 19:21:07 收到下发指令:叫号1>>>
2024-09-28 19:21:13 收到下发指令:叫号1>>>
2024-09-28 19:21:17 收到下发指令:叫号1>>>
2024-09-28 19:21:20 收到下发指令:叫号1>>>
2024-09-28 19:21:27 收到下发指令:叫号1>>>


===19:23:43===
2024-09-28 19:23:02 >>>回调事件[910,devices/S3222]
2024-09-28 19:23:02 >>>故障排除日志:上一MQTT订单号缓存列表为24092819191516298996
2024-09-28 19:23:02 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 19:23:02 开始打印,排队:133,票券:2409281922534170140901,订单:24092819225341698354,[2024-09-28 19:23:01微信支付10元]
2024-09-28 19:23:04 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281922534170140901","queue_number":133,"trade_uid":"24092819225341698354"}]}
2024-09-28 19:23:04 >>>故障排除日志:删除未同步下发订单成功24092819225341698354
2024-09-28 19:23:04 >>>故障排除日志:终端同步成功后剩余订单列表


===19:25:44===
2024-09-28 19:24:46>>>cash read=00
2024-09-28 19:24:47>>>cash read=818F42
2024-09-28 19:24:47>>>cash write=02
2024-09-28 19:24:47 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-09-28 19:24:47>>>cash read=10
2024-09-28 19:24:47 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-09-28 19:24:47 当前产品价格10元，投币10元，打印小票中...
2024-09-28 19:24:47 >>>开始打印,排队号为134,订单号为2409281924470032221055
2024-09-28 19:24:48>>>订单2409281924470032221055写入成功,剩余空间为1680000,占用RAM为608.251953125
删除未同步订单2409281924470032221055
2024-09-28 19:24:50>>>订单2409281924470032221055删除成功,剩余空间为1680500,占用RAM为618.8466796875
检测订单目录中>>>
无未同步订单>>>
2024-09-28 19:24:50 >>>当前Ram内存为590.8837890625
定时检测未同步订单启用
2024-09-28 19:24:51>>>cash write=0C
2024-09-28 19:24:51>>>cash read=3E


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


===19:27:44===
定时检测未同步订单关闭
检测订单目录中>>>
无未同步订单>>>


===19:31:44===
2024-09-28 19:30:53 >>>回调事件[910,devices/S3222]
2024-09-28 19:30:53 >>>故障排除日志:上一MQTT订单号缓存列表为24092819225341698354
2024-09-28 19:30:53 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 19:30:53 开始打印,排队:136,票券:2409281930418466415601,订单:24092819304184660446,[2024-09-28 19:30:52微信支付10元]
2024-09-28 19:30:55 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281930418466415601","queue_number":136,"trade_uid":"24092819304184660446"}]}
2024-09-28 19:30:55 >>>故障排除日志:删除未同步下发订单成功24092819304184660446
2024-09-28 19:30:55 >>>故障排除日志:终端同步成功后剩余订单列表


===19:44:45===
2024-09-28 19:43:48 >>>回调事件[910,devices/S3222]
2024-09-28 19:43:48 >>>故障排除日志:上一MQTT订单号缓存列表为24092819304184660446
2024-09-28 19:43:48 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 19:43:48 开始打印,排队:137,票券:2409281943371998248501,订单:24092819433719979182,[2024-09-28 19:43:47微信支付10元]
2024-09-28 19:43:49 开始打印,排队:138,票券:2409281943371998387902,订单:24092819433719979182,[2024-09-28 19:43:47微信支付10元]
2024-09-28 19:43:52 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281943371998248501","queue_number":137,"trade_uid":"24092819433719979182"},{"ticket_no":"2409281943371998387902","queue_number":138,"trade_uid":"24092819433719979182"}]}
2024-09-28 19:43:52 >>>故障排除日志:删除未同步下发订单成功24092819433719979182
2024-09-28 19:43:52 >>>故障排除日志:删除未同步下发订单成功24092819433719979182
2024-09-28 19:43:52 >>>故障排除日志:终端同步成功后剩余订单列表


===19:46:45===
2024-09-28 19:46:02 >>>回调事件[910,devices/S3222]
2024-09-28 19:46:02 >>>故障排除日志:上一MQTT订单号缓存列表为24092819433719979182|24092819433719979182
2024-09-28 19:46:02 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 19:46:02 开始打印,排队:139,票券:2409281945545420310301,订单:24092819455454197962,[2024-09-28 19:46:01微信支付10元]
2024-09-28 19:46:04 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281945545420310301","queue_number":139,"trade_uid":"24092819455454197962"}]}
2024-09-28 19:46:04 >>>故障排除日志:删除未同步下发订单成功24092819455454197962
2024-09-28 19:46:04 >>>故障排除日志:终端同步成功后剩余订单列表


===19:55:45===
2024-09-28 19:54:57 >>>回调事件[910,devices/S3222]
2024-09-28 19:54:57 >>>故障排除日志:上一MQTT订单号缓存列表为24092819455454197962
2024-09-28 19:54:57 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 19:54:57 开始打印,排队:140,票券:2409281954509994104501,订单:24092819545099936616,[2024-09-28 19:54:56微信支付10元]
2024-09-28 19:54:59 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281954509994104501","queue_number":140,"trade_uid":"24092819545099936616"}]}
2024-09-28 19:54:59 >>>故障排除日志:删除未同步下发订单成功24092819545099936616
2024-09-28 19:54:59 >>>故障排除日志:终端同步成功后剩余订单列表


===20:03:45===
2024-09-28 20:02:55 >>>回调事件[910,devices/S3222]
2024-09-28 20:02:55 >>>故障排除日志:上一MQTT订单号缓存列表为24092819545099936616
2024-09-28 20:02:55 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 20:02:55 开始打印,排队:141,票券:2409282002465288338201,订单:24092820024652879753,[2024-09-28 20:02:54微信支付10元]
2024-09-28 20:02:57 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409282002465288338201","queue_number":141,"trade_uid":"24092820024652879753"}]}
2024-09-28 20:02:57 >>>故障排除日志:删除未同步下发订单成功24092820024652879753
2024-09-28 20:02:57 >>>故障排除日志:终端同步成功后剩余订单列表


===20:16:45===
2024-09-28 20:16:17 >>>回调事件[910,devices/S3222]
2024-09-28 20:16:17 >>>故障排除日志:上一MQTT订单号缓存列表为24092820024652879753
2024-09-28 20:16:17 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 20:16:18 开始打印,排队:142,票券:2409282016107108772401,订单:24092820161071083686,[2024-09-28 20:16:17微信支付10元]
2024-09-28 20:16:18 开始打印,排队:143,票券:2409282016107108942002,订单:24092820161071083686,[2024-09-28 20:16:17微信支付10元]
2024-09-28 20:16:21 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409282016107108772401","queue_number":142,"trade_uid":"24092820161071083686"},{"ticket_no":"2409282016107108942002","queue_number":143,"trade_uid":"24092820161071083686"}]}
2024-09-28 20:16:21 >>>故障排除日志:删除未同步下发订单成功24092820161071083686
2024-09-28 20:16:21 >>>故障排除日志:删除未同步下发订单成功24092820161071083686
2024-09-28 20:16:21 >>>故障排除日志:终端同步成功后剩余订单列表


===20:33:46===
2024-09-28 20:33:08>>>cash read=0A
2024-09-28 20:33:09>>>cash read=3E