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
ARDUINO
PIC
PIC C Compiler
MikroC PRO
MPLAB X IDE
PIC C Compiler
Bootloader PIC18FX5K50
Bootloader PIC18FX5K50

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.

4 x Resistencias 1000 Ohms. 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
X-TRAINER P8 DIP 40
X-TRAINER P8 DIP 28
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.

MikroC PRO
Bootloader PIC18FX5K50
Programador XCU
Bootloader PIC18FX5K50

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 esta 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.

4 x Resistencias 1k Ohms. 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.

MikroC PRO for PIC. 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, 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, abre el compilador, pega el código en un nuevo proyecto, verifica en el apartado de librerías que este seleccionada la necesaria para esta práctica como se muestra en la siguiente imagen y realiza la compilación. En el siguiente link encontrarás un manual para compilar en MikroC PRO for PIC.

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
X-TRAINER P8 DIP40
X-TRAINER P8 DIP28
X-TRAINER P8

X-TRAINER P8 DIP40

X-TRAINER P8 DIP28

 

Código

Código

/*

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

FECHA: JUNIO 2019

*/

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

La práctica consiste en controlar el encendido y apagado de un LED incluido

en la tarjeta a través del uso de un teclado matricial de 4×4.

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

 

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

Para usar el código con bootloader, configurar como lo indica MICROSIDE:

1) Tools> Options> Output> Output Settings> Marcar «Long HEX format»

2) Project> Edit Project> Insertar 48000000 en «MCU Clock Frequency [MHz]» box

 

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

                                                                                                                         //Se declaran las variables globales

#pragma orgall 0x1FFF                                                                              //Espacio reservado bootloader

#define Led_On LATA1_bit = 1                                                                //Puerto A1 como salida

#define Led_Off LATA1_bit = 0                                                               //Puerto A1 como salida

char keypadPort at PORTB;                                                                       //Librería del Keypad

 

void SisInit (void)                                                                                         //Se inicializa el PIC
{                                                                                            //Se configura el oscilador interno del 18F45K50
        

          OSCTUNE = 0x80;                                                                            //Habilita el multiplicador de frecuencia x3

          OSCCON = 0x70;                                                                               //Cambia la frecuencia de HFINTOSC a 16 MHz

          OSCCON2 = 0x10;                                                                             //Deshabilita en oscilador primario

          while (PLLRDY_bit == 0);                                                              //Se crea bucle para estabilizar la frecuencia 16×3=48 MHz

          ACTCON = 0x90;                                                                               //Una vez estable la frecuencia la mantiene constante

                                                                                                                          //Se configuran las entradas y salidas del PIC
         

LATA1_bit = 0;                                                                                   //Escribe ceros en el puerto A1

          TRISA1_bit = 0;                                                                                 //Se declara el puerto A1 como salida

          ANSA1_bit = 0;                                                                                  //Se declara el puerto A1 como señal digital
}

                                                                                                                          //Función para leer el teclado matricial a tráves de un ciclo case

char getKey (void)                                                                                        //Función tipo char que posee todos los casos posibles

{

         char kp = 0;                                                                                          //Se inicializa la variable local kp como 0

         kp = Keypad_Key_Press();                                                               //Se instancia el método que lee la tecla y la aloja en kp

         switch (kp)                                                                                            //Se instancia y ejecuta un ciclo case con lo guardado en kp
                            {

                               case 1:

                               return ‘1’;                                                                         //1 usando código ASCII – 49

                               case 2:

                               return ‘2’;                                                                        //2 usando código ASCII – 50

                               case 3:

                               return ‘3’;                                                                        //3 usando código ASCII – 51

                               case 4:

                               return ‘A’;                                                                        //A usando código ASCII – 65

                               case 5:

                               return ‘4’;                                                                        //4 usando código ASCII – 52

                               case 6:

                               return ‘5’;                                                                        //5 usando código ASCII – 53

                               case 7:

                               return ‘6’;                                                                        //6 usando código ASCII – 54

                               case 8:

                               return ‘B’;                                                                        //B usando código ASCII – 66

                               case 9:

                               return ‘7’;                                                                         //7 usando código ASCII – 55

                               case 10:

                               return ‘8’;                                                                        //8 usando código ASCII – 56

                               case 11:

                               return ‘9’;                                                                        //9 usando código ASCII – 57

                               case 12:

                               return ‘C’;                                                                        //C usando código ASCII – 67

                               case 13:

                               return ‘*’;                                                                        //* usando código ASCII – 42

                               case 14:

                               return ‘0’;                                                                        //0 usando código ASCII – 48

                               case 15:

                               return ‘#’;                                                                        //# usando código ASCII – 35

                               case 16:

                               return ‘D’;                                                                       //D usando código ASCII – 68

                               default:

                                return 0;                                                                         //Si no coincide un caso, regresa a cero, vuelve a empezar el case

                             }

}

 

                                                                                                                          //Se crea el programa a ejecutarse infinitamente

