TLClient_JSSCOM_LuatOS-Air_V4010_RDA8910_RFTTS_0xe0000,2.5.4,861658065659628,90826129753619,
poweron reason:0

===08:12:26===
上一时间戳为1728176959
隔日重置时间戳true
隔日清空未同步下发列表true
当前排队号为1,音量为5
初始化产品信息:[{"time_limit_date":"","ticket_category":"0","expiry_date":726,"product_detail":"此票劵当天有效，过期作废。","time_limit_status":"0","begin_minute":"00","product_uid":"4351590954437974552","use_timer":1,"old_price":"10","end_hour":"23","sale_price":"10","end_minute":"59","begin_hour":"00","sale_status":1,"product_name":"快剪"},{"time_limit_date":"","ticket_category":"0","expiry_date":730,"product_detail":"","time_limit_status":"0","begin_minute":"00","product_uid":"4351590954437995406","use_timer":1,"old_price":"20","end_hour":"23","sale_price":"15","end_minute":"59","begin_hour":"00","sale_status":1,"product_name":"精剪(精细理发)"},{"time_limit_date":"","ticket_category":"0","expiry_date":730,"product_detail":"","time_limit_status":"0","begin_minute":"00","product_uid":"12566542176647531205","use_timer":1,"old_price":"15","end_hour":"23","sale_price":"15","end_minute":"59","begin_hour":"00","sale_status":1,"product_name":"儿童雕刻造型，女士理发"},{"time_limit_date":"","ticket_category":"0","expiry_date":730,"product_detail":"","time_limit_status":"0","begin_minute":"00","product_uid":"12566542176647920166","use_timer":1,"old_price":"5","end_hour":"23","sale_price":"5","end_minute":"59","begin_hour":"00","sale_status":1,"product_name":"y差价+5"}]
打印门店标题设置为人人发十元快剪
是否打印二维码设置为1
是否打印紧凑设置为3
session_id:878cf****5334e
纸币器设置接收纸币范围为36
欢迎使用天羚自助售票系统[2.5.4]
定时检测未同步订单启用
2024-10-07 08:11:25>>>cash write=30
2024-10-07 08:11:25>>>cash write=02
2024-10-07 08:11:25>>>cash write=3E
2024-10-07 08:11:25>>>cash read=808F808F808F
系统时间初始化成功，时间为202410781125
2024-10-07 08:11:26>>>cash write=02
2024-10-07 08:11:26 >>>剩余flash空间=1679500,占用RAM为640.2783203125
2024-10-07 08:11:26 >>>回调事件:910,subscribe,10000,连接服务器成功

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

2024-10-07 08:11:29>>>cash write=0C
2024-10-07 08:11:29>>>cash read=3E
流量卡还有297天过期
2024-10-07 08:11:33 >>>当前Ram内存为633.73046875


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


===08:35:26===
2024-10-07 08:34:36>>>cash read=0A
2024-10-07 08:34:37>>>cash read=3E


===08:43:27===
2024-10-07 08:42:40 >>>回调事件[910,devices/S2723]
当日首次设置时间戳true为1728261760
2024-10-07 08:42:40 >>>故障排除日志:上一MQTT订单号缓存列表为24100620544321964646
2024-10-07 08:42:40 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 08:42:40 开始打印,排队:1,票券:2410070842337566931201,订单:24100708423375665456,[2024-10-07 08:42:39微信支付10元]
2024-10-07 08:42:42 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410070842337566931201","queue_number":1,"trade_uid":"24100708423375665456"}]}
2024-10-07 08:42:42 >>>故障排除日志:删除未同步下发订单成功24100708423375665456
2024-10-07 08:42:42 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-07 08:42:49>>>cash read=00
2024-10-07 08:42:50>>>cash read=818F42
2024-10-07 08:42:50>>>cash write=02
2024-10-07 08:42:50 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-07 08:42:50>>>cash read=10
2024-10-07 08:42:50 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-07 08:42:50 当前产品价格10元，投币10元，打印小票中...
2024-10-07 08:42:50 >>>开始打印,排队号为2,订单号为2410070842500027233350
2024-10-07 08:42:51>>>订单2410070842500027233350写入成功,剩余空间为1679000,占用RAM为612.677734375
删除未同步订单2410070842500027233350
2024-10-07 08:42:53>>>订单2410070842500027233350删除成功,剩余空间为1680000,占用RAM为625.8935546875
检测订单目录中>>>
无未同步订单>>>
2024-10-07 08:42:53 >>>当前Ram内存为595.142578125
定时检测未同步订单启用
2024-10-07 08:42:54>>>cash write=0C
2024-10-07 08:42:54>>>cash read=3E


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


===08:52:27===
2024-10-07 08:52:24 >>>回调事件[910,devices/S2723]
2024-10-07 08:52:24 >>>故障排除日志:上一MQTT订单号缓存列表为24100708423375665456
2024-10-07 08:52:24 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 08:52:24 开始打印,排队:3,票券:2410070852174811833901,订单:24100708521748114348,[2024-10-07 08:52:24微信支付10元]


===08:53:28===
2024-10-07 08:52:26 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410070852174811833901","queue_number":3,"trade_uid":"24100708521748114348"}]}
2024-10-07 08:52:26 >>>故障排除日志:删除未同步下发订单成功24100708521748114348
2024-10-07 08:52:26 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


===09:07:29===
2024-10-07 09:06:37>>>cash read=00
2024-10-07 09:06:37>>>cash read=818F42
2024-10-07 09:06:37>>>cash write=02
2024-10-07 09:06:37 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-07 09:06:38>>>cash read=10
2024-10-07 09:06:38 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-07 09:06:39>>>cash write=0C
2024-10-07 09:06:39>>>cash read=00
2024-10-07 09:06:40>>>cash read=818F41
2024-10-07 09:06:40>>>cash write=02
2024-10-07 09:06:40 >>>回调事件130,cash_status,10022,进钞中...read money=5
2024-10-07 09:06:41>>>cash read=10
2024-10-07 09:06:41 >>>回调事件130,5,10023,finish Money=5,进钞完成
2024-10-07 09:06:41 当前产品价格15元，投币15元，打印小票中...
2024-10-07 09:06:41 >>>开始打印,排队号为6,订单号为2410070906380027235558
2024-10-07 09:06:41>>>订单2410070906380027235558写入成功,剩余空间为1679500,占用RAM为609.75
删除未同步订单2410070906380027235558
2024-10-07 09:06:43>>>订单2410070906380027235558删除成功,剩余空间为1680500,占用RAM为623.3154296875
检测订单目录中>>>
无未同步订单>>>
2024-10-07 09:06:43 >>>当前Ram内存为593.31640625
定时检测未同步订单启用
2024-10-07 09:06:44>>>cash write=0C
2024-10-07 09:06:44>>>cash read=3E


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


===09:09:30===
2024-10-07 09:09:27>>>cash read=00
2024-10-07 09:09:28>>>cash read=2F29


===09:10:30===
2024-10-07 09:09:29>>>cash read=01
2024-10-07 09:09:29>>>cash read=2F
2024-10-07 09:09:31>>>cash read=3E
2024-10-07 09:09:33>>>cash read=00
2024-10-07 09:09:35>>>cash read=2F29
2024-10-07 09:09:37>>>cash read=3E
2024-10-07 09:09:39>>>cash read=00
2024-10-07 09:09:40>>>cash read=00818F42
2024-10-07 09:09:40>>>cash write=02
2024-10-07 09:09:40 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-07 09:09:41>>>cash read=10
2024-10-07 09:09:41 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-07 09:09:41 当前产品价格10元，投币10元，打印小票中...
2024-10-07 09:09:41 >>>开始打印,排队号为7,订单号为2410070909410027238725
2024-10-07 09:09:41>>>订单2410070909410027238725写入成功,剩余空间为1679500,占用RAM为610.728515625
删除未同步订单2410070909410027238725
2024-10-07 09:09:43>>>订单2410070909410027238725删除成功,剩余空间为1680500,占用RAM为622.16796875
检测订单目录中>>>
无未同步订单>>>
2024-10-07 09:09:43 >>>当前Ram内存为592.4306640625
定时检测未同步订单启用
2024-10-07 09:09:44>>>cash write=0C
2024-10-07 09:09:44>>>cash read=3E


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


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


