RTC V3021 y otros

[wantxapas]

Hola!

Llevo unos días con un proyecto entre manos y con uno cuantos, bastantes, problemas...

Estoy diseñando un sistema con un PIC 16F877 el cual estoy programando en C con el compilador Hi-Tech.

En dicho sistema tengo un DS1307 y una memoria 24LC256 ambos conectados por el bus I2C y con sus resistencias de pull up del 10K. Todo esto lo he simulado en proteus y funciona correctamente.

Bien, aquí comienzan los problemas, el DS1307 no quiere funcionar, por más que lo intento es imposible, pero el bus I2C si que funciona ya que si quito el integrado del RTC la memoria I2C recibe y envía datos.
He leido que el cristal de 32768KHz debe tener una capacidad de 12,5pF y me ha sido imposible encontrarlo en las tiendas que he podido visitar, creo que ese puede ser el problema, he probado al menos 4 cristales. ¿Alguna idea de por qué puede ser si no es esto?

Bueno, finalmente a lo que iba, como no consigo que funcione he decidido utilizar un V3021 que tenía en una placa con su cristal y todo, pero ando un poco perdido, he generado varias funciones de lectura y escritura pero aunque en el osciloscopio veo la señal como, según yo creo debe ser, no me devuelve ningún valor.
¿Alguien tiene experiencia con este reloj?

Un saludo y mil gracias!!

[el_escudo]

Un saludo.

Hace un tiempo hice aguna cosa con este rtc. intentare buscar los programas.

Pero... has tenido en cuenta la rutina de inicializacion del reloj????

