TLClient_JSSCOM_LuatOS-Air_V4010_RDA8910_RFTTS_0xe0000,2.5.4,864708068714883,21420139256572,
poweron reason:0

===07:33:16===
2024-10-01 07:33:13 >>>剩余flash空间=1682000,占用RAM为622.1220703125
2024-10-01 07:33:13 >>>回调异常:911,initSys,30000,nil



===07:34:16===
上一时间戳为1727654621
隔日重置时间戳true
隔日清空未同步下发列表true
当前排队号为1,音量为5
初始化产品信息:[{"time_limit_date":"","ticket_category":"0","expiry_date":90,"product_detail":"","time_limit_status":"0","begin_minute":"00","product_uid":"98628273992537450","use_timer":1,"old_price":"20","end_hour":"23","sale_price":"10","end_minute":"59","begin_hour":"00","sale_status":1,"product_name":"快剪"}]
打印门店标题设置为欢迎光临
是否打印二维码设置为1
是否打印紧凑设置为3
session_id:8fb8c****94462
纸币器设置接收纸币范围为36
欢迎使用天羚自助售票系统[2.5.4]
定时检测未同步订单启用
2024-10-01 07:33:22>>>cash write=30
2024-10-01 07:33:22>>>cash write=02
2024-10-01 07:33:22>>>cash write=3E
2024-10-01 07:33:22>>>cash read=808F808F808F808F808F808F808F808F
系统时间初始化成功，时间为202410173322
2024-10-01 07:33:23>>>cash write=02
2024-10-01 07:33:23 >>>剩余flash空间=1680500,占用RAM为626.646484375
2024-10-01 07:33:23 >>>回调事件:910,subscribe,10000,连接服务器成功

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

2024-10-01 07:33:26>>>cash write=0C
2024-10-01 07:33:26>>>cash read=3E
流量卡还有149天过期
2024-10-01 07:33:30 >>>回调事件[910,devices/S3136]
当日首次设置时间戳true为1727739210
2024-10-01 07:33:30 >>>故障排除日志:上一MQTT订单号缓存列表为24093020575267189353
2024-10-01 07:33:30 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 07:33:30 开始打印,排队:1,票券:2410010733223669899601,订单:24100107332236694016,[2024-10-01 07:33:30微信支付10元]
2024-10-01 07:33:32 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410010733223669899601","queue_number":1,"trade_uid":"24100107332236694016"}]}
2024-10-01 07:33:33 >>>故障排除日志:删除未同步下发订单成功24100107332236694016
2024-10-01 07:33:33 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-01 07:33:34 >>>当前Ram内存为622.2626953125


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


===07:45:16===
2024-10-01 07:45:01>>>cash read=0A
2024-10-01 07:45:02>>>cash read=3E


===07:55:17===
2024-10-01 07:54:50 >>>回调事件[910,devices/S3136]
2024-10-01 07:54:50 >>>故障排除日志:上一MQTT订单号缓存列表为24100107332236694016
2024-10-01 07:54:50 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 07:54:50 开始打印,排队:2,票券:2410010754419012746401,订单:24100107544190122423,[2024-10-01 07:54:48微信支付10元]
2024-10-01 07:54:52 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410010754419012746401","queue_number":2,"trade_uid":"24100107544190122423"}]}
2024-10-01 07:54:52 >>>故障排除日志:删除未同步下发订单成功24100107544190122423
2024-10-01 07:54:52 >>>故障排除日志:终端同步成功后剩余订单列表


===08:23:17===
2024-10-01 08:22:33 >>>回调事件[910,devices/S3136]
2024-10-01 08:22:33 >>>故障排除日志:上一MQTT订单号缓存列表为24100107544190122423
2024-10-01 08:22:33 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 08:22:33 开始打印,排队:3,票券:2410010822165438951501,订单:24100108221654384539,[2024-10-01 08:22:32微信支付10元]
2024-10-01 08:22:33 开始打印,排队:4,票券:2410010822165439107402,订单:24100108221654384539,[2024-10-01 08:22:32微信支付10元]
2024-10-01 08:22:37 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410010822165438951501","queue_number":3,"trade_uid":"24100108221654384539"},{"ticket_no":"2410010822165439107402","queue_number":4,"trade_uid":"24100108221654384539"}]}
2024-10-01 08:22:37 >>>故障排除日志:删除未同步下发订单成功24100108221654384539
2024-10-01 08:22:37 >>>故障排除日志:删除未同步下发订单成功24100108221654384539
2024-10-01 08:22:37 >>>故障排除日志:终端同步成功后剩余订单列表


===08:27:17===
2024-10-01 08:26:53 >>>回调事件[910,devices/S3136]
2024-10-01 08:26:53 >>>故障排除日志:上一MQTT订单号缓存列表为24100108221654384539|24100108221654384539
2024-10-01 08:26:53 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 08:26:53 开始打印,排队:5,票券:2410010826445726279601,订单:24100108264457257893,[2024-10-01 08:26:52微信支付10元]
2024-10-01 08:26:55 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410010826445726279601","queue_number":5,"trade_uid":"24100108264457257893"}]}
2024-10-01 08:26:55 >>>故障排除日志:删除未同步下发订单成功24100108264457257893
2024-10-01 08:26:55 >>>故障排除日志:终端同步成功后剩余订单列表


===08:39:17===
2024-10-01 08:38:30 >>>回调事件[910,devices/S3136]
2024-10-01 08:38:30 >>>故障排除日志:上一MQTT订单号缓存列表为24100108264457257893
2024-10-01 08:38:30 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 08:38:30 开始打印,排队:6,票券:2410010838210195371901,订单:24100108382101949317,[2024-10-01 08:38:29微信支付10元]
2024-10-01 08:38:32 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410010838210195371901","queue_number":6,"trade_uid":"24100108382101949317"}]}
2024-10-01 08:38:32 >>>故障排除日志:删除未同步下发订单成功24100108382101949317
2024-10-01 08:38:32 >>>故障排除日志:终端同步成功后剩余订单列表


===08:41:18===
2024-10-01 08:41:11 >>>回调事件[910,devices/S3136]
2024-10-01 08:41:11 >>>故障排除日志:上一MQTT订单号缓存列表为24100108382101949317
2024-10-01 08:41:11 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 08:41:11 开始打印,排队:7,票券:2410010841037227535201,订单:24100108410372270279,[2024-10-01 08:41:10微信支付10元]
2024-10-01 08:41:13 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410010841037227535201","queue_number":7,"trade_uid":"24100108410372270279"}]}
2024-10-01 08:41:13 >>>故障排除日志:删除未同步下发订单成功24100108410372270279
2024-10-01 08:41:13 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


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


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


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


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


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


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


