Everything I discuss here has basically been described more than once by someone else. So, why another article on this topic? It is an attempt to summarize the basic functions, peculiarities and stumbling blocks in a single post. In particular, I am addressing Arduino users who want to get into the ESP32. But maybe also the ESP32-experienced will find one or the other interesting information here.<\/p>\r\n\r\n
In my explanations and examples, I mainly refer to the widely used ESP32-WROOM-32, or the boards based on it. However, most of it can be applied to other ESP32 boards, such as the ESP32-PICO.<\/p>\n\n
The article has become quite long – here you can jump to the sections:<\/p>\r\n
- \r\n
- ESP32 Boards<\/a><\/li>\r\n
- Features of the ESP32-WROOM-32<\/a><\/li>\r\n
- Integration of the ESP32 into the Arduino IDE<\/a><\/li>\r\n
- Pinout of the ESP32 Development Board<\/a><\/li>\r\n
- Digital inputs\/outputs<\/a><\/li>\r\n
- Analog inputs\/outputs<\/a><\/li>\r\n
- Pulse Width Modulation (PWM)<\/a><\/li>\r\n
- I2C<\/a><\/li>\r\n
- SPI<\/a><\/li>\r\n
- Serial Interfaces (UART)<\/a><\/li>\r\n
- Touch Pins<\/a><\/li>\r\n
- Hall Sensor<\/a><\/li>\r\n
- Interrupts<\/a><\/li>\r\n
- Saving power \/ Sleep modes<\/a><\/li>\r\n
- WiFi<\/a><\/li>\r\n
- Bluetooth<\/a><\/li>\r\n
- Exotic pin functions<\/a><\/a><\/li>\r\n
- The APIs (Application Programming Interfaces)<\/a><\/li>\r\n<\/ul>\r\n\n
ESP32 Boards<\/h2>\n\n
\n\n ![\"\"](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2021\/07\/ESP32.jpg\")
<\/a>Dev Module <\/figcaption><\/figure>\n\n\n\n ![\"\"](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2021\/07\/ESP32_Ard_Style.jpg\")
<\/a>D1 R32<\/figcaption><\/figure>\n\n\n\n ![\"\"](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2021\/07\/ESP32_small.jpg\")
<\/a>Mini Board<\/figcaption><\/figure>\n\n\n\n ![\"\"](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2021\/07\/ESP32_pico.jpg\")
<\/a>Pico Kit<\/figcaption><\/figure>\n<\/figure>\n\n\n\n There are various ESP32 boards. Most are based on the ESP32-WROOM-32. Very popular are the development boards like the model shown above left. However, it has a width that is not ideal for breadboards because you only have space left on one side for jumper cables (see below). If you place two breadboards next to each other, the modules will not be wide enough to bridge the +\/- bars. This may be a luxury problem, but it’s annoying. As a solution, I recommend multi-breadboards that have only one +\/- bar between each board.<\/p>\r\n<\/div><\/div>\n
\n![\"Not](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2021\/07\/ESP32_on_breadboard-1024x442.jpg\")
<\/a>Not all ESP32 modules harmonize in size with all breadboards<\/figcaption><\/figure>\n<\/div>\n Alternatively, you can also use the “Arduino UNO-like” D1 R32 board. Or you can take an ESP32 Pico because it is a bit smaller.<\/a><\/p>\r\n\n
Features of the ESP32-WROOM-32<\/h2>\n\n
The performance of the ESP32 boards makes AVR-based Arduinos like the UNO look old. The four to twelve times higher clock rate and a comparatively huge flash memory are another dimension. A clear advantage for the Arduino (AVR) boards, however, is that the underlying microcontrollers can be easily operated standalone<\/a>. This allows space and energy saving projects to be realized. Wiring a bare ESP32, on the other hand, is not necessarily what most people like.<\/p>\r\n
Here is an overview of the most important data of the ESP32-WROOM-32:<\/p>\r\n
- \r\n
- Operating voltage<\/strong>: 3.3 volts<\/li>\r\n
- Power consumption<\/strong>: 1\u03bcA (hibernation) to max ~240 mA\r\n
- \r\n
- the power consumption depends on the mode and the activated components<\/li>\r\n
- in normal operation without WiFi and Bluetooth: approx. 50-70 mA<\/li>\r\n<\/ul>\r\n<\/li>\r\n
- Clock rate<\/strong> up to 240 MHz<\/li>\r\n
- 520 kByte internal SRAM<\/strong> (for data and commands)<\/li>\r\n
- External flash memory<\/strong> up to 16 MByte\r\n
- \r\n
- most modules have 4 MByte memory, of which about 1 MByte “for free use”<\/li>\r\n<\/ul>\r\n<\/li>\r\n
- 34 inputs\/outputs<\/strong>:\r\n
- \r\n
- usable: 22 GPIOs, 4 GPIs (input only)<\/li>\r\n
- some have certain limitations<\/li>\r\n<\/ul>\r\n<\/li>\r\n
- 2 I2C<\/strong> interfaces<\/li>\r\n
- 2 usable SPI<\/strong> interfaces<\/li>\r\n
- 3 UART<\/strong> interfaces<\/li>\r\n
- Real time clock<\/strong><\/li>\r\n
- 10 touch sensors<\/strong><\/li>\r\n
- Integrated Hall sensor<\/strong><\/li>\r\n
- 16 PWM<\/strong> channels<\/li>\r\n
- 2 “real” analog outputs<\/strong><\/li>\r\n
- Up to 18 analog inputs<\/strong><\/li>\r\n
- WiFi:<\/strong> 802.11 b\/g\/n 2.4 GHz<\/li>\r\n
- Bluetooth<\/strong>: 4.2 \/ BLE (Bluetooth Low Energy)<\/a><\/li>\r\n<\/ul>\r\n\n
Integration of the ESP32 into the Arduino IDE<\/h2>\n\n
How to make the Arduino IDE ESP32-capable has been described endlessly. Therefore, I will be brief.<\/p>\r\n
- \r\n
- In the Arduino IDE, go to File – > Preferences.<\/li>\r\n
- There you click on the small icon behind “Additional Boards Manager URLs”.<\/li>\r\n
- Enter “https:\/\/dl.espressif.com\/dl\/package_esp32_index.json” as a separate line (without quotation marks).<\/li>\r\n
- Go to Tools – > Board – > Boards Manager.<\/li>\r\n
- Search for “esp32” and install “esp32 by Espressif Systems”.<\/li>\r\n
- You may need to restart the Arduino IDE.<\/li>\r\n<\/ol>\r\n
After installation you will find several dozen ESP32 boards to choose from. You have to see which one fits. The “ESP32 Dev Module” is widely used. <\/a><\/p>\r\n\n
Pinout of the ESP32 Development Board<\/h2>\n\n
There are different versions of ESP32-WROOM-32 based boards. This means that the pins on your board may be arranged differently, and some pins may also be missing. But what always matches is the multiple function of the pins. This means, for example, that GPIO4 is always HSPI_HD, ADC2_CH0, TOUCH_0 and RTC_IO 10.<\/p>\r\n\n
![\"Pins](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2021\/06\/ESP32_dev_board_pinout-1024x497.jpg\")
<\/a>Pins of the ESP32 Development Board<\/figcaption><\/figure>\n\n “Forbidden” \/ Restricted Pins<\/h3>\n\n
Some pins have certain restrictions, others should be left unconnected. The latter group includes the pins GPIO6 to GPIO11<\/strong>. They are used internally for SPI communication with the flash memory. That is why I have marked them in grey. Just ignore them.<\/p>\r\n
While the ESP32 boots, some of its pins send PWM signals or go into HIGH state for short time. Depending on what you attach to the pins, this can interfere, but it does not have to. These are the pins GPIO0, GPIO1, GPIO3, GPIO5, GPIO14 and GPIO15<\/strong>.<\/p>\r\n
GPIO0, GPIO2, GPIO4, GPIO5, GPIO12 and GPIO15 <\/strong>are so-called “strapping pins” that bring the ESP32 into bootloader or flash mode while booting. If you connect something to it during boot which pull the pins into the HIGH or LOW state, this can lead to unexpected behavior. You may know this from the GPIO0 pin of the ESP8266 ESP-01<\/a>.<\/p>\r\n
The ADC2_CHx<\/strong> pins cannot be used as analog inputs when WiFi is active.<\/a><\/p>\r\n\n
Digital inputs\/outputs of the ESP32<\/h2>\n\n
Using the GPIOs as digital inputs and outputs works essentially the same as with the Arduino with the functions
pinMode()<\/code> ,digitalWrite()<\/code> anddigitalRead()<\/code>. If you normally work with Arduino (AVR) boards, you have to get used to the lower voltage of 3.3 volts. The maximum current should not exceed 12 mA.<\/p>\r\nThere is an important difference to the Arduino in the operation of the GPIOs as an input. To achieve a LOW level at a pin when using
pinMode(pin, INPUT)<\/code>, you must use an external pull-down resistor with the Arduino. With the ESP32, however, you can connect an internal pull-down resistor viaINPUT_PULLDOWN<\/code>. If you just chooseINPUT<\/code>, then the pin level is undefined.<\/p>\r\nThe pins GPIO34-39 are pure inputs, which is why the name GPI is more appropriate. In addition, there is no internal pull-up or pull-down resistor available on these pins.<\/a><\/p>\r\n\n
Analog inputs\/outputs of the ESP32<\/h2>\n\n
Analog inputs<\/h3>\n\n
The ESP32 has two A\/D converters with a resolution of 12 bits. The ADC1 and ADC2 inputs each share one A\/D converter. With
analogRead(pin)<\/code> you read the measured values like with the Arduino. The voltage U is (theoretically):<\/p>\r\n\n<\/p>\r\n
<\/span> <\/span>
![\"\[](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/ql-cache\/quicklatex.com-0cb85d05dca5b0189ddde7c120cbac41_l3.png\" "\\"Rendered")
<\/p><\/p>\r\n\nAs excellent as the ESP32’s performance is otherwise, the A\/D converters definitely are not:<\/p>\r\n
- \r\n
- The scatter of the measured values is very high.<\/li>\r\n
- Even worse, the results are not linear.<\/li>\r\n<\/ol>\r\n
The scatter is something you can get under control. Espressif recommends (here<\/a>) connecting a 0.1 \u00b5F capacitor to the input and averaging the readings. Without a capacitor, I had to average 500 – 1000 readings to get the variation below 0.01 volts.<\/p>\r\n
The non-linearity is a bigger problem. I have checked this out and my findings are consistent with what I have found in other articles:<\/p>\r\n
\n![\"ESP32](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2021\/06\/ADC_ESP32_reliability-1024x626.png\")
<\/a>ESP32 A\/D Converter Readings vs. Actual Voltage<\/figcaption><\/figure>\n<\/div>\n Some people recommend using “look-up” tables to compensate for the error (e.g. here<\/a> on GitHub), others recommend regression polynomials (e.g. here<\/a>). If you need accurate readings, I recommend using a reasonable external A\/D converter like the ADS1115<\/a>.<\/p>\r\n\n
Analog outputs<\/h3>\n\n
analogWrite()<\/h4>\n\n
The
analogWrite()<\/code> function is available at all output pins. As you are used to with the Arduino, values between 0 and 255 are available. The underlying PWM frequency is 1 kHz. <\/p>\r\n\nThe dacWrite function<\/h4>\n\n
In addition to
analogWrite()<\/code>, you can usedacWrite()<\/code> on the ESP32. It provides a true analog signal between 0 and 3.3 volts, which can be output at the two DAC pins. To call the function:<\/p>\r\ndacWrite(pin, value)<\/code> with pin = 25 or 26 and value = 0, 1, 2 …. 255.<\/p>\r\nTheoretically, the voltage U is:<\/p>\r\n\n
<\/span> <\/span>
![\"\[](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/ql-cache\/quicklatex.com-39d6d09d0fe7d789cb7d4901d66b83be_l3.png\" "\\"Rendered")
<\/p><\/p>\r\n\nPractically, it looks like this:<\/p>\r\n
\n![\"Theoretical](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2021\/06\/DAC_ESP32__reliability-1024x608.png\")
<\/a>Theoretical and actual voltage at the DAC pins<\/figcaption><\/figure>\n<\/div>\n The minimum value in my measurements was 0.086 volts, the maximum value was 3.18 volts. After all, the slope is largely linear, so you can apply a calibration line.<\/a><\/p>\r\n\n
Pulse Width Modulation (PWM)<\/h2>\n\n
A detailed introduction to pulse width modulation (PWM) would go beyond the scope of this article. In a nutshell: PWM is used, among other things, to control servo motors or to dim LEDs. A PWM signal is a square wave signal with a defined frequency (= 1\/period) and a defined duty cycle. Here is an example of a signal with 25% duty cycle:<\/p>\r\n\n
![\"\"](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2021\/06\/PWM_scheme_dc25-1024x416.png\")
<\/a>PWM signal with 25% duty cycle<\/figcaption><\/figure>\n\n The ESP32 has 16 PWM channels that can be assigned to the GPIO pins. However, the inputs GPI32 – GPI39 cannot be used for PWM. The basic setting of the PWM signal is applied with
edcAttach(pin, freq, res)<\/code>.pin<\/code> is the GPIO-Pin,freq<\/code> is the frequency andres<\/code> is the resolution in bit. Alternatively, you set the channel yourself withledcAttachChannel(pin, freq, res, channel)<\/code>.<\/p>\r\nYou start the signal output and set the duty cycle with
ledcWrite(pin, dutyCycle)<\/code>. The duty cycle in percent is dutyCycle\/2res<\/sup> x 100.\r\n<\/p>\r\nHere is a small example sketch that periodically dims and lights up an LED attached to GPIO18.<\/p>\r\n\n
const int pwmPin = 18; \/\/ = GPIO18\r\nconst int freq = 1000;\r\nconst int pwmChannel = 0; \/\/ choose 0 - 15\r\nconst int res = 8; \/\/ 2^8 = 256\r\n \r\nvoid setup(){\r\n ledcAttach(pwmPin, freq, res); \/\/ channel is chosen automatically\r\n \/\/ ledcAttachChannel(pwmPin, freq, res, pwmChannel); \/\/ choose channel youself\r\n}\r\n \r\nvoid loop(){\r\n for(int dutyCycle = 0; dutyCycle <= 256; dutyCycle++){ \r\n ledcWrite(pwmPin, dutyCycle);\r\n delay(3);\r\n }\r\n for(int dutyCycle = 256; dutyCycle >= 0; dutyCycle--){\r\n ledcWrite(pwmPin, dutyCycle); \r\n delay(3);\r\n }\r\n}<\/pre>\r\n\nNow I briefly come back to the
analogWrite()<\/code> function. When using an Arduino,analogWrite()<\/code> generates a PWM signal of 490 Hz and a resolution of 8 bits on most pins (see here<\/a> on the Arduino pages). WithledcAttach(pin, 490, 8)<\/code>, you can easily do the same.<\/p>\r\n\nMaximum PWM resolution and frequency<\/h3>\n\n
You can select values between 1 and 15 bits as resolution. The resolution and the internal timer frequency (80 MHz) determine the maximum frequency of the PWM signal:<\/p>\r\n\n
<\/span> <\/span>
![\"\[](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/ql-cache\/quicklatex.com-622d38fcdb10280401ecfbb0efc30c28_l3.png\" "\\"Rendered")
<\/p><\/p>\r\n\nAs an extreme example, you choose a resolution of one bit. This sets the duty cycle to 50% and the maximum frequency is 40 MHz. In this range, my oscilloscope is at its limit and therefore the signal is not very sharp. <\/p>\r\n\n
![\"PWM](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2021\/07\/pwm_40mhz_78_125_khz-1024x324.png\")
<\/a>PWM with the ESP32 – left: 78125 Hz, right: 40 MHz, Duty Cyle: 50%<\/figcaption><\/figure>\n\n A friendly reader (thanks to Stefan Gro\u00df), has measured the signal with his more professional equipment (active probe, 1 GHz, 10:1): <\/a><\/p>\r\n
\n![\"40](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2022\/01\/RT-ZS10L_kurzer-GND-Anschluss.png\")
<\/a>40 MHz PWM – measured with a better oscilloscope<\/figcaption><\/figure>\n<\/div>\n Using the I2C interfaces of the ESP32<\/h2>\n\n
In contrast to the Arduino (UNO), the ESP32 has two I2C interfaces. The standard interface is assigned to GPIO21 and GPIO22. If you use the default, the operation is the same as with the Arduino. This means that you include the
Wire.h<\/code> library and use its functions as usual.<\/p>\r\nBut you have to keep in mind that the ESP32 voltage is 3.3 volts. If you connect a 5 volt device via I2C, you should apply a level shifter or voltage divider. Of course, this also applies to SPI and UART. The pins are not tolerant to 5 volts.<\/p>\r\n
Another difference is that you can assign the I2C interface to other GPIOs. How to do this, how to use the second I2C interface and how to pass the corresponding TwoWire objects to other objects, I have described here<\/a> in great detail. That is why I will not go into it in more detail.<\/a><\/p>\r\n\n
Using the SPI interfaces of the ESP32<\/h2>\n\n
The ESP32 has a total of four SPI interfaces. However, only two of them are available to you, namely VSPI and HSPI. The other two SPI interfaces are used internally. VSPI is the default SPI interface. It is assigned to the GPIOs 18 (VSPI_CLK), 19 (VSPI_MISO), 23 (VSPI_MOSI) and 5 (VSPI_CS = Chip Select). If you use VSPI, it is very similar to the Arduino. You include
SPI.h<\/code> and use functions of this class as usual. Although the interface is called V<\/strong>SPI, the object is called SPI.<\/p>\r\nIf you want to use HSPI, then you first have to create the corresponding SPI object. Here is a simple little example. I attached two MPU9250 modules to HSPI and VSPI. I used Bolderflight’s MPU9250 library which can be found here<\/a> on GitHub. But you don’t really have to deal with it. Just look at the first lines since they show the principle. <\/p>\r\n\n
\r\n#include \"MPU9250.h\"\r\n#include \"SPI.h\"\r\n\r\nSPIClass SPI_2(HSPI); \/\/ create SPI_2 object\r\nMPU9250 IMU_1(SPI,5); \/\/ pass standard SPI object (VSPI) and Chip Select\r\nMPU9250 IMU_2(SPI_2,15); \/\/ pass SPI_2 object (HSPI) and Chip Select\r\n\r\nint status;\r\n\r\nvoid setup() {\r\n Serial.begin(115200);\r\n \r\n status = IMU_1.begin();\r\n if (status < 0) {\r\n Serial.println(\"IMU 1 initialization unsuccessful\");\r\n while(1) {}\r\n }\r\n status = IMU_2.begin();\r\n if (status < 0) {\r\n Serial.println(\"IMU 2 initialization unsuccessful\");\r\n while(1) {}\r\n } \r\n}\r\n\r\nvoid loop() {\r\n IMU_1.readSensor();\r\n Serial.println(\"IMU 1 Acceleration Data:\");\r\n Serial.print(IMU_1.getAccelX_mss(),6);\r\n Serial.print(\"\\t\");\r\n Serial.print(IMU_1.getAccelY_mss(),6);\r\n Serial.print(\"\\t\");\r\n Serial.println(IMU_1.getAccelZ_mss(),6);\r\n\r\n IMU_2.readSensor();\r\n Serial.println(\"IMU 2 Acceleration Data:\");\r\n Serial.print(IMU_2.getAccelX_mss(),6);\r\n Serial.print(\"\\t\");\r\n Serial.print(IMU_2.getAccelY_mss(),6);\r\n Serial.print(\"\\t\");\r\n Serial.println(IMU_2.getAccelZ_mss(),6);\r\n \r\n delay(1000);\r\n}<\/pre>\r\n<\/p>\r\n<\/div>\r\n\n
Changing the default SPI pins<\/h3>\n\n
You can also assign VSPI and HSPI to other pins. A detailed sketch can be found here on GitHub<\/a>.<\/a><\/p>\r\n\n
Using the UART (Serial) interface with the ESP32<\/h2>\n\n
The ESP32 has three serial interfaces called U0UXD, U1UXD and U2UXD. The three interfaces are assigned to the following pins:<\/p>\r\n\n
![\"Preset](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2023\/09\/ESP32_UART_eng-1024x162.png\")
<\/a>Preset for the UART pins of the ESP32<\/figcaption><\/figure>\n\n U0UXD is the default serial interface. It is used, among other things, for output to the serial monitor. It is initialized with
Serial.begin(baud rate)<\/code> as usual. If you want to use U1UXD and U2UXD, then you determine its properties withSerialx.begin(baud rate, protocol, RXPin, TXPin)<\/code> (with x = 1 or 2). If you call the begin function only with the baud rate parameter, the default settings apply.<\/p>\r\nVery theoretical, but with the example, it should become clear:<\/p>\r\n\n
#define RX1 16\r\n#define TX1 17\r\n#define RX2 12\r\n#define TX2 13\r\n\r\nvoid setup() {\r\n Serial.begin(115200);\r\n Serial1.begin(115200, SERIAL_8N1, RX1, TX1);\r\n Serial2.begin(115200, SERIAL_8N1, RX2, TX2);\r\n delay(100);\r\n if(Serial1){\r\n Serial.println(\"Serial1 successfully set up\");\r\n }\r\n if(Serial2){\r\n Serial.println(\"Serial2 successfully set up\");\r\n }\r\n}\r\n\r\nvoid loop(){}<\/pre>\r\n<\/p>\r\n\n
SERIAL_8N1 means: 8 bits, no parity (N = no), 1 stop bit. That’s the standard. I found a collection of possible protocol parameters here on GitHub<\/a>.<\/p>\r\n
You can also change the pins for the default interface using the same function:
Serial.begin(baud rate, protocoll, RXPin, TXPin)<\/code>.<\/a><\/p>\r\n\nTouch Pins<\/h2>\n\n
The touch pins of the ESP32 are capacitance sensitive. The larger the capacitance, the smaller the measured value. Since the human body has also a capacitance, the pins react to touch. The small example sketch shows how it works:<\/p>\r\n\n
void setup() {\r\n Serial.begin(9600);\r\n while(!Serial){} \r\n Serial.println(\"ESP32 Touch Test\");\r\n}\r\n\r\nvoid loop() {\r\n Serial.println(touchRead(4)); \/\/ get value of Touch 0 pin = GPIO 4\r\n \/\/Serial.println(touchRead(T0)); \/\/ alternative \r\n delay(1000);\r\n}<\/pre>\r\n<\/p>\r\n\n
I connected the touch pin to a jumper cable and left the loose end of the cable untouched at first, then touched it and then connected it to a 10 \u03bcF capacitor. This is what the output looked like:<\/a><\/p>\r\n\n
![\"Output](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2021\/07\/Touch.png\")
Output of ESP32_touch_test.ino<\/figcaption><\/figure>\n\n Hall Sensor<\/h2>\n\n
In case you have read somewhere about the hall sensor function
hallRead()<\/code> somewhere: It is no longer supported. The hall sensor wasn’t particularly good, but support didn’t necessarily have to be removed. <\/a><\/p>\r\n\nInterrupts<\/h2>\n\n
As for the interrupt programming of the ESP32, I could fill an entire article. Therefore I will only deal with external GPIO interrupts.<\/p>\r\n
You can set up interrupts on any GPIO pin, including the input pins GPI34 – GPI39. The handling is the similar to the Arduino boards, except for one special feature. If you use the attribute IRAM_ATTR in the Interrupt Service Routine (ISR), the code is not stored in flash memory, but in RAM. This makes the execution much faster. You have to place the ISR function before
setup()<\/code> (at least that’s how it is in the Arduino IDE). It may sound complicated, but it’s not.<\/p>\r\nIn my short example, a push of a button provides a HIGH signal to GPIO4. This triggers the interrupt. First, the highly complex \ud83d\ude09 circuit:<\/p>\r\n
\n![\"ESP32](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2021\/07\/interrupt_test.png\")
<\/a>Interrupt test on GPIO4<\/figcaption><\/figure>\n<\/div>\n Here’s the sketch:<\/p>\r\n\n
int interruptPin = 4; \/\/ define GPIO4 as interrupt pin\r\nvolatile bool event = false;\r\n\r\nvoid IRAM_ATTR eventISR(){\r\n event = true;\r\n detachInterrupt(interruptPin);\r\n}\r\n\r\nvoid setup() {\r\n Serial.begin(115200);\r\n while(!Serial){}\r\n pinMode(interruptPin, INPUT_PULLDOWN);\r\n attachInterrupt(interruptPin, eventISR, RISING);\r\n}\r\n\r\nvoid loop() {\r\n if(event){\r\n Serial.println(\"Interrupt!\");\r\n delay(1000); \/\/debouncing\r\n event = false;\r\n attachInterrupt(interruptPin, eventISR, RISING); \r\n }\r\n}<\/pre>\r\n<\/p>\r\n\n
You can also easily define multiple interrupts. Would be a nice exercise for you, wouldn’t it?<\/a><\/p>\r\n\n
Saving Power – Sleep Modes<\/h2>\n\n
The ESP32 is as powerful as it is power hungry. This can be a problem with battery-powered projects. However, there are ways to reduce power consumption to a fraction. First, you can turn off certain components. The biggest power consumers are WiFi and Bluetooth. If you use them, you should turn them off in between if possible. For this purpose, you can use
WiFi.mode(WIFI_OFF)<\/code> andbtStop()<\/code>. In addition, there are different sleep modes you can choose from.<\/p>\r\nI want to limit the length of this article, so I will only briefly discuss light sleep and deep sleep. With
esp_sleep_enable_timer_wakeup()<\/code> you define a sleep phase, after which the ESP32 wakes up again. As parameter, you pass the time in microseconds. But only when you callesp_deep_sleep_start()<\/code> oresp_light_sleep_start()<\/code>, the sleep phase begins.<\/p>\r\nAfter light sleep, the program continues where it stopped. After deep sleep, it restarts. You can try this out with the following sketch:<\/p>\r\n\n
const int unsigned long microSecToSec = 1000000;\r\nconst int sleepTime = 5; \r\n\r\nvoid setup(){\r\n Serial.begin(115200);\r\n while(!Serial){}\r\n\r\n esp_sleep_enable_timer_wakeup(sleepTime * microSecToSec);\r\n Serial.println();\r\n Serial.println(\"ESP32 will go to sleep for 5 seconds....\");\r\n delay(2000);\r\n Serial.println(\"...now\");\r\n esp_deep_sleep_start();\r\n \/\/esp_light_sleep_start(); \r\n Serial.println(\"This message will only be printed after light sleep\");\r\n}\r\n\r\nvoid loop(){ \r\n}<\/pre>\r\n<\/p>\r\n\n
Wake up via external signal<\/h3>\n\n
You can also wake up the ESP32 via external signals on one of the RTC_IO pins. You set that up with
esp_sleep_enable_ext0_wakeup(GPIO_NUM_x, HIGH\/LOW)<\/code>. The function expects the pin number in the format “GPIO_NUM_x” as the first argument. If you pass an integer instead, there will be an error message. The second parameter determines whether the wake-up signal is a HIGH or a LOW.<\/p>\r\n\nvoid setup(){\r\n Serial.begin(115200);\r\n while(!Serial){};\r\n pinMode(GPIO_NUM_4, INPUT_PULLDOWN); \r\n Serial.println();\r\n esp_sleep_enable_ext0_wakeup(GPIO_NUM_4,1);\r\n Serial.println(\"ESP32 will go to deep sleep...\");\r\n delay(1000);\r\n Serial.println(\"...now\");\r\n esp_deep_sleep_start(); \/\/\r\n Serial.println(\"This message will only be printed after light sleep\");\r\n}\r\n\r\nvoid loop(){ \r\n}<\/pre>\r\n<\/p>\r\n\n
Waking up with Touch<\/h3>\n\n
You control waking up by touch with the
esp_sleep_enable_touchpad_wakeup()<\/code> function. Before that, however, you have to set up a touch interrupt. Here’s how:<\/p>\r\n\n#define THRESHOLD 40\r\nvoid callback(){}\r\n\r\nvoid setup(){\r\n Serial.begin(115200);\r\n delay(1000);\r\n touchAttachInterrupt(T4, callback, THRESHOLD); \/\/T4 = GPIO13\r\n esp_sleep_enable_touchpad_wakeup();\r\n Serial.println(\"Going to deep sleep...\");\r\n delay(1000);\r\n Serial.println(\"...now\");\r\n esp_deep_sleep_start();\r\n}\r\n\r\nvoid loop(){\r\n}<\/pre>\r\n<\/p>\r\n\n
So, all you have to do is touch the GPIO13 (easiest via a jumper cable) and the ESP32 will wake up. If you want, you can add further commands to
callback(){}<\/code>. Of course, the touch interrupt also works without an alarm function. <\/a><\/p>\r\n\nWiFi<\/h2>\n\n
The use of WiFi is a quite complex topic. Therefore, I have covered this in a separate article. You find it
- 2 usable SPI<\/strong> interfaces<\/li>\r\n
- 520 kByte internal SRAM<\/strong> (for data and commands)<\/li>\r\n
- Power consumption<\/strong>: 1\u03bcA (hibernation) to max ~240 mA\r\n
- Features of the ESP32-WROOM-32<\/a><\/li>\r\n