PRACTICA 11 – COMUNICACIÓN SPI

Ruiz Valencia Fernando Isai,Cabañez Palacios Leonardo Alexander

Instituto Politécnico Nacional, Escuela Superior de Ingeniería Mecánica y Eléctrica Unidad Culhuacán
Departamento Ingeniería en Comunicaciones y Electrónica
Ciudad de México, México
[email protected], [email protected]

Abstract This report presents the design and implementation of programa y módulos periféricos avanzados. Su versatilidad y
a system using the Serial Peripheral Interface (SPI) protocol to funcionalidad robusta lo hacen ideal para una amplia variedad
control an 8x32 LED matrix with a PIC18F45K50 de aplicaciones, como sistemas embebidos, automatización,
microcontroller. The primary goal of the project was to create a control de potencia y protocolos de comunicación. Entre sus
scrolling "IPN" message displayed on the LED matrix. The
características clave, incluye módulos
system integrates the microcontroller, configured as the SPI
master, with the LED matrix controlled via a MAX7219 driver Capture/Compare/PWM (CCP) que permiten la generación
as the SPI slave. precisa de señales PWM para el control eficiente de
The implementation involves initializing the SPI protocol, dispositivos externos [1].
designing the data frames required for controlling the LED
matrix, and generating the scrolling text effect. The project
B. PickIt 3
highlights the flexibility and efficiency of SPI communication, El programador PICkit 3 es un dispositivo de hardware
enabling synchronized data transfer between the utilizado para programar y depurar microcontroladores de la
microcontroller and the LED matrix. The MAX7219 simplifies familia PIC (Peripheral Interface Controller) fabricados por
the control of multiple LEDs by handling the multiplexing and Microchip. Permite cargar firmware (programas) en el
reducing the number of required microcontroller pins. microcontrolador y también se puede utilizar para depurar
programas en tiempo real, lo que facilita el desarrollo y la
This system demonstrates practical concepts of SPI
communication, timing synchronization, and real-time visual depuración de software para sistemas embebidos basados en
feedback, making it an excellent educational exercise in microcontroladores PIC[2].
embedded systems design. The results validate the robustness of C. Matriz Led 8x32
SPI for controlling peripheral devices, with potential
applications in signage, interactive displays, and embedded Un LCD 20x4 es un módulo de pantalla capaz de mostrar
lighting systems. 20 caracteres por línea en cuatro líneas. Emplea un
controlador estándar HD44780, lo que lo hace fácil de
Keywords—PIC18F45k50 SPI Protocol, LED Matrix, conectar a microcontroladores. Su flexibilidad y bajo
LM35, Embedded Systems. consumo de energía lo convierten en una excelente opción
para sistemas embebidos. En este proyecto, el LCD muestra
I. INTRODUCCIÓN mensajes como "Transmission" y "Reception" para
proporcionar retroalimentación en tiempo real sobre el
En esta práctica se diseñó un sistema para controlar una intercambio de datos [3].
matriz de LEDs de 8x32 utilizando un microcontrolador
PIC18F45K50 y el protocolo de comunicación SPI. El D. Controlador MAX7219
objetivo principal fue implementar un letrero que despliegue El MAX7219 es un circuito integrado diseñado para manejar
la palabra "IPN" en la matriz, con un efecto de matrices de LEDs o displays de 7 segmentos. Utiliza el
desplazamiento continuo. protocolo SPI para recibir datos, que se almacenan en
registros internos para controlar el estado de los LEDs.
El protocolo SPI permite la comunicación serial síncrona
entre el microcontrolador y el controlador MAX7219, E. Push Button
encargado de gestionar la matriz de LEDs. Este controlador Un Push Button o pulsador es un dispositivo utilizado
facilita el manejo de grandes cantidades de LEDs al integrar para realizar cierta función. Los botones son de diversas
funciones de multiplexado y registro de desplazamiento, formas y tamaños y se encuentran en todo tipo de
reduciendo la complejidad del diseño electrónico. dispositivos, aunque principalmente en aparatos eléctricos y
electrónicos. Son por lo general activados, al ser pulsados
con un dedo y permiten el flujo de corriente mientras son
A. PIC18F45K50 accionados. Cuando ya no se presiona sobre él vuelve a su
El PIC18F45K50 es un microcontrolador de 8 bits posición de reposo [4].
diseñado para aplicaciones de alto rendimiento, con una
velocidad de reloj de hasta 48 MHz, 32 KB de memoria de
 II. CODIFICACIÓN int I17[8]= {0XFC, 0XFC, 0X8C, 0X8C, 0XFC,
0XFC, 0X80, 0X80};
Se hizo la codificación del PIC18F45K50 de la siguiente int I18[8]= {0XFE, 0XFE, 0XC6, 0XC6, 0XFE,
manera. 0XFE, 0XC0, 0XC0}; // LETRA P
int I19[8]= {0X7F, 0X7F, 0X63, 0X63, 0X7F, 0X7F,
#include <xc.h> 0X60, 0X60};
#include <stdio.h> int I20[8]= {0X3F, 0X3F, 0X31, 0X31, 0X3F, 0X3F,
#include "registro.h" 0X30, 0X30};
#define _XTAL_FREQ 16000000 int I21[8]= {0X1F, 0X1F, 0X18, 0X18, 0X1F, 0X1F,
//#include "flex_lcd.h" 0X18, 0X18};

void iniciarSPI(); int I22[8]= {0X8F, 0X8F, 0X0C, 0X0C, 0X0F, 0X0F,
void escribir(unsigned dato); // dato a transmitir 0X8C, 0X8C};
void MAX(); int I23[8]= {0XC7, 0XC7, 0X06, 0X06, 0X07, 0X07,
0XC6, 0XC6};
int I24[8]= {0XE3, 0XE3, 0X83, 0X83, 0X83, 0X83,
void main() { 0XE3, 0XE3};
OSCCON = 0b01110011; int I25[8]= {0XF1, 0XF1, 0XC1, 0XC1, 0XC1, 0XC1,
0XF1, 0XF1}; //------------
// Definición de caracteres "IPN" para una matriz 8x32

int I[8]= {0X80, 0X80, 0X80, 0X80, 0X80, 0X80,

0X80, 0X80}; //-----------
int I2[8]= {0XC0, 0XC0, 0XC0, 0XC0, 0XC0, 0XC0, int I26[8]= {0XF8, 0XF8, 0X60, 0X60, 0X60, 0X60,
0XC0, 0XC0}; 0XF8, 0XF8};
int I3[8]= {0X60, 0X60, 0X60, 0X60, 0XE0, 0XE0, int I27[8]= {0XFC, 0XFC, 0X30, 0X30, 0X30, 0X30,
0X60, 0X60}; 0XFC, 0XFC};
int I4[8]= {0X30, 0X30, 0X30, 0XB0, 0XF0, 0X70, int I28[8]= {126, 126, 24, 24, 24, 24, 126, 126}; //
0X30, 0X30}; letra I
int I5[8]= {0X18, 0X18, 0X98, 0XD8, 0X78, 0X38, int I29[8]= {0X3F, 0X3F, 0X0C, 0X0C, 0X0C, 0X0C,
0X18, 0X18}; 0X3F, 0X3F};
int I6[8]= {0X0C, 0X8C, 0XCC, 0X6C, 0X3C, 0X1C, int I30[8]= {0X1F, 0X1F, 0X06, 0X06, 0X06, 0X06,
0X0C, 0X0C}; 0X1F, 0X1F};
int I7[8]= {0X86, 0XC6, 0XE6, 0XB6, 0X9E, 0X8E, int I31[8]= {0X0F, 0X0F, 0X03, 0X03, 0X03, 0X03,
0X86, 0X86}; // LETRA N 0X0F, 0X0F};
int I8[8]= {0XC3, 0XE3, 0XF3, 0XDB, 0XCF, 0XC7, int I32[8]= {0X07, 0X07, 0X01, 0X01, 0X01, 0X01,
0XC3, 0XC3}; 0X07, 0X07};
int I9[8]= {0X61, 0X71, 0X79, 0X6D, 0X67, 0X63, int I33[8]= {0X03, 0X03, 0X00, 0X00, 0X00, 0X00,
0X61, 0X61}; 0X03, 0X03};
int I10[8]= {0X30, 0X38, 0X3C, 0X36, 0X33, 0X31, int I34[8]= {0X01, 0X01, 0X00, 0X00, 0X00, 0X00,
0X30, 0X30}; 0X01, 0X01}; //----------
int I11[8]= {0X18, 0X1C, 0X1E, 0X1B, 0X19, 0X18,
0X18, 0X18};

int I12[8]= {0X8C, 0X8E, 0X8F, 0X8D, 0X8C, 0X8C, int I35[8]= {0X00, 0X00, 0X00, 0X00, 0X00, 0X00,
0X0C, 0X0C}; 0X00, 0X00}; //ESPACIO
int I13[8]= {0XC6, 0XC7, 0XC7, 0XC6, 0XC6,
0XC6, 0X06, 0X06};
int I14[8]= {0XE3, 0XE3, 0X63, 0X63, 0XE3, 0XE3, //ASIGNACIONES DEL PUNTERO
0X03, 0X03};
int I15[8]= {0XF1, 0XF1, 0X31, 0X31, 0XF1, 0XF1, int* cI[90];
0X01, 0X01}; //------------
for (int x=1;x<25;x++)
{
cI[x] = I35;
int I16[8]= {0XF8, 0XF8, 0X18, 0X18, 0XF8, 0XF8, }
0X00, 0X00};
cI[1+24] = I; LATAbits.LA5 = 0;
cI[2+24] = I2;
cI[3+24] = I3; // Enviar columna de "1"
cI[4+24] = I4; escribir(i);
cI[5+24] = I5; escribir(ci[i - 1]);
cI[6+24] = I6;
cI[7+24] = I7; // Enviar columna "2"
cI[8+24] = I8; escribir(i);
cI[9+24] = I9; escribir(ci2[i - 1]);
cI[10+24] = I10;
cI[11+24] = I11; // Enviar columna a "3"
cI[12+24] = I12; escribir(i);
cI[13+24] = I13; escribir(ci3[i - 1]);
cI[14+24] = I14;
cI[15+24] = I15; // Enviar columna 4
cI[16+24] = I16; escribir(i);
cI[17+24] = I17; escribir(ci4[i - 1]);
cI[18+24] = I18;
cI[19+24] = I19; LATAbits.LA5 = 1;
cI[20+24] = I20; delay_ms(1);
cI[21+24] = I21; }
cI[22+24] = I22; delay_ms(45);
cI[23+24] = I23;
cI[24+24] = I24; }
cI[25+24] = I25; }
cI[26+24] = I26; }
cI[27+24] = I27;
cI[28+24] = I28; void iniciarSPI() {
cI[29+24] = I29; TRISBbits.TRISB3 = 0;
cI[30+24] = I30; TRISAbits.TRISA5 = 0;
cI[31+24] = I31; TRISBbits.TRISB1 = 0;
cI[32+24] = I32;
cI[33+24] = I33; LATBbits.LB3=0;
cI[34+24] = I34; LATBbits.LB1=0;
LATAbits.LA5=0;

for (int x=59;x<91;x++) ANSELC = 0x00;

{ ANSELA = 0x00;
cI[x] = I35; SSP1STAT = 0b00000000;
} SSP1CON1 = 0b00110000;
}

