|     Inicio    |   |         |  |   FOROS      |  |      |      
   Elastix - VoIP B4A (Basic4Android) App inventor 2 PHP - MySQL
  Estación meteorológica B4J (Basic4Java) ADB Shell - Android Arduino
  AutoIt (Programación) Visual Basic Script (VBS) FireBase (BD autoactualizable) NodeMCU como Arduino
  Teleco - Emisora de A.M. Visual Basic Cosas de Windows Webs interesantes
T Búsqueda en este sitio:


.

Arduino en español
Circuitos con Arduino - Juan Antonio Villalpando

-- Tutorial de iniciación a Arduino --

Volver al índice del tutorial

____________________________

49BJ.- Teclado 4x4, bus I2C. Pantalla LCD. Sensor de humedad y temperatura. Infrarojo. RadioFrecuencia. Reloj. Lluvia. I2C. INT. ArduinoI2C-Humo.

- Nuestro proyecto va así:

- Teclado 4x4 con módulo I2C.
- Pantalla LCD.
- Sensor de Temperatura y Humedad.
- Infrarojo.
- Radio Frecuencia. Emisor y Receptor.
- Sensor de ultrasonido.
- Sensor de lluvia.
- Módulo I2C con sensores de inclinación, magnetismo y movimiento.
- Sensor de efecto Hall con interrupción.

- Añadimos un sensor de humo por I2C.

- Observamos que el segundo Arduino envía los datos al primer Arduino mediante Radio Frecuencia.

- Vamos a aprovechar este segundo Arduino para conectarlo al primer Arduino mediante bus I2C, de manera que le enviará los datos de un sensor de humo por bus I2C.

- Para estudiar la conexión entro dos Arduino mediante I2C, podemos consultar este tutorial: 30.- Comunicación entre dos Arduinos. Bus I2C.

- Para realizar las pruebas vamos a utilizar un sensor de humo MQ-2, este sensor tiene salida Digital D0 y Analógica A0, vamos a utilizar la Analógica.

- Es decir, el sensor de humo captará el humo en las proximidades del segundo Arduino y enviará su nivel al primer Arduino mediante bus I2C.

- Para visualizar el humo en la pantalla LCD, pulsaremos la tecla '1' del teclado.

_______________________
- Teclados y LED.

'A' - 'B' Modifica la temperatura máxima para encender el LED13 LED13
'B' Visualiza la Humedad en LCD. LED13
'C' Visualiza la Temperatura en LCD. LED13
'#' Fin de entrada de datos para la opción 'A'  
Mando de infrarojo Teclas '1' y '2' del mando de infrarojo. LED7
'D' Distancia ultrasonido por Radio Frecuencia en LCD.  
PulsadorA
PulsadorB
  LED5
LED6
'*' Visualiza la hora en LCD.  
'A' - 'C' Modifica la lluvia máxima para encender el LED4 LED4
'0' Visualiza la lluvia en LCD.  
  Sensor de inclinación, el magnético o el de movimiento. (I2C) LED12
  Sensor de efecto Hall (Interrupción) LED7 (repetido en infrarojo)
'1' Visualiza humo en LCD. (I2C)  

______________________________________________________
- Conexionado I2C.

- Observa que los dos Arduino están conectamos mediante I2C.

- Podemos tomar las conexiones I2C (SCL y SDA) desde cualquier punto que los posea, bien en un módulo I2C o simplemente donde encontremos conexiones I2C en el Arduino, es decir no es necesario el módulo I2C, simplemente podemos conectar donde tengamos conexiones I2C, en la figura de abajo he conectado al módulo I2C, pero no es preciso, lo he puesto ahí simplemente por comodidad del dibujo.

- Como los dos Arduino están conectados también con su alimentación (5 V y Gnd), al alimentar uno de ellos se alimenta el otro, es decir solo es necesario conectar uno a una alimentación exterior.

- En caso de que queramos conectar a los dos independientemente, cada uno con una alimentación exterior, pero conectados a su bus I2C, es conveniente que estén conectado con el cable de GND, además de SCL y SDA, ya que normalmente cada vez que conectemos elementos que compartan señal, es conviente que tengan entre ellos conexión GND.

______________________________________________________
- Conexionado del sensor de humo en el segundo Arduino.

- Conctamos el sensor de humo a la entrada Analógica A3.

______________________________________________________
- Código para el Arduino Receptor.

Teclado_LCD_humedad_ir_rfr_reloj_lluvia_i2c_int_humo.ino

