TLClient_JSSCOM_LuatOS-Air_V4010_RDA8910_RFTTS_0xe0000,2.5.4,866250069016420,35264572771295,
poweron reason:0

===08:47:05===
上一时间戳为1728177437
隔日重置时间戳true
隔日清空未同步下发列表true
当前排队号为1,音量为5
初始化产品信息:[{"time_limit_date":"","ticket_category":"0","expiry_date":7,"product_detail":"请在当天使用","time_limit_status":"0","begin_minute":"00","product_uid":"4351590954437097166","use_timer":1,"old_price":"10","end_hour":"23","sale_price":"10","end_minute":"59","begin_hour":"00","sale_status":1,"product_name":"快速剪发"}]
打印门店标题设置为星客多快剪
是否打印二维码设置为1
是否打印紧凑设置为3
session_id:b620d****2b873
纸币器设置接收纸币范围为36
欢迎使用天羚自助售票系统[2.5.4]
定时检测未同步订单启用
2024-10-07 08:46:05>>>cash write=30
2024-10-07 08:46:05>>>cash write=02
2024-10-07 08:46:05>>>cash write=3E
2024-10-07 08:46:05>>>cash read=808F808F808F808F
系统时间初始化成功，时间为20241078465
2024-10-07 08:46:06>>>cash write=02
2024-10-07 08:46:06 >>>剩余flash空间=1680500,占用RAM为628.9345703125
2024-10-07 08:46:06 >>>回调事件:910,subscribe,10000,连接服务器成功

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

2024-10-07 08:46:09>>>cash write=0C
2024-10-07 08:46:09>>>cash read=3E
流量卡还有144天过期
2024-10-07 08:46:13 >>>当前Ram内存为629.2275390625


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


===08:52:06===
2024-10-07 08:51:48>>>cash read=00
2024-10-07 08:51:50>>>cash read=2F29
2024-10-07 08:51:52>>>cash read=3E
2024-10-07 08:51:53>>>cash read=00
2024-10-07 08:51:54>>>cash read=29
2024-10-07 08:51:54 >>>回调事件130,cash_status,20029,退钞中
2024-10-07 08:51:54>>>cash read=2F29
2024-10-07 08:51:56>>>cash read=3E


===08:53:06===
2024-10-07 08:52:06>>>cash read=00
2024-10-07 08:52:06>>>cash read=818F42
2024-10-07 08:52:06>>>cash write=02
2024-10-07 08:52:06 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-07 08:52:07>>>cash read=10
2024-10-07 08:52:07 >>>回调事件130,10,10023,finish Money=10,进钞完成
当日首次设置时间戳true为1728262327
2024-10-07 08:52:07 当前产品价格10元，投币10元，打印小票中...
2024-10-07 08:52:07 >>>开始打印,排队号为1,订单号为2410070852070018891262
2024-10-07 08:52:07>>>订单2410070852070018891262写入成功,剩余空间为1679500,占用RAM为607.8310546875
删除未同步订单2410070852070018891262
2024-10-07 08:52:09>>>订单2410070852070018891262删除成功,剩余空间为1680500,占用RAM为621.3125
检测订单目录中>>>
无未同步订单>>>
2024-10-07 08:52:09 >>>当前Ram内存为590.453125
定时检测未同步订单启用
2024-10-07 08:52:10>>>cash write=0C
2024-10-07 08:52:10>>>cash read=3E


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


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


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


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


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


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


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


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


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


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


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


===10:14:10===
2024-10-07 10:13:56>>>cash read=9E
2024-10-07 10:13:58>>>cash read=3E


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


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


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


===10:32:11===
2024-10-07 10:31:45>>>cash read=9E
2024-10-07 10:31:47>>>cash read=3E


===10:33:11===
2024-10-07 10:32:32>>>cash read=00
2024-10-07 10:32:33>>>cash read=29
2024-10-07 10:32:33 >>>回调事件130,cash_status,20029,退钞中
2024-10-07 10:32:34>>>cash read=01
2024-10-07 10:32:35>>>cash read=3E
2024-10-07 10:32:46>>>cash read=00
2024-10-07 10:32:47>>>cash read=818F42
2024-10-07 10:32:47>>>cash write=02
2024-10-07 10:32:47 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-07 10:32:48>>>cash read=10
2024-10-07 10:32:48 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-07 10:32:48 当前产品价格10元，投币10元，打印小票中...
2024-10-07 10:32:48 >>>开始打印,排队号为14,订单号为2410071032480018892141
2024-10-07 10:32:48>>>订单2410071032480018892141写入成功,剩余空间为1679500,占用RAM为609.208984375
删除未同步订单2410071032480018892141
2024-10-07 10:32:50>>>订单2410071032480018892141删除成功,剩余空间为1680500,占用RAM为620.4853515625
检测订单目录中>>>
无未同步订单>>>
2024-10-07 10:32:50 >>>当前Ram内存为590.98828125
定时检测未同步订单启用
2024-10-07 10:32:51>>>cash write=0C
2024-10-07 10:32:51>>>cash read=3E


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


