TLClient_JSSCOM_LuatOS-Air_V4010_RDA8910_RFTTS_0xe0000,2.5.4,861658060959361,41404520831665,
poweron reason:0

===08:15:21===
上一时间戳为1727655054
隔日重置时间戳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":"4351590954437132837","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:8e00b****15bbe
纸币器设置接收纸币范围为36
欢迎使用天羚自助售票系统[2.5.4]
定时检测未同步订单启用
2024-10-01 08:14:21>>>cash write=30
2024-10-01 08:14:21>>>cash write=02
2024-10-01 08:14:21>>>cash write=3E
2024-10-01 08:14:21>>>cash read=808F808F808F808F
系统时间初始化成功，时间为202410181421
2024-10-01 08:14:22>>>cash write=02
2024-10-01 08:14:22 >>>剩余flash空间=1680500,占用RAM为628.677734375
2024-10-01 08:14:22 >>>回调事件:910,subscribe,10000,连接服务器成功

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

2024-10-01 08:14:25>>>cash write=0C
2024-10-01 08:14:25>>>cash read=3E
流量卡还有181天过期
2024-10-01 08:14:29 >>>当前Ram内存为613.0458984375


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


===08:24:22===
2024-10-01 08:23:36 >>>回调事件[910,devices/TL2007]
当日首次设置时间戳true为1727742216
2024-10-01 08:23:36 >>>故障排除日志:上一MQTT订单号缓存列表为24093021393455983427
2024-10-01 08:23:36 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 08:23:36 开始打印,排队:1,票券:2410010823267042749801,订单:24100108232670423216,[2024-10-01 08:23:35微信支付10元]
2024-10-01 08:23:38 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410010823267042749801","queue_number":1,"trade_uid":"24100108232670423216"}]}
2024-10-01 08:23:38 >>>故障排除日志:删除未同步下发订单成功24100108232670423216
2024-10-01 08:23:38 >>>故障排除日志:终端同步成功后剩余订单列表


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


===08:29:23===
2024-10-01 08:28:54 >>>回调事件[910,devices/TL2007]
2024-10-01 08:28:54 >>>故障排除日志:上一MQTT订单号缓存列表为24100108244607764343
2024-10-01 08:28:54 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 08:28:54 开始打印,排队:3,票券:2410010828487045896201,订单:24100108284870454514,[2024-10-01 08:28:54微信支付10元]
2024-10-01 08:28:56 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410010828487045896201","queue_number":3,"trade_uid":"24100108284870454514"}]}
2024-10-01 08:28:56 >>>故障排除日志:删除未同步下发订单成功24100108284870454514
2024-10-01 08:28:56 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-01 08:29:20 >>>回调事件[910,devices/TL2007]
2024-10-01 08:29:20 >>>故障排除日志:上一MQTT订单号缓存列表为24100108284870454514
2024-10-01 08:29:20 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 08:29:20 开始打印,排队:4,票券:2410010829128157245701,订单:24100108291281567598,[2024-10-01 08:29:20微信支付10元]


===08:34:26===
2024-10-01 08:34:22 >>>回调事件[910,devices/TL2007]
2024-10-01 08:34:22 >>>故障排除日志:上一MQTT订单号缓存列表为24100108291281567598
2024-10-01 08:34:22 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 08:34:22 开始打印,排队:5,票券:2410010834176869568701,订单:24100108341768690959,[2024-10-01 08:34:22微信支付10元]


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


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


===08:40:28===
2024-10-01 08:40:25 >>>回调事件[910,devices/TL2007]
2024-10-01 08:40:25 >>>故障排除日志:上一MQTT订单号缓存列表为24100108382269176053
2024-10-01 08:40:25 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 08:40:25 开始打印,排队:8,票券:2410010840200231035101,订单:24100108402002306182,[2024-10-01 08:40:25微信支付10元]


===08:41:28===
2024-10-01 08:40:27 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410010840200231035101","queue_number":8,"trade_uid":"24100108402002306182"}]}
2024-10-01 08:40:27 >>>故障排除日志:删除未同步下发订单成功24100108402002306182
2024-10-01 08:40:27 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


===09:10:30===
2024-10-01 09:09:47 >>>回调事件[910,devices/TL2007]
2024-10-01 09:09:47 >>>故障排除日志:上一MQTT订单号缓存列表为24100108595837754126
2024-10-01 09:09:47 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 09:09:47 开始打印,排队:13,票券:2410010909398028094501,订单:24100109093980277354,[2024-10-01 09:09:46微信支付10元]
2024-10-01 09:09:49 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410010909398028094501","queue_number":13,"trade_uid":"24100109093980277354"}]}
2024-10-01 09:09:49 >>>故障排除日志:删除未同步下发订单成功24100109093980277354
2024-10-01 09:09:49 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-01 09:09:54 >>>回调事件[910,devices/TL2007]
2024-10-01 09:09:54 >>>故障排除日志:上一MQTT订单号缓存列表为24100109093980277354
2024-10-01 09:09:54 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 09:09:54 开始打印,排队:14,票券:2410010909465004248601,订单:24100109094650038126,[2024-10-01 09:09:53微信支付10元]
2024-10-01 09:09:56 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410010909465004248601","queue_number":14,"trade_uid":"24100109094650038126"}]}
2024-10-01 09:09:56 >>>故障排除日志:删除未同步下发订单成功24100109094650038126
2024-10-01 09:09:56 >>>故障排除日志:终端同步成功后剩余订单列表


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


===09:12:31===
2024-10-01 09:11:30>>>cash read=10
2024-10-01 09:11:30 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-01 09:11:30 当前产品价格10元，投币10元，打印小票中...
2024-10-01 09:11:30 >>>开始打印,排队号为16,订单号为2410010911300020071668
定时检测未同步订单关闭
2024-10-01 09:11:30>>>订单2410010911300020071668写入成功,剩余空间为1680500,占用RAM为613.3212890625
删除未同步订单2410010911300020071668
2024-10-01 09:11:32>>>订单2410010911300020071668删除成功,剩余空间为1681000,占用RAM为618.427734375
检测订单目录中>>>
无未同步订单>>>
2024-10-01 09:11:32 >>>当前Ram内存为590.3466796875
定时检测未同步订单启用
2024-10-01 09:11:33>>>cash write=0C
2024-10-01 09:11:33>>>cash read=3E


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


===10:38:38===
2024-10-01 10:37:54 >>>回调事件[910,devices/TL2007]
2024-10-01 10:37:54 >>>故障排除日志:上一MQTT订单号缓存列表为24100110304112340389
2024-10-01 10:37:54 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 10:37:54 开始打印,排队:42,票券:2410011037402764656101,订单:24100110374027642924,[2024-10-01 10:37:53微信支付10元]
2024-10-01 10:37:56 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011037402764656101","queue_number":42,"trade_uid":"24100110374027642924"}]}
2024-10-01 10:37:56 >>>故障排除日志:删除未同步下发订单成功24100110374027642924
2024-10-01 10:37:56 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-01 10:37:57 >>>回调事件[910,devices/TL2007]
2024-10-01 10:37:57 >>>故障排除日志:上一MQTT订单号缓存列表为24100110374027642924
2024-10-01 10:37:57 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 10:37:57 开始打印,排队:43,票券:2410011037495857502101,订单:24100110374958570828,[2024-10-01 10:37:57微信支付10元]
2024-10-01 10:37:59 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011037495857502101","queue_number":43,"trade_uid":"24100110374958570828"}]}
2024-10-01 10:37:59 >>>故障排除日志:删除未同步下发订单成功24100110374958570828
2024-10-01 10:38:00 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


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


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