===09:20:31===
2024-10-07 09:19:39 >>>回调事件[910,devices/S2723]
2024-10-07 09:19:39 >>>故障排除日志:上一MQTT订单号缓存列表为24100709131459089857
2024-10-07 09:19:39 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 09:19:39 开始打印,排队:9,票券:2410070919317431913701,订单:24100709193174315126,[2024-10-07 09:19:38微信支付10元]
2024-10-07 09:19:39 开始打印,排队:10,票券:2410070919317432059702,订单:24100709193174315126,[2024-10-07 09:19:38微信支付10元]
2024-10-07 09:19:43 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410070919317431913701","queue_number":9,"trade_uid":"24100709193174315126"},{"ticket_no":"2410070919317432059702","queue_number":10,"trade_uid":"24100709193174315126"}]}
2024-10-07 09:19:43 >>>故障排除日志:删除未同步下发订单成功24100709193174315126
2024-10-07 09:19:43 >>>故障排除日志:删除未同步下发订单成功24100709193174315126
2024-10-07 09:19:43 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


===10:00:31===
2024-10-07 09:59:36 >>>回调事件[910,devices/S2723]
2024-10-07 09:59:36 >>>故障排除日志:上一MQTT订单号缓存列表为24100709193174315126|24100709193174315126
2024-10-07 09:59:36 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 09:59:36 开始打印,排队:12,票券:2410070959301179719101,订单:24100709593011792973,[2024-10-07 09:59:36微信支付10元]
2024-10-07 09:59:38 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410070959301179719101","queue_number":12,"trade_uid":"24100709593011792973"}]}
2024-10-07 09:59:38 >>>故障排除日志:删除未同步下发订单成功24100709593011792973
2024-10-07 09:59:38 >>>故障排除日志:终端同步成功后剩余订单列表


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


===10:11:32===
2024-10-07 10:10:55 >>>回调事件[910,devices/S2723]
2024-10-07 10:10:55 >>>故障排除日志:上一MQTT订单号缓存列表为24100710070428013286
2024-10-07 10:10:55 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 10:10:55 开始打印,排队:14,票券:2410071010457296738101,订单:24100710104572962667,[2024-10-07 10:10:53微信支付10元]
2024-10-07 10:10:57 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410071010457296738101","queue_number":14,"trade_uid":"24100710104572962667"}]}
2024-10-07 10:10:57 >>>故障排除日志:删除未同步下发订单成功24100710104572962667
2024-10-07 10:10:57 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


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


===10:32:33===
2024-10-07 10:31:37>>>cash read=00
2024-10-07 10:31:38>>>cash read=2F29
2024-10-07 10:31:40>>>cash read=3E
2024-10-07 10:31:42>>>cash read=2F29
2024-10-07 10:31:43>>>cash read=01
2024-10-07 10:31:44>>>cash read=2F
2024-10-07 10:31:45>>>cash read=3E
2024-10-07 10:31:47>>>cash read=00
2024-10-07 10:31:48>>>cash read=01
2024-10-07 10:31:49>>>cash read=3E
2024-10-07 10:31:50>>>cash read=00
2024-10-07 10:31:50>>>cash read=818F42
2024-10-07 10:31:50>>>cash write=02
2024-10-07 10:31:50 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-07 10:31:51>>>cash read=10
2024-10-07 10:31:51 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-07 10:31:51 当前产品价格10元，投币10元，打印小票中...
2024-10-07 10:31:51 >>>开始打印,排队号为20,订单号为2410071031510027232216
2024-10-07 10:31:51>>>订单2410071031510027232216写入成功,剩余空间为1679500,占用RAM为611.5458984375
删除未同步订单2410071031510027232216
2024-10-07 10:31:53>>>订单2410071031510027232216删除成功,剩余空间为1680000,占用RAM为621.333984375
检测订单目录中>>>
无未同步订单>>>
2024-10-07 10:31:54 >>>当前Ram内存为592.5380859375
定时检测未同步订单启用
2024-10-07 10:31:54>>>cash write=0C
2024-10-07 10:31:54>>>cash read=3E


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


===10:45:34===
2024-10-07 10:45:24 >>>回调事件[910,devices/S2723]
2024-10-07 10:45:24 >>>故障排除日志:上一MQTT订单号缓存列表为24100710272046034883
2024-10-07 10:45:24 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 10:45:24 开始打印,排队:21,票券:2410071045120451298901,订单:24100710451204508226,[2024-10-07 10:45:23微信支付10元]
2024-10-07 10:45:24 开始打印,排队:22,票券:2410071045120451529702,订单:24100710451204508226,[2024-10-07 10:45:23微信支付10元]
2024-10-07 10:45:27 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410071045120451298901","queue_number":21,"trade_uid":"24100710451204508226"},{"ticket_no":"2410071045120451529702","queue_number":22,"trade_uid":"24100710451204508226"}]}
2024-10-07 10:45:27 >>>故障排除日志:删除未同步下发订单成功24100710451204508226
2024-10-07 10:45:27 >>>故障排除日志:删除未同步下发订单成功24100710451204508226
2024-10-07 10:45:27 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


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


===11:43:36===
2024-10-07 11:43:00 >>>回调事件[910,devices/S2723]
2024-10-07 11:43:00 >>>故障排除日志:上一MQTT订单号缓存列表为24100711360525858227|24100711360525858227
2024-10-07 11:43:00 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 11:43:00 开始打印,排队:27,票券:2410071142523844821201,订单:24100711425238444229,[2024-10-07 11:42:59微信支付10元]
2024-10-07 11:43:02 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410071142523844821201","queue_number":27,"trade_uid":"24100711425238444229"}]}
2024-10-07 11:43:02 >>>故障排除日志:删除未同步下发订单成功24100711425238444229
2024-10-07 11:43:03 >>>故障排除日志:终端同步成功后剩余订单列表


===12:00:36===
2024-10-07 11:59:39>>>cash read=0A
2024-10-07 11:59:40>>>cash read=3E


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


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


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


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


===12:46:38===
2024-10-07 12:45:40>>>cash read=00818F42
2024-10-07 12:45:40>>>cash write=02
2024-10-07 12:45:40 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-07 12:45:41>>>cash read=10
2024-10-07 12:45:41 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-07 12:45:41 当前产品价格10元，投币10元，打印小票中...
2024-10-07 12:45:41 >>>开始打印,排队号为30,订单号为2410071245410027239088
2024-10-07 12:45:41>>>订单2410071245410027239088写入成功,剩余空间为1680000,占用RAM为609.4638671875
删除未同步订单2410071245410027239088
2024-10-07 12:45:43>>>订单2410071245410027239088删除成功,剩余空间为1680500,占用RAM为621.7021484375
检测订单目录中>>>
无未同步订单>>>
2024-10-07 12:45:43 >>>当前Ram内存为592.3779296875
定时检测未同步订单启用
2024-10-07 12:45:44>>>cash write=0C
2024-10-07 12:45:44>>>cash read=3E


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


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


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


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


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


===13:06:39===
2024-10-07 13:06:04>>>cash read=00
2024-10-07 13:06:05>>>cash read=29
2024-10-07 13:06:05 >>>回调事件130,cash_status,20029,退钞中
2024-10-07 13:06:06>>>cash read=00
2024-10-07 13:06:07>>>cash read=00818F42
2024-10-07 13:06:07>>>cash write=02
2024-10-07 13:06:07 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-07 13:06:07>>>cash read=10
2024-10-07 13:06:08 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-07 13:06:08 当前产品价格10元，投币10元，打印小票中...
2024-10-07 13:06:08 >>>开始打印,排队号为33,订单号为2410071306080027231881
2024-10-07 13:06:08>>>订单2410071306080027231881写入成功,剩余空间为1679500,占用RAM为610.8369140625
删除未同步订单2410071306080027231881
2024-10-07 13:06:10>>>订单2410071306080027231881删除成功,剩余空间为1680500,占用RAM为622.4453125
检测订单目录中>>>
无未同步订单>>>
2024-10-07 13:06:10 >>>当前Ram内存为592.8681640625
定时检测未同步订单启用
2024-10-07 13:06:11>>>cash write=0C
2024-10-07 13:06:11>>>cash read=3E


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


