TLClient_JSSCOM_LuatOS-Air_V4010_RDA8910_RFTTS_0xe0000,2.5.4,861658065661251,23917015452620,
poweron reason:0

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

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

2024-09-28 09:20:05>>>cash write=0C
2024-09-28 09:20:05>>>cash read=3E
流量卡还有275天过期
2024-09-28 09:20:09 >>>当前Ram内存为618.947265625


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


===09:31:02===
2024-09-28 09:30:43>>>cash read=00
2024-09-28 09:30:44>>>cash read=29
2024-09-28 09:30:44 >>>回调事件130,cash_status,20029,退钞中
2024-09-28 09:30:44>>>cash read=2F29
2024-09-28 09:30:46>>>cash read=3E
2024-09-28 09:30:49>>>cash read=00
2024-09-28 09:30:49>>>cash read=2F29
2024-09-28 09:30:51>>>cash read=01
2024-09-28 09:30:52>>>cash read=2F
2024-09-28 09:30:53>>>cash read=3E
2024-09-28 09:30:57>>>cash read=00
2024-09-28 09:30:58>>>cash read=29
2024-09-28 09:30:58 >>>回调事件130,cash_status,20029,退钞中
2024-09-28 09:30:58>>>cash read=2F29
2024-09-28 09:31:00>>>cash read=3E


===09:32:03===
2024-09-28 09:31:02>>>cash read=00
2024-09-28 09:31:03>>>cash read=29
2024-09-28 09:31:03 >>>回调事件130,cash_status,20029,退钞中
2024-09-28 09:31:03>>>cash read=2F29
2024-09-28 09:31:05>>>cash read=3E
2024-09-28 09:31:16>>>cash read=00
2024-09-28 09:31:16>>>cash read=818F41
2024-09-28 09:31:16>>>cash write=02
2024-09-28 09:31:16 >>>回调事件130,cash_status,10022,进钞中...read money=5
2024-09-28 09:31:17>>>cash read=10
2024-09-28 09:31:17 >>>回调事件130,5,10023,finish Money=5,进钞完成
当日首次设置时间戳true为1727487077
2024-09-28 09:31:18>>>cash write=0C
2024-09-28 09:31:18>>>cash read=00
2024-09-28 09:31:18>>>cash read=818F41
2024-09-28 09:31:18>>>cash write=02
2024-09-28 09:31:18 >>>回调事件130,cash_status,10022,进钞中...read money=5
2024-09-28 09:31:19>>>cash read=10
2024-09-28 09:31:19 >>>回调事件130,5,10023,finish Money=5,进钞完成
2024-09-28 09:31:20>>>cash write=0C
2024-09-28 09:31:20>>>cash read=00
2024-09-28 09:31:21>>>cash read=818F41
2024-09-28 09:31:21>>>cash write=02
2024-09-28 09:31:21 >>>回调事件130,cash_status,10022,进钞中...read money=5
2024-09-28 09:31:22>>>cash read=10
2024-09-28 09:31:22 >>>回调事件130,5,10023,finish Money=5,进钞完成
2024-09-28 09:31:22 当前产品价格15元，投币15元，打印小票中...
2024-09-28 09:31:22 >>>开始打印,排队号为68,订单号为2409280931190022535221
2024-09-28 09:31:22>>>订单2409280931190022535221写入成功,剩余空间为1679000,占用RAM为608.2109375
删除未同步订单2409280931190022535221
2024-09-28 09:31:24>>>订单2409280931190022535221删除成功,剩余空间为1679500,占用RAM为622.556640625
检测订单目录中>>>
无未同步订单>>>
2024-09-28 09:31:24 >>>当前Ram内存为591.8193359375
定时检测未同步订单启用
2024-09-28 09:31:25>>>cash write=0C
2024-09-28 09:31:25>>>cash read=3E


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


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


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


===09:45:04===
2024-09-28 09:44:33 >>>回调事件[910,devices/TL2253]
2024-09-28 09:44:33 >>>故障排除日志:上一MQTT订单号缓存列表为24092809351682276362
2024-09-28 09:44:33 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 09:44:33 开始打印,排队:71,票券:2409280944281663659301,订单:24092809442816632417,[2024-09-28 09:44:32微信支付15元]
2024-09-28 09:44:35 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409280944281663659301","queue_number":71,"trade_uid":"24092809442816632417"}]}
2024-09-28 09:44:35 >>>故障排除日志:删除未同步下发订单成功24092809442816632417
2024-09-28 09:44:35 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 09:44:42 >>>回调事件[910,devices/TL2253]
2024-09-28 09:44:42 >>>故障排除日志:上一MQTT订单号缓存列表为24092809442816632417
2024-09-28 09:44:42 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 09:44:42 开始打印,排队:72,票券:2409280944363343598501,订单:24092809443633431765,[2024-09-28 09:44:42微信支付15元]
2024-09-28 09:44:44 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409280944363343598501","queue_number":72,"trade_uid":"24092809443633431765"}]}
2024-09-28 09:44:44 >>>故障排除日志:删除未同步下发订单成功24092809443633431765
2024-09-28 09:44:44 >>>故障排除日志:终端同步成功后剩余订单列表


===09:52:04===
2024-09-28 09:51:27 >>>回调事件[910,devices/TL2253]
2024-09-28 09:51:27 >>>故障排除日志:上一MQTT订单号缓存列表为24092809443633431765
2024-09-28 09:51:27 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 09:51:27 开始打印,排队:73,票券:2409280951191215121801,订单:24092809511912147819,[2024-09-28 09:51:26微信支付15元]
2024-09-28 09:51:29 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409280951191215121801","queue_number":73,"trade_uid":"24092809511912147819"}]}
2024-09-28 09:51:29 >>>故障排除日志:删除未同步下发订单成功24092809511912147819
2024-09-28 09:51:29 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 09:51:40 >>>剩余flash空间=1680500,占用RAM为610.9541015625
2024-09-28 09:51:40 >>>回调事件:905,callUart,10002,code(E3003F)


2024-09-28 09:51:40 >>>当前Ram内存为617.6318359375
2024-09-28 09:51:45 >>>剩余flash空间=1680500,占用RAM为630.591796875
2024-09-28 09:51:45 >>>回调事件:905,callUart,10002,code(E3003F)


2024-09-28 09:51:45 >>>当前Ram内存为639.12890625
2024-09-28 09:51:50 >>>剩余flash空间=1680000,占用RAM为638.103515625
2024-09-28 09:51:50 >>>回调事件:905,callUart,10002,code(E3003F)


2024-09-28 09:51:50 >>>当前Ram内存为645.697265625


===09:53:05===
2024-09-28 09:52:08>>>cash read=00
2024-09-28 09:52:09>>>cash read=29
2024-09-28 09:52:09 >>>回调事件130,cash_status,20029,退钞中
2024-09-28 09:52:09>>>cash read=2F29
2024-09-28 09:52:10>>>cash read=012F
2024-09-28 09:52:12>>>cash read=00
2024-09-28 09:52:13>>>cash read=292F29
2024-09-28 09:52:13 >>>回调事件130,cash_status,20029,退钞中
2024-09-28 09:52:14>>>cash read=3E
2024-09-28 09:52:16>>>cash read=00
2024-09-28 09:52:18>>>cash read=2F29
2024-09-28 09:52:20>>>cash read=3E
2024-09-28 09:52:23>>>cash read=00
2024-09-28 09:52:24>>>cash read=818F42
2024-09-28 09:52:24>>>cash write=02
2024-09-28 09:52:24 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-09-28 09:52:24>>>cash read=10
2024-09-28 09:52:24 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-09-28 09:52:25>>>cash write=0C
2024-09-28 09:52:26>>>cash read=3E
2024-09-28 09:52:30>>>cash read=00
2024-09-28 09:52:31>>>cash read=818F41
2024-09-28 09:52:31>>>cash write=02
2024-09-28 09:52:31 >>>回调事件130,cash_status,10022,进钞中...read money=5
2024-09-28 09:52:31>>>cash read=10
2024-09-28 09:52:31 >>>回调事件130,5,10023,finish Money=5,进钞完成
2024-09-28 09:52:31 当前产品价格15元，投币15元，打印小票中...
2024-09-28 09:52:31 >>>开始打印,排队号为74,订单号为2409280952240022537426
2024-09-28 09:52:31>>>订单2409280952240022537426写入成功,剩余空间为1679000,占用RAM为611.078125
删除未同步订单2409280952240022537426
2024-09-28 09:52:33>>>订单2409280952240022537426删除成功,剩余空间为1679500,占用RAM为621.9248046875
检测订单目录中>>>
无未同步订单>>>
2024-09-28 09:52:34 >>>当前Ram内存为592.5205078125
定时检测未同步订单启用
2024-09-28 09:52:35>>>cash write=0C
2024-09-28 09:52:35>>>cash read=3E


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