===11:11:40===
2024-10-01 11:11:31>>>cash read=0A
2024-10-01 11:11:32>>>cash read=3E


===11:17:40===
2024-10-01 11:16:44 >>>回调事件[910,devices/TL2007]
2024-10-01 11:16:44 >>>故障排除日志:上一MQTT订单号缓存列表为24100111083096058885
2024-10-01 11:16:44 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 11:16:44 开始打印,排队:51,票券:2410011116381079247301,订单:24100111163810787523,[2024-10-01 11:16:44微信支付10元]
2024-10-01 11:16:46 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011116381079247301","queue_number":51,"trade_uid":"24100111163810787523"}]}
2024-10-01 11:16:46 >>>故障排除日志:删除未同步下发订单成功24100111163810787523
2024-10-01 11:16:47 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-01 11:17:03 >>>回调事件[910,devices/TL2007]
2024-10-01 11:17:03 >>>故障排除日志:上一MQTT订单号缓存列表为24100111163810787523
2024-10-01 11:17:03 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 11:17:03 开始打印,排队:52,票券:2410011116562683006901,订单:24100111165626824994,[2024-10-01 11:17:03微信支付10元]
2024-10-01 11:17:05 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011116562683006901","queue_number":52,"trade_uid":"24100111165626824994"}]}
2024-10-01 11:17:05 >>>故障排除日志:删除未同步下发订单成功24100111165626824994
2024-10-01 11:17:05 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-01 11:17:07 >>>回调事件[910,devices/TL2007]
2024-10-01 11:17:07 >>>故障排除日志:上一MQTT订单号缓存列表为24100111165626824994
2024-10-01 11:17:08 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 11:17:08 开始打印,排队:53,票券:2410011116582793314601,订单:24100111165827929087,[2024-10-01 11:17:07微信支付10元]
2024-10-01 11:17:10 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011116582793314601","queue_number":53,"trade_uid":"24100111165827929087"}]}
2024-10-01 11:17:10 >>>故障排除日志:删除未同步下发订单成功24100111165827929087
2024-10-01 11:17:10 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


===11:39:42===
2024-10-01 11:38:42 >>>回调事件[910,devices/TL2007]
2024-10-01 11:38:42 >>>故障排除日志:上一MQTT订单号缓存列表为24100111213815312439
2024-10-01 11:38:42 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 11:38:42 开始打印,排队:58,票券:2410011138340892343701,订单:24100111383408919161,[2024-10-01 11:38:41微信支付10元]
2024-10-01 11:38:44 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011138340892343701","queue_number":58,"trade_uid":"24100111383408919161"}]}
2024-10-01 11:38:44 >>>故障排除日志:删除未同步下发订单成功24100111383408919161
2024-10-01 11:38:44 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-01 11:39:05 >>>回调事件[910,devices/TL2007]
2024-10-01 11:39:05 >>>故障排除日志:上一MQTT订单号缓存列表为24100111383408919161
2024-10-01 11:39:05 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 11:39:05 开始打印,排队:59,票券:2410011138579372349701,订单:24100111385793718918,[2024-10-01 11:39:05微信支付10元]
2024-10-01 11:39:07 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011138579372349701","queue_number":59,"trade_uid":"24100111385793718918"}]}
2024-10-01 11:39:07 >>>故障排除日志:删除未同步下发订单成功24100111385793718918
2024-10-01 11:39:07 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


===12:53:43===
2024-10-01 12:53:01>>>cash read=9E
2024-10-01 12:53:02>>>cash read=3E


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


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


===13:06:44===
2024-10-01 13:06:11>>>cash read=0A
2024-10-01 13:06:12>>>cash read=3E


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


===13:16:44===
2024-10-01 13:16:01 >>>回调事件[910,devices/TL2007]
2024-10-01 13:16:01 >>>故障排除日志:上一MQTT订单号缓存列表为24100113090454159498
2024-10-01 13:16:01 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 13:16:01 开始打印,排队:67,票券:2410011315542087974801,订单:24100113155420875829,[2024-10-01 13:16:01微信支付10元]
2024-10-01 13:16:03 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011315542087974801","queue_number":67,"trade_uid":"24100113155420875829"}]}
2024-10-01 13:16:03 >>>故障排除日志:删除未同步下发订单成功24100113155420875829
2024-10-01 13:16:03 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-01 13:16:19 >>>回调事件[910,devices/TL2007]
2024-10-01 13:16:19 >>>故障排除日志:上一MQTT订单号缓存列表为24100113155420875829
2024-10-01 13:16:19 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 13:16:19 开始打印,排队:68,票券:2410011316129696513901,订单:24100113161296959075,[2024-10-01 13:16:19微信支付10元]
2024-10-01 13:16:19 开始打印,排队:69,票券:2410011316129696978502,订单:24100113161296959075,[2024-10-01 13:16:19微信支付10元]
2024-10-01 13:16:23 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011316129696513901","queue_number":68,"trade_uid":"24100113161296959075"},{"ticket_no":"2410011316129696978502","queue_number":69,"trade_uid":"24100113161296959075"}]}
2024-10-01 13:16:23 >>>故障排除日志:删除未同步下发订单成功24100113161296959075
2024-10-01 13:16:23 >>>故障排除日志:删除未同步下发订单成功24100113161296959075
2024-10-01 13:16:23 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


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


===13:54:46===
2024-10-01 13:54:37>>>cash read=00
2024-10-01 13:54:38>>>cash read=01
2024-10-01 13:54:42>>>cash read=3E


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


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


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


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


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


===14:05:48===
2024-10-01 14:05:14>>>cash read=29
2024-10-01 14:05:14 >>>回调事件130,cash_status,20029,退钞中
2024-10-01 14:05:16>>>cash read=01
2024-10-01 14:05:19>>>cash read=3E
2024-10-01 14:05:22>>>cash read=00
2024-10-01 14:05:23>>>cash read=818F42
2024-10-01 14:05:23>>>cash write=02
2024-10-01 14:05:23 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-01 14:05:23>>>cash read=10
2024-10-01 14:05:23 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-01 14:05:23 当前产品价格10元，投币10元，打印小票中...
2024-10-01 14:05:23 >>>开始打印,排队号为78,订单号为2410011405230020074299
2024-10-01 14:05:23>>>订单2410011405230020074299写入成功,剩余空间为1679500,占用RAM为606.0966796875
删除未同步订单2410011405230020074299
2024-10-01 14:05:25>>>订单2410011405230020074299删除成功,剩余空间为1680500,占用RAM为618.3642578125
检测订单目录中>>>
无未同步订单>>>
2024-10-01 14:05:26 >>>当前Ram内存为589.87109375
定时检测未同步订单启用
2024-10-01 14:05:27>>>cash write=0C
2024-10-01 14:05:27>>>cash read=3E


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


===14:14:48===
2024-10-01 14:13:58 >>>回调事件[910,devices/TL2007]
2024-10-01 14:13:58 >>>故障排除日志:上一MQTT订单号缓存列表为24100114043169185532
2024-10-01 14:13:58 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 14:13:58 开始打印,排队:79,票券:2410011413525706281301,订单:24100114135257057748,[2024-10-01 14:13:58微信支付10元]
2024-10-01 14:14:00 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011413525706281301","queue_number":79,"trade_uid":"24100114135257057748"}]}
2024-10-01 14:14:00 >>>故障排除日志:删除未同步下发订单成功24100114135257057748
2024-10-01 14:14:00 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-01 14:14:21 >>>回调事件[910,devices/TL2007]
2024-10-01 14:14:21 >>>故障排除日志:上一MQTT订单号缓存列表为24100114135257057748
2024-10-01 14:14:21 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 14:14:21 开始打印,排队:80,票券:2410011414163961333401,订单:24100114141639607275,[2024-10-01 14:14:21微信支付10元]
2024-10-01 14:14:23 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011414163961333401","queue_number":80,"trade_uid":"24100114141639607275"}]}
2024-10-01 14:14:23 >>>故障排除日志:删除未同步下发订单成功24100114141639607275
2024-10-01 14:14:23 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


