[dss-developer] geräteorientiertes Loggen

[Alexander Betker]

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:

intmaxPowerConsumption;
(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/20120726/39f54242/attachment-0001.html>