Home » Archives for shedboy71 » Page 3
Author

shedboy71

Hardware

The Lilygo Mini E-Paper Core a 1.02-inch e-Paper display device

by shedboy71

In this article we look at a new e-Paper-based device from Chinese manufacturer Lilygo that offers a 1.02-inch e-Paper display that is contained inside a 3D printed enclosure.

The device has other features and also comes with a microSD card socket that also serves as the primary storage, a reset button as well as a three-way user button.

The tiny low-power display also offers headers for GPIOs, ADC, DAC, SPI, and more. You can see the device pinout underneath

The all important microcontroller is a ESP32-PICO-D4

ESP32-PICO-D4 SiP specifications:

SoC – ESP32 with two Tensilica LX6 cores, 448 KB ROM, 520 KB SRAM (inc. 8KB RTC memory), 1kbit eFuse
On-module Flash – 4MB SPI flash
Connectivity
WiFi – 802.11 b/g/n/e/i (802.11n up to 150 Mbps)
Bluetooth – Bluetooth V4.2 BR/EDR and BLE specification; ; class-1, class-2 and class-3 transmitter; Audio: CVSD and SBC
SIP Interfaces
SD card, UART, SPI, SDIO, LED PWM, Motor PWM, I2S, I2C, IR
GPIO, capacitive touch sensor, ADC, DAC, LNA pre-amplifier
Sensors – On-chip Hall sensor & temperature sensor
Clock – On-module 40 MHz crystal
Power supply – 2.3 ~ 3.6V

The module requires a downloader called a T-U2T as the board does not have a USB to serial chip on it. You can buy the module with or without one.

Development

A couple of suggested ways to start development

PlatformIO

Install VSCODE an dPython
Search for the PlatformIO plug-in in the VSCODE extension and install it.
After the installation is complete and you have reloaded, there will be a small house icon in the lower left corner. Click to display the Platformio IDE home page
Go to file – > Open folder – > Select the LilyGO-Mini-Epaper folder and click the (√) symbol in the lower left corner to compile (→) for upload.

Arduino IDE

You need to visit the link below

Copy all the folders in the lib directory to “C:\User\<YourName>\Documents\Arduino\libraries”
At the top of the sketch, define the model of the board and screen to be used
Select ESP32 Pico Kit in the development board, and keep the other options as default
If you do not find the ESP32 series in the development board, then you should see the following installation method – https://github.com/espressif/arduino-esp32/blob/master/docs/arduino-ide/boards_manager.md

Purchase

This costs around £24 from Aliexpress with the downloader, if you don’t need the downloader it costs about £18 – buy the product here

Link

https://github.com/Xinyuan-LilyGO/LilyGO-Mini-Epaper

1 FacebookTwitterPinterestEmail
Hardware

Espressif unveils the ESP32-C5 a Dual-Band Wi-Fi 6 and BLE RISC-V SoC

by shedboy71
Espressif’s ESP32-C5 is the industry’s first RISC-V SoC solution that supports 2.4 and 5 GHz dual-band Wi-Fi 6, along with Bluetooth LE. It is designed for applications that require high-efficiency wireless transmissions.

Espressif Systems (SSE: 688018.SH) announces today the release of ESP32-C5, a highly integrated MCU with 2.4 and 5 GHz dual-band Wi-Fi 6, as well as Bluetooth 5 (LE) connectivity. The ESP32-C5 enriches Espressif’s Wi-Fi 6 solutions as a follow-up to the ESP32-C6 SoC, which was announced last year.

 

ESP32-C5 packs a dual-band Wi-Fi 6 (802.11ax) radio, along with the 802.11b/g/n standard for backward compatibility. The Wi-Fi 6 support is optimised for IoT devices, as the SoC supports a 20MHz bandwidth for the 802.11ax mode, and a 20/40MHz bandwidth for the 802.11b/g/n mode.

 

ESP32-C5 has a 32-bit, RISC-V, single-core processor which can clock up to 240 MHz in speed. It has a 400KB SRAM, 384KB of ROM, and it works with external flash. It has more than 20 programmable GPIOs, while supporting all the commonly-used peripheral and the best-in-class security features. Also included is an SDIO 2.0 Slave interface.

ESP32-C5 Block Diagram

 

The support for the 5GHz band provides customers with a more stable and low-latency wireless connectivity in cases where less traffic and lower interference are needed for critical applications. It gives end-users the option of assigning different IoT devices to different networks, according to the criticality of the devices in hand. The 5GHz band also supports hosts of high throughput applications, such as live-streaming devices, Wi-Fi dongles, IP Cameras, etc. By integrating a dual-band connectivity into their devices, customers may enjoy maximum flexibility, while future-proofing their solutions.

 

The 802.11ax standard (Wi-Fi 6) used in ESP32-C5 contains a variety of added features which provide concrete benefits for IoT devices. For example, ESP32-C5 supports the OFDMA (Orthogonal Frequency Division Multiple Access) mechanism for both uplink and downlink communications, as well as the MU-MIMO capability for downlink. Both of these features enable high efficiency and low latency in congested wireless environments, while also improving connectivity in high density environments. Another important feature of the 802.11ax standard is the Target Wake Time (TWT), which allows devices to sleep for an extended time-period, with assistance from an 802.11ax-capable Wi-Fi access point. This feature makes possible the use of ESP32-C5 in battery-operated devices that can last for years, while staying connected non-stop.

 

ESP32-C5 is supported on Espressif’s open-source ESP-IDF, which already powers millions of devices in the field. This ensures the availability of a robust SDK and tools, as well as an easy application migration path for developers. For customers who would like to use ESP32-C5 as a communication co-processor with an external host, ESP-AT and ESP-Hosted SDKs are available, too. ESP-AT provides a simple AT command-based interface for MCU hosts, whereas ESP-Hosted provides a standard 802.11 interface for Linux hosts.

0 FacebookTwitterPinterestEmail
m5stick and env 3
Hardware

An add on for the M5StickC the ENV-III Unit

by shedboy71

In this article we look at an add-on hat for the M5StickC and M5StickC-plus called the ENV 3 sensor.

The env 3 hat is able to detect the temperature, humidity and air pressure.

This product relates via I2C protocol which allows you to obtain 3 types of environment data thru just 2 pins, together with the tiny body, makes it a powerful application for environment data collecting.

The sensor comes with a cable for connecting it to the m5stick base unit

M5Stick C

M5Stick C

It comprises of the following sensors

SHT30 : SHT30 is a high-precision and low-power digital temperature and humidity sensor

QMP6988 : QMP6988 is an absolute air pressure sensor specially designed for mobile applications, with high accuracy and stability, suitable for environmental data collection and detection types of projects.

 

Specification

Resources Parameter
Maximum temperature measurement range -40 ~ 120 ℃
Highest measurement accuracy 0 ~ 60 ℃/±0.2℃
Humidity measurement range/error 10 ~ 90 %RH / ±2%
Maximum measured value of air pressure/resolution/error 300 ~ 1100hPa / 0.06Pa / ±3.9Pa
Communication protocol I2C: SHT30(0x44), QMP6988(0x70)
Working temperature 32°F to 104°F (0°C to 40°C )

Purchase

M5Stack Official ENV III Unit with Temperature Humidity Air Pressure Sensor (SHT30+QMP6988)

Layout

I used the grove port to connect the sensor to the M5StickC

