266 lines
9.2 KiB
C++
266 lines
9.2 KiB
C++
#include <AnalogIoT.hpp>
|
|
|
|
AnalogIoT::AnalogIoT() : adc_conversion_callbacks() {
|
|
for (uint8_t i = 0; i < 8; i++) {
|
|
adc_publish_enabled[i] = false;
|
|
adc_conversion_interval[i] = 1000;
|
|
}
|
|
this->adc_conversion_callback_index = 0;
|
|
}
|
|
|
|
AnalogIoT::~AnalogIoT() {
|
|
}
|
|
bool AnalogIoT::begin(uint8_t card_id, ExpansionCard *card, PubSubClient *mqtt, char *base_topic) {
|
|
this->mqtt = mqtt;
|
|
this->base_topic = base_topic;
|
|
this->card = (AnalogCard*)card;
|
|
this-> card_id = card_id;
|
|
this->dac_set_state_length = strlen(DAC_SET_STATE_TOPIC);
|
|
this->dac_set_value_length = strlen(DAC_SET_VALUE_TOPIC);
|
|
this->dac_state_length = strlen(DAC_STATE_TOPIC);
|
|
this->dac_value_length = strlen(DAC_VALUE_TOPIC);
|
|
this->request_state_length = strlen(REQUEST_STATE_TOPIC);
|
|
this->dac_publish_enable_length = strlen(DAC_PUBLISH_ENABLE_TOPIC);
|
|
// Register callbacks
|
|
auto bindedCallback = std::bind(&AnalogIoT::handleDACChange, this, std::placeholders::_1, std::placeholders::_2);
|
|
this->card->registerDACChangeCallback(bindedCallback);
|
|
return true;
|
|
}
|
|
void AnalogIoT::handleMqttMessage(char *topic, char *payload){
|
|
uint8_t topic_length = strlen(topic);
|
|
if(this-> processDACSetStateMessage(topic, payload, topic_length)) return;
|
|
if(this-> processDACSetValueMessage(topic, payload, topic_length)) return;
|
|
if(this-> processRequestStateMessage(topic, payload, topic_length)) return;
|
|
if(this-> processADCSetConversionIntervalMessage(topic, payload, topic_length)) return;
|
|
if(this-> processADCSetConversionEnabledMessage(topic, payload, topic_length)) return;
|
|
}
|
|
void AnalogIoT::publishADCs() {
|
|
for (uint8_t i = 0; i < 8; i++) {
|
|
this->publishADC(i);
|
|
}
|
|
}
|
|
void AnalogIoT::publishADC(uint8_t pin) {
|
|
if (this->adc_publish_enabled[pin]) {
|
|
uint16_t value = this->card->analogRead(pin);
|
|
char *topic = new char[15];
|
|
sprintf(topic, "adc/%02d/value", pin);
|
|
char *payload = new char[10];
|
|
sprintf(payload, "%d", value);
|
|
this->publishRelative(topic, payload);
|
|
delete[] topic;
|
|
delete[] payload;
|
|
// Call all callbacks
|
|
for (auto& callback : this->adc_conversion_callbacks) {
|
|
callback.second(pin, value);
|
|
}
|
|
}
|
|
}
|
|
void AnalogIoT::setADCsPublishInterval(uint32_t interval) {
|
|
for (uint8_t i = 0; i < 8; i++) {
|
|
adc_conversion_interval[i] = interval;
|
|
}
|
|
}
|
|
void AnalogIoT::setADCsPublishEnabled(bool enabled) {
|
|
for (uint8_t i = 0; i < 8; i++) {
|
|
adc_publish_enabled[i] = enabled;
|
|
}
|
|
}
|
|
void AnalogIoT::registerADCConversionCallback(std::function<void(uint8_t, uint16_t)> callback) {
|
|
this->adc_conversion_callbacks[this->adc_conversion_callback_index++] = callback;
|
|
}
|
|
void AnalogIoT::deregisterADCConversionCallback(uint8_t handler) {
|
|
this->adc_conversion_callbacks.erase(handler);
|
|
}
|
|
void AnalogIoT::setADCConversionInterval(uint8_t pin, uint16_t interval) {
|
|
adc_conversion_interval[pin] = interval;
|
|
}
|
|
void AnalogIoT::setADCConversionEnabled(uint8_t pin, bool enabled) {
|
|
adc_publish_enabled[pin] = enabled;
|
|
}
|
|
bool AnalogIoT::processADCSetConversionIntervalMessage(char *topic, char *payload, uint8_t topic_length) {
|
|
// TODO: Process payload matching the criteria
|
|
// Topic: adc/<%02d>/set/conversion_interval
|
|
// The first 4 characters are "adc/"
|
|
// The length of the topic must be 30 characters
|
|
// The last 24 characters must be "/set/conversion_interval"
|
|
// After all these conditions are met, the topic is valid
|
|
// Extract the pin number from the topic
|
|
if (topic_length != 30) {
|
|
return false;
|
|
}
|
|
if (strncmp(topic, "adc/", 4)) {
|
|
return false;
|
|
}
|
|
if (strncmp(topic + 26, "/set/conversion_interval", 24)) {
|
|
return false;
|
|
}
|
|
uint8_t pin = (topic[4] - '0') * 10 + (topic[5] - '0');
|
|
// Extract the payload
|
|
uint16_t interval = atoi(payload);
|
|
// Set the interval
|
|
this->setADCConversionInterval(pin, interval);
|
|
return true;
|
|
}
|
|
bool AnalogIoT::processADCSetConversionEnabledMessage(char *topic, char *payload, uint8_t topic_length) {
|
|
// Topic: adc/<%02d>/set/conversion_enabled
|
|
// The first 4 characters are "adc/"
|
|
// The length of the topic must be 29 characters
|
|
// The last 23 characters must be ""/set/conversion_enabled
|
|
// After all these conditions are met, the topic is valid
|
|
// Extract the pin number from the topic
|
|
if (topic_length != 29) {
|
|
return false;
|
|
}
|
|
if (strncmp(topic, "adc/", 4)) {
|
|
return false;
|
|
}
|
|
if (strncmp(topic + 25, "/set/conversion_enabled", 23)) {
|
|
return false;
|
|
}
|
|
uint8_t pin = (topic[4] - '0') * 10 + (topic[5] - '0');
|
|
// Extract the payload
|
|
bool enabled = atoi(payload);
|
|
// Set conversion enabled
|
|
this->setADCConversionEnabled(pin, enabled);
|
|
return true;
|
|
}
|
|
bool AnalogIoT::processDACSetStateMessage(char *topic, char *payload, uint8_t topic_length) {
|
|
// Topic: dac/<%02d>/set/state
|
|
// The first 4 characters are "dac/"
|
|
// The length of the topic must be 16 characters
|
|
// The last 10 characters must be "/set/state"
|
|
// After all these conditions are met, the topic is valid
|
|
// Extract the pin number from the topic
|
|
if (topic_length != 16) {
|
|
return false;
|
|
}
|
|
if (strncmp(topic, "dac/", 4)) {
|
|
return false;
|
|
}
|
|
if (strncmp(topic + 12, "/set/state", 10)) {
|
|
return false;
|
|
}
|
|
uint8_t pin = (topic[4] - '0') * 10 + (topic[5] - '0');
|
|
// Extract the payload
|
|
bool state = atoi(payload);
|
|
// Set the state
|
|
this->card->setDACState(pin, state);
|
|
return true;
|
|
}
|
|
bool AnalogIoT::processDACSetValueMessage(char *topic, char *payload, uint8_t topic_length) {
|
|
// Topic: dac/<%02d>/set/value
|
|
// The first 4 characters are "dac/"
|
|
// The length of the topic must be 16 characters
|
|
// The last 10 characters must be "/set/value"
|
|
// After all these conditions are met, the topic is valid
|
|
// Extract the pin number from the topic
|
|
if (topic_length != 16) {
|
|
return false;
|
|
}
|
|
if (strncmp(topic, "dac/", 4)) {
|
|
return false;
|
|
}
|
|
if (strncmp(topic + 12, "/set/value", 10)) {
|
|
return false;
|
|
}
|
|
uint8_t pin = (topic[4] - '0') * 10 + (topic[5] - '0');
|
|
// Extract the payload
|
|
uint16_t value = atoi(payload);
|
|
// Set the value
|
|
this->card->setDACValue(pin, value);
|
|
return true;
|
|
}
|
|
bool AnalogIoT::processRequestStateMessage(char *topic, char *payload, uint8_t topic_length) {
|
|
// Topic: requeststate
|
|
// The length of the topic must be 12 characters
|
|
// After all these conditions are met, the topic is valid
|
|
if (topic_length != 12) {
|
|
return false;
|
|
}
|
|
if (strncmp(topic, REQUEST_STATE_TOPIC, 12)) {
|
|
return false;
|
|
}
|
|
// Publish the state of all DACs
|
|
this->publishDACs();
|
|
// Publish the state of all ADCs
|
|
this->publishADCs();
|
|
return false;
|
|
}
|
|
void AnalogIoT::subscribe() {
|
|
// There are 4 DACs and 8 ADCs
|
|
// DACs: dac/<%02d>/set/state, dac/<%02d>/set/value, dac/publish_enable
|
|
// ADCs: adc/<%02d>/set/conversion_interval, adc/<%02d>/set/conversion_enabled
|
|
|
|
// Subscribe to all set state topics
|
|
char topic[20];
|
|
for (uint8_t i = 0; i < 4; i++) {
|
|
sprintf(topic, "dac/%02d/set/state", i);
|
|
this->subscribeRelative(topic);
|
|
}
|
|
// Subscribe to all set value topics
|
|
for (uint8_t i = 0; i < 4; i++) {
|
|
sprintf(topic, "dac/%02d/set/value", i);
|
|
this->subscribeRelative(topic);
|
|
}
|
|
// Subscribe to all set conversion interval topics
|
|
for (uint8_t i = 0; i < 8; i++) {
|
|
sprintf(topic, "adc/%02d/set/conversion_interval", i);
|
|
this->subscribeRelative(topic);
|
|
}
|
|
// Subscribe to all set conversion enabled topics
|
|
for (uint8_t i = 0; i < 8; i++) {
|
|
sprintf(topic, "adc/%02d/set/conversion_enabled", i);
|
|
this->subscribeRelative(topic);
|
|
}
|
|
// Subscribe to publish enable topic
|
|
this->subscribeRelative("dac/publish_enable");
|
|
}
|
|
void AnalogIoT::loop() {
|
|
// Iterate over all ADCs and publish if enabled and interval has passed
|
|
uint32_t now = millis();
|
|
for (uint8_t i = 0; i < 8; i++) {
|
|
if (this->adc_publish_enabled[i] && now - this->last_adc_publish > this->adc_conversion_interval[i]) {
|
|
this->publishADC(i);
|
|
this->last_adc_publish = now;
|
|
}
|
|
}
|
|
}
|
|
void AnalogIoT::publishReport() {
|
|
publishADCs();
|
|
publishDACs();
|
|
}
|
|
|
|
uint8_t AnalogIoT::getType() {
|
|
return CARD_TYPE_ANALOG;
|
|
}
|
|
void AnalogIoT::publishDACs() {
|
|
for (uint8_t i = 0; i < 4; i++) {
|
|
this->publishDAC(i);
|
|
}
|
|
}
|
|
void AnalogIoT::publishDAC(uint8_t pin) {
|
|
this->publishDACState(pin);
|
|
this->publishDACValue(pin);
|
|
}
|
|
void AnalogIoT::publishDACState(uint8_t pin) {
|
|
char *topic = new char[15];
|
|
sprintf(topic, "dac/%02d/state", pin);
|
|
char *payload = new char[2];
|
|
sprintf(payload, "%d", this->card->getDACState(pin));
|
|
this->publishRelative(topic, payload);
|
|
delete[] topic;
|
|
delete[] payload;
|
|
}
|
|
void AnalogIoT::publishDACValue(uint8_t pin) {
|
|
char *topic = new char[15];
|
|
sprintf(topic, "dac/%02d/value", pin);
|
|
char *payload = new char[5];
|
|
sprintf(payload, "%d", this->card->getDACValue(pin));
|
|
this->publishRelative(topic, payload);
|
|
delete[] topic;
|
|
delete[] payload;
|
|
}
|
|
|
|
void AnalogIoT::handleDACChange(uint8_t pin, uint16_t value) {
|
|
this->publishDAC(pin);
|
|
} |