Home » ESP32
Tag:

ESP32

Code

Connect an IS31FL3741 LED matrix module to an ESP32

by shedboy71

In this article we look at a module with lots of LEDs on it, its an IS31FL3741 LED matrix module from adafruit

Module Information

At the centre of the module is the IS31FL3741

The IS31FL3741 is a general purpose 39×9 LED Matrix programmed via an I2C compatible interface.

Each LED can be dimmed individually with 8-bit PWM data and 8-bit scaling data which allowing 256 steps of linear PWM dimming and 256 steps of DC current adjustable level.

Additionally each LED open and short state can be detected, IS31FL3741 store the open or short information in Open-Short Registers. The Open-Short Registers allowing MCU to read out via I2C compatible interface. Inform MCU whether there are LEDs open or short and the locations of open or short LEDs.

The IS31FL3741 operates from 2.7V to 5.5V and features a very low shutdown and operational current.

FEATURES

Supply voltage range: 2.7V ~ 5.5V
9 Current Sink × 9 SW matrix size: drive up to 351 LEDs or 117 RGBs
Individual 256 PWM control steps
Individual 256 DC current steps
Global 255 current setting
SDB rising edge reset I2C module
Programmable H/L logic: 1.4/0.4, 2.4/0.6
29kHz PWM frequency
1MHz I2C-compatible interface
interrupt and state lookup registers
Individual open and short error detect function

The adafruit module features a 13×9 RGB LED matrix breakout for a grand total of 117 RGB LEDs

Parts Required

Name Link
ESP32
IS31FL3741
Connecting cables

Schematic/Connection

 

Code Example

You can install the Adafruit IS31FL3741 library for Arduino using the Library Manager in the Arduino IDE.

Click Manage Libraries, search for IS31FL3741 , and select the Adafruit IS31FL3741 library, and install the latest version:

You may be asked about dependencies if this is the first time you have installed an Adafruit library, click “Install all” to install them as well.

The library has several example – this one scrolls text on the matrix and we have toned the brightness down as well – they are bright leds

 

#include <Adafruit_IS31FL3741.h>

Adafruit_IS31FL3741_QT matrix;
// If colors appear wrong on matrix, try invoking constructor like so:
// Adafruit_IS31FL3741_QT matrix(IS3741_RBG);

// Some boards have just one I2C interface, but some have more...
TwoWire *i2c = &Wire; // e.g. change this to &Wire1 for QT Py RP2040

char text[] = "esp32learning!";   // A message to scroll
int text_x = matrix.width(); // Initial text position = off right edge
int text_y = 1;
int text_min;                // Pos. where text resets (calc'd later)

void setup() {
  Serial.begin(115200);
  Serial.println("Adafruit QT RGB Matrix Scrolling Text Test");

  if (! matrix.begin(IS3741_ADDR_DEFAULT, i2c)) {
    Serial.println("IS41 not found");
    while (1);
  }

  Serial.println("IS41 found!");

  // By default the LED controller communicates over I2C at 400 KHz.
  // Arduino Uno can usually do 800 KHz, and 32-bit microcontrollers 1 MHz.
  i2c->setClock(800000);

  // Set brightness to max and bring controller out of shutdown state
  matrix.setLEDscaling(0x10);
  matrix.setGlobalCurrent(0x10);
  Serial.print("Global current set to: ");
  Serial.println(matrix.getGlobalCurrent());

  matrix.fill(0);
  matrix.enable(true); // bring out of shutdown
  matrix.setRotation(0);
  matrix.setTextWrap(false);

  // Get text dimensions to determine X coord where scrolling resets
  uint16_t w, h;
  int16_t ignore;
  matrix.getTextBounds(text, 0, 0, &ignore, &ignore, &w, &h);
  text_min = -w; // Off left edge this many pixels
}

void loop() {
  matrix.setCursor(text_x, text_y);
  for (int i = 0; i < (int)strlen(text); i++) {
    // set the color thru the rainbow
    uint32_t color888 = matrix.ColorHSV(65536 * i / strlen(text));
    uint16_t color565 = matrix.color565(color888);
    matrix.setTextColor(color565, 0); // backound is '0' to erase previous text!
    matrix.print(text[i]); // write the letter
  }

  if (--text_x < text_min) {
    text_x = matrix.width();
  }

  delay(25);
}

 

2 FacebookTwitterPinterestEmail
Code

Connect an LTR-329 Ambient Light sensor to an ESP32

by shedboy71

In this article we look at an Ambient Light sensor, the LTR-329 and connect it to an ESP32

Sensor Information

The LTR-329 provides 16-bit light measurements for both Infrared and Visible+IR spectrums. Subtract one from the other to get human-visible light. Thanks to configurable gain and integration time settings, the LTR-329 can measure from 0 to 65K+ lux.

I bought an Adafruit breakout board, so the LTR-329 comes integrated with a voltage regulator and level-shifting circuitry to allow it to be used with 3.3V devices or 5V devices.

Along with a header, there is a SparkFun Qwiic compatible STEMMA QT connectors for the I2C bus so you just need to fit a suitable cable

Features

I2C interface with up to Fast Mode @ 400kbit/s with address 0x29
Ultra-small 4-pin ChipLED package 2.0mm(L), 2.0mm(B), 0.7mm(H)
Built-in temperature compensation circuit
Low active power consumption with standby mode
Supply voltage range from 2.4V to 3.6V capable of 1.7V logic voltage
Operating temperature range from -30C to +70C
RoHS and Halogen free compliant
Close to human eye spectral response
Immunity to IR / UV Light Source
Automatically rejects 50 / 60 Hz lightings flicker
Full dynamic range from 0.01 lux to 64k lux
16-bit effective resolution

Parts Required

You can connect to the sensor using dupont style jumper wire.

 

Name Link
ESP32
LTR329  
Connecting cables

 

Schematic/Connection

I used 3.3v from the ESP32 and the stemma/qwic connector

 

Code Example

I installed the Adafruit library using the Arduino ide which also installed the dependency library

Click the Manage Libraries … menu item, search for LTR329_LTR303, and select the Adafruit LTR329 LTR303 library

If asked about dependencies, click on the “Install all” option

If the Dependencies window does appear, you already have the required dependencies installed.

If the dependencies are already installed, make sure that you have the latest ones installed using the Arduino Library Manager