// Juan A. Villalpando.
// Abril 2018. KIO4.COM
#include <Wire.h>
// Teclado.
#include <Keypad_I2C.h>
#include <Keypad.h>
// Pantalla LCD
#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x27, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE);
// LiquidCrystal_I2C lcd(0x3F, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE);
#define LED13 13
#define LED7 7
// Sensor humedad-temperatura.
#include <DHT.h> 
#define DHTPIN 2 
#define DHTTYPE DHT11 
DHT dht(DHTPIN, DHTTYPE);
// Infrarojo.
#include <IRremote.h>
// Radio Frecuencia.
#include <VirtualWire.h>
const int pin_de_recepcion = 8; // RF
  #define LED5 5
  #define LED6 6
  int distancia;
  int distancia_old;
  boolean radiofrecuen = false;
  // Reloj RTC
#include <RTClib.h>
RTC_DS1307 RTC;
boolean reloj = false;
// Lluvia
  #define LED4 4
  int sensorA = A0;
  int valorA_lluvia = 0;
  int valorA_lluvia_2 = 0;
  int valorA_lluvia_old = 1.5;
  String maximo_lluvia = "5";
  boolean lluvia = false;
  //  Humo
  char c;
  String humostring ="";
  String humostring_old ="";
  boolean humo = false;
  // Sensores: inclinacion, magnetico, movimiento.
  #define LED12 12 
  // Interrupciones.
  #define INT3 3 // Se llama interrupcion 1
  volatile byte cambia = LOW;
  
// Teclado
const byte ROWS = 4; 
const byte COLS = 4;
String maximo = "40";
char key = ' ';
// Humedad Temperatura.
float humedad = 0.0;
float temperatura = 0.0;
float temperatura_old = 0.1;
boolean temperatu = false;
// Infrarojo.
int RECV_PIN = 11;
IRrecv irrecv(RECV_PIN);
decode_results results;
int tecla;
 
char keys[ROWS][COLS] = {
{'1','2','3','A'},
{'4','5','6','B'},
{'7','8','9','C'},
{'*','0','#','D'}
};
 
byte rowPins[ROWS] = {0,1,2,3}; 
byte colPins[COLS] = {4,5,6,7};
 
int i2caddress = 0x38; // Direccion I2C teclado.
#define direccion_PFC8574 0x39 // Direccion I2C módulo de sensores.
 
Keypad_I2C kpd = Keypad_I2C( makeKeymap(keys), rowPins, colPins, ROWS, COLS, i2caddress );
 
void setup(){
  Serial.begin(9600);
  kpd.begin();
  lcd.begin(16,2);// Columnas y filas de LCD
  pinMode(LED13, OUTPUT);
  // Humedad Temperatura.
  dht.begin();
  // Infrarojo.
  pinMode(LED7, OUTPUT);
  irrecv.enableIRIn();
  // Radio Frecuencia.
  // Inicializa IO y ISR
  pinMode(LED5, OUTPUT);
  pinMode(LED6, OUTPUT);
  ////pinMode(LED3, OUTPUT);
  Serial.println("Recepcion");
   vw_set_rx_pin(pin_de_recepcion);
   vw_setup(2000); // Bits por segundo
   vw_rx_start(); // Comienzo de recepción
   // Reloj RTC
   Wire.begin();
   RTC.begin();
   RTC.adjust(DateTime(__DATE__, __TIME__));
   // Lluvia.
   pinMode (LED4,OUTPUT);
   // Sensores: inclinacion, magnetico, movimiento.
   pinMode(LED12, OUTPUT);
   // Establecimiento de la INTerrupcion.
   pinMode(INT3, INPUT_PULLUP);
   attachInterrupt(digitalPinToInterrupt(INT3), cambiaLED, FALLING);
}
 
