Publicado por: xootraoox en 31 de Marzo de 2005, 02:48:00
00000000000000000000000000000000000000000000000000000000000000000000000000000001 --->cadena 1
00000000000000000000000000000000000000000000000000000000000000000000000000000010 --->cadena 2
00000000000000000000000000000000000000000000000000000000000000000000000000000100 --->cadena 3
00000000000000000000000000000000000000000000000000000000000000000000000000001000 --->cadena 4
00000000000000000000000000000000000000000000000000000000000000000000000000010000 --->cadena 5
00000000000000000000000000000000000000000000000000000000000000000000000000100000 --->cadena 6
00000000000000000000000000000000000000000000000000000000000000000000000001000000 --->cadena 7
y asi sucesivamente...
el asunto es que es para controlar unos shift register los cuales estan encargados de barrer una matriz de leds de 16 matrices de 5x7
a la vez tambien hay una señal de clock la cual por cada bit enviado tiene que activarse osea al mismo tiempo y al termino de la transmicion envio un pulso de latch para activar todos los shift registers
bueno el shift register que utilizo es el 74hc595 que es de entrada serial y salida paralela lo que me permite con uno de estos transformar 3 pines del micro en 8 y que a la vez tambien poseen una salida serial para poder ponerlos en cascada unos con otros para asi tener el numero de salidas que uno guste...
yo solo utilizo 10 de estos para asi generar 80 salidas para recorrer las columnas de mi matriz
les dejo unas fotos de la matriz para que vean como esta quedando
Foto1
Foto2
Foto3
Foto4
Foto5
Foto6
Foto2
Foto3
Foto4
Foto5
Foto6
-==XooTRAooX==-
Publicado por: J0N4TH4N en 01 de Abril de 2005, 03:30:00
Publicado por: xootraoox en 01 de Abril de 2005, 03:52:00
ufff la verdad es que no entendi mucho pero igual se agradece ya que no he tenido respuestas en de los dos intentos que hecho por averiguar sobre el tema la verdad es que me tiene bien tomado del pelo este tema ya que es super interesante con decir que la matriz de las fotos es de un letrero de esos comerciales y que la verdad son bastante costosos y aunque no lo crean LO ROMPI SOLO PARA EXPERIMENTAR CON EL
y es esa ademas una de las razones de la improtancia para mi el poder hacerlo trabajar ya que no quiero sentirme arrepentido por haber desarmado este letrero que trabajaba sin problemas y era bastante entretenido todo lo que haciabueno en fin buscando por hay me encontre que en lenguaje c se puede transformar varios registros en uno solo lo cual seria ideal para lo que yo necesito
make16(variable1,variable2)
eso es en lenguaje c, ahora ¿se puede hacer eso mismo en asm y con mas registros? por ejemplo 10 a la vez
bueno si alguien pudiese hecharme una manito se agradece de antemano
Publicado por: J0N4TH4N en 01 de Abril de 2005, 04:04:00
Publicado por: xootraoox en 01 de Abril de 2005, 04:34:00
mi idea es crear una matriz lo mas cercana a lo que se encuentra en el comercio la cual va a consistir n lo siguiente
por el momento el micro sera un 16f628 y si las necesidades lo requieren pensare en otro
una memoria del tipo 24lcxx que contenga los mensajes (por el momento la memoria interna basta para hacer las pruebas)
tengo pensado a la vez la posibilidad de programarlo con un teclado de pc convencional asi como tambien una interface rs232
bueno y cualquier otra sugerencia que mejore el diseño
a la vez quiero poder agregarle varios tipos de efectos, como por ejemplo
-scroll up
-scroll down
-scroll left
-scroll right
-split scroll
-random
-flash
bueno encontre un diseño que cumple mas menos con eso pero en realidad no entiendo nada ya que esta diseñado para un microcontrolador z80 el cual dejo los enlaces por si es de interes asi como el codigo fuete
http://members.lycos.co.uk/leeedavison/z80/led/
http://members.lycos.co.uk/leeedavison/z80/led/led_drvasm.html
a la vez zi alguien necesita un poco mas de informacion no dude en pedirla asi como tambien se agradecen todo tipo de comentarios
Publicado por: J0N4TH4N en 03 de Abril de 2005, 03:09:00
... queria consultarte.. los caracteres para formarlos, como piensas hacer?.. en columnas o en filas? .. me interesaria darte una mano ya que el tema de carteles luminosos de este tipo es interesante por su elevado costo. Si quieres agregame a tu msn y charlamos mas directo. Un Abrazoloco mal 8 arroba hotmail punto com
Publicado por: Micom en 04 de Abril de 2005, 00:13:00
Publicado por: xootraoox en 04 de Abril de 2005, 00:53:00
lo principal por ahora es ver como se podria trabajar con un registro de por lo menos 80 bits para poder almacenar hay los datos a enviar serialmente la verdad es que esa seria una solucion bastante eficiente para lo que pretendo hacer
bueno espero poder ver como hacerle para solucionarlo ya que lo unico que he encontrado es en c pero no se si se podra hacer con mas de dos registros
bueno el codigo que encontre en c es algo asi
make16(variable1,variable2)
y lo ideal seria porsupuesto
make80(variable1,variable2,variable3,variable4,variable5,variable6,variable7,variable8,variable9,variable10)
Publicado por: blocktel en 05 de Abril de 2005, 21:29:00
el mensaje a mostrar lo grabo en una eeprom 24lc08, y cada cierto tiempo deacuerdo al desplazamiento voy leendo cada letra, despues busco su respectiva trama y lo vuelco a los registros de desplazamiento...los mensajes lo grabo, manualmente con tres inerruptores, sube, baja y enter respectivamente..Todo esto me ocupa media pagina del pic16f628.
bueno a ver prueba con esto,
inicializar
.
movlw.80
movwf columnas
.
interrupcion
decfsz columnas; por cada interrupcion activas una columna
goto una_mas
movlw .80 ; nuevamente empieza
movwf columnas
uno_mas
movf columnas,w
movwf columna_sale
bsf bit_desplaza ; inicias
aqui
decfsz columna_sale
goto clock
; despúes que posicionaste la respectiva columna
; activas el ic
bsf activas_latch
nop
bcf activas_latch
retfie
clock; envias el reloj
bsf clock_sale
bcf clock_sale
bcf bit_desplaza ; ahora todos ceros
goto aqui
claro con esto empiezas a activar la primera columna de iz a derecha,
prueba a ver si funciona, es una sugerencia
suerte..
Publicado por: xootraoox en 06 de Abril de 2005, 03:58:00
amigo blocktel te explico... mi matriz esta formada por unos integrados del tipo shift registers que controlan las columnas pero estos estan en cascada por medio de una salida serial que poseen estos mismo y que trabajan mas menos de esta forma:
los 10 integrados se controlan con solo 3 pines del micro los cuales corresponden a
1- clock
2- data
3- latch
--bueno obviamente por cada bitenviado, sea alto o bajo, debe ir acompañado de un clock
--estos mismos trabajan en cierta forma como un buffer por que al enviar los primeros 8 bits de datos se activa la salida serial que poseen dejando en memoria los datos recibidos y dejan pasar los siguientes datos por su salida hacia los demas que esten en cascada es por eso que la trama de datos debe de ser larga, en este caso de 80 bits para controlar los 10 shift registers
Codigo:
******** ******** ********
data in-- ********--data out--data in-- ********--data out--data in--********--etc...
******** ******** ********
por lo que obviamente los ultimos 8 bits solo llegan hasta el ultimo shift register formandose asi la cascada
bueno el shift register usado es el *74hc595* pero con interface de potencia siendo este el *tpic6b595n* por lo que se ahorra espacio y costos ya que internamente esta dotado de transistores mosfet lo por lo que no es necesario agregar transistores para obtener mayor drenaje para los leds
bueno quizas es mucho pedir pero es posible que compartieras tu experiencia de lo comentado para poder ir probando nuevos metodos si es posible que nos comentaras el tipo de hardware que haz usado, que tipos de shift registers, etc...
y si es posible el codigo para poder llegar a algo mas concreto, ademas te comento que con un amigo de aqui tenemos planeado llevar esto lo mas lejos posible dotandolo de una buena interfas para el pc ya que el es programador y se maneja bien en el tema lo cual seria genial poder llagar a algo tan parecido como lo que se encuentra en el comercio ademas tenemos muchas ideas de como dotarlo de efectos mas alla de los del tipo comercial
bueno espero puedas "compartir informacion y desde ya la agradesco y me despido coordialmente
-==XooTRAooX==-
Publicado por: blocktel en 06 de Abril de 2005, 11:43:00
00111000 ;activas primera fila y envias el dato serial 00111000(74595) y apagas
01101100 ;activas 2da fila dato 01101100 y desactivas
11000110 ...
11111110 ...
11000110 ...
11000110
11000110 ; llegas ala ultima fila e inicias nuevamente
;si tienes 10 caracteres tendrias que activar la fila correspondiente y enviar despues serialmente el dato (10byte), una de cada caracter que corresponda a la fila.
suerte
Publicado por: xootraoox en 06 de Abril de 2005, 17:33:00
si es asi se hace un poco mas facil la cosa.
mira te explico un poco lo que pretendo realizar para que te hagas una idea de donde esta mi problema
lo que pasa es que para poder darle los efectos nesesarios a mi matriz primero necesito enviar los datos a unos registros en donde hay los procesaria a mi gusto, pero en mi matriz los caracteres van a ser de 7x5 puntos... lo que se resume en que es un poco mas complicado por que en tu caso se puede enviar las columnas completas de un caracter a un registro y procesarlas pero en el mio son solo los 5 columnas y a la hora de prosesarlos se complicaria un poco la cosa por que por ejemplo si quisiera hacer un efecto de scroll solo tendria que rotar esos registros pero resulta que solo 5 bits son utiles por lo que al rotar se me mesclarian con los tres bits del mismo en desuso...
lo que realmente en este caso seria conveniente es por ejemplo poder tener ya un registro mas grande como por ejemplo de 80 bits cosa de poder manipular las columnas completamente desde un solo registro ya que si quiero hacer un scroll solo roto ese registro sin preocuparme por nada.
no se si se entiende la idea de la forma que la he planteado, espero que si y alguien pueda giarme un poco en lo que no puedo realizar
Publicado por: blocktel en 07 de Abril de 2005, 09:37:00
;
cblock h"20"
byte1,byte2,byte3,byte4.................byte10 ; activo primera fila y envio
byte11,byte12..................................byte20
............ ........byte30
.......
......
.....
byte71........................ ..........byte80
encd
; cuando inicias tu programa blanqueas todos los byte (byte1 a byte80)
y cargas
movlw byte1
movwf fsr ;puntero
MOVLW H"BF" ; se activa la primera fila
MOVWF LINEA ; en mi caso h"BF" ; rotamos el cero
; despues creas una interrupcion de 1miliseg para activar cada fila
SIGUE_1MSEG
MOVLW .10
MOVWF COUNT_BYTE ;SE ENVIA 10 BYTEX FILA
PRIMERO
MOVF INDF,W ;
MOVWF BYTE ; bufer
;
MOVLW H"08"
MOVWF COUNT_BIT ;8 bit por byte
TX_XX
BCF DATO ;del 74hc595
RLF BYTE,1
BTFSC STATUS, CARRY
BSF DATO
CALL CLOCK ;ADENTRO
decfsz COUNT_BIT,1 ;ES OCHO BIT
goto TX_XX ;AUN
INCF FSR,1 ; si el proximo byte
DECFSZ COUNT_BYTE,1 ;acabo los 10
GOTO PRIMERO ; no el siguiente
; si acabo
MOVF LINEA,W ;tomo linea
MOVWF PORTB ; activo
NOP
BSF CARGO ; cargo byte lacth 74hc595
nop
BCF CARGO ; apago
NOP
BSf STATUS,CARRY
RRF LINEA,1 ;preoero la proxima fila
BTFSC STATUS,CARRY ; se acabo todas las filas
RETFIE ; no
MOVLW BYTE1 ;si empezamos denuevo
MOVWF FSR
MOVLW H"BF" ; se activa la primera fila
MOVWF LINEA ; bufer de salida a filas
RETFIE
CLOCK ; del 74hc595
bCf CK
NOP
NOP
bSf CK
RETURN
; chequealo bien y me comentas
hasta luego
Publicado por: xootraoox en 07 de Abril de 2005, 13:34:00
saludos desde chile
Publicado por: antoniof en 07 de Abril de 2005, 18:58:00
Por lo que he podido deducir, con los registros de desplazamiento lo que controlas son las columnas, es decir, si escribes un "1" en un registro y "latcheas" , este "1" activará el ánodo/cátodo común de los LEDs y los cátodos/ánodos de las filas los controlas aparte con un puerto de 7 bits del PIC, esta es la forma estándar de controlar una matriz de tantos puntos. Si es asi, no necesitas un registro de 80 bits para enviar un uno e irlo pasando de columna a columna. Tan sólo necesitas escribir un uno la primera vez y "latchear" y después escribes un cero y "latcheas" 79 veces más. Esto se puede hacer con un bucle normal de toda la vida.
Lo mejor viene cuando tengas que enviar los datos de la columna que estas "encendiendo" en ese momento por el puerto de 7 bits.
No se como anda ese PIC de memoria pero deberás reservar 80 registros para los desplazamientos de los mensajes hacia izquierda , derecha, arriba y abajo.
Se pueden hacer subrrutinas sencillas con el direccionamiento indirecto "fsr" e "indf" son muy utiles en estos casos.
Espero haberte ayudado. Dime si funciona asi tu "MATRIX".
Publicado por: xootraoox en 07 de Abril de 2005, 23:16:00
***
Tan sólo necesitas escribir un uno la primera vez y "latchear" y después escribes un cero y "latcheas" 79 veces más. Esto se puede hacer con un bucle normal de toda la vida.
***
no es factible en este caso... por que en realidad el latch es para desplegar de forma paralela los datos enviados de forma serial, por lo que si envio un uno y latcheo se encendera solo la primera columna y si lo coloco a cero nuevamente y lactheo 79 veces solo colocare 79 veces un cero en la primera columna.... entiendes?
por otra parte, nunca he tocado el tema ***direccionamiento indirecto "fsr" e "indf" *** y si alguien me pudiese explicar un poco de forma que pueda entender de lo que se trata ya que la verdad mi nivel en esto es bien basico ya que hace poco me he iniciado y solo he hecho cosas muy basicas y la verdad ya se que me he metido en un lio al haber dado un paso tan grande con este proyecto pero se que de alguna forma y con ayuda de uds podre sacarlo adelante y mi aprendizaje avanzara un buen tramo
por lo demas, desde ya extiendo mis agradecimientos a todos los de este gran foro
despide xootraoox
Publicado por: Micom en 08 de Abril de 2005, 00:33:00
Publicado por: antoniof en 08 de Abril de 2005, 05:03:00
Me acabo de bajar el datasheet del 74HC595 de Digchip.com.
Por lo que he podido comprobar, así funciona:
El pin 14 "DS" es por donde entras los datos serial.
El pin 11 "SH_CP" es el clock del registro de desplazamiento interno.
El pin 12 "ST_CP" es el clock del registro paralelo (el latch) que al macena el sato que hay en el registro de desplazamiento y cuya salida es el dato paralelo.
La secuanci que yo haría es la siguiente:
1.- Pongo un "1" en el pin DS.
2.- Doy un pulso de reloj en el pin SH_CP.
3.- Doy otro pulso de reloj en el pin ST_CP. (Ya tenemos un uno en la salida Q0).
4.- Pongo un "0" en el pin DS.
5.- Doy un pulso de reloj en el pin SH_CP. Con esto hemos desplazado el primer "1" a la segunda posición y tenemos un cero en la primera posición.
6.- Doy otro pulso de reloj en el pin ST_CP. (Se carga el cero que acabamos de meter en Q0 y el uno anterior en Q1).
7.-Los pasos 4 a 6 los repites 78 veces más, y cada vez que lo repitas el "1" va cambiando de posición.
Cuando latcheas no borras el contenido del registro de desplazamiento interno, por lo que el "1" sigue hay, solo tienes que ir desplazandolo y latcheandolo sucesiavamente. En el propio datasheet del IC viene un ejemplo que muestra esta función.
Publicado por: antoniof en 08 de Abril de 2005, 05:24:00
El caracter lo voy a representar de la siguiente forma:
bit 7 --> 0 1 1 0 0
bit 6 --> 1 0 0 1 0
bit 5 --> 1 0 0 1 0
bit 4 --> 1 1 1 1 0
bit 3 --> 1 0 0 1 0
bit 2 --> 1 0 0 1 0
bit 1 --> 1 0 0 1 0
bit 0 --> 0 0 0 0 0
Cada columna del caracter la voy a almacenar en un registro del PIC
Tenemos, por lo tanto, 5 registros de 8 bits que llamaremos, por ejemplo, col1, col2.. col5, que ocupan los registros 0x20, 0x21.... 0x24 del PIC:
col1 equ 0x20
col2 equ 0x21
col3 equ 0x22
col4 equ 0x23
col5 equ 0x24
movlw 0x7e
movwf col1
etc....
Vamos a la rutina de desplazamiento a derechas.
El registro fsr del PIC se utiliza como puntero, es decir, en el indicas la dirección de memoria que vas a leer o escribir. A través del indf, lees o escribes la dirección de memoria a la que apunta el fsr. Por lo tanto si quieres leer por ejemplo la dirección 0x20, el programa seria:
movlw 0x20
movwf fsr
movf indf,w
En nuestro ejemplo, tendrias el valor 0x7e en el registro w.
Continua en el sisuiente mensaje
Publicado por: xootraoox en 08 de Abril de 2005, 11:26:00
despide -==XooTRAooX==-
Publicado por: xootraoox en 08 de Abril de 2005, 11:54:00
bueno les dejo el pdf y el asm modificado por mi para que lo vean
Publicado por: xootraoox en 08 de Abril de 2005, 20:32:00
para los que les acomode en formato PROTEL DXP
para los que les acomode en formato PDF (acrobat reader)
Publicado por: Micom en 08 de Abril de 2005, 21:51:00
Publicado por: xootraoox en 08 de Abril de 2005, 22:17:00
00000001
00000011
00000111
00001111
00011111
00111111
01111111
11111111
bueno con eso podran notar que al encender el primer led quizas enciende sin problemas pero ya al encender el segundo el brillo caera casi a la mitad y bueno si continuan encendiendo hasta los 8 leds el brillo decaera demaciado es por eso que es mejor usar el tpic6b595 que ya poseen una etapa de mayor drenaje pensada justo para estos casos.... en el caso mio enciendo hasta 12 leds con una misma salida sin ningun problema.... tambien hay otros que reemplazan al tpic6b595 pero en este momento no merecuerdo cuales son
en todo caso les dejo los datasheets de los 2 para que vean que es exactamente lo mismo salv que trae mas pines 2 que no se utilizan mas otros que sirven de gnd, etc
74hc595
tpic6b595
NOTA: El tpic6b595 no es un producto de la conocida empresa microchip
Publicado por: xootraoox en 09 de Abril de 2005, 01:44:00
.... y si estoy en lo correcto es exactamente lo que buscaba ya que permite guardar y leer datos secuencialmente en las paginas del micro (corrijanme si estoy equivocado) como por ejemplo... me aseguro de dejar un espacio sin usar en una de las paginas como por ejemplo MEMORIA equ 0x20
y desde hay voy escribiendo datos por medio de un contador que vaya incrementando la direccion, en otras palabras voy almacenando secuencialmente a lo largo de la pag. los datos
0x20 = 00000000
0x21 = 00000001
0x22 = 00000010
0x23 = 00000100
0x24 = 00001000
0x25 = 00010000
0x26 = 00100000
0x27 = 01000000
0x28 = 10000000
y asi sucesivamente, para luego leer los mismos...... si es asi por favor haganmelo saber por que esa seria la solucion que estaba buscandoya que asi generaria un buffer de 80 bits de forma totalmente efectiva....
ahora la verdad es que todabia no entiendo bien el como aplicarlo es por eso que agradeceria algun tipo de ejemplo en el cual se realize lo que he comentado... osea definir una direccion para la memoria y escribir aunque sean 2 direcciones de la misma (por ejemplo 0x20, 0x21) y luego leerlas para enviarlas a uno de los puertos
he editado este posT para comentar que el ejemplo ya no es necesario ya que al instante de postear encontre lo que queria es por eso que lo coloco aqui por si alguien necesita un ejemplo DEL DIRECCIONAMIENTO INDIRECTO
EJEMPLO DIRECCIONAMIENTO INDIRECTO
bueno ya se que hasta aqui he pedido mucho pero de verdad es que mi deseo es aprender el arte de manejar a estos animalitos llamados pic y es por eso que agradesco la comprencion y ayuda prestada y no duden en que una vez que entienda todo esto sere uno mas de uds ayudando a los demas a resolver sus dudas
una vez mas agradesco lo que hacen
