lunes, 1 de agosto de 2022

El display II. Funciones. (IDE Arduino)

En esta entrada vamos a utilizar las denominadas variables con índice, que van a servirnos para acceder con facilidad a los códigos 7 segmentos de las cifras numéricas. Veámoslo en el siguiente programa:

/*
* displayNumero0-9.ino * Va mostrando en el display (dígito más a la derecha) los * números del 0 al 9 a intervalos de 1 segundo. * Hemos hecho una especie de tabla con los códigos de 7 segmentos * de las diez cifras (del 0 al 9). Para acceder a estos códigos sólo * tenemos que indicar el nombre de la tabla y el orden del elemento * que queremos obtener entre los corchetes, empezando por 0. */                    //codigo7seg[], variable con índice para                    //guardar una tabla con los códigos de todas                    //las cifras decimales.                    //abcdefgp recordar que cero es encendido byte codigo7seg[] = {B00000011,     //código 7 segmentos del 0                     B10011111,     //código 7 segmentos del 1                     B00100101,     //código 7 segmentos del 2                       B00001101,     //código 7 segmentos del 3                     B10011001,     //código 7 segmentos del 4                     B01001001,     //código 7 segmentos del 5                     B01000001,     //código 7 segmentos del 6                     B00011111,     //código 7 segmentos del 7                     B00000001,     //código 7 segmentos del 8                     B00001001};    //código 7 segmentos del 9                                    //codigo7seg[0] sería 00000011                                    //codigo7seg[1] sería 10011111                                    //y así sucesivamente... int numero = 0;                       void setup (){  pinMode(4,OUTPUT);  pinMode(7,OUTPUT);  pinMode(8,OUTPUT); } void loop(){  digitalWrite(4,LOW);  shiftOut(8, 7, LSBFIRST, codigo7seg[numero]);  shiftOut(8, 7, LSBFIRST, B00010000);  digitalWrite(4,HIGH);  numero++;                            //incrementamos numero  if(numero == 10){                    //si llegamos a 10    numero = 0;                        //empezamos de nuevo en cero  }  delay(1000); }

En una entrada anterior hicimos un programa que mostraba la lectura del potenciómetro a través del Monitor Serie, ahora lo haremos con el display. Nosotros desconocemos cual es la lectura y, por tanto, no podemos enviar cuatro dígitos concretos al display; el programa tiene que ser capaz de separar en sus cuatro cifras (millar, centena, decena y unidades) el valor obtenido del potenciómetro. En el siguiente ejemplo se muestra como se puede hacer esa descomposición:

numero = 8547

                        millar = numero : 1000
                        millar =   8547 : 1000 = 8

                      centena = (numero - millar*1000) : 100
                      centena = (  8547   -    8*1000)    : 100
                      centena =           547                    : 100 = 5

                decena = (numero - millar*1000 - centena*100) : 10
                decena = (   8547  -     8000       -       500       ) : 10
                decena =                      47                                 : 10 = 4

             unidades = numero - millar*1000 - centena*100 - decena*10
             unidades =   8547   -     8000       -        500       -       40      = 7


El programa sería el siguiente:                          

/*
 * displayPotenciometro.ino
 * Visualizamos en el display los valores del potenciometro.
 * Una vez leido el numero hay que descomponenlo en sus cifras,
 * millar, centena, decena y unidad.
 */

byte codigo7seg[] = {B00000011,     //0
                     B10011111,     //1
                     B00100101,     //2  
                     B00001101,     //3
                     B10011001,     //4
                     B01001001,     //5
                     B01000001,     //6
                     B00011111,     //7
                     B00000001,     //8
                     B00001001};    //9
                      
int valorPot;              
int millar;
int centena;
int decena;
int unidad;

void setup (){
  pinMode(4,OUTPUT);    //pines display
  pinMode(7,OUTPUT);
  pinMode(8,OUTPUT);
  pinMode(A0, INPUT);   //pin potenciómetro
}