void main ()org 0x2000                                                                              //Vector de inicio usando el bootloader de Microside

{

         char key;                                                                                                //Se crea una variable local tipo char

         SisInit ();                                                                                               //Se manda a instanciar la configuración del PIC

         Keypad_Init ();                                                                                   //Se manda a instanciar la libería para el teclado matricial

         getKey ();                                                                                              //Se manda a instanciar la función que contiene todos los cases

         while (1)                                                                                                //Mientras sea verdadero se ejecuta el bucle infinitamente

                     {

                        key = getKey ();                                                                    //Se manda a asignar la función a una variable para su uso

                        if (key == ‘1’)                                                                         //Si key es igual a la condición entre comillas

                                  {

                                      Led_On;                                                                   //Led enciende

                                  }

                    else if (key == ‘0’)                                                                //Si no es igual key a la condición entre comillas

                                  {

                                     Led_Off;                                                                    //Led se apaga
                                  }

                     }

}

 

 

Descargas

Software XIDE v1.0

Descarga el software XIDE v1.0 

Práctica 10 – PIC – Bootloader

Descargar código en MikroC PRO for PIC de la práctica 10.

Programador XCU
PIC16F
PIC18F
PIC16F

Descripción

En esta práctica se realiza el control de encendido y apagado del LED incluido en el módulo X-TRAINER P8, con el PIC16F1827. También se utiliza un teclado matricial de 4x4, el cual esta 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. Comprar

1 x Microcontrolador PIC16F1827. Comprar

1 x Módulo Programador XCU. Comprar

1 x Teclado matricial 4x4. 

4 x Resistencias 1k Ohms. 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.

MikroC PRO for PIC. 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, 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, abre el compilador, pega el código en un nuevo proyecto, verifica en el apartado de librerías que este seleccionada la necesaria para esta práctica como se muestra en la siguiente imagen y realiza la compilación. En el siguiente link encontrarás un manual para compilar en MikroC PRO for PIC.

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
X-TRAINER P8

 

Código 

Código

/*

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

FECHA: JULIO 2019

*/

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

La práctica consiste en controlar el encendido y apagado de un LED incluido

en la tarjeta a través del uso de un teclado matricial de 4×4.

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

