TLClient_JSSCOM_LuatOS-Air_V3205_RDA8910_RFTTS_0xe0000,2.5.1,861714058769633,91678894377312,
poweron reason:0

===08:06:29===
上一时间戳为1727396272
隔日重置时间戳true
隔日清空未同步下发列表true
当前排队号为1,音量为6
初始化产品信息:[{"time_limit_date":null,"ticket_category":"0","expiry_date":90,"product_detail":"","time_limit_status":"0","begin_minute":null,"product_uid":"6296517047560546134","use_timer":1,"old_price":"10","end_hour":null,"sale_price":"10","end_minute":null,"begin_hour":null,"sale_status":1,"product_name":"快剪"}]
是否打印二维码设置为1
是否打印紧凑设置为3
session_id:ff00e****925c8
纸币器设置接收纸币范围为36
欢迎使用天羚自助售票系统[2.5.1]
定时检测未同步订单启用
2024-09-28 08:05:29>>>cash write=30
2024-09-28 08:05:29>>>cash write=02
2024-09-28 08:05:29>>>cash write=3E
2024-09-28 08:05:29>>>cash read=808F808F808F808F
系统时间初始化成功，时间为20249288529
2024-09-28 08:05:30>>>cash write=02
2024-09-28 08:05:30 >>>剩余flash空间=1672500,占用RAM为621.5244140625
2024-09-28 08:05:30 >>>回调事件:910,subscribe,10000,连接服务器成功

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

2024-09-28 08:05:33>>>cash write=0C
2024-09-28 08:05:33>>>cash read=3E
流量卡还有124天过期
2024-09-28 08:05:37 >>>当前Ram内存为641.681640625
2024-09-28 08:05:57>>>cash read=00
2024-09-28 08:05:58>>>cash read=818F42
2024-09-28 08:05:58>>>cash write=02
2024-09-28 08:05:58 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-09-28 08:05:59>>>cash read=10
2024-09-28 08:05:59 >>>回调事件130,10,10023,finish Money=10,进钞完成
当日首次设置时间戳true为1727481959
2024-09-28 08:05:59 >>>开始打印,排队号为1,订单号为2409280805590011615481
定时检测未同步订单关闭
2024-09-28 08:05:59>>>订单2409280805590011615481写入成功,剩余空间为1670500,占用RAM为607.802734375
删除未同步订单2409280805590011615481
2024-09-28 08:06:01>>>订单2409280805590011615481删除成功,剩余空间为1671000,占用RAM为617.40625
检测订单目录中>>>
无未同步订单>>>
2024-09-28 08:06:01 >>>当前Ram内存为586.1435546875
定时检测未同步订单启用
2024-09-28 08:06:02>>>cash write=0C
2024-09-28 08:06:02>>>cash read=3E


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


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


===08:09:30===
2024-09-28 08:08:36 >>>回调事件[910,devices/TL1161]
2024-09-28 08:08:36 >>>故障排除日志:上一MQTT订单号缓存列表为24092808074621419332
2024-09-28 08:08:36 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 08:08:36 开始打印,排队:3,票券:2409280808245848648701,订单:24092808082458481575,[2024-09-28 08:08:36微信支付10元]
2024-09-28 08:08:38 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409280808245848648701","queue_number":3,"trade_uid":"24092808082458481575"}]}
2024-09-28 08:08:38 >>>故障排除日志:删除未同步下发订单成功24092808082458481575
2024-09-28 08:08:39 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 08:08:46>>>cash read=00
2024-09-28 08:08:47>>>cash read=29
2024-09-28 08:08:47 >>>回调事件130,cash_status,20029,退钞中
2024-09-28 08:08:47>>>cash read=2F29
2024-09-28 08:08:48>>>cash read=01
2024-09-28 08:08:51>>>cash read=2F
2024-09-28 08:08:52>>>cash read=3E
2024-09-28 08:08:53>>>cash read=00
2024-09-28 08:08:55>>>cash read=2F29
2024-09-28 08:08:57>>>cash read=3E
2024-09-28 08:09:04>>>cash read=00
2024-09-28 08:09:05>>>cash read=818F42
2024-09-28 08:09:05>>>cash write=02
2024-09-28 08:09:05 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-09-28 08:09:05>>>cash read=10
2024-09-28 08:09:05 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-09-28 08:09:05 >>>开始打印,排队号为4,订单号为2409280809050011613068
2024-09-28 08:09:05>>>订单2409280809050011613068写入成功,剩余空间为1670500,占用RAM为607.8701171875
删除未同步订单2409280809050011613068
2024-09-28 08:09:08>>>订单2409280809050011613068删除成功,剩余空间为1671500,占用RAM为618.263671875
检测订单目录中>>>
无未同步订单>>>
2024-09-28 08:09:08 >>>当前Ram内存为589.0888671875
定时检测未同步订单启用
2024-09-28 08:09:09>>>cash write=0C
2024-09-28 08:09:09>>>cash read=3E


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


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


===08:15:31===
2024-09-28 08:14:48 >>>回调事件[910,devices/TL1161]
2024-09-28 08:14:48 >>>故障排除日志:上一MQTT订单号缓存列表为24092808131468555586
2024-09-28 08:14:48 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 08:14:48 开始打印,排队:6,票券:2409280814425469648601,订单:24092808144254691797,[2024-09-28 08:14:48微信支付10元]
2024-09-28 08:14:49 开始打印,排队:7,票券:2409280814425469791402,订单:24092808144254691797,[2024-09-28 08:14:48微信支付10元]
2024-09-28 08:14:52 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409280814425469648601","queue_number":6,"trade_uid":"24092808144254691797"},{"ticket_no":"2409280814425469791402","queue_number":7,"trade_uid":"24092808144254691797"}]}
2024-09-28 08:14:52 >>>故障排除日志:删除未同步下发订单成功24092808144254691797
2024-09-28 08:14:52 >>>故障排除日志:删除未同步下发订单成功24092808144254691797
2024-09-28 08:14:52 >>>故障排除日志:终端同步成功后剩余订单列表


===08:19:31===
2024-09-28 08:18:50 >>>回调事件[910,devices/TL1161]
2024-09-28 08:18:50 >>>故障排除日志:上一MQTT订单号缓存列表为24092808144254691797|24092808144254691797
2024-09-28 08:18:50 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 08:18:50 开始打印,排队:8,票券:2409280818408481379601,订单:24092808184084809484,[2024-09-28 08:18:49微信支付10元]
2024-09-28 08:18:50 开始打印,排队:9,票券:2409280818408481536802,订单:24092808184084809484,[2024-09-28 08:18:49微信支付10元]
2024-09-28 08:18:53 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409280818408481379601","queue_number":8,"trade_uid":"24092808184084809484"},{"ticket_no":"2409280818408481536802","queue_number":9,"trade_uid":"24092808184084809484"}]}
2024-09-28 08:18:53 >>>故障排除日志:删除未同步下发订单成功24092808184084809484
2024-09-28 08:18:53 >>>故障排除日志:删除未同步下发订单成功24092808184084809484
2024-09-28 08:18:53 >>>故障排除日志:终端同步成功后剩余订单列表


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


===08:28:31===
2024-09-28 08:27:44>>>cash read=00
2024-09-28 08:27:44>>>cash read=818F42
2024-09-28 08:27:44>>>cash write=02
2024-09-28 08:27:44 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-09-28 08:27:45>>>cash read=10
2024-09-28 08:27:45 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-09-28 08:27:45 >>>开始打印,排队号为11,订单号为2409280827450011611042
2024-09-28 08:27:45>>>订单2409280827450011611042写入成功,剩余空间为1672500,占用RAM为601.8740234375
删除未同步订单2409280827450011611042
2024-09-28 08:27:47>>>订单2409280827450011611042删除成功,剩余空间为1672500,占用RAM为614.51171875
检测订单目录中>>>
无未同步订单>>>
2024-09-28 08:27:47 >>>当前Ram内存为587.244140625
定时检测未同步订单启用
2024-09-28 08:27:48>>>cash write=0C
2024-09-28 08:27:48>>>cash read=3E


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


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


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


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


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


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


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


