TLClient_JSSCOM_LuatOS-Air_V3205_RDA8910_RFTTS_0xe0000,2.5.1,861714058754320,37438794650599,
poweron reason:0

===08:29:04===
上一时间戳为1727397310
隔日重置时间戳true
隔日清空未同步下发列表true
当前排队号为1,音量为6
初始化产品信息:[{"time_limit_date":"","ticket_category":"0","expiry_date":90,"product_detail":"","time_limit_status":"0","begin_minute":"00","product_uid":"5648114436008088297","use_timer":1,"old_price":"10","end_hour":"23","sale_price":"10","end_minute":"59","begin_hour":"00","sale_status":1,"product_name":"剪发一律10元"}]
打印门店标题设置为欢迎光临合剪（杭州江城店）
是否打印二维码设置为1
是否打印紧凑设置为3
session_id:4c353****46400
纸币器设置接收纸币范围为36
欢迎使用天羚自助售票系统[2.5.1]
定时检测未同步订单启用
2024-09-28 08:28:03>>>cash write=30
2024-09-28 08:28:03>>>cash write=02
2024-09-28 08:28:03>>>cash write=3E
2024-09-28 08:28:03>>>cash read=808F808F808F
系统时间初始化成功，时间为20249288283
2024-09-28 08:28:04>>>cash write=02
2024-09-28 08:28:04 >>>剩余flash空间=1674500,占用RAM为619.048828125
2024-09-28 08:28:04 >>>回调事件:910,subscribe,10000,连接服务器成功

请求下发消息结果为0,下发成功
2024-09-28 08:28:05 >>>回调事件[910,devices/D0309]
当日首次设置时间戳true为1727483285
2024-09-28 08:28:05 >>>故障排除日志:上一MQTT订单号缓存列表为24092721042964825423
2024-09-28 08:28:05 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 08:28:05 开始打印,排队:1,票券:2409280817000085548201,订单:24092808170000850624,[2024-09-28 08:17:08微信支付10元]
2024-09-28 08:28:05 开始打印,排队:2,票券:2409280821498913416501,订单:24092808214989127660,[2024-09-28 08:21:56支付宝支付10元]
流量卡还有184天过期
2024-09-28 08:28:09 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409280817000085548201","queue_number":1,"trade_uid":"24092808170000850624"},{"ticket_no":"2409280821498913416501","queue_number":2,"trade_uid":"24092808214989127660"}]}
2024-09-28 08:28:09 >>>故障排除日志:删除未同步下发订单成功24092808170000850624
2024-09-28 08:28:09 >>>故障排除日志:删除未同步下发订单成功24092808214989127660
2024-09-28 08:28:09 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 08:28:10>>>cash write=0C
2024-09-28 08:28:10>>>cash read=3E
2024-09-28 08:28:13 >>>当前Ram内存为629.53515625


===08:30:04===
定时检测未同步订单关闭
检测订单目录中>>>
无未同步订单>>>
2024-09-28 08:29:28 >>>回调事件[910,devices/D0309]
2024-09-28 08:29:28 >>>故障排除日志:上一MQTT订单号缓存列表为24092808170000850624|24092808214989127660
2024-09-28 08:29:28 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 08:29:28 开始打印,排队:3,票券:2409280829204811161001,订单:24092808292048106594,[2024-09-28 08:29:28微信支付10元]
2024-09-28 08:29:30 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409280829204811161001","queue_number":3,"trade_uid":"24092808292048106594"}]}
2024-09-28 08:29:30 >>>故障排除日志:删除未同步下发订单成功24092808292048106594
2024-09-28 08:29:31 >>>故障排除日志:终端同步成功后剩余订单列表


===08:34:06===
2024-09-28 08:33:39>>>cash read=1F
2024-09-28 08:33:40>>>cash read=3E
2024-09-28 08:34:01>>>cash read=00
2024-09-28 08:34:02>>>cash read=818F42
2024-09-28 08:34:02>>>cash write=02
2024-09-28 08:34:02 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-09-28 08:34:02>>>cash read=10
2024-09-28 08:34:02 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-09-28 08:34:02 >>>开始打印,排队号为4,订单号为2409280834020003099066
2024-09-28 08:34:02>>>订单2409280834020003099066写入成功,剩余空间为1674000,占用RAM为599.970703125


===08:35:06===
删除未同步订单2409280834020003099066
2024-09-28 08:34:04>>>订单2409280834020003099066删除成功,剩余空间为1675500,占用RAM为616.0498046875
检测订单目录中>>>
无未同步订单>>>
2024-09-28 08:34:04 >>>当前Ram内存为587.2412109375
定时检测未同步订单启用
2024-09-28 08:34:05>>>cash write=0C
2024-09-28 08:34:05>>>cash read=3E
定时检测未同步订单关闭
检测订单目录中>>>
无未同步订单>>>


===08:41:06===
2024-09-28 08:40:56 >>>回调事件[910,devices/D0309]
2024-09-28 08:40:56 >>>故障排除日志:上一MQTT订单号缓存列表为24092808292048106594
2024-09-28 08:40:56 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 08:40:56 开始打印,排队:5,票券:2409280840455520447001,订单:24092808404555199772,[2024-09-28 08:40:55支付宝支付10元]
2024-09-28 08:40:58 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409280840455520447001","queue_number":5,"trade_uid":"24092808404555199772"}]}
2024-09-28 08:40:58 >>>故障排除日志:删除未同步下发订单成功24092808404555199772
2024-09-28 08:40:58 >>>故障排除日志:终端同步成功后剩余订单列表


===08:43:07===
2024-09-28 08:42:45>>>cash read=29
2024-09-28 08:42:45 >>>回调事件130,cash_status,20029,退钞中
2024-09-28 08:42:46>>>cash read=2F29
2024-09-28 08:42:47>>>cash read=01
2024-09-28 08:42:50>>>cash read=2F
2024-09-28 08:42:51>>>cash read=3E


===08:44:07===
2024-09-28 08:43:09>>>cash read=292F29
2024-09-28 08:43:09 >>>回调事件130,cash_status,20029,退钞中
2024-09-28 08:43:10>>>cash read=01
2024-09-28 08:43:13>>>cash read=2F
2024-09-28 08:43:14>>>cash read=00
2024-09-28 08:43:15>>>cash read=2F29
2024-09-28 08:43:16>>>cash read=3E
2024-09-28 08:43:23>>>cash read=00
2024-09-28 08:43:24>>>cash read=818F42
2024-09-28 08:43:24>>>cash write=02
2024-09-28 08:43:24 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-09-28 08:43:24>>>cash read=10
2024-09-28 08:43:24 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-09-28 08:43:24 >>>开始打印,排队号为6,订单号为2409280843240003099907
2024-09-28 08:43:24>>>订单2409280843240003099907写入成功,剩余空间为1673500,占用RAM为602.58203125
删除未同步订单2409280843240003099907
2024-09-28 08:43:26>>>订单2409280843240003099907删除成功,剩余空间为1674500,占用RAM为613.611328125
检测订单目录中>>>
无未同步订单>>>
2024-09-28 08:43:27 >>>当前Ram内存为588.2216796875
定时检测未同步订单启用
2024-09-28 08:43:27>>>cash write=0C
2024-09-28 08:43:28>>>cash read=3E


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


===08:49:07===
2024-09-28 08:48:43>>>cash read=9E
2024-09-28 08:48:44>>>cash read=3E


===08:50:08===
2024-09-28 08:49:11>>>cash read=9E
2024-09-28 08:49:12>>>cash read=3E


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


===08:57:08===
2024-09-28 08:56:21>>>cash read=9E
2024-09-28 08:56:22>>>cash read=3E


===08:58:09===
2024-09-28 08:57:23 >>>回调事件[910,devices/D0309]
2024-09-28 08:57:23 >>>故障排除日志:上一MQTT订单号缓存列表为24092808551168735786
2024-09-28 08:57:23 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 08:57:23 开始打印,排队:8,票券:2409280857160869118601,订单:24092808571608686061,[2024-09-28 08:57:23微信支付10元]
2024-09-28 08:57:25 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409280857160869118601","queue_number":8,"trade_uid":"24092808571608686061"}]}
2024-09-28 08:57:25 >>>故障排除日志:删除未同步下发订单成功24092808571608686061
2024-09-28 08:57:25 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 08:57:45 >>>回调事件[910,devices/D0309]
2024-09-28 08:57:45 >>>故障排除日志:上一MQTT订单号缓存列表为24092808571608686061
2024-09-28 08:57:45 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 08:57:45 开始打印,排队:9,票券:2409280857349228186301,订单:24092808573492276864,[2024-09-28 08:57:45支付宝支付10元]
2024-09-28 08:57:47 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409280857349228186301","queue_number":9,"trade_uid":"24092808573492276864"}]}
2024-09-28 08:57:47 >>>故障排除日志:删除未同步下发订单成功24092808573492276864
2024-09-28 08:57:47 >>>故障排除日志:终端同步成功后剩余订单列表


===09:04:09===
2024-09-28 09:03:19 >>>回调事件[910,devices/D0309]
2024-09-28 09:03:19 >>>故障排除日志:上一MQTT订单号缓存列表为24092808573492276864
2024-09-28 09:03:19 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 09:03:19 开始打印,排队:10,票券:2409280903139039146501,订单:24092809031390387431,[2024-09-28 09:03:18微信支付10元]
2024-09-28 09:03:21 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409280903139039146501","queue_number":10,"trade_uid":"24092809031390387431"}]}
2024-09-28 09:03:21 >>>故障排除日志:删除未同步下发订单成功24092809031390387431
2024-09-28 09:03:21 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 09:03:33 >>>回调事件[910,devices/D0309]
2024-09-28 09:03:33 >>>故障排除日志:上一MQTT订单号缓存列表为24092809031390387431
2024-09-28 09:03:33 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 09:03:33 开始打印,排队:11,票券:2409280903270882701001,订单:24092809032708823076,[2024-09-28 09:03:33支付宝支付10元]
2024-09-28 09:03:35 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409280903270882701001","queue_number":11,"trade_uid":"24092809032708823076"}]}
2024-09-28 09:03:35 >>>故障排除日志:删除未同步下发订单成功24092809032708823076
2024-09-28 09:03:35 >>>故障排除日志:终端同步成功后剩余订单列表


===09:05:09===
2024-09-28 09:04:51>>>cash read=9E
2024-09-28 09:04:52>>>cash read=3E


===09:07:09===
2024-09-28 09:06:21>>>cash read=9E
2024-09-28 09:06:22>>>cash read=3E


===09:10:10===
2024-09-28 09:09:15>>>cash read=9E
2024-09-28 09:09:16>>>cash read=3E


===09:15:10===
2024-09-28 09:14:10>>>cash read=9E
2024-09-28 09:14:11>>>cash read=3E
2024-09-28 09:14:29 >>>回调事件[910,devices/D0309]
2024-09-28 09:14:29 >>>故障排除日志:上一MQTT订单号缓存列表为24092809032708823076
2024-09-28 09:14:29 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 09:14:29 开始打印,排队:12,票券:2409280914208669498101,订单:24092809142086690578,[2024-09-28 09:14:29微信支付10元]
2024-09-28 09:14:31 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409280914208669498101","queue_number":12,"trade_uid":"24092809142086690578"}]}
2024-09-28 09:14:31 >>>故障排除日志:删除未同步下发订单成功24092809142086690578
2024-09-28 09:14:31 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


===09:22:11===
2024-09-28 09:22:08 >>>回调事件[910,devices/D0309]
2024-09-28 09:22:08 >>>故障排除日志:上一MQTT订单号缓存列表为24092809203201400229
2024-09-28 09:22:08 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 09:22:08 开始打印,排队:15,票券:2409280922001748545401,订单:24092809220017481091,[2024-09-28 09:22:07支付宝支付10元]


===09:23:11===
2024-09-28 09:22:10 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409280922001748545401","queue_number":15,"trade_uid":"24092809220017481091"}]}
2024-09-28 09:22:10 >>>故障排除日志:删除未同步下发订单成功24092809220017481091
2024-09-28 09:22:10 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


===09:26:13===
2024-09-28 09:25:31>>>cash read=1F
2024-09-28 09:25:33>>>cash read=3E
2024-09-28 09:26:10 >>>回调事件[910,devices/D0309]
2024-09-28 09:26:10 >>>故障排除日志:上一MQTT订单号缓存列表为24092809244762837915
2024-09-28 09:26:10 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 09:26:10 开始打印,排队:18,票券:2409280926047616981301,订单:24092809260476163968,[2024-09-28 09:26:10微信支付10元]


===09:27:14===
2024-09-28 09:26:12 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409280926047616981301","queue_number":18,"trade_uid":"24092809260476163968"}]}
2024-09-28 09:26:12 >>>故障排除日志:删除未同步下发订单成功24092809260476163968
2024-09-28 09:26:12 >>>故障排除日志:终端同步成功后剩余订单列表


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


===09:30:14===
2024-09-28 09:29:21>>>cash read=1F
2024-09-28 09:29:22>>>cash read=3E


===09:34:15===
2024-09-28 09:33:45>>>cash read=1F
2024-09-28 09:33:46>>>cash read=3E


===09:37:15===
2024-09-28 09:36:28 >>>回调事件[910,devices/D0309]
2024-09-28 09:36:28 >>>故障排除日志:上一MQTT订单号缓存列表为24092809281512232023
2024-09-28 09:36:28 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 09:36:28 开始打印,排队:21,票券:2409280936216785264601,订单:24092809362167849089,[2024-09-28 09:36:28微信支付10元]
2024-09-28 09:36:30 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409280936216785264601","queue_number":21,"trade_uid":"24092809362167849089"}]}
2024-09-28 09:36:30 >>>故障排除日志:删除未同步下发订单成功24092809362167849089
2024-09-28 09:36:30 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 09:36:57 >>>回调事件[910,devices/D0309]
2024-09-28 09:36:57 >>>故障排除日志:上一MQTT订单号缓存列表为24092809362167849089
2024-09-28 09:36:57 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 09:36:57 开始打印,排队:22,票券:2409280936518998676401,订单:24092809365189981231,[2024-09-28 09:36:57支付宝支付10元]
2024-09-28 09:36:59 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409280936518998676401","queue_number":22,"trade_uid":"24092809365189981231"}]}
2024-09-28 09:36:59 >>>故障排除日志:删除未同步下发订单成功24092809365189981231
2024-09-28 09:36:59 >>>故障排除日志:终端同步成功后剩余订单列表


===09:38:15===
2024-09-28 09:37:30>>>cash read=00
2024-09-28 09:37:31>>>cash read=29
2024-09-28 09:37:31 >>>回调事件130,cash_status,20029,退钞中
2024-09-28 09:37:31>>>cash read=2F29
2024-09-28 09:37:33>>>cash read=3E
2024-09-28 09:37:37>>>cash read=00
2024-09-28 09:37:38>>>cash read=818F42
2024-09-28 09:37:38>>>cash write=02
2024-09-28 09:37:38 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-09-28 09:37:38>>>cash read=10
2024-09-28 09:37:38 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-09-28 09:37:38 >>>开始打印,排队号为23,订单号为2409280937380003097824
2024-09-28 09:37:38>>>订单2409280937380003097824写入成功,剩余空间为1673500,占用RAM为602.6025390625
删除未同步订单2409280937380003097824
2024-09-28 09:37:40>>>订单2409280937380003097824删除成功,剩余空间为1674500,占用RAM为614.7587890625
检测订单目录中>>>
无未同步订单>>>
2024-09-28 09:37:41 >>>当前Ram内存为587.2216796875
定时检测未同步订单启用
2024-09-28 09:37:41>>>cash write=0C
2024-09-28 09:37:42>>>cash read=3E
2024-09-28 09:37:42 >>>回调事件[910,devices/D0309]
2024-09-28 09:37:42 >>>故障排除日志:上一MQTT订单号缓存列表为24092809365189981231
2024-09-28 09:37:42 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 09:37:42 开始打印,排队:24,票券:2409280937368354766501,订单:24092809373683543780,[2024-09-28 09:37:42支付宝支付10元]
2024-09-28 09:37:44 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409280937368354766501","queue_number":24,"trade_uid":"24092809373683543780"}]}
2024-09-28 09:37:44 >>>故障排除日志:删除未同步下发订单成功24092809373683543780
2024-09-28 09:37:44 >>>故障排除日志:终端同步成功后剩余订单列表


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


