Computacion Fisica en Secundaria

Computacin Fsica
en Secundaria
Primera edicin
MARF Bo o k s
Ttulo original: Computacin Fsica en Secundaria

Diseo de la cubierta: Albert Jack Font y Edgar Llorente
1 Edicin en lulu.com: enero, 2010
Marco Antonio Rodrguez Fernndez
Matar, Barcelona - [Spain]
ISBN: 978-0-557-18825-3
Libro publicado bajo licencia CreativeCommons-Attribution-Share Alike 2.0:
[http://creativecommons.org/licenses/by-sa/2.0/es/
Computacin Fsica
en Secundaria
Marco A. Rodrguez Fernndez
MARF Bo o k s
A mi madre, mi padre y mi hermano que a pesar de mis ideas paranoicas y mis cambios
de humor sin sentido, aun siguen soportndome y dndome su apoyo.
A mis alumnos y compaeros de trabajo que sufren mis experimentos educativos.
Contenidos
Prlogo..........................................................................................................
POR QU?....................................................................................................................10
PARA QUIEN?...............................................................................................................10
CMO?........................................................................................................................10
Docencia Creativa......................................................................................11
EL SUELO BAJO, EL TECHO ALTO, Y LAS PAREDES AMPLIAS...........................................12
LOS LEONARDOS DEL SIGLO XXI...............................................................................13
TRABAJO COOPERATIVO Y SOCIO-CONSTRUCTIVISMO DISTRIBUIDO................................13
Material y Herramientas ...........................................................................15
HILO 0.5MM................................................................................................................15
HILO DE COSER CONDUCTOR.......................................................................................15
PINZAS DE COCODRILO ...............................................................................................16
PLACAS DE PROTOTIPAJE..............................................................................................16
LED.............................................................................................................................17
ZUMBADOR..................................................................................................................18
PULSADORES Y CONMUTADORES...................................................................................19
SIETE SEGMENTOS.......................................................................................................20
POTENCIMETRO.........................................................................................................20
LDR [FOTO-RESISTENCIA]..........................................................................................21
SENSOR DE PROXIMIDAD..............................................................................................22
SENSOR DE TEMPERATURA...........................................................................................23
ACELERMETRO..........................................................................................................23
SERVOMOTOR..............................................................................................................24
SERVOMOTOR DE ROTACIN CONTINUA.......................................................................25
MOTOR DC CON TIP120..........................................................................................27
MOTOR DC CON DRIVER L293..................................................................................28
SENSOR RFID (IDENTIFICACIN POR RADIOFRECUENCIA).......................................29
ARDUINO....................................................................................................................30
PICOBOARD O SCRATCHBOARD..................................................................................31
Programacin............................................................................................35
SECUENCIAS DE INSTRUCCIONES...................................................................................35
VARIABLES...................................................................................................................36
CONDICIONALES..........................................................................................................37
BUCLES........................................................................................................................38
Bucle contador. FOR...................................................................................................................39
FOR's anidados - [Nested Loop]................................................................................................39
Bucle condicional While............................................................................................................40
FUNCIONES Y PROCEDIMIENTOS...................................................................................40
Sobrecarga de operadores..............................................................................................................41
CLASES........................................................................................................................42
ALEATORIEDAD...........................................................................................................44
ARRAYS, ARREGLOS O MATRICES..................................................................................45
Programacin Avanzada...........................................................................46
NORMALIZACIN DE VALORES.....................................................................................46
PONDERACIN DE ENTRADAS......................................................................................46
CALIBRACIN Y CALIBRACIN DINMICA DE SENSORES................................................46
TRUCOS PARA EVITAR USAR BUCLES Y DELAYS..............................................................47
RECURSIVIDAD.............................................................................................................47
COMUNICACIN POR USB..........................................................................................48
COMUNICACIN ARDUINO-PROCESSING CON FIRMATA...............................................50
Proyectos online [ PHP+MySql ].............................................................52
MONTAR UN SERVIDOR WEB CON TECNOLOGA PHP+MYSQL.....................................52
CONSULTAR UNA BASE DE DATOS DESDE UNA WEB......................................................54
INSERTAR DATOS EN UNA BASE DE DATOS DESDE UNA WEB.........................................55
ELIMINAR DATOS DE LA BASE DE DATOS DESDE UNA WEB...........................................55
ENVIAR DATOS A UNA WEB DESDE PROCESSING...........................................................56
RECIBIR DATOS DE UNA WEB DESDE PROCESSING.........................................................57
Proyectos con la ScratchBoard..................................................................59
EL PERRO SALTARN.....................................................................................................59
CANGREJOS DEL ESPACIO EXTERIOR.............................................................................60
GORRO GIRATORIO......................................................................................................62
EL CACTUS VIRTUAL.....................................................................................................63
GAMEPAD CON CARTN Y PAPEL DE PLATA ...............................................................64
Proyectos con Arduino + Processing........................................................67
LED PARPADEANTE.....................................................................................................67
CDIGO MORSE..........................................................................................................69
EL SEMFORO PARA INVIDENTES.................................................................................70
ALARMA DE PROXIMIDAD.............................................................................................71
LA CAMISETA...............................................................................................................73
LA BANDEJA QUE NUNCA VUELCA................................................................................77
ROBOT CON RUTAS PRE-PROGRAMADAS........................................................................79
ROBOT QUE NUNCA CHOCA.........................................................................................81
ROBOT SEGUIDOR DE LINEAS.......................................................................................82
ROBOT PERSEGUIDOR..................................................................................................85
ORGANIZADOR DE MANZANAS.....................................................................................86
PONG CON SENSOR DE DISTANCIA...............................................................................90
ROBOT CONTROLADO POR INTERNET..........................................................................95
THEREMIN DE INFRAROJOS..........................................................................................98
LOCALIZADOR DE COLORES.........................................................................................99
El tintero...................................................................................................101
Apndice...................................................................................................104
Ilustracin 1: Foto realizada por Edgar Ll. y Albert "Jack" F.
Prlogo
La evolucin de los computadores ha hecho que cualquier persona pueda hacer servir un ordenador
para escribir cartas, o guardar datos. Pero, porque no hacerlo servir para otros propsitos ms
imaginativos como abrir puertas, encender el coche o analizar el contenido de un refrigerador?
Peter Dan O'Sullivan y Tom Igoe
La base de la computacin fsica es hacer servir herramientas y tecnologas

conceptualmente simples, para disear ingenios que actan directamente sobre el
mundo fsico. Por ejemplo: si tenemos un chico de unos 10 aos al que intentamos
ensear a programar y le hacemos implementar un programa en c++ que escriba en
la pantalla Hola Mundo, seguramente odie la programacin para el resto de su
vida. Pero si por el contrario utilizando 3 leds y zumbador le hacemos programar el
funcionamiento de un semforo, no solo lo tendremos enganchado a la
programacin, sino que al mismo tiempo estar aprendiendo conceptos de
electricidad, electrnica y comprender como funciona una cosa que esta
acostumbrado a ver todos los das. Y seguramente en 15 minutos se le habr
ocurrido alguna idea extraa para torturar a sus compaeros de clase haciendo
sonidos a frecuencias raras y emitiendo destellos espasmdicos con leds de alta
intensidad.
Computacin Fsica en Secundaria
Por qu?
Hace ya 10 aos que con el nico soporte econmico de mis padres, decid abrir
una pequea escuela de informtica donde poner en prctica alguna de mis ideas
sobre educacin y tecnologa. No obstante estos dos ltimos aos, gracias a la gente
que he conocido en CitiLab y en el MediaLab del MiT, me he dado cuenta que mis
ideas sobre educacin y tecnologa no son tan estpidas como yo pensaba. Tambin
he descubierto que gente de todas partes del mundo comparte planteamientos
similares.
Es por este motivo que me pareci interesante escribir este manual donde a modo
de recetas de cocina cualquiera pueda reproducir estos extraos experimentos
tecnolgicos que acostumbramos a realizar en MARF.
Para quien?
Para todo el que quiera. Compaeros de profesin, alumnos y ex-alumnos,
hobbistas, aficionados, profesionales de la industria, y/o artistas. Espero que cada
uno encuentre alguna parte de provecho en este libro.
Cmo?
El primer apartado del libro Docencia Creativa intenta resumir en un par de
pginas algunas de las ideas sobre educacin que la experiencia me ha mostrado
durante estos 10 ltimos aos. El apartado de Electrnica hace un breve resumen
de los materiales utilizados en los proyectos y de la forma como los hemos
utilizado. En este punto me gustara recordar que este libro no pretende ser un libro
de texto donde por ejemplo, se explica como funciona un led, simplemente muestro
como utilizarlo (para detalles tcnicos me remito a cualquier libro tcnico de
consulta, o cualquier web especializada). El apartado de Programacin hace un
breve resumen de los conceptos ms importantes de la programacin y algunos
trucos de software a la hora de trabajar con sensores y actuadores. Para ms
informacin sobre los lenguajes utilizados siempre podis consultar la API1 de estos
lenguajes. Y por ltimo el apartado de Proyectos, es seguramente el ms
interesante a nivel prctico.
Empezad el libro por donde creis conveniente. Si sois ex-alumnos posiblemente
sea interesante empezar por el final, si os dedicis a la docencia echadle un vistazo al
primer captulo, y si queris conocer los secretos tecnolgicos y los materiales
utilizados miraos el segundo captulo.
No dudis en enviarme sugerencias, cuestiones o aportaciones a la direccin de
correo: marf@marfonline.com o en la pagina web de MARF http://marf.es
1 Interfaz de Programacin de Aplicaciones. Conjunto de instrucciones que utiliza un lenguaje de
programacin.
10
Docencia Creativa
Docencia Creativa
La creatividad en la inmensa mayora de los sistemas educativos es casi inexistente.
Cuando planteo el tema de la creatividad a compaeros de la escuela pblica
escucho cosas como: Eso esta muy bien pero hemos de seguir el currculum, Las
aulas estn masificadas, Los alumnos vienen desganados a clase. Y es cierto,
hace 2 o 3 aos que soy profesor de secundaria y las aulas estn masificadas, la
desidia de los alumnos es considerable y el currculum casi siempre es imposible de
seguir y muchas veces da pena. Pero cuantas veces hemos visto como los mejores
pensadores, cocineros, empresarios, o artistas; han sido malos en sus estudios
acadmicos, o han sido completamente autodidactas. Hace poco estuve leyendo un
libro de un famoso director de cine espaol en el cual deca que los grandes
directores de cine aprendan haciendo cine, y que los directores que salan de las
escuelas de cine solo saban hacer pelculas sobre la guerra civil.
Pero... pensemos en positivo, todos estos genios (o cualquiera que sea bueno en su
trabajo) que tienen en comn? perseverancia, creatividad, curiosidad intelectual,
autodireccin, adaptabilidad, responsabilidad social, habilidades colaborativas,
pensamiento crtico, habilidades comunicativas... Estamos seguros de que nuestro
sistema educativo potencia estas habilidades?, o como dice Sir Ken Robinson en sus
charlas en TED2 actualmente nuestros sistemas educativos en muchos casos van
podando estas habilidades durante los diferentes ciclos?
Ok... tenemos localizado el problema y sabemos cual es nuestro objetivo. Pero...
como hacemos que nuestras clases potencien este tipo de habilidades, cual es el
truco?, que material hemos de hacer/utilizar?, cual es el mtodo a emplear?. Pues
sinceramente, no tengo ni idea. De hecho, pienso que no es cuestin de material, de
mtodo y seguramente no hay ninguna solucin que funcione siempre. Pero si que
tengo claro que una clase creativa es una clase donde el profesor esta dispuesto a
aceptar soluciones no previstas, a enfrentarse con retos extraos, y a guiar a sus
alumnos por senderos que en un principio no controla. No olvidemos que lo mejor
que le puede pasar a un profesor es que sus alumnos le superen. Si en una de estas
actividades consigues que uno de tus alumnos te supere y te ridiculice en clase...
Bien, Perfecto, eso es lo que queramos!
Durante mi participacin en la Scratch Conference-2008 en el MiT, conoc a un profesor de
Matemticas de una escuela de secundaria en Dinamarca, y tuvimos una interesante conversacin
sobre como funciona la submersion week, lo que vendra a ser el Credit de sintesi en
Catalua. El concepto es muy parecido, los chicos hacen grupos de 4 o 5 alumnos, y durante una
semana trabajan un tema concreto. La diferencia esta en como se lleva a cabo por aqu,
acostumbramos a dar un dossier con unas indicaciones de las pautas del trabajo y los chicos
2 http://www.ted.com/index.php/talks/ken_robinson_says_schools_kill_creativity
.html
11

durante la semana van siguiendo el guin y elaboran cada parte del trabajo con la ayuda de los
diferentes profesores. En cambio este profesor dans me comento que el ao anterior durante la
submersion week les hizo hacer un trabajo titulado Hazte una casa, pero... No haba guin!,
no haba pautas!, la nica regla el presupuesto que tenan para hacer la casa. Los chicos hacan
planos, calculaban costes, contactaban con distribuidores locales para obtener los precios de los
materiales, situaban la casa, redactaban informes. Y el profesor me comentaba que al sonar el
timbre tenan que echarlos de clase porque aun seguan trabajando en el proyecto!
El suelo bajo, el techo alto, y las paredes amplias.

Cuando planteemos una actividad creativa, hemos de marcar un nivel bsico que sea
asequible por cualquiera y en poco tiempo, a esto denominaremos el suelo-bajo, es
decir una suelo suficientemente bajo para que todo alumno pueda subirse a l. Por
ejemplo, una de las prcticas tpicas en MARF es el montaje de un semforo con 3 leds de colores
y un microcontrolador. Al principio solo pido que se enciendan los 3 leds consecutivamente, eso
seria un suelo-bajo, es una prctica asequible para cualquiera y en el momento que lo han
conseguido, el siguiente paso es ampliar las paredes.
Una vez hemos planteado la actividad tambin hemos de garantizar que los
alumnos puedan conseguir diferentes objetivos en funcin de sus inquietudes, ha
esto denominaremos la pared-amplia, lo nico que tenemos que hacer es darles
suficientes herramientas para que puedan, de forma autnoma, explorar
creativamente diferentes posibilidades. Volviendo al ejemplo anterior, una vez que el
alumnos ha conseguido encender los 3 leds consecutivamente le proponemos hacer un semforo
donde el led ambar parpadea antes de encender el rojo, le enseamos un piezobuzer para que pueda
hacerlo sonar, o le proponemos que conecte un pulsador para que se ponga verde a voluntad. Pero
sin exigirle algo concreto simplemente le planteamos retos y le ofrecemos posibilidades.
A su vez hemos de garantizar el techo-alto, es decir no hemos de poner lmite a donde
el alumno pueda llegar. Hemos de darle posibilidades, unas ideas bsicas, y despus
escuchar su opinin, sus propuestas, y ayudarle a conseguir los objetivos que el
mismo se plantear.
Este es el paradigma bsico que utilizo en MARF para intentar potenciar la
creatividad del alumno. En este planteamiento el profesor ofrece tcnicas para
conseguir el objetivo que el mismo alumno se marca y a su vez hace gua
inicialmente al alumno para que este consiga esos objetivos bsicos que se ha
marcado al inicio de la actividad.
12
Docencia Creativa
Los Leonardos del siglo XXI.

A pesar de que histricamente hemos separado los conocimientos que adquirimos
en diferentes materias, a la hora de la prctica cuando trabajamos un proyecto de los
abarcados en este libro estamos trabajando multitud de materias de forma
transversal. Por ejemplo en una ocasin se dio el caso que un alumno que cursaba
segundo curso de secundaria peda libros de fsica de cuarto a un compaero para
comprender los conceptos de velocidad, aceleracin y friccin para un videojuego
que estaba diseando. En otra ocasin unas chicas 10 y 11 aos utilizaban sus
conocimientos de ingls para comunicarse con unos compaeros de EEUU que
han visto sus proyectos publicados en Internet y quieran saber como estn hechos.
Como se ver ms adelante en el proyecto de la camiseta, parte del material se
compro a un proveedor canadiense y aprovechamos la ocasin para explicar como
funcionan los sistemas monetarios, los cambios de moneda, las zonas horarias, y los
procesos industriales de exportacin-importacin internacional, para ello impliqu a
los alumnos no solo en el processo creativo y tecnolgico sino tambin en el
proceso de compra del material redactando emails, estudiando cambios de divisas y
realizando los pedidos.
Trabajo cooperativo y socio-constructivismo distribuido.

La mayora de profesores de mi poca conocemos al psiclogo Piaget y la teora
constructivista, donde el aprendizaje es un proceso activo y la gente no recibe los
conocimientos, sino que los hace. Y es posible que algunos conozcan el enfoque del
construccionismo de Seymour Papert donde la gente, construye su conocimiento
cuando estn creando cosas importantes para ellos y para la gente de su alrededor.
Esta implicacin social de nuestras acciones y creaciones, hacen que el proyecto
reciba feedbacks de compaeros que motivan al alumno a seguir mejorandolo o a
compartirlo con otros grupos de trabajo para crear otros proyectos.
As pues, de esta forma no estamos aprendiendo unas tcnicas concretas para
realizar un tipo de trabajo, sino que estamos implicando al alumno en un proceso de
creacin autocrtico con implicaciones sociales que repercuten sobre el mismo.
13
Ilustracin 2: Uno de los robots del curso de verano'09 por Roger G. y Marc G.
14
Material y Herramientas
La mayora de componentes bsicos que describimos en este captulo los podemos
adquirir en tiendas de electrnica3. El material ms especfico como las placas de
arduino, las picoboards (antes conocidad como scratchboards), pueden adquirirse en
tiendas ms especficas4. Tambin podis consultar nuestra web donde ofrecemos
parte del material que utilizamos en nuestros cursos5 (www.marf.es).
Hilo 0.5mm
El hilo de conexiones de este tamao es el ideal para realizar conexiones en placas
de prototipado, se puede utilizar algn hilo ms fino pero puede darse el caso de
que el contacto con las parte no sea estable del todo y los valores que recibimos
sean muy dispares.
Hilo de coser conductor

Este tipo de hilo lo haremos servir para conectar diferentes componentes
electrnicos dentro de una prenda de vestir. Podemos coser este hilo tanto
manualmente como con mquina de coser. Cuando hagamos proyectos donde
utilizamos circuitos sobre ropa, hemos de recordar que siempre se han de lavar en
seco las prendas y con las bateras desconectadas.
Ilustracin 3: Conductive thread. Hilo

de coser conductor.
Hace algunos aos cuando empezamos en MARF a hacer experimentos con

circuitos electrnicos y ropa, este tipo de hilo de coser lo comprbamos a una
3 http://www.miliwatts.com; http://www.ondaradio.com; http://www.radioshack.com
4 http://arduino.cc; http://picocricket.com
5 http://marfonline.com
15

empresa online con sede en Canad6, hoy en da, este tipo de material se puede
encontrar bastante ms fcilmente y existen algunas empresas en Espaa que lo
importan seguramente a un precio ms asequible.
Pinzas de cocodrilo
Las pinzas de cocodrilo nos sern muy tiles para probar prototipos que van
soldados o cosidos, antes de coserlos o soldarlos. Utilizaremos dos tipos de pinzas
de cocodrilo, unas con terminal de pinza en cada borne del cable y otro con uno de
los terminales acabados en cables rgidos para poderlo conectar a una placa de
prototipado o una placa arduino. Las pinzas de cocodrilo podemos comprarlas
hechas en cualquier tienda de electrnica o comprar los conectores y soldarlos a
cables con las medida que deseemos.
Ilustracin 4: Pinzas de cocodrilo con una pinza en

cada terminal.
Placas de prototipaje
Las placas de prototipado (breadboard) se pueden adquirir en cualquier tienda de
electrnica y se suelen hacen servir para probar el funcionamiento de un circuito
antes de proceder a soldarlo. En nuestro caso, dado que el material es caro y no
podemos andar desperdicindolo, no soldaremos nada y trabajaremos siempre
sobre una placa de prototipado.
Como podis observar en la [Ilustracin 5] la placa esta dividida en columnas de 5
agujeros conectados entre si, de forma que cualquier cosa que pinchemos en uno de
estos agujeros queda conectada fsicamente con el resto de elementos pinchados en
los cuatro agujeros restantes de la misma columna. Las placas de mayor tamao
tienen 4 filas de agujeros conectados entre s en la parte superior e inferior.
6 http://www.members.shaw.ca/ubik/thread
16
Ilustracin 5: Conexiones en una placa de prototipado
Led
Hay una gran variedad de Diodos Emisores de Luz. Podemos encontrar leds de alta
intensidad, los cuales emiten luz de hasta 20000mcd(aunque suelen ser caros), los
leds RGB que puede emitir ms de un tono de color con un solo led, y los leds de
luz infrarroja o ultravioleta (aunque estos ltimos se han de manejar con unas gafas
especiales, dada la peligrosidad de su radiacin). Tambin es interesante poder jugar
con diferentes tamaos y con extensiones de fibra ptica para transportar la luz (por
ejemplo cuando realizamos proyectos sobre la ropa). Leds podemos comprar en
cualquier tienda de electrnica aunque por Internet podemos encontrar empresas
especializadas en la venta de leds de alta intensidad7, y otros dispositivos lumnicos.
Ilustracin 6:
Conecin de un led a
una placa de
prototipaje
Para conectar un Led necesitamos tambin una resistencia de unos 200-400 Ohmios
(un Led debera trabajar a 1,5V-1,8V y la placa de arduino nos proporcions uns 5V).
Conectaremos siempre la pata corta del LED a GND (Tierra) y la pata larga a la
7 http://www.ledz.com
17

resistencia. El otro borne de la resistencia lo conectaremos al pin de salida
correspondiente. En el caso de ser un led RGB conectaremos la pata ms larga a
GND y las otras 3 con a una resistencia de 200-400 Ohmios y esta resistencia al pin
de salida que deseemos.
Ilustracin 7: Air graffities realizados con la misma tcnica de los leds

throwies
Air Painting y LedThrowie8: Un experimento muy divertido que se puede realizar con
leds, es conectarlos directamente a una pila de botn y lanzarlo al aire de noche, o
realizar dibujos en el aire mientras hacemos una foto de larga exposicin [ver
Ilustracin 7].
Zumbador
Un zumbador o piezobuzzer, es un pequeo altavoz que emite un sonido al pasar
corriente entre sus dos bornes. Se pueden adquirir zumbadores de muchos tipos en
cualquier tienda de electrnica o podemos reciclar algn pequeo altavoz que
tengamos. A la hora de conectarlos conectaremos la pata ms corta o el cable negro
a tierra (GND) y la otra pata o cable rojo al pin de salida que deseemos. Tambin
podemos hacer servir un zumbador como detector de golpes (KnockSensor)
conectndolo junto con una resistencia del rango de algunos megaohms [ver
Ilustracin 46]. A la hora de programarlo nicamente tendremos que leer
analgicamente el valor que nos da el pin al que hemos conectado el altavoz.
8 http://es.wikipedia.org/wiki/LED_Throwie
18
Ilustracin 8: Esquema y Montaje del "KnockSensor"
Pulsadores y conmutadores
Pulsadores podemos encontrar gran variedad en cualquier tienda de electrnica, no
obstante podemos usar como pulsador cualquier corto circuito entre dos cables.
Para conectarlo conectaremos una pata a tierra (GND) y la otra a una resistencia de
1k-10k, la cual tendr la otra pata conectada a 5V.
Ilustracin 9: Conexin de un pulsador
En este montaje elctrico el voltaje es desviado a GND cuando se pulsa el botn.

De forma que si leemos con la instruccin x=digitalRead(3); el pin 3 obtendremos
un 1 si el botn no esta pulsado y un 0 si el botn esta pulsado:
int x;
void setup(){
pinMode(3,OUTPUT);
serial.Begin(9600);
}
19

void loop(){
x=digitalRead(3);
serial.Println(x);
}
Siete Segmentos
El siete segmentos es un dispositivo que nos permite mostrar un dgito en una
pantalla con 7 leds de forma alargada. Tal y como se puede apreciar en la [Ilustracin
10] hemos de conectar el pin K a una resistencia de 200-400 Ohms que va
conectada a tierra, el resto de pins los conectaremos a las salidas que queramos
utilizar.
Ilustracin 10: Esquema de conexionado de un 7 segmentos
Potencimetro
El potencimetro es una resistencia variable que nos retornar un valor del 0 al
1024 en funcin de hacia donde lo giremos. Podemos encontrar potencimetros de
dos tipos: los pequeos para incrustar en placas integradas en los que para variar la
resistencia hemos de usar un destornillador, y los ms grandes que podemos girar a
mano mediante un cilindro saliente. Normalmente usaremos potencimetros de
unos 10k Ohmios, estos podremos adquirirlos en cualquier tienda de electrnica.
A la hora de conectarlos, conectaremos la dos patas de un lado una a 5V y la otra a
GND, y la pata del lado contrario a una de las entradas analgicas [ver Ilustracin 11].
En caso de ser un potencimetro manual (los ms grandes) la pata que hemos de
conectar a la entrada analgica es la que tenemos en el centro.
20
Ilustracin 11: Conexin Potencimetro
En este caso para leer el valor haremos servir la instruccin x=analogRead(5) en

vez de digitalRead:
int x;
void setup(){
Serial.begin(9600);
}
void loop(){
x=analogRead(5);
Serial.println(x);
}
LDR [Foto-resistencia]
Las foto-resistencias o ldr's son resistencias variables en funcin de la luz. En
cualquier tienda de electrnica podremos disponer de diferentes modelos. Es un
sensor muy interesante y relativamente barato.
Al igual que los pulsadores conectaremos una pata tierra (GND) y la otra pata a una
resistencia de unos 10kOhms, y esta a su vez estar conectada a 5V. La entrada
analgica tomar el valor del nexo entre la resistencia y la ldr [Ilustracin 57].
21
Ilustracin 12: Esquema de conexin del sensor LDR.
Ilustracin 13:
fotorresistencias (o LDRs) de
varios tamaos y resistencias
Sensor de proximidad
Los sensores de proximidad que haremos servir son los sharp 2Y0A029. Estos
sensores utilizan tecnologa de infrarojos para detectar a que distancia esta el objeto,
mediante un emisor y un receptor de luz infraroja detectan la distancia a la que esta
el objeto que tenemos delante y nos enva un voltaje mayor o menor en funcin de
la distancia. Existen varios modelos de este tipo de sensores sharp, lo que varia de
un modelo a otro es la precisin a grandes distancias o a cortas, segn el proyecto
utilizaremos unos u otros.
9 Estos sensores se pueden adquirir en http://sparkfun.com

22
Ilustracin 14: Sensor de proximidad

Sharp 2y0a02
A la hora de conectarlos necesitaremos un conector JST de 3 terminales de donde

saldrn 3 hilos de conexin [ Ilustracin 14], 2 para alimentar el sensor (rojo 5V;
negro GND) y un tercero que nos da el valor de distancia. Este tercer hilo (azul
en nuestra fotografa) lo conectaremos a uno de los pines de entrada analgicos y
con la funcin AnalogRead obtendremos el valor del sensor.
Sensor de temperatura
Para medir temperaturas existen bastante tipos de sensores, pero los ms
econmicos son los denominados termistores. Los termistores son resistencias
variables en funcin de la temperatura. Este tipo de sensores son faciles de
encontrar en cualquier tienda de componentes electrnicos. Para leer el valor de
este tipo de sensor tendremos que realizar un montaje equivalente al que hicimos
con las fotorresistencias en la [pgina 21].
Ilustracin 15: Termistor
Acelermetro
Este tipo de sensores se ha popularizado ltimamente por su extensivo uso en
videoconsolas, telfonos mviles y reproductores de msica. Son sensores que nos
envan mayor o menor voltaje en sus salidas en funcin de la aceleracin (y por
tanto tambin su inclinacin) en 2 o 3 ejes (x-y o x-y-z esto depende del sensor). En
el mercado podemos encontrar mltiples versiones de estos sensores, nosotros
utilizamos los adxl 3xxx [Ilustracin 16] de sparkfun10. Dado que estos sensores
10 http://sparkfun.com
23

son algo ms caros hemos de prestar atencin a la hora de conectarlos para no
daarlos. En el caso del sensor adxl 3xxx conectaremos el pin llamado GND a
tierra y el Vin o Vcc a 5V el resto de salidas las podemos conectar directamente a
las entradas analgicas y leer los valores que nos dan con la funcin analogRead de
arduino.
Ilustracin 16:
Acelermetro
Estos sensores acostumbran a dar valores muy diferentes en funcin del modelo
que utilizamos as que es recomendable estudiar los valores que nos envan antes de
montar ninguna aplicacin, tambin es recomendable hacer servir la tcnica de
lectura de ponderacin de entradas explicada en la [pgina 46].
Ilustracin 17: Sensor de torsin y

vibracin
Servomotor
Los servomotores son motores que pueden girar dentro de un rango de 180 con
bastante precisin, si no son muy potentes podemos alimentarlos directamente de la
placa de arduino sin necesidad de alimentacin externa. Existen gran variedad de
potencia y tamao, en funcin del proyecto podemos elegir unos u otros.
24
Ilustracin 18: Servomotor de rotacin no

contnua
Cuando realicemos el montaje conectaremos el cable negro (o marrn) a tierra, el
cable rojo a 5V y el cable blanco (o amarillo) al pin que haremos servir para
enviarles los pulsos de configuracin de la posicin (en las placas arduino los pines
9 y 10).
Ilustracin 19: Ejemplo de control de servomotor que posiciona el motor a 30

grados.
A la hora de programarlo utilizaremos la librera Servo de Arduino, que nos

proporciona una instruccin con la cual podemos indicar los grados concretos a los
que queremos que se posicione [Ilustracin 19].
Servomotor de rotacin continua

Al construir nuestros robots casi siempre utilizamos este tipo de motores por dos
razones: en primer lugar no necesitan circuitera extra ni alimentacin externa, y en
segundo lugar porque son bastante precisos. El tipo de servo continuo que
utilizamos es casi siempre de la casa futuba, el cual podemos adquirir des de la web
de parallax11. Aunque tambin podemos adquirir servos estndar y intentar
convertirlos en servos de rotacin continua [ver pgina 108].
Al igual que los servos no continuos conectaremos el cable negro a tierra (GND), y
el cable rojo a 5V, pero en cable blanco en este caso lo podremos conectar a
cualquier salida digital que tengamos libre.
11 http://www.parallax.com
25

A la hora de programarlos tendremos que enviar un pulso de 20 milisegundos con
una amplitud de la cresta de 1 a 3 milisegundos, segn la amplitud de estos pulsos el
motor girar hacia un lado u otro a mayor o menor velocidad.
Ilustracin 20: Ejemplo para servos de rotacin continua
A veces nos podemos encontrar que los servos estn descalibrados. Para calibrarlo
haremos un programa que enve un pulso de 1,5 ms de duracin (para pararlo) y
con un pequeo destornillador de estrella giraremos el tornillo blanco del servo
hasta que se pare.
26
Ilustracin 21: Detalle del tornillo para calibrar los servomotores

continuos.
Motor DC con TIP120

Al conectar un motor sencillo de corriente continua (motor DC) a nuestra placa
necesitaremos aadir algo de circuitera extra y una fuente de alimentacin externa.
Ilustracin 22: Esquema conexionado para Motor

DC con TIP120
En este caso aadiendo una resistencia de 1kOhmios, un diodo y un TIP120, y un

par de pilas AA podemos controlar un motor de continua conectado a cualquier
salida digital, los inconvenientes de este montaje es que solo podremos hacer rodar
el motor hacia un lado.
27
Ilustracin 23: Cdigo para Motor

DC
Ilustracin 24: Control de Motor DC con TIP120
Motor DC con driver L293

Si invertimos la polaridad de un motor de continua (motor DC) conseguimos que
gire hacia el lado contrario. Para poder hacer esto y para poder suministrar la
alimentacin adecuada a este tipo de motores, la solucin ideal es utilizar lo que se
conoce como un driver de motores DC. Este driver es un chip que alimenta los
motores a un voltage diferente (3V en nuestro caso), y mediante 2 entradas digitales
controlaremos hacia donde gira el motor.
El chip que utilizaremos (L293D o L293NE) nos permite controlar 2 motores de
continua conectando 4 salidas digitales de nuestra placa (2 para cada motor). De
estas dos salidas de cada motor si ponemos la primera a HIGH y la segunda a LOW
28
girar hacia un lado y si lo hacemos a la inversa girar hacia el lado contrario
[Ilustracin 25].
Ilustracin 25: Conexin Motor DC con chip L293
Ilustracin 26: Cdigo controlador MotorDC
Sensor RFID (IDentificacin por RadioFrecuencia)

La identificacin por radiofrecuencia es una tecnologa muy utilizada en el mundo
de la logstica. Unos diminutos chips (a veces del tamao de micras) tienen un
cdigo independiente cada uno y al pasarlos por delante de un sensor RFID estos
chips envan un cdigo nico de 128 bits. Estos diminutos chips los tenemos en
tarjetas de identificacin, chapas, etiquetas o llaveros. Y sean del fabricante que
sean, al pasar por delante de un sensor de RFID, este capta el cdigo de
29

identificacin. Nosotros utilizaremos el sensor ID-12 que podemos adquirir en
sparkfun12 por ejemplo.
Ilustracin 27: Esquema de conexiones del sensor de RFID
En nuestro caso conectaremos el sensor ID-12 a un chip FTDI conectado

directamente al puerto USB de nuestro PC para despus recibir los datos
directamente en processing.
import processing.serial.*;
Serial puerto;
String datos="";
void setup() {
size(600,200);
println(Serial.list());
puerto=new Serial(this, Serial.list()[1], 2400);
puerto.buffer(12);// El puerto [1] depende en funcin del PC
}
void draw() {
background(0);
println(datos);
}
void serialEvent(Serial puerto) {
datos=trim(puerto.readString());
}
Arduino
La placa arduino es una placa para proyectos que integra un microcontrolador
amTel, un controlador de comunicacin USB, y un controlador de alimentacin
externa. Desde nuestro PC programaremos el comportamiento de la placa en
funcin de las entradas y salidas que posee desde un lenguaje de alto nivel,
enviaremos el programa y este quedar grabado en la placa hasta que lo
12 http://sparkfun.com
30
modifiquemos. Tambin podremos utilizar la conexin USB para enviar mensajes
entre el PC y Arduino, o podremos conectar una fuente de alimentacin externa a la
placa (pila de 9V) para que esta acte de forma autnoma.
En nuestro caso decidimos utilizar arduino bsicamente porque al ser un sistema de
software y hardware libre, existen muchsimos proyectos ya desarrollados y
evolucionados, y porque el software es muy fcil de utilizar. Y por supuesto por la
satisfaccin de contribuir al desarrollo y la promocin de un proyecto de software
libre como este.
Ilustracin 28: Esquema conexiones placa arduino
Como podemos observar en la [Ilustracin 28] la placa posee 14 salidas/entradas

digitales (verde) donde podemos enviar/recibir valores de 0(LOW) o 1(HIGH); 6
entradas analgicas donde podremos recibir valores del 0 al 1024 (rojo); y 6 salidas
analgicas (entradas digitales marcadas con PWM) donde podremos enviar valores
del 0 al 255; tambin disponemos de 3 conexiones a tierra (amarillo); conexiones a
3,3V y 5V (lila); y un botn de reset que nos permite reiniciar el software que hay
almacenado en la placa. Podemos obtener ms informacin sobre como funciona la
placa arduino en la pgina web oficial de arduino13.
PicoBoard o ScratchBoard
La PicoBoard (antigua ScratchBoard) es una placa diseada para trabajar con el
software Scratch. Scratch es un software educativo diseado por el grupo de
desarrollo KinderLifeLong del MiT para ensear a programar a nios y nias
desde una edad muy temprana. El potencial de este software reside en su interface
que funciona ensamblando bloques (similares a los de lego), y esta pensada para que
los chicos y chicas creen sus propias animaciones y juegos, y acto seguido los
publiquen en la pgina http://scratch.mit.edu.
13 http://arduino.cc
31

Desde esta web, chicos y chicas de todo el mundo pueden compartir, modificar y
comentar juegos y animaciones de otros usuarios.
Ilustracin 29: PicoBoard, placa de sensores para trabajar con Scratch
Parte de estos bloques de lego de la interface de scratch sirven para controlar los
datos que provienen de la placa scratchboard.
Esta placa enva a scratch los valores de los diferentes sensores que posee: un
micrfono, un botn, una barra deslizadora, un sensor de luz, y cuatro sensores de
resistividad. De esta forma podremos disear animaciones y juegos que interactuan
con los datos que provienen del exterior.
Ilustracin 30: Detalle de los sensores incorporados en la picoBoard. Azul:

sensores de resistencias, Rojo: sensor de luz, Verde: Micrfono, Naranja:
barra deslizadora, Fucsia: Botn
32
33
Ilustracin 31: Air Graffity por Jordi R., Jose E. y David A.
34
Programacin
Este libro no pretende ser un manual de programacin, el nico objetivo es dotar al
usuario inexperto de las nociones bsicas para entender el funcionamiento de
programas simples, y poder empezar a desarrollar el software necesario para sus
montajes de computacin fsica. Para todo aquel que pretenda profundizar en
alguno de los lenguajes de programacin que se tratan en este libro, seria interesante
que consulte las diversas webs14 que se anotan en los pies de pgina, o que pruebe la
infinidad de ejemplos que se pueden encontrar por la web. Si es la primera vez que
lees este captulo te pierdes en algunos temas... no te preocupes!. Intenta entender
lo bsico, prueba ejemplos, cambia valores, experimenta... Y ms tarde, cuando
releas el captulo ya empezars a entender el resto de conceptos.
Secuencias de instrucciones
Un programa o algoritmo no es ms que un conjunto de instrucciones que se
ejecutan de forma secuencial, es decir, una detrs de la otra.
Normalmente en cada lnea especificaremos una instruccin. Si la lnea empieza por
// estamos indicando que esa lnea es un comentario y no se tendr en cuenta a
efectos prcticos.
Illustration 32: Comentarios, parmetros, funciones y terminadores de lneas
Normalmente cada lnea realizar una llamada a una funcin y entre parntesis
indicaremos los parmetros necesarios. Una funcin es una instruccin que realiza
una tarea concreta. Lo parmetros indicados proporcionan a la funcin los datos
necesarios para realizar su tarea. Por ejemplo la funcin digitalWrite de arduino
necesita dos parmetros el pin en el que queremos escribir y que valor deseamos
escribir, as por ejemplo digitalWrite(3,HIGH) escribir un HIGH en el pin 3 de
la placa. Donde HIGH significa poner a 5V la salida y LOW ponerla a 0V.
En los entornos de programacin de processing y de arduino, tendremos que
definir por defecto dos funciones base: la funcin setup que se encarga de realizar
todas las funciones de inicializacin; y la funcin loop en arduino ( o draw si
utilizamos processing ) donde indicamos las tareas que debe realizar nuestro
14 http://arduino.cc; http://processing.org; http://scratch.mit.edu
35

programa. Esta funcin loop o draw es un bucle infinito que se itera hasta
desconectar la placa o parar el programa [ver ilustracin 33]
Illustration 33: Estructura de un programa en processing
En el ejemplo de la [ilustacin 33] realizado en processing, dentro del apartado de

setup llamamos a la funcin size(300,300) para pedirle a processing que cree una
ventana de 300x300 pixeles. Una vez dentro del apartado draw usamos la funcin
background(0) para pedirle que borre la pantalla con el color 0 (negro), y con la
funcin rect(100,100,100,100) definimos un rectngulo que empieza en el punto
100, 100 y con tamao de 100x100.
Variables
Una variable es un espacio de la memoria RAM reservado por nuestro programa
para almacenar un valor de cualquier tipo. Segn el tipo de dato que queramos
guardar declararemos variables de tipo: int, char, string, boolean byte, color, float, etc.
Las variables se declaran al principio del programa y podremos hacer referencia a
ellas escribiendo nicamente su nombre.
36
Programacin
Ilustracin 34: Ejemplo del uso de una

variable
En este ejemplo de arduino, la primera instruccin indica nuestro deseo de utilizar

una variable llamada x para almacenar un nmero entero int. Este nmero lo
haremos servir para controlar la velocidad con la que se enciende y apaga lo que
tengamos conectado al pin 2 de arduino. Para ello dentro del apartado setup lo
primero que haremos es asignar a x el tiempo en milisegundos que queremos que
espere, y acto seguido declaramos el pin 2 de nuestro arduino como una salida.
Dentro del programa principal loop lo que haremos ser activar el pin 2 con la
instruccin digitalWrite, esperar el nmero indicado de milisegundos con la
instruccin delay, desactivar la salida del pin 2 escribiendo en este un LOW y
volver a esperar la misma cantidad de milisegundos nuevamente con un delay.
Condicionales
Los elementos condicionales sirven para interrumpir la secuencialidad del programa
y bifurcar en dos posibles programas distintos en funcin de una condicin. Por
ejemplo:
37
Ilustracin 35: Ejemplo de uso del condicional

"if"
En este ejemplo de processing podis observar como el condicional if divide la

ejecucin en dos posibilidades. Si key=='a', es decir, si se ha pulsado una a
dibujar un rectngulo, en caso contrario (else) dibujar una elipse.
En cualquier instruccin condicional necesitamos definir la condicin (el key==a
de nuestro ejemplo). Estas condiciones se construyen mediante los operadores
bsicos:
Operador
Ejemplo
Descripcin
> (mayor que)
if ( x > 3 )
si la x es ms grande 3 ...
< (menor que)
if ( x < 5 )
si la x es menor que 5 ...
>= (mayor o igual que)
if ( x >= 5 )
si la x es mayor o igual que 5
<= (menor o igual que)
if ( x <= 5 )
si la x es menor o igual que 5
== (igual que)
if ( x == 5 )
si x es igual a 5 ...
!= (diferente que)
if ( x != 5 )
si la x es diferente a 5 ...
|| (o lgica)
if ( x == 3 || x == 5)
si la x es 3 o 5 ...
&& (y lgica)
if ( x<3 && x >0)
si la x es mayor que 0 y menor

que 3 ...
! (no lgico)
if ( ! ( x ==8) )
si no es cierto que la x es igual

a 8 ...
Bucles
Los bucles o iteraciones, las haremos servir para ahorrar lneas de cdigo cuando
escribimos estructuras repetitivas.
38
Programacin
Por ejemplo los dos programas que veremos a continuacin tienen un mismo
resultado en su ejecucin, pero como podris observar el segundo ejemplo es
mucho ms corto.
Programa secuencial
size(200,200);
line(20,20,20,180);
line(30,20,30,180);
line(40,20,40,180);
line(50,20,50,180);
line(60,20,60,180);
line(70,20,70,180);
line(80,20,80,180);
line(90,20,90,180);
line(100,20,100,180);
line(110,20,110,180);
line(120,20,120,180);
line(130,20,130,180);
line(140,20,140,180);
Programa iterativo
size(200,200);
int i;
for (i=20; i<150; i=i+10) {
line(i, 20, i, 180);
}
Bucle contador. FOR

La instruccin for recibe 3 parmetros separados por ; el primer parmetro es el
valor inicial de la variable, el segundo parmetro es la condicin que se ha de
cumplir para que el bucle siga repitindose y por ltimo, el tercer parmetro indica
que ha de hacer la variable al acabar cada iteracin del bucle. Despus abriremos
una llave y escribiremos todo aquello que queremos que repita en cada iteracin, y
al finalizar cerramos la llave.
for(i=0; i<150; i =i+10) {
print(hola);
}
Podramos leer este ejemplo como: Para una variable y que empieza valiendo 0, mientras
sea ms pequea que 150, sumale 10 a cada iteracin, y en cada iteracin escribe hola en
pantalla. El resultado seria la palabra hola escrita 15 veces en pantalla. Si
cambiamos i=i+10 por i=i+1 la escribira 150 veces.
FOR's anidados - [Nested Loop]
Esta tcnica consiste en introducir un bucle dentro de otro. Esto es muy til por
ejemplo para recorrer un array bidimensional como por ejemplo una imagen o un
espacio cartesiano. (no te preocupes si esto suena un poco a chino... ya veremos
ms adelante un ejemplo ms prctico).
Ejemplos:
int y;
int y;
39

int x;
int x;
for(y=0; y<100; y=y+10) {
for(y=0; y<100; y=y+10) {
for(x=0; x<100; x=x+10) {
for(x=0; x<y; x=x+10) {
point(x,y);
line(x,y,x+6,y+6);
}
line(x+6,y,x,y+6);
}
}
}
int y;
int x;
int x;
int y;
noStroke();
fill(0,76);
for(y=0; y<100; y=y+10) {
noStroke();
for(x=0; x<100; x=x+10) { smooth();
fill((x+y)*1.4);
for( y=-10; y<=100; y=y+10) {
rect(x,y,10,10);
for( x=-10; x<=100; x=x+10) {
}
ellipse(x+y/8,y+x/8,15+x/2,10);
}
}
}
Para comprender su funcionamiento sera interesante que copies estos ejemplos en

processing y vares los parmetros para ver que sucede.
Bucle condicional While
Un bucle condicional es un bucle que se ejecuta una y otra vez mientras se cumple
una condicin por ejemplo:
while ( key != 'A' ) {
println(Pulse la tecla A);
}
Este ejemplo escribe en pantalla Pulse la tecla A mientras no pulsemos esta tecla.
Como podis ver lo que tenemos entre parntesis es la condicin que se ha de
cumplir para que el bucle siga repitindose y lo que tenemos entre llaves son las
instrucciones que queremos que repita.
Funciones y procedimientos
Cuando los programas que diseamos empiezan a hacerse grandes, es importante
hacer divisiones de ciertas partes del programa para encapsularlas y poderlas
reutilizar y modificar como unidades independientes.
Las funciones son solo etiquetas que ponemos a ciertas partes del cdigo con el
nimo de poder reutilizarlas ms adelante. Como ejemplo realizaremos una funcin
llamada dibujar_estrella(x,y) de forma que cuando escribamos dibujar_estrella(3,2)
nos dibujar una estrella en el punto 3,2. De esta forma podremos utilizar la funcin
siempre que necesitemos dibujar una estrella en cualquier punto.
void setup(){
40
Programacin
size(100,100);
}
void draw() {
dibuixa_estrella(16,20);
dibuixa_estrella(0, 10);
dibuixa_estrella(25,2 );
}
void dibuja_estrella(int x, int y) {
line(x,
y, x+10, y+10);
line(x+10, y, x,
y+10);
}
Hasta el momento hemos visto funciones a las que llamamos con unos parmetros
y realizan un trabajo en funcin de esos parmetros. Ahora podramos hacer que
una funcin que recibe parmetros nos retorne un valor. Para ello vemos como
implementar una funcin que nos calcula la media aritmtica de dos nmeros.
void setup() {
size(300,300);
}
void draw() {
int r;
r=media(3,7);
println(r);
}
int media( int n1, int n2) {
int resultado;
resultado = int ( (n1+n2)/2 );
return resultado;
}
Nota: la funcin int( ) nos redondea el resultado de una
operacin.
Sobrecarga de operadores
En los lenguajes de programacin orientados a objetos existe un fenmeno llamado
sobrecarga de operadores, segn el cual podemos definir una funcin varias veces pero
con diferente nmero de parmetros. As podremos hacer que segn los parmetros
que recibe una funcin esta realiza una tarea u otra. En nuestro ejemplo
sobrecargamos la anterior funcin media para que funcione con 2 o con 3
parmetros.
41

void setup(){
noLoop();
}
void draw() {
println( media(3,4,6) );
println( media(3,4)
);
}
int media( int n1, int n2) {
int resultado;
resultado = int( (n1+n2)/2 );
return resultado;
}
int media( int n1, int n2, int n3) {
int resultado;
resultado = int( (n1+n2+n3)/2 );
return resultado;
}
Clases
Dentro de la programacin orientada a objetos, todo el software que desarrollamos
lo organizamos en clases. Una clase es una coleccin de variables y de funciones
que definen una entidad. Definamos por ejemplo la clase pelota:
class Pelota {
int
int
int
int
int
x;
y;
vx;
vy;
radio;
Pelota(int tempX, int tempY, int tempVx, int tempVy) {

x
= tempX;
y
= tempY;
vx = tempVx;
vy = tempVy;
}
void actualizar() {
x = x + vx;
y = y + vy;
}
void pintar() {
fill(200,0,0);
ellipse(x,y,radio,radio);
42
Programacin
}
}
Como podis observar la definicin de la clase empieza por la palabra class y el

nombre de la clase. Lo siguiente que encontramos son las variables de la clase. A
continuacin encontramos una funcin con el mismo nombre que la clase, esta
funcin se le llama el constructor y se llama automticamente al crear la clase,
nosotros la usaremos para inicializar las variables de la clase con los parmetros que
hemos llamado a la funcin.
Por ltimo tenemos las funciones propias de la clase. En nuestro caso hemos
definido la funcin pintar que dibuja una elipse en pantalla usando x,y para
indicar la posicin donde se dibuja la elipse. Y tambin tendremos definida una
funcin actualizar que hace variar los valores de la posicin de la pelota x,y para
que la pelota se vaya moviendo por la pantalla.
Veamos ahora el programa principal donde se utiliza la clase pelota:
Pelota balon;
void setup() {
size(200, 200);
balon = new Pelota(20,30,2,2);
}
void draw() {
background(0);
balon.actualizar();
balon.pintar();
println(balon.x + , + balon.y);
delay(100);
}
Para utilizar la clase , en primer lugar creamos un objeto llamado balon de tipo
pelota y despus desde el setup llamamos al constructor para inicializar los valores
de nuestro balon (mirar seleccin amarilla). Este objeto balon hereda todas las
propiedades y funciones de la clase pelota. Por ejemplo podemos acceder a la
variable x haciendo balon.x=30 o llamar a la funcin actualizar haciendo
balon.actualizar().
43
Ilustracin 36: Pulsamos en new tab para crear una

clase en un archivo externo
El cdigo de la clase lo podemos aadir al final de nuestro programa o en un

archivo separado (esta ltima opcin es la ms interesante organizativamente). Para
ello pulsamos el botn con una flecha dibujada a la derecha de todo y elegimos
New Tab, ms tarde nos pedir el nombre de la clase asegurate de poner el mismo
nombre a la clase que al archivo donde se guardar es importante.
Ilustracin 37: Escribimos el nombre del archivo que

ha de ser el mismo que el de la classe
Aleatoriedad
La funcin random, nos permitir generar valores aleatorios entre un rango de
valores que nosotros indiquemos. Por ejemplo random(0,12) nos generar un
nmero aleatorio entre el 0 y el 12. Dado que los nmeros generados contienen
decimales, utilizaremos la funcin int() para convertirlo en un nmero entero. Si
deseamos un nmero entero aleatorio entre el 0 y el 100 escribiremos
x=int(random(0,100)); de esta forma almacenamos en la variable x un nmero al
azar entre el 0 y el 100 sin decimales.
int x;
int y;
void setup()
{
size (300,300);
}
void draw()
{
x=int(random(0,300));
y=int(random(0,300));
ellipse(x,y,30,30);
}
44
Programacin
Arrays, arreglos o matrices

Para implementar ciertas aplicaciones necesitamos almacenar grandes cantidades de
datos. Para ello, en vez de declarar montones de variables declararemos un vector o
matriz, que no es ms que una sola variable con mltiples posiciones donde
podemos guardar ms de un dato. A efectos prcticos se comporta como variables
diferentes pero con la ventaja de que tiene el mismo nombre.
Ilustracin 38: Esquema de funcionamiento

de un array
En la [ilustracin 38] podis ver en primer lugar una variable comn var0. Esta
variable se declarar escribiendo la instruccin int var0; y se le asignaran valores
escribiendo var0=3;. La variable var1 es lo que denominamos un vector o array
unidimensional lo declararemos haciendo int[ ] var1= new int[3]; donde el 3 es
el nmero de posiciones que tiene este array unidimensional. Para escribir un valor
en alguno de las posiciones de la variable utilizaremos la instruccin var1[1]=3;,
donde el 1 es alguna de las 3 posiciones posibles (0,1,o 2).
int
var0;
int[]
var1 = new int[3];
int[] [] var2 = new int [3][3];
var0 = 3;
var1[1] = 8;
var2[1][2] = 8;
Estos arrays se pueden hacer de una dimensin, dos o todas las que queramos. En
espaol tambin se les suele denominar vectores, o matrices.
45
Programacin Avanzada
Normalizacin de valores
En muchas ocasiones tendremos un sensor que nos enviar valores de un rango
concreto y tendremos que reescalar a otro rango distinto. Para ello cualquier valor
de entrada lo normalizaremos a un rango de 0 a 1 con la funcin norm.
norm ( valor, mnimo, mximo);
por ejemplo: norm ( 0, 0, 255) Retorna 0
por ejemplo: norm (102, 0, 255) Retorna 0.4
por ejemplo: norm (255, 0, 255) Retorna 1
Ponderacin de entradas
Cuando trabajamos con sensores uno de los problemas que podemos tener es que
cada cierto tiempo el sensor lea un valor errneo. Para evitar estos picos de valores
aleatorios haremos una lectura ponderada de los sensores, es decir, que la lectura
actual del sensor no es la definitiva sino que varia en porcentaje la lectura anterior:
Vactual = Vanterior 0,8 + Vactual 0,2

Estos porcentajes de 0,8 para el valora anterior y de 0,2 para el valor actual, se
pueden variar siempre y cuando ambos sumen 1. Si incrementamos el peso del
valor anterior nuestra aplicacin no tendr picos pero sera de respuesta lenta. Si lo
hacemos al contrario lo que tendremos ser que la respuesta a cambios ser ms
rpida, pero los picos errneos nos pueden afectar ms.
Calibracin y calibracin dinmica de sensores

Cuando en uno de nuestros montajes conectamos un sensor a una entrada
analgica, el sensor nos devuelve un nmero del 0 al 1024. No obstante en funcin
del sensor el valor mnimo que recibiremos es muy posible que no sea 0 y el valor
mximo no sera 1024. As pues, hemos de realizar una calibracin para obtener
valores dentro de un rango estimado. Por ejemplo si queremos obtener valores con
rango de 0 a 100, aplicaremos la siguiente frmula:
Vfin=
Vact Vmn
x 100
VmxVmn
Donde Vfin es el valor definitivo de 0 a 100; Vact es el valor ledo del sensor; Vmn
es el valor mnimo que puede obtenerse del sensor y Vmx es el valor ms grande
que nos puede dar nuestro sensor.
46
Tambin nos podemos encontrar el valor numrico que recibimos depende en gran
parte de las condiciones ambientales del entrono donde se encuentra nuestro
montaje. Es por ello que un mismo montaje puede darnos unos valores u otros en
funcin del lugar donde se encuentra. Para resolver este problema, a la frmula
anterior aadiremos un par de consideraciones respecto a los valores Vmn y Vmx.
if( Vact < Vmn) Vmn=Vact;

if( Vact > Vmx) Vmx = Vact;
Con estos ajustes conseguiremos una calibracin dinmica, es decir el valor de
nuestro sensor se adaptar a las condiciones ambientales de donde se encuentre
dndonos valores siempre entre 0 y 100 donde 0 ser el valor mnimo y 100 el valor
mximo, independientemente del lugar donde se encuentra el montaje instalado.
Trucos para evitar usar bucles y delays

Cuando desarrollamos aplicaciones para uso en tiempo real (es decir con una
respuesta rpida acotada en un determinado intervalo de tiempo), hemos de evitar
siempre el uso de delays (retardos) o bucles, as evitamos retrasos en el tiempo de
respuesta. Para controlar entonces el tiempo que pasa, o las repeticiones que se han
hecho usaremos la funcin milis(). Esta funcin retorna el nmero de milisegundos
que han pasado desde que se inici el programa. Con un par de variables y esta
funcin podemos controlar cuantos segundos han pasado, o hacer que el programa
haga alguna accin concreta en un tiempo determinado, o cada cierto tiempo.
En este ejemplo veremos como hacer que una
secuencia de instrucciones se ejecute cada segundo.
int tiempo_inicial;
int tiempo_actual;
void setup() {
tiempo_inicial=millis();
}
void loop() {
tiempo_actual=millis();
if (tiempo actual > tiempo_inicial + 1000) {
//.... aqu escribiremos la secuencia
tiempo_inicial=millis();
}
}
Recursividad
La recursividad es una tcnica que utilizamos para resolver ciertos problemas de
una forma ms simple y a veces ms efectiva
47

La idea principal es implementar una funcin que se llama a si misma hasta que
llega un punto donde retorna un valor final. Como ejemplo crearemos una funcin
que dibuja un crculo y se llama a si misma para dibujar ms circulos dentro hasta
que el radio es 0.
int x=63;
int r=85;
int n=6;
void setup(){
size(100,100);
noStroke();
smooth();
noLoop();
}
void draw() {
dibuija_circulo(63,85,6);
}
void dibuija_circulo(int x, int radio, int num) {
ellipse(x,50,radio*2, radio*2);
if (num>1) {
num=num-1;
dibuija_circulo(x-radio/2, radio/2, num);
dibuija_circulo(x+radio/2, radio/2, num);
}
}
Comunicacin por USB

En esta seccin veremos como conectar el programa que lee las entradas desde
arduino con otro programa ejecutndose dentro del computador.
La comunicacin en este caso se hace por un puerto serie que puede ser el cable
USB o un bluetooth si lo tenemos conectado. En ambos casos tendremos que
seleccionar el puerto COM correspondiente, para ello haremos que nuestro
programa dentro del setup() imprima todos los puertos disponibles, as pues solo
tendremos que cambiar el [1] por el nmero de puerto que utilicemos.
El programa que tenemos a continuacin realiza una conexin processing
arduino. Procesing enva un carcter 49 a arduino y este lo imprime en pantalla.
void setup() {
puerto=new Serial(this, Serial.list()[1],9600);
}
void draw() {
48
puerto.write(49);
}
void setup() {
Serial.begin(9600);
}
void loop() {
if (Serial.available() > 0) {
int leido = Serial.read();
println(leido);
}
}
En este ejemplo vamos a conectar 2 botones y 2 potencimetros de 4k7 a arduino,

y este nos enviara los valores de las 4 entradas al PC mediante la conexin USB.
Por otro lado el programa realizado en Processing leer esos valores y los mostrar
por pantalla.
int
int
int
int
sensorIzq = 0;
sensorDer = 1;
resetBot = 2;
serverBot = 3;
int
int
int
int
valorIzq = 0;
valorDer = 0;
reset = 0;
server = 0;
void setup() {
Serial.begin(9600);
pinMode(resetBot, INPUT);
pinMode(serverBot,INPUT);
}
void loop() {
valorIzq = analogRead(sensorIzq);
valorDer = analogRead(sensorDer);
reset = digitalRead(resetBot);
server= digitalRead(serverBot);
Serial.print(valorIzq, DEC);
Serial.print(",");
Serial.print(valorDer,DEC);
Serial.print(",");
Serial.print(reset,DEC);
Serial.print(",");
Serial.println(server,DEC);
//En la ultima linea hacemos println para indicar fin
}
49

import processing.serial.*; //libreria de comunicaciones
int linefeed=10;
Serial puerto;
void setup() {
println(Serial.list()); //imprimir todos los puertos serie
puerto.bufferUntil(linefeed);
}
void draw() {
}
void serialEvent(Serial puerto) {
String cadena=puerto.readStringUntil(linefeed);
if(cadena!=null) {
cadena= trim(cadena); //Separa la cadena por comas
int token[]=int(split(cadena, ',')); //convierte a int
for(int num=0; num<token.length; num++) {
print("Token "+num+":"+token[num]+"\t");
}
println();
}
}
Comunicacin Arduino-Processing con Firmata

Firmata es un standard para comunicar microcontroladores por el puerto USB. Para
hacerlo servir cargamos el software de firmata en nuestra placa arduino, desde
processing importamos la librera de firmata y creamos un objeto llamado arduino
desde
el
cual
nos
comunicaremos
con
arduino.
Pasos para instalar Firmata:

1.- Descarga el software firmata de esta direccin web:
http://www.arduino.cc/playground/Interfacing/Processing
2.- Descomprime la carpeta "arduino" dentro de la carpeta "libraries" en la carpeta
"Processing".
3.- Copia la carpeta "Firmata" dentro de la carpeta "hardware/libraries" de la
carpeta de "Arduino". [Este paso es posible que no sea necesario, las ultimas
versiones de arudino ya lo incorporan de serie].
4.- Ejecuta arduino y carga el programa "standard_firmata_sketch" que encontrars
50
en "Examples/Library-Firmata/Standard-Firmata-Sketch". Compilalo y cargalo en
tu placa arduino.
5.- Ejecuta processing y carga alguno de los ejemplos de processing. [Mirar ejemplo
al final de este apartado]
6.- Seguramente tendrs que cambiar el nmero del puerto serie donde esta
conectado arduino. Cambia el 0 por algun otro nmero en la siguiente instruccin:
"Arduino.list()[0]"
7.- Ejecuta el ejemplo... y sobre todo prueba cosas sin miedo!
import cc.arduino.*;
Arduino arduino;
void setup()
{
println(Arduino.list());
arduino = new Arduino(this, Arduino.list()[0]);
arduino.pinMode(13, Arduino.OUTPUT);
}
void draw()
{
arduino.digitalWrite(13, Arduino.HIGH);
delay(1000);
arduino.digitalWrite(13, Arduino.LOW);
delay(1000);
}
51
Proyectos online [ PHP+MySql ]

Uno de los grandes potenciales del lenguaje Processing.org es la facilidad que tiene
para trabajar con herramientas web. En nuestro caso nos interesa para conectar
nuestros proyectos a la web de forma relativamente fcil.
Desde processing podemos consultar una web, o enviar informacin a esta. As

pues, si diseamos una web conectada a una base de datos online, podremos hacer
que nuestros montajes enven o reciban informacin de la web. Con lo cual
obtendramos una comunicacin bidireccional Internet Arduino.
Montar un servidor web con tecnologa Php+Mysql

Para probar nuestras pginas web con tecnologa php+mysql, podemos hacer dos
cosas: contratar un hosting que soporte esta tecnologa (o buscar alguno gratuito), o
montarnos nuestro propio servidor. Para montar un servidor web con soporte para
base de datos sobre windows, descargaremos e instalaremos la aplicacin
wampserver 15 (o alguna otra similar).
15 http://www.wampserver.com
52
Ilustracin 39: Panel de control del

servidor
Una vez instalado pulsaremos el icono con un dibujo de un cuentakilmetros que

aparecer en la barra de tareas, y se desplegar un men desde donde podemos
controlar todos los parmetros de nuestro servidor. En primer lugar pulsaremos
encender para iniciar todos los servicios. Una vez iniciado desde localhost
accedemos a la pgina inicial de nuestro servidor, desde phpmyadmin gestionamos
las bases de datos de nuestro servidor, y desde directorio www accedemos a la
carpeta donde tenemos las paginas almacenadas.
Ilustracin 40: Detalle de la configuracin de los campos
Una vez activado lo primero que haremos es crear una base de datos simple. Para
ello cargamos el phpmyadmin y creamos una base de datos llamada datos, despus
creamos una tabla con el mismo nombre y dos campos. Cuando nos pida el tipo de
campo lo rellenaremos tal y como indica la ilustracin 40.
53
Ilustracin 41: Detalle de la tabla ya creada
Una vez creada, ahora veremos en el siguiente captulo como crear un par de
pginas web para consultar y modificar la informacin almacenada en la base de
datos.
Consultar una base de datos desde una web

Ahora realizaremos una pgina web simple que muestra por pantalla cada uno de
ellos elementos almacenados en la tabla anterior.
<html>
<head>
<title>Consulta de Base de datos</title>
</head>
<body>
<?php
$conexion = mysql_connect("localhost", "root", "");
mysql_select_db("datos", $conexion);
$queEmp = "SELECT * FROM datos WHERE 1";
$resEmp = mysql_query($queEmp, $conexion) or
die
( mysql_error() );
$totEmp = mysql_num_rows($resEmp);
if ($totEmp> 0) {
while ($rowEmp = mysql_fetch_assoc($resEmp)) {
echo "<b>".$rowEmp['id']."</b>";
echo ": ".$rowEmp['dato']."<br>";
}
}
?>
</body>
</html>
Todo el cdigo que se halla entre <?php y ?> es cdigo php que trabaja
directamente contra la base de datos y nos retorna cdigo HTML con los datos
que recoge de la base de datos. Fijaos que en la lnea $conexion=mys...
especificamos el nombre del servidor (que sera o bien localhost o bien la ip de
nuestro servidor), el nombre del usuario para autentificarse en el servidor, y la
contrasea. Como podis observar el nombre es root y la contrasea es inexistente
54

estara bien crear un usuario desde el phpmyadmin y asignarle una contrasea, para
evitar problemas de seguridad.
Insertar datos en una base de datos desde una web

A la hora de insertar datos en una web utilizaremos el mtodo GET, este mtodo
consiste en pasar los datos que queremos insertar a la web dentro del mismo
nombre de la web. Es decir, cuando en el navegador cargamos el nombre de la
pgina que queremos ver aadiremos al coletilla ?valor=XXX donde XXX es el
valor que queremos enviarle a la web para que esta lo inserte en la base de datos.
Por ejemplo, si en el navegador escribimos http://localhost?valor=a, la web recibir
una a y la insertar en nuestra base de datos.
<html>
<head>
<title>Insercin en la Base de datos</title>
</head>
<body>
<?php
if(isset($_GET['valor'])) {
$valor=$_GET['valor'];
$queEmp = "INSERT INTO datos(dato) VALUES('".$valor."')";
die(mysql_error());
}
?>
</body>
</html>
Como podis observar el cdigo unicamente comprueba que se ha pasado como

parmetro la variable valor, y entonces inserta en la base de datos el dato concreto.
Eliminar datos de la base de datos desde una web

La mayora de veces nos interesar obtener unicamente el primer valor de la tabla y
eliminarlo. As nuestro montaje ir leyendo los valores de la tabla, los interpretar y
los eliminar para no repetir acciones.
<html>
<head>
<title>Consulta y eliminacin de la Base de datos</title>
</head>
<body>
<?php
55

$queEmp = "SELECT * FROM datos WHERE 1";
die(mysql_error());
$totEmp = mysql_num_rows($resEmp);
//*******************************
if ($totEmp> 0) {
$rowEmp = mysql_fetch_assoc($resEmp);
echo $rowEmp['dato']."<br>";
$queEmp = "DELETE FROM datos WHERE id='".
$rowEmp['id']."'";
die(mysql_error());
}
?>
</body>
</html>
El cdigo como podis observar es muy similar al cdigo de la consulta, con la

nica diferencia que obtenemos solo el primer valor y usamos este para ejecutar
otra consulta en este caso de eliminacin.
Enviar datos a una web desde processing

Para enviar datos a nuestra web utilizaremos el mtodo GET de HTML. El mtodo
GET consiste en aadir los valores que queremos enviar al nombre de la web
cuando la cargamos en nuestro navegador. Por ejemplo si escribimos
http://localhost/insertar.php?valor=hola, estamos enviando el dato hola a la variable
valor de la pagina web insertar.php de nuestro servidor.
import processing.net.*;
Client c;
String data;
boolean peticion;
void setup() {
c = new Client(this, "localhost", 80);
insertarWeb("hola");
}
void draw() {
}
void insertarWeb(String dato) {
c.write("GET /insertar.php?valor="+dato+" HTTP/1.1\n");
c.write("Host: ejemplo.com\n\n");
peticion=true;
}
56

Como podeis ver la funcin insertarWeb lo nico que hace es hacer una llamada a
la web insertar.php aadiendo el valor que le pasamos a la funcin como
parmetro.
Recibir datos de una web desde processing

Una vez que tenemos montado el servidor web y el servidor de base de datos.
Hemos de crear una web (http://localhost/datos/prueba.php) y crearemos tambin
un programa en processing que consulta esta pgina web y obtiene los valores de
la base de datos.
Client cliente;
boolean peticion = false; // Es "true" si hemos consultado
String resp = "";
// Guarda la respuesta del servidor
String respuesta = "";
void setup() {
}
void draw() {
// Hacemos una consulta al servidor
makeHTTPCall(); // web y separamos los datos recibidos
if(resp!=null) {// en "tokens"
resp = trim(resp);
int token[]=int(split(resp, ','));
for (int x=0; x<token.length; x++) {
print("He recibido:");
println(token[x]);
}
resp = "";
}
if (peticion == true) checkNetClient();
}
void makeHTTPCall() {
// Esta funcin envia la peticin web al servidor
// para que checkNetClient reciba la respuesta
if (peticion == false) {
cliente = new Client(this, "localhost", 80);
cliente.write("GET /datos/prueba.php HTTP/1.0\n");
cliente.write("HOST: localhost\n\n");
peticion = true;
}
}
void checkNetClient() {
// Esta funcin recibe las respuesta web
// y la almacena en la variable "resp"
if (cliente.available() > 0) {
respuesta += char(cliente.read());
57

} else {
if( respuesta.length() > 0) {
if(peticion==true) {
resp = respuesta;
peticion=false;
respuesta="";
}
}
}
}
58
Proyectos con la ScratchBoard

Los proyectos con Scratch que se describen a continuacin necesitan unos
conocimientos previos mnimos, al menos es recomendable haber desarrollado
todas las actividades disponibles en las scratchCards16
El perro saltarn
En este primer proyecto con la picoboard utilizaremos el sensor de sonido para
hacer que un perro salte cuando le gritamos. Para acabar de completar el juego
crearemos un gato, al que el perro debe esquivar saltando, que aparecer por un
lugar aleatorio cada vez.
Ilustracin 42: Proyecto Scratch del perro saltarn
En primer lugar mapearemos el valor del sensor a la posicin y (altura) de donde se

dibuja el perro.
Ilustracin 43: Mapeo del valor del sensor a la altura del perro.
Como podis observar simplemente corregimos el valor multiplicando por 2 y

restando 150. En el caso del gato el programa es un poco ms complejo, tendremos
que hacer que se mueva de derecha a izquierda y que al llegar a la izquierda vuelva a
salir por la derecha en una altura aleatoria.
16 http://info.scratch.mit.edu/@api/deki/files/798/=SC_es.zip
59

Unicamente nos queda aadir un condicional que detecte si el gato toca al perro y
pare el juego[Ilustracin 44].
Ilustracin 44: Cdigo para el personaje del gato.
Cangrejos del espacio exterior

En este segundo proyecto utilizamos el slider (barra deslizadera) y el botn para
controlar un cangrejo que surca el espacio y dispara pinzas. La complejidad de este
proyecto reside en el control de los proyectiles disparados desde el cangrejo.
Ilustracin 45: Cdigo para mapear el valor del sensor a la posicin "x"
En primer lugar mapearemos el valor que nos devuelve el sensor del deslizador a la
posicin x del cangrejo y a la vez guardaremos el valor en una variable x para
que sea tambin la posicin de la pinza.
60
Ilustracin 46: Aqui podemos ver los dos objetos que componen nuestro
montaje
Dado que el valor del sensor va de 0 a 100 y la posicin ser de -240 a +240,
corregimos el valor multiplicndolo por 5 y restndole 240.
Ilustracin 47: Cdigo para la pinza.
El cdigo para la pinza es algo ms complicado, en primer lugar utilizaremos una

variable llamada pinza que nos indica si la pinza a sido disparada (valor=1) o si la
pinza esta oculta (valor=0). Si la pinza ha sido lanzada lo nico que haremos es
sumarle 3 a su posicin y, mostrarla y comprobar si ha llegado al final de la pantalla
61

para ocultarla. Por otro lado si la pinza no ha sido lanzada iremos comprobando
todo el tiempo que no se pulse el boton de la picoboard. En caso de que sea
pulsado el botn pondremos la x de la pinza en el mismo lugar que el cangrejo y
podremos a 1 la variable pinza.
Gorro giratorio
Este es un proyecto muy simple que nos sirvi para observar dos formas nuevas de
trabajar. El concepto es relativamente fcil, utilizaremos un potencimetro grande
conectado a uno de los sensores de resistencia para utilizarlo como control de la
rotacin de un objeto en pantalla.
Ilustracin 48: Montaje de la picoboard con el potencimetro conectado al sensor de

resistencia A
De las dos pinzas del sensor conectaremos una al conector de en medio y la otra a
cualquiera de los dos restantes.
Ilustracin 49: Detalle de la conexin al potencimetro y detalle del programa
Ahora con un simple programa de scratch leeremos el valor del sensor y lo

convertiremos en un ngulo de rotacin para el objeto que queremos pintar. Como
62

el valor es un nmero del 0 al 100 y el ngulo es de 0 a 360 multiplicaremos por 4 el
valor obtenido.
Ilustracin 50: Cdigo del programa
El cactus virtual
En el verano del 2008, durante el campus tecnolgico de verano en Marf, algunos
de los alumnos se dedicaron a pinchar leds y resistencias en algunos de los cactus
que hay en el aula, con lo cual algunos de estos cactus murieron.
Ilustracin 51: Cactus mutilado
Como castigo, propuse una prctica donde en la maceta donde estaba el cactus se
colocaban unos electrodos que detectan la humedad de la tierra, y con este valor
tuvieron que realizar un cactus virtual que creca cuando se regaba la maceta real.
Ilustracin 52: Al aadir agua baja la resistividad

de la tierra
El montaje consta nicamente de unas varillas de metal conectadas a los dos bornes
del sensor A de la scratchboard. Este sensor detecta la variacin de la resistencia, y
63

como nos podemos imaginar al mojar la tierra, se incrementa la conductividad por
lo tanto baja la resistencia.
Ilustracin 53: Ejemplo del software de resurreccin

de cactus
Ilustracin 54: Ingenio para resucitar al cactus

virtualmente
Ilustracin 55: Cdigo del software de resurrecin de cactus
GamePad con cartn y papel de plata

En este caso ms que un proyecto, es una idea, una tecnologa interesante a explorar
en clase. Nos dedicaremos a disear perifricos para cualquiera de los juegos que
hacemos en scratch.
64

Para ello utilizaremos un trozo de cartn, papel de plata, cinta adhesiva, y cable. En
primer lugar pelaremos una de las puntas del cable bastante larga y le daremos
forma circular.
Ilustracin 56: Podemos utilizar cualquier tipo de cable.
Ms tarde cortaremos un trozo pequeo de cartn que ser nuestro pulsador, y en

un trozo grande haremos tantos agujeros como pulsadores queremos. Pasaremos
los dos cables por el agujero y con cinta aislante pegamos la parte no pelada del
cable al trozo grande del cartn y al trozo ms pequeo. Cortamos un pequeo
cuadrado de papel de plata y recubrimos cada uno de los cables pelados con este
papel. Pegamos los bordes del papel de plata con cinta adhesiva al cartn para que
no vuele. Y por ltimo conectamos cada unos de los cables a las 2 pinzas de
cocodrilo del sensor de resistividad de nuestra placa picoboard.
Ilustracin 57: Pegamos los cables al cartnRecubrimos los cables con papel de plataConexin con la picoboard
65
Cuando los dos trozo de papel de plata se toquen el sensor enviar un valor
positivo y cuando no se tocan un valor negativo. Detectamos estos valores y los
utilizamos como entradas en nuestra aplicacin de scratch.
Ilustracin 58: Cdigo scratch para detectar los valores del

gamepad conectado a la picoboard.
66
Proyectos con Arduino + Processing

Led Parpadeante
En nuestro primer proyecto con arduino, conectaremos un led al puerto 2 y
haremos que este parpadee. En primer lugar conectaremos la pata corta del led a
tierra (GND) y la pata larga a una resistencia que ir conectada tambin al pin 2.
Ilustracin 59: Conexin de led a placa

arduino
void setup() {
pinMode(2,OUTPUT);
}
void loop() {
digitalWrite(2,HIGH);
delay(500);
digitalWrite(2,LOW);
delay(500);
}
Cmo vis en el ejemplo en la parte del setup lo nico que hacemos es declarar el
pin 2 como un pin de salida. Ms adelante en la parte del loop en primer lugar
ponemos el pin 2 a HIGH (5 voltios), esperamos con un delay y ms tarde lo
ponemos al LOW (0 voltios) y volvemos a esperar. La funcin loop se repite
continuamente hasta desconectar la placa o enviar otro programa diferente.
67
Ilustracin 60: Elegimos el modelo de placa
Ilustracin 61: Seleccionamos el puerto donde

esta conectada
Ilustracin 62: Pulsamos el botn de transferir el

programa
Una vez que tengamos escrito el programa dentro del software de arduino, en
primer lugar debemos elegir la placa de arduino que estamos usando, el puerto
donde esta conectada y pulsar el botn de transferir el programa a la placa
[ilustraciones 60, 61, 62 y 63].
68
Ilustracin 63: Observamos cmo

se encienden los leds de
transferencia
Cdigo Morse
En este ejercicio trabajamos el uso de las funciones en arduino. Intentamos
implementar un programa que mediante un led enve mensajes en cdigo morse. En
primer lugar codificamos la funcin punto esta funcin enciende el led durante
100ms y la funcin ralla que enciende el led durante 500ms. De esta forma
haciendo llamadas a punto y ralla podemos enviar la letra que queramos.
void setup() {
pinMode(13,OUTPUT);
}
void loop() {
punto();
punto();
ralla();
}
void punto() {
delay(100);
delay(100);
}
void ralla() {
delay(500);
delay(100);
}
69
Ilustracin 64: Esquema Semforo
Ilustracin 65: Protoboard Semforo
El semforo para invidentes

Material necesario:Zumbador, Led rojo, Led verde, Led Amarillo, Resistencia 220
Ohms (3), Placa prototipaje, Placa Arduino, Hilo de
conexin.
En este proyecto conectaremos un zumbador y 3 leds a una placa arduino, e
intentaremos simular el funcionamiento de un semforo. Este proyecto se puede
realizar en diferentes fases, refinando en cada una de ellas el funcionamiento:
Fase 1: Programar los leds de forma que se enciendan Verde, Amarillo, Rojo.
Fase 2: Hacer que el led Amarillo parpadee un nmero determinado de veces antes
de encender el led rojo.
70

Fase 3: Incluir el funcionamiento del zumbador intermitentemente mientras el led
Verde permanece activo.
Fase 4: Simplificar el cdigo haciendo servir un bucle de tipo for.
Ilustracin 66: Cdigo arduino para el semforo.
Alarma de proximidad
Material necesario: Sensor de rango de infrarojos sharp, 3 leds de diferentes colores o
un led rgb, 3 resistencias de 200-400 Ohms, un zumbador.
En esta prctica trabajaremos los condicionales haciendo utilizando el sensor de
rango de infrarojos como alarma. Haciendo que en funcin de la proximidad de un
objeto al sensor se enciendan 1, 2, o 3 leds y el zumbador pite. Para ello
conectaremos los leds con sus resistencias a los pines 2,3 y 4 digitales y el sensor de
infrarojos al pin 0 analgico.
71
Ilustracin 67: Montaje de la Alarma
Fase 1: En una primera fase deberamos printar el valor del sensor por pantalla y
hacer cuando el sensor enve un valor mayor que 200 por ejemplo se
encienda un primer led.
x=analogRead(0);
delay(10);
Serial.println(x);
if(x>200){
} else {
}
...
Fase 2: Ahora deberamos completar el programa haciendo que al superar el sensor

diferentes valores vaya encendiendo los diferentes leds y el zumbador.
int x;
void setup(){
pinMode(2,OUTPUT);
pinMode(3,OUTPUT);
pinMode(4,OUTPUT);
}
void loop(){
x=analogRead(0);
delay(10);
if(x>200) {
} else {
72

if(x>400) {
} else {
if(x>600) {
}
}
}
}
La camiseta
Hace algunos aos encontramos un proveedor canadiense de hilo de coser
conductor de electricidad17, como nos pareci curioso el ingenio compramos
algunos metros y diseamos este proyecto. Hoy en da, seguramente podemos
encontrar proveedores locales que nos puedan ofrecer este tipo de elementos.
Ilustracin 68: Montaje de la camiseta finalizado
Este experiemento consiste en colocar un acelermetro en la manga de una

camiseta que detecta cuando se producen movimientos bruscos, y en funcin de la
aceleracin o la orientacin del movimiento enciende o apaga una ristra de leds
colocados en el frontal de la camiseta.
En primer lugar realizaremos el montaje sobre un arduino convencional y una placa
de prototipaje. Una vez que hallamos probado el software y funcione
correctamente. Pasaremos el software a un arduino de tipo Lilypad el cual esta
17 http://www.members.shaw.ca/ubik/thread/
73

diseado para trabajar sobre textil, y por ltimo coseremos este montaje a la
camiseta.
El montaje es relativamente sencillo conectaremos 6 leds a 6 salidas digitales de
arduino y conectaremos el acelermetro a una de las entradas analgicas de arduino.
Acto seguido realizaremos una serie de pruebas con el sensor para ver que valores
nos aporta en funcin de la orientacin.
Ilustracin 69: Montaje del acelermero y los leds
El software en este caso es relativamente sencillo nicamente tenemos que leer el

valor del sensor (en nuestro caso haremos una lectura ponderada), y encender ms
o menos leds en funcin del valor ledo.
int val;
int v,x;
void setup() {
// Hago servir un bucle para agilizar la declaracin
// de salidas.
for(x=2; x<8; x++) {
pinMode(x,OUTPUT);
}
}
void loop() {
// La lectura del sensor se har ponderada
v
= analogRead(0);
val = val * 0.8 + v * 0.2;
for(x=2; x<8; x++) {
digitalWrite(x,LOW);
}
if(val > 300)
if(val > 400)
if(val > 500)
if(val > 600)
if(val > 700)
if(val > 800)
delay(10);
74

}
Ahora prepararemos el material para coserlo con el hilo conductor. En el caso de

las resistencias y los leds con unos pequeos alicates enroscaremos las patas de
metal para darles forma circular y as poder coserlas al tejido.
Ilustracin 70: Utilizamos unos alicates pequeos para

curvar las patas de los leds y las resistencias
Si queremos, podemos probar el circuito sobre lylypad usando pinzas de

cocodrilo antes de coserlo a la camiseta.
Ilustracin 71: Cmo utilizar las pinzas de cocodrilo para prototipas

sobre "lilypad"
75
Ilustracin 72: Acabado de los leds y

resistencias listos para coser en la ropa
Una vez hemos probado nuestro diseo y tenemos cosidas las partes a la camiseta,
solo nos queda enviar el software creado al lilypad que tenemos cosido. Para ello
utilizaremos un FT232R o un FTDI conectado a lilypad por los pines de
conexin y al PC por el cable USB. Este chip es necesario en lilypad , ya que
arduino lo tiene integrado en la placa y lilypad no. Antes de pulsar el botn de
enviar desde arduino hemos de cambiar el tipo de placa que utilizamos.
Ilustracin 73: Cambiamos el modelo de placa antes de

enviarlo a lilypad
76
Ilustracin 74: Conexin al pc a traves de un FTDI
La bandeja que nunca vuelca

En este proyecto conectaremos un acelermetro a una superficie plana y nos dar la
inclinacin de la superficie en dos ejes (x e y). Despus con estos dos datos
activaremos los dos servomotores a los que esta conectada la superficie para
corregir la inclinacin de la superficie. El primer servo corregir el valor del eje x y
el segundo el valor del eje y.
Ilustracin 75: El acelermetro montado sobre un arduino
En primer lugar conectaremos el acelermetro a arduino y leeremos el valor de los

sensores. Tambin seria interesante tomar nota de los valores de cada eje y como
varan al girar la superficie en uno y otro ngulo. [Recordat pulsar el botn de Monitor de
Arduino para que nos ensee los valores]
int x,y;
void setup(){
Serial.begin(9600);
}
void loop() {
x = analogRead(0);
y = analogRead(5);
Serial.print(x);
Conexiones
X AnalogIn 0
Y AnalogIn 5
Gnd Gnd
77

Serial.print("-");
Serial.println(y);
Vcc 5V
Por otro lado veamos como funciona un servomotor de rotacin continua. En

nuestro caso usaremos los servos de parallax18, pero tambin podemos comprar
servos normales y convertirlos en continuos con lo cual nos ahorraremos algunos
euros [ver apndice en la pgina 108]. Para hacer funcionar estos servomotores
enviamos un pulso ponindolo durante 20ms a baja (0V) y despus a 5V durante un
tiempo entre 1ms y 3ms. Dependiendo del tiempo que este a 5V el servo girar
hacia un lado o hacia otro. As que realizaremos 4 funciones que hacen girar la
bandeja atrs, adelante, izquierda y derecha.
int x,y;
void setup(){
Serial.begin(9600);
pinMode(2,OUTPUT);
pinMode(3,OUTPUT);
}
void loop() {
x = x * 0.8 + analogRead(0) * 0.2;
y = y * 0.8 + analogRead(5) * 0.2;
Serial.print(x);
Serial.print("-");
Serial.println(y);
if
if
if
if
(y>520)
(y<490)
(x>525)
(x<485)
{
{
{
{
izquierda(); }
derecha(); }
atras(); }
adelante(); }
}
void izquierda() {
delayMicroseconds(1000);
}
void derecha() {
}
void adelante() {
18 http://www.parallax.com/
78

}
void atras() {
}
Una vez que lo tenemos todo, solo nos queda implementar el programa principal
loop que activa una u otra funcin en base a los valores que nos envi el
acelermetro. Como podis observar la lectura de los sensores se realiza de forma
ponderada como se explica en la pgina 46.
Ilustracin 76: Esquema del

montaje de los dos servos. Sobre
la plataforma iria situada la
placa de arduino con el
acelermetro.
En el montaje de los servos como podis observar en la [Ilustracin 76] hemos

realizado un par de ngulos con madera o cartn pluma donde anclamos los servos
y nos sirven para controlar el ngulo de dos ejes diferentes. Sobre la plataforma
situaremos el microcontrolador con el acelermetro que le enva a informacin a los
servos para que corrijan el ngulo.
Robot con rutas pre-programadas

Para esta prctica montaremos dos servomotores de rotacin continua a un chasis
metlico, tal y como se explica en el apndice de la pgina 107. Y desde arduino
programaremos una ruta para que el robot siga un camino concreto. El chasis
metlico que utilizamos es el de los robots boebot de parallax 19, pero podemos
fabricarnos el nuestro propio con piezas de mecano, madera, o con cualquier otro
material que tengamos a mano.
19 http://parallax.com
79
Ilustracin 77: Kit servomotores + chasis
Para hacer ms simple la programacin crearemos 4 funciones izquierda, derecha,

adelante y atras. Como los servos estn colocados simtricamente, para hacer
mover el robot hacia adelante tendremos que girar un motor al lado contrario de su
motor simtrico.
void adelante() {
}
void atras() {
}
void derecha() {
}
void izquierda() {
}
Como podis observar cada una de estas funciones realiza un nico pulso, con lo
cual si queremos que el robot ande unos centmetros hacia adelante tendremos que
implementar un bucle for que llama a la funcin adelante tantas veces como tiempo
queremos que ande hacia adelante el robot.
void setup() {
pinMode(2,OUTPUT);
pinMode(3,OUTPUT);
}
80

void loop() {
int x;
for(x=0;x<100;x=x+1) {
adelante();
}
for(x=0;x<80;x=x+1) {
derecha();
}
for(x=0;x<200;x=x+1) {
adelante();
}
delay(3000);
}
Robot que nunca choca

En esta prctica partiremos del montaje anterior donde tenamos 2 servos
conectados a nuestro arduino en los pines 2 y 3. Tambin reutilizaremos las
funciones adenlate, atras, izquierda y derecha para controlar su desplazamiento.
A todo el montaje de la prctica anterior aadiremos un par de sensores de distancia
para realizar la navegacin autnoma y detectar posibles colisiones con los objetos
cercanos.
El montaje de los sensores lo haremos en un ngulo de unos 45 grados para
asegurarnos que cubrimos posibles puntos muertos.
Ilustracin 78: Diagrama de la posicin de los sensores.
Respecto al software, nuestra primera implementacin ser relativamente simple.

Escribiremos 4 condicionales y en funcin de si detectan algo alguno de los
81

sensores o no, se tomar una decisin u otra. En este caso las lecturas de los
sensores no se harn ponderadas para acortar el tiempo de reaccin. Los valores de
400 no son funcionales para todo tipo de montajes, pueden cambiar en funcin
del sensor y de como esta conectado, depender de cada montaje y tendremos que
hacer las pruebas pertinentes para detectar el valor correcto.
void loop() {
valizq = analogRead(0);
valder = analogRead(1);
if (valder>400 && valizq>400) {
atras();
} else {
if(valder>400) {
izquierda();
} else {
if (valizq>400) {
derecha();
} else {
adelante();
}
}
}
}
Utilizando esta primera versin del software tenemos un pequeo bug, cuando el
robot detecta una esquina realiza un pequeo movimiento hacia atrs y acto seguido
vuelve a tirar hacia adelante. Una de las posible soluciones es ajustar el valor de uno
de los sensores ms alto que el otro, de esta manera nuestro robot en caso de duda
siempre girar hacia un lado. Otra forma ms elegante de solucionarlo sera
substituir la llamada a la funcin atras por un bucle que llame a la funcin atrs
un nmero determinado de veces, de esta forma har un recorrido mayor hacia
atrs y despus podr corregir correctamente su rumbo. Otra posible solucin es
guardar en variables un histrico de hacia donde ha girado las ltimas ejecuciones e
intentar detectar esos puntos muertos.
Robot seguidor de lineas

En este caso modificaremos el robot de la prctica anterior y en vez de sensores de
distancia utilizaremos dos fotorresistencias para determinar el color del suelo por
donde pasa el robot. Este montaje es extremadamente sensible a las condiciones
lumnicas de donde se realiza, por esta razn utilizaremos un rollo de cintas aislante
negra (a ser posible mate) para dibujar la lnea en el suelo, e intentaremos que la
habitacin este bien iluminada. En caso de que tengamos problemas en diferenciar
el suelo blanco del negro de la cinta aislante colocaremos un par de leds blancos al
lado de las fotoressitencias para mejorar las condiciones de iluminacin.
82
Ilustracin 79: Esquema para el circuito de

deteccin de lineas negras. Los cables Negros
se conectan a tierra, los rojos a 5V, y los
azules (que nos devuelven el valor de las
LDRs) van conectados a los pines AnalogIn.
Recordemos que las fotorresistencias no se conectarn directamente a los pines

analgicos 0 y 1, sino que realizaremos un montaje similar al de la pgina 21.
Ilustracin 80: Circuiteria para la deteccin de lneas

sobre una placa de prototipaje.
83
Ilustracin 81: Fotorresistencias montadas sobre el chasis del robot.
Respecto al software, este vuelve a ser un montaje bastante sencillo. Si las dos
fotorresistencias detectan color blanco, podemos deducir que vamos por buen
camino y seguimos hacia adelante. Si en caso contrario solo una de las
fotorresistencias detecta blanco, significa que nos hemos desviado y debemos
corregir el rumbo a derecha o izquierda. Y por ltimo si topamos con negro en los
dos sensores deberamos retroceder un poco para retomar la ruta.
void loop() {
atras();
} else {
if(valder>400) {
derecha();
} else {
if (valizq>400) {
Izquierda();
} else {
adelante();
}
}
}
}
84
Robot perseguidor
La idea es realizar un robot que sea capaz de perseguir un objeto en movimiento.
Para ello aprovecharemos el montaje de la prctica de la pgina 81, y modificaremos
el software.
Respecto al movimiento hacia adelante controlaremos la distancia del objeto a tres
rangos: lejos, cerca y muy cerca. Si el objeto esta muy cerca iremos hacia atrs para
no chocar, si lo tenemos cerca nos aproximaremos l y si lo tenemos lejos nos
mantendremos en reposo. Respecto a izquierda y derecha haremos todo lo
contrario a la prctica anterior, de forma que si detectamos algo a la izquierda
giraremos a la izquierda para encararnos al objeto, y de forma similar si detectamos
algo a la derecha giraremos a la derecha para encararnos.
void loop() {
atras();
} else {
if(valder>400 && valizq>400) {
adelante();
} else {
if (valizq>400) {
izquierda();
} else {
if(valder>400) {
derecha();
} else {
//No hacemos nada
}
}
}
}
}
85
Organizador de manzanas
Ilustracin 82: Esquema del montaje de la pala incluyendo un servo y piezas metlicas.
En esta ltima modificacin del robot aadiremos dos nuevas caractersticas: en

primer lugar aadiremos un servo no continuo para controlar una pala recogedora y
por ltimo comunicaremos arduino con processing para controlarlo desde el PC. Al
servo aadiremos algunas piezas de metal para crear la pala que levanta o deja caer
objetos.
Aadir el servo no continuo, es relativamente fcil el nico problema que podemos
tener es que nos falte alimentacin y tengamos que conectar un pila de 9V como
batera suplementaria [ver Ilustracin 83].
86
Ilustracin 83: Conexin de arduino con batera de

9V
Para mover el nuevo servo utilizaremos la librera de control de servomotores. Para

ello debemos incluir la librera en las declaraciones al inicio del programa, indicar
dentro de la funcin setup() a que pin esta conectado el servo (el 9 en nuestro caso),
y por ltimo con la funcin pala.write() le indicaremos a que grado de rotacin
queremos para nuestro servo.
#include <Servo.h>
Servo pala;
void setup()
{
pala.attach(9);
pinMode(2,OUTPUT);
pinMode(3,OUTPUT);
}
void pala_up() {
pala.write(120);
}
void pala_down() {
pala.write(30);
}
Como podis ver tenemos una funcin pala_up que levanta la pala a 120 grados y
una funcin pala_down que baja la pala a 30 grados. Los grados a los que se ha de
levantar la pala dependen de como coloquemos el servo y como este calibrado. Con
la librera servo.h podemos utilizar tanto servos de tamao normal como miniservos,
la forma de programarlos es idntica.
87
Ilustracin 84: Esquema de comunicacin a travs del "Serial monitor"
Para solucionar el problema de la comunicacin del PC con nuestro montaje en

arduino introduciremos un cdigo dentro de la funcin loop() que esperar a recibir
algn mensaje por el puerto USB o Bluetooth y al recibirlo llamar a una u otra
funcin de las implementadas. En nuestro caso para hacerlo ms simple nos
comunicaremos con caracteres simples:
w adelante
s atrs
a izquierda
void setup()
{
Serial.begin(9600);
pala.attach(9);
pinMode(2,OUTPUT);
pinMode(3,OUTPUT);
}
d derecha
o bajar pala
p levantar pala
void loop()
{
if (Serial.available() > 0) {
int rec = Serial.read();
if(rec=='w') adelante();
if(rec=='s') atras();
if(rec=='a') izquierda();
if(rec=='d') derecha();
if(rec=='o') pala_down();
if(rec=='p') pala_up();
delay(10);
}
}
Utilizando la funcin Serial.available() detectamos si nos han enviado algo por el

puerto serie y con la funcin Serial.read() capturamos el valor enviado y lo
guardamos en una variable.
88
Ilustracin 85: Robot organizador de manzanas.
Para probar si funciona, una vez hemos enviado el programa a la placa arduino
conectamos el Monitor [mirar ilustracin 86] y le enviamos mensajes a la placa a
travs del monitor [Ilustracin 87]. Al escribir algunas de las letras codificadas por el
monitor y pulsar enviar, arduino debera recibir nuestras rdenes y realizar los
movimientos programados.
Ilustracin 86: Botn para conectar el Monitor del

puerto Serie
89
Ilustracin 87: Monitor que permite enviar mensajes a

la placa a travs del USB
Pong con sensor de distancia

En este ejemplo utilizaremos arduino para capturar datos del mundo real (en
nuestro caso un sensor de proximidad) y estos datos se enviarn a processing para
utilizar estos datos como valores de entrada en un videojuego simple.
Ilustracin 88: Esquema de comunicaciones del juego
En primer lugar solucionaremos la captura de datos fsicos. Conectamos un sensor

de distancia a nuestro arduino y hacemos que este nos enve a travs del cable USB
el valor que recibe del sensor.
int val;
void setup()
{
Serial.begin(9600);
}
void loop()
{
val = 0.8*val + 0.2*analogRead(0);
Serial.println(val);
90

delay(10);
}
Una vez que tenemos solucionada la parte ms hardware de nuestro proyecto,

veamos como hacer que processing capture estos datos y site una barra en la
pantalla que vare su posicin en funcin de los valores que nos enva el sensor
Ilustracin 89: Cdigo para la comunicacin serie desde processing.org
Import processing.serial.*;
Importa la librera de comunicaciones
Serial puerto;
91

Este es el objeto que utilizaremos para enviar y recibir
datos.
Imprime en la parte de abajo toda la lista de puertos
disponibles para que podamos elegir cual es el nuestro.
Puerto.bufferUntil(10);
Indicamos que ha de almacenar datos hasta encontrar un
salto de lnea.
SerialEvent(Serial puerto)
Es una funcin que se ejecuta automticamente al recibir
algn dato por el puerto.
dato=puero.readStringUntil...
Recibe el dato del puerto y los guarda en la variable dato.
Con esta captura de los datos obtenemos el valor que se nos enva desde arduino.
Ahora solo hemos de convertirlo a un valor numrico y hacer que el programa
dibuje un rectngulo en la posicin que indica el valor. Dado que el valor que
recibimos (en nuestro caso) es siempre mayor que 80, al valor recibido le
restaremos 80 siempre para normalizarlo.
Ahora veamos ahora como simular el rebote y la velocidad de una pelota en
pantalla.
Ilustracin 90: Correccin del valor recibido por el puerto serie.
abs Devuelve el valor absoluto, es decir, si es negativo le

quita el signo.
int Convierte un valor de texto a numrico.
trim Elimina los caracteres no visibles de una cadena de
texto.
92
Ilustracin 91: Esquema de movimiento

de la bola
Como vemos en el esquema trabajaremos con 4 variables, x-y para guardar la posicin y vx-vy
para guardar la velocidad y direccin de hacia donde se dirige la bola.
Si vx es positiva se mover hacia la derecha y si es negativa hacia la izquierda. A cada pasada
del bucle de ejecucin incrementaremos la x en vx puntos y la y en vy puntos, asi conseguimos
que la pelota se mueva en la direccin deseada.
Y para hacer rebotar la pelota lo nico que tendremos que hacer es invertir el signo de vx o vy
cuando la x o la y de la pelota llegue a un borde.
Los rebotes de la pelota con las paredes son relativamente fciles de calcular, el
problema lo tendremos para calcular el rebote de la pelota con la barra. Cuando
detectamos que la x de la pelota es inferior a la x de la barra, pueden suceder dos
cosas que la pelota se ha tocado con la barra o que ha cado por el borde izquierdo.
Para detectar si la pelota a tocado la barra comprobaremos que la y de la pelota est
entre la esquina superior de la barra y la esquina inferior de la barra.
93
Ilustracin 92: Clculo de los rebotes de la pelota con la barra

y los bordes
Cuando realizamos este ejercicio en clase siempre propongo modificar el programa

para realizar un juego con dos barras y dos jugadores. Con lo qual hemos de
conectar otro sensor a placa arduino y esta debe enviar dos nmeros separados por
comas para indicar los valores de los sensores, y dentro de processing hemos de
cambiar el sistema de rebotes y dibujar la barra del segundo jugador. El nico lugar
donde podemos tener problemas graves en esta modificacin es al recibir ms de un
valor de la placa arduino, para ello utilizamos la funcin split() dentro de
SerialEvent, para que sea capaz de captar ms de un valor separado por comas y
separarlo en dos nmeros enteros.
Ilustracin 93: Evento de lectura de ms de un valor por el puerto serie
94
Robot controlado por Internet
Ilustracin 94: Esquema de comunicacin del Robot
En este proyecto intentaremos ir un poco ms all en el tema de las comunicaciones

con nuestro robot. Partiremos del Organizador de Mandarinas [ver pgina 86] que
era un robot capaz de realizar distintas acciones en funcin de la letra que se le
enva por el puerto USB, y aadiremos una interface web para que recoja las
instrucciones y se las envi a nuestro robot.
En primer lugar tendremos que disear una base de datos online que recoje las
peticiones de la web. Esta base de datos la hemos diseado en mySQL que es uno
de los sistemas ms extendidos para el uso de bases de datos online. Para montar
esta base de datos podemos montar nuestro propio servidor apache+php+mysql
[ver pgina 52], o podemos buscar algn hosting barato o gratuito que nos permita
gestionar una base de datos. Una vez instalado, nos conectamos a nuestro servidor
mySQL y creamos una base de datos con una nica tabla que contiene un campo
de tipo numrico y un campo de tipo varchar que recoger las ordenes que se
envan a travs de la web.
Ilustracin 95: Pgina Control del Robot
95

Ahora disearemos una sencilla pgina web que introduce los comandos de
movimiento del robot en la base de datos [ver pgina 55]. Una vez escrita en
cualquier editor de texto la grabamos con el nombre index.php dentro de la
carpeta www para que nuestro servidor web la abra al cargar el explorador de
internet y escribir localhost o nuestra propia direccin ip. [Ver Ilustracin 95]
Ahora hemos de crear otra pgina web que lee el primer dato de la base de datos y
lo extrae de la tabla [ver pgina 55]. Esta pgina sera la que consultar nuestro robot
para saber que orden tiene que ejecutar. [Ver Ilustracin 96]
Ilustracin 96: Pgina web control
Por ltimo nos resta la parte ms complicada e importante, hemos de disear un

programa en processing que llame a la pagina web [ver pgina 57] que captura los
valores de la tabla y haremos que enve el valor capturado a nuestro robot.
Serial puerto;
Client cliente;
boolean peticion = false;
String respuesta = "";
String resp = "";
void setup() {
}
void draw() {
makeHTTPCall();
if(resp!=null) {
resp = trim(resp);
96

int token[]=int(split(resp, ','));
for (int x=0; x<token.length; x++) {
if (token[x] == 1) {
puerto.write(49);
println("recibido: mover adelante");
}
puerto.write(50);
println("recibido: mover atras");
}
puerto.write(51);
println("recibido: girar izquierda");
}
puerto.write(52);
println("recibido: girar derecha");
}
}
resp = "";
}
if (peticion == true) checkNetClient();
}
void makeHTTPCall() {
if (peticion == false) {
cliente = new Client(this, "localhost", 80);
cliente.write("GET /datos.php HTTP/1.0\n");
cliente.write("HOST: localhost\n\n");
peticion = true;
}
}
void checkNetClient() {
if (cliente.available() > 0) {
respuesta += char(cliente.read());
} else {
if( respuesta.length() > 0) {
if(peticion==true) {
resp = respuesta;
peticion=false;
respuesta="";
}
}
}
}
97
Theremin de Infrarojos
Un theremin es un instrumento musical bastante curioso, posee un par de antenas
metlicas y acercndote o separndote de estas antenas controlas el volumen y la
frecuencia de la nota que se emite. En esta prctica intentaremos simular este
instrumento musical con nuestro arduino. En lugar de dos antenas metlicas
utilizaremos dos sensores de proximidad, dos fotorresistencias o dos
potencimetros.
Ilustracin 97: Montaje del Theremin con un sensor de