===09:24:20===
2024-10-01 09:23:58 >>>回调事件[910,devices/S3136]
2024-10-01 09:23:58 >>>故障排除日志:上一MQTT订单号缓存列表为24100109184188162635
2024-10-01 09:23:58 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 09:23:58 开始打印,排队:17,票券:2410010923513585422101,订单:24100109235135849125,[2024-10-01 09:23:58微信支付10元]
2024-10-01 09:23:58 开始打印,排队:18,票券:2410010923513585608302,订单:24100109235135849125,[2024-10-01 09:23:58微信支付10元]
2024-10-01 09:24:02 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410010923513585422101","queue_number":17,"trade_uid":"24100109235135849125"},{"ticket_no":"2410010923513585608302","queue_number":18,"trade_uid":"24100109235135849125"}]}
2024-10-01 09:24:02 >>>故障排除日志:删除未同步下发订单成功24100109235135849125
2024-10-01 09:24:02 >>>故障排除日志:删除未同步下发订单成功24100109235135849125
2024-10-01 09:24:02 >>>故障排除日志:终端同步成功后剩余订单列表


===09:27:20===
2024-10-01 09:26:27 >>>回调事件[910,devices/S3136]
2024-10-01 09:26:27 >>>故障排除日志:上一MQTT订单号缓存列表为24100109235135849125|24100109235135849125
2024-10-01 09:26:27 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 09:26:27 开始打印,排队:19,票券:2410010926213496867801,订单:24100109262134963182,[2024-10-01 09:26:27支付宝支付10元]
2024-10-01 09:26:29 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410010926213496867801","queue_number":19,"trade_uid":"24100109262134963182"}]}
2024-10-01 09:26:29 >>>故障排除日志:删除未同步下发订单成功24100109262134963182
2024-10-01 09:26:29 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-01 09:26:37>>>cash read=00
2024-10-01 09:26:38>>>cash read=818F42
2024-10-01 09:26:38>>>cash write=02
2024-10-01 09:26:38 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-01 09:26:38>>>cash read=10
2024-10-01 09:26:38 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-01 09:26:38 当前产品价格10元，投币10元，打印小票中...
2024-10-01 09:26:38 >>>开始打印,排队号为20,订单号为2410010926380031369578
2024-10-01 09:26:39>>>订单2410010926380031369578写入成功,剩余空间为1679000,占用RAM为611.0908203125
删除未同步订单2410010926380031369578
2024-10-01 09:26:41>>>订单2410010926380031369578删除成功,剩余空间为1680000,占用RAM为621.34375
检测订单目录中>>>
无未同步订单>>>
2024-10-01 09:26:41 >>>当前Ram内存为592.1357421875
定时检测未同步订单启用
2024-10-01 09:26:42>>>cash write=0C
2024-10-01 09:26:42>>>cash read=3E


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


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


===09:30:21===
2024-10-01 09:29:20 >>>回调事件[910,devices/S3136]
2024-10-01 09:29:20 >>>故障排除日志:上一MQTT订单号缓存列表为24100109262134963182
2024-10-01 09:29:20 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 09:29:20 开始打印,排队:22,票券:2410010929121186481201,订单:24100109291211860638,[2024-10-01 09:29:20支付宝支付10元]
2024-10-01 09:29:23 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410010929121186481201","queue_number":22,"trade_uid":"24100109291211860638"}]}
2024-10-01 09:29:23 >>>故障排除日志:删除未同步下发订单成功24100109291211860638
2024-10-01 09:29:23 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单关闭
检测订单目录中>>>
无未同步订单>>>


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


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


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


===09:50:22===
2024-10-01 09:49:28>>>cash read=00
2024-10-01 09:49:29>>>cash read=818F41
2024-10-01 09:49:29>>>cash write=02
2024-10-01 09:49:29 >>>回调事件130,cash_status,10022,进钞中...read money=5
2024-10-01 09:49:30>>>cash write=0C
2024-10-01 09:49:30>>>cash read=00
2024-10-01 09:49:30>>>cash read=10
2024-10-01 09:49:30 >>>回调事件130,5,10023,finish Money=5,进钞完成
2024-10-01 09:49:32>>>cash read=3E
2024-10-01 09:49:34>>>cash read=00
2024-10-01 09:49:34>>>cash read=818F41
2024-10-01 09:49:34>>>cash write=02
2024-10-01 09:49:34 >>>回调事件130,cash_status,10022,进钞中...read money=5
2024-10-01 09:49:35>>>cash read=10
2024-10-01 09:49:35 >>>回调事件130,5,10023,finish Money=5,进钞完成
2024-10-01 09:49:35 当前产品价格10元，投币10元，打印小票中...
2024-10-01 09:49:35 >>>开始打印,排队号为25,订单号为2410010949300031367631
2024-10-01 09:49:35>>>订单2410010949300031367631写入成功,剩余空间为1679500,占用RAM为606.6083984375
删除未同步订单2410010949300031367631
2024-10-01 09:49:37>>>订单2410010949300031367631删除成功,剩余空间为1680000,占用RAM为619.6103515625
检测订单目录中>>>
无未同步订单>>>
2024-10-01 09:49:37 >>>当前Ram内存为589.8603515625
定时检测未同步订单启用
2024-10-01 09:49:38>>>cash write=0C
2024-10-01 09:49:38>>>cash read=3E


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


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


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


===10:10:23===
2024-10-01 10:09:39 >>>回调事件[910,devices/S3136]
2024-10-01 10:09:39 >>>故障排除日志:上一MQTT订单号缓存列表为24100109553227673985
2024-10-01 10:09:39 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 10:09:39 开始打印,排队:28,票券:2410011009324398461601,订单:24100110093243980096,[2024-10-01 10:09:38微信支付10元]
2024-10-01 10:09:41 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011009324398461601","queue_number":28,"trade_uid":"24100110093243980096"}]}
2024-10-01 10:09:41 >>>故障排除日志:删除未同步下发订单成功24100110093243980096
2024-10-01 10:09:41 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-01 10:10:06 >>>回调事件[910,devices/S3136]
2024-10-01 10:10:06 >>>故障排除日志:上一MQTT订单号缓存列表为24100110093243980096
2024-10-01 10:10:06 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 10:10:06 开始打印,排队:29,票券:2410011010004288897801,订单:24100110100042883176,[2024-10-01 10:10:06微信支付10元]
2024-10-01 10:10:09 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011010004288897801","queue_number":29,"trade_uid":"24100110100042883176"}]}
2024-10-01 10:10:09 >>>故障排除日志:删除未同步下发订单成功24100110100042883176
2024-10-01 10:10:09 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


===10:27:24===
2024-10-01 10:26:53>>>cash read=0A
2024-10-01 10:26:54>>>cash read=3E
2024-10-01 10:26:55 >>>回调事件[910,devices/S3136]
2024-10-01 10:26:55 >>>故障排除日志:上一MQTT订单号缓存列表为24100110252074384915
2024-10-01 10:26:55 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 10:26:55 开始打印,排队:33,票券:2410011026436754209401,订单:24100110264367537551,[2024-10-01 10:26:54微信支付10元]
2024-10-01 10:26:55 开始打印,排队:34,票券:2410011026436754343802,订单:24100110264367537551,[2024-10-01 10:26:54微信支付10元]
2024-10-01 10:26:58 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011026436754209401","queue_number":33,"trade_uid":"24100110264367537551"},{"ticket_no":"2410011026436754343802","queue_number":34,"trade_uid":"24100110264367537551"}]}
2024-10-01 10:26:58 >>>故障排除日志:删除未同步下发订单成功24100110264367537551
2024-10-01 10:26:58 >>>故障排除日志:删除未同步下发订单成功24100110264367537551
2024-10-01 10:26:58 >>>故障排除日志:终端同步成功后剩余订单列表


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