===09:40:16===
2024-09-28 09:39:57>>>cash read=1F
2024-09-28 09:39:58>>>cash read=3E


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


===09:45:16===
2024-09-28 09:44:52>>>cash read=1F
2024-09-28 09:44:53>>>cash read=3E


===09:47:17===
2024-09-28 09:46:28>>>cash read=9E
2024-09-28 09:46:29>>>cash read=3E


===09:48:17===
2024-09-28 09:47:56 >>>回调事件[910,devices/D0309]
2024-09-28 09:47:56 >>>故障排除日志:上一MQTT订单号缓存列表为24092809404862510803
2024-09-28 09:47:56 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 09:47:56 开始打印,排队:26,票券:2409280947499049803201,订单:24092809474990493485,[2024-09-28 09:47:56支付宝支付10元]
2024-09-28 09:47:58 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409280947499049803201","queue_number":26,"trade_uid":"24092809474990493485"}]}
2024-09-28 09:47:58 >>>故障排除日志:删除未同步下发订单成功24092809474990493485
2024-09-28 09:47:58 >>>故障排除日志:终端同步成功后剩余订单列表


===09:51:17===
2024-09-28 09:50:52 >>>回调事件[910,devices/D0309]
2024-09-28 09:50:52 >>>故障排除日志:上一MQTT订单号缓存列表为24092809474990493485
2024-09-28 09:50:52 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 09:50:52 开始打印,排队:27,票券:2409280950462961488901,订单:24092809504629610676,[2024-09-28 09:50:51支付宝支付10元]
2024-09-28 09:50:53 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409280950462961488901","queue_number":27,"trade_uid":"24092809504629610676"}]}
2024-09-28 09:50:54 >>>故障排除日志:删除未同步下发订单成功24092809504629610676
2024-09-28 09:50:54 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 09:51:10>>>cash read=9E
2024-09-28 09:51:11>>>cash read=3E


===09:53:17===
2024-09-28 09:52:49>>>cash read=1F
2024-09-28 09:52:50>>>cash read=3E


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


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


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


===10:02:19===
2024-09-28 10:01:42>>>cash read=1F
2024-09-28 10:01:44>>>cash read=3E
2024-09-28 10:01:49>>>cash read=BF
2024-09-28 10:01:50>>>cash read=3E


===10:08:19===
2024-09-28 10:07:18 >>>回调事件[910,devices/D0309]
2024-09-28 10:07:18 >>>故障排除日志:上一MQTT订单号缓存列表为24092809584216199504
2024-09-28 10:07:18 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 10:07:18 开始打印,排队:31,票券:2409281007075154114801,订单:24092810070751536919,[2024-09-28 10:07:18支付宝支付10元]
2024-09-28 10:07:20 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281007075154114801","queue_number":31,"trade_uid":"24092810070751536919"}]}
2024-09-28 10:07:20 >>>故障排除日志:删除未同步下发订单成功24092810070751536919
2024-09-28 10:07:20 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 10:08:10>>>cash read=9E
2024-09-28 10:08:11>>>cash read=3E


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


===10:11:19===
2024-09-28 10:10:34>>>cash read=9E
2024-09-28 10:10:35>>>cash read=3E


===10:13:19===
2024-09-28 10:13:14 >>>回调事件[910,devices/D0309]
2024-09-28 10:13:14 >>>故障排除日志:上一MQTT订单号缓存列表为24092810100404046042
2024-09-28 10:13:14 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 10:13:14 开始打印,排队:33,票券:2409281013066450737901,订单:24092810130664502358,[2024-09-28 10:13:14支付宝支付10元]
2024-09-28 10:13:16 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281013066450737901","queue_number":33,"trade_uid":"24092810130664502358"}]}
2024-09-28 10:13:16 >>>故障排除日志:删除未同步下发订单成功24092810130664502358
2024-09-28 10:13:16 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 10:13:16>>>cash read=9E
2024-09-28 10:13:17>>>cash read=3E


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


===10:16:20===
2024-09-28 10:15:31>>>cash read=9E
2024-09-28 10:15:32>>>cash read=3E


===10:18:20===
2024-09-28 10:18:13 >>>回调事件[910,devices/D0309]
2024-09-28 10:18:13 >>>故障排除日志:上一MQTT订单号缓存列表为24092810135659079210
2024-09-28 10:18:13 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 10:18:13 开始打印,排队:35,票券:2409281018048097562401,订单:24092810180480970101,[2024-09-28 10:18:13微信支付10元]
2024-09-28 10:18:15 >>>回调事件[910,devices/D0309]
2024-09-28 10:18:15 >>>故障排除日志:上一MQTT订单号缓存列表为24092810180480970101
2024-09-28 10:18:15 >>>故障排除日志:终端未同步成功订单列表003524092810180480970101
已接收过此消息,票券号为2409281018048097562401,排队号为35
2024-09-28 10:18:15 开始打印,排队:36,票券:2409281018078167945001,订单:24092810180781675046,[2024-09-28 10:18:14支付宝支付10元]
2024-09-28 10:18:17 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281018048097562401","queue_number":35,"trade_uid":"24092810180480970101"}]}
2024-09-28 10:18:17 >>>故障排除日志:删除未同步下发订单成功24092810180480970101
2024-09-28 10:18:17 >>>故障排除日志:终端同步成功后剩余订单列表003624092810180781675046
2024-09-28 10:18:17 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281018048097562401","queue_number":35,"trade_uid":"24092810180480970101"},{"ticket_no":"2409281018078167945001","queue_number":36,"trade_uid":"24092810180781675046"}]}
2024-09-28 10:18:17 >>>故障排除日志:删除未同步下发订单成功24092810180781675046
2024-09-28 10:18:17 >>>故障排除日志:终端同步成功后剩余订单列表


===10:20:20===
2024-09-28 10:19:19>>>cash read=9E
2024-09-28 10:19:20>>>cash read=3E


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


===10:22:20===
2024-09-28 10:21:25 >>>回调事件[910,devices/D0309]
2024-09-28 10:21:25 >>>故障排除日志:上一MQTT订单号缓存列表为24092810202794082020
2024-09-28 10:21:25 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 10:21:25 开始打印,排队:38,票券:2409281021169007983401,订单:24092810211690075652,[2024-09-28 10:21:25微信支付10元]
2024-09-28 10:21:27 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281021169007983401","queue_number":38,"trade_uid":"24092810211690075652"}]}
2024-09-28 10:21:27 >>>故障排除日志:删除未同步下发订单成功24092810211690075652
2024-09-28 10:21:27 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 10:22:14>>>cash read=9E
2024-09-28 10:22:16>>>cash read=3E


===10:23:21===
2024-09-28 10:23:15>>>cash read=BF
2024-09-28 10:23:16>>>cash read=3E


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


===10:36:21===
2024-09-28 10:35:45 >>>回调事件[910,devices/D0309]
2024-09-28 10:35:45 >>>故障排除日志:上一MQTT订单号缓存列表为24092810334085147860
2024-09-28 10:35:45 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 10:35:45 开始打印,排队:40,票券:2409281035402736447401,订单:24092810354027359941,[2024-09-28 10:35:45微信支付10元]
2024-09-28 10:35:45 开始打印,排队:41,票券:2409281035402736595702,订单:24092810354027359941,[2024-09-28 10:35:45微信支付10元]
2024-09-28 10:35:45 开始打印,排队:42,票券:2409281035402736669103,订单:24092810354027359941,[2024-09-28 10:35:45微信支付10元]
2024-09-28 10:35:51 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281035402736447401","queue_number":40,"trade_uid":"24092810354027359941"},{"ticket_no":"2409281035402736595702","queue_number":41,"trade_uid":"24092810354027359941"},{"ticket_no":"2409281035402736669103","queue_number":42,"trade_uid":"24092810354027359941"}]}
2024-09-28 10:35:51 >>>故障排除日志:删除未同步下发订单成功24092810354027359941
2024-09-28 10:35:51 >>>故障排除日志:删除未同步下发订单成功24092810354027359941
2024-09-28 10:35:51 >>>故障排除日志:删除未同步下发订单成功24092810354027359941
2024-09-28 10:35:51 >>>故障排除日志:终端同步成功后剩余订单列表


===10:37:21===
2024-09-28 10:36:52>>>cash read=BF
2024-09-28 10:36:53>>>cash read=3E
2024-09-28 10:36:55 >>>回调事件[910,devices/D0309]
2024-09-28 10:36:55 >>>故障排除日志:上一MQTT订单号缓存列表为24092810354027359941|24092810354027359941|24092810354027359941
2024-09-28 10:36:55 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 10:36:55 开始打印,排队:43,票券:2409281036482585056301,订单:24092810364825846763,[2024-09-28 10:36:55支付宝支付10元]
2024-09-28 10:36:57 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281036482585056301","queue_number":43,"trade_uid":"24092810364825846763"}]}
2024-09-28 10:36:57 >>>故障排除日志:删除未同步下发订单成功24092810364825846763
2024-09-28 10:36:57 >>>故障排除日志:终端同步成功后剩余订单列表


===10:44:22===
2024-09-28 10:44:04 >>>回调事件[910,devices/D0309]
2024-09-28 10:44:04 >>>故障排除日志:上一MQTT订单号缓存列表为24092810364825846763
2024-09-28 10:44:04 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 10:44:04 开始打印,排队:44,票券:2409281043550707725901,订单:24092810435507073667,[2024-09-28 10:44:03微信支付10元]
2024-09-28 10:44:06 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281043550707725901","queue_number":44,"trade_uid":"24092810435507073667"}]}
2024-09-28 10:44:06 >>>故障排除日志:删除未同步下发订单成功24092810435507073667
2024-09-28 10:44:06 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 10:44:09>>>cash read=BF
2024-09-28 10:44:10>>>cash read=3E
2024-09-28 10:44:15>>>cash read=1F
2024-09-28 10:44:16>>>cash read=3E


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


===10:48:22===
2024-09-28 10:48:12>>>cash read=BF
2024-09-28 10:48:13>>>cash read=3E


===10:49:22===
2024-09-28 10:48:31>>>cash read=BF
2024-09-28 10:48:32>>>cash read=3E


===10:53:23===
2024-09-28 10:52:32>>>cash read=9E
2024-09-28 10:52:33>>>cash read=3E


===10:55:23===
2024-09-28 10:54:40>>>cash read=1F
2024-09-28 10:54:41>>>cash read=3E


===11:00:23===
2024-09-28 10:59:44>>>cash read=9E
2024-09-28 10:59:45>>>cash read=3E


===11:01:24===
2024-09-28 11:00:43>>>cash read=1F
2024-09-28 11:00:45>>>cash read=3E


===11:02:24===
2024-09-28 11:02:18>>>cash read=00
2024-09-28 11:02:18>>>cash read=818F42
2024-09-28 11:02:18>>>cash write=02
2024-09-28 11:02:18 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-09-28 11:02:19>>>cash read=10
2024-09-28 11:02:19 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-09-28 11:02:19 >>>开始打印,排队号为46,订单号为2409281102190003098593
2024-09-28 11:02:19>>>订单2409281102190003098593写入成功,剩余空间为1674500,占用RAM为601.7646484375
删除未同步订单2409281102190003098593
2024-09-28 11:02:21>>>订单2409281102190003098593删除成功,剩余空间为1674500,占用RAM为614.3583984375
检测订单目录中>>>
无未同步订单>>>
2024-09-28 11:02:21 >>>当前Ram内存为587.14453125
定时检测未同步订单启用
2024-09-28 11:02:22>>>cash write=0C


===11:03:24===
2024-09-28 11:02:27>>>cash read=00
2024-09-28 11:02:27>>>cash read=818F42
2024-09-28 11:02:27>>>cash write=02
2024-09-28 11:02:27 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-09-28 11:02:28>>>cash read=10
2024-09-28 11:02:28 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-09-28 11:02:28 >>>开始打印,排队号为47,订单号为2409281102280003099682
定时检测未同步订单关闭
2024-09-28 11:02:28>>>订单2409281102280003099682写入成功,剩余空间为1674000,占用RAM为601.2353515625
删除未同步订单2409281102280003099682
2024-09-28 11:02:30>>>订单2409281102280003099682删除成功,剩余空间为1674500,占用RAM为615.8173828125
检测订单目录中>>>
无未同步订单>>>
2024-09-28 11:02:30 >>>当前Ram内存为587.7060546875
定时检测未同步订单启用
2024-09-28 11:02:31>>>cash write=0C
2024-09-28 11:02:31>>>cash read=00
2024-09-28 11:02:32>>>cash read=818F42
2024-09-28 11:02:32>>>cash write=02
2024-09-28 11:02:32 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-09-28 11:02:33>>>cash read=10
2024-09-28 11:02:33 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-09-28 11:02:33 >>>开始打印,排队号为48,订单号为2409281102330003093611
定时检测未同步订单关闭
2024-09-28 11:02:33>>>订单2409281102330003093611写入成功,剩余空间为1673000,占用RAM为607.0244140625
删除未同步订单2409281102330003093611
2024-09-28 11:02:35>>>订单2409281102330003093611删除成功,剩余空间为1674000,占用RAM为616.5107421875
检测订单目录中>>>
无未同步订单>>>
2024-09-28 11:02:35 >>>当前Ram内存为587.73046875
定时检测未同步订单启用
2024-09-28 11:02:36>>>cash write=0C
2024-09-28 11:02:36>>>cash read=3E
2024-09-28 11:02:37>>>cash read=2F29
2024-09-28 11:02:40>>>cash read=3E
2024-09-28 11:02:41>>>cash read=00
2024-09-28 11:02:41>>>cash read=818F41
2024-09-28 11:02:41>>>cash write=02
2024-09-28 11:02:41 >>>回调事件130,cash_status,10022,进钞中...read money=5
2024-09-28 11:02:42>>>cash read=10
2024-09-28 11:02:42 >>>回调事件130,5,10023,finish Money=5,进钞完成
2024-09-28 11:02:43>>>cash write=0C
2024-09-28 11:02:43>>>cash read=3E
2024-09-28 11:02:48>>>cash read=00
2024-09-28 11:02:48>>>cash read=A0F2
2024-09-28 11:02:49>>>cash read=00
2024-09-28 11:02:53>>>cash read=29
2024-09-28 11:02:53 >>>回调事件130,cash_status,20029,退钞中
2024-09-28 11:02:54>>>cash read=2F
2024-09-28 11:02:55>>>cash read=3E
2024-09-28 11:02:57>>>cash read=00
2024-09-28 11:02:58>>>cash read=818F41
2024-09-28 11:02:58>>>cash write=02
2024-09-28 11:02:58 >>>回调事件130,cash_status,10022,进钞中...read money=5
2024-09-28 11:02:59>>>cash read=10
2024-09-28 11:02:59 >>>回调事件130,5,10023,finish Money=5,进钞完成
2024-09-28 11:02:59 >>>开始打印,排队号为49,订单号为2409281102420003094700
定时检测未同步订单关闭
2024-09-28 11:02:59>>>订单2409281102420003094700写入成功,剩余空间为1671500,占用RAM为614.625
删除未同步订单2409281102420003094700
2024-09-28 11:03:01>>>订单2409281102420003094700删除成功,剩余空间为1672000,占用RAM为625.7509765625
检测订单目录中>>>
无未同步订单>>>
2024-09-28 11:03:01 >>>当前Ram内存为590.4345703125
定时检测未同步订单启用
2024-09-28 11:03:02>>>cash write=0C
2024-09-28 11:03:03>>>cash read=3E


