miércoles, 26 de enero de 2022

JUEGO DE SUMAS

 DATOS

Alumno: C. David Téllez de Meneses Martín

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

Titulación: 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: 2021/2022


DESCRIPCIÓN DEL PROYECTO

El proyecto busca trabajar contenidos transversales, en este caso, las competencias matemáticas. El programa genera operaciones de suma de manera aleatoria con números de dos dígitos. Se podría adaptar el código para realizar otro tipo de operaciones o sumas con números dentro de otros límites de cifras. El programa guarda la entrada del mando inalámbrico en una variable "result" y espera que el usuario mande el resultado con la tecla de PLAY/PAUSE. Una vez se envía el resultado final, comprueba si es correcto o no; si es correcto iluminará el led verde y si es incorrecto sonará un zumbido que nos indicará el error. 

Si necesitásemos borrar, podremos hacerlo mediante la tecla de "FAST BACK". Una vez modificado el resultado, podemos enviarlo cuando consideremos que el resultado es el correcto. 

El usuario es el que decide cuando ha terminado la actividad, aunque se podría limitar el número de operaciones, cuando quiera finalizarla solo tendrá que pulsar el botón de ON/OFF. Una vez finalizada la actividad se mostrará el número de aciertos conseguidos y los segundos que ha durado la actividad.

Entradas: potenciómetro para regular el brillo de la pantalla LCD y mando inalámbrico junto con receptor infrarrojo.

Salidas: pantalla LCD, Led verde y buzzer activo.

ODS

El proyecto atiende además de forma trasnversal la ODS Nº4 correspondiente a una Educación de Calidad.


VIDEO


COMPONENTES
  • Pantalla LCD
  • Placa Protoboard
  • LED de color verde
  • Resistencia 220 Ohmios
  • Potenciómetro
  • Cables
  • Sensor infrarrojo
  • Mando inalámbrico
  • Buzzer activo

CÓDIGO

#include <LiquidCrystal.h>
#include "IRremote.h"

#define BUZZER_ACTIVO 4

int receiver = 13;
int resultAnterior=0;
int result=0; 
int greenLed=5;
int flag=0;
int suma;
int aciertos=0;
unsigned long tiempo;
unsigned long segundos;


LiquidCrystal lcd(7, 8, 9, 10, 11, 12);
IRrecv irrecv(receiver);     // create instance of 'irrecv'
decode_results results;      // create instance of 'decode_results'


int translateIR(int resultAnterior){ 
  int result; // takes action based on IR code received
  switch(results.value)
  
  {
  case 0xFFA25D: lcd.clear(); lcd.print("BORRANDO RESULTADO"); result=405; delay(500); lcd.clear(); break;
  case 0xFF02FD: lcd.clear(); lcd.print("ENVIANDO"); result=404; delay(500); lcd.clear(); break;
  case 0xFF22DD: lcd.clear(); resultAnterior=resultAnterior/10; result=resultAnterior; break;
  
  /*case 0xFFE21D: lcd.clear(); Serial.println("FUNC/STOP");  lcd.print("FUNC/STOP"); break;
  case 0xFF629D: lcd.clear(); Serial.println("VOL+"); lcd.print("VOL+"); break;
  case 0xFF22DD: lcd.clear(); Serial.println("FAST BACK");  lcd.print("FAST BACK"); break;
  case 0xFF02FD: lcd.clear(); Serial.println("PAUSE");     lcd.print("PAUSE"); break;
  case 0xFFC23D: lcd.clear(); Serial.println("FAST FORWARD");    lcd.print("FAST FORWARD"); break;
  case 0xFFE01F: lcd.clear(); Serial.println("DOWN");    lcd.print("DOWN"); break;
  case 0xFFA857: lcd.clear(); Serial.println("VOL-");     lcd.print("VOL-"); break;
  case 0xFF906F: lcd.clear(); Serial.println("UP");     lcd.print("UP"); break;
  case 0xFF9867: lcd.clear(); Serial.println("EQ");     lcd.print("EQ"); break;
  case 0xFFB04F: lcd.clear(); Serial.println("ST/REPT");     lcd.print("ST/REPT"); break;*/
  
  case 0xFF6897: lcd.print("0"); if(resultAnterior==0){ result=0; }else {resultAnterior=resultAnterior*10; result=resultAnterior; }break;
  case 0xFF30CF: lcd.print("1"); if(resultAnterior==0){ result=1; }else{resultAnterior=resultAnterior*10+1; result=resultAnterior;} break;
  case 0xFF18E7: lcd.print("2"); if(resultAnterior==0){ result=2; }else {resultAnterior=resultAnterior*10+2; result=resultAnterior; }break;
  case 0xFF7A85: lcd.print("3"); if(resultAnterior==0){ result=3; }else {resultAnterior=resultAnterior*10+3; result=resultAnterior; }break;
  case 0xFF10EF: lcd.print("4"); if(resultAnterior==0){ result=4; }else {resultAnterior=resultAnterior*10+4; result=resultAnterior; }break;
  case 0xFF38C7: lcd.print("5"); if(resultAnterior==0){ result=5; }else {resultAnterior=resultAnterior*10+5; result=resultAnterior; }break;
  case 0xFF5AA5: lcd.print("6"); if(resultAnterior==0){ result=6; }else {resultAnterior=resultAnterior*10+6; result=resultAnterior; }break;
  case 0xFF42BD: lcd.print("7"); if(resultAnterior==0){ result=7; }else {resultAnterior=resultAnterior*10+7; result=resultAnterior; }break;
  case 0xFF4AB5: lcd.print("8"); if(resultAnterior==0){ result=8; }else {resultAnterior=resultAnterior*10+8; result=resultAnterior; }break;
  case 0xFF52AD: lcd.print("9"); if(resultAnterior==0){ result=9; }else {resultAnterior=resultAnterior*10+9; result=resultAnterior; }break;
  
  //case 0xFFFFFFFF:  Serial.println(" REPEAT"); lcd.print("REPEAT"); break;

  }
  
  delay(500); 
  return result;
  
}

