Las ventajas de estas placas son múltiples. La primera es que que incorporan un programador/depurador en la propia placa, por lo que no hace falta comprar un programador, solo necesitamos un cable mini usb. En el caso de las Discovery de ST el depurador incorpora un conector que permite que usemos la placa como programador externo. Las placas se pueden alimentar desde el usb.

Además suelen incorporar conectores para acceder a los terminales del micro, lo que permite realizar prototipos rápidamente. Y en algunos casos incorporan algún tipo de periférico, desde leds, pulsadores, acelerómetro, giróscopo, USB OTG, pantallas LCD y un largo etc.

Y lo mejor suele ser el precio las placas. Como son placas de evaluación, las venden por precios casi simbólicos. Por menos de 20€ puedes comprar una de estas viguerías para usarla como CPU en un robot. Como ejemplo, TI está promocionando los Stellaris (CORTEX-M4) con la Stellaris LaunchPad por 4.99$ (dolares) gastos de envío incluidos… casi nada!

Yo me he comprado un par de placas de ST discovery kit. Una es la de la primera foto, que es la STM32F4 Discovery, con un CORTEX-M4, USB OTG, Ampli clase D con salida de auriculares, acelerómetro de tres ejes y casi 100 pines de GPIO. y la otra es una STM32L Discovery, con un CORTEX-M3 de bajo consumo, barra de 4 sensores táctiles y display LCD alfanumérico, que es la de la siguiente foto.

La idea es poder hacer algún robotito con estas preciosidades. Por ejemplo se me ocurre que se puede hacer un velocista o rastreador con la STM32L como CPU. Aunque la placa pesa un poco, consume muy poco y la pantalla, los sensores táctiles y el pulsador nos pueden venir de miedo para ajustar el algoritmo sin necesidad de estar reprogramando continuamente. Al lado de un PIC estos micros son una bestia parda, así que las posibilidades se disparan hasta el infinito. Como contraprestación la programación de estos micros no es como la de los PIC, así que tendré que reciclarme y acostrumbrarme al nuevo concepto.

En Julio de este año se realizo en la UPV un curso de iniciación a la programación de estos microcontroladores utilizando precisamente la STM32F4 Discovery de la que os he hablado antes. Por suerte para nosotros, los ponentes del curso han tenido a bien publicar los materiales que crearon para el curso en un blog. Os dejo unos enlaces a la página principal del blog del curso:

http://armcortexm.blogs.upv.es/

Y los materiales del curso:

http://armcortexm.blogs.upv.es/material-del-curso/

Además, algunos de los asistentes han creado un foro sobre los CORTEX-M en español:

http://armcortexm.micsoftware.es/

Ya tenemos por donde empezar. A ver si tengo tiempo y voy publicando avances sobre este tema.

Al final he encontrado en la nueva página de ITEAD los nuevos ficheros CAM. Hay un fichero para versiones hasta la 5 y otro para la 6. Se pueden descargar desde los siguientes enlaces:

ITEADstudio_CAM for Eagle5.x.zip

ITEADstudio_CAM for Eagle6.x.zip

Y ahora los gerber. Del siguiente enlace os podéis descargar los gerber para la fabricación de placas de la Arduino DAQShield en ITEAD. Solo hay que realizar el pedido y enviarles el zip. Yo todavía no los he probado, si los usáis es bajo vuestra responsabilidad .

Arduino DAQShield Gerber (256)

Que aproveche!

Y los archivos de EAGLE:

ArduinoDAQShield (300)

Estoy teniendo problemas para obtener los gerber de ITEAD con la versión 6 de EAGLE. Cuando lo consiga solucionar los publicaré.

Pingutooth

En pingubot tenemos que usar una "shield", para conectar el HC-06 al puerto serie, así que es lo que he hecho.

La CPU de Pingubot tiene accesibles los pines 8 y 9 (RX y TX) y la alimentación de 5V en un conector al lado del micro. El espacio es reducido así que he hecho la placa lo mas pequeña que he podido y con los componentes mínimos imprescindibles. Todo intentado que la placa siga la filosofía DIY, por lo que el trazado de pistas se ha hecho por la cara inferior (aunque el diseño en EAGLE incluye un plano de masa en la cara superior) y los componentes  son "troughole", a excepción del módulo bluetooth.

