[toc]
# Getting started with ESP32 and all the other things in the kitje
[Elektronica kitje](/x8G1NvD3R_eiwZn9EBbPdg)
## Inleiding
Om makkelijk op weg te geraken zullen we gebruik maken van de Arduino omgeving.
*(later kan je altijd nog platform.io gaan gebruiken in combinatie met visual studio code)*
## Voorbereiding
### Installeren van de arduino omgeving.
1. Volg de instructies op de [>> Arduino Site<< ](https://www.arduino.cc/en/Guide/HomePage) om de installatie te doen voor uw besturingsysteem.
### ESP32 toevoegen aan de Arduino omgeving:
Hiervoor kan je de tutorial volgen op: https://randomnerdtutorials.com/installing-the-esp32-board-in-arduino-ide-windows-instructions/ .
Of in het kort:
1. Open de arduino omgeving
2. klik op: File > Preferences
3. Plak volgende lijn tekst in het vakje "Additional board manager URLs"
```
https://dl.espressif.com/dl/package_esp32_index.json,https://arduino.esp8266.com/stable/package_esp8266com_index.json
```
4. Druk dan op OK
5. Ga naar: Tools > Board: > Boards Manager
6. Zoek daar op **esp32**
7. En instaleer de package van Espressif systems
### Testen van de installatie
1. Selecteer het Board: Tools > Board > **WEMOS LOLIN32**
2. Selecteer de juiste poort: Tools > Port. Selecteer hier de poort die er verschijnt als je de ESP verbind met de computer. Gebeurt er niets dan kan het [zijn dat je zelf de driver moet installeren. ](https://www.silabs.com/products/development-tools/software/usb-to-uart-bridge-vcp-drivers)
3. Open een example: File > Examples > WiFi > WiFiScan
4. Upload deze sketch naar je bordje.
5. Als er Done uploading staat is alles verlopen zoals het moet
6. Open nu de seriele monitor en stel de baudrate in op **115200**
7. Druk op de **EN**able knop op het bordje en er zou een output van wifi netwerken in je omgeving moeten verschijnen.
Als dit gelukt is kan je aan de slag met volgende voorbeelden:
# Werken met de seriele poort
De seriele poort is een van de nuttigste tools bij het werken met Arduino. Hiermee kan je makkelijk berichten naar buiten brengen van je code. Zo kan je makkelijk opzoek gaan naar de fouten en waar het mis loopt.
```cpp
// Made by Bruce
// Dit is een voorbeeld van verschillende manieren om de seriele monitor te gebruiken.
// Voor meer info van serial print kijk zeker bij: https://www.arduino.cc/reference/en/language/functions/communication/serial/print/
void setup()
{
Serial.begin(115200); //Laat weten dat we een seriele verbinding willen opzetten met een baudrate van 115200.
Serial.print("Eerste tekst ");
Serial.print("met de seriele monitor geprint met het commando Serial.print(). ");
Serial.println("Merk op dat alle tekst achter elkaar wordt geplaatst tot je een newline print."); //Na deze tekst wordt er een nieuwe lijn gestart.
Serial.println("Deze en vorige lijn zijn geprint met Serial.println() wat een newline achter je string zet");
Serial.print("Je kan ook zelf een newline in je zin plaatsen door \n \\n te typen in je zin.\n");
Serial.println("Een \t \\t typen in je zin zal 'tab' plaatsen");
int a = 15;
Serial.print("Variabele a=");
Serial.println(a); // Je kan variabelen gewoon uitprinten als volgt
}
void loop()
{
}
```
# Werken met Digitale ingangen en uitgangen
## Uitlezen digitale ingang
Hieronder heb je een overzicht van de pinnen van de ESP32 LOLIN. Bijna elke **GPIO** kan je lezen en schrijven
* 1. [Sommige pinnen hebben bepaalde functionaliteiten bij opstart of programmeren en dan kan je die beter niet gebruiken, hier kan je zien welke pinnen dat zijn.](https://randomnerdtutorials.com/esp32-pinout-reference-gpios/)
De volgende code zal gebruik makend van digitalRead(gpioPin); een pin uitlezen en deze waarde uitprinten. Digitale ingangen kunnen spanningen tussen 0 en 3.3V verdragen.
```cpp
// Made by Bruce
// Dit is een voorbeeld van verschillende manieren om de seriele monitor te gebruiken.
// Voor meer info van serial print kijk zeker bij: https://www.arduino.cc/reference/en/language/functions/communication/serial/print/
int inputA = 4;
void setup()
{
pinMode(inputA, INPUT);
Serial.begin(115200); //Laat weten dat we een seriele verbinding willen opzetten met een baudrate van 115200.
}
void loop()
{
int inputAState = digitalRead(inputA);
Serial.print("input A:");
Serial.println(inputAState);
delay(50);
}
```
Laad de code in je bordje en open de serial monitor.
Verbind nu gpio pin **4** afwisselend met de 0V of 3.3V en merk op wat er gebeurt met de output in de serial monitor.
:::spoiler Verwachting
Als alles goed gaat veranderd de waarde van een logische 0 naar een 1 en terug.
:::
## Uitlezen digitale sensor
Om nu een digitale sensor uit te lezen kunnen we de code uit vorig voorbeeld gebruiken. Of als we de code een beetje herschrijven (naamgeving aanpassen) dan krijgen we:
```cpp
// Made by Bruce
// Dit is een voorbeeld van hoe je de digitale ingang kan gebruiken om een pir sensor uit te lezen.
int pirPin = 4; //pin van de pir out
void setup()
{
pinMode(pirPin, INPUT); //Stel deze pin in als INPUT
Serial.begin(115200); //Laat weten dat we een seriele verbinding willen opzetten met een baudrate van 115200.
}
void loop()
{
int pirState = digitalRead(pirPin); //bewaar de toestand van de PIR
Serial.print("input PIR:");
Serial.println(pirState); //print de toestand van de PIR
delay(50);
}
```
Neem bijvoorbeeld de PIR sensor uit het kitje en sluit deze aan op de ESP32 als volgt:
| PIR | ESP32 |
| -------- | -------- |
| GND | GND |
| OUT | Pin 4 |
| VCC | 3V3 |
Voor meer info over de aansluitingen kijk op de pagina van het [Elektronica kitje](/x8G1NvD3R_eiwZn9EBbPdg).
1. Draai de gevoeligheid op het midden.
2. Zet de delay zo kort mogelijk.
3. Zet de jumper op retrigger
Als je nu terug naar de seriele monitor kijkt zou je moeten zien dat er een logische één wordt geprint als er beweging is gedetecteerd.
## Aansturen digitale uitgangen
Sluit voor volgend programma een **LED** met **Voorschakelweerstand** aan op **PIN 5**. Gebruik de $1k\Omega$ weerstand uit je kitje in combinatie met een led naar keuze.
```cpp
// Made by Bruce
// Dit is een voorbeeld van hoe je de digitale uitgang kan gebruiken.
int ledPin = 5; //pin van de led
void setup()
{
pinMode(ledPin, OUTPUT); //Stel deze pin in als OUTPUT
}
void loop()
{
digitalWrite(ledPin, HIGH); //maak de led HOOG
delay(100);
digitalWrite(ledPin, LOW); //maak de led LAAG
delay(900);
}
```
## Digitale sensor koppelen aan een digitale uitgang
Als we de twee vorige voorbeelden combineren dan kunnen we een LED laten oplichten als er beweging is gedetecteerd.
```cpp
// Made by Bruce
// Dit is een voorbeeld van hoe je de digitale uitgang kan gebruiken.
//In combinatie met een digitale ingang.
int pirPin = 4; //pin van de pir out
int ledPin = 5; //pin van de led
void setup()
{
pinMode(pirPin, INPUT); //Stel deze pin in als INPUT
pinMode(ledPin, OUTPUT); //Stel deze pin in als OUTPUT
Serial.begin(115200); //Laat weten dat we een seriele verbinding willen opzetten met een baudrate van 115200.
}
void loop()
{
int pirState = digitalRead(pirPin); //bewaar de toestand van de PIR
Serial.print("input PIR:");
Serial.println(pirState); //print de toestand van de PIR
digitalWrite(ledPin, pirState); //maak de led hoog als de PIR beweging detecteerd
delay(50);
}
```
# Werken met Analoge ingangen en uitgangen
## Werken met analoge ingangen
Een analoge ingang kan een spanning tussen 0V en 3.3V uitlezen met een 12-bit ADC (analoog digitaal converter) 0V = 0; 3.3V = 4095. Dit kan enkel met bij ADC ingang. Je kan bijvoorbeeld de analogewaarde op ADC3 (GPIO39) uitlezen met volgend commando analogRead(39).
Voor volgende code sluiten we een potentiometer van $10k\Omega$ aan als spanningsdeler tussen GND en 3V3. De middenaftakking laten we naar de (SVN, GPIO39, ADC3) pin lopen.
```cpp
// Made by Bruce
// Dit is een voorbeeld van hoe je een analoge waarde kan uitlezen.
int potentioMeterPin = 39; //pin van de pir out
void setup()
{
Serial.begin(115200); //Laat weten dat we een seriele verbinding willen opzetten met een baudrate van 115200.
}
void loop()
{
int potState = analogRead(potentioMeterPin); //bewaar de toestand van de PIR
Serial.print("Analoge Waarde:");
Serial.println(potState); //print de toestand van de PIR
delay(50);
}
```
## PWM signaal maken
De makkelijkste manier om een led te dimmen is met een PWM signaal. Op het eerste zich is een PWM signaal maken iets moeilijker met een ESP32 dan met een Arduino. Maar deze kan ook veel meer.
```cpp
// Made by Bruce
// Dit is een voorbeeld van hoe je een led kan dimmen met een PWM signaal.
// Voor meer info kijk op: https://randomnerdtutorials.com/esp32-pwm-arduino-ide/
int ledPin = 5;
// setting PWM properties
const int freq = 5000; //frequentie van het PWM signaal
const int ledChannel = 0; //Het kanaal waarvan je het PWM signaal insteld
const int resolution = 12; //Resolutie van het PWM kanaal
int PWMvalue = 0;
void setup()
{
Serial.begin(115200); //Laat weten dat we een seriele verbinding willen opzetten met een baudrate van 115200.
// configure LED PWM functionalitites
ledcSetup(ledChannel, freq, resolution);
// attach the channel to the GPIO to be controlled
ledcAttachPin(ledPin, ledChannel); //Led pin aansturen met het geselecteerde PWM kanaal
}
void loop()
{
for (int i = 0; i < 4096; i++) {
PWMvalue = i;
Serial.print("PWMvalue:");
Serial.println(PWMvalue);
ledcWrite(ledChannel, PWMvalue);
delay(1);
}
for (int i = 4095; i > 0; i--) {
PWMvalue = i;
Serial.print("PWMvalue:");
Serial.println(PWMvalue);
ledcWrite(ledChannel, PWMvalue);
delay(1);
}
}
```
## Led dimmen (PWM) met potentiometer:
```cpp
// Made by Bruce
// Dit is een voorbeeld van hoe je een led kan dimmen met een potentio meter.
// Voor meer info kijk op: https://randomnerdtutorials.com/esp32-pwm-arduino-ide/
int potentioMeterPin = 39; //pin van de pir out
int ledPin = 5;
// setting PWM properties
const int freq = 5000;
const int ledChannel = 0;
const int resolution = 12;
void setup()
{
Serial.begin(115200); //Laat weten dat we een seriele verbinding willen opzetten met een baudrate van 115200.
//pinMode(ledPin, OUTPUT);
// configure LED PWM functionalitites
ledcSetup(ledChannel, freq, resolution);
// attach the channel to the GPIO to be controlled
ledcAttachPin(ledPin, ledChannel);
}
void loop()
{
int potState = analogRead(potentioMeterPin); //bewaar de toestand van de POT
Serial.print("Analoge Waarde:");
Serial.println(potState); //print de toestand van de POT
ledcWrite(ledChannel, potState);
delay(50);
}
```
## Buzzer
Er is ook een commando om een PWM kanaal te veranderen van frequentie.
```cpp
// Made by Bruce
// Dit is een voorbeeld van hoe met een PWM signaal een variabele frequentie op een piezo zoemer kan zetten om lawaai te maken.
int potentioMeterPin = 39; //pin van de pir out
int piezoPin = 5;
// setting PWM properties
const int freq = 5000;
const int piezoChannel = 0;
const int resolution = 12;
void setup()
{
Serial.begin(115200); //Laat weten dat we een seriele verbinding willen opzetten met een baudrate van 115200.
// configure LED PWM functionalitites
ledcSetup(piezoChannel, freq, resolution);
// attach the channel to the GPIO to be controlled
ledcAttachPin(piezoPin, piezoChannel);
}
void loop()
{
int potState = analogRead(potentioMeterPin) * 5; //Vermenigvuldig met 5 om tot 20kHz te kunnen gaan
Serial.print("Freq [Hz]:");
Serial.println(potState); //print de toestand van de POT
//ledcWrite(piezoChannel, potState);
ledcWriteTone(piezoChannel, potState);
delay(50);
}
```
# Werken met externe bibliotheken
## Uitlezen DHT11 Temperatuur en vochtigeheidsensor
Voor de DHT11 uit te lezen bestaan er al genoeg bibliotheken gemaakt door vriendelijke mensen op het internet. In dit geval kunnen we er maar beter gebruik van maken. Zodanig dat wij ons met coole dingen kunnen houden in plaats van dubbel werk te doen: 
En hier zelf een programma voor te schrijven.
### Instaleren externe bibliotheken:
Om de DHT sensor uit te lezen zullen we gebruik maken van de DHT library van Adafruit en de Adafruit Unified Sensor library.
Om deze te instaleren klik je op: Sketch > Include Library > Manage Libraries. De Library Manager is nu geopend.
Zoek naar “DHT” in het zoekveld en klik op install the DHT library from Adafruit.
Hierna zoek je naar “Adafruit Unified Sensor” In het zoekveld en instaleer je Adafruit Unified Sensor driver library.
Nu kan het nodig zijn de Arduino IDE te herstarten.
### Testen DHT11 sensor
Bouw volgend schema:
:::danger
Vergeet de pull-up weerstand niet.
:::
(bron: [randomnerdtutorials](https://randomnerdtutorials.com/esp32-dht11-dht22-temperature-humidity-sensor-arduino-ide/))
Programeer het bordje nu met volgende code en open de seriele monitor.
```cpp
// Example testing sketch for various DHT humidity/temperature sensors
// Written by ladyada, public domain
// Code changed by Bruce Helsen
// REQUIRES the following Arduino libraries:
// - DHT Sensor Library: https://github.com/adafruit/DHT-sensor-library
// - Adafruit Unified Sensor Lib: https://github.com/adafruit/Adafruit_Sensor
#include "DHT.h"
#define DHTPIN 4 // Digital pin connected to the DHT sensor
// Uncomment whatever type you're using!
#define DHTTYPE DHT11 // DHT 11
//#define DHTTYPE DHT22 // DHT 22 (AM2302), AM2321
//#define DHTTYPE DHT21 // DHT 21 (AM2301)
// Connect pin 1 (on the left) of the sensor to +5V
// NOTE: If using a board with 3.3V logic like an Arduino Due connect pin 1
// to 3.3V instead of 5V!
// Connect pin 2 of the sensor to whatever your DHTPIN is
// Connect pin 4 (on the right) of the sensor to GROUND
// Connect a 10K resistor from pin 2 (data) to pin 1 (power) of the sensor
DHT dht(DHTPIN, DHTTYPE);
void setup() {
Serial.begin(115200);
Serial.println(F("DHTxx test!"));
dht.begin();
}
void loop() {
// Wait a few seconds between measurements.
delay(1000);
// Reading temperature or humidity takes about 250 milliseconds!
// Sensor readings may also be up to 2 seconds 'old' (its a very slow sensor)
float h = dht.readHumidity();
// Read temperature as Celsius (the default)
float t = dht.readTemperature();
// Read temperature as Fahrenheit (isFahrenheit = true)
float f = dht.readTemperature(true);
// Check if any reads failed and exit early (to try again).
if (isnan(h) || isnan(t) || isnan(f)) {
Serial.println(F("Failed to read from DHT sensor!"));
return;
}
// Compute heat index in Fahrenheit (the default)
float hif = dht.computeHeatIndex(f, h);
// Compute heat index in Celsius (isFahreheit = false)
float hic = dht.computeHeatIndex(t, h, false);
Serial.print(F("Humidity: "));
Serial.print(h);
Serial.print(F("% Temperature: "));
Serial.print(t);
Serial.print(F("°C "));
Serial.print(f);
Serial.print(F("°F Heat index: "));
Serial.print(hic);
Serial.print(F("°C "));
Serial.print(hif);
Serial.println(F("°F"));
}
```
# Werken met functies
## Uitlezen afstand sensor
De afstand sensor is een ultrasone sensor deze stuurt een geluids puls en ontvangd de echo. Aan de hand van de tijd hiertussen kan berekend worden wat de afstand was. Hiervoor gebeuren wat berekeningen, om de code mooi te houden kunnen we een functie gebruiken op deze metingen in een lijn code uit te voeren.
Een klein probleem met deze sensor is dat deze de 5V versie is. En de echo pin zal dus een 5V puls terug sturen naar de ESP32 wat te veel is voor de ESP32. Om dit op te lossen zullen we werken met een spanningsdeler.
### Aansluitingen
### Voorbeeld programma
```cpp
// defines pins numbers
// Voorbeeld programma van hoe je met een functie kan werken om bijvoorbeeld
// Een ultrasone sensor uit te lezen
// SRF-05 LOLIN32
// Vcc ------------------------------> 5V
// Trig ------------------------------> 16
// Echo -> spanningsdeler 4K7 en 10K -> 39 (SVN)
// GND ------------------------------> GND
const int trigPin = 16;
const int echoPin = 39;
// defines variables
int distance;
void setup() {
pinMode(trigPin, OUTPUT); // Sets the trigPin as an Output
pinMode(echoPin, INPUT); // Sets the echoPin as an Input
Serial.begin(115200); // Starts the serial communication
}
void loop() {
distance = getDistanceCm();
// Prints the distance on the Serial Monitor
Serial.print("Distance: ");
Serial.println(distance);
delay(100);
}
int getDistanceCm() { //een functie die de meting uitvoert en de afstand returned.
long duration;
// Clears the trigPin
digitalWrite(trigPin, LOW);
delayMicroseconds(2);
// Sets the trigPin on HIGH state for 10 micro seconds
digitalWrite(trigPin, HIGH);
delayMicroseconds(10);
digitalWrite(trigPin, LOW);
// Reads the echoPin, returns the sound wave travel time in microseconds
duration = pulseIn(echoPin, HIGH); //pulseIn meet de tijd dat het duurt voor deze pin terug hoog wordt.
// Calculating the distance
return duration * 0.0343 / 2;
}
```
## Gebruik van de serial ploter
[Extra info](https://learn.adafruit.com/experimenters-guide-for-metro/circ08-using%20the%20arduino%20serial%20plotter)
Met de code van vorig voorbeeld kan je ook de gemeten afstand waarden laten plotten door de Serial Plotter, deze vind je onder TOOLS > Serial Plotter
# Gebruik van de OLED dispaly
## Installeren van extra bibliotheken
## Gebruik bibliotheek
In dit voorbeeld word een potentiometer als spanningsdeler tussen 3V3 en GND geschakeld en wordt de midden aftakking op pin 2 aangesloten.
```cpp
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
#define SCREEN_WIDTH 128
#define SCREEN_HEIGHT 64
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, -1);
void setup() {
// put your setup code here, to run once:
Serial.begin(115200);
// Start I2C Communication SDA = 5 and SCL = 4 on Wemos Lolin32 ESP32 with built-in SSD1306 OLED
Wire.begin(5, 4);
if (!display.begin(SSD1306_SWITCHCAPVCC, 0x3C, false, false)) {
Serial.println(F("SSD1306 allocation failed"));
for (;;);
}
// delay(2000); // Pause for 2 seconds
// Clear the buffer.
display.clearDisplay();
display.setTextSize(1);
display.setTextColor(WHITE);
display.setCursor(0, 10);
}
void loop() {
display.clearDisplay();
display.setCursor(0, 10);
// Display static text
display.print("Potentiometer: ");
display.println(analogRead(2));
display.display();
}
```
## Etch A Sketch
```cpp
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
#define SCREEN_WIDTH 128
#define SCREEN_HEIGHT 64
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, -1);
void setup() {
// put your setup code here, to run once:
Serial.begin(115200);
// Start I2C Communication SDA = 5 and SCL = 4 on Wemos Lolin32 ESP32 with built-in SSD1306 OLED
Wire.begin(5, 4);
if (!display.begin(SSD1306_SWITCHCAPVCC, 0x3C, false, false)) {
Serial.println(F("SSD1306 allocation failed"));
for (;;);
}
// delay(2000); // Pause for 2 seconds
// Clear the buffer.
display.clearDisplay();
display.setTextSize(1);
display.setTextColor(WHITE);
display.setCursor(0, 10);
// Display static text
display.println("Hello, world!");
display.display();
display.clearDisplay();
}
void loop() {
display.drawPixel(analogRead(14)*(SCREEN_WIDTH-1)/4095, analogRead(2)*(SCREEN_HEIGHT-1)/4095, WHITE);
display.display();
}
```
Google Drive
Gist
Clipboard
Sign in with Wallet
