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

调整虚继承函数接口统一

This commit is contained in:
13038267101 2022-12-22 18:37:53 +08:00
parent 234937a14f
commit 85c7d1b66d
16 changed files with 668 additions and 841 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
hgdriver/hgdev/common_setting.h
View File

@ -811,7 +811,7 @@ namespace setting3399
SR_CMD, SR_CMD,
SR_STATUS, SR_STATUS,
SR_SCAN_COUNT, SR_SCAN_COUNT,
SR_OS, SR_OS, //val == 1计数模式
SR_SENSORS, SR_SENSORS,
SR_MOTOR, SR_MOTOR,
SR_IM_TYPE, SR_IM_TYPE,

76
hgdriver/hgdev/hg_scanner.cpp
View File

@ -2307,8 +2307,8 @@ SANE_Image_Statu hg_scanner::last_usb_image_statu(int err)
{ {
if (err == SCANNER_ERR_DEVICE_DOUBLE_FEEDING) if (err == SCANNER_ERR_DEVICE_DOUBLE_FEEDING)
statu = SANE_Image_Statu_Double; statu = SANE_Image_Statu_Double;
else if (err == SCANNER_ERR_DEVICE_PAPER_JAMMED) //else if (err == SCANNER_ERR_DEVICE_PAPER_JAMMED)
statu = SANE_Image_Statu_Jammed; //statu = SANE_Image_Statu_Jammed;
} }
return statu; return statu;
@ -3061,7 +3061,7 @@ int hg_scanner::device_io_control(unsigned long code, void* data, unsigned* len)
if (len) if (len)
*len = val; *len = val;
return clear_roller_num(); return set_clear_roller_num();
} }
else if (code == IO_CTRL_CODE_GET_FINAL_IMAGE_FORMAT) else if (code == IO_CTRL_CODE_GET_FINAL_IMAGE_FORMAT)
{ {
@ -3153,7 +3153,7 @@ int hg_scanner::device_io_control(unsigned long code, void* data, unsigned* len)
} }
else if (code == IO_CTRL_CODE_GET_PAPER_ON) else if (code == IO_CTRL_CODE_GET_PAPER_ON)
{ {
return get_scanner_paperon((SANE_Bool*)data); return get_scanner_paperon(*(SANE_Bool*)data);
} }
else if(code == IO_CTRL_CODE_GET_POWER_LEVEL) else if(code == IO_CTRL_CODE_GET_POWER_LEVEL)
{ {
@ -3181,28 +3181,28 @@ int hg_scanner::device_io_control(unsigned long code, void* data, unsigned* len)
switch (val) switch (val)
{ {
case SANE_POWER_NONE: case SANE_POWER_NONE:
sleeptime = 0; sleeptime = -1;
break; break;
case SANE_POWER_MINUTES_5: case SANE_POWER_MINUTES_5:
sleeptime = 300; sleeptime = 5;
break; break;
case SANE_POWER_MINUTES_10: case SANE_POWER_MINUTES_10:
sleeptime = 600; sleeptime = 10;
break; break;
case SANE_POWER_MINUTES_20: case SANE_POWER_MINUTES_20:
sleeptime = 1200; sleeptime = 20;
break; break;
case SANE_POWER_MINUTES_30: case SANE_POWER_MINUTES_30:
sleeptime = 1800; sleeptime = 30;
break; break;
case SANE_POWER_MINUTES_60: case SANE_POWER_MINUTES_60:
sleeptime = 3600; sleeptime = 60;
break; break;
case SANE_POWER_MINUTES_120: case SANE_POWER_MINUTES_120:
sleeptime = 7200; sleeptime = 120;
break; break;
case SANE_POWER_MINUTES_240: case SANE_POWER_MINUTES_240:
sleeptime = 14400; sleeptime = 14424000;
break; break;
case SANE_POWER_SHUTDOWN: case SANE_POWER_SHUTDOWN:
set_devshtudown(); set_devshtudown();
@ -3211,7 +3211,7 @@ int hg_scanner::device_io_control(unsigned long code, void* data, unsigned* len)
set_devreboot(); set_devreboot();
break; break;
default: default:
sleeptime = 0; sleeptime = -1;
break; break;
} }
return set_sleep_time(sleeptime); return set_sleep_time(sleeptime);
@ -3310,7 +3310,7 @@ int hg_scanner::device_io_control(unsigned long code, void* data, unsigned* len)
else if (code == IO_CTRL_CODE_SET_FIRMWARE_UPGRADE) else if (code == IO_CTRL_CODE_SET_FIRMWARE_UPGRADE)
{ {
string str = (char*)data; string str = (char*)data;
return firmware_upgrade(str); return set_firmware_upgrade(str);
} }
else if (code == IO_CTRL_CODE_GET_HISTORY_ROLLER_NUM) else if (code == IO_CTRL_CODE_GET_HISTORY_ROLLER_NUM)
{ {
@ -3321,7 +3321,7 @@ int hg_scanner::device_io_control(unsigned long code, void* data, unsigned* len)
} }
else if (code == IO_CTRL_CODE_GET_CLEAN_PAPER_ROAD) else if (code == IO_CTRL_CODE_GET_CLEAN_PAPER_ROAD)
{ {
return clean_paper_road(); return set_clean_paper_road();
} }
else if (code == IO_CTRL_CODE_GET_SCANN_NUM) else if (code == IO_CTRL_CODE_GET_SCANN_NUM)
{ {
@ -3372,7 +3372,7 @@ int hg_scanner::set_devshtudown()
{ {
return SCANNER_ERR_DEVICE_NOT_SUPPORT; return SCANNER_ERR_DEVICE_NOT_SUPPORT;
} }
int hg_scanner::clear_roller_num(void) int hg_scanner::set_clear_roller_num(void)
{ {
return SCANNER_ERR_DEVICE_NOT_SUPPORT; return SCANNER_ERR_DEVICE_NOT_SUPPORT;
} }
@ -3392,11 +3392,11 @@ int hg_scanner::set_scan_lock_check_val(string check_str)
{ {
return SCANNER_ERR_DEVICE_NOT_SUPPORT; return SCANNER_ERR_DEVICE_NOT_SUPPORT;
} }
int hg_scanner::firmware_upgrade(std::string filename) int hg_scanner::set_firmware_upgrade(std::string filename)
{ {
return SCANNER_ERR_DEVICE_NOT_SUPPORT; return SCANNER_ERR_DEVICE_NOT_SUPPORT;
} }
int hg_scanner::clean_paper_road() int hg_scanner::set_clean_paper_road()
{ {
return SCANNER_ERR_DEVICE_NOT_SUPPORT; return SCANNER_ERR_DEVICE_NOT_SUPPORT;
} }
@ -3408,6 +3408,10 @@ int hg_scanner::set_dev_islock_file(int islockfile)
{ {
return SCANNER_ERR_DEVICE_NOT_SUPPORT; return SCANNER_ERR_DEVICE_NOT_SUPPORT;
} }
int hg_scanner::get_scan_mode(bool& type)
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
////////////////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////////////////
int hg_scanner::set_leaflet_scan(void) int hg_scanner::set_leaflet_scan(void)
{ {
@ -3468,47 +3472,25 @@ int hg_scanner::get_device_code(void)
{ {
return SCANNER_ERR_DEVICE_NOT_SUPPORT; return SCANNER_ERR_DEVICE_NOT_SUPPORT;
} }
int hg_scanner::get_sleep_time(int& getsleepime) int hg_scanner::get_sleep_time(int& data)
{ {
return SCANNER_ERR_DEVICE_NOT_SUPPORT; return SCANNER_ERR_DEVICE_NOT_SUPPORT;
} }
int hg_scanner::set_sleep_time(int sleeptime) int hg_scanner::set_sleep_time(int data)
{ {
return SCANNER_ERR_DEVICE_NOT_SUPPORT; return SCANNER_ERR_DEVICE_NOT_SUPPORT;
} }
int hg_scanner::notify_sleep() int hg_scanner::set_notify_sleep()
{ {
return SCANNER_ERR_DEVICE_NOT_SUPPORT; return SCANNER_ERR_DEVICE_NOT_SUPPORT;
} }
int hg_scanner::get_dogear_distance(void)
int hg_scanner::get_scanner_paperon(SANE_Bool& paperon)
{ {
return SCANNER_ERR_DEVICE_NOT_SUPPORT; return SCANNER_ERR_DEVICE_NOT_SUPPORT;
} }
int hg_scanner::set_dogear_distance(void)
{ int hg_scanner::get_scan_is_sleep(SANE_Bool& data)
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner::get_scanner_paperon(SANE_Bool* paperon)
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner::set_scan_when_paper_on(void)
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner::get_scan_when_paper_on(void)
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner::get_scan_with_hole(void)
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner::set_scan_with_hole(void)
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner::get_scan_is_sleep(void)
{ {
return SCANNER_ERR_DEVICE_NOT_SUPPORT; return SCANNER_ERR_DEVICE_NOT_SUPPORT;
} }

67
hgdriver/hgdev/hg_scanner.h
View File

@ -428,41 +428,42 @@ public:
virtual std::string get_firmware_version(void); virtual std::string get_firmware_version(void);
virtual std::string get_serial_num(void); virtual std::string get_serial_num(void);
virtual std::string get_ip(void); virtual std::string get_ip(void);
/// <summary>
/// retuen scanner_err /////////////////成功返回:SCANNER_ERR_OK /////////////
/// </summary> /////////////////失败返回:IO错误码 /////////////
virtual int set_leaflet_scan(void) = 0; //单张扫描 virtual int set_leaflet_scan(void) = 0; //单张扫描
virtual int get_abuot_info(void) = 0; //获取软件关于信息 (基类实现) virtual int get_abuot_info(void); //获取软件关于信息 (基类实现)
virtual int restore_default_setting(void); //恢复默认设置 (基类实现) virtual int restore_default_setting(void); //恢复默认设置 (基类实现)
virtual int set_final_image_format(SANE_FinalImgFormat* fmt);//设置图像处理最终输出（final()）的图像数据格式 (基类实现) *** virtual int set_final_image_format(SANE_FinalImgFormat* fmt);//设置图像处理最终输出（final()）的图像数据格式 (基类实现) ***
virtual int get_compression_format(void); //获取支持的压缩格式 功能不支持
virtual int clear_roller_num(void); // 清除滚轴计数
virtual int set_compression_format(void); //设置图像数据最终输出的压缩格式 virtual int get_compression_format(void); //获取支持的压缩格式 不支持
virtual int set_auto_color_type(void); //设置自动匹配颜色模式 (基类实现) *** virtual int set_compression_format(void); //设置图像数据最终输出的压缩格式 不支持
virtual int get_device_code(void); //获取设备编码
virtual int get_dogear_distance(void); //获取折角检测最小距离阈值 virtual int set_auto_color_type(void); //设置自动匹配颜色模式 (基类实现)
virtual int set_dogear_distance(void); // 设置折角检测最小距离阈值 virtual int set_clear_roller_num(void) = 0; //清除滚轴计数
virtual int get_scanner_paperon(SANE_Bool* paperon = NULL)=0;//获取设备有无纸张
virtual int set_scan_when_paper_on(void); //获取是否为检测到进纸盘上有纸即开始扫描 virtual int get_device_code(void); //获取设备编码 不支持
virtual int get_scan_when_paper_on(void); //设置是否为检测到进纸盘上有纸即开始扫描
virtual int get_scan_with_hole(void); //获取是否为带孔扫描 virtual int get_scanner_paperon(SANE_Bool& type)=0; //获取设备有无纸张 /*/ type : false无纸（不正常状态false） true有纸 */
virtual int set_scan_with_hole(void); //设置是否为带孔扫描
virtual int get_scan_is_sleep(void); //获取设备是否休眠当中 virtual int get_scan_is_sleep(SANE_Bool& type) = 0; //获取设备是否休眠当中 /*/ type : false休眠（不正常状态false） true未休眠*/
virtual int get_sleep_time(int& getsleepime); //获取功耗模式（休眠） virtual int get_sleep_time(int& data) = 0; //获取功耗模式（休眠） /*/ data > 0*/
virtual int set_sleep_time(int sleeptime); //设置功耗模式（休眠） virtual int set_sleep_time(int data) = 0; //设置功耗模式（休眠） /*/ data > 0*/
virtual int get_history_roller_count(int &num) = 0; //获取历史扫描张数 virtual int get_history_roller_count(int &data) = 0; //获取历史扫描张数 /*/ data > 0*/
virtual int get_roller_num(int &val) = 0; //获取滚轮张数 virtual int get_roller_num(int &data) = 0; //获取滚轮张数 /*/ data > 0*/
virtual int notify_sleep(void); //唤醒设备 virtual int set_notify_sleep(void) = 0; //唤醒设备
virtual int get_device_log(string &log); //获取设备日志 virtual int get_device_log(string &log) = 0; //获取设备日志 /*/ log :储存路径*/
virtual int set_devreboot(); //设置设备重启 virtual int set_devreboot() = 0; //设置设备重启
virtual int set_devshtudown(); //设置设备关机 virtual int set_devshtudown() = 0; //设置设备关机
virtual int set_scan_islock(SANE_Bool set_islock); //设置设备是否锁定 0解锁，1锁定 ret virtual int set_scan_islock(SANE_Bool type) = 0; //设置设备是否锁定 /*/ type:0解锁，1锁定*/
virtual int get_scan_islock(SANE_Bool& islock); //获取设备是否锁定 0解锁，1锁定 virtual int get_scan_islock(SANE_Bool& type) = 0; //获取设备是否锁定 /*/ type:0解锁，1锁定*/
virtual int set_scan_lock_check_val(string check_str); //获取设备是否锁定 virtual int set_scan_lock_check_val(string str) = 0; //获取设备是否锁定 /*/ str:校验码*/
virtual int firmware_upgrade(std::string filename); //固件升级 virtual int set_firmware_upgrade(std::string str) = 0; //固件升级 /*/ str:文件名路径*/
virtual int clean_paper_road(); //清理纸道 virtual int set_clean_paper_road() = 0; //清理纸道
virtual int get_dev_islock_file(int &islockfile); //获取设备文件 设备锁状态 0 未上锁，1 上锁。-1 未发现黑名单列表 -2列表当中没有信息 virtual int get_dev_islock_file(int &data) = 0; //获取设备文件 /*/ data:0 未上锁，1 上锁。-1 未发现黑名单列表 -2列表没有信息*/
virtual int set_dev_islock_file(int islockfile); //设置设备文件 设备锁状态 0 未上锁，1 上锁。 virtual int set_dev_islock_file(int data) = 0; //设置设备文件 /*/ data:0 未上锁，1 上锁*/
virtual int get_scan_mode(bool& type) ; //获取设备是否计数模式 /*/ type:false计数模式 true非计数模式
}; };
#ifdef UOS #ifdef UOS

184
hgdriver/hgdev/hg_scanner_200.cpp
View File

@ -226,10 +226,11 @@ int hg_scanner_200::start(void)
return ret; return ret;
} }
printf_devconfig(); printf_devconfig();
ret = get_scanner_paperon(); SANE_Bool type = false;
if (ret == SCANNER_ERR_DEVICE_NO_PAPER) ret = get_scanner_paperon(type);
if (!type)
{ {
status_ = ret; status_ = ret = SCANNER_ERR_DEVICE_NO_PAPER;
notify_ui_working_status(STATU_DESC_SCANNER_ERR_DEVICE_NO_PAPER, SANE_EVENT_ERROR, status_); notify_ui_working_status(STATU_DESC_SCANNER_ERR_DEVICE_NO_PAPER, SANE_EVENT_ERROR, status_);
VLOG_MINI_1(LOG_LEVEL_WARNING, "device start status is(%s)\n", STATU_DESC_SCANNER_ERR_DEVICE_NO_PAPER); VLOG_MINI_1(LOG_LEVEL_WARNING, "device start status is(%s)\n", STATU_DESC_SCANNER_ERR_DEVICE_NO_PAPER);
return ret; return ret;
@ -665,22 +666,16 @@ std::string hg_scanner_200::get_serial_num()
return buf; return buf;
} }
std::string hg_scanner_200::get_ip(void)
{
return "";
}
int hg_scanner_200::agreement() int hg_scanner_200::agreement()
{ {
int ret = SCANNER_ERR_OK; int ret = SCANNER_ERR_OK;
//if (image_prc_param_.bits.rid_color != RID_COLOR_NONE)
//{
// dsp_config_.params_dsp.color = 1;
//}
//
ret = writedown_device_configuration(true); ret = writedown_device_configuration(true);
//io_->set_timeout(200);
return ret; return ret;
} }
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
int hg_scanner_200::set_leaflet_scan(void) int hg_scanner_200::set_leaflet_scan(void)
{ {
int ret = SCANNER_ERR_OK; int ret = SCANNER_ERR_OK;
@ -689,35 +684,17 @@ int hg_scanner_200::set_leaflet_scan(void)
ret = start(); ret = start();
return ret; return ret;
} }
int hg_scanner_200::get_abuot_info(void)
int hg_scanner_200::set_clear_roller_num(void)
{ {
return SCANNER_ERR_DEVICE_NOT_SUPPORT; return 0;
}
int hg_scanner_200::restore_default_setting(void)
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner_200::set_img_format(void)
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner_200::get_compression_format(void)
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner_200::set_compression_format(void)
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner_200::set_auto_color_type(void)
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
} }
int hg_scanner_200::get_device_code(void) int hg_scanner_200::get_device_code(void)
{ {
return SCANNER_ERR_DEVICE_NOT_SUPPORT; return SCANNER_ERR_DEVICE_NOT_SUPPORT;
} }
int hg_scanner_200::get_sleep_time(SANE_Power* getime) int hg_scanner_200::get_sleep_time(int& data )
{ {
int ret = SCANNER_ERR_OK, int ret = SCANNER_ERR_OK,
len = 0; len = 0;
@ -733,86 +710,43 @@ int hg_scanner_200::get_sleep_time(SANE_Power* getime)
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)
{ {
if (getime) data = usbcb.u32_Data;
{
*getime = (SANE_Power)usbcb.u32_Data;
}
if (usbcb.u32_Data)
{
return SCANNER_ERR_DEVICE_SLEEPING;
}
} }
return ret; return ret;
} }
int hg_scanner_200::set_sleep_time(SANE_Power* setime) int hg_scanner_200::set_sleep_time(int data)
{ {
if (!setime) int ret = SCANNER_ERR_OK;
{ USBCB usbcb = { setting3288dsp::SET_SLEEP_TIME,data, 0 };
return SCANNER_ERR_NO_DATA;
}
int ret = SCANNER_ERR_OK,
time = *setime;
USBCB usbcb = { setting3288dsp::SET_SLEEP_TIME,time, 0 };
ret = writeusb(usbcb); ret = writeusb(usbcb);
return ret; return ret;
} }
int hg_scanner_200::get_dogear_distance(void)
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner_200::set_dogear_distance(void)
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner_200::get_scanner_paperon(SANE_Bool* paperon)
{
int ret = SCANNER_ERR_OK,
len = 0;
int hg_scanner_200::get_scanner_paperon(SANE_Bool& type)
{
int ret = SCANNER_ERR_OK,
len = 0;
USBCB usbcb = { setting3288dsp::GET_PAPER_STATUS, 0, 0 }; USBCB usbcb = { setting3288dsp::GET_PAPER_STATUS, 0, 0 };
len = sizeof(USBCB); len = sizeof(USBCB);
ret = writeusb(usbcb); ret = writeusb(usbcb);
io_->set_timeout(500);
if (ret == SCANNER_ERR_OK) 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 = io_->read_bulk(&usbcb, &len);
} type = usbcb.u32_Data == 0 ? false : true;
if (ret != SCANNER_ERR_OK)
{
return ret;
}
if (usbcb.u32_Data == 0)
ret = SCANNER_ERR_DEVICE_NO_PAPER;
else
ret = SCANNER_ERR_OK;
if (paperon)
{
*paperon = usbcb.u32_Data;
} }
//if (usbcb.u32_Data == 0)
// ret = SCANNER_ERR_DEVICE_NO_PAPER;
//else
// ret = SCANNER_ERR_OK;
return ret; return ret;
} }
int hg_scanner_200::set_scan_when_paper_on(void)
{ int hg_scanner_200::get_scan_is_sleep(SANE_Bool& type)
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner_200::get_scan_when_paper_on(void)
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner_200::get_scan_with_hole(void)
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner_200::set_scan_with_hole(void)
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner_200::get_scan_is_sleep()
{ {
int ret = SCANNER_ERR_OK, int ret = SCANNER_ERR_OK,
len = 0; len = 0;
@ -821,31 +755,65 @@ int hg_scanner_200::get_scan_is_sleep()
len = sizeof(USBCB); len = sizeof(USBCB);
ret = writeusb(usbcb); ret = writeusb(usbcb);
io_->set_timeout(200);
if (ret == SCANNER_ERR_OK) 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 = io_->read_bulk(&usbcb,&len);
} }
if (ret != SCANNER_ERR_OK) if (ret == SCANNER_ERR_OK)
{ {
return ret; if (usbcb.u32_Data == 0x10)
} type = true;
if (usbcb.u32_Data == 0x10) //return SCANNER_ERR_OK;
{ else if (usbcb.u32_Data == 0x100)
return SCANNER_ERR_OK; type = false;
} //return SCANNER_ERR_DEVICE_SLEEPING;
else if (usbcb.u32_Data == 0x100)
{
return SCANNER_ERR_DEVICE_SLEEPING;
} }
return ret;
} }
int hg_scanner_200::get_device_log(string &log) int hg_scanner_200::get_device_log(string &log)
{ {
return SCANNER_ERR_DEVICE_NOT_SUPPORT; return SCANNER_ERR_DEVICE_NOT_SUPPORT;
} }
int hg_scanner_200::notify_sleep() int hg_scanner_200::set_devreboot()
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner_200::set_devshtudown()
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;;
}
int hg_scanner_200::set_scan_islock(SANE_Bool type)
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;;
}
int hg_scanner_200::get_scan_islock(SANE_Bool& type)
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;;
}
int hg_scanner_200::set_scan_lock_check_val(string str)
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;;
}
int hg_scanner_200::set_firmware_upgrade(std::string str)
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;;
}
int hg_scanner_200::set_clean_paper_road()
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;;
}
int hg_scanner_200::get_dev_islock_file(int& data)
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;;
}
int hg_scanner_200::set_dev_islock_file(int data)
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;;
}
int hg_scanner_200::set_notify_sleep()
{ {
return SCANNER_ERR_DEVICE_NOT_SUPPORT; return SCANNER_ERR_DEVICE_NOT_SUPPORT;
} }

