Banner publicitario de PCBWay

quisiera ayuda con un letrero luminoso

dannyy

dannyy

hola amigos

soy nuevo en el foro, y quisiera una ayudita si no es mucha molestia
y de paso felicitar al foro por prestar tanta atencion a los programadores principiantes (y)
:buenpost::buenpost::buenpost::buenpost::buenpost::buenpost::buenpost::buenpost::buenpost:


tengo que hacer un letrero luminoso con una memoria eeprom y no se por donde empezar :confused:,
trabajo con el compilador protonIDE
y quiero que tenga varias animaciones, bueno de los que existen hasta ahora
y tengo a la mano un 16f877A y
una memoria eeprom 24LC16B

no lo tomen como si les estuviera exigiendo que me ayuden necesariamente, tómenlo como que van ayudar a uno de sus discípulos (lo cual me considero ahora) e iré publicando mis avances en este foro

por favor alguna pista, ayuda o código sera bienvenido
y muy agradecido
saludos
 
gracias por responder

y déjame decirte q ya empece por esa parte
se q debo hacer barrido por filas se q debo usar integrados de registro,etc
pero quiero ideas nuevas
 
Primero Dimensiona tu proyecto.

Cuantas filas ?
Cuántas columnas ?
Tamaño del mensaje?

Dependiendo de esto puede que necesites un registro de corrimiento o no.

Con la memoria que propones podrías almacenar hasta 2KB de datos
 
mi problema es que al leer la memoria eeprom demora mucho en hacerlo :
mira esto es lo que hago:
1: apago todos los led
2: leo la primera posición de la memoria eeprom
3: luego agarro el bit de la fila y lo mando por los integrados de registros o flipflop
4: leo de nuevo y lomando por la fila mediante los integrados registros ( y asi asta llegar asta el ultimo bit)
5: reinicio toda la eeprom y y me paso a la siguiente fila y ago el mismo prosedimiento
ahora una memoria eeprom se demora en leer 50 microsegundos y multiplicado por las 60 columnas sale 3 ms y por las 8 fila seria 24ms y eso es mucho, se notaria un parpadeo

la ayuda q pido es sobre como aser para no tardarme tanto, porque del paso 2 al 4 demora mucho como oviar esos paso o un metodo para hcerlo para que no gaste mucho tiempo

gracias por ti atención
saludos

D@rio discúlpame si te incomode y te agradezco por tus respuestas
espero que me ayudes

amigos electroconico y D@rio
quiero llegar a hacer un letrero de 80 por 8
y tengo todos esos problemas
dime por favor si esta bien mi procedimiento o esta mal
si tienes otra idea por favor asmelo saber
considerenme su discípulo porfavor

y el mensaje q sea de 200 caracteres
 
Última edición:
Si lees byte por byte pues si te tardaras mucho.

Debes crear un buffer , en el cual cargas digamos por lo menos 128Bytes o lo que te soporte la RAM del uC.
Y Una vez que tienes cargados los datos empiezas a desplegar el texto.

Te recomiendo el uso de interrupciones , así cuando enciendes una fila o columna segun sea tu metodo vas tratando los demás datos en lo que pasas a la siguiente fila.

Espero haberme explicado
------------------------
* No recuerdo ni leí mucho acerca de la memoria que usas , pero generalmente puedes leer por bloques que es mucho más rápido que byte por byte.

Revisa bien las especificaciones del la eeprom para que maximices los tiempos de lectura.

Saludos!
 
Última edición:
uy amigo muy sabias tus palabras
pero porfavor me explicarias de como cagar ese buffer porque no sabría como cargarlo
de q forma seria....

y sobre la interrupcion
creo que te entendi un poco lo que me tratas de decir es que al hacer una interrupcion y mientras se esta dando esa interrupcion, a la vez el pic trabaja los siguientes programas mientras se esta dando la interrupcion o me equivoco
pero si yo no me deje entender ....
por favor explícamelo de nuevo porque no te entendí muy, por eso si me darías otra explicación
estaría muy agradecido

amigos porfavor respondanme

amigo electroconico explicamelo de nuevo no lo entendí bien por favor
 
Última edición:
Creas un arreglo.
buffer_1[80]; <-- En este buffer metes todos los datos de una fila
buffer_2[80]; <--- Aca metes los de la siguiente.


Algo así como hacer una funcion para el buffer

for(X=0;X<80;X++){
buffer[X]=eeprom(direccion+X);
}

Con eso llenas el buffer con 80 Bytes , dirección es un indice de donde inicia cada mensaje,etc...



Una vez que cargas los datos pues los envias y la fila correspondiente pues deberá estar encendida X tiempo.

Activas un Timer y usas esa interrupción.

Usas un Timer y la interrupcion para aprovechar el tiempo de refresco para hacer otra cosa y no quedarte esperando con un "delay_ms(tiempo) o "pause" creo que en basic a que se ejecute.

En lo que se activa la interrupción ya puedes empezar a trabajar los datos de la siguiente fila a refrescar en el buffer o en otro para mayor comodidad.

Cuando se produzca la interrupcion del Timer pues apagas la fila actual.
Habilitas la siguiente fila , Activas timer y asi te la llevas en general.