Reset and Initialization
Upon microprocessor recovery from a system reset, the V3021
must be initialized by software in order to guarantee that it is
expecting a communication cycle (i.e the internal serial buffer is
waiting for the address bit A0). Software can initialize the V3021
to expect a communication cycle by executing 8
microprocessor reads (see Fig. .

Viene en el datasheet del reloj.


Compruebalo.

Un saludo.

[wantxapas]

Hola! Gracias por contestar!

Si, he tenido en cuenta l ainicialización, y me queda algo así:

Código: [Seleccionar]

void ConfigurarV3021(void)
{
PCFG3=0; //Puerto A como Digital
PCFG2=1;
PCFG1=1;
PCFG0=0;

TRISA1=0; //Puerto A como salida
TRISA2=0;
TRISA3=1; //IO como entrada

ResetV3021(); //Secuencia de reset

EnviarDatoV3021(0xF0,0x00); //Enviamos el valor 0 al Stautus0
}

void ResetV3021(void)
{
unsigned char lecturaV3021;

WR=1; //Ponemos WR a 1
RD=1; //Ponemos RD a 1

for(i=0;i<8;i=i+1) //Repetimos la secuencia 8 veces
{
RD=0; //Flanco de bajada en RD
__delay_us(0.060); //Esperamos 60ns(TAAC)
lecturaV3021=IO; //Leemos el dato
RD=1; //Flanco de subida
__delay_us(0.120); //Esperamos 120ns (TW)
}
}

void EnviarDatoV3021(unsigned char DireccionReloj, unsigned char DatoEnvio)
{
union
{
unsigned char Completo;
struct
{
unsigned char LSB:1;
unsigned char Nada:6;
unsigned char MSB:1;
}Parte;
}Dato;

union
{
unsigned char Completa;
struct
{
unsigned char LSB:1;
unsigned char Nada:7;
}Parte;
}Direccion;

Direccion.Completa=DireccionReloj; //Almacenamos la dirección de escritura
Dato.Completo=DatoEnvio; //Almacenamos la dirección de lectura
TRISA3=0; //IO como salida

for(i=0;i<8;i=i+1) //Repetimos la secuencia 4 veces
{
IO=Direccion.Parte.LSB; //Ponemos el LSB de la direeción en IO
WR=0; //Flanco de bajada en WR
Direccion.Completa=Direccion.Completa>>1; //Desplaza la direeción
__delay_us(0.060); //Esperamos 60ns(TAAC)
WR=1; //Flanco de subida en WR
__delay_us(0.120); //Esperamos 120ns (TW)
}

for(i=0;i<8;i=i+1) //Repetimos la secuencia 8 veces
{
IO=Dato.Parte.LSB; //Ponemos el LSB del dato en IO
WR=0; //Flanco de bajada en WR
Dato.Completo=Dato.Completo>>1; //Desplaza el dato
__delay_us(0.060); //Esperamos 60ns(TAAC)
WR=1; //Flanco de subida en WR
__delay_us(0.120); //Esperamos 120ns (TW)
}
}

unsigned char LeerDatoV3021(unsigned char DireccionReloj)
{
unsigned char DatoReloj;
union
{
unsigned char Completo;
struct
{
unsigned char Nada:7;
unsigned char MSB:1;
}Parte;
}Dato;

union
{
unsigned char Completa;
struct
{
unsigned char LSB:1;
unsigned char Nada:7;
}Parte;
}Direccion;

Direccion.Completa=DireccionReloj; //Almacenamos la dirección de lectura
TRISA3=0; //IO como salida

for(i=0;i<8;i=i+1) //Repetimos la secuencia 4 veces
{
IO=Direccion.Parte.LSB; //Ponemos el LSB de la direeción en IO
WR=0; //Flanco de bajada en WR
Direccion.Completa=Direccion.Completa>>1; //Desplaza la direeción
__delay_us(0.060); //Esperamos 60ns(TAAC)
WR=1; //Flanco de subida en WR
__delay_us(0.120); //Esperamos 120ns (TW)
}

for(i=0;i<8;i=i+1)
{
RD=0; //Flanco de bajada en RD
TRISA3=1; //IO como entrada
__delay_us(0.060); //Esperamos 60ns(TAAC)
Dato.Parte.MSB=IO; //Almacenamos el dato en IO
Dato.Completo=Dato.Completo>>1; //Desplaza el dato
RD=1; //Flanco de subida en RD
__delay_us(0.120); //Esperamos 120ns (TW)
}

TRISA3=0; //IO como salida

return(Dato.Completo); //Devuelve el dato almacenado
}
Es bastante probable que esté ahí el error.
Si me pudieses pasar algo de info te lo agradercería.

Un saludo!

[el_escudo]

que micro usas y con que reloj?

[wantxapas]

Pues en un PIC 16F877 a 4MHz.
El compilador es el HI-TECH

[el_escudo]

Un saludo wantxapas.....

Sigo buscando...... que me he cambiado de piso y no se donde tengo lo que se que tengo.

Lo que si te puedo decir es que son inutiles todos esos delays de menos de 1 us ya que el ciclo minimo de instruccion a 4 mhz es de 1 us. ( entiendo yo )

Me pierdo con el HI-TECH.... espero que te sirva en ensamblador o ccs.

Espero contarte algo hoy o mañana. un saludo.

[wantxapas]

Muchas Gracias!

Aunque tampoco tengo mucha experiencia con ensamblador y CCS ya buscaré la manera de ir viendolo, ahora mismo estoy bastante atascado y valoro mucho tu ayuda.

Un millon de gracias! 

[el_escudo]

hola wantxapas......

vamo a ve.

definamos un poco el tema........

el reloj v3021 se puede comunicar con el pic usando 2 tipos de protocolo : intel y motorola

el mas sencillo de implementar es el de motorola, ya que en este se unen los pines de cs y ds quedandote solo 3 lineas para controlar el reloj.. a saber:

(cs-ds) los 2 pines arrejuntaos.

r/w

data i/o


definido en el datasheet como 3 wire serial interface

si pones el pin cs-ds a nivel bajo y luego alto mientras el r/w esta a nivel bajo estas escribiendo en la ram del reloj
si pones el pin cs-ds a nivel bajo y luego alto mientras el r/w esta a nivel alto estas leyendo de la ram del reloj


de los timming waveforms ( todo eso de tcs, tacc,twc.....  que son tiempos del orden de 200 ns maximo...) olvidate, ya que el micro es mucho mas lento y su cambio de estado en un bit mas corto para 4 mhz es 1 us como te dije...... y por eso no vamos a andar pillaos de tiempo ( al reloj le da tiempo a hacer todo lo que tiene que hacer, antes de que nosotros le pidamos algo mas)


a ver... lo primero...... una secuencia de inicializacion.......
esta es la tuya.........

void ResetV3021(void)
{
   unsigned char lecturaV3021;
   
   WR=1;         //Ponemos WR a 1
   RD=1;         //Ponemos RD a 1

   for(i=0;i<8;i=i+1)   //Repetimos la secuencia 8 veces
   {
      RD=0;            //Flanco de bajada en RD
      __delay_us(0.060);   //Esperamos 60ns(TAAC)
      lecturaV3021=IO;   //Leemos el dato
      RD=1;            //Flanco de subida
      __delay_us(0.120);   //Esperamos 120ns (TW)
   }
}


como lo que se pretende es dejar al reloj a la espera de una orden de escritura....( no sabemos como arranca tras un reset......) hay que hacer como que leemos un byte de datos...... osea 8 ciclos de lectura.....

no necesitamos realmente guardar ese dato...... solo hacer como que lo leemos.

entonces yo lo reduciria a esto:

void ResetV3021(void)
{
   
   int i;
   
            WR=1;         //Ponemos WR a 1  ya que vamos a leer
   RD=1;         //Ponemos RD a 1 ( aqui si te fijas en la figura 15 del datasheet el pin cs lo vamos a unir al rd)

   for(i=0;i<8;i=i+1)   //Repetimos la secuencia 8 veces
   {
      RD=0;            //Flanco de bajada en RD+cs
      RD=1;            //Flanco de subida  ( este pulso ya dura 2 us minimo )
   }
}


con esto ya hemos hecho 8 ciclos de lectura........ ( no importa si pones mas de 8 en el bucle for...... ) pero como minimo 8.

con esto el reloj ya esta listo para recibir una secuencia de lectura o escritura en condiciones.



paso 2.

vamos a leer la ram del reloj.

lo primero que hay que hacer es enviar un copy_clock_to _ram

segun puedes ver en la figura 9 del datasheet; sino, no copias los datos del reloj ( zona restringida) a la ram.

lo que tenemos que mandar al relol es una f en binario osease... 1111 ( ver tabla 6)

al mandarle esto al reloj copia los datos de la parte reservada a la parte que podemos leer.

la secuencia a nivel humano seria.......

      ponemos el pin r/w a 0 ( escritura )

      ponemos el pin de datos a 1 ( ya que vamos a escribir 4 unos )

      ponemos 4 veces el pin  (cs-ds) a cero y luego a 1  ( con esto escribo esos 4 bits en la ram )


ya hemos enviado un address command cicle y ya tenemos en la ram, que podemos leer, los datos del reloj.


ahora a leer los segundos ( por ejemplo)


ponemos r/w a 0 ( vamos a mandarle la direccion ram de los segundos al reloj)

como estos estan en la direccion 2  sacamos el dato  0010 alternado estos bits en i/o con pulsos en el pin ( cs-ds )

cero-pulso-cero-pulso-uno-pulso-cero-pulso  ( yo esto lo hago a pinrel sin bucles for ni rotaciones de byte.... que me lio) ( por lo menos en puebas hasta que veo que funciona....... luego ya toca pulirlo y dejarlo guapo )

luego ponemos r/w a 1 ( el reloj nos va a dar el dato de los segundos ya que ha reconocido la direccion de estos)

pulso en pin cs-ds
leemos bit d0 en pin i/o
pulso en pin cs-ds
leemos bit d1 en pin i/o
.
.
.
.
.
.
pulso en pin cs-ds
leemos bit d7 en pin i/o

esto ya con rotacion de byte o como mas te guste.

ya tenemos el dato en bcd de los segundos ( por ejemplo 00010010  osease el 12 en decimal, si no meto la pata) 12 segunditos

este dato en bcd hay que pasarlo a ascii si lo quieres representar en un lcd


si repitiendo todo esto ( haciendolo de nuevo desde el copy clock_to_ram ) vemos que nos cambia el valor de los segundos ya lo tenemos todo hecho.
lo demas es to igual


no se por que defines tantas variables char....... si el reloj lo que da son numeros binarios codificados en bcd correspondientes a las horas, minutos.......... y lo que hay que hacer es leerlos como numeros binarios de 8 bits ( creando las variables como int, no char) y luego convertirlos a lo que necesitemos.



espero que te haya dado alguna pista de por donde continuar. un saludo.

haz alguna prueba y me cuentas.

[el_escudo]

rebuscando he encontrado mi v3021 por ahi.... si tienes problemas lo conecto y hago alguna prueba yo.

unas fotos para que alguien se ria un poco ( era lo que habia.......) jeje

[wantxapas]

Que pasada de respuesta!!!

Gracias!!!

Este finde me pongo con ello y te cuento que tal!

Lo dicho, mil gracias!

[el_escudo]

mira que con lo de " que pasada de respuesta" me vengo arriba. jeje

sera una buena respuesta si te sirve....... espero que si.

Y espero que tras el fin de semana este el reloj "relojeandote"....

Un saludo.