ETM-Schurig
/
nymea-plugins
mirror of https://github.com/nymea/nymea-plugins.git
1
0
Fork 0
Code Issues 1 Packages Projects Releases Wiki Activity
nymea-plugins/i2cdevices/integrationplugini2cdevices...

271 lines
14 KiB
C++
Raw Permalink Blame History

// SPDX-License-Identifier: GPL-3.0-or-later
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* Copyright (C) 2013 - 2024, nymea GmbH
* Copyright (C) 2024 - 2025, chargebyte austria GmbH
*
* This file is part of nymea-plugins.
*
* nymea-plugins is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* nymea-plugins is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with nymea-plugins. If not, see <https://www.gnu.org/licenses/>.
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
#include "integrationplugini2cdevices.h"
#include "plugininfo.h"
#include "pi16adcchannel.h"
#include "ads1115channel.h"
#include "ina219.h"
#include <hardware/i2c/i2cmanager.h>
#include <QDebug>
#include <QJsonDocument>
IntegrationPluginI2CDevices::IntegrationPluginI2CDevices(): IntegrationPlugin()
{
m_ads1115ChannelMap.insert(0, ads1115Channel1StateTypeId);
m_ads1115ChannelMap.insert(1, ads1115Channel2StateTypeId);
m_ads1115ChannelMap.insert(2, ads1115Channel3StateTypeId);
m_ads1115ChannelMap.insert(3, ads1115Channel4StateTypeId);
m_ads1115OvervoltageMap.insert(0, ads1115Channel1overvoltageStateTypeId);
m_ads1115OvervoltageMap.insert(1, ads1115Channel2overvoltageStateTypeId);
m_ads1115OvervoltageMap.insert(2, ads1115Channel3overvoltageStateTypeId);
m_ads1115OvervoltageMap.insert(3, ads1115Channel4overvoltageStateTypeId);
m_pi16adcChannelMap.insert(0, pi16ADCChannel1StateTypeId);
m_pi16adcChannelMap.insert(1, pi16ADCChannel2StateTypeId);
m_pi16adcChannelMap.insert(2, pi16ADCChannel3StateTypeId);
m_pi16adcChannelMap.insert(3, pi16ADCChannel4StateTypeId);
m_pi16adcChannelMap.insert(4, pi16ADCChannel5StateTypeId);
m_pi16adcChannelMap.insert(5, pi16ADCChannel6StateTypeId);
m_pi16adcChannelMap.insert(6, pi16ADCChannel7StateTypeId);
m_pi16adcChannelMap.insert(7, pi16ADCChannel8StateTypeId);
m_pi16adcChannelMap.insert(8, pi16ADCChannel9StateTypeId);
m_pi16adcChannelMap.insert(9, pi16ADCChannel10StateTypeId);
m_pi16adcChannelMap.insert(10, pi16ADCChannel11StateTypeId);
m_pi16adcChannelMap.insert(11, pi16ADCChannel12StateTypeId);
m_pi16adcChannelMap.insert(12, pi16ADCChannel13StateTypeId);
m_pi16adcChannelMap.insert(13, pi16ADCChannel14StateTypeId);
m_pi16adcChannelMap.insert(14, pi16ADCChannel15StateTypeId);
m_pi16adcChannelMap.insert(15, pi16ADCChannel16StateTypeId);
m_pi16adcOvervoltageMap.insert(0, pi16ADCChannel1overvoltageStateTypeId);
m_pi16adcOvervoltageMap.insert(1, pi16ADCChannel2overvoltageStateTypeId);
m_pi16adcOvervoltageMap.insert(2, pi16ADCChannel3overvoltageStateTypeId);
m_pi16adcOvervoltageMap.insert(3, pi16ADCChannel4overvoltageStateTypeId);
m_pi16adcOvervoltageMap.insert(4, pi16ADCChannel5overvoltageStateTypeId);
m_pi16adcOvervoltageMap.insert(5, pi16ADCChannel6overvoltageStateTypeId);
m_pi16adcOvervoltageMap.insert(6, pi16ADCChannel7overvoltageStateTypeId);
m_pi16adcOvervoltageMap.insert(7, pi16ADCChannel8overvoltageStateTypeId);
m_pi16adcOvervoltageMap.insert(8, pi16ADCChannel9overvoltageStateTypeId);
m_pi16adcOvervoltageMap.insert(9, pi16ADCChannel10overvoltageStateTypeId);
m_pi16adcOvervoltageMap.insert(10, pi16ADCChannel11overvoltageStateTypeId);
m_pi16adcOvervoltageMap.insert(11, pi16ADCChannel12overvoltageStateTypeId);
m_pi16adcOvervoltageMap.insert(12, pi16ADCChannel13overvoltageStateTypeId);
m_pi16adcOvervoltageMap.insert(13, pi16ADCChannel14overvoltageStateTypeId);
m_pi16adcOvervoltageMap.insert(14, pi16ADCChannel15overvoltageStateTypeId);
m_pi16adcOvervoltageMap.insert(15, pi16ADCChannel16overvoltageStateTypeId);
}
void IntegrationPluginI2CDevices::init() {
}
void IntegrationPluginI2CDevices::discoverThings(ThingDiscoveryInfo *info)
{
foreach (const I2CScanResult &scanResult, hardwareManager()->i2cManager()->scanRegisters()) {
qCDebug(dcI2cDevices()) << "Found I2C deevice on port:" << scanResult.portName << "0x" + QString::number(scanResult.address, 16);
if (info->thingClassId() == pi16ADCThingClassId) {
// Depending on jumper settings, the Pi-16ADC can be any of those:
QList<int> addresses = {0x14, 0x15, 0x16, 0x17, 0x24, 0x25, 0x26, 0x27, 0x34, 0x35, 0x36, 0x37, 0x44, 0x45, 0x46, 0x47, 0x54, 0x55, 0x56, 0x57, 0x64, 0x65, 0x66, 0x67, 0x74, 0x75, 0x76};
if (addresses.contains(scanResult.address)) {
ThingDescriptor descriptor(pi16ADCThingClassId, "Pi-16ADC", QString("%1: 0x%2").arg(scanResult.portName).arg(scanResult.address, 0, 16));
ParamList params;
params << Param(pi16ADCThingI2cPortParamTypeId, scanResult.portName);
params << Param(pi16ADCThingI2cAddressParamTypeId, scanResult.address);
descriptor.setParams(params);
info->addThingDescriptor(descriptor);
}
}
if (info->thingClassId() == ads1115ThingClassId) {
// The ADS1115 has selectable addresses from 0x48 to 0x4B
if (scanResult.address >= 0x48 && scanResult.address <= 0x4B) {
ThingDescriptor descriptor(ads1115ThingClassId, "ADS1113/ADS1114/ADS1115", QString("%1: 0x%2").arg(scanResult.portName).arg(scanResult.address, 0, 16));
ParamList params;
params << Param(ads1115ThingI2cPortParamTypeId, scanResult.portName);
params << Param(ads1115ThingI2cAddressParamTypeId, scanResult.address);
descriptor.setParams(params);
info->addThingDescriptor(descriptor);
}
}
if (info->thingClassId() == ina219ThingClassId) {
// The INA219 has selectable addresses from 0x040 tox 0x4A
if (scanResult.address >= 0x40 && scanResult.address <= 0x4A) {
ThingDescriptor descriptor(ina219ThingClassId, "INA219", QString("%1: 0x%2").arg(scanResult.portName).arg(scanResult.address, 0, 16));
ParamList params;
params << Param(ina219ThingI2cPortParamTypeId, scanResult.portName);
params << Param(ina219ThingI2cAddressParamTypeId, scanResult.address);
descriptor.setParams(params);
info->addThingDescriptor(descriptor);
}
}
}
info->finish(Thing::ThingErrorNoError);
}
void IntegrationPluginI2CDevices::setupThing(ThingSetupInfo *info)
{
if (info->thing()->thingClassId() == pi16ADCThingClassId) {
QString i2cPortName = info->thing()->paramValue(pi16ADCThingI2cPortParamTypeId).toString();
int i2cAddress = info->thing()->paramValue(pi16ADCThingI2cAddressParamTypeId).toInt();
Q_UNUSED(i2cAddress)
for (int i = 0; i < 16; i++) {
Pi16ADCChannel *pi16ADC = new Pi16ADCChannel(i2cPortName, i2cAddress, i, this);
if (!hardwareManager()->i2cManager()->open(pi16ADC)) {
delete pi16ADC;
info->finish(Thing::ThingErrorHardwareFailure, QT_TR_NOOP("Failed to open I2C port."));
return;
}
Thing *thing = info->thing();
connect(pi16ADC, &Pi16ADCChannel::readingAvailable, thing, [this, thing, i](const QByteArray &data){
if (data.length() != 3) {
qCWarning(dcI2cDevices()) << "Error reading from" << thing->name();
return;
}
int value = ((((data[0]&0x3F))<<16))+((data[1]<<8))+(((data[2]&0xE0)));
const int max = 8388608;
double transformedValue = 2.5 * value / max;
thing->setStateValue(m_pi16adcChannelMap.value(i), transformedValue);
thing->setStateValue(m_pi16adcOvervoltageMap.value(i), (data[0] & 0xC0));
});
hardwareManager()->i2cManager()->startReading(pi16ADC, 5000);
m_i2cDevices.insert(pi16ADC, thing);
}
info->finish(Thing::ThingErrorNoError);
}
if (info->thing()->thingClassId() == ads1115ThingClassId) {
QString i2cPortName = info->thing()->paramValue(ads1115ThingI2cPortParamTypeId).toString();
int i2cAddress = info->thing()->paramValue(ads1115ThingI2cAddressParamTypeId).toInt();
double gainParam = info->thing()->paramValue(ads1115ThingInputGainParamTypeId).toDouble();
ADS1115Channel::Gain inputGain = ADS1115Channel::Gain_4_096;
if (qFuzzyCompare(gainParam, 6.144)) {
inputGain = ADS1115Channel::Gain_6_144;
} else if (qFuzzyCompare(gainParam, 4.096)) {
inputGain = ADS1115Channel::Gain_4_096;
} else if (qFuzzyCompare(gainParam, 2.048)) {
inputGain = ADS1115Channel::Gain_2_048;
} else if (qFuzzyCompare(gainParam, 1.024)) {
inputGain = ADS1115Channel::Gain_1_024;
} else if (qFuzzyCompare(gainParam, 0.512)) {
inputGain = ADS1115Channel::Gain_0_512;
} else if (qFuzzyCompare(gainParam, 0.256)) {
inputGain = ADS1115Channel::Gain_0_256;
}
for (int i = 0; i < 4; i++) {
ADS1115Channel *ads1115 = new ADS1115Channel(i2cPortName, i2cAddress, i, inputGain, this);
if (!hardwareManager()->i2cManager()->open(ads1115)) {
delete ads1115;
info->finish(Thing::ThingErrorHardwareFailure, QT_TR_NOOP("Failed to open I2C port."));
return;
}
Thing *thing = info->thing();
connect(ads1115, &ADS1115Channel::readingAvailable, thing, [this, thing, i](const QByteArray &data){
if (data.length() != 2) {
qCWarning(dcI2cDevices()) << "Error reading from" << thing;
return;
}
const int max = 32768;
int value = static_cast<qint16>(data[0]) * 256 + static_cast<qint16>(data[1]);
double transformedValue = qMin(1.0 * value / max, 1.0);
thing->setStateValue(m_ads1115ChannelMap.value(i), transformedValue);
thing->setStateValue(m_ads1115OvervoltageMap.value(i), value > 32768);
});
hardwareManager()->i2cManager()->startReading(ads1115, 5000);
m_i2cDevices.insert(ads1115, thing);
}
info->finish(Thing::ThingErrorNoError);
}
if (info->thing()->thingClassId() == ina219ThingClassId) {
QString i2cPortName = info->thing()->paramValue(ina219ThingI2cPortParamTypeId).toString();
int i2cAddress = info->thing()->paramValue(ina219ThingI2cAddressParamTypeId).toInt();
double shuntOhms = info->thing()->paramValue(ina219ThingShuntOhmsParamTypeId).toDouble();
Ina219::VoltageRange voltageRange = info->thing()->paramValue(ina219ThingVoltageRangeParamTypeId).toUInt() == 16 ? Ina219::VoltageRange16 : Ina219::VoltageRange32;
Ina219 *ina219 = new Ina219(i2cPortName, i2cAddress, shuntOhms, voltageRange, this);
if (!hardwareManager()->i2cManager()->open(ina219)) {
delete ina219;
info->finish(Thing::ThingErrorHardwareFailure, QT_TR_NOOP("Failed to open I2C port."));
return;
}
Thing *thing = info->thing();
connect(ina219, &Ina219::readingAvailable, thing, [thing](const QByteArray &data){
QJsonParseError error;
QVariantMap values = QJsonDocument::fromJson(data, &error).toVariant().toMap();
if (error.error != QJsonParseError::NoError) {
qCWarning(dcI2cDevices()) << thing->name() << "Failed to read data from INA219";
return;
}
double currentPower = values.value("power").toDouble();
thing->setStateValue(ina219CurrentPowerStateTypeId, currentPower);
thing->setStateValue(ina219VoltagePhaseAStateTypeId, values.value("busVoltage").toDouble());
thing->setStateValue(ina219CurrentPhaseAStateTypeId, values.value("current").toDouble());
thing->setStateValue(ina219OverflowStateTypeId, values.value("overflow").toBool());
// Calculate an estimate of totalEnergyConsumed
QDateTime lastUpdate = thing->property("lastUpdate").toDateTime();
if (lastUpdate.isNull()) {
lastUpdate = QDateTime::currentDateTime();
}
double hoursPassed = lastUpdate.msecsTo(QDateTime::currentDateTime()) / 1000 / 60 / 60;
if (currentPower >= 0) {
double totalEnergyConsumed = thing->stateValue(ina219TotalEnergyConsumedStateTypeId).toDouble();
totalEnergyConsumed += currentPower / 1000 * hoursPassed;
thing->setStateValue(ina219TotalEnergyConsumedStateTypeId, totalEnergyConsumed);
} else {
double totalEnergyReturned = thing->stateValue(ina219TotalEnergyProducedStateTypeId).toDouble();
totalEnergyReturned += -currentPower / 1000 * hoursPassed;
thing->setStateValue(ina219TotalEnergyProducedStateTypeId, totalEnergyReturned);
}
});
hardwareManager()->i2cManager()->writeData(ina219, "init");
hardwareManager()->i2cManager()->startReading(ina219, 5000);
info->finish(Thing::ThingErrorNoError);
}
}
void IntegrationPluginI2CDevices::thingRemoved(Thing *thing)
{
foreach (I2CDevice* i2cDevice, m_i2cDevices.keys(thing)) {
hardwareManager()->i2cManager()->close(i2cDevice);
i2cDevice->deleteLater();
m_i2cDevices.take(i2cDevice);
}
}
Reference in New Issue View Git Blame Copy Permalink