#include "stdafx.h" #include "FileVersion.hpp" #include "CCOS.Dev.FPD.KonicaDR.h" #include "DICOMImageHeadKey.h" #include "KonicaCtrl.h" #include "common_api.h" namespace nsFPD = CCOS::Dev::Detail::Detector; extern KonicaCtrl* g_pDetector; static nsFPD::KonicaDriver gIODriver; Log4CPP::Logger* gLogger = nullptr; extern const char* g_szMouldPath; KonicaDriver* gDriver = nullptr; extern "C" CCOS::Dev::IODriver * __cdecl GetIODriver() // 返回静态对象的引用, 调用者不能删除 ! { return &gIODriver; } extern "C" CCOS::Dev::IODriver * __cdecl CreateIODriver() // 返回新对象, 调用者必须自行删除此对象 ! { gDriver = new nsFPD::KonicaDriver(); return gDriver; } nsFPD::KonicaDriver::KonicaDriver() { pObjDev = nullptr; m_bDriverConnect = false; //缺省为false m_pAttribute.reset(new ResDataObject()); m_pDescription.reset(new ResDataObject()); } nsFPD::KonicaDriver::~KonicaDriver() { if (pObjDev != nullptr) { delete pObjDev; pObjDev = nullptr; } Close(); Log4CPP::ThreadContext::Map::Clear(); gLogger = nullptr; } auto nsFPD::KonicaDriver::CreateDevice(int index)->std::unique_ptr { printf("--Driver-- CreateDevice \r\n"); FINFO("--Driver-- createdevice"); pObjDev = new FPDDeviceKonica(EventCenter, m_ConfigFileName); auto Device = std::unique_ptr(new IODevice(pObjDev)); pObjDev->CreateDevice(); pObjDev->Register(); return Device; } bool nsFPD::KonicaDriver::Connect() { printf("--Driver-- Connect \r\n"); FINFO("--Driver-- connect"); return m_bDriverConnect; } void nsFPD::KonicaDriver::Disconnect() { printf("--Driver-- Disconnect \r\n"); FINFO("--Driver-- disconnect"); if (pObjDev != nullptr) { delete pObjDev; pObjDev = nullptr; } m_bDriverConnect = false; } bool nsFPD::KonicaDriver::isConnected() const { return m_bDriverConnect; } void nsFPD::KonicaDriver::Prepare() { printf("--Driver-- prepare \r\n"); string strLogPath = GetProcessDirectory() + R"(\Conf\Log4CPP.Config.xml)"; auto rc = Log4CPP::LogManager::LoadConfigFile(strLogPath.c_str()); gLogger = Log4CPP::LogManager::GetLogger("Module"); FINFO("Code Build datetime [{$} {$}]", __DATE__, __TIME__); #ifdef _WIN64 FINFO("=============================Version: {$} (64-bit)==================================", FileVersion(g_szMouldPath).GetVersionString()); #else FINFO("=============================Version: {$} (32-bit)==================================", FileVersion(g_szMouldPath).GetVersionString()); #endif FINFO("Driver Prepare get logger"); } std::string nsFPD::KonicaDriver::DriverProbe() { printf("--Driver-- DriverProbe \r\n"); FINFO("--Driver-- DriverProbe config name:{$}", m_ConfigFileName); ResDataObject r_config, HardwareInfo; if (r_config.loadFile(m_ConfigFileName.c_str())) { HardwareInfo.add("MajorID", r_config["CONFIGURATION"]["MajorID"]); HardwareInfo.add("MinorID", r_config["CONFIGURATION"]["MinorID"]); HardwareInfo.add("VendorID", r_config["CONFIGURATION"]["VendorID"]); HardwareInfo.add("ProductID", r_config["CONFIGURATION"]["ProductID"]); HardwareInfo.add("SerialID", r_config["CONFIGURATION"]["SerialID"]); } else { HardwareInfo.add("MajorID", "Detector"); HardwareInfo.add("MinorID", "DR"); HardwareInfo.add("VendorID", "Konica"); HardwareInfo.add("ProductID", "Konica"); HardwareInfo.add("SerialID", "Driver"); } string str = HardwareInfo.encode(); return str; } std::string nsFPD::KonicaDriver::GetResource() { printf("--Driver-- GetResource \r\n"); FINFO("--Driver-- GetResource"); ResDataObject r_config, temp; printf("m_ConfigFileName:%s\n", m_ConfigFileName.c_str()); FINFO("m_ConfigFileName:{$}", m_ConfigFileName); if (!temp.loadFile(m_ConfigFileName.c_str())) { return ""; } m_ConfigAll = temp; r_config = temp["CONFIGURATION"]; m_Configurations = r_config; ResDataObject DescriptionTemp; ResDataObject ListTemp; //ResDataObject m_pAttribute; //ResDataObject m_pDescription; string strTemp = ""; //用于读取字符串配置信息 string strIndex = ""; //用于读取配置信息中的List项 int nTemp = -1; //用于读取整型配置信息 char sstream[10] = { 0 }; //用于转换值 string strValue = ""; //用于存储配置的值 string strType = ""; //用于存储配置的类型 int/float/string... string strAccess = ""; //用于存储权限的类型 R/W/RW string strRequired = ""; // TRUE/FALSE string strDefaultValue = ""; string strRangeMin = ""; string strRangeMax = ""; try { int nConfigInfoCount = (int)m_Configurations["ConfigToolInfo"].GetKeyCount("AttributeInfo"); //FINFO(g_pFPDCtrlLog, "ConfigInfo Count: {$}", nConfigInfoCount); m_pAttribute->clear(); m_pDescription->clear(); for (int nInfoIndex = 0; nInfoIndex < nConfigInfoCount; nInfoIndex++) { DescriptionTemp.clear(); ListTemp.clear(); //AttributeType strTemp = (string)m_Configurations["ConfigToolInfo"][nInfoIndex]["AttributeDescripition"]["Type"]; DescriptionTemp.add(AttributeType, strTemp.c_str()); //FINFO("DescriptionTemp--> {$}: {$}", AttributeType, strTemp.c_str()); strType = strTemp; //记录配置项的类型 //AttributeKey //1. 根据AttributeType，内部key和配置路径，拿到当前的真实值 strTemp = (string)m_Configurations["ConfigToolInfo"][nInfoIndex]["InnerKey"]; nTemp = (int)m_Configurations["ConfigToolInfo"][nInfoIndex]["PathID"]; GetDeviceConfigValue(r_config, strTemp.c_str(), nTemp, strValue); //2. 赋值 strTemp = (string)m_Configurations["ConfigToolInfo"][nInfoIndex]["AttributeKey"]; if ("int" == strType) { (*m_pAttribute).add(strTemp.c_str(), atoi(strValue.c_str())); } else if ("float" == strType) { (*m_pAttribute).add(strTemp.c_str(), atof(strValue.c_str())); } else //其它先按string类型处理 { (*m_pAttribute).add(strTemp.c_str(), strValue.c_str()); } //AttributeAccess strTemp = (string)m_Configurations["ConfigToolInfo"][nInfoIndex]["AttributeDescripition"]["Access"]; DescriptionTemp.add(AttributeAccess, strTemp.c_str()); //AttributeRangeMin strTemp = (string)m_Configurations["ConfigToolInfo"][nInfoIndex]["AttributeDescripition"]["RangeMin"]; if (strTemp != "") //不需要的配置项为空 { DescriptionTemp.add(AttributeRangeMin, strTemp.c_str()); } //AttributeRangeMax strTemp = (string)m_Configurations["ConfigToolInfo"][nInfoIndex]["AttributeDescripition"]["RangeMax"]; if (strTemp != "") //不需要的配置项为空 { DescriptionTemp.add(AttributeRangeMax, strTemp.c_str()); } //AttributeList nTemp = m_Configurations["ConfigToolInfo"][nInfoIndex]["AttributeDescripition"]["ListNum"]; if (nTemp > 0) //ListNum不大于0时说明不需要list配置 { for (int nListIndex = 0; nListIndex < nTemp; nListIndex++) { strTemp = (string)m_Configurations["ConfigToolInfo"][nInfoIndex]["AttributeDescripition"]["ListInfo"][nListIndex]; //sprintf_s(sstream, "{$}", nListIndex); auto temKey = std::to_string(nListIndex); ListTemp.add(temKey.c_str(), strTemp.c_str()); } DescriptionTemp.add(AttributeList, ListTemp); } //AttributeRequired strTemp = (string)m_Configurations["ConfigToolInfo"][nInfoIndex]["AttributeDescripition"]["Required"]; DescriptionTemp.add(AttributeRequired, strTemp.c_str()); //AttributeDefaultValue strTemp = (string)m_Configurations["ConfigToolInfo"][nInfoIndex]["AttributeDescripition"]["DefaultValue"]; if (strTemp != "") //不需要的配置项为空 { DescriptionTemp.add(AttributeDefaultValue, strTemp.c_str()); } strTemp = (string)m_Configurations["ConfigToolInfo"][nInfoIndex]["AttributeKey"]; (*m_pDescription).add(strTemp.c_str(), DescriptionTemp); } } catch (ResDataObjectExption& e) { FERROR("Get config error: {$}", e.what()); return ""; } ResDataObject resDeviceResource; resDeviceResource.add(ConfKey::CcosDetectorAttribute, (*m_pAttribute)); resDeviceResource.add(ConfKey::CcosDetectorDescription, (*m_pDescription)); ResDataObject DescriptionTempEx; DescriptionTempEx.add(ConfKey::CcosDetectorConfig, resDeviceResource); m_DeviceConfig = DescriptionTempEx; string res = DescriptionTempEx.encode(); printf("KonicaDriver module: get resource over \r\n"); FINFO("KonicaDriver module: get resource over"); return res; } std::string nsFPD::KonicaDriver::DeviceProbe() { printf("--Driver-- DeviceProbe \r\n"); FINFO("--Driver-- DeviceProbe"); ResDataObject r_config, HardwareInfo; if (r_config.loadFile(m_ConfigFileName.c_str())) { HardwareInfo.add("MajorID", r_config["CONFIGURATION"]["MajorID"]); HardwareInfo.add("MinorID", "Device"); HardwareInfo.add("VendorID", r_config["CONFIGURATION"]["VendorID"]); HardwareInfo.add("ProductID", r_config["CONFIGURATION"]["ProductID"]); HardwareInfo.add("SerialID", r_config["CONFIGURATION"]["SerialID"]); } else { HardwareInfo.add("MajorID", "Detector"); HardwareInfo.add("MinorID", "Device"); HardwareInfo.add("VendorID", "Konica"); HardwareInfo.add("ProductID", "Konica"); HardwareInfo.add("SerialID", "1234"); } string str = HardwareInfo.encode(); FINFO("KonicaDriver module DeviceProbe over"); return str; } bool nsFPD::KonicaDriver::GetDeviceConfig(std::string& Cfg) { Cfg = m_DeviceConfig.encode(); FINFO("--Driver-- GetDeviceConfig Cfg:{$}", Cfg); return true; } bool nsFPD::KonicaDriver::SetDeviceConfig(std::string Cfg) { FINFO("--Driver-- SetDeviceConfig {$}", Cfg.c_str()); ResDataObject DeviceConfig; DeviceConfig.decode(Cfg.c_str()); ResDataObject DescriptionTempEx; DescriptionTempEx = DeviceConfig["DeviceConfig"]; bool bSaveFile = false; //true:重新保存配置文件 string strAccess = ""; for (int i = 0; i < DescriptionTempEx.size(); i++) { ResDataObject temp = DescriptionTempEx[i]; FINFO("{$}", temp.encode()); for (int j = 0; j < temp.size(); j++) { string strKey = temp.GetKey(j); FINFO("{$}", strKey.c_str()); try { if (m_pAttribute->GetFirstOf(strKey.c_str()) >= 0) { strAccess = (string)(*m_pDescription)[strKey.c_str()]["Access"]; if ("RW" == strAccess || "rw" == strAccess) { //修改对应配置，在其他单元的配置项要同时调用其修改函数修改真实值 //1. 修改内存中的值，用于给上层发消息 (*m_pAttribute)[strKey.c_str()] = temp[j]; //2. 拿到Innerkey int nConfigInfoCount = (int)m_Configurations["ConfigToolInfo"].GetKeyCount("AttributeInfo"); FINFO("ConfigInfo Count: {$}", nConfigInfoCount); string strTemp = ""; //存储AttributeKey for (int nInfoIndex = 0; nInfoIndex < nConfigInfoCount; nInfoIndex++) { strTemp = (string)m_Configurations["ConfigToolInfo"][nInfoIndex]["AttributeKey"]; if (strTemp == strKey) { strTemp = (string)m_Configurations["ConfigToolInfo"][nInfoIndex]["InnerKey"]; break; } } //3. 修改配置文件中的值 if (SetDeviceConfigValue(m_Configurations, strTemp.c_str(), 1, temp[j])) { bSaveFile = true; } } else { FINFO("{$} is not a RW configuration item", strKey.c_str()); } } } catch (ResDataObjectExption& e) { FERROR("SetDriverConfig crashed: {$}", e.what()); return false; } } } if (bSaveFile) { //3. 重新保存配置文件 SaveConfigFile(true); } return true; } bool nsFPD::KonicaDriver::SaveConfigFile(bool bSendNotify) { FINFO("--Driver-- SaveConfigFile m_ConfigFileName:{$}", m_ConfigFileName); m_ConfigAll["CONFIGURATION"] = m_Configurations; bool ret = m_ConfigAll.SaveFile(m_ConfigFileName.c_str()); if (ret) { FINFO("SaveConfigFile Success!"); return true; } else { FERROR("SaveConfigFile Fail!"); return false; } } bool nsFPD::KonicaDriver::GetDeviceConfigValue(ResDataObject config, const char* pInnerKey, int nPathID, string& strValue) { strValue = ""; string strTemp = pInnerKey; if (1 == nPathID) //从DriverConfig路径下每个DPC自己的配置文件读取 { if (WiredIP == strTemp || WirelessIP == strTemp || LocalIP == strTemp) { strValue = (string)config["connections"][pInnerKey]; } else if (DetectorVender == strTemp || DetectorModel == strTemp || DetectorDescription == strTemp || DetectorSerialNumber == strTemp) { strValue = (string)config[pInnerKey]; } else if (SyncType == strTemp || FPDWorkStation == strTemp || ImageWidth == strTemp || ImageHeight == strTemp) { strValue = (string)config["ModeTable"]["DetectorMode"][pInnerKey]; } else if (TempMaxLimit == strTemp || ReConnect == strTemp || TempUpperLimit == strTemp || TempLowerLimit == strTemp || TempMinLimit == strTemp || BatLowerLimit == strTemp || BatMiniLimit == strTemp || BatLowerLimitInCali == strTemp || WifiLowerLimit == strTemp || WifiMiniLimit == strTemp || HighPowerTimeout == strTemp || ShowTemperature == strTemp || ShowWifi == strTemp || ShowBattery == strTemp || ShowBluetooth == strTemp || FPDExamMode == strTemp || FPDAcqMode == strTemp || FPDModeMatch == strTemp || CcosDetectorAttachedFlag == strTemp) { strValue = (string)config[pInnerKey]; } else { strValue = ""; FERROR("Error Configuration item: {$}", pInnerKey); } } //FINFO("GetDeviceConfigValue pInnerKey:{$},nPathID:{$},strValue:{$}", pInnerKey, nPathID, strValue); return true; } bool nsFPD::KonicaDriver::SetDeviceConfigValue(ResDataObject &config, const char* pInnerKey, int nPathID, const char* szValue) { FINFO("--Driver-- SetDeviceConfigValue change {$} item value to {$}", pInnerKey, szValue); string strTemp = pInnerKey; if (1 == nPathID) //从DriverConfig路径下每个DPC自己的配置文件读取 { if (WiredIP == strTemp || WirelessIP == strTemp || LocalIP == strTemp) { config["connections"][pInnerKey] = szValue; } else if (DetectorVender == strTemp || DetectorModel == strTemp || DetectorDescription == strTemp || DetectorSerialNumber == strTemp) { config[pInnerKey] = szValue; } else if (SyncType == strTemp || FPDWorkStation == strTemp || ImageWidth == strTemp || ImageHeight == strTemp) { config["ModeTable"]["DetectorMode"][pInnerKey] = szValue; } else if (TempMaxLimit == strTemp || ReConnect == strTemp || TempUpperLimit == strTemp || TempLowerLimit == strTemp || BatLowerLimit == strTemp || BatMiniLimit == strTemp || BatLowerLimitInCali == strTemp || WifiLowerLimit == strTemp || WifiMiniLimit == strTemp || HighPowerTimeout == strTemp || ShowTemperature == strTemp || ShowWifi == strTemp || ShowBattery == strTemp || ShowBluetooth == strTemp || FPDExamMode == strTemp || FPDAcqMode == strTemp || FPDModeMatch == strTemp || CcosDetectorAttachedFlag == strTemp) { config[pInnerKey] = szValue; } else { FERROR("Error Configuration item: {$}", pInnerKey); return false; } } return true; } nsFPD::FPDDeviceKonica::FPDDeviceKonica(std::shared_ptr center,std::string strConfigPath) { m_strWorkPath = GetProcessDirectory(); m_nFullImageWidth = 0; m_nFullImageHeight = 0; m_nPreviewEnable = 0; m_nPreviewImageWidth = 0; m_nPreviewImageHeight = 0; m_nImgBits = 0; m_nAngle = 0; m_nPixelSpacing = 0; m_nSensitivity = 0; m_pFullImgBuffer = nullptr; m_pPreviewImgBuffer = nullptr; m_eAppStatus = APP_STATUS_IDLE; m_bDeviceConnect = false; m_eSyncMode = SYNC_SOFTWARE; m_fFactorEXI2UGY = 0.0f; m_nTargetCalibExi = 0; m_nCalibTotalExposureNum = 0, m_nCalibCurrentCalibrationRound = 0, m_nCalibCurrentExposureIndex = 0, m_nCalibCurrentExposureNum = 0; m_bEnterAcqStatus = false; m_CalibType = CCOS_CALIBRATION_TYPE_NONE; m_DetectorCtrlUnit.reset(new OemCtrl(center, this)); m_AcqUnit.reset(new OemAcq(center, this)); m_SyncUnit.reset(new OemSync(center, this)); m_CalibUnit.reset(new OemCalib(center, this)); m_DetectorConfiguration.reset(new DetectorConfiguration(strConfigPath)); string fullpath = g_szMouldPath; string::size_type firstHit = fullpath.find_last_of('\\'); if (firstHit == string::npos || firstHit == 0) { FERROR("Get DLL path error!"); } else { FINFO("g_szMouldPath:{$}", g_szMouldPath); } string strInfoPath = fullpath.substr(0, firstHit); m_WarnAndError.reset(new FPDErrorWarning(center, DetectorUnitType, strInfoPath)); m_DetectorCtrlUnit->SetDetectorStatus(to_string(DETECTOR_STATUS_INIT)); m_CalibUnit->SetCalibrationStatus(to_string(CCOS_CALIBRATION_STATUS_ERROR)); EventCenter = center; } nsFPD::FPDDeviceKonica::~FPDDeviceKonica() { if (nullptr != m_pFullImgBuffer) { delete[]m_pFullImgBuffer; m_pFullImgBuffer = nullptr; } if (nullptr != m_pPreviewImgBuffer) { delete[]m_pPreviewImgBuffer; m_pPreviewImgBuffer = nullptr; } } std::string nsFPD::FPDDeviceKonica::GetGUID() const { FINFO("--Func-- GetGUID"); return DetectorUnitType; } void nsFPD::FPDDeviceKonica::Register() { FINFO("--Func-- Register"); auto Disp = &Dispatch; RegisterCtrl(Disp); RegisterAcq(Disp); RegisterSync(Disp); RegisterCalib(Disp); RegisterOthers(Disp); } bool nsFPD::FPDDeviceKonica::CreateDevice() { FINFO("--Func-- CreateDevice"); if (!LoadConfig()) { FERROR("LoadConfig fail!"); return false; } if (nullptr == g_pDetector) { g_pDetector = new KonicaCtrl(); } bool bRet = g_pDetector->DriverEntry(this, m_DetectorConfiguration->m_Configurations); if (!bRet) { FERROR("DriverEntry fail!"); return false; } RET_STATUS ret = Connect(); if (ret != RET_SUCCEED) { FERROR("Connect fail!"); return false; } FINFO("CreateDevice end"); return true; } bool nsFPD::FPDDeviceKonica::Prepare() { FINFO("--Func-- device prepare"); EventCenter->OnMaxBlockSize("KonicaDrQue", m_stDeviceConfig.nMaxImgWidth * m_stDeviceConfig.nMaxImgWidth * 4, 3, 4000 * 4000 * 2, 1); return true; } RET_STATUS nsFPD::FPDDeviceKonica::Connect() { FINFO("--Func-- device Connect"); m_DetectorCtrlUnit->SetAttachStatus("1"); //没有attach功能，直接上发1，使客户端显示探测器状态 RET_STATUS ret = RET_STATUS::RET_FAILED; if (g_pDetector->Connect(this, m_strWorkPath.c_str())) { ret = RET_STATUS::RET_SUCCEED; if (m_stDeviceConfig.bSupportDDR) //是否支持DDR采集功能 { m_DetectorCtrlUnit->SetSupportDDR("1"); } else { m_DetectorCtrlUnit->SetSupportDDR("0"); } //把通知状态信息的时间间隔传给ctrl g_pDetector->SetNotifyStatusTimePeriod(m_stDeviceConfig.nNotifyStatusTimePeriod); g_pDetector->SetReconnectTimePeriod(m_stDeviceConfig.nReconnectTimePeriod); m_SyncUnit->SetSupportSyncMode(m_stDeviceConfig.strSupportSyncMode); m_CalibUnit->SetCalibMode(std::to_string(m_stDeviceConfig.nCalibMode)); m_CalibUnit->SetLastCalibrationDate(m_stDeviceConfig.strLastCalibrationDate); m_CalibUnit->SetCalibrationFileExpireTime(m_stDeviceConfig.strCalibrationFileExpireTime); m_CalibUnit->SetCalibrationFileExpirationReminder(m_stDeviceConfig.strCalibrationFileExpirationReminder); m_DetectorCtrlUnit->SetSupportSwitchResolution(std::to_string(m_stDeviceConfig.nSupportSwitchResolution)); string strTemp = ""; strTemp = (string)m_DetectorConfiguration->m_Configurations["DetectorType"]; m_DetectorCtrlUnit->SetDetectorType(strTemp); strTemp = (string)m_DetectorConfiguration->m_Configurations["Description"]; m_DetectorCtrlUnit->SetDescription(strTemp); strTemp = (string)m_DetectorConfiguration->m_Configurations["SerialNumber"]; m_DetectorCtrlUnit->SetSerialNumber(strTemp); strTemp = (string)m_DetectorConfiguration->m_Configurations["DetectorWiredIP"]; m_DetectorCtrlUnit->SetDetectorWiredIP(strTemp); strTemp = (string)m_DetectorConfiguration->m_Configurations["DetectorWirelessIP"]; m_DetectorCtrlUnit->SetDetectorWirelessIP(strTemp); strTemp = (string)m_DetectorConfiguration->m_Configurations["LocalIP"]; m_DetectorCtrlUnit->SetLocalIP(strTemp); strTemp = (string)m_DetectorConfiguration->m_Configurations["ShowTemperature"]; m_DetectorCtrlUnit->SetShowTemperature(strTemp); strTemp = (string)m_DetectorConfiguration->m_Configurations["ShowWifi"]; m_DetectorCtrlUnit->SetShowWifi(strTemp); strTemp = (string)m_DetectorConfiguration->m_Configurations["ShowBattery"]; m_DetectorCtrlUnit->SetShowBattery(strTemp); strTemp = (string)m_DetectorConfiguration->m_Configurations["ShowBluetooth"]; m_DetectorCtrlUnit->SetShowBluetooth(strTemp); } return ret; } RET_STATUS nsFPD::FPDDeviceKonica::EnterExam(int nExamMode) { FINFO("--Func-- EnterExam {$}", nExamMode); switch (nExamMode) { case APP_STATUS_WORK_BEGIN: FINFO("Enter into Exam Windows"); m_eAppStatus = APP_STATUS_WORK_BEGIN; FINFO("strLastCalibrationDate:{$},strCalibrationFileExpirationReminder:{$}", m_stDeviceConfig.strLastCalibrationDate, m_stDeviceConfig.strCalibrationFileExpirationReminder); if (m_stDeviceConfig.strCalibrationFileExpirationReminder == "1") { //进检查时判断当前校正文件是否过期，如果即将过期或者已过期都向上通知 if (m_stDeviceConfig.strLastCalibrationDate == "0000-00-00 00:00:00") { //没有做过校正 FWARN("No calibration file, please make a calibration!"); m_WarnAndError->SendWarn(ERR_FPD_CAL_FILE_NOT_EXIST, ""); } else { time_t lastCalibDate = StringToDatetime(m_stDeviceConfig.strLastCalibrationDate); int nExpireTime = std::stoi(m_stDeviceConfig.strCalibrationFileExpireTime);//单位：天 FINFO("nExpireTime:{$}", nExpireTime); time_t localtime = time(NULL); //判断是否过期 if (localtime > lastCalibDate + nExpireTime * 24 * 3600) { //过期了报错 FWARN("Calibration file is expired! please make a calibration!"); m_WarnAndError->SendWarn(ERR_FPD_CAL_FILE_OUTDATE, ""); } } } break; case APP_STATUS_WORK_END: FINFO("Quit Exam Windows"); m_eAppStatus = APP_STATUS_WORK_END; FINFO("strCalibrationFileExpirationReminder:{$}", m_stDeviceConfig.strCalibrationFileExpirationReminder); if (m_stDeviceConfig.strCalibrationFileExpirationReminder == "1") { m_WarnAndError->ClearWarn(ERR_FPD_CAL_FILE_NOT_EXIST); m_WarnAndError->ClearWarn(ERR_FPD_CAL_FILE_OUTDATE); } break; case APP_STATUS_DETSHARE_BEGIN: FINFO("Enter into Detector Share Windows"); m_eAppStatus = APP_STATUS_DETSHARE_BEGIN; break; case APP_STATUS_DETSHAR_END: FINFO("Quit Detector Share Windows"); m_eAppStatus = APP_STATUS_DETSHAR_END; break; case APP_STATUS_CAL_BEGIN: FINFO("Enter into Calibration Windows"); m_eAppStatus = APP_STATUS_CAL_BEGIN; break; case APP_STATUS_CAL_END: FINFO("Quit Calibration Windows"); m_eAppStatus = APP_STATUS_CAL_END; break; case APP_STATUS_WORK_IN_SENSITIVITY: FINFO("Enter into sensitivity test interface"); m_eAppStatus = APP_STATUS_WORK_IN_SENSITIVITY; break; default: break; } g_pDetector->EnterExamMode(nExamMode); if (nExamMode == APP_STATUS_WORK_END || nExamMode == APP_STATUS_CAL_END) { RET_STATUS ret = StopAcquisition(); if (ret != RET_STATUS::RET_SUCCEED) { FERROR("EnterExam StopAcquisition fail!"); return ret; } } return RET_STATUS::RET_SUCCEED; } bool nsFPD::FPDDeviceKonica::GetLogicMode(string& strAcqMode, int& nLogicMode) { if (strAcqMode == "RAD") { nLogicMode = RAD; } else if (strAcqMode == "Stitch") { nLogicMode = Stitch; } else if (strAcqMode == "1") { nLogicMode = RAD; } else if (strAcqMode == "2") { nLogicMode = Stitch; } else { FERROR("Not support mode!"); return false; } return true; } RET_STATUS nsFPD::FPDDeviceKonica::SetAcqMode(string strAcqMode) { FINFO("--Func-- SetAcqMode({$})", strAcqMode); RET_STATUS ret = RET_STATUS::RET_FAILED; //如果没连接，不执行 if (!m_bDeviceConnect) { FERROR("m_bDeviceConnect is false, detector not connect, return"); return ret; } //设置采集模式时发一次非Standby状态，配合子系统走流程，使界面ready状态和探测器同步 m_DetectorCtrlUnit->SetDetectorStatus(to_string(DETECTOR_STATUS_WAKEUP)); int nMode = RAD; bool bRet = GetLogicMode(strAcqMode, nMode); if (!bRet) { return ret; } try { ResDataObject objModeConfig = m_DetectorConfiguration->m_Configurations; int nModeCount = (int)objModeConfig["ModeTable"].size(); for (int i = 0; i < nModeCount; i++) { int nLogicMode = (int)objModeConfig["ModeTable"][i]["LogicMode"]; if (nLogicMode == nMode) { m_nImgBits = (int)objModeConfig["ModeTable"][i]["PhySizeInfoBit"]; m_nAngle = (int)objModeConfig["ModeTable"][i]["RotateAngle"]; m_nPixelSpacing = (int)objModeConfig["ModeTable"][i]["PixelPitch"]; m_nSensitivity = (int)objModeConfig["ModeTable"][i]["Sensitivity"]; m_nPreviewEnable = (int)objModeConfig["ModeTable"][i]["PreviewEnable"]; FINFO("m_nImgBits:{$},m_nAngle:{$},m_nPixelSpacing:{$},m_nSensitivity:{$},m_nPreviewEnable:{$}", m_nImgBits, m_nAngle, m_nPixelSpacing, m_nSensitivity, m_nPreviewEnable); string strDoseOfExi = std::to_string(m_nSensitivity); m_fFactorEXI2UGY = 100.0f / stof(strDoseOfExi) * 1.0f;//统一使用IEC标准呈现四角信息，无单位 ugy * 100 -ugy。所有Zskk探测器的FactorEXI2UGY均需*100 FINFO("m_fFactorEXI2UGY = {$} ", m_fFactorEXI2UGY); m_DetectorCtrlUnit->SetFPDSensitivity(std::to_string(m_fFactorEXI2UGY)); if (g_pDetector->SetAcqMode(nMode)) { ret = RET_STATUS::RET_SUCCEED; m_AcqUnit->AcqModeNotify(strAcqMode); } else { ret = RET_STATUS::RET_FAILED; } break; } } } catch (ResDataObjectExption& e) { FERROR("Read configuration failed, Error code: {$}", e.what()); } return ret; } RET_STATUS nsFPD::FPDDeviceKonica::GetSyncMode(SYNC_MODE& eSyncMode) { FINFO("--Func-- GetSyncMode"); eSyncMode = m_eSyncMode; return RET_STATUS::RET_SUCCEED; } RET_STATUS nsFPD::FPDDeviceKonica::PrepareAcquisition() { FINFO("--Func-- PrepareAcquisition"); RET_STATUS ret = RET_STATUS::RET_FAILED; if (!m_bDeviceConnect) { FERROR("m_bDeviceConnect is false, detector not connect, return"); return ret; } //先检查设备内是否有未上传的图，如果有的话，后续需要通知APP是否进行图像的恢复或者舍弃 //如果探测器已经处于采集状态，那么不调用此函数 if (!m_bEnterAcqStatus) { if (g_pDetector->CheckImageInDetector(this)) { ret = RET_STATUS::RET_SUCCEED; } else { ret = RET_STATUS::RET_FAILED; return ret; } } if (g_pDetector->StopAcquisition(this)) { ret = RET_STATUS::RET_SUCCEED; m_bEnterAcqStatus = false; } else { FERROR("StopAcquisition fail!"); ret = RET_STATUS::RET_FAILED; return ret; } if (g_pDetector->PrepareAcquisition(this)) { ret = RET_STATUS::RET_SUCCEED; } else { FERROR("PrepareAcquisition fail!"); ret = RET_STATUS::RET_FAILED; } FINFO("PrepareAcquisition over"); return ret; } RET_STATUS nsFPD::FPDDeviceKonica::StartAcquisition(string in) { printf("--Func-- StartAcquisition \r\n"); FINFO("--Func-- StartAcquisition"); RET_STATUS ret = RET_STATUS::RET_FAILED; if (!m_bDeviceConnect) { FERROR("m_bDeviceConnect is false, detector not connect, return"); return ret; } if (g_pDetector->StartAcquisition(this)) { ret = RET_STATUS::RET_SUCCEED; m_DetectorCtrlUnit->SetDetectorStatus(to_string(DETECTOR_STATUS_ACQ));//StartAcquisition m_SyncUnit->XWindowOnNotify();//StartAcquisition } else { FERROR("StartAcquisition fail!"); return ret; } FINFO("StartAcquisition over"); return ret; } RET_STATUS nsFPD::FPDDeviceKonica::StopAcquisition() { printf("--Func-- StopAcquisition \r\n"); FINFO("--Func-- StopAcquisition"); RET_STATUS ret = RET_STATUS::RET_FAILED; if (!m_bDeviceConnect) { FERROR("m_bDeviceConnect is false, detector not connect, return"); return ret; } if (g_pDetector->StopAcquisition(this)) { ret = RET_STATUS::RET_SUCCEED; m_DetectorCtrlUnit->SetDetectorStatus(to_string(DETECTOR_STATUS_STANDBY));//StopAcquisition m_bEnterAcqStatus = false; } FINFO("StopAcquisition over"); return ret; } RET_STATUS nsFPD::FPDDeviceKonica::ActiveCalibration(CCOS_CALIBRATION_TYPE eType) { printf("--Func-- ActiveCalibration %d \r\n", eType); FINFO("--Func-- ActiveCalibration {$}", (int)eType); RET_STATUS ret = RET_STATUS::RET_FAILED; if (!m_bDeviceConnect) { FERROR("m_bDeviceConnect is false, detector not connect, return"); return ret; } if (eType == CCOS_CALIBRATION_TYPE_NONE || eType == CCOS_CALIBRATION_TYPE_MAX) { FERROR("calibration type is invalid!"); return RET_STATUS::RET_INVALID; } else { m_CalibType = eType; } FINFO("m_bEnterAcqStatus:{$}", m_bEnterAcqStatus); ret = StopAcquisition(); if (ret != RET_STATUS::RET_SUCCEED) { FERROR("StopAcquisition fail!"); return ret; } m_eAppStatus = APP_STATUS_CAL_BEGIN; if (eType == CCOS_CALIBRATION_TYPE_XRAY) { FINFO("calibration type: XRAY"); int nCalibrationRounds = (int)m_CalibDoseList.size(); g_pDetector->SetCalibRounds(nCalibrationRounds); } if (g_pDetector->ActiveCalibration(this, eType)) { ret = RET_STATUS::RET_SUCCEED; m_CalibUnit->SetCalibrationStatus(to_string(CCOS_CALIBRATION_STATUS_ACTIVE)); m_CalibUnit->SetCalibrationProgress("0"); } else { FERROR("Active calibration failed"); ret = RET_STATUS::RET_FAILED; } //重置校正流程参数 m_nCalibCurrentCalibrationRound = 1; m_nCalibCurrentExposureIndex = 1; m_nCalibCurrentExposureNum = 0; FINFO("ActiveCalibration over"); return ret; } RET_STATUS nsFPD::FPDDeviceKonica::PrepareCalibration() { printf("--Func-- PrepareCalibration------ \n"); FINFO("--Func-- PrepareCalibration"); RET_STATUS ret = RET_STATUS::RET_FAILED; if (!m_bDeviceConnect) { FERROR("m_bDeviceConnect is false, detector not connect, return"); return ret; } if (g_pDetector->PrepareCalibration(this)) { m_CalibUnit->SetCalibrationStatus(to_string(CCOS_CALIBRATION_STATUS_PREPARE)); m_DetectorCtrlUnit->SetDetectorStatus(to_string(DETECTOR_STATUS_STANDBY));//PrepareCalibration ret = RET_STATUS::RET_SUCCEED; } else { printf("PrepareCalibration failed!\n"); FERROR("PrepareCalibration failed!"); return ret; } FINFO("--Func-- PrepareCalibration over"); return ret; } RET_STATUS nsFPD::FPDDeviceKonica::GetRequestedDose(std::string& strDose) { FINFO("--Func-- GetRequestedDose"); RET_STATUS ret = RET_STATUS::RET_FAILED; ResDataObject out; if (!m_bDeviceConnect) { FERROR("m_bDeviceConnect is false, detector not connect, return"); return ret; } CCOS_CALIBRATION_TYPE nCalibrationType = m_CalibUnit->GetCalibrationType(); FINFO("GetRequestedDose calib type is {$}", (int)nCalibrationType); if (CCOS_CALIBRATION_TYPE_DARK == nCalibrationType) { out.add("Dose", 0.0f); out.add("kV", 0.0f); out.add("mA", 0.0f); out.add("ms", 0.0f); out.add("mAs", 0.0f); } else if (CCOS_CALIBRATION_TYPE_XRAY == nCalibrationType) { FINFO("calib dose list size is {$}", m_CalibDoseList.size()); ResDataObject temp = m_CalibDoseList[m_nCalibCurrentCalibrationRound - 1]; int nTargetExi = (int)temp["TargetGainEXI"]; m_DetectorCtrlUnit->SetTargetEXI(std::to_string(nTargetExi)); FINFO("nTargetExi:{$}", nTargetExi); out.add("Dose", nTargetExi); out.add("kV", temp["KV"]); out.add("mA", temp["MA"]); out.add("ms", temp["MS"]); out.add("mAs", temp["MAS"]); } else { FERROR("Don't support CalibrationType($)", (int)nCalibrationType); return ret; } strDose = out.encode(); FINFO("GetRequestedDose:{$}", strDose); ret = RET_STATUS::RET_SUCCEED; FINFO("--Func-- GetRequestedDose over"); return ret; } RET_STATUS nsFPD::FPDDeviceKonica::SetRequestedDose(std::string strDose) { FINFO("--Func-- SetRequestedDose"); RET_STATUS Ret = RET_STATUS::RET_SUCCEED; return Ret; } RET_STATUS nsFPD::FPDDeviceKonica::GetCalibrationStep(int nDetectorID, string& strCalibrationStepInfo) { printf("--Func-- GetCalibrationStep\n"); FINFO("--Func-- GetCalibrationStep DetectorID:{$}", nDetectorID); RET_STATUS ret = RET_STATUS::RET_SUCCEED; ResDataObject out; int nCalibrationRounds = (int)m_CalibDoseList.size(); int nExposureNumCurrentRound = (int)m_CalibDoseList[m_nCalibCurrentCalibrationRound - 1]["ExpNum"]; if (g_pDetector->GetCalibrationStep(m_nCalibCurrentCalibrationRound, nCalibrationRounds, m_nCalibCurrentExposureIndex, nExposureNumCurrentRound)) { FINFO("GetCalibrationStep success"); } else { FERROR("GetCalibrationStep error"); ret = RET_STATUS::RET_FAILED; return ret; } out.add("CalibrationRounds", (int)m_CalibDoseList.size()); out.add("TotalExposureNum", m_nCalibTotalExposureNum); out.add("CurrentCalibrationRound", m_nCalibCurrentCalibrationRound); out.add("ExposureNumCurrentRound", (int)m_CalibDoseList[m_nCalibCurrentCalibrationRound - 1]["ExpNum"]); out.add("CurrentExposureIndex", m_nCalibCurrentExposureIndex); out.add("CurrentExposureNum", m_nCalibCurrentExposureNum); strCalibrationStepInfo = out.encode(); FINFO("GetCalibrationStep over,strCalibrationStepInfo: {$}", strCalibrationStepInfo.c_str()); return ret; } RET_STATUS nsFPD::FPDDeviceKonica::StartCalibration() { printf("--Func-- StartCalibration \r\n"); FINFO("--Func-- StartCalibration"); RET_STATUS ret = RET_STATUS::RET_FAILED; if (!m_bDeviceConnect) { FERROR("m_bDeviceConnect is false, detector not connect, return"); return ret; } if (m_CalibUnit->GetCalibrationStatus() != CCOS_CALIBRATION_STATUS_PREPARE) { printf("CCOS_CALIBRATION_STATUS = %d\r\n", (int)m_CalibUnit->GetCalibrationStatus()); FERROR("Start calibration failed, in {$} status", (int)m_CalibUnit->GetCalibrationStatus()); return ret; } if (g_pDetector->StartCalibration(this)) { printf("start calibration success set detector status\n"); FINFO("start calibration success set detector status"); m_CalibUnit->SetCalibrationStatus(to_string(CCOS_CALIBRATION_STATUS_RUNNING)); m_DetectorCtrlUnit->SetDetectorStatus(to_string(DETECTOR_STATUS_ACQ));//StartCalibration ret = RET_STATUS::RET_SUCCEED; } else { FERROR("StartCalibration failed"); ret = RET_STATUS::RET_FAILED; return ret; } FINFO("StartCalibration over"); return ret; } RET_STATUS nsFPD::FPDDeviceKonica::StopCalibration() { FINFO("--Func-- StopCalibration"); RET_STATUS ret = RET_STATUS::RET_FAILED; if (!m_bDeviceConnect) { FERROR("m_bDeviceConnect is false, detector not connect, return"); return ret; } m_eAppStatus = APP_STATUS_CAL_END; if (g_pDetector->StopCalibration(this)) { ret = RET_STATUS::RET_SUCCEED; m_CalibUnit->SetCalibrationStatus(to_string(CCOS_CALIBRATION_STATUS_BESTOPPED)); } else { FERROR("StopCalibration failed"); } ret = StopAcquisition(); if (ret != RET_STATUS::RET_SUCCEED) { FERROR("StopAcquisition fail!"); return ret; } FINFO("StopCalibration over"); return ret; } void nsFPD::FPDDeviceKonica::AbortCalibration() { FINFO("--Func-- AbortCalibration"); m_eAppStatus = APP_STATUS_CAL_END; CCOS_CALIBRATION_TYPE nCalibrationType = m_CalibUnit->GetCalibrationType(); m_DetectorCtrlUnit->SetDetectorStatus(to_string(DETECTOR_STATUS_STANDBY));//AbortCalibration m_CalibUnit->SetCalibrationStatus(to_string(CCOS_CALIBRATION_STATUS_ERROR)); m_CalibUnit->SetCalibrationProgress("100"); if(CCOS_CALIBRATION_TYPE_XRAY == nCalibrationType) { g_pDetector->AbortCalibration(this); m_AcqUnit->SendNoNeedWaitImage(true); } //如果中止的时候探测器在采集状态需要停止采集 FINFO("--Func-- AbortCalibration over"); } RET_STATUS nsFPD::FPDDeviceKonica::AcceptCalibration() { FINFO("--Func-- AcceptCalibration"); RET_STATUS Ret = RET_STATUS::RET_SUCCEED; if (g_pDetector->AcceptCalibration()) { FINFO("AcceptCalibration over"); Ret = RET_STATUS::RET_SUCCEED; } else { FERROR("AcceptCalibration error"); Ret = RET_STATUS::RET_FAILED; } int nExposureNumCurrentRound = (int)m_CalibDoseList[m_nCalibCurrentCalibrationRound - 1]["ExpNum"]; //完成校正条件：轮数够了，曝光次数够了 if ((m_nCalibCurrentCalibrationRound == (int)m_CalibDoseList.size()) && (m_nCalibCurrentExposureIndex == nExposureNumCurrentRound)) { FINFO("Calibration Round: {$}, Exposure Index: {$}, Finished", m_nCalibCurrentCalibrationRound, m_nCalibCurrentExposureIndex); m_DetectorCtrlUnit->SetDetectorStatus(to_string(DETECTOR_STATUS_STANDBY));//AcceptCalibration1 m_CalibUnit->SetCalibrationStatus(to_string(CCOS_CALIBRATION_STATUS_STANDBY)); m_CalibUnit->SetCalibrationProgress("100"); return Ret; } if (m_nCalibCurrentExposureIndex >= nExposureNumCurrentRound) //跳到下一轮校正参数 { m_nCalibCurrentCalibrationRound++; m_nCalibCurrentExposureIndex = 1; } else { m_nCalibCurrentExposureIndex++; } m_nCalibCurrentExposureNum++; m_DetectorCtrlUnit->SetDetectorStatus(to_string(DETECTOR_STATUS_STANDBY));//AcceptCalibration2 FINFO("--Func-- AcceptCalibration over"); return Ret; } RET_STATUS nsFPD::FPDDeviceKonica::RejectCalibration() { printf("--Func-- RejectCalibration \n"); FINFO("--Func-- RejectCalibration"); RET_STATUS Ret = RET_STATUS::RET_SUCCEED; if (g_pDetector->RejectCalibration()) { Ret = RET_STATUS::RET_SUCCEED; } else { FERROR("RejectCalibration error"); Ret = RET_STATUS::RET_FAILED; } m_DetectorCtrlUnit->SetDetectorStatus(to_string(DETECTOR_STATUS_STANDBY));//RejectCalibration FINFO("--Func-- RejectCalibration over"); return Ret; } bool nsFPD::FPDDeviceKonica::CompleteCalibration() { printf("--Func-- CompleteCalibration \n"); FINFO("--Func-- CompleteCalibration"); if (!g_pDetector->CompleteCalibration(this)) { FERROR("CompleteCalibration fail!"); return false; } if (g_pDetector->GetCalibType() == CCOS_CALIBRATION_TYPE_DARK) { printf("CompleteCalibration Calibration Type DARK\n"); FINFO("CompleteCalibration Calibration Type DARK"); } else if (g_pDetector->GetCalibType() == CCOS_CALIBRATION_TYPE_XRAY) { printf("CompleteCalibration Calibration Type XRAY\n"); FINFO("CompleteCalibration Calibration Type XRAY"); m_eAppStatus = APP_STATUS_CAL_END; } FINFO("CompleteCalibration set detector status standby"); m_DetectorCtrlUnit->SetDetectorStatus(to_string(DETECTOR_STATUS_STANDBY));//CompleteCalibration m_CalibUnit->SetCalibrationStatus(to_string(CCOS_CALIBRATION_STATUS_STANDBY)); m_CalibUnit->SetCalibrationProgress("100"); FINFO("--Func-- CompleteCalibration over"); return true; } RET_STATUS nsFPD::FPDDeviceKonica::SaveCalibrationFile(bool bSaveFlag) { printf("--Func-- SaveCalibrationFile \n"); FINFO("--Func-- SaveCalibrationFile"); RET_STATUS Ret = RET_STATUS::RET_SUCCEED; FINFO("SaveCalibrationFile bSaveFlag: {$}", bSaveFlag); if (!bSaveFlag) { FERROR("Not save calibration file"); return Ret; } //点击save按钮时先调用compelte再调用save CompleteCalibration(); if (g_pDetector->SaveCalibrationFile()) { m_CalibUnit->SetSaveCalibrationFileFinish(true); Ret = RET_STATUS::RET_SUCCEED; //更新配置文件中校正日期和时间 time_t localtime = time(NULL); string strLocalTime = DatetimeToString(localtime); FINFO("strLocalTime:{$}", strLocalTime); m_CalibUnit->SetLastCalibrationDate(strLocalTime); //清除校正文件相关警告 m_WarnAndError->ClearWarn(ERR_FPD_CAL_FILE_NOT_EXIST); m_WarnAndError->ClearWarn(ERR_FPD_CAL_FILE_OUTDATE); } else { FERROR("SaveCalibrationFile error"); m_CalibUnit->SetSaveCalibrationFileFinish(false); Ret = RET_STATUS::RET_FAILED; } FINFO("--Func-- SaveCalibrationFile over"); return Ret; } bool nsFPD::FPDDeviceKonica::Support_DarkCalib() { return true; } bool nsFPD::FPDDeviceKonica::Support_XrayCalib() { return true; } void nsFPD::FPDDeviceKonica::SendTemperatureValue(float fValue) { int nStatus = 0; m_Temperature->SetTemperature(fValue, nStatus); FINFO("SendTemperatureValue: {$}, status {$}", fValue, nStatus); return; } void nsFPD::FPDDeviceKonica::SendWifiValue(int nValue) { int nStatus = 0; m_Wifi->SetSignalValue(nValue, nStatus); FINFO("SendWifiValue: {$}, status {$}", nValue, nStatus); return; } void nsFPD::FPDDeviceKonica::SendBatteryValue(int nValue) { int nStatus = 0; m_Battery->SetRemainPowerValue(nValue, nStatus); FINFO("SendBatteryValue: {$}, status {$}", nValue, nStatus); return; } bool nsFPD::FPDDeviceKonica::LoadConfig() { FINFO("--Func-- LoadConfig start"); if (!m_DetectorConfiguration->LoadConfigurations(m_stDeviceConfig, m_CalibDoseList, m_nCalibTotalExposureNum)) { FERROR("Load configuration file failed!!!"); return false; } FINFO("m_CalibDoseList:{$}", m_CalibDoseList.encode()); FINFO("m_nCalibTotalExposureNum:{$}", m_nCalibTotalExposureNum); //const char* strkey, int initialvalue, int min, int WarnMin, int WarnMax, int CalibWarnMin, int CalibWarnMax, int max, int accuracy, std::shared_ptr EventCenter m_Battery.reset(new DeviceBatteryMould("DetectorBattery", 0, m_stDeviceConfig.nBatteryLimit, m_stDeviceConfig.nBatteryWarning, 100, m_stDeviceConfig.nBatLowerLimitInCali, 100, 100, 0, EventCenter)); //const char* strkey, float initialvalue, float min, float WarnMin, float WarnMax, float CalibWarnMin, float CalibWarnMax, float max, float accuracy,std::shared_ptr EventCenter m_Temperature.reset(new DeviceTemperatureMould("DetectorTemperature", 0.0f, m_stDeviceConfig.fTemperatureErrorMin, m_stDeviceConfig.fTemperatureWarnMin, m_stDeviceConfig.fTemperatureWarnMax, m_stDeviceConfig.fTemperatureWarnMin, m_stDeviceConfig.fTemperatureWarnMax, m_stDeviceConfig.fTemperatureErrorMax, 0.0f, EventCenter)); //const char* strkey, int initialvalue, int min, int WarnMin, int WarnMax, int CalibWarnMin, int CalibWarnMax, int max, int accuracy, std::shared_ptr EventCenter m_Wifi.reset(new DeviceWifiMould("DetectorWifi", 0, m_stDeviceConfig.nWifiLimit, m_stDeviceConfig.nWifiWarning, 100, m_stDeviceConfig.nWifiWarning, 100, 100, 0, EventCenter)); FINFO("--Func-- LoadConfig end"); return true; } void nsFPD::FPDDeviceKonica::RegisterCtrl(nsDetail::Dispatch* Dispatch) { Dispatch->Action.Push(ActionKey::ActiveDetector, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSActiveDetector); Dispatch->Action.Push(ActionKey::AttachConnect, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSAttachConnect); Dispatch->Action.Push(ActionKey::CancelAttach, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSCancelAttach); Dispatch->Action.Push(ActionKey::DisConnectFPD, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSDisConnectFPD); Dispatch->Action.Push(ActionKey::UpdateFirmware, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSUpdateFirmware); Dispatch->Action.Push(ActionKey::GetFPDinformation, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSGetDetectorInfo); Dispatch->Action.Push(ActionKey::EnterExam, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSEnterExam); Dispatch->Action.Push(ActionKey::RecoverImage, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSRecoverImage); Dispatch->Action.Push(ActionKey::SaveSensitivity, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSSaveSensitivity); Dispatch->Action.Push(ActionKey::RESET, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSRESET); Dispatch->Action.Push(ActionKey::ExitExam, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSExitExam); Dispatch->Action.Push(ActionKey::SetExposureTimes, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSSetExposureTimes); Dispatch->Action.Push(ActionKey::SetXrayOnNum, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSSetXrayOnNum); Dispatch->Get.Push(AttrKey::DetectorConnectStatus, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSGetConnectStatus); Dispatch->Get.Push(AttrKey::DetectorInitialStatus, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSGetInitialStatus); Dispatch->Get.Push(AttrKey::DetectorUpdateFWStatus, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSGetUpdateFWStatus); Dispatch->Get.Push(AttrKey::FPDShockSensorInfo, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSGetShockSensorInfo); Dispatch->Get.Push(AttrKey::DetectorStatus, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSGetFPDStatus); Dispatch->Get.Push(AttrKey::FPDAttached, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSGetAttachStatus); Dispatch->Get.Push(AttrKey::DetectorAttach, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSGetAttachResult); Dispatch->Get.Push(AttrKey::FieldofViewShape, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSGetFieldofViewShape); Dispatch->Get.Push(AttrKey::FieldofViewDimension, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSGetFieldofViewDimension); Dispatch->Get.Push(AttrKey::DetectorType, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSGetDetectorType); Dispatch->Get.Push(AttrKey::Description, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSGetDescription); Dispatch->Get.Push(AttrKey::DetectorID, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSGetDetectorID); Dispatch->Get.Push(AttrKey::DateofLastDetectorCalibration, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSGetDateofLastDetectorCalibration); Dispatch->Get.Push(AttrKey::TimeofLastDetectorCalibration, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSGetTimeofLastDetectorCalibration); Dispatch->Get.Push(AttrKey::DetectorConditionsNominalFlag, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSGetDetectorConditionsNominalFlag); Dispatch->Get.Push(AttrKey::FPDSensitivity, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSGetFPDSensitivity); Dispatch->Get.Push(AttrKey::PixelData, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSGetPixelData); Dispatch->Get.Push(AttrKey::TargetEXI, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSGetTargetEXI); Dispatch->Get.Push(AttrKey::SupportSwitchResolution, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSGetSupportSwitchResolution); Dispatch->Get.Push(AttrKey::CurrentResolution, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSGetCurrentResolution); Dispatch->Get.Push(AttrKey::SerialNumber, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSGetSerialNumber); Dispatch->Get.Push(AttrKey::DetectorWiredIP, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSGetDetectorWiredIP); Dispatch->Get.Push(AttrKey::DetectorWirelessIP, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSGetDetectorWirelessIP); Dispatch->Get.Push(SupportDDR, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSGetSupportDDR); Dispatch->Get.Push(LocalIP, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSGetLocalIP); Dispatch->Get.Push(ShowTemperature, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSGetShowTemperature); Dispatch->Get.Push(ShowWifi, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSGetShowWifi); Dispatch->Get.Push(ShowBattery, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSGetShowBattery); Dispatch->Get.Push(ShowBluetooth, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSGetShowBluetooth); Dispatch->Set.Push(AttrKey::DetectorConnectStatus, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::SetDetectorStatus); Dispatch->Set.Push(AttrKey::DetectorStatus, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::SetDetectorStatus); Dispatch->Set.Push(AttrKey::DetectorType, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::SetDetectorType); Dispatch->Set.Push(AttrKey::Description, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::SetDescription); Dispatch->Set.Push(AttrKey::DetectorID, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::SetDetectorID); Dispatch->Set.Push(AttrKey::PixelData, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::SetPixelData); Dispatch->Set.Push(AttrKey::TargetEXI, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::SetTargetEXI); Dispatch->Set.Push(AttrKey::FPDAttached, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::SetAttachStatus); Dispatch->Set.Push(AttrKey::SupportSwitchResolution, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::SetSupportSwitchResolution); Dispatch->Set.Push(AttrKey::CurrentResolution, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::SetCurrentResolution); Dispatch->Set.Push(AttrKey::SerialNumber, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::SetSerialNumber); Dispatch->Set.Push(AttrKey::DetectorWiredIP, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::SetDetectorWiredIP); Dispatch->Set.Push(AttrKey::DetectorWirelessIP, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::SetDetectorWirelessIP); Dispatch->Set.Push(SupportDDR, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::SetSupportDDR); Dispatch->Set.Push(LocalIP, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::SetLocalIP); Dispatch->Set.Push(ShowTemperature, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::SetShowTemperature); Dispatch->Set.Push(ShowWifi, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::SetShowWifi); Dispatch->Set.Push(ShowBattery, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::SetShowBattery); Dispatch->Set.Push(ShowBluetooth, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::SetShowBluetooth); Dispatch->Update.Push(AttrKey::NotifyStatusTimePeriod, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSUpdateNotifyStatusTimePeriod); Dispatch->Update.Push(AttrKey::ReconnectTimePeriod, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSUpdateReconnectTimePeriod); Dispatch->Update.Push(AttrKey::DetectorWiredIP, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSUpdateDetectorWiredIP); Dispatch->Update.Push(AttrKey::DetectorWirelessIP, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSUpdateDetectorWirelessIP); Dispatch->Update.Push(AttrKey::SerialNumber, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSUpdateSerialNumber); Dispatch->Update.Push(LocalIP, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSUpdateLocalIP); Dispatch->Update.Push(ShowTemperature, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSUpdateShowTemperature); Dispatch->Update.Push(ShowWifi, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSUpdateShowWifi); Dispatch->Update.Push(ShowBattery, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSUpdateShowBattery); Dispatch->Update.Push(ShowBluetooth, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSUpdateShowBluetooth); } void nsFPD::FPDDeviceKonica::RegisterAcq(nsDetail::Dispatch* Dispatch) { Dispatch->Action.Push(ActionKey::SetAcqMode, m_AcqUnit.get(), &AcqUnit::JSSetAcqMode); Dispatch->Action.Push(ActionKey::SetResolution, m_AcqUnit.get(), &AcqUnit::JSSetResolution); Dispatch->Get.Push(AttrKey::AcqMode, m_AcqUnit.get(), &AcqUnit::JSGetAcqMode); Dispatch->Get.Push(AttrKey::ZskkFPDState, m_AcqUnit.get(), &AcqUnit::JSGetZskkFPDState); Dispatch->Get.Push(AttrKey::NoNeedWaitImage, m_AcqUnit.get(), &AcqUnit::JSGetNoNeedWaitImage); Dispatch->Get.Push(AttrKey::ImgDataInfo, m_AcqUnit.get(), &AcqUnit::JSGetLastImage); Dispatch->Set.Push(AttrKey::ZskkFPDState, m_AcqUnit.get(), &AcqUnit::SetZskkFPDState); Dispatch->Set.Push(AttrKey::NoNeedWaitImage, m_AcqUnit.get(), &AcqUnit::JSSetNoNeedWaitImage); } void nsFPD::FPDDeviceKonica::RegisterSync(nsDetail::Dispatch* Dispatch) { Dispatch->Action.Push(ActionKey::SetSyncMode, m_SyncUnit.get(), &SyncUnit::JSSetSyncMode); Dispatch->Action.Push(ActionKey::SetXwindowSize, m_SyncUnit.get(), &SyncUnit::JSSetXwindowSize); Dispatch->Action.Push(ActionKey::PrepareAcquisition, m_SyncUnit.get(), &SyncUnit::JSPrepareAcquisition); Dispatch->Action.Push(ActionKey::StartAcquisition, m_SyncUnit.get(), &SyncUnit::JSStartAcquisition); Dispatch->Action.Push(ActionKey::StopAcquisition, m_SyncUnit.get(), &SyncUnit::JSStopAcquisition); Dispatch->Action.Push(ActionKey::ActiveSyncMode, m_SyncUnit.get(), &SyncUnit::JSActiveSyncMode); Dispatch->Get.Push(AttrKey::FPDReadyStatus, m_SyncUnit.get(), &SyncUnit::JSGetFPDReady); Dispatch->Get.Push(AttrKey::XwindowStatus, m_SyncUnit.get(), &SyncUnit::JSGetXWindowStatus); Dispatch->Get.Push(AttrKey::ImageReadingStatus, m_SyncUnit.get(), &SyncUnit::JSGetImageReadingStatus); Dispatch->Get.Push(AttrKey::XrayON, m_SyncUnit.get(), &SyncUnit::JSGetXrayON); Dispatch->Get.Push(AttrKey::SyncMode, m_SyncUnit.get(), &SyncUnit::JSGetSyncMode); Dispatch->Get.Push(AttrKey::SupportSyncMode, m_SyncUnit.get(), &SyncUnit::JSGetSupportSyncMode); Dispatch->Set.Push(AttrKey::FPDReadyStatus, m_SyncUnit.get(), &SyncUnit::JSSetFPDReady); Dispatch->Set.Push(AttrKey::XwindowStatus, m_SyncUnit.get(), &SyncUnit::JSSetXWindowStatus); Dispatch->Set.Push(AttrKey::ImageReadingStatus, m_SyncUnit.get(), &SyncUnit::JSSetImageReadingStatus); Dispatch->Set.Push(AttrKey::SupportSyncMode, m_SyncUnit.get(), &SyncUnit::SetSupportSyncMode); } void nsFPD::FPDDeviceKonica::RegisterCalib(nsDetail::Dispatch* Dispatch) { Dispatch->Action.Push(ActionKey::ActiveCalibration, m_CalibUnit.get(), &CalibUnit::JSActiveCalibration); Dispatch->Action.Push(ActionKey::GetRequestedDose, m_CalibUnit.get(), &CalibUnit::JSGetRequestedDose); Dispatch->Action.Push(ActionKey::SetRequestedDose, m_CalibUnit.get(), &CalibUnit::JSSetRequestedDose); Dispatch->Action.Push(ActionKey::PrepareCalibration, m_CalibUnit.get(), &CalibUnit::JSPrepareCalibration); Dispatch->Action.Push(ActionKey::StartCalibration, m_CalibUnit.get(), &CalibUnit::JSStartCalibration); Dispatch->Action.Push(ActionKey::StopCalibration, m_CalibUnit.get(), &CalibUnit::JSStopCalibration); Dispatch->Action.Push(ActionKey::SetCorrectionType, m_CalibUnit.get(), &CalibUnit::JSSetCorrectionType); Dispatch->Action.Push(ActionKey::AcceptCalibration, m_CalibUnit.get(), &CalibUnit::JSAcceptCalibration); Dispatch->Action.Push(ActionKey::RejectCalibration, m_CalibUnit.get(), &CalibUnit::JSRejectCalibration); Dispatch->Action.Push(ActionKey::SaveCalibrationFile, m_CalibUnit.get(), &CalibUnit::JSSaveCalibrationFile); Dispatch->Action.Push(ActionKey::GetCalibrationStep, m_CalibUnit.get(), &CalibUnit::JSGetCalibrationStep); Dispatch->Get.Push(AttrKey::CalibrationStatus, m_CalibUnit.get(), &CalibUnit::JSGetCalibStatus); Dispatch->Get.Push(AttrKey::CalibrationProgress, m_CalibUnit.get(), &CalibUnit::JSGetCalibProgress); Dispatch->Get.Push(AttrKey::UploadCalibrationFilesResult, m_CalibUnit.get(), &CalibUnit::JSGetUploadCalibrationFilesResult); Dispatch->Get.Push(AttrKey::SupportCalibrationType, m_CalibUnit.get(), &CalibUnit::JSGetSupportCalibrationType); Dispatch->Get.Push(AttrKey::HaveImgCalibration, m_CalibUnit.get(), &CalibUnit::JSGetHaveImgCalibration); Dispatch->Get.Push(AttrKey::SaveCalibrationFileFinish, m_CalibUnit.get(), &CalibUnit::JSGetSaveCalibrationFileFinish); Dispatch->Get.Push(AttrKey::CalibMode, m_CalibUnit.get(), &CalibUnit::JSGetCalibMode); Dispatch->Get.Push(AttrKey::LastCalibrationDate, m_CalibUnit.get(), &CalibUnit::JSGetLastCalibrationDate); Dispatch->Get.Push(AttrKey::CalibrationFileExpireTime, m_CalibUnit.get(), &CalibUnit::JSGetCalibrationFileExpireTime); Dispatch->Get.Push(AttrKey::CalibrationFileExpirationReminder, m_CalibUnit.get(), &CalibUnit::JSGetCalibrationFileExpirationReminder); Dispatch->Set.Push(AttrKey::CalibrationStatus, m_CalibUnit.get(), &CalibUnit::SetCalibrationStatus); Dispatch->Set.Push(AttrKey::CalibrationProgress, m_CalibUnit.get(), &CalibUnit::SetCalibrationProgress); Dispatch->Set.Push(AttrKey::UploadCalibrationFilesResult, m_CalibUnit.get(), &CalibUnit::SetUploadCalibrationFilesResult); Dispatch->Set.Push(AttrKey::CalibMode, m_CalibUnit.get(), &CalibUnit::SetCalibMode); Dispatch->Set.Push(AttrKey::LastCalibrationDate, m_CalibUnit.get(), &CalibUnit::SetLastCalibrationDate); Dispatch->Set.Push(AttrKey::CalibrationFileExpireTime, m_CalibUnit.get(), &CalibUnit::SetCalibrationFileExpireTime); Dispatch->Set.Push(AttrKey::CalibrationFileExpirationReminder, m_CalibUnit.get(), &CalibUnit::SetCalibrationFileExpirationReminder); Dispatch->Update.Push(AttrKey::CalibMode, m_CalibUnit.get(), &CalibUnit::JSUpdateCalibMode); Dispatch->Update.Push(AttrKey::LastCalibrationDate, m_CalibUnit.get(), &CalibUnit::JSUpdateLastCalibrationDate); Dispatch->Update.Push(AttrKey::CalibrationFileExpireTime, m_CalibUnit.get(), &CalibUnit::JSUpdateCalibrationFileExpireTime); Dispatch->Update.Push(AttrKey::CalibrationFileExpirationReminder, m_CalibUnit.get(), &CalibUnit::JSUpdateCalibrationFileExpirationReminder); } void nsFPD::FPDDeviceKonica::RegisterOthers(nsDetail::Dispatch* Dispatch) { Dispatch->Get.Push(AttrKey::Temperature_Value, m_Temperature.get(), &DeviceTemperatureMould::JSGetCurrentTemperatureValue); Dispatch->Get.Push(AttrKey::Remain_Power_Value, m_Battery.get(), &DeviceBatteryMould::JSGetCurrentBatteryValue); Dispatch->Get.Push(AttrKey::Wifi_Strength_Value, m_Wifi.get(), &DeviceWifiMould::JSGetCurrentSignalValue); Dispatch->Get.Push(TempUpperLimit, m_Temperature.get(), &DeviceTemperatureMould::JSGetTemperatureWarningMax); Dispatch->Get.Push(TempLowerLimit, m_Temperature.get(), &DeviceTemperatureMould::JSGetTemperatureWarningMin); Dispatch->Get.Push(TempMaxLimit, m_Temperature.get(), &DeviceTemperatureMould::JSGetTemperatureErrorMax); Dispatch->Get.Push(TempMinLimit, m_Temperature.get(), &DeviceTemperatureMould::JSGetTemperatureErrorMin); Dispatch->Get.Push(TemperatureCalibUpWarn, m_Temperature.get(), &DeviceTemperatureMould::JSGetTemperatureCalibWarningMax); Dispatch->Get.Push(TemperatureCalibLowWarn, m_Temperature.get(), &DeviceTemperatureMould::JSGetTemperatureCalibWarningMin); Dispatch->Get.Push(BatLowerLimit, m_Battery.get(), &DeviceBatteryMould::JSGetBatteryWarningMin); Dispatch->Get.Push(BatMiniLimit, m_Battery.get(), &DeviceBatteryMould::JSGetBatteryErrorMin); Dispatch->Get.Push(BatLowerLimitInCali, m_Battery.get(), &DeviceBatteryMould::JSGetBatteryCalibWarningMin); Dispatch->Get.Push(WifiLowerLimit, m_Wifi.get(), &DeviceWifiMould::JSGetSignalWarningMin); Dispatch->Get.Push(WifiMiniLimit, m_Wifi.get(), &DeviceWifiMould::JSGetSignalErrorMin); //Error Dispatch->Get.Push(nDetail::AttrKey::ErrorList, m_WarnAndError.get(), &FPDErrorWarning::JSGetErrorList); Dispatch->Set.Push(TempUpperLimit, m_Temperature.get(), &DeviceTemperatureMould::SetTemperatureWarningMax); Dispatch->Set.Push(TempLowerLimit, m_Temperature.get(), &DeviceTemperatureMould::SetTemperatureWarningMin); Dispatch->Set.Push(TempMaxLimit, m_Temperature.get(), &DeviceTemperatureMould::SetTemperatureErrorMax); Dispatch->Set.Push(TempMinLimit, m_Temperature.get(), &DeviceTemperatureMould::SetTemperatureErrorMin); Dispatch->Set.Push(TemperatureCalibUpWarn, m_Temperature.get(), &DeviceTemperatureMould::SetTemperatureCalibWarningMax); Dispatch->Set.Push(TemperatureCalibLowWarn, m_Temperature.get(), &DeviceTemperatureMould::SetTemperatureCalibWarningMin); Dispatch->Set.Push(BatLowerLimit, m_Battery.get(), &DeviceBatteryMould::SetBatteryWarningMin); Dispatch->Set.Push(BatMiniLimit, m_Battery.get(), &DeviceBatteryMould::SetBatteryErrorMin); Dispatch->Set.Push(BatLowerLimitInCali, m_Battery.get(), &DeviceBatteryMould::SetBatLowerLimitInCalib); Dispatch->Set.Push(WifiLowerLimit, m_Wifi.get(), &DeviceWifiMould::SetSignalWarningMin); Dispatch->Set.Push(WifiMiniLimit, m_Wifi.get(), &DeviceWifiMould::SetSignalErrorMin); Dispatch->Update.Push(TempUpperLimit, m_Temperature.get(), &DeviceTemperatureMould::JSUpdateTemperatureWarningMax); Dispatch->Update.Push(TempLowerLimit, m_Temperature.get(), &DeviceTemperatureMould::JSUpdateTemperatureWarningMin); Dispatch->Update.Push(TempMaxLimit, m_Temperature.get(), &DeviceTemperatureMould::JSUpdateTemperatureErrorMax); Dispatch->Update.Push(TempMinLimit, m_Temperature.get(), &DeviceTemperatureMould::JSUpdateTemperatureErrorMin); Dispatch->Update.Push(TemperatureCalibUpWarn, m_Temperature.get(), &DeviceTemperatureMould::JSUpdateTemperatureCalibWarningMax); Dispatch->Update.Push(TemperatureCalibLowWarn, m_Temperature.get(), &DeviceTemperatureMould::JSUpdateTemperatureCalibWarningMin); Dispatch->Update.Push(BatLowerLimit, m_Battery.get(), &DeviceBatteryMould::JSUpdateBatteryWarningMin); Dispatch->Update.Push(BatMiniLimit, m_Battery.get(), &DeviceBatteryMould::JSUpdateBatteryErrorMin); Dispatch->Update.Push(BatLowerLimitInCali, m_Battery.get(), &DeviceBatteryMould::JSUpdateBatLowerLimitInCalib); Dispatch->Update.Push(WifiLowerLimit, m_Wifi.get(), &DeviceWifiMould::JSUpdateSignalWarningMin); Dispatch->Update.Push(WifiMiniLimit, m_Wifi.get(), &DeviceWifiMould::JSUpdateSignalErrorMin); } void nsFPD::FPDDeviceKonica::OnFPDCallback(int nDetectorID, int nEventID, int nEventLevel, const char* pszMsg, int nParam1, float fParam2, int nPtrParamLen, void* pParam) { switch (nEventLevel) { case EVT_LEVEL_CONFIGURATION: { OnEventProcessConf(nDetectorID, nEventID, nEventLevel, pszMsg, nParam1, fParam2, nPtrParamLen, pParam); break; } case EVT_LEVEL_INFORMATOION: { OnEventProcessInfo(nDetectorID, nEventID, nEventLevel, pszMsg, nParam1, fParam2, nPtrParamLen, pParam); break; } case EVT_LEVEL_STATUS: { OnEventProcessStatus(nDetectorID, nEventID, nEventLevel, pszMsg, nParam1, fParam2, nPtrParamLen, pParam); break; } case EVT_LEVEL_DATA: { OnEventProcessData(nDetectorID, nEventID, nEventLevel, pszMsg, nParam1, fParam2, nPtrParamLen, pParam); break; } case EVT_LEVEL_WARNING: { OnEventProcessWarning(nDetectorID, nEventID, nEventLevel, pszMsg, nParam1, fParam2, nPtrParamLen, pParam); break; } case EVT_LEVEL_ERROR: { OnEventProcessError(nDetectorID, nEventID, nEventLevel, pszMsg, nParam1, fParam2, nPtrParamLen, pParam); break; } default: break; } } void nsFPD::FPDDeviceKonica::OnEventProcessConf(int nDetectorID, int nEventID, int nEventLevel, const char* pszMsg, int nParam1, float fParam2, int nPtrParamLen, void* pParam) { switch (nEventID) { case EVT_CONF_PANEL_SERIAL: { m_stDeviceConfig.strPanelSerial = pszMsg; FINFO("Detector ID:{$}, SN {$}", nDetectorID, pszMsg); m_DetectorCtrlUnit->SetDetectorID(m_stDeviceConfig.strPanelSerial); break; } case EVT_CONF_RAW_WIDTH: { m_nFullImageWidth = nParam1; m_stDeviceConfig.nFullImageWidth = nParam1; FINFO("Detector ID:{$}, Image Width:{$}", nDetectorID, m_nFullImageWidth); break; } case EVT_CONF_RAW_HIGHT: { m_nFullImageHeight = nParam1; m_stDeviceConfig.nFullImageHeight = nParam1; FINFO("Detector ID:{$}, Image Height:{$}", nDetectorID, m_nFullImageHeight); break; } case EVT_CONF_RAW_BITS: { m_stDeviceConfig.nImageBits = nParam1; m_nImgBits = nParam1; FINFO("Detector ID:{$}, Image Bit:{$}", nDetectorID, m_nImgBits); break; } case EVT_CONF_PIXELSPACE: { m_stDeviceConfig.nPixelSpace = (int)fParam2; FINFO("Detector ID:{$}, nPixelSpace:{$}", nDetectorID, m_stDeviceConfig.nPixelSpace); break; } case EVT_CONF_PREVIEW_WIDTH: { m_nPreviewImageWidth = nParam1; m_stDeviceConfig.nPreviewWidth = nParam1; FINFO("Detector ID:{$}, nPreviewWidth:{$}", nDetectorID, m_nPreviewImageWidth); break; } case EVT_CONF_PREVIEW_HIGHT: { m_nPreviewImageHeight = nParam1; m_stDeviceConfig.nPreviewHeight = nParam1; FINFO("Detector ID:{$}, nPreviewHeight:{$}", nDetectorID, m_nPreviewImageHeight); break; } case EVT_CONF_MODULE_TYPE: { //m_strModuleType = pszMsg; FINFO("Detector ID:{$}, ModuleType {$}", nDetectorID, pszMsg); break; } case EVT_CONF_MODULE_IP: { //m_strModuleIP = pszMsg; FINFO("Detector ID:{$}, ModuleIP {$}", nDetectorID, pszMsg); break; } case EVT_CONF_MODULE_SN: { //m_strModuleSN = pszMsg; FINFO("Detector ID:{$}, ModuleSN {$}", nDetectorID, pszMsg); break; } case EVT_CONF_FIRWARE_UPDATE: { m_stDeviceConfig.nFirmwareStatus = nParam1; FINFO("Detector ID:{$}, FirmwareUpdate:{$}", nDetectorID, m_stDeviceConfig.nFirmwareStatus); break; } case EVT_CONF_PART_NUMBER: { m_stDeviceConfig.strPartNumber = pszMsg; FINFO("Detector ID:{$}, PartNumber:{$}", nDetectorID, pszMsg); break; } case EVT_CONF_BATTERY_SN: { //m_strBatterySN = pszMsg; FINFO("Detector ID:{$}, Battery SN:{$}", nDetectorID, pszMsg); break; } case EVT_CONF_WIFI_SSID: { m_stDeviceConfig.strWifiSSID = pszMsg; FINFO("Detector ID:{$}, WifiSSID:{$}", nDetectorID, pszMsg); break; } case EVT_CONF_IFBOARD: { m_stDeviceConfig.strInterfaceBoard = pszMsg; FINFO("Detector ID:{$}, InterfaceBoard:{$}", nDetectorID, pszMsg); break; } case EVT_CONF_DATECODE: { m_stDeviceConfig.strDateCode = pszMsg; FINFO("Detector ID:{$}, DateCode:{$}", nDetectorID, pszMsg); break; } case EVT_CONF_LIFETIME: { int nLifeTime = nParam1; if ((nLifeTime != m_stDeviceConfig.nLifeTime)) { FINFO("LifeTime:{$}", nLifeTime); m_stDeviceConfig.nLifeTime = nLifeTime; } break; } case EVT_CONF_SUPPORT_SWITCH_RESOLUTION: { int nSupportSwitchResolution = nParam1; FINFO("Detector ID:{$}, nSupportSwitchResolution:{$}", nDetectorID, nSupportSwitchResolution); if (nSupportSwitchResolution) { m_DetectorCtrlUnit->SetSupportSwitchResolution("1"); } else { m_DetectorCtrlUnit->SetSupportSwitchResolution("0"); } break; } case EVT_CONF_CURRENT_RESOLUTION: { int nCurrentResolution = nParam1; FINFO("Detector ID:{$}, nCurrentResolution:{$}", nDetectorID, nCurrentResolution); m_DetectorCtrlUnit->SetCurrentResolution(std::to_string(nCurrentResolution)); break; } default: break; } } void nsFPD::FPDDeviceKonica::OnEventProcessInfo(int nDetectorID, int nEventID, int nEventLevel, const char* pszMsg, int nParam1, float fParam2, int nPtrParamLen, void* pParam) { FERROR("Not support this info({$})", nEventID); } void nsFPD::FPDDeviceKonica::OnEventProcessStatus(int nDetectorID, int nEventID, int nEventLevel, const char* pszMsg, int nParam1, float fParam2, int nPtrParamLen, void* pParam) { switch (nEventID) { case EVT_STATUS_INIT: { FINFO("EVT_STATUS_INIT nParam1:{$}", nParam1); break; } case EVT_STATUS_PANEL: { PanelStatus m_ePanelStatus = (PanelStatus)nParam1; if (PANEL_CLOSE == nParam1) { FINFO("EVT_STATUS_PANEL PANEL_CLOSE"); m_bDeviceConnect = false; gDriver->m_bDriverConnect = false; m_DetectorCtrlUnit->SetDetectorStatus(to_string(DETECTOR_STATUS_SHUTDOWN)); m_DetectorCtrlUnit->SetConnectStatus(to_string(PANEL_DISCONNECT_SUCCESS)); m_WarnAndError->SendError(ERR_FPD_DISCONNECT, ""); } else if (PANEL_CONNECT == nParam1) { FINFO("EVT_STATUS_PANEL PANEL_CONNECT"); m_bDeviceConnect = true; gDriver->m_bDriverConnect = true; m_DetectorCtrlUnit->SetDetectorStatus(to_string(DETECTOR_STATUS_WAKEUP)); m_DetectorCtrlUnit->SetConnectStatus(to_string(PANEL_CONNECT_OK)); m_WarnAndError->ClearError(ERR_FPD_DISCONNECT); } else if (PANEL_STANDBY == nParam1) { FINFO("EVT_STATUS_PANEL PANEL_STANDBY"); m_bEnterAcqStatus = false; m_DetectorCtrlUnit->SetDetectorStatus(to_string(DETECTOR_STATUS_WAKEUP)); //检查界面曝光超时后，如果用户没有退出检查界面需要重新ready /*if (m_eAppStatus == APP_STATUS_WORK_BEGIN) { RET_STATUS ret = PrepareAcquisition(); if (ret != RET_SUCCEED) { FERROR("PrepareAcquisition fail!"); } }*/ } else if (PANEL_READY_EXP == nParam1) { FINFO("EVT_STATUS_PANEL PANEL_READY_EXP"); m_AcqUnit->SetZskkFPDState(to_string(ZSKK_FPD_STATE_READY)); m_DetectorCtrlUnit->SetDetectorStatus(to_string(DETECTOR_STATUS_STANDBY));//PANEL_READY_EXP m_WarnAndError->ClearAllError(); m_bEnterAcqStatus = true; } else if (PANEL_XWINDOW_ON == nParam1) //Xwindow On { m_stSystemTime = { 0 }; GetLocalTime(&m_stSystemTime); FINFO("XWindowOn at {$:d04}-{$:d02}-{$:d02} {$:d02}:{$:d02}:{$:d02}:{$:d03}", m_stSystemTime.wYear, m_stSystemTime.wMonth, m_stSystemTime.wDay, m_stSystemTime.wHour, m_stSystemTime.wMinute, m_stSystemTime.wSecond, m_stSystemTime.wMilliseconds); m_SyncUnit->XWindowOnNotify();//Xwindow On } else if (PANEL_XWINDOW_OFF == nParam1) // Xwindow Off { m_stSystemTime = { 0 }; GetLocalTime(&m_stSystemTime); FINFO("XWindowOff at {$:d04}-{$:d02}-{$:d02} {$:d02}:{$:d02}:{$:d02}:{$:d03}", m_stSystemTime.wYear, m_stSystemTime.wMonth, m_stSystemTime.wDay, m_stSystemTime.wHour, m_stSystemTime.wMinute, m_stSystemTime.wSecond, m_stSystemTime.wMilliseconds); m_SyncUnit->XWindowOffNotify(); } else if (PANEL_START_ACQ == nParam1) { FINFO("EVT_STATUS_PANEL PANEL_START_ACQ"); m_DetectorCtrlUnit->SetDetectorStatus(to_string(DETECTOR_STATUS_ACQ));//PANEL_START_ACQ m_bEnterAcqStatus = true; } else if (PANEL_XRAY_ON == nParam1) { FINFO("EVT_STATUS_PANEL PANEL_XRAY_ON"); m_SyncUnit->XrayOnNotify(); } else if (PANEL_XRAY_OFF == nParam1) { FINFO("EVT_STATUS_PANEL PANEL_XRAY_OFF"); m_SyncUnit->XrayOffNotify(); } else if (PANEL_READY_TIMEOUT == nParam1) { FINFO("EVT_STATUS_PANEL PANEL_READY_TIMEOUT"); m_WarnAndError->SendError(ERR_FPD_READY_TIMEOUT, ""); } else if (PANEL_SLEEP == nParam1) { FINFO("EVT_STATUS_PANEL PANEL_SLEEP"); m_bEnterAcqStatus = false; m_DetectorCtrlUnit->SetDetectorStatus(to_string(DETECTOR_STATUS_SLEEP)); } break; } case EVT_STATUS_CALIBRATIOIN: { FINFO("EVT_STATUS_PANEL EVT_STATUS_CALIBRATIOIN"); PanelEventState eStatus = (PanelEventState)nParam1; switch (eStatus) { case PANEL_EVENT_START: break; case PANEL_EVENT_END_OK: case PANEL_EVENT_END_ERROR: m_DetectorCtrlUnit->SetDetectorStatus(to_string(DETECTOR_STATUS_STANDBY));//EVT_STATUS_CALIBRATIOIN PANEL_EVENT_END_OK m_CalibUnit->SetCalibrationStatus(to_string(CCOS_CALIBRATION_STATUS_STANDBY)); m_CalibUnit->SetCalibrationProgress("100"); break; case PANEL_EVENT_TIMEOUT: break; default: break; } break; } case EVT_STATUS_SAVECALIB: { FINFO("EVT_STATUS_SAVECALIB"); PanelEventState eStatus = (PanelEventState)nParam1; switch (eStatus) { case PANEL_EVENT_START: { FINFO("save calib file start"); break; } case PANEL_EVENT_END: { FINFO("save calib file end"); break; } default: break; } break; } case EVT_STATUS_SINGLEEXP: { FINFO("EVT_STATUS_PANEL EVT_STATUS_SINGLEEXP"); if (DOSE_ACCEPT == nParam1) { FINFO("Calibration Result is acceptable"); m_DetectorCtrlUnit->SetDetectorStatus(to_string(DETECTOR_STATUS_STANDBY));//EVT_STATUS_SINGLEEXP DOSE_ACCEPT m_CalibUnit->PauseCalibration(); } else { FERROR("Not support this param({$})", nParam1); } break; } case EVT_STATUS_IMAGEPENDING: { FINFO("EVT_STATUS_PANEL EVT_STATUS_IMAGEPENDING"); m_WarnAndError->SendError(ERR_COMSERVER_ERROR, ""); break; } case EVT_STATUS_TEMPERATURE: { FINFO("EVT_STATUS_PANEL EVT_STATUS_TEMPERATURE"); float fTemperature = fParam2; // if (fTemperature > m_fTemperMaxLimit) // { // AddErrMsg("14", "temperature_toohigh"); // } // else if (fTemperature >= m_fTemperWarning) // { // AddWarnMsg("14", "temperature_high"); // } // else if (fTemperature < m_fTemperMinLimit) // { // AddErrMsg("14", "temperature_toolow"); // } // else if (fTemperature <= m_fTemperLowLimit) // { // AddWarnMsg("14", "temperature_low"); // } // else // { // DelErrMsg("14"); // } SendTemperatureValue(fTemperature); break; } case EVT_STATUS_WIFI: { FINFO("EVT_STATUS_PANEL EVT_STATUS_WIFI"); int nWifiLevel = nParam1; // if (nWifiLevel < m_nWifiLimit) // { // AddErrMsg("15", "wifi_toolow"); // } // else if (nWifiLevel <= m_nWifiWarning) // { // AddWarnMsg("15", "wifi_low"); // } // else // { // DelErrMsg("15"); // } SendWifiValue(nWifiLevel); break; } case EVT_STATUS_BATTERY_VALUE: { FINFO("EVT_STATUS_PANEL EVT_STATUS_BATTERY_VALUE"); int nBatteryValue = nParam1; // if (nBatteryValue < m_nBatteryLimit) // { // AddErrMsg("16", "battery_toolow"); // } // else if (nBatteryValue <= m_nBatteryWarning) // { // AddWarnMsg("16", "battery_low"); // } // else // { // DelErrMsg("16"); // } SendBatteryValue(nBatteryValue); break; } default: FERROR("Not support this event({$})", nEventID); break; } } string nsFPD::FPDDeviceKonica::MakeImageHead(IMAGE_VIEW_TYPE Type) { ResDataObject pFullImageHead; ResDataObject pPreviewImageHead; SYSTEMTIME SystemTime = { 0 }; GetLocalTime(&SystemTime); if (Type == IMAGE_FULL) { ResDataObject json; json.add(SM_IMAGE_TYPE, (int)Type); json.add(SM_IMAGE_BIT, m_nImgBits); json.add(SM_IMAGE_TAG, 1); json.add(SM_IMAGE_INDEX, 1); json.add(SM_IMAGE_YEAR, SystemTime.wYear); json.add(SM_IMAGE_MONTH, SystemTime.wMonth); json.add(SM_IMAGE_DAY, SystemTime.wDay); json.add(SM_IMAGE_HOUR, SystemTime.wHour); json.add(SM_IMAGE_MINUTE, SystemTime.wMinute); json.add(SM_IMAGE_SEC, SystemTime.wSecond); json.add(SM_IMAGE_MILLSEC, SystemTime.wMilliseconds); json.add(SM_IMAGE_LSB, "5000"); json.add(SM_IMAGE_DOSE, m_nSensitivity); json.add(SM_IMAGE_PIXELREPRESENTATION, "1"); json.add(SM_IMAGE_PIXELSPACING, m_nPixelSpacing); json.add(SM_IMAGE_FLIP, "No"); json.add(SM_IMAGE_ORIGINX, "0"); json.add(SM_IMAGE_ORIGINY, "0"); json.add(SM_IMAGE_EXI2UGY, m_fFactorEXI2UGY); json.add(SM_IMAGE_TEMP, 0.0f); if (90 == m_nAngle || 270 == m_nAngle) { json.add(SM_IMAGE_WIDTH, m_nFullImageHeight); json.add(SM_IMAGE_HEIGHT, m_nFullImageWidth); json.add(SM_IMAGE_ROTATION, "Yes"); } else { json.add(SM_IMAGE_WIDTH, m_nFullImageWidth); json.add(SM_IMAGE_HEIGHT, m_nFullImageHeight); json.add(SM_IMAGE_ROTATION, "No"); } pFullImageHead.add(SM_IMAGE_HEAD, json); return pFullImageHead.encode(); } else { ResDataObject json; json.add(SM_IMAGE_TYPE, (int)Type); json.add(SM_IMAGE_WIDTH, m_nPreviewImageWidth); json.add(SM_IMAGE_HEIGHT, m_nPreviewImageHeight); json.add(SM_IMAGE_BIT, m_nImgBits); json.add(SM_IMAGE_TAG, 1); json.add(SM_IMAGE_INDEX, 1); json.add(SM_IMAGE_YEAR, SystemTime.wYear); json.add(SM_IMAGE_MONTH, SystemTime.wMonth); json.add(SM_IMAGE_DAY, SystemTime.wDay); json.add(SM_IMAGE_HOUR, SystemTime.wHour); json.add(SM_IMAGE_MINUTE, SystemTime.wMinute); json.add(SM_IMAGE_SEC, SystemTime.wSecond); json.add(SM_IMAGE_MILLSEC, SystemTime.wMilliseconds); json.add(SM_IMAGE_LSB, "5000"); json.add(SM_IMAGE_DOSE, m_nSensitivity); json.add(SM_IMAGE_ROTATION, "No"); json.add(SM_IMAGE_FLIP, "No"); json.add(SM_IMAGE_ORIGINX, "0"); json.add(SM_IMAGE_ORIGINY, "0"); json.add(SM_IMAGE_PIXELSPACING, m_nPixelSpacing); json.add(SM_IMAGE_PIXELREPRESENTATION, "1"); json.add(SM_IMAGE_TEMP, m_stDeviceConfig.fCurrentTemperValue); pPreviewImageHead.add(SM_IMAGE_HEAD, json); return pPreviewImageHead.encode(); } } void nsFPD::FPDDeviceKonica::OnEventProcessData(int nDetectorID, int nEventID, int nEventLevel, const char* pszMsg, int nParam1, float fParam2, int nPtrParamLen, void* pParam) { switch (nEventID) { case EVT_DATA_RAW_IMAGE: { FINFO("EVT_DATA_RAW_IMAGE"); if (nullptr != m_pFullImgBuffer) { delete[]m_pFullImgBuffer; m_pFullImgBuffer = nullptr; } m_pFullImgBuffer = new WORD[m_nFullImageWidth * m_nFullImageHeight]; m_AcqUnit->ImagerPixelSpacingNotify(m_nPixelSpacing); if (m_nAngle == 90 || m_nAngle == 270) { m_AcqUnit->SetFulImageInfo(m_nFullImageWidth, m_nFullImageHeight, m_nImgBits, false); } else { m_AcqUnit->SetFulImageInfo(m_nFullImageHeight, m_nFullImageWidth, m_nImgBits, false); } memcpy(m_pFullImgBuffer, pParam, (size_t)m_nFullImageWidth * (size_t)m_nFullImageHeight * sizeof(WORD)); string strImageHeader = MakeImageHead(IMAGE_FULL); FINFO("Full image head: {$}", strImageHeader); if (0 != m_nAngle) { m_AcqUnit->RotateImage(m_pFullImgBuffer, m_nFullImageHeight, m_nFullImageWidth, m_nAngle); } m_AcqUnit->AddFrameWithRawHead(IMAGE_FULL, strImageHeader, m_pFullImgBuffer, m_nFullImageWidth * m_nFullImageHeight); FINFO("Add image over"); break; } case EVT_DATA_PREVIEW_IMAGE: { FINFO("EVT_DATA_PREVIEW_IMAGE"); if (m_nPreviewEnable) { m_AcqUnit->SetPrevImageInfo(true, m_nPreviewImageHeight, m_nPreviewImageWidth, 0); if (nullptr != m_pPreviewImgBuffer) { delete[] m_pPreviewImgBuffer; m_pPreviewImgBuffer = nullptr; } m_pPreviewImgBuffer = new WORD[m_nPreviewImageWidth * m_nPreviewImageHeight]; memcpy(m_pPreviewImgBuffer, pParam, (size_t)m_nPreviewImageWidth * (size_t)m_nPreviewImageHeight * sizeof(WORD)); string strImageHeader = MakeImageHead(IMAGE_PREVIEW); FINFO("Preview image head: {$}", strImageHeader); m_AcqUnit->AddFrameWithRawHead(IMAGE_PREVIEW, strImageHeader, m_pPreviewImgBuffer, m_nPreviewImageWidth * m_nPreviewImageHeight); } break; } case EVT_DATA_DOSEPARAM: { m_nTargetCalibExi = nParam1; FINFO("EVT_DATA_DOSEPARAM m_nTargetCalibExi:{$}", m_nTargetCalibExi); break; } default: FERROR("Not support this data({$})", nEventID); break; } } void nsFPD::FPDDeviceKonica::OnEventProcessError(int nDetectorID, int nEventID, int nEventLevel, const char* pszMsg, int nParam1, float fParam2, int nPtrParamLen, void* pParam) { switch (nEventID) { case EVT_ERR_COMMUNICATE: //{ // string strTemp = pszMsg; // if (strTemp.find("true") != std::string::npos) // { // AddErrMsg("0", "communication error"); // SendTemperatureValue(0); // SendWifiValue(0); // SendBatteryValue(0); // } // else if (strTemp.find("false") != std::string::npos) // { // DelErrMsg("0"); // } //} break; case EVT_ERR_INIT_FAILED: //{ // string strTemp = pszMsg; // if (strTemp.find("true") != std::string::npos) // { // AddErrMsg("6", "initialize error"); // } // else if (strTemp.find("false") != std::string::npos) // { // //一般不可恢复 // } //} break; default: FERROR("Not support this error({$})", nEventID); break; } } void nsFPD::FPDDeviceKonica::OnEventProcessWarning(int nDetectorID, int nEventID, int nEventLevel, const char* pszMsg, int nParam1, float fParam2, int nPtrParamLen, void* pParam) { FERROR("Not support this warn({$})", nEventID); } RET_STATUS nsFPD::FPDDeviceKonica::ActiveSyncMode(int nSyncMode) { FINFO("--Func-- ActiveSyncMode nSyncMode:{$}", nSyncMode); m_eSyncMode = (SYNC_MODE)nSyncMode; if (g_pDetector->ActiveSyncMode(nSyncMode)) { return RET_SUCCEED; } else { FERROR("ActiveSyncMode fail!"); return RET_FAILED; } } RET_STATUS nsFPD::FPDDeviceKonica::ActiveDetector(bool bActive) { FINFO("--Func-- ActiveDetector bActive:{$}", bActive); if (g_pDetector->ActiveDetector(this, bActive)) { if (bActive) { FINFO("ActiveDetector success!"); } else { FINFO("InActiveDetector success!"); } return RET_SUCCEED; } else { if (bActive) { FERROR("ActiveDetector fail!"); } else { FERROR("InActiveDetector fail!"); } return RET_FAILED; } } RET_STATUS nsFPD::FPDDeviceKonica::UpdateCalibMode(CCOS_CALIBRATION_MODE eCalibMode) { FINFO("--Func-- UpdateCalibMode eCalibMode:{$}", (int)eCalibMode); m_stDeviceConfig.nCalibMode = (int)eCalibMode; if (g_pDetector->UpdateCalibMode(eCalibMode)) { FINFO("UpdateCalibMode success!"); return RET_SUCCEED; } else { FERROR("UpdateCalibMode fail!"); return RET_FAILED; } } RET_STATUS nsFPD::FPDDeviceKonica::UpdateNotifyStatusTimePeriod(int nTime) { FINFO("--Func-- UpdateNotifyStatusTimePeriod nTime:{$}", nTime); m_stDeviceConfig.nNotifyStatusTimePeriod = nTime; g_pDetector->SetNotifyStatusTimePeriod(nTime); return RET_SUCCEED; } RET_STATUS nsFPD::FPDDeviceKonica::UpdateReconnectTimePeriod(int nTime) { FINFO("--Func-- UpdateReconnectTimePeriod nTime:{$}", nTime); m_stDeviceConfig.nReconnectTimePeriod = nTime; g_pDetector->SetReconnectTimePeriod(nTime); return RET_SUCCEED; } RET_STATUS nsFPD::FPDDeviceKonica::SetResolution(int nResolution) { FINFO("--Func-- SetResolution nResolution:{$}", nResolution); if (!m_bDeviceConnect) { FERROR("m_bDeviceConnect is false, detector not connect, return"); return RET_FAILED; } if (m_stDeviceConfig.nSupportSwitchResolution == 0) { FWARN("Current detector do not support switch resolution!"); return RET_SUCCEED; } if (g_pDetector->SetResolution(nResolution)) { FINFO("SetResolution success!"); m_DetectorCtrlUnit->SetDetectorStatus(to_string(DETECTOR_STATUS_WAKEUP));//SetResolution } else { FERROR("SetResolution fail!"); return RET_FAILED; } //通知ErrorList，让状态机重新走ready流程 m_WarnAndError->SendError(ERR_SWITCH_RESOLUTION, ""); /*RET_STATUS ret = PrepareAcquisition(); if(ret != RET_SUCCEED) { FERROR("PrepareAcquisition fail!"); return RET_FAILED; }*/ return RET_SUCCEED; } RET_STATUS nsFPD::FPDDeviceKonica::UpdateLastCalibrationDate(std::string in) { FINFO("--Func-- UpdateLastCalibrationDate in:{$}", in); m_stDeviceConfig.strLastCalibrationDate = in; return RET_SUCCEED; } RET_STATUS nsFPD::FPDDeviceKonica::UpdateCalibrationFileExpireTime(std::string in) { FINFO("--Func-- UpdateCalibrationFileExpireTime in:{$}", in); m_stDeviceConfig.strCalibrationFileExpireTime = in; return RET_SUCCEED; } RET_STATUS nsFPD::FPDDeviceKonica::UpdateCalibrationFileExpirationReminder(std::string in) { FINFO("--Func-- UpdateCalibrationFileExpirationReminder in:{$}", in); m_stDeviceConfig.strCalibrationFileExpirationReminder = in; return RET_SUCCEED; } /*** * 客户端获取探测器信息 ***/ RET_STATUS nsFPD::FPDDeviceKonica::GetDetectorInfo(string& strInfo) { FINFO("--Func-- GetDetectorInfo"); ResDataObject strDetectorInfo; if (m_stDeviceConfig.strPanelSerial == "") { FWARN("strPanelSerial is null, Send Default Info"); strDetectorInfo.add("DetectorName", "Simulator"); strDetectorInfo.add("DetectorSN", "Simulator"); strDetectorInfo.add("SSID", " "); strDetectorInfo.add("LifeTime", "0"); strDetectorInfo.add("PowerOn", "0"); strDetectorInfo.add("DateCode", " "); strDetectorInfo.add("PartNumber", " "); strDetectorInfo.add("WifiDataRate", " "); strDetectorInfo.add("WifiChannel", "0"); strDetectorInfo.add("DetectorExist", "0"); strDetectorInfo.add("SystemAS", "0"); strDetectorInfo.add("CalibrationDate", "0"); strDetectorInfo.add("CalibrationDue", "0"); strDetectorInfo.add("CalibrationExist", "0"); strDetectorInfo.add("CommunicationStatus", "0"); strDetectorInfo.add("DetectorTemperature", "0"); strDetectorInfo.add("FDCalibrationTemperature", "0"); strDetectorInfo.add("TemperatureStatus", "0"); strDetectorInfo.add("WaitTime", "0"); strDetectorInfo.add("DetectorWifiSignal", "0"); strDetectorInfo.add("DetectorBattery", "0"); strDetectorInfo.add("ShockSensor", "NULL"); strDetectorInfo.add("FirmwareUpdate", "0"); strInfo = strDetectorInfo.encode(); return RET_STATUS::RET_SUCCEED; } strDetectorInfo.add("DetectorName", m_stDeviceConfig.strDeviceName.c_str()); strDetectorInfo.add("DetectorSN", m_stDeviceConfig.strPanelSerial.c_str()); //strDetectorInfo.add("Firmware", m_stDeviceConfig.strFirmware.c_str()); //strDetectorInfo.add("APFirmware", "NULL"); //strDetectorInfo.add("Software", m_stDeviceConfig.strSoftware.c_str()); //strDetectorInfo.add("SSID", m_stDeviceConfig.strWifiSSID.c_str()); //strDetectorInfo.add("LifeTime", m_stDeviceConfig.nLifeTime); //strDetectorInfo.add("PowerOn", m_stDeviceConfig.nPowerOn); //strDetectorInfo.add("FD_Voltage_List1", m_strVoltage.c_str()); //strDetectorInfo.add("DateCode", m_stDeviceConfig.strDateCode.c_str()); //strDetectorInfo.add("PartNumber", m_stDeviceConfig.strPartNumber.c_str()); //strDetectorInfo.add("WifiDataRate", m_stDeviceConfig.nWifiDataRate); //strDetectorInfo.add("WifiChannel", m_stDeviceConfig.nWifiChannel); //strDetectorInfo.add("DetectorExist", m_stDeviceConfig.bExisted); //strDetectorInfo.add("SystemAS", m_stDeviceConfig.pDetModeInfoStruct[0].nWorkStation); strInfo = strDetectorInfo.encode(); return RET_STATUS::RET_SUCCEED; }