ARDUINO ITSUNET 24 SEPT


CLASE DEL 24 DE SEPTIEMBRE 2016

DISPLAY 7 SEGMENTOS

Un visualizador de siete segmentos, también conocido como SSD por sus siglas en inglés (seven-segment display), es un componente electrónico constituido por una serie de ledes. Cada led es un segmento en forma de una pequeña raya la cual se puede prender y apagar de manera independiente. Los siete segmentos están dispuestos de tal manera que forman el número “8”. Usualmente hay también un octavo segmento que se utiliza para representar el punto decimal.

Ficha técnica del SSD
COM: Si se trata de un SSD ánodo común se conecta a Vcc.
                 * Si se trata de un SSD cátodo común se conecta a GND.

Del esquema se puede observar que cada segmento está identificado por una letra de la A a la G, y P para el segmento correspondiente al punto decimal. 
Los COM sirven de ánodo común o de cátodo común.

El SSD para nuestro proyecto es de ánodo común.

Diseño de los dígitos

Cada uno de los siete segmentos puede estar encendido o apagado. Esto quiere decir que un SSD puede tener 2= 128 estados diferentes (256 si consideramos el segmento del punto decimal). Sin embargo no todos estos estados son de nuestro interés. Para nuestro proyecto deseamos únicamente desplegar los dieciséis dígitos hexadecimales: del 0 al 9 y de la A a la  F. La siguiente imagen muestra el diseño convencional de cada uno de estos dígitos. Los segmentos encendidos se muestran en negro, mientras que los apagados están en gris:

Hay que notar que los diseños de la b y la d se encuentran en minúsculas ya que no se pueden representar en mayúsculas sin que se confundan con algún otro dígito.

Una forma compacta de representar estos diseños consiste en usar números binarios, en donde para un SSD cátodo común un bit 0 representa un segmento apagado y un bit 1 representa un segmento encendido, si se trata de un SSD ánodo común un bit 1 representa un segmento apagado y un bit 0 representa un segmento encendidos. A cada bit de un total de 7 (identificados desde la A a la G) le asociamos un segmento específico del SSD, tal como se muestra en la siguiente figura:  

A partir de la disposición anterior podemos codificar el diseño de todos los dígitos hexadecimales usando números binarios para un SSD ánodo común:

Dígito 0:
0000001
Dígito 1:
1001111
Dígito 2:
0010010
Dígito 3:
0000110
Dígito 4:
1001001
Dígito 5:
0100100
Dígito 6:
0100000
Dígito 7:
0001111
Dígito 8:
0000000
Dígito 9:
0000100
Dígito A:
0001000
Dígito B:
1100000
Dígito C:
0110001
Dígito D:
1000010
Dígito E:
0110000
Dígito F:
0111000

Al momento de escribir el software para desplegar estos diseños será necesario implementar un poco de lógica de manipulación de bits para decodificar estos números binarios.


EJERCICIO SSD - ARDUINO

En este ejercicio vamos a realizar un contador con el display de 7 segmentos, el cual tendrá un modo manual y un modo automático. El modo manual será por medio de 2 pulsadores el un pulsador irá aumentando el dígito y el segundo pulsador disminuirá el dígito entre 0 y F. El modo automático será por medio de un tercer pulsador el cual iniciará un conteo de los 16 dígitos hexadecimales de 0 a F durante 3 veces seguidas.

Materiales:
1) Una placa de Arduino
2) Un protoboard
3) 2 resistencias 220 ohm
4) 1 Display de 7 segmentos ánodo común
5) 3 pulsadores
6) 3 resistencias de 1K ohm
7) Cables de Arduino

CÓDIGO DE PROGRAMACIÓN


//Declaramos los pines de salida,
//en el el proyecto asi lo tenemos cableado
//Declaracion de pines del a,b,c,d,e,f,g del display de 7 segmentos
//  a = A3;
int b = 13;
int c = 7;
int d = 6;
int e = 8;
//  f = A4;
//  g = A5;

//Pulsadores
int p1=10;
int p2=9;
int p3=1;
int pulsador1=0;
int pulsador2=0;
int pulsador3=0;

int cont=0; //contador