This is the default ltr329_simpletest example with the delay set to 1000ms rather than 100ms which seemed a bit too short a delay for simple testing. I also removed code from the setup routine which basically displayed the settings that you can change in the setup.

These are

ltr.setGain(LTR3XX_GAIN_2);
ltr.setIntegrationTime(LTR3XX_INTEGTIME_100);
ltr.setMeasurementRate(LTR3XX_MEASRATE_200);

#include "Adafruit_LTR329_LTR303.h"

Adafruit_LTR329 ltr = Adafruit_LTR329();

void setup() {
  Serial.begin(115200);
  Serial.println("Adafruit LTR-329 advanced test");

  if ( ! ltr.begin() ) {
    Serial.println("Couldn't find LTR sensor!");
    while (1) delay(10);
  }
  Serial.println("Found LTR sensor!");

  ltr.setGain(LTR3XX_GAIN_2);
  ltr.setIntegrationTime(LTR3XX_INTEGTIME_100);
  ltr.setMeasurementRate(LTR3XX_MEASRATE_200);

}

void loop() {
  bool valid;
  uint16_t visible_plus_ir, infrared;

  if (ltr.newDataAvailable()) {
    valid = ltr.readBothChannels(visible_plus_ir, infrared);
    if (valid) {
      Serial.print("CH0 Visible + IR: ");
      Serial.print(visible_plus_ir);
      Serial.print("\t\tCH1 Infrared: ");
      Serial.println(infrared);
    }
  }

  delay(1000);
}

 

Output

Here is  an example of what I saw in the serial monitor window – you may see some different results

This was covering and uncovering the sensor

CH0 Visible + IR: 4 CH1 Infrared: 5
CH0 Visible + IR: 4 CH1 Infrared: 5
CH0 Visible + IR: 4 CH1 Infrared: 5
CH0 Visible + IR: 3 CH1 Infrared: 4
CH0 Visible + IR: 22 CH1 Infrared: 30
CH0 Visible + IR: 20 CH1 Infrared: 29
CH0 Visible + IR: 20 CH1 Infrared: 29

Links

https://optoelectronics.liteon.com/upload/download/DS86-2014-0006/LTR-329ALS-01_DS_V1.5.PDF

1 FacebookTwitterPinterestEmail
Code

Connect an LTR-303 Ambient Light sensor to an ESP32

by shedboy71

In this article, we look at an Ambient Light sensor, the LTR-303, and connect it to an ESP32 board

Sensor Information

The LTR-303ALS is a low-cost, small, I2C Ambient Light sensor. The LTR-303ALS comes in a 2.0×2.0×0.7mm 6-pin DFN package.

The LTR-303ALS has an operating voltage of 2.4-3.6V with I2C operation down to 1.7V. The LTR-303ALS provides a full dynamic range from 0.01-64K lux while providing a close-to-the-eye spectral response with immunity to IR/UV light sources and automatically rejects 50/60Hz light flicker.

There are 6 gain settings available 1X, 2X, 3X, 4X, 8X, 48X, and 96X) to the user and provides a 16-bit effective resolution output.

Features

I2C interface (Fast Mode @ 400kbit/s)
Ultra-small 6-pin ChipLED package 2.0mm(L), 2.0mm(B), 0.7mm(H)
Built-in temperature compensation circuit
Low active power consumption with standby mode
Supply voltage range from 2.4V to 3.6V capable of 1.7V logic voltage
Operating temperature range from -30C to +70C
RoHS and Halogen free compliant
Close to human eye spectral response
Immunity to IR / UV Light Source
Automatically rejects 50 / 60 Hz lightings flicker
Full dynamic range from 0.01 lux to 64k lux
16-bit effective resolution

Parts Required

You can connect to the sensor using dupont style jumper wire.

 

Name Link
ESP32
LTR303
Connecting cables

 

Schematic/Connection

I used 3.3v from the ESP32 and connected using the qwic sensor

 

Code Example

I installed the Adafruit library using the Arduino ide which also installed the dependency library

Click the Manage Libraries … menu item, search for LTR329_LTR303, and select the Adafruit LTR329 LTR303 library

If asked about dependencies, click on the “Install all” option

If the Dependencies window does appear, then you already have the required dependencies already installed.

If the dependencies are already installed, make sure that you have the latest ones installed using the Arduino Library Manager

This is the default example with the delay set to 1000ms rather than 100ms which seemed a bit too short a delay for simple testing

#include "Adafruit_LTR329_LTR303.h"

Adafruit_LTR303 ltr = Adafruit_LTR303();

void setup() {
  Serial.begin(115200);
  while (!Serial) {
    delay(10); // wait for serial port to open
  }
  Serial.println("Adafruit LTR-303 simple test");

  if ( ! ltr.begin() ) {
    Serial.println("Couldn't find LTR sensor!");
    while (1) delay(10);
  }
  Serial.println("Found LTR sensor!");

  // Set gain of 1 (see advanced demo for all options!
  ltr.setGain(LTR3XX_GAIN_1);
  // Set integration time of 50ms (see advanced demo for all options!
  ltr.setIntegrationTime(LTR3XX_INTEGTIME_50);
  // Set measurement rate of 50ms (see advanced demo for all options!
  ltr.setMeasurementRate(LTR3XX_MEASRATE_50);
}

void loop() {
  bool valid;
  uint16_t visible_plus_ir, infrared;

  if (ltr.newDataAvailable()) {
    valid = ltr.readBothChannels(visible_plus_ir, infrared);
    if (valid) {
      Serial.print("CH0 Visible + IR: ");
      Serial.print(visible_plus_ir);
      Serial.print("\t\tCH1 Infrared: ");
      Serial.println(infrared);
    }
  }

  delay(1000);
}

 

Output

Here is  an example of what I saw in the serial monitor window – you may see some different results

This was covering and uncovering the sensor

CH0 Visible + IR: 1 CH1 Infrared: 2
CH0 Visible + IR: 7 CH1 Infrared: 6
CH0 Visible + IR: 6 CH1 Infrared: 6
CH0 Visible + IR: 6 CH1 Infrared: 7
CH0 Visible + IR: 1 CH1 Infrared: 2

Links

https://optoelectronics.liteon.com/upload/download/DS86-2013-0004/LTR-303ALS-01_DS_V1.pdf

 

 

 