===10:06:05===
2024-09-28 10:05:18 >>>剩余flash空间=1682000,占用RAM为621.111328125
2024-09-28 10:05:18 >>>回调事件:905,callUart,10002,code(E3003F)


2024-09-28 10:05:18 >>>当前Ram内存为627.005859375
2024-09-28 10:05:28 >>>剩余flash空间=1681500,占用RAM为625.1298828125
2024-09-28 10:05:28 >>>回调事件:905,callUart,10002,code(E3003F)


2024-09-28 10:05:28 >>>当前Ram内存为630.123046875
2024-09-28 10:05:49 >>>回调事件[910,devices/TL2253]
2024-09-28 10:05:50 >>>故障排除日志:上一MQTT订单号缓存列表为24092809511912147819
2024-09-28 10:05:50 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 10:05:50 开始打印,排队:75,票券:2409281005440430355601,订单:24092810054404298806,[2024-09-28 10:05:50微信支付15元]
2024-09-28 10:05:52 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281005440430355601","queue_number":75,"trade_uid":"24092810054404298806"}]}
2024-09-28 10:05:52 >>>故障排除日志:删除未同步下发订单成功24092810054404298806
2024-09-28 10:05:52 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


===10:21:07===
2024-09-28 10:20:14 >>>剩余flash空间=1682000,占用RAM为613.52734375
2024-09-28 10:20:14 >>>回调事件:905,callUart,10002,code(E3003F)


2024-09-28 10:20:14 >>>当前Ram内存为619.3671875
2024-09-28 10:20:21 >>>剩余flash空间=1681500,占用RAM为624.2373046875
2024-09-28 10:20:21 >>>回调事件:905,callUart,10002,code(E3003F)


2024-09-28 10:20:21 >>>当前Ram内存为629.2900390625
2024-09-28 10:20:26 >>>剩余flash空间=1681000,占用RAM为630.0625
2024-09-28 10:20:26 >>>回调事件:905,callUart,10002,code(E3003F)


2024-09-28 10:20:26 >>>当前Ram内存为635.4619140625


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


===10:34:07===
2024-09-28 10:33:29 >>>剩余flash空间=1682000,占用RAM为613.5634765625
2024-09-28 10:33:30 >>>回调事件:905,callUart,10002,code(E3003F)


2024-09-28 10:33:30 >>>当前Ram内存为619.529296875


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


===10:37:08===
2024-09-28 10:36:24 >>>回调事件[910,devices/TL2253]
2024-09-28 10:36:24 >>>故障排除日志:上一MQTT订单号缓存列表为24092810353602634023
2024-09-28 10:36:24 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 10:36:24 开始打印,排队:83,票券:2409281036064371563201,订单:24092810360643710882,[2024-09-28 10:36:23微信支付15元]
2024-09-28 10:36:26 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281036064371563201","queue_number":83,"trade_uid":"24092810360643710882"}]}
2024-09-28 10:36:26 >>>故障排除日志:删除未同步下发订单成功24092810360643710882
2024-09-28 10:36:26 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 10:36:34 >>>剩余flash空间=1680500,占用RAM为644.185546875
2024-09-28 10:36:34 >>>回调事件:905,callUart,10002,code(E3003F)


2024-09-28 10:36:34 >>>当前Ram内存为650.857421875


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


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


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


===10:46:08===
2024-09-28 10:45:34 >>>剩余flash空间=1682000,占用RAM为611.7900390625
2024-09-28 10:45:34 >>>回调事件:905,callUart,10002,code(E3003F)


2024-09-28 10:45:34 >>>当前Ram内存为617.7197265625


===10:47:09===
2024-09-28 10:46:38 >>>剩余flash空间=1682000,占用RAM为648.1328125
2024-09-28 10:46:38 >>>回调事件:905,callUart,10002,code(E3003F)


2024-09-28 10:46:38 >>>当前Ram内存为617.234375
2024-09-28 10:47:00 >>>剩余flash空间=1681500,占用RAM为637.5830078125
2024-09-28 10:47:00 >>>回调事件:905,callUart,10002,code(E3003F)


2024-09-28 10:47:00 >>>当前Ram内存为644.166015625


===10:48:09===
2024-09-28 10:47:27 >>>剩余flash空间=1682000,占用RAM为640.1787109375
2024-09-28 10:47:27 >>>回调事件:905,callUart,10002,code(E3003F)


2024-09-28 10:47:27 >>>当前Ram内存为644.546875


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


===11:00:09===
2024-09-28 10:59:39 >>>剩余flash空间=1682000,占用RAM为644.869140625
2024-09-28 10:59:39 >>>回调事件:905,callUart,10002,code(E3003F)


2024-09-28 10:59:39 >>>当前Ram内存为650.6826171875


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


===11:09:10===
2024-09-28 11:08:30 >>>剩余flash空间=1682000,占用RAM为643.009765625
2024-09-28 11:08:30 >>>回调事件:905,callUart,10002,code(E3003F)


2024-09-28 11:08:30 >>>当前Ram内存为648.7939453125


===11:11:10===
2024-09-28 11:10:25 >>>剩余flash空间=1682000,占用RAM为641.4130859375
2024-09-28 11:10:25 >>>回调事件:905,callUart,10002,code(E3003F)


2024-09-28 11:10:25 >>>当前Ram内存为647.3427734375


===11:18:11===
2024-09-28 11:17:42 >>>剩余flash空间=1682000,占用RAM为633.55078125
2024-09-28 11:17:42 >>>回调事件:905,callUart,10002,code(E3003F)


2024-09-28 11:17:42 >>>当前Ram内存为639.470703125


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


===11:38:11===
2024-09-28 11:38:00 >>>剩余flash空间=1682000,占用RAM为638.2060546875
2024-09-28 11:38:00 >>>回调事件:905,callUart,10002,code(E3003F)


2024-09-28 11:38:00 >>>当前Ram内存为644.10546875
2024-09-28 11:38:05 >>>剩余flash空间=1681500,占用RAM为630.7255859375
2024-09-28 11:38:05 >>>回调事件:905,callUart,10002,code(E3003F)


2024-09-28 11:38:05 >>>当前Ram内存为635.720703125


===11:39:12===
2024-09-28 11:38:14 >>>剩余flash空间=1682000,占用RAM为624.11328125
2024-09-28 11:38:14 >>>回调事件:905,callUart,10002,code(E3003F)


2024-09-28 11:38:15 >>>当前Ram内存为629.833984375


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


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


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


===12:35:13===
2024-09-28 12:34:19 >>>剩余flash空间=1682000,占用RAM为641.4541015625
2024-09-28 12:34:19 >>>回调事件:905,callUart,10002,code(E3003F)


2024-09-28 12:34:19 >>>当前Ram内存为647.3837890625
2024-09-28 12:34:24 >>>剩余flash空间=1681500,占用RAM为630.8349609375
2024-09-28 12:34:24 >>>回调事件:905,callUart,10002,code(E3003F)


2024-09-28 12:34:24 >>>当前Ram内存为637.1025390625
2024-09-28 12:34:29 >>>剩余flash空间=1681000,占用RAM为628.26953125
2024-09-28 12:34:29 >>>回调事件:905,callUart,10002,code(E3003F)


2024-09-28 12:34:29 >>>当前Ram内存为633.88671875
2024-09-28 12:34:34 >>>剩余flash空间=1680500,占用RAM为625.560546875
2024-09-28 12:34:34 >>>回调事件:905,callUart,10002,code(E3003F)


2024-09-28 12:34:34 >>>当前Ram内存为631.390625


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


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


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


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


===13:28:14===
2024-09-28 13:27:29 >>>剩余flash空间=1682000,占用RAM为649.9970703125
2024-09-28 13:27:29 >>>回调事件:905,128,20000,cg

2024-09-28 13:27:29 >>>当前Ram内存为614.68359375
2024-09-28 13:27:30 >>>剩余flash空间=1681500,占用RAM为604.4833984375
2024-09-28 13:27:30 >>>回调事件:911,EmplQrCheck,500,

员工二维码验票结果为500,


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


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


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


===13:50:15===
2024-09-28 13:49:20 >>>剩余flash空间=1682000,占用RAM为633.353515625
2024-09-28 13:49:20 >>>回调事件:905,callUart,10002,code(E3003F)


