Dispositivo de asistencia en el aparcamiento y evacuación de gases inflamables

Alumno: D. David García Martín

Asignatura: Innovación Docente de la Especialidad de Tecnología.

Máster: Máster Universitario en Profesor de Educación Secundaria Obligatoria y Bachillerato, Formación Profesional y Enseñanza de Idiomas

Centro: Universidad de Salamanca.

Curso: 2023/24

PROYECTO

Descripción del proyecto:

El dispositivo que se ha creado tiene la finalidad de prestar asistencia en la maniobra de aparcamiento en de una plaza de garaje individual mediente la emisión de sonidos y luces diversas, así cómo la detección y evacuaciónde  gases inflamables que se encuentren en el habitáculo. La idea es que se encuentre intalado de forma fija en la plaza de garaje en cuestión, con el sensor de ultrasonidos apuntando al morro del coche y la pantalla LCD a una altura suficiente como para que la distancia al obstáculo, que en esta se muestra en todo momento, pueda ser visualizada sin probelmas por el conductor del vehículo. El motor de DC simula el funcionamiento de un ventilador más grande ubicado en el techo de la plaza de garaje.

Los dispositivos de entrada de información de este sistema son el sensor de ultrasonidos HC-SR04 y el sensor de gas MQ-2. En función de sus lecturas, el sistema electrónico realizará diferentes acciones.

• Lectura del HC-SR04:

1. Si la distancia al obstáculo (de ahora en adelante "d") es mayor de 50 cm, el LED verde permanecerá encendido y el buzzer no emitirá ningún sonido.
2. Si 31 < d < 50 cm: el LED amarillo comenzará a parpadear a una velocidad derminada y el buzzer emitirá un sonido de 1600 Hz y 400 ms de duración.
3. Si 10 < d < 30 cm: el LED rojo comenzará a parpadear a una velocidad más rápida que en el caso anterior y el buzzer emitirá un sonido de 1200 Hz y 150 ms de duración.
4. Si 0 < d < 9 cm: todos los LED parpadearán al unísono a una velocidad mayor que en los casos anteriores y el buzzer emitirá un sonido de 800 Hz y 50 ms de duración.

• Lectura del MQ-2: Si el nivel de gas supera un umbral determinado por la calibración del propio sensor, éste emitirá una señal digital del tipo LOW al Arduino. Cuando esto suceda el motor DC se pondrá en marcha a una velocidad constante (señal PWM de 200), de manera que evacuará el gas inflamable del habitáculo. Una vez que la concentración del gas haya disminuido lo suficiente como para que no se active el sensor MQ-2, el motor se parará.

Componentes:

x1 Arduino MEGA 2560

x1 motor DC

x1 transistor NPN PN2222

x1 diodo rectificador

x1 resistencia de 330 Ω

x1 sensor de ultrasonidos HC-SR04

x1 buzzer pasivo

x1 pantalla LCD de 16x2

x1 sensor de gas MQ-2

x3 LED (rojo, amarillo y verde)

x1 potenciómetro de 10 kΩ

x3 resistencias de 220 Ω

Cables macho - macho y protoboard.

ESQUEMA DE CONEXIONES

CÓDIGO ARDUINO

/*Trabajo autónomo Innovación Docente  | MUPES  | Curso 2023/24.

Título: SENSOR DE APARCAMIENTO CON DETECCIÓN DE GAS INFLAMABLE

AUTOR: DAVID GARCÍA MARTÍN   dagama@usal.es

*/

#include <LiquidCrystal.h> //Incluyo la librería correspondiente para utilizar la pantalla LCD.

//Defino los pines de la pantalla LCD de 16x2 y se asigna

const int rs = 5, en = 6, d4 = 7, d5 = 8, d6 = 9, d7 = 10;

LiquidCrystal lcd(rs, en, d4, d5, d6, d7);

//Inicializo constantes enteras globales que son el número al que se conecta el elemento que da nombre a la constante entera

const int pinTRIG =2;   //Al pin 2 conecto TRIGGER del sensor ultrasónico

const int pinECCO = 3;  //Al pin 3 conecto ECCO del sensor ultrasónico

const int ledVERDE = 22;  //Al pin 22 conecto el LED verde

