Autor Tema: Frecuencímetro 0-50Mhz autorrango y 0.1ppm (YAF)  (Leído 39954 veces)

0 Usuarios y 1 Visitante están viendo este tema.

Desconectado Picuino

  • Moderadores
  • DsPIC33
  • *****
  • Mensajes: 5415
Frecuencímetro 0-50Mhz autorrango y 0.1ppm (YAF)
« en: 06 de Mayo de 2012, 17:39:33 »
Hace tiempo que voy añadiendo características a un frecuencímetro casero que estoy desarrollando.
La motivación para hacer otro frecuencímetro más (Yet Another Freqmeter) con la cantidad de frecuencímetros que ya hay desarrollados fue conseguir un aparato de mucha resolución tanto en altas como en bajas frecuencias.
La resolución en bajas frecuencias es más difícil de conseguir con los aparatos habituales. Cuando me plantee por primera vez "afinar" un oscilador de 32768 Khz me di cuenta de que la mayoría de los frecuencímetros "baratos" dan la lectura:
32768 con error de +-1.
Eso significa un error de +-30 ppm en el mejor de los casos. Un reloj basado en ese oscilador tendrá un error de 80 segundos al mes, que es un poco alto.

El objetivo en este proyecto es que el frecuencímetro muestre 7 cifras significativas sin error y una cifra más con un error acotado de +-5:

   1.0000000 Hz frecuencia nominal mínima admitida por el frecuencímetro.
   50.000000 Hz frecuencia de red
   32768.000 Hz frecuencia de un oscilador de cristal de bajo consumo
   4000000.0 Hz frecuencia de un oscilador de cristal de 4Mhz
   50000000. Hz frecuencia nominal máxima admitida por el frecuencímetro

El microcontrolador a utilizar será un PIC18F2550 programado en C18 con el mínimo número de librerías para que sea más portable.
La entrada a utilizar será la RC0 / T13CKI, sin preamplificación.
El amplificador, atenuador y divisor de frecuencias para dar mayor rango de medición lo dejaré para otro proyecto.

Saludos.
« Última modificación: 21 de Mayo de 2012, 18:10:13 por Picuino »

Desconectado Suky

  • Moderadores
  • DsPIC33
  • *****
  • Mensajes: 6759
Re: Frecuencímetro 0-50Mhz autorrango y 0.1ppm (YAF)
« Respuesta #1 en: 06 de Mayo de 2012, 19:44:57 »
Lo que quieres lograr es más que interesante. Que instrumento usas para contrastar para todo ese rango?
No contesto mensajes privados, las consultas en el foro

Desconectado Picuino

  • Moderadores
  • DsPIC33
  • *****
  • Mensajes: 5415
Re: Frecuencímetro 0-50Mhz autorrango y 0.1ppm (YAF)
« Respuesta #2 en: 06 de Mayo de 2012, 20:13:18 »
Utilizo un frecuencímetro chino VC3165 como referencia para conseguir una señal exacta.
Genero una señal cuadrada con un generador de funciones DDS a una frecuencia exacta de 1048576.0Mhz (2^20 Hz).
Esa frecuencia la voy dividiendo por dos con varios integrados hasta conseguir 1Hz y esas son las frecuencias que testeo en el frecuencímetro que estoy construyendo.

Por ahora la medición tiene errores sistemáticos debido al oscilador de cristal de la placa del PIC (afinado con error de 1ppm).

El frecuencímetro será tan exacto como lo sea el oscilador que tenga el PIC. Si utilizo un cuarzo de 100ppm esa será la exactitud. Si utilizo un oscilador externo OCXO puedo llegar a 0.1ppm.
Lo que me interesa por ahora es crear el programa que sea preciso y exacto. Del oscilador me ocuparé más adelante.


http://electronicsjunk.com/index.php?option=com_content&view=article&id=55:victor-vc3165-frequency-counter&catid=34:electronics&Itemid=59
http://asterion.almadark.com/wp-content/uploads/2011/05/vc3165.pdf


Saludos.
« Última modificación: 06 de Mayo de 2012, 20:19:52 por Picuino »