===13:12:40===
2024-10-07 13:12:11>>>cash read=292F29
2024-10-07 13:12:11 >>>回调事件130,cash_status,20029,退钞中
2024-10-07 13:12:12>>>cash read=01
2024-10-07 13:12:13>>>cash read=2F
2024-10-07 13:12:14>>>cash read=3E
2024-10-07 13:12:15>>>cash read=00
2024-10-07 13:12:15>>>cash read=818F42
2024-10-07 13:12:15>>>cash write=02
2024-10-07 13:12:15 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-07 13:12:16>>>cash read=10
2024-10-07 13:12:16 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-07 13:12:16 当前产品价格10元，投币10元，打印小票中...
2024-10-07 13:12:16 >>>开始打印,排队号为34,订单号为2410071312160027238815
2024-10-07 13:12:16>>>订单2410071312160027238815写入成功,剩余空间为1679500,占用RAM为611.2578125
删除未同步订单2410071312160027238815
2024-10-07 13:12:18>>>订单2410071312160027238815删除成功,剩余空间为1680500,占用RAM为625.3603515625
检测订单目录中>>>
无未同步订单>>>
2024-10-07 13:12:18 >>>当前Ram内存为593.1044921875
定时检测未同步订单启用
2024-10-07 13:12:19>>>cash write=0C
2024-10-07 13:12:19>>>cash read=3E


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


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


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


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


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


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


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


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


===13:54:42===
2024-10-07 13:53:53 >>>回调事件[910,devices/S2723]
2024-10-07 13:53:53 >>>故障排除日志:上一MQTT订单号缓存列表为24100713394165016718
2024-10-07 13:53:53 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 13:53:53 开始打印,排队:42,票券:2410071353477796121301,订单:24100713534777954573,[2024-10-07 13:53:53微信支付10元]
2024-10-07 13:53:53 开始打印,排队:43,票券:2410071353477796333502,订单:24100713534777954573,[2024-10-07 13:53:53微信支付10元]
2024-10-07 13:53:57 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410071353477796121301","queue_number":42,"trade_uid":"24100713534777954573"},{"ticket_no":"2410071353477796333502","queue_number":43,"trade_uid":"24100713534777954573"}]}
2024-10-07 13:53:57 >>>故障排除日志:删除未同步下发订单成功24100713534777954573
2024-10-07 13:53:57 >>>故障排除日志:删除未同步下发订单成功24100713534777954573
2024-10-07 13:53:57 >>>故障排除日志:终端同步成功后剩余订单列表


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


===14:04:43===
2024-10-07 14:04:04 >>>回调事件[910,devices/S2723]
2024-10-07 14:04:04 >>>故障排除日志:上一MQTT订单号缓存列表为24100713584772995337
2024-10-07 14:04:04 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 14:04:04 开始打印,排队:45,票券:2410071403585542102501,订单:24100714035855415489,[2024-10-07 14:04:04微信支付10元]
2024-10-07 14:04:04 开始打印,排队:46,票券:2410071403585542308302,订单:24100714035855415489,[2024-10-07 14:04:04微信支付10元]
2024-10-07 14:04:08 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410071403585542102501","queue_number":45,"trade_uid":"24100714035855415489"},{"ticket_no":"2410071403585542308302","queue_number":46,"trade_uid":"24100714035855415489"}]}
2024-10-07 14:04:08 >>>故障排除日志:删除未同步下发订单成功24100714035855415489
2024-10-07 14:04:08 >>>故障排除日志:删除未同步下发订单成功24100714035855415489
2024-10-07 14:04:08 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-07 14:04:29 >>>回调事件[910,devices/S2723]
2024-10-07 14:04:29 >>>故障排除日志:上一MQTT订单号缓存列表为24100714035855415489|24100714035855415489
2024-10-07 14:04:29 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 14:04:29 开始打印,排队:47,票券:2410071404216446176801,订单:24100714042164456028,[2024-10-07 14:04:28微信支付10元]
2024-10-07 14:04:31 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410071404216446176801","queue_number":47,"trade_uid":"24100714042164456028"}]}
2024-10-07 14:04:31 >>>故障排除日志:删除未同步下发订单成功24100714042164456028
2024-10-07 14:04:31 >>>故障排除日志:终端同步成功后剩余订单列表


===14:05:43===
2024-10-07 14:05:00 >>>回调事件[910,devices/S2723]
2024-10-07 14:05:00 >>>故障排除日志:上一MQTT订单号缓存列表为24100714042164456028
2024-10-07 14:05:00 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 14:05:00 开始打印,排队:48,票券:2410071404529153073601,订单:24100714045291527023,[2024-10-07 14:04:59微信支付10元]
2024-10-07 14:05:02 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410071404529153073601","queue_number":48,"trade_uid":"24100714045291527023"}]}
2024-10-07 14:05:02 >>>故障排除日志:删除未同步下发订单成功24100714045291527023
2024-10-07 14:05:02 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-07 14:05:17 >>>回调事件[910,devices/S2723]
2024-10-07 14:05:17 >>>故障排除日志:上一MQTT订单号缓存列表为24100714045291527023
2024-10-07 14:05:17 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 14:05:17 开始打印,排队:49,票券:2410071405105535955401,订单:24100714051055355241,[2024-10-07 14:05:16微信支付10元]
2024-10-07 14:05:19 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410071405105535955401","queue_number":49,"trade_uid":"24100714051055355241"}]}
2024-10-07 14:05:19 >>>故障排除日志:删除未同步下发订单成功24100714051055355241
2024-10-07 14:05:19 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


===14:16:44===
2024-10-07 14:16:11>>>cash read=00
2024-10-07 14:16:11>>>cash read=2F29
2024-10-07 14:16:13>>>cash read=01
2024-10-07 14:16:16>>>cash read=2F
2024-10-07 14:16:17>>>cash read=3E
2024-10-07 14:16:19>>>cash read=00
2024-10-07 14:16:19>>>cash read=818F42
2024-10-07 14:16:19>>>cash write=02
2024-10-07 14:16:20 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-07 14:16:20>>>cash read=10
2024-10-07 14:16:20 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-07 14:16:20 当前产品价格10元，投币10元，打印小票中...
2024-10-07 14:16:20 >>>开始打印,排队号为51,订单号为2410071416200027236415
2024-10-07 14:16:20>>>订单2410071416200027236415写入成功,剩余空间为1679500,占用RAM为607.5048828125
删除未同步订单2410071416200027236415
2024-10-07 14:16:22>>>订单2410071416200027236415删除成功,剩余空间为1680500,占用RAM为622.625
检测订单目录中>>>
无未同步订单>>>
2024-10-07 14:16:22 >>>当前Ram内存为593.119140625
定时检测未同步订单启用
2024-10-07 14:16:23>>>cash write=0C
2024-10-07 14:16:23>>>cash read=3E


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


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


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


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


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


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


===14:41:48===
2024-10-07 14:41:43>>>cash read=00
2024-10-07 14:41:43>>>cash read=818F42
2024-10-07 14:41:43>>>cash write=02
2024-10-07 14:41:43 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-07 14:41:44>>>cash read=10
2024-10-07 14:41:44 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-07 14:41:44 当前产品价格10元，投币10元，打印小票中...
2024-10-07 14:41:44 >>>开始打印,排队号为55,订单号为2410071441440027239249
2024-10-07 14:41:44>>>订单2410071441440027239249写入成功,剩余空间为1680000,占用RAM为609.6484375


===14:42:48===
删除未同步订单2410071441440027239249
2024-10-07 14:41:46>>>订单2410071441440027239249删除成功,剩余空间为1681500,占用RAM为624.94140625
检测订单目录中>>>
无未同步订单>>>
2024-10-07 14:41:46 >>>当前Ram内存为591.7802734375
定时检测未同步订单启用
2024-10-07 14:41:47>>>cash write=0C
2024-10-07 14:41:47>>>cash read=3E
定时检测未同步订单关闭
检测订单目录中>>>
无未同步订单>>>


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


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


