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

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

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

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


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


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


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


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


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


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


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


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


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


===09:19:44===
2024-10-01 09:18:53 >>>回调事件[910,devices/TL2180]
2024-10-01 09:18:53 >>>故障排除日志:上一MQTT订单号缓存列表为24100109181601983071
2024-10-01 09:18:53 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 09:18:53 开始打印,排队:10,票券:2410010918461610575301,订单:24100109184616101471,[2024-10-01 09:18:53微信支付10元]
2024-10-01 09:18:55 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410010918461610575301","queue_number":10,"trade_uid":"24100109184616101471"}]}
2024-10-01 09:18:55 >>>故障排除日志:删除未同步下发订单成功24100109184616101471
2024-10-01 09:18:56 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-01 09:19:14 >>>回调事件[910,devices/TL2180]
2024-10-01 09:19:14 >>>故障排除日志:上一MQTT订单号缓存列表为24100109184616101471
2024-10-01 09:19:14 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 09:19:14 开始打印,排队:11,票券:2410010919080801799801,订单:24100109190808013228,[2024-10-01 09:19:14微信支付10元]
2024-10-01 09:19:16 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410010919080801799801","queue_number":11,"trade_uid":"24100109190808013228"}]}
2024-10-01 09:19:16 >>>故障排除日志:删除未同步下发订单成功24100109190808013228
2024-10-01 09:19:16 >>>故障排除日志:终端同步成功后剩余订单列表


===09:21:45===
2024-10-01 09:21:41 >>>回调事件[910,devices/TL2180]
2024-10-01 09:21:41 >>>故障排除日志:上一MQTT订单号缓存列表为24100109190808013228
2024-10-01 09:21:41 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 09:21:41 开始打印,排队:12,票券:2410010921324023137501,订单:24100109213240226443,[2024-10-01 09:21:40支付宝支付10元]
2024-10-01 09:21:41 开始打印,排队:13,票券:2410010921324023359502,订单:24100109213240226443,[2024-10-01 09:21:40支付宝支付10元]


===09:22:46===
2024-10-01 09:21:44 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410010921324023137501","queue_number":12,"trade_uid":"24100109213240226443"},{"ticket_no":"2410010921324023359502","queue_number":13,"trade_uid":"24100109213240226443"}]}
2024-10-01 09:21:44 >>>故障排除日志:删除未同步下发订单成功24100109213240226443
2024-10-01 09:21:44 >>>故障排除日志:删除未同步下发订单成功24100109213240226443
2024-10-01 09:21:44 >>>故障排除日志:终端同步成功后剩余订单列表


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


===09:27:46===
2024-10-01 09:26:49 >>>回调事件[910,devices/TL2180]
2024-10-01 09:26:49 >>>故障排除日志:上一MQTT订单号缓存列表为24100109255873075016
2024-10-01 09:26:49 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 09:26:49 开始打印,排队:15,票券:2410010926426217744501,订单:24100109264262172362,[2024-10-01 09:26:48微信支付10元]
2024-10-01 09:26:49 开始打印,排队:16,票券:2410010926426217891502,订单:24100109264262172362,[2024-10-01 09:26:48微信支付10元]
2024-10-01 09:26:52 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410010926426217744501","queue_number":15,"trade_uid":"24100109264262172362"},{"ticket_no":"2410010926426217891502","queue_number":16,"trade_uid":"24100109264262172362"}]}
2024-10-01 09:26:52 >>>故障排除日志:删除未同步下发订单成功24100109264262172362
2024-10-01 09:26:52 >>>故障排除日志:删除未同步下发订单成功24100109264262172362
2024-10-01 09:26:53 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-01 09:27:28 >>>回调事件[910,devices/TL2180]
2024-10-01 09:27:28 >>>故障排除日志:上一MQTT订单号缓存列表为24100109264262172362|24100109264262172362
2024-10-01 09:27:28 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 09:27:28 开始打印,排队:17,票券:2410010927233964003801,订单:24100109272339635957,[2024-10-01 09:27:28支付宝支付10元]
2024-10-01 09:27:31 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410010927233964003801","queue_number":17,"trade_uid":"24100109272339635957"}]}
2024-10-01 09:27:31 >>>故障排除日志:删除未同步下发订单成功24100109272339635957
2024-10-01 09:27:31 >>>故障排除日志:终端同步成功后剩余订单列表


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


===09:31:47===
2024-10-01 09:30:46>>>cash read=818F42
2024-10-01 09:30:46>>>cash write=02
2024-10-01 09:30:46 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-01 09:30:47>>>cash read=10
2024-10-01 09:30:47 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-01 09:30:47 当前产品价格10元，投币10元，打印小票中...
2024-10-01 09:30:47 >>>开始打印,排队号为19,订单号为2410010930470021801307
2024-10-01 09:30:47>>>订单2410010930470021801307写入成功,剩余空间为1680000,占用RAM为605.9951171875
删除未同步订单2410010930470021801307
2024-10-01 09:30:49>>>订单2410010930470021801307删除成功,剩余空间为1680500,占用RAM为620.1669921875
检测订单目录中>>>
无未同步订单>>>
2024-10-01 09:30:49 >>>当前Ram内存为592.3017578125
定时检测未同步订单启用
2024-10-01 09:30:50>>>cash write=0C
2024-10-01 09:30:50>>>cash read=3E
2024-10-01 09:30:54 >>>回调事件[910,devices/TL2180]
2024-10-01 09:30:54 >>>故障排除日志:上一MQTT订单号缓存列表为24100109302286576495
2024-10-01 09:30:54 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 09:30:54 开始打印,排队:20,票券:2410010930481724229501,订单:24100109304817238572,[2024-10-01 09:30:53微信支付10元]
2024-10-01 09:30:54 开始打印,排队:21,票券:2410010930481724376902,订单:24100109304817238572,[2024-10-01 09:30:53微信支付10元]
2024-10-01 09:30:58 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410010930481724229501","queue_number":20,"trade_uid":"24100109304817238572"},{"ticket_no":"2410010930481724376902","queue_number":21,"trade_uid":"24100109304817238572"}]}
2024-10-01 09:30:58 >>>故障排除日志:删除未同步下发订单成功24100109304817238572
2024-10-01 09:30:58 >>>故障排除日志:删除未同步下发订单成功24100109304817238572
2024-10-01 09:30:58 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-01 09:31:31>>>cash read=292F29
2024-10-01 09:31:31 >>>回调事件130,cash_status,20029,退钞中
2024-10-01 09:31:32>>>cash read=01
2024-10-01 09:31:33>>>cash read=2F
2024-10-01 09:31:34>>>cash read=00
2024-10-01 09:31:35>>>cash read=29
2024-10-01 09:31:35 >>>回调事件130,cash_status,20029,退钞中
2024-10-01 09:31:35>>>cash read=2F29
2024-10-01 09:31:36>>>cash read=00
2024-10-01 09:31:37>>>cash read=01
2024-10-01 09:31:39>>>cash read=00
2024-10-01 09:31:40>>>cash read=29
2024-10-01 09:31:40 >>>回调事件130,cash_status,20029,退钞中
2024-10-01 09:31:41>>>cash read=2F29
2024-10-01 09:31:42>>>cash read=00
2024-10-01 09:31:44>>>cash read=29
2024-10-01 09:31:44 >>>回调事件130,cash_status,20029,退钞中
2024-10-01 09:31:44>>>cash read=2F29
2024-10-01 09:31:45>>>cash read=01


===09:32:47===
2024-10-01 09:31:47>>>cash read=2F
2024-10-01 09:31:48>>>cash read=3E
定时检测未同步订单关闭
检测订单目录中>>>
无未同步订单>>>
2024-10-01 09:31:50>>>cash read=00
2024-10-01 09:31:51>>>cash read=2F29
2024-10-01 09:31:52>>>cash read=3E
2024-10-01 09:31:53>>>cash read=00
2024-10-01 09:31:54>>>cash read=818F42
2024-10-01 09:31:54>>>cash write=02
2024-10-01 09:31:54 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-01 09:31:55>>>cash read=10
2024-10-01 09:31:55 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-01 09:31:55 当前产品价格10元，投币10元，打印小票中...
2024-10-01 09:31:55 >>>开始打印,排队号为22,订单号为2410010931550021807378
2024-10-01 09:31:55>>>订单2410010931550021807378写入成功,剩余空间为1679500,占用RAM为609.2578125
删除未同步订单2410010931550021807378
2024-10-01 09:31:57>>>订单2410010931550021807378删除成功,剩余空间为1680500,占用RAM为619.1640625
检测订单目录中>>>
无未同步订单>>>
2024-10-01 09:31:57 >>>当前Ram内存为590.5302734375
定时检测未同步订单启用
2024-10-01 09:31:58>>>cash write=0C
2024-10-01 09:31:58>>>cash read=3E
2024-10-01 09:32:22 >>>回调事件[910,devices/TL2180]
2024-10-01 09:32:22 >>>故障排除日志:上一MQTT订单号缓存列表为24100109304817238572|24100109304817238572
2024-10-01 09:32:22 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 09:32:22 开始打印,排队:23,票券:2410010932151482097901,订单:24100109321514816156,[2024-10-01 09:32:21微信支付10元]
2024-10-01 09:32:24 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410010932151482097901","queue_number":23,"trade_uid":"24100109321514816156"}]}
2024-10-01 09:32:24 >>>故障排除日志:删除未同步下发订单成功24100109321514816156
2024-10-01 09:32:24 >>>故障排除日志:终端同步成功后剩余订单列表


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


===09:39:47===
2024-10-01 09:38:49 >>>回调事件[910,devices/TL2180]
2024-10-01 09:38:49 >>>故障排除日志:上一MQTT订单号缓存列表为24100109321514816156
2024-10-01 09:38:49 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 09:38:49 开始打印,排队:24,票券:2410010938426840179401,订单:24100109384268395041,[2024-10-01 09:38:48支付宝支付10元]
2024-10-01 09:38:49 开始打印,排队:25,票券:2410010938426840421602,订单:24100109384268395041,[2024-10-01 09:38:48支付宝支付10元]
2024-10-01 09:38:53 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410010938426840179401","queue_number":24,"trade_uid":"24100109384268395041"},{"ticket_no":"2410010938426840421602","queue_number":25,"trade_uid":"24100109384268395041"}]}
2024-10-01 09:38:53 >>>故障排除日志:删除未同步下发订单成功24100109384268395041
2024-10-01 09:38:53 >>>故障排除日志:删除未同步下发订单成功24100109384268395041
2024-10-01 09:38:53 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-01 09:39:08 >>>回调事件[910,devices/TL2180]
2024-10-01 09:39:08 >>>故障排除日志:上一MQTT订单号缓存列表为24100109384268395041|24100109384268395041
2024-10-01 09:39:08 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 09:39:08 开始打印,排队:26,票券:2410010939039419424701,订单:24100109390394190364,[2024-10-01 09:39:08微信支付10元]
2024-10-01 09:39:10 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410010939039419424701","queue_number":26,"trade_uid":"24100109390394190364"}]}
2024-10-01 09:39:10 >>>故障排除日志:删除未同步下发订单成功24100109390394190364
2024-10-01 09:39:11 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


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


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


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


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


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


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