int generarSuma(){
  int x=random(0,100);
  int y=random(0,100);
  Serial.print("Suma: "); 
  Serial.print(x);
  Serial.print(" + ");
  Serial.print(y);
  Serial.println();
  
  lcd.setCursor(0,0);
  lcd.print("Suma: "); 
  lcd.print(x);
  lcd.print(" + ");
  lcd.print(y);
  int suma=x+y;
  
  return suma;
}


void setup() {
  
  lcd.begin(16, 2);
  Serial.begin(9600);
  Serial.println("IR Receiver Button Decode"); 
  irrecv.enableIRIn();
  result=0; resultAnterior=0;
  
  pinMode (BUZZER_ACTIVO, OUTPUT);
}

void loop() { 
  
  tiempo=millis();
  segundos=tiempo/1000;
  lcd.setCursor(0, 1);
  
  int operacion=1;
  if(flag==0){ suma=generarSuma(); result=0; resultAnterior=0; }
  flag=1;
  
  if (irrecv.decode(&results)) 
  {
    
    result=translateIR(resultAnterior);
    if(result!=404) resultAnterior=result;
    
    if(result==404)
    
      if(suma==resultAnterior){
        
        aciertos++;
        lcd.print("CORRECTO");
        digitalWrite(greenLed, HIGH);
        delay(2500);
        digitalWrite(greenLed, LOW);
        
      }else{
        
        lcd.print("MAL");
        digitalWrite(BUZZER_ACTIVO, HIGH);
        delay(500);
        digitalWrite(BUZZER_ACTIVO, LOW);
      }
      
    suma=generarSuma();
    result=0; resultAnterior=0;
    
    }else if(result==405){
      
      lcd.print("ACIERTOS: ");
      lcd.setCursor(10, 0);
      lcd.print(aciertos);
      
      lcd.setCursor(0,1);
      lcd.print("TIEMPO: ");
      lcd.setCursor(8, 1);
      lcd.print(segundos);
      delay(10000);
      
      lcd.clear();
      
    }else {
      
      lcd.setCursor(0,1);
      lcd.print(result);
    }
    
    irrecv.resume();
  }

}

SEMÁFORO CON CONTROL DE TRÁFICO

 DATOS

Alumno: Manuel Jiménez González

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

Titulación: 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: 2021/2022

DESCRIPCIÓN DEL PROYECTO

El objetivo de este proyecto es diseñar un sistema automátizado que controle un semáforo situado en una intersección por medio de la placa Arduino que podría servir como actividad en el bloque didáctico de Control y Robótica de la asignatura de Tecnología en 3º de la ESO.

