TLClient_JSSCOM_LuatOS-Air_V4010_RDA8910_RFTTS_0xe0000,2.5.1,865328069246451,19617229878903,
poweron reason:0

===08:20:14===
上一时间戳为1719965295
隔日重置时间戳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":"4351590954436780423","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:113de****89369
纸币器设置接收纸币范围为36
欢迎使用天羚自助售票系统[2.5.1]
定时检测未同步订单启用
2024-07-04 08:19:14>>>cash write=30
2024-07-04 08:19:14>>>cash write=02
2024-07-04 08:19:14>>>cash write=3E
2024-07-04 08:19:14>>>cash read=808F808F808F
系统时间初始化成功，时间为20247481914
2024-07-04 08:19:15>>>cash write=02
2024-07-04 08:19:15 >>>剩余flash空间=1680500,占用RAM为621.4208984375
2024-07-04 08:19:15 >>>回调事件:910,subscribe,10000,连接服务器成功

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

2024-07-04 08:19:18>>>cash write=0C
2024-07-04 08:19:18>>>cash read=3E
流量卡还有239天过期
2024-07-04 08:19:22 >>>当前Ram内存为607.1572265625
2024-07-04 08:20:01 >>>回调事件[910,devices/TL1880]
当日首次设置时间戳true为1720052401
2024-07-04 08:20:01 >>>故障排除日志:上一MQTT订单号缓存列表为24070321020866868869
2024-07-04 08:20:01 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 08:20:01 开始打印,排队:1,票券:2407040819496223372101,订单:24070408194962229626,[2024-07-04 08:19:49微信支付10元]
2024-07-04 08:20:03 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407040819496223372101","queue_number":1,"trade_uid":"24070408194962229626"}]}
2024-07-04 08:20:03 >>>故障排除日志:删除未同步下发订单成功24070408194962229626
2024-07-04 08:20:03 >>>故障排除日志:终端同步成功后剩余订单列表
2024-07-04 08:20:03 收到下发指令:叫号1>>>


===08:21:15===
定时检测未同步订单关闭
检测订单目录中>>>
无未同步订单>>>
2024-07-04 08:20:16 >>>回调事件[910,devices/TL1880]
2024-07-04 08:20:16 >>>故障排除日志:上一MQTT订单号缓存列表为24070408194962229626
2024-07-04 08:20:16 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 08:20:16 开始打印,排队:2,票券:2407040819578914267201,订单:24070408195789137968,[2024-07-04 08:19:57支付宝支付10元]
2024-07-04 08:20:18 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407040819578914267201","queue_number":2,"trade_uid":"24070408195789137968"}]}
2024-07-04 08:20:18 >>>故障排除日志:删除未同步下发订单成功24070408195789137968
2024-07-04 08:20:18 >>>故障排除日志:终端同步成功后剩余订单列表
2024-07-04 08:20:22>>>cash read=292F29
2024-07-04 08:20:22 >>>回调事件130,cash_status,20029,退钞中
2024-07-04 08:20:23>>>cash read=01
2024-07-04 08:20:27>>>cash read=012F
2024-07-04 08:20:28>>>cash read=3E
2024-07-04 08:20:30>>>cash read=00
2024-07-04 08:20:31>>>cash read=818F42
2024-07-04 08:20:32>>>cash write=02
2024-07-04 08:20:32 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-07-04 08:20:32>>>cash read=10
2024-07-04 08:20:32 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-07-04 08:20:32 >>>开始打印,排队号为3,订单号为2407040820320018804360
2024-07-04 08:20:32>>>订单2407040820320018804360写入成功,剩余空间为1679000,占用RAM为604.763671875
删除未同步订单2407040820320018804360
2024-07-04 08:20:34>>>订单2407040820320018804360删除成功,剩余空间为1679500,占用RAM为618.306640625
检测订单目录中>>>
无未同步订单>>>
2024-07-04 08:20:35 >>>当前Ram内存为587.7880859375
定时检测未同步订单启用
2024-07-04 08:20:35>>>cash write=0C
2024-07-04 08:20:35>>>cash read=3E


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


===08:23:15===
2024-07-04 08:22:17 >>>回调事件[910,devices/TL1880]
2024-07-04 08:22:17 >>>故障排除日志:上一MQTT订单号缓存列表为24070408195789137968
2024-07-04 08:22:17 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 08:22:17 开始打印,排队:4,票券:2407040822078846879101,订单:24070408220788463843,[2024-07-04 08:22:07支付宝支付10元]
2024-07-04 08:22:19 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407040822078846879101","queue_number":4,"trade_uid":"24070408220788463843"}]}
2024-07-04 08:22:19 >>>故障排除日志:删除未同步下发订单成功24070408220788463843
2024-07-04 08:22:19 >>>故障排除日志:终端同步成功后剩余订单列表
2024-07-04 08:23:00>>>cash read=00
2024-07-04 08:23:01>>>cash read=29
2024-07-04 08:23:01 >>>回调事件130,cash_status,20029,退钞中
2024-07-04 08:23:02>>>cash read=2F29
2024-07-04 08:23:03>>>cash read=3E
2024-07-04 08:23:08>>>cash read=00
2024-07-04 08:23:10>>>cash read=29
2024-07-04 08:23:10 >>>回调事件130,cash_status,20029,退钞中
2024-07-04 08:23:10>>>cash read=2F29
2024-07-04 08:23:11>>>cash read=3E


===08:24:15===
2024-07-04 08:23:21>>>cash read=00
2024-07-04 08:23:22>>>cash read=818F42
2024-07-04 08:23:22>>>cash write=02
2024-07-04 08:23:22 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-07-04 08:23:23>>>cash read=10
2024-07-04 08:23:23 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-07-04 08:23:23 >>>开始打印,排队号为5,订单号为2407040823230018807089
2024-07-04 08:23:23>>>订单2407040823230018807089写入成功,剩余空间为1680500,占用RAM为601.5810546875
删除未同步订单2407040823230018807089
2024-07-04 08:23:25>>>订单2407040823230018807089删除成功,剩余空间为1680500,占用RAM为614.4072265625
检测订单目录中>>>
无未同步订单>>>
2024-07-04 08:23:25 >>>当前Ram内存为587.1767578125
定时检测未同步订单启用
2024-07-04 08:23:26>>>cash write=0C
2024-07-04 08:23:26>>>cash read=3E


===08:25:15===
2024-07-04 08:24:18>>>cash read=00
2024-07-04 08:24:18>>>cash read=818F42
2024-07-04 08:24:18>>>cash write=02
2024-07-04 08:24:18 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-07-04 08:24:19>>>cash read=10
2024-07-04 08:24:19 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-07-04 08:24:19 >>>开始打印,排队号为6,订单号为2407040824190018805224
定时检测未同步订单关闭
2024-07-04 08:24:19>>>订单2407040824190018805224写入成功,剩余空间为1680000,占用RAM为602.0576171875
删除未同步订单2407040824190018805224
2024-07-04 08:24:21>>>订单2407040824190018805224删除成功,剩余空间为1680500,占用RAM为614.2529296875
检测订单目录中>>>
无未同步订单>>>
2024-07-04 08:24:21 >>>当前Ram内存为586.9697265625
定时检测未同步订单启用
2024-07-04 08:24:22>>>cash write=0C
2024-07-04 08:24:22>>>cash read=3E


===08:26:16===
定时检测未同步订单关闭
检测订单目录中>>>
无未同步订单>>>
2024-07-04 08:25:37>>>cash read=00
2024-07-04 08:25:38>>>cash read=818F42
2024-07-04 08:25:38>>>cash write=02
2024-07-04 08:25:38 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-07-04 08:25:38>>>cash read=10
2024-07-04 08:25:38 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-07-04 08:25:38 >>>开始打印,排队号为7,订单号为2407040825380018806964
2024-07-04 08:25:39>>>订单2407040825380018806964写入成功,剩余空间为1680000,占用RAM为602.2392578125
删除未同步订单2407040825380018806964
2024-07-04 08:25:41>>>订单2407040825380018806964删除成功,剩余空间为1680500,占用RAM为614.6748046875
检测订单目录中>>>
无未同步订单>>>
2024-07-04 08:25:41 >>>当前Ram内存为587.3291015625
定时检测未同步订单启用
2024-07-04 08:25:42>>>cash write=0C
2024-07-04 08:25:42>>>cash read=3E
2024-07-04 08:25:46>>>cash read=00
2024-07-04 08:25:48>>>cash read=2F29
2024-07-04 08:25:49>>>cash read=2F3E
2024-07-04 08:25:54>>>cash read=00
2024-07-04 08:25:55>>>cash read=2F29
2024-07-04 08:25:57>>>cash read=3E