===14:23:49===
2024-10-01 14:23:22>>>cash read=00
2024-10-01 14:23:23>>>cash read=2F29
2024-10-01 14:23:23 >>>回调事件[910,devices/TL2007]
2024-10-01 14:23:24 >>>故障排除日志:上一MQTT订单号缓存列表为24100114165236326161
2024-10-01 14:23:24 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 14:23:24 开始打印,排队:83,票券:2410011423179391473101,订单:24100114231793911036,[2024-10-01 14:23:23微信支付10元]
2024-10-01 14:23:25 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011423179391473101","queue_number":83,"trade_uid":"24100114231793911036"}]}
2024-10-01 14:23:26 >>>故障排除日志:删除未同步下发订单成功24100114231793911036
2024-10-01 14:23:26 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-01 14:23:26>>>cash read=3E
2024-10-01 14:23:30>>>cash read=00
2024-10-01 14:23:30>>>cash read=818F42
2024-10-01 14:23:30>>>cash write=02
2024-10-01 14:23:30 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-01 14:23:30>>>cash read=10
2024-10-01 14:23:31 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-01 14:23:31 当前产品价格10元，投币10元，打印小票中...
2024-10-01 14:23:31 >>>开始打印,排队号为84,订单号为2410011423310020078057
2024-10-01 14:23:31>>>订单2410011423310020078057写入成功,剩余空间为1679000,占用RAM为613.3427734375
删除未同步订单2410011423310020078057
2024-10-01 14:23:33>>>订单2410011423310020078057删除成功,剩余空间为1680000,占用RAM为624.5009765625
检测订单目录中>>>
无未同步订单>>>
2024-10-01 14:23:33 >>>当前Ram内存为592.76953125
定时检测未同步订单启用
2024-10-01 14:23:34>>>cash write=0C
2024-10-01 14:23:34>>>cash read=3E


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


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


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


===14:32:50===
2024-10-01 14:32:22 >>>回调事件[910,devices/TL2007]
2024-10-01 14:32:22 >>>故障排除日志:上一MQTT订单号缓存列表为24100114241536959558
2024-10-01 14:32:22 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 14:32:22 开始打印,排队:87,票券:2410011432152629187301,订单:24100114321526287824,[2024-10-01 14:32:22微信支付10元]
2024-10-01 14:32:24 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011432152629187301","queue_number":87,"trade_uid":"24100114321526287824"}]}
2024-10-01 14:32:24 >>>故障排除日志:删除未同步下发订单成功24100114321526287824
2024-10-01 14:32:24 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-01 14:32:46 >>>回调事件[910,devices/TL2007]
2024-10-01 14:32:46 >>>故障排除日志:上一MQTT订单号缓存列表为24100114321526287824
2024-10-01 14:32:46 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 14:32:46 开始打印,排队:88,票券:2410011432337950761501,订单:24100114323379502893,[2024-10-01 14:32:46微信支付10元]
2024-10-01 14:32:48 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011432337950761501","queue_number":88,"trade_uid":"24100114323379502893"}]}
2024-10-01 14:32:48 >>>故障排除日志:删除未同步下发订单成功24100114323379502893
2024-10-01 14:32:48 >>>故障排除日志:终端同步成功后剩余订单列表


===14:35:50===
2024-10-01 14:35:04 >>>回调事件[910,devices/TL2007]
2024-10-01 14:35:04 >>>故障排除日志:上一MQTT订单号缓存列表为24100114323379502893
2024-10-01 14:35:04 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 14:35:04 开始打印,排队:89,票券:2410011434570919521801,订单:24100114345709190089,[2024-10-01 14:35:04支付宝支付10元]
2024-10-01 14:35:06 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011434570919521801","queue_number":89,"trade_uid":"24100114345709190089"}]}
2024-10-01 14:35:06 >>>故障排除日志:删除未同步下发订单成功24100114345709190089
2024-10-01 14:35:06 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


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


===15:06:52===
2024-10-01 15:05:54 >>>回调事件[910,devices/TL2007]
2024-10-01 15:05:54 >>>故障排除日志:上一MQTT订单号缓存列表为24100114525102628879
2024-10-01 15:05:54 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 15:05:54 开始打印,排队:95,票券:2410011505290469674101,订单:24100115052904692854,[2024-10-01 15:05:54微信支付10元]
2024-10-01 15:05:56 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011505290469674101","queue_number":95,"trade_uid":"24100115052904692854"}]}
2024-10-01 15:05:56 >>>故障排除日志:删除未同步下发订单成功24100115052904692854
2024-10-01 15:05:56 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-01 15:06:04 >>>回调事件[910,devices/TL2007]
2024-10-01 15:06:04 >>>故障排除日志:上一MQTT订单号缓存列表为24100115052904692854
2024-10-01 15:06:04 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 15:06:04 开始打印,排队:96,票券:2410011505575599001901,订单:24100115055755985438,[2024-10-01 15:06:03微信支付10元]
2024-10-01 15:06:06 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011505575599001901","queue_number":96,"trade_uid":"24100115055755985438"}]}
2024-10-01 15:06:06 >>>故障排除日志:删除未同步下发订单成功24100115055755985438
2024-10-01 15:06:06 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-01 15:06:39 >>>回调事件[910,devices/TL2007]
2024-10-01 15:06:39 >>>故障排除日志:上一MQTT订单号缓存列表为24100115055755985438
2024-10-01 15:06:39 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 15:06:39 开始打印,排队:97,票券:2410011506260124354601,订单:24100115062601238483,[2024-10-01 15:06:39微信支付10元]
2024-10-01 15:06:41 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011506260124354601","queue_number":97,"trade_uid":"24100115062601238483"}]}
2024-10-01 15:06:41 >>>故障排除日志:删除未同步下发订单成功24100115062601238483
2024-10-01 15:06:41 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


===15:42:54===
2024-10-01 15:42:51 >>>回调事件[910,devices/TL2007]
2024-10-01 15:42:51 >>>故障排除日志:上一MQTT订单号缓存列表为24100115371934436825
2024-10-01 15:42:51 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 15:42:51 开始打印,排队:102,票券:2410011542434939678901,订单:24100115424349392862,[2024-10-01 15:42:50微信支付10元]


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


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


