764 lines
16 KiB
C++
764 lines
16 KiB
C++
#include "stdafx.h"
|
||
#include "gscn_drv.h"
|
||
#include "stdio.h"
|
||
#include "turbojpeg.h"
|
||
#include <map>
|
||
#include "jpeglib.h"
|
||
#include "HuaGoCorrect.h"
|
||
#include "HuaGoCorrectDlg.h"
|
||
#include <Windows.h>
|
||
#include "twain.h"
|
||
#include "filetools.h"
|
||
#include "scn_usb.h"
|
||
|
||
//#define BYTE unsigned char
|
||
|
||
GScn_Drv::GScn_Drv()
|
||
:selectDeviceIndex(-1),m_scannerType(-1),m_isScanning(false)
|
||
{
|
||
//run();
|
||
|
||
XdPrint("Init GScn_Drv() \n");
|
||
|
||
m_bRun = false;
|
||
devState = DEV_STOP;
|
||
InitMSGMap();
|
||
InitScannerDiviceMap();
|
||
|
||
|
||
}
|
||
|
||
GScn_Drv::~GScn_Drv()
|
||
{
|
||
if (m_threadUsb.joinable())
|
||
{
|
||
m_bRun = false;
|
||
devState = DEV_STOP;
|
||
m_threadUsb.join();
|
||
XdPrint("m_threadUsb Released True 22222222222222222222222 \n");
|
||
}
|
||
XdPrint("~ GScn_Drv() \n");
|
||
}
|
||
|
||
void GScn_Drv::InitMSGMap()
|
||
{
|
||
if (ntcMsg.size()>0)
|
||
ntcMsg.clear();
|
||
ntcMsg[COUNT_MODE]="计数模式，请先退出计数模式！";
|
||
ntcMsg[NO_FEED]="无纸，请放置纸张！";
|
||
ntcMsg[OPEN_COVER]="扫描仪开盖！";
|
||
ntcMsg[FEED_IN_ERROR]="拾纸错误！";
|
||
ntcMsg[PAPER_JAM]="卡纸！";
|
||
ntcMsg[DETECT_DOUBLE_FEED]="双张！";
|
||
ntcMsg[DETECT_STAPLE]="订书针！";
|
||
ntcMsg[PAPER_SKEW]="纸张歪斜！";
|
||
ntcMsg[HARDWARE_ERROR]="硬件错误！";
|
||
ntcMsg[PC_SCAN_BUSY_or_ERROR]="PC错误！";
|
||
}
|
||
|
||
|
||
void GScn_Drv::InitScannerDiviceMap()
|
||
{
|
||
if (devType.size()>0)
|
||
{
|
||
devType.clear();
|
||
}
|
||
devType["G100"]=G100;
|
||
devType["G200"]=G200;
|
||
devType["G300"]=G300;
|
||
devType["G400"]=G400;
|
||
devType["G500"]=G500;
|
||
}
|
||
|
||
static int iNum = 0;
|
||
|
||
void GScn_Drv::open(int vid, int pid,int index)
|
||
{
|
||
auto devs = UsbScan_List::find_vid_pid(vid, pid);
|
||
|
||
if (devs.size() != 0)
|
||
{
|
||
m_usb = *devs.begin();
|
||
m_usb->open();//同时存在多个同种扫描设备时，默认选取第一个vid pid匹配的设备
|
||
selectDeviceIndex=index;
|
||
m_scannerType=G300;
|
||
h= ::FindWindow(NULL, "HGScannerTool");
|
||
}
|
||
}
|
||
|
||
static void DoEvents()
|
||
{
|
||
MSG msg;
|
||
if (PeekMessage(&msg
|
||
, NULL, 0, 0, PM_REMOVE))
|
||
{
|
||
DispatchMessage(&msg);
|
||
|
||
TranslateMessage(&msg);
|
||
}
|
||
}
|
||
|
||
std::string GScn_Drv::popMat(int num)
|
||
{
|
||
auto image = m_pImages.popMat(num);
|
||
return image;
|
||
}
|
||
|
||
|
||
int GScn_Drv::aquire_image(std::string& image,int num)
|
||
{
|
||
while (true)
|
||
{
|
||
if (this->Get_IsImageQueueEmpty())
|
||
{
|
||
DoEvents();
|
||
if (!this->is_scan())
|
||
break;
|
||
}
|
||
else
|
||
{
|
||
if (m_pImages.valid())
|
||
{
|
||
image = popMat(num);
|
||
return 0;
|
||
}
|
||
}
|
||
}
|
||
return -1;
|
||
}
|
||
|
||
int GScn_Drv::getMatSum()
|
||
{
|
||
int iSum = 0;
|
||
iSum = m_pImages.getMatSum();
|
||
return iSum;
|
||
}
|
||
|
||
void GScn_Drv::close()
|
||
{
|
||
m_usb->close();
|
||
}
|
||
|
||
void GScn_Drv::GetExpose(int& Aside, int& Bside)
|
||
{
|
||
USBCB asideexp = { GET_UV_EXPOSA,0,0 };
|
||
m_usb->write_bulk(&asideexp, sizeof(asideexp));
|
||
m_usb->read_bulk(&asideexp, sizeof(asideexp));
|
||
Aside = asideexp.u32_Data;
|
||
USBCB bsideexp = { GET_UV_EXPOSB,0,0 };
|
||
m_usb->write_bulk(&bsideexp, sizeof(asideexp));
|
||
m_usb->read_bulk(&bsideexp, sizeof(asideexp));
|
||
Bside = bsideexp.u32_Data;
|
||
|
||
}
|
||
|
||
void GScn_Drv::SetExpose(int aside, int bside)
|
||
{
|
||
USBCB asideexp = { SET_UV_EXPOSA,aside,0 };
|
||
m_usb->write_bulk(&asideexp, sizeof(asideexp));
|
||
USBCB bsideexp = { SET_UV_EXPOSB,bside,0 };
|
||
m_usb->write_bulk(&bsideexp, sizeof(bsideexp));
|
||
|
||
}
|
||
|
||
void GScn_Drv::GetSptime(int type, int& time)
|
||
{
|
||
USBCB usb = {0,0,0};
|
||
switch (type)
|
||
{
|
||
case 0:
|
||
usb.u32_CMD = 0x100;//GET_GRAY_SP
|
||
break;
|
||
case 1:
|
||
usb.u32_CMD = 0x102;//GET_COLOR_SP
|
||
break;
|
||
case 2:
|
||
usb.u32_CMD = 0x104;//GET_UV_SP
|
||
break;
|
||
default:
|
||
break;
|
||
}
|
||
m_usb->write_bulk(&usb, sizeof(usb));
|
||
m_usb->read_bulk(&usb, sizeof(usb));
|
||
time = usb.u32_Data;
|
||
}
|
||
|
||
void GScn_Drv::SetSptime(int type, int time)
|
||
{
|
||
USBCB usb = { 0,time,0 };
|
||
switch (type)
|
||
{
|
||
case 0:
|
||
usb.u32_CMD = 0x101;//GET_GRAY_SP
|
||
break;
|
||
case 1:
|
||
usb.u32_CMD = 0x103;//GET_COLOR_SP
|
||
break;
|
||
case 2:
|
||
usb.u32_CMD = 0x105;//GET_UV_SP
|
||
break;
|
||
default:
|
||
break;
|
||
}
|
||
m_usb->write_bulk(&usb, sizeof(usb));
|
||
}
|
||
|
||
void GScn_Drv::GetSleepTime(int& sleeptime)
|
||
{
|
||
if (m_usb.get() && m_usb->is_connected())
|
||
{
|
||
USBCB usb = { GET_SLEEP_TIME,0,0 };
|
||
m_usb->write_bulk(&usb, sizeof(usb));
|
||
m_usb->read_bulk(&usb, sizeof(usb));
|
||
sleeptime=usb.u32_Data;
|
||
}
|
||
}
|
||
|
||
void GScn_Drv::SetSleepTime(int sleeptime)
|
||
{
|
||
if (m_usb.get() && m_usb->is_connected())
|
||
{
|
||
USBCB usb = { SET_SLEEP_TIME,sleeptime,0 };
|
||
m_usb->write_bulk(&usb, sizeof(usb));
|
||
}
|
||
}
|
||
|
||
void GScn_Drv::reset()
|
||
{
|
||
while (!m_pImages.empty())
|
||
{
|
||
m_pImages.clear();
|
||
}
|
||
}
|
||
|
||
void GScn_Drv::pushMat(JpegBuffer& data)
|
||
{
|
||
std::lock_guard<std::mutex> lck(m_imgLocker);
|
||
m_pImages.pushMat(data);
|
||
}
|
||
|
||
bool GScn_Drv::IsConnected()
|
||
{
|
||
if(m_usb.get())
|
||
return m_usb->is_connected();
|
||
else
|
||
return false;
|
||
|
||
}
|
||
|
||
|
||
cv::Mat GScn_Drv::Get_Img_Data(int bufferSize)
|
||
{
|
||
std::lock_guard<std::mutex> lck(m_Locker);
|
||
cv::Mat iData(1, bufferSize,CV_8UC1);
|
||
USBCB usbcb = { GET_IMAGE,0,bufferSize };
|
||
DWORD transfer;
|
||
|
||
m_usb->write_bulk(&usbcb, sizeof(usbcb));
|
||
m_usb->read_bulk(iData.data, bufferSize);
|
||
return iData;
|
||
}
|
||
|
||
void GScn_Drv::run()
|
||
{
|
||
//m_isScanning=false;
|
||
if (m_threadUsb.joinable())
|
||
{
|
||
m_bRun = false;
|
||
devState = DEV_STOP;
|
||
m_threadUsb.join();
|
||
}
|
||
m_bRun = true;
|
||
devState = DEV_ISRUNNING;
|
||
m_threadUsb = std::thread(&GScn_Drv::usbmain, this);
|
||
}
|
||
|
||
|
||
void GScn_Drv::ActiveteUSB()
|
||
{
|
||
if (IsConnected())
|
||
{
|
||
DWORD transfer;
|
||
USBCB usbcb = { 1024,0 ,0 };
|
||
m_usb->write_bulk(&usbcb, sizeof(usbcb));
|
||
}
|
||
}
|
||
|
||
bool GScn_Drv::Updata(std::string filename, std::function<void(long, long)> func)
|
||
{
|
||
std::ifstream updatefile;
|
||
updatefile.open(filename, std::ios_base::in | std::ios_base::binary);
|
||
if (!updatefile.is_open())
|
||
{
|
||
return false;
|
||
}
|
||
updatefile.seekg(0, std::ios::end);
|
||
size_t length = updatefile.tellg();
|
||
func(0, length);
|
||
updatefile.seekg(0, std::ios::beg);
|
||
USBCB pre_update = { PRE_UPGRADE,0,length };
|
||
m_usb->write_bulk(&pre_update, sizeof(pre_update));
|
||
size_t nreaded = 0;
|
||
size_t nleft = length;
|
||
int buffersize = 1024 * 1024;
|
||
if (length <= buffersize)//小于1MB
|
||
{
|
||
char* uotstream = new char[length];
|
||
USBCB update = { START_UPGRADE,0,length };
|
||
m_usb->write_bulk(&update, sizeof(update));
|
||
updatefile.read(uotstream, length);
|
||
m_usb->write_bulk(uotstream, length);
|
||
m_usb->read_bulk(&update, sizeof(update));
|
||
if (update.u32_Count != length)
|
||
return false;
|
||
delete[] uotstream;
|
||
}
|
||
else
|
||
{
|
||
while (true)
|
||
{
|
||
int ntotransfer;
|
||
if (nleft < buffersize)
|
||
ntotransfer = nleft;
|
||
else
|
||
ntotransfer = buffersize;
|
||
USBCB update = { START_UPGRADE,0,ntotransfer };
|
||
m_usb->write_bulk(&update, sizeof(update));
|
||
std::vector<char> data;
|
||
data.resize(ntotransfer);
|
||
updatefile.read(data.data(), ntotransfer);
|
||
m_usb->write_bulk(data.data(), ntotransfer);
|
||
m_usb->read_bulk(&update, sizeof(update));
|
||
nreaded += ntotransfer;
|
||
nleft -= ntotransfer;
|
||
func(nreaded, length);
|
||
if (nreaded >= length)
|
||
break;
|
||
this_thread::sleep_for(std::chrono::milliseconds(10));
|
||
}
|
||
}
|
||
|
||
USBCB updatefinished = { UPDATE_FINISHED,0,0 };
|
||
m_usb->write_bulk(&updatefinished, sizeof(updatefinished));
|
||
return true;
|
||
}
|
||
|
||
|
||
DWORD GScn_Drv::usbmain()
|
||
{
|
||
try
|
||
{
|
||
while (m_bRun)
|
||
{
|
||
if (devState==DEV_ISRUNNING)
|
||
{
|
||
if (!IsConnected())
|
||
{
|
||
Sleep(200);
|
||
continue;
|
||
}
|
||
USBCB usbcb = Get_Scanner_Status();
|
||
switch (usbcb.u32_Data)
|
||
{
|
||
case HAVE_IMAGE:
|
||
{
|
||
int totalNum = usbcb.u32_Count;
|
||
DWORD transferCount = 0;
|
||
iNum++;
|
||
cv::Mat imgData = Get_Img_Data(totalNum);
|
||
switch(m_scannerType)
|
||
{
|
||
case G100:
|
||
case G200:
|
||
{
|
||
cv::Mat bufferF = imgData.clone();
|
||
cv::Mat bufferB = imgData.clone();
|
||
int j = 0;
|
||
int k = 0;
|
||
for (int i = 0; i < totalNum / 1024; i++)
|
||
{
|
||
if (imgData.data[1023 + i * 1024] == 0)
|
||
{
|
||
j++;
|
||
memcpy(&(bufferB.data[(j - 1) * 1023]), &(imgData.data[(j + k - 1) * 1024]), 1023);
|
||
}
|
||
else if (imgData.data[1023 + i * 1024] == 255)
|
||
{
|
||
k++;
|
||
memcpy(&(bufferF.data[(k - 1) * 1023]), &(imgData.data[(j + k - 1) * 1024]), 1023);
|
||
}
|
||
}
|
||
pushMat(JpegBuffer(bufferB,m_config.g200params.color==1?TJPF_BGR:TJPF_GRAY,0,0));
|
||
pushMat(JpegBuffer(bufferF, m_config.g200params.color == 1 ? TJPF_BGR : TJPF_GRAY,1,0));
|
||
break;
|
||
}
|
||
case G300:
|
||
case G400:
|
||
case G500:
|
||
pushMat(JpegBuffer(imgData, m_config.g200params.color == 1 ? TJPF_BGR : TJPF_GRAY,0,0));
|
||
break;
|
||
default:
|
||
break;
|
||
}
|
||
Pop_Image();
|
||
break;
|
||
}
|
||
case STOP_SCAN:
|
||
{
|
||
m_isScanning=false;
|
||
devState = DEV_STOP;
|
||
m_pImages.SetScanFlag(false);
|
||
break;
|
||
}
|
||
case AUTO_FLAT_FINISHED:
|
||
{
|
||
m_isScanning = false;
|
||
devState = DEV_STOP;
|
||
MessageBox(NULL,TEXT("自动校正已完成！"), TEXT("提示"), MB_OK);
|
||
}
|
||
break;
|
||
case COUNT_MODE:
|
||
case NO_FEED:
|
||
case OPEN_COVER:
|
||
case FEED_IN_ERROR:
|
||
case DETECT_DOUBLE_FEED:
|
||
case DETECT_STAPLE:
|
||
case PAPER_SKEW:
|
||
case HARDWARE_ERROR:
|
||
case PC_SCAN_BUSY_or_ERROR:
|
||
MessageBox(h, ntcMsg[usbcb.u32_Data].c_str(), "提示", MB_OK | MB_ICONERROR);
|
||
devState = DEV_WRONG;
|
||
m_pImages.SetScanFlag(false);
|
||
break;
|
||
case NORMAL:
|
||
break;
|
||
default:
|
||
break;
|
||
}
|
||
this_thread::sleep_for(std::chrono::milliseconds(20));
|
||
}
|
||
}
|
||
return 0;
|
||
}
|
||
catch (CMemoryException* e)
|
||
{
|
||
XdPrint("CMemoryException");
|
||
}
|
||
catch (CFileException* e)
|
||
{
|
||
XdPrint("CFileException");
|
||
}
|
||
catch (CException* e)
|
||
{
|
||
XdPrint("CException");
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
///////////////////////////////////////////////////////////////////////////
|
||
void GScn_Drv::Config_Scanner(PUSBCB pUSBCB)
|
||
{
|
||
if (m_usb->is_connected())
|
||
{
|
||
std::lock_guard<std::mutex> lck(m_imgLocker);
|
||
DWORD transfer;
|
||
m_usb->write_bulk(pUSBCB, sizeof(USBCB));
|
||
}
|
||
}
|
||
|
||
void GScn_Drv::Config_Scanner(HGScanConfig config)
|
||
{
|
||
m_config = config;
|
||
USBCB usbcb = { CONFIGURED_DATA ,m_config.value,0 };
|
||
if (m_usb->is_connected())
|
||
{
|
||
std::lock_guard<std::mutex> lck(m_imgLocker);
|
||
DWORD transfer;
|
||
m_usb->write_bulk(&usbcb, sizeof(USBCB));
|
||
}
|
||
}
|
||
|
||
///////////////////////////////////////////////////////////////////////////
|
||
void GScn_Drv::Scanner_StartScan(UINT16 count)
|
||
{
|
||
//count = 0;
|
||
//XdPrint("Scanner_StartScan.............\n");
|
||
if (m_usb->is_connected())
|
||
{
|
||
//XdPrint("Scanner Isconnected.............\n");
|
||
std::lock_guard<std::mutex> lck(m_imgLocker);
|
||
DWORD transfer;
|
||
USBCB usbcb = { START_COMMAND,AUTO_SCAN_MODE ,0 };
|
||
m_usb->write_bulk(&usbcb, sizeof(usbcb));
|
||
iNum = 0;
|
||
m_pImages.pixType=m_config.g200params.color;
|
||
m_pImages.SetDevModel(m_scannerType);
|
||
m_pImages.SetFilePath(csPath);
|
||
m_pImages.run();
|
||
m_pImages.SetScanFlag(true);
|
||
run();
|
||
}
|
||
}
|
||
|
||
///////////////////////////////////////////////////////////////////////////
|
||
std::string GScn_Drv::GetFWVersion()
|
||
{
|
||
if (m_usb->is_connected())
|
||
{
|
||
std::lock_guard<std::mutex> lck(m_imgLocker);
|
||
std::string pFWVersion = " ";
|
||
USBCB usbcb = { GET_FW_VERSION,0,0 };
|
||
XdPrint("Get GetFWVersion");
|
||
m_usb->write_bulk(&usbcb, sizeof(usbcb));
|
||
|
||
CString cslog;
|
||
cslog.Format("GetFWVersion Read_Data %d",usbcb.u32_Data);
|
||
|
||
m_usb->read_bulk(&pFWVersion[0], 10);
|
||
return pFWVersion;
|
||
}
|
||
return "";
|
||
}
|
||
|
||
void GScn_Drv::SetFWVersion()
|
||
{
|
||
if (m_usb->is_connected())
|
||
{
|
||
std::lock_guard<std::mutex> lck(m_imgLocker);
|
||
|
||
}
|
||
}
|
||
|
||
void GScn_Drv::SetSerialNum(std::string pvalue)
|
||
{
|
||
if (m_usb->is_connected())
|
||
{
|
||
std::lock_guard<std::mutex> lck(m_imgLocker);
|
||
USBCB sercmd = { SEND_SERIAL ,0,14};
|
||
m_usb->write_bulk(&sercmd, sizeof(sercmd));
|
||
m_usb->write_bulk(&pvalue, pvalue.length());
|
||
}
|
||
return;
|
||
}
|
||
|
||
int GScn_Drv::GetScanNum()
|
||
{
|
||
std::lock_guard<std::mutex> lck(m_imgLocker);
|
||
USBCB usbcb = { GET_SCANN_NUM,0,4 };
|
||
DWORD transfer;
|
||
XdPrint("Get GetScanNum");
|
||
m_usb->write_bulk(&usbcb, sizeof(usbcb));
|
||
|
||
CString cslog;
|
||
cslog.Format("GetScanNum Read_Data %d",usbcb.u32_Data);
|
||
//WriteLog(cslog);
|
||
|
||
m_usb->read_bulk(&usbcb, sizeof(usbcb));
|
||
return usbcb.u32_Data;
|
||
}
|
||
|
||
void GScn_Drv::ClrRollerNum()
|
||
{
|
||
std::lock_guard<std::mutex> lck(m_imgLocker);
|
||
USBCB usbcb = { CLR_ROLLER_NUM,0,4 };
|
||
DWORD transfer;
|
||
XdPrint("Get ClrRollerNum");
|
||
m_usb->write_bulk(&usbcb, sizeof(usbcb));
|
||
return;
|
||
}
|
||
|
||
void GScn_Drv::ClrScanNum()
|
||
{
|
||
std::lock_guard<std::mutex> lck(m_imgLocker);
|
||
USBCB usbcb = { CLR_SCAN_NUM,0,4 };
|
||
DWORD transfer;
|
||
XdPrint("Get ClrScanNum");
|
||
m_usb->write_bulk(&usbcb, sizeof(usbcb));
|
||
return;
|
||
}
|
||
|
||
void GScn_Drv::SendFlatData(CorrectParam param, int index)
|
||
{
|
||
UsbKeyWords keyword;
|
||
switch (index)
|
||
{
|
||
case 0:
|
||
keyword = SEND_COLORCORRECT_FLAT;
|
||
break;
|
||
case 1:
|
||
keyword = SEND_COLOR_FLAT;
|
||
break;
|
||
case 2:
|
||
keyword = SEND_GRAYCORRECT_FLAT;
|
||
break;
|
||
case 3:
|
||
keyword = SEND_GRAY_FLAT;
|
||
break;
|
||
default:
|
||
break;
|
||
}
|
||
USBCB cmd = { keyword ,0,0 };
|
||
m_usb->write_bulk(&cmd, sizeof(cmd));
|
||
m_usb->write_bulk(¶m, sizeof(param));
|
||
}
|
||
|
||
CaptureParams GScn_Drv::GetFlatData()
|
||
{
|
||
CaptureParams param = {0};
|
||
USBCB usbcb = { GET_FLAT_DATA,0,0 };
|
||
DWORD transfer;
|
||
m_usb->write_bulk(&usbcb, sizeof(usbcb));
|
||
m_usb->read_bulk(¶m, sizeof(param));
|
||
return param;
|
||
}
|
||
|
||
void GScn_Drv::StartFlat(bool iscolor)
|
||
{
|
||
if (!m_usb->is_connected())
|
||
return;
|
||
|
||
USBCB usbcb = { START_FLAT,0,0 };
|
||
DWORD transfer;
|
||
m_usb->write_bulk(&usbcb, sizeof(usbcb));
|
||
if (m_threadUsb.joinable()) {
|
||
m_bRun = false;
|
||
devState = DEV_STOP;
|
||
m_threadUsb.join();
|
||
}
|
||
m_bRun = true;
|
||
devState = DEV_ISRUNNING;
|
||
m_threadUsb = std::thread(&GScn_Drv::usbmain, this);
|
||
}
|
||
|
||
void GScn_Drv::DevStateChange()
|
||
{
|
||
devState = DEV_STOP;
|
||
}
|
||
|
||
///////////////////////////////////////////////////////////////////////////
|
||
std::string GScn_Drv::GetSerialNum()
|
||
{
|
||
if (!m_usb.get()&&!m_usb->is_connected())
|
||
{
|
||
return "";
|
||
}
|
||
|
||
std::lock_guard<std::mutex> lck(m_imgLocker);
|
||
std::string str;
|
||
str.resize(14);
|
||
USBCB usbcb = { GET_SERIAL,0,14 };
|
||
m_usb->write_bulk(&usbcb, sizeof(usbcb));
|
||
XdPrint("GetSerialNum Read_Data %d",usbcb.u32_Data);
|
||
m_usb->read_bulk(&str, 14);
|
||
return str;
|
||
}
|
||
|
||
void GScn_Drv::SetRatio(int tyepe, int ration)
|
||
{
|
||
UsbKeyWords keyword = tyepe == 0 ? SET_JUST_COF_H : SET_JUST_COF_V;
|
||
USBCB cmd = { keyword ,ration,0};
|
||
m_usb->write_bulk(&cmd, sizeof(cmd));
|
||
}
|
||
|
||
void GScn_Drv::GetRatio(int type, int& ratio)
|
||
{
|
||
UsbKeyWords keyword = type == 0 ? GET_JUST_COF_H : GET_JUST_COF_V;
|
||
USBCB cmd = { keyword ,0,0 };
|
||
m_usb->write_bulk(&cmd, sizeof(cmd));
|
||
m_usb->read_bulk(&cmd, sizeof(cmd));
|
||
ratio = cmd.u32_Data;
|
||
}
|
||
|
||
void GScn_Drv::Reboot()
|
||
{
|
||
USBCB cmd = { REBOOT,0,0 };
|
||
m_usb->write_bulk(&cmd, sizeof(cmd));
|
||
}
|
||
|
||
///////////////////////////////////////////////////////////////////////////
|
||
USBCB GScn_Drv::Get_Scanner_Status()
|
||
{
|
||
std::lock_guard<std::mutex> lck(m_imgLocker);
|
||
if (!m_usb->is_connected())
|
||
{
|
||
//XdPrint("Get_Scanner_Status Error\n");
|
||
USBCB errorType = { NO_COMMAND ,PC_SCAN_BUSY_or_ERROR ,0 };
|
||
return errorType;
|
||
}
|
||
|
||
//XdPrint("Get_Scanner_Status GET_DSP_STATUS write_bulk\n");
|
||
USBCB usbcb = { GET_DSP_STATUS ,0,0 };
|
||
DWORD transfer;
|
||
m_usb->write_bulk(&usbcb, sizeof(usbcb));
|
||
|
||
//XdPrint("Get_Scanner_Status Read_Data %d \n",usbcb.u32_Data);
|
||
|
||
m_usb->read_bulk(&usbcb,sizeof(usbcb));
|
||
|
||
//XdPrint("Get_Scanner_Status return usbcb \n",usbcb.u32_Data);
|
||
return usbcb;
|
||
}
|
||
|
||
///////////////////////////////////////////////////////////////////////////
|
||
bool GScn_Drv::is_scan()
|
||
{
|
||
return devState==DEV_ISRUNNING;
|
||
}
|
||
|
||
///////////////////////////////////////////////////////////////////////////
|
||
bool GScn_Drv::Get_Scanner_PaperOn()
|
||
{
|
||
if (!m_usb->is_connected())
|
||
{
|
||
return false;
|
||
}
|
||
USBCB usbcb = { GET_PAPERFEEDER_STATUS ,0,0 };
|
||
DWORD transfer;
|
||
std::lock_guard<std::mutex> lck(m_imgLocker);
|
||
m_usb->write_bulk(&usbcb, sizeof(usbcb));
|
||
m_usb->read_bulk(&usbcb, sizeof(usbcb));
|
||
return usbcb.u32_Data != 0;
|
||
}
|
||
|
||
///////////////////////////////////////////////////////////////////////////
|
||
void GScn_Drv::Pop_Image()
|
||
{
|
||
if (!m_usb->is_connected())
|
||
{
|
||
return;
|
||
}
|
||
std::lock_guard<std::mutex> lck(m_imgLocker);
|
||
USBCB usbcb = { POP_IMAGE ,0,0 };
|
||
DWORD transfer;
|
||
m_usb->write_bulk(&usbcb, sizeof(usbcb));
|
||
}
|
||
|
||
///////////////////////////////////////////////////////////////////////////
|
||
void GScn_Drv::Stop_scan()
|
||
{
|
||
if (!m_usb->is_connected())
|
||
{
|
||
return;
|
||
}
|
||
std::lock_guard<std::mutex> lck(m_imgLocker);
|
||
USBCB usbcb = { STOP ,0,0 };
|
||
DWORD transfer;
|
||
m_usb->write_bulk(&usbcb, sizeof(usbcb));
|
||
}
|
||
|
||
void GScn_Drv::ResetScanner()
|
||
{
|
||
if (!m_usb->is_connected())
|
||
return;
|
||
|
||
std::lock_guard<std::mutex> lck(m_imgLocker);
|
||
USBCB usbcb = { INIT_HARDWARE_SYS ,0,0 };
|
||
DWORD transfer;
|
||
m_usb->write_bulk(&usbcb, sizeof(usbcb));
|
||
}
|
||
|
||
///////////////////////////////////////////////////////////////////////////
|
||
bool GScn_Drv::Get_IsImageQueueEmpty()
|
||
{
|
||
return m_pImages.empty();
|
||
} |