TLClient_JSSCOM_LuatOS-Air_V4010_RDA8910_RFTTS_0xe0000,2.5.4,869701076527905,12833956476533,
poweron reason:0

===09:42:13===
上一时间戳为1728008762
隔日重置时间戳true
隔日清空未同步下发列表true
当前排队号为1,音量为5
初始化产品信息:[{"time_limit_date":"","ticket_category":"0","expiry_date":90,"product_detail":"","time_limit_status":"0","begin_minute":"00","product_uid":"14872826055361622720","use_timer":1,"old_price":"10","end_hour":"23","sale_price":"10","end_minute":"59","begin_hour":"00","sale_status":1,"product_name":"快剪"}]
是否打印二维码设置为1
是否打印紧凑设置为3
session_id:5b0e5****44ff3
纸币器设置接收纸币范围为36
欢迎使用天羚自助售票系统[2.5.4]
定时检测未同步订单启用
2024-10-05 09:41:12>>>cash write=30
2024-10-05 09:41:12>>>cash write=02
2024-10-05 09:41:12>>>cash write=3E
2024-10-05 09:41:12>>>cash read=808F808F
系统时间初始化成功，时间为202410594112
2024-10-05 09:41:13>>>cash write=02
2024-10-05 09:41:13 >>>剩余flash空间=1680500,占用RAM为623.4150390625
2024-10-05 09:41:13 >>>回调事件:910,subscribe,10000,连接服务器成功

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

2024-10-05 09:41:16>>>cash write=0C
2024-10-05 09:41:16>>>cash read=3E
流量卡还有329天过期
2024-10-05 09:41:23 >>>当前Ram内存为644.388671875


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


===09:46:41===
上一时间戳为1728092471
当日首次设置时间戳true为1728092740
今日nvm排队号为1
当前排队号为1,音量为5
初始化产品信息:[{"time_limit_date":"","ticket_category":"0","expiry_date":90,"product_detail":"","time_limit_status":"0","begin_minute":"00","product_uid":"14872826055361622720","use_timer":1,"old_price":"10","end_hour":"23","sale_price":"10","end_minute":"59","begin_hour":"00","sale_status":1,"product_name":"快剪"}]
是否打印二维码设置为1
是否打印紧凑设置为3
session_id:2f8c4****8ea36
纸币器设置接收纸币范围为36
欢迎使用天羚自助售票系统[2.5.4]
定时检测未同步订单启用
2024-10-05 09:45:40>>>cash write=30
2024-10-05 09:45:40>>>cash write=02
2024-10-05 09:45:40>>>cash write=3E
2024-10-05 09:45:40>>>cash read=808F808F
系统时间初始化成功，时间为202410594540
2024-10-05 09:45:41>>>cash write=02
2024-10-05 09:45:41 >>>剩余flash空间=1680500,占用RAM为624.4931640625
2024-10-05 09:45:41 >>>回调事件:910,subscribe,10000,连接服务器成功

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

2024-10-05 09:45:44>>>cash write=0C
2024-10-05 09:45:44>>>cash read=3E
流量卡还有329天过期
2024-10-05 09:45:52 >>>当前Ram内存为606.95703125


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


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


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


===10:02:42===
2024-10-05 10:01:56 >>>回调事件[910,devices/TL3586]
2024-10-05 10:01:56 >>>故障排除日志:上一MQTT订单号缓存列表为24100509595392532865
2024-10-05 10:01:56 >>>故障排除日志:终端未同步成功订单列表
2024-10-05 10:01:56 开始打印,排队:3,票券:2410051001509958501501,订单:24100510015099580369,[2024-10-05 10:01:56微信支付10元]
2024-10-05 10:01:58 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410051001509958501501","queue_number":3,"trade_uid":"24100510015099580369"}]}
2024-10-05 10:01:58 >>>故障排除日志:删除未同步下发订单成功24100510015099580369
2024-10-05 10:01:58 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-05 10:02:37>>>cash read=29
2024-10-05 10:02:37 >>>回调事件130,cash_status,20029,退钞中
2024-10-05 10:02:38>>>cash read=00
2024-10-05 10:02:38>>>cash read=818F41
2024-10-05 10:02:38>>>cash write=02
2024-10-05 10:02:39 >>>回调事件130,cash_status,10022,进钞中...read money=5
2024-10-05 10:02:39>>>cash read=10
2024-10-05 10:02:39 >>>回调事件130,5,10023,finish Money=5,进钞完成
2024-10-05 10:02:40>>>cash read=2F29


===10:03:42===
2024-10-05 10:02:41>>>cash write=0C
2024-10-05 10:02:41>>>cash read=3E
2024-10-05 10:02:42>>>cash read=2F29
2024-10-05 10:02:43>>>cash read=01
2024-10-05 10:02:43>>>cash read=2F
2024-10-05 10:02:45>>>cash read=00
2024-10-05 10:02:46>>>cash read=818F41
2024-10-05 10:02:46>>>cash write=02
2024-10-05 10:02:46 >>>回调事件130,cash_status,10022,进钞中...read money=5
2024-10-05 10:02:46>>>cash read=10
2024-10-05 10:02:46 >>>回调事件130,5,10023,finish Money=5,进钞完成
2024-10-05 10:02:46 当前产品价格10元，投币10元，打印小票中...
2024-10-05 10:02:46 >>>开始打印,排队号为4,订单号为2410051002390035866819
2024-10-05 10:02:47>>>订单2410051002390035866819写入成功,剩余空间为1679500,占用RAM为604.6220703125
删除未同步订单2410051002390035866819
2024-10-05 10:02:49>>>订单2410051002390035866819删除成功,剩余空间为1680500,占用RAM为618.580078125
检测订单目录中>>>
无未同步订单>>>
2024-10-05 10:02:49 >>>当前Ram内存为589.9560546875
定时检测未同步订单启用
2024-10-05 10:02:50>>>cash write=0C
2024-10-05 10:02:50>>>cash read=3E


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


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


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


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


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


===10:29:44===
2024-10-05 10:28:52 >>>回调事件[910,devices/TL3586]
2024-10-05 10:28:52 >>>故障排除日志:上一MQTT订单号缓存列表为24100510135439526386|24100510135439526386
2024-10-05 10:28:52 >>>故障排除日志:终端未同步成功订单列表
2024-10-05 10:28:52 开始打印,排队:9,票券:2410051028369583538101,订单:24100510283695830786,[2024-10-05 10:28:52微信支付10元]
2024-10-05 10:28:54 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410051028369583538101","queue_number":9,"trade_uid":"24100510283695830786"}]}
2024-10-05 10:28:54 >>>故障排除日志:删除未同步下发订单成功24100510283695830786
2024-10-05 10:28:54 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-05 10:29:06 >>>回调事件[910,devices/TL3586]
2024-10-05 10:29:06 >>>故障排除日志:上一MQTT订单号缓存列表为24100510283695830786
2024-10-05 10:29:06 >>>故障排除日志:终端未同步成功订单列表
2024-10-05 10:29:06 开始打印,排队:10,票券:2410051028429703313901,订单:24100510284297025298,[2024-10-05 10:29:06微信支付10元]
2024-10-05 10:29:08 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410051028429703313901","queue_number":10,"trade_uid":"24100510284297025298"}]}
2024-10-05 10:29:08 >>>故障排除日志:删除未同步下发订单成功24100510284297025298
2024-10-05 10:29:08 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


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


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


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


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


===11:00:47===
2024-10-05 11:00:26 >>>回调事件[910,devices/TL3586]
2024-10-05 11:00:26 >>>故障排除日志:上一MQTT订单号缓存列表为24100510554498191223
2024-10-05 11:00:26 >>>故障排除日志:终端未同步成功订单列表
2024-10-05 11:00:26 开始打印,排队:17,票券:2410051100172767609401,订单:24100511001727671865,[2024-10-05 11:00:25微信支付10元]
2024-10-05 11:00:28 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410051100172767609401","queue_number":17,"trade_uid":"24100511001727671865"}]}
2024-10-05 11:00:28 >>>故障排除日志:删除未同步下发订单成功24100511001727671865
2024-10-05 11:00:28 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单关闭
检测订单目录中>>>
无未同步订单>>>