iniciarSPI(); void escribir(unsigned dato) {

MAX(); SSP1BUF = dato; // buffer de transmisión
MAX(); while (PIR1bits.SSPIF == 0);
MAX(); PIR1bits.SSPIF = 0;
MAX(); }

while (1) { void MAX() {

LATAbits.LA5 = 0;
for (int c=1; c<59; c++) escribir(0x09); // modo decodificador
{ escribir(0x00);
int* ci=cI[c+24]; LATAbits.LA5 = 1;
int* ci2=cI[c+16];
int* ci3=cI[c+8]; LATAbits.LA5 = 0;
int* ci4=cI[c]; escribir(0x0A); // intensidad del brillo (PWM)
escribir(0x07);
LATAbits.LA5 = 1;
for (int i = 1; i < 9; i++) {
 LATAbits.LA5 = 0; El uso de punteros permitió pudo reducir significativamente
escribir(0x0B); // escaneo del limite del formato de la redundancia en el código, facilitando el acceso dinámico a
registro las columnas de datos, pero también añadió un nivel de
escribir(0x07); complejidad al sistema. La correcta configuración del
LATAbits.LA5 = 1; MAX7219 y su integración con el PIC18F45K50 fueron
fundamentales para lograr un funcionamiento estable.
LATAbits.LA5 = 0;
escribir(0x0C); V. REFERENCIAS
escribir(0x01); // no apagar la matriz de puntos
LATAbits.LA5 = 1; [1] “PIC18F45K50”, Microchip. Disponible:
} https://www.microchip.com/en-us/product/pic18f45k50
[Consultado: 07/01/2025]
III. RESULTADOS
Se armo el siguiente circuito proporcionado por el [2] “PICkit 3 Programador”, Unit Electronics. Disponible:
profesor para esta práctica en Protoboard, donde se usó el https://uelectronics.com/producto/pickit-3-programador-
pic18f45k50, junto con el controlador MAX7219 universal-pic-con-interfaz-icsp/ [Consultado: 07/01/2025]

[3] “MAX7219 Letrero Electrónico Matriz 8×32”, Unit

Electronics. Disponible:
https://uelectronics.com/producto/max7219-letrero-
electronico-matriz-8x32/ [Consultado: 07/01/2025]

[4] “Push Button 2 Pines MicroSwitch”, Unit Electronics.

Disponible: https://uelectronics.com/producto/push-button-
2-pines-microswitch/ [consultado:05/01/2025].

Fig. 1 Diagrama del Circuito

Fig. 2 Armado del Circuito

IV. CONCLUSION
El desarrollo de esta práctica presentó una
complejidad considerable debido al manejo de la matriz de
LEDs de 8x32, que requirió implementar un sistema de
control eficiente mediante el protocolo SPI. La generación
del letrero "IPN" con un efecto de desplazamiento dinámico
involucró el uso de punteros para gestionar las diferentes
columnas de datos en tiempo real. Este enfoque resultó
crucial para optimizar el código, ya que la estructura de la
matriz tenia un control preciso de cada LED y su
sincronización.