===10:58:12===
2024-10-07 10:57:33 >>>回调事件[910,devices/TL1889]
2024-10-07 10:57:33 >>>故障排除日志:上一MQTT订单号缓存列表为24100710304169661886
2024-10-07 10:57:33 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 10:57:33 开始打印,排队:15,票券:2410071057253005977801,订单:24100710572530055474,[2024-10-07 10:57:31微信支付10元]
2024-10-07 10:57:35 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410071057253005977801","queue_number":15,"trade_uid":"24100710572530055474"}]}
2024-10-07 10:57:35 >>>故障排除日志:删除未同步下发订单成功24100710572530055474
2024-10-07 10:57:35 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-07 10:57:43 >>>回调事件[910,devices/TL1889]
2024-10-07 10:57:43 >>>故障排除日志:上一MQTT订单号缓存列表为24100710572530055474
2024-10-07 10:57:43 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 10:57:43 开始打印,排队:16,票券:2410071057354430628901,订单:24100710573544301637,[2024-10-07 10:57:41微信支付10元]
2024-10-07 10:57:45 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410071057354430628901","queue_number":16,"trade_uid":"24100710573544301637"}]}
2024-10-07 10:57:45 >>>故障排除日志:删除未同步下发订单成功24100710573544301637
2024-10-07 10:57:45 >>>故障排除日志:终端同步成功后剩余订单列表


===11:09:12===
2024-10-07 11:09:02>>>cash read=9E
2024-10-07 11:09:03>>>cash read=3E


===11:12:12===
2024-10-07 11:11:12>>>cash read=0A
2024-10-07 11:11:13>>>cash read=3E


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


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


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


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


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


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


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


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


===13:02:15===
2024-10-07 13:02:07 >>>回调事件[910,devices/TL1889]
2024-10-07 13:02:07 >>>故障排除日志:上一MQTT订单号缓存列表为24100712345804999264
2024-10-07 13:02:07 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 13:02:07 开始打印,排队:24,票券:2410071301594271788201,订单:24100713015942711628,[2024-10-07 13:02:05微信支付10元]
2024-10-07 13:02:07 开始打印,排队:25,票券:2410071301594271933502,订单:24100713015942711628,[2024-10-07 13:02:05微信支付10元]
2024-10-07 13:02:11 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410071301594271788201","queue_number":24,"trade_uid":"24100713015942711628"},{"ticket_no":"2410071301594271933502","queue_number":25,"trade_uid":"24100713015942711628"}]}
2024-10-07 13:02:11 >>>故障排除日志:删除未同步下发订单成功24100713015942711628
2024-10-07 13:02:11 >>>故障排除日志:删除未同步下发订单成功24100713015942711628
2024-10-07 13:02:11 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-07 13:02:11>>>cash read=00
2024-10-07 13:02:12>>>cash read=818F41
2024-10-07 13:02:12>>>cash write=02
2024-10-07 13:02:12 >>>回调事件130,cash_status,10022,进钞中...read money=5
2024-10-07 13:02:12>>>cash read=10
2024-10-07 13:02:13 >>>回调事件130,5,10023,finish Money=5,进钞完成
2024-10-07 13:02:14>>>cash read=2F29


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


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


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


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


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


===13:16:17===
2024-10-07 13:15:44 >>>回调事件[910,devices/TL1889]
2024-10-07 13:15:44 >>>故障排除日志:上一MQTT订单号缓存列表为24100713070389136116
2024-10-07 13:15:44 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 13:15:44 开始打印,排队:29,票券:2410071315351171937201,订单:24100713153511715641,[2024-10-07 13:15:42微信支付10元]
2024-10-07 13:15:46 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410071315351171937201","queue_number":29,"trade_uid":"24100713153511715641"}]}
2024-10-07 13:15:46 >>>故障排除日志:删除未同步下发订单成功24100713153511715641
2024-10-07 13:15:46 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-07 13:15:58 >>>回调事件[910,devices/TL1889]
2024-10-07 13:15:58 >>>故障排除日志:上一MQTT订单号缓存列表为24100713153511715641
2024-10-07 13:15:58 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 13:15:58 开始打印,排队:30,票券:2410071315494811737301,订单:24100713154948112581,[2024-10-07 13:15:56微信支付10元]
2024-10-07 13:15:58 开始打印,排队:31,票券:2410071315494811925902,订单:24100713154948112581,[2024-10-07 13:15:56微信支付10元]
2024-10-07 13:16:02 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410071315494811737301","queue_number":30,"trade_uid":"24100713154948112581"},{"ticket_no":"2410071315494811925902","queue_number":31,"trade_uid":"24100713154948112581"}]}
2024-10-07 13:16:02 >>>故障排除日志:删除未同步下发订单成功24100713154948112581
2024-10-07 13:16:02 >>>故障排除日志:删除未同步下发订单成功24100713154948112581
2024-10-07 13:16:02 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


