TLClient_JSSCOM_LuatOS-Air_V4010_RDA8910_RFTTS_0xe0000,2.8.6,865328069264553,64115596615012,
poweron reason:0

===09:02:47===
上一时间戳为1777079191
隔日重置时间戳true
隔日清空未同步下发列表true
当前排队号为168,音量为6
初始化产品信息:[{"time_limit_date":"","ticket_category":"0","expiry_date":90,"product_detail":"请保管好票据，凭小票叫号理发\n","time_limit_status":"0","begin_minute":"00","product_uid":"4351590954437749654","use_timer":1,"old_price":"10","end_hour":"23","sale_price":"10","end_minute":"59","begin_hour":"00","sale_status":1,"product_name":"剪发"}]
打印门店标题设置为剪艺快剪
是否打印二维码设置为0
是否打印紧凑设置为3
当前号显示模式设置为1
当前卡项核销权限设置为0
session_id:f1c95****915e4
纸币器设置接收纸币范围为36
欢迎使用天羚自助售票系统[2.8.6]
定时检测未同步订单启用[checkOrderNum=536870969]
2026-04-26 09:01:47>>>cash write=30
2026-04-26 09:01:47>>>cash write=02
2026-04-26 09:01:47>>>cash write=3E
2026-04-26 09:01:47>>>cash read=808F808F808F808F
系统时间初始化成功，时间为20264269147
2026-04-26 09:01:48>>>cash write=02
2026-04-26 09:01:48 >>>剩余flash空间=1680000,占用RAM为654.923828125
2026-04-26 09:01:48 >>>回调事件:910,subscribe,10000,连接服务器成功

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

2026-04-26 09:01:51>>>cash write=0C
2026-04-26 09:01:51>>>cash read=3E
流量卡还有308天过期
2026-04-26 09:01:55 >>>当前Ram内存为639.4140625
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 09:02:00 >>>回调事件[910,devices/S2664]
当日首次设置时间戳true为1777165320
2026-04-26 09:02:00 >>>故障排除日志:上一MQTT订单号缓存列表为2604252048030086537521
2026-04-26 09:02:00 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 09:02:00 开始打印,排队:168,票券:2604260901532035117801,订单:2604260901530017569978,[2026-04-26 09:01:59微信支付10元]
2026-04-26 09:02:00>>>MQTT票号同步场景，创建空订单对象
2026-04-26 09:02:00>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 09:02:02 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604260901532035117801","queue_number":168,"trade_uid":"2604260901530017569978"}]}
2026-04-26 09:02:02 >>>故障排除日志:删除未同步下发订单成功2604260901530017569978
2026-04-26 09:02:02 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536870986]


===09:10:47===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 09:10:44 >>>回调事件[910,devices/S2664]
2026-04-26 09:10:44 >>>故障排除日志:上一MQTT订单号缓存列表为2604260901530017569978
2026-04-26 09:10:44 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 09:10:44 开始打印,排队:169,票券:2604260910376728864501,订单:2604260910370065477787,[2026-04-26 09:10:42微信支付10元]
2026-04-26 09:10:44>>>MQTT票号同步场景，创建空订单对象
2026-04-26 09:10:44>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 09:10:46 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604260910376728864501","queue_number":169,"trade_uid":"2604260910370065477787"}]}
2026-04-26 09:10:46 >>>故障排除日志:删除未同步下发订单成功2604260910370065477787
2026-04-26 09:10:46 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536871073]


===09:15:48===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 09:15:34 >>>回调事件[910,devices/S2664]
2026-04-26 09:15:34 >>>故障排除日志:上一MQTT订单号缓存列表为2604260910370065477787
2026-04-26 09:15:34 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 09:15:34 开始打印,排队:170,票券:2604260915274643892401,订单:2604260915270044484628,[2026-04-26 09:15:33微信支付10元]
2026-04-26 09:15:34>>>MQTT票号同步场景，创建空订单对象
2026-04-26 09:15:34>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 09:15:36 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604260915274643892401","queue_number":170,"trade_uid":"2604260915270044484628"}]}
2026-04-26 09:15:36 >>>故障排除日志:删除未同步下发订单成功2604260915270044484628
2026-04-26 09:15:36 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536871121]


===09:18:48===
2026-04-26 09:18:13>>>cash read=BF
2026-04-26 09:18:15>>>cash read=3E


===09:20:48===
2026-04-26 09:19:58>>>cash read=0A
2026-04-26 09:19:59>>>cash read=3E


===09:24:48===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 09:24:41 >>>回调事件[910,devices/S2664]
2026-04-26 09:24:41 >>>故障排除日志:上一MQTT订单号缓存列表为2604260915270044484628
2026-04-26 09:24:41 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 09:24:41 开始打印,排队:171,票券:2604260924322804811401,订单:2604260924320026154118,[2026-04-26 09:24:40微信支付10元]
2026-04-26 09:24:41>>>MQTT票号同步场景，创建空订单对象
2026-04-26 09:24:41>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 09:24:43 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604260924322804811401","queue_number":171,"trade_uid":"2604260924320026154118"}]}
2026-04-26 09:24:43 >>>故障排除日志:删除未同步下发订单成功2604260924320026154118
2026-04-26 09:24:43 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536871219]


===09:37:49===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 09:37:09 >>>回调事件[910,devices/S2664]
2026-04-26 09:37:09 >>>故障排除日志:上一MQTT订单号缓存列表为2604260924320026154118
2026-04-26 09:37:09 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 09:37:09 开始打印,排队:172,票券:2604260936586610094901,订单:2604260936580064070764,[2026-04-26 09:37:08微信支付10元]
2026-04-26 09:37:09>>>MQTT票号同步场景，创建空订单对象
2026-04-26 09:37:09>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 09:37:11 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604260936586610094901","queue_number":172,"trade_uid":"2604260936580064070764"}]}
2026-04-26 09:37:11 >>>故障排除日志:删除未同步下发订单成功2604260936580064070764
2026-04-26 09:37:11 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536871338]


===09:43:49===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 09:43:12 >>>回调事件[910,devices/S2664]
2026-04-26 09:43:12 >>>故障排除日志:上一MQTT订单号缓存列表为2604260936580064070764
2026-04-26 09:43:12 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 09:43:12 开始打印,排队:173,票券:2604260942564723241801,订单:2604260942560045133752,[2026-04-26 09:43:11微信支付10元]
2026-04-26 09:43:12>>>MQTT票号同步场景，创建空订单对象
2026-04-26 09:43:12>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 09:43:14 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604260942564723241801","queue_number":173,"trade_uid":"2604260942560045133752"}]}
2026-04-26 09:43:14 >>>故障排除日志:删除未同步下发订单成功2604260942560045133752
2026-04-26 09:43:14 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536871400]


===09:49:49===
2026-04-26 09:48:54>>>cash read=00
2026-04-26 09:48:55>>>cash read=818F42
2026-04-26 09:48:55>>>cash write=02
2026-04-26 09:48:55 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 09:48:55>>>cash read=10
2026-04-26 09:48:56 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 09:48:56 当前产品价格10元，投币10元，打印小票中...
2026-04-26 09:48:56 >>>开始打印,排队号为174,订单号为2604260948560022664205
2026-04-26 09:48:56>>>订单2604260948560022664205写入成功,剩余空间为1679500,占用RAM为634.5830078125
删除未同步订单2604260948560022664205
2026-04-26 09:48:58>>>订单2604260948560022664205删除成功,剩余空间为1680500,占用RAM为646.0263671875
检测订单目录中>>>
无未同步订单>>>
2026-04-26 09:48:58 >>>当前Ram内存为617.6474609375
定时检测未同步订单启用[checkOrderNum=536871460]
2026-04-26 09:48:59>>>cash write=0C
2026-04-26 09:48:59>>>cash read=3E
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 09:49:24 >>>回调事件[910,devices/S2664]
2026-04-26 09:49:24 >>>故障排除日志:上一MQTT订单号缓存列表为2604260942560045133752
2026-04-26 09:49:24 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 09:49:24 开始打印,排队:175,票券:2604260949137208967801,订单:2604260949130070040687,[2026-04-26 09:49:23微信支付10元]
2026-04-26 09:49:25>>>MQTT票号同步场景，创建空订单对象
2026-04-26 09:49:25>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 09:49:27 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604260949137208967801","queue_number":175,"trade_uid":"2604260949130070040687"}]}
2026-04-26 09:49:27 >>>故障排除日志:删除未同步下发订单成功2604260949130070040687
2026-04-26 09:49:27 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536871469]


===09:55:50===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 09:55:35 >>>回调事件[910,devices/S2664]
2026-04-26 09:55:35 >>>故障排除日志:上一MQTT订单号缓存列表为2604260949130070040687
2026-04-26 09:55:35 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 09:55:35 开始打印,排队:176,票券:2604260955264632885301,订单:2604260955260044158253,[2026-04-26 09:55:34微信支付10元]
2026-04-26 09:55:35>>>MQTT票号同步场景，创建空订单对象
2026-04-26 09:55:35>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 09:55:37 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604260955264632885301","queue_number":176,"trade_uid":"2604260955260044158253"}]}
2026-04-26 09:55:37 >>>故障排除日志:删除未同步下发订单成功2604260955260044158253
2026-04-26 09:55:37 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536871532]


===10:00:50===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 10:00:08 >>>回调事件[910,devices/S2664]
2026-04-26 10:00:08 >>>故障排除日志:上一MQTT订单号缓存列表为2604260955260044158253
2026-04-26 10:00:08 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 10:00:08 开始打印,排队:177,票券:2604261000007559472601,订单:2604261000000073482516,[2026-04-26 10:00:08微信支付10元]
2026-04-26 10:00:09 开始打印,排队:178,票券:2604261000007560116302,订单:2604261000000073482516,[2026-04-26 10:00:08微信支付10元]
2026-04-26 10:00:09>>>MQTT票号同步场景，创建空订单对象
2026-04-26 10:00:09>>>合并MQTT票号列表到订单同步请求,共2张票
2026-04-26 10:00:12 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261000007559472601","queue_number":177,"trade_uid":"2604261000000073482516"},{"ticket_no":"2604261000007560116302","queue_number":178,"trade_uid":"2604261000000073482516"}]}
2026-04-26 10:00:12 >>>故障排除日志:删除未同步下发订单成功2604261000000073482516
2026-04-26 10:00:12 >>>故障排除日志:删除未同步下发订单成功2604261000000073482516
2026-04-26 10:00:12 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536871584]


===10:06:50===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 10:06:35 >>>回调事件[910,devices/S2664]
2026-04-26 10:06:35 >>>故障排除日志:上一MQTT订单号缓存列表为2604261000000073482516|2604261000000073482516
2026-04-26 10:06:35 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 10:06:35 开始打印,排队:179,票券:2604261006263243668601,订单:2604261006260030538287,[2026-04-26 10:06:33微信支付10元]
2026-04-26 10:06:35>>>MQTT票号同步场景，创建空订单对象
2026-04-26 10:06:35>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 10:06:37 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261006263243668601","queue_number":179,"trade_uid":"2604261006260030538287"}]}
2026-04-26 10:06:37 >>>故障排除日志:删除未同步下发订单成功2604261006260030538287
2026-04-26 10:06:37 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536871646]


===10:09:50===
2026-04-26 10:08:51>>>cash read=00
2026-04-26 10:08:52>>>cash read=3E
2026-04-26 10:08:53>>>cash read=00
2026-04-26 10:08:54>>>cash read=818F42
2026-04-26 10:08:54>>>cash write=02
2026-04-26 10:08:54 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 10:08:55>>>cash read=10
2026-04-26 10:08:55 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 10:08:55 当前产品价格10元，投币10元，打印小票中...
2026-04-26 10:08:55 >>>开始打印,排队号为180,订单号为2604261008550022664197
2026-04-26 10:08:55>>>订单2604261008550022664197写入成功,剩余空间为1679500,占用RAM为636.2216796875
删除未同步订单2604261008550022664197
2026-04-26 10:08:57>>>订单2604261008550022664197删除成功,剩余空间为1680500,占用RAM为645.0078125
检测订单目录中>>>
无未同步订单>>>
2026-04-26 10:08:57 >>>当前Ram内存为617.9833984375
定时检测未同步订单启用[checkOrderNum=536871679]
2026-04-26 10:08:58>>>cash write=0C
2026-04-26 10:08:58>>>cash read=3E


===10:36:51===
2026-04-26 10:36:05>>>cash read=0A
2026-04-26 10:36:06>>>cash read=3E


===10:37:51===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 10:37:14 >>>回调事件[910,devices/S2664]
2026-04-26 10:37:14 >>>故障排除日志:上一MQTT订单号缓存列表为2604261006260030538287
2026-04-26 10:37:14 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 10:37:14 开始打印,排队:181,票券:2604261037053087333901,订单:2604261037050029080456,[2026-04-26 10:37:13微信支付10元]
2026-04-26 10:37:14>>>MQTT票号同步场景，创建空订单对象
2026-04-26 10:37:14>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 10:37:16 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261037053087333901","queue_number":181,"trade_uid":"2604261037050029080456"}]}
2026-04-26 10:37:16 >>>故障排除日志:删除未同步下发订单成功2604261037050029080456
2026-04-26 10:37:16 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536871943]


===10:39:51===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 10:39:35 >>>回调事件[910,devices/S2664]
2026-04-26 10:39:35 >>>故障排除日志:上一MQTT订单号缓存列表为2604261037050029080456
2026-04-26 10:39:35 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 10:39:35 开始打印,排队:182,票券:2604261039262674021401,订单:2604261039260023162652,[2026-04-26 10:39:34微信支付10元]
2026-04-26 10:39:35>>>MQTT票号同步场景，创建空订单对象
2026-04-26 10:39:35>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 10:39:37 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261039262674021401","queue_number":182,"trade_uid":"2604261039260023162652"}]}
2026-04-26 10:39:37 >>>故障排除日志:删除未同步下发订单成功2604261039260023162652
2026-04-26 10:39:37 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536871970]


===10:45:51===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 10:45:48 >>>回调事件[910,devices/S2664]
2026-04-26 10:45:48 >>>故障排除日志:上一MQTT订单号缓存列表为2604261039260023162652
2026-04-26 10:45:48 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 10:45:48 开始打印,排队:183,票券:2604261045402287772101,订单:2604261045400020933926,[2026-04-26 10:45:47微信支付10元]
2026-04-26 10:45:48>>>MQTT票号同步场景，创建空订单对象
2026-04-26 10:45:48>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 10:45:50 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261045402287772101","queue_number":183,"trade_uid":"2604261045400020933926"}]}
2026-04-26 10:45:50 >>>故障排除日志:删除未同步下发订单成功2604261045400020933926
2026-04-26 10:45:50 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536872037]


===10:54:52===
2026-04-26 10:54:41>>>cash read=0A
2026-04-26 10:54:43>>>cash read=3E


===10:58:52===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 10:58:44 >>>回调事件[910,devices/S2664]
2026-04-26 10:58:44 >>>故障排除日志:上一MQTT订单号缓存列表为2604261045400020933926
2026-04-26 10:58:44 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 10:58:44 开始打印,排队:184,票券:2604261058240825125401,订单:2604261058240006446221,[2026-04-26 10:58:44支付宝支付10元]
2026-04-26 10:58:45>>>MQTT票号同步场景，创建空订单对象
2026-04-26 10:58:45>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 10:58:47 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261058240825125401","queue_number":184,"trade_uid":"2604261058240006446221"}]}
2026-04-26 10:58:47 >>>故障排除日志:删除未同步下发订单成功2604261058240006446221
2026-04-26 10:58:47 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536872164]


===10:59:52===
2026-04-26 10:59:35>>>cash read=BF
2026-04-26 10:59:36>>>cash read=3E


===11:02:53===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 11:02:50 >>>回调事件[910,devices/S2664]
2026-04-26 11:02:50 >>>故障排除日志:上一MQTT订单号缓存列表为2604261058240006446221
2026-04-26 11:02:50 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 11:02:50 开始打印,排队:185,票券:2604261102400628119301,订单:2604261102400004382928,[2026-04-26 11:02:49微信支付10元]
2026-04-26 11:02:50>>>MQTT票号同步场景，创建空订单对象
2026-04-26 11:02:50>>>合并MQTT票号列表到订单同步请求,共1张票


