IR-reflectiesensorarray

Wat het is

Een IR-reflectiesensorarray is een rij kleine infraroodsensoren die op de grond zijn gericht. Elke sensor combineert een infrarood-LED die naar beneden schijnt met een fototransistor die meet hoeveel van dat licht terugkaatst. Richt hem op een donkere lijn op een lichte vloer, dan reflecteert de lijn minder en leest de sensor boven de lijn anders dan die boven de vloer. Lees de hele rij en je weet niet alleen of je op de lijn zit, maar ook waar de lijn onder de robot ligt.

Het is het oog van vrijwel elke lijnvolgerrobot en de reden dat de lijnvolger zo’n goed eerste project is: de detectie is betaalbaar, intuïtief en meteen zichtbaar.

Hoe het werkt

Elk kanaal is een paar zender-detector. De IR-LED zendt onzichtbaar licht uit van ~940 nm; hoe meer teruggekaat licht de fototransistor ontvangt, hoe beter hij geleidt. Een wit of licht oppervlak reflecteert veel licht, dus het teruggekaat licht is sterk; een zwarte lijn absorbeert het IR, dus het teruggekaat licht is zwak. Er zijn twee uitvoeringen:

• Analoog — elk kanaal meldt een doorlopende waarde die evenredig is met de reflectie. Dit biedt meer informatie: je kunt berekenen waar tussen twee sensoren de lijn ligt en zo een vloeiend foutsignaal krijgen voor een PID-regelaar.
• Digitaal — een comparator op het bord meldt per kanaal eenvoudig lijn of geen lijn. Makkelijker te lezen, maar grover.

Om van de array een besturingssignaal te maken, bereken je een gewogen gemiddelde van de sensoren die de lijn zien. Drijft de lijn onder de sensoren links, dan verschuift het gemiddelde naar links en wordt die afwijking de regelfout die je regellus corrigeert.

Wanneer je hem gebruikt

Gebruik een reflectiearray zodra een robot een contrastrijk pad moet volgen, bijvoorbeeld een zwarte lijn op wit of witte tape op een donkere vloer. Meer kanalen geven een fijnere positieresolutie en maken bochten en onderbrekingen soepeler; vijf kanalen volstaan om mee te leren, acht zijn comfortabel voor snellere of kronkeligere banen.

Het is het verkeerde gereedschap voor objectdetectie, afstand of alles buiten het vlak van de vloer. Dat is de taak van een ultrasone of looptijdsensor.

Kalibratie en valkuilen

• Kalibreer altijd. Omgevingslicht, oppervlak en hoogte veranderen de metingen. Beweeg de array vóór een rit over zowel de lijn als de vloer, leg per kanaal de min/max vast en schaal de metingen daartussen. Dit overslaan is de belangrijkste reden dat een lijnvolger op de ene tafel werkt en op de andere niet.
• Hoogte is belangrijk. Reflectiesensoren hebben een smal optimaal bereik van enkele millimeters. Monteer de array te hoog en het contrast valt weg.
• Omgevings-IR is ruis. Zonlicht en sommige verlichting vullen de detectoren met infrarood. Scherm de sensoren af of gebruik binnen voor consistent gedrag en filter het signaal; zie sensorruis beheersen.
• De afwerking van een oppervlak kan misleiden. Glanzend zwart kan onder de verkeerde hoek als wit reflecteren; matte tape op een matte vloer is de betrouwbare combinatie.

Aansluiten op een Arduino

Een analoge array heeft per kanaal één ADC-pin nodig. Een 8-kanaals array en een Uno met zes analoge pinnen vormen dus geen handige combinatie; de acht pinnen van een Nano, A0–A7, passen precies.

De LEDON-pin is de moeite waard om aan te sluiten, ook al negeren de meeste projecten hem. De zenders van een 8-kanaals array kunnen samen continu 100–200 mA vragen, een aanzienlijk deel van het budget op een kleine accu. De pin maakt bovendien de hieronder beschreven aftrek van het omgevingslicht mogelijk.

Kalibratie: de code die bepaalt of het werkt

Dit is niet optioneel en ook geen verfijning. Een niet-gekalibreerde array is de belangrijkste reden dat een lijnvolger op de keukentafel werkt en op een wedstrijd niet.

const int N = 8;
const int PIN[N] = {A0, A1, A2, A3, A4, A5, A6, A7};
int lo[N], hi[N];

void calibrate() {
  for (int i = 0; i < N; i++) { lo[i] = 1023; hi[i] = 0; }

  // Sweep the array across the line and the floor for ~3 seconds.
  unsigned long start = millis();
  while (millis() - start < 3000) {
    for (int i = 0; i < N; i++) {
      int v = analogRead(PIN[i]);
      if (v < lo[i]) lo[i] = v;
      if (v > hi[i]) hi[i] = v;
    }
  }
}

// 0 = floor, 1000 = line, per channel, normalised against this run's own extremes.
int normalised(int i) {
  int span = hi[i] - lo[i];
  if (span < 50) return 0;                       // this channel never saw contrast
  return constrain(map(analogRead(PIN[i]), lo[i], hi[i], 0, 1000), 0, 1000);
}

