IES Santa Eulalia

Carpeta para depositar trabajos de los alumnos de 4º Diversificación del IES Santa Eulalia.

CREACIÓN DE UN PANEL SOLAR PARA ALIMENTAR A NUESTROS ARDUINOS.

 PROYECTO:

Esta práctica hemos realizado la soldadura de placas solares de 0,5v cada una con un tamaño de 15cm x 8cm. Las soldadura de las placas la hemos realizado utilizando unos elementos imprescindibles para este tipo de elementos. Se trata de un rotulador que al pasarle el soldador sobre el hilo nos deja soldadas las placas.
Hemos realizado dos tipos de interconexiones la primera en serie y la segunda en paralelo.
El conectar las placas en serie nos facilita ir aumentando la tensión entre placas con el fin de conseguir la tensión que necesitamos que son los 5v (tensión a la cual trabaja arduino).
Luego al realizar las conexiones en paralelo, mantenemos la tensión de trabajo pero aumentamos la corriente que aportan estas placas.
 
MATERIALES:

-placas solares

- rotulador
-soldador
- cinta de carrocero
- hilo conductor especial
-guantes
- soporte para las placas

 ''FOTOS DEL PROYECTO''











OBSERVACIONES:
Inicialmente tuvimos problemas con las placas son muy frágiles y al principio se nos rompieron algunas
AUTORES:
ALBERTO CABEZAS, PAUL SEGOVIA Y CHRISTIAN SÁNCHEZ.
I.E.S.SANTA EULALIA MÉRIDA (BADAJOZ)

CONTROL DE SENSOR DE LUMINOSIDAD BH1750FVI

 PROYECTO:

Esta práctica hemos realizado el control de un sensor de luminosidad. Este sensor nos permite realizar mediciones del nivel de lumiosidad en el aula, o en cualquier situación que necesitemos controlar el nivel de luz. Nosotros vamos a realizar una utilización práctica de este sensor, que será el utilizarlo como guía para el ver el índice de luz que nos llega a las placas solares.
En cuanto al sensor de luminosidad  bh1750fvi:

Sabemos que nuestro sensor maneja cuatro pines que son: VCC(3,3V), SCL(A5), SDA (A4), ADD(A3) y GND. el pin A3 analógico maneja las señales del sensor.
En relación al display LCD 1602:
Tenemos cuatro pines Vcc (5v), GND y luego SCL(A5), SDA (A4). En este display manejamos el protocolo Ic2, por lo tanto hay que tener especial cuidado a la hora de buscar la librería que nos maneja este protocolo.
Por ello debemos instalarla en el IDE de arduino y borrar la antigua librería Liquid Cristal.
En cuanto al sensor, debemos descargar la librería BH1750FVI que maneja este tipo de sensores.
 
MATERIALES:

-placa de arduino uno

- sensor de luminosidad
-display LCD 1602
- cables de arduino
- placa protoboard

 CÓDIGO:

/*
  This is a simple code to test BH1750FVI Light sensor
  communicate using I2C Protocol
  this library enable 2 slave device address
  Main address  0x23
  secondary address 0x5C
  connect this sensor as following :
  VCC >>> 3.3V
  SDA >>> A4
  SCL >>> A5
  addr >> A3
  Gnd >>>Gnd

   
 */

 // Aquí definimos las librerías que necesitamos :
 #include <BH1750FVI.h> // Sensor Library
 #include <Wire.h> // I2C Library
 #include <LiquidCrystal.h>

 LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
 uint16_t Light_Intensity=0;
 // Call the function

 BH1750FVI LightSensor;
 
void setup() {
  // put your setup code here, to run once:
  Serial.begin(9600);
  lcd.begin(16, 2);

  LightSensor.begin();
  LightSensor.SetAddress(Device_Address_H); //Address 0x5C
  LightSensor.SetMode(Continuous_H_resolution_Mode);
  lcd.setCursor(0, 0);
  lcd.print("BH1750 Sensor");
  lcd.setCursor(1, 1);
  lcd.print("Please wait...");
  delay(3000);
  lcd.clear();

}

 void loop() {
   lcd.clear();
   lcd.setCursor(0, 0);
   lcd.print(" Intensity = ");
   lcd.setCursor(5, 1);
   Light_Intensity = LightSensor.GetLightIntensity();
   lcd.print(Light_Intensity);
   lcd.print(" Lux");
   delay(2000);
  
 
}
 ''FOTOS DEL PROYECTO''


















