TLClient_JSSCOM_LuatOS-Air_V4010_RDA8910_RFTTS_0xe0000,2.5.4,861658060911040,76486463208804,
poweron reason:0

===09:24:40===
2024-10-06 22:15:45>>>cash read=00
2024-10-06 22:15:46>>>cash read=818F42
2024-10-06 22:15:46>>>cash write=02
2024-10-06 22:15:46 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-06 22:15:47>>>cash write=0C
2024-10-06 22:15:47>>>cash read=00
2024-10-06 22:15:47>>>cash read=10
2024-10-06 22:15:47 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-06 22:15:48>>>cash read=00
2024-10-06 22:15:49>>>cash read=818F41
2024-10-06 22:15:49>>>cash write=02
2024-10-06 22:15:49 >>>回调事件130,cash_status,10022,进钞中...read money=5
2024-10-06 22:15:49>>>cash read=10
2024-10-06 22:15:49 >>>回调事件130,5,10023,finish Money=5,进钞完成
2024-10-06 22:15:49 当前产品价格15元，投币15元，打印小票中...
2024-10-06 22:15:49 >>>开始打印,排队号为190,订单号为2410062215470025837930
2024-10-06 22:15:49>>>订单2410062215470025837930写入成功,剩余空间为1679500,占用RAM为605.6572265625
删除未同步订单2410062215470025837930
2024-10-06 22:15:51>>>订单2410062215470025837930删除成功,剩余空间为1680000,占用RAM为621.52734375
检测订单目录中>>>
无未同步订单>>>
2024-10-06 22:15:52 >>>当前Ram内存为591.5654296875
定时检测未同步订单启用
2024-10-06 22:15:52>>>cash write=0C
2024-10-06 22:15:53>>>cash read=3E
2024-10-07 09:24:38 >>>剩余flash空间=1680000,占用RAM为623.2587890625
2024-10-07 09:24:38 >>>回调异常:911,initSys,30000,nil



===09:25:41===
上一时间戳为1728218725
隔日重置时间戳true
隔日清空未同步下发列表true
当前排队号为1,音量为5
初始化产品信息:[{"time_limit_date":null,"ticket_category":"0","expiry_date":365,"product_detail":"","time_limit_status":"0","begin_minute":null,"product_uid":"97679315402183683","use_timer":1,"old_price":"20","end_hour":null,"sale_price":"20","end_minute":null,"begin_hour":null,"sale_status":1,"product_name":"成人票"},{"time_limit_date":null,"ticket_category":"0","expiry_date":90,"product_detail":"","time_limit_status":"0","begin_minute":null,"product_uid":"98628273993276813","use_timer":1,"old_price":"15","end_hour":null,"sale_price":"15","end_minute":null,"begin_hour":null,"sale_status":1,"product_name":"儿童票"}]
打印门店标题设置为美和百货店
是否打印二维码设置为1
是否打印紧凑设置为3
session_id:dcae9****e0346
纸币器设置接收纸币范围为36
欢迎使用天羚自助售票系统[2.5.4]
定时检测未同步订单启用
2024-10-07 09:24:47>>>cash write=30
2024-10-07 09:24:47>>>cash write=02
2024-10-07 09:24:47>>>cash write=3E
2024-10-07 09:24:47>>>cash read=808F808F808F808F808F808F808F808F
系统时间初始化成功，时间为202410792447
2024-10-07 09:24:48>>>cash write=02
2024-10-07 09:24:48 >>>剩余flash空间=1680000,占用RAM为629.4189453125
2024-10-07 09:24:48 >>>回调事件:910,subscribe,10000,连接服务器成功

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

2024-10-07 09:24:51>>>cash write=0C
2024-10-07 09:24:51>>>cash read=3E
流量卡还有23天过期
2024-10-07 09:24:59 >>>当前Ram内存为624.525390625


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


===09:36:41===
2024-10-07 09:36:01 >>>回调事件[910,devices/TL2583]
当日首次设置时间戳true为1728264961
2024-10-07 09:36:01 >>>故障排除日志:上一MQTT订单号缓存列表为24100621502077014789
2024-10-07 09:36:01 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 09:36:01 开始打印,排队:1,票券:2410070935550229433501,订单:24100709355502290287,[2024-10-07 09:36:01微信支付20元]
2024-10-07 09:36:03 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410070935550229433501","queue_number":1,"trade_uid":"24100709355502290287"}]}
2024-10-07 09:36:03 >>>故障排除日志:删除未同步下发订单成功24100709355502290287
2024-10-07 09:36:03 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


===09:49:43===
2024-10-07 09:48:48 >>>回调事件[910,devices/TL2583]
2024-10-07 09:48:48 >>>故障排除日志:上一MQTT订单号缓存列表为24100709482288882942
2024-10-07 09:48:48 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 09:48:48 开始打印,排队:5,票券:2410070948418709413901,订单:24100709484187090123,[2024-10-07 09:48:48微信支付20元]
2024-10-07 09:48:50 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410070948418709413901","queue_number":5,"trade_uid":"24100709484187090123"}]}
2024-10-07 09:48:50 >>>故障排除日志:删除未同步下发订单成功24100709484187090123
2024-10-07 09:48:50 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-07 09:49:09 >>>回调事件[910,devices/TL2583]
2024-10-07 09:49:09 >>>故障排除日志:上一MQTT订单号缓存列表为24100709484187090123
2024-10-07 09:49:09 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 09:49:09 开始打印,排队:6,票券:2410070949018989721301,订单:24100709490189892595,[2024-10-07 09:49:08微信支付20元]
2024-10-07 09:49:11 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410070949018989721301","queue_number":6,"trade_uid":"24100709490189892595"}]}
2024-10-07 09:49:11 >>>故障排除日志:删除未同步下发订单成功24100709490189892595
2024-10-07 09:49:11 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-07 09:49:24>>>cash read=00
2024-10-07 09:49:25>>>cash read=818F42
2024-10-07 09:49:25>>>cash write=02
2024-10-07 09:49:25 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-07 09:49:26>>>cash write=0C
2024-10-07 09:49:26>>>cash read=00
2024-10-07 09:49:26>>>cash read=10
2024-10-07 09:49:26 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-07 09:49:27>>>cash read=01
2024-10-07 09:49:32>>>cash read=29
2024-10-07 09:49:32 >>>回调事件130,cash_status,20029,退钞中
2024-10-07 09:49:32>>>cash read=2F29
2024-10-07 09:49:33>>>cash read=01
2024-10-07 09:49:34>>>cash read=2F
2024-10-07 09:49:35>>>cash read=3E
2024-10-07 09:49:36>>>cash read=00
2024-10-07 09:49:37>>>cash read=292F29
2024-10-07 09:49:37 >>>回调事件130,cash_status,20029,退钞中
2024-10-07 09:49:39>>>cash read=3E


===09:50:43===
2024-10-07 09:50:00 >>>开始未足额打印,排队号为7,订单号为2410070949260025835926
2024-10-07 09:50:00 订单投币结束,共投币10元,请取走您的小票
2024-10-07 09:50:00>>>订单2410070949260025835926写入成功,剩余空间为1680500,占用RAM为617.5029296875
删除未同步订单2410070949260025835926
2024-10-07 09:50:02>>>订单2410070949260025835926删除成功,剩余空间为1681500,占用RAM为603.65625
检测订单目录中>>>
无未同步订单>>>
2024-10-07 09:50:02 >>>当前Ram内存为592.0224609375
定时检测未同步订单启用


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


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


===10:01:44===
2024-10-07 10:01:01 >>>回调事件[910,devices/TL2583]
2024-10-07 10:01:01 >>>故障排除日志:上一MQTT订单号缓存列表为24100709534169239596
2024-10-07 10:01:01 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 10:01:01 开始打印,排队:9,票券:2410071000469107281501,订单:24100710004691067753,[2024-10-07 10:00:59支付宝支付15元]
2024-10-07 10:01:03 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410071000469107281501","queue_number":9,"trade_uid":"24100710004691067753"}]}
2024-10-07 10:01:03 >>>故障排除日志:删除未同步下发订单成功24100710004691067753
2024-10-07 10:01:03 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


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


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


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


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


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


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


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


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


