261 lines
6.9 KiB
C++
261 lines
6.9 KiB
C++
/*
|
||
* @Descripttion:
|
||
* @version:
|
||
* @Author: pengming
|
||
* @Date: 2023-10-26 17:54:32
|
||
* @LastEditors: pengming
|
||
*/
|
||
#include "ScannerManager.h"
|
||
#include "usb_manager.h"
|
||
#include "G1G2Scanner.h"
|
||
#include "taskinfo.h"
|
||
using namespace std;
|
||
//#include <snowflake.h>
|
||
|
||
#define _countof(a) (sizeof(a) / sizeof((a)[0]))
|
||
|
||
static DevInfo g_sup_devs[] = {
|
||
{0x3072,0x0139,"00:00:00:00:00:00","G100-3399",&ScannerManager::create_scanner_g1g2},
|
||
{0x3072,0x0239,"00:00:00:00:00:00","G200-3399",&ScannerManager::create_scanner_g1g2}
|
||
};
|
||
|
||
|
||
std::string get_date_time()
|
||
{
|
||
time_t now_time;
|
||
struct tm* info_t;
|
||
char buffer[32];
|
||
time(&now_time);
|
||
info_t = localtime(&now_time);
|
||
strftime(buffer, 32, "%Y-%m-%d %H:%M:%S", info_t);
|
||
std::string str = buffer;
|
||
return str;
|
||
}
|
||
ScannerManager::ScannerManager()
|
||
{
|
||
}
|
||
|
||
ScannerManager::~ScannerManager()
|
||
{
|
||
usb_manager::clear();
|
||
}
|
||
|
||
void ScannerManager::Init()
|
||
{
|
||
usb_manager::instance()->register_hotplug(&ScannerManager::usb_event_handle, this);
|
||
}
|
||
|
||
void ScannerManager::SetScannerEventCallback(scanner_event_handler event_handler, void* user)
|
||
{
|
||
m_event_handler = event_handler;
|
||
m_user = user;
|
||
}
|
||
|
||
std::vector<ScannerManager::OLSCANNER> ScannerManager::GetOnlineScanners()
|
||
{
|
||
return m_onlinescanners;
|
||
}
|
||
|
||
int ScannerManager::SetCurrentDevice(int dev_idx)
|
||
{
|
||
lock_guard<mutex> m_lock(m_mtx_mgr);
|
||
if (dev_idx > (m_onlinescanners.size() - 1))
|
||
{
|
||
return 0;
|
||
}
|
||
m_current_select_idx = dev_idx;
|
||
m_cur_scanner = static_cast<std::shared_ptr<IScanner>>(m_onlinescanners[dev_idx].scanner);
|
||
return 1;
|
||
}
|
||
|
||
std::vector<TaskInfo> ScannerManager::GetCurSupTests()
|
||
{
|
||
return m_onlinescanners[m_current_select_idx].taskinfos;
|
||
}
|
||
|
||
void ScannerManager::AddTask(int taskID)
|
||
{
|
||
TASKID id = (TASKID)taskID;
|
||
if (id >= TASK_ID_NUM || taskID < 0)
|
||
return;
|
||
|
||
if (m_cur_scanner.get())
|
||
{
|
||
switch (id)
|
||
{
|
||
case TASK_ID_CHECK_OUTLOOK:
|
||
break;
|
||
case TASK_ID_CHECK_MECHANICAL_PRP:
|
||
break;
|
||
case TASK_ID_CKECK_ASSEMBLE:
|
||
break;
|
||
case TASK_ID_CHECK_POWERSUPPLY:
|
||
break;
|
||
case TASK_ID_CHECK_PWRBTN:
|
||
break;
|
||
case TASK_ID_CHECK_RESET_RECOVERY_BTN:
|
||
break;
|
||
case TASK_ID_CHECK_SWITCHS:
|
||
{
|
||
auto ret = m_cur_scanner->CheckSwitchs(1, 1, 1, 1);
|
||
m_onlinescanners[m_current_select_idx].taskinfos[TASK_ID_CHECK_SWITCHS].result = ret ? "PASS" : "NG";
|
||
m_onlinescanners[m_current_select_idx].taskinfos[TASK_ID_CHECK_SWITCHS].tested = "True";
|
||
m_onlinescanners[m_current_select_idx].taskinfos[TASK_ID_CHECK_SWITCHS].datetime = get_date_time();
|
||
break;
|
||
}
|
||
case TASK_ID_CHECK_IMGS:
|
||
m_cur_scanner->Flat(0);
|
||
break;
|
||
case TASK_ID_CHECK_HW_CAPACITY:
|
||
{
|
||
auto ret = m_cur_scanner->CheckCapacity(0xc0000000, 0xA00000);//3GB 10GB
|
||
m_onlinescanners[m_current_select_idx].taskinfos[TASK_ID_CHECK_HW_CAPACITY].result = ret?"PASS":"NG";
|
||
m_onlinescanners[m_current_select_idx].taskinfos[TASK_ID_CHECK_HW_CAPACITY].tested = "True";
|
||
m_onlinescanners[m_current_select_idx].taskinfos[TASK_ID_CHECK_HW_CAPACITY].datetime = get_date_time();
|
||
|
||
}
|
||
break;
|
||
case TASK_ID_CHECK_DISPLAY:
|
||
{
|
||
m_cur_scanner->CheckLEDDisplay("");//3GB 10GB
|
||
m_onlinescanners[m_current_select_idx].taskinfos[TASK_ID_CHECK_DISPLAY].tested = "True";
|
||
}
|
||
break;
|
||
default:
|
||
break;
|
||
}
|
||
}
|
||
|
||
}
|
||
|
||
bool ScannerManager::UpdateTaskResult(int taskID, std::string result)
|
||
{
|
||
bool ret = false;
|
||
if (m_current_select_idx < m_onlinescanners.size() &&
|
||
m_onlinescanners[m_current_select_idx].scanner.get())
|
||
{
|
||
for (auto info = m_onlinescanners[m_current_select_idx].taskinfos.begin(); info != m_onlinescanners[m_current_select_idx].taskinfos.end(); info++)
|
||
{
|
||
if (info->id == taskID)
|
||
{
|
||
info->result = result;
|
||
info->tested = "True";
|
||
info->datetime = get_date_time();
|
||
ret = true;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
return ret;
|
||
}
|
||
|
||
void ScannerManager::FinishTest()
|
||
{
|
||
if (m_cur_scanner.get())
|
||
{
|
||
auto content = js_task.GetInfosDump(m_onlinescanners[m_current_select_idx].taskinfos);
|
||
m_cur_scanner->RecordFinalResult(content);
|
||
}
|
||
|
||
}
|
||
|
||
void ScannerManager::Reboot(bool b_loader)
|
||
{
|
||
if (m_cur_scanner.get())
|
||
m_cur_scanner->Reboot(b_loader);
|
||
}
|
||
|
||
void ScannerManager::PowerOFF()
|
||
{
|
||
if (m_cur_scanner.get())
|
||
m_cur_scanner->PowerOFF();
|
||
}
|
||
|
||
void ScannerManager::usb_event_handle(usb_event ev, libusb_device* device, int vid, int pid, int usb_ver_h, int usb_ver_l, bool* retry, void* user)
|
||
{
|
||
ScannerManager* This = (ScannerManager*)user;
|
||
|
||
This->on_hgscanner_pnp(ev, device, vid, pid, usb_ver_h, usb_ver_l, retry);
|
||
}
|
||
|
||
void ScannerManager::on_scanner_handler(unsigned int evt, int data_type, unsigned int data_len, void* data, void* user)
|
||
{
|
||
ScannerManager* This = (ScannerManager*)user;
|
||
This->on_scanner_call(evt, data_type, data_len, data);
|
||
}
|
||
|
||
void ScannerManager::on_hgscanner_pnp(usb_event ev, libusb_device* device, int vid, int pid, int usb_ver_h, int usb_ver_l, bool* retry)
|
||
{
|
||
DevEvent devevent;
|
||
devevent.Vid = vid;
|
||
devevent.Pid = pid;
|
||
if (ev == USB_EVENT_DEVICE_ARRIVED)
|
||
{
|
||
int aa = _countof(g_sup_devs);
|
||
for (int i = 0; i < _countof(g_sup_devs); ++i)
|
||
{
|
||
if (g_sup_devs[i].vid == vid && g_sup_devs[i].pid == pid)
|
||
{
|
||
int aa = 1;
|
||
usb_io* io = NULL;
|
||
usb_manager::instance()->open(device, &io);
|
||
void* handler = nullptr;
|
||
auto iscanner = g_sup_devs[i].create_scanner(g_sup_devs[i].type.c_str(), io, handler);
|
||
if (iscanner.get())
|
||
{
|
||
OLSCANNER olscanner;
|
||
olscanner.dev = device;
|
||
olscanner.display_name = g_sup_devs[i].type;
|
||
olscanner.ind = m_onlinescanners.size();//<2F><>0<EFBFBD><30>ʼ<EFBFBD><CABC><EFBFBD><EFBFBD>
|
||
olscanner.scanner = iscanner;
|
||
GetDefaultTaskinfos(olscanner.taskinfos);
|
||
olscanner.scanner->SetScannerCallback(&ScannerManager::on_scanner_handler, this);
|
||
libusb_ref_device(device); // ref the device of queue online_devices_
|
||
m_onlinescanners.push_back(olscanner);
|
||
devevent.EvtCode = USB_EVENT_DEVICE_ARRIVED;
|
||
devevent.Msg = g_sup_devs[i].type;
|
||
devevent.Index = olscanner.ind;
|
||
m_event_handler(devevent, 0, 0, 0,0, nullptr, m_user);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
else if (ev == USB_EVENT_DEVICE_LEFT)
|
||
{
|
||
devevent.EvtCode = USB_EVENT_DEVICE_LEFT;
|
||
std::vector<OLSCANNER>::iterator it = std::find(m_onlinescanners.begin(), m_onlinescanners.end(), device);
|
||
if (it != m_onlinescanners.end())
|
||
{
|
||
if (it->scanner)
|
||
{
|
||
devevent.Index = it->ind;
|
||
m_event_handler(devevent, 0, 0, 0, 0,nullptr, m_user);
|
||
it->scanner->USBDisconnect();
|
||
libusb_unref_device(it->dev); // unref the device of queue online_devices_
|
||
m_onlinescanners.erase(it);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
void ScannerManager::on_scanner_call(unsigned int evt, int data_type, unsigned int data_len, void* data)
|
||
{
|
||
DevEvent info;
|
||
info.Msg = m_onlinescanners[m_current_select_idx].display_name;
|
||
info.EvtCode = evt;
|
||
m_event_handler(info,1, evt, data_type, data_len, data, m_user);
|
||
}
|
||
|
||
void ScannerManager::GetDefaultTaskinfos(std::vector<TaskInfo>& infos)
|
||
{
|
||
infos = js_task.GetInfos("info.json");
|
||
}
|
||
|
||
std::shared_ptr<IScanner> ScannerManager::create_scanner_g1g2(const char* name, usb_io* io, void* h)
|
||
{
|
||
std::shared_ptr<IScanner> m_g1g2scanner;
|
||
m_g1g2scanner.reset(new G1G2Scanner(io));
|
||
|
||
return m_g1g2scanner;
|
||
}
|