===11:03:53===
2026-04-26 11:02:52 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261102400628119301","queue_number":185,"trade_uid":"2604261102400004382928"}]}
2026-04-26 11:02:52 >>>故障排除日志:删除未同步下发订单成功2604261102400004382928
2026-04-26 11:02:52 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536872212]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 11:02:53 >>>回调事件[910,devices/S2664]
2026-04-26 11:02:53 >>>故障排除日志:上一MQTT订单号缓存列表为2604261102400004382928
2026-04-26 11:02:53 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 11:02:53 开始打印,排队:186,票券:2604261102465707026801,订单:2604261102460055046881,[2026-04-26 11:02:52微信支付10元]
2026-04-26 11:02:53>>>MQTT票号同步场景，创建空订单对象
2026-04-26 11:02:53>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 11:02:55 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261102465707026801","queue_number":186,"trade_uid":"2604261102460055046881"}]}
2026-04-26 11:02:55 >>>故障排除日志:删除未同步下发订单成功2604261102460055046881
2026-04-26 11:02:55 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536872218]


===11:28:54===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 11:28:38 >>>回调事件[910,devices/S2664]
2026-04-26 11:28:38 >>>故障排除日志:上一MQTT订单号缓存列表为2604261102460055046881
2026-04-26 11:28:38 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 11:28:38 开始打印,排队:187,票券:2604261128325488324701,订单:2604261128320053038931,[2026-04-26 11:28:38微信支付10元]
2026-04-26 11:28:38>>>MQTT票号同步场景，创建空订单对象
2026-04-26 11:28:38>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 11:28:40 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261128325488324701","queue_number":187,"trade_uid":"2604261128320053038931"}]}
2026-04-26 11:28:40 >>>故障排除日志:删除未同步下发订单成功2604261128320053038931
2026-04-26 11:28:40 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536872460]


===11:30:54===
2026-04-26 11:30:22>>>cash read=00
2026-04-26 11:30:23>>>cash read=818F42
2026-04-26 11:30:23>>>cash write=02
2026-04-26 11:30:23 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 11:30:24>>>cash read=10
2026-04-26 11:30:24 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 11:30:24 当前产品价格10元，投币10元，打印小票中...
2026-04-26 11:30:24 >>>开始打印,排队号为188,订单号为2604261130240022664195
2026-04-26 11:30:24>>>订单2604261130240022664195写入成功,剩余空间为1679500,占用RAM为633.19921875
删除未同步订单2604261130240022664195
2026-04-26 11:30:26>>>订单2604261130240022664195删除成功,剩余空间为1680500,占用RAM为642.1435546875
检测订单目录中>>>
无未同步订单>>>
2026-04-26 11:30:26 >>>当前Ram内存为615.4306640625
定时检测未同步订单启用[checkOrderNum=536872481]
2026-04-26 11:30:27>>>cash write=0C
2026-04-26 11:30:27>>>cash read=3E


===11:32:54===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 11:32:39 >>>回调事件[910,devices/S2664]
2026-04-26 11:32:39 >>>故障排除日志:上一MQTT订单号缓存列表为2604261128320053038931
2026-04-26 11:32:39 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 11:32:39 开始打印,排队:189,票券:2604261132307550456301,订单:2604261132300073379293,[2026-04-26 11:32:38微信支付10元]
2026-04-26 11:32:39>>>MQTT票号同步场景，创建空订单对象
2026-04-26 11:32:39>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 11:32:41 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261132307550456301","queue_number":189,"trade_uid":"2604261132300073379293"}]}
2026-04-26 11:32:41 >>>故障排除日志:删除未同步下发订单成功2604261132300073379293
2026-04-26 11:32:41 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536872513]


===11:36:55===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 11:36:28 >>>回调事件[910,devices/S2664]
2026-04-26 11:36:28 >>>故障排除日志:上一MQTT订单号缓存列表为2604261132300073379293
2026-04-26 11:36:28 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 11:36:28 开始打印,排队:190,票券:2604261136185591817501,订单:2604261136180054160815,[2026-04-26 11:36:27微信支付10元]
2026-04-26 11:36:28>>>MQTT票号同步场景，创建空订单对象
2026-04-26 11:36:28>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 11:36:30 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261136185591817501","queue_number":190,"trade_uid":"2604261136180054160815"}]}
2026-04-26 11:36:30 >>>故障排除日志:删除未同步下发订单成功2604261136180054160815
2026-04-26 11:36:30 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536872551]


===11:50:55===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 11:50:16 >>>回调事件[910,devices/S2664]
2026-04-26 11:50:16 >>>故障排除日志:上一MQTT订单号缓存列表为2604261136180054160815
2026-04-26 11:50:16 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 11:50:16 开始打印,排队:191,票券:2604261150088841918901,订单:2604261150080086666534,[2026-04-26 11:50:15微信支付10元]
2026-04-26 11:50:16>>>MQTT票号同步场景，创建空订单对象
2026-04-26 11:50:16>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 11:50:18 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261150088841918901","queue_number":191,"trade_uid":"2604261150080086666534"}]}
2026-04-26 11:50:18 >>>故障排除日志:删除未同步下发订单成功2604261150080086666534
2026-04-26 11:50:18 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536872685]


===11:55:55===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 11:55:36 >>>回调事件[910,devices/S2664]
2026-04-26 11:55:36 >>>故障排除日志:上一MQTT订单号缓存列表为2604261150080086666534
2026-04-26 11:55:36 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 11:55:36 开始打印,排队:192,票券:2604261155285638067501,订单:2604261155280054584745,[2026-04-26 11:55:35微信支付10元]
2026-04-26 11:55:36 开始打印,排队:193,票券:2604261155285638567902,订单:2604261155280054584745,[2026-04-26 11:55:35微信支付10元]
2026-04-26 11:55:36>>>MQTT票号同步场景，创建空订单对象
2026-04-26 11:55:36>>>合并MQTT票号列表到订单同步请求,共2张票
2026-04-26 11:55:40 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261155285638067501","queue_number":192,"trade_uid":"2604261155280054584745"},{"ticket_no":"2604261155285638567902","queue_number":193,"trade_uid":"2604261155280054584745"}]}
2026-04-26 11:55:40 >>>故障排除日志:删除未同步下发订单成功2604261155280054584745
2026-04-26 11:55:40 >>>故障排除日志:删除未同步下发订单成功2604261155280054584745
2026-04-26 11:55:40 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536872738]


===11:58:55===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 11:57:59 >>>回调事件[910,devices/S2664]
2026-04-26 11:57:59 >>>故障排除日志:上一MQTT订单号缓存列表为2604261155280054584745|2604261155280054584745
2026-04-26 11:57:59 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 11:57:59 开始打印,排队:194,票券:2604261157539645402101,订单:2604261157530094564992,[2026-04-26 11:57:58微信支付10元]
2026-04-26 11:57:59>>>MQTT票号同步场景，创建空订单对象
2026-04-26 11:57:59>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 11:58:01 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261157539645402101","queue_number":194,"trade_uid":"2604261157530094564992"}]}
2026-04-26 11:58:01 >>>故障排除日志:删除未同步下发订单成功2604261157530094564992
2026-04-26 11:58:01 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536872771]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 11:58:22 >>>回调事件[910,devices/S2664]
2026-04-26 11:58:22 >>>故障排除日志:上一MQTT订单号缓存列表为2604261157530094564992
2026-04-26 11:58:22 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 11:58:22 开始打印,排队:195,票券:2604261158149206528901,订单:2604261158140090285619,[2026-04-26 11:58:21微信支付10元]
2026-04-26 11:58:22>>>MQTT票号同步场景，创建空订单对象
2026-04-26 11:58:22>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 11:58:24 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261158149206528901","queue_number":195,"trade_uid":"2604261158140090285619"}]}
2026-04-26 11:58:24 >>>故障排除日志:删除未同步下发订单成功2604261158140090285619
2026-04-26 11:58:24 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536872779]


===12:02:55===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 12:02:22 >>>回调事件[910,devices/S2664]
2026-04-26 12:02:22 >>>故障排除日志:上一MQTT订单号缓存列表为2604261158140090285619
2026-04-26 12:02:22 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 12:02:22 开始打印,排队:196,票券:2604261202135656304601,订单:2604261202130054463039,[2026-04-26 12:02:22微信支付10元]
2026-04-26 12:02:23>>>MQTT票号同步场景，创建空订单对象
2026-04-26 12:02:23>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 12:02:25 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261202135656304601","queue_number":196,"trade_uid":"2604261202130054463039"}]}
2026-04-26 12:02:25 >>>故障排除日志:删除未同步下发订单成功2604261202130054463039
2026-04-26 12:02:25 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536872823]


===12:05:56===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 12:05:20 >>>回调事件[910,devices/S2664]
2026-04-26 12:05:20 >>>故障排除日志:上一MQTT订单号缓存列表为2604261202130054463039
2026-04-26 12:05:20 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 12:05:20 开始打印,排队:197,票券:2604261205067090996901,订单:2604261205060068571894,[2026-04-26 12:05:19微信支付10元]
2026-04-26 12:05:20>>>MQTT票号同步场景，创建空订单对象
2026-04-26 12:05:20>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 12:05:22 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261205067090996901","queue_number":197,"trade_uid":"2604261205060068571894"}]}
2026-04-26 12:05:22 >>>故障排除日志:删除未同步下发订单成功2604261205060068571894
2026-04-26 12:05:22 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536872858]


===12:07:56===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 12:07:13 >>>回调事件[910,devices/S2664]
2026-04-26 12:07:13 >>>故障排除日志:上一MQTT订单号缓存列表为2604261205060068571894
2026-04-26 12:07:13 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 12:07:13 开始打印,排队:198,票券:2604261207057587829401,订单:2604261207050073471639,[2026-04-26 12:07:12微信支付10元]
2026-04-26 12:07:13 开始打印,排队:199,票券:2604261207057588368102,订单:2604261207050073471639,[2026-04-26 12:07:12微信支付10元]
2026-04-26 12:07:13>>>MQTT票号同步场景，创建空订单对象
2026-04-26 12:07:13>>>合并MQTT票号列表到订单同步请求,共2张票
2026-04-26 12:07:17 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261207057587829401","queue_number":198,"trade_uid":"2604261207050073471639"},{"ticket_no":"2604261207057588368102","queue_number":199,"trade_uid":"2604261207050073471639"}]}
2026-04-26 12:07:17 >>>故障排除日志:删除未同步下发订单成功2604261207050073471639
2026-04-26 12:07:17 >>>故障排除日志:删除未同步下发订单成功2604261207050073471639
2026-04-26 12:07:17 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536872883]


===12:08:56===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 12:08:20 >>>回调事件[910,devices/S2664]
2026-04-26 12:08:20 >>>故障排除日志:上一MQTT订单号缓存列表为2604261207050073471639|2604261207050073471639
2026-04-26 12:08:20 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 12:08:20 开始打印,排队:200,票券:2604261208121519124901,订单:2604261208120013251951,[2026-04-26 12:08:20支付宝支付10元]
2026-04-26 12:08:20>>>MQTT票号同步场景，创建空订单对象
2026-04-26 12:08:20>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 12:08:22 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261208121519124901","queue_number":200,"trade_uid":"2604261208120013251951"}]}
2026-04-26 12:08:22 >>>故障排除日志:删除未同步下发订单成功2604261208120013251951
2026-04-26 12:08:22 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536872901]


===12:18:56===
2026-04-26 12:18:41>>>cash read=00
2026-04-26 12:18:42>>>cash read=29
2026-04-26 12:18:42 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 12:18:42>>>cash read=2F29
2026-04-26 12:18:44>>>cash read=3E
2026-04-26 12:18:45>>>cash read=00
2026-04-26 12:18:47>>>cash read=818F42
2026-04-26 12:18:47>>>cash write=02
2026-04-26 12:18:47 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 12:18:47>>>cash read=10
2026-04-26 12:18:47 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 12:18:47 当前产品价格10元，投币10元，打印小票中...
2026-04-26 12:18:47 >>>开始打印,排队号为201,订单号为2604261218470022664938
2026-04-26 12:18:47>>>订单2604261218470022664938写入成功,剩余空间为1679500,占用RAM为634.86328125
删除未同步订单2604261218470022664938
2026-04-26 12:18:50>>>订单2604261218470022664938删除成功,剩余空间为1680500,占用RAM为644.466796875
检测订单目录中>>>
无未同步订单>>>
2026-04-26 12:18:50 >>>当前Ram内存为615.8740234375
定时检测未同步订单启用[checkOrderNum=536873005]
2026-04-26 12:18:51>>>cash write=0C
2026-04-26 12:18:51>>>cash read=00
2026-04-26 12:18:52>>>cash read=29
2026-04-26 12:18:52 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 12:18:52>>>cash read=2F29
2026-04-26 12:18:53>>>cash read=00
2026-04-26 12:18:54>>>cash read=29
2026-04-26 12:18:54 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 12:18:54>>>cash read=2F29


===12:19:57===
2026-04-26 12:18:56>>>cash read=3E
2026-04-26 12:18:59>>>cash read=00
2026-04-26 12:18:59>>>cash read=818F42
2026-04-26 12:18:59>>>cash write=02
2026-04-26 12:18:59 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 12:19:00>>>cash read=10
2026-04-26 12:19:00 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 12:19:00 当前产品价格10元，投币10元，打印小票中...
2026-04-26 12:19:00 >>>开始打印,排队号为202,订单号为2604261219000022664208
2026-04-26 12:19:00>>>订单2604261219000022664208写入成功,剩余空间为1679500,占用RAM为632.90234375
删除未同步订单2604261219000022664208
2026-04-26 12:19:02>>>订单2604261219000022664208删除成功,剩余空间为1680500,占用RAM为641.9970703125
检测订单目录中>>>
无未同步订单>>>
2026-04-26 12:19:02 >>>当前Ram内存为615.0947265625
定时检测未同步订单启用[checkOrderNum=536873016]
2026-04-26 12:19:03>>>cash write=0C
2026-04-26 12:19:03>>>cash read=3E


===12:24:57===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 12:24:33 >>>回调事件[910,devices/S2664]
2026-04-26 12:24:33 >>>故障排除日志:上一MQTT订单号缓存列表为2604261208120013251951
2026-04-26 12:24:33 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 12:24:33 开始打印,排队:203,票券:2604261224192191235201,订单:2604261224190020082925,[2026-04-26 12:24:32微信支付10元]
2026-04-26 12:24:33>>>MQTT票号同步场景，创建空订单对象
2026-04-26 12:24:33>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 12:24:35 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261224192191235201","queue_number":203,"trade_uid":"2604261224190020082925"}]}
2026-04-26 12:24:35 >>>故障排除日志:删除未同步下发订单成功2604261224190020082925
2026-04-26 12:24:35 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536873071]