===10:43:48===
2024-10-07 10:43:44 >>>回调事件[910,devices/TL2583]
2024-10-07 10:43:45 >>>故障排除日志:上一MQTT订单号缓存列表为24100710405387102674|24100710405387102674
2024-10-07 10:43:45 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 10:43:45 开始打印,排队:23,票券:2410071043386497318701,订单:24100710433864925163,[2024-10-07 10:43:44微信支付20元]


===10:44:48===
2024-10-07 10:43:47 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410071043386497318701","queue_number":23,"trade_uid":"24100710433864925163"}]}
2024-10-07 10:43:47 >>>故障排除日志:删除未同步下发订单成功24100710433864925163
2024-10-07 10:43:47 >>>故障排除日志:终端同步成功后剩余订单列表


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


===11:00:48===
2024-10-07 10:59:52 >>>回调事件[910,devices/TL2583]
2024-10-07 10:59:52 >>>故障排除日志:上一MQTT订单号缓存列表为24100710511998019956
2024-10-07 10:59:52 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 10:59:52 开始打印,排队:25,票券:2410071059463629937501,订单:24100710594636294968,[2024-10-07 10:59:51支付宝支付20元]
2024-10-07 10:59:54 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410071059463629937501","queue_number":25,"trade_uid":"24100710594636294968"}]}
2024-10-07 10:59:54 >>>故障排除日志:删除未同步下发订单成功24100710594636294968
2024-10-07 10:59:54 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


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


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


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


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


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


===11:48:51===
2024-10-07 11:48:41>>>cash read=0A
2024-10-07 11:48:42>>>cash read=3E


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


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


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


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


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


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


===12:24:53===
2024-10-07 12:24:21>>>cash read=0A
2024-10-07 12:24:23>>>cash read=3E


===12:34:53===
2024-10-07 12:34:24 >>>回调事件[910,devices/TL2583]
2024-10-07 12:34:24 >>>故障排除日志:上一MQTT订单号缓存列表为24100712210196545016
2024-10-07 12:34:24 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 12:34:24 开始打印,排队:41,票券:2410071234178537388101,订单:24100712341785370234,[2024-10-07 12:34:23支付宝支付20元]
2024-10-07 12:34:26 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410071234178537388101","queue_number":41,"trade_uid":"24100712341785370234"}]}
2024-10-07 12:34:26 >>>故障排除日志:删除未同步下发订单成功24100712341785370234
2024-10-07 12:34:26 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-07 12:34:46 >>>回调事件[910,devices/TL2583]
2024-10-07 12:34:46 >>>故障排除日志:上一MQTT订单号缓存列表为24100712341785370234
2024-10-07 12:34:46 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 12:34:46 开始打印,排队:42,票券:2410071234401411688901,订单:24100712344014111483,[2024-10-07 12:34:45支付宝支付15元]
2024-10-07 12:34:48 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410071234401411688901","queue_number":42,"trade_uid":"24100712344014111483"}]}
2024-10-07 12:34:48 >>>故障排除日志:删除未同步下发订单成功24100712344014111483
2024-10-07 12:34:48 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


===13:03:55===
2024-10-07 13:03:12 >>>回调事件[910,devices/TL2583]
2024-10-07 13:03:12 >>>故障排除日志:上一MQTT订单号缓存列表为24100712561936111372
2024-10-07 13:03:12 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 13:03:12 开始打印,排队:47,票券:2410071303068862774901,订单:24100713030688623712,[2024-10-07 13:03:12微信支付15元]
2024-10-07 13:03:14 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410071303068862774901","queue_number":47,"trade_uid":"24100713030688623712"}]}
2024-10-07 13:03:14 >>>故障排除日志:删除未同步下发订单成功24100713030688623712
2024-10-07 13:03:14 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-07 13:03:30 >>>回调事件[910,devices/TL2583]
2024-10-07 13:03:30 >>>故障排除日志:上一MQTT订单号缓存列表为24100713030688623712
2024-10-07 13:03:30 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 13:03:30 开始打印,排队:48,票券:2410071303238043215901,订单:24100713032380426842,[2024-10-07 13:03:28微信支付20元]
2024-10-07 13:03:32 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410071303238043215901","queue_number":48,"trade_uid":"24100713032380426842"}]}
2024-10-07 13:03:32 >>>故障排除日志:删除未同步下发订单成功24100713032380426842
2024-10-07 13:03:32 >>>故障排除日志:终端同步成功后剩余订单列表


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


===13:08:55===
2024-10-07 13:08:29>>>cash read=9E
2024-10-07 13:08:30>>>cash read=3E


===13:13:56===
2024-10-07 13:12:58 >>>回调事件[910,devices/TL2583]
2024-10-07 13:12:58 >>>故障排除日志:上一MQTT订单号缓存列表为24100713064005036134
2024-10-07 13:12:58 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 13:12:58 开始打印,排队:50,票券:2410071312511742803801,订单:24100713125117423096,[2024-10-07 13:12:57微信支付20元]
2024-10-07 13:13:00 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410071312511742803801","queue_number":50,"trade_uid":"24100713125117423096"}]}
2024-10-07 13:13:00 >>>故障排除日志:删除未同步下发订单成功24100713125117423096
2024-10-07 13:13:00 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-07 13:13:33 >>>回调事件[910,devices/TL2583]
2024-10-07 13:13:33 >>>故障排除日志:上一MQTT订单号缓存列表为24100713125117423096
2024-10-07 13:13:33 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 13:13:33 开始打印,排队:51,票券:2410071313247500046501,订单:24100713132474995126,[2024-10-07 13:13:31微信支付20元]
2024-10-07 13:13:35 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410071313247500046501","queue_number":51,"trade_uid":"24100713132474995126"}]}
2024-10-07 13:13:35 >>>故障排除日志:删除未同步下发订单成功24100713132474995126
2024-10-07 13:13:35 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


===13:19:57===
2024-10-07 13:19:03>>>cash read=0A
2024-10-07 13:19:04>>>cash read=3E
2024-10-07 13:19:08 >>>回调事件[910,devices/TL2583]
2024-10-07 13:19:08 >>>故障排除日志:上一MQTT订单号缓存列表为24100713182708021929
2024-10-07 13:19:08 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 13:19:08 开始打印,排队:56,票券:2410071319004849046401,订单:24100713190048486716,[2024-10-07 13:19:07微信支付20元]
2024-10-07 13:19:10 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410071319004849046401","queue_number":56,"trade_uid":"24100713190048486716"}]}
2024-10-07 13:19:10 >>>故障排除日志:删除未同步下发订单成功24100713190048486716
2024-10-07 13:19:10 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-07 13:19:26>>>cash read=00
2024-10-07 13:19:26>>>cash read=818F43
2024-10-07 13:19:26>>>cash write=02
2024-10-07 13:19:26 >>>回调事件130,cash_status,10022,进钞中...read money=20
2024-10-07 13:19:27>>>cash read=10
2024-10-07 13:19:27 >>>回调事件130,20,10023,finish Money=20,进钞完成
2024-10-07 13:19:27 当前产品价格20元，投币20元，打印小票中...
2024-10-07 13:19:27 >>>开始打印,排队号为57,订单号为2410071319270025839444
2024-10-07 13:19:27>>>订单2410071319270025839444写入成功,剩余空间为1679000,占用RAM为613.4423828125
删除未同步订单2410071319270025839444
2024-10-07 13:19:29>>>订单2410071319270025839444删除成功,剩余空间为1680000,占用RAM为621.7490234375
检测订单目录中>>>
无未同步订单>>>
2024-10-07 13:19:29 >>>当前Ram内存为592.3388671875
定时检测未同步订单启用
2024-10-07 13:19:30>>>cash write=0C
2024-10-07 13:19:30>>>cash read=3E


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


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


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


===13:27:58===
2024-10-07 13:27:33>>>cash read=00
2024-10-07 13:27:33>>>cash read=2F29
2024-10-07 13:27:34>>>cash read=3E
2024-10-07 13:27:46>>>cash read=00
2024-10-07 13:27:46>>>cash read=818F42
2024-10-07 13:27:46>>>cash write=02
2024-10-07 13:27:46 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-07 13:27:47>>>cash read=10
2024-10-07 13:27:47 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-07 13:27:48>>>cash write=0C
2024-10-07 13:27:48>>>cash read=3E
2024-10-07 13:27:52>>>cash read=29
2024-10-07 13:27:52 >>>回调事件130,cash_status,20029,退钞中
2024-10-07 13:27:53>>>cash read=01
2024-10-07 13:27:55>>>cash read=3E
2024-10-07 13:27:56>>>cash read=00


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


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


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


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


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


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


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


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


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