===10:22:50===
2024-10-01 10:21:53>>>cash read=00
2024-10-01 10:21:54>>>cash read=29
2024-10-01 10:21:54 >>>回调事件130,cash_status,20029,退钞中
2024-10-01 10:21:55>>>cash read=2F29
2024-10-01 10:21:56>>>cash read=3E
2024-10-01 10:22:06>>>cash read=00
2024-10-01 10:22:08>>>cash read=2F29
2024-10-01 10:22:09>>>cash read=01
2024-10-01 10:22:10>>>cash read=2F
2024-10-01 10:22:11>>>cash read=3E
2024-10-01 10:22:16>>>cash read=292F29
2024-10-01 10:22:16 >>>回调事件130,cash_status,20029,退钞中
2024-10-01 10:22:18>>>cash read=00
2024-10-01 10:22:20>>>cash read=818F42
2024-10-01 10:22:20>>>cash write=02
2024-10-01 10:22:20 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-01 10:22:20>>>cash read=10
2024-10-01 10:22:20 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-01 10:22:20 当前产品价格10元，投币10元，打印小票中...
2024-10-01 10:22:20 >>>开始打印,排队号为37,订单号为2410011022200021809852
2024-10-01 10:22:21>>>订单2410011022200021809852写入成功,剩余空间为1679500,占用RAM为611.078125
删除未同步订单2410011022200021809852
2024-10-01 10:22:23>>>订单2410011022200021809852删除成功,剩余空间为1680000,占用RAM为623.240234375
检测订单目录中>>>
无未同步订单>>>
2024-10-01 10:22:23 >>>当前Ram内存为591.4326171875
定时检测未同步订单启用
2024-10-01 10:22:24>>>cash write=0C
2024-10-01 10:22:24>>>cash read=3E


===10:23:51===
2024-10-01 10:23:09>>>cash read=2F29
2024-10-01 10:23:10>>>cash read=3E
定时检测未同步订单关闭
检测订单目录中>>>
无未同步订单>>>


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


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


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


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


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


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


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


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


===10:53:54===
2024-10-01 10:53:26>>>cash read=00
2024-10-01 10:53:26>>>cash read=2F29
2024-10-01 10:53:28>>>cash read=3E
2024-10-01 10:53:32>>>cash read=00
2024-10-01 10:53:34>>>cash read=818F42
2024-10-01 10:53:34>>>cash write=02
2024-10-01 10:53:34 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-01 10:53:34>>>cash read=10
2024-10-01 10:53:34 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-01 10:53:34 当前产品价格10元，投币10元，打印小票中...
2024-10-01 10:53:34 >>>开始打印,排队号为46,订单号为2410011053340021809749
2024-10-01 10:53:34>>>订单2410011053340021809749写入成功,剩余空间为1679500,占用RAM为607.873046875
删除未同步订单2410011053340021809749
2024-10-01 10:53:37>>>订单2410011053340021809749删除成功,剩余空间为1680500,占用RAM为620.0283203125
检测订单目录中>>>
无未同步订单>>>
2024-10-01 10:53:37 >>>当前Ram内存为590.05859375
定时检测未同步订单启用
2024-10-01 10:53:37>>>cash write=0C
2024-10-01 10:53:38>>>cash read=3E


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


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


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


===11:11:55===
2024-10-01 11:11:42>>>cash read=29
2024-10-01 11:11:42 >>>回调事件130,cash_status,20029,退钞中
2024-10-01 11:11:43>>>cash read=01
2024-10-01 11:11:44>>>cash read=3E
2024-10-01 11:11:45>>>cash read=2F29
2024-10-01 11:11:47>>>cash read=01
2024-10-01 11:11:50>>>cash read=2F
2024-10-01 11:11:51>>>cash read=00
2024-10-01 11:11:53>>>cash read=29
2024-10-01 11:11:53 >>>回调事件130,cash_status,20029,退钞中
2024-10-01 11:11:53>>>cash read=2F29


===11:12:55===
2024-10-01 11:11:55>>>cash read=3E
2024-10-01 11:11:59>>>cash read=29
2024-10-01 11:11:59 >>>回调事件130,cash_status,20029,退钞中
2024-10-01 11:12:00>>>cash read=3E
2024-10-01 11:12:08>>>cash read=00
2024-10-01 11:12:09>>>cash read=29
2024-10-01 11:12:09 >>>回调事件130,cash_status,20029,退钞中
2024-10-01 11:12:10>>>cash read=2F29
2024-10-01 11:12:11>>>cash read=3E
2024-10-01 11:12:27>>>cash read=29
2024-10-01 11:12:27 >>>回调事件130,cash_status,20029,退钞中
2024-10-01 11:12:28>>>cash read=01
2024-10-01 11:12:31>>>cash read=3E
2024-10-01 11:12:38>>>cash read=00
2024-10-01 11:12:40>>>cash read=2F29
2024-10-01 11:12:42>>>cash read=3E
2024-10-01 11:12:47>>>cash read=00
2024-10-01 11:12:48>>>cash read=01
2024-10-01 11:12:51>>>cash read=3E


===11:13:56===
2024-10-01 11:12:55>>>cash read=2F29
2024-10-01 11:12:56>>>cash read=01
2024-10-01 11:12:58>>>cash read=2F
2024-10-01 11:12:59>>>cash read=3E
2024-10-01 11:13:00>>>cash read=00
2024-10-01 11:13:01>>>cash read=2F29
2024-10-01 11:13:02>>>cash read=01
2024-10-01 11:13:02>>>cash read=2F
2024-10-01 11:13:03>>>cash read=3E
2024-10-01 11:13:44 >>>回调事件[910,devices/TL2180]
2024-10-01 11:13:44 >>>故障排除日志:上一MQTT订单号缓存列表为24100111073933646565
2024-10-01 11:13:44 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 11:13:45 开始打印,排队:50,票券:2410011113377332949701,订单:24100111133773325332,[2024-10-01 11:13:44微信支付10元]
2024-10-01 11:13:47 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011113377332949701","queue_number":50,"trade_uid":"24100111133773325332"}]}
2024-10-01 11:13:47 >>>故障排除日志:删除未同步下发订单成功24100111133773325332
2024-10-01 11:13:47 >>>故障排除日志:终端同步成功后剩余订单列表


===11:19:56===
2024-10-01 11:18:55 >>>回调事件[910,devices/TL2180]
2024-10-01 11:18:55 >>>故障排除日志:上一MQTT订单号缓存列表为24100111133773325332
2024-10-01 11:18:55 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 11:18:55 开始打印,排队:51,票券:2410011118469438194501,订单:24100111184694377964,[2024-10-01 11:18:54微信支付10元]
2024-10-01 11:18:57 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011118469438194501","queue_number":51,"trade_uid":"24100111184694377964"}]}
2024-10-01 11:18:57 >>>故障排除日志:删除未同步下发订单成功24100111184694377964
2024-10-01 11:18:57 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-01 11:19:30 >>>回调事件[910,devices/TL2180]
2024-10-01 11:19:30 >>>故障排除日志:上一MQTT订单号缓存列表为24100111184694377964
2024-10-01 11:19:30 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 11:19:30 开始打印,排队:52,票券:2410011119215126386401,订单:24100111192151259037,[2024-10-01 11:19:29支付宝支付10元]
2024-10-01 11:19:32 >>>回调事件[910,devices/TL2180]
2024-10-01 11:19:32 >>>故障排除日志:上一MQTT订单号缓存列表为24100111192151259037
2024-10-01 11:19:32 >>>故障排除日志:终端未同步成功订单列表005224100111192151259037
已接收过此消息,票券号为2410011119215126386401,排队号为52
2024-10-01 11:19:32 开始打印,排队:53,票券:2410011119243299644101,订单:24100111192432991567,[2024-10-01 11:19:30微信支付10元]
2024-10-01 11:19:34 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011119215126386401","queue_number":52,"trade_uid":"24100111192151259037"}]}
2024-10-01 11:19:34 >>>故障排除日志:删除未同步下发订单成功24100111192151259037
2024-10-01 11:19:34 >>>故障排除日志:终端同步成功后剩余订单列表005324100111192432991567
2024-10-01 11:19:34 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011119215126386401","queue_number":52,"trade_uid":"24100111192151259037"},{"ticket_no":"2410011119243299644101","queue_number":53,"trade_uid":"24100111192432991567"}]}
2024-10-01 11:19:34 >>>故障排除日志:删除未同步下发订单成功24100111192432991567
2024-10-01 11:19:34 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


===11:29:57===
2024-10-01 11:29:40>>>cash read=29
2024-10-01 11:29:40 >>>回调事件130,cash_status,20029,退钞中
2024-10-01 11:29:41>>>cash read=2F29
2024-10-01 11:29:42>>>cash read=01
2024-10-01 11:29:45>>>cash read=2F
2024-10-01 11:29:46>>>cash read=3E
2024-10-01 11:29:48>>>cash read=00
2024-10-01 11:29:48>>>cash read=818F42
2024-10-01 11:29:48>>>cash write=02
2024-10-01 11:29:48 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-01 11:29:49>>>cash read=10
2024-10-01 11:29:49 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-01 11:29:49 当前产品价格10元，投币10元，打印小票中...
2024-10-01 11:29:49 >>>开始打印,排队号为55,订单号为2410011129490021804997
2024-10-01 11:29:49>>>订单2410011129490021804997写入成功,剩余空间为1679500,占用RAM为608.9072265625
删除未同步订单2410011129490021804997
2024-10-01 11:29:51>>>订单2410011129490021804997删除成功,剩余空间为1680500,占用RAM为618.9384765625
检测订单目录中>>>
无未同步订单>>>
2024-10-01 11:29:52 >>>当前Ram内存为590.3671875
定时检测未同步订单启用
2024-10-01 11:29:52>>>cash write=0C
2024-10-01 11:29:52>>>cash read=3E


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


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


