Arduino IoT: Tutorial Medidor de Agua Inteligente

Arduino Honduras Santiapps Marcio Valenzuela

Tutorial Medidor de Agua Inteligente Parte I

 

En este tutorial exploraremos mas sensores, pero aplicados.  En nuestro proyecto usamos un flujo metro construido a partir de un sensor Hall Effect para medir el flujo de agua por un conducto.

Se mira asi:

Arduino IoT: Tutorial Medidor de Flujo by Santiapps Marcio Valenzuela
Arduino IoT: Tutorial Medidor de Flujo de Agua by Santiapps

El codigo:

byte statusLed = 13;
byte sensorInterrupt = 0; // 0 = digital pin 2
byte sensorPin = 2;
// El sensor hall-effect emite ~ 4.5 pulses/sec/litre/min 
float calibrationFactor = 4.5;
volatile byte pulseCount;
float flowRate;
unsigned int flowMilliLitres;
unsigned long totalMilliLitres;
unsigned long oldTime;
void setup(){

Serial.begin(38400);
// Usarmos una LED como salida
pinMode(statusLed, OUTPUT);
digitalWrite(statusLed, HIGH);
pinMode(sensorPin, INPUT);
digitalWrite(sensorPin, HIGH);
pulseCount = 0;
flowRate = 0.0;
flowMilliLitres = 0;
totalMilliLitres = 0;
oldTime = 0;

// Configuramos para que dispare con FALLING state (HIGH a LOW)
attachInterrupt(sensorInterrupt, pulseCounter, FALLING);
}
void loop(){
if((millis() - oldTime) > 1000) { // Only process counters once per second
// Dishabilitamos el interrupt al calcular flujo y enviar
detachInterrupt(sensorInterrupt);
// Calculamos ms transcurridos desde la ultima ejecucion para escalar el resultado. Aplicamos el factor calibrationFactor para escalar el resultado en base al # de pulsos/sec de medición (litres/minute en este caso) proveniente del sensor
flowRate = ((1000.0 / (millis() - oldTime)) * pulseCount) / calibrationFactor;
// Usar el tiempo de esta ejecucion porque deshabilitamos el interrupt por ende los millis() no funcionaran pero aun asi se retornara el valor justo antes que se deshabilito
oldTime = millis();
// Dividir el flujo en litres/minute por 60 para determinar cuantos L han pasado por el sensor en el intervalo de 1 sec y luego multiplicamos por 1000 para convertir a mL.
flowMilliLitres = (flowRate / 60) * 1000;
// Sumamos los mL pasados en este segundo al total cumulativo
totalMilliLitres += flowMilliLitres;
unsigned int frac;
// Imprimir el flujo para este intervalo de 1 segundo en litres / minute
Serial.print("Flujo: ");
Serial.print(int(flowRate)); // Imprimir el entero
Serial.print("."); // Imprimir el decimal
// Determinar la fraction. El 10 multiplicador nos da 1 decimal.
frac = (flowRate - int(flowRate)) * 10;
Serial.print(frac, DEC) ; // Imprimir la parte fraccional
Serial.print("L/min");
// Imprimir L fluidos en este segundo
Serial.print(" Liquido Fluido reciente: "); // Separador
Serial.print(flowMilliLitres);
Serial.print("mL/Sec");
// Imprimir cumulativo de L fluidos desde el inicio
Serial.print(" Cantidad total fluido: "); // Separador
Serial.print(totalMilliLitres);
Serial.println("mL");
// Resetear el pulse counter para iniciar de nuevo
pulseCount = 0;
// Habilitar el interrupt nuevamente
attachInterrupt(sensorInterrupt, pulseCounter, FALLING);
}
}
void pulseCounter(){
// Incrementar pulse counter
pulseCount++;
}

Y la connexion es sencilla:

Arduino IoT: Tutorial Medidor de Flujo de Agua by Santiapps Marcio Valenzuela
Arduino IoT: Tutorial Medidor de Flujo de Agua

Lo conectamos a una salida de agua como una bañera:

Arduino IoT: Tutorial Medidor de Flujo de Agua by Santiapps Marcio Valenzuela
Arduino IoT: Tutorial Medidor de Flujo de Agua

Los resultados:

Arduino IoT: Tutorial Medidor de Flujo de Agua by Santiapps Marcio Valenzuela
Arduino IoT: Tutorial Medidor de Flujo de Agua

Esto fue durante ~ 10 segundos.  Vamos a incorporar esto a nuestro proyecto de casa inteligente.

Arduino IoT: Tutorial sobre LM7805 como fuente de poder

Arduino IoT Arduino (IoT): Simple Tutorial de Infrarojo (IR) Receptor/Transmisor by Santiapps Marcio Valenzuela
Arduino IoT Arduino (IoT): Simple Tutorial de Infrarojo (IR) Receptor/Transmisor