===08:27:16===
2024-07-04 08:26:26>>>cash read=29
2024-07-04 08:26:26 >>>回调事件130,cash_status,20029,退钞中
2024-07-04 08:26:27>>>cash read=01
2024-07-04 08:26:32>>>cash read=00
2024-07-04 08:26:33>>>cash read=29
2024-07-04 08:26:33 >>>回调事件130,cash_status,20029,退钞中
2024-07-04 08:26:33>>>cash read=2F29
2024-07-04 08:26:35>>>cash read=3E
定时检测未同步订单关闭
检测订单目录中>>>
无未同步订单>>>
2024-07-04 08:26:42>>>cash read=00
2024-07-04 08:26:43>>>cash read=01
2024-07-04 08:26:44>>>cash read=3E
2024-07-04 08:26:45>>>cash read=2F29
2024-07-04 08:26:47>>>cash read=01
2024-07-04 08:26:47>>>cash read=2F
2024-07-04 08:26:49>>>cash read=3E
2024-07-04 08:26:54>>>cash read=00
2024-07-04 08:26:55>>>cash read=818F42
2024-07-04 08:26:55>>>cash write=02
2024-07-04 08:26:56 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-07-04 08:26:56>>>cash read=10
2024-07-04 08:26:56 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-07-04 08:26:56 >>>开始打印,排队号为8,订单号为2407040826560018806914
2024-07-04 08:26:56>>>订单2407040826560018806914写入成功,剩余空间为1679000,占用RAM为603.26953125
删除未同步订单2407040826560018806914
2024-07-04 08:26:58>>>订单2407040826560018806914删除成功,剩余空间为1680000,占用RAM为616.0634765625
检测订单目录中>>>
无未同步订单>>>
2024-07-04 08:26:59 >>>当前Ram内存为587.751953125
定时检测未同步订单启用
2024-07-04 08:27:00>>>cash write=0C
2024-07-04 08:27:00>>>cash read=3E


===08:28:16===
2024-07-04 08:27:21>>>cash read=00
2024-07-04 08:27:22>>>cash read=818F42
2024-07-04 08:27:22>>>cash write=02
2024-07-04 08:27:22 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-07-04 08:27:23>>>cash read=10
2024-07-04 08:27:23 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-07-04 08:27:23 >>>开始打印,排队号为9,订单号为2407040827230018801181
定时检测未同步订单关闭
2024-07-04 08:27:23>>>订单2407040827230018801181写入成功,剩余空间为1680000,占用RAM为602.447265625
删除未同步订单2407040827230018801181
2024-07-04 08:27:25>>>订单2407040827230018801181删除成功,剩余空间为1680500,占用RAM为614.6396484375
检测订单目录中>>>
无未同步订单>>>
2024-07-04 08:27:25 >>>当前Ram内存为587.357421875
定时检测未同步订单启用
2024-07-04 08:27:26>>>cash write=0C
2024-07-04 08:27:26>>>cash read=3E
2024-07-04 08:28:02>>>cash read=00
2024-07-04 08:28:03>>>cash read=818F42
2024-07-04 08:28:03>>>cash write=02
2024-07-04 08:28:03 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-07-04 08:28:03>>>cash read=10
2024-07-04 08:28:04 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-07-04 08:28:04 >>>开始打印,排队号为10,订单号为2407040828040018805487
定时检测未同步订单关闭
2024-07-04 08:28:04>>>订单2407040828040018805487写入成功,剩余空间为1679000,占用RAM为607.021484375
删除未同步订单2407040828040018805487
2024-07-04 08:28:06>>>订单2407040828040018805487删除成功,剩余空间为1679500,占用RAM为616.57421875
检测订单目录中>>>
无未同步订单>>>
2024-07-04 08:28:06 >>>当前Ram内存为587.63671875
定时检测未同步订单启用
2024-07-04 08:28:07>>>cash write=0C
2024-07-04 08:28:07>>>cash read=3E


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


===08:31:16===
2024-07-04 08:30:48>>>cash read=00
2024-07-04 08:30:50>>>cash read=00818F42
2024-07-04 08:30:50>>>cash write=02
2024-07-04 08:30:50 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-07-04 08:30:50>>>cash read=10
2024-07-04 08:30:50 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-07-04 08:30:50 >>>开始打印,排队号为11,订单号为2407040830500018806315
2024-07-04 08:30:50>>>订单2407040830500018806315写入成功,剩余空间为1680500,占用RAM为601.9296875
2024-07-04 08:30:52 >>>回调事件[910,devices/TL1880]
2024-07-04 08:30:52 >>>故障排除日志:上一MQTT订单号缓存列表为24070408220788463843
2024-07-04 08:30:52 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 08:30:52 开始打印,排队:12,票券:2407040830418559216801,订单:24070408304185587785,[2024-07-04 08:30:41微信支付10元]
2024-07-04 08:30:54 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407040830418559216801","queue_number":12,"trade_uid":"24070408304185587785"}]}
2024-07-04 08:30:54 >>>故障排除日志:删除未同步下发订单成功24070408304185587785
2024-07-04 08:30:54 >>>故障排除日志:终端同步成功后剩余订单列表
删除未同步订单2407040830500018806315
2024-07-04 08:30:54>>>订单2407040830500018806315删除成功,剩余空间为1680000,占用RAM为592.6982421875
检测订单目录中>>>
无未同步订单>>>
2024-07-04 08:30:55 >>>当前Ram内存为588.58984375
定时检测未同步订单启用
2024-07-04 08:30:56>>>cash write=0C
2024-07-04 08:30:56>>>cash read=3E


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


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


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


===08:53:17===
2024-07-04 08:52:32>>>cash read=29
2024-07-04 08:52:32 >>>回调事件130,cash_status,20029,退钞中
2024-07-04 08:52:32>>>cash read=2F29
2024-07-04 08:52:33>>>cash read=01
2024-07-04 08:52:33>>>cash read=2F
2024-07-04 08:52:35>>>cash read=00
2024-07-04 08:52:35>>>cash read=818F42
2024-07-04 08:52:35>>>cash write=02
2024-07-04 08:52:35 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-07-04 08:52:36>>>cash read=10
2024-07-04 08:52:36 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-07-04 08:52:36 >>>开始打印,排队号为15,订单号为2407040852360018809848
2024-07-04 08:52:36>>>订单2407040852360018809848写入成功,剩余空间为1679500,占用RAM为603.3330078125
删除未同步订单2407040852360018809848
2024-07-04 08:52:38>>>订单2407040852360018809848删除成功,剩余空间为1680500,占用RAM为615.3955078125
检测订单目录中>>>
无未同步订单>>>
2024-07-04 08:52:38 >>>当前Ram内存为587.8544921875
定时检测未同步订单启用
2024-07-04 08:52:39>>>cash write=0C
2024-07-04 08:52:39>>>cash read=3E


===08:54:18===
定时检测未同步订单关闭
检测订单目录中>>>
无未同步订单>>>
2024-07-04 08:54:16>>>cash read=0A
2024-07-04 08:54:17>>>cash read=3E


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


===09:17:18===
2024-07-04 09:16:48>>>cash read=00
2024-07-04 09:16:49>>>cash read=818F42
2024-07-04 09:16:49>>>cash write=02
2024-07-04 09:16:49 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-07-04 09:16:49>>>cash read=10
2024-07-04 09:16:49 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-07-04 09:16:49 >>>开始打印,排队号为17,订单号为2407040916490018803191
2024-07-04 09:16:50>>>订单2407040916490018803191写入成功,剩余空间为1680500,占用RAM为599.94140625
删除未同步订单2407040916490018803191
2024-07-04 09:16:52>>>订单2407040916490018803191删除成功,剩余空间为1680500,占用RAM为614.0380859375
检测订单目录中>>>
无未同步订单>>>
2024-07-04 09:16:52 >>>当前Ram内存为586.7138671875
定时检测未同步订单启用
2024-07-04 09:16:53>>>cash write=0C
2024-07-04 09:16:53>>>cash read=3E


===09:18:18===
2024-07-04 09:17:25>>>cash read=00
2024-07-04 09:17:27>>>cash read=818F42
2024-07-04 09:17:27>>>cash write=02
2024-07-04 09:17:27 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-07-04 09:17:27>>>cash read=10
2024-07-04 09:17:27 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-07-04 09:17:27 >>>开始打印,排队号为18,订单号为2407040917270018802127
定时检测未同步订单关闭
2024-07-04 09:17:27>>>订单2407040917270018802127写入成功,剩余空间为1680000,占用RAM为601.6123046875
删除未同步订单2407040917270018802127
2024-07-04 09:17:30>>>订单2407040917270018802127删除成功,剩余空间为1680500,占用RAM为613.80078125
检测订单目录中>>>
无未同步订单>>>
2024-07-04 09:17:30 >>>当前Ram内存为586.4755859375
定时检测未同步订单启用
2024-07-04 09:17:30>>>cash write=0C
2024-07-04 09:17:31>>>cash read=3E


