Práctica 10 – Teclado matricial

 

INTRODUCCIÓN

 

En esta práctica se implementa el encendido y apagado de un LED, haciendo uso de un teclado matricial 4×4. Para encender el LED se presiona la tecla 1 y para apagarlo se presiona la tecla 0.

 

Selecciona la plataforma y entorno de programación.

 

 

PIC
AVR
PIC
PIC C Compiler
PIC C Compiler
Bootloader X-TRAINER
Bootloader X-TRAINER

Descripción

En esta práctica se realiza el control de encendido y apagado del LED incluido en los módulo X-TRAINER P8 o X-TRAINER P8 DIP40 o X-TRAINER P8 DIP28, con el PIC18F45K50 o el PIC18F25K50. También se utiliza un teclado matricial de 4x4, el cual está conectado en el puerto B con 4 resistencias configuradas como pull-down (B0-B3). Para encender el LED se presiona la tecla 1 y para apagar el LED se presiona la tecla 0.

 

Materiales:

1 x Módulo X-TRAINER P8 o X-TRAINER P8 DIP40 o X-TRAINER P8 DIP28. Comprar

1 x Teclado matricial 4x4. Comprar

4 x Resistencias 1 Kohms. Comprar

1 x Protoboard de 830 puntos. Comprar

1 x Juego de cables Dupont. Comprar

1 x Cable micro USB.

 

Software:

Windows 7 o posterior.

PIC C Compiler v5.069 o posterior. Descarga

XIDE v1.0 Descarga

 

Procedimiento

1. En el apartado de "Diagrama esquemático", que se encuentra a continuación, selecciona tu módulo, realiza las conexiones que se muestran en la imagen y conéctalo a la computadora.

2. Al final de esta práctica, en el apartado de "Descargas", puedes encontrar los archivos del código fuente. Es necesario descargar el archivo ya que dentro, se encuentran las librerías necesarias para la correcta compilación.

3. Ejecuta PIC C Compiler, abre el archivo descargado y compila el programa. En el siguiente link encontrarás un manual para compilar en PIC C Compiler.

4.Abre el Software XIDE v1.0 y programa el código que descargaste o compilaste en el módulo. En el siguiente link encontrarás el manual de usuario para el Software XIDE v1.0. 

5.Al terminar de programar, el módulo se reiniciará y el programa de esta práctica se ejecutará.

 

 

Diagrama esquemático

 

X-TRAINER P8 LITE
X-TRAINER P8
X-TRAINER P8 DIP 40
X-TRAINER P8 DIP 28
X-TRAINER P8 LITE

X-TRAINER P8

X-TRAINER P8 DIP 40

X-TRAINER P8 DIP 28

 

 

Código

Código

 /*

AUTOR: MICROSIDE TECHNOLOGY S.A. DE C.V.

FECHA: JUNIO 2019

*/

/**************************************************************************

En esta práctica se realiza el control de encendido o apagado de un LED mediante un teclado matricial,  que al presionar la tecla 1 se enciende el LED y al presionar la tecla 0 se apagará el LED.

**************************************************************************/

#include <18F45K50.h>                                                 // Incluye la librería para el PIC ( para X-TRAINERp8DIP28: #include <18F25K50.h> )

#use delay(internal=48MHz)                                          // Configura frecuencia del oscilador interno

#build(reset=0x02000,interrupt=0x02008)                      // Asigna los vectores de reset e interrupción para la versión con bootloader

#org 0x0000,0x1FFF {}                                                   // Reserva espacio en memoria para el bootloader

#define LED PIN_A1                                                       //Pin donde está conectado el LED de X-TRAINER
char TECLA_PRESS;

////CONFIGURACIÓN DE PINES TECLADO

#define row0 PIN_B0                                                                //Filas del teclado colocar resistencia pullup
#define row1 PIN_B1                                                               //Filas del teclado colocar resistencia pullup
#define row2 PIN_B2                                                              //Filas del teclado colocar resistencia pullup
#define row3 PIN_B3                                                             //Filas del teclado colocar resistencia pullup
#define col0 PIN_B4                                                             //Columnas del teclado
#define col1 PIN_B5
#define col2 PIN_B6
#define col3 PIN_B7

#include “Teclado4x4.h”                                                    //LIBRERÍA DE TECLADO

void main()

{

    kbd_init ();                                                                           //inicialización del teclado.

    while(TRUE)
      {
        TECLA_PRESS = kbd_getc () ;

         if (TECLA_PRESS == ‘1’)
          {
            output_HIGH (LED);                                                                   //Cambio de estado en el pin RA1
          }


          if (TECLA_PRESS == ‘0’)
         {
             output_LOW (LED);                                                            //Cambio de estado en el pin RA1
          }
    }
}

 

 

 

Descargas

Software XIDE v1.0

Descarga el software XIDE v1.0 

