Arduino i robots de competició

Arduino i robots de competició. Un robot de sumo amb hardware lliure.

1

Full de presentació

Nom de l'alumne: Aina Soler Gàlvez

Tutor: Lluís Riu Vendrell

Àrea: Tecnologia

Centre: INS Llobregat

Població: Sallent

Paraules clau: Arduino, Software lliure, Hardware lliure, Computació física, Robot, Competició, C/C++, Sumo, Creative Commons, Sensor, Infrarojos, Ring, Electrònica, Programació, Guia, Servomotor.

Key words: Arduino, Open software, Open hardware, Physicalcal computing, Robot, Competition, C/C++, Sumo, Creative Commons, Sensor, Infrared, Ring, Electronics, Programming, Guide, Servomotor.

Resum: Aquest treball es pot dividir en 3 parts. La primera tracta sobre la història i objectius del projecte Arduino. També podeu trobar una guia de referència del seu llenguatge de programació. La segona part parla sobre els robots de competició i les seves diferents modalitats. Finalment, podeu veure el procés de construcció d'un robot de competició, des de que és dissenyat fins que és programat.

Abstract: This report can be divided into 3 parts. The first one is about Aduino project, his history and objectives. You can also find a reference guide of his programming language. The second part is about competition robots and its various modalities. Finally, you can see the process of building a competition robot, from it is designed to his programmation.

“El hardware abierto significa tener la posibilidad de mirar lo que hay

dentro de las cosas, que eso sea éticamente correcto, y que permita

mejorar la educación. Educar en cómo funcionan las cosas…”

-David Cuarielles (Cofunfador del projecte Arduino)

Índex de contingutsIntroducció............................................................................................................................................71-Arduino: Una plataforma de hardware lliure....................................................................................8

La placa, computació física.............................................................................................................8L' origen i desenvolupament de la placa..........................................................................................8Models de la placa...........................................................................................................................9

Primer prototip............................................................................................................................9Arduino per soldar......................................................................................................................9Arduino USB.............................................................................................................................10Arduino Mega...........................................................................................................................12Arduino LilyPad........................................................................................................................12Altres plaques Arduino..............................................................................................................13Futures plaques.........................................................................................................................15

Alguns projectes amb Arduino......................................................................................................16ArduSat.....................................................................................................................................16Projecte RepRap........................................................................................................................17

2-Arduino: Llenguatge de programació.............................................................................................18Introducció.....................................................................................................................................18Estructura Bàsica...........................................................................................................................19

Estructura..................................................................................................................................19Setup().......................................................................................................................................19Loop()........................................................................................................................................19Funcions....................................................................................................................................20{}Claus......................................................................................................................................20; Punt i Coma.............................................................................................................................21/*...*/ Bloc de comentaris..........................................................................................................21// Comentaris de línia................................................................................................................21

Variables.........................................................................................................................................22Variables....................................................................................................................................22Declaració de variables.............................................................................................................22Posició de les variables.............................................................................................................22

Tipus de “dades”............................................................................................................................24Byte...........................................................................................................................................24Int..............................................................................................................................................24long............................................................................................................................................24float...........................................................................................................................................24Arrays........................................................................................................................................25

Aritmètica......................................................................................................................................26Aritmètica..................................................................................................................................26Operadors compostos................................................................................................................26Operadors de comparació..........................................................................................................27Operadors lògics.......................................................................................................................27

Constants........................................................................................................................................28Constants...................................................................................................................................28TRUE/FALSE...........................................................................................................................28HIGH/LOW..............................................................................................................................28IMPUT/OUTPUT.....................................................................................................................28

Control de flux...............................................................................................................................29

If................................................................................................................................................29If... Else.....................................................................................................................................29For.............................................................................................................................................30While.........................................................................................................................................30Do... While................................................................................................................................31

INPUT/ OUTPUT Digital..............................................................................................................32PinMode (Pin,Mode).................................................................................................................32Digital read................................................................................................................................32Digital write..............................................................................................................................32

INPUT/ OUTUPUT Analògic.......................................................................................................33Analog Read..............................................................................................................................33Analog Write.............................................................................................................................33

Temps i Càlculs .............................................................................................................................34Delay (ms).................................................................................................................................34Millis()......................................................................................................................................34Min (x,y)...................................................................................................................................34Max (x,y)...................................................................................................................................34

Aleatori..........................................................................................................................................35Random seed (seed)..................................................................................................................35Random(max)/ Random (min, max).........................................................................................35

Serial..............................................................................................................................................36Serial.begin (velocitat)..............................................................................................................36Serial.println(val) .....................................................................................................................36

3-Robots de competició......................................................................................................................37Introducció.....................................................................................................................................37Modalitats d'interior.......................................................................................................................37

Seguidors de línies ...................................................................................................................38Micromouse..............................................................................................................................38Cowbots....................................................................................................................................39Competicions de bípedes..........................................................................................................39Sumo.........................................................................................................................................40

4-BONIFA-CO El robot de competició que funciona amb Arduino..................................................41Introducció.....................................................................................................................................41Planificació teòrica........................................................................................................................41

Funcions del robot.....................................................................................................................41Sensors del robot.......................................................................................................................42Motors.......................................................................................................................................43Arduino.....................................................................................................................................43Disseny exterior del robot.........................................................................................................44Disseny electrònic.....................................................................................................................44

Construcció del robot.....................................................................................................................45Sensors Blanc/Negre.................................................................................................................45Muntatge complet.....................................................................................................................46

Programant el robot.......................................................................................................................48Planificació del programa (Esquivar/ Seguir obstacles)...........................................................48Planificació del programa (Sumo)............................................................................................49

Observacions i possibles millores..................................................................................................495-Conclusió.........................................................................................................................................50

6-Bibliografía.....................................................................................................................................51Annexos.................................................................................................................................................I

Annex A............................................................................................................................................IAnnex B..........................................................................................................................................IIAnnex C.........................................................................................................................................IIIAnnex D.........................................................................................................................................IVAnnex E..........................................................................................................................................VAnnex F.........................................................................................................................................VIAnnex G.......................................................................................................................................VIIAnnex H......................................................................................................................................VIIIAnnex I..........................................................................................................................................IXAnnex J...........................................................................................................................................XAnnex K.........................................................................................................................................XIAnnex L........................................................................................................................................XIIAnnex M.....................................................................................................................................XIIIAnnex N......................................................................................................................................XIVAnnex O......................................................................................................................................XXIAnnex P....................................................................................................................................XXIII

Introducció

Aquest és un treball de recerca sobre Arduino, una plataforma de hardware lliure que acosta el món de la electrònica a tothom. Estudiar l'Arduino, la seva història, els tipus de plaques, alguns exemples d'aplicacions, el seu llenguatge de programació, però, és sols una part del treball. També m'agradaria entrar en el món dels robots de competició, explicant algunes de les seves modalitats. Finalment, ajuntant els dos camps, m'agradaria construir un robot de competició a partir de l'Arduino.

Sempre m'ha interessat el software i el hardware lliure, són realment mostres de generositat i altruisme per part del grup de persones que desenvolupa el software o el hardware i el posa a disposició de tothom de forme gratuïta i oberta sense esperar realment res a canvi. També m'agraden les competicions de robots, em semblen una forma divertida d'acostar la investigació tecnològica al públic en general. Per tant, en aquest treball he volgut unir dues coses que m'agraden per fer-ne una de sola, i a la vegada obtenir uns primers coneixements i experiència que podrien ser-me útils en un futur.

Els objectius d'aquest treball són els següents.

• Conèixer l'origen, història i objectiu del projecte Arduino.

• Recopilar informació sobre la seva programació i escriure una guia útil per a qui vulgui aprendre.

• Aprendre sobre les diferents modalitats de robots de competició.

• Construir un robot de competició mitjançant hardware lliure.

• Utilitzar solament recursos i software lliure en la realització del treball.

• Distribuir de forma lliure tot el contingut que s'hagi pogut generar realitzant aquest treball (Programes, imatges, esquemes...)

• Realitzar el treball exclusivament amb informació lliure distribuïda a través d'Internet per a us lliure.

Per poder complir amb els objectius, he hagut d'utilitzar una tipografia diferent a les demanades (Arial o Times New Roman) ja que ambdues tenen llicencies tancades. En canvi he usat la tipografia Liberation (En la seva versió amb Serif) distribuïda sota llicència “GNU General Public License”. També he realitzat el treball amb el paquet ofimàtic LibreOffice (GNU Lesser General Public License), el editor d'imatges GIMP (GNU General License), el programa de creació de gràfics 3D Blender (GNU General Public License) i el programa CAD LibreCAD (GNU General Public License).

El treball estarà dividit en 4 parts:

• Una primera part dedicada a l'Arduino, la seva història i les seves versions.

• Una guia de programació en Arduino

• Un capítol dedicat als robots de competició

• En capítol dedicat al disseny, construcció i programació del BONIFA-C0, el meu robot de competició.


1-Arduino: Una plataforma de hardware lliure.

La placa, computació físicaL'Arduino és una plataforma de desenvolupament de computació física, de codi obert, formada per una placa amb un senzill microcontrolador, de hardware lliure i un entorn de desenvolupament per programar-la.

La computació física, en el sentit mes ampli de la paraula, significa construir sistemes interactius físics que poden interactuar amb el món analògic. Rebre informació a través de sensors i respondre-hi.

Aquesta es una definició suficientment àmplia per incloure coses com ara sistemes intel·ligents de control de semàfors i tràfic, o control de processos en una cinta de producció, però, normalment, aquest terme no s' usa per aquest tipus d'aplicacions.

