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

===08:14:02===
上一时间戳为1727395942
隔日重置时间戳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:79e6f****beb8e
纸币器设置接收纸币范围为36
欢迎使用天羚自助售票系统[2.5.4]
定时检测未同步订单启用
2024-09-28 08:13:02>>>cash write=30
2024-09-28 08:13:02>>>cash write=02
2024-09-28 08:13:02>>>cash write=3E
2024-09-28 08:13:02>>>cash read=808F808F808F808F
系统时间初始化成功，时间为20249288132
2024-09-28 08:13:03>>>cash write=02
2024-09-28 08:13:03 >>>剩余flash空间=1680500,占用RAM为629.73828125
2024-09-28 08:13:03 >>>回调事件:910,subscribe,10000,连接服务器成功

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

2024-09-28 08:13:06>>>cash write=0C
2024-09-28 08:13:06>>>cash read=3E
流量卡还有153天过期
2024-09-28 08:13:07 >>>回调事件[910,devices/TL1880]
当日首次设置时间戳true为1727482387
2024-09-28 08:13:07 >>>故障排除日志:上一MQTT订单号缓存列表为24092720424545357052
2024-09-28 08:13:07 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 08:13:07 开始打印,排队:1,票券:2409280813009667512901,订单:24092808130096670662,[2024-09-28 08:13:07微信支付10元]
2024-09-28 08:13:09 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409280813009667512901","queue_number":1,"trade_uid":"24092808130096670662"}]}
2024-09-28 08:13:09 >>>故障排除日志:删除未同步下发订单成功24092808130096670662
2024-09-28 08:13:09 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 08:13:10 >>>当前Ram内存为607.666015625


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


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


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


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


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


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


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


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


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


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


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


===09:01:07===
2024-09-28 09:00:07>>>cash read=00
2024-09-28 09:00:08>>>cash read=29
2024-09-28 09:00:08 >>>回调事件130,cash_status,20029,退钞中
2024-09-28 09:00:09>>>cash read=2F29
2024-09-28 09:00:10>>>cash read=3E
2024-09-28 09:00:17>>>cash read=00
2024-09-28 09:00:19>>>cash read=2F29
2024-09-28 09:00:20>>>cash read=3E
2024-09-28 09:00:30>>>cash read=2F29
2024-09-28 09:00:31>>>cash read=01
2024-09-28 09:00:31>>>cash read=2F
2024-09-28 09:00:33>>>cash read=3E
2024-09-28 09:00:35>>>cash read=29
2024-09-28 09:00:35 >>>回调事件130,cash_status,20029,退钞中
2024-09-28 09:00:36>>>cash read=01
2024-09-28 09:00:39>>>cash read=3E
2024-09-28 09:00:45>>>cash read=29
2024-09-28 09:00:45 >>>回调事件130,cash_status,20029,退钞中
2024-09-28 09:00:45>>>cash read=2F29
2024-09-28 09:00:46>>>cash read=01
2024-09-28 09:00:48>>>cash read=2F
2024-09-28 09:00:50>>>cash read=3E


===09:02:07===
2024-09-28 09:01:56>>>cash read=00
2024-09-28 09:01:57>>>cash read=29
2024-09-28 09:01:57 >>>回调事件130,cash_status,20029,退钞中
2024-09-28 09:01:57>>>cash read=2F29
2024-09-28 09:01:59>>>cash read=3E
2024-09-28 09:02:00>>>cash read=00
2024-09-28 09:02:01>>>cash read=29
2024-09-28 09:02:01 >>>回调事件130,cash_status,20029,退钞中
2024-09-28 09:02:01>>>cash read=2F29
2024-09-28 09:02:02>>>cash read=3E
2024-09-28 09:02:04>>>cash read=00
2024-09-28 09:02:05>>>cash read=2F29


===09:09:09===
2024-09-28 09:08:41>>>cash read=00
2024-09-28 09:08:42>>>cash read=29
2024-09-28 09:08:42 >>>回调事件130,cash_status,20029,退钞中
2024-09-28 09:08:43>>>cash read=2F29
2024-09-28 09:08:44>>>cash read=3E
2024-09-28 09:08:45>>>cash read=00
2024-09-28 09:08:47>>>cash read=292F29
2024-09-28 09:08:47 >>>回调事件130,cash_status,20029,退钞中
2024-09-28 09:08:48>>>cash read=3E
2024-09-28 09:09:00>>>cash read=00
2024-09-28 09:09:01>>>cash read=2F29
2024-09-28 09:09:02>>>cash read=00
2024-09-28 09:09:03>>>cash read=3E
2024-09-28 09:09:05>>>cash read=00
2024-09-28 09:09:05>>>cash read=818F42
2024-09-28 09:09:05>>>cash write=02
2024-09-28 09:09:05 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-09-28 09:09:05>>>cash read=10
2024-09-28 09:09:05 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-09-28 09:09:05 当前产品价格10元，投币10元，打印小票中...
2024-09-28 09:09:05 >>>开始打印,排队号为12,订单号为2409280909050018807581
2024-09-28 09:09:05>>>订单2409280909050018807581写入成功,剩余空间为1679000,占用RAM为609.373046875


===09:10:09===
删除未同步订单2409280909050018807581
2024-09-28 09:09:08>>>订单2409280909050018807581删除成功,剩余空间为1681500,占用RAM为625.3876953125
检测订单目录中>>>
无未同步订单>>>
2024-09-28 09:09:08 >>>当前Ram内存为590.3369140625
定时检测未同步订单启用
2024-09-28 09:09:08>>>cash write=0C
2024-09-28 09:09:09>>>cash read=3E
2024-09-28 09:09:55>>>cash read=0A
2024-09-28 09:09:56>>>cash read=3E
定时检测未同步订单关闭
检测订单目录中>>>
无未同步订单>>>


===09:12:09===
2024-09-28 09:11:45 >>>回调事件[910,devices/TL1880]
2024-09-28 09:11:45 >>>故障排除日志:上一MQTT订单号缓存列表为24092808504209185687
2024-09-28 09:11:45 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 09:11:46 开始打印,排队:13,票券:2409280911364252552301,订单:24092809113642520556,[2024-09-28 09:11:45支付宝支付10元]
2024-09-28 09:11:48 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409280911364252552301","queue_number":13,"trade_uid":"24092809113642520556"}]}
2024-09-28 09:11:48 >>>故障排除日志:删除未同步下发订单成功24092809113642520556
2024-09-28 09:11:48 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 09:11:51>>>cash read=00
2024-09-28 09:11:52>>>cash read=818F42
2024-09-28 09:11:52>>>cash write=02
2024-09-28 09:11:52 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-09-28 09:11:53>>>cash read=10
2024-09-28 09:11:53 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-09-28 09:11:53 当前产品价格10元，投币10元，打印小票中...
2024-09-28 09:11:53 >>>开始打印,排队号为14,订单号为2409280911530018804940
2024-09-28 09:11:53>>>订单2409280911530018804940写入成功,剩余空间为1679000,占用RAM为612.42578125
删除未同步订单2409280911530018804940
2024-09-28 09:11:55>>>订单2409280911530018804940删除成功,剩余空间为1680000,占用RAM为625.830078125
检测订单目录中>>>
无未同步订单>>>
2024-09-28 09:11:55 >>>当前Ram内存为593.595703125
定时检测未同步订单启用
2024-09-28 09:11:56>>>cash write=0C
2024-09-28 09:11:56>>>cash read=3E


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


