TLClient_JSSCOM_LuatOS-Air_V4010_RDA8910_RFTTS_0xe0000,2.6.1,869701076438798,79971258076835,
poweron reason:0

===07:30:25===
上一时间戳为1729296323
隔日重置时间戳true
隔日清空未同步下发列表true
当前排队号为1,音量为5
初始化产品信息:[{"time_limit_date":"","ticket_category":"0","expiry_date":90,"product_detail":"","time_limit_status":"0","begin_minute":"00","product_uid":"12711098232277568446","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:e5a93****aed40
纸币器设置接收纸币范围为36
欢迎使用天羚自助售票系统[2.6.1]
定时检测未同步订单启用
2024-10-20 07:29:24>>>cash write=30
2024-10-20 07:29:24>>>cash write=02
2024-10-20 07:29:24>>>cash write=3E
2024-10-20 07:29:24>>>cash read=808F808F
系统时间初始化成功，时间为2024102072924
2024-10-20 07:29:25>>>cash write=02
2024-10-20 07:29:25 >>>剩余flash空间=1680500,占用RAM为627.6982421875
2024-10-20 07:29:25 >>>回调事件:910,subscribe,10000,连接服务器成功

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

2024-10-20 07:29:28>>>cash write=0C
2024-10-20 07:29:28>>>cash read=3E
流量卡还有315天过期
2024-10-20 07:29:36 >>>当前Ram内存为650.505859375


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


===08:11:25===
2024-10-20 08:10:29 >>>回调事件[910,devices/D0519]
当日首次设置时间戳true为1729383029
2024-10-20 08:10:29 >>>故障排除日志:上一MQTT订单号缓存列表为24101921364940952093
2024-10-20 08:10:29 >>>故障排除日志:终端未同步成功订单列表
2024-10-20 08:10:29 开始打印,排队:1,票券:2410200810194629211201,订单:24102008101946288178,[2024-10-20 08:10:28微信支付10元]
2024-10-20 08:10:31 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410200810194629211201","queue_number":1,"trade_uid":"24102008101946288178"}]}
2024-10-20 08:10:31 >>>故障排除日志:删除未同步下发订单成功24102008101946288178
2024-10-20 08:10:32 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


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


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


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


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


===08:50:27===
2024-10-20 08:50:24>>>cash read=0A
2024-10-20 08:50:25>>>cash read=3E


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


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


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


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


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


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


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


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


===09:18:29===
2024-10-20 09:17:33 >>>回调事件[910,devices/D0519]
2024-10-20 09:17:33 >>>故障排除日志:上一MQTT订单号缓存列表为24102009041451289798
2024-10-20 09:17:33 >>>故障排除日志:终端未同步成功订单列表
2024-10-20 09:17:33 开始打印,排队:16,票券:2410200917252185828901,订单:24102009172521854252,[2024-10-20 09:17:33支付宝支付10元]
2024-10-20 09:17:35 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410200917252185828901","queue_number":16,"trade_uid":"24102009172521854252"}]}
2024-10-20 09:17:35 >>>故障排除日志:删除未同步下发订单成功24102009172521854252
2024-10-20 09:17:35 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-20 09:17:47 >>>回调事件[910,devices/D0519]
2024-10-20 09:17:47 >>>故障排除日志:上一MQTT订单号缓存列表为24102009172521854252
2024-10-20 09:17:47 >>>故障排除日志:终端未同步成功订单列表
2024-10-20 09:17:47 开始打印,排队:17,票券:2410200917382404609201,订单:24102009173824041884,[2024-10-20 09:17:47微信支付10元]
2024-10-20 09:17:49 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410200917382404609201","queue_number":17,"trade_uid":"24102009173824041884"}]}
2024-10-20 09:17:49 >>>故障排除日志:删除未同步下发订单成功24102009173824041884
2024-10-20 09:17:49 >>>故障排除日志:终端同步成功后剩余订单列表


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


===09:33:29===
2024-10-20 09:32:56 >>>回调事件[910,devices/D0519]
2024-10-20 09:32:56 >>>故障排除日志:上一MQTT订单号缓存列表为24102009215970736916
2024-10-20 09:32:56 >>>故障排除日志:终端未同步成功订单列表
2024-10-20 09:32:56 开始打印,排队:19,票券:2410200932502921949601,订单:24102009325029213026,[2024-10-20 09:32:55微信支付10元]
2024-10-20 09:32:58 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410200932502921949601","queue_number":19,"trade_uid":"24102009325029213026"}]}
2024-10-20 09:32:58 >>>故障排除日志:删除未同步下发订单成功24102009325029213026
2024-10-20 09:32:58 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-20 09:33:14>>>cash read=29
2024-10-20 09:33:14 >>>回调事件130,cash_status,20029,退钞中
2024-10-20 09:33:15>>>cash read=01
2024-10-20 09:33:17>>>cash read=3E
2024-10-20 09:33:19>>>cash read=29
2024-10-20 09:33:19 >>>回调事件130,cash_status,20029,退钞中
2024-10-20 09:33:20>>>cash read=01
2024-10-20 09:33:24>>>cash read=00
2024-10-20 09:33:25>>>cash read=29
2024-10-20 09:33:25 >>>回调事件130,cash_status,20029,退钞中
2024-10-20 09:33:26>>>cash read=2F29
2024-10-20 09:33:27>>>cash read=3E


===09:34:29===
2024-10-20 09:33:33>>>cash read=29
2024-10-20 09:33:33 >>>回调事件130,cash_status,20029,退钞中
2024-10-20 09:33:33>>>cash read=2F29
2024-10-20 09:33:34>>>cash read=01
2024-10-20 09:33:37>>>cash read=2F
2024-10-20 09:33:39>>>cash read=00
2024-10-20 09:33:39>>>cash read=818F42
2024-10-20 09:33:39>>>cash write=02
2024-10-20 09:33:39 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-20 09:33:40>>>cash read=10
2024-10-20 09:33:40 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-20 09:33:40 当前产品价格10元，投币10元，打印小票中...
2024-10-20 09:33:40 >>>开始打印,排队号为20,订单号为2410200933400000014897
2024-10-20 09:33:40>>>订单2410200933400000014897写入成功,剩余空间为1679500,占用RAM为609.1748046875
删除未同步订单2410200933400000014897
2024-10-20 09:33:42>>>订单2410200933400000014897删除成功,剩余空间为1680500,占用RAM为621.2412109375
检测订单目录中>>>
无未同步订单>>>
2024-10-20 09:33:42 >>>当前Ram内存为592.630859375
定时检测未同步订单启用
2024-10-20 09:33:43>>>cash write=0C
2024-10-20 09:33:43>>>cash read=3E
2024-10-20 09:34:18 >>>回调事件[910,devices/D0519]
2024-10-20 09:34:18 >>>故障排除日志:上一MQTT订单号缓存列表为24102009325029213026
2024-10-20 09:34:18 >>>故障排除日志:终端未同步成功订单列表
2024-10-20 09:34:19 开始打印,排队:21,票券:2410200934119819334201,订单:24102009341198189383,[2024-10-20 09:34:18微信支付10元]
2024-10-20 09:34:21 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410200934119819334201","queue_number":21,"trade_uid":"24102009341198189383"}]}
2024-10-20 09:34:21 >>>故障排除日志:删除未同步下发订单成功24102009341198189383
2024-10-20 09:34:21 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


===09:56:30===
2024-10-20 09:56:07 >>>回调事件[910,devices/D0519]
2024-10-20 09:56:07 >>>故障排除日志:上一MQTT订单号缓存列表为24102009540325035942
2024-10-20 09:56:07 >>>故障排除日志:终端未同步成功订单列表
2024-10-20 09:56:07 开始打印,排队:23,票券:2410200956010537056801,订单:24102009560105365849,[2024-10-20 09:56:06支付宝支付10元]
2024-10-20 09:56:07 开始打印,排队:24,票券:2410200956010537222402,订单:24102009560105365849,[2024-10-20 09:56:06支付宝支付10元]
2024-10-20 09:56:10 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410200956010537056801","queue_number":23,"trade_uid":"24102009560105365849"},{"ticket_no":"2410200956010537222402","queue_number":24,"trade_uid":"24102009560105365849"}]}
2024-10-20 09:56:10 >>>故障排除日志:删除未同步下发订单成功24102009560105365849
2024-10-20 09:56:10 >>>故障排除日志:删除未同步下发订单成功24102009560105365849
2024-10-20 09:56:10 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-20 09:56:14 >>>回调事件[910,devices/D0519]
2024-10-20 09:56:14 >>>故障排除日志:上一MQTT订单号缓存列表为24102009560105365849|24102009560105365849
2024-10-20 09:56:14 >>>故障排除日志:终端未同步成功订单列表
2024-10-20 09:56:14 开始打印,排队:25,票券:2410200956057963856801,订单:24102009560579634174,[2024-10-20 09:56:14微信支付10元]
2024-10-20 09:56:16 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410200956057963856801","queue_number":25,"trade_uid":"24102009560579634174"}]}
2024-10-20 09:56:16 >>>故障排除日志:删除未同步下发订单成功24102009560579634174
2024-10-20 09:56:16 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


===10:12:31===
2024-10-20 10:12:06 >>>回调事件[910,devices/D0519]
2024-10-20 10:12:06 >>>故障排除日志:上一MQTT订单号缓存列表为24102010111764533769
2024-10-20 10:12:06 >>>故障排除日志:终端未同步成功订单列表
2024-10-20 10:12:06 开始打印,排队:31,票券:2410201012010493016801,订单:24102010120104925035,[2024-10-20 10:12:05微信支付10元]
2024-10-20 10:12:08 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410201012010493016801","queue_number":31,"trade_uid":"24102010120104925035"}]}
2024-10-20 10:12:08 >>>故障排除日志:删除未同步下发订单成功24102010120104925035
2024-10-20 10:12:08 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-20 10:12:12>>>cash read=0A
2024-10-20 10:12:13>>>cash read=3E


===10:14:32===
2024-10-20 10:13:34 >>>回调事件[910,devices/D0519]
2024-10-20 10:13:34 >>>故障排除日志:上一MQTT订单号缓存列表为24102010120104925035
2024-10-20 10:13:34 >>>故障排除日志:终端未同步成功订单列表
2024-10-20 10:13:34 开始打印,排队:32,票券:2410201013283350341501,订单:24102010132833498487,[2024-10-20 10:13:33微信支付10元]
2024-10-20 10:13:36 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410201013283350341501","queue_number":32,"trade_uid":"24102010132833498487"}]}
2024-10-20 10:13:36 >>>故障排除日志:删除未同步下发订单成功24102010132833498487
2024-10-20 10:13:36 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-20 10:13:53 >>>回调事件[910,devices/D0519]
2024-10-20 10:13:53 >>>故障排除日志:上一MQTT订单号缓存列表为24102010132833498487
2024-10-20 10:13:53 >>>故障排除日志:终端未同步成功订单列表
2024-10-20 10:13:53 开始打印,排队:33,票券:2410201013485233116701,订单:24102010134852326316,[2024-10-20 10:13:53微信支付10元]
2024-10-20 10:13:55 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410201013485233116701","queue_number":33,"trade_uid":"24102010134852326316"}]}
2024-10-20 10:13:55 >>>故障排除日志:删除未同步下发订单成功24102010134852326316
2024-10-20 10:13:55 >>>故障排除日志:终端同步成功后剩余订单列表


===10:18:32===
2024-10-20 10:17:37 >>>回调事件[910,devices/D0519]
2024-10-20 10:17:37 >>>故障排除日志:上一MQTT订单号缓存列表为24102010134852326316
2024-10-20 10:17:37 >>>故障排除日志:终端未同步成功订单列表
2024-10-20 10:17:37 开始打印,排队:34,票券:2410201017281131183901,订单:24102010172811306661,[2024-10-20 10:17:36微信支付10元]
2024-10-20 10:17:39 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410201017281131183901","queue_number":34,"trade_uid":"24102010172811306661"}]}
2024-10-20 10:17:39 >>>故障排除日志:删除未同步下发订单成功24102010172811306661
2024-10-20 10:17:39 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-20 10:17:49 >>>回调事件[910,devices/D0519]
2024-10-20 10:17:49 >>>故障排除日志:上一MQTT订单号缓存列表为24102010172811306661
2024-10-20 10:17:49 >>>故障排除日志:终端未同步成功订单列表
2024-10-20 10:17:49 开始打印,排队:35,票券:2410201017424379576201,订单:24102010174243791535,[2024-10-20 10:17:49微信支付10元]
2024-10-20 10:17:50 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410201017424379576201","queue_number":35,"trade_uid":"24102010174243791535"}]}
2024-10-20 10:17:51 >>>故障排除日志:删除未同步下发订单成功24102010174243791535
2024-10-20 10:17:51 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


===10:39:33===
2024-10-20 10:39:22>>>cash read=29
2024-10-20 10:39:22 >>>回调事件130,cash_status,20029,退钞中
2024-10-20 10:39:23>>>cash read=3E
2024-10-20 10:39:25>>>cash read=00
2024-10-20 10:39:26>>>cash read=29
2024-10-20 10:39:26 >>>回调事件130,cash_status,20029,退钞中
2024-10-20 10:39:27>>>cash read=22
2024-10-20 10:39:27 >>>回调事件130,cash_status,30022,卡钞


===10:40:33===
2024-10-20 10:39:40>>>cash read=3E


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


===10:44:34===
2024-10-20 10:44:16 >>>回调事件[910,devices/D0519]
2024-10-20 10:44:16 >>>故障排除日志:上一MQTT订单号缓存列表为24102010403206684263
2024-10-20 10:44:16 >>>故障排除日志:终端未同步成功订单列表
2024-10-20 10:44:16 开始打印,排队:41,票券:2410201044112293377901,订单:24102010441122928765,[2024-10-20 10:44:16微信支付10元]
2024-10-20 10:44:18 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410201044112293377901","queue_number":41,"trade_uid":"24102010441122928765"}]}
2024-10-20 10:44:18 >>>故障排除日志:删除未同步下发订单成功24102010441122928765
2024-10-20 10:44:18 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-20 10:44:29 >>>回调事件[910,devices/D0519]
2024-10-20 10:44:29 >>>故障排除日志:上一MQTT订单号缓存列表为24102010441122928765
2024-10-20 10:44:29 >>>故障排除日志:终端未同步成功订单列表
2024-10-20 10:44:29 开始打印,排队:42,票券:2410201044218724296701,订单:24102010442187238614,[2024-10-20 10:44:29微信支付10元]
2024-10-20 10:44:31 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410201044218724296701","queue_number":42,"trade_uid":"24102010442187238614"}]}
2024-10-20 10:44:31 >>>故障排除日志:删除未同步下发订单成功24102010442187238614
2024-10-20 10:44:31 >>>故障排除日志:终端同步成功后剩余订单列表


===10:45:34===
2024-10-20 10:45:31>>>cash read=2F29
2024-10-20 10:45:32>>>cash read=3E


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


===10:47:34===
定时检测未同步订单关闭
检测订单目录中>>>
无未同步订单>>>
2024-10-20 10:47:10 >>>回调事件[910,devices/D0519]
2024-10-20 10:47:10 >>>故障排除日志:上一MQTT订单号缓存列表为24102010442187238614
2024-10-20 10:47:10 >>>故障排除日志:终端未同步成功订单列表
2024-10-20 10:47:10 开始打印,排队:44,票券:2410201047026048396401,订单:24102010470260479513,[2024-10-20 10:47:10支付宝支付10元]
2024-10-20 10:47:12 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410201047026048396401","queue_number":44,"trade_uid":"24102010470260479513"}]}
2024-10-20 10:47:12 >>>故障排除日志:删除未同步下发订单成功24102010470260479513
2024-10-20 10:47:12 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-20 10:47:15 >>>回调事件[910,devices/D0519]
2024-10-20 10:47:15 >>>故障排除日志:上一MQTT订单号缓存列表为24102010470260479513
2024-10-20 10:47:15 >>>故障排除日志:终端未同步成功订单列表
2024-10-20 10:47:15 开始打印,排队:45,票券:2410201047029549894801,订单:24102010470295495032,[2024-10-20 10:47:15支付宝支付10元]
2024-10-20 10:47:17 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410201047029549894801","queue_number":45,"trade_uid":"24102010470295495032"}]}
2024-10-20 10:47:17 >>>故障排除日志:删除未同步下发订单成功24102010470295495032
2024-10-20 10:47:17 >>>故障排除日志:终端同步成功后剩余订单列表


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


===10:57:34===
2024-10-20 10:56:58 >>>回调事件[910,devices/D0519]
2024-10-20 10:56:58 >>>故障排除日志:上一MQTT订单号缓存列表为24102010554302563873
2024-10-20 10:56:58 >>>故障排除日志:终端未同步成功订单列表
2024-10-20 10:56:58 开始打印,排队:47,票券:2410201056515071788601,订单:24102010565150712662,[2024-10-20 10:56:57微信支付10元]
2024-10-20 10:57:00 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410201056515071788601","queue_number":47,"trade_uid":"24102010565150712662"}]}
2024-10-20 10:57:00 >>>故障排除日志:删除未同步下发订单成功24102010565150712662
2024-10-20 10:57:00 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-20 10:57:09>>>cash read=00
2024-10-20 10:57:10>>>cash read=818F42
2024-10-20 10:57:10>>>cash write=02
2024-10-20 10:57:10 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-20 10:57:11>>>cash read=10
2024-10-20 10:57:11 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-20 10:57:11 当前产品价格10元，投币10元，打印小票中...
2024-10-20 10:57:11 >>>开始打印,排队号为48,订单号为2410201057110049510188
2024-10-20 10:57:11>>>订单2410201057110049510188写入成功,剩余空间为1679000,占用RAM为613.1640625
删除未同步订单2410201057110049510188
2024-10-20 10:57:13>>>订单2410201057110049510188删除成功,剩余空间为1680000,占用RAM为621.4765625
检测订单目录中>>>
无未同步订单>>>
2024-10-20 10:57:13 >>>当前Ram内存为592.259765625
定时检测未同步订单启用
2024-10-20 10:57:14>>>cash write=0C
2024-10-20 10:57:14>>>cash read=3E


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


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


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


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


===11:07:36===
2024-10-20 11:07:00 >>>回调事件[910,devices/D0519]
2024-10-20 11:07:00 >>>故障排除日志:上一MQTT订单号缓存列表为24102011013309291024
2024-10-20 11:07:00 >>>故障排除日志:终端未同步成功订单列表
2024-10-20 11:07:00 开始打印,排队:52,票券:2410201106524740622401,订单:24102011065247402291,[2024-10-20 11:07:00微信支付10元]
2024-10-20 11:07:02 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410201106524740622401","queue_number":52,"trade_uid":"24102011065247402291"}]}
2024-10-20 11:07:02 >>>故障排除日志:删除未同步下发订单成功24102011065247402291
2024-10-20 11:07:02 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-20 11:07:33 >>>回调事件[910,devices/D0519]
2024-10-20 11:07:33 >>>故障排除日志:上一MQTT订单号缓存列表为24102011065247402291
2024-10-20 11:07:33 >>>故障排除日志:终端未同步成功订单列表
2024-10-20 11:07:33 开始打印,排队:53,票券:2410201107287508065301,订单:24102011072875076297,[2024-10-20 11:07:32支付宝支付10元]


===11:08:36===
2024-10-20 11:08:03 >>>回调事件[910,devices/D0519]
2024-10-20 11:08:03 >>>故障排除日志:上一MQTT订单号缓存列表为24102011072875076297
2024-10-20 11:08:03 >>>故障排除日志:终端未同步成功订单列表
2024-10-20 11:08:03 开始打印,排队:54,票券:2410201107526686366401,订单:24102011075266858153,[2024-10-20 11:08:02微信支付10元]
2024-10-20 11:08:05 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410201107526686366401","queue_number":54,"trade_uid":"24102011075266858153"}]}
2024-10-20 11:08:05 >>>故障排除日志:删除未同步下发订单成功24102011075266858153
2024-10-20 11:08:05 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-20 11:08:28 >>>回调事件[910,devices/D0519]
2024-10-20 11:08:28 >>>故障排除日志:上一MQTT订单号缓存列表为24102011075266858153
2024-10-20 11:08:28 >>>故障排除日志:终端未同步成功订单列表
2024-10-20 11:08:28 开始打印,排队:55,票券:2410201108199466641201,订单:24102011081994662017,[2024-10-20 11:08:27支付宝支付10元]
2024-10-20 11:08:30 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410201108199466641201","queue_number":55,"trade_uid":"24102011081994662017"}]}
2024-10-20 11:08:30 >>>故障排除日志:删除未同步下发订单成功24102011081994662017
2024-10-20 11:08:30 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


===11:31:37===
2024-10-20 11:31:12 >>>回调事件[910,devices/D0519]
2024-10-20 11:31:12 >>>故障排除日志:上一MQTT订单号缓存列表为24102011221521301275|24102011221521301275
2024-10-20 11:31:12 >>>故障排除日志:终端未同步成功订单列表
2024-10-20 11:31:12 开始打印,排队:59,票券:2410201131008229475201,订单:24102011310082290794,[2024-10-20 11:31:11支付宝支付10元]
2024-10-20 11:31:12 开始打印,排队:60,票券:2410201131008229626702,订单:24102011310082290794,[2024-10-20 11:31:11支付宝支付10元]
2024-10-20 11:31:15 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410201131008229475201","queue_number":59,"trade_uid":"24102011310082290794"},{"ticket_no":"2410201131008229626702","queue_number":60,"trade_uid":"24102011310082290794"}]}
2024-10-20 11:31:15 >>>故障排除日志:删除未同步下发订单成功24102011310082290794
2024-10-20 11:31:15 >>>故障排除日志:删除未同步下发订单成功24102011310082290794
2024-10-20 11:31:15 >>>故障排除日志:终端同步成功后剩余订单列表


===11:32:38===
2024-10-20 11:32:30>>>cash read=00
2024-10-20 11:32:31>>>cash read=818F41
2024-10-20 11:32:31>>>cash write=02
2024-10-20 11:32:31 >>>回调事件130,cash_status,10022,进钞中...read money=5
2024-10-20 11:32:31>>>cash read=10
2024-10-20 11:32:31 >>>回调事件130,5,10023,finish Money=5,进钞完成
2024-10-20 11:32:32>>>cash write=0C
2024-10-20 11:32:32>>>cash read=00
2024-10-20 11:32:34>>>cash read=818F41
2024-10-20 11:32:34>>>cash write=02
2024-10-20 11:32:34 >>>回调事件130,cash_status,10022,进钞中...read money=5
2024-10-20 11:32:34>>>cash read=10
2024-10-20 11:32:34 >>>回调事件130,5,10023,finish Money=5,进钞完成
2024-10-20 11:32:34 当前产品价格10元，投币10元，打印小票中...
2024-10-20 11:32:34 >>>开始打印,排队号为61,订单号为2410201132310000002656
2024-10-20 11:32:34>>>订单2410201132310000002656写入成功,剩余空间为1679500,占用RAM为609.4150390625


===11:33:38===
2024-10-20 11:32:37>>>cash write=0C
2024-10-20 11:32:38>>>cash read=3E
定时检测未同步订单关闭
检测订单目录中>>>
无未同步订单>>>


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


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


===11:49:39===
2024-10-20 11:48:58 >>>回调事件[910,devices/D0519]
2024-10-20 11:48:58 >>>故障排除日志:上一MQTT订单号缓存列表为24102011450356300116
2024-10-20 11:48:58 >>>故障排除日志:终端未同步成功订单列表
2024-10-20 11:48:58 开始打印,排队:64,票券:2410201148389470957201,订单:24102011483894701181,[2024-10-20 11:48:58支付宝支付10元]
2024-10-20 11:49:00 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410201148389470957201","queue_number":64,"trade_uid":"24102011483894701181"}]}
2024-10-20 11:49:00 >>>故障排除日志:删除未同步下发订单成功24102011483894701181
2024-10-20 11:49:00 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-20 11:49:21>>>cash read=00
2024-10-20 11:49:22>>>cash read=818F42
2024-10-20 11:49:22>>>cash write=02
2024-10-20 11:49:22 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-20 11:49:22>>>cash read=10
2024-10-20 11:49:22 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-20 11:49:22 当前产品价格10元，投币10元，打印小票中...
2024-10-20 11:49:22 >>>开始打印,排队号为65,订单号为2410201149220000061505
2024-10-20 11:49:22>>>订单2410201149220000061505写入成功,剩余空间为1679000,占用RAM为610.1845703125
删除未同步订单2410201149220000061505
2024-10-20 11:49:24>>>订单2410201149220000061505删除成功,剩余空间为1680000,占用RAM为622.291015625
检测订单目录中>>>
无未同步订单>>>
2024-10-20 11:49:24 >>>当前Ram内存为593.06640625
定时检测未同步订单启用
2024-10-20 11:49:25>>>cash write=0C
2024-10-20 11:49:25>>>cash read=3E


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


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


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


===12:00:40===
2024-10-20 11:59:39 >>>回调事件[910,devices/D0519]
2024-10-20 11:59:39 >>>故障排除日志:上一MQTT订单号缓存列表为24102011553261753594
2024-10-20 11:59:39 >>>故障排除日志:终端未同步成功订单列表
2024-10-20 11:59:39 开始打印,排队:69,票券:2410201159296472101901,订单:24102011592964716581,[2024-10-20 11:59:39支付宝支付10元]
2024-10-20 11:59:41 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410201159296472101901","queue_number":69,"trade_uid":"24102011592964716581"}]}
2024-10-20 11:59:41 >>>故障排除日志:删除未同步下发订单成功24102011592964716581
2024-10-20 11:59:41 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-20 12:00:01 >>>回调事件[910,devices/D0519]
2024-10-20 12:00:01 >>>故障排除日志:上一MQTT订单号缓存列表为24102011592964716581
2024-10-20 12:00:01 >>>故障排除日志:终端未同步成功订单列表
2024-10-20 12:00:01 开始打印,排队:70,票券:2410201159554044504101,订单:24102011595540441181,[2024-10-20 12:00:01支付宝支付10元]
2024-10-20 12:00:03 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410201159554044504101","queue_number":70,"trade_uid":"24102011595540441181"}]}
2024-10-20 12:00:03 >>>故障排除日志:删除未同步下发订单成功24102011595540441181
2024-10-20 12:00:03 >>>故障排除日志:终端同步成功后剩余订单列表


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


===12:12:41===
2024-10-20 12:12:21>>>cash read=29
2024-10-20 12:12:21 >>>回调事件130,cash_status,20029,退钞中
2024-10-20 12:12:22>>>cash read=01
2024-10-20 12:12:23>>>cash read=3E
2024-10-20 12:12:25>>>cash read=00
2024-10-20 12:12:27>>>cash read=818F4200
2024-10-20 12:12:27>>>cash write=02
2024-10-20 12:12:27 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-20 12:12:27>>>cash read=10
2024-10-20 12:12:27 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-20 12:12:27 当前产品价格10元，投币10元，打印小票中...
2024-10-20 12:12:27 >>>开始打印,排队号为72,订单号为2410201212270000026731
2024-10-20 12:12:27>>>订单2410201212270000026731写入成功,剩余空间为1679500,占用RAM为608.052734375
删除未同步订单2410201212270000026731
2024-10-20 12:12:30>>>订单2410201212270000026731删除成功,剩余空间为1680500,占用RAM为632.470703125
检测订单目录中>>>
无未同步订单>>>
2024-10-20 12:12:30 >>>当前Ram内存为591.560546875
定时检测未同步订单启用
2024-10-20 12:12:30>>>cash write=0C
2024-10-20 12:12:31>>>cash read=3E


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


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


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


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


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


===12:32:42===
2024-10-20 12:32:03 >>>回调事件[910,devices/D0519]
2024-10-20 12:32:03 >>>故障排除日志:上一MQTT订单号缓存列表为24102012304456236076
2024-10-20 12:32:03 >>>故障排除日志:终端未同步成功订单列表
2024-10-20 12:32:03 开始打印,排队:77,票券:2410201231570429902401,订单:24102012315704295174,[2024-10-20 12:32:03微信支付10元]
2024-10-20 12:32:05 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410201231570429902401","queue_number":77,"trade_uid":"24102012315704295174"}]}
2024-10-20 12:32:05 >>>故障排除日志:删除未同步下发订单成功24102012315704295174
2024-10-20 12:32:05 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-20 12:32:19 >>>回调事件[910,devices/D0519]
2024-10-20 12:32:19 >>>故障排除日志:上一MQTT订单号缓存列表为24102012315704295174
2024-10-20 12:32:19 >>>故障排除日志:终端未同步成功订单列表
2024-10-20 12:32:19 开始打印,排队:78,票券:2410201232130874637901,订单:24102012321308741486,[2024-10-20 12:32:19微信支付10元]
2024-10-20 12:32:21 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410201232130874637901","queue_number":78,"trade_uid":"24102012321308741486"}]}
2024-10-20 12:32:21 >>>故障排除日志:删除未同步下发订单成功24102012321308741486
2024-10-20 12:32:21 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-20 12:32:24 >>>回调事件[910,devices/D0519]
2024-10-20 12:32:24 >>>故障排除日志:上一MQTT订单号缓存列表为24102012321308741486
2024-10-20 12:32:24 >>>故障排除日志:终端未同步成功订单列表
2024-10-20 12:32:24 开始打印,排队:79,票券:2410201232187228216701,订单:24102012321872276368,[2024-10-20 12:32:24微信支付10元]
2024-10-20 12:32:26 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410201232187228216701","queue_number":79,"trade_uid":"24102012321872276368"}]}
2024-10-20 12:32:26 >>>故障排除日志:删除未同步下发订单成功24102012321872276368
2024-10-20 12:32:26 >>>故障排除日志:终端同步成功后剩余订单列表


===12:35:42===
2024-10-20 12:35:29 >>>回调事件[910,devices/D0519]
2024-10-20 12:35:29 >>>故障排除日志:上一MQTT订单号缓存列表为24102012321872276368
2024-10-20 12:35:29 >>>故障排除日志:终端未同步成功订单列表
2024-10-20 12:35:29 开始打印,排队:80,票券:2410201235234479689601,订单:24102012352344791918,[2024-10-20 12:35:28微信支付10元]
2024-10-20 12:35:31 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410201235234479689601","queue_number":80,"trade_uid":"24102012352344791918"}]}
2024-10-20 12:35:31 >>>故障排除日志:删除未同步下发订单成功24102012352344791918
2024-10-20 12:35:31 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-20 12:35:35 >>>回调事件[910,devices/D0519]
2024-10-20 12:35:35 >>>故障排除日志:上一MQTT订单号缓存列表为24102012352344791918
2024-10-20 12:35:35 >>>故障排除日志:终端未同步成功订单列表
2024-10-20 12:35:35 开始打印,排队:81,票券:2410201235242881808701,订单:24102012352428812618,[2024-10-20 12:35:34微信支付10元]
2024-10-20 12:35:37 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410201235242881808701","queue_number":81,"trade_uid":"24102012352428812618"}]}
2024-10-20 12:35:37 >>>故障排除日志:删除未同步下发订单成功24102012352428812618
2024-10-20 12:35:37 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


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


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


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


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


===12:58:44===
2024-10-20 12:57:58>>>cash read=00
2024-10-20 12:57:59>>>cash read=29
2024-10-20 12:57:59 >>>回调事件130,cash_status,20029,退钞中
2024-10-20 12:58:00>>>cash read=2F29
2024-10-20 12:58:01>>>cash read=3E
2024-10-20 12:58:02>>>cash read=00
2024-10-20 12:58:02>>>cash read=818F42
2024-10-20 12:58:02>>>cash write=02
2024-10-20 12:58:02 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-20 12:58:03>>>cash read=10
2024-10-20 12:58:03 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-20 12:58:03 当前产品价格10元，投币10元，打印小票中...
2024-10-20 12:58:03 >>>开始打印,排队号为91,订单号为2410201258030000087044
2024-10-20 12:58:03>>>订单2410201258030000087044写入成功,剩余空间为1679500,占用RAM为610.40625
删除未同步订单2410201258030000087044
2024-10-20 12:58:05>>>订单2410201258030000087044删除成功,剩余空间为1680500,占用RAM为620.19140625
检测订单目录中>>>
无未同步订单>>>
2024-10-20 12:58:05 >>>当前Ram内存为591.8759765625
定时检测未同步订单启用
2024-10-20 12:58:06>>>cash write=0C
2024-10-20 12:58:06>>>cash read=3E
2024-10-20 12:58:08 >>>回调事件[910,devices/D0519]
2024-10-20 12:58:08 >>>故障排除日志:上一MQTT订单号缓存列表为24102012554592751078
2024-10-20 12:58:08 >>>故障排除日志:终端未同步成功订单列表
2024-10-20 12:58:08 开始打印,排队:92,票券:2410201257552081193101,订单:24102012575520805886,[2024-10-20 12:58:08微信支付10元]
2024-10-20 12:58:10 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410201257552081193101","queue_number":92,"trade_uid":"24102012575520805886"}]}
2024-10-20 12:58:10 >>>故障排除日志:删除未同步下发订单成功24102012575520805886
2024-10-20 12:58:10 >>>故障排除日志:终端同步成功后剩余订单列表


===12:59:44===
2024-10-20 12:58:50 >>>回调事件[910,devices/D0519]
2024-10-20 12:58:50 >>>故障排除日志:上一MQTT订单号缓存列表为24102012575520805886
2024-10-20 12:58:50 >>>故障排除日志:终端未同步成功订单列表
2024-10-20 12:58:50 开始打印,排队:93,票券:2410201258432569681801,订单:24102012584325687976,[2024-10-20 12:58:50支付宝支付10元]
2024-10-20 12:58:52 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410201258432569681801","queue_number":93,"trade_uid":"24102012584325687976"}]}
2024-10-20 12:58:52 >>>故障排除日志:删除未同步下发订单成功24102012584325687976
2024-10-20 12:58:52 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单关闭
检测订单目录中>>>
无未同步订单>>>


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


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


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


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


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


===13:08:45===
2024-10-20 13:08:07 >>>回调事件[910,devices/D0519]
2024-10-20 13:08:07 >>>故障排除日志:上一MQTT订单号缓存列表为24102013064233907567
2024-10-20 13:08:07 >>>故障排除日志:终端未同步成功订单列表
2024-10-20 13:08:07 开始打印,排队:99,票券:2410201308017172956801,订单:24102013080171725121,[2024-10-20 13:08:07支付宝支付10元]
2024-10-20 13:08:09 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410201308017172956801","queue_number":99,"trade_uid":"24102013080171725121"}]}
2024-10-20 13:08:09 >>>故障排除日志:删除未同步下发订单成功24102013080171725121
2024-10-20 13:08:09 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-20 13:08:40 >>>回调事件[910,devices/D0519]
2024-10-20 13:08:40 >>>故障排除日志:上一MQTT订单号缓存列表为24102013080171725121
2024-10-20 13:08:40 >>>故障排除日志:终端未同步成功订单列表
2024-10-20 13:08:40 开始打印,排队:100,票券:2410201308325479512401,订单:24102013083254766316,[2024-10-20 13:08:39微信支付10元]
2024-10-20 13:08:40 开始打印,排队:101,票券:2410201308325479795702,订单:24102013083254766316,[2024-10-20 13:08:39微信支付10元]
2024-10-20 13:08:44 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410201308325479512401","queue_number":100,"trade_uid":"24102013083254766316"},{"ticket_no":"2410201308325479795702","queue_number":101,"trade_uid":"24102013083254766316"}]}
2024-10-20 13:08:44 >>>故障排除日志:删除未同步下发订单成功24102013083254766316
2024-10-20 13:08:44 >>>故障排除日志:删除未同步下发订单成功24102013083254766316
2024-10-20 13:08:44 >>>故障排除日志:终端同步成功后剩余订单列表


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


===13:12:46===
2024-10-20 13:11:58>>>cash read=00
2024-10-20 13:11:59>>>cash read=2F29
2024-10-20 13:12:00>>>cash read=01
2024-10-20 13:12:04>>>cash read=2F
2024-10-20 13:12:05>>>cash read=00
2024-10-20 13:12:06>>>cash read=2F29
2024-10-20 13:12:08>>>cash read=3E
2024-10-20 13:12:17>>>cash read=29
2024-10-20 13:12:17 >>>回调事件130,cash_status,20029,退钞中
2024-10-20 13:12:18>>>cash read=01
2024-10-20 13:12:22>>>cash read=00
2024-10-20 13:12:24>>>cash read=818F42
2024-10-20 13:12:24>>>cash write=02
2024-10-20 13:12:24 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-20 13:12:24>>>cash read=10
2024-10-20 13:12:24 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-20 13:12:24 当前产品价格10元，投币10元，打印小票中...
2024-10-20 13:12:24 >>>开始打印,排队号为103,订单号为2410201312240000080792
2024-10-20 13:12:24>>>订单2410201312240000080792写入成功,剩余空间为1679500,占用RAM为609.400390625
删除未同步订单2410201312240000080792
2024-10-20 13:12:26>>>订单2410201312240000080792删除成功,剩余空间为1680000,占用RAM为619.36328125
检测订单目录中>>>
无未同步订单>>>
2024-10-20 13:12:27 >>>当前Ram内存为591.9736328125
定时检测未同步订单启用
2024-10-20 13:12:28>>>cash write=0C
2024-10-20 13:12:28>>>cash read=3E


===13:13:46===
2024-10-20 13:12:45 >>>回调事件[910,devices/D0519]
2024-10-20 13:12:45 >>>故障排除日志:上一MQTT订单号缓存列表为24102013100102070064
2024-10-20 13:12:45 >>>故障排除日志:终端未同步成功订单列表
2024-10-20 13:12:45 开始打印,排队:104,票券:2410201312396848173201,订单:24102013123968478014,[2024-10-20 13:12:45支付宝支付10元]
2024-10-20 13:12:47 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410201312396848173201","queue_number":104,"trade_uid":"24102013123968478014"}]}
2024-10-20 13:12:47 >>>故障排除日志:删除未同步下发订单成功24102013123968478014
2024-10-20 13:12:47 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单关闭
检测订单目录中>>>
无未同步订单>>>


===13:16:46===
2024-10-20 13:16:25 >>>回调事件[910,devices/D0519]
2024-10-20 13:16:25 >>>故障排除日志:上一MQTT订单号缓存列表为24102013123968478014
2024-10-20 13:16:25 >>>故障排除日志:终端未同步成功订单列表
2024-10-20 13:16:25 开始打印,排队:105,票券:2410201316209729396301,订单:24102013162097289685,[2024-10-20 13:16:25支付宝支付10元]
2024-10-20 13:16:27 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410201316209729396301","queue_number":105,"trade_uid":"24102013162097289685"}]}
2024-10-20 13:16:27 >>>故障排除日志:删除未同步下发订单成功24102013162097289685
2024-10-20 13:16:27 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-20 13:16:40 >>>回调事件[910,devices/D0519]
2024-10-20 13:16:41 >>>故障排除日志:上一MQTT订单号缓存列表为24102013162097289685
2024-10-20 13:16:41 >>>故障排除日志:终端未同步成功订单列表
2024-10-20 13:16:41 开始打印,排队:106,票券:2410201316344598125801,订单:24102013163445976572,[2024-10-20 13:16:40微信支付10元]
2024-10-20 13:16:43 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410201316344598125801","queue_number":106,"trade_uid":"24102013163445976572"}]}
2024-10-20 13:16:43 >>>故障排除日志:删除未同步下发订单成功24102013163445976572
2024-10-20 13:16:43 >>>故障排除日志:终端同步成功后剩余订单列表


===13:18:47===
2024-10-20 13:17:47 >>>回调事件[910,devices/D0519]
2024-10-20 13:17:47 >>>故障排除日志:上一MQTT订单号缓存列表为24102013163445976572
2024-10-20 13:17:47 >>>故障排除日志:终端未同步成功订单列表
2024-10-20 13:17:47 开始打印,排队:107,票券:2410201317397238987501,订单:24102013173972385915,[2024-10-20 13:17:47微信支付10元]
2024-10-20 13:17:49 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410201317397238987501","queue_number":107,"trade_uid":"24102013173972385915"}]}
2024-10-20 13:17:49 >>>故障排除日志:删除未同步下发订单成功24102013173972385915
2024-10-20 13:17:49 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-20 13:18:11 >>>回调事件[910,devices/D0519]
2024-10-20 13:18:11 >>>故障排除日志:上一MQTT订单号缓存列表为24102013173972385915
2024-10-20 13:18:11 >>>故障排除日志:终端未同步成功订单列表
2024-10-20 13:18:11 开始打印,排队:108,票券:2410201317596311089401,订单:24102013175963107237,[2024-10-20 13:18:11支付宝支付10元]
2024-10-20 13:18:13 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410201317596311089401","queue_number":108,"trade_uid":"24102013175963107237"}]}
2024-10-20 13:18:13 >>>故障排除日志:删除未同步下发订单成功24102013175963107237
2024-10-20 13:18:13 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


===14:22:52===
2024-10-20 14:22:06 >>>回调事件[910,devices/D0519]
2024-10-20 14:22:07 >>>故障排除日志:上一MQTT订单号缓存列表为24102014193862270268
2024-10-20 14:22:07 >>>故障排除日志:终端未同步成功订单列表
2024-10-20 14:22:07 开始打印,排队:132,票券:2410201421589562755901,订单:24102014215895623014,[2024-10-20 14:22:06微信支付10元]
2024-10-20 14:22:09 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410201421589562755901","queue_number":132,"trade_uid":"24102014215895623014"}]}
2024-10-20 14:22:09 >>>故障排除日志:删除未同步下发订单成功24102014215895623014
2024-10-20 14:22:09 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-20 14:22:26 >>>回调事件[910,devices/D0519]
2024-10-20 14:22:26 >>>故障排除日志:上一MQTT订单号缓存列表为24102014215895623014
2024-10-20 14:22:26 >>>故障排除日志:终端未同步成功订单列表
2024-10-20 14:22:26 开始打印,排队:133,票券:2410201422200839117401,订单:24102014222008386891,[2024-10-20 14:22:26微信支付10元]
2024-10-20 14:22:28 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410201422200839117401","queue_number":133,"trade_uid":"24102014222008386891"}]}
2024-10-20 14:22:28 >>>故障排除日志:删除未同步下发订单成功24102014222008386891
2024-10-20 14:22:28 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


===14:28:53===
2024-10-20 14:28:20>>>cash read=00
2024-10-20 14:28:21>>>cash read=818F42
2024-10-20 14:28:21>>>cash write=02
2024-10-20 14:28:21 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-20 14:28:21>>>cash read=10
2024-10-20 14:28:21 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-20 14:28:21 当前产品价格10元，投币10元，打印小票中...
2024-10-20 14:28:21 >>>开始打印,排队号为135,订单号为2410201428210024550994
2024-10-20 14:28:22>>>订单2410201428210024550994写入成功,剩余空间为1680000,占用RAM为607.4501953125
删除未同步订单2410201428210024550994
2024-10-20 14:28:24>>>订单2410201428210024550994删除成功,剩余空间为1680500,占用RAM为617.8447265625
检测订单目录中>>>
无未同步订单>>>
2024-10-20 14:28:24 >>>当前Ram内存为589.853515625
定时检测未同步订单启用
2024-10-20 14:28:25>>>cash write=0C
2024-10-20 14:28:25>>>cash read=3E
2024-10-20 14:28:40 >>>回调事件[910,devices/D0519]
2024-10-20 14:28:40 >>>故障排除日志:上一MQTT订单号缓存列表为24102014222008386891
2024-10-20 14:28:40 >>>故障排除日志:终端未同步成功订单列表
2024-10-20 14:28:40 开始打印,排队:136,票券:2410201428176127252301,订单:24102014281761268473,[2024-10-20 14:28:40支付宝支付10元]
2024-10-20 14:28:42 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410201428176127252301","queue_number":136,"trade_uid":"24102014281761268473"}]}
2024-10-20 14:28:42 >>>故障排除日志:删除未同步下发订单成功24102014281761268473
2024-10-20 14:28:42 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


===14:32:54===
2024-10-20 14:31:56 >>>回调事件[910,devices/D0519]
2024-10-20 14:31:56 >>>故障排除日志:上一MQTT订单号缓存列表为24102014295379872746
2024-10-20 14:31:56 >>>故障排除日志:终端未同步成功订单列表
2024-10-20 14:31:56 开始打印,排队:138,票券:2410201431475045564901,订单:24102014314750451048,[2024-10-20 14:31:55支付宝支付10元]
2024-10-20 14:31:58>>>cash read=818F42
2024-10-20 14:31:58>>>cash write=02
2024-10-20 14:31:58 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-20 14:31:58 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410201431475045564901","queue_number":138,"trade_uid":"24102014314750451048"}]}
2024-10-20 14:31:58 >>>故障排除日志:删除未同步下发订单成功24102014314750451048
2024-10-20 14:31:58 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-20 14:31:58>>>cash read=10
2024-10-20 14:31:58 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-20 14:31:58 当前产品价格10元，投币10元，打印小票中...
2024-10-20 14:31:58 >>>开始打印,排队号为139,订单号为2410201431580009530590
2024-10-20 14:31:58>>>订单2410201431580009530590写入成功,剩余空间为1679000,占用RAM为611.37109375
删除未同步订单2410201431580009530590
2024-10-20 14:32:00>>>订单2410201431580009530590删除成功,剩余空间为1680000,占用RAM为623.8857421875
检测订单目录中>>>
无未同步订单>>>
2024-10-20 14:32:01 >>>当前Ram内存为592.0166015625
定时检测未同步订单启用
2024-10-20 14:32:01>>>cash write=0C
2024-10-20 14:32:02>>>cash read=3E


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


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


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


===14:55:55===
2024-10-20 14:55:26 >>>回调事件[910,devices/D0519]
2024-10-20 14:55:26 >>>故障排除日志:上一MQTT订单号缓存列表为24102014542398892484
2024-10-20 14:55:26 >>>故障排除日志:终端未同步成功订单列表
2024-10-20 14:55:26 开始打印,排队:142,票券:2410201455193302731801,订单:24102014551933023194,[2024-10-20 14:55:26微信支付10元]
2024-10-20 14:55:28 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410201455193302731801","queue_number":142,"trade_uid":"24102014551933023194"}]}
2024-10-20 14:55:28 >>>故障排除日志:删除未同步下发订单成功24102014551933023194
2024-10-20 14:55:28 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-20 14:55:50 >>>回调事件[910,devices/D0519]
2024-10-20 14:55:50 >>>故障排除日志:上一MQTT订单号缓存列表为24102014551933023194
2024-10-20 14:55:50 >>>故障排除日志:终端未同步成功订单列表
2024-10-20 14:55:50 开始打印,排队:143,票券:2410201455437828079501,订单:24102014554378264787,[2024-10-20 14:55:50微信支付10元]
2024-10-20 14:55:52 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410201455437828079501","queue_number":143,"trade_uid":"24102014554378264787"}]}
2024-10-20 14:55:52 >>>故障排除日志:删除未同步下发订单成功24102014554378264787
2024-10-20 14:55:52 >>>故障排除日志:终端同步成功后剩余订单列表


===14:56:56===
2024-10-20 14:56:53 >>>回调事件[910,devices/D0519]
2024-10-20 14:56:53 >>>故障排除日志:上一MQTT订单号缓存列表为24102014554378264787
2024-10-20 14:56:53 >>>故障排除日志:终端未同步成功订单列表
2024-10-20 14:56:53 开始打印,排队:144,票券:2410201456486394075901,订单:24102014564863934459,[2024-10-20 14:56:53微信支付10元]


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


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


===15:04:57===
定时检测未同步订单关闭
检测订单目录中>>>
无未同步订单>>>
2024-10-20 15:04:48 >>>回调事件[910,devices/D0519]
2024-10-20 15:04:49 >>>故障排除日志:上一MQTT订单号缓存列表为24102015011224645362
2024-10-20 15:04:49 >>>故障排除日志:终端未同步成功订单列表
2024-10-20 15:04:49 开始打印,排队:147,票券:2410201504432880205901,订单:24102015044328794381,[2024-10-20 15:04:48微信支付10元]
2024-10-20 15:04:50 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410201504432880205901","queue_number":147,"trade_uid":"24102015044328794381"}]}
2024-10-20 15:04:50 >>>故障排除日志:删除未同步下发订单成功24102015044328794381
2024-10-20 15:04:51 >>>故障排除日志:终端同步成功后剩余订单列表


===15:05:58===
2024-10-20 15:05:47>>>cash read=29
2024-10-20 15:05:47 >>>回调事件130,cash_status,20029,退钞中
2024-10-20 15:05:48>>>cash read=01
2024-10-20 15:05:49>>>cash read=3E
2024-10-20 15:05:53>>>cash read=00
2024-10-20 15:05:54>>>cash read=818F42
2024-10-20 15:05:54>>>cash write=02
2024-10-20 15:05:54 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-20 15:05:54>>>cash read=10
2024-10-20 15:05:54 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-20 15:05:54 当前产品价格10元，投币10元，打印小票中...
2024-10-20 15:05:54 >>>开始打印,排队号为148,订单号为2410201505540000000528
2024-10-20 15:05:55>>>订单2410201505540000000528写入成功,剩余空间为1679500,占用RAM为608.408203125


===15:06:58===
删除未同步订单2410201505540000000528
2024-10-20 15:05:57>>>订单2410201505540000000528删除成功,剩余空间为1681500,占用RAM为621.6220703125
检测订单目录中>>>
无未同步订单>>>
2024-10-20 15:05:57 >>>当前Ram内存为589.3408203125
定时检测未同步订单启用
2024-10-20 15:05:58>>>cash write=0C
2024-10-20 15:05:58>>>cash read=3E


===15:07:58===
定时检测未同步订单关闭
检测订单目录中>>>
无未同步订单>>>
2024-10-20 15:07:52 >>>回调事件[910,devices/D0519]
2024-10-20 15:07:52 >>>故障排除日志:上一MQTT订单号缓存列表为24102015044328794381
2024-10-20 15:07:52 >>>故障排除日志:终端未同步成功订单列表
2024-10-20 15:07:52 开始打印,排队:149,票券:2410201507474083847901,订单:24102015074740834036,[2024-10-20 15:07:52支付宝支付10元]
2024-10-20 15:07:53 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410201507474083847901","queue_number":149,"trade_uid":"24102015074740834036"}]}
2024-10-20 15:07:54 >>>故障排除日志:删除未同步下发订单成功24102015074740834036
2024-10-20 15:07:54 >>>故障排除日志:终端同步成功后剩余订单列表


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


===15:17:59===
2024-10-20 15:17:49>>>cash read=00
2024-10-20 15:17:51>>>cash read=2F29
2024-10-20 15:17:53>>>cash read=3E


===15:18:59===
2024-10-20 15:18:14>>>cash read=00
2024-10-20 15:18:16>>>cash read=2F29
2024-10-20 15:18:17>>>cash read=3E
2024-10-20 15:18:24>>>cash read=00
2024-10-20 15:18:25>>>cash read=01
2024-10-20 15:18:29>>>cash read=3E


===15:19:59===
2024-10-20 15:19:03>>>cash read=29
2024-10-20 15:19:03 >>>回调事件130,cash_status,20029,退钞中
2024-10-20 15:19:05>>>cash read=01
2024-10-20 15:19:07>>>cash read=00
2024-10-20 15:19:07>>>cash read=2F29
2024-10-20 15:19:09>>>cash read=00
2024-10-20 15:19:10>>>cash read=01
2024-10-20 15:19:11>>>cash read=3E
2024-10-20 15:19:13>>>cash read=00
2024-10-20 15:19:15>>>cash read=01
2024-10-20 15:19:16>>>cash read=3E
2024-10-20 15:19:20>>>cash read=00
2024-10-20 15:19:21>>>cash read=29
2024-10-20 15:19:21 >>>回调事件130,cash_status,20029,退钞中
2024-10-20 15:19:22>>>cash read=2F29
2024-10-20 15:19:23>>>cash read=01
2024-10-20 15:19:24>>>cash read=2F
2024-10-20 15:19:25>>>cash read=3E
2024-10-20 15:19:26>>>cash read=00
2024-10-20 15:19:28>>>cash read=2F29
2024-10-20 15:19:30>>>cash read=3E
2024-10-20 15:19:31>>>cash read=00
2024-10-20 15:19:32>>>cash read=2F29
2024-10-20 15:19:33>>>cash read=3E
2024-10-20 15:19:34>>>cash read=29
2024-10-20 15:19:34 >>>回调事件130,cash_status,20029,退钞中
2024-10-20 15:19:35>>>cash read=3E
2024-10-20 15:19:37>>>cash read=00
2024-10-20 15:19:38>>>cash read=2F29
2024-10-20 15:19:39>>>cash read=3E
2024-10-20 15:19:40>>>cash read=29
2024-10-20 15:19:40 >>>回调事件130,cash_status,20029,退钞中
2024-10-20 15:19:41>>>cash read=00
2024-10-20 15:19:42>>>cash read=818F43
2024-10-20 15:19:42>>>cash write=02
2024-10-20 15:19:42 >>>回调事件130,cash_status,10022,进钞中...read money=20
2024-10-20 15:19:42>>>cash read=10
2024-10-20 15:19:43 >>>回调事件130,20,10023,finish Money=20,进钞完成
2024-10-20 15:19:43 当前产品价格10元，投币20元，打印小票中...
2024-10-20 15:19:43 >>>开始打印,排队号为151,订单号为2410201519430000084581
2024-10-20 15:19:43 >>>开始打印,排队号为152,订单号为2410201519430000084581
2024-10-20 15:19:43>>>订单2410201519430000084581写入成功,剩余空间为1678000,占用RAM为623.0888671875
删除未同步订单2410201519430000084581
2024-10-20 15:19:47>>>订单2410201519430000084581删除成功,剩余空间为1679000,占用RAM为632.404296875
检测订单目录中>>>
无未同步订单>>>
2024-10-20 15:19:47 >>>当前Ram内存为592.9853515625
定时检测未同步订单启用
2024-10-20 15:19:48>>>cash write=0C
2024-10-20 15:19:48>>>cash read=3E
2024-10-20 15:19:53>>>cash read=00
2024-10-20 15:19:55>>>cash read=818F42
2024-10-20 15:19:55>>>cash write=02
2024-10-20 15:19:55 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-20 15:19:55>>>cash read=10
2024-10-20 15:19:55 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-20 15:19:55 当前产品价格10元，投币10元，打印小票中...
2024-10-20 15:19:55 >>>开始打印,排队号为153,订单号为2410201519550020551422
定时检测未同步订单关闭
2024-10-20 15:19:56>>>订单2410201519550020551422写入成功,剩余空间为1677500,占用RAM为622.26953125


===15:20:59===
2024-10-20 15:19:59>>>cash write=0C
2024-10-20 15:19:59>>>cash read=3E
2024-10-20 15:20:17 >>>回调事件[910,devices/D0519]
2024-10-20 15:20:17 >>>故障排除日志:上一MQTT订单号缓存列表为24102015142723163716
2024-10-20 15:20:17 >>>故障排除日志:终端未同步成功订单列表
2024-10-20 15:20:17 开始打印,排队:154,票券:2410201520101697459101,订单:24102015201016969252,[2024-10-20 15:20:17微信支付10元]
2024-10-20 15:20:19 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410201520101697459101","queue_number":154,"trade_uid":"24102015201016969252"}]}
2024-10-20 15:20:19 >>>故障排除日志:删除未同步下发订单成功24102015201016969252
2024-10-20 15:20:19 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-20 15:20:29 >>>回调事件[910,devices/D0519]
2024-10-20 15:20:29 >>>故障排除日志:上一MQTT订单号缓存列表为24102015201016969252
2024-10-20 15:20:29 >>>故障排除日志:终端未同步成功订单列表
2024-10-20 15:20:29 开始打印,排队:155,票券:2410201520240626148701,订单:24102015202406252138,[2024-10-20 15:20:29支付宝支付10元]
2024-10-20 15:20:31 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410201520240626148701","queue_number":155,"trade_uid":"24102015202406252138"}]}
2024-10-20 15:20:31 >>>故障排除日志:删除未同步下发订单成功24102015202406252138
2024-10-20 15:20:31 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单关闭
检测订单目录中>>>
无未同步订单>>>


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


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


===15:34:00===
2024-10-20 15:33:25 >>>回调事件[910,devices/D0519]
2024-10-20 15:33:25 >>>故障排除日志:上一MQTT订单号缓存列表为24102015250484324397
2024-10-20 15:33:25 >>>故障排除日志:终端未同步成功订单列表
2024-10-20 15:33:25 开始打印,排队:158,票券:2410201533188105771501,订单:24102015331881053015,[2024-10-20 15:33:24微信支付10元]
2024-10-20 15:33:25 开始打印,排队:159,票券:2410201533188105972502,订单:24102015331881053015,[2024-10-20 15:33:24微信支付10元]
2024-10-20 15:33:28 >>>回调事件[910,devices/D0519]
2024-10-20 15:33:28 >>>故障排除日志:上一MQTT订单号缓存列表为24102015331881053015|24102015331881053015
2024-10-20 15:33:28 >>>故障排除日志:终端未同步成功订单列表015824102015331881053015|015924102015331881053015
2024-10-20 15:33:28 开始打印,排队:160,票券:2410201533129782829501,订单:24102015331297823094,[2024-10-20 15:33:26支付宝支付10元]
已接收过此消息,票券号为2410201533188105771501,排队号为158
已接收过此消息,票券号为2410201533188105972502,排队号为159
2024-10-20 15:33:30 >>>回调事件[910,devices/D0519]
2024-10-20 15:33:30 >>>故障排除日志:上一MQTT订单号缓存列表为24102015331297823094|24102015331881053015|24102015331881053015
2024-10-20 15:33:30 >>>故障排除日志:终端未同步成功订单列表015824102015331881053015|015924102015331881053015|016024102015331297823094
已接收过此消息,票券号为2410201533129782829501,排队号为160
已接收过此消息,票券号为2410201533188105771501,排队号为158
已接收过此消息,票券号为2410201533188105972502,排队号为159
2024-10-20 15:33:30 开始打印,排队:161,票券:2410201533239315567601,订单:24102015332393150895,[2024-10-20 15:33:29微信支付10元]
2024-10-20 15:33:32 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410201533188105771501","queue_number":158,"trade_uid":"24102015331881053015"},{"ticket_no":"2410201533188105972502","queue_number":159,"trade_uid":"24102015331881053015"}]}
2024-10-20 15:33:32 >>>故障排除日志:删除未同步下发订单成功24102015331881053015
2024-10-20 15:33:32 >>>故障排除日志:删除未同步下发订单成功24102015331881053015
2024-10-20 15:33:32 >>>故障排除日志:终端同步成功后剩余订单列表016024102015331297823094|016124102015332393150895
2024-10-20 15:33:32 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410201533129782829501","queue_number":160,"trade_uid":"24102015331297823094"},{"ticket_no":"2410201533188105771501","queue_number":158,"trade_uid":"24102015331881053015"},{"ticket_no":"2410201533188105972502","queue_number":159,"trade_uid":"24102015331881053015"}]}
2024-10-20 15:33:32 >>>故障排除日志:删除未同步下发订单成功24102015331297823094
2024-10-20 15:33:32 >>>故障排除日志:终端同步成功后剩余订单列表016124102015332393150895
2024-10-20 15:33:32 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410201533129782829501","queue_number":160,"trade_uid":"24102015331297823094"},{"ticket_no":"2410201533188105771501","queue_number":158,"trade_uid":"24102015331881053015"},{"ticket_no":"2410201533188105972502","queue_number":159,"trade_uid":"24102015331881053015"},{"ticket_no":"2410201533239315567601","queue_number":161,"trade_uid":"24102015332393150895"}]}
2024-10-20 15:33:32 >>>故障排除日志:删除未同步下发订单成功24102015332393150895
2024-10-20 15:33:32 >>>故障排除日志:终端同步成功后剩余订单列表


===15:35:00===
2024-10-20 15:34:30 >>>回调事件[910,devices/D0519]
2024-10-20 15:34:30 >>>故障排除日志:上一MQTT订单号缓存列表为24102015331297823094|24102015331881053015|24102015331881053015|24102015332393150895
2024-10-20 15:34:30 >>>故障排除日志:终端未同步成功订单列表
2024-10-20 15:34:30 开始打印,排队:162,票券:2410201534222611667801,订单:24102015342226110671,[2024-10-20 15:34:30微信支付10元]
2024-10-20 15:34:32 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410201534222611667801","queue_number":162,"trade_uid":"24102015342226110671"}]}
2024-10-20 15:34:32 >>>故障排除日志:删除未同步下发订单成功24102015342226110671
2024-10-20 15:34:32 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-20 15:34:45 >>>回调事件[910,devices/D0519]
2024-10-20 15:34:45 >>>故障排除日志:上一MQTT订单号缓存列表为24102015342226110671
2024-10-20 15:34:45 >>>故障排除日志:终端未同步成功订单列表
2024-10-20 15:34:45 开始打印,排队:163,票券:2410201534383010563501,订单:24102015343830101465,[2024-10-20 15:34:44微信支付10元]
2024-10-20 15:34:47 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410201534383010563501","queue_number":163,"trade_uid":"24102015343830101465"}]}
2024-10-20 15:34:47 >>>故障排除日志:删除未同步下发订单成功24102015343830101465
2024-10-20 15:34:47 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


===15:48:01===
2024-10-20 15:47:04 >>>回调事件[910,devices/D0519]
2024-10-20 15:47:04 >>>故障排除日志:上一MQTT订单号缓存列表为24102015464365437585
2024-10-20 15:47:04 >>>故障排除日志:终端未同步成功订单列表
2024-10-20 15:47:04 开始打印,排队:167,票券:2410201546381015649701,订单:24102015463810151379,[2024-10-20 15:47:03微信支付10元]
2024-10-20 15:47:06 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410201546381015649701","queue_number":167,"trade_uid":"24102015463810151379"}]}
2024-10-20 15:47:06 >>>故障排除日志:删除未同步下发订单成功24102015463810151379
2024-10-20 15:47:06 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-20 15:47:33 >>>回调事件[910,devices/D0519]
2024-10-20 15:47:33 >>>故障排除日志:上一MQTT订单号缓存列表为24102015463810151379
2024-10-20 15:47:33 >>>故障排除日志:终端未同步成功订单列表
2024-10-20 15:47:33 开始打印,排队:168,票券:2410201547276841624901,订单:24102015472768412158,[2024-10-20 15:47:33支付宝支付10元]
2024-10-20 15:47:35 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410201547276841624901","queue_number":168,"trade_uid":"24102015472768412158"}]}
2024-10-20 15:47:35 >>>故障排除日志:删除未同步下发订单成功24102015472768412158
2024-10-20 15:47:35 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


===16:02:03===
2024-10-20 16:01:05 >>>回调事件[910,devices/D0519]
2024-10-20 16:01:05 >>>故障排除日志:上一MQTT订单号缓存列表为24102015582530533252
2024-10-20 16:01:05 >>>故障排除日志:终端未同步成功订单列表
2024-10-20 16:01:05 开始打印,排队:172,票券:2410201601000481709701,订单:24102016010004811321,[2024-10-20 16:01:05微信支付10元]
2024-10-20 16:01:07 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410201601000481709701","queue_number":172,"trade_uid":"24102016010004811321"}]}
2024-10-20 16:01:07 >>>故障排除日志:删除未同步下发订单成功24102016010004811321
2024-10-20 16:01:08 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-20 16:01:34 >>>回调事件[910,devices/D0519]
2024-10-20 16:01:34 >>>故障排除日志:上一MQTT订单号缓存列表为24102016010004811321
2024-10-20 16:01:34 >>>故障排除日志:终端未同步成功订单列表
2024-10-20 16:01:34 开始打印,排队:173,票券:2410201601270363109501,订单:24102016012703625872,[2024-10-20 16:01:33微信支付10元]
2024-10-20 16:01:37 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410201601270363109501","queue_number":173,"trade_uid":"24102016012703625872"}]}
2024-10-20 16:01:37 >>>故障排除日志:删除未同步下发订单成功24102016012703625872
2024-10-20 16:01:37 >>>故障排除日志:终端同步成功后剩余订单列表


===16:06:03===
2024-10-20 16:05:20 >>>回调事件[910,devices/D0519]
2024-10-20 16:05:20 >>>故障排除日志:上一MQTT订单号缓存列表为24102016012703625872
2024-10-20 16:05:20 >>>故障排除日志:终端未同步成功订单列表
2024-10-20 16:05:20 开始打印,排队:174,票券:2410201605140233658501,订单:24102016051402332261,[2024-10-20 16:05:19微信支付10元]
2024-10-20 16:05:22 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410201605140233658501","queue_number":174,"trade_uid":"24102016051402332261"}]}
2024-10-20 16:05:22 >>>故障排除日志:删除未同步下发订单成功24102016051402332261
2024-10-20 16:05:22 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-20 16:05:27 >>>回调事件[910,devices/D0519]
2024-10-20 16:05:27 >>>故障排除日志:上一MQTT订单号缓存列表为24102016051402332261
2024-10-20 16:05:27 >>>故障排除日志:终端未同步成功订单列表
2024-10-20 16:05:27 开始打印,排队:175,票券:2410201605215984593101,订单:24102016052159841921,[2024-10-20 16:05:27微信支付10元]
2024-10-20 16:05:29 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410201605215984593101","queue_number":175,"trade_uid":"24102016052159841921"}]}
2024-10-20 16:05:29 >>>故障排除日志:删除未同步下发订单成功24102016052159841921
2024-10-20 16:05:29 >>>故障排除日志:终端同步成功后剩余订单列表


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


===16:14:05===
2024-10-20 16:13:44 >>>回调事件[910,devices/D0519]
2024-10-20 16:13:44 >>>故障排除日志:上一MQTT订单号缓存列表为24102016084431201894
2024-10-20 16:13:44 >>>故障排除日志:终端未同步成功订单列表
2024-10-20 16:13:44 开始打印,排队:177,票券:2410201613367260453501,订单:24102016133672599958,[2024-10-20 16:13:44微信支付10元]
2024-10-20 16:13:46 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410201613367260453501","queue_number":177,"trade_uid":"24102016133672599958"}]}
2024-10-20 16:13:46 >>>故障排除日志:删除未同步下发订单成功24102016133672599958
2024-10-20 16:13:46 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-20 16:14:02 >>>回调事件[910,devices/D0519]
2024-10-20 16:14:02 >>>故障排除日志:上一MQTT订单号缓存列表为24102016133672599958
2024-10-20 16:14:02 >>>故障排除日志:终端未同步成功订单列表
2024-10-20 16:14:02 开始打印,排队:178,票券:2410201613548678696901,订单:24102016135486781212,[2024-10-20 16:14:02微信支付10元]


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


===16:16:07===
2024-10-20 16:16:02 >>>回调事件[910,devices/D0519]
2024-10-20 16:16:02 >>>故障排除日志:上一MQTT订单号缓存列表为24102016141536706251
2024-10-20 16:16:02 >>>故障排除日志:终端未同步成功订单列表
2024-10-20 16:16:02 开始打印,排队:180,票券:2410201615570476908501,订单:24102016155704763185,[2024-10-20 16:16:02微信支付10元]
2024-10-20 16:16:02 开始打印,排队:181,票券:2410201615570477115702,订单:24102016155704763185,[2024-10-20 16:16:02微信支付10元]


===16:17:07===
2024-10-20 16:16:06 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410201615570476908501","queue_number":180,"trade_uid":"24102016155704763185"},{"ticket_no":"2410201615570477115702","queue_number":181,"trade_uid":"24102016155704763185"}]}
2024-10-20 16:16:06 >>>故障排除日志:删除未同步下发订单成功24102016155704763185
2024-10-20 16:16:06 >>>故障排除日志:删除未同步下发订单成功24102016155704763185
2024-10-20 16:16:06 >>>故障排除日志:终端同步成功后剩余订单列表


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


===16:24:08===
2024-10-20 16:23:09 >>>回调事件[910,devices/D0519]
2024-10-20 16:23:09 >>>故障排除日志:上一MQTT订单号缓存列表为24102016224802528053
2024-10-20 16:23:09 >>>故障排除日志:终端未同步成功订单列表
2024-10-20 16:23:09 开始打印,排队:183,票券:2410201623013715574801,订单:24102016230137151512,[2024-10-20 16:23:08微信支付10元]
2024-10-20 16:23:11 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410201623013715574801","queue_number":183,"trade_uid":"24102016230137151512"}]}
2024-10-20 16:23:11 >>>故障排除日志:删除未同步下发订单成功24102016230137151512
2024-10-20 16:23:11 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-20 16:23:23 >>>回调事件[910,devices/D0519]
2024-10-20 16:23:23 >>>故障排除日志:上一MQTT订单号缓存列表为24102016230137151512
2024-10-20 16:23:23 >>>故障排除日志:终端未同步成功订单列表
2024-10-20 16:23:23 开始打印,排队:184,票券:2410201623174497121301,订单:24102016231744966791,[2024-10-20 16:23:22微信支付10元]
2024-10-20 16:23:25 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410201623174497121301","queue_number":184,"trade_uid":"24102016231744966791"}]}
2024-10-20 16:23:25 >>>故障排除日志:删除未同步下发订单成功24102016231744966791
2024-10-20 16:23:25 >>>故障排除日志:终端同步成功后剩余订单列表


===16:26:08===
2024-10-20 16:25:26 >>>回调事件[910,devices/D0519]
2024-10-20 16:25:26 >>>故障排除日志:上一MQTT订单号缓存列表为24102016231744966791
2024-10-20 16:25:26 >>>故障排除日志:终端未同步成功订单列表
2024-10-20 16:25:26 开始打印,排队:185,票券:2410201625141823859101,订单:24102016251418235163,[2024-10-20 16:25:25支付宝支付10元]
2024-10-20 16:25:28 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410201625141823859101","queue_number":185,"trade_uid":"24102016251418235163"}]}
2024-10-20 16:25:28 >>>故障排除日志:删除未同步下发订单成功24102016251418235163
2024-10-20 16:25:28 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-20 16:25:47 >>>回调事件[910,devices/D0519]
2024-10-20 16:25:47 >>>故障排除日志:上一MQTT订单号缓存列表为24102016251418235163
2024-10-20 16:25:47 >>>故障排除日志:终端未同步成功订单列表
2024-10-20 16:25:47 开始打印,排队:186,票券:2410201625362754851201,订单:24102016253627544186,[2024-10-20 16:25:46微信支付10元]
2024-10-20 16:25:49 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410201625362754851201","queue_number":186,"trade_uid":"24102016253627544186"}]}
2024-10-20 16:25:49 >>>故障排除日志:删除未同步下发订单成功24102016253627544186
2024-10-20 16:25:49 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


===16:34:11===
2024-10-20 16:33:10 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410201632542323723801","queue_number":190,"trade_uid":"24102016325423232959"}]}
2024-10-20 16:33:10 >>>故障排除日志:删除未同步下发订单成功24102016325423232959
2024-10-20 16:33:10 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-20 16:34:05>>>cash read=00
2024-10-20 16:34:06>>>cash read=818F42
2024-10-20 16:34:06>>>cash write=02
2024-10-20 16:34:06 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-20 16:34:06>>>cash read=10
2024-10-20 16:34:06 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-20 16:34:06 当前产品价格10元，投币10元，打印小票中...
2024-10-20 16:34:06 >>>开始打印,排队号为191,订单号为2410201634060000040584
2024-10-20 16:34:07>>>订单2410201634060000040584写入成功,剩余空间为1679500,占用RAM为610.111328125
删除未同步订单2410201634060000040584
2024-10-20 16:34:09>>>订单2410201634060000040584删除成功,剩余空间为1680000,占用RAM为619.8896484375
检测订单目录中>>>
无未同步订单>>>
2024-10-20 16:34:09 >>>当前Ram内存为590.8173828125
定时检测未同步订单启用
2024-10-20 16:34:10>>>cash write=0C


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


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


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


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


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


===16:49:12===
2024-10-20 16:48:46 >>>回调事件[910,devices/D0519]
2024-10-20 16:48:46 >>>故障排除日志:上一MQTT订单号缓存列表为24102016471916714162
2024-10-20 16:48:46 >>>故障排除日志:终端未同步成功订单列表
2024-10-20 16:48:46 开始打印,排队:196,票券:2410201648420117968401,订单:24102016484201174747,[2024-10-20 16:48:46支付宝支付10元]
2024-10-20 16:48:48 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410201648420117968401","queue_number":196,"trade_uid":"24102016484201174747"}]}
2024-10-20 16:48:48 >>>故障排除日志:删除未同步下发订单成功24102016484201174747
2024-10-20 16:48:48 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-20 16:49:05 >>>回调事件[910,devices/D0519]
2024-10-20 16:49:06 >>>故障排除日志:上一MQTT订单号缓存列表为24102016484201174747
2024-10-20 16:49:06 >>>故障排除日志:终端未同步成功订单列表
2024-10-20 16:49:06 开始打印,排队:197,票券:2410201648594151966301,订单:24102016485941513992,[2024-10-20 16:49:05微信支付10元]
2024-10-20 16:49:06 开始打印,排队:198,票券:2410201648594152164802,订单:24102016485941513992,[2024-10-20 16:49:05微信支付10元]
2024-10-20 16:49:09 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410201648594151966301","queue_number":197,"trade_uid":"24102016485941513992"},{"ticket_no":"2410201648594152164802","queue_number":198,"trade_uid":"24102016485941513992"}]}
2024-10-20 16:49:09 >>>故障排除日志:删除未同步下发订单成功24102016485941513992
2024-10-20 16:49:09 >>>故障排除日志:删除未同步下发订单成功24102016485941513992
2024-10-20 16:49:09 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


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


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


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


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


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


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


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


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


===17:19:16===
2024-10-20 17:18:44 >>>回调事件[910,devices/D0519]
2024-10-20 17:18:44 >>>故障排除日志:上一MQTT订单号缓存列表为24102017180082752848|24102017180082752848
2024-10-20 17:18:44 >>>故障排除日志:终端未同步成功订单列表
2024-10-20 17:18:44 开始打印,排队:211,票券:2410201718388433117101,订单:24102017183884326685,[2024-10-20 17:18:44微信支付10元]
2024-10-20 17:18:46 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410201718388433117101","queue_number":211,"trade_uid":"24102017183884326685"}]}
2024-10-20 17:18:46 >>>故障排除日志:删除未同步下发订单成功24102017183884326685
2024-10-20 17:18:46 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-20 17:18:50>>>cash read=00
2024-10-20 17:18:51>>>cash read=818F42
2024-10-20 17:18:51>>>cash write=02
2024-10-20 17:18:51 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-20 17:18:52>>>cash read=10
2024-10-20 17:18:52 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-20 17:18:52 当前产品价格10元，投币10元，打印小票中...
2024-10-20 17:18:52 >>>开始打印,排队号为212,订单号为2410201718520000083413
2024-10-20 17:18:52>>>订单2410201718520000083413写入成功,剩余空间为1679000,占用RAM为612.4873046875
删除未同步订单2410201718520000083413
2024-10-20 17:18:54>>>订单2410201718520000083413删除成功,剩余空间为1680000,占用RAM为624.2880859375
检测订单目录中>>>
无未同步订单>>>
2024-10-20 17:18:54 >>>当前Ram内存为592.25
定时检测未同步订单启用
2024-10-20 17:18:55>>>cash write=0C
2024-10-20 17:18:55>>>cash read=3E


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


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


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


===17:33:17===
2024-10-20 17:32:23 >>>回调事件[910,devices/D0519]
2024-10-20 17:32:23 >>>故障排除日志:上一MQTT订单号缓存列表为24102017233247589953
2024-10-20 17:32:23 >>>故障排除日志:终端未同步成功订单列表
2024-10-20 17:32:23 开始打印,排队:215,票券:2410201732155900455801,订单:24102017321558999985,[2024-10-20 17:32:23支付宝支付10元]
2024-10-20 17:32:25 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410201732155900455801","queue_number":215,"trade_uid":"24102017321558999985"}]}
2024-10-20 17:32:25 >>>故障排除日志:删除未同步下发订单成功24102017321558999985
2024-10-20 17:32:25 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-20 17:33:02 >>>回调事件[910,devices/D0519]
2024-10-20 17:33:03 >>>故障排除日志:上一MQTT订单号缓存列表为24102017321558999985
2024-10-20 17:33:03 >>>故障排除日志:终端未同步成功订单列表
2024-10-20 17:33:03 开始打印,排队:216,票券:2410201732571586811301,订单:24102017325715864312,[2024-10-20 17:33:03微信支付10元]
2024-10-20 17:33:04 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410201732571586811301","queue_number":216,"trade_uid":"24102017325715864312"}]}
2024-10-20 17:33:04 >>>故障排除日志:删除未同步下发订单成功24102017325715864312
2024-10-20 17:33:05 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


===18:17:20===
2024-10-20 18:16:56 >>>回调事件[910,devices/D0519]
2024-10-20 18:16:56 >>>故障排除日志:上一MQTT订单号缓存列表为24102018154289684249
2024-10-20 18:16:56 >>>故障排除日志:终端未同步成功订单列表
2024-10-20 18:16:56 开始打印,排队:233,票券:2410201816372600393601,订单:24102018163725996917,[2024-10-20 18:16:56微信支付10元]
2024-10-20 18:16:57 开始打印,排队:234,票券:2410201816372600586302,订单:24102018163725996917,[2024-10-20 18:16:56微信支付10元]
2024-10-20 18:17:00 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410201816372600393601","queue_number":233,"trade_uid":"24102018163725996917"},{"ticket_no":"2410201816372600586302","queue_number":234,"trade_uid":"24102018163725996917"}]}
2024-10-20 18:17:00 >>>故障排除日志:删除未同步下发订单成功24102018163725996917
2024-10-20 18:17:00 >>>故障排除日志:删除未同步下发订单成功24102018163725996917
2024-10-20 18:17:00 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


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


===18:29:22===
2024-10-20 18:28:50 >>>回调事件[910,devices/D0519]
2024-10-20 18:28:50 >>>故障排除日志:上一MQTT订单号缓存列表为24102018280327226913
2024-10-20 18:28:50 >>>故障排除日志:终端未同步成功订单列表
2024-10-20 18:28:50 开始打印,排队:240,票券:2410201828428586895801,订单:24102018284285864721,[2024-10-20 18:28:50支付宝支付10元]
2024-10-20 18:28:50 开始打印,排队:241,票券:2410201828428587034902,订单:24102018284285864721,[2024-10-20 18:28:50支付宝支付10元]
2024-10-20 18:28:53 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410201828428586895801","queue_number":240,"trade_uid":"24102018284285864721"},{"ticket_no":"2410201828428587034902","queue_number":241,"trade_uid":"24102018284285864721"}]}
2024-10-20 18:28:53 >>>故障排除日志:删除未同步下发订单成功24102018284285864721
2024-10-20 18:28:53 >>>故障排除日志:删除未同步下发订单成功24102018284285864721
2024-10-20 18:28:53 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-20 18:29:08 >>>回调事件[910,devices/D0519]
2024-10-20 18:29:08 >>>故障排除日志:上一MQTT订单号缓存列表为24102018284285864721|24102018284285864721
2024-10-20 18:29:08 >>>故障排除日志:终端未同步成功订单列表
2024-10-20 18:29:08 开始打印,排队:242,票券:2410201829029659923401,订单:24102018290296594219,[2024-10-20 18:29:08微信支付10元]
2024-10-20 18:29:10 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410201829029659923401","queue_number":242,"trade_uid":"24102018290296594219"}]}
2024-10-20 18:29:10 >>>故障排除日志:删除未同步下发订单成功24102018290296594219
2024-10-20 18:29:10 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-20 18:29:18 >>>回调事件[910,devices/D0519]
2024-10-20 18:29:19 >>>故障排除日志:上一MQTT订单号缓存列表为24102018290296594219
2024-10-20 18:29:19 >>>故障排除日志:终端未同步成功订单列表
2024-10-20 18:29:19 开始打印,排队:243,票券:2410201829147523621301,订单:24102018291475231896,[2024-10-20 18:29:19微信支付10元]


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


===18:32:22===
2024-10-20 18:31:38 >>>回调事件[910,devices/D0519]
2024-10-20 18:31:38 >>>故障排除日志:上一MQTT订单号缓存列表为24102018300850471757
2024-10-20 18:31:38 >>>故障排除日志:终端未同步成功订单列表
2024-10-20 18:31:38 开始打印,排队:245,票券:2410201831327232791301,订单:24102018313272323115,[2024-10-20 18:31:38微信支付10元]
2024-10-20 18:31:40 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410201831327232791301","queue_number":245,"trade_uid":"24102018313272323115"}]}
2024-10-20 18:31:40 >>>故障排除日志:删除未同步下发订单成功24102018313272323115
2024-10-20 18:31:40 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-20 18:31:56 >>>回调事件[910,devices/D0519]
2024-10-20 18:31:56 >>>故障排除日志:上一MQTT订单号缓存列表为24102018313272323115
2024-10-20 18:31:56 >>>故障排除日志:终端未同步成功订单列表
2024-10-20 18:31:56 开始打印,排队:246,票券:2410201831493479968601,订单:24102018314934795918,[2024-10-20 18:31:56微信支付10元]
2024-10-20 18:31:58 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410201831493479968601","queue_number":246,"trade_uid":"24102018314934795918"}]}
2024-10-20 18:31:58 >>>故障排除日志:删除未同步下发订单成功24102018314934795918
2024-10-20 18:31:59 >>>故障排除日志:终端同步成功后剩余订单列表


===18:33:23===
2024-10-20 18:32:24 >>>回调事件[910,devices/D0519]
2024-10-20 18:32:24 >>>故障排除日志:上一MQTT订单号缓存列表为24102018314934795918
2024-10-20 18:32:24 >>>故障排除日志:终端未同步成功订单列表
2024-10-20 18:32:24 开始打印,排队:247,票券:2410201832180069077801,订单:24102018321800687051,[2024-10-20 18:32:24微信支付10元]
2024-10-20 18:32:26 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410201832180069077801","queue_number":247,"trade_uid":"24102018321800687051"}]}
2024-10-20 18:32:26 >>>故障排除日志:删除未同步下发订单成功24102018321800687051
2024-10-20 18:32:26 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-20 18:33:05 >>>回调事件[910,devices/D0519]
2024-10-20 18:33:05 >>>故障排除日志:上一MQTT订单号缓存列表为24102018321800687051
2024-10-20 18:33:05 >>>故障排除日志:终端未同步成功订单列表
2024-10-20 18:33:05 开始打印,排队:248,票券:2410201832589183029601,订单:24102018325891826375,[2024-10-20 18:33:04支付宝支付10元]
2024-10-20 18:33:07 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410201832589183029601","queue_number":248,"trade_uid":"24102018325891826375"}]}
2024-10-20 18:33:07 >>>故障排除日志:删除未同步下发订单成功24102018325891826375
2024-10-20 18:33:07 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


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


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


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


===18:49:24===
2024-10-20 18:48:25 >>>回调事件[910,devices/D0519]
2024-10-20 18:48:25 >>>故障排除日志:上一MQTT订单号缓存列表为24102018462530386652
2024-10-20 18:48:25 >>>故障排除日志:终端未同步成功订单列表
2024-10-20 18:48:26 开始打印,排队:256,票券:2410201848211529217401,订单:24102018482115288046,[2024-10-20 18:48:26微信支付10元]
2024-10-20 18:48:27 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410201848211529217401","queue_number":256,"trade_uid":"24102018482115288046"}]}
2024-10-20 18:48:28 >>>故障排除日志:删除未同步下发订单成功24102018482115288046
2024-10-20 18:48:28 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-20 18:49:11 >>>回调事件[910,devices/D0519]
2024-10-20 18:49:11 >>>故障排除日志:上一MQTT订单号缓存列表为24102018482115288046
2024-10-20 18:49:11 >>>故障排除日志:终端未同步成功订单列表
2024-10-20 18:49:11 开始打印,排队:257,票券:2410201849050354883801,订单:24102018490503543798,[2024-10-20 18:49:10微信支付10元]
2024-10-20 18:49:13 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410201849050354883801","queue_number":257,"trade_uid":"24102018490503543798"}]}
2024-10-20 18:49:13 >>>故障排除日志:删除未同步下发订单成功24102018490503543798
2024-10-20 18:49:13 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-20 18:49:14 >>>回调事件[910,devices/D0519]
2024-10-20 18:49:14 >>>故障排除日志:上一MQTT订单号缓存列表为24102018490503543798
2024-10-20 18:49:14 >>>故障排除日志:终端未同步成功订单列表
2024-10-20 18:49:14 开始打印,排队:258,票券:2410201849100422866201,订单:24102018491004224695,[2024-10-20 18:49:14支付宝支付10元]
2024-10-20 18:49:16 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410201849100422866201","queue_number":258,"trade_uid":"24102018491004224695"}]}
2024-10-20 18:49:16 >>>故障排除日志:删除未同步下发订单成功24102018491004224695
2024-10-20 18:49:16 >>>故障排除日志:终端同步成功后剩余订单列表


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


===18:54:24===
2024-10-20 18:54:05 >>>回调事件[910,devices/D0519]
2024-10-20 18:54:05 >>>故障排除日志:上一MQTT订单号缓存列表为24102018491782189652
2024-10-20 18:54:05 >>>故障排除日志:终端未同步成功订单列表
2024-10-20 18:54:05 开始打印,排队:260,票券:2410201853598721086301,订单:24102018535987206441,[2024-10-20 18:54:04微信支付10元]
2024-10-20 18:54:07 >>>回调事件[910,devices/D0519]
2024-10-20 18:54:07 >>>故障排除日志:上一MQTT订单号缓存列表为24102018535987206441
2024-10-20 18:54:07 >>>故障排除日志:终端未同步成功订单列表026024102018535987206441
已接收过此消息,票券号为2410201853598721086301,排队号为260
2024-10-20 18:54:07 开始打印,排队:261,票券:2410201854020188921701,订单:24102018540201883484,[2024-10-20 18:54:07微信支付10元]
2024-10-20 18:54:09 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410201853598721086301","queue_number":260,"trade_uid":"24102018535987206441"}]}
2024-10-20 18:54:09 >>>故障排除日志:删除未同步下发订单成功24102018535987206441
2024-10-20 18:54:09 >>>故障排除日志:终端同步成功后剩余订单列表026124102018540201883484
2024-10-20 18:54:09 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410201853598721086301","queue_number":260,"trade_uid":"24102018535987206441"},{"ticket_no":"2410201854020188921701","queue_number":261,"trade_uid":"24102018540201883484"}]}
2024-10-20 18:54:09 >>>故障排除日志:删除未同步下发订单成功24102018540201883484
2024-10-20 18:54:09 >>>故障排除日志:终端同步成功后剩余订单列表


===18:55:25===
2024-10-20 18:54:48 >>>回调事件[910,devices/D0519]
2024-10-20 18:54:48 >>>故障排除日志:上一MQTT订单号缓存列表为24102018535987206441|24102018540201883484
2024-10-20 18:54:48 >>>故障排除日志:终端未同步成功订单列表
2024-10-20 18:54:48 开始打印,排队:262,票券:2410201854420271914801,订单:24102018544202713738,[2024-10-20 18:54:48微信支付10元]
2024-10-20 18:54:50 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410201854420271914801","queue_number":262,"trade_uid":"24102018544202713738"}]}
2024-10-20 18:54:50 >>>故障排除日志:删除未同步下发订单成功24102018544202713738
2024-10-20 18:54:50 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


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


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


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


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


===19:19:26===
2024-10-20 19:18:58 >>>回调事件[910,devices/D0519]
2024-10-20 19:18:58 >>>故障排除日志:上一MQTT订单号缓存列表为24102019175533471459
2024-10-20 19:18:58 >>>故障排除日志:终端未同步成功订单列表
2024-10-20 19:18:58 开始打印,排队:271,票券:2410201918492614015101,订单:24102019184926135035,[2024-10-20 19:18:58微信支付10元]
2024-10-20 19:19:00 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410201918492614015101","queue_number":271,"trade_uid":"24102019184926135035"}]}
2024-10-20 19:19:00 >>>故障排除日志:删除未同步下发订单成功24102019184926135035
2024-10-20 19:19:00 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-20 19:19:14 >>>回调事件[910,devices/D0519]
2024-10-20 19:19:14 >>>故障排除日志:上一MQTT订单号缓存列表为24102019184926135035
2024-10-20 19:19:14 >>>故障排除日志:终端未同步成功订单列表
2024-10-20 19:19:14 开始打印,排队:272,票券:2410201919086273395301,订单:24102019190862729292,[2024-10-20 19:19:14支付宝支付10元]
2024-10-20 19:19:16 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410201919086273395301","queue_number":272,"trade_uid":"24102019190862729292"}]}
2024-10-20 19:19:16 >>>故障排除日志:删除未同步下发订单成功24102019190862729292
2024-10-20 19:19:16 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


===19:33:28===
2024-10-20 19:32:52 >>>回调事件[910,devices/D0519]
2024-10-20 19:32:52 >>>故障排除日志:上一MQTT订单号缓存列表为24102019294156106423
2024-10-20 19:32:52 >>>故障排除日志:终端未同步成功订单列表
2024-10-20 19:32:52 开始打印,排队:276,票券:2410201932437012407801,订单:24102019324370119362,[2024-10-20 19:32:52支付宝支付10元]
2024-10-20 19:32:54 >>>回调事件[910,devices/D0519]
2024-10-20 19:32:54 >>>故障排除日志:上一MQTT订单号缓存列表为24102019324370119362
2024-10-20 19:32:54 >>>故障排除日志:终端未同步成功订单列表027624102019324370119362
已接收过此消息,票券号为2410201932437012407801,排队号为276
2024-10-20 19:32:54 开始打印,排队:277,票券:2410201932471823708101,订单:24102019324718232315,[2024-10-20 19:32:53微信支付10元]
2024-10-20 19:32:56 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410201932437012407801","queue_number":276,"trade_uid":"24102019324370119362"}]}
2024-10-20 19:32:56 >>>故障排除日志:删除未同步下发订单成功24102019324370119362
2024-10-20 19:32:56 >>>故障排除日志:终端同步成功后剩余订单列表027724102019324718232315
2024-10-20 19:32:56 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410201932437012407801","queue_number":276,"trade_uid":"24102019324370119362"},{"ticket_no":"2410201932471823708101","queue_number":277,"trade_uid":"24102019324718232315"}]}
2024-10-20 19:32:56 >>>故障排除日志:删除未同步下发订单成功24102019324718232315
2024-10-20 19:32:56 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


===19:40:29===
2024-10-20 19:40:26 >>>回调事件[910,devices/D0519]
2024-10-20 19:40:26 >>>故障排除日志:上一MQTT订单号缓存列表为24102019385846052741
2024-10-20 19:40:26 >>>故障排除日志:终端未同步成功订单列表
2024-10-20 19:40:26 开始打印,排队:280,票券:2410201940185651023601,订单:24102019401856506492,[2024-10-20 19:40:25微信支付10元]


===19:41:29===
2024-10-20 19:40:28 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410201940185651023601","queue_number":280,"trade_uid":"24102019401856506492"}]}
2024-10-20 19:40:28 >>>故障排除日志:删除未同步下发订单成功24102019401856506492
2024-10-20 19:40:28 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-20 19:40:44 >>>回调事件[910,devices/D0519]
2024-10-20 19:40:44 >>>故障排除日志:上一MQTT订单号缓存列表为24102019401856506492
2024-10-20 19:40:44 >>>故障排除日志:终端未同步成功订单列表
2024-10-20 19:40:44 开始打印,排队:281,票券:2410201940371875254801,订单:24102019403718748065,[2024-10-20 19:40:43支付宝支付10元]
2024-10-20 19:40:46 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410201940371875254801","queue_number":281,"trade_uid":"24102019403718748065"}]}
2024-10-20 19:40:46 >>>故障排除日志:删除未同步下发订单成功24102019403718748065
2024-10-20 19:40:46 >>>故障排除日志:终端同步成功后剩余订单列表


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


===19:49:30===
2024-10-20 19:49:01 >>>回调事件[910,devices/D0519]
2024-10-20 19:49:01 >>>故障排除日志:上一MQTT订单号缓存列表为24102019474692248543
2024-10-20 19:49:01 >>>故障排除日志:终端未同步成功订单列表
2024-10-20 19:49:01 开始打印,排队:283,票券:2410201948550973306301,订单:24102019485509729851,[2024-10-20 19:49:00微信支付10元]
2024-10-20 19:49:03 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410201948550973306301","queue_number":283,"trade_uid":"24102019485509729851"}]}
2024-10-20 19:49:03 >>>故障排除日志:删除未同步下发订单成功24102019485509729851
2024-10-20 19:49:03 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-20 19:49:23 >>>回调事件[910,devices/D0519]
2024-10-20 19:49:23 >>>故障排除日志:上一MQTT订单号缓存列表为24102019485509729851
2024-10-20 19:49:23 >>>故障排除日志:终端未同步成功订单列表
2024-10-20 19:49:23 开始打印,排队:284,票券:2410201949160655908201,订单:24102019491606554592,[2024-10-20 19:49:23微信支付10元]
2024-10-20 19:49:25 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410201949160655908201","queue_number":284,"trade_uid":"24102019491606554592"}]}
2024-10-20 19:49:25 >>>故障排除日志:删除未同步下发订单成功24102019491606554592
2024-10-20 19:49:25 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


===19:52:30===
2024-10-20 19:51:33 >>>回调事件[910,devices/D0519]
2024-10-20 19:51:33 >>>故障排除日志:上一MQTT订单号缓存列表为24102019502732854517
2024-10-20 19:51:33 >>>故障排除日志:终端未同步成功订单列表
2024-10-20 19:51:33 开始打印,排队:287,票券:2410201951270577417301,订单:24102019512705770257,[2024-10-20 19:51:33微信支付10元]
2024-10-20 19:51:35 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410201951270577417301","queue_number":287,"trade_uid":"24102019512705770257"}]}
2024-10-20 19:51:35 >>>故障排除日志:删除未同步下发订单成功24102019512705770257
2024-10-20 19:51:36 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-20 19:52:10 >>>回调事件[910,devices/D0519]
2024-10-20 19:52:10 >>>故障排除日志:上一MQTT订单号缓存列表为24102019512705770257
2024-10-20 19:52:10 >>>故障排除日志:终端未同步成功订单列表
2024-10-20 19:52:10 开始打印,排队:288,票券:2410201952043926559801,订单:24102019520439261795,[2024-10-20 19:52:10微信支付10元]
2024-10-20 19:52:12 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410201952043926559801","queue_number":288,"trade_uid":"24102019520439261795"}]}
2024-10-20 19:52:12 >>>故障排除日志:删除未同步下发订单成功24102019520439261795
2024-10-20 19:52:12 >>>故障排除日志:终端同步成功后剩余订单列表


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


===19:56:34===
2024-10-20 19:55:38 >>>回调事件[910,devices/D0519]
2024-10-20 19:55:38 >>>故障排除日志:上一MQTT订单号缓存列表为24102019523216197731
2024-10-20 19:55:38 >>>故障排除日志:终端未同步成功订单列表
2024-10-20 19:55:38 开始打印,排队:290,票券:2410201955339544185601,订单:24102019553395437617,[2024-10-20 19:55:38支付宝支付10元]
2024-10-20 19:55:40 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410201955339544185601","queue_number":290,"trade_uid":"24102019553395437617"}]}
2024-10-20 19:55:40 >>>故障排除日志:删除未同步下发订单成功24102019553395437617
2024-10-20 19:55:41 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-20 19:56:17 >>>回调事件[910,devices/D0519]
2024-10-20 19:56:17 >>>故障排除日志:上一MQTT订单号缓存列表为24102019553395437617
2024-10-20 19:56:17 >>>故障排除日志:终端未同步成功订单列表
2024-10-20 19:56:17 开始打印,排队:291,票券:2410201956108510924201,订单:24102019561085105976,[2024-10-20 19:56:17支付宝支付10元]
2024-10-20 19:56:19 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410201956108510924201","queue_number":291,"trade_uid":"24102019561085105976"}]}
2024-10-20 19:56:19 >>>故障排除日志:删除未同步下发订单成功24102019561085105976
2024-10-20 19:56:19 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


===20:02:34===
2024-10-20 20:01:51 >>>回调事件[910,devices/D0519]
2024-10-20 20:01:51 >>>故障排除日志:上一MQTT订单号缓存列表为24102019593935954685
2024-10-20 20:01:51 >>>故障排除日志:终端未同步成功订单列表
2024-10-20 20:01:51 开始打印,排队:294,票券:2410202001360919774101,订单:24102020013609193017,[2024-10-20 20:01:51支付宝支付10元]
2024-10-20 20:01:54 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410202001360919774101","queue_number":294,"trade_uid":"24102020013609193017"}]}
2024-10-20 20:01:54 >>>故障排除日志:删除未同步下发订单成功24102020013609193017
2024-10-20 20:01:54 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单关闭
检测订单目录中>>>
无未同步订单>>>


===20:05:36===
2024-10-20 20:05:33 >>>回调事件[910,devices/D0519]
2024-10-20 20:05:33 >>>故障排除日志:上一MQTT订单号缓存列表为24102020013609193017
2024-10-20 20:05:33 >>>故障排除日志:终端未同步成功订单列表
2024-10-20 20:05:33 开始打印,排队:295,票券:2410202005127225627401,订单:24102020051272248663,[2024-10-20 20:05:32微信支付10元]


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


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


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


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


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


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


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


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


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


===20:28:39===
定时检测未同步订单关闭
检测订单目录中>>>
无未同步订单>>>
2024-10-20 20:28:07 >>>回调事件[910,devices/D0519]
2024-10-20 20:28:07 >>>故障排除日志:上一MQTT订单号缓存列表为24102020212053929394
2024-10-20 20:28:07 >>>故障排除日志:终端未同步成功订单列表
2024-10-20 20:28:07 开始打印,排队:304,票券:2410202027589162019101,订单:24102020275891616447,[2024-10-20 20:28:06微信支付10元]
2024-10-20 20:28:09 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410202027589162019101","queue_number":304,"trade_uid":"24102020275891616447"}]}
2024-10-20 20:28:09 >>>故障排除日志:删除未同步下发订单成功24102020275891616447
2024-10-20 20:28:09 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-20 20:28:31 >>>回调事件[910,devices/D0519]
2024-10-20 20:28:31 >>>故障排除日志:上一MQTT订单号缓存列表为24102020275891616447
2024-10-20 20:28:31 >>>故障排除日志:终端未同步成功订单列表
2024-10-20 20:28:31 开始打印,排队:305,票券:2410202028250522741301,订单:24102020282505222762,[2024-10-20 20:28:30微信支付10元]
2024-10-20 20:28:33 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410202028250522741301","queue_number":305,"trade_uid":"24102020282505222762"}]}
2024-10-20 20:28:33 >>>故障排除日志:删除未同步下发订单成功24102020282505222762
2024-10-20 20:28:33 >>>故障排除日志:终端同步成功后剩余订单列表


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


===20:31:39===
2024-10-20 20:30:53 >>>回调事件[910,devices/D0519]
2024-10-20 20:30:53 >>>故障排除日志:上一MQTT订单号缓存列表为24102020283427346241
2024-10-20 20:30:53 >>>故障排除日志:终端未同步成功订单列表
2024-10-20 20:30:53 开始打印,排队:307,票券:2410202030442369119701,订单:24102020304423687683,[2024-10-20 20:30:54支付宝支付10元]
2024-10-20 20:30:55 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410202030442369119701","queue_number":307,"trade_uid":"24102020304423687683"}]}
2024-10-20 20:30:55 >>>故障排除日志:删除未同步下发订单成功24102020304423687683
2024-10-20 20:30:55 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-20 20:31:33 >>>回调事件[910,devices/D0519]
2024-10-20 20:31:33 >>>故障排除日志:上一MQTT订单号缓存列表为24102020304423687683
2024-10-20 20:31:33 >>>故障排除日志:终端未同步成功订单列表
2024-10-20 20:31:33 开始打印,排队:308,票券:2410202031251694356501,订单:24102020312516938189,[2024-10-20 20:31:33微信支付10元]
2024-10-20 20:31:35 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410202031251694356501","queue_number":308,"trade_uid":"24102020312516938189"}]}
2024-10-20 20:31:35 >>>故障排除日志:删除未同步下发订单成功24102020312516938189
2024-10-20 20:31:35 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


===20:37:40===
2024-10-20 20:36:43 >>>回调事件[910,devices/D0519]
2024-10-20 20:36:43 >>>故障排除日志:上一MQTT订单号缓存列表为24102020340113583747
2024-10-20 20:36:43 >>>故障排除日志:终端未同步成功订单列表
2024-10-20 20:36:43 开始打印,排队:313,票券:2410202036359960368701,订单:24102020363599598524,[2024-10-20 20:36:42微信支付10元]
2024-10-20 20:36:45 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410202036359960368701","queue_number":313,"trade_uid":"24102020363599598524"}]}
2024-10-20 20:36:45 >>>故障排除日志:删除未同步下发订单成功24102020363599598524
2024-10-20 20:36:45 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-20 20:37:22 >>>回调事件[910,devices/D0519]
2024-10-20 20:37:22 >>>故障排除日志:上一MQTT订单号缓存列表为24102020363599598524
2024-10-20 20:37:22 >>>故障排除日志:终端未同步成功订单列表
2024-10-20 20:37:22 开始打印,排队:314,票券:2410202037152497841301,订单:24102020371524974745,[2024-10-20 20:37:22微信支付10元]
2024-10-20 20:37:24 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410202037152497841301","queue_number":314,"trade_uid":"24102020371524974745"}]}
2024-10-20 20:37:24 >>>故障排除日志:删除未同步下发订单成功24102020371524974745
2024-10-20 20:37:24 >>>故障排除日志:终端同步成功后剩余订单列表


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


===20:44:41===
2024-10-20 20:44:38 >>>回调事件[910,devices/D0519]
2024-10-20 20:44:38 >>>故障排除日志:上一MQTT订单号缓存列表为24102020385234601973
2024-10-20 20:44:38 >>>故障排除日志:终端未同步成功订单列表
2024-10-20 20:44:38 开始打印,排队:316,票券:2410202044323750937201,订单:24102020443237503729,[2024-10-20 20:44:38微信支付10元]


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


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


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


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


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


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


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


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