ETM-Schurig/etm-powersync-plugins
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

fixed switches, added init arguments

Browse Source
This commit is contained in:
nymea 2019-08-26 00:26:00 +02:00
parent e0e77abcbf
commit 5e0e99900a
5 changed files with 140 additions and 147 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

212
onewire/devicepluginonewire.cpp
View File

@ -1,6 +1,6 @@
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* *
* Copyright (C) 2018 Bernhard Trinnes <bernhard.trinnes@guh.io *
* Copyright (C) 2018 Bernhard Trinnes <bernhard.trinnes@nymea.io> *
* *
* This file is part of nymea. *
* *
@ -20,24 +20,7 @@
* *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/*!
\page onewire.html
\title One wire
\brief Plugin for one wire devices.
\ingroup plugins
\ingroup nymea-plugins
This plugin allows to receive data from the onw wire file system.
\chapter Plugin properties
Following JSON file contains the definition and the description of all available \l{DeviceClass}{DeviceClasses}
and \l{Vendor}{Vendors} of this \l{DevicePlugin}.
For more details how to read this JSON file please check out the documentation for \l{The plugin JSON File}.
\quotefile plugins/deviceplugins/OneWire/devicepluginOneWire.json
*/
#include "devicepluginonewire.h"
#include "devices/device.h"
@ -46,19 +29,22 @@
#include <QDebug>
#include <QDir>
//https://github.com/owfs
//https://github.com/owfs/owfs-doc/wiki
DevicePluginOneWire::DevicePluginOneWire()
{
}
void DevicePluginOneWire::init()
{
}
Device::DeviceError DevicePluginOneWire::discoverDevices(const DeviceClassId &deviceClassId, const ParamList &params)
{
Q_UNUSED(params);
if (deviceClassId == temperatureSensorDeviceClassId) {
if (deviceClassId == temperatureSensorDeviceClassId ||
deviceClassId == singleChannelSwitchDeviceClassId ||
deviceClassId == dualChannelSwitchDeviceClassId ||
deviceClassId == eightChannelSwitchDeviceClassId) {
foreach(Device *parentDevice, myDevices().filterByDeviceClassId(oneWireInterfaceDeviceClassId)) {
if (parentDevice->stateValue(oneWireInterfaceAutoAddStateTypeId).toBool()) {
@ -77,6 +63,7 @@ Device::DeviceError DevicePluginOneWire::discoverDevices(const DeviceClassId &de
Device::DeviceSetupStatus DevicePluginOneWire::setupDevice(Device *device)
{
if(!m_pluginTimer) {
m_pluginTimer = hardwareManager()->pluginTimerManager()->registerTimer(10);
connect(m_pluginTimer, &PluginTimer::timeout, this, &DevicePluginOneWire::onPluginTimer);
@ -85,14 +72,16 @@ Device::DeviceSetupStatus DevicePluginOneWire::setupDevice(Device *device)
if (device->deviceClassId() == oneWireInterfaceDeviceClassId) {
qCDebug(dcOneWire) << "Setup one wire interface";
/*if(!myDevices().filterByDeviceClassId(oneWireInterfaceDeviceClassId).isEmpty()) {
qCWarning(dcOneWire) << "Only one one wire interfaces allowed";
if (m_oneWireInterface) {
qCWarning(dcOneWire) << "One wire interface already set up";
return Device::DeviceSetupStatusFailure;
}*/
m_oneWireInterface = new OneWire(device->paramValue(oneWireInterfaceDevicePathParamTypeId).toByteArray(), this);
}
m_oneWireInterface = new OneWire(this);
QByteArray initArguments = device->paramValue(oneWireInterfaceDeviceInitArgsParamTypeId).toByteArray();
if (!m_oneWireInterface->init()){
if (!m_oneWireInterface->init(initArguments)){
m_oneWireInterface->deleteLater();
m_oneWireInterface = nullptr;
return Device::DeviceSetupStatusFailure;
}
connect(m_oneWireInterface, &OneWire::devicesDiscovered, this, &DevicePluginOneWire::onOneWireDevicesDiscovered);
@ -109,14 +98,6 @@ Device::DeviceSetupStatus DevicePluginOneWire::setupDevice(Device *device)
return Device::DeviceSetupStatusSuccess;
}
if (device->deviceClassId() == iButtonDeviceClassId) {
qCDebug(dcOneWire) << "Setup one wire iButton" << device->params();
if (!m_oneWireInterface) {
}
return Device::DeviceSetupStatusSuccess;
}
if (device->deviceClassId() == singleChannelSwitchDeviceClassId) {
qCDebug(dcOneWire) << "Setup one wire switch" << device->params();
if (!m_oneWireInterface) {
@ -125,6 +106,32 @@ Device::DeviceSetupStatus DevicePluginOneWire::setupDevice(Device *device)
}
return Device::DeviceSetupStatusSuccess;
}
if (device->deviceClassId() == dualChannelSwitchDeviceClassId) {
qCDebug(dcOneWire) << "Setup one wire dual switch" << device->params();
if (!m_oneWireInterface) {
QByteArray address = device->paramValue(dualChannelSwitchDeviceAddressParamTypeId).toByteArray();
device->setStateValue(dualChannelSwitchDigitalOutput1StateTypeId, m_oneWireInterface->getSwitchOutput(address, OneWire::SwitchChannel::PIO_A));
device->setStateValue(dualChannelSwitchDigitalOutput2StateTypeId, m_oneWireInterface->getSwitchOutput(address, OneWire::SwitchChannel::PIO_B));
}
return Device::DeviceSetupStatusSuccess;
}
if (device->deviceClassId() == eightChannelSwitchDeviceClassId) {
qCDebug(dcOneWire) << "Setup one wire eight channel switch" << device->params();
if (!m_oneWireInterface) {
QByteArray address = device->paramValue(eightChannelSwitchDeviceAddressParamTypeId).toByteArray();
device->setStateValue(eightChannelSwitchDigitalOutput1StateTypeId, m_oneWireInterface->getSwitchOutput(address, OneWire::SwitchChannel::PIO_A));
device->setStateValue(eightChannelSwitchDigitalOutput2StateTypeId, m_oneWireInterface->getSwitchOutput(address, OneWire::SwitchChannel::PIO_B));
device->setStateValue(eightChannelSwitchDigitalOutput3StateTypeId, m_oneWireInterface->getSwitchOutput(address, OneWire::SwitchChannel::PIO_C));
device->setStateValue(eightChannelSwitchDigitalOutput4StateTypeId, m_oneWireInterface->getSwitchOutput(address, OneWire::SwitchChannel::PIO_D));
device->setStateValue(eightChannelSwitchDigitalOutput5StateTypeId, m_oneWireInterface->getSwitchOutput(address, OneWire::SwitchChannel::PIO_E));
device->setStateValue(eightChannelSwitchDigitalOutput6StateTypeId, m_oneWireInterface->getSwitchOutput(address, OneWire::SwitchChannel::PIO_F));
device->setStateValue(eightChannelSwitchDigitalOutput7StateTypeId, m_oneWireInterface->getSwitchOutput(address, OneWire::SwitchChannel::PIO_G));
device->setStateValue(eightChannelSwitchDigitalOutput8StateTypeId, m_oneWireInterface->getSwitchOutput(address, OneWire::SwitchChannel::PIO_H));
}
return Device::DeviceSetupStatusSuccess;
}
return Device::DeviceSetupStatusFailure;
}
@ -147,6 +154,54 @@ Device::DeviceError DevicePluginOneWire::executeAction(Device *device, const Act
}
return Device::DeviceErrorActionTypeNotFound;
}
if (device->deviceClassId() == dualChannelSwitchDeviceClassId) {
if (action.actionTypeId() == dualChannelSwitchDigitalOutput1ActionTypeId){
m_oneWireInterface->setSwitchOutput(device->paramValue(dualChannelSwitchDeviceAddressParamTypeId).toByteArray(), OneWire::SwitchChannel::PIO_A, action.param(dualChannelSwitchDigitalOutput1ActionDigitalOutput1ParamTypeId).value().toBool());
return Device::DeviceErrorNoError;
}
if (action.actionTypeId() == dualChannelSwitchDigitalOutput2ActionTypeId){
m_oneWireInterface->setSwitchOutput(device->paramValue(dualChannelSwitchDeviceAddressParamTypeId).toByteArray(), OneWire::SwitchChannel::PIO_B, action.param(dualChannelSwitchDigitalOutput2ActionDigitalOutput2ParamTypeId).value().toBool());
return Device::DeviceErrorNoError;
}
return Device::DeviceErrorActionTypeNotFound;
}
if (device->deviceClassId() == eightChannelSwitchDeviceClassId) {
if (action.actionTypeId() == eightChannelSwitchDigitalOutput1ActionTypeId){
m_oneWireInterface->setSwitchOutput(device->paramValue(eightChannelSwitchDeviceAddressParamTypeId).toByteArray(), OneWire::SwitchChannel::PIO_A, action.param(eightChannelSwitchDigitalOutput1ActionDigitalOutput1ParamTypeId).value().toBool());
return Device::DeviceErrorNoError;
}
if (action.actionTypeId() == eightChannelSwitchDigitalOutput2ActionTypeId){
m_oneWireInterface->setSwitchOutput(device->paramValue(eightChannelSwitchDeviceAddressParamTypeId).toByteArray(), OneWire::SwitchChannel::PIO_B, action.param(eightChannelSwitchDigitalOutput2ActionDigitalOutput2ParamTypeId).value().toBool());
return Device::DeviceErrorNoError;
}
if (action.actionTypeId() == eightChannelSwitchDigitalOutput3ActionTypeId){
m_oneWireInterface->setSwitchOutput(device->paramValue(eightChannelSwitchDeviceAddressParamTypeId).toByteArray(), OneWire::SwitchChannel::PIO_C, action.param(eightChannelSwitchDigitalOutput3ActionDigitalOutput3ParamTypeId).value().toBool());
return Device::DeviceErrorNoError;
}
if (action.actionTypeId() == eightChannelSwitchDigitalOutput4ActionTypeId){
m_oneWireInterface->setSwitchOutput(device->paramValue(eightChannelSwitchDeviceAddressParamTypeId).toByteArray(), OneWire::SwitchChannel::PIO_D, action.param(eightChannelSwitchDigitalOutput4ActionDigitalOutput4ParamTypeId).value().toBool());
return Device::DeviceErrorNoError;
}
if (action.actionTypeId() == eightChannelSwitchDigitalOutput5ActionTypeId){
m_oneWireInterface->setSwitchOutput(device->paramValue(eightChannelSwitchDeviceAddressParamTypeId).toByteArray(), OneWire::SwitchChannel::PIO_E, action.param(eightChannelSwitchDigitalOutput5ActionDigitalOutput5ParamTypeId).value().toBool());
return Device::DeviceErrorNoError;
}
if (action.actionTypeId() == eightChannelSwitchDigitalOutput6ActionTypeId){
m_oneWireInterface->setSwitchOutput(device->paramValue(eightChannelSwitchDeviceAddressParamTypeId).toByteArray(), OneWire::SwitchChannel::PIO_F, action.param(eightChannelSwitchDigitalOutput6ActionDigitalOutput6ParamTypeId).value().toBool());
return Device::DeviceErrorNoError;
}
if (action.actionTypeId() == eightChannelSwitchDigitalOutput7ActionTypeId){
m_oneWireInterface->setSwitchOutput(device->paramValue(eightChannelSwitchDeviceAddressParamTypeId).toByteArray(), OneWire::SwitchChannel::PIO_G, action.param(eightChannelSwitchDigitalOutput7ActionDigitalOutput7ParamTypeId).value().toBool());
return Device::DeviceErrorNoError;
}
if (action.actionTypeId() == eightChannelSwitchDigitalOutput8ActionTypeId){
m_oneWireInterface->setSwitchOutput(device->paramValue(eightChannelSwitchDeviceAddressParamTypeId).toByteArray(), OneWire::SwitchChannel::PIO_H, action.param(eightChannelSwitchDigitalOutput8ActionDigitalOutput8ParamTypeId).value().toBool());
return Device::DeviceErrorNoError;
}
return Device::DeviceErrorActionTypeNotFound;
}
return Device::DeviceErrorNoError;
}
@ -155,12 +210,13 @@ void DevicePluginOneWire::deviceRemoved(Device *device)
{
if (device->deviceClassId() == oneWireInterfaceDeviceClassId) {
m_oneWireInterface->deleteLater();
m_oneWireInterface = nullptr;
return;
}
if (myDevices().empty()) {
hardwareManager()->pluginTimerManager()->unregisterTimer(m_pluginTimer);
m_pluginTimer = nullptr;
}
}
@ -182,6 +238,29 @@ void DevicePluginOneWire::onPluginTimer()
double temperature = m_oneWireInterface->getTemperature(address);
device->setStateValue(temperatureSensorTemperatureStateTypeId, temperature);
}
if (device->deviceClassId() == singleChannelSwitchDeviceClassId) {
QByteArray address = device->paramValue(singleChannelSwitchDeviceAddressParamTypeId).toByteArray();
device->setStateValue(singleChannelSwitchDigitalOutputStateTypeId, m_oneWireInterface->getSwitchOutput(address, OneWire::SwitchChannel::PIO_A));
}
if (device->deviceClassId() == dualChannelSwitchDeviceClassId) {
QByteArray address = device->paramValue(dualChannelSwitchDeviceAddressParamTypeId).toByteArray();
device->setStateValue(dualChannelSwitchDigitalOutput1StateTypeId, m_oneWireInterface->getSwitchOutput(address, OneWire::SwitchChannel::PIO_A));
device->setStateValue(dualChannelSwitchDigitalOutput2StateTypeId, m_oneWireInterface->getSwitchOutput(address, OneWire::SwitchChannel::PIO_B));
}
if (device->deviceClassId() == eightChannelSwitchDeviceClassId) {
QByteArray address = device->paramValue(eightChannelSwitchDeviceAddressParamTypeId).toByteArray();
device->setStateValue(eightChannelSwitchDigitalOutput1StateTypeId, m_oneWireInterface->getSwitchOutput(address, OneWire::SwitchChannel::PIO_A));
device->setStateValue(eightChannelSwitchDigitalOutput2StateTypeId, m_oneWireInterface->getSwitchOutput(address, OneWire::SwitchChannel::PIO_B));
device->setStateValue(eightChannelSwitchDigitalOutput3StateTypeId, m_oneWireInterface->getSwitchOutput(address, OneWire::SwitchChannel::PIO_C));
device->setStateValue(eightChannelSwitchDigitalOutput4StateTypeId, m_oneWireInterface->getSwitchOutput(address, OneWire::SwitchChannel::PIO_D));
device->setStateValue(eightChannelSwitchDigitalOutput5StateTypeId, m_oneWireInterface->getSwitchOutput(address, OneWire::SwitchChannel::PIO_E));
device->setStateValue(eightChannelSwitchDigitalOutput6StateTypeId, m_oneWireInterface->getSwitchOutput(address, OneWire::SwitchChannel::PIO_F));
device->setStateValue(eightChannelSwitchDigitalOutput7StateTypeId, m_oneWireInterface->getSwitchOutput(address, OneWire::SwitchChannel::PIO_G));
device->setStateValue(eightChannelSwitchDigitalOutput8StateTypeId, m_oneWireInterface->getSwitchOutput(address, OneWire::SwitchChannel::PIO_H));
}
}
}
@ -272,66 +351,19 @@ void DevicePluginOneWire::onOneWireDevicesDiscovered(QList<OneWire::OneWireDevic
if (!singleChannelSwitchDeviceDescriptors.isEmpty())
emit autoDevicesAppeared(singleChannelSwitchDeviceClassId, singleChannelSwitchDeviceDescriptors);
if (!dualChannelSwitchDeviceDescriptors.isEmpty())
emit autoDevicesAppeared(dualChannelSwitchDeviceClassId, temperatureDeviceDescriptors);
if (!temperatureDeviceDescriptors.isEmpty())
emit autoDevicesAppeared(temperatureSensorDeviceClassId, temperatureDeviceDescriptors);
emit autoDevicesAppeared(dualChannelSwitchDeviceClassId, dualChannelSwitchDeviceDescriptors);
if (!eightChannelSwitchDeviceDescriptors.isEmpty())
emit autoDevicesAppeared(eightChannelSwitchDeviceClassId, eightChannelSwitchDeviceDescriptors);
} else {
if (!temperatureDeviceDescriptors.isEmpty())
emit devicesDiscovered(temperatureSensorDeviceClassId, temperatureDeviceDescriptors);
if (!singleChannelSwitchDeviceDescriptors.isEmpty())
emit devicesDiscovered(singleChannelSwitchDeviceClassId, singleChannelSwitchDeviceDescriptors);
if (!dualChannelSwitchDeviceDescriptors.isEmpty())
emit devicesDiscovered(dualChannelSwitchDeviceClassId, temperatureDeviceDescriptors);
if (!temperatureDeviceDescriptors.isEmpty())
emit devicesDiscovered(temperatureSensorDeviceClassId, temperatureDeviceDescriptors);
emit devicesDiscovered(dualChannelSwitchDeviceClassId, dualChannelSwitchDeviceDescriptors);
if (!eightChannelSwitchDeviceDescriptors.isEmpty())
emit devicesDiscovered(eightChannelSwitchDeviceClassId, eightChannelSwitchDeviceDescriptors);
}
break;
}
}
/* foreach(QByteArray member, dirMembers) {
int family = member.split('.').first().toInt(nullptr, 16);
qDebug(dcOneWire()) << "Member" << member << member.left(2) << family;
member.remove(member.indexOf('/'), 1);
QByteArray type;
switch (family) {
//https://github.com/owfs/owfs-doc/wiki/1Wire-Device-List
case 0x10: //DS18S20
case 0x28: //DS18B20
case 0x3b: //DS1825, MAX31826, MAX31850
OneWireDevice device;
device.family =family;
device.Address = member.split('.').last();
device.Type = getValue(member, "type");
oneWireDevices.append(device);
qDebug(dcOneWire()) << "Discovered temperature sensor" << type << member;
break;
case 0x05:
case 0x12:
case 0x1C:
case 0x3A:
OneWireDevice device;
device.family =family;
device.Address = member.split('.').last();
device.Type = getValue(member, "type");
oneWireDevices.append(device);
qDebug(dcOneWire()) << "Discovered temperature sensor" << type << member;
qDebug(dcOneWire()) << "Discovered switch" << type << member;
break;
case 0x08: //DS1992 1kbit Memory iButton
case 0x06: //DS1993 4kbit Memory iButton
case 0x0A: //DS1995 16kbit Memory iButton
case 0x0C: //DS1996 64kbit Memory iButton
type = getValue(member, "type");
qDebug(dcOneWire()) << "Discovered ID device" << type << member;
break;
default:
//type = getValue(member, "type");
//qDebug(dcOneWire()) << "Discovered unknown " << type << member;
//emit unknownDeviceDiscovered(member, type);
break ;
}
}
if(!oneWireDevices.isEmpty*/