m5stick and env 3

m5stick and env 3

Code

For Arduino development you need to add ESP32 support via the board manager by adding the following ESP32 Boards Manager url to the Additional Boards Manager URLs:

https://dl.espressif.com/dl/package_esp32_index.json

Once all of the required files are downloaded then you need to Navigate to Tools->Board:->Boards Manager and then Search ESP32 in the pop-up window, find it and click Install

Under Tools->Board:-> ESP32 Arduino you will see M5Stick-C in the list

You can then install the MStickC library like this

Open Arduino IDE, then Select Sketch->Include Library->Manage Libraries. Search M5StickC , find it and click Install.

You can find the example below under examples -> Unit -> ENVIII_SHT30_QMP6988

[codesyntax lang=”cpp”]

#include <M5StickC.h>
#include "Adafruit_Sensor.h"
#include <Adafruit_BMP280.h>
#include "UNIT_ENV.h"

SHT3X sht30;
QMP6988 qmp6988;

float tmp = 0.0;
float hum = 0.0;
float pressure = 0.0;

void setup() {
  M5.begin(); //Init M5StickC.  初始化M5StickC
  M5.Lcd.setRotation(3);  //Rotate the screen. 
  Wire.begin(); //Wire init, adding the I2C bus.
  qmp6988.init();
  M5.lcd.println(F("ENV Unit III test"));
}

void loop() {
  pressure = qmp6988.calcPressure();
  if(sht30.get()==0){ //Obtain the data of shT30.  获取sht30的数据
    tmp = sht30.cTemp;  //Store the temperature obtained from shT30.  
    hum = sht30.humidity; //Store the humidity obtained from the SHT30. 
  }else{
    tmp=0,hum=0;
  }
  M5.lcd.fillRect(0,20,100,60,BLACK); //Fill the screen with black (to clear the screen)
  M5.lcd.setCursor(0,20);
  M5.Lcd.printf("Temp: %2.1f  \r\nHumi: %2.0f%%  \r\nPressure:%2.0fPa\r\n", tmp, hum, pressure);
  delay(2000);
}

[/codesyntax]

When you run this it should display various readings on the display

 

Links

 

0 FacebookTwitterPinterestEmail
ESP32 and VL6180X layout
Code

ESP32 and VL6180X module arduino example

by shedboy71

In this article we connect an VL6180X device to an ESP32

Lets look at the sensor

Sensor Information

First lets look at some information about the sensor from the manufacturer

The VL6180X is a ground-breaking technology allowing absolute distance to be measured independent of target reflectance.

Instead of estimating the distance by measuring the amount of light reflected back from the object (which is significantly influenced by color and surface), the VL6180X precisely measures the time the light takes to travel to the nearest object and reflect back to the sensor (Time-of-Flight).

Combining an IR emitter, a range sensor and an ambient light sensor, the VL6180X is easy to integrate and saves the end-product maker long and costly optical and mechanical design optimizations.

The module is designed for low power operation. Ranging and ALS measurements can be automatically performed at user defined intervals. Multiple threshold and interrupt schemes are supported to minimize host operations.

Host control and result reading is performed using an I2C interface. Optional additional functions, such as measurement ready and threshold interrupts, are provided by two programmable GPIO pins.

Key Features

  • Three-in-one smart optical module
    • Proximity sensor
    • Ambient Light Sensor
    • VCSEL light source
  • Fast, accurate distance ranging
    • Measures absolute range from 0 to above 10 cm (ranging beyond 10cm is dependent on conditions)
    • Independent of object reflectance
    • Ambient light rejection
    • Cross-talk compensation for cover glass
  • Gesture recognition
    • Distance and signal level can be used by host system to implement gesture recognition
  • Ambient light sensor
    • High dynamic range
    • Accurate/sensitive in ultra-low light
    • Calibrated output value in lux
  • Two programmable GPIO
    • Window and thresholding functions for both ranging and ALS

This was my sensor of choice that I used

Parts Required

The sensor you can pick up in the $12 price range – you can connect to the sensor using a standard header the classic dupont style jumper wire.

 

Name Link
ESP32
VL6180X
Connecting cables

 

Schematic/Connection

ESP32 and VL6180X layout

ESP32 and VL6180X layout

Code Example

This uses a library from Adafruit installed using the Library Manager in the Arduino IDE. search for VL6180X, and select the Adafruit_VL6180X library. You will also need to add another couple of libraries Adafruit BusIO library and the Adafruit Unified Sensor library

[codesyntax lang=”cpp”]

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

Adafruit_VL6180X vl = Adafruit_VL6180X();

void setup() {
  Serial.begin(115200);

  // wait for serial port to open on native usb devices
  while (!Serial) {
    delay(1);
  }
  
  Serial.println("Adafruit VL6180x test!");
  if (! vl.begin()) {
    Serial.println("Failed to find sensor");
    while (1);
  }
  Serial.println("Sensor found!");
}

void loop() {
  float lux = vl.readLux(VL6180X_ALS_GAIN_5);

  Serial.print("Lux: "); Serial.println(lux);
  
  uint8_t range = vl.readRange();
  uint8_t status = vl.readRangeStatus();

  if (status == VL6180X_ERROR_NONE) {
    Serial.print("Range: "); Serial.println(range);
  }

  // Some error occurred, print it out!
  
  if  ((status >= VL6180X_ERROR_SYSERR_1) && (status <= VL6180X_ERROR_SYSERR_5)) {
    Serial.println("System error");
  }
  else if (status == VL6180X_ERROR_ECEFAIL) {
    Serial.println("ECE failure");
  }
  else if (status == VL6180X_ERROR_NOCONVERGE) {
    Serial.println("No convergence");
  }
  else if (status == VL6180X_ERROR_RANGEIGNORE) {
    Serial.println("Ignoring range");
  }
  else if (status == VL6180X_ERROR_SNR) {
    Serial.println("Signal/Noise error");
  }
  else if (status == VL6180X_ERROR_RAWUFLOW) {
    Serial.println("Raw reading underflow");
  }
  else if (status == VL6180X_ERROR_RAWOFLOW) {
    Serial.println("Raw reading overflow");
  }
  else if (status == VL6180X_ERROR_RANGEUFLOW) {
    Serial.println("Range reading underflow");
  }
  else if (status == VL6180X_ERROR_RANGEOFLOW) {
    Serial.println("Range reading overflow");
  }
  delay(500);
}

[/codesyntax]



Output


Here is  an example of what I saw in the serial monitor window


Lux: 0.00

Range: 43

Lux: 0.00

Range: 40

Lux: 0.00

Range: 43

Lux: 0.00

Range: 11

Lux: 0.00

Range: 12


Links


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


									            

        


		            

								                    

						0						FacebookTwitterPinterestEmail                    

				            

		    








	
		
			                

										                        
							                                ESP32 and ICM20948 layout                        
					                

			
			
    

		            
Code

		
        
ESP32 and ICM-20948 MotionTracking device arduino example

				

			by 										shedboy71
									
					

					    


    

        

            

									
In this article we connect an ICM-20948 9-axis Motion Tracking device to an ESP32


Lets look at the sensor


Sensor Information






