Curso-Taller programación

en lenguaje C para
microcontroladores PIC

PIC16F877
 Características
• Velocidad de operación: hasta 20 MHz de
reloj
• 8K x 14 bits por palabra de memoria de
programa FLASH
• 368 x 8 bytes de memoria de datos (RAM)
• 256 x 8 bytes de memoria de datos
EEPROM
 Características (2)
• 14 fuentes de interrupciones
• Memoria de pila (stack) de 8 niveles de
profundidad
• Protecciones:
– Power-on Reset (POR)
– Power-up Timer (PWRT)
– Oscillator Start-up Timer (OST)
– Watchdog Timer (WDT) independiente del
cristal.
 Puertos de entrada y salida
• PORTA ( RA5, RA4, RA3, RA2, RA1, RA0 )
• PORTB ( RB7, RB6, RB5, RB4, RB3, RB2, RB1, RB0 )
• PORTC ( RC7, RC6, RC5, RC4, RC3, RC2, RC1,
RC0 )

• PORTD ( RD7, RD6, RD5, RD4, RD3, RD2, RD1,

RD0 )

• PORTE ( RE2, RE1, RE0 )

 Características (periféricos)
• Timer 0: timer/counter de 8 bits con un pre-
escalador de 8 valores.
• Timer 1: 16-bit timer/counter con pre-escalador
• Timer 2: 8-bit timer/counter con registro de
estado de 8-bit, pre-escalador y post-escalador
• Dos módulos de Capture, Compare, PWM
– Capture es de 16-bit, max. resolución es 12.5 ns
– Compare es de 16-bit, max. resolución es 200 ns
– PWM max. resolución de 10-bit
 Características (periféricos 2)
• Convertidor analógico a digital de 10-bit
multi-canal
• Puerto serial síncrono (SSP) con SPI. (modo
maestro) e I2C (maestro/esclavo)
• Transmisor-Receptor síncrono-asíncrono
universal (USART/SCI) con 9-bit
• Puerto paralelo esclavo (PSP) con 8-bits de
ancho, con terminales de control RD, WR y
CS
 Arquitectura interna
• Arquitectura HARVARD.
• Buses separados (datos e instrucciones).
• Memoria de programa : 14 bits.
• Memoria de datos: 8 bits.
• Recursos mapeados en memoria de
datos.
Arquitectura interna
Terminales fisicas
 PUERTOS
Puerto # funciones Funciones
PORTA 3 Entradas digital
Salidas digital
Entradas analógicas
PORTB 2 Entradas digital
Salidas digital

PORTC 3 Entradas digital

Salidas digital
Medios de comunicación
PORTD 3 Entradas digital
Salidas digital
Puerto paralelo esclavo
PORTE 4 Entradas digital
Salidas digital
Entradas analógicas
Control del puerto paralelo esclavo
 FUNCIONES PORTA
Terminal Funciones
RA0 Ent. Digital Sal. Digital Ent. Analógica

RA1 Ent. Digital Sal. Digital Ent. Analógica

RA2 Ent. Digital Sal. Digital Ent. Analógica VREF -

RA3 Ent. Digital Sal. Digital Ent. Analógica VREF +

RA4 Ent. Digital Sal. Digital Ent. contador 1

RA5 Ent. Digital Sal. Digital Ent. Analógica

 FUNCIONES PORTB
Terminal Funciones
RB0 Ent. Digital Sal. Digital Ent. Interrupción 0

RB1 Ent. Digital Sal. Digital

RB2 Ent. Digital Sal. Digital

RB3 Ent. Digital Sal. Digital PGM ( función LVP )

RB4 Ent. Digital Sal. Digital

RB5 Ent. Digital Sal. Digital

RB6 Ent. Digital Sal. Digital PGC ( función LVP )

RB7 Ent. Digital Sal. Digital PGD ( función LVP )

 FUNCION PORTC
Terminal Funciones
Ent. Digital Sal. Digital Sal. Osc timer 1 Ent. Contador 1
RC0
Ent. Digital Sal. Digital Ent. Osc Timer 1 Captura/Comp/PWM 1
RC1
Ent. Digital Sal. Digital Captura/Comp/PWM 2
RC2
Ent. Digital Sal. Digital Reloj sincrono SPI Reloj síncrono I2C
RC3
Ent. Digital Sal. Digital Datos entrada SPI Datos I2C
RC4
Ent. Digital Sal. Digital Datos salida SPI
RC5
Ent. Digital Sal. Digital Transmisión USART
RC6
Ent. Digital Sal. Digital Recepción USART
RC7
 FUNCIONES PORTD
Terminal Funciones
RD0 Ent. Digital Sal. Digital Bit 0 puerto paralelo esclavo

RD1 Ent. Digital Sal. Digital Bit 1 puerto paralelo esclavo

RD2 Ent. Digital Sal. Digital Bit 2 puerto paralelo esclavo

RD3 Ent. Digital Sal. Digital Bit 3 puerto paralelo esclavo

RD4 Ent. Digital Sal. Digital Bit 4 puerto paralelo esclavo

RD5 Ent. Digital Sal. Digital Bit 5 puerto paralelo esclavo

RD6 Ent. Digital Sal. Digital Bit 6 puerto paralelo esclavo

RD7 Ent. Digital Sal. Digital Bit 7 puerto paralelo esclavo

 FUNCIONES PORTE
Terminal Funciones
RE0 Ent. Digital Sal. Digital Ent. Analógica Lectura PSP

RE1 Ent. Digital Sal. Digital Ent. Analógica Escritura PSP

RE2 Ent. Digital Sal. Digital Ent. Analógica Habilitación PSP

 Tipos de datos
Tipo bytes Rango
(unsigned) char 1 0 .. 255
signed char 1 - 128 .. 127
(signed) short (int) 1 - 128 .. 127
unsigned short (int) 1 0 .. 255
(signed) int 2 -32768 .. 32767
unsigned (int) 2 0 .. 65535
(signed) long (int) 4 -2147483648 .. 2147483647
unsigned long (int) 4 0 .. 4294967295
 Tipos de datos 2
Tipo bytes Rango

float 4 ±1.17549435082 x 10-38 .. ±6.80564774407 x 1038

double 4 ±1.17549435082 x 10-38 .. ±6.80564774407 x 1038

