lmh188
/
g1g2hardwarechecker
mirror of http://192.168.1.51:8099/pm/g1g2hardwarechecker.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
g1g2hardwarechecker/Scanner/G1G2Scanner.cpp

757 lines
18 KiB
C++
Raw Permalink Normal View History

first init
2024-01-08 10:06:47 +00:00
#include "G1G2Scanner.h"
#include <3rdparty/comm/hgscanner_error.h>
#include "json.hpp"
#include <algorithm>
#include <StopWatch.h>
#include <iostream>
#include <fstream>
#include <filesystem>
#include "LineContinuityAndRGBDetection.h"
#include "applog.h"
#include "stringex.h"
using json = nlohmann::json;
using namespace std;
static const std::string loggername = "G1G2SCANNER";
#define USB_REQ_GET_FPGA_REGS 0x40
#define USB_REQ_SET_FPGA_REGS 0x41
#define USB_REQ_GET_MOTOR_REGS 0x42
#define USB_REQ_SET_MOTOR_REGS 0x43
#define USB_REQ_GET_DEV_STATUS 0x60
#define USB_REQ_GET_DEV_CONFIGURATION 0x61
#define USB_REQ_SET_DEV_CONFIGURATION 0x62
#define USB_REQ_GET_DEV_REGS 0x63
#define USB_REQ_SET_DEV_REGS 0x64
#define GET_BIT(x, bit) ((x & (1 << bit)) >> bit) /* <20><>ȡ<EFBFBD><C8A1>bitλ */
#define THIS_MODULE_NAME "G1G2ScannerChecker.exe"
void json2struct(json& j, ScannerSysInfo& info)
{
j["CPU"].get_to(info.CPU);
j["Systype"].get_to(info.Systype);
j["Screentype"].get_to(info.Screentype);
j["MtBoardVersion"].get_to(info.MtBoardVersion);
j["MtType"].get_to(info.MtType);
j["FPGAVersion"].get_to(info.FPGAVersion);
j["Cistype"].get_to(info.Cistype);
j["MaxRes"].get_to(info.ResSup);
j["MemTotal"].get_to(info.MemTotal);
j["DiskTotal"].get_to(info.DiskTotal);
j["DiskUsed"].get_to(info.DiskUsed);
j["KernelVersion"].get_to(info.KernelVersion);
j["Have_EthernPort"].get_to(info.Have_EthernPort);
j["ServiceVersion"].get_to(info.ServiceVersion);
j["UsbProtocol"].get_to(info.UsbProtocol);
}
static std::string u2a(const wchar_t* u, UINT cp = CP_ACP)
{
std::string a("");
if (u)
{
char stack[256] = { 0 }, * ansi = NULL;
int len = 0;
len = WideCharToMultiByte(cp, 0, u, lstrlenW(u), NULL, 0, NULL, NULL);
ansi = new char[len + 2];
len = WideCharToMultiByte(cp, 0, u, lstrlenW(u), ansi, len, NULL, NULL);
ansi[len--] = 0;
a = ansi;
delete[] ansi;
}
return a;
}
std::string get_moudle_path()
{
wchar_t path[MAX_PATH] = { 0 };
GetModuleFileNameW(GetModuleHandleA(THIS_MODULE_NAME), path, _countof(path) - 1);
return u2a(path, CP_UTF8);
}
G1G2Scanner::G1G2Scanner(usb_io* usb) : m_bwork(false),
m_online(false)
{
LOG_INITX();
m_usb = usb;
if (m_usb)
{
m_usb->add_ref();
auto status = m_usb->last_error();
m_online = status == SCANNER_ERR_OK;
}
//LOG_INFO("Init Thread");
init_work_thread();
//LOG_INFO("Init Thread Done");
}
G1G2Scanner::~G1G2Scanner()
{
LOG_INFO("disctor G1G2Scanner,start join m_work_thread");
if (m_work_thread.get() && m_work_thread->joinable())
{
m_bwork = false;
m_work_thread->join();
}
//LOG_INFO("disctor G1G2Scanner,start release usb");
if (m_usb)
{
m_usb->close();
m_usb->release();
m_usb = NULL;
}
//LOG_INFO("disctor G1G2Scanner,start release proc thread");
if (m_imgprocthread.get() && m_imgprocthread->joinable())
{
m_bproc = false;
imgs.ShutDown();
m_paths.ShutDown();
m_imgprocthread->join();
}
//LOG_INFO("disctor G1G2Scanner,start release msgproc thread");
if (m_msgProcThread.get() && m_msgProcThread->joinable())
{
m_bprocmsg = false;
m_msg.ShutDown();
m_msgProcThread->join();
}
LOG_INFO("disctor G1G2Scanner exit");
}
void G1G2Scanner::USBDisconnect()
{
lock_guard<mutex> m_mtx(m_mtx_usb);
m_online = false;
m_usb->on_disconnected();
}
void G1G2Scanner::Reboot(bool b_loader)
{
lock_guard<mutex> m_mtx(m_mtx_usb);
if (m_usb && m_online)
{
write_register(SR_REBOOT, b_loader ? 1 : 0);
}
}
void G1G2Scanner::PowerOFF()
{
lock_guard<mutex> m_mtx(m_mtx_usb);
if (m_usb && m_online)
{
write_register(SR_POWEROFF, 0);
}
}
void G1G2Scanner::GetFile(std::string path, std::string& content)
{
lock_guard<mutex> m_mtx(m_mtx_usb);
if (path.empty())
return;
if (m_usb && m_online)
{
write_register(SR_SET_JSON_PATH, path.length());
int len = path.length();
m_usb->write_bulk((void*)&path[0], &len);
int size = 0;
if (SCANNER_ERR_OK == read_register(SR_GET_JSON_SIZE, &size))
{
content.resize(size);
write_register(SR_GET_JSON, size);
m_usb->read_bulk((void*)&content[0], &size);
}
}
}
void G1G2Scanner::GetIOStatus(int type)
{
}
int G1G2Scanner::RecordFinalResult(std::string res)
{
std::string recordpath = "/usr/local/huago/boardtest.json";
write_file(recordpath, res);
return 0;
}
int G1G2Scanner::CheckLEDDisplay(std::string display)
{
lock_guard<mutex> m_mtx(m_mtx_usb);
if (m_usb && m_online)
{
int val = 0;
return write_register(SR_TESTDISPLAY, val);
}
return 0;
}
int G1G2Scanner::Flat(unsigned int mode)
{
lock_guard<mutex> m_mtx(m_mtx_usb);
int color = mode;
if (m_usb && m_online)
{
return write_register(SR_TESTBOARD, color);
}
return SCANNER_ERR_DEVICE_UNKNOWN_STATUS;
}
void G1G2Scanner::Snap(unsigned int mode, unsigned int count)
{
lock_guard<mutex> m_mtx(m_mtx_usb);
int color = mode;
if (m_usb && m_online)
{
write_register(SC_START, 0);
}
}
void G1G2Scanner::SetScannerCallback(scanner_call_handler callback, void* user)
{
m_callback = callback;
m_user = user;
}
int G1G2Scanner::RecordTestInfo(std::string info)
{
std::string bd_save_path = "/usr/local/huagao/";
return 0;
}
bool G1G2Scanner::CheckSwitchs(int idx0, int idx1, int idx2, int idx3)
{
lock_guard<mutex> m_mtx(m_mtx_usb);
bool ret = true;
if (m_usb && m_online)
{
int val = 0;
int ret_code = read_register(SR_GET_DAIL_CODE, &val);
if (ret_code == SCANNER_ERR_OK)
{
HG_Dail_Struct dst_val;
dst_val.value = 0;
dst_val.dails.in_voltage0 = idx0;
dst_val.dails.in_voltage2 = idx1;
dst_val.dails.in_voltage3 = idx2;
dst_val.dails.in_voltage4 = idx3;
std::string notify_info;
{
if (val != (int)dst_val.value)
{
ret = false;
dst_val.value = val;
}
for (size_t i = 0; i < 4; i++)
{
std::string info = " <20><><EFBFBD><EFBFBD>" + std::to_string(i);
int va = GET_BIT(val, i);
info += (va == 1 ? ": ON \r\n " : ": OFF \r\n");
notify_info += info;
}
notify_info += (ret ? "<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Զ<EFBFBD>У<EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ŀ<EFBFBD><EFBFBD>һ<EFBFBD><EFBFBD>,<2C><><EFBFBD><EFBFBD>ͨ<EFBFBD><CDA8>\r\n" : "<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Զ<EFBFBD>У<EFBFBD><EFBFBD>ʧ<EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ŀ<EFBFBD>겻һ<EFBFBD>£<EFBFBD><EFBFBD><EFBFBD><EFBFBD>Բ<EFBFBD>ͨ<EFBFBD><EFBFBD>\r\n");
}
m_msg.Put({ TASK_ID_CHECK_HW_CAPACITY,DAT_STRING ,notify_info }, 0);
}
}
return ret;
}
bool G1G2Scanner::CheckCapacity(int dst_mem, int dst_disk)
{
bool ret_code = false;
auto ret = read_file("/usr/local/huago/sysinfo.json");
json j = json::parse(ret);
ScannerSysInfo sysinfo;
json2struct(j, sysinfo);
if (sysinfo.MemTotal >= dst_mem && sysinfo.DiskTotal >= dst_disk)
{
ret_code = true;
}
std::string notify_info = "<EFBFBD>ڴ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>: " + std::to_string(sysinfo.MemTotal / 1024.0 / 1024.0 / 1024.0) + " GB" + " <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>: " + std::to_string(sysinfo.DiskTotal / 1024.0 / 1024.0) + "GB \r\n" + (ret_code ? " У<><D0A3>ͨ<EFBFBD><CDA8>\r\n <20><><EFBFBD>Խ<EFBFBD><D4BD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Զ<EFBFBD><D4B6><EFBFBD><EFBFBD><EFBFBD>\r\n" : " У<>鲻ͨ<E9B2BB><CDA8>\r\n");
m_msg.Put({ TASK_ID_CHECK_HW_CAPACITY,DAT_STRING ,notify_info }, 0);
return ret_code;
}
void G1G2Scanner::init_work_thread()
{
if (m_work_thread.get() && m_work_thread->joinable())
{
m_bwork = false;
m_work_thread->join();
}
m_bwork = true;
m_work_thread.reset(new std::thread(&G1G2Scanner::workrun, this));
if (m_imgprocthread.get() && m_imgprocthread->joinable())
{
m_bproc = false;
m_paths.ShutDown();
m_imgprocthread->join();
}
m_bproc = true;
m_imgprocthread.reset(new std::thread(&G1G2Scanner::proc, this, 0));
if (m_msgProcThread.get() && m_msgProcThread->joinable())
{
m_bprocmsg = false;
m_msg.ShutDown();
m_msgProcThread->join();
}
m_bprocmsg = true;
m_msgProcThread.reset(new std::thread(&G1G2Scanner::procmsg, this));
}
void G1G2Scanner::workrun()
{
int ret = SCANNER_ERR_OK;
while (m_bwork)
{
unsigned char int_buffer[64];
std::string s_info;
memset(int_buffer, 0, sizeof(int_buffer));
{
lock_guard<mutex> m_mtx(m_mtx_usb);
int sz = sizeof(int_buffer);
ret = m_usb->read_interrupt(int_buffer, &sz);
}
if (ret == SCANNER_ERR_TIMEOUT)
{
std::this_thread::sleep_for(std::chrono::milliseconds(5));
continue;
}
else if (ret != SCANNER_ERR_OK)
{
cout << "read_interrupt error ret = " << (ret) << endl;
break;
}
else
{
if (sizeof(int_buffer) == 64)
{
HGEIntInfo* info = (HGEIntInfo*)int_buffer;
switch (info->From)
{
case HGType::MtBoard:
//if(info->Code==)
break;
case HGType::IMG:
{
if (is_running() && im_dev_count() > 0)
xfer_image();
}
break;
case HGType::STOPSCAN:
break;
case HGType::AutoCorrect:
if (info->Img_Index != 0)
{
s_info.resize(info->Img_Index);
int len = s_info.length();
m_usb->read_bulk(&s_info[0], &len);
m_msg.Put({ TASK_ID_CHECK_IMGS, DAT_FLATINFO ,s_info }, 0);
}
if (info->Code == 4)//flat done
{
s_info = "У<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> \r\n";
m_msg.Put({ TASK_ID_CHECK_IMGS,DAT_FLATINFO ,s_info }, 0);
}
break;
case HGType::FPGA:
{
if (info->Code == 0x80)
{
while (get_imgproc_done())
{
if (!m_bwork)
return;
this_thread::sleep_for(chrono::microseconds(30));
}
while (im_dev_count())
{
if (!m_bwork)
return;
xfer_image();
}
}
update_statue(info);
}
break;
case HGType::V4L2:
break;
case HGType::TESTBOARD:
{
if (info->Code == 0x10)
{
s_info = "<EFBFBD><EFBFBD><EFBFBD><EFBFBD>̨<EFBFBD><EFBFBD>λ<EFBFBD><EFBFBD><EFBFBD><EFBFBD>\r\n";
m_msg.Put({ TASK_ID_CHECK_IMGS,DAT_STRING ,s_info }, 0);
}
else if (info->Code == 0x20)
{
s_info = "<EFBFBD><EFBFBD><EFBFBD><EFBFBD>Һ<EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʾ<EFBFBD><EFBFBD>... \r\n";
m_msg.Put({ TASK_ID_CHECK_IMGS, DAT_STRING ,s_info }, 0);
}
else if (info->Code == 0x30)
{
s_info = "<EFBFBD>弶<EFBFBD>Ѹ<EFBFBD><EFBFBD><EFBFBD>Һ<EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʾ...\r\n <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Һ<EFBFBD><D2BA><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʾ<EFBFBD><CABE><EFBFBD><EFBFBD><EFBFBD>Ƿ<EFBFBD><C7B7><EFBFBD><EFBFBD><EFBFBD>\r\n";
m_msg.Put({ TASK_ID_CHECK_IMGS, DAT_STRING ,s_info }, 0);
}
}
break;
default:
break;
}
}
}
}
}
int G1G2Scanner::read_register(int addr, int* val)
{
int l = sizeof(*val);
int ret = m_usb->control_io(0x0c0, USB_REQ_GET_DEV_REGS, addr, 0, val, &l);
return ret;
}
int G1G2Scanner::write_register(int addr, int val)
{
int l = sizeof(val);
int ret = m_usb->control_io(0x040, USB_REQ_SET_DEV_REGS, addr, 0, &val, &l);
return ret;
}
std::string G1G2Scanner::read_file(std::string path)
{
lock_guard<mutex> m_mtx(m_mtx_usb);
if (m_usb && m_online)
{
int l = path.size();
auto ret_code = write_register(SR_SET_JSON_PATH, l);
if (ret_code != SCANNER_ERR_OK)
LOG_INFO(string_format("write_register sr_set_json_path error: %d \n", ret_code));
ret_code = m_usb->write_bulk(&path[0], &l);
if (ret_code != SCANNER_ERR_OK)
LOG_INFO(string_format("write_bulk last_error: %d \n", ret_code));
int size = 0;
ret_code = read_register(SR_GET_JSON_SIZE, &size);
if (ret_code != SCANNER_ERR_OK)
LOG_INFO(string_format("write_register get_json_size error: %d \n", ret_code));
if (size > 0)
{
static std::string buff;
buff.resize(size);
ret_code = write_register(SR_GET_JSON, size);
LOG_INFO(string_format("write_register get_json size: %d \n", size));
ret_code = m_usb->read_bulk(&buff[0], &size);
if (ret_code != SCANNER_ERR_OK)
LOG_INFO(string_format("write_bulk last_error: %d \n", ret_code));
return buff;
}
}
return "";
}
int G1G2Scanner::write_file(std::string path, std::string content)
{
std::lock_guard<std::mutex> m_lock(m_mtx_usb);
if (m_usb && m_online)
{
int ret_code = 0;
ret_code = write_register(SR_SET_JSON_PATH, path.size());
int len = path.size();
ret_code = m_usb->write_bulk(&path[0], &len);
if (ret_code != SCANNER_ERR_OK)
LOG_INFO(string_format("write json path failed: %d ,path:%s \n", ret_code, path));
ret_code = write_register(SR_SET_JSON, content.size());
len = content.size();
ret_code = m_usb->write_bulk(&content[0], &len);
if (ret_code != SCANNER_ERR_OK)
LOG_INFO(string_format("update json failed: %d ,file content length = %d \n", ret_code, len));
}
return 0;
}
int G1G2Scanner::read_data(void* data, int length, int timeout)
{
if (m_usb && m_online)
{
timeout = max(1500, timeout);
int readed = 0;
int reading = 0;
const int buffer_size = 512 * 1024;
StopWatch sw;
while (readed < length) {
if (sw.elapsed_ms() < timeout && m_usb && m_online)
{
reading = max(0, min(length - readed, buffer_size));
auto code = m_usb->read_bulk((unsigned char*)data + readed, &reading);
if (code != SCANNER_ERR_OK)
{
LOG_INFO(string_format("read_data failed: %d \n", code));
}
if (reading > 0) {
readed += reading;
sw.reset();
}
}
else
{
LOG_INFO(string_format("read_data timeout: %.2f \n", sw.elapsed_ms()));
break;
}
}
return readed;
}
return 0;
}
bool G1G2Scanner::is_running()
{
std::lock_guard<std::mutex> m_lock(m_mtx_usb);
if (m_usb && m_online)
{
bool ret = false;
int val = 0;
int code = read_register(SR_STATUS, &val);
val &= 0x3;
return val > 0 && val < 4;
}
return 0;
}
int G1G2Scanner::im_dev_count()
{
std::lock_guard<std::mutex> m_lock(m_mtx_usb);
int ret = 0;
if (m_usb && m_online)
{
read_register(SR_IM_COUNT, &ret);
}
return ret;
}
bool G1G2Scanner::is_xferfing()
{
std::lock_guard<std::mutex> m_lock(m_mtx_usb);
int ret = 0;
if (m_usb && m_online)
{
read_register(SR_IM_TXING, &ret);
}
return ret;
}
void G1G2Scanner::xfer_start()
{
auto ret = write_register(8, 1);
if (ret != SCANNER_ERR_OK)
LOG_INFO(string_format("xfer_start error:%d \n", ret));
}
void G1G2Scanner::xfer_image()
{
if (is_xferfing())
{
std::cout << "is_xferfing return now" << std::endl;
LOG_INFO("is_xferfing return now\n");
return;
}
std::shared_ptr<std::vector<char>> buffi(new std::vector<char>);
int data_size = get_image_size();
int rcv_size = 0;
buffi->resize(data_size);
xfer_start();
std::this_thread::sleep_for(std::chrono::milliseconds(50));
rcv_size = read_data(buffi->data(), data_size, data_size / (0.005 * 1024 * 1024));
LOG_INFO(string_format("xfer_image %d ,total len =%d \n",++img_index, rcv_size));
imgs.Put(buffi, buffi->size(), 0);
popimage();
}
int G1G2Scanner::get_image_size()
{
std::lock_guard<std::mutex> m_lock(m_mtx_usb);
int len;
read_register(SR_IM_FRONT_SIZE, &len);
return len;
}
int G1G2Scanner::get_imgproc_done()
{
std::lock_guard<std::mutex> m_lock(m_mtx_usb);
int len;
read_register(SR_GET_IMAGEPROCESSDONE, &len);
return len;
}
void G1G2Scanner::popimage()
{
std::lock_guard<std::mutex> m_lock(m_mtx_usb);
int ret = 0;
if (m_usb && m_online)
{
write_register(SR_IM_POP, 1);
}
}
void G1G2Scanner::get_cur_dir(std::string& dir)
{
dir = std::filesystem::current_path().u8string();
}
void G1G2Scanner::proc(bool bcachemode)
{
std::string cur_dir = get_moudle_path();
cur_dir = cur_dir.substr(0, cur_dir.find_last_of("\\/"));
cur_dir += "\\CacheImage\\";
LOG_INFO(string_format("current cache dir:%s \n", cur_dir.c_str()));
while (m_bproc)
{
if (imgs.Size() == 0)
{
this_thread::sleep_for(chrono::milliseconds(10));
continue;
}
auto img_data = imgs.Take();
static int idx_image = 0;
std::string filename = cur_dir+std::to_string(++idx_image) + ".jpg";
LOG_INFO(string_format("cache file:%s \n", filename.c_str()));
std::string notify_info;
std::ofstream o(filename, std::ios::binary | std::ios::app);
if (o.is_open())
{
o.write(img_data->data(), img_data->size());
o.close();
m_msg.Put({ TASK_ID_CHECK_IMGS, DAT_IMAGE_PATH ,filename }, 0);
m_paths.Put(filename, filename.size());
cv::Mat mat = cv::imdecode(*img_data.get(),cv::IMREAD_ANYCOLOR);
if (!mat.empty())
{
notify_info += filename + " \r\n";
auto is_continuos = LineContinuityAndRGBDetection::isContinuous(mat);
notify_info += is_continuos ? " <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Լ<EFBFBD><D4BC>⣺ͨ<E2A3BA><CDA8>\r\n":" <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Լ<EFBFBD><D4BC><EFBFBD>:<3A>쳣<EFBFBD><ECB3A3><EFBFBD><EFBFBD>ͨ<EFBFBD><CDA8>\r\n";
m_msg.Put({ TASK_ID_CHECK_IMGS, DAT_STRING,notify_info },0);
if (mat.channels() == 3)
{
notify_info = "";
auto detect = LineContinuityAndRGBDetection::RGB_Judge(mat);
if (detect > 0)
{
notify_info += GET_BIT(detect, 0) == 1 ? "<EFBFBD><EFBFBD><EFBFBD>⵽-><3E><>ͨ<EFBFBD><CDA8> \r\n":"δ<EFBFBD><EFBFBD><EFBFBD>⵽<EFBFBD><EFBFBD>ͨ<EFBFBD><EFBFBD> \r\n";
notify_info += GET_BIT(detect, 1) == 1 ? "<EFBFBD><EFBFBD><EFBFBD>⵽-><3E><>ͨ<EFBFBD><CDA8> \r\n" : "δ<EFBFBD><EFBFBD><EFBFBD>⵽<EFBFBD><EFBFBD>ͨ<EFBFBD><EFBFBD> \r\n";
notify_info += GET_BIT(detect, 2) == 1 ? "<EFBFBD><EFBFBD><EFBFBD>⵽-><3E><>ͨ<EFBFBD><CDA8> \r\n" : "δ<EFBFBD><EFBFBD><EFBFBD>⵽<EFBFBD><EFBFBD>ͨ<EFBFBD><EFBFBD> \r\n";
m_msg.Put({ TASK_ID_CHECK_IMGS ,DAT_STRING ,notify_info }, 0);
notify_info = "";
if (detect == 7)
{
notify_info = " <20><>ɫ<EFBFBD><C9AB><EFBFBD><EFBFBD><EFBFBD>ο<EFBFBD><CEBF><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> ͨ<><CDA8> \r\n";
m_msg.Put({ TASK_ID_CHECK_IMGS ,DAT_STRING ,notify_info }, 0);
}
else
{
notify_info = " <20><>ɫ<EFBFBD><C9AB><EFBFBD><EFBFBD><EFBFBD>ο<EFBFBD><CEBF><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><>ͨ<EFBFBD><CDA8><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>˹<EFBFBD>У<EFBFBD><D0A3> \r\n";
m_msg.Put({ TASK_ID_CHECK_IMGS ,DAT_STRING ,notify_info }, 0);
}
}
}
}
else
{
notify_info = " ͼ<><CDBC><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʧ<EFBFBD>ܣ<EFBFBD><DCA3><EFBFBD><EFBFBD><EFBFBD> \r\n";
m_msg.Put({ TASK_ID_CHECK_IMGS ,DAT_STRING ,notify_info }, 0);
LOG_INFO(string_format("decode error,empty mat, filename:%s \n", filename.c_str()));
}
}
}
}
void G1G2Scanner::procmsg()
{
while (m_bprocmsg)
{
if (m_msg.Size() == 0)
{
std::this_thread::sleep_for(std::chrono::milliseconds(2));
continue;
}
auto call_info = m_msg.Take();
if (call_info.msg.length())
{
if (m_callback)
{
m_callback(call_info.id, call_info.type, call_info.msg.length(), &call_info.msg[0], m_user);
LOG_INFO(call_info.msg);
std::this_thread::sleep_for(std::chrono::milliseconds(2));//<2F>Է<EFBFBD><D4B7><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>¹<EFBFBD><C2B9><EFBFBD>
}
}
}
}
int G1G2Scanner::update_statue(HGEIntInfo* info)
{
std::string msg_info;
switch (info->Code)
{
case 0x10:
{
msg_info = "<EFBFBD><EFBFBD>ʼ<EFBFBD>Զ<EFBFBD>У<EFBFBD><EFBFBD>... \r\n";
}
break;
case 0x20:
{
msg_info = "<EFBFBD>Զ<EFBFBD>У<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>... \r\n";
}
break;
case 0x30:
{
msg_info = "<EFBFBD><EFBFBD>ʼ<EFBFBD>Զ<EFBFBD><EFBFBD>ɼ<EFBFBD>300DPI <20>Ҷ<EFBFBD>ͼ<EFBFBD><CDBC><EFBFBD><EFBFBD>... \r\n";
}
break;
case 0x40:
{
msg_info = "<EFBFBD><EFBFBD>ʼ<EFBFBD>Զ<EFBFBD><EFBFBD>ɼ<EFBFBD>300DPI <20><>ɫͼ<C9AB><CDBC><EFBFBD><EFBFBD>... \r\n";
}
break;
case 0x50:
{
msg_info = "<EFBFBD><EFBFBD>ʼ<EFBFBD>Զ<EFBFBD><EFBFBD>ɼ<EFBFBD>600DPI <20>Ҷ<EFBFBD>ͼ<EFBFBD><CDBC><EFBFBD><EFBFBD>... \r\n";
}
break;
case 0x60:
{
msg_info = "<EFBFBD><EFBFBD>ʼ<EFBFBD>Զ<EFBFBD><EFBFBD>ɼ<EFBFBD>600DPI <20><>ɫͼ<C9AB><CDBC><EFBFBD><EFBFBD>... \r\n";
}
break;
case 0x80:
{
msg_info = "<EFBFBD><EFBFBD>ʼ<EFBFBD>Զ<EFBFBD><EFBFBD>ɼ<EFBFBD>ͼ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ɣ<EFBFBD><EFBFBD><EFBFBD>ȷ<EFBFBD><EFBFBD>ͼ<EFBFBD><EFBFBD> \r\n";
}
break;
default:
msg_info = "δ֪<EFBFBD><EFBFBD>Ϣ";
break;
}
m_msg.Put({ TASK_ID_CHECK_IMGS, DAT_STRING ,msg_info }, 0);
return 0;
}