The ICM-20948 is the world’s lowest power 9-axis Motion Tracking device that is ideally suited for Smartphones, Tablets, Wearable Sensors, and IoT applications.


    

  • 1/3 the power of existing 9-axis devices
    • 

  • 3-axis gyroscope, 3-axis accelerometer, 3-axis compass, and a Digital Motion Processor™ (DMPTM) in a 3x3x1mm (24-pin QFN) package
    • 

  • DMP offloads computation of motion processing algorithms from the host processor, improving system power performance
    • 

  • Software drivers are fully compliant with Google’s latest Android release
    • 

  • EIS FSYNC support
    • 



ICM-20948 supports an auxiliary I2C interface to external sensors, on-chip 16-bit ADCs, programmable digital filters, an embedded temperature sensor, and programmable interrupts.


The device features an operating voltage range down to 1.71V. Communication ports include I 2C and high speed SPI at 7MHz.




Features


• Lowest Power 9-Axis Device at 2.5 mW

• 3-Axis Gyroscope with Programmable FSR of ±250 dps, ±500 dps, ±1000 dps, and ±2000 dps

• 3-Axis Accelerometer with Programmable FSR of ±2g, ±4g, ±8g, and ±16g

• 3-Axis Compass with a wide range to ±4900 µT

• Onboard Digital Motion Processor (DMP)

• Android support

• Auxiliary I2C interface for external sensors

• On-Chip 16-bit ADCs and Programmable Filters

• 7 MHz SPI or 400 kHz Fast Mode I²C

• Digital-output temperature sensor

• VDD operating range of 1.71V to 3.6V


Parts Required


The sensor you can pick up in the $12 price range – you can connect to the sensor using a standard header the classic dupont style jumper wire.


 






Name
Link





ESP32








ICM20948








Connecting cables










 


Schematic/Connection


ESP32 and ICM20948 layout
ESP32 and ICM20948 layout


 


Code Example


This uses a library from Adafruit installed using the Library Manager in the Arduino IDE. search for ICM20X, and select the Adafruit_ICM20X library. You will also need to add another couple of libraries Adafruit BusIO library and the Adafruit Unified Sensor library


My sensor I2C address was 0x68 so I had to modify the library


The file that needed to be modified – Adafruit_ICM20948.h and then change this line


#define ICM20948_I2CADDR_DEFAULT 0x68 ///< ICM20948 default i2c address


And now for the example


// Basic demo for accelerometer readings from Adafruit ICM20948

#include <Adafruit_ICM20X.h>
#include <Adafruit_ICM20948.h>
#include <Adafruit_Sensor.h>
#include <Wire.h>

Adafruit_ICM20948 icm;
uint16_t measurement_delay_us = 65535; // Delay between measurements for testing
// For SPI mode, we need a CS pin
#define ICM_CS 10
// For software-SPI mode we need SCK/MOSI/MISO pins
#define ICM_SCK 13
#define ICM_MISO 12
#define ICM_MOSI 11

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

  Serial.println("Adafruit ICM20948 test!");

  // Try to initialize!
  if (!icm.begin_I2C()) {
    // if (!icm.begin_SPI(ICM_CS)) {
    // if (!icm.begin_SPI(ICM_CS, ICM_SCK, ICM_MISO, ICM_MOSI)) {

    Serial.println("Failed to find ICM20948 chip");
    while (1) {
      delay(10);
    }
  }
  Serial.println("ICM20948 Found!");
  // icm.setAccelRange(ICM20948_ACCEL_RANGE_16_G);
  Serial.print("Accelerometer range set to: ");
  switch (icm.getAccelRange()) {
  case ICM20948_ACCEL_RANGE_2_G:
    Serial.println("+-2G");
    break;
  case ICM20948_ACCEL_RANGE_4_G:
    Serial.println("+-4G");
    break;
  case ICM20948_ACCEL_RANGE_8_G:
    Serial.println("+-8G");
    break;
  case ICM20948_ACCEL_RANGE_16_G:
    Serial.println("+-16G");
    break;
  }
  Serial.println("OK");

  // icm.setGyroRange(ICM20948_GYRO_RANGE_2000_DPS);
  Serial.print("Gyro range set to: ");
  switch (icm.getGyroRange()) {
  case ICM20948_GYRO_RANGE_250_DPS:
    Serial.println("250 degrees/s");
    break;
  case ICM20948_GYRO_RANGE_500_DPS:
    Serial.println("500 degrees/s");
    break;
  case ICM20948_GYRO_RANGE_1000_DPS:
    Serial.println("1000 degrees/s");
    break;
  case ICM20948_GYRO_RANGE_2000_DPS:
    Serial.println("2000 degrees/s");
    break;
  }

  //  icm.setAccelRateDivisor(4095);
  uint16_t accel_divisor = icm.getAccelRateDivisor();
  float accel_rate = 1125 / (1.0 + accel_divisor);

  Serial.print("Accelerometer data rate divisor set to: ");
  Serial.println(accel_divisor);
  Serial.print("Accelerometer data rate (Hz) is approximately: ");
  Serial.println(accel_rate);

  //  icm.setGyroRateDivisor(255);
  uint8_t gyro_divisor = icm.getGyroRateDivisor();
  float gyro_rate = 1100 / (1.0 + gyro_divisor);

  Serial.print("Gyro data rate divisor set to: ");
  Serial.println(gyro_divisor);
  Serial.print("Gyro data rate (Hz) is approximately: ");
  Serial.println(gyro_rate);

  // icm.setMagDataRate(AK09916_MAG_DATARATE_10_HZ);
  Serial.print("Magnetometer data rate set to: ");
  switch (icm.getMagDataRate()) {
  case AK09916_MAG_DATARATE_SHUTDOWN:
    Serial.println("Shutdown");
    break;
  case AK09916_MAG_DATARATE_SINGLE:
    Serial.println("Single/One shot");
    break;
  case AK09916_MAG_DATARATE_10_HZ:
    Serial.println("10 Hz");
    break;
  case AK09916_MAG_DATARATE_20_HZ:
    Serial.println("20 Hz");
    break;
  case AK09916_MAG_DATARATE_50_HZ:
    Serial.println("50 Hz");
    break;
  case AK09916_MAG_DATARATE_100_HZ:
    Serial.println("100 Hz");
    break;
  }
  Serial.println();

}

void loop() {

  //  /* Get a new normalized sensor event */
  sensors_event_t accel;
  sensors_event_t gyro;
  sensors_event_t mag;
  sensors_event_t temp;
  icm.getEvent(&accel, &gyro, &temp, &mag);

  Serial.print("\t\tTemperature ");
  Serial.print(temp.temperature);
  Serial.println(" deg C");

  /* Display the results (acceleration is measured in m/s^2) */
  Serial.print("\t\tAccel X: ");
  Serial.print(accel.acceleration.x);
  Serial.print(" \tY: ");
  Serial.print(accel.acceleration.y);
  Serial.print(" \tZ: ");
  Serial.print(accel.acceleration.z);
  Serial.println(" m/s^2 ");

  Serial.print("\t\tMag X: ");
  Serial.print(mag.magnetic.x);
  Serial.print(" \tY: ");
  Serial.print(mag.magnetic.y);
  Serial.print(" \tZ: ");
  Serial.print(mag.magnetic.z);
  Serial.println(" uT");

  /* Display the results (acceleration is measured in m/s^2) */
  Serial.print("\t\tGyro X: ");
  Serial.print(gyro.gyro.x);
  Serial.print(" \tY: ");
  Serial.print(gyro.gyro.y);
  Serial.print(" \tZ: ");
  Serial.print(gyro.gyro.z);
  Serial.println(" radians/s ");
  Serial.println();

  delay(500);

}


 