===11:04:47===
2024-10-05 11:04:18>>>cash read=0A
2024-10-05 11:04:19>>>cash read=3E


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


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


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


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


===11:18:48===
2024-10-05 11:18:23 >>>回调事件[910,devices/TL3586]
2024-10-05 11:18:23 >>>故障排除日志:上一MQTT订单号缓存列表为24100511165207523838
2024-10-05 11:18:23 >>>故障排除日志:终端未同步成功订单列表
2024-10-05 11:18:23 开始打印,排队:22,票券:2410051118134212008501,订单:24100511181342116625,[2024-10-05 11:18:22微信支付10元]
2024-10-05 11:18:25 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410051118134212008501","queue_number":22,"trade_uid":"24100511181342116625"}]}
2024-10-05 11:18:25 >>>故障排除日志:删除未同步下发订单成功24100511181342116625
2024-10-05 11:18:25 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单关闭
检测订单目录中>>>
无未同步订单>>>


===11:19:48===
2024-10-05 11:19:01>>>cash read=00
2024-10-05 11:19:03>>>cash read=00818F42
2024-10-05 11:19:03>>>cash write=02
2024-10-05 11:19:03 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-05 11:19:03>>>cash read=10
2024-10-05 11:19:03 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-05 11:19:03 当前产品价格10元，投币10元，打印小票中...
2024-10-05 11:19:03 >>>开始打印,排队号为23,订单号为2410051119030035865693
2024-10-05 11:19:03>>>订单2410051119030035865693写入成功,剩余空间为1680000,占用RAM为606.6044921875
删除未同步订单2410051119030035865693
2024-10-05 11:19:05>>>订单2410051119030035865693删除成功,剩余空间为1680500,占用RAM为617.318359375
检测订单目录中>>>
无未同步订单>>>
2024-10-05 11:19:06 >>>当前Ram内存为589.17578125
定时检测未同步订单启用
2024-10-05 11:19:06>>>cash write=0C
2024-10-05 11:19:06>>>cash read=3E
2024-10-05 11:19:26 >>>回调事件[910,devices/TL3586]
2024-10-05 11:19:26 >>>故障排除日志:上一MQTT订单号缓存列表为24100511181342116625
2024-10-05 11:19:26 >>>故障排除日志:终端未同步成功订单列表
2024-10-05 11:19:26 开始打印,排队:24,票券:2410051119192823996401,订单:24100511191928235864,[2024-10-05 11:19:26微信支付10元]
2024-10-05 11:19:28 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410051119192823996401","queue_number":24,"trade_uid":"24100511191928235864"}]}
2024-10-05 11:19:28 >>>故障排除日志:删除未同步下发订单成功24100511191928235864
2024-10-05 11:19:28 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


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


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


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


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


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


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


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


===12:00:52===
2024-10-05 11:59:59 >>>回调事件[910,devices/TL3586]
2024-10-05 11:59:59 >>>故障排除日志:上一MQTT订单号缓存列表为24100511545864517463
2024-10-05 12:00:00 >>>故障排除日志:终端未同步成功订单列表
2024-10-05 12:00:00 开始打印,排队:33,票券:2410051159372740372701,订单:24100511593727399874,[2024-10-05 12:00:00微信支付10元]
2024-10-05 12:00:01 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410051159372740372701","queue_number":33,"trade_uid":"24100511593727399874"}]}
2024-10-05 12:00:01 >>>故障排除日志:删除未同步下发订单成功24100511593727399874
2024-10-05 12:00:01 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-05 12:00:24 >>>回调事件[910,devices/TL3586]
2024-10-05 12:00:24 >>>故障排除日志:上一MQTT订单号缓存列表为24100511593727399874
2024-10-05 12:00:24 >>>故障排除日志:终端未同步成功订单列表
2024-10-05 12:00:24 开始打印,排队:34,票券:2410051200139290457301,订单:24100512001392900381,[2024-10-05 12:00:24微信支付10元]
2024-10-05 12:00:26 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410051200139290457301","queue_number":34,"trade_uid":"24100512001392900381"}]}
2024-10-05 12:00:26 >>>故障排除日志:删除未同步下发订单成功24100512001392900381
2024-10-05 12:00:26 >>>故障排除日志:终端同步成功后剩余订单列表


===12:02:53===
2024-10-05 12:02:50 >>>回调事件[910,devices/TL3586]
2024-10-05 12:02:50 >>>故障排除日志:上一MQTT订单号缓存列表为24100512001392900381
2024-10-05 12:02:50 >>>故障排除日志:终端未同步成功订单列表
2024-10-05 12:02:50 开始打印,排队:35,票券:2410051202357282824801,订单:24100512023572822615,[2024-10-05 12:02:49微信支付10元]


===12:03:54===
2024-10-05 12:02:52 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410051202357282824801","queue_number":35,"trade_uid":"24100512023572822615"}]}
2024-10-05 12:02:52 >>>故障排除日志:删除未同步下发订单成功24100512023572822615
2024-10-05 12:02:52 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


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


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


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


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


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


===12:39:56===
2024-10-05 12:39:16>>>cash read=00
2024-10-05 12:39:17>>>cash read=818F42
2024-10-05 12:39:17>>>cash write=02
2024-10-05 12:39:17 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-05 12:39:18>>>cash read=10
2024-10-05 12:39:18 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-05 12:39:18 当前产品价格10元，投币10元，打印小票中...
2024-10-05 12:39:18 >>>开始打印,排队号为44,订单号为2410051239180035862475
2024-10-05 12:39:18>>>订单2410051239180035862475写入成功,剩余空间为1680000,占用RAM为607.599609375
删除未同步订单2410051239180035862475
2024-10-05 12:39:20>>>订单2410051239180035862475删除成功,剩余空间为1680500,占用RAM为619.736328125
检测订单目录中>>>
无未同步订单>>>
2024-10-05 12:39:20 >>>当前Ram内存为590.3115234375
定时检测未同步订单启用
2024-10-05 12:39:21>>>cash write=0C
2024-10-05 12:39:21>>>cash read=3E
2024-10-05 12:39:45>>>cash read=00
2024-10-05 12:39:46>>>cash read=818F42
2024-10-05 12:39:46>>>cash write=02
2024-10-05 12:39:46 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-05 12:39:46>>>cash read=10
2024-10-05 12:39:46 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-05 12:39:46 当前产品价格10元，投币10元，打印小票中...
2024-10-05 12:39:46 >>>开始打印,排队号为45,订单号为2410051239460035867532
定时检测未同步订单关闭
2024-10-05 12:39:47>>>订单2410051239460035867532写入成功,剩余空间为1679000,占用RAM为612.396484375
删除未同步订单2410051239460035867532
2024-10-05 12:39:49>>>订单2410051239460035867532删除成功,剩余空间为1679500,占用RAM为622.7421875
检测订单目录中>>>
无未同步订单>>>
2024-10-05 12:39:49 >>>当前Ram内存为591.2275390625
定时检测未同步订单启用
2024-10-05 12:39:50>>>cash write=0C
2024-10-05 12:39:50>>>cash read=3E


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


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


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


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


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


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


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


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


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


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


===13:14:00===
2024-10-05 13:12:58 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410051312500732742101","queue_number":56,"trade_uid":"24100513125007322753"}]}
2024-10-05 13:12:58 >>>故障排除日志:删除未同步下发订单成功24100513125007322753
2024-10-05 13:12:59 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


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


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


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


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


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