===15:50:55===
2024-10-01 15:50:07>>>cash read=00
2024-10-01 15:50:08>>>cash read=818F42
2024-10-01 15:50:08>>>cash write=02
2024-10-01 15:50:08 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-01 15:50:08>>>cash read=10
2024-10-01 15:50:08 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-01 15:50:08 当前产品价格10元，投币10元，打印小票中...
2024-10-01 15:50:08 >>>开始打印,排队号为105,订单号为2410011550080020072977
2024-10-01 15:50:09>>>订单2410011550080020072977写入成功,剩余空间为1680000,占用RAM为605.568359375
删除未同步订单2410011550080020072977
2024-10-01 15:50:11>>>订单2410011550080020072977删除成功,剩余空间为1680500,占用RAM为617.57421875
检测订单目录中>>>
无未同步订单>>>
2024-10-01 15:50:11 >>>当前Ram内存为588.220703125
定时检测未同步订单启用
2024-10-01 15:50:12>>>cash write=0C
2024-10-01 15:50:12>>>cash read=3E
2024-10-01 15:50:49 >>>回调事件[910,devices/TL2007]
2024-10-01 15:50:49 >>>故障排除日志:上一MQTT订单号缓存列表为24100115443731456341
2024-10-01 15:50:49 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 15:50:49 开始打印,排队:106,票券:2410011550430649053201,订单:24100115504306486765,[2024-10-01 15:50:49微信支付10元]
2024-10-01 15:50:51 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011550430649053201","queue_number":106,"trade_uid":"24100115504306486765"}]}
2024-10-01 15:50:51 >>>故障排除日志:删除未同步下发订单成功24100115504306486765
2024-10-01 15:50:51 >>>故障排除日志:终端同步成功后剩余订单列表


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


===15:52:56===
2024-10-01 15:52:29>>>cash read=29
2024-10-01 15:52:29 >>>回调事件130,cash_status,20029,退钞中
2024-10-01 15:52:31>>>cash read=3E
2024-10-01 15:52:37>>>cash read=00
2024-10-01 15:52:37>>>cash read=818F41
2024-10-01 15:52:37>>>cash write=02
2024-10-01 15:52:37 >>>回调事件130,cash_status,10022,进钞中...read money=5
2024-10-01 15:52:38>>>cash read=10
2024-10-01 15:52:38 >>>回调事件130,5,10023,finish Money=5,进钞完成
2024-10-01 15:52:39>>>cash write=0C
2024-10-01 15:52:39>>>cash read=29
2024-10-01 15:52:39 >>>回调事件130,cash_status,20029,退钞中
2024-10-01 15:52:40>>>cash read=22
2024-10-01 15:52:40 >>>回调事件130,cash_status,30022,卡钞


===15:53:56===
2024-10-01 15:53:27>>>cash read=2F
2024-10-01 15:53:28>>>cash read=3E
2024-10-01 15:53:31>>>cash read=00
2024-10-01 15:53:32>>>cash read=818F41
2024-10-01 15:53:32>>>cash write=02
2024-10-01 15:53:32 >>>回调事件130,cash_status,10022,进钞中...read money=5
2024-10-01 15:53:32>>>cash read=10
2024-10-01 15:53:32 >>>回调事件130,5,10023,finish Money=5,进钞完成
2024-10-01 15:53:32 当前产品价格10元，投币10元，打印小票中...
2024-10-01 15:53:32 >>>开始打印,排队号为108,订单号为2410011552380020078660
2024-10-01 15:53:32>>>订单2410011552380020078660写入成功,剩余空间为1679500,占用RAM为603.0380859375
删除未同步订单2410011552380020078660
2024-10-01 15:53:35>>>订单2410011552380020078660删除成功,剩余空间为1680500,占用RAM为618.38671875
检测订单目录中>>>
无未同步订单>>>
2024-10-01 15:53:35 >>>当前Ram内存为588.2880859375
定时检测未同步订单启用
2024-10-01 15:53:36>>>cash write=0C
2024-10-01 15:53:36>>>cash read=3E


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


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


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


===16:02:57===
2024-10-01 16:02:09 >>>回调事件[910,devices/TL2007]
2024-10-01 16:02:09 >>>故障排除日志:上一MQTT订单号缓存列表为24100116013075552951
2024-10-01 16:02:09 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 16:02:09 开始打印,排队:112,票券:2410011602030515592901,订单:24100116020305151821,[2024-10-01 16:02:09微信支付10元]
2024-10-01 16:02:11 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011602030515592901","queue_number":112,"trade_uid":"24100116020305151821"}]}
2024-10-01 16:02:11 >>>故障排除日志:删除未同步下发订单成功24100116020305151821
2024-10-01 16:02:11 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-01 16:02:40>>>cash read=00
2024-10-01 16:02:40>>>cash read=818F42
2024-10-01 16:02:40>>>cash write=02
2024-10-01 16:02:40 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-01 16:02:41>>>cash read=10
2024-10-01 16:02:41 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-01 16:02:41 当前产品价格10元，投币10元，打印小票中...
2024-10-01 16:02:41 >>>开始打印,排队号为113,订单号为2410011602410020079737
2024-10-01 16:02:41>>>订单2410011602410020079737写入成功,剩余空间为1679000,占用RAM为609.7431640625
删除未同步订单2410011602410020079737
2024-10-01 16:02:43>>>订单2410011602410020079737删除成功,剩余空间为1680000,占用RAM为618.38671875
检测订单目录中>>>
无未同步订单>>>
2024-10-01 16:02:43 >>>当前Ram内存为588.919921875
定时检测未同步订单启用
2024-10-01 16:02:44>>>cash write=0C
2024-10-01 16:02:44>>>cash read=3E


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


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


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


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


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


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


===16:17:00===
2024-10-01 16:16:40 >>>回调事件[910,devices/TL2007]
2024-10-01 16:16:40 >>>故障排除日志:上一MQTT订单号缓存列表为24100116123120361497
2024-10-01 16:16:40 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 16:16:40 开始打印,排队:119,票券:2410011616338555509201,订单:24100116163385551389,[2024-10-01 16:16:40支付宝支付10元]
2024-10-01 16:16:42 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011616338555509201","queue_number":119,"trade_uid":"24100116163385551389"}]}
2024-10-01 16:16:42 >>>故障排除日志:删除未同步下发订单成功24100116163385551389
2024-10-01 16:16:42 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-01 16:16:50 >>>回调事件[910,devices/TL2007]
2024-10-01 16:16:50 >>>故障排除日志:上一MQTT订单号缓存列表为24100116163385551389
2024-10-01 16:16:50 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 16:16:50 开始打印,排队:120,票券:2410011616439155842301,订单:24100116164391554538,[2024-10-01 16:16:50微信支付10元]
2024-10-01 16:16:52 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011616439155842301","queue_number":120,"trade_uid":"24100116164391554538"}]}
2024-10-01 16:16:52 >>>故障排除日志:删除未同步下发订单成功24100116164391554538
2024-10-01 16:16:52 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


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


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


===16:40:02===
2024-10-01 16:39:07>>>cash read=0A
2024-10-01 16:39:08>>>cash read=3E
2024-10-01 16:39:45 >>>回调事件[910,devices/TL2007]
2024-10-01 16:39:45 >>>故障排除日志:上一MQTT订单号缓存列表为24100116320200788419
2024-10-01 16:39:45 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 16:39:45 开始打印,排队:127,票券:2410011639365039114101,订单:24100116393650386095,[2024-10-01 16:39:44微信支付10元]
2024-10-01 16:39:47 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011639365039114101","queue_number":127,"trade_uid":"24100116393650386095"}]}
2024-10-01 16:39:47 >>>故障排除日志:删除未同步下发订单成功24100116393650386095
2024-10-01 16:39:47 >>>故障排除日志:终端同步成功后剩余订单列表


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


