Project Rainbow - Malmö högskola

Området för teknik och samhälle
Examensarbete
15 högskolepoäng, grundnivå
Projekt Regnbåge
Project Rainbow
Carl-Philip Olsson
Henrik Andersson
Examen: Högskoleingenjörsexamen i datateknik, 180hp
Examninator:
Handledare:
Gion Koch
AngeSvedberg
handledare
Datum för slutseminarium: 2012-06-01
Handledare: Jonas Forsberg
Project Rainbow
Abstract
In this thesis we further develop an existing prototype. The prototype is an interactive art project
where two plates with water nozzles in the middle are placed at each end of an arc. These two plates
can be controlled directly with a joystick. The plates are following the motion of the joystick using
servo motors. Our main goal is to allow spectators of the art project to remotely control the plates
and the water flow by using their own mobile phone.
Our goal has been achieved by creating an Android application that the user can download
and install directly on their mobile phone. The application automatically sends information about the
angular position of the phone to a server. Then the server forwards this information to a Wifi-module
connected to an Arduino board which is moving the servo motors, attached to the
plates, in the correct position.
This thesis describes the technique used within the project and also illustrates how the design and
functionality of the prototype has been changed to make a more striking impression on the audience.
Keywords: Accelerometer, Android, Application, Arduino, Communication, Mobile phone, Servo
motors, Server, Wireless, Wifi.
Project Rainbow
Sammanfattning
Det här examensarbetet bygger vidare på en tidigare konstruerad prototyp, ett interaktivt
konstprojekt där två plattor, placerade på en båge, med vattenmunstycken i mitten styrs med en
joystick. Plattorna följer joystickens rörelse med hjälp av servomotorer.
Målet i detta examensarbete var att koppla åskådarens smarta mobiltelefon till konstprojektet.
Åskådaren ska kunna styra konstprojektet genom att vinkla sin mobiltelefon. Även vattenflödet ska
kunna kontrolleras och all interaktion ska ske via trådlös kommunikation.
Målet har uppnåtts genom att användaren installerar en applikation som skapats för
operativsystemet Android. Applikationen skickar information om mobiltelefonens aktuella
vinkelposition till en server via ett trådlöst nätverk. Servern skickar i sin tur vidare denna information
till en Wifi-modul kopplad på ett arduinokort som ställer in plattornas servomotorer i rätt läge.
Rapporten beskriver hur tekniken för att nå målet fungerar och illustrerar även hur prototypens
design och funktionalitet har förändrats för att få ett mer effektfullt intryck.
Nyckelord: Accelerometer, Android,
Servomotor, Server, Trådlös, Wifi.
Applikation,
Arduino,
Kommunikation,
Mobiltelefon,
Project Rainbow
Innehåll
1.
2.
Introduktion..................................................................................................................................... 1
1.1
Bakgrund ................................................................................................................................. 1
1.2
Syfte ......................................................................................................................................... 2
1.3
Systemöversikt ........................................................................................................................ 2
1.4
Översikt över andras arbeten .................................................................................................. 3
Metod .............................................................................................................................................. 4
2.1
Android .................................................................................................................................... 4
2.1.1
Applikationsutveckling för Android ................................................................................ 5
2.1.2
Accelerometer ................................................................................................................. 6
2.2
Server....................................................................................................................................... 7
2.3
Arduino .................................................................................................................................... 8
2.3.1
3.
Wifi-modulen ................................................................................................................. 10
2.4
Servomotorer ........................................................................................................................ 11
2.5
Spänningskälla ....................................................................................................................... 12
Genomförande .............................................................................................................................. 13
3.1
Utveckling av vår applikation till Android ............................................................................. 13
3.1.1
Behandling av accelerometerdata................................................................................. 14
3.1.2
Uppkoppling och sändning av data ............................................................................... 14
3.1.3
Nedladdning av applikationen....................................................................................... 16
3.2
Serverns uppbyggnad ............................................................................................................ 16
3.3
Utveckling av arduinokortets programvara .......................................................................... 19
3.4
Ventiler .................................................................................................................................. 20
3.5
Nätaggregat ........................................................................................................................... 22
3.6
Design .................................................................................................................................... 24
3.6.1
Belysning........................................................................................................................ 25
3.6.2
Vattenflöde .................................................................................................................... 25
3.7
Test av systemet .................................................................................................................... 26
4.
Resultat och diskussion ................................................................................................................. 27
5.
Slutsats .......................................................................................................................................... 29
Referenser ............................................................................................................................................. 30
Bildreferens ........................................................................................................................................... 32
Appendix A ............................................................................................................................................ 33
Appendix B ............................................................................................................................................ 39
Project Rainbow
Appendix C............................................................................................................................................. 41
Appendix D ............................................................................................................................................ 52
Appendix E ............................................................................................................................................. 56
Appendix F ............................................................................................................................................. 59
Appendix G ............................................................................................................................................ 60
Appendix H ............................................................................................................................................ 61
Appendix I .............................................................................................................................................. 62
Project Rainbow
Lista över figurer
Figur 1. Systemöversikt över tidigare arbete. ......................................................................................... 1
Figur 2. Systemöversikt. .......................................................................................................................... 2
Figur 3. Androidarkitekturens större delar. [101] ................................................................................... 4
Figur 4. Livscykeln för en aktivitet. [102] ................................................................................................ 5
Figur 5. Accelerometern kan ge värden i tre riktningar. [103] ................................................................ 6
Figur 6. Arkitektur för ett TCP/IP-paket. [109] ........................................................................................ 7
Figur 7. Arkitektur för ett UDP-segment. [110] ....................................................................................... 8
Figur 8. Arduinos IDE med en exempelskiss från standardbiblioteket. .................................................. 9
Figur 9. Arduino Mega ADK. [104] ........................................................................................................... 9
Figur 10. Wifi-modulen. [105] ............................................................................................................... 10
Figur 11. Exempel på några pulsbreddsmodulerade signaler för att uppnå tre vinklar. [106] ............. 11
Figur 12. Graupner Servo DES 708 BB, MG. [107] ................................................................................. 12
Figur 13. Nätaggregat från en stationär dator. ..................................................................................... 12
Figur 14. Aktivitetens användargränssnitt. ........................................................................................... 13
Figur 15. Ikonen för vår applikation. ..................................................................................................... 14
Figur 16. Utdrag ur manifestfilen. ......................................................................................................... 14
Figur 17. Ett försök att ansluta till servern görs. ................................................................................... 14
Figur 18. Metoden heartbeat. ............................................................................................................... 15
Figur 19. Enheten är ansluten till servern. ............................................................................................ 15
Figur 20. Anslutningen till servern misslyckades................................................................................... 15
Figur 21. Metoden ”sendPositions” som skickar data till servern. ....................................................... 16
Figur 22. QR-tagg för att komma direkt till applikationen. ................................................................... 16
Figur 23. Socket för UDP överföringen skapas och Wifi-modulens IP-adress sparas. .......................... 17
Figur 24. Utdrag från metoden newConnection. .................................................................................. 17
Figur 25. Datainnehållet i ett TCP-paket från en androidenhet. ........................................................... 17
Figur 26. Värdets förhållande i de två intervallen. ................................................................................ 18
Figur 27. Metoden som skapar och skickar datagram. ......................................................................... 18
Figur 28. Datainnehållet i utgående UDP-paket.................................................................................... 19
Figur 29. Källkod för att styra vänster platta från Arduinokortet. ........................................................ 19
Figur 30. Kod för att öppna respektive sluta vattenventilerna. ............................................................ 20
Figur 31. 2/2-vägselektromagnetventil, VDW21-5G-3-01F-Q. [108] .................................................... 20
Figur 32. Kretskoppling för ventiler. ...................................................................................................... 21
Figur 33. Ventilkretsen på ett prototypkort. ......................................................................................... 21
Figur 34. Laborationskontakter fästa på nätaggregatet. ....................................................................... 22
Figur 35. Nätaggregat med monterad apparatlåda. ............................................................................. 22
Figur 36. Arduinokortet med WiFly-modulen och ventilkoppling, monterade i apparatlådan. ........... 23
Figur 37. D-subminatyrs hankontakt som ska kopplas in i honkontakten på apparatlådan. ................ 23
Figur 38. Bågen i tidigare röd design. .................................................................................................... 24
Figur 39. Bågen i vitt plexiglas med lock och botten. ............................................................................ 24
Figur 40. LED-slingan och dess fjärrkontroll. ......................................................................................... 25
Figur 41. Belysning i vitt, rött, grönt och blått. ..................................................................................... 25
Figur 42. Munstycke som skapar vattenstrålen. ................................................................................... 25
Figur 43. Vattnet leds genom ventilerna. .............................................................................................. 25
Figur 44. Monter för testdagen. ............................................................................................................ 26
Project Rainbow
Lista över tabeller
Tabell 1. Egenskaper för TCP och UDP protokollen [18]. ........................................................................ 8
Tabell 2. Lista över komponenter och deras matningsbehov. .............................................................. 12
Tabell 3. Lista över anslutningar hos nätaggregatet. ............................................................................ 22
Project Rainbow
1. Introduktion
Att mobiltelefonen har en stor betydelse i dagens samhälle är ingen nyhet. Ett bevis på detta är en
undersökning [1] om tekniska prylar där man visar att sju av tio svenskar skulle ha svårt att klara sig
utan mobiltelefonen. Många har en ständig uppkoppling mot internet och andra enheter. Eftersom
de flesta bär med sig mobiltelefonen var de än är och alltid är nåbara blir mobiltelefonen nästan som
en del av kroppen. Så som vår kropp kan känna av exempelvis ljusförändringar eller hur vår hand är
vinklad har också många av dagens mobiltelefoner, så kallade smartphones, olika sensorer för att
känna av samma saker.
I det här examensarbetet beskrivs hur man genom att vinkla sin mobiltelefon trådlöst kan styra
servomotorer och elektromagnetiska ventiler. Den praktiska delen i detta arbete är en interaktiv
konstinstallation. Konstinstallationen är tänkt att illustrera sambandet mellan dagens mobilteknik
och samhälle. Mobiltelefonen kopplar upp sig mot konstinstallationen och låter man telefonen ligga i
handflatan så är det handens rörelse som kontrollerar plattornas läge precis som om de vore en del
av ens egen kropp.
Det finns många praktiska tillämpningar baserade på den tekniska lösningen som beskrivs och
diskuteras i rapporten, se kapitel 4.
1.1
Bakgrund
Höstterminen 2011 arbetade Martina Marti och Lorenz Rordorf från Schweiz med sitt examensarbete
vid Malmö Högskola [21]. Examensarbetet handlade om att göra ett interaktivt konstprojekt där
åskådaren själv kunde ta del av och skapa de visuella effekterna. De två studenterna designade och
tillverkade en båge i röd plexiglas med en platta i vardera änden vilken kan vinklas med hjälp av två
servomotorer på vardera platta. En vattenpump pumpar vatten genom en slang till munstycken på
plattorna vilka ger en vattenstråle som kan vinklas och skapa olika intressanta mönster.
Den ursprungliga tanken var att åskådarna själva skulle kunna styra konstinstallationen med hjälp av
sin mobiltelefon. Då deras arbete handlade om att konstruera den mekaniska delen av projektet så
lämnades detta till utveckling för framtiden. Konstinstallationen styrdes med hjälp av en joystick som
satt på ett Arduino Mega ADK (Android Development Kit) kort (se Figur 1).
Figur 1. Systemöversikt över tidigare arbete.
1
Project Rainbow
1.2
Syfte
Syftet med det här examensarbetet är att vidareutveckla det tidigare examensarbetet. Tanken med
slutprodukten är att användaren ska kunna installera en applikation på sin mobiltelefon som gör det
möjligt att styra konstverket trådlöst genom att vinkla telefonen åt olika håll. Den vinkel
mobiltelefonen befinner sig i ska efterliknas av bågens plattor. Även vattenflödet genom plattorna
ska kunna styras genom applikationen. Problemet som ska lösas består av följande delar (se även
förstudien i Appendix A):




Hårdvara: hur kan Arduino användas tillsammans med trådlös kommunikation och hur kan
strömförsörjningen för de olika komponenterna ske med en gemensam spänningskälla?
Server: vilka överföringsprotokoll är lämpligast att använda för kommunikationen mellan
mobiltelefon och server samt mellan server och Arduino? På vilket sätt behöver inkommande
information bearbetas innan den skickas vidare?
Android: hur gör man för att utveckla en androidapplikation? Vilket utseende ska
applikationen ha och hur kan kommunikationen skötas?
Design: vad kan förändras för att ge ett mer effektfullt intryck? Vad behövs för att skapa ett
interaktivt vattenflöde? Kan flera användare styra konstprojektet samtidigt?
Då det finns stora möjligheter att vidareutveckla projektet är det tänkt att rapporten ska kunna ligga
till grund för fortsatt utveckling.
1.3
Systemöversikt
För att göra det möjligt för användaren att interagera med konstprojektet har en applikation
utvecklats för operativsystemet Android. Applikationen hämtar accelerometerdata från användarens
mobiltelefon och skickar dessa tillsammans med värdet för vattenflödet, vidare till en server. Detta
kommer att ske genom en trådlös kommunikation mellan användarens mobiltelefon och en server
över Wifi. Servern skickar sedan vidare dessa data till en Wifi-modul som sitter på ett arduinokort (se
Figur 2). Arduinokortet ställer in servomotorerna i den position som skickats från användarens
mobiltelefon. På så vis kan användaren genom att vinkla sin mobiltelefon bestämma plattornas läge
och via ett enkelt knapptryck på telefonen sätta på eller stänga av vattenflödet.
Figur 2. Systemöversikt.
Som figur 2 illustrerar kan i nuläget enbart en användare åt gången interagera med konstprojektet.
Om konstprojektet redan används får personen som försöker ansluta sig ett meddelande om att
systemet inte är tillgängligt (läs mer i kapitel 3.1).
2
Project Rainbow
1.4
Översikt över andras arbeten
Det finns en del tidigare arbeten som behandlar tre stora problemområden i vårt projekt. Hur man
kan använda en Wifi-modul till ett arduinokort, kommunikation i Android samt hur en servomotor
styrs trådlöst. Med hjälp av dessa arbeten fick vi en större inblick i problematiken som vårt projekt
innefattar och exempel på hur dessa kan lösas. Följande arbeten har varit till hjälp:

