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

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

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

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


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


===08:26:14===
2024-10-07 08:25:59 >>>回调事件[910,devices/TL2180]
当日首次设置时间戳true为1728260759
2024-10-07 08:25:59 >>>故障排除日志:上一MQTT订单号缓存列表为24100620401506176587
2024-10-07 08:25:59 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 08:25:59 开始打印,排队:1,票券:2410070825523744826801,订单:24100708255237444586,[2024-10-07 08:25:59支付宝支付10元]
2024-10-07 08:26:01 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410070825523744826801","queue_number":1,"trade_uid":"24100708255237444586"}]}
2024-10-07 08:26:01 >>>故障排除日志:删除未同步下发订单成功24100708255237444586
2024-10-07 08:26:01 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


===12:33:22===
2024-10-07 12:33:21>>>cash read=00


===12:34:23===
2024-10-07 12:33:22>>>cash read=29
2024-10-07 12:33:22 >>>回调事件130,cash_status,20029,退钞中
2024-10-07 12:33:22>>>cash read=2F29
2024-10-07 12:33:23>>>cash read=3E
2024-10-07 12:33:27>>>cash read=00
2024-10-07 12:33:28>>>cash read=29
2024-10-07 12:33:28 >>>回调事件130,cash_status,20029,退钞中
2024-10-07 12:33:28>>>cash read=2F292F
2024-10-07 12:33:29>>>cash read=00
2024-10-07 12:33:30>>>cash read=292F29
2024-10-07 12:33:30 >>>回调事件130,cash_status,20029,退钞中
2024-10-07 12:33:32>>>cash read=3E
2024-10-07 12:33:33>>>cash read=00
2024-10-07 12:33:34>>>cash read=29
2024-10-07 12:33:34 >>>回调事件130,cash_status,20029,退钞中
2024-10-07 12:33:34>>>cash read=2F29
2024-10-07 12:33:36>>>cash read=00
2024-10-07 12:33:37>>>cash read=292F29
2024-10-07 12:33:37 >>>回调事件130,cash_status,20029,退钞中
2024-10-07 12:33:38>>>cash read=3E
2024-10-07 12:33:39>>>cash read=00
2024-10-07 12:33:40>>>cash read=29
2024-10-07 12:33:40 >>>回调事件130,cash_status,20029,退钞中
2024-10-07 12:33:40>>>cash read=2F29
2024-10-07 12:33:42>>>cash read=3E
2024-10-07 12:33:56>>>cash read=00
2024-10-07 12:33:56>>>cash read=818F42
2024-10-07 12:33:56>>>cash write=02
2024-10-07 12:33:56 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-07 12:33:57>>>cash read=10
2024-10-07 12:33:57 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-07 12:33:57 当前产品价格10元，投币10元，打印小票中...
2024-10-07 12:33:57 >>>开始打印,排队号为32,订单号为2410071233570021807884
2024-10-07 12:33:57>>>订单2410071233570021807884写入成功,剩余空间为1678500,占用RAM为613.8935546875
删除未同步订单2410071233570021807884
2024-10-07 12:33:59>>>订单2410071233570021807884删除成功,剩余空间为1679500,占用RAM为621.375
检测订单目录中>>>
无未同步订单>>>
2024-10-07 12:33:59 >>>当前Ram内存为591.4326171875
定时检测未同步订单启用
2024-10-07 12:34:00>>>cash write=0C
2024-10-07 12:34:00>>>cash read=3E


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


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


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


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