59
hgdriver/hgdev/hg_scanner_200.h
View File

@ -54,38 +54,41 @@ private:
int writedown_device_configuration(bool type =false,setting_hardware::HGSCANCONF_DSP *d = NULL); int writedown_device_configuration(bool type =false,setting_hardware::HGSCANCONF_DSP *d = NULL);
void writedown_image_configuration(void); void writedown_image_configuration(void);
void printf_devconfig(setting_hardware::HGSCANCONF_DSP *d = NULL); void printf_devconfig(setting_hardware::HGSCANCONF_DSP *d = NULL);
virtual std::string get_firmware_version(void) override;
virtual std::string get_serial_num(void) override;
setting_hardware::HGSCANCONF_DSP dsp_config_; setting_hardware::HGSCANCONF_DSP dsp_config_;
int agreement(); int agreement();
public: public:
virtual int set_leaflet_scan(void);//单张扫描 virtual std::string get_firmware_version(void);
virtual int get_abuot_info(void);//获取软件关于信息 virtual std::string get_serial_num(void);
virtual int restore_default_setting(void);//恢复默认设置 virtual std::string get_ip(void);
virtual int set_img_format(void); // 设置图像处理最终输出（final()）的图像数据格式
virtual int get_compression_format(void);//获取支持的压缩格式
virtual int set_compression_format(void);//设置图像数据最终输出的压缩格式
virtual int set_auto_color_type(void);// 设置自动匹配颜色模式
virtual int get_device_code(void);//获取设备编码
virtual int get_sleep_time(SANE_Power* setime = NULL);//获取功耗模式（休眠）
virtual int set_sleep_time(SANE_Power* setime);//设置功耗模式（休眠）
virtual int get_dogear_distance(void);//获取折角检测最小距离阈值
virtual int set_dogear_distance(void);// 设置折角检测最小距离阈值
virtual int get_scanner_paperon(SANE_Bool* paperon=NULL);//获取设备有无纸张
virtual int set_scan_when_paper_on(void);//获取是否为检测到进纸盘上有纸即开始扫描
virtual int get_scan_when_paper_on(void);//设置是否为检测到进纸盘上有纸即开始扫描
virtual int get_scan_with_hole(void);// 获取是否为带孔扫描
virtual int set_scan_with_hole(void);// 设置是否为带孔扫描
virtual int get_scan_is_sleep(void);//获取设备是否休眠当中
virtual int get_device_log(string &log);//获取设备日志
virtual int notify_sleep(void);//唤醒设备
virtual int get_history_roller_count(int& num); //获取历史扫描张数
virtual int get_roller_num(int& val); //获取滚轮张数
public: /////////////////成功返回:SCANNER_ERR_OK /////////////
//virtual int get_roller_num(void) override; //获取滚轮张数 -2：设备不支持该功能；-1：与设备通信失败；其它大于等于0的为正常 /////////////////失败返回:IO错误码 /////////////
//virtual int clear_roller_num(void) override; // 清除滚轴计数 virtual int set_leaflet_scan(void) override; //单张扫描
//virtual int get_history_count(void) override;//获取历史扫描张数 -2：设备不支持该功能；-1：与设备通信失败；其它大于等于0的为正常
virtual int set_clear_roller_num(void) override; //清除滚轴计数
virtual int get_device_code(void); //获取设备编码 不支持
virtual int get_scanner_paperon(SANE_Bool& type) override; //获取设备有无纸张 /*/ type : 0无纸 1有纸 */
virtual int get_scan_is_sleep(SANE_Bool& type) override; //获取设备是否休眠当中 /*/ type : 0休眠 1唤醒状态*/
virtual int get_sleep_time(int& data) override; //获取功耗模式（休眠） /*/ data > 0*/
virtual int set_sleep_time(int data) override; //设置功耗模式（休眠） /*/ data > 0*/
virtual int get_history_roller_count(int& data) override; //获取历史扫描张数 /*/ data > 0*/
virtual int get_roller_num(int& data) override; //获取滚轮张数 /*/ data > 0*/
virtual int set_notify_sleep(void) override; //唤醒设备
virtual int get_device_log(string& log) override; //获取设备日志 /*/ log :储存路径*/
virtual int set_devreboot() override; //设置设备重启
virtual int set_devshtudown() override; //设置设备关机
virtual int set_scan_islock(SANE_Bool type) override; //设置设备是否锁定 /*/ type:0解锁，1锁定*/
virtual int get_scan_islock(SANE_Bool& type) override; //获取设备是否锁定 /*/ type:0解锁，1锁定*/
virtual int set_scan_lock_check_val(string str) override; //获取设备是否锁定 /*/ str:校验码*/
virtual int set_firmware_upgrade(std::string str) override; //固件升级 /*/ str:文件名路径*/
virtual int set_clean_paper_road() override; //清理纸道
virtual int get_dev_islock_file(int& data) override; //获取设备文件 /*/ data:0 未上锁，1 上锁。-1 未发现黑名单列表 -2列表没有信息*/
virtual int set_dev_islock_file(int data) override; //设置设备文件 /*/ data:0 未上锁，1 上锁*/
}; };