Esto es algo así muy por encimita , pero espero te des una idea de una de tantas formas de hacerlo.
 
Es simple... dices que tienes una matriz de 80x8, entonces en vez de leer la primer columna despegarla, leer la segunda, y asi sucesivamente... lees de corrido las 80 columnas, los cargas en la RAM del micro y ejecutas el barrido desde alli.....
 
o muchisimas gracias

pero tu as echo este letrero alguna vez no?
seguro que si

me podrías dar tu hotmail si tengo alguna consulta?

de igual manera muchísimas gracias
con esa idea voy a empezar a hacerlo y voy a ir publicando avances

una ultima pregunta q te parece esta idea:

1: grabo las letras en la eprom (voy a grabar letra por letra en ASCII para q ocupe menos espacio y ago una tabla en el pic de cada letra)
2: leo esa letra con el pic y me dirijo a la tabla indicada y mando bit por bit hasta completar la palabra
3: prendo la fila y asi susesivamente

esa respuesta fue para electroconico

D@rio muchas gracias
me hablan sobre interrupciones y se explican bien
pero lo voy a leer mañana estoy cansado y ya es tarde me voy a dormir
gracias a todos me ayudaron mucho voy a estar publicando mis avances y
al ultimo se los voy a dedicar mi proyecto en un video terminado
cuídense hasta mañana

Chico3001 muy buena tu respuesta es parecida al de electroconico que desde hoy es mi maestro
y voy a tomarla en cuenta

buena noches
 
Última edición:
Hola! D@ario
sabes usar bien las interrupciones o usar bien el TMR0
porque tengo una duda
Saludos!

Este mensaje es para electroconico para cuando se encuentre en linea o si hay alguien que me pueda responder seria maravilloso
como podria usar el TMR0 como interrupción para mi letrero
porque todo lo que investigue sobre ellos es que el TMR0 me da una temporizacion y luego se desborda
dejando el registro INTCON,T0IF en 1 y supongo que ese uno me avisaria que ya a terminado de mandar todos los bit por los registros para empezar a prender la fila si no es asi por favor corrigeme
te lo agradeseria mucho.
ahora mi pregunta es:
como calculo el tiempo que demora en enviar todos los bit de la fila para poder fijarle al TMR0 y que en ese tiempo se desborde y mande la interrupcion para prender esa fila.
o acaso hay otro metodo
porfavor si lo hubiera hasmelo saber me estaré muy agradecido
Saludos!
 
Última edición:
Efectivamente el timer se desborda, pero genera una interrupcion para alertar al micro que ya se termino el tiempo programado, asi que el micro salta a la direccion 04h donde se puede volver a programar un nuevo tiempo igual o diferente al anterior... y dentro de la misma sacas el siguiente dato del display y lo muestras...

posteriormente el micro regresa al programa principal a terminar la tarea pendiente, que para tu caso puede ser procesar nuevos efectos o sacar mas datos de la memoria EEPROM

Hay una formula para calcular el tiempo.. pero la verdad ahorita son las 12 y no me acuerdo ni de mi nombre... te la busco y la coloco mañanita... o tambien date una vuelta en los tutoriales de programacion, alli la explican detalladamente...
 
Antes de que quieras unir todas las etapas de tu proyecto ve resolviendo modulo por modulo.

Puesdes usar el Timer0,1,2 etc... el que sea.

Solo revisa la hoja de datos del pic que usas.

Por ejemplo.

Si tu pic usa un Oscilador de 4MHz , cada instruccion Ciclo de trabajo le lleva al pic 1micro segundo ejecutarlo. Esto tomalo en cuenta.

Ahora

El timer desborda cuando pasa de 0xFF a 0x00 en el caso de que sea de 8 bits , si es de más pues de 0xFFFF a 0x0000.

El timer tiene presscaler , que va de 2,4,8,16,32,n-256.

Si tu seteas el presscales a 4 estas indicando que el timer incrementara 1vez cuando se realicen 4 ciclos de trabajo.

Si lo seteas a 8 , entonces por cada 8 ciclos de trabajo tendras un incremento en el timer.

Un ejemplo con Oscilador a 4MHz y prescaler a 4

Así que cada ciclo de trabajo consume 1us

Si quieres que desborde cada 1ms aproximadamente

prescaler*Tciclo*Timer0=Tiempo
4*1us*Timer0 = 1ms

Timer0 = 1ms/(4*1us)
= 250

Ya sabes que necesitar cargar con 250 , pero el timer desborda de 255 a 0 , no en cuenta regresciva.

Por lo que 255-250 = 5 , con ese valor 5 es con lo que cargas el timer.

A lo mejor te preguntas , pero porque con 5 :/ , bueno . el timer es incremental, asi que para que desborde le hacen falta 250 pasitos y esos 250 pasos por la prescala equivalen a 1000us lo que es 1ms.

Prueba prender un led y trabajando las interrupciones para que te familiarices con el procedimiento y revisa otras fuentes.
 
muchas gracias Chico3001 como siempre atento, agradezco to participación ojala y me sigas ayudando de esa forma
y muchisimas gracias electroconico me acabas de describir detalladamente todo!