2024-09-28 13:49:20 >>>当前Ram内存为639.2783203125
2024-09-28 13:49:24 >>>剩余flash空间=1681500,占用RAM为647.1533203125
2024-09-28 13:49:24 >>>回调事件:905,callUart,10002,code(E3003F)


2024-09-28 13:49:24 >>>当前Ram内存为609.2080078125
2024-09-28 13:49:41 >>>剩余flash空间=1681000,占用RAM为623.78515625
2024-09-28 13:49:41 >>>回调事件:905,callUart,10002,code(E3003F)


2024-09-28 13:49:41 >>>当前Ram内存为630.5888671875
2024-09-28 13:49:46 >>>剩余flash空间=1680500,占用RAM为627.5576171875
2024-09-28 13:49:46 >>>回调事件:905,callUart,10002,code(E3003F)


2024-09-28 13:49:46 >>>当前Ram内存为633.5419921875
2024-09-28 13:49:50 >>>剩余flash空间=1680500,占用RAM为630.626953125
2024-09-28 13:49:50 >>>回调事件:905,callUart,10002,code(E3003F)


2024-09-28 13:49:50 >>>当前Ram内存为617.5986328125
2024-09-28 13:49:55 >>>剩余flash空间=1680000,占用RAM为633.921875
2024-09-28 13:49:55 >>>回调事件:905,callUart,10002,code(E3003F)


2024-09-28 13:49:55 >>>当前Ram内存为640.6513671875
2024-09-28 13:50:04 >>>剩余flash空间=1680000,占用RAM为648.0888671875
2024-09-28 13:50:04 >>>回调事件:905,callUart,10002,code(E3003F)


2024-09-28 13:50:04 >>>当前Ram内存为610.3583984375


===13:54:16===
2024-09-28 13:53:38 >>>剩余flash空间=1682000,占用RAM为646.6025390625
2024-09-28 13:53:38 >>>回调事件:905,callUart,10002,code(E3003F)


2024-09-28 13:53:38 >>>当前Ram内存为609.28515625


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


===14:12:16===
2024-09-28 14:11:45 >>>回调事件[910,devices/TL2253]
2024-09-28 14:11:45 >>>故障排除日志:上一MQTT订单号缓存列表为24092814012105952467
2024-09-28 14:11:45 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 14:11:45 开始打印,排队:100,票券:2409281411388625297201,订单:24092814113886248918,[2024-09-28 14:11:45微信支付15元]
2024-09-28 14:11:47 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281411388625297201","queue_number":100,"trade_uid":"24092814113886248918"}]}
2024-09-28 14:11:47 >>>故障排除日志:删除未同步下发订单成功24092814113886248918
2024-09-28 14:11:47 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 14:11:53 >>>剩余flash空间=1680500,占用RAM为623.9716796875
2024-09-28 14:11:53 >>>回调事件:905,callUart,10002,code(E3003F)


2024-09-28 14:11:53 >>>当前Ram内存为630.638671875
2024-09-28 14:11:58 >>>剩余flash空间=1680500,占用RAM为635.4462890625
2024-09-28 14:11:58 >>>回调事件:905,callUart,10002,code(E3003F)


2024-09-28 14:11:58 >>>当前Ram内存为643.791015625


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


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


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


===14:53:18===
2024-09-28 14:53:14 >>>回调事件[910,devices/TL2253]
2024-09-28 14:53:14 >>>故障排除日志:上一MQTT订单号缓存列表为24092814460063286912
2024-09-28 14:53:14 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 14:53:14 开始打印,排队:104,票券:2409281453073749712601,订单:24092814530737491684,[2024-09-28 14:53:14微信支付15元]


===14:54:18===
2024-09-28 14:53:16 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281453073749712601","queue_number":104,"trade_uid":"24092814530737491684"}]}
2024-09-28 14:53:16 >>>故障排除日志:删除未同步下发订单成功24092814530737491684
2024-09-28 14:53:17 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 14:53:21 >>>剩余flash空间=1681500,占用RAM为626.0458984375
2024-09-28 14:53:21 >>>回调事件:905,callUart,10002,code(E3003F)


2024-09-28 14:53:21 >>>当前Ram内存为631.611328125
2024-09-28 14:53:24 >>>剩余flash空间=1680500,占用RAM为631.8369140625
2024-09-28 14:53:24 >>>回调事件:905,callUart,10002,code(E3003F)


2024-09-28 14:53:24 >>>当前Ram内存为637.8583984375
2024-09-28 14:53:27 >>>剩余flash空间=1680500,占用RAM为635.4375
2024-09-28 14:53:27 >>>回调事件:905,callUart,10002,code(E3003F)


2024-09-28 14:53:27 >>>当前Ram内存为643.052734375
2024-09-28 14:53:33 >>>剩余flash空间=1680500,占用RAM为640.4208984375
2024-09-28 14:53:33 >>>回调事件:905,callUart,10002,code(E3003F)


2024-09-28 14:53:33 >>>当前Ram内存为649.0546875


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


===14:59:19===
2024-09-28 14:59:00 >>>剩余flash空间=1682000,占用RAM为614.806640625
2024-09-28 14:59:00 >>>回调事件:905,callUart,10002,code(E3003F)


2024-09-28 14:59:00 >>>当前Ram内存为620.6630859375
2024-09-28 14:59:05 >>>剩余flash空间=1681500,占用RAM为628.63671875
2024-09-28 14:59:05 >>>回调事件:905,callUart,10002,code(E3003F)


2024-09-28 14:59:05 >>>当前Ram内存为631.693359375
2024-09-28 14:59:12 >>>剩余flash空间=1681000,占用RAM为632.0224609375
2024-09-28 14:59:12 >>>回调事件:905,callUart,10002,code(E3003F)


2024-09-28 14:59:12 >>>当前Ram内存为637.072265625


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


===15:05:19===
2024-09-28 15:04:58 >>>剩余flash空间=1682000,占用RAM为622.58203125
2024-09-28 15:04:58 >>>回调事件:905,callUart,10002,code(E3003F)


2024-09-28 15:04:58 >>>当前Ram内存为628.505859375


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


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


===15:52:20===
2024-09-28 15:51:21 >>>回调事件[910,devices/TL2253]
2024-09-28 15:51:21 >>>故障排除日志:上一MQTT订单号缓存列表为24092815392723810359
2024-09-28 15:51:21 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 15:51:21 开始打印,排队:109,票券:2409281551100169007401,订单:24092815511001685576,[2024-09-28 15:51:20微信支付15元]
2024-09-28 15:51:23 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281551100169007401","queue_number":109,"trade_uid":"24092815511001685576"}]}
2024-09-28 15:51:23 >>>故障排除日志:删除未同步下发订单成功24092815511001685576
2024-09-28 15:51:23 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 15:51:30 >>>回调事件[910,devices/TL2253]
2024-09-28 15:51:30 >>>故障排除日志:上一MQTT订单号缓存列表为24092815511001685576
2024-09-28 15:51:30 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 15:51:30 开始打印,排队:110,票券:2409281551245598637601,订单:24092815512455982126,[2024-09-28 15:51:30微信支付15元]
2024-09-28 15:51:32 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281551245598637601","queue_number":110,"trade_uid":"24092815512455982126"}]}
2024-09-28 15:51:32 >>>故障排除日志:删除未同步下发订单成功24092815512455982126
2024-09-28 15:51:32 >>>故障排除日志:终端同步成功后剩余订单列表


===16:04:21===
2024-09-28 16:03:43 >>>剩余flash空间=1682000,占用RAM为613.265625
2024-09-28 16:03:43 >>>回调事件:905,callUart,10002,code(E3003F)


2024-09-28 16:03:43 >>>当前Ram内存为619.03125
2024-09-28 16:03:46 >>>剩余flash空间=1681500,占用RAM为644.30859375
2024-09-28 16:03:46 >>>回调事件:905,callUart,10002,code(E3003F)


2024-09-28 16:03:46 >>>当前Ram内存为612.4208984375
2024-09-28 16:03:50 >>>剩余flash空间=1681500,占用RAM为641.921875
2024-09-28 16:03:50 >>>回调事件:905,callUart,10002,code(E3003F)


2024-09-28 16:03:50 >>>当前Ram内存为623.71484375
2024-09-28 16:03:52 >>>剩余flash空间=1680500,占用RAM为602.857421875
2024-09-28 16:03:52 >>>回调事件:905,callUart,10002,code(E3003F)


2024-09-28 16:03:52 >>>当前Ram内存为609


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


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