139
hgdriver/hgdev/hg_scanner_239.cpp
View File

@ -243,17 +243,16 @@ std::string hg_scanner_239::get_fpga(void)
return fpga; return fpga;
} }
int hg_scanner_239::get_scan_mode(int &v) int hg_scanner_239::get_scan_mode(bool &type)
{ {
int val = 0, int val = 0,
ret = read_register(setting3399::SR_OS, &val); ret = read_register(setting3399::SR_OS, &val); //val == 1计数模式
v = val; type =val == 1 ? false : true;
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "get scan mode error: %s\n", hg_scanner_err_name(ret));
if (val == 1) //if (val == 1)
{ //{
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "get scan mode error: %s\n", hg_scanner_err_name(ret)); //return SCANNER_ERR_DEVICE_COUNT_MODE;
return SCANNER_ERR_DEVICE_COUNT_MODE; //}
}
return ret; return ret;
} }
int hg_scanner_239::get_status(void) int hg_scanner_239::get_status(void)
@ -1062,8 +1061,13 @@ void hg_scanner_239::thread_handle_usb_read(void)
} }
if (status_ == SCANNER_ERR_DEVICE_STOPPED && !user_cancel_) if (status_ == SCANNER_ERR_DEVICE_STOPPED && !user_cancel_)
{ {
SANE_Bool b = false; SANE_Bool b = true;
status_ = ret = get_scanner_paperon(&b); ret = get_scanner_paperon(b);
if (ret != SCANNER_ERR_OK)
{
status_ = ret;
}
status_ = b ? SCANNER_ERR_OK : SCANNER_ERR_DEVICE_NO_PAPER;
} }
VLOG_MINI_2(LOG_LEVEL_DEBUG_INFO, "USB thread exit with code: %s, status = %s\n", hg_scanner_err_name(ret), hg_scanner_err_name(status_)); VLOG_MINI_2(LOG_LEVEL_DEBUG_INFO, "USB thread exit with code: %s, status = %s\n", hg_scanner_err_name(ret), hg_scanner_err_name(status_));
} }
@ -1093,17 +1097,19 @@ int hg_scanner_239::start(void)
//ret = get_roller_num(val); //ret = get_roller_num(val);
//211220固件版本不支持返回 //211220固件版本不支持返回
ret = get_scan_is_sleep(val);
if ((get_scan_is_sleep(val)) == SCANNER_ERR_DEVICE_SLEEPING) if (!val)
{ {
status_ = SCANNER_ERR_DEVICE_SLEEPING; status_ = SCANNER_ERR_DEVICE_SLEEPING;
VLOG_MINI_1(LOG_LEVEL_WARNING, "device start status is(%s)\n", STATU_DESC_SCANNER_ERR_DEVICE_SLEEPING); VLOG_MINI_1(LOG_LEVEL_WARNING, "device start status is(%s)\n", STATU_DESC_SCANNER_ERR_DEVICE_SLEEPING);
if(is_kernelsnap_220830_) if(is_kernelsnap_220830_)
ret = notify_sleep(); ret = set_notify_sleep();
notify_ui_working_status(STATU_DESC_SCANNER_ERR_DEVICE_NOTIFY_SLEEP, SANE_EVENT_ERROR, status_); notify_ui_working_status(STATU_DESC_SCANNER_ERR_DEVICE_NOTIFY_SLEEP, SANE_EVENT_ERROR, status_);
return status_; return status_;
} }
else if (( get_scan_mode(val)) == SCANNER_ERR_DEVICE_COUNT_MODE) bool type = true;
ret = get_scan_mode(type);
if (!type)
{ {
status_ = SCANNER_ERR_DEVICE_COUNT_MODE; status_ = SCANNER_ERR_DEVICE_COUNT_MODE;
return status_; return status_;
@ -1206,8 +1212,6 @@ int hg_scanner_239::device_io_control(unsigned long code, void* data, unsigned*
} }
std::string hg_scanner_239::get_firmware_version(void) std::string hg_scanner_239::get_firmware_version(void)
{ {
return control_fetch(setting3399::SR_GET_FWVERSION, 0, 20); return control_fetch(setting3399::SR_GET_FWVERSION, 0, 20);
} }
std::string hg_scanner_239::get_serial_num(void) std::string hg_scanner_239::get_serial_num(void)
@ -1225,7 +1229,7 @@ int hg_scanner_239::get_history_roller_count(int &val)
int ret = read_register(setting3399::SR_GET_SCANN_NUM, &val); int ret = read_register(setting3399::SR_GET_SCANN_NUM, &val);
return ret; return ret;
} }
int hg_scanner_239::clear_roller_num(void) int hg_scanner_239::set_clear_roller_num(void)
{ {
int val = 0, int val = 0,
ret = read_register(setting3399::SR_CLR_ROLLER_NUM, &val); ret = read_register(setting3399::SR_CLR_ROLLER_NUM, &val);
@ -1241,45 +1245,23 @@ int hg_scanner_239::set_leaflet_scan(void)
ret = start(); ret = start();
return ret; return ret;
} }
int hg_scanner_239::get_abuot_info(void)
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner_239::restore_default_setting(void)
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner_239::set_final_image_format(SANE_FinalImgFormat* fmt)
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner_239::get_compression_format(void)
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner_239::set_compression_format(void)
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner_239::set_auto_color_type(void)
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner_239::get_device_code(void) int hg_scanner_239::get_device_code(void)
{ {
return SCANNER_ERR_DEVICE_NOT_SUPPORT; return SCANNER_ERR_DEVICE_NOT_SUPPORT;
} }
int hg_scanner_239::get_sleep_time(int& getime) int hg_scanner_239::get_sleep_time(int& data)
{ {
int val = 0, int val = 0;
ret = read_register(setting3399::SR_GET_SLEEPTIME, &val); int ret = read_register(setting3399::SR_GET_SLEEPTIME, &val);
if (ret == SCANNER_ERR_OK) if (ret == SCANNER_ERR_OK)
{ {
getime = val;
save_sleeptime_type_ = true; save_sleeptime_type_ = true;
data = val;
} }
VLOG_MINI_2(LOG_LEVEL_DEBUG_INFO, "get_sleep_time = %d with %s\n", val,hg_scanner_err_name(ret));
VLOG_MINI_2(LOG_LEVEL_DEBUG_INFO, "get_sleep_time = %d with %s\n", data,hg_scanner_err_name(ret));
return ret; return ret;
} }
int hg_scanner_239::set_sleep_time(int setsleepime) int hg_scanner_239::set_sleep_time(int setsleepime)
@ -1290,51 +1272,32 @@ int hg_scanner_239::set_sleep_time(int setsleepime)
return ret; return ret;
} }
int hg_scanner_239::get_dogear_distance(void)
int hg_scanner_239::get_scanner_paperon(SANE_Bool& type)
{ {
return SCANNER_ERR_DEVICE_NOT_SUPPORT; int val = 0;
} int ret = read_register(setting3399::SR_GET_PAPERON, &val); //0无纸 1有纸
int hg_scanner_239::set_dogear_distance(void) if (ret == SCANNER_ERR_OK)
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner_239::get_scanner_paperon(SANE_Bool* paperon)
{
int val = 0,
ret = read_register(setting3399::SR_GET_PAPERON, &val);
if (ret != SCANNER_ERR_OK)
{ {
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "get_scanner_paperon = %s\n", hg_scanner_err_name(ret)); type = val == 0 ? false : true;
return ret;
} }
ret = val ? SCANNER_ERR_OK : SCANNER_ERR_DEVICE_NO_PAPER; VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "get_scanner_paperon = %s\n", hg_scanner_err_name(ret));
*paperon = val;
return ret; return ret;
} }
int hg_scanner_239::set_scan_when_paper_on(void)
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner_239::get_scan_when_paper_on(void)
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner_239::get_scan_with_hole(void)
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner_239::set_scan_with_hole(void)
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner_239::get_scan_is_sleep(int& status)
{
int ret = 0;
ret = read_register(setting3399::SR_GET_SLEEP_STAUTUS, &status); int hg_scanner_239::get_scan_is_sleep(SANE_Bool& type)
return ret = status ? SCANNER_ERR_OK : SCANNER_ERR_DEVICE_SLEEPING; {
int ret = 0,val;
ret = read_register(setting3399::SR_GET_SLEEP_STAUTUS, &val); //0休眠 1唤醒状态
if (ret == SCANNER_ERR_OK)
{
type = val == 1 ? true : false;
}
return ret;
} }
int hg_scanner_239::notify_sleep() int hg_scanner_239::set_notify_sleep()
{ {
int val = 0, int val = 0,
ret = SCANNER_ERR_OK; ret = SCANNER_ERR_OK;
@ -1510,7 +1473,7 @@ int hg_scanner_239::set_scan_lock_check_val(string check_str)
return ret; return ret;
#endif #endif
} }
int hg_scanner_239::firmware_upgrade(std::string filename) int hg_scanner_239::set_firmware_upgrade(std::string filename)
{ {
std::lock_guard<std::mutex> lock(io_lock_); std::lock_guard<std::mutex> lock(io_lock_);
std::ifstream fwname; std::ifstream fwname;
@ -1588,9 +1551,9 @@ int hg_scanner_239::firmware_upgrade(std::string filename)
} }
return ret; return ret;
} }
int hg_scanner_239::clean_paper_road() int hg_scanner_239::set_clean_paper_road()
{ {
std::lock_guard<std::mutex> lock(io_lock_); //std::lock_guard<std::mutex> lock(io_lock_);
int ret = 0, len = 0; int ret = 0, len = 0;
ret = write_register(setting3399::SR_CLEAN_PAPER_ROAD, len); ret = write_register(setting3399::SR_CLEAN_PAPER_ROAD, len);
return ret; return ret;

61
hgdriver/hgdev/hg_scanner_239.h
View File

@ -30,7 +30,6 @@ class hg_scanner_239 : public hg_scanner
std::string control_fetch(int addr, int val, int size); std::string control_fetch(int addr, int val, int size);
std::string get_fpga(void); std::string get_fpga(void);
int get_scan_mode(int &v);
int get_status(void); int get_status(void);
int get_image_count(void); int get_image_count(void);
int get_front_data_size(void); int get_front_data_size(void);
@ -81,37 +80,33 @@ public:
virtual std::string get_firmware_version(void); virtual std::string get_firmware_version(void);
virtual std::string get_serial_num(void); virtual std::string get_serial_num(void);
virtual std::string get_ip(void); virtual std::string get_ip(void);
virtual int set_leaflet_scan(void); //单张扫描
virtual int get_abuot_info(void); //获取软件关于信息 (基类实现) /////////////////成功返回:SCANNER_ERR_OK /////////////
virtual int restore_default_setting(void); //恢复默认设置 (基类实现) /////////////////失败返回:IO错误码 /////////////
virtual int set_final_image_format(SANE_FinalImgFormat* fmt); // 设置图像处理最终输出（final()）的图像数据格式 (基类实现) *** virtual int set_leaflet_scan(void) override; //单张扫描
virtual int get_compression_format(void); //获取支持的压缩格式
virtual int get_roller_num(int &val); //获取滚轮张数 virtual int set_clear_roller_num(void) override; //清除滚轴计数
virtual int clear_roller_num(void); //清除滚轴计数
virtual int set_compression_format(void); //设置图像数据最终输出的压缩格式 ***功能不支持 virtual int get_device_code(void); //获取设备编码 不支持
virtual int set_auto_color_type(void); //设置自动匹配颜色模式 (基类实现) ***完成
virtual int get_device_code(void); //获取设备编码 virtual int get_scanner_paperon(SANE_Bool& type) override; //获取设备有无纸张 /*/ type : 0无纸 1有纸 */
virtual int get_sleep_time(int& getime); //获取功耗模式（休眠）
virtual int set_sleep_time(int setsleepime); //设置功耗模式（休眠） virtual int get_scan_is_sleep(SANE_Bool& type) override; //获取设备是否休眠当中 /*/ type : 0休眠 1唤醒状态*/
virtual int get_dogear_distance(void); //获取折角检测最小距离阈值 virtual int get_sleep_time(int& data) override; //获取功耗模式（休眠） /*/ data > 0*/
virtual int set_dogear_distance(void); //设置折角检测最小距离阈值 virtual int set_sleep_time(int data) override; //设置功耗模式（休眠） /*/ data > 0*/
virtual int get_scanner_paperon(SANE_Bool* paperon);//获取设备有无纸张 virtual int get_history_roller_count(int& data) override; //获取历史扫描张数 /*/ data > 0*/
virtual int set_scan_when_paper_on(void); //获取是否为检测到进纸盘上有纸即开始扫描 virtual int get_roller_num(int& data) override; //获取滚轮张数 /*/ data > 0*/
virtual int get_scan_when_paper_on(void); //设置是否为检测到进纸盘上有纸即开始扫描 virtual int set_notify_sleep(void) override; //唤醒设备
virtual int get_scan_with_hole(void); //获取是否为带孔扫描 virtual int get_device_log(string& log) override; //获取设备日志 /*/ log :储存路径*/
virtual int set_scan_with_hole(void); //设置是否为带孔扫描 virtual int set_devreboot() override; //设置设备重启
virtual int get_scan_is_sleep(int &status); //获取设备是否休眠当中 virtual int set_devshtudown() override; //设置设备关机
virtual int notify_sleep(void); //唤醒设备 virtual int set_scan_islock(SANE_Bool type) override; //设置设备是否锁定 /*/ type:0解锁，1锁定*/
virtual int get_history_roller_count(int &num); //获取历史扫描张数 virtual int get_scan_islock(SANE_Bool& type) override; //获取设备是否锁定 /*/ type:0解锁，1锁定*/
virtual int get_device_log(string &get_device_log); //获取设备日志 virtual int set_scan_lock_check_val(string str) override; //获取设备是否锁定 /*/ str:校验码*/
virtual int set_devreboot(); //设置设备重启 virtual int set_firmware_upgrade(std::string str) override; //固件升级 /*/ str:文件名路径*/
virtual int set_devshtudown(); //设置设备关机 virtual int set_clean_paper_road() override; //清理纸道
virtual int set_scan_islock(SANE_Bool set_islock); virtual int get_dev_islock_file(int& data) override; //获取设备文件 /*/ data:0 未上锁，1 上锁。-1 未发现黑名单列表 -2列表没有信息*/
virtual int get_scan_islock(SANE_Bool& islock); virtual int set_dev_islock_file(int data) override; //设置设备文件 /*/ data:0 未上锁，1 上锁*/
virtual int set_scan_lock_check_val(string check_str); virtual int get_scan_mode(bool& type);
virtual int firmware_upgrade(std::string filename);
virtual int clean_paper_road(); //清理纸道
virtual int get_dev_islock_file(int& islockfile); //获取设备文件 设备锁状态 0 未上锁，1 上锁。
virtual int set_dev_islock_file(int islockfile); //设置设备文件 设备锁状态 0 未上锁，1 上锁。
}; };