===13:44:18===
2024-10-07 13:44:17>>>cash read=9E


===13:45:19===
2024-10-07 13:44:18>>>cash read=3E


===13:50:19===
2024-10-07 13:49:59 >>>回调事件[910,devices/TL1889]
2024-10-07 13:49:59 >>>故障排除日志:上一MQTT订单号缓存列表为24100713154948112581|24100713154948112581
2024-10-07 13:49:59 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 13:49:59 开始打印,排队:33,票券:2410071349434429392101,订单:24100713494344289174,[2024-10-07 13:49:58支付宝支付10元]
2024-10-07 13:50:01 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410071349434429392101","queue_number":33,"trade_uid":"24100713494344289174"}]}
2024-10-07 13:50:01 >>>故障排除日志:删除未同步下发订单成功24100713494344289174
2024-10-07 13:50:02 >>>故障排除日志:终端同步成功后剩余订单列表


===13:56:19===
2024-10-07 13:55:29>>>cash read=00
2024-10-07 13:55:30>>>cash read=818F40
2024-10-07 13:55:30>>>cash write=02
2024-10-07 13:55:30 >>>回调事件130,cash_status,10022,进钞中...read money=1
2024-10-07 13:55:30>>>cash read=10
2024-10-07 13:55:30 >>>回调事件130,1,10023,finish Money=1,进钞完成
2024-10-07 13:55:31>>>cash write=0C
2024-10-07 13:55:31>>>cash read=00
2024-10-07 13:55:32>>>cash read=818F40
2024-10-07 13:55:32>>>cash write=02
2024-10-07 13:55:32 >>>回调事件130,cash_status,10022,进钞中...read money=1
2024-10-07 13:55:33>>>cash read=10
2024-10-07 13:55:33 >>>回调事件130,1,10023,finish Money=1,进钞完成
2024-10-07 13:55:34>>>cash write=0C
2024-10-07 13:55:34>>>cash read=00
2024-10-07 13:55:35>>>cash read=2F29
2024-10-07 13:55:36>>>cash read=00
2024-10-07 13:55:37>>>cash read=818F40
2024-10-07 13:55:37>>>cash write=02
2024-10-07 13:55:37 >>>回调事件130,cash_status,10022,进钞中...read money=1
2024-10-07 13:55:37>>>cash read=10
2024-10-07 13:55:37 >>>回调事件130,1,10023,finish Money=1,进钞完成
2024-10-07 13:55:39>>>cash write=0C
2024-10-07 13:55:39>>>cash read=3E
2024-10-07 13:55:40>>>cash read=00
2024-10-07 13:55:40>>>cash read=818F40
2024-10-07 13:55:40>>>cash write=02
2024-10-07 13:55:40 >>>回调事件130,cash_status,10022,进钞中...read money=1
2024-10-07 13:55:41>>>cash read=10
2024-10-07 13:55:41 >>>回调事件130,1,10023,finish Money=1,进钞完成
2024-10-07 13:55:42>>>cash write=0C
2024-10-07 13:55:42>>>cash read=3E
2024-10-07 13:55:46>>>cash read=29
2024-10-07 13:55:46 >>>回调事件130,cash_status,20029,退钞中
2024-10-07 13:55:47>>>cash read=3E
2024-10-07 13:55:51>>>cash read=00
2024-10-07 13:55:52>>>cash read=818F40
2024-10-07 13:55:52>>>cash write=02
2024-10-07 13:55:52 >>>回调事件130,cash_status,10022,进钞中...read money=1
2024-10-07 13:55:53>>>cash read=10
2024-10-07 13:55:53 >>>回调事件130,1,10023,finish Money=1,进钞完成
2024-10-07 13:55:54>>>cash write=0C
2024-10-07 13:55:54>>>cash read=3E
2024-10-07 13:55:55>>>cash read=00
2024-10-07 13:55:56>>>cash read=818F41
2024-10-07 13:55:56>>>cash write=02
2024-10-07 13:55:56 >>>回调事件130,cash_status,10022,进钞中...read money=5
2024-10-07 13:55:56>>>cash read=10
2024-10-07 13:55:56 >>>回调事件130,5,10023,finish Money=5,进钞完成
2024-10-07 13:55:57 当前产品价格10元，投币10元，打印小票中...
2024-10-07 13:55:57 >>>开始打印,排队号为34,订单号为2410071355530018891643
2024-10-07 13:55:57>>>订单2410071355530018891643写入成功,剩余空间为1677500,占用RAM为615.37890625
删除未同步订单2410071355530018891643
2024-10-07 13:55:59>>>订单2410071355530018891643删除成功,剩余空间为1678500,占用RAM为628.515625
检测订单目录中>>>
无未同步订单>>>
2024-10-07 13:55:59 >>>当前Ram内存为592.9560546875
定时检测未同步订单启用
2024-10-07 13:56:00>>>cash write=0C
2024-10-07 13:56:00>>>cash read=3E


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