===09:05:33===
2024-09-28 09:05:26>>>cash read=00
2024-09-28 09:05:27>>>cash read=818F42
2024-09-28 09:05:27>>>cash write=02
2024-09-28 09:05:27 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-09-28 09:05:27>>>cash read=10
2024-09-28 09:05:27 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-09-28 09:05:27 >>>开始打印,排队号为19,订单号为2409280905270011614828
2024-09-28 09:05:28>>>订单2409280905270011614828写入成功,剩余空间为1672500,占用RAM为601.3837890625
删除未同步订单2409280905270011614828
2024-09-28 09:05:30>>>订单2409280905270011614828删除成功,剩余空间为1672500,占用RAM为614.03515625
检测订单目录中>>>
无未同步订单>>>
2024-09-28 09:05:30 >>>当前Ram内存为586.732421875
定时检测未同步订单启用
2024-09-28 09:05:31>>>cash write=0C
2024-09-28 09:05:31>>>cash read=3E


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


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


===09:11:37===
2024-09-28 09:11:35>>>cash read=29
2024-09-28 09:11:35 >>>回调事件130,cash_status,20029,退钞中


===09:12:37===
2024-09-28 09:11:36>>>cash read=3E
2024-09-28 09:11:42>>>cash read=00
2024-09-28 09:11:42>>>cash read=2F29
2024-09-28 09:11:43>>>cash read=01
2024-09-28 09:11:46>>>cash read=2F
2024-09-28 09:11:47>>>cash read=3E
2024-09-28 09:11:56>>>cash read=29
2024-09-28 09:11:56 >>>回调事件130,cash_status,20029,退钞中
2024-09-28 09:11:57>>>cash read=3E
2024-09-28 09:11:58>>>cash read=00
2024-09-28 09:11:58>>>cash read=818F42
2024-09-28 09:11:58>>>cash write=02
2024-09-28 09:11:58 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-09-28 09:11:59>>>cash read=10
2024-09-28 09:11:59 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-09-28 09:11:59 >>>开始打印,排队号为21,订单号为2409280911590011616680
2024-09-28 09:11:59>>>订单2409280911590011616680写入成功,剩余空间为1671500,占用RAM为602.0810546875
删除未同步订单2409280911590011616680
2024-09-28 09:12:01>>>订单2409280911590011616680删除成功,剩余空间为1672500,占用RAM为615.6044921875
检测订单目录中>>>
无未同步订单>>>
2024-09-28 09:12:01 >>>当前Ram内存为587.71484375
定时检测未同步订单启用
2024-09-28 09:12:02>>>cash write=0C
2024-09-28 09:12:02>>>cash read=3E


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


===09:25:39===
2024-09-28 09:25:36 >>>回调事件[910,devices/TL1161]
2024-09-28 09:25:36 >>>故障排除日志:上一MQTT订单号缓存列表为24092809094465355253
2024-09-28 09:25:36 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 09:25:36 开始打印,排队:22,票券:2409280925267474746501,订单:24092809252674743839,[2024-09-28 09:25:35微信支付10元]


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


===09:37:39===
2024-09-28 09:36:52>>>cash read=9E
2024-09-28 09:36:53>>>cash read=3E


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


===09:50:40===
2024-09-28 09:49:54 >>>回调事件[910,devices/TL1161]
2024-09-28 09:49:54 >>>故障排除日志:上一MQTT订单号缓存列表为24092809445296335623
2024-09-28 09:49:54 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 09:49:54 开始打印,排队:25,票券:2409280949453971792301,订单:24092809494539713897,[2024-09-28 09:49:53支付宝支付10元]
2024-09-28 09:49:54 开始打印,排队:26,票券:2409280949453971947502,订单:24092809494539713897,[2024-09-28 09:49:53支付宝支付10元]
2024-09-28 09:49:58 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409280949453971792301","queue_number":25,"trade_uid":"24092809494539713897"},{"ticket_no":"2409280949453971947502","queue_number":26,"trade_uid":"24092809494539713897"}]}
2024-09-28 09:49:58 >>>故障排除日志:删除未同步下发订单成功24092809494539713897
2024-09-28 09:49:58 >>>故障排除日志:删除未同步下发订单成功24092809494539713897
2024-09-28 09:49:58 >>>故障排除日志:终端同步成功后剩余订单列表


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


===09:57:40===
2024-09-28 09:57:33>>>cash read=00
2024-09-28 09:57:33>>>cash read=818F42
2024-09-28 09:57:33>>>cash write=02
2024-09-28 09:57:33 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-09-28 09:57:34>>>cash read=10
2024-09-28 09:57:34 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-09-28 09:57:34 >>>开始打印,排队号为28,订单号为2409280957340011612169
2024-09-28 09:57:34>>>订单2409280957340011612169写入成功,剩余空间为1672500,占用RAM为601.9306640625
删除未同步订单2409280957340011612169
2024-09-28 09:57:36>>>订单2409280957340011612169删除成功,剩余空间为1672500,占用RAM为614.4560546875
检测订单目录中>>>
无未同步订单>>>
2024-09-28 09:57:36 >>>当前Ram内存为587.298828125
定时检测未同步订单启用
2024-09-28 09:57:37>>>cash write=0C
2024-09-28 09:57:37>>>cash read=3E


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


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


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


===10:15:41===
2024-09-28 10:14:49>>>cash read=9E
2024-09-28 10:14:50>>>cash read=3E


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


===10:39:42===
2024-09-28 10:39:03>>>cash read=00
2024-09-28 10:39:04>>>cash read=818F42
2024-09-28 10:39:04>>>cash write=02
2024-09-28 10:39:04 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-09-28 10:39:05>>>cash read=10
2024-09-28 10:39:05 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-09-28 10:39:05 >>>开始打印,排队号为33,订单号为2409281039050011612232
2024-09-28 10:39:05>>>订单2409281039050011612232写入成功,剩余空间为1672500,占用RAM为601.859375
删除未同步订单2409281039050011612232
2024-09-28 10:39:07>>>订单2409281039050011612232删除成功,剩余空间为1672500,占用RAM为616.3662109375
检测订单目录中>>>
无未同步订单>>>
2024-09-28 10:39:07 >>>当前Ram内存为587.244140625
定时检测未同步订单启用
2024-09-28 10:39:08>>>cash write=0C
2024-09-28 10:39:08>>>cash read=3E


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


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


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


===10:51:43===
2024-09-28 10:51:17>>>cash read=9E
2024-09-28 10:51:18>>>cash read=3E


===11:03:43===
2024-09-28 11:03:30>>>cash read=9E
2024-09-28 11:03:32>>>cash read=3E


===11:06:43===
2024-09-28 11:06:23 >>>回调事件[910,devices/TL1161]
2024-09-28 11:06:23 >>>故障排除日志:上一MQTT订单号缓存列表为24092810473953569421
2024-09-28 11:06:23 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 11:06:23 开始打印,排队:36,票券:2409281106169559218301,订单:24092811061695587346,[2024-09-28 11:06:22支付宝支付10元]
2024-09-28 11:06:23 开始打印,排队:37,票券:2409281106169559400902,订单:24092811061695587346,[2024-09-28 11:06:22支付宝支付10元]
2024-09-28 11:06:23 开始打印,排队:38,票券:2409281106169559491403,订单:24092811061695587346,[2024-09-28 11:06:22支付宝支付10元]
2024-09-28 11:06:28 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281106169559218301","queue_number":36,"trade_uid":"24092811061695587346"},{"ticket_no":"2409281106169559400902","queue_number":37,"trade_uid":"24092811061695587346"},{"ticket_no":"2409281106169559491403","queue_number":38,"trade_uid":"24092811061695587346"}]}
2024-09-28 11:06:28 >>>故障排除日志:删除未同步下发订单成功24092811061695587346
2024-09-28 11:06:28 >>>故障排除日志:删除未同步下发订单成功24092811061695587346
2024-09-28 11:06:29 >>>故障排除日志:删除未同步下发订单成功24092811061695587346
2024-09-28 11:06:29 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


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


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


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


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


===12:12:45===
2024-09-28 12:12:08>>>cash read=9E
2024-09-28 12:12:09>>>cash read=3E


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


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


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


===12:53:46===
2024-09-28 12:52:49>>>cash read=9E
2024-09-28 12:52:50>>>cash read=3E