===11:04:24===
2024-09-28 11:03:33>>>cash read=00
2024-09-28 11:03:35>>>cash read=2F29
2024-09-28 11:03:37>>>cash read=00
2024-09-28 11:03:37>>>cash read=818F42
2024-09-28 11:03:37>>>cash write=02
2024-09-28 11:03:37 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-09-28 11:03:37>>>cash read=10
2024-09-28 11:03:37 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-09-28 11:03:37 >>>开始打印,排队号为50,订单号为2409281103370003098543
定时检测未同步订单关闭
2024-09-28 11:03:38>>>订单2409281103370003098543写入成功,剩余空间为1673500,占用RAM为602.0654296875
2024-09-28 11:03:40>>>cash read=818F42
2024-09-28 11:03:40 >>>回调事件130,cash_status,10022,进钞中...read money=10
删除未同步订单2409281103370003098543
2024-09-28 11:03:40>>>订单2409281103370003098543删除成功,剩余空间为1674500,占用RAM为599.0224609375
检测订单目录中>>>
无未同步订单>>>
2024-09-28 11:03:40 >>>当前Ram内存为585.853515625
定时检测未同步订单启用
2024-09-28 11:03:41>>>cash read=10
2024-09-28 11:03:41 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-09-28 11:03:41 >>>开始打印,排队号为51,订单号为2409281103410003099682
定时检测未同步订单关闭
2024-09-28 11:03:41>>>订单2409281103410003099682写入成功,剩余空间为1673000,占用RAM为614.0908203125
2024-09-28 11:03:43>>>cash read=818F42
2024-09-28 11:03:43 >>>回调事件130,cash_status,10022,进钞中...read money=10
删除未同步订单2409281103410003099682
2024-09-28 11:03:43>>>订单2409281103410003099682删除成功,剩余空间为1673500,占用RAM为601.466796875
检测订单目录中>>>
无未同步订单>>>
2024-09-28 11:03:43 >>>当前Ram内存为587.0966796875
定时检测未同步订单启用
2024-09-28 11:03:44>>>cash read=10
2024-09-28 11:03:44 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-09-28 11:03:44 >>>开始打印,排队号为52,订单号为2409281103440003096052
定时检测未同步订单关闭
2024-09-28 11:03:44>>>订单2409281103440003096052写入成功,剩余空间为1672000,占用RAM为610.7431640625
删除未同步订单2409281103440003096052
2024-09-28 11:03:46>>>订单2409281103440003096052删除成功,剩余空间为1673000,占用RAM为619.80859375
检测订单目录中>>>
无未同步订单>>>
2024-09-28 11:03:46 >>>当前Ram内存为588.7158203125
定时检测未同步订单启用
2024-09-28 11:03:46>>>cash read=2F29
2024-09-28 11:03:48>>>cash write=0C
2024-09-28 11:03:48>>>cash read=00
2024-09-28 11:03:48>>>cash read=818F42
2024-09-28 11:03:48>>>cash write=02
2024-09-28 11:03:48 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-09-28 11:03:49>>>cash read=10
2024-09-28 11:03:49 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-09-28 11:03:49 >>>开始打印,排队号为53,订单号为2409281103490003096002
定时检测未同步订单关闭
2024-09-28 11:03:49>>>订单2409281103490003096002写入成功,剩余空间为1671500,占用RAM为616.78515625
2024-09-28 11:03:51>>>cash read=818F42
2024-09-28 11:03:51 >>>回调事件130,cash_status,10022,进钞中...read money=10
删除未同步订单2409281103490003096002
2024-09-28 11:03:51>>>订单2409281103490003096002删除成功,剩余空间为1672000,占用RAM为606.5419921875
检测订单目录中>>>
无未同步订单>>>
2024-09-28 11:03:51 >>>当前Ram内存为589.162109375
定时检测未同步订单启用
2024-09-28 11:03:52>>>cash read=10
2024-09-28 11:03:52 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-09-28 11:03:52 >>>开始打印,排队号为54,订单号为2409281103520003095351
定时检测未同步订单关闭
2024-09-28 11:03:52>>>订单2409281103520003095351写入成功,剩余空间为1670500,占用RAM为620.6513671875
删除未同步订单2409281103520003095351
2024-09-28 11:03:54>>>订单2409281103520003095351删除成功,剩余空间为1671500,占用RAM为622.3056640625
检测订单目录中>>>
无未同步订单>>>
2024-09-28 11:03:54 >>>当前Ram内存为590.4814453125
定时检测未同步订单启用
2024-09-28 11:03:55>>>cash read=818F42
2024-09-28 11:03:55 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-09-28 11:03:55>>>cash read=10
2024-09-28 11:03:55 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-09-28 11:03:55 >>>开始打印,排队号为55,订单号为2409281103550003091721
定时检测未同步订单关闭
2024-09-28 11:03:55>>>订单2409281103550003091721写入成功,剩余空间为1669500,占用RAM为626.9189453125
删除未同步订单2409281103550003091721
2024-09-28 11:03:58>>>订单2409281103550003091721删除成功,剩余空间为1670500,占用RAM为626.017578125
检测订单目录中>>>
无未同步订单>>>
2024-09-28 11:03:58 >>>当前Ram内存为591.6708984375
定时检测未同步订单启用
2024-09-28 11:03:59>>>cash write=0C
2024-09-28 11:03:59>>>cash read=3E


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


===11:08:25===
2024-09-28 11:08:20 >>>回调事件[910,devices/D0309]
2024-09-28 11:08:20 >>>故障排除日志:上一MQTT订单号缓存列表为24092810455231499228
2024-09-28 11:08:20 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 11:08:20 开始打印,排队:56,票券:2409281108099301161501,订单:24092811080993007549,[2024-09-28 11:08:19支付宝支付10元]
2024-09-28 11:08:22 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281108099301161501","queue_number":56,"trade_uid":"24092811080993007549"}]}
2024-09-28 11:08:22 >>>故障排除日志:删除未同步下发订单成功24092811080993007549
2024-09-28 11:08:22 >>>故障排除日志:终端同步成功后剩余订单列表


===11:13:25===
2024-09-28 11:12:29>>>cash read=9E
2024-09-28 11:12:30>>>cash read=3E


===11:14:25===
2024-09-28 11:13:25>>>cash read=BF
2024-09-28 11:13:26>>>cash read=3E
2024-09-28 11:14:13>>>cash read=1F
2024-09-28 11:14:14>>>cash read=3E


===11:16:26===
2024-09-28 11:15:36>>>cash read=1F
2024-09-28 11:15:37>>>cash read=3E
2024-09-28 11:16:10>>>cash read=9E
2024-09-28 11:16:11>>>cash read=3E


===11:20:26===
2024-09-28 11:19:41>>>cash read=BF
2024-09-28 11:19:42>>>cash read=3E


===11:22:26===
2024-09-28 11:22:10>>>cash read=9E
2024-09-28 11:22:11>>>cash read=3E


===11:25:27===
2024-09-28 11:24:35 >>>回调事件[910,devices/D0309]
2024-09-28 11:24:35 >>>故障排除日志:上一MQTT订单号缓存列表为24092811080993007549
2024-09-28 11:24:35 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 11:24:35 开始打印,排队:57,票券:2409281124282748508101,订单:24092811242827475549,[2024-09-28 11:24:34支付宝支付10元]
2024-09-28 11:24:37 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281124282748508101","queue_number":57,"trade_uid":"24092811242827475549"}]}
2024-09-28 11:24:37 >>>故障排除日志:删除未同步下发订单成功24092811242827475549
2024-09-28 11:24:37 >>>故障排除日志:终端同步成功后剩余订单列表


===11:26:27===
2024-09-28 11:25:57>>>cash read=BF
2024-09-28 11:25:58>>>cash read=3E


===11:28:27===
2024-09-28 11:27:27>>>cash read=BF
2024-09-28 11:27:28>>>cash read=3E


===11:31:28===
2024-09-28 11:30:59 >>>回调事件[910,devices/D0309]
2024-09-28 11:30:59 >>>故障排除日志:上一MQTT订单号缓存列表为24092811242827475549
2024-09-28 11:30:59 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 11:30:59 开始打印,排队:58,票券:2409281130425021833101,订单:24092811304250214713,[2024-09-28 11:30:58支付宝支付10元]
2024-09-28 11:31:01 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281130425021833101","queue_number":58,"trade_uid":"24092811304250214713"}]}
2024-09-28 11:31:01 >>>故障排除日志:删除未同步下发订单成功24092811304250214713
2024-09-28 11:31:01 >>>故障排除日志:终端同步成功后剩余订单列表


===11:32:28===
2024-09-28 11:31:27>>>cash read=BF
2024-09-28 11:31:28>>>cash read=3E
2024-09-28 11:31:40 >>>回调事件[910,devices/D0309]
2024-09-28 11:31:40 >>>故障排除日志:上一MQTT订单号缓存列表为24092811304250214713
2024-09-28 11:31:40 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 11:31:40 开始打印,排队:59,票券:2409281131295064466901,订单:24092811312950640070,[2024-09-28 11:31:40支付宝支付10元]
2024-09-28 11:31:42 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281131295064466901","queue_number":59,"trade_uid":"24092811312950640070"}]}
2024-09-28 11:31:42 >>>故障排除日志:删除未同步下发订单成功24092811312950640070
2024-09-28 11:31:42 >>>故障排除日志:终端同步成功后剩余订单列表


===11:33:28===
2024-09-28 11:32:58 >>>回调事件[910,devices/D0309]
2024-09-28 11:32:58 >>>故障排除日志:上一MQTT订单号缓存列表为24092811312950640070
2024-09-28 11:32:58 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 11:32:58 开始打印,排队:60,票券:2409281132462797705901,订单:24092811324627972525,[2024-09-28 11:32:58微信支付10元]
2024-09-28 11:33:00 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281132462797705901","queue_number":60,"trade_uid":"24092811324627972525"}]}
2024-09-28 11:33:00 >>>故障排除日志:删除未同步下发订单成功24092811324627972525
2024-09-28 11:33:00 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 11:33:12>>>cash read=9E
2024-09-28 11:33:13>>>cash read=3E


===11:35:30===
2024-09-28 11:35:26 >>>回调事件[910,devices/D0309]
2024-09-28 11:35:26 >>>故障排除日志:上一MQTT订单号缓存列表为24092811324627972525
2024-09-28 11:35:26 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 11:35:26 开始打印,排队:61,票券:2409281135162668706901,订单:24092811351626682431,[2024-09-28 11:35:25微信支付10元]


===11:37:30===
2024-09-28 11:36:29>>>cash read=9E
2024-09-28 11:36:30>>>cash read=3E


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


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


===11:42:32===
2024-09-28 11:41:56 >>>回调事件[910,devices/D0309]
2024-09-28 11:41:56 >>>故障排除日志:上一MQTT订单号缓存列表为24092811392925778614
2024-09-28 11:41:56 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 11:41:56 开始打印,排队:64,票券:2409281141488703362501,订单:24092811414887028474,[2024-09-28 11:41:56支付宝支付10元]
2024-09-28 11:41:58 >>>回调事件[910,devices/D0309]
2024-09-28 11:41:58 >>>故障排除日志:上一MQTT订单号缓存列表为24092811414887028474
2024-09-28 11:41:58 >>>故障排除日志:终端未同步成功订单列表006424092811414887028474
已接收过此消息,票券号为2409281141488703362501,排队号为64
2024-09-28 11:41:58 开始打印,排队:65,票券:2409281141502790376501,订单:24092811415027897132,[2024-09-28 11:41:58微信支付10元]
2024-09-28 11:42:00 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281141488703362501","queue_number":64,"trade_uid":"24092811414887028474"}]}
2024-09-28 11:42:00 >>>故障排除日志:删除未同步下发订单成功24092811414887028474
2024-09-28 11:42:00 >>>故障排除日志:终端同步成功后剩余订单列表006524092811415027897132
2024-09-28 11:42:00 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281141488703362501","queue_number":64,"trade_uid":"24092811414887028474"},{"ticket_no":"2409281141502790376501","queue_number":65,"trade_uid":"24092811415027897132"}]}
2024-09-28 11:42:00 >>>故障排除日志:删除未同步下发订单成功24092811415027897132
2024-09-28 11:42:01 >>>故障排除日志:终端同步成功后剩余订单列表


===11:48:32===
2024-09-28 11:47:57 >>>回调事件[910,devices/D0309]
2024-09-28 11:47:57 >>>故障排除日志:上一MQTT订单号缓存列表为24092811414887028474|24092811415027897132
2024-09-28 11:47:57 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 11:47:57 开始打印,排队:66,票券:2409281147507480422401,订单:24092811475074799757,[2024-09-28 11:47:57支付宝支付10元]
2024-09-28 11:47:59 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281147507480422401","queue_number":66,"trade_uid":"24092811475074799757"}]}
2024-09-28 11:47:59 >>>故障排除日志:删除未同步下发订单成功24092811475074799757
2024-09-28 11:48:00 >>>故障排除日志:终端同步成功后剩余订单列表


===11:49:34===
2024-09-28 11:48:33 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281148250697860201","queue_number":67,"trade_uid":"24092811482506974779"}]}
2024-09-28 11:48:33 >>>故障排除日志:删除未同步下发订单成功24092811482506974779
2024-09-28 11:48:33 >>>故障排除日志:终端同步成功后剩余订单列表


===11:50:35===
2024-09-28 11:50:05>>>cash read=9E
2024-09-28 11:50:06>>>cash read=3E
2024-09-28 11:50:27>>>cash read=9E
2024-09-28 11:50:29>>>cash read=3E


===11:57:35===
2024-09-28 11:57:12>>>cash read=1F
2024-09-28 11:57:13>>>cash read=3E


===12:00:35===
2024-09-28 11:59:51>>>cash read=9E
2024-09-28 11:59:53>>>cash read=3E


===12:04:36===
2024-09-28 12:04:11>>>cash read=00
2024-09-28 12:04:12>>>cash read=818F42
2024-09-28 12:04:12>>>cash write=02
2024-09-28 12:04:12 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-09-28 12:04:12>>>cash read=10
2024-09-28 12:04:12 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-09-28 12:04:12 >>>开始打印,排队号为68,订单号为2409281204120003094673
2024-09-28 12:04:12>>>订单2409281204120003094673写入成功,剩余空间为1674500,占用RAM为602.134765625
删除未同步订单2409281204120003094673
2024-09-28 12:04:14>>>订单2409281204120003094673删除成功,剩余空间为1674500,占用RAM为613.6298828125
检测订单目录中>>>
无未同步订单>>>
2024-09-28 12:04:15 >>>当前Ram内存为587.169921875
定时检测未同步订单启用
2024-09-28 12:04:16>>>cash write=0C
2024-09-28 12:04:16>>>cash read=3E


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


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


