Sin duda una gran aplicación para los que hacemos uso de este protocolo constantemente para conexión del ordenador con microcontroladores, módulos usb-serial, gps, controladores de servos, etc. Lo mejor de todo esta bajo una licencia freeware y es multiplataforma.

Descargar desde la pagina oficial | freeware.the-meiers.org

Today we will see how to communicate your mobile device android / iphone / iphone / iphone with our PC, through a protocol known as OSC (Open Sound Control) , this protocol is commonly used to control luminaires and devices such as strobes, sequencers and other things used in the musical world, one could say that is the replacement of the MIDI. OSCinternet protocol uses UDP for communication, which is why we need a requirement that the devices are on the same network, know your IP address and open a communication port.

Need for the next act: processing , arduino , LED RGB device TouchOSC installed. But we’ll do exactly?? … We will create a custom template with TouchOSC editor, which we use as a control to vary the intensity of an RGB LED and color combinations to create, we will open a communication link between processing and TouchOSC, finally send all information received to an Arduino board connected to the serial port and see the result obtained in the RGB LED at the end of all this we have the following result:

For start, the first thing to do is create our template for the TouchOSC and charge it to the device, for this we use the TouchOSC Editor a tool created by Hexl that you can download from here , we will use three  fader controls with a resolution of one byte (0 – 255) to vary the intensity of the LED, for this follow the next steps in the video tutorial:

Now it’s time to open processing, but before you start throwing lines of code you need to install a specific library for communication with OSC, use the library oscP5 created by Andreas Schlegel, we can download it here, then decompress it and move its contents to documents / processing / libraries, once installed now open a new sketch.

We create a fader class that will be used as a control and to display the interaction with the mobile device, this control will be the closest thing to fader and with the same properties we use in our template, the final class for the Fader is as follows:

class Fader {

  int val, valMap;
  int px, py;
  final int h=300, w=70;
  color[] col;

