Een schakelschema lezen: symbolen, knooppunten en breadboards
Een schakelschema lezen: symbolen voor weerstand, diode, transistor, VCC en GND, knooppunten versus kruisingen, netnamen, moduleschema's en bedrading op een breadboard.
Hoe lees je een schakelschema? Kort gezegd: een schema is een kaart die met standaardsymbolen laat zien welke pin elektrisch met welke pin verbonden is, niet hoe de onderdelen eruitzien. Om er een te lezen herken je eerst de symbolen, volg je elke lijn als een verbinding, onderscheid je knooppuntpunten van gewone kruisingen, lees je aanduidingen en waarden zoals R1 of 220, en bepaal je ten slotte welk deel van de schakeling de VCC- en GND-symbolen voeden. Met deze vijf vaardigheden begrijp je elke tekening, van een schakeling met één led tot het schema van de Arduino zelf.
In deze gids zetten we de symbolen die je het vaakst tegenkomt in één tabel en leggen we uit hoe je de richting van diode- en transistorsymbolen leest, wat het verschil is tussen kruisende en verbonden draden, welke verborgen verbindingen netnamen maken en waar je op let in de schema's van kant-en-klare modules. Daarna zetten we het schema van een echte schakeling met knop, led en buzzer om in een verbindingslijst (netlijst), bouwen we die stap voor stap na op een breadboard en geven we code om de afgebouwde schakeling te testen op een Arduino, ESP32 en Raspberry Pi Pico. In de laatste delen vind je het verschil tussen de breadboardweergave van Fritzing en een echt schema, plus de meest gemaakte leesfouten.