Los componentes son de fácil adquisición, incluido el MCP1700, que es un LDO de 3,3V que se puede conseguir en el programa de samples de Microchip.

El esquema que que montado en la placa es este:

Esquema Pingutooth

Esta es la cara de componentes:

Pigutooth-Componentes

No se aprecia muy bien, pero si se hace la placa a una cara hay que hacer un puente  por la cara de componentes entre el regulador y el conector. Está marcado en la serigrafía de la placa.

Esta es la cara de pistas:

Pingutooth-Pistas

Y aquí vemos la colocación del módulo bluetooth. No es necesario soldar todos los pad, basta con soldar los que tienen una pista. Yo he soldado los que están conectados a algún sitio y los de las esquinas para que hagan algo de fuerza.

Pigutooth-HC06

Y el prototipo de placa es ha quedado así:

Pingutooth montado

Y aquí una muestra de como queda conectada a la CPU de Pingubot. El espacio está justo, pero la placa de la foto es ligeramente más grande que la de el diseño. No he querido cortarla demasiado justa por si las moscas. De todas formas, si retoco el diseño cambiaré la posición del condensador electrolítico para que no moleste con el de la CPU.

Pingutooth-Conexion

Obviamente, también se puede usar con Pinguino:

Pingutooth y pinguino

Y para terminar un zip con los archivos de EAGLE del diseño. Los he hecho con la versión 6.2, por lo que es posible que necesitéis esa versión o una posterior.

Pigutooth.zip (111)

Pinguino32 DIY

Empecemos por las novedades software:

Han liberado una beta de la versión X.3 del IDE de pinguino.

De momento solo está para windows y linux. Solo he tenido tiempo de instalarlo y tiene buen aspecto. Cuando tenga algo más de tiempo veré que se necesita en cuanto a las instalación y lo postearé como es habitual. Demomento os dejo el enlace al post del blog del proyecto pinguino que anuncia la versión 381, aunque en la zona de descargas ya está la 399.

Pinguino X.3 !!

En cuanto al hardware; han publicado un versión DIY de Pinguino con componentes "No SMD" (al estilo del primer Pinguino) pero cuya principal novedad es que usa un PIC32MX250F128B. GENIAL!!! 128k de flash,32k de RAM, 17 I/O, 2 UART y la potencia de cálculo de un PIC32 en el mismo espacio de un Pinguino de 8 bit y que además te lo puedes hacer en casa por muy poco dinero. El PIC32 está en el programa de samples de Microchip así que se pude conseguir gratis. Yo ya estoy esperando mis muestras y veremos a ver que sale.

La versión publicada no es la definitiva, ya que pretenden utilizar el oscilador interno del PIC para evitarse componentes, pero esto es algo que hay que seguir con interés.

Os pongo el enlace al post del blog del proyecto,

PINGUINO32-DIY

y a la página de descargas de donde podéis descargar tanto los archivos de kicad del nuevo pinguino32, como el IDE X.3.

http://code.google.com/p/pinguino32/downloads/list

A lo mejor dentro de poco vemos un Pingubot de 32 bit…

La idea es que de manera rápida y sin casi recursos se puedan realizar aplicaciones de Labview usando Arduino. Uno de los problemas que se nos presentaba era la posibilidad de dañar la tarjeta al realizar los circuitos haciendo las conexiones con cables en las tiras de pines hembra que trae la placa. Para minimizar riesgos se nos ocurrió hacer una placa que pudiésemos "pinchar" al Arduino (shield) que tuviese lo básico para realizar aplicaciones controladas con Labview.

