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

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

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

2024-07-20 08:06:18>>>cash write=0C
2024-07-20 08:06:18>>>cash read=3E
流量卡还有315天过期
2024-07-20 08:06:22 >>>当前Ram内存为608.13671875
2024-07-20 08:06:24 >>>回调事件[910,devices/TL2180]
当日首次设置时间戳true为1721433984
2024-07-20 08:06:25 >>>故障排除日志:上一MQTT订单号缓存列表为24071920594883096945
2024-07-20 08:06:25 >>>故障排除日志:终端未同步成功订单列表
2024-07-20 08:06:25 开始打印,排队:1,票券:2407200806170882831701,订单:24072008061708824506,[2024-07-20 08:06:17微信支付10元]
2024-07-20 08:06:27 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407200806170882831701","queue_number":1,"trade_uid":"24072008061708824506"}]}
2024-07-20 08:06:27 >>>故障排除日志:删除未同步下发订单成功24072008061708824506
2024-07-20 08:06:27 >>>故障排除日志:终端同步成功后剩余订单列表
2024-07-20 08:06:27 收到下发指令:叫号1>>>
2024-07-20 08:06:36 >>>回调事件[910,devices/TL2180]
2024-07-20 08:06:36 >>>故障排除日志:上一MQTT订单号缓存列表为24072008061708824506
2024-07-20 08:06:36 >>>故障排除日志:终端未同步成功订单列表
2024-07-20 08:06:37 开始打印,排队:2,票券:2407200806281661925301,订单:24072008062816614921,[2024-07-20 08:06:28微信支付10元]
2024-07-20 08:06:39 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407200806281661925301","queue_number":2,"trade_uid":"24072008062816614921"}]}
2024-07-20 08:06:39 >>>故障排除日志:删除未同步下发订单成功24072008062816614921
2024-07-20 08:06:39 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


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


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


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


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


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


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


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


===09:13:18===
2024-07-20 09:12:34 >>>回调事件[910,devices/TL2180]
2024-07-20 09:12:34 >>>故障排除日志:上一MQTT订单号缓存列表为24072009054177733227
2024-07-20 09:12:34 >>>故障排除日志:终端未同步成功订单列表
2024-07-20 09:12:34 开始打印,排队:12,票券:2407200912267314110601,订单:24072009122673134640,[2024-07-20 09:12:26微信支付10元]
2024-07-20 09:12:36 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407200912267314110601","queue_number":12,"trade_uid":"24072009122673134640"}]}
2024-07-20 09:12:36 >>>故障排除日志:删除未同步下发订单成功24072009122673134640
2024-07-20 09:12:36 >>>故障排除日志:终端同步成功后剩余订单列表
2024-07-20 09:12:58>>>cash read=01
2024-07-20 09:12:59>>>cash read=3E
2024-07-20 09:13:01>>>cash read=2F29
2024-07-20 09:13:02>>>cash read=01
2024-07-20 09:13:02>>>cash read=2F
2024-07-20 09:13:03>>>cash read=3E
2024-07-20 09:13:06>>>cash read=00
2024-07-20 09:13:06>>>cash read=818F41
2024-07-20 09:13:06>>>cash write=02
2024-07-20 09:13:07 >>>回调事件130,cash_status,10022,进钞中...read money=5
2024-07-20 09:13:07>>>cash read=10
2024-07-20 09:13:07 >>>回调事件130,5,10023,finish Money=5,进钞完成
2024-07-20 09:13:08>>>cash write=0C
2024-07-20 09:13:08>>>cash read=3E
2024-07-20 09:13:09>>>cash read=00
2024-07-20 09:13:10>>>cash read=818F41
2024-07-20 09:13:10>>>cash write=02
2024-07-20 09:13:10 >>>回调事件130,cash_status,10022,进钞中...read money=5
2024-07-20 09:13:10>>>cash read=10
2024-07-20 09:13:10 >>>回调事件130,5,10023,finish Money=5,进钞完成
2024-07-20 09:13:10 >>>开始打印,排队号为13,订单号为2407200913070021806641
2024-07-20 09:13:11>>>订单2407200913070021806641写入成功,剩余空间为1678500,占用RAM为605.994140625
删除未同步订单2407200913070021806641
2024-07-20 09:13:13>>>订单2407200913070021806641删除成功,剩余空间为1679500,占用RAM为621.08203125
检测订单目录中>>>
无未同步订单>>>
2024-07-20 09:13:13 >>>当前Ram内存为588.96484375
定时检测未同步订单启用
2024-07-20 09:13:14>>>cash write=0C
2024-07-20 09:13:14>>>cash read=3E


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


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


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


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


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


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


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


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


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


===10:09:23===
上一时间戳为1721433984
当日首次设置时间戳true为1721441303
今日nvm排队号为21
当前排队号为21,音量为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:05e88****8baef
纸币器设置接收纸币范围为15
欢迎使用天羚自助售票系统[2.5.1]
定时检测未同步订单启用
2024-07-20 10:08:23>>>cash write=30
2024-07-20 10:08:23>>>cash write=02
2024-07-20 10:08:23>>>cash write=3E
2024-07-20 10:08:23>>>cash read=808F808F808F
系统时间初始化成功，时间为202472010823
2024-07-20 10:08:24>>>cash write=02
2024-07-20 10:08:24 >>>剩余flash空间=1680500,占用RAM为623.9013671875
2024-07-20 10:08:24 >>>回调事件:910,subscribe,10000,连接服务器成功

请求下发消息结果为0,下发成功
2024-07-20 10:08:25 >>>回调事件[910,devices/TL2180]
2024-07-20 10:08:25 >>>故障排除日志:上一MQTT订单号缓存列表为24072009530406431406
2024-07-20 10:08:25 >>>故障排除日志:终端未同步成功订单列表
2024-07-20 10:08:25 开始打印,排队:21,票券:2407201002498671366001,订单:24072010024986709261,[2024-07-20 10:02:49微信支付10元]
2024-07-20 10:08:27 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407201002498671366001","queue_number":21,"trade_uid":"24072010024986709261"}]}
2024-07-20 10:08:27 >>>故障排除日志:删除未同步下发订单成功24072010024986709261
2024-07-20 10:08:27 >>>故障排除日志:终端同步成功后剩余订单列表
流量卡还有315天过期
2024-07-20 10:08:28>>>cash write=0C
2024-07-20 10:08:28>>>cash read=3E
2024-07-20 10:08:31 >>>当前Ram内存为613.755859375


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