===09:14:12===
2024-09-28 09:13:11 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409280913026638538601","queue_number":15,"trade_uid":"24092809130266380231"}]}
2024-09-28 09:13:11 >>>故障排除日志:删除未同步下发订单成功24092809130266380231
2024-09-28 09:13:11 >>>故障排除日志:终端同步成功后剩余订单列表


===09:20:13===
2024-09-28 09:19:23>>>cash read=00
2024-09-28 09:19:24>>>cash read=2F29
2024-09-28 09:19:25 >>>回调事件130,cash_status,20029,退钞中
2024-09-28 09:19:26>>>cash read=00
2024-09-28 09:19:27>>>cash read=818F42
2024-09-28 09:19:27>>>cash write=02
2024-09-28 09:19:27 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-09-28 09:19:28>>>cash read=10
2024-09-28 09:19:28 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-09-28 09:19:28 当前产品价格10元，投币10元，打印小票中...
2024-09-28 09:19:28 >>>开始打印,排队号为16,订单号为2409280919280018809486
2024-09-28 09:19:28>>>订单2409280919280018809486写入成功,剩余空间为1679500,占用RAM为608.8896484375
删除未同步订单2409280919280018809486
2024-09-28 09:19:30>>>订单2409280919280018809486删除成功,剩余空间为1680500,占用RAM为620.9560546875
检测订单目录中>>>
无未同步订单>>>
2024-09-28 09:19:30 >>>当前Ram内存为590.96484375
定时检测未同步订单启用
2024-09-28 09:19:31>>>cash write=0C
2024-09-28 09:19:31>>>cash read=3E


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


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


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


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


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


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


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


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


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


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


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


===09:47:18===
2024-09-28 09:47:05>>>cash read=29
2024-09-28 09:47:05 >>>回调事件130,cash_status,20029,退钞中
2024-09-28 09:47:06>>>cash read=01
2024-09-28 09:47:09>>>cash read=3E
2024-09-28 09:47:12>>>cash read=29
2024-09-28 09:47:12 >>>回调事件130,cash_status,20029,退钞中
2024-09-28 09:47:13>>>cash read=01


===09:48:19===
2024-09-28 09:47:18>>>cash read=00
2024-09-28 09:47:19>>>cash read=3E
2024-09-28 09:47:20>>>cash read=00
2024-09-28 09:47:21>>>cash read=29
2024-09-28 09:47:21 >>>回调事件130,cash_status,20029,退钞中
2024-09-28 09:47:21>>>cash read=2F29
2024-09-28 09:47:22>>>cash read=01
2024-09-28 09:47:23>>>cash read=2F
2024-09-28 09:47:24>>>cash read=3E
2024-09-28 09:47:26>>>cash read=2F29
2024-09-28 09:47:27>>>cash read=01
2024-09-28 09:47:31>>>cash read=2F
2024-09-28 09:47:32>>>cash read=01
2024-09-28 09:47:40>>>cash read=00
2024-09-28 09:47:41>>>cash read=29
2024-09-28 09:47:41 >>>回调事件130,cash_status,20029,退钞中
2024-09-28 09:47:42>>>cash read=2F29
2024-09-28 09:47:43>>>cash read=3E
2024-09-28 09:47:46>>>cash read=00
2024-09-28 09:47:47>>>cash read=818F42
2024-09-28 09:47:47>>>cash write=02
2024-09-28 09:47:47 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-09-28 09:47:47>>>cash read=10
2024-09-28 09:47:47 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-09-28 09:47:48 当前产品价格10元，投币10元，打印小票中...
2024-09-28 09:47:48 >>>开始打印,排队号为27,订单号为2409280947480018801480
2024-09-28 09:47:48>>>订单2409280947480018801480写入成功,剩余空间为1679000,占用RAM为612.8935546875
删除未同步订单2409280947480018801480
2024-09-28 09:47:50>>>订单2409280947480018801480删除成功,剩余空间为1680000,占用RAM为623.5087890625
检测订单目录中>>>
无未同步订单>>>
2024-09-28 09:47:50 >>>当前Ram内存为592.2255859375
定时检测未同步订单启用
2024-09-28 09:47:51>>>cash write=0C
2024-09-28 09:47:51>>>cash read=3E


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


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


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


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


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


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


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


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


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


===10:17:23===
2024-09-28 10:17:10>>>cash read=9E
2024-09-28 10:17:11>>>cash read=3E


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


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


===10:21:24===
2024-09-28 10:21:22>>>cash read=00
2024-09-28 10:21:23>>>cash read=818F42
2024-09-28 10:21:23>>>cash write=02
2024-09-28 10:21:23 >>>回调事件130,cash_status,10022,进钞中...read money=10


===10:22:26===
删除未同步订单2409281021230018808951
2024-09-28 10:21:25>>>订单2409281021230018808951删除成功,剩余空间为1681500,占用RAM为625.2587890625
检测订单目录中>>>
无未同步订单>>>
2024-09-28 10:21:26 >>>当前Ram内存为591.970703125
定时检测未同步订单启用
2024-09-28 10:21:26>>>cash write=0C
2024-09-28 10:21:26>>>cash read=3E


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


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


===10:48:28===
2024-09-28 10:47:32 >>>回调事件[910,devices/TL1880]
2024-09-28 10:47:32 >>>故障排除日志:上一MQTT订单号缓存列表为24092810430523223182
2024-09-28 10:47:32 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 10:47:32 开始打印,排队:43,票券:2409281047165072419001,订单:24092810471650719991,[2024-09-28 10:47:31微信支付10元]
2024-09-28 10:47:34 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281047165072419001","queue_number":43,"trade_uid":"24092810471650719991"}]}
2024-09-28 10:47:34 >>>故障排除日志:删除未同步下发订单成功24092810471650719991
2024-09-28 10:47:34 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 10:48:10 >>>回调事件[910,devices/TL1880]
2024-09-28 10:48:10 >>>故障排除日志:上一MQTT订单号缓存列表为24092810471650719991
2024-09-28 10:48:10 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 10:48:10 开始打印,排队:44,票券:2409281047512934290301,订单:24092810475129337680,[2024-09-28 10:48:09微信支付10元]
2024-09-28 10:48:12 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281047512934290301","queue_number":44,"trade_uid":"24092810475129337680"}]}
2024-09-28 10:48:12 >>>故障排除日志:删除未同步下发订单成功24092810475129337680
2024-09-28 10:48:12 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