Lo primero era repartir las entradas y salidas de Arduino. La placa dispone de 6 entradas analógicas, y 14 pines E/S digital. El sentido común dicta que las entradas analógicas deben de ir a conectores tipo regleta (con tornillo) para poder conectar sensores analógicos. Estos pines analógicos también pueden usarse como entradas o salidas digitales, así que más versátil no puede ser. Cuando la programación se hace con el IDE de Arduino, para usar las entradas analógicas como E/S digital se configuran con pinMode() usando los números de pines del 14 (para A0) hasta el 19 (para A5). No se si funcionará en Labview, lo tengo que probar.

Nos quedan los pines digitales. En los procesos "industriales"  lo normal es que necesitamos un número de entradas superior al de salidas que controlamos por lo que la placa tendrá más entradas digitales que salidas. En algunos procesos necesitaremos salidas analógicas para controlar algún actuador de manera "continua". Arduino no tiene salidas analógicas, aunque en su defecto podemos utilizar las salidas PWM que si que tiene. En concreto la Arduino Uno tiene 6 salidas por PWM, que pueden usarse como salidas digitales normales o como PWM. Los pines que tienen la capacidad de generar salidas PWM serán los que usemos como salidas digitales, y los que no tengan esta capacidad los usaremos como entradas digitales.

Las entradas digitales las vamos a conectar directamente a interruptores que nos faciliten la tarea de simular las entradas de los procesos, mientras que las salidas digitales las conectaremos a unos LED y a conectores de regleta. De esta forma podremos ver en la propia placa la activación de las salidas.

Al final el reparto de pines queda así:

• Entradas analógicas: de A0 a A5, conectadas a regleta.
• Salidas digitales: D3, D5, D6, D9, D10 y D11, conectadas a LED y regleta.
• Entradas digitales: D0, D1, D2, D4, D7, D8, D12 y D13, conectadas a interruptores.

Para no perder ninguna funcionalidad, además conectaremos todos los pines de Arduino a tiras de pines hembra  que estarán accesibles en la placa. Las conexiones de alimentación también se van a conectar a regletas para que se puedan alimentar circuitos externos usando las alimentaciones de Arduino.

Por el momento, las entradas digitales solo se conectan a los interruptores. No les he puesto regletas, por que como los interruptores se activan a 5V, corremos el riesgo de producir cortocircuitos.

Esquema

El esquema de la placa es el siguiente:

Placa

Y la placa al final quedará así:

De momento, la "Arduino DAQ shied" solo es un proyecto. No he tenido tiempo de construirla y probarla, y seguramente cuando lo haga cambie alguna cosa, así que hasta entonces lo voy ha dejar así. Cuando la haya fabricado y me guste, prometo publicar tanto los archivos de EAGLE como los gerber para mandar a fabricar.

Salu2!

El módulo que yo tengo es el HC-06 (no se de que empresa), que últimamente se puede comprar en Ebay por menos de 5€. Yo lo compre hace bastante tiempo en ITEAD, pero no suelto sinó en una shield tipo XBEE. Es el de la foto siguiente. Se puede apreciar el módulo y las señales necesarias para la comunicación.

El primer problema es la alimentación. Este módulo funciona a 3,3V, por lo que si queremos usarlo con Pinguino, primero tenemos que conseguir la alimentación de 3,3. Esto es muy facil con un MCP1700, que es un regulador LDO de 3,3V de microchip, que se puede conseguir como sample. Tambien hay que tener en cuenta que la lógica también va a ser de 3,3V y que si conectamos la línea TX del Pinguino directamente al módulo lo podemos estropear. Solución facil; una resistencia en serie de unos 2k7 o bien un divisor de tensión  que de aproximadamente 3,3V cuando alimentemos con 5V. Hay soluciones mucho más "elegantes" a base de transistores, pero lo cierto es que así funciona bastante bien.

El circuito que he montado es el siguiente:

El circuito solo tiene lo necesario para alimentar al módulo y usarlo para comunicarse con el. Las líneas RX y TX del módulo y del pinguino se tienen que cruzar, es decir la línea TX del pinguino (pin 8) se conecta al RX (con la resistencia en serie) y viceversa. Con este circuito básico podemos comunicar el pinguino  mediante bluetooth.

La configuración "de fabrica" de este módulo es la siguiente:

• NOMBRE BT: linvor
• PIN: 1234
• BAUD: 9600
• PARIDAD: N (sin paridad)
• BITS: 8
• BIT STOP: 1
• PROTOCOLO: Ninguno

Podemos usar esta configuración para comunicarnos por bluetooth. Solo tendriamos que configurar la comunicación serie del Pinguino (Serial.begin(9600);) y emparejar el módulo bluetooth. Partiendo de esta configuración, veamos como podemos cambiar la configuración del módulo.

La configuración del módulo se hace mediante comandos AT. Es decir una vez estamos conectados con el módulo, solo hay que enviarle una serie de "tramas" para cambiar la configuracion. Los comandos de configuración son los siguientes:

Comando AT:

Solo sirve para comprobar la comunicación. Si le enviamos la trama "AT" el módulo debe contestar con un "OK"

Velocidad:

La velocidad de comunicación se cambia con la trama "AT+BAUDx", donde x es un número de 1 a 8. El número indica la velocidad según la siguiente relación:

1———1200
2———2400
3———4800
4———9600
5———19200
6———38400
7———57600
8———115200

El módulo responde con "OKxxxx" donde las x representan la velocidad en número. Por ejemplo si enviamos "AT+BAUD8" el módulo debe contestar "OK115200".

Nombre:

El nombre del módulo es el que veremos más tarde cuando vayamos a emparejar el PC (o lo que sea) con el módulo para recibir los datos. La trama para cambiar el nombre es "AT+NAMEnombre" y el módulo contesta con"OKnombre".

PIN:

Es el código que utilizaremos para emparejarnos con el módulo bluetooth. Se cambia con "AT+PINxxxx", donde las x representan el código y contesta con "OKxxxx".

La mayoria de problemas que me he encontrado a la hora de configurar el módulo se han debido a dos cosas:

1. El módulo no puede estar emparejado. Obvio, pero piqué como un pardillo.
2. Las tramas de configuración no tienen ningún caracter de final de trama. Esto no es tan obvio, pero me habría ahorrado dolores de cabeza si hubiese leido el manual con algo más de detenimiento.

Inicialmente intenté configurar el módulo conectandolo directamente al conversor USB-RS232 TTL, y enviandole las tramas con un programa tipo hyperterminal (TeraTerm, PuTTY…), pero entre que algunos de estos programas ponen un "retorno de carro" al final de la trama y que yo era un poco lento tecleando, la cosa no funcionó.

Al final me hice un programa de Pinguino que hacía la configuración. Es el siguiente programa:

void setup() {
  Serial.begin(9600);
  Serial.print("AT+NAMEBTBEE");
  delay(1000);
  Serial.print("AT+PIN1243");
  delay(1000);
  Serial.print("AT+BAUD8");
}

void loop() {
}

Con esta configuración, ahora el módulo funciona a 115200 baudios, se llama "BTBEE" y el pin para emparejarse con el es 1243. Bien, pues nos vamos a emparejar con el para probar la comunicación. 

En el PC, nos vamos a agregar dispositivos bluetooth. Esto inicia la busqueda y debe encontrar el dispositivo "BTBEE".

Lo seleccionamos y lo emparejamos indicando el pin cuando nos lo solicita. Una vez emparejado el sistema nos avisa de que tenemos un puerto serie estandar sobre bluetooth, informandonos además de cual es el COM con el que debemos comunicar. Si no nos da tiempo a ver el globo de información siempre podemos recurrir al "Administrador de dispositivos".

Ahora el módulo está vinculado con el PC, y se emparejará cuando una aplicación se conecte al COM para enviar o recibir datos.

Para probar la comunicación he añadido al circuito anterior un potenciometro y un led. La idea es enviar al PC la lectura de una entrada analógica usando el bluetooth. El led se encenderá cuando la entrada analógica supere los 2,5V. El circuito ahora queda así:

Y el programa es este:

void setup()
{
	pinMode(7,OUTPUT);
	Serial.begin(115200);
}

void loop() {
  int sensorValue = analogRead(A0);
  if (sensorValue>512)
		digitalWrite(7,HIGH);
  else
		digitalWrite(7,LOW);
  Serial.printf("@%d\r\n",sensorValue);
}