/**************************************************************************}

1) Project>Edit Project, insertar 32000000 en «MCU Clock Frequency [MHz]» box

2) Project>Edit Project, Oscillador> Seleccion bit> Seleccionar «INTOSC oscillador: I/O funcion on ClKIN pin»

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

#define LED_On LATA1_bit = 1

#define LED_Off LATA1_bit = 0

char keypadPort at PORTB;


void SisInit (void)
{
                                                                                                                              //Se configura el oscilador
                                                                                                                               //Configura el oscilador interno
   OSCCON = 0xF0;                                                                                                //Cambiar HFINTOSC a 32MHz
                                                                                                                              //Se configuran las entradas y salidas del PIC
    LATA1_bit = 0;                                                                                                  //Escribe ceros en el puerto A1

    TRISA1_bit = 0;                                                                                                 //Se declara el puerto A1 como salida

    ANSA1_bit = 0;                                                                                                  //Se declara el puerto A1 como señal digitaL

    ANSELB = 0 ;                                                                                                     // Habilita el puerto B en estado digital
}


char getKey(void)

{
   char kp = 0;

   kp = Keypad_Key_Press ();                                                                               //Se instancia el metodo que lee una tecla y la guarda en kp

   if (!kp);                                                                                                               //Mientras kp es nula

   switch (kp)
   {
     case 1: return ‘1’; break;                                                                                       // 1

     case 2: return ‘2’; break;                                                                                      // 2

     case 3: return ‘3’; break;                                                                                      // 3

     case 4: return ‘A’; break;                                                                                      // A

     case 5: return ‘4’; break;                                                                                      // 4

     case 6: return ‘5’; break;                                                                                      // 5

     case 7: return ‘6’; break;                                                                                      // 6

     case 8: return ‘B’; break;                                                                                      // B

     case 9: return ‘7’; break;                                                                                      // 7

     case 10: return ‘8’; break;                                                                                    // 8

     case 11: return ‘9’; break;                                                                                      // 9

     case 12: return ‘C’; break;                                                                                      // C

     case 13: return ‘*’; break;                                                                                      // *

     case 14: return ‘0’; break;                                                                                      // 0

     case 15: return ‘#’; break;                                                                                      // #

     case 16: return ‘D’; break;                                                                                      // D

default: return 0;
     }
}

 

void main ()

{

char key;

  SisInit ();                                                                                                                  //Se manda a instanciar la configuración del PIC

  Keypad_Init ();                                                                                                          //Se manda a inicializar la libería para el teclado matricial

  while (1)                                                                                                                    //Bucle infinito
  { 
      key = getKey();

   if (key == ‘1’)                                                                                                              //Si kp es igual que el numero entre comilla simples
   {
     LED_On;                                                                                                                   //LED enciende
    }

    else if (key == ‘0’)                                                                                                        //Si no kp es igual a el numero entre comillas simples

    {                                                                                                                                   //LED se apaga

     LED_Off;
    }
   }
}

 

Descargas

Software XIDE v1.0

Descarga el software XIDE v1.0 

Práctica 10-PIC-XCU-16F

Descargar código en mikroC PRO for PIC de la práctica 10.

PIC18F

Descripción

En esta práctica se realiza el control de encendido y apagado del LED incluido en los módulos X-TRAINER P8 o X-TRAINER P8 DIP28, con el PIC18F25K22. También se utiliza un teclado matricial de 4x4, el cual esta 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 X-TRAINER P8 o X-TRAINER P8 DIP28. Comprar

1 x Microcontrolador PIC18F25K22. Comprar

1 x Módulo Programador XCU. Comprar

1 x Teclado matricial 4x4.

4 x Resistencias 1k Ohms. 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.

MikroC PRO for PIC. Descarga

XIDE v1.0 Descarga

 

Procedimiento

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

2.En el apartado de Descargas puedes encontrar los archivos del código fuente o bien copiarlo del apartado de Código.

3.Si descargaste el archivo omite este paso. Si copiaste el código, abre el compilador, pega el código en un nuevo proyecto, selecciona en el apartado de librerías la necesaria para esta práctica como se muestra en la siguiente imagen y realiza la compilación. En el siguiente link encontrarás un manual para compilar en MikroC PRO for PIC.

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
X-TRAINER P8 DIP28
X-TRAINER P8

 

X-TRAINER P8 DIP28

 

Código

Código

/*

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

FECHA: JUNIO 2019

*/

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

La práctica consiste en controlar el encendido y apagado de un LED incluido

en la tarjeta a través del uso de un teclado matricial de 4×4.

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

/*******************************************************************************
1) Project> Edit Project> Oscillator Selection> Internal Oscillator Block»

2) Project> Edit Project> Insertar 64000000 en «MCU Clock Frequency [MHz]» box

3) Tools> Options> Output> Output Settings> Marcar «Long HEX format»
********************************************************************************/

                                                                                                                //Se declaran las variables globales y librerías a utilizar
#define Led_On LATA1_bit = 1                                                                //Pin A1 como salida

#define Led_Off LATA1_bit = 0                                                               //Pin A1 como salida

char keypadPort at PORTB;                                                                       //Se declara la librería para el Keypad

 