El sistema cuenta con dos entradas (pulsador para el paso de peatones y un fotorresistor situado a 50m de la intersección, que se active cuando un coche estacione sobre el) y tres salida correspondientes a tres LEDs, uno para cada luz del semáforo (rojo, ámbar y verde).

El sistema está preparado para dar respuesta a tres posibles situaciones como se explicará en el siguiente vídeo.

Vídeo:




Componentes:



- Arduino Elegoo One.
- Protoboard.
- Diodo LED rojo.
- Diodo LED amarillo.
- Diodo LED verde.
- 10 Cables de diferentes longitudes.
- 3 Resistencias de 220 Ohmios.
- 2 Resistencias de 10 KOhmios.
- 1 Pulsador.
- 1 Fotorresistor.

Código:

// Semáforo sencillo en Arduino
int tiempoEspera = 5000;

// variable to hold sensor value
int sensor;

const int ledRojo = 10;
const int ledAmarillo = 9;
const int ledVerde = 8;
int switchstate = 0;

void setup(){
  Serial.begin(9600);
  pinMode(ledRojo, OUTPUT);    // Rojo
  pinMode(ledAmarillo, OUTPUT);     // Amarillo
  pinMode(ledVerde, OUTPUT);     // Verde
}
void loop() { 

  sensor = analogRead(A0);
  switchstate = digitalRead(2);
  if (switchstate == HIGH){
    digitalWrite(ledRojo, HIGH);     // rojo encendido
  }
  else{
    digitalWrite(ledRojo, LOW);     // rojo encendido
    if (sensor <400){
      digitalWrite(ledVerde, HIGH);      // verde encendido
      digitalWrite(ledRojo, LOW);     // rojo encendido
      digitalWrite(ledAmarillo, LOW);       // amarillo apagado
      delay(5000);
    }
    else if(sensor>500){
      digitalWrite(ledVerde, LOW);       // verde apagado
      digitalWrite(ledAmarillo, HIGH);       // amarillo apagado
      delay(5000);
      digitalWrite(ledAmarillo, LOW);       // amarillo apagado    
      digitalWrite(ledRojo, HIGH);     // rojo encendido
      delay(5000);
    }
  }
}






PLACA FOTOVOLTAICA CON SEGUIDOR SOLAR Y ALARMA DE MOVIMIENTO.

Datos autor proyecto:

Alumno: Jonatan Villa Cuadrado
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: 2021/2022


Descripción proyecto:


En el proyecto que se va a mostrar a continuación, se puede observar un prototipo simple que imita el comportamiento de las potenciales placas solares a instalar en una planta fotovoltaica. Dichas placas tienen la función de orientarse en función de la dirección desde la cual reciban más cantidad de luz, además de avisar tanto con señales acústicas como visuales de que las placas van a proceder a moverse, evitando así los posibles accidentes laborales de trabajadores u operarios que se encuentren trabajando en la planta solar, mejorando tanto el rendimiento de las placas solares, como la prevención de riesgos laborales.

También se trabajan de forma transversal y se intentan mejorar los siguientes ODS:

Funcionamiento:

En el prototipo que se observará a continuación, se puede ver que está compuesto por tres LDR, los cuales, cada uno tiene una dirección distinta y a través de ellos se mide y compara cual recibe más luz y por lo tanto hacia que dirección deberá girar el servo que mueve la placa solar. Antes de iniciar el giro, se produce una alerta sonora y visual que evitará accidentes laborales. Este funcionamiento se puede observar en el siguiente video.

Video:



Lista de componentes:


Montaje circuito:

A continuación se mostrará el esquema del circuito necesario para realizar este proyecto. Para su realización se ha utilizado la aplicación web de Autodesk, Tinkercad. En primer lugar aparecerá un circuito en donde se pueden observar los componentes con su aspecto real, y seguidamente se mostrará el esquema con la simblogía normalizada.

 


Código:

