Beispiel #1
0
ReceiverThread::ReceiverThread()
{
	uart_init();
	
	setParameterValue(TOTAL_SPANNUNG, 0x1010);
	setParameterValue(BUS_ADRESSE, 0x31);
}
Beispiel #2
0
IPState WeatherWatcher::updateWeather()
{

    if (readWatchFile() == false)
        return IPS_BUSY;

    for (auto const &x : weatherMap)
    {
        if (x.first == keywordT[0].text)
        {
            setParameterValue("WEATHER_RAIN_HOUR", std::strtod(x.second.c_str(), nullptr));
        }
        else if (x.first == keywordT[1].text)
        {
            setParameterValue("WEATHER_TEMPERATURE", std::strtod(x.second.c_str(), nullptr));
        }
        else if (x.first == keywordT[2].text)
        {
            setParameterValue("WEATHER_WIND_SPEED", std::strtod(x.second.c_str(), nullptr));
        }
        else if (x.first == keywordT[3].text)
        {

            setParameterValue("WEATHER_WIND_GUST", std::strtod(x.second.c_str(), nullptr));
        }
        else if (x.first == keywordT[4].text)
        {
            setParameterValue("WEATHER_FORECAST", std::strtod(x.second.c_str(), nullptr));
        }
    }

    return IPS_OK;
}
Beispiel #3
0
BiasedDelay::BiasedDelay() : delayBuffer(MAX_CHANNELS, INITIAL_BUFFER_SIZE) {
  parameterNames.add("Time");
  parameterNames.add("Feedback");
  parameterNames.add("Bias");
  parameterNames.add("Dry/Wet");
  
  setParameterValue(PARAMETER_TIME, 0.2f);
  setParameterValue(PARAMETER_FEEDBACK, 0.1f);
  setParameterValue(PARAMETER_BIAS, 0.5f);
  setParameterValue(PARAMETER_DRYWET, 0.5f);
}
// virtual
bool CQTaskMethodParametersDM::setData(const QModelIndex &_index, const QVariant &value, int role)
{
  CCopasiParameter * pNode = nodeFromIndex(_index);

  if (pNode == NULL) return false;

  bool success = false;

  if (role == Qt::EditRole ||
      role == Qt::CheckStateRole)
    {
      switch (_index.column())
        {
          case COL_VALUE:
            success = setParameterValue(pNode, value);

            break;

          default:
            success = true;
            break;
        }
    }

  return success;
}
Beispiel #5
0
void BiasedDelay::setStateInformation(ScopedPointer<XmlElement> state){
  if (state->hasTagName("BiasedDelayState"))
  {
    for (int i=0; i<getNumParameters(); i++)
      setParameterValue(i, (float)state->getDoubleAttribute(String::formatted("parameter%d", i), getParameterValue(i)));
    //      setParameterValue(i, (float)state->getDoubleAttribute(getParameterName(i), getParameterValue(i)));
  }
}
Beispiel #6
0
void ReceiverThread::receiveData()
{
	uint16_t value;
	
	value = data[3] | (data[2]<<8);
	
	setParameterValue(parameter, value);
}
Beispiel #7
0
void Effect::setParameterValue(const EffectParameter &param, const QVariant &newValue)
{
    K_D(Effect);
    d->parameterValues[param] = newValue;
    if (d->backendObject()) {
        INTERFACE_CALL(setParameterValue(param, newValue));
    }
}
void DistrhoUISoulForce::imageSwitchClicked(ImageSwitch* imageSwitch, bool down)
{
    const uint buttonId(imageSwitch->getId());

    editParameter(buttonId, true);
    setParameterValue(buttonId, down ? 1.0f : 0.0f);
    editParameter(buttonId, false);
}
void
ParameterSlider::reset(float minimumValue, float maximumValue, float value)
{
	if (maximumValue < minimumValue + EPSILON) {
		THROW_EXCEPTION(InvalidValueException, "The maximum value must be greater than the minimum value. Slider: "
							<< parameter_ << '.');
	}
	minimumValue_ = minimumValue;
	maximumValue_ = maximumValue;
	setParameterValue(value);
}
Beispiel #10
0
bool CQLNAWidget::saveParameterTable()
{
  size_t i, k;
  QString value;
  CCopasiParameter::Type Type;

  for (i = 0; i < mpMethod->size(); i++)
    {
      value = mpMethodWidget->mpTableParameter->item((int) i, 0)->text();

      if (value != getParameterValue(mpMethod, i, &Type))
        {
          setParameterValue(mpMethod, i, value);
          mChanged = true;
        }
    }

  if (mpCheckSteadyState->isChecked())
    {
      assert(CCopasiRootContainer::getDatamodelList()->size() > 0);
      CSteadyStateTask * pSteadyStateTask =
        dynamic_cast<CSteadyStateTask *>((*(*CCopasiRootContainer::getDatamodelList())[0]->getTaskList())["Steady-State"]);

      if (!pSteadyStateTask) return false;

      CCopasiMethod * pMethod = pSteadyStateTask->getMethod();

      for (i = mpMethod->size(), k = 0; k < pMethod->size(); i++, k++)
        {
          value = mpMethodWidget->mpTableParameter->item((int) i, 0)->text();

          if (value != getParameterValue(pMethod, k, &Type))
            {
              setParameterValue(pMethod, k, value);
              mChanged = true;
            }
        }
    }

  return true;
}
bool HdfsConfig::setParameterValue(const string &parameterName,
                                   const string &parameterValue,
                                   const string &conftype) {
  if (hawq::test::lower(conftype) == "hdfs") {
    return setParameterValue(parameterName, parameterValue);
  }
  bool ret = LoadFromHawqConfigFile();
  if (!ret) {
    return false;
  }

  return hawqxmlconf->setString(parameterName, parameterValue);
}
void DistrhoUISoulForce::imageButtonClicked(ImageButton* imageButton, int)
{
    const uint buttonId(imageButton->getId());

    if (buttonId != DistrhoPluginSoulForce::kParameterFootswitch)
        return;

    fFootDown = !fFootDown;

    editParameter(buttonId, true);
    setParameterValue(buttonId, fFootDown ? 1.0f : 0.0f);
    editParameter(buttonId, false);

    repaint();
}
Beispiel #13
0
// Called by Weather::TimerHit every UpdatePeriodN[0].value seconds if we return IPS_OK or every 5 seconds otherwise
IPState WeatherSafetyProxy::updateWeather()
{
    IPState ret = IPS_ALERT;
    if (ScriptOrCurlS[WSP_USE_SCRIPT].s == ISS_ON)
    {
        ret = executeScript();
    }
    else
    {
        ret = executeCurl();
    }
    if (ret != IPS_OK)
    {
        if (Safety == WSP_SAFE)
        {
            SofterrorCount++;
            LOGF_WARN("Soft error %d occured during SAFE conditions, counting", SofterrorCount);
            if (SofterrorCount > softErrorHysteresisN[WSP_SOFT_ERROR_MAX].value)
            {
                char Warning[] = "Max softerrors reached while Weather was SAFE";
                LOG_WARN(Warning);
                Safety = WSP_UNSAFE;
                setParameterValue("WEATHER_SAFETY", WSP_UNSAFE);
                IUSaveText(&reasonsT[0], Warning);
                reasonsTP.s = IPS_OK;
                IDSetText(&reasonsTP, nullptr);
                SofterrorRecoveryMode = true;
                ret = IPS_OK; // So that indiweather actually syncs the CriticalParameters we just set
            }
        }
        else
        {
            LOG_WARN("Soft error occured during UNSAFE conditions, ignore");
            SofterrorCount = 0;
            SofterrorRecoveryCount = 0;
        }
    }
    else
    {
        SofterrorCount = 0;
    }
    return ret;
}
Beispiel #14
0
/**
 * Initialize the object with a string of parameters
 * @param params :: A key=value list of parameters
 */