195
hgdriver/hgdev/hg_scanner_300.cpp
View File

@ -168,7 +168,8 @@ void hg_scanner_300::thread_handle_usb_read(void)
{ {
bool handled = false; bool handled = false;
int ret = try_third_app_handle_start(handled), int ret = try_third_app_handle_start(handled),
count = -1; count = -1,
val = 1;
user_cancel_ = false; user_cancel_ = false;
@ -186,22 +187,22 @@ void hg_scanner_300::thread_handle_usb_read(void)
} }
printf_devconfig(); printf_devconfig();
ret = get_scan_is_sleep(); ret = get_scan_is_sleep(val);
if (ret == SCANNER_ERR_DEVICE_SLEEPING) if (!val)
{ {
status_ = ret; status_ = SCANNER_ERR_DEVICE_SLEEPING;
notify_ui_working_status(STATU_DESC_SCANNER_ERR_DEVICE_SLEEPING, SANE_EVENT_ERROR, status_); notify_ui_working_status(STATU_DESC_SCANNER_ERR_DEVICE_SLEEPING, SANE_EVENT_ERROR, status_);
notify_ui_working_status(STATU_DESC_SCANNER_ERR_DEVICE_NOTIFY_SLEEP, SANE_EVENT_ERROR, status_); notify_ui_working_status(STATU_DESC_SCANNER_ERR_DEVICE_NOTIFY_SLEEP, SANE_EVENT_ERROR, status_);
VLOG_MINI_1(LOG_LEVEL_WARNING, "device start status is(%s)\n", STATU_DESC_SCANNER_ERR_DEVICE_SLEEPING); VLOG_MINI_1(LOG_LEVEL_WARNING, "device start status is(%s)\n", STATU_DESC_SCANNER_ERR_DEVICE_SLEEPING);
return ret; return status_;
} }
ret = get_scanner_paperon(); ret = get_scanner_paperon(val);
if (ret == SCANNER_ERR_DEVICE_NO_PAPER) if (!val)
{ {
status_ = ret; status_ = SCANNER_ERR_DEVICE_NO_PAPER;
notify_ui_working_status(STATU_DESC_SCANNER_ERR_DEVICE_NO_PAPER, SANE_EVENT_ERROR, status_); notify_ui_working_status(STATU_DESC_SCANNER_ERR_DEVICE_NO_PAPER, SANE_EVENT_ERROR, status_);
VLOG_MINI_1(LOG_LEVEL_WARNING, "device start status is(%s)\n", STATU_DESC_SCANNER_ERR_DEVICE_NO_PAPER); VLOG_MINI_1(LOG_LEVEL_WARNING, "device start status is(%s)\n", STATU_DESC_SCANNER_ERR_DEVICE_NO_PAPER);
return ret; return status_;
} }
USBCB usb = { setting3288dsp::START_COMMAND, img_conf_.scannum, 0}; USBCB usb = { setting3288dsp::START_COMMAND, img_conf_.scannum, 0};
@ -569,6 +570,10 @@ std::string hg_scanner_300::get_firmware_version()
return SerialNum; return SerialNum;
} }
std::string hg_scanner_300::get_ip(void)
{
return "";
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
int hg_scanner_300::set_leaflet_scan(void) int hg_scanner_300::set_leaflet_scan(void)
{ {
@ -578,28 +583,8 @@ int hg_scanner_300::set_leaflet_scan(void)
ret = start(); ret = start();
return ret; return ret;
} }
int hg_scanner_300::get_abuot_info(void)
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT; int hg_scanner_300::set_clear_roller_num(void)
}
int hg_scanner_300::restore_default_setting(void)
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner_300::set_final_image_format(void)
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner_300::get_compression_format(void)
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner_300::set_compression_format(void)
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner_300::set_auto_color_type(void)
{ {
return SCANNER_ERR_DEVICE_NOT_SUPPORT; return SCANNER_ERR_DEVICE_NOT_SUPPORT;
} }
@ -607,56 +592,35 @@ int hg_scanner_300::get_device_code(void)
{ {
return SCANNER_ERR_DEVICE_NOT_SUPPORT; return SCANNER_ERR_DEVICE_NOT_SUPPORT;
} }
int hg_scanner_300::get_sleep_time(SANE_Power* getime) int hg_scanner_300::get_sleep_time(int &data)
{ {
int ret = SCANNER_ERR_OK, int ret = SCANNER_ERR_OK,
len = 0; len = 0;
USBCB usbcb = { setting3288dsp::GET_SLEEP_TIME, 0, 0}; USBCB usbcb = { setting3288dsp::GET_SLEEP_TIME, 0, 0 };
ret = writeusb(usbcb); ret = writeusb(usbcb);
if (ret != SCANNER_ERR_OK) if (ret != SCANNER_ERR_OK)
{ {
return ret; return ret;
} }
len = sizeof(usbcb); len = sizeof(usbcb);
ret = io_->read_bulk(&usbcb,&len); ret = io_->read_bulk(&usbcb, &len);
printf("usbcb.u32_Data = %d\r\n", usbcb.u32_Data);
if (ret == SCANNER_ERR_OK) if (ret == SCANNER_ERR_OK)
{ {
if (getime) data = (SANE_Power)usbcb.u32_Data;
{
*getime = (SANE_Power)usbcb.u32_Data;
}
if (usbcb.u32_Data)
{
return SCANNER_ERR_DEVICE_SLEEPING;
}
} }
return ret; return ret;
} }
int hg_scanner_300::set_sleep_time(SANE_Power* setime) int hg_scanner_300::set_sleep_time(int data)
{ {
if (!setime) int ret = SCANNER_ERR_OK;
{ USBCB usbcb = { setting3288dsp::SET_SLEEP_TIME,data, 0};
return SCANNER_ERR_NO_DATA;
}
int ret = SCANNER_ERR_OK,
time = *setime;
USBCB usbcb = { setting3288dsp::SET_SLEEP_TIME,time, 0};
ret = writeusb(usbcb); ret = writeusb(usbcb);
return ret; return ret;
} }
int hg_scanner_300::get_dogear_distance(void)
{ int hg_scanner_300::get_scanner_paperon(SANE_Bool& type)
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner_300::set_dogear_distance(void)
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner_300::get_scanner_paperon(SANE_Bool* paperon)
{ {
int ret = SCANNER_ERR_OK, int ret = SCANNER_ERR_OK,
len = 0; len = 0;
@ -664,69 +628,46 @@ int hg_scanner_300::get_scanner_paperon(SANE_Bool* paperon)
USBCB usbcb = { setting3288dsp::GET_PAPER_STATUS, 0, 0}; USBCB usbcb = { setting3288dsp::GET_PAPER_STATUS, 0, 0};
len = sizeof(USBCB); len = sizeof(USBCB);
ret = writeusb(usbcb); ret = writeusb(usbcb);
//io_->set_timeout(500);
if (ret == SCANNER_ERR_OK) if (ret == SCANNER_ERR_OK)
{ {
ret = io_->read_bulk(&usbcb,&len); std::lock_guard<std::mutex> lock(io_lock_);
} ret = io_->read_bulk(&usbcb, &len);
if (ret != SCANNER_ERR_OK) type = usbcb.u32_Data == 0 ? false : true;
{
return ret;
}
if (usbcb.u32_Data == 0)
ret = SCANNER_ERR_DEVICE_NO_PAPER;
else
ret = SCANNER_ERR_OK;
if (paperon)
{
*paperon = usbcb.u32_Data;
} }
//if (usbcb.u32_Data == 0)
// ret = SCANNER_ERR_DEVICE_NO_PAPER;
//else
// ret = SCANNER_ERR_OK;
return ret; return ret;
} }
int hg_scanner_300::set_scan_when_paper_on(void)
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner_300::get_scan_when_paper_on(void)
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner_300::get_scan_with_hole(void)
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner_300::set_scan_with_hole(void)
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner_300::get_scan_is_sleep()
{
int ret = SCANNER_ERR_OK,
len = 0;
USBCB usbcb = {0x100, 0, 0}; int hg_scanner_300::get_scan_is_sleep(SANE_Bool& type)
{
int ret = SCANNER_ERR_OK,
len = 0;
USBCB usbcb = { setting3288dsp::CHECK_IS_SLEEP, 0, 0 };
len = sizeof(USBCB); len = sizeof(USBCB);
ret = writeusb(usbcb); ret = writeusb(usbcb);
//io_->set_timeout(200);
if (ret == SCANNER_ERR_OK) if (ret == SCANNER_ERR_OK)
{ {
ret = io_->read_bulk(&usbcb,&len); std::lock_guard<std::mutex> lock(io_lock_);
ret = io_->read_bulk(&usbcb, &len);
} }
if (ret != SCANNER_ERR_OK) if (ret == SCANNER_ERR_OK)
{ {
return ret; if (usbcb.u32_Data == 0x10)
} type = true;
if (usbcb.u32_Data == 0x10) //return SCANNER_ERR_OK;
{ else if (usbcb.u32_Data == 0x100)
return SCANNER_ERR_OK; type = false;
} //return SCANNER_ERR_DEVICE_SLEEPING;
else if (usbcb.u32_Data == 0x100)
{
return SCANNER_ERR_DEVICE_SLEEPING;
} }
return ret;
} }
///此款设备无此功能 ///此款设备无此功能
int hg_scanner_300::on_staple_check_changed(bool& check) int hg_scanner_300::on_staple_check_changed(bool& check)
@ -753,7 +694,43 @@ int hg_scanner_300::get_device_log(string &log)
{ {
return SCANNER_ERR_DEVICE_NOT_SUPPORT; return SCANNER_ERR_DEVICE_NOT_SUPPORT;
} }
int hg_scanner_300::notify_sleep() int hg_scanner_300::set_devreboot()
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner_300::set_devshtudown()
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner_300::set_scan_islock(SANE_Bool type)
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner_300::get_scan_islock(SANE_Bool& type)
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner_300::set_scan_lock_check_val(string str)
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner_300::set_firmware_upgrade(std::string str)
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner_300::set_clean_paper_road()
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner_300::get_dev_islock_file(int& data)
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner_300::set_dev_islock_file(int data)
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner_300::set_notify_sleep()
{ {
return SCANNER_ERR_DEVICE_NOT_SUPPORT; return SCANNER_ERR_DEVICE_NOT_SUPPORT;
} }

57
hgdriver/hgdev/hg_scanner_300.h
View File

@ -52,33 +52,42 @@ private:
int writedown_device_configuration(bool type =false,setting_hardware::HGSCANCONF_3288 *d = NULL); int writedown_device_configuration(bool type =false,setting_hardware::HGSCANCONF_3288 *d = NULL);
void writedown_image_configuration(void); void writedown_image_configuration(void);
void printf_devconfig(setting_hardware::HGSCANCONF_3288 *d = NULL); void printf_devconfig(setting_hardware::HGSCANCONF_3288 *d = NULL);
virtual std::string get_firmware_version() override;
virtual std::string get_serial_num(void) override;
private: private:
std::vector<int> savestatus_; std::vector<int> savestatus_;
setting_hardware::HGSCANCONF_3288 dsp_config; setting_hardware::HGSCANCONF_3288 dsp_config;
Device::PaperSize papersize; Device::PaperSize papersize;
public: public:
virtual int set_leaflet_scan(void);//单张扫描 virtual std::string get_firmware_version(void)override;
virtual int get_abuot_info(void);//获取软件关于信息 virtual std::string get_serial_num(void)override;
virtual int restore_default_setting(void);//恢复默认设置 virtual std::string get_ip(void)override;
virtual int set_final_image_format(void); // 设置图像处理最终输出（final()）的图像数据格式
virtual int get_compression_format(void);//获取支持的压缩格式
virtual int set_compression_format(void);//设置图像数据最终输出的压缩格式 /////////////////成功返回:SCANNER_ERR_OK /////////////
virtual int set_auto_color_type(void);// 设置自动匹配颜色模式 /////////////////失败返回:IO错误码 /////////////
virtual int get_device_code(void);//获取设备编码 virtual int set_leaflet_scan(void) override; //单张扫描
virtual int get_sleep_time(SANE_Power* setime = NULL);//获取功耗模式（休眠）
virtual int set_sleep_time(SANE_Power* setime);//设置功耗模式（休眠）
virtual int get_dogear_distance(void);//获取折角检测最小距离阈值 virtual int set_clear_roller_num(void) override; //清除滚轴计数
virtual int set_dogear_distance(void);// 设置折角检测最小距离阈值
virtual int get_scanner_paperon(SANE_Bool* paperon=NULL);//获取设备有无纸张 virtual int get_device_code(void); //获取设备编码 不支持
virtual int set_scan_when_paper_on(void);//获取是否为检测到进纸盘上有纸即开始扫描
virtual int get_scan_when_paper_on(void);//设置是否为检测到进纸盘上有纸即开始扫描 virtual int get_scanner_paperon(SANE_Bool& type) override; //获取设备有无纸张 /*/ type : 0无纸 1有纸 */
virtual int get_scan_with_hole(void);// 获取是否为带孔扫描
virtual int set_scan_with_hole(void);// 设置是否为带孔扫描 virtual int get_scan_is_sleep(SANE_Bool& type) override; //获取设备是否休眠当中 /*/ type : 0休眠 1唤醒状态*/
virtual int get_scan_is_sleep(void);//获取设备是否休眠当中 virtual int get_sleep_time(int& data) override; //获取功耗模式（休眠） /*/ data > 0*/
virtual int get_device_log(string &log);//获取设备日志 virtual int set_sleep_time(int data) override; //设置功耗模式（休眠） /*/ data > 0*/
virtual int notify_sleep(void);//唤醒设备 virtual int get_history_roller_count(int& data) override; //获取历史扫描张数 /*/ data > 0*/
virtual int get_history_roller_count(int& num); //获取历史扫描张数 virtual int get_roller_num(int& data) override; //获取滚轮张数 /*/ data > 0*/
virtual int get_roller_num(int& val); //获取滚轮张数 virtual int set_notify_sleep(void) override; //唤醒设备
virtual int get_device_log(string& log) override; //获取设备日志 /*/ log :储存路径*/
virtual int set_devreboot() override; //设置设备重启
virtual int set_devshtudown() override; //设置设备关机
virtual int set_scan_islock(SANE_Bool type) override; //设置设备是否锁定 /*/ type:0解锁，1锁定*/
virtual int get_scan_islock(SANE_Bool& type) override; //获取设备是否锁定 /*/ type:0解锁，1锁定*/
virtual int set_scan_lock_check_val(string str) override; //获取设备是否锁定 /*/ str:校验码*/
virtual int set_firmware_upgrade(std::string str) override; //固件升级 /*/ str:文件名路径*/
virtual int set_clean_paper_road() override; //清理纸道
virtual int get_dev_islock_file(int& data) override; //获取设备文件 /*/ data:0 未上锁，1 上锁。-1 未发现黑名单列表 -2列表没有信息*/
virtual int set_dev_islock_file(int data) override; //设置设备文件 /*/ data:0 未上锁，1 上锁*
}; };