===10:15:24===
2024-07-20 10:14:54 >>>回调事件[910,devices/TL2180]
2024-07-20 10:14:54 >>>故障排除日志:上一MQTT订单号缓存列表为24072010024986709261
2024-07-20 10:14:54 >>>故障排除日志:终端未同步成功订单列表
2024-07-20 10:14:54 开始打印,排队:22,票券:2407201014476671346301,订单:24072010144766709763,[2024-07-20 10:14:47微信支付10元]
2024-07-20 10:14:56 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407201014476671346301","queue_number":22,"trade_uid":"24072010144766709763"}]}
2024-07-20 10:14:56 >>>故障排除日志:删除未同步下发订单成功24072010144766709763
2024-07-20 10:14:56 >>>故障排除日志:终端同步成功后剩余订单列表
2024-07-20 10:15:01>>>cash read=00
2024-07-20 10:15:02>>>cash read=818F42
2024-07-20 10:15:02>>>cash write=02
2024-07-20 10:15:02 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-07-20 10:15:02>>>cash read=10
2024-07-20 10:15:02 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-07-20 10:15:02 >>>开始打印,排队号为23,订单号为2407201015020021804603
2024-07-20 10:15:03>>>订单2407201015020021804603写入成功,剩余空间为1679000,占用RAM为603.2587890625
删除未同步订单2407201015020021804603
2024-07-20 10:15:05>>>订单2407201015020021804603删除成功,剩余空间为1680000,占用RAM为617.3193359375
检测订单目录中>>>
无未同步订单>>>
2024-07-20 10:15:05 >>>当前Ram内存为587.40234375
定时检测未同步订单启用
2024-07-20 10:15:06>>>cash write=0C
2024-07-20 10:15:06>>>cash read=3E
2024-07-20 10:15:08>>>cash read=29
2024-07-20 10:15:08 >>>回调事件130,cash_status,20029,退钞中
2024-07-20 10:15:09>>>cash read=3E
2024-07-20 10:15:10>>>cash read=00
2024-07-20 10:15:12>>>cash read=29
2024-07-20 10:15:12 >>>回调事件130,cash_status,20029,退钞中
2024-07-20 10:15:12>>>cash read=2F29
2024-07-20 10:15:13>>>cash read=00
2024-07-20 10:15:14>>>cash read=2F29
2024-07-20 10:15:15>>>cash read=00
2024-07-20 10:15:16>>>cash read=2F29
2024-07-20 10:15:18>>>cash read=00
2024-07-20 10:15:19>>>cash read=2F29
2024-07-20 10:15:20 >>>回调事件130,cash_status,20029,退钞中
2024-07-20 10:15:22>>>cash read=00


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


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


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


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


===10:22:26===
2024-07-20 10:21:46 >>>回调事件[910,devices/TL2180]
2024-07-20 10:21:46 >>>故障排除日志:上一MQTT订单号缓存列表为24072010202362244867
2024-07-20 10:21:46 >>>故障排除日志:终端未同步成功订单列表
2024-07-20 10:21:46 开始打印,排队:27,票券:2407201021343858066001,订单:24072010213438576073,[2024-07-20 10:21:34支付宝支付10元]
2024-07-20 10:21:48 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407201021343858066001","queue_number":27,"trade_uid":"24072010213438576073"}]}
2024-07-20 10:21:48 >>>故障排除日志:删除未同步下发订单成功24072010213438576073
2024-07-20 10:21:48 >>>故障排除日志:终端同步成功后剩余订单列表
2024-07-20 10:22:00 >>>回调事件[910,devices/TL2180]
2024-07-20 10:22:00 >>>故障排除日志:上一MQTT订单号缓存列表为24072010213438576073
2024-07-20 10:22:00 >>>故障排除日志:终端未同步成功订单列表
2024-07-20 10:22:00 开始打印,排队:28,票券:2407201021529176908701,订单:24072010215291765241,[2024-07-20 10:21:52支付宝支付10元]
2024-07-20 10:22:03 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407201021529176908701","queue_number":28,"trade_uid":"24072010215291765241"}]}
2024-07-20 10:22:03 >>>故障排除日志:删除未同步下发订单成功24072010215291765241
2024-07-20 10:22:03 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


===10:36:27===
2024-07-20 10:36:22 >>>回调事件[910,devices/TL2180]
2024-07-20 10:36:22 >>>故障排除日志:上一MQTT订单号缓存列表为24072010243358060953
2024-07-20 10:36:22 >>>故障排除日志:终端未同步成功订单列表
2024-07-20 10:36:22 开始打印,排队:31,票券:2407201036157704610701,订单:24072010361577041079,[2024-07-20 10:36:15微信支付10元]
2024-07-20 10:36:22 开始打印,排队:32,票券:2407201036157704827102,订单:24072010361577041079,[2024-07-20 10:36:15微信支付10元]


===10:37:27===
2024-07-20 10:36:26 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407201036157704610701","queue_number":31,"trade_uid":"24072010361577041079"},{"ticket_no":"2407201036157704827102","queue_number":32,"trade_uid":"24072010361577041079"}]}
2024-07-20 10:36:26 >>>故障排除日志:删除未同步下发订单成功24072010361577041079
2024-07-20 10:36:26 >>>故障排除日志:删除未同步下发订单成功24072010361577041079
2024-07-20 10:36:26 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


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


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


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


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


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


===11:30:31===
2024-07-20 11:29:44 >>>回调事件[910,devices/TL2180]
2024-07-20 11:29:44 >>>故障排除日志:上一MQTT订单号缓存列表为24072011204232168043
2024-07-20 11:29:44 >>>故障排除日志:终端未同步成功订单列表
2024-07-20 11:29:44 开始打印,排队:43,票券:2407201129349508332901,订单:24072011293495078995,[2024-07-20 11:29:34微信支付10元]
2024-07-20 11:29:44 开始打印,排队:44,票券:2407201129349508487102,订单:24072011293495078995,[2024-07-20 11:29:34微信支付10元]
2024-07-20 11:29:47 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407201129349508332901","queue_number":43,"trade_uid":"24072011293495078995"},{"ticket_no":"2407201129349508487102","queue_number":44,"trade_uid":"24072011293495078995"}]}
2024-07-20 11:29:47 >>>故障排除日志:删除未同步下发订单成功24072011293495078995
2024-07-20 11:29:47 >>>故障排除日志:删除未同步下发订单成功24072011293495078995
2024-07-20 11:29:48 >>>故障排除日志:终端同步成功后剩余订单列表
2024-07-20 11:30:20 >>>回调事件[910,devices/TL2180]
2024-07-20 11:30:20 >>>故障排除日志:上一MQTT订单号缓存列表为24072011293495078995|24072011293495078995
2024-07-20 11:30:20 >>>故障排除日志:终端未同步成功订单列表
2024-07-20 11:30:20 开始打印,排队:45,票券:2407201130152049918501,订单:24072011301520494494,[2024-07-20 11:30:15微信支付10元]
2024-07-20 11:30:22 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407201130152049918501","queue_number":45,"trade_uid":"24072011301520494494"}]}
2024-07-20 11:30:22 >>>故障排除日志:删除未同步下发订单成功24072011301520494494
2024-07-20 11:30:22 >>>故障排除日志:终端同步成功后剩余订单列表


