Arduino

Esta página va dedicada a todos los proyectos que haré en clase con Arduino, como propiamente dice el título.

Todos los materiales que utilizaremos esta actividad son:
  • Por supuesto el programa Arduino instalado en el equipo y la placa de Arduino UNO, que será con la que trabajaremos.
  • Cable USB para conectar Arduino a la torre del equipo.
  • Resistencias de 220 y 1k ohmios.
  • Una placa protoboard que nos servirá para conectar ahí los LEDS, resistencias, pulsadores...
  • Cables que conectarán la board con Arduino.
  • LEDS.
  • Pulsadores.
  • 1 servo
  • 1 LDR
Related image   Image result for arduino uno
        Arduino (programa)                        Arduino UNO (placa)                

Image result for cable usb arduino
 Related image
Cable USB                                              Resistencias
 Related image    Related image
Placa protoboard                                        Cables
Related image Related image
Pulsadores                                                                 LEDS

Imagen relacionada      Resultado de imagen de ldr
Servo motor                                                       LDR


La estructura básica del programa es la siguiente:
//Zona DECLARACIONES
void setup() {
  // Zona funcion SETUP
}
void loop() {
  // Zona funcion LOOP
}

Les muestro a continuación todos proyectos que haremos, estos los iré publicando a medida que los vayamos realizando:

  1. LED que parpadea con un tiempo establecido de encendido y de apagado.
  2. Secuencia de 3 LEDS.
  3. LED que está encendido si un botón está pulsado.
  4. Botón como interruptor.
  5. Juego: Duelo de reflejos.
  6. Semáforo.
  7. Cuenta atrás
  8. Sensor

  Primera práctica

El primer circuito que hemos hecho en clase es hacer que un LED se encienda y se apague eligiendo nosotros el tiempo que estará encendido y el tiempo que estará apagado.


El código es el siguiente:
const int pinLED= 13;          //asignar variable led como 13
void setup() {              
  pinMode(pinLED, OUTPUT);      //definir pin 13 como salida
}
void loop() {
  digitalWrite(pinLED, HIGH);      // encender LED
  delay(1000);                             // esperar un segundo
  digitalWrite(pinLED, LOW);     // apagar LED
  delay(1000);                          // esperar un segundo
}



Segunda práctica

En esta hemos colocado 3 LEDS y hemos hecho que se enciendan y se apaguen siguiendo una secuencia. En mi caso he hecho esta secuencia:
  1. El primer LED (en mi caso verde, por eso le he puesto una "v" en el código, para identificarlo) se enciende durante 10 segundos, y posteriormente se apagua a la vez que la amarilla se enciende y se apaga 5 veces, durando 0,5 segundos encendida y otros 0,5 segundos apagada. Y por último la roja se encenderá dos veces 5 y 4 segundos.
Image result for arduino 3 leds

El código es el siguiente:
void setup() {
  pinMode(PINVERDE,OUTPUT);
  pinMode(PINAMARILLO,OUTPUT);
  pinMode(PINROJO,OUTPUT);
}
void loop() {
  digitalWrite(PINVERDE,HIGH);
  delay(10000);
  digitalWrite(PINVERDE,LOW);
  digitalWrite(PINAMARILLO,HIGH);
  delay(5000);
  digitalWrite(PINAMARILLO,LOW);
  digitalWrite(PINAMARILLO,HIGH);
  delay(5000);
  digitalWrite(PINAMARILLO,LOW);
  digitalWrite(PINAMARILLO,HIGH);
  delay(5000);
  digitalWrite(PINAMARILLO,LOW);
  digitalWrite(PINAMARILLO,HIGH);
  delay(5000);
  digitalWrite(PINAMARILLO,LOW);
  digitalWrite(PINAMARILLO,HIGH);
  delay(5000);
  digitalWrite(PINAMARILLO,LOW);

  digitalWrite(PINROJO,HIGH);
  delay(5000);
  digitalWrite(PINROJO,LOW);
  digitalWrite(PINROJO,HIGH);
  delay(5000);
  digitalWrite(PINROJO,LOW);
  digitalWrite(PINROJO,HIGH);
  delay(4000);
  digitalWrite(PINROJO,LOW);
}