===11:06:30===
定时检测未同步订单关闭
检测订单目录中>>>
无未同步订单>>>
2024-09-28 11:06:25>>>cash read=00
2024-09-28 11:06:26>>>cash read=818F42
2024-09-28 11:06:26>>>cash write=02
2024-09-28 11:06:26 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-09-28 11:06:26>>>cash read=10
2024-09-28 11:06:26 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-09-28 11:06:26 当前产品价格10元，投币10元，打印小票中...
2024-09-28 11:06:26 >>>开始打印,排队号为48,订单号为2409281106260018809194
2024-09-28 11:06:26>>>订单2409281106260018809194写入成功,剩余空间为1679500,占用RAM为608.806640625
删除未同步订单2409281106260018809194
2024-09-28 11:06:29>>>订单2409281106260018809194删除成功,剩余空间为1680500,占用RAM为621.345703125
检测订单目录中>>>
无未同步订单>>>
2024-09-28 11:06:29 >>>当前Ram内存为591.1298828125
定时检测未同步订单启用


===11:07:31===
2024-09-28 11:06:29>>>cash write=0C
2024-09-28 11:06:29>>>cash read=3E
定时检测未同步订单关闭
检测订单目录中>>>
无未同步订单>>>


===11:16:32===
2024-09-28 11:16:29 >>>回调事件[910,devices/TL1880]
2024-09-28 11:16:29 >>>故障排除日志:上一MQTT订单号缓存列表为24092811035451400258
2024-09-28 11:16:29 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 11:16:29 开始打印,排队:49,票券:2409281116226345720701,订单:24092811162263453265,[2024-09-28 11:16:28微信支付10元]


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


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


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


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


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


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


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


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


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


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


===12:17:37===
2024-09-28 12:16:41 >>>回调事件[910,devices/TL1880]
2024-09-28 12:16:41 >>>故障排除日志:上一MQTT订单号缓存列表为24092812113621851898
2024-09-28 12:16:41 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 12:16:41 开始打印,排队:61,票券:2409281216327951483501,订单:24092812163279511107,[2024-09-28 12:16:40支付宝支付10元]
2024-09-28 12:16:43 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281216327951483501","queue_number":61,"trade_uid":"24092812163279511107"}]}
2024-09-28 12:16:43 >>>故障排除日志:删除未同步下发订单成功24092812163279511107
2024-09-28 12:16:43 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 12:17:15 >>>回调事件[910,devices/TL1880]
2024-09-28 12:17:15 >>>故障排除日志:上一MQTT订单号缓存列表为24092812163279511107
2024-09-28 12:17:15 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 12:17:15 开始打印,排队:62,票券:2409281217083976495001,订单:24092812170839760260,[2024-09-28 12:17:15微信支付10元]
2024-09-28 12:17:15 开始打印,排队:63,票券:2409281217083976668702,订单:24092812170839760260,[2024-09-28 12:17:15微信支付10元]
2024-09-28 12:17:15 开始打印,排队:64,票券:2409281217083976728403,订单:24092812170839760260,[2024-09-28 12:17:15微信支付10元]
2024-09-28 12:17:21 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281217083976495001","queue_number":62,"trade_uid":"24092812170839760260"},{"ticket_no":"2409281217083976668702","queue_number":63,"trade_uid":"24092812170839760260"},{"ticket_no":"2409281217083976728403","queue_number":64,"trade_uid":"24092812170839760260"}]}
2024-09-28 12:17:21 >>>故障排除日志:删除未同步下发订单成功24092812170839760260
2024-09-28 12:17:21 >>>故障排除日志:删除未同步下发订单成功24092812170839760260
2024-09-28 12:17:21 >>>故障排除日志:删除未同步下发订单成功24092812170839760260
2024-09-28 12:17:21 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


===12:43:40===
2024-09-28 12:42:50 >>>回调事件[910,devices/TL1880]
2024-09-28 12:42:50 >>>故障排除日志:上一MQTT订单号缓存列表为24092812305682425138
2024-09-28 12:42:50 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 12:42:50 开始打印,排队:68,票券:2409281242442781957301,订单:24092812424427815658,[2024-09-28 12:42:49支付宝支付10元]
2024-09-28 12:42:52 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281242442781957301","queue_number":68,"trade_uid":"24092812424427815658"}]}
2024-09-28 12:42:52 >>>故障排除日志:删除未同步下发订单成功24092812424427815658
2024-09-28 12:42:52 >>>故障排除日志:终端同步成功后剩余订单列表


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


===13:02:40===
2024-09-28 13:02:03 >>>回调事件[910,devices/TL1880]
2024-09-28 13:02:03 >>>故障排除日志:上一MQTT订单号缓存列表为24092812520230528571
2024-09-28 13:02:03 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 13:02:03 开始打印,排队:70,票券:2409281301580898276901,订单:24092813015808977684,[2024-09-28 13:02:02微信支付10元]
2024-09-28 13:02:05 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281301580898276901","queue_number":70,"trade_uid":"24092813015808977684"}]}
2024-09-28 13:02:05 >>>故障排除日志:删除未同步下发订单成功24092813015808977684
2024-09-28 13:02:05 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 13:02:18 >>>回调事件[910,devices/TL1880]
2024-09-28 13:02:18 >>>故障排除日志:上一MQTT订单号缓存列表为24092813015808977684
2024-09-28 13:02:18 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 13:02:18 开始打印,排队:71,票券:2409281302122191901801,订单:24092813021221914547,[2024-09-28 13:02:17支付宝支付10元]
2024-09-28 13:02:20 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281302122191901801","queue_number":71,"trade_uid":"24092813021221914547"}]}
2024-09-28 13:02:20 >>>故障排除日志:删除未同步下发订单成功24092813021221914547
2024-09-28 13:02:20 >>>故障排除日志:终端同步成功后剩余订单列表


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