A la pràctica, computació física, es refereix a obres d'art, disseny, o projectes de bricolatge com a hobby, que usen sensors i microcontroladors per traduir una entrada analògica a un sistema de programari o control de dispositius, com ara podrien ser, motors, servos, il·luminació i altre tipus de maquinari

L' origen i desenvolupament de la placaAl poble Italià d'Ivrea, existeix un pub anomenat Bar di Re Arduino. Aquest Bar, era freqüentat per Massimo Banzi, el cofundador italià del projecte anomenat Arduino en honor a aquest pub.

L' any 2005, el projecte va ser iniciat per donar una alternativa a les cares plataformes de desenvolupament de les que disposaven el estudiants aleshores. Plaques com BASIC Stamp podíen arribar a costar fins a 150€.

Massimo Banzi i David Cuartielles van crear un primer prototip en 2 dies, i de seguida van decidir que havia de convertir-se en un projecte lliure.

Al equip es van unir David Melles i Tom Igoe, que es van encarregar del software, i Gialuca Martino, que va disposar els medis per a Manufacturar les plaques.

8

Randi Silberman Klett

D' esquerra a dreta: David Cuartielles, Gianluca Martino, Tom Igoe, David Mellis, and Massimo Banzi

Arduino Diecimila Imatge original de DanielrocaES

Llicencia Ceative Commons Reconeixement- Compartir Igual 3.0 No adaptada (CC BY-SA 3.0)


Models de la placaDes del primer prototip de la placa fins als actuals models mes moderns, han existit un gran ventall de models de la placa, aquí resumeixo els models mes destacats i les seves característiques principals.

Totes les imatges en aquest apartat han estat obtingudes directament de la web de l'Arduino i disposen d'una llicència Creative Commons:

Primer prototip

El primera placa, un prototip dissenyat i construït al 2005, tenia un disseny simple i no s'anomenava encara “Arduino”. Tot i així, els models actuals encara segueixen les pautes d'aquella primera placa.

El microprocessador és de la mateixa família que el que porten les plaques actuals, un ATmega. També disposava dels mateixos components bàsics que les actuals, com ara la presencia d'un LED d'indicació.

Aquest primer Arduino està basat en una placa anomenada “Wiring”, creada per Hernando Barragan, estudiant, per a la

seva tesis. “Wiring”, al igual que Arduino, és un projecte de Hardware lliure, amb, també, moltes possibilitats.

Arduino per soldar

Existeix una versió de l' Arduino on tots els components es troben a la mateixa cara, facilitant enormement la soldadura manual. La placa es comunica a través d'un port sèrie amb l'ordinador.

És una alternativa sols en el cas de que, per qualsevol motiu, no es pugui comprar un Arduino original, ja que el preu de tots els components al detall ronda els 30€.

És una placa abandonada i ja no es desenvolupen mes versions oficials. Tot i així, es comú trobar per Internet esquemes i versions personalitzades, per aficionats o professionals, de la mateixa.

9


Arduino USB

Els Arduino USB estan pensats per ser les versions principals i bàsiques de les plaques Arduino. Es poden connectar al ordinador amb un cable USB del tipus “Connector estàndard-B” com el de les impressores, que gairebé tothom te a casa. Això facilita la connexió i compatibilitat amb gairebé tots els ordinadors personals.

Han existit varies versions de la placa Arduino USB, cada una amb un nom específic:

L' Arduino USB va ser la primera placa anomenada “Arduino” com a tal.

Principalment es va vendre en forma de kits per a soldar, desmuntats.

Com a curiositat, la primera versió d'aquesta placa tenia un error en el Pin USB, a mes portava impresa la URL: “www.potemkin.org” la pàgina personal de Massimo Banzi. Això va ser canviat a la versió “Arduino USB v2.0” on el error del USB va ser reparat i la URL va ser canviada a “arduino.berlios.de”

L' Arduino Extreme (I la seva successora Arduino Extreme v2) Disposaven de molts mes components que les versions anteriors. Ja tenien els connectors femella a cada Pin (per facilitar la connexió de cables i estalviar soldar) . A mes disposaven de dos leds addicionals que mostraven quan s'estava transferint informació a la placa.

Finalment, va ser la primera placa en portar impresa la adreça web actual i definitiva del projecte Arduino: www.arduino.cc.

Aquests canvis s' han conservat fins a la versió actual.

L' Arduino NG (Nuova Generazione) i les seves revisions no van oferir gaires novetats. Les mes remarcables són:

Incloïen un LED al Pin 13, a mes a mes van afegir una resistència d'uns 1000 ohms al Pin 13, així que es podia connectar un LED directament en aquest Pin sense necessitat d'afegir cap resistència.

Finalment, el xip de la placa va ser canviat per una versió mes nova, però que no va comportar cap canvi significatiu en el funcionament bàsic de la placa.

Com les anteriors, aquests canvis s' han anat conservant.

10


El canvi principal en l' Arduino Diecimila va ser que es podia resetejar des de l'ordinador. També es va reduir el consum d'energia de la placa al ser usada amb una font d'energia externa (Adaptador de paret o bateria) .Es va incloure un fusible que protegia els USB del ordinador de curtcircuits i altres problemes.Algunes plaques portaven imprès “Prototype” però en realitat eren plaques definitives. Els prototips, en lloc de ser blaus, són vermells.

El principal i més important canvi en el Arduino Duemilanove va ser que la font d'energia (USB o font externa) es selecciona de forma automàtica, estalviant selectors presents en les versions anteriors.També afegeix una forma més senzilla per eliminar el reset automàtic de la placa.Uns mesos després de la seva sortida, el xip de la placa va ser canviat per una versió més moderna, i lleugerament més ràpida. L'últim model de les plaques USB que ha sortit al mercat és l' Arduino UNO.Els canvis principals respecte versions anteriors són: Alguns components han sigut canviats per versions més noves i més petites, com és el cas del xip que podem veure en totes les plaques després del connector USB (Que té la funció de transformar la senyal USB a una senyal serie, que és la que pot “entendre” el xip principal).També s'ha canviat la forma en la que els Pins estan retolats, sent així mes fàcils d'entendre i distingir.

11


Arduino Mega

Els Arduino Mega són versions de la placa Arduino pensades per a projectes que requereixin més pins, ja siguin digitals, analògics...

Es poden connectar als ordinadors de la mateixa forma que els Arduino USB.

La placa Arduino Mega original disposa de 54 pins d'entrada i sortida digital (14 dels quals poden ser usats per transmetre senyals modulats) i 16 pins analògics.

La resta d'especificacions són semblants a les de qualsevol altre Arduino USB.

La versió Mega 2560 va ser llançada al mateix temps que l'Arduino UNO.

La seva principal característica és que disposa de gairebé el doble de memòria que la versió anterior.

La senyalització dels pins també ha canviat per adaptar-se al disseny nou de totes les plaques Arduino.

Apart d'aquests aspectes, no hi ha hagut modificacions destacables.

Arduino LilyPad

Els Arduino LilyPad tenen una forma circular i estan dissenyats per a ser cosits en roba o altres superfícies flexibles.

Necessiten un adaptador especial per a ser connectats al ordinador, però així no necessiten un connector USB i permeten estalviar moríssim lloc a la placa.

El primer LilyPad, el LilyPad 00, podia ser programat amb l' ordinador a través dels 10 pins que es poden veure a la imatge (Dreta).

Com a rellotge usava el integrat en el microxip en lloc d'un d'extern, principalment per estalviar espai en la placa.

Disposava de 6 pins analògics i 14 de digitals, però cap Pin de 5V ni de GND.

No va ser comercialitzada a gran escala, ja que era nomes un disseny i tenia grans limitacions.

La versió 01 del Arduino LilyPad, la primera en sortir a la venda oficialment, ja no es programava amb els 10 pins del diseny00, sinó que en lloc disposava de 6 pins i de 4 més a la part superior, cosa que feia molt més fàcil la seva programació.

Finalment, es va afegir el Pin de 5V i el GND, que no eren presents en la versió 00.

El rellotge que usava, però, seguia sent un integrat en el propi xip.

12


La versió 02 de l' Arduino LilyPad, ja incloïa un rellotge extern al microxip.

També es va canviar el programa pre-grabat del microxip; fins aleshores, al escriure un programa a la placa i alimentar-la, el programa no s'inicialitzava immediatament.

Després d'aquest canvi, la placa era capaç d'iniciar el programa immediatament un cop era alimentada.

El color de la placa va canviar a un morat més intens.

Finalment, la versió 03 i la actual, la 04 són pràcticament idèntiques.

Es va introduir el suport per a Reset automàtic, això vol dir que no calia pressionar el botó de “Reset” cada cop que calgués gravar un programa nou.

Finalment, tots els components van passar a ser muntats directament sobre la superfície de la placa, deixant així la part posterior lliure de “punxes” que podien fer malbé els teixits on havien de ser cosits.

Altres plaques Arduino

A part de totes aquestes plaques que acabem de descriure, existeixen una gran varietat de plaques amb usos molt diversos, a continuació una descripció de les mes destacables:

Arduino BT (Bluetooth)

L' Arduino BT, és una placa Arduino que suporta comunicació sèrie a través de la tecnologia inalàmbrica Bluetooth.

Com la majoria d'altres Arduino, disposa de 14 pins digitals d'entrada/sortida i 6 pins analògics.