// Incluimos la biblioteca del servo con la que podemos controlar su velocidad.
#include <VarSpeedServo.h>
VarSpeedServo Servo2;  // Creamos un objeto de servo.
// Pin analogico de entrada para el LDR
int pinLDR1= A0;
int pinLDR2= A1;
int pinLDR3= A2;
// Variable donde se almacena el valor del LDR
int valorLDR1;
int valorLDR2;
int valorLDR3;
// Variable donde se almacena el ángulo del servo motor.
int grados=Servo2.read();
// Variable donde se almacenará el número de bandera.
int bandera;
// Configuración a realizar una sola vez
void setup()
{
  // open a serial connection to your computer
  Serial.begin(9600);
  // attaches the servo on pin 3 to the servo object
  Servo2.attach(9);
  // Configuramos como salidas los pines donde se conectan los led
  pinMode(5, OUTPUT);
  pinMode(6, OUTPUT);
  //
  bandera=0;
}
//
void loop()
{
  // Guardamos el valor leido del ADC en una variable
  // El valor leido por el ADC (voltaje) aumenta de manera directamente proporcional
  // con respecto a la luz percibida por el LDR
  valorLDR1= analogRead(pinLDR1);
  valorLDR2= analogRead(pinLDR2);
  valorLDR3= analogRead(pinLDR3);
 //
 if ((valorLDR1 > valorLDR2) && (valorLDR1 > valorLDR3) && (bandera!=1)){
    digitalWrite(5,HIGH);
    tone(6, 50, 200);
    delay(300);
    digitalWrite(6,LOW);
    tone(6, 50, 200);
    delay(300);
    digitalWrite(6,LOW);
    tone(6, 50, 200);
    delay(2000);
    Servo2.write(135, 30, true);
    digitalWrite(5,LOW);
    digitalWrite(6,LOW);
    delay(1000);
    bandera=1;
 }
 //
 if ((valorLDR1 < valorLDR2) && (valorLDR2 > valorLDR3) && (bandera!=2)){
    digitalWrite(5,HIGH);
    tone(6, 50, 200);
    delay(300);
    digitalWrite(6,LOW);
    tone(6, 50, 200);
    delay(300);
    digitalWrite(6,LOW);
    tone(6, 50, 200);
    delay(2000);
    Servo2.write(90, 30, true);
    digitalWrite(5,LOW);
    digitalWrite(6,LOW);
    delay(1000);
    bandera=2;
 }
 //
 if ((valorLDR1 < valorLDR2) && (valorLDR2 < valorLDR3) && (bandera!=3)){
    digitalWrite(5,HIGH);
    tone(6, 50, 200);
    delay(300);
    digitalWrite(6,LOW);
    tone(6, 50, 200);
    delay(300);
    digitalWrite(6,LOW);
    tone(6, 50, 200);
    delay(2000);
    Servo2.write(45, 30, true);
    digitalWrite(5,LOW);
    digitalWrite(6,LOW);
    delay(1000);
    bandera=3;
 }
}   




martes, 25 de enero de 2022

CONTROL DE TEMPERATURA PARA PANELES SOLARES FOTOVOLTAICOS

Descripción:

El proyecto que se presenta a continuación pretende solucionar problemas de calentaminto en paneles solares de isntalaciones fotovoltaicas mejorando así su rendimiento, producción y vida útil.

El sistema diseñado consta de un sensor de temperatura que recogería los grados a los que se encuentra el panel, los cuales aparecerán en la pantalla LCD implementada en el circuito. Según se ha programado en el código, una vez que se alcance la temperatura fijada de 20ºC, se encenderá un led que nos alertará del exceso de temperatura y se accionará al mismo tiempo un ventilados, con el fin de refrigerar la placa.

Cuando se consiga bajar la temperatura a menos de los 20ºC impuestos, el led se apagará y el ventilado dejará de girar.

Esta actividad está dirigida a alumnos desde 3º de E.S.O. si se les plantea solo su montaje o para cursos superiores como puede ser 1º de Bachiller si se les pide mayor entendiminto del sistema y de la elaboración del código.

Video:


Elementos utilizados para la eleboración del prototipo:




Código:

#include <LiquidCrystal.h>

#define ENABLE 5

#define DIRA 3

#define DIRB 4


int i;

int tempPin = 0;

 

LiquidCrystal lcd(7, 8, 9, 10, 11, 12);

 

void setup()

{

  lcd.begin(16, 2);

   //---set pin direction

  pinMode(ENABLE,OUTPUT);

  pinMode(DIRA,OUTPUT);

  pinMode(DIRB,OUTPUT);

  Serial.begin(9600);

}

void loop()

