Archivo del Autor: admin

Clase BarraInfo para Processing

He creado una clase llamada BarraInfo para que podais añadir a vuestros proyectos de Processing. La clase sirve para crear barras de información, como las que habeis visto en la telemetría para mostrar el PWM de los motores o el nivel de la batería.

La ventaja de usar esta clase (y cualquier otra) es que os evitais tener que crear el código de cero porque ya está hecho, podeis usarla en todos los proyectos de Processing que hagais, podeis tener varias barras de información en la pantalla y se puede configurar a medida.

A continuación os pongo el código fuente de la clase:

class BarraInfo
{
  float inicio; // primer valor del rango
  float fin; // último valor del rango
  color linea; // color del texto de los valores de referencia y las muescas
  color barra; // color de la barra
  int x; // posición x del conjunto
  int y; // posición y del conjunto
  int anchura; // anchura de las muescas y de la barra
  int altura; // altura del conjunto
  int pasoLinea; // cada cuantos píxeles se dibuja una muesca
  int pasoNumero; // cada cuantos píxeles se dibuja un valor de referencia del rango
  PFont fuente; // fuente con la que se dibuja el texto de los valores de referencia
  int recorteX; // ajuste de la posición X del texto de los valores de referencia
  int recorteY; // ajuste de la posición Y del texto de los valores de referencia
  int digitos; // Número de digitos que aparecerán en el texto de los valores de referencia
  int decimales; // Número de decimales que aparecerán en el texto de los valores de referencia
  float valor; // Valor real

  BarraInfo()
  {
    valor = 0;
  }

  void dibuja()
  {
    int indice;
    int longitud;

    stroke(linea);
    fill(linea);
    text(nfs(map(y, y, y + altura, fin, inicio), digitos, decimales), x - recorteX, y + recorteY - pasoLinea);
    text(nfs(map(y + altura, y, y + altura, fin, inicio), digitos, decimales), x - recorteX, y + altura + recorteY - pasoLinea);
    for(indice = y; indice &lt;= y + altura; indice++)
    {
      if(indice % pasoLinea == 0)
      {
        line(x, indice, x + anchura, indice);
      }

      if(indice % pasoNumero == 0)
      {
        text(nfs(map(indice, y, y + altura, fin, inicio), digitos, decimales), x - recorteX, indice + recorteY - pasoLinea);
      }
    }
    stroke(barra);
    fill(barra);
    longitud = int(map(valor, inicio, fin, 0, altura));
    rect(x + anchura * 2, y + altura - longitud, anchura, longitud);
  }
}

class BarraInfo

{

float inicio; // primer valor del rango

float fin; // último valor del rango

color linea; // color del texto de los valores de referencia y las muescas

color barra; // color de la barra

int x; // posición x del conjunto

int y; // posición y del conjunto

int anchura; // anchura de las muescas y de la barra

int altura; // altura del conjunto

int pasoLinea; // cada cuantos píxeles se dibuja una muesca

int pasoNumero; // cada cuantos píxeles se dibuja un valor de referencia del rango

PFont fuente; // fuente con la que se dibuja el texto de los valores de referencia

int recorteX; // ajuste de la posición X del texto de los valores de referencia

int recorteY; // ajuste de la posición Y del texto de los valores de referencia

int digitos; // Número de digitos que aparecerán en el texto de los valores de referencia

int decimales; // Número de decimales que aparecerán en el texto de los valores de referencia

float valor; // Valor real

BarraInfo()

{

valor = 0;

}

void dibuja()

{

int indice;

int longitud;

stroke(linea);

fill(linea);

text(nfs(map(y, y, y + altura, fin, inicio), digitos, decimales), x - recorteX, y + recorteY - pasoLinea);

text(nfs(map(y + altura, y, y + altura, fin, inicio), digitos, decimales), x - recorteX, y + altura + recorteY - pasoLinea);

for(indice = y; indice <= y + altura; indice++)

{

if(indice % pasoLinea == 0)

{

line(x, indice, x + anchura, indice);

}

if(indice % pasoNumero == 0)

{

text(nfs(map(indice, y, y + altura, fin, inicio), digitos, decimales), x - recorteX, indice + recorteY - pasoLinea);

}

stroke(barra);

fill(barra);

longitud = int(map(valor, inicio, fin, 0, altura));

rect(x + anchura * 2, y + altura - longitud, anchura, longitud);

}

Para usarla os voy a poner un ejemplo de cómo mostrar el PWM asignado a un motor.

Lo primero es copiar el código fuente que he puesto más arriba en vuestro proyecto, preferentemente al final.

Lo segundo es crear una variable global del tipo BarraInfo.

BarraInfo pwm;

1	BarraInfo pwm;

Lo tercero es instanciar la clase para crear un objeto en el método setup de vuestro sketch.

pwm = new BarraInfo();

1	pwm = new BarraInfo();

Después, y dentro del mismo método setup inicializamos las variables de la clase. Dado que las variables de las clases de Processing son públicas y no se admiten variables de tipo privado, he preferido acceder a ellas directamente sin métodos get/set:

Establecemos el valor de inicio y final que podrá tener la barra, en el PWM es de 0 a 255, en una batería Lipo sería de 0 a 8,4.

pwm.inicio = 0;
pwm.fin = 255;

1 2	pwm.inicio = 0; pwm.fin = 255;

Establecemos el color de las lineas (que comprende las muescas y el texto asociado a ellas) y el color de la barra.

pwm.linea = color(0, 255, 255);
pwm.barra = color(0, 0, 255);

1 2	pwm.linea = color(0, 255, 255); pwm.barra = color(0, 0, 255);

Establecemos la posición x e y de nuestra ventana donde se mostrará la barra de información.

pwm.x = 300;
pwm.y = 100;

1 2	pwm.x = 300; pwm.y = 100;

Establecemos la anchura de las muescas y de la barra (cada una) y la altura del conjunto.

pwm.anchura = 10;
pwm.altura = 150;

1 2	pwm.anchura = 10; pwm.altura = 150;

Establecemos cada cuantos píxeles se dibuja una muesca y cada cuantos píxeles se muestra un número de referencia.

pwm.pasoLinea = 5;
pwm.pasoNumero = 25;

1 2	pwm.pasoLinea = 5; pwm.pasoNumero = 25;

Establecemos la fuente que previamente habremos creado en el menú Tools/Create Font… de Processing y la desplazamos en su eje x e y para que encaje bien en las muescas.

pwm.fuente = loadFont("ArialMT-12.vlw");
pwm.recorteX = 30;
pwm.recorteY = 10;

pwm.fuente = loadFont("ArialMT-12.vlw");

pwm.recorteX = 30;

pwm.recorteY = 10;

Establecemos el número mínimo de enteros que apareceran (rellenando con ceros por la izquierda si no llega) y el número de decimales (-1 si no queremos que salgan) de los números de referencia.

pwm.digitos = 3;
pwm.decimales = -1;

1 2	pwm.digitos = 3; pwm.decimales = -1;

Finalmente en el método draw se debe establecer el valor que debe tener la barra y pintarlo. He puesto un random para que pueda apreciar el movimiento.

pwm.valor = random(255);
pwm.dibuja();

1 2	pwm.valor = random(255); pwm.dibuja();

Así es como quedaría el código fuente:

BarraInfo pwm;

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

  pwm = new BarraInfo();
  pwm.inicio = 0;
  pwm.fin = 255;
  pwm.linea = color(0, 255, 255);
  pwm.barra = color(0, 0, 255);
  pwm.x = 300;
  pwm.y = 100;
  pwm.anchura = 10;
  pwm.altura = 150;
  pwm.pasoLinea = 5;
  pwm.pasoNumero = 25;
  pwm.fuente = loadFont("ArialMT-12.vlw");
  pwm.recorteX = 30;
  pwm.recorteY = 10;
  pwm.digitos = 3;
  pwm.decimales = -1;
}

void draw()
{
  background(0);
  pwm.valor = random(255);
  pwm.dibuja();
}

class BarraInfo
{
  float inicio; // primer valor del rango
  float fin; // último valor del rango
  color linea; // color del texto de los valores de referencia y las muescas
  color barra; // color de la barra
  int x; // posición x del conjunto
  int y; // posición y del conjunto
  int anchura; // anchura de las muescas y de la barra
  int altura; // altura del conjunto
  int pasoLinea; // cada cuantos píxeles se dibuja una muesca
  int pasoNumero; // cada cuantos píxeles se dibuja un valor de referencia del rango
  PFont fuente; // fuente con la que se dibuja el texto de los valores de referencia
  int recorteX; // ajuste de la posición X del texto de los valores de referencia
  int recorteY; // ajuste de la posición Y del texto de los valores de referencia
  int digitos; // Número de digitos que aparecerán en el texto de los valores de referencia
  int decimales; // Número de decimales que aparecerán en el texto de los valores de referencia
  float valor; // Valor real