===13:02:47===
2024-09-28 13:02:35>>>cash read=00
2024-09-28 13:02:36>>>cash read=818F42
2024-09-28 13:02:36>>>cash write=02
2024-09-28 13:02:36 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-09-28 13:02:36>>>cash read=10
2024-09-28 13:02:36 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-09-28 13:02:36 >>>开始打印,排队号为50,订单号为2409281302360011617058
2024-09-28 13:02:37>>>订单2409281302360011617058写入成功,剩余空间为1672500,占用RAM为601.748046875
删除未同步订单2409281302360011617058
2024-09-28 13:02:39>>>订单2409281302360011617058删除成功,剩余空间为1672500,占用RAM为614.6298828125
检测订单目录中>>>
无未同步订单>>>
2024-09-28 13:02:39 >>>当前Ram内存为587.3115234375
定时检测未同步订单启用
2024-09-28 13:02:40>>>cash write=0C
2024-09-28 13:02:40>>>cash read=3E


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


===13:05:47===
2024-09-28 13:05:07>>>cash read=29
2024-09-28 13:05:07 >>>回调事件130,cash_status,20029,退钞中
2024-09-28 13:05:07>>>cash read=2F29
2024-09-28 13:05:08>>>cash read=01
2024-09-28 13:05:12>>>cash read=2F
2024-09-28 13:05:13>>>cash read=00
2024-09-28 13:05:13>>>cash read=818F42
2024-09-28 13:05:13>>>cash write=02
2024-09-28 13:05:13 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-09-28 13:05:13>>>cash read=10
2024-09-28 13:05:13 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-09-28 13:05:13 >>>开始打印,排队号为52,订单号为2409281305130011618748
2024-09-28 13:05:14>>>订单2409281305130011618748写入成功,剩余空间为1671500,占用RAM为602.93359375
删除未同步订单2409281305130011618748
2024-09-28 13:05:16>>>订单2409281305130011618748删除成功,剩余空间为1672500,占用RAM为615.037109375
检测订单目录中>>>
无未同步订单>>>
2024-09-28 13:05:16 >>>当前Ram内存为587.4326171875
定时检测未同步订单启用
2024-09-28 13:05:17>>>cash write=0C
2024-09-28 13:05:17>>>cash read=3E


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


===13:18:48===
2024-09-28 13:18:45 >>>回调事件[910,devices/TL1161]
2024-09-28 13:18:45 >>>故障排除日志:上一MQTT订单号缓存列表为24092813030095197518
2024-09-28 13:18:45 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 13:18:45 开始打印,排队:53,票券:2409281318342026408901,订单:24092813183420259792,[2024-09-28 13:18:44微信支付10元]


===13:22:48===
2024-09-28 13:21:58>>>cash read=9E
2024-09-28 13:21:59>>>cash read=3E


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


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


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


===14:07:49===
2024-09-28 14:07:10>>>cash read=00
2024-09-28 14:07:11>>>cash read=818F42
2024-09-28 14:07:11>>>cash write=02
2024-09-28 14:07:11 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-09-28 14:07:11>>>cash read=10
2024-09-28 14:07:11 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-09-28 14:07:11 >>>开始打印,排队号为57,订单号为2409281407110011613663
2024-09-28 14:07:12>>>订单2409281407110011613663写入成功,剩余空间为1672500,占用RAM为601.62109375
删除未同步订单2409281407110011613663
2024-09-28 14:07:14>>>订单2409281407110011613663删除成功,剩余空间为1672500,占用RAM为615.5498046875
检测订单目录中>>>
无未同步订单>>>
2024-09-28 14:07:14 >>>当前Ram内存为587.037109375
定时检测未同步订单启用
2024-09-28 14:07:15>>>cash write=0C
2024-09-28 14:07:15>>>cash read=3E


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


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


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


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


===15:05:51===
2024-09-28 15:05:17>>>cash read=00
2024-09-28 15:05:17>>>cash read=818F42
2024-09-28 15:05:17>>>cash write=02
2024-09-28 15:05:17 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-09-28 15:05:18>>>cash read=10
2024-09-28 15:05:18 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-09-28 15:05:18 >>>开始打印,排队号为61,订单号为2409281505180011613711
2024-09-28 15:05:18>>>订单2409281505180011613711写入成功,剩余空间为1672500,占用RAM为602.3671875
删除未同步订单2409281505180011613711
2024-09-28 15:05:20>>>订单2409281505180011613711删除成功,剩余空间为1672500,占用RAM为614.849609375
检测订单目录中>>>
无未同步订单>>>
2024-09-28 15:05:20 >>>当前Ram内存为587.5673828125
定时检测未同步订单启用
2024-09-28 15:05:21>>>cash write=0C
2024-09-28 15:05:21>>>cash read=3E


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


===15:14:51===
2024-09-28 15:14:03>>>cash read=00
2024-09-28 15:14:03>>>cash read=818F42
2024-09-28 15:14:03>>>cash write=02
2024-09-28 15:14:03 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-09-28 15:14:04>>>cash read=10
2024-09-28 15:14:04 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-09-28 15:14:04 >>>开始打印,排队号为62,订单号为2409281514040011616627
2024-09-28 15:14:04>>>订单2409281514040011616627写入成功,剩余空间为1672500,占用RAM为600.685546875
删除未同步订单2409281514040011616627
2024-09-28 15:14:06>>>订单2409281514040011616627删除成功,剩余空间为1672500,占用RAM为613.31640625
检测订单目录中>>>
无未同步订单>>>
2024-09-28 15:14:06 >>>当前Ram内存为586.03125
定时检测未同步订单启用
2024-09-28 15:14:07>>>cash write=0C
2024-09-28 15:14:07>>>cash read=3E


===15:15:51===
定时检测未同步订单关闭
检测订单目录中>>>
无未同步订单>>>
2024-09-28 15:15:11>>>cash read=00
2024-09-28 15:15:12>>>cash read=818F42
2024-09-28 15:15:12>>>cash write=02
2024-09-28 15:15:12 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-09-28 15:15:12>>>cash read=10
2024-09-28 15:15:12 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-09-28 15:15:12 >>>开始打印,排队号为63,订单号为2409281515120011613698
2024-09-28 15:15:13>>>订单2409281515120011613698写入成功,剩余空间为1672000,占用RAM为600.5498046875
删除未同步订单2409281515120011613698
2024-09-28 15:15:15>>>订单2409281515120011613698删除成功,剩余空间为1672500,占用RAM为612.955078125
检测订单目录中>>>
无未同步订单>>>
2024-09-28 15:15:15 >>>当前Ram内存为585.5732421875
定时检测未同步订单启用
2024-09-28 15:15:16>>>cash write=0C
2024-09-28 15:15:16>>>cash read=3E


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


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


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


===15:37:52===
2024-09-28 15:37:07>>>cash read=00
2024-09-28 15:37:08>>>cash read=818F42
2024-09-28 15:37:08>>>cash write=02
2024-09-28 15:37:08 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-09-28 15:37:08>>>cash read=10
2024-09-28 15:37:08 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-09-28 15:37:08 >>>开始打印,排队号为66,订单号为2409281537080011618159
2024-09-28 15:37:09>>>订单2409281537080011618159写入成功,剩余空间为1672500,占用RAM为599.994140625
删除未同步订单2409281537080011618159
2024-09-28 15:37:11>>>订单2409281537080011618159删除成功,剩余空间为1672500,占用RAM为612.75
检测订单目录中>>>
无未同步订单>>>
2024-09-28 15:37:11 >>>当前Ram内存为585.421875
定时检测未同步订单启用
2024-09-28 15:37:12>>>cash write=0C
2024-09-28 15:37:12>>>cash read=3E


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


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


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


===15:53:54===
2024-09-28 15:53:51 >>>回调事件[910,devices/TL1161]
2024-09-28 15:53:51 >>>故障排除日志:上一MQTT订单号缓存列表为24092815463847880586
2024-09-28 15:53:51 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 15:53:51 开始打印,排队:69,票券:2409281553434897916301,订单:24092815534348975756,[2024-09-28 15:53:50微信支付10元]


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


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


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


===16:09:55===
2024-09-28 16:09:00>>>cash read=9E
2024-09-28 16:09:01>>>cash read=3E


