From e964c601489b1b1fb10b71d50181761727e699c5 Mon Sep 17 00:00:00 2001 From: masayume <1936714878@qq.com> Date: Wed, 10 Aug 2022 11:10:20 +0800 Subject: [PATCH] =?UTF-8?q?=E8=B0=83=E6=95=B4usb=20readbulk=E8=B6=85?= =?UTF-8?q?=E6=97=B6=E6=97=B6=E9=97=B4=20=E5=A2=9E=E5=8A=A0=E5=9B=BA?= =?UTF-8?q?=E4=BB=B6=E5=85=BC=E5=AE=B9=E6=80=A7?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- changelog.txt | 8 +- huagao/CImageProcPage.cpp | 20 +- huagao/CImageProcPage.h | 1 + huagao/Device/GScan439Android.cpp | 605 ++++++++++++++++++++++ huagao/Device/GScan439Android.h | 76 +++ huagao/Device/GScanO200.cpp | 3 +- huagao/Device/GScanO400.cpp | 10 +- huagao/Device/IConfig.h | 12 +- huagao/Device/ImageMatQueue.cpp | 2 +- huagao/Device/PublicFunc.h | 1 + huagao/Device/UsbScanEx.cpp | 24 +- huagao/Device/filetools.h | 2 +- huagao/ImageProcess/ImageApplyOutHole.cpp | 37 +- huagao/ImageProcess/ImageApplyOutHole.h | 20 +- huagao/huagaods.cpp | 41 +- huagao/huagaotwds.rc | Bin 50874 -> 50828 bytes huagao/stdafx.h | Bin 25534 -> 25538 bytes 17 files changed, 810 insertions(+), 52 deletions(-) create mode 100644 huagao/Device/GScan439Android.cpp create mode 100644 huagao/Device/GScan439Android.h diff --git a/changelog.txt b/changelog.txt index 9bbe0d3f..726674f5 100644 --- a/changelog.txt +++ b/changelog.txt @@ -55,4 +55,10 @@ 13.添加画质优先与速度优先模式 14.调整互斥锁，不同设备能在同一台pc上使用 15.调整速度优先600 dpi 按照真实300dpi 缩放 - 16.协议问题排查 \ No newline at end of file + 16.协议问题排查 + 17.完成安卓3399适配 + 18.取消UI置顶 +2020年8月10日 + 版本：3.3.5.9 + 1.调整usb通信，加长readbulk超时时间 + 2.屏蔽3288 自适应幅面功能 \ No newline at end of file diff --git a/huagao/CImageProcPage.cpp b/huagao/CImageProcPage.cpp index 487e96d7..f9ffd43a 100644 --- a/huagao/CImageProcPage.cpp +++ b/huagao/CImageProcPage.cpp @@ -59,6 +59,7 @@ CImageProcPage::~CImageProcPage() void CImageProcPage::ImageProcPageUpdate(int val,int twss, int cmduplexsel,bool is_Crop,int dpi) { + this->colormode_index = val; this->dpi = dpi; this->twss = twss; this->cmduplexsel = cmduplexsel; @@ -88,6 +89,7 @@ void CImageProcPage::ImageProcPageUpdate(int val,int twss, int cmduplexsel,bool GetDlgItem(IDC_CHMULTIPUT)->EnableWindow(TRUE); GetDlgItem(IDC_CMBMULTIOUT)->EnableWindow(((CButton*)GetDlgItem(IDC_CHMULTIPUT))->GetCheck()); } + t_chMultiOutput->EnableWindow(TRUE); } else { GetDlgItem(IDC_CKHSVCORRECT)->EnableWindow(FALSE); @@ -98,21 +100,22 @@ void CImageProcPage::ImageProcPageUpdate(int val,int twss, int cmduplexsel,bool ((CButton*)GetDlgItem(IDC_CHMULTIPUT))->SetCheck(FALSE); GetDlgItem(IDC_CMBMULTIOUT)->EnableWindow(FALSE); ((CButton*)GetDlgItem(IDC_CMBMULTIOUT))->SetCheck(FALSE); + t_chMultiOutput->SetCheck(FALSE); + t_chMultiOutput->EnableWindow(FALSE); } if (0 == val||val==3)//彩色 { m_temp->SetCurSel(0); m_temp->EnableWindow(FALSE); //t_chMultiOutput->SetCheck(TRUE); - t_chMultiOutput->EnableWindow(TRUE); } else { m_temp->EnableWindow(TRUE); - t_chMultiOutput->SetCheck(FALSE); - t_chMultiOutput->EnableWindow(FALSE); GetDlgItem(IDC_CKBACKGROUNDSMOOTH)->EnableWindow(FALSE); } + + if (val == 2) { ((CButton*)GetDlgItem(IDC_CHECKDETACHNOISE))->EnableWindow(true); @@ -234,8 +237,10 @@ void CImageProcPage::SetMultiOutputEnable(int pixtype, bool enable) switch (pixtype) { case 2://彩色 - ((CButton*)GetDlgItem(IDC_CKMULTIOUTPUT))->SetCheck(enable); - ((CButton*)GetDlgItem(IDC_CKMULTIOUTPUT))->EnableWindow(TRUE); + if (colormode_index == 0) { + ((CButton*)GetDlgItem(IDC_CKMULTIOUTPUT))->SetCheck(enable); + ((CButton*)GetDlgItem(IDC_CKMULTIOUTPUT))->EnableWindow(TRUE); + } break; case 0://灰度 黑白 case 1: @@ -350,7 +355,10 @@ void CImageProcPage::OnBnClickedChmultiput() { GetDlgItem(IDC_CMBMULTIOUT)->EnableWindow(FALSE); ((CComboBox*)GetDlgItem(IDC_CMBMULTIOUT))->SetCurSel(0); - GetDlgItem(IDC_CKMULTIOUTPUT)->EnableWindow(TRUE); + if (colormode_index == 0) + { + GetDlgItem(IDC_CKMULTIOUTPUT)->EnableWindow(TRUE); + } } } diff --git a/huagao/CImageProcPage.h b/huagao/CImageProcPage.h index 3c216689..eecd65f6 100644 --- a/huagao/CImageProcPage.h +++ b/huagao/CImageProcPage.h @@ -42,6 +42,7 @@ public: int twss; int cmduplexsel; int dpi; + int colormode_index; bool is_convex; bool is_crop; bool is_bw; diff --git a/huagao/Device/GScan439Android.cpp b/huagao/Device/GScan439Android.cpp new file mode 100644 index 00000000..37ff72ba --- /dev/null +++ b/huagao/Device/GScan439Android.cpp @@ -0,0 +1,605 @@ +#include "GScan439Android.h" +#include "IUsb.h" +#include "UsbScanEx.h" +#include + +using namespace std; +static std::mutex mx_ctrl; + +#define m_max(a, b) (((a) > (b)) ? (a) : (b)) +#define m_min(a, b) (((a) < (b)) ? (a) : (b)) + +static int read_reg(std::shared_ptr& usb, int addr) +{ + std::lock_guard lck(mx_ctrl); + std::this_thread::sleep_for(std::chrono::milliseconds(50)); + if (usb.get() && usb->is_connected()) { + int val = 0; + usb->control_msg(0xc0, USB_REQ_GET_DEV_REGS, addr, 0, 4, &val); + return val; + } + else + FileTools::writelog(log_ERROR, " read_reg error usb disconnect"); + return 0; +} + +static void write_reg(std::shared_ptr& usb, int addr, int val) +{ + std::lock_guard lck(mx_ctrl); + std::this_thread::sleep_for(std::chrono::milliseconds(50)); + if (usb.get() && usb->is_connected()) + { + usb->control_msg(0x40, USB_REQ_SET_DEV_REGS, addr, 0, 4, &val); + } + else + FileTools::writelog(log_ERROR, " write_reg error usb disconnect"); +} + +static void scanner_control(std::shared_ptr& usb, int cmd) +{ + write_reg(usb, 0, cmd); +} + + +GScan439Android::GScan439Android():m_readimgpool(1) +{ + im_data.reset(new std::vector()); + m_status = -1; + m_pImages.reset(new ImageMatQueue()); +} + +GScan439Android::~GScan439Android() +{ + if (m_usbthread.get() && m_usbthread->joinable()) + { + b_usbthread = false; + m_usbthread->join(); + m_usbthread.reset(); + } + + imgs.ShutDown(); + + m_imagedata.ShutDown(); +} + +void GScan439Android::open(int vid, int pid) +{ + if (m_usb.get() && m_usb->is_connected()) + return; + auto lsusb = UsbScan_List::find_vid_pid(vid, pid); + if (!lsusb.empty()) + { + m_usb = *lsusb.begin(); + m_usb->open(); + if (m_usb->is_open()) + m_usb->set_usbhotplug_callback(usbhotplug_callback, this); + } +} + +void GScan439Android::regist_deviceevent_callback(deviceevent_callback callback, void* usrdata) +{ + huagods = usrdata; + dev_callback = callback; +} + +void GScan439Android::DogEar_callback(std::function fun) +{ +} + +int GScan439Android::aquire_bmpdata(std::vector& bmpdata) +{ + FileTools::writelog(log_lv::log_DEBUG, " aquire_bmpdata start"); + StopWatch sw; + while (true) + { + if (m_pImages->empty()) { + DoEvents(); + std::this_thread::sleep_for(std::chrono::milliseconds(10)); + if (sw.elapsed_s() > 30.00) + { + if (m_usbthread.get() && m_usbthread->joinable()) { + m_status = DEV_STOP; + m_usbthread->join(); + m_usbthread.reset(); + } + Stop_scan();//ֹͣɨ�� + ResetScanner(); + auto rollernew = Get_Roller_num(); + set_scannum(abs(rollernew - roller_num)); + FileTools::writelog(log_lv::log_DEBUG, " aquire_bmpdata timeout"); + return HARDWARE_ERROR; + } + + if (!is_scan()) { + auto rollernew = Get_Roller_num(); + set_scannum(abs(rollernew - roller_num)); + FileTools::writelog(log_lv::log_DEBUG, " aquire_bmpdata stop"); + if (m_status == DEV_WRONG) { + return get_ErrorCode(); + } + return -1; + } + } + else { + if (m_pImages->valid()) { + bmpdata = *(m_pImages->popBmpdata()); + UpdateScanInfo(get_imgnReaded(), countNTransfered()); + FileTools::writelog(log_lv::log_DEBUG, " aquire_bmpdata quit"); + return 0; + } + DoEvents(); + std::this_thread::sleep_for(std::chrono::milliseconds(2)); + } + } +} + +BOOL GScan439Android::IsConnected() +{ + return m_usb.get() && m_usb->is_connected(); +} + +std::string GScan439Android::GetFWVersion() +{ + static std::string fw;// = "12312312"; + if (m_usb.get() && m_usb->is_connected() && fw.empty()) + { + write_reg(m_usb, SR_GET_FWVERSION, 0); + fw.resize(512); + m_usb->read_bulk(&fw[0], 512); + //read_data(&fw[0], fw.length(), 100); + } + return fw; +} + +std::string GScan439Android::GetSerialNum() +{ + static std::string sn;// = "12333123123123"; + if (m_usb.get() && m_usb->is_connected() && sn.empty()) + { + write_reg(m_usb, SR_GET_SERIALNUM, 0); + sn.resize(512); + m_usb->read_bulk(&sn[0], 512); + //read_data(&sn[0], sn.length(), 100); + } + return sn; +} + +std::string GScan439Android::GetMacAdder() +{ + return std::string(); +} + +std::uint32_t GScan439Android::GetMotorFPGA() +{ + return std::uint32_t(); +} + +std::uint32_t GScan439Android::GetScanFPGA() +{ + return std::uint32_t(); +} + +bool GScan439Android::is_scan() +{ + return m_status == DEV_ISRUNNING || (m_imagedata.Size() > 0); +} + +BOOL GScan439Android::Get_Scanner_PaperOn() +{ + return read_reg(m_usb, SR_GET_PAPERON); +} + +int GScan439Android::Get_Roller_num() +{ + return read_reg(m_usb, SR_GET_ROLLER_NUM); +} + +void GScan439Android::config_params(GScanCap& param) +{ + m_param = param; + HGScanConfig cfg; + cfg.value = 0; + + PaperStatus ps = { param.papertype,param.paperAlign }; + cfg.g200params.paper = SupPaperTyps.count(ps) > 0 ? SupPaperTyps[ps] : 0; + if (param.filter != 3 || param.enhance_color != 0 || param.hsvcorrect) + cfg.g200params.color = 1;//color + else + { + cfg.g200params.color = SupPixelTypes.count(param.pixtype) > 0 ? SupPixelTypes[param.pixtype] : 2; + + } + cfg.g200params.dpi = param.resolution_dst >=300 ? 2 : 1;// SupResolutions.count(param.resolution_native) > 0 ? SupResolutions[param.resolution_native] : 1; + param.resolution_native = param.resolution_dst >= 300 ? 300 : 200; + cfg.g200params.double_feed_enbale = (unsigned int)param.hardwarecaps.en_doublefeed; + //cfg.g200params.stable_enbale = 0; + cfg.g200params.stable_enbale = (unsigned int)param.hardwarecaps.en_stapledetect; + cfg.g200params.screw_detect_enable = (unsigned int)param.hardwarecaps.en_skrewdetect; + cfg.g200params.screw_detect_level = (unsigned int)cfg.g200params.screw_detect_enable ? secrewMaps[param.hardwarecaps.skrewdetectlevel] : 0; + + cfg.g200params.enable_sizecheck = param.en_sizecheck == 1 ? 1 : 0; + + write_reg(m_usb, SR_CONFIG_SCAN_PARAM, cfg.value); + m_pImages->setparam(param); +} + +void GScan439Android::Scanner_StartScan(UINT16 count) +{ + error_index = 0; + roller_num = read_reg(m_usb, SR_GET_ROLLER_NUM); + + Set_ErrorCode(0); + getimgnum = 0; + aquirenum = 0; + imagecount = 0; + reset(); + m_status = DEV_ISRUNNING; + //if (read_reg(m_usb, SR_GET_SLEEP_STAUTUS) != 1) + //{ + // m_status = DEV_WRONG; + // Set_ErrorCode(SLEEPING); + // scanflag = false; + // return; + //} + + if (!Get_Scanner_PaperOn()) + { + m_status = DEV_WRONG; + Set_ErrorCode(NO_FEED); + scanflag = false; + return; + } + int state = read_reg(m_usb, SR_GET_ANDROID_STATE); + if (state != 0) + { + if (state == 1) Set_ErrorCode(OPEN_COVER); + else if (state == 2) Set_ErrorCode(PAPER_JAM); + else if (state == 3) Set_ErrorCode(NO_FEED); + else Set_ErrorCode(HARDWARE_ERROR); + scanflag = false; + m_status = DEV_WRONG; + return; + } + write_reg(m_usb, 0x1000, m_param.is_duplex ? m_param.scannum /2 : m_param.scannum); + scanner_control(m_usb, SC_START); + + + if (!m_usbthread.get()) { + b_usbthread = true; + m_usbthread.reset(new thread(&GScan439Android::usbmainloop, this)); + } + m_pImages->setscanflags(true); + m_pImages->run(); +} + +void GScan439Android::Stop_scan() +{ + scanner_control(m_usb, SC_STOP); + if ((m_status == DEV_WRONG) || (m_status == DEV_STOP)) + return; + m_status = DEV_STOP; +} + +int GScan439Android::notifyscan() +{ + return 1; +} + +void GScan439Android::ResetScanner() +{ +} + +bool GScan439Android::Get_IsImageQueueEmpty() +{ + return m_pImages->empty() && m_status == DEV_STOP; +} + +void GScan439Android::reset() +{ + m_status = DEV_STOP; + m_pImages->clear(); + //scanner_control(m_usb, SC_INIT); +} + +void GScan439Android::clear_hwerror() +{ + //scanner_control(m_usb, SC_INIT); +} + +UINT32 GScan439Android::get_ErrorCode() +{ + return Error_Code; +} + +void GScan439Android::Set_ErrorCode(UINT32 value) +{ + Error_Code = value; +} + +int GScan439Android::get_scanned_num() +{ + return 0; +} + +void GScan439Android::set_sleep_time(int mode) +{ +} + +bool GScan439Android::set_scannercode(std::string str) +{ + return false; +} + +std::string GScan439Android::get_scannercode() +{ + return std::string(); +} + + +void GScan439Android::usbhotplug_callback(bool isconnect, void* userdata) +{ + GScan439Android* This = (GScan439Android*)userdata; + This->usbhotplug(isconnect); +} + +void GScan439Android::usbhotplug(bool isleft) +{ + FileTools::writelog(log_ERROR, "enable usb callback "); + if (isleft) { + m_status = DEV_WRONG; + Error_Code = USB_DISCONNECTED; + m_pImages->setscanflags(false); + scanflag = false; + if (m_usb.get()) + m_usb.reset(); + if (huagods) + dev_callback(USB_DISCONNECTED, huagods); + } +} + +int GScan439Android::read_data(void* data, int length, int timeout) +{ + if (!m_usb.get() && !m_usb->is_connected()) + { + FileTools::writelog(log_INFO, "if (!m_usb.get() && !m_usb->is_connected())"); + return 0; + } + timeout = std::max(1000, timeout); + + int readed = 0; + int reading = 0; + const int buffer_size = 512 * 1024; + StopWatch sw; + FileTools::writelog(log_INFO, "read_data timeout =" + to_string(timeout)); + while (readed < length) { + if (sw.elapsed_ms() < timeout && m_usb.get()) + { + reading = std::max(0, std::min(length - readed, buffer_size)); + reading = m_usb->read_bulk((unsigned char*)data + readed, reading); + if (reading > 0) { + readed += reading; + sw.reset(); + } + } + else + { + FileTools::writelog(log_INFO, "read usb image data time out ,time = " + std::to_string(sw.elapsed_ms())); + break; + } + } + return readed; +} + +void GScan439Android::usbmainloop() +{ + unsigned char buff[32]; + while (b_usbthread) + { + if (!m_usb.get() || !m_usb->is_connected()) + { + this_thread::sleep_for(chrono::milliseconds(20)); + continue; + } + memset(buff, 0, sizeof(buff)); + auto length = m_usb->read_int(buff, sizeof(buff)); + if (((length) == sizeof(buff)))//|| im_dev_count() + { + HGEIntInfo info = *(HGEIntInfo*)&buff; + if (codeconvter(info) > 0 && get_ErrorCode() == 0) + { + Set_ErrorCode(codeconvter(info)); + } + if (codeconvter(info) == -1) + { + m_readimgpool.enqueue([this] { + StopWatch stoptime; + while (stoptime.elapsed_s() < 3) { + if (read_reg(m_usb, SR_IM_COUNT) > 0) + { + readimg(); + stoptime.reset(); + } + this_thread::sleep_for(chrono::milliseconds(200)); + } + m_status = get_ErrorCode() == 0 ? DEV_STOP : DEV_WRONG; + m_pImages->setscanflags(false); }); + } + switch (info.From) + { + case IMG: + m_readimgpool.enqueue([this] { + if (read_reg(m_usb, SR_IM_COUNT) > 0) + readimg(); + }); + break; + case MtBoard: + FileTools::writelog(log_ERROR, "Got MotorBoard error code = " + to_string(info.Code)); + break; + case FPGA: + FileTools::writelog(log_ERROR, "Got FPGA Error code = " + to_string(info.Code)); + break; + case V4L2: + FileTools::writelog(log_ERROR, "Got V4L2 Error code = " + to_string(info.Code)); + scanner_control(m_usb, SC_STOP); + break; + case STOPSCAN: + FileTools::writelog(log_INFO, "StopScan"); + break; + default: + FileTools::writelog(log_ERROR, "Got Unkown error code ! From =" + to_string(info.From) + " Code = " + to_string(info.Code)); + break; + } + //this_thread::sleep_for(chrono::microseconds(10)); + } + + } +} + +void GScan439Android::readimg() +{ + if (read_reg(m_usb, SR_IM_TXING)) + { + FileTools::writelog(log_ERROR, "Read image TXING"); + return; + } + + + if (read_reg(m_usb, SR_IM_COUNT) > 0 && getStatus()) + { + unsigned int len = read_reg(m_usb, SR_IM_FRONT_SIZE); + if (len > 0) + { + write_reg(m_usb, SR_IM_TX, 1); + im_data->resize(len); + static int indeximg = 0; + auto nreaded = tranxferimg(len, im_data); + if (nreaded == len) + { + m_pImages->pushMat(std::shared_ptr(new G400Decode(im_data))); + this_thread::sleep_for(chrono::milliseconds(10)); + write_reg(m_usb, SR_IM_POP, 1); + FileTools::writelog(log_ERROR, "Enqueue image " + to_string(++indeximg) + "size " + to_string(nreaded)); + UpdateScanInfo(countNReaded(), get_imgTransfered()); + } + else + { + FileTools::writelog(log_ERROR, "error :read image data len error"); + } + } + else + FileTools::writelog(log_ERROR, "error :Get front image data len ZERO" ); + } + else + FileTools::writelog(log_ERROR, "image queue empty or not scanning" ); +} + + +int GScan439Android::tranxferimg(unsigned int datalen, std::shared_ptr> data) +{ + unsigned int timeout = 3000; + unsigned int readed = 0; + unsigned int reading = 0; + const int buffer_size = 512 * 1024; + StopWatch sw; + while (readed < datalen) + { + if (sw.elapsed_ms() < timeout && m_usb.get()) + { + reading = m_max(0, m_min(datalen - readed, buffer_size)); + reading = m_usb->read_bulk((unsigned char*)data->data() + readed, reading); + if (reading > 0) + { + readed += reading; + sw.reset(); + } + else + FileTools::writelog(log_ERROR, "Read Image size zero"); + } + else + { + FileTools::writelog(log_ERROR, "Read Image timeout" ); + break; + } + } + return readed; +} + + + +int GScan439Android::codeconvter(HGEIntInfo code) +{ + if (code.From == HGType::FPGA) + { + switch (code.Code) + { + default: + break; + } + } + if (code.From == HGType::MtBoard) + { + switch (code.Code) + { + case 0x00002: + return NO_FEED; + case 0x00004: + return OPEN_COVER; + case 0x00008: + return FEED_IN_ERROR; + case 0x00010: + return PAPER_JAM; + case 0x00020: + return DETECT_DOUBLE_FEED; + case 0x00040: + return DETECT_STAPLE; + case 0x00080: + return PAPER_SKEW; + case 0x10000: + return AQUIRE_IMAGE_TIMEOUT; + case 0x20000: + return SIZE_ERROR; + case 0x40000: + return PAPER_HOLE; + case 0x80000: + return MLTOP_TIMEOUT; + default: + break; + } + } + if (code.From == HGType::V4L2) + { + switch (code.Code) + { + case 0: + return V4L2_AQULRE_ERROR; + case 1: + return V4L2_IMAGE_EMPTY; + default: + break; + } + } + + if (code.From == HGType::STOPSCAN) + { + switch (code.Code) + { + case 0: + return -1; + case 1: + if (m_status == DEV_ISRUNNING) + m_status = DEV_STOP; + return 0; + default: + break; + } + } + return 0; +} + +bool GScan439Android::getStatus() +{ + return 1; + int val = read_reg(m_usb, SR_STATUS) & 0x3; + bool ret = (val > 0) && (val < 4); + return ret; +} diff --git a/huagao/Device/GScan439Android.h b/huagao/Device/GScan439Android.h new file mode 100644 index 00000000..099b6fd3 --- /dev/null +++ b/huagao/Device/GScan439Android.h @@ -0,0 +1,76 @@ +#pragma once +#include "stdafx.h" +#include "GScan.h" +#include "IConfig.h" +#include "G400ScanConfig.h" +#include +#include +#include +#include "ThreadPool.h" +#include "StopWatch.h" +#include "ImageMatQueue.h" +#include "opencv2/opencv.hpp" + +class GScan439Android : + public IScanner +{ +public: + GScan439Android(); + virtual ~GScan439Android(); + virtual void open(int vid, int pid) override; + virtual void regist_deviceevent_callback(deviceevent_callback callback, void* usrdata = 0) override; + virtual void DogEar_callback(std::function fun) override; + virtual int aquire_bmpdata(std::vector& bmpdata) override; + virtual BOOL IsConnected() override; + virtual std::string GetFWVersion() override; + virtual std::string GetSerialNum() override; + virtual std::string GetMacAdder() override; + virtual std::uint32_t GetMotorFPGA() override; + virtual std::uint32_t GetScanFPGA() override; + virtual bool is_scan() override; + virtual BOOL Get_Scanner_PaperOn() override; + virtual int Get_Roller_num() override; + virtual void config_params(GScanCap& param) override; + virtual void Scanner_StartScan(UINT16 count) override; + virtual void Stop_scan() override; + virtual int notifyscan() override; + virtual void ResetScanner() override; + virtual bool Get_IsImageQueueEmpty() override; + virtual void reset() override; + virtual void clear_hwerror() override; + virtual UINT32 get_ErrorCode() override; + virtual void Set_ErrorCode(UINT32 value) override; + virtual int get_scanned_num() override; + virtual void set_sleep_time(int mode) override; + virtual bool set_scannercode(std::string str) override; + virtual std::string get_scannercode() override; + +private: + static void usbhotplug_callback(bool isconnect, void* userdata); + void usbhotplug(bool isleft); + int read_data(void* data, int length, int timeout); + void usbmainloop(); + void readimg(); + int tranxferimg(unsigned int datalen, std::shared_ptr> data); + int codeconvter(HGEIntInfo code); + bool getStatus(); +private: + volatile int Error_Code; + volatile bool scanflag; + std::atomic_int imagecount; + int aquirenum = 0; + int getimgnum = 0; + GScanCap m_param; + std::shared_ptr m_usb; + volatile bool b_imgprothread; + volatile bool b_usbthread; + volatile int m_status; + + ThreadPool m_readimgpool; + BlockingQueue>> imgs; + std::shared_ptr m_usbthread; + std::shared_ptr> im_data; + BlockingQueue>> m_imagedata; + deviceevent_callback dev_callback; + void* huagods; +}; diff --git a/huagao/Device/GScanO200.cpp b/huagao/Device/GScanO200.cpp index a1db8cd6..6e1bd5ff 100644 --- a/huagao/Device/GScanO200.cpp +++ b/huagao/Device/GScanO200.cpp @@ -440,7 +440,8 @@ void GScanO200::Scanner_StartScan(UINT16 count) // return; // } //#endif // !G200 - m_pImages->reset_DogEar(); + + m_pImages->reset_DogEar(); if (gcap.is_duplex) count = count == 65535 ? 65535 : count / 2; USBCB usbcb = { START_COMMAND,(UINT32)count ,0 }; diff --git a/huagao/Device/GScanO400.cpp b/huagao/Device/GScanO400.cpp index c7e2685f..f0da883d 100644 --- a/huagao/Device/GScanO400.cpp +++ b/huagao/Device/GScanO400.cpp @@ -371,11 +371,11 @@ void GScanO400::config_params(GScanCap& params) G400ScanConfig cfg = G400ScanConfig(params); UINT32 cfgdata = cfg.GetData(); auto fw = GetFWVersion(); - if (atoi(fw.substr(4, 6).c_str()) >= 220117) - { - if (params.papertype == 52 || params.papertype == 54 || params.papertype == 131 || params.papertype == 0) - cfgdata = (cfgdata & 0xffffffe0) + 18; - } + //if (atoi(fw.substr(4, 6).c_str()) >= 220117) + //{ + // if (params.papertype == 52 || params.papertype == 54 || params.papertype == 131 || params.papertype == 0) + // cfgdata = (cfgdata & 0xffffffe0) + 18; + //} #ifdef G400 if (atoi(fw.substr(4, 6).c_str()) >= 220117) { diff --git a/huagao/Device/IConfig.h b/huagao/Device/IConfig.h index d1bc4d26..1dd4a7a9 100644 --- a/huagao/Device/IConfig.h +++ b/huagao/Device/IConfig.h @@ -190,6 +190,13 @@ enum Scanner_Reg_Defs SR_SET_JSON, SR_GET_FILE_POS, SR_SET_FILE_POS, + SR_NOTIFY_SLEEP, + SR_GET_FEEDMODE, + SR_SET_FEEDMODE, + SR_GET_AUTOMATICCONTROLFEEDMODE_ENABLE, + SR_SET_AUTOMATICCONTROLFEEDMODE_ENABLE, + SR_GET_AUTOMATICCONTROLFEEDMODE_THRESHOLD, + SR_SET_AUTOMATICCONTROLFEEDMODE_THRESHOLD, SR_GET_CUO_ERROR = 0x50, SR_GET_DOU_ERROR, SR_GET_JAM_ERROR, @@ -227,7 +234,10 @@ enum Scanner_Reg_Defs SR_GET_MBVERSION_LENGHT, SR_GET_MBVERSION, SR_GET_USBVIDPID, - SR_SET_USBVIDPID + SR_SET_USBVIDPID, + SR_SET_ANDROID_SCANCOUNT = 0x1000, + SR_GET_ANDROID_STATE = 0x1001, + }; enum Scanner_Cmd_Defs diff --git a/huagao/Device/ImageMatQueue.cpp b/huagao/Device/ImageMatQueue.cpp index fcc0a91e..35d572e2 100644 --- a/huagao/Device/ImageMatQueue.cpp +++ b/huagao/Device/ImageMatQueue.cpp @@ -167,7 +167,7 @@ void ImageMatQueue::setparam(const GScanCap& param) if (scanParam.fillhole.is_fillhole && scanParam.resolution_dst < 500) { float ratio = scanParam.fillhole.fillholeratio / 100.0; - m_iaList.push_back(shared_ptr(new CImageApplyOutHole(200, ratio, 50))); + m_iaList.push_back(shared_ptr(new CImageApplyOutHole(25, ratio, 40))); } //确保能够获取正反两面图 diff --git a/huagao/Device/PublicFunc.h b/huagao/Device/PublicFunc.h index 889e3669..9f85b24e 100644 --- a/huagao/Device/PublicFunc.h +++ b/huagao/Device/PublicFunc.h @@ -359,6 +359,7 @@ struct GScanCap_3399 uint32_t dogeardistabce; /**< ۽Ǽ۶㵽ʵ¾>*/ bool fadeback; /**< ɫ>*/ int fadebackrange; /**< ɫΧ>*/ + bool isuploadexceptionimage; /**< Ƿϴ˫ű쳣ͼ>*/ uint32_t reserve[1024]; /**< Ԥ4096ֽЭչ*/ }; diff --git a/huagao/Device/UsbScanEx.cpp b/huagao/Device/UsbScanEx.cpp index 53eae3b8..340b781b 100644 --- a/huagao/Device/UsbScanEx.cpp +++ b/huagao/Device/UsbScanEx.cpp @@ -3,8 +3,8 @@ #include #include -//#ifdef ANDROIDSERIAL -#if false +#ifdef ANDROIDSERIAL + UsbScanEx::UsbScanEx(int index) { @@ -30,9 +30,9 @@ bool UsbScanEx::open() //ut.TimeoutEvent = 1; //ut.TimeoutRead = 1; //ut.TimeoutWrite = 1; - ut.TimeoutEvent = 0; - ut.TimeoutRead = 0; - ut.TimeoutWrite = 0; + ut.TimeoutEvent = 1; + ut.TimeoutRead = 2; + ut.TimeoutWrite = 3; _stprintf(szDevPath, TEXT("\\\\.\\Usbscan%d"), m_h_index); m_h_dev = CreateFile(szDevPath, @@ -79,7 +79,6 @@ bool UsbScanEx::open() CloseHandle(m_h_dev); m_h_dev = INVALID_HANDLE_VALUE; } - //FileTools::writelog(log_lv::log_INFO,"USB Open!"); return m_h_dev; } @@ -115,7 +114,6 @@ bool UsbScanEx::close() } } m_b_is_connected = FALSE; - //FileTools::writelog(log_lv::log_INFO,"USB Close!"); return b_ret; } @@ -201,7 +199,7 @@ int UsbScanEx::control_msg(int rtype, int req, int value, int index, int len, vo LPOVERLAPPED lp_overlap = ov + CTRL_IN_OUT; b_ret = DeviceIoControl(m_h_dev, IOCTL_SEND_USB_REQUEST, &irp, sizeof(irp), data, len, &dw_ret, NULL); - + FileTools::writelog(log_ERROR, " USB control_msg ret = " + std::to_string(b_ret)); //if (!b_ret) // b_ret = WaitForSingleObject(lp_overlap->hEvent, timeout) == WAIT_OBJECT_0; @@ -234,7 +232,8 @@ int UsbScanEx::read_int(void* data, int len) return dw_ret; } else { - switch (GetLastError()) + int error_code = GetLastError(); + switch (error_code) { case ERROR_FILE_NOT_FOUND: case ERROR_ACCESS_DENIED: @@ -244,7 +243,7 @@ int UsbScanEx::read_int(void* data, int len) } break; default: - break; + break; } } @@ -393,7 +392,6 @@ bool UsbScanEx::open() CloseHandle(m_h_dev); m_h_dev = INVALID_HANDLE_VALUE; } - //FileTools::writelog(log_lv::log_INFO,"USB Open!"); return m_h_dev; } @@ -446,7 +444,6 @@ bool UsbScanEx::close() } } m_b_is_connected = FALSE; - //FileTools::writelog(log_lv::log_INFO,"USB Close!"); return b_ret; } @@ -481,7 +478,7 @@ int UsbScanEx::read_bulk(void* data, int len) #ifdef ANDROIDSERIAL GetOverlappedResult(h_pipe, lp_overlap, &pdw_ret, TRUE); #else - WaitForSingleObject(lp_overlap->hEvent, 500); + WaitForSingleObject(lp_overlap->hEvent, 1000); GetOverlappedResult(h_pipe, lp_overlap, &pdw_ret, FALSE); #endif // ANDROIDSERIAL return pdw_ret; @@ -489,7 +486,6 @@ int UsbScanEx::read_bulk(void* data, int len) case ERROR_FILE_NOT_FOUND: case ERROR_ACCESS_DENIED: m_b_is_connected = false; - //FileTools::writelog(log_lv::log_WARN, "errorcode =" + std::to_string(error_code)); if (hotplug_call) { hotplug_call(true, usrdata); } diff --git a/huagao/Device/filetools.h b/huagao/Device/filetools.h index 5eaa8847..a3f37cb7 100644 --- a/huagao/Device/filetools.h +++ b/huagao/Device/filetools.h @@ -60,7 +60,7 @@ public: { log4cplus::SharedAppenderPtr rf(new log4cplus::RollingFileAppender( path, - 2048 * 1024, + 1024 * 1024 * 10, 5 )); rf->setName(LOG4CPLUS_TEXT("file")); diff --git a/huagao/ImageProcess/ImageApplyOutHole.cpp b/huagao/ImageProcess/ImageApplyOutHole.cpp index d4e616c4..85c7b9cc 100644 --- a/huagao/ImageProcess/ImageApplyOutHole.cpp +++ b/huagao/ImageProcess/ImageApplyOutHole.cpp @@ -1,6 +1,10 @@ #include "ImageApplyOutHole.h" #include "ImageProcess_Public.h" +#ifdef LOG +#include "Device/filetools.h" +#endif // LOG + CImageApplyOutHole::CImageApplyOutHole(void) : CImageApply() , m_borderSize(600) @@ -29,13 +33,23 @@ void CImageApplyOutHole::apply(cv::Mat& pDib, int side) void CImageApplyOutHole::apply(std::vector& mats, bool isTwoSide) { +#ifdef LOG + FileTools::write_log("imgprc.txt", "enter ImageOutHole apply"); +#endif // LOG + if (mats.size() < 2) { +#ifdef LOG + FileTools::write_log("imgprc.txt", "exit ImageOutHole apply"); +#endif // LOG return; } if (mats[0].empty() || mats[1].empty()) { +#ifdef LOG + FileTools::write_log("imgprc.txt", "exit ImageOutHole apply"); +#endif // LOG return; } @@ -63,6 +77,9 @@ void CImageApplyOutHole::apply(std::vector& mats, bool isTwoSide) std::vector maxContour_front = hg::getMaxContour(contours_front, b1_front); std::vector maxContour_back = hg::getMaxContour(contours_back, b1_back); + if (maxContour_front.empty() || maxContour_back.empty()) + return; + cv::RotatedRect rrect_front = hg::getBoundingRect(maxContour_front); //ȡСӾ cv::RotatedRect rrect_back = hg::getBoundingRect(maxContour_back); //ȡСӾ @@ -78,19 +95,25 @@ void CImageApplyOutHole::apply(std::vector& mats, bool isTwoSide) cv::Mat roiMat_front(front_thre, roi_front); //ֵͼнȡص cv::Mat roiMat_back(back_thre, roi_back); //ڷֵͼнȡص + //cv::imwrite("roiMat_front.jpg", roiMat_front); + //cv::imwrite("roiMat_back.jpg", roiMat_back); //ֵͼ㣬ο0طΪ255 cv::Mat mask; cv::bitwise_or(roiMat_front, roiMat_back, mask); //㣬ֵͼص + //cv::imwrite("mask1.jpg", mask); //ֵͼصͼɫȡͣȡ - cv::bitwise_not(mask, mask); //ɫ + cv::bitwise_not(mask, mask); + //cv::imwrite("mask2.jpg", mask); //ɫ element = cv::getStructuringElement(cv::MORPH_ELLIPSE, cv::Size(10, 10)); cv::dilate(mask, mask, element, cv::Point(-1, -1), 1, cv::BORDER_CONSTANT, cv::Scalar(255)); //㷨׶ͨ + //cv::imwrite("mask3.jpg", mask); //Ϊ˱׶׹ᴩֽߣΪֽȷп׶ΪͼΣ뱳ճ - cv::polylines(mask, hg::getVertices(mask_rotatedRect), true, cv::Scalar(0), 15); //ֽžαԵ + cv::polylines(mask, hg::getVertices(mask_rotatedRect), true, cv::Scalar(255), 15); //ֽžαԵ + //cv::imwrite("mask4.jpg", mask); std::vector> contours_mask; std::vector b1_mask; @@ -215,7 +238,11 @@ std::vector> CImageApplyOutHole::filterPoly(std::vector areaThreshold * 6 || + rrect.size.height > areaThreshold * 6) + continue; bool enabled = true; for (size_t j = 0, count = contours[i].size(); j < count; j++) @@ -293,10 +320,10 @@ uchar CImageApplyOutHole::getBackGroudChannelMean(const cv::Mat& gray, int total hist_array[i] = hist.at(i, 0); int length = 1; - const int length_max = 255 - m_threshold; + const int length_max = 255; while (length < length_max) { - for (size_t i = m_threshold + 1; i < 256 - length; i++) + for (size_t i = 1; i < 256 - length; i++) { int count = 0; uint pixSum = 0; diff --git a/huagao/ImageProcess/ImageApplyOutHole.h b/huagao/ImageProcess/ImageApplyOutHole.h index 8d4117fb..a75779e7 100644 --- a/huagao/ImageProcess/ImageApplyOutHole.h +++ b/huagao/ImageProcess/ImageApplyOutHole.h @@ -6,12 +6,17 @@ * ʱ䣺2020/11/21 * ޸ʱ䣺2020/05/12 v1.0 * 2020/11/17 v1.1 - * 2021/09/06 v1.2 Ĭ϶ֵֵԭ50Ϊ100ɫӾֲɫȡΪȫɫȡ - * 2021/11/03 v1.3 ߼ͼߴ쳬10أֱӷأٽг״ - * 2021/11/04 v1.4 ӱƣܹ5صı - * 2021/11/17 v1.5 ʽһЩopencv汾µBUG - * 2022/04/18 v1.6 ޸ͼ񳬳߽絼µĶλ׶쳣BUG - * 汾ţv1.6 + * 2021/09/06 v1.2 Ĭ϶ֵֵԭ50Ϊ100ɫӾֲɫȡΪȫɫȡ + * 2021/11/03 v1.3 ߼ͼߴ쳬10أֱӷأٽг״ + * 2021/11/04 v1.4 ӱƣܹ5صı + * 2021/11/17 v1.5 ʽһЩopencv汾µBUG + * 2022/04/18 v1.6 ޸ͼ񳬳߽絼µĶλ׶쳣BUG + * 2022/05/04 v1.6.1 ߼жϣֺͼֱӷأԭͼκδ + * 2022/07/16 v1.6.2 ޸ԶʶɫBUG + * 2022/07/18 v1.6.3 ޸maskһЩ߼ + * 2022/07/18 v1.7 ޸߼BUG滻캯borderSize߼,ԭΪ߳崩׷ΧΪ[borderSize, borderSize * 6] + * 2022/07/22 v1.7.1 ޸ԶʶɫBUG + * 汾ţv1.7.1 * ==================================================== */ @@ -72,4 +77,5 @@ private: double m_threshold; }; -#endif // !IMAGE_APPLY_OUT_HOLE_H \ No newline at end of file +#endif // !IMAGE_APPLY_OUT_HOLE_H + diff --git a/huagao/huagaods.cpp b/huagao/huagaods.cpp index 58e120bb..9f083e52 100644 --- a/huagao/huagaods.cpp +++ b/huagao/huagaods.cpp @@ -18,6 +18,7 @@ #include "Device/GScanO400.h" #include "Device/GScanO400Android.h" #include "Device/GScanO1003399.h" +#include "Device/GScan439Android.h" #include "Device/filetools.h" #include "Device/GScanVirtual.h" #include @@ -98,7 +99,7 @@ using namespace std::placeholders; TWPP_ENTRY_MFC(HuagaoDs) static constexpr const Identity srcIdent( - Version(3, 3, Language::English, Country::China, "v3.3.5.8"), + Version(3, 3, Language::English, Country::China, "v3.3.5.9"), DataGroup::Image, #ifdef MAKEHUAGAO "HUAGO", @@ -202,8 +203,10 @@ static constexpr const Identity srcIdent( #ifdef MAKEHUAGAO #ifdef UV "HUAGOSCAN G300UV TWAIN" +#elif defined ANDROIDSERIAL + "HUAGOSCAN G300 Android TWAIN"// ݾɼ pm changed "HUAGOSCAN G300 TWAIN" #else - "HUAGOSCAN G300 TWAIN"// ݾɼ pm changed "HUAGOSCAN G300 TWAIN" + "HUAGOSCAN G300 Linux TWAIN" #endif #elif defined UV && defined MAKERIGHTWAY "RIGHTWAYSCAN G300 TWAIN" @@ -224,7 +227,11 @@ static constexpr const Identity srcIdent( #endif #elif defined(G400) // G200 #ifdef MAKEHUAGAO - "HUAGOSCAN G400 TWAIN" + #ifdef ANDROIDSERIAL + "HUAGOSCAN G400 Android TWAIN" + #else + "HUAGOSCAN G400 Linux TWAIN" + #endif // ANDROIDSERIES #elif defined HANVON #ifdef ANDROIDSERIAL "Hanvon HW-7000 TAWIN" @@ -333,6 +340,7 @@ static std::vector DeviceID{ #endif // ISG100 #elif defined G300 {0x31c9,0x8420}, + {0x31c9,0x8429}, #elif defined G400 {0x31c9,0x8520}, {0x31c9,0x8529}, @@ -396,10 +404,18 @@ static std::vector DeviceID{ #endif // ISG100 #elif defined G300 {0x3072,0x0300}, - {0x3072,0x0339}, + #ifdef ANDROIDSERIAL + {0x3072,0x0302}, + #else + {0x3072,0x0339}, + #endif // ANDROIDSERIAL #elif defined G400 {0x3072,0x0400}, - {0x3072,0x0439}, + #ifdef ANDROIDSERIAL + {0x3072,0x0402}, + #else + {0x3072,0x0439}, + #endif // ANDROIDSERIAL #endif // ISG100 }; @@ -881,6 +897,7 @@ Result HuagaoDs::capabilitySet(const Identity& origin, Capability& data) { Result HuagaoDs::eventProcess(const Identity&, Event& event) { // Qt needs to process its events, otherwise the GUI will appear frozen // this is Windows-only method, Linux and macOS behave differently + //FileTools::writelog(log_ERROR, "eventProcess " + to_string((int)event.message())); if (guiTwain) { // // QApplication::processEvents(); - TODO: needs more investigation; results in freeze when attempting to scan using old DSM // QApplication::sendPostedEvents(); @@ -983,14 +1000,18 @@ Result HuagaoDs::identityOpenDs(const Identity&) { scanner.reset(new GScanO200()); #else - if (pid == 0x339 || pid == 0x439 || pid == 0x7039 || pid == 0x8529) + if (pid == 0x339 || pid == 0x439 || pid == 0x7039 || pid == 0x8529 || pid == 0x8429) scanner.reset(new GScanO1003399()); - else + else { #ifdef ANDROIDSERIAL - scanner.reset(new GScanO400Android()); + if (pid == 0x402 || pid == 0x302) + scanner.reset(new GScan439Android()); + else + scanner.reset(new GScanO400Android()); #else - scanner.reset(new GScanO400()); + scanner.reset(new GScanO400()); #endif + } #endif // G400 break; } @@ -2816,7 +2837,7 @@ Twpp::Result HuagaoDs::showTwainUI(Twpp::UserInterface& ui, bool bUiOnly) ::GetWindowRect(static_cast(ui.parent().raw()), &newRect); if (newRect.top <= 0 || newRect.left <= 0) newRect.top = newRect.left = 20; - SetWindowPos(guiTwain->m_hWnd, HWND_TOPMOST, newRect.left + 20, newRect.top + 100, 0, 0, SWP_SHOWWINDOW | SWP_NOSIZE | SWP_NOACTIVATE); + SetWindowPos(guiTwain->m_hWnd, HWND_TOP, newRect.left + 20, newRect.top + 100, 0, 0, SWP_SHOWWINDOW | SWP_NOSIZE | SWP_NOACTIVATE); //SetWindowPos(guiTwain->m_hWnd, HWND_TOPMOST, 0, 0, 0, 0, SWP_NOSIZE); guiTwain->ShowWindow(SW_SHOWNORMAL); return success(); diff --git a/huagao/huagaotwds.rc b/huagao/huagaotwds.rc index e6504eaa0b946170bc8fec95d8767696d0d07032..8e69b3747c55e677f333ad1dbd21d48189939a45 100644 GIT binary patch delta 52 zcmdnh%iPn;yuprlQkl@^I$pJjjFyv^&NBp(it{Bmf0%cUiP3WN{)Lknfg<}Cif_(Z H9H0yU80{3n delta 53 zcmeC_W!}}xyuprlvO}`MWSKOD%>le>6B#Wgm(Md~wAj3I-g71(HF4o&MxfZlh2ooS I76&K;018GEt^fc4 diff --git a/huagao/stdafx.h b/huagao/stdafx.h index 2b2c9265794eb7410dac8a3bc2944f902acc032e..bdedce1b536979c5ef763500051044f83a1bd278 100644 GIT binary patch delta 113 zcmdmYobk|c#tkhTtR@Tw3t7E>q?mVgLXD