===13:07:24===
2024-10-07 13:06:44>>>cash read=00
2024-10-07 13:06:46>>>cash read=29
2024-10-07 13:06:46 >>>回调事件130,cash_status,20029,退钞中
2024-10-07 13:06:46>>>cash read=2F29
2024-10-07 13:06:48>>>cash read=3E
2024-10-07 13:06:49>>>cash read=00
2024-10-07 13:06:50>>>cash read=2F29
2024-10-07 13:06:51>>>cash read=3E
2024-10-07 13:06:58>>>cash read=00
2024-10-07 13:06:59>>>cash read=29
2024-10-07 13:06:59 >>>回调事件130,cash_status,20029,退钞中
2024-10-07 13:06:59>>>cash read=2F29
2024-10-07 13:07:00>>>cash read=3E
2024-10-07 13:07:02>>>cash read=292F29
2024-10-07 13:07:02 >>>回调事件130,cash_status,20029,退钞中
2024-10-07 13:07:04>>>cash read=00
2024-10-07 13:07:05>>>cash read=2F29
2024-10-07 13:07:06>>>cash read=3E
2024-10-07 13:07:11>>>cash read=00
2024-10-07 13:07:12>>>cash read=818F42
2024-10-07 13:07:12>>>cash write=02
2024-10-07 13:07:12 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-07 13:07:13>>>cash read=10
2024-10-07 13:07:13 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-07 13:07:13 当前产品价格10元，投币10元，打印小票中...
2024-10-07 13:07:13 >>>开始打印,排队号为37,订单号为2410071307130021802582
2024-10-07 13:07:13>>>订单2410071307130021802582写入成功,剩余空间为1679000,占用RAM为611.3642578125
删除未同步订单2410071307130021802582
2024-10-07 13:07:15>>>订单2410071307130021802582删除成功,剩余空间为1680000,占用RAM为620.0087890625
检测订单目录中>>>
无未同步订单>>>
2024-10-07 13:07:15 >>>当前Ram内存为590.591796875
定时检测未同步订单启用
2024-10-07 13:07:16>>>cash write=0C
2024-10-07 13:07:16>>>cash read=3E


===13:08:25===
2024-10-07 13:07:38 >>>回调事件[910,devices/TL2180]
2024-10-07 13:07:38 >>>故障排除日志:上一MQTT订单号缓存列表为24100712580844246642
2024-10-07 13:07:38 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 13:07:38 开始打印,排队:38,票券:2410071307298360397601,订单:24100713072983599169,[2024-10-07 13:07:37微信支付10元]
2024-10-07 13:07:40 >>>回调事件[910,devices/TL2180]
2024-10-07 13:07:40 >>>故障排除日志:上一MQTT订单号缓存列表为24100713072983599169
2024-10-07 13:07:40 >>>故障排除日志:终端未同步成功订单列表003824100713072983599169
已接收过此消息,票券号为2410071307298360397601,排队号为38
2024-10-07 13:07:40 开始打印,排队:39,票券:2410071307334164928701,订单:24100713073341644915,[2024-10-07 13:07:40微信支付10元]
2024-10-07 13:07:42 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410071307298360397601","queue_number":38,"trade_uid":"24100713072983599169"}]}
2024-10-07 13:07:42 >>>故障排除日志:删除未同步下发订单成功24100713072983599169
2024-10-07 13:07:42 >>>故障排除日志:终端同步成功后剩余订单列表003924100713073341644915
2024-10-07 13:07:42 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410071307298360397601","queue_number":38,"trade_uid":"24100713072983599169"},{"ticket_no":"2410071307334164928701","queue_number":39,"trade_uid":"24100713073341644915"}]}
2024-10-07 13:07:42 >>>故障排除日志:删除未同步下发订单成功24100713073341644915
2024-10-07 13:07:43 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单关闭
检测订单目录中>>>
无未同步订单>>>


===13:10:25===
2024-10-07 13:09:50 >>>回调事件[910,devices/TL2180]
2024-10-07 13:09:50 >>>故障排除日志:上一MQTT订单号缓存列表为24100713072983599169|24100713073341644915
2024-10-07 13:09:50 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 13:09:50 开始打印,排队:40,票券:2410071309437314075701,订单:24100713094373137028,[2024-10-07 13:09:50支付宝支付10元]
2024-10-07 13:09:50 开始打印,排队:41,票券:2410071309437314217902,订单:24100713094373137028,[2024-10-07 13:09:50支付宝支付10元]
2024-10-07 13:09:54 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410071309437314075701","queue_number":40,"trade_uid":"24100713094373137028"},{"ticket_no":"2410071309437314217902","queue_number":41,"trade_uid":"24100713094373137028"}]}
2024-10-07 13:09:54 >>>故障排除日志:删除未同步下发订单成功24100713094373137028
2024-10-07 13:09:54 >>>故障排除日志:删除未同步下发订单成功24100713094373137028
2024-10-07 13:09:54 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