3 FacebookTwitterPinterestEmail
Code

Connect a KX134 Triple Axis Accelerometer to an ESP32 example

by shedboy71

In this article we look at another Triple-axis Magnetometer, the KX134 Triple Axis Accelerometer, and connect it to an ESP32 board

This is very similar to the KX132 we wrote about previously in an article

Sensor Information

This KX134 is a digital accelerometer from Kionix. We will use the KX134 breakout from Sparkfun

The KX134 is a low-power, 16-bit resolution three-axis accelerometer capable of measuring ±8g/16g/32g/64g (user-selectable) and has up to a 10kHz output data rate making it ideal for high-g measurements as well as high-speed applications such as vibration sensing

The KX134 includes a host of features including Freefall detection, Directional Tap™ and Double-Tap™ detection, tilt orientation detection and more. The Qwiic KX134 can interface with controllers using both I2C and SPI at high speeds so you can use it in an existing Qwiic chain or on an SPI bus.

This is what the breakout looks like

Features

  • Measurement Range: ±8g, ±16g, ±32g, ±64g (User Selectable)
  • High Resolution (8 or 16-bit)
  • User-Configurable Output Data Rate (ODR) up to 25600Hz
  • User-Configurable 3-stage Advanced Data Path featuring low-pass filter, low-pass/high-pass filter and RMS calculation engine
  • Wide range of built-in sensing functions
    • Free Fall
    • Directional-Tap™ / Double-Tap™
    • Device Orientation & Activity Algorithms
  • Low Noise: 130µg/√Hz (varies based on ODR, power mode & other settings)
  • High-Resolution Wake-Up & Back-to-Sleep Detection with a configurable threshold as low as 3.9mg
  • 512-byte FIFO buffer that continues recording data while being read
  • Selectable Low-Power or High-Performance operating modes
  • Low Power with Integrated Voltage Regulator
    • High-Performance Operating Current Consumption (400Hz ODR + Wake-Up Detection): 148µA
    • Low Power Operating Current Consumption (0.781Hz ODR + Wake-Up Detection): 0.53µA
    • Standby Current Consumption: 0.5µA
  • Self-Test Functionality
  • Digital I2C up to 3.4MHz and Digital SPI up to 10MHz
  • 2x Qwiic Connectors
  • SPI available on PTH Header Pins
  • I2C Address: 0x1E (0x1F can be used as an alternate but requires soldering abridge across 2 pads on the underside of the board)

Parts Required

You can connect to the sensor using DuPont style jumper wire.

 

Name Link
ESP32
KX134
Connecting cables

 

Schematic/Connection

I used 3.3v from the ESP32

I also used a Qwiic cable, but if you do not have one, there is an unpopulated set of pins you can solder a header to. This is how you would wire this up

 

Code Example

I installed the Sparkfun library using the Arduino ide

Click the Manage Libraries … menu item, search for KX134, and select the Sparkfun KX13x library like this

This is one of the examples that gets installed with the library, with a  few comments and unused lines removed.

#include <Wire.h>
#include <SparkFun_KX13X.h>

SparkFun_KX134 kxAccel;

outputData myData; // Struct for the accelerometer's data

void setup()
{

  Wire.begin();
  Serial.begin(115200);

  // Wait for the Serial monitor to be opened.
  while (!Serial)
    delay(50);

  if (!kxAccel.begin())
  {
    Serial.println("Could not communicate with the the KX13X");
    while (1)
      ;
  }
  Serial.println("Ready.");

  if (kxAccel.softwareReset())
    Serial.println("Reset.");

  // Give some time for the accelerometer to reset.
  // It needs two, but give it five for good measure.
  delay(5);

  // Many settings for KX13X can only be
  // applied when the accelerometer is powered down.
  // However there are many that can be changed "on-the-fly"
  // check datasheet for more info, or the comments in the
  // "...regs.h" file which specify which can be changed when.
  kxAccel.enableAccel(false);

  kxAccel.setRange(SFE_KX134_RANGE16G);         // 16g for the KX134

  kxAccel.enableDataEngine(); // Enables the bit that indicates data is ready.
  // kxAccel.setOutputDataRate(); // Default is 50Hz
  kxAccel.enableAccel();
}

void loop()
{
  // Check if data is ready.
  if (kxAccel.dataReady())
  {
    kxAccel.getAccelData(&myData);
    Serial.print("X: ");
    Serial.print(myData.xData, 4);
    Serial.print(" Y: ");
    Serial.print(myData.yData, 4);
    Serial.print(" Z: ");
    Serial.print(myData.zData, 4);
    Serial.println();
  }
  delay(500); // Delay should be 1/ODR (Output Data Rate), default is 1/50ODR
}

 

Output

When run and the sensor was moved around

Ready.
Reset.
X: 0.3035 Y: -0.0088 Z: -0.9189
X: -0.0044 Y: 0.6022 Z: -1.2317
X: -1.3576 Y: -0.2172 Z: -0.2381
X: -0.0693 Y: -0.0176 Z: 0.6759

Links

https://kionixfs.azureedge.net/en/datasheet/kx134-1211-e.pdf

0 FacebookTwitterPinterestEmail
Code

Connecting a KX132 Triple Axis Accelerometer to an ESP32 board example

by shedboy71

In this article we look at one of 2 similar Triple-axis Magnetometer that I recently purchased, the KX132 Triple Axis Accelerometer, and connect it to an ESP32

Sensor Information

The KX132 is a digital accelerometer from Kionix.

The KX132 is a low-power, 16-bit resolution three-axis accelerometer with four user-selectable acceleration measurement ranges of ±2g/4g/8g/16g and has up to a 10kHz (max) output data rate making it ideal for a wide range of acceleration measurements as well as high-speed applications such as vibration and tap sensing.

The KX132 includes a host of features including Freefall detection, Directional Tap™ and Double-Tap™ detection, tilt orientation detection and more.

The Qwiic KX132 can interface with controllers using both I2C and SPI at high speeds so you can use it in an existing Qwiic/I2C chain or on a SPI bus.

Features

Measurement Range: ±2g, ±4g, ±8g, ±16g (User Selectable)
High Resolution (8 or 16-bit)
User-Configurable Output Data Rate (ODR) up to 25600Hz
User-Configurable 3-stage Advanced Data Path featuring low-pass filter, low-pass/high-pass filter, and RMS calculation engine
Wide range of built-in sensing functions

  • Free Fall
  • Directional-Tap™ / Double-Tap™
  • Device Orientation & Activity Algorithms

