Para esto veremos el programa y luego lo explicare.

#include <16F883.h>
#use delay(int=4000000)
#define LARGO 28
int const tabla[LARGO+8]={

//Longitud de la tabla
0b00000000,
0b00000000,
0b00000000,
0b00000000,
0b00000000,
0b00000000,
0b00000000,
0b00000000,
0b11111111,
0b00001000,
0b00001000,
0b11111111,
0b00000000,
0b01111110,
0b10000001,
0b10000001,
0b01111110,
0b00000000,
0b11111111,
0b00000001,
0b00000001,
0b00000000,
0b01111111,
0b10001000,
0b10001000,
0b01111111,
0b00000000,
0b00000000,
};

//Espacio
//Espacio
//Espacio
//Espacio
//Espacio
//Espacio
//Espacio
//Espacio
//Dato de tabla H

//Espacio
//Dato de tabla O

//Espacio
//Dato de tabla L

//Espacio
//Dato de tabla A

//Espacio
//Espacio

void main(){
byte const bitMask[8]={1,2,4,8,16,32,64,128}; //Mascara
int i,j,k;
//Variables contadores
while(TRUE){
//Ciclo infinito
for(i=0;i<LARGO+8;i++){
//Recorrido de tabla
for(k=0;k<20;k++){
//Refresco de matriz
for(j=0;j<8;j++){
//Barrido de columnas
output_a(~bitMask[j]); //Columnas ponderadas
output_b(tabla[j+i]); //Desplazamiento de tabla
delay_ms(1);
//Demora de multiplexado
}

}
}
}
}
Bueno aqui podemos ver principalmente la tabla con los caracteres realizados en funcion a las filas
que forma la palabra HOLA, ahora lo mas importante que son los for anidados.
Notemos desde el for que se encuentra mas profundo hacia al for que se encuentra en la
superficie.
El for(j=0;j<8;j++)cumple la funcin de recorrer las columnas que se encuentran en el puerto
A, por eso encontramos la sentencia output_a(~bitMask[j]), donde bitMask[j]es el
vector definido mas arriba que contiene los valores {1,2,4,8,16,32,64,128}, esto hace
referencia a 00000001, 00000010, 00000100, 00001000, 00010000, 00100000,
01000000, 10000000. De esta forma activamos cada columna una a una. Luego como
podemos ver tenemos la salida del puerto B la cual posee el vector de la tabla donde su indice dice
j+i, bueno esto es clave para que la matriz desplace la palabra dentro de ella.
Ahora el for(i=0;i<LARGO+8;i++)lo que hace es recorrer la tabla, como pueden ver el valor
constante LARGO que se carga en la parte de arriba del programa es la longitud de la tabla, es
decir el largo del vector, pero se le suma 8, esto es porque la matriz posee 8 columnas las cuales
debe mostrar apagadas al finalizar dicho mensaje para que no se solape cuando se repita.
Volviendo a lo mencionado anterior que era clave el j+i lo que hace es que cada vez que se
refrescan las columnas, se recorre toda la tabla, pero por cada refresco, la tabla se recorre desde
un inicio distinto, es decir, para crear el movimiento de la matriz, lo que se hace es mostrar el
contenido de la tabla desde su primer byte hacia el ultimo, pero cada vez que se genera un
muestreo en lugar de comenzar del primero se comienza del segundo, luego del tercero, y por eso
el j+i, lo que nos genera la ilusion ptica del movimiento. Ahora se mostrara en el siguiente gif
animado, a velocidad lenta para la comprensin y a velocidad normal para ver el resultado
obtenido.
Por ultimo el for(k=0;k<20;k++) lo que hace es la cantidad de frames, es decir la cantidad de
veces que refresca la pantalla por cada barrido de columnas, lo que quiere decir es que realizara
20 barridos de matriz completa por cada movimiento del desplazamiento de la palabra en la matriz.
Tener en cuenta que el gif animado no se muestra en tiempo real, pero servir para tener en cuenta
el funcionamiento.

Esta sera la versin final a velocidad aceptable para leer y sin parpadeos.

http://electgpl.blogspot.com/2013/11/matriz-8x8-mensaje-condesplazamiento.html

http://musicaplay.net/index.php?
wizard=musicas&video=Zl0H4vTZdl0&nomart=programacion%20de
%20matrices%20leds%20con%20el%20pic%2016f877a%20con%20%20matriz
%20de%20leds(8x32)&query=publik%20-%20matrix%20de%20leds-%20pic
%2016f877a%20-%20ccs%20compiler%20y%20proteus&Genero=087

//////////////////////////////////////////A
portc=0b10001;
portb=0b11111111;
porta=0b11;
delay_ms(200);
portc=0b11111;
portb=0b010001;
porta=0b00;
delay_ms(200);

asi lo hacemos nosotros

puerto c es filas

portb columnas

porta complemento de las columnas

portc=0b11111; // todas las filas activas

portb=0b00000001; solo la primera columna
porta=0b10; el resto
delay_ms(200); esperamos
portc=0b00100; activamos lo del centro osea filas
portb=0b11111111; todas las columnas
porta=0b11; el resto
delay_ms(200);

lo que hacemos es por pedazos

primero los palos de la a

||

luego los del centro

y ahi esta la a

solo que al momento de ponerlo en el pic hay que ponerle menos tiempo entre cada segmento de letra

DUDAS??

#include <16f877a.h> //PIC utilizado

#fuses XT,NOWDT,NOPROTECT,NOLVP,PUT,BROWNOUT
#use delay(clock=4000000)
#USE STANDARD_IO (b)// Esta funcin afecta directamente al registro de
puertos TRISx y adems se asegura que cada vez que se utilice un pin del
puerto sea configurado como I/O creando el cdigo necesario. Esta es la
directiva por defecto.
int ret=2;

void main()
{
do {

output_b(191);
output_c(127);
delay_ms(ret);
output_b(223);
output_c(136);
delay_ms(ret);
output_b(239);
output_c(136);

delay_ms(ret);
output_b(247);
output_c(136);
delay_ms(ret);
output_b(251);
output_c(127);

delay_ms(ret);

if (ret>10){ret=ret-10;}
delay_ms(ret);
}while(true);
}

#include <16F887.h>
#FUSES NOWDT, XT, NOPUT, NOMCLR, NOPROTECT, NOCPD, NOBROWNOUT,
NOIESO, NOFCMEN, NOLVP, NODEBUG, NOWRT, BORV40
#use delay(clock=4000000)