void loop(){
  digitalWrite(LED7, cambia); // Interrupcion.
  infrarojo();
  radiofrecuencia();
  valorA_lluvia = analogRead(sensorA);
  valorA_lluvia_2 = map(valorA_lluvia, 160, 1020, 10, 0); // Entre 0 y 10.
  //////////////////////////////////////////////////////////
  byte cual; // Sensores: inclinacion, magnetico, movimiento.
  cual = Leer(direccion_PFC8574);
                                if(bitRead(cual,0)){
                                digitalWrite(LED12, LOW);
                                }else{
                                digitalWrite(LED12, HIGH);}
                                
                                if(bitRead(cual,1)){
                                digitalWrite(LED12, LOW);
                                }else{
                                digitalWrite(LED12, HIGH);}
                                
                                if(bitRead(cual,2)){
                                digitalWrite(LED12, LOW);
                                }else{
                                digitalWrite(LED12, HIGH);}
  /////////////////////////////////////////////////////////

  key = kpd.getKey();
  if (key){
      if (key == 'A'){ // Cambiar maximo.
       introduce_maximo();
      }      
      if (key == 'B'){ // Ver humedad.
       ver_humedad();
      }
      if (key == 'C'){ // Ver temperatura.
       temperatu = !temperatu;
       temperatura_old = 999999;
       reloj = false;
       lluvia = false;
       radiofrecuen = false;
       humo = false;
      }
      if (key == 'D'){ // Ver RadioFrecuencia-Ultrasonido.
       radiofrecuen = !radiofrecuen;
       distancia_old = 999999;
       reloj = false;
       temperatu = false;
       lluvia = false;
       humo = false;
      }
      if (key == '*'){ // Ver Reloj RTC.
       reloj = !reloj;
       lluvia = false;
       temperatu = false;
       radiofrecuen = false;
       humo = false;
      }
      if (key == '0'){ // Ver lluvia
       lluvia = !lluvia;
       valorA_lluvia_old = 999999;
       reloj = false;
       temperatu = false;
       radiofrecuen = false;
       humo = false;
      }
      if (key == '1'){ // Ver Humo por Conexion I2C.
       humo = !humo;
       humostring_old = 999999;
       reloj = false;
       temperatu = false;
       lluvia = false;
       radiofrecuen = false;
      }
  }
     if (temperatu){ver_temperatura();}
     if (reloj){ver_reloj();} 
     if (lluvia){ver_lluvia();} 
     if (humo){ver_humo();} 
     if (radiofrecuen){ver_radiofrecuencia();} 
     if (String(temperatura) >= maximo) {
          digitalWrite(LED13, HIGH);
       } else {
          digitalWrite(LED13, LOW);
      }
      if (String(valorA_lluvia_2) >= maximo_lluvia) {
          digitalWrite(LED4, HIGH);
       } else {
          digitalWrite(LED4, LOW);
      }
      
} // FIN loop.
///////////// FUNCIONES ///////////////////////////
///////////////////////////////////////////////////
/////  Introduccion de datos de maximo. ///////////
void introduce_maximo() {
     // maximo = "";
      lcd.setCursor(0,0); // Inicio del cursor
      lcd.print("Pulsa B o C");
      lcd.setCursor(0,1); // Siguiente renglón.
      lcd.print(maximo);
      maximo = "";
      maximo_lluvia = "";
      // Dos teclas.
      while (key != 'B' && key != 'C' && key != '#') { // '#' para salir
        Serial.println("Introduce otra tecla.");
        delay(50);
        key = kpd.getKey();
        Serial.print(key);
        }
     if (key == 'B'){   // Establecer temperatura.
                 while (key != '#' )
                    {
                       key = kpd.getKey(); 
                       if (key){
                        maximo = maximo + key;
                        lcd.clear(); // Borra pantalla
                        lcd.setCursor(0,0); // Inicio del cursor
                        lcd.print("Temperat. maxima");
                        lcd.setCursor(0,1); // Siguiente renglón.
                        lcd.print(maximo);
                        delay(100);
                        }
                    }
                    }
         if (key == 'C'){  // Establecer lluvia. 
               while (key != '#' )
                  {
                     key = kpd.getKey(); 
                     if (key){
                      maximo_lluvia = maximo_lluvia + key;
                      lcd.clear(); // Borra pantalla
                      lcd.setCursor(0,0); // Inicio del cursor
                      lcd.print("Lluvia maxima");
                      lcd.setCursor(0,1); // Siguiente renglón.
                      lcd.print(maximo_lluvia);
                      delay(100);
                      }
                  }
                  }              
                    
  }
///////////////////////////////////////////////////
/////  Ver informacion humedad ///////////////////
void ver_humedad() {
  lcd.clear(); // Borra pantalla
  humedad = dht.readHumidity();
  lcd.setCursor(0,0); // Inicio del cursor
  lcd.print("Humedad");
  lcd.setCursor(0,1); // Siguiente renglón.
  lcd.print(humedad);
  delay(50);
  }
