Mostrando entradas con la etiqueta educación. Mostrar todas las entradas
Mostrando entradas con la etiqueta educación. Mostrar todas las entradas

domingo, 2 de febrero de 2020

Proyecto Arduino: Tecnología GOL

 

Imagen proyecto terminado

DATOS


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

 









 

viernes, 8 de febrero de 2019

PROYECTO DE UN FARO CON ARDUINO


Imagen del proyecto acabado


COMPONENTES DEL GRUPO

Lidia Sánchez Calvo
Ismael Peña Sánchez
Enrique José Guzmán de la Iglesia

DATOS 

Universidad de Salamanca

Máster de Profesor de Educación Secundaria Obligatoria, Bachillerato, Formación profesional y enseñanza de idiomas. 

  • Especialidad en Tecnología 2018/2019
  • Asignatura: Innovación docente en la especialidad de Tecnología

CONTEXTO

Este proyecto está pensado para ser realizado como proyecto final de la asignatura de Tecnología en Educación Secundaria Obligatoria.

  • Cursos: 4º ESO de Académicas y 4º ESO de Aplicadas
  • Bloques con los que se relaciona: Bloque de electrónica y Bloque de control y robótica

FUNCIONAMIENTO

Este proyecto cuenta con tres partes diferentes:

Una de ellas es el faro que tiene una LDR que captará la luz del sol, si es de noche se encenderá un LED y un servo girará simulando el movimiento del faro. En la función setup durante los primeros cinco segundos, se calibrará la LDR para que los valores máximo y mínimo sean reales y no establecidos por el programador.


Otra parte del proyecto es un sensor de ultrasonidos que va a captar si algún barco está próximo al muelle, si está a una distancia entre 10 y 26 cm un piezoeléctrico emitirá un pitido de forma intermitente, mientras que si la distancia del barco al sensor es menor a 10 el pitido sonará de forma continua.


La última parte que tiene el proyecto es un control de aparcamiento. Este control se ha simulado con tres sensores de ultrasonidos, una pantalla LCD y otro Arduino. Los sensores están conectados al primer Arduino que recibirá la señal de estos y la procesará. Cuando este note que una plaza ha sido ocupada o vaciada mandará una señal al otro Arduino que la procesará y mostrará el cambio en la pantalla LCD sumando uno al número de plazas si alguna ha sido vaciada o restando uno en el caso de que una plaza haya sido ocupada.





Las dos placas están comunicadas por el protocolo de comunicación serie I2C, para ello se han unido los pines analógicos 4 y 5 y las dos tierras. Se ha tenido que utilizar dos Arduinos, porque el primero no tenía suficientes pines digitales para poder conectar todos los sensores y actuadores necesarios.


MÁS FOTOGRAFÍAS DEL PROYECTO










 VÍDEO




ESQUEMA DEL CIRCUITO REALIZADO CON FRITZING





SERVO, LED, LDR Y SENSORES ULTRASONIDOS



PANTALLA LCD

COMUNICACIÓN ENTRE LAS PLACAS


MATERIALES UTILIZADOS

  • Arduino Uno
  • Arduino Duemilanove
  • 2 placas protoboard
  • 1 piezoeléctrico
  • 1 LED amarillo
  • 1 servomotor
  • 1 condensador de 100 µF
  • 4 sensores de ultrasonidos
  • 1 LDR
  • 1 pantalla LCD
  • 2 resistencias 220 Ω
  • 1 resistencia 1 kΩ
  • 1 resistencia 10 kΩ
  • Cables para el montaje de los circuitos
Materiales utilizados para la maqueta:
  • 1 caja de cartón
  • 1 rollo de papel de cocina
  • Parte superior de una botella
  • Pinturas
  • Pegamento
  • Cinta adhesiva
  • Cartulina
  • Goma elástica
CÓDIGO FUENTE

/* PROYECTO FARO */
#include <Servo.h>
#include <pitches.h>
#include <Wire.h>
/*  Ismael Peña Sánchez
 Lidia Sánchez Calvo
 Enrique José Guzmán de la Iglesia
*/

/*En esta primera parte del proyecto se encuentran declarados todos
los pines que se van a utilizar, las variables auxiliares y un objeto
de la clase Servo que va a controlar el servo que simulará el faro.*/
Servo faro;
const int pinLED = 2;
const int pinZumbador = 7;
int sensorluz = A0;
int valorsensor = 0;
int sensorLow = 1023;
int sensorHigh = 0;
int angulo = 0;
boolean flag = true;

unsigned long pulso;
long distancia;

unsigned long pulso_1;
long distancia_1;
unsigned long pulso_2;
long distancia_2;
unsigned long pulso_3;
long distancia_3;

boolean flag_1 = true, flag_2 = true, flag_3 = true;

int trig = 8;
int echo = 9;

int plaza_1 = 3;
int plaza_2 = 5;
int plaza_3 = 11;
int trig_plaza1 = 4;
int trig_plaza2 = 10;
int trig_plaza3 = 12;