===13:46:03===
2024-10-05 13:45:04 >>>回调事件[910,devices/TL3586]
2024-10-05 13:45:04 >>>故障排除日志:上一MQTT订单号缓存列表为24100513414370000136
2024-10-05 13:45:04 >>>故障排除日志:终端未同步成功订单列表
2024-10-05 13:45:04 开始打印,排队:66,票券:2410051344516135758301,订单:24100513445161351671,[2024-10-05 13:45:04微信支付10元]
2024-10-05 13:45:06 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410051344516135758301","queue_number":66,"trade_uid":"24100513445161351671"}]}
2024-10-05 13:45:06 >>>故障排除日志:删除未同步下发订单成功24100513445161351671
2024-10-05 13:45:06 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-05 13:45:46 >>>回调事件[910,devices/TL3586]
2024-10-05 13:45:46 >>>故障排除日志:上一MQTT订单号缓存列表为24100513445161351671
2024-10-05 13:45:46 >>>故障排除日志:终端未同步成功订单列表
2024-10-05 13:45:46 开始打印,排队:67,票券:2410051345399688295701,订单:24100513453996879131,[2024-10-05 13:45:46微信支付10元]
2024-10-05 13:45:49 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410051345399688295701","queue_number":67,"trade_uid":"24100513453996879131"}]}
2024-10-05 13:45:49 >>>故障排除日志:删除未同步下发订单成功24100513453996879131
2024-10-05 13:45:49 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


===13:58:04===
2024-10-05 13:57:31 >>>回调事件[910,devices/TL3586]
2024-10-05 13:57:31 >>>故障排除日志:上一MQTT订单号缓存列表为24100513453996879131
2024-10-05 13:57:31 >>>故障排除日志:终端未同步成功订单列表
2024-10-05 13:57:31 开始打印,排队:69,票券:2410051357240656769101,订单:24100513572406562826,[2024-10-05 13:57:31支付宝支付10元]
2024-10-05 13:57:33 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410051357240656769101","queue_number":69,"trade_uid":"24100513572406562826"}]}
2024-10-05 13:57:33 >>>故障排除日志:删除未同步下发订单成功24100513572406562826
2024-10-05 13:57:34 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


===15:11:12===
2024-10-05 15:11:04>>>cash read=00
2024-10-05 15:11:05>>>cash read=818F41
2024-10-05 15:11:05>>>cash write=02
2024-10-05 15:11:05 >>>回调事件130,cash_status,10022,进钞中...read money=5
2024-10-05 15:11:05>>>cash read=10
2024-10-05 15:11:05 >>>回调事件130,5,10023,finish Money=5,进钞完成
2024-10-05 15:11:06>>>cash write=0C
2024-10-05 15:11:06>>>cash read=3E
2024-10-05 15:11:07>>>cash read=00
2024-10-05 15:11:08>>>cash read=818F41
2024-10-05 15:11:08>>>cash write=02
2024-10-05 15:11:08 >>>回调事件130,cash_status,10022,进钞中...read money=5
2024-10-05 15:11:08>>>cash read=10
2024-10-05 15:11:08 >>>回调事件130,5,10023,finish Money=5,进钞完成
2024-10-05 15:11:08 当前产品价格10元，投币10元，打印小票中...
2024-10-05 15:11:08 >>>开始打印,排队号为90,订单号为2410051511050035868436
2024-10-05 15:11:09>>>订单2410051511050035868436写入成功,剩余空间为1679500,占用RAM为605.7294921875


===15:12:12===
删除未同步订单2410051511050035868436
2024-10-05 15:11:11>>>订单2410051511050035868436删除成功,剩余空间为1681500,占用RAM为622.1376953125
检测订单目录中>>>
无未同步订单>>>
2024-10-05 15:11:11 >>>当前Ram内存为588.07421875
定时检测未同步订单启用
2024-10-05 15:11:12>>>cash write=0C
2024-10-05 15:11:12>>>cash read=3E
定时检测未同步订单关闭
检测订单目录中>>>
无未同步订单>>>


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


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


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


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


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


===15:24:14===
2024-10-05 15:23:46>>>cash read=00
2024-10-05 15:23:47>>>cash read=01
2024-10-05 15:23:48>>>cash read=29
2024-10-05 15:23:48 >>>回调事件130,cash_status,20029,退钞中
2024-10-05 15:23:49>>>cash read=3E
2024-10-05 15:23:50>>>cash read=00
2024-10-05 15:23:51>>>cash read=818F42
2024-10-05 15:23:51>>>cash write=02
2024-10-05 15:23:51 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-05 15:23:51>>>cash read=10
2024-10-05 15:23:51 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-05 15:23:51 当前产品价格10元，投币10元，打印小票中...
2024-10-05 15:23:51 >>>开始打印,排队号为95,订单号为2410051523510035861993
2024-10-05 15:23:52>>>订单2410051523510035861993写入成功,剩余空间为1679500,占用RAM为607.2041015625
删除未同步订单2410051523510035861993
2024-10-05 15:23:54>>>订单2410051523510035861993删除成功,剩余空间为1680500,占用RAM为617.1025390625
检测订单目录中>>>
无未同步订单>>>
2024-10-05 15:23:54 >>>当前Ram内存为588.873046875
定时检测未同步订单启用
2024-10-05 15:23:55>>>cash write=0C
2024-10-05 15:23:55>>>cash read=3E
2024-10-05 15:23:56 >>>回调事件[910,devices/TL3586]
2024-10-05 15:23:56 >>>故障排除日志:上一MQTT订单号缓存列表为24100515193330489327
2024-10-05 15:23:56 >>>故障排除日志:终端未同步成功订单列表
2024-10-05 15:23:56 开始打印,排队:96,票券:2410051523440151883401,订单:24100515234401514742,[2024-10-05 15:23:56微信支付10元]
2024-10-05 15:23:58 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410051523440151883401","queue_number":96,"trade_uid":"24100515234401514742"}]}
2024-10-05 15:23:58 >>>故障排除日志:删除未同步下发订单成功24100515234401514742
2024-10-05 15:23:58 >>>故障排除日志:终端同步成功后剩余订单列表


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


===15:32:15===
2024-10-05 15:31:45 >>>回调事件[910,devices/TL3586]
2024-10-05 15:31:45 >>>故障排除日志:上一MQTT订单号缓存列表为24100515234401514742
2024-10-05 15:31:45 >>>故障排除日志:终端未同步成功订单列表
2024-10-05 15:31:45 开始打印,排队:97,票券:2410051531386397818101,订单:24100515313863971039,[2024-10-05 15:31:45微信支付10元]
2024-10-05 15:31:47 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410051531386397818101","queue_number":97,"trade_uid":"24100515313863971039"}]}
2024-10-05 15:31:47 >>>故障排除日志:删除未同步下发订单成功24100515313863971039
2024-10-05 15:31:47 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-05 15:31:52 >>>回调事件[910,devices/TL3586]
2024-10-05 15:31:52 >>>故障排除日志:上一MQTT订单号缓存列表为24100515313863971039
2024-10-05 15:31:52 >>>故障排除日志:终端未同步成功订单列表
2024-10-05 15:31:52 开始打印,排队:98,票券:2410051531457700745201,订单:24100515314577001926,[2024-10-05 15:31:52微信支付10元]
2024-10-05 15:31:54 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410051531457700745201","queue_number":98,"trade_uid":"24100515314577001926"}]}
2024-10-05 15:31:54 >>>故障排除日志:删除未同步下发订单成功24100515314577001926
2024-10-05 15:31:54 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


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


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


===16:00:17===
2024-10-05 15:59:31 >>>回调事件[910,devices/TL3586]
2024-10-05 15:59:31 >>>故障排除日志:上一MQTT订单号缓存列表为24100515551105597651
2024-10-05 15:59:31 >>>故障排除日志:终端未同步成功订单列表
2024-10-05 15:59:31 开始打印,排队:105,票券:2410051559239463664301,订单:24100515592394628473,[2024-10-05 15:59:30微信支付10元]
2024-10-05 15:59:33 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410051559239463664301","queue_number":105,"trade_uid":"24100515592394628473"}]}
2024-10-05 15:59:33 >>>故障排除日志:删除未同步下发订单成功24100515592394628473
2024-10-05 15:59:33 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单关闭
检测订单目录中>>>
无未同步订单>>>


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


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