===13:36:26===
2024-10-07 13:35:40>>>cash read=00
2024-10-07 13:35:41>>>cash read=818F41
2024-10-07 13:35:41>>>cash write=02
2024-10-07 13:35:41 >>>回调事件130,cash_status,10022,进钞中...read money=5
2024-10-07 13:35:42>>>cash read=10
2024-10-07 13:35:42 >>>回调事件130,5,10023,finish Money=5,进钞完成
2024-10-07 13:35:43>>>cash write=0C
2024-10-07 13:35:43>>>cash read=00
2024-10-07 13:35:44>>>cash read=818F41
2024-10-07 13:35:44>>>cash write=02
2024-10-07 13:35:44 >>>回调事件130,cash_status,10022,进钞中...read money=5
2024-10-07 13:35:44>>>cash read=10
2024-10-07 13:35:44 >>>回调事件130,5,10023,finish Money=5,进钞完成
2024-10-07 13:35:44 当前产品价格10元，投币10元，打印小票中...
2024-10-07 13:35:44 >>>开始打印,排队号为45,订单号为2410071335420021804665
2024-10-07 13:35:44>>>订单2410071335420021804665写入成功,剩余空间为1679500,占用RAM为606.953125
删除未同步订单2410071335420021804665
2024-10-07 13:35:47>>>订单2410071335420021804665删除成功,剩余空间为1680500,占用RAM为620.25
检测订单目录中>>>
无未同步订单>>>
2024-10-07 13:35:47 >>>当前Ram内存为590.3388671875
定时检测未同步订单启用
2024-10-07 13:35:47>>>cash write=0C
2024-10-07 13:35:48>>>cash read=3E


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


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


===13:50:27===
2024-10-07 13:49:39>>>cash read=9E
2024-10-07 13:49:40>>>cash read=3E


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


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


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


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


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


===14:13:28===
2024-10-07 14:13:18>>>cash read=29
2024-10-07 14:13:18 >>>回调事件130,cash_status,20029,退钞中
2024-10-07 14:13:18>>>cash read=2F29
2024-10-07 14:13:19>>>cash read=01
2024-10-07 14:13:21>>>cash read=2F
2024-10-07 14:13:22>>>cash read=3E
2024-10-07 14:13:23>>>cash read=00
2024-10-07 14:13:23>>>cash read=818F42
2024-10-07 14:13:23>>>cash write=02
2024-10-07 14:13:23 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-07 14:13:24>>>cash read=10
2024-10-07 14:13:24 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-07 14:13:24 当前产品价格10元，投币10元，打印小票中...
2024-10-07 14:13:24 >>>开始打印,排队号为51,订单号为2410071413240021808255
2024-10-07 14:13:24>>>订单2410071413240021808255写入成功,剩余空间为1679500,占用RAM为609.1669921875
删除未同步订单2410071413240021808255
2024-10-07 14:13:26>>>订单2410071413240021808255删除成功,剩余空间为1680500,占用RAM为619.2392578125
检测订单目录中>>>
无未同步订单>>>
2024-10-07 14:13:26 >>>当前Ram内存为590.66796875
定时检测未同步订单启用


===14:14:28===
2024-10-07 14:13:27>>>cash write=0C
2024-10-07 14:13:27>>>cash read=3E
2024-10-07 14:13:53 >>>回调事件[910,devices/TL2180]
2024-10-07 14:13:53 >>>故障排除日志:上一MQTT订单号缓存列表为24100714020785448968
2024-10-07 14:13:53 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 14:13:53 开始打印,排队:52,票券:2410071413459481478201,订单:24100714134594810653,[2024-10-07 14:13:52微信支付10元]
2024-10-07 14:13:53 开始打印,排队:53,票券:2410071413459481616102,订单:24100714134594810653,[2024-10-07 14:13:52微信支付10元]
2024-10-07 14:13:56 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410071413459481478201","queue_number":52,"trade_uid":"24100714134594810653"},{"ticket_no":"2410071413459481616102","queue_number":53,"trade_uid":"24100714134594810653"}]}
2024-10-07 14:13:56 >>>故障排除日志:删除未同步下发订单成功24100714134594810653
2024-10-07 14:13:56 >>>故障排除日志:删除未同步下发订单成功24100714134594810653
2024-10-07 14:13:57 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单关闭
检测订单目录中>>>
无未同步订单>>>


===14:18:29===
2024-10-07 14:18:25 >>>回调事件[910,devices/TL2180]
2024-10-07 14:18:25 >>>故障排除日志:上一MQTT订单号缓存列表为24100714134594810653|24100714134594810653
2024-10-07 14:18:25 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 14:18:25 开始打印,排队:54,票券:2410071418172233264601,订单:24100714181722328193,[2024-10-07 14:18:25微信支付10元]