Output


Here is  an example of what I saw in the serial monitor window


Temperature 33.31 deg C

Accel X: -1.23 Y: 0.00 Z: 1.22 m/s^2

Mag X: 1185.60 Y: 2456.85 Z: 75.00 uT

Gyro X: 0.00 Y: 0.00 Z: -0.05 radians/s


Temperature 33.31 deg C

Accel X: -1.23 Y: 0.00 Z: 1.22 m/s^2

Mag X: 1185.60 Y: 2456.85 Z: 75.00 uT

Gyro X: 0.00 Y: 0.00 Z: -0.05 radians/s


Temperature 33.31 deg C

Accel X: -1.23 Y: 0.00 Z: 1.22 m/s^2

Mag X: 1185.60 Y: 2456.85 Z: 75.00 uT

Gyro X: 0.00 Y: 0.00 Z: -0.05 radians/s


 


Links


 


 


 


 






									            

        


		            

								                    

						0						FacebookTwitterPinterestEmail                    

				            

		    








	
		
			                

										                        
							                                                        
					                

			
			
    

		            
Hardware

		
        
an ESP32-PICO-D4 witha 1.02 inch e-paper display

				

			by 										shedboy71
									
					

					    


    

        

            

									
In this article we look at an ESP32 board which is a combination of an ESP32-PICO-D4 and a 1.02 inch e-paper display


The board does not have a USB to serial chip and therefore you need a download adapter which can be bought with the display


There is a micro sd (tf) card slot and also 2 GPIO expansion headers


Features


– 3D printed shell

– ESP32-PICO-D4 4MB Flash WIFI/Bluetooth

– Low power consumption sleep mode is about 10uA

– 1.02 inch e-paper @ 128 X 80

– Three-way toggle button

– TF card socket

– Reset button

– Battery charging and discharging circuit

– Bottom expansion interface (2.54 female row)

– T-U2T downloader (if you already have this downloader, you don’t need to buy it again)

– TYPE-C USB


Pinout




Purchase


About $20 for this board with the downloader


AliExpress – LILYGO® TTGO Mini E-Paper Core 1.02 Inch TF Card ESP32 PICO / T- U2T USB to TTL Downloader Wifi BLE Module Development Board


Arduino Instructions


Donwload all the files from https://github.com/Xinyuan-LilyGO/LilyGO-Mini-Epaper


    

  1. Copy all the folders in the lib directory to "C:\User\<YourName>\Documents\Arduino\libraries"
    2. 

  2. At the top of the sketch, define the model of the board and screen to be used
    3. 

  3. Select ESP32 Pico Kit in the development board, and keep the other options as default
    4. 

  4. If you do not find the ESP32 series in the development board, then you should see the following installation method How to install ESP32 in ArduinoIDE
    5. 

  5. For the version of the board you purchased, please check the product link below
    6. 

  6. When you think there is a problem with your board, you can pull the binary file corresponding to your screen model in the firmware directory, follow the SETTING.png settings in the directory, download it to the board, and then observe the execution.
    7. 



Code


This is one of the default examples there are several in the download above.


[codesyntax lang=”cpp”]


/*
    LilyGo Ink Screen Series u8g2Fonts Test
        - Created by Lewis he
*/

// According to the board, cancel the corresponding macro definition
// #define LILYGO_T5_V213
// #define LILYGO_T5_V22
// #define LILYGO_T5_V24
// #define LILYGO_T5_V28
#define LILYGO_T5_V102
// #define LILYGO_T5_V266
// #define LILYGO_EPD_DISPLAY_102
// #define LILYGO_EPD_DISPLAY_154


#include <boards.h>
#include <GxEPD.h>

#if defined(LILYGO_T5_V102) || defined(LILYGO_EPD_DISPLAY_102)
#include <GxGDGDEW0102T4/GxGDGDEW0102T4.h> //1.02" b/w
#elif defined(LILYGO_T5_V266)
#include <GxDEPG0266BN/GxDEPG0266BN.h>    // 2.66" b/w   form DKE GROUP
#elif defined(LILYGO_T5_V213)
#include <GxDEPG0213BN/GxDEPG0213BN.h>    // 2.13" b/w  form DKE GROUP
#else
// #include <GxGDGDEW0102T4/GxGDGDEW0102T4.h> //1.02" b/w
// #include <GxGDEW0154Z04/GxGDEW0154Z04.h>  // 1.54" b/w/r 200x200
// #include <GxGDEW0154Z17/GxGDEW0154Z17.h>  // 1.54" b/w/r 152x152
// #include <GxGDEH0154D67/GxGDEH0154D67.h>  // 1.54" b/w
// #include <GxDEPG0150BN/GxDEPG0150BN.h>    // 1.51" b/w   form DKE GROUP
// #include <GxDEPG0266BN/GxDEPG0266BN.h>    // 2.66" b/w   form DKE GROUP
// #include <GxDEPG0290R/GxDEPG0290R.h>      // 2.9" b/w/r  form DKE GROUP
// #include <GxDEPG0290B/GxDEPG0290B.h>      // 2.9" b/w    form DKE GROUP
// #include <GxGDEW029Z10/GxGDEW029Z10.h>    // 2.9" b/w/r  form GoodDisplay
// #include <GxGDEW0213Z16/GxGDEW0213Z16.h>  // 2.13" b/w/r form GoodDisplay
// #include <GxGDE0213B1/GxGDE0213B1.h>      // 2.13" b/w  old panel , form GoodDisplay
// #include <GxGDEH0213B72/GxGDEH0213B72.h>  // 2.13" b/w  old panel , form GoodDisplay
// #include <GxGDEH0213B73/GxGDEH0213B73.h>  // 2.13" b/w  old panel , form GoodDisplay
// #include <GxGDEM0213B74/GxGDEM0213B74.h>  // 2.13" b/w  form GoodDisplay 4-color
// #include <GxGDEW0213M21/GxGDEW0213M21.h>  // 2.13"  b/w Ultra wide temperature , form GoodDisplay
// #include <GxDEPG0213BN/GxDEPG0213BN.h>    // 2.13" b/w  form DKE GROUP
// #include <GxGDEW027W3/GxGDEW027W3.h>      // 2.7" b/w   form GoodDisplay
// #include <GxGDEW027C44/GxGDEW027C44.h>    // 2.7" b/w/r form GoodDisplay
// #include <GxGDEH029A1/GxGDEH029A1.h>      // 2.9" b/w   form GoodDisplay
// #include <GxDEPG0750BN/GxDEPG0750BN.h>    // 7.5" b/w   form DKE GROUP
#endif

#include GxEPD_BitmapExamples
// FreeFonts from Adafruit_GFX
#include <Fonts/FreeMonoBold9pt7b.h>
#include <Fonts/FreeMonoBold12pt7b.h>
#include <Fonts/FreeMonoBold18pt7b.h>
#include <GxIO/GxIO_SPI/GxIO_SPI.h>
#include <GxIO/GxIO.h>


GxIO_Class io(SPI,  EPD_CS, EPD_DC,  EPD_RSET);
GxEPD_Class display(io, EPD_RSET, EPD_BUSY);

void LilyGo_logo();