===14:20:20===
2024-10-07 14:19:53>>>cash read=00
2024-10-07 14:19:54>>>cash read=2F29
2024-10-07 14:19:55>>>cash read=00
2024-10-07 14:19:56>>>cash read=818F42
2024-10-07 14:19:56>>>cash write=02
2024-10-07 14:19:56 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-07 14:19:56>>>cash read=10
2024-10-07 14:19:56 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-07 14:19:56 当前产品价格10元，投币10元，打印小票中...
2024-10-07 14:19:56 >>>开始打印,排队号为35,订单号为2410071419560018892609
2024-10-07 14:19:56>>>订单2410071419560018892609写入成功,剩余空间为1679500,占用RAM为608.2822265625
删除未同步订单2410071419560018892609
2024-10-07 14:19:59>>>订单2410071419560018892609删除成功,剩余空间为1680500,占用RAM为620.126953125
检测订单目录中>>>
无未同步订单>>>
2024-10-07 14:19:59 >>>当前Ram内存为590.6650390625
定时检测未同步订单启用
2024-10-07 14:20:00>>>cash write=0C
2024-10-07 14:20:00>>>cash read=3E


===14:21:20===
2024-10-07 14:20:50 >>>回调事件[910,devices/TL1889]
2024-10-07 14:20:50 >>>故障排除日志:上一MQTT订单号缓存列表为24100713494344289174
2024-10-07 14:20:50 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 14:20:50 开始打印,排队:36,票券:2410071420415829161601,订单:24100714204158287612,[2024-10-07 14:20:48微信支付10元]
2024-10-07 14:20:50 开始打印,排队:37,票券:2410071420415829314802,订单:24100714204158287612,[2024-10-07 14:20:48微信支付10元]
2024-10-07 14:20:54 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410071420415829161601","queue_number":36,"trade_uid":"24100714204158287612"},{"ticket_no":"2410071420415829314802","queue_number":37,"trade_uid":"24100714204158287612"}]}
2024-10-07 14:20:54 >>>故障排除日志:删除未同步下发订单成功24100714204158287612
2024-10-07 14:20:54 >>>故障排除日志:删除未同步下发订单成功24100714204158287612
2024-10-07 14:20:54 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单关闭
检测订单目录中>>>
无未同步订单>>>


===14:22:21===
2024-10-07 14:21:49 >>>回调事件[910,devices/TL1889]
2024-10-07 14:21:49 >>>故障排除日志:上一MQTT订单号缓存列表为24100714204158287612|24100714204158287612
2024-10-07 14:21:49 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 14:21:49 开始打印,排队:38,票券:2410071421429940214301,订单:24100714214299396376,[2024-10-07 14:21:48微信支付10元]
2024-10-07 14:21:51 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410071421429940214301","queue_number":38,"trade_uid":"24100714214299396376"}]}
2024-10-07 14:21:51 >>>故障排除日志:删除未同步下发订单成功24100714214299396376
2024-10-07 14:21:51 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-07 14:21:53 >>>回调事件[910,devices/TL1889]
2024-10-07 14:21:53 >>>故障排除日志:上一MQTT订单号缓存列表为24100714214299396376
2024-10-07 14:21:53 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 14:21:53 开始打印,排队:39,票券:2410071421472032119101,订单:24100714214720317315,[2024-10-07 14:21:52微信支付10元]
2024-10-07 14:21:55 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410071421472032119101","queue_number":39,"trade_uid":"24100714214720317315"}]}
2024-10-07 14:21:55 >>>故障排除日志:删除未同步下发订单成功24100714214720317315
2024-10-07 14:21:55 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


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


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


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


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


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


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


