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

按业务命令对USB操作加锁

This commit is contained in:
gb 2023-05-24 10:11:56 +08:00
parent 1430cbb8be
commit df805cc81c
2 changed files with 241 additions and 161 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

165
hgdriver/hgdev/hg_scanner_200.cpp
View File

@ -156,8 +156,10 @@ void hg_scanner_200::thread_handle_usb_read(void)
std::string msg; std::string msg;
int count = usb.u32_Count; int count = usb.u32_Count;
msg.resize(count); msg.resize(count);
{
ret = io_->read_bulk(&msg[0], &count); std::lock_guard<std::mutex> lock(io_lock_);
ret = io_->read_bulk(&msg[0], &count);
}
if (ret == SCANNER_ERR_OK) if (ret == SCANNER_ERR_OK)
notify_ui_working_status(msg.c_str(), SANE_EVENT_STATUS, status_); notify_ui_working_status(msg.c_str(), SANE_EVENT_STATUS, status_);
else else
@ -173,7 +175,10 @@ void hg_scanner_200::thread_handle_usb_read(void)
std::string msg; std::string msg;
int count = usb.u32_Count; int count = usb.u32_Count;
msg.resize(count); msg.resize(count);
ret = io_->read_bulk(&msg[0], &count); {
std::lock_guard<std::mutex> lock(io_lock_);
ret = io_->read_bulk(&msg[0], &count);
}
if (ret == SCANNER_ERR_OK) if (ret == SCANNER_ERR_OK)
{ {
status_ = ret = SCANNER_ERR_DEVICE_AUTO_FAIL_INFO; status_ = ret = SCANNER_ERR_DEVICE_AUTO_FAIL_INFO;
@ -321,8 +326,6 @@ int hg_scanner_200::stop(void)
} }
int hg_scanner_200::writeusb(USBCB &usb) int hg_scanner_200::writeusb(USBCB &usb)
{ {
std::lock_guard<std::mutex> lock(io_lock_);
int ret = SCANNER_ERR_OK; int ret = SCANNER_ERR_OK;
int len = sizeof(usb); int len = sizeof(usb);
@ -336,8 +339,6 @@ int hg_scanner_200::writeusb(USBCB &usb)
} }
int hg_scanner_200::readusb(USBCB &usb) int hg_scanner_200::readusb(USBCB &usb)
{ {
std::lock_guard<std::mutex> lock(io_lock_);
int ret = SCANNER_ERR_OK; int ret = SCANNER_ERR_OK;
int len = sizeof(USBCB); int len = sizeof(USBCB);
@ -351,6 +352,8 @@ int hg_scanner_200::readusb(USBCB &usb)
} }
int hg_scanner_200::pop_image() int hg_scanner_200::pop_image()
{ {
std::lock_guard<std::mutex> lock(io_lock_);
int ret = SCANNER_ERR_OK; int ret = SCANNER_ERR_OK;
USBCB usbcb = { setting3288dsp::POP_IMAGE, 0, 0 }; USBCB usbcb = { setting3288dsp::POP_IMAGE, 0, 0 };
@ -360,6 +363,8 @@ int hg_scanner_200::pop_image()
} }
int hg_scanner_200::get_scanner_status(USBCB &usb) int hg_scanner_200::get_scanner_status(USBCB &usb)
{ {
std::lock_guard<std::mutex> lock(io_lock_);
int ret = SCANNER_ERR_OK; int ret = SCANNER_ERR_OK;
usb = { setting3288dsp::GET_DSP_STATUS, 0, 0 }; usb = { setting3288dsp::GET_DSP_STATUS, 0, 0 };
@ -393,37 +398,41 @@ int hg_scanner_200::get_img_data(unsigned int bytes, SANE_Image_Statu statu)
USBCB usb{ setting3288dsp::GET_IMAGE, 0, total }; USBCB usb{ setting3288dsp::GET_IMAGE, 0, total };
imagedata->set_image_statu(statu); imagedata->set_image_statu(statu);
ret = writeusb(usb);
if (ret != SCANNER_ERR_OK)
{ {
status_ = ret; std::lock_guard<std::mutex> lock(io_lock_);
return ret;
}
io_->set_timeout(500);
while (total > 0) ret = writeusb(usb);
{
block = 512 * 1024;
if (total < block)
block = total;
unsigned int size = block;
void* buf = imagedata->data(index, &size);
if (!buf)
{
VLOG_MINI_3(LOG_LEVEL_FATAL, "memory(0x%08x + %u) fatal when read USB image %d !!!\n", index, block, usb_img_index_);
ret = SCANNER_ERR_INSUFFICIENT_MEMORY;
break;
}
block = size;
ret = io_->read_bulk(buf, &block);
io_->set_timeout(500); //不能删除可能会导致IO超时
if (ret != SCANNER_ERR_OK) if (ret != SCANNER_ERR_OK)
break; {
status_ = ret;
return ret;
}
io_->set_timeout(500);
index += block; while (total > 0)
total -= block; {
block = 512 * 1024;
if (total < block)
block = total;
unsigned int size = block;
void* buf = imagedata->data(index, &size);
if (!buf)
{
VLOG_MINI_3(LOG_LEVEL_FATAL, "memory(0x%08x + %u) fatal when read USB image %d !!!\n", index, block, usb_img_index_);
ret = SCANNER_ERR_INSUFFICIENT_MEMORY;
break;
}
block = size;
ret = io_->read_bulk(buf, &block);
io_->set_timeout(500); //不能删除可能会导致IO超时
if (ret != SCANNER_ERR_OK)
break;
index += block;
total -= block;
}
} }
if (ret == SCANNER_ERR_OK) if (ret == SCANNER_ERR_OK)
{ {
@ -453,9 +462,13 @@ int hg_scanner_200::writedown_device_configuration(bool type,setting_hardware::H
d->params_dsp.color = 1; d->params_dsp.color = 1;
} }
USBCB usbcb = { setting3288dsp::CONFIGURED_DATA, d->value, 0 }; {
len = sizeof(USBCB); std::lock_guard<std::mutex> lock(io_lock_);
ret = io_->write_bulk(&usbcb,&len);
USBCB usbcb = { setting3288dsp::CONFIGURED_DATA, d->value, 0 };
len = sizeof(USBCB);
ret = io_->write_bulk(&usbcb, &len);
}
VLOG_MINI_1(LOG_LEVEL_WARNING, "writedown_device_configuration is .(%s)\n", hg_scanner_err_name(ret)); VLOG_MINI_1(LOG_LEVEL_WARNING, "writedown_device_configuration is .(%s)\n", hg_scanner_err_name(ret));
@ -710,11 +723,13 @@ std::string hg_scanner_200::get_firmware_version()
len = 8; //协议定义长度为8 300 400 =10 len = 8; //协议定义长度为8 300 400 =10
USBCB cmd = { setting3288dsp::GET_FW_VERSION, len, 0 }; USBCB cmd = { setting3288dsp::GET_FW_VERSION, len, 0 };
ret = writeusb(cmd);
if(ret == SCANNER_ERR_OK)
{ {
std::lock_guard<std::mutex> lock(io_lock_); std::lock_guard<std::mutex> lock(io_lock_);
ret = io_->read_bulk(buf, &len); ret = writeusb(cmd);
if (ret == SCANNER_ERR_OK)
{
ret = io_->read_bulk(buf, &len);
}
} }
return buf; return buf;
@ -726,11 +741,13 @@ std::string hg_scanner_200::get_serial_num()
len = 12; //协议定义长度为8 300 400 =10 len = 12; //协议定义长度为8 300 400 =10
USBCB cmd = { setting3288dsp::GET_SERIAL, len, 0 }; USBCB cmd = { setting3288dsp::GET_SERIAL, len, 0 };
ret = writeusb(cmd);
if (ret == SCANNER_ERR_OK)
{ {
std::lock_guard<std::mutex> lock(io_lock_); std::lock_guard<std::mutex> lock(io_lock_);
ret = io_->read_bulk(buf, &len); ret = writeusb(cmd);
if (ret == SCANNER_ERR_OK)
{
ret = io_->read_bulk(buf, &len);
}
} }
return buf; return buf;
@ -758,12 +775,14 @@ int hg_scanner_200::set_serial_num(string str)
} }
int hg_scanner_200::set_vid_pid(int data) int hg_scanner_200::set_vid_pid(int data)
{ {
std::lock_guard<std::mutex> lock(io_lock_);
USBCB usbcb = { setting3288dsp::SET_USB_INFOR_VIDPID,0,0 }; USBCB usbcb = { setting3288dsp::SET_USB_INFOR_VIDPID,0,0 };
int len = sizeof(usbcb); int len = sizeof(usbcb);
return io_->write_bulk(&usbcb, &len); return io_->write_bulk(&usbcb, &len);
} }
int hg_scanner_200::get_vid_pid(int& data) int hg_scanner_200::get_vid_pid(int& data)
{ {
std::lock_guard<std::mutex> lock(io_lock_);
USBCB usbcb = { setting3288dsp::GET_USB_INFOR_VIDPID,0,0 }; USBCB usbcb = { setting3288dsp::GET_USB_INFOR_VIDPID,0,0 };
int ret = SCANNER_ERR_OK, int ret = SCANNER_ERR_OK,
len = sizeof(usbcb); len = sizeof(usbcb);
@ -809,13 +828,16 @@ int hg_scanner_200::get_sleep_time(int& data )
len = 0; len = 0;
USBCB usbcb = { setting3288dsp::GET_SLEEP_TIME, 0, 0 }; USBCB usbcb = { setting3288dsp::GET_SLEEP_TIME, 0, 0 };
ret = writeusb(usbcb);
if (ret != SCANNER_ERR_OK)
{ {
return ret; std::lock_guard<std::mutex> lock(io_lock_);
ret = writeusb(usbcb);
if (ret != SCANNER_ERR_OK)
{
return ret;
}
len = sizeof(usbcb);
ret = io_->read_bulk(&usbcb, &len);
} }
len = sizeof(usbcb);
ret = io_->read_bulk(&usbcb,&len);
printf("usbcb.u32_Data = %d\r\n",usbcb.u32_Data); printf("usbcb.u32_Data = %d\r\n",usbcb.u32_Data);
if (ret == SCANNER_ERR_OK) if (ret == SCANNER_ERR_OK)
{ {
@ -825,6 +847,7 @@ int hg_scanner_200::get_sleep_time(int& data )
} }
int hg_scanner_200::set_sleep_time(int data) int hg_scanner_200::set_sleep_time(int data)
{ {
std::lock_guard<std::mutex> lock(io_lock_);
int ret = SCANNER_ERR_OK; int ret = SCANNER_ERR_OK;
USBCB usbcb = { setting3288dsp::SET_SLEEP_TIME,data, 0 }; USBCB usbcb = { setting3288dsp::SET_SLEEP_TIME,data, 0 };
@ -839,14 +862,16 @@ int hg_scanner_200::get_scanner_paperon(SANE_Bool& type)
len = 0; len = 0;
USBCB usbcb = { setting3288dsp::GET_PAPERFEEDER_STATUS, 0, 0 }; USBCB usbcb = { setting3288dsp::GET_PAPERFEEDER_STATUS, 0, 0 };
len = sizeof(USBCB);
ret = writeusb(usbcb);
if (ret == SCANNER_ERR_OK)
{ {
std::lock_guard<std::mutex> lock(io_lock_); std::lock_guard<std::mutex> lock(io_lock_);
ret = io_->read_bulk(&usbcb, &len); len = sizeof(USBCB);
type = usbcb.u32_Data == 0 ? false : true; ret = writeusb(usbcb);
if (ret == SCANNER_ERR_OK)
{
ret = io_->read_bulk(&usbcb, &len);
type = usbcb.u32_Data == 0 ? false : true;
}
} }
//if (usbcb.u32_Data == 0) //if (usbcb.u32_Data == 0)
// ret = SCANNER_ERR_DEVICE_NO_PAPER; // ret = SCANNER_ERR_DEVICE_NO_PAPER;
@ -862,13 +887,13 @@ int hg_scanner_200::get_scan_is_sleep(SANE_Bool& type)
USBCB usbcb = { setting3288dsp::ACTIVE_SCANNER, 0, 0 }; USBCB usbcb = { setting3288dsp::ACTIVE_SCANNER, 0, 0 };
len = sizeof(USBCB); len = sizeof(USBCB);
ret = writeusb(usbcb);
if (ret == SCANNER_ERR_OK)
{ {
std::lock_guard<std::mutex> lock(io_lock_); std::lock_guard<std::mutex> lock(io_lock_);
ret = io_->read_bulk(&usbcb,&len); ret = writeusb(usbcb);
if (ret == SCANNER_ERR_OK)
{
ret = io_->read_bulk(&usbcb, &len);
}
} }
if (ret == SCANNER_ERR_OK) if (ret == SCANNER_ERR_OK)
{ {
@ -970,12 +995,15 @@ int hg_scanner_200::get_history_scan_count(int& num)
len = 0; len = 0;
USBCB usbcb = { setting3288dsp::GET_SCANN_NUM,0, 0 }; USBCB usbcb = { setting3288dsp::GET_SCANN_NUM,0, 0 };
len = sizeof(usbcb); len = sizeof(usbcb);
ret = io_->write_bulk(&usbcb, &len);
if (ret != SCANNER_ERR_OK)
{ {
return ret; std::lock_guard<std::mutex> lock(io_lock_);
ret = io_->write_bulk(&usbcb, &len);
if (ret != SCANNER_ERR_OK)
{
return ret;
}
ret = io_->read_bulk(&usbcb, &len);
} }
ret = io_->read_bulk(&usbcb, &len);
if (ret != SCANNER_ERR_OK) if (ret != SCANNER_ERR_OK)
{ {
return ret; return ret;
@ -989,12 +1017,15 @@ int hg_scanner_200::get_roller_num(int& val)
len = 0; len = 0;
USBCB usbcb = { setting3288dsp::GET_ROLLER_NUM,0, 0 }; USBCB usbcb = { setting3288dsp::GET_ROLLER_NUM,0, 0 };
len = sizeof(usbcb); len = sizeof(usbcb);
ret = io_->write_bulk(&usbcb, &len);
if (ret != SCANNER_ERR_OK)
{ {
return ret; std::lock_guard<std::mutex> lock(io_lock_);
ret = io_->write_bulk(&usbcb, &len);
if (ret != SCANNER_ERR_OK)
{
return ret;
}
ret = io_->read_bulk(&usbcb, &len);
} }
ret = io_->read_bulk(&usbcb, &len);
if (ret != SCANNER_ERR_OK) if (ret != SCANNER_ERR_OK)
{ {
return ret; return ret;

237
hgdriver/hgdev/hg_scanner_300.cpp
View File

@ -160,7 +160,10 @@ void hg_scanner_300::thread_handle_usb_read(void)
int count = usb.u32_Count; int count = usb.u32_Count;
msg.resize(count); msg.resize(count);
ret = io_->read_bulk(&msg[0], &count); {
std::lock_guard<std::mutex> lock(io_lock_);
ret = io_->read_bulk(&msg[0], &count);
}
if (ret == SCANNER_ERR_OK) if (ret == SCANNER_ERR_OK)
notify_ui_working_status(msg.c_str(), SANE_EVENT_STATUS, status_); notify_ui_working_status(msg.c_str(), SANE_EVENT_STATUS, status_);
else else
@ -268,30 +271,28 @@ void hg_scanner_300::thread_handle_usb_read(void)
} }
int hg_scanner_300::discard_all_images(void) int hg_scanner_300::discard_all_images(void)
{ {
int block = 1024 * 512, len = block;
uint8_t* buf = new uint8_t[block];
if(buf)
{ {
int block = 1024 * 512; std::lock_guard<std::mutex> lock(io_lock_);
int cnt = 0, ret = SCANNER_ERR_OK; int cnt = 0, ret = SCANNER_ERR_OK;
io_->set_timeout(1000); io_->set_timeout(1000);
string str; while ((ret = io_->read_bulk(buf, &len)) == SCANNER_ERR_OK)
{ {
std::lock_guard<std::mutex> lock(io_lock_); len = block;
int ret = io_->read_bulk(&str[0], &block); this_thread::sleep_for(chrono::milliseconds(10));
} if (cnt++ > 10)
while (ret == SCANNER_ERR_OK)
{
cnt++;
{
std::lock_guard<std::mutex> lock(io_lock_);
ret = io_->read_bulk(&str[0], &block);
}
this_thread::sleep_for(chrono::milliseconds(1000));
if (cnt > 10)
{ {
break; break;
} }
} }
delete[] buf;
} }
if (is_read_int) if (is_read_int)
{ {
//initdevice(); //initdevice();
@ -367,7 +368,10 @@ int hg_scanner_300::start(void)
} }
printf_devconfig(); printf_devconfig();
USBCB usb = { setting3288dsp::START_COMMAND, img_conf_.scannum, 0}; USBCB usb = { setting3288dsp::START_COMMAND, img_conf_.scannum, 0};
ret = writeusb(usb); {
std::lock_guard<std::mutex> lock(io_lock_);
ret = writeusb(usb);
}
if(ret == SCANNER_ERR_OK) if(ret == SCANNER_ERR_OK)
{ {
@ -385,7 +389,10 @@ int hg_scanner_300::stop(void)
int ret = SCANNER_ERR_OK; int ret = SCANNER_ERR_OK;
USBCB usbcb = { setting3288dsp::STOP, 0, 0}; USBCB usbcb = { setting3288dsp::STOP, 0, 0};
ret = writeusb(usbcb); {
std::lock_guard<std::mutex> lock(io_lock_);
ret = writeusb(usbcb);
}
if (status_ == SCANNER_ERR_DEVICE_BUSY) if (status_ == SCANNER_ERR_DEVICE_BUSY)
{ {
@ -403,8 +410,6 @@ int hg_scanner_300::stop(void)
} }
int hg_scanner_300::writeusb(USBCB &usb) int hg_scanner_300::writeusb(USBCB &usb)
{ {
std::lock_guard<std::mutex> lock(io_lock_);
int ret = SCANNER_ERR_OK; int ret = SCANNER_ERR_OK;
int len = sizeof(usb); int len = sizeof(usb);
@ -418,8 +423,6 @@ int hg_scanner_300::writeusb(USBCB &usb)
} }
int hg_scanner_300::readusb(USBCB &usb) int hg_scanner_300::readusb(USBCB &usb)
{ {
std::lock_guard<std::mutex> lock(io_lock_);
int ret = SCANNER_ERR_OK; int ret = SCANNER_ERR_OK;
int len = sizeof(USBCB); int len = sizeof(USBCB);
@ -436,12 +439,16 @@ int hg_scanner_300::pop_image()
int ret = SCANNER_ERR_OK; int ret = SCANNER_ERR_OK;
USBCB usbcb = { setting3288dsp::POP_IMAGE, 0, 0}; USBCB usbcb = { setting3288dsp::POP_IMAGE, 0, 0};
ret = writeusb(usbcb); {
std::lock_guard<std::mutex> lock(io_lock_);
ret = writeusb(usbcb);
}
return ret; return ret;
} }
int hg_scanner_300::get_scanner_status(USBCB &usb) int hg_scanner_300::get_scanner_status(USBCB &usb)
{ {
std::lock_guard<std::mutex> lock(io_lock_);
int ret = SCANNER_ERR_OK; int ret = SCANNER_ERR_OK;
usb = { setting3288dsp::GET_DSP_STATUS, 0, 0}; usb = { setting3288dsp::GET_DSP_STATUS, 0, 0};
@ -471,45 +478,48 @@ int hg_scanner_300::get_img_data(std::shared_ptr<tiny_buffer> &imagedata)
block = total; block = total;
USBCB usb{ setting3288dsp::GET_IMAGE, 0, total}; USBCB usb{ setting3288dsp::GET_IMAGE, 0, total};
ret = writeusb(usb);
if (ret != SCANNER_ERR_OK)
{ {
VLOG_MINI_1(LOG_LEVEL_WARNING, "get_img_data setting3288dsp::GET_IMAGE write usb: %s\n", hg_scanner_err_name(ret)); std::lock_guard<std::mutex> lock(io_lock_);
} ret = writeusb(usb);
else if (ret != SCANNER_ERR_OK)
{
VLOG_MINI_1(LOG_LEVEL_FATAL, "get_img_data get data total len is:%d\n", total);
while (total > 0)
{ {
block = 512 * 1024; VLOG_MINI_1(LOG_LEVEL_WARNING, "get_img_data setting3288dsp::GET_IMAGE write usb: %s\n", hg_scanner_err_name(ret));
}
if (total < block) else
block = total; {
VLOG_MINI_1(LOG_LEVEL_FATAL, "get_img_data get data total len is:%d\n", total);
unsigned int size = block; while (total > 0)
void* buf = imagedata->data(index, &size);
if (!buf)
{ {
VLOG_MINI_3(LOG_LEVEL_FATAL, "memory(0x%08x + %u) fatal when read USB image %d !!!\n", index, block, usb_img_index_); block = 512 * 1024;
ret = SCANNER_ERR_INSUFFICIENT_MEMORY;
break;
}
block = size;
ret = io_->read_bulk(buf, &block);
if (ret != SCANNER_ERR_OK && ret != SCANNER_ERR_TIMEOUT) if (total < block)
{ block = total;
VLOG_MINI_1(LOG_LEVEL_FATAL, "get_img_data read_data:%s!!! \n", hg_scanner_err_name(ret));
break;
}
else if (ret == SCANNER_ERR_TIMEOUT && io_->get_timeout() > 3000)
{
VLOG_MINI_2(LOG_LEVEL_FATAL, "get_img_data read_data:%s!!! ,get_timeout is %d\n", hg_scanner_err_name(ret), io_->get_timeout());
break;
}
index += block; unsigned int size = block;
total -= block; void* buf = imagedata->data(index, &size);
if (!buf)
{
VLOG_MINI_3(LOG_LEVEL_FATAL, "memory(0x%08x + %u) fatal when read USB image %d !!!\n", index, block, usb_img_index_);
ret = SCANNER_ERR_INSUFFICIENT_MEMORY;
break;
}
block = size;
ret = io_->read_bulk(buf, &block);
if (ret != SCANNER_ERR_OK && ret != SCANNER_ERR_TIMEOUT)
{
VLOG_MINI_1(LOG_LEVEL_FATAL, "get_img_data read_data:%s!!! \n", hg_scanner_err_name(ret));
break;
}
else if (ret == SCANNER_ERR_TIMEOUT && io_->get_timeout() > 3000)
{
VLOG_MINI_2(LOG_LEVEL_FATAL, "get_img_data read_data:%s!!! ,get_timeout is %d\n", hg_scanner_err_name(ret), io_->get_timeout());
break;
}
index += block;
total -= block;
}
} }
} }
if (ret == SCANNER_ERR_OK) if (ret == SCANNER_ERR_OK)
@ -577,7 +587,10 @@ int hg_scanner_300::writedown_device_configuration(bool type,setting_hardware::H
USBCB usbcb = { setting3288dsp::CONFIGURED_DATA, d->value, 0}; USBCB usbcb = { setting3288dsp::CONFIGURED_DATA, d->value, 0};
len = sizeof(USBCB); len = sizeof(USBCB);
ret = io_->write_bulk(&usbcb,&len); {
std::lock_guard<std::mutex> lock(io_lock_);
ret = io_->write_bulk(&usbcb, &len);
}
if (type) if (type)
{ {
printf_devconfig(d); printf_devconfig(d);
@ -821,9 +834,12 @@ std::string hg_scanner_300::get_firmware_version()
len = 10; //协议定义长度为10 100 200 =8 len = 10; //协议定义长度为10 100 200 =8
USBCB cmd = { setting3288dsp::GET_FW_VERSION,len,0,}; USBCB cmd = { setting3288dsp::GET_FW_VERSION,len,0,};
ret = writeusb(cmd); {
std::lock_guard<std::mutex> lock(io_lock_); std::lock_guard<std::mutex> lock(io_lock_);
ret = io_->read_bulk(buf, &len); ret = writeusb(cmd);
if(ret == SCANNER_ERR_OK)
ret = io_->read_bulk(buf, &len);
}
string fw = buf; string fw = buf;
VLOG_MINI_1(LOG_LEVEL_WARNING, "get_firmware_version:%s\n", !fw.empty() ? fw.c_str() : "not find devs firmware_version"); VLOG_MINI_1(LOG_LEVEL_WARNING, "get_firmware_version:%s\n", !fw.empty() ? fw.c_str() : "not find devs firmware_version");
@ -837,10 +853,12 @@ std::string hg_scanner_300::get_firmware_version()
SerialNum.resize(len); SerialNum.resize(len);
USBCB cmd = { setting3288dsp::GET_SERIAL,len,0,}; USBCB cmd = { setting3288dsp::GET_SERIAL,len,0,};
ret = writeusb(cmd); {
std::lock_guard<std::mutex> lock(io_lock_);
std::lock_guard<std::mutex> lock(io_lock_); ret = writeusb(cmd);
ret = io_->read_bulk(&SerialNum[0],&len); if(ret == SCANNER_ERR_OK)
ret = io_->read_bulk(&SerialNum[0], &len);
}
VLOG_MINI_1(LOG_LEVEL_WARNING, "get_serial_num:%s\n", !SerialNum.empty() ? SerialNum.c_str() : "not find devs get_serial_num"); VLOG_MINI_1(LOG_LEVEL_WARNING, "get_serial_num:%s\n", !SerialNum.empty() ? SerialNum.c_str() : "not find devs get_serial_num");
return SerialNum; return SerialNum;
@ -861,6 +879,7 @@ int hg_scanner_300::set_leaflet_scan(void)
int hg_scanner_300::set_clear_roller_num(void) int hg_scanner_300::set_clear_roller_num(void)
{ {
std::lock_guard<std::mutex> lock(io_lock_);
USBCB usbcb = { setting3288dsp::CLR_ROLLER_NUM,0,4 }; USBCB usbcb = { setting3288dsp::CLR_ROLLER_NUM,0,4 };
return writeusb(usbcb); return writeusb(usbcb);
} }
@ -870,6 +889,7 @@ int hg_scanner_300::set_clear_history_num(void)
{ {
return SCANNER_ERR_DEVICE_NOT_SUPPORT; return SCANNER_ERR_DEVICE_NOT_SUPPORT;
} }
std::lock_guard<std::mutex> lock(io_lock_);
USBCB usbcb = { setting3288dsp::CLR_SCAN_NUM,0,4 }; USBCB usbcb = { setting3288dsp::CLR_SCAN_NUM,0,4 };
return writeusb(usbcb); return writeusb(usbcb);
} }
@ -883,13 +903,16 @@ int hg_scanner_300::get_sleep_time(int &data)
len = 0; len = 0;
USBCB usbcb = { setting3288dsp::GET_SLEEP_TIME, 0, 0 }; USBCB usbcb = { setting3288dsp::GET_SLEEP_TIME, 0, 0 };
ret = writeusb(usbcb);
if (ret != SCANNER_ERR_OK)
{ {
return ret; std::lock_guard<std::mutex> lock(io_lock_);
ret = writeusb(usbcb);
if (ret != SCANNER_ERR_OK)
{
return ret;
}
len = sizeof(usbcb);
ret = io_->read_bulk(&usbcb, &len);
} }
len = sizeof(usbcb);
ret = io_->read_bulk(&usbcb, &len);
if (ret == SCANNER_ERR_OK) if (ret == SCANNER_ERR_OK)
{ {
data = (SANE_Power)usbcb.u32_Data; data = (SANE_Power)usbcb.u32_Data;
@ -899,6 +922,7 @@ int hg_scanner_300::get_sleep_time(int &data)
} }
int hg_scanner_300::set_sleep_time(int data) int hg_scanner_300::set_sleep_time(int data)
{ {
std::lock_guard<std::mutex> lock(io_lock_);
int ret = SCANNER_ERR_OK; int ret = SCANNER_ERR_OK;
USBCB usbcb = { setting3288dsp::SET_SLEEP_TIME,data, 0}; USBCB usbcb = { setting3288dsp::SET_SLEEP_TIME,data, 0};
ret = writeusb(usbcb); ret = writeusb(usbcb);
@ -912,13 +936,15 @@ int hg_scanner_300::get_scanner_paperon(SANE_Bool& type)
USBCB usbcb = { setting3288dsp::GET_PAPERFEEDER_STATUS, 0, 0}; USBCB usbcb = { setting3288dsp::GET_PAPERFEEDER_STATUS, 0, 0};
len = sizeof(USBCB); len = sizeof(USBCB);
ret = writeusb(usbcb);
if (ret == SCANNER_ERR_OK)
{ {
std::lock_guard<std::mutex> lock(io_lock_); std::lock_guard<std::mutex> lock(io_lock_);
ret = io_->read_bulk(&usbcb, &len); ret = writeusb(usbcb);
type = usbcb.u32_Data == 0 ? false : true; if (ret == SCANNER_ERR_OK)
{
ret = io_->read_bulk(&usbcb, &len);
type = usbcb.u32_Data == 0 ? false : true;
}
} }
//if (usbcb.u32_Data == 0) //if (usbcb.u32_Data == 0)
// ret = SCANNER_ERR_DEVICE_NO_PAPER; // ret = SCANNER_ERR_DEVICE_NO_PAPER;
@ -935,13 +961,14 @@ int hg_scanner_300::get_scan_is_sleep(SANE_Bool& type)
USBCB usbcb = { setting3288dsp::ACTIVE_SCANNER, 0, 0 }; USBCB usbcb = { setting3288dsp::ACTIVE_SCANNER, 0, 0 };
len = sizeof(USBCB); len = sizeof(USBCB);
ret = writeusb(usbcb);
if (ret == SCANNER_ERR_OK)
{ {
std::lock_guard<std::mutex> lock(io_lock_); std::lock_guard<std::mutex> lock(io_lock_);
ret = io_->read_bulk(&usbcb, &len);
ret = writeusb(usbcb);
if (ret == SCANNER_ERR_OK)
{
ret = io_->read_bulk(&usbcb, &len);
}
} }
if (ret == SCANNER_ERR_OK) if (ret == SCANNER_ERR_OK)
{ {
@ -1164,7 +1191,10 @@ int hg_scanner_300::set_devs_distortion_check_val(float data)
float f = *(float*)&(val); float f = *(float*)&(val);
VLOG_MINI_3(LOG_LEVEL_WARNING, "set_devs_distortion_check_val dpi is:%d,config dpi = %d,distortion_check_val(%f)\n", resolution_, protocol_dpi,f); VLOG_MINI_3(LOG_LEVEL_WARNING, "set_devs_distortion_check_val dpi is:%d,config dpi = %d,distortion_check_val(%f)\n", resolution_, protocol_dpi,f);
io_->set_timeout(5000); io_->set_timeout(5000);
ret = io_->write_bulk(&usbcb, &len); {
std::lock_guard<std::mutex> lock(io_lock_);
ret = io_->write_bulk(&usbcb, &len);
}
return ret; return ret;
} }
int hg_scanner_300::get_devs_distortion_check_val(float& data) int hg_scanner_300::get_devs_distortion_check_val(float& data)
@ -1176,14 +1206,18 @@ int hg_scanner_300::get_devs_distortion_check_val(float& data)
int protocol_dpi = resolution_ == 200 ? 1 : (resolution_ == 300 ? 2 : 3); int protocol_dpi = resolution_ == 200 ? 1 : (resolution_ == 300 ? 2 : 3);
USBCB usbcb = { setting3288dsp::GET_JUST_COF_V ,0,protocol_dpi }; USBCB usbcb = { setting3288dsp::GET_JUST_COF_V ,0,protocol_dpi };
len = sizeof(usbcb); len = sizeof(usbcb);
ret = io_->write_bulk(&usbcb, &len);
if (ret != SCANNER_ERR_OK)
{ {
return ret; std::lock_guard<std::mutex> lock(io_lock_);
}
io_->set_timeout(3000); ret = io_->write_bulk(&usbcb, &len);
ret = io_->read_bulk(&usbcb, &len); if (ret != SCANNER_ERR_OK)
{
return ret;
}
io_->set_timeout(3000);
ret = io_->read_bulk(&usbcb, &len);
}
if (ret != SCANNER_ERR_OK) if (ret != SCANNER_ERR_OK)
{ {
return ret; return ret;
@ -1203,7 +1237,12 @@ int hg_scanner_300::set_auto_flat(int data)
} }
USBCB usbcb = { setting3288dsp::START_FLAT,data,0 }; USBCB usbcb = { setting3288dsp::START_FLAT,data,0 };
int len = sizeof(usbcb); int len = sizeof(usbcb);
int ret = writeusb(usbcb); int ret = SCANNER_ERR_OK;
{
std::lock_guard<std::mutex> lock(io_lock_);
ret = writeusb(usbcb);
}
if (ret == SCANNER_ERR_OK && wait_usb_.is_waiting()) if (ret == SCANNER_ERR_OK && wait_usb_.is_waiting())
{ {
@ -1268,12 +1307,14 @@ int hg_scanner_300::set_serial_num(string str)
} }
int hg_scanner_300::set_vid_pid(int data) int hg_scanner_300::set_vid_pid(int data)
{ {
std::lock_guard<std::mutex> lock(io_lock_);
USBCB usbcb = { setting3288dsp::SET_USB_INFOR_VIDPID,data,0 }; USBCB usbcb = { setting3288dsp::SET_USB_INFOR_VIDPID,data,0 };
int len = sizeof(usbcb); int len = sizeof(usbcb);
return io_->write_bulk(&usbcb, &len); return io_->write_bulk(&usbcb, &len);
} }
int hg_scanner_300::get_vid_pid(int& data) int hg_scanner_300::get_vid_pid(int& data)
{ {
std::lock_guard<std::mutex> lock(io_lock_);
USBCB usbcb = { setting3288dsp::GET_USB_INFOR_VIDPID,0,0 }; USBCB usbcb = { setting3288dsp::GET_USB_INFOR_VIDPID,0,0 };
int ret = SCANNER_ERR_OK, int ret = SCANNER_ERR_OK,
len = sizeof(usbcb); len = sizeof(usbcb);
@ -1295,12 +1336,16 @@ int hg_scanner_300::get_history_scan_count(int& num)
len = 0; len = 0;
USBCB usbcb = { setting3288dsp::GET_SCANN_NUM,0, 0 }; USBCB usbcb = { setting3288dsp::GET_SCANN_NUM,0, 0 };
len = sizeof(usbcb); len = sizeof(usbcb);
ret = io_->write_bulk(&usbcb, &len);
if (ret != SCANNER_ERR_OK)
{ {
return ret; std::lock_guard<std::mutex> lock(io_lock_);
ret = io_->write_bulk(&usbcb, &len);
if (ret != SCANNER_ERR_OK)
{
return ret;
}
ret = io_->read_bulk(&usbcb, &len);
} }
ret = io_->read_bulk(&usbcb, &len);
if (ret != SCANNER_ERR_OK) if (ret != SCANNER_ERR_OK)
{ {
return ret; return ret;
@ -1314,12 +1359,16 @@ int hg_scanner_300::get_roller_num(int& val)
len = 0; len = 0;
USBCB usbcb = { setting3288dsp::GET_ROLLER_NUM,0, 0 }; USBCB usbcb = { setting3288dsp::GET_ROLLER_NUM,0, 0 };
len = sizeof(usbcb); len = sizeof(usbcb);
ret = io_->write_bulk(&usbcb, &len);
if (ret != SCANNER_ERR_OK)
{ {
return ret; std::lock_guard<std::mutex> lock(io_lock_);
ret = io_->write_bulk(&usbcb, &len);
if (ret != SCANNER_ERR_OK)
{
return ret;
}
ret = io_->read_bulk(&usbcb, &len);
} }
ret = io_->read_bulk(&usbcb, &len);
if (ret != SCANNER_ERR_OK) if (ret != SCANNER_ERR_OK)
{ {
return ret; return ret;