{

  int tempReading = analogRead(tempPin);

  // This is OK

  double tempK = log(10000.0 * ((1024.0 / tempReading - 1)));

  tempK = 1 / (0.001129148 + (0.000234125 + (0.0000000876741 * tempK * tempK )) * tempK );       //  Temp Kelvin

  float tempC = tempK - 273.15;            // Convert Kelvin to Celcius

  float tempF = (tempC * 9.0)/ 5.0 + 32.0; // Convert Celcius to Fahrenheit

  /*  replaced

    float tempVolts = tempReading * 5.0 / 1024.0;

    float tempC = (tempVolts - 0.5) * 10.0;

    float tempF = tempC * 9.0 / 5.0 + 32.0;

  */

  // Display Temperature in C

  lcd.setCursor(0, 0);

  lcd.print("Temp         C  ");

  lcd.setCursor(6, 0);

  lcd.print(tempC);

 

   if (tempC > 20.0) {

    digitalWrite(2, HIGH); // Encender led si Tª>20º

     

    digitalWrite(ENABLE,HIGH); // Encender motor-ventilador si Tª>20º

    digitalWrite(DIRA,HIGH); //one way

     digitalWrite(DIRB,LOW);

    delay(3000);

  }

  else{

    digitalWrite(ENABLE,LOW); // Apagar motor-ventilador si Tª<20º

     digitalWrite(2,LOW); // Apagar led si Tª<20º

    }

 

   }

ODS:

En este proyecto se quiere destacar la importancia de las ODS y mencionar de manera más detallada las referidas al ahorro energético y a la implantación de instalaciones energéticas con origen de energías limpias como lo es la energía solar. 


Datos:

Alumna: María Hernández Quintas

Estudios superiores en proceso: Master Universitario en Profesor de Educación Secundaria Obligatoria y Bachillerato, Formación Profesional y Enseñanza de Idiomas.

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

Curso: 2021-2022

Centro: Universidad de Salamanca

Barrera de coches para puerta de parking



 Alumno
: Carlos Prieto Herranz

Curso: 2021/2022

Universidad de Salamanca

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

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


Descripción del proyecto

 Este proyecto consiste básicamente en una barrera de un parking, que se abre y se cierra en función de diferentes entradas. Una vez que el coche llega a la puerta del parking, se detecta con un ultrasonidos su presencia, y en ese momento, se sube la barrera poco a poco, para dejarle pasar. Al mismo tiempo, la luz roja empieza a parpadear, signo de que aún no se puede pasar y además existe una señal acústica para reforzarlo. Una vez que la barrera alcanza el punto más alto, el semáforo se pone en verde y la barrera se mantiene abierta, hasta el momento en el que se asegura que el coche ha entrado por completo en el parking. Para poder cerciorarlo, se dispone una ldr en el suelo del parking, que en todo momento se encuentra iluminada por un foco, por lo que una vez que pase el coche por encima, la luminosidad que recibe la ldr, será mucho menor, y en ese momento, la barrera comenzará a bajar al mismo tiempo que el semáforo vuelve a parpadear con luz roja y suena una señal acústica. Este proyecto, podría encuadrarse dentro de la asignatura de Tecnología de 4º ESO.


Entradas: 1 ldr y 1 sensor de ultrasonidos.

Salidas: 2 led (1 roja y 1 verde), 1 servomotor y 1 zumbador.

Otros componentes: Placa de arduino, cables, protoboard y resistencias.

Vídeo explicativo

Esquema  de conexiones con Tinkercad


Código

//Se incluyen las liberías a utilizar

#include "SR04.h"

#include "Servo.h"


//Se introduce el número del pin de cada elemento como variables enteras

int ldr=A0;

int ledroja=4;

int ledverde=2;

int timbre=12;


//Se define la variable luz, que se utilizará en la LDR

int luz;


//La librería del ultrasonidos permite asignar directamente trig y echo a los pines correspondientes

#define TRIG_PIN 9

#define ECHO_PIN 8

//Se obtiene una salida para la entrada de los dos pines del ultrasonidos

SR04 sr04 = SR04(ECHO_PIN,TRIG_PIN);

//Se define la variable a, que será la distancia que detecta el ultrasonidos

long a;


//Con la librería del servo, se define la variable del servo, en este caso motor, y se define también su posición inicial

Servo motor;

int position=45;


//Se inicializa el setup

void setup() {

  

   Serial.begin(9600); //Se conecta la consola

   delay(1000);   //Se retrasa 1 s

   motor.attach(10);  //Con la librería del servo, se conecta al pin correspondiente

   

   //Las variables enteras asignadas previamente se definen como entradas o salidas

   pinMode(ldr,INPUT);

   pinMode(ledroja,OUTPUT);

   pinMode(ledverde,OUTPUT);

   pinMode(timbre,OUTPUT);

   

   //Se establece la posición inicial del motor

   motor.write(position);

   

}  