  color[] red= {
    color(#DE1D2A), color(#131010), color(#501515)
  };
  color[] green= {
    color(#3B811C), color(#111410), color(#25451A)
  };
  color[] blue= {
    color(#1C2D81), color(#0D0D10), color(#0C1233)
  };  

  Fader(int px, int py, char c) {
    this.px=px;
    this.py=py;

    switch(c) {
    case 'R':
      col=red;
      break;
    case 'G':
      col=green;
      break;
    case 'B':
      col=blue;
      break;
    }
    setValue(0);
  }

  void draw() {
    strokeWeight(4);
    strokeJoin(ROUND);
    stroke(col[0]);
    fill(col[1]);
    rect(px, py, w, h);
    fill(col[2]);
    rect(px, py+(h-valMap), w, valMap);

    if (mousePressed && (mouseX>=px && mouseX< =px+w) && (mouseY>=py && mouseY< =py+h)) {
      setValue((int)map((h-(mouseY-py)), 0, h, 0, 255));
    }
  }

  void setValue(int val) {
    this.val=val;
    valMap=int(map(val, 0, 255, 0, h));
  }

  int getValue() {
    return val;
  }
}

After we create our custom template, for this we will use vectors with the addresses of each of our controls, these addresses are url type, we define this addresses in our template with the editor. The class of our template is as follows:

class RGBLayout {

  //Define the addresses
  //We defined it before in touchOSC Editor
  //Addresses are url type     /Page/Address
  String[] Addr= {
    "/RGB/fdrRed",
    "/RGB/fdrGreen",
    "/RGB/fdrBlue",
  };

  //create a vector to store recieved data
  //creates as many variables as addresses have our templete
  float[] Data= new float[Addr.length];

  //by default touchOSC use the "f" typetag  as identifier
  String Typetag="f";

  //this method check if the received data must be processed
  void check(OscMessage theOscMessage) {

    //for each address in our template
    for (int i = 0; i < Addr.length; i++) {
      //Check if the data sent matches an address
      if (theOscMessage.checkAddrPattern(Addr[i])==true) {
        //check if identifier matches
        if (theOscMessage.checkTypetag(Typetag)) {
          //Save the value in this address in variable Data
          Data[i] = theOscMessage.get(0).floatValue();
          //prints address and its new value
          println(Addr[i]+" = "+ Data[i]);
        }
      }
    }
    //if it doesn't match, ignore data
  }

  //prints data stored
  void printData() {
    println(Data);
  }

  //prints addresses url
  void printAddr() {
    println(Addr);
  }
}

And finally our main program, this must import the libraries netP5 and oscP5 to work properly, create objects of classes defined before and verify the received data for later send them to the Arduino trought the serial port, our main program is as follows:

//import nedded libraries
import oscP5.*;
import netP5.*;
import processing.serial.*; 

OscP5 oscP5;
Serial serial;
RGBLayout layout;

//create 3 fader objects
Fader fdrRed;
Fader fdrGreen;
Fader fdrBlue;

//variables for each color
int r, g, b;
//PImage logo;

void setup() {
  size(600, 320);
  smooth();

  //create OSC object to open the 8000 port
  oscP5 = new OscP5(this, 8000);
  //create our custom template
  layout= new RGBLayout();
  //try to open serial port
  try {
    serial = new Serial(this, Serial.list()[0], 9600);
  }
  //in case of exception produced
  catch(Exception e) {
    println("Can't open port...");
  }
  //print addresses name and its position in vector
  layout.printAddr();

  //create the faders
  fdrRed=new Fader(10, 10, 'R');//px, py, color
  fdrGreen=new Fader(90, 10, 'G');
  fdrBlue=new Fader(170, 10, 'B');

  //load watermark
  //logo=loadImage("watermark.png");
}

void draw() {
  //draw the faders
  fdrRed.draw();
  fdrGreen.draw();
  fdrBlue.draw();

  //save each fader value using get
  r=fdrRed.getValue();
  g=fdrGreen.getValue();
  b=fdrBlue.getValue();

  //try to write serial port
  try {
    //command for red color and its value
    serial.write(114);
    serial.write(r);
    //command for green color and its value
    serial.write(103);
    serial.write(g);
    //command for blue color and its value
    serial.write(98);
    serial.write(b);
  }
  //n case of error, handle the exceptio
  catch(Exception e) {
    println("Can't write serial port...");
  }

  //draw a rect with the mixed colors
  stroke(0);
  fill(color(r, g, b));
  rect(270, 10, 300, 300);

  //image(logo, 450, 240);
}

//This event happens every time we receive data over OSC
//theOSCMessage contains all data received
void oscEvent(OscMessage theOscMessage) {
  //check if data matches with our template
  layout.check(theOscMessage);

  //faders take the value received
  fdrRed.setValue((int) layout.Data[0]);
  fdrGreen.setValue((int)layout.Data[1]);
  fdrBlue.setValue((int) layout.Data[2]);
}

Now arduino board must process the data received, for it will create an algorithm that receives a byte and determine whether it is a command, after waiting for another command determines the value stored in the corresponding variable to vary the intensity the LED will use the arduino PWM pins using the analogOut() function.

//incoming data
int inByte = 0;
//leds pins
int led[]={
  6,5,3};
//current led to modify
int  currLed;
//data received flag
boolean commandFlag=0;
//command indicator
const int ledCom=13;  

void setup()
{
  //Red led output
  pinMode(led[0], OUTPUT);
  //Green led output
  pinMode(led[1], OUTPUT);
  //Blue led output
  pinMode(led[2], OUTPUT);
  //command indicator output
  pinMode(ledCom, OUTPUT); 

  //Initializes serial communication at 9600bps
  Serial.begin(9600);
  Serial.print("Connected...");
}

void loop()
{
  //if data is available in port buffer
  if (Serial.available() > 0) {
    //read incoming byte
    inByte = Serial.read();

    //if the command expects a value
    if (commandFlag){
      //modify current led intensity
      analogWrite(led[currLed],inByte);
      //reset the flag and led indicator
      commandFlag=false;
      digitalWrite(ledCom, LOW);
    }
    //if expects a command
    else
    {
      //select led to modify
      //then make the command flag true
      switch (inByte){
      case 114://r ascii
        currLed=0;
        digitalWrite(ledCom, HIGH);
        commandFlag=1;
        break;
      case 103://g ascii
        currLed=1;
        digitalWrite(ledCom, HIGH);
        commandFlag=1;
        break;
      case 98://b ascii
        currLed=2;
        digitalWrite(ledCom, HIGH);
        commandFlag=1;
        break;
      }
    }
  }
}

Post your comments and suggestions.

Para el siguiente acto necesitaremos: processing, arduino, led RGB, dispositivo con touchOSC instalado. Pero que haremos exactamente??… Crearemos una plantilla personalizada con el touchOSC editor, la cual usaremos como control para variar la intensidad de un led RGB y poder crear combinaciones de colores, abriremos un enlace de comunicación entre processing y touchOSC, por ultimo mandaremos toda la informacion recibida a una placa arduino conectada por el puerto serie y veremos el resultado obtenido en el led RGB, al final de todo esto tendremos el siguiente resultado:

Pues comencemos, lo primero que debemos hacer es crear nuestra plantilla para el touchOSC y cargarla al dispositivo, para esto usaremos el touchOSC Editor una herramienta creada por Hexler que podemos descargar de aquí, usaremos tres controles tipo fader con resolucion de un byte (0-255) para variar la intensidad del led, para ello seguimos los siguientes pasos del videotutorial:

Ahora toca abrir processing, pero antes de empezar a tirar lineas de codigo debemos instalar una libreria especifica para el la comunicacion con OSC, usaremos la libreria oscP5 creada por Andreas Schlegel y podemos descargarla aqui, la descomprimos y movemos su contenido a documentos/processing/libraries, una vez instalada ahora si abrimos un nuevo sketch.

Crearemos una clase Fader que usaremos como control y para visualizar la interaccion con el dispositivo movil, este control sera lo mas parecido al fader y con las mismas propiedades que usamos en nuestra plantilla, la clase final para el Fader queda de la siguiente manera:

class Fader {

  int val, valMap;
  int px, py;
  final int h=300, w=70;
  color[] col;

  color[] red= {
    color(#DE1D2A), color(#131010), color(#501515)
  };
  color[] green= {
    color(#3B811C), color(#111410), color(#25451A)
  };
  color[] blue= {
    color(#1C2D81), color(#0D0D10), color(#0C1233)
  };  

  Fader(int px, int py, char c) {
    this.px=px;
    this.py=py;

    switch(c) {
    case 'R':
      col=red;
      break;
    case 'G':
      col=green;
      break;
    case 'B':
      col=blue;
      break;
    }
    setValue(0);
  }

  void draw() {
    strokeWeight(4);
    strokeJoin(ROUND);
    stroke(col[0]);
    fill(col[1]);
    rect(px, py, w, h);
    fill(col[2]);
    rect(px, py+(h-valMap), w, valMap);

    if (mousePressed && (mouseX>=px && mouseX< =px+w) && (mouseY>=py && mouseY< =py+h)) {
      setValue((int)map((h-(mouseY-py)), 0, h, 0, 255));
    }
  }

  void setValue(int val) {
    this.val=val;
    valMap=int(map(val, 0, 255, 0, h));
  }

  int getValue() {
    return val;
  }
}

Despues crearemos nuestra plantilla personalizada, para esto haremos uso de vectores con las direcciones de cada uno de nuestros controles, estas direcciones son del url y las definimos cuando creamos nuestra plantilla con el editor. La clase de nuestra plantilla queda asi:

class RGBLayout {

  //Creamos nuestras direcciones para recibir datos
  //Estos nombres los pusimos al crear la plantilla
  //en el touchOSC editor     /Pagina/Direccion
  String[] Addr= {
    "/RGB/fdrRed",
    "/RGB/fdrGreen",
    "/RGB/fdrBlue",
  };

  //Creamos un vector para guardar los datos recibidos
  //crea tantas variables como direcciones tenga nuestra plantilla
  float[] Data= new float[Addr.length];

  //Por default touOSC usa el typetag "f" como identificador
  String Typetag="f";

  //Con este metodo comprobaremos si la informacion debe ser procesada
  void check(OscMessage theOscMessage) {

    //Para cada direccion en nuestra plantilla
    for (int i = 0; i < Addr.length; i++) {
      //Verfica si la informacion enviada coincide con alguna direccion
      if (theOscMessage.checkAddrPattern(Addr[i])==true) {
        //Comprueba que coincida el idenificador
        if (theOscMessage.checkTypetag(Typetag)) {
          //Guardamos el valor de la direccion en el vector Data
          Data[i] = theOscMessage.get(0).floatValue();
          //Imprime la direccion y el nuevo valor que tomo
          println(Addr[i]+" = "+ Data[i]);
        }
      }
    }
    //En caso de que no coincida ninguna direccion, se ignora la info
  }

  //imprime la informacion de todas nuestras variables
  void printData() {
    println(Data);
  }

  //imprime el nombre de nuestros objetos
  void printAddr() {
    println(Addr);
  }
}

Y por ultimo nuestro programa principal, en este debemos importar las librerias oscP5 y netP5 para que funcione correctamente, crearemos objetos de las clases definidas anteriormemte y verificaremos los datos recibidos para posterioremente mandarlas al arduino por el puerto serie, y nuestro programa principal queda asi:

//importamos librerias necesarias
import oscP5.*;
import netP5.*;
import processing.serial.*; 

OscP5 oscP5;
Serial serial;
RGBLayout layout;

//Creamos tres objetos Fader, uno por color
Fader fdrRed;
Fader fdrGreen;
Fader fdrBlue;

//variables para la intensidad de color
int r, g, b;
//PImage logo;

void setup() {
  size(600, 320);
  smooth();

  //creamos el objeto OSC en el puerto 8000
  oscP5 = new OscP5(this, 8000);
  //creamos la plantilla de touchOSC a usar
  layout= new RGBLayout();
  //intentamos abrir el puerto serial
  try {
    serial = new Serial(this, Serial.list()[0], 9600);
  }
  //en caso de error tendremos una excepcion
  catch(Exception e) {
    println("Error al abrir puerto serial...");
  }
  //muestra el direccionamiento de la plantilla
  layout.printAddr();

  //creamos los faders
  fdrRed=new Fader(10, 10, 'R');//px, py, color
  fdrGreen=new Fader(90, 10, 'G');
  fdrBlue=new Fader(170, 10, 'B');

  //cargamos la marca de agua
  //logo=loadImage("watermark.png");
}

void draw() {
  //Dibujamos los faders
  fdrRed.draw();
  fdrGreen.draw();
  fdrBlue.draw();

  //Guardamos el valor del fader en la variable
  r=fdrRed.getValue();
  g=fdrGreen.getValue();
  b=fdrBlue.getValue();

  //intentamos escribir el PS
  try {
    //comando para color r y su valor
    serial.write(114);
    serial.write(r);
    //comando para color g y su valor
    serial.write(103);
    serial.write(g);
    //comando para color b y su valor
    serial.write(98);
    serial.write(b);
  }
  //en caso de error tendremos una excepcion
  catch(Exception e) {
    println("Error con el puerto serial, no se puede escribir...");
  }

  //Dibujamos cuadro con colores mezclados
  stroke(0);
  fill(color(r, g, b));
  rect(270, 10, 300, 300);

  //image(logo, 450, 240);
}

//Este evento ocurre cada vez que llega informacion desde OCS
//theOSCMessage lleva toda la informacion recibida
void oscEvent(OscMessage theOscMessage) {
  //verificamos si coincide la informacion con nuestra plantilla
  layout.check(theOscMessage);

  //los faders toman el valor enviado
  fdrRed.setValue((int) layout.Data[0]);
  fdrGreen.setValue((int)layout.Data[1]);
  fdrBlue.setValue((int) layout.Data[2]);
}

Ahora si para finalizar necesitamos que la placa arduino procese los datos recibidos, para ello crearemos un algoritmo que reciba un byte y determine si es un comando, una vez que determina el comando espera otro valor para almacenarlo en la variable correspondiente, para variar la intensidad del led usaremos los pines de PWM de arduino usando la funcion analogOut().

//dato recibido
int inByte = 0;
//Pines de los leds
int led[]={
  6,5,3};
//led a modificar
int  currLed;
//bandera de valor recibido
boolean commandFlag=0;
//led de espera de valor
const int ledCom=13;  

void setup()
{
  //salida led R
  pinMode(led[0], OUTPUT);
  //salida led G
  pinMode(led[1], OUTPUT);
  //salida led B
  pinMode(led[2], OUTPUT);
  //salida led comando
  pinMode(ledCom, OUTPUT); 

  //Inicializa comunicacion serial a 9600bps
  Serial.begin(9600);
  Serial.print("Conectado...");
}

void loop()
{
  //si hay datos en el bufer del puerto
  if (Serial.available() > 0) {
    //leemos valor recibido
    inByte = Serial.read();

    //si un comando espera valor
    if (commandFlag){
      //modificamos la intensidad del led seleccionado
      analogWrite(led[currLed],inByte);
      //reiniciamos bandera y led de comando
      commandFlag=false;
      digitalWrite(ledCom, LOW);
    }
    //Si esparamos un comando
    else
    {
      //Elegimos que led modificar
      //modificamos bandera y led de comando
      switch (inByte){
      case 114://r ascii
        currLed=0;
        digitalWrite(ledCom, HIGH);
        commandFlag=1;
        break;
      case 103://g ascii
        currLed=1;
        digitalWrite(ledCom, HIGH);
        commandFlag=1;
        break;
      case 98://b ascii
        currLed=2;
        digitalWrite(ledCom, HIGH);
        commandFlag=1;
        break;
      }
    }
  }
}

Fue un post un poco largo, espero que no se hayan aburrido. No olvides dejar tus comentarios al final de la pagina

En el tutorial anterior describimos brevemente cual era la función de las entradas/salidas digitales, en este tutorial nos adentraremos en detalle de su funcionamiento y lo aplicaremos con un pequeño circuito, en el cual prenderemos leds dependiendo del estado de los pulsadores, para este circuito es necesario el siguiente material:

• Arduino
• Protoboard
• 3 pulsadores (pushButton)
• 3 leds (en mi caso usare un led RGB)
• 3 resistencias 220 ohm
• 3 resistencias 10 Kohm
• cable

Comúnmente cuando se desea leer un pulsador desde una entrada digital se coloca una resistencia pull-up o pull-down, esto es para mantener siempre un estado lógico ya sea alto o bajo, con una resistencia pull-up en la entrada de Arduino siempre tendremos un estado lógico alto, en cambio con una pull-down tendremos un valor bajo. En caso de no utilizar estas resistencias y la entrada no esta conectada a algo el valor de entrada puede ser aleatorio teniendo un HIGH o LOW. La configuración de estas resistencias es la siguiente:

Recuerda que los pines digitales son los que se encuentran marcados en la placa con los números del 0 al 13, ademas los pines analógicos pueden ser usados como pines digitales usando los números 14 (entrada analógica número 0) hasta 19 (entrada analógica número 5).

En cuanto a la programación veremos 3 funciones clave para el manejo de los pines digitales:

pinMode(int pin,modo): Nos permite configurar un pin digital en modo entrada o salida, recibe 2 parámetros, el primero es el numero del pin a configurar y el segundo es el modo que queremos, los modos permitidos son INPUT (entrada) y OUTPUT (salida).

digitalRead(int pin):  Lee el valor de una entrada digital, la función regresa HIGH cuando en la entrada tenemos un estado lógico alto y LOW cuando tenemos un valor bajo, podemos usar el valor regresado para guardarlo en una variable o usarlo directamente en una condición. El único parámetro de entrada es el pin a leer.

digitalWrite(int pin, valor): Escribe en un pin de salida, si el valor es HIGH tendremos a la salida de ese pin un estado lógico alto (5V), si el valor es LOW tendremos a la salida un estado lógico bajo (0V). Sus parámetros son el numero de pin a modificar y el valor que tomara.

Para este caso usaremos resistencia de pull down, para que al presionar el boton tengamos un nivel alto a la entrada. Tenemos el diseño del circuito propuesto hecho en fritzing, el codigo fuente y un video con la desmotracion del ejemplo.

//Pines donde se conectan los botones
const int boton1 =13 ;
const int boton2 =12 ;
const int boton3 =11 ;

//Pines donde se conectan los leds
const int led1 = 5;
const int led2 = 4;
const int led3 = 3; 

void setup() {
  //Inicializamos los pines de leds como salidas
  pinMode(led1, OUTPUT);
  pinMode(led2, OUTPUT);
  pinMode(led3, OUTPUT);  

  //Inicializamos los pines de botones como entradas
  pinMode(boton1, INPUT);
  pinMode(boton2, INPUT);
  pinMode(boton3, INPUT); 

}

void loop(){
  //Comprobamos estado del boton1
  if (digitalRead(boton1)) {
    digitalWrite(led1, HIGH);
  }
  else {
    digitalWrite(led1, LOW);
  }

  //Comprobamos estado del boton2
  if (digitalRead(boton2)) {
    digitalWrite(led2, HIGH);
  }
  else {
    digitalWrite(led2, LOW);
  }

  //Comprobamos estado del boton3
  if (digitalRead(boton3)) {
    digitalWrite(led3, HIGH);
  }
  else {
    digitalWrite(led3, LOW);
  }
}

Realmente es un ejemplo bastante basico, pero tiene el suficiente contenido para entender la funcion de estos pines digitales. En proximos tutoriales veremos algo un poco mas interactivo.

La realidad aumentada (RA) es el término que se usa para definir una visión directa o indirecta de un entorno físico del mundo real, cuyos elementos se combinan con elementos virtuales para la creación de una realidad mixta en tiempo real. Consiste en un conjunto de dispositivos que añaden información virtual a la información física ya existente, es decir, añadir una parte sintética virtual a lo real. Esta es la principal diferencia con la realidad virtual, puesto que no sustituye la realidad física, sino que sobreimprime los datos informáticos al mundo real.

Con la ayuda de la tecnología (por ejemplo, añadiendo la visión por computador y reconocimiento de objetos) la información sobre el mundo real alrededor del usuario se convierte en interactiva y digital. La información artificial sobre el medio ambiente y los objetos pueden ser almacenada y recuperada como una capa de información en la parte superior de la visión del mundo real.

Wikipedia

Desde el sitio de Creative Applications Network nos sorprenden con un excelente tutorial sobre realidad aumentada, usando processing y una librería llama NyArToolkit podemos aumentar nuestra realidad y añadir objetos 3D. Para esta aplicacion se utiliza la camara web y tags para identificar donde agregar los objetos virtuales.

Enlace | Tutorial AR con processing (Ingles)

Fue realizado para la campaña publicitaria “Todo puede volar” de Avios en el Reino Unido. Este es el comercial final:

Comenzaremos con el IDE, esta basado en processing de ahi su enorme parecido, el IDE cuenta con todas las herramientas necesarias para codificar, compilar y subir un programa al Arduino. Los archivos creados tienen la extensión .ino (Versiones anteriores del IDE usan .pde ) y son denominados sketchs. Ahora hagamos un reconocimiento de su interfaz.

En la parte superior (rectángulo blanco)tenemos 6 botones principales, describamos su funcionamiento de izquierda a derecha:

• Verify (Verificar): Verifica que el código introducido sea correcto y lo compila, en caso de error nos indica la linea donde ocurrió.
• Upload (Subir): Compila el programa y lo sube a la placa Arduino.
• New (Nuevo): Crea un nuevo sketch.
• Open (Abrir): Abrir un sketch existente, ya se que tu lo hayas creado o escojas alguno de los ejemplos que ya vienen precargados.
• Save (Salvar): Salva el sketch actual.
• Serial Monitor: Muestra una terminal serial, esta herramienta no será útil para comunicarnos con el Arduino, comúnmente se utiliza como consola de depuración.

Debajo de los botones tenemos el área de código (rectángulo rojo), en esta área es donde escribiremos nuestro programa, automáticamente colorea las palabras reservadas por el compilador.

En la parte inferior (rectángulo verde) tenemos la consola, ahi es donde se informara de errores y progreso en el proceso de compilación y programación de la placa; mas abajo del lado izquierdo nos indica el numero de linea donde se encuentra el cursor y del lado derecho nos indica la versión de placa conectada y el puerto serie a utilizar.

Ahora veamos las características generales de la placa en cuanto a sus pines, consta de entradas analógicas (rectángulo rosa) marcadas desde A0 hasta A5, entradas/salidas digitales (rectángulo cyan) están marcadas desde 0-13, 6 salidas PWM (rect cyan) estas están marcadas con el signo ~, pines de reset, GND (tierra), 5V, 3.3V (rect amarillo). Veamos el funcionamiento general de las entradas/salidas,  posteriormente veremos este tema con mas detalle:

• Entradas analógicas: Este tipo de entradas reciben una señal analógica en la entrada y el microcontrolador la convierte en  digital para su uso durante el programa.
• Entradas/salidas digitales: Pueden ser configuradas como entradas o como salidas, algunos de estos pines pueden usarse como salidas PWM y otros son usados por el modulo serial, por lo que se debe de reservar su uso. Estos pines manejan estados lógicos encendido o apagado, donde 0V a la entrada es un estado lógico bajo y 5V un estado alto.
• Salidas de PWM: Estos pines generan una señal PWM (Pulse Width Modulation, modulación por ancho de pulso), estas salidas generalmente se utilizan para el control de servos, control de velocidad de motores y control de luminosidad de leds.
• Comunicación serial: Arduino se puede comunicar con la computadora por medio de un puerto serie, para realizar esta conexión la placa tiene montado un convertidor FTDI USB-Serial (FT232), en los pines 1 y 2 podemos obtener las señales TX y RX de este modulo.

Es todo para este tutorial, en el siguiente articulo veremos los tipos de variables que podemos usar en nuestro programa y el uso de las entradas/salidas digitales. Para poder comprender los siguientes artículos es necesario que leas estos tutoriales acerca de ciclos y condicionales, que aunque no son de arduino, el entendimiento general de esos bloques de código serán de mucha ayuda.

Con esta actualización NAO adquiere un mayor nivel de interactividad con el usuario gracias a que se le ha incrementado el poder de computo. Las mejoras realizadas son las siguientes:

• Procesador intel Atom a 1.6GHz
• 2 cámaras HD controladas por FPGA
• Se mejoro el programa de reconocimiento  vocal (NUANCE)
• Mejoras en el algoritmo de caminar y colisiones con él mismo
• Nuevo sistema inteligente de control de torque

Sin duda seria mi regalo deseado para esta navidad