===12:34:57===
2026-04-26 12:34:32>>>cash read=00
2026-04-26 12:34:33>>>cash read=818F42
2026-04-26 12:34:33>>>cash write=02
2026-04-26 12:34:33 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 12:34:34>>>cash read=10
2026-04-26 12:34:34 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 12:34:34 当前产品价格10元，投币10元，打印小票中...
2026-04-26 12:34:34 >>>开始打印,排队号为204,订单号为2604261234340022664042
2026-04-26 12:34:34>>>订单2604261234340022664042写入成功,剩余空间为1679500,占用RAM为633.767578125
删除未同步订单2604261234340022664042
2026-04-26 12:34:36>>>订单2604261234340022664042删除成功,剩余空间为1680500,占用RAM为642.7333984375
检测订单目录中>>>
无未同步订单>>>
2026-04-26 12:34:36 >>>当前Ram内存为615.982421875
定时检测未同步订单启用[checkOrderNum=536873170]
2026-04-26 12:34:37>>>cash read=818F42
2026-04-26 12:34:37 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 12:34:37>>>cash read=10
2026-04-26 12:34:37 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 12:34:37 当前产品价格10元，投币10元，打印小票中...
2026-04-26 12:34:37 >>>开始打印,排队号为205,订单号为2604261234370022664690
2026-04-26 12:34:38>>>订单2604261234370022664690写入成功,剩余空间为1679000,占用RAM为638.95703125
删除未同步订单2604261234370022664690
2026-04-26 12:34:40>>>订单2604261234370022664690删除成功,剩余空间为1679500,占用RAM为647.2744140625
检测订单目录中>>>
无未同步订单>>>
2026-04-26 12:34:40 >>>当前Ram内存为617.423828125
定时检测未同步订单启用[checkOrderNum=536873177]
2026-04-26 12:34:41>>>cash read=818F42
2026-04-26 12:34:41 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 12:34:41>>>cash read=10
2026-04-26 12:34:41 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 12:34:41 当前产品价格10元，投币10元，打印小票中...
2026-04-26 12:34:41 >>>开始打印,排队号为206,订单号为2604261234410022664759
2026-04-26 12:34:42>>>订单2604261234410022664759写入成功,剩余空间为1678000,占用RAM为650.6748046875
删除未同步订单2604261234410022664759
2026-04-26 12:34:44>>>订单2604261234410022664759删除成功,剩余空间为1678500,占用RAM为649.56640625
检测订单目录中>>>
无未同步订单>>>
2026-04-26 12:34:44 >>>当前Ram内存为618.4248046875
定时检测未同步订单启用[checkOrderNum=536873189]
2026-04-26 12:34:44>>>cash read=818F42
2026-04-26 12:34:44 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 12:34:45>>>cash read=10
2026-04-26 12:34:45 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 12:34:45 当前产品价格10元，投币10元，打印小票中...
2026-04-26 12:34:45 >>>开始打印,排队号为207,订单号为2604261234450022664559
2026-04-26 12:34:45>>>订单2604261234450022664559写入成功,剩余空间为1677000,占用RAM为653.0458984375
删除未同步订单2604261234450022664559
2026-04-26 12:34:48>>>订单2604261234450022664559删除成功,剩余空间为1678000,占用RAM为652.7236328125
检测订单目录中>>>
无未同步订单>>>
2026-04-26 12:34:48 >>>当前Ram内存为619.5537109375
定时检测未同步订单启用[checkOrderNum=536873196]
2026-04-26 12:34:48>>>cash read=818F42
2026-04-26 12:34:48 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 12:34:48>>>cash read=10
2026-04-26 12:34:49 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 12:34:49 当前产品价格10元，投币10元，打印小票中...
2026-04-26 12:34:49 >>>开始打印,排队号为208,订单号为2604261234490022664360
2026-04-26 12:34:49>>>订单2604261234490022664360写入成功,剩余空间为1676000,占用RAM为659.716796875
删除未同步订单2604261234490022664360
2026-04-26 12:34:51>>>订单2604261234490022664360删除成功,剩余空间为1677000,占用RAM为655.2509765625
检测订单目录中>>>
无未同步订单>>>
2026-04-26 12:34:51 >>>当前Ram内存为620.681640625
定时检测未同步订单启用[checkOrderNum=536873203]
2026-04-26 12:34:52>>>cash read=818F42
2026-04-26 12:34:52 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 12:34:52>>>cash read=10
2026-04-26 12:34:52 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 12:34:52 当前产品价格10元，投币10元，打印小票中...
检测订单目录中>>>


===12:35:57===
2026-04-26 12:35:27>>>cash read=00
2026-04-26 12:35:28>>>cash read=818F42
2026-04-26 12:35:28>>>cash write=02
2026-04-26 12:35:28 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 12:35:28>>>cash read=10
2026-04-26 12:35:28 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 12:35:28 当前产品价格10元，投币10元，打印小票中...
2026-04-26 12:35:28 >>>开始打印,排队号为210,订单号为2604261235280022664263
2026-04-26 12:35:29>>>订单2604261235280022664263写入成功,剩余空间为1679500,占用RAM为633.1357421875
2026-04-26 12:35:31>>>cash read=818F42
2026-04-26 12:35:31 >>>回调事件130,cash_status,10022,进钞中...read money=10
删除未同步订单2604261235280022664263
2026-04-26 12:35:31>>>订单2604261235280022664263删除成功,剩余空间为1680500,占用RAM为629.263671875
检测订单目录中>>>
无未同步订单>>>
2026-04-26 12:35:31 >>>当前Ram内存为616.5126953125
定时检测未同步订单启用[checkOrderNum=536873223]
2026-04-26 12:35:31>>>cash read=10
2026-04-26 12:35:31 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 12:35:31 当前产品价格10元，投币10元，打印小票中...
2026-04-26 12:35:31 >>>开始打印,排队号为211,订单号为2604261235310022664269
2026-04-26 12:35:32>>>订单2604261235310022664269写入成功,剩余空间为1679000,占用RAM为638.869140625
删除未同步订单2604261235310022664269
2026-04-26 12:35:34>>>订单2604261235310022664269删除成功,剩余空间为1679500,占用RAM为648.228515625
检测订单目录中>>>
无未同步订单>>>
2026-04-26 12:35:34 >>>当前Ram内存为618.3310546875
定时检测未同步订单启用[checkOrderNum=536873230]
2026-04-26 12:35:34>>>cash read=818F42
2026-04-26 12:35:34 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 12:35:34>>>cash read=10
2026-04-26 12:35:35 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 12:35:35 当前产品价格10元，投币10元，打印小票中...
2026-04-26 12:35:35 >>>开始打印,排队号为212,订单号为2604261235350022664079
2026-04-26 12:35:35>>>订单2604261235350022664079写入成功,剩余空间为1678000,占用RAM为648.091796875
删除未同步订单2604261235350022664079
2026-04-26 12:35:37>>>订单2604261235350022664079删除成功,剩余空间为1678500,占用RAM为649.26953125
检测订单目录中>>>
无未同步订单>>>
2026-04-26 12:35:37 >>>当前Ram内存为619.45703125
定时检测未同步订单启用[checkOrderNum=536873237]
2026-04-26 12:35:38>>>cash write=0C
2026-04-26 12:35:38>>>cash read=3E


===12:36:58===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 12:36:33 >>>回调事件[910,devices/S2664]
2026-04-26 12:36:33 >>>故障排除日志:上一MQTT订单号缓存列表为2604261224190020082925
2026-04-26 12:36:33 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 12:36:33 开始打印,排队:213,票券:2604261236251101864201,订单:2604261236250009238868,[2026-04-26 12:36:33微信支付10元]
2026-04-26 12:36:33 开始打印,排队:214,票券:2604261236251102254902,订单:2604261236250009238868,[2026-04-26 12:36:33微信支付10元]
2026-04-26 12:36:34>>>MQTT票号同步场景，创建空订单对象
2026-04-26 12:36:34>>>合并MQTT票号列表到订单同步请求,共2张票
2026-04-26 12:36:37 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261236251101864201","queue_number":213,"trade_uid":"2604261236250009238868"},{"ticket_no":"2604261236251102254902","queue_number":214,"trade_uid":"2604261236250009238868"}]}
2026-04-26 12:36:37 >>>故障排除日志:删除未同步下发订单成功2604261236250009238868
2026-04-26 12:36:37 >>>故障排除日志:删除未同步下发订单成功2604261236250009238868
2026-04-26 12:36:37 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536873254]


===12:42:58===
2026-04-26 12:42:22>>>cash read=0A
2026-04-26 12:42:23>>>cash read=3E


===12:44:58===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 12:44:03 >>>回调事件[910,devices/S2664]
2026-04-26 12:44:03 >>>故障排除日志:上一MQTT订单号缓存列表为2604261236250009238868|2604261236250009238868
2026-04-26 12:44:03 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 12:44:03 开始打印,排队:215,票券:2604261243555254322601,订单:2604261243550050615245,[2026-04-26 12:44:02微信支付10元]
2026-04-26 12:44:03>>>MQTT票号同步场景，创建空订单对象
2026-04-26 12:44:03>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 12:44:05 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261243555254322601","queue_number":215,"trade_uid":"2604261243550050615245"}]}
2026-04-26 12:44:05 >>>故障排除日志:删除未同步下发订单成功2604261243550050615245
2026-04-26 12:44:05 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536873335]


===12:47:59===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 12:47:28 >>>回调事件[910,devices/S2664]
2026-04-26 12:47:28 >>>故障排除日志:上一MQTT订单号缓存列表为2604261243550050615245
2026-04-26 12:47:28 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 12:47:28 开始打印,排队:216,票券:2604261247100217027501,订单:2604261247100000099823,[2026-04-26 12:47:26微信支付10元]
2026-04-26 12:47:28>>>MQTT票号同步场景，创建空订单对象
2026-04-26 12:47:28>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 12:47:30 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261247100217027501","queue_number":216,"trade_uid":"2604261247100000099823"}]}
2026-04-26 12:47:30 >>>故障排除日志:删除未同步下发订单成功2604261247100000099823
2026-04-26 12:47:30 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536873370]


===12:48:59===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 12:48:38 >>>回调事件[910,devices/S2664]
2026-04-26 12:48:38 >>>故障排除日志:上一MQTT订单号缓存列表为2604261247100000099823
2026-04-26 12:48:38 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 12:48:38 开始打印,排队:217,票券:2604261248307691845701,订单:2604261248300074433635,[2026-04-26 12:48:38微信支付10元]
2026-04-26 12:48:38>>>MQTT票号同步场景，创建空订单对象
2026-04-26 12:48:38>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 12:48:40 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261248307691845701","queue_number":217,"trade_uid":"2604261248300074433635"}]}
2026-04-26 12:48:40 >>>故障排除日志:删除未同步下发订单成功2604261248300074433635
2026-04-26 12:48:40 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536873388]


===12:50:59===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 12:50:13 >>>回调事件[910,devices/S2664]
2026-04-26 12:50:13 >>>故障排除日志:上一MQTT订单号缓存列表为2604261248300074433635
2026-04-26 12:50:13 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 12:50:13 开始打印,排队:218,票券:2604261250046974735101,订单:2604261250040067804231,[2026-04-26 12:50:12微信支付10元]
2026-04-26 12:50:13>>>MQTT票号同步场景，创建空订单对象
2026-04-26 12:50:13>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 12:50:15 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261250046974735101","queue_number":218,"trade_uid":"2604261250040067804231"}]}
2026-04-26 12:50:15 >>>故障排除日志:删除未同步下发订单成功2604261250040067804231
2026-04-26 12:50:15 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536873413]


===12:54:00===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 12:53:02 >>>回调事件[910,devices/S2664]
2026-04-26 12:53:02 >>>故障排除日志:上一MQTT订单号缓存列表为2604261250040067804231
2026-04-26 12:53:02 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 12:53:02 开始打印,排队:219,票券:2604261252516895751601,订单:2604261252510066973212,[2026-04-26 12:53:01微信支付10元]
2026-04-26 12:53:02 开始打印,排队:220,票券:2604261252516896395802,订单:2604261252510066973212,[2026-04-26 12:53:01微信支付10元]
2026-04-26 12:53:02>>>MQTT票号同步场景，创建空订单对象
2026-04-26 12:53:02>>>合并MQTT票号列表到订单同步请求,共2张票
2026-04-26 12:53:06 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261252516895751601","queue_number":219,"trade_uid":"2604261252510066973212"},{"ticket_no":"2604261252516896395802","queue_number":220,"trade_uid":"2604261252510066973212"}]}
2026-04-26 12:53:06 >>>故障排除日志:删除未同步下发订单成功2604261252510066973212
2026-04-26 12:53:06 >>>故障排除日志:删除未同步下发订单成功2604261252510066973212
2026-04-26 12:53:06 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536873451]


===12:57:00===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 12:56:57 >>>回调事件[910,devices/S2664]
2026-04-26 12:56:57 >>>故障排除日志:上一MQTT订单号缓存列表为2604261252510066973212|2604261252510066973212
2026-04-26 12:56:57 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 12:56:57 开始打印,排队:221,票券:2604261256473633284801,订单:2604261256470034368169,[2026-04-26 12:56:57微信支付10元]
2026-04-26 12:56:57>>>MQTT票号同步场景，创建空订单对象
2026-04-26 12:56:57>>>合并MQTT票号列表到订单同步请求,共1张票


===13:01:01===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 13:00:17 >>>回调事件[910,devices/S2664]
2026-04-26 13:00:17 >>>故障排除日志:上一MQTT订单号缓存列表为2604261256470034368169
2026-04-26 13:00:17 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 13:00:18 开始打印,排队:222,票券:2604261300058304368901,订单:2604261300050080985416,[2026-04-26 13:00:17微信支付10元]
2026-04-26 13:00:18>>>MQTT票号同步场景，创建空订单对象
2026-04-26 13:00:18>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 13:00:20 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261300058304368901","queue_number":222,"trade_uid":"2604261300050080985416"}]}
2026-04-26 13:00:20 >>>故障排除日志:删除未同步下发订单成功2604261300050080985416
2026-04-26 13:00:20 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536873535]


===13:05:01===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 13:04:16 >>>回调事件[910,devices/S2664]
2026-04-26 13:04:16 >>>故障排除日志:上一MQTT订单号缓存列表为2604261300050080985416
2026-04-26 13:04:16 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 13:04:16 开始打印,排队:223,票券:2604261304116063032901,订单:2604261304110058734176,[2026-04-26 13:04:16微信支付10元]
2026-04-26 13:04:16>>>MQTT票号同步场景，创建空订单对象
2026-04-26 13:04:16>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 13:04:18 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261304116063032901","queue_number":223,"trade_uid":"2604261304110058734176"}]}
2026-04-26 13:04:18 >>>故障排除日志:删除未同步下发订单成功2604261304110058734176
2026-04-26 13:04:18 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536873579]


===13:15:01===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 13:14:10 >>>回调事件[910,devices/S2664]
2026-04-26 13:14:10 >>>故障排除日志:上一MQTT订单号缓存列表为2604261304110058734176
2026-04-26 13:14:10 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 13:14:10 开始打印,排队:224,票券:2604261314013492274701,订单:2604261314010032772293,[2026-04-26 13:14:09微信支付10元]
2026-04-26 13:14:10>>>MQTT票号同步场景，创建空订单对象
2026-04-26 13:14:10>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 13:14:12 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261314013492274701","queue_number":224,"trade_uid":"2604261314010032772293"}]}
2026-04-26 13:14:12 >>>故障排除日志:删除未同步下发订单成功2604261314010032772293
2026-04-26 13:14:12 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536873676]


===13:31:02===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 13:30:49 >>>回调事件[910,devices/S2664]
2026-04-26 13:30:49 >>>故障排除日志:上一MQTT订单号缓存列表为2604261314010032772293
2026-04-26 13:30:49 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 13:30:49 开始打印,排队:225,票券:2604261330423691342501,订单:2604261330420033346825,[2026-04-26 13:30:48微信支付10元]
2026-04-26 13:30:49>>>MQTT票号同步场景，创建空订单对象
2026-04-26 13:30:49>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 13:30:51 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261330423691342501","queue_number":225,"trade_uid":"2604261330420033346825"}]}
2026-04-26 13:30:51 >>>故障排除日志:删除未同步下发订单成功2604261330420033346825
2026-04-26 13:30:51 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536873835]


===13:34:02===
2026-04-26 13:33:32>>>cash read=00
2026-04-26 13:33:32>>>cash read=818F42
2026-04-26 13:33:32>>>cash write=02
2026-04-26 13:33:32 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 13:33:33>>>cash read=10
2026-04-26 13:33:33 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 13:33:33 当前产品价格10元，投币10元，打印小票中...
2026-04-26 13:33:33 >>>开始打印,排队号为226,订单号为2604261333330022664425
2026-04-26 13:33:33>>>订单2604261333330022664425写入成功,剩余空间为1679500,占用RAM为633.5185546875
删除未同步订单2604261333330022664425
2026-04-26 13:33:35>>>订单2604261333330022664425删除成功,剩余空间为1680500,占用RAM为645.298828125
检测订单目录中>>>
无未同步订单>>>
2026-04-26 13:33:35 >>>当前Ram内存为617.58984375
定时检测未同步订单启用[checkOrderNum=536873865]
2026-04-26 13:33:36>>>cash write=0C
2026-04-26 13:33:36>>>cash read=3E


===13:44:02===
2026-04-26 13:43:44>>>cash read=00
2026-04-26 13:43:44>>>cash read=818F43
2026-04-26 13:43:44>>>cash write=02
2026-04-26 13:43:44 >>>回调事件130,cash_status,10022,进钞中...read money=20
2026-04-26 13:43:45>>>cash read=10
2026-04-26 13:43:45 >>>回调事件130,20,10023,finish Money=20,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 13:43:45 当前产品价格10元，投币20元，打印小票中...
2026-04-26 13:43:45 >>>开始打印,排队号为227,订单号为2604261343450022664111
2026-04-26 13:43:45 >>>开始打印,排队号为228,订单号为2604261343450022664111
2026-04-26 13:43:45>>>订单2604261343450022664111写入成功,剩余空间为1679000,占用RAM为642.45703125
删除未同步订单2604261343450022664111
2026-04-26 13:43:49>>>订单2604261343450022664111删除成功,剩余空间为1680500,占用RAM为658.0322265625
检测订单目录中>>>
无未同步订单>>>
2026-04-26 13:43:49 >>>当前Ram内存为618.7001953125
定时检测未同步订单启用[checkOrderNum=536873969]
2026-04-26 13:43:50>>>cash write=0C
2026-04-26 13:43:50>>>cash read=3E