void SisInit (void)                                                                                         //Se inicializa el PIC
{                                                                                                                        //Se configura el oscilador interno del 18F25K22

           OSCCON = 0x78;                                                                              //Se establece la frecuencia a 16 MHz

           PLLEN_bit = 1;                                                                                  //Se habilita el multiplicador de frecuencia x4

           while (PLLRDY_bit == 0);                                                             //Se crea un bucle donde de estabiliza la frecuencia

                                                                                                                          //Se configuran las entradas y salidas del PIC

           LATA1_bit = 0;                                                                                  //Este comando escribe 0 a la salida del puerto A1

           TRISA1_bit = 0;                                                                                //Se declara el puerto A1 como salida

           ANSA1_bit = 0;                                                                                 //Se declara el puerto A1 como señal digital

           ANSELB = 0;                                                                                      //Todas las salidas del puerto B sean digitales, 0.-digitales
}

                                                                                                                          //Función para leer el teclado matricial a tráves de un ciclo case
char getKey (void)                                                                                        //Función tipo char que posee todos los casos posibles
{

           char kp = 0;                                                                                         //Se inicializa la variable local kp como 0

           kp = Keypad_Key_Press();                                                             //Se instancia el método que lee la tecla y la aloja en kp

           switch (kp)                                                                                          //Se instancia y ejecuta un ciclo case con lo guardado en kp

                             {
                                case 1:                              

                                return ‘1’;                                                                        //1 usando código ASCII – 49

                                case 2:

                                return ‘2’;                                                                       //2 usando código ASCII – 50

                                case 3:

                                return ‘3’;                                                                       //3 usando código ASCII – 51

                                case 4:

                                return ‘A’;                                                                       //A usando código ASCII – 65

                                case 5:

                                return ‘4’;                                                                       //4 usando código ASCII – 52

                                case 6:

                                return ‘5’;                                                                       //5 usando código ASCII – 53

                                case 7:

                                return ‘6’;                                                                       //6 usando código ASCII – 54

                                case 8:

                                return ‘B’;                                                                       //B usando código ASCII – 66

                                case 9:

                                return ‘7’;                                                                        //7 usando código ASCII – 55

                                case 10:

                                return ‘8’;                                                                       //8 usando código ASCII – 56

                                case 11:

                                return ‘9’;                                                                       //9 usando código ASCII – 57

                                case 12:

                                return ‘C’;                                                                       //C usando código ASCII – 67

                                case 13:

                                return ‘*’;                                                                        //* usando código ASCII – 42

                                case 14:

                                return ‘0’;                                                                       //0 usando código ASCII – 48

                                case 15:

                                return ‘#’;                                                                       //# usando código ASCII – 35

                                case 16:

                                return ‘D’;                                                                      //D usando código ASCII – 68

                                default:

                                return 0;                                                                         //Si no coincide un caso, regresa a cero, vuelve a empezar el case

                              }
}

 

void main ()                                                                                                   //Se crea el programa principal
{
           char key;                                                                                              //Se crea una variable local tipo char

           SisInit ();                                                                                             //Se manda a instanciar la configuración del PIC

           Keypad_Init ();                                                                                  //Se manda a instanciar la librería del teclado matricial

           getKey ();                                                                                        //Se manda a instanciar la función que contiene todos los cases
           while (1)                                                                                              //Mientras sea verdadero el bucle se ejecuta infinitamente

                          {

                             key = getKey ();                                                               //Se manda a asignar la función a una variable para su uso

                             if (key == ‘1’)                                                                     //Si key es igual a la condición entre comillas

                                       {

                                          Led_On;                                                               //Led enciende

                                       }

                             else if (key == ‘0’)                                                            //Si no es igual key a la condición entre comillas

                                       {

                                          Led_Off;                                                               //Led de apaga

                                       }

                          }

}

 

Descargas

Software XIDE v1.0

Descarga el software XIDE v1.0 

Práctica 10 – XCU – PIC18F25K22

Descargar código en MikroC PRO for PIC de la práctica 10.

MPLAB X IDE
Programador PK3 LITE
Programador PK3 LITE

Descripción

En esta práctica se realiza el control de encendido y apagado del LED incluido en los módulos X-TRAINER P8 o X-TRAINER P8 DIP 40, con el PIC18F47K42. También se utiliza un teclado matricial de 4x4, el cual esta 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 X-TRAINER P8 o X-TRAINER P8 DIP40. Comprar

1 x Microcontrolador PIC18F47K42. Comprar

1 x Módulo Programador PK3 LITE. Comprar

1 x Teclado matricial 4x4.

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.