===12:07:36===
2024-09-28 12:07:33>>>cash read=BF
2024-09-28 12:07:34>>>cash read=3E


===12:08:36===
2024-09-28 12:07:38>>>cash read=1F
2024-09-28 12:07:39>>>cash read=3E


===12:10:36===
2024-09-28 12:09:50>>>cash read=00
2024-09-28 12:09:50>>>cash read=818F42
2024-09-28 12:09:50>>>cash write=02
2024-09-28 12:09:50 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-09-28 12:09:51>>>cash read=10
2024-09-28 12:09:51 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-09-28 12:09:51 >>>开始打印,排队号为70,订单号为2409281209510003096262
2024-09-28 12:09:51>>>订单2409281209510003096262写入成功,剩余空间为1674500,占用RAM为603.0927734375
删除未同步订单2409281209510003096262
2024-09-28 12:09:53>>>订单2409281209510003096262删除成功,剩余空间为1674500,占用RAM为614.609375
检测订单目录中>>>
无未同步订单>>>
2024-09-28 12:09:53 >>>当前Ram内存为587.2275390625
定时检测未同步订单启用
2024-09-28 12:09:54>>>cash write=0C
2024-09-28 12:09:54>>>cash read=3E
2024-09-28 12:10:00>>>cash read=9E
2024-09-28 12:10:01>>>cash read=3E


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


===12:12:37===
2024-09-28 12:11:52>>>cash read=1F
2024-09-28 12:11:53>>>cash read=3E


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


===12:14:37===
2024-09-28 12:13:37>>>cash read=BF
2024-09-28 12:13:38>>>cash read=3E


===12:19:37===
2024-09-28 12:18:44>>>cash read=BF
2024-09-28 12:18:45>>>cash read=3E


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


===12:31:38===
2024-09-28 12:30:37 >>>回调事件[910,devices/D0309]
2024-09-28 12:30:38 >>>故障排除日志:上一MQTT订单号缓存列表为24092812222544559426
2024-09-28 12:30:38 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 12:30:38 开始打印,排队:74,票券:2409281230253717135801,订单:24092812302537166656,[2024-09-28 12:30:37支付宝支付10元]
2024-09-28 12:30:39 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281230253717135801","queue_number":74,"trade_uid":"24092812302537166656"}]}
2024-09-28 12:30:39 >>>故障排除日志:删除未同步下发订单成功24092812302537166656
2024-09-28 12:30:39 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 12:31:05 >>>回调事件[910,devices/D0309]
2024-09-28 12:31:05 >>>故障排除日志:上一MQTT订单号缓存列表为24092812302537166656
2024-09-28 12:31:05 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 12:31:05 开始打印,排队:75,票券:2409281230590216308101,订单:24092812305902134560,[2024-09-28 12:31:05微信支付10元]
2024-09-28 12:31:07 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281230590216308101","queue_number":75,"trade_uid":"24092812305902134560"}]}
2024-09-28 12:31:07 >>>故障排除日志:删除未同步下发订单成功24092812305902134560
2024-09-28 12:31:07 >>>故障排除日志:终端同步成功后剩余订单列表


===12:33:38===
2024-09-28 12:33:27>>>cash read=1F
2024-09-28 12:33:28>>>cash read=3E


===12:34:38===
2024-09-28 12:34:04>>>cash read=1F
2024-09-28 12:34:05>>>cash read=3E


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


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


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


===12:47:39===
2024-09-28 12:47:09>>>cash read=1F
2024-09-28 12:47:10>>>cash read=3E


===12:50:40===
2024-09-28 12:49:38>>>cash read=BF
2024-09-28 12:49:39>>>cash read=3E


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


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


===12:59:40===
2024-09-28 12:58:41 >>>回调事件[910,devices/D0309]
2024-09-28 12:58:41 >>>故障排除日志:上一MQTT订单号缓存列表为24092812555926584441
2024-09-28 12:58:41 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 12:58:41 开始打印,排队:81,票券:2409281258304448873001,订单:24092812583044483281,[2024-09-28 12:58:41支付宝支付10元]
2024-09-28 12:58:43 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281258304448873001","queue_number":81,"trade_uid":"24092812583044483281"}]}
2024-09-28 12:58:43 >>>故障排除日志:删除未同步下发订单成功24092812583044483281
2024-09-28 12:58:43 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 12:59:15>>>cash read=1F
2024-09-28 12:59:16>>>cash read=3E


===13:04:41===
2024-09-28 13:04:21 >>>回调事件[910,devices/D0309]
2024-09-28 13:04:21 >>>故障排除日志:上一MQTT订单号缓存列表为24092812583044483281
2024-09-28 13:04:21 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 13:04:21 开始打印,排队:82,票券:2409281304147210253401,订单:24092813041472098812,[2024-09-28 13:04:21支付宝支付10元]
2024-09-28 13:04:23 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281304147210253401","queue_number":82,"trade_uid":"24092813041472098812"}]}
2024-09-28 13:04:23 >>>故障排除日志:删除未同步下发订单成功24092813041472098812
2024-09-28 13:04:23 >>>故障排除日志:终端同步成功后剩余订单列表


===13:06:41===
2024-09-28 13:05:42>>>cash read=9E
2024-09-28 13:05:43>>>cash read=3E


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


===13:10:42===
2024-09-28 13:10:16>>>cash read=9E
2024-09-28 13:10:18>>>cash read=3E


===13:14:42===
2024-09-28 13:13:57>>>cash read=1F
2024-09-28 13:13:58>>>cash read=3E
2024-09-28 13:14:34>>>cash read=00
2024-09-28 13:14:35>>>cash read=2F29
2024-09-28 13:14:37>>>cash read=3E
2024-09-28 13:14:39>>>cash read=00


===13:15:42===
2024-09-28 13:14:41>>>cash read=2F29
2024-09-28 13:14:43>>>cash read=00
2024-09-28 13:14:44>>>cash read=2F29
2024-09-28 13:14:45>>>cash read=00
2024-09-28 13:14:46>>>cash read=29
2024-09-28 13:14:46 >>>回调事件130,cash_status,20029,退钞中
2024-09-28 13:14:47>>>cash read=2F29
2024-09-28 13:14:48>>>cash read=3E
2024-09-28 13:15:10>>>cash read=BF
2024-09-28 13:15:12>>>cash read=3E
2024-09-28 13:15:34>>>cash read=29
2024-09-28 13:15:34 >>>回调事件130,cash_status,20029,退钞中
2024-09-28 13:15:34>>>cash read=2F29
2024-09-28 13:15:35>>>cash read=00
2024-09-28 13:15:36>>>cash read=818F43
2024-09-28 13:15:36>>>cash write=02
2024-09-28 13:15:36 >>>回调事件130,cash_status,10022,进钞中...read money=20
2024-09-28 13:15:36>>>cash read=10
2024-09-28 13:15:36 >>>回调事件130,20,10023,finish Money=20,进钞完成
2024-09-28 13:15:36 >>>开始打印,排队号为84,订单号为2409281315360003099539
2024-09-28 13:15:37 >>>开始打印,排队号为85,订单号为2409281315360003099539
2024-09-28 13:15:37>>>订单2409281315360003099539写入成功,剩余空间为1672500,占用RAM为612.3310546875
删除未同步订单2409281315360003099539
2024-09-28 13:15:40>>>订单2409281315360003099539删除成功,剩余空间为1674000,占用RAM为625.8837890625
检测订单目录中>>>
无未同步订单>>>
2024-09-28 13:15:40 >>>当前Ram内存为589.1796875
定时检测未同步订单启用


===13:16:43===
2024-09-28 13:15:41>>>cash write=0C
2024-09-28 13:15:41>>>cash read=00
2024-09-28 13:15:42>>>cash read=2F29
2024-09-28 13:15:45>>>cash read=3E
2024-09-28 13:15:49>>>cash read=00
2024-09-28 13:15:49>>>cash read=818F43
2024-09-28 13:15:49>>>cash write=02
2024-09-28 13:15:49 >>>回调事件130,cash_status,10022,进钞中...read money=20
2024-09-28 13:15:50>>>cash read=10
2024-09-28 13:15:50 >>>回调事件130,20,10023,finish Money=20,进钞完成
2024-09-28 13:15:50 >>>开始打印,排队号为86,订单号为2409281315500003094557
2024-09-28 13:15:50 >>>开始打印,排队号为87,订单号为2409281315500003094557
定时检测未同步订单关闭
2024-09-28 13:15:50>>>订单2409281315500003094557写入成功,剩余空间为1673000,占用RAM为610.091796875
2024-09-28 13:15:54>>>cash read=818F43
2024-09-28 13:15:54 >>>回调事件130,cash_status,10022,进钞中...read money=20
删除未同步订单2409281315500003094557
2024-09-28 13:15:54>>>订单2409281315500003094557删除成功,剩余空间为1674500,占用RAM为597.3583984375
检测订单目录中>>>
无未同步订单>>>
2024-09-28 13:15:54 >>>当前Ram内存为589.0849609375
定时检测未同步订单启用
2024-09-28 13:15:54>>>cash read=10
2024-09-28 13:15:54 >>>回调事件130,20,10023,finish Money=20,进钞完成
2024-09-28 13:15:54 >>>开始打印,排队号为88,订单号为2409281315540003092717
2024-09-28 13:15:55 >>>开始打印,排队号为89,订单号为2409281315540003092717
定时检测未同步订单关闭
2024-09-28 13:15:55>>>订单2409281315540003092717写入成功,剩余空间为1672000,占用RAM为618.3427734375
删除未同步订单2409281315540003092717
2024-09-28 13:15:59>>>订单2409281315540003092717删除成功,剩余空间为1673500,占用RAM为631.50390625
检测订单目录中>>>
无未同步订单>>>
2024-09-28 13:15:59 >>>当前Ram内存为590.9033203125
定时检测未同步订单启用
2024-09-28 13:16:00>>>cash write=0C
2024-09-28 13:16:01>>>cash read=3E


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


===13:18:43===
2024-09-28 13:17:55 >>>回调事件[910,devices/D0309]
2024-09-28 13:17:55 >>>故障排除日志:上一MQTT订单号缓存列表为24092813090068801648
2024-09-28 13:17:55 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 13:17:55 开始打印,排队:90,票券:2409281317503661490601,订单:24092813175036609059,[2024-09-28 13:17:55支付宝支付10元]
2024-09-28 13:17:55 开始打印,排队:91,票券:2409281317503661700502,订单:24092813175036609059,[2024-09-28 13:17:55支付宝支付10元]
2024-09-28 13:17:59 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281317503661490601","queue_number":90,"trade_uid":"24092813175036609059"},{"ticket_no":"2409281317503661700502","queue_number":91,"trade_uid":"24092813175036609059"}]}
2024-09-28 13:17:59 >>>故障排除日志:删除未同步下发订单成功24092813175036609059
2024-09-28 13:17:59 >>>故障排除日志:删除未同步下发订单成功24092813175036609059
2024-09-28 13:17:59 >>>故障排除日志:终端同步成功后剩余订单列表


===13:24:43===
2024-09-28 13:24:29>>>cash read=BF
2024-09-28 13:24:30>>>cash read=3E


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


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


===13:28:44===
2024-09-28 13:28:07>>>cash read=1F
2024-09-28 13:28:08>>>cash read=3E


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


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


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


===13:43:46===
2024-09-28 13:43:10>>>cash read=9E
2024-09-28 13:43:11>>>cash read=3E


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


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


===13:49:47===
2024-09-28 13:49:16>>>cash read=1F
2024-09-28 13:49:17>>>cash read=3E
2024-09-28 13:49:28>>>cash read=BF
2024-09-28 13:49:29>>>cash read=3E


===13:57:47===
2024-09-28 13:57:07>>>cash read=9E
2024-09-28 13:57:08>>>cash read=3E


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


===13:59:47===
2024-09-28 13:58:48 >>>回调事件[910,devices/D0309]
2024-09-28 13:58:48 >>>故障排除日志:上一MQTT订单号缓存列表为24092813582437851438
2024-09-28 13:58:48 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 13:58:48 开始打印,排队:100,票券:2409281358422338140101,订单:24092813584223375983,[2024-09-28 13:58:47支付宝支付10元]
2024-09-28 13:58:49 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281358422338140101","queue_number":100,"trade_uid":"24092813584223375983"}]}
2024-09-28 13:58:49 >>>故障排除日志:删除未同步下发订单成功24092813584223375983
2024-09-28 13:58:50 >>>故障排除日志:终端同步成功后剩余订单列表


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


===14:01:48===
2024-09-28 14:01:22>>>cash read=9E
2024-09-28 14:01:23>>>cash read=3E


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


===14:04:48===
2024-09-28 14:03:48>>>cash read=9E
2024-09-28 14:03:49>>>cash read=3E


===14:05:48===
2024-09-28 14:05:10>>>cash read=9E
2024-09-28 14:05:11>>>cash read=3E


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


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


===14:11:49===
2024-09-28 14:11:37 >>>回调事件[910,devices/D0309]
2024-09-28 14:11:37 >>>故障排除日志:上一MQTT订单号缓存列表为24092814075906887718
2024-09-28 14:11:37 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 14:11:37 开始打印,排队:105,票券:2409281411318158032801,订单:24092814113181574892,[2024-09-28 14:11:36支付宝支付10元]
2024-09-28 14:11:39 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281411318158032801","queue_number":105,"trade_uid":"24092814113181574892"}]}
2024-09-28 14:11:39 >>>故障排除日志:删除未同步下发订单成功24092814113181574892
2024-09-28 14:11:39 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


===14:19:50===
2024-09-28 14:19:24>>>cash read=BF
2024-09-28 14:19:25>>>cash read=3E


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


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


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


===14:31:51===
2024-09-28 14:31:04 >>>回调事件[910,devices/D0309]
2024-09-28 14:31:04 >>>故障排除日志:上一MQTT订单号缓存列表为24092814303780444061
2024-09-28 14:31:04 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 14:31:04 开始打印,排队:112,票券:2409281430525437799601,订单:24092814305254374020,[2024-09-28 14:31:04支付宝支付10元]
2024-09-28 14:31:06 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281430525437799601","queue_number":112,"trade_uid":"24092814305254374020"}]}
2024-09-28 14:31:06 >>>故障排除日志:删除未同步下发订单成功24092814305254374020
2024-09-28 14:31:06 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 14:31:27 >>>回调事件[910,devices/D0309]
2024-09-28 14:31:27 >>>故障排除日志:上一MQTT订单号缓存列表为24092814305254374020
2024-09-28 14:31:27 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 14:31:27 开始打印,排队:113,票券:2409281431203405115901,订单:24092814312034046751,[2024-09-28 14:31:27微信支付10元]
2024-09-28 14:31:29 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281431203405115901","queue_number":113,"trade_uid":"24092814312034046751"}]}
2024-09-28 14:31:29 >>>故障排除日志:删除未同步下发订单成功24092814312034046751
2024-09-28 14:31:29 >>>故障排除日志:终端同步成功后剩余订单列表


