TLClient_JSSCOM_LuatOS-Air_V4010_RDA8910_RFTTS_0xe0000,2.5.4,866250069008534,96405583046574,
poweron reason:3

===05:11:19===
2024-10-07 05:10:42>>>cash read=0A
2024-10-07 05:10:43>>>cash read=3E


===05:50:19===
2024-10-07 05:49:45>>>cash read=0A
2024-10-07 05:49:46>>>cash read=3E


===09:19:19===
2024-10-07 09:18:53 >>>回调事件[910,devices/TL1643]
隔日重置时间戳true
隔日清空未同步下发列表true
2024-10-07 09:18:54 >>>故障排除日志:上一MQTT订单号缓存列表为24100620593254199742
2024-10-07 09:18:54 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 09:18:54 开始打印,排队:1,票券:2410070918455222463901,订单:24100709184552220586,[2024-10-07 09:18:55微信支付12元]
2024-10-07 09:18:56 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410070918455222463901","queue_number":1,"trade_uid":"24100709184552220586"}]}
2024-10-07 09:18:56 >>>故障排除日志:删除未同步下发订单成功24100709184552220586
2024-10-07 09:18:56 >>>故障排除日志:终端同步成功后剩余订单列表


===09:26:20===
2024-10-07 09:25:33>>>cash read=00
2024-10-07 09:25:34>>>cash read=818F42
2024-10-07 09:25:34>>>cash write=02
2024-10-07 09:25:34 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-07 09:25:34>>>cash read=10
2024-10-07 09:25:34 >>>回调事件130,10,10023,finish Money=10,进钞完成
上一时间戳为1728263933
2024-10-07 09:25:35>>>cash write=0C
2024-10-07 09:25:36>>>cash read=00
2024-10-07 09:25:37>>>cash read=29
2024-10-07 09:25:37 >>>回调事件130,cash_status,20029,退钞中
2024-10-07 09:25:37>>>cash read=2F29
2024-10-07 09:25:39>>>cash read=00
2024-10-07 09:25:40>>>cash read=818F40
2024-10-07 09:25:40>>>cash write=02
2024-10-07 09:25:40 >>>回调事件130,cash_status,10022,进钞中...read money=1
2024-10-07 09:25:40>>>cash read=10
2024-10-07 09:25:40 >>>回调事件130,1,10023,finish Money=1,进钞完成
2024-10-07 09:25:42>>>cash write=0C
2024-10-07 09:25:42>>>cash read=3E
2024-10-07 09:25:43>>>cash read=00
2024-10-07 09:25:43>>>cash read=818F40
2024-10-07 09:25:43>>>cash write=02
2024-10-07 09:25:43 >>>回调事件130,cash_status,10022,进钞中...read money=1
2024-10-07 09:25:44>>>cash read=10
2024-10-07 09:25:44 >>>回调事件130,1,10023,finish Money=1,进钞完成
2024-10-07 09:25:44 当前产品价格12元，投币12元，打印小票中...
2024-10-07 09:25:44 >>>开始打印,排队号为2,订单号为2410070925400016435348
2024-10-07 09:25:44>>>订单2410070925400016435348写入成功,剩余空间为1679000,占用RAM为615.1640625
删除未同步订单2410070925400016435348
2024-10-07 09:25:46>>>订单2410070925400016435348删除成功,剩余空间为1679500,占用RAM为628.9052734375
检测订单目录中>>>
无未同步订单>>>
2024-10-07 09:25:46 >>>当前Ram内存为597.8359375
定时检测未同步订单启用
2024-10-07 09:25:47>>>cash write=0C
2024-10-07 09:25:47>>>cash read=3E


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


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


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


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


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


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


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


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


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