const int ledAMARILLO = 23;   //Al pin 23 conecto el LED amarillo

const int ledROJO = 24;   //Al pin 24 conecto el LED rojo

const int buzzer = 4;   //Al pin 4 conecto el buzzer pasivo

const int motor = 11;   //Defino pin motor

const int pingas = 50;  //Defino pin del sensor de gas

//Defino las variables necersarias para el cálculo de la distancia con el sensor ultrasónico

long duracion;  //Variable numérica global de tipo long

int distancia;  //Variable numérica global de tipo entera

void setup() {//Pasos que se ejecutan en el arranque del Arduino MEGA

  // Inicializo los pines que voy a usar y los configuro como entradas o salidas según corresponda

  pinMode(pinTRIG, OUTPUT);   //Configuro el pin "pinTRIGG" como pin de salida

  pinMode(pinECCO, INPUT);    //Configuro el pin "pinECCO" como pin de entrada

  pinMode(ledVERDE, OUTPUT);    //Configuro el pin "ledVERDE" como pin de salida

  pinMode(ledAMARILLO, OUTPUT);   //Configuro el pin "ledAMARILLO" como pin de salida

  pinMode(ledROJO, OUTPUT);   //Configuro el pin "ledROJO" como pin de salida

  pinMode(buzzer, OUTPUT);    //Configuro el pin "buzzer" como pin de salida

  pinMode(pingas, INPUT);    //Configuro el pin "pingas" como pin de entrada

  pinMode(motor, OUTPUT);

  //Inicializo la pantalla LCD de 16x2

  lcd.begin(16, 2);

 

  /*Inicializo el puerto serie. Con este se podrá comprobar que las lecturas que

  devuleve la pantalla LCD son correctas.*/

  Serial.begin(9600);

  analogWrite(motor, 0);  //empieza el sketch con el motor parado

}

void loop() {//Bucle principal del programa

  /*Si detecta que hay gas inflamable, activa el ventilador

  para que se vaya el gas*/

  //Genero un pulso en el pin de trigger del sensor ultrasónico

  digitalWrite(pinTRIG, LOW);

  delayMicroseconds(2);

  digitalWrite(pinTRIG, HIGH);

  delayMicroseconds(10);

  digitalWrite(pinTRIG, LOW);

 

  //Mido la duración del eco del sensor ultrasónico y calculo la distancia

  duracion = pulseIn(pinECCO, HIGH);

  distancia = duracion * 0.034 / 2; //Fórmula para obtener la distancia en cm al obstáculo

  //Muestro en monitor serial la distancia medida por el sensor ultrasónico

  Serial.print("Distancia: ");

  Serial.println(distancia);

  //En la pantalla LCD se imprime lo siguiente:

  lcd.clear();

  lcd.print("Distancia:");

  lcd.setCursor(0, 1);

  lcd.print(distancia);

  lcd.print(" cm");

 

  //Programación del funcionamiento de los LEDs y del buzzer según la distancia que mide el sensor ultrasónico:

  switch(distancia){

    case 31 ... 50: //Si la distancia al obstáculo está dentro del intervalo [21,50] cm, realiza lo siguiente:

      digitalWrite(ledVERDE, LOW);

      digitalWrite(ledAMARILLO, HIGH);  //Enciende el LED amarillo y apaga el resto

      digitalWrite(ledROJO, LOW);

      tone(buzzer, 1600);  //Emite un sonido de 500 Hz durante 500ms. Posteriormente permanece callado 500ms.

      delay(400);

      noTone(buzzer);

      delay(300);

      digitalWrite(ledAMARILLO, LOW);

      delay(10);

      break;    //sale del caso

    case 10 ... 30: //Si la distancia al obstáculo está dentro del intervalo [0,20] cm, realiza lo siguiente:

      digitalWrite(ledVERDE, LOW);

      digitalWrite(ledAMARILLO, LOW);

      digitalWrite(ledROJO, HIGH);  //Enciende el LED rojo y apaga el resto

      tone(buzzer, 1200); //Emite un sonido de 1000 Hz durante 300ms. Posteriormente permanece callado 300ms.

      delay(150);

      noTone(buzzer);

      delay(50);

      digitalWrite(ledROJO, LOW);

      delay(10);

      break;    //sale del caso

    case 0 ... 9:

      digitalWrite(ledVERDE, HIGH);

      digitalWrite(ledAMARILLO, HIGH);

      digitalWrite(ledROJO, HIGH);  //Enciende todos los LED

      tone(buzzer, 800); //Emite un sonido de 1000 Hz durante 300ms. Posteriormente permanece callado 300ms.

      delay(100);

      noTone(buzzer);

      delay(50);

      digitalWrite(ledVERDE, LOW);

      digitalWrite(ledAMARILLO, LOW);

      digitalWrite(ledROJO, LOW);

      delay(5);

      break;  //sale del caso

    default:  /*Si la distancia al obstáculo es mayor que 50 cm, es decir que no es ninguno de

              los dos intervalos anteriores, realiza lo siguiente:*/

      digitalWrite(ledVERDE, HIGH); //Enciende el LED verde y los demás permanecen apagados

      digitalWrite(ledAMARILLO, LOW);

      digitalWrite(ledROJO, LOW);

      noTone(buzzer); //No genera pitido

      break;    //sale del caso

  }

  /*Introduzco una pequeña pausa antes de que se reinicie el bucle.

  De esta manera evito que trabaje a una velocidad excesivamente alta,

  además de que se podrán visualizar las medidas con más calma*/

  delay(100);

  int estado = digitalRead(pingas); //creo una valiable de estado que recoge la señal digital del MQ-2

  if (estado == LOW) {      ////del sesnor MQ-2. Como este trabaja con lógica inversa, el código queda así.

      analogWrite(motor, 200);

  } else {

    analogWrite(motor, 0);

  }

}   // Fin del bucle