===09:19:19===
定时检测未同步订单关闭
检测订单目录中>>>
无未同步订单>>>
2024-07-04 09:18:46>>>cash read=00
2024-07-04 09:18:46>>>cash read=818F42
2024-07-04 09:18:46>>>cash write=02
2024-07-04 09:18:46 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-07-04 09:18:47>>>cash read=10
2024-07-04 09:18:47 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-07-04 09:18:47 >>>开始打印,排队号为19,订单号为2407040918470018805657
2024-07-04 09:18:47>>>订单2407040918470018805657写入成功,剩余空间为1680000,占用RAM为601.708984375
删除未同步订单2407040918470018805657
2024-07-04 09:18:49>>>订单2407040918470018805657删除成功,剩余空间为1680500,占用RAM为614.138671875
检测订单目录中>>>
无未同步订单>>>
2024-07-04 09:18:49 >>>当前Ram内存为586.8232421875
定时检测未同步订单启用
2024-07-04 09:18:50>>>cash write=0C
2024-07-04 09:18:50>>>cash read=3E
2024-07-04 09:18:52 >>>回调事件[910,devices/TL1880]
2024-07-04 09:18:52 >>>故障排除日志:上一MQTT订单号缓存列表为24070408570020475401
2024-07-04 09:18:52 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 09:18:52 开始打印,排队:20,票券:2407040918424650288901,订单:24070409184246498487,[2024-07-04 09:18:42微信支付10元]
2024-07-04 09:18:54 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407040918424650288901","queue_number":20,"trade_uid":"24070409184246498487"}]}
2024-07-04 09:18:54 >>>故障排除日志:删除未同步下发订单成功24070409184246498487
2024-07-04 09:18:54 >>>故障排除日志:终端同步成功后剩余订单列表
2024-07-04 09:18:59 >>>回调事件[910,devices/TL1880]
2024-07-04 09:18:59 >>>故障排除日志:上一MQTT订单号缓存列表为24070409184246498487
2024-07-04 09:18:59 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 09:18:59 开始打印,排队:21,票券:2407040918529348104901,订单:24070409185293475180,[2024-07-04 09:18:52微信支付10元]
2024-07-04 09:19:01 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407040918529348104901","queue_number":21,"trade_uid":"24070409185293475180"}]}
2024-07-04 09:19:01 >>>故障排除日志:删除未同步下发订单成功24070409185293475180
2024-07-04 09:19:01 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


===09:26:19===
2024-07-04 09:25:54>>>cash read=00
2024-07-04 09:25:55>>>cash read=818F42
2024-07-04 09:25:55>>>cash write=02
2024-07-04 09:25:55 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-07-04 09:25:55>>>cash read=10
2024-07-04 09:25:55 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-07-04 09:25:56 >>>开始打印,排队号为23,订单号为2407040925550018809915
2024-07-04 09:25:56>>>订单2407040925550018809915写入成功,剩余空间为1680500,占用RAM为601.4189453125
删除未同步订单2407040925550018809915
2024-07-04 09:25:58>>>订单2407040925550018809915删除成功,剩余空间为1680500,占用RAM为615.6279296875
检测订单目录中>>>
无未同步订单>>>
2024-07-04 09:25:58 >>>当前Ram内存为586.75390625
定时检测未同步订单启用
2024-07-04 09:25:59>>>cash write=0C
2024-07-04 09:25:59>>>cash read=3E


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


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


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


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


===10:01:21===
2024-07-04 10:00:31 >>>回调事件[910,devices/TL1880]
2024-07-04 10:00:31 >>>故障排除日志:上一MQTT订单号缓存列表为24070409514432107964
2024-07-04 10:00:31 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 10:00:31 开始打印,排队:27,票券:2407041000209372077801,订单:24070410002093716151,[2024-07-04 10:00:20微信支付10元]
2024-07-04 10:00:33 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407041000209372077801","queue_number":27,"trade_uid":"24070410002093716151"}]}
2024-07-04 10:00:33 >>>故障排除日志:删除未同步下发订单成功24070410002093716151
2024-07-04 10:00:33 >>>故障排除日志:终端同步成功后剩余订单列表
2024-07-04 10:00:47 >>>回调事件[910,devices/TL1880]
2024-07-04 10:00:47 >>>故障排除日志:上一MQTT订单号缓存列表为24070410002093716151
2024-07-04 10:00:47 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 10:00:47 开始打印,排队:28,票券:2407041000368876878301,订单:24070410003688764089,[2024-07-04 10:00:36微信支付10元]
2024-07-04 10:00:49 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407041000368876878301","queue_number":28,"trade_uid":"24070410003688764089"}]}
2024-07-04 10:00:49 >>>故障排除日志:删除未同步下发订单成功24070410003688764089
2024-07-04 10:00:49 >>>故障排除日志:终端同步成功后剩余订单列表


===10:04:21===
2024-07-04 10:03:23>>>cash read=29
2024-07-04 10:03:23 >>>回调事件130,cash_status,20029,退钞中
2024-07-04 10:03:24>>>cash read=01
2024-07-04 10:03:26>>>cash read=3E
2024-07-04 10:03:34>>>cash read=00
2024-07-04 10:03:35>>>cash read=818F42
2024-07-04 10:03:35>>>cash write=02
2024-07-04 10:03:35 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-07-04 10:03:35>>>cash read=10
2024-07-04 10:03:35 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-07-04 10:03:35 >>>开始打印,排队号为29,订单号为2407041003350018801121
2024-07-04 10:03:36>>>订单2407041003350018801121写入成功,剩余空间为1679500,占用RAM为600.541015625
删除未同步订单2407041003350018801121
2024-07-04 10:03:38>>>订单2407041003350018801121删除成功,剩余空间为1680500,占用RAM为612.630859375
检测订单目录中>>>
无未同步订单>>>
2024-07-04 10:03:38 >>>当前Ram内存为585.283203125
定时检测未同步订单启用
2024-07-04 10:03:39>>>cash write=0C
2024-07-04 10:03:39>>>cash read=3E


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


===10:18:21===
2024-07-04 10:17:27>>>cash read=00
2024-07-04 10:17:28>>>cash read=818F42
2024-07-04 10:17:28>>>cash write=02
2024-07-04 10:17:28 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-07-04 10:17:28>>>cash read=10
2024-07-04 10:17:28 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-07-04 10:17:28 >>>开始打印,排队号为30,订单号为2407041017280018806480
2024-07-04 10:17:28>>>订单2407041017280018806480写入成功,剩余空间为1680500,占用RAM为598.6962890625
删除未同步订单2407041017280018806480
2024-07-04 10:17:30>>>订单2407041017280018806480删除成功,剩余空间为1680500,占用RAM为613.26171875
检测订单目录中>>>
无未同步订单>>>
2024-07-04 10:17:30 >>>当前Ram内存为586.0244140625
定时检测未同步订单启用
2024-07-04 10:17:31>>>cash write=0C
2024-07-04 10:17:31>>>cash read=3E


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


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


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


===10:37:22===
2024-07-04 10:36:39>>>cash read=00
2024-07-04 10:36:39>>>cash read=818F42
2024-07-04 10:36:39>>>cash write=02
2024-07-04 10:36:39 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-07-04 10:36:40>>>cash read=10
2024-07-04 10:36:40 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-07-04 10:36:40 >>>开始打印,排队号为33,订单号为2407041036400018808954
2024-07-04 10:36:40>>>订单2407041036400018808954写入成功,剩余空间为1680500,占用RAM为598.560546875
删除未同步订单2407041036400018808954
2024-07-04 10:36:42>>>订单2407041036400018808954删除成功,剩余空间为1680500,占用RAM为612.4775390625
检测订单目录中>>>
无未同步订单>>>
2024-07-04 10:36:42 >>>当前Ram内存为585.224609375
定时检测未同步订单启用
2024-07-04 10:36:43>>>cash write=0C
2024-07-04 10:36:43>>>cash read=3E


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


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


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


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


===11:11:23===
2024-07-04 11:11:21>>>cash read=2F29


===11:12:23===
2024-07-04 11:11:23>>>cash read=00
2024-07-04 11:11:24>>>cash read=818F42
2024-07-04 11:11:24>>>cash write=02
2024-07-04 11:11:24 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-07-04 11:11:24>>>cash read=10
2024-07-04 11:11:24 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-07-04 11:11:24 >>>开始打印,排队号为37,订单号为2407041111240018805004
2024-07-04 11:11:25>>>订单2407041111240018805004写入成功,剩余空间为1680500,占用RAM为601.7724609375
删除未同步订单2407041111240018805004
2024-07-04 11:11:27>>>订单2407041111240018805004删除成功,剩余空间为1680500,占用RAM为615.8271484375
检测订单目录中>>>
无未同步订单>>>
2024-07-04 11:11:27 >>>当前Ram内存为587.1162109375
定时检测未同步订单启用
2024-07-04 11:11:28>>>cash write=0C
2024-07-04 11:11:28>>>cash read=3E


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


