TLClient_JSSCOM_LuatOS-Air_V4010_RDA8910_RFTTS_0xe0000,2.5.1,861658060957217,08272845957526,
poweron reason:0

===08:07:45===
上一时间戳为1721441303
隔日重置时间戳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":"4351590954437531799","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:23b16****4e577
纸币器设置接收纸币范围为15
欢迎使用天羚自助售票系统[2.5.1]
定时检测未同步订单启用
2024-07-21 08:07:29>>>cash write=30
2024-07-21 08:07:29>>>cash write=02
2024-07-21 08:07:29>>>cash write=3E
2024-07-21 08:07:29>>>cash read=808F808F808F
系统时间初始化成功，时间为20247218729
2024-07-21 08:07:30>>>cash write=02
2024-07-21 08:07:30 >>>剩余flash空间=1680500,占用RAM为623.33984375
2024-07-21 08:07:30 >>>回调事件:910,subscribe,10000,连接服务器成功

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



===08:08:45===
上一时间戳为1721520449
当日首次设置时间戳true为1721520465
今日nvm排队号为1
当前排队号为1,音量为6
初始化产品信息:[{"time_limit_date":null,"ticket_category":"0","expiry_date":90,"product_detail":"","time_limit_status":"0","begin_minute":null,"product_uid":"4351590954437531799","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:c8923****fdda9
纸币器设置接收纸币范围为15
欢迎使用天羚自助售票系统[2.5.1]
定时检测未同步订单启用
2024-07-21 08:07:45>>>cash write=30
2024-07-21 08:07:45>>>cash write=02
2024-07-21 08:07:45>>>cash write=3E
2024-07-21 08:07:45>>>cash read=808F808F808F
系统时间初始化成功，时间为20247218745
2024-07-21 08:07:46>>>cash write=02
2024-07-21 08:07:46 >>>剩余flash空间=1680500,占用RAM为626.3896484375
2024-07-21 08:07:46 >>>回调事件:910,subscribe,10000,连接服务器成功

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

2024-07-21 08:07:49>>>cash write=0C
2024-07-21 08:07:49>>>cash read=3E
流量卡还有314天过期
2024-07-21 08:07:53 >>>当前Ram内存为642.9892578125


===08:17:46===
2024-07-21 08:17:10 >>>回调事件[910,devices/TL2180]
2024-07-21 08:17:10 >>>故障排除日志:上一MQTT订单号缓存列表为24072021263024544696|24072021263024544696
2024-07-21 08:17:10 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 08:17:10 开始打印,排队:1,票券:2407210817035602413901,订单:24072108170356019883,[2024-07-21 08:17:03微信支付10元]
2024-07-21 08:17:12 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407210817035602413901","queue_number":1,"trade_uid":"24072108170356019883"}]}
2024-07-21 08:17:12 >>>故障排除日志:删除未同步下发订单成功24072108170356019883
2024-07-21 08:17:12 >>>故障排除日志:终端同步成功后剩余订单列表
2024-07-21 08:17:12 收到下发指令:叫号1>>>


===08:32:46===
2024-07-21 08:32:02 >>>回调事件[910,devices/TL2180]
2024-07-21 08:32:02 >>>故障排除日志:上一MQTT订单号缓存列表为24072108170356019883
2024-07-21 08:32:02 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 08:32:02 开始打印,排队:2,票券:2407210831568927573701,订单:24072108315689272038,[2024-07-21 08:31:56微信支付10元]
2024-07-21 08:32:04 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407210831568927573701","queue_number":2,"trade_uid":"24072108315689272038"}]}
2024-07-21 08:32:04 >>>故障排除日志:删除未同步下发订单成功24072108315689272038
2024-07-21 08:32:05 >>>故障排除日志:终端同步成功后剩余订单列表
2024-07-21 08:32:37 >>>回调事件[910,devices/TL2180]
2024-07-21 08:32:37 >>>故障排除日志:上一MQTT订单号缓存列表为24072108315689272038
2024-07-21 08:32:37 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 08:32:37 开始打印,排队:3,票券:2407210832265986608501,订单:24072108322659861301,[2024-07-21 08:32:26微信支付10元]
2024-07-21 08:32:40 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407210832265986608501","queue_number":3,"trade_uid":"24072108322659861301"}]}
2024-07-21 08:32:40 >>>故障排除日志:删除未同步下发订单成功24072108322659861301
2024-07-21 08:32:40 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


===09:02:47===
2024-07-21 09:02:11 >>>回调事件[910,devices/TL2180]
2024-07-21 09:02:11 >>>故障排除日志:上一MQTT订单号缓存列表为24072109010908932525
2024-07-21 09:02:11 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 09:02:11 开始打印,排队:8,票券:2407210902039254603901,订单:24072109020392542616,[2024-07-21 09:02:03微信支付10元]
2024-07-21 09:02:13 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407210902039254603901","queue_number":8,"trade_uid":"24072109020392542616"}]}
2024-07-21 09:02:13 >>>故障排除日志:删除未同步下发订单成功24072109020392542616
2024-07-21 09:02:13 >>>故障排除日志:终端同步成功后剩余订单列表
2024-07-21 09:02:32 >>>回调事件[910,devices/TL2180]
2024-07-21 09:02:32 >>>故障排除日志:上一MQTT订单号缓存列表为24072109020392542616
2024-07-21 09:02:32 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 09:02:32 开始打印,排队:9,票券:2407210902242025815001,订单:24072109022420253993,[2024-07-21 09:02:24微信支付10元]
2024-07-21 09:02:34 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407210902242025815001","queue_number":9,"trade_uid":"24072109022420253993"}]}
2024-07-21 09:02:34 >>>故障排除日志:删除未同步下发订单成功24072109022420253993
2024-07-21 09:02:34 >>>故障排除日志:终端同步成功后剩余订单列表


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


===09:12:48===
2024-07-21 09:12:04>>>cash read=00
2024-07-21 09:12:05>>>cash read=818F42
2024-07-21 09:12:05>>>cash write=02
2024-07-21 09:12:05 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-07-21 09:12:06>>>cash read=10
2024-07-21 09:12:06 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-07-21 09:12:06 >>>开始打印,排队号为11,订单号为2407210912060021809979
2024-07-21 09:12:06>>>订单2407210912060021809979写入成功,剩余空间为1680500,占用RAM为599.40234375
删除未同步订单2407210912060021809979
2024-07-21 09:12:08>>>订单2407210912060021809979删除成功,剩余空间为1680500,占用RAM为615.00390625
检测订单目录中>>>
无未同步订单>>>
2024-07-21 09:12:08 >>>当前Ram内存为586.271484375
定时检测未同步订单启用
2024-07-21 09:12:09>>>cash write=0C
2024-07-21 09:12:09>>>cash read=3E


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


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


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


===09:19:49===
2024-07-21 09:18:52 >>>回调事件[910,devices/TL2180]
2024-07-21 09:18:52 >>>故障排除日志:上一MQTT订单号缓存列表为24072109171352728529
2024-07-21 09:18:52 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 09:18:52 开始打印,排队:14,票券:2407210918435643480601,订单:24072109184356429747,[2024-07-21 09:18:43微信支付10元]
2024-07-21 09:18:54 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407210918435643480601","queue_number":14,"trade_uid":"24072109184356429747"}]}
2024-07-21 09:18:54 >>>故障排除日志:删除未同步下发订单成功24072109184356429747
2024-07-21 09:18:54 >>>故障排除日志:终端同步成功后剩余订单列表
2024-07-21 09:19:47 >>>回调事件[910,devices/TL2180]
2024-07-21 09:19:47 >>>故障排除日志:上一MQTT订单号缓存列表为24072109184356429747
2024-07-21 09:19:47 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 09:19:47 开始打印,排队:15,票券:2407210919395392788101,订单:24072109193953920007,[2024-07-21 09:19:39微信支付10元]


===09:20:50===
2024-07-21 09:19:49 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407210919395392788101","queue_number":15,"trade_uid":"24072109193953920007"}]}
2024-07-21 09:19:49 >>>故障排除日志:删除未同步下发订单成功24072109193953920007
2024-07-21 09:19:49 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


===09:27:50===
2024-07-21 09:26:54 >>>回调事件[910,devices/TL2180]
2024-07-21 09:26:54 >>>故障排除日志:上一MQTT订单号缓存列表为24072109261922898347
2024-07-21 09:26:54 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 09:26:54 开始打印,排队:18,票券:2407210926464070637501,订单:24072109264640702117,[2024-07-21 09:26:46微信支付10元]
2024-07-21 09:26:56 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407210926464070637501","queue_number":18,"trade_uid":"24072109264640702117"}]}
2024-07-21 09:26:56 >>>故障排除日志:删除未同步下发订单成功24072109264640702117
2024-07-21 09:26:57 >>>故障排除日志:终端同步成功后剩余订单列表


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


===09:36:51===
2024-07-21 09:35:56>>>cash read=00
2024-07-21 09:35:57>>>cash read=01
2024-07-21 09:35:58>>>cash read=3E
2024-07-21 09:36:08>>>cash read=00
2024-07-21 09:36:09>>>cash read=818F42
2024-07-21 09:36:09>>>cash write=02
2024-07-21 09:36:09 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-07-21 09:36:10>>>cash read=10
2024-07-21 09:36:10 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-07-21 09:36:10 >>>开始打印,排队号为20,订单号为2407210936100021806715
2024-07-21 09:36:10>>>订单2407210936100021806715写入成功,剩余空间为1679500,占用RAM为601.20703125
删除未同步订单2407210936100021806715
2024-07-21 09:36:12>>>订单2407210936100021806715删除成功,剩余空间为1680500,占用RAM为615.2412109375
检测订单目录中>>>
无未同步订单>>>
2024-07-21 09:36:12 >>>当前Ram内存为586.21484375
定时检测未同步订单启用
2024-07-21 09:36:13>>>cash write=0C
2024-07-21 09:36:13>>>cash read=3E


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


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


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


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


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


===10:00:52===
2024-07-21 10:00:14 >>>回调事件[910,devices/TL2180]
2024-07-21 10:00:14 >>>故障排除日志:上一MQTT订单号缓存列表为24072109544762942316
2024-07-21 10:00:14 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 10:00:14 开始打印,排队:25,票券:2407211000069490016401,订单:24072110000694895838,[2024-07-21 10:00:06微信支付10元]
2024-07-21 10:00:16 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407211000069490016401","queue_number":25,"trade_uid":"24072110000694895838"}]}
2024-07-21 10:00:16 >>>故障排除日志:删除未同步下发订单成功24072110000694895838
2024-07-21 10:00:17 >>>故障排除日志:终端同步成功后剩余订单列表
2024-07-21 10:00:46 >>>回调事件[910,devices/TL2180]
2024-07-21 10:00:46 >>>故障排除日志:上一MQTT订单号缓存列表为24072110000694895838
2024-07-21 10:00:46 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 10:00:46 开始打印,排队:26,票券:2407211000326540897801,订单:24072110003265404760,[2024-07-21 10:00:32微信支付10元]
2024-07-21 10:00:48 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407211000326540897801","queue_number":26,"trade_uid":"24072110003265404760"}]}
2024-07-21 10:00:48 >>>故障排除日志:删除未同步下发订单成功24072110003265404760
2024-07-21 10:00:49 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


===11:13:57===
2024-07-21 11:12:58 >>>回调事件[910,devices/TL2180]
2024-07-21 11:12:58 >>>故障排除日志:上一MQTT订单号缓存列表为24072111101731151554
2024-07-21 11:12:59 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 11:12:59 开始打印,排队:40,票券:2407211112505638805801,订单:24072111125056384080,[2024-07-21 11:12:50微信支付10元]
2024-07-21 11:13:01 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407211112505638805801","queue_number":40,"trade_uid":"24072111125056384080"}]}
2024-07-21 11:13:01 >>>故障排除日志:删除未同步下发订单成功24072111125056384080
2024-07-21 11:13:01 >>>故障排除日志:终端同步成功后剩余订单列表
2024-07-21 11:13:46 >>>回调事件[910,devices/TL2180]
2024-07-21 11:13:46 >>>故障排除日志:上一MQTT订单号缓存列表为24072111125056384080
2024-07-21 11:13:46 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 11:13:46 开始打印,排队:41,票券:2407211113402023614601,订单:24072111134020232598,[2024-07-21 11:13:40微信支付10元]
2024-07-21 11:13:49 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407211113402023614601","queue_number":41,"trade_uid":"24072111134020232598"}]}
2024-07-21 11:13:49 >>>故障排除日志:删除未同步下发订单成功24072111134020232598
2024-07-21 11:13:49 >>>故障排除日志:终端同步成功后剩余订单列表


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


===11:18:57===
2024-07-21 11:18:04>>>cash read=29
2024-07-21 11:18:04 >>>回调事件130,cash_status,20029,退钞中
2024-07-21 11:18:05>>>cash read=2F29
2024-07-21 11:18:06>>>cash read=00
2024-07-21 11:18:07>>>cash read=818F41
2024-07-21 11:18:07>>>cash write=02
2024-07-21 11:18:07 >>>回调事件130,cash_status,10022,进钞中...read money=5
2024-07-21 11:18:07>>>cash read=10
2024-07-21 11:18:07 >>>回调事件130,5,10023,finish Money=5,进钞完成
2024-07-21 11:18:08>>>cash write=0C
2024-07-21 11:18:08>>>cash read=00
2024-07-21 11:18:09>>>cash read=818F41
2024-07-21 11:18:09>>>cash write=02
2024-07-21 11:18:09 >>>回调事件130,cash_status,10022,进钞中...read money=5
2024-07-21 11:18:09>>>cash read=10
2024-07-21 11:18:09 >>>回调事件130,5,10023,finish Money=5,进钞完成
2024-07-21 11:18:09 >>>开始打印,排队号为43,订单号为2407211118070021809789
2024-07-21 11:18:10>>>订单2407211118070021809789写入成功,剩余空间为1679500,占用RAM为601.294921875
删除未同步订单2407211118070021809789
2024-07-21 11:18:12>>>订单2407211118070021809789删除成功,剩余空间为1680000,占用RAM为619.4365234375
检测订单目录中>>>
无未同步订单>>>
2024-07-21 11:18:12 >>>当前Ram内存为587.1630859375
定时检测未同步订单启用
2024-07-21 11:18:13>>>cash write=0C
2024-07-21 11:18:13>>>cash read=3E


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


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


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


===11:44:58===
2024-07-21 11:44:27 >>>回调事件[910,devices/TL2180]
2024-07-21 11:44:27 >>>故障排除日志:上一MQTT订单号缓存列表为24072111391059877210|24072111391059877210
2024-07-21 11:44:27 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 11:44:27 开始打印,排队:47,票券:2407211144196223732401,订单:24072111441962230138,[2024-07-21 11:44:19微信支付10元]
2024-07-21 11:44:29 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407211144196223732401","queue_number":47,"trade_uid":"24072111441962230138"}]}
2024-07-21 11:44:29 >>>故障排除日志:删除未同步下发订单成功24072111441962230138
2024-07-21 11:44:29 >>>故障排除日志:终端同步成功后剩余订单列表


===11:48:59===
2024-07-21 11:48:03>>>cash read=00
2024-07-21 11:48:04>>>cash read=29
2024-07-21 11:48:04 >>>回调事件130,cash_status,20029,退钞中
2024-07-21 11:48:04>>>cash read=2F29
2024-07-21 11:48:06>>>cash read=3E
2024-07-21 11:48:12>>>cash read=00
2024-07-21 11:48:13>>>cash read=2F29
2024-07-21 11:48:15>>>cash read=3E
2024-07-21 11:48:17>>>cash read=00
2024-07-21 11:48:18>>>cash read=29
2024-07-21 11:48:18 >>>回调事件130,cash_status,20029,退钞中
2024-07-21 11:48:19>>>cash read=2F29
2024-07-21 11:48:20>>>cash read=00
2024-07-21 11:48:21>>>cash read=292F29
2024-07-21 11:48:21 >>>回调事件130,cash_status,20029,退钞中
2024-07-21 11:48:22>>>cash read=3E
2024-07-21 11:48:24>>>cash read=00
2024-07-21 11:48:26>>>cash read=29
2024-07-21 11:48:26 >>>回调事件130,cash_status,20029,退钞中
2024-07-21 11:48:26>>>cash read=2F29
2024-07-21 11:48:27>>>cash read=01
2024-07-21 11:48:28>>>cash read=2F
2024-07-21 11:48:29>>>cash read=00
2024-07-21 11:48:30>>>cash read=2F29
2024-07-21 11:48:31>>>cash read=3E
2024-07-21 11:48:32>>>cash read=00
2024-07-21 11:48:34>>>cash read=2F29
2024-07-21 11:48:35>>>cash read=3E
2024-07-21 11:48:48>>>cash read=00
2024-07-21 11:48:48>>>cash read=818F42
2024-07-21 11:48:48>>>cash write=02
2024-07-21 11:48:48 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-07-21 11:48:49>>>cash read=10
2024-07-21 11:48:49 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-07-21 11:48:49 >>>开始打印,排队号为48,订单号为2407211148490021806665
2024-07-21 11:48:49>>>订单2407211148490021806665写入成功,剩余空间为1678500,占用RAM为606.166015625
删除未同步订单2407211148490021806665
2024-07-21 11:48:52>>>订单2407211148490021806665删除成功,剩余空间为1679500,占用RAM为619.666015625
检测订单目录中>>>
无未同步订单>>>
2024-07-21 11:48:52 >>>当前Ram内存为587.3505859375
定时检测未同步订单启用
2024-07-21 11:48:52>>>cash write=0C
2024-07-21 11:48:52>>>cash read=3E


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


===12:00:59===
2024-07-21 12:00:58>>>cash read=00


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


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


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


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


===12:09:00===
2024-07-21 12:08:06 >>>回调事件[910,devices/TL2180]
2024-07-21 12:08:06 >>>故障排除日志:上一MQTT订单号缓存列表为24072112064418088776
2024-07-21 12:08:06 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 12:08:06 开始打印,排队:52,票券:2407211207580702431701,订单:24072112075807020434,[2024-07-21 12:07:58支付宝支付10元]
2024-07-21 12:08:08 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407211207580702431701","queue_number":52,"trade_uid":"24072112075807020434"}]}
2024-07-21 12:08:08 >>>故障排除日志:删除未同步下发订单成功24072112075807020434
2024-07-21 12:08:08 >>>故障排除日志:终端同步成功后剩余订单列表
2024-07-21 12:08:28 >>>回调事件[910,devices/TL2180]
2024-07-21 12:08:28 >>>故障排除日志:上一MQTT订单号缓存列表为24072112075807020434
2024-07-21 12:08:28 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 12:08:28 开始打印,排队:53,票券:2407211208201448874701,订单:24072112082014484690,[2024-07-21 12:08:20支付宝支付10元]
2024-07-21 12:08:30 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407211208201448874701","queue_number":53,"trade_uid":"24072112082014484690"}]}
2024-07-21 12:08:30 >>>故障排除日志:删除未同步下发订单成功24072112082014484690
2024-07-21 12:08:30 >>>故障排除日志:终端同步成功后剩余订单列表


===12:10:00===
2024-07-21 12:09:03 >>>回调事件[910,devices/TL2180]
2024-07-21 12:09:03 >>>故障排除日志:上一MQTT订单号缓存列表为24072112082014484690
2024-07-21 12:09:03 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 12:09:03 开始打印,排队:54,票券:2407211208541531743201,订单:24072112085415310502,[2024-07-21 12:08:54支付宝支付10元]
2024-07-21 12:09:05 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407211208541531743201","queue_number":54,"trade_uid":"24072112085415310502"}]}
2024-07-21 12:09:05 >>>故障排除日志:删除未同步下发订单成功24072112085415310502
2024-07-21 12:09:05 >>>故障排除日志:终端同步成功后剩余订单列表
2024-07-21 12:09:48 >>>回调事件[910,devices/TL2180]
2024-07-21 12:09:48 >>>故障排除日志:上一MQTT订单号缓存列表为24072112085415310502
2024-07-21 12:09:48 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 12:09:48 开始打印,排队:55,票券:2407211209263836971901,订单:24072112092638366389,[2024-07-21 12:09:26支付宝支付10元]
2024-07-21 12:09:50 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407211209263836971901","queue_number":55,"trade_uid":"24072112092638366389"}]}
2024-07-21 12:09:50 >>>故障排除日志:删除未同步下发订单成功24072112092638366389
2024-07-21 12:09:50 >>>故障排除日志:终端同步成功后剩余订单列表


===12:24:01===
2024-07-21 12:23:22 >>>回调事件[910,devices/TL2180]
2024-07-21 12:23:22 >>>故障排除日志:上一MQTT订单号缓存列表为24072112092638366389
2024-07-21 12:23:22 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 12:23:23 开始打印,排队:56,票券:2407211223153907537901,订单:24072112231539071852,[2024-07-21 12:23:15微信支付10元]
2024-07-21 12:23:25 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407211223153907537901","queue_number":56,"trade_uid":"24072112231539071852"}]}
2024-07-21 12:23:25 >>>故障排除日志:删除未同步下发订单成功24072112231539071852
2024-07-21 12:23:25 >>>故障排除日志:终端同步成功后剩余订单列表
2024-07-21 12:23:42 >>>回调事件[910,devices/TL2180]
2024-07-21 12:23:43 >>>故障排除日志:上一MQTT订单号缓存列表为24072112231539071852
2024-07-21 12:23:43 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 12:23:43 开始打印,排队:57,票券:2407211223360308287801,订单:24072112233603078343,[2024-07-21 12:23:36微信支付10元]
2024-07-21 12:23:45 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407211223360308287801","queue_number":57,"trade_uid":"24072112233603078343"}]}
2024-07-21 12:23:45 >>>故障排除日志:删除未同步下发订单成功24072112233603078343
2024-07-21 12:23:45 >>>故障排除日志:终端同步成功后剩余订单列表


===12:25:01===
2024-07-21 12:24:52 >>>回调事件[910,devices/TL2180]
2024-07-21 12:24:52 >>>故障排除日志:上一MQTT订单号缓存列表为24072112233603078343
2024-07-21 12:24:52 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 12:24:52 开始打印,排队:58,票券:2407211224439163236301,订单:24072112244391627801,[2024-07-21 12:24:43支付宝支付10元]
2024-07-21 12:24:54 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407211224439163236301","queue_number":58,"trade_uid":"24072112244391627801"}]}
2024-07-21 12:24:54 >>>故障排除日志:删除未同步下发订单成功24072112244391627801
2024-07-21 12:24:54 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


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


===12:53:03===
2024-07-21 12:52:10 >>>回调事件[910,devices/TL2180]
2024-07-21 12:52:10 >>>故障排除日志:上一MQTT订单号缓存列表为24072112480457651710
2024-07-21 12:52:10 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 12:52:10 开始打印,排队:64,票券:2407211251596878469601,订单:24072112515968780609,[2024-07-21 12:51:59微信支付10元]
2024-07-21 12:52:12 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407211251596878469601","queue_number":64,"trade_uid":"24072112515968780609"}]}
2024-07-21 12:52:12 >>>故障排除日志:删除未同步下发订单成功24072112515968780609
2024-07-21 12:52:12 >>>故障排除日志:终端同步成功后剩余订单列表
2024-07-21 12:52:57 >>>回调事件[910,devices/TL2180]
2024-07-21 12:52:57 >>>故障排除日志:上一MQTT订单号缓存列表为24072112515968780609
2024-07-21 12:52:57 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 12:52:57 开始打印,排队:65,票券:2407211252421201382401,订单:24072112524212010156,[2024-07-21 12:52:42支付宝支付10元]
2024-07-21 12:52:59 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407211252421201382401","queue_number":65,"trade_uid":"24072112524212010156"}]}
2024-07-21 12:52:59 >>>故障排除日志:删除未同步下发订单成功24072112524212010156
2024-07-21 12:52:59 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


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


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


===13:54:05===
2024-07-21 13:53:36 >>>回调事件[910,devices/TL2180]
2024-07-21 13:53:36 >>>故障排除日志:上一MQTT订单号缓存列表为24072113304500757783
2024-07-21 13:53:36 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 13:53:36 开始打印,排队:70,票券:2407211353259300586801,订单:24072113532593000878,[2024-07-21 13:53:25支付宝支付10元]
2024-07-21 13:53:38 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407211353259300586801","queue_number":70,"trade_uid":"24072113532593000878"}]}
2024-07-21 13:53:38 >>>故障排除日志:删除未同步下发订单成功24072113532593000878
2024-07-21 13:53:38 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


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


===14:52:07===
2024-07-21 14:51:19 >>>回调事件[910,devices/TL2180]
2024-07-21 14:51:19 >>>故障排除日志:上一MQTT订单号缓存列表为24072114494981525285
2024-07-21 14:51:19 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 14:51:19 开始打印,排队:76,票券:2407211451105610911601,订单:24072114511056105481,[2024-07-21 14:51:10支付宝支付10元]
2024-07-21 14:51:21 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407211451105610911601","queue_number":76,"trade_uid":"24072114511056105481"}]}
2024-07-21 14:51:21 >>>故障排除日志:删除未同步下发订单成功24072114511056105481
2024-07-21 14:51:21 >>>故障排除日志:终端同步成功后剩余订单列表
2024-07-21 14:51:51 >>>回调事件[910,devices/TL2180]
2024-07-21 14:51:51 >>>故障排除日志:上一MQTT订单号缓存列表为24072114511056105481
2024-07-21 14:51:51 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 14:51:51 开始打印,排队:77,票券:2407211451450095349501,订单:24072114514500949979,[2024-07-21 14:51:45支付宝支付10元]
2024-07-21 14:51:53 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407211451450095349501","queue_number":77,"trade_uid":"24072114514500949979"}]}
2024-07-21 14:51:53 >>>故障排除日志:删除未同步下发订单成功24072114514500949979
2024-07-21 14:51:53 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


===15:08:08===
2024-07-21 15:07:17>>>cash read=0A
2024-07-21 15:07:18>>>cash read=3E


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


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


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


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


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


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


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


===15:38:10===
2024-07-21 15:37:32 >>>回调事件[910,devices/TL2180]
2024-07-21 15:37:32 >>>故障排除日志:上一MQTT订单号缓存列表为24072115212851251010|24072115212851251010
2024-07-21 15:37:32 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 15:37:32 开始打印,排队:86,票券:2407211537245115128901,订单:24072115372451146102,[2024-07-21 15:37:24微信支付10元]
2024-07-21 15:37:34 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407211537245115128901","queue_number":86,"trade_uid":"24072115372451146102"}]}
2024-07-21 15:37:34 >>>故障排除日志:删除未同步下发订单成功24072115372451146102
2024-07-21 15:37:34 >>>故障排除日志:终端同步成功后剩余订单列表
2024-07-21 15:38:00 >>>回调事件[910,devices/TL2180]
2024-07-21 15:38:01 >>>故障排除日志:上一MQTT订单号缓存列表为24072115372451146102
2024-07-21 15:38:01 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 15:38:01 开始打印,排队:87,票券:2407211537520540269601,订单:24072115375205398328,[2024-07-21 15:37:52微信支付10元]
2024-07-21 15:38:01 开始打印,排队:88,票券:2407211537520540414802,订单:24072115375205398328,[2024-07-21 15:37:52微信支付10元]
2024-07-21 15:38:01 开始打印,排队:89,票券:2407211537520540478903,订单:24072115375205398328,[2024-07-21 15:37:52微信支付10元]
2024-07-21 15:38:06 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407211537520540269601","queue_number":87,"trade_uid":"24072115375205398328"},{"ticket_no":"2407211537520540414802","queue_number":88,"trade_uid":"24072115375205398328"},{"ticket_no":"2407211537520540478903","queue_number":89,"trade_uid":"24072115375205398328"}]}
2024-07-21 15:38:06 >>>故障排除日志:删除未同步下发订单成功24072115375205398328
2024-07-21 15:38:06 >>>故障排除日志:删除未同步下发订单成功24072115375205398328
2024-07-21 15:38:06 >>>故障排除日志:删除未同步下发订单成功24072115375205398328
2024-07-21 15:38:06 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


===15:50:11===
2024-07-21 15:49:41 >>>回调事件[910,devices/TL2180]
2024-07-21 15:49:41 >>>故障排除日志:上一MQTT订单号缓存列表为24072115420734267845
2024-07-21 15:49:41 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 15:49:41 开始打印,排队:92,票券:2407211549331436195901,订单:24072115493314358442,[2024-07-21 15:49:33支付宝支付10元]
2024-07-21 15:49:43 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407211549331436195901","queue_number":92,"trade_uid":"24072115493314358442"}]}
2024-07-21 15:49:43 >>>故障排除日志:删除未同步下发订单成功24072115493314358442
2024-07-21 15:49:43 >>>故障排除日志:终端同步成功后剩余订单列表


===15:51:11===
2024-07-21 15:50:44>>>cash read=00
2024-07-21 15:50:45>>>cash read=2F29
2024-07-21 15:50:47>>>cash read=01
2024-07-21 15:50:48>>>cash read=2F
2024-07-21 15:50:49>>>cash read=3E
2024-07-21 15:50:53>>>cash read=00
2024-07-21 15:50:54>>>cash read=818F42
2024-07-21 15:50:54>>>cash write=02
2024-07-21 15:50:54 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-07-21 15:50:54>>>cash read=10
2024-07-21 15:50:54 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-07-21 15:50:54 >>>开始打印,排队号为93,订单号为2407211550540021809650
2024-07-21 15:50:55>>>订单2407211550540021809650写入成功,剩余空间为1679500,占用RAM为600.3076171875
删除未同步订单2407211550540021809650
2024-07-21 15:50:57>>>订单2407211550540021809650删除成功,剩余空间为1680500,占用RAM为614.1005859375
检测订单目录中>>>
无未同步订单>>>
2024-07-21 15:50:57 >>>当前Ram内存为584.9931640625
定时检测未同步订单启用
2024-07-21 15:50:58>>>cash write=0C
2024-07-21 15:50:58>>>cash read=3E


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


===15:55:12===
2024-07-21 15:54:21>>>cash read=00
2024-07-21 15:54:21>>>cash read=2F29
2024-07-21 15:54:22>>>cash read=01
2024-07-21 15:54:26>>>cash read=2F
2024-07-21 15:54:27>>>cash read=2F29
2024-07-21 15:54:29>>>cash read=3E
2024-07-21 15:54:38>>>cash read=00
2024-07-21 15:54:38>>>cash read=818F42
2024-07-21 15:54:38>>>cash write=02
2024-07-21 15:54:38 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-07-21 15:54:38>>>cash read=10
2024-07-21 15:54:38 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-07-21 15:54:38 >>>开始打印,排队号为94,订单号为2407211554380021805143
2024-07-21 15:54:39>>>订单2407211554380021805143写入成功,剩余空间为1679500,占用RAM为600.6689453125
删除未同步订单2407211554380021805143
2024-07-21 15:54:41>>>订单2407211554380021805143删除成功,剩余空间为1680500,占用RAM为614.9873046875
检测订单目录中>>>
无未同步订单>>>
2024-07-21 15:54:41 >>>当前Ram内存为585.078125
定时检测未同步订单启用
2024-07-21 15:54:42>>>cash write=0C
2024-07-21 15:54:42>>>cash read=3E
2024-07-21 15:54:43>>>cash read=00
2024-07-21 15:54:43>>>cash read=818F42
2024-07-21 15:54:43>>>cash write=02
2024-07-21 15:54:43 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-07-21 15:54:44>>>cash read=10
2024-07-21 15:54:44 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-07-21 15:54:44 >>>开始打印,排队号为95,订单号为2407211554440021809862
定时检测未同步订单关闭
2024-07-21 15:54:44>>>订单2407211554440021809862写入成功,剩余空间为1678500,占用RAM为606.484375
删除未同步订单2407211554440021809862
2024-07-21 15:54:47>>>订单2407211554440021809862删除成功,剩余空间为1679500,占用RAM为597.046875
检测订单目录中>>>
无未同步订单>>>
2024-07-21 15:54:47 >>>当前Ram内存为587.2373046875
定时检测未同步订单启用
2024-07-21 15:54:47>>>cash write=0C
2024-07-21 15:54:48>>>cash read=3E


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


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


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


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


===16:15:13===
2024-07-21 16:14:56 >>>回调事件[910,devices/TL2180]
2024-07-21 16:14:56 >>>故障排除日志:上一MQTT订单号缓存列表为24072116110575435740
2024-07-21 16:14:56 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 16:14:56 开始打印,排队:99,票券:2407211614494959475801,订单:24072116144949591608,[2024-07-21 16:14:49微信支付10元]
2024-07-21 16:14:58 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407211614494959475801","queue_number":99,"trade_uid":"24072116144949591608"}]}
2024-07-21 16:14:58 >>>故障排除日志:删除未同步下发订单成功24072116144949591608
2024-07-21 16:14:59 >>>故障排除日志:终端同步成功后剩余订单列表
2024-07-21 16:15:03 >>>回调事件[910,devices/TL2180]
2024-07-21 16:15:03 >>>故障排除日志:上一MQTT订单号缓存列表为24072116144949591608
2024-07-21 16:15:03 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 16:15:03 开始打印,排队:100,票券:2407211614467964480301,订单:24072116144679640757,[2024-07-21 16:14:46微信支付10元]
2024-07-21 16:15:05 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407211614467964480301","queue_number":100,"trade_uid":"24072116144679640757"}]}
2024-07-21 16:15:05 >>>故障排除日志:删除未同步下发订单成功24072116144679640757
2024-07-21 16:15:05 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


===16:26:14===
2024-07-21 16:25:58>>>cash read=00
2024-07-21 16:25:59>>>cash read=3E
2024-07-21 16:26:03>>>cash read=00
2024-07-21 16:26:03>>>cash read=818F42
2024-07-21 16:26:03>>>cash write=02
2024-07-21 16:26:03 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-07-21 16:26:03>>>cash read=10
2024-07-21 16:26:03 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-07-21 16:26:03 >>>开始打印,排队号为103,订单号为2407211626030021803689
2024-07-21 16:26:04>>>订单2407211626030021803689写入成功,剩余空间为1680000,占用RAM为599.892578125
删除未同步订单2407211626030021803689
2024-07-21 16:26:06>>>订单2407211626030021803689删除成功,剩余空间为1680500,占用RAM为615.486328125
检测订单目录中>>>
无未同步订单>>>
2024-07-21 16:26:06 >>>当前Ram内存为584.9716796875
定时检测未同步订单启用
2024-07-21 16:26:07>>>cash write=0C
2024-07-21 16:26:07>>>cash read=3E


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


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


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


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


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


===16:38:16===
2024-07-21 16:38:12>>>cash read=00
2024-07-21 16:38:13>>>cash read=29
2024-07-21 16:38:13 >>>回调事件130,cash_status,20029,退钞中
2024-07-21 16:38:13>>>cash read=2F29


===16:39:16===
2024-07-21 16:38:15>>>cash read=3E
2024-07-21 16:38:18>>>cash read=2F29
2024-07-21 16:38:20>>>cash read=00
2024-07-21 16:38:21>>>cash read=818F42
2024-07-21 16:38:21>>>cash write=02
2024-07-21 16:38:21 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-07-21 16:38:22>>>cash read=10
2024-07-21 16:38:22 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-07-21 16:38:22 >>>开始打印,排队号为108,订单号为2407211638220021802978
2024-07-21 16:38:22>>>订单2407211638220021802978写入成功,剩余空间为1680000,占用RAM为599.986328125
删除未同步订单2407211638220021802978
2024-07-21 16:38:24>>>订单2407211638220021802978删除成功,剩余空间为1680500,占用RAM为613.9697265625
检测订单目录中>>>
无未同步订单>>>
2024-07-21 16:38:24 >>>当前Ram内存为585.076171875
定时检测未同步订单启用
2024-07-21 16:38:25>>>cash write=0C
2024-07-21 16:38:25>>>cash read=3E
2024-07-21 16:39:10 >>>回调事件[910,devices/TL2180]
2024-07-21 16:39:10 >>>故障排除日志:上一MQTT订单号缓存列表为24072116332525558138
2024-07-21 16:39:10 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 16:39:10 开始打印,排队:109,票券:2407211639043947941601,订单:24072116390439475580,[2024-07-21 16:39:04微信支付10元]
2024-07-21 16:39:13 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407211639043947941601","queue_number":109,"trade_uid":"24072116390439475580"}]}
2024-07-21 16:39:13 >>>故障排除日志:删除未同步下发订单成功24072116390439475580
2024-07-21 16:39:13 >>>故障排除日志:终端同步成功后剩余订单列表


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


===16:48:17===
2024-07-21 16:47:24 >>>回调事件[910,devices/TL2180]
2024-07-21 16:47:24 >>>故障排除日志:上一MQTT订单号缓存列表为24072116394004717407
2024-07-21 16:47:24 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 16:47:24 开始打印,排队:111,票券:2407211647164013785301,订单:24072116471640134582,[2024-07-21 16:47:16微信支付10元]
2024-07-21 16:47:26 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407211647164013785301","queue_number":111,"trade_uid":"24072116471640134582"}]}
2024-07-21 16:47:26 >>>故障排除日志:删除未同步下发订单成功24072116471640134582
2024-07-21 16:47:26 >>>故障排除日志:终端同步成功后剩余订单列表
2024-07-21 16:47:38>>>cash read=00
2024-07-21 16:47:39>>>cash read=29
2024-07-21 16:47:39 >>>回调事件130,cash_status,20029,退钞中
2024-07-21 16:47:40>>>cash read=2F29
2024-07-21 16:47:41>>>cash read=01
2024-07-21 16:47:42>>>cash read=2F
2024-07-21 16:47:43>>>cash read=3E
2024-07-21 16:47:45>>>cash read=00
2024-07-21 16:47:46>>>cash read=818F42
2024-07-21 16:47:46>>>cash write=02
2024-07-21 16:47:46 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-07-21 16:47:47>>>cash read=10
2024-07-21 16:47:47 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-07-21 16:47:47 >>>开始打印,排队号为112,订单号为2407211647470021803641
2024-07-21 16:47:47>>>订单2407211647470021803641写入成功,剩余空间为1679000,占用RAM为604.384765625
删除未同步订单2407211647470021803641
2024-07-21 16:47:49>>>订单2407211647470021803641删除成功,剩余空间为1679500,占用RAM为616.458984375
检测订单目录中>>>
无未同步订单>>>
2024-07-21 16:47:49 >>>当前Ram内存为585.9208984375
定时检测未同步订单启用
2024-07-21 16:47:50>>>cash write=0C
2024-07-21 16:47:50>>>cash read=3E


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


===16:59:17===
2024-07-21 16:58:43 >>>回调事件[910,devices/TL2180]
2024-07-21 16:58:43 >>>故障排除日志:上一MQTT订单号缓存列表为24072116471640134582
2024-07-21 16:58:43 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 16:58:43 开始打印,排队:113,票券:2407211658342559922101,订单:24072116583425594908,[2024-07-21 16:58:34微信支付10元]
2024-07-21 16:58:45 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407211658342559922101","queue_number":113,"trade_uid":"24072116583425594908"}]}
2024-07-21 16:58:46 >>>故障排除日志:删除未同步下发订单成功24072116583425594908
2024-07-21 16:58:46 >>>故障排除日志:终端同步成功后剩余订单列表


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


===17:06:21===
2024-07-21 17:05:35>>>cash read=00
2024-07-21 17:05:36>>>cash read=818F41
2024-07-21 17:05:36>>>cash write=02
2024-07-21 17:05:36 >>>回调事件130,cash_status,10022,进钞中...read money=5
2024-07-21 17:05:36>>>cash read=10
2024-07-21 17:05:36 >>>回调事件130,5,10023,finish Money=5,进钞完成
2024-07-21 17:05:37>>>cash write=0C
2024-07-21 17:05:37>>>cash read=3E
2024-07-21 17:05:40>>>cash read=00
2024-07-21 17:05:40>>>cash read=818F41
2024-07-21 17:05:40>>>cash write=02
2024-07-21 17:05:40 >>>回调事件130,cash_status,10022,进钞中...read money=5
2024-07-21 17:05:41>>>cash read=10
2024-07-21 17:05:41 >>>回调事件130,5,10023,finish Money=5,进钞完成
2024-07-21 17:05:41 >>>开始打印,排队号为115,订单号为2407211705360021803431
2024-07-21 17:05:41>>>订单2407211705360021803431写入成功,剩余空间为1679500,占用RAM为600.3310546875
删除未同步订单2407211705360021803431
2024-07-21 17:05:43>>>订单2407211705360021803431删除成功,剩余空间为1680500,占用RAM为617.830078125
检测订单目录中>>>
无未同步订单>>>
2024-07-21 17:05:43 >>>当前Ram内存为585.888671875
定时检测未同步订单启用
2024-07-21 17:05:44>>>cash write=0C
2024-07-21 17:05:44>>>cash read=3E


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


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


===17:19:23===
2024-07-21 17:19:15>>>cash read=00
2024-07-21 17:19:16>>>cash read=818F41
2024-07-21 17:19:16>>>cash write=02
2024-07-21 17:19:16 >>>回调事件130,cash_status,10022,进钞中...read money=5
2024-07-21 17:19:17>>>cash write=0C
2024-07-21 17:19:17>>>cash read=00
2024-07-21 17:19:17>>>cash read=10
2024-07-21 17:19:17 >>>回调事件130,5,10023,finish Money=5,进钞完成
2024-07-21 17:19:18>>>cash read=3E
2024-07-21 17:19:19>>>cash read=00
2024-07-21 17:19:20>>>cash read=818F41
2024-07-21 17:19:20>>>cash write=02
2024-07-21 17:19:20 >>>回调事件130,cash_status,10022,进钞中...read money=5
2024-07-21 17:19:20>>>cash read=10
2024-07-21 17:19:20 >>>回调事件130,5,10023,finish Money=5,进钞完成
2024-07-21 17:19:20 >>>开始打印,排队号为118,订单号为2407211719170021802332
2024-07-21 17:19:21>>>订单2407211719170021802332写入成功,剩余空间为1679500,占用RAM为600.447265625


===17:20:24===
删除未同步订单2407211719170021802332
2024-07-21 17:19:23>>>订单2407211719170021802332删除成功,剩余空间为1681500,占用RAM为619.1572265625
检测订单目录中>>>
无未同步订单>>>
2024-07-21 17:19:23 >>>当前Ram内存为584.873046875
定时检测未同步订单启用
2024-07-21 17:19:24>>>cash write=0C
2024-07-21 17:19:24>>>cash read=3E


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


===17:25:24===
2024-07-21 17:25:21 >>>回调事件[910,devices/TL2180]
2024-07-21 17:25:21 >>>故障排除日志:上一MQTT订单号缓存列表为24072117210149492329
2024-07-21 17:25:21 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 17:25:21 开始打印,排队:120,票券:2407211725155662654801,订单:24072117251556618306,[2024-07-21 17:25:15微信支付10元]


===17:26:24===
2024-07-21 17:25:23 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407211725155662654801","queue_number":120,"trade_uid":"24072117251556618306"}]}
2024-07-21 17:25:24 >>>故障排除日志:删除未同步下发订单成功24072117251556618306
2024-07-21 17:25:24 >>>故障排除日志:终端同步成功后剩余订单列表


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


===17:34:25===
2024-07-21 17:33:49 >>>回调事件[910,devices/TL2180]
2024-07-21 17:33:49 >>>故障排除日志:上一MQTT订单号缓存列表为24072117275889371482
2024-07-21 17:33:49 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 17:33:49 开始打印,排队:122,票券:2407211733421677721301,订单:24072117334216772989,[2024-07-21 17:33:42微信支付10元]
2024-07-21 17:33:51 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407211733421677721301","queue_number":122,"trade_uid":"24072117334216772989"}]}
2024-07-21 17:33:51 >>>故障排除日志:删除未同步下发订单成功24072117334216772989
2024-07-21 17:33:51 >>>故障排除日志:终端同步成功后剩余订单列表
2024-07-21 17:34:17>>>cash read=0A
2024-07-21 17:34:18>>>cash read=3E


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


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


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


===17:56:26===
2024-07-21 17:55:29 >>>回调事件[910,devices/TL2180]
2024-07-21 17:55:29 >>>故障排除日志:上一MQTT订单号缓存列表为24072117431617756551
2024-07-21 17:55:29 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 17:55:29 开始打印,排队:125,票券:2407211755210843979101,订单:24072117552108435792,[2024-07-21 17:55:21微信支付10元]
2024-07-21 17:55:31 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407211755210843979101","queue_number":125,"trade_uid":"24072117552108435792"}]}
2024-07-21 17:55:31 >>>故障排除日志:删除未同步下发订单成功24072117552108435792
2024-07-21 17:55:31 >>>故障排除日志:终端同步成功后剩余订单列表
2024-07-21 17:56:05 >>>回调事件[910,devices/TL2180]
2024-07-21 17:56:05 >>>故障排除日志:上一MQTT订单号缓存列表为24072117552108435792
2024-07-21 17:56:05 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 17:56:05 开始打印,排队:126,票券:2407211755567865283901,订单:24072117555678649182,[2024-07-21 17:55:56微信支付10元]
2024-07-21 17:56:07 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407211755567865283901","queue_number":126,"trade_uid":"24072117555678649182"}]}
2024-07-21 17:56:07 >>>故障排除日志:删除未同步下发订单成功24072117555678649182
2024-07-21 17:56:07 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


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


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


===18:09:27===
2024-07-21 18:08:27>>>cash write=0C
2024-07-21 18:08:27>>>cash read=3E
2024-07-21 18:08:44 >>>回调事件[910,devices/TL2180]
2024-07-21 18:08:44 >>>故障排除日志:上一MQTT订单号缓存列表为24072118042202110629
2024-07-21 18:08:44 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 18:08:44 开始打印,排队:133,票券:2407211808360339548201,订单:24072118083603392187,[2024-07-21 18:08:36支付宝支付10元]
2024-07-21 18:08:46 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407211808360339548201","queue_number":133,"trade_uid":"24072118083603392187"}]}
2024-07-21 18:08:47 >>>故障排除日志:删除未同步下发订单成功24072118083603392187
2024-07-21 18:08:47 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单关闭
检测订单目录中>>>
无未同步订单>>>


===18:11:14===
上一时间戳为1721520465
当日首次设置时间戳true为1721556613
今日nvm排队号为134
当前排队号为134,音量为6
初始化产品信息:[{"time_limit_date":null,"ticket_category":"0","expiry_date":90,"product_detail":"","time_limit_status":"0","begin_minute":null,"product_uid":"4351590954437531799","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:a303f****09505
纸币器设置接收纸币范围为15
欢迎使用天羚自助售票系统[2.5.1]
定时检测未同步订单启用
2024-07-21 18:10:13>>>cash write=30
2024-07-21 18:10:13>>>cash write=02
2024-07-21 18:10:13>>>cash write=3E
2024-07-21 18:10:13>>>cash read=808F808F808F808F
系统时间初始化成功，时间为2024721181013
2024-07-21 18:10:14>>>cash write=02
2024-07-21 18:10:14 >>>剩余flash空间=1680500,占用RAM为624.73828125
2024-07-21 18:10:14 >>>回调事件:910,subscribe,10000,连接服务器成功

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

2024-07-21 18:10:17>>>cash write=0C
2024-07-21 18:10:17>>>cash read=3E
流量卡还有314天过期
2024-07-21 18:10:21 >>>当前Ram内存为642.5810546875


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


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


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


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


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


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


===18:40:16===
2024-07-21 18:39:41>>>cash read=00
2024-07-21 18:39:41>>>cash read=2F29
2024-07-21 18:39:43>>>cash read=00
2024-07-21 18:39:43>>>cash read=818F42
2024-07-21 18:39:43>>>cash write=02
2024-07-21 18:39:43 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-07-21 18:39:44>>>cash read=10
2024-07-21 18:39:44 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-07-21 18:39:44 >>>开始打印,排队号为138,订单号为2407211839440021809667
2024-07-21 18:39:44>>>订单2407211839440021809667写入成功,剩余空间为1680000,占用RAM为601.5830078125
删除未同步订单2407211839440021809667
2024-07-21 18:39:46>>>订单2407211839440021809667删除成功,剩余空间为1680500,占用RAM为615.5322265625
检测订单目录中>>>
无未同步订单>>>
2024-07-21 18:39:46 >>>当前Ram内存为586.6005859375
定时检测未同步订单启用
2024-07-21 18:39:47>>>cash write=0C
2024-07-21 18:39:47>>>cash read=3E


===18:41:16===
2024-07-21 18:40:30 >>>回调事件[910,devices/TL2180]
2024-07-21 18:40:30 >>>故障排除日志:上一MQTT订单号缓存列表为24072118364808771404
2024-07-21 18:40:30 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 18:40:30 开始打印,排队:139,票券:2407211840232136819601,订单:24072118402321364813,[2024-07-21 18:40:23微信支付10元]
2024-07-21 18:40:32 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407211840232136819601","queue_number":139,"trade_uid":"24072118402321364813"}]}
2024-07-21 18:40:32 >>>故障排除日志:删除未同步下发订单成功24072118402321364813
2024-07-21 18:40:32 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单关闭
检测订单目录中>>>
无未同步订单>>>


===18:43:18===
2024-07-21 18:43:15 >>>回调事件[910,devices/TL2180]
2024-07-21 18:43:15 >>>故障排除日志:上一MQTT订单号缓存列表为24072118402321364813
2024-07-21 18:43:15 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 18:43:15 开始打印,排队:140,票券:2407211843094228986001,订单:24072118430942285515,[2024-07-21 18:43:09微信支付10元]


===18:44:19===
2024-07-21 18:43:17 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407211843094228986001","queue_number":140,"trade_uid":"24072118430942285515"}]}
2024-07-21 18:43:17 >>>故障排除日志:删除未同步下发订单成功24072118430942285515
2024-07-21 18:43:17 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


===18:57:20===
2024-07-21 18:56:40 >>>回调事件[910,devices/TL2180]
2024-07-21 18:56:40 >>>故障排除日志:上一MQTT订单号缓存列表为24072118553797020801
2024-07-21 18:56:40 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 18:56:40 开始打印,排队:144,票券:2407211856350515763601,订单:24072118563505154232,[2024-07-21 18:56:35微信支付10元]
2024-07-21 18:56:42 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407211856350515763601","queue_number":144,"trade_uid":"24072118563505154232"}]}
2024-07-21 18:56:42 >>>故障排除日志:删除未同步下发订单成功24072118563505154232
2024-07-21 18:56:42 >>>故障排除日志:终端同步成功后剩余订单列表


===18:58:21===
2024-07-21 18:57:30 >>>回调事件[910,devices/TL2180]
2024-07-21 18:57:30 >>>故障排除日志:上一MQTT订单号缓存列表为24072118563505154232
2024-07-21 18:57:30 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 18:57:30 开始打印,排队:145,票券:2407211857247632360601,订单:24072118572476320169,[2024-07-21 18:57:24微信支付10元]
2024-07-21 18:57:32 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407211857247632360601","queue_number":145,"trade_uid":"24072118572476320169"}]}
2024-07-21 18:57:32 >>>故障排除日志:删除未同步下发订单成功24072118572476320169
2024-07-21 18:57:32 >>>故障排除日志:终端同步成功后剩余订单列表
2024-07-21 18:58:18 >>>回调事件[910,devices/TL2180]
2024-07-21 18:58:18 >>>故障排除日志:上一MQTT订单号缓存列表为24072118572476320169
2024-07-21 18:58:18 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 18:58:18 开始打印,排队:146,票券:2407211858125532889101,订单:24072118581255325565,[2024-07-21 18:58:12微信支付10元]


===18:59:22===
2024-07-21 18:58:20 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407211858125532889101","queue_number":146,"trade_uid":"24072118581255325565"}]}
2024-07-21 18:58:20 >>>故障排除日志:删除未同步下发订单成功24072118581255325565
2024-07-21 18:58:20 >>>故障排除日志:终端同步成功后剩余订单列表


===19:03:22===
2024-07-21 19:02:45 >>>回调事件[910,devices/TL2180]
2024-07-21 19:02:45 >>>故障排除日志:上一MQTT订单号缓存列表为24072118581255325565
2024-07-21 19:02:45 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 19:02:45 开始打印,排队:147,票券:2407211902379820850601,订单:24072119023798204174,[2024-07-21 19:02:37微信支付10元]
2024-07-21 19:02:47 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407211902379820850601","queue_number":147,"trade_uid":"24072119023798204174"}]}
2024-07-21 19:02:47 >>>故障排除日志:删除未同步下发订单成功24072119023798204174
2024-07-21 19:02:47 >>>故障排除日志:终端同步成功后剩余订单列表
2024-07-21 19:03:12 >>>回调事件[910,devices/TL2180]
2024-07-21 19:03:13 >>>故障排除日志:上一MQTT订单号缓存列表为24072119023798204174
2024-07-21 19:03:13 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 19:03:13 开始打印,排队:148,票券:2407211902597100720501,订单:24072119025971001294,[2024-07-21 19:02:59微信支付10元]
2024-07-21 19:03:15 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407211902597100720501","queue_number":148,"trade_uid":"24072119025971001294"}]}
2024-07-21 19:03:15 >>>故障排除日志:删除未同步下发订单成功24072119025971001294
2024-07-21 19:03:15 >>>故障排除日志:终端同步成功后剩余订单列表


===19:06:22===
2024-07-21 19:05:33>>>cash read=00
2024-07-21 19:05:33>>>cash read=818F42
2024-07-21 19:05:33>>>cash write=02
2024-07-21 19:05:33 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-07-21 19:05:34>>>cash read=10
2024-07-21 19:05:34 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-07-21 19:05:34 >>>开始打印,排队号为149,订单号为2407211905340021806929
2024-07-21 19:05:34>>>订单2407211905340021806929写入成功,剩余空间为1680500,占用RAM为601.2978515625
删除未同步订单2407211905340021806929
2024-07-21 19:05:36>>>订单2407211905340021806929删除成功,剩余空间为1680500,占用RAM为617.1240234375
检测订单目录中>>>
无未同步订单>>>
2024-07-21 19:05:36 >>>当前Ram内存为586.642578125
定时检测未同步订单启用
2024-07-21 19:05:37>>>cash write=0C
2024-07-21 19:05:37>>>cash read=3E
2024-07-21 19:06:00 >>>回调事件[910,devices/TL2180]
2024-07-21 19:06:00 >>>故障排除日志:上一MQTT订单号缓存列表为24072119025971001294
2024-07-21 19:06:00 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 19:06:00 开始打印,排队:150,票券:2407211905522471873801,订单:24072119055224712786,[2024-07-21 19:05:52微信支付10元]
2024-07-21 19:06:02 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407211905522471873801","queue_number":150,"trade_uid":"24072119055224712786"}]}
2024-07-21 19:06:02 >>>故障排除日志:删除未同步下发订单成功24072119055224712786
2024-07-21 19:06:02 >>>故障排除日志:终端同步成功后剩余订单列表


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


===19:08:23===
2024-07-21 19:07:51 >>>回调事件[910,devices/TL2180]
2024-07-21 19:07:51 >>>故障排除日志:上一MQTT订单号缓存列表为24072119055224712786
2024-07-21 19:07:51 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 19:07:51 开始打印,排队:151,票券:2407211907423698140801,订单:24072119074236976884,[2024-07-21 19:07:42微信支付10元]
2024-07-21 19:07:53 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407211907423698140801","queue_number":151,"trade_uid":"24072119074236976884"}]}
2024-07-21 19:07:53 >>>故障排除日志:删除未同步下发订单成功24072119074236976884
2024-07-21 19:07:54 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


===19:21:25===
2024-07-21 19:20:24 >>>回调事件[910,devices/TL2180]
2024-07-21 19:20:24 >>>故障排除日志:上一MQTT订单号缓存列表为24072119184502446313
2024-07-21 19:20:24 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 19:20:25 开始打印,排队:156,票券:2407211920173085621601,订单:24072119201730851985,[2024-07-21 19:20:17微信支付10元]
2024-07-21 19:20:27 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407211920173085621601","queue_number":156,"trade_uid":"24072119201730851985"}]}
2024-07-21 19:20:27 >>>故障排除日志:删除未同步下发订单成功24072119201730851985
2024-07-21 19:20:27 >>>故障排除日志:终端同步成功后剩余订单列表
2024-07-21 19:20:49 >>>回调事件[910,devices/TL2180]
2024-07-21 19:20:50 >>>故障排除日志:上一MQTT订单号缓存列表为24072119201730851985
2024-07-21 19:20:50 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 19:20:50 开始打印,排队:157,票券:2407211920405698482701,订单:24072119204056981212,[2024-07-21 19:20:40微信支付10元]
2024-07-21 19:20:51 >>>回调事件[910,devices/TL2180]
2024-07-21 19:20:51 >>>故障排除日志:上一MQTT订单号缓存列表为24072119204056981212
2024-07-21 19:20:51 >>>故障排除日志:终端未同步成功订单列表015724072119204056981212
已接收过此消息,票券号为2407211920405698482701,排队号为157
2024-07-21 19:20:51 开始打印,排队:158,票券:2407211920439285125601,订单:24072119204392846192,[2024-07-21 19:20:43微信支付10元]
2024-07-21 19:20:53 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407211920405698482701","queue_number":157,"trade_uid":"24072119204056981212"}]}
2024-07-21 19:20:54 >>>故障排除日志:删除未同步下发订单成功24072119204056981212
2024-07-21 19:20:54 >>>故障排除日志:终端同步成功后剩余订单列表015824072119204392846192
2024-07-21 19:20:54 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407211920405698482701","queue_number":157,"trade_uid":"24072119204056981212"},{"ticket_no":"2407211920439285125601","queue_number":158,"trade_uid":"24072119204392846192"}]}
2024-07-21 19:20:54 >>>故障排除日志:删除未同步下发订单成功24072119204392846192
2024-07-21 19:20:54 >>>故障排除日志:终端同步成功后剩余订单列表


===19:23:25===
2024-07-21 19:22:45 >>>回调事件[910,devices/TL2180]
2024-07-21 19:22:45 >>>故障排除日志:上一MQTT订单号缓存列表为24072119204056981212|24072119204392846192
2024-07-21 19:22:45 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 19:22:45 开始打印,排队:159,票券:2407211922395216400801,订单:24072119223952159847,[2024-07-21 19:22:39支付宝支付10元]
2024-07-21 19:22:47 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407211922395216400801","queue_number":159,"trade_uid":"24072119223952159847"}]}
2024-07-21 19:22:47 >>>故障排除日志:删除未同步下发订单成功24072119223952159847
2024-07-21 19:22:47 >>>故障排除日志:终端同步成功后剩余订单列表
2024-07-21 19:23:03 >>>回调事件[910,devices/TL2180]
2024-07-21 19:23:03 >>>故障排除日志:上一MQTT订单号缓存列表为24072119223952159847
2024-07-21 19:23:03 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 19:23:03 开始打印,排队:160,票券:2407211922564245313701,订单:24072119225642448903,[2024-07-21 19:22:56微信支付10元]
2024-07-21 19:23:06 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407211922564245313701","queue_number":160,"trade_uid":"24072119225642448903"}]}
2024-07-21 19:23:06 >>>故障排除日志:删除未同步下发订单成功24072119225642448903
2024-07-21 19:23:06 >>>故障排除日志:终端同步成功后剩余订单列表


===19:25:26===
2024-07-21 19:25:01 >>>回调事件[910,devices/TL2180]
2024-07-21 19:25:01 >>>故障排除日志:上一MQTT订单号缓存列表为24072119225642448903
2024-07-21 19:25:01 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 19:25:01 开始打印,排队:161,票券:2407211924508928472401,订单:24072119245089279170,[2024-07-21 19:24:50微信支付10元]
2024-07-21 19:25:03 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407211924508928472401","queue_number":161,"trade_uid":"24072119245089279170"}]}
2024-07-21 19:25:03 >>>故障排除日志:删除未同步下发订单成功24072119245089279170
2024-07-21 19:25:03 >>>故障排除日志:终端同步成功后剩余订单列表
2024-07-21 19:25:23 >>>回调事件[910,devices/TL2180]
2024-07-21 19:25:23 >>>故障排除日志:上一MQTT订单号缓存列表为24072119245089279170
2024-07-21 19:25:23 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 19:25:23 开始打印,排队:162,票券:2407211925146983989701,订单:24072119251469834668,[2024-07-21 19:25:14微信支付10元]


===19:26:29===
2024-07-21 19:25:25 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407211925146983989701","queue_number":162,"trade_uid":"24072119251469834668"}]}
2024-07-21 19:25:25 >>>故障排除日志:删除未同步下发订单成功24072119251469834668
2024-07-21 19:25:25 >>>故障排除日志:终端同步成功后剩余订单列表


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


===19:31:30===
2024-07-21 19:31:14 >>>回调事件[910,devices/TL2180]
2024-07-21 19:31:14 >>>故障排除日志:上一MQTT订单号缓存列表为24072119272463935115
2024-07-21 19:31:14 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 19:31:14 开始打印,排队:164,票券:2407211931083685018601,订单:24072119310836843963,[2024-07-21 19:31:08微信支付10元]
2024-07-21 19:31:16 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407211931083685018601","queue_number":164,"trade_uid":"24072119310836843963"}]}
2024-07-21 19:31:16 >>>故障排除日志:删除未同步下发订单成功24072119310836843963
2024-07-21 19:31:16 >>>故障排除日志:终端同步成功后剩余订单列表
2024-07-21 19:31:23>>>cash read=00
2024-07-21 19:31:24>>>cash read=29
2024-07-21 19:31:24 >>>回调事件130,cash_status,20029,退钞中
2024-07-21 19:31:24>>>cash read=2F29
2024-07-21 19:31:26>>>cash read=3E
2024-07-21 19:31:28>>>cash read=00


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


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


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


===19:39:31===
2024-07-21 19:38:50 >>>回调事件[910,devices/TL2180]
2024-07-21 19:38:50 >>>故障排除日志:上一MQTT订单号缓存列表为24072119352657909386
2024-07-21 19:38:50 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 19:38:50 开始打印,排队:168,票券:2407211938461005428501,订单:24072119384610050151,[2024-07-21 19:38:46微信支付10元]
2024-07-21 19:38:53 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407211938461005428501","queue_number":168,"trade_uid":"24072119384610050151"}]}
2024-07-21 19:38:53 >>>故障排除日志:删除未同步下发订单成功24072119384610050151
2024-07-21 19:38:53 >>>故障排除日志:终端同步成功后剩余订单列表
2024-07-21 19:39:02 >>>回调事件[910,devices/TL2180]
2024-07-21 19:39:02 >>>故障排除日志:上一MQTT订单号缓存列表为24072119384610050151
2024-07-21 19:39:02 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 19:39:02 开始打印,排队:169,票券:2407211938560588207001,订单:24072119385605877961,[2024-07-21 19:38:56微信支付10元]
2024-07-21 19:39:04 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407211938560588207001","queue_number":169,"trade_uid":"24072119385605877961"}]}
2024-07-21 19:39:04 >>>故障排除日志:删除未同步下发订单成功24072119385605877961
2024-07-21 19:39:04 >>>故障排除日志:终端同步成功后剩余订单列表


===19:41:31===
2024-07-21 19:40:32>>>cash read=00
2024-07-21 19:40:33>>>cash read=29
2024-07-21 19:40:33 >>>回调事件130,cash_status,20029,退钞中
2024-07-21 19:40:34>>>cash read=2F29
2024-07-21 19:40:35>>>cash read=3E
2024-07-21 19:40:38>>>cash read=00
2024-07-21 19:40:39>>>cash read=2F29
2024-07-21 19:40:41>>>cash read=3E
2024-07-21 19:40:48>>>cash read=00
2024-07-21 19:40:48>>>cash read=818F42
2024-07-21 19:40:48>>>cash write=02
2024-07-21 19:40:48 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-07-21 19:40:48>>>cash read=10
2024-07-21 19:40:48 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-07-21 19:40:48 >>>开始打印,排队号为170,订单号为2407211940480021807968
2024-07-21 19:40:49>>>订单2407211940480021807968写入成功,剩余空间为1679500,占用RAM为602.69140625
删除未同步订单2407211940480021807968
2024-07-21 19:40:51>>>订单2407211940480021807968删除成功,剩余空间为1680500,占用RAM为617.84765625
检测订单目录中>>>
无未同步订单>>>
2024-07-21 19:40:51 >>>当前Ram内存为586.80859375
定时检测未同步订单启用
2024-07-21 19:40:52>>>cash write=0C
2024-07-21 19:40:52>>>cash read=3E


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


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


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


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


===19:51:33===
2024-07-21 19:50:43 >>>回调事件[910,devices/TL2180]
2024-07-21 19:50:43 >>>故障排除日志:上一MQTT订单号缓存列表为24072119483267748709
2024-07-21 19:50:43 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 19:50:43 开始打印,排队:174,票券:2407211950374915037001,订单:24072119503749143246,[2024-07-21 19:50:37微信支付10元]
2024-07-21 19:50:46 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407211950374915037001","queue_number":174,"trade_uid":"24072119503749143246"}]}
2024-07-21 19:50:46 >>>故障排除日志:删除未同步下发订单成功24072119503749143246
2024-07-21 19:50:46 >>>故障排除日志:终端同步成功后剩余订单列表


===19:54:33===
2024-07-21 19:53:45 >>>回调事件[910,devices/TL2180]
2024-07-21 19:53:45 >>>故障排除日志:上一MQTT订单号缓存列表为24072119503749143246
2024-07-21 19:53:45 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 19:53:45 开始打印,排队:175,票券:2407211953366917262301,订单:24072119533669168341,[2024-07-21 19:53:36微信支付10元]
2024-07-21 19:53:47 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407211953366917262301","queue_number":175,"trade_uid":"24072119533669168341"}]}
2024-07-21 19:53:47 >>>故障排除日志:删除未同步下发订单成功24072119533669168341
2024-07-21 19:53:47 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


===20:00:34===
2024-07-21 19:59:39 >>>回调事件[910,devices/TL2180]
2024-07-21 19:59:39 >>>故障排除日志:上一MQTT订单号缓存列表为24072119591132876127
2024-07-21 19:59:39 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 19:59:39 开始打印,排队:178,票券:2407211959330204006001,订单:24072119593302035160,[2024-07-21 19:59:33微信支付10元]
2024-07-21 19:59:41 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407211959330204006001","queue_number":178,"trade_uid":"24072119593302035160"}]}
2024-07-21 19:59:41 >>>故障排除日志:删除未同步下发订单成功24072119593302035160
2024-07-21 19:59:41 >>>故障排除日志:终端同步成功后剩余订单列表


===20:02:34===
2024-07-21 20:01:51 >>>回调事件[910,devices/TL2180]
2024-07-21 20:01:51 >>>故障排除日志:上一MQTT订单号缓存列表为24072119593302035160
2024-07-21 20:01:51 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 20:01:51 开始打印,排队:179,票券:2407212001451039105101,订单:24072120014510385510,[2024-07-21 20:01:45支付宝支付10元]
2024-07-21 20:01:53 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407212001451039105101","queue_number":179,"trade_uid":"24072120014510385510"}]}
2024-07-21 20:01:53 >>>故障排除日志:删除未同步下发订单成功24072120014510385510
2024-07-21 20:01:53 >>>故障排除日志:终端同步成功后剩余订单列表
2024-07-21 20:02:04>>>cash read=00
2024-07-21 20:02:05>>>cash read=29
2024-07-21 20:02:05 >>>回调事件130,cash_status,20029,退钞中
2024-07-21 20:02:06>>>cash read=01
2024-07-21 20:02:11>>>cash read=00
2024-07-21 20:02:12>>>cash read=818F42
2024-07-21 20:02:12>>>cash write=02
2024-07-21 20:02:12 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-07-21 20:02:12>>>cash read=10
2024-07-21 20:02:12 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-07-21 20:02:12 >>>开始打印,排队号为180,订单号为2407212002120021805141
2024-07-21 20:02:12>>>订单2407212002120021805141写入成功,剩余空间为1679000,占用RAM为602.349609375
删除未同步订单2407212002120021805141
2024-07-21 20:02:15>>>订单2407212002120021805141删除成功,剩余空间为1680000,占用RAM为617.8583984375
检测订单目录中>>>
无未同步订单>>>
2024-07-21 20:02:15 >>>当前Ram内存为585.90234375
定时检测未同步订单启用
2024-07-21 20:02:16>>>cash write=0C
2024-07-21 20:02:16>>>cash read=3E


===20:03:35===
定时检测未同步订单关闭
检测订单目录中>>>
无未同步订单>>>
2024-07-21 20:03:32 >>>回调事件[910,devices/TL2180]
2024-07-21 20:03:32 >>>故障排除日志:上一MQTT订单号缓存列表为24072120014510385510
2024-07-21 20:03:32 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 20:03:32 开始打印,排队:181,票券:2407212003244249094001,订单:24072120032442487104,[2024-07-21 20:03:24微信支付10元]


===20:04:36===
2024-07-21 20:03:34 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407212003244249094001","queue_number":181,"trade_uid":"24072120032442487104"}]}
2024-07-21 20:03:34 >>>故障排除日志:删除未同步下发订单成功24072120032442487104
2024-07-21 20:03:34 >>>故障排除日志:终端同步成功后剩余订单列表
2024-07-21 20:04:12 >>>回调事件[910,devices/TL2180]
2024-07-21 20:04:12 >>>故障排除日志:上一MQTT订单号缓存列表为24072120032442487104
2024-07-21 20:04:12 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 20:04:12 开始打印,排队:182,票券:2407212004024483458101,订单:24072120040244830802,[2024-07-21 20:04:02支付宝支付10元]
2024-07-21 20:04:14 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407212004024483458101","queue_number":182,"trade_uid":"24072120040244830802"}]}
2024-07-21 20:04:14 >>>故障排除日志:删除未同步下发订单成功24072120040244830802
2024-07-21 20:04:14 >>>故障排除日志:终端同步成功后剩余订单列表


===20:08:36===
2024-07-21 20:07:58 >>>回调事件[910,devices/TL2180]
2024-07-21 20:07:58 >>>故障排除日志:上一MQTT订单号缓存列表为24072120040244830802
2024-07-21 20:07:58 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 20:07:58 开始打印,排队:183,票券:2407212007521724681301,订单:24072120075217243548,[2024-07-21 20:07:52微信支付10元]
2024-07-21 20:08:00 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407212007521724681301","queue_number":183,"trade_uid":"24072120075217243548"}]}
2024-07-21 20:08:00 >>>故障排除日志:删除未同步下发订单成功24072120075217243548
2024-07-21 20:08:00 >>>故障排除日志:终端同步成功后剩余订单列表
2024-07-21 20:08:05>>>cash read=00
2024-07-21 20:08:07>>>cash read=2F29
2024-07-21 20:08:08>>>cash read=3E
2024-07-21 20:08:12>>>cash read=00
2024-07-21 20:08:13>>>cash read=818F42
2024-07-21 20:08:13>>>cash write=02
2024-07-21 20:08:13 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-07-21 20:08:13>>>cash read=10
2024-07-21 20:08:13 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-07-21 20:08:13 >>>开始打印,排队号为184,订单号为2407212008130021807069
2024-07-21 20:08:14>>>订单2407212008130021807069写入成功,剩余空间为1679000,占用RAM为603.8388671875
删除未同步订单2407212008130021807069
2024-07-21 20:08:16>>>订单2407212008130021807069删除成功,剩余空间为1680000,占用RAM为617.41796875
检测订单目录中>>>
无未同步订单>>>
2024-07-21 20:08:16 >>>当前Ram内存为586.0029296875
定时检测未同步订单启用
2024-07-21 20:08:17>>>cash write=0C
2024-07-21 20:08:17>>>cash read=3E
2024-07-21 20:08:19 >>>回调事件[910,devices/TL2180]
2024-07-21 20:08:19 >>>故障排除日志:上一MQTT订单号缓存列表为24072120075217243548
2024-07-21 20:08:19 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 20:08:19 开始打印,排队:185,票券:2407212008126313809101,订单:24072120081263132294,[2024-07-21 20:08:12微信支付10元]
2024-07-21 20:08:21 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407212008126313809101","queue_number":185,"trade_uid":"24072120081263132294"}]}
2024-07-21 20:08:21 >>>故障排除日志:删除未同步下发订单成功24072120081263132294
2024-07-21 20:08:21 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


===20:17:37===
2024-07-21 20:16:38 >>>回调事件[910,devices/TL2180]
2024-07-21 20:16:38 >>>故障排除日志:上一MQTT订单号缓存列表为24072120162093044905
2024-07-21 20:16:38 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 20:16:38 开始打印,排队:189,票券:2407212016314975974101,订单:24072120163149726361,[2024-07-21 20:16:31支付宝支付10元]
2024-07-21 20:16:40 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407212016314975974101","queue_number":189,"trade_uid":"24072120163149726361"}]}
2024-07-21 20:16:40 >>>故障排除日志:删除未同步下发订单成功24072120163149726361
2024-07-21 20:16:40 >>>故障排除日志:终端同步成功后剩余订单列表
2024-07-21 20:16:59 >>>回调事件[910,devices/TL2180]
2024-07-21 20:16:59 >>>故障排除日志:上一MQTT订单号缓存列表为24072120163149726361
2024-07-21 20:16:59 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 20:16:59 开始打印,排队:190,票券:2407212016507545855001,订单:24072120165075454740,[2024-07-21 20:16:50支付宝支付10元]
2024-07-21 20:17:01 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407212016507545855001","queue_number":190,"trade_uid":"24072120165075454740"}]}
2024-07-21 20:17:01 >>>故障排除日志:删除未同步下发订单成功24072120165075454740
2024-07-21 20:17:01 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


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


===20:26:39===
2024-07-21 20:25:47 >>>回调事件[910,devices/TL2180]
2024-07-21 20:25:47 >>>故障排除日志:上一MQTT订单号缓存列表为24072120222260109193
2024-07-21 20:25:47 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 20:25:47 开始打印,排队:197,票券:2407212025400710582401,订单:24072120254007101864,[2024-07-21 20:25:40微信支付10元]
2024-07-21 20:25:49 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407212025400710582401","queue_number":197,"trade_uid":"24072120254007101864"}]}
2024-07-21 20:25:49 >>>故障排除日志:删除未同步下发订单成功24072120254007101864
2024-07-21 20:25:49 >>>故障排除日志:终端同步成功后剩余订单列表
2024-07-21 20:26:27 >>>回调事件[910,devices/TL2180]
2024-07-21 20:26:27 >>>故障排除日志:上一MQTT订单号缓存列表为24072120254007101864
2024-07-21 20:26:27 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 20:26:27 开始打印,排队:198,票券:2407212026162862204101,订单:24072120261628618361,[2024-07-21 20:26:16微信支付10元]
2024-07-21 20:26:30 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407212026162862204101","queue_number":198,"trade_uid":"24072120261628618361"}]}
2024-07-21 20:26:30 >>>故障排除日志:删除未同步下发订单成功24072120261628618361
2024-07-21 20:26:30 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


===20:32:40===
2024-07-21 20:31:58 >>>回调事件[910,devices/TL2180]
2024-07-21 20:31:58 >>>故障排除日志:上一MQTT订单号缓存列表为24072120275565673998
2024-07-21 20:31:58 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 20:31:58 开始打印,排队:201,票券:2407212031526651042901,订单:24072120315266499969,[2024-07-21 20:31:52支付宝支付10元]
2024-07-21 20:32:00 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407212031526651042901","queue_number":201,"trade_uid":"24072120315266499969"}]}
2024-07-21 20:32:00 >>>故障排除日志:删除未同步下发订单成功24072120315266499969
2024-07-21 20:32:00 >>>故障排除日志:终端同步成功后剩余订单列表


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


===20:36:41===
2024-07-21 20:36:00>>>cash read=0A
2024-07-21 20:36:01>>>cash read=3E


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


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


===20:50:42===
2024-07-21 20:50:05 >>>回调事件[910,devices/TL2180]
2024-07-21 20:50:05 >>>故障排除日志:上一MQTT订单号缓存列表为24072120431429169674
2024-07-21 20:50:05 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 20:50:05 开始打印,排队:205,票券:2407212049597305101501,订单:24072120495973047351,[2024-07-21 20:49:59微信支付10元]
2024-07-21 20:50:07 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407212049597305101501","queue_number":205,"trade_uid":"24072120495973047351"}]}
2024-07-21 20:50:07 >>>故障排除日志:删除未同步下发订单成功24072120495973047351
2024-07-21 20:50:07 >>>故障排除日志:终端同步成功后剩余订单列表
2024-07-21 20:50:19 >>>回调事件[910,devices/TL2180]
2024-07-21 20:50:20 >>>故障排除日志:上一MQTT订单号缓存列表为24072120495973047351
2024-07-21 20:50:20 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 20:50:20 开始打印,排队:206,票券:2407212050129017333701,订单:24072120501290168054,[2024-07-21 20:50:12微信支付10元]
2024-07-21 20:50:22 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407212050129017333701","queue_number":206,"trade_uid":"24072120501290168054"}]}
2024-07-21 20:50:22 >>>故障排除日志:删除未同步下发订单成功24072120501290168054
2024-07-21 20:50:22 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


===21:07:43===
2024-07-21 21:06:53 >>>回调事件[910,devices/TL2180]
2024-07-21 21:06:53 >>>故障排除日志:上一MQTT订单号缓存列表为24072121034875328818
2024-07-21 21:06:53 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 21:06:53 开始打印,排队:209,票券:2407212106465992551601,订单:24072121064659922442,[2024-07-21 21:06:46微信支付10元]
2024-07-21 21:06:55 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407212106465992551601","queue_number":209,"trade_uid":"24072121064659922442"}]}
2024-07-21 21:06:55 >>>故障排除日志:删除未同步下发订单成功24072121064659922442
2024-07-21 21:06:56 >>>故障排除日志:终端同步成功后剩余订单列表
2024-07-21 21:07:03 >>>回调事件[910,devices/TL2180]
2024-07-21 21:07:03 >>>故障排除日志:上一MQTT订单号缓存列表为24072121064659922442
2024-07-21 21:07:03 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 21:07:03 开始打印,排队:210,票券:2407212106570269912601,订单:24072121065702694106,[2024-07-21 21:06:57微信支付10元]
2024-07-21 21:07:06 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407212106570269912601","queue_number":210,"trade_uid":"24072121065702694106"}]}
2024-07-21 21:07:06 >>>故障排除日志:删除未同步下发订单成功24072121065702694106
2024-07-21 21:07:06 >>>故障排除日志:终端同步成功后剩余订单列表
2024-07-21 21:07:29 >>>回调事件[910,devices/TL2180]
2024-07-21 21:07:29 >>>故障排除日志:上一MQTT订单号缓存列表为24072121065702694106
2024-07-21 21:07:29 >>>故障排除日志:终端未同步成功订单列表
2024-07-21 21:07:29 开始打印,排队:211,票券:2407212107192283655201,订单:24072121071922831702,[2024-07-21 21:07:19微信支付10元]
2024-07-21 21:07:31 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407212107192283655201","queue_number":211,"trade_uid":"24072121071922831702"}]}
2024-07-21 21:07:32 >>>故障排除日志:删除未同步下发订单成功24072121071922831702
2024-07-21 21:07:32 >>>故障排除日志:终端同步成功后剩余订单列表