Programación Específica > Microcontroladores
Cargar Una E2prom Con Usart Del 16f628
pikman:
Hola, bueno, aqui dejo el codigo, como esta funciona en un 16F877 u otro que tenga puerto C, por lo tanto hay que modificar esto, tambien debe usarse la instruccion tris para los 16CX (los de 12 bits) en lugar de cargar el registro tris, por lo tanto si se pretende usar un PIC16C55 por ejemplo ( pues este posee port C), se debe reemplazar esto
bsf STATUS,RP0
movlw b'11100111'
movwf TRISC
bcf STATUS,RP0
por
movlw b'11100111'
tris portc
Y ademas las direcciones de los registros de RAM, que pueden lelgar a ser posiciones usadas en otros procesos, o bueno si les sobra memoria las dejas solo para esto, pero no olviden este precioso detalle.
Como podran observar mas abajo, cada vez que se realiza una operacion se programa el sentido de los pines, se puede llegar a optimizar, y eliminar algunas
operaciones pero para entender la rutina se las dejo asi, y por supuesto no olviden que el valor binario que cargan al registro debe contener las direcciones fijas de los otro pines, y por ultimo las lineas SDA y SCL deben tener una resistencia de PULL-UP de 100K al +VCC, en algunos circuitos omiten la de SDA, pero les aconsejo porner las dos si no le puede llegar a doler la cabeza.
Es posible, en los micros que lo disponen, activar en el portB los week pullup, con esto se pueden omitir las resistencias internas.
Al final hay dos rutinas una que lee y otra que escribe un byte determinado de la memoria.
No todas las 24XX son iguales, de la 24C16 en adelante la direccion es de 16 bits, y si se va usar la 24LC16 mucha atencion que su direccionamiento no es igual, de cualquier modo les recomiendo leer la hoja de datos de la memoria que vayan a utilizar, basicamente estas rutinas pueden ser usadas para cualquiera.
saludos y espero que les sirva.
PIKMAN / ARIEL
;====================================================================
; Definicion de registros auxiliares en RAM para manejo de la memoria
; Rutina generica para microcontroladores sin MSSP, totalmente
; FIRMWARE es aplicable en cualquier microcontrolador, de la linea 16c6xx
; para los 16c5x hay que modificar los registros TRIS si no no anda
;====================================================================
ADDR equ 0x30 ; direccion a escribir
DATAO equ 0x31 ; dato a escribir
SLAVE equ 0x32 ; direccion de esclavo
TXBUF equ 0x33 ; buffer de tx
COUNT equ 0x34
EEPROM equ 0x35
RXBUF equ 0x36 ; buffer de rx
LOOPS equ 0x37
LOOPS2 equ 0x38
BCOUNT equ 0x39
; Definicion de Bits Para para manejo de la memoria
DI equ 7 ; bits internos
DO equ 6
SDATA equ 4 ; pines SDA ( datos) y SCL ( clock ) I2C
SCLK equ 3 ; en este caso programa los pines 3 y 4
; modificar segun circuito.
;==============RUTINA PARA GENERAR BIT DE START===================
BSTART
bsf STATUS,RP0
movlw b'11100111'
movwf TRISC
bcf STATUS,RP0
bcf PORTC,SCLK
bsf PORTC,SDATA
nop
bsf PORTC,SCLK
nop
nop
nop
nop
nop
bcf PORTC,SDATA
nop
nop
nop
nop
nop
bcf PORTC,SCLK
nop
nop
return
;==============RUTINA PARA GENERAR BIT DE STOP===================
BSTOP
bsf STATUS,RP0
movlw b'11100111'
movwf TRISC
bcf STATUS,RP0
bcf PORTC,SCLK
bcf PORTC,SDATA
nop
nop
nop
bsf PORTC,SCLK
nop
nop
nop
bsf PORTC,SDATA
nop
nop
bcf PORTC,SCLK
nop
nop
nop
return
;==============RUTINA PARA ENVIAR BIT HACIA LA MEMORIA============
BITOUT
bsf STATUS,RP0
movlw b'11100111'
movwf TRISC
bcf STATUS,RP0
bcf PORTC,SCLK
bsf PORTC,SDATA
btfss EEPROM,DO
bcf PORTC,SDATA
nop
nop
bsf PORTC,SCLK
nop
nop
nop
nop
bcf PORTC,SCLK
return
;==============RUTINA PARA RECIBIR BIT DESDE LA MEMORIA===========
BITIN
bsf EEPROM,DI
bsf STATUS,RP0
movlw b'11110111'
movwf TRISC
bcf STATUS,RP0
bcf PORTC,SCLK
bsf PORTC,SCLK
nop
nop
nop
nop
nop
nop
nop
nop
btfss PORTC,SDATA
bcf EEPROM,DI
bcf PORTC,SCLK
return
;==============RUTINA TRANSMITIR UN BYTE ===================
TX
movlw .8
movwf COUNT
TXLP bcf EEPROM,DO
btfsc TXBUF,7
bsf EEPROM,DO
call BITOUT
rlf TXBUF,1
decfsz COUNT
goto TXLP
call BITIN
return
;==============RUTINA PARA RECIBIR UN BYTE========================
RX
clrf RXBUF
movlw .8
movwf COUNT
bcf STATUS,C
RXLP rlf RXBUF,F
call BITIN
btfsc EEPROM,DI
bsf RXBUF,0
decfsz COUNT
goto RXLP
bsf EEPROM,DO
call BITOUT
return
;==============RUTINA PARA LEER UN BYTE DE LA MEMORIA=============
LEER
call BSTART ; Se genera Bit de START
nop
nop
bcf SLAVE,0 ; Selecciona el modo de escritura
movfw SLAVE ; del dispositivo esclavo
movwf TXBUF ; Tranb
call TX ;
movfw ADDR
movwf TXBUF
call TX
nop
nop
call BSTART
nop
nop
bsf SLAVE,0
movfw SLAVE
movwf TXBUF
call TX
nop
call RX
bsf EEPROM,DO
call BITOUT
call BSTOP
return
;==============RUTINA PARA ESCRIBIR UN BYTE DE LA MEMORIA=============
ESCRIB
call BSTART ; Se genera bit de START
nop
nop
bcf SLAVE,0 ; Selecciona modo escribir en
movfw SLAVE ; la direccion del esclavo y se pone en W
movwf TXBUF ; Se transfiere W al buffer de TX
call TX ; Se transmite el byte a la memoria
movfw ADDR ; Se carga en W la direccion a escribir
movwf TXBUF ; Se transfiere W al buffer de TX
call TX ; Se transmite el byte a la memoria
nop
nop
movfw DATAO ; Se transfiere a W el dato a escribir
movwf TXBUF ; Se transfiere W al buffer de TX
call TX ; Se transmite el byte a la memoria
call BSTOP ; Se Genera bit de STOP
movlw .20 ; Carga 20 milisegundos
movwf LOOPS ; Para esperar que termine
call WAIT ; la escritura en la memoria
return ; Y retorna
goto WAIT
WAIT1 movlw .150
goto WAIT
WAIT ; Retardo de W milisegundos
movwf TEMP3
TOP2 movlw .110
movwf TEMP4
TOP nop ; sit and wait
nop
nop
nop
nop
nop
decfsz TEMP4,F ; inner loop done?
goto TOP ; no, go again
decfsz TEMP3,F ; outer loop done?
goto TOP2 ; no, go again
return
;=================================================================
Huguen_aus_Tirol:
Hola Pikman! Muy buenas las rutinas! :)
Solo quiero corregir un pequeño detalle. Las R de 100K son un poco grandes, puedes llegar a tener problemas, con 10K ya estaría super...
Cuando usas el PIC como maestro, la linea SCL es salida, por lo que no puedes habilitar la R interna; cuando el micro envia información a la memoria, SDA es salida, por lo que tampoco se puede habilitar la R interna. Es decir que si o si se necesitan las R afuera.
Por lo demás, está perfecto!
Un abrazo
Saludos! :hola:
Hugo
Ivan N.:
Buenas a todos! Antes que anda soy nuevo en el foro y la verdad que felicito a esta comunidad por la seriedad con que toman las consultas.
Antes que nada voy a aclarar un poquito mi situacion. Soy estudiante de electronica, mas precisamente estoy en una secundaria con orientacion electronica. Para poder recibirme tengo que realizar un proyecto a modo de prueba final. Mas o menso lo que estoy haciendo, o mejor dicho tratando de hace que un pic conectado a un telefono, guarde en su memoria el numero al que se desea llamar y lo compare con una lista de numeros permitidos previamente almacenados. Uno de los problemas principales es que recien comenzamos a aprender a programar pics hace unos 3 meses, por lo tanto mis conocimientos sobre el tema no son muchos (por suerte desde hace unos años se nos enseña a programar con orientacion a bajo nivel :D ). El segundo problema es que sabiendo que lso numeros telefonicos tienen varios numeros y que por cada numero necesito un byte, y si ademas se tiene en cuenta que necesitare almacenar al menos unos 50 numeros telefonicos, la memoria del pic es un gran problema segun me dijieron algunos profesores. Asi mismo me dijieron que iba a tener que usar una memoria externa del tipo 24LCXX.
Bueno hasta aqui la breve situacion xD. Ahora si las consultas:
Leyendo material que fui bajando de varios lugares sobre este tipo de memorias y lso pics, me di cuenta de que funcionan con un protocolo I2C y que estan los masters y los slaves.
1º En mi caso el pic que necesitaria tendria q ser master ya q la memoria es slave, verdad?
2º Que tipo de instrucciones se utilizan para escribir datos en la memoria desde el pic (siendo este el master) y cuales se utilizan para leer datos de la memoria?
3º Cuales son los registros que controlan la comunicacion I2C?
Y por ultimo si alguien fuera tan amable de dejar algun ejemplo de un codigo que utilice estas instrucciones y registros para escribir y leer datos de la memoria se agradeceria muchismo! Desde ya muchas gracias!
Huguen_aus_Tirol:
Bienvenido!
Me parece un proyecto interesante... Existen algunos integrados que se encargan de convertir los tonos DTMF en su correspondiente valor binario (de 4 bits); deberías buscar cual es el que consigues en tu zona.
En segundo lugar, los codigos binarios que se generan son de 4 bits, es decir las teclas del 0 al 9, el *, el #, y digamos C, D, E y F para las otras cuatro posibilidades (normalmente no las tenemos en los teléfonos). Es decir, que por byte podemos guardar 2 "teclas" del teléfono. Tomando algún micro con EEPROM interna de 128 bytes, podrías almacenar 256 digitos, digamos que unos 25 números telefónicos.
Pero si prefieres usar una memoria externa, podrías guardar más números, u otros datos (tiempo de llamada, fecha, etc.)
En este caso, lo mejor es que busques un micro con modulo I2C incorporado. Lee en la hoja de datos todo lo relacionado a este modulo e intenta escribir el programa y probarlo; no es algo muy complicado, solo hay que escribir correctamente los distintos registros. También vas a necesitar la hoja de datos de la memoria que uses (todo se encuentra en la red)
No hay instrucciones específicas para escribir o leer estas memorias, tienes que escribir las rutinas para estas tareas
Bien, busca la información, la lees y después nos cuentas... Mientras veo que puedo conseguirte de ejemplo
Saludos!
Ivan N.:
Muchas gracias por tu interes!
Te cuento que toda la parte del harware ya la tengo desarrollada y 100% funcionando :D . En efecto para la deteccion de tonos uso un simple integrado, en mi caso el CM8870. Este integrado, como todos los otros decodificadores DTMF, posse 5 salidas de datos, 4 que se utilizan para brindar un numero binario correspondiente a la tecla presionada como bien dijiste, y otro que avisa de la presencia de un tono DTMF decodificado en la salida (todo aquel que desee mas informacion sobre el tema no dude en preguntar xD).
Lo que planteas de guardar 2 teclas por byte es muy interesante ya q asi ahorraria bastante espacio... pero al verdad es q nose muy bien como hacerlo. Tendria q ir preguntando bit por bit e ir guardando bit por bit con la instruccion bsf Numero,x (aca va una duda muy de principiante: La x que indicaria el numero del bit que pongo a 1, puede ser un contador que se valla incrementando de a uno? )
Y el tema del pic, tendria q se un pic q traiga el modulo MSSP, o sea q sea master?
Por q encontre por varios lados que hay 2 tipos de pic con I2C, uno q es simplemente I2C, y que hay que armar todo un programa como el que postearon mas arriba, y despues hay otro que es MI2C, que segun lei en varios lados toda la interfaz de software q hay q hacer en el otro caso ya biene integrada en el mismo hardware. Con esto pienso q en el segundo caso el programa deberia ser menos engorroso. Y en lo personal apunto a que si esto es asi utilizar un pic con esta caracteristica para alivianar el programa xD
Estube viendo unas hojas de datos de pic q traen el MSSP pero no encontre en ninguna ejemplos practicos de como serian las lineas de codigo para grabar o leer memorias con esto... :(
Si alguien me puede sacar todas estas dudas se agradece! xD
Navegación
[#] Página Siguiente
[*] Página Anterior
Ir a la versión completa