===11:31:31===
2024-07-20 11:30:44 >>>回调事件[910,devices/TL2180]
2024-07-20 11:30:44 >>>故障排除日志:上一MQTT订单号缓存列表为24072011301520494494
2024-07-20 11:30:44 >>>故障排除日志:终端未同步成功订单列表
2024-07-20 11:30:44 开始打印,排队:46,票券:2407201130380266836001,订单:24072011303802663036,[2024-07-20 11:30:38微信支付10元]
2024-07-20 11:30:46>>>cash read=818F42
2024-07-20 11:30:46>>>cash write=02
2024-07-20 11:30:46 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-07-20 11:30:47>>>cash read=10
2024-07-20 11:30:47 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-07-20 11:30:47 >>>开始打印,排队号为47,订单号为2407201130470021801274
2024-07-20 11:30:47>>>订单2407201130470021801274写入成功,剩余空间为1679500,占用RAM为610.55078125
2024-07-20 11:30:49 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407201130380266836001","queue_number":46,"trade_uid":"24072011303802663036"}]}
2024-07-20 11:30:49 >>>故障排除日志:删除未同步下发订单成功24072011303802663036
2024-07-20 11:30:49 >>>故障排除日志:终端同步成功后剩余订单列表
删除未同步订单2407201130470021801274
2024-07-20 11:30:49>>>订单2407201130470021801274删除成功,剩余空间为1680000,占用RAM为606.0966796875
检测订单目录中>>>
无未同步订单>>>
2024-07-20 11:30:49 >>>当前Ram内存为586.9970703125
定时检测未同步订单启用
2024-07-20 11:30:50>>>cash write=0C
2024-07-20 11:30:50>>>cash read=3E


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


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


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


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


===12:25:35===
2024-07-20 12:25:31 >>>回调事件[910,devices/TL2180]
2024-07-20 12:25:31 >>>故障排除日志:上一MQTT订单号缓存列表为24072012111160873293
2024-07-20 12:25:31 >>>故障排除日志:终端未同步成功订单列表
2024-07-20 12:25:31 开始打印,排队:52,票券:2407201225242068777401,订单:24072012252420682171,[2024-07-20 12:25:24微信支付10元]


===12:27:35===
2024-07-20 12:26:36>>>cash read=00
2024-07-20 12:26:36>>>cash read=818F42
2024-07-20 12:26:36>>>cash write=02
2024-07-20 12:26:36 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-07-20 12:26:37>>>cash read=10
2024-07-20 12:26:37 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-07-20 12:26:37 >>>开始打印,排队号为53,订单号为2407201226370021801319
2024-07-20 12:26:37>>>订单2407201226370021801319写入成功,剩余空间为1680500,占用RAM为600.7197265625
删除未同步订单2407201226370021801319
2024-07-20 12:26:39>>>订单2407201226370021801319删除成功,剩余空间为1680500,占用RAM为616.40625
检测订单目录中>>>
无未同步订单>>>
2024-07-20 12:26:39 >>>当前Ram内存为586.08203125
定时检测未同步订单启用
2024-07-20 12:26:40>>>cash write=0C
2024-07-20 12:26:40>>>cash read=3E
2024-07-20 12:26:46>>>cash read=00
2024-07-20 12:26:47>>>cash read=29
2024-07-20 12:26:47 >>>回调事件130,cash_status,20029,退钞中
2024-07-20 12:26:47>>>cash read=2F29
2024-07-20 12:26:49>>>cash read=3E
2024-07-20 12:26:53>>>cash read=00
2024-07-20 12:26:54>>>cash read=818F42
2024-07-20 12:26:54>>>cash write=02
2024-07-20 12:26:54 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-07-20 12:26:54>>>cash read=10
2024-07-20 12:26:54 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-07-20 12:26:54 >>>开始打印,排队号为54,订单号为2407201226540021809205
定时检测未同步订单关闭
2024-07-20 12:26:55>>>订单2407201226540021809205写入成功,剩余空间为1678500,占用RAM为606.4130859375
删除未同步订单2407201226540021809205
2024-07-20 12:26:57>>>订单2407201226540021809205删除成功,剩余空间为1679500,占用RAM为618.369140625
检测订单目录中>>>
无未同步订单>>>
2024-07-20 12:26:57 >>>当前Ram内存为587.744140625
定时检测未同步订单启用
2024-07-20 12:26:58>>>cash write=0C
2024-07-20 12:26:58>>>cash read=3E
2024-07-20 12:27:21>>>cash read=00
2024-07-20 12:27:21>>>cash read=818F42
2024-07-20 12:27:21>>>cash write=02
2024-07-20 12:27:21 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-07-20 12:27:22>>>cash read=10
2024-07-20 12:27:22 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-07-20 12:27:22 >>>开始打印,排队号为55,订单号为2407201227220021805262
定时检测未同步订单关闭
2024-07-20 12:27:22>>>订单2407201227220021805262写入成功,剩余空间为1678000,占用RAM为613.0927734375
删除未同步订单2407201227220021805262
2024-07-20 12:27:25>>>订单2407201227220021805262删除成功,剩余空间为1678500,占用RAM为622.5205078125
检测订单目录中>>>
无未同步订单>>>
2024-07-20 12:27:25 >>>当前Ram内存为588.6162109375
定时检测未同步订单启用
2024-07-20 12:27:25>>>cash write=0C
2024-07-20 12:27:26>>>cash read=3E


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


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


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


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


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


