[dss-developer] geräteorientiertes Loggen

[Hofmann, Christoph]

Hallo Alexander,

ich möchte nicht detailliert auf all Deine Vorschläge eingehen.
Nur ein paar Anmerkungen:

-          Es wäre unschön, hin und wieder mal ein Gerät nur dazu einzuschalten, um die Leistung zu ermitteln.

-          Insbesondere Leuchtmittel (Glühbirnen) haben keinen zum Ausgangswert linearen Stromverbrauch.

-          Aktuell wissen wir im dSS noch nicht, bei welchen Szenen welche Geräte an oder aus sind. (Es ist geplant, zukünftig diese Informationen im dSS zu sammeln.)

Der Stromverbrauch eines einzelnen Gerätes kann abgefragt werden. Dies hatte ich Dir in [1] mal erklärt. Prinzipiell könnte man (mit dem Wissen, in welcher Szene ein bestimmtes Gerät an ist) ein von Dir beschriebenes Verfahren auch selber als dS Add-On implementieren.

Schöne Grüße
Christoph

[1] http://forum.digitalstrom.org/pipermail/dss-developer/2012-March/000429.html


--
Christoph Hofmann
aizo gmbh, Deutschland - http://www.aizo.com



Von: dss-developer-bounces at forum.digitalstrom.org [mailto:dss-developer-bounces at forum.digitalstrom.org] Im Auftrag von Alexander Betker
Gesendet: Donnerstag, 26. Juli 2012 17:09
An: dss-developer at forum.digitalstrom.org
Betreff: [dss-developer] geräteorientiertes Loggen

Hallo zusammen,

momentan wird ja dSM-basiert der Stromverbrauch vom kompl. Stromkreis
geloggt. Die gezielte JSON-Abfrage eines Devices gibt momentan "0" zurück.
Ein permanentes Abfragen würde ja auch den Bus überlasten und der Traffic
über die Stromleitung würde erhöht.

Wenn also das Device weitere Variablen erhalten würde:



    int maxPowerConsumption;
    (int minPowerConsumption;)
    int standbyPowerConsumption;
    int configValue;

MaxPowerConsumption ist ist der Stromverbrauch, den das Gerät bei
vollem Betrieb hat und wird bei dem ersten Initialisieren
durch das System ermittelt, indem, wenn ein komplett
neue Hardware gefunden wird, der Verbraucher einmal eingeschaltet wird
und der Stromverbrauch über den Sensor gemessen wird. Dann wird das
Gerät wieder ausgeschaltet und erneut der Stromverbrauch ermittelt
(Standby-Verbrauch).

Diese Variablen werden in der Apartment.xml beim jeweiligen
Device gespeichrt.



modelpersistence.cpp

void ModelPersistence::loadDevices(Node* _node) {

      ... // Code

      int maxPowerConsumption = 0;
      if (elem->hasAttribute("maxPowerConsumption"))
              maxPowerConsumption = strToInt(elem->getAttribute("maxPowerConsumption"));

      int minPowerConsumption = 0;
      if (elem->hasAttribute("minPowerConsumption"))
              minPowerConsumption = strToInt(elem->getAttribute("minPowerConsumption"));

      int standbyPowerConsumption = 0;
      if (elem->hasAttribute("standbyPowerConsumption"))
              standbyPowerConsumption = strToInt(elem->getAttribute("standbyPowerConsumption"));

      int configValue = 0;
          if (elem->hasAttribute("configValue"))
              configValue = strToInt(elem->getAttribute("configValue"));

    ... // weiter Code



    newDevice->setConfigValue(configValue);
                  newDevice->setStandbyPowerConsumption(standbyPowerConsumption);
          newDevice->setMinPowerConsumption(minPowerConsumption);
          newDevice->setMaxPowerConsumption(maxPowerConsumption);

    ... // weiter Code

}



void deviceToXML( .. )

pDeviceNode->setAttribute("minPowerConsumption", intToString(_pDevice->getMinPowerConsumption()));
    pDeviceNode->setAttribute("maxPowerConsumption", intToString(_pDevice->getMaxPowerConsumption()));
    pDeviceNode->setAttribute("standbyPowerConsumption", intToString(_pDevice->getStandbyPowerConsumption()));
    pDeviceNode->setAttribute("configValue", intToString(_pDevice->getConfigValue()));

...