===11:53:57===
2024-10-01 11:53:34 >>>回调事件[910,devices/TL2180]
2024-10-01 11:53:34 >>>故障排除日志:上一MQTT订单号缓存列表为24100111333640057428
2024-10-01 11:53:34 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 11:53:34 开始打印,排队:57,票券:2410011153279236477801,订单:24100111532792361216,[2024-10-01 11:53:33支付宝支付10元]
2024-10-01 11:53:36 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011153279236477801","queue_number":57,"trade_uid":"24100111532792361216"}]}
2024-10-01 11:53:36 >>>故障排除日志:删除未同步下发订单成功24100111532792361216
2024-10-01 11:53:36 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-01 11:53:46 >>>回调事件[910,devices/TL2180]
2024-10-01 11:53:46 >>>故障排除日志:上一MQTT订单号缓存列表为24100111532792361216
2024-10-01 11:53:46 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 11:53:46 开始打印,排队:58,票券:2410011153392386901801,订单:24100111533923862761,[2024-10-01 11:53:46微信支付10元]
2024-10-01 11:53:48 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011153392386901801","queue_number":58,"trade_uid":"24100111533923862761"}]}
2024-10-01 11:53:48 >>>故障排除日志:删除未同步下发订单成功24100111533923862761
2024-10-01 11:53:48 >>>故障排除日志:终端同步成功后剩余订单列表


===11:56:58===
2024-10-01 11:55:57 >>>回调事件[910,devices/TL2180]
2024-10-01 11:55:57 >>>故障排除日志:上一MQTT订单号缓存列表为24100111533923862761
2024-10-01 11:55:57 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 11:55:57 开始打印,排队:59,票券:2410011155510893436501,订单:24100111555108930952,[2024-10-01 11:55:56微信支付10元]
2024-10-01 11:55:59 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011155510893436501","queue_number":59,"trade_uid":"24100111555108930952"}]}
2024-10-01 11:55:59 >>>故障排除日志:删除未同步下发订单成功24100111555108930952
2024-10-01 11:55:59 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-01 11:56:38 >>>回调事件[910,devices/TL2180]
2024-10-01 11:56:38 >>>故障排除日志:上一MQTT订单号缓存列表为24100111555108930952
2024-10-01 11:56:38 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 11:56:38 开始打印,排队:60,票券:2410011156319128626801,订单:24100111563191281946,[2024-10-01 11:56:38微信支付10元]
2024-10-01 11:56:40 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011156319128626801","queue_number":60,"trade_uid":"24100111563191281946"}]}
2024-10-01 11:56:40 >>>故障排除日志:删除未同步下发订单成功24100111563191281946
2024-10-01 11:56:40 >>>故障排除日志:终端同步成功后剩余订单列表


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


===12:00:58===
2024-10-01 12:00:03 >>>回调事件[910,devices/TL2180]
2024-10-01 12:00:03 >>>故障排除日志:上一MQTT订单号缓存列表为24100111573483802538
2024-10-01 12:00:03 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 12:00:03 开始打印,排队:62,票券:2410011159562628193801,订单:24100111595626277626,[2024-10-01 12:00:03微信支付10元]
2024-10-01 12:00:05 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011159562628193801","queue_number":62,"trade_uid":"24100111595626277626"}]}
2024-10-01 12:00:05 >>>故障排除日志:删除未同步下发订单成功24100111595626277626
2024-10-01 12:00:05 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-01 12:00:20 >>>回调事件[910,devices/TL2180]
2024-10-01 12:00:20 >>>故障排除日志:上一MQTT订单号缓存列表为24100111595626277626
2024-10-01 12:00:20 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 12:00:20 开始打印,排队:63,票券:2410011200097620187201,订单:24100112000976196728,[2024-10-01 12:00:19微信支付10元]
2024-10-01 12:00:22 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011200097620187201","queue_number":63,"trade_uid":"24100112000976196728"}]}
2024-10-01 12:00:22 >>>故障排除日志:删除未同步下发订单成功24100112000976196728
2024-10-01 12:00:22 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-01 12:00:23 >>>回调事件[910,devices/TL2180]
2024-10-01 12:00:23 >>>故障排除日志:上一MQTT订单号缓存列表为24100112000976196728
2024-10-01 12:00:23 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 12:00:23 开始打印,排队:64,票券:2410011200171356304101,订单:24100112001713557384,[2024-10-01 12:00:23微信支付10元]
2024-10-01 12:00:25 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011200171356304101","queue_number":64,"trade_uid":"24100112001713557384"}]}
2024-10-01 12:00:25 >>>故障排除日志:删除未同步下发订单成功24100112001713557384
2024-10-01 12:00:25 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


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


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


===12:20:00===
2024-10-01 12:19:29>>>cash read=0A
2024-10-01 12:19:30>>>cash read=3E


===12:25:00===
2024-10-01 12:24:27 >>>回调事件[910,devices/TL2180]
2024-10-01 12:24:27 >>>故障排除日志:上一MQTT订单号缓存列表为24100112131190334464
2024-10-01 12:24:27 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 12:24:27 开始打印,排队:70,票券:2410011224207169645401,订单:24100112242071692279,[2024-10-01 12:24:26微信支付10元]
2024-10-01 12:24:27 开始打印,排队:71,票券:2410011224207169796902,订单:24100112242071692279,[2024-10-01 12:24:26微信支付10元]
2024-10-01 12:24:31 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011224207169645401","queue_number":70,"trade_uid":"24100112242071692279"},{"ticket_no":"2410011224207169796902","queue_number":71,"trade_uid":"24100112242071692279"}]}
2024-10-01 12:24:31 >>>故障排除日志:删除未同步下发订单成功24100112242071692279
2024-10-01 12:24:31 >>>故障排除日志:删除未同步下发订单成功24100112242071692279
2024-10-01 12:24:31 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


===12:32:01===
2024-10-01 12:31:22>>>cash read=00
2024-10-01 12:31:22>>>cash read=2F29
2024-10-01 12:31:23>>>cash read=01
2024-10-01 12:31:27>>>cash read=2F
2024-10-01 12:31:28>>>cash read=00
2024-10-01 12:31:29>>>cash read=818F42
2024-10-01 12:31:29>>>cash write=02
2024-10-01 12:31:29 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-01 12:31:29>>>cash read=10
2024-10-01 12:31:29 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-01 12:31:30 当前产品价格10元，投币10元，打印小票中...
2024-10-01 12:31:30 >>>开始打印,排队号为75,订单号为2410011231300021803618
2024-10-01 12:31:30>>>订单2410011231300021803618写入成功,剩余空间为1679500,占用RAM为607.384765625
删除未同步订单2410011231300021803618
2024-10-01 12:31:32>>>订单2410011231300021803618删除成功,剩余空间为1680500,占用RAM为617.42578125
检测订单目录中>>>
无未同步订单>>>
2024-10-01 12:31:32 >>>当前Ram内存为589.3017578125
定时检测未同步订单启用
2024-10-01 12:31:33>>>cash write=0C
2024-10-01 12:31:33>>>cash read=3E


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


===12:43:02===
2024-10-01 12:42:06 >>>回调事件[910,devices/TL2180]
2024-10-01 12:42:06 >>>故障排除日志:上一MQTT订单号缓存列表为24100112292683654415
2024-10-01 12:42:06 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 12:42:06 开始打印,排队:76,票券:2410011241593826915901,订单:24100112415938264641,[2024-10-01 12:42:05微信支付10元]
2024-10-01 12:42:08 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011241593826915901","queue_number":76,"trade_uid":"24100112415938264641"}]}
2024-10-01 12:42:08 >>>故障排除日志:删除未同步下发订单成功24100112415938264641
2024-10-01 12:42:08 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-01 12:42:26 >>>回调事件[910,devices/TL2180]
2024-10-01 12:42:26 >>>故障排除日志:上一MQTT订单号缓存列表为24100112415938264641
2024-10-01 12:42:26 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 12:42:26 开始打印,排队:77,票券:2410011242186231184201,订单:24100112421862307884,[2024-10-01 12:42:26微信支付10元]
2024-10-01 12:42:28 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011242186231184201","queue_number":77,"trade_uid":"24100112421862307884"}]}
2024-10-01 12:42:28 >>>故障排除日志:删除未同步下发订单成功24100112421862307884
2024-10-01 12:42:28 >>>故障排除日志:终端同步成功后剩余订单列表


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


===12:48:02===
2024-10-01 12:47:02 >>>回调事件[910,devices/TL2180]
2024-10-01 12:47:02 >>>故障排除日志:上一MQTT订单号缓存列表为24100112462840450914
2024-10-01 12:47:02 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 12:47:02 开始打印,排队:79,票券:2410011246507360357101,订单:24100112465073598029,[2024-10-01 12:47:02微信支付10元]
2024-10-01 12:47:04 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011246507360357101","queue_number":79,"trade_uid":"24100112465073598029"}]}
2024-10-01 12:47:04 >>>故障排除日志:删除未同步下发订单成功24100112465073598029
2024-10-01 12:47:04 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-01 12:47:28 >>>回调事件[910,devices/TL2180]
2024-10-01 12:47:28 >>>故障排除日志:上一MQTT订单号缓存列表为24100112465073598029
2024-10-01 12:47:28 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 12:47:28 开始打印,排队:80,票券:2410011247211811487801,订单:24100112472118110613,[2024-10-01 12:47:27微信支付10元]
2024-10-01 12:47:30 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011247211811487801","queue_number":80,"trade_uid":"24100112472118110613"}]}
2024-10-01 12:47:30 >>>故障排除日志:删除未同步下发订单成功24100112472118110613
2024-10-01 12:47:30 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-01 12:47:33 >>>回调事件[910,devices/TL2180]
2024-10-01 12:47:33 >>>故障排除日志:上一MQTT订单号缓存列表为24100112472118110613
2024-10-01 12:47:33 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 12:47:33 开始打印,排队:81,票券:2410011247265095344901,订单:24100112472650949093,[2024-10-01 12:47:33微信支付10元]
2024-10-01 12:47:35 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011247265095344901","queue_number":81,"trade_uid":"24100112472650949093"}]}
2024-10-01 12:47:35 >>>故障排除日志:删除未同步下发订单成功24100112472650949093
2024-10-01 12:47:35 >>>故障排除日志:终端同步成功后剩余订单列表
mqttTask.mqttMsgRecv.proc error
2024-10-01 12:47:43 >>>剩余flash空间=1678500,占用RAM为630.748046875
2024-10-01 12:47:43 >>>回调异常:910,mqtt_tl,30000,mqtt_stop

2024-10-01 12:47:43 >>>MQTT连接断开，尝试重连中
cannot resume dead coroutine
stack traceback:
2024-10-01 12:47:55 >>>剩余flash空间=1678000,占用RAM为623.294921875
2024-10-01 12:47:55 >>>回调事件:910,subscribe,10000,连接服务器成功

2024-10-01 12:47:55 >>>剩余flash空间=1678000,占用RAM为608.642578125
2024-10-01 12:47:55 >>>回调事件:911,GetMqttQueue,500,暂无需要下发的信息，请求类型：ticket