Y cuando conectamos un programa tipo hyperterminal al COMx de la conexión bluetooth, empezará a recibir los datos:

Bueno, pues ya tenemos  conexión bluetooth, lo siguiente es hacerle telemetria a pingubot jeje.

Hace algún tiempo Angel Perles (gran profesor y mejor director de proyecto) me mando el siguiente enlace por si me interesaba, y vaya si me ha interesado.

NI LabVIEW Interface for Arduino Toolkit – Utilice E/S Arduino con LabVIEW – National Instruments

Por cierto, Angel es el autor de cheapDAQ, del que ya hablaré más adelante.

Bueno, pues resulta que los amigos de NI nos han hecho un traje a medida. Han creado componentes para Labview (VI) y el firmware necesario para convertir una placa de arduino en una tarjeta de adquisición de datos y poder manejarla por USB desde labview. Las características de la DAQ resultante no es que sea como para tirar cohetes (200hz), pero es mejor que lo que teníamos (nada).

Pues nada os explico como he conseguido que funcione. Al lío!

Requisitos:

• Un arduino (Obvio) basado en el ATMEGA328 o superior (en el ATMEGA168 no cabe el firmware). Vale un Duemilanove, pero en nuestro caso será un Arduino UNO.
• El IDE de Arduino (versión 1)
• Labview 2009 o superior (vale la versión trial)
• Kit de drivers VISA.
• VIPM (VI package manager).
• Labview Interface for Arduino (en adelante LIFA)

Lo primero que necesitamos instalar es Labview. Podemos descargar la versión de evaluación del siguiente enlace, aunque para hacerlo primero tendremos que registrarnos.

http://www.ni.com/trylabview/

Una vez unstalado Labview, procedemos a instalar el pack de drivers de VISA, que podemos descargarlo desde la siguiente página. Yo he instalado la versión 5.1.1, pero funciona con la versión 5.0.3 y ya han sacado la 5.1.2.

NI-VISA 5.1.1

Después instalamos el gestor de paquetes VI (VIPM). Podemos descargar la versión de la comunidad (free) de la siguiente página. Este programa será el que descargue e instale los VI de Arduino en Labview.

JKI VI Package Manager.

Una vez instalado todo esto, ejecutamos el gestor de VI (VIPM) y buscamos "Arduino". Solo tenemos que seleccionar el paquete de la lista e instalarlo. Los paquetes de componentes del LIFA se pueden descargar e instalar manualmente, pero esta forma es mucho más fácil. Cuando termine, habremos completado la parte de instalación del Labview, nos queda la parte del Arduino.

El IDE de arduino lo descargamos directamente de la página de GoogleCode. En la página de Arduino en Español, los enlaces a las últimas versiones no están actualizados, se quedaron en la versión 0019. Yo he utilizado la versión 1.0. En el siguiente enlace está la lista de las últimas versiones del IDE.

http://code.google.com/p/arduino/downloads/list

Una vez descargado lo descomprimimos y nos creamos un enlace en el menú de programas o el escritorio si lo prefieres. Con esto ya está todo instalado y solo tenemos que cargar el firmware del LIFA al Arduino para que se pueda comunicar con Labview.

Lo primero es conectar la placa de arduino al USB. Si es la primera vez que lo haces, deberás instalar los drivers de windows (si es que todavía usas este SO). No te preocupes que el IDE de arduino ya los trae, solo hay que decirle al sistema en que carpeta se encuentran. Conectamos el Arduino y nos aparece el típico globo que avisa de que no se han encontrado los drivers del nuevo dispositivo, hacemos clic en el y nos da la opción de buscar los drivers. Si no aparece, podemos ir directamente al administrador de dispositivos haciendo clic derecho sobre "Equipo" (Mi PC en XP) y seleccionando Administrar en el menú emergente. Una vez abierto el administrador de dispositivos nos encontraremos con el arduino desconocido.