Low Noise: 130µg/√Hz (varies based on ODR, power mode & other settings)
High-Resolution Wake-Up & Back-to-Sleep Detection with a configurable threshold as low as 3.9mg
512-byte FIFO buffer that continues recording data while being read
Selectable Low-Power or High-Performance operating modes
Low Power with Integrated Voltage Regulator

  • High Performance Operating Current Consumption (400Hz ODR + Wake-Up Detection): 148µA
  • Low Power Operating Current Consumption (0.781Hz ODR + Wake-Up Detection): 0.53µA
  • Standby Current Consumption: 0.5µA

Self-Test Functionality
Digital I2C up to 3.4MHz and Digital SPI up to 10MHz
2x Qwiic Connectors
SPI available on PTH Header Pins
I2C Address: 0x1E (0x1F can be used as an alternate)

Parts Required

You can connect to the sensor using DuPont style jumper wire.

 

Name Link
ESP32
KX132
Connecting cables

 

Schematic/Connection

I used 3.3v from the ESP32 Lolin board I used for testing

I also used a Qwiic cable but if you do not have one of them there is an unpopulated set of pins you can solder a header to. This is how you would wire this up

 

Code Example

I installed the Sparkfun library using the Arduino ide

Click the Manage Libraries … menu item, search for KX132, and select the Sparkfun KX13x library like this

This is one of the examples that gets installed with the library, with a  few comments and unused lines removed.

#include <Wire.h>
#include <SparkFun_KX13X.h>

SparkFun_KX132 kxAccel;

outputData myData; // Struct for the accelerometer's data

void setup()
{

  Wire.begin();
  Serial.begin(115200);

  // Wait for the Serial monitor to be opened.
  while (!Serial)
    delay(50);

  if (!kxAccel.begin())
  {
    Serial.println("Could not communicate with the the KX13X");
    while (1)
      ;
  }
  Serial.println("Ready.");

  if (kxAccel.softwareReset())
    Serial.println("Reset.");

  // Give some time for the accelerometer to reset.
  delay(5);

  // Many settings for KX13X can only be
  // applied when the accelerometer is powered down.
  kxAccel.enableAccel(false);

  kxAccel.setRange(SFE_KX132_RANGE16G); // 16g Range
  kxAccel.enableDataEngine(); // Enables the bit that indicates data is ready.
  kxAccel.enableAccel();
}

void loop()
{
  // Check if data is ready.
  if (kxAccel.dataReady())
  {
    kxAccel.getAccelData(&myData);
    Serial.print("X: ");
    Serial.print(myData.xData, 4);
    Serial.print(" Y: ");
    Serial.print(myData.yData, 4);
    Serial.print(" Z: ");
    Serial.print(myData.zData, 4);
    Serial.println();
  }
  delay(500);
}

 

Output

When run and the sensor was moved around

Welcome.
Ready.
Reset.
X: 0.0005 Y: -0.6676 Z: -0.7608
X: 0.0464 Y: -0.6598 Z: -0.7544
X: 0.0600 Y: -0.6324 Z: -0.8428
X: 0.1459 Y: -0.6759 Z: -0.8589

Links

https://www.kionix.com/product/KX132-1211

1 FacebookTwitterPinterestEmail
Hardware

UNIT Electronics DualMCU Joins Together An ESP32 and RP2040 in One Board

by shedboy71

There are so many development boards available in the market, it can be tricky to find a board with a lot of versatility and power.

Additionally, the target use cases involving ESP32 generally require more I/O for data transmission, and RP2040 projects lack support for WiFi and Bluetooth connectivity.

This board from UNIT Electronics attempts to solve this problem with the DualMCU. Hence, this development board combines the features of two 32-bit microprocessors– the ESP-WROOM-32, and the Raspberry Pi RP2040.

The ESP-WROOM-32 module has two Tensilica Xtensa LX7 with a clock speed of up to 240MHz and SRAM of 520kB, WiFi, Bluetooth/Bluetooth Low Energy (BLE) radio.
Meanwhile, the RP2040 constitutes two Arm cortex-M0+ with a clock speed of 133MHz and 264kB of SRAM, along with 16MB of external FLASH memory. It also supports 30 GPIO pins, 4 ADC channels, 16 PWM channels, and useful PIOs to increase the development board’s applications further.

 

Some of the Features:

Combines a Raspberry Pi RP2040 microcontroller and an Espressif ESP32 chip on a compact board.
Offers Bluetooth and Wi-Fi connectivity.
Features four programmable cores with wireless functions and advanced capabilities.

The RP2040 microcontroller has a clock speed of 133MHz, 264kB of SRAM, support for up to 16MB of external flash memory, 30 GPIO pins, 4 ADC channels, and 16 PWM channels, amongst many other features.
The ESP32 chip has a clock speed of up to 240MHz, integrated Wi-Fi and Bluetooth connectivity, and support for multiple wireless protocols, amongst many other features.

With its Dual CORE architecture, this development board comes with robust capabilities for IoT projects in addition to its advanced low-power features and WiFi/Bluetooth connectivity. But, the board has four programmable COREs–two Arm cortex-M0+ and two LX7, with wireless features and Arduino IDE and MicroPython support for programming. This means that one can program each core using MicroPython, CircuitPython, as well as with Arduino Programming Language.

The DualMCU has a large range of potential applications like the Internet of Things(IoT), prototype development, and robotics. Also, the high processing capacity from RP2040, along with its flexible programming support, enables the board to be used in extensive applications involving motor control and machine learning.

The two microcontrollers operate largely independently. For the most part, the general-purpose input/output (GPIO) pins for each microcontroller are on opposite sides of the board — this allows them to be treated as two boards in one, running independently. You can link the microcontrollers together — via UART, SPI, I2C, or in any other way — which then allows for cooperative use of the resources.

Pinout

Other Features

External Memory
The RP2040 (U1) has access to an external 2 MB of flash memory (U3) via a QSPI interface. All the application code and data must be stored in an external flash chip. Six dedicated pins are used to communicate with a separate QSPI flash, using execute-in-place (XIP) technology to run code directly from flash without needing to copy it to RAM first.

