Bouwen van een licht-etende robot

Iedereen droomt ervan om zijn eigen robot te bouwen. Dankzij het Dwengo-bord, wat Lego™ en deze tutorial wordt het bouwen van een robot een koud kunstje. Stap voor stap leren we je aan hoe je een robot kan bouwen die in staat is om autonoom naar het licht toe te rijden. Met behulp van deze tutorial, wat uitleg over verschillende sensoren en je eigen fantasie kan je in de toekomst je robot uitbreiden tot een lijnvolger of zelfs een geavanceerde sumorobot.

Benodigdheden

1. Een Dwengo-bord
2. Een Dwengo-programmer
3. De bijhorende kabels
4. Eventueel een Dwengo-breadbord om snel een aantal zaken te testen
5. Wat Lego™ om je robot te bouwen
6. Twee fototransistors en bijhorende weerstanden
7. Twee Lego™ motoren

Aansturen van DC-motoren met PWM

In de tutorial over interrupts heb je reeds geleerd hoe je een PWM-signaal kan genereren. We hebben hierbij ook kort vermeld dat je PWM-signalen ook kan gebruiken om de ingangsspanning van bijvoorbeeld motoren te regelen. Alle apparaten die werken op gelijkspanning, ook wel DC-spanning genoemd, vereisen een constante ingang. Hieronder vallen heel wat elektronische componenten zoals bijvoorbeeld Lego™ motoren en LEDs. De spanning van deze componenten ligt hierbij typisch in een bepaald bereik maar mag kan vaak verlaagd worden. In het geval van LEDs resulteert een lagere spanning in minder licht en door de ingangsspanning te regelen over een motor kan het toerental geregeld worden. De motor zal dan trager beginnen draaien.
Wanneer een PWM-signaal met erg hoge frequentie gegenereerd wordt dan lijkt het voor de motor alsof ze een constante ingangsspanning krijgen. Door de pulsbreedte of duty cycle van het PWM-signaal te regelen kan de amplitude van de gemiddelde spanning verhoogt of verlaagt worden. Overeenkomstig zal de motor dus sneller of trager draaien. Dit is geïllustreerd op de figuur. Hetzelfde concept kan ook gebruikt worden voor bijvoorbeeld LEDs te dimmen.

Indien we het Dwengo-bord nader bekijken zien we dat er connector voorzien is voor twee motoren op aan te sluiten. Zoals op de figuur te zien is werd dit aangeduid met M1 en M2.

Het schema van het Dwengo-bord leert ons dat de motor-pinnen M1 en M2 aangesloten zijn op de motordriver. Dit is een component die de signalen afkomstig van de microcontroller zal omzetten naar signalen waarmee motoren kunnen aangestuurd worden. Immers, motoren vragen immers grote stromen die niet standaard door een microcontroller geleverd kunnen worden. Bovendien kan de amplitude van het PWM-signaal (5 Volt of ingangsspanning van het Dwengo-bord) geregeld worden met jumper 2. De motordriver zal ervoor zorgen dat deze spanning doorgegeven wordt aan de motoren.
De motordriver is op zijn beurt ook verbonden met de microcontroller. Dit op de pinnen van de ingebouwde PWM-modules CCP1 en CCP2. Het zijn de PWM-modules die we correct moeten aansturen willen we de motoren laten draaien zoals we wensen.

Een licht-etende robot

Wanneer je alle tutorials doorlopen hebt zal de code die we schrijven erg gemakkelijk te volgen zijn. Immers vele zaken, zoals het gebruik van het LCD-scherm en het uit meten van een lichtsensor, zijn in de vorige tutorials aan bod gekomen. We gaan de zaken die we herhalen niet in detail uitleggen. Mocht je hierover iets niet goed begrijpen, aarzel dan niet om terug te grijpen naar de desbetreffende tutorials. Het gebruik van de PWM-module en het bouwen van de robot worden wel in detail uitgelegd.

We laden eerst de nodige bibliotheken in. Nieuw is hierbij het inladen van de bibliotheek dwengoMotor die nodig is om de motoren van aan te sturen met behulp van de ingebouwde PWM-module.

#include <dwengoBoard.h>
#include <dwengoConfig.h>
#include <dwengoADC.h>
#include <dwengoMotor.h>
#include <dwengoDelay.h>