MPLAB X IDE. 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 MPLAB X IDE, pega el código en un nuevo proyecto y realiza la compilación. 

4. Programa el código en el microcontrolador. En el siguiente link encontrarás un manual para compilar y programar tu proyecto en MPLAB X IDE.

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
X-TRAINER P8 DIP 40
X-TRAINER P8

X-TRAINER P8 DIP 40

 

Código

Código

 

/*

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

FECHA: JUNIO 2019
*/

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

La práctica consiste en controlar el encendido y apagado de un LED incluido

en la tarjeta a través del uso de un teclado matricial de 4×4.

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

#pragma config FEXTOSC = OFF                                     //Oscilador  externo deshabilitado

#pragma config RSTOSC = HFINTOSC_64MHZ          //Frecuancia de 64MHz

#pragma config CLKOUTEN = OFF                                  //Función CLOKOUTEN deshabilitada

#pragma config WDTE = OFF                                             //Deshabilita WDT

 

#include <xc.h>

#include <stdint.h>

#define _XTAL_FREQ 64000000                                       //Defina la frecuencia de  64MHz

#define tiempo 25                                                                     //Variable del retardo

#define LED_High() LATAbits.LA1 = 1;                            //Declaración para encender el LED

#define LED_Low() LATAbits.LA1 = 0;                             //Declaración para encender el LED

 

void SisInit(void) { 

  OSCCON1 = 0X60;                                                               //NOSC HFINTOSC; NDIV 1;

  OSCCON3 = 0X00;                                                               //CSWHOLD procede; oscilador secundario opera en Low power;

  OSCEN = 0X00;                                                                     //Activación manual de osciladores

  OSCFRQ = 0X08;                                                                   //HFFRQ 64_MHz;

  OSCTUNE = 0X00;                                                                //TUN 0;

  LATAbits.LA1 = 0;                                                                //PIN en bajo

  TRISAbits.TRISA1 = 0;                                                        //PIN como salida

  ANSELAbits.ANSELA1 = 0;                                               //PIN como digital

  TRISB = 0x0F;                                                                      //PIN como salida

  ANSELB = 0x00;                                                                  //PIN como digital

  WPUB = 0xFF;                                                                      //Habilita PULL-UP en el puerto B
}