Sistema de Frenado

SISTEMA DE FRENADO

DESCRIPCIÓN

El proyecto consiste en la programación de un prototipo de sistema de frenado para vehículos utilizando Arduino UNO y otros componentes descritos más adelante.

El prototipo se basa en un servo que adoptará diferentes posiciones definidas en el código dependiendo de la distancia a la que esté el obstáculo, este dato lo proporcionará un sensor de ultrasonidos. Además se han incorporado estímulos lumínicos (LEDs de colores que brillarán en función de la distancia siguiendo el código de color estandarizado) y auditivos (mediante un zumbador que sonará con mayor frecuencia cuando la distancia al obstáculo sea crítica).

CONTEXTO

4º de ESO tanto en la rama de académicas como de aplicadas.

• Académicas:
• Bloque 1: Electrónica Aplicada.
• Bloque 2: Control y Robótica.
• Aplicadas:
• Bloque 3: Electrónica.
• Bloque 4: Control y Robótica.

ESQUEMA

COMPONENTES

• Arduino UNO
• Protoboard
• Sensor de Ultrasonidos
• Servo
• Buzzer Pasivo
• 3 x LEDs
• LED verde
• LED amarillo
• LED rojo
• 3 x Resistencias 220 Ω
• Cables

IMÁGENES

DESCARGAS

CÓDIGO COMENTADO

PROGRAMA

CREADOR/A

Ester Martín Rodríguez

Asignatura: Innovación Docente en la Especialidad de Tecnología

Máster Universitario en Profesor de Educación Secundaria Obligatoria, Bachillerato, Formación Profesional y Enseñanza de Idiomas (Universidad de Salamanca)

Proyecto Arduino: Tecnología GOL

 

Imagen proyecto terminado

DATOS

Universidad de Salamanca – Master Universitario en Profesor de Educación Secundaria Obligatoria, Bachillerato, Formación Profesional y Enseñanza de Idiomas.

Asignatura: Innovación Docente en la Especialidad de Tecnología.

Curso: 2019/2020

COMPONENTES DEL GRUPO

• Carlos Hernández Calvo
• Daniel Pescador Hernández

CONTEXTO

El siguiente proyecto se puede realizar para alumnos de 4º de la E.S.O. de la asignatura de Tecnología tanto Académicas como Aplicadas.

1. Bloque 1: Tecnologías de la Información y la Comunicación.
2. Bloque 3: Electrónica.
3. Bloque 4: Control y Robótica.