===16:15:56===
2024-09-28 16:15:27>>>cash read=00
2024-09-28 16:15:29>>>cash read=818F42
2024-09-28 16:15:29>>>cash write=02
2024-09-28 16:15:29 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-09-28 16:15:29>>>cash read=10
2024-09-28 16:15:29 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-09-28 16:15:29 >>>开始打印,排队号为73,订单号为2409281615290011613476
2024-09-28 16:15:29>>>订单2409281615290011613476写入成功,剩余空间为1672500,占用RAM为600.4296875
删除未同步订单2409281615290011613476
2024-09-28 16:15:31>>>订单2409281615290011613476删除成功,剩余空间为1672500,占用RAM为597.0615234375
检测订单目录中>>>
无未同步订单>>>
2024-09-28 16:15:32 >>>当前Ram内存为584.958984375
定时检测未同步订单启用
2024-09-28 16:15:32>>>cash write=0C
2024-09-28 16:15:33>>>cash read=3E


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


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


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


===16:27:57===
2024-09-28 16:26:58 >>>回调事件[910,devices/TL1161]
2024-09-28 16:26:58 >>>故障排除日志:上一MQTT订单号缓存列表为24092816241732959948
2024-09-28 16:26:58 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 16:26:58 开始打印,排队:77,票券:2409281626474839457001,订单:24092816264748390775,[2024-09-28 16:26:57微信支付10元]
2024-09-28 16:27:00 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281626474839457001","queue_number":77,"trade_uid":"24092816264748390775"}]}
2024-09-28 16:27:00 >>>故障排除日志:删除未同步下发订单成功24092816264748390775
2024-09-28 16:27:00 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 16:27:35 >>>回调事件[910,devices/TL1161]
2024-09-28 16:27:35 >>>故障排除日志:上一MQTT订单号缓存列表为24092816264748390775
2024-09-28 16:27:35 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 16:27:35 开始打印,排队:78,票券:2409281627286474733701,订单:24092816272864742830,[2024-09-28 16:27:35微信支付10元]
2024-09-28 16:27:37 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281627286474733701","queue_number":78,"trade_uid":"24092816272864742830"}]}
2024-09-28 16:27:37 >>>故障排除日志:删除未同步下发订单成功24092816272864742830
2024-09-28 16:27:37 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


===16:42:58===
2024-09-28 16:42:56>>>cash read=00


===16:43:58===
2024-09-28 16:42:57>>>cash read=818F42
2024-09-28 16:42:57>>>cash write=02
2024-09-28 16:42:57 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-09-28 16:42:57>>>cash read=10
2024-09-28 16:42:57 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-09-28 16:42:57 >>>开始打印,排队号为82,订单号为2409281642570011617947
2024-09-28 16:42:58>>>订单2409281642570011617947写入成功,剩余空间为1672500,占用RAM为598.6064453125
删除未同步订单2409281642570011617947
2024-09-28 16:43:00>>>订单2409281642570011617947删除成功,剩余空间为1672500,占用RAM为612.8955078125
检测订单目录中>>>
无未同步订单>>>
2024-09-28 16:43:00 >>>当前Ram内存为585.6015625
定时检测未同步订单启用
2024-09-28 16:43:01>>>cash write=0C
2024-09-28 16:43:01>>>cash read=3E


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


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


===16:49:59===
2024-09-28 16:49:32>>>cash read=9E
2024-09-28 16:49:33>>>cash read=3E


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


===16:54:59===
2024-09-28 16:54:23 >>>回调事件[910,devices/TL1161]
2024-09-28 16:54:23 >>>故障排除日志:上一MQTT订单号缓存列表为24092816534121850703
2024-09-28 16:54:23 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 16:54:23 开始打印,排队:85,票券:2409281654154924340901,订单:24092816541549235119,[2024-09-28 16:54:22微信支付10元]
2024-09-28 16:54:25 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281654154924340901","queue_number":85,"trade_uid":"24092816541549235119"}]}
2024-09-28 16:54:25 >>>故障排除日志:删除未同步下发订单成功24092816541549235119
2024-09-28 16:54:25 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 16:54:49 >>>回调事件[910,devices/TL1161]
2024-09-28 16:54:49 >>>故障排除日志:上一MQTT订单号缓存列表为24092816541549235119
2024-09-28 16:54:49 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 16:54:49 开始打印,排队:86,票券:2409281654424179799801,订单:24092816544241793295,[2024-09-28 16:54:49微信支付10元]
2024-09-28 16:54:52 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281654424179799801","queue_number":86,"trade_uid":"24092816544241793295"}]}
2024-09-28 16:54:52 >>>故障排除日志:删除未同步下发订单成功24092816544241793295
2024-09-28 16:54:52 >>>故障排除日志:终端同步成功后剩余订单列表


===16:56:59===
2024-09-28 16:56:24>>>cash read=29
2024-09-28 16:56:24 >>>回调事件130,cash_status,20029,退钞中
2024-09-28 16:56:25>>>cash read=01
2024-09-28 16:56:31>>>cash read=00
2024-09-28 16:56:32>>>cash read=818F42
2024-09-28 16:56:32>>>cash write=02
2024-09-28 16:56:32 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-09-28 16:56:32>>>cash read=10
2024-09-28 16:56:32 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-09-28 16:56:32 >>>开始打印,排队号为87,订单号为2409281656320011615108
2024-09-28 16:56:33>>>订单2409281656320011615108写入成功,剩余空间为1671500,占用RAM为600.8271484375
删除未同步订单2409281656320011615108
2024-09-28 16:56:35>>>订单2409281656320011615108删除成功,剩余空间为1672500,占用RAM为600.7197265625
检测订单目录中>>>
无未同步订单>>>
2024-09-28 16:56:35 >>>当前Ram内存为585.244140625
定时检测未同步订单启用
2024-09-28 16:56:36>>>cash write=0C
2024-09-28 16:56:36>>>cash read=3E


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


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


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


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


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


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


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


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


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


===17:30:02===
2024-09-28 17:29:33 >>>回调事件[910,devices/TL1161]
2024-09-28 17:29:33 >>>故障排除日志:上一MQTT订单号缓存列表为24092817275853833460
2024-09-28 17:29:33 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 17:29:33 开始打印,排队:97,票券:2409281729233926736701,订单:24092817292339262716,[2024-09-28 17:29:33微信支付10元]
2024-09-28 17:29:33 开始打印,排队:98,票券:2409281729233926870402,订单:24092817292339262716,[2024-09-28 17:29:33微信支付10元]
2024-09-28 17:29:37 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281729233926736701","queue_number":97,"trade_uid":"24092817292339262716"},{"ticket_no":"2409281729233926870402","queue_number":98,"trade_uid":"24092817292339262716"}]}
2024-09-28 17:29:37 >>>故障排除日志:删除未同步下发订单成功24092817292339262716
2024-09-28 17:29:37 >>>故障排除日志:删除未同步下发订单成功24092817292339262716
2024-09-28 17:29:37 >>>故障排除日志:终端同步成功后剩余订单列表


===17:31:03===
2024-09-28 17:31:00 >>>回调事件[910,devices/TL1161]
2024-09-28 17:31:00 >>>故障排除日志:上一MQTT订单号缓存列表为24092817292339262716|24092817292339262716
2024-09-28 17:31:00 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 17:31:00 开始打印,排队:99,票券:2409281730542112941801,订单:24092817305421122581,[2024-09-28 17:30:59微信支付10元]


===17:32:03===
2024-09-28 17:31:02 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281730542112941801","queue_number":99,"trade_uid":"24092817305421122581"}]}
2024-09-28 17:31:02 >>>故障排除日志:删除未同步下发订单成功24092817305421122581
2024-09-28 17:31:02 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 17:31:05>>>cash read=29
2024-09-28 17:31:05 >>>回调事件130,cash_status,20029,退钞中
2024-09-28 17:31:06>>>cash read=01
2024-09-28 17:31:09>>>cash read=3E
2024-09-28 17:31:12>>>cash read=00
2024-09-28 17:31:13>>>cash read=29
2024-09-28 17:31:13 >>>回调事件130,cash_status,20029,退钞中
2024-09-28 17:31:13>>>cash read=2F29
2024-09-28 17:31:15>>>cash read=00
2024-09-28 17:31:16>>>cash read=29
2024-09-28 17:31:16 >>>回调事件130,cash_status,20029,退钞中
2024-09-28 17:31:17>>>cash read=2F29
2024-09-28 17:31:18>>>cash read=3E
2024-09-28 17:31:21>>>cash read=00
2024-09-28 17:31:22>>>cash read=818F42
2024-09-28 17:31:22>>>cash write=02
2024-09-28 17:31:22 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-09-28 17:31:23>>>cash read=10
2024-09-28 17:31:23 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-09-28 17:31:23 >>>开始打印,排队号为100,订单号为2409281731230011616165
2024-09-28 17:31:23>>>订单2409281731230011616165写入成功,剩余空间为1671000,占用RAM为604.4775390625
删除未同步订单2409281731230011616165
2024-09-28 17:31:25>>>订单2409281731230011616165删除成功,剩余空间为1671500,占用RAM为615.142578125
检测订单目录中>>>
无未同步订单>>>
2024-09-28 17:31:25 >>>当前Ram内存为586.35546875
定时检测未同步订单启用
2024-09-28 17:31:26>>>cash write=0C
2024-09-28 17:31:26>>>cash read=3E


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