===13:32:37===
2024-07-20 13:32:15>>>cash read=00
2024-07-20 13:32:16>>>cash read=818F4200
2024-07-20 13:32:16>>>cash write=02
2024-07-20 13:32:16 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-07-20 13:32:17>>>cash read=10
2024-07-20 13:32:17 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-07-20 13:32:17 >>>开始打印,排队号为61,订单号为2407201332170021805565
2024-07-20 13:32:17>>>订单2407201332170021805565写入成功,剩余空间为1680500,占用RAM为601.580078125
删除未同步订单2407201332170021805565
2024-07-20 13:32:19>>>订单2407201332170021805565删除成功,剩余空间为1680500,占用RAM为618.2802734375
检测订单目录中>>>
无未同步订单>>>
2024-07-20 13:32:20 >>>当前Ram内存为586.9072265625
定时检测未同步订单启用
2024-07-20 13:32:20>>>cash write=0C
2024-07-20 13:32:20>>>cash read=3E
2024-07-20 13:32:23>>>cash read=00
2024-07-20 13:32:24>>>cash read=818F42
2024-07-20 13:32:24>>>cash write=02
2024-07-20 13:32:24 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-07-20 13:32:24>>>cash read=10
2024-07-20 13:32:24 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-07-20 13:32:24 >>>开始打印,排队号为62,订单号为2407201332240021803074
定时检测未同步订单关闭
2024-07-20 13:32:24>>>订单2407201332240021803074写入成功,剩余空间为1679000,占用RAM为607.08984375
删除未同步订单2407201332240021803074
2024-07-20 13:32:27>>>订单2407201332240021803074删除成功,剩余空间为1680000,占用RAM为600.09765625
检测订单目录中>>>
无未同步订单>>>
2024-07-20 13:32:27 >>>当前Ram内存为588.814453125
定时检测未同步订单启用
2024-07-20 13:32:28>>>cash write=0C
2024-07-20 13:32:28>>>cash read=3E


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


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


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


===13:46:39===
2024-07-20 13:45:52>>>cash read=00
2024-07-20 13:45:52>>>cash read=818F42
2024-07-20 13:45:52>>>cash write=02
2024-07-20 13:45:52 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-07-20 13:45:53>>>cash read=10
2024-07-20 13:45:53 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-07-20 13:45:53 >>>开始打印,排队号为66,订单号为2407201345530021804516
2024-07-20 13:45:53>>>订单2407201345530021804516写入成功,剩余空间为1680500,占用RAM为600.630859375
删除未同步订单2407201345530021804516
2024-07-20 13:45:55>>>订单2407201345530021804516删除成功,剩余空间为1680500,占用RAM为614.99609375
检测订单目录中>>>
无未同步订单>>>
2024-07-20 13:45:55 >>>当前Ram内存为586.1181640625
定时检测未同步订单启用
2024-07-20 13:45:56>>>cash write=0C
2024-07-20 13:45:56>>>cash read=3E


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


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


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


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


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


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


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


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


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


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


===14:43:43===
2024-07-20 14:43:39 >>>回调事件[910,devices/TL2180]
2024-07-20 14:43:39 >>>故障排除日志:上一MQTT订单号缓存列表为24072014374711981710
2024-07-20 14:43:39 >>>故障排除日志:终端未同步成功订单列表
2024-07-20 14:43:39 开始打印,排队:74,票券:2407201443302405831801,订单:24072014433024055012,[2024-07-20 14:43:30微信支付10元]


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


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


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


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


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


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


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


===15:11:47===
2024-07-20 15:11:43>>>cash read=00
2024-07-20 15:11:43>>>cash read=818F42
2024-07-20 15:11:43>>>cash write=02
2024-07-20 15:11:43 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-07-20 15:11:44>>>cash read=10
2024-07-20 15:11:44 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-07-20 15:11:44 >>>开始打印,排队号为81,订单号为2407201511440021806131
2024-07-20 15:11:44>>>订单2407201511440021806131写入成功,剩余空间为1680500,占用RAM为601.5634765625


===15:12:47===
删除未同步订单2407201511440021806131
2024-07-20 15:11:46>>>订单2407201511440021806131删除成功,剩余空间为1681500,占用RAM为620.771484375
检测订单目录中>>>
无未同步订单>>>
2024-07-20 15:11:46 >>>当前Ram内存为586.578125
定时检测未同步订单启用
2024-07-20 15:11:47>>>cash write=0C
2024-07-20 15:11:47>>>cash read=3E


===15:14:48===
2024-07-20 15:14:31>>>cash read=00
2024-07-20 15:14:32>>>cash read=2F29
2024-07-20 15:14:33>>>cash read=00
2024-07-20 15:14:34>>>cash read=29
2024-07-20 15:14:34 >>>回调事件130,cash_status,20029,退钞中
2024-07-20 15:14:35>>>cash read=2F29
2024-07-20 15:14:36>>>cash read=3E
2024-07-20 15:14:38>>>cash read=00
2024-07-20 15:14:40>>>cash read=2F29
2024-07-20 15:14:41>>>cash read=3E
2024-07-20 15:14:46>>>cash read=00


===15:15:48===
2024-07-20 15:14:48>>>cash read=2F29
2024-07-20 15:14:49>>>cash read=3E
2024-07-20 15:14:50>>>cash read=29
2024-07-20 15:14:50 >>>回调事件130,cash_status,20029,退钞中
2024-07-20 15:14:50>>>cash read=2F29
2024-07-20 15:14:51>>>cash read=01
2024-07-20 15:14:53>>>cash read=2F
2024-07-20 15:14:54>>>cash read=3E
2024-07-20 15:15:01>>>cash read=00
2024-07-20 15:15:02>>>cash read=2F29
2024-07-20 15:15:03>>>cash read=3E
2024-07-20 15:15:32>>>cash read=00
2024-07-20 15:15:34>>>cash read=3E
2024-07-20 15:15:35>>>cash read=00
2024-07-20 15:15:35>>>cash read=818F42
2024-07-20 15:15:35>>>cash write=02
2024-07-20 15:15:35 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-07-20 15:15:35>>>cash read=10
2024-07-20 15:15:35 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-07-20 15:15:35 >>>开始打印,排队号为82,订单号为2407201515350021808133
2024-07-20 15:15:36>>>订单2407201515350021808133写入成功,剩余空间为1679500,占用RAM为603.9990234375
删除未同步订单2407201515350021808133
2024-07-20 15:15:38>>>订单2407201515350021808133删除成功,剩余空间为1680000,占用RAM为607.6748046875
检测订单目录中>>>
无未同步订单>>>
2024-07-20 15:15:38 >>>当前Ram内存为587.3544921875
定时检测未同步订单启用
2024-07-20 15:15:39>>>cash write=0C
2024-07-20 15:15:39>>>cash read=3E


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