Ett övervakningssystem där en mobiltelefon med operativsystemet Android kan koppla upp
sig mot en server för att hämta sensordata och video från en webbkamera [5].

Implementering av en http server och klient på en WiFly RN-131 modul från Roving
Network’s för att kunna hämta sensordata trådlöst [13].

En väderstation som använder Arduino tillsammans med en Wifi-modul (WiFly-shield) för att
samla in väderdata och komma åt denna genom att trådlöst koppla upp sig mot Wifimodulen [24].

Arduino som tillsammans med en Wifi-modul (WiFly-shield) trådlöst styr servomotorer
genom en windowsapplikation [22].
3
Project Rainbow
2. Metod
För att lösa problemet började vi med att ta fram en problemformulering och systemöversikt. När
problemet var formulerat fortsatte vi med en förstudie för att strukturera och avgränsa problemet
(se förstudie Appendix A). Vi bröt ner huvudproblemet i mindre delproblem för att på så sätt få en
klarare bild över vilka delproblem som projektet har och göra det enklare att hitta relevant
information och bearbeta var problem för sig. Under förstudien sökte vi litteraturen som skulle
kunna vara till hjälp för att lösa de olika delproblemen. Vi specificerade också kraven för systemet
och gjorde en detaljplanering.
Rapporten är tänkt att kunna användas som grund för att fortsätta med utvecklingen av projektet
och beskriver därför vissa delar mer detaljerat.
2.1
Android
Android är ett operativsystem utvecklat för mobila apparater med pekskärm. Många av dagens
mobiltelefoner och surfplattor använder Android. Det är ett Linuxbaserat operativsystem som
utvecklas av OHA (Open Handset Alliance) vilket leds av Google och består av 84 olika företag med
inriktning mot teknik- och mobilbranschen. Eftersom Google släppt Android som öppen källkod kan
vem som helst ladda ner och göra egna modifieringar i operativsystemets källkod [2] i motsats till
Apple iOS1.
Antalet enheter med Android ökar snabbt. Enligt Andy Rubin, Senior Vice President of Mobile at
Google och en av grundarna till Android, aktiveras över 850 000 androidenheter varje dag (februari
2012) [3].
Det är fritt fram för vem som helst att utveckla och sälja egna applikationer, även kallat ”appar”.
Enligt Google fanns det i april 2012 över 450 000 applikationer och spel att ladda ner på Google Play
som är portalen man använder för att hämta androidapplikationer [4]. För att utveckla applikationer
för Android behöver man Android SDK (Software Development Kit) vilket innehåller verktyg och APIer
(Application Programming Interface) för utveckling i programmeringsspråket Java. Jämfört med
andra liknande operativsystem
har Android många fördelar så
som
öppenhet,
behandlar
applikationer lika, inga gränser
mellan applikationer samt
möjlighet till snabb och enkel
applikationsutveckling. Dessa
fördelar kan härledas från
androidsystemets arkitektur [5].
Figur 3. Androidarkitekturens större delar. [101]
1
iOS är Apples motsvarighet till Android.
4
Project Rainbow
Androidarkitekturens större beståndsdelar är (se Figur 3):





2.1.1
Applications, de applikationer som finns i operativsystemet. T.ex. e-postklient och kalender.
Application framework, ramverket för att utvecklare enkelt ska kunna använda sig av
enhetens hårdvara.
Libraries, vissa komponenter använder C/C++ bibliotek men funktionerna som utvecklare kan
använda visas genom ovan nämnda applikationsramverk.
Android runtime, för att få tillgång till den mesta funktionaliteten från kärnbiblioteken i Java
samt Dalvik virtual machine vilken kör applikationerna på androidenheten.
Linux kernel, Android bygger på Linux version 2.6 för de grundläggande tjänsterna så som
t.ex. säkerhet och minneshantering [6].
Applikationsutveckling för Android
För utvecklingen av applikationen valde vi att använda oss av Eclipse IDE2 (Integrated Development
Environment) tillsammans med två stycken insticksprogram3, JDT (Java Development Tools) med
utvecklingsverktyg för Java samt ADT (Android Development Tools). ADT integrerar bland annat
androidverktyg i Eclipse för att användaren snabbt och enkelt ska kunna skapa, bygga, packa,
installera och felsöka sina androidprojekt. Det viktigaste är installationen av Android SDK som
nämnts i föregående kapitel. Eftersom ovan nämnda insticksprogram fanns till Eclipse, samt att vi är
vana att arbeta med det sedan tidigare, var inte valet av IDE svårt.
Activities, services, content providers
och broadcast receivers är de fyra
komponenter som en applikation kan
bestå av. Aktiviteten (Activity) kommer
senare att användas i applikationen och
beskrivs därför mer ingående.
Det finns tre tillstånd som en aktivitet
kan befinna sig i:



Återupptagen: aktiviteten har
användarens fokus och är synlig
på skärmen.
Pausad: aktiviteten har förlorat
fokus på skärmen.
Stoppad: för användaren ser det
ut som aktiviteten har avslutats.
När en aktivitet befinner sig i tillstånden
pausad eller stoppad ligger den fortfarande sparad i enhetens minne för att
2
3
Figur 4. Livscykeln för en aktivitet. [102]
Ett program för att utveckla programvara.
Insticksprogram körs som en del av ett annat program.
5
Project Rainbow
snabbt kunna återupptas men om systemet behöver det minne som aktiviteten tar upp så avslutas
den.
En aktivitets livscykel består av ett antal metoder som anropas automatiskt vid olika skeden efter att
applikationen startats (se Figur 4). Dessa generiska metoder är alltid implementerade men det räcker
att anpassa de man kommer att använda sig av. De tre metoder som senare kommer att anpassas är
onCreate, onResume samt onPause.



