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_STATUS,
SR_SCAN_COUNT,
SR_OS,
SR_OS, //val == 1计数模式
SR_SENSORS,
SR_MOTOR,
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)
statu = SANE_Image_Statu_Double;
else if (err == SCANNER_ERR_DEVICE_PAPER_JAMMED)
statu = SANE_Image_Statu_Jammed;
//else if (err == SCANNER_ERR_DEVICE_PAPER_JAMMED)
//statu = SANE_Image_Statu_Jammed;
}
return statu;
@ -3061,7 +3061,7 @@ int hg_scanner::device_io_control(unsigned long code, void* data, unsigned* len)
if (len)
*len = val;
return clear_roller_num();
return set_clear_roller_num();
}
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)
{
return get_scanner_paperon((SANE_Bool*)data);
return get_scanner_paperon(*(SANE_Bool*)data);
}
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)
{
case SANE_POWER_NONE:
sleeptime = 0;
sleeptime = -1;
break;
case SANE_POWER_MINUTES_5:
sleeptime = 300;
sleeptime = 5;
break;
case SANE_POWER_MINUTES_10:
sleeptime = 600;
sleeptime = 10;
break;
case SANE_POWER_MINUTES_20:
sleeptime = 1200;
sleeptime = 20;
break;
case SANE_POWER_MINUTES_30:
sleeptime = 1800;
sleeptime = 30;
break;
case SANE_POWER_MINUTES_60:
sleeptime = 3600;
sleeptime = 60;
break;
case SANE_POWER_MINUTES_120:
sleeptime = 7200;
sleeptime = 120;
break;
case SANE_POWER_MINUTES_240:
sleeptime = 14400;
sleeptime = 14424000;
break;
case SANE_POWER_SHUTDOWN:
set_devshtudown();
@ -3211,7 +3211,7 @@ int hg_scanner::device_io_control(unsigned long code, void* data, unsigned* len)
set_devreboot();
break;
default:
sleeptime = 0;
sleeptime = -1;
break;
}
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)
{
string str = (char*)data;
return firmware_upgrade(str);
return set_firmware_upgrade(str);
}
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)
{
return clean_paper_road();
return set_clean_paper_road();
}
else if (code == IO_CTRL_CODE_GET_SCANN_NUM)
{
@ -3372,7 +3372,7 @@ int hg_scanner::set_devshtudown()
{
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;
}
@ -3392,11 +3392,11 @@ int hg_scanner::set_scan_lock_check_val(string check_str)
{
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;
}
int hg_scanner::clean_paper_road()
int hg_scanner::set_clean_paper_road()
{
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;
}
int hg_scanner::get_scan_mode(bool& type)
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
//////////////////////////////////////////////////////////////////////////////////////////////////////
int hg_scanner::set_leaflet_scan(void)
{
@ -3468,47 +3472,25 @@ int hg_scanner::get_device_code(void)
{
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;
}
int hg_scanner::set_sleep_time(int sleeptime)
int hg_scanner::set_sleep_time(int data)
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner::notify_sleep()
int hg_scanner::set_notify_sleep()
{
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;
}
int hg_scanner::set_dogear_distance(void)
{
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)
int hg_scanner::get_scan_is_sleep(SANE_Bool& data)
{
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_serial_num(void);
virtual std::string get_ip(void);
/// <summary>
/// retuen scanner_err
/// </summary>
virtual int set_leaflet_scan(void) = 0; //单张扫描
virtual int get_abuot_info(void) = 0; //获取软件关于信息 (基类实现)
/////////////////成功返回:SCANNER_ERR_OK /////////////
/////////////////失败返回:IO错误码 /////////////
virtual int set_leaflet_scan(void) = 0; //单张扫描
virtual int get_abuot_info(void); //获取软件关于信息 (基类实现)
virtual int restore_default_setting(void); //恢复默认设置 (基类实现)
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 set_auto_color_type(void); //设置自动匹配颜色模式 (基类实现) ***
virtual int get_device_code(void); //获取设备编码
virtual int get_dogear_distance(void); //获取折角检测最小距离阈值
virtual int set_dogear_distance(void); // 设置折角检测最小距离阈值
virtual int get_scanner_paperon(SANE_Bool* paperon = NULL)=0;//获取设备有无纸张
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_sleep_time(int& getsleepime); //获取功耗模式（休眠）
virtual int set_sleep_time(int sleeptime); //设置功耗模式（休眠）
virtual int get_history_roller_count(int &num) = 0; //获取历史扫描张数
virtual int get_roller_num(int &val) = 0; //获取滚轮张数
virtual int notify_sleep(void); //唤醒设备
virtual int get_device_log(string &log); //获取设备日志
virtual int set_devreboot(); //设置设备重启
virtual int set_devshtudown(); //设置设备关机
virtual int set_scan_islock(SANE_Bool set_islock); //设置设备是否锁定 0解锁，1锁定 ret
virtual int get_scan_islock(SANE_Bool& islock); //获取设备是否锁定 0解锁，1锁定
virtual int set_scan_lock_check_val(string check_str); //获取设备是否锁定
virtual int firmware_upgrade(std::string filename); //固件升级
virtual int clean_paper_road(); //清理纸道
virtual int get_dev_islock_file(int &islockfile); //获取设备文件 设备锁状态 0 未上锁，1 上锁。-1 未发现黑名单列表 -2列表当中没有信息
virtual int set_dev_islock_file(int islockfile); //设置设备文件 设备锁状态 0 未上锁，1 上锁。
virtual int get_compression_format(void); //获取支持的压缩格式 不支持
virtual int set_compression_format(void); //设置图像数据最终输出的压缩格式 不支持
virtual int set_auto_color_type(void); //设置自动匹配颜色模式 (基类实现)
virtual int set_clear_roller_num(void) = 0; //清除滚轴计数
virtual int get_device_code(void); //获取设备编码 不支持
virtual int get_scanner_paperon(SANE_Bool& type)=0; //获取设备有无纸张 /*/ type : false无纸（不正常状态false） true有纸 */
virtual int get_scan_is_sleep(SANE_Bool& type) = 0; //获取设备是否休眠当中 /*/ type : false休眠（不正常状态false） true未休眠*/
virtual int get_sleep_time(int& data) = 0; //获取功耗模式（休眠） /*/ data > 0*/
virtual int set_sleep_time(int data) = 0; //设置功耗模式（休眠） /*/ data > 0*/
virtual int get_history_roller_count(int &data) = 0; //获取历史扫描张数 /*/ data > 0*/
virtual int get_roller_num(int &data) = 0; //获取滚轮张数 /*/ data > 0*/
virtual int set_notify_sleep(void) = 0; //唤醒设备
virtual int get_device_log(string &log) = 0; //获取设备日志 /*/ log :储存路径*/
virtual int set_devreboot() = 0; //设置设备重启
virtual int set_devshtudown() = 0; //设置设备关机
virtual int set_scan_islock(SANE_Bool type) = 0; //设置设备是否锁定 /*/ type:0解锁，1锁定*/
virtual int get_scan_islock(SANE_Bool& type) = 0; //获取设备是否锁定 /*/ type:0解锁，1锁定*/
virtual int set_scan_lock_check_val(string str) = 0; //获取设备是否锁定 /*/ str:校验码*/
virtual int set_firmware_upgrade(std::string str) = 0; //固件升级 /*/ str:文件名路径*/
virtual int set_clean_paper_road() = 0; //清理纸道
virtual int get_dev_islock_file(int &data) = 0; //获取设备文件 /*/ data:0 未上锁，1 上锁。-1 未发现黑名单列表 -2列表没有信息*/
virtual int set_dev_islock_file(int data) = 0; //设置设备文件 /*/ data:0 未上锁，1 上锁*/
virtual int get_scan_mode(bool& type) ; //获取设备是否计数模式 /*/ type:false计数模式 true非计数模式
};
#ifdef UOS

184
hgdriver/hgdev/hg_scanner_200.cpp
View File

@ -226,10 +226,11 @@ int hg_scanner_200::start(void)
return ret;
}
printf_devconfig();
ret = get_scanner_paperon();
if (ret == SCANNER_ERR_DEVICE_NO_PAPER)
SANE_Bool type = false;
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_);
VLOG_MINI_1(LOG_LEVEL_WARNING, "device start status is(%s)\n", STATU_DESC_SCANNER_ERR_DEVICE_NO_PAPER);
return ret;
@ -665,22 +666,16 @@ std::string hg_scanner_200::get_serial_num()
return buf;
}
std::string hg_scanner_200::get_ip(void)
{
return "";
}
int hg_scanner_200::agreement()
{
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);
//io_->set_timeout(200);
return ret;
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
int hg_scanner_200::set_leaflet_scan(void)
{
int ret = SCANNER_ERR_OK;
@ -689,35 +684,17 @@ int hg_scanner_200::set_leaflet_scan(void)
ret = start();
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;
}
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;
return 0;
}
int hg_scanner_200::get_device_code(void)
{
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,
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);
if (ret == SCANNER_ERR_OK)
{
if (getime)
{
*getime = (SANE_Power)usbcb.u32_Data;
}
if (usbcb.u32_Data)
{
return SCANNER_ERR_DEVICE_SLEEPING;
}
data = usbcb.u32_Data;
}
return ret;
}
int hg_scanner_200::set_sleep_time(SANE_Power* setime)
int hg_scanner_200::set_sleep_time(int data)
{
if (!setime)
{
return SCANNER_ERR_NO_DATA;
}
int ret = SCANNER_ERR_OK,
time = *setime;
USBCB usbcb = { setting3288dsp::SET_SLEEP_TIME,time, 0 };
int ret = SCANNER_ERR_OK;
USBCB usbcb = { setting3288dsp::SET_SLEEP_TIME,data, 0 };
ret = writeusb(usbcb);
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 };
len = sizeof(USBCB);
ret = writeusb(usbcb);
io_->set_timeout(500);
if (ret == SCANNER_ERR_OK)
{
std::lock_guard<std::mutex> lock(io_lock_);
ret = io_->read_bulk(&usbcb,&len);
}
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;
ret = io_->read_bulk(&usbcb, &len);
type = usbcb.u32_Data == 0 ? false : true;
}
//if (usbcb.u32_Data == 0)
// ret = SCANNER_ERR_DEVICE_NO_PAPER;
//else
// ret = SCANNER_ERR_OK;
return ret;
}
int hg_scanner_200::set_scan_when_paper_on(void)
{
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 hg_scanner_200::get_scan_is_sleep(SANE_Bool& type)
{
int ret = SCANNER_ERR_OK,
len = 0;
@ -821,31 +755,65 @@ int hg_scanner_200::get_scan_is_sleep()
len = sizeof(USBCB);
ret = writeusb(usbcb);
io_->set_timeout(200);
if (ret == SCANNER_ERR_OK)
{
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)
{
return SCANNER_ERR_OK;
}
else if (usbcb.u32_Data == 0x100)
{
return SCANNER_ERR_DEVICE_SLEEPING;
if (usbcb.u32_Data == 0x10)
type = true;
//return SCANNER_ERR_OK;
else if (usbcb.u32_Data == 0x100)
type = false;
//return SCANNER_ERR_DEVICE_SLEEPING;
}
return ret;
}
int hg_scanner_200::get_device_log(string &log)
{
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;
}

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);
void writedown_image_configuration(void);
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_;
int agreement();
public:
virtual int set_leaflet_scan(void);//单张扫描
virtual int get_abuot_info(void);//获取软件关于信息
virtual int restore_default_setting(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); //获取滚轮张数
virtual std::string get_firmware_version(void);
virtual std::string get_serial_num(void);
virtual std::string get_ip(void);
public:
//virtual int get_roller_num(void) override; //获取滚轮张数 -2：设备不支持该功能；-1：与设备通信失败；其它大于等于0的为正常
//virtual int clear_roller_num(void) override; // 清除滚轴计数
//virtual int get_history_count(void) override;//获取历史扫描张数 -2：设备不支持该功能；-1：与设备通信失败；其它大于等于0的为正常
/////////////////成功返回:SCANNER_ERR_OK /////////////
/////////////////失败返回:IO错误码 /////////////
virtual int set_leaflet_scan(void) override; //单张扫描
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;
}
int hg_scanner_239::get_scan_mode(int &v)
int hg_scanner_239::get_scan_mode(bool &type)
{
int val = 0,
ret = read_register(setting3399::SR_OS, &val);
v = val;
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;
}
ret = read_register(setting3399::SR_OS, &val); //val == 1计数模式
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)
//{
//return SCANNER_ERR_DEVICE_COUNT_MODE;
//}
return ret;
}
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_)
{
SANE_Bool b = false;
status_ = ret = get_scanner_paperon(&b);
SANE_Bool b = true;
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_));
}
@ -1093,17 +1097,19 @@ int hg_scanner_239::start(void)
//ret = get_roller_num(val);
//211220固件版本不支持返回
if ((get_scan_is_sleep(val)) == SCANNER_ERR_DEVICE_SLEEPING)
ret = get_scan_is_sleep(val);
if (!val)
{
status_ = 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_)
ret = notify_sleep();
ret = set_notify_sleep();
notify_ui_working_status(STATU_DESC_SCANNER_ERR_DEVICE_NOTIFY_SLEEP, SANE_EVENT_ERROR, 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;
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)
{
return control_fetch(setting3399::SR_GET_FWVERSION, 0, 20);
}
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);
return ret;
}
int hg_scanner_239::clear_roller_num(void)
int hg_scanner_239::set_clear_roller_num(void)
{
int val = 0,
ret = read_register(setting3399::SR_CLR_ROLLER_NUM, &val);
@ -1241,45 +1245,23 @@ int hg_scanner_239::set_leaflet_scan(void)
ret = start();
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)
{
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,
ret = read_register(setting3399::SR_GET_SLEEPTIME, &val);
int val = 0;
int ret = read_register(setting3399::SR_GET_SLEEPTIME, &val);
if (ret == SCANNER_ERR_OK)
{
getime = val;
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;
}
int hg_scanner_239::set_sleep_time(int setsleepime)
@ -1290,51 +1272,32 @@ int hg_scanner_239::set_sleep_time(int setsleepime)
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 hg_scanner_239::set_dogear_distance(void)
{
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)
int val = 0;
int ret = read_register(setting3399::SR_GET_PAPERON, &val); //0无纸 1有纸
if (ret == SCANNER_ERR_OK)
{
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "get_scanner_paperon = %s\n", hg_scanner_err_name(ret));
return ret;
type = val == 0 ? false : true;
}
ret = val ? SCANNER_ERR_OK : SCANNER_ERR_DEVICE_NO_PAPER;
*paperon = val;
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "get_scanner_paperon = %s\n", hg_scanner_err_name(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);
return ret = status ? SCANNER_ERR_OK : SCANNER_ERR_DEVICE_SLEEPING;
int hg_scanner_239::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_239::notify_sleep()
int hg_scanner_239::set_notify_sleep()
{
int val = 0,
ret = SCANNER_ERR_OK;
@ -1510,7 +1473,7 @@ int hg_scanner_239::set_scan_lock_check_val(string check_str)
return ret;
#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::ifstream fwname;
@ -1588,9 +1551,9 @@ int hg_scanner_239::firmware_upgrade(std::string filename)
}
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;
ret = write_register(setting3399::SR_CLEAN_PAPER_ROAD, len);
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 get_fpga(void);
int get_scan_mode(int &v);
int get_status(void);
int get_image_count(void);
int get_front_data_size(void);
@ -81,37 +80,33 @@ public:
virtual std::string get_firmware_version(void);
virtual std::string get_serial_num(void);
virtual std::string get_ip(void);
virtual int set_leaflet_scan(void); //单张扫描
virtual int get_abuot_info(void); //获取软件关于信息 (基类实现)
virtual int restore_default_setting(void); //恢复默认设置 (基类实现)
virtual int set_final_image_format(SANE_FinalImgFormat* fmt); // 设置图像处理最终输出（final()）的图像数据格式 (基类实现) ***
virtual int get_compression_format(void); //获取支持的压缩格式
virtual int get_roller_num(int &val); //获取滚轮张数
virtual int clear_roller_num(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(int& 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);//获取设备有无纸张
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(int &status); //获取设备是否休眠当中
virtual int notify_sleep(void); //唤醒设备
virtual int get_history_roller_count(int &num); //获取历史扫描张数
virtual int get_device_log(string &get_device_log); //获取设备日志
virtual int set_devreboot(); //设置设备重启
virtual int set_devshtudown(); //设置设备关机
virtual int set_scan_islock(SANE_Bool set_islock);
virtual int get_scan_islock(SANE_Bool& islock);
virtual int set_scan_lock_check_val(string check_str);
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 上锁。
/////////////////成功返回:SCANNER_ERR_OK /////////////
/////////////////失败返回:IO错误码 /////////////
virtual int set_leaflet_scan(void) override; //单张扫描
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 上锁*/
virtual int get_scan_mode(bool& type);
};

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;
int ret = try_third_app_handle_start(handled),
count = -1;
count = -1,
val = 1;
user_cancel_ = false;
@ -186,22 +187,22 @@ void hg_scanner_300::thread_handle_usb_read(void)
}
printf_devconfig();
ret = get_scan_is_sleep();
if (ret == SCANNER_ERR_DEVICE_SLEEPING)
ret = get_scan_is_sleep(val);
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_NOTIFY_SLEEP, SANE_EVENT_ERROR, status_);
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();
if (ret == SCANNER_ERR_DEVICE_NO_PAPER)
ret = get_scanner_paperon(val);
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_);
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};
@ -569,6 +570,10 @@ std::string hg_scanner_300::get_firmware_version()
return SerialNum;
}
std::string hg_scanner_300::get_ip(void)
{
return "";
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
int hg_scanner_300::set_leaflet_scan(void)
{
@ -578,28 +583,8 @@ int hg_scanner_300::set_leaflet_scan(void)
ret = start();
return ret;
}
int hg_scanner_300::get_abuot_info(void)
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
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)
int hg_scanner_300::set_clear_roller_num(void)
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
@ -607,56 +592,35 @@ int hg_scanner_300::get_device_code(void)
{
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,
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;
}
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 (getime)
{
*getime = (SANE_Power)usbcb.u32_Data;
}
if (usbcb.u32_Data)
{
return SCANNER_ERR_DEVICE_SLEEPING;
}
data = (SANE_Power)usbcb.u32_Data;
}
return ret;
}
int hg_scanner_300::set_sleep_time(SANE_Power* setime)
int hg_scanner_300::set_sleep_time(int data)
{
if (!setime)
{
return SCANNER_ERR_NO_DATA;
}
int ret = SCANNER_ERR_OK,
time = *setime;
USBCB usbcb = { setting3288dsp::SET_SLEEP_TIME,time, 0};
int ret = SCANNER_ERR_OK;
USBCB usbcb = { setting3288dsp::SET_SLEEP_TIME,data, 0};
ret = writeusb(usbcb);
return ret;
}
int hg_scanner_300::get_dogear_distance(void)
{
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 hg_scanner_300::get_scanner_paperon(SANE_Bool& type)
{
int ret = SCANNER_ERR_OK,
len = 0;
@ -664,69 +628,46 @@ int hg_scanner_300::get_scanner_paperon(SANE_Bool* paperon)
USBCB usbcb = { setting3288dsp::GET_PAPER_STATUS, 0, 0};
len = sizeof(USBCB);
ret = writeusb(usbcb);
//io_->set_timeout(500);
if (ret == SCANNER_ERR_OK)
{
ret = io_->read_bulk(&usbcb,&len);
}
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;
std::lock_guard<std::mutex> lock(io_lock_);
ret = io_->read_bulk(&usbcb, &len);
type = usbcb.u32_Data == 0 ? false : true;
}
//if (usbcb.u32_Data == 0)
// ret = SCANNER_ERR_DEVICE_NO_PAPER;
//else
// ret = SCANNER_ERR_OK;
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);
ret = writeusb(usbcb);
//io_->set_timeout(200);
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)
{
return SCANNER_ERR_OK;
}
else if (usbcb.u32_Data == 0x100)
{
return SCANNER_ERR_DEVICE_SLEEPING;
if (usbcb.u32_Data == 0x10)
type = true;
//return SCANNER_ERR_OK;
else if (usbcb.u32_Data == 0x100)
type = false;
//return SCANNER_ERR_DEVICE_SLEEPING;
}
return ret;
}
///此款设备无此功能
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;
}
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;
}

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);
void writedown_image_configuration(void);
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:
std::vector<int> savestatus_;
setting_hardware::HGSCANCONF_3288 dsp_config;
Device::PaperSize papersize;
public:
virtual int set_leaflet_scan(void);//单张扫描
virtual int get_abuot_info(void);//获取软件关于信息
virtual int restore_default_setting(void);//恢复默认设置
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);//获取设备编码
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); //获取滚轮张数
virtual std::string get_firmware_version(void)override;
virtual std::string get_serial_num(void)override;
virtual std::string get_ip(void)override;
/////////////////成功返回:SCANNER_ERR_OK /////////////
/////////////////失败返回:IO错误码 /////////////
virtual int set_leaflet_scan(void) override; //单张扫描
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 上锁*
};

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);
reset();
get_roller_num();
read_register(setting3399::SR_GET_PAPERON, &val);
if (!val)
{
@ -1110,25 +1109,8 @@ std::string hg_scanner_302::get_ip(void)
{
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)
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 hg_scanner_302::set_clear_roller_num(void)
{
int val = 0,
ret = read_register(setting3399::SR_CLR_ROLLER_NUM, &val);
@ -1144,47 +1126,24 @@ int hg_scanner_302::set_leaflet_scan(void)
ret = start();
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)
{
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,
ret = read_register(setting3399::SR_GET_SLEEPTIME, &val);
int val = 0;
int ret = read_register(setting3399::SR_GET_SLEEPTIME, &val);
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));
return -1;
save_sleeptime_type_ = true;
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)
{
@ -1194,64 +1153,28 @@ int hg_scanner_302::set_sleep_time(int setsleepime)
return ret;
}
int hg_scanner_302::get_dogear_distance(void)
{
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 hg_scanner_302::get_scanner_paperon(SANE_Bool& type)
{
int val = 0,
ret = read_register(setting3399::SR_GET_PAPERON, &val);
if (ret == SCANNER_ERR_OK)
{
if (!val)
{
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;
type = val == 0 ? false : true;;
}
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 hg_scanner_302::get_scan_when_paper_on(void)
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner_302::get_scan_with_hole(void)
{
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 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_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));
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,
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;
public:
virtual int set_leaflet_scan(void);//单张扫描
virtual int get_abuot_info(void);//获取软件关于信息 (基类实现)
virtual int restore_default_setting(void);//恢复默认设置 (基类实现)
virtual int set_final_image_format(SANE_FinalImgFormat* fmt); // 设置图像处理最终输出（final()）的图像数据格式 (基类实现) ***
virtual int get_compression_format(void);//获取支持的压缩格式 ***功能不支持
virtual std::string get_firmware_version(void)override;
virtual std::string get_serial_num(void)override;
virtual std::string get_ip(void)override;
virtual int get_roller_num(void); //获取滚轮张数 ***完成
virtual int get_history_count(void);//获取历史扫描张数 -2：设备不支持该功能；-1：与设备通信失败；其它大于等于0的为正常
virtual int clear_roller_num(void); // 清除滚轴计数 ***完成
/////////////////成功返回:SCANNER_ERR_OK /////////////
/////////////////失败返回:IO错误码 /////////////
virtual int set_leaflet_scan(void) override; //单张扫描
virtual int set_compression_format(void);//设置图像数据最终输出的压缩格式 ***功能不支持
virtual int set_auto_color_type(void);// 设置自动匹配颜色模式 (基类实现) ***完成
virtual int set_clear_roller_num(void) override; //清除滚轴计数
virtual std::string get_firmware_version(void);
virtual std::string get_serial_num(void);
virtual std::string get_ip(void);
virtual int get_device_code(void); //获取设备编码 不支持
virtual int get_device_code(void);//获取设备编码
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_scanner_paperon(SANE_Bool& type) override; //获取设备有无纸张 /*/ type : 0无纸 1有纸 */
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); //获取滚轮张数
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 上锁*/
};

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());
else
init_settings((jsontext3 + jsontext4).c_str());
printf_devconfig();
}
hg_scanner_400::~hg_scanner_400()
{}
@ -179,7 +176,8 @@ int hg_scanner_400::start(void)
{
bool handled = false;
int ret = try_third_app_handle_start(handled),
count = -1;
count = -1,
val = 1;
// for third-sane-app invoking, added on 2022-05-19
if (handled)
@ -195,23 +193,22 @@ int hg_scanner_400::start(void)
return ret;
}
printf_devconfig();
ret = get_scan_is_sleep();
if (ret == SCANNER_ERR_DEVICE_SLEEPING)
ret = get_scan_is_sleep(val);
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_NOTIFY_SLEEP, SANE_EVENT_ERROR, status_);
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();
if (ret == SCANNER_ERR_DEVICE_NO_PAPER)
ret = get_scanner_paperon(val);
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_);
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 };
@ -593,6 +590,10 @@ std::string hg_scanner_400::get_firmware_version()
return buf;
}
std::string hg_scanner_400::get_ip(void)
{
return "";
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
int hg_scanner_400::set_leaflet_scan(void)
{
@ -602,31 +603,12 @@ int hg_scanner_400::set_leaflet_scan(void)
ret = start();
return ret;
}
int hg_scanner_400::get_abuot_info(void)
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
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)
int hg_scanner_400::set_clear_roller_num(void)
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner_400::get_device_code(void)
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
@ -661,85 +643,54 @@ int hg_scanner_400::set_sleep_time(int setsleepime)
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);
ret = writeusb(usbcb);
//io_->set_timeout(500);
if (ret == SCANNER_ERR_OK)
{
ret = io_->read_bulk(&usbcb,&len);
}
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;
std::lock_guard<std::mutex> lock(io_lock_);
ret = io_->read_bulk(&usbcb, &len);
type = usbcb.u32_Data == 0 ? false : true;
}
//if (usbcb.u32_Data == 0)
// ret = SCANNER_ERR_DEVICE_NO_PAPER;
//else
// ret = SCANNER_ERR_OK;
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);
ret = writeusb(usbcb);
//io_->set_timeout(200);
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)
{
return SCANNER_ERR_OK;
}
else if (usbcb.u32_Data == 0x100)
{
return SCANNER_ERR_DEVICE_SLEEPING;
if (usbcb.u32_Data == 0x10)
type = true;
//return SCANNER_ERR_OK;
else if (usbcb.u32_Data == 0x100)
type = false;
//return SCANNER_ERR_DEVICE_SLEEPING;
}
return ret;
}
////////////////////////////////start/////////////////////////////
///此款设备无此功能暂时预留
@ -768,7 +719,43 @@ int hg_scanner_400::get_device_log(string &log)
{
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;
}

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);
void writedown_image_configuration(void);
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:
setting_hardware::HGSCANCONF_3288 dsp_config;
Device::PaperSize papersize;
public:
virtual int set_leaflet_scan(void);//单张扫描
virtual int get_abuot_info(void);//获取软件关于信息
virtual int restore_default_setting(void);//恢复默认设置
virtual int set_final_image_format(void); // 设置图像处理最终输出（final()）的图像数据格式
virtual std::string get_firmware_version(void)override;
virtual std::string get_serial_num(void)override;
virtual std::string get_ip(void)override;
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(int& getsleepime);//获取功耗模式（休眠）
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);// 设置是否为带孔扫描
/////////////////成功返回:SCANNER_ERR_OK /////////////
/////////////////失败返回:IO错误码 /////////////
virtual int set_leaflet_scan(void) override; //单张扫描
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); //获取滚轮张数
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 上锁*
};

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);
reset();
get_roller_num();
read_register(setting3399::SR_GET_PAPERON, &val);
if (!val)
{
@ -1069,25 +1069,8 @@ std::string hg_scanner_402::get_ip(void)
{
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)
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 hg_scanner_402::set_clear_roller_num(void)
{
int val = 0,
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 ret = SCANNER_ERR_OK;
int ret = SCANNER_ERR_OK;
test_1_paper_ = true;
ret = start();
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)
{
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,
ret = read_register(setting3399::SR_GET_SLEEPTIME, &val);
int val = 0;
int ret = read_register(setting3399::SR_GET_SLEEPTIME, &val);
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));
return -1;
save_sleeptime_type_ = true;
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)
{
@ -1153,70 +1113,88 @@ int hg_scanner_402::set_sleep_time(int setsleepime)
return ret;
}
int hg_scanner_402::get_dogear_distance(void)
{
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 hg_scanner_402::get_scanner_paperon(SANE_Bool& type)
{
int val = 0,
ret = read_register(setting3399::SR_GET_PAPERON, &val);
if (ret == SCANNER_ERR_OK)
{
if (!val)
{
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;
type = val == 0 ? false : true;;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
int hg_scanner_402::notify_sleep()
int hg_scanner_402::set_notify_sleep()
{
int val = 0,
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;
public:
virtual int set_leaflet_scan(void);//单张扫描
virtual int get_abuot_info(void);//获取软件关于信息 (基类实现)
virtual int restore_default_setting(void);//恢复默认设置 (基类实现)
virtual int set_final_image_format(SANE_FinalImgFormat* fmt); // 设置图像处理最终输出（final()）的图像数据格式 (基类实现) ***
virtual int get_compression_format(void);//获取支持的压缩格式 ***功能不支持
virtual std::string get_firmware_version(void)override;
virtual std::string get_serial_num(void)override;
virtual std::string get_ip(void)override;
virtual int get_roller_num(void); //获取滚轮张数 ***完成
virtual int get_history_count(void);//获取历史扫描张数 -2：设备不支持该功能；-1：与设备通信失败；其它大于等于0的为正常
virtual int clear_roller_num(void); // 清除滚轴计数 ***完成
/////////////////成功返回:SCANNER_ERR_OK /////////////
/////////////////失败返回:IO错误码 /////////////
virtual int set_leaflet_scan(void) override; //单张扫描
virtual int set_compression_format(void);//设置图像数据最终输出的压缩格式 ***功能不支持
virtual int set_auto_color_type(void);// 设置自动匹配颜色模式 (基类实现) ***完成
virtual int set_clear_roller_num(void) override; //清除滚轴计数
virtual std::string get_firmware_version(void);
virtual std::string get_serial_num(void);
virtual std::string get_ip(void);
virtual int get_device_code(void); //获取设备编码 不支持
virtual int get_device_code(void);//获取设备编码
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_scanner_paperon(SANE_Bool& type) override; //获取设备有无纸张 /*/ type : 0无纸 1有纸 */
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); //获取滚轮张数
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 上锁*/
};

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);
about->logo_bytes = sizeof(g_logo);;
about->logo = ptr;
memcpy(ptr, g_logo, about->logo_bytes);
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_SERIAL_NUM, scanner->get_serial_num().c_str(), NULL);
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);
ret = scanner->get_roller_num(rolls);
if (ret == SCANNER_ERR_OK)