void setup(void)
{
    Serial.begin(115200);
    Serial.println();
    Serial.println("setup");

#if defined(LILYGO_EPD_DISPLAY_102)
    pinMode(EPD_POWER_ENABLE, OUTPUT);
    digitalWrite(EPD_POWER_ENABLE, HIGH);
#endif /*LILYGO_EPD_DISPLAY_102*/
#if defined(LILYGO_T5_V102)
    pinMode(POWER_ENABLE, OUTPUT);
    digitalWrite(POWER_ENABLE, HIGH);
#endif /*LILYGO_T5_V102*/
    SPI.begin(EPD_SCLK, EPD_MISO, EPD_MOSI);
    display.init(); // enable diagnostic output on Serial

    LilyGo_logo();
    Serial.println("setup done");
}


void loop()
{

    display.setRotation(1);
    display.fillScreen(GxEPD_WHITE);
    display.setTextColor(GxEPD_BLACK);
    display.setFont(&FreeMonoBold9pt7b);
    display.setCursor(0, 45);
    display.println("Hello World");
    display.update();
    delay(10000);
}



void LilyGo_logo(void)
{
    display.setRotation(0);
    display.fillScreen(GxEPD_WHITE);
    display.drawExampleBitmap(BitmapExample1, 0, 0, GxEPD_WIDTH, GxEPD_HEIGHT, GxEPD_BLACK);
    display.update();
}


[/codesyntax]


 


Links


									            

        


		            

								                    

						0						FacebookTwitterPinterestEmail                    

				            

		    








	
		
			                

										                        
							                                                        
					                

			
			
    

		            
Code

		
        
HTU31 Humidity and Temperature Sensor and ESP32 board example

				

			by 										shedboy71
									
					

					    


    

        

            

									
In this article we connect an HTU31 Humidity and Temperature Combination Sensor to an ESP32


Sensor Information


The HTU31 is one of the smallest and most accurate humidity sensors on the market. TE Connectivity precision engineering and 20+ years of experience in humidity and temperature combination sensors, enabled this new product with fast response time, precision measurement, low hysteresis, robustness to reflow assembly process and sustained performance even when exposed to extreme temperature [-40° to 125°C] and humidity [0%RH to 100%RH] environments.


HTU31 humidity & temperature sensor includes both digital (D) and analog (V) versions and combines multiple functions with an application-friendly operating supply voltage range from 3V to 5.5V






Product Type Features


Humidity Sensor Component Product Type  RHT

Humidity Sensor Component Sensor Type  Digital


Electrical Characteristics


Supply Voltage (Peak) (V) – 6v maximum

Current Consumption (mA) .76, .77, .78


Usage Conditions


Humidity Operating Range (%RH) – Humidity measurement range is 0 to 100% relative humidity

Operating Temperature Range (°C) – Temperature measurement range is -40 -degrees C to +125-degrees C

Operating Temperature Range (°F) -40 – 257, -40 – 258, -40 – 259




Parts Required


The sensor you can pick up in the $3 price range – you can connect to the sensor using a standard header the classic dupont style jumper wire.


 






Name
Link





ESP32








HTU31D








Connecting cables










 


Schematic/Connection




 


Code Example


This uses a library from Adafruit installed using the Library Manager in the Arduino IDE. search for HTU31, and select the Adafruit_HTU31D library. You will also need to add another couple of libraries Adafruit BusIO library and the Adafruit Unified Sensor library


[codesyntax lang=”cpp”]


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

Adafruit_HTU31D htu = Adafruit_HTU31D();
uint32_t timestamp;
bool heaterEnabled = false;

void setup() {
  Serial.begin(115200);
  while (!Serial) {
    delay(10); // wait till serial port opens
  }
  Serial.println("Adafruit HTU31D test");

  if (!htu.begin(0x40)) {
    Serial.println("Couldn't find sensor!");
    while (1);
  }
  timestamp = millis();
}

void loop() {
  sensors_event_t humidity, temp;
  
  htu.getEvent(&humidity, &temp);// populate temp and humidity objects with fresh data

  Serial.print("Temp: "); 
  Serial.print(temp.temperature);
  Serial.println(" C");
  
  Serial.print("Humidity: ");
  Serial.print(humidity.relative_humidity);
  Serial.println(" \% RH");

  // every 5 seconds
  if ((millis() - timestamp) > 5000) {
    // toggle the heater
    heaterEnabled = !heaterEnabled;
    if (heaterEnabled) {
      Serial.println("Turning on heater");
    } else {
      Serial.println("Turning off heater");
    }
    if (! htu.enableHeater(heaterEnabled)) {
      Serial.println("Command failed");
    }

    timestamp = millis();
  }

  delay(500);
}


[/codesyntax]


Output


Here is  an example of what I saw in the serial monitor window


 


 


Links


 


 


 


 






									            

        


		            

								                    

						1						FacebookTwitterPinterestEmail                    

				            

		    








	
		
			                

										                        
							                                ESP32 and TLV493D layout                        
					                

			
			
    

		            
Code

		
        
TLV493D magnetic sensor and ESP32 board example

				

			by 										shedboy71
									
					

					    


    

        

            

									
In this article we look at a TLV493D magnetic sensor and we will connect it to an ESP32 development board, its a Lolin D32 pro but pretty much any ESP32 board will do.


First lets look at the sensor


The 3D magnetic sensor TLV493D offers accurate three-dimensional sensing with extremely low power consumption in a small 6-pin package.


With its magnetic field detection in x, y, and z-direction the sensor reliably measures three dimensional, linear and rotation movements.


Applications include joysticks, control elements (white goods, multifunction knops), or electric meters (anti tampering) and any other application that requires accurate angular measurements or low power consumptions.


Features


• 3D magnetic sensing

• Very low power consumption = 10 µA during operations (10 Hz, typ.)

• Power down mode with 7 nA power consumption

• Digital output via 2-wire based standard I2C interface up to 1 MBit/sec

• 12-bit data resolution for each measurement direction

• Bx, By and Bz linear field measurement up to +130 mT

• Excellent matching of X/Y measurement for accurate angle sensing

• Variable update frequencies and power modes (configurable during operation)

• Supply voltage range = 2.8 V…3.5 V, Temperature range Tj = -40°C…125°C

• Triggering by external µC possible

• Interrupt signal available to wake up a microcontroller

• Temperature measurement


 


Parts Required


 






Name
Link





ESP32








TLV493D








Connecting cables










 


Schematic/Connection


I used the Adafruit TLV493 sensor and in this case used the Stemma connection on the sensor


For the STEMMA QT cables, it uses the Qwiic convention:


Black for GND

Red for V+

Blue for SDA

Yellow for SCL


So color coded for ease of use, this layout shows a connection to the module


This example shows an Adafruit ESP32 board connected to the sensor


ESP32 and TLV493D layout
ESP32 and TLV493D layout


Code Example


This uses the library from Infineon installed using the Library Manager in the Arduino IDE. search for Infineon TLV493, and select theTLV493D-A1B6 library


This is the cartesian example which reads the X, Y, and Z axis measurements in milli-teslas (mT), there are a few examples to investigate


[codesyntax lang=”cpp”]


#include <Tlv493d.h>

// Tlv493d Opject
Tlv493d Tlv493dMagnetic3DSensor = Tlv493d();