167
hgdriver/hgdev/hg_scanner_302.cpp
View File

@ -994,7 +994,6 @@ int hg_scanner_302::start(void)
notify_ui_working_status(STATU_DESC_PREPARE_START); notify_ui_working_status(STATU_DESC_PREPARE_START);
reset(); reset();
get_roller_num();
read_register(setting3399::SR_GET_PAPERON, &val); read_register(setting3399::SR_GET_PAPERON, &val);
if (!val) if (!val)
{ {
@ -1110,25 +1109,8 @@ std::string hg_scanner_302::get_ip(void)
{ {
return control_fetch(setting3399::SR_GET_IPADDR, 0, 512); return control_fetch(setting3399::SR_GET_IPADDR, 0, 512);
} }
int hg_scanner_302::get_roller_num(void)
{
int val = 0,
ret = read_register(setting3399::SR_GET_ROLLER_NUM, &val);
if (ret == SCANNER_ERR_OK) int hg_scanner_302::set_clear_roller_num(void)
return val;
else
{
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "get_roller_num = %s\n", hg_scanner_err_name(ret));
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
// return -2;
}
int hg_scanner_302::get_history_count(void)
{
return -2;
}
int hg_scanner_302::clear_roller_num(void)
{ {
int val = 0, int val = 0,
ret = read_register(setting3399::SR_CLR_ROLLER_NUM, &val); ret = read_register(setting3399::SR_CLR_ROLLER_NUM, &val);
@ -1144,47 +1126,24 @@ int hg_scanner_302::set_leaflet_scan(void)
ret = start(); ret = start();
return ret; return ret;
} }
int hg_scanner_302::get_abuot_info(void)
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner_302::restore_default_setting(void)
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner_302::set_final_image_format(SANE_FinalImgFormat* fmt)
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner_302::get_compression_format(void)
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner_302::set_compression_format(void)
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner_302::set_auto_color_type(void)
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner_302::get_device_code(void) int hg_scanner_302::get_device_code(void)
{ {
return SCANNER_ERR_DEVICE_NOT_SUPPORT; return SCANNER_ERR_DEVICE_NOT_SUPPORT;
} }
int hg_scanner_302::get_sleep_time(SANE_Power* getime) int hg_scanner_302::get_sleep_time(int& data)
{ {
int val = 0, int val = 0;
ret = read_register(setting3399::SR_GET_SLEEPTIME, &val); int ret = read_register(setting3399::SR_GET_SLEEPTIME, &val);
if (ret == SCANNER_ERR_OK) if (ret == SCANNER_ERR_OK)
*getime = (SANE_Power)val;
else
{ {
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "get_sleep_time = %s\n", hg_scanner_err_name(ret)); save_sleeptime_type_ = true;
return -1; data = val;
} }
VLOG_MINI_2(LOG_LEVEL_DEBUG_INFO, "get_sleep_time = %d with %s\n", data, hg_scanner_err_name(ret));
return ret;
} }
int hg_scanner_302::set_sleep_time(int setsleepime) int hg_scanner_302::set_sleep_time(int setsleepime)
{ {
@ -1194,64 +1153,28 @@ int hg_scanner_302::set_sleep_time(int setsleepime)
return ret; return ret;
} }
int hg_scanner_302::get_dogear_distance(void)
{ int hg_scanner_302::get_scanner_paperon(SANE_Bool& type)
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner_302::set_dogear_distance(void)
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner_302::get_scanner_paperon(SANE_Bool* paperon)
{ {
int val = 0, int val = 0,
ret = read_register(setting3399::SR_GET_PAPERON, &val); ret = read_register(setting3399::SR_GET_PAPERON, &val);
if (ret == SCANNER_ERR_OK) if (ret == SCANNER_ERR_OK)
{ {
if (!val) type = val == 0 ? false : true;;
{
ret = SCANNER_ERR_DEVICE_NO_PAPER;
if (paperon)
{
*paperon = false;
}
}
else
{
ret = SCANNER_ERR_OK;
if (paperon)
{
*paperon = true;
}
}
}
else
{
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "get_scanner_paperon = %s\n", hg_scanner_err_name(ret));
return -1;
} }
return ret; return ret;
} }
int hg_scanner_302::set_scan_when_paper_on(void)
int hg_scanner_302::get_scan_is_sleep(SANE_Bool& type)
{ {
return SCANNER_ERR_DEVICE_NOT_SUPPORT; int ret = 0, val;
} ret = read_register(setting3399::SR_GET_SLEEP_STAUTUS, &val); //0休眠 1唤醒状态
int hg_scanner_302::get_scan_when_paper_on(void) if (ret == SCANNER_ERR_OK)
{ {
return SCANNER_ERR_DEVICE_NOT_SUPPORT; type = val == 1 ? true : false;
} }
int hg_scanner_302::get_scan_with_hole(void) return ret;
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner_302::set_scan_with_hole(void)
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner_302::get_scan_is_sleep()
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
} }
int hg_scanner_302::get_device_log(string &log) int hg_scanner_302::get_device_log(string &log)
{ {
@ -1265,7 +1188,53 @@ int hg_scanner_302::get_device_log(string &log)
VLOG_MINI_2(LOG_LEVEL_DEBUG_INFO, "log path:%s ret:%s\n", log.c_str(),hg_scanner_err_name(ret)); VLOG_MINI_2(LOG_LEVEL_DEBUG_INFO, "log path:%s ret:%s\n", log.c_str(),hg_scanner_err_name(ret));
return ret; return ret;
} }
int hg_scanner_302::notify_sleep() int hg_scanner_302::set_devreboot()
{
int val = 0,
ret = write_register(setting3399::SR_REBOOT, val);
if (ret != SCANNER_ERR_OK)
return ret;
}
int hg_scanner_302::set_devshtudown()
{
int val = 0,
ret = write_register(setting3399::SR_POWEROFF, val);
if (ret != SCANNER_ERR_OK)
return ret;
}
int hg_scanner_302::set_scan_islock(SANE_Bool type)
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner_302::get_scan_islock(SANE_Bool& type)
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner_302::set_scan_lock_check_val(string str)
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner_302::set_firmware_upgrade(std::string str)
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner_302::set_clean_paper_road()
{
int ret = 0, len = 0;
ret = write_register(setting3399::SR_CLEAN_PAPER_ROAD, len);
return ret;
}
int hg_scanner_302::get_dev_islock_file(int& data)
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner_302::set_dev_islock_file(int data)
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner_302::set_notify_sleep()
{ {
int val = 0, int val = 0,
ret = write_register(setting3399::SR_NOTIFY_SLEEP, val); ret = write_register(setting3399::SR_NOTIFY_SLEEP, val);

54
hgdriver/hgdev/hg_scanner_302.h
View File

@ -85,38 +85,34 @@ public:
virtual int device_io_control(unsigned long code, void* data, unsigned* len) override; virtual int device_io_control(unsigned long code, void* data, unsigned* len) override;
public: public:
virtual int set_leaflet_scan(void);//单张扫描 virtual std::string get_firmware_version(void)override;
virtual int get_abuot_info(void);//获取软件关于信息 (基类实现) virtual std::string get_serial_num(void)override;
virtual int restore_default_setting(void);//恢复默认设置 (基类实现) virtual std::string get_ip(void)override;
virtual int set_final_image_format(SANE_FinalImgFormat* fmt); // 设置图像处理最终输出（final()）的图像数据格式 (基类实现) ***
virtual int get_compression_format(void);//获取支持的压缩格式 ***功能不支持
virtual int get_roller_num(void); //获取滚轮张数 ***完成 /////////////////成功返回:SCANNER_ERR_OK /////////////
virtual int get_history_count(void);//获取历史扫描张数 -2：设备不支持该功能；-1：与设备通信失败；其它大于等于0的为正常 /////////////////失败返回:IO错误码 /////////////
virtual int clear_roller_num(void); // 清除滚轴计数 ***完成 virtual int set_leaflet_scan(void) override; //单张扫描
virtual int set_compression_format(void);//设置图像数据最终输出的压缩格式 ***功能不支持 virtual int set_clear_roller_num(void) override; //清除滚轴计数
virtual int set_auto_color_type(void);// 设置自动匹配颜色模式 (基类实现) ***完成
virtual std::string get_firmware_version(void); virtual int get_device_code(void); //获取设备编码 不支持
virtual std::string get_serial_num(void);
virtual std::string get_ip(void);
virtual int get_device_code(void);//获取设备编码 virtual int get_scanner_paperon(SANE_Bool& type) override; //获取设备有无纸张 /*/ type : 0无纸 1有纸 */
virtual int get_sleep_time(SANE_Power* getime);//获取功耗模式（休眠）
virtual int set_sleep_time(int setsleepime);//设置功耗模式（休眠）
virtual int get_dogear_distance(void);//获取折角检测最小距离阈值
virtual int set_dogear_distance(void);// 设置折角检测最小距离阈值
virtual int get_scanner_paperon(SANE_Bool* paperon = NULL);//获取设备有无纸张
virtual int set_scan_when_paper_on(void);//获取是否为检测到进纸盘上有纸即开始扫描
virtual int get_scan_when_paper_on(void);//设置是否为检测到进纸盘上有纸即开始扫描
virtual int get_scan_with_hole(void);// 获取是否为带孔扫描
virtual int set_scan_with_hole(void);// 设置是否为带孔扫描
virtual int get_scan_is_sleep(void);//获取设备是否休眠当中 virtual int get_scan_is_sleep(SANE_Bool& type) override; //获取设备是否休眠当中 /*/ type : 0休眠 1唤醒状态*/
virtual int get_device_log(string &log);//获取设备日志 virtual int get_sleep_time(int& data) override; //获取功耗模式（休眠） /*/ data > 0*/
virtual int notify_sleep(void);//唤醒设备 virtual int set_sleep_time(int data) override; //设置功耗模式（休眠） /*/ data > 0*/
virtual int get_history_roller_count(int& num); //获取历史扫描张数 virtual int get_history_roller_count(int& data) override; //获取历史扫描张数 /*/ data > 0*/
virtual int get_roller_num(int& val); //获取滚轮张数 virtual int get_roller_num(int& data) override; //获取滚轮张数 /*/ data > 0*/
virtual int set_notify_sleep(void) override; //唤醒设备
virtual int get_device_log(string& log) override; //获取设备日志 /*/ log :储存路径*/
virtual int set_devreboot() override; //设置设备重启
virtual int set_devshtudown() override; //设置设备关机
virtual int set_scan_islock(SANE_Bool type) override; //设置设备是否锁定 /*/ type:0解锁，1锁定*/
virtual int get_scan_islock(SANE_Bool& type) override; //获取设备是否锁定 /*/ type:0解锁，1锁定*/
virtual int set_scan_lock_check_val(string str) override; //获取设备是否锁定 /*/ str:校验码*/
virtual int set_firmware_upgrade(std::string str) override; //固件升级 /*/ str:文件名路径*/
virtual int set_clean_paper_road() override; //清理纸道
virtual int get_dev_islock_file(int& data) override; //获取设备文件 /*/ data:0 未上锁，1 上锁。-1 未发现黑名单列表 -2列表没有信息*/
virtual int set_dev_islock_file(int data) override; //设置设备文件 /*/ data:0 未上锁，1 上锁*/
}; };

