2023-07-17 03:29:37 +00:00
|
|
|
|
#include "Scanner.h"
|
|
|
|
|
#include <iostream>
|
2023-10-26 07:34:10 +00:00
|
|
|
|
|
2023-07-17 03:29:37 +00:00
|
|
|
|
#include "MemoryInfo.h"
|
|
|
|
|
#include "SysInforTool.h"
|
2023-11-18 03:48:39 +00:00
|
|
|
|
#include "StopWatch.h"
|
2023-07-17 03:29:37 +00:00
|
|
|
|
|
2023-10-10 10:12:15 +00:00
|
|
|
|
#define BTN_START 0
|
|
|
|
|
#define BTN_STOP 1 //按键停止扫描
|
|
|
|
|
#define BTN_LOW_POWER 2 //按键低功耗
|
|
|
|
|
#define BTN_NORMAL_POWER 3 //按键正常模式 (退出低功耗)
|
2023-07-17 03:29:37 +00:00
|
|
|
|
|
|
|
|
|
Scanner::Scanner(ScannerGlue glue)
|
2024-02-05 06:55:03 +00:00
|
|
|
|
: motorZouzhi(),motorCuozhi(),motor_cfg_(),
|
|
|
|
|
m_glue(glue),m_isPulling(false),
|
|
|
|
|
m_isDoublePaper(false),isPaperInit(false),
|
|
|
|
|
m_jamPaper(false),m_jamIn(false),
|
|
|
|
|
m_correctting(false),waitpapertime(200),
|
|
|
|
|
m_scansysinfo(nullptr),auto_size_(false)
|
2023-07-17 03:29:37 +00:00
|
|
|
|
{
|
2023-11-18 03:48:39 +00:00
|
|
|
|
frame_time_ = 3000;
|
2023-07-17 03:29:37 +00:00
|
|
|
|
m_scaninfo = GetScanInfoFromJson();
|
|
|
|
|
|
2024-02-22 06:05:17 +00:00
|
|
|
|
status_change_init();
|
|
|
|
|
|
2023-10-26 07:34:10 +00:00
|
|
|
|
capturer.reset(new MultiFrameCapture(m_glue));
|
2023-07-17 03:29:37 +00:00
|
|
|
|
capturer->SetParent(this);
|
2023-11-18 03:48:39 +00:00
|
|
|
|
capturer->set_image_callback(&have_img_callback);
|
2023-11-18 09:06:42 +00:00
|
|
|
|
|
2023-09-19 02:12:37 +00:00
|
|
|
|
//固件版本
|
|
|
|
|
int version=7010;
|
2023-07-17 03:29:37 +00:00
|
|
|
|
|
|
|
|
|
auto btnevent = [this](const int eventtype)
|
|
|
|
|
{
|
|
|
|
|
if (!IsScanning()) //未扫描
|
|
|
|
|
{
|
2023-10-19 09:29:46 +00:00
|
|
|
|
switch (eventtype)
|
2023-10-10 10:12:15 +00:00
|
|
|
|
{
|
2023-10-19 09:29:46 +00:00
|
|
|
|
case BTN_LOW_POWER:
|
|
|
|
|
stop_countdown();
|
|
|
|
|
system("sh /mnt/flash-disk/low_power.sh 1");
|
|
|
|
|
break;
|
|
|
|
|
case BTN_NORMAL_POWER:
|
|
|
|
|
system("sh /mnt/flash-disk/low_power.sh 0");
|
|
|
|
|
start_enter_lowpwoer();
|
|
|
|
|
break;
|
|
|
|
|
case BTN_START:
|
|
|
|
|
/* code */
|
|
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
break;
|
2023-10-10 10:12:15 +00:00
|
|
|
|
}
|
2023-07-17 03:29:37 +00:00
|
|
|
|
}
|
|
|
|
|
else //扫描中
|
|
|
|
|
{
|
2023-10-10 10:12:15 +00:00
|
|
|
|
if (eventtype == BTN_STOP)
|
2023-07-17 03:29:37 +00:00
|
|
|
|
{
|
2024-02-22 06:05:17 +00:00
|
|
|
|
put(HG_EVT_STOP_SCAN);
|
2023-10-19 09:29:46 +00:00
|
|
|
|
printf("keyboard cancel scan\r\n");
|
2023-07-17 03:29:37 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
};
|
|
|
|
|
sensor = std::make_shared<Sensor>(sysEvent);
|
2023-11-18 09:06:42 +00:00
|
|
|
|
|
|
|
|
|
|
2023-07-17 03:29:37 +00:00
|
|
|
|
m_keyboard.reset(new huagao::Keyboard(btnevent));
|
|
|
|
|
m_keyboard->init();
|
2023-11-18 09:06:42 +00:00
|
|
|
|
|
2023-07-17 03:29:37 +00:00
|
|
|
|
motorZouzhi.enablePower(true);
|
|
|
|
|
motorZouzhi.setSpeed(4000);
|
|
|
|
|
motorCuozhi.setSpeed(3000);
|
|
|
|
|
motorCuozhi.setDirection(false);
|
2023-09-19 02:40:47 +00:00
|
|
|
|
|
2023-07-17 03:29:37 +00:00
|
|
|
|
FsmState::setScanner(this);
|
2024-02-22 06:05:17 +00:00
|
|
|
|
|
2023-07-17 03:29:37 +00:00
|
|
|
|
threadRunMessageLoop = std::thread(&Scanner::runMessageLoop, this);
|
|
|
|
|
Motor::enablePower(true);
|
2024-02-05 06:55:03 +00:00
|
|
|
|
UpdateScanInfo();
|
2023-07-17 03:29:37 +00:00
|
|
|
|
}
|
|
|
|
|
Scanner::~Scanner()
|
|
|
|
|
{
|
|
|
|
|
Motor::enablePower(false);
|
|
|
|
|
sysEvent.Clear();
|
|
|
|
|
sysEvent.ShutDown();
|
|
|
|
|
bMsgLoop = false;
|
|
|
|
|
threadRunMessageLoop.join();
|
|
|
|
|
|
|
|
|
|
m_DstScannum = 0;
|
|
|
|
|
if (threadRunScan.joinable())
|
|
|
|
|
threadRunScan.join();
|
|
|
|
|
}
|
|
|
|
|
|
2023-10-21 09:20:07 +00:00
|
|
|
|
void Scanner::updateSpeedMode()
|
2023-07-17 03:29:37 +00:00
|
|
|
|
{
|
|
|
|
|
m_scaninfo = GetScanInfoFromJson();
|
2024-02-05 06:55:03 +00:00
|
|
|
|
int speed = m_scaninfo.SpeedMode;
|
|
|
|
|
printf("JSON文件获取当前速度:%d\r\n",speed);
|
|
|
|
|
if(speed == 0)
|
|
|
|
|
speed = 3;
|
2023-10-07 06:08:42 +00:00
|
|
|
|
|
2023-09-14 02:46:04 +00:00
|
|
|
|
unsigned int t_dpi = m_config.params.dpi;
|
2023-09-19 02:40:47 +00:00
|
|
|
|
|
2023-10-31 10:05:43 +00:00
|
|
|
|
if(m_config.params.pageSize == (unsigned int)PaperSize::G400_MAXSIZE || m_config.params.pageSize == (unsigned int)PaperSize::G400_MAXAUTO ) //长文稿采用600dpi模式扫描
|
2023-10-21 09:20:07 +00:00
|
|
|
|
t_dpi = 3;
|
|
|
|
|
if (m_config.params.slow_moire) //摩尔纹特殊处理
|
2024-02-05 06:55:03 +00:00
|
|
|
|
t_dpi = speed = 16;
|
2023-10-21 09:20:07 +00:00
|
|
|
|
|
2024-02-05 06:55:03 +00:00
|
|
|
|
Zouzhi_ParamEx_ = motor_cfg_.GetMotorSpeedParam(true,MotorConfig::MTBDType::MT_TMC,speed,m_config.params.isColor,t_dpi);
|
|
|
|
|
Cuozhi_ParamEx_ = motor_cfg_.GetMotorSpeedParam(false,MotorConfig::MTBDType::MT_TMC,speed,m_config.params.isColor,t_dpi);
|
|
|
|
|
|
|
|
|
|
motorCuozhi.speedChange(Cuozhi_ParamEx_);
|
|
|
|
|
motorZouzhi.speedChange(Zouzhi_ParamEx_);
|
2023-07-17 03:29:37 +00:00
|
|
|
|
}
|
2024-02-05 06:55:03 +00:00
|
|
|
|
void Scanner::ConfigScanParam(HG_ScanConfiguration config)
|
|
|
|
|
{
|
|
|
|
|
m_config = config;
|
|
|
|
|
auto_size_ = m_config.params.pageSize==(int)PaperSize::G400_AUTO ||
|
|
|
|
|
m_config.params.pageSize==(int)PaperSize::G400_MAXAUTO ||
|
|
|
|
|
m_config.params.pageSize==(int)PaperSize::G400_MAXSIZE;
|
2023-07-17 03:29:37 +00:00
|
|
|
|
|
2024-02-05 06:55:03 +00:00
|
|
|
|
updateSpeedMode();
|
|
|
|
|
capturer->UpdateScanParam(m_config);
|
|
|
|
|
}
|
|
|
|
|
void Scanner::UpdateScanInfo()
|
|
|
|
|
{
|
|
|
|
|
m_scaninfo = GetScanInfoFromJson();
|
|
|
|
|
auto params = motor_cfg_.GetMotorSpeedParams(true,MotorConfig::MTBDType::MT_TMC);
|
|
|
|
|
for (int i = 0; i < params.size(); i++)
|
|
|
|
|
{
|
|
|
|
|
if (params[i].speed == m_scaninfo.SpeedMode)
|
|
|
|
|
{
|
|
|
|
|
auto fpgaparam = GetFpgaparam(params[i].dpi, params[i].colormode);
|
|
|
|
|
fpgaparam.Sp = params[i].sp;
|
|
|
|
|
SaveFpgaparam(fpgaparam);
|
|
|
|
|
if (params[i].dpi == 3 && params[i].colormode)
|
|
|
|
|
{
|
|
|
|
|
printf("sp sp sp sp sp sp sp sp sp:%d :%d\r\n",params[i].sp,fpgaparam.Sp);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
// if(params[i].speed == 0x10)
|
|
|
|
|
// {
|
|
|
|
|
// auto fpgaparam = GetFpgaparam(params[i].dpi, params[i].colormode);
|
|
|
|
|
// fpgaparam.Sp = params[i].sp;
|
|
|
|
|
// SaveFpgaparam(fpgaparam);
|
|
|
|
|
// }
|
|
|
|
|
}
|
|
|
|
|
updateSpeedMode();
|
|
|
|
|
}
|
2023-11-18 03:48:39 +00:00
|
|
|
|
void Scanner::have_img_callback(int val)
|
|
|
|
|
{
|
|
|
|
|
if (val < 0)
|
|
|
|
|
{
|
|
|
|
|
frame_time_ = 3000;
|
|
|
|
|
}
|
|
|
|
|
frame_time_ = val ;
|
|
|
|
|
}
|
|
|
|
|
|
2023-07-17 03:29:37 +00:00
|
|
|
|
void Scanner::startScan()
|
|
|
|
|
{
|
|
|
|
|
if (threadRunScan.joinable())
|
|
|
|
|
threadRunScan.join();
|
|
|
|
|
stop_countdown();
|
2024-02-05 06:55:03 +00:00
|
|
|
|
|
2023-10-21 09:20:07 +00:00
|
|
|
|
updateSpeedMode();
|
2023-07-17 03:29:37 +00:00
|
|
|
|
// //开始进行扫描
|
|
|
|
|
threadRunScan = std::thread(&Scanner::runScan, this);
|
|
|
|
|
}
|
|
|
|
|
void Scanner::runMessageLoop()
|
|
|
|
|
{
|
2024-02-23 07:29:14 +00:00
|
|
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(200));//避免scanpin io 开始异常
|
2023-07-17 03:29:37 +00:00
|
|
|
|
GetSysInfo();//待fpga 重启完成
|
2024-02-22 06:05:17 +00:00
|
|
|
|
FsmState *fsm = FsmStateManagerEx<InitState>::GetState();
|
2023-07-17 03:29:37 +00:00
|
|
|
|
while (bMsgLoop)
|
|
|
|
|
{
|
|
|
|
|
ScanEvent evt = sysEvent.Take();
|
2024-02-22 06:05:17 +00:00
|
|
|
|
fsm = fsm->on_event(evt);
|
|
|
|
|
processevent(evt);
|
2023-07-17 03:29:37 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
2024-02-22 06:05:17 +00:00
|
|
|
|
void Scanner::processevent(ScanEvent event)
|
2023-07-17 03:29:37 +00:00
|
|
|
|
{
|
2024-02-22 06:05:17 +00:00
|
|
|
|
if (event == HG_EVT_START_SCAN
|
|
|
|
|
|| event == HG_EVT_COVER_CLOSED
|
2024-02-23 07:29:14 +00:00
|
|
|
|
|| event == HG_EVT_PAPER_STANDBY
|
|
|
|
|
|| event == HG_EVT_NORES) //可以过滤没有用的信息
|
2023-07-17 03:29:37 +00:00
|
|
|
|
{
|
|
|
|
|
return;
|
|
|
|
|
}
|
2024-02-22 06:05:17 +00:00
|
|
|
|
printf("插入事件 001 ID:%d\r\n",event);
|
|
|
|
|
m_glue.m_deviceevent(event_2_hg_map_[event], "");
|
2023-07-17 03:29:37 +00:00
|
|
|
|
}
|
|
|
|
|
void Scanner::runScan()
|
|
|
|
|
{
|
|
|
|
|
LOG("-------------Scanner RunScan Start-------------\r\n");
|
2024-02-05 06:55:03 +00:00
|
|
|
|
sensor->resetPaperPin();
|
2023-07-17 03:29:37 +00:00
|
|
|
|
capturer->open();
|
|
|
|
|
motorCuozhi.pauseWaitForThread();
|
2023-08-31 08:37:05 +00:00
|
|
|
|
|
2023-07-17 03:29:37 +00:00
|
|
|
|
if (!isPaperInit)
|
|
|
|
|
{
|
2024-02-22 06:05:17 +00:00
|
|
|
|
//preFeed();
|
|
|
|
|
//isPaperInit = true;
|
2023-07-17 03:29:37 +00:00
|
|
|
|
}
|
2024-02-05 06:55:03 +00:00
|
|
|
|
motorZouzhi.start();
|
2023-07-17 03:29:37 +00:00
|
|
|
|
capturer->setScanFlag(true);
|
2023-08-09 07:31:27 +00:00
|
|
|
|
|
2023-07-17 03:29:37 +00:00
|
|
|
|
StopWatch sw;
|
2024-02-05 06:55:03 +00:00
|
|
|
|
|
2023-11-07 06:34:33 +00:00
|
|
|
|
isScaning = true;
|
2024-02-05 06:55:03 +00:00
|
|
|
|
m_isDoublePaper = false;
|
|
|
|
|
m_jamPaper = false;
|
|
|
|
|
m_jamIn = false;
|
2023-11-14 10:02:27 +00:00
|
|
|
|
int error_code = 0;
|
2023-07-17 03:29:37 +00:00
|
|
|
|
while (m_DstScannum > 0)
|
|
|
|
|
{
|
|
|
|
|
sensor->enableDoubleSensor(m_config.params.doubleFeeded);
|
2024-02-23 07:29:14 +00:00
|
|
|
|
sensor->width_detect_enable(m_config.params.width_detect_enable);
|
|
|
|
|
sensor->screw_detect_enable(m_config.params.screw_detect_enable);
|
2023-07-17 03:29:37 +00:00
|
|
|
|
if (m_DstScannum == 0) //被取消扫描了
|
|
|
|
|
{
|
2023-11-07 06:34:33 +00:00
|
|
|
|
isScaning = false;
|
2023-07-17 03:29:37 +00:00
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
2024-02-05 06:55:03 +00:00
|
|
|
|
motorCuozhi.startAsyn();
|
2023-07-17 03:29:37 +00:00
|
|
|
|
if (!sensor->isPaperStandby())
|
|
|
|
|
{
|
2024-02-23 07:29:14 +00:00
|
|
|
|
//put(HG_EVT_STOP_SCAN);
|
2023-07-17 03:29:37 +00:00
|
|
|
|
isRested = false;
|
2023-11-07 06:34:33 +00:00
|
|
|
|
isScaning = false;
|
2023-07-17 03:29:37 +00:00
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
isRested = false;
|
2023-09-19 01:24:12 +00:00
|
|
|
|
if (!sensor->waitPaperIn(3000))//
|
2023-07-17 03:29:37 +00:00
|
|
|
|
{
|
|
|
|
|
if (!m_isDoublePaper)
|
|
|
|
|
{
|
|
|
|
|
m_jamIn = true;
|
2024-02-22 06:05:17 +00:00
|
|
|
|
put(HG_EVT_JAM_IN);
|
2023-07-17 03:29:37 +00:00
|
|
|
|
m_scaninfo.JamInNum++;
|
|
|
|
|
}
|
2023-11-07 06:34:33 +00:00
|
|
|
|
isScaning = false;
|
2023-07-17 03:29:37 +00:00
|
|
|
|
break;
|
|
|
|
|
}
|
2023-09-14 02:46:04 +00:00
|
|
|
|
printf("检测到纸张的时间:%f\r\n",sw.elapsed_ms());//检测到纸张
|
|
|
|
|
|
2023-07-18 02:29:03 +00:00
|
|
|
|
capturer->snap();
|
2023-11-14 10:02:27 +00:00
|
|
|
|
|
2023-11-18 03:48:39 +00:00
|
|
|
|
motorCuozhi.pauseWaitForThread();
|
2024-02-01 09:33:55 +00:00
|
|
|
|
//capturer->wait_image_notify();
|
2023-11-14 10:02:27 +00:00
|
|
|
|
|
2023-11-18 03:48:39 +00:00
|
|
|
|
if (!sensor->isCoverClosed()) //中途开盖 笑麻了
|
2023-11-14 10:02:27 +00:00
|
|
|
|
{
|
2024-02-22 06:05:17 +00:00
|
|
|
|
error_code = (int)HG_ScannerStatus::OPEN_COVER;
|
|
|
|
|
capturer->waitsnapdone(error_code);//等待采集完成
|
2023-11-14 10:02:27 +00:00
|
|
|
|
break;
|
|
|
|
|
}
|
2023-07-17 03:29:37 +00:00
|
|
|
|
|
2023-12-11 08:12:03 +00:00
|
|
|
|
printf("一张纸所需要的采集时间:%dms\r\n",frame_time_);
|
2024-02-05 06:55:03 +00:00
|
|
|
|
if (auto_size_ || m_config.params.dpi == 3)
|
|
|
|
|
{
|
|
|
|
|
frame_time_ += 2000;
|
|
|
|
|
}
|
|
|
|
|
|
2023-11-18 03:48:39 +00:00
|
|
|
|
if (sensor->waitPaperOut(frame_time_))
|
|
|
|
|
{
|
2023-07-17 03:29:37 +00:00
|
|
|
|
if (!m_isDoublePaper)
|
|
|
|
|
{
|
2023-11-18 03:48:39 +00:00
|
|
|
|
error_code = (int)HG_ScannerStatus::PAPER_JAM;
|
2023-07-17 03:29:37 +00:00
|
|
|
|
m_jamPaper = true;
|
2024-02-22 06:05:17 +00:00
|
|
|
|
put(HG_EVT_JAM_OUT);
|
2023-07-17 03:29:37 +00:00
|
|
|
|
m_scaninfo.JamOutNum++;
|
2023-11-04 01:38:17 +00:00
|
|
|
|
printf("paper 卡纸了。。。。。\n");
|
2023-07-17 03:29:37 +00:00
|
|
|
|
}
|
2023-12-11 08:12:03 +00:00
|
|
|
|
else
|
|
|
|
|
error_code = (int)HG_ScannerStatus::DETECT_DOUBLE_FEED;
|
|
|
|
|
printf("error_code:%d\r\n",error_code);
|
2023-11-14 10:02:27 +00:00
|
|
|
|
capturer->waitsnapdone(error_code);//等待采集完成
|
2023-11-07 06:34:33 +00:00
|
|
|
|
isScaning = false;
|
2023-07-17 03:29:37 +00:00
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
2023-11-18 03:48:39 +00:00
|
|
|
|
sensor->enableDoubleSensor(false);
|
2024-02-23 07:29:14 +00:00
|
|
|
|
sensor->width_detect_enable(false);
|
|
|
|
|
sensor->screw_detect_enable(false);
|
2024-02-05 06:55:03 +00:00
|
|
|
|
capturer->stopsnap(auto_size_);
|
2023-11-14 10:02:27 +00:00
|
|
|
|
|
2023-11-18 03:48:39 +00:00
|
|
|
|
error_code = m_isDoublePaper ? (int)HG_ScannerStatus::DETECT_DOUBLE_FEED : m_jamPaper ? (int)HG_ScannerStatus::PAPER_JAM :0;
|
2023-11-14 10:02:27 +00:00
|
|
|
|
capturer->waitsnapdone(error_code);//等待采集完成
|
2023-08-09 07:31:27 +00:00
|
|
|
|
|
2023-12-11 08:12:03 +00:00
|
|
|
|
{
|
|
|
|
|
m_DstScannum--;
|
|
|
|
|
m_scaninfo.RollerNum++;
|
|
|
|
|
m_scaninfo.TotalScanned++;
|
|
|
|
|
}
|
2023-07-17 03:29:37 +00:00
|
|
|
|
if (m_DstScannum == 0)
|
|
|
|
|
{
|
2024-02-22 06:05:17 +00:00
|
|
|
|
put(HG_EVT_STOP_SCAN);
|
2023-11-07 06:34:33 +00:00
|
|
|
|
isScaning = false;
|
2023-07-17 03:29:37 +00:00
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
sw.reset();
|
2023-11-18 03:48:39 +00:00
|
|
|
|
|
2023-12-11 08:12:03 +00:00
|
|
|
|
////必须控制队列帧数。
|
|
|
|
|
while ( m_config.params.dpi == 0x01 && image_num_>=15)
|
|
|
|
|
{
|
|
|
|
|
printf("200DPI 图像队列过多,正在等待图像取走:%d\r\n",image_num_);
|
|
|
|
|
this_thread::sleep_for(std::chrono::milliseconds(300));
|
|
|
|
|
}
|
2024-02-05 06:55:03 +00:00
|
|
|
|
while ( m_config.params.dpi == 0x02 && image_num_ >= 12 && m_config.params.isColor == 1)
|
2023-12-11 08:12:03 +00:00
|
|
|
|
{
|
|
|
|
|
printf("300DPI 图像队列过多,正在等待图像取走:%d\r\n",image_num_);
|
|
|
|
|
this_thread::sleep_for(std::chrono::milliseconds(300));
|
|
|
|
|
}
|
2023-12-25 06:16:56 +00:00
|
|
|
|
// while ( m_config.params.dpi == 0x02 && image_num_ >= 20 && m_config.params.isColor == 0)
|
|
|
|
|
// {
|
|
|
|
|
// printf("300DPI 图像队列过多,正在等待图像取走:%d\r\n",image_num_);
|
|
|
|
|
// this_thread::sleep_for(std::chrono::milliseconds(300));
|
|
|
|
|
// }
|
2023-12-11 08:12:03 +00:00
|
|
|
|
while ( m_config.params.dpi == 0x03 && image_num_ >= 2)
|
2023-07-17 03:29:37 +00:00
|
|
|
|
{
|
2023-12-11 08:12:03 +00:00
|
|
|
|
printf("600DPI 图像队列过多,正在等待图像取走:%d\r\n",image_num_);
|
|
|
|
|
this_thread::sleep_for(std::chrono::milliseconds(300));
|
|
|
|
|
}
|
|
|
|
|
while (meminfo->GetMemoryUsed() > 90.0f) //内存占用高于75% 其实我觉得开发人员应该自己控制好这个内存大小,让他绝对不可能超过这个内存大小
|
|
|
|
|
{
|
2023-08-31 08:37:05 +00:00
|
|
|
|
if (sw.elapsed_s() < 50.0)
|
2023-11-18 03:48:39 +00:00
|
|
|
|
std::this_thread::yield();
|
2023-07-17 03:29:37 +00:00
|
|
|
|
else
|
|
|
|
|
{
|
2024-02-22 06:05:17 +00:00
|
|
|
|
put(HG_EVT_STOP_SCAN);
|
2023-11-07 06:34:33 +00:00
|
|
|
|
isScaning = false;
|
2023-07-17 03:29:37 +00:00
|
|
|
|
break;
|
|
|
|
|
}
|
2023-12-11 08:12:03 +00:00
|
|
|
|
}
|
2023-07-17 03:29:37 +00:00
|
|
|
|
}
|
2023-11-07 06:34:33 +00:00
|
|
|
|
isScaning = false;
|
2023-07-17 03:29:37 +00:00
|
|
|
|
m_DstScannum = 0;
|
|
|
|
|
sensor->enableDoubleSensor(false);
|
2024-02-23 07:29:14 +00:00
|
|
|
|
sensor->width_detect_enable(false);
|
|
|
|
|
sensor->screw_detect_enable(false);
|
2023-07-17 03:29:37 +00:00
|
|
|
|
sensor->resetPaperPin();
|
|
|
|
|
capturer->setScanFlag(false);
|
2024-02-05 06:55:03 +00:00
|
|
|
|
capturer->stopsnap(auto_size_);
|
2023-08-09 07:31:27 +00:00
|
|
|
|
|
2023-12-11 08:12:03 +00:00
|
|
|
|
int t_delay = 500;
|
2023-09-15 06:05:42 +00:00
|
|
|
|
this_thread::sleep_for(std::chrono::milliseconds(t_delay)); //走纸多转一会儿 确保扫描传感器过了之后 纸能出完
|
|
|
|
|
|
2023-07-17 03:29:37 +00:00
|
|
|
|
LOG("\n--------------------------scan done --------------------------------\n");
|
|
|
|
|
}
|
|
|
|
|
void Scanner::CreatCorrectData(int correctmode)
|
|
|
|
|
{
|
|
|
|
|
m_correctting = true;
|
|
|
|
|
capturer->createCorrect(correctmode);
|
|
|
|
|
}
|
|
|
|
|
void Scanner::preFeed()
|
|
|
|
|
{
|
2024-02-05 06:55:03 +00:00
|
|
|
|
int sleeptime = 150;
|
2023-07-17 03:29:37 +00:00
|
|
|
|
motorCuozhi.feeding();
|
|
|
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(sleeptime));
|
|
|
|
|
motorCuozhi.pause();
|
2024-02-05 06:55:03 +00:00
|
|
|
|
//std::this_thread::sleep_for(std::chrono::milliseconds(300));
|
2023-07-17 03:29:37 +00:00
|
|
|
|
}
|
|
|
|
|
std::string Scanner::GetSysInfo()
|
|
|
|
|
{
|
|
|
|
|
meminfo = MemoryInfo::GetInstance();
|
2023-09-19 02:40:47 +00:00
|
|
|
|
|
2023-07-17 03:29:37 +00:00
|
|
|
|
auto scannerinfo = GetScanInfo();
|
|
|
|
|
auto fwverion = mapFradme_SP[scannerinfo.SpeedMode].FWVERSIO;
|
|
|
|
|
ScannerSysInfo info = {
|
|
|
|
|
.CPU = SCPU::CPU_3288,
|
|
|
|
|
.Systype = SysType::Sys_Linux_Debian,
|
|
|
|
|
.Screentype = ScreenType::ST_None,
|
|
|
|
|
.MtBoardVersion = 0x20220114,
|
2023-10-26 07:34:10 +00:00
|
|
|
|
.MtType = SMBType::MB_DRV_UNKNOWUN,
|
2023-09-19 02:12:37 +00:00
|
|
|
|
.FPGAVersion = 0,
|
2023-10-26 07:34:10 +00:00
|
|
|
|
.Cistype = HGCISType::CIS_UNKOWNUN,
|
2023-07-17 03:29:37 +00:00
|
|
|
|
.ResSup = {200, 300, 0},
|
|
|
|
|
.MemTotal = 0,
|
|
|
|
|
.DiskTotal = 100,
|
|
|
|
|
.DiskUsed = 0,
|
|
|
|
|
.KernelVersion = "",
|
|
|
|
|
.Have_EthernPort = 0,
|
|
|
|
|
.ServiceVersion = fwverion,
|
|
|
|
|
.UsbProtocol = 1.0};
|
2023-09-19 02:40:47 +00:00
|
|
|
|
|
2023-07-17 03:29:37 +00:00
|
|
|
|
m_scansysinfo.reset(new SysInforTool(info));
|
|
|
|
|
return m_scansysinfo->GetSysInfo();
|
|
|
|
|
}
|
2023-11-14 10:02:27 +00:00
|
|
|
|
void Scanner::emergency_stop(int id)
|
|
|
|
|
{
|
|
|
|
|
sensor->cancelWaitPaper();
|
|
|
|
|
sensor->enableDoubleSensor(false);
|
2024-02-23 07:29:14 +00:00
|
|
|
|
sensor->width_detect_enable(false);
|
|
|
|
|
sensor->screw_detect_enable(false);
|
2023-11-14 10:02:27 +00:00
|
|
|
|
m_DstScannum = 0;
|
|
|
|
|
|
|
|
|
|
motorCuozhi.stop();
|
|
|
|
|
motorZouzhi.stop();
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
capturer->stopsnap(true);
|
|
|
|
|
SaveScaninfo(m_scaninfo);
|
|
|
|
|
start_enter_lowpwoer();
|
2024-02-22 06:05:17 +00:00
|
|
|
|
printf("异常错误!!! 紧急停止!!! \n");
|
2023-11-14 10:02:27 +00:00
|
|
|
|
}
|
|
|
|
|
void Scanner::stop_scan()
|
|
|
|
|
{
|
|
|
|
|
sensor->cancelWaitPaper();
|
|
|
|
|
sensor->enableDoubleSensor(false);
|
2024-02-23 07:29:14 +00:00
|
|
|
|
sensor->width_detect_enable(false);
|
|
|
|
|
sensor->screw_detect_enable(false);
|
2023-11-14 10:02:27 +00:00
|
|
|
|
m_DstScannum = 0;
|
2023-11-18 03:48:39 +00:00
|
|
|
|
|
2023-11-14 10:02:27 +00:00
|
|
|
|
if (threadRunScan.joinable())
|
|
|
|
|
threadRunScan.join();
|
2023-11-18 03:48:39 +00:00
|
|
|
|
|
2023-11-14 10:02:27 +00:00
|
|
|
|
motorZouzhi.stop();
|
|
|
|
|
motorCuozhi.stop();
|
|
|
|
|
|
|
|
|
|
SaveScaninfo(m_scaninfo);
|
|
|
|
|
start_enter_lowpwoer();
|
2024-02-22 06:05:17 +00:00
|
|
|
|
printf("扫描结束!!! 正常停止!!! \n");
|
2023-11-14 10:02:27 +00:00
|
|
|
|
}
|
|
|
|
|
void Scanner::reset()
|
|
|
|
|
{
|
|
|
|
|
if (!sensor->isPaperStandby())
|
|
|
|
|
{
|
|
|
|
|
motorCuozhi.reset();
|
|
|
|
|
isRested = true;
|
|
|
|
|
isPaperInit = false;
|
2024-02-22 06:05:17 +00:00
|
|
|
|
LOG("Scanner->motorCuozhi is reseted \n");
|
2023-11-14 10:02:27 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
void Scanner::paper_pullout()
|
|
|
|
|
{
|
|
|
|
|
if (!m_isPulling)
|
|
|
|
|
m_isPulling = true;
|
|
|
|
|
|
|
|
|
|
motorCuozhi.stop();
|
2024-02-05 06:55:03 +00:00
|
|
|
|
MotorSpeedParamEx ParamEx = motor_cfg_.GetMotorSpeedParam(true,MotorConfig::MTBDType::MT_TMC,1,1,1);
|
|
|
|
|
motorZouzhi.speedChange(ParamEx);
|
2023-11-14 10:02:27 +00:00
|
|
|
|
motorZouzhi.setDirection(1);
|
|
|
|
|
motorZouzhi.start();
|
|
|
|
|
if (sensor->waitPaperOut(5000))
|
|
|
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(2000));
|
|
|
|
|
motorZouzhi.stop();
|
|
|
|
|
motorZouzhi.speedRecover();
|
|
|
|
|
m_isPulling = false;
|
|
|
|
|
}
|
|
|
|
|
|
2024-02-22 06:05:17 +00:00
|
|
|
|
void Scanner::status_change_init()
|
|
|
|
|
{
|
|
|
|
|
status_change_map_[HG_EVT_PAPER_NOT_STANDBY] = &Scanner::status_change_standby ;
|
|
|
|
|
status_change_map_[HG_EVT_PAPER_STANDBY] = &Scanner::status_change_paper_ready;
|
|
|
|
|
status_change_map_[HG_EVT_JAM_OUT] = &Scanner::status_change_paperjam;
|
|
|
|
|
status_change_map_[HG_EVT_JAM_IN] = &Scanner::status_change_feed_in_error;
|
|
|
|
|
status_change_map_[HG_EVT_COVER_OPENED] = &Scanner::status_change_open_cover;
|
|
|
|
|
status_change_map_[HG_EVT_COVER_CLOSED] = &Scanner::status_change_close_cover;
|
|
|
|
|
status_change_map_[HG_EVT_ERROR_DOUBLEPAPER] = &Scanner::status_change_double_paper;
|
|
|
|
|
status_change_map_[HG_EVT_START_SCAN] = &Scanner::status_change_scanning;
|
|
|
|
|
status_change_map_[HG_EVT_STOP_SCAN] = &Scanner::status_change_stop_scan;
|
|
|
|
|
status_change_map_[HG_EVT_STOP_SCAN_EMERGENCY] = &Scanner::status_change_emergency_stop_scan;
|
|
|
|
|
status_change_map_[HG_EVT_DOUBLEPAPER] = &Scanner::status_change_double_paper;
|
2024-02-23 07:29:14 +00:00
|
|
|
|
//status_change_map_[HG_EVT_SCREW_DETECTION] = &Scanner::status_change_screw_detection;
|
|
|
|
|
//status_change_map_[HG_EVT_NORES] = &Scanner::status_change_screw_detection;
|
2024-02-22 06:05:17 +00:00
|
|
|
|
|
|
|
|
|
event_2_hg_map_[HG_EVT_PAPER_NOT_STANDBY] = (int)HG_ScannerStatus::NO_FEED;
|
|
|
|
|
event_2_hg_map_[HG_EVT_JAM_OUT] = (int)HG_ScannerStatus::PAPER_JAM;
|
|
|
|
|
event_2_hg_map_[HG_EVT_JAM_IN] = (int)HG_ScannerStatus::FEED_IN_ERROR;
|
|
|
|
|
event_2_hg_map_[HG_EVT_COVER_OPENED] = (int)HG_ScannerStatus::OPEN_COVER;
|
|
|
|
|
event_2_hg_map_[HG_EVT_ERROR_DOUBLEPAPER] = (int)HG_ScannerStatus::DETECT_DOUBLE_FEED;
|
|
|
|
|
event_2_hg_map_[HG_EVT_STOP_SCAN] = (int)HG_ScannerStatus::STOP_SCAN;
|
|
|
|
|
event_2_hg_map_[HG_EVT_STOP_SCAN_EMERGENCY] = (int)HG_ScannerStatus::STOP_SCAN;
|
2024-02-23 07:29:14 +00:00
|
|
|
|
event_2_hg_map_[HG_EVT_SCREW_DETECTION] = (int)HG_ScannerStatus::PAPER_SKEW;
|
2024-02-22 06:05:17 +00:00
|
|
|
|
}
|
|
|
|
|
FsmState* Scanner::status_change_standby()
|
|
|
|
|
{
|
2024-02-23 07:29:14 +00:00
|
|
|
|
return FsmStateManagerEx<NoPaperState>::GetState();
|
2024-02-22 06:05:17 +00:00
|
|
|
|
}
|
|
|
|
|
FsmState *Scanner::status_change_paper_ready()
|
|
|
|
|
{
|
|
|
|
|
return FsmStateManagerEx<PaperReadyState>::GetState();
|
|
|
|
|
}
|
|
|
|
|
FsmState* Scanner::status_change_scanning()
|
|
|
|
|
{
|
|
|
|
|
return FsmStateManagerEx<ScanningState>::GetState();
|
|
|
|
|
}
|
|
|
|
|
FsmState* Scanner::status_change_paperjam()
|
|
|
|
|
{
|
|
|
|
|
return FsmStateManagerEx<ErrorJamState>::GetState();
|
|
|
|
|
}
|
|
|
|
|
FsmState* Scanner::status_change_feed_in_error()
|
|
|
|
|
{
|
|
|
|
|
return FsmStateManagerEx<ErrorState>::GetState();
|
|
|
|
|
}
|
|
|
|
|
FsmState* Scanner::status_change_double_paper()
|
|
|
|
|
{
|
|
|
|
|
SetIsDoublePaper(true);//现在还有用吗? 先放着
|
|
|
|
|
return FsmStateManagerEx<Double_Paper_State>::GetState();
|
|
|
|
|
}
|
|
|
|
|
FsmState* Scanner::status_change_open_cover()
|
|
|
|
|
{
|
|
|
|
|
return FsmStateManagerEx<CoverOpenState>::GetState();
|
|
|
|
|
}
|
|
|
|
|
FsmState* Scanner::status_change_close_cover()
|
|
|
|
|
{
|
|
|
|
|
return FsmStateManagerEx<CoverCloseState>::GetState();
|
|
|
|
|
}
|
|
|
|
|
FsmState* Scanner::status_change_stop_scan()
|
|
|
|
|
{
|
|
|
|
|
return FsmStateManagerEx<StopScanState>::GetState();
|
|
|
|
|
}
|
|
|
|
|
FsmState* Scanner::status_change_emergency_stop_scan()
|
|
|
|
|
{
|
|
|
|
|
return FsmStateManagerEx<EmergencyStopScanState>::GetState();
|
|
|
|
|
}
|
2024-02-23 07:29:14 +00:00
|
|
|
|
FsmState* Scanner::status_change_screw_detection()
|
|
|
|
|
{
|
|
|
|
|
return FsmStateManagerEx<ScrewDetectionState>::GetState();
|
|
|
|
|
}
|
|
|
|
|
FsmState* Scanner::status_change_init_status()
|
|
|
|
|
{
|
|
|
|
|
return FsmStateManagerEx<InitState>::GetState();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2024-02-22 06:05:17 +00:00
|
|
|
|
|
|
|
|
|
FsmState *Scanner::test(ScanEvent e)
|
|
|
|
|
{
|
|
|
|
|
printf("插入事件 000 ID:%d\r\n",e);
|
|
|
|
|
if (status_change_map_.count(e) > 0)
|
|
|
|
|
{
|
|
|
|
|
FsmState *fsm = (this->*status_change_map_[e])();
|
2024-02-23 07:29:14 +00:00
|
|
|
|
//printf("当前状态事件:%s\r\n",typeid(*fsm).name());
|
2024-02-22 06:05:17 +00:00
|
|
|
|
|
|
|
|
|
return fsm;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return FsmStateManagerEx<InitState>::GetState();
|
|
|
|
|
}
|