===16:09:18===
2024-10-05 16:08:39>>>cash read=00
2024-10-05 16:08:40>>>cash read=00818F42
2024-10-05 16:08:40>>>cash write=02
2024-10-05 16:08:40 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-05 16:08:41>>>cash read=10
2024-10-05 16:08:41 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-05 16:08:41 当前产品价格10元，投币10元，打印小票中...
2024-10-05 16:08:41 >>>开始打印,排队号为108,订单号为2410051608410035862987
2024-10-05 16:08:41>>>订单2410051608410035862987写入成功,剩余空间为1680000,占用RAM为605.4677734375
删除未同步订单2410051608410035862987
2024-10-05 16:08:43>>>订单2410051608410035862987删除成功,剩余空间为1680500,占用RAM为617.744140625
检测订单目录中>>>
无未同步订单>>>
2024-10-05 16:08:43 >>>当前Ram内存为588.1025390625
定时检测未同步订单启用
2024-10-05 16:08:44>>>cash write=0C
2024-10-05 16:08:44>>>cash read=3E


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


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


===16:15:19===
2024-10-05 16:14:24 >>>回调事件[910,devices/TL3586]
2024-10-05 16:14:24 >>>故障排除日志:上一MQTT订单号缓存列表为24100516125837086843
2024-10-05 16:14:24 >>>故障排除日志:终端未同步成功订单列表
2024-10-05 16:14:24 开始打印,排队:111,票券:2410051614176070763501,订单:24100516141760703196,[2024-10-05 16:14:24微信支付10元]
2024-10-05 16:14:26 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410051614176070763501","queue_number":111,"trade_uid":"24100516141760703196"}]}
2024-10-05 16:14:26 >>>故障排除日志:删除未同步下发订单成功24100516141760703196
2024-10-05 16:14:26 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-05 16:14:58 >>>回调事件[910,devices/TL3586]
2024-10-05 16:14:58 >>>故障排除日志:上一MQTT订单号缓存列表为24100516141760703196
2024-10-05 16:14:58 >>>故障排除日志:终端未同步成功订单列表
2024-10-05 16:14:58 开始打印,排队:112,票券:2410051614490924264901,订单:24100516144909236927,[2024-10-05 16:14:58微信支付10元]
2024-10-05 16:15:00 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410051614490924264901","queue_number":112,"trade_uid":"24100516144909236927"}]}
2024-10-05 16:15:00 >>>故障排除日志:删除未同步下发订单成功24100516144909236927
2024-10-05 16:15:00 >>>故障排除日志:终端同步成功后剩余订单列表


===16:23:19===
2024-10-05 16:22:29 >>>回调事件[910,devices/TL3586]
2024-10-05 16:22:29 >>>故障排除日志:上一MQTT订单号缓存列表为24100516144909236927
2024-10-05 16:22:29 >>>故障排除日志:终端未同步成功订单列表
2024-10-05 16:22:29 开始打印,排队:113,票券:2410051622232316348601,订单:24100516222323159245,[2024-10-05 16:22:29微信支付10元]
2024-10-05 16:22:31 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410051622232316348601","queue_number":113,"trade_uid":"24100516222323159245"}]}
2024-10-05 16:22:31 >>>故障排除日志:删除未同步下发订单成功24100516222323159245
2024-10-05 16:22:31 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-05 16:23:11 >>>回调事件[910,devices/TL3586]
2024-10-05 16:23:12 >>>故障排除日志:上一MQTT订单号缓存列表为24100516222323159245
2024-10-05 16:23:12 >>>故障排除日志:终端未同步成功订单列表
2024-10-05 16:23:12 开始打印,排队:114,票券:2410051623027563152901,订单:24100516230275625437,[2024-10-05 16:23:12微信支付10元]
2024-10-05 16:23:14 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410051623027563152901","queue_number":114,"trade_uid":"24100516230275625437"}]}
2024-10-05 16:23:14 >>>故障排除日志:删除未同步下发订单成功24100516230275625437
2024-10-05 16:23:14 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


===16:31:20===
2024-10-05 16:30:38 >>>回调事件[910,devices/TL3586]
2024-10-05 16:30:38 >>>故障排除日志:上一MQTT订单号缓存列表为24100516293825156935
2024-10-05 16:30:38 >>>故障排除日志:终端未同步成功订单列表
2024-10-05 16:30:38 开始打印,排队:117,票券:2410051630301351792901,订单:24100516303013513857,[2024-10-05 16:30:38微信支付10元]
2024-10-05 16:30:38 开始打印,排队:118,票券:2410051630301351948902,订单:24100516303013513857,[2024-10-05 16:30:38微信支付10元]
2024-10-05 16:30:38 开始打印,排队:119,票券:2410051630301352016903,订单:24100516303013513857,[2024-10-05 16:30:38微信支付10元]
2024-10-05 16:30:43 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410051630301351792901","queue_number":117,"trade_uid":"24100516303013513857"},{"ticket_no":"2410051630301351948902","queue_number":118,"trade_uid":"24100516303013513857"},{"ticket_no":"2410051630301352016903","queue_number":119,"trade_uid":"24100516303013513857"}]}
2024-10-05 16:30:43 >>>故障排除日志:删除未同步下发订单成功24100516303013513857
2024-10-05 16:30:43 >>>故障排除日志:删除未同步下发订单成功24100516303013513857
2024-10-05 16:30:43 >>>故障排除日志:删除未同步下发订单成功24100516303013513857
2024-10-05 16:30:43 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-05 16:31:06 >>>回调事件[910,devices/TL3586]
2024-10-05 16:31:06 >>>故障排除日志:上一MQTT订单号缓存列表为24100516303013513857|24100516303013513857|24100516303013513857
2024-10-05 16:31:06 >>>故障排除日志:终端未同步成功订单列表
2024-10-05 16:31:06 开始打印,排队:120,票券:2410051630590372227201,订单:24100516305903716329,[2024-10-05 16:31:06微信支付10元]
2024-10-05 16:31:08 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410051630590372227201","queue_number":120,"trade_uid":"24100516305903716329"}]}
2024-10-05 16:31:08 >>>故障排除日志:删除未同步下发订单成功24100516305903716329
2024-10-05 16:31:08 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


===16:53:21===
2024-10-05 16:52:31 >>>回调事件[910,devices/TL3586]
2024-10-05 16:52:31 >>>故障排除日志:上一MQTT订单号缓存列表为24100516462753420584
2024-10-05 16:52:31 >>>故障排除日志:终端未同步成功订单列表
2024-10-05 16:52:31 开始打印,排队:124,票券:2410051652255808668201,订单:24100516522558081928,[2024-10-05 16:52:31微信支付10元]
2024-10-05 16:52:31 开始打印,排队:125,票券:2410051652255808822802,订单:24100516522558081928,[2024-10-05 16:52:31微信支付10元]
2024-10-05 16:52:34 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410051652255808668201","queue_number":124,"trade_uid":"24100516522558081928"},{"ticket_no":"2410051652255808822802","queue_number":125,"trade_uid":"24100516522558081928"}]}
2024-10-05 16:52:35 >>>故障排除日志:删除未同步下发订单成功24100516522558081928
2024-10-05 16:52:35 >>>故障排除日志:删除未同步下发订单成功24100516522558081928
2024-10-05 16:52:35 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


===17:23:22===
2024-10-05 17:22:54 收到下发指令:叫号2>>>


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


===17:40:23===
2024-10-05 17:39:33 >>>回调事件[910,devices/TL3586]
2024-10-05 17:39:34 >>>故障排除日志:上一MQTT订单号缓存列表为24100517322185638926
2024-10-05 17:39:34 >>>故障排除日志:终端未同步成功订单列表
2024-10-05 17:39:34 开始打印,排队:130,票券:2410051739252275341401,订单:24100517392522749573,[2024-10-05 17:39:34微信支付10元]
2024-10-05 17:39:34 开始打印,排队:131,票券:2410051739252275488502,订单:24100517392522749573,[2024-10-05 17:39:34微信支付10元]
2024-10-05 17:39:37 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410051739252275341401","queue_number":130,"trade_uid":"24100517392522749573"},{"ticket_no":"2410051739252275488502","queue_number":131,"trade_uid":"24100517392522749573"}]}
2024-10-05 17:39:37 >>>故障排除日志:删除未同步下发订单成功24100517392522749573
2024-10-05 17:39:37 >>>故障排除日志:删除未同步下发订单成功24100517392522749573
2024-10-05 17:39:37 >>>故障排除日志:终端同步成功后剩余订单列表