===14:32:51===
2024-09-28 14:31:56>>>cash read=9E
2024-09-28 14:31:58>>>cash read=3E
2024-09-28 14:32:02 >>>回调事件[910,devices/D0309]
2024-09-28 14:32:02 >>>故障排除日志:上一MQTT订单号缓存列表为24092814312034046751
2024-09-28 14:32:02 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 14:32:02 开始打印,排队:114,票券:2409281431580223546701,订单:24092814315802228472,[2024-09-28 14:32:02支付宝支付10元]
2024-09-28 14:32:04 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281431580223546701","queue_number":114,"trade_uid":"24092814315802228472"}]}
2024-09-28 14:32:04 >>>故障排除日志:删除未同步下发订单成功24092814315802228472
2024-09-28 14:32:04 >>>故障排除日志:终端同步成功后剩余订单列表


===14:33:52===
2024-09-28 14:33:47>>>cash read=9E
2024-09-28 14:33:48>>>cash read=3E


===14:34:52===
2024-09-28 14:34:44>>>cash read=BF
2024-09-28 14:34:46>>>cash read=3E


===14:36:52===
2024-09-28 14:36:35 >>>回调事件[910,devices/D0309]
2024-09-28 14:36:35 >>>故障排除日志:上一MQTT订单号缓存列表为24092814315802228472
2024-09-28 14:36:35 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 14:36:35 开始打印,排队:115,票券:2409281436288992110101,订单:24092814362889915986,[2024-09-28 14:36:35支付宝支付10元]
2024-09-28 14:36:37 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281436288992110101","queue_number":115,"trade_uid":"24092814362889915986"}]}
2024-09-28 14:36:37 >>>故障排除日志:删除未同步下发订单成功24092814362889915986
2024-09-28 14:36:37 >>>故障排除日志:终端同步成功后剩余订单列表


===14:40:52===
2024-09-28 14:40:06>>>cash read=BF
2024-09-28 14:40:07>>>cash read=3E


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


===14:49:53===
2024-09-28 14:49:31 >>>回调事件[910,devices/D0309]
2024-09-28 14:49:31 >>>故障排除日志:上一MQTT订单号缓存列表为24092814453290273859
2024-09-28 14:49:31 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 14:49:31 开始打印,排队:117,票券:2409281449179504883501,订单:24092814491795045102,[2024-09-28 14:49:32支付宝支付10元]
2024-09-28 14:49:33 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281449179504883501","queue_number":117,"trade_uid":"24092814491795045102"}]}
2024-09-28 14:49:33 >>>故障排除日志:删除未同步下发订单成功24092814491795045102
2024-09-28 14:49:33 >>>故障排除日志:终端同步成功后剩余订单列表


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


===15:07:54===
2024-09-28 15:07:45>>>cash read=BF
2024-09-28 15:07:47>>>cash read=3E


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


===15:09:54===
2024-09-28 15:08:56 >>>回调事件[910,devices/D0309]
2024-09-28 15:08:56 >>>故障排除日志:上一MQTT订单号缓存列表为24092815074902779790
2024-09-28 15:08:56 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 15:08:56 开始打印,排队:120,票券:2409281508471137315201,订单:24092815084711369484,[2024-09-28 15:08:56支付宝支付10元]
2024-09-28 15:08:58 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281508471137315201","queue_number":120,"trade_uid":"24092815084711369484"}]}
2024-09-28 15:08:58 >>>故障排除日志:删除未同步下发订单成功24092815084711369484
2024-09-28 15:08:58 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 15:09:39 >>>回调事件[910,devices/D0309]
2024-09-28 15:09:39 >>>故障排除日志:上一MQTT订单号缓存列表为24092815084711369484
2024-09-28 15:09:39 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 15:09:39 开始打印,排队:121,票券:2409281509331933987401,订单:24092815093319336147,[2024-09-28 15:09:39支付宝支付10元]
2024-09-28 15:09:41 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281509331933987401","queue_number":121,"trade_uid":"24092815093319336147"}]}
2024-09-28 15:09:41 >>>故障排除日志:删除未同步下发订单成功24092815093319336147
2024-09-28 15:09:41 >>>故障排除日志:终端同步成功后剩余订单列表


===15:11:54===
2024-09-28 15:11:15>>>cash read=9E
2024-09-28 15:11:17>>>cash read=3E
2024-09-28 15:11:27 >>>回调事件[910,devices/D0309]
2024-09-28 15:11:27 >>>故障排除日志:上一MQTT订单号缓存列表为24092815093319336147
2024-09-28 15:11:27 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 15:11:27 开始打印,排队:122,票券:2409281511166822802301,订单:24092815111668222939,[2024-09-28 15:11:27支付宝支付10元]
2024-09-28 15:11:27 开始打印,排队:123,票券:2409281511166823003902,订单:24092815111668222939,[2024-09-28 15:11:27支付宝支付10元]
2024-09-28 15:11:31 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281511166822802301","queue_number":122,"trade_uid":"24092815111668222939"},{"ticket_no":"2409281511166823003902","queue_number":123,"trade_uid":"24092815111668222939"}]}
2024-09-28 15:11:31 >>>故障排除日志:删除未同步下发订单成功24092815111668222939
2024-09-28 15:11:31 >>>故障排除日志:删除未同步下发订单成功24092815111668222939
2024-09-28 15:11:31 >>>故障排除日志:终端同步成功后剩余订单列表


===15:13:55===
2024-09-28 15:13:09>>>cash read=0A
2024-09-28 15:13:10>>>cash read=3E
2024-09-28 15:13:23 >>>回调事件[910,devices/D0309]
2024-09-28 15:13:23 >>>故障排除日志:上一MQTT订单号缓存列表为24092815111668222939|24092815111668222939
2024-09-28 15:13:23 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 15:13:23 开始打印,排队:124,票券:2409281513166979503601,订单:24092815131669790136,[2024-09-28 15:13:23微信支付10元]
2024-09-28 15:13:25 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281513166979503601","queue_number":124,"trade_uid":"24092815131669790136"}]}
2024-09-28 15:13:25 >>>故障排除日志:删除未同步下发订单成功24092815131669790136
2024-09-28 15:13:25 >>>故障排除日志:终端同步成功后剩余订单列表


===15:15:55===
2024-09-28 15:15:30>>>cash read=00
2024-09-28 15:15:31>>>cash read=818F42
2024-09-28 15:15:31>>>cash write=02
2024-09-28 15:15:31 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-09-28 15:15:32>>>cash read=10
2024-09-28 15:15:32 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-09-28 15:15:32 >>>开始打印,排队号为125,订单号为2409281515320003099456
2024-09-28 15:15:32>>>订单2409281515320003099456写入成功,剩余空间为1674500,占用RAM为602.6767578125
删除未同步订单2409281515320003099456
2024-09-28 15:15:34>>>订单2409281515320003099456删除成功,剩余空间为1674500,占用RAM为614.8369140625
检测订单目录中>>>
无未同步订单>>>
2024-09-28 15:15:34 >>>当前Ram内存为587.4775390625
定时检测未同步订单启用
2024-09-28 15:15:35>>>cash write=0C
2024-09-28 15:15:35>>>cash read=3E


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


===15:19:56===
2024-09-28 15:19:33>>>cash read=9E
2024-09-28 15:19:34>>>cash read=3E


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


===15:26:56===
2024-09-28 15:26:35 >>>回调事件[910,devices/D0309]
2024-09-28 15:26:35 >>>故障排除日志:上一MQTT订单号缓存列表为24092815231356349751
2024-09-28 15:26:35 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 15:26:35 开始打印,排队:127,票券:2409281526287847411301,订单:24092815262878470476,[2024-09-28 15:26:34支付宝支付10元]
2024-09-28 15:26:37 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281526287847411301","queue_number":127,"trade_uid":"24092815262878470476"}]}
2024-09-28 15:26:37 >>>故障排除日志:删除未同步下发订单成功24092815262878470476
2024-09-28 15:26:37 >>>故障排除日志:终端同步成功后剩余订单列表


===15:29:57===
2024-09-28 15:29:42>>>cash read=9E
2024-09-28 15:29:43>>>cash read=3E


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


===15:37:57===
2024-09-28 15:37:13>>>cash read=1F
2024-09-28 15:37:14>>>cash read=3E


===15:40:57===
2024-09-28 15:40:00>>>cash read=9E
2024-09-28 15:40:03>>>cash read=3E


===15:41:58===
2024-09-28 15:41:35 >>>回调事件[910,devices/D0309]
2024-09-28 15:41:35 >>>故障排除日志:上一MQTT订单号缓存列表为24092815355237434267
2024-09-28 15:41:35 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 15:41:35 开始打印,排队:129,票券:2409281541250015120601,订单:24092815412500147489,[2024-09-28 15:41:34支付宝支付10元]
2024-09-28 15:41:37 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281541250015120601","queue_number":129,"trade_uid":"24092815412500147489"}]}
2024-09-28 15:41:37 >>>故障排除日志:删除未同步下发订单成功24092815412500147489
2024-09-28 15:41:37 >>>故障排除日志:终端同步成功后剩余订单列表


===15:45:58===
2024-09-28 15:45:49>>>cash read=9E
2024-09-28 15:45:50>>>cash read=3E
2024-09-28 15:45:54 >>>回调事件[910,devices/D0309]
2024-09-28 15:45:54 >>>故障排除日志:上一MQTT订单号缓存列表为24092815412500147489
2024-09-28 15:45:54 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 15:45:54 开始打印,排队:130,票券:2409281545460342853801,订单:24092815454603423915,[2024-09-28 15:45:54支付宝支付10元]
2024-09-28 15:45:56 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281545460342853801","queue_number":130,"trade_uid":"24092815454603423915"}]}
2024-09-28 15:45:56 >>>故障排除日志:删除未同步下发订单成功24092815454603423915
2024-09-28 15:45:56 >>>故障排除日志:终端同步成功后剩余订单列表


===15:47:58===
2024-09-28 15:47:22>>>cash read=1F
2024-09-28 15:47:23>>>cash read=3E


===15:49:58===
2024-09-28 15:49:32 >>>回调事件[910,devices/D0309]
2024-09-28 15:49:32 >>>故障排除日志:上一MQTT订单号缓存列表为24092815454603423915
2024-09-28 15:49:32 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 15:49:32 开始打印,排队:131,票券:2409281549236820198601,订单:24092815492368196693,[2024-09-28 15:49:31微信支付10元]
2024-09-28 15:49:34 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281549236820198601","queue_number":131,"trade_uid":"24092815492368196693"}]}
2024-09-28 15:49:34 >>>故障排除日志:删除未同步下发订单成功24092815492368196693
2024-09-28 15:49:34 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 15:49:44>>>cash read=BF
2024-09-28 15:49:45>>>cash read=3E


===15:53:00===
2024-09-28 15:52:56 >>>回调事件[910,devices/D0309]
2024-09-28 15:52:56 >>>故障排除日志:上一MQTT订单号缓存列表为24092815492368196693
2024-09-28 15:52:56 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 15:52:56 开始打印,排队:132,票券:2409281552497643353701,订单:24092815524976429545,[2024-09-28 15:52:56微信支付10元]


===15:54:00===
2024-09-28 15:52:58 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281552497643353701","queue_number":132,"trade_uid":"24092815524976429545"}]}
2024-09-28 15:52:58 >>>故障排除日志:删除未同步下发订单成功24092815524976429545
2024-09-28 15:52:58 >>>故障排除日志:终端同步成功后剩余订单列表


===15:56:00===
2024-09-28 15:55:20>>>cash read=BF
2024-09-28 15:55:21>>>cash read=3E
2024-09-28 15:55:23 >>>回调事件[910,devices/D0309]
2024-09-28 15:55:23 >>>故障排除日志:上一MQTT订单号缓存列表为24092815524976429545
2024-09-28 15:55:23 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 15:55:23 开始打印,排队:133,票券:2409281555166669425201,订单:24092815551666689159,[2024-09-28 15:55:24微信支付10元]
2024-09-28 15:55:25 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281555166669425201","queue_number":133,"trade_uid":"24092815551666689159"}]}
2024-09-28 15:55:25 >>>故障排除日志:删除未同步下发订单成功24092815551666689159
2024-09-28 15:55:25 >>>故障排除日志:终端同步成功后剩余订单列表


===15:58:00===
2024-09-28 15:57:01>>>cash read=00
2024-09-28 15:57:02>>>cash read=29
2024-09-28 15:57:02 >>>回调事件130,cash_status,20029,退钞中
2024-09-28 15:57:02>>>cash read=2F29
2024-09-28 15:57:03>>>cash read=00
2024-09-28 15:57:04>>>cash read=2F2901
2024-09-28 15:57:06>>>cash read=00
2024-09-28 15:57:07>>>cash read=2F29
2024-09-28 15:57:08>>>cash read=3E


===16:03:00===
2024-09-28 16:02:44>>>cash read=BF
2024-09-28 16:02:45>>>cash read=3E


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


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


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


===16:15:01===
2024-09-28 16:14:29>>>cash read=BF
2024-09-28 16:14:30>>>cash read=3E


===16:16:02===
2024-09-28 16:15:37 >>>回调事件[910,devices/D0309]
2024-09-28 16:15:37 >>>故障排除日志:上一MQTT订单号缓存列表为24092816132366369606
2024-09-28 16:15:37 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 16:15:37 开始打印,排队:137,票券:2409281615329635551801,订单:24092816153296349826,[2024-09-28 16:15:37支付宝支付10元]
2024-09-28 16:15:39 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281615329635551801","queue_number":137,"trade_uid":"24092816153296349826"}]}
2024-09-28 16:15:39 >>>故障排除日志:删除未同步下发订单成功24092816153296349826
2024-09-28 16:15:39 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 16:15:41 >>>回调事件[910,devices/D0309]
2024-09-28 16:15:41 >>>故障排除日志:上一MQTT订单号缓存列表为24092816153296349826
2024-09-28 16:15:41 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 16:15:41 开始打印,排队:138,票券:2409281615329451024301,订单:24092816153294505065,[2024-09-28 16:15:41微信支付10元]
2024-09-28 16:15:43 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281615329451024301","queue_number":138,"trade_uid":"24092816153294505065"}]}
2024-09-28 16:15:43 >>>故障排除日志:删除未同步下发订单成功24092816153294505065
2024-09-28 16:15:43 >>>故障排除日志:终端同步成功后剩余订单列表


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


===16:19:02===
2024-09-28 16:18:26 >>>回调事件[910,devices/D0309]
2024-09-28 16:18:26 >>>故障排除日志:上一MQTT订单号缓存列表为24092816170454594125
2024-09-28 16:18:26 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 16:18:26 开始打印,排队:140,票券:2409281618190397101901,订单:24092816181903966678,[2024-09-28 16:18:25支付宝支付10元]
2024-09-28 16:18:28 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281618190397101901","queue_number":140,"trade_uid":"24092816181903966678"}]}
2024-09-28 16:18:28 >>>故障排除日志:删除未同步下发订单成功24092816181903966678
2024-09-28 16:18:28 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 16:18:39 >>>回调事件[910,devices/D0309]
2024-09-28 16:18:39 >>>故障排除日志:上一MQTT订单号缓存列表为24092816181903966678
2024-09-28 16:18:39 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 16:18:39 开始打印,排队:141,票券:2409281618343617179701,订单:24092816183436166836,[2024-09-28 16:18:39微信支付10元]
2024-09-28 16:18:41 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281618343617179701","queue_number":141,"trade_uid":"24092816183436166836"}]}
2024-09-28 16:18:41 >>>故障排除日志:删除未同步下发订单成功24092816183436166836
2024-09-28 16:18:41 >>>故障排除日志:终端同步成功后剩余订单列表


===16:23:03===
2024-09-28 16:22:51>>>cash read=1F
2024-09-28 16:22:53>>>cash read=3E


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