===10:30:23===
2024-10-07 10:29:23>>>cash read=00
2024-10-07 10:29:24>>>cash read=818F42
2024-10-07 10:29:24>>>cash write=02
2024-10-07 10:29:24 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-07 10:29:25>>>cash read=10
2024-10-07 10:29:25 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-07 10:29:26>>>cash write=0C
2024-10-07 10:29:26>>>cash read=00
2024-10-07 10:29:26>>>cash read=818F40
2024-10-07 10:29:26>>>cash write=02
2024-10-07 10:29:26 >>>回调事件130,cash_status,10022,进钞中...read money=1
2024-10-07 10:29:27>>>cash read=10
2024-10-07 10:29:27 >>>回调事件130,1,10023,finish Money=1,进钞完成
2024-10-07 10:29:28>>>cash write=0C
2024-10-07 10:29:28>>>cash read=00
2024-10-07 10:29:28>>>cash read=818F40
2024-10-07 10:29:28>>>cash write=02
2024-10-07 10:29:28 >>>回调事件130,cash_status,10022,进钞中...read money=1
2024-10-07 10:29:29>>>cash read=10
2024-10-07 10:29:29 >>>回调事件130,1,10023,finish Money=1,进钞完成
2024-10-07 10:29:29 当前产品价格12元，投币12元，打印小票中...
2024-10-07 10:29:29 >>>开始打印,排队号为11,订单号为2410071029270016438775
2024-10-07 10:29:29>>>订单2410071029270016438775写入成功,剩余空间为1679000,占用RAM为615.544921875
删除未同步订单2410071029270016438775
2024-10-07 10:29:31>>>订单2410071029270016438775删除成功,剩余空间为1680000,占用RAM为628.6884765625
检测订单目录中>>>
无未同步订单>>>
2024-10-07 10:29:31 >>>当前Ram内存为597.830078125
定时检测未同步订单启用
2024-10-07 10:29:32>>>cash write=0C
2024-10-07 10:29:32>>>cash read=3E


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


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


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


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


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


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


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


===11:06:25===
2024-10-07 11:05:35 >>>回调事件[910,devices/TL1643]
2024-10-07 11:05:35 >>>故障排除日志:上一MQTT订单号缓存列表为24100710521892803445
2024-10-07 11:05:35 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 11:05:35 开始打印,排队:17,票券:2410071105313485351301,订单:24100711053134846452,[2024-10-07 11:05:36微信支付12元]
2024-10-07 11:05:37 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410071105313485351301","queue_number":17,"trade_uid":"24100711053134846452"}]}
2024-10-07 11:05:37 >>>故障排除日志:删除未同步下发订单成功24100711053134846452
2024-10-07 11:05:37 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-07 11:05:57 >>>回调事件[910,devices/TL1643]
2024-10-07 11:05:57 >>>故障排除日志:上一MQTT订单号缓存列表为24100711053134846452
2024-10-07 11:05:57 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 11:05:57 开始打印,排队:18,票券:2410071105525842526801,订单:24100711055258421429,[2024-10-07 11:05:58微信支付12元]
2024-10-07 11:05:59 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410071105525842526801","queue_number":18,"trade_uid":"24100711055258421429"}]}
2024-10-07 11:05:59 >>>故障排除日志:删除未同步下发订单成功24100711055258421429
2024-10-07 11:05:59 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


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


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


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


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


===14:05:30===
2024-10-07 14:05:23 >>>回调事件[910,devices/TL1643]
2024-10-07 14:05:23 >>>故障排除日志:上一MQTT订单号缓存列表为24100713294764864447
2024-10-07 14:05:23 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 14:05:23 开始打印,排队:28,票券:2410071405187145948101,订单:24100714051871456134,[2024-10-07 14:05:24微信支付12元]
2024-10-07 14:05:23 开始打印,排队:29,票券:2410071405187146078302,订单:24100714051871456134,[2024-10-07 14:05:24微信支付12元]


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


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


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


===15:45:31===
2024-10-07 15:44:42>>>cash read=00
2024-10-07 15:44:42>>>cash read=818F42
2024-10-07 15:44:42>>>cash write=02
2024-10-07 15:44:42 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-07 15:44:43>>>cash read=10
2024-10-07 15:44:43 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-07 15:44:44>>>cash write=0C
2024-10-07 15:44:44>>>cash read=00
2024-10-07 15:44:44>>>cash read=818F40
2024-10-07 15:44:44>>>cash write=02
2024-10-07 15:44:44 >>>回调事件130,cash_status,10022,进钞中...read money=1
2024-10-07 15:44:45>>>cash write=0C
2024-10-07 15:44:45>>>cash read=00
2024-10-07 15:44:45>>>cash read=10
2024-10-07 15:44:45 >>>回调事件130,1,10023,finish Money=1,进钞完成
2024-10-07 15:44:47>>>cash read=00
2024-10-07 15:44:47>>>cash read=818F40
2024-10-07 15:44:47>>>cash write=02
2024-10-07 15:44:47 >>>回调事件130,cash_status,10022,进钞中...read money=1
2024-10-07 15:44:48>>>cash read=10
2024-10-07 15:44:48 >>>回调事件130,1,10023,finish Money=1,进钞完成
2024-10-07 15:44:48 当前产品价格12元，投币12元，打印小票中...
2024-10-07 15:44:48 >>>开始打印,排队号为33,订单号为2410071544450016439922
2024-10-07 15:44:48>>>订单2410071544450016439922写入成功,剩余空间为1679000,占用RAM为613.3701171875
删除未同步订单2410071544450016439922
2024-10-07 15:44:50>>>订单2410071544450016439922删除成功,剩余空间为1680000,占用RAM为626.724609375
检测订单目录中>>>
无未同步订单>>>
2024-10-07 15:44:50 >>>当前Ram内存为597.3505859375
定时检测未同步订单启用
2024-10-07 15:44:51>>>cash write=0C
2024-10-07 15:44:51>>>cash read=3E


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


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


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


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


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


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


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