char TECLADO(void) {

  char TECLA; //Variable

  LATB = 0xE0;                                                                     //PINB4 en bajo

  if (PORTBbits.RB0 == 0) {                                                 //Lee si estado del PINB0 es igual 0

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

        while (PORTBbits.RB0 == 0)

        __delay_ms(tiempo);                                                      //Retardo

}    else if (PORTBbits.RB1 == 0) {                                      //Lee si estado del PINB1 es igual 0

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

          while (PORTBbits.RB1 == 0)

          __delay_ms(tiempo); //Retardo

}    else if (PORTBbits.RB2 == 0) {                                     //Lee si estado del PINB2 es igual 0

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

           while (PORTBbits.RB2 == 0)

            __delay_ms(tiempo);                                                 //Retardo

}    else if (PORTBbits.RB3 == 0) {                                     //Lee si estado del PINB3 es igual 0

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

            while (PORTBbits.RB3 == 0)

           __delay_ms(tiempo);                                                   //Retardo

}

      LATB = 0xD0;                                                                //PINB5 en bajo

    if (PORTBbits.RB0 == 0) {                                              //Lee si estado del PINB0 es igual 0

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

         while (PORTBbits.RB0 == 0)

          __delay_ms(tiempo);                                                   //Retardo

}    else if (PORTBbits.RB1 == 0) {                                     //Lee si estado del PINB1 es igual 0

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

           while (PORTBbits.RB1 == 0)

            __delay_ms(tiempo);                                                //Retardo

}     else if (PORTBbits.RB2 == 0) {                                   //Lee si estado del PINB2 es igual 0

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

             while (PORTBbits.RB2 == 0)

              __delay_ms(tiempo);                                              //Retardo

}       else if (PORTBbits.RB3 == 0) {                                //Lee si estado del PINB3 es igual 0

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

             while (PORTBbits.RB3 == 0)

             __delay_ms(tiempo);                                               //Retardo

}

     LATB = 0xB0;                                                                   //PINB6 en bajo

    if (PORTBbits.RB0 == 0) {                                              //Lee si estado del PINB0 es igual 0

           TECLA = ‘B’;                                                                // TECLA toma el valor de B

           while (PORTBbits.RB0 == 0)

            __delay_ms(tiempo);                                                  //Retardo

}     else if (PORTBbits.RB1 == 0) {                                   //Lee si estado del PINB1 es igual 0

            TECLA = ‘6’;                                                               // TECLA toma el valor de 6

            while (PORTBbits.RB1 == 0)

            __delay_ms(tiempo);                                                 //Retardo

}      else if (PORTBbits.RB2 == 0) {                                  //Lee si estado del PINB2 es igual 0

             TECLA = ‘5’;                                                               // TECLA toma el valor de 5

             while (PORTBbits.RB2 == 0)

              __delay_ms(tiempo);                                             //Retardo

}    else if (PORTBbits.RB3 == 0) {                                  //Lee si estado del PINB3 es igual 0

             TECLA = ‘4’;                                                            // TECLA toma el valor de 4

             while (PORTBbits.RB3 == 0)

              __delay_ms(tiempo);                                            //Retardo

}

 

LATB = 0x70; //PINB7 en bajo

  if (PORTBbits.RB0 == 0) {                                     //Lee si estado del PINB0 es igual 0

          TECLA = ‘A’;                                                     // TECLA toma el valor de A

          while (PORTBbits.RB0 == 0)

           __delay_ms(tiempo);                                      //Retardo

   }  else if (PORTBbits.RB1 == 0) {                       //Lee si estado del PINB1 es igual 0

           TECLA = ‘3’;                                                    // TECLA toma el valor de 3

            while (PORTBbits.RB1 == 0)

            __delay_ms(tiempo);                                      //Retardo

   }   else if (PORTBbits.RB2 == 0) {                       //Lee si estado del PINB2 es igual 0

            TECLA = ‘2’;                                                    // TECLA toma el valor de 2

            while (PORTBbits.RB2 == 0)

             __delay_ms(tiempo);                                    //Retardo

   }   else if (PORTBbits.RB3 == 0) {                       //Lee si estado del PINB3 es igual 0

            TECLA = ‘1’;                                                    // TECLA toma el valor de 1

            while (PORTBbits.RB3 == 0)

            __delay_ms(tiempo);                                      //Retardo

   }

return TECLA;

}

 

void main(void) {

   SisInit();

   char TECLA_PRESS;

   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 el LED

      }

   }

}

 


Descargas

 

Práctica 10 –PIC –PK3

Descargar código en MPLAB X IDE de la práctica 10.

 

 

AVR
MikroC PRO
Atmel Studio 7
MikroC PRO
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 está conectado en el puerto D. 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.

1 x Juego de cables Dupont. Comprar

1 x Protoboard de 830 puntos. Comprar

1 x Cable micro USB.


Software:

Windows 7 o posterior.

MikroC PRO for AVR. 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, 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, abre el compilador, pega el código en un nuevo proyecto, verifica en el apartado de librerías que este seleccionada la necesaria para esta práctica como se muestra en la siguiente imagen y realiza la compilación. En el siguiente link encontrarás un manual para compilar en MikroC PRO for AVR.

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-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.

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

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

              Registros de configuración:

              Project>Edit Project

              CKDIV8 = NO SPIEN = SI

              CKOUT = NO WDTON = NO

              RSTDISBL = NO EESAVE = SI

              DWEN = NO BOOTRST = NO

              Brown - out detection level al VCC = 2.7 V

              Boot Flash section size = 256 words...

              Start - up time PWRDWN / RESET: 16K CK / 14 CK + 65 ms

              Ext. Crystal Osc., Frequency > 8.0MHz, Show startup

              Insertar 16.000000 en "MCU Clock Frequency [MHz]" box

              En "Program Memory is used for": Application (Boot Flash Section is reserved)
   

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

unsigned short kp, cnt, oldstate = 0;
char keypadPort at PORTD;                                                                 //Modo de coneccion
char keypadPort_Direction at DDRD;

#define LED_ON PORTB |= (1<<PORTB5)                                         //Enciende el LED
#define LED_OFF PORTB &= ~(1<<PORTB5)                                   //Apaga el LED


