Table of Contents....Portfolio of Work....Informes
 

informes de investigación

por Adam M. Hasler

 
sobre estos
informes
 
informes introductorios
diario de diciembre
 
introducción al Arduino y otras herramientas

 
informes de sensores y protocolos
Making Things Talk proyecto 1
 
Making Things Talk proyecto 2
 
informes de microcontroladores
microcontroladores parte 1: el fracaso
 
microcontroladores parte 2: el éxito
 
microcontroladores parte 3

introducción al Arduino y otras herramientas


Making Things Talk capítulo 1 y Getting Started with Arduino

describe: mis experiencias con el libro introductorio al Arduino, Getting Started with Arduino por Massimo Banzi, y capítulo 1 de Making Things Talk por Tom Igoe, que introduce al lector a muchos de los protocolos y las herramientas físicas y electrónicas que se encuentran en circuitos interactivos.
fechas: enero 2010
Me fui por los Estados Unidos para la navidad y el año nuevo, y cuando regresé, traje una caja de herramientas conmigo, llena de cosas para seguir con mis investigaciones. Mis planes: los primeros proyectos en Making Things Talk, y los tutoriales en Sparkfun y Adafruit sobre la programación de microcontrolers. Además, seguía con mis cursos on-line de programación en C, Processing, y software de interactividad. Mi intento, después de unas pocas semanas de explorar un poco fue tener un conocimiento muy bueno de los códigos basados en C (C, C++, Java, y Processing), un mejor conocimiento de sensores comunes y protocolos de datos (Making Things Talk), y la capacidad de trabajar con circuitos y microcontroladores (seminarios en Adafruit y Sparkfun). Mi descripción de lo que sucedió con esos proyectos aparece en los capítulos siguientes.

En este punto en los principios de enero, comencé con investigaciones y una introducción general de protocolos, el uso de Arduino, y formas de datos. Primero, Making Things Talk, una colecció de proyectos, dice que la computación física tiene que ver sobre todo con los objetos: objetos de software, objetos de datos, y la interfaz (o protocolo, la serie de criterios para comunicación entre dos o más objetos) entre todos para realizar un propósito. Todo los proyectos en Making Things Talk están basados en Arduino y su primo Processing, y involucran el uso de varios otras herramientas, como puertos en la computadora, PHP y servidores*, UNIX y la línea de comanda, etc. En todas las pruebas para que necesito un servidor de web, uso mi propio sitio de web, www.projectpageone.com. Mi webhost es OCS Solutions.

*Para aprender más sobre PHP, por favor ver proyecto dos, en que envío un email con un switch.

Según Tom Igoe (escritor del libro), el uso de Arduino es un proceso en tres etapas:

  1. Se contecta los sensores a las entradas para convertir la energía física como moción, calor, y sonido a la energía eléctrica.
  2. Se adjunta los motores, parlantes, y otros aparatos a las salidas para convertir la energía eléctrica a la acción física.
  3. Por fin, se escribe un programa para determinar como los cambios de entrada afecta las salidas.
Buenos Consejos de Tom Igoe, el escritor de Making Things Talk:
  • Si un objeto de software se confunde, escribe un programa sencillo que demuestra solo esa función, y luego regresa al proyecto.
  • Se debería escribir programas tal como escuchan para mensajes nuevos el mayor parte del tiempo, y envían mensajes nuevos solamente cuando está necesario.
  • Tal vez se tendrá la tentación de hacer toda la lógica del sistema y todos los pasos de los mensajes antes que se empiece conectar las cosas, y luego construirlo y probar todo a la vez. Evite esa tentación.
Además, da una descripción de los requeridos de cada sistema interactivo, que ha de tener un acuerdo en cinco niveles:
  • Física: Cómo están conectadas las entradas y salidas? Cuantas conexiones hacen falta para comunicar mensajes?
  • Eléctrica: Cuáles niveles de voltaje estarán enviados para representar los bits de data?
  • Lógica: Representa 0 o 1 una súbida en voltaje?
  • Datos: Qué es la rapidez de los bits? Son en grupos de 8, 9, o 10 los bits? Hay bits en el comienzo o el fin?
  • Aplicación: Cómo están arreglados los grupos de bits? En qué orden están intercambiado?
Encontré estas lecturas sumamente importantes, en términos de describir la mejor práctica de construir dispositivos interactivos.

El fin de capítulo de Making Things Talk sobre el funcionamiento seguía muy bien a mi próximo paso, leer Getting Started with Arduino, un curso introductorio y corto para Arduino, que usa texto y pruebas para demostrar la placa creada por Massimo Banzi. La información de los siguientes párrafos vienen por el mayor parte de eso dos textos, sino que note otro.