long double 4 ±1.17549435082 x 10-38 .. ±6.80564774407 x 1038

 Asignación de datos
• Decimal
– int i = 10; /* decimal 10 */
– int j = -10; /* decimal -10 */
– int p = 0; /* decimal 0 */

• Hexadecimal
– short x = 0x37; /* decimal 55 */
– short y = 0x7F; /* decimal 127 */
– int z = 0x125; /* decimal 293 */
 Asignación de datos
• Octal
– int m = 023; /* 19 */
– short n = 016; /* 14 */

• Binario
– char dato = 0b00001111;
– short dat = 0b10101010;
– unsigned char sig = 0b11001100;

• ASCII
– char dat = ‘a’;
– char m = ‘5’;
 Registros asociados
Entrada/salida Configuración
• PORTA TRISA
• PORTB TRISB
• PORTC TRISC
• PORTD TRISD
• PORTE TRISE
 Entrada o salida
• SALIDA DE DATOS : 0
• ENTRADA DE DATOS: 1

• La asignación es individual
correspondiente a cada terminal del
puerto.
 Acceso individual de bits 1
• mikroC te permite acceso individual en variables de 8 bits
(char and unsigned short). Simplemente usando el
selector (.) seguido de uno de los identificadores F0, F1,
… , F7. Siendo F7 el bit mas significativo.

• Ejemplo:
PORTC.F0 = 1;
PORTD.F5 = 0;
PORTB.F7 = 1;

Los identificadores F0–F7 no se reconocen en minúsculas.

NOTA: Entre dos accesos a bits se debe tener un retardo mínimo de 2
microsegundos.
 Entrada o salida
• Si deseamos configurar el puerto C con la
siguiente asignación:
RC0 entrada
RC1 entrada
RC2 entrada
RC3 entrada
RC4 salida
RC5 salida
RC6 salida
RC7 salida

• Posibles instrucciones a utilizar

TRISC = 0b’00001111’; o
TRISC = 0x0F; o
TRISC = 15;
 Entrada o salida
• Si deseamos configurar el puerto D con la
siguiente asignación:
RD0 entrada
RD1 salida
RD2 entrada
RD3 salida
RD4 entrada
RD5 salida
RD6 entrada
RD7 salida

• Debemos utilizar cualquiera de las siguientes instrucciones

TRISD = 0b’01010101’; o
TRISD = 0x55; o
TRISD = 85;
 Entrada o salida
• Si deseamos configurar el puerto A con la siguiente
asignación:
RA0 salida
RA1 salida
RA2 salida
RA3 salida
RA4 entrada
RA5 entrada
RA6 entrada

• Posibles instrucciones a utilizar

ADCON1 = 6; \\ instrucción indispensable para usar el
puerto A y el puerto E como entrada o
salida de datos digitales
TRISA = 0b’01110000’; o
TRISA = 0x70; o
TRISA = 112;
 ADCON1
ADCON1 = 0 0 0 0 0 1 1 0

ADCON1 = 6 ;
 Delay_ms (retardo por software)
• Descripción: Crea un retardo por software dado el tiempo en
milisegundos (constante). El rango de constantes aplicables a la
función depende de la frecuencia del oscilador. Es una función
interna; El código es generado en el lugar donde se hace la
llamada, así que la llamada de esta función no cuenta dentro del
limite de llamadas anidadas.

• void Delay_ms(const time_in_ms)

• Ejemplo:
Generar un retardo de 1 segundo

Delay_ms(1000); /* Pausa de un segundo */

 Estructura de un programa en C
( ciclo while )
// Definición de variables globales

// Definición de funciones

void main(void)
{
// Definición de variables locales

// Configuración de registros (recursos y puertos)

// ciclo infinito
while ( 1 )
{

// Programa de usuario

}
}
 Estructura de un programa en C
( ciclo for )
// Definición de variables globales

// Definición de funciones

void main(void)
{
// Definición de variables locales

// Configuración de registros (recursos y puertos)

// ciclo infinito
for ( ; ; )
{

// Programa de usuario

}
}
 Estructura de un programa en C
( ciclo do - while )
// Definición de variables globales

// Definición de funciones

void main(void)
{
// Definición de variables locales

// Configuración de registros (recursos y puertos)

// ciclo infinito
do
{

// Programa de usuario

} while ( 1 ) ;
}
 1.- Encendido de LED
• Crear un programa que encienda y
apague un led, ubicado en la terminal RD7
del puerto D. El tiempo de encendido es
de 1000 milisegundo y el de apagado de
300 milisegundos.
 Encendido de LED (algoritmo)
1. Configurar el bit 7 del puerto D como salida de
datos
2. Encendido del led
3. Retardo por software de 1000 milisegundos.
4. Apagado del led
5. Retardo por software de 300 milisegundos
6. Repetir el paso 2
Encendido de LED (diagrama de flujo)
Led

Configura bit del

puerto como salida Apaga bit

Enciende bit Retardo de 300 ms

Retardo de 1000ms
Encendido de LED (esquemático)
Encendido de LED (programa)
void main ( void )
{
TRISD.F7 = 0;
while( 1 )
{
PORTD.F7 = 1;
Delay_ms( 1000 );
PORTD.F7 = 0;
Delay_ms( 300 );
}
}
Encendido de LED (programa 2)
void main ( void )
{
TRISD = 0;
while( 1 )
{
PORTD = 0x80;
Delay_ms( 1000 );
PORTD = 0;
Delay_ms( 300 );
}
}
 Ejercicios propuestos 1
1. El alumno encenderá y apagara en forma
alternada dos led’s ubicados en los bit’s 2 y 3
del puerto B. Los retardos serán de 500
milisegundos (ambos). Usando asignación
directa a bits.

2. El alumno encenderá y apagara un led

ubicado en el bit 5 del puerto C. Los retardos
serán de 100 milisegundos y 2 segundos,
respectivamente. Usando asignación de byte.
 2.- Luces secuenciales
• Programa que envíe la siguiente secuencia de
datos al puerto de salida D.

Secuencia :
– 00000001
– 00000010
– 00000100
– 00001000
– 00010000
– 00100000
– 01000000
– 10000000
 Luces secuenciales (algoritmo)