TCP://post-cn-09k20cnrl07.mqtt.aliyuncs.com:1883 closed@01_12:47:44
PDP_DEACT_IND@01_12:47:43
===12:55:03===
2024-10-01 12:54:22 >>>回调事件[910,devices/TL2180]
2024-10-01 12:54:22 >>>故障排除日志:上一MQTT订单号缓存列表为24100112472650949093
2024-10-01 12:54:22 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 12:54:22 开始打印,排队:82,票券:2410011254152505775701,订单:24100112541525053338,[2024-10-01 12:54:21微信支付10元]
2024-10-01 12:54:24 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011254152505775701","queue_number":82,"trade_uid":"24100112541525053338"}]}
2024-10-01 12:54:24 >>>故障排除日志:删除未同步下发订单成功24100112541525053338
2024-10-01 12:54:24 >>>故障排除日志:终端同步成功后剩余订单列表


===12:57:03===
2024-10-01 12:56:14 >>>回调事件[910,devices/TL2180]
2024-10-01 12:56:14 >>>故障排除日志:上一MQTT订单号缓存列表为24100112541525053338
2024-10-01 12:56:14 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 12:56:14 开始打印,排队:83,票券:2410011256074795453801,订单:24100112560747950174,[2024-10-01 12:56:13微信支付10元]
2024-10-01 12:56:14 开始打印,排队:84,票券:2410011256074795606402,订单:24100112560747950174,[2024-10-01 12:56:13微信支付10元]
2024-10-01 12:56:14 开始打印,排队:85,票券:2410011256074795669203,订单:24100112560747950174,[2024-10-01 12:56:13微信支付10元]
2024-10-01 12:56:19 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011256074795453801","queue_number":83,"trade_uid":"24100112560747950174"},{"ticket_no":"2410011256074795606402","queue_number":84,"trade_uid":"24100112560747950174"},{"ticket_no":"2410011256074795669203","queue_number":85,"trade_uid":"24100112560747950174"}]}
2024-10-01 12:56:19 >>>故障排除日志:删除未同步下发订单成功24100112560747950174
2024-10-01 12:56:19 >>>故障排除日志:删除未同步下发订单成功24100112560747950174
2024-10-01 12:56:19 >>>故障排除日志:删除未同步下发订单成功24100112560747950174
2024-10-01 12:56:19 >>>故障排除日志:终端同步成功后剩余订单列表


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


===13:00:03===
2024-10-01 12:59:33 >>>回调事件[910,devices/TL2180]
2024-10-01 12:59:33 >>>故障排除日志:上一MQTT订单号缓存列表为24100112574066102758
2024-10-01 12:59:33 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 12:59:33 开始打印,排队:87,票券:2410011259246747014901,订单:24100112592467465935,[2024-10-01 12:59:32支付宝支付10元]
2024-10-01 12:59:33 开始打印,排队:88,票券:2410011259246747167302,订单:24100112592467465935,[2024-10-01 12:59:32支付宝支付10元]
2024-10-01 12:59:37 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011259246747014901","queue_number":87,"trade_uid":"24100112592467465935"},{"ticket_no":"2410011259246747167302","queue_number":88,"trade_uid":"24100112592467465935"}]}
2024-10-01 12:59:37 >>>故障排除日志:删除未同步下发订单成功24100112592467465935
2024-10-01 12:59:37 >>>故障排除日志:删除未同步下发订单成功24100112592467465935
2024-10-01 12:59:37 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


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


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


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


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


===13:58:06===
2024-10-01 13:58:03>>>cash read=29
2024-10-01 13:58:03 >>>回调事件130,cash_status,20029,退钞中
2024-10-01 13:58:03>>>cash read=2F29
2024-10-01 13:58:04>>>cash read=01
2024-10-01 13:58:05>>>cash read=2F


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


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


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


===14:03:07===
2024-10-01 14:02:52 >>>回调事件[910,devices/TL2180]
2024-10-01 14:02:52 >>>故障排除日志:上一MQTT订单号缓存列表为24100114000791749549
2024-10-01 14:02:52 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 14:02:52 开始打印,排队:99,票券:2410011402464110535201,订单:24100114024641101715,[2024-10-01 14:02:51微信支付10元]
2024-10-01 14:02:54 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011402464110535201","queue_number":99,"trade_uid":"24100114024641101715"}]}
2024-10-01 14:02:54 >>>故障排除日志:删除未同步下发订单成功24100114024641101715
2024-10-01 14:02:54 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-01 14:03:03 >>>回调事件[910,devices/TL2180]
2024-10-01 14:03:03 >>>故障排除日志:上一MQTT订单号缓存列表为24100114024641101715
2024-10-01 14:03:03 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 14:03:03 开始打印,排队:100,票券:2410011402566318453701,订单:24100114025663178725,[2024-10-01 14:03:02微信支付10元]
2024-10-01 14:03:05 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011402566318453701","queue_number":100,"trade_uid":"24100114025663178725"}]}
2024-10-01 14:03:05 >>>故障排除日志:删除未同步下发订单成功24100114025663178725
2024-10-01 14:03:05 >>>故障排除日志:终端同步成功后剩余订单列表


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


===14:07:07===
2024-10-01 14:06:35>>>cash read=00
2024-10-01 14:06:36>>>cash read=2F29
2024-10-01 14:06:37>>>cash read=01
2024-10-01 14:06:41>>>cash read=2F
2024-10-01 14:06:42>>>cash read=00
2024-10-01 14:06:43>>>cash read=2F29
2024-10-01 14:06:44>>>cash read=01
2024-10-01 14:06:46>>>cash read=2F
2024-10-01 14:06:47>>>cash read=00
2024-10-01 14:06:47>>>cash read=2F29
2024-10-01 14:06:49>>>cash read=3E
2024-10-01 14:06:50>>>cash read=29
2024-10-01 14:06:50 >>>回调事件130,cash_status,20029,退钞中
2024-10-01 14:06:52>>>cash read=3E
2024-10-01 14:06:53>>>cash read=00
2024-10-01 14:06:53>>>cash read=818F42
2024-10-01 14:06:53>>>cash write=02
2024-10-01 14:06:53 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-01 14:06:53>>>cash read=10
2024-10-01 14:06:53 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-01 14:06:53 当前产品价格10元，投币10元，打印小票中...
2024-10-01 14:06:53 >>>开始打印,排队号为102,订单号为2410011406530021801708
2024-10-01 14:06:54>>>订单2410011406530021801708写入成功,剩余空间为1679000,占用RAM为612.9033203125
删除未同步订单2410011406530021801708
2024-10-01 14:06:56>>>订单2410011406530021801708删除成功,剩余空间为1680000,占用RAM为621.98046875
检测订单目录中>>>
无未同步订单>>>
2024-10-01 14:06:56 >>>当前Ram内存为593.015625
定时检测未同步订单启用
2024-10-01 14:06:57>>>cash write=0C
2024-10-01 14:06:57>>>cash read=3E


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


===14:09:08===
2024-10-01 14:08:42 >>>回调事件[910,devices/TL2180]
2024-10-01 14:08:42 >>>故障排除日志:上一MQTT订单号缓存列表为24100114043781096593
2024-10-01 14:08:42 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 14:08:42 开始打印,排队:103,票券:2410011408356611671701,订单:24100114083566112686,[2024-10-01 14:08:41微信支付10元]
2024-10-01 14:08:44 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011408356611671701","queue_number":103,"trade_uid":"24100114083566112686"}]}
2024-10-01 14:08:44 >>>故障排除日志:删除未同步下发订单成功24100114083566112686
2024-10-01 14:08:44 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-01 14:08:53>>>cash read=29
2024-10-01 14:08:53 >>>回调事件130,cash_status,20029,退钞中
2024-10-01 14:08:54>>>cash read=3E
2024-10-01 14:09:06>>>cash read=00
2024-10-01 14:09:07>>>cash read=29
2024-10-01 14:09:07 >>>回调事件130,cash_status,20029,退钞中


===14:10:09===
2024-10-01 14:09:08>>>cash read=3E
2024-10-01 14:09:11>>>cash read=29
2024-10-01 14:09:11 >>>回调事件130,cash_status,20029,退钞中
2024-10-01 14:09:12>>>cash read=01
2024-10-01 14:09:16>>>cash read=3E
2024-10-01 14:09:17>>>cash read=29
2024-10-01 14:09:17 >>>回调事件130,cash_status,20029,退钞中
2024-10-01 14:09:18>>>cash read=3E
2024-10-01 14:10:05>>>cash read=00
2024-10-01 14:10:05>>>cash read=818F42
2024-10-01 14:10:05>>>cash write=02
2024-10-01 14:10:05 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-01 14:10:06>>>cash read=10
2024-10-01 14:10:06 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-01 14:10:06 当前产品价格10元，投币10元，打印小票中...
2024-10-01 14:10:06 >>>开始打印,排队号为104,订单号为2410011410060021802825
2024-10-01 14:10:06>>>订单2410011410060021802825写入成功,剩余空间为1679500,占用RAM为612.234375


===14:11:09===
删除未同步订单2410011410060021802825
2024-10-01 14:10:08>>>订单2410011410060021802825删除成功,剩余空间为1681500,占用RAM为624.9697265625
检测订单目录中>>>
无未同步订单>>>
2024-10-01 14:10:08 >>>当前Ram内存为592.3759765625
定时检测未同步订单启用
2024-10-01 14:10:09>>>cash write=0C
2024-10-01 14:10:09>>>cash read=3E
定时检测未同步订单关闭
检测订单目录中>>>
无未同步订单>>>


===14:15:10===
2024-10-01 14:14:10 >>>回调事件[910,devices/TL2180]
2024-10-01 14:14:10 >>>故障排除日志:上一MQTT订单号缓存列表为24100114083566112686
2024-10-01 14:14:10 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 14:14:10 开始打印,排队:105,票券:2410011413594359968401,订单:24100114135943593758,[2024-10-01 14:14:09微信支付10元]
2024-10-01 14:14:12 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011413594359968401","queue_number":105,"trade_uid":"24100114135943593758"}]}
2024-10-01 14:14:12 >>>故障排除日志:删除未同步下发订单成功24100114135943593758
2024-10-01 14:14:12 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-01 14:14:33 >>>回调事件[910,devices/TL2180]
2024-10-01 14:14:33 >>>故障排除日志:上一MQTT订单号缓存列表为24100114135943593758
2024-10-01 14:14:33 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 14:14:33 开始打印,排队:106,票券:2410011414256634608201,订单:24100114142566341269,[2024-10-01 14:14:32支付宝支付10元]
2024-10-01 14:14:35 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011414256634608201","queue_number":106,"trade_uid":"24100114142566341269"}]}
2024-10-01 14:14:35 >>>故障排除日志:删除未同步下发订单成功24100114142566341269
2024-10-01 14:14:35 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