Este proyecto permite implementar un problema de la vida real, como es el caso si el balón ha entrado o no en una portería, con conceptos vistos en la asignatura de Tecnología.

FUNCIONAMIENTO

La tecnología de Gol tiene el siguiente funcionamiento:
En primer lugar, disponemos de 5 sensores de Infrarrojos situados en el larguero de la portería (realizada con una impresora 3D), de manera que puedan detectar si el balón atraviesa la misma. La elección de 5 sensores ha sido debido a la longitud que debían abarcar.

En segundo lugar, vamos a disponer de una pantalla LCD donde se irá reflejando el marcador del partido, además del mensaje de GOL cuando haya entrado la pelota, o de reinicio del mismo cuando sea necesario (mediante un botón pulsador).

Por último, disponemos de servo motor para simular el banderín del asistente de árbitro con un led verde que se encenderá cada vez que haya un gol.

Así pues, cada vez que el balón pase la portería se mostrará el mensaje de GOL por la pantalla LCD, se levantará el banderín y se encenderá la luz LED durante 2 segundos, después de esto la pantalla LCD mostrará el marcador existente. Si se desea reinicializar el partido, se dispone de un botón “switch” para ello.

ESQUEMA DEL CIRCUITO CON FRITZING

 

Para una mejor visualización se especifican 2 de los 5 sensores de Infrarrojos, los cuales irán situados en las entradas analógicas de la A0 a la A4.

 Protoboard

Esquema electrónico

MATERIALES UTILIZADOS 

• Arduino MEGA (también podría usarse Arduino UNO)
• 2 protoboard 
• 1 LED verde
• 1 pulsador
• 5 sensores de Infrarrojos 
• 1 servomotor 
• 1 condensador de 100 µF
• 1 pantalla LCD 
• 1 potenciómetro 10kΩ
• 1 resistencia 220Ω
• 1 resistencia 10kΩ 
• Cables para el montaje de los circuitos

Materiales utilizados para la maqueta:

• Portería diseñada con Tinkercad e impresa en 3D
• Caja de cartón
• Césped artificial
• Chinchetas
• Tapón de corcho
• Palo de Chupa-Chups
• Pegamento
• Cinta adhesiva
• Pintura blanca
• Cartulina

 

CÓDIGO FUENTE

/*
 * PROYECTO OJO DE HALCÓN GOL:
 * MUPES UNIVERSIDAD DE SALAMANCA - Innovación Docente en la Especialidad de Tecnología
 *
 * El siguiente código implementa los pasos necesarios para la detección de 5 sensores de infrarojos en una porteria realizada en Impresión 3D
 * Donde cada vez que el balon consigue pasar dicha portería, se enciende un LED, se mueve un servo con el banderín del linier y muestra en
 * una pantalla LCD el mensaje de GOL y el Marcador correspondiente.
 *
 * Creado en Enero de 2020, por los integrantes del grupo:
 * - Carlos Hernández Calvo
 * - Daniel Pescador Hernández
 *
 * #################################
 */
// Se incluyen las librerias del Servo y el LCD
#include <Servo.h>
#include <LiquidCrystal.h>

Servo myServo;  //creamos el objecto del Servo

//Inicialización de la LCD con cada uno de los PINs
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

const int analogInPin01 = A0;// Pin analogico 1 para la lectura del Fototransistor
const int analogInPin02 = A1;// Pin analogico 2 para la lectura del Fototransistor
const int analogInPin03 = A2;// Pin analogico 3 para la lectura del Fototransistor
const int analogInPin04 = A3;// Pin analogico 4 para la lectura del Fototransistor
const int analogInPin05 = A4;// Pin analogico 5 para la lectura del Fototransistor

const int OutPin = 13;// Pin para el led indicador
const int InPin = 7;  // Pin para el Switch

//Inicialización del valor de los sensores:
int sensorValue01 = 0;
int sensorValue02 = 0;
int sensorValue03 = 0;
int sensorValue04 = 0;
int sensorValue05 = 0;

int varGol = 0;        // Inicializamos la variable de goles a 0
String stringMarcador; //Inicializamos el texto del marcador