177
hgdriver/hgdev/hg_scanner_400.cpp
View File

@ -80,9 +80,6 @@ hg_scanner_400::hg_scanner_400(const char* dev_name,int pid, usb_io* io) : hg_sc
init_settings((jsontext1 + jsontext2).c_str()); init_settings((jsontext1 + jsontext2).c_str());
else else
init_settings((jsontext3 + jsontext4).c_str()); init_settings((jsontext3 + jsontext4).c_str());
printf_devconfig();
} }
hg_scanner_400::~hg_scanner_400() hg_scanner_400::~hg_scanner_400()
{} {}
@ -179,7 +176,8 @@ int hg_scanner_400::start(void)
{ {
bool handled = false; bool handled = false;
int ret = try_third_app_handle_start(handled), int ret = try_third_app_handle_start(handled),
count = -1; count = -1,
val = 1;
// for third-sane-app invoking, added on 2022-05-19 // for third-sane-app invoking, added on 2022-05-19
if (handled) if (handled)
@ -195,23 +193,22 @@ int hg_scanner_400::start(void)
return ret; return ret;
} }
printf_devconfig(); ret = get_scan_is_sleep(val);
ret = get_scan_is_sleep(); if (!val)
if (ret == SCANNER_ERR_DEVICE_SLEEPING)
{ {
status_ = ret; status_ = SCANNER_ERR_DEVICE_SLEEPING;
//notify_ui_working_status(STATU_DESC_SCANNER_ERR_DEVICE_SLEEPING, SANE_EVENT_ERROR, status_); //notify_ui_working_status(STATU_DESC_SCANNER_ERR_DEVICE_SLEEPING, SANE_EVENT_ERROR, status_);
notify_ui_working_status(STATU_DESC_SCANNER_ERR_DEVICE_NOTIFY_SLEEP, SANE_EVENT_ERROR, status_); notify_ui_working_status(STATU_DESC_SCANNER_ERR_DEVICE_NOTIFY_SLEEP, SANE_EVENT_ERROR, status_);
VLOG_MINI_1(LOG_LEVEL_WARNING, "device start status is(%s)\n", STATU_DESC_SCANNER_ERR_DEVICE_SLEEPING); VLOG_MINI_1(LOG_LEVEL_WARNING, "device start status is(%s)\n", STATU_DESC_SCANNER_ERR_DEVICE_SLEEPING);
return ret; return status_;
} }
ret = get_scanner_paperon(); ret = get_scanner_paperon(val);
if (ret == SCANNER_ERR_DEVICE_NO_PAPER) if (!val)
{ {
status_ = ret; status_ = SCANNER_ERR_DEVICE_NO_PAPER;
notify_ui_working_status(STATU_DESC_SCANNER_ERR_DEVICE_NO_PAPER, SANE_EVENT_ERROR, status_); notify_ui_working_status(STATU_DESC_SCANNER_ERR_DEVICE_NO_PAPER, SANE_EVENT_ERROR, status_);
VLOG_MINI_1(LOG_LEVEL_WARNING, "device start status is(%s)\n", STATU_DESC_SCANNER_ERR_DEVICE_NO_PAPER); VLOG_MINI_1(LOG_LEVEL_WARNING, "device start status is(%s)\n", STATU_DESC_SCANNER_ERR_DEVICE_NO_PAPER);
return ret; return status_;
} }
USBCB usb = { setting3288dsp::START_COMMAND, img_conf_.scannum, 0 }; USBCB usb = { setting3288dsp::START_COMMAND, img_conf_.scannum, 0 };
@ -593,6 +590,10 @@ std::string hg_scanner_400::get_firmware_version()
return buf; return buf;
} }
std::string hg_scanner_400::get_ip(void)
{
return "";
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
int hg_scanner_400::set_leaflet_scan(void) int hg_scanner_400::set_leaflet_scan(void)
{ {
@ -602,31 +603,12 @@ int hg_scanner_400::set_leaflet_scan(void)
ret = start(); ret = start();
return ret; return ret;
} }
int hg_scanner_400::get_abuot_info(void)
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT; int hg_scanner_400::set_clear_roller_num(void)
}
int hg_scanner_400::restore_default_setting(void)
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner_400::set_final_image_format(void)
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner_400::get_compression_format(void)
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner_400::set_compression_format(void)
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner_400::set_auto_color_type(void)
{ {
return SCANNER_ERR_DEVICE_NOT_SUPPORT; return SCANNER_ERR_DEVICE_NOT_SUPPORT;
} }
int hg_scanner_400::get_device_code(void) int hg_scanner_400::get_device_code(void)
{ {
return SCANNER_ERR_DEVICE_NOT_SUPPORT; return SCANNER_ERR_DEVICE_NOT_SUPPORT;
@ -661,85 +643,54 @@ int hg_scanner_400::set_sleep_time(int setsleepime)
return ret;; return ret;;
} }
int hg_scanner_400::get_dogear_distance(void)
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner_400::set_dogear_distance(void)
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner_400::get_scanner_paperon(SANE_Bool* paperon)
{
int ret = SCANNER_ERR_OK,
len = 0;
USBCB usbcb = { setting3288dsp::GET_PAPER_STATUS, 0, 0}; int hg_scanner_400::get_scanner_paperon(SANE_Bool& type)
{
int ret = SCANNER_ERR_OK,
len = 0;
USBCB usbcb = { setting3288dsp::GET_PAPER_STATUS, 0, 0 };
len = sizeof(USBCB); len = sizeof(USBCB);
ret = writeusb(usbcb); ret = writeusb(usbcb);
//io_->set_timeout(500);
if (ret == SCANNER_ERR_OK) if (ret == SCANNER_ERR_OK)
{ {
ret = io_->read_bulk(&usbcb,&len); std::lock_guard<std::mutex> lock(io_lock_);
} ret = io_->read_bulk(&usbcb, &len);
if (ret != SCANNER_ERR_OK) type = usbcb.u32_Data == 0 ? false : true;
{
return ret;
}
if (usbcb.u32_Data == 0)
ret = SCANNER_ERR_DEVICE_NO_PAPER;
else
ret = SCANNER_ERR_OK;
if (paperon)
{
*paperon = usbcb.u32_Data;
} }
//if (usbcb.u32_Data == 0)
// ret = SCANNER_ERR_DEVICE_NO_PAPER;
//else
// ret = SCANNER_ERR_OK;
return ret; return ret;
} }
int hg_scanner_400::set_scan_when_paper_on(void)
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner_400::get_scan_when_paper_on(void)
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner_400::get_scan_with_hole(void)
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner_400::set_scan_with_hole(void)
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner_400::get_scan_is_sleep()
{
int ret = SCANNER_ERR_OK,
len = 0;
USBCB usbcb = {0x100, 0, 0}; int hg_scanner_400::get_scan_is_sleep(SANE_Bool& type)
{
int ret = SCANNER_ERR_OK,
len = 0;
USBCB usbcb = { setting3288dsp::CHECK_IS_SLEEP, 0, 0 };
len = sizeof(USBCB); len = sizeof(USBCB);
ret = writeusb(usbcb); ret = writeusb(usbcb);
//io_->set_timeout(200);
if (ret == SCANNER_ERR_OK) if (ret == SCANNER_ERR_OK)
{ {
ret = io_->read_bulk(&usbcb,&len); std::lock_guard<std::mutex> lock(io_lock_);
ret = io_->read_bulk(&usbcb, &len);
} }
if (ret != SCANNER_ERR_OK) if (ret == SCANNER_ERR_OK)
{ {
return ret; if (usbcb.u32_Data == 0x10)
} type = true;
if (usbcb.u32_Data == 0x10) //return SCANNER_ERR_OK;
{ else if (usbcb.u32_Data == 0x100)
return SCANNER_ERR_OK; type = false;
} //return SCANNER_ERR_DEVICE_SLEEPING;
else if (usbcb.u32_Data == 0x100)
{
return SCANNER_ERR_DEVICE_SLEEPING;
} }
return ret;
} }
////////////////////////////////start///////////////////////////// ////////////////////////////////start/////////////////////////////
///此款设备无此功能暂时预留 ///此款设备无此功能暂时预留
@ -768,7 +719,43 @@ int hg_scanner_400::get_device_log(string &log)
{ {
return SCANNER_ERR_DEVICE_NOT_SUPPORT; return SCANNER_ERR_DEVICE_NOT_SUPPORT;
} }
int hg_scanner_400::notify_sleep() int hg_scanner_400::set_devreboot()
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner_400::set_devshtudown()
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner_400::set_scan_islock(SANE_Bool type)
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner_400::get_scan_islock(SANE_Bool& type)
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner_400::set_scan_lock_check_val(string str)
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner_400::set_firmware_upgrade(std::string str)
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner_400::set_clean_paper_road()
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner_400::get_dev_islock_file(int& data)
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner_400::set_dev_islock_file(int data)
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner_400::set_notify_sleep()
{ {
return SCANNER_ERR_DEVICE_NOT_SUPPORT; return SCANNER_ERR_DEVICE_NOT_SUPPORT;
} }