void setup(){
  //ENTRADAS
   pinMode(p1,INPUT);
   pinMode(p2,INPUT);
   pinMode(p3,INPUT);
  //SALIDAS
   pinMode(A3, OUTPUT);
   pinMode(b, OUTPUT);
   pinMode(c, OUTPUT);
   pinMode(d, OUTPUT);
   pinMode(e, OUTPUT);
   pinMode(A4, OUTPUT);
   pinMode(A5, OUTPUT);
   numerodisplay(cont);
}

void loop(){
  //Lectura de pulsadores
  pulsador1=digitalRead(p1);
  pulsador2=digitalRead(p2);
  pulsador3=digitalRead(p3);
  
  //si se presiona p1 el dígito asciende
  if(pulsador1==HIGH){
    cont=cont+1;
    numerodisplay(cont);
    if(cont>15) cont=-1;
    delay(700);
  }
  
  //si se presiona p2 el dígito desciende
  if(pulsador2==HIGH){
    cont=cont-1;
    numerodisplay(cont);
    if(cont<0) cont=16;
    delay(700);
  }
  
  //si se presiona p3 cuenta 3 veces de 0 a F
  if(pulsador3==HIGH){
    for(int i=0; i<3; i++){
      for(cont=0;cont<16;cont++){
        numerodisplay(cont);
        delay(500);
      }
    }
    numerodisplay(0);
  }
}

//Función para identificar los bits según el número 
void numerodisplay(int n){
  switch(n){
    case 0:
      //Cero
       escribirEnElDisplay(0,0,0,0,0,0,1);
    break;
    
    case 1:
      //Uno
      escribirEnElDisplay(1,0,0,1,1,1,1);
    break;
    
    case 2:
      //Dos
      escribirEnElDisplay(0,0,1,0,0,1,0);
    break;
    
    case 3:
      //Tres
      escribirEnElDisplay(0,0,0,0,1,1,0);
   break;
   
   case 4:
     //Cuatro
     escribirEnElDisplay(1,0,0,1,1,0,0);
   break;
   
   case 5:
     //Cinco
     escribirEnElDisplay(0,1,0,0,1,0,0);
   break;
   
   case 6:
     //Seis
     escribirEnElDisplay(0,1,0,0,0,0,0);
   break;
   
   case 7:
     //Siete
     escribirEnElDisplay(0,0,0,1,1,1,1);
   break;
   
   case 8:
     //Ocho
     escribirEnElDisplay(0,0,0,0,0,0,0);
   break;
   
   case 9:
     //Nueve
     escribirEnElDisplay(0,0,0,0,1,0,0);
   break;
   
   case 10:
     //A
     escribirEnElDisplay(0,0,0,1,0,0,0);
   break;
   
   case 11:
     //B
     escribirEnElDisplay(1,1,0,0,0,0,0);
   break;
   
   case 12:
     //C
     escribirEnElDisplay(0,1,1,0,0,0,1);
   break;
   
   case 13:
     //D
     escribirEnElDisplay(1,0,0,0,0,1,0);
   break;
   
   case 14:
     //E
     escribirEnElDisplay(0,1,1,0,0,0,0);
   break;
   
   case 15:
     //F
     escribirEnElDisplay(0,1,1,1,0,0,0);
   break;
  }
}

//Función para enviar 0 y 1 lógico a los pines del SSD
void escribirEnElDisplay(int va, int vb, int vc, int vd, int ve, int vf, int vg){
   digitalWrite(A3,va);
   digitalWrite(b,vb);
   digitalWrite(c,vc);
   digitalWrite(d,vd);
   digitalWrite(e,ve);
   digitalWrite(A4,vf);
   digitalWrite(A5,vg);
}


DIAGRAMA ELÉCTRICO




LIQUID CRYSTAL DISPLAY (LCD)


El LCD (liquid crystal display) es un elemento indispensable en la electrónica cuando usamos microcontroladores ya que nos permiten mostrar información de forma muy sencilla y con un coste muy bajo. 

Las principales ventajas que presentan sobre los displays numéricos de LEDs es que son capaces de mostrar muchos más caracteres en varias líneas y que su consumo es muy bajo (del orden de 1mA). 