Tercera práctica

En esta práctica y las próximas nos serviremos del libro Arduino intro, que hemos obtenido en la página eductic.wikispaces.com y mediante esta podemos guiarnos para aprender más.
Esta vez hemos hecho un circuito en el que hemos introducido un pulsador, el cual mientras esté pulsado un LED se mantendrá encendido. Para ello necesitamos una nueva resistencia de 1k ohmios como se muestra en la imagen:



El código es el siguiente:
void setup() {
  pinMode(4,INPUT);
  pinMode(3,OUTPUT);
}
void loop() {
  int botoncito = digitalRead(4);
  if (botoncito == 1) {
    digitalWrite(3,HIGH);
  }
  if (botoncito == 0) {
    digitalWrite (3,LOW);
  }
}

Cuarta práctica

Esta vez haré funcionar un circuito que consiste, básicamente, en lo que es un interruptor y una bombilla: Cuando alguien presione el botón la luz se encenderá, y quedará encendida hasta que el botón vuelva a ser presionado.



El código es el siguiente:
// Práctica encender LED con botón pulsador y luego apagar LED con el mismo
//boton pulsador
const int LED =13;
const int BOTON = 7;
int val = 0; //val se emplea para almacenar el estado del boton
int state = 0; // 0 LED apagado, mientras que 1 encendido
int old_val = 0; // almacena el antiguo valor de val
void setup(){  // definir si la variable es de entrada // o salida.
 pinMode(LED,OUTPUT); // establecer que el pin digital es una señal de salida
 pinMode(BOTON,INPUT); // y BOTON como señal de entrada
}
void loop() {       // loop = realice un lazo continuamente
val= digitalRead(BOTON); // lee el estado del Boton
if ((val == HIGH) && (old_val == LOW)){
state=1-state;
delay(10);
}
old_val = val; // valor del antiguo estado
if (state==1){
 digitalWrite(LED, HIGH); // enciende el LED
}
else{
 digitalWrite(LED,LOW); // apagar el LED
}
}

Quinta práctica

Esta vez también nos servimos del libro Arduino intro, y esta vez vamos a hacer una práctica llamada: el duelo de reflejos, que consiste, básicamente en crear un juego para 2 jugadores donde el LED de color verde se encenderá indicando el inicio del juego y posteriormente y de forma aleatoria se apagará indicando la salida. Cuando este se apaga los jugadores deben ser lo más rápidos posibles en pulsar su botón, quien lo pulse antes hará que su LED quede encendido y, por tanto, ganará.

El código es el siguiente:
#define PIN_LED_1 11
#define PIN_BOTON_1 12
#define PIN_LED_2 2
#define PIN_BOTON_2 3
#define PIN_SALIDA 7 
byte game_over;


void setup() {

  pinMode(PIN_LED_1, OUTPUT);
   pinMode(PIN_BOTON_1, INPUT);
   pinMode(PIN_LED_2, OUTPUT);
   pinMode(PIN_BOTON_2, INPUT);
   pinMode(PIN_SALIDA, OUTPUT);

   game_over = 0;
   digitalWrite(PIN_LED_1, LOW);
   digitalWrite(PIN_LED_2, LOW);
   digitalWrite(PIN_SALIDA, HIGH);
   delay(random(10000));
   digitalWrite(PIN_SALIDA, LOW);
   
}

// the loop function runs over and over again forever
void loop() {

byte boton_1 = digitalRead(PIN_BOTON_1);
byte boton_2 = digitalRead(PIN_BOTON_2);
if ((boton_1 == 1) && (game_over == 0)){
  digitalWrite(PIN_LED_1, HIGH);
  game_over = 1;
}
if ((boton_2 == 1) && (game_over == 0)){
  digitalWrite(PIN_LED_2, HIGH);
  game_over = 1;
}
  delay(10);
}