===16:42:03===
2024-10-01 16:41:52 >>>回调事件[910,devices/TL2007]
2024-10-01 16:41:52 >>>故障排除日志:上一MQTT订单号缓存列表为24100116402311316864
2024-10-01 16:41:52 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 16:41:52 开始打印,排队:129,票券:2410011641450003438401,订单:24100116414500029334,[2024-10-01 16:41:52微信支付10元]
2024-10-01 16:41:54 >>>回调事件[910,devices/TL2007]
2024-10-01 16:41:54 >>>故障排除日志:上一MQTT订单号缓存列表为24100116414500029334
2024-10-01 16:41:54 >>>故障排除日志:终端未同步成功订单列表012924100116414500029334
2024-10-01 16:41:54 开始打印,排队:130,票券:2410011641446483294701,订单:24100116414464829425,[2024-10-01 16:41:52微信支付10元]
已接收过此消息,票券号为2410011641450003438401,排队号为129
2024-10-01 16:41:56 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011641450003438401","queue_number":129,"trade_uid":"24100116414500029334"}]}
2024-10-01 16:41:56 >>>故障排除日志:删除未同步下发订单成功24100116414500029334
2024-10-01 16:41:56 >>>故障排除日志:终端同步成功后剩余订单列表013024100116414464829425
2024-10-01 16:41:56 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011641446483294701","queue_number":130,"trade_uid":"24100116414464829425"},{"ticket_no":"2410011641450003438401","queue_number":129,"trade_uid":"24100116414500029334"}]}
2024-10-01 16:41:56 >>>故障排除日志:删除未同步下发订单成功24100116414464829425
2024-10-01 16:41:56 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


===16:53:04===
2024-10-01 16:52:11>>>cash read=0A
2024-10-01 16:52:12>>>cash read=3E


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


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


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


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


===17:13:05===
2024-10-01 17:12:17 >>>回调事件[910,devices/TL2007]
2024-10-01 17:12:17 >>>故障排除日志:上一MQTT订单号缓存列表为24100117064179144736
2024-10-01 17:12:17 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 17:12:17 开始打印,排队:139,票券:2410011712100638266501,订单:24100117121006378479,[2024-10-01 17:12:16微信支付10元]
2024-10-01 17:12:19 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011712100638266501","queue_number":139,"trade_uid":"24100117121006378479"}]}
2024-10-01 17:12:19 >>>故障排除日志:删除未同步下发订单成功24100117121006378479
2024-10-01 17:12:19 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-01 17:12:32 >>>回调事件[910,devices/TL2007]
2024-10-01 17:12:32 >>>故障排除日志:上一MQTT订单号缓存列表为24100117121006378479
2024-10-01 17:12:32 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 17:12:32 开始打印,排队:140,票券:2410011712262471475301,订单:24100117122624711264,[2024-10-01 17:12:32微信支付10元]
2024-10-01 17:12:35 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011712262471475301","queue_number":140,"trade_uid":"24100117122624711264"}]}
2024-10-01 17:12:35 >>>故障排除日志:删除未同步下发订单成功24100117122624711264
2024-10-01 17:12:35 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-01 17:12:41 >>>回调事件[910,devices/TL2007]
2024-10-01 17:12:41 >>>故障排除日志:上一MQTT订单号缓存列表为24100117122624711264
2024-10-01 17:12:41 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 17:12:41 开始打印,排队:141,票券:2410011712347909443901,订单:24100117123479089724,[2024-10-01 17:12:41微信支付10元]
2024-10-01 17:12:43 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011712347909443901","queue_number":141,"trade_uid":"24100117123479089724"}]}
2024-10-01 17:12:43 >>>故障排除日志:删除未同步下发订单成功24100117123479089724
2024-10-01 17:12:43 >>>故障排除日志:终端同步成功后剩余订单列表


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


===17:18:06===
2024-10-01 17:17:50 >>>回调事件[910,devices/TL2007]
2024-10-01 17:17:50 >>>故障排除日志:上一MQTT订单号缓存列表为24100117143182155249
2024-10-01 17:17:50 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 17:17:50 开始打印,排队:143,票券:2410011717427768063401,订单:24100117174277676426,[2024-10-01 17:17:50支付宝支付10元]
2024-10-01 17:17:52 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011717427768063401","queue_number":143,"trade_uid":"24100117174277676426"}]}
2024-10-01 17:17:52 >>>故障排除日志:删除未同步下发订单成功24100117174277676426
2024-10-01 17:17:52 >>>故障排除日志:终端同步成功后剩余订单列表


===17:22:06===
2024-10-01 17:21:13 >>>回调事件[910,devices/TL2007]
2024-10-01 17:21:13 >>>故障排除日志:上一MQTT订单号缓存列表为24100117174277676426
2024-10-01 17:21:13 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 17:21:13 开始打印,排队:144,票券:2410011721065181251701,订单:24100117210651806798,[2024-10-01 17:21:12微信支付10元]
2024-10-01 17:21:15 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011721065181251701","queue_number":144,"trade_uid":"24100117210651806798"}]}
2024-10-01 17:21:15 >>>故障排除日志:删除未同步下发订单成功24100117210651806798
2024-10-01 17:21:15 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-01 17:21:23 >>>回调事件[910,devices/TL2007]
2024-10-01 17:21:23 >>>故障排除日志:上一MQTT订单号缓存列表为24100117210651806798
2024-10-01 17:21:23 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 17:21:23 开始打印,排队:145,票券:2410011721168243503501,订单:24100117211682429287,[2024-10-01 17:21:23微信支付10元]
2024-10-01 17:21:25 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011721168243503501","queue_number":145,"trade_uid":"24100117211682429287"}]}
2024-10-01 17:21:25 >>>故障排除日志:删除未同步下发订单成功24100117211682429287
2024-10-01 17:21:25 >>>故障排除日志:终端同步成功后剩余订单列表


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


===17:43:07===
2024-10-01 17:42:23 >>>回调事件[910,devices/TL2007]
2024-10-01 17:42:23 >>>故障排除日志:上一MQTT订单号缓存列表为24100117253302979473
2024-10-01 17:42:23 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 17:42:23 开始打印,排队:147,票券:2410011742165287814501,订单:24100117421652874528,[2024-10-01 17:42:23微信支付10元]
2024-10-01 17:42:25 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011742165287814501","queue_number":147,"trade_uid":"24100117421652874528"}]}
2024-10-01 17:42:25 >>>故障排除日志:删除未同步下发订单成功24100117421652874528
2024-10-01 17:42:25 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-01 17:42:44 >>>回调事件[910,devices/TL2007]
2024-10-01 17:42:44 >>>故障排除日志:上一MQTT订单号缓存列表为24100117421652874528
2024-10-01 17:42:44 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 17:42:44 开始打印,排队:148,票券:2410011742373448464201,订单:24100117423734480224,[2024-10-01 17:42:44微信支付10元]
2024-10-01 17:42:46 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011742373448464201","queue_number":148,"trade_uid":"24100117423734480224"}]}
2024-10-01 17:42:46 >>>故障排除日志:删除未同步下发订单成功24100117423734480224
2024-10-01 17:42:46 >>>故障排除日志:终端同步成功后剩余订单列表


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


===17:56:09===
2024-10-01 17:55:35>>>cash read=00
2024-10-01 17:55:36>>>cash read=818F42
2024-10-01 17:55:36>>>cash write=02
2024-10-01 17:55:36 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-01 17:55:36>>>cash read=10
2024-10-01 17:55:36 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-01 17:55:36 当前产品价格10元，投币10元，打印小票中...
2024-10-01 17:55:36 >>>开始打印,排队号为150,订单号为2410011755360020076780
2024-10-01 17:55:37>>>订单2410011755360020076780写入成功,剩余空间为1680000,占用RAM为605.69921875
删除未同步订单2410011755360020076780
2024-10-01 17:55:39>>>订单2410011755360020076780删除成功,剩余空间为1680500,占用RAM为616.5625
检测订单目录中>>>
无未同步订单>>>
2024-10-01 17:55:39 >>>当前Ram内存为588.345703125
定时检测未同步订单启用
2024-10-01 17:55:40>>>cash write=0C
2024-10-01 17:55:40>>>cash read=3E
2024-10-01 17:56:05 >>>回调事件[910,devices/TL2007]
2024-10-01 17:56:05 >>>故障排除日志:上一MQTT订单号缓存列表为24100117514293916456
2024-10-01 17:56:05 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 17:56:05 开始打印,排队:151,票券:2410011755589183798901,订单:24100117555891834278,[2024-10-01 17:56:05微信支付10元]


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


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