===11:32:24===
2024-07-04 11:31:47>>>cash read=00
2024-07-04 11:31:48>>>cash read=818F42
2024-07-04 11:31:48>>>cash write=02
2024-07-04 11:31:48 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-07-04 11:31:48>>>cash read=10
2024-07-04 11:31:48 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-07-04 11:31:48 >>>开始打印,排队号为38,订单号为2407041131480018808924
2024-07-04 11:31:49>>>订单2407041131480018808924写入成功,剩余空间为1680500,占用RAM为601.7373046875
删除未同步订单2407041131480018808924
2024-07-04 11:31:51>>>订单2407041131480018808924删除成功,剩余空间为1680500,占用RAM为614.21484375
检测订单目录中>>>
无未同步订单>>>
2024-07-04 11:31:51 >>>当前Ram内存为587.068359375
定时检测未同步订单启用
2024-07-04 11:31:52>>>cash write=0C
2024-07-04 11:31:52>>>cash read=3E


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


===11:40:24===
2024-07-04 11:39:56>>>cash read=00
2024-07-04 11:39:57>>>cash read=818F42
2024-07-04 11:39:57>>>cash write=02
2024-07-04 11:39:57 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-07-04 11:39:57>>>cash read=10
2024-07-04 11:39:57 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-07-04 11:39:57 >>>开始打印,排队号为39,订单号为2407041139570018805247
2024-07-04 11:39:58>>>订单2407041139570018805247写入成功,剩余空间为1680500,占用RAM为601.5947265625
删除未同步订单2407041139570018805247
2024-07-04 11:40:00>>>订单2407041139570018805247删除成功,剩余空间为1680500,占用RAM为615.8046875
检测订单目录中>>>
无未同步订单>>>
2024-07-04 11:40:00 >>>当前Ram内存为586.943359375
定时检测未同步订单启用
2024-07-04 11:40:01>>>cash write=0C
2024-07-04 11:40:01>>>cash read=3E


===11:41:24===
2024-07-04 11:40:26 >>>回调事件[910,devices/TL1880]
2024-07-04 11:40:26 >>>故障排除日志:上一MQTT订单号缓存列表为24070410564486793989
2024-07-04 11:40:26 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 11:40:26 开始打印,排队:40,票券:2407041140186702287801,订单:24070411401867014693,[2024-07-04 11:40:18微信支付10元]
2024-07-04 11:40:28 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407041140186702287801","queue_number":40,"trade_uid":"24070411401867014693"}]}
2024-07-04 11:40:28 >>>故障排除日志:删除未同步下发订单成功24070411401867014693
2024-07-04 11:40:28 >>>故障排除日志:终端同步成功后剩余订单列表
2024-07-04 11:40:47 >>>回调事件[910,devices/TL1880]
2024-07-04 11:40:47 >>>故障排除日志:上一MQTT订单号缓存列表为24070411401867014693
2024-07-04 11:40:47 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 11:40:47 开始打印,排队:41,票券:2407041140390638417101,订单:24070411403906379050,[2024-07-04 11:40:39微信支付10元]
2024-07-04 11:40:47 开始打印,排队:42,票券:2407041140390638627302,订单:24070411403906379050,[2024-07-04 11:40:39微信支付10元]
2024-07-04 11:40:50 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407041140390638417101","queue_number":41,"trade_uid":"24070411403906379050"},{"ticket_no":"2407041140390638627302","queue_number":42,"trade_uid":"24070411403906379050"}]}
2024-07-04 11:40:50 >>>故障排除日志:删除未同步下发订单成功24070411403906379050
2024-07-04 11:40:50 >>>故障排除日志:删除未同步下发订单成功24070411403906379050
2024-07-04 11:40:51 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单关闭
检测订单目录中>>>
无未同步订单>>>


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


===11:57:25===
2024-07-04 11:56:48>>>cash read=00
2024-07-04 11:56:49>>>cash read=818F42
2024-07-04 11:56:49>>>cash write=02
2024-07-04 11:56:49 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-07-04 11:56:49>>>cash read=10
2024-07-04 11:56:49 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-07-04 11:56:49 >>>开始打印,排队号为44,订单号为2407041156490018802132
2024-07-04 11:56:50>>>订单2407041156490018802132写入成功,剩余空间为1680500,占用RAM为601.73828125
删除未同步订单2407041156490018802132
2024-07-04 11:56:52>>>订单2407041156490018802132删除成功,剩余空间为1680500,占用RAM为614.375
检测订单目录中>>>
无未同步订单>>>
2024-07-04 11:56:52 >>>当前Ram内存为587.0791015625
定时检测未同步订单启用
2024-07-04 11:56:53>>>cash write=0C
2024-07-04 11:56:53>>>cash read=3E


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


===12:07:25===
2024-07-04 12:06:30>>>cash read=00
2024-07-04 12:06:31>>>cash read=29
2024-07-04 12:06:31 >>>回调事件130,cash_status,20029,退钞中
2024-07-04 12:06:32>>>cash read=2F29
2024-07-04 12:06:33>>>cash read=00
2024-07-04 12:06:35>>>cash read=2F29
2024-07-04 12:06:36>>>cash read=3E
2024-07-04 12:06:41>>>cash read=00
2024-07-04 12:06:42>>>cash read=818F42
2024-07-04 12:06:42>>>cash write=02
2024-07-04 12:06:42 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-07-04 12:06:42>>>cash read=10
2024-07-04 12:06:42 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-07-04 12:06:42 >>>开始打印,排队号为45,订单号为2407041206420018807380
2024-07-04 12:06:42>>>订单2407041206420018807380写入成功,剩余空间为1679500,占用RAM为603.0029296875
删除未同步订单2407041206420018807380
2024-07-04 12:06:45>>>订单2407041206420018807380删除成功,剩余空间为1680500,占用RAM为615.0009765625
检测订单目录中>>>
无未同步订单>>>
2024-07-04 12:06:45 >>>当前Ram内存为587.298828125
定时检测未同步订单启用
2024-07-04 12:06:46>>>cash write=0C
2024-07-04 12:06:46>>>cash read=3E


===12:08:25===
2024-07-04 12:07:29 >>>回调事件[910,devices/TL1880]
2024-07-04 12:07:29 >>>故障排除日志:上一MQTT订单号缓存列表为24070411430459147473
2024-07-04 12:07:29 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 12:07:29 开始打印,排队:46,票券:2407041207217266298101,订单:24070412072172658672,[2024-07-04 12:07:21微信支付10元]
2024-07-04 12:07:31 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407041207217266298101","queue_number":46,"trade_uid":"24070412072172658672"}]}
2024-07-04 12:07:31 >>>故障排除日志:删除未同步下发订单成功24070412072172658672
2024-07-04 12:07:31 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单关闭
检测订单目录中>>>
无未同步订单>>>


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


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


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


===13:01:26===
2024-07-04 13:00:44>>>cash read=00
2024-07-04 13:00:44>>>cash read=818F42
2024-07-04 13:00:44>>>cash write=02
2024-07-04 13:00:44 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-07-04 13:00:45>>>cash read=10
2024-07-04 13:00:45 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-07-04 13:00:45 >>>开始打印,排队号为50,订单号为2407041300450018809628
2024-07-04 13:00:45>>>订单2407041300450018809628写入成功,剩余空间为1680500,占用RAM为599.8916015625
删除未同步订单2407041300450018809628
2024-07-04 13:00:47>>>订单2407041300450018809628删除成功,剩余空间为1680500,占用RAM为612.513671875
检测订单目录中>>>
无未同步订单>>>
2024-07-04 13:00:47 >>>当前Ram内存为585.2587890625
定时检测未同步订单启用
2024-07-04 13:00:48>>>cash write=0C
2024-07-04 13:00:48>>>cash read=3E


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


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


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


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


===13:50:27===
2024-07-04 13:50:17>>>cash read=00
2024-07-04 13:50:18>>>cash read=818F42
2024-07-04 13:50:18>>>cash write=02
2024-07-04 13:50:18 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-07-04 13:50:19>>>cash read=10
2024-07-04 13:50:19 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-07-04 13:50:19 >>>开始打印,排队号为54,订单号为2407041350190018801742
2024-07-04 13:50:19>>>订单2407041350190018801742写入成功,剩余空间为1680500,占用RAM为599.69921875
删除未同步订单2407041350190018801742
2024-07-04 13:50:21>>>订单2407041350190018801742删除成功,剩余空间为1680500,占用RAM为612.48046875
检测订单目录中>>>
无未同步订单>>>
2024-07-04 13:50:21 >>>当前Ram内存为585.2080078125
定时检测未同步订单启用
2024-07-04 13:50:22>>>cash write=0C
2024-07-04 13:50:22>>>cash read=3E


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


===14:02:28===
2024-07-04 14:01:55>>>cash read=0A
2024-07-04 14:01:56>>>cash read=3E


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


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


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