1. Configuración de puerto como salida de datos.
2. Envío de primer dato al puerto de salida
3. Envío de segundo dato al puerto de salida
4. Envío de tercer dato al puerto de salida
.
.
.
9. Envío de ultimo dato al puerto de salida
10. Regresar a 2
Luces secuenciales (diagrama de flujo)
Luces

Configura puerto
como salida Envía 00000100 Envía 00100000

Envía 00000001 Envía 00001000 Envía 01000000

Envía 00000010 Envía 00010000 Envía 10000000

Luces secuenciales (esquemático)
Luces secuenciales (programa)
void main(void)
{
TRISD = 0; // CONFIGURACION COMO PUERTO DE SALIDA

while ( 1 ) // CICLO INFINITO

{
PORTD = 0b00000001; // ENVIA PRIMER DATO
Delay_ms(500);
PORTD = 0b00000010; // ENVIA SEGUNDO DATO
Delay_ms(500);
PORTD = 0b00000100; // ENVIA TERCER DATO
Delay_ms(500);
PORTD = 0b00001000;
Delay_ms(500);
PORTD = 0b00010000;
Delay_ms(500);
PORTD = 0b00100000;
Delay_ms(500);
PORTD = 0b01000000;
Delay_ms(500);
PORTD = 0b10000000;
Delay_ms(500);
}
}
 Ejercicios propuestos 2
1. El alumno enviara una secuencia de datos distinta por
el puerto B, utilizando retardos por software de
distintas duraciones, con incrementos de 100
milisegundos entre si.

2. El alumno enviara la secuencia de datos por el puerto

A, utilizando retardos por software con duración de 800
milisegundos.
100001
010010
001100
010010
100001
 Arreglos (definiciones)
#define MAX 50
int vector_one[10]; /* arreglo de 10 enteros */
float vector_two[MAX]; /* arreglo 50 flotantes */
float vector_three[MAX - 20]; /* arreglo 30 flotantes */
char numero[5];
short dato[8];
long temperatura[15];
unsigned peso[7];
unsigned short d[3];
 Arreglos (Inicializando)
/* Arreglo el cúal contiene el número de días de cada mes */

int days[12] = {31,28,31,30,31,30,31,31,30,31,30,31};

/* La declaraciones es identica a la anterior */

int *days = {31,28,31,30,31,30,31,31,30,31,30,31};

/* Las dos declaraciones son identicas */

const char msg1[ ] = {'T', 'e', 's', 't', '\0'};

const char msg2[ ] = "Test";

 Condicionante if
if (expresión) conjunto 1 [else conjunto 2]

• Cuando la expresión evaluada es verdadera,

Las instrucciones del conjunto 1 son ejecutadas.
Si la expresión es falso, las instrucciones del
conjunto 2 es ejecutada. La expresión debe ser
evaluada a un valor entero. Los paréntesis que
encierra la expresión son obligatorios.
• La palabra especial “else conjunto 2” es
opcional.
 Símbolos de condición
Operador Operación
== igual
!= no igual
> mayor que
< menor que
>= mayor que o igual a
<= menor que o igual a
 3.- Luces con arreglo (algoritmo)
1. Configuración de puerto como salida.
2. Inicializa apuntador.
3. Envío de dato apuntado.
4. Incrementa apuntador.
5. Si apuntador es mayor que o igual a 8
inicia el apuntador.
6. Regresa a 3.
Luces con arreglo (diagrama de flujo)
Luces

Configura puerto Incrementa

como salida apuntador

Limpia apuntador si
apuntador ≥ 8 Limpia
apuntador

Envía dato
no
apuntado
 Luces con arreglo (programa)
short dato [ 8 ] = {1, 2, 4, 8, 16, 32, 64, 128};
short apunta;

void main(void)
{
TRISB = 0; // Configura puerto
apunta = 0; // Limpia apuntador
while(1) // Ciclo infinito
{
PORTB = dato [ apunta ]; // Envía dato
Delay_ms(1000);
apunta ++; // Incrementa apuntador
if ( apunta > = 8 ) // Si apuntador ≥ 8
apunta = 0; // Limpia apuntador
}
}
 Ejercicios propuestos 3
1. El alumno enviara una secuencia por el
puerto B usando los valores almacenado
en un arreglo.
00000011
00000110
00001100
00011000
00110000
01100000
11000000
 Operadores a nivel de bits
Operador operacion
AND; compara pares de bits y regresa 1 si ambos son 1’s,
& de otra manera regresa 0.

OR (inclusive); compara pares de bits y regresa 1 si uno o

| ambos son 1’s, de otra manera regresa 0.

OR (exclusiva); compara pares de bits y regresa 1 si los

^ bits son complementarios, de otra manera regresa 0.

Complemento (unitario); invierte cada bit

~
<< Corrimiento hacia la izquierda; mueve los bits hacia la
izquierda, descartando el bit mas a la izquierda y
asignando ceros al bit a la derecha.
>> Corrimiento hacia la derecha; mueve los bits hacia la
derecha, descartando el bit mas a la derecha y asignando
ceros al bit a la izquierda.
 Ejemplos operadores lógicos
0x1234 & 0x5678 /* Igual 0x1230 */

porque...
0x1234 : 0001 0010 0011 0100
0x5678: 0101 0110 0111 1000
-----------------------------------
&: 0001 0010 0011 0000 esto es, 0x1230

/* De forma similar: */

0x1234 | 0x5678; /* Igual 0x567C */

0x1234 ^ 0x5678; /* Igual 0x444C */
~ 0x1234; /* Igual 0xEDCB */
 Ejemplos a nivel de bits
000001 << 5; /* Igual 000040 */
0x3801 << 4; /* Igual 0x8010, sobreflujo! */

0x02F6 >> 4; /* Igual 0x002F */

0xFF56 >> 4; /* Igual 0x0FF5 */

Corrimiento a la derecha division entre 2n.

Corrimiento a la izquierda producto por 2n.
 4.- Luces con desplazamiento
(algoritmo)
1. Configuración de puerto como salida.
2. Inicializa variable.
3. Envía valor de la variable al puerto.
4. Modifica la variable.
5. Si variable es cero, Inicializa la variable.
6. Regresa a 3.
Luces con desplazamiento (diagrama de
flujo)

Luces

Configura puerto Modifica

como salida variable

