Obbart/ETcontroller_PRO
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

expand and fix digitalIO class

Browse Source
This commit is contained in:
Emanuele Trabattoni
2025-07-24 13:51:21 +02:00
parent 71c7ff8756
commit 07dd200de8
12 changed files with 403 additions and 81 deletions
Download Patch File Download Diff File Expand all files Collapse all files

13
lib/GPIO/TCA9554PWR_Driver.cpp
View File

@@ -53,6 +53,12 @@ namespace drivers
return setPort(newState);
}
const bool TCA9554PWR::toggleOut(const uint8_t channel)
{
bool value;
return readOut(channel, value) && setOut(channel, value);
}
const bool TCA9554PWR::setPort(const uint8_t state)
{
if (writeRegister(TCA9554_OUTPUT_REG, state))
@@ -61,7 +67,7 @@ namespace drivers
return false;
}
const bool TCA9554PWR::readOut(const uint8_t ch)
const bool TCA9554PWR::readOut(const uint8_t ch, bool &state)
{
uint8_t currState(0);
if (ch < DO1 || ch > DO8)
@@ -71,12 +77,13 @@ namespace drivers
}
if (!readPort(currState))
return false;
return (currState && (High >> ch));
state = (currState && (High << ch));
return true;
}
const bool TCA9554PWR::readPort(uint8_t &state)
{
if (readRegister(TCA9554_INPUT_REG, state))
if (readRegister(TCA9554_OUTPUT_REG, state))
return true;
LOG_ERROR("Unable to read IO port: state[%02x]", state);
return false;

3
lib/GPIO/TCA9554PWR_Driver.h
View File

@@ -42,9 +42,10 @@ namespace drivers
~TCA9554PWR();
const bool setOut(const uint8_t channel, const bool state);
const bool toggleOut(const uint8_t channel);
const bool setPort(const uint8_t state);
const bool readOut(const uint8_t channel);
const bool readOut(const uint8_t channel, bool &state);
const bool readPort(uint8_t &state);
private:

34
lib/RS485/RS485_Driver.cpp
View File

@@ -69,16 +69,18 @@ namespace drivers
}
void MODBUS::delayAccess(const uint8_t device)
{
if (device == m_lastDevice) return;
auto now = millis();
if ((now - m_lastAccess) < c_minDelay) // fixed 10 milliseconds delay between commands
{ // minimum m_lastRequest between requests
delay(now - m_lastAccess);
}
m_lastAccess = now;
m_lastDevice = device;
{
if (device == m_lastDevice)
return;
auto now = millis();
if ((now - m_lastAccess) < c_minDelay) // fixed milliseconds delay between commands to different devices
{ // minimum m_lastRequest between requests
LOG_WARN("MODBUS access delay", now - m_lastAccess, "device", device);
delay(now - m_lastAccess);
}
m_lastAccess = millis();
m_lastDevice = device;
}
// Func 0x01
const bool MODBUS::readCoils(const uint8_t device, const uint16_t reg, const uint16_t num, std::vector<bool> &coils)
@@ -88,7 +90,7 @@ namespace drivers
LOG_DEBUG("Read coils: dev[", device, "], reg[", reg, "], num[", num, "]");
return readBinary(device, func, reg, num, coils);
}
// Func 0x02
const bool MODBUS::readInputs(const uint8_t device, const uint16_t reg, const uint8_t num, std::vector<bool> &inputs)
{
@@ -97,7 +99,7 @@ namespace drivers
LOG_DEBUG("Read multi inputs: dev[", device, "], reg[", reg, "], num[", num, "]");
return readBinary(device, func, reg, num, inputs);
}
// Func 0x03
const bool MODBUS::readHoldingRegisters(const uint8_t device, const uint16_t reg, const uint8_t num, std::vector<uint16_t> &values)
{
@@ -106,7 +108,7 @@ namespace drivers
LOG_DEBUG("Read multi holding registers: dev[", device, "], reg[", reg, "], num[", num, "]");
return readInteger(device, func, reg, num, values);
}
// Func 0x04
const bool MODBUS::readInputRegisters(const uint8_t device, const uint16_t reg, const uint8_t num, std::vector<uint16_t> &values)
{
@@ -115,7 +117,7 @@ namespace drivers
LOG_DEBUG("Read multi input registers: dev[", device, "], reg[", reg, "], num[", num, "]");
return readInteger(device, func, reg, num, values);
}
// Func 0x05
const bool MODBUS::writeCoil(const uint8_t device, const uint16_t coil, const bool value)
{
@@ -124,7 +126,7 @@ namespace drivers
LOG_DEBUG("Write single coil: dev[", device, "], coil[", coil, "], value[", value ? "true" : "false", "]");
return writeBinary(device, func, coil, {value});
}
// Func 0x06
const bool MODBUS::writeRegister(const uint8_t device, const uint16_t reg, const uint16_t value)
{
@@ -133,7 +135,7 @@ namespace drivers
LOG_DEBUG("Write single register: dev[", device, "], reg[", reg, "], value[", value, "]");
return writeInteger(device, func, reg, {value}, false);
}
// Func 0x0F
const bool MODBUS::writeCoils(const uint8_t device, const uint16_t coils, const std::vector<bool> &values)
{
@@ -142,7 +144,7 @@ namespace drivers
LOG_DEBUG("Write multi coils: dev[", device, "], start[", coils, "], num[", values.size(), "]");
return writeBinary(device, func, coils, values);
}
// Func 0x10
const bool MODBUS::writeRegisters(const uint8_t device, const uint16_t reg, const std::vector<uint16_t> &values)
{

2
lib/RS485/RS485_Driver.h
View File

@@ -34,7 +34,7 @@ namespace drivers
const uint8_t c_respHeaderSize = 3;
const uint8_t c_respCrcSize = 2;
const uint16_t c_minDelay = 50;
const uint16_t c_minDelay = 10;
typedef struct
{

2
lib/SENECA/S50140_Driver.cpp
View File

@@ -78,7 +78,7 @@ namespace drivers
{ // minimum m_lastRequest between requests
delay(now - m_lastRequest);
}
m_lastRequest = now;
m_lastRequest = millis();
}
const uint8_t S50140::getRegset()

2
lib/SENECA/S50140_Driver.h
View File

@@ -13,7 +13,7 @@ namespace drivers
private:
const uint8_t c_maxRetries = 5;
const uint8_t c_dataWords = 2;
const uint16_t c_minDelay = 200;
const uint16_t c_minDelay = 500;
const uint16_t REG_V = 0x100C;
const uint16_t REG_A = 0x1016;

37
lib/utils/utils.cpp
View File

@@ -1,5 +1,6 @@
#include "utils.h"
void printBytes(const char title[], const std::vector<uint8_t> &b)
{
Serial0.flush();
@@ -18,20 +19,32 @@ void printBytes(const char title[], const std::vector<uint16_t> &b)
printf("%s: ", title);
for (auto v : b)
{
printf("0x%04x ", v);
}
printf("\n");
Serial0.flush();
printf("0x%04x ", v);
}
printf("\n");
Serial0.flush();
}
void printBool(const char title[], const std::vector<bool> &vals)
{
Serial0.flush();
printf("%s: ", title);
for (auto j(0); j < vals.size(); j++)
{
printf("%s ", vals.at(j) ? "True" : "False");
}
printf("\n");
Serial0.flush();
Serial0.flush();
printf("%s: ", title);
for (auto j(0); j < vals.size(); j++)
{
printf("%s ", vals.at(j) ? "True" : "False");
}
printf("\n");
Serial0.flush();
}
const std::string printBoolVec(const std::vector<bool> &vals)
{
std::string buf;
buf.reserve(vals.size()+1);
buf.append("b");
for (const auto v : vals)
{
buf.append(v ? "1" : "0");
}
return buf;
}

