Basis · 18 min leestijd

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.

Breadboard (soldeervrij experimenteerbord)
Elke verbinding uit het schema maak je op het breadboard door pootjes in dezelfde kolom van vijf gaatjes te steken of met een jumperdraad.

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-elementHoe het eruitzietWat het je vertelt
SymboolEen tekening die bij het component hoort (rechthoek, driehoek, parallelle lijnen)Het type component en de richting van de pins
Draad (lijn)Een rechte lijnDe uiteinden zitten op hetzelfde elektrische punt; het is niet het echte pad van de draad
KnooppuntEen gevulde stipWaar drie of meer lijnen samenkomen
Aanduiding (reference designator)R1, C2, D1, Q1, U1Componenttype en volgnummer; dezelfde tekst staat op de print
Waarde220, 4k7, 100n, BC547Weerstandswaarde, capaciteit of onderdeelmodel
NetnaamEen naam bij een draad: SDA, LED, BTNAlle draden met dezelfde naam zijn met elkaar verbonden
VoedingssymboolVCC, +5V, 3V3, GNDVoeding en massa; symbolen met dezelfde naam zijn verbonden, ook zonder lijn
PinnummerEen klein getal naast een pinOm 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:

ComponentLettercodeSchemasymboolWaar je op let bij het lezen
WeerstandRRechthoek (IEC) of zigzaglijn (ANSI)Geen polariteit; de waarde is in ohm (220, 4k7)
Potmeter / trimmerRV, VR of PWeerstandssymbool met een pijl die het midden raaktDe pijl is de middelste pin (loper); de buitenste pins zijn de vaste uiteinden
Condensator (niet-gepolariseerd)CTwee gelijke parallelle lijnenKeramische condensatoren en foliecondensatoren; geen polariteit
Elco (elektrolytische condensator)CTwee platen, één recht en één gebogen of gevuld, met een plustekenDe plusplaat gaat naar plus; verkeerd om wordt hij heet en zet hij uit
DiodeDEen driehoek met een streep aan de puntDe streep is de kathode; die komt overeen met de ring op de behuizing
LEDLED of DDiodesymbool met twee pijlen die naar buiten wijzenDe driehoek wijst van de anode (lange pootje) naar de kathode
ZenerdiodeD of ZDDiodesymbool met omgebogen uiteinden aan de kathodestreepIn sperrichting aangesloten; geleidt bij een bepaalde spanning
NPN-transistorQBasislijn in een cirkel, pijl op de emitter wijst naar buitenDe pijl markeert de emitter; de emitter gaat meestal naar GND
PNP-transistorQZelfde symbool, pijl wijst naar binnenDe emitter gaat meestal naar de positieve voeding
N-kanaal-MOSFETQGate-lijn (G) los van het kanaal, pijl op de body wijst naar binnenG-, D- en S-pins; de pijlrichting vertelt je het kanaaltype
Drukknop (momentschakelaar)SW of SEen verhoogde brug boven twee contactpuntenVerbindt de twee uiteinden zolang hij ingedrukt is
Schakelaar (aan-uit)SW of SEen schuine lijn die aan één kant open scharniertBlijft staan waar je hem laat; een SPDT-type heeft drie aansluitingen
Batterij / gelijkspanningsbronBT of BLange en korte parallelle lijnenDe lange lijn is de positieve (+) aansluiting
RelaisKEen spoelblokje met een contact dat via een stippellijn eraan gekoppeld isDe spoel en de contacten kunnen op verschillende plaatsen in het schema getekend zijn
BuzzerBZHalve cirkel of klokvormig symbool met een +-aansluitingEen actieve buzzer heeft polariteit
IC / moduleU of ICEen rechthoek met genummerde pinsHet pinnummer is de fysieke pin, de tekst is de functie
Let vooral op de vier gepolariseerde componenten in een schema: elco's, diodes, leds en transistors. Het plusteken, de kathodestreep of de emitterpijl in het schema moet je koppelen aan het tegenstuk op het echte onderdeel: de minstreep op een elco, de grijze ring op een diode, het korte pootje en de platte kant van de koepel bij een led. Een onderdeel dat je zonder deze controle plaatst, kan de schakeling laten uitvallen of doorbranden, ook al heb je het schema goed gelezen.

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.