===17:44:24===
2024-10-05 17:43:30>>>cash read=29
2024-10-05 17:43:30 >>>回调事件130,cash_status,20029,退钞中
2024-10-05 17:43:30>>>cash read=2F29
2024-10-05 17:43:32>>>cash read=3E
2024-10-05 17:43:34>>>cash read=00
2024-10-05 17:43:35>>>cash read=818F42
2024-10-05 17:43:35>>>cash write=02
2024-10-05 17:43:35 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-05 17:43:35>>>cash read=10
2024-10-05 17:43:35 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-05 17:43:35 当前产品价格10元，投币10元，打印小票中...
2024-10-05 17:43:35 >>>开始打印,排队号为132,订单号为2410051743350035862781
2024-10-05 17:43:35>>>订单2410051743350035862781写入成功,剩余空间为1679500,占用RAM为608.056640625
删除未同步订单2410051743350035862781
2024-10-05 17:43:37>>>订单2410051743350035862781删除成功,剩余空间为1680500,占用RAM为619.134765625
检测订单目录中>>>
无未同步订单>>>
2024-10-05 17:43:38 >>>当前Ram内存为589.7431640625
定时检测未同步订单启用
2024-10-05 17:43:38>>>cash write=0C
2024-10-05 17:43:38>>>cash read=3E


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


===17:46:24===
2024-10-05 17:45:26 >>>回调事件[910,devices/TL3586]
2024-10-05 17:45:26 >>>故障排除日志:上一MQTT订单号缓存列表为24100517392522749573|24100517392522749573
2024-10-05 17:45:26 >>>故障排除日志:终端未同步成功订单列表
2024-10-05 17:45:26 开始打印,排队:133,票券:2410051745182562181601,订单:24100517451825618024,[2024-10-05 17:45:27微信支付10元]
2024-10-05 17:45:28 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410051745182562181601","queue_number":133,"trade_uid":"24100517451825618024"}]}
2024-10-05 17:45:29 >>>故障排除日志:删除未同步下发订单成功24100517451825618024
2024-10-05 17:45:29 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


===17:56:25===
2024-10-05 17:56:13 >>>回调事件[910,devices/TL3586]
2024-10-05 17:56:13 >>>故障排除日志:上一MQTT订单号缓存列表为24100517501258552783
2024-10-05 17:56:13 >>>故障排除日志:终端未同步成功订单列表
2024-10-05 17:56:13 开始打印,排队:137,票券:2410051756074665228401,订单:24100517560746647228,[2024-10-05 17:56:13微信支付10元]
2024-10-05 17:56:15 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410051756074665228401","queue_number":137,"trade_uid":"24100517560746647228"}]}
2024-10-05 17:56:15 >>>故障排除日志:删除未同步下发订单成功24100517560746647228
2024-10-05 17:56:15 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-05 17:56:22 >>>回调事件[910,devices/TL3586]
2024-10-05 17:56:22 >>>故障排除日志:上一MQTT订单号缓存列表为24100517560746647228
2024-10-05 17:56:22 >>>故障排除日志:终端未同步成功订单列表
2024-10-05 17:56:22 开始打印,排队:138,票券:2410051756151123548701,订单:24100517561511230938,[2024-10-05 17:56:22微信支付10元]
2024-10-05 17:56:24 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410051756151123548701","queue_number":138,"trade_uid":"24100517561511230938"}]}
2024-10-05 17:56:24 >>>故障排除日志:删除未同步下发订单成功24100517561511230938
2024-10-05 17:56:24 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


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


===18:27:27===
2024-10-05 18:26:34 >>>回调事件[910,devices/TL3586]
2024-10-05 18:26:34 >>>故障排除日志:上一MQTT订单号缓存列表为24100518211997705973
2024-10-05 18:26:34 >>>故障排除日志:终端未同步成功订单列表
2024-10-05 18:26:34 开始打印,排队:145,票券:2410051826260992529501,订单:24100518262609919196,[2024-10-05 18:26:34微信支付10元]
2024-10-05 18:26:34 开始打印,排队:146,票券:2410051826260992721302,订单:24100518262609919196,[2024-10-05 18:26:34微信支付10元]
2024-10-05 18:26:37 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410051826260992529501","queue_number":145,"trade_uid":"24100518262609919196"},{"ticket_no":"2410051826260992721302","queue_number":146,"trade_uid":"24100518262609919196"}]}
2024-10-05 18:26:37 >>>故障排除日志:删除未同步下发订单成功24100518262609919196
2024-10-05 18:26:37 >>>故障排除日志:删除未同步下发订单成功24100518262609919196
2024-10-05 18:26:38 >>>故障排除日志:终端同步成功后剩余订单列表


===18:28:28===
2024-10-05 18:28:01 >>>回调事件[910,devices/TL3586]
2024-10-05 18:28:01 >>>故障排除日志:上一MQTT订单号缓存列表为24100518262609919196|24100518262609919196
2024-10-05 18:28:01 >>>故障排除日志:终端未同步成功订单列表
2024-10-05 18:28:01 开始打印,排队:147,票券:2410051827553309569601,订单:24100518275533092171,[2024-10-05 18:28:00微信支付10元]
2024-10-05 18:28:03 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410051827553309569601","queue_number":147,"trade_uid":"24100518275533092171"}]}
2024-10-05 18:28:03 >>>故障排除日志:删除未同步下发订单成功24100518275533092171
2024-10-05 18:28:03 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-05 18:28:09 >>>回调事件[910,devices/TL3586]
2024-10-05 18:28:09 >>>故障排除日志:上一MQTT订单号缓存列表为24100518275533092171
2024-10-05 18:28:09 >>>故障排除日志:终端未同步成功订单列表
2024-10-05 18:28:09 开始打印,排队:148,票券:2410051828024651938201,订单:24100518280246514574,[2024-10-05 18:28:09微信支付10元]
2024-10-05 18:28:11 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410051828024651938201","queue_number":148,"trade_uid":"24100518280246514574"}]}
2024-10-05 18:28:11 >>>故障排除日志:删除未同步下发订单成功24100518280246514574
2024-10-05 18:28:11 >>>故障排除日志:终端同步成功后剩余订单列表


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


===18:48:28===
2024-10-05 18:47:46 >>>回调事件[910,devices/TL3586]
2024-10-05 18:47:46 >>>故障排除日志:上一MQTT订单号缓存列表为24100518471238986018
2024-10-05 18:47:46 >>>故障排除日志:终端未同步成功订单列表
2024-10-05 18:47:46 开始打印,排队:150,票券:2410051847311711475601,订单:24100518473117110534,[2024-10-05 18:47:46微信支付10元]
2024-10-05 18:47:46 开始打印,排队:151,票券:2410051847311711628502,订单:24100518473117110534,[2024-10-05 18:47:46微信支付10元]
2024-10-05 18:47:50 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410051847311711475601","queue_number":150,"trade_uid":"24100518473117110534"},{"ticket_no":"2410051847311711628502","queue_number":151,"trade_uid":"24100518473117110534"}]}
2024-10-05 18:47:50 >>>故障排除日志:删除未同步下发订单成功24100518473117110534
2024-10-05 18:47:50 >>>故障排除日志:删除未同步下发订单成功24100518473117110534
2024-10-05 18:47:50 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


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