Desconectado todopic

  • Administrador
  • DsPIC30
  • *******
  • Mensajes: 3492
    • http://www.todopicelectronica.com.ar
Re: Frecuencímetro 0-50Mhz autorrango y 0.1ppm (YAF)
« Respuesta #3 en: 06 de Mayo de 2012, 21:24:08 »
Estoy atento al tema...  muy interesante ...
Firmat - Santa Fe - Argentina

www.TodoPic.net

Solo se tiran piedras, al arbol que tiene frutos...

Desconectado Nocturno

  • Administrador
  • DsPIC33
  • *******
  • Mensajes: 17740
    • MicroPIC
Re: Frecuencímetro 0-50Mhz autorrango y 0.1ppm (YAF)
« Respuesta #4 en: 07 de Mayo de 2012, 02:06:30 »
Me suscribo al hilo.
Un saludo desde Sevilla, España.
Visita MicroPIC                                                                                        ɔ!doɹɔ!ɯ ɐʇ!s!ʌ

Desconectado Picuino

  • Moderadores
  • DsPIC33
  • *****
  • Mensajes: 5415
Re: Frecuencímetro 0-50Mhz autorrango y 0.1ppm (YAF)
« Respuesta #5 en: 07 de Mayo de 2012, 18:08:12 »
Sigo peleándome con las rutinas matemáticas. Ya me falta poco.

Saludos.

Desconectado MLO__

  • Colaborador
  • DsPIC33
  • *****
  • Mensajes: 4583
Re: Frecuencímetro 0-50Mhz autorrango y 0.1ppm (YAF)
« Respuesta #6 en: 07 de Mayo de 2012, 19:52:09 »
Hola

Esta muy interesante!!! me suscribo al hilo tambien  :)

Saludos
El papel lo aguanta todo

Desconectado Picuino

  • Moderadores
  • DsPIC33
  • *****
  • Mensajes: 5415
Re: Frecuencímetro 0-50Mhz autorrango y 0.1ppm (YAF)
« Respuesta #7 en: 07 de Mayo de 2012, 20:36:04 »
Primeros resultados. Las rutinas matemáticas parecen funcionar bien con 12 dígitos de precisión:


System OK

Time=   000000010000037   Pulses=   000000010000054   freq=   005000009,02586
Time=   000000020031617   Pulses=   000000020031652   freq=   005000008,97166
Time=   000000030000024   Pulses=   000000030000077   freq=   005000009,02851
Time=   000000040011031   Pulses=   000000040011103   freq=   005000009,48954


El tiempo está medido en ciclos de instrucción (5 millones por segundo para un oscilador de 20Mhz)

Los pulsos provienen de un oscilador de 5MHz.

La frecuencia se calcula como la diferencia entre pulsos dividido entre la diferencia entre tiempos.

Se puede ver como bailan los números a partir de  0.1ppm = 0.5 Hz

Saludos.
« Última modificación: 21 de Mayo de 2012, 18:08:52 por Picuino »

Desconectado Picuino

  • Moderadores
  • DsPIC33
  • *****
  • Mensajes: 5415
Re: Frecuencímetro 0-50Mhz autorrango y 0.1ppm (YAF)
« Respuesta #8 en: 07 de Mayo de 2012, 20:40:52 »
Código para manejar aritmética de 48 bits:


math48.c
Código: C
  1. /****************************************************************************
  2.     48 bit integer math
  3.  
  4.    Picuino Development Board
  5.    Creative Commons Reconocimiento-CompartirIgual 3.0 España License.
  6.    https://sites.google.com/site/picuino
  7.    
  8.  ****************************************************************************/
  9. #include "math48.h"
  10.  
  11. /****************************************************************************
  12.       GLOBAL VARS AND DEFINITIONS
  13.  ****************************************************************************/
  14.  
  15. // Variable for store answer and status register
  16. static uint48 ans;
  17. static struct {
  18.     unsigned char carry:1;
  19.     unsigned char overflow:1;
  20. } st48;
  21.  
  22.  
  23. /****************************************************************************
  24.       BASIC MATH ROUTINES
  25.  ****************************************************************************/
  26. /*
  27.    Compare 2 uint48 numbers
  28.    (a = b) return 0
  29.    (a > b) return 1
  30.    (a < b) return -1
  31. */
  32. signed char comp48(uint48 a, uint48 b) {
  33.    if (a.dword > b.dword) return 1;
  34.    if (a.dword < b.dword) return -1;
  35.    if (a.word[0] > b.word[0]) return 1;
  36.    if (a.word[0] < b.word[0]) return -1;
  37.    return 0;
  38. }
  39.  
  40.  
  41. /*
  42.    Sub 2 uint48 numbers
  43.    return a - b
  44. */
  45. uint48 sub48(uint48 a, uint48 b) {
  46.    ans.dword = a.dword - b.dword;
  47.    if (b.word[0] > a.word[0])
  48.       ans.dword--;
  49.    ans.word[0] = a.word[0] - b.word[0];
  50.    return ans;
  51. }
  52.  
  53. /*
  54.    Add 2 uint48 numbers
  55.    return a + b
  56. */
  57. uint48 add48(uint48 a, uint48 b) {
  58.    ans.dword = a.dword + b.dword;
  59.    ans.word[0] = a.word[0] + b.word[0];
  60.    if (ans.word[0] < a.word[0])
  61.       ans.dword++;
  62.    return ans;
  63. }
  64.  
  65. /*
  66.    Add 2 uint48 numbers
  67.    return a + b
  68. */
  69. uint48 inc48(uint48 a) {
  70.    ans.word[0] = a.word[0] + 1;
  71.    ans.dword = a.dword;
  72.    if (ans.word[0] == 0)
  73.       ans.dword++;
  74.    return ans;
  75. }
  76.  
  77.  
  78. /*
  79.    Rotate left
  80.    return a<<1
  81. */
  82. uint48 _rl48(uint48 a) {
  83.    st48.carry = 0;
  84.    if (a.b47==1) st48.carry = 1;
  85.    ans.dword = a.dword<<1;
  86.    if (a.b15==1) ans.b16 = 1;
  87.    ans.word[0] = a.word[0]<<1;
  88.    if (st48.carry == 1)
  89.       ans.b0 = 1;
  90.    return ans;
  91. }
  92.  
  93. /*
  94.    Rotate right
  95.    return a>>1
  96. */
  97. uint48 _rr48(uint48 a) {
  98.    st48.carry = 0;
  99.    if (a.b0==1) st48.carry = 1;
  100.    ans.word[0] = a.word[0]>>1;
  101.    if (a.b16==1) ans.b15 = 1;
  102.    ans.dword = a.dword>>1;
  103.    if (st48.carry == 1)
  104.       ans.b47 = 1;
  105.    return ans;
  106. }
  107.  
  108.  
  109. /*
  110.    Shift left
  111.    return a<<1
  112. */
  113. uint48 sl48(uint48 a) {
  114.    st48.carry = 0;
  115.    if (a.b47==1) st48.carry = 1;
  116.    ans.dword = a.dword<<1;
  117.    if (a.b15==1) ans.b16 = 1;
  118.    ans.word[0] = a.word[0]<<1;
  119.    return ans;
  120. }
  121.  
  122. /*
  123.    Shift right
  124.    return a>>1
  125. */
  126. uint48 sr48(uint48 a) {
  127.    st48.carry = 0;
  128.    if (a.b0==1) st48.carry = 1;
  129.    ans.word[0] = a.word[0]>>1;
  130.    if (a.b16==1) ans.b15 = 1;
  131.    ans.dword = a.dword>>1;
  132.    return ans;
  133. }
  134.  
  135.  
  136. /****************************************************************************
  137.       DECIMAL MATH ROUTINES
  138.  ****************************************************************************/
  139.  
  140. /*
  141.    Multiply by 10
  142.    return a*10
  143. */
  144. uint48 mul10_48(uint48 a) {
  145.    a = sl48(a);
  146.    ans = sl48(a);
  147.    ans = sl48(ans);
  148.    ans = add48(a, ans);
  149.    return ans;
  150. }
  151.  
  152.  
  153. /*
  154.    Rational division
  155.    rat = a/b * 10^dot
  156.    rat = [signed char dot] + [uint 40bit number]
  157. */
  158. uint48 div48_rat(uint48 a, uint48 b) {
  159.    signed char i, exp, dot;
  160.    uint48 rat;
  161.  
  162.    // Clear rational result
  163.    LOAD48(rat, 0);
  164.  
  165.    // Adjust integers
  166.    exp = 0;
  167.    for(i=46; i>0; i--) {
  168.       if (a.b46 == 1) break;
  169.       a = sl48(a);
  170.       exp--;
  171.    }
  172.    for(i=46; i>0; i--) {
  173.       if (b.b46 == 1) break;
  174.       b = sl48(b);
  175.       exp++;
  176.    }
  177.  
  178.    // if (argument == zero) return zero
  179.    if (b.b46 == 0 || a.b46 == 0)
  180.       return rat;
  181.  
  182.  
  183.    // divide a / b
  184.    do {
  185.       if (comp48(a, b) >= 0) {
  186.          a = sub48(a, b);
  187.          rat.b0 = 1;
  188.       }
  189.       a = sl48(a);
  190.       rat = sl48(rat);
  191.       exp--;      
  192.    } while(rat.b39==0); // max resolution = 40bit = 12 decimal digits
  193.  
  194.  
  195.    // Adjust binary to decimal ratio
  196.    dot = 0;
  197.    for(i=30; i>0; i--) {
  198.  
  199.       // rat = rat * 10/8
  200.       if (exp>-3) break;
  201.       if (exp==-3)
  202.          if (rat.byte[4]>=186) break; // avoid overflow
  203.       inc48(rat);
  204.       sr48(ans);
  205.       sr48(ans);
  206.       rat = add48(rat, ans);
  207.       exp += 3;
  208.       dot--;
  209.  
  210.       // rat = rat / 2
  211.       if (rat.b40==1) {
  212.          inc48(rat);
  213.          rat = sr48(ans);   // 1/2
  214.          exp++;
  215.       }
  216.    };
  217.  
  218.    for(;exp<0; exp++) {
  219.       inc48(rat);
  220.       rat = sr48(ans);
  221.    }
  222.  
  223.    // Add exponent and return
  224.    rat.byte[5] = dot;
  225.    return rat;
  226. }
  227.  
  228.  
  229. /*
  230.    Transform 48bit binary to BCD
  231.    sdlong = byte[8]
  232.    Delay = 12500 cycles
  233. */
  234. #define DEC_DIG_48   15
  235. void ltoa48(unsigned char *str, static uint48 bin) {
  236.    unsigned char maxdig, digcnt, bitcnt;
  237.    static unsigned char *p, carry;
  238.  
  239.    // Clear string
  240.    p = str;
  241.    digcnt = DEC_DIG_48 + 1;
  242.    do *p++ = 0; while (--digcnt);
  243.  
  244.    // Transform binary to BCD
  245.    bitcnt = 48;
  246.    maxdig = (DEC_DIG_48 - 1);
  247.    str += (DEC_DIG_48 - 1);
  248.    do {
  249.       // shift binary number left with carry
  250.       carry = 0;
  251.       if (bin.b47==1) carry |= 1;
  252.       bin = sl48(bin);
  253.      
  254.       // shift decimal number left with carry
  255.       p = str;
  256.       digcnt = DEC_DIG_48 - maxdig;
  257.       do {
  258.          carry = (*p<<1) + carry;
  259.          if (carry>=10) {
  260.             *p-- = carry - 10;
  261.             carry = 1;
  262.             if (digcnt==1) {
  263.                maxdig--;
  264.                digcnt++;
  265.             }
  266.          }
  267.          else {
  268.             *p-- = carry;
  269.             carry = 0;
  270.          }
  271.       } while(--digcnt);
  272.    } while(--bitcnt);
  273.  
  274.    // Transform BCD to ASCII
  275.    digcnt = DEC_DIG_48;
  276.    do *str-- += '0'; while (--digcnt);
  277. }
  278.  