Práctica 10 – PIC – Bootloader – CCS

Descargar código en PIC C Compiler de la práctica 10.

AVR
Atmel Studio 7
Atmel Studio 7
Programador XCU
Programador XCU

Descripción

En esta práctica se realiza el control de encendido y apagado del LED incluido en los módulos X-NANO o X-UNO. También se utiliza un teclado matricial de 4x4, el cual esta conectado en el puerto D con 4 resistencias internas configuradas como pull-up. Para encender el LED se presiona la tecla 1 y para apagar el LED se presiona la tecla 0.

 
Materiales:

1 x Módulo X-UNO o X-NANO. Comprar

1 x Módulo programador XCU. Comprar

1 x Módulo X-AVR. Comprar

1 x Teclado Matricial 4x4. Comprar

1 x Juego de cables Dupont. Comprar

1 x Protoboard de 830 puntos. Comprar

1 x Cable micro USB.

 

Software:

Windows 7 o posterior.

Atmel Studio 7. Descarga

 

Procedimiento

1. En el apartado de "Diagrama esquemático", que se encuentra a continuación, selecciona tu módulo, realiza las conexiones que se muestran en la imagen y conéctalo a la computadora.

2. Al final de esta práctica, en el apartado de "Descargas", puedes encontrar los archivos del código fuente, o bien copiarlo del apartado de "Código" que se encuentra más abajo.

3. Si descargaste el archivo del paso 2, omite este paso. Si copiaste el código, ejecuta Atmel Studio 7, pega el código en un nuevo proyecto y realiza la compilación.

4. Programa el código que descargaste o compilaste en el módulo. En el siguiente link encontrarás un manual para compilar tu proyecto en Atmel Studio 7. En el siguiente link encontrarás un manual de Atmel Studio para programador XCU.

5. Al terminar de programar, el programa de esta práctica se ejecutará.

 

Diagrama esquemático

 

X-UNO
X-NANO
X-UNO

X-NANO

 

Código 

Código

/**

AUTOR: MICROSIDE TECHNOLOGY S.A. DE C.V.

FECHA: JUNIO 2019

*/

/**************************************************************************

En esta práctica se realiza el control de encendido o apagado de un LED mediante un teclado matricial,

que al presionar la tecla 1 se enciende el LED y al presionar la tecla 0 se apagará el LED.

**************************************************************************/

/**************************************************************************

Fuses:

HIGH.BOOTRST : desmarcar

LOW.SUT_CKSEL : deleccionar> Ex.Crystal Osc.8.0- Mhz;Start-up time PWRDWN/RESET: 1K CK/14 CK + 65 ms

EXTXOSC_8MHZ_XX_1KCK_14CK_65MS

**************************************************************************/

#define F_CPU 16000000

#include <avr/io.h>

#include <util/delay.h>

char TECLA_PRESS;

#define LED_HIGH (PORTB|=(1<<PORTB5))

#define LED_LOW (PORTB &= ~(1<<PORTB5))

void SisInit(void) 

{

              DDRD&=~(15<<0);                                                                                                    // PD0 a PD3 como entradas digitales

              PORTD|=(15<<0);                                                                                                      // Pull up de PD0 a PD3

              DDRD|=(15<<4);                                                                                                        // PD4 a PD7 como salida digitales

              PORTD|=(15<<4);                                                                                                      // PD4 a PD7 a 1

              DDRB|= (1<<DDB5);                                                                                                // DDB5 = salida

}

TECLADO()