void loop(){
  valorPot = analogRead(A0);
  millar = valorPot/1000;
  centena = (valorPot - millar*1000)/100;
  decena = (valorPot - millar*1000 - centena*100)/10;
  unidad = valorPot - millar*1000 - centena*100 - decena*10;
  digitalWrite(4,LOW);
  shiftOut(8, 7, LSBFIRST, codigo7seg[unidad]);
  shiftOut(8, 7, LSBFIRST, B00010000);
  digitalWrite(4,HIGH);
  digitalWrite(4,LOW);
  shiftOut(8, 7, LSBFIRST, codigo7seg[decena]);
  shiftOut(8, 7, LSBFIRST, B00100000);
  digitalWrite(4,HIGH);
  digitalWrite(4,LOW);
  shiftOut(8, 7, LSBFIRST, codigo7seg[centena]);
  shiftOut(8, 7, LSBFIRST, B01000000);
  digitalWrite(4,HIGH);
  digitalWrite(4,LOW);
  shiftOut(8, 7, LSBFIRST, codigo7seg[millar]);
  shiftOut(8, 7, LSBFIRST, B10000000);
  digitalWrite(4,HIGH);
}

Vamos a modificar el programa anterior para incluir una especie de "instrucción propia" (función) que sirva para visualizar cualquier numero en el display, esta función la podríamos incluir también en otros programas.

/*
 * displayFuncion.ino
 * El programa muestra en el display las lecturas del
 * potenciómetro.
 * En este caso, vamos a crea una función denominada display7Seg
 * para poder visualizar cualquier número, bastará con escribir
 * el nombre de la función y, entre paréntesis, el número a mostrar.
 * Por ejemplo: display7Seg(1582);
 */
                    
byte codigo7seg[] = {B00000011, B10011111, B00100101, B00001101, B10011001, 
B01001001, B01000001, B00011111, B00000001, B00001001};
int valorPot;                            //para guardar el valor del potenciómetro
//las variables millar, centena, decena
//y unidad están declaradas en la función void setup (){  pinMode(4,OUTPUT); //pines display  pinMode(7,OUTPUT);  pinMode(8,OUTPUT);  pinMode(A0, INPUT); //pin potenciómetro } void loop(){  valorPot = analogRead(A0);             //leemos el potenciómetro  display7Seg(valorPot);                 //lo mostramos en el display }
                                         //Nuestra función
void display7Seg(int numero){
  int millar = numero/1000;                         
  int centena = (numero - millar*1000)/100;              
  int decena = (numero - millar*1000 - centena*100)/10;  
  int unidad = numero - millar*1000 - centena*100 - decena*10;  
  digitalWrite(4,LOW);
  shiftOut(8, 7, LSBFIRST, codigo7seg[unidad]);
  shiftOut(8, 7, LSBFIRST, B00010000);
  digitalWrite(4,HIGH);
  digitalWrite(4,LOW);
  shiftOut(8, 7, LSBFIRST, codigo7seg[decena]);
  shiftOut(8, 7, LSBFIRST, B00100000);
  digitalWrite(4,HIGH);
  digitalWrite(4,LOW);
  shiftOut(8, 7, LSBFIRST, codigo7seg[centena]);
  shiftOut(8, 7, LSBFIRST, B01000000);
  digitalWrite(4,HIGH);
  digitalWrite(4,LOW);
  shiftOut(8, 7, LSBFIRST, codigo7seg[millar]);
  shiftOut(8, 7, LSBFIRST, B10000000);
  digitalWrite(4,HIGH);
}

Ejercicios propuestos:

1.- Realizar un programa en el que el display muestre, inicialmente, el número "0000" y, mientras mantengamos presionado  el pulsador "S1", cambie el cero de las centenas por un uno. Utilizar la función display7Seg y crear la variable numero con el valor 0. Tener en cuenta que para hacer aparecer un 1 en la cifra de las centenas bastaría con sumar 100 y para quitarlo con restar dicha cantidad.

2.- Ahora queremos que si presionamos S1 aparezca un 1 en la cifra de las centenas, si presionamos S2 veamos un 1 en las decenas y si presionamos S3 aparezca un 1 en la cifra de las unidades.

3.- Vamos a hacer una especie de "marcador deportivo". Con el pulsador S1 incrementamos el valor de los dos dígitos situados más a la izquierda, con S2 incrementamos el de los dos dígitos de la derecha. Si se llega a 20 se vuelve a empezar desde cero.