===13:15:41===
2024-09-28 13:14:43 >>>回调事件[910,devices/TL1880]
2024-09-28 13:14:43 >>>故障排除日志:上一MQTT订单号缓存列表为24092813064055813105
2024-09-28 13:14:43 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 13:14:43 开始打印,排队:73,票券:2409281314364150740101,订单:24092813143641501341,[2024-09-28 13:14:42支付宝支付10元]
2024-09-28 13:14:45 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281314364150740101","queue_number":73,"trade_uid":"24092813143641501341"}]}
2024-09-28 13:14:45 >>>故障排除日志:删除未同步下发订单成功24092813143641501341
2024-09-28 13:14:45 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 13:15:36 >>>回调事件[910,devices/TL1880]
2024-09-28 13:15:36 >>>故障排除日志:上一MQTT订单号缓存列表为24092813143641501341
2024-09-28 13:15:36 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 13:15:36 开始打印,排队:74,票券:2409281315308528222301,订单:24092813153085274532,[2024-09-28 13:15:36微信支付10元]
2024-09-28 13:15:39 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281315308528222301","queue_number":74,"trade_uid":"24092813153085274532"}]}
2024-09-28 13:15:39 >>>故障排除日志:删除未同步下发订单成功24092813153085274532
2024-09-28 13:15:39 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


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


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


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


===14:16:47===
2024-09-28 14:16:27>>>cash read=00
2024-09-28 14:16:28>>>cash read=2F29
2024-09-28 14:16:29>>>cash read=01
2024-09-28 14:16:33>>>cash read=2F
2024-09-28 14:16:34>>>cash read=29
2024-09-28 14:16:34 >>>回调事件130,cash_status,20029,退钞中
2024-09-28 14:16:34>>>cash read=2F29
2024-09-28 14:16:35>>>cash read=01
2024-09-28 14:16:37>>>cash read=2F
2024-09-28 14:16:38>>>cash read=3E
2024-09-28 14:16:40>>>cash read=00
2024-09-28 14:16:41>>>cash read=818F41
2024-09-28 14:16:41>>>cash write=02
2024-09-28 14:16:41 >>>回调事件130,cash_status,10022,进钞中...read money=5
2024-09-28 14:16:42>>>cash read=10
2024-09-28 14:16:42 >>>回调事件130,5,10023,finish Money=5,进钞完成
2024-09-28 14:16:43>>>cash write=0C
2024-09-28 14:16:43>>>cash read=00
2024-09-28 14:16:44>>>cash read=818F41
2024-09-28 14:16:44>>>cash write=02
2024-09-28 14:16:44 >>>回调事件130,cash_status,10022,进钞中...read money=5
2024-09-28 14:16:44>>>cash read=10
2024-09-28 14:16:44 >>>回调事件130,5,10023,finish Money=5,进钞完成
2024-09-28 14:16:44 当前产品价格10元，投币10元，打印小票中...
2024-09-28 14:16:44 >>>开始打印,排队号为81,订单号为2409281416420018805594
2024-09-28 14:16:44>>>订单2409281416420018805594写入成功,剩余空间为1679000,占用RAM为611.1494140625


===14:17:48===
删除未同步订单2409281416420018805594
2024-09-28 14:16:47>>>订单2409281416420018805594删除成功,剩余空间为1681500,占用RAM为628.4853515625
检测订单目录中>>>
无未同步订单>>>
2024-09-28 14:16:47 >>>当前Ram内存为590.6396484375
定时检测未同步订单启用
2024-09-28 14:16:47>>>cash write=0C
2024-09-28 14:16:48>>>cash read=3E


===14:19:48===
2024-09-28 14:18:55 >>>回调事件[910,devices/TL1880]
2024-09-28 14:18:55 >>>故障排除日志:上一MQTT订单号缓存列表为24092813550423156079
2024-09-28 14:18:55 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 14:18:55 开始打印,排队:82,票券:2409281418483155822701,订单:24092814184831554228,[2024-09-28 14:18:54支付宝支付10元]
2024-09-28 14:18:57 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281418483155822701","queue_number":82,"trade_uid":"24092814184831554228"}]}
2024-09-28 14:18:57 >>>故障排除日志:删除未同步下发订单成功24092814184831554228
2024-09-28 14:18:57 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


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


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


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


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


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


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


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


===15:13:54===
2024-09-28 15:13:46>>>cash read=29
2024-09-28 15:13:46 >>>回调事件130,cash_status,20029,退钞中
2024-09-28 15:13:46>>>cash read=2F29
2024-09-28 15:13:47>>>cash read=00
2024-09-28 15:13:48>>>cash read=818F42
2024-09-28 15:13:48>>>cash write=02
2024-09-28 15:13:48 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-09-28 15:13:48>>>cash read=10
2024-09-28 15:13:48 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-09-28 15:13:48 当前产品价格10元，投币10元，打印小票中...
2024-09-28 15:13:48 >>>开始打印,排队号为95,订单号为2409281513480018808029
2024-09-28 15:13:48>>>订单2409281513480018808029写入成功,剩余空间为1679500,占用RAM为609.8837890625
删除未同步订单2409281513480018808029
2024-09-28 15:13:51>>>订单2409281513480018808029删除成功,剩余空间为1680500,占用RAM为623.9287109375
检测订单目录中>>>
无未同步订单>>>
2024-09-28 15:13:51 >>>当前Ram内存为591.8828125
定时检测未同步订单启用
2024-09-28 15:13:51>>>cash write=0C
2024-09-28 15:13:52>>>cash read=3E


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


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


===15:21:55===
2024-09-28 15:20:56 >>>回调事件[910,devices/TL1880]
2024-09-28 15:20:56 >>>故障排除日志:上一MQTT订单号缓存列表为24092815163070982751
2024-09-28 15:20:56 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 15:20:56 开始打印,排队:97,票券:2409281520476899048901,订单:24092815204768986286,[2024-09-28 15:20:55微信支付10元]
2024-09-28 15:20:56 开始打印,排队:98,票券:2409281520476899192802,订单:24092815204768986286,[2024-09-28 15:20:55微信支付10元]
2024-09-28 15:21:00 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281520476899048901","queue_number":97,"trade_uid":"24092815204768986286"},{"ticket_no":"2409281520476899192802","queue_number":98,"trade_uid":"24092815204768986286"}]}
2024-09-28 15:21:00 >>>故障排除日志:删除未同步下发订单成功24092815204768986286
2024-09-28 15:21:00 >>>故障排除日志:删除未同步下发订单成功24092815204768986286
2024-09-28 15:21:01 >>>故障排除日志:终端同步成功后剩余订单列表


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