{

                      uint8_t tiempo=25;                                                                                             //Variable del retardo

                      char TECLA;                                                                                                          //Variable

                       PORTD&=~(1<<PORTD4);                                                                                   //PIND4 en bajo

                       PORTD|=((1<<PORTD5)|(1<<PORTD6)|(1<<PORTD7));                                  //PIND5, PIND6 y PIND7 en alto

                       if((PIND&(1<<PORTD0))==0){                                                                             

                                          TECLA=’D’;                                                                                          // TECLA toma el valor de D

                                           while((PIND&(1<<PORTD0))==0)

                                           _delay_ms(tiempo);                                                                         

                         }

                        else if((PIND&(1<<PORTD1))==0){                                                                    

                                           TECLA=’#’;                                                                                          // TECLA toma el valor de #

                                           while((PIND&(1<<PORTD1))==0)

                                           _delay_ms(tiempo);                                                                         

                         }

                        else if((PIND&(1<<PORTD2))==0){                                                                     

                                           TECLA=’0′;                                                                                          // TECLA toma el valor de 0

                                           while((PIND&(1<<PORTD2))==0)

                                           _delay_ms(tiempo);                                                                          

                          }

                        else if((PIND&(1<<PORTD3))==0){                                                                     

                                           TECLA=’*’;                                                                                          // TECLA toma el valor de *

                                           while((PIND&(1<<PORTD3))==0)

                                           _delay_ms(tiempo);                                                                          

                         }

                         PORTD&=~(1<<PORTD5);                                                                                   //PIND5 en bajo

                        PORTD|=((1<<PORTD4)|(1<<PORTD6)|(1<<PORTD7));                                  //PIND4, PIND6 y PIND7 en alto

                         if((PIND&(1<<PORTD0))==0){                                                                           

                                           TECLA=’C’;                                                                                          // TECLA toma el valor de C

                                           while((PIND&(1<<PORTD0))==0)

                                           _delay_ms(tiempo);                                                                         

                         }

                         else if((PIND&(1<<PORTD1))==0){                                                                      

                                           TECLA=’9′;                                                                                          // TECLA toma el valor de 9

                                           while((PIND&(1<<PORTD1))==0)

                                           _delay_ms(tiempo);                                                                          

                         }

                         else if((PIND&(1<<PORTD2))==0){                                                                     

                                           TECLA=’8′;                                                                                          // TECLA toma el valor de 8

                                           while((PIND&(1<<PORTD2))==0)

                                           _delay_ms(tiempo);                                                                          

                         }

                         else if((PIND&(1<<PORTD3))==0){                                                                      

                                           TECLA=’7′;                                                                                          // TECLA toma el valor de 7

                                           while((PIND&(1<<PORTD3))==0)
                                           _delay_ms(tiempo);                                                                          
                         }
                         PORTD&=~(1<<PORTD6);                                                                                   //PIND6 en bajo
                         PORTD|=((1<<PORTD5)|(1<<PORTD4)|(1<<PORTD7));                                  //PIND5, PIND4 y PIND7 en alto
                         if((PIND&(1<<PORTD0))==0){                                                                           
                                           TECLA=’B’;                                                                                          // TECLA toma el valor de B
                                           while((PIND&(1<<PORTD0))==0)
                                           _delay_ms(tiempo);                                                                         
                         }
                         else if((PIND&(1<<PORTD1))==0){                                                                     
                                           TECLA=’6′;                                                                                          // TECLA toma el valor de 6
                                           while((PIND&(1<<PORTD1))==0)
                                           _delay_ms(tiempo);                                                                       
                         }
                         else if((PIND&(1<<PORTD2))==0){                                                                    
                                           TECLA=’5′;                                                                                          // TECLA toma el valor de 5
                                           while((PIND&(1<<PORTD2))==0)
                                           _delay_ms(tiempo);                                                                          
                         }
                         else if((PIND&(1<<PORTD3))==0){                                                                      
                                           TECLA=’4′;                                                                                          // TECLA toma el valor de 4
                                           while((PIND&(1<<PORTD3))==0)
                                           _delay_ms(tiempo);                                                                         
                         }

                         PORTD&=~(1<<PORTD7);                                                                                   //PIND7 en bajo
                         PORTD|=((1<<PORTD5)|(1<<PORTD4)|(1<<PORTD6));                                  //PIND5, PIND4 y PIND6 en alto
                         if((PIND&(1<<PORTD0))==0){                                                                           
                                           TECLA=’A’;                                                                                           // TECLA toma el valor de A
                                           while((PIND&(1<<PORTD0))==0)
                                           _delay_ms(tiempo);                                                                          
                         }
                         else if((PIND&(1<<PORTD1))==0){                                                                      //Lee si estado del PIND1 es igual 0
                                           TECLA=’3′;                                                                                          // TECLA toma el valor de 3
                                           while((PIND&(1<<PORTD1))==0)
                                           _delay_ms(tiempo);                                                                          
                         }
                         else if((PIND&(1<<PORTD2))==0){                                                                    
                                           TECLA=’2′;                                                                                          // TECLA toma el valor de 2
                                           while((PIND&(1<<PORTD2))==0)
                                           _delay_ms(tiempo);                                                                         
                         }
                         else if((PIND&(1<<PORTD3))==0){                                                                      
                                           TECLA=’1′;                                                                                         // TECLA toma el valor de 1
                                           while((PIND&(1<<PORTD3))==0)
                                           _delay_ms(tiempo);                                                                      
                         }
                         return TECLA;
}

int main(void)
{
                SisInit();

                while (1)
                {
                                TECLA_PRESS=TECLADO();                                                                      //Variable es igualada a la funcion.
                                if (TECLA_PRESS == ‘1’){                                                                           //Compara el valor de TECLA_PRESS
                                                LED_HIGH;                                                                                 //Enciende LED
                                }
                                else if (TECLA_PRESS ==’0′){                                                                    //Compara el valor de TECLA_PRESS
                                                LED_LOW;                                                                                   //Apaga LED
                                }
                 }
}

 

Descargas

Práctica 10-AVR-XCU

Descargar código en Atmel Studio 7 de la práctica 10.

 

Fecha

agosto 13, 2019

Categoría

Prácticas CCS-AS7

EnglishSpanish