Medir el consumo del gas con Arduino

// (c) eMariete 2016-2023 https://emariete.com/medir-consumo-gas-arduino/
// Este sketch para Arduino se llama ContadorReedDelGas.ino:
// Se utiliza para contar los pulsos de un sensor de gas de tipo reed y enviar los datos a través de RFM12B a un nodo de registro.
// El código se basa en el código de ejemplo de JeeLib y se ha modificado para adaptarse a las necesidades de este proyecto.
// También está basado en código encontrado en el foro de Open Energy Monitor pero han pasado años y no localizo nombre ni autor (lo siento)

/* Asignación recomendada de ID de nodo
------------------------------------------------------------------------------------------------------------
-ID-  - Tipo de Nodo
0     - Asignación especial en el controlador JeeLib RFM12: reservado para uso OOK
1-4   - Nodos de control
5-10  - Nodos de monitoreo de energía
11-14 - No asignado--
15-16 - Estación base y nodos de registro
17-30 - Nodos de detección ambiental (temperatura, humedad, etc.)
31    - Asignación especial en el controlador JeeLib RFM12: el Nodo31 puede comunicarse con nodos en cualquier grupo de red
-------------------------------------------------------------------------------------------------------------
*/

#define RF_freq RF12_868MHZ                                                // Frecuencia del módulo RF12B, puede ser RF12_433MHZ, RF12_868MHZ o RF12_915MHZ.
const int nodeID = 18;                                                     // ID del nodo Jeenode
const int networkGroup = 212;                                              // Grupo de red inalámbrica Jeenode RFM12B
const int UNO = 1;                                                         // Establecer en 0 si no se está utilizando el cargador de arranque UNO (es decir, utilizando Duemilanove)

#include <avr/wdt.h>                                                       // El cargador de arranque UNO
#include <JeeLib.h>                                                        // Descargar JeeLib: http://github.com/jcw/jeelib

ISR(WDT_vect) {
  Sleepy::watchdogEvent();
}
#include <avr/power.h>
#include <avr/sleep.h>
#include <PinChangeInt.h>                                                  // Interrupciones de cambio de pin.

typedef struct {
  unsigned int pulse, totalpulse, battery;
} PayloadGas;
PayloadGas gas;                                                          // Forma ordenada de empaquetar datos para la comunicación RF

const  unsigned long WDT_PERIOD = 1000;                                    // milisegundos.
const  unsigned long WDT_MAX_NUMBER = 10;                                  // Datos enviados después de WDT_MAX_NUMBER periodos de  WDT_PERIOD ms sin pulsos
//                              O
const  unsigned long PULSE_MAX_NUMBER = 5;                                 // Datos enviados después de PULSE_MAX_NUMBER pulsos
const  unsigned long PULSE_MAX_DURATION = 10;                              // El sensor se apaga durante PULSE_MAX_DURATION milisegundos después de un pulso para desactivar el rebote.

const int BATT_ADC = A0;
const int magPin = 3;                                                      // Sensor magnético
const int ledPin = 13;                                                     // LED de depuración.

// Objetos
PCintPort PCintPort();

volatile unsigned long pulseCount ;
volatile unsigned long elapsed_time;
unsigned long WDT_number;

boolean  debug = true;
boolean  p;                                                                // Bandera para nuevo pulso

void setup()
{
  Serial.begin(57600);
  Serial.println("ContadorReedDelGas.ino V1.0c");
  Serial.print("Grupo Id: ");
  Serial.println(networkGroup);
  Serial.print("ID de nodo: ");
  Serial.println(nodeID);
  Serial.print("Enviando datos después de ");
  Serial.print(PULSE_MAX_NUMBER);
  Serial.println(" pulsos");
  Serial.print("  o  ");
  Serial.print(WDT_MAX_NUMBER);
  Serial.print(" periodos de ");
  Serial.print(WDT_PERIOD);
  Serial.println(" ms sin ningún pulso");
  Serial.println("Inicializando RF..");
  delay(100);
  rf12_initialize(nodeID, RF_freq, networkGroup);                          // Inicializar RF
  rf12_sleep(RF12_SLEEP);
  Serial.println("RF listo");
  delay(50);

  gas.pulse = 0;
  gas.totalpulse = 0;
  gas.battery = 0;
  pulseCount = 0;
  analogReference(INTERNAL);
  delay(50);

  WDT_number = 0;

  if (Serial) debug = 1; else debug = 0;                                   // Si la UART serie a USB está conectada, mostrar la salida de depuración. Si no, deshabilitar la serie.
  debug = true;
  p = 0;

  pinMode(magPin, INPUT);                                                  // Establecer el pin como entrada
  digitalWrite(magPin, HIGH);                                              // No utilizar la resistencia pull-up interna
  pinMode(ledPin, OUTPUT);
  digitalWrite(ledPin, !0);

  // attachInterrupt(1, onPulse, RISING);                                  // Interrupción de kWh adjunta a IRQ 0  = Digita 2 - conectado directamente al bloque de terminales
  PCintPort::attachInterrupt(magPin, onPulse, FALLING);

  gas.battery = (unsigned int)(analogRead(BATT_ADC) *   0.542);            // La primera lectura de DAC es inexacta
}