proximidad
Una nota musical, no es ms que una onda que vibra a una frecuencia concreta, si la
frecuencia es ms alta obtenemos notas ms agudas y al contrario notas ms graves.
Por ejemplo un LA funcionaria a 440 herzios, es decir, que para reproducirlo
tenemos que producir una onda de 440 pulsos en un segundo, o lo que es lo mismo
pulsos de 2.272 microsegundos.
1s
=2,272 ms
440
En nuestra implementacin capturaremos el valor del infrarojo para saber que nota
se quiere reproducir, calcularemos de cuanto tiempo han de ser los pulsos, y
reproduciremos pulsos de la frecuencia enviada durante un cuarto de segundo.
int v1;
float tiempo;
void setup(){
Serial.begin(9600);
pinMode(8,OUTPUT);
}
void loop() {
v1=analogRead(0);
98

tiempo=(1000000/v1)/2;
Serial.print(v1);
Serial.print(",");
Serial.println(tiempo);
if(v1>200) { // con este if obviamos notas muy bajas.
for(int i=0; i<v1/4; i++) {
delayMicroseconds(int(tiempo));
digitalWrite(8, LOW);
delayMicroseconds(int(tiempo));
}
}
}
Localizador de colores
Processing es un lenguaje de programacin pensado para artistas, es por esta razn
que esta provisto de infinidad de libreras para trabajar con audio, video e imagen a
tiempo real. Por otro lado es un lenguaje bastante simple y muy similar a arduino.
Ilustracin 98: Ejemplo de captura de video a travs de la webcam
En este proyecto vamos a trabajar con la librera videoCapture que nos permite
capturar y editar a tiempo real video de una webcam conectada al PC. Antes de
empezar a programar necesitamos tener instalado en nuestro PC (si funciona bajo
99

macOS no es necesario) el software Quicktime20 y el driver Winvdig21. Una vez
instalado probamos el siguiente programa para capturar la imagen que viene de la
cmara y presentarla en pantalla a tiempo real.
Import processing.video.*;
Cargamos la librera de video.
Capture video;
Creamos el objeto donde recibimos los datos de la webcam.
Video = new Capture...
Inicilizamos la webcam.
video.read();
carga la imagen que esta viendo la webcam ahora.
image(video,0,0);
dibuja en pantalla lo que hay en el objeto video.
Con este escueto cdigo inicializamos la webcam, capturamos la imagen que esta
viendo la webcam en este momento (si esta disponible) y la dibujamos en pantalla
con la instruccin image(), y todo esto a tiempo real.
Ahora veremos como retocar en tiempo real el contenido de estas imgenes que
nos enva la cmara. Podemos acceder a los pxeles de la imgen capturada
mediante el array video.pixels[ ], este array guarda los colores de cada uno de los
pxeles de la pantalla. Para recorrerlo crearemos un par de bucles anidados que se
mueven por las columnas y filas del array video.pixels[ ]. Para cada punto
guardaremos su color en la variable col de tipo color. Haciendo red(col),
green(col) y blue(col) accedemos a cada uno de los componentes de color del
punto que estamos estudiando.
for (int x = 0; x < video.width; x ++ ) {
for (int y = 0; y < video.height; y ++ ) {
int loc = x + y*video.width;
color col = video.pixels[loc];
float r1 = red(col);
float g1 = green(col);
float b1 = blue(col);
r1=255;
col= color(r1,g1,b1);
video.pixels[loc]=col;
}
}
video.loadPixels();
20 http://www.apple.com/es/quicktime/download/
21 http://www.eden.net.nz/7/20071008/
100

