Control de múltiples servos con un único TIMER.

En esta entrada vamos a ver como conectar nuestro microcontrolador con otro dispositivo muy popular, un servomotor. Un servomotor es un motor DC, similar a los usados en las entradas que dedicamos al control de motores. Sin embargo, al contrario que los motores que manejamos allí, los servomotores incluyen su propio hardware de control, por lo que no tendremos que preocuparnos de esa parte.

En la primera parte de esta entrada describiremos los fundamentos de cómo controlar un servo con un microcontrolador, con una mínima sobrecarga para el PIC mediante el uso de un timer y sus interrupción asociada.

En la segunda parte extenderemos este enfoque para el caso de que necesitemos controlar muchos servos con un único PIC. Veremos como podemos controlar hasta 8/10 servos dedicando sólo un TIMER del microcontrolador.

Archivos de código asociados a esta entrada:  servo_calib.c  y  servo_n.c

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

Monitor del ritmo cardíaco

Vamos a volver a usar el sensor de luz TSL235 en una aplicación más interesante: monitorizar nuestro ritmo cardíaco.  ¿Cómo hacerlo con un sensor de luz? 

La idea viene explicada en una "application note" dedicada a estos sensores:

http://smartdata.usbid.com/datasheets/usbid/2000/2000-q2/230evm2taos.pdf

La configuración propuesta se muestra en la imagen adjunta. Un LED (u otra fuente de luz) ilumina un dedo, detrás del cuál se encuentra nuestro sensor. A cada pulsación del corazón, un nuevo flujo de sangre llega al dedo, cambiando su "opacidad" a la luz. El objetivo es detectar dichas oscilaciones, determinar su frecuencia fundamental y a partir de ahí el ritmo cardíaco en pulsaciones por minuto (ppm).

En la aplicación citada antes, el microcontrolador solo recoge los datos del sensor y los manda al PC para su proceso. La principal mejora de mi proyecto es que el PIC no sólo captura la señal, sino que la procesa y obtiene el ritmo cardíaco. De esta forma tenemos un sistema autónomo.

Al igual que en otras entradas el código del PIC se complementa con un programa MATLAB que nos permite ver gráficamente los datos sobre los que trabajamos y los resultados obtenidos. Recalcar que el programa MATLAB sólo visualiza los datos: todos los cálculos se llevan a cabo en el PIC.

En este corto video podemos visualizar los datos obtenidos tras un pre-proceso de los datos del sensor. Es sobre esta señal sobre la que el PIC trabaja para estima su periodo:

Archivos de código asociados a esta entrada:

     PIC:   pulse_monitor2.c  

     MATLAB: heart_monitor.m

Vuelta de vacaciones

 He vuelto hoy de vacaciones y me he encontrado con un montón de comentarios nuevos. Desde mi perspectiva norte-céntrica pensaba que agosto sería un mes muy tranquilo, pero veo que no.

Intentare ponerme al día en los próximos días.

   Un saludo,  Antonio.

Aplicación modo CAPTURA: sensor TSL235

En la entrada anterior describimos la funcionalidad del modo Captura del módulo CCP. En esta entrada usaremos dicha funcionalidad en una sencilla aplicación.  

Vamos a usar el sensor TSL235, que es un medidor de intensidad de luz. Al contrario que otros sensores, cuya salida es un voltaje proporcional a la irradianza recibida,  la salida de este sensor es una onda cuadrada, cuya frecuencia es proporcional a la magnitud (luz) medida. 

Usando el módulo de CAPTURA mediremos el periodo de los pulsos emitidos. A partir de dicho periodo será sencillo deducir su frecuencia y de ahí la irradianza (en W/m2) recibida.

Como en entradas anteriores, los datos recibidos se mandan al puerto serie del PC donde usamos un programa MATLAB para ver los resultados.

Archivos de código asociados a esta entrada:  

  Código para PIC      tls235.c  

  Programa MATLAB    flicker.m  

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

Modo de Captura en el módulo CCP

En una entrada anterior (PWM) vimos una de las funcionalidades del módulo CCP. En esta entrada describiremos otra de sus funcionalidades, el modo CAPTURE.

Como su nombre indica, este modo se usa para capturar eventos. Los eventos serán bajadas o subidas de los pines correspondientes a CCP1 y CCP2 que son, respectivamente, RC2 y RC1 (este último puede cambiarse por RB3 en la configuración inicial).  Para la captura se precisa que un timer este corriendo. Este timer será nuestro "reloj": capturar un evento será grabar la "hora" (contador del timer) en que se ha producido. Los timers usados con el módulo de CAPTURA pueden ser tanto el TMR1 como el TMR3.

Podríamos conseguir similares resultados usando las interrupciones INTx que vimos en los codificadores en cuadratura. Cada vez que entre la interrupción podríamos guardar el valor de un timer que este corriendo. La diferencia es que con este enfoque, para cuando "miremos la hora" ya habrá pasado un tiempo (mientras el micro termina lo que esté haciendo, pasa el control a la interrupción, etc.) que puede ser del orden de microsegundos.