===14:13:01===
2024-10-07 14:12:22>>>cash read=2F29
2024-10-07 14:12:23>>>cash read=01
2024-10-07 14:12:26>>>cash read=2F
2024-10-07 14:12:27>>>cash read=3E
2024-10-07 14:12:39>>>cash read=2F29
2024-10-07 14:12:40>>>cash read=00
2024-10-07 14:12:41>>>cash read=818F4100
2024-10-07 14:12:41>>>cash write=02
2024-10-07 14:12:41 >>>回调事件130,cash_status,10022,进钞中...read money=5
2024-10-07 14:12:42 >>>回调事件130,5,10023,finish Money=5,进钞完成
2024-10-07 14:12:43>>>cash write=0C
2024-10-07 14:12:43>>>cash read=3E
2024-10-07 14:12:49>>>cash read=29
2024-10-07 14:12:49 >>>回调事件130,cash_status,20029,退钞中
2024-10-07 14:12:50>>>cash read=01
2024-10-07 14:12:51>>>cash read=3E
2024-10-07 14:12:52>>>cash read=29
2024-10-07 14:12:52 >>>回调事件130,cash_status,20029,退钞中
2024-10-07 14:12:53>>>cash read=01
2024-10-07 14:12:55>>>cash read=3E


===14:14:01===
2024-10-07 14:13:01>>>cash read=00
2024-10-07 14:13:02>>>cash read=00818F41
2024-10-07 14:13:02>>>cash write=02
2024-10-07 14:13:03 >>>回调事件130,cash_status,10022,进钞中...read money=5
2024-10-07 14:13:03>>>cash read=10
2024-10-07 14:13:03 >>>回调事件130,5,10023,finish Money=5,进钞完成
2024-10-07 14:13:04>>>cash write=0C
2024-10-07 14:13:04>>>cash read=3E
2024-10-07 14:13:14>>>cash read=01
2024-10-07 14:13:16>>>cash read=00
2024-10-07 14:13:16>>>cash read=818F41
2024-10-07 14:13:16>>>cash write=02
2024-10-07 14:13:16 >>>回调事件130,cash_status,10022,进钞中...read money=5
2024-10-07 14:13:17>>>cash read=10
2024-10-07 14:13:17 >>>回调事件130,5,10023,finish Money=5,进钞完成
2024-10-07 14:13:17 当前产品价格15元，投币15元，打印小票中...
2024-10-07 14:13:17 >>>开始打印,排队号为69,订单号为2410071413030025832209
2024-10-07 14:13:17>>>订单2410071413030025832209写入成功,剩余空间为1679500,占用RAM为608.17578125
删除未同步订单2410071413030025832209
2024-10-07 14:13:19>>>订单2410071413030025832209删除成功,剩余空间为1680000,占用RAM为620.6689453125
检测订单目录中>>>
无未同步订单>>>
2024-10-07 14:13:19 >>>当前Ram内存为591.7783203125
定时检测未同步订单启用
2024-10-07 14:13:20>>>cash write=0C
2024-10-07 14:13:20>>>cash read=3E


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


===14:21:01===
2024-10-07 14:20:47>>>cash read=9E
2024-10-07 14:20:48>>>cash read=3E


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


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


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


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


===14:34:03===
2024-10-07 14:33:35 >>>回调事件[910,devices/TL2583]
2024-10-07 14:33:35 >>>故障排除日志:上一MQTT订单号缓存列表为24100714324493680562
2024-10-07 14:33:35 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 14:33:35 开始打印,排队:74,票券:2410071433136402495801,订单:24100714331364021298,[2024-10-07 14:33:34微信支付15元]
2024-10-07 14:33:35 开始打印,排队:75,票券:2410071433136402641602,订单:24100714331364021298,[2024-10-07 14:33:34微信支付15元]
2024-10-07 14:33:39 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410071433136402495801","queue_number":74,"trade_uid":"24100714331364021298"},{"ticket_no":"2410071433136402641602","queue_number":75,"trade_uid":"24100714331364021298"}]}
2024-10-07 14:33:39 >>>故障排除日志:删除未同步下发订单成功24100714331364021298
2024-10-07 14:33:39 >>>故障排除日志:删除未同步下发订单成功24100714331364021298
2024-10-07 14:33:39 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-07 14:33:46 >>>回调事件[910,devices/TL2583]
2024-10-07 14:33:46 >>>故障排除日志:上一MQTT订单号缓存列表为24100714331364021298|24100714331364021298
2024-10-07 14:33:46 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 14:33:46 开始打印,排队:76,票券:2410071433409144713601,订单:24100714334091442589,[2024-10-07 14:33:46微信支付20元]
2024-10-07 14:33:48 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410071433409144713601","queue_number":76,"trade_uid":"24100714334091442589"}]}
2024-10-07 14:33:48 >>>故障排除日志:删除未同步下发订单成功24100714334091442589
2024-10-07 14:33:49 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


===15:04:04===
2024-10-07 15:03:10>>>cash read=00
2024-10-07 15:03:11>>>cash read=818F43
2024-10-07 15:03:11>>>cash write=02
2024-10-07 15:03:11 >>>回调事件130,cash_status,10022,进钞中...read money=20
2024-10-07 15:03:11>>>cash read=10
2024-10-07 15:03:11 >>>回调事件130,20,10023,finish Money=20,进钞完成
2024-10-07 15:03:11 当前产品价格20元，投币20元，打印小票中...
2024-10-07 15:03:11 >>>开始打印,排队号为80,订单号为2410071503110025834294
2024-10-07 15:03:11>>>订单2410071503110025834294写入成功,剩余空间为1680000,占用RAM为606.3935546875
删除未同步订单2410071503110025834294
2024-10-07 15:03:13>>>订单2410071503110025834294删除成功,剩余空间为1680500,占用RAM为617.185546875
检测订单目录中>>>
无未同步订单>>>
2024-10-07 15:03:14 >>>当前Ram内存为589.126953125
定时检测未同步订单启用
2024-10-07 15:03:15>>>cash write=0C
2024-10-07 15:03:15>>>cash read=3E
2024-10-07 15:03:42>>>cash read=00
2024-10-07 15:03:42>>>cash read=818F42
2024-10-07 15:03:42>>>cash write=02
2024-10-07 15:03:42 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-07 15:03:43>>>cash write=0C
2024-10-07 15:03:44>>>cash read=00
2024-10-07 15:03:44>>>cash read=10
2024-10-07 15:03:44 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-07 15:03:45>>>cash read=01
2024-10-07 15:03:46>>>cash read=3E
2024-10-07 15:03:48>>>cash read=00
2024-10-07 15:03:49>>>cash read=2F29
2024-10-07 15:03:51>>>cash read=3E
2024-10-07 15:03:51 >>>开始未足额打印,排队号为81,订单号为2410071503440025837799
2024-10-07 15:03:51 订单投币结束,共投币10元,请取走您的小票
定时检测未同步订单关闭
2024-10-07 15:03:51>>>订单2410071503440025837799写入成功,剩余空间为1678500,占用RAM为616.9462890625
删除未同步订单2410071503440025837799
2024-10-07 15:03:53>>>订单2410071503440025837799删除成功,剩余空间为1679500,占用RAM为621.1484375
检测订单目录中>>>
无未同步订单>>>
2024-10-07 15:03:53 >>>当前Ram内存为590.822265625
定时检测未同步订单启用
2024-10-07 15:03:55>>>cash read=00
2024-10-07 15:03:56>>>cash read=818F41
2024-10-07 15:03:56>>>cash write=02
2024-10-07 15:03:56 >>>回调事件130,cash_status,10022,进钞中...read money=5
2024-10-07 15:03:56>>>cash read=10
2024-10-07 15:03:56 >>>回调事件130,5,10023,finish Money=5,进钞完成
2024-10-07 15:03:58>>>cash write=0C
2024-10-07 15:03:58>>>cash read=3E