===16:30:35===
2024-10-07 16:29:51 >>>回调事件[910,devices/TL1643]
2024-10-07 16:29:51 >>>故障排除日志:上一MQTT订单号缓存列表为24100716283438120516|24100716283438120516
2024-10-07 16:29:51 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 16:29:51 开始打印,排队:41,票券:2410071629470356995301,订单:24100716294703564131,[2024-10-07 16:29:52微信支付12元]
2024-10-07 16:29:53 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410071629470356995301","queue_number":41,"trade_uid":"24100716294703564131"}]}
2024-10-07 16:29:53 >>>故障排除日志:删除未同步下发订单成功24100716294703564131
2024-10-07 16:29:53 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-07 16:30:29 >>>回调事件[910,devices/TL1643]
2024-10-07 16:30:29 >>>故障排除日志:上一MQTT订单号缓存列表为24100716294703564131
2024-10-07 16:30:29 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 16:30:29 开始打印,排队:42,票券:2410071630248267978901,订单:24100716302482676135,[2024-10-07 16:30:31微信支付12元]


===16:31:35===
2024-10-07 16:30:31 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410071630248267978901","queue_number":42,"trade_uid":"24100716302482676135"}]}
2024-10-07 16:30:31 >>>故障排除日志:删除未同步下发订单成功24100716302482676135
2024-10-07 16:30:31 >>>故障排除日志:终端同步成功后剩余订单列表


===16:32:37===
2024-10-07 16:31:59 >>>回调事件[910,devices/TL1643]
2024-10-07 16:31:59 >>>故障排除日志:上一MQTT订单号缓存列表为24100716302482676135
2024-10-07 16:31:59 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 16:31:59 开始打印,排队:43,票券:2410071631533566543501,订单:24100716315335661883,[2024-10-07 16:32:00微信支付12元]
2024-10-07 16:32:01 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410071631533566543501","queue_number":43,"trade_uid":"24100716315335661883"}]}
2024-10-07 16:32:01 >>>故障排除日志:删除未同步下发订单成功24100716315335661883
2024-10-07 16:32:01 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-07 16:32:13>>>cash read=00
2024-10-07 16:32:14>>>cash read=818F43
2024-10-07 16:32:14>>>cash write=02
2024-10-07 16:32:14 >>>回调事件130,cash_status,10022,进钞中...read money=20
2024-10-07 16:32:14>>>cash read=10
2024-10-07 16:32:14 >>>回调事件130,20,10023,finish Money=20,进钞完成
2024-10-07 16:32:15>>>cash write=0C
2024-10-07 16:32:15>>>cash read=00
2024-10-07 16:32:16>>>cash read=818F40
2024-10-07 16:32:16>>>cash write=02
2024-10-07 16:32:16 >>>回调事件130,cash_status,10022,进钞中...read money=1
2024-10-07 16:32:16>>>cash read=10
2024-10-07 16:32:16 >>>回调事件130,1,10023,finish Money=1,进钞完成
2024-10-07 16:32:18>>>cash write=0C
2024-10-07 16:32:18>>>cash read=00
2024-10-07 16:32:19>>>cash read=2F29
2024-10-07 16:32:20>>>cash read=00
2024-10-07 16:32:21>>>cash read=818F40
2024-10-07 16:32:21>>>cash write=02
2024-10-07 16:32:21 >>>回调事件130,cash_status,10022,进钞中...read money=1
2024-10-07 16:32:21>>>cash read=10
2024-10-07 16:32:22 >>>回调事件130,1,10023,finish Money=1,进钞完成
2024-10-07 16:32:23>>>cash write=0C
2024-10-07 16:32:23>>>cash read=3E
2024-10-07 16:32:24>>>cash read=00
2024-10-07 16:32:24>>>cash read=818F40
2024-10-07 16:32:25>>>cash write=02
2024-10-07 16:32:25 >>>回调事件130,cash_status,10022,进钞中...read money=1
2024-10-07 16:32:25>>>cash read=10
2024-10-07 16:32:25 >>>回调事件130,1,10023,finish Money=1,进钞完成
2024-10-07 16:32:26>>>cash write=0C
2024-10-07 16:32:26>>>cash read=00
2024-10-07 16:32:28>>>cash read=00818F40
2024-10-07 16:32:28>>>cash write=02
2024-10-07 16:32:28 >>>回调事件130,cash_status,10022,进钞中...read money=1
2024-10-07 16:32:28>>>cash read=10
2024-10-07 16:32:28 >>>回调事件130,1,10023,finish Money=1,进钞完成
2024-10-07 16:32:28 当前产品价格12元，投币24元，打印小票中...
2024-10-07 16:32:28 >>>开始打印,排队号为44,订单号为2410071632280016438225
2024-10-07 16:32:29 >>>开始打印,排队号为45,订单号为2410071632280016438225
2024-10-07 16:32:29>>>订单2410071632280016438225写入成功,剩余空间为1677000,占用RAM为635.685546875


