Project 02 — De afstandssensor · Arduino Werkplaats

0

Wat je nodig hebt

Je 1.44" TFT-scherm, aangesloten zoals in project 01. Laat het gewoon zitten.
Je 0.96" OLED-schermpje, aangesloten zoals in de OLED-start — vier draadjes via I2C. Laat het gewoon zitten.
De HC-SR04 afstandssensor (de zilveren "oogjes", 4 pinnen: Vcc · Trig · Echo · Gnd).
Vier extra dupont-draadjes en een breadboard om de 5V en GND te delen met het scherm.

Waarom deze sensor als tweede stap? Je hoeft niets nieuws te leren over het scherm — dat ken je al. We voegen precies één ding toe: een sensor uitlezen. Zo bouwt elke stap logisch op de vorige.

1

Hoe "zien met geluid" werkt

De HC-SR04 werkt net als een vleermuis of een parkeersensor. Eén "oog" zendt een kort, onhoorbaar piepje (ultrasoon). Dat geluid kaatst tegen een voorwerp en komt terug bij het andere "oog". De Arduino meet de tijd die daar tussen zit — en omdat geluid met een bekende snelheid reist, reken je die tijd om naar afstand.

De ÷ 2 is omdat het geluid de weg heen én terug aflegt.

De vier pinnen:

Vcc: Voeding, 5V (deze sensor wil echt 5V — niet 3.3V).
Trig: "Trigger": hier geven wij het startsein om een piepje te versturen.
Echo: Hier komt het antwoord terug: de pin blijft hoog zolang het geluid onderweg is.
Gnd: De min / 0 volt.

Goed nieuws over de spanning Anders dan bij het scherm hoef je hier niet met weerstandsdelers te werken voor een simpele test: de Echo-pin geeft 5V terug, wat je Arduino gewoon aankan. (Wil je het helemaal netjes, dan zet je later een deler op Echo — voor nu niet nodig.)

2

De sensor aansluiten

We kiezen twee vrije digitale pinnen die je scherm níét gebruikt: D6 voor Trig en D7 voor Echo. Die zijn op de Uno R4 en de Mega precies hetzelfde.

Vier draadjes erbij — de sensorpinnen zijn op beide borden gelijk.

Sensor	Naar je Arduino	Draad
Vcc	5V	rood
Trig	D6	groen
Echo	D7	amber
Gnd	GND	zwart

Onthoud van project 01 Je TFT-scherm blijft op D8/D9/D10 plus de klok/data-pinnen zitten. Op de R4 zijn dat D13/D11. De afstandssensor komt daar los naast — ze bijten elkaar niet.

Onthoud van de OLED-start Je OLED gebruikt alleen de I2C-pinnen SDA/SCL (of A4/A5) plus 5V en GND. D6 en D7 blijven dus gewoon vrij voor de sensor — ze bijten elkaar niet.

3

Eerst meten in de Serial Monitor

Voordat we het scherm erbij pakken, controleren we of de sensor überhaupt goede getallen geeft. Upload dit, open Tools → Serial Monitor en beweeg je hand ervoor. Je hoort de piepjes niet, maar de getallen bewegen mee.

01_afstand_serial.ino

#define TRIG 6
#define ECHO 7

void setup() {
  Serial.begin(9600);
  pinMode(TRIG, OUTPUT);
  pinMode(ECHO, INPUT);
}

// stuurt één piepje en geeft de afstand in cm terug
long leesAfstand() {
  digitalWrite(TRIG, LOW);              // even stil
  delayMicroseconds(2);
  digitalWrite(TRIG, HIGH);             // 10 microseconden "piep!"
  delayMicroseconds(10);
  digitalWrite(TRIG, LOW);

  long duur = pulseIn(ECHO, HIGH);      // tijd (µs) dat de echo onderweg was
  return duur * 0.034 / 2;             // omrekenen naar centimeters
}

void loop() {
  Serial.print(leesAfstand());
  Serial.println(" cm");
  delay(200);
}

Wat gebeurt hier? pulseIn(ECHO, HIGH) is een handige ingebouwde functie: hij wacht en meet hoe lang de Echo-pin hoog blijft. Geluid legt ongeveer 0,034 cm per microseconde af — vandaar het rekensommetje. Door ÷ 2 tel je alleen de heenweg.

4

Het getal op het scherm

Werkt de meting? Mooi. Nu combineren we het met het scherm dat je al kent. We laten het aantal centimeter groot in beeld zien. Herken je de scherm-regels uit project 01 — die zijn precies hetzelfde.

02_afstand_scherm.ino

#include <Adafruit_GFX.h>
#include <Adafruit_ST7735.h>
#include <SPI.h>

#define TFT_CS 10
#define TFT_RST 9
#define TFT_DC 8
#define TRIG 6
#define ECHO 7

Adafruit_ST7735 tft = Adafruit_ST7735(TFT_CS, TFT_DC, TFT_RST);

