El potenciómetro (IDE Arduino)

La mayor parte de las magnitudes con las que hemos trabajado hasta ahora han sido magnitudes digitales o binarias; es decir, que sólo pueden tener dos estados: 0-1, encendido-apagado, presionado-liberado, cierto-falso. El potenciómetro multivuelta que incluye el Shield suministra, al pin A0 de Arduino, un voltaje comprendido entre 0 y 5 voltios, que podemos modificar girando su cursor y pasar por todos los valores posibles. Se trata de una magnitud analógica que será digitalizada por Arduino y transformada en un número entero entre 0 y 1023.

Para leer ese valor analógico usaremos la instrucción  analogRead(A0);

En el programa siguiente leemos el valor suministrado por el potenciómetro y lo mostramos en el Monitor Serie.

/*
 * potenciometro.ino
 * Este programa muestra en el Monitor Serie el valor leído en el pin A0
 * (el que está conectado al potenciómetro). La instrucción utilizada es
 * analogRead(A0);
 * El resultado será un número entero entre 0 y 1023, que se corresponde
 * con un voltaje entre 0 y 5 voltios.
 */

void setup() {
  pinMode(A0, INPUT);       //pin A0 como entrada
  Serial.begin(9600);
}

void loop() { 
  Serial.println(analogRead(A0));
  delay(500);
}

Ahora haremos que se encienda el Led D1 (pin 13) cuando el valor del potenciómetro esté comprendido entre 400y 450, quedando apagado en caso contrario.

/*
 * potenciometroLed.ino
 * Este programa enciende el LED D1 (pin 13) si el valor leido del
 * potenciómetro (pin A0) esté comprendido entre 400 y 450. En caso
 * contrario el LED permanecerá apagado.
 */

int valorPot;                     //variable para guardar el valor obtenido
                                  //en la lectura del potenciómetro
void setup() {
  pinMode(A0, INPUT);              //pin A0 como entrada
  pinMode(13, OUTPUT);             //pin 13 salida
  digitalWrite(13, HIGH);          //apagamos LED
  Serial.begin(9600);
}

void loop() { 
  valorPot = analogRead(A0);                    //leemos el pin A0
  if((valorPot > 400) && (valorPot < 450)) {    //si >400 y <450
    digitalWrite(13, LOW);                      //encendemos LED
  }else{                                        //en caso contrario
    digitalWrite(13, HIGH);                     //lo apagamos
  }
  Serial.println(valorPot);                     //motramos el valor leído
  delay(100);
}

Ejercicios propuestos:

1.- Realizar un programa que encienda el LED 4 cuando la lectura del potenciómetro sea mayor de 500 y, además, el LED 3 si supera 550.

2.- Ahora tenemos que encender los LEDs 3 y 4 si la lectura está comprendida entre 500 y 550. Además, añadimos los LEDs 1 y 2 entre 600 y 650 y, finalmente, hacemos sonar el zumbador si se superan los 700.

Pulsadores (II). Variables (IDE Arduino)

En esta entrada vamos a hacer un programa que puede parecer sencillo, pero presenta algunas complicaciones. Se trata de cambiar (voltear) el estado de un LED cada vez que accionemos un pulsador; es decir, si estaba apagado se enciende y si estaba encendido se apaga.

Para cambiar o voltear el LED usaremos el operador lógico ! (lo contrario de...) y las instrucciones digitalWrite y digitalRead:

    digitalWrite(13, !digitalRead(13));            
   escribimos en el LED el estado contrario al que tenía

Vamos a ver un primer programa que no funciona correctamente, pero no ayudará a entender las dificultades del razonamiento lógico que tiene.

/*
 * pulsadorPulsadoFallido.ino
 * Al accionar el pulsador, si el LED estaba apagado se enciende y si
 * estaba encendido se apaga.
 * Para cambiar el LED utilizaremos el operador ! que viene a significar
 * lo contrario de ...
 * Tal como está hecho no funcionará correctamente, como se podrá
 * comprobar al cargarlo en nuestra placa Arduino, lo solucionaremos
 * en el siguiente programa.
 */