===16:33:37===
删除未同步订单2410071632280016438225
2024-10-07 16:32:33>>>订单2410071632280016438225删除成功,剩余空间为1681500,占用RAM为647.6435546875
检测订单目录中>>>
无未同步订单>>>
2024-10-07 16:32:33 >>>当前Ram内存为597.1318359375
定时检测未同步订单启用
2024-10-07 16:32:34>>>cash write=0C
2024-10-07 16:32:34>>>cash read=3E


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


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


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


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


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


===17:20:39===
2024-10-07 17:20:07>>>cash read=00
2024-10-07 17:20:07>>>cash read=818F41
2024-10-07 17:20:07>>>cash write=02
2024-10-07 17:20:07 >>>回调事件130,cash_status,10022,进钞中...read money=5
2024-10-07 17:20:08>>>cash read=10
2024-10-07 17:20:08 >>>回调事件130,5,10023,finish Money=5,进钞完成
2024-10-07 17:20:09>>>cash write=0C
2024-10-07 17:20:09>>>cash read=3E
2024-10-07 17:20:10>>>cash read=292F29
2024-10-07 17:20:10 >>>回调事件130,cash_status,20029,退钞中
2024-10-07 17:20:11>>>cash read=012F
2024-10-07 17:20:12>>>cash read=29
2024-10-07 17:20:12 >>>回调事件130,cash_status,20029,退钞中
2024-10-07 17:20:13>>>cash read=2F29
2024-10-07 17:20:15 >>>回调事件130,cash_status,20029,退钞中
2024-10-07 17:20:16>>>cash read=01
2024-10-07 17:20:17>>>cash read=3E
2024-10-07 17:20:19>>>cash read=00
2024-10-07 17:20:20>>>cash read=818F41
2024-10-07 17:20:21>>>cash write=02
2024-10-07 17:20:21 >>>回调事件130,cash_status,10022,进钞中...read money=5
2024-10-07 17:20:21>>>cash read=10
2024-10-07 17:20:21 >>>回调事件130,5,10023,finish Money=5,进钞完成
2024-10-07 17:20:22>>>cash write=0C
2024-10-07 17:20:22>>>cash read=3E
2024-10-07 17:20:23>>>cash read=00
2024-10-07 17:20:24>>>cash read=818F40
2024-10-07 17:20:24>>>cash write=02
2024-10-07 17:20:24 >>>回调事件130,cash_status,10022,进钞中...read money=1
2024-10-07 17:20:25>>>cash read=10
2024-10-07 17:20:25 >>>回调事件130,1,10023,finish Money=1,进钞完成
2024-10-07 17:20:26>>>cash write=0C
2024-10-07 17:20:26>>>cash read=3E
2024-10-07 17:20:29>>>cash read=00
2024-10-07 17:20:30>>>cash read=818F40
2024-10-07 17:20:30>>>cash write=02
2024-10-07 17:20:30 >>>回调事件130,cash_status,10022,进钞中...read money=1
2024-10-07 17:20:31>>>cash read=10
2024-10-07 17:20:31 >>>回调事件130,1,10023,finish Money=1,进钞完成
2024-10-07 17:20:31 当前产品价格12元，投币12元，打印小票中...
2024-10-07 17:20:31 >>>开始打印,排队号为51,订单号为2410071720250016438400
2024-10-07 17:20:31>>>订单2410071720250016438400写入成功,剩余空间为1678000,占用RAM为620.8310546875
删除未同步订单2410071720250016438400
2024-10-07 17:20:33>>>订单2410071720250016438400删除成功,剩余空间为1679000,占用RAM为630.0439453125
检测订单目录中>>>
无未同步订单>>>
2024-10-07 17:20:33 >>>当前Ram内存为599.189453125
定时检测未同步订单启用
2024-10-07 17:20:34>>>cash write=0C
2024-10-07 17:20:34>>>cash read=3E


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