//Se inicializa el loop, que se repetirá de manera cíclica cuando se cargue a la placa

void loop() {


  //Medida de la distancia del ultrasonidos

   a=sr04.Distance(); //La variable a, será la distancia que mide el ultrasonidos

   Serial.print(a); //Se imprime en la consola la distancia

   Serial.println("cm"); //Se imprime en la consola cm y se pide que se de un salto de línea

    

    //Medida de la luminosidad con la ldr

   luz=analogRead(A0);  //Se guarda en luz, la lectura del ldr

    Serial.println(luz); //Se imprime la lectura del ldr


   //Situación del servo

   Serial.print(position); //Se imprime la posición de la barrera

   Serial.println("grados"); //Se imprime después del número, la palabra "grados"

   

   delay(500); //Se retrasa 0,5 s entre lecturas de posición  

   digitalWrite(ledroja,HIGH); //La luz roja estará activada

   digitalWrite(ledverde,LOW); //La luz verde estará desactivada

   

   if (a<=10){    //Se pone un condicional, si la distancia es menor de 10 cm, detecta la presencia de un coche

    for (position=45; position<135;)  //Se introduce un ciclo for, que va desde 45, que es la posición inicial a la posición final de la barrera

    {

    digitalWrite(ledroja,HIGH); 

    delay(500);

    digitalWrite(ledroja,LOW); //Con estas tres últimas sentencias, se permite que la luz roja parpadee

    tone(timbre,260,2000); //Al mismo tiempo que parpadea la luz, suena un timbre

    delay(500); //Se introduce un retardo de 0,5s

    

    position=position+10; //A la variable posición se le suma en cada vuelta 10 grados

    motor.write(position); //Con la variable position que va cambiando, se permite mover el motor

    delay(50);

    }

    //En este punto, la barrera está ya arriba

    digitalWrite(ledroja,LOW); //La luz roja se apaga

    digitalWrite(ledverde,HIGH); //La luz verde se enciende

    while(luz>150){  //Con un while conseguimos que mientras la luz sea mayor que un valor de 150, no se baje la barrera, dado que el coche aún no ha pasado por encima de la ldr

      luz=analogRead(A0); //Hacemos una lectura de la luminosidad con la ldr

      Serial.println(luz); //Imprimimos el valor en la consola

      delay(10);} //Dejamos un breve tiempo para evitar que el coche pase por encima y no detectemos que se oscurece

      

      //Cuando salimos del while, implica que la luminosidad ha bajado, y que el coche ha pasado por encima, por lo que 

      //hay que bajar la barrera

      delay(2000); //Dejamos 2 s para asegurar que el coche haya pasado completamente

      digitalWrite(ledverde,LOW); //Apagamos la luz verde

    for (position=134; position>45;) //Para el rango de posiciones desde 134 a 45:

    {

    digitalWrite(ledroja,HIGH);

    delay(500);

    digitalWrite(ledroja,LOW); //Volvemos a hacer que la luz roja parpadee

    tone(timbre,260,2000); //Al mismo tiempo hacemos que el timbre suene

    delay(500);

    position=position-10; //En cada vuelta, le restamos 10 grados a la posición    

    motor.write(position); //Movemos el motor a la nueva posición

    Serial.print(position); //Se imprime la posición de la barrera

    Serial.println("grados"); //Se imprime después del número, la palabra "grados"

    delay(50);

    }  

    }

   }

Control de aforo

DATOS

Alumno: Eloy Fernández Benito

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

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

Centro: Universidad de Salamanca


PROYECTO

Actualmente, vivimos en el tiempo del COVID-19, donde día a día sufrimos más o menos restricciones según las olas de contagios. Una de esas restricciones habituales es el control de aforo que todo lugar público debe tener.

El proyecto dispone de dos pulsadores que representan los sensores (de movimiento, de presión, etc) que controla el número de personas que entran y que salen. El Arduino va sumando y restando la gente que entra y sale, quedando este valor visible en la pantalla LCD. Mientras no se llegue al valor máximo, una luz led verde nos indicará que hay libertad de paso para entrar en el local.

Cuando el aforo llega a un valor determinado (en este caso 11 personas), el led verde será sustituido por uno rojo que nos indicará que no se puede entrar en el local hasta que alguien lo abandone, seguido de un mensaje de advertencia de aforo máximo. Tras esto, el servomotor accionará la apertura de las ventanas para ventilar el local mientras el aforo sigua en máximos.