===15:29:24===
2024-10-07 15:29:02 >>>回调事件[910,devices/TL1889]
2024-10-07 15:29:02 >>>故障排除日志:上一MQTT订单号缓存列表为24100715215638737297
2024-10-07 15:29:02 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 15:29:02 开始打印,排队:49,票券:2410071528555185182301,订单:24100715285551847212,[2024-10-07 15:29:01微信支付10元]
2024-10-07 15:29:04 >>>回调事件[910,devices/TL1889]
2024-10-07 15:29:04 >>>故障排除日志:上一MQTT订单号缓存列表为24100715285551847212
2024-10-07 15:29:04 >>>故障排除日志:终端未同步成功订单列表004924100715285551847212
已接收过此消息,票券号为2410071528555185182301,排队号为49
2024-10-07 15:29:04 开始打印,排队:50,票券:2410071528582783901501,订单:24100715285827834978,[2024-10-07 15:29:03微信支付10元]
2024-10-07 15:29:06 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410071528555185182301","queue_number":49,"trade_uid":"24100715285551847212"}]}
2024-10-07 15:29:06 >>>故障排除日志:删除未同步下发订单成功24100715285551847212
2024-10-07 15:29:06 >>>故障排除日志:终端同步成功后剩余订单列表005024100715285827834978
2024-10-07 15:29:06 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410071528555185182301","queue_number":49,"trade_uid":"24100715285551847212"},{"ticket_no":"2410071528582783901501","queue_number":50,"trade_uid":"24100715285827834978"}]}
2024-10-07 15:29:06 >>>故障排除日志:删除未同步下发订单成功24100715285827834978
2024-10-07 15:29:07 >>>故障排除日志:终端同步成功后剩余订单列表


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


===15:52:25===
2024-10-07 15:51:28>>>cash read=9E
2024-10-07 15:51:30>>>cash read=3E


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


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


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


===16:06:26===
2024-10-07 16:06:10 >>>回调事件[910,devices/TL1889]
2024-10-07 16:06:10 >>>故障排除日志:上一MQTT订单号缓存列表为24100716043869073119
2024-10-07 16:06:10 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 16:06:10 开始打印,排队:55,票券:2410071606036430829401,订单:24100716060364304161,[2024-10-07 16:06:08微信支付10元]
2024-10-07 16:06:12 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410071606036430829401","queue_number":55,"trade_uid":"24100716060364304161"}]}
2024-10-07 16:06:12 >>>故障排除日志:删除未同步下发订单成功24100716060364304161
2024-10-07 16:06:12 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-07 16:06:20>>>cash read=00
2024-10-07 16:06:21>>>cash read=818F42
2024-10-07 16:06:21>>>cash write=02
2024-10-07 16:06:21 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-07 16:06:22>>>cash read=10
2024-10-07 16:06:22 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-07 16:06:22 当前产品价格10元，投币10元，打印小票中...
2024-10-07 16:06:22 >>>开始打印,排队号为56,订单号为2410071606220018896345
2024-10-07 16:06:22>>>订单2410071606220018896345写入成功,剩余空间为1679000,占用RAM为610.931640625
删除未同步订单2410071606220018896345
2024-10-07 16:06:24>>>订单2410071606220018896345删除成功,剩余空间为1680000,占用RAM为620.7548828125
检测订单目录中>>>
无未同步订单>>>
2024-10-07 16:06:24 >>>当前Ram内存为590.1923828125
定时检测未同步订单启用
2024-10-07 16:06:25>>>cash write=0C
2024-10-07 16:06:25>>>cash read=3E


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


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


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


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


===16:40:28===
2024-10-07 16:39:37 >>>回调事件[910,devices/TL1889]
2024-10-07 16:39:37 >>>故障排除日志:上一MQTT订单号缓存列表为24100716291192429998
2024-10-07 16:39:37 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 16:39:37 开始打印,排队:60,票券:2410071639308343097301,订单:24100716393083425912,[2024-10-07 16:39:36微信支付10元]
2024-10-07 16:39:39 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410071639308343097301","queue_number":60,"trade_uid":"24100716393083425912"}]}
2024-10-07 16:39:39 >>>故障排除日志:删除未同步下发订单成功24100716393083425912
2024-10-07 16:39:39 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-07 16:39:50>>>cash read=00
2024-10-07 16:39:52>>>cash read=2F29
2024-10-07 16:39:54>>>cash read=3E
2024-10-07 16:40:02>>>cash read=00
2024-10-07 16:40:03>>>cash read=2F29
2024-10-07 16:40:05>>>cash read=3E
2024-10-07 16:40:06>>>cash read=00
2024-10-07 16:40:07>>>cash read=29
2024-10-07 16:40:07 >>>回调事件130,cash_status,20029,退钞中
2024-10-07 16:40:07>>>cash read=2F29
2024-10-07 16:40:09>>>cash read=3E
2024-10-07 16:40:10>>>cash read=00
2024-10-07 16:40:12>>>cash read=2F29
2024-10-07 16:40:14>>>cash read=3E


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


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


===17:01:29===
2024-10-07 17:01:20>>>cash read=9E
2024-10-07 17:01:21>>>cash read=3E


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


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


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


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


