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.

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:

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

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:

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

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);
 }

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:

• Encender lentamente una serie de LEDs con un potenciómetro

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:

• Potenciómetro y LED

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.

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:

• Apagar un LED mientras esté apretado un botón

/*
 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:

• Encender un LED mientras esté apretado un botón

/*
 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:

• LED encendido solo cuando el pulsador está presionado

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

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:

• Encender y apagar un LED presionando un botón

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
}

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:

• Serie de LEDs con encendido aleatorio

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:

• LEDs secuenciales sucesivos

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:

• Botón pulsador

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

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:

• Serie de LEDs con encendido secuencial

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  
 }