===14:41:29===
2024-10-07 14:41:17>>>cash read=00
2024-10-07 14:41:17>>>cash read=2F29
2024-10-07 14:41:18>>>cash read=01
2024-10-07 14:41:19>>>cash read=2F
2024-10-07 14:41:20>>>cash read=3E
2024-10-07 14:41:21>>>cash read=00
2024-10-07 14:41:22>>>cash read=818F42
2024-10-07 14:41:22>>>cash write=02
2024-10-07 14:41:22 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-07 14:41:23>>>cash read=10
2024-10-07 14:41:23 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-07 14:41:23 当前产品价格10元，投币10元，打印小票中...
2024-10-07 14:41:23 >>>开始打印,排队号为55,订单号为2410071441230021803203
2024-10-07 14:41:23>>>订单2410071441230021803203写入成功,剩余空间为1679500,占用RAM为608.572265625
删除未同步订单2410071441230021803203
2024-10-07 14:41:25>>>订单2410071441230021803203删除成功,剩余空间为1680500,占用RAM为618.7236328125
检测订单目录中>>>
无未同步订单>>>
2024-10-07 14:41:25 >>>当前Ram内存为590.251953125
定时检测未同步订单启用
2024-10-07 14:41:26>>>cash write=0C
2024-10-07 14:41:26>>>cash read=3E


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


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


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


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


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


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


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


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


===15:09:32===
2024-10-07 15:09:14>>>cash read=29
2024-10-07 15:09:14 >>>回调事件130,cash_status,20029,退钞中
2024-10-07 15:09:15>>>cash read=01
2024-10-07 15:09:17>>>cash read=00
2024-10-07 15:09:18>>>cash read=818F42
2024-10-07 15:09:18>>>cash write=02
2024-10-07 15:09:18 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-07 15:09:18>>>cash read=10
2024-10-07 15:09:18 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-07 15:09:18 当前产品价格10元，投币10元，打印小票中...
2024-10-07 15:09:18 >>>开始打印,排队号为63,订单号为2410071509180021806460
2024-10-07 15:09:18>>>订单2410071509180021806460写入成功,剩余空间为1679500,占用RAM为608.1337890625
删除未同步订单2410071509180021806460
2024-10-07 15:09:21>>>订单2410071509180021806460删除成功,剩余空间为1680500,占用RAM为618.609375
检测订单目录中>>>
无未同步订单>>>
2024-10-07 15:09:21 >>>当前Ram内存为590.16796875
定时检测未同步订单启用
2024-10-07 15:09:22>>>cash write=0C
2024-10-07 15:09:22>>>cash read=00
2024-10-07 15:09:22>>>cash read=818F42
2024-10-07 15:09:22>>>cash write=02
2024-10-07 15:09:22 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-07 15:09:23>>>cash read=10
2024-10-07 15:09:23 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-07 15:09:23 当前产品价格10元，投币10元，打印小票中...
2024-10-07 15:09:23 >>>开始打印,排队号为64,订单号为2410071509230021809389
定时检测未同步订单关闭
2024-10-07 15:09:23>>>订单2410071509230021809389写入成功,剩余空间为1678500,占用RAM为615.609375
删除未同步订单2410071509230021809389
2024-10-07 15:09:25>>>订单2410071509230021809389删除成功,剩余空间为1679500,占用RAM为621.2861328125
检测订单目录中>>>
无未同步订单>>>
2024-10-07 15:09:25 >>>当前Ram内存为591.6142578125
定时检测未同步订单启用
2024-10-07 15:09:26>>>cash write=0C
2024-10-07 15:09:26>>>cash read=3E


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


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


===15:19:32===
2024-10-07 15:18:36 >>>回调事件[910,devices/TL2180]
2024-10-07 15:18:36 >>>故障排除日志:上一MQTT订单号缓存列表为24100715182188416951
2024-10-07 15:18:36 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 15:18:36 开始打印,排队:66,票券:2410071518317721429501,订单:24100715183177206927,[2024-10-07 15:18:36微信支付10元]
2024-10-07 15:18:38 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410071518317721429501","queue_number":66,"trade_uid":"24100715183177206927"}]}
2024-10-07 15:18:38 >>>故障排除日志:删除未同步下发订单成功24100715183177206927
2024-10-07 15:18:38 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-07 15:18:53>>>cash read=00
2024-10-07 15:18:54>>>cash read=818F42
2024-10-07 15:18:54>>>cash write=02
2024-10-07 15:18:54 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-07 15:18:54>>>cash read=10
2024-10-07 15:18:54 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-07 15:18:54 当前产品价格10元，投币10元，打印小票中...
2024-10-07 15:18:54 >>>开始打印,排队号为67,订单号为2410071518540021802319
2024-10-07 15:18:54>>>订单2410071518540021802319写入成功,剩余空间为1679000,占用RAM为609.0458984375
删除未同步订单2410071518540021802319
2024-10-07 15:18:56>>>订单2410071518540021802319删除成功,剩余空间为1680000,占用RAM为619.759765625
检测订单目录中>>>
无未同步订单>>>
2024-10-07 15:18:57 >>>当前Ram内存为590.1513671875
定时检测未同步订单启用
2024-10-07 15:18:57>>>cash write=0C
2024-10-07 15:18:57>>>cash read=3E


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


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


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


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


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


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


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


