Entornos y Contornos | UNQ | Cierre de Ciclo 2007

JUEVES 13 de DICIEMBRE - 20 hs. | Entornos Simultáneos | Cierre de Ciclo 2007
P R O Y E C C I O N E S S I M U L T Á N E A S + B R I N D I S

Sensores de Campo Magnético

El efecto Hall es un fenómeno descubierto en 1879 por Edwin Herbert Hall y consiste en la aparición de un campo eléctrico en un conductor cuando este es atravesado por un campo magnético. Industrialmente se fabrican sensores que se basan en este principio y pueden ser usados para detectar el movimiento de un engranaje, cambios de dirección y sentido, medir velocidad y posición, entre muchas otras cosas.

Estos dispositivos vienen integrados y básicamente entregan una tensión (voltaje) de salida en función de la densidad campo magnético a la cual están expuestos.

Podemos empezar clasificando estos sensores en dos grandes grupos, lineales y conmutados. Los sensores lineales son aquellos en los que la tensión de salida es proporcional a la intensidad de campo magnético. Por otro lado los conmutados son aquellos que la salida varia entre dos valores que llamaremos “on” y “off” (encendido y apagado) dependiendo de la intensidad y/o polaridad del campo magnético. El punto (o intensidad) de campo magnético necesario para conmutar el sensor esta especificado para cada modelo en particular.

Los sensores conmutados son comúnmente utilizados en pulsadores, botones sin contacto mecánico y medidores de velocidad. Dentro de los sensores conmutados están los llamados bipolares, que diferencian que polo magnético del imán esta expuesto, por ejemplo pasan al estado “on” cuando se lo expone al polo sur del imán y al estado “off” frente al polo norte (por ejemplo, posibilita detectar dos caras de una pieza).

En el caso de los sensores lineales, son utilizados para medir corriente eléctrica, proximidad entre objetos, entre otras cosas.

La siguiente clasificación nos servirá a la hora de elegir un sensor (eso espero):

Conmutados

• Onmipolar: Conmutan de acuerdo a la intensidad de campo magnético. No diferencian polo norte de polo sur.
• Bipolar: Conmutan de acuerdo a la intensidad y polaridad del campo magnético. El valor de salida es indeterminado ante la ausencia de campo magnético.
• Latches: Son equivalentes a los bipolares pero a diferencia de estos el valor de salida quedara constante si se elimina el campo magnético aplicado.
• Contador de dientes de engranaje: Es una pastilla que incluye un imán y un sensor, con capacidad para contar los dientes de un engranaje metálico que pasa por delante de el.
• Diferenciales: Presentan inmunidad al ruido causado por ejemplo por variaciones mecánicas.
• Histéresis: Presentan una memoria que los hace inmunes al ruido magnético.

Lineales

• Lineales: el voltaje de salida de este sensor es proporcional a la intensidad de campo magnético aplicado.
• Sensores de corriente: Esencialmente son sensores lineales con características mecánicas y de operación particulares, para montar cerca de cables y/o en plaquetas.

Para muchas de las aplicaciones es necesario construir piezas con imanes adosados o utilizar imanes industriales de formas particulares.

Estos sensores pueden ser obviamente conectados a cualquiera de las plataformas de desarrollo disponibles, como así también a microcontroladores en general.

Les dejo el enlace a uno ejemplo de Arduino que se llama ReadingRPM (no esta muy documentado, pero si saben leer código de Processing lo podrán entender) que hace uso de un sensor de efecto hall para medir la velocidad de rotación de un ventilador de PC.

Este es otro enlace de un proyecto muy interesante (y bastante complicado) que hizo la gente de CUI que se llama Musical Interaction Design with the CREATE USB Interface.

Enlaces de los fabricantes de sensores:

Allegro MicroSystems

Gainer