void ChopperModel::initialize(const std::string & params)
{
    if(params.empty()) throw std::invalid_argument("ChopperModel::initialize - Empty parameter string.");
    static const char * keyValSep = "=";
    static const char * listSep = ",";

    auto keyValues = Kernel::Strings::splitToKeyValues(params, keyValSep, listSep);
    if(keyValues.empty())
    {
        throw std::invalid_argument("ChopperModel::initialize - Parameter string was not empty but no values"
                                    " could be parsed. Check it is a comma-separated key=value string");
    }

    setBaseParameters(keyValues);

    for(auto iter = keyValues.begin(); iter != keyValues.end(); ++iter)
    {
        setParameterValue(iter->first, iter->second);
    }
}
Beispiel #15
0
    /**
     * Initialize the object from a string of parameters
     * @param params :: A string containing the parameter names & values
     */
    void ModeratorModel::initialize(const std::string & params)
    {
      if(params.empty()) throw std::invalid_argument("ModeratorModel::initialize - Empty parameter string.");
      static const char * keyValSep = "=";
      static const char * listSep = ",";

      auto keyValues = Kernel::Strings::splitToKeyValues(params, keyValSep, listSep);
      if(keyValues.empty())
      {
        throw std::invalid_argument("ModeratorModel::initialize - Parameter string was not empty but no values"
                                    "could be parsed. Check it has the key=value format.");
      }

      for(auto iter = keyValues.begin(); iter != keyValues.end(); ++iter)
      {
        setParameterValue(iter->first, iter->second);
      }

      /// Any custom setup
      this->init();
    }