===16:11:35===
2024-10-07 16:10:44>>>cash read=2F29
2024-10-07 16:10:45>>>cash read=01
2024-10-07 16:10:46>>>cash read=2F
2024-10-07 16:10:48>>>cash read=3E
2024-10-07 16:10:49>>>cash read=00
2024-10-07 16:10:49>>>cash read=818F42
2024-10-07 16:10:49>>>cash write=02
2024-10-07 16:10:49 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-07 16:10:50>>>cash read=10
2024-10-07 16:10:50 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-07 16:10:50 当前产品价格10元，投币10元，打印小票中...
2024-10-07 16:10:50 >>>开始打印,排队号为75,订单号为2410071610500021803991
2024-10-07 16:10:50>>>订单2410071610500021803991写入成功,剩余空间为1679500,占用RAM为609.697265625
删除未同步订单2410071610500021803991
2024-10-07 16:10:52>>>订单2410071610500021803991删除成功,剩余空间为1680500,占用RAM为620.0498046875
检测订单目录中>>>
无未同步订单>>>
2024-10-07 16:10:52 >>>当前Ram内存为591.658203125
定时检测未同步订单启用
2024-10-07 16:10:53>>>cash write=0C
2024-10-07 16:10:53>>>cash read=3E


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


===17:49:39===
2024-10-07 17:49:08 >>>回调事件[910,devices/TL2180]
2024-10-07 17:49:08 >>>故障排除日志:上一MQTT订单号缓存列表为24100717453542867338
2024-10-07 17:49:08 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 17:49:08 开始打印,排队:90,票券:2410071749045891024101,订单:24100717490458904035,[2024-10-07 17:49:09微信支付10元]
2024-10-07 17:49:11 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410071749045891024101","queue_number":90,"trade_uid":"24100717490458904035"}]}
2024-10-07 17:49:11 >>>故障排除日志:删除未同步下发订单成功24100717490458904035
2024-10-07 17:49:11 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-07 17:49:21>>>cash read=00
2024-10-07 17:49:22>>>cash read=818F42
2024-10-07 17:49:22>>>cash write=02
2024-10-07 17:49:22 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-07 17:49:22>>>cash read=10
2024-10-07 17:49:22 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-07 17:49:22 当前产品价格10元，投币10元，打印小票中...
2024-10-07 17:49:22 >>>开始打印,排队号为91,订单号为2410071749220021806540
2024-10-07 17:49:23>>>订单2410071749220021806540写入成功,剩余空间为1679000,占用RAM为610.9208984375
删除未同步订单2410071749220021806540
2024-10-07 17:49:25>>>订单2410071749220021806540删除成功,剩余空间为1680000,占用RAM为621.228515625
检测订单目录中>>>
无未同步订单>>>
2024-10-07 17:49:25 >>>当前Ram内存为592.0537109375
定时检测未同步订单启用
2024-10-07 17:49:26>>>cash write=0C
2024-10-07 17:49:26>>>cash read=3E


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


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


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


===17:57:40===
2024-10-07 17:56:46>>>cash read=00
2024-10-07 17:56:46>>>cash read=818F42
2024-10-07 17:56:46>>>cash write=02
2024-10-07 17:56:46 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-07 17:56:46>>>cash read=10
2024-10-07 17:56:46 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-07 17:56:46 当前产品价格10元，投币10元，打印小票中...
2024-10-07 17:56:46 >>>开始打印,排队号为94,订单号为2410071756460021804915
2024-10-07 17:56:47>>>订单2410071756460021804915写入成功,剩余空间为1680000,占用RAM为607.33203125
删除未同步订单2410071756460021804915
2024-10-07 17:56:49>>>订单2410071756460021804915删除成功,剩余空间为1680500,占用RAM为618.04296875
检测订单目录中>>>
无未同步订单>>>
2024-10-07 17:56:49 >>>当前Ram内存为590.0078125
定时检测未同步订单启用
2024-10-07 17:56:50>>>cash write=0C
2024-10-07 17:56:50>>>cash read=3E


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


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


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


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


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


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


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