onCreate anropas när aktiviteten startas och det är här alla statiska inställningar görs.
onResume anropas precis innan användaren kan interagera med aktiviteten.
onPause anropas när aktiviteten inte längre kommer att vara i fokus. Det bör inte vara
mycket kod som ska köras då detta kan fördröja tiden innan en annan aktivitet kan ta över
fokus [8].
Vissa funktioner måste godkännas av användaren för att applikationen ska kunna använda dessa.
Exempel på sådana funktioner är: använda kameran, tillgång till Bluetooth eller att använda Wifi.
Funktioner som kräver användarens tillstånd måste anges i en manifestfil. Användaren godkänner att
applikationen använder dessa funktioner i samband med nedladdningen från Google Play. Förutom
att ange de funktioner som kräver användarens tillåtelse i manifestfilen kan den även innefatta saker
som aktivitetens sökväg, namn på applikationen, vilka versioner av Android som är kompatibla, ikon
och vilken orientering det ska vara på skärmen. Det krävs att varje applikation har en manifestfil och
att denna ligger i rotkatalogen [6].
2.1.2
Accelerometer
En accelerometer är en sensortyp som kan mäta hastighetsförändring och känna av vilket läge den
befinner sig i. Den använder tyngdkraften till sin hjälp att beräkna detta. Accelerometern i
androidenheter ger värden i tre riktningar (se Figur 5). Dessa värden beräknas genom förhållandet:
, där Eh är accelerationen enheten utsätts för,
m/s2 är storleken på
gravitationskraften, F är kraften sensorn utsätts för och m är dess massa [20].
Figur 5. Accelerometern kan ge
värden i tre riktningar. [103]
6
Project Rainbow
2.2
Server
Precis som androidapplikationen bygger även servern på programmeringsspråket Java.
Kommunikationen mellan androidenhet och server sköts med TCP (Transmission Control Protocol)protokoll, vilket gör det enklare att hantera inkommande anslutningsförfrågningar på servern och när
anslutningen till en användare väl är etablerad är pålitligheten hög. Ett TCP-segment består av en
huvud (header) som har en storlek på 20 bytes, som sedan inkapslas i ett IP-datagram. IPdatagrammet innehåller informationen som behövs för att överföra paketet till rätt destination. I
TCP-huvudet finns information om hur paketet ska behandlas och vilka regler som ska följas vid
sändning och mottagning. Data som ska skickas från en androidenhet till servern läggs in under TCPsegmentets datafält (se figur 6) [25].
Figur 6. Arkitektur för ett TCP/IP-paket. [109]
Datatransmissionen mellan en androidenhet och servern görs via TCP-sockets som är strömbaserade.
Där blir inkapslingsprocedur, sändning och mottagning av data automatiserad i en ström.
UDP (User Datagram Protocol)-protokoll används för kommunikationen mellan server och
arduinokortet. Eftersom gammal parameterdata inte är aktuell att få återsänd utan enbart det
senast sända paketet är relevant så passar UDP utmärkt som kommunikationsprotokoll mellan
servern och arduinokortet. Till skillnad från en TCP-socket har en UDP-socket ingen anslutning och
kan därför inte vara strömbaserad utan är istället baserad på datagram. Data både läggs i och läses ur
utifrån datagram [9].
UDP-segmentet består av ett UDP-huvud som är inkapslat i ett IP-datagram. Till skillnad från TCPhuvudet är storleken på UDP-huvudet endast 8 bytes då den saknar funktioner som till exempel
sekvens- och bekräftelsenummer (se figur 7).
7
Project Rainbow
Figur 7. Arkitektur för ett UDP-segment. [110]
Med ett UDP-protokoll får man ingen garanti att paketen mottagits i rätt ordning och den stödjer
ingen avancerad felhantering eller återsändning av förlorade eller korrupta paket [17]. Allt detta
stödjer TCP-protokollet men detta medför att transmissionshastigheten minskar (se Tabell 1).
Pålitlighet:
Flödeskontroll:
Användningsområde:
Header-storlek:
Felkontroll:
Paketsändning:
Hastighet:
TCP
Garanterar att paketen tas emot i
samma ordning som de skickades.
Sändaren tar emot en bekräftelse
efter varje mottaget paket.
Har flödeskontroll, kräver tre paket
för att etablera en socketanslutning
innan data kan skickas.
Applikationer som kräver pålitlig
dataöverföring.
20 bytes.
Ja.
Delar upp paketen i mindre paket
om så krävs och skickar dem efter
en specificerad ordning.
Hög.
UDP
Garanterar inte att paketen
mottags i rätt ordning, eller
över huvud taget.
Saknar flödeskontroll.
Applikationer som kräver
hög transmissionshastighet.
8 bytes.
Nej.
Skickar paketen var för sig.
Väldigt hög.
Tabell 1. Egenskaper för TCP och UDP protokollen [18].
2.3
Arduino
Arduino är en open-source plattform för elektronikprototyper. Plattformen består av två huvuddelar:
arduinokorten (hårdvara) och Arduinos IDE. Med hjälp av Arduinos IDE skriver man programmet som
ska köras på arduinokortet och enheterna som är kopplade till det [10]. Detta kallas för skiss (se Figur
8). Skissen skriver man på ett programmeringsspråk som är en blandning mellan C och C++. När
skissen ska programmeras in på arduinokortet genomgår den en smärre förändring, som kontrollerar
koden, och förs sedan till en C/C++ -kompilator. Här förändras koden till maskinkodsinstruktioner.
8
Project Rainbow
Därefter länkas koden till arduinobiblioteken som innehåller en del standardfunktioner.
Slutresultatet blir en enda fil som ska överföras till arduinokortets programminne via USB kontakt
[11].
Figur 8. Arduinos IDE med en exempelskiss från standardbiblioteket.
Arduinos plattform är tänkt att användas av designers, artister, hobbyister och alla som är
intresserade av att skapa ett interaktivt objekt eller miljö. Fördelarna med Arduino är att kretskorten
är billigare och lättare att använda än andra mikroprocessorplattformar. Utvecklingsverktyget är
även plattformsoberoende och ger en enkel programmeringsmiljö.
Det finns många olika typer av arduinokort men det som passade detta projekt bäst var Arduino
Mega ADK (se Figur 9). Kortet har ett USB-gränssnitt som är kompatibelt med androidenheter vilket
passade utmärkt för vårt ändamål. Detta gjorde att en androidenhet kunde anslutas till kortet och vi
kunde då börja laborera med accelerometervärden redan under förstudien. Kortet har dessutom 54
digitala in/utgångar varav 14 kan användas som PWM4(Pulse Width Modulation)-utgångar, 16
analoga ingångar och 4 UART (Universal Asynchronous Receiver/Transmitter)5 [12]. För fullständiga
specifikationer se Appendix F.
Figur 9. Arduino Mega ADK. [104]
4
5
PWM är en teknik för att reglera och styra elektroniska komponenter
UART är en komponent som omvandlar data mellan parallella och seriella former
9
Project Rainbow
2.3.1
Wifi-modulen
Eftersom Arduino Mega ADK inte stödjer trådlös kommunikation som standard så måste en modul
för detta implementeras. Det finns olika alternativ för att skapa en trådlös kommunikation som skulle
kunna tillämpas. Exempel på dessa är Bluetooth, IR (Infraröd Strålning), Xbee och Wifi. För att Xbee
ska fungera krävs det att både servern och arduinokortet är utrustade med en Xbee-modul. IR
uteslöts då ett krav är fri sikt mellan sändare och mottagare eftersom det är infrarött ljus som
används. Bluetooth valdes också bort eftersom vi ville ha möjligheten att ha servern på en annan
plats än konstprojektet. Kvar fanns möjligheten att använda Wifi för kommunikation. Eftersom
mobiltelefonen kommer att använda sig av Wifi-uppkoppling till servern så valde vi att utnyttja
samma teknik genom hela projektet. Wifi passade även utmärkt på grund av att ingen modifiering av
serverns hårdvara krävs.
Efter en del sökande hittades en smidig tilläggsmodul som kan lösa problemet (se Figur 10). Modulen
möjliggör uppkoppling mot ett 2.4Ghz 802.11b/g-nätverk, som är en WLAN standard, och på så sätt
göra kommunikationen mellan servern och arduinokortet trådlös. WiFly som modulen heter, bygger
på en trådlös Roving Network's RN-131G modul (specifikationer se Appendix G) och ett SC16IS750
SPI (Serial Peripheral Interface Bus)6 till UART(Universal Asynchronous Receiver/Transmitter) chip. En
SPI till UART brygga används för att öka transmissionshastigheten och för att frigöra arduinokortets
egna UART. RN-131G-modulen stödjer även SDIO (Source Digital Input Output) 7 , RFID (Radio
Frequency Identification)8 och tillhandahåller tio programmerbara in/utgångar samt åtta analoga
sensorgränssnitt. Modulen har en inbyggd keramisk chippantenn med möjlighet att ansluta en extern
antenn [13].
Figur 10. Wifi-modulen. [105]
Strömförsörjningen av Wifi-modulen sker från utgången märkt ”Vin” från Arduino Mega ADK, den är
reglerad till 3.3V och försörjer både RN-131G-modulen och SC16IS750 chippet. Kommunikationen
mellan modulen och arduinokortet sker över SPI på de digitala utgångarna 50-52 (MISO, MISO, SCK,
SS) [14]. Modulen innehåller även en liten prototyparea med 0.1 tums hål där man kan göra egna
kopplingar eller fästa diverse komponenter [15].
För att konfigurera Wifi-modulen kopplar man upp sig med ett terminalprogram, t.ex. Terra Term, via
USB-kontakten till arduinokortet. Standardinställningarna för att få kontakt seriellt är 9600 bitars
hastighet, 8 bitars data, ingen paritet, 1 stoppbit och att flödeskontrollen är avstängd. Man kan även
koppla upp sig via telnet9 över Wifi för att konfigurera modulen. Det senare alternativet kräver dock
att man redan konfigurerat Wifi-modulen och har kontakt med den.
6
SPI är en synkron seriell datalänksstandard som arbetar i full duplex
SDIO tillåter kortplatsen för SD-kort att användas för ett annat ändamål
8
RFID är en teknik som möjliggör att information kan läsas på avstånd från transpondrar och minnen som kallas
för ”taggar”
9
Telnet är ett nätverksprotokoll avsedd för textbaserad kommunikation.
7
10
Project Rainbow
När anslutningen är upprättad skriver man tre tecken, ”$$$” för att komma in i modulens
konfigureringsläge. När kommandot är skickat får man tillbaka ”CMD” som bekräftelse på att man är
inne i konfigureringsläget. Väl inne i konfigureringsläget kan man definiera parametrar för hur
modulen ska bete sig, som t.ex. vilket nätverk den ska ansluta sig till, lösenord för nätverket, IPadress, kanal och protokoll. När konfigurationen är klar kan man välja att spara de aktuella
inställningarna i minnet genom att skriva ”save”. Detta gör att varje gång Wifi-modulen startar
kommer dessa parametrar läsas in från minnet och användas. För att avsluta konfigureringsläget
skickar man ”exit” [16].
2.4
Servomotorer
En servomotor är en DC (direct current)-motor som är utrustad med en servomekanism för att kunna
uppnå ett visst vinkelläge och är den komponent som kommer vinkla plattorna. Utöver en DC-motor
består den även av ett växelsystem, ett positioneringssystem (som oftast består av en
potentiometer) och styrelektronik. Motorn är ansluten till växelmekaniken som ger feedback från en
positioneringssensor. Från växellådan styr motorns utsignal servoarmen. Potentiometern ändrar
positionen som motsvarar den nuvarande positionen hos motorn, så att förändringen i resistans ger
en ekvivalent förändring i spänning från potentiometern. En servomotor brukar oftast kunna rotera
90⁰ eller 180⁰, det finns även vissa servomotorer som kan rotera 360⁰ eller mer. Rotationen är
begränsad mellan vissa vinklar och för att styra en servomotor använder man pulsbreddsmodulering,
en så kallad PWM - signal.
En puls vars bredd varierar mellan 1 – 2 millisekunder skickas upprepade gånger till servomotorn,
cirka 50 gånger per sekund. Då servomotorn tar emot en puls behålls värdet i 20-millisekunder, fram
tills en ny puls tas emot. Bredden på pulsen bestämmer vinkelläget som servomotorn ska ställa in sig
på [19].
T.ex. om pulsbredden är 1 millisekund så rör sig servoarmen mot 0⁰ och 2 millisekunders pulsbredd
rör sig mot 180⁰. Då skulle 1.5 millisekunders pulsbredd motsvara en vinkel på 90⁰ (se Figur 11).
Dessa värden är ungefärliga och beteendet på servomotorerna skiljer sig baserat på tillverkare.
Figur 11. Exempel på några pulsbreddsmodulerade signaler för att uppnå tre vinklar. [106]
11
Project Rainbow
Servomotorerna som används i projektet är typiska servomotorer för modellbyggen, fyra stycken
Graupner Servo DES 708 BB, MG (se Figur 12). Dessa servomotorer drivs med 4.8V – 6V och kräver en
ström på cirka 1800mA. Eftersom detta är mer än arduinokortet klarar av att driva krävs en extern
spänningskälla som kan tillhandhålla tillräckligt hög ström.
Figur 12. Graupner Servo DES 708 BB, MG. [107]
2.5
Spänningskälla
De olika komponenterna som kommer att användas i projektet behöver matas med olika spänning
och drar olika mycket ström (se Tabell 2) blir det enklare att ha en enda spänningskälla som kan
försörja alla komponenter istället för att varje komponent har sin individuella adapter.
Antal
2
4
1
1
Komponent
Ventiler VDW21-5G-3-01F-Q
Graupner Servo DES 708 BB,MG
Arduino Mega ADK
LED Slinga för belysning
Spänning
12V
4.8-6V
12V
12V
Ström
0.25A
1.63-1.84A
Max 1.5A
2A
Tabell 2. Lista över komponenter och deras matningsbehov.
Då ett vanligt nätaggregat för stationära datorer (se Figur 13) kan ge dessa spänningar och klarar av
att lämna tillräckligt hög ström gjordes valet att använda detta som spänningskälla. Nätaggregatet
behöver dock modifieras för att tillfredsställa komponenternas behov. Ytterligare information om
detta finns i kapitel 3.5.
Figur 13. Nätaggregat från en stationär dator.
12
Project Rainbow
3. Genomförande
I detta kapitel beskrivs genomförandet av arbetsprocessen. Kapitlet är uppbyggt i den ordning
kommunikationen sker, Android → Server → Arduino. Efter det beskrivs konstruktionen av
spänningskällan och sist de förändringar vi gjort i den ursprungliga designen. Fullständig källkod för
androidapplikationen finns i Appendix C, koden för servern i Appendix D och arduinokoden i
Appendix E.
3.1
Utveckling av vår applikation till Android
Applikationen ska vara så enkel och användarvänlig som möjligt och därför består den av endast en
aktivitet. Aktiviteten representeras av en skärmsida med ett användargränssnitt [7].
Användargränssnittet består av en svart bakgrund, för att ge ett starkt konstnärligt intryck, och tre
stycken växlingsknappar (se Figur 14).
Figur 14. Aktivitetens användargränssnitt.
När applikationen startar anropas ”onCreate” metoden. Där skapas ett objekt som kommer att sköta
TCP-kommunikationen samt en sensorhanterare som hanterar accelerometern. Växlingsknapparna
(Connect, Controlling Off och Water Off) kopplas till ”lyssnare” som känner av om en knapptryckning
sker. Då anropas en metod som kontrollerar vilken knapp det är och beroende på detta hanterar
knapptryckningen på rätt sätt. Igångsättning eller byte av nätverk görs också i ”onCreate” metoden.
Efter att ”onCreate” metoden anropats eller när applikationen återfår användarens fokus anropas
metoden ”onResume”. Här registrerar sensorhanteraren accelerometern så att den sätts igång och
kan användas. Växlingsknapparna ställs in i de lägen de ska ha vid uppstart då enbart knappen
”Connect” ska kunna tryckas på.
Metoden ”onPause” anropas när applikationen försvinner ur användarens fokus. Applikationen
kopplar då ner anslutningen till servern och sensorhanteraren avregistrerar användandet av
accelerometern så att den inte ligger igång och drar ström från batteriet i användarens mobiltelefon.
Se Appendix B för sekvensdiagram över ovan nämnda metoder samt klassdiagram för applikationen.
13
Project Rainbow
Knapparnas funktioner är följande: försöka koppla upp sig mot servern, sätta
igång styrningen av plattorna samt sätta igång vattenflödet. Det krävs att
androidenheten är uppkopplad mot samma trådlösa nätverk som servern men för
att användaren inte ska behöva tänka på detta så sköter applikationen det
automatiskt vid uppstart. För att få tillåtelse att använda dessa funktioner, som Figur 15. Ikonen för
innefattar igångsättning av nätverkskortet och/eller byte av trådlöst nätverk, vår applikation.
måste detta anges i applikationens manifestfil (se Figur 16). I denna fil har även
sökvägen som hänvisar till applikationens ikon (se Figur 15) lagts till.
Figur 16. Utdrag ur manifestfilen.
3.1.1
Behandling av accelerometerdata
För att ha möjlighet att styra plattorna efter androidenheten behövs tillgång till data från
accelerometern som anger enhetens läge. Dessa data kan fås genom att skapa en sensorhanterare
som hanterar accelerometern. Då accelerometerns värde ändras (enhetens vinkel ändras) ska dessa
skickas till servern. Som tidigare nämnt kan accelerometern ge värden i tre riktningar, x-, y- och z-led.
Det är enbart förändringen i x- och y-led som applikationen skickar till servern eftersom det är i dessa
riktningar användaren kan vinkla plattorna. Innan dessa värden skickas kontrolleras om enheten
skakas genom att se om det skett en snabb accelerationsförändring i någon av riktningarna och i så
fall skickas inga värden. Detta för att skydda servomotorerna mot plötsliga förändringar.
3.1.2
Uppkoppling och sändning av data
Som nämnts tidigare behöver
användarens androidenhet vara
uppkopplad mot samma trådlösa
nätverk som servern för att enheten
ska kunna ansluta till servern. Genom
att trycka på knappen ”Connect” kan
användaren försöka ansluta till
servern (se Figur 17).
Figur 17. Ett försök att ansluta till servern görs.
14
Project Rainbow
För att anslutningen ska lyckas måste servern vara tillgänglig. Det sker också en kontroll att ingen
annan enhet är uppkopplad mot servern genom att ett kontrolltecken skickas från enheten och
väntar på ett svar i tre sekunder. Metoden som sköter detta heter ”heartbeat” (se Figur 18) och
används även för att kontrollera att uppkopplingen mellan androidenhet och server är aktiv. Detta
görs var femte sekund. Mottags inget svar tre sekunder efter att tecknet skickats kopplas
anslutningen till servern ner.
Figur 18. Metoden heartbeat.
Lyckas enheten ansluta sig till servern blir användaren medveten om detta genom att knappen blir
grön och visar texten ”Connected”. Växlingsknappen som sätter på och av styrningen blir då
tillgänglig (se Figur 19). Är servern däremot upptagen eller inte går att ansluta sig till, visas ett
meddelande om detta på enhetens skärm (se Figur 20).
Figur 19. Enheten är ansluten till servern.
Figur 20. Anslutningen till servern misslyckades.
15
Project Rainbow
När styrningen är aktiverad skickas accelerometerdatan och ett värde för ventilerna som bestämmer
om de ska öppnas eller stängas. Ska det vara möjligt att kontrollera vattenflödet måste styrningen
vara aktiv. För att servern ska veta att det är styrningsdata som kommer så skickas först ett ”A” och
sedan styrningsdata. Metoden ”sendPositions” (se Figur 21) sköter sändningen av dessa data.
Figur 21. Metoden ”sendPositions” som skickar data till servern.
3.1.3
Nedladdning av applikationen
Applikationen finns tillgänglig på Google Play och heter Project Rainbow. Den kan laddas ner av
användaren antingen genom att söka efter ”Project Rainbow” på Google Play eller med hjälp av en
QR (Quick Response)-tagg som kommer att finnas tillgänglig vid utställning av projektet (se Figur 22).
QR-taggen scannas med en applikation som kan läsa av streckkoder och skickar användaren direkt till
applikationen i Google Play.
Figur 22. QR-tagg för att komma direkt till applikationen.
3.2 Serverns uppbyggnad
Servern tillhandahåller och sköter kommunikationen mellan androidenheten och arduinokortet, som
styr konstinstallationen. När konstinstallationen är utställd ska servern vara igång hela tiden och
vänta på att någon ska koppla upp sig mot den med sin androidenhet. När en enhet är uppkopplad
kan ingen annan enhet koppla upp sig.
På servern används både en TCP-socket10 och en UDP-socket. När servern startar börjar den med att
skapa en socket för datagrammen (se Figur 23) som ska skickas till arduinokortet.
10
Socket är en anslutningspunkt som uppkopplad mot en annan socket kan överföra data mellan varandra.
16
Project Rainbow
Figur 23. Socket för UDP överföringen skapas och Wifi-modulens IP-adress sparas.
För att en klient, i detta fall en androidenhet, ska kunna koppla upp sig mot servern skapas en
serversocket vilken ligger och väntar på att en klient ska försöka ansluta på en specifik port11 (se Figur
24 rad 4). I samband med att en klientuppkoppling accepteras skapas två strömmar (se Figur 24 rad
16 och 18) som har hand om in- och utgående data mellan klient och server.
Figur 24. Utdrag från metoden newConnection.
När servern tar emot TCP-paketet från androidenheten så läses datainnehållet in rad för rad. Första
raden är ett A, andra är x-värdet, tredje y-värdet och fjärde är värdet för vattnet. När servern känner
av att första tecknet är ett A så vet den att nästkommande värden är accelerometerdata och
vattenvärde. Varje rad avslutas med en punkt. Ett exempel på hur dessa data från paketet kan se ut
visas i Figur 25. Övre raden visar datainnehållet i hexadecimal form och raden under dess
motsvarighet i decimalform. Storleken på datadelen i TCP-paketet kan variera något beroende på hur
många decimaler som de sända värdena innehåller men ofta ligger storleken på 43 bytes.
Figur 25. Datainnehållet i ett TCP-paket från en androidenhet.
Innan dessa data skickas till Wifi-modulen räknas x- och y-värdet om till ett nytt intervall. Intervallet
på accelerometerdatan från androidenheten är mellan cirka -10 och 10. Det värde arduinokortet kan
skicka till servomotorerna ska ha ett intervall på 0 till 180 som motsvarar grader.
11
Port kan ses som en adress för att datorn ska veta vilket program som paketen ska hänvisas till.
17
Project Rainbow
Följande formel används för att få värdet inom det nya intervallet:
.






