Calibrar el rtc por "smooth calibration"

[juaperser1]

Siento no haber contestado antes, he estado fuera de servicio un tiempo 

Pero bueno, este tiempo ha servido para que me lleguen los GPS que me recomendaste Picuino.

Ya los he probado y medido con un osciloscopio y da los pulsos a 1 segundo exactos, ademas coge señal bastante rápido.

Vale, lo dejamos que ya había configurado un timer para capturar los pulsos del LSE (reloj externo de 32.768KHz).

Con eso sirve.
Ahora tienes que configurar otro contador para que cuente los pulsos de alta frecuencia del oscilador principal.

Los dos contadores deben funcionar a la vez.

¿Para que necesito los pulsos del reloj principal de 64Mhz? aquí me he perdió un poco. Ademas no creo que pueda capturar los pulsos del reloj de 64Mhz, ya que el propio programa deberia ir mas rapido para poder capturarlos no?

un saludo.

[Picuino]

Los necesitas para medir tiempo y tener una medida con mayor exactitud.
Si no puedes capturar esa frecuencia, el micro dejará la opción de capturar la frecuencia de reloj dividida por dos (en los micros de 32bits de Atmel al menos es así)

[juaperser1]

Los necesitas para medir tiempo y tener una medida con mayor exactitud.
Si no puedes capturar esa frecuencia, el micro dejará la opción de capturar la frecuencia de reloj dividida por dos (en los micros de 32bits de Atmel al menos es así)

A ok no te habia entendido, lo que te refieres es que configure un timer con un TICK de 64 MHz del reloj interno, si eso no hay problema le pongo el prescaler a 1 y ya esta, lo que daria que un tick seria 1/64Mhz.

pues ya están los dos timer, uno que captura el pulso en alto del LSE y otro que funciona a una frecuencia de 64Mhz.

al timer que captura el LSE le he puesto una interrupción para que me salte cada vez que me llega el pulso.

un saludo.

[Picuino]

Ahora tienes que tomar mediciones de un segundo. Cada segundo tienes que borrar el bit de interrupción y habilitar la interrupción para que lea los contadores y deshabilitas la interrupción dentro de la propia rutina.

En una variable guardas el valor anterior y en otra variable guardas el nuevo valor de cada contador.
La resta de ambas te dará el número de pulsos en un segundo.

La frecuencia es igual a pulsos del contador de LSE * 64000000.0 / pulsos del contador de TICKS
Todo calculado con flotantes de doble precisión (double)

[Picuino]

Te dejo pseudocódigo

int32 time_now, time_old, pulses_now, pulses_old;
volatile bit lectura = 0;
double frecuencia;


main() {
   setup_contadores()
   reset_contadores()
   time_now = 0
   pulses_now = 0

   while(1) {
      time_old = time_now
      pulses_old = pulses_now

      delay_ms(1000)

      Interrupt Flag = 0
      Interrupt Enable = 1
      esperar hasta que (lectura == 1)
      lectura = 0

      frecuencia = 64000000.0 * (double)(pulses_now - pulses_old) / ((double)(time_now - time_old));
      printf("Tiempo=%lu\n", time_now - time_old)
      printf("Frecuencia=%5.5f\n", frecuencia)
   }
}


ISR() {
   pulses_now = contador de LSE
   time_now = contador de TICKS

   Interrupt Enable = 0
   Interrupt Flag = 0

   lectura = 1
}

[Picuino]

Con eso tendrás la lectura de frecuencia del oscilador de 32kHz.


Ahora necesitas también tener la lectura de frecuencia del pulso por segundo del GPS.
Para ello configura el contador del oscilador de 32kHz para que cuente pulsos externos y colocas en el pin correspondiente la señal de 1PPS del GPS.

En realidad deberías medir primero el GPS, ajustar la fórmula de frecuencia y luego medir la señal de 32kHz

[juaperser1]

Te dejo pseudocódigo

int32 time_now, time_old, pulses_now, pulses_old;
volatile bit lectura = 0;
double frecuencia;