En este tutorial, se va a mostrar cómo conectar una pantalla LCD 1602A a una placa Arduino para mostrar texto por pantalla. Es bien sencillo y necesita poco material y nada caro.

Estas pantallas constan de 16 pines. De izquierda a derecha, sus usos son los siguientes:
  • Pin 1 – VSS o GND
  • Pin 2 – VDD o alimentación (+5V)
  • Pin 3 – Voltaje de contraste. Se conecta a un potenciómetro.
  • Pin 4 – Selección de registro. Aquí se selecciona el dispositivo para su uso.
  • Pin 5 – Lectura/Escritura. Dependiendo del estado (HIGH o LOW), se podrá escribir o leer datos     en el LCD
  • Pin 6 – Enable. Es el pin que habilita o deshabilita el LCD.
  • Pin 7 hasta Pin 14 – Son los pines de datos por donde se envía o recibe información.
  • Pin 15 – El ánodo del LED de iluminación de fondo (+5v).
  • Pin 16 – El cátodo del LED de iluminación de fondo (GND).
EJERCICIO CON LCD Y ARDUINO
En este ejemplo vamos a imprimir en  "HOLA MUNDO" en la primera fila y en la segunda fila pondremos otro mensaje en mi caso pondré "JCTECNOLOGIAS". 
Materiales:
1) Una tarjeta de Arduino
2) Un Protoboard
3) Un potenciómetro de 2K ohm
4) Una resistencia 1K ohm
5) Una LCD 16x2
6) Cables de Arduino
Si contamos con una pantalla LCD y la queremos utilizar con Arduino, debemos hacer las siguientes conexiones:

DIAGRAMA ELÉCTRICO
CÓDIGO DE PROGRAMACIÓN


/*
  LiquidCrystal Library - Hello World

 Demonstrates the use a 16x2 LCD display.  The LiquidCrystal
 library works with all LCD displays that are compatible with the
 Hitachi HD44780 driver. There are many of them out there, and you
 can usually tell them by the 16-pin interface.

 This sketch prints "Hello World!" to the LCD
 and shows the time.

  The circuit:
 * LCD RS pin to digital pin 12
 * LCD Enable pin to digital pin 11
 * LCD D4 pin to digital pin 5
 * LCD D5 pin to digital pin 4
 * LCD D6 pin to digital pin 3
 * LCD D7 pin to digital pin 2
 * LCD R/W pin to ground
 * LCD VSS pin to ground
 * LCD VCC pin to 5V
 * 10K resistor:
 * ends to +5V and ground
 * wiper to LCD VO pin (pin 3)

 Library originally added 18 Apr 2008
 by David A. Mellis
 library modified 5 Jul 2009
 by Limor Fried (http://www.ladyada.net)
 example added 9 Jul 2009
 by Tom Igoe
 modified 22 Nov 2010
 by Tom Igoe

 This example code is in the public domain.

 http://www.arduino.cc/en/Tutorial/LiquidCrystal
 */

// include the library code:
#include <LiquidCrystal.h>

// initialize the library with the numbers of the interface pins
//LiquidCrystal lcd(RS, E, D4, D5, D6, D7);
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

void setup() {
  // set up the LCD's number of columns and rows:
  lcd.begin(16, 2);
  // Print a message to the LCD.
  lcd.clear();
}

void loop() {
  // set the cursor to column 0, line 1
  // (note: line 1 is the second row, since counting begins with 0):
  lcd.setCursor(0, 0);
  lcd.print("HOLA MUNDO");
  lcd.setCursor(0, 1);
  lcd.print("JCTECNOLOGIAS");
  // print the number of seconds since reset:
  //lcd.print(millis() / 1000);
}


SISTEMA INTELIGENTE ASCENSOR
En el siguiente ejercicio vamos a diseñar un sistema inteligente de un ascensor usando Arduino, donde realizará las siguientes funciones: En una LCD se mostrará las ordenes a ejecutar las cuales son: elegir a que piso desea ir dentro del edificio o si está subiendo o bajando el ascensor; para realizar los mandos del control se contará con 3 pulsadores los cuales tendrán como función aumentar o disminuir el número de piso e iniciar el arranque del ascensor; también se contará con un display de 7 segmentos que indicará la posición actual del piso; finalmente usaremos 2 leds para simular el giro de un motor y un sensor de temperatura LM35Z para apreciar la temperatura en la LCD . Para este ejercicio vamos a combinar los diagramas eléctricos de los ejercicios anteriores.