void setup() 
{
  Serial.begin(9600);
  while(!Serial);
  Tlv493dMagnetic3DSensor.begin();
}

void loop() {
  Tlv493dMagnetic3DSensor.updateData();
  delay(100);

  Serial.print("X = ");
  Serial.print(Tlv493dMagnetic3DSensor.getX());
  Serial.print(" mT; Y = ");
  Serial.print(Tlv493dMagnetic3DSensor.getY());
  Serial.print(" mT; Z = ");
  Serial.print(Tlv493dMagnetic3DSensor.getZ());
  Serial.println(" mT");
   
  delay(500);
}


[/codesyntax]


Output


Open the serial monitor and you should see something like this.


 


Links


Infineon datasheet


 


 


 


									            

        


		            

								                    

						0						FacebookTwitterPinterestEmail                    

				            

		    








	
		
			                

										                        
							                                FeatherS2 Neo                        
					                

			
			
    

		            
Hardware

		
        
The FeatherS2 NEO an ESP32 board in Feather format

				

			by 										shedboy71
									
					

					    


    

        

            

									
In this article we look at an ESP32 board called the FeatherS2 NEO which is a feather format board but is not made by Adafruit.


Lets see an image of this board


You can see that on this board there is a 5×5 RGB matrix built in and also an RGB LED


FeatherS2 Neo
FeatherS2 Neo


Features


    

  • 32-bit ESP32 S2 240 MHz single-core processor
    • 

  • 4 MB SPI Flash
    • 

  • 2 MB extra PSRAM
    • 

  • 2.4 GHz Wi-Fi – 802.11b/g/n
    • 

  • 3D antenna fitted to th eboard
    • 

  • 700 mA 3.3 V LDO regulator
    • 

  • Optimised power path for low-power battery usage
    • 

  • LiPo battery management
    • 

  • 3 LEDS for Power (red), Charge (orange) & IO13 (blue)
    • 

  • 5×5 RGB LED matrix + User controller power
    • 

  • 22x GPIO pins identified at the side of the board
    • 

  • VBAT voltage sense on IO2
    • 

  • VBUS detection on IO34
    • 

  • USB-C connection
    • 

  • RGB LED (PWR 39, DATA IO40)
    • 

  • QWIIC/STEMMA connector
    • 

  • Feather format – Adafruit
    • 



The board ships ships with a UF2 bootloader and the latest version of CircuitPython that supports the ESP32-S2. You can also use Micropython with the board.


Pinout




Micropython


Flashing MicroPython on to your FeatherS2 Neo


If you would like to put MicroPython on your FeatherS2 Neo, please follow these steps:


Download the MicroPython firmware for the FeatherS2 Neo


In this case the file is featherS2neo-20211025-unstable-v1.17-99-g99221cd11.bin


    

  1. 

    Put your FeatherS2 Neo into download mode by holding [BOOT], clicking [RESET] and then releasing [BOOT]
    

    2. 

  2. 

    Erase the flash on your FeatherS2 Neo to give you a clean start. COM(X) is the com port for your board in Windows
    

    Windows
    

    esptool --chip esp32s2 -p COM(X) erase_flash
    

    Mac
    

    esptool.py --chip esp32s2 -p /dev/cu.usbmodem01 erase_flash
    

    Linux
    

    esptool.py --chip esp32s2 -p /dev/ttyACM0 erase_flash
    

    3. 

  3. 

    Flash the downloaded firmware to your FeatherS2 Neo. COM(X) is the com port for your board in Windows
    

    Windows
    

    esptool --chip esp32s2 -p COM(X) write_flash -z 0x1000 featherS2neo-20211025-unstable-v1.17-99-g99221cd11.bin
    

    Mac
    

    esptool.py --chip esp32s2 -p /dev/cu.usbmodem01 write_flash -z 0x1000 featherS2neo-20211025-unstable-v1.17-99-g99221cd11.bin
    

    Linux
    

    esptool.py --chip esp32s2 -p /dev/ttyACM0 write_flash -z 0x1000 featherS2neo-20211025-unstable-v1.17-99-g99221cd11.bin
    

    4. 

  4. 

    Restart your FeatherS2 Neo by pressing the [RESET] button
    

    5. 



Arduino support


If you currently have CircuitPython or MicroPython installed or have flashed your FeatherS2 Neo via the IDF and you would like to use your device in the Arduino IDE, you will need to put it into download mode by holding [BOOT], clicking [RESET] and then releasing [BOOT].


That will enable the CDC USB in ROM and you will be able to select the device port in the Arduino IDE tools menu.


This only needs to be done once, while you keep working in the Arduino IDE, so long as you have the FeatherS2 Neo board selected and you have CDC boot enabled selected in the menu.


Links


									            

        


		            

								                    

						0						FacebookTwitterPinterestEmail                    

				            

		    








	
		
			                

										                        
							                                ESP32 and VCNL4040                        
					                

			
			
    

		            
Code

		
        
VCNL4040 Proximity and Ambient Light Sensor and ESP32 board example

				

			by 										shedboy71
									
					

					    


    

        

            

									
In this example we connect a VCNL4040 Proximity and Ambient Light Sensor from Vishay to an ESP32


First lets look at some information about the sensor from the manufacturer


VCNL4040 integrates a proximity sensor (PS), ambientlight sensor (ALS), and a high power IRED into one small package. It incorporates photodiodes, amplifiers, and analog to digital converting circuits into a single chip byCMOS process.


The 16-bit high resolution ALS offersexcellent sensing capabilities with sufficient selections to fulfill most applications whether dark or high transparencylens design.


High and low interrupt thresholds can beprogrammed for both ALS and PS, allowing the component to use a minimal amount of the microcontrollers resources.


The proximity sensor features an intelligent cancellation scheme, so that cross talk phenomenon is eliminated effectively. To accelerate the PS response time, smart persistence prevents the misjudgment of proximity sensing but also keeps a fast response time.


In active force mode, a single measurement can be requested, allowing another good approach for more design flexibility to fulfill different kinds of applications with more power saving.


The patented Filtron technology achieves ambient lightspectral sensitivity closest to real human eye response andoffers the best background light cancellation capability(including sunlight) without utilizing the microcontrollers’resources.


VCNL4040 provides an excellent temperature compensation capability for keeping output stable undervarious temperature configurations. ALS and PS functions are easily set via the simple command format of I2C(SMBus compatible) interface protocol.


Operating voltage ranges from 2.5 V to 3.6 V.


Here is the sensor I purchased from the good folks at Adafruit (via Pimoroni in the UK)


vcnl4040 board
vcnl4040 board


Parts Required


Here are the parts I used


The sensor you can pick up in the $6 price range – you can connect to the sensor using a standard header the classic dupont style jumper wire.


 






Name
Link





ESP32








VCNL4040








Connecting cables










 


 


Schematic/Connection


The layout below shows an Adafruit Huzzah ESP32, I tried a couple of other ESP32 boards like the Lolin32 as well and they worked just fine


If you have an ESP32 board with a STEMMA QT cables, you can use these:


Black for GND

Red for V+

Blue for SDA

Yellow for SCL


I actually just extended and use this but in the layout I have shown that you can solder a header and just this as well – so you have a choice


ESP32 and VCNL4040
ESP32 and VCNL4040


Code Example


This sensor uses a couple of libraries, both of which can be installed using the library manager. if you search for the VCNL4040 one first and you are using a newer version of the Arduino IDE it will install the other one as well.