2
onewire/devicepluginonewire.h
View File

@ -37,6 +37,7 @@ class DevicePluginOneWire : public DevicePlugin
public:
explicit DevicePluginOneWire();
void init() override;
Device::DeviceError discoverDevices(const DeviceClassId &deviceClassId, const ParamList &params) override;
Device::DeviceSetupStatus setupDevice(Device *device) override;
@ -49,7 +50,6 @@ private:
private slots:
void onPluginTimer();
void onOneWireDevicesDiscovered(QList<OneWire::OneWireDevice> devices);
};

42
onewire/devicepluginonewire.json
View File

@ -12,15 +12,15 @@
"id": "c36c68d9-6182-4ae1-972d-b8b5e0cf185f",
"name": "oneWireInterface",
"displayName": "One wire interface",
"interfaces": ["connectable"],
"interfaces": ["gateway"],
"createMethods": ["user"],
"paramTypes": [
{
"id": "a0e773ff-fd19-499e-96f0-830168229cd3",
"name": "path",
"displayName": "Path",
"name": "initArgs",
"displayName": "OWFS init arguments",
"type": "QString",
"defaultValue": "/dev/ttyS0"
"defaultValue": "--i2c=ALL:ALL"
}
],
"stateTypes": [
@ -267,40 +267,6 @@
"writable": true
}
]
},
{
"id": "22aff41f-0f48-40f2-aa4e-bb251723be1c",
"name": "iButton",
"displayName": "iButton",
"interfaces": [ ],
"createMethods": ["discovery"],
"paramTypes": [
{
"id": "759e919c-8af2-43dd-af99-9b8c59321050",
"name": "address",
"displayName": "Address",
"type": "QString",
"readOnly": true
},
{
"id": "5ca8d942-4ef2-47be-8ac9-be2ee19e168d",
"name": "type",
"displayName": "Type",
"type": "QString",
"inputType": "TextLine",
"readOnly": true
}
],
"stateTypes": [
],
"eventTypes": [
{
"id": "61d69bec-c948-4703-9686-8762381d0ae4",
"name": "authenticated",
"displayName": "Authenticated"
}
]
}
]
}