===14:29:11===
2024-10-01 14:28:58 >>>回调事件[910,devices/TL2180]
2024-10-01 14:28:58 >>>故障排除日志:上一MQTT订单号缓存列表为24100114232347658221
2024-10-01 14:28:58 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 14:28:58 开始打印,排队:110,票券:2410011428506781698201,订单:24100114285067739235,[2024-10-01 14:28:57支付宝支付10元]
2024-10-01 14:29:00 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011428506781698201","queue_number":110,"trade_uid":"24100114285067739235"}]}
2024-10-01 14:29:00 >>>故障排除日志:删除未同步下发订单成功24100114285067739235
2024-10-01 14:29:00 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-01 14:29:02 >>>回调事件[910,devices/TL2180]
2024-10-01 14:29:02 >>>故障排除日志:上一MQTT订单号缓存列表为24100114285067739235
2024-10-01 14:29:02 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 14:29:02 开始打印,排队:111,票券:2410011428539367767201,订单:24100114285393672129,[2024-10-01 14:29:01微信支付10元]
2024-10-01 14:29:02 开始打印,排队:112,票券:2410011428539367953902,订单:24100114285393672129,[2024-10-01 14:29:01微信支付10元]
2024-10-01 14:29:05 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011428539367767201","queue_number":111,"trade_uid":"24100114285393672129"},{"ticket_no":"2410011428539367953902","queue_number":112,"trade_uid":"24100114285393672129"}]}
2024-10-01 14:29:05 >>>故障排除日志:删除未同步下发订单成功24100114285393672129
2024-10-01 14:29:05 >>>故障排除日志:删除未同步下发订单成功24100114285393672129
2024-10-01 14:29:06 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


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


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


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


===14:51:13===
2024-10-01 14:50:26 >>>回调事件[910,devices/TL2180]
2024-10-01 14:50:26 >>>故障排除日志:上一MQTT订单号缓存列表为24100114491649434767
2024-10-01 14:50:26 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 14:50:26 开始打印,排队:120,票券:2410011450205754802801,订单:24100114502057542541,[2024-10-01 14:50:25支付宝支付10元]
2024-10-01 14:50:28 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011450205754802801","queue_number":120,"trade_uid":"24100114502057542541"}]}
2024-10-01 14:50:28 >>>故障排除日志:删除未同步下发订单成功24100114502057542541
2024-10-01 14:50:28 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-01 14:50:56 >>>回调事件[910,devices/TL2180]
2024-10-01 14:50:56 >>>故障排除日志:上一MQTT订单号缓存列表为24100114502057542541
2024-10-01 14:50:56 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 14:50:56 开始打印,排队:121,票券:2410011450475036485901,订单:24100114504750358776,[2024-10-01 14:50:54微信支付10元]
2024-10-01 14:50:58 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011450475036485901","queue_number":121,"trade_uid":"24100114504750358776"}]}
2024-10-01 14:50:58 >>>故障排除日志:删除未同步下发订单成功24100114504750358776
2024-10-01 14:50:58 >>>故障排除日志:终端同步成功后剩余订单列表


===14:54:13===
2024-10-01 14:53:43 >>>回调事件[910,devices/TL2180]
2024-10-01 14:53:43 >>>故障排除日志:上一MQTT订单号缓存列表为24100114504750358776
2024-10-01 14:53:43 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 14:53:43 开始打印,排队:122,票券:2410011453345036145301,订单:24100114533450357393,[2024-10-01 14:53:43微信支付10元]
2024-10-01 14:53:45 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011453345036145301","queue_number":122,"trade_uid":"24100114533450357393"}]}
2024-10-01 14:53:45 >>>故障排除日志:删除未同步下发订单成功24100114533450357393
2024-10-01 14:53:46 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-01 14:54:04 >>>回调事件[910,devices/TL2180]
2024-10-01 14:54:04 >>>故障排除日志:上一MQTT订单号缓存列表为24100114533450357393
2024-10-01 14:54:04 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 14:54:04 开始打印,排队:123,票券:2410011453583704018101,订单:24100114535837034714,[2024-10-01 14:54:03支付宝支付10元]
2024-10-01 14:54:06 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011453583704018101","queue_number":123,"trade_uid":"24100114535837034714"}]}
2024-10-01 14:54:06 >>>故障排除日志:删除未同步下发订单成功24100114535837034714
2024-10-01 14:54:06 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


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


===15:10:14===
2024-10-01 15:10:06>>>cash read=0A
2024-10-01 15:10:07>>>cash read=3E


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


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


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


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


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


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


===15:46:17===
2024-10-01 15:45:27 >>>回调事件[910,devices/TL2180]
2024-10-01 15:45:27 >>>故障排除日志:上一MQTT订单号缓存列表为24100115365980528197
2024-10-01 15:45:27 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 15:45:27 开始打印,排队:138,票券:2410011545207869454301,订单:24100115452078689264,[2024-10-01 15:45:26微信支付10元]
2024-10-01 15:45:29 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011545207869454301","queue_number":138,"trade_uid":"24100115452078689264"}]}
2024-10-01 15:45:29 >>>故障排除日志:删除未同步下发订单成功24100115452078689264
2024-10-01 15:45:29 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-01 15:45:51 >>>回调事件[910,devices/TL2180]
2024-10-01 15:45:51 >>>故障排除日志:上一MQTT订单号缓存列表为24100115452078689264
2024-10-01 15:45:51 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 15:45:51 开始打印,排队:139,票券:2410011545408000111701,订单:24100115454079996494,[2024-10-01 15:45:51微信支付10元]
2024-10-01 15:45:53 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011545408000111701","queue_number":139,"trade_uid":"24100115454079996494"}]}
2024-10-01 15:45:53 >>>故障排除日志:删除未同步下发订单成功24100115454079996494
2024-10-01 15:45:53 >>>故障排除日志:终端同步成功后剩余订单列表


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


===15:50:17===
2024-10-01 15:49:55 >>>回调事件[910,devices/TL2180]
2024-10-01 15:49:55 >>>故障排除日志:上一MQTT订单号缓存列表为24100115463470596753
2024-10-01 15:49:55 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 15:49:55 开始打印,排队:141,票券:2410011549489746252101,订单:24100115494897459114,[2024-10-01 15:49:54支付宝支付10元]
2024-10-01 15:49:57 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011549489746252101","queue_number":141,"trade_uid":"24100115494897459114"}]}
2024-10-01 15:49:57 >>>故障排除日志:删除未同步下发订单成功24100115494897459114
2024-10-01 15:49:57 >>>故障排除日志:终端同步成功后剩余订单列表


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


===16:00:18===
2024-10-01 15:59:42 >>>回调事件[910,devices/TL2180]
2024-10-01 15:59:42 >>>故障排除日志:上一MQTT订单号缓存列表为24100115530200156253
2024-10-01 15:59:42 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 15:59:42 开始打印,排队:143,票券:2410011559243525656801,订单:24100115592435252293,[2024-10-01 15:59:40微信支付10元]
2024-10-01 15:59:42 开始打印,排队:144,票券:2410011559243525812602,订单:24100115592435252293,[2024-10-01 15:59:40微信支付10元]
2024-10-01 15:59:45 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011559243525656801","queue_number":143,"trade_uid":"24100115592435252293"},{"ticket_no":"2410011559243525812602","queue_number":144,"trade_uid":"24100115592435252293"}]}
2024-10-01 15:59:46 >>>故障排除日志:删除未同步下发订单成功24100115592435252293
2024-10-01 15:59:46 >>>故障排除日志:删除未同步下发订单成功24100115592435252293
2024-10-01 15:59:46 >>>故障排除日志:终端同步成功后剩余订单列表


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


===16:02:18===
2024-10-01 16:02:11 >>>回调事件[910,devices/TL2180]
2024-10-01 16:02:11 >>>故障排除日志:上一MQTT订单号缓存列表为24100116010698381458
2024-10-01 16:02:11 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 16:02:11 开始打印,排队:146,票券:2410011602048343303601,订单:24100116020483426198,[2024-10-01 16:02:10微信支付10元]
2024-10-01 16:02:13 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011602048343303601","queue_number":146,"trade_uid":"24100116020483426198"}]}
2024-10-01 16:02:13 >>>故障排除日志:删除未同步下发订单成功24100116020483426198
2024-10-01 16:02:13 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-01 16:02:14 >>>回调事件[910,devices/TL2180]
2024-10-01 16:02:14 >>>故障排除日志:上一MQTT订单号缓存列表为24100116020483426198
2024-10-01 16:02:14 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 16:02:14 开始打印,排队:147,票券:2410011602088984315101,订单:24100116020889838469,[2024-10-01 16:02:13微信支付10元]
2024-10-01 16:02:16 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011602088984315101","queue_number":147,"trade_uid":"24100116020889838469"}]}
2024-10-01 16:02:16 >>>故障排除日志:删除未同步下发订单成功24100116020889838469
2024-10-01 16:02:16 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


===16:20:21===
2024-10-01 16:20:17>>>cash read=00
2024-10-01 16:20:17>>>cash read=818F42
2024-10-01 16:20:17>>>cash write=02
2024-10-01 16:20:17 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-01 16:20:18>>>cash read=10
2024-10-01 16:20:18 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-01 16:20:18 当前产品价格10元，投币10元，打印小票中...
2024-10-01 16:20:18 >>>开始打印,排队号为150,订单号为2410011620180021808893
2024-10-01 16:20:18>>>订单2410011620180021808893写入成功,剩余空间为1680000,占用RAM为610.43359375


===16:21:21===
删除未同步订单2410011620180021808893
2024-10-01 16:20:20>>>订单2410011620180021808893删除成功,剩余空间为1681500,占用RAM为624.48046875
检测订单目录中>>>
无未同步订单>>>
2024-10-01 16:20:20 >>>当前Ram内存为592.5205078125
定时检测未同步订单启用
2024-10-01 16:20:21>>>cash write=0C
2024-10-01 16:20:21>>>cash read=3E


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


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


===16:29:22===
2024-10-01 16:28:25 >>>回调事件[910,devices/TL2180]
2024-10-01 16:28:25 >>>故障排除日志:上一MQTT订单号缓存列表为24100116240686911684
2024-10-01 16:28:25 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 16:28:25 开始打印,排队:153,票券:2410011628171891038301,订单:24100116281718906468,[2024-10-01 16:28:24微信支付10元]
2024-10-01 16:28:27 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011628171891038301","queue_number":153,"trade_uid":"24100116281718906468"}]}
2024-10-01 16:28:27 >>>故障排除日志:删除未同步下发订单成功24100116281718906468
2024-10-01 16:28:27 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-01 16:28:54 >>>回调事件[910,devices/TL2180]
2024-10-01 16:28:54 >>>故障排除日志:上一MQTT订单号缓存列表为24100116281718906468
2024-10-01 16:28:54 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 16:28:54 开始打印,排队:154,票券:2410011628450709315401,订单:24100116284507088657,[2024-10-01 16:28:53微信支付10元]
2024-10-01 16:28:56 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011628450709315401","queue_number":154,"trade_uid":"24100116284507088657"}]}
2024-10-01 16:28:56 >>>故障排除日志:删除未同步下发订单成功24100116284507088657
2024-10-01 16:28:56 >>>故障排除日志:终端同步成功后剩余订单列表