You need the Adafruit library for the VCNL4040 –https://github.com/adafruit/Adafruit_VCNL4040


You also need an I2C support library from the same folks for the library above to work and that is available from – https://github.com/adafruit/Adafruit_BusIO


This is mainly the default example – with a couple of sections of code that were not required removed. I just used the defaults


[codesyntax lang=”cpp”]


#include <Adafruit_VCNL4040.h>

Adafruit_VCNL4040 vcnl4040 = Adafruit_VCNL4040();

void setup() {
  Serial.begin(115200);
  // Wait until serial port is opened
  while (!Serial) { delay(1); }

  Serial.println("Adafruit VCNL4040 Config demo");

  if (!vcnl4040.begin()) {
    Serial.println("Couldn't find VCNL4040 chip");
    while (1);
  }
  Serial.println("Found VCNL4040 chip");

  //vcnl4040.setProximityLEDCurrent(VCNL4040_LED_CURRENT_200MA);
  Serial.print("Proximity LED current set to: ");
  switch(vcnl4040.getProximityLEDCurrent()) {
    case VCNL4040_LED_CURRENT_50MA: Serial.println("50 mA"); break;
    case VCNL4040_LED_CURRENT_75MA: Serial.println("75 mA"); break;
    case VCNL4040_LED_CURRENT_100MA: Serial.println("100 mA"); break;
    case VCNL4040_LED_CURRENT_120MA: Serial.println("120 mA"); break;
    case VCNL4040_LED_CURRENT_140MA: Serial.println("140 mA"); break;
    case VCNL4040_LED_CURRENT_160MA: Serial.println("160 mA"); break;
    case VCNL4040_LED_CURRENT_180MA: Serial.println("180 mA"); break;
    case VCNL4040_LED_CURRENT_200MA: Serial.println("200 mA"); break;
  }
  
  //vcnl4040.setProximityLEDDutyCycle(VCNL4040_LED_DUTY_1_40);
  Serial.print("Proximity LED duty cycle set to: ");
  switch(vcnl4040.getProximityLEDDutyCycle()) {
    case VCNL4040_LED_DUTY_1_40: Serial.println("1/40"); break;
    case VCNL4040_LED_DUTY_1_80: Serial.println("1/80"); break;
    case VCNL4040_LED_DUTY_1_160: Serial.println("1/160"); break;
    case VCNL4040_LED_DUTY_1_320: Serial.println("1/320"); break;
  }

  //vcnl4040.setAmbientIntegrationTime(VCNL4040_AMBIENT_INTEGRATION_TIME_80MS);
  Serial.print("Ambient light integration time set to: ");
  switch(vcnl4040.getAmbientIntegrationTime()) {
    case VCNL4040_AMBIENT_INTEGRATION_TIME_80MS: Serial.println("80 ms"); break;
    case VCNL4040_AMBIENT_INTEGRATION_TIME_160MS: Serial.println("160 ms"); break;
    case VCNL4040_AMBIENT_INTEGRATION_TIME_320MS: Serial.println("320 ms"); break;
    case VCNL4040_AMBIENT_INTEGRATION_TIME_640MS: Serial.println("640 ms"); break;
  }


  //vcnl4040.setProximityIntegrationTime(VCNL4040_PROXIMITY_INTEGRATION_TIME_8T);
  Serial.print("Proximity integration time set to: ");
  switch(vcnl4040.getProximityIntegrationTime()) {
    case VCNL4040_PROXIMITY_INTEGRATION_TIME_1T: Serial.println("1T"); break;
    case VCNL4040_PROXIMITY_INTEGRATION_TIME_1_5T: Serial.println("1.5T"); break;
    case VCNL4040_PROXIMITY_INTEGRATION_TIME_2T: Serial.println("2T"); break;
    case VCNL4040_PROXIMITY_INTEGRATION_TIME_2_5T: Serial.println("2.5T"); break;
    case VCNL4040_PROXIMITY_INTEGRATION_TIME_3T: Serial.println("3T"); break;
    case VCNL4040_PROXIMITY_INTEGRATION_TIME_3_5T: Serial.println("3.5T"); break;
    case VCNL4040_PROXIMITY_INTEGRATION_TIME_4T: Serial.println("4T"); break;
    case VCNL4040_PROXIMITY_INTEGRATION_TIME_8T: Serial.println("8T"); break;
  }

  //vcnl4040.setProximityHighResolution(false);
  Serial.print("Proximity measurement high resolution? ");
  Serial.println(vcnl4040.getProximityHighResolution() ? "True" : "False");

  Serial.println("");

}

void loop() {
  
  Serial.print("Proximity:"); Serial.println(vcnl4040.getProximity());
  Serial.print("Ambient light:"); Serial.println(vcnl4040.getLux());
  Serial.print("Raw white light:"); Serial.println(vcnl4040.getWhiteLight());
  Serial.println("");
 
  delay(500);
}


[/codesyntax]


Output


Here is what I saw in Serial monitor


Proximity:1

Ambient light:6

Raw white light:17


Proximity:1

Ambient light:7

Raw white light:17


Proximity:0

Ambient light:6

Raw white light:17


Proximity:1

Ambient light:6

Raw white light:16


Links


https://www.vishay.com/docs/84274/vcnl4040.pdf


									            

        


		            

								                    

						0						FacebookTwitterPinterestEmail                    

				            

		    








	
		
			                

										                        
							                                ESP32 and LTR390                        
					                

			
			
    

		            
Code

		
        
LTR390 UV Light Sensor and ESP32 board example

				

			by 										shedboy71
									
					

					    


    

        

            

									
In this example we connect a LTR390 UV Light Sensor to an ESP32


First lets look at some information about the sensor from the manufacturer


This sensor converts light intensity to a digital output signal capable of direct I2C interface.






It provides a linear ALS response over a wide dynamic range, and is well suited to applications under high ambient brightness.


The sensor has a programmable interrupt with hysteresis to response to events and that removes the need to poll the sensor for a reading which improves system efficiency.


This CMOS design and factory-set one time trimming capability ensure minimal sensor-to-sensor variations forease of manufacturability to the end customers.


Features


I2C interface capable of Standard mode @100kHz or Fast mode @400kHz communication; 1.8V logic compatible

Ambient Light / Ultraviolet light(UVS)Technology in one ultra-small 2x2mm Chip LED package

Very low power consumption with sleep mode capability

Operating voltage ranges: 1.7V to 3.6V

Operating temperature ranges: -40 to +85 ºC

Built-in temperature compensation circuit

Programmable interrupt function for ALS , UVS with upper and lower thresholds

RoHS and Halogen free compliant


UVS/ALS Features


    

  • 13 to 20 bits effective resolution
    • 

  • Wide dynamic range of 1:18,000,000 with linear response
    • 

  • Close to human eye spectral response
    • 

  • Automatic rejection for 50Hz/60Hz lighting flicker
    • 







This is the sensor that I bought




Parts Required


Here are the parts I used


The sensor you can pick up in the $6 price range – you can connect to the sensor using a standard header the classic dupont style jumper wire.






Name
Link





ESP32








LTR390








Connecting cables










 


Schematic/Connection


The layout below shows an Adafruit Huzzah ESP32, I tried a couple of other ESP32 boards like the Lolin32 as well and they worked just fine