Cryptography IC
Optionally, the ATECC608A can be incorporated and used for authentication tasks, which can be accessed by both MCUs through selection pads for I2C communication. The ATECC608A Cryptographic IC (U7) provides secure boot capabilities alongside SHA and AES-128 encryption/decryption support for security in Smart Home and Industrial IoT (IIoT) applications.

RGB LED
The common anode RGB LED (L5) is also controlled by the ESP32 module such that the LED is on when the digital state is LOW and off when the digital state is HIGH.

WS2812B LED
The WS2812B (L4) led is an intelligent control RGB NeoPixel for full color indication integrated in a 3535 component package and is connected to RP2040 at pins GPIO16 for intelligent digital port (DI) and GPIO17 for power enable.

MicroSD Card Socket
The DualMCU interfaces a microSD card with ESP32 using the microSD card socket connected via an SPI interface. Using a microSD card becomes very handy for applications where we need to store files that are larger than the size of SPIFF (flash file system) of ESP32.

 

Development

The DualMCU development board is compatible with the Micropython Integrated Development Environment (IDE), such as Thonny, and also with the Arduino development environment. This means that you can use these development environments to program the DualMCU using both the Micropython or Circuitpython programming languages, as well as the Arduino programming language.

The support for the Micropython IDE includes an interactive console (REPL) for executing commands immediately in Micropython and Circuitpython. This allows you to easily and quickly test and debug your code.

Additionally, support for the Arduino development environment allows you to use the tools and extensive community available through Arduino to develop projects with the DualMCU development board. This can be especially useful if you are already familiar with Arduino and want to take advantage of its ease of use and wealth of resources.

Arduino Package RP2040 Index – JSON https://github.com/UNIT-Electronics/Uelectronics-RP2040-Arduino-Package
Arduino Package ESP32 Index – JSON https://github.com/UNIT-Electronics/Uelectronics-ESP32-Arduino-Package

Links

https://www.tindie.com/products/unitelectronics/unit-dualmcu-esp32-rp2040-development-board/

https://github.com/UNIT-Electronics/DualMCU

1 FacebookTwitterPinterestEmail
esp32 and STTS22H_bb
Code

Connecting a STTS22H temperature sensor to an ESP32 example

by shedboy71

In this article we look at a temperature sensor, the STTS22H sensor from ST and connect it to an ESP32 board

Sensor Information

The STTS22H is an ultralow-power, high-accuracy, digital temperature sensor offering high performance over the entire operating temperature range.

The STTS22H Temperature Sensor is an ultralow-power, high-accuracy, digital temperature sensor from ST Microelectronics and is housed in our standard Qwiic form factor. Thanks to its factory calibration the STTS22H offers high-end accuracy performance over the entire operating temperature range, reaching as low as ±0.5°C without requiring any further calibration at the application level.

The sensor operating mode is user-configurable and allows selecting between different ODRs (down to 1Hz) or the one-shot mode for battery saving. In one-shot mode, the sensor current consumption falls to 1.75µA. Peripheral addresses are also user-configurable and allow up to four different addresses to be specified by manipulating the jumpers on the back of the breakout. In addition, an interrupt pin is available to signal the application whenever the user-selectable high or low threshold has been exceeded.

Features

  • Uses I2C interface (Qwiic-enabled)
  • Four selectable addresses
    • 0x3C (default), 0x3E, 0x38, 0x3F
  • Operating temperature: -40°C to +125°C
  • Temperature accuracy (max): ± 0.5°C (-10°C to +60°C)
  • Operating voltage: 1.5V to 3.6V
    • Typically 3.3V if using the Qwiic cable
  • Ultralow current: 1.75µA in one-shot mode
  • Programmable thresholds with interrupt pin
  • Programmable operating modes
    • Freerun, one-shot, and Low-ODR
  • NIST traceability

Parts Required

You can connect to the sensor using DuPont-style jumper wire.

I use an ESP32 board from Wemos, the Lolin32 – it should work with any ESP32 board

 

Name Link
ESP32
STTS22H  
Connecting cables

 

Schematic/Connection

I used 3.3v from the ESP32 board

I also used a Qwiic cable, but if you do not have one, there is an unpopulated set of pins you can solder a header to. This is how you would wire this up

esp32 and STTS22H_bb

esp32 and STTS22H_bb

 

Code Example

I installed the Sparkfun library using the Arduino ide

Click the Manage Libraries … menu item, search for STTS22H, and select the Sparkfun STTS22H library like this

This is one of the examples that gets installed with the library, with a  few comments and unused lines removed.

#include <Wire.h>
#include "SparkFun_STTS22H.h"

SparkFun_STTS22H mySTTS; 

float temp; 

void setup()
{

    Wire.begin();

    Serial.begin(115200);

    if( !mySTTS.begin() )
    {
        Serial.println("Did not begin.");
        while(1);
    }

    Serial.println("Ready");

    // Other output data rates can be found in the description
    // above. To change the ODR or mode, the device must first be
    // powered down.
    mySTTS.setDataRate(STTS22H_POWER_DOWN);
    delay(10);
    mySTTS.setDataRate(STTS22H_1Hz);

    // Enables incrementing register behavior for the IC.
    // It is not enabled by default as the datsheet states and
    // is vital for reading the two temperature registers.
    mySTTS.enableAutoIncrement();

    delay(100);
}

void loop()
{

    // Only use data ready for one-shot mode or 1Hz output. 
    if( mySTTS.dataReady() ) 
    {
        // Temperature in different units can be retrieved
        // using the following functions.
        //mySTTS.getTemperatureC(&temp);
        mySTTS.getTemperatureK(&temp);
        Serial.print("Temp: "); 
        Serial.print(temp);
        Serial.println("F"); 
    } 
    delay(1000);

}

 

Output

When run you will see something like this in the serial monitor window

Temp: 68.68F
Temp: 68.67F
Temp: 68.74F
Temp: 68.70F
Temp: 68.72F
Temp: 68.72F

 

Links

https://www.st.com/resource/en/datasheet/stts22h.pdf

1 FacebookTwitterPinterestEmail
Code

Connect a BMP384 pressure sensor to an ESP32 module example

by shedboy71

In this article we look at a temperature and pressure sensor, the BMP384 pressure sensor from Bosch Sensortec, and connect it to an ESP32 board