===14:56:49===
2024-10-07 14:56:03>>>cash read=00
2024-10-07 14:56:04>>>cash read=29
2024-10-07 14:56:04 >>>回调事件130,cash_status,20029,退钞中
2024-10-07 14:56:04>>>cash read=2F29
2024-10-07 14:56:06>>>cash read=00
2024-10-07 14:56:06>>>cash read=818F43
2024-10-07 14:56:06>>>cash write=02
2024-10-07 14:56:06 >>>回调事件130,cash_status,10022,进钞中...read money=20
2024-10-07 14:56:07>>>cash read=10
2024-10-07 14:56:07 >>>回调事件130,20,10023,finish Money=20,进钞完成
2024-10-07 14:56:07 当前产品价格10元，投币20元，打印小票中...
2024-10-07 14:56:07 >>>开始打印,排队号为59,订单号为2410071456070027235246
2024-10-07 14:56:07 >>>开始打印,排队号为60,订单号为2410071456070027235246
定时检测未同步订单关闭
2024-10-07 14:56:07>>>订单2410071456070027235246写入成功,剩余空间为1679000,占用RAM为619.2294921875
删除未同步订单2410071456070027235246
2024-10-07 14:56:11>>>订单2410071456070027235246删除成功,剩余空间为1680500,占用RAM为636.169921875
检测订单目录中>>>
无未同步订单>>>
2024-10-07 14:56:11 >>>当前Ram内存为594.5458984375
定时检测未同步订单启用
2024-10-07 14:56:12>>>cash write=0C
2024-10-07 14:56:12>>>cash read=3E


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


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


===15:04:50===
2024-10-07 15:03:55>>>cash read=0A
2024-10-07 15:03:56>>>cash read=3E


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


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


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


===15:14:51===
2024-10-07 15:14:20>>>cash read=29
2024-10-07 15:14:20 >>>回调事件130,cash_status,20029,退钞中
2024-10-07 15:14:21>>>cash read=01
2024-10-07 15:14:23>>>cash read=00
2024-10-07 15:14:24>>>cash read=29
2024-10-07 15:14:24 >>>回调事件130,cash_status,20029,退钞中
2024-10-07 15:14:25>>>cash read=2F29
2024-10-07 15:14:26>>>cash read=3E
2024-10-07 15:14:28>>>cash read=00
2024-10-07 15:14:28>>>cash read=2F29
2024-10-07 15:14:30>>>cash read=3E
2024-10-07 15:14:34>>>cash read=00
2024-10-07 15:14:34>>>cash read=818F42
2024-10-07 15:14:34>>>cash write=02
2024-10-07 15:14:34 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-07 15:14:35>>>cash read=10
2024-10-07 15:14:35 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-07 15:14:35 当前产品价格10元，投币10元，打印小票中...
2024-10-07 15:14:35 >>>开始打印,排队号为64,订单号为2410071514350027235761
2024-10-07 15:14:35>>>订单2410071514350027235761写入成功,剩余空间为1679500,占用RAM为611.23046875
删除未同步订单2410071514350027235761
2024-10-07 15:14:37>>>订单2410071514350027235761删除成功,剩余空间为1680000,占用RAM为621.9501953125
检测订单目录中>>>
无未同步订单>>>
2024-10-07 15:14:37 >>>当前Ram内存为591.830078125
定时检测未同步订单启用
2024-10-07 15:14:38>>>cash write=0C
2024-10-07 15:14:38>>>cash read=3E


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


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


===15:22:52===
2024-10-07 15:22:28>>>cash read=00
2024-10-07 15:22:29>>>cash read=818F42
2024-10-07 15:22:29>>>cash write=02
2024-10-07 15:22:29 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-07 15:22:29>>>cash read=10
2024-10-07 15:22:29 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-07 15:22:29 当前产品价格10元，投币10元，打印小票中...
2024-10-07 15:22:29 >>>开始打印,排队号为66,订单号为2410071522290027235724
2024-10-07 15:22:30>>>订单2410071522290027235724写入成功,剩余空间为1680000,占用RAM为608.8916015625
删除未同步订单2410071522290027235724
2024-10-07 15:22:32>>>订单2410071522290027235724删除成功,剩余空间为1680500,占用RAM为624.3955078125
检测订单目录中>>>
无未同步订单>>>
2024-10-07 15:22:32 >>>当前Ram内存为593.5234375
定时检测未同步订单启用
2024-10-07 15:22:33>>>cash write=0C
2024-10-07 15:22:33>>>cash read=3E


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


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


===15:30:53===
2024-10-07 15:30:49 >>>回调事件[910,devices/S2723]
2024-10-07 15:30:49 >>>故障排除日志:上一MQTT订单号缓存列表为24100715293496457167
2024-10-07 15:30:49 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 15:30:50 开始打印,排队:68,票券:2410071530420710903801,订单:24100715304207105262,[2024-10-07 15:30:49微信支付10元]


===15:31:53===
2024-10-07 15:30:52 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410071530420710903801","queue_number":68,"trade_uid":"24100715304207105262"}]}
2024-10-07 15:30:52 >>>故障排除日志:删除未同步下发订单成功24100715304207105262
2024-10-07 15:30:52 >>>故障排除日志:终端同步成功后剩余订单列表


===15:34:54===
2024-10-07 15:34:37>>>cash read=00
2024-10-07 15:34:38>>>cash read=29
2024-10-07 15:34:38 >>>回调事件130,cash_status,20029,退钞中
2024-10-07 15:34:39>>>cash read=01
2024-10-07 15:34:40>>>cash read=3E
2024-10-07 15:34:50>>>cash read=00
2024-10-07 15:34:50>>>cash read=818F42
2024-10-07 15:34:50>>>cash write=02
2024-10-07 15:34:50 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-07 15:34:51>>>cash read=10
2024-10-07 15:34:51 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-07 15:34:51 当前产品价格10元，投币10元，打印小票中...
2024-10-07 15:34:51 >>>开始打印,排队号为69,订单号为2410071534510027235864
2024-10-07 15:34:51>>>订单2410071534510027235864写入成功,剩余空间为1679500,占用RAM为611.8486328125


===15:35:55===
删除未同步订单2410071534510027235864
2024-10-07 15:34:53>>>订单2410071534510027235864删除成功,剩余空间为1681500,占用RAM为626.384765625
检测订单目录中>>>
无未同步订单>>>
2024-10-07 15:34:53 >>>当前Ram内存为592.810546875
定时检测未同步订单启用
2024-10-07 15:34:54>>>cash write=0C
2024-10-07 15:34:54>>>cash read=3E
定时检测未同步订单关闭
检测订单目录中>>>
无未同步订单>>>


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


===15:37:55===
2024-10-07 15:37:02 >>>回调事件[910,devices/S2723]
2024-10-07 15:37:02 >>>故障排除日志:上一MQTT订单号缓存列表为24100715304207105262
2024-10-07 15:37:02 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 15:37:02 开始打印,排队:71,票券:2410071536563442258901,订单:24100715365634418875,[2024-10-07 15:37:02微信支付10元]
2024-10-07 15:37:04 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410071536563442258901","queue_number":71,"trade_uid":"24100715365634418875"}]}
2024-10-07 15:37:04 >>>故障排除日志:删除未同步下发订单成功24100715365634418875
2024-10-07 15:37:04 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单关闭
检测订单目录中>>>
无未同步订单>>>
2024-10-07 15:37:40 >>>回调事件[910,devices/S2723]
2024-10-07 15:37:40 >>>故障排除日志:上一MQTT订单号缓存列表为24100715365634418875
2024-10-07 15:37:40 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 15:37:40 开始打印,排队:72,票券:2410071537342041736701,订单:24100715373420412342,[2024-10-07 15:37:40微信支付10元]
2024-10-07 15:37:42 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410071537342041736701","queue_number":72,"trade_uid":"24100715373420412342"}]}
2024-10-07 15:37:42 >>>故障排除日志:删除未同步下发订单成功24100715373420412342
2024-10-07 15:37:42 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


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


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


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


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


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


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