long leesAfstand() {
  digitalWrite(TRIG, LOW);  delayMicroseconds(2);
  digitalWrite(TRIG, HIGH); delayMicroseconds(10);
  digitalWrite(TRIG, LOW);
  long duur = pulseIn(ECHO, HIGH, 30000);   // stop na 30 ms (niets gezien)
  if (duur == 0) return 400;                // geen echo -> "ver weg"
  return duur * 0.034 / 2;
}

void setup() {
  pinMode(TRIG, OUTPUT);
  pinMode(ECHO, INPUT);
  tft.initR(INITR_144GREENTAB);
  tft.fillScreen(ST77XX_BLACK);
  tft.setTextColor(ST77XX_WHITE);
  tft.setCursor(8, 12);
  tft.setTextSize(1);
  tft.print("AFSTAND");
}

void loop() {
  long cm = leesAfstand();

  // wis alleen het cijfervak en teken het nieuwe getal
  tft.fillRect(0, 45, 128, 45, ST77XX_BLACK);
  tft.setCursor(14, 50);
  tft.setTextSize(5);
  tft.setTextColor(ST77XX_CYAN);
  tft.print(cm);

  delay(80);
}

Flikkert het getal? Dat komt doordat we elke ronde wissen en opnieuw tekenen. In de volgende stap lossen we dat netjes op door alleen te wissen wat echt verandert — precies de animatie-truc uit project 01.

Werkt de meting? Mooi. Nu combineren we het met je OLED. We laten het aantal centimeter groot in beeld zien. Herken je de scherm-regels uit de OLED-start — die zijn precies hetzelfde, inclusief die ene oled.display() onderaan.

02_afstand_oled.ino

#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

#define TRIG 6
#define ECHO 7

Adafruit_SSD1306 oled(128, 64, &Wire, -1);

long leesAfstand() {
  digitalWrite(TRIG, LOW);  delayMicroseconds(2);
  digitalWrite(TRIG, HIGH); delayMicroseconds(10);
  digitalWrite(TRIG, LOW);
  long duur = pulseIn(ECHO, HIGH, 30000);   // stop na 30 ms (niets gezien)
  if (duur == 0) return 400;                // geen echo -> "ver weg"
  return duur * 0.034 / 2;
}

void setup() {
  pinMode(TRIG, OUTPUT);
  pinMode(ECHO, INPUT);
  oled.begin(SSD1306_SWITCHCAPVCC, 0x3C);   // adres 0x3C (soms 0x3D)
  oled.setTextColor(SSD1306_WHITE);
}

void loop() {
  long cm = leesAfstand();

  oled.clearDisplay();          // maak het kladblok leeg
  oled.setTextSize(1);
  oled.setCursor(0, 0);
  oled.print("AFSTAND");

  oled.setTextSize(4);          // het grote getal
  oled.setCursor(6, 24);
  oled.print(cm);
  oled.setTextSize(2);
  oled.print(" cm");

  oled.display();               // <-- nu pas zichtbaar

  delay(80);
}

Waarom flikkert dit níét? Op een kleurenscherm zie je bij zo'n "wissen-en-opnieuw-tekenen"-lus vaak geflikker. Op de OLED niet: jij tekent in het kladblok, en pas oled.display() zet het hele plaatje in één klap op het scherm. Dat is precies waarvoor die buffer bedoeld is.

5

Een live kleurenbalk

De mooiste versie: een balk die voller wordt naarmate iets dichterbij komt, met een kleur die van groen naar geel naar rood springt. Zo zie je in één oogopslag hoe dichtbij iets is.

Dichterbij = vollere balk en een fellere kleur.

De hele sketch. Alleen de loop() is echt nieuw — lees de commentaren mee:

03_afstandsmeter.ino

#include <Adafruit_GFX.h>
#include <Adafruit_ST7735.h>
#include <SPI.h>

#define TFT_CS 10
#define TFT_RST 9
#define TFT_DC 8
#define TRIG 6
#define ECHO 7

Adafruit_ST7735 tft = Adafruit_ST7735(TFT_CS, TFT_DC, TFT_RST);

long leesAfstand() {
  digitalWrite(TRIG, LOW);  delayMicroseconds(2);
  digitalWrite(TRIG, HIGH); delayMicroseconds(10);
  digitalWrite(TRIG, LOW);
  long duur = pulseIn(ECHO, HIGH, 30000);
  if (duur == 0) return 400;
  return duur * 0.034 / 2;
}

void setup() {
  pinMode(TRIG, OUTPUT);
  pinMode(ECHO, INPUT);
  tft.initR(INITR_144GREENTAB);
  tft.fillScreen(ST77XX_BLACK);
  tft.setTextColor(ST77XX_WHITE);
  tft.setCursor(8, 10);
  tft.setTextSize(1);
  tft.print("AFSTANDSMETER");
  tft.drawRect(6, 92, 116, 24, ST77XX_WHITE);   // balk-omtrek: 1x tekenen
}