martes, 12 de julio de 2022

El display de 7 segmentos I (IDE Arduino)

Se trata de un display de cuatro dígitos en el que, principalmente, podemos visualizar números y también algunas letras y símbolos. Cada uno de los dígitos está compuesto por 8 diodos LED, los 7 segmentos y el punto decimal. Estos diodos se encienden con un "0" y permanecen apagados cuando se les suministra un "1".

En la figura adjunta podemos apreciar el nombre de los segmentos, su orden y los códigos binarios de 7 segmentos correspondientes a algunos números y letras. 

   a b c d e f g p
2  0 0 1 0 0 1 1 0
8  0 0 0 0 0 0 0 0
L  1 1 1 0 0 0 1 0
A  0 0 0 1 0 0 0 0


Para encender el número "2". en el dígito más a la izquierda del shield multifunción, Arduino debe enviar dos códigos binarios, el de 7 segmentos del número "2" (00100101) y otro para indicar cual es el dígito que se enciende, en este caso, el situado a la izquierda (10000000). Estos códigos se envían en serie, un bit tras otro, a través del pin 8, utilizando la instrucción "siftOut" que se encarga de hacer todo el proceso. Además son necesarios dos pines más, el pin 4, (una especie de permiso que se activa cuando está en "0", tenemos que hacerlo nosotros) y el pin 7 (unos pulsos de reloj para indicar cuando son válidos cada uno de los bit); de este pin y de generar esos pulsos se encarga la propia instrucción "siftOut". En la imagen podemos ver este proceso:


En definitiva, el programa para visualizar el número 2 en el display de la izquierda quedaría de la siguiente manera:
/*
 * display2.ino
 * Visualiza el número 2 en el dígito más a la izquierda del display
 * de 7 segmentos.
 * Los leds del display se encienden con un cero y se apagan con un 1. 
 * El código del numero 2 sería: a b c d e f g p
 *                               0 0 1 0 0 1 0 1
 * Arduino envía los datos (DATA) al shield multifunción en serie, usando
 * el pin 7. A través del pin 8 manda unos pulsos de "reloj" (CLOCK)para 
 * indicar la validez de los datos presentes en el pin 7. Por último, el
 * pin 4 sirve de cerrojo (LATCH), para que el shield multifunción sepa
 * cuando empieza y termina la transmisión de datos.
 * Hay que enviar dos números: el primero se corresponde con el código
 * 7 segmentos que queremos visualizar, el segundo indica (con un 1) el
 * dígito que estará encendido.
 */

void setup (){
  pinMode(4,OUTPUT);     //LATCH, habilita recepción de datos
  pinMode(7,OUTPUT);     //DATA, para enviar los datos
  pinMode(8,OUTPUT);     //CLOK, indica cuando los datos son válidos
}
void loop(){
  digitalWrite(4,LOW);                   //Un 0 habilita la llegada de datos
  shiftOut(8, 7, LSBFIRST, B00100101);   //envía el código 7 segmentos
  shiftOut(8, 7, LSBFIRST, B10000000);   //envía el dígito que se enciende
  digitalWrite(4,HIGH);                  //Un 1 deshabilita la transmisión
}

Ahora vamos a mostrar el número "0134"; primero dígito a dígito y, posteriormente, con una pequeña modificación, los veremos los cuatro a la vez.

/*
 * display0134.ino
 * Vemos en el display los números 0, 1, 3 y 4, de uno en uno
 * a intervalos de 1 segundo. Cada número aparece en un dígito
 * diferente, el 0 en el más a la izquierda.
 * Para ver el número completo 0134 a la vez, tenemos que quitar
 * los retardos (delay) de 1 segundo. Se sigue encendiendo un solo
 * dígito, pero al no haber retardos y estar en un bucle que se
 * repite rapidísimamente nuestros ojos los ven todos encendidos.
 */

void setup (){
  pinMode(4,OUTPUT);     //LATCH
  pinMode(7,OUTPUT);     //DATA
  pinMode(8,OUTPUT);     //CLOCK
}