===14:32:28===
2024-07-04 14:32:25 >>>回调事件[910,devices/TL1880]
2024-07-04 14:32:25 >>>故障排除日志:上一MQTT订单号缓存列表为24070414221462353695
2024-07-04 14:32:25 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 14:32:25 开始打印,排队:58,票券:2407041432170757061201,订单:24070414321707566092,[2024-07-04 14:32:17支付宝支付10元]
2024-07-04 14:32:27 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407041432170757061201","queue_number":58,"trade_uid":"24070414321707566092"}]}
2024-07-04 14:32:27 >>>故障排除日志:删除未同步下发订单成功24070414321707566092
2024-07-04 14:32:27 >>>故障排除日志:终端同步成功后剩余订单列表


===14:50:29===
2024-07-04 14:49:46 >>>回调事件[910,devices/TL1880]
2024-07-04 14:49:46 >>>故障排除日志:上一MQTT订单号缓存列表为24070414321707566092
2024-07-04 14:49:46 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 14:49:46 开始打印,排队:59,票券:2407041449410269203201,订单:24070414494102687954,[2024-07-04 14:49:41支付宝支付10元]
2024-07-04 14:49:48 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407041449410269203201","queue_number":59,"trade_uid":"24070414494102687954"}]}
2024-07-04 14:49:48 >>>故障排除日志:删除未同步下发订单成功24070414494102687954
2024-07-04 14:49:48 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


===15:29:29===
2024-07-04 15:29:01>>>cash read=00
2024-07-04 15:29:02>>>cash read=818F42
2024-07-04 15:29:02>>>cash write=02
2024-07-04 15:29:02 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-07-04 15:29:02>>>cash read=10
2024-07-04 15:29:02 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-07-04 15:29:02 >>>开始打印,排队号为63,订单号为2407041529020018803134
2024-07-04 15:29:02>>>订单2407041529020018803134写入成功,剩余空间为1680500,占用RAM为599.8271484375
删除未同步订单2407041529020018803134
2024-07-04 15:29:04>>>订单2407041529020018803134删除成功,剩余空间为1680500,占用RAM为612.2958984375
检测订单目录中>>>
无未同步订单>>>
2024-07-04 15:29:05 >>>当前Ram内存为585.189453125
定时检测未同步订单启用
2024-07-04 15:29:05>>>cash write=0C
2024-07-04 15:29:06>>>cash read=3E
2024-07-04 15:29:16 >>>回调事件[910,devices/TL1880]
2024-07-04 15:29:16 >>>故障排除日志:上一MQTT订单号缓存列表为24070415233804885794
2024-07-04 15:29:16 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 15:29:16 开始打印,排队:64,票券:2407041529093560055101,订单:24070415290935593635,[2024-07-04 15:29:09微信支付10元]
2024-07-04 15:29:18 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407041529093560055101","queue_number":64,"trade_uid":"24070415290935593635"}]}
2024-07-04 15:29:18 >>>故障排除日志:删除未同步下发订单成功24070415290935593635
2024-07-04 15:29:18 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


===15:38:30===
2024-07-04 15:38:00>>>cash read=00
2024-07-04 15:38:01>>>cash read=818F42
2024-07-04 15:38:01>>>cash write=02
2024-07-04 15:38:01 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-07-04 15:38:01>>>cash read=10
2024-07-04 15:38:01 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-07-04 15:38:01 >>>开始打印,排队号为67,订单号为2407041538010018805300
2024-07-04 15:38:02>>>订单2407041538010018805300写入成功,剩余空间为1680500,占用RAM为599.9541015625
删除未同步订单2407041538010018805300
2024-07-04 15:38:04>>>订单2407041538010018805300删除成功,剩余空间为1680500,占用RAM为614.0615234375
检测订单目录中>>>
无未同步订单>>>
2024-07-04 15:38:04 >>>当前Ram内存为585.2880859375
定时检测未同步订单启用
2024-07-04 15:38:05>>>cash write=0C
2024-07-04 15:38:05>>>cash read=3E


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


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


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


===16:00:31===
2024-07-04 15:59:34 >>>回调事件[910,devices/TL1880]
2024-07-04 15:59:34 >>>故障排除日志:上一MQTT订单号缓存列表为24070415492360742657
2024-07-04 15:59:34 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 15:59:34 开始打印,排队:70,票券:2407041559225865604701,订单:24070415592258652161,[2024-07-04 15:59:22支付宝支付10元]
2024-07-04 15:59:36 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407041559225865604701","queue_number":70,"trade_uid":"24070415592258652161"}]}
2024-07-04 15:59:36 >>>故障排除日志:删除未同步下发订单成功24070415592258652161
2024-07-04 15:59:36 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


===16:13:32===
2024-07-04 16:12:56>>>cash read=0A
2024-07-04 16:12:57>>>cash read=3E
2024-07-04 16:12:58 >>>回调事件[910,devices/TL1880]
2024-07-04 16:12:58 >>>故障排除日志:上一MQTT订单号缓存列表为24070416105568702494
2024-07-04 16:12:58 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 16:12:58 开始打印,排队:73,票券:2407041612522262702901,订单:24070416125222622594,[2024-07-04 16:12:52微信支付10元]
2024-07-04 16:13:01 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407041612522262702901","queue_number":73,"trade_uid":"24070416125222622594"}]}
2024-07-04 16:13:01 >>>故障排除日志:删除未同步下发订单成功24070416125222622594
2024-07-04 16:13:01 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


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


===16:41:33===
2024-07-04 16:41:01 >>>回调事件[910,devices/TL1880]
2024-07-04 16:41:01 >>>故障排除日志:上一MQTT订单号缓存列表为24070416401926614159
2024-07-04 16:41:01 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 16:41:01 开始打印,排队:79,票券:2407041640543506827901,订单:24070416405435062074,[2024-07-04 16:40:54微信支付10元]
2024-07-04 16:41:03 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407041640543506827901","queue_number":79,"trade_uid":"24070416405435062074"}]}
2024-07-04 16:41:03 >>>故障排除日志:删除未同步下发订单成功24070416405435062074
2024-07-04 16:41:03 >>>故障排除日志:终端同步成功后剩余订单列表
2024-07-04 16:41:23 >>>回调事件[910,devices/TL1880]
2024-07-04 16:41:23 >>>故障排除日志:上一MQTT订单号缓存列表为24070416405435062074
2024-07-04 16:41:23 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 16:41:23 开始打印,排队:80,票券:2407041641150922347601,订单:24070416411509218647,[2024-07-04 16:41:15微信支付10元]
2024-07-04 16:41:23 开始打印,排队:81,票券:2407041641150922491502,订单:24070416411509218647,[2024-07-04 16:41:15微信支付10元]
2024-07-04 16:41:27 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407041641150922347601","queue_number":80,"trade_uid":"24070416411509218647"},{"ticket_no":"2407041641150922491502","queue_number":81,"trade_uid":"24070416411509218647"}]}
2024-07-04 16:41:27 >>>故障排除日志:删除未同步下发订单成功24070416411509218647
2024-07-04 16:41:27 >>>故障排除日志:删除未同步下发订单成功24070416411509218647
2024-07-04 16:41:27 >>>故障排除日志:终端同步成功后剩余订单列表


===16:48:33===
2024-07-04 16:47:35 >>>回调事件[910,devices/TL1880]
2024-07-04 16:47:35 >>>故障排除日志:上一MQTT订单号缓存列表为24070416411509218647|24070416411509218647
2024-07-04 16:47:35 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 16:47:36 开始打印,排队:82,票券:2407041647252560504601,订单:24070416472525601690,[2024-07-04 16:47:25支付宝支付10元]
2024-07-04 16:47:37 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407041647252560504601","queue_number":82,"trade_uid":"24070416472525601690"}]}
2024-07-04 16:47:37 >>>故障排除日志:删除未同步下发订单成功24070416472525601690
2024-07-04 16:47:38 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


===16:59:34===
2024-07-04 16:58:41>>>cash read=2F29
2024-07-04 16:58:42>>>cash read=01
2024-07-04 16:58:43>>>cash read=2F
2024-07-04 16:58:44>>>cash read=3E
2024-07-04 16:58:49>>>cash read=00
2024-07-04 16:58:50>>>cash read=818F42
2024-07-04 16:58:50>>>cash write=02
2024-07-04 16:58:50 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-07-04 16:58:50>>>cash read=10
2024-07-04 16:58:50 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-07-04 16:58:50 >>>开始打印,排队号为85,订单号为2407041658500018802276
2024-07-04 16:58:50>>>订单2407041658500018802276写入成功,剩余空间为1679500,占用RAM为600.5654296875
删除未同步订单2407041658500018802276
2024-07-04 16:58:53>>>订单2407041658500018802276删除成功,剩余空间为1680500,占用RAM为612.859375
检测订单目录中>>>
无未同步订单>>>
2024-07-04 16:58:53 >>>当前Ram内存为585.39453125
定时检测未同步订单启用
2024-07-04 16:58:54>>>cash write=0C
2024-07-04 16:58:54>>>cash read=3E


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


===17:07:34===
2024-07-04 17:06:42>>>cash read=0A
2024-07-04 17:06:43>>>cash read=3E


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


