Taak 1: Video stream starten en stoppen

Video-streaming bestaat uit drie fasen: initialisatie (verbinding + stream starten), ophalen (loop over frames), shutdown (netjes afsluiten).

Fase 1: Initialisatie

Verbinding maken en stream starten:

tello = Tello()
tello.connect()
tello.streamon()
time.sleep(2)  # Wacht op buffering!

De wacht is cruciaal — zonder krijg je None-frames.

Fase 2: Ophalen in een lus

Je vraagt de frame-lezer één keer op. Daarna haal je in een for-lus steeds het nieuwste frame op, controleer je het en laat je het zien. De lus heeft een maximum, en met q stop je eerder:

frame_read = tello.get_frame_read()

for frame_nr in range(300):          # hooguit 300 frames, ongeveer 10 seconden
    img = frame_read.frame
    if img is None:
        continue                     # nog geen beeld: door naar de volgende ronde
    cv2.imshow("Tello", img)

    key = cv2.waitKey(1) & 0xFF      # 1 ms kijken of er een toets is ingedrukt
    if key == ord('q'):
        break                        # q = stoppen

Fase 3: Shutdown

Stream en verbinding netjes sluiten, ná de lus, op niveau 0:

cv2.destroyAllWindows()
tello.streamoff()
tello.end()

Video-streaming is fundamenteel anders dan normale code. Het draait om drie principes: asynchroniteit, timing-geduld, en voorzichtige opruiming.

Principe 1: Asynchroniteit — request dan wait

Synchroon: x = 5 + 3 → meteen 8. Asynchroon: je vraagt, hardware doet iets, jij wacht.

tello.streamon()  # Vraag, hardware begint

Frames bestaan nog niet — je moet wachten.

Principe 2: Buffering-timing — sleep is nodig

Hardware doet: camera starten → coderen → Wi-Fi sturen. Dit kost tijd. Te snel vragen = None.

time.sleep(2)  # Wacht tot hardware klaar is

Principe 3: None-checking — altijd controleren

get_frame_read() geeft iets terug, maar kan leeg zijn (None).

for frame_nr in range(300):
    if frame_read.frame is None:
        continue  # stream nog niet klaar: sla deze ronde over
    img = frame_read.frame

Met continue sla je alleen dit ene lege frame over. Met break zou je de hele stream stoppen bij het eerste lege frame — en dat gebeurt vooral in de eerste seconde.

Principe 4: Frame als NumPy-array — 3D tabel

Shape: (hoogte, breedte, 3 kleuren). NumPy-operaties zijn snel.

img.shape  # Bijv. (720, 960, 3)
img.mean()  # Alle pixels in ÉÉN operatie

Principe 5: Volgorde in de lus — ophalen → controleren → verwerken → stop-check

Elke ronde van de lus doet dezelfde vier stappen, in deze volgorde.

for frame_nr in range(300):
    img = frame_read.frame              # 1. ophalen
    if img is None:                     # 2. controleren
        continue
    cv2.imshow("Tello", img)            # 3. verwerken
    if cv2.waitKey(1) & 0xFF == ord('q'):   # 4. stop-check
        break

Principe 6: cv2.waitKey(1) — non-blocking

Geeft 1ms voor toetsen, dan loop verder. Geen blokkering.

Zonder waitKey ververst het venster van imshow niet eens — het is dus nodig, ook als je geen toets gebruikt.

Principe 7: Opruimen — altijd na de lus

De stream mag nooit blijven openstaan. Zet het opruimen daarom ná de lus, op niveau 0. Of de lus nu stopt door break of omdat range op is: daarna wordt het opruimen altijd uitgevoerd.

tello.connect()
tello.streamon()
time.sleep(2)
frame_read = tello.get_frame_read()

for frame_nr in range(300):
    img = frame_read.frame
    if img is None:
        continue
    cv2.imshow("Tello", img)
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

# Na de lus: altijd opruimen
cv2.destroyAllWindows()
tello.streamoff()
tello.end()

Eén uitzondering: crasht je script halverwege met een foutmelding, dan komt het nooit bij het opruimen. Daar leer je in sprint 4 een oplossing voor. Voor nu: test je lus goed, zodat hij niet crasht.

Principe 8: Frame-rate timing

Hoeveel frames per seconde krijg je? Om dit te meten:

import time

start = time.time()
frame_count = 0

for frame_nr in range(300):
    # ophalen en verwerken
    frame_count = frame_count + 1

    # Elk 30e frame: print FPS
    if frame_count % 30 == 0:
        elapsed = time.time() - start
        fps = frame_count / elapsed
        print(f"FPS: {fps:.1f}")

Dit geeft feedback: gaat je systeem snel genoeg?