void main() {
Keypad_Init();                                                                                    // Initializa Keypad

do {
kp = 0;                                                                                                 

do
   kp = Keypad_Key_Click();                                                        // Almacenar código clave en la variable kp
   while (!kp);
   switch (kp) {

   case 1: kp = 49; break; // 1                                                     // Descomenta este bloque para el teclado 4x4
   case 2: kp = 50; break; // 2
   case 3: kp = 51; break; // 3
   case 4: kp = 65; break; // A
   case 5: kp = 52; break; // 4
   case 6: kp = 53; break; // 5
   case 7: kp = 54; break; // 6
   case 8: kp = 66; break; // B
   case 9: kp = 55; break; // 7
   case 10: kp = 56; break; // 8
   case 11: kp = 57; break; // 9
   case 12: kp = 67; break; // C
   case 13: kp = 42; break; // *
   case 14: kp = 48; break; // 0
   case 15: kp = 35; break; // #
   case 16: kp = 68; break; // D

}

  if (kp ==49) {                                                                               //Comparamos si el valor de kp es igual a 49
   LED_ON;
  }
  if (kp ==48) {                                                                           //Comparamos si el valor de kp es igual a 48
    LED_OFF;
  }

} while (1);
}

 

 

Descargas

Práctica 10-XCU-AVR

Descargar el código en mikroC PRO for AVR de la práctica 10.

Atmel Studio 7
Programador MKII LITE
Programador MKII LITE

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 MKII LITE. Comprar

1 x Módulo X-AVR. Comprar

1 x Teclado Matricial 4x4.

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 y programar tu proyecto en Atmel Studio 7.

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-MKII

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

ARDUINO

Descripción

En esta práctica se realiza el control de encendido y apagado del LED incluido en los módulos X-UNO, X-MEGA o X-NANO. También se utiliza un teclado matricial de 4x4, el cual esta conectado en el puerto D. 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, X-MEGA o X-NANO. Comprar

1 x Módulo Programador XCU. Comprar

1 x Teclado Matricial 4x4. 

1 x Juego de cables Dupont. Comprar

1 x Protoboard de 830 puntos. Comprar

1 x Cable micro USB.

 

Software:

Windows 7 o posterior.

Arduino IDE. 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, abre el software Arduino IDE, pega el código en un nuevo proyecto, 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 y programar en Arduino IDE.

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

 

Diagrama esquemático

 

X-UNO
X-MEGA
X-NANO
X-UNO

X-MEGA

X-NANO

 

Código

Código

/*

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

FECHA: JUNIO 2019

*/

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

La práctica consiste en controlar el encendido y apagado de un LED incluido

en la tarjeta a través del uso de un teclado matricial de 4×4.

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

#include "Keypad.h"

int LED = 13;

 const byte rowsCount = 4;                                                                            //indica el número de filas

const byte columnsCount = 4;                                                                     //indica el número de columnas

char keys[rowsCount][columnsCount] =

{

                                    {'1', '2', '3', 'a'}, 

                                    {'4', '5', '6', 'b'},

                                    {'7', '8', '9', 'C'},

                                    {'*', '0', '#', 'D'},

};

        const byte rowPins[rowsCount] = {7, 6, 5, 4};                                     //Indica los pines usados para las filas del teclado

        const byte columnsPins[columnsCount] = {3, 2, 1, 0};                     //Indica los pines usados para las columnas del teclado

       Keypad keypad = Keypad(makeKeymap(keys), rowPins, columnsPins, rowsCount, columnsCount);

void setup()

{

              pinMode (LED, OUTPUT);

}

void loop()

{

            char key = keypad.getKey();                                                          //Almacena el caracter de la tecla que se presiona en la variable key

      if (key == '1')                                                                                               //Verifica si el caracter presionado es un "1"

     {

             digitalWrite (LED, HIGH);                                                              // Enciende el LED

      } else if (key == '0')                                                                                   //Verifica si el caracter presionado es un "0"

           {

                  digitalWrite (LED,                                                                        //Apaga el LED

            }

}

 

Descargas

Práctica 10 – Arduino

Descarga código en Arduino de la práctica 10.

Fecha

agosto 13, 2019

Categoría

Prácticas XIDE

× WhatsApp