Let op de veiligheidscontrole span < 50 in de code. Een kanaal dat tijdens de kalibratie geen contrast zag, omdat de beweging het miste of omdat de zender defect is, zou anders enorme genormaliseerde waarden uit kleine ruiswaarden maken en de robot naar een sensor sturen die niets te melden heeft.

Van acht metingen naar één besturingswaarde

Het gewogen gemiddelde is de hele truc en levert een doorlopende positie op in plaats van een discrete melding “sensor 3 ziet hem”:

// Returns position in the same units as the weights: 0..7000 for an 8-channel array,
// or -1 if the line is not visible at all.
long linePosition() {
  long weighted = 0, total = 0;
  for (int i = 0; i < N; i++) {
    int v = normalised(i);
    if (v > 100) {                    // ignore channels that are clearly on floor
      weighted += (long)v * i * 1000;
      total    += v;
    }
  }
  if (total == 0) return -1;          // line lost
  return weighted / total;
}

// Error for the control loop: 0 when centred.
long error() {
  long pos = linePosition();
  if (pos < 0) return LAST_ERROR;     // hold the last known direction, do not zero it
  return pos - 3500;                  // centre of an 8-channel array
}

Twee ontwerpkeuzes zijn belangrijker dan de rekensom:

Kanalen onder een drempel negeren voorkomt dat vloerruis het gemiddelde meesleurt. Zonder die uitsluiting trekken acht kanalen die elk een kleine niet-nulwaarde lezen de schatting onafhankelijk van de werkelijke lijnpositie naar het midden.

De laatste regelfout onthouden wanneer de lijn verdwijnt, in plaats van nul terug te geven, laat een robot herstellen na een scherpe hoek. Betekent nul “perfect gecentreerd”, dan rijdt een robot die bij verlies van de lijn op nul zet voluit rechtstreeks weg van de lijn die hij zojuist kwijtraakte. Door de laatste fout te onthouden, blijft de robot dezelfde draairichting houden als waarin de lijn verdween.

Montagehoogte en waarom die alles bepaalt

Reflectiesensoren hebben een smal optimaal bereik. Het signaal neemt in beide richtingen snel af: te hoog is het teruggekaat licht zwak en te laag heeft de kegel van de zender zich nog niet ver genoeg verspreid om het gebied dat de detector ziet te verlichten.

Twee praktische gevolgen. Monteer de array stijf: een array op een buigzame beugel verandert hoogte terwijl de robot versnelt, waardoor de metingen veranderen en de regellus dat interpreteert als een bewegende lijn. En monteer hem waterpas, want bij een gekantelde array heeft elk kanaal een andere effectieve hoogte en dus een andere kalibratie. Dat merk je aan een robot die in de ene richting goed en in de andere slecht de lijn volgt.

De montage vóór de wielen is eveneens belangrijk: hoe verder naar voren, hoe eerder de robot een hoek ziet en hoe meer reactietijd de regelaar heeft. Te ver naar voren versterkt de geometrie de fout tot een oscillatie.

Omgevingslicht overwinnen

Zonlicht bevat veel infrarood rond 940 nm. Bij de detector komt dat vrijwel precies aan als een reflectie. Een robot die binnen werkt en bij een raam mislukt, heeft vrijwel altijd hiermee te maken.

Kunnen de zenders van je array worden uitgeschakeld, dan is de oplossing volledig en kosten twee metingen:

int ambientSubtracted(int i) {
  digitalWrite(LEDON, LOW);   delayMicroseconds(200);
  int dark = analogRead(PIN[i]);      // ambient only
  digitalWrite(LEDON, HIGH);  delayMicroseconds(200);
  int lit  = analogRead(PIN[i]);      // ambient + our own emitter
  return lit - dark;                  // just our emitter
}

De meting met uitgeschakelde zender is daarmee de referentie; het verschil is alleen het teruggekaat licht van de eigen zender. Alles wat constant in de omgeving aanwezig is, valt precies weg. De bemonstertijd verdubbelt, wat bij een snelle lijnvolger een reële kost is, maar maakt een onbetrouwbare sensor betrouwbaar. Commerciële arrays gebruiken deze techniek.

Als dat niet kan: scherm de array af met een rand, zodat hij alleen de vloer recht eronder ziet.

Problemen oplossen

Een array kiezen

Analoog is beter dan digitaal voor alles met een regellus. De comparator van een digitale array meldt lijn of geen lijn per kanaal, waardoor de positie wordt opgedeeld in een handvol discrete waarden en vloeiende proportionele besturing onmogelijk is. Analoog levert een doorlopend foutsignaal, en dat is wat een PID-regelaar nodig heeft.

De afstand tussen kanalen is net zo belangrijk als het aantal. De array moet breder zijn dan de lijn, zodat aan elke rand altijd minstens één sensor op de vloer staat, maar niet zo breed dat de lijn ongezien tussen twee sensoren kan vallen. Voor standaard elektrische tape van 19 mm werkt een kanaalafstand van 8 mm goed.

Voor een lijndoolhofoplosser geldt één extra eis: de array moet breed genoeg zijn om een kruising te zien. Een robot detecteert een linkerbocht door te zien dat de meest linkse sensoren donker worden terwijl het midden nog op de lijn zit. Dat is onmogelijk als de array nauwelijks breder is dan de tape.