===16:27:03===
2024-09-28 16:26:13>>>cash read=BF
2024-09-28 16:26:14>>>cash read=3E
2024-09-28 16:26:26>>>cash read=9E
2024-09-28 16:26:27>>>cash read=3E


===16:31:04===
2024-09-28 16:30:40 >>>回调事件[910,devices/D0309]
2024-09-28 16:30:40 >>>故障排除日志:上一MQTT订单号缓存列表为24092816245452906805
2024-09-28 16:30:40 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 16:30:40 开始打印,排队:143,票券:2409281630349162098201,订单:24092816303491617408,[2024-09-28 16:30:41支付宝支付10元]
2024-09-28 16:30:42 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281630349162098201","queue_number":143,"trade_uid":"24092816303491617408"}]}
2024-09-28 16:30:42 >>>故障排除日志:删除未同步下发订单成功24092816303491617408
2024-09-28 16:30:42 >>>故障排除日志:终端同步成功后剩余订单列表


===16:34:04===
2024-09-28 16:33:44>>>cash read=9E
2024-09-28 16:33:45>>>cash read=3E


===16:38:04===
2024-09-28 16:37:22 >>>回调事件[910,devices/D0309]
2024-09-28 16:37:22 >>>故障排除日志:上一MQTT订单号缓存列表为24092816303491617408
2024-09-28 16:37:22 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 16:37:22 开始打印,排队:144,票券:2409281637156556931001,订单:24092816371565565082,[2024-09-28 16:37:22支付宝支付10元]
2024-09-28 16:37:24 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281637156556931001","queue_number":144,"trade_uid":"24092816371565565082"}]}
2024-09-28 16:37:24 >>>故障排除日志:删除未同步下发订单成功24092816371565565082
2024-09-28 16:37:24 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 16:37:44>>>cash read=9E
2024-09-28 16:37:46>>>cash read=3E


===16:41:05===
2024-09-28 16:40:33>>>cash read=00
2024-09-28 16:40:34>>>cash read=00818F42
2024-09-28 16:40:34>>>cash write=02
2024-09-28 16:40:34 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-09-28 16:40:34>>>cash read=10
2024-09-28 16:40:34 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-09-28 16:40:34 >>>开始打印,排队号为145,订单号为2409281640340003098773
2024-09-28 16:40:35>>>订单2409281640340003098773写入成功,剩余空间为1674500,占用RAM为602.1572265625
删除未同步订单2409281640340003098773
2024-09-28 16:40:37>>>订单2409281640340003098773删除成功,剩余空间为1674500,占用RAM为614.6953125
检测订单目录中>>>
无未同步订单>>>
2024-09-28 16:40:37 >>>当前Ram内存为587.421875
定时检测未同步订单启用
2024-09-28 16:40:38>>>cash write=0C
2024-09-28 16:40:38>>>cash read=3E


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


===16:46:05===
2024-09-28 16:45:29 >>>回调事件[910,devices/D0309]
2024-09-28 16:45:29 >>>故障排除日志:上一MQTT订单号缓存列表为24092816371565565082
2024-09-28 16:45:29 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 16:45:29 开始打印,排队:146,票券:2409281645227410252701,订单:24092816452274097223,[2024-09-28 16:45:29支付宝支付10元]
2024-09-28 16:45:31 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281645227410252701","queue_number":146,"trade_uid":"24092816452274097223"}]}
2024-09-28 16:45:31 >>>故障排除日志:删除未同步下发订单成功24092816452274097223
2024-09-28 16:45:31 >>>故障排除日志:终端同步成功后剩余订单列表


===16:49:05===
2024-09-28 16:49:00>>>cash read=9E
2024-09-28 16:49:02>>>cash read=3E


===16:51:06===
2024-09-28 16:50:50 >>>回调事件[910,devices/D0309]
2024-09-28 16:50:50 >>>故障排除日志:上一MQTT订单号缓存列表为24092816452274097223
2024-09-28 16:50:50 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 16:50:50 开始打印,排队:147,票券:2409281650438912737001,订单:24092816504389122179,[2024-09-28 16:50:50支付宝支付10元]
2024-09-28 16:50:52 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281650438912737001","queue_number":147,"trade_uid":"24092816504389122179"}]}
2024-09-28 16:50:52 >>>故障排除日志:删除未同步下发订单成功24092816504389122179
2024-09-28 16:50:52 >>>故障排除日志:终端同步成功后剩余订单列表


===16:52:06===
2024-09-28 16:51:55>>>cash read=9E
2024-09-28 16:51:56>>>cash read=3E


===16:57:07===
2024-09-28 16:57:03>>>cash read=9E
2024-09-28 16:57:04>>>cash read=3E


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


===17:04:07===
2024-09-28 17:03:08>>>cash read=BF
2024-09-28 17:03:10>>>cash read=3E
2024-09-28 17:03:19>>>cash read=00
2024-09-28 17:03:19>>>cash read=818F42
2024-09-28 17:03:19>>>cash write=02
2024-09-28 17:03:19 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-09-28 17:03:19>>>cash read=10
2024-09-28 17:03:19 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-09-28 17:03:19 >>>开始打印,排队号为149,订单号为2409281703190003097839
2024-09-28 17:03:20>>>订单2409281703190003097839写入成功,剩余空间为1674000,占用RAM为600.7265625
删除未同步订单2409281703190003097839
2024-09-28 17:03:22>>>订单2409281703190003097839删除成功,剩余空间为1674500,占用RAM为614.7685546875
检测订单目录中>>>
无未同步订单>>>
2024-09-28 17:03:22 >>>当前Ram内存为585.81640625
定时检测未同步订单启用
2024-09-28 17:03:23>>>cash write=0C
2024-09-28 17:03:23>>>cash read=3E


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


===17:07:08===
2024-09-28 17:06:19>>>cash read=9E
2024-09-28 17:06:20>>>cash read=3E


===17:09:08===
2024-09-28 17:08:08 >>>回调事件[910,devices/D0309]
2024-09-28 17:08:08 >>>故障排除日志:上一MQTT订单号缓存列表为24092817012179871084
2024-09-28 17:08:08 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 17:08:08 开始打印,排队:150,票券:2409281708030969650701,订单:24092817080309690508,[2024-09-28 17:08:08支付宝支付10元]
2024-09-28 17:08:11 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281708030969650701","queue_number":150,"trade_uid":"24092817080309690508"}]}
2024-09-28 17:08:11 >>>故障排除日志:删除未同步下发订单成功24092817080309690508
2024-09-28 17:08:11 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 17:08:52>>>cash read=BF
2024-09-28 17:08:54>>>cash read=3E


===17:11:09===
2024-09-28 17:10:08 >>>回调事件[910,devices/D0309]
2024-09-28 17:10:08 >>>故障排除日志:上一MQTT订单号缓存列表为24092817080309690508
2024-09-28 17:10:08 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 17:10:08 开始打印,排队:151,票券:2409281710013612639001,订单:24092817100136121743,[2024-09-28 17:10:08微信支付10元]
2024-09-28 17:10:10 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281710013612639001","queue_number":151,"trade_uid":"24092817100136121743"}]}
2024-09-28 17:10:10 >>>故障排除日志:删除未同步下发订单成功24092817100136121743
2024-09-28 17:10:10 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 17:10:49 >>>回调事件[910,devices/D0309]
2024-09-28 17:10:49 >>>故障排除日志:上一MQTT订单号缓存列表为24092817100136121743
2024-09-28 17:10:49 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 17:10:49 开始打印,排队:152,票券:2409281710414091816101,订单:24092817104140910808,[2024-09-28 17:10:48支付宝支付10元]
2024-09-28 17:10:51 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281710414091816101","queue_number":152,"trade_uid":"24092817104140910808"}]}
2024-09-28 17:10:51 >>>故障排除日志:删除未同步下发订单成功24092817104140910808
2024-09-28 17:10:51 >>>故障排除日志:终端同步成功后剩余订单列表


===17:12:09===
2024-09-28 17:12:01>>>cash read=9E
2024-09-28 17:12:02>>>cash read=3E


===17:13:09===
2024-09-28 17:12:13>>>cash read=0A
2024-09-28 17:12:14>>>cash read=3E


===17:14:10===
2024-09-28 17:13:32>>>cash read=1F
2024-09-28 17:13:33>>>cash read=3E
2024-09-28 17:13:58>>>cash read=1F
2024-09-28 17:13:59>>>cash read=3E


===17:19:10===
2024-09-28 17:18:51>>>cash read=1F
2024-09-28 17:18:52>>>cash read=3E


===17:20:10===
2024-09-28 17:19:55>>>cash read=1F
2024-09-28 17:19:56>>>cash read=3E


===17:22:10===
2024-09-28 17:21:37>>>cash read=1F
2024-09-28 17:21:38>>>cash read=3E


===17:25:11===
2024-09-28 17:24:09 >>>回调事件[910,devices/D0309]
2024-09-28 17:24:10 >>>故障排除日志:上一MQTT订单号缓存列表为24092817104140910808
2024-09-28 17:24:10 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 17:24:10 开始打印,排队:153,票券:2409281724034077870201,订单:24092817240340773271,[2024-09-28 17:24:10微信支付10元]
2024-09-28 17:24:11 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281724034077870201","queue_number":153,"trade_uid":"24092817240340773271"}]}
2024-09-28 17:24:12 >>>故障排除日志:删除未同步下发订单成功24092817240340773271
2024-09-28 17:24:12 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 17:24:39 >>>回调事件[910,devices/D0309]
2024-09-28 17:24:39 >>>故障排除日志:上一MQTT订单号缓存列表为24092817240340773271
2024-09-28 17:24:39 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 17:24:39 开始打印,排队:154,票券:2409281724295564307901,订单:24092817242955639623,[2024-09-28 17:24:39微信支付10元]
2024-09-28 17:24:41 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281724295564307901","queue_number":154,"trade_uid":"24092817242955639623"}]}
2024-09-28 17:24:41 >>>故障排除日志:删除未同步下发订单成功24092817242955639623
2024-09-28 17:24:41 >>>故障排除日志:终端同步成功后剩余订单列表


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


===17:33:11===
2024-09-28 17:32:20>>>cash read=BF
2024-09-28 17:32:21>>>cash read=3E


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


===17:36:11===
2024-09-28 17:35:14>>>cash read=9E
2024-09-28 17:35:15>>>cash read=3E


===17:39:12===
2024-09-28 17:39:08 >>>回调事件[910,devices/D0309]
2024-09-28 17:39:08 >>>故障排除日志:上一MQTT订单号缓存列表为24092817342372327303
2024-09-28 17:39:08 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 17:39:08 开始打印,排队:158,票券:2409281739007381463001,订单:24092817390073808875,[2024-09-28 17:39:08支付宝支付10元]


===17:40:12===
2024-09-28 17:39:10 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281739007381463001","queue_number":158,"trade_uid":"24092817390073808875"}]}
2024-09-28 17:39:10 >>>故障排除日志:删除未同步下发订单成功24092817390073808875
2024-09-28 17:39:10 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 17:39:10 >>>回调事件[910,devices/D0309]
2024-09-28 17:39:10 >>>故障排除日志:上一MQTT订单号缓存列表为24092817390073808875
2024-09-28 17:39:10 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 17:39:10 开始打印,排队:159,票券:2409281739066345420101,订单:24092817390663449997,[2024-09-28 17:39:11微信支付10元]
2024-09-28 17:39:13 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281739066345420101","queue_number":159,"trade_uid":"24092817390663449997"}]}
2024-09-28 17:39:13 >>>故障排除日志:删除未同步下发订单成功24092817390663449997
2024-09-28 17:39:13 >>>故障排除日志:终端同步成功后剩余订单列表


===17:41:12===
2024-09-28 17:40:32>>>cash read=BF
2024-09-28 17:40:33>>>cash read=3E


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


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


===17:47:13===
2024-09-28 17:46:49 >>>回调事件[910,devices/D0309]
2024-09-28 17:46:49 >>>故障排除日志:上一MQTT订单号缓存列表为24092817435494250748
2024-09-28 17:46:49 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 17:46:49 开始打印,排队:162,票券:2409281746454850897601,订单:24092817464548505630,[2024-09-28 17:46:49微信支付10元]
2024-09-28 17:46:51 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281746454850897601","queue_number":162,"trade_uid":"24092817464548505630"}]}
2024-09-28 17:46:51 >>>故障排除日志:删除未同步下发订单成功24092817464548505630
2024-09-28 17:46:51 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 17:46:56 >>>回调事件[910,devices/D0309]
2024-09-28 17:46:56 >>>故障排除日志:上一MQTT订单号缓存列表为24092817464548505630
2024-09-28 17:46:56 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 17:46:56 开始打印,排队:163,票券:2409281746482370482101,订单:24092817464823699889,[2024-09-28 17:46:56支付宝支付10元]
2024-09-28 17:46:58 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281746482370482101","queue_number":163,"trade_uid":"24092817464823699889"}]}
2024-09-28 17:46:58 >>>故障排除日志:删除未同步下发订单成功24092817464823699889
2024-09-28 17:46:58 >>>故障排除日志:终端同步成功后剩余订单列表


===17:49:14===
2024-09-28 17:48:27 >>>回调事件[910,devices/D0309]
2024-09-28 17:48:27 >>>故障排除日志:上一MQTT订单号缓存列表为24092817464823699889
2024-09-28 17:48:27 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 17:48:27 开始打印,排队:164,票券:2409281748217244469301,订单:24092817482172440497,[2024-09-28 17:48:27微信支付10元]
2024-09-28 17:48:29 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281748217244469301","queue_number":164,"trade_uid":"24092817482172440497"}]}
2024-09-28 17:48:29 >>>故障排除日志:删除未同步下发订单成功24092817482172440497
2024-09-28 17:48:29 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 17:48:45 >>>回调事件[910,devices/D0309]
2024-09-28 17:48:45 >>>故障排除日志:上一MQTT订单号缓存列表为24092817482172440497
2024-09-28 17:48:45 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 17:48:45 开始打印,排队:165,票券:2409281748317561226001,订单:24092817483175605328,[2024-09-28 17:48:44支付宝支付10元]
2024-09-28 17:48:47 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281748317561226001","queue_number":165,"trade_uid":"24092817483175605328"}]}
2024-09-28 17:48:47 >>>故障排除日志:删除未同步下发订单成功24092817483175605328
2024-09-28 17:48:47 >>>故障排除日志:终端同步成功后剩余订单列表


===17:51:14===
2024-09-28 17:50:38>>>cash read=1F
2024-09-28 17:50:39>>>cash read=3E


===17:53:14===
2024-09-28 17:52:33>>>cash read=1F
2024-09-28 17:52:35>>>cash read=3E


===17:54:15===
2024-09-28 17:54:05>>>cash read=9E
2024-09-28 17:54:06>>>cash read=3E


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


===18:01:15===
2024-09-28 18:00:35>>>cash read=BF
2024-09-28 18:00:36>>>cash read=3E
2024-09-28 18:00:38>>>cash read=1F
2024-09-28 18:00:39>>>cash read=3E
2024-09-28 18:00:48>>>cash read=BF
2024-09-28 18:00:49>>>cash read=3E


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


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


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


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


===18:25:17===
2024-09-28 18:24:28>>>cash read=1F
2024-09-28 18:24:30>>>cash read=3E


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


===18:27:17===
2024-09-28 18:26:49>>>cash read=1F
2024-09-28 18:26:50>>>cash read=3E


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


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


