Home » Archives for shedboy71
Author

shedboy71

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 Aliexpress link
KX132 Aliexpress link
Connecting cables Male to Male + Male to Female and Female to Female Jumper Wire Dupont Cable

 

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

0 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

0 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 Aliexpress link
STTS22H Aliexpress link
Connecting cables Male to Male + Male to Female and Female to Female Jumper Wire Dupont Cable

 

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

0 FacebookTwitterPinterestEmail
Code

Connect a MMC5603 Triple-axis Magnetometer to an ESP32

by shedboy71

In this article, we look at a Triple-axis Magnetometer, the MMC5603, and connect it to an ESP32 board

Sensor Information

This sensor can sense ranges from ±30 Gauss (±3000uT or ±3mT) with no range-setting required and full 20-bit output up to 1000 Hz rate reading. The range makes it good for reading Earth's magnetic field (which maxes at about 0.6 Gauss) or some basic magnets. It isn't good for very strong rare earth magnets

I bought an Adafruit breakout board, so the MMC5603 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

    • Superior Dynamic Range and Accuracy:
      ±30 G FSR
    • 20bits operation mode
    • 0.0625mG per LSB resolution
    • 2 mG total RMS noise
    • Enables heading accuracy of 1º

Sensor true frequency response up to 1KHz
On-chip automatic degaussing with built-in SET/RESET function

    • Eliminates thermal variation-induced offset error (Null field output)
    • Clears the residual magnetization resulting

from strong external fields
On-chip sensitivity compensation
On-chip temperature sensor
Selftest signal available
Data_ready Interrupt (I3C only)
Low power consumption
1 µA power down current
I2C slave, FAST (≤400 KHz) mode
I3C interface available
1.62V to 3.6V

Parts Required

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

Name Link
ESP32 Aliexpress link
MMC5603 ebay link
Connecting cables Male to Male + Male to Female and Female to Female Jumper Wire Dupont Cable

 

Schematic/Connection

I used 3.3v from the ESP32 – and I also use 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 MMC56x3, and select the Adafruit_MMC56x3 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 magsensor example – there are a few examples

#include <Adafruit_MMC56x3.h>

/* Assign a unique ID to this sensor at the same time */
Adafruit_MMC5603 mmc = Adafruit_MMC5603(12345);

void setup(void) {
  Serial.begin(115200);
  while (!Serial)
    delay(10); // will pause Zero, Leonardo, etc until serial console opens

  Serial.println("Adafruit_MMC5603 Magnetometer Test");
  Serial.println("");

  /* Initialise the sensor */
  if (!mmc.begin(MMC56X3_DEFAULT_ADDRESS, &Wire)) {  // I2C mode
    /* There was a problem detecting the MMC5603 ... check your connections */
    Serial.println("Ooops, no MMC5603 detected ... Check your wiring!");
    while (1) delay(10);
  }

  /* Display some basic information on this sensor */
  mmc.printSensorDetails();
}

void loop(void) {
  // Get a new sensor event 
  sensors_event_t event;
  mmc.getEvent(&event);

  // Display the results (magnetic vector values are in micro-Tesla (uT))
  Serial.print("X: ");
  Serial.print(event.magnetic.x);
  Serial.print("  ");
  Serial.print("Y: ");
  Serial.print(event.magnetic.y);
  Serial.print("  ");
  Serial.print("Z: ");
  Serial.print(event.magnetic.z);
  Serial.print("  ");
  Serial.println("uT");

  // Read and display temperature
  float temp_c = mmc.readTemperature();
  Serial.print("Temp: "); 
  Serial.print(temp_c); 
  Serial.println(" *C");
  // Delay before the next sample
  delay(1000);
}

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

X: -3276.80 Y: -3276.80 Z: -3276.80 uT
Temp: 21.00 *C
X: -3276.80 Y: -3276.80 Z: -3276.80 uT
Temp: 25.00 *C
X: -3276.80 Y: -3276.80 Z: -3276.80 uT
Temp: 25.80 *C

This is the compass example – this would be good with one of those round LCD displays – a clue to a future project

#include <Adafruit_MMC56x3.h>

/* Assign a unique ID to this sensor at the same time */
Adafruit_MMC5603 mag = Adafruit_MMC5603(12345);