===18:23:42===
2024-10-07 18:22:44>>>cash read=29
2024-10-07 18:22:44 >>>回调事件130,cash_status,20029,退钞中
2024-10-07 18:22:45>>>cash read=3E
2024-10-07 18:22:46>>>cash read=29
2024-10-07 18:22:46 >>>回调事件130,cash_status,20029,退钞中
2024-10-07 18:22:47>>>cash read=3E
2024-10-07 18:22:52>>>cash read=00
2024-10-07 18:22:52>>>cash read=818F43
2024-10-07 18:22:52>>>cash write=0f
2024-10-07 18:22:52 >>>回调事件130,cash_status,10024,识别到金额为20,面值不在接收范围内，正在退钞
2024-10-07 18:22:52>>>cash read=29
2024-10-07 18:22:52 >>>回调事件130,cash_status,20029,退钞中
2024-10-07 18:22:53>>>cash read=2F29
2024-10-07 18:22:55>>>cash write=0C
2024-10-07 18:22:55>>>cash read=3E
2024-10-07 18:23:06>>>cash read=00
2024-10-07 18:23:07>>>cash read=818F42
2024-10-07 18:23:07>>>cash write=02
2024-10-07 18:23:07 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-07 18:23:07>>>cash read=10
2024-10-07 18:23:07 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-07 18:23:07 当前产品价格10元，投币10元，打印小票中...
2024-10-07 18:23:07 >>>开始打印,排队号为100,订单号为2410071823070021805106
2024-10-07 18:23:07>>>订单2410071823070021805106写入成功,剩余空间为1679000,占用RAM为611.6181640625
删除未同步订单2410071823070021805106
2024-10-07 18:23:09>>>订单2410071823070021805106删除成功,剩余空间为1680000,占用RAM为620.0625
检测订单目录中>>>
无未同步订单>>>
2024-10-07 18:23:09 >>>当前Ram内存为590.9345703125
定时检测未同步订单启用
2024-10-07 18:23:10>>>cash write=0C
2024-10-07 18:23:11>>>cash read=3E
2024-10-07 18:23:16 >>>回调事件[910,devices/TL2180]
2024-10-07 18:23:16 >>>故障排除日志:上一MQTT订单号缓存列表为24100718104553036235
2024-10-07 18:23:16 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 18:23:16 开始打印,排队:101,票券:2410071823093557829501,订单:24100718230935573393,[2024-10-07 18:23:16微信支付10元]
2024-10-07 18:23:18 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410071823093557829501","queue_number":101,"trade_uid":"24100718230935573393"}]}
2024-10-07 18:23:18 >>>故障排除日志:删除未同步下发订单成功24100718230935573393
2024-10-07 18:23:18 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-07 18:23:25 >>>回调事件[910,devices/TL2180]
2024-10-07 18:23:25 >>>故障排除日志:上一MQTT订单号缓存列表为24100718230935573393
2024-10-07 18:23:25 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 18:23:25 开始打印,排队:102,票券:2410071823177598705901,订单:24100718231775981832,[2024-10-07 18:23:25微信支付10元]
2024-10-07 18:23:25 开始打印,排队:103,票券:2410071823177598904702,订单:24100718231775981832,[2024-10-07 18:23:25微信支付10元]
2024-10-07 18:23:28 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410071823177598705901","queue_number":102,"trade_uid":"24100718231775981832"},{"ticket_no":"2410071823177598904702","queue_number":103,"trade_uid":"24100718231775981832"}]}
2024-10-07 18:23:28 >>>故障排除日志:删除未同步下发订单成功24100718231775981832
2024-10-07 18:23:28 >>>故障排除日志:删除未同步下发订单成功24100718231775981832
2024-10-07 18:23:28 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


