I will cover the following topics:<\/p>\n\n
- \r\n
- Short repetition: how to switch GPIOs<\/a><\/li>\r\n
- Reading the ADCs<\/a><\/li>\r\n
- Pulse width modulation<\/a><\/li>\r\n
- Analog pins<\/a><\/li>\r\n
- Time functions<\/a><\/li>\r\n
- External interrupts<\/a><\/li>\r\n
- Timer<\/a><\/li>\r\n<\/ul>\r\n<\/div>\n\n\n\n
\n- \r\n
- I2C<\/a><\/li>\r\n
- Adding external modules<\/a><\/li>\r\n
- SPI<\/a><\/li>\r\n
- UART<\/a><\/li>\r\n
- Deep and light sleep<\/a><\/li>\r\n
- Touch pins<\/a><\/li>\r\n
- Hall sensor<\/a><\/li>\r\n<\/ul>\r\n<\/div>\n<\/div>\n\n
I will only very briefly discuss Wi-Fi and Bluetooth<\/a>.<\/p>\r\n\n
Pinout of the ESP32<\/h2>\n\n
I have explained the pins of the ESP32 and their functions in detail here<\/a>. The pinout is:<\/p>\r\n\n
![\"Pinout](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2021\/09\/ESP32_mPython-1024x497.png\")
<\/a>Pinout of the ESP32 with MicroPython<\/figcaption><\/figure>\n\n The only difference to the pin assignment in the Arduino implementation is the position of the I2C pins. <\/a><\/p>\r\n\n
Short repetition: Switching and reading the GPIOs<\/h2>\n\n
Since I covered switching of GPIOs in detail in the last post, there is only a compact repetition here. A simple blink program on the ESP32 with MicroPython looks like this:<\/p>\r\n\n
from machine import Pin\r\nfrom time import sleep\r\nled = Pin(18, Pin.OUT)\r\nwhile True:\r\n led.value(not led.value())\r\n sleep(0.5)<\/pre>\r\n\n
The big difference to C++ is that the pins are defined as objects. Whether a pin acts as input or output is determined with
Pin.OUT<\/code> orPin.IN<\/code>. You can read the GPIO level withpinname.value()<\/code>. You can switch the pin usingpinname.value(0\/1)<\/code>. In addition, you can connect internal pull-up or pull-down resistors if they are available at the respective pin. You would define a pin for reading a button state like this:<\/p>\r\nbuttonPin = Pin(18, Pin.IN, Pin.PULL_DOWN) # button Pin = GPIO18<\/code> <\/a><\/p>\r\n\nRead the ADCs of the ESP32 with MicroPython<\/h2>\n\n
First of all: As powerful as the ESP32 is, as bad are its A\/D converters. They generate quite a bit of noise, and what’s worse, they are not linear. I have described this in detail here<\/a>. <\/p>\r\n
Now for the code:<\/p>\r\n\n
from machine import ADC, Pin\r\nfrom time import sleep\r\n\r\nadc = ADC(Pin(32)) \r\n\r\nadc.atten(ADC.ATTN_11DB) # ATTN_11DB, ATTN_6DB, ATTN_2_5DB, ATTN_0DB (default)\r\nadc.width(ADC.WIDTH_12BIT) # WIDTH_12BIT (default), WITDTH_11BIT, WIDTH_10BIT, WIDTH_9BIT\r\n\r\nwhile True:\r\n val = adc.read()\r\n print(\"Raw ADC value:\", val)\r\n sleep(1)<\/pre>\r\n\n
In order to use a pin as an A\/D converter input, you first create an object. The default resolution is 12 bits. Alternatively, you can set with
adc.width()<\/code> 11, 10 or 9 bits. Withadc.atten(ADC.ATTN_XDB)<\/code> you set the attenuation and thus determine the input voltage range:<\/p>\r\n\n![\"Parameter](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2021\/08\/ADC_atten_ESP32.png\")
<\/a>Parameter selection for attenuation <\/figcaption><\/figure>\n\n This data is from the MicroPython Quick Reference<\/a>. In my own measurements, the A\/D converter overflowed in the maximum range at about 3.15 volts.<\/a><\/p>\r\n\n
Pulse width modulation<\/h2>\n\n
To produce pulse width modulation (PWM), you create a PWM object for a specific pin and pass the frequency and duty cycle. With the Arduino implementation of the ESP32 you can set the resolution (see here<\/a>). If you program the ESP32 with MicroPython, only 10 bit resolution is available (0-1023). Here is an example:<\/p>\r\n\n
from machine import Pin, PWM\r\n\r\npwm16 = PWM(Pin(16)) # create PWM object from GPIO 16\r\npwm16.freq(1000) # 1 kHz\r\npwm16.duty(256) # duty cycle = 256\/1024 * 100 = 25%\r\n\r\n# pwm16 = PWM(Pin(16), freq=1000, duty=256) # short Version<\/pre>\r\n\n
Other functions are:<\/p>\r\n\n
pwm16.freq() # get current frequency\r\npwm16.duty() # get current duty cycle\r\npwm16.deinit() # turn off PWM on the pin<\/pre>\r\n\n
The maximum PWM frequency is 40 MHz. However, due to the timer frequency of the ESP32 (80 MHz), you only get the full 10 bit resolution up to the following PWM frequency: <\/p>\r\n\n
<\/p>\r\n
<\/span> <\/span>
![\"\[](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/ql-cache\/quicklatex.com-fd0abfe2f4cc6b377d2aec37832c6cf6_l3.png\" "\\"Rendered")
<\/p><\/p>\r\n\nFor larger frequencies, you can calculate the actual resolution as follows:<\/p>\r\n\n
<\/span> <\/span>
![\"\[](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/ql-cache\/quicklatex.com-463e7e41ce62932c68909f324b85b306_l3.png\" "\\"Rendered")
<\/p><\/p>\r\n\nFor example, if you choose 20 MHz as frequency, you only have a resolution of 4, i.e. you can set the duty cycles 0, 25, 50 and 75% by passing values in the ranges 0-255, 256-511, 512-767 or 768-1023 to
pwm.duty()<\/code>.<\/a><\/p>\r\n\nAnalog Pins <\/h2>\n\n
You can pick off a real analog signal between 0 and 3.3 V at pins 25 and 26. The resolution is 8 bits. Here’s how it works:<\/p>\r\n\n
from machine import Pin, DAC\r\ndac = DAC(Pin(25)) \r\ndac.write(128) # voltage = 3.3 * 128\/256<\/pre>\r\n\n
The drawback: the output voltage is linear to the value passed to dac.write(), but the slope of the straight line is not quite right. In my measurements, the range was 0.086 to 3.18 volts instead of 0 to 3.3 volts (see here<\/a>).<\/a><\/p>\r\n\n
Time functions<\/h2>\n\n
The equivalents to
delay()<\/code> anddelayMicroseconds()<\/code> when using ESP32 with MicroPython aresleep_ms()<\/code> orsleep_us()<\/code>. In addition, you can usesleep()<\/code> which takes seconds as parameter.<\/p>\r\nmillis()<\/code> andmicros()<\/code> are calledticks_ms()<\/code> andticks_us()<\/code> in MicroPython. Withticks_diff()<\/code> you can determine time spans. Here is a small example:<\/p>\r\n\nimport time\r\n\r\nstart_ms = time.ticks_ms() \r\nstart_us = time.ticks_us()\r\nprint(\"Millisecs: \", start_ms)\r\nprint(\"Microsecs: \", start_us)\r\ntime.sleep(3)\r\ndelta = time.ticks_diff(time.ticks_ms(), start_ms)\r\nprint(\"Delta =\", delta)<\/pre>\r\n\n
The time module<\/h3>\n\n
With the time module, you can query the current time and the seconds since 01\/01\/2000, 00:00 o’clock. You can calculate the frequently used Unix time<\/a> from this.<\/p>\r\n\n
import time\r\n\r\nnow = time.localtime() # query local time as tuple\r\nprint(now)\r\nprint(now[0]) # print element 0\r\nnow_secs = time.time() # secs since 01\/01\/2000, 00:00\r\nnow_unix = now_secs + 946681200 # unixtime: secs since 01\/01\/1970, 00:00 \r\nprint(now_unix)<\/pre>\r\n\n
“localtime” is used as a tuple in the format:<\/p>\r\n
(year, month, day of the month, hours, minutes, seconds, day of the week, day of the year)<\/p>\r\n
The elements are integers. Here’s what the output looks like:<\/p>\r\n\n
![\"\"](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2021\/08\/localtime.png\")
Output of local_and_unixtime.py<\/figcaption><\/figure>\n\n The RTC class<\/h3>\n\n
If you want to set the date and time of the ESP32, then you have to use the RTC class. The time tuple is structured a little differently:<\/p>\r\n
(year, month, day of the month, day of the week, hours, minutes, seconds, microseconds).<\/p>\r\n
On the day of the week, it should be noted that Monday is 0 and Sunday is 6. When setting the time, the day of the week is irrelevant. MicroPython will correct the day of the week if it is wrong.<\/p>\r\n\n
from machine import RTC\r\n\r\nrtc = RTC()\r\na = rtc.datetime()\r\nprint(a)\r\nnew_time= (2030, 12, 24, 0, 20, 35, 0, 0)\r\nrtc.init(new_time)\r\na = rtc.datetime()\r\nprint(a)<\/pre>\r\n\n
We learn: December 24th, 2030 is a Tuesday:<\/p>\r\n\n
![\"\"](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2021\/08\/rtc.png\")
<\/figure>\n\nIn addition, we learn: the time is set according to the system time of the computer when booting the ESP32.<\/p>\r\n
Actually, the RTC class can do much more, e.g. alarm interrupts. However, this does not seem to have been implemented (yet) for the ESP32.<\/a><\/p>\r\n\n
External interrupts<\/h2>\n\n
External (pin change) interrupts can be set up for each GPIO. This works similarly to the Arduino. The following program triggers an interrupt when a button attached to GPIO 23 is pressed. An LED on the GPIO 18 then lights up:<\/p>\r\n\n
from machine import Pin\r\nfrom time import sleep\r\n\r\nled = Pin(18, Pin.OUT)\r\nbtn = Pin(23, Pin.IN, Pin.PULL_DOWN)\r\n\r\nbtn_pressed = False\r\n\r\ndef btn_handler(btn):\r\n global btn_pressed\r\n btn_pressed = True\r\n \r\nbtn.irq(trigger=Pin.IRQ_RISING, handler=btn_handler)\r\n \r\nwhile True:\r\n if btn_pressed:\r\n led.value(1)\r\n sleep(1)\r\n led.value(0)\r\n btn_pressed = False<\/pre>\r\n\n
A few explanations:<\/p>\r\n\n
- \r\n
- With
btn.irq()<\/code> the pin “btn” gets an interrupt function.\r\n- \r\n
trigger=Pin.IRQ_RISING<\/code> causes the interrupt to be triggered by the rising edge.\r\n- \r\n
- In addition, there is – surprise! – also
IRQ_FALLING<\/code>.<\/li>\r\n<\/ul>\r\n<\/li>\r\nhandler=btn_handler<\/code> defines the interrupt handler, i.e. the function that is called when the interrupt is triggered (without parentheses).<\/li>\r\n<\/ul>\r\n<\/li>\r\n- You must pass the pin object to the interrupt handler.<\/li>\r\n
- In the handler function, btn_pressed must be set as global, otherwise Python considers the variable to be local.<\/a><\/li>\r\n<\/ul>\r\n\n
Programming the timers of the ESP32 with MicroPython<\/h2>\n\n
Timers trigger internal interrupts. The ESP32 has 4 hardware timers with the ID 0 to 3, and they are easy to program. No comparison to the timers of the ATmega328P<\/a>! Here is an example program that flashes 2 LEDs in asynchronously:<\/p>\r\n\n
from machine import Pin, Timer\r\n\r\nled0 = Pin(18, Pin.OUT)\r\nled1 = Pin(19, Pin.OUT)\r\n\r\ndef handler_0(tim0):\r\n led0.value(not led0.value())\r\n \r\ndef handler_1(tim1):\r\n led1.value(not led1.value())\r\n\r\ntim0 = Timer(0)\r\ntim0.init(period=973, mode=Timer.PERIODIC, callback=handler_0)\r\n\r\ntim1 = Timer(1)\r\ntim1.init(period=359, mode=Timer.PERIODIC, callback=handler_1)\r\n<\/pre>\r\n\n
I think the code is almost self-explanatory:<\/p>\r\n
- \r\n
- Timer is a class of the machine module.<\/li>\r\n
- First you create a timer object and pass the timer ID (0 to 3).<\/li>\r\n
init()<\/code> expects three arguments:\r\n- \r\n
period<\/code> is the timespan in milliseconds until the timer interrupt is triggered.<\/li>\r\nmode<\/code> is eitherPERIODIC<\/code> orONE_SHOT<\/code>.<\/li>\r\ncallback<\/code> defines the function (interrupt handler) that will be called when the timer interrupt is triggered.<\/li>\r\n<\/ul>\r\n<\/li>\r\n- As with external interrupts, you must pass the causing object to the handlers (tim0 and tim1 in this case).<\/li>\r\n<\/ul>\r\n
Isn’t that wonderfully easy?<\/p>\r\n
As an alternative to periods, you can also pass the frequency in Hertz, e.g.:
freq = 20000<\/code>.<\/p>\r\n\nWatchdog timer<\/h3>\n\n
The watchdog timer of the ESP32 is not particularly convenient, but easy to program. You create a WDT object and pass the timeout in milliseconds. Once started, it can no longer be stopped. It’s a bit unusual that you can only prevent the reset by a wdt.feed(). Other MCUs extend the timeout with any statement.<\/p>\r\n
Here is an example:<\/p>\r\n\n
from machine import WDT\r\nfrom time import sleep\r\n\r\nwdt = WDT(timeout=5000)\r\n\r\nprint(\"Hi, I have just booted\")\r\n \r\nwhile True:\r\n sleep(1)\r\n print(\"Still there...\")\r\n #wdt.feed()<\/pre>\r\n\n
You will see that the ESP32 resets after 5 seconds. If you uncomment
wdt.feed()<\/code>, that doesn’t happen. By the way, the minimum timeout is 1 second.<\/a><\/p>\r\n\nI2C<\/h2>\n\n
The ESP32 has two I2C interfaces. I had explained this in detail here<\/a>. In MicroPython, the interfaces are distinguished by their index (0 or 1). Interface 0 is assigned to GPIOs 18 (SCL) and 19 (SDA). Interface 1 is assigned to GPIOs 25 (SCL) and 26 (SDA). You can change the assignment and optionally specify the frequency. You do this when you create your I2C object.<\/p>\r\n\n
from machine import I2C, Pin # I2C is a class in machine\r\n\r\ni2c = I2C(0) # simplest definition, SDA=GPIO19, SCL=GPIO18\r\ni2c = I2C(1) # SDA=GPIO26, SCL=GPIO25\r\ni2c = I2C(0, scl=Pin(16), sda=Pin(17)) # new pin assignment\r\ni2c = I2C(1, scl=Pin(12), sda=Pin(14), freq=400000) # new frequency and pin assignment<\/pre>\r\n\n
Scanning for I2C addresses is easy with
scan()<\/code>. The function returns a list of I2C addresses in decimal numbers:<\/p>\r\n\n![\"ESP32](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2021\/09\/i2c_scan.png\")
<\/a>i2c.scan() in action<\/figcaption><\/figure>\n\n You write into registers via I2C with the function
writeto_mem()<\/code> and read them withreadfrom_mem()<\/code> orreadfrom_mem_into()<\/code>. You need to pass the I2C address and the register number to these functions. The data you write or query must be of type bytearray, even if it is only one byte. Here’s how the functions are used:<\/p>\r\n\n# writing to registers:\r\ndata = bytearray([128, 255]) # just an example\r\ni2c.writeto_mem(I2C_ADDR, REG_ADDR, data)\r\n\r\n# reading from registers:\r\ndata = i2c.readfrom_mem(I2C_ADDR, REG_ADDR, 2) # read two bytes\r\n# or, alternatively:\r\ndata = bytearray(2)\r\ni2c.readfrom_mem_into(I2C_ADDR, REG_ADDR, data)<\/pre>\r\n\n
You often need to read 16-bit values from two 8-bit registers and then combine the individual values to form an integer. This can be done as in C++ with shift operators (
MSB<<8 | LSB<\/code>).int.from_bytes(data, order)<\/code> is less cryptic. Data is a bytearray that contains the bytes to be assembled, order is either “big” or “little”. “big” means that the MSB (Most Significant Byte) is first, with “little” it is at the end.<\/p>\r\nThen there is a small problem: how can MicroPython know whether the read data is signed or unsigned? With C++ you can specify that. The answer is: not at all, but you can easily solve this problem. For example, if you read a 16-bit signed integer((-215<\/sup>) to (+215<\/sup>-1), then the biggest positive value is 32767. Larger values are misinterpreted and actually negative. Because of the two’s complement representation<\/a>, you just need to subtract 65536 (i.e.216<\/sup>). This applies at least to the current implementation of MicroPython on the ESP32. There are also Python versions in which you can pass
int.from_bytes()<\/code> tosigned=true<\/code>.<\/p>\r\n\nI2C example: Reading the MPU6050 on ESP32 with MicroPython <\/h4>\n\n
The following program provides the acceleration values, temperature and gyroscope data of an MPU6050. The example shows how compact MicroPython code can be.<\/p>\r\n\n
from machine import I2C\r\nfrom time import sleep\r\n\r\nMPU_ADDR = 0x68\r\ni2c = I2C(0)\r\ni2c.writeto_mem(MPU_ADDR, 0x6B, bytearray([0])) # \"wake-up call\"\r\n\r\ndef byteToInt(bytePair):\r\n intVal = int.from_bytes(bytePair, 'big') # \"big\" = MSB at beginning\r\n if intVal > 32767: # intVal is negative => 2^15\r\n intVal -= 65536\r\n return intVal\r\n \r\n\r\nwhile True:\r\n regVal = i2c.readfrom_mem(MPU_ADDR, 0x3B, 14) # Read 14 bytes \r\n print(\"AccX =\", byteToInt(bytearray([regVal[0],regVal[1]]))) \r\n print(\"AccY =\", byteToInt(bytearray([regVal[2],regVal[3]])))\r\n print(\"AccZ =\", byteToInt(bytearray([regVal[4],regVal[5]])))\r\n print(\"Temp =\", (byteToInt(bytearray([regVal[6],regVal[7]])))\/340.00+36.53)\r\n print(\"GyrX =\", byteToInt(bytearray([regVal[8],regVal[9]])))\r\n print(\"GyrY =\", byteToInt(bytearray([regVal[10],regVal[11]])))\r\n print(\"GyrZ =\", byteToInt(bytearray([regVal[12],regVal[13]])))\r\n print(\"***************\")\r\n sleep(2)\r\n<\/pre>\r\n\n
First, the MPU6050 is woken up by writing a zero to its register 0x6B (“Powermanagement 1”). The measured values are available in fourteen registers, starting from 0x3B, and they are read in one go. 2 bytes each of the bytearray regVal form one of the 7 measured values.<\/p>\r\n
Most of the time, however, you will probably not want to deal with registers and therefore choose external modules. I come to that now.<\/a><\/p>\r\n\n
Adding external (I2C) modules<\/h2>\n\n
First of all, there is a certain confusion of names here. You will find the terms module, library and package. In first approximation, the terms mean the same thing.<\/p>\r\n
For many components such as sensors, displays, ADCs, etc., hard-working people have written modules. To use them, you have to install them in most cases.<\/p>\r\n
If you work with Thonny, then it is best to use the package manager. Go to Tools \u2192 Manage Packages. Enter the name and search for PyPI. Select the package, install it, and you can immediately use it. This is similar to the library management in the Arduino IDE. Only the handling of example programs is less well solved. To get them, you have to go to the platforms where the packages are made available.<\/p>\r\n
However, there may also be modules that you cannot find via the package management. Maybe you programmed them yourself. In this case, take the file to be included, right-click on it in Thonny and select “Upload to \\”. Then you can use the classes and functions. <\/p>\r\n
uPyCraft does not have a package management. There, you open the file to be included and select “Download”. <\/a> <\/p>\r\n\n
SPI<\/h2>\n\n
The ESP32 has four SPI interfaces, of which you can use two. They are called HSPI and VSPI and they are addressed via their IDs 1 and 2 respectively. By default, the following pins are assigned to the interfaces:<\/p>\r\n\n
![\"SPI](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2021\/09\/SPI_pinout_ESP32-1024x236.png\")
<\/a>SPI Pins of the ESP32<\/figcaption><\/figure>\n\n You can easily change the pin assignment. The creation of SPI objects is similar to I2C. You can pass different parameters:<\/p>\r\n\n
from machine import Pin, SPI\r\n\r\nhspi = SPI(1) # use default Pins\r\nhspi = SPI(1, 20000000)\r\nhspi = SPI(1, baudrate=20000000, sck=Pin(14), mosi=Pin(13), miso=Pin(12))\r\nvspi = SPI(2, baudrate=40000000, polarity=0, phase=0, bits=8, firstbit=0, sck=Pin(15), mosi=Pin(16), miso=Pin(17))<\/pre>\r\n\n
When using the standard GPIOs, the baud rate can be up to 80 MHz. If you choose other GPIOs, the baud rate is limited to 40 MHz.<\/p>\r\n
Reading and writing to registers is also similar. The data is passed and received as bytearrays. Here is an example of how to use the most important functions:<\/p>\r\n\n
spi.read(5) # read 5 bytes \r\nspi.read(5, 0xFF) # read 5 bytes and write 0xFF\r\n\r\nbuf = bytearray(20) \r\nspi.readinto(buf) # read into the given buffer \r\nspi.readinto(buf, 0xFF) # read into the buffer and write 0xFF\r\n\r\nspi.write(buf) # write buffer\r\nspi.write_readinto(buf_1, buf_2) # write buf_1 and read into the buf_2<\/pre>\r\n
<\/p>\r\n\n
UART (Serial)<\/h2>\n\n
The ESP32 has the three UART interfaces UART0, UART1 and UART2. By default, these are assigned to the following GPIOs:<\/p>\r\n\n
![\"Standard](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2021\/09\/UART_GPIOs_ESP32-1024x162.png\")
<\/a>Standard GPIOs of the UART interfaces<\/figcaption><\/figure>\n\n When choosing the pins, you have to be a bit careful. You should not use the standard GPIOS for UART0 and UART1 (see also here<\/a>).<\/p>\r\n
Things repeat. Again, you first create a UART object, where you can pass several parameters. At least you have to pass the UART ID. Here is an example:<\/p>\r\n\n
from machine import UART\r\n\r\nuart1 = UART(1, baudrate=115200, tx=18, rx=19)<\/pre>\r\n\n
And here are a few – I think self-explanatory – statements:<\/p>\r\n\n
uart1.init(9600, bits=8, parity=None, stop=1) # standard settings\r\nuart1.read(7) # read 7 characters, returns a bytes object, not bytearray\r\nuart1.read() # read all available characters\r\nuart1.readline() # read a line\r\nuart1.readinto(buf) # read and store into buf\r\nuart1.write('xyz') # write the 3 characters\r\nuart1.any() # returns number of bytes available <\/pre>\r\n<\/a>\r\n\nDeep and Light Sleep<\/h2>\n\n
To save power, the ESP32 has a light sleep and a deep sleep function. After a light sleep, the program picks up where it left off. A deep sleep causes a reset. The setting is very easy on the ESP32 with MicroPython. You can try the following program:<\/p>\r\n\n
import machine, time \r\n\r\nif machine.reset_cause() == machine.DEEPSLEEP_RESET:\r\n print(\"woke up from a deep sleep\")\r\n\r\nwhile True:\r\n #machine.deepsleep(3000)\r\n machine.lightsleep(3000)\r\n print(\"woke up from a light sleep\")\r\n time.sleep(0.1)<\/pre>\r\n\n
Without the small
time.sleep()<\/code> delay,print()<\/code> did not work properly for me. Apparently, the ESP32 goes to sleep before theprint()<\/code> instruction is completely processed.<\/a><\/p>\r\n\nTouch Pins<\/h2>\n\n
The touch pins register capacities. Since the human body also has a certain capacity, the touch pins serve as touch sensors. Here’s how it works:<\/p>\r\n\n
from machine import TouchPad, Pin\r\nfrom time import sleep\r\n\r\nt = TouchPad(Pin(32))\r\n\r\nwhile True:\r\n t_val=t.read()\r\n print(\"Touch value:\", t_val)\r\n sleep(0.5)<\/pre>\r\n\n
The initial values (ESP32 used on a breadboard) were around 800 for me. When I touched the touch pin via a jumper cable, the values dropped below 100. <\/p>\r\n
A touch event can wake the ESP32 from both light and deep sleep. Here’s how it works:<\/p>\r\n\n
import machine\r\nfrom machine import TouchPad, Pin\r\nimport esp32\r\nfrom time import sleep\r\n\r\nt = TouchPad(Pin(32))\r\nt.config(300) # configure the threshold at which the pin is considered touched\r\nesp32.wake_on_touch(True)\r\n\r\nwhile True:\r\n machine.lightsleep() # put the MCU to sleep until a touchpad is touched\r\n print(\"Woke up from light sleep\")\r\n sleep(1)\r\n print(\"Falling asleep again\")\r\n sleep(0.1) # you can try without this<\/pre>\r\n<\/a>\r\n\n
Hall Sensor<\/h2>\n\n
The ESP32 has a Hall sensor<\/a> that detects magnetic fields. It is easy to read:<\/p>\r\n\n
import esp32, time\r\n\r\nwhile True:\r\n m = esp32.hall_sensor()\r\n print(m)\r\n time.sleep(2)<\/pre>\r\n<\/a>\r\n\n
Wi-Fi<\/h2>\n\n
One of the great advantages of the ESP32 is the integrated WLAN. However, the topic is quite extensive and would go beyond the scope of this post. Maybe I’ll cover it in a later article.<\/p>\r\n
If you want to deal with the topic in more detail, then I recommend this tutorial<\/a> as a starting point. There it is shown how to set up a web server with the ESP32 and how to then switch an LED via browser. The instructions worked wonderfully for me right away.<\/p>\r\n\n
Bluetooth<\/h2>\n\n
With Bluetooth, a distinction is made – among many other things – between Bluetooth Classic and BLE (Bluetooth Low Energy). You may know the classic version from the HC-05 and HC-06 modules<\/a> or from my article about programming the ESP32 with Arduino code.<\/a> The advantage is the simple programming.<\/p>\r\n
- In addition, there is – surprise! – also
- Adding external modules<\/a><\/li>\r\n
- Reading the ADCs<\/a><\/li>\r\n