ahora lo que voy hacer es como lo que me dijo electroconico voy a ir familirisandome prendiendo un led

pero mi pregunta es para los dos:
"¿ENTONCES LO QUE TENGO QUE HACER ES, CALCULAR EL TIEMPO EN QUE MANDO TODOS LOS BIT DE LA FILA, PARA QUE LO TOME EL TMR0 Y HAGA SU INTERRUPCION JUSTO EN EL TIEMPO DE QUE A TERMINADO DE ENVIAR TODOS LOS BIT DE LA FILA?
osea si no me explique bien es asi:
que primero le pongo al TMR0 un valor que calcule , lo cual es el tiempo que se demora en mandar todos los bit por bit a la fila y para cuando lo termine de mandar todos los bit el TMR0 se desborda para que haga la interrupcion para prender la fila correspondiente
diganme si estoy en lo cierto, ya que si no lo fuera explíquenme la otra forma por favor
Saludos!
 
El tiempo del timer es para apagar/encender la fila correspondiente para crear un el efecto de persistencia a la vision.

Mientras una fila esta encendida y el timer corriendo , el micro se va a dedicar a hacer otra cosa , en este caso tratar más datos para la siguiente fila , lectura de memoria eeprom , etc...

Cuando el tiempo de encendido de la fila haya terminado la interrupcion del timer te lo indicara , entonces sea lo que sea que estes haciendo das prioridad al refresco de las filas para que se vea una imagen fija.
 
muchísimas gracias amigo
ahora si lo tengo bien claro
voy a comenzarlo a hacer
solo una ultima pregunta :
¿cuanto de tiempo como mínimo y como máximo me recomendarías de refresco o cuanto tiempo me recomiendas tenerlo prendido cada fila para no tener problemas con el parpadeo?
gracias por el asesoramiento me quedo muy agradecido
iré publicando mis avances muy pronto
Saludos!

:d:d:d:d:d:d:d:d:d:d:d:d:d:d:d:d:d:d:d:d
 
Última edición:
minimo 50Hz , si puedes obtener más pues mucho mejor.

Son las veces que debes encender las filas para crear el efecto de que todas estan encendidas a la vez.

Dependiento del numero de filas repartiras el tiempo.

Tiempo = 1 / Frecuencia
 
e aqui un avance:
Ver el archivo adjunto letrero.rar
ya pude sacar una imagen
pero ahora quiero hacerles otra pregunta para electroconico y Chico3001 :) :
como puedo grabar en la eeprom

hasta ahora pensé en dos cosas( si estoy equivocado por favor corrijanme estaria muy agradecido y si tienen otro metodo huy seria mucho mejor):

1°:la primera es guardar todas las columnas asi como esta columna por columna en la eeprom y luego leer la eeprom y guardar asi como esta columna por columna en la ram hasta llegar al final del tamaño del tablero y luego leer las ram y mandar bit por bit en toda la fila y ensender la fila etc.

ESTOS SE GRABA EN LA EPROM
%11111110 <-----primera columna (primera posicion de la memoria eeprom)
%00100001 <-----segunda columna(segunda posicion de la memoria eeprom)
%00100001 <-----tercera columna(tercera posicion de la memoria eeprom)
%00100001 <-----cuarta columna(cuarta posicion de la memoria eeprom)
%11111110 <-----quinta columna(quinta posicion de la memoria eeprom)

el inconveniente es que gasto mucha memoria eeprom ( 6 posiciones por letra asi como la figura anterior) y cuento con una memoria de 2048 posiciones o bytes (24lc16b)
y eso me alcansaria para unas 341 caracteres o algo asi y yo quiero que sea para algo mas grante minimo 1000 caracteres

2°-el segundo es grabar letra por letra en la eeprom asi:
ESTOS SE GRABAN EN LA EEPROM
A <--------primera posicion de la memoria eeprom

y al leer el pic esto se va a la subrutina donde esta las columnas de la letra a y los para guardar columna por columna en el pic asi

ESTA ES LA SUBRUTINA DE LA LETRA A
%11111110 <-----primera columna (envia estos digitos al la primera posicion de la memoria ram)
%00100001 <----segunda columna(envia estos digitos al la segunda posicion de la memoria ram)
%00100001 <-----tercera columna(envia estos digitos al la tercera posicion de la memoria ram)
%00100001 <-----cuarta columna(envia estos digitos al la cuarta posicion de la memoria ram)
%11111110 <-----quinta columna(envia estos digitos al la quinta posicion de la memoria ram)

y luego leer las ram y mandar bit por bit en toda la fila y ensender la fila etc.

y otra cosa por favor :
esas dos opciones no se mucho como seria su programacion solamente es una proyeccion de como podria aserlo
por eso si no fuera mucha molestia explicamelo detalladamente la opcion escojida o la opcion que me vas a decir
y te doy gracias de antemano:apreton:
Saludos?

y disculpen que fuera un imagen
esque no tengo camara o celular para grabarla
pero a la proxima me compro una para presentar el trabajo
 
Última edición:
Atrás
Arriba