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

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)