Beispiel #16
0
bool setParameterValue(CCopasiParameterGroup * group,
                       const std::string & name,
                       const QString & value)
{return setParameterValue(group, group->getIndex(name), value);}
Beispiel #17
0
//--------------------------------------------------------------
void oscReceiver::update()
{
    if (hasWaitingMessages())
    {
		while(getNextMessage(&m_oscMessage))
		{
            // int indexArg = 0;
			ofLog() << "oscReceiver::update() - received " << m_oscMessage.getAddress();


			if (m_oscMessage.getAddress() == OSC_MOD_SET_WEIGHT)
			{
				apparelModManager* pModManager = GLOBALS->getModManager();
				if (pModManager)
				{
					// Name of the mod
					string instanceName = m_oscMessage.getArgAsString(0);

					// Get Mod instance
					apparelMod* pMod = pModManager->getMod(instanceName);

					// Exists ??
					if (pMod && pMod->m_isWeightManual)
					{
						pMod->setWeight( m_oscMessage.getArgAsFloat(1) );
					}
				}
			}
			else if (m_oscMessage.getAddress() == OSC_MOD_SET_PARAMETER)
			{
				apparelModManager* pModManager = GLOBALS->getModManager();
				if (pModManager)
				{
					// Name of the mod
					string instanceName = m_oscMessage.getArgAsString(0);

					// Get Mod instance
					apparelMod* pMod = pModManager->getMod(instanceName);

					// Exists ??
					if (pMod)
					{
					  if (m_oscMessage.getNumArgs() == 3)
					  {
						 string parameterName = m_oscMessage.getArgAsString(1);
					  
						 ofAbstractParameter& modParam = pMod->getParameter(parameterName);
						 setParameterValue(modParam, m_oscMessage, 2);
					 
						  //OFAPPLOG->println("instanceName="+instanceName+"/parameterName="+parameterName);
						 // OFAPPLOG->println("value for "+instanceName+"/"+parameterName+"="+modParam.toString());
					  }
					 
					  //
					  else if (m_oscMessage.getNumArgs() == 4)
					  {
						  string groupName = m_oscMessage.getArgAsString(1);
						  string parameterName = m_oscMessage.getArgAsString(2);
						  ofAbstractParameter& modGroupParam = pMod->getParameter(groupName);
						  if (modGroupParam.type()==typeid(ofParameterGroup).name())
						  {
							  setParameterValue(modGroupParam, m_oscMessage, 3);
						  }
					  }
					}
				}
	   		}

		}
	}
}
Beispiel #18
0
IPState WeatherSafetyProxy::parseSafetyJSON(const char *clean_buf, int byte_count)
{
    // copy clean_buf to buf which jsonParse can destroy
    char buf[BUFSIZ];
    strncpy(buf, clean_buf, byte_count);

    char *source = buf;
    char *endptr;
    JsonValue value;
    JsonAllocator allocator;
    int status = jsonParse(source, &endptr, &value, allocator);
    if (status != JSON_OK)
    {
        LOGF_ERROR("jsonParse %s at position %zd", jsonStrError(status), endptr - source);
        LastParseSuccess = false;
        return IPS_ALERT;
    }

    JsonIterator it;
    JsonIterator observationIterator;
    bool roof_status_found = false;
    bool open_ok_found = false;
    bool reasons_found = false;
    bool error_found = false;
    for (it = begin(value); it != end(value); ++it)
    {
        if (!strcmp(it->key, "roof_status"))
        {
            roof_status_found = true;
            for (observationIterator = begin(it->value); observationIterator != end(it->value); ++observationIterator)
            {
                if (!strcmp(observationIterator->key, "open_ok"))
                {
                    open_ok_found = true;
                    int NewSafety = observationIterator->value.toNumber();
                    if (NewSafety != Safety)
                    {
                        if (NewSafety == WSP_UNSAFE)
                        {
                            LOG_WARN("Weather is UNSAFE");
                        }
                        else if (NewSafety == WSP_SAFE)
                        {
                            if (SofterrorRecoveryMode == true)
                            {
                                SofterrorRecoveryCount++;
                                if (SofterrorRecoveryCount > softErrorHysteresisN[WSP_SOFT_ERROR_RECOVERY].value)
                                {
                                    LOG_INFO("Minimum soft recovery errors reached while Weather was SAFE");
                                    SofterrorRecoveryCount = 0;
                                    SofterrorRecoveryMode = false;
                                }
                                else
                                {
                                    LOGF_INFO("Weather is SAFE but soft error recovery %d is still counting", SofterrorRecoveryCount);
                                    NewSafety = WSP_UNSAFE;
                                }
                            }
                            else
                            {
                                LOG_INFO("Weather is SAFE");
                            }
                        }
                        Safety = NewSafety;
                    }
                    setParameterValue("WEATHER_SAFETY", NewSafety);
                }
                else if (!strcmp(observationIterator->key, "reasons"))
                {
                    reasons_found = true;
                    char *reasons = observationIterator->value.toString();
                    if (SofterrorRecoveryMode == true)
                    {
                        char newReasons[MAXRBUF];
                        snprintf(newReasons, MAXRBUF, "SofterrorRecoveryMode, %s", reasons);
                        IUSaveText(&reasonsT[0], newReasons);
                    }
                    else
                    {
                        IUSaveText(&reasonsT[0], reasons);
                    }
                    reasonsTP.s = IPS_OK;
                    IDSetText(&reasonsTP, nullptr);
                }
            }
        }
        if (!strcmp(it->key, "error"))
        {
            error_found = true;
        }
    }

    if (error_found)
    {
        LOGF_ERROR("Error hint found in JSON [%s]", clean_buf);
        LastParseSuccess = false;
        return IPS_ALERT;
    }
    if (!roof_status_found)
    {
        LOGF_ERROR("Found no roof_status field in JSON [%s]", clean_buf);
        LastParseSuccess = false;
        return IPS_ALERT;
    }
    if (!open_ok_found)
    {
        LOGF_ERROR("Found no open_ok field in roof_status JSON [%s]", clean_buf);
        LastParseSuccess = false;
        return IPS_ALERT;
    }
    // do not error if reasons are missing, they're not required for safety
    if (!LastParseSuccess)
    {
        // show the good news. Once.
        LOGF_INFO("Script output fully parsed, weather is %s", (Safety == 1) ? "SAFE" : "UNSAFE");
        LastParseSuccess = true;
    }
    return IPS_OK;
}
void DistrhoUISoulForce::imageKnobValueChanged(ImageKnob* knob, float value)
{
    setParameterValue(knob->getId(), value);
}
Beispiel #20
0
IPState WunderGround::updateWeather()
{    
      CURL *curl;
      CURLcode res;
      std::string readBuffer;
      char requestURL[MAXRBUF];

      // If location is not updated yet, return busy
      if (wunderLat == -1000 || wunderLong == -1000)
          return IPS_BUSY;

      char *orig = setlocale(LC_NUMERIC,"C");

      snprintf(requestURL, MAXRBUF, "http://api.wunderground.com/api/%s/conditions/q/%g,%g.json", wunderAPIKeyT[0].text, wunderLat, wunderLong);

      curl = curl_easy_init();
      if(curl)
      {
        curl_easy_setopt(curl, CURLOPT_URL, requestURL);
        curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteCallback);
        curl_easy_setopt(curl, CURLOPT_WRITEDATA, &readBuffer);
        res = curl_easy_perform(curl);
        curl_easy_cleanup(curl);
      }

      char srcBuffer[readBuffer.size()];
      strncpy(srcBuffer, readBuffer.c_str(), readBuffer.size());
      char *source = srcBuffer;
      // do not forget terminate source string with 0
      char *endptr;
      JsonValue value;
      JsonAllocator allocator;
      int status = jsonParse(source, &endptr, &value, allocator);
      if (status != JSON_OK)
      {
          DEBUGF(INDI::Logger::DBG_ERROR, "%s at %zd", jsonStrError(status), endptr - source);
          DEBUGF(INDI::Logger::DBG_DEBUG, "%s", requestURL);
          DEBUGF(INDI::Logger::DBG_DEBUG, "%s", readBuffer.c_str());
          setlocale(LC_NUMERIC,orig);
          return IPS_ALERT;
      }

      JsonIterator it;
      JsonIterator observationIterator;

      for (it = begin(value); it!= end(value); ++it)
      {
          if (!strcmp(it->key, "current_observation"))
          {
              for (observationIterator = begin(it->value); observationIterator!= end(it->value); ++observationIterator)
              {
                  if (!strcmp(observationIterator->key, "weather"))
                  {
                      char *value = observationIterator->value.toString();

                      if (!strcmp(value, "Clear"))
                          setParameterValue("WEATHER_FORECAST", 0);
                      else if (!strcmp(value, "Unknown") || !strcmp(value, "Scattered Clouds") || !strcmp(value, "Partly Cloudy") || !strcmp(value, "Overcast")
                               || !strcmp(value, "Patches of Fog") || !strcmp(value, "Partial Fog") || !strcmp(value, "Light Haze"))
                          setParameterValue("WEATHER_FORECAST", 1);
                      else
                          setParameterValue("WEATHER_FORECAST", 2);

                      DEBUGF(INDI::Logger::DBG_SESSION, "Weather condition: %s", value);
                  }
                  else if (!strcmp(observationIterator->key, "temp_c"))
                  {
                      if (observationIterator->value.isDouble())
                          setParameterValue("WEATHER_TEMPERATURE", observationIterator->value.toNumber());
                      else
                          setParameterValue("WEATHER_TEMPERATURE", atof(observationIterator->value.toString()));
                  }
                  else if (!strcmp(observationIterator->key, "wind_kph"))
                  {
                      if (observationIterator->value.isDouble())
                          setParameterValue("WEATHER_WIND_SPEED", observationIterator->value.toNumber());
                      else
                          setParameterValue("WEATHER_WIND_SPEED", atof(observationIterator->value.toString()));
                  }
                  else if (!strcmp(observationIterator->key, "wind_gust_kph"))
                  {
                      if (observationIterator->value.isDouble())
                        setParameterValue("WEATHER_WIND_GUST", observationIterator->value.toNumber());
                      else
                        setParameterValue("WEATHER_WIND_GUST", atof(observationIterator->value.toString()));
                  }
                  else if (!strcmp(observationIterator->key, "precip_1hr_metric"))
                  {
                      char *value = observationIterator->value.toString();
                      double mm=-1;
                      if (!strcmp(value, "--"))
                          setParameterValue("WEATHER_RAIN_HOUR", 0);
                      else
                      {
                          mm = atof(value);
                          if (mm >= 0)
                              setParameterValue("WEATHER_RAIN_HOUR", mm);
                      }
                  }
              }
          }
      }

      setlocale(LC_NUMERIC,orig);
      return IPS_OK;
}
void DistrhoUIPingPongPan::imageKnobValueChanged(ImageKnob* knob, float value)
{
    setParameterValue(knob->getId(), value);
}
void EtherCatServer::setParameterValue(unsigned int deviceAlias, int deviceOffset, std::string parameterName, int value) {
	setParameterValue("", deviceAlias, deviceOffset, parameterName, value);
}
Beispiel #23
0
IPState Vantage::updateWeather()
{    
    int nbytes_written=0, nbytes_read=0, rc=-1;
    char errstr[MAXRBUF];
    char command[VANTAGE_CMD];
    char response[VANTAGE_RES];

    if (wakeup() == false)
        return IPS_ALERT;

    strncpy(command, "LOOP 1", VANTAGE_CMD);
    command[6] = 0;

    tcflush(PortFD, TCIOFLUSH);

    DEBUGF(INDI::Logger::DBG_DEBUG, "CMD (%s)", command);

    command[6] = 0xA;

    if ( (rc = tty_write(PortFD, command, 7, &nbytes_written)) != TTY_OK)
    {
        tty_error_msg(rc, errstr, MAXRBUF);
        DEBUGF(INDI::Logger::DBG_ERROR, "Loop error: %s.", errstr);
        return IPS_ALERT;
    }

    if ( (rc = tty_read(PortFD, response, 1, VANTAGE_TIMEOUT, &nbytes_read)) != TTY_OK)
    {
        tty_error_msg(rc, errstr, MAXRBUF);
        DEBUGF(INDI::Logger::DBG_ERROR, "Loop error: %s.", errstr);
        return IPS_ALERT;
    }

    if (response[0] != 0x06)
    {
        DEBUGF(INDI::Logger::DBG_ERROR, "Expecting 0x06, received %#X", response[0]);
        return IPS_ALERT;
    }

    if ( (rc = tty_read(PortFD, response, 99, VANTAGE_TIMEOUT, &nbytes_read)) != TTY_OK)
    {
        tty_error_msg(rc, errstr, MAXRBUF);
        DEBUGF(INDI::Logger::DBG_ERROR, "Loop error: %s.", errstr);
        return IPS_ALERT;
    }

    uint16_t crc = crc16(response, 99);

    if (crc != 0)
    {
        DEBUG(INDI::Logger::DBG_ERROR, "CRC check failed.");
        return IPS_ALERT;
    }

    uint8_t *loopData = (uint8_t *) response;

    DEBUGF(INDI::Logger::DBG_DEBUG, "Packet Type (%d)", loopData[4]);

    uint8_t forecastValue = loopData[89];

    DEBUGF(INDI::Logger::DBG_DEBUG, "Raw Forecast (%d)", forecastValue);

    switch (forecastValue)
    {
    // Clear
    case 0x08:
        DEBUG(INDI::Logger::DBG_SESSION, "Forecast: Mostly Clear.");
        setParameterValue("WEATHER_FORECAST", 0);
        break;

    case 0x06:
        DEBUG(INDI::Logger::DBG_SESSION, "Forecast: Partly Cloudy.");
        setParameterValue("WEATHER_FORECAST", 1);
        break;

    case 0x02:
        DEBUG(INDI::Logger::DBG_SESSION, "Forecast: Mostly Cloudy.");
        setParameterValue("WEATHER_FORECAST", 2);
        break;

    case 0x03:
        DEBUG(INDI::Logger::DBG_SESSION, "Forecast: Mostly Cloudy. Rain within 12 hours.");
        setParameterValue("WEATHER_FORECAST", 2);
        break;

    case 0x12:
        DEBUG(INDI::Logger::DBG_SESSION, "Forecast: Mostly Cloudy. Snow within 12 hours.");
        setParameterValue("WEATHER_FORECAST", 2);
        break;

    case 0x13:
        DEBUG(INDI::Logger::DBG_SESSION, "Forecast: Mostly Cloudy. Rain or Snow within 12 hours.");
        setParameterValue("WEATHER_FORECAST", 2);
        break;

    case 0x07:
        DEBUG(INDI::Logger::DBG_SESSION, "Forecast: Partly Cloudy. Rain within 12 hours.");
        setParameterValue("WEATHER_FORECAST", 1);
        break;

    case 0x16:
        DEBUG(INDI::Logger::DBG_SESSION, "Forecast: Partly Cloudy. Snow within 12 hours.");
        setParameterValue("WEATHER_FORECAST", 1);
        break;

    case 0x17:
        DEBUG(INDI::Logger::DBG_SESSION, "Forecast: Partly Cloudy. Rain or Snow within 12 hours.");
        setParameterValue("WEATHER_FORECAST", 1);
        break;

    }

    // Inside Temperature
    uint16_t temperatureValue = loopData[10] << 8 | loopData[9];

    setParameterValue("WEATHER_TEMPERATURE", ( (temperatureValue/10.0) - 32) / 1.8);

    DEBUGF(INDI::Logger::DBG_DEBUG, "Raw Temperature (%d) [%#4X %#4X]", temperatureValue, loopData[9], loopData[10]);

    // Barometer
    uint16_t barometerValue = loopData[8] << 8 | loopData[7];

    setParameterValue("WEATHER_BAROMETER", (barometerValue/1000.0) * 33.8639);

    DEBUGF(INDI::Logger::DBG_DEBUG, "Raw Barometer (%d) [%#4X %#4X]", barometerValue, loopData[7], loopData[8]);

    // Wind Speed
    uint8_t windValue = loopData[14];

    DEBUGF(INDI::Logger::DBG_DEBUG, "Raw Wind Speed (%d) [%#X4]", windValue, loopData[14]);

    setParameterValue("WEATHER_WIND_SPEED", windValue / 0.62137);

    // Wind Direction
    uint16_t windDir = loopData[17] << 8 | loopData[16];

    DEBUGF(INDI::Logger::DBG_DEBUG, "Raw Wind Direction (%d) [%#4X,%#4X]", windDir, loopData[16], loopData[17]);

    setParameterValue("WEATHER_WIND_DIRECTION", windDir);

    // Rain Rate
    uint16_t rainRate = loopData[42] << 8 | loopData[41];

    DEBUGF(INDI::Logger::DBG_DEBUG, "Raw Rain Rate (%d) [%#4X,%#4X]", rainRate, loopData[41], loopData[42]);

    setParameterValue("WEATHER_RAIN_RATE", rainRate / (100 * 0.039370));

    // Solar Radiation
    uint16_t solarRadiation = loopData[45] << 8 | loopData[44];

    DEBUGF(INDI::Logger::DBG_DEBUG, "Raw Solar Radiation (%d) [%#4X,%#4X]", solarRadiation, loopData[44], loopData[45]);

    if (solarRadiation == 32767)
        solarRadiation = 0;

    setParameterValue("WEATHER_SOLAR_RADIATION", solarRadiation);

    return IPS_OK;
}
Beispiel #24
0
void ZamNoiseUI::imageToggleClicked(ImageToggle*, int)
{
        float toggle = fToggleNoise->getValue();
        fToggleNoise->setValue(toggle);
        setParameterValue(ZamNoisePlugin::paramNoiseToggle, toggle);
}
// TODO: we need to template this for different types of value
void EtherCatServer::setParameterValue(std::string deviceName, std::string parameterName, int value) {
	setParameterValue(deviceName, 0, 0, parameterName, value);
}