  BarraInfo()
  {
    valor = 0;
  }

  void dibuja()
  {
    int indice;
    int longitud;

    stroke(linea);
    fill(linea);
    text(nfs(map(y, y, y + altura, fin, inicio), digitos, decimales), x - recorteX, y + recorteY - pasoLinea);
    text(nfs(map(y + altura, y, y + altura, fin, inicio), digitos, decimales), x - recorteX, y + altura + recorteY - pasoLinea);
    for(indice = y; indice &lt;= y + altura; indice++)
    {
      if(indice % pasoLinea == 0)
      {
        line(x, indice, x + anchura, indice);
      }

      if(indice % pasoNumero == 0)
      {
        text(nfs(map(indice, y, y + altura, fin, inicio), digitos, decimales), x - recorteX, indice + recorteY - pasoLinea);
      }
    }
    stroke(barra);
    fill(barra);
    longitud = int(map(valor, inicio, fin, 0, altura));
    rect(x + anchura * 2, y + altura - longitud, anchura, longitud);
  }
}

BarraInfo pwm;

void setup()

{

size(600, 600);

pwm = new BarraInfo();

pwm.inicio = 0;

pwm.fin = 255;

pwm.linea = color(0, 255, 255);

pwm.barra = color(0, 0, 255);

pwm.x = 300;

pwm.y = 100;

pwm.anchura = 10;

pwm.altura = 150;

pwm.pasoLinea = 5;

pwm.pasoNumero = 25;

pwm.fuente = loadFont("ArialMT-12.vlw");

pwm.recorteX = 30;

pwm.recorteY = 10;

pwm.digitos = 3;

pwm.decimales = -1;

}

void draw()

{

background(0);

pwm.valor = random(255);

pwm.dibuja();

}

class BarraInfo

{

float inicio; // primer valor del rango

float fin; // último valor del rango

color linea; // color del texto de los valores de referencia y las muescas

color barra; // color de la barra

int x; // posición x del conjunto

int y; // posición y del conjunto

int anchura; // anchura de las muescas y de la barra

int altura; // altura del conjunto

int pasoLinea; // cada cuantos píxeles se dibuja una muesca

int pasoNumero; // cada cuantos píxeles se dibuja un valor de referencia del rango

PFont fuente; // fuente con la que se dibuja el texto de los valores de referencia

int recorteX; // ajuste de la posición X del texto de los valores de referencia

int recorteY; // ajuste de la posición Y del texto de los valores de referencia

int digitos; // Número de digitos que aparecerán en el texto de los valores de referencia

int decimales; // Número de decimales que aparecerán en el texto de los valores de referencia

float valor; // Valor real

BarraInfo()

{

valor = 0;

}

void dibuja()

{

int indice;

int longitud;

stroke(linea);

fill(linea);

text(nfs(map(y, y, y + altura, fin, inicio), digitos, decimales), x - recorteX, y + recorteY - pasoLinea);

text(nfs(map(y + altura, y, y + altura, fin, inicio), digitos, decimales), x - recorteX, y + altura + recorteY - pasoLinea);

for(indice = y; indice <= y + altura; indice++)

{

if(indice % pasoLinea == 0)

{

line(x, indice, x + anchura, indice);

}

if(indice % pasoNumero == 0)

{

text(nfs(map(indice, y, y + altura, fin, inicio), digitos, decimales), x - recorteX, indice + recorteY - pasoLinea);

}

stroke(barra);

fill(barra);

longitud = int(map(valor, inicio, fin, 0, altura));

rect(x + anchura * 2, y + altura - longitud, anchura, longitud);

}

Y así el resultado:

Manifiesto por una Red Neutral

Deja un comentario

Los ciudadanos y las empresas usuarias de Internet adheridas a este texto manifestamos:

Que Internet es una Red Neutral por diseño, desde su creación hasta su actual implementación, en la que la información fluye de manera libre, sin discriminación alguna en función de origen, destino, protocolo o contenido.
Que las empresas, emprendedores y usuarios de Internet han podido crear servicios y productos en esa Red Neutral sin necesidad de autorizaciones ni acuerdos previos, dando lugar a una barrera de entrada prácticamente inexistente que ha permitido la explosión creativa, de innovación y de servicios que define el estado de la red actual.
Que todos los usuarios, emprendedores y empresas de Internet han podido definir y ofrecer sus servicios en condiciones de igualdad llevando el concepto de la libre competencia hasta extremos nunca antes conocidos.
Que Internet es el vehículo de libre expresión, libre información y desarrollo social más importante con el que cuentan ciudadanos y empresas. Su naturaleza no debe ser puesta en riesgo bajo ningún concepto.
Que para posibilitar esa Red Neutral las operadoras deben transportar paquetes de datos de manera neutral sin erigirse en «aduaneros» del tráfico y sin favorecer o perjudicar a unos contenidos por encima de otros.
Que la gestión del tráfico en situaciones puntuales y excepcionales de saturación de las redes debe acometerse de forma transparente, de acuerdo a criterios homogéneos de interés público y no discriminatorios ni comerciales.
Que dicha restricción excepcional del tráfico por parte de las operadoras no puede convertirse en una alternativa sostenida a la inversión en redes.
Que dicha Red Neutral se ve amenazada por operadoras interesadas en llegar a acuerdos comerciales por los que se privilegie o degrade el contenido según su relación comercial con la operadora.
Que algunos operadores del mercado quieren “redefinir” la Red Neutral para manejarla de acuerdo con sus intereses, y esa pretensión debe ser evitada; la definición de las reglas fundamentales del funcionamiento de Internet debe basarse en el interés de quienes la usan, no de quienes la proveen.
Que la respuesta ante esta amenaza para la red no puede ser la inacción: no hacer nada equivale a permitir que intereses privados puedan de facto llevar a cabo prácticas que afectan a las libertades fundamentales de los ciudadanos y la capacidad de las empresas para competir en igualdad de condiciones.
Que es preciso y urgente instar al Gobierno a proteger de manera clara e inequívoca la Red Neutral, con el fin de proteger el valor de Internet de cara al desarrollo de una economía más productiva, moderna, eficiente y libre de injerencias e intromisiones indebidas. Para ello es preciso que cualquier moción que se apruebe vincule de manera indisoluble la definición de Red Neutral en el contenido de la futura ley que se promueve, y no condicione su aplicación a cuestiones que poco tienen que ver con ésta.

La Red Neutral es un concepto claro y definido en el ámbito académico, donde no suscita debate: los ciudadanos y las empresas tienen derecho a que el tráfico de datos recibido o generado no sea manipulado, tergiversado, impedido, desviado, priorizado o retrasado en función del tipo de contenido, del protocolo o aplicación utilizado, del origen o destino de la comunicación ni de cualquier otra consideración ajena a la de su propia voluntad. Ese tráfico se tratará como una comunicación privada y exclusivamente bajo mandato judicial podrá ser espiado, trazado, archivado o analizado en su contenido, como correspondencia privada que es en realidad.

Europa, y España en particular, se encuentran en medio de una crisis económica tan importante que obligará al cambio radical de su modelo productivo, y a un mejor aprovechamiento de la creatividad de sus ciudadanos. La Red Neutral es crucial a la hora de preservar un ecosistema que favorezca la competencia e innovación para la creación de los innumerables productos y servicios que quedan por inventar y descubrir. La capacidad de trabajar en red, de manera colaborativa, y en mercados conectados, afectará a todos los sectores y todas las empresas de nuestro país, lo que convierte a Internet en un factor clave actual y futuro en nuestro desarrollo económico y social, determinando en gran medida el nivel de competitividad del país. De ahí nuestra profunda preocupación por la preservación de la Red Neutral. Por eso instamos con urgencia al Gobierno español a ser proactivo en el contexto europeo y a legislar de manera clara e inequívoca en ese sentido.

(Si te sientes cómodo y representado por este texto, dale toda la difusión que puedas y quieras: reprodúcelo, enlázalo, tradúcelo, compártelo, vótalo… todas esas cosas que puedes hacer con total tranquilidad y libertad gracias, precisamente, al hecho de que tenemos todavía una red neutral. Hagamos posible el seguir teniéndola)

Clon de videocámara MD80

6 respuestas

Hace algún tiempo me compré un clon de la videocámara MD80. Esta cámara, que se puede comprar por unos 11 € ( http://www.dealextreme.com/details.dx/sku.32022 ) tiene una relación calidad/precio inmejorable. Graba imagenes a 720×480 pixeles / 30 fps en formato AVI con el codec Motion JPEG y sonido PCM en mono a 22050 hz. Los videos se almacenan en una tarjeta microSD (recomendable class 4 o incluso class 6) de hasta 16 GB. La batería es recargable por el puerto USB y dura para una grabación de 80 minutos. Puede grabar automáticamente cuando detecta un sonido por encima de los 60 db. Además puede funcionar como webcam. Trae consigo varios soportes para que se puedan colocar el distintos sitios. Es sensible a la luz y se ajusta automáticamente.

La verdad es que es muy completa y la gente la suele usar mucho cuando quiere salir al campo en bicicleta y grabar un vídeo. Su tamaño tan reducido y su peso de 20 gramos hace que sea ideal para colocarla en cualquier sitio.

No todo son maravillas, por ejemplo la cámara no tiene estabilizador, por lo que se notarán los movimientos abruptos. También la grabación no es del todo fluida, pero eso ya depende de las condiciones de luz. Importante lo de la clase de la memoria microSD, ya que si no es lo suficientemente rápida veremos saltos en los videos. Por otro lado muestra la fecha y la hora en la grabación, pero esto tiene arreglo.

Finalmente dejo un video que he grabado por el centro de Madrid y en el parking de un conocido centro comercial:

Processing y el puerto serie

9 respuestas

Processing es un software de programación de representaciónes gráficas y animaciones. Está basado en java y debido a ello es multiplataforma. Es software libre y tiene una comunidad muy extensa de desarrolladores y de usuarios.

El objetivo de este artículo es tratar de dar una idea de cómo hacer que Processing pueda interactuar con un puerto serie: cómo recibir y enviar datos, cómo mostrarlos en un gráfico y/o guardarlos en un fichero.

Como Processing puede usar librerías al estilo de java, hay una que necesitaremos para la programación del puerto serie, esta es processing.serial y se puede importar desde un sketch de la siguiente manera:

import processing.serial.*;

1	import processing.serial.*;

A continuación se debe crear una variable global del tipo Serial (o varias si vamos a tratar con más de un puerto serie).

Serial puerto;

1	Serial puerto;

Después hay que instanciarlo en el método Setup.

puerto = new Serial(this, Serial.list()[0], 115200);

1	puerto = new Serial(this, Serial.list()[0], 115200);

Lo que estamos haciendo es crear un objeto Serial. El constructor de la clase Serial tiene varias sobrecargas:

Serial(padre)
Serial(padre, velocidad)
Serial(padre, puerto)
Serial(padre, puerto, velocidad)
Serial(padre, puerto, velocidad, paridad, palabra, parada)

Los parámetros son:

padre: Se suele usar this siempre.
velocidad: La velocidad en b.p.s. a la que se quiere enviar y recibir datos: 9600 es la que toma por defecto si no se le indica otra cosa.
puerto: Nombre del puerto de comunicaciones. «COM1» es el que toma por defecto, pero puede ser otro de windows. En linux o mac suele ser /dev/tty*
paridad: ‘N’ para ninguna, ‘E’ para paridad par, ‘O’ para paridad impar. ‘N’ es la que se toma por defecto.
palabra: Número de bits que conforman una unidad de datos. 8 es el que se toma por defecto.
parada: Número de bits de parada (stop). Puede ser 1.0, 1.5, or 2.0, siempre en formato float. 1.0 es el que se toma por defecto.

Si no sabemos a priori qué puertos serie tenemos en nuestro ordenador, podemos imprimir un listado de los disponibles.

println(Serial.list());

1	println(Serial.list());

Como se trata simplemente de un array de cadenas, podemos acceder al valor de cualquier de ellas y pasárselo como argumento al constructor de Serial, tal y como he expuesto lineas atrás en la creación del objeto.

A partir de aquí, y si el puerto se ha podido abrir sin problemas, podemos enviar y recibir los datos.

Para enviar datos desde Processing al puerto serie hay que usar el método write del objeto que hayamos creado.

puerto.write(11);
puerto.write("hola");
puerto.write('e');

puerto.write(11);

puerto.write("hola");

puerto.write('e');

Se puede enviar tipos byte, char, int, array de bytes o cadenas.

Para recibir los datos tenemos dos posibilidades.

1) Comprobar dentro del método Draw si hay datos disponibles para su lectura, leerlos y procesarlos:

while (puerto.available() &gt; 0)
{
 dato = puerto.read();
}

while (puerto.available() > 0)

{

dato = puerto.read();

}

El método available nos devuelve el número de bytes que hay pendientes por leer en el buffer. El método read nos devuelve un valor de 0 a 255 del primer byte de la cola FIFO del buffer, o -1 si no hay dato disponible. Además de read hay otros métodos para recuperar los datos: readChar, readBytes, readBytesUntil, readString, readStringUntil.

2) Definir en el método Setup cuantos bytes queremos leer cada vez, esperar a que se active el evento serialEvent, y dentro de este leer los bytes.

En Setup:

puerto.buffer(2);

1	puerto.buffer(2);

En el cuerpo principal del sketch:

void serialEvent(Serial puerto_serie)
{
 valor1 = puerto_serie.read();
 valor2 = puerto_serie.read();
}

void serialEvent(Serial puerto_serie)

{

valor1 = puerto_serie.read();

valor2 = puerto_serie.read();

}

Esta técnica es mucho más optima que la primera. El rendimiento del método Draw para leer los datos del puerto serie y dibujarlos será menor que si el método Draw sólo se centra en leer las variables y dibujar en consecuencia, dejando al evento serialEvent que se encargue de poblar las variables con los datos recibidos por el puerto serie. Para que funcione esta técnica, se debe informar al objeto Serial de cuantos bytes se deben leer antes de que se dispare el evento serialEvent, esto se hace usando el método buffer indicando los bytes a leer. Dentro del evento serialEvent se deben leer tantos bytes como se especificaron con el método buffer. Si se está trabajando con más de un puerto serie se puede usar el único parámetro del evento serialEvent para distinguir desde qué puerto serie se han recibido los bytes.

if(puerto_serie == puerto)

1	if(puerto_serie == puerto)

Si se desea escribir los datos que se reciben a un fichero se debe crear una variable global del tipo PrintWriter.

PrintWriter fichero;

1	PrintWriter fichero;

Luego en el método Setup debemos crear el objeto PrintWriter indicando en qué fichero guardar los datos.

fichero = createWriter("positions.txt");

1	fichero = createWriter("positions.txt");

Finalmente, ya sea dentro del método Draw o del evento serialEvent (recomendado) se escriben los datos al fichero:

fichero.print(valor1);
fichero.print(',');
fichero.println(valor2);
fichero.flush();

fichero.print(valor1);

fichero.print(',');

fichero.println(valor2);

fichero.flush();

Es importante ejecutar el método flush para garantizar que se están guardando los datos y no se quedan en buffers intermedios, ya que cuando cerremos la ejecución de nuestro sketch todo lo que no haya sido físicamente escrito al disco se pierde.

Interactuar remótamente con nuestros dispositivos con Bluetooth

3 respuestas

Muchas veces surge la necesidad de comunicarnos con nuestros proyectos de electrónica desde un PC. Lo más sencillo cuando nuestro dispositivo está cerca es conectarlo mediante el puerto serie del ordenador, sin embargo hoy en día tanto los PC de escritorio como los portátiles ya no traen puerto serie (a veces incluso no traen puerto paralelo). Existen soluciones como los conversores de puerto serie a usb, pero no funcionan muy bien cuando usamos únicamente las lineas TX, RX y GND.

Una solución pasa por usar un intermediario, por ejemplo un arduino que recibe los datos en serie de nuestro dispositivo y los reenvía en serie también por el puerto usb. Sin embargo esta solución es un tanto engorrosa y además cara si lo que se pretende es simplemente enviar y recibir datos desde nuestro dispositivo.

Hay una mejor opción, más estandar, relativamente barata, que nos permite quitarnos los cables de por medio por ser inalámbrica y que requiere poco hardware. Se trata del bluetooth. Hoy en día la mayoría de los portátiles, muchos PCs de escritorio (que si no lo tienen se puede conseguir con un dongle), las PDAs, los tablet, los móviles y un largo etcétera de aparatos disponen de un módulo bluetooth. Así nos quitamos de en medio una parte de la comunicación porque ya viene integrada en nuestro sistema. La otra parte debemos añadírsela a nuestro dispositivo.

Bluetooth permite crear una conexión serie inalámbrica mediante RFCOMM. Por lo tanto sólo necesitamos que nuestro dispositivo tenga un módulo bluetooth. Yo he usado con éxito el módulo bluetooth de sure electronics. Es un módulo barato, que funciona a 9600 bps, tiene 10 metros de alcance y es fácil de usar. Su datasheet es este.

El módulo es esclavo, por tanto nuestro pc se tendrá que conectar a el y no al revés. Normalmente la primera vez que se empareja pide como clave la secuencia 1234. Funciona a 3,3 V. aunque en el datasheet dice que puede funcionar a 4,2 V. (incluso hasta 5,6 V. aunque no lo recomiendan) y consume 10 mA. Esta es la configuración que he usado para comunicarme con el microcontrolador:

Como se puede ver es muy sencillo de implementar. La recepción del micro es directa ya que casi todos los micros funciona bien con señales de 3,3 V. La salida del micro tiene una resistencia de 10000 ohm. para reducir la corriente que llega al pin de recepción del módulo. Además de la alimentación y de las 4 masas que hay que conectar, el pin de reset se debe poner a nivel alto. Está diseñado para usarlo en una placa como componente SMD, pero yo lo he soldado con hilo de wrapping, placa de topos y pines macho para que pueda usarlo en cualquier sitio sin que ocupe mucho:

A partir de aquí, y una vez que esté enlazado con el pc, sólo hay que comunicarse con el dispositivo como si se tratase de un puerto serie.

Convertir un fichero wav comprimido con el codec G729A

2 respuestas

Recientemente me ha surgido la necesidad de convertir unos ficheros de audio que estaban en formato .WAV comprimido con el codec G729A a un formato .WAV reproducible en cualquier PC para hacer unas pruebas. Se trataba de poder escuchar ficheros .WAV que estaban comprimidos con ese codec, pero dada la dificultad de encontrar el codec gratuitamente para poder instalarlo en Windows he encontrado una alternativa que sirve igualmente.

En la página de Voice Age he encontrado una librería gratuita para windows con ejemplos y ejecutables de cómo extraer el audio comprimido con un codec G729A. Si se va a usar comercialmente se debe pedir una licencia a sipro que es quien tiene los derechos de licenciamiento.

El problema con los ejecutables de Voice Age es que convierte de formato G729A a formato RAW, pero ni el origen tiene los datos por sí sólo (están embebidos en un fichero .wav) ni en la conversión se pasa a un fichero .wav reproducible en windows.

Por ello he creado un programa de consola en Visual C++ 6.0 que hace uso de la librería .lib que ofrece VoiceAge para hacer esos dos pasos. La idea es leer unos datos del fichero wav y moverse hasta el byte 44 del fichero wav de origen, accediendo así a los datos de audio directamente; crear un fichero .wav de destino, introduciendo en este la cabecera de un fichero .wav con el tamaño de los datos de audio descomprimido e indicando que tiene formato PCM; finalmente leer los datos de audio comprimido, descomprimirlos con la librería y escribirlos en el fichero de destino.

Este es el código fuente del mismo:

#include "stdafx.h"
#include "va_g729.h"
#include <stdio.h>
#include <memory.h>

int main(int argc, char* argv[])
{
	FILE *entrada;
	FILE *salida;
	unsigned char	serial[L_FRAME_COMPRESSED];
	short			synth[L_FRAME];
	int				bfi;
	unsigned char cabecera[] = {0x52,0x49,0x46,0x46,0x00,0x00,0x00,0x00,0x57,0x41,0x56,0x45,0x66,0x6D,0x74,0x20,0x10,0x00,0x00,0x00,0x01,0x00,0x01,0x00,0x40,0x1F,0x00,0x00,0x80,0x3E,0x00,0x00,0x02,0x00,0x10,0x00,0x64,0x61,0x74,0x61,0x00,0x00,0x00,0x00};
	unsigned long longitud;
	unsigned long *puntero;

	puts("SISTEMAS O.R.P.\nConvertidor de WAVs G729A a PCM\n");

	// Se comprueban los parámetros
	if(argc != 3)
	{
		puts("Debe introducir el archivo wav de origen y el archivo wav de destino.");
		return 1;
	}

	// Se abre el fichero de origen
	entrada = fopen(argv[1], "rb");
	if(entrada == NULL)
	{
		puts("No se pudo abrir el fichero de origen");
		return 2;
	}

	// Se abre el fichero de destino
	salida = fopen(argv[2], "wb");
	if(salida == NULL)
	{
		puts("No se pudo abrir el fichero de destino");
		fclose(entrada);
		return 2;
	}

	// Se comprueba que el fichero origen es un .wav
	fread(serial, sizeof(char), 4, entrada);
	if(memcmp(serial, "RIFF", 4) != 0)
	{

		puts("El fichero de entrada no es un wav");
		fclose(entrada);
		fclose(salida);
		return 3;
	}

	// Se lee el tamaño de los datos de audio del fichero origen
	// y se calcula el tamaño de los datis de audio del fichero destino
	fread(&longitud, sizeof(unsigned long), 1, entrada);
	puntero = (unsigned long *)(cabecera + 4);
	*puntero = 36 + (longitud - 36) * L_FRAME / L_FRAME_COMPRESSED * 2;
	puntero = (unsigned long *)(cabecera + 40);
	*puntero = (longitud - 36) * L_FRAME / L_FRAME_COMPRESSED * 2;
	// Se escribe la cabecera wav al fichero de destino
	fwrite(cabecera, sizeof(char), sizeof(cabecera), salida);
	// Saltamos al byte 44 donde se encuentran los datos de audio comprimido
	fseek(entrada, 44, SEEK_SET);

	// Se inicializa el descompresor
	va_g729a_init_decoder();

	// Se lee un grupo de bytes comprimidos y se escriben descomprimidos
	while (fread(serial, sizeof(char), L_FRAME_COMPRESSED, entrada) == L_FRAME_COMPRESSED)
	{
		bfi = 0;
		va_g729a_decoder(serial, synth, bfi);
		fwrite(synth, sizeof(short), L_FRAME, salida);
	}

	fclose(entrada);
	fclose(salida);

	puts("Proceso terminado");

	return 0;
}

#include "stdafx.h"

#include "va_g729.h"

#include <stdio.h>

#include <memory.h>

int main(int argc, char* argv[])

{

FILE *entrada;

FILE *salida;

unsigned char serial[L_FRAME_COMPRESSED];

short synth[L_FRAME];

int bfi;

unsigned char cabecera[] = {0x52,0x49,0x46,0x46,0x00,0x00,0x00,0x00,0x57,0x41,0x56,0x45,0x66,0x6D,0x74,0x20,0x10,0x00,0x00,0x00,0x01,0x00,0x01,0x00,0x40,0x1F,0x00,0x00,0x80,0x3E,0x00,0x00,0x02,0x00,0x10,0x00,0x64,0x61,0x74,0x61,0x00,0x00,0x00,0x00};

unsigned long longitud;

unsigned long *puntero;

puts("SISTEMAS O.R.P.\nConvertidor de WAVs G729A a PCM\n");

// Se comprueban los parámetros

if(argc != 3)

{

puts("Debe introducir el archivo wav de origen y el archivo wav de destino.");

return 1;

}

// Se abre el fichero de origen

entrada = fopen(argv[1], "rb");

if(entrada == NULL)

{

puts("No se pudo abrir el fichero de origen");

return 2;

}

// Se abre el fichero de destino

salida = fopen(argv[2], "wb");

if(salida == NULL)

{

puts("No se pudo abrir el fichero de destino");

fclose(entrada);

return 2;

}

// Se comprueba que el fichero origen es un .wav

fread(serial, sizeof(char), 4, entrada);

if(memcmp(serial, "RIFF", 4) != 0)

{

puts("El fichero de entrada no es un wav");

fclose(entrada);

fclose(salida);

return 3;

}

// Se lee el tamaño de los datos de audio del fichero origen

// y se calcula el tamaño de los datis de audio del fichero destino

fread(&longitud, sizeof(unsigned long), 1, entrada);

puntero = (unsigned long *)(cabecera + 4);

*puntero = 36 + (longitud - 36) * L_FRAME / L_FRAME_COMPRESSED * 2;

puntero = (unsigned long *)(cabecera + 40);

*puntero = (longitud - 36) * L_FRAME / L_FRAME_COMPRESSED * 2;

// Se escribe la cabecera wav al fichero de destino

fwrite(cabecera, sizeof(char), sizeof(cabecera), salida);

// Saltamos al byte 44 donde se encuentran los datos de audio comprimido

fseek(entrada, 44, SEEK_SET);

// Se inicializa el descompresor

va_g729a_init_decoder();

// Se lee un grupo de bytes comprimidos y se escriben descomprimidos

while (fread(serial, sizeof(char), L_FRAME_COMPRESSED, entrada) == L_FRAME_COMPRESSED)

{

bfi = 0;

va_g729a_decoder(serial, synth, bfi);

fwrite(synth, sizeof(short), L_FRAME, salida);

}

fclose(entrada);

fclose(salida);

puts("Proceso terminado");

return 0;

}

Y aquí dejo el fichero ejecutable:

G729AtoPCM

El Bus Pirate

2 respuestas

Bueno, pues me ha llegado el bus pirate y es una maravilla.

Se trata de una placa open hardware que sirve para medir y/o interactuar de una forma simple con un montón de cosas. Se conecta por puerto usb a un ordenador y con una interfaz serie podemos enviar comandos al bus pirate. Esto es lo que puede hacer:

Tomar medidas de 0 a 6 voltios.
Medir frecuencias de 1 Hz a 40 MHz
Generar PWM de 1 kHz a 4 MHz
Interactuar con dispositivos UART, SPI, I2C, MIDI, teclado, LCD, JTAG, etc
Analizador lógico de 10 Hz a 1 MHz
Se pueden hacer scripts desde Perl, Python, etc.
Se puede reprogramar para ser un programador de AVR o de PIC

Mi primera prueba ha sido medir la temperatura de un LM35:

Que indica que en la habitación tengo 32 grados (calorcito hace, si :))

La verdad es que es muy cómodo y muy rápido para probar todos aquellos componenes que en otro caso tendríamos que desplegar un montón de componentes para obtener algún resultado.

Alarma con un pic 16f628, un transceptor ds275, sensor de movimiento y un modem antiguo

82 respuestas

Tenía un modem externo antiguo de 2400 b.p.s. que me regalaron y se me ocurrió la idea de usarlo para crear una alarma. Los bueno de los modems es que puedes interactuar con la línea telefónica para hacer llamadas.

La idea consiste en que un sensor de movimiento piroeléctrico de infrarrojos (PIR) detecte el movimiento de una persona en una sala, este informaría de la detección a un pic y este sería el encargado de llamar a un número de teléfono a través del modem.

El matería que he usado es:

Sensor de movimiento piroeléctrico de infrarrojos (PIR) de sure electronics DC-SS502 ( http://www.sureelectronics.net/goods.php?id=932 )
Microcontrolador PIC 16f628A ( http://www.microchip.com/wwwproducts/devices.aspx?ddocname=en010210 )
Transceptor ds275 ( http://www.maxim-ic.com/datasheet/index.mvp/id/2929 )
Una placa de topos, cable, un conector serie db9 macho y un modem externo

Para hacer el circuito lo más sencillo posible he usado un pic 16f628a dado que con él podemos ahorrarnos el poner un cristal de cuarzo externo, poder desactivar el pin MCLR y usar la USART que trae consigo (podría haber usado un pic 16f88 igualmente). También he usado el transceptor ds275 porque se puede comunicar con un puerto serie como el del modem sin añadirle ningún condensador como ocurre con el MAX232. Como no quería depender de una fuente de alimentación externa, he soldado unos cables al modem para obtener de este los 5 voltios necesarios para el pic y el transceptor y para la alimentación de 9 voltios del sensor PIR.

Este es el esquema del circuito:

El sensor PIR tiene una salida digital que va conectada al pin RB0 del pic, que se puede programar como interrupción, por lo que el pic puede permanecer en modo sleep hasta que recibe la interrupción del sensor y empezar a mandar los comandos AT para hacer la llamada de alarma. Como el PIC no puede por sí sólo interactuar con un puerto serie, el transceptor convierte las señales del PIC a señales RS232 para enviárselas al puerto serie del modem y viceversa. Una vez que se ha hecho la llamada y el modem detecta que se ha colgado la linea, devolverá un código numérico que el pic recibirá para volver a dejar el sistema en modo de detección.

Foto del conjunto:

Un video de demostración:

Lo que sucede en el video es lo siguiente: Se enciende el modem y el pic configura este para que no tenga eco los comandos, para que devuelva respuestas numéricas y que el altavoz esté desactivado, después de 15 segundos de espera para que el usuario pueda abandonar la habitación el pic se pone a esperar la detección de movimiento, cuando la detecta llama a un número de móvil prefijado para que el usuario reciba la alerta.

El código fuente del pic esta programado en CCS y es el siguiente:

main.h

#include <16F628A.h>

#FUSES NOWDT                    //No Watch Dog Timer
#FUSES INTRC                    //Internal RC Osc
#FUSES NOPUT                    //No Power Up Timer
#FUSES NOPROTECT                //Code not protected from reading
#FUSES NOBROWNOUT               //No brownout reset
#FUSES NOMCLR                   //Master Clear pin used for I/O
#FUSES NOLVP                    //No low voltage prgming, B3(PIC16) or B5(PIC18) used for I/O
#FUSES NOCPD                    //No EE protection

#use delay(clock=4000000)
#use fast_io(b)
#use rs232(baud=9600,parity=N,xmit=PIN_B2,rcv=PIN_B1,bits=8)

typedef enum {INICIO, DETECTA, ALARMA, LLAMADO} ESTADOS;

#include <16F628A.h>

#FUSES NOWDT //No Watch Dog Timer

#FUSES INTRC //Internal RC Osc

#FUSES NOPUT //No Power Up Timer

#FUSES NOPROTECT //Code not protected from reading

#FUSES NOBROWNOUT //No brownout reset

#FUSES NOMCLR //Master Clear pin used for I/O

#FUSES NOLVP //No low voltage prgming, B3(PIC16) or B5(PIC18) used for I/O

#FUSES NOCPD //No EE protection

#use delay(clock=4000000)

#use fast_io(b)

#use rs232(baud=9600,parity=N,xmit=PIN_B2,rcv=PIN_B1,bits=8)

typedef enum {INICIO, DETECTA, ALARMA, LLAMADO} ESTADOS;

main.c

#include "main.h"

ESTADOS estado;
volatile int8 dato;

// se ha detectado un movimiento y se pasa al estado de alarma
#INT_EXT
void movimiento()
{
   if(estado == DETECTA)
   {
      estado = ALARMA;
   }
}

// se ha detectado un carácter en la cola la USART
#INT_RDA
void lectura()
{
   int8 valor;
   if(kbhit())
   {
      valor = getc();
      if(valor != '\r')
      {
         dato = valor;
      }
   }
}

// función genérica que pasa al estado de detección borrando cualquier interrupción anterior y activándola 
void deteccion()
{
   estado = DETECTA;
   clear_interrupt(int_ext);
   enable_interrupts(int_ext);
}

void main()
{
   setup_timer_0(RTCC_INTERNAL|RTCC_DIV_1);
   setup_timer_1(T1_DISABLED);
   setup_timer_2(T2_DISABLED,0,1);
   setup_comparator(NC_NC_NC_NC);
   setup_vref(FALSE);
   setup_oscillator(OSC_4MHZ);
   // Ponemos a todos los pines del puerto B como entrada excepto el de salida de la USART 
   set_tris_b(0xFB);
   // Empezamos por el estado de inicio
   estado = INICIO;
   // La interrupción debe ser cuando pasa de nivel bajo a nivel alto
   ext_int_edge( L_TO_H );
   enable_interrupts(int_rda);
   enable_interrupts(global);

   // TODO: USER CODE!!
   
   for(;;)
   {
      switch(estado)
      {
         // En el estado de inicio inicializamos el modem para que no haga eco de los comandos, 
         // los valores de respuesta sean numéricos y apague el altavoz del modem, esperando
         // 15 segundos para dejar salir al usuario de la sala y pasamos al estado de detección
         case INICIO:
            delay_ms(2000);
            printf("ATE0V0M0\r");
            delay_ms(13000);
            deteccion();
            break;
         // En el estado de detección esperamos la interrupción en modo sleep para consumir menos
         case DETECTA:
            sleep();
            break;
         // Se desactiva la interrupción y marcamos el número de teléfono que queramos alertar
         case ALARMA:
            disable_interrupts(int_ext);
            dato = 'A';
            printf("ATDTXXXXXXXXX\r");
            estado = LLAMADO;
            break;
         // Esperamos a que termine la llamada para que vuelva al estado de detección
         case LLAMADO:
            if(dato != 'A')
            {
               deteccion();
            }
      }
   }

}

#include "main.h"

ESTADOS estado;

volatile int8 dato;

// se ha detectado un movimiento y se pasa al estado de alarma

#INT_EXT

void movimiento()

{

if(estado == DETECTA)

{

estado = ALARMA;

}

// se ha detectado un carácter en la cola la USART

#INT_RDA

void lectura()

{

int8 valor;

if(kbhit())

{

valor = getc();

if(valor != '\r')

{

dato = valor;

}

// función genérica que pasa al estado de detección borrando cualquier interrupción anterior y activándola

void deteccion()

{

estado = DETECTA;

clear_interrupt(int_ext);

enable_interrupts(int_ext);

}

void main()

{

setup_timer_0(RTCC_INTERNAL|RTCC_DIV_1);

setup_timer_1(T1_DISABLED);

setup_timer_2(T2_DISABLED,0,1);

setup_comparator(NC_NC_NC_NC);

setup_vref(FALSE);

setup_oscillator(OSC_4MHZ);

// Ponemos a todos los pines del puerto B como entrada excepto el de salida de la USART

set_tris_b(0xFB);

// Empezamos por el estado de inicio

estado = INICIO;

// La interrupción debe ser cuando pasa de nivel bajo a nivel alto

ext_int_edge( L_TO_H );

enable_interrupts(int_rda);

enable_interrupts(global);

// TODO: USER CODE!!

for(;;)

{

switch(estado)

{

// En el estado de inicio inicializamos el modem para que no haga eco de los comandos,

// los valores de respuesta sean numéricos y apague el altavoz del modem, esperando

// 15 segundos para dejar salir al usuario de la sala y pasamos al estado de detección

case INICIO:

delay_ms(2000);

printf("ATE0V0M0\r");

delay_ms(13000);

deteccion();

break;

// En el estado de detección esperamos la interrupción en modo sleep para consumir menos

case DETECTA:

sleep();

break;

// Se desactiva la interrupción y marcamos el número de teléfono que queramos alertar

case ALARMA:

disable_interrupts(int_ext);

dato = 'A';

printf("ATDTXXXXXXXXX\r");

estado = LLAMADO;

break;

// Esperamos a que termine la llamada para que vuelva al estado de detección

case LLAMADO:

if(dato != 'A')

{

deteccion();

}

Sólo comentar que XXXXXXXXX hay que sustituirlo por el número de teléfono al que queramos dar la alarma.

Restringir el area de uso del ratón

Deja un comentario

Con un simple comando de la API de windows, ClipCursor, podemos restringir el uso del ratón a una zona del escritorio de windows. Un posible uso es restringir a un usuario el uso del ratón a la ventana de una aplicación sin que pueda salir de ella, y por tanto no ejecutar otras opciones del escritorio, pulsar sobre otras ventanas, o deplegar el menú de inicio.

El prototipo de la función es:

bool ClipCursor(RECT *rectangulo);

1	bool ClipCursor(RECT *rectangulo);

Asi por ejemplo si queremos restringirlo a la ventana de la calculadora podemos hacerlo de la siguiente forma:

RECT retangulo;
HWND ventana = FindWindow(NULL, "Calculadora");
GetClientRect(ventana, &rectangulo);
ClipCursor(&rectangulo);

RECT retangulo;

HWND ventana = FindWindow(NULL, "Calculadora");

GetClientRect(ventana, &rectangulo);

ClipCursor(&rectangulo);

Robot con arduino, motorshield, módulo bluetooth y cámara portatil

25 respuestas

Hace tiempo que hice mi primer robot, pero este se quedó en el olvido y recientemente he querido retomarlo para un proyecto de orientación por GPS. De momento lo he estado montando para que detecte colisiones con objetos, pero además me comunique mediante bluetooth cuando detecta esas colisiones. He aquí los pasos que he ido siguiendo para montarlo:

Primero extraemos la electronica y nos quedamos con los cables de los motores del coche teledirigido, después añadimos un conector tamiya con fusible para la batería LIPO:

Nos hacemos con una placa Arduino y un motorshield, en la cual se pueden acoplar en sus pines los cables de los motores:

En el mercado existen multitud de módulos bluetooth, yo he comprado el de sure electronics por su sencillez tanto de montaje como de comunicaciones (va a 9600 bps). Dos cables van a los pines RX y TX de la arduino y otros dos van a la salida de 3,3 voltios y GND de la arduino. Para comunicarse con él en windows basta con el putty accediendo al puerto COM que se haya asociado a vuestra conexión bluetooth; si se trata de linux o mac podeis conectaros desde la consola con screen /dev/<dispositivo> 9600 siendo <dispositivo> el tty asociado a la conexión:

Montamos los bumpers. El cable suelto va a uno de los pines GND de la arduino, los otros dos cables van conectados a los pines EC1 y EC2 de la motorshield, que a su vez están conectados a los pines 4 y 5 de la arduino, por lo que se deberá activar la resistencia pull-up interna de esos pines:

Una batería LIPO para alimentar el conjunto, pegada con velcro para que se sujete bien a la vez que sea fácil quitarla para cargarla o sustituirla:

Aunque no es necesario, he puesto una cámara wireless alimentada con una pila de 9 voltios para grabar los movimientos. Al final el conjunto queda así:

Como el movimiento se demuestra andando, pongo un video de su funcionamiento (recomiendo agrandarlo para ver mejor los detalles). A la izquierda el putty mostrando los mensajes que envía la arduino a través de bluetooth, en el centro un video del cómo responde el robot y a la derecha otro video desde dentro del robot:

Finalmente dejo el código fuente del robot para el entorno Arduino:

int dirA = 12; // sentido
int dirB = 13;  // direccion 
int speedA = 10; // velocidad del motor
int speedB = 11; // parada o encendido de la dirección
int bumperI = 5; // bumper izquierdo
int bumperD = 4; // bumper derecho
int boton2 = 6; // boton 2 de la motorshield
int boton1 = 7; // boton 1 de la motorshield

// El robot va hacia atrás
void atras()
{
  digitalWrite (dirA, HIGH);
}

// El robot va hacia alante
void alante()
{
  digitalWrite (dirA, LOW);
}

// El robot tuerce a la izquierda
void izquierda()
{
  digitalWrite (dirB, LOW);
}

// El robot tuerce a la derecha
void derecha()
{
  digitalWrite (dirB, HIGH);
}


void setup() 
{
  // Configuración de los pines de la motorshield
  pinMode (dirA, OUTPUT); 
  pinMode (dirB, OUTPUT); 
  pinMode (speedA, OUTPUT); 
  pinMode (speedB, OUTPUT);
  
  // Configuración de los pines de los bumpers
  pinMode (bumperI, INPUT);
  pinMode (bumperD, INPUT);
  
  // Configuración de los botones de la motorshield
  pinMode (boton1, INPUT);
  pinMode (boton2, INPUT);
  
  // Configuración de las comunicaciones por bluetooth
  Serial.begin(9600);
}


void loop() 
{ 
  // Si se ha pulsado el boton de arranque
  if(digitalRead(boton1) == 0)
  {
    delay(200); // para evitar rebotes en el boton
    Serial.println("empiezo");  
    analogWrite(speedA, 100); // PWM a 100
  }
  // Si se ha pulsado el boton de parada
  else if(digitalRead(boton2) == 0)
  {
    delay(200); // para evitar rebotes en el boton
    Serial.println("termino");
    analogWrite(speedA, 0); // PWM a 0
  }  
  alante();
  // Si se ha detectado una colisión por el flanco derecho
  if(digitalRead(bumperD) == 0)
  {
    Serial.println("choque derecha");
    digitalWrite(speedB, HIGH); 
    // Va hacia atrás a la derecha durante 1 segundo    
    derecha();
    atras();
    delay(1000);
    // Va hacia alante a la izquierda durante medio segundo
    alante();
    izquierda();
    delay(500);
    digitalWrite(speedB, LOW); 
  }
  // Si se ha detectado una colisión por el flanco izquierdo
  else if(digitalRead(bumperI) == 0)
  {
    Serial.println("choque izquierda");
    digitalWrite(speedB, HIGH); 
    // Va hacia atrás a la izquierda durante 1 segundo
    izquierda();
    atras();
    delay(1000);
    // Va hacia alante a la derecha durante medio segundo    
    alante();
    derecha();
    delay(500);
    digitalWrite(speedB, LOW); 
  }
}

100

101

102

103

int dirA = 12; // sentido

int dirB = 13; // direccion

int speedA = 10; // velocidad del motor

int speedB = 11; // parada o encendido de la dirección

int bumperI = 5; // bumper izquierdo

int bumperD = 4; // bumper derecho

int boton2 = 6; // boton 2 de la motorshield

int boton1 = 7; // boton 1 de la motorshield

// El robot va hacia atrás

void atras()

{

digitalWrite (dirA, HIGH);

}

// El robot va hacia alante

void alante()

{

digitalWrite (dirA, LOW);

}

// El robot tuerce a la izquierda

void izquierda()

{

digitalWrite (dirB, LOW);

}

// El robot tuerce a la derecha

void derecha()

{

digitalWrite (dirB, HIGH);

}

void setup()

{

// Configuración de los pines de la motorshield

pinMode (dirA, OUTPUT);

pinMode (dirB, OUTPUT);

pinMode (speedA, OUTPUT);

pinMode (speedB, OUTPUT);

// Configuración de los pines de los bumpers

pinMode (bumperI, INPUT);

pinMode (bumperD, INPUT);

// Configuración de los botones de la motorshield

pinMode (boton1, INPUT);

pinMode (boton2, INPUT);

// Configuración de las comunicaciones por bluetooth

Serial.begin(9600);

}

void loop()

{

// Si se ha pulsado el boton de arranque

if(digitalRead(boton1) == 0)

{

delay(200); // para evitar rebotes en el boton

Serial.println("empiezo");

analogWrite(speedA, 100); // PWM a 100

}

// Si se ha pulsado el boton de parada

else if(digitalRead(boton2) == 0)

{

delay(200); // para evitar rebotes en el boton

Serial.println("termino");

analogWrite(speedA, 0); // PWM a 0

}

alante();

// Si se ha detectado una colisión por el flanco derecho

if(digitalRead(bumperD) == 0)

{

Serial.println("choque derecha");

digitalWrite(speedB, HIGH);

// Va hacia atrás a la derecha durante 1 segundo

derecha();

atras();

delay(1000);

// Va hacia alante a la izquierda durante medio segundo

alante();

izquierda();

delay(500);

digitalWrite(speedB, LOW);

}

// Si se ha detectado una colisión por el flanco izquierdo

else if(digitalRead(bumperI) == 0)

{

Serial.println("choque izquierda");

digitalWrite(speedB, HIGH);

// Va hacia atrás a la izquierda durante 1 segundo

izquierda();

atras();

delay(1000);

// Va hacia alante a la derecha durante medio segundo

alante();

derecha();

delay(500);

digitalWrite(speedB, LOW);

}