Hacemos clic con el botón derecho sobre el dispositivo desconocido y elegimos la opción "Actualizar software de controlador". En la siguiente ventana  elegimos la opción "Buscar software de controlador en el equipo". Ahora se nos pedirá que indiquemos en que carpeta están los drivers de arduino. Tendremos que seleccionar la carpeta "drivers" que hay dentro del directorio de Arduino.

y aceptamos la instalación del driver, tras lo cual, nuestro arduino estará reconocido en el sistema como un puerto serie. El número de puerto serie lo necesitaremos en los siguientes pasos.

Ya tenemos arduino conectado al usb y reconocido por el sistema, ahora toca programar el arduino con el sketch que comunica la placa con labview. El sketch de arduino se instala con LIFA, por lo que tenemos que ir a la carpeta donde se ha instalado.  La ruta es un poco larga, así que mejor lo miráis en el pantallazo de la derecha. En el directorio LVIFA_Base, se encuentra el archivo LVIFA_Base.pde que es el sketch que debemos abrir. Se nos abrirán además todas las librerías. Cuando lo tenemos todo abierto lo programamos en la placa de arduino. Primero seleccionamos el tipo de placa que estamos utilizando, que en nuestro caso es una arduino UNO. Se selecciona desde el menú tools, en la opción Board.

Ahora elegimos el puerto serie (COM) que utiliza el sistema para comunicarse con la placa de arduino. En mi caso es el COM14, pero el sistema nos puede haber asignado cualquier otro. Lo puedes averiguar en el Administrador de dispositivos. El puerto se selecciona en la opción "Serial Port" del menú Tools.

Y ya podemos programar la placa con el botón de la flecha de la parte superior.

Eso es todo. Con esto ya tenemos lista la placa de arduino para comunicarse con Labview y en Labview tenemos montones de VI que nos van a permitir hacer facilmente aplicaciones para controlar procesos usando arduino como tarjeta de adquisición de datos.

Si abrimos labview podemos usar alguno de los ejemplos que vienen con LIFA. Como ejemplo vamos a ver el hace uso de una entrada analógica. Los ejemplos de LIFA para Labview se instalan por defecto en la carpeta de ejemplos de Labview, y el ejemplo que buscamos es Arduino Analog Read Pin.

Este ejemplo consiste en leer una entrada analógica de Arduino y mostrar la tensión de entrada en un indicador. Primero montamos un circuito que nos varíe la tensión en una entrada con un potenciómetro por ejemplo. El propio ejemplo nos da una esquema para hacerlo:

Una vez montado el  circuito y  abierto el ejemplo tendremos que modificar en el VI  (Arduino Init) los datos referentes a la placa de arduino: Puerto de comunicación y  modelo de Arduino. En la ventana del front end del ejemplo, seleccionamos "Show Block Diagram" del menú Window.

En el diagrama de bloques haremos doble clic sobre el VI de inicialización de Arduino. Este es el encargado de iniciar la comunicación con la placa, por lo que es aquí donde hay que configurar el modelo de placa de Arduino que utilizamos y el puerto serie.

En la ventana que nos aparece al hacer doble clic, seleccionamos el modelo de Arduino y el puerto serie que utiliza. Se muestra que opciones hay que modificar en la siguiente imagen.

Con eso lo tenemos listo; cerramos las dos ultimas ventanas, y en la ventana del front end ejecutamos la aplicación de Labview. Si la placa está conectada y hemos configurado correctamente la aplicación; al modificar la tensión de la entrada con el potenciómetro, se mueve el indicador de la aplicación. En el siguiente vídeo se puede ver el funcionamiento.

http://www.youtube.com/watch?v=BhIa7FT4Gm0

Por último os dejo aquí los enlaces a las páginas de las que he sacado toda esta información:

• https://decibel.ni.com/content/groups/labview-interface-for-arduino?view=overview
• http://vishots.com/getting-started-with-the-labview-interface-for-arduino/

Espero que os sea tan útil como nos va a ser a nosotros.

Salu2!

Por fin!!. A tres meses del concurso, por fin se han publicado las bases del Desafío Robot 2012.