===18:36:18===
2024-09-28 18:35:25>>>cash read=9E
2024-09-28 18:35:26>>>cash read=3E
2024-09-28 18:36:01>>>cash read=9E
2024-09-28 18:36:02>>>cash read=3E


===18:37:18===
2024-09-28 18:37:14>>>cash read=1F
2024-09-28 18:37:15>>>cash read=3E


===18:42:19===
2024-09-28 18:41:33 >>>回调事件[910,devices/D0309]
2024-09-28 18:41:33 >>>故障排除日志:上一MQTT订单号缓存列表为24092818320173888498
2024-09-28 18:41:33 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 18:41:33 开始打印,排队:175,票券:2409281841245429553401,订单:24092818412454291529,[2024-09-28 18:41:32支付宝支付10元]
2024-09-28 18:41:35 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281841245429553401","queue_number":175,"trade_uid":"24092818412454291529"}]}
2024-09-28 18:41:35 >>>故障排除日志:删除未同步下发订单成功24092818412454291529
2024-09-28 18:41:35 >>>故障排除日志:终端同步成功后剩余订单列表


===18:49:19===
2024-09-28 18:48:17>>>cash read=00
2024-09-28 18:48:18>>>cash read=818F43
2024-09-28 18:48:18>>>cash write=02
2024-09-28 18:48:18 >>>回调事件130,cash_status,10022,进钞中...read money=20
2024-09-28 18:48:18>>>cash read=10
2024-09-28 18:48:18 >>>回调事件130,20,10023,finish Money=20,进钞完成
2024-09-28 18:48:18 >>>开始打印,排队号为176,订单号为2409281848180003093291
2024-09-28 18:48:19 >>>开始打印,排队号为177,订单号为2409281848180003093291
2024-09-28 18:48:19>>>订单2409281848180003093291写入成功,剩余空间为1673500,占用RAM为607.388671875
删除未同步订单2409281848180003093291
2024-09-28 18:48:23>>>订单2409281848180003093291删除成功,剩余空间为1674500,占用RAM为622.4052734375
检测订单目录中>>>
无未同步订单>>>
2024-09-28 18:48:23 >>>当前Ram内存为586.7197265625
定时检测未同步订单启用
2024-09-28 18:48:24>>>cash write=0C
2024-09-28 18:48:24>>>cash read=3E


===18:50:19===
定时检测未同步订单关闭
检测订单目录中>>>
无未同步订单>>>
2024-09-28 18:49:57>>>cash read=9E
2024-09-28 18:49:58>>>cash read=3E


===18:51:20===
2024-09-28 18:51:08>>>cash read=9E
2024-09-28 18:51:10>>>cash read=3E


===18:52:20===
2024-09-28 18:51:23>>>cash read=9E
2024-09-28 18:51:24>>>cash read=3E


===18:53:20===
2024-09-28 18:52:24>>>cash read=1F
2024-09-28 18:52:25>>>cash read=3E


===18:54:21===
2024-09-28 18:53:37 >>>回调事件[910,devices/D0309]
2024-09-28 18:53:37 >>>故障排除日志:上一MQTT订单号缓存列表为24092818412454291529
2024-09-28 18:53:37 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 18:53:37 开始打印,排队:178,票券:2409281853327306841801,订单:24092818533273064701,[2024-09-28 18:53:37支付宝支付10元]
2024-09-28 18:53:39 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281853327306841801","queue_number":178,"trade_uid":"24092818533273064701"}]}
2024-09-28 18:53:39 >>>故障排除日志:删除未同步下发订单成功24092818533273064701
2024-09-28 18:53:39 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 18:54:15 >>>回调事件[910,devices/D0309]
2024-09-28 18:54:15 >>>故障排除日志:上一MQTT订单号缓存列表为24092818533273064701
2024-09-28 18:54:15 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 18:54:15 开始打印,排队:179,票券:2409281854114934527901,订单:24092818541149340738,[2024-09-28 18:54:16微信支付10元]
2024-09-28 18:54:17 >>>回调事件[910,devices/D0309]
2024-09-28 18:54:17 >>>故障排除日志:上一MQTT订单号缓存列表为24092818541149340738
2024-09-28 18:54:17 >>>故障排除日志:终端未同步成功订单列表017924092818541149340738
2024-09-28 18:54:17 开始打印,排队:180,票券:2409281854093195160101,订单:24092818540931947289,[2024-09-28 18:54:17支付宝支付10元]
已接收过此消息,票券号为2409281854114934527901,排队号为179


===18:55:21===
2024-09-28 18:54:45>>>cash read=29
2024-09-28 18:54:45 >>>回调事件130,cash_status,20029,退钞中
2024-09-28 18:54:45>>>cash read=2F29
2024-09-28 18:54:46>>>cash read=3E
2024-09-28 18:54:48>>>cash read=00
2024-09-28 18:54:49>>>cash read=2F29
2024-09-28 18:54:50>>>cash read=3E


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


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


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


===19:02:23===
2024-09-28 19:02:08 >>>回调事件[910,devices/D0309]
2024-09-28 19:02:08 >>>故障排除日志:上一MQTT订单号缓存列表为24092818591445756082
2024-09-28 19:02:08 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 19:02:08 开始打印,排队:184,票券:2409281902007509926901,订单:24092819020075093671,[2024-09-28 19:02:07支付宝支付10元]
2024-09-28 19:02:10 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281902007509926901","queue_number":184,"trade_uid":"24092819020075093671"}]}
2024-09-28 19:02:10 >>>故障排除日志:删除未同步下发订单成功24092819020075093671
2024-09-28 19:02:10 >>>故障排除日志:终端同步成功后剩余订单列表


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


===19:04:24===
2024-09-28 19:03:44>>>cash read=BF
2024-09-28 19:03:45>>>cash read=3E


===19:08:24===
2024-09-28 19:07:33 >>>回调事件[910,devices/D0309]
2024-09-28 19:07:33 >>>故障排除日志:上一MQTT订单号缓存列表为24092819025106563607
2024-09-28 19:07:33 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 19:07:33 开始打印,排队:186,票券:2409281907182241647101,订单:24092819071822412363,[2024-09-28 19:07:33支付宝支付10元]
2024-09-28 19:07:35 >>>回调事件[910,devices/D0309]
2024-09-28 19:07:35 >>>故障排除日志:上一MQTT订单号缓存列表为24092819071822412363
2024-09-28 19:07:35 >>>故障排除日志:终端未同步成功订单列表018624092819071822412363
已接收过此消息,票券号为2409281907182241647101,排队号为186
2024-09-28 19:07:35 开始打印,排队:187,票券:2409281907187326300301,订单:24092819071873257735,[2024-09-28 19:07:35支付宝支付10元]
2024-09-28 19:07:37 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281907182241647101","queue_number":186,"trade_uid":"24092819071822412363"}]}
2024-09-28 19:07:37 >>>故障排除日志:删除未同步下发订单成功24092819071822412363
2024-09-28 19:07:37 >>>故障排除日志:终端同步成功后剩余订单列表018724092819071873257735
2024-09-28 19:07:37 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281907182241647101","queue_number":186,"trade_uid":"24092819071822412363"},{"ticket_no":"2409281907187326300301","queue_number":187,"trade_uid":"24092819071873257735"}]}
2024-09-28 19:07:37 >>>故障排除日志:删除未同步下发订单成功24092819071873257735
2024-09-28 19:07:37 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 19:08:05 >>>回调事件[910,devices/D0309]
2024-09-28 19:08:05 >>>故障排除日志:上一MQTT订单号缓存列表为24092819071822412363|24092819071873257735
2024-09-28 19:08:05 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 19:08:05 开始打印,排队:188,票券:2409281907548355396501,订单:24092819075483548421,[2024-09-28 19:08:05微信支付10元]
2024-09-28 19:08:07 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281907548355396501","queue_number":188,"trade_uid":"24092819075483548421"}]}
2024-09-28 19:08:07 >>>故障排除日志:删除未同步下发订单成功24092819075483548421
2024-09-28 19:08:07 >>>故障排除日志:终端同步成功后剩余订单列表


===19:10:24===
2024-09-28 19:09:52>>>cash read=BF
2024-09-28 19:09:53>>>cash read=3E


===19:11:25===
2024-09-28 19:10:34 >>>回调事件[910,devices/D0309]
2024-09-28 19:10:34 >>>故障排除日志:上一MQTT订单号缓存列表为24092819075483548421
2024-09-28 19:10:34 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 19:10:34 开始打印,排队:189,票券:2409281910300844358301,订单:24092819103008439832,[2024-09-28 19:10:34支付宝支付10元]
2024-09-28 19:10:36 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281910300844358301","queue_number":189,"trade_uid":"24092819103008439832"}]}
2024-09-28 19:10:36 >>>故障排除日志:删除未同步下发订单成功24092819103008439832
2024-09-28 19:10:36 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 19:10:57 >>>回调事件[910,devices/D0309]
2024-09-28 19:10:57 >>>故障排除日志:上一MQTT订单号缓存列表为24092819103008439832
2024-09-28 19:10:57 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 19:10:57 开始打印,排队:190,票券:2409281910501223333101,订单:24092819105012229179,[2024-09-28 19:10:57微信支付10元]
2024-09-28 19:10:59 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281910501223333101","queue_number":190,"trade_uid":"24092819105012229179"}]}
2024-09-28 19:10:59 >>>故障排除日志:删除未同步下发订单成功24092819105012229179
2024-09-28 19:10:59 >>>故障排除日志:终端同步成功后剩余订单列表


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


===19:19:25===
2024-09-28 19:18:28>>>cash read=9E
2024-09-28 19:18:29>>>cash read=3E


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


===19:23:25===
2024-09-28 19:22:52>>>cash read=9E
2024-09-28 19:22:53>>>cash read=3E


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


===19:26:25===
2024-09-28 19:25:24>>>cash read=9E
2024-09-28 19:25:25>>>cash read=3E


===19:30:25===
2024-09-28 19:29:25>>>cash read=9E
2024-09-28 19:29:26>>>cash read=3E
2024-09-28 19:29:38 >>>回调事件[910,devices/D0309]
2024-09-28 19:29:38 >>>故障排除日志:上一MQTT订单号缓存列表为24092819244844649069
2024-09-28 19:29:38 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 19:29:38 开始打印,排队:194,票券:2409281929327393873701,订单:24092819293273934942,[2024-09-28 19:29:38支付宝支付10元]
2024-09-28 19:29:40 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281929327393873701","queue_number":194,"trade_uid":"24092819293273934942"}]}
2024-09-28 19:29:40 >>>故障排除日志:删除未同步下发订单成功24092819293273934942
2024-09-28 19:29:40 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 19:30:02 >>>回调事件[910,devices/D0309]
2024-09-28 19:30:02 >>>故障排除日志:上一MQTT订单号缓存列表为24092819293273934942
2024-09-28 19:30:02 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 19:30:02 开始打印,排队:195,票券:2409281929572666961201,订单:24092819295726665108,[2024-09-28 19:30:02微信支付10元]
2024-09-28 19:30:04 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281929572666961201","queue_number":195,"trade_uid":"24092819295726665108"}]}
2024-09-28 19:30:04 >>>故障排除日志:删除未同步下发订单成功24092819295726665108
2024-09-28 19:30:04 >>>故障排除日志:终端同步成功后剩余订单列表


===19:34:26===
2024-09-28 19:33:31 >>>回调事件[910,devices/D0309]
2024-09-28 19:33:31 >>>故障排除日志:上一MQTT订单号缓存列表为24092819295726665108
2024-09-28 19:33:31 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 19:33:31 开始打印,排队:196,票券:2409281933261757525801,订单:24092819332617571580,[2024-09-28 19:33:31支付宝支付10元]
2024-09-28 19:33:33 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281933261757525801","queue_number":196,"trade_uid":"24092819332617571580"}]}
2024-09-28 19:33:33 >>>故障排除日志:删除未同步下发订单成功24092819332617571580
2024-09-28 19:33:33 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 19:34:09 >>>回调事件[910,devices/D0309]
2024-09-28 19:34:09 >>>故障排除日志:上一MQTT订单号缓存列表为24092819332617571580
2024-09-28 19:34:09 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 19:34:09 开始打印,排队:197,票券:2409281934031314266801,订单:24092819340313138672,[2024-09-28 19:34:09微信支付10元]
2024-09-28 19:34:11 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281934031314266801","queue_number":197,"trade_uid":"24092819340313138672"}]}
2024-09-28 19:34:11 >>>故障排除日志:删除未同步下发订单成功24092819340313138672
2024-09-28 19:34:11 >>>故障排除日志:终端同步成功后剩余订单列表


===19:35:26===
2024-09-28 19:34:32>>>cash read=9E
2024-09-28 19:34:33>>>cash read=3E
2024-09-28 19:34:34 >>>回调事件[910,devices/D0309]
2024-09-28 19:34:34 >>>故障排除日志:上一MQTT订单号缓存列表为24092819340313138672
2024-09-28 19:34:34 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 19:34:34 开始打印,排队:198,票券:2409281934266602926501,订单:24092819342666024069,[2024-09-28 19:34:34支付宝支付10元]
2024-09-28 19:34:36 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281934266602926501","queue_number":198,"trade_uid":"24092819342666024069"}]}
2024-09-28 19:34:36 >>>故障排除日志:删除未同步下发订单成功24092819342666024069
2024-09-28 19:34:36 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 19:35:11 >>>回调事件[910,devices/D0309]
2024-09-28 19:35:11 >>>故障排除日志:上一MQTT订单号缓存列表为24092819342666024069
2024-09-28 19:35:11 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 19:35:11 开始打印,排队:199,票券:2409281935060123282301,订单:24092819350601229420,[2024-09-28 19:35:11微信支付10元]
2024-09-28 19:35:13 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281935060123282301","queue_number":199,"trade_uid":"24092819350601229420"}]}
2024-09-28 19:35:13 >>>故障排除日志:删除未同步下发订单成功24092819350601229420
2024-09-28 19:35:13 >>>故障排除日志:终端同步成功后剩余订单列表


===19:36:27===
2024-09-28 19:35:24>>>cash read=9E
2024-09-28 19:35:26>>>cash read=3E


===19:37:27===
2024-09-28 19:37:04>>>cash read=BF
2024-09-28 19:37:05>>>cash read=3E
2024-09-28 19:37:09 >>>回调事件[910,devices/D0309]
2024-09-28 19:37:09 >>>故障排除日志:上一MQTT订单号缓存列表为24092819350601229420
2024-09-28 19:37:09 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 19:37:09 开始打印,排队:200,票券:2409281937000311511701,订单:24092819370003109352,[2024-09-28 19:37:08支付宝支付10元]
2024-09-28 19:37:11 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281937000311511701","queue_number":200,"trade_uid":"24092819370003109352"}]}
2024-09-28 19:37:11 >>>故障排除日志:删除未同步下发订单成功24092819370003109352
2024-09-28 19:37:11 >>>故障排除日志:终端同步成功后剩余订单列表


===19:38:27===
2024-09-28 19:37:48>>>cash read=9E
2024-09-28 19:37:49>>>cash read=3E


===19:40:27===
2024-09-28 19:39:39>>>cash read=9E
2024-09-28 19:39:40>>>cash read=3E


===19:41:27===
2024-09-28 19:40:41>>>cash read=9E
2024-09-28 19:40:42>>>cash read=3E
2024-09-28 19:40:54>>>cash read=BF
2024-09-28 19:40:55>>>cash read=3E


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