void setup() {
  //Utilizando la clase Wire se dice que se van a utilizar dos
  //arduinos conectados de forma común
  Wire.begin();
  
  //El servo va a estar situado en el pin número 6
  faro.attach(6);
  //Se incia el puerto serie
  Serial.begin(9600);
  //Se pone como pines de salida el LED que simulará la luz del faro
  pinMode(pinLED, OUTPUT);
  //y el zumbador que simulará la alarma
  pinMode(pinZumbador, OUTPUT);

  //A continuación, se han declarado los pines que se utilizarán 
  //en los sensores de ultrasonidos, poniendo el pin trig como salida
  //y el pin echo como entrada
  pinMode(trig, OUTPUT);
  pinMode(echo, INPUT);
  pinMode(trig_plaza1, OUTPUT);
  pinMode(plaza_1, INPUT);
  pinMode(trig_plaza2, OUTPUT);
  pinMode(plaza_2, INPUT);
  pinMode(trig_plaza3, OUTPUT);
  pinMode(plaza_3, INPUT);
  
  //Durante 5 segundos se va a calibrar la LDR
  while (millis() < 5000) {
    valorsensor = analogRead(A0);
    if (valorsensor > sensorHigh) {
      sensorHigh = valorsensor;
    }
    if (valorsensor < sensorLow) {
      sensorLow = valorsensor;
    }
  }
  
}


void loop() {
  //Con la llamada a esta función se controlorá si el motor
  //girará o no y si el LED estará encendido o no
  controlFaro();
  //Con esta función se va a gestionar la alarma del faro
  alarmaFaro();
  controlFaro();
  //Llamando a esta última función se controlorá el número de
  //plazas que quedan libres en el puerto
  plazas();
 
}


void controlFaro(){
  //Al comienzo se lee la LDR que indica si es de día o de noche
  valorsensor = analogRead(sensorluz);
  //Una vez leído el valor lo escribimos en el puerto serie
  Serial.print("LDR: ");
  Serial.println(valorsensor);
  
  //Si el valor del sensor es menor de 500, se supone que es de noche
  if(valorsensor<=500) {
 /*Este if se utiliza para saber si el motor tiene que girar
    a la izquierda o a la derecha
    Mientras que el motor no llegue a los 180 grados, este irá
    sumando grados hasta llegar al máximo.
    Cuando llegue el flag se pone a false, para que empiece a girar
    en el otro sentido*/
    if(flag){
      angulo += 2;
      if(angulo == 180) flag = false;
    }
    else{
      angulo -= 2;
      if(angulo == 0) flag = true;
    }
 /*Una vez que se ha calculado el ángulo del motor, se le pasará
    a este para que se sitúe en esa posición*/
    faro.write(angulo);
 //Se enciende el LED
    digitalWrite(pinLED, HIGH);
 //Se hace una pequeña pausa para que el motor puede girar de forma correcta
    delay(30);
  }
  //Si es de día, la luz tiene que estar apagada
  else digitalWrite(pinLED, LOW);
}


void alarmaFaro(){
  //Lo primero que se hace es lanzar un pulso desde el sensor de ultrasonidos
  //Para ello, se activa el trigger, se espera 10 microsegundos y se desactiva
  digitalWrite(trig, HIGH);
  delayMicroseconds(10);
  digitalWrite(trig, LOW);
  //A continuación, con la función pulseIn se mide el pulso de salida en microsegundos
  pulso = pulseIn(echo, HIGH); 
  //Con esta función, transformamos los microsegundos en centimetros
  /*La velocidad del sonido a 20º es de 340m/s
  29 microsegundos por cm
  la señal va y vuelve por la misma distancia
  por lo tanto, la distancia a la que se encuentra el objeto es la mitad de la distancia recorrida*/
  distancia = pulso/29/2;

  //Si la distancia está entre 26 y 10 suena un pitido de forma intermitente para avisar
  //a la gente que hay un barco cerca
  if (distancia<=26 && distancia>10){
    tone(pinZumbador, NOTE_D6, 500);
    delay(600);
  }
  //Si la distancia es menor de 10, el pitido suene de forma continua
  else if (distancia <10)  {
    tone(pinZumbador, NOTE_D6, 500);}
  
  //Finalmente, se imprime la distancia en el puerto serie
  Serial.print("Distancia puerto: ");
  Serial.println(distancia);

}