===16:26:22===
2024-09-28 16:25:29 >>>回调事件[910,devices/TL2253]
2024-09-28 16:25:29 >>>故障排除日志:上一MQTT订单号缓存列表为24092816242450928239
2024-09-28 16:25:29 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 16:25:29 开始打印,排队:113,票券:2409281625227490286401,订单:24092816252274893953,[2024-09-28 16:25:29微信支付15元]
2024-09-28 16:25:29 开始打印,排队:114,票券:2409281625227490481902,订单:24092816252274893953,[2024-09-28 16:25:29微信支付15元]
2024-09-28 16:25:29 开始打印,排队:115,票券:2409281625227490582303,订单:24092816252274893953,[2024-09-28 16:25:29微信支付15元]
2024-09-28 16:25:36 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281625227490286401","queue_number":113,"trade_uid":"24092816252274893953"},{"ticket_no":"2409281625227490481902","queue_number":114,"trade_uid":"24092816252274893953"},{"ticket_no":"2409281625227490582303","queue_number":115,"trade_uid":"24092816252274893953"}]}
2024-09-28 16:25:36 >>>故障排除日志:删除未同步下发订单成功24092816252274893953
2024-09-28 16:25:36 >>>故障排除日志:删除未同步下发订单成功24092816252274893953
2024-09-28 16:25:36 >>>故障排除日志:删除未同步下发订单成功24092816252274893953
2024-09-28 16:25:36 >>>故障排除日志:终端同步成功后剩余订单列表


===16:33:22===
2024-09-28 16:32:52 >>>回调事件[910,devices/TL2253]
2024-09-28 16:32:52 >>>故障排除日志:上一MQTT订单号缓存列表为24092816252274893953|24092816252274893953|24092816252274893953
2024-09-28 16:32:52 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 16:32:52 开始打印,排队:116,票券:2409281632446586182501,订单:24092816324465858030,[2024-09-28 16:32:51微信支付15元]
2024-09-28 16:32:54 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281632446586182501","queue_number":116,"trade_uid":"24092816324465858030"}]}
2024-09-28 16:32:54 >>>故障排除日志:删除未同步下发订单成功24092816324465858030
2024-09-28 16:32:54 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 16:33:07 >>>剩余flash空间=1680500,占用RAM为634.552734375
2024-09-28 16:33:07 >>>回调事件:905,callUart,10002,code(E3003F)


2024-09-28 16:33:07 >>>当前Ram内存为614.0732421875
2024-09-28 16:33:10 >>>剩余flash空间=1680500,占用RAM为635.78515625
2024-09-28 16:33:10 >>>回调事件:905,callUart,10002,code(E3003F)


2024-09-28 16:33:10 >>>当前Ram内存为644.0615234375
2024-09-28 16:33:17 >>>剩余flash空间=1680000,占用RAM为617.6708984375
2024-09-28 16:33:17 >>>回调事件:905,callUart,10002,code(E3003F)


2024-09-28 16:33:17 >>>当前Ram内存为626.876953125


===16:34:23===
2024-09-28 16:33:25 >>>剩余flash空间=1682000,占用RAM为649.71875
2024-09-28 16:33:25 >>>回调事件:905,callUart,10002,code(E3003F)


2024-09-28 16:33:25 >>>当前Ram内存为610.4814453125
2024-09-28 16:33:31 >>>剩余flash空间=1681500,占用RAM为644.1845703125
2024-09-28 16:33:31 >>>回调事件:905,callUart,10002,code(E3003F)


2024-09-28 16:33:31 >>>当前Ram内存为626.02734375
2024-09-28 16:33:48 >>>剩余flash空间=1681500,占用RAM为645.2900390625
2024-09-28 16:33:48 >>>回调事件:905,callUart,10002,code(E3003F)


2024-09-28 16:33:48 >>>当前Ram内存为643.8037109375


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


===16:57:23===
2024-09-28 16:56:31 >>>回调事件[910,devices/TL2253]
2024-09-28 16:56:32 >>>故障排除日志:上一MQTT订单号缓存列表为24092816483578177104|24092816483578177104
2024-09-28 16:56:32 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 16:56:32 开始打印,排队:119,票券:2409281656255754724201,订单:24092816562557543219,[2024-09-28 16:56:31微信支付15元]
2024-09-28 16:56:33 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281656255754724201","queue_number":119,"trade_uid":"24092816562557543219"}]}
2024-09-28 16:56:33 >>>故障排除日志:删除未同步下发订单成功24092816562557543219
2024-09-28 16:56:34 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


===17:12:24===
2024-09-28 17:11:27 >>>回调事件[910,devices/TL2253]
2024-09-28 17:11:27 >>>故障排除日志:上一MQTT订单号缓存列表为24092817090896337294
2024-09-28 17:11:27 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 17:11:27 开始打印,排队:123,票券:2409281711230975943401,订单:24092817112309754432,[2024-09-28 17:11:27微信支付15元]
2024-09-28 17:11:29 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281711230975943401","queue_number":123,"trade_uid":"24092817112309754432"}]}
2024-09-28 17:11:29 >>>故障排除日志:删除未同步下发订单成功24092817112309754432
2024-09-28 17:11:29 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 17:12:01 >>>剩余flash空间=1680500,占用RAM为645.0712890625
2024-09-28 17:12:01 >>>回调事件:905,callUart,10002,code(E3003F)


2024-09-28 17:12:01 >>>当前Ram内存为641.7568359375
2024-09-28 17:12:10 >>>剩余flash空间=1680500,占用RAM为619.05078125
2024-09-28 17:12:10 >>>回调事件:905,callUart,10002,code(E3003F)


2024-09-28 17:12:10 >>>当前Ram内存为627.650390625
2024-09-28 17:12:14 >>>剩余flash空间=1680000,占用RAM为646.921875
2024-09-28 17:12:14 >>>回调事件:905,callUart,10002,code(E3003F)


2024-09-28 17:12:14 >>>当前Ram内存为614.4521484375


===17:21:24===
2024-09-28 17:21:09 >>>回调事件[910,devices/TL2253]
2024-09-28 17:21:09 >>>故障排除日志:上一MQTT订单号缓存列表为24092817112309754432
2024-09-28 17:21:09 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 17:21:09 开始打印,排队:124,票券:2409281721001166925301,订单:24092817210011663401,[2024-09-28 17:21:08微信支付15元]
2024-09-28 17:21:09 开始打印,排队:125,票券:2409281721001167149702,订单:24092817210011663401,[2024-09-28 17:21:08微信支付15元]
2024-09-28 17:21:09 开始打印,排队:126,票券:2409281721001167245803,订单:24092817210011663401,[2024-09-28 17:21:08微信支付15元]
2024-09-28 17:21:14 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281721001166925301","queue_number":124,"trade_uid":"24092817210011663401"},{"ticket_no":"2409281721001167149702","queue_number":125,"trade_uid":"24092817210011663401"},{"ticket_no":"2409281721001167245803","queue_number":126,"trade_uid":"24092817210011663401"}]}
2024-09-28 17:21:14 >>>故障排除日志:删除未同步下发订单成功24092817210011663401
2024-09-28 17:21:14 >>>故障排除日志:删除未同步下发订单成功24092817210011663401
2024-09-28 17:21:14 >>>故障排除日志:删除未同步下发订单成功24092817210011663401
2024-09-28 17:21:14 >>>故障排除日志:终端同步成功后剩余订单列表


===17:31:25===
2024-09-28 17:31:00 >>>回调事件[910,devices/TL2253]
2024-09-28 17:31:00 >>>故障排除日志:上一MQTT订单号缓存列表为24092817210011663401|24092817210011663401|24092817210011663401
2024-09-28 17:31:00 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 17:31:00 开始打印,排队:127,票券:2409281730495653355201,订单:24092817304956527953,[2024-09-28 17:30:59微信支付15元]
2024-09-28 17:31:02 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281730495653355201","queue_number":127,"trade_uid":"24092817304956527953"}]}
2024-09-28 17:31:02 >>>故障排除日志:删除未同步下发订单成功24092817304956527953
2024-09-28 17:31:02 >>>故障排除日志:终端同步成功后剩余订单列表


===17:32:25===
2024-09-28 17:31:28 >>>剩余flash空间=1682000,占用RAM为628.9140625
2024-09-28 17:31:28 >>>回调事件:905,callUart,10002,code(E3003F)


2024-09-28 17:31:28 >>>当前Ram内存为633.0830078125
2024-09-28 17:31:41 >>>剩余flash空间=1681500,占用RAM为643.08203125
2024-09-28 17:31:41 >>>回调事件:905,callUart,10002,code(E3003F)


2024-09-28 17:31:41 >>>当前Ram内存为649.5244140625