===15:31:56===
2024-09-28 15:31:29 >>>回调事件[910,devices/TL1880]
2024-09-28 15:31:29 >>>故障排除日志:上一MQTT订单号缓存列表为24092815222222378987
2024-09-28 15:31:29 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 15:31:29 开始打印,排队:100,票券:2409281531226577965601,订单:24092815312265774862,[2024-09-28 15:31:28微信支付10元]
2024-09-28 15:31:31 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281531226577965601","queue_number":100,"trade_uid":"24092815312265774862"}]}
2024-09-28 15:31:31 >>>故障排除日志:删除未同步下发订单成功24092815312265774862
2024-09-28 15:31:31 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 15:31:32 >>>回调事件[910,devices/TL1880]
2024-09-28 15:31:32 >>>故障排除日志:上一MQTT订单号缓存列表为24092815312265774862
2024-09-28 15:31:32 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 15:31:32 开始打印,排队:101,票券:2409281531257323778501,订单:24092815312573232230,[2024-09-28 15:31:31支付宝支付10元]
2024-09-28 15:31:34 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281531257323778501","queue_number":101,"trade_uid":"24092815312573232230"}]}
2024-09-28 15:31:34 >>>故障排除日志:删除未同步下发订单成功24092815312573232230
2024-09-28 15:31:34 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


===15:48:57===
2024-09-28 15:48:21>>>cash read=00
2024-09-28 15:48:22>>>cash read=2F29
2024-09-28 15:48:24>>>cash read=3E
2024-09-28 15:48:25>>>cash read=00
2024-09-28 15:48:26>>>cash read=818F42
2024-09-28 15:48:26>>>cash write=02
2024-09-28 15:48:26 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-09-28 15:48:26>>>cash read=10
2024-09-28 15:48:26 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-09-28 15:48:26 当前产品价格10元，投币10元，打印小票中...
2024-09-28 15:48:26 >>>开始打印,排队号为104,订单号为2409281548260018809837
2024-09-28 15:48:27>>>订单2409281548260018809837写入成功,剩余空间为1679500,占用RAM为607.294921875
删除未同步订单2409281548260018809837
2024-09-28 15:48:29>>>订单2409281548260018809837删除成功,剩余空间为1680500,占用RAM为620.849609375
检测订单目录中>>>
无未同步订单>>>
2024-09-28 15:48:29 >>>当前Ram内存为589.4111328125
定时检测未同步订单启用
2024-09-28 15:48:30>>>cash write=0C
2024-09-28 15:48:30>>>cash read=3E


===15:49:58===
定时检测未同步订单关闭
检测订单目录中>>>
无未同步订单>>>
2024-09-28 15:49:36>>>cash read=00
2024-09-28 15:49:36>>>cash read=818F42
2024-09-28 15:49:36>>>cash write=02
2024-09-28 15:49:36 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-09-28 15:49:37>>>cash read=10
2024-09-28 15:49:37 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-09-28 15:49:37 当前产品价格10元，投币10元，打印小票中...
2024-09-28 15:49:37 >>>开始打印,排队号为105,订单号为2409281549370018804780
2024-09-28 15:49:37>>>订单2409281549370018804780写入成功,剩余空间为1679500,占用RAM为607.01171875
删除未同步订单2409281549370018804780
2024-09-28 15:49:39>>>订单2409281549370018804780删除成功,剩余空间为1680500,占用RAM为622.541015625
检测订单目录中>>>
无未同步订单>>>
2024-09-28 15:49:39 >>>当前Ram内存为589.2900390625
定时检测未同步订单启用
2024-09-28 15:49:40>>>cash write=0C
2024-09-28 15:49:40>>>cash read=3E
2024-09-28 15:49:50 >>>回调事件[910,devices/TL1880]
2024-09-28 15:49:50 >>>故障排除日志:上一MQTT订单号缓存列表为24092815331630238579
2024-09-28 15:49:50 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 15:49:50 开始打印,排队:106,票券:2409281549459498369601,订单:24092815494594978070,[2024-09-28 15:49:50微信支付10元]
2024-09-28 15:49:52 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281549459498369601","queue_number":106,"trade_uid":"24092815494594978070"}]}
2024-09-28 15:49:52 >>>故障排除日志:删除未同步下发订单成功24092815494594978070
2024-09-28 15:49:52 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


===16:14:59===
2024-09-28 16:14:39>>>cash read=0A
2024-09-28 16:14:40>>>cash read=3E


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


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


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


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


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


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


===16:44:03===
2024-09-28 16:43:18>>>cash read=0A
2024-09-28 16:43:19>>>cash read=3E


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


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


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


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


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


===16:56:06===
2024-09-28 16:55:21 >>>回调事件[910,devices/TL1880]
2024-09-28 16:55:21 >>>故障排除日志:上一MQTT订单号缓存列表为24092816520465350735
2024-09-28 16:55:21 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 16:55:21 开始打印,排队:117,票券:2409281655139499692101,订单:24092816551394992569,[2024-09-28 16:55:21支付宝支付10元]
2024-09-28 16:55:21 开始打印,排队:118,票券:2409281655139499861302,订单:24092816551394992569,[2024-09-28 16:55:21支付宝支付10元]
2024-09-28 16:55:25 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281655139499692101","queue_number":117,"trade_uid":"24092816551394992569"},{"ticket_no":"2409281655139499861302","queue_number":118,"trade_uid":"24092816551394992569"}]}
2024-09-28 16:55:25 >>>故障排除日志:删除未同步下发订单成功24092816551394992569
2024-09-28 16:55:25 >>>故障排除日志:删除未同步下发订单成功24092816551394992569
2024-09-28 16:55:25 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


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


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


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


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


===17:21:10===
2024-09-28 17:20:40>>>cash read=00
2024-09-28 17:20:41>>>cash read=01
2024-09-28 17:20:46>>>cash read=29
2024-09-28 17:20:46 >>>回调事件130,cash_status,20029,退钞中
2024-09-28 17:20:48>>>cash read=01
2024-09-28 17:20:50>>>cash read=3E
2024-09-28 17:20:53>>>cash read=29
2024-09-28 17:20:53 >>>回调事件130,cash_status,20029,退钞中
2024-09-28 17:20:54>>>cash read=01
2024-09-28 17:20:56>>>cash read=3E
2024-09-28 17:21:02>>>cash read=00
2024-09-28 17:21:04>>>cash read=01
2024-09-28 17:21:08>>>cash read=3E