Sensor Information

The BMP384 can be used for high-resolution measurements (up to 21-bit) and uses a gel-filled cavity to provide extra resistance to liquids (water and other chemicals). This makes it a great option for monitoring pressure near water or in humid environments, though the sensor is not water-proof without an adequate integration concept.

The BMP384 provides excellent accuracy across a wide measurement range (300hPa to 1250hPa and -40 to +85°C) on an incredibly small footprint that uses the Qwiic Micro size (0.75in. x 0.30in. / 19.05mm x 7.62mm) so you can install it in projects with exceptionally tight spaces.

The sensor also features a configurable oversampling setting, a FIFO buffer for storing up to 73 measurements, and a low-pass filter so users can customize the performance based on the application's requirements.

The Qwiic Pressure Sensor communicates over I2C by default, utilizing the handy Qwiic system so no soldering is required to connect it to the rest of your system.

The BMP384 has three operating modes: Sleep Mode, Normal Mode and Forced Mode. In Sleep Mode, the sensor is idle and consumes ~2µA, while in Normal Mode the sensor automatically cycles between measurement and standby periods and consumes ~700µA at peak current draw during measurements.

Forced Mode allows direct control of measurements to wake the sensor from Sleep Mode, take a single-shot measurement, and return the device to Sleep Mode.

This is what the breakout looks like that I purchased, it is from SparkFun

Features

Take note of the supply voltage

  • Supply Voltage Range: 1.65V – 3.6V
  • Current Draw:
    • 700µA – Peak while measuring pressure
    • 3.4 µA @ 1Hz – Pressure and temperature monitoring with Ultra Low Power oversampling settings
    • ~2µA – Sleep Mode
  • Data Transfer Speeds:
    • I2C – 3.4MHz
    • SPI – 10MHz
  • I2C Address: 0x77 (Default), 0x76 (Alternate which can be set under the board by bridging 2 pads using solder)
  • Internal Temperature Sensor

Parts Required

You can connect to the sensor using DuPont-style jumper wire.

The sensor will cost in the range of $20, I did get it along with various others at a decent sale price

You can connect up pretty much any ESP32 board – I used a Lolin 32 from Wemos – first board I had at hand

 

Name Link
ESP32
BMP384
Connecting cables

 

Schematic/Connection

I used 3.3v from the ESP32

I also used a Qwiic cable, but if you do not have one, there is an unpopulated set of pins you can solder a header to. This is how you would wire this up

 

Code Example

I installed the Sparkfun library using the Arduino ide

Click the Manage Libraries … menu item, search for BMP384, and select the Sparkfun BMP384 library like this

This is one of the examples that gets installed with the library, with a  few comments and unused lines removed.

#include <Wire.h>
#include "SparkFunBMP384.h"

// Create a new sensor object
BMP384 pressureSensor;

// I2C address selection
uint8_t i2cAddress = BMP384_I2C_ADDRESS_DEFAULT; // 0x77
//uint8_t i2cAddress = BMP384_I2C_ADDRESS_SECONDARY; // 0x76

void setup()
{
    // Start serial
    Serial.begin(115200);
    Serial.println("BMP384 Example1 begin!");

    // Initialize the I2C library
    Wire.begin();

    // Check if sensor is connected and initialize
    // Address is optional (defaults to 0x77)
    while(pressureSensor.beginI2C(i2cAddress) != BMP3_OK)
    {
        // Not connected, inform user
        Serial.println("Error: BMP384 not connected, check wiring and I2C address!");

        // Wait a bit to see if connection is established
        delay(1000);
    }

    Serial.println("BMP384 connected!");
}

void loop()
{
    // Get measurements from the sensor
    bmp3_data data;
    int8_t err = pressureSensor.getSensorData(&data);

    // Check whether data was acquired successfully
    if(err == BMP3_OK)
    {
        // Acquisistion succeeded, print temperature and pressure
        Serial.print("Temperature (C): ");
        Serial.print(data.temperature);
        Serial.print("\t\t");
        Serial.print("Pressure (Pa): ");
        Serial.println(data.pressure);
    }
    else
    {
        // Acquisition failed, most likely a communication error (code -2)
        Serial.print("Error getting data from sensor! Error code: ");
        Serial.println(err);
    }

    // Only print every second
    delay(1000);
}

 

Output

When run you will see something like this in the serial monitor window

Temperature (C): 20.67 Pressure (Pa): 100386.79
Temperature (C): 20.67 Pressure (Pa): 100403.07
Temperature (C): 20.66 Pressure (Pa): 100388.79
Temperature (C): 20.66 Pressure (Pa): 100406.11

Links

https://www.bosch-sensortec.com/media/boschsensortec/downloads/datasheets/bst-bmp384-ds003.pdf

0 FacebookTwitterPinterestEmail
Hardware

An ESP32 based Heart Rate Development Kit

by shedboy71

In this article we look at a bit of a niche product featuring an ESP32 it is a Heart development kit featuring an ESP32 and a Max30102.

The kit is already comes complete and you get a typical heart rate monitor that you can put a finger in.

You can see this in the image below

The MAX30102 is an integrated pulse oximetry and heart-rate monitor module. It includes internal LEDs, photodetectors, optical elements, and low-noise electronics with ambient light rejection. The MAX30102 provides a complete system solution to ease the design-in process for mobile and wearable devices.

The MAX30102 operates on a single 1.8V power supply and a separate 3.3V power supply for the internal LEDs. Communication is through a standard I2C-compatible interface. The module can be shut down through software with zero standby current, allowing the power rails to remain powered at all times.

The MPU-6050 devices combine a 3-axis gyroscope and a 3-axis accelerometer on the same silicon die, together with an onboard Digital Motion Processor™ (DMP™), which processes complex 6-axis MotionFusion algorithms. The device can access external magnetometers or other sensors through an auxiliary master I²C bus, allowing the devices to gather a full set of sensor data without intervention from the system processor

For precision tracking of both fast and slow motions, the parts feature a user-programmable gyro full-scale range of ±250, ±500, ±1000, and ±2000 °/sec (dps), and a user-programmable accelerometer full-scale range of ±2g, ±4g, ±8g, and ±16g. Additional features include an embedded temperature sensor and an on-chip oscillator with ±1% variation over the operating temperature range