El usuario del Arduino y los circuitos interactivos exige en tres tipos de información, con que el Arduino puede manipular y procesar: el digital, el análogo, y el serial. En términos de circuitos físicos, hay dos circuitos básicos, la entrada análoga y la entrada digital. El circuito digital detecta si hay voltaje o no en un circuito, y maneja en dos términos: 0 o 1, verdad o falso, sí o no, prendido o apagado, etc. Está compuesto de un circuito básico de fuente, switch, resistencia, y masa. Una conexión adicional, que representa una puerta lógica, va desde el circuito principal al microcontrolador. Cuando el switch cierra y permite la fuente de electricidad por el circuito principal, el sensor en el microcontrolador recibe el señal que hay corriente, y comunica un mensaje de 1 al resto del sistema. Si la puerta lógica junta con el circuito principal después de la resistencia, se llama una resistencia pull-up. Si se conecta antes de la resistencia, es una resistencia pull-down. Por el mayor parte, se prefiere el uso de la resistencia pull-up. Para aprender más sobre esto, visita éste.

Más consejos de Igoe sobre buen diseño físico:
  • botones de poder y reinicializar
  • luz de indicación de poder
  • claridad de la arriba y el abajo del dispositivo.
  • controles físicos claramente visible
Una circuito análogo tiene un sensor que se actúa como un divisor de voltaje, en que el voltaje total de un circuito está proporcionado entre dos resistencias (una con valor variable, una fija). El sensor está después de la resistencia variable, y detecta la proporción del voltaje que va a través de esa. Distinto que el circuito digital, el valor de la información está expresado sobre un gran alcance de valores, por lo usual entre 0-255, dependiendo en los bits o sistema de numeración que se usa para guardar la información.

Estos sensores y mensajes son interesante, pero vale muy poco sin un microcontrolador que hace sentido de los pulsos de electricidad. Han existido por mucho tiempo en varias formas (PIC y AVR, entre otros, que se distinguen por el tipo y cantidad de memoria que tiene, la presencia de una oscilador, numero de patitas, arquitectura, y muchos otros aspectos). En 2005 empezó el proyecto Arduino en el Instituto de Diseño Interactivo de Ivrea, Italy (IDII, ahora parte del Instituto Domus, Milano). Fue desarrollado por el propósito de hacer más barato el proceso de construir prototipos en proyectos de diseño.

circuitos y programas básicos para el Arduino

arduino_schematic
esquemático del Arduino Duemilanove

Arduino tiene dos partes: un plataforma open-source de computación física. En el centro de la placa es (para el Arduino Duemilanove) el microcontrolador ATMEGA168 (un chip AVR, otros tamaños disponibles), y el resto de la placa tiene todos los componentes para que funcione correctamente el microcontrolador (poder, conexiones con sensores, actuadores, y la computadora). El segundo parte del Arduino es el ambiente de desarrollo que implementa una modificación del lenguaje de Processing (Desarrollado por Casey Reas en MIT Media Lab para artistas y diseñadores, y basado en el lenguaje Wiring). La intención del ambiente de programación es esconder el mayor parte de la traducciones al lenguaje de maquinas, y entonces las complejidades de la programación de microcontroladores.

Circuitos con entrada y salida digital son los más básicos, entonces también los más predominantes. Empecé probando y aprendiendo las construcciones de estos circuitos, que tienen muchas posibilidades, que son hechas con unos trucos de programación. El siguiente demuestra los cambios en salida que suceden con cambios en programación.

blink_schematic
esquemático para programas 1 y 2

programa 1: el botón empujado, luz prendida - el más básico. Se empuja un botón, y prende una luz.

// Constantes no cambian,
// ponen numeros de patitas:
const int buttonPin = 2; // el numero del patita del botón
const int ledPin = 13; // el numero del patita del LED

// variables cambian:
int buttonState = 0; // variable para leer el estado del botón

void setup() {
  // inicia el patita del LED como salida:
  pinMode(ledPin, OUTPUT);
  // inicia el patita del botón como entrada:
  pinMode(buttonPin, INPUT);
}

void loop(){
  // lee el valor del estado del botón:
  buttonState = digitalRead(buttonPin);

  // Revisa si está empujado el botón.
  // si es, el "buttonState" está HIGH:
  if (buttonState == HIGH) {
    // Prende el LED:
    digitalWrite(ledPin, HIGH);
  }else{
    // Apaga el LED:
    digitalWrite(ledPin, LOW);
  }
}

programa 2: la luz prenda y apaga con debounce. Con este programa, usamos un variable que actúa como una forma de memoria ("state"). Esta variable usa tipo de memoria que se llama RAM. Cuando se apaga la placa, los datos guardados en RAM está perdido (y los valores de los variables regresan a sus valores iniciales). Programas no están guardados en RAM, pero en la memoria flash.