SchemalabelBetekenisArduino UnoESP32 DevKitRaspberry Pi Pico
VCC, +5V5 V-voeding5V-pinVIN-/5V-pin (via USB)VBUS (pin 40, via USB)
3V3, +3.3V, VDD3,3 V-voeding3.3V-pin (max. 50 mA)3V3-pin3V3(OUT) (pin 36)
VIN, VSYS, VBATIngang vóór de regelaarVIN (7–12 V aanbevolen)VINVSYS (pin 39, 1,8–5,5 V)
GND, VSS, 0VMassa, gemeenschappelijke referentieGND-pinsGND-pinsGND (pins 3, 8, 13, 18, 23, 28, 33, 38)
Logisch niveauHIGH-spanning van de pins5 V3,3 V (niet 5V-tolerant)3,3 V (niet 5V-tolerant)
Alleen omdat er in het schema van een module VCC staat, mag je hem niet op elk board met 5 V voeden. De pins van de ESP32 en de Pico werken op 3,3 V; geeft een module die op 5 V draait een 5 V-signaal af, dan kan het direct aansluiten van dat signaal de pin beschadigen. Voeg in zulke gevallen een spanningsdeler of een niveauconverter toe; de ECHO-pin van de HC-SR04 is het bekendste voorbeeld.

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.
Zie je een twijfelachtige kruising, kijk dan naar de rest van het schema: gebruikt de ontwerper bij andere knooppunten stippen, dan is een kruising zonder stip zeker niet verbonden. Weet je het nog niet zeker, bevraag dan de logica van de schakeling: zou de voeding kortgesloten worden met GND als deze verbinding bestond? De meeste onduidelijkheden los je met die vraag op.

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.

NotatieBetekenisVoorbeeld
Letter + cijferComponentaanduidingR3 = derde weerstand, U2 = tweede IC
4k7, 2R2, 1MWeerstandswaarde; de letter vervangt de decimale komma4,7 kΩ, 2,2 Ω, 1 MΩ
100n, 104, 10u/16VCondensatorwaarde en spanningsklasse100 nF; 10 µF, max. 16 V
Naam bij een draadNetlabelAlle SDA's zijn met elkaar verbonden
Naam met streep erboven, /RESET, RESET#, nRESETActief-LOW-signaalDe functie werkt wanneer de pin LOW is
D[0..7], A0–A3BusAcht lijnen weergegeven als één dikke lijn
X-tekenNiet-aangesloten pin (NC)Een IC-pin die vrij blijft
StreepjesvakFunctioneel blok of de omtrek van een kant-en-klare module"Voeding", "Sensormodule"
Heeft de naam van een pin een streep erboven, een schuine streep (/) ervoor of een # of _N erachter, dan is het signaal actief LOW: de functie werkt wanneer de pin naar 0 V getrokken wordt. De RESET-pin van de Arduino en de IN-ingang van veel relaismodules werken zo; dit detail over het hoofd zien is de meest voorkomende oorzaak van de klacht "mijn relais werkt andersom".

Een schakelschema lezen, stap voor stap

  1. 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.
  2. Herken het hoofdonderdeel: een Arduino, ESP32, Pico of IC is meestal het grote blok midden in het schema; al het andere is eromheen gebouwd.
  3. 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.
  4. Verdeel de schakeling in blokken: teken kaders rond de delen voeding, ingang (knop, sensor), verwerking (board) en uitgang (led, buzzer, motor).
  5. 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.
  6. 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.
  7. 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.

NetnaamVerbonden aansluitingenOp het breadboard
+5VArduino 5V, BZ1 (+)Rode (+) voedingsrail
GNDArduino GND, kathode van LED1, één kant van SW1, één kant van C1, emitter van Q1Blauwe (−) voedingsrail
LEDD9, één kant van R1Jumperdraad van D9 naar de kolom van R1
N1Andere kant van R1, anode van LED1R1 en het lange pootje van LED1 in dezelfde kolom van vijf gaatjes
BTND2, andere kant van SW1, andere kant van C1Pootje van de knop en C1 in dezelfde kolom, vandaar een jumper naar D2
BZD8, één kant van R2Jumperdraad van D8 naar de kolom van R2
N2Andere kant van R2, basis van Q1R2 en het middelste pootje (B) van de BC547 in dezelfde kolom
N3Collector 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

  1. 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.
  2. 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.
  3. 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.
  4. 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.
  5. 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.
  6. 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.
  7. 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 meest gemaakte overzetfout op een breadboard is beide pootjes van een component in dezelfde kolom van vijf gaatjes steken. Het component is dan kortgesloten en gedraagt zich alsof het er niet is: een weerstand in één kolom beperkt de stroom niet, en een knop wordt gelezen als permanent ingedrukt. Weet je niet zeker hoe een breadboard intern verbonden is, lees dan eerst Wat is een breadboard?; voor het meten helpt de gids Een multimeter gebruiken.

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 schemaArduino UnoESP32Raspberry Pi Pico
LED (naar LED1 via R1)D9GPIO 18GP15
BTN (SW1 en C1, andere kanten naar GND)D2GPIO 4GP14
BZ (naar basis van Q1 via R2)D8GPIO 19GP16
+5V (plus-aansluiting van BZ1)5VVIN / 5VVBUS
GNDGNDGNDGND
C++ (Arduino IDE)
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:

MicroPython
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.

ModuleWaar je in het schema op letWat het je vertelt
RelaismoduleTransistor of optocoupler, diode 1N4148 of 1N4007, JD-VCC-jumperOf 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-upweerstandenAdres: 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 SCLDat 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 datalijnDat je geen aparte pull-upweerstand hoeft toe te voegen
HC-SR045 V-voeding en ECHO-uitgangDat 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.

KenmerkBreadboardweergaveSchemaPCB-weergave
Wat het laat zienRealistische tekeningen van onderdelen en het gaatje waar elke draad in gaatSymbolen en elektrische verbindingenKoperbanen, pads en afmetingen van de print
Het best voorVoor het eerst bouwen, exact nabouwenBegrijpen, fouten zoeken, aanpassenEen print laten maken
Bij grote schakelingenDraden raken in de knoop en zijn moeilijk te lezenBlijft overzichtelijk met blokken en netnamenWordt ingewikkeld met lagen en banen
Draadkleur en padZichtbaar maar zonder elektrische betekenisGeen draadpad, alleen verbindingenBaanbreedte en lengte doen ertoe
Overstappen op een ander boardDe tekening moet opnieuw gemaakt wordenAlleen de pinnummers veranderenDe print wordt opnieuw ontworpen

Veelgemaakte fouten en hoe je ze oplost

FoutSymptoomOplossing
Een kruising zonder stip als verbinding zienExtra draden, soms kortsluitingVerbind alleen waar een gevulde stip staat
Netlabels overslaanI2C- of seriële communicatie werkt helemaal nietZoek elk label met dezelfde naam op en koppel ze
De GND's niet samenvoegenDe sensor geeft onzin door, de module reageert nietBreng alle GND-symbolen samen op één punt
De pinvolgorde van de transistor uit het schema overnemenDe transistor wordt heet of de belasting werkt helemaal nietControleer de pinout van de behuizing in de datasheet
Een diode of led omgekeerd plaatsenDe led brandt niet, een beveiligingsdiode sluit de voeding kortKoppel de kathodestreep aan de ring op de behuizing
Een actief-LOW-ingang over het hoofd zienHet relais klikt bij het opstarten aan, de logica werkt andersomLet op pinnamen met een streep erboven, / of #
Pinnummers en GPIO-nummers door elkaar halenDe verkeerde pin reageertOp de Pico is fysieke pin 20 GP15; gebruik in code het GP-nummer
Een voedingsrail die in het midden gesplitst isDe helft van de schakeling krijgt geen stroomMeet de rail en overbrug zo nodig de twee helften met een jumper
Als je voor het eerst een complex schema leest, probeer dan niet alles in één keer te begrijpen. Kleur eerst de voeding en GND in, dan het hoofdboard en als laatste de ingangs- en uitgangsblokken. Elk blok apart bouwen en testen op het breadboard gaat veel sneller dan de hele schakeling in één keer bouwen en dan zoeken naar het onderdeel dat niet werkt. Houd de tool Pinout bij de hand om de exacte pinindeling van je boards te zien.

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.

Alle projecten bekijken
LED laten knipperen
AR-1Beginner

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.

4.6(200)
1246
LED aansturen met een drukknop (Push)
AR-9Beginner

LED aansturen met een drukknop (Push)

Net als een deurbel: het licht blijft aan zolang je indrukt en gaat uit als je loslaat.

4.8(114)
253
Verkeerslicht
AR-3Beginner

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…

4.8(137)
440
Nachtlampje met LDR
AR-12Beginner

Nachtlampje met LDR

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

4.7(105)
224
Een buzzer gebruiken
AR-13Beginner

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.

4.7(92)
170
Raspberry Pi Pico: een externe led aansturen (breadboard)
PI-2Beginner

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.

4.5(2)
7
ESP32-ledbesturing met drukknop (Push)
ES-2Beginner

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.

4.6(36)
57
Raspberry Pi Pico: led bedienen met een knop (indrukken)
PI-9Beginner
Premium

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.

11