main() {
   setup_contadores()
   reset_contadores()
   time_now = 0
   pulses_now = 0

   while(1) {
      time_old = time_now
      pulses_old = pulses_now

      delay_ms(1000)

      Interrupt Flag = 0
      Interrupt Enable = 1
      esperar hasta que (lectura == 1)
      lectura = 0

      frecuencia = 64000000.0 * (double)(pulses_now - pulses_old) / ((double)(time_now - time_old));
      printf("Tiempo=%lu\n", time_now - time_old)
      printf("Frecuencia=%5.5f\n", frecuencia)
   }
}


ISR() {
   pulses_now = contador de LSE
   time_now = contador de TICKS

   Interrupt Enable = 0
   Interrupt Flag = 0

   lectura = 1
}

Contar los pulsos del LSE no es problema, pero el contador de TICK para el tiempo se me va ha desbordad si esta contando pulsos a 64Mhz durante 1 segundo, ya que el timer solo es de 16bits. El timer a 64Mhz da como mucho para 1mS.

1/64MHz * 2^16 = 0,001024 Segundos.

Siguiendo tu idea, ¿podría ser por ejemplo cuando reciba el pulso del GPS echo a andar un timer con la frecuencia del LSE, y al segundo pulso ver cuanta diferencia existe en el timer del LSE y cuando deberia ser?

[Picuino]

Creía que tenías contadores de 32 bit.

En ese caso es más complejo, tienes que ampliar el contador a 32 bit contando los desbordamientos con una rutina de interrupción. Evitar que en la lectura se produzca un desbordamiento es difícil, pero no creo que plantee problemas en tu aplicación y no veo necesario que lo tengas en cuenta.

[juaperser1]

A ver, pues esto es lo que he podido hacer.

No he conectado todavia el GPS, pero estoy simulandolo con un timer a milisegundo (timer14). cuando llega a 1000, conecto enciendo los timer 17(64MHz) y el timer 16 que captura los pulsos ascendentes del LSE (32,768KHz)

cuando llega al segundo 2 paro los timer (es decir al segundo pulso que me de el GPS) y miro los valores de los contadores.

el timer que mide el LSE tengo que tenerlo con una interrupcion y un contador cada vez que entra, no se por que pero si no no cuenta:

Código: [Seleccionar]

void TIM14_IRQHandler(void)
{
  /* USER CODE BEGIN TIM14_IRQn 0 */

  /* USER CODE END TIM14_IRQn 0 */
  HAL_TIM_IRQHandler(&htim14);
  /* USER CODE BEGIN TIM14_IRQn 1 */
  static uint32_t Contador = 0;
  static uint8_t ContadorPulsosGPS = 0;

  Contador++;

  if (Contador >= 1000 && Contador < 2000)
  {
  HAL_TIM_Base_Start(&htim17);
  HAL_TIM_IC_Start_IT(&htim16, TIM_CHANNEL_1);
  ContadorPulsosGPS++;
  }
  else if(Contador >= 2000)
  {
  ContadorPulsosGPS++;
  ContadorPulsos_64MHz = __HAL_TIM_GetCounter(&htim17);
  ContadorPulsos_1Segundo = __HAL_TIM_GetCounter(&htim14);

  HAL_TIM_Base_Stop(&htim17);
  HAL_TIM_Base_Stop_IT(&htim14);
  HAL_TIM_IC_Stop_IT(&htim16, TIM_CHANNEL_1);

  ContadorPulsos_32KHz = 0;
  }
  /* USER CODE END TIM14_IRQn 1 */
}

/**
  * @brief This function handles TIM16 global interrupt.
  */
void TIM16_IRQHandler(void)
{
  /* USER CODE BEGIN TIM16_IRQn 0 */

  /* USER CODE END TIM16_IRQn 0 */
  HAL_TIM_IRQHandler(&htim16);
  /* USER CODE BEGIN TIM16_IRQn 1 */
  ContadorPulsos_32KHz++;
  /* USER CODE END TIM16_IRQn 1 */
}
al segundo 2 tenemos los valores:

ContadorPulsosGPS = 2;
ContadorPulsos_32KHz ~=33034 (me bailan los valores supongo que es por que empiezo a capturar los valores en un pulso en bajo o en alto etc, o que aun no estoy usando el GPS.
ContadorPulsos_64MHz = 12549 (Estos si salen clavados, y logicamente se habrá desbordado varias veces.

 

[Picuino]

Primero debes contar pulsos de alta frecuencia cada segundo, entre dos flancos ascendentes de la señal de 1PPS. Cuenta también los desbordamientos.

Con eso sabrás exactamente cuantos pulsos por segundo tienes en alta frecuencia.

[Picuino]

Despues cuenta cuantos pulsos de alta frecuencia tienes comenzando a contar en un flanco del LSE y terminando después de 32768 flancos LSE.

Si el reloj LSE fuese perfecto, tendría que darte el mismo valor que en el caso anterior.
Como se va a desviar un porcentaje, ese es el ajuste que debes hacer.

[juaperser1]

Pues creo que hay un problema, los pulsos registrados de 64Mhz entre dos pulsos del gps varian mucho.

es decir, mido y me da (sin contar desbordamientos) 14185, vuelvo a repetir la prueba y me da 5017, y así todas las veces.

Se me ocurre otra manera, que creo que ya me lo comento el servicio técnico, hace tiempo.

medir los pulsos de 64Mhz en un periodo del LSE, lo he hecho y me da valores comprendidos entre (1975-1969). Eso es un periodo de entre 0,00003085937-0,00003076562  es decir, coinciden 6 cifras decimales siempre.

Sabiendo que el periodo de un LSE perfecto (32.768KHz) seria de 0,00003051757 o 1953 pulsos de 64Mhz puedo ver la diferencia con lo que estoy midiendo, tomando por ejemplo 1953-1975 = -22

si lo ajusto a mi reloj y tendiendo en cuenta que nos vamos al otro extremo (1969 en el peor caso) tendríamos 1969-22 = 1947

que sería 1947 pulsos de 64Mhz = 0,00003042187 (perfecto=0,00003051757) estoy dándole una precisión de 6 cifras decimales 1PPM, sin necesidad del GPS.

¿esto es así?

[Picuino]

Así sólo consigues tener una precisión de 3 cifras decimales (precisión de 500ppm).
Además estás midiendo con un reloj de 64MHz que no está calibrado y puede tener error.

Tienes que medir pulsos de 64MHz entre 32000 pulsos LSE y ahí si que tienes precisión.

[juaperser1]

Así sólo consigues tener una precisión de 3 cifras decimales (precisión de 500ppm).
Además estás midiendo con un reloj de 64MHz que no está calibrado y puede tener error.

Tienes que medir pulsos de 64MHz entre 32000 pulsos LSE y ahí si que tienes precisión.

¿Por que 3 cifras decimales?

el problema es que si cuento pulsos de 64Mhz entre los pulsos de 1 segundo del gps me da valores distintos.

[Picuino]

Lo normal es que haya un error en la cuenta de +-0.5 pulsos. Es decir, que el error será aproximadamente de 1 pulso.

Si cuentas 1947 pulsos, el error relativo será de 1/1947 = 0.0005136
Que significa que solo puedes tomar como válidas las primeras 3 cifras de cualquier cálculo que hagas con ese número que has contado (1947).


Cuenta pulsos entre dos flancos ascendentes del GPS. A mí me sale bastante bien con cualquier micro. El error está en 0.1ppm aproximadamente. Si soplas un poco el oscilador, puede cambiar hasta varias partes por millon, pero si la temperatura la mantienes estable no debe haber problemas.


Si tienes dudas del GPS, utiliza otro micro que tenga un oscilador a cristal para generar una señal de 1 pulso por segundo y prueba con esa señal. Solo para descartar que sea error del GPS.

Un saludo.