lmh188
/
huago-corrcet_tools
mirror of http://192.168.1.51:8099/lmh188/huago-corrcet_-tools
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
huago-corrcet_tools/HuaGoCorrect/gscn_drv.cpp

894 lines
19 KiB
C++
Raw Normal View History

first init
2020-08-31 08:08:50 +00:00
#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"
//extern CHuaGoCorrectDlg theApp;
//#define BYTE unsigned char
GScn_Drv::GScn_Drv()
: canUseDiscardBlank(false),selectDeviceIndex(-1),m_scannerType(-1)
, device_id(0)
{
XdPrint("Init GScn_Drv() \n");
devState = DEV_STOP;
isDuplex=TRUE;
InitMSGMap();
InitScannerDiviceMap();
}
GScn_Drv::~GScn_Drv()
{
if (m_threadUsb.joinable())
{
devState = DEV_STOP;
m_threadUsb.join();
XdPrint("m_threadUsb Released True 22222222222222222222222 \n");
}
XdPrint("~ GScn_Drv() \n");
}
void GScn_Drv::save_config(bool saveOrigin, bool saveFixedOrigin)
{
m_pImages.UpdateSaveConfig(saveOrigin, saveFixedOrigin);
}
void GScn_Drv::InitMSGMap()
{
if (ntcMsg.size()>0)
ntcMsg.clear();
ntcMsg[COUNT_MODE]="<EFBFBD><EFBFBD><EFBFBD><EFBFBD>ģʽ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>˳<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ģʽ<EFBFBD><EFBFBD>";
ntcMsg[NO_FEED]="<EFBFBD><EFBFBD>ֽ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ֽ<EFBFBD>ţ<EFBFBD>";
ntcMsg[OPEN_COVER]="ɨ<EFBFBD><EFBFBD><EFBFBD>ǿ<EFBFBD><EFBFBD>ǣ<EFBFBD>";
ntcMsg[FEED_IN_ERROR]="ʰֽ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>";
ntcMsg[PAPER_JAM]="<EFBFBD><EFBFBD>ֽ<EFBFBD><EFBFBD>";
ntcMsg[DETECT_DOUBLE_FEED]="˫<EFBFBD>ţ<EFBFBD>";
ntcMsg[DETECT_STAPLE]="<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>룡";
ntcMsg[PAPER_SKEW]="ֽ<EFBFBD><EFBFBD><EFBFBD><EFBFBD>б<EFBFBD><EFBFBD>";
ntcMsg[HARDWARE_ERROR]="Ӳ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>";
ntcMsg[PC_SCAN_BUSY_or_ERROR]="PC<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>";
}
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)
{
usb_scan_dev devs = Devices(vid, pid);
if (devs._NumberOfDevs != 0)
{
device_id = devs._CURNUMBER;
m_usb.open(devs.dev_infos[index].index);//ͬʱ<CDAC><CAB1><EFBFBD>ڶ<EFBFBD><DAB6><EFBFBD>ͬ<EFBFBD><CDAC>ɨ<EFBFBD><C9A8><EFBFBD>豸ʱ<E8B1B8><CAB1>Ĭ<EFBFBD><C4AC>ѡȡ<D1A1><C8A1>һ<EFBFBD><D2BB>vid pidƥ<64><C6A5><EFBFBD><EFBFBD><EFBFBD>豸
selectDeviceIndex=index;
m_scannerType=G200;
}
}
void GScn_Drv::open(int vid)
{
usb_scan_dev devs = Devices(vid);
if (devs._NumberOfDevs != 0)
{
device_id = devs._CURNUMBER;
m_usb.open(devs.dev_infos[0].index);//ͬʱ<CDAC><CAB1><EFBFBD>ڶ<EFBFBD><DAB6><EFBFBD>ͬ<EFBFBD><CDAC>ɨ<EFBFBD><C9A8><EFBFBD>豸ʱ<E8B1B8><CAB1>Ĭ<EFBFBD><C4AC>ѡȡ<D1A1><C8A1>һ<EFBFBD><D2BB>vid pidƥ<64><C6A5><EFBFBD><EFBFBD><EFBFBD>豸
selectDeviceIndex = 0;
m_scannerType = G200;
}
}
void GScn_Drv::close()
{
if (m_usb.is_connected())
{
m_usb.close();
}
}
static void DoEvents()
{
MSG msg;
if (PeekMessage(&msg
, NULL, 0, 0, PM_REMOVE))
{
DispatchMessage(&msg);
TranslateMessage(&msg);
}
}
cv::Mat GScn_Drv::popMat(int num)
{
cv::Mat image = m_pImages.popMat(num);
return image;
}
int GScn_Drv::aquire_image(cv::Mat& image,int num)
{
while (true)
{
if (Get_IsImageQueueEmpty())
{
DoEvents();
if (!is_scan())
break;
}
else
{
if (m_pImages.valid())
{
image = popMat(num);
return 0;
}
}
this_thread::sleep_for(std::chrono::milliseconds(2));
}
return -1;
}
int GScn_Drv::aquire_image(cv::Mat & image)
{
while (true)
{
if (Get_IsImageQueueEmpty())
{
DoEvents();
if (!is_scan())
break;
}
else
{
if (m_pImages.valid())
{
image = m_pImages.popMat();
return 0;
}
}
this_thread::sleep_for(std::chrono::milliseconds(2));
}
return -1;
}
int GScn_Drv::getMatSum()
{
int iSum = 0;
iSum = m_pImages.getMatSum();
return iSum;
}
void GScn_Drv::reset()
{
while (!m_pImages.empty())
{
m_pImages.clear();
}
}
void GScn_Drv::pushMat(JpegBuffer& data)
{
m_pImages.pushMat(data);
}
BOOL GScn_Drv::IsConnected()
{
//XdPrint("Check for Connected!\n");
return m_usb.is_connected();
}
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;
//XdPrint("Get_Img_Data bulk_out GET_IMAGE CV_8UC1 \n.....................");
m_usb.bulk_out(0x00, &usbcb, sizeof(usbcb), &transfer);
StopWatch sw;
sw.start();
//XdPrint("Get_Img_Data Read_Data bufferSize begin \n.....................");
m_usb.Read_Data(iData.data, bufferSize, 2000, &transfer);
sw.stop();
//XdPrint("GetDate Consume time %lf \n.....................................",sw.time_run());
return iData;
}
void GScn_Drv::run()
{
if (m_threadUsb.joinable())
{
devState = DEV_STOP;
m_threadUsb.join();
}
devState = DEV_ISRUNNING;
m_threadUsb = std::thread(&GScn_Drv::usbmain, this);
}
INT GScn_Drv::get_decompress_pix_type()
{
return pixType;
}
void GScn_Drv::set_decompress_pix_type(int pixtype)
{
if (pixtype==TWPT_RGB)//TWPT_RGB=2
{
pixType=TJPF_BGR;
XdPrint("TurboJpeg <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>TJPF_BGR\n");
}
else
{
pixType=TJPF_GRAY;
XdPrint("TurboJpeg <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>TJPF_GRAY\n");
}
}
void GScn_Drv::enableDiscardBlank(bool bVal)
{
canUseDiscardBlank=bVal;
}
void GScn_Drv::SetIsDuplex(BOOL value)
{
isDuplex=value;
m_pImages.setduplexflag(value);
}
void GScn_Drv::SetRotate(int rotateType)
{
m_rotate=rotateType;
}
void GScn_Drv::SetBackRotate(bool enBackRoate)
{
backRotate=enBackRoate;
}
std::vector<std::string> GScn_Drv::GetSerials(int vid,int pid)
{
usb_scan_dev devs=Devices(vid,pid);
for (int i=0;i<devs._NumberOfDevs;i++)
{
cscn_usb usb;
usb.open(devs.dev_infos[i].index);
if(!usb.is_connected())
{
return vcSerials;
}
string serial=" ";
DWORD nTransfer;
USBCB usbcb={GET_SERIAL,12,0};
usb.bulk_out(0x00,&usbcb,sizeof(USBCB),&nTransfer);
CString cslog;
cslog.Format("GetSerials Read_Data %d",usbcb.u32_Data);
//WriteLog(cslog);
usb.Read_Data(&serial[0],12,200,&nTransfer);
if (serial.length()>0)
{
vcSerials.push_back(serial);
}
usb.close();
}
return vcSerials;
}
void GScn_Drv::ActiveteUSB()
{
if (IsConnected())
{
DWORD transfer;
USBCB usbcb = { 1024,0 ,0 };
m_usb.bulk_out(0x00, &usbcb, sizeof(usbcb), &transfer);
}
}
DWORD GScn_Drv::usbmain()
{
try
{
while (devState == DEV_ISRUNNING)
{
if (!IsConnected())
{
Sleep(200);
continue;
}
USBCB usbcb = Get_Scanner_Status();
//XdPrint("u32_CMD is %d, u32_Data is %d, u32_Count is %d \n", usbcb.u32_CMD, usbcb.u32_Data, usbcb.u32_Count);
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,pixType,0,0));
pushMat(JpegBuffer(bufferF,pixType,1,0));
Pop_Image();
break;
}
case G300:
case G400:
case G500:
pushMat(JpegBuffer(imgData,pixType,0,0));
break;
default:
break;
}
break;
}
case STOP_SCAN:
{
devState = DEV_STOP;
//::PostMessage(HWND_BROADCAST,WM_MYMESSAGE,200,NULL);
break;
}
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:
devState = DEV_WRONG;
break;
case NORMAL:
break;
default:
break;
}
this_thread::sleep_for(std::chrono::milliseconds(10));
}
return 0;
}
catch (CMemoryException* e)
{
XdPrint("CMemoryException");
}
catch (CFileException* e)
{
XdPrint("CFileException");
}
catch (CException* e)
{
XdPrint("CException");
}
}
///////////////////////////////////////////////////////////////////////////
void GScn_Drv::Config_Scanner(PUSBCB pUSBCB)
{
if (m_usb.is_connected())
{
std::lock_guard<std::mutex> lck(m_imgLocker);
DWORD transfer;
m_usb.bulk_out(0x00, pUSBCB, sizeof(USBCB), &transfer);
}
}
//void GScn_Drv::setlist(std::vector<std::shared_ptr<CImageApply> >list)
//{
// m_pImages.setlist(list);
//}
///////////////////////////////////////////////////////////////////////////
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.bulk_out(0x00, &usbcb, sizeof(usbcb), &transfer);
std::this_thread::sleep_for(std::chrono::milliseconds(500));
iNum = 0;
m_pImages.pixType=pixType;
m_pImages.SetDevModel(m_scannerType);
m_pImages.SetFilePath(csPath);
m_pImages.run();
run();
}
}
void GScn_Drv::Set_Scanner_Correct_Ratio(float hrz, float vtc)
{
if (m_usb.is_connected()) {
lock_guard<mutex> lck(m_imgLocker);
UINT32 hv = *(UINT32*)(&hrz);
USBCB usbcbH = { SET_JUST_COF_H,hv,0 };
DWORD transfer;
m_usb.bulk_out(0x00,&usbcbH,sizeof(usbcbH), &transfer);
this_thread::sleep_for(std::chrono::milliseconds(200));
UINT32 vv = *(UINT32*)(&vtc);
USBCB usbcbV = { SET_JUST_COF_V,vv,0 };
m_usb.bulk_out(00,&usbcbV, sizeof(usbcbV),&transfer);
}
}
void GScn_Drv::Get_Scanner_Correct_Ratio(float& hrz, float& vtc)
{
if (m_usb.is_connected()) {
lock_guard<mutex> lck(m_imgLocker);
USBCB usbcb = { GET_JUST_COF_H ,0,0 };
DWORD transfer;
m_usb.bulk_out(00,&usbcb, sizeof(usbcb),&transfer);
m_usb.bulk_in(00,&usbcb, sizeof(usbcb),200, &transfer);
float hratio = *((float*)(&usbcb.u32_Data));
hrz = hratio;
usbcb = { GET_JUST_COF_V ,0,0 };
m_usb.bulk_out(00, &usbcb, sizeof(usbcb), &transfer);
m_usb.bulk_in(00, &usbcb, sizeof(usbcb),200, &transfer);
float vratio = *((float*)(&usbcb.u32_Data));
vtc = vratio;
}
}
///////////////////////////////////////////////////////////////////////////
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,8,0 };
DWORD transfer;
XdPrint("Get GetFWVersion");
m_usb.bulk_out(0x00, &usbcb, sizeof(usbcb), &transfer);
CString cslog;
cslog.Format("GetFWVersion Read_Data %d",usbcb.u32_Data);
//WriteLog(cslog);
m_usb.Read_Data(&pFWVersion[0], 8, 200, &transfer);
return pFWVersion;
}
return "";
}
void GScn_Drv::SetSerialNum(byte *pvalue)
{
if (m_usb.is_connected())
{
std::lock_guard<std::mutex> lck(m_imgLocker);
for (UINT i = 0; i < 12; i = i + 4)
{
USBCB usbcb;
usbcb.u32_CMD = SEND_SERIAL;
usbcb.u32_Data = (UINT)pvalue[i] + ((UINT)pvalue[i + 1] << 8) + ((UINT)pvalue[i + 2] << 16) + ((UINT)pvalue[i + 3] << 24);
usbcb.u32_Count = i;
DWORD transfer;
m_usb.bulk_out(0x00, &usbcb, sizeof(usbcb), &transfer);
//m_usb.bulk_out(0x00, &pvalue, 12, &transfer);
Sleep(1000);
}
}
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.bulk_out(0x00, &usbcb, sizeof(usbcb), &transfer);
CString cslog;
cslog.Format("GetScanNum Read_Data %d",usbcb.u32_Data);
//WriteLog(cslog);
m_usb.Read_Data(&usbcb, sizeof(usbcb), 200, &transfer);
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.bulk_out(0x00, &usbcb, sizeof(usbcb), &transfer);
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.bulk_out(0x00, &usbcb, sizeof(usbcb), &transfer);
return;
}
void GScn_Drv::SendColorCorrentFlat(byte buffer[],int size)
{
DWORD transfer;
byte temp[524] = {0};
for(int i = 0; i<524;i++)
{
temp[i] = buffer[i];
}
m_usb.bulk_out(0x00, &temp, size, &transfer);
return;
}
void GScn_Drv::SendColorFlat(byte buffer[],int size)
{
DWORD transfer;
byte temp[524] = {0};
for(int i = 0; i<524;i++)
{
temp[i] = buffer[i];
}
m_usb.bulk_out(0x00, &temp, size, &transfer);
return;
}
void GScn_Drv::SendGrayCorrectFlat(byte buffer[],int size)
{
DWORD transfer;
byte temp[524] = {0};
for(int i = 0; i<524;i++)
{
temp[i] = buffer[i];
}
m_usb.bulk_out(0x00, &temp, size, &transfer);
return;
}
void GScn_Drv::SendGrayFlat(byte buffer[],int size)
{
DWORD transfer;
byte temp[524] = {0};
for(int i = 0; i<524;i++)
{
temp[i] = buffer[i];
}
m_usb.bulk_out(0x00, &temp, size, &transfer);
return;
}
byte* GScn_Drv::GetFlatData()
{
byte buffer[512] = {0};
USBCB usbcb = { GET_FLAT_DATA,0,0 };
DWORD transfer;
m_usb.bulk_out(0x00, &usbcb, sizeof(usbcb), &transfer);
CString cslog;
cslog.Format("GetFlatData Read_Data %d",usbcb.u32_Data);
//WriteLog(cslog);
m_usb.Read_Data(&buffer, 512, 200, &transfer);
return buffer;
}
byte* GScn_Drv::GetCisPara()
{
byte buffer[16] = {0};
USBCB usbcb = { GET_CIS_PARA,0,16 };
DWORD transfer;
m_usb.bulk_out(0x00, &usbcb, sizeof(usbcb), &transfer);
CString cslog;
cslog.Format("GetCisPara Read_Data %d",usbcb.u32_Data);
//WriteLog(cslog);
m_usb.Read_Data(&buffer, 16, 200, &transfer);
return buffer;
}
bool GScn_Drv::FlatA4()
{
if (!m_usb.is_connected())
{
return false;
}
//XdPrint("<22>·<EFBFBD>START_FLAT \n.....................");
USBCB usbcb = { START_FLAT,0,0 };
DWORD transfer;
m_usb.bulk_out(0x00, &usbcb, sizeof(usbcb), &transfer);
//XdPrint("<22>·<EFBFBD>START_FLAT<41><54><EFBFBD><EFBFBD> \n.....................");
//Sleep(1500);
if(devState != DEV_ISRUNNING)
{
//XdPrint("DEV_ISRUNNING \n.....................");
devState = DEV_ISRUNNING;
}
//iNum = 0;
m_pImages.pixType=pixType;
m_pImages.SetDevModel(m_scannerType);
m_pImages.SetFilePath(csPath);
m_pImages.run();
return true;
}
bool GScn_Drv::FlatA4Conrrect()
{
char cTime[32];
CTime currTime = CTime::GetCurrentTime();
_snprintf(cTime, 30, "[%04d-%02d-%02d %02d:%02d:%02d]",
currTime.GetYear(), currTime.GetMonth(), currTime.GetDay(),
currTime.GetHour(), currTime.GetMinute(), currTime.GetSecond());
if (!m_usb.is_connected())
{
XdPrint("%s m_usb δ<><CEB4><EFBFBD><EFBFBD> \n...................", cTime);
return false;
}
//XdPrint("%s <20>·<EFBFBD>START_FLAT \n.....................", cTime);
USBCB usbcb = { START_FLAT,0,0 };
DWORD transfer;
m_usb.bulk_out(0x00, &usbcb, sizeof(usbcb), &transfer);
//XdPrint("%s <20>·<EFBFBD>START_FLAT<41><54><EFBFBD><EFBFBD> \n.................", cTime);
//Sleep(1500);
if(devState != DEV_ISRUNNING)
{
//XdPrint("%s DEV_ISRUNNING \n.....................", cTime);
devState = DEV_ISRUNNING;
}
return true;
}
bool GScn_Drv::FlatA3(UINT para)
{
if (!m_usb.is_connected())
{
return false;
}
USBCB usbcb = { START_FLAT,para,0 };
DWORD transfer;
m_usb.bulk_out(0x00, &usbcb, sizeof(usbcb), &transfer);
Sleep(1500);
devState = DEV_ISRUNNING;
m_pImages.pixType=pixType;
m_pImages.SetDevModel(m_scannerType);
m_pImages.SetFilePath(csPath);
m_pImages.run();
return true;
}
void GScn_Drv::DevStateChange()
{
devState = DEV_STOP;
}
bool GScn_Drv::SendrAdPara(UINT para)
{
if (!m_usb.is_connected())
{
return false;
}
std::lock_guard<std::mutex> lck(m_imgLocker);
USBCB usbcb = { ADI_PARA,para,0 };
DWORD transfer;
m_usb.bulk_out(0x00, &usbcb, sizeof(usbcb), &transfer);
//Sleep(500);
return true;
}
bool GScn_Drv::SendrRgbAdPara(UINT para)
{
if (!m_usb.is_connected())
{
return false;
}
std::lock_guard<std::mutex> lck(m_imgLocker);
USBCB usbcb = { RGB_ADI_PARA,para,0 };
DWORD transfer;
m_usb.bulk_out(0x00, &usbcb, sizeof(usbcb), &transfer);
//Sleep(500);
return true;
}
bool GScn_Drv::SenGRPara(UINT para)
{
if (!m_usb.is_connected())
{
return false;
}
std::lock_guard<std::mutex> lck(m_imgLocker);
USBCB usbcb = { SEND_COMPONENTS_GR,para,0 };
DWORD transfer;
m_usb.bulk_out(0x00, &usbcb, sizeof(usbcb), &transfer);
Sleep(500);
return true;
}
bool GScn_Drv::SenGBPara(UINT para)
{
if (!m_usb.is_connected())
{
return false;
}
std::lock_guard<std::mutex> lck(m_imgLocker);
USBCB usbcb = { SEND_COMPONENTS_GB,para,0 };
DWORD transfer;
m_usb.bulk_out(0x00, &usbcb, sizeof(usbcb), &transfer);
Sleep(500);
return true;
}
///////////////////////////////////////////////////////////////////////////
byte* GScn_Drv::GetSerialNum()
{
if (!m_usb.is_connected())
{
return false;
}
std::lock_guard<std::mutex> lck(m_imgLocker);
byte buffer[16] = {0};
USBCB usbcb = { GET_SERIAL,0,12 };
DWORD transfer;
m_usb.bulk_out(0x00, &usbcb, sizeof(usbcb), &transfer);
XdPrint("GetSerialNum Read_Data %d",usbcb.u32_Data);
m_usb.Read_Data(&buffer, 16, 50, &transfer);
return buffer;
}
///////////////////////////////////////////////////////////////////////////
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 bulk_out\n");
USBCB usbcb = { GET_DSP_STATUS ,0,0 };
DWORD transfer;
m_usb.bulk_out(0x00, &usbcb, sizeof(usbcb), &transfer);
//XdPrint("Get_Scanner_Status Read_Data %d \n",usbcb.u32_Data);
m_usb.Read_Data(&usbcb, sizeof(usbcb), 200, &transfer);
//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_PAPER_STATUS ,0,0 };
DWORD transfer;
std::lock_guard<std::mutex> lck(m_imgLocker);
m_usb.bulk_out(0x00, &usbcb, sizeof(usbcb), &transfer);
m_usb.bulk_in(0x00, &usbcb, sizeof(usbcb), 200, &transfer);
return usbcb.u32_Data != 0;
}
///////////////////////////////////////////////////////////////////////////
void GScn_Drv::Pop_Image()
{
if (!m_usb.is_connected())
{
return;
}
USBCB usbcb = { POP_IMAGE ,0,0 };
DWORD transfer;
m_usb.bulk_out(0x00, &usbcb, sizeof(usbcb), &transfer);
}
///////////////////////////////////////////////////////////////////////////
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.bulk_out(0x00, &usbcb, sizeof(usbcb), &transfer);
}
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.bulk_out(0x00, &usbcb, sizeof(usbcb), &transfer);
}
///////////////////////////////////////////////////////////////////////////
bool GScn_Drv::Get_IsImageQueueEmpty()
{
bool bIsEmpty = m_pImages.empty();
return bIsEmpty;
}