//Creación de una variable global para el stado del Switch
int switchstate = 0;

void setup() {
  // Inicializamos la comunicacion serial a 9600 bps:
  Serial.begin(9600);
  //"Attach" del servo al pin 9
  myServo.attach(9);
 
  //Declaración de los pines de Entrada y Salida
  pinMode(InPin, INPUT);
  pinMode(OutPin, OUTPUT);
 
  //Configuración del número de caracteres y columnas del LCD.
  lcd.begin(16, 2);
 
  //Impresión del mensaje inicial en el LCD
  lcd.print("MARCADOR: ");
  //Movemos el cursor a la linea 1 segunda columna
  lcd.setCursor(0, 1);
  stringMarcador += varGol;
  stringMarcador += " - 0";
  lcd.print(stringMarcador);
}

void loop() {

  // Leemos el valor del Switch
  // digitalRead() comprueba si tiene voltage el pin o no
  switchstate = digitalRead(InPin);
 
  //Leemos los pines de entrada y se lo asignamos a las variables
  sensorValue01 = analogRead(analogInPin01); 
  sensorValue02 = analogRead(analogInPin02);
  sensorValue03 = analogRead(analogInPin03);
  sensorValue04 = analogRead(analogInPin04); 
  sensorValue05 = analogRead(analogInPin05);              

  //Reinicio del Partido al pulsar el botón del Switch
   if (switchstate == HIGH) {
    varGol = 0;
    stringMarcador = "";
    //Limpiamos la pantalla antes de poner el nuevo mensaje
    lcd.clear();
    lcd.setCursor(0, 0);
    //Impresión de Primera Línea
    lcd.print("INICIO PARTIDO");
    //Esperamos 1.5 segundos para volver a inicializar el LCD
    delay(1500);
    lcd.clear();
    lcd.setCursor(0, 0);
    lcd.print("MARCADOR: ");
    //Movemos el cursor a la linea 1 segunda columna
    lcd.setCursor(0, 1);
    stringMarcador += varGol;
    stringMarcador += " - 0";
    lcd.print(stringMarcador);
  }
 
  // Si el valor obtenido es menor a 900 entonces detecta el balon (los sensores IR estás configurados para que cuando no destecta ningún obstáculo de valores superiores a 900 hasta 1023)
  if(sensorValue01 < 900 || sensorValue02 < 900 || sensorValue03 < 900 || sensorValue04 < 900 || sensorValue05 < 900)
  {
    Serial.print("GOOOOOL ");
    varGol = varGol + 1; //Se aumenta la variable gol
    stringMarcador = ""; //Ponemos el texto del marcador vacío
    //Se ilumina el led
    digitalWrite(OutPin, HIGH);
    //Movemos el servo 180° para hacer mover el banderín del linier
    myServo.write(179);
    //Limpiamos el LCD para poner el mensaje de GOL
    lcd.clear();
    lcd.setCursor(0, 0);
    lcd.print("GOOOOOL!!!!!!");
    //Esperamos 2 segundos antes de poner el marcador de nuevo
    delay(2000);
    lcd.clear();
    lcd.setCursor(0, 0);
    //Escribimos el número de goles en el marcador
    lcd.print("MARCADOR: ");
    lcd.setCursor(0, 1);
    stringMarcador += varGol;
    stringMarcador += " - 0";
    lcd.print(stringMarcador);
  }
  else
  {
    //Miestras no detecten nada los sensores el Pin estará apagado y el servo no se mueve
    digitalWrite(OutPin, LOW);
    myServo.write(0);
  }

  //Imprimimos los valores de los sensores para hacer comprobaciones en el puerto serie
  Serial.print("sensor1 = " );                      
  Serial.println(sensorValue01);
  Serial.print(" y sensor2 = " );                      
  Serial.println(sensorValue02);   
  Serial.print(" y sensor3 = " );                      
  Serial.println(sensorValue03);
  Serial.print(" y sensor4 = " );                      
  Serial.println(sensorValue04); 
  Serial.print(" y sensor5 = " );                      
  Serial.println(sensorValue05);    

  delay(100);                    
}

GALERÍA DE FOTOGRAFÍAS DEL PROYECTO