===17:44:26===
2024-09-28 17:43:27 >>>剩余flash空间=1682000,占用RAM为615.3857421875
2024-09-28 17:43:27 >>>回调事件:905,callUart,10002,code(E3003F)


2024-09-28 17:43:27 >>>当前Ram内存为621.2470703125
2024-09-28 17:43:36 >>>剩余flash空间=1681500,占用RAM为626.4296875
2024-09-28 17:43:36 >>>回调事件:905,callUart,10002,code(E3003F)


2024-09-28 17:43:36 >>>当前Ram内存为631.3359375


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


===17:54:26===
2024-09-28 17:54:22 >>>剩余flash空间=1682000,占用RAM为630.279296875
2024-09-28 17:54:22 >>>回调事件:905,callUart,10002,code(E3003F)


2024-09-28 17:54:22 >>>当前Ram内存为636.2080078125


===17:55:26===
2024-09-28 17:54:26 >>>剩余flash空间=1682000,占用RAM为645.4541015625
2024-09-28 17:54:26 >>>回调事件:905,callUart,10002,code(E3003F)


2024-09-28 17:54:26 >>>当前Ram内存为609.2705078125
2024-09-28 17:54:32 >>>剩余flash空间=1681500,占用RAM为643.173828125
2024-09-28 17:54:32 >>>回调事件:905,callUart,10002,code(E3003F)


2024-09-28 17:54:32 >>>当前Ram内存为649.466796875
2024-09-28 17:54:44 >>>剩余flash空间=1681000,占用RAM为611.9052734375
2024-09-28 17:54:44 >>>回调事件:905,callUart,10002,code(E3003F)


2024-09-28 17:54:44 >>>当前Ram内存为618.8369140625
2024-09-28 17:54:50 >>>剩余flash空间=1680500,占用RAM为616.97265625
2024-09-28 17:54:50 >>>回调事件:905,callUart,10002,code(E3003F)


2024-09-28 17:54:51 >>>当前Ram内存为623.2607421875


===18:04:27===
2024-09-28 18:03:36 >>>回调事件[910,devices/TL2253]
2024-09-28 18:03:36 >>>故障排除日志:上一MQTT订单号缓存列表为24092817452747480954
2024-09-28 18:03:36 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 18:03:36 开始打印,排队:129,票券:2409281803320770508401,订单:24092818033207700317,[2024-09-28 18:03:36支付宝支付15元]
2024-09-28 18:03:38 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281803320770508401","queue_number":129,"trade_uid":"24092818033207700317"}]}
2024-09-28 18:03:38 >>>故障排除日志:删除未同步下发订单成功24092818033207700317
2024-09-28 18:03:39 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 18:04:13 >>>回调事件[910,devices/TL2253]
2024-09-28 18:04:14 >>>故障排除日志:上一MQTT订单号缓存列表为24092818033207700317
2024-09-28 18:04:14 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 18:04:14 开始打印,排队:130,票券:2409281803589345105401,订单:24092818035893447503,[2024-09-28 18:04:13微信支付15元]
2024-09-28 18:04:16 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281803589345105401","queue_number":130,"trade_uid":"24092818035893447503"}]}
2024-09-28 18:04:16 >>>故障排除日志:删除未同步下发订单成功24092818035893447503
2024-09-28 18:04:16 >>>故障排除日志:终端同步成功后剩余订单列表


===18:07:27===
2024-09-28 18:06:36 >>>剩余flash空间=1682000,占用RAM为636.2431640625
2024-09-28 18:06:36 >>>回调事件:905,callUart,10002,code(E3003F)


2024-09-28 18:06:36 >>>当前Ram内存为642.146484375
2024-09-28 18:06:47 >>>剩余flash空间=1681500,占用RAM为645.0791015625
2024-09-28 18:06:47 >>>回调事件:905,callUart,10002,code(E3003F)


2024-09-28 18:06:47 >>>当前Ram内存为641.9814453125
2024-09-28 18:06:56 >>>回调事件[910,devices/TL2253]
2024-09-28 18:06:56 >>>故障排除日志:上一MQTT订单号缓存列表为24092818035893447503
2024-09-28 18:06:56 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 18:06:56 开始打印,排队:131,票券:2409281806494414574001,订单:24092818064944141525,[2024-09-28 18:06:56微信支付15元]
2024-09-28 18:06:58 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281806494414574001","queue_number":131,"trade_uid":"24092818064944141525"}]}
2024-09-28 18:06:58 >>>故障排除日志:删除未同步下发订单成功24092818064944141525
2024-09-28 18:06:58 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 18:07:03 >>>剩余flash空间=1680000,占用RAM为640.869140625
2024-09-28 18:07:03 >>>回调事件:905,callUart,10001,code(E300FC)


2024-09-28 18:07:03 >>>当前Ram内存为650.18359375


===18:12:27===
2024-09-28 18:12:12>>>cash read=0A
2024-09-28 18:12:13>>>cash read=3E


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


===18:25:28===
2024-09-28 18:24:59 >>>回调事件[910,devices/TL2253]
2024-09-28 18:24:59 >>>故障排除日志:上一MQTT订单号缓存列表为24092818204097281527
2024-09-28 18:24:59 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 18:24:59 开始打印,排队:133,票券:2409281824532518741501,订单:24092818245325182051,[2024-09-28 18:24:59微信支付15元]
2024-09-28 18:25:01 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281824532518741501","queue_number":133,"trade_uid":"24092818245325182051"}]}
2024-09-28 18:25:01 >>>故障排除日志:删除未同步下发订单成功24092818245325182051
2024-09-28 18:25:01 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 18:25:17 >>>剩余flash空间=1680500,占用RAM为624.1220703125
2024-09-28 18:25:17 >>>回调事件:905,callUart,10002,code(E3003F)


2024-09-28 18:25:17 >>>当前Ram内存为630.6220703125


===18:26:28===
2024-09-28 18:25:30 >>>剩余flash空间=1682000,占用RAM为639.654296875
2024-09-28 18:25:30 >>>回调事件:905,callUart,10002,code(E3003F)


2024-09-28 18:25:30 >>>当前Ram内存为645.1904296875
2024-09-28 18:25:49 >>>剩余flash空间=1681500,占用RAM为611.79296875
2024-09-28 18:25:49 >>>回调事件:905,callUart,10002,code(E3003F)


2024-09-28 18:25:49 >>>当前Ram内存为618.404296875
2024-09-28 18:26:01 >>>剩余flash空间=1681000,占用RAM为632.9921875
2024-09-28 18:26:01 >>>回调事件:905,callUart,10002,code(E3003F)


2024-09-28 18:26:01 >>>当前Ram内存为639.8779296875


===18:29:28===
2024-09-28 18:28:36 >>>回调事件[910,devices/TL2253]
2024-09-28 18:28:36 >>>故障排除日志:上一MQTT订单号缓存列表为24092818245325182051
2024-09-28 18:28:36 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 18:28:36 开始打印,排队:134,票券:2409281828297967145601,订单:24092818282979667745,[2024-09-28 18:28:35微信支付15元]
2024-09-28 18:28:36 开始打印,排队:135,票券:2409281828297967289002,订单:24092818282979667745,[2024-09-28 18:28:35微信支付15元]
2024-09-28 18:28:39 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281828297967145601","queue_number":134,"trade_uid":"24092818282979667745"},{"ticket_no":"2409281828297967289002","queue_number":135,"trade_uid":"24092818282979667745"}]}
2024-09-28 18:28:40 >>>故障排除日志:删除未同步下发订单成功24092818282979667745
2024-09-28 18:28:40 >>>故障排除日志:删除未同步下发订单成功24092818282979667745
2024-09-28 18:28:40 >>>故障排除日志:终端同步成功后剩余订单列表


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


===18:38:29===
2024-09-28 18:37:55>>>cash read=00
2024-09-28 18:37:56>>>cash read=818F42
2024-09-28 18:37:56>>>cash write=02
2024-09-28 18:37:56 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-09-28 18:37:56>>>cash read=10
2024-09-28 18:37:56 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-09-28 18:37:58>>>cash write=0C
2024-09-28 18:37:58>>>cash read=3E
2024-09-28 18:38:01>>>cash read=00
2024-09-28 18:38:02>>>cash read=818F41
2024-09-28 18:38:02>>>cash write=02
2024-09-28 18:38:02 >>>回调事件130,cash_status,10022,进钞中...read money=5
2024-09-28 18:38:03>>>cash read=10
2024-09-28 18:38:03 >>>回调事件130,5,10023,finish Money=5,进钞完成
2024-09-28 18:38:03 当前产品价格15元，投币15元，打印小票中...
2024-09-28 18:38:03 >>>开始打印,排队号为137,订单号为2409281837560022533371
2024-09-28 18:38:03>>>订单2409281837560022533371写入成功,剩余空间为1679500,占用RAM为605.6083984375
删除未同步订单2409281837560022533371
2024-09-28 18:38:05>>>订单2409281837560022533371删除成功,剩余空间为1680000,占用RAM为618.1142578125
检测订单目录中>>>
无未同步订单>>>
2024-09-28 18:38:05 >>>当前Ram内存为589.314453125
定时检测未同步订单启用
2024-09-28 18:38:06>>>cash write=0C
2024-09-28 18:38:06>>>cash read=3E


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


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


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