Sextapráctica

Esta vez voy a hacer un semáforo con ayuda de 3 LEDS de colores (rojo, verde y amarillo).
Voy a hacer que el verde se encienda durante 7 segundos, posteriormente el amarillo durante 2 segundos y por último, el rojo durante 8 segundos. Esto será una sucesión y se repetirá continuamente (verde, amarillo, rojo, verde, amarillo...)

(Pines donde conecto los LEDS: el verde al 3, el amarillo al 7 y el rojo al 10)


El código es el siguiente:
void setup() {
  pinMode(PINVERDE,OUTPUT);
  pinMode(PINAMARILLO,OUTPUT);
  pinMode(PINROJO,OUTPUT);
}
void loop() {
  digitalWrite(PINVERDE,HIGH);
  delay(7000);
  digitalWrite(PINVERDE,LOW);
  digitalWrite(PINAMARILLO,HIGH);
  delay(2000);
  digitalWrite(PINAMARILLO,LOW);
  digitalWrite(PINROJO,HIGH);
  delay(8000);
  digitalWrite(PINROJO,LOW);
}


Séptima práctica

Es esta realizaremos una cuenta atrás desde 9 hasta 0, y volverá a repetirse una y otra vez.
Imagen relacionada

El código es el siguiente:
#define Pin_a 3
     #define Pin_b 4
     #define Pin_c 7
     #define Pin_d 6
     #define Pin_e 5
     #define Pin_f 2
     #define Pin_g 1

   void setup()
  {
    pinMode(Pin_a,OUTPUT);
    pinMode(Pin_b,OUTPUT);
    pinMode(Pin_c,OUTPUT);
    pinMode(Pin_d,OUTPUT);
    pinMode(Pin_e,OUTPUT);
    pinMode(Pin_f,OUTPUT);
    pinMode(Pin_g,OUTPUT);

   }

 void loop()
{
  nueve();
  delay(1000);
  ocho();
  delay(1000);
  siete();
  delay(1000);
  seis();
  delay(1000);
  cinco();
  delay(1000);
  cuatro();
  delay(1000);
  tres();
  delay(1000);
  dos();
  delay(1000);
  uno();
  delay(1000);
  cero();
  delay(1000);
 }

   void cero()
  {
    digitalWrite(Pin_a,LOW);
    digitalWrite(Pin_b,LOW);
    digitalWrite(Pin_c,LOW);
    digitalWrite(Pin_d,LOW);
    digitalWrite(Pin_e,LOW);
    digitalWrite(Pin_f,LOW);
    digitalWrite(Pin_g,HIGH);
  }

   void uno ()
  {
    digitalWrite(Pin_a,HIGH);
    digitalWrite(Pin_b,LOW);
    digitalWrite(Pin_c,LOW);
    digitalWrite(Pin_d,HIGH);
    digitalWrite(Pin_e,HIGH);
    digitalWrite(Pin_f,HIGH);
    digitalWrite(Pin_g,HIGH);
  }

   void dos()
  {
    digitalWrite(Pin_a,LOW);
    digitalWrite(Pin_b,LOW);
    digitalWrite(Pin_c,HIGH);
    digitalWrite(Pin_d,LOW);
    digitalWrite(Pin_e,LOW);
    digitalWrite(Pin_f,HIGH);
    digitalWrite(Pin_g,LOW);
  }

    void tres()
  {
    digitalWrite(Pin_a,LOW);
    digitalWrite(Pin_b,LOW);
    digitalWrite(Pin_c,LOW);
    digitalWrite(Pin_d,LOW);
    digitalWrite(Pin_e,HIGH);
    digitalWrite(Pin_f,HIGH);
    digitalWrite(Pin_g,LOW);
  }

    void cuatro()
  {
    digitalWrite(Pin_a,HIGH);
    digitalWrite(Pin_b,LOW);
    digitalWrite(Pin_c,LOW);
    digitalWrite(Pin_d,HIGH);
    digitalWrite(Pin_e,HIGH);
    digitalWrite(Pin_f,LOW);
    digitalWrite(Pin_g,LOW);
  }

    void cinco()
  {
    digitalWrite(Pin_a,LOW);
    digitalWrite(Pin_b,HIGH);
    digitalWrite(Pin_c,LOW);
    digitalWrite(Pin_d,LOW);
    digitalWrite(Pin_e,HIGH);
    digitalWrite(Pin_f,LOW);
    digitalWrite(Pin_g,LOW);
  }

    void seis()
  {
    digitalWrite(Pin_a,LOW);
    digitalWrite(Pin_b,HIGH);
    digitalWrite(Pin_c,LOW);
    digitalWrite(Pin_d,LOW);
    digitalWrite(Pin_e,LOW);
    digitalWrite(Pin_f,LOW);
    digitalWrite(Pin_g,LOW);
  }

    void siete()
  {
    digitalWrite(Pin_a,LOW);
    digitalWrite(Pin_b,LOW);
    digitalWrite(Pin_c,LOW);
    digitalWrite(Pin_d,HIGH);
    digitalWrite(Pin_e,HIGH);
    digitalWrite(Pin_f,HIGH);
    digitalWrite(Pin_g,HIGH);
  }

    void ocho()
  {
    digitalWrite(Pin_a,LOW);
    digitalWrite(Pin_b,LOW);
    digitalWrite(Pin_c,LOW);
    digitalWrite(Pin_d,LOW);
    digitalWrite(Pin_e,LOW);
    digitalWrite(Pin_f,LOW);
    digitalWrite(Pin_g,LOW);
  }

    void nueve()
  {
    digitalWrite(Pin_a,LOW);
    digitalWrite(Pin_b,LOW);
    digitalWrite(Pin_c,LOW);
    digitalWrite(Pin_d,HIGH);
    digitalWrite(Pin_e,HIGH);
    digitalWrite(Pin_f,LOW);
    digitalWrite(Pin_g,LOW);

   }