És una placa interessant sobretot per aplicacions en les que no és gaire pràctic moure la placa prop d'un ordinador. (Per exemple la placa es troba a una alçada considerable).

Arduino Nano

L' Arduino Nano, és una placa completa, però molt més compacta, gràcies a que una part des components es troben muntats en una altra capa de la placa al dors.

L' Arduino Nano està pensat per ser usat en plaques de proves, per tant, els seus pins són mascles (en lloc de ser femella, com en la majoria d'Arduinos), mes llargs del normal, i muntats a la part inferior de la placa, facilitant així ser encaixat.

13


Arduino Mini

L' Arduino Mini és una versió super-compacta i super-miniaturitzada de l' Arduino.

Es bona per a projectes amb poc espai i que requereixin poc voltatge.

Arduino Fio

El principal propòsit de la placa Fio son les aplicacions inalàmbriques.

Principalment es pot usar amb mòduls del tipus Xbee.

Arduino Ethernet

La placa Arduino Ethernet no disposa de connexió USB, però en lloc d'això pot ser connectada a la xarxa a través de la connexió Ethernet.

Amb un modul especial, la placa pot inclús, ser alimentada a través d'Ethernet.

Finalment, disposa d'una entrada per a targes Micro SD.

Arduino Mega ADK

Aquest Arduino no difereix gaire dels actuals Arduino Mega, però hi ha una diferència important. A part de disposar els 54 pins digitals i els 16 analògics de la versió Mega, a més també té una entrada USB pensada per ser usada amb un dispositiu mòbil amb el sistema operatiu Android.

Pot ser usada tan com per controlar l'Arduino des de l'Android (per exemple enviar i rebre informació de sensors, fer actuar motors...) com per controlar l'Android des de l'Arduino (usar el teclat, la càmera...).

14


Futures plaques

Arduino és un projecte en desenvolupament continuu, per tant constantment es desenvolupen nous models. A continuació descric les plaques oficials que han sigut ja anunciades, però que no han sortit encara a la venda. Aquestes plaques formaran la següent generació d'Arduinos.

Arduino Leonardo

L'Arduino Leonardo serà la següent placa USB que sortirà.

Disposa de 20 Pins analògics (12 es poden usar com a entrada analògica) i es podrà connectar al ordinador per Micro USB.

La principal novetat és que s'elimina la necessitat d'usar un segon Xip per traduir les senyals que arriben per l'USB a una senyal que el ATmega pugui usar, per tant, afegeix la possibilitat de poder controlar l' ordinador des de la placa,

cosa que abans no era possible ja que hi havia aquest segon xip entremig.

La placa, a mes, estarà disponible amb i sense els pins i el jack soldat.

Per acabar, una altre característica molt destacable serà el seu preu, que rondarà els 15€ en la versió sense pins i els 17€ en la que porta els Pins. Aconseguint així un preu increïblement baix, i podent així arribar encara a mes gent.

Arduino Pro

Aquesta placa Arduino està pensada per a instal·lacions permanents.

Disposa de 14 pins digitals i de 6 analògics, al igual que la majoria de les altres plaques Arduino USB, però a diferencia d'aquestes, la pro no disposa d'un port USB i es pot comunicar amb l' ordinador d'una forma semblant a les Arduino LilyPad.

No disposa de pins, ja que com que està dissenyada per ser semi permanent, està pensada per a ser directament soldada.

Com a novetat, porta un interruptor per poder ser engegada i parada.

Arduino DUE

Molt poc es sap d'aquesta placa, però és la nova generació de les plaques Mega, i la segona de la línia principal d'Arduinos (Després de la UNO).

Comparteix amb la Leonardo la absència del xip que traduïa el senyal de l'USB, per tant també les possibilitats que això comporta.

15


Alguns projectes amb ArduinoGracies a la flexibilitat de la placa Arduino, al llarg del temps han anat sorgint grans projectes, de tot tipus, i increïblement útils i imaginatius.

La gran majoria d'aquests projectes es poden veure a Internet, i alguns d'ells fins i tot poden ser construïts per un mateix si es disposa de la habilitat i coneixements necessaris.

A continuació, i a mode d'exemple, podeu veure alguns dels millors projectes que han anat sorgint tots al voltant de la plataforma Arduino.

ArduSat

El projecte ArduSat neix de la idea de acostar la exploració espacial a tothom de forma assequible.

Un cop llançat a l'espai, l'ArduSat (Arduino + Satèl·lit) serà la primera plataforma oberta en permetre al public general dissenyar i executar les seves pròpies aplicacions, jocs i experiments relacionats amb l'espai. També permetrà usar les seves càmeres integrades per prendre fotos sota demanda. L'ArduSat ha estat financiat mitjançant Crowdfunding.

L'ArduSat és un satèl·lit en miniatura, té unes dimensions de 10cm x 10cm i pesa aproximadament 1Kg. En el seu interior es troben més de 25 sensors diferents, incloent 3 càmeres, un comptador Geiger, un

espectròmetre, un magnetòmetre... Tots connectats a processadors Arduino, programables per l'usuari, llestos per recollir dades de l'espai.

Alguns exemples d'experiments que el satèl·lit podria realitzar son els següents:

Ciència: Detectar meteorits. Cada dia petits meteorits xoquen contra l' atmosfera i deixen cues de gas ionitzat que reflexen les senyals de ràdio de la terra i aquestes poden ser detectades pel Satèl·lit.

Finances i Seguretat: Crear nombres Aleatoris reals. Els rajos còsmics són realment aleatoris, i es poden usar per generar una seqüència

d'aquests nombres, útils, per exemple, per provar models financers.

Entreteniment: Un concurs de fotografia espacial o un “Bingo!” usant les lectures del comptador Geiger. Existeixen centenars de

maneres d'usar el satèl·lit i els seus sensors per a entreteniment.

Enginyeria: Totes les funcions de la càmera són configurables, exposició, balanç de blancs, color... Com es poden prendre millors fotos?

Imatge propietat de l' equip de l'ArduSat

Distribució interna dels components del satèl·lit

16


Projecte RepRap

El Projecte RepRap (Replicating rapid prototyper) és una iniciativa per desenvolupar una impressora 3D capaç d'imprimir la gran part dels seus components.

Es tracta d'un disseny de hardware obert, per tant, tothom pot agafar els dissenys i programes de la impressora, comprar els materials i construir-la.

El principal controlador de les ultimes versions de les impressores del projecte RepRap és un Arduino USB, tot i que és possible usar altres opcions aquesta és la mes recomanada.

L'objectiu del projecte RepRap és produir un dispositiu capaç de replicar-se a si mateix per poder posar copies a les mans de gent d'arreu del planeta amb un desemborsament mínim de diners. Això permetria disposar d'un sistema de fabricació d'escriptori capaç de fabricar artefactes necessaris en la vida quotidiana.

També podria canviar la visió del mont actual sobre el disseny i consum d'objectes patentats i obrir tot un mon de possibilitats d'objectes no patentats amb especificacions

obertes. La naturalesa auto-replicant de RepRap pot facilitar la difusió viral de les impressores 3D amb preus populars, i així acostar el món del disseny i millora dels objectes a la població en general.

Actualment la RepRap treballa bé amb termopolímers (Com el ABS) però, a diferència de moltes impressores comercials, el projecte RepRap anima als seus usuaris a experimentar amb nous mètodes i materials, i compartir els seus resultats. Mètodes per imprimir amb materials com la ceràmica s'han desenvolupat d'aquesta forma.

S'està experimentant amb metalls amb baixos punts de fusió o polímers amb traces metàl·liques que que si s'aconseguissin fer servir per imprimir circuits electrònics seria tot un èxit ja que aleshores la RepRap seria totalment independent en la seva fabricació.

17

La RepRap és capaç de fer còpies de gairebé totes les seves parts (a la imatge primera RepRap feta amb una altre RepRap)

Llicència:Creative Commons Attribution-Share Alike 3.0 Unported SteveBaker


2-Arduino: Llenguatge de programació

IntroduccióExisteixen moltíssimes guies i tutorials a Internet sobre el lèxic de programació en Arduino, però la gran majoria són immenses llistes de comandaments i exemples, poc organitzades, i pensades per a gent que ja té una base en la programació. Finalment, el material disponible en Espanyol és poc, i en Català és pràcticament inexistent.

Així que en aquesta guia de referencia, he intentat recopilar les funcions bàsiques i deixar de banda les complementaries que pràcticament no s'usen, amb explicacions senzilles perquè algú sense experiència pugui entendre sense cap problema, i amb exemples bàsics i senzills, explicats línia a línia.

En definitiva, és una guia escrita per algú que està aprenent dirigida a algú que està aprenent. Al realitzar la guia en català, a partir de documents principalment en anglès, existeixen alguns conceptes, com serien “pin” o “array”, que he mantingut, ja que són usats de forma general en tots els idiomes, i una traducció hauria sigut molt forçada.

El llenguatge de programació de l'Arduino està basat en el conegut llenguatge de programació C/C++, un llenguatge molt eficient, que amb no moltes línies de codi ens permet obtenir un programa funcional. Tot i que ha sigut modificat perquè resulti encara més fàcil d'aprendre i usar.

Els programes d'Arduino es divideixen en 3 parts principals: La estructura, que és la manera com s'ha d'organitzar el programa; els valors, que poden ser variables o constants; i finalment les funcions, que són les accions que pot realitzar l'Arduino.

18


Estructura Bàsica

Estructura

La estructura bàsica perquè el programa de l' Arduino funcioni és:

void setup() { Ordres; }