newValue är värdet som ska vara inom intervallet 0 till 180.
oldValue är värdet från accelerometern som är inom intervallet -10 till 10.
a1 är det gamla intervallets minimum värde (-10).
a2 är det gamla intervallets maximum värde (10).
b1 är det nya intervallets minimum värde (0).
b2 är det nya intervallets maximum värde (180).
Figur 26 visar värdets förhållande i de två intervallen.
Beräkning av accelerometervärdets nya intervall
Resultatet på värdet i intervallet 0-180
180
160
140
120
100
80
60
40
20
0
-10 -9
-8
-7
-6
-5
-4
-3
-2
-1
0
1
2
3
4
5
6
7
8
9
10
Aaccelerometervärdet i det gamla intervallet (-10) - 10
Figur 26. Värdets förhållande i de två intervallen.
Efter att värdena räknats om till det nya intervallet avrundas de till ett heltal och får då plats i varsin
byte. Dessa tre bytes läggs i datagrampaketet (se Figur 27) och skickas till Wifi-modulen via den UDPsocket som tidigare skapats.
Figur 27. Metoden som skapar och skickar datagram.
18
Project Rainbow
UDP-paketets datainnehåll som skickas från servern visas i Figur 28. Här har det inkommande TCPpaketets datainnehåll från Figur 25 räknats om till grader. Värdet i x-led är 81 grader, y-led 132
grader och värdet för vattnet är 0 vilket indikerar att det ska vara avstängt.
Figur 28. Datainnehållet i utgående UDP-paket.
Det sker en kontroll av värdena innan de skickas vilket innebär att klienten ses som inaktiv om
accelerometerdatan inte är ändrad efter 150 mottagningar, i tid innebär detta cirka 30 sekunder.
Kontrollen görs genom att jämföra de senast inkommande värdena med föregående värden. Är det
samma värden adderas en etta till räknaren som kopplar ner anslutningen när den når 150. Räknaren
nollställs när det är nya värden som kommer.
Om klienten önskar att uppkopplingen ska avbrytas skickas ett ”X” i dataströmmen till servern vilket
sker i bakgrunden när användaren trycker på knappen för att koppla ifrån. Strömmarna stängs då ner
och det gör även socketanslutningarna. Servern börjar sedan om med att skapa nya sockets och
återigen väntar den på att en ny klient ska ansluta sig.
3.3
Utveckling av arduinokortets programvara
När arduinokortet startas börjar Wifi-modulen skapa en anslutning till ett angivet nätverk med hjälp
av de sparade parametrar som förprogrammerats, så som nätverksnamn och lösenord. Även vilket
protokoll som ska användas för kommunikationen finns sparat i minnet på modulen. Protokollet som
används mellan Wifi-modulen och servern är UDP.
Efter att Wifi-modulen anslutit till nätverket börjar den lyssna efter trafik på en viss port, i vårt fall
portnummer 8888. Servern skickar ut paketen med aktuella accelerometervärden till Wifi-modulens
IP-adress på port 8888. Paketet som tas emot innehåller tre bytes, första byten innehåller x-värdet
och andra byten innehåller y-värdet. Sista byten
innehåller värdet för ventilerna till vattenflödet.
Vid uppstart skapas även en kommunikationslänk över SPI
mellan Wifi-modulen och arduinokortet samt initiering av
servomotorerna till PWM-utgång 2,3,4 och 5. Även
utgång 22 aktiveras för att göra det möjligt att öppna eller
sluta ventilerna för vattenflödet. Efter detta körs en loop
för att se om data sänds från Wifi-modulen. Pågår ingen
kommunikation mellan korten stängs servomotorerna av i
väntan på att data ska tas emot. Är det däremot en
datatrafik mellan korten, så kontrolleras x- och y-värdena
med hjälp av koden som visas i Figur 29. Där ”income[0]”
är det inkomna x-värdet och ”income[1]” är y-värdet.
Viss kalibrering behöver programmeras eftersom
servomotorerna inte ska röra sig över vissa vinklar för att
Figur 29. Källkod för att styra vänster platta från förhindra skada på konstprojektet. Därför krävs det en
Arduinokortet.
19
Project Rainbow
kontroll av de mottagna värdena innan de skickas till respektive servomotor.
Detta görs i de två övre satserna enligt Figur 29 som visar koden för styrningen av vänster platta,
styrningen för höger platta fungerar på samma sätt. Är det inkomna x-värdet mindre än eller lika
med 24 ska värdet 24 skickas till ”servo[0]”. Är x-värdet större än eller lika med 160 ska 160 skickas
som värde till ”servo[0]”. Alla x-värden mellan 24 och 160 kan skickas direkt till ”servo[0]”.
För y-värdet krävs en liknande kontroll förutom att y-värdet skickas till ”servo[1]”. Eftersom
servomotorerna är spegelvända behövs även en formel för att också spegla värdena, t.ex. blir 0 = 180
och 160 = 20. Denna formel kan ses i de två nedre satserna i figuren.
När Arduinokortet sänder värdet med hjälp av write()-funktionen, så skickas en PWM-signal till
servomotorerna som ställer in plattorna i rätt läge. Efter varje sänd signal anropas även funktionen
detach() vilken kopplar från servomotorerna i väntan på att nya värden ska skickas.
Inkommande värde för ventilerna är antingen 1 för att öppna eller 0 för att sluta. Är det inkomna
värdet 1 så skickas 5 V till utgång 22 som är ansluten till ett kretskort för att öppna ventilerna (se
Kapitel 3.4). Är värdet istället 0 så skickas ingen spänning till utgång 22 vilket gör att ventilerna är
slutna (se Figur 30).
Figur 30. Kod för att öppna respektive sluta vattenventilerna.
3.4
Ventiler
För att ha möjlighet att stänga av och sätta på vattenflödet genom munstycket i plattorna behövs ett
par elektriskt kontrollerbara ventiler. De som passade projektet bäst var 2/2vägselektromagnetventil, VDW21-5G-3-01F-Q (se Figur 31). Ventilerna klarar att släppa genom ett
vattenflöde på 0.43 l/min och kräver en arbetsspänning på minst 12 V. De öppnas eller sluts
beroende på vad de tar emot för spänning.
Matas de med låg spänning stängs ventilerna och när spänningen blir hög öppnas ventilerna så att
vattnet kan flöda fritt genom kopplingen.
Figur 31. 2/2-vägselektromagnetventil, VDW21-5G-3-01F-Q. [108]
20
Project Rainbow
Eftersom all information från användaren kommer till arduinokortet måste därför ventilerna även
kunna styras genom detta. Vi har tillverkat ett eget kretskort som gör det möjligt för arduinokortet
att slå på respektive av den externa spänningen på 12V till ventilerna. Detta kretskort består av ett
motstånd på 1kΩ, en NPN transistor BD241C och en 1N4002 diod. Motståndet kopplas mellan utgång
22 på arduinokortet till basen på transistorn. Ventilernas jord kopplas till kollektorn på transistorn,
och arduinokortets jord kopplas till emittern på transistorn. Dioden kopplas från kollektorn med
katoden riktad till spänningskällans pluspol. Den förhindrar att bakslagsspänning skadar kretsen.
Spänningskällans jord kopplas slutligen till emittern (se Figur 32).
Figur 32. Kretskoppling för ventiler.
När användaren har tryckt på knappen ”Water On” skickas en etta i tredje byten i paketet till
arduinokortet som i sin tur skickar ut en hög spänning på utgång 22 vilket öppnar kretsen. Med hjälp
av ovanstående koppling kan kretsen (se Figur 33) styras för att mata ventilerna med den externa
spänningskällan på 12 V.
Figur 33. Ventilkretsen på ett prototypkort.
21
Project Rainbow
3.5
Nätaggregat
Som spänningskälla använde vi ett gammalt nätaggregat till en dator. Nätaggregatet är tillverkat av
Macron Technologies och ansluts till ett vanligt 230V uttag. Nätaggregatet kan förse önskade
komponenter med spänning och ström enligt tabell 3.
Kabelfärg
Röd
Gul
Vit
Blå
Svart
Spänning
+5 V
+12V
-5V
-12V
GND
Ström
30A
15A
0.5A
0.8A
GND
Tabell 3. Lista över anslutningar hos nätaggregatet.
För att skapa en enkel kontakt för utgångarna fästes laborationsutgångar på framsidan av
nätaggregatet. Totalt är det tre kontakter, två kontakter för +5 respektive +12 V samt en för jord (se
Figur 34).
Figur 34. Laborationskontakter fästa på nätaggregatet.
För att utgångarna skall fungera optimalt krävs det att all kablage för en viss spänning fästs
tillsammans med respektive laborationsutgång. Kablagen med färgmarkeringen vit, blå och orange
isolerades eftersom de inte behöver användas.
För att minimera kablagen och göra systemet smidigare fästes även en apparatlåda till nätaggregatet.
På apparatlådan monterades en strömbrytare för nätaggregatet och en 25-utgångars D-subminatyrs
honkontakt (se Figur 35).
Figur 35. Nätaggregat med monterad apparatlåda.
22
Project Rainbow
När apparatlådan monterats på nätaggregatet placeras arduinokortet, Wifi-modulen och kretskortet
för att styra ventilerna inuti apparatlådan (se Figur 36). Alla kablar som ska anslutas klämdes fast i en
D-subminatyrs honkontakt, och ett litet hål för att kunna ansluta till arduinokortet via USB-kontakten
sågades ut.
Figur 36. Arduinokortet med WiFly-modulen och ventilkoppling, monterade i apparatlådan.
Från bågen där ventiler, servomotorer och belysning är installerat, går en 12-ledarkabel och en 2ledarkabel. Kablagen går i andra änden till en D-subminatyrs hankontakt (se Figur 37) som kopplas in
i apparatlådan.
Figur 37. D-subminatyrs hankontakt som ska kopplas in i honkontakten på apparatlådan.
23
Project Rainbow
3.6
Design
För att öka den visuella effekten för användaren valde vi att göra förändringar på designen.
Bågen som tidigare var tillverkad i rött plexiglas (se Figur 38) förändrades så att den nu består av vitt
plexiglas (se Figur 39). Med hjälp av en laserskärare och ritningarna som användes för det röda
plexiglaset skars de olika delarna till sidorna på bågen ut. Vi valde även att tillverka ett lock och en
botten på bågen för att kunna dölja kablage och vattenslang samt fånga den nymonterade LEDslingans effekt. Eftersom laserskäraren inte klarar av delar som är längre än 60 cm så fick lock och
botten tillverkas i delar om tre. För dessa delar fanns inga tidigare ritningar utan dessa skapades efter
de mått som bågen har (se Appendix H). Kanterna på locket och botten fasades ut för att få en bättre
passform. För att få delarna formade efter bågens form värmdes de upp med hjälp av en
värmepistol. Delarna hålls på plats med hjälp av bultar som fästs med en mutter under
bottendelarna.
Figur 38. Bågen i tidigare röd design.
Figur 39. Bågen i vitt plexiglas med lock och botten.
24
Project Rainbow
3.6.1 Belysning
För att få ett mer effektfullt intryck monterades en 5 meter lång LED-ljusslinga inuti bågen(se Figur
33). Man kan med hjälp av en fjärrkontroll (se Figur 40) ändra färg och intensitet på ljusslingan eller
låta den automatiskt skifta mellan olika färger. Användaren bjuds på en härlig visuell effekt när
ljusslingan lyser genom det vita plexiglaset (se Figur 41)
Figur 41. Belysning i vitt, rött, grönt och blått.
Figur 40. LEDslingan och dess
fjärrkontroll.
3.6.2 Vattenflöde
En annan funktion som ökar upplevelsen är vattenflödet. Varje platta har ett munstycke(se Figur 42)
där vatten forcerar genom när ventilerna är öppna. För att pumpa upp vattnet används en länspump
som drivs av 12 volt, vattnet går från plastdammen upp genom vattenslangen som ligger inuti bågen,
ut till varje platta (se Figur 43). Länspumpen klarar att leverera ett vattenflöde på 32 l/min vilket ger
ett tillräckligt bra tryck för att producera en tunn stråle vatten från varje platta. När användaren styr
plattorna med sin mobiltelefon följer vattenstrålarna telefonens rörelser och tillåter användaren att
sätta på eller stänga av vattenflödet under tiden.
Figur 42. Munstycke som skapar vattenstrålen.
Figur 43. Vattnet leds genom ventilerna.
25
Project Rainbow
3.7
Test av systemet
En testdag gjorde det möjligt att se hur besökare kunde interagera med projektet och samtidigt testa
hur väl applikationen fungerade på mobiltelefoner med olika version av Android (se Figur 44).
Besökaren följde den användarbeskrivning (se Appendix I) som fanns intill konstprojektet.
Applikationen testades på olika versioner av Android (från 2.2 och uppåt) med framgång. Men vid ett
test på den senaste versionen (Android 4.0.3, API 15) kraschade applikationen. Efter felsökning
kunde felet lokaliseras. Applikationens krasch berodde på att kommunikationen till servern skedde i
programmets huvudtråd vilket inte är tillåtet i denna version av Android. Detta löstes genom att vid
applikationens uppstart kontrollera vilken version som körs. Om det är en senare version än 2.2, sätts
en mindre strikt policy för applikationen som tillåter denna typ av uppgift i huvudtråden. En annan
lösning på problemet är att skapa en asynkron uppgift för att sköta kommunikationen till servern.
Det är en uppgift som körs i en egen tråd i bakgrunden av huvudtråden och på så sätt inte riskerar att
låsa den.
Figur 44. Monter för testdagen.
26
Project Rainbow
4. Resultat och diskussion
I den här rapporten har vi beskrivit hur man trådlöst kan styra ett elektromekaniskt system med hjälp
av en mobiltelefon. En prototyp för systemet har konstruerats och fungerar enligt de avgränsningar
och kriterier som skulle uppfyllas enligt förstudien (se Appendix A). Applikationen finns lättillgänglig
via Google Play. En användare åt gången kan koppla upp sig mot konstprojektet och styra det trådlöst
med hjälp av en androidenhet. Den separata spänningskällan som tillverkades blev också lyckad. Med
hjälp av den behövs enbart två kablar för att strömförsörja hela installationen, en kabel från bågen
till apparatlådan och en kabel från nätaggregatet till ett eluttag.
Ett av problemen som uppstod under projektet var att LED-belysningen flimrade till när
servomotorerna ändrade läge. Detta berodde på den höga ström som servomotorerna drar under
små tidsintervaller, vilket gjorde att strömmen till belysningen inte var tillräcklig. Detta löstes genom
att byta ut nätaggregatet från originalkonstruktion till ett annat med högre effekt. Det blev även
problem med att ventilerna inte kunde öppnas eller slutas när vattenpumpen kördes. Detta berodde
också på att nätaggregatet inte kunde ge den spänning som krävdes för att styra ventilerna när de
utsattes för trycket från vattnet. Även detta löstes när nätaggregatet blev utbytt.
Vi stötte även på problem när vi implementerade en kontroll på servern för att hålla reda på att
uppkopplingen mellan en androidenhet och servern är aktiv. Tanken var att använda javaspråkets
fördefinierade funktioner för denna kontroll så som isConnected() och isBound(). Då detta inte
fungerade som tänkt, skapade vi en egen funktion vilken meddelar användaren om att kontakten
med servern brutits och servern återgår då till sitt startläge för att låta en ny användare ansluta.
En annan svårighet var att hitta relevant information för att skapa en bra kommunikationslänk
mellan Roving Network's WiFly-modul och servern. Tack vare olika utvecklarforum på internet och de
tidigare arbeten som tas upp i kapitel 1.4 fick vi en del tips som kunde lösa våra problem med
modulen.
I grundkonstruktionen på bågen kan servomotorernas rörelsemönster inte utnyttjas fullt ut eftersom
den mekaniska konstruktionen som plattorna är fästa med begränsar plattornas rörelse. Men
konstruktionen är ändå tillräckligt bra för att användaren tydligt ska se vinkelförändringar på
plattorna. Servomotorernas hastighet är i teorin ca 0.1 s/40° vilken dock minskas något på grund av
plattornas vikt men är ändå så pass starka, med ett vridmoment på ca 100 N/cm, att tidsökningen blir
marginell och påverkar inte upplevelsen.
Vi utförde även ett pilotprojekt där vi ställde ut konstinstallationen för en dag tillsammans med
instruktioner för hur besökare skulle kunna interagera med den. Servern hade en fast IP-adress som
även gick att nå via det mobila nätverket. Detta gjorde det möjligt att styra konstinstallationen utan
att befinna sig på samma trådlösa nätverk som servern. Tyvärr var det mobila nätverket inte
tillräckligt snabbt för att ge användaren en bra responstid vid styrningen. Det tog cirka 5 sekunder
från det att användaren vinklat sin telefon tills plattorna ändrade läge. Responstiden försämrade
helhetsintrycket markant vilket gjorde att vi enbart tillät uppkoppling via ett eget trådlöst nätverk.
Där var responstiden cirka ½ sekund.
27
Project Rainbow
Reaktionen från användarna var mycket positiv och installationen väckte stort intresse bland de
förbipasserande. Detta var en utmärkt möjlighet för oss att testa systemet som helhet och även
kunna testa applikationen på många olika mobiltelefoner. Det enda problemet som uppstod under
dagen var att telefonmodellen Xperia Arc S tillverkad av Sony Ericsson skickade accelerometervärden
för ofta för att plattorna skulle hinna ändra läge. Till skillnad från mobiltelefoner av andra tillverkare,
skickade Sony Ericssons modell tre gånger mer information under en minuts tidsintervall. Detta beror
förmodligen på att accelerometerchippet i den modellen har en högre samplingsfrekvens.
28
Project Rainbow
5. Slutsats
Projektet har gått bra och vi har följt tidsplaneringen. Vi har uppfyllt delmål och milstolpar som
upprättades under förstudien. Samarbetet i gruppen har gått bra och varje individ har slutfört de
delar som den ansvarat för (se ansvarsområden samt uppgiftsuppdelning i förstudien, appendix A).
Eftersom en server används som länk i kommunikationsflödet är möjligheterna för framtida
utveckling stor. De tankar och idéer vi har om framtida utveckling är:
 Möjliggöra kommunikation via mobilt nätverk, till exempel 3G-nätet. Förutsatt att servern har ett