----------------------------------------------------------------------------------------


math48.h
Código: C
  1. /*
  2.     Declaration file for math48.c
  3.  
  4.    Picuino Development Board
  5.    Creative Commons Reconocimiento-CompartirIgual 3.0 España License.
  6.    https://sites.google.com/site/picuino
  7.  
  8. */
  9.  
  10. #ifndef MATH48_H
  11. #define MATH48_H
  12.  
  13. // Unsigned 48 bit integer
  14. typedef union {
  15.    unsigned char  byte[6];
  16.    unsigned int   word[3];
  17.    struct {
  18.       unsigned int __word;
  19.       unsigned long dword;
  20.    };
  21.    struct {
  22.       unsigned b0:1;
  23.       unsigned b1:1;
  24.       unsigned b2:1;
  25.       unsigned b3:1;
  26.       unsigned b4:1;
  27.       unsigned b5:1;
  28.       unsigned b6:1;
  29.       unsigned b7:1;
  30.       unsigned b8:1;
  31.       unsigned b9:1;
  32.       unsigned b10:1;
  33.       unsigned b11:1;
  34.       unsigned b12:1;
  35.       unsigned b13:1;
  36.       unsigned b14:1;
  37.       unsigned b15:1;
  38.       unsigned b16:1;
  39.       unsigned b17:1;
  40.       unsigned b18:1;
  41.       unsigned b19:1;
  42.       unsigned b20:1;
  43.       unsigned b21:1;
  44.       unsigned b22:1;
  45.       unsigned b23:1;
  46.       unsigned b24:1;
  47.       unsigned b25:1;
  48.       unsigned b26:1;
  49.       unsigned b27:1;
  50.       unsigned b28:1;
  51.       unsigned b29:1;
  52.       unsigned b30:1;
  53.       unsigned b31:1;
  54.       unsigned b32:1;
  55.       unsigned b33:1;
  56.       unsigned b34:1;
  57.       unsigned b35:1;
  58.       unsigned b36:1;
  59.       unsigned b37:1;
  60.       unsigned b38:1;
  61.       unsigned b39:1;
  62.       unsigned b40:1;
  63.       unsigned b41:1;
  64.       unsigned b42:1;
  65.       unsigned b43:1;
  66.       unsigned b44:1;
  67.       unsigned b45:1;
  68.       unsigned b46:1;
  69.       unsigned b47:1;
  70.       unsigned b48:1;
  71.    };
  72. } uint48;
  73.  
  74. #define LOAD48(u48, n) u48.dword = n / 65536; u48.word[0] = n % 65536
  75. #define CLEAR48(u48) u48.word[0] = 0; u48.word[1] = 0; u48.word[2] = 0
  76.  
  77.  
  78. uint48 _rl48(uint48 a);                              // Line  141
  79. uint48 _rr48(uint48 a);                              // Line  156
  80. uint48 add48(uint48 a, uint48 b);                    // Line  116,   2 calls
  81. signed char comp48(uint48 a, uint48 b);              // Line   91
  82. uint48 div48_rat(uint48 a, uint48 b);                // Line  217
  83. uint48 inc48(uint48 a);                              // Line  128,   3 calls
  84. void ltoa48(unsigned char *str, static uint48 bin);  // Line  294
  85. uint48 mul10_48(uint48 a);                           // Line  203
  86. uint48 sl48(uint48 a);                               // Line  172,   8 calls
  87. uint48 sr48(uint48 a);                               // Line  185,   4 calls
  88. uint48 sub48(uint48 a, uint48 b);                    // Line  104,   1 calls
  89.  
  90. #endif
  91.  