===15:05:04===
2024-10-07 15:04:11 >>>回调事件[910,devices/TL2583]
2024-10-07 15:04:11 >>>故障排除日志:上一MQTT订单号缓存列表为24100715004450759124
2024-10-07 15:04:11 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 15:04:11 开始打印,排队:82,票券:2410071504043406992301,订单:24100715040434065468,[2024-10-07 15:04:11微信支付20元]
2024-10-07 15:04:13 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410071504043406992301","queue_number":82,"trade_uid":"24100715040434065468"}]}
2024-10-07 15:04:13 >>>故障排除日志:删除未同步下发订单成功24100715040434065468
2024-10-07 15:04:14 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-07 15:04:28 >>>回调事件[910,devices/TL2583]
2024-10-07 15:04:28 >>>故障排除日志:上一MQTT订单号缓存列表为24100715040434065468
2024-10-07 15:04:28 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 15:04:28 开始打印,排队:83,票券:2410071504205714477601,订单:24100715042057139254,[2024-10-07 15:04:28微信支付15元]
2024-10-07 15:04:30 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410071504205714477601","queue_number":83,"trade_uid":"24100715042057139254"}]}
2024-10-07 15:04:30 >>>故障排除日志:删除未同步下发订单成功24100715042057139254
2024-10-07 15:04:30 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单关闭
检测订单目录中>>>
无未同步订单>>>
2024-10-07 15:04:57 >>>开始未足额打印,排队号为84,订单号为2410071503570025837048
2024-10-07 15:04:57>>>订单2410071503570025837048写入成功,剩余空间为1678500,占用RAM为612.1318359375
删除未同步订单2410071503570025837048
2024-10-07 15:04:59>>>订单2410071503570025837048删除成功,剩余空间为1679500,占用RAM为645.6494140625
检测订单目录中>>>
无未同步订单>>>
2024-10-07 15:04:59 >>>当前Ram内存为590.40625
定时检测未同步订单启用


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


===15:15:07===
2024-10-07 15:15:00 >>>回调事件[910,devices/TL2583]
2024-10-07 15:15:00 >>>故障排除日志:上一MQTT订单号缓存列表为24100715053373331397
2024-10-07 15:15:01 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 15:15:01 开始打印,排队:86,票券:2410071514463431974101,订单:24100715144634316797,[2024-10-07 15:15:00微信支付15元]
2024-10-07 15:15:01 开始打印,排队:87,票券:2410071514463432097802,订单:24100715144634316797,[2024-10-07 15:15:00微信支付15元]
2024-10-07 15:15:01 开始打印,排队:88,票券:2410071514463432157103,订单:24100715144634316797,[2024-10-07 15:15:00微信支付15元]


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


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


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


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


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


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


===15:42:09===
2024-10-07 15:41:11 >>>回调事件[910,devices/TL2583]
2024-10-07 15:41:11 >>>故障排除日志:上一MQTT订单号缓存列表为24100715370199464426
2024-10-07 15:41:11 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 15:41:11 开始打印,排队:96,票券:2410071541054097764801,订单:24100715410540971213,[2024-10-07 15:41:11微信支付20元]
2024-10-07 15:41:14 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410071541054097764801","queue_number":96,"trade_uid":"24100715410540971213"}]}
2024-10-07 15:41:14 >>>故障排除日志:删除未同步下发订单成功24100715410540971213
2024-10-07 15:41:14 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-07 15:41:38 >>>回调事件[910,devices/TL2583]
2024-10-07 15:41:38 >>>故障排除日志:上一MQTT订单号缓存列表为24100715410540971213
2024-10-07 15:41:38 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 15:41:38 开始打印,排队:97,票券:2410071541295565001501,订单:24100715412955644764,[2024-10-07 15:41:38微信支付15元]
2024-10-07 15:41:40 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410071541295565001501","queue_number":97,"trade_uid":"24100715412955644764"}]}
2024-10-07 15:41:40 >>>故障排除日志:删除未同步下发订单成功24100715412955644764
2024-10-07 15:41:40 >>>故障排除日志:终端同步成功后剩余订单列表


===15:45:09===
2024-10-07 15:44:15 >>>回调事件[910,devices/TL2583]
2024-10-07 15:44:15 >>>故障排除日志:上一MQTT订单号缓存列表为24100715412955644764
2024-10-07 15:44:15 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 15:44:15 开始打印,排队:98,票券:2410071544093005679701,订单:24100715440930052121,[2024-10-07 15:44:15微信支付20元]
2024-10-07 15:44:17 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410071544093005679701","queue_number":98,"trade_uid":"24100715440930052121"}]}
2024-10-07 15:44:17 >>>故障排除日志:删除未同步下发订单成功24100715440930052121
2024-10-07 15:44:17 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-07 15:44:38 >>>回调事件[910,devices/TL2583]
2024-10-07 15:44:38 >>>故障排除日志:上一MQTT订单号缓存列表为24100715440930052121
2024-10-07 15:44:38 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 15:44:38 开始打印,排队:99,票券:2410071544296741624601,订单:24100715442967412574,[2024-10-07 15:44:38微信支付15元]
2024-10-07 15:44:40 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410071544296741624601","queue_number":99,"trade_uid":"24100715442967412574"}]}
2024-10-07 15:44:40 >>>故障排除日志:删除未同步下发订单成功24100715442967412574
2024-10-07 15:44:41 >>>故障排除日志:终端同步成功后剩余订单列表


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


===15:47:11===
2024-10-07 15:47:07 >>>回调事件[910,devices/TL2583]
2024-10-07 15:47:07 >>>故障排除日志:上一MQTT订单号缓存列表为24100715451352738897
2024-10-07 15:47:07 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 15:47:07 开始打印,排队:101,票券:2410071546590425254201,订单:24100715465904248685,[2024-10-07 15:47:06微信支付20元]
2024-10-07 15:47:07 开始打印,排队:102,票券:2410071546590425396802,订单:24100715465904248685,[2024-10-07 15:47:06微信支付20元]


===15:48:12===
2024-10-07 15:47:10 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410071546590425254201","queue_number":101,"trade_uid":"24100715465904248685"},{"ticket_no":"2410071546590425396802","queue_number":102,"trade_uid":"24100715465904248685"}]}
2024-10-07 15:47:10 >>>故障排除日志:删除未同步下发订单成功24100715465904248685
2024-10-07 15:47:10 >>>故障排除日志:删除未同步下发订单成功24100715465904248685
2024-10-07 15:47:10 >>>故障排除日志:终端同步成功后剩余订单列表


===15:49:12===
2024-10-07 15:48:19 >>>回调事件[910,devices/TL2583]
2024-10-07 15:48:19 >>>故障排除日志:上一MQTT订单号缓存列表为24100715465904248685|24100715465904248685
2024-10-07 15:48:19 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 15:48:19 开始打印,排队:103,票券:2410071548128347893401,订单:24100715481283475453,[2024-10-07 15:48:18微信支付20元]
2024-10-07 15:48:21 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410071548128347893401","queue_number":103,"trade_uid":"24100715481283475453"}]}
2024-10-07 15:48:21 >>>故障排除日志:删除未同步下发订单成功24100715481283475453
2024-10-07 15:48:21 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-07 15:49:04 >>>回调事件[910,devices/TL2583]
2024-10-07 15:49:04 >>>故障排除日志:上一MQTT订单号缓存列表为24100715481283475453
2024-10-07 15:49:04 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 15:49:04 开始打印,排队:104,票券:2410071548554045164201,订单:24100715485540447567,[2024-10-07 15:49:03支付宝支付20元]
2024-10-07 15:49:06 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410071548554045164201","queue_number":104,"trade_uid":"24100715485540447567"}]}
2024-10-07 15:49:06 >>>故障排除日志:删除未同步下发订单成功24100715485540447567
2024-10-07 15:49:06 >>>故障排除日志:终端同步成功后剩余订单列表