===19:45:28===
2024-09-28 19:45:07>>>cash read=9E
2024-09-28 19:45:09>>>cash read=3E


===19:50:28===
2024-09-28 19:50:17>>>cash read=00
2024-09-28 19:50:18>>>cash read=01
2024-09-28 19:50:20>>>cash read=3E


===19:52:29===
2024-09-28 19:51:53 >>>回调事件[910,devices/D0309]
2024-09-28 19:51:53 >>>故障排除日志:上一MQTT订单号缓存列表为24092819430773248352
2024-09-28 19:51:53 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 19:51:53 开始打印,排队:202,票券:2409281951465175085301,订单:24092819514651747461,[2024-09-28 19:51:52微信支付10元]
2024-09-28 19:51:55 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281951465175085301","queue_number":202,"trade_uid":"24092819514651747461"}]}
2024-09-28 19:51:55 >>>故障排除日志:删除未同步下发订单成功24092819514651747461
2024-09-28 19:51:55 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 19:52:06>>>cash read=9E
2024-09-28 19:52:07>>>cash read=3E


===19:55:29===
2024-09-28 19:55:01>>>cash read=9E
2024-09-28 19:55:02>>>cash read=3E


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


===19:57:29===
2024-09-28 19:56:46 >>>回调事件[910,devices/D0309]
2024-09-28 19:56:47 >>>故障排除日志:上一MQTT订单号缓存列表为24092819553063274664
2024-09-28 19:56:47 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 19:56:47 开始打印,排队:204,票券:2409281956390351967801,订单:24092819563903514318,[2024-09-28 19:56:46支付宝支付10元]
2024-09-28 19:56:49 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281956390351967801","queue_number":204,"trade_uid":"24092819563903514318"}]}
2024-09-28 19:56:49 >>>故障排除日志:删除未同步下发订单成功24092819563903514318
2024-09-28 19:56:49 >>>故障排除日志:终端同步成功后剩余订单列表


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


===20:00:30===
2024-09-28 19:59:47 >>>回调事件[910,devices/D0309]
2024-09-28 19:59:47 >>>故障排除日志:上一MQTT订单号缓存列表为24092819584971003904
2024-09-28 19:59:47 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 19:59:47 开始打印,排队:206,票券:2409281959402892814601,订单:24092819594028922898,[2024-09-28 19:59:47微信支付10元]
2024-09-28 19:59:49 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281959402892814601","queue_number":206,"trade_uid":"24092819594028922898"}]}
2024-09-28 19:59:49 >>>故障排除日志:删除未同步下发订单成功24092819594028922898
2024-09-28 19:59:49 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 20:00:09 >>>回调事件[910,devices/D0309]
2024-09-28 20:00:09 >>>故障排除日志:上一MQTT订单号缓存列表为24092819594028922898
2024-09-28 20:00:09 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 20:00:09 开始打印,排队:207,票券:2409281959592754654801,订单:24092819595927542302,[2024-09-28 20:00:09微信支付10元]
2024-09-28 20:00:11 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409281959592754654801","queue_number":207,"trade_uid":"24092819595927542302"}]}
2024-09-28 20:00:11 >>>故障排除日志:删除未同步下发订单成功24092819595927542302
2024-09-28 20:00:12 >>>故障排除日志:终端同步成功后剩余订单列表


===20:01:30===
2024-09-28 20:00:55 >>>回调事件[910,devices/D0309]
2024-09-28 20:00:55 >>>故障排除日志:上一MQTT订单号缓存列表为24092819595927542302
2024-09-28 20:00:55 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 20:00:55 开始打印,排队:208,票券:2409282000486677800701,订单:24092820004866774091,[2024-09-28 20:00:55支付宝支付10元]
2024-09-28 20:00:55 开始打印,排队:209,票券:2409282000486677933002,订单:24092820004866774091,[2024-09-28 20:00:55支付宝支付10元]
2024-09-28 20:00:59 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409282000486677800701","queue_number":208,"trade_uid":"24092820004866774091"},{"ticket_no":"2409282000486677933002","queue_number":209,"trade_uid":"24092820004866774091"}]}
2024-09-28 20:00:59 >>>故障排除日志:删除未同步下发订单成功24092820004866774091
2024-09-28 20:00:59 >>>故障排除日志:删除未同步下发订单成功24092820004866774091
2024-09-28 20:00:59 >>>故障排除日志:终端同步成功后剩余订单列表


===20:02:31===
2024-09-28 20:01:40>>>cash read=1F
2024-09-28 20:01:41>>>cash read=3E
2024-09-28 20:02:19 >>>回调事件[910,devices/D0309]
2024-09-28 20:02:19 >>>故障排除日志:上一MQTT订单号缓存列表为24092820004866774091|24092820004866774091
2024-09-28 20:02:19 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 20:02:19 开始打印,排队:210,票券:2409282002122800246001,订单:24092820021227998687,[2024-09-28 20:02:19支付宝支付10元]
2024-09-28 20:02:20 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409282002122800246001","queue_number":210,"trade_uid":"24092820021227998687"}]}
2024-09-28 20:02:21 >>>故障排除日志:删除未同步下发订单成功24092820021227998687
2024-09-28 20:02:21 >>>故障排除日志:终端同步成功后剩余订单列表


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


===20:10:31===
2024-09-28 20:09:31 >>>回调事件[910,devices/D0309]
2024-09-28 20:09:31 >>>故障排除日志:上一MQTT订单号缓存列表为24092820040690580250
2024-09-28 20:09:31 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 20:09:31 开始打印,排队:212,票券:2409282009272087168001,订单:24092820092720866945,[2024-09-28 20:09:31微信支付10元]
2024-09-28 20:09:33 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409282009272087168001","queue_number":212,"trade_uid":"24092820092720866945"}]}
2024-09-28 20:09:33 >>>故障排除日志:删除未同步下发订单成功24092820092720866945
2024-09-28 20:09:33 >>>故障排除日志:终端同步成功后剩余订单列表
2024-09-28 20:10:22 >>>回调事件[910,devices/D0309]
2024-09-28 20:10:22 >>>故障排除日志:上一MQTT订单号缓存列表为24092820092720866945
2024-09-28 20:10:22 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 20:10:22 开始打印,排队:213,票券:2409282010161682677101,订单:24092820101616822758,[2024-09-28 20:10:23微信支付10元]
2024-09-28 20:10:24 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409282010161682677101","queue_number":213,"trade_uid":"24092820101616822758"}]}
2024-09-28 20:10:24 >>>故障排除日志:删除未同步下发订单成功24092820101616822758
2024-09-28 20:10:25 >>>故障排除日志:终端同步成功后剩余订单列表


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


===20:22:32===
2024-09-28 20:21:53>>>cash read=BF
2024-09-28 20:21:54>>>cash read=3E


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


===20:26:33===
2024-09-28 20:26:19>>>cash read=1F
2024-09-28 20:26:20>>>cash read=3E
2024-09-28 20:26:20 >>>回调事件[910,devices/D0309]
2024-09-28 20:26:20 >>>故障排除日志:上一MQTT订单号缓存列表为24092820230995287330
2024-09-28 20:26:20 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 20:26:20 开始打印,排队:216,票券:2409282026139750601301,订单:24092820261397502612,[2024-09-28 20:26:21支付宝支付10元]
2024-09-28 20:26:22 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409282026139750601301","queue_number":216,"trade_uid":"24092820261397502612"}]}
2024-09-28 20:26:23 >>>故障排除日志:删除未同步下发订单成功24092820261397502612
2024-09-28 20:26:23 >>>故障排除日志:终端同步成功后剩余订单列表


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


===20:29:33===
2024-09-28 20:29:06>>>cash read=1F
2024-09-28 20:29:07>>>cash read=3E


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


===20:39:34===
2024-09-28 20:38:49>>>cash read=BF
2024-09-28 20:38:50>>>cash read=3E


===20:44:34===
2024-09-28 20:43:42 >>>回调事件[910,devices/D0309]
2024-09-28 20:43:42 >>>故障排除日志:上一MQTT订单号缓存列表为24092820365716697898
2024-09-28 20:43:42 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 20:43:42 开始打印,排队:219,票券:2409282043378491735801,订单:24092820433784912032,[2024-09-28 20:43:42支付宝支付10元]
2024-09-28 20:43:44 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409282043378491735801","queue_number":219,"trade_uid":"24092820433784912032"}]}
2024-09-28 20:43:44 >>>故障排除日志:删除未同步下发订单成功24092820433784912032
2024-09-28 20:43:44 >>>故障排除日志:终端同步成功后剩余订单列表


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


===20:51:34===
2024-09-28 20:50:52 >>>回调事件[910,devices/D0309]
2024-09-28 20:50:52 >>>故障排除日志:上一MQTT订单号缓存列表为24092820493857760663
2024-09-28 20:50:52 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 20:50:52 开始打印,排队:221,票券:2409282050466712040601,订单:24092820504667114795,[2024-09-28 20:50:52支付宝支付10元]
2024-09-28 20:50:54 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409282050466712040601","queue_number":221,"trade_uid":"24092820504667114795"}]}
2024-09-28 20:50:54 >>>故障排除日志:删除未同步下发订单成功24092820504667114795
2024-09-28 20:50:54 >>>故障排除日志:终端同步成功后剩余订单列表


===20:52:35===
2024-09-28 20:51:50 >>>回调事件[910,devices/D0309]
2024-09-28 20:51:50 >>>故障排除日志:上一MQTT订单号缓存列表为24092820504667114795
2024-09-28 20:51:50 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 20:51:50 开始打印,排队:222,票券:2409282051427161606501,订单:24092820514271612376,[2024-09-28 20:51:50支付宝支付10元]
2024-09-28 20:51:52 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409282051427161606501","queue_number":222,"trade_uid":"24092820514271612376"}]}
2024-09-28 20:51:52 >>>故障排除日志:删除未同步下发订单成功24092820514271612376
2024-09-28 20:51:52 >>>故障排除日志:终端同步成功后剩余订单列表


===20:56:35===
2024-09-28 20:56:30>>>cash read=BF
2024-09-28 20:56:32>>>cash read=3E


===20:58:35===
2024-09-28 20:57:37>>>cash read=2F29
2024-09-28 20:57:39>>>cash read=00
2024-09-28 20:57:40>>>cash read=2F2901
2024-09-28 20:57:41>>>cash read=3E
2024-09-28 20:57:44>>>cash read=29
2024-09-28 20:57:44 >>>回调事件130,cash_status,20029,退钞中
2024-09-28 20:57:44>>>cash read=2F29
2024-09-28 20:57:45>>>cash read=01
2024-09-28 20:57:46>>>cash read=2F
2024-09-28 20:57:47>>>cash read=00
2024-09-28 20:57:48>>>cash read=292F29
2024-09-28 20:57:48 >>>回调事件130,cash_status,20029,退钞中
2024-09-28 20:57:49>>>cash read=3E
2024-09-28 20:57:53>>>cash read=00
2024-09-28 20:57:54>>>cash read=2F29
2024-09-28 20:57:56>>>cash read=3E
2024-09-28 20:58:12>>>cash read=00
2024-09-28 20:58:13>>>cash read=818F43
2024-09-28 20:58:13>>>cash write=02
2024-09-28 20:58:13 >>>回调事件130,cash_status,10022,进钞中...read money=20
2024-09-28 20:58:13>>>cash read=10
2024-09-28 20:58:13 >>>回调事件130,20,10023,finish Money=20,进钞完成
2024-09-28 20:58:13 >>>开始打印,排队号为223,订单号为2409282058130003091195
2024-09-28 20:58:13 >>>开始打印,排队号为224,订单号为2409282058130003091195
2024-09-28 20:58:14>>>订单2409282058130003091195写入成功,剩余空间为1672500,占用RAM为609.9345703125
2024-09-28 20:58:17>>>cash read=818F43
2024-09-28 20:58:17 >>>回调事件130,cash_status,10022,进钞中...read money=20
删除未同步订单2409282058130003091195
2024-09-28 20:58:17>>>订单2409282058130003091195删除成功,剩余空间为1674000,占用RAM为603.775390625
检测订单目录中>>>
无未同步订单>>>
2024-09-28 20:58:17 >>>当前Ram内存为586.9248046875
定时检测未同步订单启用
2024-09-28 20:58:18>>>cash read=10
2024-09-28 20:58:18 >>>回调事件130,20,10023,finish Money=20,进钞完成
2024-09-28 20:58:18 >>>开始打印,排队号为225,订单号为2409282058180003091145
2024-09-28 20:58:18 >>>开始打印,排队号为226,订单号为2409282058180003091145
定时检测未同步订单关闭
2024-09-28 20:58:18>>>订单2409282058180003091145写入成功,剩余空间为1671500,占用RAM为617.087890625
2024-09-28 20:58:22>>>cash read=818F42
2024-09-28 20:58:22 >>>回调事件130,cash_status,10022,进钞中...read money=10
删除未同步订单2409282058180003091145
2024-09-28 20:58:22>>>订单2409282058180003091145删除成功,剩余空间为1673000,占用RAM为604.041015625
检测订单目录中>>>
无未同步订单>>>
2024-09-28 20:58:22 >>>当前Ram内存为587.9443359375
定时检测未同步订单启用
2024-09-28 20:58:22>>>cash read=10
2024-09-28 20:58:22 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-09-28 20:58:22 >>>开始打印,排队号为227,订单号为2409282058220003099782
定时检测未同步订单关闭
2024-09-28 20:58:23>>>订单2409282058220003099782写入成功,剩余空间为1671500,占用RAM为615.0029296875
删除未同步订单2409282058220003099782
2024-09-28 20:58:25>>>订单2409282058220003099782删除成功,剩余空间为1672500,占用RAM为619.1083984375
检测订单目录中>>>
无未同步订单>>>
2024-09-28 20:58:25 >>>当前Ram内存为588.740234375
定时检测未同步订单启用
2024-09-28 20:58:26>>>cash write=0C
2024-09-28 20:58:26>>>cash read=3E


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


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


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


===21:02:36===
2024-09-28 21:02:02>>>cash read=1F
2024-09-28 21:02:03>>>cash read=3E


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


===21:05:37===
2024-09-28 21:04:59>>>cash read=9E
2024-09-28 21:05:00>>>cash read=3E


===21:06:37===
2024-09-28 21:05:38 >>>回调事件[910,devices/D0309]
2024-09-28 21:05:38 >>>故障排除日志:上一MQTT订单号缓存列表为24092821032371613396
2024-09-28 21:05:38 >>>故障排除日志:终端未同步成功订单列表
2024-09-28 21:05:38 开始打印,排队:231,票券:2409282105300448268501,订单:24092821053004478178,[2024-09-28 21:05:39支付宝支付10元]
2024-09-28 21:05:40 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2409282105300448268501","queue_number":231,"trade_uid":"24092821053004478178"}]}
2024-09-28 21:05:40 >>>故障排除日志:删除未同步下发订单成功24092821053004478178
2024-09-28 21:05:40 >>>故障排除日志:终端同步成功后剩余订单列表


===21:09:37===
2024-09-28 21:08:41>>>cash read=1F
2024-09-28 21:08:42>>>cash read=3E


===21:10:37===
2024-09-28 21:09:38>>>cash read=1F
2024-09-28 21:09:39>>>cash read=3E


===21:12:37===
2024-09-28 21:12:26>>>cash read=9E
2024-09-28 21:12:27>>>cash read=3E


===21:13:38===
2024-09-28 21:13:22>>>cash read=9E
2024-09-28 21:13:24>>>cash read=3E