void plazas(){
  //Cada plaza de aparcamiento tiene un sensor de ultrasonidos diferente
  //El proceso para calcular la distancia es el mismo que en la función anterior
  digitalWrite(trig_plaza1, HIGH);
  delayMicroseconds(10);
  digitalWrite(trig_plaza1, LOW);
  pulso_1 = pulseIn(plaza_1, HIGH); 
  distancia_1 = pulso_1/29/2;
  
  digitalWrite(trig_plaza2, HIGH);
  delayMicroseconds(10);
  digitalWrite(trig_plaza2, LOW);
  pulso_2 = pulseIn(plaza_2, HIGH); 
  distancia_2 = pulso_2/29/2;
  
  digitalWrite(trig_plaza3, HIGH);
  delayMicroseconds(10);
  digitalWrite(trig_plaza3, LOW);
  pulso_3 = pulseIn(plaza_3, HIGH); 
  distancia_3 = pulso_3/29/2;
 
  //Una vez calculadas, se muestran en el puerto serie
  Serial.print("Distancia 1: ");
  Serial.println(distancia_1);
  Serial.print("Distancia 2: ");
  Serial.println(distancia_2);
  Serial.print("Distancia 3: ");
  Serial.println(distancia_3);
  
  //Si la distancia del sensor 1 es menor de 5, quiere decir que hay un
  //barco dentro de esa plaza
  if(distancia_1<5){
 //Se utiliza un flag para mandar la señal al otro arduino solo cuando cambie de estado
    //Si no se utilizara ningún flag, cada vez que se hiciera una nueva lectura con un
    //barco en el muelle se indicaría al otro arduino que hay una plaza menos
    if(flag_1){
  //Para comenzar la transmisión, se indica al número de arduino que se va a transmitir
        Wire.beginTransmission(8); 
  //A continuación se envia la información, en este caso un 1 para indicar que tiene 
        que restar una plaza
        Wire.write(1);  
  //Finalmente, se termina la transmisión       
        Wire.endTransmission();    
  //El flag utilizado se tiene que poner a false para que no vuelva a entrar aquí hasta 
que se haya ido el barco
        flag_1=false;
    }
  }
  //Si la distancia del sensor es mayor que 5, quiere decir que no hay un barco en este muelle
  else {
 //Si el flag está desactivado quiere decir que el barco se acaba de ir y se puede mandar
    //al otro arduino la información
    if(!flag_1){
  //La transmisión de información es igual que en el caso anterior
        //a excepción de que se transmite un cero en lugar de un uno
        //Un cero quiere decir que una plaza se ha quedado vacía
        Wire.beginTransmission(8); 
        Wire.write(0);             
        Wire.endTransmission();    
  //El flag que controla este muelle se pone a true para indicar que el muelle 
se ha quedado vacío
        flag_1=true;
    }
  }

  //El control de los otros muelles se realiza de la misma forma que en el muelle uno.
  if(distancia_2<5){
    if(flag_2){
        Wire.beginTransmission(8); 
        Wire.write(1);  
        Wire.endTransmission(); 
        flag_2=false;
    }
  }
  else {
    if(!flag_2){
        Wire.beginTransmission(8);
        Wire.write(0);            
        Wire.endTransmission();   
        flag_2=true;
    }
  }


  if(distancia_3<5){
    if(flag_3){
        Wire.beginTransmission(8);
        Wire.write(1);            
        Wire.endTransmission();   
        flag_3=false;
    }
  }
  else {
    if(!flag_3){
        Wire.beginTransmission(8);
        Wire.write(0);            
        Wire.endTransmission();   
        flag_3=true;
    }
  }
}
Código Pantalla LCD
#include <LiquidCrystal.h>
#include <Wire.h>

/*  Ismael Peña Sánchez
 Lidia Sánchez Calvo
 Enrique José Guzmán de la Iglesia
*/

//Al principio se declara un objeto de la clase LiquidCrystal con los pines que se van a utilizar
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
int i=0;
//Esta variable sirve para guardar el número de plazas que hay en el muelle
int numPlazas = 3;

void setup() {
  //Se comienza indicando el número identificativo que va a tener este arduino
  Wire.begin(8);
  //Se inicia el puerto serie
  Serial.begin(9600);
  //Con esta línea se indica que función va a gestionar las excepciones que reciba
  Wire.onReceive(receiveEvent);
  //Una vez registrado el evento, se inicia la pantalla LCD con 16 columnas y 2 filas
  lcd.begin(16, 2);
  //A continuación, se pone en la pantalla el mensaje Bienvenido en la primera línea
  lcd.print("Bienvenido");
  //En la segunda fila se pone el mensaje Plazas: y el número de plazas que hay disponibles
  //para ello se introduce el contenido de la variable numPlazas
  lcd.setCursor(0, 1);
  lcd.print("Plazas: ");
  lcd.setCursor(8, 1);
  lcd.print(numPlazas);
}



void loop() {
  //En este arduino la función loop no va a hacer nada
}

void receiveEvent(int howMany) {
  //Para comenzar se sitúa el cursor en el lugar donde está el número de plazas libres
  lcd.setCursor(8, 1);
  //En la variable x se guarda el número que ha mandado el otro arduino
  int x = Wire.read(); 
  //A continuación, se escribe el valor en el puerto serie
  Serial.println(x);   
  //Si es un cero, quiere decir que ha quedado una plaza vacía y se suma uno al número de plazas
  if(x==0){
    numPlazas++;
  }
  //Si es un 1, quiere decir que ha quedado una plaza menos, por lo que hay que restar uno a las plazas
  else{
    numPlazas--;
  }
  //Finalmente, se imprime el número de plazas en el pantalla y en el puerto serie
  Serial.println(numPlazas);
  lcd.print(numPlazas);
}

Imagen de Pixabay