===16:29:53===
2024-07-20 16:29:12 >>>回调事件[910,devices/TL2180]
2024-07-20 16:29:12 >>>故障排除日志:上一MQTT订单号缓存列表为24072016262480166724
2024-07-20 16:29:12 >>>故障排除日志:终端未同步成功订单列表
2024-07-20 16:29:12 开始打印,排队:98,票券:2407201629045315565401,订单:24072016290453151285,[2024-07-20 16:29:04微信支付10元]
2024-07-20 16:29:14 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407201629045315565401","queue_number":98,"trade_uid":"24072016290453151285"}]}
2024-07-20 16:29:14 >>>故障排除日志:删除未同步下发订单成功24072016290453151285
2024-07-20 16:29:14 >>>故障排除日志:终端同步成功后剩余订单列表
2024-07-20 16:29:38 >>>回调事件[910,devices/TL2180]
2024-07-20 16:29:38 >>>故障排除日志:上一MQTT订单号缓存列表为24072016290453151285
2024-07-20 16:29:38 >>>故障排除日志:终端未同步成功订单列表
2024-07-20 16:29:38 开始打印,排队:99,票券:2407201629321785461001,订单:24072016293217849112,[2024-07-20 16:29:32微信支付10元]
2024-07-20 16:29:40 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407201629321785461001","queue_number":99,"trade_uid":"24072016293217849112"}]}
2024-07-20 16:29:41 >>>故障排除日志:删除未同步下发订单成功24072016293217849112
2024-07-20 16:29:41 >>>故障排除日志:终端同步成功后剩余订单列表


===16:36:54===
2024-07-20 16:36:52>>>cash read=00
2024-07-20 16:36:52>>>cash read=818F42
2024-07-20 16:36:52>>>cash write=02
2024-07-20 16:36:52 >>>回调事件130,cash_status,10022,进钞中...read money=10


===16:37:56===
删除未同步订单2407201636530021802957
2024-07-20 16:36:55>>>订单2407201636530021802957删除成功,剩余空间为1681500,占用RAM为620.365234375
检测订单目录中>>>
无未同步订单>>>
2024-07-20 16:36:55 >>>当前Ram内存为586.650390625
定时检测未同步订单启用
2024-07-20 16:36:56>>>cash write=0C
2024-07-20 16:36:56>>>cash read=3E


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


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


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


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


===17:01:58===
2024-07-20 17:01:08 >>>回调事件[910,devices/TL2180]
2024-07-20 17:01:08 >>>故障排除日志:上一MQTT订单号缓存列表为24072016595878450882
2024-07-20 17:01:08 >>>故障排除日志:终端未同步成功订单列表
2024-07-20 17:01:08 开始打印,排队:104,票券:2407201700581650619701,订单:24072017005816502739,[2024-07-20 17:00:58支付宝支付10元]
2024-07-20 17:01:10 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407201700581650619701","queue_number":104,"trade_uid":"24072017005816502739"}]}
2024-07-20 17:01:10 >>>故障排除日志:删除未同步下发订单成功24072017005816502739
2024-07-20 17:01:10 >>>故障排除日志:终端同步成功后剩余订单列表
2024-07-20 17:01:54 >>>回调事件[910,devices/TL2180]
2024-07-20 17:01:54 >>>故障排除日志:上一MQTT订单号缓存列表为24072017005816502739
2024-07-20 17:01:54 >>>故障排除日志:终端未同步成功订单列表
2024-07-20 17:01:54 开始打印,排队:105,票券:2407201701467173161401,订单:24072017014671727208,[2024-07-20 17:01:46微信支付10元]
2024-07-20 17:01:56 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407201701467173161401","queue_number":105,"trade_uid":"24072017014671727208"}]}
2024-07-20 17:01:56 >>>故障排除日志:删除未同步下发订单成功24072017014671727208
2024-07-20 17:01:57 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


===17:30:00===
2024-07-20 17:29:14 >>>回调事件[910,devices/TL2180]
2024-07-20 17:29:14 >>>故障排除日志:上一MQTT订单号缓存列表为24072017280731585284
2024-07-20 17:29:14 >>>故障排除日志:终端未同步成功订单列表
2024-07-20 17:29:14 开始打印,排队:110,票券:2407201729052552450801,订单:24072017290525520993,[2024-07-20 17:29:05微信支付10元]
2024-07-20 17:29:14 开始打印,排队:111,票券:2407201729052552590802,订单:24072017290525520993,[2024-07-20 17:29:05微信支付10元]
2024-07-20 17:29:18 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407201729052552450801","queue_number":110,"trade_uid":"24072017290525520993"},{"ticket_no":"2407201729052552590802","queue_number":111,"trade_uid":"24072017290525520993"}]}
2024-07-20 17:29:18 >>>故障排除日志:删除未同步下发订单成功24072017290525520993
2024-07-20 17:29:18 >>>故障排除日志:删除未同步下发订单成功24072017290525520993
2024-07-20 17:29:18 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


===17:57:01===
2024-07-20 17:56:43 >>>回调事件[910,devices/TL2180]
2024-07-20 17:56:43 >>>故障排除日志:上一MQTT订单号缓存列表为24072017470907487491|24072017470907487491
2024-07-20 17:56:43 >>>故障排除日志:终端未同步成功订单列表
2024-07-20 17:56:43 开始打印,排队:117,票券:2407201756373325965201,订单:24072017563733254316,[2024-07-20 17:56:37支付宝支付10元]
2024-07-20 17:56:45 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407201756373325965201","queue_number":117,"trade_uid":"24072017563733254316"}]}
2024-07-20 17:56:45 >>>故障排除日志:删除未同步下发订单成功24072017563733254316
2024-07-20 17:56:45 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


===18:15:02===
2024-07-20 18:14:32>>>cash read=00
2024-07-20 18:14:32>>>cash read=818F42
2024-07-20 18:14:32>>>cash write=02
2024-07-20 18:14:32 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-07-20 18:14:33>>>cash read=10
2024-07-20 18:14:33 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-07-20 18:14:33 >>>开始打印,排队号为121,订单号为2407201814330021807032
2024-07-20 18:14:33>>>订单2407201814330021807032写入成功,剩余空间为1680500,占用RAM为601.6328125
删除未同步订单2407201814330021807032
2024-07-20 18:14:35>>>订单2407201814330021807032删除成功,剩余空间为1680500,占用RAM为615.8662109375
检测订单目录中>>>
无未同步订单>>>
2024-07-20 18:14:36 >>>当前Ram内存为586.97265625
定时检测未同步订单启用
2024-07-20 18:14:36>>>cash write=0C
2024-07-20 18:14:36>>>cash read=3E


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


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


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


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


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