===18:47:30===
2024-09-28 18:47:10 >>>剩余flash空间=1682000,占用RAM为616.4384765625
2024-09-28 18:47:10 >>>回调事件:905,callUart,10002,code(E3003F)


2024-09-28 18:47:10 >>>当前Ram内存为622.3720703125


===18:48:30===
2024-09-28 18:47:29 >>>剩余flash空间=1682000,占用RAM为611.955078125
2024-09-28 18:47:29 >>>回调事件:905,callUart,10002,code(E3003F)


2024-09-28 18:47:29 >>>当前Ram内存为616.2412109375
2024-09-28 18:47:37 >>>剩余flash空间=1681500,占用RAM为645.134765625
2024-09-28 18:47:37 >>>回调事件:905,callUart,10002,code(E3003F)


2024-09-28 18:47:37 >>>当前Ram内存为606.7158203125
2024-09-28 18:47:54 >>>回调事件[910,devices/TL2253]
2024-09-28 18:47:54 >>>故障排除日志:上一MQTT订单号缓存列表为24092818313336105381
2024-09-28 18:47:54 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 18:47:54 开始打印,排队:139,票券:2409281847457866890101,订单:24092818474578664659,[2024-09-28 18:47:54微信支付15元]
2024-09-28 18:47:56 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281847457866890101","queue_number":139,"trade_uid":"24092818474578664659"}]}
2024-09-28 18:47:56 >>>故障排除日志:删除未同步下发订单成功24092818474578664659
2024-09-28 18:47:56 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 18:48:19 >>>剩余flash空间=1680000,占用RAM为616.5537109375
2024-09-28 18:48:19 >>>回调事件:905,callUart,10002,code(E3003F)


2024-09-28 18:48:19 >>>当前Ram内存为624.4267578125
2024-09-28 18:48:24 >>>剩余flash空间=1680000,占用RAM为632.9306640625
2024-09-28 18:48:25 >>>回调事件:905,callUart,10002,code(E3003F)


2024-09-28 18:48:25 >>>当前Ram内存为642.6259765625


===18:49:31===
2024-09-28 18:48:30 >>>剩余flash空间=1682000,占用RAM为646.0390625
2024-09-28 18:48:30 >>>回调事件:905,callUart,10002,code(E3003F)


2024-09-28 18:48:30 >>>当前Ram内存为610.79296875
2024-09-28 18:48:36 >>>剩余flash空间=1681500,占用RAM为636.7041015625
2024-09-28 18:48:36 >>>回调事件:905,callUart,10001,code(E300FC)


2024-09-28 18:48:36 >>>当前Ram内存为641.5771484375


===18:55:31===
2024-09-28 18:55:14 >>>剩余flash空间=1682000,占用RAM为648.7001953125
2024-09-28 18:55:14 >>>回调事件:905,callUart,10002,code(E3003F)


2024-09-28 18:55:14 >>>当前Ram内存为607.5908203125


===18:57:31===
2024-09-28 18:57:04 >>>回调事件[910,devices/TL2253]
2024-09-28 18:57:04 >>>故障排除日志:上一MQTT订单号缓存列表为24092818474578664659
2024-09-28 18:57:04 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 18:57:04 开始打印,排队:140,票券:2409281856571841867501,订单:24092818565718414596,[2024-09-28 18:57:03微信支付15元]
2024-09-28 18:57:06 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281856571841867501","queue_number":140,"trade_uid":"24092818565718414596"}]}
2024-09-28 18:57:06 >>>故障排除日志:删除未同步下发订单成功24092818565718414596
2024-09-28 18:57:06 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 18:57:25 >>>剩余flash空间=1680500,占用RAM为626.2021484375
2024-09-28 18:57:25 >>>回调事件:905,callUart,10002,code(E3003F)


2024-09-28 18:57:25 >>>当前Ram内存为634.359375


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


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


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


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


===19:27:33===
2024-09-28 19:26:41 >>>回调事件[910,devices/TL2253]
2024-09-28 19:26:41 >>>故障排除日志:上一MQTT订单号缓存列表为24092819243029303994
2024-09-28 19:26:41 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 19:26:41 开始打印,排队:145,票券:2409281926350480630901,订单:24092819263504802576,[2024-09-28 19:26:41微信支付15元]
2024-09-28 19:26:41 开始打印,排队:146,票券:2409281926350480788102,订单:24092819263504802576,[2024-09-28 19:26:41微信支付15元]
2024-09-28 19:26:45 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281926350480630901","queue_number":145,"trade_uid":"24092819263504802576"},{"ticket_no":"2409281926350480788102","queue_number":146,"trade_uid":"24092819263504802576"}]}
2024-09-28 19:26:45 >>>故障排除日志:删除未同步下发订单成功24092819263504802576
2024-09-28 19:26:45 >>>故障排除日志:删除未同步下发订单成功24092819263504802576
2024-09-28 19:26:45 >>>故障排除日志:终端同步成功后剩余订单列表


===19:31:33===
2024-09-28 19:31:21 >>>回调事件[910,devices/TL2253]
2024-09-28 19:31:21 >>>故障排除日志:上一MQTT订单号缓存列表为24092819263504802576|24092819263504802576
2024-09-28 19:31:21 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 19:31:21 开始打印,排队:147,票券:2409281931162997815301,订单:24092819311629974650,[2024-09-28 19:31:21微信支付15元]
2024-09-28 19:31:23 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281931162997815301","queue_number":147,"trade_uid":"24092819311629974650"}]}
2024-09-28 19:31:23 >>>故障排除日志:删除未同步下发订单成功24092819311629974650
2024-09-28 19:31:24 >>>故障排除日志:终端同步成功后剩余订单列表


===19:40:34===
2024-09-28 19:39:34 >>>回调事件[910,devices/TL2253]
2024-09-28 19:39:34 >>>故障排除日志:上一MQTT订单号缓存列表为24092819311629974650
2024-09-28 19:39:34 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 19:39:34 开始打印,排队:148,票券:2409281939289332497901,订单:24092819392893317463,[2024-09-28 19:39:34微信支付15元]
2024-09-28 19:39:36 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281939289332497901","queue_number":148,"trade_uid":"24092819392893317463"}]}
2024-09-28 19:39:36 >>>故障排除日志:删除未同步下发订单成功24092819392893317463
2024-09-28 19:39:36 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 19:40:03 >>>回调事件[910,devices/TL2253]
2024-09-28 19:40:03 >>>故障排除日志:上一MQTT订单号缓存列表为24092819392893317463
2024-09-28 19:40:03 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 19:40:03 开始打印,排队:149,票券:2409281939565429521601,订单:24092819395654290426,[2024-09-28 19:40:03微信支付15元]
2024-09-28 19:40:05 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281939565429521601","queue_number":149,"trade_uid":"24092819395654290426"}]}
2024-09-28 19:40:05 >>>故障排除日志:删除未同步下发订单成功24092819395654290426
2024-09-28 19:40:05 >>>故障排除日志:终端同步成功后剩余订单列表


===19:42:34===
2024-09-28 19:42:00 >>>剩余flash空间=1682000,占用RAM为637.498046875
2024-09-28 19:42:00 >>>回调事件:905,callUart,10002,code(E3003F)


2024-09-28 19:42:00 >>>当前Ram内存为643.345703125
2024-09-28 19:42:04 >>>剩余flash空间=1681500,占用RAM为608.6123046875
2024-09-28 19:42:04 >>>回调事件:905,callUart,10002,code(E3003F)


2024-09-28 19:42:04 >>>当前Ram内存为613.64453125
2024-09-28 19:42:08 >>>剩余flash空间=1681000,占用RAM为614.875
2024-09-28 19:42:08 >>>回调事件:905,callUart,10002,code(E3003F)