===13:54:02===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 13:53:02 >>>回调事件[910,devices/S2664]
2026-04-26 13:53:02 >>>故障排除日志:上一MQTT订单号缓存列表为2604261330420033346825
2026-04-26 13:53:02 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 13:53:02 开始打印,排队:229,票券:2604261352541402976901,订单:2604261352540011740727,[2026-04-26 13:53:02支付宝支付10元]
2026-04-26 13:53:03>>>MQTT票号同步场景，创建空订单对象
2026-04-26 13:53:03>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 13:53:04 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261352541402976901","queue_number":229,"trade_uid":"2604261352540011740727"}]}
2026-04-26 13:53:04 >>>故障排除日志:删除未同步下发订单成功2604261352540011740727
2026-04-26 13:53:05 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536874061]


===13:55:02===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 13:54:07 >>>回调事件[910,devices/S2664]
2026-04-26 13:54:07 >>>故障排除日志:上一MQTT订单号缓存列表为2604261352540011740727
2026-04-26 13:54:07 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 13:54:07 开始打印,排队:230,票券:2604261354009279235901,订单:2604261354000090702668,[2026-04-26 13:54:07微信支付10元]
2026-04-26 13:54:08>>>MQTT票号同步场景，创建空订单对象
2026-04-26 13:54:08>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 13:54:09 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261354009279235901","queue_number":230,"trade_uid":"2604261354000090702668"}]}
2026-04-26 13:54:09 >>>故障排除日志:删除未同步下发订单成功2604261354000090702668
2026-04-26 13:54:09 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536874078]


===14:12:03===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 14:11:49 >>>回调事件[910,devices/S2664]
2026-04-26 14:11:49 >>>故障排除日志:上一MQTT订单号缓存列表为2604261354000090702668
2026-04-26 14:11:49 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 14:11:49 开始打印,排队:231,票券:2604261411428882475301,订单:2604261411420086300376,[2026-04-26 14:11:48支付宝支付10元]
2026-04-26 14:11:49>>>MQTT票号同步场景，创建空订单对象
2026-04-26 14:11:49>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 14:11:51 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261411428882475301","queue_number":231,"trade_uid":"2604261411420086300376"}]}
2026-04-26 14:11:51 >>>故障排除日志:删除未同步下发订单成功2604261411420086300376
2026-04-26 14:11:51 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536874245]


===14:19:03===
2026-04-26 14:18:58>>>cash read=00
2026-04-26 14:18:58>>>cash read=818F42
2026-04-26 14:18:58>>>cash write=02
2026-04-26 14:18:58 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 14:18:58>>>cash read=10
2026-04-26 14:18:58 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 14:18:58 当前产品价格10元，投币10元，打印小票中...
2026-04-26 14:18:58 >>>开始打印,排队号为232,订单号为2604261418580022664229
2026-04-26 14:18:59>>>订单2604261418580022664229写入成功,剩余空间为1679500,占用RAM为634.26953125
删除未同步订单2604261418580022664229
2026-04-26 14:19:01>>>订单2604261418580022664229删除成功,剩余空间为1680500,占用RAM为648.546875
检测订单目录中>>>
无未同步订单>>>
2026-04-26 14:19:01 >>>当前Ram内存为616.0224609375
定时检测未同步订单启用[checkOrderNum=536874318]
2026-04-26 14:19:02>>>cash write=0C
2026-04-26 14:19:02>>>cash read=3E


===14:25:04===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 14:24:37 >>>回调事件[910,devices/S2664]
2026-04-26 14:24:37 >>>故障排除日志:上一MQTT订单号缓存列表为2604261411420086300376
2026-04-26 14:24:37 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 14:24:37 开始打印,排队:233,票券:2604261424256460683801,订单:2604261424250062653957,[2026-04-26 14:24:37微信支付10元]
2026-04-26 14:24:37>>>MQTT票号同步场景，创建空订单对象
2026-04-26 14:24:37>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 14:24:39 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261424256460683801","queue_number":233,"trade_uid":"2604261424250062653957"}]}
2026-04-26 14:24:39 >>>故障排除日志:删除未同步下发订单成功2604261424250062653957
2026-04-26 14:24:39 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536874373]


===14:26:04===
2026-04-26 14:25:17>>>cash read=00
2026-04-26 14:25:17>>>cash read=818F42
2026-04-26 14:25:17>>>cash write=02
2026-04-26 14:25:17 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 14:25:18>>>cash read=10
2026-04-26 14:25:18 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 14:25:18 当前产品价格10元，投币10元，打印小票中...
2026-04-26 14:25:18 >>>开始打印,排队号为234,订单号为2604261425180022664736
2026-04-26 14:25:18>>>订单2604261425180022664736写入成功,剩余空间为1679500,占用RAM为632.9775390625
2026-04-26 14:25:20>>>cash read=818F42
2026-04-26 14:25:20 >>>回调事件130,cash_status,10022,进钞中...read money=10
删除未同步订单2604261425180022664736
2026-04-26 14:25:20>>>订单2604261425180022664736删除成功,剩余空间为1680500,占用RAM为628.98046875
检测订单目录中>>>
无未同步订单>>>
2026-04-26 14:25:20 >>>当前Ram内存为614.6328125
定时检测未同步订单启用[checkOrderNum=536874391]
2026-04-26 14:25:21>>>cash read=10
2026-04-26 14:25:21 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 14:25:21 当前产品价格10元，投币10元，打印小票中...
2026-04-26 14:25:21 >>>开始打印,排队号为235,订单号为2604261425210022664632
2026-04-26 14:25:21>>>订单2604261425210022664632写入成功,剩余空间为1679000,占用RAM为636.91015625
删除未同步订单2604261425210022664632
2026-04-26 14:25:23>>>订单2604261425210022664632删除成功,剩余空间为1679500,占用RAM为646.263671875
检测订单目录中>>>
无未同步订单>>>
2026-04-26 14:25:23 >>>当前Ram内存为616.447265625
定时检测未同步订单启用[checkOrderNum=536874398]
2026-04-26 14:25:24>>>cash write=0C
2026-04-26 14:25:24>>>cash read=3E


===14:27:04===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 14:26:21 >>>回调事件[910,devices/S2664]
2026-04-26 14:26:21 >>>故障排除日志:上一MQTT订单号缓存列表为2604261424250062653957
2026-04-26 14:26:21 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 14:26:21 开始打印,排队:236,票券:2604261426135288123801,订单:2604261426130050880938,[2026-04-26 14:26:20微信支付10元]
2026-04-26 14:26:21>>>MQTT票号同步场景，创建空订单对象
2026-04-26 14:26:21>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 14:26:23 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261426135288123801","queue_number":236,"trade_uid":"2604261426130050880938"}]}
2026-04-26 14:26:23 >>>故障排除日志:删除未同步下发订单成功2604261426130050880938
2026-04-26 14:26:23 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536874415]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 14:26:39 >>>回调事件[910,devices/S2664]
2026-04-26 14:26:39 >>>故障排除日志:上一MQTT订单号缓存列表为2604261426130050880938
2026-04-26 14:26:39 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 14:26:39 开始打印,排队:237,票券:2604261426316653521201,订单:2604261426310064442918,[2026-04-26 14:26:38微信支付10元]
2026-04-26 14:26:39>>>MQTT票号同步场景，创建空订单对象
2026-04-26 14:26:39>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 14:26:41 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261426316653521201","queue_number":237,"trade_uid":"2604261426310064442918"}]}
2026-04-26 14:26:42 >>>故障排除日志:删除未同步下发订单成功2604261426310064442918
2026-04-26 14:26:42 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536874426]


===14:38:05===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 14:37:43 >>>回调事件[910,devices/S2664]
2026-04-26 14:37:43 >>>故障排除日志:上一MQTT订单号缓存列表为2604261426310064442918
2026-04-26 14:37:43 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 14:37:43 开始打印,排队:238,票券:2604261437338804649401,订单:2604261437330086153029,[2026-04-26 14:37:42微信支付10元]
2026-04-26 14:37:43>>>MQTT票号同步场景，创建空订单对象
2026-04-26 14:37:43>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 14:37:45 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261437338804649401","queue_number":238,"trade_uid":"2604261437330086153029"}]}
2026-04-26 14:37:45 >>>故障排除日志:删除未同步下发订单成功2604261437330086153029
2026-04-26 14:37:45 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536874533]


===14:41:05===
2026-04-26 14:40:59>>>cash read=BF
2026-04-26 14:41:01>>>cash read=3E


===14:42:07===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 14:41:33 >>>回调事件[910,devices/S2664]
2026-04-26 14:41:33 >>>故障排除日志:上一MQTT订单号缓存列表为2604261437330086153029
2026-04-26 14:41:33 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 14:41:33 开始打印,排队:239,票券:2604261441249690715601,订单:2604261441240094750164,[2026-04-26 14:41:32微信支付10元]
2026-04-26 14:41:33>>>MQTT票号同步场景，创建空订单对象
2026-04-26 14:41:33>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 14:41:35 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261441249690715601","queue_number":239,"trade_uid":"2604261441240094750164"}]}
2026-04-26 14:41:35 >>>故障排除日志:删除未同步下发订单成功2604261441240094750164
2026-04-26 14:41:35 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536874574]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 14:42:04 >>>回调事件[910,devices/S2664]
2026-04-26 14:42:04 >>>故障排除日志:上一MQTT订单号缓存列表为2604261441240094750164
2026-04-26 14:42:04 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 14:42:04 开始打印,排队:240,票券:2604261441568555566701,订单:2604261441560083804547,[2026-04-26 14:42:03微信支付10元]
2026-04-26 14:42:04>>>MQTT票号同步场景，创建空订单对象
2026-04-26 14:42:04>>>合并MQTT票号列表到订单同步请求,共1张票


===14:43:07===
2026-04-26 14:42:06 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261441568555566701","queue_number":240,"trade_uid":"2604261441560083804547"}]}
2026-04-26 14:42:06 >>>故障排除日志:删除未同步下发订单成功2604261441560083804547
2026-04-26 14:42:06 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536874590]


===14:56:08===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 14:55:19 >>>回调事件[910,devices/S2664]
2026-04-26 14:55:19 >>>故障排除日志:上一MQTT订单号缓存列表为2604261441560083804547
2026-04-26 14:55:19 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 14:55:19 开始打印,排队:241,票券:2604261455116816708601,订单:2604261455110066364395,[2026-04-26 14:55:18微信支付10元]
2026-04-26 14:55:19>>>MQTT票号同步场景，创建空订单对象
2026-04-26 14:55:19>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 14:55:21 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261455116816708601","queue_number":241,"trade_uid":"2604261455110066364395"}]}
2026-04-26 14:55:21 >>>故障排除日志:删除未同步下发订单成功2604261455110066364395
2026-04-26 14:55:22 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536874716]


===14:58:08===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 14:58:04 >>>回调事件[910,devices/S2664]
2026-04-26 14:58:04 >>>故障排除日志:上一MQTT订单号缓存列表为2604261455110066364395
2026-04-26 14:58:04 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 14:58:04 开始打印,排队:242,票券:2604261457552571742901,订单:2604261457550023870682,[2026-04-26 14:58:03微信支付10元]
2026-04-26 14:58:04>>>MQTT票号同步场景，创建空订单对象
2026-04-26 14:58:04>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 14:58:06 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261457552571742901","queue_number":242,"trade_uid":"2604261457550023870682"}]}
2026-04-26 14:58:06 >>>故障排除日志:删除未同步下发订单成功2604261457550023870682
2026-04-26 14:58:06 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536874750]


===15:05:08===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 15:04:10 >>>回调事件[910,devices/S2664]
2026-04-26 15:04:10 >>>故障排除日志:上一MQTT订单号缓存列表为2604261457550023870682
2026-04-26 15:04:10 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 15:04:10 开始打印,排队:243,票券:2604261504013346713701,订单:2604261504010031545181,[2026-04-26 15:04:07微信支付10元]
2026-04-26 15:04:10>>>MQTT票号同步场景，创建空订单对象
2026-04-26 15:04:10>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 15:04:12 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261504013346713701","queue_number":243,"trade_uid":"2604261504010031545181"}]}
2026-04-26 15:04:12 >>>故障排除日志:删除未同步下发订单成功2604261504010031545181
2026-04-26 15:04:12 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536874812]


===15:13:08===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 15:12:14 >>>回调事件[910,devices/S2664]
2026-04-26 15:12:14 >>>故障排除日志:上一MQTT订单号缓存列表为2604261504010031545181
2026-04-26 15:12:14 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 15:12:14 开始打印,排队:244,票券:2604261511537080442101,订单:2604261511530069012329,[2026-04-26 15:12:13微信支付10元]
2026-04-26 15:12:14 开始打印,排队:245,票券:2604261511537080984302,订单:2604261511530069012329,[2026-04-26 15:12:13微信支付10元]
2026-04-26 15:12:14>>>MQTT票号同步场景，创建空订单对象
2026-04-26 15:12:14>>>合并MQTT票号列表到订单同步请求,共2张票
2026-04-26 15:12:18 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261511537080442101","queue_number":244,"trade_uid":"2604261511530069012329"},{"ticket_no":"2604261511537080984302","queue_number":245,"trade_uid":"2604261511530069012329"}]}
2026-04-26 15:12:18 >>>故障排除日志:删除未同步下发订单成功2604261511530069012329
2026-04-26 15:12:18 >>>故障排除日志:删除未同步下发订单成功2604261511530069012329
2026-04-26 15:12:18 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536874892]


===15:23:09===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 15:22:50 >>>回调事件[910,devices/S2664]
2026-04-26 15:22:50 >>>故障排除日志:上一MQTT订单号缓存列表为2604261511530069012329|2604261511530069012329
2026-04-26 15:22:50 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 15:22:50 开始打印,排队:246,票券:2604261522423084769101,订单:2604261522420028172526,[2026-04-26 15:22:49微信支付10元]
2026-04-26 15:22:50>>>MQTT票号同步场景，创建空订单对象
2026-04-26 15:22:50>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 15:22:52 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261522423084769101","queue_number":246,"trade_uid":"2604261522420028172526"}]}
2026-04-26 15:22:52 >>>故障排除日志:删除未同步下发订单成功2604261522420028172526
2026-04-26 15:22:52 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536874996]


===15:30:09===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 15:29:12 >>>回调事件[910,devices/S2664]
2026-04-26 15:29:12 >>>故障排除日志:上一MQTT订单号缓存列表为2604261522420028172526
2026-04-26 15:29:12 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 15:29:12 开始打印,排队:247,票券:2604261529042856152801,订单:2604261529040026106419,[2026-04-26 15:29:11微信支付10元]
2026-04-26 15:29:12>>>MQTT票号同步场景，创建空订单对象
2026-04-26 15:29:12>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 15:29:14 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261529042856152801","queue_number":247,"trade_uid":"2604261529040026106419"}]}
2026-04-26 15:29:14 >>>故障排除日志:删除未同步下发订单成功2604261529040026106419
2026-04-26 15:29:14 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536875061]


===15:38:09===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 15:38:05 >>>回调事件[910,devices/S2664]
2026-04-26 15:38:05 >>>故障排除日志:上一MQTT订单号缓存列表为2604261529040026106419
2026-04-26 15:38:05 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 15:38:05 开始打印,排队:248,票券:2604261537580428714501,订单:2604261537580001963253,[2026-04-26 15:38:04微信支付10元]
2026-04-26 15:38:05>>>MQTT票号同步场景，创建空订单对象
2026-04-26 15:38:05>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 15:38:07 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261537580428714501","queue_number":248,"trade_uid":"2604261537580001963253"}]}
2026-04-26 15:38:07 >>>故障排除日志:删除未同步下发订单成功2604261537580001963253
2026-04-26 15:38:07 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536875150]


===15:40:11===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 15:40:08 >>>回调事件[910,devices/S2664]
2026-04-26 15:40:08 >>>故障排除日志:上一MQTT订单号缓存列表为2604261537580001963253
2026-04-26 15:40:08 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 15:40:08 开始打印,排队:249,票券:2604261539593679862701,订单:2604261539590034765441,[2026-04-26 15:40:07微信支付10元]
2026-04-26 15:40:08>>>MQTT票号同步场景，创建空订单对象
2026-04-26 15:40:08>>>合并MQTT票号列表到订单同步请求,共1张票


===15:41:11===
2026-04-26 15:40:10 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261539593679862701","queue_number":249,"trade_uid":"2604261539590034765441"}]}
2026-04-26 15:40:10 >>>故障排除日志:删除未同步下发订单成功2604261539590034765441
2026-04-26 15:40:10 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536875178]


