2020-03-11 01:58:06 +00:00
|
|
|
|
#include "stdafx.h"
|
|
|
|
|
#include "GScanO200.h"
|
|
|
|
|
#include "UsbScanEx.h"
|
|
|
|
|
#include "StopWatch.h"
|
|
|
|
|
#include "scn_config.h"
|
|
|
|
|
#include "ImageMatQueue.h"
|
2020-11-16 10:05:04 +00:00
|
|
|
|
#include "ImageProcess/ImageApplyDogEarDetection.h"
|
2020-03-11 01:58:06 +00:00
|
|
|
|
#include "filetools.h"
|
2020-05-16 01:50:34 +00:00
|
|
|
|
#include "GetMemoryUsage.h"
|
2020-03-11 01:58:06 +00:00
|
|
|
|
//u32_CMD
|
|
|
|
|
typedef enum tagUsbKeyWords : UINT32
|
|
|
|
|
{
|
|
|
|
|
//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
|
|
|
|
NO_COMMAND = 0,
|
|
|
|
|
//<2F><>ȡdsp ״̬
|
|
|
|
|
GET_DSP_STATUS = 1,
|
|
|
|
|
//ȡͼ
|
|
|
|
|
GET_IMAGE = 2,
|
|
|
|
|
//<2F><><EFBFBD><EFBFBD>DSP<53><50>פ<EFBFBD><D7A4><EFBFBD><EFBFBD>ͼ
|
|
|
|
|
POP_IMAGE = 3,
|
|
|
|
|
//<2F><>ʼɨ<CABC><C9A8><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
|
|
|
|
START_COMMAND = 4,
|
|
|
|
|
//ֹͣɨ<D6B9><C9A8><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
|
|
|
|
STOP = 5,
|
|
|
|
|
//<2F><>ȡɨ<C8A1><C9A8><EFBFBD><EFBFBD>ɨ<EFBFBD><C9A8>ģʽ
|
|
|
|
|
GET_SCAN_MODE = 6,
|
|
|
|
|
//<2F><>ȡ<EFBFBD>̼<EFBFBD><CCBC>汾<EFBFBD><E6B1BE>
|
|
|
|
|
GET_FW_VERSION = 7,
|
|
|
|
|
//<2F><><EFBFBD><EFBFBD>PC<50>˵<EFBFBD>״̬
|
|
|
|
|
SEND_STATUS_PC = 8,
|
|
|
|
|
//<2F>·<EFBFBD>ɨ<EFBFBD><C9A8><EFBFBD><EFBFBD><EFBFBD>ò<EFBFBD><C3B2><EFBFBD>
|
|
|
|
|
CONFIGURED_DATA = 9,
|
|
|
|
|
//<2F>·<EFBFBD><C2B7>̼<EFBFBD><CCBC><EFBFBD>Ϣ
|
|
|
|
|
SEND_FW = 10,
|
|
|
|
|
//<2F><>ȡɨ<C8A1><C9A8><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
|
|
|
|
GET_CONFIG_DATA = 11,
|
|
|
|
|
//<2F><>ȡɨ<C8A1><C9A8><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
|
|
|
|
GET_SCANN_NUM = 12,
|
|
|
|
|
//<2F><>ȡ<EFBFBD><C8A1><EFBFBD><EFBFBD>ֽ<EFBFBD><D6BD>״̬
|
|
|
|
|
GET_PAPERFEEDER_STATUS = 13,
|
|
|
|
|
//DSP<53><50>ʼ<EFBFBD><CABC>
|
|
|
|
|
INIT_HARDWARE_SYS = 14,
|
|
|
|
|
//<2F><>ȡ<EFBFBD><C8A1><EFBFBD><EFBFBD>ֽ<EFBFBD><D6BD>״̬
|
|
|
|
|
GET_PAPER_STATUS = 0x0d,
|
|
|
|
|
//<2F>·<EFBFBD>Ԫ<EFBFBD><D4AA><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ò<EFBFBD><C3B2><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ҷȣ<D2B6>LED R<>ع<EFBFBD>ʱ<EFBFBD>䣩
|
|
|
|
|
SEND_COMPONENTS_GR = 15,
|
|
|
|
|
//<2F>·<EFBFBD>Ԫ<EFBFBD><D4AA><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ò<EFBFBD><C3B2><EFBFBD><EFBFBD><EFBFBD>LED G/B<>ع<EFBFBD>ʱ<EFBFBD>䣩
|
|
|
|
|
SEND_COMPONENTS_GB = 16,
|
|
|
|
|
//<2F>·<EFBFBD>ɨ<EFBFBD><C9A8>ģʽ
|
|
|
|
|
SEND_SCAN_MODE = 17,
|
|
|
|
|
//<2F><>ʼ<EFBFBD><CABC><EFBFBD><EFBFBD>ƽ<EFBFBD><C6BD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
|
|
|
|
START_FLAT = 18,
|
|
|
|
|
//ֹͣƽ<D6B9><C6BD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
|
|
|
|
STOP_FLAT = 19,
|
|
|
|
|
//<2F>·<EFBFBD>200dpi<70><69>ɫƽ<C9AB><C6BD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
|
|
|
|
SEND_200_COLOR_FLAT_DATA = 20,
|
|
|
|
|
//<2F>·<EFBFBD>300dpi<70><69>ɫƽ<C9AB><C6BD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
|
|
|
|
SEND_300_COLOR_FLAT_DATA = 21,
|
|
|
|
|
//<2F><>ȡ200dpi<70><69>ɫƽ<C9AB><C6BD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
|
|
|
|
GET_200_COLOR_FLAT_DATA = 22,
|
|
|
|
|
//<2F><>ȡ300dpi<70><69>ɫƽ<C9AB><C6BD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
|
|
|
|
GET_300_COLOR_FLAT_DATA = 23,
|
|
|
|
|
//<2F>·<EFBFBD>200dpi<70>Ҷ<EFBFBD>ƽ<EFBFBD><C6BD>У<EFBFBD><D0A3><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
|
|
|
|
SEND_200_GRAY_FLAT_DATA = 24,
|
|
|
|
|
//<2F>·<EFBFBD>300dpi<70>Ҷ<EFBFBD>ƽ<EFBFBD><C6BD>У<EFBFBD><D0A3><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
|
|
|
|
SEND_300_GRAY_FLAT_DATA = 25,
|
|
|
|
|
//<2F><>ȡ200DPI<50>Ҷ<EFBFBD>ƽ<EFBFBD><C6BD>У<EFBFBD><D0A3><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
|
|
|
|
GET_200_GRAY_FLAT_DATA = 26,
|
|
|
|
|
//<2F><>ȡ300DPI<50>Ҷ<EFBFBD>ƽ<EFBFBD><C6BD>У<EFBFBD><D0A3><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
|
|
|
|
GET_300_GRAY_FLAT_DATA = 27,
|
|
|
|
|
//<2F>·<EFBFBD><C2B7><EFBFBD><EFBFBD>к<EFBFBD><D0BA><EFBFBD><EFBFBD><EFBFBD>
|
|
|
|
|
SEND_SERIAL = 28,
|
|
|
|
|
//<2F><>ȡ<EFBFBD><C8A1><EFBFBD>к<EFBFBD><D0BA><EFBFBD><EFBFBD><EFBFBD>
|
2020-05-16 01:50:34 +00:00
|
|
|
|
GET_SERIAL = 29,
|
|
|
|
|
//<2F><>ȡ<EFBFBD><C8A1><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
2020-06-20 03:13:18 +00:00
|
|
|
|
GET_ROLLER_NUM = 0x1e,
|
2020-05-16 01:50:34 +00:00
|
|
|
|
//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
2020-06-20 03:13:18 +00:00
|
|
|
|
CLR_ROLLER_NUM = 0x1f,
|
2020-05-16 01:50:34 +00:00
|
|
|
|
//<2F><><EFBFBD><EFBFBD>ɨ<EFBFBD><C9A8><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
2020-06-20 03:13:18 +00:00
|
|
|
|
CLR_SCAN_NUM = 0x20,
|
2020-05-16 01:50:34 +00:00
|
|
|
|
//<><D7BC><EFBFBD><EFBFBD><EFBFBD>¹̼<C2B9>
|
2020-06-20 03:13:18 +00:00
|
|
|
|
PRE_UPGRADE = 0X21,
|
2020-05-16 01:50:34 +00:00
|
|
|
|
//<2F><>ʼ<EFBFBD><CABC><EFBFBD>¹̼<C2B9>
|
2020-06-20 03:13:18 +00:00
|
|
|
|
START_UPGRADE = 0x22,
|
2020-05-16 01:50:34 +00:00
|
|
|
|
//<2F><>ɫ<EFBFBD><C9AB>AD<41><44><EFBFBD><EFBFBD>
|
2020-06-20 03:13:18 +00:00
|
|
|
|
RGB_ADI_PARA = 0x23,
|
2020-05-16 01:50:34 +00:00
|
|
|
|
//<2F>Ҷȵ<D2B6>AD<41><44><EFBFBD><EFBFBD>
|
2020-06-20 03:13:18 +00:00
|
|
|
|
ADI_PARA = 0x24,
|
2020-05-16 01:50:34 +00:00
|
|
|
|
//<2F><>ȡCIS<49><53><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ع<EFBFBD>ʱ<EFBFBD>䣬ad<61><64><EFBFBD><EFBFBD>)
|
2020-06-20 03:13:18 +00:00
|
|
|
|
GET_CIS_PARA = 0x25,
|
2020-05-16 01:50:34 +00:00
|
|
|
|
//ɨ<><C9A8><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
2020-06-20 03:13:18 +00:00
|
|
|
|
START_COMMAND_COUNT = 0x26,
|
2020-05-16 01:50:34 +00:00
|
|
|
|
//<2F>·<EFBFBD><C2B7><EFBFBD><EFBFBD><EFBFBD>ʱ<EFBFBD><CAB1>
|
2020-06-20 03:13:18 +00:00
|
|
|
|
SET_SLEEP_TIME = 0x27,
|
2020-05-16 01:50:34 +00:00
|
|
|
|
//<2F><>ȡ<EFBFBD><C8A1><EFBFBD><EFBFBD>ʱ<EFBFBD><CAB1>
|
2020-06-20 03:13:18 +00:00
|
|
|
|
GET_SLEEP_TIME = 0x28,
|
2020-05-16 01:50:34 +00:00
|
|
|
|
//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
2020-06-20 03:13:18 +00:00
|
|
|
|
CLR_CACHE = 0x29,
|
2020-05-16 01:50:34 +00:00
|
|
|
|
//<2F>·<EFBFBD><C2B7>ٶ<EFBFBD>ģʽ
|
2020-06-20 03:13:18 +00:00
|
|
|
|
SET_SPEED_MODE = 0x2a,
|
2020-05-16 01:50:34 +00:00
|
|
|
|
//<2F><>ȡɨ<C8A1><C9A8><EFBFBD>ٶ<EFBFBD>ģʽ
|
2020-06-20 03:13:18 +00:00
|
|
|
|
GET_SPEED_MODE = 0X2b,
|
2020-05-16 01:50:34 +00:00
|
|
|
|
//<2F><><EFBFBD>ù̼<C3B9><CCBC>汾һ<E6B1BE><D2BB>8<EFBFBD><38><EFBFBD>ֽ<EFBFBD>
|
2020-06-20 03:13:18 +00:00
|
|
|
|
SET_FW_VERSION = 0X2c,
|
2020-05-16 01:50:34 +00:00
|
|
|
|
//<2F><>ȡDSP<53>汾
|
2020-06-20 03:13:18 +00:00
|
|
|
|
GET_DSP_VERSION = 0X2d,
|
2020-05-16 01:50:34 +00:00
|
|
|
|
//<2F>ɼ<EFBFBD><C9BC><EFBFBD>FPGA<47>̼<EFBFBD><CCBC>汾
|
2020-06-20 03:13:18 +00:00
|
|
|
|
GET_SCANFPGA_VERSION = 0x2e,
|
2020-05-16 01:50:34 +00:00
|
|
|
|
//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>FPGA<47>̼<EFBFBD><CCBC>汾
|
2020-06-20 03:13:18 +00:00
|
|
|
|
GET_MOTORFPGA_VERSION = 0X2f,
|
2020-05-16 01:50:34 +00:00
|
|
|
|
//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ϣ
|
2020-06-20 03:13:18 +00:00
|
|
|
|
SET_USB_INFOR_MANUFACTURE = 0X30,
|
2020-05-16 01:50:34 +00:00
|
|
|
|
//<2F><>ȡ<EFBFBD><C8A1><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ϣ
|
2020-06-20 03:13:18 +00:00
|
|
|
|
GET_USB_INFOR_MANUFACTURE = 0X31,
|
2020-05-16 01:50:34 +00:00
|
|
|
|
//<2F><><EFBFBD>ò<EFBFBD>Ʒ<EFBFBD>ͺ<EFBFBD><CDBA><EFBFBD>Ϣ
|
2020-06-20 03:13:18 +00:00
|
|
|
|
SET_USB_INFOR_MODEL_NAME = 0X32,
|
2020-05-16 01:50:34 +00:00
|
|
|
|
//<2F><>ȡ<EFBFBD><C8A1>Ʒ<EFBFBD>ͺ<EFBFBD><CDBA><EFBFBD>Ϣ
|
2020-06-20 03:13:18 +00:00
|
|
|
|
GET_USB_INFOR_MODEL_NAME = 0X33,
|
2020-05-16 01:50:34 +00:00
|
|
|
|
//<2F><><EFBFBD><EFBFBD>USB PID / VID<49><44>Ϣ
|
2020-06-20 03:13:18 +00:00
|
|
|
|
SET_USB_INFOR_VIDPID = 0X34,
|
|
|
|
|
GET_USB_INFOR_VIDPID = 0X35,
|
2020-05-16 01:50:34 +00:00
|
|
|
|
//<2F><><EFBFBD>ÿ<EFBFBD>ֽ<EFBFBD><D6BD>ͣ<EFBFBD><CDA3><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
2020-06-20 03:13:18 +00:00
|
|
|
|
SET_JAM_DETECT_SENSITIVE = 0X36,
|
2020-05-16 01:50:34 +00:00
|
|
|
|
//<2F><>ȡ<EFBFBD><C8A1>ֽ<EFBFBD><D6BD>ͣ<EFBFBD><CDA3><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
2020-06-20 03:13:18 +00:00
|
|
|
|
GET_JAM_DETECT_SENSITIVE = 0X37,
|
2020-05-16 01:50:34 +00:00
|
|
|
|
//<2F><><EFBFBD>ú<EFBFBD><C3BA><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ϵ<EFBFBD><CFB5>
|
2020-06-20 03:13:18 +00:00
|
|
|
|
SET_JUST_COF_H = 0x38,
|
2020-05-16 01:50:34 +00:00
|
|
|
|
//<2F><>ȡ<EFBFBD><C8A1><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ϵ<EFBFBD><CFB5>
|
2020-06-20 03:13:18 +00:00
|
|
|
|
GET_JUST_COF_H = 0x39,
|
|
|
|
|
//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ϵ<EFBFBD><CFB5>
|
2020-05-16 01:50:34 +00:00
|
|
|
|
SET_JUST_COF_V = 0x41,
|
|
|
|
|
//<2F><>ȡ<EFBFBD><C8A1><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ϵ<EFBFBD><CFB5>
|
2021-04-06 01:31:21 +00:00
|
|
|
|
GET_JUST_COF_V=0x42,
|
|
|
|
|
//<2F><><EFBFBD><EFBFBD>ɨ<EFBFBD><C9A8><EFBFBD>DZ<EFBFBD><C7B1><EFBFBD>
|
|
|
|
|
GET_CODE_G400 = 0x59,
|
|
|
|
|
//<2F><>ȡɨ<C8A1><C9A8><EFBFBD>DZ<EFBFBD><C7B1><EFBFBD>
|
2021-05-13 10:13:08 +00:00
|
|
|
|
SET_CODE_G400 = 0x5A,
|
2021-04-06 01:31:21 +00:00
|
|
|
|
//<2F><><EFBFBD><EFBFBD>ɨ<EFBFBD><C9A8><EFBFBD>DZ<EFBFBD><C7B1><EFBFBD>
|
|
|
|
|
SET_CODE_G200=0x63,
|
|
|
|
|
//<2F><>ȡɨ<C8A1><C9A8><EFBFBD>DZ<EFBFBD><C7B1><EFBFBD>
|
|
|
|
|
GET_CODE_G200=0x64,
|
2020-05-16 01:50:34 +00:00
|
|
|
|
|
2020-07-11 10:43:17 +00:00
|
|
|
|
} UsbKeyWords, * PUsbKeyWords;
|
2020-03-11 01:58:06 +00:00
|
|
|
|
|
2020-07-11 10:43:17 +00:00
|
|
|
|
GScanO200::GScanO200() :
|
2020-08-31 07:46:14 +00:00
|
|
|
|
huagods(NULL),
|
2020-11-16 10:05:04 +00:00
|
|
|
|
image_num(0),
|
2021-06-21 11:38:36 +00:00
|
|
|
|
m_bread_fixed_ratio_fromDSP(false),
|
|
|
|
|
is_orginimgcount(true)
|
2020-03-11 01:58:06 +00:00
|
|
|
|
{
|
2020-06-20 03:13:18 +00:00
|
|
|
|
m_pImages.reset(new ImageMatQueue());
|
2021-07-02 03:29:24 +00:00
|
|
|
|
auto getimgnum = [&](bool isadd,int num)
|
2021-06-30 13:58:13 +00:00
|
|
|
|
{
|
|
|
|
|
isadd ? image_num++ : image_num--;
|
|
|
|
|
};
|
|
|
|
|
m_pImages->SetGetimgnumcall(getimgnum);
|
2020-03-11 01:58:06 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
GScanO200::~GScanO200()
|
|
|
|
|
{
|
|
|
|
|
if (m_threadUsb && m_threadUsb->joinable()) {
|
|
|
|
|
devState = DEV_STOP;
|
|
|
|
|
m_threadUsb->join();
|
|
|
|
|
m_threadUsb.reset();
|
|
|
|
|
}
|
2021-06-30 13:58:13 +00:00
|
|
|
|
|
2020-11-12 11:35:20 +00:00
|
|
|
|
if (m_usb.get())
|
2020-07-20 02:29:10 +00:00
|
|
|
|
m_usb.reset();
|
2020-06-23 09:16:45 +00:00
|
|
|
|
|
2021-06-30 13:58:13 +00:00
|
|
|
|
m_pImages.reset();
|
2020-11-16 10:05:04 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void GScanO200::DogEar_callback(std::function<void(int)> fun)
|
|
|
|
|
{
|
2021-06-30 13:58:13 +00:00
|
|
|
|
m_pImages->SetDogEarCallback(fun);
|
2020-11-16 10:05:04 +00:00
|
|
|
|
}
|
|
|
|
|
|
2020-03-11 01:58:06 +00:00
|
|
|
|
void GScanO200::open(int vid, int pid)
|
|
|
|
|
{
|
|
|
|
|
auto usbs = UsbScan_List::find_vid_pid(vid, pid);
|
|
|
|
|
|
2020-07-11 10:43:17 +00:00
|
|
|
|
if (!usbs.empty())
|
2021-02-03 10:21:45 +00:00
|
|
|
|
{
|
2020-03-11 01:58:06 +00:00
|
|
|
|
m_usb = *usbs.begin();
|
2021-02-03 10:21:45 +00:00
|
|
|
|
m_usb->set_usbhotplug_callback(usbhotplug_callback, this);
|
2020-05-16 01:50:34 +00:00
|
|
|
|
bool ret = m_usb->open();
|
2020-08-31 07:46:14 +00:00
|
|
|
|
USBCB status = { GET_DSP_STATUS ,0,0 };
|
|
|
|
|
if (m_usb.get() && m_usb->is_connected())
|
|
|
|
|
m_usb->write_bulk(&status, sizeof(status));
|
|
|
|
|
|
|
|
|
|
if (m_usb.get() && m_usb->is_connected())
|
|
|
|
|
m_usb->read_bulk(&status, sizeof(status));
|
2020-03-11 01:58:06 +00:00
|
|
|
|
}
|
2020-12-20 06:37:19 +00:00
|
|
|
|
if (this->IsConnected())
|
|
|
|
|
GetFWVersion();
|
2020-03-11 01:58:06 +00:00
|
|
|
|
}
|
2020-12-20 06:37:19 +00:00
|
|
|
|
|
2020-08-31 07:46:14 +00:00
|
|
|
|
void GScanO200::regist_deviceevent_callback(deviceevent_callback callback, void* usrdata)
|
|
|
|
|
{
|
|
|
|
|
huagods = usrdata;
|
|
|
|
|
dev_callback = callback;
|
|
|
|
|
}
|
2021-07-02 03:29:24 +00:00
|
|
|
|
|
2020-03-11 01:58:06 +00:00
|
|
|
|
int GScanO200::aquire_bmpdata(std::vector<unsigned char>& bmpdata)
|
|
|
|
|
{
|
|
|
|
|
StopWatch sw;
|
|
|
|
|
while (true)
|
|
|
|
|
{
|
|
|
|
|
if (m_pImages->empty()) {
|
2020-12-17 09:02:33 +00:00
|
|
|
|
DoEvents();
|
2021-06-21 11:38:36 +00:00
|
|
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(10));
|
2021-05-19 10:58:07 +00:00
|
|
|
|
if (sw.elapsed_s() > 30.00)
|
2020-03-11 01:58:06 +00:00
|
|
|
|
{
|
|
|
|
|
if (m_threadUsb && m_threadUsb->joinable()) {
|
|
|
|
|
devState = DEV_STOP;
|
|
|
|
|
m_threadUsb->join();
|
|
|
|
|
m_threadUsb.reset();
|
2020-06-23 09:16:45 +00:00
|
|
|
|
//writelog("aquire_bmpdata m_threadUsb.reset();");
|
2020-03-11 01:58:06 +00:00
|
|
|
|
}
|
|
|
|
|
Stop_scan();//ֹͣɨ<D6B9><C9A8>
|
|
|
|
|
ResetScanner();
|
2021-06-21 11:38:36 +00:00
|
|
|
|
auto rollernew = Get_Roller_num();
|
2021-07-19 10:36:34 +00:00
|
|
|
|
set_scannum(abs(rollernew - roller_num));
|
2020-03-11 01:58:06 +00:00
|
|
|
|
return HARDWARE_ERROR;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (!is_scan()) {
|
2021-07-19 10:36:34 +00:00
|
|
|
|
auto rollernew = Get_Roller_num();
|
|
|
|
|
set_scannum(abs(rollernew - roller_num));
|
2020-03-11 01:58:06 +00:00
|
|
|
|
if (devState == DEV_WRONG) {
|
|
|
|
|
return get_ErrorCode();
|
|
|
|
|
}
|
|
|
|
|
return -1;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else {
|
|
|
|
|
if (m_pImages->valid()) {
|
2020-05-16 01:50:34 +00:00
|
|
|
|
bmpdata = *(m_pImages->popBmpdata());
|
2021-07-02 03:29:24 +00:00
|
|
|
|
UpdateScanInfo(get_imgnReaded(), countNTransfered());
|
2020-03-11 01:58:06 +00:00
|
|
|
|
return 0;
|
|
|
|
|
}
|
2020-12-17 09:02:33 +00:00
|
|
|
|
DoEvents();
|
2021-04-13 09:30:05 +00:00
|
|
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(2));
|
2020-03-11 01:58:06 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
BOOL GScanO200::IsConnected()
|
|
|
|
|
{
|
|
|
|
|
return m_usb.get() && m_usb->is_connected();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
std::string GScanO200::GetFWVersion()
|
|
|
|
|
{
|
|
|
|
|
if (m_usb.get() && m_usb->is_connected()) {
|
|
|
|
|
lock_guard< mutex> lock(m_imgLocker);
|
|
|
|
|
if (fwVersion.empty()) {
|
2020-06-20 03:13:18 +00:00
|
|
|
|
fwVersion.resize(8);
|
|
|
|
|
USBCB cmd = { GET_FW_VERSION,fwVersion.size(),0, };
|
|
|
|
|
m_usb->write_bulk(&cmd, sizeof(cmd));
|
|
|
|
|
m_usb->read_bulk(&fwVersion[0], fwVersion.size());
|
|
|
|
|
std::string ver = fwVersion.substr((fwVersion.length() - 2), 2);
|
|
|
|
|
int verValue = atoi(ver.c_str());
|
|
|
|
|
m_bread_fixed_ratio_fromDSP = verValue >= 15;
|
2021-06-21 11:38:36 +00:00
|
|
|
|
FileTools::writelog(log_ERROR,m_bread_fixed_ratio_fromDSP ? "can get ratio from dsp" : "can not get dsp ratio");
|
2020-06-20 03:13:18 +00:00
|
|
|
|
updateHVRatio();
|
2020-03-11 01:58:06 +00:00
|
|
|
|
}
|
|
|
|
|
return fwVersion;
|
|
|
|
|
}
|
|
|
|
|
return "";
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
std::string GScanO200::GetSerialNum()
|
|
|
|
|
{
|
2020-08-15 08:08:47 +00:00
|
|
|
|
//return "G20018000298";
|
2020-03-11 01:58:06 +00:00
|
|
|
|
if (m_usb.get() && m_usb->is_connected())
|
|
|
|
|
{
|
|
|
|
|
std::lock_guard<std::mutex> lck(m_imgLocker);
|
2020-11-12 11:35:20 +00:00
|
|
|
|
if (SerialNum.empty()) {
|
2020-06-20 03:13:18 +00:00
|
|
|
|
SerialNum.resize(12);
|
|
|
|
|
USBCB usbcb = { GET_SERIAL,SerialNum.size(),0 };
|
|
|
|
|
m_usb->write_bulk(&usbcb, sizeof(usbcb));
|
|
|
|
|
m_usb->read_bulk(&SerialNum[0], SerialNum.size());
|
2020-05-16 01:50:34 +00:00
|
|
|
|
|
2020-11-12 11:35:20 +00:00
|
|
|
|
}
|
2020-03-11 01:58:06 +00:00
|
|
|
|
return SerialNum;
|
|
|
|
|
}
|
|
|
|
|
return "";
|
|
|
|
|
}
|
|
|
|
|
|
2021-06-21 11:38:36 +00:00
|
|
|
|
std::uint32_t GScanO200::GetMotorFPGA()
|
|
|
|
|
{
|
|
|
|
|
if (m_usb.get() && m_usb->is_connected())
|
|
|
|
|
{
|
|
|
|
|
std::lock_guard<std::mutex> lck(m_imgLocker);
|
|
|
|
|
USBCB usbcb = { GET_MOTORFPGA_VERSION,0,sizeof(MotorFpga) };
|
|
|
|
|
m_usb->write_bulk(&usbcb, sizeof(usbcb));
|
|
|
|
|
m_usb->read_bulk(&usbcb, sizeof(usbcb));
|
|
|
|
|
MotorFpga = usbcb.u32_Data;
|
|
|
|
|
return MotorFpga;
|
|
|
|
|
}
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
std::uint32_t GScanO200::GetScanFPGA()
|
|
|
|
|
{
|
|
|
|
|
if (m_usb.get() && m_usb->is_connected())
|
|
|
|
|
{
|
|
|
|
|
std::lock_guard<std::mutex> lck(m_imgLocker);
|
|
|
|
|
USBCB usbcb = { GET_SCANFPGA_VERSION,0,4 };
|
|
|
|
|
m_usb->write_bulk(&usbcb, sizeof(usbcb));
|
|
|
|
|
m_usb->read_bulk(&usbcb, sizeof(usbcb));
|
|
|
|
|
ScanFpga = usbcb.u32_Data;
|
|
|
|
|
return ScanFpga;
|
|
|
|
|
}
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2020-03-11 01:58:06 +00:00
|
|
|
|
bool GScanO200::is_scan()
|
|
|
|
|
{
|
|
|
|
|
//std::lock_guard<std::mutex> lck(m_imgLocker);
|
|
|
|
|
return devState == DEV_ISRUNNING;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
BOOL GScanO200::Get_Scanner_PaperOn()
|
|
|
|
|
{
|
2021-02-03 10:21:45 +00:00
|
|
|
|
if (!(m_usb.get() && m_usb->is_open()))
|
2020-03-11 01:58:06 +00:00
|
|
|
|
return false;
|
|
|
|
|
|
|
|
|
|
USBCB usbcb = { GET_PAPER_STATUS ,0,0 };
|
2021-01-28 10:48:35 +00:00
|
|
|
|
usbcb.u32_Data = 1;//<2F>ij<DEB8>ʼֵ<CABC><D6B5>ֹͨ<D6B9><CDA8><EFBFBD>쳣ʱĬ<CAB1>ϳ<EFBFBD>ʼֵΪ0<CEAA><30><EFBFBD><EFBFBD>ֽ
|
2020-03-11 01:58:06 +00:00
|
|
|
|
std::lock_guard<std::mutex> lck(m_imgLocker);
|
|
|
|
|
m_usb->write_bulk(&usbcb, sizeof(usbcb));
|
2021-01-28 10:48:35 +00:00
|
|
|
|
if (0 == m_usb->read_bulk(&usbcb, sizeof(usbcb)))
|
|
|
|
|
{
|
|
|
|
|
Set_ErrorCode(USB_DISCONNECTED);
|
|
|
|
|
return true;
|
|
|
|
|
}
|
2020-03-11 01:58:06 +00:00
|
|
|
|
return usbcb.u32_Data != 0;
|
|
|
|
|
}
|
|
|
|
|
|
2021-05-13 10:13:08 +00:00
|
|
|
|
int GScanO200::Get_Roller_num()
|
|
|
|
|
{
|
|
|
|
|
if (!(m_usb.get() && m_usb->is_open()))
|
2021-06-21 11:38:36 +00:00
|
|
|
|
return 0;
|
2021-12-16 08:21:35 +00:00
|
|
|
|
USBCB usbcb = { GET_SCANN_NUM ,0,4 };
|
2021-05-13 10:13:08 +00:00
|
|
|
|
std::lock_guard<std::mutex> lck(m_imgLocker);
|
|
|
|
|
m_usb->write_bulk(&usbcb, sizeof(usbcb));
|
2021-05-19 10:58:07 +00:00
|
|
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(50));
|
2021-05-13 10:13:08 +00:00
|
|
|
|
m_usb->read_bulk(&usbcb, sizeof(usbcb));
|
2021-12-16 08:21:35 +00:00
|
|
|
|
if (usbcb.u32_CMD != GET_SCANN_NUM)
|
2021-06-21 11:38:36 +00:00
|
|
|
|
{
|
|
|
|
|
FileTools::writelog(log_ERROR, "get roller usb bulk error");
|
|
|
|
|
}
|
|
|
|
|
FileTools::writelog(log_INFO, "get roller num " + to_string(usbcb.u32_Data));
|
2021-05-13 10:13:08 +00:00
|
|
|
|
return usbcb.u32_Data;
|
|
|
|
|
}
|
|
|
|
|
|
2020-03-11 01:58:06 +00:00
|
|
|
|
void GScanO200::config_params(GScanCap& params)
|
|
|
|
|
{
|
2020-05-16 01:50:34 +00:00
|
|
|
|
if (m_usb.get() && m_usb->is_connected()) {
|
|
|
|
|
hgConfigClass cfg = hgConfigClass(params);
|
|
|
|
|
gcap = params;
|
2020-03-11 01:58:06 +00:00
|
|
|
|
UINT32 cfgdata = cfg.GetData();
|
|
|
|
|
USBCB usbcb = { CONFIGURED_DATA,cfgdata,0 };
|
2021-06-21 11:38:36 +00:00
|
|
|
|
FileTools::writelog(log_INFO, "config hardware param"+to_string(cfgdata));
|
2020-03-11 01:58:06 +00:00
|
|
|
|
m_usb->write_bulk(&usbcb, sizeof(USBCB));
|
2020-07-11 10:43:17 +00:00
|
|
|
|
this_thread::sleep_for(std::chrono::milliseconds(200));
|
2020-03-11 01:58:06 +00:00
|
|
|
|
m_pImages->setparam(params);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void GScanO200::Scanner_StartScan(UINT16 count)
|
|
|
|
|
{
|
2021-06-21 11:38:36 +00:00
|
|
|
|
if (fwVersion.size() > 1)
|
|
|
|
|
{
|
|
|
|
|
if ((atoi(fwVersion.substr(2, 6).c_str()) > 211132) && ((MotorFpga >= 25210514)&&(MotorFpga<100000000)))
|
|
|
|
|
is_orginimgcount = true;
|
|
|
|
|
else
|
|
|
|
|
is_orginimgcount = false;
|
|
|
|
|
}
|
|
|
|
|
roller_num = Get_Roller_num();
|
2020-11-12 11:35:20 +00:00
|
|
|
|
std::lock_guard<std::mutex> lck(m_imgLocker);
|
|
|
|
|
if (m_threadUsb && m_threadUsb->joinable()) {
|
|
|
|
|
devState = DEV_STOP;
|
|
|
|
|
m_threadUsb->join();
|
|
|
|
|
}
|
2021-06-21 11:38:36 +00:00
|
|
|
|
|
2020-12-20 06:37:19 +00:00
|
|
|
|
USBCB status = { GET_DSP_STATUS ,0,0 };
|
2020-11-12 11:35:20 +00:00
|
|
|
|
if (m_usb.get() && m_usb->is_connected())
|
|
|
|
|
m_usb->write_bulk(&status, sizeof(status));
|
|
|
|
|
if (m_usb.get() && m_usb->is_connected())
|
|
|
|
|
m_usb->read_bulk(&status, sizeof(status));
|
|
|
|
|
switch (status.u32_Data)
|
|
|
|
|
{
|
|
|
|
|
case COUNT_MODE:
|
|
|
|
|
case NO_FEED:
|
|
|
|
|
case OPEN_COVER:
|
|
|
|
|
case FEED_IN_ERROR:
|
|
|
|
|
case PAPER_JAM:
|
|
|
|
|
case DETECT_DOUBLE_FEED:
|
|
|
|
|
case DETECT_STAPLE:
|
|
|
|
|
case PAPER_SKEW:
|
|
|
|
|
case HARDWARE_ERROR:
|
|
|
|
|
case PC_SCAN_BUSY_or_ERROR:
|
|
|
|
|
m_pImages->setscanflags(false);
|
|
|
|
|
devState = DEV_WRONG;
|
|
|
|
|
Set_ErrorCode(status.u32_Data);
|
|
|
|
|
if (huagods)
|
|
|
|
|
dev_callback(status.u32_Data, huagods);
|
|
|
|
|
return;
|
|
|
|
|
default:
|
|
|
|
|
break;
|
|
|
|
|
}
|
2021-01-28 10:48:35 +00:00
|
|
|
|
//#ifndef G200
|
|
|
|
|
//
|
|
|
|
|
// USBCB paperstatus = { GET_PAPER_STATUS ,0,0 };
|
|
|
|
|
// paperstatus.u32_Data = 1;
|
|
|
|
|
// if (m_usb.get() && m_usb->is_connected())
|
|
|
|
|
// m_usb->write_bulk(&paperstatus, sizeof(paperstatus));
|
|
|
|
|
// if (m_usb.get() && m_usb->is_connected())
|
|
|
|
|
// m_usb->read_bulk(&paperstatus, sizeof(paperstatus));
|
|
|
|
|
// if (paperstatus.u32_Data == 0) {
|
|
|
|
|
// m_pImages->setscanflags(false);
|
|
|
|
|
// devState = DEV_WRONG;
|
|
|
|
|
// Set_ErrorCode(NO_FEED);
|
|
|
|
|
// if (huagods)
|
|
|
|
|
// dev_callback(NO_FEED, huagods);
|
|
|
|
|
// return;
|
|
|
|
|
// }
|
|
|
|
|
//#endif // !G200
|
2020-11-16 10:05:04 +00:00
|
|
|
|
m_pImages->reset_DogEar();
|
2020-11-12 11:35:20 +00:00
|
|
|
|
if (gcap.is_duplex)
|
|
|
|
|
count = count == 65535 ? 65535 : count / 2;
|
|
|
|
|
USBCB usbcb = { START_COMMAND,(UINT32)count ,0 };
|
|
|
|
|
if (m_usb.get() && m_usb->is_connected())
|
|
|
|
|
m_usb->write_bulk(&usbcb, sizeof(usbcb));
|
2021-06-21 11:38:36 +00:00
|
|
|
|
this_thread::sleep_for(std::chrono::milliseconds(500));
|
2020-11-12 11:35:20 +00:00
|
|
|
|
if (m_usb.get() && m_usb->is_connected())
|
|
|
|
|
{
|
|
|
|
|
m_pImages->setscanflags(true);
|
|
|
|
|
m_threadUsb.reset(new std::thread(&GScanO200::usbmain, this));
|
|
|
|
|
m_pImages->run();
|
|
|
|
|
}
|
2020-03-11 01:58:06 +00:00
|
|
|
|
}
|
|
|
|
|
|
2021-06-21 11:38:36 +00:00
|
|
|
|
int GScanO200::notifyscan()
|
|
|
|
|
{
|
2021-11-20 03:09:04 +00:00
|
|
|
|
return 1;
|
2021-06-21 11:38:36 +00:00
|
|
|
|
}
|
|
|
|
|
|
2020-03-11 01:58:06 +00:00
|
|
|
|
void GScanO200::Stop_scan()
|
|
|
|
|
{
|
|
|
|
|
std::lock_guard<std::mutex> lck(m_imgLocker);
|
|
|
|
|
USBCB usbcb = { STOP ,0,0 };
|
2020-07-20 02:29:10 +00:00
|
|
|
|
if (m_usb.get() && m_usb->is_connected())
|
|
|
|
|
m_usb->write_bulk(&usbcb, sizeof(usbcb));
|
2020-03-11 01:58:06 +00:00
|
|
|
|
}
|
|
|
|
|
|
2020-11-12 11:35:20 +00:00
|
|
|
|
|
2020-03-11 01:58:06 +00:00
|
|
|
|
void GScanO200::ResetScanner()
|
|
|
|
|
{
|
2021-02-03 10:21:45 +00:00
|
|
|
|
if (!(m_usb.get() && m_usb->is_connected()))
|
2020-03-11 01:58:06 +00:00
|
|
|
|
return;
|
|
|
|
|
std::lock_guard<std::mutex> lck(m_imgLocker);
|
|
|
|
|
USBCB usbcb = { INIT_HARDWARE_SYS ,0,0 };
|
2020-11-12 11:35:20 +00:00
|
|
|
|
if (m_usb.get() && m_usb->is_connected())
|
2020-07-20 02:29:10 +00:00
|
|
|
|
m_usb->write_bulk(&usbcb, sizeof(usbcb));
|
2021-06-30 13:58:13 +00:00
|
|
|
|
m_pImages->clear();
|
2020-03-11 01:58:06 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bool GScanO200::Get_IsImageQueueEmpty()
|
|
|
|
|
{
|
|
|
|
|
return m_pImages->empty();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void GScanO200::reset()
|
|
|
|
|
{
|
2020-05-16 01:50:34 +00:00
|
|
|
|
while (!m_pImages->empty())
|
2020-03-11 01:58:06 +00:00
|
|
|
|
m_pImages->clear();
|
2020-06-20 03:13:18 +00:00
|
|
|
|
|
2020-03-11 01:58:06 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
UINT32 GScanO200::get_ErrorCode()
|
|
|
|
|
{
|
|
|
|
|
return Error_Code;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void GScanO200::Set_ErrorCode(UINT32 value)
|
|
|
|
|
{
|
|
|
|
|
Error_Code = value;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int GScanO200::get_scanned_num()
|
|
|
|
|
{
|
|
|
|
|
std::lock_guard<std::mutex> lck(m_imgLocker);
|
|
|
|
|
USBCB usbcb = { GET_SCANN_NUM ,0,0 };
|
2020-07-20 02:29:10 +00:00
|
|
|
|
if (m_usb.get() && m_usb->is_connected())
|
|
|
|
|
m_usb->write_bulk(&usbcb, sizeof(usbcb));
|
|
|
|
|
|
2020-03-11 01:58:06 +00:00
|
|
|
|
return usbcb.u32_Count;
|
|
|
|
|
}
|
|
|
|
|
|
2020-05-16 01:50:34 +00:00
|
|
|
|
void GScanO200::clear_hwerror()
|
|
|
|
|
{
|
2021-01-22 07:18:41 +00:00
|
|
|
|
;
|
2020-05-16 01:50:34 +00:00
|
|
|
|
}
|
|
|
|
|
|
2021-02-03 10:21:45 +00:00
|
|
|
|
void GScanO200::set_sleep_time(int mode)
|
|
|
|
|
{
|
|
|
|
|
if (!(m_usb.get() && m_usb->is_connected()))
|
|
|
|
|
return ;
|
|
|
|
|
USBCB usbcb = { SET_SLEEP_TIME ,mode&0x7,0 };
|
|
|
|
|
m_usb->write_bulk(&usbcb, sizeof(usbcb));
|
|
|
|
|
m_usb->read_bulk(&usbcb, sizeof(usbcb));
|
|
|
|
|
usbcb = { GET_SLEEP_TIME ,0,0 };
|
|
|
|
|
m_usb->write_bulk(&usbcb, sizeof(usbcb));
|
|
|
|
|
m_usb->read_bulk(&usbcb, sizeof(usbcb));
|
|
|
|
|
}
|
|
|
|
|
|
2021-04-06 01:31:21 +00:00
|
|
|
|
bool GScanO200::set_scannercode(std::string str)
|
|
|
|
|
{
|
|
|
|
|
if (str.size() != 32)
|
|
|
|
|
return false;
|
|
|
|
|
if (!(m_usb.get() && m_usb->is_connected()))
|
|
|
|
|
return false;
|
|
|
|
|
for (int i = 0; i < str.size(); i += 4)
|
|
|
|
|
{
|
|
|
|
|
USBCB usbcb = { SET_CODE_G200,UINT32(str[i]) + ((UINT32(str[i + 1])) << 8) + (((UINT32)str[i + 2]) << 16) + (((UINT32)str[i + 3]) << 24),i };
|
|
|
|
|
m_usb->write_bulk(&usbcb, sizeof(usbcb));
|
|
|
|
|
}
|
|
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
std::string GScanO200::get_scannercode()
|
|
|
|
|
{
|
|
|
|
|
if (!(m_usb.get() && m_usb->is_connected()))
|
|
|
|
|
return NULL;
|
|
|
|
|
USBCB usb{ GET_CODE_G200,0,32 };
|
|
|
|
|
m_usb->write_bulk(&usb, sizeof(USBCB));
|
|
|
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(20));
|
|
|
|
|
scannercode.resize(32);
|
|
|
|
|
m_usb->read_bulk(&scannercode[0], 32);
|
|
|
|
|
return scannercode.c_str();
|
|
|
|
|
}
|
|
|
|
|
|
2021-01-05 11:27:26 +00:00
|
|
|
|
|
2020-03-11 01:58:06 +00:00
|
|
|
|
void GScanO200::usbhotplug_callback(bool isconnect, void* userdata)
|
|
|
|
|
{
|
|
|
|
|
GScanO200* This = (GScanO200*)userdata;
|
|
|
|
|
This->usbhotplug(isconnect);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void GScanO200::usbhotplug(bool isleft)
|
|
|
|
|
{
|
2021-05-13 10:13:08 +00:00
|
|
|
|
FileTools::writelog(log_ERROR, "enable usb callback ");
|
2020-03-11 01:58:06 +00:00
|
|
|
|
if (isleft) {
|
2020-07-11 10:43:17 +00:00
|
|
|
|
devState = DEV_WRONG;
|
|
|
|
|
Error_Code = USB_DISCONNECTED;
|
|
|
|
|
m_pImages->setscanflags(false);
|
2020-07-20 02:29:10 +00:00
|
|
|
|
if (m_usb.get())
|
|
|
|
|
m_usb.reset();
|
2020-08-31 07:46:14 +00:00
|
|
|
|
if (huagods)
|
|
|
|
|
dev_callback(USB_DISCONNECTED, huagods);
|
2020-05-16 01:50:34 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void GScanO200::updateHVRatio()
|
|
|
|
|
{
|
2021-02-03 10:21:45 +00:00
|
|
|
|
if (!(m_usb.get() && m_usb->is_connected()))
|
2020-05-16 01:50:34 +00:00
|
|
|
|
return;
|
|
|
|
|
if (m_bread_fixed_ratio_fromDSP) {
|
|
|
|
|
USBCB usbcb = { GET_JUST_COF_H ,0,0 };
|
|
|
|
|
m_usb->write_bulk(&usbcb, sizeof(usbcb));
|
|
|
|
|
m_usb->read_bulk(&usbcb, sizeof(usbcb));
|
|
|
|
|
float hratio = *((float*)(&usbcb.u32_Data));
|
2020-06-20 03:13:18 +00:00
|
|
|
|
usbcb = { GET_JUST_COF_V ,0,0 };
|
2020-05-16 01:50:34 +00:00
|
|
|
|
m_usb->write_bulk(&usbcb, sizeof(usbcb));
|
|
|
|
|
m_usb->read_bulk(&usbcb, sizeof(usbcb));
|
|
|
|
|
float vratio = *((float*)(&usbcb.u32_Data));
|
|
|
|
|
m_pImages->updatefixratio(hratio, vratio);
|
2021-01-22 07:18:41 +00:00
|
|
|
|
|
2020-03-11 01:58:06 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void GScanO200::usbmain()
|
|
|
|
|
{
|
|
|
|
|
std::shared_ptr<std::vector<char>> imgData;
|
|
|
|
|
devState = DEV_ISRUNNING;
|
2020-06-20 03:13:18 +00:00
|
|
|
|
bool haveError = false;
|
2020-07-20 02:29:10 +00:00
|
|
|
|
try
|
|
|
|
|
{
|
2020-08-15 08:08:47 +00:00
|
|
|
|
StopWatch sw;
|
2020-07-20 02:29:10 +00:00
|
|
|
|
while (devState == DEV_ISRUNNING) {
|
2021-02-03 10:21:45 +00:00
|
|
|
|
if (!(m_usb.get() && m_usb->is_connected())) {
|
2020-07-20 02:29:10 +00:00
|
|
|
|
this_thread::sleep_for(chrono::milliseconds(200));
|
|
|
|
|
break;
|
|
|
|
|
}
|
2020-05-16 01:50:34 +00:00
|
|
|
|
|
2021-05-13 10:13:08 +00:00
|
|
|
|
if (sw.elapsed_ms() > 30000)
|
2020-08-15 08:08:47 +00:00
|
|
|
|
{
|
|
|
|
|
m_pImages->setscanflags(false);
|
2021-05-19 10:58:07 +00:00
|
|
|
|
//devState = haveError ? DevState::DEV_WRONG : DevState::DEV_STOP;
|
|
|
|
|
devState = DevState::DEV_WRONG;
|
|
|
|
|
Set_ErrorCode(AQUIRE_IMAGE_TIMEOUT);
|
2021-05-13 10:13:08 +00:00
|
|
|
|
FileTools::writelog(log_ERROR, "USBmain aquire image timeout");
|
2020-08-15 08:08:47 +00:00
|
|
|
|
return;
|
|
|
|
|
}
|
2020-05-16 01:50:34 +00:00
|
|
|
|
|
2020-07-20 02:29:10 +00:00
|
|
|
|
USBCB usbcb = Get_Scanner_Status();
|
|
|
|
|
switch (usbcb.u32_Data) {
|
|
|
|
|
case HAVE_IMAGE:
|
|
|
|
|
{
|
|
|
|
|
int totalNum = usbcb.u32_Count;
|
|
|
|
|
m_usb->set_timeout(2000);
|
|
|
|
|
imgData = Get_Img_Data(totalNum);
|
|
|
|
|
if (!imgData->size()) {
|
|
|
|
|
Stop_scan();
|
2021-05-13 10:13:08 +00:00
|
|
|
|
FileTools::writelog(log_ERROR,"imgData->size() error send stop scan");
|
2020-07-20 02:29:10 +00:00
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
m_usb->set_timeout(200);
|
2021-06-30 13:58:13 +00:00
|
|
|
|
if(!m_pImages->get_isDogEar())
|
|
|
|
|
m_pImages->pushMat(std::shared_ptr<IDecode>(new G200Decode(imgData)));
|
2020-07-20 02:29:10 +00:00
|
|
|
|
Pop_Image();
|
2021-07-02 03:29:24 +00:00
|
|
|
|
UpdateScanInfo(countNReaded(), get_imgTransfered());
|
|
|
|
|
FileTools::writelog(log_INFO, "<EFBFBD><EFBFBD>ɨ<EFBFBD><EFBFBD><EFBFBD>ǽ<EFBFBD><EFBFBD><EFBFBD>"+to_string(get_imgnReaded())+"<EFBFBD><EFBFBD><EFBFBD>ļ<EFBFBD><EFBFBD><EFBFBD>");
|
2020-08-15 08:08:47 +00:00
|
|
|
|
sw.reset();
|
2020-07-20 02:29:10 +00:00
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
case STOP_SCAN:
|
2021-05-19 10:58:07 +00:00
|
|
|
|
{
|
2020-07-20 02:29:10 +00:00
|
|
|
|
m_pImages->setscanflags(false);
|
2021-05-19 10:58:07 +00:00
|
|
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(1500));
|
2020-07-20 02:29:10 +00:00
|
|
|
|
devState = haveError ? DevState::DEV_WRONG : DevState::DEV_STOP;
|
|
|
|
|
//m_pImages->setscanflags(false);
|
|
|
|
|
//devState = DEV_STOP;
|
|
|
|
|
break;
|
2021-05-19 10:58:07 +00:00
|
|
|
|
}
|
2020-07-20 02:29:10 +00:00
|
|
|
|
case COUNT_MODE:
|
|
|
|
|
case NO_FEED:
|
|
|
|
|
case OPEN_COVER:
|
|
|
|
|
case FEED_IN_ERROR:
|
|
|
|
|
case PAPER_JAM:
|
|
|
|
|
case DETECT_DOUBLE_FEED:
|
|
|
|
|
case DETECT_STAPLE:
|
|
|
|
|
case PAPER_SKEW:
|
|
|
|
|
case HARDWARE_ERROR:
|
|
|
|
|
case PC_SCAN_BUSY_or_ERROR:
|
2021-06-21 11:38:36 +00:00
|
|
|
|
case SIZE_ERROR:
|
|
|
|
|
case USB_BULK_ERROR:
|
|
|
|
|
{
|
|
|
|
|
if (usbcb.u32_Data == USB_BULK_ERROR)
|
|
|
|
|
Stop_scan();
|
2020-06-20 03:13:18 +00:00
|
|
|
|
Set_ErrorCode(usbcb.u32_Data);
|
2020-07-20 02:29:10 +00:00
|
|
|
|
m_pImages->setscanflags(false);
|
|
|
|
|
devState = DEV_WRONG;
|
2021-06-21 11:38:36 +00:00
|
|
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(1500));
|
2021-05-19 10:58:07 +00:00
|
|
|
|
auto rollernew = Get_Roller_num();
|
2021-07-02 03:29:24 +00:00
|
|
|
|
if (get_imgnReaded() != (rollernew - roller_num))
|
|
|
|
|
set_lose_image_num(std::abs((rollernew - roller_num) - get_imgnReaded()));
|
2020-08-31 07:46:14 +00:00
|
|
|
|
if (huagods)
|
|
|
|
|
dev_callback(usbcb.u32_Data, huagods);
|
2020-07-20 02:29:10 +00:00
|
|
|
|
break;
|
2021-05-19 10:58:07 +00:00
|
|
|
|
}
|
2020-07-20 02:29:10 +00:00
|
|
|
|
case NORMAL:
|
|
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
this_thread::sleep_for(chrono::milliseconds(10));
|
2020-03-11 01:58:06 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
2020-07-20 02:29:10 +00:00
|
|
|
|
catch (const std::exception& e)
|
|
|
|
|
{
|
2021-05-13 10:13:08 +00:00
|
|
|
|
//writelog(e.what());
|
|
|
|
|
FileTools::writelog(log_ERROR, e.what());
|
2020-07-20 02:29:10 +00:00
|
|
|
|
}
|
2020-03-11 01:58:06 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////
|
|
|
|
|
USBCB GScanO200::Get_Scanner_Status()
|
|
|
|
|
{
|
2021-02-03 10:21:45 +00:00
|
|
|
|
if (!(m_usb.get() && m_usb->is_connected())) {
|
2020-03-11 01:58:06 +00:00
|
|
|
|
return { NO_COMMAND ,PC_SCAN_BUSY_or_ERROR ,0 };
|
|
|
|
|
}
|
2020-07-20 02:29:10 +00:00
|
|
|
|
|
2020-03-11 01:58:06 +00:00
|
|
|
|
USBCB usbcb = { GET_DSP_STATUS ,0,0 };
|
2020-07-20 02:29:10 +00:00
|
|
|
|
if (m_usb.get() && m_usb->is_connected())
|
|
|
|
|
m_usb->write_bulk(&usbcb, sizeof(usbcb));
|
|
|
|
|
|
|
|
|
|
if (m_usb.get() && m_usb->is_connected())
|
|
|
|
|
m_usb->read_bulk(&usbcb, sizeof(usbcb));
|
2020-03-11 01:58:06 +00:00
|
|
|
|
return usbcb;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
std::shared_ptr<std::vector<char>> GScanO200::Get_Img_Data(int bufferSize)
|
|
|
|
|
{
|
2021-05-13 10:13:08 +00:00
|
|
|
|
try
|
2020-11-12 11:35:20 +00:00
|
|
|
|
{
|
2021-05-13 10:13:08 +00:00
|
|
|
|
if (!(m_usb.get() && m_usb->is_connected()))
|
|
|
|
|
return std::shared_ptr<std::vector<char>>(new std::vector<char>());
|
|
|
|
|
|
|
|
|
|
std::shared_ptr<std::vector<char>> imData(new std::vector<char>(bufferSize));
|
|
|
|
|
StopWatch sw;
|
|
|
|
|
int readed = 0;
|
|
|
|
|
USBCB usbcb = { GET_IMAGE,0,bufferSize };
|
|
|
|
|
m_usb->write_bulk(&usbcb, sizeof(usbcb));
|
|
|
|
|
int totalength = bufferSize;
|
|
|
|
|
int startindex = 0;
|
|
|
|
|
while (totalength > 0)
|
2020-11-12 11:35:20 +00:00
|
|
|
|
{
|
2021-05-20 10:17:37 +00:00
|
|
|
|
int dstlength = 512 * 1024;
|
2021-05-13 10:13:08 +00:00
|
|
|
|
if (totalength <= dstlength)
|
|
|
|
|
{
|
|
|
|
|
dstlength = totalength;
|
|
|
|
|
totalength = 0;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
totalength -= dstlength;
|
|
|
|
|
|
|
|
|
|
int tt = m_usb->read_bulk(imData->data() + startindex, dstlength);
|
|
|
|
|
startindex += dstlength;
|
2020-11-12 11:35:20 +00:00
|
|
|
|
}
|
|
|
|
|
|
2021-05-13 10:13:08 +00:00
|
|
|
|
if (sw.elapsed_ms() > 5000)
|
|
|
|
|
{
|
|
|
|
|
FileTools::writelog(log_ERROR,"Usb read data timeout\n");
|
|
|
|
|
}
|
|
|
|
|
return imData;
|
2020-03-11 01:58:06 +00:00
|
|
|
|
}
|
2021-05-13 10:13:08 +00:00
|
|
|
|
catch (const std::exception& e)
|
2020-11-12 11:35:20 +00:00
|
|
|
|
{
|
2021-05-13 10:13:08 +00:00
|
|
|
|
FileTools::writelog(log_ERROR, e.what());
|
2020-03-11 01:58:06 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////
|
|
|
|
|
void GScanO200::Pop_Image()
|
|
|
|
|
{
|
2021-02-03 10:21:45 +00:00
|
|
|
|
if (!(m_usb.get() && m_usb->is_open()))
|
2020-03-11 01:58:06 +00:00
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
USBCB usbcb = { POP_IMAGE ,0,0 };
|
|
|
|
|
m_usb->write_bulk(&usbcb, sizeof(usbcb));
|
|
|
|
|
}
|