|     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

____________________________

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

- 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.
- Sensor de Humo con envío de información mediante I2C
- Ahora le pondremos una LDR.

 

- Vamos a añadir a nuestro proyecto una LDR que entregará un número entre 0 y 255, este número controlará el Duty Cycle de un PWM, que a su vez hará que el LED19 ilumine más o menos.

- Para estudiar PWM podemos consultar este tutoria: 6.- PWM. Modulación por Anchura de Pulso. Duty Cycle.

- Para estudiar la LDR y el PWM podemos consultar este tutorial: 7.- LDR.

- Para realizar las pruebas vamos a utilizar una LDR que conectaremos a la entrada Analógica A1, en la salida Digital D10~ conectaremos un LED que iluminará más o menos según el valor de la LDR.

- En vez de utilizar una LDR y una resistencia fija, podríamos conectar un módulo como el indicado, observa que este módulo tiene salida Analógica A0, hay otros módulos que solo tienen salida Digital D0.

- Para visualizar el valor de la señal recibida LDR-PWM en la pantalla LCD, pulsaremos la tecla '2' 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)  
'2' Visualiza valor LDR-PWM LED10 PWM

______________________________________________________
- Conexionado.

- Conectamos la LDR a la entrada Analógica A1.
- Conectamos un LED al terminal 10 del Arduino.

______________________________________________________
- Código.

Teclado_LCD_humedad_ir_rfr_reloj_lluvia_i2c_int_humo_ldr.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;
  //  LDR PWM
  #define LED10 10 
  int pin_ldr = A1;
  int leer_ldr;
  int leer_ldr_2;
  int leer_ldr_old;
  boolean ldr = 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);
   // LDR PWM LED
   pinMode(LED10,OUTPUT);
}
 
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.
  leer_ldr = analogRead(pin_ldr);
  //////////////////////////////////////////////////////////
  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 (key == '2'){ // Ver LDR-PWM.
       ldr = !ldr;
       leer_ldr_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 (ldr){ver_ldr();} 
     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); 
}
}
//////////////////////////////////////////////////
/////// Ver LDR PWM LED  ///////////////////////
void ver_ldr() {
  String ver;
  leer_ldr = analogRead(pin_ldr);
  leer_ldr_2 = map(leer_ldr, 0, 1023, 0, 255);
  analogWrite(LED10, leer_ldr_2); // Enviamos a LED10 un Duty Cycle del 0 al 255.
  if (leer_ldr_2 != leer_ldr_old) { // Para que no parpadee.
    leer_ldr_old = leer_ldr_2;
    lcd.clear(); // Borra pantalla
    lcd.setCursor(0,0); // Inicio del cursor
    lcd.print("LDR -> PWM");
    lcd.setCursor(0,1); // Siguiente renglón.
    ver = String(leer_ldr) + " -> " + String(leer_ldr_2);
    lcd.print(ver);
    delay(50);
   }
}

______________________________________________________
- Motor con PWM, motor de ventilación de ordenador.

- En el terminal 10 del Arduino tenemos una señal PWM, provocada por la LDR, estos pulsos PWM lo podemos conectar a un motor de los que se utilizan en los ordenadores para enfriar la CPU, estos motores funcionan con PWM, según el pulso sea más estrecho o más ancho el motor girará a menos o más velocidad.

- Fíjate que alimentamos al motor con una alimentación externa de unos 12 V, ya que si lo alimentamos directamente con los 5 V del Arduino, extraería mucha intensidad de la tarjeta, además con 5 V no funcionaría eficientemente.

- Observa también que las GND del Arduino y de la batería están conectadas.

______________________________________________________
- Comentarios.

- El proyecto quedará así:

______________________________________________________
________________________________

 

 

- 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