===19:04:31===
2024-10-05 19:03:58 >>>回调事件[910,devices/TL3586]
2024-10-05 19:03:58 >>>故障排除日志:上一MQTT订单号缓存列表为24100519001577233684
2024-10-05 19:03:58 >>>故障排除日志:终端未同步成功订单列表
2024-10-05 19:03:58 开始打印,排队:156,票券:2410051903538739433901,订单:24100519035387389391,[2024-10-05 19:03:58微信支付10元]
2024-10-05 19:03:58 开始打印,排队:157,票券:2410051903538739625402,订单:24100519035387389391,[2024-10-05 19:03:58微信支付10元]
2024-10-05 19:04:02 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410051903538739433901","queue_number":156,"trade_uid":"24100519035387389391"},{"ticket_no":"2410051903538739625402","queue_number":157,"trade_uid":"24100519035387389391"}]}
2024-10-05 19:04:02 >>>故障排除日志:删除未同步下发订单成功24100519035387389391
2024-10-05 19:04:02 >>>故障排除日志:删除未同步下发订单成功24100519035387389391
2024-10-05 19:04:02 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-05 19:04:27 >>>回调事件[910,devices/TL3586]
2024-10-05 19:04:27 >>>故障排除日志:上一MQTT订单号缓存列表为24100519035387389391|24100519035387389391
2024-10-05 19:04:27 >>>故障排除日志:终端未同步成功订单列表
2024-10-05 19:04:27 开始打印,排队:158,票券:2410051904205926872501,订单:24100519042059265027,[2024-10-05 19:04:27微信支付10元]


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


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


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


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


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


===19:19:33===
2024-10-05 19:18:37 >>>回调事件[910,devices/TL3586]
2024-10-05 19:18:37 >>>故障排除日志:上一MQTT订单号缓存列表为24100519172922181148
2024-10-05 19:18:37 >>>故障排除日志:终端未同步成功订单列表
2024-10-05 19:18:37 开始打印,排队:163,票券:2410051918319741231301,订单:24100519183197408783,[2024-10-05 19:18:37微信支付10元]
2024-10-05 19:18:39 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410051918319741231301","queue_number":163,"trade_uid":"24100519183197408783"}]}
2024-10-05 19:18:39 >>>故障排除日志:删除未同步下发订单成功24100519183197408783
2024-10-05 19:18:39 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-05 19:18:53 >>>回调事件[910,devices/TL3586]
2024-10-05 19:18:53 >>>故障排除日志:上一MQTT订单号缓存列表为24100519183197408783
2024-10-05 19:18:53 >>>故障排除日志:终端未同步成功订单列表
2024-10-05 19:18:53 开始打印,排队:164,票券:2410051918470748819701,订单:24100519184707482625,[2024-10-05 19:18:53微信支付10元]
2024-10-05 19:18:55 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410051918470748819701","queue_number":164,"trade_uid":"24100519184707482625"}]}
2024-10-05 19:18:55 >>>故障排除日志:删除未同步下发订单成功24100519184707482625
2024-10-05 19:18:55 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


===19:35:34===
2024-10-05 19:34:40 >>>回调事件[910,devices/TL3586]
2024-10-05 19:34:40 >>>故障排除日志:上一MQTT订单号缓存列表为24100519301832300469
2024-10-05 19:34:40 >>>故障排除日志:终端未同步成功订单列表
2024-10-05 19:34:40 开始打印,排队:167,票券:2410051934337064483101,订单:24100519343370639148,[2024-10-05 19:34:40微信支付10元]
2024-10-05 19:34:40 开始打印,排队:168,票券:2410051934337064673102,订单:24100519343370639148,[2024-10-05 19:34:40微信支付10元]
2024-10-05 19:34:44 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410051934337064483101","queue_number":167,"trade_uid":"24100519343370639148"},{"ticket_no":"2410051934337064673102","queue_number":168,"trade_uid":"24100519343370639148"}]}
2024-10-05 19:34:44 >>>故障排除日志:删除未同步下发订单成功24100519343370639148
2024-10-05 19:34:44 >>>故障排除日志:删除未同步下发订单成功24100519343370639148
2024-10-05 19:34:44 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-05 19:34:51 >>>回调事件[910,devices/TL3586]
2024-10-05 19:34:51 >>>故障排除日志:上一MQTT订单号缓存列表为24100519343370639148|24100519343370639148
2024-10-05 19:34:51 >>>故障排除日志:终端未同步成功订单列表
2024-10-05 19:34:51 开始打印,排队:169,票券:2410051934423979477301,订单:24100519344239790035,[2024-10-05 19:34:51微信支付10元]
2024-10-05 19:34:53 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410051934423979477301","queue_number":169,"trade_uid":"24100519344239790035"}]}
2024-10-05 19:34:53 >>>故障排除日志:删除未同步下发订单成功24100519344239790035
2024-10-05 19:34:53 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


===19:47:35===
2024-10-05 19:47:30>>>cash read=00
2024-10-05 19:47:31>>>cash read=818F42
2024-10-05 19:47:31>>>cash write=02
2024-10-05 19:47:31 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-05 19:47:32>>>cash read=10
2024-10-05 19:47:32 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-05 19:47:32 当前产品价格10元，投币10元，打印小票中...
2024-10-05 19:47:32 >>>开始打印,排队号为172,订单号为2410051947320035867581
2024-10-05 19:47:32>>>订单2410051947320035867581写入成功,剩余空间为1680000,占用RAM为605.3955078125


===19:48:36===
删除未同步订单2410051947320035867581
2024-10-05 19:47:34>>>订单2410051947320035867581删除成功,剩余空间为1681500,占用RAM为619.4443359375
检测订单目录中>>>
无未同步订单>>>
2024-10-05 19:47:34 >>>当前Ram内存为587.4453125
定时检测未同步订单启用
2024-10-05 19:47:35>>>cash write=0C
2024-10-05 19:47:35>>>cash read=3E
定时检测未同步订单关闭
检测订单目录中>>>
无未同步订单>>>


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


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


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


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


===19:59:37===
2024-10-05 19:58:46 >>>回调事件[910,devices/TL3586]
2024-10-05 19:58:46 >>>故障排除日志:上一MQTT订单号缓存列表为24100519565938790182
2024-10-05 19:58:46 >>>故障排除日志:终端未同步成功订单列表
2024-10-05 19:58:46 开始打印,排队:176,票券:2410051958404414385901,订单:24100519584044139684,[2024-10-05 19:58:46微信支付10元]
2024-10-05 19:58:46 开始打印,排队:177,票券:2410051958404414511802,订单:24100519584044139684,[2024-10-05 19:58:46微信支付10元]
2024-10-05 19:58:50 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410051958404414385901","queue_number":176,"trade_uid":"24100519584044139684"},{"ticket_no":"2410051958404414511802","queue_number":177,"trade_uid":"24100519584044139684"}]}
2024-10-05 19:58:50 >>>故障排除日志:删除未同步下发订单成功24100519584044139684
2024-10-05 19:58:50 >>>故障排除日志:删除未同步下发订单成功24100519584044139684
2024-10-05 19:58:50 >>>故障排除日志:终端同步成功后剩余订单列表


===20:12:38===
2024-10-05 20:11:53 >>>回调事件[910,devices/TL3586]
2024-10-05 20:11:53 >>>故障排除日志:上一MQTT订单号缓存列表为24100519584044139684|24100519584044139684
2024-10-05 20:11:53 >>>故障排除日志:终端未同步成功订单列表
2024-10-05 20:11:53 开始打印,排队:178,票券:2410052011457835085701,订单:24100520114578347558,[2024-10-05 20:11:53微信支付10元]
2024-10-05 20:11:54 开始打印,排队:179,票券:2410052011457835224102,订单:24100520114578347558,[2024-10-05 20:11:53微信支付10元]
2024-10-05 20:11:57 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410052011457835085701","queue_number":178,"trade_uid":"24100520114578347558"},{"ticket_no":"2410052011457835224102","queue_number":179,"trade_uid":"24100520114578347558"}]}
2024-10-05 20:11:57 >>>故障排除日志:删除未同步下发订单成功24100520114578347558
2024-10-05 20:11:57 >>>故障排除日志:删除未同步下发订单成功24100520114578347558
2024-10-05 20:11:57 >>>故障排除日志:终端同步成功后剩余订单列表