void setup(void) {
  Serial.begin(115200);
  while (!Serial)
    delay(10); // will pause Zero, Leonardo, etc until serial console opens

  Serial.println("Adafruit_MMC5603 Magnetometer Compass");
  Serial.println("");

  /* Initialise the sensor */
  if (!mag.begin(MMC56X3_DEFAULT_ADDRESS, &Wire)) {  // I2C mode
    /* There was a problem detecting the MMC5603 ... check your connections */
    Serial.println("Ooops, no MMC5603 detected ... Check your wiring!");
    while (1) delay(10);
  }
}

void loop(void)
{
  /* Get a new sensor event */
  sensors_event_t event;
  mag.getEvent(&event);

  float Pi = 3.14159;

  // Calculate the angle of the vector y,x
  float heading = (atan2(event.magnetic.y,event.magnetic.x) * 180) / Pi;

  // Normalize to 0-360
  if (heading < 0)
  {
    heading = 360 + heading;
  }
  Serial.print("Compass Heading: ");
  Serial.println(heading);
  delay(500);
}

The output of this example was this, I moved the sensor around

Compass Heading: 279.68
Compass Heading: 313.03
Compass Heading: 290.95
Compass Heading: 344.84
Compass Heading: 294.77

Links

https://media.digikey.com/pdf/Data%20Sheets/MEMSIC%20PDFs/MMC5603NJ_RevB_7-12-18.pdf

0 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 Aliexpress link
BMP384 Aliexpress link
Connecting cables Male to Male + Male to Female and Female to Female Jumper Wire Dupont Cable

 

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

0 FacebookTwitterPinterestEmail
Hardware

A 4.3 inch TFT and ESP32-S3

by shedboy71

This LCD module uses an ESP32-S3-WROOM-1 module as the main controller, the main controller is a dual-core MCU, integrated WI-FI and Bluetooth functions, the frequency can reach 240MHz, 512KB SRAM, 384KB ROM, 8M PSRAM,Flash size is 16MB, The display resolution is 480*272 or 800*480, resistive touch or Capacitive touch.

The module includes an LCD display screen, backlight control circuit, touch screen control circuit . Reserve the TF card interface ,IO port interface, this module supports development in arduino IDE, ESP IDE, Micropython and Mixly.

ESP32-S3 is a low-power MCU-based system-on-chip (SoC) that supports 2.4 GHz Wi-Fi and Bluetooth®LowEnergy (Bluetooth LE).

It consists of high-performance dual-core microprocessor (Xtensa®32-bit LX7), a lowpower coprocessor, a Wi-Fi baseband, a Bluetooth LE baseband, RF module, and peripherals.

Features

  • ESP32-S3-WROOM Controller
  • Working voltage 4.75-5.25V
  • Resolution: 800*480 IPS
  • Dimension: 4.3 inch
  • Capacitive Touch
  • Onboard SD card socket
  • Extended IO for applications' usage
  • Onboard Photosensitive resistor (for auto Backlight adjustment)
  • Onboard RGB LED

Display color RGB 65K color
Size – 4.3 inch
Type – TFT
Driver chip – ILI9485
Resolution – 480*272(Pixel)
Effective display area – 95.04* 53.86(mm)
Module size – 105.5*74(mm)
View >60°
Operating temperature is -20℃~70℃
Storage temperature is -30℃~80℃
Operating Voltage is 5V
Power consumption comes in at about 260mA
Product weight comes in at about 130g

Software setup

To ensure the running environment, the same version is recommended.

All the projects are based on ESP32-S3 development board.

1.Install the Arduino IDE V1.8.19.

2.Install the ESP32 boards supporting V2.0.5

3.Click “Tools>Board>Boards Manager” to search for and install the ESP32 library:

Summary

A nice big LCD screen at a price of $27 which can be programmed using the Arduino IDE

A couple of examples are supplied via the links, the TFT comes with an sd card fitted

Links

https://www.makerfabs.com/sunton-esp32-s3-4-3-inch-ips-with-touch.html

0 FacebookTwitterPinterestEmail
Hardware

An ESP32 heart rate monitor kit

by shedboy71

In this article we look at another interesting idea for an ESP32., its an ESP32 heart rate monitor kit.

Its an all in one development kit which contains the development board, a touch enabled LCD display and its all contained in a typical finger sensor that you get for checking your blood oxygen levels.

Pinout

Features