image(video,0,0);
Como ejemplo en el cdigo que vemos aqu arriba, descomponemos cada uno de
los pxeles en rojo, verde, azul, y volvemos a guardar el color pero con el rojo a 255,
con lo cual obtendremos un filtro rojo en todas las imgenes que vienen de la
webcam.
Pero en esta prctica lo que queremos es detectar un color concreto, para ello
descompondremos el color y lo compararemos con el color que estamos buscando.
Si la diferencia entre los dos colores es menor que la diferencia de las
comparaciones anteriores, se establece el punto x,y del color como el punto ms
cercano al color que buscamos. Al acabar de ejecutar los dos bucles anidados
tenemos el punto ms cercano al color de referencia.
int cX = 0;
int cY = 0;
float record = 500;
for (int x = 0; x < video.width; x ++ ) {
for (int y = 0; y < video.height; y ++ ) {
int loc = x + y*video.width;
color col = video.pixels[loc];
float r1 = red(col);
float g1 = green(col);
float b1 = blue(col);
float r2 = red(trackColor);
float g2 = green(trackColor);
float b2 = blue(trackColor);
float d = dist(r1,g1,b1,r2,g2,b2);
if (d < record) {
record = d;
cX = x;
cY = y;
}
}
}
if (record < 10) {
ellipse(cX,cY,16,16);
}
El tintero
Finalizo este libro una vez acabado el 2009 con un montn de nuevos proyectos en
el tintero. Tengo tres alumnas de 10 a 13 aos que a partir de un conejo de peluche
han diseado un robot que modifica su comportamiento en funcin de la
101