===18:36:04===
2024-07-20 18:35:47>>>cash read=29
2024-07-20 18:35:47 >>>回调事件130,cash_status,20029,退钞中
2024-07-20 18:35:48>>>cash read=2F29
2024-07-20 18:35:49>>>cash read=01
2024-07-20 18:35:53>>>cash read=2F
2024-07-20 18:35:54>>>cash read=29
2024-07-20 18:35:54 >>>回调事件130,cash_status,20029,退钞中
2024-07-20 18:35:55>>>cash read=3E
2024-07-20 18:35:59>>>cash read=29
2024-07-20 18:35:59 >>>回调事件130,cash_status,20029,退钞中
2024-07-20 18:36:00>>>cash read=01


===18:37:04===
2024-07-20 18:36:03>>>cash read=3E
2024-07-20 18:36:07>>>cash read=00
2024-07-20 18:36:08>>>cash read=818F42
2024-07-20 18:36:08>>>cash write=02
2024-07-20 18:36:08 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-07-20 18:36:08>>>cash read=10
2024-07-20 18:36:08 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-07-20 18:36:08 >>>开始打印,排队号为126,订单号为2407201836080021805896
2024-07-20 18:36:09>>>订单2407201836080021805896写入成功,剩余空间为1680000,占用RAM为601.7333984375
删除未同步订单2407201836080021805896
2024-07-20 18:36:11>>>订单2407201836080021805896删除成功,剩余空间为1680500,占用RAM为590.251953125
检测订单目录中>>>
无未同步订单>>>
2024-07-20 18:36:11 >>>当前Ram内存为586.814453125
定时检测未同步订单启用
2024-07-20 18:36:12>>>cash write=0C
2024-07-20 18:36:12>>>cash read=3E
2024-07-20 18:36:18>>>cash read=29
2024-07-20 18:36:18 >>>回调事件130,cash_status,20029,退钞中
2024-07-20 18:36:20>>>cash read=01
2024-07-20 18:36:24>>>cash read=3E
2024-07-20 18:36:25>>>cash read=29
2024-07-20 18:36:25 >>>回调事件130,cash_status,20029,退钞中
2024-07-20 18:36:26>>>cash read=01
2024-07-20 18:36:48>>>cash read=3E
2024-07-20 18:36:56>>>cash read=00
2024-07-20 18:36:57>>>cash read=818F42
2024-07-20 18:36:57>>>cash write=02
2024-07-20 18:36:57 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-07-20 18:36:57>>>cash read=10
2024-07-20 18:36:57 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-07-20 18:36:58 >>>开始打印,排队号为127,订单号为2407201836580021809789
定时检测未同步订单关闭
2024-07-20 18:36:58>>>订单2407201836580021809789写入成功,剩余空间为1678500,占用RAM为609.041015625
删除未同步订单2407201836580021809789
2024-07-20 18:37:00>>>订单2407201836580021809789删除成功,剩余空间为1679500,占用RAM为620.48046875
检测订单目录中>>>
无未同步订单>>>
2024-07-20 18:37:00 >>>当前Ram内存为587.88671875
定时检测未同步订单启用
2024-07-20 18:37:01>>>cash write=0C
2024-07-20 18:37:01>>>cash read=3E


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


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


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


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


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


===19:06:06===
2024-07-20 19:05:22 >>>回调事件[910,devices/TL2180]
2024-07-20 19:05:22 >>>故障排除日志:上一MQTT订单号缓存列表为24072018585484138671
2024-07-20 19:05:22 >>>故障排除日志:终端未同步成功订单列表
2024-07-20 19:05:22 开始打印,排队:134,票券:2407201905153579629701,订单:24072019051535792582,[2024-07-20 19:05:15微信支付10元]
2024-07-20 19:05:25 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407201905153579629701","queue_number":134,"trade_uid":"24072019051535792582"}]}
2024-07-20 19:05:25 >>>故障排除日志:删除未同步下发订单成功24072019051535792582
2024-07-20 19:05:25 >>>故障排除日志:终端同步成功后剩余订单列表
2024-07-20 19:05:37>>>cash read=00
2024-07-20 19:05:38>>>cash read=818F42
2024-07-20 19:05:38>>>cash write=02
2024-07-20 19:05:38 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-07-20 19:05:38>>>cash read=10
2024-07-20 19:05:38 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-07-20 19:05:38 >>>开始打印,排队号为135,订单号为2407201905380021807540
2024-07-20 19:05:39>>>订单2407201905380021807540写入成功,剩余空间为1679000,占用RAM为604.09375
删除未同步订单2407201905380021807540
2024-07-20 19:05:41>>>订单2407201905380021807540删除成功,剩余空间为1680000,占用RAM为618.1748046875
检测订单目录中>>>
无未同步订单>>>
2024-07-20 19:05:41 >>>当前Ram内存为586.638671875
定时检测未同步订单启用
2024-07-20 19:05:42>>>cash write=0C
2024-07-20 19:05:42>>>cash read=3E


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


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


===19:11:07===
2024-07-20 19:10:13 >>>回调事件[910,devices/TL2180]
2024-07-20 19:10:13 >>>故障排除日志:上一MQTT订单号缓存列表为24072019091875459582
2024-07-20 19:10:13 >>>故障排除日志:终端未同步成功订单列表
2024-07-20 19:10:13 开始打印,排队:137,票券:2407201910087388711501,订单:24072019100873881976,[2024-07-20 19:10:08支付宝支付10元]
2024-07-20 19:10:15 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407201910087388711501","queue_number":137,"trade_uid":"24072019100873881976"}]}
2024-07-20 19:10:15 >>>故障排除日志:删除未同步下发订单成功24072019100873881976
2024-07-20 19:10:16 >>>故障排除日志:终端同步成功后剩余订单列表
2024-07-20 19:10:26 >>>回调事件[910,devices/TL2180]
2024-07-20 19:10:26 >>>故障排除日志:上一MQTT订单号缓存列表为24072019100873881976
2024-07-20 19:10:26 >>>故障排除日志:终端未同步成功订单列表
2024-07-20 19:10:26 开始打印,排队:138,票券:2407201910189762063401,订单:24072019101897613656,[2024-07-20 19:10:18支付宝支付10元]
2024-07-20 19:10:26 开始打印,排队:139,票券:2407201910189762226502,订单:24072019101897613656,[2024-07-20 19:10:18支付宝支付10元]
2024-07-20 19:10:30 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407201910189762063401","queue_number":138,"trade_uid":"24072019101897613656"},{"ticket_no":"2407201910189762226502","queue_number":139,"trade_uid":"24072019101897613656"}]}
2024-07-20 19:10:30 >>>故障排除日志:删除未同步下发订单成功24072019101897613656
2024-07-20 19:10:30 >>>故障排除日志:删除未同步下发订单成功24072019101897613656
2024-07-20 19:10:30 >>>故障排除日志:终端同步成功后剩余订单列表


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