Gainer es una plataforma para realizar prototipos de sistemas interactivos e instalaciones en general. Gainer puede manejar sensores y actuadores desde una PC usando Flash, Max/MSP y Processing. Algunos puntos básicos a destacar son:

• Puede ser usado en las etapas de desarrollo y producción
  
• Utilizando una plaqueta de experimentación el usuario puede aprender por prueba y error
• El usuario puede construir sus propias interfaces de entradas y salidas
• Existen varias configuraciones disponibles
• Todo el proyecto es abierto (hardware y software)
  

El proyecto esta basado en el microcontrolador Cypress CY8C29466. En una próxima entrada voy comentar un poco cuales son las particularidades de este microcontrolador.

Videoproyección | Sincronías Precarias

Processing: Manejando imágenes

Processing es un entorno de desarrollo que permite a artistas, diseñadores y entusiastas en general crear aplicaciones para manipular imágenes, sonidos e interacción en general de manera sencilla.
La idea es presentar alguna de las posibilidades de processing usando una cámara.
En este articulo me voy a concentrar en un programa que captura y muestra constantemente imágenes de la cámara, en el momento que se hace clic en el mouse una nueva imagen estática es volcada al área de visualización como si fuese una foto.
La forma de implementar este programa no es única, elegí una forma que sea sencilla de leer y muestre varios elementos de processing.
Los comentarios están incluidos en el código de forma tal que se pueda copiar y pegar directamente en processing.

// Indico que paquetes importar.
import processing.video.*;

// Declaro los objetos que voy a usar.
// La forma de declarar un objeto es:
// TipoDeObjeto nombreDelObejto;
// myCapture representara a la cámara.
Capture myCapture;
// capturedPhoto: almacenara la imagen capturada al
// momento de hacer clic en el mouse

PImage capturedPhoto;
// graphicBuffer es un objeto intermedio que permite
// manipular las gráficos
PGraphics graphicBuffer;

// Declaro dos números enteros y les asigno el valor:

// w representa el ancho de una imagen.
// h representa la altura de una imagen.
int w = 320;
int h = 240;

// Declaro e inicializo una variable que me servirá
// como indicador para saber si debo volcar una
// nueva imagen en la visualización.
boolean newPhoto = false;

// Función de inicialización:
void setup() {
 // Preparo la zona de visualización, serán dos
 // imágenes distribuidas horizontalmente,
 // por eso w*2 indica un ancho del doble de una imagen

 size( w * 2, h, P2D );

 // Negro para el fondo del área de visualización
 background( 0 );
 // Creo gráfico intermedia para guardar la imagen 
 // capturada

 graphicBuffer = createGraphics( w, h, P2D );

 // Creo el objeto que maneja la cámara:
 // En este caso usara la ultima cámara utilizada por 
 // quicktime. Parámetros:
 // this: Esta aplicacion
 // w, h: son el ancho y el largo de la imagen capturada
 // 5: es la cantidad de cuadros por segundo a capturar

 myCapture = new Capture( this, w, h, 5 );

}
// Esta función es llamada por procesing cada vez que 
// el usuario hace clic con el mouse
void mouseClicked() {
 // Guardo la imagen actual, este área de gráficos que
 // me permitirá en un futuro dibujar o trabajar sobre la

 // imagen capturada
 graphicBuffer.set(0, 0, myCapture);

 // Convierto el área de gráficos en una imagen común
 // para poder mostrarla fácilmente.
 capturedPhoto = graphicBuffer.get();
 // Inidico que se ha capturado una nueva imagen.

 newPhoto = true;
}

// Esta función es llamada por processing por cada imagen
// disponible de la cámara
void captureEvent(Capture myCapture) {

 // ¿Existe una nueva imagen desde la cámara?
 if(myCapture.available()) {
   // Leo de la cámara la nueva imagen
   myCapture.read();

 }
}