CÓDIGO DEL PROGRAMA


#include <LiquidCrystal.h>

//LiquidCrystal lcd(RS, E, D4, D5, D6, D7);
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
int cond=0;

//Declaramos los pines de salida,
//en el el proyecto asi lo tenemos cableado
//Declaracion de pines del a,b,c,d,e,f,g del display de 7 segmentos
//  a = A3;
int b = 13;
int c = 7;
int d = 6;
int e = 8;
//  f = A4;
//  g = A5;

//Pulsadores
int p1=10;
int p2=9;
int p3=1;
int pulsador1=0;
int pulsador2=0;
int pulsador3=0;

//Variables de ascensor
int piso_actual=1; 
int piso_ir=1;
int j=1; //contador

//Variables que representarán un motor
//motor_arriba -> A6
//motor_abajo -> A7

int temperatura=0;

void setup(){
  // Inicializa la libreria de la LCD
  lcd.begin(16, 2);
  //Limpia todos los caracteres de la LCD
  lcd.clear();
  //ENTRADAS
   pinMode(p1,INPUT);
   pinMode(p2,INPUT);
   pinMode(p3,INPUT);
  //SALIDAS
   pinMode(A3, OUTPUT);
   pinMode(b, OUTPUT);
   pinMode(c, OUTPUT);
   pinMode(d, OUTPUT);
   pinMode(e, OUTPUT);
   pinMode(A4, OUTPUT);
   pinMode(A5, OUTPUT);
   pinMode(A6, OUTPUT);
   pinMode(A7, OUTPUT);
   //Función escribrir dígito en en SSD
   numerodisplay(piso_actual);
}

void loop(){
  //Lectura de pulsadores
  pulsador1=digitalRead(p1);
  pulsador2=digitalRead(p2);
  pulsador3=digitalRead(p3);
  digitalWrite(A6,LOW);
  digitalWrite(A7,LOW);
  
  temperatura = analogRead(A2);
  temperatura = ((temperatura*5*100)/1023); //Conversión de un sensor LM35
  
  if(cond==0){
    mensaje_inicio();
  }
  cond=1;
  
  lcd.setCursor(0, 0);
  lcd.print("Temperatura:");
  lcd.print(temperatura);
  lcd.setCursor(0, 1);
  lcd.print("Ir al piso:");
  lcd.print(piso_ir);
  delay(200);
  lcd.clear();
  
  //si se presiona p1 el piso asciende
  if(pulsador1==HIGH){
    piso_ir=piso_ir+1;
    if(piso_ir>9) piso_ir=9;
    if(piso_ir==piso_actual){ 
      piso_ir=piso_ir+1;
      if(piso_ir>9) piso_ir=9;
    }
    delay(700);
  }
  
  //si se presiona p2 el piso desciende
  if(pulsador2==HIGH){
    piso_ir=piso_ir-1;
    if(piso_ir<1) piso_ir=1;
    if(piso_ir==piso_actual){ 
      piso_ir=piso_ir-1;
      if(piso_ir<1) piso_ir=1;
    }
    delay(700);
  }
  
  //si se presiona p3 cuenta 3 veces de 0 a F
  if(pulsador3==HIGH){
    if(piso_actual<piso_ir){
      digitalWrite(A6,HIGH);
      lcd.setCursor(0, 0);
      lcd.print("SERVICIO ASCENSOR");
      lcd.setCursor(0, 1);
      lcd.print("  SUBIENDO....");
      for(j=piso_actual;j<=piso_ir;j++){
        numerodisplay(j);
        delay(800);
      }
      piso_actual=piso_ir;
      lcd.clear();
    }
    
    if(piso_actual>piso_ir){
      digitalWrite(A7,HIGH);
      lcd.setCursor(0, 0);
      lcd.print("SERVICIO ASCENSOR");
      lcd.setCursor(0, 1);
      lcd.print("  BAJANDO.....");
      for(j=piso_actual;j>=piso_ir;j--){
        numerodisplay(j);
        delay(800);
      }
      piso_actual=piso_ir;
      lcd.clear();
    }
  }
}