56
hgdriver/hgdev/hg_scanner_400.h
View File

@ -58,40 +58,42 @@ private:
int writedown_device_configuration(bool type =false,setting_hardware::HGSCANCONF_3288 *d = NULL); int writedown_device_configuration(bool type =false,setting_hardware::HGSCANCONF_3288 *d = NULL);
void writedown_image_configuration(void); void writedown_image_configuration(void);
void printf_devconfig(setting_hardware::HGSCANCONF_3288 *d = NULL); void printf_devconfig(setting_hardware::HGSCANCONF_3288 *d = NULL);
virtual std::string get_firmware_version(void) override;
virtual std::string get_serial_num(void) override;
private: private:
setting_hardware::HGSCANCONF_3288 dsp_config; setting_hardware::HGSCANCONF_3288 dsp_config;
Device::PaperSize papersize; Device::PaperSize papersize;
public: public:
virtual int set_leaflet_scan(void);//单张扫描 virtual std::string get_firmware_version(void)override;
virtual int get_abuot_info(void);//获取软件关于信息 virtual std::string get_serial_num(void)override;
virtual int restore_default_setting(void);//恢复默认设置 virtual std::string get_ip(void)override;
virtual int set_final_image_format(void); // 设置图像处理最终输出（final()）的图像数据格式
virtual int get_compression_format(void);//获取支持的压缩格式
virtual int set_compression_format(void);//设置图像数据最终输出的压缩格式
virtual int set_auto_color_type(void);// 设置自动匹配颜色模式
virtual int get_device_code(void);//获取设备编码 /////////////////成功返回:SCANNER_ERR_OK /////////////
virtual int get_sleep_time(int& getsleepime);//获取功耗模式（休眠） /////////////////失败返回:IO错误码 /////////////
virtual int set_sleep_time(int setsleepime);//设置功耗模式（休眠）//设置功耗模式（休眠） virtual int set_leaflet_scan(void) override; //单张扫描
virtual int get_dogear_distance(void);//获取折角检测最小距离阈值
virtual int set_dogear_distance(void);// 设置折角检测最小距离阈值
virtual int get_scanner_paperon(SANE_Bool* paperon=NULL);//获取设备有无纸张
virtual int set_scan_when_paper_on(void);//获取是否为检测到进纸盘上有纸即开始扫描
virtual int get_scan_when_paper_on(void);//设置是否为检测到进纸盘上有纸即开始扫描
virtual int get_scan_with_hole(void);// 获取是否为带孔扫描
virtual int set_scan_with_hole(void);// 设置是否为带孔扫描
virtual int get_scan_is_sleep(void);//获取设备是否休眠当中
virtual int get_device_log(string &log);//获取设备日志 virtual int set_clear_roller_num(void) override; //清除滚轴计数
virtual int notify_sleep(void);//唤醒设备
virtual int get_history_roller_count(int& num); //获取历史扫描张数 virtual int get_device_code(void); //获取设备编码 不支持
virtual int get_roller_num(int& val); //获取滚轮张数
virtual int get_scanner_paperon(SANE_Bool& type) override; //获取设备有无纸张 /*/ type : 0无纸 1有纸 */
virtual int get_scan_is_sleep(SANE_Bool& type) override; //获取设备是否休眠当中 /*/ type : 0休眠 1唤醒状态*/
virtual int get_sleep_time(int& data) override; //获取功耗模式（休眠） /*/ data > 0*/
virtual int set_sleep_time(int data) override; //设置功耗模式（休眠） /*/ data > 0*/
virtual int get_history_roller_count(int& data) override; //获取历史扫描张数 /*/ data > 0*/
virtual int get_roller_num(int& data) override; //获取滚轮张数 /*/ data > 0*/
virtual int set_notify_sleep(void) override; //唤醒设备
virtual int get_device_log(string& log) override; //获取设备日志 /*/ log :储存路径*/
virtual int set_devreboot() override; //设置设备重启
virtual int set_devshtudown() override; //设置设备关机
virtual int set_scan_islock(SANE_Bool type) override; //设置设备是否锁定 /*/ type:0解锁，1锁定*/
virtual int get_scan_islock(SANE_Bool& type) override; //获取设备是否锁定 /*/ type:0解锁，1锁定*/
virtual int set_scan_lock_check_val(string str) override; //获取设备是否锁定 /*/ str:校验码*/
virtual int set_firmware_upgrade(std::string str) override; //固件升级 /*/ str:文件名路径*/
virtual int set_clean_paper_road() override; //清理纸道
virtual int get_dev_islock_file(int& data) override; //获取设备文件 /*/ data:0 未上锁，1 上锁。-1 未发现黑名单列表 -2列表没有信息*/
virtual int set_dev_islock_file(int data) override; //设置设备文件 /*/ data:0 未上锁，1 上锁*
}; };

158
hgdriver/hgdev/hg_scanner_402.cpp
View File