Octava práctica

En esta introduciremos un sensor, y lo que haremos consistirá en leer el valor proporcionado por la LDR.



El código es el siguiente:
void setup() {
  Serial.begin(9600);
  pinMode(A0,INPUT);
}
void loop() {
  int luz = analogRead(A0);
  Serial.print("Lectura : ");
  Serial.print(luz);
  Serial.print(
  Serial
  delay(500);
}


Novena práctica

En esta ocasión voy a utilizar un servo, el cual hace la función de un motor, en mi ejemplo voy a hacer que de media vuelta en 1,5 segundos y otra media vuelta, en sentido, contrario en 2 segundos. Y esto se repetirá continuamente.



El código es el siguiente:
#include <Servo.h>

Servo myservo;  // create servo object to control a servo
// twelve servo objects can be created on most boards

int pos = 0;    // variable to store the servo position

void setup() {
  myservo.attach(9);  // attaches the servo on pin 9 to the servo object
}

void loop() {
  for (pos = 0; pos <= 180; pos += 1) { // goes from 0 degrees to 180 degrees
    // in steps of 1 degree
    myservo.write(pos);              // tell servo to go to position in variable 'pos'
    delay(15);                       // waits 15ms for the servo to reach the position
  }
  for (pos = 180; pos >= 0; pos -= 1) { // goes from 180 degrees to 0 degrees
    myservo.write(pos);              // tell servo to go to position in variable 'pos'
    delay(20);                       // waits 15ms for the servo to reach the position
  }

}

No hay comentarios:

Publicar un comentario

Suscribirse a: Entradas (Atom)