===17:22:10===
2024-09-28 17:21:11>>>cash read=29
2024-09-28 17:21:11 >>>回调事件130,cash_status,20029,退钞中
2024-09-28 17:21:13>>>cash read=01
2024-09-28 17:21:15>>>cash read=3E
2024-09-28 17:21:17>>>cash read=29
2024-09-28 17:21:17 >>>回调事件130,cash_status,20029,退钞中
2024-09-28 17:21:18>>>cash read=3E
2024-09-28 17:21:20>>>cash read=29
2024-09-28 17:21:20 >>>回调事件130,cash_status,20029,退钞中
2024-09-28 17:21:22>>>cash read=01
2024-09-28 17:21:24>>>cash read=3E
2024-09-28 17:21:27>>>cash read=29
2024-09-28 17:21:27 >>>回调事件130,cash_status,20029,退钞中
2024-09-28 17:21:28>>>cash read=01
2024-09-28 17:21:31>>>cash read=3E
2024-09-28 17:21:42>>>cash read=00
2024-09-28 17:21:43>>>cash read=818F42
2024-09-28 17:21:43>>>cash write=02
2024-09-28 17:21:43 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-09-28 17:21:43>>>cash read=10
2024-09-28 17:21:43 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-09-28 17:21:43 当前产品价格10元，投币10元，打印小票中...
2024-09-28 17:21:43 >>>开始打印,排队号为127,订单号为2409281721430018808693
2024-09-28 17:21:44>>>订单2409281721430018808693写入成功,剩余空间为1679000,占用RAM为610.2041015625
删除未同步订单2409281721430018808693
2024-09-28 17:21:46>>>订单2409281721430018808693删除成功,剩余空间为1680000,占用RAM为621.013671875
检测订单目录中>>>
无未同步订单>>>
2024-09-28 17:21:46 >>>当前Ram内存为589.796875
定时检测未同步订单启用
2024-09-28 17:21:47>>>cash write=0C
2024-09-28 17:21:47>>>cash read=3E


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


===17:25:11===
2024-09-28 17:24:18 >>>回调事件[910,devices/TL1880]
2024-09-28 17:24:18 >>>故障排除日志:上一MQTT订单号缓存列表为24092817220899045082
2024-09-28 17:24:18 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 17:24:18 开始打印,排队:129,票券:2409281724127081243101,订单:24092817241270804897,[2024-09-28 17:24:17微信支付10元]
2024-09-28 17:24:20 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281724127081243101","queue_number":129,"trade_uid":"24092817241270804897"}]}
2024-09-28 17:24:20 >>>故障排除日志:删除未同步下发订单成功24092817241270804897
2024-09-28 17:24:20 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 17:24:56 >>>回调事件[910,devices/TL1880]
2024-09-28 17:24:56 >>>故障排除日志:上一MQTT订单号缓存列表为24092817241270804897
2024-09-28 17:24:56 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 17:24:56 开始打印,排队:130,票券:2409281724493036686801,订单:24092817244930363334,[2024-09-28 17:24:55微信支付10元]
2024-09-28 17:24:58 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281724493036686801","queue_number":130,"trade_uid":"24092817244930363334"}]}
2024-09-28 17:24:58 >>>故障排除日志:删除未同步下发订单成功24092817244930363334
2024-09-28 17:24:58 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


===17:41:13===
2024-09-28 17:40:36>>>cash read=0A
2024-09-28 17:40:38>>>cash read=3E


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


===17:56:14===
2024-09-28 17:55:59 >>>回调事件[910,devices/TL1880]
2024-09-28 17:55:59 >>>故障排除日志:上一MQTT订单号缓存列表为24092817432217672310
2024-09-28 17:55:59 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 17:55:59 开始打印,排队:135,票券:2409281755531058080901,订单:24092817555310576171,[2024-09-28 17:55:58微信支付10元]
2024-09-28 17:55:59 开始打印,排队:136,票券:2409281755531058238302,订单:24092817555310576171,[2024-09-28 17:55:58微信支付10元]
2024-09-28 17:56:03 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281755531058080901","queue_number":135,"trade_uid":"24092817555310576171"},{"ticket_no":"2409281755531058238302","queue_number":136,"trade_uid":"24092817555310576171"}]}
2024-09-28 17:56:03 >>>故障排除日志:删除未同步下发订单成功24092817555310576171
2024-09-28 17:56:03 >>>故障排除日志:删除未同步下发订单成功24092817555310576171
2024-09-28 17:56:03 >>>故障排除日志:终端同步成功后剩余订单列表


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


===17:59:16===
2024-09-28 17:58:55 >>>回调事件[910,devices/TL1880]
2024-09-28 17:58:55 >>>故障排除日志:上一MQTT订单号缓存列表为24092817575961600218
2024-09-28 17:58:55 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 17:58:55 开始打印,排队:138,票券:2409281758493119063101,订单:24092817584931186841,[2024-09-28 17:58:55微信支付10元]
2024-09-28 17:58:57 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281758493119063101","queue_number":138,"trade_uid":"24092817584931186841"}]}
2024-09-28 17:58:57 >>>故障排除日志:删除未同步下发订单成功24092817584931186841
2024-09-28 17:58:57 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 17:59:13 >>>回调事件[910,devices/TL1880]
2024-09-28 17:59:13 >>>故障排除日志:上一MQTT订单号缓存列表为24092817584931186841
2024-09-28 17:59:13 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 17:59:13 开始打印,排队:139,票券:2409281759069582533601,订单:24092817590695821031,[2024-09-28 17:59:12支付宝支付10元]


===18:00:16===
2024-09-28 17:59:15 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281759069582533601","queue_number":139,"trade_uid":"24092817590695821031"}]}
2024-09-28 17:59:15 >>>故障排除日志:删除未同步下发订单成功24092817590695821031
2024-09-28 17:59:15 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


===18:11:21===
2024-09-28 18:11:16 >>>回调事件[910,devices/TL1880]
2024-09-28 18:11:16 >>>故障排除日志:上一MQTT订单号缓存列表为24092818081447040146
2024-09-28 18:11:16 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 18:11:16 开始打印,排队:144,票券:2409281811078949087301,订单:24092818110789485983,[2024-09-28 18:11:15支付宝支付10元]
2024-09-28 18:11:16 开始打印,排队:145,票券:2409281811078949287202,订单:24092818110789485983,[2024-09-28 18:11:15支付宝支付10元]


===18:12:21===
2024-09-28 18:11:20 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281811078949087301","queue_number":144,"trade_uid":"24092818110789485983"},{"ticket_no":"2409281811078949287202","queue_number":145,"trade_uid":"24092818110789485983"}]}
2024-09-28 18:11:20 >>>故障排除日志:删除未同步下发订单成功24092818110789485983
2024-09-28 18:11:20 >>>故障排除日志:删除未同步下发订单成功24092818110789485983
2024-09-28 18:11:20 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


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


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


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


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


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