===16:32:23===
2024-10-01 16:31:37 >>>回调事件[910,devices/TL2180]
2024-10-01 16:31:37 >>>故障排除日志:上一MQTT订单号缓存列表为24100116284507088657
2024-10-01 16:31:37 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 16:31:37 开始打印,排队:155,票券:2410011631063258686401,订单:24100116310632582385,[2024-10-01 16:31:36微信支付10元]
2024-10-01 16:31:39 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011631063258686401","queue_number":155,"trade_uid":"24100116310632582385"}]}
2024-10-01 16:31:39 >>>故障排除日志:删除未同步下发订单成功24100116310632582385
2024-10-01 16:31:39 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-01 16:32:20 >>>回调事件[910,devices/TL2180]
2024-10-01 16:32:20 >>>故障排除日志:上一MQTT订单号缓存列表为24100116310632582385
2024-10-01 16:32:20 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 16:32:20 开始打印,排队:156,票券:2410011631552150106101,订单:24100116315521495341,[2024-10-01 16:32:19微信支付10元]


===16:33:23===
2024-10-01 16:32:22 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011631552150106101","queue_number":156,"trade_uid":"24100116315521495341"}]}
2024-10-01 16:32:22 >>>故障排除日志:删除未同步下发订单成功24100116315521495341
2024-10-01 16:32:22 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


===17:00:24===
2024-10-01 16:59:41 >>>回调事件[910,devices/TL2180]
2024-10-01 16:59:41 >>>故障排除日志:上一MQTT订单号缓存列表为24100116533080239887
2024-10-01 16:59:41 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 16:59:41 开始打印,排队:161,票券:2410011659339300263501,订单:24100116593392998626,[2024-10-01 16:59:40微信支付10元]
2024-10-01 16:59:43 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011659339300263501","queue_number":161,"trade_uid":"24100116593392998626"}]}
2024-10-01 16:59:43 >>>故障排除日志:删除未同步下发订单成功24100116593392998626
2024-10-01 16:59:43 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-01 17:00:11 >>>回调事件[910,devices/TL2180]
2024-10-01 17:00:11 >>>故障排除日志:上一MQTT订单号缓存列表为24100116593392998626
2024-10-01 17:00:11 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 17:00:11 开始打印,排队:162,票券:2410011700040684459801,订单:24100117000406839656,[2024-10-01 17:00:11微信支付10元]
2024-10-01 17:00:13 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011700040684459801","queue_number":162,"trade_uid":"24100117000406839656"}]}
2024-10-01 17:00:13 >>>故障排除日志:删除未同步下发订单成功24100117000406839656
2024-10-01 17:00:14 >>>故障排除日志:终端同步成功后剩余订单列表


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


===17:13:25===
2024-10-01 17:12:51>>>cash read=0A
2024-10-01 17:12:52>>>cash read=3E


===17:19:25===
2024-10-01 17:18:25 >>>回调事件[910,devices/TL2180]
2024-10-01 17:18:25 >>>故障排除日志:上一MQTT订单号缓存列表为24100117051074164413
2024-10-01 17:18:25 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 17:18:25 开始打印,排队:164,票券:2410011718175625419401,订单:24100117181756248052,[2024-10-01 17:18:24微信支付10元]
2024-10-01 17:18:27 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011718175625419401","queue_number":164,"trade_uid":"24100117181756248052"}]}
2024-10-01 17:18:27 >>>故障排除日志:删除未同步下发订单成功24100117181756248052
2024-10-01 17:18:27 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-01 17:18:56>>>cash read=00
2024-10-01 17:18:56>>>cash read=818F43
2024-10-01 17:18:56>>>cash write=0f
2024-10-01 17:18:56 >>>回调事件130,cash_status,10024,识别到金额为20,面值不在接收范围内，正在退钞
2024-10-01 17:18:56>>>cash read=29
2024-10-01 17:18:56 >>>回调事件130,cash_status,20029,退钞中
2024-10-01 17:18:57>>>cash read=2F29
2024-10-01 17:18:59>>>cash write=0C
2024-10-01 17:18:59>>>cash read=3E
2024-10-01 17:19:09>>>cash read=29
2024-10-01 17:19:09 >>>回调事件130,cash_status,20029,退钞中
2024-10-01 17:19:09>>>cash read=2F29
2024-10-01 17:19:11>>>cash read=00
2024-10-01 17:19:12>>>cash read=818F42
2024-10-01 17:19:12>>>cash write=02
2024-10-01 17:19:12 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-01 17:19:13>>>cash read=10
2024-10-01 17:19:13 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-01 17:19:13 当前产品价格10元，投币10元，打印小票中...
2024-10-01 17:19:13 >>>开始打印,排队号为165,订单号为2410011719130021804735
2024-10-01 17:19:13>>>订单2410011719130021804735写入成功,剩余空间为1678500,占用RAM为617.9853515625
删除未同步订单2410011719130021804735
2024-10-01 17:19:15>>>订单2410011719130021804735删除成功,剩余空间为1679500,占用RAM为624.853515625
检测订单目录中>>>
无未同步订单>>>
2024-10-01 17:19:15 >>>当前Ram内存为594.3896484375
定时检测未同步订单启用
2024-10-01 17:19:16>>>cash write=0C
2024-10-01 17:19:16>>>cash read=3E


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


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


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


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


===17:31:27===
2024-10-01 17:31:24 >>>回调事件[910,devices/TL2180]
2024-10-01 17:31:24 >>>故障排除日志:上一MQTT订单号缓存列表为24100117293782917735
2024-10-01 17:31:24 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 17:31:24 开始打印,排队:169,票券:2410011731162837483401,订单:24100117311628371493,[2024-10-01 17:31:23微信支付10元]


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


===17:40:29===
2024-10-01 17:39:28>>>cash read=29
2024-10-01 17:39:28 >>>回调事件130,cash_status,20029,退钞中
2024-10-01 17:39:28>>>cash read=2F29
2024-10-01 17:39:29>>>cash read=01
2024-10-01 17:39:31>>>cash read=2F
2024-10-01 17:39:33>>>cash read=3E
2024-10-01 17:39:36>>>cash read=00
2024-10-01 17:39:37>>>cash read=818F42
2024-10-01 17:39:37>>>cash write=02
2024-10-01 17:39:37 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-01 17:39:37>>>cash read=10
2024-10-01 17:39:37 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-01 17:39:37 当前产品价格10元，投币10元，打印小票中...
2024-10-01 17:39:37 >>>开始打印,排队号为170,订单号为2410011739370021801158
2024-10-01 17:39:37>>>订单2410011739370021801158写入成功,剩余空间为1679500,占用RAM为611.5478515625
删除未同步订单2410011739370021801158
2024-10-01 17:39:39>>>订单2410011739370021801158删除成功,剩余空间为1680500,占用RAM为627.095703125
检测订单目录中>>>
无未同步订单>>>
2024-10-01 17:39:40 >>>当前Ram内存为592.9140625
定时检测未同步订单启用
2024-10-01 17:39:40>>>cash write=0C
2024-10-01 17:39:41>>>cash read=3E
2024-10-01 17:39:45>>>cash read=00
2024-10-01 17:39:46>>>cash read=2F29
2024-10-01 17:39:47>>>cash read=01
2024-10-01 17:39:48>>>cash read=2F
2024-10-01 17:39:49>>>cash read=3E
2024-10-01 17:39:53>>>cash read=00
2024-10-01 17:39:54>>>cash read=818F42
2024-10-01 17:39:54>>>cash write=02
2024-10-01 17:39:54 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-01 17:39:55>>>cash read=10
2024-10-01 17:39:55 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-01 17:39:55 当前产品价格10元，投币10元，打印小票中...
2024-10-01 17:39:55 >>>开始打印,排队号为171,订单号为2410011739550021803336
定时检测未同步订单关闭
2024-10-01 17:39:55>>>订单2410011739550021803336写入成功,剩余空间为1678500,占用RAM为619.267578125
删除未同步订单2410011739550021803336
2024-10-01 17:39:57>>>订单2410011739550021803336删除成功,剩余空间为1679000,占用RAM为625.7275390625
检测订单目录中>>>
无未同步订单>>>
2024-10-01 17:39:57 >>>当前Ram内存为593.509765625
定时检测未同步订单启用
2024-10-01 17:39:58>>>cash write=0C
2024-10-01 17:39:58>>>cash read=3E
2024-10-01 17:40:26 >>>回调事件[910,devices/TL2180]
2024-10-01 17:40:26 >>>故障排除日志:上一MQTT订单号缓存列表为24100117311628371493
2024-10-01 17:40:26 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 17:40:26 开始打印,排队:172,票券:2410011740162072516701,订单:24100117401620721456,[2024-10-01 17:40:25支付宝支付10元]


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


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


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


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


===17:57:30===
2024-10-01 17:56:32>>>cash read=00
2024-10-01 17:56:33>>>cash read=818F42
2024-10-01 17:56:33>>>cash write=02
2024-10-01 17:56:33 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-01 17:56:34>>>cash read=10
2024-10-01 17:56:34 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-01 17:56:34 当前产品价格10元，投币10元，打印小票中...
2024-10-01 17:56:34 >>>开始打印,排队号为178,订单号为2410011756340021802474
2024-10-01 17:56:34>>>订单2410011756340021802474写入成功,剩余空间为1680000,占用RAM为609.8720703125
删除未同步订单2410011756340021802474
2024-10-01 17:56:36>>>订单2410011756340021802474删除成功,剩余空间为1680500,占用RAM为620.6884765625
检测订单目录中>>>
无未同步订单>>>
2024-10-01 17:56:36 >>>当前Ram内存为592.5439453125
定时检测未同步订单启用
2024-10-01 17:56:37>>>cash write=0C
2024-10-01 17:56:37>>>cash read=3E


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


===18:00:31===
2024-10-01 18:00:09 >>>回调事件[910,devices/TL2180]
2024-10-01 18:00:09 >>>故障排除日志:上一MQTT订单号缓存列表为24100117544105770115
2024-10-01 18:00:09 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 18:00:09 开始打印,排队:179,票券:2410011800030704764301,订单:24100118000307043945,[2024-10-01 18:00:08微信支付10元]
2024-10-01 18:00:09 开始打印,排队:180,票券:2410011800030704899102,订单:24100118000307043945,[2024-10-01 18:00:08微信支付10元]
2024-10-01 18:00:13 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011800030704764301","queue_number":179,"trade_uid":"24100118000307043945"},{"ticket_no":"2410011800030704899102","queue_number":180,"trade_uid":"24100118000307043945"}]}
2024-10-01 18:00:13 >>>故障排除日志:删除未同步下发订单成功24100118000307043945
2024-10-01 18:00:13 >>>故障排除日志:删除未同步下发订单成功24100118000307043945
2024-10-01 18:00:13 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


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


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


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


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


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


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


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