void draw() {
 // Actualizo la visualización con la imagen obtenida
 // captureEvent()

 image(myCapture, 0, 0);
 // Pregunto si existe una imagen capturada con el clic 
 // del mouse

 if (newPhoto != false) {
   // Si hay imagen, la vuelco en el área de visualización,
   // al lado de la imagen antes dibujada, por eso la

   // posición de esta nueva imagen, será w,0 que indica 
   // un desplazamiento horizontal igual al ancho de una 
   // imagen (w)
   image(capturedPhoto, w , 0);

   // Vuelvo el aviso de imagen capturada a falso
   newPhoto = false;
 }
}

I don't see any method (at all) goes iPhone

LED Dimming

Recently, I’ve been seeing several projects using LEDs. One of the most interesting things to control on a LED is its brightness. Controlling LED brightness not only allows you to modulate the amount of light emitted by the LED but also compose colors if you are using a RGB (3-color) LED. I wrote this article to show the inner workings behind the LED dimming.

In order to control LED’s brightness we can use Pulse-Width Modulation (PWM.) The idea behind this mechanism is, given a desired brightness and a time period, which we call ‘T’, we’ve to set the percentage of ‘T’ in which the LED will be turned on and which one it will be turned off. We call Pulse Width to the time in which the LED is turned on (See figure).

Let’s say that during 50% of ‘T’ the LED is turned on and during 50% of ‘T’ it is turned off, the LED will emit an amount of light which we call L1. However, if we choose to turn it on during 75% percent of ‘T’ and to turn it off during 25% of ‘T’, the LED brightness will be L2, where L2>L1. We can conclude that LED brightness is proportional to the percentage of ‘T’ in which the LED is turned on (considering ‘T’ as a constant.)

Won’t I see a blinking LED instead of a constant brightness? No, but you have to choose the right value for the time period ‘T’. Human vision system has a property called persistence in which, changes that happen quickly aren’t detected by our vision system. Because of that, if we toggle the LED state (on and off) quickly we won’t see those changes, but a constant brightness (as long as we maintain the on-off ratio constant). The maximum recommend value for T is 0.01 seconds.

The hottest physical computing projects such as Arduino and CREATE USB Interface have implemented this kind of brightness controls.

The previous figure shows three different PWM setups.

Control de luminosidad para LEDs

Muchos de los proyectos que vi últimamente, hacen uso de LEDs y una de las variables fundamentales a controlar cuando usamos LEDs es su brillo. Mediante el control de brillo no solo se puede iluminar mas o menos, si no también controlar el color resultante cuando utilizamos LEDs RGB (componiendo un color). Se me ocurrió escribir este articulo de forma tal de enteder como funcionan la mayoria de los controles de intensidad de lumínica de LEDs.

Una de las manera de implementar un control de intensidad de lumínica para LEDs es usando una técnica denominada PWM, Pulse-Width Modulation en ingles y Modulación de Ancho de Pulso en español. La idea de este mecanismo de control de intensidad es la siguiente, dado un intensidad lumínica deseada y un periodo 'T' que porcentaje de 'T' estará prendido el LED. El tiempo de encendido se lo denomina ancho de pulso (ver grafico).

Por ejemplo, si durante el 50% de 'T' el LED esta prendido y el otro 50% de 'T' el LED esta apagado lograre obtener una intensidad lumínica que llamamos L1. Si ahora decido que el LED este prendido un 75% del tiempo 'T' y apagado un 25% del tiempo 'T' lograre una intensidad lumínica L2. Podemos pensar sin temor a equivocarnos que L2 > L1, es decir el LED presentara mas brillo para el caso de 75% encendido que para el caso de 50% encendido. Concluimos que el brillo será proporcional al porcentaje de ‘T’ en el cual se encuentre encendido el LED o dicho de otra manera al valor medio de la salida que controla el LED.