///////////////////////////////////////////////////
/////  Ver informacion temperatura ////////////////
void ver_temperatura() { 
  temperatura = dht.readTemperature();
  if (temperatura != temperatura_old) { // Para que no parpadee.
  temperatura_old = temperatura;
  lcd.clear(); // Borra pantalla
  lcd.setCursor(0,0); // Inicio del cursor
  lcd.print("Temperatura");
  lcd.setCursor(0,1); // Siguiente renglón.
  lcd.print(temperatura);
  delay(50);
  }
}
///////////////////////////////////////////////////
/////  Leer infrarojo ////////////////////////////
void infrarojo() {
  if (irrecv.decode(&results)) {
  Serial.println(results.value, DEC);
  tecla=results.value; // Obtenemos el valor decimal de la tecla pulsada
  //Serial.println(tecla);
  if (tecla==12495){ // Código de la tecla 1 
  digitalWrite(LED7, HIGH);
  }
  if (tecla==6375){ // Código de la tecla 2 
  digitalWrite(LED7, LOW);
  }
  irrecv.resume(); // Receive the next value
  }
  delay(100);
}
///////////////////////////////////////////////////
/////  Leer Radio Frecuencia //////////////////////
  void radiofrecuencia() {
  uint8_t buf[VW_MAX_MESSAGE_LEN];
  uint8_t buflen = VW_MAX_MESSAGE_LEN;
  
  if (vw_get_message(buf, &buflen))
  {
  int i;
  // Mensaje en el Monitor Serial
  for (i = 0; i < buflen; i++)
  {
  Serial.print((char) buf[i]); // Salen los 6 caracteres
  Serial.print(' ');
  }
  Serial.println();

//////////////// Los LED
// LED5
  if(buf[0] == '0'){
   digitalWrite(LED5,HIGH);   
  } else {
   digitalWrite(LED5,LOW); 
  }
  // LED6
  if(buf[1] == '0'){
   digitalWrite(LED6,HIGH);   
  } else {
   digitalWrite(LED6,LOW); 
  }

// Obtiene el valor del potenciómetro
   int a, b, c, d;

   a = 1000 * (buf[2] - 48);
   b = 100 * (buf[3] - 48);
   c = 10 * (buf[4] - 48);
   d = 1 * (buf[5] - 48);

   distancia =  a + b + c + d;
   Serial.print("Distancia ultrasonido = "); 
   Serial.println(distancia);
}
} 
///////////////////////////////////////////////////
/////  Ver radiofrecuencia en LCD ////////////////
void ver_radiofrecuencia() {
  if (distancia != distancia_old) { // Para que no parpadee.
    distancia_old = distancia;
  lcd.clear(); // Borra pantalla
  lcd.setCursor(0,0); // Inicio del cursor
  lcd.print("Distancia (RF)");
  lcd.setCursor(0,1); // Siguiente renglón.
  lcd.print(distancia);
  delay(50);
  }
}
///////////////////////////////////////////////////
/////  Ver Reloj RTC en LCD ///////////////////////
void ver_reloj() {
  DateTime now = RTC.now();
  lcd.clear(); // Borra pantalla
  lcd.setCursor(0,0); // Inicio del cursor
  lcd.print(now.day(), DEC);
  lcd.print("/");
  lcd.print(now.month(), DEC);
  lcd.print("/");
  lcd.print(now.year(), DEC);
  lcd.setCursor(0,1); // Siguiente renglón.;
  lcd.print(now.hour(), DEC);
  lcd.print("/");
  lcd.print(now.minute(), DEC);
  lcd.print("/");
  lcd.print(now.second(), DEC);
  delay(200);
}
//////////////////////////////////////////////////
/////// Ver lluvia en LCD ///////////////////////
void ver_lluvia() {
  valorA_lluvia = analogRead(sensorA);
  valorA_lluvia_2 = map(valorA_lluvia, 160, 1020, 10, 0);
  if (valorA_lluvia_2 != valorA_lluvia_old) { // Para que no parpadee.
    valorA_lluvia_old = valorA_lluvia_2;
    lcd.clear(); // Borra pantalla
    lcd.setCursor(0,0); // Inicio del cursor
    lcd.print("Lluvia");
    lcd.setCursor(0,1); // Siguiente renglón.
    valorA_lluvia_2 = map(valorA_lluvia, 160, 1020, 10, 0);
    lcd.print(valorA_lluvia_2);
    delay(50);
   }
}
//////////////////////////////////////////////////
// Sensores: inclinacion, magnetico, movimiento. /
byte Leer(int direccion) {
byte LeeDato = 0xff;
Wire.requestFrom(direccion,1);
if(Wire.available()){
LeeDato = Wire.read();
}
return LeeDato;
}
///////////////////////////////////////////////
///// Interrupcion ///////////////////////////
void cambiaLED() {
  cambia = !cambia;
}
///////////////////////////////////////////
/////  Leer HUMO I2C //////////////////////
    void ver_humo() {
  //  Dos Arduinos I2C
                  Wire.requestFrom(2, 3);    // Le pide 3 bytes al Esclavo 2
                  humostring ="";
                  while(Wire.available())
                  { 
                    c = Wire.read();   // Recibe byte a byte
                   // Serial.print(String(c));
                    humostring = humostring + String(c);
                  }

  if (humostring != humostring_old) { // Para que no parpadee.
  humostring_old = humostring;
  lcd.clear(); // Borra pantalla
  lcd.setCursor(0,0); // Inicio del cursor
  lcd.print("Humo (I2C)");
  lcd.setCursor(0,1); // Siguiente renglón.
  lcd.print(humostring);
  delay(50); 
}
}