===17:22:35===
2024-07-04 17:22:11 >>>回调事件[910,devices/TL1880]
2024-07-04 17:22:11 >>>故障排除日志:上一MQTT订单号缓存列表为24070417080080989820
2024-07-04 17:22:11 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 17:22:11 开始打印,排队:87,票券:2407041722030217325901,订单:24070417220302165335,[2024-07-04 17:22:03支付宝支付10元]
2024-07-04 17:22:13 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407041722030217325901","queue_number":87,"trade_uid":"24070417220302165335"}]}
2024-07-04 17:22:13 >>>故障排除日志:删除未同步下发订单成功24070417220302165335
2024-07-04 17:22:13 >>>故障排除日志:终端同步成功后剩余订单列表


===17:28:35===
2024-07-04 17:28:10>>>cash read=00
2024-07-04 17:28:10>>>cash read=818F42
2024-07-04 17:28:10>>>cash write=02
2024-07-04 17:28:10 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-07-04 17:28:11>>>cash read=10
2024-07-04 17:28:11 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-07-04 17:28:11 >>>开始打印,排队号为88,订单号为2407041728110018804333
2024-07-04 17:28:11>>>订单2407041728110018804333写入成功,剩余空间为1680500,占用RAM为599.74609375
删除未同步订单2407041728110018804333
2024-07-04 17:28:13>>>订单2407041728110018804333删除成功,剩余空间为1680500,占用RAM为613.96875
检测订单目录中>>>
无未同步订单>>>
2024-07-04 17:28:13 >>>当前Ram内存为585.2880859375
定时检测未同步订单启用
2024-07-04 17:28:14>>>cash write=0C
2024-07-04 17:28:14>>>cash read=3E


===17:29:37===
定时检测未同步订单关闭
检测订单目录中>>>
无未同步订单>>>
2024-07-04 17:29:34 >>>回调事件[910,devices/TL1880]
2024-07-04 17:29:34 >>>故障排除日志:上一MQTT订单号缓存列表为24070417220302165335
2024-07-04 17:29:34 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 17:29:34 开始打印,排队:89,票券:2407041729284004754301,订单:24070417292840040354,[2024-07-04 17:29:28微信支付10元]


===17:30:37===
2024-07-04 17:29:36 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407041729284004754301","queue_number":89,"trade_uid":"24070417292840040354"}]}
2024-07-04 17:29:36 >>>故障排除日志:删除未同步下发订单成功24070417292840040354
2024-07-04 17:29:36 >>>故障排除日志:终端同步成功后剩余订单列表


===17:34:37===
2024-07-04 17:33:50>>>cash read=0A
2024-07-04 17:33:51>>>cash read=3E


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


===17:36:38===
2024-07-04 17:36:07 >>>回调事件[910,devices/TL1880]
2024-07-04 17:36:07 >>>故障排除日志:上一MQTT订单号缓存列表为24070417343195509582
2024-07-04 17:36:07 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 17:36:07 开始打印,排队:91,票券:2407041735566383193501,订单:24070417355663821937,[2024-07-04 17:35:56微信支付10元]
2024-07-04 17:36:09 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407041735566383193501","queue_number":91,"trade_uid":"24070417355663821937"}]}
2024-07-04 17:36:09 >>>故障排除日志:删除未同步下发订单成功24070417355663821937
2024-07-04 17:36:09 >>>故障排除日志:终端同步成功后剩余订单列表
2024-07-04 17:36:15 >>>回调事件[910,devices/TL1880]
2024-07-04 17:36:15 >>>故障排除日志:上一MQTT订单号缓存列表为24070417355663821937
2024-07-04 17:36:15 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 17:36:15 开始打印,排队:92,票券:2407041736085342755901,订单:24070417360853423343,[2024-07-04 17:36:08微信支付10元]
2024-07-04 17:36:17 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407041736085342755901","queue_number":92,"trade_uid":"24070417360853423343"}]}
2024-07-04 17:36:17 >>>故障排除日志:删除未同步下发订单成功24070417360853423343
2024-07-04 17:36:17 >>>故障排除日志:终端同步成功后剩余订单列表


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


===17:55:38===
2024-07-04 17:54:41 >>>回调事件[910,devices/TL1880]
2024-07-04 17:54:41 >>>故障排除日志:上一MQTT订单号缓存列表为24070417455297819932
2024-07-04 17:54:41 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 17:54:41 开始打印,排队:94,票券:2407041754343728418001,订单:24070417543437280346,[2024-07-04 17:54:34支付宝支付10元]
2024-07-04 17:54:43 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407041754343728418001","queue_number":94,"trade_uid":"24070417543437280346"}]}
2024-07-04 17:54:43 >>>故障排除日志:删除未同步下发订单成功24070417543437280346
2024-07-04 17:54:43 >>>故障排除日志:终端同步成功后剩余订单列表


===17:57:39===
2024-07-04 17:56:42 >>>回调事件[910,devices/TL1880]
2024-07-04 17:56:42 >>>故障排除日志:上一MQTT订单号缓存列表为24070417543437280346
2024-07-04 17:56:42 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 17:56:42 开始打印,排队:95,票券:2407041756342640756801,订单:24070417563426402756,[2024-07-04 17:56:34微信支付10元]
2024-07-04 17:56:42 开始打印,排队:96,票券:2407041756342640910302,订单:24070417563426402756,[2024-07-04 17:56:34微信支付10元]
2024-07-04 17:56:42 开始打印,排队:97,票券:2407041756342640971803,订单:24070417563426402756,[2024-07-04 17:56:34微信支付10元]
2024-07-04 17:56:47 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407041756342640756801","queue_number":95,"trade_uid":"24070417563426402756"},{"ticket_no":"2407041756342640910302","queue_number":96,"trade_uid":"24070417563426402756"},{"ticket_no":"2407041756342640971803","queue_number":97,"trade_uid":"24070417563426402756"}]}
2024-07-04 17:56:47 >>>故障排除日志:删除未同步下发订单成功24070417563426402756
2024-07-04 17:56:47 >>>故障排除日志:删除未同步下发订单成功24070417563426402756
2024-07-04 17:56:47 >>>故障排除日志:删除未同步下发订单成功24070417563426402756
2024-07-04 17:56:48 >>>故障排除日志:终端同步成功后剩余订单列表


===18:00:39===
2024-07-04 18:00:16 >>>回调事件[910,devices/TL1880]
2024-07-04 18:00:16 >>>故障排除日志:上一MQTT订单号缓存列表为24070417563426402756|24070417563426402756|24070417563426402756
2024-07-04 18:00:16 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 18:00:16 开始打印,排队:98,票券:2407041800047802527201,订单:24070418000478020698,[2024-07-04 18:00:04支付宝支付10元]
2024-07-04 18:00:18 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407041800047802527201","queue_number":98,"trade_uid":"24070418000478020698"}]}
2024-07-04 18:00:18 >>>故障排除日志:删除未同步下发订单成功24070418000478020698
2024-07-04 18:00:18 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


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


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


===18:21:42===
2024-07-04 18:21:14>>>cash read=29
2024-07-04 18:21:14 >>>回调事件130,cash_status,20029,退钞中
2024-07-04 18:21:16>>>cash read=00
2024-07-04 18:21:16>>>cash read=2F29
2024-07-04 18:21:17>>>cash read=01
2024-07-04 18:21:21>>>cash read=2F
2024-07-04 18:21:22>>>cash read=2F29
2024-07-04 18:21:23>>>cash read=01
2024-07-04 18:21:33>>>cash read=2F
2024-07-04 18:21:34>>>cash read=3E
2024-07-04 18:21:38>>>cash read=00
2024-07-04 18:21:38>>>cash read=818F42
2024-07-04 18:21:38>>>cash write=02
2024-07-04 18:21:38 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-07-04 18:21:39>>>cash read=10
2024-07-04 18:21:39 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-07-04 18:21:39 >>>开始打印,排队号为105,订单号为2407041821390018804015
2024-07-04 18:21:39>>>订单2407041821390018804015写入成功,剩余空间为1679500,占用RAM为602.078125


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


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


===18:30:43===
2024-07-04 18:30:41 >>>回调事件[910,devices/TL1880]
2024-07-04 18:30:41 >>>故障排除日志:上一MQTT订单号缓存列表为24070418174846138412
2024-07-04 18:30:41 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 18:30:41 开始打印,排队:106,票券:2407041830339241439201,订单:24070418303392410664,[2024-07-04 18:30:33微信支付10元]