===18:49:27===
2024-09-28 18:49:03>>>cash read=00
2024-09-28 18:49:04>>>cash read=818F42
2024-09-28 18:49:04>>>cash write=02
2024-09-28 18:49:04 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-09-28 18:49:04>>>cash read=10
2024-09-28 18:49:04 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-09-28 18:49:04 当前产品价格10元，投币10元，打印小票中...
2024-09-28 18:49:04 >>>开始打印,排队号为154,订单号为2409281849040018809024
2024-09-28 18:49:05>>>订单2409281849040018809024写入成功,剩余空间为1680000,占用RAM为606.6162109375
删除未同步订单2409281849040018809024
2024-09-28 18:49:07>>>订单2409281849040018809024删除成功,剩余空间为1680500,占用RAM为622.728515625
检测订单目录中>>>
无未同步订单>>>
2024-09-28 18:49:07 >>>当前Ram内存为588.9453125
定时检测未同步订单启用
2024-09-28 18:49:08>>>cash write=0C
2024-09-28 18:49:08>>>cash read=3E
2024-09-28 18:49:13>>>cash read=2F29
2024-09-28 18:49:14>>>cash read=01
2024-09-28 18:49:15>>>cash read=2F
2024-09-28 18:49:16>>>cash read=00
2024-09-28 18:49:17>>>cash read=292F29
2024-09-28 18:49:17 >>>回调事件130,cash_status,20029,退钞中
2024-09-28 18:49:18>>>cash read=01
2024-09-28 18:49:22>>>cash read=2F
2024-09-28 18:49:23>>>cash read=29
2024-09-28 18:49:23 >>>回调事件130,cash_status,20029,退钞中
2024-09-28 18:49:24>>>cash read=3E


===18:50:27===
2024-09-28 18:49:27>>>cash read=00
2024-09-28 18:49:28>>>cash read=818F42
2024-09-28 18:49:28>>>cash write=02
2024-09-28 18:49:28 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-09-28 18:49:28>>>cash read=10
2024-09-28 18:49:28 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-09-28 18:49:28 当前产品价格10元，投币10元，打印小票中...
2024-09-28 18:49:28 >>>开始打印,排队号为155,订单号为2409281849280018803942
定时检测未同步订单关闭
2024-09-28 18:49:28>>>订单2409281849280018803942写入成功,剩余空间为1679500,占用RAM为606.4052734375
删除未同步订单2409281849280018803942
2024-09-28 18:49:31>>>订单2409281849280018803942删除成功,剩余空间为1680500,占用RAM为618.3486328125
检测订单目录中>>>
无未同步订单>>>
2024-09-28 18:49:31 >>>当前Ram内存为588.4580078125
定时检测未同步订单启用
2024-09-28 18:49:32>>>cash write=0C
2024-09-28 18:49:32>>>cash read=3E
2024-09-28 18:49:43 >>>剩余flash空间=1680000,占用RAM为645.953125
2024-09-28 18:49:43 >>>回调事件:903,keyPress,10000,长按切换键

进入终端自检模式
2024-09-28 18:49:45>>>cash write=30
2024-09-28 18:49:45>>>cash write=02
2024-09-28 18:49:45>>>cash write=3E
2024-09-28 18:49:46>>>cash write=0C
2024-09-28 18:49:47>>>cash read=808F
2024-09-28 18:49:48>>>cash write=02
2024-09-28 18:49:49>>>cash write=0C
2024-09-28 18:49:49>>>cash read=3E


===18:51:28===
定时检测未同步订单关闭
检测订单目录中>>>
无未同步订单>>>
2024-09-28 18:50:54 >>>回调事件[910,devices/TL1880]
2024-09-28 18:50:54 >>>故障排除日志:上一MQTT订单号缓存列表为24092818480912731512
2024-09-28 18:50:54 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 18:50:54 开始打印,排队:156,票券:2409281850473375768701,订单:24092818504733749965,[2024-09-28 18:50:53微信支付10元]
2024-09-28 18:50:56 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281850473375768701","queue_number":156,"trade_uid":"24092818504733749965"}]}
2024-09-28 18:50:56 >>>故障排除日志:删除未同步下发订单成功24092818504733749965
2024-09-28 18:50:56 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 18:51:01 >>>回调事件[910,devices/TL1880]
2024-09-28 18:51:01 >>>故障排除日志:上一MQTT订单号缓存列表为24092818504733749965
2024-09-28 18:51:01 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 18:51:01 开始打印,排队:157,票券:2409281850497877425001,订单:24092818504978769048,[2024-09-28 18:51:01微信支付10元]
2024-09-28 18:51:03 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281850497877425001","queue_number":157,"trade_uid":"24092818504978769048"}]}
2024-09-28 18:51:03 >>>故障排除日志:删除未同步下发订单成功24092818504978769048
2024-09-28 18:51:04 >>>故障排除日志:终端同步成功后剩余订单列表


===18:52:28===
2024-09-28 18:51:43 >>>剩余flash空间=1682000,占用RAM为629.775390625
2024-09-28 18:51:43 >>>回调事件:903,keyPress,10000,退出终端自检模式

退出终端自检模式


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


===18:57:31===
2024-09-28 18:56:29 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281856209752127901","queue_number":159,"trade_uid":"24092818562097516945"}]}
2024-09-28 18:56:29 >>>故障排除日志:删除未同步下发订单成功24092818562097516945
2024-09-28 18:56:30 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 18:56:37 >>>回调事件[910,devices/TL1880]
2024-09-28 18:56:37 >>>故障排除日志:上一MQTT订单号缓存列表为24092818562097516945
2024-09-28 18:56:37 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 18:56:37 开始打印,排队:160,票券:2409281856319986592901,订单:24092818563199859483,[2024-09-28 18:56:37微信支付10元]
2024-09-28 18:56:39 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281856319986592901","queue_number":160,"trade_uid":"24092818563199859483"}]}
2024-09-28 18:56:39 >>>故障排除日志:删除未同步下发订单成功24092818563199859483
2024-09-28 18:56:39 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