===15:51:12===
2024-10-07 15:50:17>>>cash read=00
2024-10-07 15:50:18>>>cash read=818F42
2024-10-07 15:50:18>>>cash write=02
2024-10-07 15:50:18 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-07 15:50:19>>>cash read=10
2024-10-07 15:50:19 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-07 15:50:20>>>cash write=0C
2024-10-07 15:50:20>>>cash read=00
2024-10-07 15:50:21>>>cash read=29
2024-10-07 15:50:21 >>>回调事件130,cash_status,20029,退钞中
2024-10-07 15:50:22>>>cash read=3E
2024-10-07 15:50:26>>>cash read=00
2024-10-07 15:50:26>>>cash read=818F41
2024-10-07 15:50:26>>>cash write=02
2024-10-07 15:50:26 >>>回调事件130,cash_status,10022,进钞中...read money=5
2024-10-07 15:50:27>>>cash read=10
2024-10-07 15:50:27 >>>回调事件130,5,10023,finish Money=5,进钞完成
2024-10-07 15:50:27 当前产品价格15元，投币15元，打印小票中...
2024-10-07 15:50:27 >>>开始打印,排队号为105,订单号为2410071550190025837081
2024-10-07 15:50:27>>>订单2410071550190025837081写入成功,剩余空间为1679500,占用RAM为606.5244140625
删除未同步订单2410071550190025837081
2024-10-07 15:50:29>>>订单2410071550190025837081删除成功,剩余空间为1680000,占用RAM为618.4521484375
检测订单目录中>>>
无未同步订单>>>
2024-10-07 15:50:29 >>>当前Ram内存为589.666015625
定时检测未同步订单启用
2024-10-07 15:50:30>>>cash write=0C
2024-10-07 15:50:30>>>cash read=3E


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


===15:58:13===
2024-10-07 15:57:18 >>>回调事件[910,devices/TL2583]
2024-10-07 15:57:18 >>>故障排除日志:上一MQTT订单号缓存列表为24100715485540447567
2024-10-07 15:57:18 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 15:57:18 开始打印,排队:106,票券:2410071557121272521901,订单:24100715571212721312,[2024-10-07 15:57:17支付宝支付20元]
2024-10-07 15:57:20 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410071557121272521901","queue_number":106,"trade_uid":"24100715571212721312"}]}
2024-10-07 15:57:20 >>>故障排除日志:删除未同步下发订单成功24100715571212721312
2024-10-07 15:57:20 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-07 15:57:36 >>>回调事件[910,devices/TL2583]
2024-10-07 15:57:36 >>>故障排除日志:上一MQTT订单号缓存列表为24100715571212721312
2024-10-07 15:57:36 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 15:57:36 开始打印,排队:107,票券:2410071557293158653401,订单:24100715572931582839,[2024-10-07 15:57:35支付宝支付15元]
2024-10-07 15:57:36 开始打印,排队:108,票券:2410071557293158793902,订单:24100715572931582839,[2024-10-07 15:57:35支付宝支付15元]
2024-10-07 15:57:39 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410071557293158653401","queue_number":107,"trade_uid":"24100715572931582839"},{"ticket_no":"2410071557293158793902","queue_number":108,"trade_uid":"24100715572931582839"}]}
2024-10-07 15:57:40 >>>故障排除日志:删除未同步下发订单成功24100715572931582839
2024-10-07 15:57:40 >>>故障排除日志:删除未同步下发订单成功24100715572931582839
2024-10-07 15:57:40 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-07 15:57:45 >>>回调事件[910,devices/TL2583]
2024-10-07 15:57:45 >>>故障排除日志:上一MQTT订单号缓存列表为24100715572931582839|24100715572931582839
2024-10-07 15:57:45 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 15:57:46 开始打印,排队:109,票券:2410071557396161892901,订单:24100715573961614847,[2024-10-07 15:57:45支付宝支付20元]
2024-10-07 15:57:48 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410071557396161892901","queue_number":109,"trade_uid":"24100715573961614847"}]}
2024-10-07 15:57:48 >>>故障排除日志:删除未同步下发订单成功24100715573961614847
2024-10-07 15:57:48 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


===16:06:14===
2024-10-07 16:05:43 >>>回调事件[910,devices/TL2583]
2024-10-07 16:05:43 >>>故障排除日志:上一MQTT订单号缓存列表为24100716024382021867
2024-10-07 16:05:43 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 16:05:43 开始打印,排队:114,票券:2410071605371760661801,订单:24100716053717600143,[2024-10-07 16:05:42微信支付15元]
2024-10-07 16:05:44 开始打印,排队:115,票券:2410071605371761005902,订单:24100716053717600143,[2024-10-07 16:05:42微信支付15元]
2024-10-07 16:05:47 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410071605371760661801","queue_number":114,"trade_uid":"24100716053717600143"},{"ticket_no":"2410071605371761005902","queue_number":115,"trade_uid":"24100716053717600143"}]}
2024-10-07 16:05:47 >>>故障排除日志:删除未同步下发订单成功24100716053717600143
2024-10-07 16:05:47 >>>故障排除日志:删除未同步下发订单成功24100716053717600143
2024-10-07 16:05:47 >>>故障排除日志:终端同步成功后剩余订单列表


===16:10:14===
2024-10-07 16:09:58 >>>回调事件[910,devices/TL2583]
2024-10-07 16:09:58 >>>故障排除日志:上一MQTT订单号缓存列表为24100716053717600143|24100716053717600143
2024-10-07 16:09:58 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 16:09:58 开始打印,排队:116,票券:2410071609504165402701,订单:24100716095041647723,[2024-10-07 16:09:56支付宝支付20元]
2024-10-07 16:10:00 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410071609504165402701","queue_number":116,"trade_uid":"24100716095041647723"}]}
2024-10-07 16:10:00 >>>故障排除日志:删除未同步下发订单成功24100716095041647723
2024-10-07 16:10:00 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


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


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


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


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


===16:52:16===
2024-10-07 16:51:17>>>cash read=00
2024-10-07 16:51:18>>>cash read=818F42
2024-10-07 16:51:18>>>cash write=02
2024-10-07 16:51:18 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-07 16:51:18>>>cash read=10
2024-10-07 16:51:18 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-07 16:51:20>>>cash write=0C
2024-10-07 16:51:20>>>cash read=3E
2024-10-07 16:51:21>>>cash read=00
2024-10-07 16:51:22>>>cash read=29
2024-10-07 16:51:22 >>>回调事件130,cash_status,20029,退钞中
2024-10-07 16:51:22>>>cash read=2F29
2024-10-07 16:51:24>>>cash read=3E
2024-10-07 16:51:25>>>cash read=00
2024-10-07 16:51:26>>>cash read=818F42
2024-10-07 16:51:26>>>cash write=02
2024-10-07 16:51:26 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-07 16:51:26>>>cash read=10
2024-10-07 16:51:26 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-07 16:51:26 当前产品价格20元，投币20元，打印小票中...
2024-10-07 16:51:26 >>>开始打印,排队号为125,订单号为2410071651180025836933
2024-10-07 16:51:27>>>订单2410071651180025836933写入成功,剩余空间为1679000,占用RAM为607.3310546875
删除未同步订单2410071651180025836933
2024-10-07 16:51:29>>>订单2410071651180025836933删除成功,剩余空间为1680000,占用RAM为619.0126953125
检测订单目录中>>>
无未同步订单>>>
2024-10-07 16:51:29 >>>当前Ram内存为590.076171875
定时检测未同步订单启用
2024-10-07 16:51:30>>>cash write=0C
2024-10-07 16:51:30>>>cash read=3E


===16:53:17===
2024-10-07 16:52:24 >>>回调事件[910,devices/TL2583]
2024-10-07 16:52:24 >>>故障排除日志:上一MQTT订单号缓存列表为24100716423436438347
2024-10-07 16:52:24 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 16:52:24 开始打印,排队:126,票券:2410071652106730973401,订单:24100716521067304382,[2024-10-07 16:52:23微信支付20元]
2024-10-07 16:52:26 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410071652106730973401","queue_number":126,"trade_uid":"24100716521067304382"}]}
2024-10-07 16:52:26 >>>故障排除日志:删除未同步下发订单成功24100716521067304382
2024-10-07 16:52:26 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单关闭
检测订单目录中>>>
无未同步订单>>>
2024-10-07 16:52:55 >>>回调事件[910,devices/TL2583]
2024-10-07 16:52:55 >>>故障排除日志:上一MQTT订单号缓存列表为24100716521067304382
2024-10-07 16:52:55 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 16:52:55 开始打印,排队:127,票券:2410071652469811393901,订单:24100716524698109552,[2024-10-07 16:52:54微信支付20元]
2024-10-07 16:52:57 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410071652469811393901","queue_number":127,"trade_uid":"24100716524698109552"}]}
2024-10-07 16:52:57 >>>故障排除日志:删除未同步下发订单成功24100716524698109552
2024-10-07 16:52:57 >>>故障排除日志:终端同步成功后剩余订单列表