===17:26:31===
2024-10-07 17:25:46 >>>回调事件[910,devices/TL1889]
2024-10-07 17:25:47 >>>故障排除日志:上一MQTT订单号缓存列表为24100717220247292623
2024-10-07 17:25:47 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 17:25:47 开始打印,排队:67,票券:2410071725372879775901,订单:24100717253728793229,[2024-10-07 17:25:45微信支付10元]
2024-10-07 17:25:49 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410071725372879775901","queue_number":67,"trade_uid":"24100717253728793229"}]}
2024-10-07 17:25:49 >>>故障排除日志:删除未同步下发订单成功24100717253728793229
2024-10-07 17:25:49 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-07 17:25:55 >>>回调事件[910,devices/TL1889]
2024-10-07 17:25:55 >>>故障排除日志:上一MQTT订单号缓存列表为24100717253728793229
2024-10-07 17:25:55 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 17:25:55 开始打印,排队:68,票券:2410071725461329642401,订单:24100717254613289453,[2024-10-07 17:25:55微信支付10元]
2024-10-07 17:25:58 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410071725461329642401","queue_number":68,"trade_uid":"24100717254613289453"}]}
2024-10-07 17:25:58 >>>故障排除日志:删除未同步下发订单成功24100717254613289453
2024-10-07 17:25:58 >>>故障排除日志:终端同步成功后剩余订单列表


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


===17:38:31===
2024-10-07 17:38:15 >>>回调事件[910,devices/TL1889]
2024-10-07 17:38:15 >>>故障排除日志:上一MQTT订单号缓存列表为24100717274380523481
2024-10-07 17:38:15 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 17:38:15 开始打印,排队:70,票券:2410071738061725876401,订单:24100717380617253589,[2024-10-07 17:38:13微信支付10元]
2024-10-07 17:38:17 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410071738061725876401","queue_number":70,"trade_uid":"24100717380617253589"}]}
2024-10-07 17:38:17 >>>故障排除日志:删除未同步下发订单成功24100717380617253589
2024-10-07 17:38:17 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-07 17:38:21 >>>回调事件[910,devices/TL1889]
2024-10-07 17:38:21 >>>故障排除日志:上一MQTT订单号缓存列表为24100717380617253589
2024-10-07 17:38:21 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 17:38:21 开始打印,排队:71,票券:2410071738095373538401,订单:24100717380953729495,[2024-10-07 17:38:20支付宝支付10元]
2024-10-07 17:38:23 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410071738095373538401","queue_number":71,"trade_uid":"24100717380953729495"}]}
2024-10-07 17:38:23 >>>故障排除日志:删除未同步下发订单成功24100717380953729495
2024-10-07 17:38:23 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


===18:13:33===
2024-10-07 18:12:36 >>>回调事件[910,devices/TL1889]
2024-10-07 18:12:36 >>>故障排除日志:上一MQTT订单号缓存列表为24100717380953729495
2024-10-07 18:12:36 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 18:12:36 开始打印,排队:74,票券:2410071812272195523901,订单:24100718122721951781,[2024-10-07 18:12:34微信支付10元]
2024-10-07 18:12:36 开始打印,排队:75,票券:2410071812272195673802,订单:24100718122721951781,[2024-10-07 18:12:34微信支付10元]
2024-10-07 18:12:40 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410071812272195523901","queue_number":74,"trade_uid":"24100718122721951781"},{"ticket_no":"2410071812272195673802","queue_number":75,"trade_uid":"24100718122721951781"}]}
2024-10-07 18:12:40 >>>故障排除日志:删除未同步下发订单成功24100718122721951781
2024-10-07 18:12:40 >>>故障排除日志:删除未同步下发订单成功24100718122721951781
2024-10-07 18:12:40 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-07 18:13:17 >>>回调事件[910,devices/TL1889]
2024-10-07 18:13:17 >>>故障排除日志:上一MQTT订单号缓存列表为24100718122721951781|24100718122721951781
2024-10-07 18:13:17 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 18:13:17 开始打印,排队:76,票券:2410071813099072194501,订单:24100718130990717654,[2024-10-07 18:13:16微信支付10元]
2024-10-07 18:13:19 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410071813099072194501","queue_number":76,"trade_uid":"24100718130990717654"}]}
2024-10-07 18:13:19 >>>故障排除日志:删除未同步下发订单成功24100718130990717654
2024-10-07 18:13:19 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


===18:35:34===
2024-10-07 18:35:05 >>>回调事件[910,devices/TL1889]
2024-10-07 18:35:05 >>>故障排除日志:上一MQTT订单号缓存列表为24100718323501210159
2024-10-07 18:35:05 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 18:35:05 开始打印,排队:80,票券:2410071834570572509201,订单:24100718345705719759,[2024-10-07 18:35:04支付宝支付10元]
2024-10-07 18:35:07 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410071834570572509201","queue_number":80,"trade_uid":"24100718345705719759"}]}
2024-10-07 18:35:07 >>>故障排除日志:删除未同步下发订单成功24100718345705719759
2024-10-07 18:35:07 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-07 18:35:27>>>cash read=9E
2024-10-07 18:35:28>>>cash read=3E


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


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


