jueves, 14 de mayo de 2015

Majarduino: Reto 2. Ultrasonidos

Reto 2


Ultrasonidos

  1. Comprender funcionamiento de los sensores de ultrasonidos y darles aplicación
  2. La detección
    • Mostrar por puerto serie como varia la distancia de obstáculos delante del sensor
    • Mostrar como se acerca o aleja un objeto del sensor en un conjunto de 5 leds de tal forma que si está muy lejos el objeto todos los leds estén apagados y a medida que se acerca el objeto se van encendiendo progresivamente.
    • Marcar la proximidad de un objeto con el pitido de un zumbador.
Materiales

  • Arduino 1
  • Protoboard
  • Sensor de ultrasonidos (HC-SR04) x 1
  • Leds de color al gusto x 5
  • Mazo de diferentes cables
  • domingo, 19 de abril de 2015

    Controlar la posición de un servo con un potenciómetro

    Vamos a controlar la posición de un Servo moviendo un potenciómetro o resistencia variable.

    Utilizamos para el Servo el PIN 9 que es de tipo PWM pero al usar la librería Servo.h en un Arduino UNO lo que hace esta librería es deshabilitar la capacidad PWM del PIN 9 y 10. Por este, motivo podríamos usar cualquier PIN digital para controlar el servo ya que el trabajo duro lo hace la librería, que usa pulsos para según la frecuencia y duración indicar al relé a que ángulo debe ir.

    El proyecto se puede ver en el siguiente enlace:





    
    

    El código está obtenido del siguiente enlace: http://www.arduino.cc/en/Tutorial/Knob

    Majarduino: Reto 1. SEÑAL PWM Y LED RGB

    #Majarduino

    Reto 1: SEÑAL PWM Y LED RGB

    • OBJETIVO
      1. COMPRENDER FUNCIONAMIENTO DE LA SEÑAL PWM
      2. SERVOMOTORES
        1. CONTROLAR ÁNGULO DE GIRO DE UN SERVOMOTOR (ENTRE 0 Y 170)
        2. CONTROLAR SENTIDO DE GIRO Y VELOCIDAD DE UN SERVOMOTOR DE ROTACIÓN CONTINUA
      3. LEDS RGB (COLORINES !!!!)
        1. CONTROLAR LA TONALIDAD DE UN LED RGB DE ÁNODO O CÁTODO COMÚN  CON 3 POTENCIÓMETROS (ROJO, VERDE Y AZUL)
    • MATERIAL DE UTILIDAD
      1. ARDUINO 1
      2. PROTOBOARD
      3. SERVOMOTORES
        1. MINISERVO
        2. SERVO DE ROTACIÓN CONTÍNUA
      4. LEDS RGB (COLORINES !!!!)
        1. LED RGB
        2. 3 POTENCIÓMETROS

    Encender una lámpara con un Arduino y un relé

    Vamos a utilizar un relé para encender una lámpara con un Arduino UNO. El relé es el más sencillo y económico que podemos encontrar. Se trata de una unidad que trabaja con 220 V y hasta 10 A. Se puede adquirir en eBay por menos de 3 €.




    También existen relés múltiples, por ejemplo, disponemos de uno de cuatro unidades de 10 A.






    • GND → NEGRO → NEGATIVO → Tierra o masa
    • Vcc → ROJO → POSITIVO → +5v (aquí van lo 5 voltios del Arduino)
    • IN1 → Entrada de CONTROL del Relé 1 → AMARILLO → Al PIN de control del Arduino
    • IN2 → Entrada de CONTROL del Relé 2
    • IN3 → Entrada de CONTROL del Relé 3
    • IN4 → Entrada de CONTROL del Relé 4


    En Arduino UNO el led interno de la placa que ya lleva resistencia de protección está asociado al PIN 13. Si conectamos un led externo al PIN 13 no será necesaria la resistencia de protección.
    En el código del probrama Blink que viene como ejemplo básico en el IDE de Arduino se utiliza el PIN que está asociado a ese led interno. Este es el motivo por el que hemos conectado el cable amarillo que va al PIN de control del relé al PIN 13 de nuestro Arduino UNO.


    sábado, 28 de marzo de 2015

    Because we can

    Me ha hecho mucha gracia el vídeo que se muestra a continuación, porque me he sentido muy identificado. Una de las ideas que tenía justamente es encender una lampara con Arduino de la misma forma que se muestra en el vídeo.

    domingo, 22 de marzo de 2015

    Encender rápidamente una serie de LEDs con un potenciómetro

    Al girar el potenciómetro encendemos una serie de LEDs de forma acumulada. En esta ocasión podemos mover rápidamente la rueda del potenciómetro.

    Un potenciómetro o resistencia variable nos permite disponer de valores analógicos entre 0 y 1023, en total son 1024 valores que podemos asociar a una entrada analógica como A0 y luego con condicionales establecer en el código las acciones que necesitamos. En este caso encenderemos una serie de LEDs de forma secuencial.

    Ahora podemos mover rápidamente el potenciómetro y conseguiremos que se enciendan siempre no solo el LED que toque sino todos los anteriores. Esto se logra dando la instrucción en el código de que se enciendan todos los previos. Y el proceso análogo al apagarlos.

    El proyecto se puede ver en el siguiente enlace:



    int i;
    int j;
    int pinPotenciometro = A0;
    int valorPotenciometro = 0;
    
    void setup()
     {
      pinMode(pinPotenciometro, INPUT);
      for (i = 0; i < 14; i++)
      pinMode(i, OUTPUT);
      Serial.begin(9600);
     }
    
    void loop()
     {
      valorPotenciometro = analogRead(pinPotenciometro);
      for (i = 0; i < 14; i++)
       {
        if (valorPotenciometro == 0) apagarLeds();
        if (valorPotenciometro > i*73 && valorPotenciometro <= (i+1)*73) encenderHasta(); //en este rango está el LED que toca encender
        if (valorPotenciometro == 1023) encenderLeds();
       }
     }
    
    void encenderHasta()
     {
      for (j = 0; j < 14; j++) 
       if (j<=i) digitalWrite(j, HIGH); //se enciende el LED que toca (el i-esimo) y todos los anteriores
       else digitalWrite(j, LOW);       //el resto se apagan
     }
    
    void apagarLeds()
     {
      for (i = 0; i < 14; i++)
       digitalWrite(i, LOW);
     }
    
    void encenderLeds()
     {
      for (i = 0; i < 14; i++)
       digitalWrite(i, HIGH);
     }
    

    Encender uno a uno una serie de LEDs con un potenciómetro

    Al girar el potenciómetro encendemos uno a uno una serie de LEDs y luego los apagamos. Solo hay uno encendido salvo en los extremos del potenciómetro.

    Encendemos uno a uno 14 LEDs usando un potenciómetro, salvo en los extremos de la rueda del potenciómetro donde en un extremo apagamos todos y en contrario encendemos todos.

    Podemos ver el proyecto en el siguiente enlace:



    int i;
    int j;
    int pinPotenciometro = A0;
    int valorPotenciometro = 0;
    int tocaLed; //este es el LED que toca encender en cada momento
    
    void setup()
     {
      pinMode(pinPotenciometro, INPUT);
      for (i = 0; i < 14; i++)
      pinMode(i, OUTPUT);
      Serial.begin(9600);
     }
    
    void loop()
     {
      valorPotenciometro = analogRead(pinPotenciometro);
      for (i = 0; i < 14; i++)
       {
        if (valorPotenciometro == 0) apagarLeds();
        if (valorPotenciometro > i*73 && valorPotenciometro <= (i+1)*73)  //en este rango está el LED que toca encender
         {
          tocaLed = i;
          for (j=0; j<14; j++) //creamos otro bucle para encender el LED que toca y apagar el resto
            {
             if (j==tocaLed) digitalWrite(j, HIGH);
             else digitalWrite(j, LOW);
            }
         }
        if (valorPotenciometro == 1023) encenderLeds();
       }
     }
    
    void apagarLeds()
     {
      for (i = 0; i < 14; i++)
       digitalWrite(i, LOW);
     }
    
    void encenderLeds()
     {
      for (i = 0; i < 14; i++)
       digitalWrite(i, HIGH);
     }

    sábado, 21 de marzo de 2015

    Encender lentamente una serie de LEDs con un potenciómetro

    Vamos a ver cómo actúa un potenciómetro al ir encendiendo una serie de LEDs y luego al ir apagándolos.

    En este caso se trata de girar la rueda del potenciómetro o resistencia variable para conseguir que se vayan encendiendo los 14 LEDs, de forma que al encenderse uno de ellos queden encendidos los anteriores. Podemos girar la rueda hasta su posición final que es cuando todos quedan encendidos, y luego podemos ir girando en sentido contrario de forma que se irán apagando los LEDs hasta que al volver a la posición original todos quedarán apagados.

    Disponemos de un voltímetro para ir mirando las lecturas que nos proporciona la resistencia variable.

    Puedes ver el proyecto en el siguiente enlace:



    int i = 0;
    int pinPotenciometro =A0;
    int valorPotenciometro = 0;
    
    void setup()
     {
      pinMode(pinPotenciometro, INPUT);
      for (i = 0; i < 14; i++)
      pinMode(i, OUTPUT);
      Serial.begin(9600);
     }
    
    void loop()
     {
      valorPotenciometro = analogRead(pinPotenciometro);
      //Las dos siguientes líneas de código se ponen si deseamos ver los valores por el monitor serial
      //Serial.println(valorPotenciometro, DEC);
      //delay(100);
      for (i = 0; i < 14; i++)
       {
        if (valorPotenciometro == 0) apagarLeds();
        if (valorPotenciometro > i*73 && valorPotenciometro < (i+1)*73) digitalWrite(i, HIGH);
        if (valorPotenciometro > (i-1)*73 && valorPotenciometro < i*73) digitalWrite(i, LOW);
        if (valorPotenciometro == 1023) encenderLeds();
      }
     }
    
    void apagarLeds()
     {
      for (i = 0; i < 14; i++)
       digitalWrite(i, LOW);
     }
    
    void encenderLeds()
     {
      for (i = 0; i < 14; i++)
       digitalWrite(i, HIGH);
     }
    

    Potenciómetro y LED

    Introducimos un potenciómetro o resistencia variable que proporcionará valores analógicos a la placa Arduino entre 0 y 1023. Esto es, existen 1024 valores analógicos que se recogen en la entrada A0 del Arduino.

    El código analiza esos valores y lo que hace es que al inicio del recorrido del potenciómetro el LED está apagado, en el recorrido intermedio del potenciómetro el LED se enciende de forma intermitente y en su recorrido final el LED queda encendido de forma continua.

    En términos aproximados estos son los intervalos según el voltímetro que se adjunta.
    • de 0V a 1.4V el LED está apagado
    • de 1.5V a 3.4V el LED está encendido de forma intermitente
    • de 3.5V a 5V el LED está encendido de forma continua

    Hemos añadido un voltímetro para ir viendo los valores que arroja entre 0V y 5V al ir girando el potenciómetro.

    Se puede ver el proyecto en el siguiente enlace:




    int valorPotenciometro = 0;
    void setup()
    {
    pinMode(A0, INPUT);
    pinMode(13, OUTPUT);
    Serial.begin(9600);
    }
    void loop()
    {
    valorPotenciometro = analogRead(A0);
    //delay(100);
    if (valorPotenciometro < 300) digitalWrite(13, LOW);
    if (valorPotenciometro >= 300 && valorPotenciometro < 700) intermitencia();
    if (valorPotenciometro >= 700) digitalWrite(13, HIGH);
    }
    void intermitencia()
    {
    digitalWrite(13, HIGH);   
      delay(200);             
      digitalWrite(13, LOW);  
      delay(200);             
    }
    

    En una entrada posterior vamos a controlar una serie de LEDs con un potenciómetro, para que se vayan encendiendo de forma secuencial.

    viernes, 13 de marzo de 2015

    Apagar un LED mientras esté apretado un botón

    En la entrada anterior de este blog hemos visto el caso denominado Encender un LED mientras esté apretado un botón.

    Para este caso hemos respetado el código íntegramente y el circuito únicamente cambia en dos puntos que están marcados en la siguiente imagen mediante un circulo de color azul que rodea la resistencia y uno de los cables, que son los dos únicos que cambian.

    Este es el proyecto:



    /*
     El LED está asociado al pin digital 12.
     El botón está asociado al pin digital 2.
     El LED está permanentemente encendido
     sólo se apaga al presional el pulsador
     */
    
    // Variables estáticas
    int pinBoton = 2;   // Declaramos la variable pin del Botón
    int pinLed =  12;   // Declaramos la variable pin del Led
    
    // Variables dinámicas
    int estadoBoton = 0;  // Variable para estado del botón
    
    void setup() {
    // Inicializa el pin del LED como salida:
    pinMode(pinLed, OUTPUT);
    // Inicializa el pin del botón como entrada:
    pinMode(pinBoton, INPUT);
    }
    
    void loop(){
    // Lee el valor del pin del botón y lo almacena
    // en la variable estadoBoton
    estadoBoton = digitalRead(pinBoton);
    
    // Chequea si el botón está pulsado:
    if (estadoBoton == HIGH) {
    // Si es así, enciende el LED:
    digitalWrite(pinLed, HIGH);
    }
    
    else {
    // Si no, lo mantiene apagado:
    digitalWrite(pinLed, LOW);
    }
    }
    

    También podríamos sustituir el código del proyecto anterior por el siguiente código y funcionaría perfectamente.

    int estado;
    void setup(){
      pinMode(12,OUTPUT);
      pinMode(2,INPUT);
    }
    void loop(){
      estado = digitalRead(2);
      digitalWrite(12,estado);
      delay(50);
    }
    

    Encender un LED mientras esté apretado un botón

    Puedes ver el proyecto en el siguiente enlace:



    /*
     El LED se conecta al pin digital 12.
     El botón está conectado al pin digital 2.
     Al pulsar el botón se enciende el LED
    */
    
    // Variables estáticas
    int pinBoton = 2;   // Declaramos la variable Botón
    int pinLed =  12;   // Declaramos la variable Led
    
    // Variables dinámicas
    int estadoBoton = 0;  // Variable para estado del botón
    
    void setup() {
    // Inicializa el pin del LED como salida:
    pinMode(pinLed, OUTPUT);
    // Inicializa el pin del botón como entrada:
    pinMode(pinBoton, INPUT);
    }
    
    void loop(){
    // Lee el valor del pin del botón y lo almacena
    // en la variable estadoBoton
    estadoBoton = digitalRead(pinBoton);
    
    // Chequea si el botón está pulsado:
    if (estadoBoton == HIGH) {
    // Si es así, enciende el LED:
    digitalWrite(pinLed, HIGH);
    }
    
    else {
    // Si no, lo mantiene apagado:
    digitalWrite(pinLed, LOW);
    }
    }
    

    También puedes verse otro proyecto donde se consigue el mismo resultado pero con código mucho más corto. Es el siguiente proyecto:



    int estado;
    void setup(){
      pinMode(2,OUTPUT);
      pinMode(8,INPUT);
    }
    void loop(){
      estado = digitalRead(8);
      digitalWrite(2,estado);
      delay(50);
    }
    

    jueves, 12 de marzo de 2015

    Encender y apagar un LED presionando un botón

    El LED lleva su resistencia para que no se queme y el botón lleva también una resistencia pero es para hacer una derivación a masa (tierra o GND).

    Usamos dos pines digitales, el 8 para leer el botón y el 2 para actuar sobre el LED.

    Necesitamos:
    • Placa Arduino
    • LED
    • Botón pulsador de 4 patillas
    • una resistencia de 100 Ohm para el LED
    • una resistencia de 10KOhm para la derivación a tierra del botón

    Al pulsar el botón el LED se enciende y permanece encendido hasta que se vuelve a presionar el botón.

    Puedes ver el proyecto en el siguiente enlace:


    const int pinLed = 2;             //El pin del LED
    const int pinBtn = 8;             // El pin del botón
    
    int encender = 0;                 // Si está encendido el LED
    int anterior = 0;                 // Pulsación anterior
    int estado = 0;                   //El estado actual del botón
    
    void setup()
    {
      pinMode(pinLed, OUTPUT);         // Ponemos el pin del LED como salida
      pinMode(pinBtn, INPUT);          // Ponemos el pin del botón como entrada
    }
    
    void loop()
    {
      estado = digitalRead(pinBtn);    //Comprobamos el estado
    
      if (estado && anterior == 0)     // Comprobamos si el anterior era sin pulsar y el estado actual es pulsado
      {
        encender = 1 - encender;       // Asignamos el estado contrario
        delay(30);                     // Anti-rebote
      }
      anterior = estado;                // Guardamos el estado actual para posteriores comprobaciones
    
      if(encender)                     // Si encender es 1
        digitalWrite(pinLed, HIGH);    // Endendemos el LED
      else                             // Si no
        digitalWrite(pinLed, LOW);     // Apagamos el LED
    }
    


    martes, 10 de marzo de 2015

    LEDs con encendido aleatorio

    Vamos a usar la función RANDOM() para generar números aleatorios que nos digan que LED toca encender cada vez.

    Puedes ver el proyecto en el siguiente enlace:


    int timer=300;
    int cont = 13;              //tenemos 13 LEDs
    
    void setup(){
     for (int pin=1; pin<=cont; pin++){
      pinMode (pin, OUTPUT);
     }
     randomSeed(analogRead(0));  //para generar una nueva semilla
    }
              
    void loop () {
     int rnd=random(14);        // ponemos hasta 14 ya que nunca se llega a 14
     digitalWrite (rnd, HIGH);
     delay (timer);
     digitalWrite (rnd, LOW);
     delay (timer);
    }
    

    La línea siguiente se añade para elegir una nueva semilla para la serie de números pseudo-aleatorios:

    randomSeed(analogRead(0));
    


    Lo que hace es una llamada al pin analógico cero para escuchar el ruido blanco del sistema y usarlo como semilla. Equivale a barajar un mazo de cartas. El problema es que si esto lo probamos en el simulador no hay ruido blanco y por tanto la secuencia de encendido de los LEDs se repite siempre siguiendo la misma serie de números pseudo-aleatorios.

    También se podría generar una nueva semilla usando la expresión siguiente:

    randomSeed(millis());  // genera una semilla para aleatorio a partir de la función millis()
    

    LEDs secuenciales sucesivos

    Veamos el encendido y apagado secuencial de 13 LEDs sin el uso de matrices (ARRAY), simplemente usando un FOR para hacer la secuencia correlativa.

    El proyecto se puede ver en el siguiente enlace:


    En esta ocasión no hemos utilizado una matriz para indicar los pines utilizados, ya que usamos todos (del uno al trece), por lo que simplemente usamos un FOR que recorre todos ellos. Se encienden y apagan de forma secuencial y correltiva.

    // LEDs en secuencia correlativa de encendido y apagado
    int timer=100;
    int cont = 13;
    
    void setup(){
     for (int pin=1; pin<=cont; pin++){
      pinMode (pin, OUTPUT);
     }
    }
              
    void loop () {
     for (int pin=1; pin<=cont; pin++)
     {
      digitalWrite (pin, HIGH);
      delay (timer);
      digitalWrite (pin, LOW);
     }
    
     for (int pin=cont; pin>=0; pin--)
     {
      digitalWrite (pin, HIGH);
      delay (timer);
      digitalWrite (pin, LOW);
     }
    }
    

    Botón pulsador

    Vamos a estudiar el comportamiento de un botón de 4 patillas. El típico será uno de 6*6*5 mm.


    Estos pulsadores actúan como interruptores cuando los cables están "cruzados". Para ver esto hemos planteado un ejemplo sin el uso de ninguna placa Arduino. Usamos simplemente una pila.

    El proyecto se puede ver en el siguiente enlace:


    No existe código asociado al montaje ya que no usamos una placa Arduino.

    lunes, 9 de marzo de 2015

    Serie de LEDs con encendido secuencial

    Vamos a encender y apagar secuencialmente un conjunto de LEDs y efectuaremos el viaje de ida y vuelta.

    Puedes verlo en el siguiente enlace:


    int timer=100;                        //establecemos el tiempo de espera en milisegundos
    int cont = 5;                         //indica que usamos 5 LEDs y por tanto 5 pines digitales
    int matriz[5] = {5, 7, 9, 11, 13};    //la matriz contiene los cinco pines digitales usados y su orden
    
    void setup(){
     for (int pin=0; pin < cont; pin++){     //recorremos los 5 pines
      pinMode (matriz [pin], OUTPUT);     //establecemos la salida de cada pin
     }
    }
              
    void loop () {
     for (int pin=0; pin < cont; pin++)     //recorremos los 5 pines
     {
      digitalWrite (matriz [pin], HIGH);  //encendemos el LED que toca
      delay (timer);                      //el LED permanece encendido el tiempo indicado en la variable timer
      digitalWrite (matriz [pin], LOW);   //transcurrido el tiempo de espera se apaga el LED
     }
    
     for (int pin=cont-1;pin>=0; pin --)  //recorremos los 5 pines pero ahora en sentido contrario
     {
      digitalWrite (matriz [pin], HIGH);  //encendemos el LED que toca
      delay (timer);                      //el LED permanece encendido el tiempo indicado en la variable timer
      digitalWrite (matriz [pin], LOW);   //transcurrido el tiempo de espera se apaga el LED
     }
    }

    Majarduino: Reto 0. Analógico y digital

    #Majarduino




    Reto 0 

    Comprender funcionamiento de entradas salidas analógica y digitales 


    1. Pulsadores y leds


    • Al pulsar un botón encender un led. 
    • Ampliación: utilizar 2 botones para apagar 2 leds que están siempre encendidos. 


    2. Potenciómetro 


    • Encender 1 Led cuando hemos girado mas de la mitad del potenciómetro. 
    • Dividir el ángulo de giro del potenciómetro para encender 5 leds diferentes dependiendo de la posición del potenciómetro.



    Hola Mundo con Arduino

    Hemos comenzado un proyecto vital: aprender a manejar una placa de Arduino y con ello algo de electrónica, robótica y programación. Con el apoyo y el entusiasmo de MajadaLab en un taller de Arduino donde nos orienta Jompy cuando tenemos dudas. Y algunos somos realmente novatos, y tenemos que preguntarle por la polaridad de un LED.

    En este blog pretendemos ir dejando constancia de nuestros progresos a lo largo del tiempo. Ilusión tenemos mucha, a ver hasta donde llegamos. Y como la velocidad se demuestra andando vamos con el primer proyecto con Arduino. Es el típico "Hola Mundo" para aprender a manejarnos con las conexiones, los componentes y la programación.

    Usando este simulador tinkercad.com hemos creado nuestro primer circuito con Arduino.

    Lo hemos titulado Hola Mundo con Arduino.


    La resistencia de 220 ohm se usa para conectar un led a las salidas digitales. Si se usa el pin 13 no necesita resistencia ya que internamente ya la lleva puesto que es la que tiene conectado un pequeño led en la placa.

     // primer montaje con Arduino  
     // objetivo: conseguir encender y apagar un LED de forma intermitente  
     int Pin = 12;        // hacemos que la variable Pin tome el valor del pin 12 u otro pin digital elegido   
     void setup() {  
      pinMode(Pin, OUTPUT);   //inicializamos el pin de la variable Pin como de salida  
     }  
     void loop() {        // loop hace que se repita indefinidamente  
      digitalWrite(Pin, HIGH);  // hacemos que el LED se encienda (HIGH es el nivel de voltaje)  
      delay(1000);        // esperamos 1000 milisegundos  
      digitalWrite(Pin, LOW);  // apagamos el LED haciendo el nivel de voltaje LOW  
      delay(1000);        // esperamos un segundo  
     }