void getConfig( map<string,string> &config ) const { GET_CONFIG(DescriptorType); GET_CONFIG(DescriptorSize); GET_CONFIG(Quality); GET_CONFIG(Ratio); };
/* @req SWS_Gpt_00288 */ void Gpt_SetMode( Gpt_ModeType Mode ) { /* @req SWS_Gpt_00228 */ VALIDATE((STD_ON == Gpt_Global.initRun), GPT_SETMODE_SERVICE_ID, GPT_E_UNINIT); /* @req SWS_Gpt_00231 */ VALIDATE(((GPT_MODE_SLEEP == Mode) || (GPT_MODE_NORMAL == Mode)), GPT_SETMODE_SERVICE_ID, GPT_E_PARAM_MODE); /* @req SWS_Gpt_00164 */ if (GPT_MODE_SLEEP == Mode) { for (uint8 chnlCnt = 0; chnlCnt < GPT_CHANNEL_CNT; chnlCnt++) { if ((!Gpt_Global.Gpt_WakUpEnable[chnlCnt]) && (GPT_STATE_RUNNING == Gpt_Global.Gpt_ChannelState[chnlCnt])) { Gpt_StopTimer( GET_CONFIG(chnlCnt).GptChannelId); //Stop channels not configured/Enabled for wakeup } /* @req SWS_Gpt_00341 */ //No Wakeup timer started } } else { /* @req SWS_Gpt_00165 */ //Other timers are not started in Normal mode } /* @req SWS_Gpt_00151 */ Gpt_Global.mode = Mode; }
NavGraphRosRetriever(ros::NodeHandle &n) : n(n) { ros::NodeHandle privn("~"); GET_CONFIG(privn, n, "navgraph_file", cfg_navgraph_file_); if (cfg_navgraph_file_.empty()) { throw std::runtime_error("No navgraph file given"); } boost::filesystem::path p(cfg_navgraph_file_); p = boost::filesystem::absolute(p); cfg_navgraph_file_ = p.string(); ROS_INFO("Using navgraph path: %s", p.string().c_str()); if (boost::filesystem::exists(p)) { boost::filesystem::remove(p); } boost::filesystem::create_directories(p.parent_path()); sub_has_received_ = false; sub_navgraph_ = n.subscribe<fawkes_msgs::NavGraph>("navgraph", 10, &NavGraphRosRetriever::cb_navgraph, this); sub_init_timer_ = n.createWallTimer(ros::WallDuration(5.0), &NavGraphRosRetriever::cb_sub_init_timer, this); }
void OutputWindow::setCounterAlignment(Qt::Alignment align) { GET_CONFIG(); config.setValue("counter-alignment", (int)align); /// TODO }
void OutputWindow::setOverlayAlignment(Qt::Alignment align) { GET_CONFIG(); config.setValue("overlay-alignment", (int)align); /// TODO }
void OutputWindow::setCounterVisible(bool flag) { m_counterVisible = flag; m_counterText->setVisible(flag); m_counterBgRect->setVisible(flag); GET_CONFIG(); config.setValue("counter-visible", flag ? "true" : "false"); }
void OutputWindow::setOverlayText(QString text) { m_overlayText->setText(text); GET_CONFIG(); config.setValue("overlay-text", text); m_overlayBgRect->setPos(m_overlayText->pos()); m_overlayBgRect->setRect(m_overlayText->boundingRect().adjusted(0,13/2,0,0)); }
/* @req SWS_Gpt_00287 */ void Gpt_DisableNotification( Gpt_ChannelType Channel ) { /* @req SWS_Gpt_00227 */ VALIDATE((STD_ON == Gpt_Global.initRun), GPT_DISABLENOTIFICATION_SERVICE_ID, GPT_E_UNINIT); /* @req SWS_Gpt_00217 */ VALIDATE(IS_CHANNEL_VALID(Channel), GPT_DISABLENOTIFICATION_SERVICE_ID, GPT_E_PARAM_CHANNEL); /* @req SWS_Gpt_00379 */ VALIDATE((NULL != GET_CONFIG(Channel).GptNotification), GPT_DISABLENOTIFICATION_SERVICE_ID, GPT_E_PARAM_CHANNEL); /* @req SWS_Gpt_00015 */ Gpt_Global.Gpt_NotifEnable[Channel] = FALSE; }
/* @req SWS_Gpt_00279 */ void Gpt_GetVersionInfo( Std_VersionInfoType* VersionInfoPtr ) { const Std_VersionInfoType _Gpt_VersionInfo = { .vendorID = (uint16)GPT_VENDOR_ID, .moduleID = (uint16) GPT_MODULE_ID, .sw_major_version = (uint8)GPT_SW_MAJOR_VERSION, .sw_minor_version = (uint8)GPT_SW_MINOR_VERSION, .sw_patch_version = (uint8)GPT_SW_PATCH_VERSION, }; /* @req SWS_Gpt_00338 **/ VALIDATE( (VersionInfoPtr != NULL), GPT_GETVERSIONINFO_SERVICE_ID, GPT_E_PARAM_POINTER ); memcpy(VersionInfoPtr, &_Gpt_VersionInfo, sizeof(Std_VersionInfoType)); return; } #endif /* @req SWS_Gpt_00280 */ void Gpt_Init(const Gpt_ConfigType* ConfigPtr) { uint8 hwCh; /* @req SWS_Gpt_00307 */ VALIDATE ((STD_OFF == Gpt_Global.initRun), GPT_INIT_SERVICE_ID, GPT_E_ALREADY_INITIALIZED); /* @req SWS_Gpt_00294 */ VALIDATE((ConfigPtr != NULL), GPT_INIT_SERVICE_ID, GPT_E_PARAM_POINTER); /* @req SWS_Gpt_00107 */ memset(&Gpt_Global, 0, sizeof(Gpt_Global)); /* @req SWS_Gpt_00006 */ Gpt_Global.config = (const Gpt_ConfigType (*)[GPT_CHANNEL_CNT]) ConfigPtr; /*lint !e929 !e740 !e826 */ for (uint8 ch = 0; ch < GPT_CHANNEL_CNT; ch++) { hwCh = GET_CONFIG(ch).GptChannelId; Gpt_Global.channelMap[hwCh] = ch; Gpt_Global.Gpt_ChannelState[ch] = GPT_STATE_INITIALIZED; } Gpt_Hw_Init(ConfigPtr); /* @req SWS_Gpt_00339 */ Gpt_Global.mode = GPT_MODE_NORMAL; Gpt_Global.initRun = STD_ON; }
/* @req SWS_Gpt_00328 */ void Gpt_CheckWakeup( EcuM_WakeupSourceType WakeupSource ) { /* @req SWS_Gpt_00325 */ VALIDATE((STD_ON == Gpt_Global.initRun), GPT_CHECKWAKEUP_SERVICE_ID, GPT_E_UNINIT); for (uint8 chnlCnt = 0; chnlCnt < GPT_CHANNEL_CNT; chnlCnt++) { // Loop over all channels to check if Wakeup source is found if (Gpt_Global.Gpt_WakUpEnable[chnlCnt] && (GET_CONFIG(chnlCnt).GptWakeupSource == WakeupSource) && ( GPT_STATE_EXPIRED == Gpt_Global.Gpt_ChannelState[chnlCnt])) { /* @req SWS_Gpt_00321 */ EcuM_SetWakeupEvent(WakeupSource); break; } } return; }
void OutputWindow::setBlinkOverlay(bool flag, int speed) { m_blinkOverlayTimer.setInterval(speed); m_blinkOverlay = flag; if(flag) { m_blinkOverlayTimer.start(); } else { m_blinkOverlayTimer.stop(); if(m_overlayVisible); m_overlayText->show(); } GET_CONFIG(); config.setValue("blink-overlay", flag ? "true" : "false"); config.setValue("blink-speed", speed); }
/* @req SWS_Gpt_00290 */ void Gpt_EnableWakeup( Gpt_ChannelType Channel ) { uint8 chnlidx; /* @req SWS_Gpt_00230 */ VALIDATE((STD_ON == Gpt_Global.initRun), GPT_ENABLEWAKEUP_SERVICE_ID, GPT_E_UNINIT); /* @req SWS_Gpt_00216 */ VALIDATE(IS_CHANNEL_VALID(Channel), GPT_ENABLEWAKEUP_SERVICE_ID, GPT_E_PARAM_CHANNEL); chnlidx = Gpt_Global.channelMap[Channel]; /* @req SWS_Gpt_00216 */ VALIDATE(GET_CONFIG(chnlidx).GptEnableWakeup, GPT_ENABLEWAKEUP_SERVICE_ID, GPT_E_PARAM_CHANNEL); /* @req SWS_Gpt_00160 */ Gpt_Global.Gpt_WakUpEnable[chnlidx] = TRUE; }
/* @req SWS_Gpt_00283 */ Gpt_ValueType Gpt_GetTimeRemaining( Gpt_ChannelType Channel ) { /* @req SWS_Gpt_00223 */ VALIDATE_W_RV((STD_ON == Gpt_Global.initRun), GPT_GETTIMEREMAINING_SERVICE_ID, GPT_E_UNINIT, DEFAULT_RETURN_VALUE); /* @req SWS_Gpt_00211 */ VALIDATE_W_RV(IS_CHANNEL_VALID(Channel), GPT_GETTIMEREMAINING_SERVICE_ID, GPT_E_PARAM_CHANNEL, DEFAULT_RETURN_VALUE); if (GPT_STATE_INITIALIZED == Gpt_Global.Gpt_ChannelState[Channel]) { /* @req SWS_Gpt_00301 */ return DEFAULT_RETURN_VALUE; } /* @req SWS_Gpt_00305 */ // Expired - Counter Freeze at target if ((GPT_CH_MODE_ONESHOT == GET_CONFIG(Channel).GptChannelMode) && (GPT_STATE_EXPIRED == Gpt_Global.Gpt_ChannelState[Channel])) { return DEFAULT_RETURN_VALUE; } return Gpt_Hw_GetTimeRemaining(ChannelToHwChannel(Channel)); }
void OutputWindow::setWindowGeom(QRect geom) { scene()->setSceneRect(0,0,geom.size().width(),geom.size().height()); QPixmap bluePixmap(32,23); bluePixmap.fill(Qt::blue); m_pixmap->setPixmap(bluePixmap.scaled(geom.size())); if(m_drw) m_drw->setRect(scene()->sceneRect()); // if(verbose) // qDebug() << "SlideShowWindow: pos:"<<windowPos<<", size:"<<windowSize; resize(geom.width(),geom.height()); move(geom.x(),geom.y()); m_geom = geom; GET_CONFIG(); config.setValue("geom",tr("%1,%2,%3,%4").arg(geom.x()).arg(geom.y()).arg(geom.width()).arg(geom.height())); }
void getConfig( map<string,string> &config ) const { GET_CONFIG( Threshold ); }
int enic_get_vnic_config(struct enic *enic) { struct vnic_enet_config *c = &enic->config; int err; err = vnic_dev_get_mac_addr(enic->vdev, enic->mac_addr); if (err) { dev_err(enic_get_dev(enic), "Error getting MAC addr, %d\n", err); return err; } #define GET_CONFIG(m) \ do { \ err = vnic_dev_spec(enic->vdev, \ offsetof(struct vnic_enet_config, m), \ sizeof(c->m), &c->m); \ if (err) { \ dev_err(enic_get_dev(enic), \ "Error getting %s, %d\n", #m, err); \ return err; \ } \ } while (0) GET_CONFIG(flags); GET_CONFIG(wq_desc_count); GET_CONFIG(rq_desc_count); GET_CONFIG(mtu); GET_CONFIG(intr_timer_type); GET_CONFIG(intr_mode); GET_CONFIG(intr_timer_usec); GET_CONFIG(loop_tag); c->wq_desc_count = min_t(u32, ENIC_MAX_WQ_DESCS, max_t(u32, ENIC_MIN_WQ_DESCS, c->wq_desc_count)); c->wq_desc_count &= 0xffffffe0; /* must be aligned to groups of 32 */ c->rq_desc_count = min_t(u32, ENIC_MAX_RQ_DESCS, max_t(u32, ENIC_MIN_RQ_DESCS, c->rq_desc_count)); c->rq_desc_count &= 0xffffffe0; /* must be aligned to groups of 32 */ if (c->mtu == 0) c->mtu = 1500; c->mtu = min_t(u16, ENIC_MAX_MTU, max_t(u16, ENIC_MIN_MTU, c->mtu)); c->intr_timer_usec = min_t(u32, c->intr_timer_usec, vnic_dev_get_intr_coal_timer_max(enic->vdev)); dev_info(enic_get_dev(enic), "vNIC MAC addr %pM wq/rq %d/%d mtu %d\n", enic->mac_addr, c->wq_desc_count, c->rq_desc_count, c->mtu); dev_info(enic_get_dev(enic), "vNIC csum tx/rx %s/%s " "tso/lro %s/%s rss %s intr mode %s type %s timer %d usec " "loopback tag 0x%04x\n", ENIC_SETTING(enic, TXCSUM) ? "yes" : "no", ENIC_SETTING(enic, RXCSUM) ? "yes" : "no", ENIC_SETTING(enic, TSO) ? "yes" : "no", ENIC_SETTING(enic, LRO) ? "yes" : "no", ENIC_SETTING(enic, RSS) ? "yes" : "no", c->intr_mode == VENET_INTR_MODE_INTX ? "INTx" : c->intr_mode == VENET_INTR_MODE_MSI ? "MSI" : c->intr_mode == VENET_INTR_MODE_ANY ? "any" : "unknown", c->intr_timer_type == VENET_INTR_TYPE_MIN ? "min" : c->intr_timer_type == VENET_INTR_TYPE_IDLE ? "idle" : "unknown", c->intr_timer_usec, c->loop_tag); return 0; }
BOOL q5_config_block_show(BYTE *config) { uint32_t value= hextoulong(config); UserMessage(" Config Block: %.8s\r\n", config); UserMessageNum(" Page Select: %d = ", GET_CONFIG(value, Q5_MASK_PAGE_SELECT, Q5_SHIFT_PAGE_SELECT)); UserMessage("%s\r\n", GET_CONFIG(value, Q5_MASK_PAGE_SELECT, Q5_SHIFT_PAGE_SELECT) ? "True" : "False"); UserMessageNum(" Fast Write: %d = ", GET_CONFIG(value, Q5_MASK_FAST_WRITE, Q5_SHIFT_FAST_WRITE)); UserMessage("%s\r\n", GET_CONFIG(value, Q5_MASK_FAST_WRITE, Q5_SHIFT_FAST_WRITE) ? "True" : "False"); UserMessageNum(" Data Rate: %02d = ", GET_CONFIG(value, Q5_MASK_DATA_BIT_RATE, Q5_SHIFT_DATA_BIT_RATE)); UserMessageNum("%d * FC\r\n", GET_CONFIG(value, Q5_MASK_DATA_BIT_RATE, Q5_SHIFT_DATA_BIT_RATE) * 2 + 2); UserMessageNum(" Use AOR: %d = ", GET_CONFIG(value, Q5_MASK_USE_AOR, Q5_SHIFT_USE_AOR)); UserMessage("%s\r\n", GET_CONFIG(value, Q5_MASK_USE_AOR, Q5_SHIFT_USE_AOR) ? "True" : "False"); UserMessageNum(" Use PWD: %d = ", GET_CONFIG(value, Q5_MASK_USE_PWD, Q5_SHIFT_USE_PWD)); UserMessage("%s\r\n", GET_CONFIG(value, Q5_MASK_USE_PWD, Q5_SHIFT_USE_PWD) ? "True" : "False"); UserMessageNum(" PSK Carrier: %d = ", GET_CONFIG(value, Q5_MASK_PSK_CARRIER_FREQ, Q5_SHIFT_PSK_CARRIER_FREQ)); UserMessageNum("%d * FC\r\n", PSK_Rates[GET_CONFIG(value, Q5_MASK_PSK_CARRIER_FREQ, Q5_SHIFT_PSK_CARRIER_FREQ)]); UserMessageNum(" Modulation: %d = ", GET_CONFIG(value, Q5_MASK_MODULATION, Q5_SHIFT_MODULATION)); UserMessage("%s\r\n", (BYTE *) Q5_Modulation[GET_CONFIG(value, Q5_MASK_MODULATION, Q5_SHIFT_MODULATION)]); UserMessageNum(" Max Block: %d\r\n", GET_CONFIG(value, Q5_MASK_MAX_BLOCK, Q5_SHIFT_MAX_BLOCK)); UserMessageNum(" ST: %d = ", GET_CONFIG(value, Q5_MASK_ST, Q5_SHIFT_ST)); UserMessage("%s\r\n", GET_CONFIG(value, Q5_MASK_ST, Q5_SHIFT_ST) ? "True" : "False"); return TRUE; }
BOOL hitag2_config_block_show(BYTE *config, BYTE *password, BYTE *key) { BYTE value= hextobyte(config); // first byte only used as config UserMessage(" PWD Block (1): %.8s ", password); printhexreadable(password, 4); UserMessage("\r\n\r\n Key Block (2): %.8s ", key); printhexreadable(key, 4); UserMessage("\r\n\r\n Config Block (3): %.8s\r\n\r\n", config); UserMessageNum(" Page 1 & 2: %d = ", GET_CONFIG(value, HITAG2_MASK_PAGE_1_2_OTP_PROTECT, HITAG2_SHIFT_PAGE_1_2_OTP_PROTECT)); if(GET_CONFIG(value, HITAG2_MASK_SECURITY, HITAG2_SHIFT_SECURITY)) UserMessage("%s\r\n", GET_CONFIG(value, HITAG2_MASK_PAGE_1_2_OTP_PROTECT, HITAG2_SHIFT_PAGE_1_2_OTP_PROTECT) ? "No Read / No Write" : "Read / Write"); else UserMessage("%s\r\n", GET_CONFIG(value, HITAG2_MASK_PAGE_1_2_OTP_PROTECT, HITAG2_SHIFT_PAGE_1_2_OTP_PROTECT) ? "Page 1: No Read / No Write, Page 2: Read Only" : "Read / Write"); UserMessageNum(" Page 3: %d = ", GET_CONFIG(value, HITAG2_MASK_PAGE_3_OTP_PROTECT, HITAG2_SHIFT_PAGE_3_OTP_PROTECT)); UserMessage("%s\r\n", GET_CONFIG(value, HITAG2_MASK_PAGE_3_OTP_PROTECT, HITAG2_SHIFT_PAGE_3_OTP_PROTECT) ? "Read Only" : "Read / Write"); UserMessageNum(" Page 4 & 5: %d = ", GET_CONFIG(value, HITAG2_MASK_PAGE_4_5_PROTECT, HITAG2_SHIFT_PAGE_4_5_PROTECT)); UserMessage("%s\r\n", GET_CONFIG(value, HITAG2_MASK_PAGE_4_5_PROTECT, HITAG2_SHIFT_PAGE_4_5_PROTECT) ? "Read Only" : "Read / Write"); UserMessageNum(" Page 6 & 7: %d = ", GET_CONFIG(value, HITAG2_MASK_PAGE_6_7_PROTECT, HITAG2_SHIFT_PAGE_6_7_PROTECT)); UserMessage("%s\r\n", GET_CONFIG(value, HITAG2_MASK_PAGE_6_7_PROTECT, HITAG2_SHIFT_PAGE_6_7_PROTECT) ? "Read Only" : "Read / Write"); UserMessageNum(" Security: %d = ", GET_CONFIG(value, HITAG2_MASK_SECURITY, HITAG2_SHIFT_SECURITY)); UserMessage("%s\r\n", GET_CONFIG(value, HITAG2_MASK_SECURITY, HITAG2_SHIFT_SECURITY) ? "Crypto" : "Password"); UserMessageNum(" Mode: %d = ", GET_CONFIG(value, HITAG2_MASK_MODE, HITAG2_SHIFT_MODE)); UserMessage("%s\r\n", (BYTE *) Hitag2_Modes[GET_CONFIG(value, HITAG2_MASK_MODE, HITAG2_SHIFT_MODE)]); UserMessageNum(" Modulation: %d = ", GET_CONFIG(value, HITAG2_MASK_MODULATION, HITAG2_SHIFT_MODULATION)); UserMessage("%s\r\n", GET_CONFIG(value, HITAG2_MASK_MODULATION, HITAG2_SHIFT_MODULATION) ? "BiPhase" : "Manchester"); UserMessage("\r\n PWD Block (3): %.6s ", config + 2); printhexreadable(config + 2, 3); UserMessage("%s", "\r\n"); return TRUE; }
void getConfig( map<string, string> &config ) const { GET_CONFIG( param1 ); GET_CONFIG( param2 ); }
OutputWindow::OutputWindow() : QGraphicsView(new QGraphicsScene()) , m_url("") , m_pollDviz(false) , m_updateTime(1000) , m_isDataPoll(false) , m_slideId(-1) , m_slideName("") //, m_startStopButton(0) , m_countValue(0) , m_drw(0) , m_blinkCount(0) { // Setup graphics view setRenderHints(QPainter::Antialiasing | QPainter::TextAntialiasing | QPainter::SmoothPixmapTransform ); setCacheMode(QGraphicsView::CacheBackground); setViewportUpdateMode(QGraphicsView::BoundingRectViewportUpdate); setOptimizationFlags(QGraphicsView::DontSavePainterState); setViewportUpdateMode(QGraphicsView::SmartViewportUpdate); setTransformationAnchor(AnchorUnderMouse); setResizeAnchor(AnchorViewCenter); setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff); setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff); // Add pixmap item for background QPixmap bluePixmap(32,23); bluePixmap.fill(Qt::blue); m_pixmap = scene()->addPixmap(bluePixmap); // Background behind text m_counterBgRect = scene()->addRect(0,0,100,60,QPen(), Qt::black); m_counterBgRect->setZValue(99); // Add text (for use with clock) QFont font("Monospace", 50, 600); m_counterText = new QGraphicsSimpleTextItem("0"); m_counterText->setFont(font); m_counterText->setPen(QPen(Qt::black)); m_counterText->setBrush(Qt::white); m_counterText->setPos(0, -13); m_counterText->setZValue(100); scene()->addItem(m_counterText); // Background behind text m_overlayBgRect = scene()->addRect(0,300,100,60,QPen(), Qt::black); m_overlayBgRect->setZValue(99); // Add text (for use with clock) //QFont font("Monospace", 50, 600); m_overlayText = new QGraphicsSimpleTextItem("Hello, World!"); m_overlayText->setFont(font); m_overlayText->setPen(QPen(Qt::black)); m_overlayText->setBrush(Qt::white); m_overlayText->setPos(0, 300-13); m_overlayText->setZValue(100); scene()->addItem(m_overlayText); m_blinkOverlay = false; connect(&m_blinkOverlayTimer, SIGNAL(timeout()), this, SLOT(blinkOverlaySlot())); GET_CONFIG(); QPoint windowPos(1024,0); QPoint windowSize(1024,768); //QPoint windowPos(10,10); //QPoint windowSize = QPoint(640,480); QString windowGeomString = config.value("geom","1024,0,1024,768").toString(); if(!windowGeomString.isEmpty()) { QStringList list = windowGeomString.split(","); windowPos = QPoint(list[0].toInt(), list[1].toInt()); windowSize = QPoint(list[2].toInt(), list[3].toInt()); } setWindowGeom(QRect(windowPos.x(),windowPos.y(),windowSize.x(),windowSize.y())); bool frameless = config.value("frameless","true").toString() == "true"; if(frameless) setWindowFlags(Qt::FramelessWindowHint);// | Qt::ToolTip); connect(&m_pollDvizTimer, SIGNAL(timeout()), this, SLOT(initDvizPoll())); //connect(&m_pollImageTimer, SIGNAL(timeout()), this, SLOT(initImagePoll())); setUpdateTime(m_updateTime); //setUrl("http://10.10.9.90:8081/image"); //setUrl(""); //setPollDviz(true); setInputSource(config.value("source","dviz://192.168.0.10:8081/image").toString()); // m_startStopButton = new QPushButton("Start Counter"); // connect(m_startStopButton, SIGNAL(clicked()), this, SLOT(toggleCounter())); connect(&m_counterTimer, SIGNAL(timeout()), this, SLOT(counterTick())); m_counterTimer.setInterval(1000); // // m_startStopButton->show(); //toggleCounter(); setCounterActive(false); setBlinkOverlay(config.value("blink-overlay","false").toString() == "true", config.value("blink-speed", 333).toInt()); //setOverlayVisible(config.value("overlay-visible", "true").toString() == "true"); setCounterVisible(config.value("counter-visible", "true").toString() == "true"); setCounterAlignment((Qt::Alignment)config.value("counter-alignment", (int)(Qt::AlignLeft | Qt::AlignTop)).toInt()); setOverlayAlignment((Qt::Alignment)config.value("overlay-alignment", (int)(Qt::AlignCenter | Qt::AlignBottom)).toInt()); setOverlayText(config.value("overlay-text").toString()); }
/* * Dump the devspec */ int usd_dump_devspec( struct usd_qp_impl *qp) { struct vnic_enet_config config; struct vnic_enet_config *c; int ret; c = &config; memset(&config, 0, sizeof(config)); GET_CONFIG(flags); GET_CONFIG(wq_desc_count); GET_CONFIG(rq_desc_count); GET_CONFIG(mtu); GET_CONFIG(intr_timer_deprecated); GET_CONFIG(intr_timer_type); GET_CONFIG(intr_mode); GET_CONFIG(intr_timer_usec); GET_CONFIG(loop_tag); GET_CONFIG(vf_rq_count); GET_CONFIG(num_arfs); GET_CONFIG(mem_paddr); ret = vnic_dev_spec(qp->uq_vf->vf_vdev, usd_offset_of(struct vnic_enet_config, devname), 8, &c->devname[0]); ret |= vnic_dev_spec(qp->uq_vf->vf_vdev, usd_offset_of(struct vnic_enet_config, devname) + 8, 8, &c->devname[8]); printf("devname = \"%s\", ret = %d\n", c->devname, ret); return 0; }
void OutputWindow::setInputSource(QString source) { if(m_drw) { scene()->removeItem(m_drw); delete m_drw; m_drw = 0; } GET_CONFIG(); config.setValue("source",source); qDebug() << "OutputWindow::setInputSource: source:"<<source; if(source.startsWith("dviz:") || source.startsWith("http:")) { setUrl(source.replace("dviz:","http:")); setPollDviz(true); m_pixmap->show(); qDebug() << "OutputWindow: dviz source:"<<source; } else if(source.startsWith("tx:") || source.startsWith("raw:")) { setPollDviz(false); // ex: tx://192.168.0.18:7758 source = source.replace("tx://",""); source = source.replace("raw://",""); QStringList hostPort = source.split(":"); QString host = hostPort[0]; int port = hostPort[1].toInt(); m_rx = VideoReceiver::getReceiver(host, port); if(!m_rx) { qDebug() << "OutputWindow: Error connecting to source "<<source; } else { qDebug() << "OutputWindow: raw source, host:"<<host<<", port:"<<port<<", rx:"<<m_rx; } m_drw = new GLVideoDrawable(); m_drw->setVideoSource(m_rx); m_drw->setPos(0,0); m_drw->setRect(scene()->sceneRect()); scene()->addItem(m_drw); m_drw->show(); m_drw->setZIndex(-99); m_pixmap->hide(); } else { // assume it's a capture device // CameraThread *cam = CameraThread::threadForCamera(source); // if(!cam) // { // qDebug() << "OutputWindow: Unable to locate input source: "<<source; // } // // m_drw = new GLDrawable(); // m_drw->setVideoSource(cam); // m_drw->setPos(0,0); // m_drw->setRect(scene()->sceneRect()); // // m_pixmap->hide(); } }
int enic_get_vnic_config(struct enic *enic) { struct vnic_enet_config *c = &enic->config; int err; err = vnic_dev_mac_addr(enic->vdev, enic->mac_addr); if (err) { dev_err(enic_get_dev(enic), "Error getting MAC addr, %d\n", err); return err; } #define GET_CONFIG(m) \ do { \ err = vnic_dev_spec(enic->vdev, \ offsetof(struct vnic_enet_config, m), \ sizeof(c->m), &c->m); \ if (err) { \ dev_err(enic_get_dev(enic), \ "Error getting %s, %d\n", #m, err); \ return err; \ } \ } while (0) GET_CONFIG(flags); GET_CONFIG(wq_desc_count); GET_CONFIG(rq_desc_count); GET_CONFIG(mtu); GET_CONFIG(intr_timer_type); GET_CONFIG(intr_mode); GET_CONFIG(intr_timer_usec); GET_CONFIG(loop_tag); c->wq_desc_count = min_t(u32, ENIC_MAX_WQ_DESCS, max_t(u32, ENIC_MIN_WQ_DESCS, c->wq_desc_count)); c->wq_desc_count &= 0xffffffe0; /* must be aligned to groups of 32 */ c->rq_desc_count = min_t(u32, ENIC_MAX_RQ_DESCS, max_t(u32, ENIC_MIN_RQ_DESCS, c->rq_desc_count)); c->rq_desc_count &= 0xffffffe0; /* must be aligned to groups of 32 */ if (c->mtu == 0) c->mtu = 1500; c->mtu = min_t(u16, ENIC_MAX_MTU, max_t(u16, ENIC_MIN_MTU, c->mtu)); c->intr_timer_usec = min_t(u32, INTR_COALESCE_HW_TO_USEC(VNIC_INTR_TIMER_MAX), c->intr_timer_usec); dev_info(enic_get_dev(enic), "vNIC MAC addr %02x:%02x:%02x:%02x:%02x:%02x " "wq/rq %d/%d\n", enic->mac_addr[0], enic->mac_addr[1], enic->mac_addr[2], enic->mac_addr[3], enic->mac_addr[4], enic->mac_addr[5], c->wq_desc_count, c->rq_desc_count); dev_info(enic_get_dev(enic), "vNIC mtu %d csum tx/rx %d/%d " "tso/lro %d/%d intr timer %d usec\n", c->mtu, ENIC_SETTING(enic, TXCSUM), ENIC_SETTING(enic, RXCSUM), ENIC_SETTING(enic, TSO), ENIC_SETTING(enic, LRO), c->intr_timer_usec); return 0; }
void getConfig( map<string,string> &config ) const { GET_CONFIG( PatchSize ); GET_CONFIG( Density ); GET_CONFIG( ToFilter ); }
int enic_get_vnic_config(struct enic *enic) { struct vnic_enet_config *c = &enic->config; int err; err = vnic_dev_mac_addr(enic->vdev, enic->mac_addr); if (err) { printk(KERN_ERR PFX "Error getting MAC addr, %d\n", err); return err; } #define GET_CONFIG(m) \ do { \ err = vnic_dev_spec(enic->vdev, \ offsetof(struct vnic_enet_config, m), \ sizeof(c->m), &c->m); \ if (err) { \ printk(KERN_ERR PFX \ "Error getting %s, %d\n", #m, err); \ return err; \ } \ } while (0) GET_CONFIG(flags); GET_CONFIG(wq_desc_count); GET_CONFIG(rq_desc_count); GET_CONFIG(mtu); GET_CONFIG(intr_timer); GET_CONFIG(intr_timer_type); GET_CONFIG(intr_mode); c->wq_desc_count = min_t(u32, ENIC_MAX_WQ_DESCS, max_t(u32, ENIC_MIN_WQ_DESCS, c->wq_desc_count)); c->wq_desc_count &= 0xfffffff0; /* must be aligned to groups of 16 */ c->rq_desc_count = min_t(u32, ENIC_MAX_RQ_DESCS, max_t(u32, ENIC_MIN_RQ_DESCS, c->rq_desc_count)); c->rq_desc_count &= 0xfffffff0; /* must be aligned to groups of 16 */ if (c->mtu == 0) c->mtu = 1500; c->mtu = min_t(u16, ENIC_MAX_MTU, max_t(u16, ENIC_MIN_MTU, c->mtu)); c->intr_timer = min_t(u16, VNIC_INTR_TIMER_MAX, c->intr_timer); printk(KERN_INFO PFX "vNIC MAC addr %pM wq/rq %d/%d\n", enic->mac_addr, c->wq_desc_count, c->rq_desc_count); printk(KERN_INFO PFX "vNIC mtu %d csum tx/rx %d/%d tso/lro %d/%d " "intr timer %d\n", c->mtu, ENIC_SETTING(enic, TXCSUM), ENIC_SETTING(enic, RXCSUM), ENIC_SETTING(enic, TSO), ENIC_SETTING(enic, LRO), c->intr_timer); return 0; }
void getConfig( map<string,string> &config ) const { GET_CONFIG( MinPoints ); GET_CONFIG( FeatureDistance ); }
int enic_get_vnic_config(struct enic *enic) { struct vnic_enet_config *c = &enic->config; int err; err = vnic_dev_get_mac_addr(enic->vdev, enic->mac_addr); if (err) { dev_err(enic_get_dev(enic), "Error getting MAC addr, %d\n", err); return err; } #define GET_CONFIG(m) \ do { \ err = vnic_dev_spec(enic->vdev, \ offsetof(struct vnic_enet_config, m), \ sizeof(c->m), &c->m); \ if (err) { \ dev_err(enic_get_dev(enic), \ "Error getting %s, %d\n", #m, err); \ return err; \ } \ } while (0) GET_CONFIG(flags); GET_CONFIG(wq_desc_count); GET_CONFIG(rq_desc_count); GET_CONFIG(mtu); GET_CONFIG(intr_timer_type); GET_CONFIG(intr_mode); GET_CONFIG(intr_timer_usec); GET_CONFIG(loop_tag); GET_CONFIG(num_arfs); GET_CONFIG(max_pkt_size); /* max packet size is only defined in newer VIC firmware * and will be 0 for legacy firmware and VICs */ if (c->max_pkt_size > ENIC_DEFAULT_MAX_PKT_SIZE) enic->max_mtu = c->max_pkt_size - (ETHER_HDR_LEN + 4); else enic->max_mtu = ENIC_DEFAULT_MAX_PKT_SIZE - (ETHER_HDR_LEN + 4); if (c->mtu == 0) c->mtu = 1500; enic->rte_dev->data->mtu = min_t(u16, enic->max_mtu, max_t(u16, ENIC_MIN_MTU, c->mtu)); enic->adv_filters = vnic_dev_capable_adv_filters(enic->vdev); dev_info(enic, "Advanced Filters %savailable\n", ((enic->adv_filters) ? "" : "not ")); c->wq_desc_count = min_t(u32, ENIC_MAX_WQ_DESCS, max_t(u32, ENIC_MIN_WQ_DESCS, c->wq_desc_count)); c->wq_desc_count &= 0xffffffe0; /* must be aligned to groups of 32 */ c->rq_desc_count = min_t(u32, ENIC_MAX_RQ_DESCS, max_t(u32, ENIC_MIN_RQ_DESCS, c->rq_desc_count)); c->rq_desc_count &= 0xffffffe0; /* must be aligned to groups of 32 */ c->intr_timer_usec = min_t(u32, c->intr_timer_usec, vnic_dev_get_intr_coal_timer_max(enic->vdev)); dev_info(enic_get_dev(enic), "vNIC MAC addr %02x:%02x:%02x:%02x:%02x:%02x " "wq/rq %d/%d mtu %d, max mtu:%d\n", enic->mac_addr[0], enic->mac_addr[1], enic->mac_addr[2], enic->mac_addr[3], enic->mac_addr[4], enic->mac_addr[5], c->wq_desc_count, c->rq_desc_count, enic->rte_dev->data->mtu, enic->max_mtu); dev_info(enic_get_dev(enic), "vNIC csum tx/rx %s/%s " "rss %s intr mode %s type %s timer %d usec " "loopback tag 0x%04x\n", ENIC_SETTING(enic, TXCSUM) ? "yes" : "no", ENIC_SETTING(enic, RXCSUM) ? "yes" : "no", ENIC_SETTING(enic, RSS) ? "yes" : "no", c->intr_mode == VENET_INTR_MODE_INTX ? "INTx" : c->intr_mode == VENET_INTR_MODE_MSI ? "MSI" : c->intr_mode == VENET_INTR_MODE_ANY ? "any" : "unknown", c->intr_timer_type == VENET_INTR_TYPE_MIN ? "min" : c->intr_timer_type == VENET_INTR_TYPE_IDLE ? "idle" : "unknown", c->intr_timer_usec, c->loop_tag); return 0; }
int fnic_get_vnic_config(struct fnic *fnic) { struct vnic_fc_config *c = &fnic->config; int err; #define GET_CONFIG(m) \ do { \ err = vnic_dev_spec(fnic->vdev, \ offsetof(struct vnic_fc_config, m), \ sizeof(c->m), &c->m); \ if (err) { \ shost_printk(KERN_ERR, fnic->lport->host, \ "Error getting %s, %d\n", #m, \ err); \ return err; \ } \ } while (0); GET_CONFIG(node_wwn); GET_CONFIG(port_wwn); GET_CONFIG(wq_enet_desc_count); GET_CONFIG(wq_copy_desc_count); GET_CONFIG(rq_desc_count); GET_CONFIG(maxdatafieldsize); GET_CONFIG(ed_tov); GET_CONFIG(ra_tov); GET_CONFIG(intr_timer); GET_CONFIG(intr_timer_type); GET_CONFIG(flags); GET_CONFIG(flogi_retries); GET_CONFIG(flogi_timeout); GET_CONFIG(plogi_retries); GET_CONFIG(plogi_timeout); GET_CONFIG(io_throttle_count); GET_CONFIG(link_down_timeout); GET_CONFIG(port_down_timeout); GET_CONFIG(port_down_io_retries); GET_CONFIG(luns_per_tgt); c->wq_enet_desc_count = min_t(u32, VNIC_FNIC_WQ_DESCS_MAX, max_t(u32, VNIC_FNIC_WQ_DESCS_MIN, c->wq_enet_desc_count)); c->wq_enet_desc_count = ALIGN(c->wq_enet_desc_count, 16); c->wq_copy_desc_count = min_t(u32, VNIC_FNIC_WQ_COPY_DESCS_MAX, max_t(u32, VNIC_FNIC_WQ_COPY_DESCS_MIN, c->wq_copy_desc_count)); c->wq_copy_desc_count = ALIGN(c->wq_copy_desc_count, 16); c->rq_desc_count = min_t(u32, VNIC_FNIC_RQ_DESCS_MAX, max_t(u32, VNIC_FNIC_RQ_DESCS_MIN, c->rq_desc_count)); c->rq_desc_count = ALIGN(c->rq_desc_count, 16); c->maxdatafieldsize = min_t(u16, VNIC_FNIC_MAXDATAFIELDSIZE_MAX, max_t(u16, VNIC_FNIC_MAXDATAFIELDSIZE_MIN, c->maxdatafieldsize)); c->ed_tov = min_t(u32, VNIC_FNIC_EDTOV_MAX, max_t(u32, VNIC_FNIC_EDTOV_MIN, c->ed_tov)); c->ra_tov = min_t(u32, VNIC_FNIC_RATOV_MAX, max_t(u32, VNIC_FNIC_RATOV_MIN, c->ra_tov)); c->flogi_retries = min_t(u32, VNIC_FNIC_FLOGI_RETRIES_MAX, c->flogi_retries); c->flogi_timeout = min_t(u32, VNIC_FNIC_FLOGI_TIMEOUT_MAX, max_t(u32, VNIC_FNIC_FLOGI_TIMEOUT_MIN, c->flogi_timeout)); c->plogi_retries = min_t(u32, VNIC_FNIC_PLOGI_RETRIES_MAX, c->plogi_retries); c->plogi_timeout = min_t(u32, VNIC_FNIC_PLOGI_TIMEOUT_MAX, max_t(u32, VNIC_FNIC_PLOGI_TIMEOUT_MIN, c->plogi_timeout)); c->io_throttle_count = min_t(u32, VNIC_FNIC_IO_THROTTLE_COUNT_MAX, max_t(u32, VNIC_FNIC_IO_THROTTLE_COUNT_MIN, c->io_throttle_count)); c->link_down_timeout = min_t(u32, VNIC_FNIC_LINK_DOWN_TIMEOUT_MAX, c->link_down_timeout); c->port_down_timeout = min_t(u32, VNIC_FNIC_PORT_DOWN_TIMEOUT_MAX, c->port_down_timeout); c->port_down_io_retries = min_t(u32, VNIC_FNIC_PORT_DOWN_IO_RETRIES_MAX, c->port_down_io_retries); c->luns_per_tgt = min_t(u32, VNIC_FNIC_LUNS_PER_TARGET_MAX, max_t(u32, VNIC_FNIC_LUNS_PER_TARGET_MIN, c->luns_per_tgt)); c->intr_timer = min_t(u16, VNIC_INTR_TIMER_MAX, c->intr_timer); c->intr_timer_type = c->intr_timer_type; shost_printk(KERN_INFO, fnic->lport->host, "vNIC MAC addr %pM " "wq/wq_copy/rq %d/%d/%d\n", fnic->ctlr.ctl_src_addr, c->wq_enet_desc_count, c->wq_copy_desc_count, c->rq_desc_count); shost_printk(KERN_INFO, fnic->lport->host, "vNIC node wwn %llx port wwn %llx\n", c->node_wwn, c->port_wwn); shost_printk(KERN_INFO, fnic->lport->host, "vNIC ed_tov %d ra_tov %d\n", c->ed_tov, c->ra_tov); shost_printk(KERN_INFO, fnic->lport->host, "vNIC mtu %d intr timer %d\n", c->maxdatafieldsize, c->intr_timer); shost_printk(KERN_INFO, fnic->lport->host, "vNIC flags 0x%x luns per tgt %d\n", c->flags, c->luns_per_tgt); shost_printk(KERN_INFO, fnic->lport->host, "vNIC flogi_retries %d flogi timeout %d\n", c->flogi_retries, c->flogi_timeout); shost_printk(KERN_INFO, fnic->lport->host, "vNIC plogi retries %d plogi timeout %d\n", c->plogi_retries, c->plogi_timeout); shost_printk(KERN_INFO, fnic->lport->host, "vNIC io throttle count %d link dn timeout %d\n", c->io_throttle_count, c->link_down_timeout); shost_printk(KERN_INFO, fnic->lport->host, "vNIC port dn io retries %d port dn timeout %d\n", c->port_down_io_retries, c->port_down_timeout); return 0; }
/* CENTRY */ int GLUTAPIENTRY glutGet(GLenum param) { Window win, root; int x, y, value; unsigned int width, height, border, depth; switch (param) { case GLUT_INIT_WINDOW_X: return __glutInitX; case GLUT_INIT_WINDOW_Y: return __glutInitY; case GLUT_INIT_WINDOW_WIDTH: return __glutInitWidth; case GLUT_INIT_WINDOW_HEIGHT: return __glutInitHeight; case GLUT_INIT_DISPLAY_MODE: return __glutDisplayMode; case GLUT_WINDOW_X: XTranslateCoordinates(__glutDisplay, __glutCurrentWindow->win, __glutRoot, 0, 0, &x, &y, &win); return x; case GLUT_WINDOW_Y: XTranslateCoordinates(__glutDisplay, __glutCurrentWindow->win, __glutRoot, 0, 0, &x, &y, &win); return y; case GLUT_WINDOW_WIDTH: if (!__glutCurrentWindow->reshape) { XGetGeometry(__glutDisplay, __glutCurrentWindow->win, &root, &x, &y, &width, &height, &border, &depth); return width; } return __glutCurrentWindow->width; case GLUT_WINDOW_HEIGHT: if (!__glutCurrentWindow->reshape) { XGetGeometry(__glutDisplay, __glutCurrentWindow->win, &root, &x, &y, &width, &height, &border, &depth); return height; } return __glutCurrentWindow->height; #ifdef __OS2__ #define GET_CONFIG(attrib) \ { if (__glutCurrentWindow->renderWin == __glutCurrentWindow->win) \ glXGetConfig( __glutCurrentWindow->vis, attrib, &value); \ else \ glXGetConfig(__glutCurrentWindow->overlay->vis, attrib, &value); \ } \ #else #define GET_CONFIG(attrib) { \ if (__glutCurrentWindow->renderWin == __glutCurrentWindow->win) { \ glXGetConfig(__glutDisplay, __glutCurrentWindow->vis, \ attrib, &value); \ } else { \ glXGetConfig(__glutDisplay, __glutCurrentWindow->overlay->vis, \ attrib, &value); \ } \ } #endif case GLUT_WINDOW_BUFFER_SIZE: GET_CONFIG(GLX_BUFFER_SIZE); return value; case GLUT_WINDOW_STENCIL_SIZE: GET_CONFIG(GLX_STENCIL_SIZE); return value; case GLUT_WINDOW_DEPTH_SIZE: GET_CONFIG(GLX_DEPTH_SIZE); return value; case GLUT_WINDOW_RED_SIZE: GET_CONFIG(GLX_RED_SIZE); return value; case GLUT_WINDOW_GREEN_SIZE: GET_CONFIG(GLX_GREEN_SIZE); return value; case GLUT_WINDOW_BLUE_SIZE: GET_CONFIG(GLX_BLUE_SIZE); return value; case GLUT_WINDOW_ALPHA_SIZE: GET_CONFIG(GLX_ALPHA_SIZE); return value; case GLUT_WINDOW_ACCUM_RED_SIZE: GET_CONFIG(GLX_ACCUM_RED_SIZE); return value; case GLUT_WINDOW_ACCUM_GREEN_SIZE: GET_CONFIG(GLX_ACCUM_GREEN_SIZE); return value; case GLUT_WINDOW_ACCUM_BLUE_SIZE: GET_CONFIG(GLX_ACCUM_BLUE_SIZE); return value; case GLUT_WINDOW_ACCUM_ALPHA_SIZE: GET_CONFIG(GLX_ACCUM_ALPHA_SIZE); return value; case GLUT_WINDOW_DOUBLEBUFFER: GET_CONFIG(GLX_DOUBLEBUFFER); return value; case GLUT_WINDOW_RGBA: GET_CONFIG(GLX_RGBA); return value; case GLUT_WINDOW_COLORMAP_SIZE: GET_CONFIG(GLX_RGBA); if (value) { return 0; } else { #if defined(_WIN32) || defined(__OS2__) /* KLUDGE: we always assume 256 colors in CI mode on Win32 */ return 256; #else if (__glutCurrentWindow->renderWin == __glutCurrentWindow->win) { return __glutCurrentWindow->vis->visual->map_entries; } else { return __glutCurrentWindow->overlay->vis->visual->map_entries; } #endif /* _WIN32 */ } case GLUT_WINDOW_PARENT: return __glutCurrentWindow->parent ? __glutCurrentWindow->parent->num + 1 : 0; case GLUT_WINDOW_NUM_CHILDREN: { int num = 0; GLUTwindow *children = __glutCurrentWindow->children; while (children) { num++; children = children->siblings; } return num; } case GLUT_WINDOW_NUM_SAMPLES: #if defined(GLX_VERSION_1_1) && defined(GLX_SGIS_multisample) if (__glutIsSupportedByGLX("GLX_SGIS_multisample")) { GET_CONFIG(GLX_SAMPLES_SGIS); return value; } else { return 0; } #else /* Independent of GLX server support, multisampling not supported by GLX client-side. */ return 0; #endif case GLUT_WINDOW_STEREO: GET_CONFIG(GLX_STEREO); return value; case GLUT_WINDOW_CURSOR: return __glutCurrentWindow->cursor; case GLUT_SCREEN_WIDTH: return DisplayWidth(__glutDisplay, __glutScreen); case GLUT_SCREEN_HEIGHT: return DisplayHeight(__glutDisplay, __glutScreen); case GLUT_SCREEN_WIDTH_MM: return DisplayWidthMM(__glutDisplay, __glutScreen); case GLUT_SCREEN_HEIGHT_MM: return DisplayHeightMM(__glutDisplay, __glutScreen); case GLUT_MENU_NUM_ITEMS: return __glutCurrentMenu->num; case GLUT_DISPLAY_MODE_POSSIBLE: { XVisualInfo *vi; Bool dummy, visAlloced; void *fbc; #if defined(_WIN32) /* Our fake glXChooseVisual (which is called by __glutDetermineVisual) needs an HDC to work with, so grab one from the "root" window. */ XHDC = GetDC(GetDesktopWindow()); #endif vi = __glutDetermineWindowVisual(&dummy, &visAlloced, &fbc); #if defined(_WIN32) ReleaseDC(GetDesktopWindow(), XHDC); #endif if (vi) { if (visAlloced) XFree(vi); return 1; } return 0; } case GLUT_ELAPSED_TIME: { #ifdef OLD_VMS struct timeval6 elapsed, beginning, now; #else struct timeval elapsed, beginning, now; #endif __glutInitTime(&beginning); GETTIMEOFDAY(&now); TIMEDELTA(elapsed, now, beginning); /* Return elapsed milliseconds. */ #if defined(__vms) && ( __VMS_VER < 70000000 ) return (int) (elapsed.val / TICKS_PER_MILLISECOND); #else return (int) ((elapsed.tv_sec * 1000) + (elapsed.tv_usec / 1000)); #endif } case GLUT_WINDOW_FORMAT_ID: #if defined(__OS2__) return wglGetPixelFormat(__glutCurrentWindow->hdc); #elif defined(_WIN32) return GetPixelFormat(__glutCurrentWindow->hdc); #else if (__glutCurrentWindow->renderWin == __glutCurrentWindow->win) { return (int) __glutCurrentWindow->vis->visualid; } else { return (int) __glutCurrentWindow->overlay->vis->visualid; } #endif default: __glutWarning("invalid glutGet parameter: %d", param); return -1; } }
BOOL t55x7_config_block_show(BYTE *config, BYTE *password) { uint32_t value= hextoulong(config); BOOL xmode; UserMessage(" Config Block (0): %.8s\r\n\r\n", config); UserMessageNum(" Master Key: %d = ", GET_CONFIG(value, T55X7_MASK_MASTER_KEY, T55X7_SHIFT_MASTER_KEY)); if(GET_CONFIG(value, T55X7_MASK_MASTER_KEY, T55X7_SHIFT_MASTER_KEY) == T55X7_COMPAT_MODE) UserMessage("%s\r\n", "Compatibility Mode"); else if(GET_CONFIG(value, T55X7_MASK_MASTER_KEY, T55X7_SHIFT_MASTER_KEY) == T55X7_XMODE_MODE) UserMessage("%s\r\n", "Extended Mode"); else UserMessage("%s\r\n", "Undefined Mode"); xmode= GET_CONFIG(value, T55X7_MASK_XMODE, T55X7_SHIFT_XMODE); UserMessage(" X-Mode: %s\r\n", xmode ? "True" : "False"); // display additional/alternate fields if in xmode if(xmode) { UserMessageNum(" Data Rate: %02d = ", GET_CONFIG(value, T55X7_XMODE_MASK_DATA_BIT_RATE, T55X7_SHIFT_DATA_BIT_RATE)); UserMessageNum("%d * FC\r\n", GET_CONFIG(value, T55X7_XMODE_MASK_DATA_BIT_RATE, T55X7_SHIFT_DATA_BIT_RATE) * 2 + 2); UserMessageNum(" Modulation: %02d = ", GET_CONFIG(value, T55X7_MASK_MODULATION, T55X7_SHIFT_MODULATION)); if(GET_CONFIG(value, T55X7_MASK_MODULATION, T55X7_SHIFT_MODULATION) > 8) { if(GET_CONFIG(value, T55X7_MASK_MODULATION, T55X7_SHIFT_MODULATION)== T55X7_MOD_BIPHASE_50) UserMessage("%s\r\n", "BiPhase ('50)"); else if (GET_CONFIG(value, T55X7_MASK_MODULATION, T55X7_SHIFT_MODULATION)== T55X7_MOD_BIPHASE_57) UserMessage("%s\r\n", "BiPhase ('57)"); else UserMessage("%s\r\n", "Invalid"); } else UserMessage("%s\r\n", (BYTE *) T55x7_Compat_Modulation[GET_CONFIG(value, T55X7_MASK_MODULATION, T55X7_SHIFT_MODULATION)]); UserMessage(" SST: %s\r\n", GET_CONFIG(value, T55X7_XMODE_MASK_SST, T55X7_SHIFT_ST_SST) ? "True" : "False"); } else { UserMessageNum(" Data Rate: %02d = ", GET_CONFIG(value, T55X7_COMPAT_MASK_DATA_BIT_RATE, T55X7_SHIFT_DATA_BIT_RATE)); UserMessageNum("%d * FC\r\n", T55x7_Compat_Data_Rates[GET_CONFIG(value, T55X7_COMPAT_MASK_DATA_BIT_RATE, T55X7_SHIFT_DATA_BIT_RATE)]); UserMessageNum(" Modulation: %02d = ", GET_CONFIG(value, T55X7_MASK_MODULATION, T55X7_SHIFT_MODULATION)); if(GET_CONFIG(value, T55X7_MASK_MODULATION, T55X7_SHIFT_MODULATION) > 8) { if(GET_CONFIG(value, T55X7_MASK_MODULATION, T55X7_SHIFT_MODULATION)== 16) UserMessage("%s\r\n", "BiPhase ('50)"); else UserMessage("%s\r\n", "Reserved/Invalid"); } else UserMessage("%s\r\n", (BYTE *) T55x7_Compat_Modulation[GET_CONFIG(value, T55X7_MASK_MODULATION, T55X7_SHIFT_MODULATION)]); UserMessage(" ST: %s\r\n", GET_CONFIG(value, T55X7_COMPAT_MASK_ST, T55X7_SHIFT_ST_SST) ? "True" : "False"); } // display common fields UserMessageNum(" PSK Carrier: %d = ", GET_CONFIG(value, T55X7_MASK_PSK_CARRIER_FREQ, T55X7_SHIFT_PSK_CARRIER_FREQ)); if(GET_CONFIG(value, T55X7_MASK_PSK_CARRIER_FREQ, T55X7_SHIFT_PSK_CARRIER_FREQ) > 2) UserMessage("%s\r\n", "Reserved"); else UserMessageNum("%d * FC\r\n", GET_CONFIG(value, T55X7_MASK_PSK_CARRIER_FREQ, T55X7_SHIFT_PSK_CARRIER_FREQ) * 2 + 2); UserMessageNum(" Maxblock: %d\r\n", GET_CONFIG(value, T55X7_MASK_MAX_BLOCK, T55X7_SHIFT_MAX_BLOCK)); UserMessage(" AOR: %s\r\n", GET_CONFIG(value, T55X7_MASK_AOR, T55X7_SHIFT_AOR) ? "True" : "False"); UserMessage(" OTP: %s\r\n", GET_CONFIG(value, T55X7_MASK_OTP, T55X7_SHIFT_OTP) ? "True" : "False"); UserMessage(" PWD: %s\r\n", GET_CONFIG(value, T55X7_MASK_PWD, T55X7_SHIFT_PWD) ? "True" : "False"); UserMessage(" Fast Write: %s\r\n", GET_CONFIG(value, T55X7_MASK_FAST_WRITE, T55X7_SHIFT_FAST_WRITE) ? "True" : "False"); UserMessage(" Inverse Data: %s\r\n", GET_CONFIG(value, T55X7_MASK_INVERSE_DATA, T55X7_SHIFT_INVERSE_DATA) ? "True" : "False"); UserMessage(" POR Delay: %s\r\n", GET_CONFIG(value, T55X7_MASK_POR_DELAY, T55X7_SHIFT_POR_DELAY) ? "True" : "False"); UserMessage("\r\n PWD Block (7): %.8s ", password); printhexreadable(password, 4); UserMessage("%s", "\r\n"); return TRUE; }