===18:32:34===
2024-10-01 18:32:10>>>cash read=00
2024-10-01 18:32:11>>>cash read=29
2024-10-01 18:32:11 >>>回调事件130,cash_status,20029,退钞中
2024-10-01 18:32:12>>>cash read=2F29
2024-10-01 18:32:14>>>cash read=3E
2024-10-01 18:32:17>>>cash read=00
2024-10-01 18:32:18>>>cash read=292F29
2024-10-01 18:32:18 >>>回调事件130,cash_status,20029,退钞中
2024-10-01 18:32:20>>>cash read=3E
2024-10-01 18:32:24>>>cash read=00
2024-10-01 18:32:26>>>cash read=2F29
2024-10-01 18:32:28>>>cash read=3E
2024-10-01 18:32:31>>>cash read=00
2024-10-01 18:32:32>>>cash read=2F2901


===18:33:34===
2024-10-01 18:32:33>>>cash read=3E
2024-10-01 18:32:34>>>cash read=00
2024-10-01 18:32:36>>>cash read=818F42
2024-10-01 18:32:36>>>cash write=02
2024-10-01 18:32:36 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-01 18:32:36>>>cash read=10
2024-10-01 18:32:36 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-01 18:32:36 当前产品价格10元，投币10元，打印小票中...
2024-10-01 18:32:36 >>>开始打印,排队号为193,订单号为2410011832360021805972
2024-10-01 18:32:37>>>订单2410011832360021805972写入成功,剩余空间为1679500,占用RAM为610.3427734375
删除未同步订单2410011832360021805972
2024-10-01 18:32:39>>>订单2410011832360021805972删除成功,剩余空间为1680500,占用RAM为621.0458984375
检测订单目录中>>>
无未同步订单>>>
2024-10-01 18:32:39 >>>当前Ram内存为592.78515625
定时检测未同步订单启用
2024-10-01 18:32:40>>>cash write=0C
2024-10-01 18:32:40>>>cash read=3E


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


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


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


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


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


===18:45:35===
2024-10-01 18:44:50 >>>回调事件[910,devices/TL2180]
2024-10-01 18:44:50 >>>故障排除日志:上一MQTT订单号缓存列表为24100118400952164142
2024-10-01 18:44:50 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 18:44:50 开始打印,排队:199,票券:2410011844447979404901,订单:24100118444479789219,[2024-10-01 18:44:49支付宝支付10元]
2024-10-01 18:44:50 开始打印,排队:200,票券:2410011844447979597302,订单:24100118444479789219,[2024-10-01 18:44:49支付宝支付10元]
2024-10-01 18:44:54 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011844447979404901","queue_number":199,"trade_uid":"24100118444479789219"},{"ticket_no":"2410011844447979597302","queue_number":200,"trade_uid":"24100118444479789219"}]}
2024-10-01 18:44:54 >>>故障排除日志:删除未同步下发订单成功24100118444479789219
2024-10-01 18:44:54 >>>故障排除日志:删除未同步下发订单成功24100118444479789219
2024-10-01 18:44:54 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


===18:50:36===
2024-10-01 18:50:21 >>>回调事件[910,devices/TL2180]
2024-10-01 18:50:21 >>>故障排除日志:上一MQTT订单号缓存列表为24100118481239610326
2024-10-01 18:50:21 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 18:50:21 开始打印,排队:203,票券:2410011850147764549101,订单:24100118501477636573,[2024-10-01 18:50:20微信支付10元]
2024-10-01 18:50:23 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011850147764549101","queue_number":203,"trade_uid":"24100118501477636573"}]}
2024-10-01 18:50:23 >>>故障排除日志:删除未同步下发订单成功24100118501477636573
2024-10-01 18:50:23 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-01 18:50:30 >>>回调事件[910,devices/TL2180]
2024-10-01 18:50:30 >>>故障排除日志:上一MQTT订单号缓存列表为24100118501477636573
2024-10-01 18:50:30 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 18:50:31 开始打印,排队:204,票券:2410011850242794978701,订单:24100118502427946124,[2024-10-01 18:50:30微信支付10元]
2024-10-01 18:50:33 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011850242794978701","queue_number":204,"trade_uid":"24100118502427946124"}]}
2024-10-01 18:50:33 >>>故障排除日志:删除未同步下发订单成功24100118502427946124
2024-10-01 18:50:33 >>>故障排除日志:终端同步成功后剩余订单列表


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


===18:55:37===
2024-10-01 18:54:41 >>>回调事件[910,devices/TL2180]
2024-10-01 18:54:41 >>>故障排除日志:上一MQTT订单号缓存列表为24100118503904605953
2024-10-01 18:54:41 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 18:54:41 开始打印,排队:206,票券:2410011854348592267401,订单:24100118543485916492,[2024-10-01 18:54:40微信支付10元]
2024-10-01 18:54:43 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011854348592267401","queue_number":206,"trade_uid":"24100118543485916492"}]}
2024-10-01 18:54:43 >>>故障排除日志:删除未同步下发订单成功24100118543485916492
2024-10-01 18:54:43 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-01 18:55:18>>>cash read=00
2024-10-01 18:55:19>>>cash read=818F42
2024-10-01 18:55:19>>>cash write=02
2024-10-01 18:55:19 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-01 18:55:20>>>cash read=10
2024-10-01 18:55:20 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-01 18:55:20 当前产品价格10元，投币10元，打印小票中...
2024-10-01 18:55:20 >>>开始打印,排队号为207,订单号为2410011855200021804530
2024-10-01 18:55:20>>>订单2410011855200021804530写入成功,剩余空间为1679000,占用RAM为613.5712890625
删除未同步订单2410011855200021804530
2024-10-01 18:55:22>>>订单2410011855200021804530删除成功,剩余空间为1680000,占用RAM为624.2060546875
检测订单目录中>>>
无未同步订单>>>
2024-10-01 18:55:22 >>>当前Ram内存为592.728515625
定时检测未同步订单启用
2024-10-01 18:55:23>>>cash write=0C
2024-10-01 18:55:23>>>cash read=3E


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


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


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


===19:01:38===
2024-10-01 19:01:04 >>>回调事件[910,devices/TL2180]
2024-10-01 19:01:04 >>>故障排除日志:上一MQTT订单号缓存列表为24100118590057167094
2024-10-01 19:01:04 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 19:01:04 开始打印,排队:212,票券:2410011900575823612801,订单:24100119005758231958,[2024-10-01 19:01:03微信支付10元]
2024-10-01 19:01:06 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011900575823612801","queue_number":212,"trade_uid":"24100119005758231958"}]}
2024-10-01 19:01:06 >>>故障排除日志:删除未同步下发订单成功24100119005758231958
2024-10-01 19:01:06 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-01 19:01:36>>>cash read=29
2024-10-01 19:01:36 >>>回调事件130,cash_status,20029,退钞中


===19:02:38===
2024-10-01 19:01:37>>>cash read=01
2024-10-01 19:01:42>>>cash read=3E
2024-10-01 19:01:43>>>cash read=29
2024-10-01 19:01:43 >>>回调事件130,cash_status,20029,退钞中
2024-10-01 19:01:44>>>cash read=01
2024-10-01 19:02:04>>>cash read=3E
2024-10-01 19:02:06>>>cash read=29
2024-10-01 19:02:06 >>>回调事件130,cash_status,20029,退钞中
2024-10-01 19:02:06>>>cash read=2F29
2024-10-01 19:02:08>>>cash read=01
2024-10-01 19:02:11>>>cash read=2F
2024-10-01 19:02:13>>>cash read=00
2024-10-01 19:02:14>>>cash read=2F29
2024-10-01 19:02:15>>>cash read=01
2024-10-01 19:02:16>>>cash read=2F
2024-10-01 19:02:17>>>cash read=3E
2024-10-01 19:02:18>>>cash read=29
2024-10-01 19:02:18 >>>回调事件130,cash_status,20029,退钞中
2024-10-01 19:02:18>>>cash read=2F29
2024-10-01 19:02:19>>>cash read=01
2024-10-01 19:02:23>>>cash read=2F
2024-10-01 19:02:24>>>cash read=00
2024-10-01 19:02:25>>>cash read=818F42
2024-10-01 19:02:25>>>cash write=02
2024-10-01 19:02:25 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-01 19:02:25>>>cash read=10
2024-10-01 19:02:25 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-01 19:02:25 当前产品价格10元，投币10元，打印小票中...
2024-10-01 19:02:25 >>>开始打印,排队号为213,订单号为2410011902250021802390
2024-10-01 19:02:26>>>订单2410011902250021802390写入成功,剩余空间为1679000,占用RAM为613.35546875
删除未同步订单2410011902250021802390
2024-10-01 19:02:28>>>订单2410011902250021802390删除成功,剩余空间为1680000,占用RAM为623.5009765625
检测订单目录中>>>
无未同步订单>>>
2024-10-01 19:02:28 >>>当前Ram内存为593.8759765625
定时检测未同步订单启用
2024-10-01 19:02:29>>>cash write=0C
2024-10-01 19:02:29>>>cash read=3E


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


===19:05:39===
2024-10-01 19:04:43>>>cash read=29
2024-10-01 19:04:43 >>>回调事件130,cash_status,20029,退钞中
2024-10-01 19:04:44>>>cash read=01
2024-10-01 19:04:48>>>cash read=3E
2024-10-01 19:04:51>>>cash read=29
2024-10-01 19:04:51 >>>回调事件130,cash_status,20029,退钞中
2024-10-01 19:04:52>>>cash read=01
2024-10-01 19:04:53>>>cash read=3E
2024-10-01 19:04:54>>>cash read=29
2024-10-01 19:04:54 >>>回调事件130,cash_status,20029,退钞中
2024-10-01 19:04:56>>>cash read=01
2024-10-01 19:04:57>>>cash read=3E
2024-10-01 19:04:59>>>cash read=00
2024-10-01 19:05:00>>>cash read=29
2024-10-01 19:05:00 >>>回调事件130,cash_status,20029,退钞中
2024-10-01 19:05:01>>>cash read=01
2024-10-01 19:05:03>>>cash read=3E
2024-10-01 19:05:04>>>cash read=00
2024-10-01 19:05:05>>>cash read=01
2024-10-01 19:05:06>>>cash read=3E
2024-10-01 19:05:07>>>cash read=00
2024-10-01 19:05:08>>>cash read=29
2024-10-01 19:05:08 >>>回调事件130,cash_status,20029,退钞中
2024-10-01 19:05:08>>>cash read=2F29
2024-10-01 19:05:10>>>cash read=3E
2024-10-01 19:05:34 >>>回调事件[910,devices/TL2180]
2024-10-01 19:05:34 >>>故障排除日志:上一MQTT订单号缓存列表为24100119025906740438
2024-10-01 19:05:34 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 19:05:34 开始打印,排队:215,票券:2410011905276983936401,订单:24100119052769835925,[2024-10-01 19:05:33微信支付10元]
2024-10-01 19:05:36 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011905276983936401","queue_number":215,"trade_uid":"24100119052769835925"}]}
2024-10-01 19:05:36 >>>故障排除日志:删除未同步下发订单成功24100119052769835925
2024-10-01 19:05:37 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