Este concurso, que va a celebrar la 4ª edición, está orientado a alumnos de la ESO, Bachillerato y ciclos formativos de grado medio y superior. El concurso se celebrará el viernes 25 de Mayo de 2012. Hay tres categorías de concurso: categoría LEGO, para robots construidos con piezas de esta marca, categoría libre para robots construidos con cualquier tipo de piezas y componentes (exceptuando piezas de LEGO) y la categoría Especial para grupos de robots de baile.

Las pruebas de las categoría LEGO y Libre son las mismas, pero se realizan por separado. La primera prueba consiste en resolver un laberinto. Los robots deberán recorrer un circuito (línea negra sobre fondo blanco) con múltiples bifurcaciones de 90º sin indicaciones hasta encontrar la salida, representada por un cuadrado negro. El laberinto tendrá tramos bonificados que restarán 10 segundos al tiempo que se ha tardado en resolver el laberinto.

La segunda prueba, como de costumbre (ha habido una prueba así en todas las ediciones) es una prueba de velocidad. Hay que dar una vuelta a un circuito cerrado en el menor tiempo posible. Como novedad, este año se ha incluido un discontinuidad en el circuito para no ponerlo tan fácil, aunque no va a suponer ningún problema para ningún robot.

Las pruebas de este año supone un cambio importante con respecto a otras ediciones. La prueba del laberinto es otra modalidad de prueba para robot siguelineas. Y no supone la construcción de mecanismos especiales que complican mucho la construcción de los robot sobre todo para la categoría libre. En contrapartida, el laberinto supone una complejidad a la hora de programar, pero no es más complicado de programar que la prueba de los botes del año pasado. Otra diferencia es que cualquier robot construido para ediciones anteriores puede participar casi sin modificaciones (solo quitando los mecanismos recoge-botes).

Como podéis ver, este año, aunque con un poco de retraso el concurso viene con alguna novedades importante. Parece que han escuchado nuestras quejas del año pasado y este año van a limitar la participación de robots comerciales tipo 3PI a la prueba Especial. Y menos mal, por que con los ejemplos que te puedes descargar para programar ese tipo de robot, en media hora preparas el concurso de este año.

Ahora toca poner a punto los robot. Nos vemos por allí!!

Hoy traigo una de esas cosas olvidadas. Se trata de una placa entrenadora del PIC 16F876. La diseñe hace un par de años para un curso de programación de microcontroladores PIC en C.

La placa incluye el circuito del ART2003, por lo que se programa mediante el puerto paralelo. También tiene un regulador 7805 para alimentar el PIC con alimentación externa con un diodo en serie para evitar inversiones de polaridad de la tensión de alimentación.

Aparte de eso, la placa solo tiene una tira de pines pero eso es lo que más me gusta de ella. Todos los pines de E/S del 16F876 (excepto RB3) se conectan a un pin de la tira. Además las señales están ordenadas. La tira de pines se coloca en la cara de pistas, con la idea de que la placa se pueda "pinchar" en un placa board. Esta idea la tomé prestada de las placas de pinguino. Me gusto la idea de pinchar la placa en la board para poder hacer prototipos de manera rápida. También se puede utilizar un conector hembra y conectar mediante cables a otros circuitos.

La idea era hacer una placa que no sirviera solo para unos cuantos ejemplos, si no que sirviera para poder conectar y hacer prácticas casi con cualquier cosa… un LCD, teclado, sensores, finales de carrera. La placa funciona bien, pero de vez en cuando, y en función del circuito que le conectes (sobre todo si utiliza las líneas RB6 y RB7) daba problemas a la hora de programar. Esto se debe que al cargar las líneas que se utilizan para programar interferimos en el proceso de programación del PIC. La solución es sencilla… desconectamos la placa de la board, programamos y después volvemos a conectar la placa al circuito.

Pues nada, aquí tenéis los archivos de EAGLE y algunos pdf e imágenes:

Placa entrenadora de PIC 16F876 (389)

No lo he probado, pero seguro que también se puede usar con PIC's "compatibles" de la serie 16F, como el 16F886 y otros de 28 pines. Con un poco de suerte la será útil a alguien más…