===18:47:35===
2024-10-07 18:47:30 >>>回调事件[910,devices/TL1889]
2024-10-07 18:47:30 >>>故障排除日志:上一MQTT订单号缓存列表为24100718445501783018
2024-10-07 18:47:30 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 18:47:30 开始打印,排队:83,票券:2410071847221145291801,订单:24100718472211445818,[2024-10-07 18:47:29微信支付10元]
2024-10-07 18:47:30 开始打印,排队:84,票券:2410071847221145469202,订单:24100718472211445818,[2024-10-07 18:47:29微信支付10元]
2024-10-07 18:47:34 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410071847221145291801","queue_number":83,"trade_uid":"24100718472211445818"},{"ticket_no":"2410071847221145469202","queue_number":84,"trade_uid":"24100718472211445818"}]}
2024-10-07 18:47:34 >>>故障排除日志:删除未同步下发订单成功24100718472211445818
2024-10-07 18:47:34 >>>故障排除日志:删除未同步下发订单成功24100718472211445818
2024-10-07 18:47:34 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


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


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


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


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


===19:13:38===
2024-10-07 19:12:41 >>>回调事件[910,devices/TL1889]
2024-10-07 19:12:41 >>>故障排除日志:上一MQTT订单号缓存列表为24100719080048341179
2024-10-07 19:12:41 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 19:12:41 开始打印,排队:92,票券:2410071912349499053801,订单:24100719123494984343,[2024-10-07 19:12:41微信支付10元]
2024-10-07 19:12:43 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410071912349499053801","queue_number":92,"trade_uid":"24100719123494984343"}]}
2024-10-07 19:12:43 >>>故障排除日志:删除未同步下发订单成功24100719123494984343
2024-10-07 19:12:44 >>>故障排除日志:终端同步成功后剩余订单列表
2024-10-07 19:13:21>>>cash read=00
2024-10-07 19:13:21>>>cash read=818F42
2024-10-07 19:13:21>>>cash write=02
2024-10-07 19:13:21 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-07 19:13:22>>>cash read=10
2024-10-07 19:13:22 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-07 19:13:22 当前产品价格10元，投币10元，打印小票中...
2024-10-07 19:13:22 >>>开始打印,排队号为93,订单号为2410071913220018893198
2024-10-07 19:13:22>>>订单2410071913220018893198写入成功,剩余空间为1679000,占用RAM为611.912109375
删除未同步订单2410071913220018893198
2024-10-07 19:13:24>>>订单2410071913220018893198删除成功,剩余空间为1680000,占用RAM为621.2900390625
检测订单目录中>>>
无未同步订单>>>
2024-10-07 19:13:24 >>>当前Ram内存为590.5830078125
定时检测未同步订单启用
2024-10-07 19:13:25>>>cash write=0C
2024-10-07 19:13:25>>>cash read=3E


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


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


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


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


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


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


===19:54:40===
2024-10-07 19:54:35>>>cash read=9E
2024-10-07 19:54:36>>>cash read=3E


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


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


===20:12:41===
2024-10-07 20:11:46>>>cash read=29
2024-10-07 20:11:46 >>>回调事件130,cash_status,20029,退钞中
2024-10-07 20:11:46>>>cash read=2F29
2024-10-07 20:11:48>>>cash read=3E
2024-10-07 20:11:50>>>cash read=00
2024-10-07 20:11:52>>>cash read=29
2024-10-07 20:11:52 >>>回调事件130,cash_status,20029,退钞中
2024-10-07 20:11:53>>>cash read=01
2024-10-07 20:11:55>>>cash read=3E
2024-10-07 20:11:57>>>cash read=00
2024-10-07 20:11:58>>>cash read=00818F42
2024-10-07 20:11:58>>>cash write=02
2024-10-07 20:11:58 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-07 20:11:59>>>cash read=10
2024-10-07 20:11:59 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-07 20:11:59 当前产品价格10元，投币10元，打印小票中...
2024-10-07 20:11:59 >>>开始打印,排队号为101,订单号为2410072011590018891768
2024-10-07 20:11:59>>>订单2410072011590018891768写入成功,剩余空间为1679500,占用RAM为609.3115234375
删除未同步订单2410072011590018891768
2024-10-07 20:12:01>>>订单2410072011590018891768删除成功,剩余空间为1680000,占用RAM为619.9619140625
检测订单目录中>>>
无未同步订单>>>
2024-10-07 20:12:01 >>>当前Ram内存为590.2265625
定时检测未同步订单启用
2024-10-07 20:12:02>>>cash write=0C
2024-10-07 20:12:02>>>cash read=3E
2024-10-07 20:12:19 >>>回调事件[910,devices/TL1889]
2024-10-07 20:12:20 >>>故障排除日志:上一MQTT订单号缓存列表为24100720113017850063
2024-10-07 20:12:20 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 20:12:20 开始打印,排队:102,票券:2410072012112531853501,订单:24100720121125314549,[2024-10-07 20:12:18微信支付10元]
2024-10-07 20:12:22 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410072012112531853501","queue_number":102,"trade_uid":"24100720121125314549"}]}
2024-10-07 20:12:22 >>>故障排除日志:删除未同步下发订单成功24100720121125314549
2024-10-07 20:12:22 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


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