Arduino (IoT): Tutorial LM7805 como fuente de poder

 

Muchas veces terminamos un prototipo y queremos llevarlo a la practica.  Es decir, queremos hacerlo funcionar en el ambiente para el cual fue diseñado.  El ejemplo típico en robótica es un carro, que luego de subir el codigo desde la compu al carro y probarlo mientras sigue conectado a la compu, queremos llevarlo a la calle.  En el caso de este robot para remover semillas, queremos conectarlo a su fuente de poder (baterías recargables) y llevarlo a la practica.

El problema es que necesitamos 5V para nuestros MCUs (a veces 3.3V) y tenemos combinaciones de baterías AA que nos dan 3V, 4.5V, 6V etc.  En este caso tenemos un par de baterías de alta capacidad de 3.7V cada una, ósea que tenemos 7.4V lo cual no podemos alimentar a nuestro MCU.

Entra el regulador de voltage, LM7805.  Este es uno de los componentes mas comunes en la electronica de hoy en dia.  A pesar que conectamos muchos electrónicos a la pared, de donde obtenemos 120VAC, nuestros electrónicos:

  • Celulares
  • Videojuegos portatiles
  • Tablets
  • Camaras digitales

Todos utilizan 5VDC.  Hay muchos otros componentes que reducen 120VAC a 5VDC y veremos eso en un tutorial mas adelante, pero por lo general siempre queremos tener 5VDC estables, y eso se obtiene a través de un regulador como este.

El diferencial de voltaje entre 7.4V y 5V se pierde como calor y a veces es necesario usar una fuente de disipación termica que en este caso no usamos, a pesar que los LM7805 traen una pequeña incorporada en su parte posterior que se ve de color gris-metal con un agujero en medio.  Por lo general para disipar voltajes mas altos se ocupa conectar el LM7805 a una placa mas grande.

Aquí vemos como los 7.4V son traspasados a 5V por el LM7805 y luego alimentados al mcu nano y al servo.  La LCD muestra el voltaje de la fuente de poder y lo vemos registrado como 4.99-5VDC.

Video

Es muy util poner uno de estos reguladores en un modulo aparte porque su uso sera muy frecuente.  El diagrama es así:

Arduino IoT: Tutorial LM7805 en Voltmeter by Santiapps Marcio Valenzuela
Arduino IoT: Tutorial LM7805 en Voltmeter

Y el producto final se mira asi:

Este fue

Arduino IoT: Tutorial Uso de LM7805 Regulador de Voltaje by Santiapps Marcio Valenzuela
Arduino IoT: Tutorial Uso de LM7805 Regulador de Voltaje

Aqui vemos la entrada a la derecha:

blanco: positivo & negro: negativo

Luego se pasa por el capacitor de 100uF, luego el LM7805 y finalmente el capacitor de 10uF.  Finalmente tenemos a la izquierda:

rojo: positivo & naranja: negativo

Aquí vemos un pack de baterias de 3.7V cada una en serie, para un total de 7.4V según muestra el medidor:

Arduino IoT: Tutorial Uso de LM7805 Regulador de Voltaje by Santiapps Marcio Valenzuela
Arduino IoT: Tutorial Uso de LM7805 Regulador de Voltaje

Aqui vemos la medición directa del paquete de batería.  El regulador esta fuera de linea.

Arduino IoT: Tutorial Uso de LM7805 Regulador de Voltaje by Santiapps Marcio Valenzuela
Arduino IoT: Tutorial Uso de LM7805 Regulador de Voltaje

Finalmente vemos el regulador en acción, entre el pack de baterías y el medidor.  Aquí se ve el voltaje final regulado, el que podemos usar con seguridad en nuestros proyectos.

Los LM7805 se piden encontrar en muchos dispositivos electrónicos viejos que puede desarmar.

In: Entran 7.4V

GND: Tierra

Out: Salen 5.0V regulados

Arduino (IoT): Simple Tutorial de IR Receptor/Transmisor (Parte 3)

Arduino IoT Arduino (IoT): Simple Tutorial de Infrarojo (IR) Receptor/Transmisor by Santiapps Marcio Valenzuela
Arduino IoT Arduino (IoT): Simple Tutorial de Infrarojo (IR) Receptor/Transmisor

Arduino (IoT): Simple Tutorial de IR Receptor/Transmisor (Parte 3)

 

En la Parte 1 & 2 vimos como usar receptor y LED IR para leer controles y controlar LEDs de color. Ahora veremos como enviar nuestros propios códigos o señales IR desde un LED IR.  Es decir, en la primera parte solo usamos el receptor IR para recibir los códigos de un control remoto.  Ahora enviaremos esos códigos al dispositivo para controlarlo.

 

Conexiones

 

Nuestra conexión sera si:

Arduino (IoT) Simple Tutorial Infrarojo (IR) Receptor/Transmisor by Santiapps Marcio Valenzuela
Arduino (IoT) Simple Tutorial Infrarojo (IR) Receptor/Transmisor