===16:54:17===
2024-10-07 16:53:28 >>>回调事件[910,devices/TL2583]
2024-10-07 16:53:28 >>>故障排除日志:上一MQTT订单号缓存列表为24100716524698109552
2024-10-07 16:53:28 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 16:53:28 开始打印,排队:128,票券:2410071653215321354201,订单:24100716532153209773,[2024-10-07 16:53:27微信支付20元]
2024-10-07 16:53:30 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410071653215321354201","queue_number":128,"trade_uid":"24100716532153209773"}]}
2024-10-07 16:53:30 >>>故障排除日志:删除未同步下发订单成功24100716532153209773
2024-10-07 16:53:30 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-07 16:53:36 >>>回调事件[910,devices/TL2583]
2024-10-07 16:53:36 >>>故障排除日志:上一MQTT订单号缓存列表为24100716532153209773
2024-10-07 16:53:36 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 16:53:36 开始打印,排队:129,票券:2410071653274627073401,订单:24100716532746267437,[2024-10-07 16:53:35微信支付20元]
2024-10-07 16:53:38 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410071653274627073401","queue_number":129,"trade_uid":"24100716532746267437"}]}
2024-10-07 16:53:38 >>>故障排除日志:删除未同步下发订单成功24100716532746267437
2024-10-07 16:53:38 >>>故障排除日志:终端同步成功后剩余订单列表


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


===17:11:18===
2024-10-07 17:10:44 >>>剩余flash空间=1682000,占用RAM为634.8330078125
2024-10-07 17:10:44 >>>回调事件:903,keyPress,10000,长按切换键

进入终端自检模式
2024-10-07 17:10:45>>>cash write=30
2024-10-07 17:10:45>>>cash write=02
2024-10-07 17:10:45>>>cash write=3E
2024-10-07 17:10:46>>>cash write=0C
2024-10-07 17:10:47>>>cash read=808F
2024-10-07 17:10:48>>>cash write=02
2024-10-07 17:10:49>>>cash write=0C
2024-10-07 17:10:49>>>cash read=3E


===17:12:18===
2024-10-07 17:11:51 >>>回调事件[910,devices/TL2583]
2024-10-07 17:11:51 >>>故障排除日志:上一MQTT订单号缓存列表为24100717022855931075
2024-10-07 17:11:51 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 17:11:52 开始打印,排队:131,票券:2410071711438598962101,订单:24100717114385981932,[2024-10-07 17:11:50微信支付20元]
2024-10-07 17:11:53 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410071711438598962101","queue_number":131,"trade_uid":"24100717114385981932"}]}
2024-10-07 17:11:53 >>>故障排除日志:删除未同步下发订单成功24100717114385981932
2024-10-07 17:11:53 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-07 17:12:04 >>>回调事件[910,devices/TL2583]
2024-10-07 17:12:04 >>>故障排除日志:上一MQTT订单号缓存列表为24100717114385981932
2024-10-07 17:12:04 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 17:12:04 开始打印,排队:132,票券:2410071711570219121901,订单:24100717115702126459,[2024-10-07 17:12:04微信支付20元]
2024-10-07 17:12:06 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410071711570219121901","queue_number":132,"trade_uid":"24100717115702126459"}]}
2024-10-07 17:12:06 >>>故障排除日志:删除未同步下发订单成功24100717115702126459
2024-10-07 17:12:06 >>>故障排除日志:终端同步成功后剩余订单列表


===17:13:19===
2024-10-07 17:12:44 >>>剩余flash空间=1682000,占用RAM为611.1484375
2024-10-07 17:12:44 >>>回调事件:903,keyPress,10000,退出终端自检模式

退出终端自检模式


===17:16:19===
2024-10-07 17:15:30 >>>回调事件[910,devices/TL2583]
2024-10-07 17:15:30 >>>故障排除日志:上一MQTT订单号缓存列表为24100717115702126459
2024-10-07 17:15:30 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 17:15:31 开始打印,排队:133,票券:2410071715204275035901,订单:24100717152042746318,[2024-10-07 17:15:28支付宝支付20元]
2024-10-07 17:15:33 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410071715204275035901","queue_number":133,"trade_uid":"24100717152042746318"}]}
2024-10-07 17:15:33 >>>故障排除日志:删除未同步下发订单成功24100717152042746318
2024-10-07 17:15:33 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-07 17:15:33 >>>回调事件[910,devices/TL2583]
2024-10-07 17:15:33 >>>故障排除日志:上一MQTT订单号缓存列表为24100717152042746318
2024-10-07 17:15:33 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 17:15:33 开始打印,排队:134,票券:2410071715268978004701,订单:24100717152689774613,[2024-10-07 17:15:33微信支付15元]
2024-10-07 17:15:36 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410071715268978004701","queue_number":134,"trade_uid":"24100717152689774613"}]}
2024-10-07 17:15:36 >>>故障排除日志:删除未同步下发订单成功24100717152689774613
2024-10-07 17:15:36 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


===17:43:20===
2024-10-07 17:43:12 >>>回调事件[910,devices/TL2583]
2024-10-07 17:43:12 >>>故障排除日志:上一MQTT订单号缓存列表为24100717361759233962
2024-10-07 17:43:12 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 17:43:12 开始打印,排队:139,票券:2410071742297833928301,订单:24100717422978334575,[2024-10-07 17:43:11支付宝支付15元]
2024-10-07 17:43:12 开始打印,排队:140,票券:2410071742297834081202,订单:24100717422978334575,[2024-10-07 17:43:11支付宝支付15元]
2024-10-07 17:43:15 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410071742297833928301","queue_number":139,"trade_uid":"24100717422978334575"},{"ticket_no":"2410071742297834081202","queue_number":140,"trade_uid":"24100717422978334575"}]}
2024-10-07 17:43:15 >>>故障排除日志:删除未同步下发订单成功24100717422978334575
2024-10-07 17:43:15 >>>故障排除日志:删除未同步下发订单成功24100717422978334575
2024-10-07 17:43:16 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


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


===18:00:23===
2024-10-07 18:00:20 >>>回调事件[910,devices/TL2583]
2024-10-07 18:00:20 >>>故障排除日志:上一MQTT订单号缓存列表为24100717534329108835
2024-10-07 18:00:20 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 18:00:20 开始打印,排队:147,票券:2410071800123679152401,订单:24100718001236785816,[2024-10-07 18:00:19微信支付15元]


===18:01:23===
2024-10-07 18:00:21 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410071800123679152401","queue_number":147,"trade_uid":"24100718001236785816"}]}
2024-10-07 18:00:21 >>>故障排除日志:删除未同步下发订单成功24100718001236785816
2024-10-07 18:00:22 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


===18:22:10===
2024-10-07 18:22:08 >>>剩余flash空间=1682000,占用RAM为625.77734375
2024-10-07 18:22:08 >>>回调异常:911,initSys,30000,nil



===18:23:11===
上一时间戳为1728264961
当日首次设置时间戳true为1728296537
今日nvm排队号为151
当前排队号为151,音量为5
初始化产品信息:[{"time_limit_date":null,"ticket_category":"0","expiry_date":365,"product_detail":"","time_limit_status":"0","begin_minute":null,"product_uid":"97679315402183683","use_timer":1,"old_price":"20","end_hour":null,"sale_price":"20","end_minute":null,"begin_hour":null,"sale_status":1,"product_name":"成人票"},{"time_limit_date":null,"ticket_category":"0","expiry_date":90,"product_detail":"","time_limit_status":"0","begin_minute":null,"product_uid":"98628273993276813","use_timer":1,"old_price":"15","end_hour":null,"sale_price":"15","end_minute":null,"begin_hour":null,"sale_status":1,"product_name":"儿童票"}]
打印门店标题设置为美和百货店
是否打印二维码设置为1
是否打印紧凑设置为3
session_id:12888****fa7d2
纸币器设置接收纸币范围为36
欢迎使用天羚自助售票系统[2.5.4]
定时检测未同步订单启用
2024-10-07 18:22:17>>>cash write=30
2024-10-07 18:22:17>>>cash write=02
2024-10-07 18:22:17>>>cash write=3E
2024-10-07 18:22:17>>>cash read=808F808F808F808F808F808F808F808F808F
系统时间初始化成功，时间为2024107182217
2024-10-07 18:22:18>>>cash write=02
2024-10-07 18:22:18 >>>剩余flash空间=1680000,占用RAM为631.126953125
2024-10-07 18:22:18 >>>回调事件:910,subscribe,10000,连接服务器成功

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