« Última modificación: 07 de Mayo de 2012, 20:43:57 por Picuino »

Desconectado Picuino

  • Moderadores
  • DsPIC33
  • *****
  • Mensajes: 5415
Re: Frecuencímetro 0-50Mhz autorrango y 0.1ppm (YAF)
« Respuesta #9 en: 08 de Mayo de 2012, 10:21:08 »
He añadido notación de ingeniería (con prefijos del tipo micro, mili, kilo, mega, etc) y he reducido el número de cifras significativas que se muestran en pantalla a 9 cifras significativas.

Con un tiempo de muestreo de 10 segundos los resultados tienen una resolución asombrosa:


System OK

Time=   000000050000036   Pulses=   000000050002998   f=   5,00029635 MHz
Time=   000000100000494   Pulses=   000000100006420   f=   5,00029639 MHz
Time=   000000150000020   Pulses=   000000150008909   f=   5,00029630 MHz
Time=   000000200000324   Pulses=   000000200012176   f=   5,00029629 MHz
Time=   000000250000041   Pulses=   000000250014855   f=   5,00029620 MHz
Time=   000000299010228   Pulses=   000000299027946   f=   5,00029626 MHz
Time=   000000350002167   Pulses=   000000350022907   f=   5,00029628 MHz
Time=   000000400003827   Pulses=   000000400027530   f=   5,00029629 MHz
Time=   000000450004022   Pulses=   000000450030688   f=   5,00029629 MHz
Time=   000000500000735   Pulses=   000000500030363   f=   5,00029621 MHz
Time=   000000550001169   Pulses=   000000550033759   f=   5,00029619 MHz
Time=   000000600003606   Pulses=   000000600039159   f=   5,00029628 MHz
Time=   000000650004641   Pulses=   000000650043156   f=   5,00029619 MHz
Time=   000000700000369   Pulses=   000000700041847   f=   5,00029632 MHz
Time=   000000750000012   Pulses=   000000750044452   f=   5,00029620 MHz