Ahora una pregunta que puede surgir, ¿No veré el LED titilando constantemente? La respuesta es NO, siempre y cuando 'T' este bien elegido. El sistema de visión humano tiene una persistencia, es decir no detecta los cambios de manera instantánea, por lo tanto si 'T' es lo suficientemente chico como para que el ojo no vea los cambios "prendido" a "apagado", no veremos al LED titilando, en cambio percibiremos un nivel de brillo que para nosotros será constante mientras mantengamos constante la proporción tiempo prendido, tiempo apagado de ‘T’. El valor máximo recomendado para ‘T’ es de 0,01 segundos.

Este tipo de control ya se encuentra implementado en plataformas como Arduino, CREATE USB Interface y otras.
El gráfico muestra tres situaciones distintas de PWM.
En el tercer caso, el tiempo de encendido es mas grande y como consecuencia sera el caso de mayor voltaje medio.

Seminario de Second Life en el EFT

Second Life: Presente y futuro de los Mundos Sintéticos. Se dicta en el Espacio Fundación Telefonica.

Enlace con el programa completo del seminario aqui.

Arduino

Arduino es una plataforma de código y hardware abierto que permite realizar prototipos en electrónica. Esta orientada a artistas, diseñadores, entusiastas y cualquiera que este interesado en crear objetos o ambientes interactivos.

Arduino puede censar el ambiente recibiendo información de diferentes sensores y puede actuar sobre el entorno controlando motores, luces, entre otras cosas.

Arduino esta basado en un microcontrolador que se programa utilizando el lenguaje de programación Arduino (basado en Wiring) y la herramienta de programación Arduino (basada en Processing).

Los proyectos desarrollados utilizando Arduino pueden funcionar de manera autónoma o pueden comunicarse con la PC (por ejemplo, Flash, MaxMSP)

Arduino puede utilizarse desde Windows, Linux y MAC OS X.

La idea es poder generar pequeños circuitos, sencillos de construir que otorguen la capacidad de convertir en interactivos a los objetos o ambientes.

La idea de este entrada es seguirla con una serie de instrucciones generales para entender como usar Arduino y de esa manera decidir si es lo que necesitamos para nuestro proyecto.

Pagina oficial del proyecto Arduino

DMX-512: Aproximación

DMX-512: Aproximación

Me encontré enrollado en un proyecto de control de escena (stage control).
La idea era controlar una cierta cantidad de LEDS RGB (o pixels, conformados por tres LEDS) de forma tal de poder crear efectos visuales sincronizados con la música.
Lo primero que pensé fue una interfase MIDI-USB que controle los LEDS.
El problema que surgió con esa solución es la distancia máxima entre la PC y el dispositivo USB de control, resulto ser chica para un escenario.
Investigando un poco llegue al protocolo DMX-512:

• Estándar diseñado para control de escenarios
• Características eléctricas compatibles con el estándar RS-485 (bus diferencial)
• Interfaces USB a DMX-512 disponibles comercialmente (las hay de codigo abierto)
• Frecuencia de símbolos 250KHz (cada bit 4uSeg)
• 512 canales de 8 bits cada uno
• Frecuencia de refresco ~44Hz
  

Voy a obviar por ahora algunos detalles técnicos, pero cada canal DMX se codifica en 8 bits (0-255).
Cada dispositivo tiene un/os canal/es asignado/s, entonces al momento de recibir el cuadro DMX el receptor iniciliza un contador en cero a la espera que llegue el numero de canal asignado y asi tomar el valor de esos 8 bits en particular.

En principio con un universo DMX-512 se pueden controlar hasta 512 canales, que en términos de LEDS RGB son 512/3=170 (cada LED RGB tiene un control independiente por color) que por cierto no es mucho (no es como para pensar en una pantalla).

La idea entonces es usar un microntrolador como receptor/controlador DMX-512 y una interfase comercial USB a DMX-512 para mandar los datos desde la PC. Hay muchos controladores comerciales pero suelen tener precios altos y no son fáciles de conseguir. Habrá que fabricar uno propio.