Implementation of mesh communication between a server and small autonomous mobile robots
Master thesis
Permanent lenke
https://hdl.handle.net/11250/2991120Utgivelsesdato
2021Metadata
Vis full innførselSamlinger
Beskrivelse
Full text not available
Sammendrag
Denne oppgaven har fortsatt arbeidet utført av Halvorsen 2021 på en robot basert på ArduinoMega som omhandlet å kartlegge et ukjent område. Oppgaven har også fortsatt arbeidet gjortav Blom 2020 og Grønvold 2021 som omhandler hvordan robotene kan nyttiggjøre seg av trådløsmeshnettverk ved å bruke et nettverk basert på OpenThread.
Denne oppgaven har fortsatt arbeidet utført av Halvorsen 2021 på en Arduino robot for å kartleggeet ukjent område. Oppgaven har også fortsatt arbeidet gjort av Blom 2020 og Grønvold 2021som omhandler hvordan robotene i prosjektet kan bli ytterligere forbedret for å oppnå bedrekommunikasjon ved å nyttiggjøre seg av et trådløst meshnettverk.
For å muliggjøre kommunikasjon mellom arduinoroboten og OpenThread nettverket, ble en nRF52koblet til roboten. En nRF52 ble også koblet til en datamaskin som kjørte en server skrevet iJava. Java ble valgt for å ha mest mulig kompatibilitet med javaserveren som tidligere har blittlaget av Blom 2020. Serveren i denne oppgaven er skrevet i Java og omtales som Mini-server.Grunnen til dette er at den har minimalt med funksjonalitet og ikke er i stand til å håndtere alletyper meldinger som roboten kan sende. For å unngå å øke kodebasen ytterligere, kjører beggenRF52 mikrokontrollerne OpenThread CLI. Kommandolinjegrensesnittet (CLI) kan bli kontrollertved hjelp av en universell asynkron sender mottaker (UART) eller via seriell kommunikasjon overUSB
For å sørge for best mulige forhold for kommunikasjon ble en spenningsomformer plassert mellomnRF52-en og Arduinoen. nRF52-en opererer med 3.3 volt i motsetning til Arduinoen som operererpå 5 volt. Videre ble det eksisterende biblioteket for kommunikasjon ved hjelp av UART omstrukturert. Det nye biblioteket nyttiggjorde seg av mikrokontrollerens mulighet for avbrudd, både forsending og mottagelse av data. UART biblioteket var også laget fritt for avhengigheter. Biblioteket ble deretter pakket inn for å kunne brukes i kombinasjon med sanntidssystemet FreeRTOS.Denne pakken innehold to køer, én for sending og én for mottakelse. Innpakningen besørget ogsåtrådsikkerhet for å eliminere problemer med tanke på samtidighet. Det eneste kravet for å kunnebruke denne innpakningen, var at alle meldinger sluttet med tegnet for en ny linje. Dette kravetvar automatisk oppfylt av OpenThread CLI.
For å styre nRF52 brikken ble det laget en ny FreeRTOS oppgave på Arduinoen. Denne oppgavenopererte som en egen tråd. Hensikten med denne tråden var først å initialisere kommandolinjegrensesnitt, deretter var oppgaven å lytte etter meldinger som skulle mottas. De mottatte meldingene ble satt inn i den samme meldingsstrukturen som ble brukt når kommunikasjon over Blåtannvar valgt. For å sende en melding ble innholdet til meldingsstrukturen pakket, byte for byte.Deretter ble dette sent til Mini-serveren som kjørte på en datamaskin. Dette ble gjort ved hjelpav kommandolinjegrensesnitt til OpenThread CLI. Mini-serveren utførte de samme trinnene for åsende en melding til Arduinoen. Når serveren mottok en melding, ble den pakket ut. Mini-serverenvar også i stand til å pakke og sende en ny melding som inneholdt ordreinformasjon om hvor roboten skulle bevege seg. Som et resultat av at Mini-serveren er skrevet i Java, burde det væremulig å slå den sammen med serveren laget av Blom 2020. Dette kan føre til at alle funksjonenetil serveren kan bli sendt ved hjelp av OpenThread nettverket.
I OpenThread CLI er det noen tegn som er reservert til å styre kommandolinjegrensesnittet. Eteksempel på dette er tegnet for linjeskift. For å forsikre seg om at ingen av de reservert tegneneble benyttet inni en melding, ble det utviklet et system for konvertering. Systemet konverterte enog en byte som følgelig inneholdt et nummer mellom 0 og 255 til et heksadesimalt nummer. Somet resultat av dette ble alle nummer mellom 0 og 255 til ett nummer med to siffer mellom 0 og 15.Disse to tallene ble så individuelt addert med 48. Resultatet av dette var at alle numrene mellom0 og 255 ble konvertert til to nummer mellom 48 og 63. Disse numrene ble så sendt individueltsom to separate bytes over OpenThread nettverket. Denne konverteringen førte til at innholdet ialle meldinger som ble sendt mellom roboten og serveren doblet seg i størrelse.
Teknikken for å sende meldinger fungerte. OpenThread CLI var i stand til å initialisere seg selv påMini-serveren og Arduino roboten. Etter dette kunne Mini-serveren sende meldinger om hvor Arduino roboten skulle kjøre. Meldingene ble lest korrekt inn i meldingsstrukturen for nye meldinger. Roboten var også i stand til å sende meldinger over nettverket til Mini-serveren. Uheldigvis var ikke roboten i stand til å kjøre skikkelig. Dette hadde sannsynligvis sammenheng med posisjonskontrolleren. Når roboten ble plassert på en kloss og hjulene roterte fritt, virket den tilsynelatende som den skulle.
På tross av mange hindringer i arbeidet med denne oppgaven så kan roboten sende noen typermeldinger på nettverket. Kompleksiteten til systemet har sunket vesentlig i forhold til Grønvold2021. Både serveren og roboten bruker den samme ferdiglagde programvaren til nRF52 brikken.Ved å gjøre dette unngås det en større kodebase som må vedlikeholdes. Det er heller ikke lengernødvendig å benytte seg av en broruter (Boarder Router) eller en MQTT-tjener. Ved å gjøredette er også behovet og kompleksiteten ved å ha et vanlig nettverk (LAN) i tillegg til OpenThread nettverket fjernet. Ulempen med dette var naturligvis at mer logikk måtte flyttes tilArduino roboten og Mini-serveren. Ved å komme tettere på OpenThread nettverket, er den førstebyggesteinen for direkte kommunikasjon mellom robotene blitt lagt. This thesis has continued the work done by Halvorsen 2021 on a robot to map an unknownenvironment based on an Arduino robot. The thesis has continued the work by Blom 2020 andGrønvold 2021 and explored how the robots in the project can be further improved to achievebetter communication by utilizing wireless mesh communication.
To enable the Arduino robot to communicate, the OpenThread network was used. This wan doneby adding a nRF52 to the robot. A nRF52 was also added to a computer running a server createdin Java. Java was chosen to maximize compatibility with the java server, originally created byBlom 2020. The Java server used in this thesis is called Mini-server, because it only handles aminimal subset of all functionality provided by the robot. To avoid increasing the codebase of theproject further, both the nRF52 in the robot and in the computer used the OpenThread CommandLine Interface (CLI). The Command Line Interface running on the nRF52 can be controlled by anuniversal asynchronous receiver-transmitter (UART) and serial communication through USB.
To ensure optimal conditions for communication, a logic level converter was added between thenRF52 and the Arduino Mega. The nRF52 was running at 3.3v and the Arduino Mega was runningat 5v. Furthermore, the existing library for UART communication was refactored. The new libraryutilised both interrupt-driven sending and receiving. The UART library was also created to becompletely free for dependencies. Around this library it was created a wrapper to be used withFreeRTOS. This wrapper contained two queues, one for receiving and one for sending. This wrapperalso ensured thread safety when sending and receiving the content. The only requirement for usingthis is that each message received needs to end with a New Line character. This requirement wasautomatically fulfilled by the OpenThread CLI.
For controlling the nRF52 a new FreeRTOS task was created on the Arduino. This tasks wasoperating as a separate thread. The purpose of this thread was to initialize the OpenThread CLIand then listen for incoming messages. The incoming messages were then injected into the samemessage structure as used by Bluetooth. To send a message, the content of the message structwas packed byte by byte and sent through the OpenThread CLI to the Mini-server running onthe computer. The Mini server was doing the same task regarding messages as the Arduino robot.When the server was receiving a message, it unpacked it. The Mini-server was also able to packand send new messages which contained an order of where to go next for the robot. Since the Miniserver is written in Java, it should be possible to merge it with the Java-server created by Blom2020, and hence obtain all the features provided by this server to be sent over the OpenThreadnetwork.
In the OpenThread CLI some characters are reserved for controlling the CLI itself. One exampleof this is the character for newline. To ensure that any reserved character was not used in thecontent of the message, a converting scheme was created. This scheme converted each byte whichcontained a number between 0 and 255 to a hexadecimal number. This means that any numberbetween 0 and 255 now was two numbers between 0 and 15 instead. These two numbers were thenadded individually with 48. As a result of this each number between 0 and 255 was now convertedto two numbers between 48 and 63. The two numbers were then sent as two individually bytes overthe OpenThread network. This technique doubled the size of each message that was sent betweenthe robot and the Mini-server.
The method for sending messages was working. The OpenThread CLI was able to initialize itselfon Mini-server running on the computer and the Arduino robot. The Mini-server was then ableto send new orders describing where the robot should desire to move. The message was correctlyinserted into the message-structure for new messages. The robot was also able to send messageswith information over the network to the Mini-server. Unfortunately, the Arduino robot was notlonger able to move properly caused by something wrong with the position controller. However,when the robot was put om a stand, it seemed to behave as it should.
Despite many obstacles during the work with this thesis, the robot can now send some messagesthrough the OpenThread network. In contrast to the work of Grønvold 2021, the complexity ofthe system is now reduced considerably. Both the server and the robot uses the same pre created software running on the nRF52. This avoided the need for a larger software stack and reducedthe codebase to maintain. The OpenThread Boarder Router and the MQTT-server have alsobeen omitted. This removes the complexity involved having to obtain a LAN network as wellas the OpenThread network itself. The cost of this was naturally that more logic needed to beimplemented in the Arduino robot and the Mini-server itself. With closer access to the OpenThreadnetwork, the foundation to send messages directly between robots have been created.