===19:17:40===
2024-10-01 19:17:06 >>>回调事件[910,devices/TL2180]
2024-10-01 19:17:06 >>>故障排除日志:上一MQTT订单号缓存列表为24100119141005343237
2024-10-01 19:17:06 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 19:17:06 开始打印,排队:219,票券:2410011916592639211301,订单:24100119165926388538,[2024-10-01 19:17:04微信支付10元]
2024-10-01 19:17:07 >>>回调事件[910,devices/TL2180]
2024-10-01 19:17:07 >>>故障排除日志:上一MQTT订单号缓存列表为24100119165926388538
2024-10-01 19:17:07 >>>故障排除日志:终端未同步成功订单列表021924100119165926388538
已接收过此消息,票券号为2410011916592639211301,排队号为219
2024-10-01 19:17:07 开始打印,排队:220,票券:2410011916595741556401,订单:24100119165957411047,[2024-10-01 19:17:06微信支付10元]
2024-10-01 19:17:08 开始打印,排队:221,票券:2410011916595741692802,订单:24100119165957411047,[2024-10-01 19:17:06微信支付10元]
2024-10-01 19:17:11 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011916592639211301","queue_number":219,"trade_uid":"24100119165926388538"}]}
2024-10-01 19:17:11 >>>故障排除日志:删除未同步下发订单成功24100119165926388538
2024-10-01 19:17:11 >>>故障排除日志:终端同步成功后剩余订单列表022024100119165957411047|022124100119165957411047
2024-10-01 19:17:11 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011916592639211301","queue_number":219,"trade_uid":"24100119165926388538"},{"ticket_no":"2410011916595741556401","queue_number":220,"trade_uid":"24100119165957411047"},{"ticket_no":"2410011916595741692802","queue_number":221,"trade_uid":"24100119165957411047"}]}
2024-10-01 19:17:11 >>>故障排除日志:删除未同步下发订单成功24100119165957411047
2024-10-01 19:17:11 >>>故障排除日志:删除未同步下发订单成功24100119165957411047
2024-10-01 19:17:11 >>>故障排除日志:终端同步成功后剩余订单列表


===19:21:40===
2024-10-01 19:21:14 >>>回调事件[910,devices/TL2180]
2024-10-01 19:21:14 >>>故障排除日志:上一MQTT订单号缓存列表为24100119165926388538|24100119165957411047|24100119165957411047
2024-10-01 19:21:14 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 19:21:14 开始打印,排队:222,票券:2410011921080045988901,订单:24100119210800456254,[2024-10-01 19:21:13微信支付10元]
2024-10-01 19:21:16 >>>回调事件[910,devices/TL2180]
2024-10-01 19:21:16 >>>故障排除日志:上一MQTT订单号缓存列表为24100119210800456254
2024-10-01 19:21:16 >>>故障排除日志:终端未同步成功订单列表022224100119210800456254
已接收过此消息,票券号为2410011921080045988901,排队号为222
2024-10-01 19:21:16 开始打印,排队:223,票券:2410011921092717316401,订单:24100119210927169693,[2024-10-01 19:21:15微信支付10元]
2024-10-01 19:21:16 开始打印,排队:224,票券:2410011921092717444102,订单:24100119210927169693,[2024-10-01 19:21:15微信支付10元]
2024-10-01 19:21:19 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011921080045988901","queue_number":222,"trade_uid":"24100119210800456254"}]}
2024-10-01 19:21:19 >>>故障排除日志:删除未同步下发订单成功24100119210800456254
2024-10-01 19:21:20 >>>故障排除日志:终端同步成功后剩余订单列表022324100119210927169693|022424100119210927169693
2024-10-01 19:21:20 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011921080045988901","queue_number":222,"trade_uid":"24100119210800456254"},{"ticket_no":"2410011921092717316401","queue_number":223,"trade_uid":"24100119210927169693"},{"ticket_no":"2410011921092717444102","queue_number":224,"trade_uid":"24100119210927169693"}]}
2024-10-01 19:21:20 >>>故障排除日志:删除未同步下发订单成功24100119210927169693
2024-10-01 19:21:20 >>>故障排除日志:删除未同步下发订单成功24100119210927169693
2024-10-01 19:21:20 >>>故障排除日志:终端同步成功后剩余订单列表


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


===19:26:41===
2024-10-01 19:26:09>>>cash read=0A
2024-10-01 19:26:10>>>cash read=3E


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


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


===19:41:44===
2024-10-01 19:41:28 >>>回调事件[910,devices/TL2180]
2024-10-01 19:41:28 >>>故障排除日志:上一MQTT订单号缓存列表为24100119352945443578
2024-10-01 19:41:28 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 19:41:28 开始打印,排队:228,票券:2410011941217097093701,订单:24100119412170946773,[2024-10-01 19:41:27微信支付10元]
2024-10-01 19:41:30 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011941217097093701","queue_number":228,"trade_uid":"24100119412170946773"}]}
2024-10-01 19:41:30 >>>故障排除日志:删除未同步下发订单成功24100119412170946773
2024-10-01 19:41:30 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-01 19:41:39 >>>回调事件[910,devices/TL2180]
2024-10-01 19:41:39 >>>故障排除日志:上一MQTT订单号缓存列表为24100119412170946773
2024-10-01 19:41:39 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 19:41:39 开始打印,排队:229,票券:2410011941333420034301,订单:24100119413334195915,[2024-10-01 19:41:38微信支付10元]
2024-10-01 19:41:39 开始打印,排队:230,票券:2410011941333420219402,订单:24100119413334195915,[2024-10-01 19:41:38微信支付10元]


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


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


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


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


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


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


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


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


===19:56:46===
2024-10-01 19:56:19>>>cash read=0A
2024-10-01 19:56:21>>>cash read=3E


===19:59:46===
2024-10-01 19:58:59 >>>回调事件[910,devices/TL2180]
2024-10-01 19:58:59 >>>故障排除日志:上一MQTT订单号缓存列表为24100119544185603798
2024-10-01 19:58:59 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 19:58:59 开始打印,排队:240,票券:2410011958470421525101,订单:24100119584704210419,[2024-10-01 19:58:58微信支付10元]
2024-10-01 19:59:01 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410011958470421525101","queue_number":240,"trade_uid":"24100119584704210419"}]}
2024-10-01 19:59:01 >>>故障排除日志:删除未同步下发订单成功24100119584704210419
2024-10-01 19:59:02 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-01 19:59:20>>>cash read=0A
2024-10-01 19:59:21>>>cash read=3E


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


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


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


===20:14:47===
2024-10-01 20:13:59 >>>回调事件[910,devices/TL2180]
2024-10-01 20:13:59 >>>故障排除日志:上一MQTT订单号缓存列表为24100120122028116994
2024-10-01 20:13:59 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 20:13:59 开始打印,排队:244,票券:2410012013484015601601,订单:24100120134840151748,[2024-10-01 20:13:57微信支付10元]
2024-10-01 20:13:59 开始打印,排队:245,票券:2410012013484015766702,订单:24100120134840151748,[2024-10-01 20:13:57微信支付10元]
2024-10-01 20:14:02 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410012013484015601601","queue_number":244,"trade_uid":"24100120134840151748"},{"ticket_no":"2410012013484015766702","queue_number":245,"trade_uid":"24100120134840151748"}]}
2024-10-01 20:14:02 >>>故障排除日志:删除未同步下发订单成功24100120134840151748
2024-10-01 20:14:02 >>>故障排除日志:删除未同步下发订单成功24100120134840151748
2024-10-01 20:14:02 >>>故障排除日志:终端同步成功后剩余订单列表


===20:19:48===
2024-10-01 20:19:00>>>cash read=00
2024-10-01 20:19:01>>>cash read=818F42
2024-10-01 20:19:01>>>cash write=02
2024-10-01 20:19:01 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-01 20:19:02>>>cash read=10
2024-10-01 20:19:02 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-01 20:19:02 当前产品价格10元，投币10元，打印小票中...
2024-10-01 20:19:02 >>>开始打印,排队号为246,订单号为2410012019020021809512
2024-10-01 20:19:02>>>订单2410012019020021809512写入成功,剩余空间为1680000,占用RAM为609.9326171875
删除未同步订单2410012019020021809512
2024-10-01 20:19:04>>>订单2410012019020021809512删除成功,剩余空间为1680500,占用RAM为624.279296875
检测订单目录中>>>
无未同步订单>>>
2024-10-01 20:19:04 >>>当前Ram内存为594.1962890625
定时检测未同步订单启用
2024-10-01 20:19:05>>>cash write=0C
2024-10-01 20:19:05>>>cash read=3E
2024-10-01 20:19:13>>>cash read=00
2024-10-01 20:19:15>>>cash read=2F29
2024-10-01 20:19:16>>>cash read=00
2024-10-01 20:19:17>>>cash read=292F29
2024-10-01 20:19:17 >>>回调事件130,cash_status,20029,退钞中
2024-10-01 20:19:19>>>cash read=3E
2024-10-01 20:19:20>>>cash read=00
2024-10-01 20:19:21>>>cash read=2F29
2024-10-01 20:19:22>>>cash read=00
2024-10-01 20:19:23>>>cash read=2F29
2024-10-01 20:19:24>>>cash read=00
2024-10-01 20:19:25>>>cash read=2F29
2024-10-01 20:19:26>>>cash read=3E
2024-10-01 20:19:33 >>>回调事件[910,devices/TL2180]
2024-10-01 20:19:33 >>>故障排除日志:上一MQTT订单号缓存列表为24100120134840151748|24100120134840151748
2024-10-01 20:19:33 >>>故障排除日志:终端未同步成功订单列表
2024-10-01 20:19:33 开始打印,排队:247,票券:2410012019264672678401,订单:24100120192646720652,[2024-10-01 20:19:32微信支付10元]
2024-10-01 20:19:35 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410012019264672678401","queue_number":247,"trade_uid":"24100120192646720652"}]}
2024-10-01 20:19:35 >>>故障排除日志:删除未同步下发订单成功24100120192646720652
2024-10-01 20:19:35 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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