===18:07:10===
2024-10-01 18:06:28>>>cash read=00
2024-10-01 18:06:28>>>cash read=818F42
2024-10-01 18:06:28>>>cash write=02
2024-10-01 18:06:28 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-01 18:06:28>>>cash read=10
2024-10-01 18:06:28 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-01 18:06:28 当前产品价格10元，投币10元，打印小票中...
2024-10-01 18:06:28 >>>开始打印,排队号为153,订单号为2410011806280020076532
2024-10-01 18:06:29>>>订单2410011806280020076532写入成功,剩余空间为1680000,占用RAM为602.2900390625
删除未同步订单2410011806280020076532
2024-10-01 18:06:31>>>订单2410011806280020076532删除成功,剩余空间为1680500,占用RAM为618.6376953125
检测订单目录中>>>
无未同步订单>>>
2024-10-01 18:06:31 >>>当前Ram内存为588.6767578125
定时检测未同步订单启用
2024-10-01 18:06:32>>>cash write=0C
2024-10-01 18:06:32>>>cash read=3E
2024-10-01 18:06:39>>>cash read=29
2024-10-01 18:06:39 >>>回调事件130,cash_status,20029,退钞中
2024-10-01 18:06:40>>>cash read=01
2024-10-01 18:06:42>>>cash read=3E
2024-10-01 18:06:44>>>cash read=00
2024-10-01 18:06:45>>>cash read=3E
2024-10-01 18:06:48>>>cash read=00
2024-10-01 18:06:49>>>cash read=818F41
2024-10-01 18:06:49>>>cash write=02
2024-10-01 18:06:49 >>>回调事件130,cash_status,10022,进钞中...read money=5
2024-10-01 18:06:49>>>cash read=10
2024-10-01 18:06:49 >>>回调事件130,5,10023,finish Money=5,进钞完成
2024-10-01 18:06:50>>>cash write=0C
2024-10-01 18:06:50>>>cash read=3E
2024-10-01 18:06:53>>>cash read=292F29
2024-10-01 18:06:53 >>>回调事件130,cash_status,20029,退钞中
2024-10-01 18:06:55>>>cash read=3E
2024-10-01 18:06:56>>>cash read=29
2024-10-01 18:06:56 >>>回调事件130,cash_status,20029,退钞中
2024-10-01 18:06:57>>>cash read=3E
2024-10-01 18:07:03>>>cash read=29
2024-10-01 18:07:03 >>>回调事件130,cash_status,20029,退钞中
2024-10-01 18:07:04>>>cash read=3E
2024-10-01 18:07:06>>>cash read=29
2024-10-01 18:07:06 >>>回调事件130,cash_status,20029,退钞中
2024-10-01 18:07:07>>>cash read=3E


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


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


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


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


===18:51:11===
2024-10-01 18:50:13 >>>回调事件[910,devices/TL2007]
2024-10-01 18:50:13 >>>故障排除日志:上一MQTT订单号缓存列表为24100118270914688413
2024-10-01 18:50:13 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 18:50:13 开始打印,排队:157,票券:2410011850059674043801,订单:24100118500596736562,[2024-10-01 18:50:13微信支付10元]
2024-10-01 18:50:15 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011850059674043801","queue_number":157,"trade_uid":"24100118500596736562"}]}
2024-10-01 18:50:15 >>>故障排除日志:删除未同步下发订单成功24100118500596736562
2024-10-01 18:50:15 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-01 18:50:18 >>>回调事件[910,devices/TL2007]
2024-10-01 18:50:18 >>>故障排除日志:上一MQTT订单号缓存列表为24100118500596736562
2024-10-01 18:50:18 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 18:50:18 开始打印,排队:158,票券:2410011850113108075201,订单:24100118501131075741,[2024-10-01 18:50:18微信支付10元]
2024-10-01 18:50:20 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011850113108075201","queue_number":158,"trade_uid":"24100118501131075741"}]}
2024-10-01 18:50:20 >>>故障排除日志:删除未同步下发订单成功24100118501131075741
2024-10-01 18:50:20 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-01 18:50:56 >>>回调事件[910,devices/TL2007]
2024-10-01 18:50:56 >>>故障排除日志:上一MQTT订单号缓存列表为24100118501131075741
2024-10-01 18:50:56 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 18:50:56 开始打印,排队:159,票券:2410011850503037839501,订单:24100118505030373284,[2024-10-01 18:50:56微信支付10元]
2024-10-01 18:50:58 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011850503037839501","queue_number":159,"trade_uid":"24100118505030373284"}]}
2024-10-01 18:50:58 >>>故障排除日志:删除未同步下发订单成功24100118505030373284
2024-10-01 18:50:58 >>>故障排除日志:终端同步成功后剩余订单列表


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


===18:58:12===
2024-10-01 18:58:02 >>>回调事件[910,devices/TL2007]
2024-10-01 18:58:02 >>>故障排除日志:上一MQTT订单号缓存列表为24100118561923275156|24100118561923275156
2024-10-01 18:58:02 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 18:58:02 开始打印,排队:162,票券:2410011857541825862901,订单:24100118575418255075,[2024-10-01 18:58:02微信支付10元]
2024-10-01 18:58:02 开始打印,排队:163,票券:2410011857541825993502,订单:24100118575418255075,[2024-10-01 18:58:02微信支付10元]
2024-10-01 18:58:02 开始打印,排队:164,票券:2410011857541826057403,订单:24100118575418255075,[2024-10-01 18:58:02微信支付10元]
2024-10-01 18:58:07 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011857541825862901","queue_number":162,"trade_uid":"24100118575418255075"},{"ticket_no":"2410011857541825993502","queue_number":163,"trade_uid":"24100118575418255075"},{"ticket_no":"2410011857541826057403","queue_number":164,"trade_uid":"24100118575418255075"}]}
2024-10-01 18:58:07 >>>故障排除日志:删除未同步下发订单成功24100118575418255075
2024-10-01 18:58:07 >>>故障排除日志:删除未同步下发订单成功24100118575418255075
2024-10-01 18:58:07 >>>故障排除日志:删除未同步下发订单成功24100118575418255075
2024-10-01 18:58:07 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