===18:29:45===
2024-10-07 18:29:05>>>cash read=29
2024-10-07 18:29:05 >>>回调事件130,cash_status,20029,退钞中
2024-10-07 18:29:06>>>cash read=01
2024-10-07 18:29:10>>>cash read=00
2024-10-07 18:29:12>>>cash read=2F29
2024-10-07 18:29:13>>>cash read=01
2024-10-07 18:29:16>>>cash read=2F
2024-10-07 18:29:17>>>cash read=3E
2024-10-07 18:29:19>>>cash read=00
2024-10-07 18:29:20>>>cash read=01
2024-10-07 18:29:25>>>cash read=3E
2024-10-07 18:29:29>>>cash read=00
2024-10-07 18:29:30>>>cash read=818F42
2024-10-07 18:29:30>>>cash write=02
2024-10-07 18:29:30 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-07 18:29:31>>>cash read=10
2024-10-07 18:29:31 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-07 18:29:31 当前产品价格10元，投币10元，打印小票中...
2024-10-07 18:29:31 >>>开始打印,排队号为106,订单号为2410071829310021801638
2024-10-07 18:29:31>>>订单2410071829310021801638写入成功,剩余空间为1679500,占用RAM为609.6748046875
删除未同步订单2410071829310021801638
2024-10-07 18:29:33>>>订单2410071829310021801638删除成功,剩余空间为1680000,占用RAM为619.2509765625
检测订单目录中>>>
无未同步订单>>>
2024-10-07 18:29:33 >>>当前Ram内存为590.3515625
定时检测未同步订单启用
2024-10-07 18:29:34>>>cash write=0C
2024-10-07 18:29:34>>>cash read=00
2024-10-07 18:29:35>>>cash read=29
2024-10-07 18:29:35 >>>回调事件130,cash_status,20029,退钞中
2024-10-07 18:29:36>>>cash read=2F29
2024-10-07 18:29:38>>>cash read=3E
2024-10-07 18:29:39>>>cash read=00
2024-10-07 18:29:40>>>cash read=818F42
2024-10-07 18:29:40>>>cash write=02
2024-10-07 18:29:40 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-07 18:29:41>>>cash read=10
2024-10-07 18:29:41 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-07 18:29:41 当前产品价格10元，投币10元，打印小票中...
2024-10-07 18:29:41 >>>开始打印,排队号为107,订单号为2410071829410021804517
定时检测未同步订单关闭
2024-10-07 18:29:41>>>订单2410071829410021804517写入成功,剩余空间为1678000,占用RAM为615.5966796875


===18:30:45===
2024-10-07 18:29:44>>>cash write=0C
2024-10-07 18:29:44>>>cash read=3E
2024-10-07 18:29:50>>>cash read=00
2024-10-07 18:29:51>>>cash read=818F42
2024-10-07 18:29:51>>>cash write=02
2024-10-07 18:29:51 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-07 18:29:51>>>cash read=10
2024-10-07 18:29:51 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-07 18:29:51 当前产品价格10元，投币10元，打印小票中...
2024-10-07 18:29:51 >>>开始打印,排队号为108,订单号为2410071829510021807396
定时检测未同步订单关闭
2024-10-07 18:29:52>>>订单2410071829510021807396写入成功,剩余空间为1679500,占用RAM为607.6455078125
删除未同步订单2410071829510021807396
2024-10-07 18:29:54>>>订单2410071829510021807396删除成功,剩余空间为1680500,占用RAM为617.6826171875
检测订单目录中>>>
无未同步订单>>>
2024-10-07 18:29:54 >>>当前Ram内存为589.271484375
定时检测未同步订单启用
2024-10-07 18:29:55>>>cash write=0C
2024-10-07 18:29:55>>>cash read=3E
2024-10-07 18:29:56 >>>回调事件[910,devices/TL2180]
2024-10-07 18:29:56 >>>故障排除日志:上一MQTT订单号缓存列表为24100718245217811674
2024-10-07 18:29:56 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 18:29:56 开始打印,排队:109,票券:2410071829512001677801,订单:24100718295120012157,[2024-10-07 18:29:56微信支付10元]
2024-10-07 18:29:58 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410071829512001677801","queue_number":109,"trade_uid":"24100718295120012157"}]}
2024-10-07 18:29:58 >>>故障排除日志:删除未同步下发订单成功24100718295120012157
2024-10-07 18:29:58 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


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


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


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


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


===18:58:49===
2024-10-07 18:58:45 >>>回调事件[910,devices/TL2180]
2024-10-07 18:58:45 >>>故障排除日志:上一MQTT订单号缓存列表为24100718541518519939
2024-10-07 18:58:45 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 18:58:45 开始打印,排队:118,票券:2410071858308739997101,订单:24100718583087394113,[2024-10-07 18:58:45微信支付10元]


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


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


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


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


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


