lmh188
/
code_device
mirror of http://192.168.10.5:8099/sane/code_device.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

恢复200通信代码，修改SANE_Gamma结构

This commit is contained in:
gb 2022-05-06 15:15:18 +08:00
parent ac6c138fb3
commit a88d505c25
3 changed files with 77 additions and 97 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
hgdriver/hgdev/hg_scanner.cpp
View File

@ -26,7 +26,7 @@ hg_scanner::hg_scanner(ScannerSerial serial
{
paper_size_mm_.cx = 210;
paper_size_mm_.cy = 297;
custom_gamma_val_.pt_count = 0;
custom_gamma_val_.pt_count_r = custom_gamma_val_.pt_count_g = custom_gamma_val_.pt_count_b = 0;
for (int i = 0; i < ARRAY_SIZE(custom_gamma_val_.table); ++i)
custom_gamma_val_.table[i] = i & 0x0ff;
@ -455,7 +455,7 @@ int hg_scanner::restore(int setting_no)
setting_jsn_.at(key).at("name").get_to(val);
if (val == KNOWN_OPT_NAME_CUSTOM_GAMMA)
{
custom_gamma_val_.pt_count = 0;
custom_gamma_val_.pt_count_r = custom_gamma_val_.pt_count_g = custom_gamma_val_.pt_count_b = 0;
for (int i = 0; i < ARRAY_SIZE(custom_gamma_val_.table); ++i)
custom_gamma_val_.table[i] = i & 0x0ff;

148
hgdriver/hgdev/hg_scanner_200.cpp
View File

@ -207,12 +207,7 @@ enum hg_239_setting_item
hg_scanner_200::hg_scanner_200(const char* dev_name,int pid, usb_io* io) : hg_scanner(G100Serial, dev_name, io), pid_(pid)
, buf_read_img_len_(512 * 1024), buf_read_img_(nullptr), io_read_img_(0)
{
#ifdef WIN32
buf_read_img_ = new char[buf_read_img_len_];
#endif
string fw = get_firmware_version();
HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO, "get_firmware_version is: %s\n",fw.c_str());
// initdevice();
@ -225,35 +220,33 @@ hg_scanner_200::hg_scanner_200(const char* dev_name,int pid, usb_io* io) : hg_sc
printf_devconfig();
}
hg_scanner_200::~hg_scanner_200()
{
if (buf_read_img_)
delete[] buf_read_img_;
}
{}
void hg_scanner_200::discard_prev(void)
{
int ret = get_scanner_status(),
USBCB usb = { 0 };
int ret = get_scanner_status(usb),
imgs = 0,
packets = 0,
normal = 0;
while (ret == HG_ERR_OK)
{
if (buf_statu_.data.u32_Data == HAVE_IMAGE)
if (usb.u32_Data == HAVE_IMAGE)
{
pop_image();
imgs++;
normal = 0;
packets++;
}
else if (buf_statu_.data.u32_Data == NORMAL)
else if (usb.u32_Data == NORMAL)
{
if(normal++ > 10)
break;
}
else
packets++;
ret = get_scanner_status();
ret = get_scanner_status(usb);
}
if (imgs || packets)
HG_VLOG_MINI_2(HG_LOG_LEVEL_DEBUG_INFO, "discard prev-scanning %d packets and %d images.\n", packets, imgs);
@ -343,7 +336,8 @@ void hg_scanner_200::thread_handle_usb_read(void)
break;
}
ret = get_scanner_status();
USBCB usb = {0};
ret = get_scanner_status(usb);
if (ret == HG_ERR_DEVICE_NOT_FOUND)
{
@ -351,9 +345,9 @@ void hg_scanner_200::thread_handle_usb_read(void)
status_ = ret;
break;
}
else if (buf_statu_.data.u32_Data == HAVE_IMAGE)
else if (usb.u32_Data == HAVE_IMAGE)
{
ret = get_img_data(buf_statu_.data.u32_Count);
ret = get_img_data(usb.u32_Count);
io_->set_timeout(200);
pop_image();
sw.reset();
@ -372,10 +366,10 @@ void hg_scanner_200::thread_handle_usb_read(void)
{
// if the error occurs at the 2nd paper, then the first normal paper maybe lost, we delay 2 seconds here ...
std::this_thread::sleep_for(std::chrono::milliseconds(2000));
get_scanner_status();
if (buf_statu_.data.u32_Data == HAVE_IMAGE)
get_scanner_status(usb);
if (usb.u32_Data == HAVE_IMAGE)
{
get_img_data(buf_statu_.data.u32_Count);
get_img_data(usb.u32_Count);
io_->set_timeout(200);
pop_image();
sw.reset();
@ -483,6 +477,21 @@ int hg_scanner_200::writeusb(USBCB &usb)
return ret;
}
int hg_scanner_200::readusb(USBCB &usb)
{
std::lock_guard<std::mutex> lock(io_lock_);
int ret = HG_ERR_OK;
int len = sizeof(USBCB);
ret = io_->read_bulk(&usb,&len);
if (ret)
{
status_ = ret;
}
return ret;
}
int hg_scanner_200::pop_image()
{
int ret = HG_ERR_OK;
@ -492,43 +501,35 @@ int hg_scanner_200::pop_image()
return ret;
}
int hg_scanner_200::get_scanner_status(void)
int hg_scanner_200::get_scanner_status(USBCB &usb)
{
int ret = HG_ERR_OK;
buf_statu_ = {GET_DSP_STATUS, 0, 0};
usb = {GET_DSP_STATUS, 0, 0};
ret = writeusb(buf_statu_.data);
ret = writeusb(usb);
if (ret != HG_ERR_OK)
return ret;
buf_statu_.len = sizeof(buf_statu_.data);
io_->set_timeout(500);
{
std::lock_guard<std::mutex> lock(io_lock_);
ret = io_->read_bulk(&buf_statu_.data, &buf_statu_.len);
}
ret = readusb(usb);
if (ret != HG_ERR_OK)
{
status_ = ret;
return ret;
}
return settingsdsp_200::device_status_to_hg_err(buf_statu_.data.u32_Data, nullptr);
return settingsdsp_200::device_status_to_hg_err(usb.u32_Data, nullptr);
}
int hg_scanner_200::get_img_data(unsigned int bytes)
{
int total = bytes,
ret = HG_ERR_OK;
ret = HG_ERR_OK,
index = 0,
block = total;
std::shared_ptr<std::vector<char >> imagedata(new std::vector<char>(total));
#ifdef WIN32
char* buf = buf_read_img_;
#else
char* buf = imagedata->data();
#endif
char* dst = imagedata->data();
USBCB usb{GET_IMAGE, 0, total};
ret = writeusb(usb);
if (ret != HG_ERR_OK)
@ -536,27 +537,22 @@ int hg_scanner_200::get_img_data(unsigned int bytes)
status_ = ret;
return ret;
}
io_->set_timeout(2000);
io_->set_timeout(500);
while (total > 0)
{
io_read_img_ = buf_read_img_len_;
block = 512 * 1024;
if (total < io_read_img_)
io_read_img_ = total;
ret = io_->read_bulk(buf, &io_read_img_);
if (total < block)
block = total;
ret = io_->read_bulk(imagedata->data() + index,&block);
io_->set_timeout(500); //不能删除可能会导致IO超时
if (ret != HG_ERR_OK)
break;
#ifdef WIN32
memcpy(dst, buf, io_read_img_);
dst += io_read_img_;
#else
buf += io_read_img_;
#endif
total -= io_read_img_;
index += block;
total -= block;
}
if (ret == HG_ERR_OK)
{
@ -1124,36 +1120,36 @@ void hg_scanner_200::printf_devconfig(HGSCANCONF_DSP *d)
}
std::string hg_scanner_200::get_firmware_version()
{
char buf[20] = { 0 };
int ret = HG_ERR_OK,
len = 8; //协议定义长度为8 300 400 =10
USBCB cmd = {GET_FW_VERSION, len, 0,};
memset(buf_mini_str_, 0, sizeof(buf_mini_str_));
ret = writeusb(cmd);
if(ret == HG_ERR_OK)
{
std::lock_guard<std::mutex> lock(io_lock_);
ret = io_->read_bulk(buf_mini_str_, &len);
ret = io_->read_bulk(buf, &len);
}
return buf_mini_str_;
return buf;
}
std::string hg_scanner_200::get_serial_num()
{
char buf[20] = { 0 };
int ret = HG_ERR_OK,
len = 12; //协议定义长度为8 300 400 =10
USBCB cmd = {GET_SERIAL, len, 0,};
memset(buf_mini_str_, 0, sizeof(buf_mini_str_));
ret = writeusb(cmd);
if (ret == HG_ERR_OK)
{
std::lock_guard<std::mutex> lock(io_lock_);
ret = io_->read_bulk(buf_mini_str_, &len);
ret = io_->read_bulk(buf, &len);
}
return buf_mini_str_;
return buf;
}
@ -1229,19 +1225,16 @@ int hg_scanner_200::get_sleep_time(SANE_Power* getime)
{
return ret;
}
buf_sleep_.data = usbcb;
buf_sleep_.len = sizeof(buf_sleep_.data);
{
std::lock_guard<std::mutex> lock(io_lock_);
ret = io_->read_bulk(&buf_sleep_.data, &buf_sleep_.len);
}
len = sizeof(usbcb);
ret = io_->read_bulk(&usbcb,&len);
printf("usbcb.u32_Data = %d\r\n",usbcb.u32_Data);
if (ret == HG_ERR_OK)
{
if (getime)
{
*getime = (SANE_Power)buf_sleep_.data.u32_Data;
*getime = (SANE_Power)usbcb.u32_Data;
}
if (buf_sleep_.data.u32_Data)
if (usbcb.u32_Data)
{
return HG_ERR_DEVICE_SLEEPING;
}
@ -1282,19 +1275,23 @@ int hg_scanner_200::get_scanner_paperon(SANE_Bool* paperon)
ret = writeusb(usbcb);
io_->set_timeout(500);
buf_paper_on_.data = usbcb;
buf_paper_on_.len = sizeof(buf_paper_on_.data);
if (ret == HG_ERR_OK)
{
std::lock_guard<std::mutex> lock(io_lock_);
ret = io_->read_bulk(&buf_paper_on_.data, &buf_paper_on_.len);
if (ret == HG_ERR_OK && buf_paper_on_.data.u32_Data == 0)
ret = HG_ERR_DEVICE_NO_PAPER;
ret = io_->read_bulk(&usbcb,&len);
}
if (ret != HG_ERR_OK)
{
return ret;
}
if (usbcb.u32_Data == 0)
ret = HG_ERR_DEVICE_NO_PAPER;
else
ret = HG_ERR_OK;
if (paperon)
*paperon = buf_paper_on_.data.u32_Data;
{
*paperon = usbcb.u32_Data;
}
return ret;
}
int hg_scanner_200::set_scan_when_paper_on(void)
@ -1319,8 +1316,7 @@ int hg_scanner_200::get_scan_is_sleep()
len = 0;
USBCB usbcb = { CHECK_IS_SLEEP, 0, 0};
buf_is_sleep_.data = usbcb;
buf_is_sleep_.len = len = sizeof(USBCB);
len = sizeof(USBCB);
ret = writeusb(usbcb);
io_->set_timeout(200);
@ -1328,17 +1324,17 @@ int hg_scanner_200::get_scan_is_sleep()
if (ret == HG_ERR_OK)
{
std::lock_guard<std::mutex> lock(io_lock_);
ret = io_->read_bulk(&buf_is_sleep_.data, &buf_is_sleep_.len);
ret = io_->read_bulk(&usbcb,&len);
}
if (ret != HG_ERR_OK)
{
return ret;
}
if (buf_is_sleep_.data.u32_Data == 0x10)
if (usbcb.u32_Data == 0x10)
{
return HG_ERR_OK;
}
else if (buf_is_sleep_.data.u32_Data == 0x100)
else if (usbcb.u32_Data == 0x100)
{
return HG_ERR_DEVICE_SLEEPING;
}

20
hgdriver/hgdev/hg_scanner_200.h
View File

@ -15,23 +15,6 @@
class hg_scanner_200 : public hg_scanner
{
// reading buffers ... (for overlapped IO maybe rewrite the buffer after the timeout)
typedef struct _usb_block
{
USBCB data;
int len;
}USBBLOCK;
const int buf_read_img_len_;
char *buf_read_img_;
int io_read_img_;
char buf_mini_str_[20];
USBBLOCK buf_sleep_;
USBBLOCK buf_paper_on_;
USBBLOCK buf_is_sleep_;
USBBLOCK buf_statu_;
void discard_prev(void);
protected:
@ -61,8 +44,9 @@ public:
private:
int initdevice();
int writeusb(USBCB &usb);
int readusb(USBCB &usb);
int pop_image();
int get_scanner_status(void);
int get_scanner_status(USBCB &usb);
int get_img_data(unsigned int bytes);
int writedown_device_configuration(bool type =false,HGSCANCONF_DSP *d = NULL);
void writedown_image_configuration(void);