===19:07:14===
2024-10-01 19:06:43 >>>回调事件[910,devices/TL2007]
2024-10-01 19:06:43 >>>故障排除日志:上一MQTT订单号缓存列表为24100119045245667049
2024-10-01 19:06:43 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 19:06:43 开始打印,排队:169,票券:2410011906379374986101,订单:24100119063793745982,[2024-10-01 19:06:43微信支付10元]
2024-10-01 19:06:44 >>>回调事件[910,devices/TL2007]
2024-10-01 19:06:44 >>>故障排除日志:上一MQTT订单号缓存列表为24100119063793745982
2024-10-01 19:06:45 >>>故障排除日志:终端未同步成功订单列表016924100119063793745982
2024-10-01 19:06:45 开始打印,排队:170,票券:2410011906376165858501,订单:24100119063761654987,[2024-10-01 19:06:44微信支付10元]
已接收过此消息,票券号为2410011906379374986101,排队号为169
2024-10-01 19:06:47 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011906379374986101","queue_number":169,"trade_uid":"24100119063793745982"}]}
2024-10-01 19:06:47 >>>故障排除日志:删除未同步下发订单成功24100119063793745982
2024-10-01 19:06:47 >>>故障排除日志:终端同步成功后剩余订单列表017024100119063761654987
2024-10-01 19:06:47 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011906376165858501","queue_number":170,"trade_uid":"24100119063761654987"},{"ticket_no":"2410011906379374986101","queue_number":169,"trade_uid":"24100119063793745982"}]}
2024-10-01 19:06:47 >>>故障排除日志:删除未同步下发订单成功24100119063761654987
2024-10-01 19:06:47 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-01 19:07:08 >>>回调事件[910,devices/TL2007]
2024-10-01 19:07:08 >>>故障排除日志:上一MQTT订单号缓存列表为24100119063761654987|24100119063793745982
2024-10-01 19:07:08 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 19:07:08 开始打印,排队:171,票券:2410011906566737266701,订单:24100119065667366759,[2024-10-01 19:07:08微信支付10元]
2024-10-01 19:07:10 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011906566737266701","queue_number":171,"trade_uid":"24100119065667366759"}]}
2024-10-01 19:07:10 >>>故障排除日志:删除未同步下发订单成功24100119065667366759
2024-10-01 19:07:10 >>>故障排除日志:终端同步成功后剩余订单列表


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


===19:11:14===
2024-10-01 19:10:27 >>>回调事件[910,devices/TL2007]
2024-10-01 19:10:27 >>>故障排除日志:上一MQTT订单号缓存列表为24100119073956472183
2024-10-01 19:10:27 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 19:10:27 开始打印,排队:173,票券:2410011910147238951901,订单:24100119101472385338,[2024-10-01 19:10:27微信支付10元]
2024-10-01 19:10:29 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011910147238951901","queue_number":173,"trade_uid":"24100119101472385338"}]}
2024-10-01 19:10:29 >>>故障排除日志:删除未同步下发订单成功24100119101472385338
2024-10-01 19:10:29 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-01 19:10:42>>>cash read=0A
2024-10-01 19:10:43>>>cash read=3E


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


===19:18:15===
2024-10-01 19:17:14>>>cash read=29
2024-10-01 19:17:14 >>>回调事件130,cash_status,20029,退钞中
2024-10-01 19:17:15>>>cash read=01
2024-10-01 19:17:17>>>cash read=3E
2024-10-01 19:17:21>>>cash read=2F29
2024-10-01 19:17:22>>>cash read=01
2024-10-01 19:17:25>>>cash read=2F
2024-10-01 19:17:26>>>cash read=29
2024-10-01 19:17:26 >>>回调事件130,cash_status,20029,退钞中
2024-10-01 19:17:27>>>cash read=01
2024-10-01 19:17:30>>>cash read=3E


===19:19:15===
2024-10-01 19:18:20 >>>回调事件[910,devices/TL2007]
2024-10-01 19:18:20 >>>故障排除日志:上一MQTT订单号缓存列表为24100119125425115054
2024-10-01 19:18:20 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 19:18:20 开始打印,排队:175,票券:2410011918138712525101,订单:24100119181387121461,[2024-10-01 19:18:20微信支付10元]
2024-10-01 19:18:22 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011918138712525101","queue_number":175,"trade_uid":"24100119181387121461"}]}
2024-10-01 19:18:22 >>>故障排除日志:删除未同步下发订单成功24100119181387121461
2024-10-01 19:18:23 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-01 19:18:24>>>cash read=00
2024-10-01 19:18:25>>>cash read=818F42
2024-10-01 19:18:25>>>cash write=02
2024-10-01 19:18:25 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-01 19:18:26>>>cash read=10
2024-10-01 19:18:26 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-01 19:18:26 当前产品价格10元，投币10元，打印小票中...
2024-10-01 19:18:26 >>>开始打印,排队号为176,订单号为2410011918260020072592
2024-10-01 19:18:26>>>订单2410011918260020072592写入成功,剩余空间为1679000,占用RAM为610.8408203125
删除未同步订单2410011918260020072592
2024-10-01 19:18:28>>>订单2410011918260020072592删除成功,剩余空间为1680000,占用RAM为624.091796875
检测订单目录中>>>
无未同步订单>>>
2024-10-01 19:18:29 >>>当前Ram内存为591.5927734375
定时检测未同步订单启用
2024-10-01 19:18:29>>>cash write=0C
2024-10-01 19:18:29>>>cash read=3E
2024-10-01 19:18:38>>>cash read=00
2024-10-01 19:18:40>>>cash read=818F42
2024-10-01 19:18:40>>>cash write=02
2024-10-01 19:18:40 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-01 19:18:40>>>cash read=10
2024-10-01 19:18:40 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-01 19:18:40 当前产品价格10元，投币10元，打印小票中...
2024-10-01 19:18:40 >>>开始打印,排队号为177,订单号为2410011918400020076611
定时检测未同步订单关闭
2024-10-01 19:18:41>>>订单2410011918400020076611写入成功,剩余空间为1678000,占用RAM为615.68359375
删除未同步订单2410011918400020076611
2024-10-01 19:18:43>>>订单2410011918400020076611删除成功,剩余空间为1679000,占用RAM为623.1787109375
检测订单目录中>>>
无未同步订单>>>
2024-10-01 19:18:43 >>>当前Ram内存为590.197265625
定时检测未同步订单启用
2024-10-01 19:18:44>>>cash write=0C
2024-10-01 19:18:44>>>cash read=3E


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


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


===19:26:16===
2024-10-01 19:25:34>>>cash read=0A
2024-10-01 19:25:35>>>cash read=3E


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


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


===19:37:17===
2024-10-01 19:36:54 >>>回调事件[910,devices/TL2007]
2024-10-01 19:36:54 >>>故障排除日志:上一MQTT订单号缓存列表为24100119350387667249
2024-10-01 19:36:54 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 19:36:54 开始打印,排队:181,票券:2410011936475091271301,订单:24100119364750909038,[2024-10-01 19:36:54支付宝支付10元]
2024-10-01 19:36:56 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011936475091271301","queue_number":181,"trade_uid":"24100119364750909038"}]}
2024-10-01 19:36:56 >>>故障排除日志:删除未同步下发订单成功24100119364750909038
2024-10-01 19:36:56 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


===19:40:18===
2024-10-01 19:39:38 >>>回调事件[910,devices/TL2007]
2024-10-01 19:39:38 >>>故障排除日志:上一MQTT订单号缓存列表为24100119384003114783
2024-10-01 19:39:38 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 19:39:38 开始打印,排队:184,票券:2410011939328249273101,订单:24100119393282488752,[2024-10-01 19:39:38微信支付10元]
2024-10-01 19:39:40 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011939328249273101","queue_number":184,"trade_uid":"24100119393282488752"}]}
2024-10-01 19:39:40 >>>故障排除日志:删除未同步下发订单成功24100119393282488752
2024-10-01 19:39:40 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-01 19:40:12 >>>回调事件[910,devices/TL2007]
2024-10-01 19:40:12 >>>故障排除日志:上一MQTT订单号缓存列表为24100119393282488752
2024-10-01 19:40:12 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 19:40:12 开始打印,排队:185,票券:2410011940045002866201,订单:24100119400450024961,[2024-10-01 19:40:12微信支付10元]
2024-10-01 19:40:12 开始打印,排队:186,票券:2410011940045003002102,订单:24100119400450024961,[2024-10-01 19:40:12微信支付10元]
2024-10-01 19:40:15 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011940045002866201","queue_number":185,"trade_uid":"24100119400450024961"},{"ticket_no":"2410011940045003002102","queue_number":186,"trade_uid":"24100119400450024961"}]}
2024-10-01 19:40:15 >>>故障排除日志:删除未同步下发订单成功24100119400450024961
2024-10-01 19:40:15 >>>故障排除日志:删除未同步下发订单成功24100119400450024961
2024-10-01 19:40:16 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