void loop() {
  long cm = leesAfstand();
  int toon = constrain(cm, 2, 40);              // toon-bereik: 2 t/m 40 cm

  // kies een kleur op basis van de afstand
  uint16_t kleur = ST77XX_GREEN;
  if (toon < 20) kleur = ST77XX_YELLOW;
  if (toon < 8)  kleur = ST77XX_RED;

  // --- groot getal (wis alleen dit vak) ---
  tft.fillRect(0, 34, 128, 44, ST77XX_BLACK);
  tft.setCursor(14, 38);
  tft.setTextSize(4);
  tft.setTextColor(kleur);
  tft.print(toon);
  tft.setTextSize(2);
  tft.print(" cm");

  // --- balk binnen de omtrek: dichtbij = voller ---
  int breedte = map(toon, 2, 40, 112, 4);       // 112 px vol ... 4 px leeg
  tft.fillRect(8, 94, breedte, 20, kleur);
  tft.fillRect(8 + breedte, 94, 112 - breedte, 20, ST77XX_BLACK);

  delay(60);
}

De mooiste versie: een balk die voller wordt naarmate iets dichterbij komt. Kleur heb je niet op de OLED — dus gebruiken we iets anders om "gevaar" te laten zien: onder de 8 cm zetten we er een waarschuwing bij. Vaak is dat zelfs duidelijker dan kleur.

Alles wit-op-zwart, en de hele hoogte is maar 64 pixels — dus compacter indelen dan op de TFT.

De hele sketch. Alleen de loop() is echt nieuw — lees de commentaren mee:

03_afstandsmeter_oled.ino

#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

#define TRIG 6
#define ECHO 7

Adafruit_SSD1306 oled(128, 64, &Wire, -1);

long leesAfstand() {
  digitalWrite(TRIG, LOW);  delayMicroseconds(2);
  digitalWrite(TRIG, HIGH); delayMicroseconds(10);
  digitalWrite(TRIG, LOW);
  long duur = pulseIn(ECHO, HIGH, 30000);
  if (duur == 0) return 400;
  return duur * 0.034 / 2;
}

void setup() {
  pinMode(TRIG, OUTPUT);
  pinMode(ECHO, INPUT);
  oled.begin(SSD1306_SWITCHCAPVCC, 0x3C);
  oled.setTextColor(SSD1306_WHITE);
}

void loop() {
  long cm = leesAfstand();
  int toon = constrain(cm, 2, 40);              // toon-bereik: 2 t/m 40 cm

  oled.clearDisplay();                          // kladblok leeg

  // --- kopregel ---
  oled.setTextSize(1);
  oled.setCursor(0, 0);
  oled.print("AFSTANDSMETER");

  // --- groot getal ---
  oled.setTextSize(3);
  oled.setCursor(0, 16);
  oled.print(toon);
  oled.setTextSize(1);
  oled.print(" cm");

  // --- balk onderaan: dichtbij = voller ---
  int breedte = map(toon, 2, 40, 124, 4);       // 124 px vol ... 4 px leeg
  oled.drawRect(0, 46, 128, 18, SSD1306_WHITE); // de omtrek
  oled.fillRect(2, 48, breedte, 14, SSD1306_WHITE);

  // --- geen kleur? dan een woord als waarschuwing ---
  if (toon < 8) {
    oled.setTextSize(1);
    oled.setCursor(62, 24);
    oled.print("DICHTBIJ!");
  }

  oled.display();                               // alles in een keer tonen
  delay(60);
}

De twee handigste nieuwe trucs constrain(x, laag, hoog) houdt een getal netjes binnen grenzen. map(x, van1, van2, naar1, naar2) rekent een bereik om naar een ander bereik — hier van "centimeters" naar "pixels breedte". Twee gouden gereedschappen voor elk sensor-project.

6

Zelf uitbreiden

Kleine uitdagingen om zelf te proberen, van makkelijk naar wat pittiger:

Laat bij minder dan 8 cm het woord "TE DICHTBIJ!" knipperen onder de balk.
Draai de balk om: verder weg = voller. Pas alleen de map(...)-regel aan.
Onthoud de kortste afstand ooit gemeten en toon die als "record" in de hoek.
Gevorderd: gebruik de afstand als besturing voor het spelfiguurtje uit project 01 — je hand wordt de joystick.

Meet de wereld,
toon het op je scherm.

Wat je nodig hebt

Hoe "zien met geluid" werkt

De sensor aansluiten

Eerst meten in de Serial Monitor

Het getal op het scherm

Een live kleurenbalk

Zelf uitbreiden

Volgende stap: een weerstation

Meet de wereld,toon het op je scherm.

Wat je nodig hebt

Hoe "zien met geluid" werkt

De sensor aansluiten

Eerst meten in de Serial Monitor

Het getal op het scherm

Een live kleurenbalk

Zelf uitbreiden

Volgende stap: een weerstation

Meet de wereld,
toon het op je scherm.