===10:40:24===
2024-10-01 10:39:35 >>>回调事件[910,devices/S3136]
2024-10-01 10:39:35 >>>故障排除日志:上一MQTT订单号缓存列表为24100110383009327338
2024-10-01 10:39:35 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 10:39:35 开始打印,排队:36,票券:2410011039290806386501,订单:24100110392908058618,[2024-10-01 10:39:34支付宝支付10元]
2024-10-01 10:39:35 开始打印,排队:37,票券:2410011039290806594202,订单:24100110392908058618,[2024-10-01 10:39:34支付宝支付10元]
2024-10-01 10:39:39 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011039290806386501","queue_number":36,"trade_uid":"24100110392908058618"},{"ticket_no":"2410011039290806594202","queue_number":37,"trade_uid":"24100110392908058618"}]}
2024-10-01 10:39:39 >>>故障排除日志:删除未同步下发订单成功24100110392908058618
2024-10-01 10:39:39 >>>故障排除日志:删除未同步下发订单成功24100110392908058618
2024-10-01 10:39:39 >>>故障排除日志:终端同步成功后剩余订单列表


===10:45:24===
2024-10-01 10:45:20 >>>回调事件[910,devices/S3136]
2024-10-01 10:45:20 >>>故障排除日志:上一MQTT订单号缓存列表为24100110392908058618|24100110392908058618
2024-10-01 10:45:20 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 10:45:20 开始打印,排队:38,票券:2410011045151230867201,订单:24100110451512303781,[2024-10-01 10:45:20支付宝支付10元]
2024-10-01 10:45:22 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011045151230867201","queue_number":38,"trade_uid":"24100110451512303781"}]}
2024-10-01 10:45:22 >>>故障排除日志:删除未同步下发订单成功24100110451512303781
2024-10-01 10:45:22 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


===11:02:25===
2024-10-01 11:01:48 >>>回调事件[910,devices/S3136]
2024-10-01 11:01:48 >>>故障排除日志:上一MQTT订单号缓存列表为24100110584449796734
2024-10-01 11:01:48 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 11:01:48 开始打印,排队:42,票券:2410011101374101835201,订单:24100111013741012852,[2024-10-01 11:01:47微信支付10元]
2024-10-01 11:01:48 开始打印,排队:43,票券:2410011101374102043202,订单:24100111013741012852,[2024-10-01 11:01:47微信支付10元]
2024-10-01 11:01:51 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011101374101835201","queue_number":42,"trade_uid":"24100111013741012852"},{"ticket_no":"2410011101374102043202","queue_number":43,"trade_uid":"24100111013741012852"}]}
2024-10-01 11:01:51 >>>故障排除日志:删除未同步下发订单成功24100111013741012852
2024-10-01 11:01:51 >>>故障排除日志:删除未同步下发订单成功24100111013741012852
2024-10-01 11:01:51 >>>故障排除日志:终端同步成功后剩余订单列表


===11:13:25===
2024-10-01 11:12:39 >>>回调事件[910,devices/S3136]
2024-10-01 11:12:39 >>>故障排除日志:上一MQTT订单号缓存列表为24100111013741012852|24100111013741012852
2024-10-01 11:12:39 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 11:12:39 开始打印,排队:44,票券:2410011112304068498601,订单:24100111123040679826,[2024-10-01 11:12:38微信支付10元]
2024-10-01 11:12:41 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011112304068498601","queue_number":44,"trade_uid":"24100111123040679826"}]}
2024-10-01 11:12:41 >>>故障排除日志:删除未同步下发订单成功24100111123040679826
2024-10-01 11:12:41 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-01 11:13:21 >>>回调事件[910,devices/S3136]
2024-10-01 11:13:21 >>>故障排除日志:上一MQTT订单号缓存列表为24100111123040679826
2024-10-01 11:13:21 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 11:13:21 开始打印,排队:45,票券:2410011113138099442501,订单:24100111131380989482,[2024-10-01 11:13:20微信支付10元]
2024-10-01 11:13:23 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011113138099442501","queue_number":45,"trade_uid":"24100111131380989482"}]}
2024-10-01 11:13:23 >>>故障排除日志:删除未同步下发订单成功24100111131380989482
2024-10-01 11:13:23 >>>故障排除日志:终端同步成功后剩余订单列表


===11:17:25===
2024-10-01 11:16:51 >>>回调事件[910,devices/S3136]
2024-10-01 11:16:51 >>>故障排除日志:上一MQTT订单号缓存列表为24100111131380989482
2024-10-01 11:16:51 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 11:16:51 开始打印,排队:46,票券:2410011116418684987201,订单:24100111164186846153,[2024-10-01 11:16:50微信支付10元]
2024-10-01 11:16:51 开始打印,排队:47,票券:2410011116418685115302,订单:24100111164186846153,[2024-10-01 11:16:50微信支付10元]
2024-10-01 11:16:54 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011116418684987201","queue_number":46,"trade_uid":"24100111164186846153"},{"ticket_no":"2410011116418685115302","queue_number":47,"trade_uid":"24100111164186846153"}]}
2024-10-01 11:16:54 >>>故障排除日志:删除未同步下发订单成功24100111164186846153
2024-10-01 11:16:54 >>>故障排除日志:删除未同步下发订单成功24100111164186846153
2024-10-01 11:16:54 >>>故障排除日志:终端同步成功后剩余订单列表


===11:20:26===
2024-10-01 11:19:34 >>>回调事件[910,devices/S3136]
2024-10-01 11:19:34 >>>故障排除日志:上一MQTT订单号缓存列表为24100111164186846153|24100111164186846153
2024-10-01 11:19:34 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 11:19:34 开始打印,排队:48,票券:2410011119267451038701,订单:24100111192674505538,[2024-10-01 11:19:34支付宝支付10元]
2024-10-01 11:19:36 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011119267451038701","queue_number":48,"trade_uid":"24100111192674505538"}]}
2024-10-01 11:19:36 >>>故障排除日志:删除未同步下发订单成功24100111192674505538
2024-10-01 11:19:36 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


===12:24:27===
2024-10-01 12:23:29 >>>回调事件[910,devices/S3136]
2024-10-01 12:23:29 >>>故障排除日志:上一MQTT订单号缓存列表为24100111442434499721
2024-10-01 12:23:29 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 12:23:29 开始打印,排队:52,票券:2410011223223950036301,订单:24100112232239493365,[2024-10-01 12:23:29微信支付10元]
2024-10-01 12:23:31 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011223223950036301","queue_number":52,"trade_uid":"24100112232239493365"}]}
2024-10-01 12:23:31 >>>故障排除日志:删除未同步下发订单成功24100112232239493365
2024-10-01 12:23:31 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