Las cifras bailan en el rango de 0.01ppm. Tanto el frecuencímetro como el generador de señal tienen osciladores de cristal de cuarzo sin compensar.

Saludos.

Desconectado Picuino

  • Moderadores
  • DsPIC33
  • *****
  • Mensajes: 5415
Re: Frecuencímetro 0-50Mhz autorrango y 0.1ppm (YAF)
« Respuesta #10 en: 08 de Mayo de 2012, 11:27:46 »
He forzado un poco las medidas, a ver hasta donde se podía llegar.

Tiempo de muestreo = 2 segundos (10millones de ciclos de reloj, en el límite de las 0.1ppm)

Frecuencia de entrada = oscilador de precisión, no compensado térmicamente.


Resultados devueltos por el frecuencímetro por RS232:

Código: [Seleccionar]
Time= 000000010010033 Pulses= 000000160160795 f= 80,0001416 MHz
Time= 000000020013916 Pulses= 000000320223206 f= 80,0001414 MHz
Time= 000000030010541 Pulses= 000000480169489 f= 80,0001415 MHz
Time= 000000040004498 Pulses= 000000640073084 f= 80,0001415 MHz
Time= 000000050003748 Pulses= 000000800061366 f= 80,0001410 MHz
Time= 000000060015826 Pulses= 000000960254897 f= 80,0001413 MHz
Time= 000000070009354 Pulses= 000001120151628 f= 80,0001415 MHz
Time= 000000080012070 Pulses= 000001280195367 f= 80,0001414 MHz
Time= 000000090011300 Pulses= 000001440183330 f= 80,0001415 MHz
Time= 000000100007045 Pulses= 000001600115533 f= 80,0001415 MHz
Time= 000000110001381 Pulses= 000001760025192 f= 80,0001415 MHz
Time= 000000120005648 Pulses= 000001920093747 f= 80,0001414 MHz
Time= 000000130003277 Pulses= 000002080056094 f= 80,0001415 MHz
Time= 000000140009494 Pulses= 000002240155850 f= 80,0001419 MHz
Time= 000000150004264 Pulses= 000002400072453 f= 80,0001415 MHz
Time= 000000160018444 Pulses= 000002560299616 f= 80,0001412 MHz
Time= 000000170015982 Pulses= 000002720260506 f= 80,0001410 MHz
Time= 000000180014504 Pulses= 000002880237141 f= 80,0001415 MHz
Time= 000000190002404 Pulses= 000003040043823 f= 80,0001411 MHz
Time= 000000200011880 Pulses= 000003200195721 f= 80,0001408 MHz
Time= 000000210012834 Pulses= 000003360211267 f= 80,0001409 MHz
Time= 000000220010587 Pulses= 000003520175597 f= 80,0001410 MHz
Time= 000000230005729 Pulses= 000003680098151 f= 80,0001410 MHz
Time= 000000240000209 Pulses= 000003840010113 f= 80,0001410 MHz
Time= 000000250002992 Pulses= 000004000054924 f= 80,0001414 MHz
Time= 000000260014831 Pulses= 000004160244631 f= 80,0001413 MHz
Time= 000000270002168 Pulses= 000004320042306 f= 80,0001416 MHz
Time= 000000280010573 Pulses= 000004480177070 f= 80,0001418 MHz
Time= 000000290015971 Pulses= 000004640263721 f= 80,0001414 MHz
Time= 000000300000371 Pulses= 000004800014404 f= 80,0001417 MHz
Time= 000000310018154 Pulses= 000004960299215 f= 80,0001412 MHz
Time= 000000320003668 Pulses= 000005120067721 f= 80,0001412 MHz
Time= 000000330012690 Pulses= 000005280212355 f= 80,0001408 MHz
Time= 000000340013923 Pulses= 000005440232365 f= 80,0001409 MHz
Time= 000000350001562 Pulses= 000005600034871 f= 80,0001411 MHz
Time= 000000360004004 Pulses= 000005760074224 f= 80,0001404 MHz

