1739 lines
54 KiB
C++
1739 lines
54 KiB
C++
#include"test_base.h"
|
||
#include<string>
|
||
#include <stdio.h>
|
||
#include <windows.h>
|
||
#include <map>
|
||
#include <iostream>
|
||
#include "huagao/hgscanner_error.h"
|
||
#include "sane/sane_option_definitions.h";
|
||
static struct Test_Map
|
||
{
|
||
const wchar_t* name; // DIAL_SWITCH
|
||
const wchar_t* title; // 歪斜检测
|
||
}Test_Map_NO[] =
|
||
{
|
||
{HGPDTTOOLDB_NAME_DIAL_SWITCH ,HGPDTTOOLDB_TITLE_DIAL_SWITCH},
|
||
{HGPDTTOOLDB_NAME_ROCKER_SWITCH ,HGPDTTOOLDB_TITLE_ROCKER_SWITCH},
|
||
{HGPDTTOOLDB_NAME_BOOT_STATUS ,HGPDTTOOLDB_TITLE_BOOT_STATUS},
|
||
{HGPDTTOOLDB_NAME_LCD_DISPLAY ,HGPDTTOOLDB_TITLE_LCD_DISPLAY},
|
||
{HGPDTTOOLDB_NAME_KEY_FUNCTION ,HGPDTTOOLDB_TITLE_KEY_FUNCTION},
|
||
{HGPDTTOOLDB_NAME_COUNTING_MODE ,HGPDTTOOLDB_TITLE_COUNTING_MODE},
|
||
{HGPDTTOOLDB_NAME_CIS_ORIGINAL_IMAGE ,HGPDTTOOLDB_TITLE_CIS_ORIGINAL_IMAGE},
|
||
{HGPDTTOOLDB_NAME_HOST_FAN ,HGPDTTOOLDB_TITLE_HOST_FAN},
|
||
{HGPDTTOOLDB_NAME_SCAN_WORKING_STATUS ,HGPDTTOOLDB_TITLE_SCAN_WORKING_STATUS},
|
||
{HGPDTTOOLDB_NAME_USB_PC_INTERFACE ,HGPDTTOOLDB_TITLE_USB_PC_INTERFACE},
|
||
{HGPDTTOOLDB_NAME_LED_LIGHT ,HGPDTTOOLDB_TITLE_LED_LIGHT},
|
||
{HGPDTTOOLDB_NAME_RESET ,HGPDTTOOLDB_TITLE_RESET},
|
||
{HGPDTTOOLDB_NAME_PAPER_FEED ,HGPDTTOOLDB_TITLE_PAPER_FEED},
|
||
{HGPDTTOOLDB_NAME_SCANNING_SENSOR ,HGPDTTOOLDB_TITLE_SCANNING_SENSOR},
|
||
{HGPDTTOOLDB_NAME_PLACE_CORRECTION_PAPER ,HGPDTTOOLDB_TITLE_PLACE_CORRECTION_PAPER},
|
||
{HGPDTTOOLDB_NAME_AUTO_FLAT_FIELD ,HGPDTTOOLDB_TITLE_AUTO_FLAT_FIELD},
|
||
{HGPDTTOOLDB_NAME_IMAGE_COLOR_QUALITY ,HGPDTTOOLDB_TITLE_IMAGE_QUALITY},
|
||
{HGPDTTOOLDB_NAME_COLORCARD_IMAGEING_QUALITY ,HGPDTTOOLDB_TITLE_COLORCARD_IMAGEING_QUALITY},
|
||
{HGPDTTOOLDB_NAME_COLORCARD_BIAS_IMAGEING_QUALITY ,HGPDTTOOLDB_TITLE_COLORCARD_BIAS_IMAGEING_QUALITY},
|
||
{HGPDTTOOLDB_NAME_CLARITY_QUALITY ,HGPDTTOOLDB_TITLE_CLARITY_QUALITY},
|
||
{HGPDTTOOLDB_NAME_GET_DISTORTION_VAL ,HGPDTTOOLDB_TITLE_DISTORTION},
|
||
{HGPDTTOOLDB_NAME_SEPARATER_MOTOR ,HGPDTTOOLDB_TITLE_SEPARATER_MOTOR},
|
||
{HGPDTTOOLDB_NAME_CLEAR_PAPER_PATH ,HGPDTTOOLDB_TITLE_CLEAR_PAPER_PATH},
|
||
{HGPDTTOOLDB_NAME_SKEW_DETECTION ,HGPDTTOOLDB_TITLE_SKEW_DETECTION},
|
||
{HGPDTTOOLDB_NAME_ULTRASONIC_MODULE ,HGPDTTOOLDB_TITLE_ULTRASONIC_MODULE},
|
||
{HGPDTTOOLDB_NAME_COVER_SENSOR ,HGPDTTOOLDB_TITLE_COVER_SENSOR },
|
||
{HGPDTTOOLDB_NAME_REBOOT_DEVICE ,HGPDTTOOLDB_TITLE_REBOOT_DEVICE},
|
||
{HGPDTTOOLDB_NAME_MECH_PAPER_FEEDING_INCLINATION ,HGPDTTOOLDB_TITLE_MECH_PAPER_FEEDING_INCLINATION},
|
||
{HGPDTTOOLDB_NAME_CLEAR_ROLLER_COUNT ,HGPDTTOOLDB_TITLE_CLEAR_ROLLER_COUNT},
|
||
{HGPDTTOOLDB_NAME_CLEAR_HISTORY_COUNT ,HGPDTTOOLDB_TITLE_CLEAR_HISTORY_COUNT},
|
||
{HGPDTTOOLDB_NAME_PAPER_SEPARATION_STRENGTH ,HGPDTTOOLDB_TITLE_PAPER_SEPARATION_STRENGTH},
|
||
{HGPDTTOOLDB_NAME_CONFIGURE_SPEED_MODE ,HGPDTTOOLDB_TITLE_CONFIGURE_SPEED_MODE},
|
||
{HGPDTTOOLDB_NAME_DORMANCY ,HGPDTTOOLDB_TITLE_DORMANCY},
|
||
{HGPDTTOOLDB_NAME_GET_DEVICE_CONFIG ,HGPDTTOOLDB_TITLE_GET_DEVICE_CONFIG},
|
||
{HGPDTTOOLDB_NAME_GET_DEVICE_CPU_DISK ,HGPDTTOOLDB_TITLE_GET_DEVICE_CPU_DISK},
|
||
{HGPDTTOOLDB_NAME_BACKUP ,HGPDTTOOLDB_TITLE_BACKUP},
|
||
{HGPDTTOOLDB_NAME_SHUTDOWN ,HGPDTTOOLDB_TITLE_SHUTDOWN},
|
||
{HGPDTTOOLDB_NAME_SET_FIRMWARE_LANGUAGE ,HGPDTTOOLDB_TITLE_SET_FIRMWARE_LANGUAGE},
|
||
{HGPDTTOOLDB_NAME_IMAGE_CORRECTION_RGB_200DPI ,HGPDTTOOLDB_TITLE_IMAGE_CORRECTION_RGB_200DPI},
|
||
{HGPDTTOOLDB_NAME_IMAGE_CORRECTION_GRAY_200DPI ,HGPDTTOOLDB_TITLE_IMAGE_CORRECTION_GRAY_200DPI},
|
||
{HGPDTTOOLDB_NAME_IMAGE_CORRECTION_RGB_300DPI ,HGPDTTOOLDB_TITLE_IMAGE_CORRECTION_RGB_300DPI},
|
||
{HGPDTTOOLDB_NAME_IMAGE_CORRECTION_GRAY_300DPI ,HGPDTTOOLDB_TITLE_IMAGE_CORRECTION_GRAY_300DPI},
|
||
{HGPDTTOOLDB_NAME_IMAGE_CORRECTION_RGB_600DPI ,HGPDTTOOLDB_TITLE_IMAGE_CORRECTION_RGB_600DPI},
|
||
{HGPDTTOOLDB_NAME_IMAGE_CORRECTION_GRAY_600DPI ,HGPDTTOOLDB_TITLE_IMAGE_CORRECTION_GRAY_600DPI}
|
||
};
|
||
|
||
static std::string StringToUtf(std::string strValue)
|
||
{
|
||
int nwLen = MultiByteToWideChar(CP_UTF8, 0, strValue.c_str(), -1, NULL, 0);
|
||
wchar_t* pwBuf = new wchar_t[nwLen + 1];//加上末尾'\0'
|
||
memset(pwBuf, 0, nwLen * 2 + 2);
|
||
MultiByteToWideChar(CP_UTF8, 0, strValue.c_str(), strValue.length(), pwBuf, nwLen);
|
||
int nLen = WideCharToMultiByte(CP_ACP, 0, pwBuf, -1, NULL, NULL, NULL, NULL);
|
||
char* pBuf = new char[nLen + 1];
|
||
memset(pBuf, 0, nLen + 1);
|
||
WideCharToMultiByte(CP_ACP, 0, pwBuf, nwLen, pBuf, nLen, NULL, NULL);
|
||
std::string retStr = pBuf;
|
||
delete[]pBuf;
|
||
delete[]pwBuf;
|
||
return retStr;
|
||
}
|
||
static int str_to_wchar(std::string str, wchar_t* s, size_t* strlen)
|
||
{
|
||
if (str.empty())
|
||
return ERROR_INSUFFICIENT_BUFFER;
|
||
|
||
size_t size = str.length();
|
||
int len = 0;
|
||
len = MultiByteToWideChar(CP_UTF8, 0, str.c_str(), -1, NULL, 0);
|
||
if (*strlen < len)
|
||
{
|
||
*strlen = len;
|
||
return ERROR_INSUFFICIENT_BUFFER;
|
||
}
|
||
MultiByteToWideChar(CP_UTF8, 0, str.c_str(), -1, s, len);
|
||
return 0;
|
||
}
|
||
static int wchar_to_char(std::string &str, wchar_t* s, size_t* strlen)
|
||
{
|
||
if (!s)
|
||
return ERROR_INSUFFICIENT_BUFFER;
|
||
|
||
int len = WideCharToMultiByte(CP_ACP, 0, s, -1, NULL, 0, NULL, NULL);
|
||
if (*strlen < len)
|
||
{
|
||
*strlen = len;
|
||
return ERROR_INSUFFICIENT_BUFFER;
|
||
}
|
||
|
||
WideCharToMultiByte(CP_ACP, 0, s, -1, (char *)str.c_str(), len, NULL, NULL);
|
||
return 0;
|
||
}
|
||
int get_json_config_file()
|
||
{
|
||
int len = 0;
|
||
char exePath[256];
|
||
char* buf = NULL;
|
||
GetModuleFileNameA(NULL, exePath, 255);
|
||
(strrchr(exePath, '\\'))[1] = 0; //去掉执行的文件名。
|
||
|
||
strcat(exePath, "DLLs\\G302.hsc");
|
||
FILE* fp = fopen(exePath, "rb");
|
||
if (fp == NULL)
|
||
{
|
||
return -1;
|
||
}
|
||
fseek(fp, 0, SEEK_END);
|
||
len = ftell(fp);
|
||
fseek(fp, 0, SEEK_SET);
|
||
buf = new char[len];
|
||
if (!buf)
|
||
{
|
||
fclose(fp);
|
||
return -1;
|
||
}
|
||
memset(buf, 0, len);
|
||
fread(buf, len, 1, fp);
|
||
fclose(fp);
|
||
std::cout << buf << std::endl;
|
||
}
|
||
static std::wstring set_test_name_ =L"";
|
||
//bool is_distortion_get_image = false;
|
||
//bool is_distortion_get_image_abnormal = false;
|
||
std::atomic<bool> is_distortion_get_image_abnormal(false);
|
||
std::atomic<bool> is_distortion_get_image(false);
|
||
class test
|
||
{
|
||
ui_helper* helper_;
|
||
int fw_;
|
||
|
||
/*设置vid pid*/
|
||
int test_set_vidpid(void* data)
|
||
{
|
||
unsigned int len = sizeof(int);
|
||
int set_vidpid = *((int*)data),
|
||
get_vidpid = 0,
|
||
ret = SCANNER_ERR_OK;
|
||
ret = helper_->io_control(IO_CTRL_CODE_SET_VIDPID, &set_vidpid, &len);
|
||
if (ret == SCANNER_ERR_OK)
|
||
{
|
||
ret = helper_->io_control(IO_CTRL_CODE_GET_VIDPID, &get_vidpid, &len);
|
||
if (set_vidpid == get_vidpid)
|
||
helper_->test_callback(set_test_name_.c_str(), ui_helper::TEST_EVENT_MANUAL_CONFIRMATION, (void*)L"设置vidpid成功", true);
|
||
else
|
||
helper_->test_callback(set_test_name_.c_str(), ui_helper::TEST_EVENT_MANUAL_CONFIRMATION, (void*)L"设置vidpid失败", false);
|
||
}
|
||
return ret;
|
||
}
|
||
/*设置序列号*/
|
||
int test_set_serial_num(void* data)
|
||
{
|
||
wchar_t* sn = (wchar_t*)data;
|
||
|
||
std::string set_sn,
|
||
get_sn;
|
||
int ret = SCANNER_ERR_OK;
|
||
size_t len = 0;
|
||
ret = wchar_to_char(set_sn, sn, &len);
|
||
if (ret == ERROR_INSUFFICIENT_BUFFER)
|
||
{
|
||
set_sn.resize(len);
|
||
ret = wchar_to_char(set_sn, sn, &len);
|
||
}
|
||
unsigned int setlen = set_sn.size(),
|
||
getlen = 0;
|
||
|
||
ret = helper_->io_control(IO_CTRL_CODE_SET_SERIAL, &set_sn[0], &setlen);
|
||
|
||
if (ret != SCANNER_ERR_OK)return ret;
|
||
|
||
helper_->test_callback(set_test_name_.c_str(), ui_helper::TEST_EVENT_MANUAL_CONFIRMATION, (void*)L"设置序列号完成", true);
|
||
|
||
return ret;
|
||
}
|
||
/* 设置休眠 */
|
||
int test_dormancy(void* data)
|
||
{
|
||
const wchar_t sleep_buf[8] = { 0,5,10,20,30,60,120,240 };
|
||
int sleep_time = *((int*)data);
|
||
SANE_Power power;
|
||
unsigned int len = sizeof(SANE_Power);
|
||
|
||
for (size_t i = 0; i < 8; i++)
|
||
{
|
||
if (sleep_buf[i] == sleep_time)
|
||
{
|
||
power = (SANE_Power)i;
|
||
break;
|
||
}
|
||
else
|
||
power = SANE_POWER_NONE;
|
||
}
|
||
int ret = helper_->io_control(IO_CTRL_CODE_SET_POWER_LEVEL, &power, &len);
|
||
if (ret != SCANNER_ERR_OK)
|
||
{
|
||
return ret;
|
||
}
|
||
int gettime = 0;
|
||
unsigned int timelen = sizeof(int*);
|
||
|
||
ret = helper_->io_control(IO_CTRL_CODE_GET_POWER_LEVEL, &gettime, &timelen);
|
||
|
||
if (gettime == INT_MAX || gettime == -1)
|
||
gettime = 0;
|
||
else
|
||
gettime /= 60;
|
||
|
||
if (sleep_time == gettime)
|
||
helper_->test_callback(set_test_name_.c_str(), ui_helper::TEST_EVENT_MANUAL_CONFIRMATION, (void*)L"设置休眠时间成功", true);
|
||
else
|
||
helper_->test_callback(set_test_name_.c_str(), ui_helper::TEST_EVENT_MANUAL_CONFIRMATION, (void*)L"设置休眠时间失败", false);
|
||
return ret;
|
||
}
|
||
/*获取固件版本号*/
|
||
std::string get_firmware_version()
|
||
{
|
||
std::string fw = "";
|
||
unsigned int len = 0;
|
||
int ret = helper_->io_control(IO_CTRL_CODE_GET_HARDWARE_VERSION, &fw[0], &len);
|
||
fw.resize(len);
|
||
ret = helper_->io_control(IO_CTRL_CODE_GET_HARDWARE_VERSION, &fw[0], &len);
|
||
|
||
return fw;
|
||
}
|
||
/* 配置速度模式 */
|
||
int test_configure_speed_mode(void* data)
|
||
{
|
||
unsigned int len = sizeof(int);
|
||
int speed_mode = *((int*)data);
|
||
bool type = false;
|
||
const char G139[6] = { 60,70,80,90,110 };
|
||
const char G239[6] = { 90,100,110,120,130 };
|
||
const char G300[6] = { 40,50,60,70,80,90 };
|
||
const char G306[6] = { 30,40,50,60,70 };
|
||
const char G400[6] = { 40,50,60,70,80 };
|
||
|
||
std::string fv(get_firmware_version());
|
||
if (fv.empty())
|
||
{
|
||
return -1;
|
||
}
|
||
std::string str = fv.substr(0, 2);
|
||
std::string str2 = fv.substr(3, 1);
|
||
|
||
//139和239设备直接设置实际速度,其它设备设置速度模式为1 2 3 4 5
|
||
if (str2 == "Z" && speed_mode >= 30 && speed_mode <= 70)
|
||
{
|
||
for (size_t i = 0; i < sizeof(G306) / sizeof(G306[0]); i++)
|
||
{
|
||
if (G306[i] == speed_mode)
|
||
{
|
||
speed_mode = i + 1;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
else if (str == "G3" && speed_mode >= 40 && speed_mode <= 90)
|
||
{
|
||
for (size_t i = 0; i < sizeof(G300) / sizeof(G300[0]); i++)
|
||
{
|
||
if (G300[i] == speed_mode)
|
||
{
|
||
speed_mode = i + 1;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
else if (str == "G4" && speed_mode >= 40 && speed_mode <= 80)
|
||
{
|
||
for (size_t i = 0; i < sizeof(G400) / sizeof(G400[0]); i++)
|
||
{
|
||
if (G400[i] == speed_mode)
|
||
{
|
||
speed_mode = i + 1;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
int ret = helper_->io_control(IO_CTRL_CODE_SET_SPEED_MODE, &speed_mode, &len);
|
||
return ret;
|
||
}
|
||
public:
|
||
|
||
static int sane_ex_callback(SANE_Handle hdev, int code, void* data, unsigned int* len, void* param)
|
||
{
|
||
if (!hdev && !param)
|
||
{
|
||
return -1;
|
||
}
|
||
ui_helper* h= (ui_helper*)param;
|
||
|
||
std::wstring wstr = L"";
|
||
size_t l = 0;
|
||
bool type = true;
|
||
wchar_t buf[128] =L"";
|
||
int ret = SCANNER_ERR_OK;
|
||
if (code != SANE_EVENT_IMAGE_OK)
|
||
{
|
||
ret = str_to_wchar((char*)data, (wchar_t*)wstr.c_str(), &l);
|
||
if (ret == ERROR_INSUFFICIENT_BUFFER)
|
||
{
|
||
wstr.resize(l);
|
||
ret = str_to_wchar((char*)data, (wchar_t*)wstr.c_str(), &l);
|
||
}
|
||
if (ret == ERROR_INSUFFICIENT_BUFFER)
|
||
{
|
||
type = false;
|
||
|
||
h->test_callback(set_test_name_.c_str(), ui_helper::TEST_EVENT_RESULT, (void*)wstr.c_str(), type);
|
||
return -1;
|
||
}
|
||
}
|
||
|
||
//std::string str = StringToUtf((char*)data);
|
||
switch (code)
|
||
{
|
||
case SANE_EVENT_SCAN_FINISHED:
|
||
{
|
||
SANE_Bool close = false;
|
||
unsigned int closelen = sizeof(SANE_Bool);
|
||
|
||
if (wcscmp(set_test_name_.c_str(), HGPDTTOOLDB_NAME_SKEW_DETECTION) == 0)
|
||
{
|
||
if (strcmp((char*)data, STATU_DESC_SCANNER_ERR_DEVICE_PAPER_SKEW) != 0)
|
||
{
|
||
type = false;
|
||
wcscpy(buf, L"未检测到纸张倾斜, 原因--->");
|
||
}
|
||
}
|
||
else if(wcscmp(set_test_name_.c_str(), HGPDTTOOLDB_NAME_ULTRASONIC_MODULE) == 0)
|
||
{
|
||
if (strcmp((char*)data, STATU_DESC_SCANNER_ERR_DEVICE_DOUBLE_FEEDING) != 0)
|
||
{
|
||
type = false;
|
||
wcscpy(buf, L"未检测到双张, 原因--->");
|
||
}
|
||
}
|
||
else if (wcscmp(set_test_name_.c_str(), HGPDTTOOLDB_NAME_COVER_SENSOR) == 0)
|
||
{
|
||
if (strcmp((char*)data, STATU_DESC_SCANNER_ERR_DEVICE_COVER_OPENNED) != 0)
|
||
{
|
||
type = false;;
|
||
wcscpy(buf, L"未检测到设备开盖, 原因--->");
|
||
}
|
||
}
|
||
else if (wcscmp(set_test_name_.c_str(), HGPDTTOOLDB_NAME_PAPER_FEED) == 0)
|
||
{
|
||
if (strcmp((char*)data, STATU_DESC_SCAN_STOPPED) != 0)
|
||
{
|
||
type = false;
|
||
wcscpy(buf, L"走纸检测失败, 原因--->");
|
||
}
|
||
}
|
||
else if(wcscmp(set_test_name_.c_str(), HGPDTTOOLDB_NAME_AUTO_FLAT_FIELD) == 0)
|
||
{
|
||
if (strcmp((char*)data, STATU_DESC_SCANNER_ERR_DEVICE_AUTO_FAIL_OVER) != 0)
|
||
{
|
||
type = false;
|
||
wcscpy(buf, L"平场校正失败, 原因--->");
|
||
}
|
||
}
|
||
else if (wcscmp(set_test_name_.c_str(), HGPDTTOOLDB_NAME_GET_DISTORTION_VAL) == 0 || wcscmp(set_test_name_.c_str(), HGPDTTOOLDB_NAME_CONFIRM_DISTORTION_VAL) == 0)
|
||
{
|
||
if (strcmp((char*)data, STATU_DESC_SCAN_STOPPED) != 0 || strcmp((char*)data, STATU_DESC_SCANNER_ERR_DEVICE_DISTORTION) == 0)
|
||
{
|
||
type = false;
|
||
is_distortion_get_image = false;
|
||
is_distortion_get_image_abnormal = true;
|
||
wcscpy(buf, L"畸变修正值获取失败,原因--->");
|
||
}
|
||
else
|
||
{
|
||
is_distortion_get_image = true;
|
||
//type = true;
|
||
//wcscpy(buf, L"畸变修正值获取完成:");
|
||
break;
|
||
}
|
||
}
|
||
else if (wcscmp(set_test_name_.c_str(), HGPDTTOOLDB_NAME_IMAGE_COLOR_QUALITY) == 0
|
||
|| wcscmp(set_test_name_.c_str(), HGPDTTOOLDB_NAME_IMAGE_GRAY_QUALITY) == 0)
|
||
{
|
||
if (strcmp((char*)data, STATU_DESC_SCAN_STOPPED) != 0)
|
||
{
|
||
type = false;
|
||
wcscpy(buf, L"扫描图像质量确认失败, 原因--->");
|
||
}
|
||
}
|
||
else if (wcscmp(set_test_name_.c_str(), HGPDTTOOLDB_NAME_SCANNING_SENSOR) == 0)
|
||
{
|
||
if (strcmp((char*)data, STATU_DESC_SCAN_STOPPED) != 0)
|
||
{
|
||
type = false;
|
||
wcscpy(buf, L"扫描传感器检查失败, 原因--->");
|
||
}
|
||
}
|
||
else if (wcscmp(set_test_name_.c_str(), HGPDTTOOLDB_NAME_CIS_ORIGINAL_IMAGE) == 0)
|
||
{
|
||
if (strcmp((char*)data, STATU_DESC_SCAN_STOPPED) != 0)
|
||
{
|
||
type = false;
|
||
wcscpy(buf, L"CIS原图初检, 原因--->");
|
||
}
|
||
h->io_control(IO_CTRL_CODE_SET_CIS_IMAGE, &close, &closelen);
|
||
}
|
||
else if (wcscmp(set_test_name_.c_str(), HGPDTTOOLDB_NAME_PRESSUER_TEST_RGB_200DPI) == 0
|
||
|| wcscmp(set_test_name_.c_str(), HGPDTTOOLDB_NAME_PRESSUER_TEST_GRAY_200DPI) == 0
|
||
|| wcscmp(set_test_name_.c_str(), HGPDTTOOLDB_NAME_PRESSUER_TEST_RGB_300DPI) == 0
|
||
|| wcscmp(set_test_name_.c_str(), HGPDTTOOLDB_NAME_PRESSUER_TEST_GRAY_300DPI) == 0
|
||
|| wcscmp(set_test_name_.c_str(), HGPDTTOOLDB_NAME_PRESSUER_TEST_RGB_600DPI) == 0
|
||
|| wcscmp(set_test_name_.c_str(), HGPDTTOOLDB_NAME_PRESSUER_TEST_GRAY_600DPI) == 0)
|
||
{
|
||
if (strcmp((char*)data, STATU_DESC_SCAN_STOPPED) != 0)
|
||
{
|
||
type = false;
|
||
wcscpy(buf, L"压力测试失败, 原因--->");
|
||
}
|
||
else
|
||
{
|
||
type = true;
|
||
wcscpy(buf, L"压力测试完成--->");
|
||
}
|
||
}
|
||
else if (wcscmp(set_test_name_.c_str(), HGPDTTOOLDB_NAME_COLORCARD_IMAGEING_QUALITY) == 0)
|
||
{
|
||
if (strcmp((char*)data, STATU_DESC_SCAN_STOPPED) != 0)
|
||
{
|
||
type = false;
|
||
wcscpy(buf, L"色卡纸成像质量评估失败, 原因--->");
|
||
}
|
||
}
|
||
else if (wcscmp(set_test_name_.c_str(), HGPDTTOOLDB_NAME_COLORCARD_BIAS_IMAGEING_QUALITY) == 0)
|
||
{
|
||
if (strcmp((char*)data, STATU_DESC_SCAN_STOPPED) != 0)
|
||
{
|
||
type = false;
|
||
wcscpy(buf, L"色卡纸偏色成像质量评估失败, 原因--->");
|
||
}
|
||
}
|
||
else if (wcscmp(set_test_name_.c_str(), HGPDTTOOLDB_NAME_CLARITY_QUALITY) == 0)
|
||
{
|
||
if (strcmp((char*)data, STATU_DESC_SCAN_STOPPED) != 0)
|
||
{
|
||
type = false;
|
||
wcscpy(buf, L"清晰度质量评估失败, 原因--->");
|
||
}
|
||
}
|
||
else if (wcscmp(set_test_name_.c_str(), HGPDTTOOLDB_NAME_SINGLE_PAGE_TEST) == 0)
|
||
{
|
||
if (strcmp((char*)data, STATU_DESC_SCAN_STOPPED) != 0)
|
||
{
|
||
type = false;
|
||
wcscpy(buf, L"单张测试失败, 原因--->");
|
||
}
|
||
}
|
||
else if (wcscmp(set_test_name_.c_str(), HGPDTTOOLDB_NAME_IMAGE_CORRECTION_RGB_200DPI) == 0
|
||
|| wcscmp(set_test_name_.c_str(), HGPDTTOOLDB_NAME_IMAGE_CORRECTION_GRAY_200DPI) == 0
|
||
|| wcscmp(set_test_name_.c_str(), HGPDTTOOLDB_NAME_IMAGE_CORRECTION_RGB_300DPI) == 0
|
||
|| wcscmp(set_test_name_.c_str(), HGPDTTOOLDB_NAME_IMAGE_CORRECTION_GRAY_300DPI) == 0
|
||
|| wcscmp(set_test_name_.c_str(), HGPDTTOOLDB_NAME_IMAGE_CORRECTION_RGB_600DPI) == 0
|
||
|| wcscmp(set_test_name_.c_str(), HGPDTTOOLDB_NAME_IMAGE_CORRECTION_GRAY_600DPI) == 0)
|
||
{
|
||
if (strcmp((char*)data, STATU_DESC_SCANNER_ERR_IMAGE_CORRECTION_FAIL) == 0)
|
||
{
|
||
type = false;
|
||
}
|
||
else
|
||
{
|
||
type = true;
|
||
}
|
||
}
|
||
|
||
wcscat(buf, wstr.c_str());
|
||
//ret = h->io_control(IO_CTRL_CODE_RESTORE_SETTINGS, NULL, NULL);//结束恢复默认
|
||
|
||
h->test_callback(set_test_name_.c_str(), ui_helper::TEST_EVENT_RESULT, (void*)buf, type);
|
||
}
|
||
break;
|
||
case SANE_EVENT_ERROR:
|
||
{
|
||
h->test_callback(set_test_name_.c_str(), ui_helper::TEST_EVENT_RESULT, (void*)wstr.c_str(), false);
|
||
}
|
||
break;
|
||
case SANE_EVENT_STATUS:
|
||
{
|
||
if (wcscmp(set_test_name_.c_str(), HGPDTTOOLDB_NAME_AUTO_FLAT_FIELD) == 0)
|
||
{
|
||
h->test_callback(set_test_name_.c_str(), ui_helper::TEST_EVENT_FALT_INFO, (wchar_t*)wstr.c_str(), type);
|
||
}
|
||
}
|
||
break;
|
||
case SANE_EVENT_IMAGE_OK:
|
||
{
|
||
if ( wcscmp(set_test_name_.c_str(), HGPDTTOOLDB_NAME_CIS_ORIGINAL_IMAGE) == 0
|
||
||wcscmp(set_test_name_.c_str(), HGPDTTOOLDB_NAME_IMAGE_COLOR_QUALITY) == 0
|
||
|| wcscmp(set_test_name_.c_str(), HGPDTTOOLDB_NAME_IMAGE_GRAY_QUALITY) == 0
|
||
||wcscmp(set_test_name_.c_str(), HGPDTTOOLDB_NAME_GET_DISTORTION_VAL) == 0
|
||
||wcscmp(set_test_name_.c_str(), HGPDTTOOLDB_NAME_CONFIRM_DISTORTION_VAL) == 0
|
||
|| wcscmp(set_test_name_.c_str(), HGPDTTOOLDB_NAME_SCANNING_SENSOR) == 0
|
||
|| wcscmp(set_test_name_.c_str(), HGPDTTOOLDB_NAME_COLORCARD_IMAGEING_QUALITY) == 0
|
||
|| wcscmp(set_test_name_.c_str(), HGPDTTOOLDB_NAME_COLORCARD_BIAS_IMAGEING_QUALITY) == 0
|
||
|| wcscmp(set_test_name_.c_str(), HGPDTTOOLDB_NAME_CLARITY_QUALITY) == 0
|
||
|| wcscmp(set_test_name_.c_str(), HGPDTTOOLDB_NAME_SINGLE_PAGE_TEST) == 0
|
||
|| wcscmp(set_test_name_.c_str(), HGPDTTOOLDB_NAME_PRESSUER_TEST_RGB_200DPI) == 0
|
||
|| wcscmp(set_test_name_.c_str(), HGPDTTOOLDB_NAME_PRESSUER_TEST_GRAY_200DPI) == 0
|
||
|| wcscmp(set_test_name_.c_str(), HGPDTTOOLDB_NAME_PRESSUER_TEST_RGB_300DPI) == 0
|
||
|| wcscmp(set_test_name_.c_str(), HGPDTTOOLDB_NAME_PRESSUER_TEST_GRAY_300DPI) == 0
|
||
|| wcscmp(set_test_name_.c_str(), HGPDTTOOLDB_NAME_PRESSUER_TEST_RGB_600DPI) == 0
|
||
|| wcscmp(set_test_name_.c_str(), HGPDTTOOLDB_NAME_PRESSUER_TEST_GRAY_600DPI) == 0
|
||
|| wcscmp(set_test_name_.c_str(), HGPDTTOOLDB_NAME_IMAGE_CORRECTION_RGB_200DPI) == 0
|
||
|| wcscmp(set_test_name_.c_str(), HGPDTTOOLDB_NAME_IMAGE_CORRECTION_GRAY_200DPI) == 0
|
||
|| wcscmp(set_test_name_.c_str(), HGPDTTOOLDB_NAME_IMAGE_CORRECTION_RGB_300DPI) == 0
|
||
|| wcscmp(set_test_name_.c_str(), HGPDTTOOLDB_NAME_IMAGE_CORRECTION_GRAY_300DPI) == 0
|
||
|| wcscmp(set_test_name_.c_str(), HGPDTTOOLDB_NAME_IMAGE_CORRECTION_RGB_600DPI) == 0
|
||
|| wcscmp(set_test_name_.c_str(), HGPDTTOOLDB_NAME_IMAGE_CORRECTION_GRAY_600DPI) == 0)
|
||
|
||
{
|
||
if (wcscmp(set_test_name_.c_str(), HGPDTTOOLDB_NAME_GET_DISTORTION_VAL) == 0)
|
||
{
|
||
is_distortion_get_image = true;
|
||
}
|
||
h->test_callback(set_test_name_.c_str(), ui_helper::TEST_EVENT_HAVE_IMAGE, data, true);
|
||
}
|
||
}
|
||
break;
|
||
}
|
||
return 0;
|
||
}
|
||
test(ui_helper* helper) :helper_(helper), fw_(0)
|
||
{
|
||
helper->register_sane_callback(sane_ex_callback, NULL);
|
||
init_test_map_();
|
||
}
|
||
~test()
|
||
{}
|
||
|
||
std::map<std::wstring, int(test::*)(void *)> test_map_;
|
||
void init_test_map_()
|
||
{
|
||
test_map_[WRITE_CFG_NAME] = &test::set_init_cfg;
|
||
test_map_[HGPDTTOOLDB_NAME_SET_JSON_SN] = &test::test_set_json_serial_num;
|
||
test_map_[HGPDTTOOLDB_NAME_CLEAR_PAPER_PATH] = &test::tset_clear_paper_path;
|
||
test_map_[HGPDTTOOLDB_NAME_KEY_FUNCTION] = &test::test_key_funtion;
|
||
test_map_[HGPDTTOOLDB_NAME_COUNTING_MODE] = &test::test_count_mode;
|
||
test_map_[HGPDTTOOLDB_NAME_SKEW_DETECTION] = &test::test_skew_detection;
|
||
test_map_[HGPDTTOOLDB_NAME_SEPARATER_MOTOR] = &test::test_separater_motor;
|
||
test_map_[HGPDTTOOLDB_NAME_CIS_ORIGINAL_IMAGE] = &test::test_cis__original_image;
|
||
test_map_[HGPDTTOOLDB_NAME_HOST_FAN] = &test::test_host_fan;
|
||
test_map_[HGPDTTOOLDB_NAME_SCAN_WORKING_STATUS] = &test::test_scan_work_status;
|
||
test_map_[HGPDTTOOLDB_NAME_USB_PC_INTERFACE] = &test::test_usb_pc_interface;
|
||
test_map_[HGPDTTOOLDB_NAME_ULTRASONIC_MODULE] = &test::test_ultrasonic_module;
|
||
test_map_[HGPDTTOOLDB_NAME_LED_LIGHT] = &test::test_led_light;
|
||
test_map_[HGPDTTOOLDB_NAME_RESET] = &test::test_reset;
|
||
test_map_[HGPDTTOOLDB_NAME_PAPER_FEED] = &test::test_paper_feed;
|
||
test_map_[HGPDTTOOLDB_NAME_SCANNING_SENSOR] = &test::test_scanning_sensor;
|
||
test_map_[HGPDTTOOLDB_NAME_CONFIGURE_SPEED_MODE] = &test::test_configure_speed_mode;
|
||
test_map_[HGPDTTOOLDB_NAME_PLACE_CORRECTION_PAPER] = &test::test_place_correction_paper;
|
||
test_map_[HGPDTTOOLDB_NAME_AUTO_FLAT_FIELD] = &test::test_auto_flat_field;
|
||
test_map_[HGPDTTOOLDB_NAME_REBOOT_DEVICE] = &test::test_reboot_device;
|
||
|
||
test_map_[HGPDTTOOLDB_NAME_IMAGE_COLOR_QUALITY] = &test::test_image_color_quality;
|
||
test_map_[HGPDTTOOLDB_NAME_IMAGE_GRAY_QUALITY] = &test::test_image_gray_quality;
|
||
|
||
test_map_[HGPDTTOOLDB_NAME_GET_DISTORTION_VAL] = &test::test_get_auto_distortion;
|
||
test_map_[HGPDTTOOLDB_NAME_SET_DISTORTION_VAL] = &test::test_set_auto_distortion;
|
||
test_map_[HGPDTTOOLDB_NAME_CONFIRM_DISTORTION_VAL] = &test::test_confirm_auto_distortion;
|
||
test_map_[HGPDTTOOLDB_NAME_DORMANCY] = &test::test_dormancy;
|
||
test_map_[HGPDTTOOLDB_NAME_PAPER_SEPARATION_STRENGTH] = &test::test_paper_separation_strength;
|
||
test_map_[HGPDTTOOLDB_NAME_MECH_PAPER_FEEDING_INCLINATION] = &test::test_mech_paper_feeding_inclination;
|
||
test_map_[HGPDTTOOLDB_NAME_CLEAR_ROLLER_COUNT] = &test::test_clear_roller_count;
|
||
test_map_[HGPDTTOOLDB_NAME_CLEAR_HISTORY_COUNT] = &test::test_clear_history_count;
|
||
|
||
test_map_[HGPDTTOOLDB_NAME_COVER_SENSOR] = &test::test_single_page_test;
|
||
test_map_[HGPDTTOOLDB_NAME_SINGLE_PAGE_TEST] = &test::test_single_page_test;
|
||
test_map_[HGPDTTOOLDB_NAME_COLORCARD_IMAGEING_QUALITY] = &test::test_single_page_test;
|
||
test_map_[HGPDTTOOLDB_NAME_COLORCARD_BIAS_IMAGEING_QUALITY] = &test::test_single_page_test;
|
||
test_map_[HGPDTTOOLDB_NAME_CLARITY_QUALITY] = &test::test_single_page_test;
|
||
|
||
test_map_[HGPDTTOOLDB_NAME_PRESSUER_TEST_RGB_200DPI] = &test::test_pressuer_test_rgb_200dpi;
|
||
test_map_[HGPDTTOOLDB_NAME_PRESSUER_TEST_GRAY_200DPI] = &test::test_pressuer_test_gray_200dpi;
|
||
test_map_[HGPDTTOOLDB_NAME_PRESSUER_TEST_RGB_300DPI] = &test::test_pressuer_test_rgb_300dpi;
|
||
test_map_[HGPDTTOOLDB_NAME_PRESSUER_TEST_GRAY_300DPI] = &test::test_pressuer_test_gray_300dpi;
|
||
test_map_[HGPDTTOOLDB_NAME_PRESSUER_TEST_RGB_600DPI] = &test::test_pressuer_test_rgb_600dpi;
|
||
test_map_[HGPDTTOOLDB_NAME_PRESSUER_TEST_GRAY_600DPI] = &test::test_pressuer_test_gray_600dpi;
|
||
test_map_[HGPDTTOOLDB_NAME_GET_DEVICE_CONFIG] = &test::test_get_device_config;
|
||
test_map_[HGPDTTOOLDB_NAME_GET_DEVICE_CPU_DISK] = &test::test_get_device_cpu_disk;
|
||
test_map_[HGPDTTOOLDB_NAME_BACKUP] = &test::test_backup;
|
||
test_map_[HGPDTTOOLDB_NAME_SHUTDOWN] = &test::test_shutdown;
|
||
test_map_[HGPDTTOOLDB_NAME_SET_FIRMWARE_LANGUAGE] = &test::test_set_firmware_language;
|
||
test_map_[HGPDTTOOLDB_NAME_IMAGE_CORRECTION_RGB_200DPI] = &test::test_image_correct_rgb_200dpi;
|
||
test_map_[HGPDTTOOLDB_NAME_IMAGE_CORRECTION_GRAY_200DPI] = &test::test_image_correct_gray_200dpi;
|
||
test_map_[HGPDTTOOLDB_NAME_IMAGE_CORRECTION_RGB_300DPI] = &test::test_image_correct_rgb_300dpi;
|
||
test_map_[HGPDTTOOLDB_NAME_IMAGE_CORRECTION_GRAY_300DPI] = &test::test_image_correct_gray_300dpi;
|
||
test_map_[HGPDTTOOLDB_NAME_IMAGE_CORRECTION_RGB_600DPI] = &test::test_image_correct_rgb_600dpi;
|
||
test_map_[HGPDTTOOLDB_NAME_IMAGE_CORRECTION_GRAY_600DPI] = &test::test_image_correct_gray_600dpi;
|
||
}
|
||
int set_test(const wchar_t* name,const wchar_t* oper)
|
||
{
|
||
|
||
if (wcscmp(name, HGPDTTOOLDB_NAME_SET_JSON_SN) == 0
|
||
|| wcscmp(name, HGPDTTOOLDB_NAME_GET_DEVICE_CONFIG) == 0
|
||
|| wcscmp(name, HGPDTTOOLDB_NAME_CONFIGURE_SPEED_MODE) == 0
|
||
|| wcscmp(name, WRITE_CFG_NAME) == 0)
|
||
{
|
||
std::string fw1(get_firmware_version());
|
||
if (!fw1.empty())
|
||
{
|
||
if ("G1" == fw1.substr(0, 2))
|
||
fw_ = 1;
|
||
else if ("G2" == fw1.substr(0, 2))
|
||
fw_ = 2;
|
||
else if ("G3" == fw1.substr(0, 2))
|
||
fw_ = 3;
|
||
else if ("G4" == fw1.substr(0, 2))
|
||
fw_ = 4;
|
||
}
|
||
}
|
||
if (!name)
|
||
return SCANNER_ERR_NO_DATA;
|
||
set_test_name_ = name;
|
||
int ret = SCANNER_ERR_OK;
|
||
|
||
auto it = test_map_.find(name);
|
||
|
||
if (it == test_map_.end())
|
||
{
|
||
helper_->test_callback(name, ui_helper::TEST_EVENT_NOT_FIND_TEST, NULL, false);
|
||
return ret;
|
||
}
|
||
ret = (this->*test_map_[name])((void*)oper);
|
||
|
||
const wchar_t* info = NULL;
|
||
if (ret == SCANNER_ERR_DEVICE_NOT_SUPPORT
|
||
|| ret == SCANNER_ERR_IO
|
||
|| ret == SCANNER_ERR_TIMEOUT
|
||
|| ret == SCANNER_ERR_NO_DATA
|
||
)
|
||
{
|
||
if (ret == SCANNER_ERR_DEVICE_NOT_SUPPORT)
|
||
info = L"设备不支持该操作";
|
||
else if (ret == SCANNER_ERR_IO)
|
||
info = L"IO错误";
|
||
else if (ret == SCANNER_ERR_TIMEOUT)
|
||
info = L"超时错误";
|
||
else if (ret == SCANNER_ERR_NO_DATA)
|
||
info = L"没有数据";
|
||
|
||
helper_->test_callback(name, ui_helper::TEST_EVENT_IO_FAIL, (void*)info, ret);
|
||
}
|
||
return ret;
|
||
}
|
||
public:
|
||
|
||
int set_init_cfg(void *data)
|
||
{
|
||
const wchar_t* p = (const wchar_t*)data;
|
||
LPWRITECFG cfg = (LPWRITECFG)p;
|
||
unsigned int len = 0;
|
||
int ret = SCANNER_ERR_OK;
|
||
switch (cfg->cat)
|
||
{
|
||
case WRITE_CAT_VID_PID:
|
||
ret = test_set_vidpid(cfg->val);
|
||
break;
|
||
case WRITE_CAT_SPEED:
|
||
ret = test_configure_speed_mode(cfg->val);
|
||
break;
|
||
case WRITE_CAT_SLEEP:
|
||
ret = test_dormancy(cfg->val);
|
||
break;
|
||
case WRITE_CAT_SERIALNUM:
|
||
ret = test_set_serial_num(cfg->val);
|
||
break;
|
||
case WRITE_CAT_DEVS_MODEL:
|
||
ret = test_set_devs_model (cfg->val);
|
||
break;
|
||
default:
|
||
helper_->test_callback(set_test_name_.c_str(), ui_helper::TEST_EVENT_RESULT, (void*)L"协议未找到", false);
|
||
break;
|
||
}
|
||
return ret;
|
||
}
|
||
|
||
/*设置序列号*/
|
||
int test_set_json_serial_num(void* data)
|
||
{
|
||
int ret = SCANNER_ERR_OK,
|
||
val = 0;
|
||
wchar_t* sn;
|
||
|
||
std::string set_sn,get_sn;
|
||
size_t len = 0;
|
||
parameter* prt = helper_->get_user_input(ui_helper::DATA_FROM_USER, ui_helper::VAL_TYPE_FLOAT, set_test_name_.c_str(), L"请设置序列号");
|
||
if (!prt)
|
||
{
|
||
helper_->test_callback(set_test_name_.c_str(), ui_helper::TEST_EVENT_RESULT, (void*)L"已退出序列号设置", false);
|
||
return -1;
|
||
}
|
||
else
|
||
{
|
||
sn = (wchar_t*)prt->get_data();
|
||
if (!sn)
|
||
{
|
||
helper_->test_callback(set_test_name_.c_str(), ui_helper::TEST_EVENT_RESULT, (void*)L"设置序列号失败", false);
|
||
return -1;
|
||
}
|
||
}
|
||
std::string fv(get_firmware_version());
|
||
if (fv.empty())
|
||
{
|
||
return -1;
|
||
}
|
||
std::string fvv = fv.substr(0, 4);
|
||
if (fvv != "G439" && fvv != "G239" && fvv != "G139")
|
||
{
|
||
fvv = fv.substr(0, 2);
|
||
}
|
||
|
||
ret = wchar_to_char(set_sn, sn, &len);
|
||
if (ret == ERROR_INSUFFICIENT_BUFFER)
|
||
{
|
||
if (fvv == "G3" || fvv == "G4")
|
||
{
|
||
if (len != 14)
|
||
{
|
||
helper_->test_callback(set_test_name_.c_str(), ui_helper::TEST_EVENT_RESULT, (void*)L"设置序列号不足:14位", false);
|
||
return -1;
|
||
}
|
||
|
||
}
|
||
set_sn.resize(len);
|
||
ret = wchar_to_char(set_sn, sn, &len);
|
||
}
|
||
unsigned int setlen = set_sn.size(),
|
||
getlen = 0;
|
||
|
||
ret = helper_->io_control(IO_CTRL_CODE_SET_SERIAL, &set_sn[0], &setlen);
|
||
|
||
if (ret != SCANNER_ERR_OK)return ret;
|
||
|
||
ret = helper_->io_control(IO_CTRL_CODE_GET_SERIAL, &get_sn[0], &getlen);
|
||
if (ret == SANE_STATUS_NO_MEM)
|
||
{
|
||
ret = helper_->io_control(IO_CTRL_CODE_GET_SERIAL, &get_sn[0], &getlen);
|
||
}
|
||
|
||
if (set_sn == get_sn)
|
||
{
|
||
helper_->test_callback(set_test_name_.c_str(), ui_helper::TEST_EVENT_RESULT, (void*)L"设置序列号完成", true);
|
||
}
|
||
else
|
||
{
|
||
helper_->test_callback(set_test_name_.c_str(), ui_helper::TEST_EVENT_RESULT, (void*)L"设置序列号失败", true);
|
||
|
||
}
|
||
|
||
|
||
return ret;
|
||
}
|
||
/* 清理纸道功能确认 */
|
||
int tset_clear_paper_path(void *data)
|
||
{
|
||
int ret = helper_->io_control(IO_CTRL_CODE_GET_CLEAN_PAPER_ROAD, NULL, NULL);
|
||
if (ret != SCANNER_ERR_OK)
|
||
{
|
||
return ret;
|
||
}
|
||
helper_->test_callback(set_test_name_.c_str(), ui_helper::TEST_EVENT_MANUAL_CONFIRMATION, (void*)L"请确认是否清理纸道成功", true);
|
||
return ret;
|
||
}
|
||
/* 按键功能检测 */
|
||
int test_key_funtion(void *data)
|
||
{
|
||
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
|
||
}
|
||
/* 计数模式检测 */
|
||
int test_count_mode(void *data)
|
||
{
|
||
SANE_Bool ismode = false;
|
||
unsigned int len = sizeof(SANE_Bool);
|
||
|
||
int ret = helper_->io_control(IO_CTRL_CODE_GET_IS_MODE, &ismode, &len);
|
||
if (ret != SCANNER_ERR_OK)
|
||
{
|
||
return ret;
|
||
}
|
||
helper_->test_callback(set_test_name_.c_str(), ui_helper::TEST_EVENT_MANUAL_CONFIRMATION, (void*)L"请确认与液晶面板是否匹配", ismode);
|
||
return ret;
|
||
}
|
||
/* 歪斜检测 */
|
||
int test_skew_detection(void *data)
|
||
{
|
||
const wchar_t* NAME = set_test_name_.c_str();
|
||
SANE_Bool type = true;
|
||
unsigned int len = sizeof(SANE_Bool);
|
||
int num = 0;
|
||
void* get_data = NULL;
|
||
parameter * ptr = helper_->get_user_input(ui_helper::DATA_FROM_USER, ui_helper::VAL_TYPE_INT, NAME,L"请歪斜放纸...设置阈值:0 - 5,值越小越容易检测,0为关闭歪斜检测");
|
||
if (ptr)
|
||
{
|
||
get_data = ptr->get_data();
|
||
if (!get_data)
|
||
{
|
||
helper_->test_callback(set_test_name_.c_str(), ui_helper::TEST_EVENT_RESULT, (void*)L"已退出歪斜检测流程", false);
|
||
return -1;
|
||
}
|
||
num = *((int*)get_data);
|
||
}
|
||
else
|
||
{
|
||
helper_->test_callback(set_test_name_.c_str(), ui_helper::TEST_EVENT_RESULT, (void*)L"已退出歪斜检测流程", false);
|
||
return -1;
|
||
}
|
||
type = num == 0 ? false:true;
|
||
ptr->release();
|
||
int ret = helper_->io_control(IO_CTRL_CODE_SET_SKEW_CHECK, &type, &len);
|
||
if (ret != SCANNER_ERR_OK)
|
||
return ret;
|
||
|
||
ret = helper_->io_control(IO_CTRL_CODE_SET_SKEW_CHECK_VAL, &num, &len);
|
||
if (ret != SCANNER_ERR_OK)
|
||
return ret;
|
||
|
||
ret = helper_->io_control(IO_CTRL_CODE_TEST_SINGLE, NULL, NULL);
|
||
return ret;
|
||
}
|
||
/* 分纸电机检测 */
|
||
int test_separater_motor(void *data)
|
||
{
|
||
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
|
||
}
|
||
/* cis原图初检 */
|
||
int test_cis__original_image(void *data)
|
||
{
|
||
const wchar_t* NAME = set_test_name_.c_str();
|
||
SANE_Bool type = true;
|
||
unsigned int len = sizeof(SANE_Bool);
|
||
int ret = SCANNER_ERR_OK;
|
||
|
||
ret = helper_->io_control(IO_CTRL_CODE_SET_CIS_IMAGE, &type, &len);
|
||
if (ret != SCANNER_ERR_OK)
|
||
{
|
||
return ret;
|
||
}
|
||
ret = helper_->io_control(IO_CTRL_CODE_GET_IMAGE, NULL, NULL);
|
||
if (ret != SCANNER_ERR_OK)
|
||
{
|
||
return ret;
|
||
}
|
||
return ret;
|
||
}
|
||
/* 主机风扇功能检测 */
|
||
int test_host_fan(void *data)
|
||
{
|
||
return helper_->io_control(IO_CTRL_CODE_GET_IMAGE, NULL, NULL);
|
||
}
|
||
/* 扫描工作状态 */
|
||
int test_scan_work_status(void* data)
|
||
{
|
||
return helper_->io_control(IO_CTRL_CODE_GET_IMAGE, NULL, NULL);
|
||
}
|
||
/* USB-PC接口 */
|
||
int test_usb_pc_interface(void* data)
|
||
{
|
||
return helper_->io_control(IO_CTRL_CODE_GET_IMAGE, NULL, NULL);
|
||
}
|
||
/* 超声波模块检验 */
|
||
int test_ultrasonic_module(void *data)
|
||
{
|
||
const wchar_t* NAME = set_test_name_.c_str();
|
||
SANE_Bool type = true;
|
||
unsigned int len = sizeof(SANE_Bool);
|
||
void* get_data = NULL;
|
||
int ret = SCANNER_ERR_OK;
|
||
parameter* ptr = helper_->get_user_input(ui_helper::DATA_FROM_USER, ui_helper::VAL_TYPE_BOOL, NAME,
|
||
L"请选择是否开启超声波检查,并且请放置双张纸");
|
||
if (ptr)
|
||
{
|
||
get_data = ptr->get_data();
|
||
if (!get_data)
|
||
{
|
||
helper_->test_callback(set_test_name_.c_str(), ui_helper::TEST_EVENT_RESULT, (void*)L"已退出超声波模块检测流程", false);
|
||
return -1;
|
||
}
|
||
else
|
||
type = *((bool*)get_data);
|
||
}
|
||
else
|
||
{
|
||
helper_->test_callback(set_test_name_.c_str(), ui_helper::TEST_EVENT_RESULT, (void*)L"已退出超声波模块检测流程", false);
|
||
return -1;
|
||
}
|
||
ptr->release();
|
||
|
||
ret = helper_->io_control(IO_CTRL_CODE_SET_ULTRASONIC_MODULE, &type, &len);
|
||
|
||
if (ret != SCANNER_ERR_OK)
|
||
{
|
||
return ret;
|
||
}
|
||
ret = helper_->io_control(IO_CTRL_CODE_TEST_SINGLE, NULL, NULL);
|
||
return ret;
|
||
}
|
||
/* led灯状态检查 */
|
||
int test_led_light(void *data)
|
||
{
|
||
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
|
||
}
|
||
/* 复位检查 */
|
||
int test_reset(void *data)
|
||
{
|
||
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
|
||
}
|
||
/* 走纸检查 */
|
||
int test_paper_feed(void *data) //使用单张扫描测试
|
||
{
|
||
return helper_->io_control(IO_CTRL_CODE_GET_IMAGE, NULL, NULL);
|
||
}
|
||
/* 扫描传感器检查 */
|
||
int test_scanning_sensor(void *data)
|
||
{
|
||
return helper_->io_control(IO_CTRL_CODE_GET_IMAGE, NULL, NULL);
|
||
}
|
||
/* 放置校正纸 */
|
||
int test_place_correction_paper(void *data)
|
||
{
|
||
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
|
||
}
|
||
/* 自动平场校正 */
|
||
int test_auto_flat_field(void *data)
|
||
{
|
||
if (!data)
|
||
return SCANNER_ERR_DATA_DAMAGED;
|
||
unsigned int len = sizeof(int);
|
||
wchar_t* p = (wchar_t*)data;
|
||
std::string str;
|
||
|
||
int ret = SCANNER_ERR_OK,
|
||
dpi_type = 0;
|
||
unsigned int llen = sizeof(int);
|
||
size_t strl = 0;
|
||
//ret = wchar_to_char(str, p, &strl);
|
||
//if (ret == ERROR_INSUFFICIENT_BUFFER)
|
||
//{
|
||
// str.resize(strl);
|
||
// ret = wchar_to_char(str, p, &strl);
|
||
// if (str.empty())
|
||
// {
|
||
// return SCANNER_ERR_DATA_DAMAGED;
|
||
// }
|
||
// dpi_type = atoi(str.c_str());
|
||
//}
|
||
return helper_->io_control(IO_CTRL_CODE_SET_AUTO_FALT, &dpi_type, &len);;
|
||
}
|
||
/* 重启设备 */
|
||
int test_reboot_device(void *data)
|
||
{
|
||
if (!data)
|
||
{
|
||
helper_->test_callback(set_test_name_.c_str(), ui_helper::TEST_EVENT_RESULT, (void*)L"设备重启中失败", false);
|
||
return -1;
|
||
}
|
||
wchar_t* p = (wchar_t*)data;
|
||
|
||
int i = _wtoi(p);
|
||
unsigned int len = sizeof(int);
|
||
int ret = helper_->io_control(IO_CTRL_CODE_SET_DEVS_REBOOT, &i, &len);
|
||
helper_->test_callback(set_test_name_.c_str(), ui_helper::TEST_EVENT_RESULT, (void*)L"设备重启中,请观察设备是否重启", true);
|
||
return ret;
|
||
}
|
||
/* 扫描图像彩色质量确认 */
|
||
int test_image_color_quality(void *data)
|
||
{
|
||
if (!data)
|
||
{
|
||
return SCANNER_ERR_DATA_DAMAGED;
|
||
}
|
||
wchar_t* p = (wchar_t*)data;
|
||
std::string str;
|
||
int ret = SCANNER_ERR_OK,
|
||
dpi = 0;
|
||
unsigned int len = sizeof(int);
|
||
size_t strl = 0;
|
||
ret = wchar_to_char(str, p, &strl);
|
||
if (ret == ERROR_INSUFFICIENT_BUFFER)
|
||
{
|
||
str.resize(strl);
|
||
ret = wchar_to_char(str, p, &strl);
|
||
if (str.empty())
|
||
{
|
||
return SCANNER_ERR_DATA_DAMAGED;
|
||
}
|
||
dpi = atoi(str.c_str());
|
||
}
|
||
if (dpi > 0)
|
||
{
|
||
ret = helper_->io_control(IO_CTRL_CODE_SET_DPI, &dpi, &len);
|
||
}
|
||
if (ret != SCANNER_ERR_OK)
|
||
{
|
||
return -1;
|
||
}
|
||
const char* color = OPTION_VALUE_YSMS_24WCS;
|
||
unsigned int colorlen = strlen(color);
|
||
helper_->io_control(IO_CTRL_CODE_SET_COLOR, (void*)color, &colorlen);
|
||
|
||
return helper_->io_control(IO_CTRL_CODE_GET_IMAGE, NULL, NULL);
|
||
}
|
||
/* 扫描图像灰度质量确认 */
|
||
int test_image_gray_quality(void* data)
|
||
{
|
||
if (!data)
|
||
{
|
||
return SCANNER_ERR_DATA_DAMAGED;
|
||
}
|
||
wchar_t* p = (wchar_t*)data;
|
||
std::string str;
|
||
int ret = SCANNER_ERR_OK,
|
||
dpi = 0;
|
||
unsigned int len = sizeof(int);
|
||
size_t strl = 0;
|
||
ret = wchar_to_char(str, p, &strl);
|
||
if (ret == ERROR_INSUFFICIENT_BUFFER)
|
||
{
|
||
str.resize(strl);
|
||
ret = wchar_to_char(str, p, &strl);
|
||
if (str.empty())
|
||
{
|
||
return SCANNER_ERR_DATA_DAMAGED;
|
||
}
|
||
dpi = atoi(str.c_str());
|
||
}
|
||
if (dpi > 0)
|
||
{
|
||
ret = helper_->io_control(IO_CTRL_CODE_SET_DPI, &dpi, &len);
|
||
}
|
||
if (ret != SCANNER_ERR_OK)
|
||
{
|
||
return -1;
|
||
}
|
||
const char* color = OPTION_VALUE_YSMS_256JHD;
|
||
unsigned int colorlen = strlen(color);
|
||
helper_->io_control(IO_CTRL_CODE_SET_COLOR, (void*)color, &colorlen);
|
||
return helper_->io_control(IO_CTRL_CODE_GET_IMAGE, NULL, NULL);
|
||
}
|
||
/* 获取自动计算畸变值 */
|
||
int test_get_auto_distortion(void *data)
|
||
{
|
||
if (!data )
|
||
{
|
||
return SCANNER_ERR_DATA_DAMAGED;
|
||
}
|
||
wchar_t* p = (wchar_t*)data;
|
||
std::string str;
|
||
|
||
int ret = SCANNER_ERR_OK,
|
||
dpi = 0;
|
||
SANE_Bool type = true;
|
||
unsigned int len = sizeof(SANE_Bool),
|
||
llen = sizeof(int);
|
||
size_t strl = 0;
|
||
ret = wchar_to_char(str, p, &strl);
|
||
if (ret == ERROR_INSUFFICIENT_BUFFER)
|
||
{
|
||
str.resize(strl);
|
||
ret = wchar_to_char(str, p, &strl);
|
||
if (str.empty())
|
||
{
|
||
return SCANNER_ERR_DATA_DAMAGED;
|
||
}
|
||
dpi = atoi(str.c_str());
|
||
}
|
||
|
||
ret = helper_->io_control(IO_CTRL_CODE_GET_PAPER_ON, &type, &llen);
|
||
if (!type)
|
||
{
|
||
helper_->test_callback(set_test_name_.c_str(), ui_helper::TEST_EVENT_RESULT, (void*)L"自动计算畸变值获取失败: 无纸", false);
|
||
return ret;
|
||
}
|
||
|
||
if (dpi > 0)
|
||
{
|
||
ret = helper_->io_control(IO_CTRL_CODE_SET_DPI, &dpi, &llen);
|
||
}
|
||
//先默认设置1
|
||
float distortion = 1.0;
|
||
|
||
ret = helper_->io_control(IO_CTRL_CODE_SET_DISTORTION_DEVS_CHECK_VAL, &distortion, &len);
|
||
|
||
ret = helper_->io_control(IO_CTRL_CODE_SET_DISTORTION_IMAGE, &type, &len);
|
||
if (ret != SCANNER_ERR_OK)
|
||
{
|
||
return ret;
|
||
}
|
||
int cnt = 0;
|
||
SANE_DISTORTION_VAL dis = { 0 };
|
||
while (ret == SCANNER_ERR_OK)
|
||
{
|
||
if (is_distortion_get_image)
|
||
{
|
||
ret = helper_->io_control(IO_CTRL_CODE_GET_PC_DISTORTION_CHECK_VAL, &dis, &llen);
|
||
break;
|
||
}
|
||
else if (cnt == 20)
|
||
break;
|
||
|
||
if (is_distortion_get_image_abnormal)
|
||
break;
|
||
|
||
Sleep(1000);
|
||
cnt++;
|
||
}
|
||
if (dis.h > 0 && dis.scaleXY < 10)
|
||
{
|
||
helper_->test_callback(set_test_name_.c_str(), ui_helper::TEST_EVENT_DISTORTION_VAL, (void *)&dis, true);
|
||
}
|
||
else
|
||
{
|
||
helper_->test_callback(set_test_name_.c_str(), ui_helper::TEST_EVENT_RESULT,(void*)L"自动计算畸变值获取失败", false);
|
||
}
|
||
return ret;
|
||
}
|
||
int test_set_auto_distortion(void* data)
|
||
{
|
||
if (!data)
|
||
{
|
||
return SCANNER_ERR_DATA_DAMAGED;
|
||
}
|
||
wchar_t* p = (wchar_t*)data;
|
||
std::string str;
|
||
|
||
int ret = SCANNER_ERR_OK,
|
||
dpi = 0;
|
||
unsigned int len = sizeof(int);
|
||
float distortion = 0.0;
|
||
size_t strl = 0;
|
||
|
||
ret = wchar_to_char(str, p, &strl);
|
||
if (ret == ERROR_INSUFFICIENT_BUFFER)
|
||
{
|
||
str.resize(strl);
|
||
ret = wchar_to_char(str, p, &strl);
|
||
if (str.empty())
|
||
{
|
||
return SCANNER_ERR_DATA_DAMAGED;
|
||
}
|
||
dpi = atoi(str.c_str());
|
||
}
|
||
if (dpi > 0)
|
||
{
|
||
ret = helper_->io_control(IO_CTRL_CODE_SET_DPI, &dpi, &len);
|
||
}
|
||
|
||
parameter* prt = helper_->get_user_input(ui_helper::DATA_FROM_USER, ui_helper::VAL_TYPE_FLOAT, set_test_name_.c_str(), L"请设置畸变值");
|
||
if (!prt)
|
||
{
|
||
helper_->test_callback(set_test_name_.c_str(), ui_helper::TEST_EVENT_RESULT, (void*)L"已退出畸变值设置", false);
|
||
return -1;
|
||
}
|
||
else
|
||
{
|
||
|
||
void * p = prt->get_data();
|
||
distortion = *(float*)p;
|
||
}
|
||
if (distortion == 0.0)
|
||
{
|
||
helper_->test_callback(set_test_name_.c_str(), ui_helper::TEST_EVENT_RESULT, (void *)L"已退出畸变值设置", false);
|
||
return -1;
|
||
}
|
||
float setdistortion = distortion;
|
||
float getdistortion = 0;
|
||
|
||
ret = helper_->io_control(IO_CTRL_CODE_SET_DISTORTION_DEVS_CHECK_VAL, &setdistortion, &len);
|
||
if (ret != SCANNER_ERR_OK)
|
||
{
|
||
return ret;
|
||
}
|
||
|
||
ret = helper_->io_control(IO_CTRL_CODE_GET_DISTORTION_DEVS_CHECK_VAL, &getdistortion, &len);
|
||
if (setdistortion == getdistortion)
|
||
{
|
||
helper_->test_callback(set_test_name_.c_str(), ui_helper::TEST_EVENT_RESULT, (void*)L"设置畸变值成功", true);
|
||
}
|
||
else
|
||
{
|
||
helper_->test_callback(set_test_name_.c_str(), ui_helper::TEST_EVENT_RESULT, (void*)L"设置畸变值失败", false);
|
||
}
|
||
|
||
return ret;
|
||
}
|
||
int test_confirm_auto_distortion(void *data)
|
||
{
|
||
if (!data )
|
||
{
|
||
return SCANNER_ERR_DATA_DAMAGED;
|
||
}
|
||
|
||
float distortion = 0;
|
||
unsigned int len = sizeof(int);
|
||
|
||
int ret = SCANNER_ERR_OK;
|
||
float value[3] = { 0 };
|
||
int dpi[3] = { 200, 300, 600 };
|
||
for (int i = 0; i < 3; i++)
|
||
{
|
||
ret = helper_->io_control(IO_CTRL_CODE_SET_DPI, &dpi[i], &len);
|
||
ret = helper_->io_control(IO_CTRL_CODE_GET_DISTORTION_DEVS_CHECK_VAL, &distortion, &len);
|
||
if (ret != SCANNER_ERR_OK)
|
||
break;
|
||
|
||
value[i] = distortion;
|
||
}
|
||
|
||
if (ret == SCANNER_ERR_OK)
|
||
{
|
||
|
||
helper_->test_callback(set_test_name_.c_str(), ui_helper::TEST_EVENT_RESULT, (void*)(float*)value, true);
|
||
}
|
||
else
|
||
{
|
||
helper_->test_callback(set_test_name_.c_str(), ui_helper::TEST_EVENT_RESULT,(void*)L"获取设备畸变值失败", false);
|
||
}
|
||
return ret;
|
||
}
|
||
/* 分纸强度检测 */
|
||
int test_paper_separation_strength(void *data)
|
||
{
|
||
//parameter* ptr = helper_->get_user_input(ui_helper::DATA_FROM_USER, ui_helper::VAL_TYPE_TIPS_VAL, NAME, (wchar_t*)&info_);
|
||
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
|
||
}
|
||
/* 机械走纸倾斜检测 */
|
||
int test_mech_paper_feeding_inclination(void *data)
|
||
{
|
||
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
|
||
}
|
||
/* 清除滚轴计数 */
|
||
int test_clear_roller_count(void *data)
|
||
{
|
||
SANE_Int roller_num = -1;
|
||
const wchar_t* info = NULL;
|
||
bool type = false;
|
||
unsigned int len = sizeof(SANE_Int);
|
||
int ret = helper_->io_control(IO_CTRL_CODE_SET_CLEAR_ROLLER_COUNT, NULL, NULL);
|
||
ret = helper_->io_control(IO_CTRL_CODE_GET_ROLLER_NUM, &roller_num, &len);
|
||
|
||
if ((roller_num == 0 && roller_num != -1))
|
||
{
|
||
type = true;
|
||
info = L"清除滚轴计数成功";
|
||
}
|
||
else
|
||
{
|
||
type = false;
|
||
info = L"清除滚轴计数失败";
|
||
}
|
||
helper_->test_callback(set_test_name_.c_str(), ui_helper::TEST_EVENT_RESULT, (void*)info, type);
|
||
|
||
return ret;
|
||
}
|
||
/* 清除历史计数 */
|
||
int test_clear_history_count(void* data)
|
||
{
|
||
SANE_Int num = -1;
|
||
const wchar_t* info = NULL;
|
||
bool type = false;
|
||
unsigned int len = sizeof(SANE_Int);
|
||
int ret = helper_->io_control(IO_CTRL_CODE_SET_CLEAR_HISTORY_COUNT, NULL, NULL);
|
||
if (ret != SCANNER_ERR_OK)
|
||
{
|
||
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
|
||
}
|
||
ret = helper_->io_control(IO_CTRL_CODE_GET_HISTORY_SCAN_NUM, &num, &len);
|
||
|
||
if ((num == 0 && num != -1))
|
||
{
|
||
type = true;
|
||
info = L"清除历史计数成功";
|
||
}
|
||
else
|
||
{
|
||
type = false;
|
||
info = L"清除历史计数失败";
|
||
}
|
||
helper_->test_callback(set_test_name_.c_str(), ui_helper::TEST_EVENT_RESULT, (void*)info, type);
|
||
|
||
return ret;
|
||
}
|
||
/* 单张测试 */
|
||
int test_single_page_test(void* data)
|
||
{
|
||
return helper_->io_control(IO_CTRL_CODE_TEST_SINGLE, NULL, NULL);
|
||
}
|
||
/*压力测试彩色_200dpi*/
|
||
int test_pressuer_test_rgb_200dpi(void* data)
|
||
{
|
||
const char* color = OPTION_VALUE_YSMS_24WCS;
|
||
int dpi = 200;
|
||
unsigned int len = strlen(color);
|
||
helper_->io_control(IO_CTRL_CODE_SET_COLOR, (void *)color, &len);
|
||
helper_->io_control(IO_CTRL_CODE_SET_DPI, (void*)&dpi, &len);
|
||
return helper_->io_control(IO_CTRL_CODE_GET_IMAGE, NULL, NULL);
|
||
}
|
||
/*压力测试灰色_200dpi*/
|
||
int test_pressuer_test_gray_200dpi(void* data)
|
||
{
|
||
const char* color = OPTION_VALUE_YSMS_256JHD;
|
||
int dpi = 200;
|
||
unsigned int len = strlen(color);
|
||
helper_->io_control(IO_CTRL_CODE_SET_COLOR, (void*)color, &len);
|
||
helper_->io_control(IO_CTRL_CODE_SET_DPI, (void*)&dpi, &len);
|
||
return helper_->io_control(IO_CTRL_CODE_GET_IMAGE, NULL, NULL);
|
||
}
|
||
/*压力测试彩色_300dpi*/
|
||
int test_pressuer_test_rgb_300dpi(void* data)
|
||
{
|
||
const char* color = OPTION_VALUE_YSMS_24WCS;
|
||
int dpi = 300;
|
||
unsigned int len = strlen(color);
|
||
helper_->io_control(IO_CTRL_CODE_SET_COLOR, (void*)color, &len);
|
||
helper_->io_control(IO_CTRL_CODE_SET_DPI, (void*)&dpi, &len);
|
||
return helper_->io_control(IO_CTRL_CODE_GET_IMAGE, NULL, NULL);
|
||
}
|
||
/*压力测试灰色_300dpi*/
|
||
int test_pressuer_test_gray_300dpi(void* data)
|
||
{
|
||
const char* color = OPTION_VALUE_YSMS_256JHD;
|
||
int dpi = 300;
|
||
unsigned int len = strlen(color);
|
||
helper_->io_control(IO_CTRL_CODE_SET_COLOR, (void*)color, &len);
|
||
helper_->io_control(IO_CTRL_CODE_SET_DPI, (void*)&dpi, &len);
|
||
return helper_->io_control(IO_CTRL_CODE_GET_IMAGE, NULL, NULL);
|
||
}
|
||
/*压力测试彩色_600dpi*/
|
||
int test_pressuer_test_rgb_600dpi(void* data)
|
||
{
|
||
const char* color = OPTION_VALUE_YSMS_24WCS;
|
||
int dpi = 600;
|
||
unsigned int len = strlen(color);
|
||
helper_->io_control(IO_CTRL_CODE_SET_COLOR, (void*)color, &len);
|
||
helper_->io_control(IO_CTRL_CODE_SET_DPI, (void*)&dpi, &len);
|
||
return helper_->io_control(IO_CTRL_CODE_GET_IMAGE, NULL, NULL);
|
||
}
|
||
/*压力测试灰色_600dpi*/
|
||
int test_pressuer_test_gray_600dpi(void* data)
|
||
{
|
||
const char* color = OPTION_VALUE_YSMS_256JHD;
|
||
int dpi = 600;
|
||
unsigned int len = strlen(color);
|
||
helper_->io_control(IO_CTRL_CODE_SET_COLOR, (void*)color, &len);
|
||
helper_->io_control(IO_CTRL_CODE_SET_DPI, (void*)&dpi, &len);
|
||
return helper_->io_control(IO_CTRL_CODE_GET_IMAGE, NULL, NULL);
|
||
}
|
||
/*获取设备配置*/
|
||
int test_get_device_config(void* data)
|
||
{
|
||
unsigned int len = sizeof(int);
|
||
unsigned int getlen = 0;
|
||
|
||
int get_vidpid = 0,
|
||
ret = SCANNER_ERR_OK;
|
||
|
||
if (ret == SCANNER_ERR_OK)
|
||
{
|
||
ret = helper_->io_control(IO_CTRL_CODE_GET_VIDPID, &get_vidpid, &len);
|
||
helper_->test_callback(set_test_name_.c_str(), ui_helper::TEST_EVEB_GET_DEVICE_CONFIG_VIDPID, &get_vidpid, true);
|
||
}
|
||
|
||
std::string set_sn, get_sn;
|
||
std::wstring wstr;
|
||
size_t l = 0;
|
||
ret = helper_->io_control(IO_CTRL_CODE_GET_SERIAL, &get_sn[0], &getlen);
|
||
if (ret == SANE_STATUS_NO_MEM)
|
||
{
|
||
ret = helper_->io_control(IO_CTRL_CODE_GET_SERIAL, &get_sn[0], &getlen);
|
||
if (ret != SCANNER_ERR_OK)
|
||
{
|
||
return ret;
|
||
}
|
||
ret = str_to_wchar(get_sn.c_str(), (wchar_t*)wstr.c_str(), &l);
|
||
if (ret == ERROR_INSUFFICIENT_BUFFER)
|
||
{
|
||
wstr.resize(l);
|
||
ret = str_to_wchar(get_sn.c_str(), (wchar_t*)wstr.c_str(), &l);
|
||
}
|
||
if (wstr.empty())
|
||
{
|
||
helper_->test_callback(set_test_name_.c_str(), ui_helper::TEST_EVEB_GET_DEVICE_CONFIG_SN, (void*)L"获取序列号失败", false);
|
||
return ret;
|
||
}
|
||
helper_->test_callback(set_test_name_.c_str(), ui_helper::TEST_EVEB_GET_DEVICE_CONFIG_SN, (void *)wstr.c_str(), true);
|
||
}
|
||
|
||
int gettime = 0;
|
||
unsigned int timelen = sizeof(int*);
|
||
|
||
ret = helper_->io_control(IO_CTRL_CODE_GET_POWER_LEVEL, &gettime, &timelen);
|
||
|
||
if (gettime == INT_MAX || gettime == -1)
|
||
gettime = 0;
|
||
else
|
||
gettime /= 60;
|
||
helper_->test_callback(set_test_name_.c_str(), ui_helper::TEST_EVEB_GET_DEVICE_CONFIG_SLEEPTIME, (void*)&gettime, true);
|
||
|
||
|
||
std::string fw(get_firmware_version());
|
||
size_t fwlen= 0;
|
||
wstr.clear();
|
||
ret = str_to_wchar(fw.c_str(), (wchar_t*)wstr.c_str(), &fwlen);
|
||
if (ret == ERROR_INSUFFICIENT_BUFFER)
|
||
{
|
||
wstr.resize(fwlen);
|
||
ret = str_to_wchar(fw.c_str(), (wchar_t*)wstr.c_str(), &fwlen);
|
||
}
|
||
if (wstr.empty())
|
||
{
|
||
helper_->test_callback(set_test_name_.c_str(), ui_helper::TEST_EVEB_GET_DEVICE_CONFIG_FW, (void*)L"获取固件号失败", false);
|
||
return ret;
|
||
}
|
||
helper_->test_callback(set_test_name_.c_str(), ui_helper::TEST_EVEB_GET_DEVICE_CONFIG_FW, (void*)wstr.c_str(), true);
|
||
|
||
|
||
std::string fvv = fw.substr(0, 4);
|
||
if (fvv != "G439" && fvv != "G239" && fvv != "G139")
|
||
{
|
||
fvv = fw.substr(0, 2);
|
||
}
|
||
|
||
const wchar_t G139[6] = { 60,70,80,90,110 };
|
||
const wchar_t G239[6] = { 90,100,110,120,130 };
|
||
const wchar_t G300[6] = { 40,50,60,70 };
|
||
const wchar_t G400[6] = { 40,50,60,70,80 };
|
||
SANE_Int num = 0;
|
||
unsigned int lensp = sizeof(SANE_Int);
|
||
ret = helper_->io_control(IO_CTRL_CODE_GET_SPEED_MODE, &num, &lensp);
|
||
int save_num = 0;
|
||
|
||
if (fvv == "G3" || fvv == "G4" && num > 0 && num < 6)
|
||
{
|
||
for (size_t i = 0; i < sizeof(G400) / sizeof(G400[0]); i++)//3288设置速度模式为1 2 3 4 5
|
||
{
|
||
if ((num - 1) == i)
|
||
{
|
||
save_num = G400[i];
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
else
|
||
save_num = num;
|
||
|
||
helper_->test_callback(set_test_name_.c_str(), ui_helper::TEST_EVEB_GET_DEVICE_CONFIG_SP, (void*)&save_num, true);
|
||
|
||
|
||
std::string devs_model;
|
||
unsigned int devs_len = 0;
|
||
l = 0;
|
||
wstr.clear();
|
||
|
||
ret = helper_->io_control(IO_CTRL_CODE_GET_DEVS_MODEL, &devs_model[0], &devs_len);
|
||
if (ret == SANE_STATUS_NO_MEM)
|
||
{
|
||
devs_model.resize(devs_len);
|
||
ret = helper_->io_control(IO_CTRL_CODE_GET_DEVS_MODEL, &devs_model[0], &devs_len);
|
||
}
|
||
|
||
ret = str_to_wchar(devs_model.c_str(), (wchar_t*)wstr.c_str(), &l);
|
||
if (ret == ERROR_INSUFFICIENT_BUFFER)
|
||
{
|
||
wstr.resize(l);
|
||
ret = str_to_wchar(devs_model.c_str(), (wchar_t*)wstr.c_str(), &l);
|
||
}
|
||
|
||
helper_->test_callback(set_test_name_.c_str(), ui_helper::TEST_EVEB_GET_DEVICE_CONFIG_DEVS_MODEL, wstr.empty() ? (void*)L"获取设备类型失败" : (void*)wstr.c_str(), wstr.empty() ? false : true);
|
||
|
||
helper_->test_callback(set_test_name_.c_str(), ui_helper::TEST_EVENT_RESULT, (void*)(L"配置获取完成"), true);
|
||
return ret;
|
||
}
|
||
/*获取设备内存和硬盘容量大小*/
|
||
int test_get_device_cpu_disk(void* data)
|
||
{
|
||
int cpu = 0;
|
||
unsigned len = 0;
|
||
int ret = helper_->io_control(IO_CTRL_CODE_GET_DEVS_CPU, &cpu, &len);
|
||
|
||
if (0 != cpu)
|
||
{
|
||
helper_->test_callback(set_test_name_.c_str(), ui_helper::TEST_EVEB_GET_DEVICE_DEVS_CPU, (void*)&cpu, true);
|
||
}
|
||
|
||
int disk = 0;
|
||
unsigned len2 = 0;
|
||
ret = helper_->io_control(IO_CTRL_CODE_GET_DEVS_DISK, &disk, &len2);
|
||
|
||
if (0 != disk)
|
||
{
|
||
helper_->test_callback(set_test_name_.c_str(), ui_helper::TEST_EVEB_GET_DEVICE_DEVS_DISK, (void*)&disk, true);
|
||
}
|
||
|
||
if (0 == cpu || 0 == disk)
|
||
{
|
||
helper_->test_callback(set_test_name_.c_str(), ui_helper::TEST_EVENT_RESULT, nullptr, false);
|
||
return -1;
|
||
}
|
||
else
|
||
{
|
||
helper_->test_callback(set_test_name_.c_str(), ui_helper::TEST_EVENT_RESULT, nullptr, true);
|
||
return -1;
|
||
}
|
||
|
||
return ret;
|
||
}
|
||
/* 备份设备配置 */
|
||
int test_backup(void *data)
|
||
{
|
||
int val = 0;
|
||
unsigned int len = 0;
|
||
int ret = helper_->io_control(IO_CTRL_CODE_SET_BACKUP, &val, &len);
|
||
if (SCANNER_ERR_OK == ret)
|
||
{
|
||
helper_->test_callback(set_test_name_.c_str(), ui_helper::TEST_EVENT_RESULT, (void*)(L"备份配置完成"), true);
|
||
}
|
||
else
|
||
{
|
||
helper_->test_callback(set_test_name_.c_str(), ui_helper::TEST_EVENT_RESULT, (void*)(L"备份配置失败"), false);
|
||
return -1;
|
||
}
|
||
return ret;
|
||
}
|
||
/* 关机 */
|
||
int test_shutdown(void *data)
|
||
{
|
||
int val = 0;
|
||
unsigned int len = 0;
|
||
int ret = helper_->io_control(IO_CTRL_CODE_SET_DEVS_SHUTDOWN, &val, &len);
|
||
if (SCANNER_ERR_OK != ret)
|
||
{
|
||
if (SCANNER_ERR_DEVICE_NOT_SUPPORT == ret)
|
||
{
|
||
helper_->test_callback(set_test_name_.c_str(), ui_helper::TEST_EVENT_RESULT, (void*)(L"设备固件不支持"), false);
|
||
}
|
||
else
|
||
{
|
||
helper_->test_callback(set_test_name_.c_str(), ui_helper::TEST_EVENT_RESULT, (void*)(L"关机失败"), false);
|
||
}
|
||
|
||
return -1;
|
||
}
|
||
return ret;
|
||
}
|
||
/* 设置固件语言模式 */
|
||
int test_set_firmware_language(void* data)
|
||
{
|
||
int mode = 0;
|
||
void* get_data = nullptr;
|
||
|
||
parameter* ptr = helper_->get_user_input(ui_helper::DATA_FROM_USER, ui_helper::VAL_TYPE_TIPS_VAL, set_test_name_.c_str(), L"请设置固件语言模式");
|
||
if (ptr)
|
||
{
|
||
get_data = ptr->get_data();
|
||
if (!get_data)
|
||
{
|
||
helper_->test_callback(set_test_name_.c_str(), ui_helper::TEST_EVENT_RESULT, (void*)L"已退出设置固件语言模式流程", false);
|
||
return -1;
|
||
}
|
||
mode = *((int*)get_data);
|
||
}
|
||
else
|
||
{
|
||
helper_->test_callback(set_test_name_.c_str(), ui_helper::TEST_EVENT_RESULT, (void*)L"已退出设置固件语言模式流程", false);
|
||
return -1;
|
||
}
|
||
|
||
int ret = helper_->io_control(IO_CTRL_CODE_SET_FIRMWARE_LANGUAGE, &mode, NULL);
|
||
if (ret != SCANNER_ERR_OK)
|
||
{
|
||
helper_->test_callback(set_test_name_.c_str(), ui_helper::TEST_EVENT_RESULT, (void*)L"不支持设置固件语言模式", false);
|
||
return -1;
|
||
}
|
||
else
|
||
{
|
||
helper_->test_callback(set_test_name_.c_str(), ui_helper::TEST_EVENT_RESULT, (void*)L"设置固件语言模式成功,设备即将重启", true);
|
||
|
||
int val = 0;
|
||
unsigned int len = sizeof(int);
|
||
int ret = helper_->io_control(IO_CTRL_CODE_SET_DEVS_REBOOT, &val, &len);
|
||
}
|
||
|
||
return ret;
|
||
}
|
||
/*设置设备型号*/
|
||
int test_set_devs_model(void* data)
|
||
{
|
||
if (!data)
|
||
{
|
||
return SCANNER_ERR_NO_DATA;
|
||
}
|
||
wchar_t* sc = (wchar_t*)data;
|
||
std::string str;
|
||
size_t len = 0;
|
||
int ret =wchar_to_char(str, sc, &len);
|
||
if (ret == ERROR_INSUFFICIENT_BUFFER)
|
||
{
|
||
str.resize(len);
|
||
ret = wchar_to_char(str, sc, &len);
|
||
}
|
||
if (str.empty())
|
||
{
|
||
helper_->test_callback(set_test_name_.c_str(), ui_helper::TEST_EVENT_MANUAL_CONFIRMATION, (void*)L"设置设备类型失败", false);
|
||
|
||
return -1;
|
||
}
|
||
unsigned int l = str.size();
|
||
ret = helper_->io_control(IO_CTRL_CODE_SET_DEVS_MODEL, &str[0], &l);
|
||
if (ret != SCANNER_ERR_OK)
|
||
return ret;
|
||
|
||
helper_->test_callback(set_test_name_.c_str(), ui_helper::TEST_EVENT_MANUAL_CONFIRMATION, (void*)L"设置设备类型成功", true);
|
||
return ret;
|
||
}
|
||
int public_test_image_correct(void* data, int dpi, bool isColor)
|
||
{
|
||
if (!data)
|
||
{
|
||
return SCANNER_ERR_NO_DATA;
|
||
}
|
||
wchar_t* sc = (wchar_t*)data;
|
||
std::string str;
|
||
size_t len = 0;
|
||
int ret = wchar_to_char(str, sc, &len);
|
||
if (ret == ERROR_INSUFFICIENT_BUFFER)
|
||
{
|
||
str.resize(len);
|
||
ret = wchar_to_char(str, sc, &len);
|
||
}
|
||
if (str.empty())
|
||
{
|
||
helper_->test_callback(set_test_name_.c_str(), ui_helper::TEST_EVENT_RESULT, (void*)L"校正失败", false);
|
||
|
||
return -1;
|
||
}
|
||
|
||
unsigned int l = str.size();
|
||
ret = helper_->io_control(IO_CTRL_CODE_SET_DPI, (void*)&dpi, &l);
|
||
const char* color = isColor ? OPTION_VALUE_YSMS_24WCS : OPTION_VALUE_YSMS_256JHD;
|
||
unsigned int colorlen = strlen(color);
|
||
ret = helper_->io_control(IO_CTRL_CODE_SET_COLOR, (void*)color, &colorlen);
|
||
|
||
SANE_Bool isOriImg = true;
|
||
ret = ret = helper_->io_control(IO_CTRL_CODE_ORIGINAL_IMAGE, (void*)&isOriImg, &l);
|
||
|
||
ret = helper_->io_control(IO_CTRL_CODE_SET_CORRECT_IMAGE, &str[0], &l);
|
||
ret = helper_->io_control(IO_CTRL_CODE_GET_IMAGE, NULL, NULL);
|
||
|
||
if (ret != SCANNER_ERR_OK)
|
||
return ret;
|
||
|
||
//helper_->test_callback(set_test_name_.c_str(), ui_helper::TEST_EVENT_RESULT, (void*)L"校正完成", true);
|
||
return ret;
|
||
}
|
||
int test_image_correct_rgb_200dpi(void* data)
|
||
{
|
||
return public_test_image_correct(data, 200, true);
|
||
}
|
||
int test_image_correct_gray_200dpi(void* data)
|
||
{
|
||
return public_test_image_correct(data, 200, false);
|
||
}
|
||
int test_image_correct_rgb_300dpi(void* data)
|
||
{
|
||
return public_test_image_correct(data, 300, true);
|
||
}
|
||
int test_image_correct_gray_300dpi(void* data)
|
||
{
|
||
return public_test_image_correct(data, 300, false);
|
||
}
|
||
int test_image_correct_rgb_600dpi(void* data)
|
||
{
|
||
return public_test_image_correct(data, 600, true);
|
||
}
|
||
int test_image_correct_gray_600dpi(void* data)
|
||
{
|
||
return public_test_image_correct(data, 600, false);
|
||
}
|
||
private:
|
||
|
||
};
|
||
|
||
|
||
//test
|
||
static std::string jsontext1("{\"1\":{\"NAME\":\"test-8\",\"ver\":1}}");
|
||
bool have_img_ = false;
|
||
|
||
DECL_API(int) func_test_init(void* init)
|
||
{
|
||
return 0;
|
||
}
|
||
DECL_API(int) func_test_get_list(wchar_t* buf, size_t* len)
|
||
{
|
||
return str_to_wchar(jsontext1, buf, len);
|
||
}
|
||
DECL_API(int) func_test_go(const wchar_t* NAME, const wchar_t* oper, ui_helper* helper)
|
||
{
|
||
if (!NAME || !oper || !helper)
|
||
{
|
||
return -1;
|
||
}
|
||
//helper->add_ref(void *data);
|
||
|
||
is_distortion_get_image = false;
|
||
is_distortion_get_image_abnormal = false;
|
||
|
||
int ret = 0;
|
||
SANE_Bool type = false;
|
||
unsigned int len = sizeof(SANE_Bool);
|
||
test ts(helper);
|
||
|
||
//ret = helper->io_control(IO_CTRL_CODE_RESTORE_SETTINGS, NULL, NULL);//结束恢复默认
|
||
return ts.set_test(NAME, oper);
|
||
}
|
||
DECL_API(int) func_test_uninit(void* uninit)
|
||
{
|
||
return 0;
|
||
}
|