===12:46:27===
2024-10-01 12:45:32 >>>回调事件[910,devices/S3136]
2024-10-01 12:45:32 >>>故障排除日志:上一MQTT订单号缓存列表为24100112440103190925
2024-10-01 12:45:32 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 12:45:32 开始打印,排队:55,票券:2410011245258669715401,订单:24100112452586689524,[2024-10-01 12:45:31微信支付10元]
2024-10-01 12:45:34 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011245258669715401","queue_number":55,"trade_uid":"24100112452586689524"}]}
2024-10-01 12:45:34 >>>故障排除日志:删除未同步下发订单成功24100112452586689524
2024-10-01 12:45:34 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


===13:19:28===
2024-10-01 13:18:31 >>>回调事件[910,devices/S3136]
2024-10-01 13:18:31 >>>故障排除日志:上一MQTT订单号缓存列表为24100113092123602339
2024-10-01 13:18:31 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 13:18:31 开始打印,排队:59,票券:2410011318031030451601,订单:24100113180310300567,[2024-10-01 13:18:31微信支付10元]
2024-10-01 13:18:32 开始打印,排队:60,票券:2410011318031030604502,订单:24100113180310300567,[2024-10-01 13:18:31微信支付10元]
2024-10-01 13:18:35 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011318031030451601","queue_number":59,"trade_uid":"24100113180310300567"},{"ticket_no":"2410011318031030604502","queue_number":60,"trade_uid":"24100113180310300567"}]}
2024-10-01 13:18:35 >>>故障排除日志:删除未同步下发订单成功24100113180310300567
2024-10-01 13:18:35 >>>故障排除日志:删除未同步下发订单成功24100113180310300567
2024-10-01 13:18:35 >>>故障排除日志:终端同步成功后剩余订单列表


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


===13:38:29===
2024-10-01 13:38:02 >>>回调事件[910,devices/S3136]
2024-10-01 13:38:02 >>>故障排除日志:上一MQTT订单号缓存列表为24100113180310300567|24100113180310300567
2024-10-01 13:38:02 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 13:38:02 开始打印,排队:62,票券:2410011337540263292701,订单:24100113375402629385,[2024-10-01 13:38:01微信支付10元]
2024-10-01 13:38:04 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011337540263292701","queue_number":62,"trade_uid":"24100113375402629385"}]}
2024-10-01 13:38:04 >>>故障排除日志:删除未同步下发订单成功24100113375402629385
2024-10-01 13:38:04 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单关闭
检测订单目录中>>>
无未同步订单>>>


===13:46:29===
2024-10-01 13:45:48 >>>回调事件[910,devices/S3136]
2024-10-01 13:45:48 >>>故障排除日志:上一MQTT订单号缓存列表为24100113375402629385
2024-10-01 13:45:48 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 13:45:48 开始打印,排队:63,票券:2410011345424295098401,订单:24100113454242947186,[2024-10-01 13:45:47微信支付10元]
2024-10-01 13:45:50 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011345424295098401","queue_number":63,"trade_uid":"24100113454242947186"}]}
2024-10-01 13:45:50 >>>故障排除日志:删除未同步下发订单成功24100113454242947186
2024-10-01 13:45:50 >>>故障排除日志:终端同步成功后剩余订单列表


===13:50:29===
2024-10-01 13:49:36 >>>回调事件[910,devices/S3136]
2024-10-01 13:49:36 >>>故障排除日志:上一MQTT订单号缓存列表为24100113454242947186
2024-10-01 13:49:36 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 13:49:36 开始打印,排队:64,票券:2410011349301087567401,订单:24100113493010871356,[2024-10-01 13:49:36微信支付10元]
2024-10-01 13:49:38 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011349301087567401","queue_number":64,"trade_uid":"24100113493010871356"}]}
2024-10-01 13:49:38 >>>故障排除日志:删除未同步下发订单成功24100113493010871356
2024-10-01 13:49:38 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


===14:47:30===
2024-10-01 14:46:44 >>>回调事件[910,devices/S3136]
2024-10-01 14:46:44 >>>故障排除日志:上一MQTT订单号缓存列表为24100114452119658652
2024-10-01 14:46:44 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 14:46:44 开始打印,排队:67,票券:2410011446391992874701,订单:24100114463919923952,[2024-10-01 14:46:43微信支付10元]
2024-10-01 14:46:46 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011446391992874701","queue_number":67,"trade_uid":"24100114463919923952"}]}
2024-10-01 14:46:46 >>>故障排除日志:删除未同步下发订单成功24100114463919923952
2024-10-01 14:46:46 >>>故障排除日志:终端同步成功后剩余订单列表


===14:51:31===
2024-10-01 14:50:50 >>>回调事件[910,devices/S3136]
2024-10-01 14:50:50 >>>故障排除日志:上一MQTT订单号缓存列表为24100114463919923952
2024-10-01 14:50:50 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 14:50:50 开始打印,排队:68,票券:2410011450428373809201,订单:24100114504283734252,[2024-10-01 14:50:49微信支付10元]
2024-10-01 14:50:50 开始打印,排队:69,票券:2410011450428373937202,订单:24100114504283734252,[2024-10-01 14:50:49微信支付10元]
2024-10-01 14:50:53 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011450428373809201","queue_number":68,"trade_uid":"24100114504283734252"},{"ticket_no":"2410011450428373937202","queue_number":69,"trade_uid":"24100114504283734252"}]}
2024-10-01 14:50:53 >>>故障排除日志:删除未同步下发订单成功24100114504283734252
2024-10-01 14:50:53 >>>故障排除日志:删除未同步下发订单成功24100114504283734252
2024-10-01 14:50:53 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


===15:16:32===
2024-10-01 15:16:17>>>cash read=00
2024-10-01 15:16:18>>>cash read=2F29
2024-10-01 15:16:20>>>cash read=3E
2024-10-01 15:16:27>>>cash read=00
2024-10-01 15:16:28>>>cash read=818F42
2024-10-01 15:16:28>>>cash write=02
2024-10-01 15:16:28 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-01 15:16:28>>>cash read=10
2024-10-01 15:16:28 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-01 15:16:28 当前产品价格10元，投币10元，打印小票中...
2024-10-01 15:16:28 >>>开始打印,排队号为73,订单号为2410011516280031367814
2024-10-01 15:16:29>>>订单2410011516280031367814写入成功,剩余空间为1679500,占用RAM为606.7568359375


===15:17:32===
删除未同步订单2410011516280031367814
2024-10-01 15:16:31>>>订单2410011516280031367814删除成功,剩余空间为1681500,占用RAM为620.212890625
检测订单目录中>>>
无未同步订单>>>
2024-10-01 15:16:31 >>>当前Ram内存为588.23828125
定时检测未同步订单启用
2024-10-01 15:16:32>>>cash write=0C
2024-10-01 15:16:32>>>cash read=3E


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