Además, este código incluye una pieza de información incluida para evitar "bouncing", o señales eléctricas no anticipadas. Aunque existen muchas maneras de evitar bouncing, una demora de 10 milísegundos está usada en este ejemplo.

#define LED 13 // el patita para el LED
#define BUTTON 7 // el patita de entrada donde está conectado el botón

int val = 0; // estaré usado para guardar el estado el patita de entrada.

int old_val = 0; // este variable guarda el vaor previo de "val".

int state = 0; // 0 = LED apagado y 1 = LED prendido

void setup() {
  pinMode (LED, OUTPUT); // decirle Arduino que es una salida
  pinMode (BUTTON, INPUT); // y botón es una entrada
}

void loop() {
  val = digitalRead(BUTTON); // lee el valor de entrada y la guarda

  // averigua si hay una transición
  if ((val == HIGH) && (old_val == LOW)){
    state = 1 - state; // me encanta este parte. muy astuto.
    delay(10);
  }

  old_val = val; // "val" ahora es viejo. Hay que guardarlo.

  if (state == 1) {
   digitalWrite(LED, HIGH); // prende el LED
  }else{
    digitalWrite(LED, LOW);
  }
}
dimmer_schematic
esquemático para programa 3

PWM graphic
programa 3: modulación de la anchura de pulso (Pulse Width Modulation, o PWM). Hasta ahora solo hemos visto ejemplos que prende y apaga la led. Usando un técnico que se llama PWM, es posible también controlar la brillantez del led. Básicamente, la rapidez de parpadear de una luz, y la proporción entre estar prendido y apagado, crea el efecto de disminución o subida de brillantez. El ojo no detecte parpadear, solo el cambio en la brillantez. Este efecto exige en el mismo efecto que usa una televisión o el cine. El diagrama a la izquierda explica estas proporciones.

Se puede usar tres patitas en el Arduino (patitas 9, 10, 11) para este tipo de salida...aún tiene el nombre PWM en la mayor parte de placas Arduino. Se controla estas patitas usando la comanda analogWrite() en el Arduino IDE. Hace la misma cosa que el PWM digital, sin embargo en vez de proporciones y demorras, usa un valor entre 0-255. También por que hay tres patitas, y ergo la posibilidad de tres canales, contectados a leds rojo, azul, y verde se puede hacer cualquier color.

#define LED 9 // la patita para el LED
int i = 0; // se usa para contar arriba y abajo

void setup(){
  pinMode(LED, OUTPUT); // dice al Arduino que el LED es una salida
}

void loop(){

  for(i=0; i<255; i++){ // ciclo desde 0 a 254 (prende)
    analogWrite(LED, i); // arma la brillantez
    delay(10); // Espera 10ms porque analogWrite
               // es instantáneo y no veríamos cambio.
  }

  for(i=255;i>0;i--){ // ciclo desde 255 a 1 (apaga)

    analogWrite(LED, i); // arma la brillantez del LED
    delay(10); // espera 10ms
  }

}

Con entrada análoga, podemos mover más allá que la entrada digital, que funciona siempre en términos binarios. La entrada análoga nos puede decir no sólo si algo está prendido o apagado, pero la cantidad de algo, expresado en un valor entre 0 y 1023. Se utiliza esta función del Arduino con la función analogRead().

Comunicación Serial

El aspecto final de la interfaz del Arduino es la capacidad de comunicarle con el Arduino y monitor la información que recoge con la computadora usando la comunicación serial. La computadora trata el Arduino como un objeto serial, como un mouse o teclador, y con la adición de la comanda Serial.println(), y la especificación de la rapidez de la transferencia de datos entre el Arduino y la computadora, el Arduino envia información serial a la compu. Con esta información se puede comenzar construir proyectos en la computadora que usa esta información como entrada. Aprendería más sobre la comunicación serial en el primer proyecto de Making Things Talk y los capítulos finales de los tutoriales de Sparkfun.

En este punto de mi trayectoria, fui en dos direcciones. Una fue el proceso despacio de aprender, poco a poco, sobre temas más avanzados de sensores y protocolos de datos en Making Things Talk. El otro fue un entendimiento mejor del Arduino y su funcionamiento, con el intento de, por lo eventual, hacer uno yo mismo. Los siguientes informes se tratan de esos proyectos que hice para progresar en estas dos trayectorias distintas.

 
contacto

amhasler[at]gmail[dot]com

 
textos
Making Things Talk
 
Getting Started with Arduino
 
seminarios de Sparkfun
 
otros vínculos
Processing
 
Arduino
 
Estado Lateral
 
Adafruit
 
AVRFreaks
 
Doing the Projects in Making Things Talk