Chipset: ESP32 WIFI/Bluetooth
USB TO TTL: CP2104
LCD: 0.96 IPS LCD
Heart rate blood oxygen sensor: MAX30102
Six-axis attitude sensor chip: MPU6050
RTC: PCF8563
Customizable buttons: Button
Battery: 200mah
Charging voltage and current: 5V, 500mah

Individual sensors

MAX30102

The MAX30102 is an integrated pulse oximetry and heart-rate monitor biosensor 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.

MPU-6050

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.

PCF8563

The PCF8563 is a CMOS1 Real-Time Clock (RTC) and calendar optimized for low power
consumption. A programmable clock output, interrupt output, and voltage-low detector are
also provided.

All addresses and data are transferred serially via a two-line bidirectional I2C-bus.

Maximum bus speed is 400 kbit/s. The register address is incremented automatically after each written or read data byte.

Development

The files are available on the github archive – https://github.com/Xinyuan-LilyGO/LilyGo-HeartRate-Kit

Download all the files from the github repository above

  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

Purchase

The development board costs about £30

LILYGO®TTGO Heart Rate Programming Development Kit ESP32-D0WDQ6-V3 Flash 16MB WIFI Bluetooth IPS 0.96 LCD – Buy here

0 FacebookTwitterPinterestEmail
Hardware

An ESP32 based board from Seeedstudio in its XIAO form factor.

by shedboy71

In this article we look at an ESP32 based board from Seeedstudio in its XIAO form factor.

The Seeed Studio XIAO ESP32C3 is a mini development board based on the Espressif ESP32-C3 WiFi/Bluetooth dual-mode chip.

The ESP32-C3 is a 32-bit RISC-V CPU, which includes an Floating Point Unit for 32-bit single-precision arithmetic with powerful computing power. It supports IEEE 802.11 b/g/n WiFi, and Bluetooth 5 (LE) protocols. This board comes included with an external antenna to increase the signal strength for your wireless applications.

It also has a very small form-factor coming in at 21 x 17.5mm – a true thumb sized board.

It has 11 digital I/O pins that can be used as PWM pins and 4 analog I/O that can be used as ADC pins. It supports four serial interfaces such as UART, I2C, SPI and I2S.

There is also a reset button and a bootloader mode button on the board.

Being an XIAO form factor this means there are a couple of generic add-on boards that can be purchased and used – an expansion board and one for the popular Grove connectors, modules and sensors

Specifications

Processor ESP32-C3
RISC-V single-core 32-bit chip processor with a four-stage pipeline that operates at up to 160 MHz
Wireless 2.4GHz Wi-Fi subsystem
Bluetooth 5.0/ Bluetooth mesh
On-chip Memory 400KB SRAM & 4MB Flash
Interface 1x UART, 1x I2C, 1x I2S, 1x SPI,11x GPIO(PWM), 4x ADC
1x Reset button, 1x Boot button
Dimensions 21 x 17.5mm
Power Circuit operating voltage: 3.3V@200mA
Charging current: 50mA/100mA
Input voltage (VIN): 5V
Deep Sleep Power Consumption Deep Sleep Mode: >44 μA
Wi-Fi Enabled Power Consumption Active Mode: <75 mA
Modem-sleep Mode: <25 mA
Light-sleep Mode: <4 mA
BLE Enabled Power Consumption Modem-sleep Mode: <27 mA
Light-sleep Mode: <10 mA

 

Being a low power device it is ideal for IoT applications and that small and compact size also means that its a practical option for wearables as well

Software setup

  • Step 1. Download and Install the latest version of Arduino IDE according to your operating system
  • Step 2. Launch the Arduino application
  • Step 3. Add ESP32 board package to your Arduino IDE

Navigate to File > Preferences, and fill “Additional Boards Manager URLs” with the url below: https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_dev_index.json

Navigate to Tools > Board > Boards Manager…, type the keyword “esp32” in the search box, select the latest version of ****esp32****, and install it.

  • Step 4. Select your board and port

Navigate to Tools > Board > ESP32 Arduino and select “XIAO_ESP32C3“. The list of boards is long and you need to scroll to the bottom to reach it.

Now you are ready to go and

Purchase

Aliexpress click here

Links

ESP32C3 Datasheet

XIAO ESP32 Schematic

XIAO ESP32 Eagle Libraries

0 FacebookTwitterPinterestEmail
Newer Posts
Older Posts

Adblock Detected

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