===15:20:32===
2024-10-01 15:20:17 >>>回调事件[910,devices/S3136]
2024-10-01 15:20:17 >>>故障排除日志:上一MQTT订单号缓存列表为24100115173671853458
2024-10-01 15:20:17 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 15:20:17 开始打印,排队:75,票券:2410011520091398051201,订单:24100115200913975852,[2024-10-01 15:20:16微信支付10元]
2024-10-01 15:20:19 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011520091398051201","queue_number":75,"trade_uid":"24100115200913975852"}]}
2024-10-01 15:20:19 >>>故障排除日志:删除未同步下发订单成功24100115200913975852
2024-10-01 15:20:19 >>>故障排除日志:终端同步成功后剩余订单列表


===15:24:32===
2024-10-01 15:23:34>>>cash read=0A
2024-10-01 15:23:35>>>cash read=3E
2024-10-01 15:23:57 >>>回调事件[910,devices/S3136]
2024-10-01 15:23:57 >>>故障排除日志:上一MQTT订单号缓存列表为24100115200913975852
2024-10-01 15:23:57 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 15:23:58 开始打印,排队:76,票券:2410011523480095258701,订单:24100115234800949187,[2024-10-01 15:23:57微信支付10元]
2024-10-01 15:23:59 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011523480095258701","queue_number":76,"trade_uid":"24100115234800949187"}]}
2024-10-01 15:23:59 >>>故障排除日志:删除未同步下发订单成功24100115234800949187
2024-10-01 15:24:00 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-01 15:24:01 >>>回调事件[910,devices/S3136]
2024-10-01 15:24:01 >>>故障排除日志:上一MQTT订单号缓存列表为24100115234800949187
2024-10-01 15:24:01 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 15:24:01 开始打印,排队:77,票券:2410011523553022033901,订单:24100115235530216353,[2024-10-01 15:24:01微信支付10元]
2024-10-01 15:24:03 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011523553022033901","queue_number":77,"trade_uid":"24100115235530216353"}]}
2024-10-01 15:24:03 >>>故障排除日志:删除未同步下发订单成功24100115235530216353
2024-10-01 15:24:03 >>>故障排除日志:终端同步成功后剩余订单列表


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


===15:29:33===
2024-10-01 15:28:51 >>>回调事件[910,devices/S3136]
2024-10-01 15:28:51 >>>故障排除日志:上一MQTT订单号缓存列表为24100115272179253345
2024-10-01 15:28:51 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 15:28:51 开始打印,排队:79,票券:2410011528436709587801,订单:24100115284367092245,[2024-10-01 15:28:49支付宝支付10元]
2024-10-01 15:28:51 开始打印,排队:80,票券:2410011528436709722302,订单:24100115284367092245,[2024-10-01 15:28:49支付宝支付10元]
2024-10-01 15:28:54 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011528436709587801","queue_number":79,"trade_uid":"24100115284367092245"},{"ticket_no":"2410011528436709722302","queue_number":80,"trade_uid":"24100115284367092245"}]}
2024-10-01 15:28:54 >>>故障排除日志:删除未同步下发订单成功24100115284367092245
2024-10-01 15:28:54 >>>故障排除日志:删除未同步下发订单成功24100115284367092245
2024-10-01 15:28:54 >>>故障排除日志:终端同步成功后剩余订单列表


===15:39:33===
2024-10-01 15:39:23 >>>回调事件[910,devices/S3136]
2024-10-01 15:39:23 >>>故障排除日志:上一MQTT订单号缓存列表为24100115284367092245|24100115284367092245
2024-10-01 15:39:23 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 15:39:23 开始打印,排队:81,票券:2410011539158917615101,订单:24100115391589170889,[2024-10-01 15:39:22微信支付10元]
2024-10-01 15:39:25 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011539158917615101","queue_number":81,"trade_uid":"24100115391589170889"}]}
2024-10-01 15:39:25 >>>故障排除日志:删除未同步下发订单成功24100115391589170889
2024-10-01 15:39:25 >>>故障排除日志:终端同步成功后剩余订单列表


===15:41:33===
2024-10-01 15:40:34>>>cash read=00
2024-10-01 15:40:35>>>cash read=818F42
2024-10-01 15:40:35>>>cash write=02
2024-10-01 15:40:35 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-01 15:40:35>>>cash read=10
2024-10-01 15:40:35 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-01 15:40:35 当前产品价格10元，投币10元，打印小票中...
2024-10-01 15:40:35 >>>开始打印,排队号为82,订单号为2410011540350031366467
2024-10-01 15:40:36>>>订单2410011540350031366467写入成功,剩余空间为1680000,占用RAM为605.423828125
删除未同步订单2410011540350031366467
2024-10-01 15:40:38>>>订单2410011540350031366467删除成功,剩余空间为1680500,占用RAM为615.986328125
检测订单目录中>>>
无未同步订单>>>
2024-10-01 15:40:38 >>>当前Ram内存为588.1064453125
定时检测未同步订单启用
2024-10-01 15:40:39>>>cash write=0C
2024-10-01 15:40:39>>>cash read=3E


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


===15:55:33===
2024-10-01 15:54:58 >>>回调事件[910,devices/S3136]
2024-10-01 15:54:58 >>>故障排除日志:上一MQTT订单号缓存列表为24100115391589170889
2024-10-01 15:54:58 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 15:54:58 开始打印,排队:83,票券:2410011554495529192801,订单:24100115544955287369,[2024-10-01 15:54:57微信支付10元]
2024-10-01 15:55:00 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011554495529192801","queue_number":83,"trade_uid":"24100115544955287369"}]}
2024-10-01 15:55:00 >>>故障排除日志:删除未同步下发订单成功24100115544955287369
2024-10-01 15:55:00 >>>故障排除日志:终端同步成功后剩余订单列表


===16:17:34===
2024-10-01 16:16:42 >>>回调事件[910,devices/S3136]
2024-10-01 16:16:42 >>>故障排除日志:上一MQTT订单号缓存列表为24100115544955287369
2024-10-01 16:16:42 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 16:16:42 开始打印,排队:84,票券:2410011616352985717501,订单:24100116163529851643,[2024-10-01 16:16:42微信支付10元]
2024-10-01 16:16:44 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011616352985717501","queue_number":84,"trade_uid":"24100116163529851643"}]}
2024-10-01 16:16:44 >>>故障排除日志:删除未同步下发订单成功24100116163529851643
2024-10-01 16:16:45 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-01 16:16:54>>>cash read=00
2024-10-01 16:16:55>>>cash read=818F42
2024-10-01 16:16:55>>>cash write=02
2024-10-01 16:16:55 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-01 16:16:55>>>cash read=10
2024-10-01 16:16:55 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-01 16:16:55 当前产品价格10元，投币10元，打印小票中...
2024-10-01 16:16:55 >>>开始打印,排队号为85,订单号为2410011616550031362948
2024-10-01 16:16:56>>>订单2410011616550031362948写入成功,剩余空间为1679000,占用RAM为609.49609375
删除未同步订单2410011616550031362948
2024-10-01 16:16:58>>>订单2410011616550031362948删除成功,剩余空间为1680000,占用RAM为619.7578125
检测订单目录中>>>
无未同步订单>>>
2024-10-01 16:16:58 >>>当前Ram内存为590.615234375
定时检测未同步订单启用
2024-10-01 16:16:59>>>cash write=0C
2024-10-01 16:16:59>>>cash read=3E


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