===16:30:58===
2024-10-07 16:30:29>>>cash read=00
2024-10-07 16:30:30>>>cash read=818F42
2024-10-07 16:30:30>>>cash write=02
2024-10-07 16:30:30 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-07 16:30:31>>>cash read=10
2024-10-07 16:30:31 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-07 16:30:31 当前产品价格10元，投币10元，打印小票中...
2024-10-07 16:30:31 >>>开始打印,排队号为81,订单号为2410071630310027231528
2024-10-07 16:30:31>>>订单2410071630310027231528写入成功,剩余空间为1680000,占用RAM为608.7236328125
删除未同步订单2410071630310027231528
2024-10-07 16:30:33>>>订单2410071630310027231528删除成功,剩余空间为1680500,占用RAM为622.720703125
检测订单目录中>>>
无未同步订单>>>
2024-10-07 16:30:33 >>>当前Ram内存为593.3701171875
定时检测未同步订单启用
2024-10-07 16:30:34>>>cash write=0C
2024-10-07 16:30:34>>>cash read=3E


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


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


===16:34:59===
定时检测未同步订单关闭
检测订单目录中>>>
无未同步订单>>>
2024-10-07 16:34:56>>>cash read=00
2024-10-07 16:34:57>>>cash read=01


===16:35:59===
2024-10-07 16:35:01>>>cash read=29
2024-10-07 16:35:01 >>>回调事件130,cash_status,20029,退钞中
2024-10-07 16:35:02>>>cash read=3E
2024-10-07 16:35:04>>>cash read=00
2024-10-07 16:35:04>>>cash read=818F42
2024-10-07 16:35:04>>>cash write=02
2024-10-07 16:35:04 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-07 16:35:05>>>cash read=10
2024-10-07 16:35:05 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-07 16:35:05 当前产品价格10元，投币10元，打印小票中...
2024-10-07 16:35:05 >>>开始打印,排队号为83,订单号为2410071635050027237769
2024-10-07 16:35:05>>>订单2410071635050027237769写入成功,剩余空间为1679500,占用RAM为611.4833984375
删除未同步订单2410071635050027237769
2024-10-07 16:35:07>>>订单2410071635050027237769删除成功,剩余空间为1680500,占用RAM为623.130859375
检测订单目录中>>>
无未同步订单>>>
2024-10-07 16:35:07 >>>当前Ram内存为593.541015625
定时检测未同步订单启用
2024-10-07 16:35:08>>>cash write=0C
2024-10-07 16:35:08>>>cash read=3E
2024-10-07 16:35:21>>>cash read=00
2024-10-07 16:35:21>>>cash read=818F42
2024-10-07 16:35:21>>>cash write=02
2024-10-07 16:35:21 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-07 16:35:22>>>cash read=10
2024-10-07 16:35:22 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-07 16:35:22 当前产品价格10元，投币10元，打印小票中...
2024-10-07 16:35:22 >>>开始打印,排队号为84,订单号为2410071635220027238157
定时检测未同步订单关闭
2024-10-07 16:35:22>>>订单2410071635220027238157写入成功,剩余空间为1678500,占用RAM为616.130859375
删除未同步订单2410071635220027238157
2024-10-07 16:35:24>>>订单2410071635220027238157删除成功,剩余空间为1679500,占用RAM为624.958984375
检测订单目录中>>>
无未同步订单>>>
2024-10-07 16:35:24 >>>当前Ram内存为593.9462890625
定时检测未同步订单启用
2024-10-07 16:35:25>>>cash write=0C
2024-10-07 16:35:25>>>cash read=3E


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


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


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


===16:47:00===
2024-10-07 16:46:51>>>cash read=29
2024-10-07 16:46:51 >>>回调事件130,cash_status,20029,退钞中
2024-10-07 16:46:51>>>cash read=2F29
2024-10-07 16:46:53>>>cash read=3E
2024-10-07 16:46:59>>>cash read=00


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


===16:49:01===
定时检测未同步订单关闭
检测订单目录中>>>
无未同步订单>>>
2024-10-07 16:48:22 >>>回调事件[910,devices/S2723]
2024-10-07 16:48:22 >>>故障排除日志:上一MQTT订单号缓存列表为24100716400057874178
2024-10-07 16:48:22 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 16:48:22 开始打印,排队:88,票券:2410071648146562969401,订单:24100716481465625859,[2024-10-07 16:48:21微信支付10元]
2024-10-07 16:48:24 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410071648146562969401","queue_number":88,"trade_uid":"24100716481465625859"}]}
2024-10-07 16:48:24 >>>故障排除日志:删除未同步下发订单成功24100716481465625859
2024-10-07 16:48:24 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


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


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


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


===17:10:03===
2024-10-07 17:10:00>>>cash read=00
2024-10-07 17:10:01>>>cash read=818F41
2024-10-07 17:10:01>>>cash write=02
2024-10-07 17:10:01 >>>回调事件130,cash_status,10022,进钞中...read money=5


===17:11:04===
2024-10-07 17:10:02>>>cash write=0C
2024-10-07 17:10:02>>>cash read=0010
2024-10-07 17:10:02 >>>回调事件130,5,10023,finish Money=5,进钞完成
2024-10-07 17:10:04>>>cash read=818F41
2024-10-07 17:10:04>>>cash write=02
2024-10-07 17:10:04 >>>回调事件130,cash_status,10022,进钞中...read money=5
2024-10-07 17:10:04>>>cash read=10
2024-10-07 17:10:04 >>>回调事件130,5,10023,finish Money=5,进钞完成
2024-10-07 17:10:04 当前产品价格10元，投币10元，打印小票中...
2024-10-07 17:10:04 >>>开始打印,排队号为95,订单号为2410071710020027234545
2024-10-07 17:10:04>>>订单2410071710020027234545写入成功,剩余空间为1679500,占用RAM为608.505859375
2024-10-07 17:10:06>>>cash read=818F42
2024-10-07 17:10:06 >>>回调事件130,cash_status,10022,进钞中...read money=10
删除未同步订单2410071710020027234545
2024-10-07 17:10:07>>>订单2410071710020027234545删除成功,剩余空间为1680500,占用RAM为610.2705078125
检测订单目录中>>>
无未同步订单>>>
2024-10-07 17:10:07 >>>当前Ram内存为592.8525390625
定时检测未同步订单启用
2024-10-07 17:10:07>>>cash read=10
2024-10-07 17:10:07 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-07 17:10:07 当前产品价格10元，投币10元，打印小票中...
2024-10-07 17:10:07 >>>开始打印,排队号为96,订单号为2410071710070027234495
定时检测未同步订单关闭
2024-10-07 17:10:07>>>订单2410071710070027234495写入成功,剩余空间为1679000,占用RAM为614.78125
删除未同步订单2410071710070027234495
2024-10-07 17:10:09>>>订单2410071710070027234495删除成功,剩余空间为1679500,占用RAM为626.720703125
检测订单目录中>>>
无未同步订单>>>
2024-10-07 17:10:09 >>>当前Ram内存为594.541015625
定时检测未同步订单启用
2024-10-07 17:10:10>>>cash write=0C
2024-10-07 17:10:10>>>cash read=3E
2024-10-07 17:10:54>>>cash read=00
2024-10-07 17:10:55>>>cash read=2F29
2024-10-07 17:10:56>>>cash read=3E
2024-10-07 17:10:59>>>cash read=29
2024-10-07 17:10:59 >>>回调事件130,cash_status,20029,退钞中
2024-10-07 17:11:00>>>cash read=01
2024-10-07 17:11:01>>>cash read=3E


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


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


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