===17:41:17===
上一时间戳为1727481959
当日首次设置时间戳true为1727516416
今日nvm排队号为101
当前排队号为101,音量为6
初始化产品信息:[{"time_limit_date":null,"ticket_category":"0","expiry_date":90,"product_detail":"","time_limit_status":"0","begin_minute":null,"product_uid":"6296517047560546134","use_timer":1,"old_price":"10","end_hour":null,"sale_price":"10","end_minute":null,"begin_hour":null,"sale_status":1,"product_name":"快剪"}]
是否打印二维码设置为1
是否打印紧凑设置为3
session_id:6b588****c1d32
纸币器设置接收纸币范围为36
欢迎使用天羚自助售票系统[2.5.1]
定时检测未同步订单启用
2024-09-28 17:40:17>>>cash write=30
2024-09-28 17:40:17>>>cash write=02
2024-09-28 17:40:17>>>cash write=3E
2024-09-28 17:40:17>>>cash read=808F808F808F808F
系统时间初始化成功，时间为2024928174017
2024-09-28 17:40:18>>>cash write=02
2024-09-28 17:40:18 >>>剩余flash空间=1672500,占用RAM为627.2294921875
2024-09-28 17:40:18 >>>回调事件:910,subscribe,10000,连接服务器成功

请求下发消息结果为0,下发成功
2024-09-28 17:40:19 >>>回调事件[910,devices/TL1161]
2024-09-28 17:40:19 >>>故障排除日志:上一MQTT订单号缓存列表为24092817305421122581
2024-09-28 17:40:19 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 17:40:19 开始打印,排队:101,票券:2409281739307097183101,订单:24092817393070967272,[2024-09-28 17:39:37微信支付10元]
2024-09-28 17:40:21 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281739307097183101","queue_number":101,"trade_uid":"24092817393070967272"}]}
2024-09-28 17:40:21 >>>故障排除日志:删除未同步下发订单成功24092817393070967272
2024-09-28 17:40:21 >>>故障排除日志:终端同步成功后剩余订单列表
流量卡还有124天过期
2024-09-28 17:40:22>>>cash write=0C
2024-09-28 17:40:22>>>cash read=3E
2024-09-28 17:40:25 >>>当前Ram内存为620.98828125


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


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


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


===17:50:18===
2024-09-28 17:49:26>>>cash read=9E
2024-09-28 17:49:27>>>cash read=3E
2024-09-28 17:49:50 >>>回调事件[910,devices/TL1161]
2024-09-28 17:49:50 >>>故障排除日志:上一MQTT订单号缓存列表为24092817482044935267
2024-09-28 17:49:50 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 17:49:50 开始打印,排队:105,票券:2409281749450250353101,订单:24092817494502499731,[2024-09-28 17:49:50支付宝支付10元]
2024-09-28 17:49:52 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281749450250353101","queue_number":105,"trade_uid":"24092817494502499731"}]}
2024-09-28 17:49:52 >>>故障排除日志:删除未同步下发订单成功24092817494502499731
2024-09-28 17:49:52 >>>故障排除日志:终端同步成功后剩余订单列表


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


===18:00:19===
2024-09-28 17:59:48>>>cash read=2F29
2024-09-28 17:59:49>>>cash read=01
2024-09-28 17:59:50>>>cash read=2F
2024-09-28 17:59:51>>>cash read=29
2024-09-28 17:59:51 >>>回调事件130,cash_status,20029,退钞中
2024-09-28 17:59:51>>>cash read=2F29
2024-09-28 17:59:53>>>cash read=00
2024-09-28 17:59:53>>>cash read=818F42
2024-09-28 17:59:53>>>cash write=02
2024-09-28 17:59:53 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-09-28 17:59:54>>>cash read=10
2024-09-28 17:59:54 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-09-28 17:59:54 >>>开始打印,排队号为108,订单号为2409281759540011612827
2024-09-28 17:59:54>>>订单2409281759540011612827写入成功,剩余空间为1671500,占用RAM为603.66796875
删除未同步订单2409281759540011612827
2024-09-28 17:59:56>>>订单2409281759540011612827删除成功,剩余空间为1672500,占用RAM为617.0947265625
检测订单目录中>>>
无未同步订单>>>
2024-09-28 17:59:56 >>>当前Ram内存为589.4794921875
定时检测未同步订单启用
2024-09-28 17:59:57>>>cash write=0C
2024-09-28 17:59:57>>>cash read=3E


===18:01:19===
定时检测未同步订单关闭
检测订单目录中>>>
无未同步订单>>>
2024-09-28 18:01:07 >>>回调事件[910,devices/TL1161]
2024-09-28 18:01:07 >>>故障排除日志:上一MQTT订单号缓存列表为24092817543020515172|24092817543020515172
2024-09-28 18:01:07 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 18:01:07 开始打印,排队:109,票券:2409281800586197287601,订单:24092818005861967629,[2024-09-28 18:01:05微信支付10元]
2024-09-28 18:01:09 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281800586197287601","queue_number":109,"trade_uid":"24092818005861967629"}]}
2024-09-28 18:01:09 >>>故障排除日志:删除未同步下发订单成功24092818005861967629
2024-09-28 18:01:09 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 18:01:14>>>cash read=00
2024-09-28 18:01:15>>>cash read=2F29
2024-09-28 18:01:17>>>cash read=3E


===18:02:19===
2024-09-28 18:01:20>>>cash read=00
2024-09-28 18:01:21>>>cash read=818F42
2024-09-28 18:01:21>>>cash write=02
2024-09-28 18:01:21 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-09-28 18:01:21>>>cash read=10
2024-09-28 18:01:21 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-09-28 18:01:21 >>>开始打印,排队号为110,订单号为2409281801210011613866
2024-09-28 18:01:22>>>订单2409281801210011613866写入成功,剩余空间为1672500,占用RAM为602.61328125
删除未同步订单2409281801210011613866
2024-09-28 18:01:24>>>订单2409281801210011613866删除成功,剩余空间为1672500,占用RAM为616.7236328125
检测订单目录中>>>
无未同步订单>>>
2024-09-28 18:01:24 >>>当前Ram内存为587.8994140625
定时检测未同步订单启用
2024-09-28 18:01:25>>>cash write=0C
2024-09-28 18:01:25>>>cash read=3E


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


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


===18:09:20===
2024-09-28 18:08:26 >>>回调事件[910,devices/TL1161]
2024-09-28 18:08:26 >>>故障排除日志:上一MQTT订单号缓存列表为24092818080204912765
2024-09-28 18:08:26 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 18:08:26 开始打印,排队:112,票券:2409281808176439225101,订单:24092818081764383961,[2024-09-28 18:08:25微信支付10元]
2024-09-28 18:08:28 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281808176439225101","queue_number":112,"trade_uid":"24092818081764383961"}]}
2024-09-28 18:08:28 >>>故障排除日志:删除未同步下发订单成功24092818081764383961
2024-09-28 18:08:28 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 18:09:02 >>>回调事件[910,devices/TL1161]
2024-09-28 18:09:02 >>>故障排除日志:上一MQTT订单号缓存列表为24092818081764383961
2024-09-28 18:09:02 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 18:09:02 开始打印,排队:113,票券:2409281808514663088001,订单:24092818085146626293,[2024-09-28 18:09:01微信支付10元]
2024-09-28 18:09:04 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281808514663088001","queue_number":113,"trade_uid":"24092818085146626293"}]}
2024-09-28 18:09:04 >>>故障排除日志:删除未同步下发订单成功24092818085146626293
2024-09-28 18:09:04 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


