|     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

____________________________

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

- Vamos a añadirle a nuestro proyecto un sensor de movimiento, otro de inclinación y otro magnético. Serán sensores digitales, es decir funcionarán como interruptores.

- Estos sensores los vamos a conectar a un bus I2C, para ahorrar terminales en el Arduino.

- Cuando se active cualquiera de esos sensores se encenderá el LED12 en el Arduino.

- Recordamos que un bus I2C, utiliza dos cables para trabajar con la información: SCL y SDA. A estos dos cables irán los sensores anteriormente indicado.

- Consulta los tutoriales sobre I2C:
49C.- Juego de luces con 8 LED en Bus I2C. Adaptador a Bus I2C, el PCF8574.
49D.- Leer pulsadores en Bus I2C. Encender LED. Adaptador a Bus I2C, el PCF8574.

49E.- Bus I2C. Adaptador a Bus I2C, el PCF8574. Entradas y salidas.

- Consulta los tutoriales los sensores utilizados:

40.- Interruptor de inclinación. Sensor SW-520D.
41.- Interruptor magnético.
47.- Detector de movimiento. Sensor piroeléctrico HC-SR501.

_______________________
- 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. LED12

- Funcionamiento:

- Al activarse el sensor de inclinación, el magnético o el de movimiento se encenderá el LED12 del Arduino.

______________________________________________________
- Conexionado.

- Observa, para que el módulo I2C de los sensores tenga la dirección 0x39, he cambiado el puente del A0, pero atención, no todos los módulos I2C vienen de fábrica con esa dirección, debemos ir al tutorial 31.- Pantalla LCD, y cargar un programa para escaner las direcciones de las tarjetas y dispositivos I2C que tenemos conectados, en el Monitor Serie nos dará sus direcciones, de ahí podemos tomar la dirección de nuestra tarjeta I2C.

- ATENCION: la tarjeta I2C puede tener una dirección distinta a la mostrada (0x39), debes cargar el programa para escaner los I2C y ver sus direcciones.

______________________________________________________
- Código para el Arduino.

jTeclado_LCD_humedad_ir_rfr_reloj_lluvia_i2c.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;
  // Sensores: inclinacion, magnetico, movimiento.
  #define LED12 12 
  
// 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);
}
 
void loop(){
  infrarojo();
  radiofrecuencia();
  valorA_lluvia = analogRead(sensorA);
  valorA_lluvia_2 = map(valorA_lluvia, 160, 1020, 10, 0);
  //////////////////////////////////////////////////////////
  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 = 99;
       reloj = false;
       lluvia = false;
       radiofrecuen = false;
      }
      if (key == 'D'){ // Ver RadioFrecuencia-Ultrasonido.
       radiofrecuen = !radiofrecuen;
       distancia_old = 123456;
       reloj = false;
       temperatu = false;
       lluvia = false;
      }
      if (key == '*'){ // Ver Reloj RTC.
       reloj = !reloj;
       lluvia = false;
       temperatu = false;
       radiofrecuen = false;
      }
      if (key == '0'){ // Ver lluvia
       lluvia = !lluvia;
       valorA_lluvia_old = 99;
       reloj = false;
       temperatu = false;
       radiofrecuen = false;
      }
  }
     if (temperatu){ver_temperatura();}
     if (reloj){ver_reloj();} 
     if (lluvia){ver_lluvia();} 
     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;
}

______________________________________________________
- Comentarios.

- IMPORTANTE.

- Este código es posible que no funcione ya que al utilizar el LED12 para los tres sensores (inclinación, magnético y movimiento), este LED12 estaría siempre apagado, ya que un sensor lo enciende y otro lo apaga.

- La mejor solución sería poner tres LED, por ejemplo LED10, LED11, LED12.

	   //////////////////////////////////////////////////////////
  byte cual; // Sensores: inclinacion, magnetico, movimiento.
  cual = Leer(direccion_PFC8574);
                                if(bitRead(cual,0)){
                                digitalWrite(LED10, LOW);
                                }else{
                                digitalWrite(LED10, HIGH);}
                                
                                if(bitRead(cual,1)){
                                digitalWrite(LED11, LOW);
                                }else{
                                digitalWrite(LED11, HIGH);}
                                
                                if(bitRead(cual,2)){
                                digitalWrite(LED12, LOW);
                                }else{
                                digitalWrite(LED12, HIGH);}
  /////////////////////////////////////////////////////////
	  
	  

- Para utilizar un solo LED12 podríamos poner:


	  if(bitRead(cual,0) || bitRead(cual,1) || bitRead(cual,2)){
      // cual = ~cual;
       digitalWrite(LED12, LOW);
       } else {
       digitalWrite(LED12, HIGH);
      }
	  

- Otro asunto es que en reposo podríamos tener 11111111 y nos gustaría 00000000

- Para invertir un byte utilizamos:

cual = ~cual;

- También te puede interesar pasar un byte a entero.

int entero = (int) cual;

___________________________________________________

- Observamos que se pueden utilizar dos maneras para definir las variables:

int i2caddress = 0x38; 
        // Direccion I2C teclado.
        #define direccion_PFC8574 0x39 // Direccion I2C módulo de sensores.


- Observa que con el define no se pone ;
int LED1 = 1; // Con punto y coma.
#define LED9 9 // Sin punto y coma.

- Esta es la función que lee el dato del I2C.

// Sensores: inclinacion, magnetico, movimiento. /
      byte Leer(int direccion) {
      byte LeeDato = 0xff;
      Wire.requestFrom(direccion,1);
      if(Wire.available()){
      LeeDato = Wire.read();
      }
      return LeeDato;
      }

- Es conveniente ver este tutorial para controlar las entradas del módulo I2C:
49D.- Leer pulsadores en Bus I2C. Encender LED. Adaptador a Bus I2C, el PCF8574.
_____________________________________________________
________________________________

 

- 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