===17:19:05===
2024-10-07 17:18:40 >>>回调事件[910,devices/S2723]
2024-10-07 17:18:40 >>>故障排除日志:上一MQTT订单号缓存列表为24100717174853960885
2024-10-07 17:18:40 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 17:18:40 开始打印,排队:99,票券:2410071718329503768501,订单:24100717183295034125,[2024-10-07 17:18:38微信支付10元]
2024-10-07 17:18:42 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410071718329503768501","queue_number":99,"trade_uid":"24100717183295034125"}]}
2024-10-07 17:18:42 >>>故障排除日志:删除未同步下发订单成功24100717183295034125
2024-10-07 17:18:42 >>>故障排除日志:终端同步成功后剩余订单列表


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


===17:33:05===
2024-10-07 17:32:18>>>cash read=00
2024-10-07 17:32:19>>>cash read=29
2024-10-07 17:32:19 >>>回调事件130,cash_status,20029,退钞中
2024-10-07 17:32:19>>>cash read=2F29
2024-10-07 17:32:21>>>cash read=01
2024-10-07 17:32:24>>>cash read=2F
2024-10-07 17:32:26>>>cash read=00
2024-10-07 17:32:27>>>cash read=2F29
2024-10-07 17:32:28>>>cash read=01
2024-10-07 17:32:30>>>cash read=2F
2024-10-07 17:32:31>>>cash read=00
2024-10-07 17:32:32>>>cash read=2F29
2024-10-07 17:32:34>>>cash read=00
2024-10-07 17:32:35>>>cash read=818F43
2024-10-07 17:32:35>>>cash write=02
2024-10-07 17:32:35 >>>回调事件130,cash_status,10022,进钞中...read money=20
2024-10-07 17:32:35>>>cash read=10
2024-10-07 17:32:35 >>>回调事件130,20,10023,finish Money=20,进钞完成
2024-10-07 17:32:35 当前产品价格10元，投币20元，打印小票中...
2024-10-07 17:32:35 >>>开始打印,排队号为101,订单号为2410071732350027238102
2024-10-07 17:32:36 >>>开始打印,排队号为102,订单号为2410071732350027238102
2024-10-07 17:32:36>>>订单2410071732350027238102写入成功,剩余空间为1678500,占用RAM为620.087890625
删除未同步订单2410071732350027238102
2024-10-07 17:32:40>>>订单2410071732350027238102删除成功,剩余空间为1680000,占用RAM为636.384765625
检测订单目录中>>>
无未同步订单>>>
2024-10-07 17:32:40 >>>当前Ram内存为594.4921875
定时检测未同步订单启用
2024-10-07 17:32:41>>>cash write=0C
2024-10-07 17:32:41>>>cash read=3E


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


===17:40:06===
2024-10-07 17:39:27>>>cash read=00
2024-10-07 17:39:28>>>cash read=2F29
2024-10-07 17:39:29>>>cash read=3E
2024-10-07 17:39:31>>>cash read=00
2024-10-07 17:39:31>>>cash read=818F42
2024-10-07 17:39:31>>>cash write=02
2024-10-07 17:39:31 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-07 17:39:32>>>cash read=10
2024-10-07 17:39:32 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-07 17:39:32 当前产品价格10元，投币10元，打印小票中...
2024-10-07 17:39:32 >>>开始打印,排队号为103,订单号为2410071739320027239642
2024-10-07 17:39:32>>>订单2410071739320027239642写入成功,剩余空间为1679500,占用RAM为611.2626953125
删除未同步订单2410071739320027239642
2024-10-07 17:39:34>>>订单2410071739320027239642删除成功,剩余空间为1680500,占用RAM为622.12109375
检测订单目录中>>>
无未同步订单>>>
2024-10-07 17:39:34 >>>当前Ram内存为592.8876953125
定时检测未同步订单启用
2024-10-07 17:39:35>>>cash write=0C
2024-10-07 17:39:35>>>cash read=3E


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


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


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


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


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


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


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


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


===18:12:08===
2024-10-07 18:11:24>>>cash read=00
2024-10-07 18:11:24>>>cash read=818F42
2024-10-07 18:11:24>>>cash write=02
2024-10-07 18:11:24 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-07 18:11:25>>>cash read=10
2024-10-07 18:11:25 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-07 18:11:25 当前产品价格10元，投币10元，打印小票中...
2024-10-07 18:11:25 >>>开始打印,排队号为110,订单号为2410071811250027231461
2024-10-07 18:11:25>>>订单2410071811250027231461写入成功,剩余空间为1680000,占用RAM为610.4052734375
删除未同步订单2410071811250027231461
2024-10-07 18:11:27>>>订单2410071811250027231461删除成功,剩余空间为1680500,占用RAM为624.2333984375
检测订单目录中>>>
无未同步订单>>>
2024-10-07 18:11:27 >>>当前Ram内存为593.171875
定时检测未同步订单启用
2024-10-07 18:11:28>>>cash read=818F42
2024-10-07 18:11:28 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-07 18:11:28>>>cash read=10
2024-10-07 18:11:28 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-07 18:11:28 当前产品价格10元，投币10元，打印小票中...
2024-10-07 18:11:29 >>>开始打印,排�
===18:12:14===
2024-10-07 18:11:24>>>cash read=00
2024-10-07 18:11:24>>>cash read=818F42
2024-10-07 18:11:24>>>cash write=02
2024-10-07 18:11:24 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-07 18:11:25>>>cash read=10
2024-10-07 18:11:25 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-07 18:11:25 当前产品价格10元，投币10元，打印小票中...
2024-10-07 18:11:25 >>>开始打印,排队号为110,订单号为2410071811250027231461
2024-10-07 18:11:25>>>订单2410071811250027231461写入成功,剩余空间为1680000,占用RAM为610.4052734375
删除未同步订单2410071811250027231461
2024-10-07 18:11:27>>>订单2410071811250027231461删除成功,剩余空间为1680500,占用RAM为624.2333984375
检测订单目录中>>>
无未同步订单>>>
2024-10-07 18:11:27 >>>当前Ram内存为593.171875
定时检测未同步订单启用
2024-10-07 18:11:28>>>cash read=818F42
2024-10-07 18:11:28 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-07 18:11:28>>>cash read=10
2024-10-07 18:11:28 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-07 18:11:28 当前产品价格10元，投币10元，打印小票中...
2024-10-07 18:11:29 >>>开始打印,排队号为111,订单号为2410071811290027238620
定时检测未同步订单关闭
2024-10-07 18:11:29>>>订单2410071811290027238620写入成功,剩余空间为1679000,占用RAM为617.0302734375
删除未同步订单2410071811290027238620
2024-10-07 18:11:31>>>订单2410071811290027238620删除成功,剩余空间为1680000,占用RAM为625.203125
检测订单目录中>>>
无未同步订单>>>
2024-10-07 18:11:31 >>>当前Ram内存为594.4833984375
定时检测未同步订单启用
2024-10-07 18:11:32>>>cash read=818F42
2024-10-07 18:11:32 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-07 18:11:32>>>cash read=10
2024-10-07 18:11:32 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-07 18:11:32 当前产品价格10元，投币10元，打印小票中...
2024-10-07 18:11:32 >>>开始打印,排队号为112,订单号为2410071811320027237970
定时检测未同步订单关闭
2024-10-07 18:11:32>>>订单2410071811320027237970写入成功,剩余空间为1678000,占用RAM为622.794921875
删除未同步订单2410071811320027237970
2024-10-07 18:11:35>>>订单2410071811320027237970删除成功,剩余空间为1679000,占用RAM为627.7470703125
检测订单目录中>>>
无未同步订单>>>
2024-10-07 18:11:35 >>>当前Ram内存为595.525390625
定时检测未同步订单启用
2024-10-07 18:11:36>>>cash write=0C
2024-10-07 18:11:36>>>cash read=3E
2024-10-07 18:11:49>>>cash read=00
2024-10-07 18:11:50>>>cash read=818F42
2024-10-07 18:11:50>>>cash write=02
2024-10-07 18:11:50 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-07 18:11:51>>>cash read=10
2024-10-07 18:11:51 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-07 18:11:51 当前产品价格10元，投币10元，打印小票中...
2024-10-07 18:11:51 >>>开始打印,排队号为113,订单号为2410071811510027231436
定时检测未同步订单关闭
2024-10-07 18:11:51>>>订单2410071811510027231436写入成功,剩余空间为1677000,占用RAM为627.4306640625
删除未同步订单2410071811510027231436
2024-10-07 18:11:53>>>订单2410071811510027231436删除成功,剩余空间为1678000,占用RAM为630.7099609375
检测订单目录中>>>
无未同步订单>>>
2024-10-07 18:11:53 >>>当前Ram内存为596.734375
定时检测未同步订单启用
2024-10-07 18:11:54>>>cash write=0C
2024-10-07 18:11:54>>>cash read=3E