2024-10-07 18:22:21>>>cash write=0C
2024-10-07 18:22:21>>>cash read=3E
流量卡还有23天过期
2024-10-07 18:22:29 >>>当前Ram内存为638.119140625


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


===18:26:12===
2024-10-07 18:25:39 >>>回调事件[910,devices/TL2583]
2024-10-07 18:25:39 >>>故障排除日志:上一MQTT订单号缓存列表为24100718171841774541
2024-10-07 18:25:39 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 18:25:39 开始打印,排队:151,票券:2410071825323318491201,订单:24100718253233179239,[2024-10-07 18:25:38微信支付20元]
2024-10-07 18:25:41 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410071825323318491201","queue_number":151,"trade_uid":"24100718253233179239"}]}
2024-10-07 18:25:41 >>>故障排除日志:删除未同步下发订单成功24100718253233179239
2024-10-07 18:25:41 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-07 18:25:58 >>>回调事件[910,devices/TL2583]
2024-10-07 18:25:58 >>>故障排除日志:上一MQTT订单号缓存列表为24100718253233179239
2024-10-07 18:25:58 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 18:25:58 开始打印,排队:152,票券:2410071825516186496101,订单:24100718255161861291,[2024-10-07 18:25:57微信支付15元]
2024-10-07 18:26:00 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410071825516186496101","queue_number":152,"trade_uid":"24100718255161861291"}]}
2024-10-07 18:26:00 >>>故障排除日志:删除未同步下发订单成功24100718255161861291
2024-10-07 18:26:00 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


===18:40:02===
2024-10-07 18:39:53 >>>剩余flash空间=1682000,占用RAM为620.8935546875
2024-10-07 18:39:53 >>>回调异常:911,initSys,30000,nil



===18:41:02===
上一时间戳为1728296537
当日首次设置时间戳true为1728297606
今日nvm排队号为156
当前排队号为156,音量为5
初始化产品信息:[{"time_limit_date":null,"ticket_category":"0","expiry_date":365,"product_detail":"","time_limit_status":"0","begin_minute":null,"product_uid":"97679315402183683","use_timer":1,"old_price":"20","end_hour":null,"sale_price":"20","end_minute":null,"begin_hour":null,"sale_status":1,"product_name":"成人票"},{"time_limit_date":null,"ticket_category":"0","expiry_date":90,"product_detail":"","time_limit_status":"0","begin_minute":null,"product_uid":"98628273993276813","use_timer":1,"old_price":"15","end_hour":null,"sale_price":"15","end_minute":null,"begin_hour":null,"sale_status":1,"product_name":"儿童票"}]
打印门店标题设置为美和百货店
是否打印二维码设置为1
是否打印紧凑设置为3
session_id:dd282****8f3f1
纸币器设置接收纸币范围为36
欢迎使用天羚自助售票系统[2.5.4]
定时检测未同步订单启用
2024-10-07 18:40:06>>>cash write=30
2024-10-07 18:40:06>>>cash write=02
2024-10-07 18:40:06>>>cash write=3E
2024-10-07 18:40:06>>>cash read=808F808F808F808F808F808F808F808F
系统时间初始化成功，时间为202410718406
2024-10-07 18:40:07>>>cash write=02
2024-10-07 18:40:07 >>>剩余flash空间=1680000,占用RAM为629.7099609375
2024-10-07 18:40:07 >>>回调事件:910,subscribe,10000,连接服务器成功

请求下发消息结果为0,下发成功
2024-10-07 18:40:08 >>>回调事件[910,devices/TL2583]
2024-10-07 18:40:08 >>>故障排除日志:上一MQTT订单号缓存列表为24100718315880911597
2024-10-07 18:40:08 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 18:40:08 开始打印,排队:156,票券:2410071839391415437401,订单:24100718393914150612,[2024-10-07 18:39:44微信支付15元]
2024-10-07 18:40:10 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410071839391415437401","queue_number":156,"trade_uid":"24100718393914150612"}]}
2024-10-07 18:40:10 >>>故障排除日志:删除未同步下发订单成功24100718393914150612
2024-10-07 18:40:10 >>>故障排除日志:终端同步成功后剩余订单列表
流量卡还有23天过期
2024-10-07 18:40:11>>>cash write=0C
2024-10-07 18:40:11>>>cash read=3E
2024-10-07 18:40:20 >>>当前Ram内存为649.580078125


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


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


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


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


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


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


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


===19:04:04===
2024-10-07 19:03:16 >>>回调事件[910,devices/TL2583]
2024-10-07 19:03:16 >>>故障排除日志:上一MQTT订单号缓存列表为24100719004692037992
2024-10-07 19:03:16 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 19:03:16 开始打印,排队:163,票券:2410071903082458418301,订单:24100719030824579895,[2024-10-07 19:03:15微信支付15元]
2024-10-07 19:03:18 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410071903082458418301","queue_number":163,"trade_uid":"24100719030824579895"}]}
2024-10-07 19:03:18 >>>故障排除日志:删除未同步下发订单成功24100719030824579895
2024-10-07 19:03:18 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-07 19:03:45 >>>回调事件[910,devices/TL2583]
2024-10-07 19:03:45 >>>故障排除日志:上一MQTT订单号缓存列表为24100719030824579895
2024-10-07 19:03:45 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 19:03:45 开始打印,排队:164,票券:2410071903328550581701,订单:24100719033285501439,[2024-10-07 19:03:43微信支付20元]
2024-10-07 19:03:47 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410071903328550581701","queue_number":164,"trade_uid":"24100719033285501439"}]}
2024-10-07 19:03:47 >>>故障排除日志:删除未同步下发订单成功24100719033285501439
2024-10-07 19:03:47 >>>故障排除日志:终端同步成功后剩余订单列表


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


===19:09:05===
2024-10-07 19:08:18 >>>回调事件[910,devices/TL2583]
2024-10-07 19:08:18 >>>故障排除日志:上一MQTT订单号缓存列表为24100719040263967348
2024-10-07 19:08:18 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 19:08:18 开始打印,排队:166,票券:2410071908094359692101,订单:24100719080943590772,[2024-10-07 19:08:17支付宝支付15元]
2024-10-07 19:08:20 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410071908094359692101","queue_number":166,"trade_uid":"24100719080943590772"}]}
2024-10-07 19:08:20 >>>故障排除日志:删除未同步下发订单成功24100719080943590772
2024-10-07 19:08:20 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-07 19:08:40 >>>回调事件[910,devices/TL2583]
2024-10-07 19:08:40 >>>故障排除日志:上一MQTT订单号缓存列表为24100719080943590772
2024-10-07 19:08:40 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 19:08:40 开始打印,排队:167,票券:2410071908330222668401,订单:24100719083302222341,[2024-10-07 19:08:38支付宝支付20元]
2024-10-07 19:08:42 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410071908330222668401","queue_number":167,"trade_uid":"24100719083302222341"}]}
2024-10-07 19:08:42 >>>故障排除日志:删除未同步下发订单成功24100719083302222341
2024-10-07 19:08:42 >>>故障排除日志:终端同步成功后剩余订单列表


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


===19:12:05===
2024-10-07 19:11:46 >>>回调事件[910,devices/TL2583]
2024-10-07 19:11:46 >>>故障排除日志:上一MQTT订单号缓存列表为24100719092393853249
2024-10-07 19:11:46 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 19:11:46 开始打印,排队:169,票券:2410071911411059637601,订单:24100719114110591586,[2024-10-07 19:11:45支付宝支付20元]
2024-10-07 19:11:48 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410071911411059637601","queue_number":169,"trade_uid":"24100719114110591586"}]}
2024-10-07 19:11:48 >>>故障排除日志:删除未同步下发订单成功24100719114110591586
2024-10-07 19:11:48 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-07 19:11:55 >>>回调事件[910,devices/TL2583]
2024-10-07 19:11:55 >>>故障排除日志:上一MQTT订单号缓存列表为24100719114110591586
2024-10-07 19:11:55 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 19:11:55 开始打印,排队:170,票券:2410071911485438123601,订单:24100719114854377423,[2024-10-07 19:11:54微信支付20元]
2024-10-07 19:11:57 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410071911485438123601","queue_number":170,"trade_uid":"24100719114854377423"}]}
2024-10-07 19:11:57 >>>故障排除日志:删除未同步下发订单成功24100719114854377423
2024-10-07 19:11:57 >>>故障排除日志:终端同步成功后剩余订单列表


