medida y filtrado de temperatura con ntc
TRANSCRIPT
Medida y filtrado de temperatura con NTC. Una introducción al procesado de señales.
Introducción.
La medida de la temperatura es uno de los temas más recurrentes en los que se topa
cuando se trata de empezar en el mundo de las mediciones, sensores e instrumentación.
Probablemente sea el tipo de sensor de magnitudes no eléctricas más empleado en la
electrónica.
Quizás sea por este motivo, por el cual hay gran variedad de modelos y métodos para
medir la temperatura. Y es por ello, que hay uno en particular, que facilita mucho la
medida, de tal manera que se convierte en un buen punto de partida para empezar a
interactuar con el ‘mundo real’.
La intención de este tutorial es la de explicar cómo trabajar con una cadena de medida
de una manera genérica, sencilla y práctica, enfocado desde un punto de vista más
genérico, dejando más a un lado la aplicación más puntual y específica. De esta manera,
la explicación aquí servida serviría con gran facilidad y pocos cambios, para
implementar este tipo de medida tanto en un sencillo PIC como en un ARM de la peor
especie. O incluso con un conversor externo. De todas maneras, para el caso se ha
aplicado con un microcontrolador de la familia AVR, pues es el que más conoce el
autor.
Primera Parte: El Hardware.
Para medir la temperatura hay muchos métodos. El más sencillo y económico de todos,
es usar un sensor tipo NTC. El acrónimo hace referencia a un tipo de resistencia que
varía grandemente su valor a la inversa de la temperatura. Es decir, que cuando la
temperatura crece, el valor de la resistencia disminuye, y por tanto, el coeficiente que
relaciona ambos términos es negativo. De ahí su nombre Coeficiente Térmico Negativo.
Como siempre, en inglés, el orden de las palabras se invierte, de manera que tenemos el
término Negative Temperatura Coefficient.
De este tipo de sensores, hay gran abundancia de tipos y valores. Por tanto, se intentará
ser lo más genérico posible, para poder ver una manera más global de tratar el diseño.
El punto de partida de este diseño, como en todos, es siempre la hoja de características
(Datasheet) del componente. En dicha hoja, debe aparecer una tabla de valores de la
resistencia para diferentes temperaturas. Nos valdremos de dicha tabla, de la ley de
Ohm y de una práctica hoja de cálculo, para realizar el trabajo.
En el dibujo adjunto se puede ver el sencillo circuito de conexionado de una NTC
cualquiera. Como se puede apreciar, es muy sencillo, y por tanto, económico. La base es
un simple divisor resistivo, donde la resistencia superior, llamada Resistencia de Carga,
para el caso, es fija y conocida. La resistencia inferior es el sensor NTC, cuyo valor
queremos medir para saber la temperatura. Los dos condensadores (C1 y C2) y la
tercera resistencia (Rf) simplemente forman un filtro (tipo pasa-bajos) para eliminar el
ruido eléctrico que se pueda generar. Además, los condensadores hacen la vez de simple
adaptador de impedancias, puesto que no todos los conversores AD tienen una alta
impedancia de entrada.
Un detalle importante del circuito, es el hecho de que la tensión de alimentación del
divisor resistivo es precisamente la tensión de referencia del conversor AD. Este tipo de
circuito se llama ratiométrico, pues el valor que devuelve el divisor resistivo es
proporcional a dicha tensión. Puesto que la lectura del conversor AD también lo es,
resulta que el valor del mismo es bastante irrelevante, siempre y cuando esté dentro de
los valores de funcionamiento de dicho conversor.
Veamos más detalladamente la explicación. Un divisor resistivo devuelve una tensión
V, que depende de las resistencias Rl (Resistencia de Carga), Rt (valor de la NTC), y
Va, según la siguiente función:
V=Va*Rt/(Rt+Rl)
Un conversor devuelve un valor AD según la tensión de entrada y la tensión de
referencia, V y Va, y según su resolución FE (Fondo de Escala), que sigue la ley:
AD=V*FE/Vref.
Si sustituimos la primera ecuación en la segunda, tenemos que:
AD=Rt*FE/(Rt+Rl)
Y por tanto, no depende de Va. Esto simplifica la circuitería, pues elimina la necesidad
de tener una referencia de tensión de precisión, y nos obliga a conocer un único valor
importante del circuito: la resistencia de carga. El valor de fondo de escala depende
siempre del conversor, y el valor de la NTC, depende de la elegida. Por tanto, nos queda
la cuestión de cómo elegir Rl.
Para empezar dicho cálculo, conviene observar que el valor de la NTC varía mucho con
la temperatura, y que esta variación no es lineal. Dado tal comportamiento, entonces ¿en
que se debe basar la elección de Rl? Explicarlo puede resultar arduo, pero se puede
decir que la elección es relativamente sencilla.
Cuando interesa medir temperaturas, generalmente hay un rango de interés, donde las
especificaciones requieren una mayor precisión. Resulta que dicho rango, tiene un punto
medio, y este valor, para cada NTC, tiene una resistencia asociada. Por ejemplo, en la
NTC de Semitec que se usa en este tutorial, si el centro de interés es la temperatura
ambiente, por ejemplo 25ºC, el valor de la NTC a dicha temperatura es de 10KOhms. Y
por tanto, la mejor resistencia de carga es de 10KOhms. Esto implica que a dicha
temperatura, el conversor AD trabajará más o menos en el centro de su escala, de
manera que se reparte el rango de interés a partes iguales por encima y por debajo de
dicho punto.
Si interesa centrar la medida alrededor de 0ºC, por ejemplo para trabajar con una nevera
de refrescos, entonces el valor que debería tener Rl sería de 27.28 KOhms, pues es el
valor de la NTC a 0ºC.
Supongamos de ahora en adelante que la temperatura de interés está en 25ºC, y por
tanto Rl será de 10KOhms.
El conversor de los uC AVR es de 10 bits, un valor habitual para la mayoría de uC. Por
tanto, el fondo de escala es de 1023.
Así pues, el valor devuelto por el conversor a 25ºC, será de 1023*10/(10+10) = 511. De
esta manera, se puede calcular el valor devuelto por el conversor para cualquier
resistencia de la NTC, o lo que es lo mismo, para cualquier temperatura.
Pero, ¿cómo podemos obtener la temperatura a partir de un valor del conversor? Para
ello, primero debemos obtener la lectura de dicho conversor. Que es precisamente, el
objeto del siguiente capítulo.
Segunda Parte. La Conversión.
En esta parte, abordaremos los puntos más específicos de la electrónica relativa a la
cadena de medida. Es decir, el conversor AD en este caso, pues no hay más circuitería
asociada. Se trata por tanto de la parte más específica del uC a usar, y además depende
de la estructura del programa que se pretenda abordar.
Dado que lo que se pretende es medir la temperatura como si fuese un termómetro, el
procedimiento utilizará una medida continua. El resultado de esta medida se almacenará
en un búfer circular de 34 valores, a partir del cual, se realizará la conversión de valor
binario a temperatura. De esta manera, se podrán usar diferentes técnicas de procesado
sobre dichos valores.
Para inicializar el conversor AD, se escoge la entrada adecuada, la velocidad de
conversión más baja (la temperatura cambia muy lentamente), y habilitamos las
interrupciones. No sin antes desactivar el comparador analógico y limpiar cualquier
interrupción pendiente.
//********************************************************************
//** Inicialización del conversor ADC
//**
void initadc(void)
{
ADCSRA = (1<<ADEN)|(1<<ADIF); //Paramos el ADC y 'limpiamos' el flag
de IRQ
ADMUX = (1<<REFS0)|(CanalADC<<MUX0);//0x41; //seleccionamos ref=AVCC
i AMUX entrada termistor
ACSR = ACSR & ~(1<<ACIE); //'limpiamos' el flag de IRQ del
comparador analógico
ACSR = (1<<ACD); //Paramos el comparador analógico
ADCSRB = 0x00; //Deshabilitamos el Autotrigger
ADCSRA = (1<<ADEN)|(1<<ADIE)|(7<<ADPS0); //Activo, Interrupt Enabled
y Prescaler a 128
}
La rutina de interrupción, lo único que hace es actualizar el búfer circular de datos
recogidos y empezar de nuevo la conversión, usando una macro definida previamente.
//***************************************************
//** ISR de fin de conversión del ADC
//** Recoge el resultado y lo pone en el buffer
#pragma vector=ADC_vect
__interrupt void ISR_ADC(void)
{
ADCBuff[AdcIn++]=ADC;
if (AdcIn==34)
AdcIn=0;
ArrancaADC();//ADCSRA|=(1<<ADSC);//recomençam conversió
}
Las declaraciones del búfer circular y de otras macros que afectan a esta parte son:
//Definición de macros útiles
#define ArrancaADC() ADCSRA |=(1<<ADSC)
#define CanalADC (2)
#define ADCBuffLar (34)
volatile unsigned int ADCBuff[ADCBuffLar];
volatile char AdcIn;
El hecho de tener el buffer circular nos permitirá observar diferentes comportamientos
tanto de la temperatura como de filtros aplicables a cualquier medida.
Tercera Parte. Obtención de la Temperatura.
Bien, ahora ya disponemos de un valor binario de 10 bits que depende de la
temperatura. Pero ¿cómo sabemos que temperatura representa? Hacer dicha conversión
es algo que puede ser sencillo, o muy complejo, depende de lo que se pretenda, la
precisión requerida, etc. Pero para el caso, buscaremos una manera sencilla pero
potente, que ilustre técnicas habituales para la medida de señales, y que se puede aplicar
a muchos tipos diferentes de sensores.
La técnica que describiremos a continuación se basa en el uso de tablas de valores y
técnicas de interpolación. Si se usase una tabla donde para cada valor de AD tengamos
un valor de temperatura, harían falta 1024 valores, o sea, 2048 bytes de datos. Eso no es
poco.
Usar una fórmula matemática nos obligaría a usar siempre el mismo tipo de sensor, de
manera que no sería aplicable a otros sensores. Además, el uso de según que funciones
(exponenciales y logaritmos para este caso) implica el uso de librerías que también
consumen mucha memoria de programa, y potencia de cálculo.
Sin embargo, el método que se propone es sencillo, usa relativamente poca memoria
(dependiendo de la precisión y los puntos de interpolación), y rutinas matemáticas
relativamente sencillas, que además son aplicables para muchos tipos de sensores no
lineales, como por ejemplo, los termopares.
Para este método, se va a usar una tabla donde almacenaremos los valores teóricos
devueltos por el conversor AD para unas temperaturas conocidas. Tomemos por
ejemplo el rango de -30ºC a 70ºC, y calculemos el valor de AD para cada 10ºC. Así
obtendremos una tabla de 11 valores (22 bytes), que calcularemos con la ayuda
inestimable de una hoja de cálculo, como la anexa. El procedimiento es sencillo: en una
casilla se pone el valor de la resistencia de carga (10KOhms en este caso), en otras, se
pone el valor de la NTC para las temperaturas de interés, y en otras, se pone la fórmula
que nos devuelve el valor de AD para dicho valor de la NTC.
Pero con esta tabla, no es suficiente. Hace falta algún tipo de proceso para poder
encontrar la temperatura a partir de la tabla y del valor AD. Este proceso es el siguiente:
1º: Dado el valor AD, hay que buscar en la tabla entre que dos entrada de la misma cae.
Pongamos por ejemplo que leemos 511. Como se vió en la primera parte, esto se debe
corresponder con 25ºC. Si buscamos en la tabla, vemos que 511 está entre la entrada 5
(560) y 6 (464) (recordemos que se empieza por la 0), que son los valores del conversor
a 20ºC y 30ºC respectivamente.
La tabla, la hoja de Excel y el datasheet de la NTC usados en este tutorial, al igual que
el código fuente del programa, se encuentran adjuntos en el zip de este tutorial.
Para realizar dicha búsqueda, lo haremos con el siguiente bucle:
for(i=0;(i<PuntosTabla)&&(ADC<(TablaADC[i])); i++);
donde ADC = 511 y PuntosTabla = Nº de puntos de la Tabla TablaADC
Este bucle se parará cuando TablaADC[n] valga menos que 511, y por tanto tendremos
un valor de n=6.
Por tanto, sabremos que la temperatura será un valor entre 20 y 30, es decir, -30+(n-
1)*10 y -30+(n)*10. El 10 es porque cada paso de la tabla corresponde a 10 grados. El -
30 es porque la tabla empieza a -30.
2º: Bien, ya tenemos algo, pero no es suficiente, pues se pretende medir grados, no
decenas de grados. Así que interpolaremos de manera lineal. Para ello, haremos los
siguientes cálculos:
max=TablaADC[i-1]; //Buscamos el valor más alto del intervalo
min=TablaADC[i]; //y el más bajo
De esto, obtenemos los valores de ADC para la temperatura del extremo superior del
intervalo, y del extremo inferior, 560 y 464 respectivamente. Pero buscamos el valor
representado por ? en el gráfico siguiente:
De la gráfica y de las ecuaciones de la recta, se deduce que el valor se puede calcular
mediante:
? = (560-511)*(30-20)/(560-464) + 20
Entonces, hacemos:
aux=(max-ADC)*10; //hacemos el primer paso de la interpolación
aux=aux/(max-min); //y el segundo paso
En el primer paso, el valor, 511, es restado del extremo superior, 560, que se
corresponde al valor de la entrada 5 de la tabla. El resultado, es 49. Y lo multiplicamos
por el intervalo de grados que tenemos, 10. Por tanto, aux valdrá 490.
Si a esto lo dividimos por la diferencia de valores del intervalo (560-464=96),
tendremos 5,1, redondeado a 5 en enteros. Por tanto, tenemos que para 511, el valor de
temperatura será el valor en el punto 5 de la tabla, 20ºC, más 5, que es el valor
calculado por interpolación. Por tanto, 25ºC. Justo lo que sabemos que tenía que dar.
Esto, se expresa de la siguiente manera:
aux+=(i-1)*10-30; //y añadimos el offset del resultado
que es el valor que luego devolvemos al final de la tabla.
3º: Si nos fijamos, tenemos que para el intervalo de 20 a 30º, hay 96 puntos del
conversor, de manera que tenemos mucha más resolución que la que estamos usando.
Por tanto, podemos incrementar dicha resolución, haciendo que los valores de offset (el
-30) y la diferencia entre puntos (el 10) valgan diez veces más. Así, en lugar de obtener
la temperatura en grados, la obtenemos en décimas de grado, y por tanto, tenemos más
resolución (y también más precisión).
Pero si resulta que las unidades no nos convencen, o alguien no está habituado a los ºC,
siempre podemos usar los grados Fahnrenheit, o como a los profesores de física les
gusta, los Kelvin.
Para optar a otras unidades, hay dos caminos: la conversión de ºC a ºF o Kelvins (que
sería un clásico, pero una pérdida de tiempo y recursos), o simplemente, cambiar el
valor de offset y diferencia de intervalo de manera adecuada. Es decir, que en lugar de
poner -30 y 10, o -300 y 100, pasar estos valores como parámetros a la función,
digamos To (Temperatura del primer punto de la tabla), y dT (Diferencial de
temperatura entre dos puntos de la tabla).
Con esta segunda opción, simplemente poniendo To y dT adecuados, podemos trabajar
en las unidades que nos guste. Por eso, tenemos definidos los siguientes valores: //Parámetros para conversión en ºCelsius
#define ToCels (-300)
#define dTCels (100)
//Parámetros para conversión en Kelvins
#define ToKelv (2430)
#define dTKelv (100)
//Parámetros para conversión en ºFahrenheit
#define ToFahr (-220)
#define dTFahr (180)
Y la función de conversión ‘universal’ será: //***************************************************************************
//* Función TempNTC
//* Devuelve el valor numérico de la temperatura obtenido por interpolación
//* ADC es el valor devuelto por el conversor ADC
//* To es el valor de la temperatura para el índice 0 de la tabla (-30ºC)
//* dT es la diferencia de temperatura entre dos entradas de la tabla (10ºC)
//***************************************************************************
int TempNTC(unsigned int ADC, int To, int dT) {
int aux;
unsigned int min, max;
char i;
//Buscamos el intervalo de la tabla en que se encuentra el valor de ADC
for(i=0;(i<PuntosTabla)&&(ADC<(TablaADC[i])); i++);
if ((i==0)||(i==PuntosTabla)) //Si no está, devolvemos un error
return -32767;
max=TablaADC[i-1]; //Buscamos el valor más alto del intervalo
min=TablaADC[i]; //y el más bajoa
aux=(max-ADC)*dT; //hacemos el primer paso de la interpolación
aux=aux/(max-min); //y el segundo paso
aux+=(i-1)*dT+To; //y añadimos el offset del resultado
return aux; }
De esta manera, para obtener un valor de temperatura en ºC, bastará con llamar a la
función de la siguiente manera:
TemperaturaC=TempNTC(Valor,ToCels,dTCels);
Y para obtener el valor en Kelvins, entonces bastará con llamar a la función así:
TemperaturaK=TempNTC(Valor,ToKelv,dTKelv);
Cuarta Parte: Técnicas de filtrado.
Por suerte (o por desgracia, tal y como veremos más adelante), la conversión de
temperaturas por NTC es muy robusta y apenas tiene variación, de manera que una
medida directa de la misma podría valer perfectamente. Pero no siempre es el caso, y se
puede encontrar una NTC situada varios metros lejos del conversor, en un ambiente de
mucho ruido eléctrico, de manera que la lectura del ADC sea muy fluctuante o con
mucho ruido. De hecho, en alguna ocasión, puede ser interesante añadir ruido de manera
artificial, pues permite aumentar la resolución del conversor, si bien, esto no será
abordado en este tutorial.
Por estas razones, creo conveniente explicar algunas técnicas de filtrado digital de la
señal. Nunca va mal aplicarlas, incluso a una NTC.
Para empezar, veremos la más sencilla: la media. Algo tan simple como sumar todos los
valores acumulados, y dividir por en número de muestras. Para el caso, conviene
siempre usar una cantidad que sea potencia de dos, o sea, 2, 4, 8, 16, 32, 64, etc. Eso
nos permite hacer un simple desplazamiento a la derecha de 1, 2, 3, 4, 5, 6 bits
respectivamente, reduciendo una división a unas pocas operaciones del micro.
Este método tiene dos inconvenientes: hay que hacer muchas sumas, con el posible
‘overflow’, y hacen falta n muestras para hacer dichas sumas. O sea, que se obtiene una
medida cada n muestras. Esto vale para algo que cambia tan lentamente como la
temperatura, pero para otros valores puede no ser válido.
Por eso, hay un truco muy habitual: la media móvil. Se trata de siempre tener un valor
acumulado al que se le suma el nuevo valor del buffer, y se le resta el más viejo. Una
suma, y una resta. Luego este valor, se divide por el número de muestras, como una
media normal. La ventaja de este método es que es rápido, y que tenemos una media
para cada muestra del ADC. Pero antes hay que ‘llenar’ el valor acumulado, es decir,
que hasta al cabo de n muestras (sólo las N primeras), no tendremos un valor fiable.
Otro problema habitual en algunas medidas, es que a veces el ruido introduce algún
valor muy fuera de lo normal, y que por tanto el resultado no queda muy bien filtrado.
Para este problema, se usa un filtrado ‘robusto’. Este sistema consta en hacer la media
sobre n muestras de un total de m. Por ejemplo, tomamos 34 muestras, pero hacemos la
media sólo sobre 32, descartando la medida más alta, y la más baja. De esta manera, se
reduce el efecto indeseable que puede producir un ruido eléctrico. Un ejemplo de
medida donde se suele usar esta técnica, es en la medida de distancia por ultrasonidos.
Hasta aquí las técnicas básicas de filtrado. No son muy complicadas, son eficientes,
habituales, y entendibles para mucha gente. Pero no son las mejores desde el punto de
vista de prestaciones. Veamos pues dos técnicas más, habituales en sistemas
profesionales: el filtro FIR y el filtro IIR.
Hemos visto la media aritmética como la suma de valores, y su posterior división por el
número de muestras. Este sistema, desde un punto de vista matemático, otorga igual
‘importancia’ a todas las muestras, es decir, que se valora tanto la primera como la
última. Pero podemos decidir dar una ‘valoración’ diferente para cada muestra, es decir,
dar más importancia a las muestras que no son ni viejas ni nuevas, y menos importancia
a las muestras más viejas (por ‘obsoletas’) o a las más nuevas. Por tanto, podemos
multiplicar cada muestra por un valor (la ‘ponderación’) diferente, y luego escalar, es
decir, dividir por un valor adecuado para que el resultado sea le que nos interesa.
Generalmente, suele ser la suma de los valores de la tabla de valoración. Esto también
se llama Media Ponderada.
Pues bien, esto último que hemos explicado, es la base de lo que se llama convolución,
y que para el caso, forma lo que se llama filtro FIR, por Respuesta al Impulso Finita (los
anglosajones, siempre haciendo las cosas al revés). Se llama así, porque dado cualquier
entrada, cuando esta pasa a valer 0, la salida del filtro, al cabo de un tiempo finito
SIEMPRE será 0.
Este tipo de filtro es el que tiene mejores prestaciones desde el punto de vista de
procesado de la señal. También es el que necesita más potencia de cálculo, pues para
cada muestra se tienen que generar n multiplicaciones y n sumas, con una división. Por
este motivo, hay circuitos electrónicos (llamados Multiplica y ACumula, MAC)
específicos para acelerar este proceso, y que se usan en sistemas de procesado digital de
la señal (DSP’s).
El cálculo de los valores, también llamado ‘núcleo’ de la convolución, es una parte
complicada para ser explicada aquí, y es lo que nos determinará el comportamiento del
filtro (pasa bajos, pasa banda, pasa altos, etc). El que presentamos en este programa, con
el nombre de FIR, es pasa-bajos.
Por último, y dado que los filtros tipo FIR requieren tanta potencia de cálculo, hay que
destacar que hay una alternativa: los filtros IIR, por Respuesta al Impulso Infinita. Estos
filtros se basan en usar los resultados de salida del filtro para calcular la nueva salida. Es
decir, que tienen una ‘realimentación’. Y por este motivo, puede ser que cuando se les
aplica una entrada que al cabo de un tiempo pase a ser cero, la salida puede continuar
dando valores diferentes infinitamente. Y para muestra, probad a usar el siguiente:
Y=X+2Y-1 donde Y es el valor de salida actual, X es la entrada del filtro (la muestra), e
Y-1 el valor anterior de salida del filtro. En C se puede escribir como:
Out = ADC+2*Out;
Es un ejercicio interesante probar poniendo ADC como 1 la primera vez, y el resto de
veces que valga 0. Así se demuestra lo peligrosos que son estos filtros.
Pero bien diseñados, pueden ser buenos, y hay uno muy usado como filtro pasa-bajos,
que es el que se presenta en este caso. Para tal filtro, se toma un valor de valoración A
entre 0 y 1, que nos determinará las características del mismo: cuanto más grande sea A,
más lenta será la respuesta (menor frecuencia de corte). Cuanto más pequeño sea A, más
rápido (mayor frecuencia de corte). La aplicación es la siguiente:
Y = (1-A)*X + A*Y;
Pero como trabajamos con enteros, en este caso daremos a A un valor entre 0 i 63, y
haremos lo siguiente:
Y = (63-A)*X + A*Y;
Y = Y/63; o lo que es lo mismo, Y = Y>>6;
Una cosa muy importante a la hora de hacer estos cálculos, es que este sistema de
cálculo es muy peliagudo desde el punto de vista de los escalados de los factores. Es
muy fácil tener problemas de overflow si uno se descuida, así que hay que vigilar
mucho las magnitudes de los resultados de las operaciones.
Como guía, la suma de dos números de n bits, dará un número de n+1 bits. El producto
de dos números de n y m bits dará un número de n+m bits. Por tanto, si el resultado del
conversor es de 10 bits, y sumamos 64 resultados, el valor nos ocupará 64 bits. Por
tanto, para el caso no podemos sumar más de 64 resultados para no tener problemas de
overflow.
Para un filtro IIR, lo mismo, no podemos multiplicar un valor de 10 bits por uno de más
de 6 bits (63), sin que nos pueda dar un desbordamiento. Y para un filtro FIR, si
multiplicamos enteros de 10 bits por enteros de 10 bits y sumamos 32, obtenemos un
valor de 25 bits, o sea, que de todas maneras, debemos acumular el resultado en un
entero de 32 bits. Esto no sólo implica más operaciones y complejidad, si no que obliga
a ser más cuidadoso con la elección de los valores, los escalados, las operaciones, etc.
0
100
200
300
400
500
600
700
1 3 5 7 9 11 13 15 17 19 21 23 25 27 29 31 33 35 37 39
Media
Filtro FIR
Filtro IIR
En la gráfica anterior, se puede ver el resultado de los diferentes filtros ante una entrada
constante a partir de la muestra 4. De este gráfico, se desprende que el filtro más rápido
es el IIR, que también es el que más se parece a los filtros electrónicos simples (R-C),
mientras que la media es el más lento, y el filtro FIR es el que de el resultado más
suave.
Conclusiones.
Después de lo aquí explicado, queda claro que el tomar medidas provenientes de
sensores externos es algo más que simplemente programar el conversor ADC. Pero con
unas simples herramientas, un poco de idea, y algo de matemáticas, no es muy difícil
obtener resultados profesionales con poco esfuerzo.
Beamspot.