void setup() {
  pinMode(13, OUTPUT);      //pin 13 como salida
  pinMode(A1, INPUT);       //pin A1 como entrada
  digitalWrite(13, HIGH);   //Led D1 apagado
}

void loop() { 
  if((digitalRead(A1)==LOW)){             //si pulsador presionado
    digitalWrite(13, !digitalRead(13));   //volteamos el LED
  }                                       //Esto no funcionará, ya que,
  delay(50);                              //mientras lo tengamos presionado,
}                                         //el LED estará cambiando y no
                                          //sabremos como quedará al soltar

No nos vale únicamente con saber si el pulsador está presionado, tenemos que detectar el momento inicial en el que se presiona; es decir, el paso de liberado a presionado. Para ello, vamos a utilizar una variable, que no es más que un "lugar" donde podemos guardar cosas. A las variables hay que darles un nombre e indicar el tipo de datos que almacenan (números, letras, estados lógicos, etc.). En nuestro caso, se tratará de una variable de tipo booleano, capaz de guardar estados lógicos; es decir, cero o uno, alto o bajo, cierto o falso. Veamos una nueva versión del programa.

/*
 * pulsadorPulsado.ino
 * Al accionar el pulsador, si el LED estaba apagado se enciende y si
 * estaba encendido se apaga.
 * Vamos a crear una variable que pueda tomar los valores cierto y falso,
 * se denominan booleanas, para saber si el pulsador está o no liberado.
 * También usaremos el operador && (y) para hacer una pregunta doble.
 */

bool liberado = false;     //variable para saber si el pulsador estaba
                           //liberado antes de presionarlo 
 
void setup() {
  pinMode(13, OUTPUT);      //pin 13 como salida
  pinMode(A1, INPUT);       //pin A1 como entrada
  digitalWrite(13, HIGH);   //Led D1 apagado
}

void loop() { 
                                                   //Si hemos presionado y
  if((digitalRead(A1)==LOW) && (liberado==true)){  //antes estaba liberado
    digitalWrite(13, !digitalRead(13));            //volteamos el LED.
    liberado = false;                              //Ya no está liberado
  }                                                //y no hay más volteos.
  if(digitalRead(A1)==HIGH){                       //Si pulsador liberado,
    liberado = true;                               //liberado es cierto y
  }                                                //podemos volver a voltear
  delay(50);                                       //cuando presionemos
}

Es un programa corto pero un poco complicado de entender, es necesario pensar en su lógica detenidamente para comprenderlo completamente, ya que el uso de variables es necesario en la realización de muchos programas.

En el siguiente programa iremos incrementando un número (se mostrará en el Monitor Serie) cada vez que accionemos un pulsador; teniendo en cuenta que cuando sea mayor de 20 tenemos que volver a cero. Será necesario crear una variable de tipo entero (int) para guardar el número.

/*
 * pulsadorNumero.ino
 * Cada vez que accionemos el pulsador se incrementará un número en el
 * Monitor serie. Cuando se llega a 20 se reinicia en cero.
 * Vamos a utilizar una variable capaz de guardar números eneros, es decir,
 * de tipo integer y le damos el valor inicial de cero.
 * Seguiremos usando el operador && (y) para hacer una pregunta doble.
 */

bool liberado = false;
int numero = 0;            //variable que guarda el nº de veces  que
                           //accionamos el pulsador.

void setup() {
  pinMode(A1, INPUT);       //pin A1 como entrada
  Serial.begin(9600);
}

void loop() { 
  if((digitalRead(A1)==LOW)&& (liberado==true)){
    numero++;                                         //incrementamos numero
    liberado = false;
  }
  if(digitalRead(A1)==HIGH){
    liberado = true;
  }
  if(numero > 20){                    //si mayor que 20
    numero = 0;                       //empezamos de nuevo en cero
  }
  Serial.println(numero);             //mostramos el contenido de la variable
  delay(50);
}

Ejercicios propuestos:

1.- Modificar y ampliar el programa anterior para utilizar dos pulsadores, uno para incrementar (numero++) y otro para decrementar (numero--). El numero no debe ser mayor (>) que 20 ni menor (<) que 0.

2.- Ahora queremos ir encendiendo de uno en uno los diodos LEDs cada vez que accionemos un pulsador.