2024-09-28 19:42:08 >>>当前Ram内存为619.9560546875
2024-09-28 19:42:16 >>>剩余flash空间=1680500,占用RAM为627.0458984375
2024-09-28 19:42:16 >>>回调事件:905,callUart,10002,code(E3003F)


2024-09-28 19:42:16 >>>当前Ram内存为634.5439453125
2024-09-28 19:42:25 >>>剩余flash空间=1680500,占用RAM为610.9462890625
2024-09-28 19:42:25 >>>回调事件:905,callUart,10002,code(E3003F)


2024-09-28 19:42:25 >>>当前Ram内存为618.783203125


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


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


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


===19:53:35===
2024-09-28 19:53:00 >>>剩余flash空间=1682000,占用RAM为639.3798828125
2024-09-28 19:53:00 >>>回调事件:905,callUart,10002,code(E3003F)


2024-09-28 19:53:00 >>>当前Ram内存为645.251953125
2024-09-28 19:53:28 >>>剩余flash空间=1681500,占用RAM为636.25390625
2024-09-28 19:53:28 >>>回调事件:905,callUart,10002,code(E3003F)


2024-09-28 19:53:28 >>>当前Ram内存为641.2763671875


===19:54:35===
2024-09-28 19:53:47 >>>剩余flash空间=1682000,占用RAM为625.4091796875
2024-09-28 19:53:47 >>>回调事件:905,callUart,10002,code(E3003F)


2024-09-28 19:53:47 >>>当前Ram内存为631.169921875


===19:57:35===
2024-09-28 19:57:16 >>>剩余flash空间=1682000,占用RAM为626.6630859375
2024-09-28 19:57:16 >>>回调事件:905,callUart,10002,code(E3003F)


2024-09-28 19:57:16 >>>当前Ram内存为632.55078125


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


===20:05:36===
2024-09-28 20:05:21 >>>剩余flash空间=1682000,占用RAM为648.6435546875
2024-09-28 20:05:21 >>>回调事件:905,callUart,10002,code(E3003F)


2024-09-28 20:05:21 >>>当前Ram内存为607.8037109375
2024-09-28 20:05:31 >>>剩余flash空间=1681500,占用RAM为627.443359375
2024-09-28 20:05:31 >>>回调事件:905,callUart,10002,code(E3003F)


2024-09-28 20:05:31 >>>当前Ram内存为632.2880859375


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


===20:08:36===
2024-09-28 20:07:40>>>cash read=00
2024-09-28 20:07:40>>>cash read=818F42
2024-09-28 20:07:40>>>cash write=02
2024-09-28 20:07:40 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-09-28 20:07:41>>>cash read=10
2024-09-28 20:07:41 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-09-28 20:07:42>>>cash write=0C
2024-09-28 20:07:42>>>cash read=29
2024-09-28 20:07:42 >>>回调事件130,cash_status,20029,退钞中
2024-09-28 20:07:43>>>cash read=01
2024-09-28 20:07:44>>>cash read=00
2024-09-28 20:07:45>>>cash read=818F41
2024-09-28 20:07:45>>>cash write=02
2024-09-28 20:07:45 >>>回调事件130,cash_status,10022,进钞中...read money=5
2024-09-28 20:07:46>>>cash read=10
2024-09-28 20:07:46 >>>回调事件130,5,10023,finish Money=5,进钞完成
2024-09-28 20:07:46 当前产品价格15元，投币15元，打印小票中...
2024-09-28 20:07:46 >>>开始打印,排队号为155,订单号为2409282007410022534192
2024-09-28 20:07:46>>>订单2409282007410022534192写入成功,剩余空间为1679500,占用RAM为605.9765625
删除未同步订单2409282007410022534192
2024-09-28 20:07:48>>>订单2409282007410022534192删除成功,剩余空间为1680000,占用RAM为618.203125
检测订单目录中>>>
无未同步订单>>>
2024-09-28 20:07:48 >>>当前Ram内存为589.2255859375
定时检测未同步订单启用
2024-09-28 20:07:49>>>cash write=0C
2024-09-28 20:07:49>>>cash read=3E


===20:09:36===
定时检测未同步订单关闭
检测订单目录中>>>
无未同步订单>>>
2024-09-28 20:08:55 >>>剩余flash空间=1681500,占用RAM为643.4755859375
2024-09-28 20:08:55 >>>回调事件:905,callUart,10002,code(E3003F)


2024-09-28 20:08:55 >>>当前Ram内存为649.73828125


===20:15:37===
2024-09-28 20:15:27 >>>剩余flash空间=1682000,占用RAM为629.9267578125
2024-09-28 20:15:27 >>>回调事件:905,callUart,10002,code(E3003F)


2024-09-28 20:15:27 >>>当前Ram内存为635.8603515625


===20:20:37===
2024-09-28 20:19:39 >>>剩余flash空间=1682000,占用RAM为611.2001953125
2024-09-28 20:19:39 >>>回调事件:905,callUart,10002,code(E3003F)


2024-09-28 20:19:39 >>>当前Ram内存为617.1337890625
2024-09-28 20:20:03 >>>回调事件[910,devices/TL2253]
2024-09-28 20:20:03 >>>故障排除日志:上一MQTT订单号缓存列表为24092820071383982271
2024-09-28 20:20:03 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 20:20:03 开始打印,排队:156,票券:2409282019554855903801,订单:24092820195548505938,[2024-09-28 20:20:03微信支付15元]
2024-09-28 20:20:05 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409282019554855903801","queue_number":156,"trade_uid":"24092820195548505938"}]}
2024-09-28 20:20:05 >>>故障排除日志:删除未同步下发订单成功24092820195548505938
2024-09-28 20:20:05 >>>故障排除日志:终端同步成功后剩余订单列表


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


===20:28:37===
2024-09-28 20:28:22 >>>剩余flash空间=1682000,占用RAM为645.6416015625
2024-09-28 20:28:22 >>>回调事件:905,callUart,10002,code(E3003F)


2024-09-28 20:28:22 >>>当前Ram内存为609.7587890625


===20:32:38===
2024-09-28 20:31:58 >>>剩余flash空间=1682000,占用RAM为627.9814453125
2024-09-28 20:31:58 >>>回调事件:905,callUart,10002,code(E3003F)


2024-09-28 20:31:58 >>>当前Ram内存为633.203125


===20:34:38===
2024-09-28 20:34:21 >>>回调事件[910,devices/TL2253]
2024-09-28 20:34:21 >>>故障排除日志:上一MQTT订单号缓存列表为24092820231669666576
2024-09-28 20:34:21 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 20:34:21 开始打印,排队:158,票券:2409282034138982433201,订单:24092820341389820042,[2024-09-28 20:34:20微信支付15元]
2024-09-28 20:34:23 >>>回调事件[910,devices/TL2253]
2024-09-28 20:34:23 >>>故障排除日志:上一MQTT订单号缓存列表为24092820341389820042
2024-09-28 20:34:23 >>>故障排除日志:终端未同步成功订单列表015824092820341389820042
已接收过此消息,票券号为2409282034138982433201,排队号为158
2024-09-28 20:34:23 开始打印,排队:159,票券:2409282034164804563701,订单:24092820341648034763,[2024-09-28 20:34:23微信支付15元]
2024-09-28 20:34:25 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409282034138982433201","queue_number":158,"trade_uid":"24092820341389820042"}]}
2024-09-28 20:34:25 >>>故障排除日志:删除未同步下发订单成功24092820341389820042
2024-09-28 20:34:25 >>>故障排除日志:终端同步成功后剩余订单列表015924092820341648034763
2024-09-28 20:34:25 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409282034138982433201","queue_number":158,"trade_uid":"24092820341389820042"},{"ticket_no":"2409282034164804563701","queue_number":159,"trade_uid":"24092820341648034763"}]}
2024-09-28 20:34:25 >>>故障排除日志:删除未同步下发订单成功24092820341648034763
2024-09-28 20:34:25 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


===20:38:39===
2024-09-28 20:38:12 >>>剩余flash空间=1682000,占用RAM为637.4931640625
2024-09-28 20:38:12 >>>回调事件:905,callUart,10002,code(E3003F)


2024-09-28 20:38:12 >>>当前Ram内存为643.3505859375


===20:41:39===
2024-09-28 20:41:12 >>>剩余flash空间=1682000,占用RAM为624.947265625
2024-09-28 20:41:12 >>>回调事件:905,callUart,10002,code(E3003F)


2024-09-28 20:41:12 >>>当前Ram内存为630.8408203125


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


===20:52:40===
2024-09-28 20:51:39 >>>剩余flash空间=1682000,占用RAM为616.9365234375
2024-09-28 20:51:39 >>>回调事件:905,callUart,10002,code(E3003F)