//Función mensaje de entrada del Sistema del Ascensor
void mensaje_inicio(){
  lcd.setCursor(0, 0);
    lcd.print("SISTEMA INTELIGE");
    lcd.setCursor(0, 1);
    lcd.print("    ASCENSOR");
    delay(1500);
    lcd.clear();
    lcd.setCursor(0, 0);
    lcd.print("ISTEMA INTELIGEN");
    lcd.setCursor(0, 1);
    lcd.print("    ASCENSOR");
    delay(1000);
    lcd.clear();
    lcd.print("STEMA INTELIGENT");
    lcd.setCursor(0, 1);
    lcd.print("    ASCENSOR");
    delay(1000);
    lcd.clear();
    lcd.print("TEMA INTELIGENTE");
    lcd.setCursor(0, 1);
    lcd.print("    ASCENSOR");
    delay(2000);
    lcd.clear();
}

//Función para identificar los bits según el número 
void numerodisplay(int n){
  switch(n){
    case 0:
      //Cero
       escribirEnElDisplay(0,0,0,0,0,0,1);
    break;
    
    case 1:
      //Uno
      escribirEnElDisplay(1,0,0,1,1,1,1);
    break;
    
    case 2:
      //Dos
      escribirEnElDisplay(0,0,1,0,0,1,0);
    break;
    
    case 3:
      //Tres
      escribirEnElDisplay(0,0,0,0,1,1,0);
   break;
   
   case 4:
     //Cuatro
     escribirEnElDisplay(1,0,0,1,1,0,0);
   break;
   
   case 5:
     //Cinco
     escribirEnElDisplay(0,1,0,0,1,0,0);
   break;
   
   case 6:
     //Seis
     escribirEnElDisplay(0,1,0,0,0,0,0);
   break;
   
   case 7:
     //Siete
     escribirEnElDisplay(0,0,0,1,1,1,1);
   break;
   
   case 8:
     //Ocho
     escribirEnElDisplay(0,0,0,0,0,0,0);
   break;
   
   case 9:
     //Nueve
     escribirEnElDisplay(0,0,0,0,1,0,0);
   break;
   
   case 10:
     //A
     escribirEnElDisplay(0,0,0,1,0,0,0);
   break;
   
   case 11:
     //B
     escribirEnElDisplay(1,1,0,0,0,0,0);
   break;
   
   case 12:
     //C
     escribirEnElDisplay(0,1,1,0,0,0,1);
   break;
   
   case 13:
     //D
     escribirEnElDisplay(1,0,0,0,0,1,0);
   break;
   
   case 14:
     //E
     escribirEnElDisplay(0,1,1,0,0,0,0);
   break;
   
   case 15:
     //F
     escribirEnElDisplay(0,1,1,1,0,0,0);
   break;
  }
}

//Función para enviar 0 y 1 lógico a los pines del SSD
void escribirEnElDisplay(int va, int vb, int vc, int vd, int ve, int vf, int vg){
   digitalWrite(A3,va);
   digitalWrite(b,vb);
   digitalWrite(c,vc);
   digitalWrite(d,vd);
   digitalWrite(e,ve);
   digitalWrite(A4,vf);
   digitalWrite(A5,vg);
}


Bueno con esto se concluye el curso de Arduino impartido hacia los estudiantes de Tecnología en Sistemas del "INSTITUTO TECNOLÓGICO SUPERIOR NELSON TORRES", Si están interesados en cursos tales como: electrónica básica, electrónica avanzada, proyectos de robótica, domótica, lenguajes de programción, aplicaciones Android ir a la página y buscar mas información o puede contactarse con nosotros mediante formulario, correo electrónico o llamadas telefónicas, no dude en buscarnos estaremos dispuesto a ayudarlo.

0 comentarios:

Copyright © 2013 JCTECNOLOGIAS and Blogger Themes.