===15:44:11===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 15:43:36 >>>回调事件[910,devices/S2664]
2026-04-26 15:43:36 >>>故障排除日志:上一MQTT订单号缓存列表为2604261539590034765441
2026-04-26 15:43:36 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 15:43:36 开始打印,排队:250,票券:2604261543263114858401,订单:2604261543260028815694,[2026-04-26 15:43:34微信支付10元]
2026-04-26 15:43:36>>>MQTT票号同步场景，创建空订单对象
2026-04-26 15:43:36>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 15:43:38 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261543263114858401","queue_number":250,"trade_uid":"2604261543260028815694"}]}
2026-04-26 15:43:38 >>>故障排除日志:删除未同步下发订单成功2604261543260028815694
2026-04-26 15:43:38 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536875214]


===15:45:11===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 15:44:35 >>>回调事件[910,devices/S2664]
2026-04-26 15:44:35 >>>故障排除日志:上一MQTT订单号缓存列表为2604261543260028815694
2026-04-26 15:44:35 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 15:44:35 开始打印,排队:251,票券:2604261544261755756701,订单:2604261544260015440545,[2026-04-26 15:44:34微信支付10元]
2026-04-26 15:44:35>>>MQTT票号同步场景，创建空订单对象
2026-04-26 15:44:35>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 15:44:37 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261544261755756701","queue_number":251,"trade_uid":"2604261544260015440545"}]}
2026-04-26 15:44:37 >>>故障排除日志:删除未同步下发订单成功2604261544260015440545
2026-04-26 15:44:37 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536875231]


===15:49:11===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 15:48:55 >>>回调事件[910,devices/S2664]
2026-04-26 15:48:55 >>>故障排除日志:上一MQTT订单号缓存列表为2604261544260015440545
2026-04-26 15:48:55 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 15:48:55 开始打印,排队:252,票券:2604261548465646424201,订单:2604261548460054300818,[2026-04-26 15:48:54微信支付10元]
2026-04-26 15:48:55>>>MQTT票号同步场景，创建空订单对象
2026-04-26 15:48:55>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 15:48:57 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261548465646424201","queue_number":252,"trade_uid":"2604261548460054300818"}]}
2026-04-26 15:48:57 >>>故障排除日志:删除未同步下发订单成功2604261548460054300818
2026-04-26 15:48:57 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536875280]


===15:54:12===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 15:53:49 >>>回调事件[910,devices/S2664]
2026-04-26 15:53:49 >>>故障排除日志:上一MQTT订单号缓存列表为2604261548460054300818
2026-04-26 15:53:49 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 15:53:49 开始打印,排队:253,票券:2604261553432115164201,订单:2604261553430018144723,[2026-04-26 15:53:49微信支付10元]
2026-04-26 15:53:49>>>MQTT票号同步场景，创建空订单对象
2026-04-26 15:53:49>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 15:53:51 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261553432115164201","queue_number":253,"trade_uid":"2604261553430018144723"}]}
2026-04-26 15:53:51 >>>故障排除日志:删除未同步下发订单成功2604261553430018144723
2026-04-26 15:53:51 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536875333]


===15:59:12===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 15:58:53 >>>回调事件[910,devices/S2664]
2026-04-26 15:58:53 >>>故障排除日志:上一MQTT订单号缓存列表为2604261553430018144723
2026-04-26 15:58:53 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 15:58:53 开始打印,排队:254,票券:2604261558464552965401,订单:2604261558460042413045,[2026-04-26 15:58:53微信支付10元]
2026-04-26 15:58:53>>>MQTT票号同步场景，创建空订单对象
2026-04-26 15:58:53>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 15:58:55 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261558464552965401","queue_number":254,"trade_uid":"2604261558460042413045"}]}
2026-04-26 15:58:55 >>>故障排除日志:删除未同步下发订单成功2604261558460042413045
2026-04-26 15:58:55 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536875386]


===16:08:12===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 16:07:30 >>>回调事件[910,devices/S2664]
2026-04-26 16:07:30 >>>故障排除日志:上一MQTT订单号缓存列表为2604261558460042413045
2026-04-26 16:07:30 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 16:07:30 开始打印,排队:255,票券:2604261607203512841801,订单:2604261607200033125215,[2026-04-26 16:07:29微信支付10元]
2026-04-26 16:07:30>>>MQTT票号同步场景，创建空订单对象
2026-04-26 16:07:30>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 16:07:32 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261607203512841801","queue_number":255,"trade_uid":"2604261607200033125215"}]}
2026-04-26 16:07:32 >>>故障排除日志:删除未同步下发订单成功2604261607200033125215
2026-04-26 16:07:32 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536875469]


===16:09:12===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 16:08:22 >>>回调事件[910,devices/S2664]
2026-04-26 16:08:22 >>>故障排除日志:上一MQTT订单号缓存列表为2604261607200033125215
2026-04-26 16:08:22 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 16:08:22 开始打印,排队:256,票券:2604261608155731233101,订单:2604261608150055307082,[2026-04-26 16:08:21微信支付10元]
2026-04-26 16:08:22>>>MQTT票号同步场景，创建空订单对象
2026-04-26 16:08:22>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 16:08:24 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261608155731233101","queue_number":256,"trade_uid":"2604261608150055307082"}]}
2026-04-26 16:08:24 >>>故障排除日志:删除未同步下发订单成功2604261608150055307082
2026-04-26 16:08:24 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536875486]


===16:10:13===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 16:09:41 >>>回调事件[910,devices/S2664]
2026-04-26 16:09:41 >>>故障排除日志:上一MQTT订单号缓存列表为2604261608150055307082
2026-04-26 16:09:41 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 16:09:41 开始打印,排队:257,票券:2604261609298392077901,订单:2604261609290081686254,[2026-04-26 16:09:40微信支付10元]
2026-04-26 16:09:41>>>MQTT票号同步场景，创建空订单对象
2026-04-26 16:09:42>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 16:09:43 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261609298392077901","queue_number":257,"trade_uid":"2604261609290081686254"}]}
2026-04-26 16:09:43 >>>故障排除日志:删除未同步下发订单成功2604261609290081686254
2026-04-26 16:09:44 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536875508]


===16:17:13===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 16:16:59 >>>回调事件[910,devices/S2664]
2026-04-26 16:16:59 >>>故障排除日志:上一MQTT订单号缓存列表为2604261609290081686254
2026-04-26 16:16:59 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 16:16:59 开始打印,排队:258,票券:2604261616529839766801,订单:2604261616520096433082,[2026-04-26 16:16:59微信支付10元]
2026-04-26 16:16:59>>>MQTT票号同步场景，创建空订单对象
2026-04-26 16:16:59>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 16:17:01 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261616529839766801","queue_number":258,"trade_uid":"2604261616520096433082"}]}
2026-04-26 16:17:01 >>>故障排除日志:删除未同步下发订单成功2604261616520096433082
2026-04-26 16:17:01 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536875581]


===16:18:13===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 16:17:50 >>>回调事件[910,devices/S2664]
2026-04-26 16:17:50 >>>故障排除日志:上一MQTT订单号缓存列表为2604261616520096433082
2026-04-26 16:17:50 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 16:17:50 开始打印,排队:259,票券:2604261617402071769401,订单:2604261617400018863612,[2026-04-26 16:17:49微信支付10元]
2026-04-26 16:17:50>>>MQTT票号同步场景，创建空订单对象
2026-04-26 16:17:50>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 16:17:52 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261617402071769401","queue_number":259,"trade_uid":"2604261617400018863612"}]}
2026-04-26 16:17:52 >>>故障排除日志:删除未同步下发订单成功2604261617400018863612
2026-04-26 16:17:52 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536875597]


===16:26:14===
2026-04-26 16:25:39>>>cash read=00
2026-04-26 16:25:39>>>cash read=818F42
2026-04-26 16:25:39>>>cash write=02
2026-04-26 16:25:39 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 16:25:39>>>cash read=10
2026-04-26 16:25:39 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 16:25:39 当前产品价格10元，投币10元，打印小票中...
2026-04-26 16:25:39 >>>开始打印,排队号为260,订单号为2604261625390022664381
2026-04-26 16:25:40>>>订单2604261625390022664381写入成功,剩余空间为1679500,占用RAM为631.9521484375
删除未同步订单2604261625390022664381
2026-04-26 16:25:42>>>订单2604261625390022664381删除成功,剩余空间为1680500,占用RAM为646.2197265625
检测订单目录中>>>
无未同步订单>>>
2026-04-26 16:25:42 >>>当前Ram内存为615.970703125
定时检测未同步订单启用[checkOrderNum=536875672]
2026-04-26 16:25:43>>>cash write=0C
2026-04-26 16:25:43>>>cash read=3E


===16:28:14===
2026-04-26 16:27:33>>>cash read=00
2026-04-26 16:27:33>>>cash read=818F42
2026-04-26 16:27:33>>>cash write=02
2026-04-26 16:27:33 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 16:27:34>>>cash read=10
2026-04-26 16:27:34 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 16:27:34 当前产品价格10元，投币10元，打印小票中...
2026-04-26 16:27:34 >>>开始打印,排队号为261,订单号为2604261627340022664805
2026-04-26 16:27:34>>>订单2604261627340022664805写入成功,剩余空间为1679500,占用RAM为631.9609375
删除未同步订单2604261627340022664805
2026-04-26 16:27:36>>>订单2604261627340022664805删除成功,剩余空间为1680500,占用RAM为642.4755859375
检测订单目录中>>>
无未同步订单>>>
2026-04-26 16:27:36 >>>当前Ram内存为615.7275390625
定时检测未同步订单启用[checkOrderNum=536875699]
2026-04-26 16:27:37>>>cash read=818F42
2026-04-26 16:27:37 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 16:27:37>>>cash read=10
2026-04-26 16:27:37 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 16:27:37 当前产品价格10元，投币10元，打印小票中...
2026-04-26 16:27:37 >>>开始打印,排队号为262,订单号为2604261627370022664463
2026-04-26 16:27:38>>>订单2604261627370022664463写入成功,剩余空间为1679000,占用RAM为640.55078125
删除未同步订单2604261627370022664463
2026-04-26 16:27:40>>>订单2604261627370022664463删除成功,剩余空间为1679500,占用RAM为647.0009765625
检测订单目录中>>>
无未同步订单>>>
2026-04-26 16:27:40 >>>当前Ram内存为617.1708984375
定时检测未同步订单启用[checkOrderNum=536875706]
2026-04-26 16:27:40>>>cash read=818F41
2026-04-26 16:27:40 >>>回调事件130,cash_status,10022,进钞中...read money=5
2026-04-26 16:27:41>>>cash read=10
2026-04-26 16:27:41 >>>回调事件130,5,10023,finish Money=5,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 16:27:42>>>cash write=0C
2026-04-26 16:27:42>>>cash read=3E
2026-04-26 16:27:44>>>cash read=00
2026-04-26 16:27:46>>>cash read=3E
2026-04-26 16:27:48>>>cash read=00
2026-04-26 16:27:49>>>cash read=818F41
2026-04-26 16:27:49>>>cash write=02
2026-04-26 16:27:49 >>>回调事件130,cash_status,10022,进钞中...read money=5
2026-04-26 16:27:50>>>cash read=10
2026-04-26 16:27:50 >>>回调事件130,5,10023,finish Money=5,进钞完成
2026-04-26 16:27:50 当前产品价格10元，投币10元，打印小票中...
2026-04-26 16:27:50 >>>开始打印,排队号为263,订单号为2604261627410022664512
2026-04-26 16:27:50>>>订单2604261627410022664512写入成功,剩余空间为1677500,占用RAM为645.58984375
删除未同步订单2604261627410022664512
2026-04-26 16:27:52>>>订单2604261627410022664512删除成功,剩余空间为1678000,占用RAM为651.390625
检测订单目录中>>>
无未同步订单>>>
2026-04-26 16:27:52 >>>当前Ram内存为619.0361328125
定时检测未同步订单启用[checkOrderNum=536875723]
2026-04-26 16:27:53>>>cash write=0C
2026-04-26 16:27:53>>>cash read=3E


===16:30:14===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 16:29:21 >>>回调事件[910,devices/S2664]
2026-04-26 16:29:21 >>>故障排除日志:上一MQTT订单号缓存列表为2604261617400018863612
2026-04-26 16:29:21 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 16:29:22 开始打印,排队:264,票券:2604261629103404773901,订单:2604261629100032279295,[2026-04-26 16:29:21微信支付10元]
2026-04-26 16:29:22>>>MQTT票号同步场景，创建空订单对象
2026-04-26 16:29:22>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 16:29:24 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261629103404773901","queue_number":264,"trade_uid":"2604261629100032279295"}]}
2026-04-26 16:29:24 >>>故障排除日志:删除未同步下发订单成功2604261629100032279295
2026-04-26 16:29:24 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536875743]


===16:32:14===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 16:32:10 >>>回调事件[910,devices/S2664]
2026-04-26 16:32:10 >>>故障排除日志:上一MQTT订单号缓存列表为2604261629100032279295
2026-04-26 16:32:10 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 16:32:10 开始打印,排队:265,票券:2604261632051046577801,订单:2604261632050008593443,[2026-04-26 16:32:10微信支付10元]
2026-04-26 16:32:11>>>MQTT票号同步场景，创建空订单对象
2026-04-26 16:32:11>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 16:32:12 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261632051046577801","queue_number":265,"trade_uid":"2604261632050008593443"}]}
2026-04-26 16:32:12 >>>故障排除日志:删除未同步下发订单成功2604261632050008593443
2026-04-26 16:32:13 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536875777]


===16:33:16===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 16:33:13 >>>回调事件[910,devices/S2664]
2026-04-26 16:33:13 >>>故障排除日志:上一MQTT订单号缓存列表为2604261632050008593443
2026-04-26 16:33:13 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 16:33:13 开始打印,排队:266,票券:2604261633061018197301,订单:2604261633060007491475,[2026-04-26 16:33:12微信支付10元]
2026-04-26 16:33:13>>>MQTT票号同步场景，创建空订单对象
2026-04-26 16:33:13>>>合并MQTT票号列表到订单同步请求,共1张票


===16:41:16===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 16:41:05 >>>回调事件[910,devices/S2664]
2026-04-26 16:41:05 >>>故障排除日志:上一MQTT订单号缓存列表为2604261633060007491475
2026-04-26 16:41:05 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 16:41:05 开始打印,排队:267,票券:2604261640553584727601,订单:2604261640550033804037,[2026-04-26 16:41:04微信支付10元]
2026-04-26 16:41:05>>>MQTT票号同步场景，创建空订单对象
2026-04-26 16:41:05>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 16:41:07 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261640553584727601","queue_number":267,"trade_uid":"2604261640550033804037"}]}
2026-04-26 16:41:07 >>>故障排除日志:删除未同步下发订单成功2604261640550033804037
2026-04-26 16:41:07 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536875874]


===16:42:17===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 16:41:32 >>>回调事件[910,devices/S2664]
2026-04-26 16:41:32 >>>故障排除日志:上一MQTT订单号缓存列表为2604261640550033804037
2026-04-26 16:41:32 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 16:41:32 开始打印,排队:268,票券:2604261641229642114701,订单:2604261641220093978736,[2026-04-26 16:41:31微信支付10元]
2026-04-26 16:41:32>>>MQTT票号同步场景，创建空订单对象
2026-04-26 16:41:32>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 16:41:34 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261641229642114701","queue_number":268,"trade_uid":"2604261641220093978736"}]}
2026-04-26 16:41:34 >>>故障排除日志:删除未同步下发订单成功2604261641220093978736
2026-04-26 16:41:34 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536875883]


===16:46:17===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 16:45:25 >>>回调事件[910,devices/S2664]
2026-04-26 16:45:25 >>>故障排除日志:上一MQTT订单号缓存列表为2604261641220093978736
2026-04-26 16:45:25 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 16:45:25 开始打印,排队:269,票券:2604261645173100574501,订单:2604261645170029291658,[2026-04-26 16:45:24微信支付10元]
2026-04-26 16:45:25>>>MQTT票号同步场景，创建空订单对象
2026-04-26 16:45:25>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 16:45:27 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261645173100574501","queue_number":269,"trade_uid":"2604261645170029291658"}]}
2026-04-26 16:45:27 >>>故障排除日志:删除未同步下发订单成功2604261645170029291658
2026-04-26 16:45:28 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536875926]