Wat is een schakelschema en waar dient het voor?
Een schakelschema is een tekening die de elektrische opbouw van een elektronische schakeling laat zien. Componenten worden getekend als symbolen, niet op hun echte grootte of plaats, en de lijnen ertussen tonen niet het werkelijke pad van een draad; ze zeggen alleen dat beide uiteinden op hetzelfde elektrische punt zitten. Daarom kunnen twee weerstanden die in het schema naast elkaar staan op de print ver uit elkaar liggen, en kan een lange lijn in het schema één kolom gaatjes op een breadboard zijn. Dat is de kracht van een schema: in één oogopslag zie je hoe de schakeling werkt, welk pad de stroom neemt en waar je moet zoeken als er iets misgaat.
Goed getekende schema's volgen een paar vaste gewoonten: het signaal loopt meestal van links naar rechts (ingangen links, uitgangen rechts), hogere spanningen staan bovenaan en GND onderaan. Naast elk component staat een aanduiding (R1, C2, Q1) en een waarde (220, 100n, BC547). IC's en modules worden getekend als rechthoeken met hun pinnummers en namen. De tabel hieronder vat de bouwstenen samen die je in een schema ziet:
| Schema-element | Hoe het eruitziet | Wat het je vertelt |
|---|---|---|
| Symbool | Een tekening die bij het component hoort (rechthoek, driehoek, parallelle lijnen) | Het type component en de richting van de pins |
| Draad (lijn) | Een rechte lijn | De uiteinden zitten op hetzelfde elektrische punt; het is niet het echte pad van de draad |
| Knooppunt | Een gevulde stip | Waar drie of meer lijnen samenkomen |
| Aanduiding (reference designator) | R1, C2, D1, Q1, U1 | Componenttype en volgnummer; dezelfde tekst staat op de print |
| Waarde | 220, 4k7, 100n, BC547 | Weerstandswaarde, capaciteit of onderdeelmodel |
| Netnaam | Een naam bij een draad: SDA, LED, BTN | Alle draden met dezelfde naam zijn met elkaar verbonden |
| Voedingssymbool | VCC, +5V, 3V3, GND | Voeding en massa; symbolen met dezelfde naam zijn verbonden, ook zonder lijn |
| Pinnummer | Een klein getal naast een pin | Om welke fysieke pin van de IC of connector het gaat |
De meest voorkomende symbolen in schakelschema's
Er zijn twee hoofdtradities voor het tekenen van symbolen: IEC 60617, gangbaar in Europa en een groot deel van de wereld, en de Amerikaanse ANSI/IEEE 315. Het bekendste verschil is de weerstand: in IEC-schema's is dat een lege rechthoek, in ANSI-schema's een zigzaglijn. Beide betekenen hetzelfde component, en omdat je in Arduino-schema's online beide ziet, moet je beide herkennen. De tabel hieronder bevat bijna elk symbool dat je in je eerste projecten tegenkomt:
| Component | Lettercode | Schemasymbool | Waar je op let bij het lezen |
|---|---|---|---|
| Weerstand | R | Rechthoek (IEC) of zigzaglijn (ANSI) | Geen polariteit; de waarde is in ohm (220, 4k7) |
| Potmeter / trimmer | RV, VR of P | Weerstandssymbool met een pijl die het midden raakt | De pijl is de middelste pin (loper); de buitenste pins zijn de vaste uiteinden |
| Condensator (niet-gepolariseerd) | C | Twee gelijke parallelle lijnen | Keramische condensatoren en foliecondensatoren; geen polariteit |
| Elco (elektrolytische condensator) | C | Twee platen, één recht en één gebogen of gevuld, met een plusteken | De plusplaat gaat naar plus; verkeerd om wordt hij heet en zet hij uit |
| Diode | D | Een driehoek met een streep aan de punt | De streep is de kathode; die komt overeen met de ring op de behuizing |
| LED | LED of D | Diodesymbool met twee pijlen die naar buiten wijzen | De driehoek wijst van de anode (lange pootje) naar de kathode |
| Zenerdiode | D of ZD | Diodesymbool met omgebogen uiteinden aan de kathodestreep | In sperrichting aangesloten; geleidt bij een bepaalde spanning |
| NPN-transistor | Q | Basislijn in een cirkel, pijl op de emitter wijst naar buiten | De pijl markeert de emitter; de emitter gaat meestal naar GND |
| PNP-transistor | Q | Zelfde symbool, pijl wijst naar binnen | De emitter gaat meestal naar de positieve voeding |
| N-kanaal-MOSFET | Q | Gate-lijn (G) los van het kanaal, pijl op de body wijst naar binnen | G-, D- en S-pins; de pijlrichting vertelt je het kanaaltype |
| Drukknop (momentschakelaar) | SW of S | Een verhoogde brug boven twee contactpunten | Verbindt de twee uiteinden zolang hij ingedrukt is |
| Schakelaar (aan-uit) | SW of S | Een schuine lijn die aan één kant open scharniert | Blijft staan waar je hem laat; een SPDT-type heeft drie aansluitingen |
| Batterij / gelijkspanningsbron | BT of B | Lange en korte parallelle lijnen | De lange lijn is de positieve (+) aansluiting |
| Relais | K | Een spoelblokje met een contact dat via een stippellijn eraan gekoppeld is | De spoel en de contacten kunnen op verschillende plaatsen in het schema getekend zijn |
| Buzzer | BZ | Halve cirkel of klokvormig symbool met een +-aansluiting | Een actieve buzzer heeft polariteit |
| IC / module | U of IC | Een rechthoek met genummerde pins | Het pinnummer is de fysieke pin, de tekst is de functie |
Leesrichting in diode-, led- en transistorsymbolen
Zie de driehoek in een diode- of ledsymbool als een pijl: de stroom loopt in de richting waarin de driehoek wijst, van de anode naar de kathode. De streep aan de punt van de driehoek is de kathode en komt overeen met de ring op de behuizing van een echte diode. Bij een led staan de twee kleine pijltjes die van de driehoek af wijzen voor licht; wijzen de pijltjes naar binnen, dan is het geen led maar een lichtgevoelig onderdeel zoals een fotodiode of fototransistor. Zit de led goed om maar brandt hij heel zwak of gaat hij snel kapot, controleer dan de serieweerstand met de rekenmachine Ledweerstand.
In een transistorsymbool zit de pijl altijd op de emitter en geeft hij de richting van de conventionele stroom aan. Bij een NPN wijst de pijl naar buiten: de stroom loopt van collector naar emitter, en de emitter gaat meestal naar GND. Bij een PNP wijst de pijl naar binnen en is de emitter verbonden met de positieve voeding. De schuine aansluiting zonder pijl is de collector, en de aansluiting die haaks op de korte dikke lijn uitkomt is de basis. Hier zit een belangrijke valkuil: de letters B, C en E in het schema vertellen je niet de pinvolgorde van de echte behuizing. Met de platte kant naar je toe zijn de pootjes van de BC547 van links naar rechts C, B, E, terwijl de 2N2222A en S8050 E, B, C zijn. Controleer dus bij de overgang van schema naar breadboard de pinout van elke transistor in de datasheet of met de tool Transistor; meer details staan in Wat is een transistor?.
VCC, GND en voedingssymbolen
Als je de voedingslijnen apart naar elk component tekent, wordt een schema onoverzichtelijk. Daarom gebruikt men voedingssymbolen. VCC, +5V of 3V3 naast een pijl omhoog of een kort horizontaal streepje markeert een voedingspunt, terwijl drie horizontale lijnen die naar beneden korter worden (in sommige tekeningen een driehoek naar beneden) GND aanduiden, het massa- en referentiepunt. Vergeet de regel niet: alle voedingssymbolen met dezelfde naam zijn met elkaar verbonden, ook als er geen lijn tussen staat. Een GND rechtsonder in het schema is hetzelfde punt als de GND linksboven. Daarom moeten alle GND's aan elkaar, zelfs bij modules met aparte voeding; Wat is GND? legt uitgebreid uit waarom.
De namen van de voedingen komen van transistoraansluitingen: VCC van de collectorvoeding van bipolaire transistors, VDD en VSS van de drain en source van de MOSFET's in CMOS-schakelingen. In de praktijk betekenen VCC en VDD de positieve voeding, terwijl VSS en VEE GND of een negatieve voeding betekenen. Zie je AGND (analoge massa) en DGND (digitale massa), dan zijn dat massa's die apart getekend zijn om ruis gescheiden te houden, maar ze worden meestal uiteindelijk op één punt samengevoegd. Welke spanning je op de VCC-pin van een module zet, vertelt niet het label maar het schema of de datasheet van de module.
| Schemalabel | Betekenis | Arduino Uno | ESP32 DevKit | Raspberry Pi Pico |
|---|---|---|---|---|
| VCC, +5V | 5 V-voeding | 5V-pin | VIN-/5V-pin (via USB) | VBUS (pin 40, via USB) |
| 3V3, +3.3V, VDD | 3,3 V-voeding | 3.3V-pin (max. 50 mA) | 3V3-pin | 3V3(OUT) (pin 36) |
| VIN, VSYS, VBAT | Ingang vóór de regelaar | VIN (7–12 V aanbevolen) | VIN | VSYS (pin 39, 1,8–5,5 V) |
| GND, VSS, 0V | Massa, gemeenschappelijke referentie | GND-pins | GND-pins | GND (pins 3, 8, 13, 18, 23, 28, 33, 38) |
| Logisch niveau | HIGH-spanning van de pins | 5 V | 3,3 V (niet 5V-tolerant) | 3,3 V (niet 5V-tolerant) |
Kruisende en verbonden draden: de puntregel
Wat beginners bij het lezen van een schema het meest in de war brengt, zijn de plaatsen waar twee lijnen elkaar overlappen. De regel is eenvoudig maar streng: staat er een gevulde stip op het snijpunt, dan zijn de lijnen verbonden; staat er geen stip, dan kruisen ze alleen. Oudere schema's tekenden onverbonden kruisingen als een lijn die met een klein halfrondje over de andere heen springt, en dat zie je nog in sommige leerboeken. Moderne tekenprogramma's zoals KiCad en EasyEDA plaatsen de stip automatisch wanneer het uiteinde van een lijn het midden van een andere raakt.
- T-knooppunt met stip: drie lijnen komen op één punt samen; ze zitten allemaal op hetzelfde net. Dit is de veiligste en meest gebruikte manier van tekenen.
- Plusvormige kruising, geen stip: twee lijnen lopen over elkaar heen zonder elkaar te raken; er is geen verbinding tussen.
- Plusvormige kruising met stip: alle vier de lijnen zijn verbonden, maar omdat de stip op een fotokopie of een klein scherm kan verdwijnen, tekenen goede ontwerpers dit als twee verschoven T-knooppunten.
- Halfrondje-sprong: ouderwetse stijl; de ene lijn springt over de andere, geen verbinding.
- X aan het eind van een lijn: een niet-aangesloten pin (NC, no connect); die pin vrij laten is een bewuste keuze.
Aanduidingen, waarden en netnamen
De componentaanduiding naast elk component bestaat uit een lettercode en een volgnummer: R1, R2, C1, D1, Q1, U1. De letter vertelt het type: R weerstand, C condensator, L spoel, D diode, Q transistor, U IC, K relais, F zekering, SW schakelaar, J of P connector, Y kristal, BZ buzzer, M motor. Op kant-en-klare boards staat dezelfde aanduiding op de zeefdruk, zodat je de C5 uit het schema op het board kunt terugvinden. Waarden worden verkort geschreven: 4k7 betekent 4,7 kΩ, 100n 100 nF en 10u 10 µF; de letter neemt de plaats van de decimale komma in. Moet je een waarde van kleurringen aflezen, gebruik dan de tool Weerstandskleurcode; de details van elke componentfamilie staan in Elektronische basiscomponenten.
De echte kunst van schema's lezen zit in netnamen. Een net is het elektrische punt dat gevormd wordt door alle aansluitingen die met elkaar verbonden zijn. Omdat het onmogelijk is om in grote schema's elke verbinding als lijn te tekenen, schrijft de ontwerper aan het eind van een draad een naam: SDA, SCL, LED, TX enzovoort. Twee draden met dezelfde naam zijn verbonden, ook als er geen lijn tussen staat. In het officiële schema van de Arduino Uno zijn bijvoorbeeld de TX- en RX-lijnen van de USB-serieel-chip op deze manier, via de naam, met de hoofdprocessor verbonden. Een naam kan in de ene hoek van de pagina staan en zijn partner in de andere; zolang je ze niet bij elkaar hebt gezocht, heb je het schema niet echt gelezen.
| Notatie | Betekenis | Voorbeeld |
|---|---|---|
| Letter + cijfer | Componentaanduiding | R3 = derde weerstand, U2 = tweede IC |
| 4k7, 2R2, 1M | Weerstandswaarde; de letter vervangt de decimale komma | 4,7 kΩ, 2,2 Ω, 1 MΩ |
| 100n, 104, 10u/16V | Condensatorwaarde en spanningsklasse | 100 nF; 10 µF, max. 16 V |
| Naam bij een draad | Netlabel | Alle SDA's zijn met elkaar verbonden |
| Naam met streep erboven, /RESET, RESET#, nRESET | Actief-LOW-signaal | De functie werkt wanneer de pin LOW is |
| D[0..7], A0–A3 | Bus | Acht lijnen weergegeven als één dikke lijn |
| X-teken | Niet-aangesloten pin (NC) | Een IC-pin die vrij blijft |
| Streepjesvak | Functioneel blok of de omtrek van een kant-en-klare module | "Voeding", "Sensormodule" |
Een schakelschema lezen, stap voor stap
- Zoek de voedingsbronnen: markeer de batterij, USB, VIN of adapteringang en elk VCC-, 3V3- en GND-symbool. Weet vanaf het begin op welke spanning de schakeling draait.
- Herken het hoofdonderdeel: een Arduino, ESP32, Pico of IC is meestal het grote blok midden in het schema; al het andere is eromheen gebouwd.
- Maak een onderdelenlijst: schrijf alle aanduidingen en waarden op (R1 220 Ω, C1 100 nF, Q1 BC547). Deze lijst wordt zowel je boodschappenlijst als je controlelijst.
- Verdeel de schakeling in blokken: teken kaders rond de delen voeding, ingang (knop, sensor), verwerking (board) en uitgang (led, buzzer, motor).
- Volg elk net apart: begin bij een pin, volg de lijn tot de stippen en schrijf elke pin op dat net op. Vergeet netlabels met dezelfde naam niet.
- Markeer de gepolariseerde onderdelen: markeer in het schema de kathode van de diode, de anode van de led, de plus van de elco en de emitter van de transistor.
- Beschrijf het signaalpad in één zin: kun je zeggen "als ik op de knop druk, wordt D2 LOW, zet de code D8 HIGH, gaat Q1 aan en klinkt de buzzer", dan heb je het schema echt gelezen.
Voorbeeld: het schema van een schakeling met knop, led en buzzer lezen
Laten we het geleerde nu toepassen op een echt schema. Onze schakeling heeft zeven componenten. Het net LED dat de D9-pin van de Arduino verlaat, gaat via weerstand R1 (220 Ω) naar de anode van LED1; de kathode van de led zit aan GND. Het net BTN op pin D2 gaat naar GND via drukknop SW1 en daarmee parallel condensator C1 (100 nF). Het net BZ dat pin D8 verlaat, bereikt via R2 (1 kΩ) de basis van transistor Q1 (BC547); de emitter van Q1 zit op GND en zijn collector op de min-aansluiting van actieve buzzer BZ1, waarvan de plus-aansluiting op +5V zit. De betrouwbaarste manier om een schema te lezen is het om te zetten in een verbindingslijst (netlijst) zoals hieronder: elke rij is een net, en alle aansluitingen in die rij moeten op het breadboard op één punt samenkomen.
| Netnaam | Verbonden aansluitingen | Op het breadboard |
|---|---|---|
| +5V | Arduino 5V, BZ1 (+) | Rode (+) voedingsrail |
| GND | Arduino GND, kathode van LED1, één kant van SW1, één kant van C1, emitter van Q1 | Blauwe (−) voedingsrail |
| LED | D9, één kant van R1 | Jumperdraad van D9 naar de kolom van R1 |
| N1 | Andere kant van R1, anode van LED1 | R1 en het lange pootje van LED1 in dezelfde kolom van vijf gaatjes |
| BTN | D2, andere kant van SW1, andere kant van C1 | Pootje van de knop en C1 in dezelfde kolom, vandaar een jumper naar D2 |
| BZ | D8, één kant van R2 | Jumperdraad van D8 naar de kolom van R2 |
| N2 | Andere kant van R2, basis van Q1 | R2 en het middelste pootje (B) van de BC547 in dezelfde kolom |
| N3 | Collector van Q1, BZ1 (−) | Het C-pootje van de BC547 en het min-pootje van de buzzer in dezelfde kolom |
Let op twee details in de tabel. Ten eerste zit er in het schema geen pull-upweerstand op de knop, omdat de code INPUT_PULLUP gebruikt en de weerstand in de processor (ongeveer 20–50 kΩ op de Uno) die taak overneemt. Goede schema's vermelden dit met een kleine opmerking naast de pin. Ten tweede is C1 een hardwarematige ontdenderingscondensator die de contactdender van de knop afvlakt; samen met de interne pull-up vormt hij een RC-tijdconstante van ongeveer 2–5 ms. De naamloze nets hebben we zelf N1, N2 en N3 genoemd; programma's zoals KiCad benoemen ze automatisch. Meer over het aansluiten van knoppen vind je in Een knop aansluiten op Arduino.
Een schema overzetten op een breadboard
- Print het schema uit of houd het naast je op het scherm en leg een markeerstift klaar; kleur elke verbinding in het schema in terwijl je hem bouwt.
- Maak de voedingsrails klaar: verbind de 5V van het board met de rode (+) rail en de GND met de blauwe (−) rail. Controleer bij lange breadboards of de rails in het midden gesplitst zijn.
- Plaats de grote onderdelen: zet IC's over de middengleuf, en steek modules en de transistor zo in dat hun pootjes in aparte kolommen uitkomen.
- Geef elk net een kolom: de vijf verticale gaatjes op een breadboard zijn al met elkaar verbonden; zet de pootjes van hetzelfde net in dezelfde kolom of verbind kolommen met een jumperdraad.
- Plaats gepolariseerde onderdelen door ze te vergelijken met de markeringen in het schema: het lange pootje van de led naar N1, en de BC547 met de platte kant naar je toe zodat de volgorde C, B, E in de juiste kolommen komt.
- Geef draadkleuren een vaste regel: rood voor voeding, zwart of blauw voor GND, andere kleuren voor signalen. Kleur verandert niets elektrisch, maar maakt foutzoeken sneller.
- Meet voordat je spanning geeft: zet de multimeter op doorgangstest (piep); controleer eerst dat er geen kortsluiting is tussen 5V en GND en bevestig dan een piep tussen de aansluitingen van elke rij in de netlijst.
De gebouwde schakeling testen: code voor Arduino en ESP32
De snelste manier om te weten dat je het schema goed hebt overgezet, is een klein testprogramma dat elk net één voor één controleert. De code hieronder laat bij het opstarten eerst de led een seconde branden, laat dan kort de buzzer klinken en print de huidige stap naar de Serial Monitor; daarna houdt hij de knop in de gaten. We hebben de namen van de constanten in de code gelijk gehouden aan de netnamen in het schema, dus het net BZ in het schema is BZ_PIN in de code. Dezelfde code wisselt op een ESP32 zelf van pinnummers; bedraad hem volgens de tabel hieronder.
| Net in het schema | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| LED (naar LED1 via R1) | D9 | GPIO 18 | GP15 |
| BTN (SW1 en C1, andere kanten naar GND) | D2 | GPIO 4 | GP14 |
| BZ (naar basis van Q1 via R2) | D8 | GPIO 19 | GP16 |
| +5V (plus-aansluiting van BZ1) | 5V | VIN / 5V | VBUS |
| GND | GND | GND | GND |
1// Şemadan kurulan devreyi net net test eder / Tests the circuit built from the schematic, net by net
2// Sabit isimleri şemadaki net isimleriyle aynı / Constant names match the net names on the schematic
3#if defined(ESP32)
4const int LED_PIN = 18; // LED neti: R1 üzerinden LED1 anoduna / LED net: to LED1 anode via R1
5const int BTN_PIN = 4; // BTN neti: SW1 ve C1, diğer uçları GND / BTN net: SW1 and C1, other ends to GND
6const int BZ_PIN = 19; // BZ neti: R2 üzerinden Q1 beyzine / BZ net: to Q1 base via R2
7#else
8const int LED_PIN = 9;
9const int BTN_PIN = 2;
10const int BZ_PIN = 8;
11#endif
12
13bool lastPressed = false;
14
15void setup() {
16 Serial.begin(115200);
17 pinMode(LED_PIN, OUTPUT);
18 pinMode(BZ_PIN, OUTPUT);
19 pinMode(BTN_PIN, INPUT_PULLUP); // dahili pull-up, şemada ayrı direnç yok / internal pull-up, no separate resistor on the schematic
20
21 Serial.println(F("1) LED testi / LED test"));
22 digitalWrite(LED_PIN, HIGH); // N1 netine akım gider, LED1 yanar / current flows into N1, LED1 lights
23 delay(1000);
24 digitalWrite(LED_PIN, LOW);
25
26 Serial.println(F("2) Buzzer testi / Buzzer test"));
27 digitalWrite(BZ_PIN, HIGH); // Q1 iletime geçer, N3 GND'ye çekilir / Q1 turns on, N3 is pulled to GND
28 delay(300);
29 digitalWrite(BZ_PIN, LOW);
30
31 Serial.println(F("3) Butona bas / Press the button"));
32}
33
34void loop() {
35 bool pressed = (digitalRead(BTN_PIN) == LOW); // SW1 basılıyken BTN neti GND olur / BTN net goes to GND while SW1 is pressed
36 digitalWrite(LED_PIN, pressed ? HIGH : LOW);
37 digitalWrite(BZ_PIN, pressed ? HIGH : LOW);
38
39 if (pressed != lastPressed) { // yalnızca değişince yaz / print only on change
40 if (pressed) {
41 Serial.println(F("Basildi / Pressed"));
42 } else {
43 Serial.println(F("Birakildi / Released"));
44 }
45 lastPressed = pressed;
46 }
47 delay(10);
48}Drie regels in het programma hebben direct met het schema te maken. INPUT_PULLUP schakelt de interne pull-upweerstand in die niet in het schema getekend is, zodat de pin HIGH leest als de knop niet ingedrukt is en LOW als hij dat wel is, omdat SW1 het net met GND verbindt. digitalWrite(BZ_PIN, HIGH) stuurt stroom via R2 naar de basis van Q1: op een Uno met 5 V is deze stroom (5 − 0,7) / 1000 ≈ 4,3 mA. Omdat de BC547 een stroomversterking van minstens 110 heeft, schakelt dat gemakkelijk de ongeveer 30 mA die de buzzer trekt; op de ESP32 geeft de pin 3,3 V, waardoor de basisstroom daalt naar 2,6 mA, wat nog steeds genoeg is. De ledstroom op de Uno is (5 − 2) / 220 ≈ 14 mA voor een rode led; je kunt deze berekeningen herhalen met de rekenmachine Wet van Ohm.
Hetzelfde schema met een Raspberry Pi Pico en MicroPython
Het mooie van een schema is dat het niet van het board afhangt: om dezelfde netlijst op een Pico te bouwen, schrijf je gewoon andere pinnummers naast de netnamen. Verbind op de Pico de plus-aansluiting van de buzzer met de VBUS-pin (pin 40), die de 5 V van USB levert. GP16 is alleen via R2 met de basis van de transistor verbonden; de 5 V-kant zit op de collector en raakt de pin van de Pico nooit rechtstreeks, zodat de 3,3 V-pins veilig blijven. Sla de code met Thonny als main.py op de Pico op:
1# Pico: şemadan kurulan devreyi net net test eder / tests the circuit built from the schematic, net by net
2from machine import Pin
3import time
4
5led = Pin(15, Pin.OUT) # LED neti: GP15 -> R1 -> LED1 / LED net
6btn = Pin(14, Pin.IN, Pin.PULL_UP) # BTN neti: GP14 -> SW1 + C1 -> GND / BTN net
7bz = Pin(16, Pin.OUT) # BZ neti: GP16 -> R2 -> Q1 beyz / BZ net to Q1 base
8
9print("1) LED testi / LED test")
10led.on()
11time.sleep(1)
12led.off()
13
14print("2) Buzzer testi / Buzzer test")
15bz.on() # Q1 iletime geçer / Q1 turns on
16time.sleep(0.3)
17bz.off()
18
19print("3) Butona bas / Press the button")
20last = False
21while True:
22 pressed = btn.value() == 0 # basılıyken 0 okunur / reads 0 while pressed
23 led.value(pressed)
24 bz.value(pressed)
25 if pressed != last: # yalnızca değişince yaz / print only on change
26 print("Basildi / Pressed" if pressed else "Birakildi / Released")
27 last = pressed
28 time.sleep_ms(10)Moduleschema's lezen
Kant-en-klare modules (relaisboards, I2C-LCD-adapters, OLED-displays, sensorboards) zijn eigenlijk ook kleine schakelingen, en de meeste schema's ervan vind je op de pagina van de verkoper of in de datasheet van de fabrikant. Als je een moduleschema leest, is je doel niet om elke weerstand te begrijpen, maar om de vijf gegevens te vinden die je vertellen hoe je de module aansluit: voedingsspanning en regelaar, logisch niveau, pull-upweerstanden, actief-LOW-ingangen en jumpers die een adres of modus kiezen. Het schema van de Arduino Uno zelf is ook goede oefening: alleen het schema vertelt je dat op de Uno R3 de L-led niet direct op D13 zit maar via een opamp-buffer, de LMV358.
| Module | Waar je in het schema op let | Wat het je vertelt |
|---|---|---|
| Relaismodule | Transistor of optocoupler, diode 1N4148 of 1N4007, JD-VCC-jumper | Of de ingang actief LOW of HIGH is en of de spoel apart gevoed kan worden |
| I2C-LCD-adapter (PCF8574) | A0-, A1-, A2-soldeerjumpers en pull-upweerstanden | Adres: 0x27 bij de PCF8574, 0x3F bij de PCF8574A; een jumper doorverbinden verlaagt het adres |
| 0,96-inch OLED (SSD1306) | 3,3 V-regelaar en pull-upweerstanden voor SDA en SCL | Dat VCC 3,3–5 V aankan en er geen extra pull-ups nodig zijn |
| DHT11-module (3 pins) | Een weerstand van 4,7–10 kΩ op de datalijn | Dat je geen aparte pull-upweerstand hoeft toe te voegen |
| HC-SR04 | 5 V-voeding en ECHO-uitgang | Dat ECHO 5 V afgeeft en op de ESP32 en Pico een spanningsdeler nodig heeft |
Breadboardweergave van Fritzing versus schema: wat is het verschil?
De kleurrijke tekeningen die je in de meeste Arduino-projecten online ziet, zijn eigenlijk geen schema's maar de breadboardweergave van een programma genaamd Fritzing. Fritzing bewaart dezelfde schakeling in drie weergaven: de breadboardweergave met fotoachtige tekeningen van echte onderdelen, de schemaweergave met standaardsymbolen en de PCB-weergave voor het ontwerpen van een print. Een verbinding die je in de ene weergave maakt, verschijnt in de andere als gestippelde ratsnest-lijnen; het programma weet dat de verbinding bestaat, maar laat het aan jou over om hem in die weergave netjes te tekenen. De schemaweergave die Tinkercad Circuits automatisch tekent, speelt een vergelijkbare overbruggende rol; details staan in Arduino-simulatie met Tinkercad.
De breadboardweergave is voor beginners erg prettig: hij laat precies zien in welk gaatje elke draad gaat. Maar naarmate de schakeling groeit, kruisen draden elkaar, wordt het moeilijk te zien in welke rij een draad uitkomt en kun je niet zien waarom de schakeling zo gebouwd is. Een schema laat de fysieke indeling helemaal los en toont alleen de functie, en daarom ga je altijd terug naar het schema om fouten te zoeken, de schakeling naar een ander board te verplaatsen of een print te ontwerpen. Maak er een goede gewoonte van: kijk naar de breadboardtekening tijdens het bouwen van een project en naar het schema als je het wilt begrijpen.
| Kenmerk | Breadboardweergave | Schema | PCB-weergave |
|---|---|---|---|
| Wat het laat zien | Realistische tekeningen van onderdelen en het gaatje waar elke draad in gaat | Symbolen en elektrische verbindingen | Koperbanen, pads en afmetingen van de print |
| Het best voor | Voor het eerst bouwen, exact nabouwen | Begrijpen, fouten zoeken, aanpassen | Een print laten maken |
| Bij grote schakelingen | Draden raken in de knoop en zijn moeilijk te lezen | Blijft overzichtelijk met blokken en netnamen | Wordt ingewikkeld met lagen en banen |
| Draadkleur en pad | Zichtbaar maar zonder elektrische betekenis | Geen draadpad, alleen verbindingen | Baanbreedte en lengte doen ertoe |
| Overstappen op een ander board | De tekening moet opnieuw gemaakt worden | Alleen de pinnummers veranderen | De print wordt opnieuw ontworpen |
Veelgemaakte fouten en hoe je ze oplost
| Fout | Symptoom | Oplossing |
|---|---|---|
| Een kruising zonder stip als verbinding zien | Extra draden, soms kortsluiting | Verbind alleen waar een gevulde stip staat |
| Netlabels overslaan | I2C- of seriële communicatie werkt helemaal niet | Zoek elk label met dezelfde naam op en koppel ze |
| De GND's niet samenvoegen | De sensor geeft onzin door, de module reageert niet | Breng alle GND-symbolen samen op één punt |
| De pinvolgorde van de transistor uit het schema overnemen | De transistor wordt heet of de belasting werkt helemaal niet | Controleer de pinout van de behuizing in de datasheet |
| Een diode of led omgekeerd plaatsen | De led brandt niet, een beveiligingsdiode sluit de voeding kort | Koppel de kathodestreep aan de ring op de behuizing |
| Een actief-LOW-ingang over het hoofd zien | Het relais klikt bij het opstarten aan, de logica werkt andersom | Let op pinnamen met een streep erboven, / of # |
| Pinnummers en GPIO-nummers door elkaar halen | De verkeerde pin reageert | Op de Pico is fysieke pin 20 GP15; gebruik in code het GP-nummer |
| Een voedingsrail die in het midden gesplitst is | De helft van de schakeling krijgt geen stroom | Meet de rail en overbrug zo nodig de twee helften met een jumper |
Projectideeën om schema's lezen te oefenen
- Eén led en een weerstand: je begint met twee symbolen en drie nets; zet de schakeling uit Wat is een led? eerst om in een schema en daarna op een breadboard.
- Automatisch nachtlampje: de spanningsdeler van een LDR en een weerstand van 10 kΩ leert je serieschakelingen en het gedeelde middelpunt in een schema te lezen.
- Verkeerslicht: met drie leds en drie weerstanden is het Arduino-verkeerslicht ideaal om herhaalde blokken te leren herkennen.
- Lampbesturing met een relais: het schema van een relaismodule brengt een transistor, een diode en een actief-LOW-ingang samen.
- 555-knipperlicht: de 555-timer-IC is de klassieke oefening in het lezen van een blokssymbool met genummerde pins.
- 7-segmentteller: schema's van een 7-segmentdisplay laten zien hoe acht segmenten netjes met netnamen getekend worden.
Schakelschema's lezen lijkt in het begin op een vreemd alfabet, maar als je de symbolen, de puntregel en de netnamen kent, bouw je elk nieuw project door het te begrijpen in plaats van na te doen. Als volgende stap kun je het voorbeeld uit dit artikel in je eigen tekenprogramma helemaal opnieuw tekenen en de stromen en spanningen op elk net berekenen met de wetten van Kirchhoff. In de BlueGrays-app kun je de schakelschema's van projecten zoals een knipperende led, knoppen, een nachtlampje, een buzzer en een verkeerslicht stap voor stap bestuderen samen met hun code, en meteen met echte onderdelen uitproberen wat je geleerd hebt.
Veelgestelde vragen
Wat betekenen de symbolen in een schakelschema?
Elk symbool staat voor een type component: een rechthoek of zigzaglijn is een weerstand, twee parallelle lijnen een condensator, een driehoek met een streep een diode en een symbool met een pijl in een cirkel een transistor. Aanduidingen zoals R1, C1, D1 en Q1 naast het symbool geven het type en nummer van het component, terwijl tekst zoals 220 of 100n de waarde geeft. VCC- en GND-symbolen markeren de voedings- en massapunten.
Wat betekent een stip in een schakelschema?
Een gevulde stip waar twee of meer lijnen samenkomen, laat zien dat die lijnen elektrisch verbonden zijn. Bij plusvormige kruisingen zonder stip lopen de lijnen alleen over elkaar heen en zijn ze niet verbonden. Oudere schema's tekenen onverbonden kruisingen ook met een klein halfrondje als sprong.
Wat betekenen VCC en GND in een schema?
VCC is de positieve voedingslijn van de schakeling; dat is meestal 5 V op een Arduino Uno en 3,3 V op de ESP32 en Pico. GND is massa, het 0 V-referentiepunt waartegen alle spanningen gemeten worden. Alle VCC- en GND-symbolen met dezelfde naam in een schema zijn verbonden, ook als er geen lijn tussen staat.
Wat is het verschil tussen een schema en een breadboardtekening?
Een breadboardtekening laat zien hoe de onderdelen er echt uitzien en in welk gaatje elke draad gaat; hij is makkelijk na te bouwen maar wordt onleesbaar bij grote schakelingen. Een schema toont alleen de elektrische verbindingen met standaardsymbolen en legt uit hoe de schakeling werkt. Programma's zoals Fritzing en Tinkercad kunnen dezelfde schakeling in beide weergaven tonen.
Welke software gebruik je om schakelschema's te tekenen?
KiCad, gratis en professioneel, is het meest gebruikte programma voor schema's en printontwerp. EasyEDA draait in de browser en is direct gekoppeld aan het bestellen van prints, terwijl Fritzing met zijn breadboardweergave geschikt is voor beginners. In Tinkercad Circuits zie je het schema van de schakeling die je bouwde ook automatisch.
Is een bedradingsschema hetzelfde als een schakelschema?
Niet helemaal. Een bedradingsschema toont meestal de fysieke indeling en de echte draden tussen onderdelen, zoals de zekeringen, stopcontacten, schakelaars en lampen in een gebouw, vaak als eenlijnschema. Een elektronisch schakelschema toont de pin-voor-pin-verbindingen van componenten zoals weerstanden, transistors en IC's zonder zich te bekommeren om waar ze zitten. De puntregel, de symboollogica en de aanduidingen werken in beide op vergelijkbare wijze.
Projecten om hierna te bouwen
Alle projecten bekijken
LED laten knipperen
De allereerste hallo van de elektronica: één LED aan- en uitzetten. De Arduino zet de LED met korte tussenpozen aan en uit, zodat het licht snel knippert.