fast IP-nummer som går att nå externt så fungerar det att kommunicera över det mobila
nätverket. Detta betyder att användaren inte behöver vara uppkopplad mot ett specifikt trådlöst
nätverk utan det räcker att personen har internetuppkoppling via sin mobiloperatör.
 Eftersom all information som styr installation skickas via en server finns möjlighet att styra den via
ett webbgränssnitt också. Tanken är då att man skulle kunna se konstprojektet via en
webbkamera och kunna interagera med det från en annan plats i världen.
 Ändra den mekaniska grundkonstruktionen så att plattorna kan få ett större rörelsemönster.
 Systemet skulle kunna vidareutvecklas för att tillåta två användare att vara uppkopplade mot
konstprojektet samtidigt och styra varsin platta. För att detta ska fungera krävs det att
applikationen, servern samt arduinokortet omprogrammeras.
 Systemet öppnar eller sluter båda ventilerna samtidigt. I framtiden skulle man även kunna ha
möjlighet att sluta eller öppna var ventil för sig. För att möjligöra detta behöver applikationen
innehålla en knapp till samt att servern ska skicka ytterligare ett värde till Arduinokortet. Även ett
extra kretskort (se Figur 25) för att styra ventilen behöver byggas.
 Möjliggöra styrning av ljusslingan genom mobilapplikationen. För att detta ska fungera krävs det