===16:30:34===
2024-10-01 16:29:44 >>>回调事件[910,devices/S3136]
2024-10-01 16:29:44 >>>故障排除日志:上一MQTT订单号缓存列表为24100116163529851643
2024-10-01 16:29:44 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 16:29:44 开始打印,排队:86,票券:2410011629379612685801,订单:24100116293796122018,[2024-10-01 16:29:43微信支付10元]
2024-10-01 16:29:46 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011629379612685801","queue_number":86,"trade_uid":"24100116293796122018"}]}
2024-10-01 16:29:46 >>>故障排除日志:删除未同步下发订单成功24100116293796122018
2024-10-01 16:29:46 >>>故障排除日志:终端同步成功后剩余订单列表


===16:35:34===
2024-10-01 16:34:51 >>>回调事件[910,devices/S3136]
2024-10-01 16:34:51 >>>故障排除日志:上一MQTT订单号缓存列表为24100116293796122018
2024-10-01 16:34:51 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 16:34:51 开始打印,排队:87,票券:2410011634390622247601,订单:24100116343906217779,[2024-10-01 16:34:50微信支付10元]
2024-10-01 16:34:51 开始打印,排队:88,票券:2410011634390622402602,订单:24100116343906217779,[2024-10-01 16:34:50微信支付10元]
2024-10-01 16:34:55 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011634390622247601","queue_number":87,"trade_uid":"24100116343906217779"},{"ticket_no":"2410011634390622402602","queue_number":88,"trade_uid":"24100116343906217779"}]}
2024-10-01 16:34:55 >>>故障排除日志:删除未同步下发订单成功24100116343906217779
2024-10-01 16:34:55 >>>故障排除日志:删除未同步下发订单成功24100116343906217779
2024-10-01 16:34:55 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


===16:50:35===
2024-10-01 16:50:01>>>cash read=29
2024-10-01 16:50:01 >>>回调事件130,cash_status,20029,退钞中
2024-10-01 16:50:02>>>cash read=01
2024-10-01 16:50:03>>>cash read=3E
2024-10-01 16:50:08>>>cash read=00
2024-10-01 16:50:09>>>cash read=01
2024-10-01 16:50:11>>>cash read=3E
2024-10-01 16:50:18>>>cash read=29
2024-10-01 16:50:18 >>>回调事件130,cash_status,20029,退钞中
2024-10-01 16:50:18>>>cash read=2F29
2024-10-01 16:50:20>>>cash read=00
2024-10-01 16:50:21>>>cash read=2F29
2024-10-01 16:50:23>>>cash read=00
2024-10-01 16:50:24>>>cash read=2F29
2024-10-01 16:50:25>>>cash read=3E


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


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


===17:23:37===
2024-10-01 17:23:34 >>>回调事件[910,devices/S3136]
2024-10-01 17:23:34 >>>故障排除日志:上一MQTT订单号缓存列表为24100117104783762851
2024-10-01 17:23:34 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 17:23:34 开始打印,排队:94,票券:2410011723291132096501,订单:24100117232911314941,[2024-10-01 17:23:34微信支付10元]


===17:26:37===
2024-10-01 17:26:00 >>>回调事件[910,devices/S3136]
2024-10-01 17:26:00 >>>故障排除日志:上一MQTT订单号缓存列表为24100117232911314941
2024-10-01 17:26:00 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 17:26:00 开始打印,排队:95,票券:2410011725477675924601,订单:24100117254776755086,[2024-10-01 17:25:59支付宝支付10元]
2024-10-01 17:26:02 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011725477675924601","queue_number":95,"trade_uid":"24100117254776755086"}]}
2024-10-01 17:26:02 >>>故障排除日志:删除未同步下发订单成功24100117254776755086
2024-10-01 17:26:02 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


===17:35:39===
2024-10-01 17:34:59 >>>回调事件[910,devices/S3136]
2024-10-01 17:34:59 >>>故障排除日志:上一MQTT订单号缓存列表为24100117291989025853
2024-10-01 17:34:59 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 17:34:59 开始打印,排队:98,票券:2410011734516021561701,订单:24100117345160212285,[2024-10-01 17:34:58微信支付10元]
2024-10-01 17:35:01 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011734516021561701","queue_number":98,"trade_uid":"24100117345160212285"}]}
2024-10-01 17:35:01 >>>故障排除日志:删除未同步下发订单成功24100117345160212285
2024-10-01 17:35:01 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单关闭
检测订单目录中>>>
无未同步订单>>>
2024-10-01 17:35:36 >>>回调事件[910,devices/S3136]
2024-10-01 17:35:36 >>>故障排除日志:上一MQTT订单号缓存列表为24100117345160212285
2024-10-01 17:35:36 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 17:35:36 开始打印,排队:99,票券:2410011735301201618201,订单:24100117353012011038,[2024-10-01 17:35:36微信支付10元]


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


===17:40:40===
2024-10-01 17:40:01 >>>回调事件[910,devices/S3136]
2024-10-01 17:40:01 >>>故障排除日志:上一MQTT订单号缓存列表为24100117382459141453
2024-10-01 17:40:01 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 17:40:01 开始打印,排队:101,票券:2410011739519684687301,订单:24100117395196843318,[2024-10-01 17:39:59支付宝支付10元]
2024-10-01 17:40:03 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011739519684687301","queue_number":101,"trade_uid":"24100117395196843318"}]}
2024-10-01 17:40:03 >>>故障排除日志:删除未同步下发订单成功24100117395196843318
2024-10-01 17:40:03 >>>故障排除日志:终端同步成功后剩余订单列表


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


===17:46:40===
2024-10-01 17:45:49 >>>回调事件[910,devices/S3136]
2024-10-01 17:45:49 >>>故障排除日志:上一MQTT订单号缓存列表为24100117395196843318
2024-10-01 17:45:49 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 17:45:49 开始打印,排队:103,票券:2410011745440640577801,订单:24100117454406398839,[2024-10-01 17:45:49微信支付10元]
2024-10-01 17:45:51 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011745440640577801","queue_number":103,"trade_uid":"24100117454406398839"}]}
2024-10-01 17:45:51 >>>故障排除日志:删除未同步下发订单成功24100117454406398839
2024-10-01 17:45:51 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单关闭
检测订单目录中>>>
无未同步订单>>>


===17:55:40===
2024-10-01 17:54:46>>>cash read=29
2024-10-01 17:54:46 >>>回调事件130,cash_status,20029,退钞中
2024-10-01 17:54:47>>>cash read=01
2024-10-01 17:54:50>>>cash read=00
2024-10-01 17:54:50>>>cash read=818F42
2024-10-01 17:54:50>>>cash write=02
2024-10-01 17:54:50 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-01 17:54:51>>>cash read=10
2024-10-01 17:54:51 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-01 17:54:51 当前产品价格10元，投币10元，打印小票中...
2024-10-01 17:54:51 >>>开始打印,排队号为104,订单号为2410011754510031365817
2024-10-01 17:54:51>>>订单2410011754510031365817写入成功,剩余空间为1679500,占用RAM为606.5361328125
删除未同步订单2410011754510031365817
2024-10-01 17:54:53>>>订单2410011754510031365817删除成功,剩余空间为1680500,占用RAM为616.828125
检测订单目录中>>>
无未同步订单>>>
2024-10-01 17:54:53 >>>当前Ram内存为588.55859375
定时检测未同步订单启用
2024-10-01 17:54:54>>>cash write=0C
2024-10-01 17:54:55>>>cash read=3E


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