===16:55:17===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 16:55:07 >>>回调事件[910,devices/S2664]
2026-04-26 16:55:08 >>>故障排除日志:上一MQTT订单号缓存列表为2604261645170029291658
2026-04-26 16:55:08 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 16:55:08 开始打印,排队:270,票券:2604261655000505575601,订单:2604261655000003051796,[2026-04-26 16:55:07微信支付10元]
2026-04-26 16:55:08 开始打印,排队:271,票券:2604261655000506313502,订单:2604261655000003051796,[2026-04-26 16:55:07微信支付10元]
2026-04-26 16:55:08>>>MQTT票号同步场景，创建空订单对象
2026-04-26 16:55:08>>>合并MQTT票号列表到订单同步请求,共2张票
2026-04-26 16:55:11 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261655000505575601","queue_number":270,"trade_uid":"2604261655000003051796"},{"ticket_no":"2604261655000506313502","queue_number":271,"trade_uid":"2604261655000003051796"}]}
2026-04-26 16:55:11 >>>故障排除日志:删除未同步下发订单成功2604261655000003051796
2026-04-26 16:55:11 >>>故障排除日志:删除未同步下发订单成功2604261655000003051796
2026-04-26 16:55:11 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536876024]


===16:58:18===
2026-04-26 16:57:57>>>cash read=00
2026-04-26 16:57:58>>>cash read=818F42
2026-04-26 16:57:58>>>cash write=02
2026-04-26 16:57:58 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 16:57:59>>>cash read=10
2026-04-26 16:57:59 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 16:57:59 当前产品价格10元，投币10元，打印小票中...
2026-04-26 16:57:59 >>>开始打印,排队号为272,订单号为2604261657590022664851
2026-04-26 16:57:59>>>订单2604261657590022664851写入成功,剩余空间为1679500,占用RAM为635.451171875
删除未同步订单2604261657590022664851
2026-04-26 16:58:01>>>订单2604261657590022664851删除成功,剩余空间为1680500,占用RAM为647.9697265625
检测订单目录中>>>
无未同步订单>>>
2026-04-26 16:58:01 >>>当前Ram内存为617.359375
定时检测未同步订单启用[checkOrderNum=536876058]
2026-04-26 16:58:02>>>cash write=0C
2026-04-26 16:58:02>>>cash read=3E


===17:10:18===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 17:09:20 >>>回调事件[910,devices/S2664]
2026-04-26 17:09:20 >>>故障排除日志:上一MQTT订单号缓存列表为2604261655000003051796|2604261655000003051796
2026-04-26 17:09:20 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 17:09:20 开始打印,排队:273,票券:2604261709106202384701,订单:2604261709100059993985,[2026-04-26 17:09:19微信支付10元]
2026-04-26 17:09:20>>>MQTT票号同步场景，创建空订单对象
2026-04-26 17:09:20>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 17:09:22 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261709106202384701","queue_number":273,"trade_uid":"2604261709100059993985"}]}
2026-04-26 17:09:22 >>>故障排除日志:删除未同步下发订单成功2604261709100059993985
2026-04-26 17:09:22 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536876167]


===17:16:18===
2026-04-26 17:15:48>>>cash read=00
2026-04-26 17:15:49>>>cash read=818F42
2026-04-26 17:15:49>>>cash write=02
2026-04-26 17:15:49 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 17:15:49>>>cash read=10
2026-04-26 17:15:49 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 17:15:49 当前产品价格10元，投币10元，打印小票中...
2026-04-26 17:15:49 >>>开始打印,排队号为274,订单号为2604261715490022664972
2026-04-26 17:15:49>>>订单2604261715490022664972写入成功,剩余空间为1679500,占用RAM为632.1474609375
删除未同步订单2604261715490022664972
2026-04-26 17:15:51>>>订单2604261715490022664972删除成功,剩余空间为1680500,占用RAM为646.4150390625
检测订单目录中>>>
无未同步订单>>>
2026-04-26 17:15:52 >>>当前Ram内存为616.2197265625
定时检测未同步订单启用[checkOrderNum=536876236]
2026-04-26 17:15:52>>>cash read=818F42
2026-04-26 17:15:52 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 17:15:53>>>cash read=10
2026-04-26 17:15:53 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 17:15:53 当前产品价格10元，投币10元，打印小票中...
2026-04-26 17:15:53 >>>开始打印,排队号为275,订单号为2604261715530022664120
2026-04-26 17:15:53>>>订单2604261715530022664120写入成功,剩余空间为1679000,占用RAM为640.986328125
删除未同步订单2604261715530022664120
2026-04-26 17:15:55>>>订单2604261715530022664120删除成功,剩余空间为1679500,占用RAM为647.4658203125
检测订单目录中>>>
无未同步订单>>>
2026-04-26 17:15:55 >>>当前Ram内存为617.6640625
定时检测未同步订单启用[checkOrderNum=536876243]
2026-04-26 17:15:56>>>cash write=0C
2026-04-26 17:15:56>>>cash read=3E


===17:20:18===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 17:19:29 >>>回调事件[910,devices/S2664]
2026-04-26 17:19:29 >>>故障排除日志:上一MQTT订单号缓存列表为2604261709100059993985
2026-04-26 17:19:29 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 17:19:29 开始打印,排队:276,票券:2604261719111883594501,订单:2604261719110017011363,[2026-04-26 17:19:28微信支付10元]
2026-04-26 17:19:29 开始打印,排队:277,票券:2604261719111884068902,订单:2604261719110017011363,[2026-04-26 17:19:28微信支付10元]
2026-04-26 17:19:29>>>MQTT票号同步场景，创建空订单对象
2026-04-26 17:19:29>>>合并MQTT票号列表到订单同步请求,共2张票
2026-04-26 17:19:33 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261719111883594501","queue_number":276,"trade_uid":"2604261719110017011363"},{"ticket_no":"2604261719111884068902","queue_number":277,"trade_uid":"2604261719110017011363"}]}
2026-04-26 17:19:33 >>>故障排除日志:删除未同步下发订单成功2604261719110017011363
2026-04-26 17:19:33 >>>故障排除日志:删除未同步下发订单成功2604261719110017011363
2026-04-26 17:19:33 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536876281]


===17:34:19===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 17:33:28 >>>回调事件[910,devices/S2664]
2026-04-26 17:33:28 >>>故障排除日志:上一MQTT订单号缓存列表为2604261719110017011363|2604261719110017011363
2026-04-26 17:33:28 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 17:33:28 开始打印,排队:278,票券:2604261733207046848201,订单:2604261733200068411354,[2026-04-26 17:33:27微信支付10元]
2026-04-26 17:33:28>>>MQTT票号同步场景，创建空订单对象
2026-04-26 17:33:28>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 17:33:30 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261733207046848201","queue_number":278,"trade_uid":"2604261733200068411354"}]}
2026-04-26 17:33:30 >>>故障排除日志:删除未同步下发订单成功2604261733200068411354
2026-04-26 17:33:30 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536876415]


===17:35:19===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 17:34:39 >>>回调事件[910,devices/S2664]
2026-04-26 17:34:39 >>>故障排除日志:上一MQTT订单号缓存列表为2604261733200068411354
2026-04-26 17:34:39 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 17:34:39 开始打印,排队:279,票券:2604261734309631656401,订单:2604261734300094167546,[2026-04-26 17:34:38微信支付10元]
2026-04-26 17:34:39>>>MQTT票号同步场景，创建空订单对象
2026-04-26 17:34:39>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 17:34:41 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261734309631656401","queue_number":279,"trade_uid":"2604261734300094167546"}]}
2026-04-26 17:34:41 >>>故障排除日志:删除未同步下发订单成功2604261734300094167546
2026-04-26 17:34:41 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536876432]


===17:37:19===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 17:36:25 >>>回调事件[910,devices/S2664]
2026-04-26 17:36:25 >>>故障排除日志:上一MQTT订单号缓存列表为2604261734300094167546
2026-04-26 17:36:25 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 17:36:25 开始打印,排队:280,票券:2604261736184999698901,订单:2604261736180048244362,[2026-04-26 17:36:24微信支付10元]
2026-04-26 17:36:25>>>MQTT票号同步场景，创建空订单对象
2026-04-26 17:36:25>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 17:36:27 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261736184999698901","queue_number":280,"trade_uid":"2604261736180048244362"}]}
2026-04-26 17:36:27 >>>故障排除日志:删除未同步下发订单成功2604261736180048244362
2026-04-26 17:36:27 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536876458]


===17:42:19===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 17:42:14 >>>回调事件[910,devices/S2664]
2026-04-26 17:42:14 >>>故障排除日志:上一MQTT订单号缓存列表为2604261736180048244362
2026-04-26 17:42:14 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 17:42:14 开始打印,排队:281,票券:2604261742069509915401,订单:2604261742060093097989,[2026-04-26 17:42:13微信支付10元]
2026-04-26 17:42:14>>>MQTT票号同步场景，创建空订单对象
2026-04-26 17:42:14>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 17:42:16 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261742069509915401","queue_number":281,"trade_uid":"2604261742060093097989"}]}
2026-04-26 17:42:16 >>>故障排除日志:删除未同步下发订单成功2604261742060093097989
2026-04-26 17:42:16 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536876519]


===17:50:20===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 17:49:36 >>>回调事件[910,devices/S2664]
2026-04-26 17:49:36 >>>故障排除日志:上一MQTT订单号缓存列表为2604261742060093097989
2026-04-26 17:49:36 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 17:49:36 开始打印,排队:282,票券:2604261749273561408201,订单:2604261749270033903083,[2026-04-26 17:49:35微信支付10元]
2026-04-26 17:49:36>>>MQTT票号同步场景，创建空订单对象
2026-04-26 17:49:36>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 17:49:38 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261749273561408201","queue_number":282,"trade_uid":"2604261749270033903083"}]}
2026-04-26 17:49:38 >>>故障排除日志:删除未同步下发订单成功2604261749270033903083
2026-04-26 17:49:38 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536876591]


===17:52:20===
2026-04-26 17:51:37>>>cash read=00
2026-04-26 17:51:37>>>cash read=818F42
2026-04-26 17:51:37>>>cash write=02
2026-04-26 17:51:37 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 17:51:38>>>cash read=10
2026-04-26 17:51:38 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 17:51:38 当前产品价格10元，投币10元，打印小票中...
2026-04-26 17:51:38 >>>开始打印,排队号为283,订单号为2604261751380022664444
2026-04-26 17:51:38>>>订单2604261751380022664444写入成功,剩余空间为1679500,占用RAM为633.5419921875
删除未同步订单2604261751380022664444
2026-04-26 17:51:40>>>订单2604261751380022664444删除成功,剩余空间为1680500,占用RAM为642.455078125
检测订单目录中>>>
无未同步订单>>>
2026-04-26 17:51:40 >>>当前Ram内存为615.7197265625
定时检测未同步订单启用[checkOrderNum=536876618]
2026-04-26 17:51:41>>>cash write=0C
2026-04-26 17:51:41>>>cash read=3E


===17:57:20===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 17:56:42 >>>回调事件[910,devices/S2664]
2026-04-26 17:56:42 >>>故障排除日志:上一MQTT订单号缓存列表为2604261749270033903083
2026-04-26 17:56:42 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 17:56:42 开始打印,排队:284,票券:2604261756343612564201,订单:2604261756340034126752,[2026-04-26 17:56:41微信支付10元]
2026-04-26 17:56:42>>>MQTT票号同步场景，创建空订单对象
2026-04-26 17:56:42>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 17:56:44 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261756343612564201","queue_number":284,"trade_uid":"2604261756340034126752"}]}
2026-04-26 17:56:44 >>>故障排除日志:删除未同步下发订单成功2604261756340034126752
2026-04-26 17:56:44 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536876676]


===18:06:21===
2026-04-26 18:05:24>>>cash read=00
2026-04-26 18:05:24>>>cash read=818F42
2026-04-26 18:05:24>>>cash write=02
2026-04-26 18:05:24 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 18:05:25>>>cash read=10
2026-04-26 18:05:25 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 18:05:25 当前产品价格10元，投币10元，打印小票中...
2026-04-26 18:05:25 >>>开始打印,排队号为285,订单号为2604261805250022664859
2026-04-26 18:05:25>>>订单2604261805250022664859写入成功,剩余空间为1679500,占用RAM为631.6923828125
删除未同步订单2604261805250022664859
2026-04-26 18:05:27>>>订单2604261805250022664859删除成功,剩余空间为1680500,占用RAM为650.93359375
检测订单目录中>>>
无未同步订单>>>
2026-04-26 18:05:27 >>>当前Ram内存为615.76171875
定时检测未同步订单启用[checkOrderNum=536876761]
2026-04-26 18:05:28>>>cash write=0C
2026-04-26 18:05:28>>>cash read=3E


===18:07:21===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 18:07:00 >>>回调事件[910,devices/S2664]
2026-04-26 18:07:00 >>>故障排除日志:上一MQTT订单号缓存列表为2604261756340034126752
2026-04-26 18:07:00 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 18:07:00 开始打印,排队:286,票券:2604261806457633856901,订单:2604261806450074400057,[2026-04-26 18:06:59微信支付10元]
2026-04-26 18:07:00>>>MQTT票号同步场景，创建空订单对象
2026-04-26 18:07:00>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 18:07:02 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261806457633856901","queue_number":286,"trade_uid":"2604261806450074400057"}]}
2026-04-26 18:07:02 >>>故障排除日志:删除未同步下发订单成功2604261806450074400057
2026-04-26 18:07:02 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536876785]


===18:10:21===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 18:09:54 >>>回调事件[910,devices/S2664]
2026-04-26 18:09:54 >>>故障排除日志:上一MQTT订单号缓存列表为2604261806450074400057
2026-04-26 18:09:54 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 18:09:54 开始打印,排队:287,票券:2604261809465134658301,订单:2604261809460049338125,[2026-04-26 18:09:53微信支付10元]
2026-04-26 18:09:54>>>MQTT票号同步场景，创建空订单对象
2026-04-26 18:09:54>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 18:09:56 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261809465134658301","queue_number":287,"trade_uid":"2604261809460049338125"}]}
2026-04-26 18:09:56 >>>故障排除日志:删除未同步下发订单成功2604261809460049338125
2026-04-26 18:09:56 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536876818]


===18:18:22===
2026-04-26 18:17:25>>>cash read=00
2026-04-26 18:17:26>>>cash read=818F42
2026-04-26 18:17:26>>>cash write=02
2026-04-26 18:17:26 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 18:17:26>>>cash read=10
2026-04-26 18:17:26 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 18:17:26 当前产品价格10元，投币10元，打印小票中...
2026-04-26 18:17:26 >>>开始打印,排队号为288,订单号为2604261817260022664708
2026-04-26 18:17:27>>>订单2604261817260022664708写入成功,剩余空间为1679500,占用RAM为633.43359375
删除未同步订单2604261817260022664708
2026-04-26 18:17:29>>>订单2604261817260022664708删除成功,剩余空间为1680500,占用RAM为642.50390625
检测订单目录中>>>
无未同步订单>>>
2026-04-26 18:17:29 >>>当前Ram内存为615.5908203125
定时检测未同步订单启用[checkOrderNum=536876893]
2026-04-26 18:17:30>>>cash write=0C
2026-04-26 18:17:30>>>cash read=3E


===18:22:22===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 18:21:23 >>>回调事件[910,devices/S2664]
2026-04-26 18:21:23 >>>故障排除日志:上一MQTT订单号缓存列表为2604261809460049338125
2026-04-26 18:21:23 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 18:21:23 开始打印,排队:289,票券:2604261821157794112901,订单:2604261821150076074985,[2026-04-26 18:21:22微信支付10元]
2026-04-26 18:21:23>>>MQTT票号同步场景，创建空订单对象
2026-04-26 18:21:23>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 18:21:25 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261821157794112901","queue_number":289,"trade_uid":"2604261821150076074985"}]}
2026-04-26 18:21:25 >>>故障排除日志:删除未同步下发订单成功2604261821150076074985
2026-04-26 18:21:25 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536876937]


===18:26:22===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 18:25:44 >>>回调事件[910,devices/S2664]
2026-04-26 18:25:44 >>>故障排除日志:上一MQTT订单号缓存列表为2604261821150076074985
2026-04-26 18:25:44 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 18:25:44 开始打印,排队:290,票券:2604261825349709763801,订单:2604261825340094984937,[2026-04-26 18:25:44微信支付10元]
2026-04-26 18:25:44>>>MQTT票号同步场景，创建空订单对象
2026-04-26 18:25:44>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 18:25:46 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261825349709763801","queue_number":290,"trade_uid":"2604261825340094984937"}]}
2026-04-26 18:25:46 >>>故障排除日志:删除未同步下发订单成功2604261825340094984937
2026-04-26 18:25:46 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536876987]