@ -953,7 +953,7 @@ int hg_scanner_402::start(void)
notify_ui_working_status(STATU_DESC_PREPARE_START); notify_ui_working_status(STATU_DESC_PREPARE_START);
reset(); reset();
get_roller_num();
read_register(setting3399::SR_GET_PAPERON, &val); read_register(setting3399::SR_GET_PAPERON, &val);
if (!val) if (!val)
{ {
@ -1069,25 +1069,8 @@ std::string hg_scanner_402::get_ip(void)
{ {
return control_fetch(setting3399::SR_GET_IPADDR, 0, 512); return control_fetch(setting3399::SR_GET_IPADDR, 0, 512);
} }
int hg_scanner_402::get_roller_num(void)
{
int val = 0,
ret = read_register(setting3399::SR_GET_ROLLER_NUM, &val);
if (ret == SCANNER_ERR_OK) int hg_scanner_402::set_clear_roller_num(void)
return val;
else
{
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "get_roller_num = %s\n", hg_scanner_err_name(ret));
return -2;
}
// return -2;
}
int hg_scanner_402::get_history_count(void)
{
return -2;
}
int hg_scanner_402::clear_roller_num(void)
{ {
int val = 0, int val = 0,
ret = read_register(setting3399::SR_CLR_ROLLER_NUM, &val); ret = read_register(setting3399::SR_CLR_ROLLER_NUM, &val);
@ -1097,53 +1080,30 @@ int hg_scanner_402::clear_roller_num(void)
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
int hg_scanner_402::set_leaflet_scan(void) int hg_scanner_402::set_leaflet_scan(void)
{ {
int ret = SCANNER_ERR_OK; int ret = SCANNER_ERR_OK;
test_1_paper_ = true; test_1_paper_ = true;
ret = start(); ret = start();
return ret; return ret;
} }
int hg_scanner_402::get_abuot_info(void)
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner_402::restore_default_setting(void)
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner_402::set_final_image_format(SANE_FinalImgFormat* fmt)
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner_402::get_compression_format(void)
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner_402::set_compression_format(void)
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner_402::set_auto_color_type(void)
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner_402::get_device_code(void) int hg_scanner_402::get_device_code(void)
{ {
return SCANNER_ERR_DEVICE_NOT_SUPPORT; return SCANNER_ERR_DEVICE_NOT_SUPPORT;
} }
int hg_scanner_402::get_sleep_time(SANE_Power* getime) int hg_scanner_402::get_sleep_time(int& data)
{ {
int val = 0, int val = 0;
ret = read_register(setting3399::SR_GET_SLEEPTIME, &val); int ret = read_register(setting3399::SR_GET_SLEEPTIME, &val);
if (ret == SCANNER_ERR_OK) if (ret == SCANNER_ERR_OK)
*getime = (SANE_Power)val;
else
{ {
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "get_sleep_time = %s\n", hg_scanner_err_name(ret)); save_sleeptime_type_ = true;
return -1; data = val;
} }
VLOG_MINI_2(LOG_LEVEL_DEBUG_INFO, "get_sleep_time = %d with %s\n", data, hg_scanner_err_name(ret));
return ret;
} }
int hg_scanner_402::set_sleep_time(int setsleepime) int hg_scanner_402::set_sleep_time(int setsleepime)
{ {
@ -1153,70 +1113,88 @@ int hg_scanner_402::set_sleep_time(int setsleepime)
return ret; return ret;
} }
int hg_scanner_402::get_dogear_distance(void)
{ int hg_scanner_402::get_scanner_paperon(SANE_Bool& type)
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner_402::set_dogear_distance(void)
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner_402::get_scanner_paperon(SANE_Bool* paperon)
{ {
int val = 0, int val = 0,
ret = read_register(setting3399::SR_GET_PAPERON, &val); ret = read_register(setting3399::SR_GET_PAPERON, &val);
if (ret == SCANNER_ERR_OK) if (ret == SCANNER_ERR_OK)
{ {
if (!val) type = val == 0 ? false : true;;
{
ret = SCANNER_ERR_DEVICE_NO_PAPER;
if (paperon)
{
*paperon = false;
}
}
else
{
ret = SCANNER_ERR_OK;
if (paperon)
{
*paperon = true;
}
}
}
else
{
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "get_scanner_paperon = %s\n", hg_scanner_err_name(ret));
return -1;
} }
return ret; return ret;
} }
int hg_scanner_402::set_scan_when_paper_on(void)
int hg_scanner_402::get_scan_is_sleep(SANE_Bool& type)
{
int ret = 0, val;
ret = read_register(setting3399::SR_GET_SLEEP_STAUTUS, &val); //0休眠 1唤醒状态
if (ret == SCANNER_ERR_OK)
{
type = val == 1 ? true : false;
}
return ret;
}
int hg_scanner_402::get_device_log(string& log)
{
int ret = SCANNER_ERR_OK;
int len = log.size();
ret = write_register(setting3399::SR_SET_JSON_PATH, len);
if (ret == SCANNER_ERR_OK)
ret = io_->write_bulk(&log[0], &len);
VLOG_MINI_2(LOG_LEVEL_DEBUG_INFO, "log path:%s ret:%s\n", log.c_str(), hg_scanner_err_name(ret));
return ret;
}
int hg_scanner_402::set_devreboot()
{
int val = 0,
ret = write_register(setting3399::SR_REBOOT, val);
if (ret != SCANNER_ERR_OK)
return ret;
}
int hg_scanner_402::set_devshtudown()
{
int val = 0,
ret = write_register(setting3399::SR_POWEROFF, val);
if (ret != SCANNER_ERR_OK)
return ret;
}
int hg_scanner_402::set_scan_islock(SANE_Bool type)
{ {
return SCANNER_ERR_DEVICE_NOT_SUPPORT; return SCANNER_ERR_DEVICE_NOT_SUPPORT;
} }
int hg_scanner_402::get_scan_when_paper_on(void) int hg_scanner_402::get_scan_islock(SANE_Bool& type)
{ {
return SCANNER_ERR_DEVICE_NOT_SUPPORT; return SCANNER_ERR_DEVICE_NOT_SUPPORT;
} }
int hg_scanner_402::get_scan_with_hole(void) int hg_scanner_402::set_scan_lock_check_val(string str)
{ {
return SCANNER_ERR_DEVICE_NOT_SUPPORT; return SCANNER_ERR_DEVICE_NOT_SUPPORT;
} }
int hg_scanner_402::set_scan_with_hole(void) int hg_scanner_402::set_firmware_upgrade(std::string str)
{ {
return SCANNER_ERR_DEVICE_NOT_SUPPORT; return SCANNER_ERR_DEVICE_NOT_SUPPORT;
} }
int hg_scanner_402::get_scan_is_sleep() int hg_scanner_402::set_clean_paper_road()
{
int ret = 0, len = 0;
ret = write_register(setting3399::SR_CLEAN_PAPER_ROAD, len);
return ret;
}
int hg_scanner_402::get_dev_islock_file(int& data)
{ {
return SCANNER_ERR_DEVICE_NOT_SUPPORT; return SCANNER_ERR_DEVICE_NOT_SUPPORT;
} }
int hg_scanner_402::get_device_log(string &log) int hg_scanner_402::set_dev_islock_file(int data)
{ {
return SCANNER_ERR_DEVICE_NOT_SUPPORT; return SCANNER_ERR_DEVICE_NOT_SUPPORT;
} }
int hg_scanner_402::notify_sleep() int hg_scanner_402::set_notify_sleep()
{ {
int val = 0, int val = 0,
ret = write_register(setting3399::SR_NOTIFY_SLEEP, val); ret = write_register(setting3399::SR_NOTIFY_SLEEP, val);

54
hgdriver/hgdev/hg_scanner_402.h
View File

@ -85,38 +85,34 @@ public:
virtual int device_io_control(unsigned long code, void* data, unsigned* len) override; virtual int device_io_control(unsigned long code, void* data, unsigned* len) override;
public: public:
virtual int set_leaflet_scan(void);//单张扫描 virtual std::string get_firmware_version(void)override;
virtual int get_abuot_info(void);//获取软件关于信息 (基类实现) virtual std::string get_serial_num(void)override;
virtual int restore_default_setting(void);//恢复默认设置 (基类实现) virtual std::string get_ip(void)override;
virtual int set_final_image_format(SANE_FinalImgFormat* fmt); // 设置图像处理最终输出（final()）的图像数据格式 (基类实现) ***
virtual int get_compression_format(void);//获取支持的压缩格式 ***功能不支持
virtual int get_roller_num(void); //获取滚轮张数 ***完成 /////////////////成功返回:SCANNER_ERR_OK /////////////
virtual int get_history_count(void);//获取历史扫描张数 -2：设备不支持该功能；-1：与设备通信失败；其它大于等于0的为正常 /////////////////失败返回:IO错误码 /////////////
virtual int clear_roller_num(void); // 清除滚轴计数 ***完成 virtual int set_leaflet_scan(void) override; //单张扫描
virtual int set_compression_format(void);//设置图像数据最终输出的压缩格式 ***功能不支持 virtual int set_clear_roller_num(void) override; //清除滚轴计数
virtual int set_auto_color_type(void);// 设置自动匹配颜色模式 (基类实现) ***完成
virtual std::string get_firmware_version(void); virtual int get_device_code(void); //获取设备编码 不支持
virtual std::string get_serial_num(void);
virtual std::string get_ip(void);
virtual int get_device_code(void);//获取设备编码 virtual int get_scanner_paperon(SANE_Bool& type) override; //获取设备有无纸张 /*/ type : 0无纸 1有纸 */
virtual int get_sleep_time(SANE_Power* getime);//获取功耗模式（休眠）
virtual int set_sleep_time(int setsleepime);//设置功耗模式（休眠）
virtual int get_dogear_distance(void);//获取折角检测最小距离阈值
virtual int set_dogear_distance(void);// 设置折角检测最小距离阈值
virtual int get_scanner_paperon(SANE_Bool* paperon = NULL);//获取设备有无纸张
virtual int set_scan_when_paper_on(void);//获取是否为检测到进纸盘上有纸即开始扫描
virtual int get_scan_when_paper_on(void);//设置是否为检测到进纸盘上有纸即开始扫描
virtual int get_scan_with_hole(void);// 获取是否为带孔扫描
virtual int set_scan_with_hole(void);// 设置是否为带孔扫描
virtual int get_scan_is_sleep(void);//获取设备是否休眠当中 virtual int get_scan_is_sleep(SANE_Bool& type) override; //获取设备是否休眠当中 /*/ type : 0休眠 1唤醒状态*/
virtual int get_device_log(string &log);//获取设备日志 virtual int get_sleep_time(int& data) override; //获取功耗模式（休眠） /*/ data > 0*/
virtual int notify_sleep(void);//唤醒设备 virtual int set_sleep_time(int data) override; //设置功耗模式（休眠） /*/ data > 0*/
virtual int get_history_roller_count(int& num); //获取历史扫描张数 virtual int get_history_roller_count(int& data) override; //获取历史扫描张数 /*/ data > 0*/
virtual int get_roller_num(int& val); //获取滚轮张数 virtual int get_roller_num(int& data) override; //获取滚轮张数 /*/ data > 0*/
virtual int set_notify_sleep(void) override; //唤醒设备
virtual int get_device_log(string& log) override; //获取设备日志 /*/ log :储存路径*/
virtual int set_devreboot() override; //设置设备重启
virtual int set_devshtudown() override; //设置设备关机
virtual int set_scan_islock(SANE_Bool type) override; //设置设备是否锁定 /*/ type:0解锁，1锁定*/
virtual int get_scan_islock(SANE_Bool& type) override; //获取设备是否锁定 /*/ type:0解锁，1锁定*/
virtual int set_scan_lock_check_val(string str) override; //获取设备是否锁定 /*/ str:校验码*/
virtual int set_firmware_upgrade(std::string str) override; //固件升级 /*/ str:文件名路径*/
virtual int set_clean_paper_road() override; //清理纸道
virtual int get_dev_islock_file(int& data) override; //获取设备文件 /*/ data:0 未上锁，1 上锁。-1 未发现黑名单列表 -2列表没有信息*/
virtual int set_dev_islock_file(int data) override; //设置设备文件 /*/ data:0 未上锁，1 上锁*/
}; };

3
hgdriver/hgdev/scanner_manager.cpp
View File

@ -501,6 +501,7 @@ scanner_err hg_scanner_mgr::get_about_info(scanner_handle h, void* data, unsigne
MOVE_TO_NEXT_STR(ptr); MOVE_TO_NEXT_STR(ptr);
about->logo_bytes = sizeof(g_logo);; about->logo_bytes = sizeof(g_logo);;
about->logo = ptr;
memcpy(ptr, g_logo, about->logo_bytes); memcpy(ptr, g_logo, about->logo_bytes);
ptr += about->logo_bytes + 1; ptr += about->logo_bytes + 1;
@ -517,7 +518,7 @@ scanner_err hg_scanner_mgr::get_about_info(scanner_handle h, void* data, unsigne
set_appendix_info_for_about(about, ptr, count, BRAND_TITLE_FIRM_VERSION, scanner->get_firmware_version().c_str(), NULL); set_appendix_info_for_about(about, ptr, count, BRAND_TITLE_FIRM_VERSION, scanner->get_firmware_version().c_str(), NULL);
set_appendix_info_for_about(about, ptr, count, BRAND_TITLE_SERIAL_NUM, scanner->get_serial_num().c_str(), NULL); set_appendix_info_for_about(about, ptr, count, BRAND_TITLE_SERIAL_NUM, scanner->get_serial_num().c_str(), NULL);
info = scanner->get_ip(); info = scanner->get_ip();
if(info.length()) if (info.length() > 10)
set_appendix_info_for_about(about, ptr, count, BRAND_TITLE_IP, info.c_str(), NULL); set_appendix_info_for_about(about, ptr, count, BRAND_TITLE_IP, info.c_str(), NULL);
ret = scanner->get_roller_num(rolls); ret = scanner->get_roller_num(rolls);
if (ret == SCANNER_ERR_OK) if (ret == SCANNER_ERR_OK)