void loop(){
  digitalWrite(4,LOW); 
  shiftOut(8, 7, LSBFIRST, B00000011);    //el 0
  shiftOut(8, 7, LSBFIRST, B10000000);    //en el dígito de la izquierda
  digitalWrite(4,HIGH);
  delay(1000);
  digitalWrite(4,LOW); 
  shiftOut(8, 7, LSBFIRST, B10011111);    //el 1
  shiftOut(8, 7, LSBFIRST, B01000000);    //en el siguiente dígito
  digitalWrite(4,HIGH);
  delay(1000);
  digitalWrite(4,LOW); 
  shiftOut(8, 7, LSBFIRST, B00001101);    //el 3
  shiftOut(8, 7, LSBFIRST, B00100000);    //en el siguiente dígito
  digitalWrite(4,HIGH);
  delay(1000);
  digitalWrite(4,LOW); 
  shiftOut(8, 7, LSBFIRST, B10011001);    //el 4
  shiftOut(8, 7, LSBFIRST, B00010000);    //en el último de la derecha
  digitalWrite(4,HIGH);
  delay(1000);                            //quitar todos los delay
                                          //para ver los cuatro a la vez
}

Ejercicios propuestos:

1.- Escribir un programa que haga aparecer en el display (en el dígito más a la derecha) los números del 0 al 5 a intervalos de un segundo.

2.- Mostrar en el display la palabra "HOLA".

3.- Hacer un programa que vaya encendiendo y apagando de uno en uno los segmentos exteriores del display, dándole la vuelta completa:






martes, 14 de junio de 2022

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.










lunes, 6 de junio de 2022

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.

lunes, 16 de mayo de 2022

El monitor serie (IDE Arduino)

Controlar el display de la tarjeta multifunción sin ninguna ayuda es complicado; por ello, de momento, utilizaremos el monitor serie que tiene el IDE Arduino para visualizar datos. Arduino se comunica con el ordenador a través del cable USB utilizando un puerto serie y podemos transmitir datos del uno al otro.

Para activar el monitor serie hay que tener conectada la tarjeta y seleccionarlo en el menú herramientas, se abrirá la ventana adjunta:


El siguiente programa envía al monitor serie el número 1, después de un segundo la palabra "Hola" y pasados dos segundos se repite el ciclo.
/*
 * monitorSerie.ino
 * Escribimos en el monitor Serie del IDE Arduino el número 1
 * seguido de la palabra Hola, a intervalos de tres segundos.
 */


void setup() {
  Serial.begin(9600);   //fijamos la velocidad de transmisión
                        //en 9600 baudios (bits por segundo)
}

void loop() {
  Serial.print(1);            //escribimos 1
  delay(1000);
  Serial.println("  Hola");   //escribimos y pasamos línea
  delay(2000);
}


Ahora visualizaremos en el monitor serie el estado de los tres pulsadores; es decir, si están presionados o liberados.

/*
 * monitorSeriePulsadores.ino
 * Monitorizamos el estado de los pulsadores en el monitor
 * serie,indicando si están presionados o liberados.
 * Usamos un variante de la instrucción if
 * if condición        si se cumple se ejecutan instruciones1
 *    instrucciones1
 * else                en caso contrario se ejecutan instruciones2
 *    instrucciones2
 */

void setup() {
  pinMode(A1, INPUT);
  pinMode(A2, INPUT);
  pinMode(A3, INPUT);
  Serial.begin(9600);

}

void loop() {
  if(digitalRead(A1) == LOW) {        //si pulsador presionado
    Serial.print("D1 presionado");    //   escribe D1 presionado
  }else{                              //en caso contrario  
    Serial.print("D1 liberado");      //   escribe D1 liberado
  }
  if(digitalRead(A2) == LOW) {
    Serial.print("   D2 presionado");
  }else{
    Serial.print("   D2 liberado");
  }
  if(digitalRead(A3) == LOW) {
    Serial.println("   D3 presionado");  
  }else{
    Serial.println("   D3 liberado");
  }
  delay(1000);
}



Ejercicios propuestos:

1.- Hacer un programa que visualice en el monitor serie vuestro nombre, transcurridos 5 segundos,  la edad (en la misma línea) y pasados otros 5 segundos la dirección (en la línea siguiente). Tras 5 segundos más en ciclo se repite.