===19:13:08===
2024-07-20 19:13:05 >>>回调事件[910,devices/TL2180]
2024-07-20 19:13:05 >>>故障排除日志:上一MQTT订单号缓存列表为24072019110985787167|24072019110985787167
2024-07-20 19:13:05 >>>故障排除日志:终端未同步成功订单列表
2024-07-20 19:13:05 开始打印,排队:142,票券:2407201912591001516101,订单:24072019125910011607,[2024-07-20 19:12:59微信支付10元]


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


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


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


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


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


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


===19:27:11===
2024-07-20 19:26:49 >>>回调事件[910,devices/TL2180]
2024-07-20 19:26:49 >>>故障排除日志:上一MQTT订单号缓存列表为24072019225875590772
2024-07-20 19:26:49 >>>故障排除日志:终端未同步成功订单列表
2024-07-20 19:26:49 开始打印,排队:148,票券:2407201926406008980401,订单:24072019264060086589,[2024-07-20 19:26:40支付宝支付10元]
2024-07-20 19:26:51 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407201926406008980401","queue_number":148,"trade_uid":"24072019264060086589"}]}
2024-07-20 19:26:51 >>>故障排除日志:删除未同步下发订单成功24072019264060086589
2024-07-20 19:26:52 >>>故障排除日志:终端同步成功后剩余订单列表


===19:31:12===
2024-07-20 19:31:08 >>>回调事件[910,devices/TL2180]
2024-07-20 19:31:08 >>>故障排除日志:上一MQTT订单号缓存列表为24072019264060086589
2024-07-20 19:31:08 >>>故障排除日志:终端未同步成功订单列表
2024-07-20 19:31:08 开始打印,排队:149,票券:2407201931013889455701,订单:24072019310138889051,[2024-07-20 19:31:01微信支付10元]


===19:32:12===
2024-07-20 19:31:10 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407201931013889455701","queue_number":149,"trade_uid":"24072019310138889051"}]}
2024-07-20 19:31:10 >>>故障排除日志:删除未同步下发订单成功24072019310138889051
2024-07-20 19:31:10 >>>故障排除日志:终端同步成功后剩余订单列表
2024-07-20 19:31:19 >>>回调事件[910,devices/TL2180]
2024-07-20 19:31:19 >>>故障排除日志:上一MQTT订单号缓存列表为24072019310138889051
2024-07-20 19:31:19 >>>故障排除日志:终端未同步成功订单列表
2024-07-20 19:31:19 开始打印,排队:150,票券:2407201931100360128101,订单:24072019311003595234,[2024-07-20 19:31:10微信支付10元]
2024-07-20 19:31:22 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407201931100360128101","queue_number":150,"trade_uid":"24072019311003595234"}]}
2024-07-20 19:31:22 >>>故障排除日志:删除未同步下发订单成功24072019311003595234
2024-07-20 19:31:22 >>>故障排除日志:终端同步成功后剩余订单列表
2024-07-20 19:31:56 >>>回调事件[910,devices/TL2180]
2024-07-20 19:31:56 >>>故障排除日志:上一MQTT订单号缓存列表为24072019311003595234
2024-07-20 19:31:56 >>>故障排除日志:终端未同步成功订单列表
2024-07-20 19:31:56 开始打印,排队:151,票券:2407201931479381158401,订单:24072019314793807293,[2024-07-20 19:31:47微信支付10元]
2024-07-20 19:31:58 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407201931479381158401","queue_number":151,"trade_uid":"24072019314793807293"}]}
2024-07-20 19:31:58 >>>故障排除日志:删除未同步下发订单成功24072019314793807293
2024-07-20 19:31:58 >>>故障排除日志:终端同步成功后剩余订单列表


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


===19:36:13===
2024-07-20 19:35:24 >>>回调事件[910,devices/TL2180]
2024-07-20 19:35:24 >>>故障排除日志:上一MQTT订单号缓存列表为24072019323145046626
2024-07-20 19:35:24 >>>故障排除日志:终端未同步成功订单列表
2024-07-20 19:35:25 开始打印,排队:153,票券:2407201935175992380801,订单:24072019351759920604,[2024-07-20 19:35:17微信支付10元]
2024-07-20 19:35:27 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407201935175992380801","queue_number":153,"trade_uid":"24072019351759920604"}]}
2024-07-20 19:35:27 >>>故障排除日志:删除未同步下发订单成功24072019351759920604
2024-07-20 19:35:27 >>>故障排除日志:终端同步成功后剩余订单列表
2024-07-20 19:35:39 >>>回调事件[910,devices/TL2180]
2024-07-20 19:35:39 >>>故障排除日志:上一MQTT订单号缓存列表为24072019351759920604
2024-07-20 19:35:39 >>>故障排除日志:终端未同步成功订单列表
2024-07-20 19:35:39 开始打印,排队:154,票券:2407201935332168584801,订单:24072019353321679362,[2024-07-20 19:35:33微信支付10元]
2024-07-20 19:35:41 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407201935332168584801","queue_number":154,"trade_uid":"24072019353321679362"}]}
2024-07-20 19:35:41 >>>故障排除日志:删除未同步下发订单成功24072019353321679362
2024-07-20 19:35:41 >>>故障排除日志:终端同步成功后剩余订单列表


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


===19:45:14===
2024-07-20 19:44:21 >>>回调事件[910,devices/TL2180]
2024-07-20 19:44:22 >>>故障排除日志:上一MQTT订单号缓存列表为24072019383074073501
2024-07-20 19:44:22 >>>故障排除日志:终端未同步成功订单列表
2024-07-20 19:44:22 开始打印,排队:156,票券:2407201944142573819601,订单:24072019441425734560,[2024-07-20 19:44:14微信支付10元]
2024-07-20 19:44:24 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407201944142573819601","queue_number":156,"trade_uid":"24072019441425734560"}]}
2024-07-20 19:44:24 >>>故障排除日志:删除未同步下发订单成功24072019441425734560
2024-07-20 19:44:24 >>>故障排除日志:终端同步成功后剩余订单列表
2024-07-20 19:44:43 >>>回调事件[910,devices/TL2180]
2024-07-20 19:44:43 >>>故障排除日志:上一MQTT订单号缓存列表为24072019441425734560
2024-07-20 19:44:43 >>>故障排除日志:终端未同步成功订单列表
2024-07-20 19:44:43 开始打印,排队:157,票券:2407201944345193038201,订单:24072019443451925956,[2024-07-20 19:44:34微信支付10元]
2024-07-20 19:44:43 开始打印,排队:158,票券:2407201944345193175002,订单:24072019443451925956,[2024-07-20 19:44:34微信支付10元]
2024-07-20 19:44:47 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407201944345193038201","queue_number":157,"trade_uid":"24072019443451925956"},{"ticket_no":"2407201944345193175002","queue_number":158,"trade_uid":"24072019443451925956"}]}
2024-07-20 19:44:47 >>>故障排除日志:删除未同步下发订单成功24072019443451925956
2024-07-20 19:44:47 >>>故障排除日志:删除未同步下发订单成功24072019443451925956
2024-07-20 19:44:47 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