===18:14:21===
2024-09-28 18:13:47>>>cash read=29
2024-09-28 18:13:47 >>>回调事件130,cash_status,20029,退钞中
2024-09-28 18:13:48>>>cash read=01
2024-09-28 18:13:50>>>cash read=3E
2024-09-28 18:13:54>>>cash read=00
2024-09-28 18:13:54>>>cash read=818F42
2024-09-28 18:13:54>>>cash write=02
2024-09-28 18:13:54 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-09-28 18:13:55>>>cash read=10
2024-09-28 18:13:55 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-09-28 18:13:55 >>>开始打印,排队号为116,订单号为2409281813550011615984
2024-09-28 18:13:55>>>订单2409281813550011615984写入成功,剩余空间为1671500,占用RAM为603.51953125
删除未同步订单2409281813550011615984
2024-09-28 18:13:57>>>订单2409281813550011615984删除成功,剩余空间为1672500,占用RAM为617.1884765625
检测订单目录中>>>
无未同步订单>>>
2024-09-28 18:13:57 >>>当前Ram内存为588.177734375
定时检测未同步订单启用
2024-09-28 18:13:58>>>cash write=0C
2024-09-28 18:13:58>>>cash read=3E


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


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


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


===18:24:22===
2024-09-28 18:23:44>>>cash read=0A
2024-09-28 18:23:46>>>cash read=3E


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


===18:27:22===
2024-09-28 18:26:21 >>>回调事件[910,devices/TL1161]
2024-09-28 18:26:21 >>>故障排除日志:上一MQTT订单号缓存列表为24092818243755018820
2024-09-28 18:26:21 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 18:26:21 开始打印,排队:120,票券:2409281826159403875801,订单:24092818261594033568,[2024-09-28 18:26:20微信支付10元]
2024-09-28 18:26:21 开始打印,排队:121,票券:2409281826159404072002,订单:24092818261594033568,[2024-09-28 18:26:20微信支付10元]
2024-09-28 18:26:25 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281826159403875801","queue_number":120,"trade_uid":"24092818261594033568"},{"ticket_no":"2409281826159404072002","queue_number":121,"trade_uid":"24092818261594033568"}]}
2024-09-28 18:26:25 >>>故障排除日志:删除未同步下发订单成功24092818261594033568
2024-09-28 18:26:25 >>>故障排除日志:删除未同步下发订单成功24092818261594033568
2024-09-28 18:26:25 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 18:26:35 >>>回调事件[910,devices/TL1161]
2024-09-28 18:26:35 >>>故障排除日志:上一MQTT订单号缓存列表为24092818261594033568|24092818261594033568
2024-09-28 18:26:35 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 18:26:35 开始打印,排队:122,票券:2409281826213594260401,订单:24092818262135937787,[2024-09-28 18:26:35支付宝支付10元]
2024-09-28 18:26:37 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281826213594260401","queue_number":122,"trade_uid":"24092818262135937787"}]}
2024-09-28 18:26:37 >>>故障排除日志:删除未同步下发订单成功24092818262135937787
2024-09-28 18:26:38 >>>故障排除日志:终端同步成功后剩余订单列表


===18:28:23===
2024-09-28 18:27:28 >>>回调事件[910,devices/TL1161]
2024-09-28 18:27:28 >>>故障排除日志:上一MQTT订单号缓存列表为24092818262135937787
2024-09-28 18:27:28 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 18:27:28 开始打印,排队:123,票券:2409281827156804942401,订单:24092818271568044692,[2024-09-28 18:27:27微信支付10元]
2024-09-28 18:27:30 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281827156804942401","queue_number":123,"trade_uid":"24092818271568044692"}]}
2024-09-28 18:27:30 >>>故障排除日志:删除未同步下发订单成功24092818271568044692
2024-09-28 18:27:30 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 18:27:33 >>>回调事件[910,devices/TL1161]
2024-09-28 18:27:33 >>>故障排除日志:上一MQTT订单号缓存列表为24092818271568044692
2024-09-28 18:27:33 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 18:27:33 开始打印,排队:124,票券:2409281827260180447601,订单:24092818272601801196,[2024-09-28 18:27:33微信支付10元]
2024-09-28 18:27:35 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281827260180447601","queue_number":124,"trade_uid":"24092818272601801196"}]}
2024-09-28 18:27:35 >>>故障排除日志:删除未同步下发订单成功24092818272601801196
2024-09-28 18:27:35 >>>故障排除日志:终端同步成功后剩余订单列表


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


===18:36:23===
2024-09-28 18:35:44 >>>回调事件[910,devices/TL1161]
2024-09-28 18:35:44 >>>故障排除日志:上一MQTT订单号缓存列表为24092818282233043201
2024-09-28 18:35:44 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 18:35:44 开始打印,排队:126,票券:2409281835375109942901,订单:24092818353751094814,[2024-09-28 18:35:43微信支付10元]
2024-09-28 18:35:46 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281835375109942901","queue_number":126,"trade_uid":"24092818353751094814"}]}
2024-09-28 18:35:46 >>>故障排除日志:删除未同步下发订单成功24092818353751094814
2024-09-28 18:35:46 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 18:35:49>>>cash read=00
2024-09-28 18:35:50>>>cash read=818F42
2024-09-28 18:35:50>>>cash write=02
2024-09-28 18:35:50 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-09-28 18:35:50>>>cash read=10
2024-09-28 18:35:50 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-09-28 18:35:50 >>>开始打印,排队号为127,订单号为2409281835500011614585
2024-09-28 18:35:51>>>订单2409281835500011614585写入成功,剩余空间为1671000,占用RAM为606.7060546875
删除未同步订单2409281835500011614585
2024-09-28 18:35:53>>>订单2409281835500011614585删除成功,剩余空间为1672000,占用RAM为620.4296875
检测订单目录中>>>
无未同步订单>>>
2024-09-28 18:35:53 >>>当前Ram内存为590.7578125
定时检测未同步订单启用
2024-09-28 18:35:54>>>cash write=0C
2024-09-28 18:35:54>>>cash read=3E
2024-09-28 18:36:22>>>cash read=00


===18:37:23===
2024-09-28 18:36:23>>>cash read=818F42
2024-09-28 18:36:23>>>cash write=02
2024-09-28 18:36:23 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-09-28 18:36:23>>>cash read=10
2024-09-28 18:36:23 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-09-28 18:36:23 >>>开始打印,排队号为128,订单号为2409281836230011619592
定时检测未同步订单关闭
2024-09-28 18:36:24>>>订单2409281836230011619592写入成功,剩余空间为1672500,占用RAM为602.6708984375
删除未同步订单2409281836230011619592
2024-09-28 18:36:26>>>订单2409281836230011619592删除成功,剩余空间为1672500,占用RAM为615.0751953125
检测订单目录中>>>
无未同步订单>>>
2024-09-28 18:36:26 >>>当前Ram内存为587.5859375
定时检测未同步订单启用
2024-09-28 18:36:27>>>cash write=0C
2024-09-28 18:36:27>>>cash read=3E


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


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


===18:44:24===
2024-09-28 18:44:02 >>>回调事件[910,devices/TL1161]
2024-09-28 18:44:02 >>>故障排除日志:上一MQTT订单号缓存列表为24092818422413314152|24092818422413314152
2024-09-28 18:44:02 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 18:44:02 开始打印,排队:131,票券:2409281843546707737901,订单:24092818435467073629,[2024-09-28 18:44:01微信支付10元]
2024-09-28 18:44:04 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281843546707737901","queue_number":131,"trade_uid":"24092818435467073629"}]}
2024-09-28 18:44:04 >>>故障排除日志:删除未同步下发订单成功24092818435467073629
2024-09-28 18:44:04 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 18:44:07>>>cash read=00
2024-09-28 18:44:08>>>cash read=818F43
2024-09-28 18:44:08>>>cash write=02
2024-09-28 18:44:08 >>>回调事件130,cash_status,10022,进钞中...read money=20
2024-09-28 18:44:08>>>cash read=10
2024-09-28 18:44:08 >>>回调事件130,20,10023,finish Money=20,进钞完成
2024-09-28 18:44:08 >>>开始打印,排队号为132,订单号为2409281844080011616320
2024-09-28 18:44:09 >>>开始打印,排队号为133,订单号为2409281844080011616320
2024-09-28 18:44:09>>>订单2409281844080011616320写入成功,剩余空间为1670500,占用RAM为616.0546875
删除未同步订单2409281844080011616320
2024-09-28 18:44:13>>>订单2409281844080011616320删除成功,剩余空间为1672000,占用RAM为639.091796875
检测订单目录中>>>
无未同步订单>>>
2024-09-28 18:44:13 >>>当前Ram内存为590.099609375
定时检测未同步订单启用
2024-09-28 18:44:14>>>cash write=0C
2024-09-28 18:44:14>>>cash read=3E


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