Aseguremos de conectar la LED correctamente con su pata al pin tierra y larga al resistor.

 

Codigo

El codigo de nuestro ejemplo sera el IRrecord de la librería:
[code]

/* record.ino Example sketch for IRLib2
* Illustrate how to record a signal and then play it back.
*/
#include <IRLibDecodeBase.h> //We need both the coding and
#include <IRLibSendBase.h> // sending base classes
#include <IRLib_P01_NEC.h> //Lowest numbered protocol 1st
#include <IRLib_P02_Sony.h> // Include only protocols you want
#include <IRLib_P03_RC5.h>
#include <IRLib_P04_RC6.h>
#include <IRLib_P05_Panasonic_Old.h>
#include <IRLib_P07_NECx.h>
#include <IRLib_HashRaw.h> //We need this for IRsendRaw
#include <IRLibCombo.h> // After all protocols, include this
// All of the above automatically creates a universal decoder
// class called “IRdecode” and a universal sender class “IRsend”
// containing only the protocols you want.
// Now declare instances of the decoder and the sender.
IRdecode myDecoder;
IRsend mySender;

// Include a receiver either this or IRLibRecvPCI or IRLibRecvLoop
#include <IRLibRecv.h>
IRrecv myReceiver(2); //pin number for the receiver

// Storage for the recorded code
uint8_t codeProtocol; // The type of code
uint32_t codeValue; // The data bits if type is not raw
uint8_t codeBits; // The length of the code in bits

//These flags keep track of whether we received the first code
//and if we have have received a new different code from a previous one.
bool gotOne, gotNew;

void setup() {
gotOne=false; gotNew=false;
codeProtocol=UNKNOWN;
codeValue=0;
Serial.begin(9600);
delay(2000);while(!Serial);//delay for Leonardo
Serial.println(F(“Send a code from your remote and we will record it.”));
Serial.println(F(“Type any character and press enter. We will send the recorded code.”));
Serial.println(F(“Type ‘r’ special repeat sequence.”));
myReceiver.enableIRIn(); // Start the receiver
}

// Stores the code for later playback
void storeCode(void) {
gotNew=true; gotOne=true;
codeProtocol = myDecoder.protocolNum;
Serial.print(F(“Received “));
Serial.print(Pnames(codeProtocol));
if (codeProtocol==UNKNOWN) {
Serial.println(F(” saving raw data.”));
myDecoder.dumpResults();
codeValue = myDecoder.value;
}
else {
if (myDecoder.value == REPEAT_CODE) {
// Don’t record a NEC repeat value as that’s useless.
Serial.println(F(“repeat; ignoring.”));
} else {
codeValue = myDecoder.value;
codeBits = myDecoder.bits;
}
Serial.print(F(” Value:0x”));
Serial.println(codeValue, HEX);
}
}
void sendCode(void) {
if( !gotNew ) {//We’ve already sent this so handle toggle bits
if (codeProtocol == RC5) {
codeValue ^= 0x0800;
}
else if (codeProtocol == RC6) {
switch(codeBits) {
case 20: codeValue ^= 0x10000; break;
case 24: codeValue ^= 0x100000; break;
case 28: codeValue ^= 0x1000000; break;
case 32: codeValue ^= 0x8000; break;
}
}
}
gotNew=false;
if(codeProtocol== UNKNOWN) {
//The raw time values start in decodeBuffer[1] because
//the [0] entry is the gap between frames. The address
//is passed to the raw send routine.
codeValue=(uint32_t)&(recvGlobal.decodeBuffer[1]);
//This isn’t really number of bits. It’s the number of entries
//in the buffer.
codeBits=recvGlobal.decodeLength-1;
Serial.println(F(“Sent raw”));
}
mySender.send(codeProtocol,codeValue,codeBits);
if(codeProtocol==UNKNOWN) return;
Serial.print(F(“Sent “));
Serial.print(Pnames(codeProtocol));
Serial.print(F(” Value:0x”));
Serial.println(codeValue, HEX);
}

void loop() {
if (Serial.available()) {
uint8_t C= Serial.read();
if(C==’r’)codeValue=REPEAT_CODE;
if(gotOne) {
sendCode();
myReceiver.enableIRIn(); // Re-enable receiver
}
}
else if (myReceiver.getResults()) {
myDecoder.decode();
storeCode();
myReceiver.enableIRIn(); // Re-enable receiver
}
}
[/code]

Aqui lo que hacemos es que del Monitor Serial vemos que código da el botón de encender/apagar del control de la television.  Eso se imprime en la pantalla del monitor y simplemente lo copiamos y lo pegamos en el mismo monitor, arriba, para ENVIAR ese códigos a través de la LED IR.  Movemos el proyecto cerca del televisor y la LED IR ahora enviara ese código y controlara el televisor!