Hello!
The code below reads the OPTA inputs with a 0-10V signal and this signal is replicated at the output of the first analog expansion module. I am trying to add another analog module to read an input and replicate it at the output of this same module, but I am not able to do this.
I was only successful in reading the OPTA inputs and replicating it at the outputs of an expansion module.
Can anyone find the error in the code below?
#include "OptaBlue.h"
/************************************************************************************************************************************************/
/* */
/* CONFIGURAÇÃO DE TEMPO */
/* */
/************************************************************************************************************************************************/
#define PERIODIC_UPDATE_TIME 200
#define DELAY_AFTER6SETUP 200
/************************************************************************************************************************************************/
/* */
/* CONFIGURAÇÃO DAS PORTAS DO OPTA */
/* */
/************************************************************************************************************************************************/
#define INPUT_PIN1 A0 // Defina o pino analógico de entrada
#define INPUT_PIN2 A1 // Defina o pino analógico de entrada
#define INPUT_PIN3 A2 // Defina o pino analógico de entrada
#define INPUT_PIN4 A3 // Defina o pino analógico de entrada
#define INPUT_PIN5 A4 // Defina o pino analógico de entrada
#define INPUT_PIN6 A5 // Defina o pino analógico de entrada
#define INPUT_PIN7 A6 // Defina o pino analógico de entrada
#define INPUT_PIN8 A7 // Defina o pino analógico de entrada
/* -------------------------------------------------------------------------- */
void printExpansionType(ExpansionType_t t) {
/* -------------------------------------------------------------------------- */
if (t == EXPANSION_NOT_VALID) {
Serial.print("Unknown!");
} else if (t == EXPANSION_OPTA_DIGITAL_MEC) {
Serial.print("Opta --- DIGITAL [Mechanical] ---");
} else if (t == EXPANSION_OPTA_DIGITAL_STS) {
Serial.print("Opta --- DIGITAL [Solid State] ---");
} else if (t == EXPANSION_DIGITAL_INVALID) {
Serial.print("Opta --- DIGITAL [!!Invalid!!] ---");
} else if (t == EXPANSION_OPTA_ANALOG) {
Serial.print("~~~ Opta ANALOG ~~~");
} else {
Serial.print("Unknown!");
}
}
/* -------------------------------------------------------------------------- */
void printExpansionInfo() {
/* -------------------------------------------------------------------------- */
static long int start = millis();
if (millis() - start > 5000) {
start = millis();
Serial.print("Number of expansions: ");
Serial.println(OptaController.getExpansionNum());
for (int i = 0; i < OptaController.getExpansionNum(); i++) {
Serial.print("Expansion n. ");
Serial.print(i);
Serial.print(" type ");
printExpansionType(OptaController.getExpansionType(i));
Serial.print(" I2C address ");
Serial.println(OptaController.getExpansionI2Caddress(i));
}
}
}
/* -------------------------------------------------------------------------- */
/* SETUP */
/* -------------------------------------------------------------------------- */
void setup() {
/* -------------------------------------------------------------------------- */
Serial.begin(115200);
delay(2000);
OptaController.begin();
// Configurar o canal DAC para saída de tensão
for (int device = 0; device < OptaController.getExpansionNum(); device++) {
for (int ch = 0; ch < OA_AN_CHANNELS_NUM; ch++) {
// Configure os canais ímpares como DAC de tensão
AnalogExpansion::beginChannelAsDac(OptaController,
device,
ch,
OA_VOLTAGE_DAC,
true,
false,
OA_SLEW_RATE_0);
}
}
/************************************************************************************************************************************************/
/* */
/* CONFIGURAÇÃO DAS PORTAS DE ENTRADA E SAÍDA DO OPTA */
/* */
/************************************************************************************************************************************************/
pinMode(INPUT_PIN1, INPUT); // Defina o pino de entrada como INPUT
pinMode(INPUT_PIN2, INPUT); // Defina o pino de entrada como INPUT
pinMode(INPUT_PIN3, INPUT); // Defina o pino de entrada como INPUT
pinMode(INPUT_PIN4, INPUT); // Defina o pino de entrada como INPUT
pinMode(INPUT_PIN5, INPUT); // Defina o pino de entrada como INPUT
pinMode(INPUT_PIN6, INPUT); // Defina o pino de entrada como INPUT
pinMode(INPUT_PIN7, INPUT); // Defina o pino de entrada como INPUT
pinMode(INPUT_PIN8, INPUT); // Defina o pino de entrada como INPUT
}
/* -------------------------------------------------------------------------- */
void optaAnalogTask() {
/* -------------------------------------------------------------------------- */
static long int start = millis();
// Execute esta parte a cada PERIODIC_UPDATE_TIME milissegundos
if (millis() - start > PERIODIC_UPDATE_TIME) {
start = millis();
//LE O VALOR LIDO NA ENTRADA A0
uint16_t input_value1 = analogRead(INPUT_PIN1);
//LE O VALOR LIDO NA ENTRADA A1
uint16_t input_value2 = analogRead(INPUT_PIN2);
//LE O VALOR LIDO NA ENTRADA A2
uint16_t input_value3 = analogRead(INPUT_PIN3);
//LE O VALOR LIDO NA ENTRADA A3
uint16_t input_value4 = analogRead(INPUT_PIN4);
//LE O VALOR LIDO NA ENTRADA A4
uint16_t input_value5 = analogRead(INPUT_PIN5);
//LE O VALOR LIDO NA ENTRADA A5
uint16_t input_value6 = analogRead(INPUT_PIN6);
//LE O VALOR LIDO NA ENTRADA A6
uint16_t input_value7 = analogRead(INPUT_PIN7);
//LE O VALOR LIDO NA ENTRADA A7
uint16_t input_value8 = analogRead(INPUT_PIN8);
// Converter o valor lido para a escala de 0 a 7490 (usada pelo DAC - ENTRADA A0)
uint16_t dac_value1 = map(input_value1, 0, 1023, 0, 7490);
// Converter o valor lido para a escala de 0 a 7490 (usada pelo DAC - ENTRADA A1)
uint16_t dac_value2 = map(input_value2, 0, 1023, 0, 7490);
// Converter o valor lido para a escala de 0 a 7490 (usada pelo DAC - ENTRADA A2)
uint16_t dac_value3 = map(input_value3, 0, 1023, 0, 7490);
// Converter o valor lido para a escala de 0 a 7490 (usada pelo DAC - ENTRADA A3)
uint16_t dac_value4 = map(input_value4, 0, 1023, 0, 7490);
// Converter o valor lido para a escala de 0 a 7490 (usada pelo DAC - ENTRADA A4)
uint16_t dac_value5 = map(input_value5, 0, 1023, 0, 7490);
// Converter o valor lido para a escala de 0 a 7490 (usada pelo DAC - ENTRADA A5)
uint16_t dac_value6 = map(input_value6, 0, 1023, 0, 7490);
// Converter o valor lido para a escala de 0 a 7490 (usada pelo DAC - ENTRADA A6)
uint16_t dac_value7 = map(input_value7, 0, 1023, 0, 7490);
// Converter o valor lido para a escala de 0 a 7490 (usada pelo DAC - ENTRADA A7)
uint16_t dac_value8 = map(input_value8, 0, 1023, 0, 7490);
// Enviar o valor para o DAC
AnalogExpansion exp = OptaController.getExpansion(0);
Serial.println("Setting DAC value " + String(dac_value1) + " on expansion n. " + String(exp.getIndex()));
//ENVIA O MESMO SINAL DE ENTRADA PARA A SAÍDA I1
exp.setDac(OA_CH_0, dac_value1);
Serial.println("Setting DAC value " + String(dac_value2) + " on expansion n. " + String(exp.getIndex()));
//ENVIA O MESMO SINAL DE ENTRADA PARA A SAÍDA I2
exp.setDac(OA_CH_1, dac_value2);
Serial.println("Setting DAC value " + String(dac_value3) + " on expansion n. " + String(exp.getIndex()));
//ENVIA O MESMO SINAL DE ENTRADA PARA A SAÍDA I3
exp.setDac(OA_CH_2, dac_value3);
Serial.println("Setting DAC value " + String(dac_value4) + " on expansion n. " + String(exp.getIndex()));
//ENVIA O MESMO SINAL DE ENTRADA PARA A SAÍDA I4
exp.setDac(OA_CH_3, dac_value4);
Serial.println("Setting DAC value " + String(dac_value5) + " on expansion n. " + String(exp.getIndex()));
//ENVIA O MESMO SINAL DE ENTRADA PARA A SAÍDA O1
exp.setDac(OA_CH_4, dac_value5);
Serial.println("Setting DAC value " + String(dac_value6) + " on expansion n. " + String(exp.getIndex()));
//ENVIA O MESMO SINAL DE ENTRADA PARA A SAÍDA I5
exp.setDac(OA_CH_5, dac_value6);
Serial.println("Setting DAC value " + String(dac_value7) + " on expansion n. " + String(exp.getIndex()));
//ENVIA O MESMO SINAL DE ENTRADA PARA A SAÍDA I6
exp.setDac(OA_CH_6, dac_value7);
Serial.println("Setting DAC value " + String(dac_value8) + " on expansion n. " + String(exp.getIndex()));
//ENVIA O MESMO SINAL DE ENTRADA PARA A SAÍDA O2
exp.setDac(OA_CH_7, dac_value8);
}
}
void optaAnalogTaskum() {
static long int start = millis();
// Execute esta parte a cada PERIODIC_UPDATE_TIME milissegundos
if (millis() - start > PERIODIC_UPDATE_TIME) {
start = millis();
// Obtenha a expansão secundária
AnalogExpansion expum = OptaController.getExpansion(1);
// Leia o valor do canal OA_CH_0 da expansão secundária
uint16_t input_value9 = expum.analogRead(OA_CH_0);
// Mapeie o valor lido para a escala do DAC
uint16_t dac_value9 = map(input_value9, 0, 1023, 0, 7490);
// Envie o valor mapeado para o canal OA_CH_1 da expansão secundária
Serial.println("Setting DAC value " + String(dac_value9) + " on expansion n. " + String(expum.getIndex()));
expum.setDac(OA_CH_1, dac_value9);
}
}
/* -------------------------------------------------------------------------- */
/* LOOP */
/* -------------------------------------------------------------------------- */
void loop() {
/* -------------------------------------------------------------------------- */
OptaController.update();
printExpansionInfo();
optaAnalogTask();
optaAnalogTaskum();
}