===18:46:25===
2024-09-28 18:45:37>>>cash read=00
2024-09-28 18:45:38>>>cash read=818F42
2024-09-28 18:45:38>>>cash write=02
2024-09-28 18:45:38 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-09-28 18:45:38>>>cash read=10
2024-09-28 18:45:38 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-09-28 18:45:38 >>>开始打印,排队号为134,订单号为2409281845380011613729
2024-09-28 18:45:39>>>订单2409281845380011613729写入成功,剩余空间为1672500,占用RAM为603.060546875
删除未同步订单2409281845380011613729
2024-09-28 18:45:41>>>订单2409281845380011613729删除成功,剩余空间为1672500,占用RAM为615.0439453125
检测订单目录中>>>
无未同步订单>>>
2024-09-28 18:45:41 >>>当前Ram内存为587.7265625
定时检测未同步订单启用
2024-09-28 18:45:42>>>cash write=0C
2024-09-28 18:45:42>>>cash read=3E


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


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


===18:59:25===
2024-09-28 18:59:02>>>cash read=00
2024-09-28 18:59:04>>>cash read=818F43
2024-09-28 18:59:04>>>cash write=02
2024-09-28 18:59:04 >>>回调事件130,cash_status,10022,进钞中...read money=20
2024-09-28 18:59:04>>>cash read=10
2024-09-28 18:59:04 >>>回调事件130,20,10023,finish Money=20,进钞完成
2024-09-28 18:59:04 >>>开始打印,排队号为137,订单号为2409281859040011618801
2024-09-28 18:59:05 >>>开始打印,排队号为138,订单号为2409281859040011618801
2024-09-28 18:59:05>>>订单2409281859040011618801写入成功,剩余空间为1671500,占用RAM为609.498046875
删除未同步订单2409281859040011618801
2024-09-28 18:59:08>>>订单2409281859040011618801删除成功,剩余空间为1672500,占用RAM为626.97265625
检测订单目录中>>>
无未同步订单>>>
2024-09-28 18:59:08 >>>当前Ram内存为589.091796875
定时检测未同步订单启用
2024-09-28 18:59:09>>>cash write=0C
2024-09-28 18:59:09>>>cash read=3E


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


===19:01:26===
2024-09-28 19:00:54>>>cash read=00
2024-09-28 19:00:54>>>cash read=2F29
2024-09-28 19:00:55>>>cash read=01
2024-09-28 19:00:58>>>cash read=2F
2024-09-28 19:00:59>>>cash read=3E
2024-09-28 19:01:03>>>cash read=00
2024-09-28 19:01:04>>>cash read=818F42
2024-09-28 19:01:04>>>cash write=02
2024-09-28 19:01:04 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-09-28 19:01:05>>>cash read=10
2024-09-28 19:01:05 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-09-28 19:01:05 >>>开始打印,排队号为139,订单号为2409281901050011617637
2024-09-28 19:01:05>>>订单2409281901050011617637写入成功,剩余空间为1671500,占用RAM为602.474609375
删除未同步订单2409281901050011617637
2024-09-28 19:01:07>>>订单2409281901050011617637删除成功,剩余空间为1672500,占用RAM为615.611328125
检测订单目录中>>>
无未同步订单>>>
2024-09-28 19:01:07 >>>当前Ram内存为588.11328125
定时检测未同步订单启用
2024-09-28 19:01:08>>>cash write=0C
2024-09-28 19:01:08>>>cash read=3E
2024-09-28 19:01:12 >>>回调事件[910,devices/TL1161]
2024-09-28 19:01:12 >>>故障排除日志:上一MQTT订单号缓存列表为24092818474070976198
2024-09-28 19:01:12 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 19:01:12 开始打印,排队:140,票券:2409281901062605565801,订单:24092819010626050015,[2024-09-28 19:01:12微信支付10元]
2024-09-28 19:01:14 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281901062605565801","queue_number":140,"trade_uid":"24092819010626050015"}]}
2024-09-28 19:01:14 >>>故障排除日志:删除未同步下发订单成功24092819010626050015
2024-09-28 19:01:15 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


===19:12:27===
2024-09-28 19:11:38>>>cash read=9E
2024-09-28 19:11:39>>>cash read=3E


===19:14:27===
2024-09-28 19:14:08>>>cash read=00
2024-09-28 19:14:09>>>cash read=818F42
2024-09-28 19:14:09>>>cash write=02
2024-09-28 19:14:09 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-09-28 19:14:09>>>cash read=10
2024-09-28 19:14:09 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-09-28 19:14:09 >>>开始打印,排队号为145,订单号为2409281914090011619392
2024-09-28 19:14:09>>>订单2409281914090011619392写入成功,剩余空间为1672500,占用RAM为600.3525390625
删除未同步订单2409281914090011619392
2024-09-28 19:14:11>>>订单2409281914090011619392删除成功,剩余空间为1672500,占用RAM为614.52734375
检测订单目录中>>>
无未同步订单>>>
2024-09-28 19:14:11 >>>当前Ram内存为587.2412109375
定时检测未同步订单启用
2024-09-28 19:14:12>>>cash write=0C
2024-09-28 19:14:12>>>cash read=3E
2024-09-28 19:14:15 >>>回调事件[910,devices/TL1161]
2024-09-28 19:14:15 >>>故障排除日志:上一MQTT订单号缓存列表为24092819074382483781
2024-09-28 19:14:15 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 19:14:15 开始打印,排队:146,票券:2409281914091132471601,订单:24092819140911320576,[2024-09-28 19:14:15微信支付10元]
2024-09-28 19:14:17 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281914091132471601","queue_number":146,"trade_uid":"24092819140911320576"}]}
2024-09-28 19:14:17 >>>故障排除日志:删除未同步下发订单成功24092819140911320576
2024-09-28 19:14:17 >>>故障排除日志:终端同步成功后剩余订单列表


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


===19:18:28===
2024-09-28 19:17:36 >>>回调事件[910,devices/TL1161]
2024-09-28 19:17:37 >>>故障排除日志:上一MQTT订单号缓存列表为24092819140911320576
2024-09-28 19:17:37 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 19:17:37 开始打印,排队:147,票券:2409281917286522500901,订单:24092819172865220168,[2024-09-28 19:17:35微信支付10元]
2024-09-28 19:17:38 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281917286522500901","queue_number":147,"trade_uid":"24092819172865220168"}]}
2024-09-28 19:17:39 >>>故障排除日志:删除未同步下发订单成功24092819172865220168
2024-09-28 19:17:39 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 19:18:12 >>>回调事件[910,devices/TL1161]
2024-09-28 19:18:12 >>>故障排除日志:上一MQTT订单号缓存列表为24092819172865220168
2024-09-28 19:18:12 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 19:18:12 开始打印,排队:148,票券:2409281918043975896001,订单:24092819180439755002,[2024-09-28 19:18:11微信支付10元]
2024-09-28 19:18:14 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281918043975896001","queue_number":148,"trade_uid":"24092819180439755002"}]}
2024-09-28 19:18:14 >>>故障排除日志:删除未同步下发订单成功24092819180439755002
2024-09-28 19:18:14 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 19:18:21>>>cash read=00
2024-09-28 19:18:21>>>cash read=818F42
2024-09-28 19:18:21>>>cash write=02
2024-09-28 19:18:21 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-09-28 19:18:22>>>cash read=10
2024-09-28 19:18:22 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-09-28 19:18:22 >>>开始打印,排队号为149,订单号为2409281918220011614210
2024-09-28 19:18:22>>>订单2409281918220011614210写入成功,剩余空间为1670500,占用RAM为609.826171875
删除未同步订单2409281918220011614210
2024-09-28 19:18:24>>>订单2409281918220011614210删除成功,剩余空间为1671000,占用RAM为619.5390625
检测订单目录中>>>
无未同步订单>>>
2024-09-28 19:18:24 >>>当前Ram内存为588.5634765625
定时检测未同步订单启用
2024-09-28 19:18:25>>>cash write=0C
2024-09-28 19:18:25>>>cash read=3E