3
lib/utils/utils.h
View File

@@ -4,6 +4,7 @@
#include <Arduino.h>
#include <DebugLog.h>
#include <string>
#include <vector>
///////////// UTIL Functions /////////////////
@@ -13,3 +14,5 @@ void printBytes(const char title[], const std::vector<uint8_t> &b);
void printBytes(const char title[], const std::vector<uint16_t> &b);
void printBool(const char title[], const std::vector<bool> &vals);
const std::string printBoolVec(const std::vector<bool> &vals);

296
src/digitalIO.cpp
View File

@@ -1,4 +1,5 @@
#include <digitalIO.h>
#include <utils.h>
digitalIO::digitalIO(drivers::I2C &i2c, drivers::MODBUS &bus, std::vector<uint8_t> remotes) : m_localOuts(drivers::TCA9554PWR(i2c, TCA9554_ADDRESS)), m_remoteAddrs(remotes)
{
@@ -9,31 +10,76 @@ digitalIO::digitalIO(drivers::I2C &i2c, drivers::MODBUS &bus, std::vector<uint8_
for (auto a : remotes)
{
m_remotes.emplace_back(remoteIO(a, bus));
m_remotes.emplace_back(a, bus);
}
LOG_INFO("Initialized digitalIO -> inputs", getInNum(), "outputs", getOutNum());
}
digitalIO::~digitalIO()
{
}
void digitalIO::digitalIOWrite(const uint8_t ch, const bool value)
void digitalIO::digitalOutWrite(const uint8_t ch, const bool value)
{
if (ch < 0 || ch > getOutNum())
{
LOG_ERROR("Invalid digitalIOWrite channel number", ch);
LOG_ERROR("Invalid digitalOutWrite channel number", ch);
return;
}
if (ch < drivers::TCA9554PWR::DO_MAX) // write to i2c device for local outputs
{
digitalWriteLocal(ch, value);
writeLocal(ch, value);
}
else
{
digitalWriteRemote(ch - drivers::TCA9554PWR::DO_MAX, value);
writeRemote(ch - drivers::TCA9554PWR::DO_MAX, value);
}
}
const bool digitalIO::digitalIORead(const uint8_t ch)
void digitalIO::digitalOutWritePort(const std::vector<bool> &values)
{
if (values.size() != getOutNum())
{
LOG_ERROR("Invalid digitalOutWrite channel number", values.size());
return;
}
const std::vector<bool> locals(values.begin(), values.begin() + drivers::TCA9554PWR::DO_MAX);
const std::vector<bool> remotes(values.begin() + drivers::TCA9554PWR::DO_MAX, values.end());
writeLocalPort(locals);
writeRemotePort(remotes);
}
const bool digitalIO::digitalOutRead(const uint8_t ch)
{
if (ch < 0 || ch > getOutNum())
{
LOG_ERROR("Invalid digitalOutRead channel number", ch);
return false;
}
if (ch < drivers::TCA9554PWR::DO_MAX) // write to i2c device for local outputs
{
return readLocalIn(ch);
}
else
{
return readRemoteIn(ch - drivers::TCA9554PWR::DO_MAX);
}
}
const std::vector<bool> digitalIO::digitalOutReadPort()
{
const std::vector<bool> locals(readLocalOutPort());
const std::vector<bool> remotes(readRemoteOutPort());
std::vector<bool> rv;
rv.reserve(getOutNum());
rv.insert(rv.begin(), locals.begin(), locals.end());
rv.insert(rv.end(), remotes.begin(), remotes.end());
return std::move(rv);
}
const bool digitalIO::digitalInRead(const uint8_t ch)
{
if (ch < 0 || ch > getInNum())
{
@@ -42,70 +88,192 @@ const bool digitalIO::digitalIORead(const uint8_t ch)
if (ch < (DI_MAX - DI1)) // read from local inputs not as gpio numbers
{
return digitalReadLocal(ch);
return readLocalIn(ch);
}
else
{
return digitalReadRemote(ch - (DI_MAX - DI1));
return readRemoteIn(ch - (DI_MAX - DI1));
}
}
const std::vector<bool> digitalIO::digitalInReadPort()
{
const std::vector<bool> locals(readLocalInPort());
const std::vector<bool> remotes(readRemoteInPort());
std::vector<bool> rv;
rv.reserve(getInNum());
rv.insert(rv.begin(), locals.begin(), locals.end());
rv.insert(rv.end(), remotes.begin(), remotes.end());
return std::move(rv);
}
void digitalIO::reset()
{
// set all local and remote outputs to 0
m_localOuts.setPort(0x00);
for (auto r: m_remotes)
for (auto r : m_remotes)
r.resetAll(false);
}
const uint8_t digitalIO::getLocalInNum()
{
return (DI_MAX - DI1);
}
const uint8_t digitalIO::getLocalOutNum()
{
return drivers::TCA9554PWR::DO_MAX;
}
const uint8_t digitalIO::getRemoteInNum()
{
return m_remotes.size() * remoteIO::CH_MAX;
}
const uint8_t digitalIO::getRemoteOutNum()
{
return m_remotes.size() * remoteIO::CH_MAX;
}
const uint8_t digitalIO::getOutNum()
{
return drivers::TCA9554PWR::DO_MAX + m_remotes.size() * remoteIO::CH_MAX;
return getLocalOutNum() + getRemoteOutNum();
}
const uint8_t digitalIO::getInNum()
{
return DI_MAX + m_remotes.size() * remoteIO::CH_MAX;
return getLocalInNum() + getRemoteInNum();
}
void digitalIO::digitalWriteLocal(const uint8_t ch, const bool value)
void digitalIO::writeLocal(const uint8_t ch, const bool value)
{
uint8_t retries(0);
while (retries++ < maxRetries)
{
if (m_localOuts.setOut(ch, value))
{
LOG_DEBUG("digitalWriteLocal channel", ch, " status", value ? "True" : "False");
break;
LOG_DEBUG("writeLocal channel", ch, " status", value ? "True" : "False");
return;
}
LOG_ERROR("Failed digitalWriteLocal channel ", ch, " status", value ? "True" : "False");
LOG_ERROR("Failed writeLocal channel ", ch, " status", value ? "True" : "False");
}
}
void digitalIO::digitalWriteRemote(const uint8_t ch, const bool value)
void digitalIO::writeLocalPort(const std::vector<bool> &values)
{
uint8_t retries(0);
const uint8_t selectedRemote(floor(ch / 8.0f));
uint8_t decValue(0);
for (uint8_t i(0); i < 8; i++) // convert from bits to byte value
{
if (values[i])
decValue |= High << i;
}
while (retries++ < maxRetries)
{
if (m_localOuts.setPort(decValue))
{
LOG_DEBUG("writeLocalPort value", printBoolVec(values).c_str());
return;
}
LOG_ERROR("Failed writeLocalPort value", printBoolVec(values).c_str());
}
}
void digitalIO::writeRemote(const uint8_t ch, const bool value)
{
uint8_t retries(0);
const uint8_t selectedRemote(floor(ch / (float)remoteIO::CH_MAX));
const uint8_t selectedChannel(ch % remoteIO::CH_MAX);
while (retries++ < maxRetries)
{
if (m_remotes[selectedRemote].setOut((remoteIO::channel_t)selectedChannel, value))
{
LOG_DEBUG("digitalWriteRemote remote", selectedRemote, " channel ", selectedChannel, " status", value ? "True" : "False");
break;
LOG_DEBUG("writeRemote remote", selectedRemote, " channel ", selectedChannel, " status", value ? "True" : "False");
return;
}
LOG_ERROR("Failed digitalWriteRemote remote", selectedRemote, " channel ", selectedChannel, " status", value ? "True" : "False");
LOG_ERROR("Failed writeRemote remote", selectedRemote, " channel ", selectedChannel, " status", value ? "True" : "False");
}
}
const bool digitalIO::digitalReadLocal(const uint8_t ch)
void digitalIO::writeRemotePort(const std::vector<bool> &values)
{
uint8_t retries(0);
while (retries++ < maxRetries)
{
bool ok(true);
for (uint8_t i(0); i < values.size(); i += remoteIO::CH_MAX)
{
const uint8_t selectedRemote(floor(i / (float)remoteIO::CH_MAX));
const std::vector<bool> currValues(values.begin() + i, values.begin() + i + remoteIO::CH_MAX);
ok &= m_remotes[selectedRemote].setOutPort(currValues);
if (ok)
{
LOG_DEBUG("writeRemotePort remote", selectedRemote, "values", printBoolVec(values).c_str());
continue;
}
LOG_ERROR("Failed writeRemotePort remote", selectedRemote, "values", printBoolVec(values).c_str());
break;
}
if (ok)
break;
}
}
const bool digitalIO::readLocalIn(const uint8_t ch)
{
bool value = !digitalRead(ch + DI1); // base pin number in enum, inverted input
LOG_DEBUG("digitalReadLocal pin", (ch + DI1), " status", value ? "True" : "False");
LOG_DEBUG("readLocalIn pin", (ch + DI1), " status", value ? "True" : "False");
return value;
}
const bool digitalIO::digitalReadRemote(const uint8_t ch)
const bool digitalIO::readLocalOut(const uint8_t ch)
{
bool value(false);
uint8_t retries(0);
while (retries++ < maxRetries)
{
if (m_localOuts.readOut(ch, value))
{
LOG_DEBUG("readLocalOut pin", (ch), " status", value ? "True" : "False");
return value;
}
LOG_ERROR("Failed readLocalOut channel", ch);
}
return false;
}
const std::vector<bool> digitalIO::readLocalInPort()
{
std::vector<bool> values(getLocalInNum());
for (uint8_t i(0); i < values.size(); i++)
{
values[i] = readLocalIn(i);
}
LOG_DEBUG("readLocalInPort values", printBoolVec(values).c_str());
return values;
}
const std::vector<bool> digitalIO::readLocalOutPort()
{
uint8_t retries(0);
uint8_t state(0);
std::vector<bool> values(getLocalOutNum());
while (retries++ < maxRetries)
{
if (m_localOuts.readPort(state))
{
for (uint8_t i(0); i < values.size(); i++)
{
values[i] = (state >> i) & High;
}
LOG_DEBUG("readLocalOutPort values", printBoolVec(values).c_str());
return values;
}
LOG_ERROR("Failed readLocalOutPort");
}
values.clear();
return values;
}
const bool digitalIO::readRemoteIn(const uint8_t ch)
{
uint8_t retries(0);
const uint8_t selectedRemote(floor(ch / 8.0f));
@@ -115,10 +283,86 @@ const bool digitalIO::digitalReadRemote(const uint8_t ch)
{
if (m_remotes[selectedRemote].getIn((remoteIO::channel_t)selectedChannel, value))
{
LOG_DEBUG("digitalReadRemote remote", selectedRemote, " channel ", selectedChannel, " status", value ? "True" : "False");
LOG_DEBUG("readRemoteIn remote", selectedRemote, " channel ", selectedChannel, " status", value ? "True" : "False");
return value;
}
LOG_ERROR("Failed digitalReadRemote remote", selectedRemote, " channel ", selectedChannel, " status", value ? "True" : "False");
LOG_ERROR("Failed readRemoteIn remote", selectedRemote, " channel ", selectedChannel, " status", value ? "True" : "False");
}
return false;
}
}
const bool digitalIO::readRemoteOut(const uint8_t ch)
{
uint8_t retries(0);
const uint8_t selectedRemote(floor(ch / (float)remoteIO::CH_MAX));
const uint8_t selectedChannel(ch % remoteIO::CH_MAX);
bool value;
while (retries++ < maxRetries)
{
if (m_remotes[selectedRemote].getOut((remoteIO::channel_t)selectedChannel, value))
{
LOG_DEBUG("readRemoteOut remote", selectedRemote, " channel ", selectedChannel, " status", value ? "True" : "False");
return value;
}
LOG_ERROR("Failed readRemoteOut remote", selectedRemote, " channel ", selectedChannel, " status", value ? "True" : "False");
}
return false;
}
const std::vector<bool> digitalIO::readRemoteInPort()
{
uint8_t retries(0);
std::vector<bool> values;
values.reserve(getRemoteInNum());
while (retries++ < maxRetries)
{
bool ok(true);
for (uint8_t i(0); i < getRemoteInNum(); i += remoteIO::CH_MAX)
{
const uint8_t selectedRemote(floor(i / (float)remoteIO::CH_MAX));
std::vector<bool> remVals(remoteIO::CH_MAX);
ok &= m_remotes[selectedRemote].getInPort(remVals);
if (ok)
{
values.insert(values.begin() + values.size(), remVals.begin(), remVals.end());
LOG_DEBUG("readRemoteInPort remote", selectedRemote, "values", printBoolVec(remVals).c_str());
continue;
}
LOG_ERROR("Failed readRemoteInPort remote", selectedRemote);
break;
}
if (ok)
return values;
}
values.clear();
return values;
}
const std::vector<bool> digitalIO::readRemoteOutPort()
{
uint8_t retries(0);
std::vector<bool> values;
values.reserve(getRemoteOutNum());
while (retries++ < maxRetries)
{
bool ok(true);
for (uint8_t i(0); i < getRemoteOutNum(); i += remoteIO::CH_MAX)
{
const uint8_t selectedRemote(floor(i / (float)remoteIO::CH_MAX));
std::vector<bool> remVals(remoteIO::CH_MAX);
ok &= m_remotes[selectedRemote].getOutPort(remVals);
if (ok)
{
values.insert(values.begin() + values.size(), remVals.begin(), remVals.end());
LOG_DEBUG("readRemoteOutPort remote", selectedRemote, "values", printBoolVec(remVals).c_str());
continue;
}
LOG_ERROR("Failed readRemoteOutPort remote", selectedRemote);
break;
}
if (ok)
return values;
}
values.clear();
return values;
}

33
src/digitalIO.h
View File

@@ -34,19 +34,38 @@ public:
digitalIO(drivers::I2C &i2c, drivers::MODBUS &bus, std::vector<uint8_t> remotes);
~digitalIO();
void digitalIOWrite(const uint8_t ch, const bool value);
const bool digitalIORead(const uint8_t ch);
void digitalOutWrite(const uint8_t ch, const bool value);
void digitalOutWritePort(const std::vector<bool> &values);
const bool digitalOutRead(const uint8_t ch);
const std::vector<bool> digitalOutReadPort();
const bool digitalInRead(const uint8_t ch);
const std::vector<bool> digitalInReadPort();
void reset();
const uint8_t getOutNum();
const uint8_t getInNum();
private:
void digitalWriteLocal(const uint8_t ch, const bool value);
void digitalWriteRemote(const uint8_t ch, const bool value);
private:
const uint8_t getLocalInNum();
const uint8_t getLocalOutNum();
const uint8_t getRemoteInNum();
const uint8_t getRemoteOutNum();
const bool digitalReadLocal(const uint8_t ch);
const bool digitalReadRemote(const uint8_t ch);
void writeLocal(const uint8_t ch, const bool value);
void writeLocalPort(const std::vector<bool> &values);
void writeRemote(const uint8_t ch, const bool value);
void writeRemotePort(const std::vector<bool> &values);
const bool readLocalIn(const uint8_t ch);
const bool readLocalOut(const uint8_t ch);
const std::vector<bool> readLocalInPort();
const std::vector<bool> readLocalOutPort();
const bool readRemoteIn(const uint8_t ch);
const bool readRemoteOut(const uint8_t ch);
const std::vector<bool> readRemoteInPort();
const std::vector<bool> readRemoteOutPort();
private:
std::vector<uint8_t> m_remoteAddrs;

55
src/main.cpp
View File

@@ -50,6 +50,7 @@ void loop()
auto seneca = drivers::S50140(bus, conf.m_modbusSenecaAddr);
auto buzzer = drivers::Buzzer();
auto led = drivers::Led();
delay(500);
auto io = digitalIO(i2c, bus, {conf.m_modbusRelayAddr});
// Initialize temperature sensors
sensors = tmp.getNum();
@@ -63,8 +64,24 @@ void loop()
std::function<void(const ArduinoJson::JsonDocument &)> mycallback =
[&io](const ArduinoJson::JsonDocument &doc)
{
io.digitalIOWrite(0, doc["stat"].as<bool>());
io.digitalIOWrite(15, doc["stat"].as<bool>());
std::vector<bool> v1 = {1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0};
std::vector<bool> v2 = {0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1};
std::vector<bool> v0(io.getOutNum(), 0);
LOG_INFO("SET Digital Outputs V1: ", printBoolVec(v1).c_str());
io.digitalOutWritePort(v1);
delay(100);
LOG_INFO("GET Digital Outputs V1: ", printBoolVec(io.digitalOutReadPort()).c_str());
delay(2000);
LOG_INFO("SET Digital Outputs V2: ", printBoolVec(v2).c_str());
io.digitalOutWritePort(v2);
delay(100);
LOG_INFO("GET Digital Outputs V2: ", printBoolVec(io.digitalOutReadPort()).c_str());
delay(2000);
LOG_INFO("GET Digital Inputs: ", printBoolVec(io.digitalInReadPort()).c_str());
io.digitalOutWritePort(v0);
};
//////////////// NETWORK ////////////////
@@ -134,16 +151,32 @@ void loop()
drivers::S50140::powerinfo_t pinfo = seneca.getAll();
LOG_INFO("Power Info ==> V:", pinfo.v, "- A:", pinfo.a, "- W:", pinfo.pAct, "- F:", pinfo.f, "- Wh_t:", pinfo.whTot, "- Wh_p:", pinfo.whPar);
if (io.digitalIORead(0)) // rosso
if (io.digitalInRead(0)) // rosso
{
uint8_t regset(seneca.getRegset());
uint16_t countStat(seneca.getCounterStatus());
LOG_INFO("Register Set: ", regset);
LOG_INFO("Counter Status: ", countStat);
seneca.resetPartialCounters();
std::vector<bool> v1 = {1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0};
std::vector<bool> v2 = {0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1};
std::vector<bool> v0(16, 0);
LOG_INFO("SET Digital Outputs V1: ", printBoolVec(v1).c_str());
io.digitalOutWritePort(v1);
delay(100);
LOG_INFO("GET Digital Outputs V1: ", printBoolVec(io.digitalOutReadPort()).c_str());
delay(2000);
LOG_INFO("SET Digital Outputs V2: ", printBoolVec(v2).c_str());
io.digitalOutWritePort(v2);
delay(100);
LOG_INFO("GET Digital Outputs V2: ", printBoolVec(io.digitalOutReadPort()).c_str());
delay(2000);
LOG_INFO("GET Digital Inputs: ", printBoolVec(io.digitalInReadPort()).c_str());
delay(2000);
io.digitalOutWritePort(v0);
}
delay(100);
if (io.digitalIORead(8)) // blu
if (io.digitalInRead(8)) // blu
{
if (!buzzing)
{
@@ -160,12 +193,12 @@ void loop()
LOG_INFO("Buzzing -> ", buzzing ? "True" : "False");
}
if (io.digitalIORead(9))
if (io.digitalInRead(9))
{ // verde
conf.resetConfig();
}
if (io.digitalIORead(10))
if (io.digitalInRead(10))
{ // giallo
esp_restart();
}

4
src/remoteIO.cpp
View File

@@ -47,7 +47,7 @@ const bool remoteIO::setOutPort(const std::vector<bool> values)
return false;
auto lock = m_bus.getLock();
LOG_DEBUG("Write Port", CH_MAX);
return m_bus.writeCoils(m_address, CH_MAX, values);
return m_bus.writeCoils(m_address, REG_COILS, values);
}
const bool remoteIO::getOut(const channel_t ch, bool &value)
@@ -69,7 +69,7 @@ const bool remoteIO::getOutPort(std::vector<bool> &values)
return false;
auto lock = m_bus.getLock();
LOG_DEBUG("Read Port", CH_MAX);
return m_bus.readCoils(m_address, REG_COILS, 8, values);
return m_bus.readCoils(m_address, REG_COILS, CH_MAX, values);
}
const bool remoteIO::getIn(const channel_t input, bool &value)