Implementation of mesh communication between a server and small autonomous mobile robots

Abstract

Denne oppgaven har fortsatt arbeidet utført av Halvorsen 2021 på en robot basert på Arduino Mega som omhandlet å kartlegge et ukjent område. Oppgaven har også fortsatt arbeidet gjort av Blom 2020 og Grønvold 2021 som omhandler hvordan robotene kan nyttiggjøre seg av trådløs meshnettverk ved å bruke et nettverk basert på OpenThread.

Denne oppgaven har fortsatt arbeidet utført av Halvorsen 2021 på en Arduino robot for å kartlegge et ukjent område. Oppgaven har også fortsatt arbeidet gjort av Blom 2020 og Grønvold 2021 som omhandler hvordan robotene i prosjektet kan bli ytterligere forbedret for å oppnå bedre kommunikasjon ved å nyttiggjøre seg av et trådløst meshnettverk.

For å muliggjøre kommunikasjon mellom arduinoroboten og OpenThread nettverket, ble en nRF52 koblet til roboten. En nRF52 ble også koblet til en datamaskin som kjørte en server skrevet i Java. Java ble valgt for å ha mest mulig kompatibilitet med javaserveren som tidligere har blitt laget 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 alle typer meldinger som roboten kan sende. For å unngå å øke kodebasen ytterligere, kjører begge nRF52 mikrokontrollerne OpenThread CLI. Kommandolinjegrensesnittet (CLI) kan bli kontrollert ved hjelp av en universell asynkron sender mottaker (UART) eller via seriell kommunikasjon over USB

For å sørge for best mulige forhold for kommunikasjon ble en spenningsomformer plassert mellom nRF52-en og Arduinoen. nRF52-en opererer med 3.3 volt i motsetning til Arduinoen som opererer på 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 for sending 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 å kunne bruke denne innpakningen, var at alle meldinger sluttet med tegnet for en ny linje. Dette kravet var automatisk oppfylt av OpenThread CLI.

For å styre nRF52 brikken ble det laget en ny FreeRTOS oppgave på Arduinoen. Denne oppgaven opererte 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åtann var 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 hjelp av 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-serveren var 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ære mulig å slå den sammen med serveren laget av Blom 2020. Dette kan føre til at alle funksjonene til serveren kan bli sendt ved hjelp av OpenThread nettverket.

I OpenThread CLI er det noen tegn som er reservert til å styre kommandolinjegrensesnittet. Et eksempel på dette er tegnet for linjeskift. For å forsikre seg om at ingen av de reservert tegnene ble benyttet inni en melding, ble det utviklet et system for konvertering. Systemet konverterte en og en byte som følgelig inneholdt et nummer mellom 0 og 255 til et heksadesimalt nummer. Som et 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 mellom 0 og 255 ble konvertert til to nummer mellom 48 og 63. Disse numrene ble så sendt individuelt som to separate bytes over OpenThread nettverket. Denne konverteringen førte til at innholdet i alle 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 typer meldinger på nettverket. Kompleksiteten til systemet har sunket vesentlig i forhold til Grønvold 2021. 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 lenger nødvendig å benytte seg av en broruter (Boarder Router) eller en MQTT-tjener. Ved å gjøre dette 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 til Arduino roboten og Mini-serveren. Ved å komme tettere på OpenThread nettverket, er den første byggesteinen for direkte kommunikasjon mellom robotene blitt lagt.

This thesis has continued the work done by Halvorsen 2021 on a robot to map an unknown environment based on an Arduino robot. The thesis has continued the work by Blom 2020 and Grønvold 2021 and explored how the robots in the project can be further improved to achieve better communication by utilizing wireless mesh communication.

To enable the Arduino robot to communicate, the OpenThread network was used. This wan done by adding a nRF52 to the robot. A nRF52 was also added to a computer running a server created in Java. Java was chosen to maximize compatibility with the java server, originally created by Blom 2020. The Java server used in this thesis is called Mini-server, because it only handles a minimal subset of all functionality provided by the robot. To avoid increasing the codebase of the project further, both the nRF52 in the robot and in the computer used the OpenThread Command Line Interface (CLI). The Command Line Interface running on the nRF52 can be controlled by an universal asynchronous receiver-transmitter (UART) and serial communication through USB.

To ensure optimal conditions for communication, a logic level converter was added between the nRF52 and the Arduino Mega. The nRF52 was running at 3.3v and the Arduino Mega was running at 5v. Furthermore, the existing library for UART communication was refactored. The new library utilised both interrupt-driven sending and receiving. The UART library was also created to be completely free for dependencies. Around this library it was created a wrapper to be used with FreeRTOS. This wrapper contained two queues, one for receiving and one for sending. This wrapper also ensured thread safety when sending and receiving the content. The only requirement for using this is that each message received needs to end with a New Line character. This requirement was automatically fulfilled by the OpenThread CLI.

For controlling the nRF52 a new FreeRTOS task was created on the Arduino. This tasks was operating as a separate thread. The purpose of this thread was to initialize the OpenThread CLI and then listen for incoming messages. The incoming messages were then injected into the same message structure as used by Bluetooth. To send a message, the content of the message struct was packed byte by byte and sent through the OpenThread CLI to the Mini-server running on the 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 pack and 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 Blom 2020, and hence obtain all the features provided by this server to be sent over the OpenThread network.

In the OpenThread CLI some characters are reserved for controlling the CLI itself. One example of this is the character for newline. To ensure that any reserved character was not used in the content of the message, a converting scheme was created. This scheme converted each byte which contained a number between 0 and 255 to a hexadecimal number. This means that any number between 0 and 255 now was two numbers between 0 and 15 instead. These two numbers were then added individually with 48. As a result of this each number between 0 and 255 was now converted to two numbers between 48 and 63. The two numbers were then sent as two individually bytes over the OpenThread network. This technique doubled the size of each message that was sent between the robot and the Mini-server.

The method for sending messages was working. The OpenThread CLI was able to initialize itself on Mini-server running on the computer and the Arduino robot. The Mini-server was then able to send new orders describing where the robot should desire to move. The message was correctly inserted into the message-structure for new messages. The robot was also able to send messages with information over the network to the Mini-server. Unfortunately, the Arduino robot was not longer 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 messages through the OpenThread network. In contrast to the work of Grønvold 2021, the complexity of the 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 reduced the codebase to maintain. The OpenThread Boarder Router and the MQTT-server have also been omitted. This removes the complexity involved having to obtain a LAN network as well as the OpenThread network itself. The cost of this was naturally that more logic needed to be implemented in the Arduino robot and the Mini-server itself. With closer access to the OpenThread network, the foundation to send messages directly between robots have been created.