If you have an ESP32 board with a STEMMA QT cables, you can use these:


Black for GND

Red for V+

Blue for SDA

Yellow for SCL


I actually just extended and use this but in the layout I have shown that you can solder a header and just this as well – so you have a choice


ESP32 and LTR390
ESP32 and LTR390


Code Example


This sensor uses a couple of libraries, both of which can be installed using the library manager. if you search for the LTR390 one first and you are using a newer version of the Arduino IDE it will install the other one as well – which makes things a bit easier.


You need the Adafruit library for the https://github.com/adafruit/Adafruit_LTR390


You also need an I2C support library from the same folks for the library above to work and that is available from – https://github.com/adafruit/Adafruit_BusIO


This is the simple test example


[codesyntax lang=”cpp”]


/*************************************************** 
  This is an example for the LTR390 UV Sensor

  Designed specifically to work with the LTR390 UV sensor from Adafruit
  ----> https://www.adafruit.com

  These sensors use I2C to communicate, 2 pins are required to  
  interface
 ****************************************************/
 
#include "Adafruit_LTR390.h"

Adafruit_LTR390 ltr = Adafruit_LTR390();

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

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

  ltr.setMode(LTR390_MODE_UVS);
  if (ltr.getMode() == LTR390_MODE_ALS) {
    Serial.println("In ALS mode");
  } else {
    Serial.println("In UVS mode");
  }

  ltr.setGain(LTR390_GAIN_3);
  Serial.print("Gain : ");
  switch (ltr.getGain()) {
    case LTR390_GAIN_1: Serial.println(1); break;
    case LTR390_GAIN_3: Serial.println(3); break;
    case LTR390_GAIN_6: Serial.println(6); break;
    case LTR390_GAIN_9: Serial.println(9); break;
    case LTR390_GAIN_18: Serial.println(18); break;
  }

  ltr.setResolution(LTR390_RESOLUTION_16BIT);
  Serial.print("Resolution : ");
  switch (ltr.getResolution()) {
    case LTR390_RESOLUTION_13BIT: Serial.println(13); break;
    case LTR390_RESOLUTION_16BIT: Serial.println(16); break;
    case LTR390_RESOLUTION_17BIT: Serial.println(17); break;
    case LTR390_RESOLUTION_18BIT: Serial.println(18); break;
    case LTR390_RESOLUTION_19BIT: Serial.println(19); break;
    case LTR390_RESOLUTION_20BIT: Serial.println(20); break;
  }

  ltr.setThresholds(100, 1000);
  ltr.configInterrupt(true, LTR390_MODE_UVS);
}

void loop() {
  if (ltr.newDataAvailable()) {
      Serial.print("UV data: "); 
      Serial.print(ltr.readUVS());
  }
  
  delay(100);
}


[/codesyntax]


Output


Here is what I saw in Serial monitor – I was indoors at the time


UV data: 0

UV data: 0

UV data: 0

UV data: 0

UV data: 0

UV data: 0


Links


Datasheet


									            

        


		            

								                    

						0						FacebookTwitterPinterestEmail                    

				            

		    








	
		
			                

										                        
							                                ESP32 and AHT20                        
					                

			
			
    

		            
Code

		
        
AHT20 Integrated temperature and humidity Sensor and ESP32 board example

				

			by 										shedboy71
									
					

					    


    

        

            

									
Another day another sensor hits the workshop.


In this example we connect a AHT20 Integrated temperature and humidity Sensor to an ESP32


First lets look at some information about the sensor from the manufacturer






AHT20, as a new generation of temperature and humidity sensors, has established a new standard in size and intelligence. It is embedded in a double row flat no-lead package suitable for reflow soldering, with a bottom of 3 x 3 mm and a height of 1.0 mm.


The sensor outputs calibrated digital signals in standard IAHT20, as a new generation of temperature and humidity sensors, has established a new standard in size and intelligence.


It is embedded in a double row flat no-lead package suitable for reflow soldering, with a bottom of 3 x 3 mm and a height of 1.0 mm.


The sensor outputs calibrated digital signals in standard I2C format. The AHT20 is equipped with a newly designed ASIC chip, an improved MEMS semiconductor capacitive humidity sensing element and a standard on-chip temperature sensing element.






Supply voltage
DC : 2.0 – 5.5V




Measuring range (humidity)
0 ~ 100% RH




Measuring range (temperature)
-40 ~ + 85 ℃




Humidity accuracy
± 2 % RH ( 25 ℃ )




Temperature accuracy
± 0.3 ℃




Resolution
temperature: 0.01℃ Humidity: 0.024%RH




Response time
temperature: 5s humidity: 8s 1/e (63%)




Output signal
I2C signal










 


This is the sensor that I bought


 


Parts Required


Here are the parts I used


The sensor you can pick up in the $6 price range – you can connect to the sensor using a standard header the classic dupont style jumper wire.


 






Name
Link





ESP32








AHT20








Connecting cables










 


Schematic/Connection


The layout below shows an Adafruit Huzzah ESP32, I tried a couple of other ESP32 boards like the Lolin32 as well and they worked just fine


If you have an ESP32 board with a STEMMA QT cables, you can use these:


Black for GND

Red for V+

Blue for SDA

Yellow for SCL


I actually just extended and use this but in the layout I have shown that you can solder a header and just this as well – so you have a choice


ESP32 and AHT20
ESP32 and AHT20


Code Example


This example uses a couple of libraries, both of which can be installed using the library manager. if you search for the AHT20 one first and you are using a newer version of the Arduino IDE it will install the other one as well – which makes things a bit easier.


You need the Adafruit library for the AHT20 from https://github.com/adafruit/Adafruit_AHTX0


You also need an I2C support library from the same folks for the library above to work and that is available from – https://github.com/adafruit/Adafruit_BusIO


This is the simple test example that comes with the library


[codesyntax lang=”cpp”]


#include <Adafruit_AHTX0.h>

Adafruit_AHTX0 aht;

void setup() 
{
  Serial.begin(115200);
  Serial.println("Adafruit AHT10/AHT20 demo!");

  if (! aht.begin()) 
  {
    Serial.println("Could not find AHT? Check wiring");
    while (1) delay(10);
  }
  Serial.println("AHT10 or AHT20 found");
}

void loop() {
  sensors_event_t humidity, temp;
  aht.getEvent(&humidity, &temp);// populate temp and humidity objects with fresh data
  Serial.print("Temperature: "); 
  Serial.print(temp.temperature); 
  Serial.println(" degrees C");
  Serial.print("Humidity: "); 
  Serial.print(humidity.relative_humidity); 
  Serial.println("% rH");

  delay(500);
}


[/codesyntax]


Output


Here is what I saw in Serial monitor


Temperature: 21.42 degrees C

Humidity: 52.41% rH

Temperature: 21.72 degrees C

Humidity: 54.38% rH

Temperature: 21.91 degrees C

Humidity: 56.12% rH

Temperature: 21.90 degrees C

Humidity: 57.22% rH

Temperature: 21.61 degrees C

Humidity: 56.53% rH


Links


Product download pdf


									            

        


		            

								                    

						0						FacebookTwitterPinterestEmail                    

				            

		    





				

					

													Newer Posts											

					

													Older Posts 											

				

							
			
        

    


			


    

		
		    



			



    


											        
	    


    
    
























		


			

				


					

					
Adblock Detected


					

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