===19:17:06===
2024-10-07 19:16:56 >>>剩余flash空间=1682000,占用RAM为645.3251953125
2024-10-07 19:16:56 >>>回调事件:903,keyPress,10000,长按切换键

进入终端自检模式
2024-10-07 19:16:57>>>cash write=30
2024-10-07 19:16:57>>>cash write=02
2024-10-07 19:16:57>>>cash write=3E
2024-10-07 19:16:58>>>cash write=0C
2024-10-07 19:16:59>>>cash read=808F
2024-10-07 19:17:00>>>cash write=02
2024-10-07 19:17:01>>>cash write=0C
2024-10-07 19:17:01>>>cash read=3E


===19:19:06===
2024-10-07 19:18:56 >>>剩余flash空间=1682000,占用RAM为640.888671875
2024-10-07 19:18:56 >>>回调事件:903,keyPress,10000,退出终端自检模式

退出终端自检模式


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


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


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


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


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


===19:37:08===
2024-10-07 19:36:12 >>>回调事件[910,devices/TL2583]
2024-10-07 19:36:12 >>>故障排除日志:上一MQTT订单号缓存列表为24100719322472063292
2024-10-07 19:36:12 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 19:36:12 开始打印,排队:176,票券:2410071936051133104301,订单:24100719360511327116,[2024-10-07 19:36:11微信支付15元]
2024-10-07 19:36:14 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410071936051133104301","queue_number":176,"trade_uid":"24100719360511327116"}]}
2024-10-07 19:36:14 >>>故障排除日志:删除未同步下发订单成功24100719360511327116
2024-10-07 19:36:14 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-07 19:36:38 >>>回调事件[910,devices/TL2583]
2024-10-07 19:36:38 >>>故障排除日志:上一MQTT订单号缓存列表为24100719360511327116
2024-10-07 19:36:38 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 19:36:38 开始打印,排队:177,票券:2410071936282538216201,订单:24100719362825377256,[2024-10-07 19:36:36支付宝支付20元]
2024-10-07 19:36:40 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410071936282538216201","queue_number":177,"trade_uid":"24100719362825377256"}]}
2024-10-07 19:36:40 >>>故障排除日志:删除未同步下发订单成功24100719362825377256
2024-10-07 19:36:40 >>>故障排除日志:终端同步成功后剩余订单列表


===19:43:08===
2024-10-07 19:42:24 >>>回调事件[910,devices/TL2583]
2024-10-07 19:42:24 >>>故障排除日志:上一MQTT订单号缓存列表为24100719362825377256
2024-10-07 19:42:24 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 19:42:24 开始打印,排队:178,票券:2410071942148140885301,订单:24100719421481403965,[2024-10-07 19:42:22微信支付20元]
2024-10-07 19:42:25 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410071942148140885301","queue_number":178,"trade_uid":"24100719421481403965"}]}
2024-10-07 19:42:26 >>>故障排除日志:删除未同步下发订单成功24100719421481403965
2024-10-07 19:42:26 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-07 19:42:44 >>>回调事件[910,devices/TL2583]
2024-10-07 19:42:44 >>>故障排除日志:上一MQTT订单号缓存列表为24100719421481403965
2024-10-07 19:42:44 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 19:42:44 开始打印,排队:179,票券:2410071942370845824601,订单:24100719423708454695,[2024-10-07 19:42:43微信支付15元]
2024-10-07 19:42:46 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410071942370845824601","queue_number":179,"trade_uid":"24100719423708454695"}]}
2024-10-07 19:42:46 >>>故障排除日志:删除未同步下发订单成功24100719423708454695
2024-10-07 19:42:46 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-07 19:43:01 >>>回调事件[910,devices/TL2583]
2024-10-07 19:43:01 >>>故障排除日志:上一MQTT订单号缓存列表为24100719423708454695
2024-10-07 19:43:01 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 19:43:01 开始打印,排队:180,票券:2410071942546373013501,订单:24100719425463726885,[2024-10-07 19:43:00微信支付20元]
2024-10-07 19:43:03 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410071942546373013501","queue_number":180,"trade_uid":"24100719425463726885"}]}
2024-10-07 19:43:03 >>>故障排除日志:删除未同步下发订单成功24100719425463726885
2024-10-07 19:43:03 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


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


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


===20:06:10===
2024-10-07 20:05:15 >>>回调事件[910,devices/TL2583]
2024-10-07 20:05:15 >>>故障排除日志:上一MQTT订单号缓存列表为24100720042388231971
2024-10-07 20:05:15 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 20:05:15 开始打印,排队:187,票券:2410072005074973831901,订单:24100720050749734246,[2024-10-07 20:05:15微信支付15元]
2024-10-07 20:05:17 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410072005074973831901","queue_number":187,"trade_uid":"24100720050749734246"}]}
2024-10-07 20:05:17 >>>故障排除日志:删除未同步下发订单成功24100720050749734246
2024-10-07 20:05:18 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-07 20:05:49 >>>回调事件[910,devices/TL2583]
2024-10-07 20:05:49 >>>故障排除日志:上一MQTT订单号缓存列表为24100720050749734246
2024-10-07 20:05:49 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 20:05:49 开始打印,排队:188,票券:2410072005418822482101,订单:24100720054188220227,[2024-10-07 20:05:47微信支付20元]
2024-10-07 20:05:51 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410072005418822482101","queue_number":188,"trade_uid":"24100720054188220227"}]}
2024-10-07 20:05:51 >>>故障排除日志:删除未同步下发订单成功24100720054188220227
2024-10-07 20:05:51 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


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


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


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


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


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


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


===21:08:14===
2024-10-07 21:08:12 >>>剩余flash空间=1682000,占用RAM为621.8564453125
2024-10-07 21:08:12 >>>回调异常:911,initSys,30000,nil



===21:09:14===
上一时间戳为1728297606
当日首次设置时间戳true为1728306501
今日nvm排队号为199
当前排队号为199,音量为5
初始化产品信息:[{"time_limit_date":null,"ticket_category":"0","expiry_date":365,"product_detail":"","time_limit_status":"0","begin_minute":null,"product_uid":"97679315402183683","use_timer":1,"old_price":"20","end_hour":null,"sale_price":"20","end_minute":null,"begin_hour":null,"sale_status":1,"product_name":"成人票"},{"time_limit_date":null,"ticket_category":"0","expiry_date":90,"product_detail":"","time_limit_status":"0","begin_minute":null,"product_uid":"98628273993276813","use_timer":1,"old_price":"15","end_hour":null,"sale_price":"15","end_minute":null,"begin_hour":null,"sale_status":1,"product_name":"儿童票"}]
打印门店标题设置为美和百货店
是否打印二维码设置为1
是否打印紧凑设置为3
session_id:89cbe****b7f05
纸币器设置接收纸币范围为36
欢迎使用天羚自助售票系统[2.5.4]
定时检测未同步订单启用
2024-10-07 21:08:21>>>cash write=30
2024-10-07 21:08:21>>>cash write=02
2024-10-07 21:08:21>>>cash write=3E
2024-10-07 21:08:21>>>cash read=808F808F808F808F808F808F808F808F
系统时间初始化成功，时间为202410721821
2024-10-07 21:08:21 >>>剩余flash空间=1679500,占用RAM为602.927734375
2024-10-07 21:08:21 >>>回调异常:910,connect,30006,fail

2024-10-07 21:08:21 >>>MQTT连接断开，尝试重连中
2024-10-07 21:08:22>>>cash write=02
2024-10-07 21:08:25>>>cash write=0C
2024-10-07 21:08:25>>>cash read=3E
流量卡还有23天过期
2024-10-07 21:08:32 >>>剩余flash空间=1679000,占用RAM为624.1181640625
2024-10-07 21:08:32 >>>回调事件:910,subscribe,10000,连接服务器成功

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

2024-10-07 21:08:33 >>>当前Ram内存为597.0322265625


TCP://post-cn-09k20cnrl07.mqtt.aliyuncs.com:1883@07_21:08:21:connect fail
===21:10:15===
定时检测未同步订单关闭
检测订单目录中>>>
无未同步订单>>>


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


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


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


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


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


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


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


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