===18:31:23===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 18:31:08 >>>回调事件[910,devices/S2664]
2026-04-26 18:31:08 >>>故障排除日志:上一MQTT订单号缓存列表为2604261825340094984937
2026-04-26 18:31:08 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 18:31:08 开始打印,排队:291,票券:2604261830598398378301,订单:2604261830590081806832,[2026-04-26 18:31:08微信支付10元]
2026-04-26 18:31:08 开始打印,排队:292,票券:2604261830598398868902,订单:2604261830590081806832,[2026-04-26 18:31:08微信支付10元]
2026-04-26 18:31:09>>>MQTT票号同步场景，创建空订单对象
2026-04-26 18:31:09>>>合并MQTT票号列表到订单同步请求,共2张票
2026-04-26 18:31:12 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261830598398378301","queue_number":291,"trade_uid":"2604261830590081806832"},{"ticket_no":"2604261830598398868902","queue_number":292,"trade_uid":"2604261830590081806832"}]}
2026-04-26 18:31:12 >>>故障排除日志:删除未同步下发订单成功2604261830590081806832
2026-04-26 18:31:12 >>>故障排除日志:删除未同步下发订单成功2604261830590081806832
2026-04-26 18:31:12 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877043]


===18:35:23===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 18:34:27 >>>回调事件[910,devices/S2664]
2026-04-26 18:34:27 >>>故障排除日志:上一MQTT订单号缓存列表为2604261830590081806832|2604261830590081806832
2026-04-26 18:34:27 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 18:34:27 开始打印,排队:293,票券:2604261834173726393501,订单:2604261834170035141265,[2026-04-26 18:34:26微信支付10元]
2026-04-26 18:34:27>>>MQTT票号同步场景，创建空订单对象
2026-04-26 18:34:27>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 18:34:29 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261834173726393501","queue_number":293,"trade_uid":"2604261834170035141265"}]}
2026-04-26 18:34:29 >>>故障排除日志:删除未同步下发订单成功2604261834170035141265
2026-04-26 18:34:29 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877078]


===18:45:24===
2026-04-26 18:44:26>>>cash read=1F
2026-04-26 18:44:28>>>cash read=3E
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 18:45:12 >>>回调事件[910,devices/S2664]
2026-04-26 18:45:12 >>>故障排除日志:上一MQTT订单号缓存列表为2604261834170035141265
2026-04-26 18:45:12 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 18:45:12 开始打印,排队:294,票券:2604261845020162446801,订单:2604261845010099499987,[2026-04-26 18:45:11微信支付10元]
2026-04-26 18:45:12 开始打印,排队:295,票券:2604261845020162917302,订单:2604261845010099499987,[2026-04-26 18:45:11微信支付10元]
2026-04-26 18:45:12>>>MQTT票号同步场景，创建空订单对象
2026-04-26 18:45:12>>>合并MQTT票号列表到订单同步请求,共2张票
2026-04-26 18:45:15 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261845020162446801","queue_number":294,"trade_uid":"2604261845010099499987"},{"ticket_no":"2604261845020162917302","queue_number":295,"trade_uid":"2604261845010099499987"}]}
2026-04-26 18:45:15 >>>故障排除日志:删除未同步下发订单成功2604261845010099499987
2026-04-26 18:45:16 >>>故障排除日志:删除未同步下发订单成功2604261845010099499987
2026-04-26 18:45:16 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877185]


===18:46:24===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 18:45:25 >>>回调事件[910,devices/S2664]
2026-04-26 18:45:25 >>>故障排除日志:上一MQTT订单号缓存列表为2604261845010099499987|2604261845010099499987
2026-04-26 18:45:25 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 18:45:25 开始打印,排队:296,票券:2604261845194620636201,订单:2604261845190044376562,[2026-04-26 18:45:24支付宝支付10元]
2026-04-26 18:45:25>>>MQTT票号同步场景，创建空订单对象
2026-04-26 18:45:25>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 18:45:27 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261845194620636201","queue_number":296,"trade_uid":"2604261845190044376562"}]}
2026-04-26 18:45:27 >>>故障排除日志:删除未同步下发订单成功2604261845190044376562
2026-04-26 18:45:27 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877193]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 18:46:03 >>>回调事件[910,devices/S2664]
2026-04-26 18:46:03 >>>故障排除日志:上一MQTT订单号缓存列表为2604261845190044376562
2026-04-26 18:46:03 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 18:46:03 开始打印,排队:297,票券:2604261845542681865401,订单:2604261845540024016814,[2026-04-26 18:46:02微信支付10元]
2026-04-26 18:46:03>>>MQTT票号同步场景，创建空订单对象
2026-04-26 18:46:03>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 18:46:05 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261845542681865401","queue_number":297,"trade_uid":"2604261845540024016814"}]}
2026-04-26 18:46:05 >>>故障排除日志:删除未同步下发订单成功2604261845540024016814
2026-04-26 18:46:05 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877207]


===18:50:24===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 18:49:27 >>>回调事件[910,devices/S2664]
2026-04-26 18:49:27 >>>故障排除日志:上一MQTT订单号缓存列表为2604261845540024016814
2026-04-26 18:49:27 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 18:49:27 开始打印,排队:298,票券:2604261849179256602501,订单:2604261849170090438128,[2026-04-26 18:49:26微信支付10元]
2026-04-26 18:49:27>>>MQTT票号同步场景，创建空订单对象
2026-04-26 18:49:27>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 18:49:29 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261849179256602501","queue_number":298,"trade_uid":"2604261849170090438128"}]}
2026-04-26 18:49:29 >>>故障排除日志:删除未同步下发订单成功2604261849170090438128
2026-04-26 18:49:29 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877243]


===18:57:24===
2026-04-26 18:56:41>>>cash read=BF
2026-04-26 18:56:42>>>cash read=3E


===18:59:24===
2026-04-26 18:58:30>>>cash read=00
2026-04-26 18:58:31>>>cash read=818F42
2026-04-26 18:58:31>>>cash write=02
2026-04-26 18:58:31 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 18:58:31>>>cash read=10
2026-04-26 18:58:31 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 18:58:31 当前产品价格10元，投币10元，打印小票中...
2026-04-26 18:58:31 >>>开始打印,排队号为299,订单号为2604261858310022664735
2026-04-26 18:58:31>>>订单2604261858310022664735写入成功,剩余空间为1679500,占用RAM为633.6767578125
删除未同步订单2604261858310022664735
2026-04-26 18:58:34>>>订单2604261858310022664735删除成功,剩余空间为1680500,占用RAM为642.6435546875
检测订单目录中>>>
无未同步订单>>>
2026-04-26 18:58:34 >>>当前Ram内存为615.8369140625
定时检测未同步订单启用[checkOrderNum=536877335]
2026-04-26 18:58:35>>>cash write=0C
2026-04-26 18:58:35>>>cash read=3E


===19:10:25===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:09:46 >>>回调事件[910,devices/S2664]
2026-04-26 19:09:46 >>>故障排除日志:上一MQTT订单号缓存列表为2604261849170090438128
2026-04-26 19:09:46 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 19:09:46 开始打印,排队:300,票券:2604261909400729091301,订单:2604261909400005571585,[2026-04-26 19:09:45微信支付10元]
2026-04-26 19:09:46 开始打印,排队:301,票券:2604261909400729625302,订单:2604261909400005571585,[2026-04-26 19:09:45微信支付10元]
2026-04-26 19:09:46>>>MQTT票号同步场景，创建空订单对象
2026-04-26 19:09:46>>>合并MQTT票号列表到订单同步请求,共2张票
2026-04-26 19:09:49 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261909400729091301","queue_number":300,"trade_uid":"2604261909400005571585"},{"ticket_no":"2604261909400729625302","queue_number":301,"trade_uid":"2604261909400005571585"}]}
2026-04-26 19:09:49 >>>故障排除日志:删除未同步下发订单成功2604261909400005571585
2026-04-26 19:09:49 >>>故障排除日志:删除未同步下发订单成功2604261909400005571585
2026-04-26 19:09:49 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877448]


===19:11:25===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:10:56 >>>回调事件[910,devices/S2664]
2026-04-26 19:10:56 >>>故障排除日志:上一MQTT订单号缓存列表为2604261909400005571585|2604261909400005571585
2026-04-26 19:10:56 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 19:10:56 开始打印,排队:302,票券:2604261910491896161301,订单:2604261910490017117292,[2026-04-26 19:10:55微信支付10元]
2026-04-26 19:10:56>>>MQTT票号同步场景，创建空订单对象
2026-04-26 19:10:56>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 19:10:58 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261910491896161301","queue_number":302,"trade_uid":"2604261910490017117292"}]}
2026-04-26 19:10:58 >>>故障排除日志:删除未同步下发订单成功2604261910490017117292
2026-04-26 19:10:58 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877465]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:11:00 >>>回调事件[910,devices/S2664]
2026-04-26 19:11:00 >>>故障排除日志:上一MQTT订单号缓存列表为2604261910490017117292
2026-04-26 19:11:00 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 19:11:00 开始打印,排队:303,票券:2604261910491391202301,订单:2604261910490008958443,[2026-04-26 19:10:59微信支付10元]
2026-04-26 19:11:00 开始打印,排队:304,票券:2604261910491391956802,订单:2604261910490008958443,[2026-04-26 19:10:59微信支付10元]
2026-04-26 19:11:00>>>MQTT票号同步场景，创建空订单对象
2026-04-26 19:11:00>>>合并MQTT票号列表到订单同步请求,共2张票
2026-04-26 19:11:04 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261910491391202301","queue_number":303,"trade_uid":"2604261910490008958443"},{"ticket_no":"2604261910491391956802","queue_number":304,"trade_uid":"2604261910490008958443"}]}
2026-04-26 19:11:04 >>>故障排除日志:删除未同步下发订单成功2604261910490008958443
2026-04-26 19:11:04 >>>故障排除日志:删除未同步下发订单成功2604261910490008958443
2026-04-26 19:11:04 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877473]


===19:17:25===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:17:12 >>>回调事件[910,devices/S2664]
2026-04-26 19:17:12 >>>故障排除日志:上一MQTT订单号缓存列表为2604261910490008958443|2604261910490008958443
2026-04-26 19:17:12 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 19:17:12 开始打印,排队:305,票券:2604261917002230834501,订单:2604261917000019318514,[2026-04-26 19:17:10微信支付10元]
2026-04-26 19:17:12>>>MQTT票号同步场景，创建空订单对象
2026-04-26 19:17:12>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 19:17:14 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261917002230834501","queue_number":305,"trade_uid":"2604261917000019318514"}]}
2026-04-26 19:17:14 >>>故障排除日志:删除未同步下发订单成功2604261917000019318514
2026-04-26 19:17:14 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877535]


===19:20:25===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:19:45 >>>回调事件[910,devices/S2664]
2026-04-26 19:19:45 >>>故障排除日志:上一MQTT订单号缓存列表为2604261917000019318514
2026-04-26 19:19:45 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 19:19:45 开始打印,排队:306,票券:2604261919397384971801,订单:2604261919390070744546,[2026-04-26 19:19:45微信支付10元]
2026-04-26 19:19:45>>>MQTT票号同步场景，创建空订单对象
2026-04-26 19:19:45>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 19:19:47 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261919397384971801","queue_number":306,"trade_uid":"2604261919390070744546"}]}
2026-04-26 19:19:47 >>>故障排除日志:删除未同步下发订单成功2604261919390070744546
2026-04-26 19:19:47 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877567]


===19:21:26===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:20:27 >>>回调事件[910,devices/S2664]
2026-04-26 19:20:27 >>>故障排除日志:上一MQTT订单号缓存列表为2604261919390070744546
2026-04-26 19:20:27 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 19:20:27 开始打印,排队:307,票券:2604261920184963562401,订单:2604261920180046963441,[2026-04-26 19:20:26微信支付10元]
2026-04-26 19:20:27>>>MQTT票号同步场景，创建空订单对象
2026-04-26 19:20:27>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 19:20:29 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261920184963562401","queue_number":307,"trade_uid":"2604261920180046963441"}]}
2026-04-26 19:20:29 >>>故障排除日志:删除未同步下发订单成功2604261920180046963441
2026-04-26 19:20:29 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877579]


===19:22:26===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:21:36 >>>回调事件[910,devices/S2664]
2026-04-26 19:21:36 >>>故障排除日志:上一MQTT订单号缓存列表为2604261920180046963441
2026-04-26 19:21:36 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 19:21:36 开始打印,排队:308,票券:2604261921292207029101,订单:2604261921290019931185,[2026-04-26 19:21:36微信支付10元]
2026-04-26 19:21:36 开始打印,排队:309,票券:2604261921292207463502,订单:2604261921290019931185,[2026-04-26 19:21:36微信支付10元]
2026-04-26 19:21:36>>>MQTT票号同步场景，创建空订单对象
2026-04-26 19:21:36>>>合并MQTT票号列表到订单同步请求,共2张票
2026-04-26 19:21:40 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261921292207029101","queue_number":308,"trade_uid":"2604261921290019931185"},{"ticket_no":"2604261921292207463502","queue_number":309,"trade_uid":"2604261921290019931185"}]}
2026-04-26 19:21:40 >>>故障排除日志:删除未同步下发订单成功2604261921290019931185
2026-04-26 19:21:40 >>>故障排除日志:删除未同步下发订单成功2604261921290019931185
2026-04-26 19:21:40 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877596]


===19:23:26===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:23:07 >>>回调事件[910,devices/S2664]
2026-04-26 19:23:07 >>>故障排除日志:上一MQTT订单号缓存列表为2604261921290019931185|2604261921290019931185
2026-04-26 19:23:07 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 19:23:07 开始打印,排队:310,票券:2604261922542590111601,订单:2604261922540024180252,[2026-04-26 19:23:06微信支付10元]
2026-04-26 19:23:07>>>MQTT票号同步场景，创建空订单对象
2026-04-26 19:23:07>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 19:23:09 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261922542590111601","queue_number":310,"trade_uid":"2604261922540024180252"}]}
2026-04-26 19:23:09 >>>故障排除日志:删除未同步下发订单成功2604261922540024180252
2026-04-26 19:23:09 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877621]


===19:26:27===
2026-04-26 19:25:50 >>>剩余flash空间=1682000,占用RAM为658.3388671875
2026-04-26 19:25:50 >>>回调事件:901,netChange,1,4G LTE网络

定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:26:12 >>>回调事件[910,devices/S2664]
2026-04-26 19:26:12 >>>故障排除日志:上一MQTT订单号缓存列表为2604261922540024180252
2026-04-26 19:26:12 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 19:26:12 开始打印,排队:311,票券:2604261926040613142801,订单:2604261926040004168398,[2026-04-26 19:26:11微信支付10元]
2026-04-26 19:26:13>>>MQTT票号同步场景，创建空订单对象
2026-04-26 19:26:13>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 19:26:14 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261926040613142801","queue_number":311,"trade_uid":"2604261926040004168398"}]}
2026-04-26 19:26:15 >>>故障排除日志:删除未同步下发订单成功2604261926040004168398
2026-04-26 19:26:15 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877656]


===19:28:27===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:27:59 >>>回调事件[910,devices/S2664]
2026-04-26 19:27:59 >>>故障排除日志:上一MQTT订单号缓存列表为2604261926040004168398
2026-04-26 19:27:59 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 19:27:59 开始打印,排队:312,票券:2604261927483267496701,订单:2604261927480030415457,[2026-04-26 19:27:58微信支付10元]
2026-04-26 19:27:59>>>MQTT票号同步场景，创建空订单对象
2026-04-26 19:27:59>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 19:28:01 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261927483267496701","queue_number":312,"trade_uid":"2604261927480030415457"}]}
2026-04-26 19:28:01 >>>故障排除日志:删除未同步下发订单成功2604261927480030415457
2026-04-26 19:28:01 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877681]