TCP://log.tl-self.com:9807@07_18:12:08:send fail
TCP://log.tl-self.com:9807 closed@07_18:12:08
===18:13:15===
定时检测未同步订单关闭
检测订单目录中>>>
无未同步订单>>>


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


===18:18:15===
2024-10-07 18:17:28 >>>剩余flash空间=1682000,占用RAM为634.0751953125
2024-10-07 18:17:28 >>>回调事件:901,netChange,1,4G LTE网络

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


===18:20:15===
2024-10-07 18:19:46 >>>回调事件[910,devices/S2723]
2024-10-07 18:19:46 >>>故障排除日志:上一MQTT订单号缓存列表为24100718180158761765
2024-10-07 18:19:46 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 18:19:46 开始打印,排队:116,票券:2410071819398827637901,订单:24100718193988270384,[2024-10-07 18:19:45支付宝支付10元]
2024-10-07 18:19:48 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410071819398827637901","queue_number":116,"trade_uid":"24100718193988270384"}]}
2024-10-07 18:19:48 >>>故障排除日志:删除未同步下发订单成功24100718193988270384
2024-10-07 18:19:48 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-07 18:20:07 >>>回调事件[910,devices/S2723]
2024-10-07 18:20:07 >>>故障排除日志:上一MQTT订单号缓存列表为24100718193988270384
2024-10-07 18:20:07 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 18:20:07 开始打印,排队:117,票券:2410071820012297575901,订单:24100718200122970069,[2024-10-07 18:20:07微信支付10元]
2024-10-07 18:20:09 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410071820012297575901","queue_number":117,"trade_uid":"24100718200122970069"}]}
2024-10-07 18:20:09 >>>故障排除日志:删除未同步下发订单成功24100718200122970069
2024-10-07 18:20:09 >>>故障排除日志:终端同步成功后剩余订单列表


===18:21:16===
2024-10-07 18:20:32 >>>回调事件[910,devices/S2723]
2024-10-07 18:20:32 >>>故障排除日志:上一MQTT订单号缓存列表为24100718200122970069
2024-10-07 18:20:32 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 18:20:32 开始打印,排队:118,票券:2410071820194117202101,订单:24100718201941167424,[2024-10-07 18:20:29微信支付10元]
2024-10-07 18:20:34 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410071820194117202101","queue_number":118,"trade_uid":"24100718201941167424"}]}
2024-10-07 18:20:34 >>>故障排除日志:删除未同步下发订单成功24100718201941167424
2024-10-07 18:20:34 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-07 18:20:54>>>cash read=00
2024-10-07 18:20:54>>>cash read=818F42
2024-10-07 18:20:54>>>cash write=02
2024-10-07 18:20:54 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-07 18:20:54>>>cash read=10
2024-10-07 18:20:54 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-07 18:20:55 当前产品价格10元，投币10元，打印小票中...
2024-10-07 18:20:55 >>>开始打印,排队号为119,订单号为2410071820550027231601
2024-10-07 18:20:55>>>订单2410071820550027231601写入成功,剩余空间为1679000,占用RAM为613.9541015625
删除未同步订单2410071820550027231601
2024-10-07 18:20:57>>>订单2410071820550027231601删除成功,剩余空间为1680000,占用RAM为625.654296875
检测订单目录中>>>
无未同步订单>>>
2024-10-07 18:20:57 >>>当前Ram内存为595.0556640625
定时检测未同步订单启用
2024-10-07 18:20:58>>>cash write=0C
2024-10-07 18:20:58>>>cash read=3E


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


===18:23:17===
2024-10-07 18:22:18 >>>回调事件[910,devices/S2723]
2024-10-07 18:22:18 >>>故障排除日志:上一MQTT订单号缓存列表为24100718201941167424
2024-10-07 18:22:18 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 18:22:18 开始打印,排队:120,票券:2410071822123322202401,订单:24100718221233218343,[2024-10-07 18:22:18微信支付10元]
2024-10-07 18:22:20 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410071822123322202401","queue_number":120,"trade_uid":"24100718221233218343"}]}
2024-10-07 18:22:20 >>>故障排除日志:删除未同步下发订单成功24100718221233218343
2024-10-07 18:22:20 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-07 18:22:44 >>>回调事件[910,devices/S2723]
2024-10-07 18:22:44 >>>故障排除日志:上一MQTT订单号缓存列表为24100718221233218343
2024-10-07 18:22:44 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 18:22:44 开始打印,排队:121,票券:2410071822366325886201,订单:24100718223663251856,[2024-10-07 18:22:44微信支付10元]
2024-10-07 18:22:46 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410071822366325886201","queue_number":121,"trade_uid":"24100718223663251856"}]}
2024-10-07 18:22:46 >>>故障排除日志:删除未同步下发订单成功24100718223663251856
2024-10-07 18:22:46 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


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


===18:45:19===
2024-10-07 18:45:08>>>cash read=00
2024-10-07 18:45:08>>>cash read=818F42
2024-10-07 18:45:08>>>cash write=02
2024-10-07 18:45:08 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-07 18:45:08>>>cash read=10
2024-10-07 18:45:08 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-07 18:45:10>>>cash write=0C
2024-10-07 18:45:10>>>cash read=3E
2024-10-07 18:45:13 >>>开始未足额打印,排队号为126,订单号为2410071845080027233944
2024-10-07 18:45:13 订单投币结束,共投币10元,请取走您的小票
2024-10-07 18:45:14>>>订单2410071845080027233944写入成功,剩余空间为1679500,占用RAM为652.5458984375
删除未同步订单2410071845080027233944
2024-10-07 18:45:16>>>订单2410071845080027233944删除成功,剩余空间为1680500,占用RAM为604.908203125
检测订单目录中>>>
无未同步订单>>>
2024-10-07 18:45:16 >>>当前Ram内存为592.8955078125
定时检测未同步订单启用


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


===18:52:19===
2024-10-07 18:51:28>>>cash read=0A
2024-10-07 18:51:29>>>cash read=3E


===18:53:19===
2024-10-07 18:52:23 >>>回调事件[910,devices/S2723]
2024-10-07 18:52:23 >>>故障排除日志:上一MQTT订单号缓存列表为24100718414460052425
2024-10-07 18:52:23 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 18:52:23 开始打印,排队:127,票券:2410071852162455537501,订单:24100718521624548131,[2024-10-07 18:52:23微信支付10元]
2024-10-07 18:52:25 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410071852162455537501","queue_number":127,"trade_uid":"24100718521624548131"}]}
2024-10-07 18:52:25 >>>故障排除日志:删除未同步下发订单成功24100718521624548131
2024-10-07 18:52:25 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-07 18:52:46 >>>回调事件[910,devices/S2723]
2024-10-07 18:52:46 >>>故障排除日志:上一MQTT订单号缓存列表为24100718521624548131
2024-10-07 18:52:46 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 18:52:46 开始打印,排队:128,票券:2410071852385678846701,订单:24100718523856781767,[2024-10-07 18:52:45微信支付15元]
2024-10-07 18:52:48 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410071852385678846701","queue_number":128,"trade_uid":"24100718523856781767"}]}
2024-10-07 18:52:48 >>>故障排除日志:删除未同步下发订单成功24100718523856781767
2024-10-07 18:52:48 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


===19:12:22===
删除未同步订单2410071911180027236515
2024-10-07 19:11:21>>>订单2410071911180027236515删除成功,剩余空间为1681500,占用RAM为624.3623046875
检测订单目录中>>>
无未同步订单>>>
2024-10-07 19:11:21 >>>当前Ram内存为591.2158203125
定时检测未同步订单启用
2024-10-07 19:11:22>>>cash write=0C
2024-10-07 19:11:22>>>cash read=3E


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


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