Por el contrario, si se usa el método de captura, en cuanto se produce el evento se copia el valor del timer usado a los registros CCPRxH:CCPRxL. Por supuesto, será nuestra responsabilidad guardar dicho valor en otra variable antes de que se repita el evento y se machaque con otro valor.

En la entrada explicaremos la configuración del modo de CAPTURA y los registros asociados. En la siguiente entrada usaremos el modo de CAPTURA para leer los datos de un sensor de luz (TSL235) cuya salida en una onda cuadrada de frecuencia variable. 

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

Proyecto: Medidor de potencia

En este proyecto vamos a construir un medidor de potencia, un dispositivo que monitoriza la potencia (de la que se puede deducir fácilmente el consumo) de un electrodoméstico o cualquier otro aparato conectado a la red.

Para obtener la potencia consumida tendremos que monitorizar (muestrear) la intensidad y el voltaje de la red. Como siempre que manipulemos la red, debemos ser muy cuidadosos con nuestros montajes. Existen varias formas de monitorizar el voltaje e intensidad de la red. En este montaje he escogido la que me ha parecido más segura: un montaje en el que existe un aislamiento galvánico entre la red y las señales que el micro monitoriza.

Una vez que tenemos las medidas de intensidad y voltaje a lo largo de un ciclo de trabajo (20 milisegundos si nuestra red va a 50 Hz) es muy sencillo para el micro estimar valores como la intensidad RMS, potencia RMS y potencia real consumida y volcar los resultados por el puerto serie o (si queremos un sistema más autónomo) presentarlos en un LCD.

Como en proyectos anteriores, se adjunta un programa MATLAB para visualizar los datos capturados (intensidad, potencia instantánea, etc.) a lo largo de un ciclo, permitiéndonos ver gráficamente aspectos como el desfase entre Intensidad y Voltaje, forma de onda de la intensidad, etc.  En el video adjunto se muestran los resultados para el caso de una pequeña batidora, mientras cambiamos su velocidad, ponemos el "turbo", etc:

Código asociado:  power_meter.c  (código PIC)
                         18f4520_g.lkr    (linker script modificado) 
                         power_meter.m (programa MATLAB de interfaz con el PC).  

Formateo de números en coma flotante

Como comentamos en la entrada anterior, la función sprintf (y sus variantes) del compilador C18 no tienen soporte para volcar datos de tipo float en coma flotante (modificador %f en ANSI C). La posible razón es que interpretar y volcar números en coma flotante no es trivial, por lo que el código necesario es relativamente grande. La función sprintf ya ocupa bastante código (alrededor de 2K word) y si incluyese soporte para números reales su tamaño posiblemente se doblaría. Al ser una función monolítica, dicho coste adicional lo sufrirían incluso aquellos usuarios que nunca trabajasen con números en coma flotante.

En esta entrada vamos a describir la representación de números en coma flotante dentro del PIC para entender como se guarda la información. A partir de ahí crearemos un par de rutinas que nos permitan volcar este tipo de datos a una cadena.

El objetivo es poder sacar datos por el LCD o puerto serie con los formatos mostrados en la figura adjunta, que corresponden a %e (izquierda) y %f (derecha) del printf definido en ANSI C.

Código asociado a esta entrada: float2ascii.c 

Formateo de datos (para LCD o puerto serie)

En muchos momentos (presentación de resultados, debug) tendremos que visualizar valores de la variables de nuestro programa por el LCD, puerto serie o equivalente. Ello conlleva convertir los datos numéricos en cadenas de texto mostrando sus contenidos, bien sea en formato binario, hexadecimal, decimal, etc.

El compilador C18 (y otros basados en ANSI C) ya cuentan con una forma rápida y versatil de hacer dicha conversión: con las rutinas tipo printf, sprintf o equivalentes.

Estas funciones son muy flexibles y convenientes pero como veremos pueden ser lentas y ocupar bastante espacio. Son ideales por su conveniencia en las primeras fases de un desarrollo. Sin embargo, si la  aplicación se va complicando y nos acercamos a los límites del micro usado podemos encontrarnos con que ocupan demasiada memoria de programa y/o van demasiado lentas.

En esta entrada replicaremos la funcionalidad de sprintf de forma modular. Escribiremos varias rutinas para volcar diferentes datos enteros con varios formatos (binario, hexadecimal, decimal con o sin signo, etc). Estas funciones, al preocuparse de un solo argumento y tipo de formato van a ser mucho más pequeñas y rápidas que sprintf. Además, muchas veces, dentro de una aplicación, solo trabajaremos con un cierto tipo de datos, por lo que este tipo de rutinas pueden ahorrarnos bastante código.

En una entrada posterior trataremos el tema de la presentación de datos tipo float, del que carecemos por defecto en C18.

Código asociado a esta entrada: int2ascii.c