===20:16:38===
2024-10-05 20:15:54 >>>回调事件[910,devices/TL3586]
2024-10-05 20:15:54 >>>故障排除日志:上一MQTT订单号缓存列表为24100520114578347558|24100520114578347558
2024-10-05 20:15:54 >>>故障排除日志:终端未同步成功订单列表
2024-10-05 20:15:54 开始打印,排队:180,票券:2410052015470852957101,订单:24100520154708524798,[2024-10-05 20:15:54微信支付10元]
2024-10-05 20:15:56 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410052015470852957101","queue_number":180,"trade_uid":"24100520154708524798"}]}
2024-10-05 20:15:56 >>>故障排除日志:删除未同步下发订单成功24100520154708524798
2024-10-05 20:15:56 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-05 20:16:19 >>>回调事件[910,devices/TL3586]
2024-10-05 20:16:19 >>>故障排除日志:上一MQTT订单号缓存列表为24100520154708524798
2024-10-05 20:16:19 >>>故障排除日志:终端未同步成功订单列表
2024-10-05 20:16:19 开始打印,排队:181,票券:2410052016135388062101,订单:24100520161353876894,[2024-10-05 20:16:19微信支付10元]
2024-10-05 20:16:21 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410052016135388062101","queue_number":181,"trade_uid":"24100520161353876894"}]}
2024-10-05 20:16:21 >>>故障排除日志:删除未同步下发订单成功24100520161353876894
2024-10-05 20:16:22 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


===20:32:39===
2024-10-05 20:31:46>>>cash read=00
2024-10-05 20:31:48>>>cash read=2F29
2024-10-05 20:31:49>>>cash read=012F
2024-10-05 20:31:50>>>cash read=00
2024-10-05 20:31:50>>>cash read=818F42
2024-10-05 20:31:50>>>cash write=02
2024-10-05 20:31:50 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-05 20:31:51>>>cash read=10
2024-10-05 20:31:51 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-05 20:31:51 当前产品价格10元，投币10元，打印小票中...
2024-10-05 20:31:51 >>>开始打印,排队号为185,订单号为2410052031510035865002
2024-10-05 20:31:51>>>订单2410052031510035865002写入成功,剩余空间为1679500,占用RAM为607.3046875
删除未同步订单2410052031510035865002
2024-10-05 20:31:53>>>订单2410052031510035865002删除成功,剩余空间为1680500,占用RAM为617.71484375
检测订单目录中>>>
无未同步订单>>>
2024-10-05 20:31:53 >>>当前Ram内存为589.365234375
定时检测未同步订单启用
2024-10-05 20:31:54>>>cash write=0C
2024-10-05 20:31:54>>>cash read=3E


===20:33:39===
定时检测未同步订单关闭
检测订单目录中>>>
无未同步订单>>>
2024-10-05 20:33:10>>>cash read=00
2024-10-05 20:33:10>>>cash read=818F43
2024-10-05 20:33:10>>>cash write=02
2024-10-05 20:33:10 >>>回调事件130,cash_status,10022,进钞中...read money=20
2024-10-05 20:33:10>>>cash read=10
2024-10-05 20:33:10 >>>回调事件130,20,10023,finish Money=20,进钞完成
2024-10-05 20:33:10 当前产品价格10元，投币20元，打印小票中...
2024-10-05 20:33:10 >>>开始打印,排队号为186,订单号为2410052033100035868244
2024-10-05 20:33:10 >>>开始打印,排队号为187,订单号为2410052033100035868244
2024-10-05 20:33:11>>>订单2410052033100035868244写入成功,剩余空间为1679000,占用RAM为614.2685546875
删除未同步订单2410052033100035868244
2024-10-05 20:33:14>>>订单2410052033100035868244删除成功,剩余空间为1680500,占用RAM为629.876953125
检测订单目录中>>>
无未同步订单>>>
2024-10-05 20:33:14 >>>当前Ram内存为590.8203125
定时检测未同步订单启用
2024-10-05 20:33:15>>>cash write=0C
2024-10-05 20:33:15>>>cash read=3E


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


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


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


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


===20:49:40===
2024-10-05 20:48:45>>>cash read=00
2024-10-05 20:48:46>>>cash read=818F4200
2024-10-05 20:48:46>>>cash write=02
2024-10-05 20:48:46 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-05 20:48:47>>>cash read=10
2024-10-05 20:48:47 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-05 20:48:47 当前产品价格10元，投币10元，打印小票中...
2024-10-05 20:48:47 >>>开始打印,排队号为191,订单号为2410052048470035861550
2024-10-05 20:48:47>>>订单2410052048470035861550写入成功,剩余空间为1680000,占用RAM为606.3076171875
删除未同步订单2410052048470035861550
2024-10-05 20:48:49>>>订单2410052048470035861550删除成功,剩余空间为1680500,占用RAM为616.5615234375
检测订单目录中>>>
无未同步订单>>>
2024-10-05 20:48:49 >>>当前Ram内存为588.380859375
定时检测未同步订单启用
2024-10-05 20:48:50>>>cash write=0C
2024-10-05 20:48:50>>>cash read=3E
2024-10-05 20:49:31 >>>回调事件[910,devices/TL3586]
2024-10-05 20:49:31 >>>故障排除日志:上一MQTT订单号缓存列表为24100520452866037534
2024-10-05 20:49:31 >>>故障排除日志:终端未同步成功订单列表
2024-10-05 20:49:31 开始打印,排队:192,票券:2410052049254162497901,订单:24100520492541620943,[2024-10-05 20:49:31微信支付10元]
2024-10-05 20:49:33 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410052049254162497901","queue_number":192,"trade_uid":"24100520492541620943"}]}
2024-10-05 20:49:33 >>>故障排除日志:删除未同步下发订单成功24100520492541620943
2024-10-05 20:49:34 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


===21:03:42===
2024-10-05 21:03:21>>>cash read=0A
2024-10-05 21:03:22>>>cash read=3E
2024-10-05 21:03:38 >>>回调事件[910,devices/TL3586]
2024-10-05 21:03:38 >>>故障排除日志:上一MQTT订单号缓存列表为24100521015132856467
2024-10-05 21:03:38 >>>故障排除日志:终端未同步成功订单列表
2024-10-05 21:03:38 开始打印,排队:194,票券:2410052103321375189401,订单:24100521033213747796,[2024-10-05 21:03:38微信支付10元]


===21:04:42===
2024-10-05 21:03:40 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410052103321375189401","queue_number":194,"trade_uid":"24100521033213747796"}]}
2024-10-05 21:03:40 >>>故障排除日志:删除未同步下发订单成功24100521033213747796
2024-10-05 21:03:40 >>>故障排除日志:终端同步成功后剩余订单列表


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


===21:18:42===
2024-10-05 21:18:29 收到下发指令:叫号2>>>
2024-10-05 21:18:36 收到下发指令:叫号3>>>
2024-10-05 21:18:39 收到下发指令:叫号4>>>


===21:19:42===
2024-10-05 21:18:41 收到下发指令:叫号5>>>
2024-10-05 21:18:44 收到下发指令:叫号6>>>
2024-10-05 21:18:46 收到下发指令:叫号7>>>
2024-10-05 21:18:48 收到下发指令:叫号8>>>
2024-10-05 21:18:54 收到下发指令:叫号9>>>
2024-10-05 21:18:55 收到下发指令:叫号10>>>
2024-10-05 21:18:57 收到下发指令:叫号11>>>
2024-10-05 21:18:58 收到下发指令:叫号12>>>
2024-10-05 21:19:00 收到下发指令:叫号13>>>
2024-10-05 21:19:02 收到下发指令:叫号14>>>
2024-10-05 21:19:04 收到下发指令:叫号15>>>
2024-10-05 21:19:06 收到下发指令:叫号16>>>
2024-10-05 21:19:08 收到下发指令:叫号17>>>
2024-10-05 21:19:10 收到下发指令:叫号18>>>
2024-10-05 21:19:12 收到下发指令:叫号19>>>
2024-10-05 21:19:13 收到下发指令:叫号20>>>
2024-10-05 21:19:15 收到下发指令:叫号21>>>
2024-10-05 21:19:17 收到下发指令:叫号22>>>
2024-10-05 21:19:19 收到下发指令:叫号23>>>
2024-10-05 21:19:21 收到下发指令:叫号24>>>
2024-10-05 21:19:23 收到下发指令:叫号25>>>
2024-10-05 21:19:25 收到下发指令:叫号26>>>
2024-10-05 21:19:26 收到下发指令:叫号27>>>
2024-10-05 21:19:28 收到下发指令:叫号28>>>
2024-10-05 21:19:29 收到下发指令:叫号29>>>
2024-10-05 21:19:31 收到下发指令:叫号30>>>
2024-10-05 21:19:33 收到下发指令:叫号31>>>
2024-10-05 21:19:35 收到下发指令:叫号32>>>
2024-10-05 21:19:37 收到下发指令:叫号33>>>
2024-10-05 21:19:39 收到下发指令:叫号34>>>