Eveneens definiëren we een aantal macro's die onze code leesbaarder zullen maken.

#define THRESHOLD 30 // defines light sensitivity
#define MAX_SPEED 1023 // maximal speed setting
#define MIN_SPEED 600 // minimal speed setting

Vervolgens starten we de hoofdlus van ons programma. We maken onmiddellijk twee rijen aan van telkens twee integers waarin we de waarden afkomstig van de twee lichtsensoren zullen in opslaan. We zullen telkens de huidige en de oude waarde opslaan wat ons de mogelijkheid biedt om wat ruis weg te filteren zoals we in de tutorial over de lichtvolger deden.

void main(void) {
  int lightSensors[2];
  int previousLightSensors[2];

We initialiseren de functionaliteit van het Dwengo-bord. Het oproepen van deze functies zorgt ervoor dat alle pinnen op de juiste manier ingesteld worden. Zo zal de functie initMotor() ervoor zorgen dat de motor-pinnen M1 en M2 als digitale uitgang worden geconfigureerd en dat de PWM-module op een correcte manier wordt ingesteld. Wens je gedetailleerdere informatie te lezen over wat er allemaal op de achtergrond gebeurt, lees dan dan de handige tips hierover.

  // initializations
  initBoard();
  initADC();
  initMotor();
  backlightOn();

Eveneens geven we aan de variabelen waarin we de hoeveelheid licht opslaan een beginwaarde mee.

  lightSensors[0] = 500;
  lightSensors[1] = 500;

Nu de ADC-module en het LCD-scherm geïnitialiseerd zijn en de PWM-modules met bijhorende timer2 geconfigureerd zijn, kunnen we overgaan tot het programmeren van de intelligentie van onze robot. Zoals in de tutorial over de lichtvolger zetten we de backlight van het LCD-scherm aan en initialiseren we de variabelen lightSensors met zinnige waarden.

  LCDBacklightOn();
 
  lightSensors[0] = 500;
  lightSensors[1] = 500;

De intelligentie van onze licht-etende-robot bestaat uit een oneindige lus waarin achtereenvolgens de sensoren worden uitgelezen en gefilterd, met elkaar worden vergeleken en overeenkomstig de snelheden van de twee motoren worden ingesteld. Hierbij moet de linker motor sneller draaien dan de rechter motor wanneer er rechts meer licht is dan links en visa verse.

We starten met het programmeren van de oneindige lus, het bewaren van de oude sensor-waarden, het uitlezen van de sensor-waarden, het tonen van deze sensor-waarden op het LCD-scherm en het filteren van deze sensor-waarden.

  while(TRUE) {
    // set previous sensor data
    previousLightSensors[0] = lightSensors[0];
    previousLightSensors[1] = lightSensors[1];
 
    // read lightsensors
    lightSensors[0] = readADC(0);
    lightSensors[1] = readADC(1);
 
    // show sensor data
    clearLCD();
    printStringToLCD("Right: ", 0, 0);
    appendIntToLCD(lightSensors[0]);
    printStringToLCD("Left: ", 1, 0);
    appendIntToLCD(lightSensors[1]);
 
    // filtering
    lightSensors[0] = (lightSensors[0] + previousLightSensors[0])/2;
    lightSensors[1] = (lightSensors[1] + previousLightSensors[1])/2;

Vervolgens vergelijken we de gefilterde waarden afkomstig van de licht-sensoren. De sensoren werken zodanig dat hoe meer licht de sensor ontvangt, hoe kleiner de uitgelezen waarde zal zijn. Wanneer de rechter sensor-waarde (opgeslagen in lightSensor[1]) groter is dan de linker sensor-waarde (lightSensors[0]), dan ontvangt de linker-sensor meer licht en moet het rechter wiel dus sneller draaien dan het linker wiel zodat de robot naar links zal draaien. Net zoals in de tutorial over de licht-volger werken we hierbij met een bepaalde drempel-waarde waarmee de gevoeligheid voor het licht kan ingesteld worden. Hierbij moeten de twee wielen van de robot met gelijke snelheid draaien wanneer beide sensoren ongeveer evenveel licht ontvangen.
De snelheid van de motoren kan geregeld worden door de pulsbreedte van het PWM-signaal in te stellen. Het instellen van de pulsbreedte gebeurt met de functie setSpeedMotor1 voor de eerste PWM-module (motor 1) en de functie setSpeedMotor2 voor de tweede PWM-module (motor 2). Aan deze functies moet men een getal meegeven tussen 0 (pulsbreedte gelijk aan nul en dus geen puls) en 1023 (pulsbreedte zo breed als PWM-periode en dus motor op volle kracht) waarmee de pulsbreedte wordt bepaald. Je kan ook een negatieve waarde meegeven om de motoren in omgekeerde zin te laten draaien. De correcte interpretatie van links en rechts draaien zal afhangen van hou jij de motoren aangesloten hebt op connector M1 en M2. Niettemin kan je dit steeds softwarematig corrigeren.

    // set motor speed
    if((lightSensors[1]-lightSensors[0]) > THRESHOLD) { // turn left
      setSpeedMotor1(-MIN_SPEED);
      setSpeedMotor2(MAX_SPEED);
    } else if((lightSensors[0]-lightSensors[1]) > THRESHOLD) { // turn right
      setSpeedMotor1(-MAX_SPEED);
      setSpeedMotor2(MIN_SPEED);
    } else { // drive straight
      setSpeedMotor1(-MAX_SPEED); // - or + depends on how motors are connected to the board
      setSpeedMotor2(MAX_SPEED);
    }

Terwijl de motoren op de juiste snelheid draaien wachten we even alvorens de while-lus opnieuw te beginnen.

    // wait a bit
    delay_ms(250);
  }
}