LED aansturen met een drukknop (Push)
Net als een deurbel: het licht blijft aan zolang je indrukt en gaat uit als je loslaat.

Verkeerslicht
Een kleine kopie van het verkeerslicht dat je elke dag op straat ziet. Rood brandt twee seconden, geel knippert even, groen brandt twee seconden en daarna gaat het via geel weer naar rood, steeds…

Nachtlampje met LDR
Een klein nachtlampje dat vanzelf aangaat als het donker wordt en uitgaat als het ochtend is.

Een buzzer gebruiken
Heb je je ooit afgevraagd hoe een deurbel of alarm geluid maakt? De Arduino laat een kleine buzzer met korte tussenpozen piepen: piep, pauze, piep, pauze.

Raspberry Pi Pico: een externe led aansturen (breadboard)
De volgende stap na de ingebouwde led van de Pico: sluit een externe led aan op een breadboard en bestuur hem via pin GP14. Je leert hoe je elke GPIO-pin van de Pico als uitgang gebruikt, de polariteit van de led (lang pootje = anode/+, kort pootje = kathode/–) en waarom een stroombeperkende weerstand (220Ω) een must is. Zonder weerstand loopt er te veel stroom door de led en kan hij doorbranden.

ESP32-ledbesturing met drukknop (Push)
De led brandt zolang je de knop indrukt en gaat uit als je loslaat. Laat zien hoe je de digitale ingangspin en de interne pull-upweerstand van de ESP32 gebruikt. Met de modus INPUT_PULLUP heb je geen externe weerstand nodig.

Raspberry Pi Pico: led bedienen met een knop (indrukken)
Het eerste invoerproject met de Pico — een knop uitlezen! De led brandt zolang je de knop indrukt en gaat uit als je loslaat. Dit is de grote stap na de ledanimaties: signalen van buiten naar de Pico. Je leert Pin.IN (invoermodus), Pin.PULL_UP (interne pull-upweerstand — standaard voor knoppen) en button.value() uitlezen. GP14 led, GP2 knop (interne PULL_UP). Ingedrukt = LOW (0), losgelaten = HIGH (1) — die omgekeerde logica lijkt eerst verwarrend, maar is de industriestandaard.
Meer artikelen
BlueGrays-app
Bouw deze schakeling stap voor stap op je telefoon
Schakelschema, code en onderdelenlijst op één scherm. Meer dan 500 Arduino-, ESP32- en Pico-projecten om te bouwen.
Scan met je telefoon
Richt je camera op de code en de appstore van je telefoon opent.
of open de store