25
onewire/onewire.cpp
View File

@ -23,9 +23,8 @@
#include "onewire.h"
#include "extern-plugininfo.h"
OneWire::OneWire(const QByteArray &deviceLocation, QObject *parent) :
QObject(parent),
m_deviceLocation(deviceLocation)
OneWire::OneWire(QObject *parent) :
QObject(parent)
{
}
@ -35,13 +34,17 @@ OneWire::~OneWire()
OW_finish();
}
bool OneWire::init()
bool OneWire::init(const QByteArray &owfsInitArguments)
{
QByteArray initArguments;
//QByteArray initArguments;
//Test OWFS arguments
//initArguments.append("--fake 28 --fake 10"); //fake temperature sensors
//initArguments.append("--fake 29 --fake 12 --fake 05"); //fake temperature sensors
initArguments.append("--i2c=ALL:ALL");
if (OW_init(initArguments) < 0) {
//initArguments.append("--fake 29 --fake 12 --fake 05"); //fake temperature sensor
//Test i2c
//initArguments.append("--i2c=ALL:ALL");
if (OW_init(owfsInitArguments) < 0) {
qWarning(dcOneWire()) << "ERROR initialising one wire" << strerror(errno);
return false;
}
@ -165,12 +168,6 @@ double OneWire::getTemperature(const QByteArray &address)
return temperature.toDouble();
}
QByteArray OneWire::readMemory(const QByteArray &address)
{
//getValue
return address; //TODDO
}
QByteArray OneWire::getType(const QByteArray &address)
{
QByteArray type = getValue(address, "type");

6
onewire/onewire.h
View File

@ -58,9 +58,9 @@ public:
QByteArray type;
};
explicit OneWire(const QByteArray &deviceLocation, QObject *parent = nullptr);
explicit OneWire(QObject *parent = nullptr);
~OneWire();
bool init();
bool init(const QByteArray &owfsInitArguments);
QByteArray getPath();
bool discoverDevices();
@ -69,13 +69,11 @@ public:
double getTemperature(const QByteArray &address);
QByteArray getType(const QByteArray &address);
QByteArray readMemory(const QByteArray &address);
bool getSwitchOutput(const QByteArray &address, SwitchChannel channel);
void setSwitchOutput(const QByteArray &address, SwitchChannel channel, bool state);
bool getSwitchInput(const QByteArray &address, SwitchChannel channel);
private:
QByteArray m_deviceLocation;
QByteArray m_path;
QByteArray getValue(const QByteArray &address, const QByteArray &deviceType);
void setValue(const QByteArray &address, const QByteArray &deviceType, const QByteArray &value);