proximidad de la gente. Un par de chicos de unos 14 - 15 aos se han animado a
desarrollar sus propios videojuegos para consolas y mviles. Y actualmente estoy
ayudando a unos 6 chicos de 1 de bachillerato con su Treball de Recerca22: maquetas
de casas inteligentes, girasoles mecnicos que cargan sus propias bateras
orientndose al sol, simulacin tridimensional de armas de asedio medievales, tablas
"multitouch" con sensores infrarrojos de bajo coste, motores grficos anaglficos...
ya tengo ganas de que llegue este prximo 2010 cargado de nuevos proyectos y de
alumnos con ganas de innovar, inventar y crear.
Espero poder documentar todo esto y poderlo incluir en la prxima edicin del
libro, igualmente siempre podis consultar el apartado de "Docs" de la pgina web
de MARF ( http://marf.es ) donde vamos intentado comentar todo lo que se va
creando.
Y de la misma forma os animo a que compartis vuestras experiencias, proyectos y
creaciones conmigo [marf@marfonline.com].
22 El Treball de recerca es un trabajo que realizan los alumnos en Catalunya al finalizar el primer curso de
bachillerato.
102
Apndice
104
Apndice
105
106
Apndice
107
108

Computacion Fisica en Secundaria

Cargado por

Información del documento

Descripción:

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Descripción:

Copyright:

Formatos disponibles

Computacion Fisica en Secundaria

Cargado por

Descripción:

Copyright:

Formatos disponibles

Computacin Fsica

Ttulo original: Computacin Fsica en Secundaria

Ilustracin 1: Foto realizada por Edgar Ll. y Albert "Jack" F.

Peter Dan O'Sullivan y Tom Igoe

La base de la computacin fsica es hacer servir herramientas y tecnologas

Computacin Fsica en Secundaria

Computacin Fsica en Secundaria

El suelo bajo, el techo alto, y las paredes amplias.

Los Leonardos del siglo XXI.

Trabajo cooperativo y socio-constructivismo distribuido.

Computacin Fsica en Secundaria

Hilo de coser conductor

Ilustracin 3: Conductive thread. Hilo

Hace algunos aos cuando empezamos en MARF a hacer experimentos con

Computacin Fsica en Secundaria

Ilustracin 4: Pinzas de cocodrilo con una pinza en

Ilustracin 5: Conexiones en una placa de prototipado

Computacin Fsica en Secundaria

Ilustracin 7: Air graffities realizados con la misma tcnica de los leds

Ilustracin 8: Esquema y Montaje del "KnockSensor"

Ilustracin 9: Conexin de un pulsador

En este montaje elctrico el voltaje es desviado a GND cuando se pulsa el botn.

Computacin Fsica en Secundaria

Ilustracin 10: Esquema de conexionado de un 7 segmentos

Ilustracin 11: Conexin Potencimetro

En este caso para leer el valor haremos servir la instruccin x=analogRead(5) en

Computacin Fsica en Secundaria

Ilustracin 12: Esquema de conexin del sensor LDR.

9 Estos sensores se pueden adquirir en http://sparkfun.com

Ilustracin 14: Sensor de proximidad

A la hora de conectarlos necesitaremos un conector JST de 3 terminales de donde

Ilustracin 15: Termistor

Computacin Fsica en Secundaria

Ilustracin 17: Sensor de torsin y

Ilustracin 18: Servomotor de rotacin no

Ilustracin 19: Ejemplo de control de servomotor que posiciona el motor a 30

A la hora de programarlo utilizaremos la librera Servo de Arduino, que nos

Servomotor de rotacin continua

Computacin Fsica en Secundaria

Ilustracin 20: Ejemplo para servos de rotacin continua

Ilustracin 21: Detalle del tornillo para calibrar los servomotores

Motor DC con TIP120

Ilustracin 22: Esquema conexionado para Motor

En este caso aadiendo una resistencia de 1kOhmios, un diodo y un TIP120, y un

Computacin Fsica en Secundaria

Ilustracin 23: Cdigo para Motor

Ilustracin 24: Control de Motor DC con TIP120

Motor DC con driver L293

Ilustracin 25: Conexin Motor DC con chip L293

Ilustracin 26: Cdigo controlador MotorDC

Sensor RFID (IDentificacin por RadioFrecuencia)

Computacin Fsica en Secundaria

Ilustracin 27: Esquema de conexiones del sensor de RFID

En nuestro caso conectaremos el sensor ID-12 a un chip FTDI conectado

Ilustracin 28: Esquema conexiones placa arduino

Como podemos observar en la [Ilustracin 28] la placa posee 14 salidas/entradas

Computacin Fsica en Secundaria

Ilustracin 29: PicoBoard, placa de sensores para trabajar con Scratch

Ilustracin 30: Detalle de los sensores incorporados en la picoBoard. Azul:

Computacin Fsica en Secundaria

Ilustracin 31: Air Graffity por Jordi R., Jose E. y David A.