OBSERVACIONES:
Inicialmente tuvimos problemas con la librería del LCD 1602
AUTORES:
PATRICIA RUIZ CABALLERO Y PABLO MONTERO CABALLERO.
I.E.S.SANTA EULALIA MÉRIDA (BADAJOZ)

CONTROL DEL SENSOR DE HUMEDAD Y TEMPERATURA USANDO EL DISPLAY LCD 1602 PROYECTO:

Esta práctica hemos realizado el control de un sensor de humedad y temperatura. Este sensor nos permite realizar mediciones del nivel de temperatura y humedad.
En cuanto al sensor de humedad y temperatura DTH11:

Sabemos que nuestro sensor maneja tres pines que son: VCC(5V) GND. el pin de salida que nosotros hemos utilizado una de las entradas/salidas digitales de la placa de arduino concretamente la 13.
En relación al display LCD 1602:
Tenemos cuatro pines Vcc (5v), GND y luego SCL(A5), SDA (A4). En este display manejamos el protocolo Ic2, por lo tanto hay que tener especial cuidado a la hora de buscar la librería que nos maneja este protocolo.
Por ello debemos instalarla en el IDE de arduino y borrar la antigua librería Liquid Cristal.
En cuanto al sensor, debemos descargar la librería DTH11I que maneja este tipo de sensores.
 
MATERIALES:

-placa de arduino uno

- sensor de humedad y temperatura.
-display LCD 1602
- cables de arduino
- placa protoboard

 CÓDIGO:
#include <FastIO.h>
#include <I2CIO.h>
#include <LCD.h>
#include <LiquidCrystal.h>
#include <LiquidCrystal_I2C.h>
#include <LiquidCrystal_SR.h>
#include <LiquidCrystal_SR2W.h>
#include <LiquidCrystal_SR3W.h>

#include <DHT.h>



 // Ejemplo de programa para LCD 1602 I2C v.3//

 /* Importamos las bibliotecas necesarias*/
 #include <Wire.h>  // Incluida en el Arduino IDE
 #include <LiquidCrystal_I2C.h>
 #include <DHT.h>

 // Definimos las variables que vamos a utilizar//
 #define DHTPIN 2 //Seleccionamos el pin en el que se //conectará el sensor
 #define DHTTYPE DHT11 //Se selecciona el DHT11 (hay //otros DHT)
 DHT dht(DHTPIN, DHTTYPE); //Se inicia una variable que será usada por Arduino para comunicarse con el sensor


 /* Definimos los objetos */
 // Establecer la dirección de LCD de 0x20 para una pantalla de 20 caracteres 4 líneas
 // Establecer las patas del chip I2C utilizado para las conexiones de LCD:
 //                    addr, en,rw,rs,d4,d5,d6,d7,bl,blpol
 LiquidCrystal_I2C lcd(0x27, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE);  // Set the LCD I2C address  // configura la direccion LCD I2C


 /* Ejecutamos el setup */

 void setup() 
 {
  Serial.begin(9600);  // Se utiliza para introducir caracteres

  lcd.begin(16,2);  // inicializar el LCD con 20 caracteres 4 líneas y encender la luz de fondo
  dht.begin(); //Se inicia el sensor de temperatura
 // --------3 parpadeos rapidos de la luz de fondo---------- //

  for(int i = 0; i< 3; i++)
  {
    lcd.backlight();
    delay(250);
    lcd.noBacklight();
    delay(250);
  }
  lcd.backlight();
 
 // --------- Terminar con luz de fondo encendida ------------ //
 
 //-------- Escribe los caracteres de la pantalla ----------------
 // NOTA: La osición del cursor: (CUADRO, LÍNEA) comenzará con 0
  lcd.setCursor(2,0);
  lcd.print("Hola Chicos!");
  delay(1000);
  lcd.setCursor(1,1);
  lcd.print("Ardueficiencia");
  delay(1000);
  lcd.clear();
 }
 /* Termina el setup*/

 /* Inicializamos el bucle */

 void loop()
 {
  float h = dht.readHumidity(); //Se lee la humedad
  float t = dht.readTemperature(); //Se lee la temperatura
 
  //Se escriben los datos de humedad y temperatura en el LCD
  lcd.setCursor(0,0);
  lcd.write("Humedad: ");
  lcd.setCursor(14,0);
  lcd.print( h);
  lcd.setCursor(0,1);
  lcd.write("Temperatura:");
  lcd.setCursor(14,1);
  lcd.print( t);
  delay(2000); //Se espera 2 segundos para seguir leyendo //datos


 }
 /* Terminamos el bucle */
 ''FOTOS DEL PROYECTO''



