Este control de aforo es de total actualidad y suple uno de los problemas que muchos establecimientos públicos sufren, siendo una solución fácil y barata a los pequeños locales que realizan su control de aforo de forma manual.

Por su poca complejidad (2 entradas y 4 salidas) este puede ser un buen proyecto para el bloque "Proceso de resolución de problemas tecnológicos" de 3º de ESO.

Este proyecto puede relacionarse con el Objetivo de Desarrollo Sostenible 3º, dedicado a la Salud y al Bienestar. Los ODS son iniciativas impulsadas por la ONU para combatir el cambio climático y desigualdades económicas o promover la innovación.

 

COMPONENTES

El proyecto está compuesto por los siguientes componentes:

-                                  -        Arduino Elegoo One.

-        1 Protoboard.

-        25 cables de diferentes longitudes y colores.

-        2 pulsadores.

-        1 led rojo.

-        1 led verde.

-        1 pantalla LCD.

-        1 servomotor.

-        1 potenciómetro.

-        2 resistencias de 220Ω

 

ESQUEMA

A continuación, se presenta el esquema del proyecto con todos sus componentes montados.

 

 

PRESENTACIÓN

El siguiente vídeo muestra el funcionamiento completo del proyecto:



 

PROGRAMACIÓN

A continuación, se presenta la programación del proyecto:



ALARMA DETECTORA DE INTRUSOS

 DATOS 

Alumno: Javier Navarro Arenas

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

Master: 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: 2021/2022.


DESCRIPCIÓN

El proyecto consiste en una alarma que suena (Buzzer) y se enciende (LED) cuando el intruso se acerca a menos de 5 cm, si el intruso se aleja a mas de 5 cm el LED se apaga y el BUZZER deja de sonar. Para calcular la distancia se utilizará un sensor de ultrasonidos.

La pantalla LCD indicará la distancia a la que se encuentra el intruso y si se acerca a menos de 5 cm pondrá "intruso detectado". El circuito también consta de un potenciómetro para regular la pantalla LCD.

El proyecto tiene 2 entradas (Sensor de ultrasonidos y potenciómetro) y 3 salidas (Pantalla LCD, LED y BUZZER).

La ODS que he tratado en este proyecto es Industria, Innovación e Infraestructura.



COMPONENTES UTILIZADOS

  • Placa Arduino UNO
  • Protoboard
  • 1 LED
  • 1 Resistencia de 220 Ω
  • Cables
  • 1 Potenciómetro
  • Pantalla LCD
  • BUZZER
  • Sensor de ultrasonidos
ESQUEMA DEL CIRCUITO













VIDEO




CÓDIGO

// include the library code:
//Libreria de la pantalla LCD
#include <LiquidCrystal.h>

//Librería del sensor de ultrasonidos
#include "SR04.h"

//Definimos pines del sensor de ultrasonidos
#define TRIG_PIN 4  
#define ECHO_PIN 3

#define BUZZER_ACTIVO 2

// incializamos la biblioteca con los pines de la pantalla LCD
LiquidCrystal lcd(7, 8, 9, 10, 11, 12);

//Declaramos la variable del sensor de ultrasonidos
SR04 sr04 = SR04(ECHO_PIN,TRIG_PIN);
long a;

//La variable LED la declaramos en el pin 6
const int LED=6;



void setup() {
  // configuramos el número de filas y columnas de la pantalla LCD
  lcd.begin(16, 2);
  // Imprimimos en la pantalla LCD el mensaje "intruso a".
  lcd.print("Intruso a:");

   Serial.begin(9600);
   delay(1000);

//Dejamos el BUZZER inactivo en un primer momento
   pinMode (BUZZER_ACTIVO, OUTPUT);
}