______________________________________________________
- Código para el Arduino Emisor.

Teclado_LCD_humedad_ir_rfr_reloj_lluvia_i2c_int_humo.ino

// Juan Antonio Villalpando
// juana1991@yahoo.com
// kio4.com

#include <VirtualWire.h>
#include <Wire.h>
// Ultrasonido.
int Trigger = 11;
int Echo = 10;
long microsegundos;
long duracion;
#define pulsadorA  4
#define pulsadorB  5
 int valorA, valorB;
 char A, B;
 int distancia;
 String str="";
 // Humo
const int pin_humo = A2;
String humo;
String enviar_humo;
// RF
 const int pin_de_transmision = 7; // RF

void setup()
{
// Inicializa IO y ISR
vw_set_tx_pin(pin_de_transmision);
vw_setup(2000); // Bits por segundo
pinMode(pulsadorA, INPUT); 
pinMode(pulsadorB, INPUT); 
pinMode(Trigger, OUTPUT);
pinMode(Echo, INPUT);
Serial.begin(9600);
// Bus I2C otro Arduino.
Wire.begin(2);                // Este Esclavo es el número 2
Wire.onRequest(requestEvent); // Cuando el Maestro le hace una petición,
                             // realiza el requestEvent
}

void loop()
{
ultrasonido();
sensor_humo();
valorA = digitalRead(pulsadorA);
valorB = digitalRead(pulsadorB);

// A y B son los valores de los botones.
if (valorA == HIGH) { 
  A='0';
} else {
  A='1';
}

if (valorB == HIGH) { 
  B='0';
} else {
  B='1';
} 

// str es el valor de la distancia con 4 caracteres.
//  String str="";
  str = "0000" + String(distancia); // Pasa el entero a String
  str = str.substring(str.length()-4); // Siempre 4 caracteres

  char msg[6] = {A, B, str[0], str[1],str[2], str[3]};
  vw_send((uint8_t *)msg, 6); // Send: Aquí envía 6 elementos.
  // Si está A y B en alto y la distancia en 546, enviará:
  // 1 1 0 5 4 6
  vw_wait_tx(); // Espera que termine el mensaje
  delay(100);
}
/////////////////////////////////////////////
///////////FUNCION ULTRASONIDO //////////////
void ultrasonido(){
digitalWrite(Trigger, LOW);
delayMicroseconds(2);
digitalWrite(Trigger, HIGH);
delayMicroseconds(10);
digitalWrite(Trigger, LOW);
delayMicroseconds(2);

duracion = pulseIn(Echo, HIGH);
distancia = duracion / 29 / 2;

Serial.println(String(distancia));
delay(50);
}
/////////////////////////////////////////////
///////////////// HUMO ///////////
void sensor_humo(){
int lee_humo = analogRead(pin_humo);
enviar_humo = "000" + String(map(lee_humo, 100, 500, 0, 10));
//// Funcion enviar datos por I2C al otro Arduino.
// Esto es lo que envía cuando le hace la petición.
}
void requestEvent()
{   
 // Wire.write(str.substring(str.length()-3).c_str()); // Envía 3 bytes
 Wire.write(enviar_humo.substring(enviar_humo.length()-3).c_str()); // Envía 3 bytes                
}

______________________________________________________
- Comentarios.

- El sensor que hemos utilizado tiene salida Digital D0 y Analógica A0, utilizaremos solo la Analógica D0, que la conectamos al terminal A2 del Arduino.

- Al pulsar la tecla '1' visualizaremos el humo en la pantalla LCD.

- El segundo Arduino enviará por conexión bus I2C el nivel de humo captado por su sensor.

______________________________________________________
________________________________

 

 

- Mi correo:
juana1991@yahoo.com
- KIO4.COM - Política de cookies. Textos e imágenes propiedad del autor:
© Juan A. Villalpando
No se permite la copia de información ni imágenes.
Usamos cookies propias y de terceros que entre otras cosas recogen datos sobre sus hábitos de navegación y realizan análisis de uso de nuestro sitio.
Si continúa navegando consideramos que acepta su uso. Acepto    Más información