OBSERVACIONES:
Inicialmente tuvimos problemas con la librería del LCD 1602
AUTORES:
ALEXANDRO CASTRO SERRANO Y JAVIER CASTRO DE TORRES.
I.E.S.SANTA EULALIA MÉRIDA (BADAJOZ)

  SENSOR DE PRESENCIA PIR CON MÓDULO DE 8 RELES

 

 PROYECTO:

Esta práctica hemos realizado el control de un sensor de presencia PIR, para ello hemos utilizado también un módulo de relés para conectar la lámpara de 220v.
En la placa de reles hay que tener especial cuidado en la alimentación. Nos encontramos con Vcc que iría a 5v, GND que iría a la patilla de GND de arduino y luego tenemos COM que debemos alimentarla a 5V. Finalmente tenemos cada uno de los pines que nos manejarán los datos del rele que lo llevaremos a una de las entradas/salidas digitales de la placa de arduino UNO.
En cuanto al sensor PIR maneja tres pines, uno sería Vcc que va a 5v, el otro GND y finalmente la salida OUT que la conectamos a uno de los pines que nuestro arduino UNO maneja como entradas o salidas. Concretamente nosotros la hemos puesto en el pin 2.
 
MATERIALES:

-placa de arduino uno
- placa de 8 reles
- sensor PIR
- portalámpara de 220v
- cables de arduino
- placa protoboard
CÓDIGO:




/*

Implementación básica de un sensor PIR;

*/



const int buttonPin=2;

const int ledPin=13;

int buttonState=0;

void setup(){

pinMode(ledPin,OUTPUT);

pinMode(buttonPin,INPUT);

Serial.begin(9600);

}

void loop(){

buttonState=digitalRead(buttonPin);

if(buttonState==HIGH){

digitalWrite(ledPin,HIGH);

}

else{

digitalWrite(ledPin,LOW);

}

Serial.println(buttonState);

delay(500);

}



 ''FOTOS DEL PROYECTO''






OBSERVACIONES:
No hemos tenido ninguna duda.
AUTORES: PALOMA DÍAZ GARCÍA Y BRUNO BECERRA BUET.
I.E.S.SANTA EULALIA MÉRIDA (BADAJOZ)

CONTROL DE UNA LÁMPARA DE 220V MEDIANTE MÓDULO DE 8 RELES

 

 PROYECTO:

Esta práctica consiste en encender y apagar una lámpara de 220 v durante 100 segundos, mediante el programa IDE de arduino, utilizando también una placa de 8 reles, con alimentacion externa de 5 v.
En la placa de reles hay que tener especial cuidado en la alimentación. Nos encontramos con Vcc que iría a 5v, GND que iría a la patilla de GND de arduino y luego tenemos COM que debemos alimentarla a 5V. Finalmente tenemos cada uno de los pines que nos manejarán los datos del rele que lo llevaremos a una de las entradas/salidas digitales de la placa de arduino UNO.
 
MATERIALES:

-placa de arduino uno
- placa de 8 reles
- portalámpara de 220v
- cables de arduino
- placa protoboard
CÓDIGO:



int ledPin=13;
void setup(){
  pinMode(ledPin,OUTPUT);
}
void loop(){
     digitalWrite(ledPin,HIGH);
delay (1000);
    digitalWrite(ledPin,LOW);
  }


 ''FOTOS DEL PROYECTO''