In der Klasse dss.cpp die Aufforderung, sollte das System mal herunter fahren,
unbedingt die Apartment.xml aktualisieren



dss.cpp

... //Code
m_State = ssTerminating;
m_pModelMaintenance.get()->addModelEvent(new ModelEvent(ModelEvent::etModelDirty));

std::for_each(m_Subsystems.begin(), m_Subsystems.end(), StopSubsystem);
m_pEventQueue->shutdown();
m_pEventInterpreter->terminate();

...

Wir haben nun einmal persistent was das Gerät verbraucht im Betrieb und
im StandBy, die Variable configValue die wir brauchen werden um zu wissen,
ob das Gerät an oder aus oder gedimmt ist. Beim Wert 0 ist es aus,
bei 255 ist es an und dazwischen ist es halt gedimmt. Wenn nun eine
callScene aufgerufen wird, muss diese Variable aktualisiert werden.

Die Methode getPowerConsumption würde dann so aussehen:



unsigned long Device::getPowerConsumption() {
        if (isPresent()) {
              if (configValue == 0)
                    return standbyPowerConsumption;
              else
                    return maxPowerConsumption*(configValue/255);
        }
        else return 0;

} // getPowerConsumption

Natürlich ist das jetzt nicht perfekt und geht auch nur bei Verbrauchern, die
einen konstanten Stromverbrauch haben und nicht dynamisch wie etwa bei
Computern die unter Vollast mehr verbrauchen als unter Office-Betrieb.
Aber bei Lampen geht das (bei Leuchtmittelwechsel mit andere Wattzahl
muss eine Kalibrierung durchgeführt werden) und wie gesagt bei "normalen"
Geräten. In der minPowerConsumption kann man speichern, wenn
ein Gerät über eine Leistungsstufe verfügt (ähnlich wie beim Ventilator
mit versch. Leistungsstufen) wobei dann wahrscheinlich mehr zwischen
Variablen gebraucht würden.

Die Methode isOn vielleicht:

bool Device::isOn() const {

    if (isPresent()) {

        if (configValue == 0)
            return false;
        else return true;
    }

    else return false;
} // isOn

Soweit die Idee, nicht vollkommen da jeder Statuswechsel, der das Gerät
betrifft (an, aus und dimmen) im configValue festgehalten werden muss.
Aber das wäre schonmal eine große Steigerung zu jetzt, wo man nur
bei Device getPowerConsumption "0" erhält.

Und wir erzeugen hier keine zusätzliche Busbelastung! Es muss nur ledigleich
einmal ermittelt werden, was das Gerät verbraucht.

Für das geräteorientierte Loggen in



metering.h

typedef std::map<boost::shared_ptr<Device>,
                             boost::shared_ptr<std::string> > DeviceCachedSeriesMap;
DeviceCachedSeriesMap m_DeviceCachedSeries;

boost::shared_ptr<std::string> getOrCreateDeviceCachedSeries(
              boost::shared_ptr<MeteringConfigChain> _pChain,
              boost::shared_ptr<Device> _device );

void postDeviceMeteringEvent(boost::shared_ptr<Device> _device,
int _valuePower, int _valueEnergy, DateTime _sampledAt);


nach dem Muster vom dSM. Entsprechend Änderungen in der Datei metering.cpp.

In modelmaintenace.cpp :

...
case ModelEvent::etMeteringValues:
...


m_pMetering->postMeteringEvent(meter, power, meter->getCachedEnergyMeterValue(), DateTime());

// Direkt nach dem DSM

for (int i=0; i < meter->getDevices().length(); i++) {
                  dss_dsid_t deviceID = meter->getDevices().get(i).getDSID();
                  boost::shared_ptr<Device> device = (meter->getDevices().getByDSID(deviceID)).getDevice();
                  m_pMetering->postDeviceMeteringEvent(device ,
        device->getPowerConsumption(), device->getEnergyMeterValue, DateTime());//
}

In der Apartment.xml könnte man auch geräteorientiert festhalten, was das Gerät bisher
verbraucht hat, ähnlich wie beim EnergyCounter im dSM.

Das Ganze ist natürlich ausbaufähig.
Hin und wieder müßten Sensor-Kontrollabfragen erfolgen.
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://forum.digitalstrom.org/pipermail/dss-developer/attachments/20120727/ad74ecc1/attachment-0001.html>