===21:20:43===
2024-10-05 21:19:41 收到下发指令:叫号35>>>
2024-10-05 21:19:43 收到下发指令:叫号36>>>
2024-10-05 21:19:45 收到下发指令:叫号37>>>
2024-10-05 21:19:47 收到下发指令:叫号38>>>
2024-10-05 21:19:48 收到下发指令:叫号39>>>
2024-10-05 21:19:50 收到下发指令:叫号40>>>
2024-10-05 21:19:52 收到下发指令:叫号41>>>
2024-10-05 21:19:54 收到下发指令:叫号42>>>
2024-10-05 21:19:55 收到下发指令:叫号43>>>
2024-10-05 21:19:57 收到下发指令:叫号44>>>
2024-10-05 21:19:59 收到下发指令:叫号45>>>
2024-10-05 21:20:00 收到下发指令:叫号46>>>
2024-10-05 21:20:02 收到下发指令:叫号47>>>
2024-10-05 21:20:04 收到下发指令:叫号48>>>
2024-10-05 21:20:06 收到下发指令:叫号49>>>
2024-10-05 21:20:08 收到下发指令:叫号50>>>
2024-10-05 21:20:09 收到下发指令:叫号51>>>
2024-10-05 21:20:11 收到下发指令:叫号52>>>
2024-10-05 21:20:13 收到下发指令:叫号53>>>
2024-10-05 21:20:15 收到下发指令:叫号54>>>
2024-10-05 21:20:17 收到下发指令:叫号55>>>
2024-10-05 21:20:18 收到下发指令:叫号56>>>


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


===21:30:43===
2024-10-05 21:30:11 收到下发指令:叫号57>>>
2024-10-05 21:30:23 >>>回调事件[910,devices/TL3586]
2024-10-05 21:30:23 >>>故障排除日志:上一MQTT订单号缓存列表为24100521271456912271
2024-10-05 21:30:23 >>>故障排除日志:终端未同步成功订单列表
2024-10-05 21:30:23 开始打印,排队:197,票券:2410052130180602528901,订单:24100521301806020714,[2024-10-05 21:30:23微信支付10元]
2024-10-05 21:30:25 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410052130180602528901","queue_number":197,"trade_uid":"24100521301806020714"}]}
2024-10-05 21:30:25 >>>故障排除日志:删除未同步下发订单成功24100521301806020714
2024-10-05 21:30:25 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


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


===22:26:47===
2024-10-05 22:25:50 收到下发指令:叫号58>>>
2024-10-05 22:25:51 收到下发指令:叫号59>>>
2024-10-05 22:25:52 收到下发指令:叫号60>>>
2024-10-05 22:25:53 收到下发指令:叫号61>>>
2024-10-05 22:25:54 收到下发指令:叫号62>>>
2024-10-05 22:25:55 收到下发指令:叫号63>>>
2024-10-05 22:25:56 收到下发指令:叫号64>>>
2024-10-05 22:25:57 收到下发指令:叫号65>>>
2024-10-05 22:25:58 收到下发指令:叫号66>>>
2024-10-05 22:25:59 收到下发指令:叫号67>>>
2024-10-05 22:25:59 收到下发指令:叫号68>>>
2024-10-05 22:26:00 收到下发指令:叫号69>>>
2024-10-05 22:26:01 收到下发指令:叫号70>>>
2024-10-05 22:26:02 收到下发指令:叫号71>>>
2024-10-05 22:26:03 收到下发指令:叫号72>>>
2024-10-05 22:26:04 收到下发指令:叫号73>>>
2024-10-05 22:26:05 收到下发指令:叫号74>>>
2024-10-05 22:26:06 收到下发指令:叫号75>>>
2024-10-05 22:26:07 收到下发指令:叫号76>>>
2024-10-05 22:26:08 收到下发指令:叫号77>>>
2024-10-05 22:26:08 收到下发指令:叫号78>>>
2024-10-05 22:26:09 收到下发指令:叫号79>>>
2024-10-05 22:26:10 收到下发指令:叫号80>>>
2024-10-05 22:26:10 收到下发指令:叫号81>>>
2024-10-05 22:26:11 收到下发指令:叫号82>>>
2024-10-05 22:26:12 收到下发指令:叫号83>>>
2024-10-05 22:26:13 收到下发指令:叫号84>>>
2024-10-05 22:26:14 收到下发指令:叫号85>>>
2024-10-05 22:26:15 收到下发指令:叫号86>>>
2024-10-05 22:26:15 收到下发指令:叫号87>>>
2024-10-05 22:26:16 收到下发指令:叫号88>>>
2024-10-05 22:26:17 收到下发指令:叫号89>>>
2024-10-05 22:26:19 收到下发指令:叫号90>>>
2024-10-05 22:26:20 收到下发指令:叫号91>>>
2024-10-05 22:26:21 收到下发指令:叫号92>>>
2024-10-05 22:26:22 收到下发指令:叫号93>>>
2024-10-05 22:26:22 收到下发指令:叫号94>>>
2024-10-05 22:26:23 收到下发指令:叫号95>>>
2024-10-05 22:26:24 收到下发指令:叫号96>>>
2024-10-05 22:26:25 收到下发指令:叫号97>>>
2024-10-05 22:26:26 收到下发指令:叫号98>>>
2024-10-05 22:26:27 收到下发指令:叫号99>>>
2024-10-05 22:26:28 收到下发指令:叫号100>>>
2024-10-05 22:26:29 收到下发指令:叫号101>>>
2024-10-05 22:26:30 收到下发指令:叫号102>>>
2024-10-05 22:26:31 收到下发指令:叫号103>>>
2024-10-05 22:26:32 收到下发指令:叫号104>>>
2024-10-05 22:26:33 收到下发指令:叫号105>>>
2024-10-05 22:26:33 收到下发指令:叫号106>>>
2024-10-05 22:26:34 收到下发指令:叫号107>>>
2024-10-05 22:26:35 收到下发指令:叫号108>>>
2024-10-05 22:26:36 收到下发指令:叫号109>>>
2024-10-05 22:26:37 收到下发指令:叫号110>>>
2024-10-05 22:26:38 收到下发指令:叫号111>>>
2024-10-05 22:26:39 收到下发指令:叫号112>>>
2024-10-05 22:26:39 收到下发指令:叫号113>>>
2024-10-05 22:26:40 收到下发指令:叫号114>>>
2024-10-05 22:26:41 收到下发指令:叫号115>>>
2024-10-05 22:26:42 收到下发指令:叫号116>>>
2024-10-05 22:26:43 收到下发指令:叫号117>>>
2024-10-05 22:26:43 收到下发指令:叫号118>>>
2024-10-05 22:26:44 收到下发指令:叫号119>>>
2024-10-05 22:26:45 收到下发指令:叫号120>>>


===22:39:49===
2024-10-05 22:39:46 >>>回调事件[910,devices/TL3586]
2024-10-05 22:39:46 >>>故障排除日志:上一MQTT订单号缓存列表为24100522014185967481
2024-10-05 22:39:46 >>>故障排除日志:终端未同步成功订单列表
2024-10-05 22:39:46 开始打印,排队:202,票券:2410052239361065735801,订单:24100522393610653685,[2024-10-05 22:39:45微信支付10元]


===22:41:50===
2024-10-05 22:40:51 收到下发指令:叫号121>>>