===18:31:47===
2024-07-04 18:30:43 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407041830339241439201","queue_number":106,"trade_uid":"24070418303392410664"}]}
2024-07-04 18:30:43 >>>故障排除日志:删除未同步下发订单成功24070418303392410664
2024-07-04 18:30:43 >>>故障排除日志:终端同步成功后剩余订单列表
2024-07-04 18:30:58 >>>回调事件[910,devices/TL1880]
2024-07-04 18:30:58 >>>故障排除日志:上一MQTT订单号缓存列表为24070418303392410664
2024-07-04 18:30:58 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 18:30:58 开始打印,排队:107,票券:2407041830520062332701,订单:24070418305200618760,[2024-07-04 18:30:52微信支付10元]
2024-07-04 18:31:01 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407041830520062332701","queue_number":107,"trade_uid":"24070418305200618760"}]}
2024-07-04 18:31:01 >>>故障排除日志:删除未同步下发订单成功24070418305200618760
2024-07-04 18:31:01 >>>故障排除日志:终端同步成功后剩余订单列表
2024-07-04 18:31:23 >>>回调事件[910,devices/TL1880]
2024-07-04 18:31:23 >>>故障排除日志:上一MQTT订单号缓存列表为24070418305200618760
2024-07-04 18:31:23 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 18:31:23 开始打印,排队:108,票券:2407041831107711673001,订单:24070418311077113083,[2024-07-04 18:31:10微信支付10元]
2024-07-04 18:31:25 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407041831107711673001","queue_number":108,"trade_uid":"24070418311077113083"}]}
2024-07-04 18:31:25 >>>故障排除日志:删除未同步下发订单成功24070418311077113083
2024-07-04 18:31:26 >>>故障排除日志:终端同步成功后剩余订单列表


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


===18:37:47===
2024-07-04 18:37:23>>>cash read=00
2024-07-04 18:37:25>>>cash read=818F42
2024-07-04 18:37:25>>>cash write=02
2024-07-04 18:37:25 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-07-04 18:37:25>>>cash read=10
2024-07-04 18:37:25 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-07-04 18:37:25 >>>开始打印,排队号为110,订单号为2407041837250018801389
2024-07-04 18:37:25>>>订单2407041837250018801389写入成功,剩余空间为1680500,占用RAM为600.1533203125
删除未同步订单2407041837250018801389
2024-07-04 18:37:27>>>订单2407041837250018801389删除成功,剩余空间为1680500,占用RAM为612.9677734375
检测订单目录中>>>
无未同步订单>>>
2024-07-04 18:37:27 >>>当前Ram内存为585.515625
定时检测未同步订单启用
2024-07-04 18:37:28>>>cash write=0C
2024-07-04 18:37:29>>>cash read=3E


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


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


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


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


===18:57:48===
2024-07-04 18:56:49>>>cash read=00
2024-07-04 18:56:50>>>cash read=818F42
2024-07-04 18:56:50>>>cash write=02
2024-07-04 18:56:50 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-07-04 18:56:50>>>cash read=10
2024-07-04 18:56:50 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-07-04 18:56:50 >>>开始打印,排队号为115,订单号为2407041856500018803112
2024-07-04 18:56:50>>>订单2407041856500018803112写入成功,剩余空间为1680500,占用RAM为600.34375
删除未同步订单2407041856500018803112
2024-07-04 18:56:53>>>订单2407041856500018803112删除成功,剩余空间为1680500,占用RAM为616.0126953125
检测订单目录中>>>
无未同步订单>>>
2024-07-04 18:56:53 >>>当前Ram内存为585.681640625
定时检测未同步订单启用
2024-07-04 18:56:53>>>cash write=0C
2024-07-04 18:56:54>>>cash read=3E


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


===18:59:49===
2024-07-04 18:59:28 >>>回调事件[910,devices/TL1880]
2024-07-04 18:59:28 >>>故障排除日志:上一MQTT订单号缓存列表为24070418510923722879
2024-07-04 18:59:28 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 18:59:28 开始打印,排队:116,票券:2407041859180475836501,订单:24070418591804754218,[2024-07-04 18:59:18支付宝支付10元]
2024-07-04 18:59:28 开始打印,排队:117,票券:2407041859180475996102,订单:24070418591804754218,[2024-07-04 18:59:18支付宝支付10元]
2024-07-04 18:59:32 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407041859180475836501","queue_number":116,"trade_uid":"24070418591804754218"},{"ticket_no":"2407041859180475996102","queue_number":117,"trade_uid":"24070418591804754218"}]}
2024-07-04 18:59:32 >>>故障排除日志:删除未同步下发订单成功24070418591804754218
2024-07-04 18:59:32 >>>故障排除日志:删除未同步下发订单成功24070418591804754218
2024-07-04 18:59:32 >>>故障排除日志:终端同步成功后剩余订单列表


===19:00:49===
2024-07-04 18:59:58 >>>回调事件[910,devices/TL1880]
2024-07-04 18:59:58 >>>故障排除日志:上一MQTT订单号缓存列表为24070418591804754218|24070418591804754218
2024-07-04 18:59:58 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 18:59:58 开始打印,排队:118,票券:2407041859478271109701,订单:24070418594782707172,[2024-07-04 18:59:47微信支付10元]
2024-07-04 18:59:58 开始打印,排队:119,票券:2407041859478271243402,订单:24070418594782707172,[2024-07-04 18:59:47微信支付10元]
2024-07-04 19:00:02 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407041859478271109701","queue_number":118,"trade_uid":"24070418594782707172"},{"ticket_no":"2407041859478271243402","queue_number":119,"trade_uid":"24070418594782707172"}]}
2024-07-04 19:00:02 >>>故障排除日志:删除未同步下发订单成功24070418594782707172
2024-07-04 19:00:02 >>>故障排除日志:删除未同步下发订单成功24070418594782707172
2024-07-04 19:00:02 >>>故障排除日志:终端同步成功后剩余订单列表
2024-07-04 19:00:16 >>>回调事件[910,devices/TL1880]
2024-07-04 19:00:16 >>>故障排除日志:上一MQTT订单号缓存列表为24070418594782707172|24070418594782707172
2024-07-04 19:00:16 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 19:00:16 开始打印,排队:120,票券:2407041900072645407501,订单:24070419000726446681,[2024-07-04 19:00:07微信支付10元]
2024-07-04 19:00:18 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407041900072645407501","queue_number":120,"trade_uid":"24070419000726446681"}]}
2024-07-04 19:00:18 >>>故障排除日志:删除未同步下发订单成功24070419000726446681
2024-07-04 19:00:18 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


===19:16:50===
2024-07-04 19:16:19 >>>回调事件[910,devices/TL1880]
2024-07-04 19:16:19 >>>故障排除日志:上一MQTT订单号缓存列表为24070419152878144786
2024-07-04 19:16:19 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 19:16:19 开始打印,排队:125,票券:2407041916061528223901,订单:24070419160615278224,[2024-07-04 19:16:06微信支付10元]
2024-07-04 19:16:21 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407041916061528223901","queue_number":125,"trade_uid":"24070419160615278224"}]}
2024-07-04 19:16:21 >>>故障排除日志:删除未同步下发订单成功24070419160615278224
2024-07-04 19:16:21 >>>故障排除日志:终端同步成功后剩余订单列表
2024-07-04 19:16:26 >>>回调事件[910,devices/TL1880]
2024-07-04 19:16:26 >>>故障排除日志:上一MQTT订单号缓存列表为24070419160615278224
2024-07-04 19:16:26 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 19:16:26 开始打印,排队:126,票券:2407041916183951400901,订单:24070419161839510284,[2024-07-04 19:16:18微信支付10元]
2024-07-04 19:16:29 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407041916183951400901","queue_number":126,"trade_uid":"24070419161839510284"}]}
2024-07-04 19:16:29 >>>故障排除日志:删除未同步下发订单成功24070419161839510284
2024-07-04 19:16:29 >>>故障排除日志:终端同步成功后剩余订单列表


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


===19:19:50===
2024-07-04 19:19:30 >>>回调事件[910,devices/TL1880]
2024-07-04 19:19:30 >>>故障排除日志:上一MQTT订单号缓存列表为24070419183185450541
2024-07-04 19:19:30 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 19:19:30 开始打印,排队:128,票券:2407041919238284690701,订单:24070419192382839948,[2024-07-04 19:19:23支付宝支付10元]
2024-07-04 19:19:32 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407041919238284690701","queue_number":128,"trade_uid":"24070419192382839948"}]}
2024-07-04 19:19:32 >>>故障排除日志:删除未同步下发订单成功24070419192382839948
2024-07-04 19:19:32 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


===19:45:52===
2024-07-04 19:45:09 >>>回调事件[910,devices/TL1880]
2024-07-04 19:45:09 >>>故障排除日志:上一MQTT订单号缓存列表为24070419434830531830
2024-07-04 19:45:09 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 19:45:09 开始打印,排队:132,票券:2407041945031289687501,订单:24070419450312893484,[2024-07-04 19:45:03支付宝支付10元]
2024-07-04 19:45:11 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407041945031289687501","queue_number":132,"trade_uid":"24070419450312893484"}]}
2024-07-04 19:45:11 >>>故障排除日志:删除未同步下发订单成功24070419450312893484
2024-07-04 19:45:11 >>>故障排除日志:终端同步成功后剩余订单列表