void loop() { Ordres; }

Setup()

La funció setup() s' executa una sola vegada al començar el programa, ha de ser inclosa encara que no contingui res.

void setup() { pinMode(pin, OUTPUT); //Marca "pin" com a Output, o sortida }

Loop()

Després de la funció setup(), la funció loop() fa precisament el que diu el seu nom, es repeteix constantment en un “loop”.

void loop() { digitalWrite(pin, HIGH); //Engega "pin" delay(1000); //Pausa el programa 1 segon digitalWrite(pin,LOW); //Apaga "pin" delay(1000); //Pausa el programa 1 segon }

19


Funcions

Una funció és un bloc de codi amb nom que conté les diferents ordres que s' executen al “cridar” la funció.

Poden ser usades per a realitzar tasques repetitives i reduir l' espai en el programa principal.

Primer es posa el tipus de funció, aquest és el tipus de valor que ha de retornar la funció, per exemple “int” per a un valor enter. Si no ha de retornar res el tipus serà “void”. Després s' ha d'indicar el nom de la funció i els seus paràmetres.

tipus nomdelafunció(paràmetres) { Ordres; }

La següent funció entera serveix per crear un valor de “delay” a partir de la lectura del valor d'un potenciòmetre, primer es crea una variable “v”, es dona a “v” el valor del potenciòmetre, un nombre entre 0 i 1023, i es divideix per obtenir un valor entre 0 i 255, finalment retorna “v” al programa principal.

int valordedelay() { int v; //crea una variable temporal "v" v=analogRead(Potenciòmetre); //Llegeix el potenciòmetre v/=4; //Divideix per 4 Return v; //retorna el valor de "v"

{}Claus

Defineixen l' inici i el final dels diferents blocs, com per exemple “void loop()”:

tipus funció() { Ordres; }

Una clau d'obertura ({) sempre ha d'estar acompanyada per una de tancament (})

20


; Punt i Coma

S' ha de posar “;” al final de cada línia, per separar els components d'un programa, també serveix per separar els elements d'un “loop”

int x=13; //declara la variable "x" amb el valor enter "13"

Si falta en alguna línia, el programa retorna un error, per tant s' ha d'estar atent en no deixar-se'l.

/*...*/ Bloc de comentaris

Son àrees que el programa ignorarà, s' usen per a llargues descripcions de text, normalment amb la finalitat de descriure un programa.

Com que els comentaris no ocupen lloc a la memòria, és recomanable usar-los generosament.

/* Comentari de varies línies. sempre ha de ser tancat */

// Comentaris de línia

Comentaris que comencen amb “//” i acaben al final de la línia.

//Comentari de línia

21


Variables

Variables

Una variable és una manera de donar nom i guardar un valor numèric. Com indica el seu nom, les variables poden canviar contínuament, al contrari de les constants, que mai canvien.

int variable=0; //crea una variable i li dona valor de 0 variable= analogRead(2) //li dona el valor de la lectura del

pin analògic 2

“Variable” és la variable en el programa.

També es pot comprovar la variable en qualsevol moment per veure si compleix certes condicions o es pot usar el seu valor directament.

if (variable<100) // testeja i comprova si es menor de 100 { variable=100; //si es així li dona valor de 100 }

delay (variable); //usa la variable com a delay

Declaració de variables

Totes les variables necessiten ser declarades abans de ser usades.

Això vol dir definir el tipus de valor (int, long, float, etc...), un nom específic i, opcional-ment, un valor, això sols s' ha de fer un cop en el programa, però el valor pot canviar en qualsevol moment

int variable=0; //crea una variable i li dona valor de 0

Posició de les variables

Depenent d'on es declari la variable, aquesta estarà disponible per a una o altre part del codi.

int valor; //"valor" pot ser usat en qualsevol part del codi

void setup() { //no necessita setup }

22


void loop() { for (int i=0; i<20;) //"i" nomes pot ser usat dins del loop

// "for" {i++; }

float f; //"f" es pot usar dins del loop principal }

23


Tipus de “dades”

Byte

“Byte” emmagatzema una xifra de 8-bits sense decimals, te un rang entre 0 i 255

byte variable= 180; // Declara “variable” com una de tipus //byte

Int

Els enters són el principal tipus de dada, es guarden en 16-bits, sense decimals, i amb un rang entre 32.767 i -32.768.

int variable=1500; //declara “variable “ com una de tipus //enter

Les Variables enters donen la volta al passar el seu màxim o mínim, per exemple, si x=32.767 i la següent ordre afegeix “1” a “x” (x= x+1 o x++), el valor de “x” donarà la volta i passarà a ser -32.786.

long

És un tipus de dada entera estesa, es guarda en 32-bits, sense decimals, pot estar entre 2.147.483.647 i -2.147.483.648

long variable= 90000; // declara “variable” com una de tipus //“long”

float

És un tipus de dada per a nombres que tenen un punt decimal, es guarden en 32-bits i amb un rang entre 3,4028235E+38 i -3,4028235E+38

float variable=3,14; //declara “variable com una de tipus //“float”

Els nombres decimals no són exactes, i poden donar lloc a resultats estranys al comparar-se entre ells, a més a més, els càlculs amb dades d'aquest tipus són molt més lents que les operacions amb dades de tipus enter, així que s' han d'evitar el màxim possible.

24


Arrays

Els arrays són una col·lecció de valors accessibles mitjançant un nombre d'índex del valor. Els arrays estan indexats a 0, per tant, el primer valor tindrà el nombre d'índex 0.

Un array ha de ser declarat (i de forma opcional amb valors assignats) abans de poder ser usat en el programa:

int Array[]={Valor0, valor1, valor2...}

Es possible declarar un array només dient el nom, la mida i el tipus, assignant valors més tard:

int Array[5]; //declara un array enter amb 6 posicionsArray[3]= 10; //posa el valor “10” a la 4a posició de la

//llista

Per usar un valor d'un array, es posa el nom i la posició:

x=Array[3]; // es dona a “x” el valor 10

Els arrays són sovint usats en loops “for” on l' increment correspon a un index de posició.

L' exemple següent usa un array per fer fer pampallugues a un led, usant el loop “for”, el cantador comença a 0 (A l' array es el valor 180), espera 200 ms, i després fa el mateix amb el següent valor.

Int ledPin=10; //Led al pin 10

byte pampallugues[]= {180, 30, 255, 200, 10, 90, 150, 60}; //array de 8 valors diferents

void setup(){pinMode(ledPin, OUTPUT); //assenyala pin3 com a sortida}

void loop(){

for (int=i=0; i<7; i++); // “i” equival al index del array{analog write(ledPin, pampallugues[i]);delay (200); // espera 200 milisegons}

}

25


Aritmètica

Aritmètica

Els operadors aritmètics incloses suma, resta, multiplicació i divisió, retornen la suma, la diferència, el producte i el quocient (respectivament) de dos operands

y= y+3; //Sumax= x-7; //Restai= j*6; //Multiplicaciór= r/5; //divisió

Les operacions es fan segons el tipus de dada dels operands, per exemple dividint els enters 9 entre 4, el resultat seria 2, en lloc de 2,25, ja que els enters no suporten decimals. Això també significa que el resultat donarà la volta si el resultat és més llarg que el que pot emmagatzemar el tipus de dada.

En operands de diferent tipus, el més gran serà el tipus de dada del resultat, per exemple, al multiplicar un enter (“int”) per un nombre amb decimals (“float”), retornarà un resultat de tipus “float”

Per convertir un tipus de dada en un altre, es pot fer així:

i= (int) 3,6; //i val 3, (“int” no accepta decimals)

Operadors compostos

Són usats sovint en loops, i combinen una operació aritmètica amb una variable.

Els més comuns son:

x++ // sumar 1 a xx-- // restar 1 a xx+=y // sumar y a xx-=y // restar y a xx*=y // multiplicar x per yx/=y // dividir x entre y

26


Operadors de comparació

Compara una constant o una variable amb una altre, sovint s' usen per testar si una condició és certa:

x==y //x és gual a yx!=y //x no és igual a yx<y //x és menor a yx>y //x és major a yx<=y //x és menor o igual a yx>=y //x és major o igual a y

Operadors lògics

Són usats per comparar 2 expressions i retornen “TRUE” si és certa o “FALSE” si no ho és. N'hi ha 3: AND, OR i NOT. S' usen sovint en blocs “if”

AND lògic:

if (x>o&&x<5) //cert si les 2 expressions ho són

OR lògic:

if(>0||y>0) //cert si qualsevol de les 2 expressions és certa

NOT lògic:

if(!x>0) //cert si la expressió no és certa

27


Constants

Constants

En el llenguatge de programació del Arduino, existeixen varis valors preestablerts, les constants.

TRUE/FALSE

“FALSE” es pot interpretar com a fals, 0, incorrecte, mentida... i “TRUE” es cert, 1, correcte, veritat... etc.

If (b==TRUE);{Ordres;}

HIGH/LOW

Constants usades per llegir o escriure en els diferents Pins: HIGH és encès (o 5V) i LOW, apagat (o 0V).

digitalWrite (13, HIGH);

IMPUT/OUTPUT

Constants usades amb pinMode() per desriure si un pin és un IMPUT (entrada) o un OUTPUT (sortida)

pinMode (13,OUTPUT);

28


Control de flux

If

Comprova si certa condició és certa, si ho és, executa la tasca, sinó, o sigui, és falsa, la salta.

If (variable==valor){Ordres;}

L' exemple comprova si “variable” és igual a “valor”, si ho és, executa les ordres, si no, salta el bloc.

If... Else

If (InputPin<500){accióA;}

else if (InputPin>=1000){accióB;}

else{accióC;}

Comprova si “InputPin” és mes petit que 500, si ho és, executa la “accióA”, de no ser així, salta el bloc i comprova si és mes gran o igual a 1000, de ser així, realitza la “accióB”, en cas contrari salta el bloc i efectua la “accióC”

En un programa poden aparèixer tants blocs seguits “else if” com sigui necessari, que s' aniran comprovant l' un darrere l' altre.

29


For

El loop “for” repeteix el programa que conté un nombre especific de cops, pràcticament sempre s'usa un comptador d'increment amb aquesta funció per tal de que es repeteixi cert nombre de cops.

Al declarar la funció, s' han de especificar 3 paràmetres diferents, separats per un “punt i coma” (;), l'estructura bàsica del loop és la següent:

for (inicialització; condició; expressió) //Els 3 paràmetres } //entre parèntesisacció;}

La “inicialització” d'una variable local (nomes usada en aquest loop), o comptador d'increment, es produeix al principi i sols un cop. Cada cop que s' efectua el loop, es comprova si es compleix la “condició”, si és així, s' efectua la “expressió” i el loop; un cop la “condició” esdevingui falsa, el loop acabarà.

for (int i=0; i<20; i++) //Declara i, comprova si es menor a { //20 i suma 1digitalWrite (13, HIGH); //engega el pin 13delay(250); //pausa 1/4 de segondigitalWrite (13,LOW); //apaga el pin 13delay(250); //pausa 1/4 de segon}

Aquest exemple, crea un valor de 0, i mentre sigui menor a 20, sumarà 1 i reproduirà el loop.

While

En un loop “While” , tot el que sigui declarat s'anirà repetint mentre la expressió entre parèntesis sigui falsa.

Aquesta és la estructura bàsica del loop “while”:

while (variable ?? valor){acció;}

En el següent exemple es comprova que la “variable” sigui menor a 200, si ho és, executa les accions que conté, suma 1 a la “variable” i torna a repetir, fins que “variable” sigui major a 200:

30


while (variable<200) //comprova si es menor a 200{acció; //executa les ordres que contévariable++; //suma 1 a la variable}

Do... While

Aquest loop és igual al anterior, amb la única diferencia de que la condició és comprovada al final, per tant , les ordres s' executaran com a mínim un cop.

do{acció;} while (variable ?? valor)

31


INPUT/ OUTPUT Digital

PinMode (Pin,Mode)

Usat a “void setup()” per declarar si un Pin és d'entrada (INPUT) o de sortida (OUTPUT)

PinMode(pin, OUTPUT); // declara “pin” com a sortida

Els pins de l'Arduino estan de forma predeterminada com INPUT, per protegir-los de qualsevol entrada de corrent involuntària, així que, si no es vol, no és necessari especificar-los explícitament.

Digital read

Llegeix el valor d'un pin i retorna HIGH o LOW, pin pot ser una variable o una constant (1~13)

valor= digitalRead(in); //la variable “valor” pren com a valor //la lectura del pin digital

Digital write

Envia a un pin de sortida (o Output) “HIGH” (5v) o “LOW” (0v)

digitalWrite (pin, HIGH) //envia 5v a “pin”

digitalWrite (pin, LOW) //apaga “pin”

32


INPUT/ OUTUPUT Analògic

Analog Read

Llegeix el valor d'un pin analògic especific, aquesta funció només funciona als pin analògics (0~5) i retorna valors entre 0 i 1023.

valor= analogRead (pin); //dona a “valor” el valor del pin

Els pins analògics no necessiten ser declarats com a INPUT/ OUTPUT.

Analog Write

Escriu un valor pseudo-analògic usant PWM (Pulse With Modulation), en els Arduinos amb Atmega 168, funciona als pins3, 5, 6, 9, 10 i 11, als Arduinos amb Atmega 8, només funcionen els pins 9, 10 i 11.

Pot ser un valor entre 0 i 255.

analogWrite (pin, valor); // envia “valor” a “pin”

Un valor de 0, genera 0 volts al pin específic, i un valor de 255 genera 5 volts al punt de sortida.

Com més alt sigui el valor, més estona el pin estarà en HIGH, per exemple, amb un valor de 64, estarà 3/4 del temps en 0v i 1/4 en 5v. Un valor de 128 estarà la meitat del temps a 5v i la meitat a 0v i un de 192 estarà a 0v 1/4 del temps i la resta a 5v.

33


Temps i Càlculs

Delay (ms)

Pausa el programa per una quantitat de temps, en milisegons (1000ms = 1s)

delay(1000); //Pausa el programa 1s

Millis()

Retorna el nombre de milisegons transcorreguts des de que l' Arduino ha començat a executar el programa, en un valor del tipus “Long” (Tornarà a 0 després d'aproximadament 9 hores):

valor= millis(); // “valor” pren el valor de “millis()”

Min (x,y)

Retorna el més petit dels dos nombres:

valor= min(valor1, valor2) // “valor” pren el valor de valor1 // o de valor2, depenent de quin // sigui el més petit

Max (x,y)

Retorna el més gran dels dos nombres:

valor= max(valor1, valor2) // “valor” pren el valor de valor1 // o de valor2, depenent de quin // sigui el més gran

34


Aleatori

Random seed (seed)

Dóna un valor, o seed, com a punt de partida a la funció random()

random seed(valor) //defineix “valor” com a seed.

L' Arduino no pot generar nombres verdaderament aleatoris, per tant, random seed et permet donar-li un punt de partida per generar-ne un; pot ser una variable, constant, funció, milis(), inclús un analogRead() per usar el soroll elèctric a través d'un pin analògic.

Random(max)/ Random (min, max)

Retorna nombres pseudo-aleatoris dins d'un rang màxim i mínim.

valor= random(100, 200); //dona a “valor” un valor aleatori //entre 100 i 200

És necessari usar “Random seed()” abans d'usar aquesta funció.

35


Serial

Serial.begin (velocitat)

Obre un port serie i assigna una velocitat (en bits per segon) . Generalment s'usa 9600, tot i que altres velocitats són suportades.

Void setup(){Serial.begin(9600); //obre un port serie a 9600bps}

Usant la comunicació en serie, els pins digitals 0 (RX) i 1 (TX) (S' usen per a la transmissió de dades) no poden ser usats.

Serial.println(val)

Envia (o mostra, imprimeix) dades a través del port serie. Amb un canvi de línia al final (retorn) després de cada valor.

Serial.println(42); //envia per port serie el valor 42

36


3-Robots de competició

IntroduccióLes competicions de robots són esdeveniments que han anat guanyant popularitat la última dècada,a mesura que la electrònica i la robòtica ha anat esdevenint més popular entre els aficionats.

En les competicions, els robots han d'executar una certa tasca. Normalment consisteix en derrotar a altres competidors per tal d'aconseguir ser el millor en una eliminatòria.

Moltes universitats organitzen competicions, però cada cop hi ha mes professionals que també participen.

Els robots que participen en les competicions han de ser completament autònoms i han de complir el reglament oficial per a cada una de les modalitats i competicions.

Hi ha desenes de competicions robòtiques arreu del mon, en múltiples modalitats i disciplines (A la imatge el logotip dels Robogames, la competició més gran del món) i s'organitzen segons tipus:

Exterior: Normalment es tracta de curses de velocitat i/o orientació en pistes exteriors. Els robots acostumen a ser de gran mida.

Interior: Acostumen a ser robots de mida més petita, existeixen desenes de modalitats i encara hi ha més competicions. La Robocup i els Robogames són competicions d'aquest grup. Mes endavant parlaré d'aquest grup de forma més concreta.

Subaquàtiques: Aquest tipus de competició és molt recent i està destinada a investigadors que desenvolupen vehicles subaquàtics autònoms. Els participants han de realitzar tasques com seguir recorreguts marins, prendre dades amb els seus sensors...

Aèries: Consisteixen principalment de competicions de petits vehicles autònoms que realitzen curses o segueixen recorreguts, esquiven obstacles... Últimament, la modalitat de quadricropters que han de realitzar certa tasca o han de cooperar entre ells per aconseguir els objectius ha esdevingut molt popular.

Modalitats d'interiorEn els següents apartats ens centrarem exclusivament en robots del tipus interior, ja que es tracta del tipus més popular entre aficionats, a diferencia de la resta de modalitats que estan més destinades al sector professional. Podreu veure un resum de les categories més populars, així com un resum de la seva normativa i el funcionament dels seus participants.

37


Seguidors de línies

Es tracta dels robots mes senzills, ja que sols estan programats per seguir una línia en un fons blanc, tot i que els podem separar en els que sols recorren una línia i en els que segueixen un laberint amb múltiples bifurcacions.

No existeixen normes generals per a aquesta modalitat, sols és necessari que sigui autònom (No teledirigit). Algunes competicions poden demanar que el robot completi un circuit de proba en un temps límit abans de poder entrar en la competició, per evitar la acumulació de robots lents.

Els robots poden funcionar tenint un mínim de dos sensors i pràcticament no hi ha màxim. Com més sensors hi hagi, mes estable serà el robot, i a més situacions diferents podrà reaccionar, però el codi serà més complex.

Micromouse

Els micromouse o robots de laberint, són robots amb un format molt reduït, que han d'aconseguir arribar a una zona específica del laberint en el mínim temps possible.

Les parets del laberint són de color vermell fosc, excepte les de la zona final i les de la zona inicial, que són de color blanc brillant, ajudant així al ratolí saber més o menys on es troba la meta.

Les categories existents són micromouse, micromouse 1/2 i micromouse 1/4 (La meitat i un quart del format de la categoria original)

El programa del robot no és excessivament complex, però és necessari un disseny molt precís, que permeti als sensors i als motors treballar a la màxima velocitat possible, ja que el temps de reacció és molt important en una competició de velocitat.

38

Funcionament amb dos sensors

Imatge propietat del projecte stravaganza

Funcionament amb 3 sensors

Imatge propietat del projecte stravaganza

Robot de la categoria 1/4 Imatge propietat de "Kato-san"


Cowbots

Els Cowbots, com bé indica el seu nom, estan basats en els cowboys de les pel·lícules del oest. Són robots que s'enfronten en parelles en un duel.

Els robots normalment disposen de 2 armes, una cos a cos i l' altre de llarg rang, normalment disparant projectils tous, com pilotes d'espuma.

És una modalitat popular a les competicions d'Amèrica Llatina i és difícil veure-la en altres competicions, tot i així cada vegada guanya més popularitat perquè és una competició molt dinàmica i que atreu a molta gent.

Els Cowbots acostumen a usar varis sensors de proximitat (El de la imatge podem veure que porta 3 al davant, però a la part de darrere porta 2 més, tots d'ultrasons). Els sensors per detectar marques al terra no són necessaris, ja que la zona de batalla està delimitada per unes “parets”.

Els projectils poden ser propulsats mitjançant aire comprimit, tot i que són més populars sistemes basats en gomes elàstiques, que tot i ser més imprecises i lentes, simplifiquen el procés.

No és molt necessari que els robots siguin molt estables, ja que el combat cos a cos és molt difícil que es produeixi, per això és molt

comú trobar robots molt alts, que tot i no ser molt estables donen al Cowbot un rang de visió més gran i li permeten veure per sobre de qualsevol obstacle que hi hagi en el camp de batalla.

Competicions de bípedes

Existeixen desenes de modalitats diferents en les que participin robots bípedes (Coneguts com Androides per la seva forma humana). Aquí resumiré les més populars.

Dansa: Els robots executen una coreografia al ritme d'una cançó, que tant pot ser lliure com prèviament establerta pels organitzadors. Un jurat decideix el guanyador.

Marató o cursa: Els Androides competeixen en una cursa, més o menys llarga. El guanyador és el primer en arribar a la meta.

Lluita: Els robots lluiten cos a cos. El guanyador és l'últim robot que quedi dret.

Habilitat: Els robots executen una demostració d'alguna habilitat (Per exemple robots que poden saltar a corda, o que poden actuar). Un jurat decideix el guanyador.

39

Primer lloc a la Latin American Robocup.

Robot i imatge propietat de: Daniel Maturano i Guillermo Zañartu. Imatge usada amb el permís del propietari.

1a marató robòtica

Imatge propietat de l' equip Vsotne, usada amb permís del propietari


Sumo

Les competicions de sumo robot consisteixen en dos robots intentant empènyer l'enemic fora del ring, de forma semblant a com es fa en el Sumo tradicional.

El robot ha d'aconseguir detectar l' enemic, normalment usant un sensor infraroig o per ultrasons. També ha de ser capaç d'evitar caure de la zona de batalla, per tant s'usen sensors infrarojos capaços de detectar la diferència entre blanc i negre.

Els robots de sumo estan dividits en categories segons les seves dimensions i el seu pes. Les dimensions del ring en el que competeixen també varien en funció de la categoria.

En la següent taula resumeixo les característiques de les 3 categories més populars: Categoria Japonesa, Categoria Mini i Categoria Micro, així com les dimensions del ring corresponent.

Dimensions màximes Pes màxim Diàmetre del ring

Japonesa 20x20cm 3Kg 154cm

Mini 10x10cm 500g 77cm

Micro 5x5cm 100g 38,5cm

Tot i així, existeixen altres categories, des de les més petites, com les Nano i les Femto (2,5x2,5 i 1x1 centímetres respectivament) que lluiten en rings de mides semblants a les d'un CD, fins a les més grans, com la categoria Ontario, que poden arribar a pesar 16Kg.

40

Diagrama d'un ring de sumo.

Imatge de domini public, creada per la organització de la competició Robothon.


4-BONIFA-CO El robot de competició que funciona amb Arduino

IntroduccióCom hem vist, Arduino és una plataforma molt flexible i fàcilment programable amb la que podem, entre centenars d'altres coses construir un robot de competició com algun dels que hem vist en l'apartat anterior.

Com a objectiu final d'aquest treball, m'agradaria sintetitzar tot l'après en un projecte final: La construcció d'un robot de competició usant Arduino com a plataforma de desenvolupament.

En un projecte d'aquest tipus és molt important la planificació prèvia, ja que és important no cometre cap error que pugui afectar el robot de forma que mai arribi a funcionar.

Planificació teòricaPer a la planificació del robot caldrà primer decidir quines funcions volem que realitzi per decidir components volem usar.

Hem de decidir amb molta cura quins components comprar, i elegir els adequats.

Després hem de fer esquemes per tenir una idea aproximada del disseny final del robot

Funcions del robot

El robot serà un robot de competició, però com que l'objectiu no serà presentar-lo a una competició oficial sinó provar el funcionament i programació de la placa Arduino no és necessari centrar-nos en una sola modalitat i podem construir un robot amb els components necessaris per realitzar funcions diverses.

El meu robot realitzarà les següents funcions:

• Esquivar obstacles

• Seguir obstacles

• Seguir línies

• Lluitar a Sumo

Per tant hem d'elegir els sensors necessaris per tal de que pugui realitzar aquestes operacions.

41


Sensors del robot

El robot necessitarà detectar obstacles o cossos a davant seu, per tant necessita un sensor que li permeti realitzar això.

El sensor que necessita és un sensor de proximitat. Existeixen principalment sensors de proximitat de 2 tipus, per ultrasons i per infrarojos.

Els sensors per infrarojos no són molt precisos a la hora de detectar distàncies grans, però sí que ho son per a petites distàncies. El seu funcionament es basa en detectar l'angle en el que retorna un raig de llum infraroja després de rebotar amb un obstacle per així detectar la distància a la que es troba. També són relativament barats i fàcilment disponibles.

Tenen el problema que poden veure's afectats per la llum directa del sol, que els pot causar interferències.

Els sensors per ultrasons (També coneguts com a sonars) són molt precisos a la hora de detectar

distàncies, però no poden detectar materials bons en absorbir el so (Com el cartró i l'esponja). No es veuen afectats per la llum del sol, però si tenen interferències causades per l' eco del ultrasò en rebotar en obstacles propers. Per això són mes indicats per aplicacions en exterior. Són més cars que els infrarojos.

He decidit usar un sensor per infrarojos Sharp GP2Y0A21YK . És un sensor analògic que dona senyals de entre 3,1V per a distàncies de 10 cm fins a 0.4V als 80cm. Podeu veure la fitxa tècnica al Annex A.

Per detectar les ralles del terra, tant per el seguidor de línies com per el de mini-sumo, necessita uns sensors capaços de distingir el blanc del negre.

Per realitzar aquesta funció he decidit usar 4 detectors òptics /fototransistors QRD1114.

Aquests sensors són en realitat un emissor infraroig i un fototransistor preparat per detectar la senyal infraroja junts.

Com podeu veure en la imatge, si el senyal infraroig es troba amb una superfície blanca, rebota i es detecta pel fototransistor. En canvi, si la superfície és negre. Part d'aquest senyal és absorbit.

D' aquesta manera, podem detectar si sota el robot hi ha una superfície negre o una de blanca. Podeu veure la fitxa tècnica d'aquests sensors al Annex B.

42

Diagrama del funcionament d'un sensor per infrarojos.

Domini públic

Diagrama que mostra com funciona el sensor blanc/negre.

Domini public


Motors

Per tal de poder moure's, el robot necessita uns motors.

Existeixen multitud de motors de tot tipus, però pel robot he decidit usar uns servomotors de rotació continua, els principals motius pels que he decidit usar aquests motors són els següents:

• Petites dimensions

• Gran velocitat

• Fàcils d'usar

• Es poden connectar fàcilment a una bateria

• Es poden controlar directament des del Arduino

Els motors que he usat s'anomenen ROB-10189, tenen un preu relativament baix (entre 10 i 13€) i es poden trobar fàcilment.

Normalment, els servomotors estàndard, tenen la característica de poder moure's fins a un angle determinat, entre 0 i 180º, en canvi, els servomotors de rotació continua poden girar lliurement.

Els servomotors disposen de 3 cables, un de vermell, el positiu, un de negre, el negatiu o terra, i finalment un que tant pot ser blanc com groc.

Aquest últim cable és el que s' usa per controlar el servomotor, si és estàndard serveix per indicar l'angle, i en un servo de rotació continua, la direcció i la velocitat de rotació.

Per programar el robot usarem una Biblioteca (Un conjunt de funcions que faciliten d'utilització d'un recurs específic)

S'han de tenir en compte les dimensions (Annex C) dels motors a la hora de construir el robot, ja que la seva posició és important.

Podeu veure la fitxa tècnica dels motors a l' Annex D.

Arduino

Per a aquest robot usaré un dels Arduino USB, l' Arduino UNO.

He triat aquest Arduino perquè és la ultima versió d'Arduino USB que ha sortit, i té els suficients Pins com per connectar tots els sensors i motors.

43

Servomotor.

Imatge lliure, forma part del software Fritzing


Disseny exterior del robot

El primer que vaig fer van ser uns primers emboços i dissenys de com m'agradaria repartir els diferents components a l'interior del robot.

La llista completa de components que s' han de col·locar dins del robot són:

• Arduino UNO (1)

• Servomotors (2)

• Piles de 9V (2)

• Sensor de proximitat (1)

• Placa amb els sensors blanc/negre i les seves resistències (1) (4 sensors, 8 resistències)

• Interruptors (2)

També s'havia de decidir l'aspecte exterior del robot i la forma i posició de les rodes.

Al Annex E podeu veure els primers dissenys que vaig fer del robot. A l'Annex F podeu veure un dels dissenys finals .

Per ajudar a visualitzar el resultat final, vaig fer un model en 3D, podeu veure algunes imatges a l'Annex G

Disseny electrònic

El disseny electrònic del robot és relativament senzill, ja que L'Arduino estalvia molta feia al anar completament muntat.

He hagut de tenir en compte els següents punts:

• Els servomotors necessiten una pila independent per ells sols, ja que sinó, la placa Arduino no els podria alimentar.

• Com que hi ha d'haver 2 piles, fan falta 2 interruptors, per seguretat és millor que siguin independents.

• Els sensors B/N necessiten 2 resistències cada un. Una per no cremar l'emissor infraroig (200Ω) i una per evitar que ens retorni valors massa grans i amb els que sigui difícil treballar. Aquesta segona pot tenir el valor que jo desitgi, després de varies proves he decidit usar una de (5,6KΩ)

El primer esquema el podeu veure al Annex H, i l'esquema final a l'Annex I.

44


Construcció del robotUn cop hem decidit el material que hem d'usar i hem realitzat tots els esquemes i diagrames necessaris, podem començar a construir el robot.

Sensors Blanc/Negre

Un cop Obtingut tot el material, podem començar amb la construcció del robot.Primer realitzarem la tasca mes complexa, que és la de la placa inferior on van els sensors de Blanc/Negre i les seves respectives resistències.

Es comprova que els sensors funcionin correctament.Usem una placa de prototips. Connectem el sensor al Pin A0 de l'Arduino. Programem l'Arduino amb el programa que podeu veure a l'Annex J i llegim a la pantalla del ordinador els valors que ens retorna.Els resultats d'aquest test es troben a l'Annex K.

Usant una placa perforada anem soldant mica a mica cada component al seu lloc.A la hora de soldar, és important tenir totes les eines superfícies i components ben nets per tal de fer una soldadura ràpida i neta. També és important no escalfar massa estona un mateix component per evitar causar danys greus.

Podem usar estany per fer fer les diverses connexions. Hem de vigilar que els diversos “camins” no s'ajuntin de forma no desitjada, ja que podríem cremar algun component per error.Si creiem que en algun punt estan fent contacte, amb un bisturí ens assegurem de que quedin separats.

45


La nostre vista no és capaç de veure la llum infraroja, però amb una càmera podem comprovar perfectament si els sensors són correctament alimentats.

Muntatge complet

Amb la placa de prototips, comprovem que el sensor de proximitat i els motors funcionin correctament.Un dels meus motors anava lleugerament desfasat de l'altre. Això va ser molt senzill d'arreglar posant un dels engranatges interiors en la mateixa posició en els dos motors.El resultats d'aquest test es troben a l'Annex K.

Amb la placa de prototip realitzem un primer muntatge del robot per comprovar que tot funcioni correctament.Com que no es va trobar cap problema, es procedeix al muntatge definitiu.

Els motors i les bateries van a una de les dos plataformes (posteriorment els motors es van moure a la part inferior de l'altre plataforma. Subjectem els components amb Velcro.A la segona plataforma anirà l' Arduino.

46


Les dos plataformes són subjectades entre elles amb peces metàliques perforades.Es col·loquen els interruptors aprofitant les perforacions de les plataformes.

Usem brides de nylon per subjectar els motors a lloc.Ens hem d'assegurar de que tot el robot no es vegi afectat per les vibracions que hi puguin haver.

En una petita placa perforada col·locarem les connexions per els motors. Aquestes connexions consisteixen en 3 pins mascles on podem connectar fàcilment els 3 femella que duen els motors.

Subjectem la placa amb sensors a la part inferior del robot. Numerem cada sensor per tal de Facilitar la programació.

Col·loquem l'Arduino i realitzem les connexions a la placa.Cal protegir cada connexió i soldadura amb tub termoretràctil, per evitar qualsevol contacte indesitjat.

47


Les rodes es fan amb fusta contraplacada, es subjecten als motors i ja sols queda fer els últims retocs estètics. Etiquetes per a la part davantera i les rodes:

Programant el robot

Planificació del programa (Esquivar/ Seguir obstacles)

Per efectuar aquesta tasca (Seguir/esquivar obstacles) el robot haurà de fer us del sensor de proximitat.

Com que el robot sols ha d'esquivar o seguir obstacles i no necessita realitzar cap altre tasca serà un programa molt senzill.

El robot sols es trobarà amb dues situacions diferents, detecta obstacle i no detecta obstacle.

Detecta un obstacle:

• Seguirà recte ( Seguidor d'obstacles)

• Girarà (Esquivador d'obstacles)

No detecta un obstacle:

• Seguirà recte (Esquivador d'obstacles)

• Girarà (Seguidor d'obstacles)

Els programes finals es troben a l' Annex L (Seguidor) i l'Annex M (Esquivador).

48

Robot finalitzat. Imatge pròpia


Planificació del programa (Sumo)

El programa del lluitador de sumo és més complex. El robot ha de realitzar les següents tasques, per ordre de prioritat:

• Sobreviure (Actuar si està a punt de sortir del ring)

• Detectar l'enemic

• Atacar

A més farem que el robot pugui actuar d'una forma o altre segons el que hagi fet anteriorment. Per tant podem dir que el robot tindrà certa intel·ligència artificial.

El l'apartat “sobreviure” el robot pot afrontar les següents situacions:

• Que no detecti línies blanques.

Aleshores pot passar a detectar l'Enemic.

• Que detecti línies blanques.

Aleshores ha de girar per tal de deixar de veure-les.

En l'apartat “Detectar l'Enemic” el robot pot afrontar les següents situacions:

• Que detecti l'Enemic.

Aleshores por accelerar i “Atacar”.

• Que no detecti l' enemic.

Aleshores ha de moure's pel ring per poder-lo detectar.

El programa final el podeu trobar a l'Annex N.

Observacions i possibles milloresUn cop el robot ha estat acabat de construir, s' ha provat en un ring reglamentari (Podeu veure la construcció en el Annex O) he arribat a les següents conclusions:

• El Centre de gravetat esta molt amunt, cosa que provoca que el robot, en certes ocasions, bolqui.

• Els sensors Blanc/Negre es troben per sota del cos del robot, això fa que els sensors detectin la línia blanca quan les rodes ja es troben a sobre d'ella i impedeixin una ràpida reacció. Els sensors haurien de ser per davant de les rodes.

• Les rodes es troben massa separades del cos del robot.

Tenint en compte aquestes observacions, he realitzat el disseny d'un nou robot solucionant aquests problemes (PANCRA-C0). Podeu veure el disseny a l'Annex P.

49


5-Conclusió

Com hem vist, l'Arduino és molt útil per ajudar a divulgar l'electrònica entre la societat. Una persona por agafar un Arduino, un parell de sensors i quatre LEDS i muntar una aplicació que funciona en pocs minuts sense necessitar abans aprendre-ho tot sobre electrònica, sense necessitar saber posar un microcontrolador a punt per fer-lo servir.

Acostar la electrònica a la població en general és molt important, ja que pot provocar en les noves generacions un interès per el desenvolupament i intentar crear innovacions tecnològiques.

L'Arduino és molt fàcil de fer servir, amb poques línies de codi senzill es pot fer funcionar. Per tant podria ser una eina molt útil en la docència.

La metodologia usada en el treball ha sigut correcta i m'ha permès assolir els objectius sense gaires complicacions. També crec que he aprofundit bastant en els diferents temes que volia tractar, tot i incloure'n molts de diferents.

He sigut molt estricte en usar exclusivament software lliure, i així demostrar-me a mi mateixa i a qui s'interessi per el treball que aquest tipus de software es troba a la mateixa altura que qualsevol altre alternativa comercial. He pogut assolir aquest objectiu perfectament i sense cap excepció.

En un futur m'agradaria seguir treballant en el BONIFA-C0, millorant-lo i solucionant els errors detectats en aquest primer model. M' agradaria en un any tenir la segona versió (PANCRA-C0, que podeu veure en els Annexos) funcionant. I en poc temps més, una 3a versió definitiva (FIBONA-C0) a la altura ja de competir en un torneig oficial.

També m'he interessat pel projecte RepRap, i en un futur m'agradaria construir jo mateixa una d'aquelles impressores.

Realitzant el treball de recerca he après sobretot a desenvolupar un projecte des de que és una idea fins a tenir un prototip funcionant. Això en un futur em servirà per dur a terme els meus propis projectes personals i professionals amb més seguretat.

També he aprés algunes tècniques que potser en un futur em seran útils (Com per exemple fer una soldadura neta i precisa)

Valoro el treball de recerca de forma positiva, ja que, a part d'haver après el que he mencionat, al tractar-se d'un tema que m'interessava i m'agradava no m'ha costat de fer.

50


6-Bibliografía

Physical Computing. Ultima edició 03/09/2012. <www.en.wikipedia.org/wiki/Physical_computing>

Arduino. Ultima edició 07/09/2012. <www.ca.wikipedia.org/wiki/Arduino>

Arduino. Ultima edició 22/09/2012. <www.en.wikipedia.org/wiki/Arduino>

La revolución silenciosa del hardware libre. Publicat 14/03/2011. <www.sorayapaniagua.com>

The making of Arduino. Publicat 10/09/2011. <www.spectrum.ieee.org>

Arduino: The documentary. Audiovisual (2010) <www.vimeo.com/18539129>

Boards. Ultima edició: 05/05/2012 <www.arduino.cc/en/Main/Boards>

RepRap Project. Ultima edició: 12/09/2012 <www.en.wikipedia.org/wiki/RepRap_Project>

Robot Competition. Ultima edició: 10/09/2012<www.en.wikipedia.org/wiki/Robot_competition>

Sumo Rules. Recurs digital. <www.robotroom.com/SumoRules.html>

GP2Y0A21YK. Producte. <www.sparkfun.com/products/242>

QRD1114. Producte <www.sparkfun.com/products/246>

51


Annexos

Annex AFitxa tècnica del sensor GP2Y0A21YK

I


Annex BFitxa tècnica del sensor QRD1114

II


Annex CEsquemes dels Servomotors

III


Annex DFitxa tècnica dels Servomotors

IV


Annex EPrimer disseny del robot

V


Annex FDisseny final del robot

VI


Annex GModel 3D de pocs polígons

NOTA: Aquest model en un inici anava dirigit a la creació d'una animació, no ha sigut possible degut a que el meu ordinador no era suficientment potent.

VII


Annex HPrimer esquema electrònic.

VIII


Annex IDisseny electrònic final.

IX


Annex JPrograma usat per testejar els sensors:

int sensorPin = 0; //pin analògic 0

void setup(){ Serial.begin(9600);}

void loop(){ int val = analogRead(sensorPin); Serial.println(val);

//per fer que arribin dades mes apoc a poc

delay(100);

}

Aquest programa llegeix el valor retornat pel sensor connectat al Pin 0 i imprimeix a la pantalla del PC els valors que el sensor retorna.

X


Annex KResultats del test dels sensors.

En la taula a continuació, podeu veure els valors retornats per cada sensor en les diverses condicions.

Sensor de proximitat

Valor màxim Valor mínim

Obstacle present 783 113

Obstalce no present 97 13

Per tant si ens retorna un valor menor de 100 interpretarem que no hi ha obstacle i si és major, interpretarem que sí que hi és.

Sensors Blanc/Negre

V.Min. Blanc V.Max. Blanc V.Min. Negre V.Max. Negre

Sensor 1 0 50 700 800

Sensor 2 40 110 850 1000

Sensor 3 10 60 800 900

Sensor 4 30 70 800 1000

Per tant, si ens retorna un valor major a 410, interpretarem que es troba sobre negre, si el valor és menor, que es troba sobre blanc.

XI


Annex LPrograma final per el seguidor d'obstacles:

#include <Servo.h> //incloure biblioteca

Servo servodret; //Declarem el servo

Servo servoesquerre; //Declarem el servo

int sensorPin = 0; //analog pin 0

//INICIALITZACIÓ//

void setup(){

delay (3000);

servodret.attach(5); // servo dret al pin 5

servoesquerre.attach(10); //servo esquerre al pin 10

}

//LOOP//

void loop(){

int val = analogRead(sensorPin); //Llegir valor analògic

if (val > 400) //Si detecta obstacle

{

servodret.write(110); //Seguir endavant

servoesquerre.write(70);

}

else

{

servodret.write(70); //Girar fins a detectar obstacle

}

}

XII


Annex MEsquivador d'obstacles, el programa és gairebé idèntic al anterior:

#include <Servo.h> //incloure biblioteca

Servo servodret; //Declarem el servo

Servo servoesquerre; //Declarem el servo

int sensorPin = 0; //analog pin 0

//INICIALITZACIÓ//

void setup(){

delay (3000);



}

//LOOP//

void loop(){

int val = analogRead(sensorPin); //Llegir valor analògic

if (val < 400) //Si detecta obstacle

{

servodret.write(110); //Seguir endavant


}

else

{

servodret.write(70); //Girar fins a detectar obstacle

}

}

XIII


Annex NPrograma del lluitador de sumo:

//~~~~~~LLIBRERIES I VARIABLES~~~~~~//

#include <Servo.h>

Servo servodret; //Declarem el servo dret

Servo servoesquerre; //Declarem el servo esquerre

int sensorulls = 0; //els "ulls" es troben al pin 0

int sensor1 = 1; // sensor 1 al pin 1




int mov = 1; //creem una variable per definir el tipus de moviment del robot

//~~~~~~FUNCIONS DELS SENSORS~~~~~~//

void atacar(){

int distancia = analogRead(sensorulls);//llegim el valor que que ens dona els "ulls" del robot

if(distancia>100) //si detecta un enemic

{

endavant();

mov = 4;

}

//si no veu l' enemic, farà un moviment basat en el que ha fet anteriorment

else if (mov == 1)

{

rastrejar_mov1();

}

else if (mov == 2)

{

XIV


rastrejar_mov2();

}

else if (mov == 3)

{

rastrejar_mov3();

}

else if (mov == 4)

{

rastrejar_mov4();

}

else

{

mov = 1; //donem pas al moviment 1

}

}

//~~~~~~FUNCIONS DELS MOTORS~~~~~~//

//Anar endavant//

void endavant(){

servodret.write(80);


}

//Anar enrere//

void enrere(){



}

XV


//Girar horari//

void horari(){



}

//Girar antihorari//

void antihorari(){



}

//Pivot esquerre endavant//

void piv_esq_end(){



}

//Pivot esquerre enrere//

void piv_esq_enr(){



}

//Pivot dret endavant//

void piv_dre_end(){



}

XVI


//Pivot dret enrere//

void piv_dre_enr(){



}

//~~~~~~PATRONS DE MOVIMENTS~~~~~~//

void rastrejar_mov1(){

endavant();

delay(2000);

antihorari();

delay(1000);

endavant();

delay(2000);

horari();

delay(1000);

}


enrere();

delay(1500);

antihorari();

delay(1000);

enrere();

delay(1500);

antihorari();

delay(1000);


}


enrere();

delay(1500);

horari();

delay(1000);

enrere();

delay(1500);

XVII


horari();

delay(1000);


}


horari();

delay(2000);

}

//~~~~~~SETUP~~~~~~//

void setup(){



delay (3000); //espera els 5 segons reglamentaris

}

//~~~~~~ FUNCIO PRINCIPAL ~ LOOP~~~~~~//

void loop(){

//primer és important sobreviure

//llegim els valors dels "sensors de blanc/negre"

int bn1 = analogRead(sensor1);




if( bn1>=410 && bn2>=410 && bn3<410 && bn4>=410 ) //si detecta blanc nomes a 3

{

piv_dre_end();

mov = 1;

}

XVIII


else if ( bn1<410 && bn2>=410 && bn3>=410 && bn4>=410 ) //si detecta blanc nomes a 1

{

piv_esq_end();

mov = 1;

}

else if ( bn1>=410 && bn2<410 && bn3>=410 && bn4>=410 ) //si detecta blanc nomes a 2

{

piv_esq_enr();

mov = 3;

}

else if ( bn1>=410 && bn2>=410 && bn3>=410 && bn4<410 ) //si detecta blanc nomes a 4

{

piv_dre_enr();

mov = 2;

}

else if ( bn1<410 && bn2>=410 && bn3<410 && bn4>=410 ) //si detecta blanc nomes a 1 i a 3

{

endavant();

mov = 1;

}

else if ( bn1>=410 && bn2<410 && bn3>=410 && bn4<410 ) // si detecta blanc a 2 i a 4

{

enrere();

mov = 2;

}

else if ( bn1>=410 && bn2>=410 && bn3<410 && bn4<410 ) // si detecta blanc a 4 i 3

{

piv_dre_end();

mov = 1;

XIX


}

else if ( bn1<410 && bn2<410 && bn3>=410 && bn4>=410 ) //si detecta blanc a 2 i a 1

{

piv_esq_enr();

mov=1;

}

//si no està en perill, per tant no veu línies blanques, el robot pot atacar

else

{

atacar();

}

}

XX


Annex OConstrucció d'un ring reglamentari:

Es dibuixa la circumferència de la mida reglamentaria (770 mm de diàmetre) en fusta.

La fusta es talla, procurant que quedi el màxim de regular possible.

Abans de tot, és necessari protegir el terra en una zona ventilada.

Pintem la superfície amb varies capes d'esprai negre mate.

XXI


Es dibuixa la vora blanca del ring, també de la mida reglamentaria (25mm)

Es protegeix la resta del ring amb cinta de fuster, per evitar pintar parts no desitjades

Pintem la línia exterior amb varies capes de pintura blanca brillant o setinada. Procurem no embrutar la part negra.

Un cop la pintura està seca. Podem treure amb compte la cinta de fuster.Així completem el ring.

XXII


Annex PPrimers emboços del PANCRA-C0, el possible successor del BONIFA-C0.

Entre les 2 vistes es pot veure un diagrama de com penso que podria usar 2 sensors per detectar cap a quina direcció es troba l'enemic.

XXIII


XXIV

Arduino i robots de competició

Documents

Transcript of Arduino i robots de competició