Inicializa variable si
variable = 0 Inicializa
variable

Envía variable
no
al puerto
Luces con desplazamiento (programa 1)
void main ( void )
{ unsigned short dato;

TRISD = 0;

dato = 0b00000001;

while ( 1 )
{
PORTD = dato;
Delay_ms ( 300 );
dato = dato << 1;
if ( dato == 0 )
dato = 0x01;
}
}
 Operaciones aritméticas
Operador Operación

+ Suma

- Resta

* Multiplicación

/ División

% Resto, regresa el residuo de la división entera (no puede ser usado

con variables flotantes
++ Como prefijo Incrementa en uno el valor de la variable antes de
evaluar la expresión. Como Postfijo suma en uno la variable después
de ser evaluado la expresión.
-- Como prefijo decrementa en uno el valor de la variable antes de
evaluar la expresión. Como Postfijo resta en uno la variable después
de ser evaluado la expresión.
Luces con desplazamiento (programa 2)
void main ( void )
{ unsigned short dato;

TRISD = 0;

dato = 1;

while ( 1 )
{
PORTD = dato;
Delay_ms (250);
dato = dato * 2;
if ( dato == 0 )
dato = 0x01;
}
}
 Ejercicios propuestos 4
1. El alumno realizara un programa que envíe al
puerto C los siguientes valores utilizando para
generarlas, las instrucciones de
desplazamiento y/o aritméticas.

1, 5, 9, 13, 17, 21, 25, 29, 33, 37, 41, 45

2. Lo mismo que el ejercicio anterior con la

siguiente secuencia:

3, 6, 12, 24, 48, 92, 172, 1, 3, 6, 9, 12, 15, 18, 21, 24

 Acceso a bits individual
• mikroC te permite acceso individual en variables de 8
bits (char and unsigned short). Simplemente usando el
selector (.) seguido de uno de los identificadores F0, F1,
… , F7, siendo F7 el bit mas significativo.

• Ejemplo:
// Si RB0 es uno, colocar en uno la terminal RC0:
if ( PORTB.F0 )
PORTC.F0 = 1;

Los Identificadores F0–F7 no se reconocen en minúsculas.

5.- Secuencias condicionadas ( problema )

• Realizar un programa que envíe

secuencias distintas al puerto D,
dependiendo del valor de la terminal RA0.
Si RA0 es igual a cero se envía la serie de
dos bits desplazados hacia la izquierda,
mientras que si RA0 es igual a 1 entonces
se envía la serie de tres bits desplazados
hacia la derecha.
Secuencias condicionadas (algoritmo)
1. Configuración de puertos
2. Inicia contador
3. Si RA0 es igual a 0 entonces envía
secuencia_izquierda
4. De lo contrario envía secuencia_derecha
5. Incrementa contador
6. Si contador es igual a 8 entonces contador
igual a 0
7. Regresa a 3
Secuencias condicionadas (diagrama de
flujo)
Luces
Envía
Configura puertos
secuencia_izquierda
RD salida, RA entrada

Incrementa
Limpia contador contador

si
si Contador = 10 Limpia
RA0 = 0 contador

Envía no
no Secuencia_derecha
Secuencias condicionadas (programa)
short izquierda[10] = { 0, 1, 3, 6, 12, 24, 48, 96, 192, 128 };
short derecha[10] = { 128, 192, 226, 102, 56, 28, 14, 7, 3, 1 };
void main ( void )
{
TRISD = 0;
ADCON1 = 6;
TRISA = 0x7F;

Contador = 0;

for ( ; ; )
{
Delay_ms ( 500 );

if ( PORTA.F0 = = 0 )
PORTD = izquierda [ contador];
else
PORTD = derecha [ contador];

contador + + ;

If ( contador = = 10 )
contador = 0;
}
}
 Ejercicios propuestos 5
1. El alumno desarrollara un programa que
envíe una secuencia de números BCD a
un display de 7 segmentos ubicados en
el puerto D. Si la terminal RA1 ubicada
en el puerto A, es igual a 0, la
numeración debe ser incremental; en
caso contrario debe decrementarse.
Ejercicios propuestos 5 (esquemático)
 MOTOR A PASOS 1
• Unipolar.- Tiene 4 bobinas independientes (A, B, C,
D) y una terminal común a todas ellas.
 MOTOR A PASOS 2
• Unipolar.- Tiene 4 bobinas independientes (A, B,
C, D) y dos terminales comunes.
 MOTOR A PASOS 2
• Bipolar.- Tiene 2 bobinas (A – C, B – D)
 Secuencias de activación 1
• Unipolar.- Movimiento de 1 paso por pulso
(mayor torque).

Paso A B C D
1 1 1 0 0
2 0 1 1 0
3 0 0 1 1
4 1 0 0 1
 Secuencias de activación 2
• Unipolar.- Movimiento de 1 paso por pulso
(mayor velocidad).

Paso A B C D
1 1 0 0 0
2 0 1 0 0
3 0 0 1 0
4 0 0 0 1
 Secuencias de activación 3
• Unipolar.- Movimiento de 1/2 paso por pulso.
Paso A B C D
0.5 1 0 0 0
1 1 1 0 0
1.5 0 1 0 0
2 0 1 1 0
2.5 0 0 1 0
3 0 0 1 1
3.5 0 0 0 1
4 1 0 0 1
 Secuencias de activación 4
• Bipolar.- Movimiento de un paso

Paso A C B D
1 1 0 1 0
2 1 0 0 1
3 0 1 0 1
4 0 1 1 0
 Secuencia de activación 5
•Bipolar.- Movimiento de medio paso
Paso A C B D
0.5 1 0 1 0
1 1 0 0 0
1.5 1 0 0 1
2 0 0 0 1
2.5 0 1 0 1
3 0 1 0 0
3.5 0 1 1 0
4 0 0 1 0
Circuito de potencia 1 (motor unipolar )
Circuito de potencia 2 (motor unipolar )
Circuito de potencia 3 (motor bipolar )

Este mismo diagrama se repetiría para manejar la segunda bobina

Circuito de potencia x (motor a pasos )

Circuito integrado UCN 5804 Circuito integrado SAA1042

Circuito de potencia x1 (motor unipolar )
Circuito de potencia x2 (motor bipolar )
 Ejercicios propuestos 5
2.- El alumno desarrollara un programa que
envíe la secuencia de activación de un
motor a pasos ubicado en el puerto D. Si
la terminal ubicada en el puerto A, RA6,
sea igual a 0, el motor debe girar a la
derecha, en caso contrario debe girar a
la izquierda.
Ejercicios propuestos 5 (esquemático)
 6.- Display de 7 segmentos
• Realizar un programa en donde se
implemente un contador de 00-99
desplegando en un par de display’s de 7
segmentos. El programa debe realizar la
visualización utilizando el multiplexaje de
los datos, utilizando el puerto B como bus
de datos y las terminales RC0 y RC1
como terminales de habilitación de
display.
Display de 7 segmentos (algoritmo)
1. Configurar los puertos, inicialización de variables (unidades = ‘0’
decenas = ‘0’)
2. Envío de decenas
3. Habilitación de decenas
4. Envío de unidades
5. Habilitación de unidades
6. Incremento de unidades
7. Si unidades mayor de ‘9’ entonces 9
8. Sigue 2
9. Unidades = ‘0’
10. Incrementa decenas
11. Si decenas mayor de ‘9’ entonces 12
12. Sigue 2
13. Decenas=‘0’
14. Sigue 2
Display de 7 segmentos (diagrama de flujo)
Display

Limpia unidades
Incrementa decenas
Configura puertos
Inicia variables
si
Envía decena Decenas>’9’
Envía unidad
Incrementa unidad no

si Limpia decenas
Unidades>’9’

no
Display de 7 segmentos (programa)
short numero[ ] = { 0x3F, 0x06, 0x1B, 0x4F, 0x66, 0x6D, 0x5E, 0x07, 0x7F, 0x67 };

void main ( void ) // Programa principal

{
TRISB = 0; // Configuración de puertos
TRISC = 0;
unidades = decenas = ‘0’; // Inicialización de variables

while ( 1 ) // Programa de usuario

{
PORTB = numero [ decenas ]; // Envía decenas
PORTC.F0 = 1; // Habilita el display de decenas
delay-ms( 10 );
PORTC.F0 = 0;
PORTB = numero [ unidades ]; // Envía unidades
PORTC.F1 = 1; // Habilita el display de decenas
delay-ms( 10 );
PORTC.F1 = 0;

unidades++; // Incrementa unidades

if ( unidades > ’9’ )
{
unidades = ‘0’; // Reinicia unidades
decenas++; // Incrementa decenas
if ( decenas > ’9’ )
{
decenas = ‘0’; // Reinicie decenas
}
}

}
Display de 7 segmentos ( esquemático )
 Ejercicio propuesto 6 (d7seg)
• El alumno modificara el programa
elaborado de tal forma que se cambie el
incremento por decremento, al usar un
interruptor. Si el interruptor esta apagado
el conteo será incremental, en caso
contrario, el conteo será decremental. El
interruptor estará ubicado en la terminal
RE0 del puerto E.
Ejercicio propuesto 6 (esquemático)
Display de cristal liquido
 LCD (funciones bus 8 bits)
• Lcd8_Config
• Lcd8_Init
• Lcd8_Out
• Lcd8_Out_Cp
• Lcd8_Chr
• Lcd8_Chr_Cp
• Lcd8_Cmd
 Lcd8_Config
• Descripción: Inicializa el LCD usando un bus de datos de 8 bits. Los
puertos de Control (ctrlport) y Datos (dataport) usan la asignación de
terminales especificada.

• void Lcd8_Config( unsigned short *ctrlport,

unsigned short *dataport,
unsigned short RS,
unsigned short EN,
unsigned short WR,
unsigned short D7,
unsigned short D6,
unsigned short D5,
unsigned short D4,
unsigned short D3,
unsigned short D2,
unsigned short D1,
unsigned short D0 );
 Lcd8_Config 2
Ejemplo:
Lcd8_Config(&PORTC,&PORTD,0,1,2,0,1,2,3,4,5,6,7);
 Lcd8_Init
• Descripción: Inicializa el LCD usando un bus de 8 bits.
Los puertos de Control (ctrlport) y Datos (dataport) usan
la siguiente asignación de terminales.-
E → ctrlport.3
RS → ctrlport.2
R/W → ctrlport.0
D7 → dataport.7
D6 → dataport.6
D5 → dataport.5
D4 → dataport.4
D3 → dataport.3
D2 → dataport.2
D1 → dataport.1
D0 → dataport.0

• void Lcd8_Init(unsigned short *ctrlport, unsigned short *dataport);

 Lcd8_Init 2
Ejemplo:
Lcd8_Init(&PORTB, &PORTC);
 Lcd8_Out
• Descripción: Imprime mensaje en el LCD en la
fila y columna especificada (row y col).

• void Lcd8_Out( unsigned short row,

unsigned short col,
char *text );

• Ejemplo:
-Imprime “Hello!” en el LCD en la linea 1, columna 3
Lcd8_Out(1, 3, "Hello!");
 Lcd8_Out_Cp
• Descripción: Imprime mensaje en el LCD
en la posición actual del cursor.

• void Lcd8_Out_Cp(char *text);

• Ejemplo: Imprime “Here!” en la posición

actual del cursor
Lcd8_Out_Cp("Here!");
 Lcd8_Chr
• Descripción: Imprime un caracter en el LCD en
la fila y columna especificada (row y col).

• void Lcd8_Chr( unsigned short row,

unsigned short col,
char character );

Ejemplo: Imprime la letra “i” en el LCD en la línea

2,y columna 3
Lcd8_Out(2, 3, 'i');
 Lcd8_Chr_Cp
• Descripción: Imprime un caracter en el
LCD en la posición actual del cursor.

• void Lcd8_Chr_Cp(char character);

• Ejemplo: Imprime la letra “e” en la

posición actual del cursor
Lcd8_Chr_Cp('e');
 Lcd8_Cmd
• Descripción: Envía un comando al LCD.
Se puede pasar a la función una de las
constantes predefinidas.

• void Lcd8_Cmd(unsigned short command);

• Ejemplo: Limpia el LCD

Lcd8_Cmd(LCD_CLEAR);
 Comandos predefinidos
Comando Función
LCD_FIRST_ROW Mueve el cursor a la 1a. fila.
LCD_SECOND_ROW Mueve el cursor a la 2a. fila.
LCD_THIRD_ROW Mueve el cursor a la 3a. fila.
LCD_FOURTH_ROW Mueve el cursor a la 4a. fila.
LCD_CLEAR Limpia el display.
LCD_RETURN_HOME Regresa el cursor a la posición 1,1. Los datos de la RAM no son
afectados.
LCD_CURSOR_OFF Apaga el cursor.
LCD_UNDERLINE_ON Coloca el caracter subrayado.
LCD_BLINK_CURSOR_ON Parpadeo del cursor.
LCD_MOVE_CURSOR_LEFT Mueve el cursor hacia la izquierda sin cambiar la RAM
LCD_MOVE_CURSOR_RIGHT Mueve el cursor hacia la derecha sin cambiar el contenido de la RAM
LCD_TURN_ON Enciende el display
LCD_TURN_OFF Apaga el display
LCD_SHIFT_LEFT Mueve el display hacia la izquierda sin cambiar el contenido de la
RAM
LCD_SHIFT_RIGHT Mueve el display hacia la derecha sin cambiar el contenido de la RAM
 7.- LCD 8 BITS
• Diseñar el programa que inicialice un
LCD, usando un bus de datos de 8 bits, y
a continuación mande un mensaje de
bienvenida. El mensaje debe desplazarse
hacia la izquierda en forma continua.
 LCD 8 BITS (algoritmo)
1. Inicialice los puertos de datos y control.
2. Envía mensaje a desplegar.
3. Envía comando de desplazamiento hacia
la izquierda.
4. Repite el paso 3.
LCD 8 BITS (diagrama de flujo)
LCD 8 bits

Inicializa puertos de
datos y control

Envía mensaje

Envía comando de
Corrimiento a la izq.
LCD 8 BITS (esquemático)
 LCD 8 BITS (programa 1)
Void main(void)
{ TRISB = 0;
TRISC = 0;

Lcd8_Config(&PORTC,&PORTB,0,2,1,7,6,5,4,3,2,1,0);

Lcd8_Out(1,1,”Hola mundo cruel”);

while(1)
{
Lcd8_Cmd(LCD_SHIFT_LEFT);
Delay_ms(100);
}
}
 LCD 8 BITS (programa 2)
char mensaje[ ] = “Programa numero 2”;

void main(void)
{ TRISB = 0;
TRISC = 0;

Lcd8_Config(&PORTC,&PORTB,0,2,1,7,6,5,4,3,2,1,0);

Lcd8_Out(1,1,mensaje);

while(1)
{
Lcd8_Cmd(LCD_SHIFT_LEFT);
Delay_ms(500);
}
}
LCD 8 BITS (esquemático)
 LCD 8 BITS (programa 3)
char *mensaje3 = “mensaje tres”;

void main(void)
{ TRISB = 0;
TRISC = 0;

Lcd8_Init(&PORTC,&PORTB);

Lcd8_Out(1,1,mensaje3);
Lcd8_Out(2,1,”segunda fila”);

while(1)
{
Lcd8_Cmd(LCD_SHIFT_LEFT);
Delay_ms(50);
}
}
 Ejercicios propuestos 7
1. Programa que forme la palabra ‘HOLA’ en un
LCD, configurado para utilizar un bus de 8 bits.
Las letras deben desplazarse de derecha a
izquierda. Primero debe aparecer la H,
moviendose desde la derecha a la primer
columna a la izquierda. Enseguida debe
aparecer la O, tambien saliendo de la derecha
y terminando a la derecha de la letra H. Lo
mismo debe suceder para las letras L y A. El
programa debe ser ciclico.
 Ejercicio propuesto 8

H H O HO L

.
H H O
.
.

H H O HOLA
 LCD (funciones bus 4 bits)
• Lcd_Config
• Lcd_Init
• Lcd_Out
• Lcd_Out_Cp
• Lcd_Chr
• Lcd_Chr_Cp
• Lcd_Cmd
 Lcd_Config
• Descripción: Inicializa LCD usando un bus de datos
de 4 bits. El puerto de Control (ctrlport) y Datos
(dataport) tiene las asignaciones de terminales
especificadas.

• void Lcd_Config( unsigned short *ctrl_data_port,

unsigned short RS,
unsigned short EN,
unsigned short WR,
unsigned short D7,
unsigned short D6,
unsigned short D5,
unsigned short D4 );
 Lcd_Config 2
Ejemplo:
Lcd_Config(&PORTC,0,1,2,4,5,6,7);
 Lcd_Init
• Descripción: Inicializa el LCD usando un bus
de 4 bits. El puerto de Control (ctrlport) y Datos
(dataport) tiene la siguiente asignación de
terminales.-
E → ctrl_data_port.3
RS → ctrl_data_port.2
D7 → ctrl_data_port.7
D6 → ctrl_data_port.6
D5 → ctrl_data_port.5
D4 → ctrl_data_port.4

• void Lcd_Init(unsigned short *ctrl_data_port);

 Lcd_Init 2
Ejemplo:
Lcd_Init(&PORTB);
 Lcd_Out
• Descripción: Imprime mensaje en el LCD en la
fila y columna especificada (row y col).

• void Lcd_Out( unsigned short row,

unsigned short col,
char *text );

• Ejemplo:
-Imprime “Hello!” en el LCD en la línea 1, columna 3
Lcd_Out(1, 3, "Hello!");
 Lcd_Out_Cp
• Descripción: Imprime mensaje en el LCD en la
posición actual del cursor.

• void Lcd_Out_Cp(char *text);

• Ejemplo:
- Imprime “Here!” en la posición actual del cursor
Lcd_Out_Cp("Here!");
 Lcd_Chr
• Descripción: Imprime un caracter en el LCD en
la fila y columna especificada (row y col).

• void Lcd_Chr( unsigned short row,

unsigned short col,
char character );

Ejemplo:
- Imprime la letra ‘i’ en el LCD en la línea 2,y columna 3
Lcd_Out(2, 3, 'i');
 Lcd_Chr_Cp
• Descripción: Imprime un caracter en el LCD en
la posición actual del cursor.

• void Lcd_Chr_Cp(char character);

• Ejemplo:
- Imprime la letra ‘e’ en la posición actual del cursor
Lcd_Chr_Cp('e');
 Lcd_Cmd
• Descripción: Envía un comando al LCD. Se puede
pasar a la función una de las constantes predefinidas.
Los comandos son los mismos para ambos modos de
manejo del LCD (bus 8 o 4 bits).

• void Lcd_Cmd(unsigned short command);

• Ejemplo:
- Apaga el cursor, no aparece en el LCD
Lcd_Cmd(LCD_CURSOR_OFF);
 8.- LCD 4 BITS
• Diseñar el programa que inicialice un
LCD, usando un bus de datos de 4 bits, y
a continuación mande un mensaje
cualquiera de bienvenida. El mensaje
debe desplazarse hacia la derecha en
forma continua.
 LCD 4 BITS (algoritmo)
1. Inicialice los puertos de datos y control.
2. Envía mensaje a desplegar.
3. Envía comando de desplazamiento hacia
la derecha.
4. Repite el paso 3.
LCD 4 BITS (diagrama de flujo)
LCD 8 bits

Inicializa puertos de
datos y control

Envía mensaje

Envía comando de
Corrimiento a la der.
LCD 4 BITS (esquemático Config)
 LCD 4 BITS (programa 1)
void main(void)
{ TRISD = 0;

Lcd_Config(&PORTD,0,2,1,7,6,5,4);

Lcd_Out(1,1,”Envio de datos”);
Lcd_Out(2,1,”Usando bus de 4 bits”);

while(1)
{
Lcd_Cmd(LCD_SHIFT_RIGHT);
Delay_ms(200);
}
}
 LCD 4 BITS (programa 2)
char mensaje[11]={‘B’, ‘u’, ‘s’, ‘ ’, ‘4’, ‘ ’, ‘b’, ‘i’, ‘t’, ‘s’, ‘\0’};

void main(void)
{ TRISD = 0;

Lcd_Config(&PORTD,0,2,1,7,6,5,4);

Lcd_Out(1, 6, mensaje);

while(1)
{
Lcd_Cmd(LCD_SHIFT_RIGHT);
Delay_ms(200);
}
}
LCD 4 BITS (esquemático Init)
 LCD 4 BITS (programa 3)
char *mensaje3 = “programa 3 usando bus 4 bits”;

void main(void)
{ TRISB = 0;
TRISC = 0;

Lcd8_Init(&PORTC,&PORTB);

Lcd8_Out(1,16,mensaje3);
Lcd8_Out(2,1,”fila=2 columna=5”);

while(1)
{
Lcd8_Cmd(LCD_SHIFT_LEFT);
Delay_ms(50);
}
}
 Conversión de tipo de datos
Tipo de dato a cadena
• ByteToStr
• ShortToStr
• WordToStr
• IntToStr
• LongToStr
• FloatToStr
 ByteToStr
Descripcion: Crea una cadena de salida de un pequeño
numero sin signo (valor numérico menos a 0x100). La cadena
esta ajustada a un ancho de 3 caracteres; Las posiciones a la
izquierda que no se usan en la conversión se rellenan con
espacios.

void ByteToStr(unsigned short number, char *output);

Ejemplo:
unsigned short t = 24;
char *txt=“ “; //se inicializa un apuntador a 4 espacios

ByteToStr(t, txt); // txt es " 24" (un espacio en blanco)

 ShortToStr
Descripción: Crea una cadena de salida de un numero
pequeño con signo (valor numérico menor a 0x100). La
cadena esta ajustada a un ancho de 4 caracteres; Las
posiciones a la izquierda que no se usan en la conversión
se rellenan con espacios.

void ShortToStr(short number, char *output);

Ejemplo:
short t = -4;
char *txt=“ “; // Se inicializa un apuntador de 5 espacios

ShortToStr(t, txt); // txt es " -4" (dos espacio en

blanco)
 WordToStr
Descripción: Crea una cadena de salida de un numero sin
signo (Valor numérico de una variable unsigned). La
cadena esta ajustada a un ancho de 5 caracteres; Las
posiciones a la izquierda que no se usan en la
conversión se rellenan con espacios.

void WordToStr(unsigned number, char *output);

Ejemplo:
unsigned t = 437;
char *txt=“ “; // Inicializa un apuntador con 6 espacios

WordToStr(t, txt); // txt es “ 437" (dos espacios vacios)

 IntToStr
Descripción: Crea una cadena de salida de un numero con
signo (Valor numérico de una variable int). La cadena esta
ajustada a un ancho de 6 caracteres; Las posiciones a la
izquierda que no se usan en la conversión se rellenan con
espacios.

void IntToStr(int number, char *output);

Ejemplo:
int j = -4220;
char *txt=“ “; // Inicializa un apuntador con 6 espacios

IntToStr(j, txt); // txt es " -4220" (un espacio en blanco)

 LongToStr
Descripción: Crea una cadena de salida de un numero largo con
signo (Valor numérico de una variable long). La cadena esta
ajustada a un ancho de 11 caracteres; Las posiciones a la
izquierda que no se usan en la conversión se rellenan con
espacios.

void LongToStr(long number, char *output);

Ejemplo:
long jj = -3700000;
char *txt=“ “; // Inicializa un apuntador con 12 espacios

LongToStr(jj, txt); // txt es “ -3700000" (3 espacios en blanco)

 FloatToStr
Descripción: Crea una cadena de salida de un numero de
punto flotante. La cadena contiene un formato normalizado de
un numero (mantisa entre 0 y 1) con signo en la primera
posición. La mantisa esta ajustada a un formato de 6 dígitos,
0.ddddd; Hay siempre 5 dígitos a continuación del punto
decimal.

void FloatToStr(float number, char *output);

Ejemplo:
float ff = -374.2;
char *txt=“ “; // Inicializa un apuntador con 14 espacios

FloatToStr(ff, txt); // txt es "-0.37420e3"

 9.- Contador 0-9 (problema)
• Se quiere un programa que visualice un
conteo de 0 a 9 en un LCD.
 Contador 0-9 (algoritmo)
1. Configura el LCD
2. Inicializa el contador
3. Convierte a ASCII el valor del contador
4. Envía valor en ASCII al LCD
5. Incrementa el contador
6. Regresa a 3
 Contador 0-9 (diagrama de flujo)
teclado

Inicializa puertos
(LCD)
Convierte contador
a ASCII
Inicializa contador

Envía a LCD
ASCII

Incrementa
contador
 Contador 0-9 (programa)
void main(void)
{ unsigned short contador;
char cadena[ 5 ] = “ “;

TRISD = 0;

Lcd_Config(&PORTD,0,2,1,7,6,5,4);

contador = 0;

Lcd_Out(1,1,”Contador 0-9”);

while(1)
{
ShortToStr ( contador , cadena );
Lcd_Out ( 2 , 8 , cadena );
contador ++;
Delay_ms(500);
}
}
Contador 0-9 (esquemático)
 Contador 0-9 (funcionamiento)
Contador 0-9 : Contador 0-9 : Contador 0-9 :
0 1 2

Contador 0-9 : Contador 0-9 : Contador 0-9 :

3 4 5

Contador 0-9 :
6
. . . Contador 0-9 :
9
 Ejercicio propuesto 8
1. Programa que utilice un LCD, configurado
para usar un bus de 8 bits. En el LCD deben
aparecer en forma secuencial, los números de
la secuencia 1 – 2 – 4 – 8 – 16 – 32 – 64 – 128 –
256 – 512 – 1024 – 2048 – 4096 – 8192 – 16384 -
32768. Los numero deben ser generados por
operaciones aritméticas. El desplegado debe
hacerse de la forma mostrada en las
siguientes figuras. Se utiliza la segunda fila,
presentando hasta 3 numeros consecutivos,
un numero a la izquierda, uno mas al centro y
otro a la derecha.
 Ejercicio propuesto 8

Serie de numeros Serie de numeros Serie de numeros

1 1 2

Serie de numeros Serie de numeros Serie de numeros

1 2 4 8 8 16

Serie de numeros
8 16 32
. . . Serie de numeros
8192 16384 32768
 Ejercicio propuesto 9
1. El alumno diseñara un programa en
donde se muestre en un LCD los
números desde 00 hasta el 99. Con un
intervalo de tiempo entre cambio igual a
500 milisegundos.
 Ejercicio propuesto 9

Contador 00-99 cada 500 mseg Contador 00-99 cada 500 mseg Contador 00-99 cada 500 mseg
00 01 02

Contador 00-99 cada 500 mseg Contador 00-99 cada 500 mseg Contador 00-99 cada 500 mseg
03 04 05

Contador 00-99 cada 500 mseg

06
. . . Contador 00-99 cada 500 mseg
99
Teclado matricial (esquemático)
 Teclado matricial (funciones)

• Keypad_Init
• Keypad_Read
• Keypad_Released
 Keypad_Init
• Descripción: Inicializa el puerto para trabajar con el
teclado. Las terminales del teclado deben estar
conectadas de la siguiente forma:
port.F0 columna 1
port.F1 columna 2
port.F2 columna 3
port.F3 columna 4
port.F4 fila 1
port.F5 fila 2
port.F6 fila 3
port.F7 fila 4

• void Keypad_Init(unsigned *port);

 Keypad_Init 2
Ejemplo:
Keypad_Init(&PORTB);
 Keypad_Read
• Descripción: Verifica si alguna tecla fue presionada. La función
regresa 1 a 12, dependiendo la tecla presionada, o 0 si no existe
tecla presionada.
1 1
2 2
… …
9 9
* 10
0 11
# 12

• unsigned short Keypad_Read(void);

• Ejemplo:
kp = Keypad_Read();
 Keypad_Released
• Descripción: La llamada a la función Keypad_Released es
una función blocking call: La función espera hasta que cualquier
tecla sea presionada y liberada. Cuando se libera, la función
regresa de 1 a 12, dependiendo de la tecla presionada.

• unsigned short Keypad_Released(void);

• Ejemplo:
Keypad_Released();
 10.- Teclado matricial (problema)
• Se desea un programa con el cual se
muestre en un LCD (bus 8 bits en puerto
B y puerto C como control) la tecla
presionada en un teclado matricial (puerto
D).
 Teclado matricial (algoritmo)
1. Configuración de puertos (teclado y lcd).
2. Lectura de teclado
3. Conversión a ASCII
4. Envío al LCD
5. Regresar a 2
Teclado matricial (diagramas de flujo)
teclado

Inicializa puertos
(LCD y teclado)

Lee teclado

Convierte a ASCII

Envía a LCD
Teclado matricial (esquemático)
 Teclado matricial (programa)
unsigned short kp, cnt;
char txt[5];

void main()
{ cnt = 0;
Keypad_Init(&PORTD);
Lcd8_Init(&PORTC, &PORTB, 0, 2, 1, 7, 6, 5, 4, 3, 2, 1, 0); // Inicializa LCD en puerto B y puerto C
Lcd8_Cmd(LCD_CLEAR); // Limpia display
Lcd8_Cmd(LCD_CURSOR_OFF); // Cursor apagado
Lcd8_Out(1, 1, "Key :");
Lcd8_Out(2, 1, "Times:");
do { kp = 0; // Espera a que se presione una tecla
pressed
do kp = Keypad_Read();
while (!kp); // Prepara valor para salida
switch (kp)
{ case 10: kp = 42;
break; // '*'
case 11: kp = 48;
break; // '0'
case 12: kp = 35;
break; // '#'
default: kp += 48;
}
cnt++;
Lcd9_Chr(1, 10, kp);
if (cnt == 255) { cnt = 0; Lcd8_Out(2, 10, " "); } // Imprime en LCD
WordToStr(cnt, txt);
Lcd8_Out(2, 10, txt);
} while (1);
}
 Ejercicio propuesto 9
1. El alumno realizara un programa que
tome 3 números desde un teclado
matricial, los guarde en un arreglo, los
convierta a un numero que se guarde en
una variable tipo entera. Con este
numero el alumno deberá proporcionar
el producto por 2 y división entre 2
resultantes. Visualizando los resultados
en un LCD.
 Ejercicio propuesto 9
Cual es el numero de 3 cifras: Cual es el numero de 3 cifras:
025

Cual es el numero de 3 cifras:

Cual es el numero de 3 cifras:
025 025
El producto por 2 es: 050
El producto por 2 es: 050
La división entre 2 es: 012