===17:22:40===
2024-10-07 17:21:41 >>>回调事件[910,devices/TL1643]
2024-10-07 17:21:41 >>>故障排除日志:上一MQTT订单号缓存列表为24100717182231288041
2024-10-07 17:21:41 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 17:21:41 开始打印,排队:52,票券:2410071721386705835301,订单:24100717213867054397,[2024-10-07 17:21:44微信支付12元]
2024-10-07 17:21:41 开始打印,排队:53,票券:2410071721386705989202,订单:24100717213867054397,[2024-10-07 17:21:44微信支付12元]
2024-10-07 17:21:41 开始打印,排队:54,票券:2410071721386706074903,订单:24100717213867054397,[2024-10-07 17:21:44微信支付12元]
2024-10-07 17:21:46 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410071721386705835301","queue_number":52,"trade_uid":"24100717213867054397"},{"ticket_no":"2410071721386705989202","queue_number":53,"trade_uid":"24100717213867054397"},{"ticket_no":"2410071721386706074903","queue_number":54,"trade_uid":"24100717213867054397"}]}
2024-10-07 17:21:46 >>>故障排除日志:删除未同步下发订单成功24100717213867054397
2024-10-07 17:21:46 >>>故障排除日志:删除未同步下发订单成功24100717213867054397
2024-10-07 17:21:46 >>>故障排除日志:删除未同步下发订单成功24100717213867054397
2024-10-07 17:21:47 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


===19:14:45===
2024-10-07 19:13:53 >>>回调事件[910,devices/TL1643]
2024-10-07 19:13:53 >>>故障排除日志:上一MQTT订单号缓存列表为24100719124248578257
2024-10-07 19:13:53 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 19:13:53 开始打印,排队:75,票券:2410071913468660539201,订单:24100719134686596231,[2024-10-07 19:13:55微信支付12元]
2024-10-07 19:13:55 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410071913468660539201","queue_number":75,"trade_uid":"24100719134686596231"}]}
2024-10-07 19:13:55 >>>故障排除日志:删除未同步下发订单成功24100719134686596231
2024-10-07 19:13:55 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-07 19:14:02 >>>回调事件[910,devices/TL1643]
2024-10-07 19:14:02 >>>故障排除日志:上一MQTT订单号缓存列表为24100719134686596231
2024-10-07 19:14:02 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 19:14:02 开始打印,排队:76,票券:2410071913586512144501,订单:24100719135865116732,[2024-10-07 19:14:04微信支付12元]
2024-10-07 19:14:04 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410071913586512144501","queue_number":76,"trade_uid":"24100719135865116732"}]}
2024-10-07 19:14:04 >>>故障排除日志:删除未同步下发订单成功24100719135865116732
2024-10-07 19:14:04 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-07 19:14:22 >>>回调事件[910,devices/TL1643]
2024-10-07 19:14:22 >>>故障排除日志:上一MQTT订单号缓存列表为24100719135865116732
2024-10-07 19:14:22 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 19:14:22 开始打印,排队:77,票券:2410071914185095919201,订单:24100719141850954896,[2024-10-07 19:14:24微信支付12元]
2024-10-07 19:14:24 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410071914185095919201","queue_number":77,"trade_uid":"24100719141850954896"}]}
2024-10-07 19:14:24 >>>故障排除日志:删除未同步下发订单成功24100719141850954896
2024-10-07 19:14:24 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


===22:19:51===
2024-10-07 22:19:11>>>cash read=0A
2024-10-07 22:19:12>>>cash read=3E


===22:40:51===
2024-10-07 22:40:10>>>cash read=0A
2024-10-07 22:40:11>>>cash read=3E


===22:44:51===
2024-10-07 22:44:45>>>cash read=0A
2024-10-07 22:44:46>>>cash read=3E