===17:59:40===
2024-10-01 17:59:23 >>>回调事件[910,devices/S3136]
2024-10-01 17:59:23 >>>故障排除日志:上一MQTT订单号缓存列表为24100117454406398839
2024-10-01 17:59:23 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 17:59:23 开始打印,排队:105,票券:2410011759141110886101,订单:24100117591411103554,[2024-10-01 17:59:22微信支付10元]
2024-10-01 17:59:25 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011759141110886101","queue_number":105,"trade_uid":"24100117591411103554"}]}
2024-10-01 17:59:25 >>>故障排除日志:删除未同步下发订单成功24100117591411103554
2024-10-01 17:59:25 >>>故障排除日志:终端同步成功后剩余订单列表


===18:03:41===
2024-10-01 18:03:30 >>>回调事件[910,devices/S3136]
2024-10-01 18:03:30 >>>故障排除日志:上一MQTT订单号缓存列表为24100117591411103554
2024-10-01 18:03:30 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 18:03:30 开始打印,排队:106,票券:2410011803236249074301,订单:24100118032362486079,[2024-10-01 18:03:29微信支付10元]
2024-10-01 18:03:32 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011803236249074301","queue_number":106,"trade_uid":"24100118032362486079"}]}
2024-10-01 18:03:32 >>>故障排除日志:删除未同步下发订单成功24100118032362486079
2024-10-01 18:03:32 >>>故障排除日志:终端同步成功后剩余订单列表


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


===18:11:41===
2024-10-01 18:11:24 >>>回调事件[910,devices/S3136]
2024-10-01 18:11:24 >>>故障排除日志:上一MQTT订单号缓存列表为24100118090799934585
2024-10-01 18:11:24 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 18:11:24 开始打印,排队:108,票券:2410011811148010739301,订单:24100118111480103645,[2024-10-01 18:11:23微信支付10元]
2024-10-01 18:11:26 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011811148010739301","queue_number":108,"trade_uid":"24100118111480103645"}]}
2024-10-01 18:11:26 >>>故障排除日志:删除未同步下发订单成功24100118111480103645
2024-10-01 18:11:26 >>>故障排除日志:终端同步成功后剩余订单列表


===18:16:41===
2024-10-01 18:16:33 >>>回调事件[910,devices/S3136]
2024-10-01 18:16:33 >>>故障排除日志:上一MQTT订单号缓存列表为24100118111480103645
2024-10-01 18:16:33 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 18:16:33 开始打印,排队:109,票券:2410011816210747964101,订单:24100118162107475074,[2024-10-01 18:16:31微信支付10元]
2024-10-01 18:16:35 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011816210747964101","queue_number":109,"trade_uid":"24100118162107475074"}]}
2024-10-01 18:16:35 >>>故障排除日志:删除未同步下发订单成功24100118162107475074
2024-10-01 18:16:35 >>>故障排除日志:终端同步成功后剩余订单列表


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


===18:22:42===
删除未同步订单2410011821380031361052
2024-10-01 18:21:41>>>订单2410011821380031361052删除成功,剩余空间为1681500,占用RAM为620.2529296875
检测订单目录中>>>
无未同步订单>>>
2024-10-01 18:21:41 >>>当前Ram内存为588.5771484375
定时检测未同步订单启用
2024-10-01 18:21:42>>>cash write=0C
2024-10-01 18:21:42>>>cash read=3E


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


===18:24:42===
2024-10-01 18:23:48 >>>回调事件[910,devices/S3136]
2024-10-01 18:23:48 >>>故障排除日志:上一MQTT订单号缓存列表为24100118162107475074
2024-10-01 18:23:48 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 18:23:48 开始打印,排队:111,票券:2410011823403834472301,订单:24100118234038340397,[2024-10-01 18:23:48微信支付10元]
2024-10-01 18:23:50 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011823403834472301","queue_number":111,"trade_uid":"24100118234038340397"}]}
2024-10-01 18:23:50 >>>故障排除日志:删除未同步下发订单成功24100118234038340397
2024-10-01 18:23:50 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-01 18:24:21 >>>回调事件[910,devices/S3136]
2024-10-01 18:24:21 >>>故障排除日志:上一MQTT订单号缓存列表为24100118234038340397
2024-10-01 18:24:21 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 18:24:21 开始打印,排队:112,票券:2410011824147786323601,订单:24100118241477859593,[2024-10-01 18:24:20微信支付10元]
2024-10-01 18:24:23 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011824147786323601","queue_number":112,"trade_uid":"24100118241477859593"}]}
2024-10-01 18:24:23 >>>故障排除日志:删除未同步下发订单成功24100118241477859593
2024-10-01 18:24:23 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


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


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


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


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


===18:46:44===
2024-10-01 18:46:17 >>>回调事件[910,devices/S3136]
2024-10-01 18:46:17 >>>故障排除日志:上一MQTT订单号缓存列表为24100118402442270927
2024-10-01 18:46:17 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 18:46:17 开始打印,排队:119,票券:2410011846116860778101,订单:24100118461168604249,[2024-10-01 18:46:16微信支付10元]
2024-10-01 18:46:19 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011846116860778101","queue_number":119,"trade_uid":"24100118461168604249"}]}
2024-10-01 18:46:19 >>>故障排除日志:删除未同步下发订单成功24100118461168604249
2024-10-01 18:46:19 >>>故障排除日志:终端同步成功后剩余订单列表


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


===18:59:45===
2024-10-01 18:59:08 >>>回调事件[910,devices/S3136]
2024-10-01 18:59:08 >>>故障排除日志:上一MQTT订单号缓存列表为24100118573859990718
2024-10-01 18:59:08 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 18:59:08 开始打印,排队:121,票券:2410011858556740876201,订单:24100118585567402196,[2024-10-01 18:59:07支付宝支付10元]
2024-10-01 18:59:10 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011858556740876201","queue_number":121,"trade_uid":"24100118585567402196"}]}
2024-10-01 18:59:10 >>>故障排除日志:删除未同步下发订单成功24100118585567402196
2024-10-01 18:59:10 >>>故障排除日志:终端同步成功后剩余订单列表


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


===19:08:45===
2024-10-01 19:08:42 >>>回调事件[910,devices/S3136]
2024-10-01 19:08:42 >>>故障排除日志:上一MQTT订单号缓存列表为24100119022287146071
2024-10-01 19:08:42 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 19:08:42 开始打印,排队:123,票券:2410011908339924084601,订单:24100119083399237034,[2024-10-01 19:08:41微信支付10元]