===19:54:19===
定时检测未同步订单关闭
检测订单目录中>>>
无未同步订单>>>
2024-10-01 19:54:08 >>>回调事件[910,devices/TL2007]
2024-10-01 19:54:08 >>>故障排除日志:上一MQTT订单号缓存列表为24100119513119193514
2024-10-01 19:54:08 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 19:54:08 开始打印,排队:190,票券:2410011953593827889801,订单:24100119535938274818,[2024-10-01 19:54:08微信支付10元]
2024-10-01 19:54:10 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011953593827889801","queue_number":190,"trade_uid":"24100119535938274818"}]}
2024-10-01 19:54:10 >>>故障排除日志:删除未同步下发订单成功24100119535938274818
2024-10-01 19:54:10 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-01 19:54:13 >>>回调事件[910,devices/TL2007]
2024-10-01 19:54:14 >>>故障排除日志:上一MQTT订单号缓存列表为24100119535938274818
2024-10-01 19:54:14 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 19:54:14 开始打印,排队:191,票券:2410011954053583323701,订单:24100119540535829952,[2024-10-01 19:54:13微信支付10元]
2024-10-01 19:54:16 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011954053583323701","queue_number":191,"trade_uid":"24100119540535829952"}]}
2024-10-01 19:54:16 >>>故障排除日志:删除未同步下发订单成功24100119540535829952
2024-10-01 19:54:16 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


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


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


===20:04:21===
2024-10-01 20:03:23 >>>回调事件[910,devices/TL2007]
2024-10-01 20:03:23 >>>故障排除日志:上一MQTT订单号缓存列表为24100120023766105021
2024-10-01 20:03:23 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 20:03:23 开始打印,排队:197,票券:2410012003173111821501,订单:24100120031731114068,[2024-10-01 20:03:23微信支付10元]
2024-10-01 20:03:25 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410012003173111821501","queue_number":197,"trade_uid":"24100120031731114068"}]}
2024-10-01 20:03:25 >>>故障排除日志:删除未同步下发订单成功24100120031731114068
2024-10-01 20:03:26 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-01 20:03:54 >>>回调事件[910,devices/TL2007]
2024-10-01 20:03:54 >>>故障排除日志:上一MQTT订单号缓存列表为24100120031731114068
2024-10-01 20:03:54 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 20:03:55 开始打印,排队:198,票券:2410012003475074117301,订单:24100120034750737783,[2024-10-01 20:03:54微信支付10元]
2024-10-01 20:03:57 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410012003475074117301","queue_number":198,"trade_uid":"24100120034750737783"}]}
2024-10-01 20:03:57 >>>故障排除日志:删除未同步下发订单成功24100120034750737783
2024-10-01 20:03:57 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


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


===20:28:23===
2024-10-01 20:27:37 >>>回调事件[910,devices/TL2007]
2024-10-01 20:27:37 >>>故障排除日志:上一MQTT订单号缓存列表为24100120224301312728
2024-10-01 20:27:37 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 20:27:37 开始打印,排队:203,票券:2410012027299230281901,订单:24100120272992298961,[2024-10-01 20:27:37微信支付10元]
2024-10-01 20:27:39 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410012027299230281901","queue_number":203,"trade_uid":"24100120272992298961"}]}
2024-10-01 20:27:39 >>>故障排除日志:删除未同步下发订单成功24100120272992298961
2024-10-01 20:27:39 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-01 20:27:40>>>cash read=00
2024-10-01 20:27:41>>>cash read=2F29
2024-10-01 20:27:42>>>cash read=00
2024-10-01 20:27:43>>>cash read=818F42
2024-10-01 20:27:43>>>cash write=02
2024-10-01 20:27:44 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-01 20:27:44>>>cash read=10
2024-10-01 20:27:44 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-01 20:27:44 当前产品价格10元，投币10元，打印小票中...
2024-10-01 20:27:44 >>>开始打印,排队号为204,订单号为2410012027440020072289
2024-10-01 20:27:44>>>订单2410012027440020072289写入成功,剩余空间为1679000,占用RAM为610.9638671875
删除未同步订单2410012027440020072289
2024-10-01 20:27:46>>>订单2410012027440020072289删除成功,剩余空间为1680000,占用RAM为622.8955078125
检测订单目录中>>>
无未同步订单>>>
2024-10-01 20:27:47 >>>当前Ram内存为591.755859375
定时检测未同步订单启用
2024-10-01 20:27:47>>>cash write=0C
2024-10-01 20:27:48>>>cash read=3E


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


===20:30:23===
2024-10-01 20:29:37 >>>回调事件[910,devices/TL2007]
2024-10-01 20:29:37 >>>故障排除日志:上一MQTT订单号缓存列表为24100120272992298961
2024-10-01 20:29:37 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 20:29:37 开始打印,排队:205,票券:2410012029329240681201,订单:24100120293292403156,[2024-10-01 20:29:37支付宝支付10元]
2024-10-01 20:29:39 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410012029329240681201","queue_number":205,"trade_uid":"24100120293292403156"}]}
2024-10-01 20:29:39 >>>故障排除日志:删除未同步下发订单成功24100120293292403156
2024-10-01 20:29:39 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


===21:08:25===
2024-10-01 21:07:26>>>cash read=00
2024-10-01 21:07:27>>>cash read=01
2024-10-01 21:07:32>>>cash read=3E
2024-10-01 21:07:34>>>cash read=29
2024-10-01 21:07:34 >>>回调事件130,cash_status,20029,退钞中
2024-10-01 21:07:34>>>cash read=2F29
2024-10-01 21:07:36>>>cash read=01
2024-10-01 21:07:36>>>cash read=2F
2024-10-01 21:07:37>>>cash read=00
2024-10-01 21:07:38>>>cash read=2F29
2024-10-01 21:07:39>>>cash read=3E
2024-10-01 21:07:43>>>cash read=29
2024-10-01 21:07:43 >>>回调事件130,cash_status,20029,退钞中
2024-10-01 21:07:44>>>cash read=01
2024-10-01 21:07:48>>>cash read=3E
2024-10-01 21:07:55>>>cash read=00
2024-10-01 21:07:55>>>cash read=818F42
2024-10-01 21:07:55>>>cash write=02
2024-10-01 21:07:55 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-01 21:07:56>>>cash read=10
2024-10-01 21:07:56 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-01 21:07:56 当前产品价格10元，投币10元，打印小票中...
2024-10-01 21:07:56 >>>开始打印,排队号为210,订单号为2410012107560020079807
2024-10-01 21:07:56>>>订单2410012107560020079807写入成功,剩余空间为1679000,占用RAM为609.6298828125
删除未同步订单2410012107560020079807
2024-10-01 21:07:58>>>订单2410012107560020079807删除成功,剩余空间为1680000,占用RAM为618.6796875
检测订单目录中>>>
无未同步订单>>>
2024-10-01 21:07:58 >>>当前Ram内存为589.49609375
定时检测未同步订单启用
2024-10-01 21:07:59>>>cash write=0C
2024-10-01 21:07:59>>>cash read=3E


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