Specifications

  • SoC – Espressif Systems ESP32 dual-core Tensilica SoC with WiFi 4 & Bluetooth connectivity
  • Display – 0.96-inch IPS LCD using a ST7735 SPI controller
  • Sensors
    • MAX30102 heart rate blood oxygen I2C sensor
    • MPU6050 6-axis accelerometer and gyroscope (I2C)
  • Debug – Micro USB port via CP2104 USB to TTL bridge
  • Misc -PCF8563 RTC, user button
  • Battery – 200 mAh; charging voltage and current: 5V, 500mah via micro USB port

 

Development

You can develop using the Arduino IDE and/or PlatformIO. The github link at the bottom has more information

Use Arduino IDE

  1. Install the correct serial port driver CP210X Driver
  2. Change src/main.cpp to src.ino
  3. Copy the files in the lib directory to ~/Arduino/libraries, Windows users copy to Documents/Arduino/libraries
  4. Double-click to open src/src.ino
  5. Change the port to the correct port and select upload

Use PlatformIO

  1. Install the correct serial port driver CP210X Driver
  2. Open directly to change your serial port in platformio.ini, click compile
  • Note: To use TFT_eSPI, you need to select the correct model, you need to select Setup26_TTGO_T_Wristband.h, which has the same definition as T-Wristband, If the copy is in the lib folder, you can ignore it

In the examples directory contains two sample programs, FactoryTest is the factory test file, HeartRateMeter is a simple heart rate meter.

Purchase

The kit costs about £27 – buy from aliexpress

Links

https://github.com/Xinyuan-LilyGO/LilyGo-HeartRate-Kit

0 FacebookTwitterPinterestEmail
Hardware

Another board – the ESP32C3-CORE Development Board

by shedboy71

This is another ESP32 I purchased for the collection

CORE ESP32 core board is a core board designed based on Espressif ESP32-C3, the size is only 21mm*51mm, and the edge of the board is designed with stamp holes, which is convenient for developers to use in different scenarios. 
The core board supports UART, GPIO, SPI, I2C, ADC, PWM and other interfaces, which can be selected according to actual needs.
Here is a picture of the board, it is marked with a website on the back luatos.com/t/esp32c3

Hardware

    • Size length and width 21mm*51mm
    • 1 way SPI FLASH, onboard 4MB, support up to 16MB
    • 2-way UART interface, UART0~UART1, among which the download port is UART0
    • 5 channels of 12-bit ADC, the highest sampling rate is 100KSPS
    • 1 low-speed SPI interface, support master mode
    • 1 way IIC controller
    • 4-way PWM interface, any GPIO can be used
    • 15 GPIO external pins, reusable
    • 2-way SMD LED indicator light
    • 1 way reset button + 1 way BOOT button
    • 1 USB to TTL download and debug port
    • 2.4G PCB onboard antenna

Pinout

Now lets look at the pinout and functions of the board

Pin Number Name Default function multiplexing function
32 GND grounding
31 5V 5V power interface, connected to VBUS of USB
30 BOOT GPIO09, input BOOTMODE
29 IO08 GPIO08, input, output, high impedance
28 IO04 GPIO04, input, output, high impedance I2C_SDA/ADC_4
27 IO05 GPIO05, input, output, high impedance I2C_SCL/ADC_5
26 3.3V Chip power supply, 3.3V
25 GND ground
24 PB_11 GPIO11, input, output, high impedance VDD_SPI
23 IO07 GPIO07, input, output, high impedance SPI2_CS
22 IO06 GPIO06, input, output, high impedance
21 IO10 GPIO10, input, output, high impedance SPI2_MISO
20 IO03 GPIO03, input, output, high impedance SPI2_MOSI/ADC_3
19 IO02 GPIO02, input, output, high impedance SPI2_CK/ADC_2
18 3.3V Chip power supply, 3.3V
17 GND ground
16 5V 5V power interface, connected to VBUS of USB
15 PWB Chip 3.3V power supply control, high level is effective, can be suspended when not in use
14 GND ground
13 3.3V Chip power supply, 3.3V
12 RESET chip reset
11 NC
10 IO13 GPIO13, input, output, high impedance
09 U0_RX GPIO20, input, output, high impedance UART0_RX
08 U0_TX GPIO21, input, output, high impedance UART0_TX
07 GND ground
06 IO19 GPIO19, input, output, high impedance USB_D+
05 IO18 GPIO18, input, output, high impedance USB_D-
04 IO12 GPIO12, input, output, high impedance SPIHD
03 IO01 GPIO1, input, output, high impedance UART1_RX/ADC_1
02 IO00 GPIO0, input, output, high impedance UART1_TX/ADC_0
01 GND ground

 

The ESP32 core board has 2 LEDs on board that can be used.

LED GPIO pin description
D4 IO12 GPIO12 configuration
D5 IO13 GPIO13 configuration

 

There are two buttons on the ESP32 core board, among which the BOOT button can perform the BOOT download function, and the RST button can be used for the reset function, 

Button pin description
BOOT/GPIO9 When the button is pressed, the chip enters the download mode
RST When the button is pressed, the chip resets

 

The CORE ESP32 core board equipped with ESP32-C3 is a version without built-in FLASH, and the external SPI FLASH is mounted by default.

If you encounter a core without external SPI FLASH, you need to pay attention to the specific model of the main chip. Using built-in Flash is GPIO11/12/13not available.

flash pin pin description
SPICS0 GPIO14 configuration, FLASH_CS, chip select
SPIQ GPIO17 configuration, FLASH_D1, data pin 1
SPID GPIO16 configuration, FLASH_D0, data pin 0
SPICLK GPIO15 configuration, FLASH_CK, clock

 

This board seems to be designed to work with a development environment called LuatIDE and LuatOS, so I will check these out but being an ESP32-C£ it will work with Arduino IDE and Micropython

 

Hardware Information

Schematic of CORE-ESP32-C3 development board

New version of CORE-ESP32-C3 development board schematic diagram (version without serial port chip)

https://wiki.luatos.com/pages/tools.html

0 FacebookTwitterPinterestEmail
Hardware

A look at the LILYGO® T5 V2.3.1 2.13inch E-Paper Display

by shedboy71

In this article we look at a development board that contains an ESP32 and an 2.13inch E-paper display

Here is an image of the board.

Specifications