===19:28:23===
2024-10-07 19:27:29 >>>回调事件[910,devices/S2723]
2024-10-07 19:27:29 >>>故障排除日志:上一MQTT订单号缓存列表为24100719251119675586
2024-10-07 19:27:29 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 19:27:29 开始打印,排队:134,票券:2410071927240152652401,订单:24100719272401521325,[2024-10-07 19:27:29微信支付10元]
2024-10-07 19:27:31 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410071927240152652401","queue_number":134,"trade_uid":"24100719272401521325"}]}
2024-10-07 19:27:31 >>>故障排除日志:删除未同步下发订单成功24100719272401521325
2024-10-07 19:27:31 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-07 19:27:34 >>>回调事件[910,devices/S2723]
2024-10-07 19:27:34 >>>故障排除日志:上一MQTT订单号缓存列表为24100719272401521325
2024-10-07 19:27:34 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 19:27:34 开始打印,排队:135,票券:2410071927148754385201,订单:24100719271487539964,[2024-10-07 19:27:34支付宝支付10元]
2024-10-07 19:27:36 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410071927148754385201","queue_number":135,"trade_uid":"24100719271487539964"}]}
2024-10-07 19:27:36 >>>故障排除日志:删除未同步下发订单成功24100719271487539964
2024-10-07 19:27:36 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-07 19:27:37 >>>回调事件[910,devices/S2723]
2024-10-07 19:27:37 >>>故障排除日志:上一MQTT订单号缓存列表为24100719271487539964
2024-10-07 19:27:37 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 19:27:37 开始打印,排队:136,票券:2410071927271779884501,订单:24100719272717795218,[2024-10-07 19:27:37微信支付10元]
2024-10-07 19:27:39 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410071927271779884501","queue_number":136,"trade_uid":"24100719272717795218"}]}
2024-10-07 19:27:39 >>>故障排除日志:删除未同步下发订单成功24100719272717795218
2024-10-07 19:27:39 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-07 19:27:53 >>>回调事件[910,devices/S2723]
2024-10-07 19:27:53 >>>故障排除日志:上一MQTT订单号缓存列表为24100719272717795218
2024-10-07 19:27:53 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 19:27:53 开始打印,排队:137,票券:2410071927409184599701,订单:24100719274091841074,[2024-10-07 19:27:50微信支付10元]
2024-10-07 19:27:55 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410071927409184599701","queue_number":137,"trade_uid":"24100719274091841074"}]}
2024-10-07 19:27:55 >>>故障排除日志:删除未同步下发订单成功24100719274091841074
2024-10-07 19:27:55 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


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


===19:46:25===
2024-10-07 19:45:46>>>cash read=29
2024-10-07 19:45:46 >>>回调事件130,cash_status,20029,退钞中
2024-10-07 19:45:46>>>cash read=2F29
2024-10-07 19:45:47>>>cash read=3E
2024-10-07 19:45:53>>>cash read=00
2024-10-07 19:45:53>>>cash read=818F42
2024-10-07 19:45:53>>>cash write=02
2024-10-07 19:45:53 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-07 19:45:54>>>cash read=10
2024-10-07 19:45:54 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-07 19:45:54 当前产品价格10元，投币10元，打印小票中...
2024-10-07 19:45:54 >>>开始打印,排队号为142,订单号为2410071945540027233628
2024-10-07 19:45:54>>>订单2410071945540027233628写入成功,剩余空间为1679500,占用RAM为611.166015625
删除未同步订单2410071945540027233628
2024-10-07 19:45:56>>>订单2410071945540027233628删除成功,剩余空间为1680500,占用RAM为622.3955078125
检测订单目录中>>>
无未同步订单>>>
2024-10-07 19:45:56 >>>当前Ram内存为593.068359375
定时检测未同步订单启用
2024-10-07 19:45:57>>>cash write=0C
2024-10-07 19:45:57>>>cash read=3E


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


===19:49:25===
2024-10-07 19:48:29 >>>回调事件[910,devices/S2723]
2024-10-07 19:48:29 >>>故障排除日志:上一MQTT订单号缓存列表为24100719394432317757
2024-10-07 19:48:29 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 19:48:29 开始打印,排队:143,票券:2410071948226687226801,订单:24100719482266866784,[2024-10-07 19:48:28微信支付10元]
2024-10-07 19:48:31 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410071948226687226801","queue_number":143,"trade_uid":"24100719482266866784"}]}
2024-10-07 19:48:31 >>>故障排除日志:删除未同步下发订单成功24100719482266866784
2024-10-07 19:48:31 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


===20:03:27===
2024-10-07 20:03:24 >>>回调事件[910,devices/S2723]
2024-10-07 20:03:24 >>>故障排除日志:上一MQTT订单号缓存列表为24100719551981173283
2024-10-07 20:03:24 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 20:03:24 开始打印,排队:146,票券:2410072003176425148701,订单:24100720031764243859,[2024-10-07 20:03:23微信支付10元]


===20:07:28===
2024-10-07 20:06:42>>>cash read=00
2024-10-07 20:06:43>>>cash read=818F42
2024-10-07 20:06:43>>>cash write=02
2024-10-07 20:06:43 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-07 20:06:44>>>cash read=10
2024-10-07 20:06:44 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-07 20:06:44 当前产品价格10元，投币10元，打印小票中...
2024-10-07 20:06:44 >>>开始打印,排队号为147,订单号为2410072006440027239026
2024-10-07 20:06:44>>>订单2410072006440027239026写入成功,剩余空间为1680000,占用RAM为610.166015625
删除未同步订单2410072006440027239026
2024-10-07 20:06:46>>>订单2410072006440027239026删除成功,剩余空间为1680500,占用RAM为624.2626953125
检测订单目录中>>>
无未同步订单>>>
2024-10-07 20:06:46 >>>当前Ram内存为592.89453125
定时检测未同步订单启用
2024-10-07 20:06:47>>>cash write=0C
2024-10-07 20:06:47>>>cash read=3E
2024-10-07 20:07:19 >>>回调事件[910,devices/S2723]
2024-10-07 20:07:20 >>>故障排除日志:上一MQTT订单号缓存列表为24100720031764243859
2024-10-07 20:07:20 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 20:07:20 开始打印,排队:148,票券:2410072007117643192501,订单:24100720071176427239,[2024-10-07 20:07:19微信支付10元]
2024-10-07 20:07:21 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410072007117643192501","queue_number":148,"trade_uid":"24100720071176427239"}]}
2024-10-07 20:07:22 >>>故障排除日志:删除未同步下发订单成功24100720071176427239
2024-10-07 20:07:22 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


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


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


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


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


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


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


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


===20:58:31===
2024-10-07 20:58:16>>>cash read=0A
2024-10-07 20:58:17>>>cash read=3E


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


===21:02:31===
2024-10-07 21:02:10>>>cash read=00
2024-10-07 21:02:10>>>cash read=818F41
2024-10-07 21:02:10>>>cash write=02
2024-10-07 21:02:10 >>>回调事件130,cash_status,10022,进钞中...read money=5
2024-10-07 21:02:10>>>cash read=10
2024-10-07 21:02:10 >>>回调事件130,5,10023,finish Money=5,进钞完成
2024-10-07 21:02:10 当前产品价格5元，投币5元，打印小票中...
2024-10-07 21:02:10 >>>开始打印,排队号为158,订单号为2410072102100027233203
2024-10-07 21:02:11>>>订单2410072102100027233203写入成功,剩余空间为1680000,占用RAM为608.8544921875
删除未同步订单2410072102100027233203
2024-10-07 21:02:13>>>订单2410072102100027233203删除成功,剩余空间为1680500,占用RAM为620.4453125
检测订单目录中>>>
无未同步订单>>>
2024-10-07 21:02:13 >>>当前Ram内存为591.1083984375
定时检测未同步订单启用
2024-10-07 21:02:14>>>cash write=0C
2024-10-07 21:02:14>>>cash read=3E


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