===19:09:45===
2024-10-01 19:08:44 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011908339924084601","queue_number":123,"trade_uid":"24100119083399237034"}]}
2024-10-01 19:08:44 >>>故障排除日志:删除未同步下发订单成功24100119083399237034
2024-10-01 19:08:44 >>>故障排除日志:终端同步成功后剩余订单列表


===19:20:46===
2024-10-01 19:19:54 >>>回调事件[910,devices/S3136]
2024-10-01 19:19:54 >>>故障排除日志:上一MQTT订单号缓存列表为24100119083399237034
2024-10-01 19:19:54 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 19:19:54 开始打印,排队:124,票券:2410011919439844637101,订单:24100119194398441638,[2024-10-01 19:19:53支付宝支付10元]
2024-10-01 19:19:55 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011919439844637101","queue_number":124,"trade_uid":"24100119194398441638"}]}
2024-10-01 19:19:56 >>>故障排除日志:删除未同步下发订单成功24100119194398441638
2024-10-01 19:19:56 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-01 19:20:19 >>>回调事件[910,devices/S3136]
2024-10-01 19:20:19 >>>故障排除日志:上一MQTT订单号缓存列表为24100119194398441638
2024-10-01 19:20:19 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 19:20:19 开始打印,排队:125,票券:2410011920071628843501,订单:24100119200716282616,[2024-10-01 19:20:18微信支付10元]
2024-10-01 19:20:21 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011920071628843501","queue_number":125,"trade_uid":"24100119200716282616"}]}
2024-10-01 19:20:21 >>>故障排除日志:删除未同步下发订单成功24100119200716282616
2024-10-01 19:20:21 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


===19:49:48===
2024-10-01 19:49:45 >>>回调事件[910,devices/S3136]
2024-10-01 19:49:45 >>>故障排除日志:上一MQTT订单号缓存列表为24100119200716282616
2024-10-01 19:49:45 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 19:49:45 开始打印,排队:127,票券:2410011949383299351201,订单:24100119493832990182,[2024-10-01 19:49:44微信支付10元]


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


===19:53:48===
2024-10-01 19:53:23 >>>回调事件[910,devices/S3136]
2024-10-01 19:53:23 >>>故障排除日志:上一MQTT订单号缓存列表为24100119520381450896
2024-10-01 19:53:23 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 19:53:23 开始打印,排队:129,票券:2410011953181379001401,订单:24100119531813786478,[2024-10-01 19:53:22微信支付10元]
2024-10-01 19:53:23 开始打印,排队:130,票券:2410011953181379145102,订单:24100119531813786478,[2024-10-01 19:53:22微信支付10元]
2024-10-01 19:53:27 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011953181379001401","queue_number":129,"trade_uid":"24100119531813786478"},{"ticket_no":"2410011953181379145102","queue_number":130,"trade_uid":"24100119531813786478"}]}
2024-10-01 19:53:27 >>>故障排除日志:删除未同步下发订单成功24100119531813786478
2024-10-01 19:53:27 >>>故障排除日志:删除未同步下发订单成功24100119531813786478
2024-10-01 19:53:27 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


===20:11:49===
2024-10-01 20:11:41 >>>回调事件[910,devices/S3136]
2024-10-01 20:11:41 >>>故障排除日志:上一MQTT订单号缓存列表为24100120065327106835
2024-10-01 20:11:41 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 20:11:41 开始打印,排队:133,票券:2410012011342493211601,订单:24100120113424928797,[2024-10-01 20:11:40微信支付10元]
2024-10-01 20:11:43 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410012011342493211601","queue_number":133,"trade_uid":"24100120113424928797"}]}
2024-10-01 20:11:43 >>>故障排除日志:删除未同步下发订单成功24100120113424928797
2024-10-01 20:11:43 >>>故障排除日志:终端同步成功后剩余订单列表


===20:13:49===
2024-10-01 20:13:11 >>>回调事件[910,devices/S3136]
2024-10-01 20:13:11 >>>故障排除日志:上一MQTT订单号缓存列表为24100120113424928797
2024-10-01 20:13:11 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 20:13:11 开始打印,排队:134,票券:2410012013055932843101,订单:24100120130559324785,[2024-10-01 20:13:11支付宝支付10元]
2024-10-01 20:13:13 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410012013055932843101","queue_number":134,"trade_uid":"24100120130559324785"}]}
2024-10-01 20:13:13 >>>故障排除日志:删除未同步下发订单成功24100120130559324785
2024-10-01 20:13:14 >>>故障排除日志:终端同步成功后剩余订单列表


===20:24:49===
2024-10-01 20:24:38>>>cash read=0A
2024-10-01 20:24:39>>>cash read=3E


===20:35:49===
2024-10-01 20:35:06 >>>回调事件[910,devices/S3136]
2024-10-01 20:35:06 >>>故障排除日志:上一MQTT订单号缓存列表为24100120130559324785
2024-10-01 20:35:06 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 20:35:06 开始打印,排队:135,票券:2410012034547999236701,订单:24100120345479987979,[2024-10-01 20:35:04微信支付10元]
2024-10-01 20:35:07 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410012034547999236701","queue_number":135,"trade_uid":"24100120345479987979"}]}
2024-10-01 20:35:07 >>>故障排除日志:删除未同步下发订单成功24100120345479987979
2024-10-01 20:35:08 >>>故障排除日志:终端同步成功后剩余订单列表


===20:41:50===
2024-10-01 20:41:28>>>cash read=00
2024-10-01 20:41:29>>>cash read=2F29
2024-10-01 20:41:30>>>cash read=3E
2024-10-01 20:41:32>>>cash read=00
2024-10-01 20:41:33>>>cash read=29
2024-10-01 20:41:33 >>>回调事件130,cash_status,20029,退钞中
2024-10-01 20:41:34>>>cash read=2F29
2024-10-01 20:41:35>>>cash read=3E
2024-10-01 20:41:37>>>cash read=2F2901
2024-10-01 20:41:39>>>cash read=00
2024-10-01 20:41:39>>>cash read=818F42
2024-10-01 20:41:39>>>cash write=02
2024-10-01 20:41:39 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-01 20:41:40>>>cash read=10
2024-10-01 20:41:40 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-01 20:41:40 当前产品价格10元，投币10元，打印小票中...
2024-10-01 20:41:40 >>>开始打印,排队号为136,订单号为2410012041400031365497
2024-10-01 20:41:40>>>订单2410012041400031365497写入成功,剩余空间为1679500,占用RAM为606.76953125
删除未同步订单2410012041400031365497
2024-10-01 20:41:42>>>订单2410012041400031365497删除成功,剩余空间为1680500,占用RAM为618.337890625
检测订单目录中>>>
无未同步订单>>>
2024-10-01 20:41:42 >>>当前Ram内存为589.6201171875
定时检测未同步订单启用
2024-10-01 20:41:43>>>cash write=0C
2024-10-01 20:41:43>>>cash read=3E


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


===20:43:50===
定时检测未同步订单关闭
检测订单目录中>>>
无未同步订单>>>