===19:06:32===
2024-09-28 19:06:02>>>cash read=00
2024-09-28 19:06:02>>>cash read=2F29
2024-09-28 19:06:03>>>cash read=01
2024-09-28 19:06:05>>>cash read=2F
2024-09-28 19:06:06>>>cash read=3E
2024-09-28 19:06:12>>>cash read=00
2024-09-28 19:06:13>>>cash read=818F42
2024-09-28 19:06:13>>>cash write=02
2024-09-28 19:06:13 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-09-28 19:06:13>>>cash read=10
2024-09-28 19:06:13 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-09-28 19:06:13 当前产品价格10元，投币10元，打印小票中...
2024-09-28 19:06:13 >>>开始打印,排队号为163,订单号为2409281906130018807800
2024-09-28 19:06:14>>>订单2409281906130018807800写入成功,剩余空间为1679500,占用RAM为607.3427734375
删除未同步订单2409281906130018807800
2024-09-28 19:06:16>>>订单2409281906130018807800删除成功,剩余空间为1680500,占用RAM为625.345703125
检测订单目录中>>>
无未同步订单>>>
2024-09-28 19:06:16 >>>当前Ram内存为589.15234375
定时检测未同步订单启用
2024-09-28 19:06:17>>>cash write=0C
2024-09-28 19:06:17>>>cash read=3E
2024-09-28 19:06:22>>>cash read=00
2024-09-28 19:06:24>>>cash read=818F42
2024-09-28 19:06:24>>>cash write=02
2024-09-28 19:06:24 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-09-28 19:06:24>>>cash read=10
2024-09-28 19:06:24 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-09-28 19:06:24 当前产品价格10元，投币10元，打印小票中...
2024-09-28 19:06:24 >>>开始打印,排队号为164,订单号为2409281906240018803469
定时检测未同步订单关闭
2024-09-28 19:06:25>>>订单2409281906240018803469写入成功,剩余空间为1678500,占用RAM为615.0654296875
删除未同步订单2409281906240018803469
2024-09-28 19:06:27>>>订单2409281906240018803469删除成功,剩余空间为1679500,占用RAM为622.6455078125
检测订单目录中>>>
无未同步订单>>>
2024-09-28 19:06:27 >>>当前Ram内存为590.6533203125
定时检测未同步订单启用
2024-09-28 19:06:28>>>cash write=0C
2024-09-28 19:06:28>>>cash read=3E


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


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


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


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


===19:13:33===
2024-09-28 19:12:45 >>>回调事件[910,devices/TL1880]
2024-09-28 19:12:45 >>>故障排除日志:上一MQTT订单号缓存列表为24092819113550301542
2024-09-28 19:12:45 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 19:12:45 开始打印,排队:169,票券:2409281912385935340201,订单:24092819123859346658,[2024-09-28 19:12:44微信支付10元]
2024-09-28 19:12:47 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281912385935340201","queue_number":169,"trade_uid":"24092819123859346658"}]}
2024-09-28 19:12:47 >>>故障排除日志:删除未同步下发订单成功24092819123859346658
2024-09-28 19:12:47 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 19:13:04 >>>回调事件[910,devices/TL1880]
2024-09-28 19:13:04 >>>故障排除日志:上一MQTT订单号缓存列表为24092819123859346658
2024-09-28 19:13:04 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 19:13:04 开始打印,排队:170,票券:2409281912584485202101,订单:24092819125844847478,[2024-09-28 19:13:04微信支付10元]
2024-09-28 19:13:07 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281912584485202101","queue_number":170,"trade_uid":"24092819125844847478"}]}
2024-09-28 19:13:07 >>>故障排除日志:删除未同步下发订单成功24092819125844847478
2024-09-28 19:13:07 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 19:13:17 >>>回调事件[910,devices/TL1880]
2024-09-28 19:13:18 >>>故障排除日志:上一MQTT订单号缓存列表为24092819125844847478
2024-09-28 19:13:18 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 19:13:18 开始打印,排队:171,票券:2409281913095552724101,订单:24092819130955522345,[2024-09-28 19:13:17微信支付10元]
2024-09-28 19:13:18 开始打印,排队:172,票券:2409281913095552916102,订单:24092819130955522345,[2024-09-28 19:13:17微信支付10元]
2024-09-28 19:13:21 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281913095552724101","queue_number":171,"trade_uid":"24092819130955522345"},{"ticket_no":"2409281913095552916102","queue_number":172,"trade_uid":"24092819130955522345"}]}
2024-09-28 19:13:21 >>>故障排除日志:删除未同步下发订单成功24092819130955522345
2024-09-28 19:13:21 >>>故障排除日志:删除未同步下发订单成功24092819130955522345
2024-09-28 19:13:22 >>>故障排除日志:终端同步成功后剩余订单列表


===19:17:34===
2024-09-28 19:17:07>>>cash read=29
2024-09-28 19:17:07 >>>回调事件130,cash_status,20029,退钞中
2024-09-28 19:17:08>>>cash read=2F29
2024-09-28 19:17:10>>>cash read=3E
2024-09-28 19:17:25>>>cash read=00
2024-09-28 19:17:26>>>cash read=01
2024-09-28 19:17:27>>>cash read=3E


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


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


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


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


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


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


===19:57:38===
2024-09-28 19:56:47>>>cash read=2F2901
2024-09-28 19:56:53>>>cash read=3E
2024-09-28 19:56:56>>>cash read=00
2024-09-28 19:56:57>>>cash read=3E
2024-09-28 19:57:03>>>cash read=00
2024-09-28 19:57:04>>>cash read=01
2024-09-28 19:57:07>>>cash read=3E
2024-09-28 19:57:24>>>cash read=00
2024-09-28 19:57:25>>>cash read=29
2024-09-28 19:57:25 >>>回调事件130,cash_status,20029,退钞中
2024-09-28 19:57:25>>>cash read=2F29
2024-09-28 19:57:27>>>cash read=3E
2024-09-28 19:57:35>>>cash read=00


===19:58:38===
2024-09-28 19:57:37>>>cash read=2F29
2024-09-28 19:57:39>>>cash read=00
2024-09-28 19:57:41>>>cash read=2F29
2024-09-28 19:57:42>>>cash read=3E
2024-09-28 19:58:01>>>cash read=29
2024-09-28 19:58:01 >>>回调事件130,cash_status,20029,退钞中
2024-09-28 19:58:01>>>cash read=2F29
2024-09-28 19:58:03>>>cash read=00
2024-09-28 19:58:04>>>cash read=818F42
2024-09-28 19:58:04>>>cash write=02
2024-09-28 19:58:04 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-09-28 19:58:04>>>cash read=10
2024-09-28 19:58:04 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-09-28 19:58:04 当前产品价格10元，投币10元，打印小票中...
2024-09-28 19:58:04 >>>开始打印,排队号为179,订单号为2409281958040018806543
2024-09-28 19:58:05>>>订单2409281958040018806543写入成功,剩余空间为1679500,占用RAM为608.2431640625
删除未同步订单2409281958040018806543
2024-09-28 19:58:07>>>订单2409281958040018806543删除成功,剩余空间为1680500,占用RAM为625.333984375
检测订单目录中>>>
无未同步订单>>>
2024-09-28 19:58:07 >>>当前Ram内存为589.4677734375
定时检测未同步订单启用
2024-09-28 19:58:08>>>cash write=0C
2024-09-28 19:58:08>>>cash read=3E


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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