Creo que puedo dar por buena la medición de frecuencias en el rango de 5Mhz a 50 Mhz. Funciona sin problemas con errores máximo de 0.1 ppm

Voy a pedir por e-bay un oscilador OCXO con error menor de 0.1ppm para probar exactitud.

Saludos.

Desconectado Picuino

  • Moderadores
  • DsPIC33
  • *****
  • Mensajes: 5415
Re: Frecuencímetro 0-50Mhz autorrango y 0.1ppm (YAF)
« Respuesta #11 en: 08 de Mayo de 2012, 13:47:24 »
Página del NIST de la división encargada de la medición del tiempo y la frecuencia:
http://www.nist.gov/pml/div688


Un widget interesante que da la hora y el error de retardo de la red:
http://www.time.gov/widget/

http://time.gov/widget/NISTtimewidget.swf

Saludos.
« Última modificación: 09 de Mayo de 2012, 20:20:53 por Picuino »


Desconectado Picuino

  • Moderadores
  • DsPIC33
  • *****
  • Mensajes: 5415
Re: Frecuencímetro 0-50Mhz autorrango y 0.1ppm (YAF)
« Respuesta #13 en: 09 de Mayo de 2012, 09:54:15 »
He pedido por e-bay un oscilador de cuarzo de horno controlado (OCXO) de 10Mhz con salida de señal cuadrada de 0 a 5v.
La precisión es mejor de 0.1ppm.
El error máximo se debe al envejecimiento y según la hoja de características es de 0.1ppm al año.

El oscilador tiene una entrada de tensión de 0 a 5 voltios que permite variar la frecuencia +-1 ppm para poder "afinarle".

Ahora el reto que tengo es encontrar una señal patrón con la que comparar el oscilador cada cierto tiempo para comprobar su exactitud.
Estoy valorando las opciones de un módulo GPS o de señales de radio reloj, como la DCF77 que se utiliza para poner en hora los radio-relojes.

¿Alguien conoce el tema? agradecería un poco de orientación.


La exactitud que busco es de 0.1ppm que traducido significa un error de:

   100     nanosegundos cada segundo
   6        microsegundos cada minuto
   360     microsegundos cada hora
   8.64    milisegundos al día
   0.259  segundos al mes
   3.156  segundos al año

   200Hz en 2GHz
   10 Hz en 100MHz
   1 Hz en 10MHz
   0.000005 Hz en 50Hz
   0.0000001 Hz en 1Hz

Saludos.

Desconectado Picuino

  • Moderadores
  • DsPIC33
  • *****
  • Mensajes: 5415
Re: Frecuencímetro 0-50Mhz autorrango y 0.1ppm (YAF)
« Respuesta #14 en: 09 de Mayo de 2012, 20:06:28 »
Comparativa entre las emisiones de radio-reloj  DCF77 y TDF:
http://www.leunig.de/_en/_pro/radio-controlled-clock/funkuhren_DCF77_TDF.htm




Saludos.


 

anything