/**
 * The main loop function that runs repeatedly in the program.
 * It checks for incoming pulses, performs fading, and sends RF data.
 */
void loop()
{
  // Si acaba de llegar un pulso, esperar PULSE_MAX_DURATION ms para el desvanecimiento
  if (p) {
    Serial.flush;
    Sleepy::loseSomeTime(PULSE_MAX_DURATION);
    if (debug == debug) {
      flashLed(25);
    }
    p = 0;
  }

  Serial.flush;
  if (Sleepy::loseSomeTime(WDT_PERIOD) == 1) {                            // Verdadero si no ocurrió ningún pulso durante el WDT
    WDT_number++;                                                         // Número de WDT finalizados normalmente desde el último envío de RF
    if (debug) {
      Serial.print(".");
      delay(3);
    }
  }
  else if (debug)
  {
    Serial.print("INT ");
    delay(5);
    Serial.println(pulseCount);
    delay(5);
  }

  if (WDT_number >= WDT_MAX_NUMBER || pulseCount >= PULSE_MAX_NUMBER) {
    cli(); // Desactivar la interrupción en caso de que llegue un pulso mientras estamos actualizando el conteo
    gas.totalpulse += (unsigned int) pulseCount;
    gas.pulse = (unsigned int) pulseCount;
    pulseCount = 0;
    sei();

    gas.battery = (unsigned int)(readVcc());

    if (debug == 1) {
      Serial.print("ADC: "); delay(5); Serial.println(readVcc()); delay(5);
      Serial.print("Batería: "); delay(5); Serial.println(gas.battery); delay(5);
    }

    if (debug == 1) {
      Serial.println(""); delay(5);
      Serial.print("Enviando "); delay(5);
      Serial.print(gas.pulse); delay(5);
      Serial.print("/"); delay(5);
      Serial.print(gas.totalpulse); delay(5);
      Serial.print("/"); delay(5);
      Serial.print(gas.battery); delay(5);
      Serial.println(""); delay(5);
    }

    send_rf_data();                          // *ENVIAR DATOS RF* - 
    WDT_number = 0;
  }
}

// La rutina de interrupción - se ejecuta cada vez que se detecta un flanco descendente de un pulso
void onPulse()
{
  p = 1;                                     // Bandera para nuevo pulso establecida a verdadero
  pulseCount++;                              // Número de pulsos desde el último envío de RF
}

// Calcular el voltaje de la MCU (mV).
long readVcc() {
  long result;
  ADMUX = _BV(REFS0) | _BV(MUX3) | _BV(MUX2) | _BV(MUX1);
  Sleepy::loseSomeTime(2);
  ADCSRA |= _BV(ADSC);
  while (bit_is_set(ADCSRA, ADSC));
  result = ADCL;
  result |= ADCH << 8;
  result = 1126400L / result;
  return result;
}

// Enviar datos a través del módulo RF
void send_rf_data()
{
  power_spi_enable();
  rf12_sleep(RF12_WAKEUP);
  rf12_sendNow(0, &gas, sizeof gas);   // Enviar datos de temperatura a través de RFM12B utilizando el wraper rf12_sendNow
  rf12_sendWait(2);
  rf12_sleep(RF12_SLEEP);
  power_spi_disable();
}

// Parpadear un LED con fines de depuración
void flashLed (int i) {
  digitalWrite(ledPin, !1);
  Sleepy::loseSomeTime(i);
  digitalWrite(ledPin, !0);
}