===19:10:52===
2024-10-07 19:10:46 >>>回调事件[910,devices/TL2180]
2024-10-07 19:10:46 >>>故障排除日志:上一MQTT订单号缓存列表为24100719093021949943
2024-10-07 19:10:46 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 19:10:46 开始打印,排队:125,票券:2410071910411487886101,订单:24100719104114874285,[2024-10-07 19:10:46微信支付10元]
2024-10-07 19:10:47 开始打印,排队:126,票券:2410071910411488052602,订单:24100719104114874285,[2024-10-07 19:10:46微信支付10元]


===19:11:52===
2024-10-07 19:10:50 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410071910411487886101","queue_number":125,"trade_uid":"24100719104114874285"},{"ticket_no":"2410071910411488052602","queue_number":126,"trade_uid":"24100719104114874285"}]}
2024-10-07 19:10:50 >>>故障排除日志:删除未同步下发订单成功24100719104114874285
2024-10-07 19:10:50 >>>故障排除日志:删除未同步下发订单成功24100719104114874285
2024-10-07 19:10:50 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


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


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


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


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


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


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


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


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


===19:53:11===
上一时间戳为1728260759
当日首次设置时间戳true为1728301930
今日nvm排队号为142
当前排队号为142,音量为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:5c118****42cf7
纸币器设置接收纸币范围为15
欢迎使用天羚自助售票系统[2.5.4]
定时检测未同步订单启用
2024-10-07 19:52:11>>>cash write=30
2024-10-07 19:52:11>>>cash write=02
2024-10-07 19:52:11>>>cash write=3E
2024-10-07 19:52:11>>>cash read=808F808F808F
系统时间初始化成功，时间为2024107195211
2024-10-07 19:52:12>>>cash write=02
2024-10-07 19:52:12 >>>剩余flash空间=1680500,占用RAM为628.70703125
2024-10-07 19:52:12 >>>回调事件:910,subscribe,10000,连接服务器成功

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

2024-10-07 19:52:15>>>cash write=0C
2024-10-07 19:52:15>>>cash read=3E
流量卡还有236天过期
2024-10-07 19:52:19 >>>当前Ram内存为629.16796875


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


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


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


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


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


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


===20:33:06===
上一时间戳为1728301930
当日首次设置时间戳true为1728304325
今日nvm排队号为147
当前排队号为147,音量为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:a4c0f****e580b
纸币器设置接收纸币范围为15
欢迎使用天羚自助售票系统[2.5.4]
定时检测未同步订单启用
2024-10-07 20:32:05>>>cash write=30
2024-10-07 20:32:05>>>cash write=02
2024-10-07 20:32:05>>>cash write=3E
2024-10-07 20:32:05>>>cash read=808F808F808F808F
系统时间初始化成功，时间为202410720325
2024-10-07 20:32:06>>>cash write=02
2024-10-07 20:32:06 >>>剩余flash空间=1680500,占用RAM为627.76953125
2024-10-07 20:32:06 >>>回调事件:910,subscribe,10000,连接服务器成功

请求下发消息结果为0,下发成功
2024-10-07 20:32:07 >>>回调事件[910,devices/TL2180]
2024-10-07 20:32:07 >>>故障排除日志:上一MQTT订单号缓存列表为24100720202114820274
2024-10-07 20:32:07 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 20:32:07 开始打印,排队:147,票券:2410072031456883801701,订单:24100720314568834395,[2024-10-07 20:31:51微信支付10元]
2024-10-07 20:32:09 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410072031456883801701","queue_number":147,"trade_uid":"24100720314568834395"}]}
2024-10-07 20:32:09 >>>故障排除日志:删除未同步下发订单成功24100720314568834395
2024-10-07 20:32:09 >>>故障排除日志:终端同步成功后剩余订单列表
流量卡还有236天过期
2024-10-07 20:32:10>>>cash write=0C
2024-10-07 20:32:10>>>cash read=3E
2024-10-07 20:32:13 >>>当前Ram内存为644.1533203125
2024-10-07 20:32:41 >>>回调事件[910,devices/TL2180]
2024-10-07 20:32:41 >>>故障排除日志:上一MQTT订单号缓存列表为24100720314568834395
2024-10-07 20:32:41 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 20:32:41 开始打印,排队:148,票券:2410072032353396409201,订单:24100720323533959337,[2024-10-07 20:32:41微信支付10元]
2024-10-07 20:32:43 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410072032353396409201","queue_number":148,"trade_uid":"24100720323533959337"}]}
2024-10-07 20:32:43 >>>故障排除日志:删除未同步下发订单成功24100720323533959337
2024-10-07 20:32:43 >>>故障排除日志:终端同步成功后剩余订单列表


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


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