Operating voltage: 3.3V
Interface: 3-wire SPI, 4-wire SPI
Display color: black, white
Grey level: 2
Full refresh time: 8s
Refresh power: 26.4mW
Driver chip：SSD1680
Display Driver：DEPG0213BN/ GDEM0213B74 / GDEM0213B74

2.13 inch/DES electronic paper/ultra wide temperature
This is a 2.13-inch DES electronic paper display (what is DES?), with a resolution of 212×104 and communication via SPI interface
The driver IC includes gate buffer, source buffer, time control logic, oscillator, DC-DC, SRAM, LUT, VCOM, and each panel provides a frame.

Wide operating temperature range: -20c to 60c.

Can be used in cold environment and sunlight, GDEW0213M21 is an excellent choice for shelf label, smart label, smart home application, industrial tool, smart card, outdoor equipment application.
Power consumption: ultra-low power consumption
Viewing angle: 180 degrees
Use in the sun: support
Ultra-wide temperature -20 degrees use: support

Features

What is DES?

  • Characteristics: Compared with other similar products, DES has higher contrast and better display effect.
  • DES products are greater than 1:45, ordinary EPD products are less than 1:25

The driver IC includes：

  • Gate buffer, source buffer, time control logic, oscillator, DC-DC, SRAM, LUT, VCOM, and each panel provides a frame.

Ultra-wide temperature working range: -20℃ ~ 60℃

  • Can be used in cold environment and sunlight, GDEW0213M21 is an excellent choice for shelf label, smart label, smart home application, industrial tool, smart card, outdoor equipment application.
  • Working temperature range of conventional monochromatic electronic ink screen: 0℃-50℃, three-color working temperature 0℃-40℃,ultra-low temperature working temperature: -25℃ ~ 25℃

Purchase

  • If you already have a T-U2T, you can buy the DEPG0213BN No Chip version.

  • If you don't already have a T-U2T, you can purchase the DEPG0213BN T-U2T version.

You can purchase these from alixepress from about £12 – buy it here

Development

Use Arduino IDE

  1. Install the correct serial port driver CP210X Driver
  2. For the first use, you need to select the model you are using at the top of main.cpp, and select the corresponding screen header file
  3. Change src/main.cpp to src.ino
  4. Copy the files in the lib directory to ~/Arduino/libraries, Windows users copy to Documents/Arduino/libraries
  5. Double-click to open src/src.ino
  6. Change the port to the correct port and select upload
  7. Put the data folder in the src directory
  8. Use Arduino ESP32 Sketch data Upload files,if you not install,Download ESP32FS-vX.zip,Extract to <C:\Users\Your User Name\Documents\Arduino\tools>,Open Ardunio IDE, Tools -> ESP32 Sketch data Upload -> Upload

https://github.com/Xinyuan-LilyGO/T5-Ink-Screen-Series

0 FacebookTwitterPinterestEmail
Hardware

A look at the TTGO T4 from LilyGO an ESP32 LCD development board

by shedboy71

The TTGO T4 from LilyGO is an electronic development board based around an ESP32 with a built-in 2.2 inch TFT display. There is also a 2.4inch LCD option as well.

The USB to serial converter makes it easy to program, even using the  Arduino IDE. The board has a micro USB connection with which it can be programmed and/or powered.

Pinout and functions

Specifications:

  • ESP32 chip (240Mhz dual core processor)
  • Flash memory: 4MB
  • PSRAM: 8MB
  • Built-in Wi-Fi
  • Built-in Bluetooth
  • Built-in 2.2 inch TFT display (ILI9341 driver)
  • Built-in power management chip (IP5306) with Li-ion/Li-Po battery charging circuit (charge up to ~2A)
  • USB to serial converter: CP2104 or CH9102 (drivers)
  • Built-in micro SD card connection
  • I2C connector: 5p JST-PH
  • I2C cable included
  • Battery connector: 2p Molex Picoblade
  • Battery cable included
  • Dimensions PCB: 65.9×40.8mm

ILI9341 is a 262,144-color single-chip SOC driver for a-TFT liquid crystal display with resolution of 240 RGB x 320 dots, comprising a 720-channel source driver, a 320-channel gate driver, 172,800 bytes GRAM for graphic display data of 240 RGB x 320 dots, and power supply circuit.

ILI9341 supports parallel 8-/9-/16-/18-bit data bus MCU interface, 6-/16-/18-bit data bus RGB interface and 3-/4-line serial peripheral interface (SPI).

The moving picture area can be specified in internal GRAM by window address function.

The specified window area can be updated selectively, so that moving picture can be displayed simultaneously independent of still picture area.

Purchase

This board costs around £22 for the 2.4 inch version

LILYGO® TTGO T4 V1.3 ILI9341 2.4 inch LCD Display Backlight Adjustment ESP32 Development Board WIFI Wireless Bluetooth Module – Buy this from Aliexpress here

Development

There are several examples on the github repo

Quick Start

  1. Install TFT_eSPI from the Arduino library installation manager
  2. Copy the Buttons in the LilyGo_Txx/lib directory to the <C:\Users\UserName\Documents\Arduino\libraries> directory
  3. Enter <C:\Users\UserName\Documents\Arduino\libraries\TFT_eSPI> to change the configuration file. For different types of boards, you need to enable the corresponding TFT_eSPI setting (select the corresponding pin of the LCD screen).

I have the T4 V1.3 version so I did this

  • Open User_Setup_Select.h in the TFT_eSPI directory and disable it by #include <User_Setup.h>.
  • Uncomment the #include <User_Setups/Setup22_TTGO_T4_v1.3.h> line

  • Select the board according to the following options

    1. Board -> ESP32 -> ESP32 Dev Module
    2. PSRAM -> Enable (if it is TS, you need to select Disable here)
    3. Flash Size -> 4MB(32Mb)
    4. Flash Mode -> DIO
    5. Some other options are filled in according to the actual situation, and the selection is as shown in the figure below

  • Click the right arrow above Arduino IDE to compile and upload (please make sure to install the serial driver and connect the board to the computer via USB)

Check the examples out from

https://github.com/Xinyuan-LilyGO/LilyGo_Txx

1 FacebookTwitterPinterestEmail
Newer Posts
Older Posts

Adblock Detected

Please support us by disabling your AdBlocker extension from your browsers for our website.