===19:33:27===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:32:28 >>>回调事件[910,devices/S2664]
2026-04-26 19:32:28 >>>故障排除日志:上一MQTT订单号缓存列表为2604261927480030415457
2026-04-26 19:32:28 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 19:32:28 开始打印,排队:313,票券:2604261931544537079601,订单:2604261931540043458052,[2026-04-26 19:32:28微信支付10元]
2026-04-26 19:32:28>>>MQTT票号同步场景，创建空订单对象
2026-04-26 19:32:28>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 19:32:30 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261931544537079601","queue_number":313,"trade_uid":"2604261931540043458052"}]}
2026-04-26 19:32:30 >>>故障排除日志:删除未同步下发订单成功2604261931540043458052
2026-04-26 19:32:30 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877727]
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:33:21 >>>回调事件[910,devices/S2664]
2026-04-26 19:33:21 >>>故障排除日志:上一MQTT订单号缓存列表为2604261931540043458052
2026-04-26 19:33:21 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 19:33:21 开始打印,排队:314,票券:2604261933142743159801,订单:2604261933140025591152,[2026-04-26 19:33:20支付宝支付10元]
2026-04-26 19:33:21>>>MQTT票号同步场景，创建空订单对象
2026-04-26 19:33:21>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 19:33:23 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261933142743159801","queue_number":314,"trade_uid":"2604261933140025591152"}]}
2026-04-26 19:33:23 >>>故障排除日志:删除未同步下发订单成功2604261933140025591152
2026-04-26 19:33:23 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877741]


===19:39:27===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:38:39 >>>回调事件[910,devices/S2664]
2026-04-26 19:38:39 >>>故障排除日志:上一MQTT订单号缓存列表为2604261933140025591152
2026-04-26 19:38:39 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 19:38:39 开始打印,排队:315,票券:2604261938308172478701,订单:2604261938300078624054,[2026-04-26 19:38:38微信支付10元]
2026-04-26 19:38:39>>>MQTT票号同步场景，创建空订单对象
2026-04-26 19:38:39>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 19:38:41 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261938308172478701","queue_number":315,"trade_uid":"2604261938300078624054"}]}
2026-04-26 19:38:41 >>>故障排除日志:删除未同步下发订单成功2604261938300078624054
2026-04-26 19:38:41 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877795]


===19:48:28===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:47:54 >>>回调事件[910,devices/S2664]
2026-04-26 19:47:54 >>>故障排除日志:上一MQTT订单号缓存列表为2604261938300078624054
2026-04-26 19:47:54 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 19:47:54 开始打印,排队:316,票券:2604261947453403833201,订单:2604261947450032051498,[2026-04-26 19:47:53微信支付10元]
2026-04-26 19:47:54>>>MQTT票号同步场景，创建空订单对象
2026-04-26 19:47:54>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 19:47:56 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261947453403833201","queue_number":316,"trade_uid":"2604261947450032051498"}]}
2026-04-26 19:47:56 >>>故障排除日志:删除未同步下发订单成功2604261947450032051498
2026-04-26 19:47:56 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877889]


===19:50:28===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:49:40 >>>回调事件[910,devices/S2664]
2026-04-26 19:49:40 >>>故障排除日志:上一MQTT订单号缓存列表为2604261947450032051498
2026-04-26 19:49:40 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 19:49:40 开始打印,排队:317,票券:2604261949319329776501,订单:2604261949310091123556,[2026-04-26 19:49:39微信支付10元]
2026-04-26 19:49:40>>>MQTT票号同步场景，创建空订单对象
2026-04-26 19:49:40>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 19:49:42 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261949319329776501","queue_number":317,"trade_uid":"2604261949310091123556"}]}
2026-04-26 19:49:42 >>>故障排除日志:删除未同步下发订单成功2604261949310091123556
2026-04-26 19:49:42 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877910]


===19:51:28===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:50:28 >>>回调事件[910,devices/S2664]
2026-04-26 19:50:28 >>>故障排除日志:上一MQTT订单号缓存列表为2604261949310091123556
2026-04-26 19:50:28 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 19:50:28 开始打印,排队:318,票券:2604261950217051467301,订单:2604261950210067069886,[2026-04-26 19:50:28微信支付10元]
2026-04-26 19:50:28>>>MQTT票号同步场景，创建空订单对象
2026-04-26 19:50:28>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 19:50:30 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261950217051467301","queue_number":318,"trade_uid":"2604261950210067069886"}]}
2026-04-26 19:50:30 >>>故障排除日志:删除未同步下发订单成功2604261950210067069886
2026-04-26 19:50:30 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536877926]


===20:00:28===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 19:59:31 >>>回调事件[910,devices/S2664]
2026-04-26 19:59:31 >>>故障排除日志:上一MQTT订单号缓存列表为2604261950210067069886
2026-04-26 19:59:31 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 19:59:31 开始打印,排队:319,票券:2604261959205754527201,订单:2604261959200055628887,[2026-04-26 19:59:30微信支付10元]
2026-04-26 19:59:31>>>MQTT票号同步场景，创建空订单对象
2026-04-26 19:59:32>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 19:59:33 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604261959205754527201","queue_number":319,"trade_uid":"2604261959200055628887"}]}
2026-04-26 19:59:33 >>>故障排除日志:删除未同步下发订单成功2604261959200055628887
2026-04-26 19:59:33 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878015]


===20:11:29===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 20:11:26 >>>回调事件[910,devices/S2664]
2026-04-26 20:11:26 >>>故障排除日志:上一MQTT订单号缓存列表为2604261959200055628887
2026-04-26 20:11:26 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 20:11:26 开始打印,排队:320,票券:2604262011203378888701,订单:2604262011200031987881,[2026-04-26 20:11:25微信支付10元]
2026-04-26 20:11:26>>>MQTT票号同步场景，创建空订单对象
2026-04-26 20:11:26>>>合并MQTT票号列表到订单同步请求,共1张票


===20:15:29===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 20:14:44 >>>回调事件[910,devices/S2664]
2026-04-26 20:14:44 >>>故障排除日志:上一MQTT订单号缓存列表为2604262011200031987881
2026-04-26 20:14:44 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 20:14:44 开始打印,排队:321,票券:2604262014326091327301,订单:2604262014320059210026,[2026-04-26 20:14:43支付宝支付10元]
2026-04-26 20:14:44>>>MQTT票号同步场景，创建空订单对象
2026-04-26 20:14:44>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 20:14:46 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604262014326091327301","queue_number":321,"trade_uid":"2604262014320059210026"}]}
2026-04-26 20:14:46 >>>故障排除日志:删除未同步下发订单成功2604262014320059210026
2026-04-26 20:14:46 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878172]


===20:19:30===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 20:18:32 >>>回调事件[910,devices/S2664]
2026-04-26 20:18:32 >>>故障排除日志:上一MQTT订单号缓存列表为2604262014320059210026
2026-04-26 20:18:32 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 20:18:32 开始打印,排队:322,票券:2604262018246483271801,订单:2604262018240062928884,[2026-04-26 20:18:31微信支付10元]
2026-04-26 20:18:33>>>MQTT票号同步场景，创建空订单对象
2026-04-26 20:18:33>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 20:18:35 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604262018246483271801","queue_number":322,"trade_uid":"2604262018240062928884"}]}
2026-04-26 20:18:35 >>>故障排除日志:删除未同步下发订单成功2604262018240062928884
2026-04-26 20:18:35 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878210]


===20:21:30===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 20:20:42 >>>回调事件[910,devices/S2664]
2026-04-26 20:20:42 >>>故障排除日志:上一MQTT订单号缓存列表为2604262018240062928884
2026-04-26 20:20:42 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 20:20:42 开始打印,排队:323,票券:2604262020287258379601,订单:2604262020280070031324,[2026-04-26 20:20:41微信支付10元]
2026-04-26 20:20:43>>>MQTT票号同步场景，创建空订单对象
2026-04-26 20:20:43>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 20:20:44 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604262020287258379601","queue_number":323,"trade_uid":"2604262020280070031324"}]}
2026-04-26 20:20:44 >>>故障排除日志:删除未同步下发订单成功2604262020280070031324
2026-04-26 20:20:45 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878237]


===20:25:30===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 20:24:32 >>>回调事件[910,devices/S2664]
2026-04-26 20:24:32 >>>故障排除日志:上一MQTT订单号缓存列表为2604262020280070031324
2026-04-26 20:24:32 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 20:24:32 开始打印,排队:324,票券:2604262024231952279601,订单:2604262024230017595851,[2026-04-26 20:24:32微信支付10元]
2026-04-26 20:24:33>>>MQTT票号同步场景，创建空订单对象
2026-04-26 20:24:33>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 20:24:34 >>>回调事件[910,devices/S2664]
2026-04-26 20:24:34 >>>故障排除日志:上一MQTT订单号缓存列表为2604262024230017595851
2026-04-26 20:24:34 >>>故障排除日志:终端未同步成功订单列表03242604262024230017595851
2026-04-26 20:24:34 开始打印,排队:325,票券:2604262024223849367301,订单:2604262024220035992623,[2026-04-26 20:24:32微信支付10元]
已接收过此消息,票券号为2604262024231952279601,排队号为324
2026-04-26 20:24:34>>>HTTP请求进行中，跳过本次同步
2026-04-26 20:24:36 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604262024231952279601","queue_number":324,"trade_uid":"2604262024230017595851"}]}
2026-04-26 20:24:36 >>>故障排除日志:删除未同步下发订单成功2604262024230017595851
2026-04-26 20:24:36 >>>故障排除日志:终端同步成功后剩余订单列表03252604262024220035992623
定时检测未同步订单启用[checkOrderNum=536878280]


===20:27:30===
2026-04-26 20:27:19>>>cash read=0A
2026-04-26 20:27:20>>>cash read=3E


===20:34:31===
2026-04-26 20:33:40>>>cash read=BF
2026-04-26 20:33:41>>>cash read=3E


===20:35:31===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 20:34:31 >>>回调事件[910,devices/S2664]
2026-04-26 20:34:31 >>>故障排除日志:上一MQTT订单号缓存列表为2604262024220035992623|2604262024230017595851
2026-04-26 20:34:31 >>>故障排除日志:终端未同步成功订单列表03252604262024220035992623
已接收过此消息,票券号为2604262024223849367301,排队号为325
2026-04-26 20:34:31 开始打印,排队:326,票券:2604262034241946896401,订单:2604262034240017651439,[2026-04-26 20:34:31微信支付10元]
2026-04-26 20:34:31>>>MQTT票号同步场景，创建空订单对象
2026-04-26 20:34:31>>>合并MQTT票号列表到订单同步请求,共2张票
2026-04-26 20:34:33 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604262024223849367301","queue_number":325,"trade_uid":"2604262024220035992623"},{"ticket_no":"2604262034241946896401","queue_number":326,"trade_uid":"2604262034240017651439"}]}
2026-04-26 20:34:33 >>>故障排除日志:删除未同步下发订单成功2604262024220035992623
2026-04-26 20:34:33 >>>故障排除日志:删除未同步下发订单成功2604262034240017651439
2026-04-26 20:34:33 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878382]


===20:38:31===
2026-04-26 20:38:22>>>cash read=0A
2026-04-26 20:38:23>>>cash read=3E


===20:49:31===
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 20:48:58 >>>回调事件[910,devices/S2664]
2026-04-26 20:48:58 >>>故障排除日志:上一MQTT订单号缓存列表为2604262024220035992623|2604262034240017651439
2026-04-26 20:48:58 >>>故障排除日志:终端未同步成功订单列表
2026-04-26 20:48:58 开始打印,排队:327,票券:2604262048515866617801,订单:2604262048510056987776,[2026-04-26 20:48:57微信支付10元]
2026-04-26 20:48:58>>>MQTT票号同步场景，创建空订单对象
2026-04-26 20:48:58>>>合并MQTT票号列表到订单同步请求,共1张票
2026-04-26 20:49:00 排队号更新回调:{"return_code":"success","return_msg":"同步成功","data":[{"ticket_no":"2604262048515866617801","queue_number":327,"trade_uid":"2604262048510056987776"}]}
2026-04-26 20:49:00 >>>故障排除日志:删除未同步下发订单成功2604262048510056987776
2026-04-26 20:49:00 >>>故障排除日志:终端同步成功后剩余订单列表
定时检测未同步订单启用[checkOrderNum=536878525]


===20:54:31===
2026-04-26 20:54:28>>>cash read=0A
2026-04-26 20:54:29>>>cash read=3E


===20:56:32===
2026-04-26 20:55:52>>>cash read=00
2026-04-26 20:55:53>>>cash read=818F42
2026-04-26 20:55:53>>>cash write=02
2026-04-26 20:55:53 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 20:55:53>>>cash read=10
2026-04-26 20:55:53 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 20:55:53 当前产品价格10元，投币10元，打印小票中...
2026-04-26 20:55:53 >>>开始打印,排队号为328,订单号为2604262055530022664113
2026-04-26 20:55:54>>>订单2604262055530022664113写入成功,剩余空间为1679500,占用RAM为634.28515625
2026-04-26 20:55:55>>>cash read=818F42
2026-04-26 20:55:55 >>>回调事件130,cash_status,10022,进钞中...read money=10
删除未同步订单2604262055530022664113
2026-04-26 20:55:56>>>订单2604262055530022664113删除成功,剩余空间为1680500,占用RAM为624.154296875
检测订单目录中>>>
无未同步订单>>>
2026-04-26 20:55:56 >>>当前Ram内存为616.03125
定时检测未同步订单启用[checkOrderNum=536878597]
2026-04-26 20:55:56>>>cash read=10
2026-04-26 20:55:56 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 20:55:56 当前产品价格10元，投币10元，打印小票中...
2026-04-26 20:55:56 >>>开始打印,排队号为329,订单号为2604262055560022664771
2026-04-26 20:55:56>>>订单2604262055560022664771写入成功,剩余空间为1679000,占用RAM为638.6513671875
2026-04-26 20:55:58>>>cash read=818F42
2026-04-26 20:55:58 >>>回调事件130,cash_status,10022,进钞中...read money=10
删除未同步订单2604262055560022664771
2026-04-26 20:55:58>>>订单2604262055560022664771删除成功,剩余空间为1679500,占用RAM为625.7265625
检测订单目录中>>>
无未同步订单>>>
2026-04-26 20:55:59 >>>当前Ram内存为617.224609375
定时检测未同步订单启用[checkOrderNum=536878605]
2026-04-26 20:55:59>>>cash read=10
2026-04-26 20:55:59 >>>回调事件130,10,10023,finish Money=10,进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 20:55:59 当前产品价格10元，投币10元，打印小票中...
2026-04-26 20:55:59 >>>开始打印,排队号为330,订单号为2604262055590022664329
2026-04-26 20:55:59>>>订单2604262055590022664329写入成功,剩余空间为1678000,占用RAM为644.8037109375
删除未同步订单2604262055590022664329
2026-04-26 20:56:01>>>订单2604262055590022664329删除成功,剩余空间为1678500,占用RAM为650.5224609375
检测订单目录中>>>
无未同步订单>>>
2026-04-26 20:56:02 >>>当前Ram内存为619.025390625
定时检测未同步订单启用[checkOrderNum=536878613]
2026-04-26 20:56:03>>>cash write=0C
2026-04-26 20:56:03>>>cash read=29
2026-04-26 20:56:03 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 20:56:03>>>cash read=2F29
2026-04-26 20:56:05>>>cash read=3E
2026-04-26 20:56:07>>>cash read=00
2026-04-26 20:56:08>>>cash read=818F42
2026-04-26 20:56:08>>>cash write=02
2026-04-26 20:56:08 >>>回调事件130,cash_status,10022,进钞中...read money=10
2026-04-26 20:56:09>>>cash write=0C
2026-04-26 20:56:09>>>cash read=3E
2026-04-26 20:56:09 >>>回调事件130,10,10023,finish Money=10,非正常进钞完成
定时检测未同步订单关闭[lastTableNumForSync=0][lastOrderCheckTime=0]
2026-04-26 20:56:09 当前产品价格10元，投币10元，打印小票中...
2026-04-26 20:56:09 >>>开始打印,排队号为331,订单号为2604262056090022664693
2026-04-26 20:56:09>>>订单2604262056090022664693写入成功,剩余空间为1676500,占用RAM为671.33203125
删除未同步订单2604262056090022664693
2026-04-26 20:56:12>>>订单2604262056090022664693删除成功,剩余空间为1677500,占用RAM为654.4560546875
检测订单目录中>>>
无未同步订单>>>
2026-04-26 20:56:12 >>>当前Ram内存为620.5322265625
定时检测未同步订单启用[checkOrderNum=536878621]
2026-04-26 20:56:13>>>cash read=29
2026-04-26 20:56:13 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 20:56:13>>>cash read=2F29
2026-04-26 20:56:15>>>cash read=3E
2026-04-26 20:56:16>>>cash read=00
2026-04-26 20:56:17>>>cash read=29
2026-04-26 20:56:17 >>>回调事件130,cash_status,20029,退钞中
2026-04-26 20:56:18>>>cash read=2F29
2026-04-26 20:56:19>>>cash read=3E