2024-09-28 20:51:39 >>>当前Ram内存为622.55859375


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


===21:00:40===
2024-09-28 21:00:04 >>>回调事件[910,devices/TL2253]
2024-09-28 21:00:04 >>>故障排除日志:上一MQTT订单号缓存列表为24092820555734968776
2024-09-28 21:00:04 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 21:00:05 开始打印,排队:164,票券:2409282059597499765101,订单:24092820595974993745,[2024-09-28 21:00:04微信支付15元]
2024-09-28 21:00:05 开始打印,排队:165,票券:2409282059597499905002,订单:24092820595974993745,[2024-09-28 21:00:04微信支付15元]
2024-09-28 21:00:08 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409282059597499765101","queue_number":164,"trade_uid":"24092820595974993745"},{"ticket_no":"2409282059597499905002","queue_number":165,"trade_uid":"24092820595974993745"}]}
2024-09-28 21:00:08 >>>故障排除日志:删除未同步下发订单成功24092820595974993745
2024-09-28 21:00:08 >>>故障排除日志:删除未同步下发订单成功24092820595974993745
2024-09-28 21:00:08 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


===21:40:42===
2024-09-28 21:40:21 >>>剩余flash空间=1682000,占用RAM为629.8466796875
2024-09-28 21:40:21 >>>回调事件:905,callUart,10002,code(E3003F)


2024-09-28 21:40:21 >>>当前Ram内存为635.4794921875


===21:55:43===
2024-09-28 21:55:24 收到下发指令:叫号69>>>
2024-09-28 21:55:25 收到下发指令:叫号70>>>
2024-09-28 21:55:26 收到下发指令:叫号71>>>
2024-09-28 21:55:27 收到下发指令:叫号72>>>
2024-09-28 21:55:28 收到下发指令:叫号73>>>
2024-09-28 21:55:29 收到下发指令:叫号74>>>
2024-09-28 21:55:30 收到下发指令:叫号75>>>
2024-09-28 21:55:31 收到下发指令:叫号76>>>
2024-09-28 21:55:32 收到下发指令:叫号77>>>
2024-09-28 21:55:33 收到下发指令:叫号78>>>
2024-09-28 21:55:34 收到下发指令:叫号79>>>
2024-09-28 21:55:35 收到下发指令:叫号80>>>
2024-09-28 21:55:36 收到下发指令:叫号81>>>
2024-09-28 21:55:37 收到下发指令:叫号82>>>
2024-09-28 21:55:38 收到下发指令:叫号83>>>
2024-09-28 21:55:39 收到下发指令:叫号84>>>
2024-09-28 21:55:40 收到下发指令:叫号85>>>
2024-09-28 21:55:41 收到下发指令:叫号86>>>


===21:56:44===
2024-09-28 21:55:45 收到下发指令:叫号88>>>
2024-09-28 21:55:46 收到下发指令:叫号89>>>
2024-09-28 21:55:47 收到下发指令:叫号90>>>
2024-09-28 21:55:48 收到下发指令:叫号91>>>
2024-09-28 21:55:49 收到下发指令:叫号92>>>
2024-09-28 21:55:50 收到下发指令:叫号93>>>
2024-09-28 21:55:51 收到下发指令:叫号94>>>
2024-09-28 21:55:52 收到下发指令:叫号95>>>
2024-09-28 21:55:54 收到下发指令:叫号96>>>
2024-09-28 21:55:55 收到下发指令:叫号97>>>
2024-09-28 21:55:56 收到下发指令:叫号98>>>
2024-09-28 21:55:57 收到下发指令:叫号99>>>
2024-09-28 21:55:58 收到下发指令:叫号100>>>
2024-09-28 21:56:00 收到下发指令:叫号101>>>
2024-09-28 21:56:01 收到下发指令:叫号102>>>
2024-09-28 21:56:04 收到下发指令:叫号103>>>
2024-09-28 21:56:05 收到下发指令:叫号104>>>
2024-09-28 21:56:06 收到下发指令:叫号105>>>
2024-09-28 21:56:07 收到下发指令:叫号106>>>
2024-09-28 21:56:08 收到下发指令:叫号107>>>
2024-09-28 21:56:08 收到下发指令:叫号108>>>
2024-09-28 21:56:09 收到下发指令:叫号109>>>
2024-09-28 21:56:13 收到下发指令:叫号110>>>
2024-09-28 21:56:14 收到下发指令:叫号111>>>
2024-09-28 21:56:16 收到下发指令:叫号112>>>
2024-09-28 21:56:17 收到下发指令:叫号113>>>
2024-09-28 21:56:18 收到下发指令:叫号114>>>
2024-09-28 21:56:18 收到下发指令:叫号115>>>
2024-09-28 21:56:19 收到下发指令:叫号116>>>
2024-09-28 21:56:20 收到下发指令:叫号117>>>
2024-09-28 21:56:21 收到下发指令:叫号118>>>
2024-09-28 21:56:22 收到下发指令:叫号119>>>
2024-09-28 21:56:24 收到下发指令:叫号120>>>
2024-09-28 21:56:27 收到下发指令:叫号121>>>


===21:57:45===
2024-09-28 21:56:49 收到下发指令:叫号122>>>
2024-09-28 21:56:49 收到下发指令:叫号123>>>
2024-09-28 21:56:50 收到下发指令:叫号124>>>
2024-09-28 21:56:51 收到下发指令:叫号125>>>
2024-09-28 21:56:52 收到下发指令:叫号126>>>
2024-09-28 21:56:53 收到下发指令:叫号127>>>
2024-09-28 21:56:54 收到下发指令:叫号128>>>
2024-09-28 21:56:54 收到下发指令:叫号129>>>
2024-09-28 21:56:55 收到下发指令:叫号130>>>
2024-09-28 21:56:56 收到下发指令:叫号131>>>
2024-09-28 21:56:56 收到下发指令:叫号132>>>
2024-09-28 21:56:56 收到下发指令:叫号133>>>
2024-09-28 21:56:57 收到下发指令:叫号134>>>
2024-09-28 21:56:58 收到下发指令:叫号135>>>
2024-09-28 21:56:58 收到下发指令:叫号136>>>
2024-09-28 21:56:59 收到下发指令:叫号137>>>
2024-09-28 21:56:59 收到下发指令:叫号138>>>
2024-09-28 21:57:00 收到下发指令:叫号139>>>
2024-09-28 21:57:00 收到下发指令:叫号140>>>
2024-09-28 21:57:01 收到下发指令:叫号141>>>
2024-09-28 21:57:02 收到下发指令:叫号142>>>
2024-09-28 21:57:02 收到下发指令:叫号143>>>
2024-09-28 21:57:02 收到下发指令:叫号144>>>
2024-09-28 21:57:03 收到下发指令:叫号145>>>
2024-09-28 21:57:04 收到下发指令:叫号146>>>
2024-09-28 21:57:04 收到下发指令:叫号147>>>
2024-09-28 21:57:05 收到下发指令:叫号148>>>
2024-09-28 21:57:06 收到下发指令:叫号149>>>
2024-09-28 21:57:06 收到下发指令:叫号150>>>
2024-09-28 21:57:07 收到下发指令:叫号151>>>
2024-09-28 21:57:08 收到下发指令:叫号152>>>
2024-09-28 21:57:08 收到下发指令:叫号153>>>
2024-09-28 21:57:08 收到下发指令:叫号154>>>
2024-09-28 21:57:09 收到下发指令:叫号155>>>
2024-09-28 21:57:10 收到下发指令:叫号156>>>
2024-09-28 21:57:10 收到下发指令:叫号157>>>
2024-09-28 21:57:11 收到下发指令:叫号158>>>
2024-09-28 21:57:12 收到下发指令:叫号159>>>
2024-09-28 21:57:12 收到下发指令:叫号160>>>
2024-09-28 21:57:13 收到下发指令:叫号161>>>
2024-09-28 21:57:13 收到下发指令:叫号162>>>
2024-09-28 21:57:14 收到下发指令:叫号163>>>
2024-09-28 21:57:14 收到下发指令:叫号164>>>
2024-09-28 21:57:14 收到下发指令:叫号165>>>
2024-09-28 21:57:15 收到下发指令:叫号166>>>
2024-09-28 21:57:16 收到下发指令:叫号167>>>
2024-09-28 21:57:17 收到下发指令:叫号168>>>
2024-09-28 21:57:17 收到下发指令:叫号169>>>


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


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


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


===22:12:46===
2024-09-28 22:12:20 收到下发指令:叫号171>>>