//Este es el bucle infinito
void loop() {


  // set the cursor to column 0, line 1Ponemos el cursor en columna 0, fila 1
  // (nota: fila 1 es la segunda fila, ya que comienza en 0 el conteo):
  lcd.setCursor(0, 1);
  // print the number of seconds since reset:
   
   a=sr04.Distance();     //Decimos que la variable a sea igual a la distancia del objeto al sensor
   Serial.print(a);           // imprimimos por consola la variable a
   Serial.println("cm");
   delay(1000);              //Delay de 1 segundo para que imprima por consola cada 1 segundo

//Aquí hacemos lo mismo pero para que lo imprima en la pantalla LCD
   lcd.setCursor(0, 1);
   lcd.print("    ");
   lcd.setCursor(0, 1);
   lcd.print(a);
   lcd.print(" cm     ");


//Si la distancia es menor de 5 cm imprime por pantalla intruso detectado, enciende el LED y suena el BUZZER
   if(a<5){
      lcd.begin(16, 2);
      // Print a message to the LCD.
      lcd.print("Intruso detectado  ");

      digitalWrite(LED,HIGH);
  
    digitalWrite(BUZZER_ACTIVO, HIGH);
    delay(500);
    digitalWrite(BUZZER_ACTIVO, LOW);
   }
   else{
    digitalWrite(LED,LOW);
   }

}

PUERTA DE GARAJE

DATOS ALUMNO

Nombre: Laura Valle Santos

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

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

Centro: Universidad de Salamanca

DESCRIPCIÓN

El proyecto a realizar es una puerta de garaje. Trata de un proyecto realizado con el KIT arduino que cuenta con dos entradas y tres tipos de Salidas. 

La puerta se abre mediante el accionamiento del servomotor al tocar del pulsador. Mientras esto sucede, un led rojo se iluminara y en la pantalla saldrá un mensaje para los peatones "abriendo puertas". Una ves abierta la puerta, se iluminará un led verde dando paso a que el coche acceda o salga del garaje. 

Después de ello, se volverá a cerrar la puerta, activándose el led rojo y con el mensaje para los viandantes "cerrando puertas".

COMPONENTES

·          Arduino UNO

·          Protoboard

·          Fotolector

·          Servo

·          3 x LEDs

o   LED verde

o   LED blanco

o   LED rojo

·          4 x Resistencias 

·          1 Potenciometro

·          Cables

VIDEO DESCRIPTIVO







LENGUAJE



#include<Servo.h>
#include <LiquidCrystal.h>
Servo motor;
int switchstate = 0;
int sensorValue;
LiquidCrystal lcd(7, 8, 9, 10, 11, 12);

void setup() { 
         motor.attach(3);
         pinMode(2, INPUT);

         lcd.begin(16, 2);
         lcd.print("Barrera!");
         Serial.begin(9600);
 }

void loop() {
         switchstate = digitalRead(2);
         sensorValue = analogRead(A0);
         Serial.println(sensorValue);
     
if (switchstate == HIGH) {
  
        lcd.setCursor(0, 1);
        lcd.print("abriendo puertas!");
    
        digitalWrite(4,HIGH);
        digitalWrite(5,LOW);
    
    motor.write(9);
    delay (500);
    motor.write(20);
    delay (500);
    motor.write(20);
    delay (500);
    motor.write(30);
    delay (500);
    motor.write(40);
    delay (500);
    motor.write(50);
    delay (500);
    motor.write(60);
    delay (500);
    motor.write(70);
    delay (500);
    motor.write(80);
    delay (500);
    motor.write(90);
    delay (500);
    motor.write(100);
    delay (500);
    motor.write(110);
    delay (500);
    motor.write(120);
    delay (500);
    motor.write(130);
    delay (500);
    
       digitalWrite(4,LOW);
       digitalWrite(5,HIGH);
       delay (5000);
    
      lcd.setCursor(0, 1);
      lcd.print("cerrando puertas!");
    
      digitalWrite(4,HIGH);
      digitalWrite(5,LOW);
    
    motor.write(130);
    delay (500);
    motor.write(120);
    delay (500);
    motor.write(110);
    delay (500);
    motor.write(100);
    delay (500);
    motor.write(90);
    delay (500);
    motor.write(80);
    delay (500);
    motor.write(70);
    delay (500);
    motor.write(60);
    delay (500);
    motor.write(50);
    delay (500);
    motor.write(40);
    delay (500);
    motor.write(30);
    delay (500);
    motor.write(20);
    delay (500);
    motor.write(10);
    delay (500);
    
    
    digitalWrite(4,LOW);
    digitalWrite(5,LOW);
    
    lcd.setCursor(0, 1);
    lcd.print("cuidado puertas!");
    delay(500);
 }

  else 
    
    digitalWrite(4,LOW);
    digitalWrite(5,LOW);
  }

if (sensorValue < 500) {

   digitalWrite(13,HIGH);
}
 else 
  { 
    digitalWrite(13,LOW);
}
 }