Bouwen van je robot

Het bouwen van een robot kan je heel snel en gemakkelijk doen met wat Lego™ die je thuis liggen hebt. Naast een aantal Lego™ technic of Lego™ mindstorms blokjes zijn volgende twee zaken noodzakelijk:

1. Twee DC-motoren: bijvoorbeeld twee Power Functions XL-Motoren
2. Een batterij-houder met een uitgangsspanning van 9 V à 15 V die kan aansluiten op het Dwengo-bord

Mocht je niet voldoende blokjes hebben om je robot te bouwen dan kan je steeds losse Lego-blokken bestellen via BrickLink .
Tot slot geven we ook nog een handig stappenplan voor het bouwen van een basisrobot in Lego™.

Aansluiten hardware

Als je niet goed weet hoe de lichtsensoren moet aansluiten dan lees je best de tutorials over het meten van licht en het volgen van licht nog eens door.

Het aansluiten van de Lego-motoren doe je als volgt:

1. Knip de connector van de Lego-motoren, zorg dat je een lang stuk connector overhoudt.
2. Maak de vier kabeltjes van de connector los van elkaar.
3. Knip de buitenste twee kabels wat weg.
4. Strip de binnenste twee kabels met een striptang.
5. Doorloop stappen 1-4 voor de tweede Lego-motor
6. Bevestig de 4 gestripte kabels van de twee motoren aan een connector die je in de motor-connector van het Dwengo-bord kan plaatsen. Hierbij komen de kabels van de ene motor vlak naast elkaar in de twee pinnen aangeduid met "M1" op het Dwengo-bord. De twee kabels van de andere motor plaats je vlak naast elkaar in de twee pinnen aangeduid met "M2".

Wanneer je het geheel wat proper afwerkt krijg je een robot zoals op de volgende foto. Aan deze robot werd eveneens reeds een grondsensor toegevoegd.

Uitbreiden tot een lijnvolger

Wanneer je het starterspakket+ bezit dan heb je eveneens een aantal grondsensoren ter beschikking. Knutsel deze sensoren met behulp van de uitleg op de sensoren pagina ineen en sluit deze aan op pin AN2 en AN3 van de uitbreidingsconnector op het Dwengo-bord. Plaats de grondsensoren op je robot en richt ze naar de grond. Pas vervolgens de code van je robot aan zodat deze bijvoorbeeld niet van tafel rijdt.
Een andere mogelijkheid is de grondsensor te gebruiken om een lijn te volgen die je op de grond tekent. Of door ze weg van de robot te plaatsen kunnen ze ook gebruikt worden als eenvoudige afstandssensor. Je robot zal in staat zijn objecten te ontwijken. Wil je je robot ook veraf objecten laten zien, lees dan helemaal de sensoren pagina door! Veel plezier!