att arduinokortet utrustas med en IR-sändare och att androidapplikationen sänder ett extra värde
för färgvalet till servern. Arduinokortet skickar sedan en signal via IR-sändaren till konstprojektets
IR-mottagare som ställer om färgen.
Tekniken som används i projektet kan även appliceras på andra användningsområden. Exempelvis
skulle mobiltelefonens accelerometer och gyroskopiska sensorer kunna användas för att kontrollera
en Segway PT12 där telefonen skulle kunna kopplas in i styret och tillhandahålla styrning och
balansfunktionerna.
Styrningen för svensktillverkade övervakningsroboten Rotundus [23] skulle även kunna bygga på
samma teknik. Roboten har formen av en sfär och tar sig fram genom att en pendel inuti roboten
vinklas åt det håll den ska färdas.
Framförallt kan tekniken användas för att skapa billiga prototyper till olika projekt eller för att skapa
egna interaktiva miljöer där bara fantasin sätter gränser för vad som är möjligt.
12
Segway PT är ett tvåhjuligt fordon som själv håller balansen. Styrs genom att personen lutar sig åt det håll
den vill färdas.
29
Project Rainbow
Referenser
[1] ”Tekniska prylar”, Undersökning utförd av: Silentium, april 2011,
http://www.silentium.se/wp-content/uploads/Tekniska-prylar-var-2011.pdf, 2012-05-04
[2] FAQ, Open Handset Alliance,
http://www.openhandsetalliance.com/oha_faq.html, 2012-04-12
[3] Andy Rubin Google+ post, 27 februari 2012, Andy Rubin,
https://plus.google.com/u/0/112599748506977857728/posts/Btey7rJBaLF, 2012-04-12
[4] Om Google Play, Google,
https://play.google.com/about/features/, 2012-04-11
[5] Heming Pang, Linying Jiang, Liu Yang och Kun Yue. ”Research of android smart phone
surveillance system” in Computer Design and Applications (ICCDA), Qinhuangdao, China. 2010, s.
V2-373 - V2-376
[6] Adam M. Dutko, "Domo Arigato Mr Androidato—An Introduction to the New Google Mobile
Linux Framework, Android", Linux Journal, Vol. 2008, nr. 167, s. 48-80.
[7] Application Fundamentals, Android Developers,
http://developer.android.com/guide/topics/fundamentals.html, 2012-04-12
[8] Activities, Android Developers,
http://developer.android.com/guide/topics/fundamentals/activities.html, 2012-04-13
[9] Greg Gagne, ”To java.net and beyond: teaching networking concepts using the Java networking
API”. In Proceedings of the 33rd SIGCSE technical symposium on Computer science
education (SIGCSE '02), mars 2002. ACM, New York, NY, USA, s. 406-410.
[10] Amit Saha. ”Learning to program the Arduino”. Linux Journal. Vol. 2011, nr. 211.
[11] Arduino Build Process, Arduino,
http://arduino.cc/en/Hacking/BuildProcess, 2012-04-10
[12] Arduino ADK, Arduino,
http://arduino.cc/en/Main/ArduinoBoardADK, 2012-04-10
[13] Benedikt Ostermaier, Matthias Kovatsch och Silvia Santini, ”Connecting things to the web using
programmable low-power Wifi modules”. In Proceedings of the Second International Workshop
on Web of Things (WoT '11), 2011. ACM, New York, NY, USA.
[14] SPI Library, Arduino,
http://arduino.cc/en/Reference/SPI, 2012-04-10
[15] WiFly Shield, Sparkfun Electronics,
http://www.sparkfun.com/products/9367, 2012-04-11
30
Project Rainbow
[16] WiFly GSX - User Manual and Command Reference, Roving Networks,
http://www.sparkfun.com/datasheets/Wireless/Wifi/WiFlyGSX-um2.pdf, 2012-04-11
[17] Min Zhang, Maurizio Dusi, Wolfgang John and Changjia Chen, ” Analysis of UDP Traffic Usage on
Internet Backbone Links”. Ninth Annual International Symposium on Applications and the
Internet (20 - 24 juli 2009), Seattle, USA.
[18] A. Malhotra, V. Sharma, P. Gandhi, N. Purohit, "UDP based chat application," 2nd International
Conference on Computer Engineering and Technology, Chengdu, China, 16-18 April 2010, pp.V6374-V6-377.
[19] Servo Motor, EngineersGarage,
http://www.engineersgarage.com/articles/servo-motor, 2012-04-11
[20] SensorEvent, Android Developers,
http://developer.android.com/reference/android/hardware/SensorEvent.html, 2012-05-07
[21] Martina Marti, Lorenz Rordorf, ”Interactive art installation”, 2011, bachelor thesis, Malmö
Högskola, Institutionen för datavetenskap.
[22] Jakub Wójcik, ”The conception and the implementation of control system for servomotor with
application of wireless network”, Krakow, Polen, 2011, master thesis, AGH University of Science
and Technology, Electrical Engineering.
[23] Rotundus,
http://www.rotundus.se/, 2012-05-11
[24] Danial Bin Mohd Ruslan,Ezreen Aida Bintikamarulzaman, “Build a wireless weather station”,
2011, Report for diploma: Engineering Technology in Telecommunication, University Kuala
Lumpur, Malaysia.
[25] TCP - How it works, The ISP Column, Geoff Huston
http://www.potaroo.net/ispcol/2004-07/2004-07-isp.htm, 2012-06-26
31
Project Rainbow
Bildreferens
[101] http://developer.android.com/guide/basics/what-is-android.html, 2012-04-11
[102] http://developer.android.com/images/activity_lifecycle.png, 2012-04-13
[103] http://developer.android.com/reference/android/hardware/SensorEvent.html, 2012-05-07
[104] http://arduino.cc/en/Main/ArduinoBoardADK, 2012-04-13
[105] http://dlnmh9ip6v2uc.cloudfront.net/images/products/09954-01b.jpg, 2012-04-14
[106] http://www.engineersgarage.com/articles/servo-motor?page=3, 2012-04-14
[107] http://www.graupner.de/en/products/7946/product.aspx, 2012-04-16
[108] https://www.elfa.se/elfa3~se_sv/elfa/init.do?item=54-229-10&toc=0, 2012-04-16
[109] http://www.potaroo.net/ispcol/2004-07/2004-07-isp.htm, 2012-06-26
[110] http://book.javanb.com/java-network-programming-3rd/javanp3-CHP-13-SECT-2.html,
2012-06-26
32
Appendix A
Förstudie
Appendix A
Projekt Rainbow - Förstudie
Bakgrund
Höstterminen 2011 gjorde två studenter från Schweiz sitt examensarbete vid Malmö högskola.
Examensarbetet handlade om att göra ett interaktivt konstprojekt där åskådaren själv kunde skapa
de visuella effekterna. De två studenterna designade och tillverkade en arm i plexiglas som har en
platta i vardera ända som kan vinklas med hjälp av två servomotorer. En vattenpump förser dessa två
plattor med en vattenstråle som på så vis kan vinklas och skapa olika intressanta mönster.
Deras tanke var att åskådarna själva skulle kunna styra konstinstallationen med hjälp av sin
mobiltelefon, då detta moment inte ingick i deras utbildning så lämnade de detta till framtida
utveckling. Istället styrdes konstinstallationen med hjälp av en joystick som sitter på ett Arduino
Mega ADK (se Figur 1).
Figur 1. Hur Användaren interagerar idag.
Avgränsning av forskningsfrågan eller huvudproblemet, förtydligande
av kravspecifikationer
Syftet med det här examensarbetet är att vidareutveckla ett tidigare examensarbete gjort av två
studenter, och att bygga vidare på den produkt som existerar idag. Tanken med slutprodukten är att
man ska kunna styra ett konstprojekt via sin mobiltelefon genom en applikation som hämtar
accelerometerdata från telefonen. Detta kommer att ske genom en kommunikation mellan
användarens telefon och en webbserver via TCP/IP över Wifi. Webbservern skickar sedan vidare den
bearbetade datan till Arduino-kortet med UPD över WIFI (se Figur 2). Konstinstallationen ska
använda sig av ett Arduino Mega ADK-kort, som ständigt hämtar data från webbservern och ändrar
de styrbara plattornas läge beroende på accelerometerdatan från användarens mobiltelefon. På så
vis kan användaren genom att vinkla sin mobiltelefon bestämma plattans läge. Applikationen
kommer att utvecklas för mobiltelefoner med operativsystemet Android, på grund av de enkla
utvecklingsmöjligheterna och stora antalet användare.
33
Appendix A
Förstudie
Figur 2. Systemöversikt
För att få en klar bild över projektets problematik och genomförbarhet, har vi valt att bryta ner
huvudproblemet i mindre delproblem (se Figur 3). På detta sätt får vi en klar bild över vilka
delproblem som projektet har och det blir enklare att börja leta efter relevant information och
bearbeta var problem för sig.
Figur 3. Delproblem och lösningsprinciper.
34
Appendix A
Förstudie
Följande tabell beskriver de olika delproblemens lösningsprinciper.
Lösningsprinci
p (LP)
1.1
Beskrivning
Strömförsörjningen till servomotorerna sker med en icke switchad 12Vadapter som kan ge en ström på minst 2A. Arduinokortet matas med en 5Vadapter och belysningen med en egen 12V-adapter. Ventilerna drivs med
12V och 0.125A. Istället för att ha fyra olika adaptrar hade vi tänkt tillverka
en egen strömförsörjningsadapter.
1.2.1.1
Arduinokortet förses med en Wifly-modul som kopplar upp sig mot ett
trådlöst nätverk. Detta gör att Arduinokortet får en ip-adress och vi får
möjlighet att skicka och ta emot data trådlöst.
1.2.2.1
Ventilerna kan antingen stängas av eller sättas på. Detta ska användaren
kunna göra genom samma applikation som styr konstverket. Eftersom
Arduinokortet inte kan mata en utgång med 12V kan inte styrningen ske
direkt på kortet.
1.2.2.2
Servomotorerna styrs med en PWM-signal som genereras av arduinokortet.
2.1
Applikationen kopplar upp sig mot servern och skickar data över TCP.
Servern skickar även tillbaka paket via TCP till applikationen. Servern
förmedlar denna bearbetade datan till arduinokortet via UDP.
2.2
Servern tar emot accerleometerdata från användarens telefon och räknar
om dessa värden till ett visst gradantal som skickas till arduinokortet som i
sin tur ställer in servomotorerna rätt.
3.1
Applikationen skapas i eclipse till androidversioner senare än 1.5.
Applikationen tillåter användaren att styra konstprojektet och ska vara
tillgänglig på android Market
3.2.1
Sändning och mottagning av data sker med TCP-paket. Applikationen
kommunicerar med wiflymodulen på arduinokortet över ett trådlöst nätverk.
3.1
Bågen ska lysa i olika färger för att ge en bättre upplevelse. Detta görs med
hjälp av en LED-slinga som ligger i bågen och styrs med hjälp av en IRfjärrkontroll.
3.2
Vattenpumpen ska kunna förse ventilerna med vatten samt ett eventuellt
vattenfall. Pumpen klarar 42liter per minut.
Följande krav har tagits fram för systemet. Typbetäckning m betyder minimikrav, i betyder idealkrav
och ö betyder önskemål.
Kravnr.
Typ
m/i/ö
Kravspecifikation
Gäller
för
DP och
LP
Styrningen av konstverket ska ske med en applikation i DP
3.1
användarens telefon.
LP 3.1
K1
m
K2
m
Applikationen ska vara lättillgänglig.
K3
m
K4
m
Konstverkets servomotorer och ventiler ska kunna styras med DP
applikationen.
1.2.2.1
DP
1.2.2.2
LP
1.2.2.1
LP
1.2.2.2
En användare ska via applikationen trådlöst koppla upp sig mot DP
LP 3.1
35
Appendix A
Förstudie
konstverket.
K5
m
K6
m
K7
i
K8
m
K9
m
K10
M
K11
m
K12
m
K13
ö
1.2.1.1
DP 3.2.1
LP
1.2.1.1
LP 3.2.1
Det ska inte gå att koppla upp sig mot konstverket om en DP
annan användare redan är ansluten.
1.2.1.1
DP 3.2.1
LP
1.2.1.1
LP 3.2.1
Applikationen ska vara kompatibel med alla telefoner som har DP 3.1
operativsystemet Android version 1.5 (API nivå 3) och uppåt.
LP 3.1
Responstiden för konstverket efter att användaren ändrat läge LP
på sin telefon bör inte överstiga ½ sekund.
1.2.1.1
LP 3.2.1
Applikationen ska vara så användarvänlig som möjligt
DP 3.1
LP 3.1
Applikationen ska gå att ladda ner genom att, med hjälp av sin DP 3.1
telefon, läsa av en QR-kod i anslutning till konstverket.
LP 3.1
Ingen strömförsörjning ska ske med batteri.
DP 1.1
LP 1.1
Bågen ska skifta i olika färger för att förstärka upplevelsen.
DP 4.1
LP 4.1
Vattenpumpen ska kunna förse konstprojektet med rätt mängd DP 4.2
vatten
LP 4.2
Konstprojektet ska kunna styras över internet.
Informationssökning efter vetenskapliga artiklar och yrkeskunskap
DP, LP
DP 3.1
DP 3.2.1
LP 3.1
LP 3.2.1
LP 3.1
DP 3.2.1
LP 3.1
LP 3.2.1
DP
1.2.2.2
LP 1.2.2.2
DP 1.2.1
DP
1.2.1.1
DP 3.2.1
LP 1.2.1
LP 1.2.1.1
LP 3.2.1
Källförteckning
Heming Pang, Linying Jiang, Liu
Yang, och Kun Yue. ”Research of
android smart phone surveillance
system” in Computer Design and
Applications (ICCDA), Qinhuangdao,
China. 2010, pp. V2-373 - V2-376
Adam M. Dutko, "Domo Arigato Mr
Androidato—An Introduction to the
New Google Mobile Linux Framework,
Android", Linux Journal, vol. 2008, nr.
167, s. 48-80.
Amit Saha. ”Learning to program the
Arduino”. Linux Journal. Vol. 2011, nr,
211.
Benedikt
Ostermaier,
Matthias
Kovatsch,
och
Silvia
Santini.”Connecting things to the web
using programmable low-power WiFi
modules”. In Proceedings of the
Second International Workshop on
Web of Things (WoT '11). ACM, New
York, NY, USA. 2011, Article 2 , 6
pages.
Relevans
Artikeln visar hur man kopplar upp sig
mot en server och skickar och tar
emot information med hjälp av
Android.
Artikel
som
operativsystemet android.
beskriver
Artikel som visar hur
kontrollera en servomotor
av Arduino
Artikel som beskriver
använder wifi-moduler för
till webben.
man kan
med hjälp
hur man
att ansluta
36
Appendix A
Förstudie
DP 1.2
DP
1.2.1.1
DP
1.2.2.2
LP 1.2.1.1
LP 1.2.2.2
Jakub Wójcik . “The conception and the
implementation of control system for
servomotor with application of wireless
network “Kraków 2011. AGH University
of Science and Technology.
Master’s thesis written under the direction
of prof. dr hab. inż Zygfryd Głowacz
http://www.smartgrid.agh.edu.pl/document
s/Wojcik.pdf
Examensarbete av Jakub Wójcik där
han beskriver hur man kan styra
servomotorer trådlöst med hjälp av
Arduino och en wifly-modul.
DP
1.2.1.1
LP 1.2.1.1
Roving Networks, Inc.
“WIFLY GSX
RN-131G, RN-131C, RN-134,
RN-121, RN-123 & RN-125, RN-370
WIFLY EZX
RN-171, RN-174, RN-XV”
October 26th 2011
http://dlnmh9ip6v2uc.cloudfront.net/da
tasheets/Wireless/WiFi/WiFly-RNUM.pdf
developer.android.com
arduino.cc
code.google.com/p/microbridge
Manual och kommandoreferens för
Wifly-modulen som beskriver hur man
kan kommunicera med hjälp av olika
protokoll.
DP 3
DP 1.2
DP 3
DP 1.2
Developers guide för Android.
Developers guide för Arduino.
Android debug bridge för att få
android att kommunicera via USB till
Arduino.
Genomförbarhetsanalys
Under förstudiens gång har vi bestämt vilka komponenter vi ska använda och hur vi ska gå tillväga för
att lösa projektets problematik. Vi har köpt de önskade komponenterna och även börjat laborera
med en prototyp för styrningen. I dagsläget har vi en fungerande prototyp där användaren hämtar
vår applikation från android market, applikationen ansluter sig sedan över ett lokalt trådlöst nätverk
till en wifly-modul som sitter kopplad på ett Arduino Mega ADK-kort. Applikationen samlar
accelerometerdata från telefonens rörelse och skickar det trådlöst via med hjälp av en UDP-socket till
konstprojektet. Wifly-modulen som sitter på Arduinokortet tar emot den skickade informationen och
behandlar den för att kunna ställa in servomotorerna i rätt läge. Flera personer kan använda
applikationen och turas om att interagera med konstprojektet. Med den här prototypen och
förstudien som grund, har vi verifierat att vi kan genomföra projektet inom den angivna tidsramen.
37
Tidsplanering med uppgiftsuppdelning
Projekt Rainbow
Aktivitet
Beteckning M-datum
Ansvarig Tiduppskattn.
Externa milstolpar
Problemformulering
Förstudie
Beta-redovisning
Slutredovisning
M1
M2
M3
M4
HACO
HACO
HACO
HACO
HA
2012-01-27
2012-03-02
2012-04-27
2012-05-28
v4
v5
v6
v7
v8
v9
v10
v11
v12
v13
v14
v15
v16
v17
v18
v19
v20
v21
v22
CO
Hårdvara
Strömförsörjning
H
H1
CO
10
10
20
Mottagning och sändning av data
Styrning av ventiler
H2
HA
50
50
100
40
∑
H3
CO
20
20
Styrning av servomotorer
Arduinoprogram
H4
HA
20
20
Android
A
Sändning och mottagning av data
Applikationsutveckling
Androidapplikation
A1
HA
40
40
80
A2
HACO
60
60
120
Server
S
Sändning och mottagning av data
Bearbetning av data
A1
HACO
10
10
20
A2
HACO
10
10
20
Design
Belysning
Vattenpump
Upphängning
Prototyp
D
Test
Optimering
Rapportskrivning
Handledarmöten
T
O
R
160
200
40
D1
HA
D2
CO
D3
HACO
20
10
20
20
20
10
20
60
HACO
HACO
HACO
HACO
Total Tid
20
20
50
11
20
20
50
11
351
351
38
Appendix B
Appendix B
Klassdiagram för androidapplikationen.
39
Appendix B
Sekvensdiagram för androidapplikationens metoder: onCreate(), onResume och onPause().
40
Appendix C
ServoControl.java
Appendix C
Källkod för androidapplikationen. Först kommer koden för klassen ServoControl.java efter det koden
för klassen TCP.java som sköter kommunikationen.
package project.rainbow.gui;
import
import
import
import
import
import
import
import
import
import
import
import
import
import
import
import
import
import
import
import
import
import
project.rainbow.comm.TCP;
com.rainbow.gui.R;
android.app.Activity;
android.app.ProgressDialog;
android.hardware.Sensor;
android.hardware.SensorEvent;
android.hardware.SensorEventListener;
android.hardware.SensorManager;
android.net.wifi.WifiConfiguration;
android.net.wifi.WifiManager;
android.os.Build;
android.os.Bundle;
android.os.Handler;
android.os.Message;
android.os.StrictMode;
android.view.Gravity;
android.view.View;
android.view.View.OnClickListener;
android.view.Window;
android.view.WindowManager;
android.widget.Toast;
android.widget.ToggleButton;
/**
* @author
*
*
*
*
*
*
*
*/
Henrik Andersson, Carl-Philip Olsson The "shake" check, including the
methods isAccelerationChanged(), isAccelerationChanged() and some of
the code in onSensorChanged(), is based on code by Thomas Manthey
from the AndroidCookbook.com
(http://androidcookbook.com/Recipe.seam;jsessionid
=278C53288C9F75D55D8316B0165D748E?recipeId=529&recipeFrom=ViewTOC,
2012-05-07)
public class ServoControl extends Activity implements SensorEventListener,
OnClickListener, Runnable {
private SensorManager mSensorManager;
private Sensor mAccelerometer;
private TCP tcp;
private ProgressDialog pd;
private boolean shakeToast = false;
/* Here we store the current values of acceleration, one for each axis
*/
private float xAccel;
private float yAccel;
private float zAccel;
/* And here the previous ones */
private float xPreviousAccel;
41
Appendix C
ServoControl.java
private float yPreviousAccel;
private float zPreviousAccel;
/* Used to suppress the first shaking */
private boolean firstUpdate = true;
/* What acceleration difference would we assume as a rapid movement?
*/
private final float shakeThreshold = 2.3f;
/* Has a shaking motion been started (one direction) */
private boolean shakeInitiated = false;
private Handler counterHandler = new Handler();
/*
* Is called when the application is created. If Android API version
* is higher than 8 a less strict mode is set to be able to send data
* from the main thread. A tcp object is created and the wifi is
turned
* on. Listeners are set to the Connect and Controlling buttons.
*/
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
if (Build.VERSION.SDK_INT > 8) {
StrictMode.ThreadPolicy policy = new
StrictMode.ThreadPolicy.Builder().permitAll().
build();
StrictMode.setThreadPolicy(policy);
}
tcp = new TCP();
getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,
WindowManager.LayoutParams.FLAG_FULLSCREEN);
getWindow().setFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON,
WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
requestWindowFeature(Window.FEATURE_NO_TITLE);
mSensorManager = (SensorManager)
getSystemService(SENSOR_SERVICE);
mAccelerometer = mSensorManager
.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);
setContentView(R.layout.main);
final ToggleButton tglConnect = (ToggleButton)
findViewById(R.id.tglConnectDisconnect);
final ToggleButton tglStartStop = (ToggleButton)
findViewById(R.id.tglStartStop);
//Wifi configuration to start the wifi and change the
network
WifiManager wifiManager = (WifiManager)
getSystemService(ServoControl.WIFI_SERVICE);
42
Appendix C
ServoControl.java
WifiConfiguration wc = new WifiConfiguration();
wc.SSID = "\"ProjectRainbow\"";
wc.status = WifiConfiguration.Status.ENABLED;
wc.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.NONE);
int netId = wifiManager.addNetwork(wc);
wifiManager.setWifiEnabled(true);
wifiManager.enableNetwork(netId, true);
//End Wifi configuration
tglStartStop.setOnClickListener(this);
tglConnect.setOnClickListener(this);
}
/*
* Starts the counter for the heartbeat function.
* Will be called every 5 seconds
*/
public void HeartbeatCounterStart() {
counterHandler.postDelayed(Heartbeat, 5000);
}
/*
* Stops the counter.
*/
public void HeartbeatCounterStop() {
counterHandler.removeCallbacks(Heartbeat);
}
/*
* This will run when the HeartbeatCounter reaches its
* counter value. Checks the server conncetion by calling
* heartbeat in the TCP class. If a heartbeat is received
* everything is ok otherwise will the tcp connection
* close.
*/
private Runnable Heartbeat = new Runnable() {
public void run() {
boolean hb = tcp.heartbeat();
if (tcp.getIsConnected() && hb) {
HeartbeatCounterStart();
} else if (!hb) {
tcp.closeConnection();
((ToggleButton)findViewById(R.id.tglConnectDisconnect)).setChecked(fal
se);
((ToggleButton)
((ToggleButton)
((ToggleButton)
((ToggleButton)
findViewById(R.id.tglStartStop)).setChecked(false);
findViewById(R.id.tglWater)).setChecked(false);
findViewById(R.id.tglStartStop)).setEnabled(false);
findViewById(R.id.tglWater)).setEnabled(false);
showToast("Server connection
lost");
System.err.println("No heartbeat
received");
}
}
};
/*
* Shows the incoming string in a
43
Appendix C
ServoControl.java
* toast message on the display for 3 seconds.
*/
public void showToast(String messageToShow) {
final Toast toastMessage = Toast.makeText(this,
messageToShow, 3000);
toastMessage.setGravity(Gravity.CENTER, Gravity.CENTER,
Gravity.CENTER);
toastMessage.show();
}
/*
* Will be called when a click on a button
* occurs. Checks which button that was clicked
* and makes different changes. If the connect button
* is clicked and there is no connection a new thread
* will be started and show a progress dialog while a
* connection to the server i trying to get established.
*/
public void onClick(View v) {
Thread thread = new Thread(this);
final ToggleButton tglConnect = (ToggleButton)
findViewById(R.id.tglConnectDisconnect);
final ToggleButton tglStartStop = (ToggleButton)
findViewById(R.id.tglStartStop);
final ToggleButton tglWater = (ToggleButton)
findViewById(R.id.tglWater);
if (v == tglConnect) {
if (!tcp.getIsConnected()) {
pd = ProgressDialog.show(this, "", "Connecting to
server...",true, false);
thread.start();
} else {
HeartbeatCounterStop();
tcp.sendExitPositions();
tglStartStop.setChecked(false);
tglWater.setChecked(false);
tglStartStop.setEnabled(false);
tglWater.setEnabled(false);
}
} else if (v == tglStartStop) {
if (tglWater.isEnabled()) {
tcp.sendPositions(0, 0, 0);
tglWater.setEnabled(false);
tglWater.setChecked(false);
} else {
tglWater.setEnabled(true);
}
}
}
/*
* The thread that will be started when
* a server connection is trying to get
* established. A specific handler takes care of
* the changes needed whether the connection
* is ok or not.
*/
44
Appendix C
ServoControl.java
public void run() {
if (tcp.tryToConnect()) {
handler.sendEmptyMessage(0);
HeartbeatCounterStart();
} else {
handler.sendEmptyMessage(1);
}
}
/*
* This handler is called when a server connection
* has been established or failed to establish. If
* the connection is ok the incoming message is "0"
* otherwise "1". Makes the needed changes and dismisses
* the dialogue.
*/
private Handler handler = new Handler() {
@Override
public void handleMessage(Message msg) {
if (msg.what == 0) {
((ToggleButton)
findViewById(R.id.tglStartStop).setEnabled(true);
((ToggleButton)
findViewById(R.id.tglWater)).setEnabled(false);
pd.dismiss();
} else if (msg.what == 1) {
((ToggleButton)
findViewById(R.id.tglConnectDisconnect)).setChecked(false);
pd.dismiss();
showToast("No server connection or
server busy!");
}
}
};
/*
* Is called when the application gets in
* focus. Registers the accelerometer listener
* and sets the buttons to its start values.
*/
@Override
protected void onResume() {
super.onResume();
mSensorManager.registerListener(this, mAccelerometer,
SensorManager.SENSOR_DELAY_NORMAL);
((ToggleButton) findViewById(R.id.tglConnectDisconnect))
.setChecked(false);
((ToggleButton)
findViewById(R.id.tglStartStop)).setChecked(false);
((ToggleButton)
findViewById(R.id.tglStartStop)).setEnabled(false);
((ToggleButton)
findViewById(R.id.tglWater)).setChecked(false);
((ToggleButton)
findViewById(R.id.tglWater)).setEnabled(false);
}
/*
* Is called when the application loses focus.
45
Appendix C
ServoControl.java
* Unregisters the accelerometer listener and if
* there is a connection to the server it will be
* disconnected.
*/
@Override
protected void onPause() {
super.onPause();
mSensorManager.unregisterListener(this);
if (((ToggleButton)
findViewById(R.id.tglStartStop)).isChecked()) {
((ToggleButton)ViewById(R.id.tglStartStop)).setChecked(false);
}
if (tcp.getIsConnected()) {
tcp.sendExitPositions();
}
}
/*
* Not used
*/
public void onAccuracyChanged(Sensor sensor, int accuracy) {
}
/*
* Is called everytime the accelerometer value is changed.
* If the controlling button is on and no shake is registered
* the values from the event will be sent to sendPositions.
* event.values[0] is the x-value, event.values[1] the y-value
* and event.values[2] the z-value (not used)
*/
public void onSensorChanged(SensorEvent event) {
if (((ToggleButton)
findViewById(R.id.tglStartStop)).isChecked()) {
updateAccelParameters(event.values[0],
event.values[1],
event.values[2]);
if ((!shakeInitiated) &&
isAccelerationChanged()) {
shakeInitiated = true;
} else if ((shakeInitiated) &&
isAccelerationChanged()
&& !shakeToast) {
showToast("Please don't shake
me!");
shakeToast = true;
} else if ((shakeInitiated) &&
(!isAccelerationChanged())) {
shakeInitiated = false;
} else if ((!shakeInitiated) &&
(!isAccelerationChanged())) {
shakeToast = false;
double[] xy = new double[2];
xy[0] = event.values[0];
xy[1] = event.values[1];
sendPositions(xy);
}
}
}
46
Appendix C
ServoControl.java
/*
* Store the acceleration values given by the sensor is based on code
by
* Thomas Manthey from the AndroidCookbook.com
* (http://androidcookbook.com/Recipe
* .seam;jsessionid=278C53288C9F75D55D8316B0165D748E
* ?recipeId=529&recipeFrom=ViewTOC, 2012-05-07)
*/
private void updateAccelParameters(float xNewAccel, float yNewAccel,
float zNewAccel) {
/*
* we have to suppress the first change of acceleration,
it results from
* first values being initialized with 0
*/
if (firstUpdate) {
xPreviousAccel = xNewAccel;
yPreviousAccel = yNewAccel;
zPreviousAccel = zNewAccel;
firstUpdate = false;
} else {
xPreviousAccel = xAccel;
yPreviousAccel = yAccel;
zPreviousAccel = zAccel;
}
xAccel = xNewAccel;
yAccel = yNewAccel;
zAccel = zNewAccel;
}
/*
* If the values of acceleration have changed on at least two axises,
we are
* probably in a shake motion Thomas Manthey from the
AndroidCookbook.com
* (http://androidcookbook.com/Recipe.seam;jsessionid=278
* C53288C9F75D55D8316B0165D748E?recipeId=529&recipeFrom=ViewTOC,
* 2012-05-07)
*/
private boolean isAccelerationChanged() {
float deltaX = Math.abs(xPreviousAccel - xAccel);
float deltaY = Math.abs(yPreviousAccel - yAccel);
float deltaZ = Math.abs(zPreviousAccel - zAccel);
return (deltaX > shakeThreshold && deltaY >
shakeThreshold)
|| (deltaX > shakeThreshold && deltaZ >
shakeThreshold)
|| (deltaY > shakeThreshold && deltaZ >
shakeThreshold);
}
/*
* Sends the incoming values to sendPositions in the
* tcp class and the correct value for the water depending
* on if the water button is checked or not.
*/
public void sendPositions(double[] xy) {
if (tcp.getIsConnected()) {
47
Appendix C
ServoControl.java
if (((ToggleButton)
findViewById(R.id.tglWater)).isChecked()) {
tcp.sendPositions(xy[0], xy[1], 1);
} else {
tcp.sendPositions(xy[0], xy[1], 0);
}
}
}
}
48
Appendix C
TCP.java
package project.rainbow.comm;
import
import
import
import
import
import
import
import
import
java.io.BufferedReader;
java.io.IOException;
java.io.InputStreamReader;
java.io.PrintWriter;
java.net.InetSocketAddress;
java.net.Socket;
java.net.SocketAddress;
java.net.SocketException;
java.net.UnknownHostException;
public class TCP {
// The servers ip address
private final String SERVER_IP = "192.168.0.51";
// The port number on which the server will receive data
private final int SERVER_PORT = 4445;
private Socket clientSocket = null;
private PrintWriter out = null;
private BufferedReader in = null;
private boolean isConnected = false;
/*
* Tries to connect to the server with a
* specific ip address and port number. Creates
* one output and one input stream. Returns true
* if connection establishes otherwise false.
*/
public boolean tryToConnect() {
try {
SocketAddress sockaddr = new
InetSocketAddress(SERVER_IP,SERVER_PORT);
clientSocket = new Socket();
clientSocket.connect(sockaddr, 3000);
out = new PrintWriter(clientSocket.getOutputStream(), true);
in = new BufferedReader(new InputStreamReader(
clientSocket.getInputStream()));
isConnected = true;
if (!heartbeat()) {
closeConnection();
isConnected = false;
}
} catch (UnknownHostException e) {
System.err.println("Don't know about host: Project Rainbow.");
try {
clientSocket.close();
} catch (IOException e1) {
System.err.println("Couldn't close clientSocket after UnknownHostException");
e1.printStackTrace();
}
isConnected = false;
} catch (IOException e) {
try {
clientSocket.close();
} catch (IOException e1) {
System.err.println("Couldn't close clientSocket after IOException");
e1.printStackTrace();
}
isConnected = false;
49
Appendix C
TCP.java
System.err.println("Couldn't get I/O for the connection to: Project Rainbow.");
}
try {
if (clientSocket.isClosed()) {
this.isConnected = false;
} else if (!clientSocket.isClosed()) {
this.isConnected = true;
}
} catch (NullPointerException e) {
this.isConnected = false;
System.err.println("NullPointerException in tryToConnect()");
}
return isConnected;
}
/*
* Can be called to check if the socket connection
* is established.
*/
public boolean getIsConnected() {
try {
if (clientSocket.isClosed()) {
this.isConnected = false;
} else if (!clientSocket.isClosed()) {
this.isConnected = true;
}
} catch (NullPointerException e) {
this.isConnected = false;
System.err.println("Exception in getIsConnected()");
}
return this.isConnected;
}
/*
* Sends a "H" to the server and waits for 3 seconds to get a "H"
back. If
* this doesn't happen the connection is lost. Returns true if a "H"
is
* received otherwise false.
*/
public boolean heartbeat() {
boolean hb = false;
String inputLine = "";
try {
clientSocket.setSoTimeout(3000);
out.println("H");
} catch (SocketException e1) {
System.err.println("Couldn't send heartbeat!");
}
try {
while ((inputLine = in.readLine()) != null) {
if (inputLine.equals("H")) {
System.out.println("Heartbeat received");
hb = true;
break;
}
}
50
Appendix C
TCP.java
} catch (IOException e) {
System.out.println("No heartbeat received");
}
return hb;
}
/*
* Is called when the application is going
* to disconnect from the server.
*/
public void sendExitPositions() {
out.println("X");
try {
this.clientSocket.close();
} catch (IOException e) {
System.err.println("Couldn't close clientSocket in sendExitPositions()");
e.printStackTrace();
}
this.isConnected = false;
}
/*
* Closes the socket connection
*/
public void closeConnection() {
try {
clientSocket.close();
} catch (IOException e) {
this.isConnected = false;
System.err.println("NullPointerException in tryToConnect()");
}
}
/*
* Sends the information to the server.
*/
public void sendPositions(double x, double y, int w) {
// Character for the server to let it know steering data is coming
out.println("A");
// The position from the accelerometer in x-direction
out.println(x);
// The position from the accelerometer in y-direction
out.println(y);
// If the water should be turned on w = 1 otherwise w = 0
out.println(w);
}
}
51
Appendix D
TCPServer.java
Appendix D
Serverns källkod.
import
import
import
import
import
import
java.io.BufferedReader;
java.io.IOException;
java.io.InputStreamReader;
java.io.PrintWriter;
java.net.*;
java.util.Calendar;
public class TCPServer2 {
private static InetAddress wiflyAddress;
private static DatagramSocket wiflySocket;
public static void main(String args[]) {
newWiFlyConnection();
newConnection();
}
/*
* Creates an UDP socket which will be used to
* send data to the WiFly on the Arduino board.
*/
public static void newWiFlyConnection() {
try {
wiflySocket = new DatagramSocket();
wiflyAddress = InetAddress.getByName("192.168.0.52");
} catch (UnknownHostException e) {
e.printStackTrace();
} catch (SocketException e1) {
e1.printStackTrace();
}
}
/*
* Sends the incoming bytes to the WiFly.
*/
public static void sendToWiFly(byte x, byte y, byte w) {
byte dataToWiFly[] = new byte[3];
dataToWiFly[0] = x;
dataToWiFly[1] = y;
dataToWiFly[2] = w;
DatagramPacket packetToWiFly = new DatagramPacket(dataToWiFly,
dataToWiFly.length, wiflyAddress, 8888);
try {
wiflySocket.send(packetToWiFly);
} catch (IOException e) {
e.printStackTrace();
}
}
/*
* Listens for and establishes a connection to a client.
* While a client is connected the input stream is read.
* If first incoming character is an "A" the next three lines will be
52
Appendix D
TCPServer.java
* the x-value, y-value and the water value. If the same values has
been
* received 150 times the client will be disconnected due to
inactivity.
* If first incoming character is a "H" will the server send a "H"
back
* to the client, this is the clients heart beat function. If first
* incoming character is a "X" this means the client wants to
disconnect
* and the server closes the connections and streams and starts to
listen
* for a new client.
*/
public static void newConnection() {
ServerSocket serverSocket = null;
int[] oldXY = new int[2];
int oldW = -1, notActive = 0;
int nr = 0;
long startTime = 0;
try {
serverSocket = new ServerSocket(4445);
} catch (IOException e) {
System.out.println("Could not listen on port: 4445");
System.exit(-1);
}
Socket clientSocket = null;
try {
clientSocket = serverSocket.accept();
} catch (IOException e) {
System.out.println("Accept failed: 4445");
System.exit(-1);
}
try {
PrintWriter out = new PrintWriter(clientSocket.getOutputStream(),true);
BufferedReader in = new BufferedReader(new InputStreamReader(
clientSocket.getInputStream()));
String inputLine;
double[] dbinputXY = new double[2];
int[] xy = new int[2];
int inputW = -1;
Calendar cal = Calendar.getInstance();
startTime = cal.getTimeInMillis();
while (clientSocket.isConnected()) {
clientSocket.setSoTimeout(7500);
inputLine = in.readLine();
if (!inputLine.equals("X") && !inputLine.equals("H")) {
System.out.println("Connected !X");
if (inputLine.equals("A")) {
System.out.println("Connected A");
try {
dbinputXY[0] = Double.parseDouble(in.readLine());
dbinputXY[1] = Double.parseDouble(in.readLine());
xy = calculatePositions(dbinputXY);
inputW = Integer.parseInt(in.readLine());
if (xy[0] < 0) {
xy[0] = 0;
53
Appendix D
TCPServer.java
} else if (xy[0] > 180) {
xy[0] = 180;
}
if (xy[1] < 0) {
xy[1] = 0;
} else if (xy[1] > 180) {
xy[1] = 180;
}
nr++;
sendToWiFly((byte) xy[0], (byte) xy[1],(byte) inputW);
} catch (NumberFormatException e) {
e.getStackTrace();
}
if (oldXY[0] == xy[0] && oldXY[1] == xy[1] && oldW == inputW) {
notActive++;
} else {
notActive = 0;
}
if (notActive == 150) {
out.close();
in.close();
clientSocket.close();
serverSocket.close();
newConnection();
}
oldXY[0] = xy[0];
oldXY[1] = xy[1];
oldW = inputW;
}
} else if (inputLine.equals("H")) {
System.out.println("Heartbeat received");
out.println("H");
} else if (inputLine.equals("X")) {
System.out.println("Connected XX");
sendToWiFly((byte) 90, (byte) 90, (byte) 0);
out.close();
in.close();
clientSocket.close();
serverSocket.close();
newConnection();
}
}
System.out.println("Connected X");
sendToWiFly((byte) 90, (byte) 90, (byte) 0);
out.close();
in.close();
clientSocket.close();
serverSocket.close();
newConnection();
} catch (IOException e) {
System.out.println("IOException");
try {
clientSocket.close();
serverSocket.close();
} catch (IOException e1) {
System.out.println("IOException, Couldn't close client- or serversocket.");
}
newConnection();
} catch (NullPointerException e1) {
54
Appendix D
TCPServer.java
System.out.println("NullPointerException");
try {
clientSocket.close();
serverSocket.close();
} catch (IOException e2) {
System.out.println("IOException, Couldn't close client- or serversocket.");
}
newConnection();
}
}
/*
* Calculates the incoming double values with interval (-10)-10
* to the interval in degrees 0-180 instead. Returns as integers.
*/
public static int[] calculatePositions(double[] xy) {
double[] retXY = new double[2];
int[] retInt = new int[2];
retXY[0] = (((xy[0] - -10) * (180 - 0)) / (10 - -10)) + 0;
retInt[0] = (int) Math.round(retXY[0]);
retXY[1] = (((xy[1] - -10) * (180 - 0)) / (10 - -10)) + 0;
retInt[1] = (int) Math.round(retXY[1]);
return retInt;
}
}
55
Appendix E
WiFly_FinalReceive.pde
Appendix E
Kod för arduinon.
/*
* For the Arduino Mega ADK board with a WiFly-shield. Reads
* incoming data from the spi on the WiFly. The incoming
* data controls 4 servos on pin 2, 3, 4, and 5. Pin 22 is
* connected to a chip which controls 2 valves. When pin is high
* the valves are on and when pin is low the valves are turned
* off. The servos are detached when not in use and attached before
* a value are written to them preventing the servos to be on all
* the time.
* Created by: Carl-Philip Olsson & Henrik Andersson
*/
#include "WiFly.h"
#include "Servo.h"
Servo servos[4];
int income[3];
void setup() {
Serial.begin(9600);
SpiSerial.begin();
pinMode(22, OUTPUT);
Serial.println(WiFly.ip());
servos[0].attach(2);
servos[1].attach(3);
servos[2].attach(4);
servos[3].attach(5);
}
void loop(){
if ( SpiSerial.available() > 0) {
servos[0].attach(2);
servos[1].attach(3);
servos[2].attach(4);
servos[3].attach(5);
delay(50);
income[0]=SpiSerial.read();
delay(2);
income[1]=SpiSerial.read();
delay(2);
56
Appendix E
WiFly_FinalReceive.pde
income[2]=SpiSerial.read();
//Test print
Serial.print("x:");
Serial.println(income[0]);
Serial.print(" y:");
Serial.println(income[1]);
Serial.print(" w:");
Serial.println(income[2]);
//End test print
int value = 0;
//Left plate
if(income[0]<=24){
servos[0].write(24);
servos[0].detach();
}
else if(income[0]>=160){
servos[0].write(160);
servos[0].detach();
}
else{
servos[0].write(income[0]);
servos[0].detach();
}
if(income[1]<=33){
servos[1].write(180-33);
servos[1].detach();
}
else if(income[1]>=161){
servos[1].write(180-161);
servos[1].detach();
}
else{
servos[1].write(180-income[1]);
servos[1].detach();
}
//End Left plate
//Right plate
if(income[0]<=33){
servos[2].write(180-33);
servos[2].detach();
}
else if(income[0]>=155){
servos[2].write(180-155);
servos[2].detach();
57
Appendix E
WiFly_FinalReceive.pde
}
else{
servos[2].write(180-income[0]);
servos[2].detach();
}
if(income[1]<=33){
servos[3].write(180-33);
servos[3].detach();
}
else if(income[1]>=157){
servos[3].write(180-157);
servos[3].detach();
}
else{
servos[3].write( 180-income[1]);
servos[3].detach();
}
//End right plate
//Water
if(income[2]==1){
digitalWrite(22, HIGH);
}
else{
digitalWrite(22, LOW);
}
//End water
}
servos[0].detach();
servos[1].detach();
servos[2].detach();
servos[3].detach();
} // End loop
58
Appendix F
Appendix F
Specifikationer för Arduino Mega ADK
Microcontroller
Operating Voltage
Input Voltage (recommended)
Input Voltage (limits)
Digital I/O Pins
Analog Input Pins
DC Current per I/O Pin
DC Current for 3.3V Pin
Flash Memory
SRAM
EEPROM
Clock Speed
ATmega2560
5V
7-12V
6-20V
54 (of which 14 provide PWM output)
16
40 mA
50 mA
256 KB of which 8 KB used by bootloader
8 KB
4 KB
16 MHz
59
Appendix G
Appendix G
Radio egenskaper för RN-131G
Parameter
Frequency
Modulation
Channel intervals
Channels
Transmission rate (over the air)
Receive sensitivity
Output level (Class1)
Maximum RF input to U.FL connector
Specifications
2402 ~ 2480MHz
802.11b compatibility : DSSS(CCK-11, CCK-5.5,
DQPSK-2, DBPSK-1) 802.11g : OFDM (default)
5MHz
1 - 14
1 – 11Mbps for 802.11b / 6 – 54Mbps for
802.11g
-85dBm typ.
+18dBm
10 dBm
Egenskaper för RN-131G
-
Qualified 2.4GHz IEEE 802.11b/g transceiver
High throughput, 1Mbps sustained data rate with TCP/IP and WPA2
Ultra-low power - 4uA sleep, 40mA Rx, 210mA Tx (max)
Small, compact surface mount module
On board ceramic chip antenna and U.FLconnector for external antenna
8 Mbit flash memory and 128 KB RAM
UART hardware interface
10 general purpose digital I/O
8 analog sensor interfaces
Real-time clock for wakeup and time stamping
Accepts 3.3V regulated or 2-3V battery
Supports Adhoc connections
On board ECOS -OS, TCP/IP stacks
Wi-Fi Alliance certified for WPA2-PSK
FCC / CE/ ICS certified and RoHS compliant.
60
Appendix H
Appendix H
Ritning för att skära ut lock och botten till bågen i laserskäraren.
61
Appendix I
Appendix I
Användarbeskrivning för androidapplikationen.
1. Se till att din enhet har en internetuppkoppling.
2. Gå in på Google Play och sök efter ”Project Rainbow” eller använd QR-taggen nedan.
3. Välj applikationen, utvecklad av HACO, med ikonen nedan.
4. Klicka på installera.
5. Starta applikationen och klicka på ”Connect”.
6. Klicka på knappen ”Controlling” för att aktivera styrningen och vinkla enheten för att styra
plattorna.
7. Sätt igång vattenflödet genom att klicka på knappen ”Water”.
8. Du kan när som helst koppla ifrån konstverket genom att trycka på ”Connected” eller stänga
ner applikationen.
62