===20:42:43===
2024-10-07 20:41:42>>>cash read=00
2024-10-07 20:41:43>>>cash read=818F41
2024-10-07 20:41:43>>>cash write=02
2024-10-07 20:41:43 >>>回调事件130,cash_status,10022,进钞中...read money=5
2024-10-07 20:41:43>>>cash read=10
2024-10-07 20:41:43 >>>回调事件130,5,10023,finish Money=5,进钞完成
2024-10-07 20:41:44>>>cash write=0C
2024-10-07 20:41:44>>>cash read=00
2024-10-07 20:41:45>>>cash read=818F41
2024-10-07 20:41:45>>>cash write=02
2024-10-07 20:41:45 >>>回调事件130,cash_status,10022,进钞中...read money=5
2024-10-07 20:41:45>>>cash read=10
2024-10-07 20:41:45 >>>回调事件130,5,10023,finish Money=5,进钞完成
2024-10-07 20:41:45 当前产品价格10元，投币10元，打印小票中...
2024-10-07 20:41:45 >>>开始打印,排队号为106,订单号为2410072041430018899381
2024-10-07 20:41:45>>>订单2410072041430018899381写入成功,剩余空间为1679500,占用RAM为606.8271484375
删除未同步订单2410072041430018899381
2024-10-07 20:41:48>>>订单2410072041430018899381删除成功,剩余空间为1680500,占用RAM为621.4423828125
检测订单目录中>>>
无未同步订单>>>
2024-10-07 20:41:48 >>>当前Ram内存为590.4140625
定时检测未同步订单启用
2024-10-07 20:41:48>>>cash write=0C
2024-10-07 20:41:49>>>cash read=3E
2024-10-07 20:42:24 >>>回调事件[910,devices/TL1889]
2024-10-07 20:42:24 >>>故障排除日志:上一MQTT订单号缓存列表为24100720294139613642
2024-10-07 20:42:24 >>>故障排除日志:终端未同步成功订单列表
2024-10-07 20:42:24 开始打印,排队:107,票券:2410072042179674136901,订单:24100720421796737924,[2024-10-07 20:42:23微信支付10元]
2024-10-07 20:42:26 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2410072042179674136901","queue_number":107,"trade_uid":"24100720421796737924"}]}
2024-10-07 20:42:26 >>>故障排除日志:删除未同步下发订单成功24100720421796737924
2024-10-07 20:42:26 >>>故障排除日志:终端同步成功后剩余订单列表


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


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


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


===20:57:44===
2024-10-07 20:57:12>>>cash read=29
2024-10-07 20:57:12 >>>回调事件130,cash_status,20029,退钞中
2024-10-07 20:57:12>>>cash read=2F29
2024-10-07 20:57:13>>>cash read=01
2024-10-07 20:57:14>>>cash read=2F
2024-10-07 20:57:15>>>cash read=29
2024-10-07 20:57:15 >>>回调事件130,cash_status,20029,退钞中
2024-10-07 20:57:16>>>cash read=3E
2024-10-07 20:57:27>>>cash read=00
2024-10-07 20:57:28>>>cash read=818F42
2024-10-07 20:57:28>>>cash write=02
2024-10-07 20:57:28 >>>回调事件130,cash_status,10022,进钞中...read money=10
2024-10-07 20:57:29>>>cash read=10
2024-10-07 20:57:29 >>>回调事件130,10,10023,finish Money=10,进钞完成
2024-10-07 20:57:29 当前产品价格10元，投币10元，打印小票中...
2024-10-07 20:57:29 >>>开始打印,排队号为110,订单号为2410072057290018895278
2024-10-07 20:57:29>>>订单2410072057290018895278写入成功,剩余空间为1679500,占用RAM为609.3271484375
删除未同步订单2410072057290018895278
2024-10-07 20:57:31>>>订单2410072057290018895278删除成功,剩余空间为1680500,占用RAM为620.3115234375
检测订单目录中>>>
无未同步订单>>>
2024-10-07 20:57:31 >>>当前Ram内存为590.4423828125
定时检测未同步订单启用
2024-10-07 20:57:32>>>cash write=0C
2024-10-07 20:57:32>>>cash read=3E


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


===21:03:44===
2024-10-07 21:02:51>>>cash read=0A
2024-10-07 21:02:52>>>cash read=3E


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


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


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