OBSERVACIONES:
No hemos tenido ninguna duda.
AUTORES: PALOMA DÍAZ GARCÍA Y BRUNO BECERRA BUET.
I.E.S.SANTA EULALIA MÉRIDA (BADAJOZ)
    Dispositivos Arduino para la
    Eficiencia Energética
    PRIMER PROYECTO:
    Comenzamos con algo sencillo explicando paso a paso el porqué de cada cosa.
    El primer proyecto que se hace siempre con arduino es el "blik" (parpadeo). También es conocido como el "Hola mundo".
    Básicamente consiste en que dos pulsadores encienda y apaguen un led.
    El código del programa sería el siguiente:
    MATERIALES:
    -         Placa de Arduino
    -         Cable USB de conexión

    CÓDIGO:
    /*Blink.
    Empezamos:
    int buttonPin=2;
    int ledPin=13;
    int estado=0;
    void setup(){
      pinMode(ledPin,OUTPUT);
      pinMode(buttonPin,INPUT);
    }
    void loop(){
      estado=digitalRead(buttonPin);
      if(estado==HIGH){
        digitalWrite(ledPin,HIGH);
      }
      else{
        digitalWrite(ledPin,LOW);
      }
    }

     ''FRITZING''



    OBSERVACIONES:
    No hemos tenido ninguna duda.
    AUTORES: PATRICIA RUIZ CABALLERO Y PABLO MONTERO CABALLERO.
    I.E.S.SANTA EULALIA MÉRIDA (BADAJOZ)



          

    Dispositivos Arduino para la
    Eficiencia Energética
    PRIMER PROYECTO: 
    Comenzamos  con algo sencillo explicando paso a paso el porqué de cada cosa.
    El primer proyecto que se hace siempre con arduino es el "blik"  (parpadeo). También es conocido como el "Hola mundo".
    Básicamente consiste en un diodo led que se enciende y se apaga.
     El código del programa sería el siguiente: 
    MATERIALES:
    -         Placa de Arduino
    -         Cable USB de conexión

    CÓDIGO:
    /*Blink. Consiste en un led que se enciende y se apaga. Lo conectaremos en el pin 13, ya que en este pin no es necesario conectar la resistencia en serie con el  led. El encendido y apagado lo realizaremos con el comanda delay*/
    Esto que acabo de escribir, se puede escribir también en la misma pantalla donde estamos tecleando el código del programa. La regla es comenzar el párrafo  con   /*   y terminarlo con */ 
    Si no necesitamos escribir un párrafo muy largo también podemos utilizar al comienzo de la línea //   Pero en este caso solo sirve para una línea, cada vez que empecemos otra nueva siempre comenzaremos con  //
    Empezamos:

    int ledPin=13;        // Indicamos que utilizaremos el pin 13 como variable y lo identificaremos

                                 // como ledPin, pero podríamos llamarle como quisiéramos.
                                 // Importante la sintaxis. int separado del nombre que queremos darle
                                 // y terminamos con ;
                                 //  int, es una variable. Al colocarla en este punto el programa podrá
                                 // utilizarla en cualquier momento. Se conoce como variable global.

    void setup ()        
    // Inicio del programa. Terminado en paréntesis abierto y cerrado.
                                 // Abrimos llaves. Todo lo que escribamos a continuación estará
                                 // incluido dentro de la llaves.
    {
    pinMode ( ledPin, OUTPUT);  // Declaramos el pin 13, que lo hemos identificado como ledPin
                                                   // como salida. OUTPUT con mayúsculas y
                                                  // entre paréntesis y terminado en ;
    }

    void loop()           // Indicamos que aquí comienza el bucle para que el programa se repita

                                // indefinidamente. Abrimos llaves.
    {
    digitalWrite (ledPin, HIGH);  // Literalmente lo que estamos diciendo es: "escribe un 1 en el 
                                                // ledPin" Es decir, enciende el led que hemos identificado 
                                                // como ledPin.
    delay (1000);                      // Mediante delay lo que hacemos es una parada en el programa,
                                               //ojo, no es un temporizador es provocar una parada en el loop.
                                               //En este caso la parada será de un segundo ya que hemos 
                                               // programado 1000 milisegundos.
    digitalWrite (ledPin, LOW); // En esta ocasión el mensaje es "Escribe un 0 en el ledPin"
                                               // es decir, apaga el led.
    delay (1000);                      // Provocamos otra parada en el loop
    }                                          // Importante, terminar el programa cerrando las llaves
    "Fritzing"                                      
    FOTO:  
         


          
                 
    OBSERVACIONES:
    Es muy importante, no para el funcionamiento del programa, si no para que controlemos lo que hemos escrito, hacer todas, las aclaraciones que consideremos oportunas sobre las diferentes instrucciones. Siempre después de // o abriendo el comentario con  /*  y cerrándolo con */
    Una vez tecleado el código lo validamos, lo guardamos y lo transferimos a la placa Arduino, que previamente hemos conectado al ordenador a través del cable USB

    Si todo va bien tendrá que funcionar, de lo contrario nos dará un mensaje de error en la validación.
    Se pueden modificar los tiempos de encendido y apagado del led, cambiando el tiempo en “delay
    AUTORES : Paloma Díaz y Bruno Becerra



    Dispositivos Arduino para la
    Eficiencia Energética
    PRIMER PROYECTO: (COCHE FANTÁSTICO)

    Esta practica a consistido en una secuencia de LEDs sucesivamente encendiéndose y apagándose secuencialmente

    MATERIALES:
    -1   Placa de Arduino
    -1   Cable USB de conexión
    -7  Leds
    -10 Cables de conexión.

    CÓDIGO:

    Esta a sido la secuencia de luces hecha con arduino:

    void setup () {                          // comienza la configuracion.

    pinMode (5, OUTPUT);            // configuramos el pin 5 como salida 
    pinMode (6, OUTPUT);              //  configuramos el pin 6 como salida 
    pinMode (7, OUTPUT);             //   configuramos el pin 7 como salida     
    pinMode (8, OUTPUT);             //  configuramos el pin 8 como salida                       
    pinMode (9, OUTPUT);           //  configuramos el pin 9 como salida           
    pinMode (10, OUTPUT);           //    configuramos el pin 10 como salida                                 
    pinMode (11, OUTPUT);         //   configuramos el pin 11 como salida          
    }                                                        
     void loop(){                            //comienza el bucle principal del programa                     
                                                           
      digitalWrite (5 , HIGH);            //se enciende el led 5                   
     delay (50);                              //se espera 50 ms                           
      digitalWrite (5 , LOW);       //se apaga el led 5
      digitalWrite (6, HIGH);           //se enciende el led 6                                           
     delay (50);                             //se espera 50 ms                                           
       digitalWrite ( 6 , LOW);        //se apaga el led 6               
       digitalWrite ( 7, HIGH);         //se enciende el led 7                     
      delay(50);                             //se espera 50 ms              
       digitalWrite ( 7, LOW);        //se apaga el led 7                
      digitalWrite (8, HIGH);             //se enciende el led 8                        
      delay(50);                              //se espera 50 ms                          
      digitalWrite (8 , LOW);        //se apaga el led 8                      
      digitalWrite (9, HIGH);           //se enciende el led 9                                  
      delay(50);                                //se espera 50 ms                       
      digitalWrite (9  , LOW);       //se apaga el led 9                               
      digitalWrite (10 , HIGH);            //se enciende el led 10                                           
      delay(50);                                 //se espera 50 ms                                                  
     digitalWrite (10 , LOW);    //se apaga el led 10                      
      digitalWrite (11, HIGH);             //se enciende el led 11                             
      delay(50);                                  //se espera 50 ms                           
      digitalWrite (11, LOW);      //se apaga el led 11                     
      digitalWrite (10 , HIGH);             //se enciende el led 10                                 
      delay(50);                                  //se espera 50 ms                                     
      digitalWrite (10, LOW);          //se apaga el led 10                     
     digitalWrite ( 9 , HIGH);              //se enciende el led 9                                  
      delay(50);                                  //se espera 50 ms                     
      digitalWrite (9 , LOW);            //se apaga el led 9                                  
      digitalWrite ( 8 , HIGH);           //se enciende el led 8                                      
      delay(50);                                  //se espera 50 ms                            
      digitalWrite (8 , LOW);           //se apaga el led 8   
      digitalWrite (7 , HIGH);              //se enciende el led 7                   
      delay(50);                                  //se espera 50 ms                       
      digitalWrite (7, LOW);              //se apaga el led 7                                            
     digitalWrite ( 6, HIGH);             //se enciende el led 6                                            
      delay(50);                                   //se espera 50 ms                     
      digitalWrite (6 , LOW);             //se apaga el led 6                                                   
      digitalWrite ( 5, HIGH);             //se enciende el led 5                                            
      delay(50);                                   //se espera 50 ms                         
      digitalWrite (5  , LOW);         //se apaga el led 5                               
     }  

    "Fritzing"                                      







                              
    OBSERVACIONES:
    Es muy importante, no para el funcionamiento del programa, si no para que controlemos lo que hemos escrito, hacer todas, las aclaraciones que consideremos oportunas sobre las diferentes instrucciones. Siempre después de // o abriendo el comentario con  /*  y cerrándolo con */
    Una vez tecleado el código lo validamos, lo guardamos y lo transferimos a la placa Arduino, que previamente hemos conectado al ordenador a través del cable USB

    Si todo va bien tendrá que funcionar, de lo contrario nos dará un mensaje de error en la validación.
    Se pueden modificar los tiempos de encendido y apagado del led, cambiando el tiempo en “delay
    AUTOR: Javier Castro de Torres y Alexandro Castro Serrano
    IES “SANTA EULAIA”. Merida

    Dispositivos Arduino para la
    Eficiencia Energética
    PRIMER PROYECTO: 
    Comenzamos  con algo sencillo explicando paso a paso el porqué de cada cosa.
    El primer proyecto
    se trata de encender un “LED” pulsando un botón y al volver a pulsar se apague.
     El código del programa sería el siguiente: 
    MATERIALES:
    • Placa de Arduino
    • Cable USB de conexión

    CÓDIGO:
    /*LED Consiste en que se enciende y se apaga con un pulsador. Lo conectaremos en el pin 1 y 2, .*/
    Este que acabo de escribir, se puede escribir también en la misma pantalla donde estamos tecleando el código del programa. La regla es comenzar el párrafo  con   /*   y terminarlo con */ 
    Si no necesitamos escribir un párrafo muy largo también podemos utilizar al comienzo de la línea //   Pero en este caso solo sirve para una línea, cada vez que empecemos otra nueva siempre comenzaremos con  //
    Empezamos:

    int boton=0;
    void setup(){
    pinMode(1,INPUT); // declaramos el pin 1 como entrada.
    pinMode(2,OUTPUT); // declaramos pin 2 como salida.
    }
    void loop(){
    boton=digitalRead(1);
    if(boton=HIGH){
    digitalWrite(2,HIGH); // si esta pulsado enciende el LED.
    }
    else{
    digitalWrite(2,LOW); // sino, se apaga.
    }
    "Fritzing" 




    OBSERVACIONES:
    Es muy importante, no para el funcionamiento del programa, si no para que controlemos lo que hemos escrito, hacer todas, las aclaraciones que consideremos oportunas sobre las diferentes instrucciones.
    AUTOR: Paul Segovia,Christian Sanchez,Alberto Cabezas.


























































































































































































7 comentarios:

  1. Los alumnos de 4ª DIVERSIFICACIÓN, están realizando prácticas con el fin de ir familiarizandose con Arduino. También tienen muchas ganas de comenzar su parte del proyecto.

    ResponderEliminar
  2. Tal como dice nuestro profesor estamos deseando comenzar el proyecto

    ResponderEliminar
  3. Somos el grupo de Alexandro y Javier estamos de acuerdo con mi compañero deseamos empezar el proyecto.

    ResponderEliminar
  4. Al igual que mi compañero Alberto y mis demas compañeros también estoy deseando empezar el proyecto de Arduino

    ResponderEliminar
  5. como dicen mis compañeros estoy deseando empezar el proyecto =)

    ResponderEliminar
  6. Un saludo desde el IES Extremadura, estáis avanzando bastante.

    ResponderEliminar
  7. Enhorabuena a todos los chicos y chicas de 4º Diversificación. Estáis realizando un trabajo estupendo.

    ResponderEliminar