===19:53:19===
2024-07-20 19:52:27>>>cash read=0A
2024-07-20 19:52:28>>>cash read=3E


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


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


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


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


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


===20:05:21===
2024-07-20 20:04:25 >>>回调事件[910,devices/TL2180]
2024-07-20 20:04:25 >>>故障排除日志:上一MQTT订单号缓存列表为24072020024937721885
2024-07-20 20:04:25 >>>故障排除日志:终端未同步成功订单列表
2024-07-20 20:04:25 开始打印,排队:167,票券:2407202004185331983201,订单:24072020041853312135,[2024-07-20 20:04:18微信支付10元]
2024-07-20 20:04:27 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2407202004185331983201","queue_number":167,"trade_uid":"24072020041853312135"}]}
2024-07-20 20:04:27 >>>故障排除日志:删除未同步下发订单成功24072020041853312135
2024-07-20 20:04:27 >>>故障排除日志:终端同步成功后剩余订单列表
2024-07-20 20:04:33>>>cash read=00
2024-07-20 20:04:34>>>cash read=01
2024-07-20 20:04:38>>>cash read=3E
2024-07-20 20:04:48>>>cash read=00
2024-07-20 20:04:50>>>cash read=818F42
2024-07-20 20:04:50>>>cash write=02
2024-07-20 20:04:50 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-07-20 20:04:50>>>cash read=10
2024-07-20 20:04:50 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-07-20 20:04:50 >>>开始打印,排队号为168,订单号为2407202004500021803770
2024-07-20 20:04:50>>>订单2407202004500021803770写入成功,剩余空间为1679000,占用RAM为603.673828125
删除未同步订单2407202004500021803770
2024-07-20 20:04:53>>>订单2407202004500021803770删除成功,剩余空间为1680000,占用RAM为617.716796875
检测订单目录中>>>
无未同步订单>>>
2024-07-20 20:04:53 >>>当前Ram内存为585.8623046875
定时检测未同步订单启用
2024-07-20 20:04:54>>>cash write=0C
2024-07-20 20:04:54>>>cash read=3E
2024-07-20 20:05:03>>>cash read=00
2024-07-20 20:05:04>>>cash read=818F42
2024-07-20 20:05:04>>>cash write=02
2024-07-20 20:05:04 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-07-20 20:05:04>>>cash read=10
2024-07-20 20:05:04 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-07-20 20:05:04 >>>开始打印,排队号为169,订单号为2407202005040021803307
定时检测未同步订单关闭
2024-07-20 20:05:05>>>订单2407202005040021803307写入成功,剩余空间为1678000,占用RAM为611.271484375
删除未同步订单2407202005040021803307
2024-07-20 20:05:07>>>订单2407202005040021803307删除成功,剩余空间为1679000,占用RAM为622.6201171875
检测订单目录中>>>
无未同步订单>>>
2024-07-20 20:05:07 >>>当前Ram内存为586.1416015625
定时检测未同步订单启用
2024-07-20 20:05:08>>>cash write=0C
2024-07-20 20:05:08>>>cash read=3E


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


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


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


===20:12:22===
2024-07-20 20:11:44>>>cash read=29
2024-07-20 20:11:44 >>>回调事件130,cash_status,20029,退钞中
2024-07-20 20:11:46>>>cash read=01
2024-07-20 20:11:48>>>cash read=3E
2024-07-20 20:11:50>>>cash read=00
2024-07-20 20:11:51>>>cash read=818F42
2024-07-20 20:11:51>>>cash write=02
2024-07-20 20:11:51 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-07-20 20:11:51>>>cash read=10
2024-07-20 20:11:51 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-07-20 20:11:51 >>>开始打印,排队号为172,订单号为2407202011510021801968
2024-07-20 20:11:51>>>订单2407202011510021801968写入成功,剩余空间为1679500,占用RAM为600.74609375
删除未同步订单2407202011510021801968
2024-07-20 20:11:54>>>订单2407202011510021801968删除成功,剩余空间为1680500,占用RAM为617.701171875
检测订单目录中>>>
无未同步订单>>>
2024-07-20 20:11:54 >>>当前Ram内存为585.4326171875
定时检测未同步订单启用
2024-07-20 20:11:55>>>cash write=0C
2024-07-20 20:11:55>>>cash read=3E


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


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


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


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


===20:26:26===
2024-07-20 20:26:22 >>>回调事件[910,devices/TL2180]
2024-07-20 20:26:22 >>>故障排除日志:上一MQTT订单号缓存列表为24072020181821052203
2024-07-20 20:26:22 >>>故障排除日志:终端未同步成功订单列表
2024-07-20 20:26:22 开始打印,排队:177,票券:2407202026151676320301,订单:24072020261516759021,[2024-07-20 20:26:15微信支付10元]


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


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


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


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


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


===20:54:27===
2024-07-20 20:53:57>>>cash read=00
2024-07-20 20:53:58>>>cash read=29
2024-07-20 20:53:58 >>>回调事件130,cash_status,20029,退钞中
2024-07-20 20:53:58>>>cash read=2F29
2024-07-20 20:54:00>>>cash read=3E
2024-07-20 20:54:01>>>cash read=00
2024-07-20 20:54:02>>>cash read=818F42
2024-07-20 20:54:02>>>cash write=02
2024-07-20 20:54:02 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-07-20 20:54:02>>>cash read=10
2024-07-20 20:54:02 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-07-20 20:54:02 >>>开始打印,排队号为181,订单号为2407202054020021804547
2024-07-20 20:54:02>>>订单2407202054020021804547写入成功,剩余空间为1679500,占用RAM为600.6259765625
删除未同步订单2407202054020021804547
2024-07-20 20:54:05>>>订单2407202054020021804547删除成功,剩余空间为1680500,占用RAM为614.39453125
检测订单目录中>>>
无未同步订单>>>
2024-07-20 20:54:05 >>>当前Ram内存为585.166015625
定时检测未同步订单启用
2024-07-20 20:54:05>>>cash write=0C
2024-07-20 20:54:06>>>cash read=3E


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


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


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


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


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


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


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


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