===19:46:52===
2024-07-04 19:46:30 >>>回调事件[910,devices/TL1880]
2024-07-04 19:46:30 >>>故障排除日志:上一MQTT订单号缓存列表为24070419450312893484
2024-07-04 19:46:30 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 19:46:30 开始打印,排队:133,票券:2407041946207890699701,订单:24070419462078903337,[2024-07-04 19:46:20微信支付10元]
2024-07-04 19:46:32 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407041946207890699701","queue_number":133,"trade_uid":"24070419462078903337"}]}
2024-07-04 19:46:32 >>>故障排除日志:删除未同步下发订单成功24070419462078903337
2024-07-04 19:46:32 >>>故障排除日志:终端同步成功后剩余订单列表
2024-07-04 19:46:47 >>>回调事件[910,devices/TL1880]
2024-07-04 19:46:47 >>>故障排除日志:上一MQTT订单号缓存列表为24070419462078903337
2024-07-04 19:46:48 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 19:46:48 开始打印,排队:134,票券:2407041946406257814601,订单:24070419464062574261,[2024-07-04 19:46:40微信支付10元]
2024-07-04 19:46:50 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407041946406257814601","queue_number":134,"trade_uid":"24070419464062574261"}]}
2024-07-04 19:46:50 >>>故障排除日志:删除未同步下发订单成功24070419464062574261
2024-07-04 19:46:50 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


===20:00:53===
2024-07-04 20:00:32 >>>回调事件[910,devices/TL1880]
2024-07-04 20:00:33 >>>故障排除日志:上一MQTT订单号缓存列表为24070419581954770871
2024-07-04 20:00:33 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 20:00:33 开始打印,排队:139,票券:2407042000232912067501,订单:24070420002329113703,[2024-07-04 20:00:23支付宝支付10元]
2024-07-04 20:00:35 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407042000232912067501","queue_number":139,"trade_uid":"24070420002329113703"}]}
2024-07-04 20:00:35 >>>故障排除日志:删除未同步下发订单成功24070420002329113703
2024-07-04 20:00:35 >>>故障排除日志:终端同步成功后剩余订单列表
2024-07-04 20:00:38 >>>回调事件[910,devices/TL1880]
2024-07-04 20:00:38 >>>故障排除日志:上一MQTT订单号缓存列表为24070420002329113703
2024-07-04 20:00:38 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 20:00:38 开始打印,排队:140,票券:2407042000268836375801,订单:24070420002688358649,[2024-07-04 20:00:26微信支付10元]
2024-07-04 20:00:40 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407042000268836375801","queue_number":140,"trade_uid":"24070420002688358649"}]}
2024-07-04 20:00:40 >>>故障排除日志:删除未同步下发订单成功24070420002688358649
2024-07-04 20:00:40 >>>故障排除日志:终端同步成功后剩余订单列表


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


===20:06:54===
2024-07-04 20:06:00 >>>回调事件[910,devices/TL1880]
2024-07-04 20:06:00 >>>故障排除日志:上一MQTT订单号缓存列表为24070420050696918367
2024-07-04 20:06:00 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 20:06:00 开始打印,排队:142,票券:2407042005511644103501,订单:24070420055116436741,[2024-07-04 20:05:51微信支付10元]
2024-07-04 20:06:00 开始打印,排队:143,票券:2407042005511644259802,订单:24070420055116436741,[2024-07-04 20:05:51微信支付10元]
2024-07-04 20:06:04 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407042005511644103501","queue_number":142,"trade_uid":"24070420055116436741"},{"ticket_no":"2407042005511644259802","queue_number":143,"trade_uid":"24070420055116436741"}]}
2024-07-04 20:06:04 >>>故障排除日志:删除未同步下发订单成功24070420055116436741
2024-07-04 20:06:04 >>>故障排除日志:删除未同步下发订单成功24070420055116436741
2024-07-04 20:06:04 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


===20:19:56===
2024-07-04 20:19:16 >>>回调事件[910,devices/TL1880]
2024-07-04 20:19:16 >>>故障排除日志:上一MQTT订单号缓存列表为24070420144208347340
2024-07-04 20:19:16 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 20:19:16 开始打印,排队:146,票券:2407042019088861784601,订单:24070420190888610450,[2024-07-04 20:19:08微信支付10元]
2024-07-04 20:19:18 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407042019088861784601","queue_number":146,"trade_uid":"24070420190888610450"}]}
2024-07-04 20:19:18 >>>故障排除日志:删除未同步下发订单成功24070420190888610450
2024-07-04 20:19:18 >>>故障排除日志:终端同步成功后剩余订单列表
2024-07-04 20:19:53 >>>回调事件[910,devices/TL1880]
2024-07-04 20:19:53 >>>故障排除日志:上一MQTT订单号缓存列表为24070420190888610450
2024-07-04 20:19:53 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 20:19:53 开始打印,排队:147,票券:2407042019425968848701,订单:24070420194259684813,[2024-07-04 20:19:42微信支付10元]


===20:20:56===
2024-07-04 20:19:55 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407042019425968848701","queue_number":147,"trade_uid":"24070420194259684813"}]}
2024-07-04 20:19:55 >>>故障排除日志:删除未同步下发订单成功24070420194259684813
2024-07-04 20:19:55 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


===20:37:58===
2024-07-04 20:37:55 >>>回调事件[910,devices/TL1880]
2024-07-04 20:37:55 >>>故障排除日志:上一MQTT订单号缓存列表为24070420360135076560
2024-07-04 20:37:55 >>>故障排除日志:终端未同步成功订单列表
2024-07-04 20:37:55 开始打印,排队:151,票券:2407042037481343366301,订单:24070420374813429896,[2024-07-04 20:37:48微信支付10元]


===20:38:58===
2024-07-04 20:37:57 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407042037481343366301","queue_number":151,"trade_uid":"24070420374813429896"}]}
2024-07-04 20:37:57 >>>故障排除日志:删除未同步下发订单成功24070420374813429896
2024-07-04 20:37:57 >>>故障排除日志:终端同步成功后剩余订单列表


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


===20:52:59===
2024-07-04 20:52:44>>>cash read=29
2024-07-04 20:52:44 >>>回调事件130,cash_status,20029,退钞中
2024-07-04 20:52:45>>>cash read=3E
2024-07-04 20:52:55>>>cash read=00
2024-07-04 20:52:56>>>cash read=29
2024-07-04 20:52:56 >>>回调事件130,cash_status,20029,退钞中
2024-07-04 20:52:57>>>cash read=2F29


===20:54:00===
2024-07-04 20:52:59>>>cash read=3E
2024-07-04 20:53:05>>>cash read=00
2024-07-04 20:53:06>>>cash read=29
2024-07-04 20:53:06 >>>回调事件130,cash_status,20029,退钞中
2024-07-04 20:53:06>>>cash read=2F29
2024-07-04 20:53:07>>>cash read=01
2024-07-04 20:53:07>>>cash read=2F
2024-07-04 20:53:08>>>cash read=3E
2024-07-04 20:53:09>>>cash read=00
2024-07-04 20:53:11>>>cash read=818F42
2024-07-04 20:53:11>>>cash write=02
2024-07-04 20:53:11 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-07-04 20:53:11>>>cash read=10
2024-07-04 20:53:11 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-07-04 20:53:11 >>>开始打印,排队号为153,订单号为2407042053110018807148
2024-07-04 20:53:11>>>订单2407042053110018807148写入成功,剩余空间为1679500,占用RAM为602.015625
删除未同步订单2407042053110018807148
2024-07-04 20:53:14>>>订单2407042053110018807148删除成功,剩余空间为1680500,占用RAM为613.9677734375
检测订单目录中>>>
无未同步订单>>>
2024-07-04 20:53:14 >>>当前Ram内存为586.2119140625
定时检测未同步订单启用
2024-07-04 20:53:14>>>cash write=0C
2024-07-04 20:53:15>>>cash read=3E


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


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


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


===21:29:01===
2024-07-04 21:28:50>>>cash read=00
2024-07-04 21:28:51>>>cash read=818F43
2024-07-04 21:28:51>>>cash write=02
2024-07-04 21:28:51 >>>回调事件130,cash_status,10022,进钞中...read money=20
2024-07-04 21:28:51>>>cash read=10
2024-07-04 21:28:51 >>>回调事件130,20,10023,finish Money=20,进钞完成
2024-07-04 21:28:51 >>>开始打印,排队号为157,订单号为2407042128510018801307
2024-07-04 21:28:52 >>>开始打印,排队号为158,订单号为2407042128510018801307
2024-07-04 21:28:52>>>订单2407042128510018801307写入成功,剩余空间为1679500,占用RAM为607.431640625
删除未同步订单2407042128510018801307
2024-07-04 21:28:55>>>订单2407042128510018801307删除成功,剩余空间为1680500,占用RAM为625.357421875
检测订单目录中>>>
无未同步订单>>>
2024-07-04 21:28:56 >>>当前Ram内存为587.255859375
定时检测未同步订单启用
2024-07-04 21:28:56>>>cash write=0C
2024-07-04 21:28:56>>>cash read=3E


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