===19:19:28===
2024-09-28 19:18:27 >>>回调事件[910,devices/TL1161]
2024-09-28 19:18:27 >>>故障排除日志:上一MQTT订单号缓存列表为24092819180439755002
2024-09-28 19:18:27 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 19:18:27 开始打印,排队:150,票券:2409281918187828997401,订单:24092819181878283082,[2024-09-28 19:18:26微信支付10元]
2024-09-28 19:18:29 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281918187828997401","queue_number":150,"trade_uid":"24092819181878283082"}]}
2024-09-28 19:18:29 >>>故障排除日志:删除未同步下发订单成功24092819181878283082
2024-09-28 19:18:29 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 19:18:30>>>cash read=01
2024-09-28 19:18:32>>>cash read=3E
2024-09-28 19:18:35>>>cash read=29
2024-09-28 19:18:35 >>>回调事件130,cash_status,20029,退钞中
2024-09-28 19:18:37>>>cash read=01
2024-09-28 19:18:38>>>cash read=3E
2024-09-28 19:18:46>>>cash read=00
2024-09-28 19:18:47>>>cash read=29
2024-09-28 19:18:47 >>>回调事件130,cash_status,20029,退钞中
2024-09-28 19:18:47>>>cash read=2F29
2024-09-28 19:18:49>>>cash read=3E
2024-09-28 19:18:54>>>cash read=00
2024-09-28 19:18:55>>>cash read=818F42
2024-09-28 19:18:55>>>cash write=02
2024-09-28 19:18:55 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-09-28 19:18:55>>>cash read=10
2024-09-28 19:18:55 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-09-28 19:18:55 >>>开始打印,排队号为151,订单号为2409281918550011619216
定时检测未同步订单关闭
2024-09-28 19:18:55>>>订单2409281918550011619216写入成功,剩余空间为1670500,占用RAM为607.6669921875
删除未同步订单2409281918550011619216
2024-09-28 19:18:58>>>订单2409281918550011619216删除成功,剩余空间为1671500,占用RAM为619.3349609375
检测订单目录中>>>
无未同步订单>>>
2024-09-28 19:18:58 >>>当前Ram内存为588.380859375
定时检测未同步订单启用
2024-09-28 19:18:59>>>cash write=0C
2024-09-28 19:18:59>>>cash read=3E


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


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


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


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


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


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


===19:41:30===
2024-09-28 19:40:33>>>cash read=00
2024-09-28 19:40:33>>>cash read=818F42
2024-09-28 19:40:33>>>cash write=02
2024-09-28 19:40:33 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-09-28 19:40:34>>>cash read=10
2024-09-28 19:40:34 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-09-28 19:40:34 >>>开始打印,排队号为158,订单号为2409281940340011619219
2024-09-28 19:40:34>>>订单2409281940340011619219写入成功,剩余空间为1672500,占用RAM为601.9130859375
删除未同步订单2409281940340011619219
2024-09-28 19:40:36>>>订单2409281940340011619219删除成功,剩余空间为1672500,占用RAM为614.501953125
检测订单目录中>>>
无未同步订单>>>
2024-09-28 19:40:36 >>>当前Ram内存为587.236328125
定时检测未同步订单启用
2024-09-28 19:40:37>>>cash write=0C
2024-09-28 19:40:37>>>cash read=3E


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


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


===19:51:30===
2024-09-28 19:50:54>>>cash read=9E
2024-09-28 19:50:55>>>cash read=3E
2024-09-28 19:51:06 >>>回调事件[910,devices/TL1161]
2024-09-28 19:51:06 >>>故障排除日志:上一MQTT订单号缓存列表为24092819455909892106
2024-09-28 19:51:06 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 19:51:06 开始打印,排队:160,票券:2409281951004053143801,订单:24092819510040522618,[2024-09-28 19:51:06微信支付10元]
2024-09-28 19:51:08 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281951004053143801","queue_number":160,"trade_uid":"24092819510040522618"}]}
2024-09-28 19:51:08 >>>故障排除日志:删除未同步下发订单成功24092819510040522618
2024-09-28 19:51:08 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


===19:59:31===
2024-09-28 19:58:48 >>>回调事件[910,devices/TL1161]
2024-09-28 19:58:48 >>>故障排除日志:上一MQTT订单号缓存列表为24092819555858451534
2024-09-28 19:58:48 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 19:58:48 开始打印,排队:163,票券:2409281958436208726401,订单:24092819584362081136,[2024-09-28 19:58:48微信支付10元]
2024-09-28 19:58:50 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281958436208726401","queue_number":163,"trade_uid":"24092819584362081136"}]}
2024-09-28 19:58:50 >>>故障排除日志:删除未同步下发订单成功24092819584362081136
2024-09-28 19:58:50 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 19:59:19 >>>回调事件[910,devices/TL1161]
2024-09-28 19:59:19 >>>故障排除日志:上一MQTT订单号缓存列表为24092819584362081136
2024-09-28 19:59:19 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 19:59:19 开始打印,排队:164,票券:2409281959120700754801,订单:24092819591207000935,[2024-09-28 19:59:18微信支付10元]
2024-09-28 19:59:21 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281959120700754801","queue_number":164,"trade_uid":"24092819591207000935"}]}
2024-09-28 19:59:21 >>>故障排除日志:删除未同步下发订单成功24092819591207000935
2024-09-28 19:59:21 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


===20:27:33===
2024-09-28 20:27:04>>>cash read=00
2024-09-28 20:27:05>>>cash read=29
2024-09-28 20:27:05 >>>回调事件130,cash_status,20029,退钞中
2024-09-28 20:27:05>>>cash read=2F29
2024-09-28 20:27:07>>>cash read=3E
2024-09-28 20:27:09>>>cash read=00
2024-09-28 20:27:10>>>cash read=2F29
2024-09-28 20:27:12>>>cash read=3E
2024-09-28 20:27:14>>>cash read=00
2024-09-28 20:27:15>>>cash read=29
2024-09-28 20:27:15 >>>回调事件130,cash_status,20029,退钞中
2024-09-28 20:27:16>>>cash read=2F29
2024-09-28 20:27:17>>>cash read=3E
2024-09-28 20:27:28>>>cash read=00
2024-09-28 20:27:29>>>cash read=818F42
2024-09-28 20:27:29>>>cash write=02
2024-09-28 20:27:29 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-09-28 20:27:29>>>cash read=10
2024-09-28 20:27:29 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-09-28 20:27:29 >>>开始打印,排队号为167,订单号为2409282027290011615258
2024-09-28 20:27:30>>>订单2409282027290011615258写入成功,剩余空间为1671500,占用RAM为604.5791015625


===20:28:33===
删除未同步订单2409282027290011615258
2024-09-28 20:27:32>>>订单2409282027290011615258删除成功,剩余空间为1673500,占用RAM为619.384765625
检测订单目录中>>>
无未同步订单>>>
2024-09-28 20:27:32 >>>当前Ram内存为586.8662109375
定时检测未同步订单启用
2024-09-28 20:27:33>>>cash write=0C
2024-09-28 20:27:33>>>cash read=3E
定时检测未同步订单关闭
检测订单目录中>>>
无未同步订单>>>


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


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


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


===20:55:34===
2024-09-28 20:55:14 >>>回调事件[910,devices/TL1161]
2024-09-28 20:55:14 >>>故障排除日志:上一MQTT订单号缓存列表为24092820383775953071
2024-09-28 20:55:14 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 20:55:14 开始打印,排队:171,票券:2409282055025204890801,订单:24092820550252045308,[2024-09-28 20:55:12微信支付10元]
2024-09-28 20:55:14 开始打印,排队:172,票券:2409282055025205031502,订单:24092820550252045308,[2024-09-28 20:55:12微信支付10元]
2024-09-28 20:55:17 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409282055025204890801","queue_number":171,"trade_uid":"24092820550252045308"},{"ticket_no":"2409282055025205031502","queue_number":172,"trade_uid":"24092820550252045308"}]}
2024-09-28 20:55:17 >>>故障排除日志:删除未同步下发订单成功24092820550252045308
2024-09-28 20:55:17 >>>故障排除日志:删除未同步下发订单成功24092820550252045308
2024-09-28 20:55:18 >>>故障排除日志:终端同步成功后剩余订单列表