Blog
Modular IoT system construction offers high flexibility and scalability as the developers can quickly build prototype systems using existing modules to save time in design and development. It assists developers in swiftly developing and validating their concepts and works directly from idea to product, allowing developers to create various types of devices and solutions more quickly and economically.
M5Stack’s products have a stackable design, providing standardized interfaces for easy construction of the system, when combined with the intuitive visual programming interface of UIFlow, it significantly reduces the technical barriers of system design and development. Even developers with limited hardware and software knowledge can quickly build powerful IoT devices.
Setting up the UIFlow Environment
Taking the MStack Basic as an example, the first step is to refer to the UIFlow firmware burning tutorial and download M5Burner to burn the UIFlow firmware to the controller.
Building an IoT System
If we need to detect air quality. We can stack the PM2.5 Air Quality Module to the MStack Basic.
Then, in UIFlow, click on "PM2.5" and select "Load Examples" to open the sample code.
Click "Run," and we will see the air quality displayed on the screen.
When we want to drive a stepper motor to actuate certain mechanisms when the PM2.5 concentration is high. We can stack the GRBL Module.
Next, find the code blocks corresponding to the GRBL module in UIFlow.
Set the motor drive mode at the beginning of the code, here we set it to distance mode.
In the main loop of the program, add a condition based on the PM2.5 concentration, using the value stored in SP for simplicity. When the concentration exceeds 55 (μg/m³), the stepper motor starts rotating. When it falls below 55, the stepper motor stops rotating.
Click "Run," and the system will operate as we set.
Conclusion
In summary, the stackable modular design provides a flexible, efficient, and scalable approach to IoT system development. When combined with the visual and user-friendly programming environment of UIFlow, it makes system construction easier, reduces development costs and risks, and facilitates rapid prototyping and feature expansion.
Building Modular IoT Systems: Advantages of Stackable Designs
With the continuous development of the Internet of Things (IoT) technology, an increasing number of devices require remote monitoring and control. In this context, RS485 communication, as a reliable communication protocol, is widely used for data transmission and communication connectivity between IoT devices.
RS485 communication, as a serial communication protocol, offers several prominent advantages:
1. Long-distance transmission: RS485 communication supports transmission over a maximum distance of 1200 meters, suitable for communication needs among IoT devices distributed over larger areas.
2. Strong anti-interference capability: RS485 communication uses differential signal transmission, exhibiting excellent anti-interference capability, ensuring stable and reliable data transmission in industrial environments.
3. Multi-point communication: RS485 supports multi-point communication, enabling the connection of multiple devices to form a network, meeting the inter-device connectivity requirements in IoT.
4. High-speed transmission: RS485 supports data transmission speeds of up to 10Mbps, meeting the data transfer speed requirements of IoT devices.
Applications of RS485 in IoT:
1. Industrial Automation:
In the field of industrial automation, RS485 communication is widely used for data transmission and control connectivity among various devices such as sensors, actuators, and PLCs. Through RS485 communication, these devices can achieve remote monitoring and control, enhancing production efficiency and work safety.
2. Smart Buildings:
In smart building systems, RS485 communication is used to connect various smart devices, such as lighting control systems, HVAC systems, and security systems, enabling data exchange and centralized management among devices. The stability and reliability of RS485 communication enable smart building systems to achieve efficient energy management and intelligent control.
3. Agricultural IoT:
In agricultural IoT applications, RS485 communication can be used to connect soil moisture sensors, weather stations, irrigation systems, and other devices, enabling remote monitoring of farmland environments and precision irrigation to improve crop yield and quality.
Future development of RS485 communication:
In conclusion, RS485 communication, as an important communication means in IoT, provides a reliable solution for data transmission and communication connectivity between different devices through its features such as long-distance transmission, strong anti-interference capability, and multi-point communication. As IoT continues to evolve, we have reason to believe that RS485 communication will continue to play an important role, building a solid bridge for interconnection among IoT devices.
Next, we will use the M5Stack device as an example to demonstrate the application of RS485 communication in IoT. Here we use RS485 HAT, RS485 HAT consists of a 485 automatic transceiver circuit and a DC-DC buck circuit which can drop an input 12V to 5V.
Setting up the Arduino Environment
First, please refer to the Arduino IDE setup tutorial to complete the basic software installation. And then install the `M5Unified and FastLED libraries` in the library manager, or manually clone and install them from the following GitHub links into the C:\Users\PC\Documents\Arduino\libraries directory:
*M5Unified: (https://github.com/m5stack/M5Unified)
*FastLED: (https://github.com/FastLED/FastLED)
Setting up the Hardware Environment
Devices needed:
1. ATOM Matrix x1
2. M5StickC Plus x1
3. RS485 HAT x1
4. Tail485 x1
5.120 Ohm plug-in resistor x1
6. RS485 cable x1
7. 12V power supply x1
Operational steps:
1.Connect the RS485 HAT to the M5stickc Plus.
2. Connect the ATOM Matrix to the Tail485.
3. Connect a 120-ohm matching resistor is needed at the AB end of RS485.
4. Use a 12V power supply.
5. Connect using the RS485 cable.
RS485 Transmitter
Using the following code, we will utilize the M5stickc Plus + RS485 HAT to create an RS485 transmitter. Pressing button A will send control commands via RS485 to control the color of the receiving end's RGB light.
#include "M5Unified.h"
String command[3] = {"RED\n", "GREEN\n", "BLUE\n"};
uint8_t command_index = 0;
void setup() {
M5.begin();
M5.Display.setEpdMode(epd_mode_t::epd_fastest);
M5.Display.setFont(&fonts::Font4);
M5.Display.setTextColor(WHITE);
if (M5.Display.width() < M5.Display.height())
{ /// Landscape mode.
M5.Display.setRotation(M5.Display.getRotation() ^ 1);
}
M5.Display.startWrite();
M5.Display.setTextSize(1);
M5.Display.drawCenterString("M5Stack RS485", M5.Display.width()/2, M5.Display.height()/8);
M5.Display.drawCenterString("Demo", M5.Display.width()/2, M5.Display.height()/8+20);
M5.Display.setTextSize(1);
M5.Display.drawCenterString("btnA send command", M5.Display.width()/2, M5.Display.height()/8+60);
M5.Display.endWrite();
Serial2.begin(115200, SERIAL_8N1, 26, 0);
while (1)
{
M5.update();
M5.Display.startWrite();
if (M5.BtnA.wasClicked()) {
command_index++;
if (command_index > 2)
command_index = 0;
Serial2.printf("%s", command[command_index].c_str());
switch (command_index)
{
case 0:
M5.Display.clear(RED);
break;
case 1:
M5.Display.clear(GREEN);
break;
case 2:
M5.Display.clear(BLUE);
break;
default:
break;
}
M5.Display.setTextSize(1);
M5.Display.drawCenterString("M5Stack RS485", M5.Display.width()/2, M5.Display.height()/8);
M5.Display.drawCenterString("Demo", M5.Display.width()/2, M5.Display.height()/8+20);
M5.Display.setTextSize(2);
M5.Display.drawCenterString(command[command_index], M5.Display.width()/2, M5.Display.height()/8+60);
M5.Display.endWrite();
break;
}
}
}
void loop() {
M5.update();
M5.Display.startWrite();
if (M5.BtnA.wasClicked()) {
command_index++;
if (command_index > 2)
command_index = 0;
Serial2.printf("%s", command[command_index].c_str());
switch (command_index)
{
case 0:
M5.Display.clear(RED);
break;
case 1:
M5.Display.clear(GREEN);
break;
case 2:
M5.Display.clear(BLUE);
break;
default:
break;
}
}
M5.Display.setTextSize(1);
M5.Display.drawCenterString("M5Stack RS485", M5.Display.width()/2, M5.Display.height()/8);
M5.Display.drawCenterString("Demo", M5.Display.width()/2, M5.Display.height()/8+20);
M5.Display.setTextSize(2);
M5.Display.drawCenterString(command[command_index], M5.Display.width()/2, M5.Display.height()/8+60);
M5.Display.endWrite();
}
RS485 Receiver
With the code below, we utilize the ATOM Matrix+Tail485 to create an RS485 receiver. The receiver waits for commands sent by the transmitter and changes the color of the RGB LED.
#include "Arduino.h"
#include <FastLED.h>
#define NUM_LEDS 25
#define DATA_PIN 27
CRGB leds[NUM_LEDS];
char terminateChar = '\n';
const int bufferLength = 100;
char serialBuffer[bufferLength];
String rx_str;
void setup() {
FastLED.addLeds<NEOPIXEL, DATA_PIN>(leds, NUM_LEDS);
Serial2.begin(115200, SERIAL_8N1, 32, 26);
}
void loop() {
if (Serial2.available()) {
Serial2.readBytesUntil(terminateChar, serialBuffer, bufferLength);
rx_str = serialBuffer;
if (rx_str.indexOf("GREEN") != -1) {
for (int i = 0; i < 25; i++)
leds[i] = 0x001000;
FastLED.show();
}
else if (rx_str.indexOf("RED") != -1) {
for (int i = 0; i < 25; i++)
leds[i] = 0x100000;
FastLED.show();
}
else if (rx_str.indexOf("BLUE") != -1) {
for (int i = 0; i < 25; i++)
leds[i] = 0x000010;
FastLED.show();
}
}
}
RS485 Communication in IoT: Bridging the Gap Between Devices
ESP32 CAM is an ESP32 development board with a built-in camera. It is powerful, compact, and suitable for Internet of Things (IoT) projects. It can meet the market's demands for device connectivity, data transmission, and security. The ESP32 CAM offers the following advantages:
Powerful processing capabilities and rich features: ESP32 CAM integrates a high-performance ESP32 chip, providing powerful processing capabilities and various functional modules such as Wi-Fi, Bluetooth, and a camera. This enables easy device connectivity and data processing, meeting the requirements of IoT projects.
Stable wireless connection: ESP32 CAM has a built-in robust Wi-Fi module, offering a stable and reliable wireless connection. This facilitates reliable communication between devices and supports remote monitoring and control functionality.
Flexible device integration: ESP32 CAM has ample GPIO pins and communication interfaces, allowing for flexible integration with other sensors, actuators, and external devices. This simplifies the expansion and customization process of IoT projects.
Security assurance: ESP32 CAM supports secure data transmission and communication protocols such as SSL/TLS. Additionally, being open-source and having an active developer community ensures timely fixes and updates for security vulnerabilities, providing reliable security assurance.
Due to the advantages of the ESP32 CAM, it has a wide range of applications in IoT projects. It can be used in areas such as smart homes, industrial automation, smart agriculture, and smart cities. For example, leveraging the high-performance camera and image processing capabilities of the ESP32 CAM, intelligent video surveillance and facial recognition systems can be implemented.
In the following, we'll use the M5Stack TimerCam as an example and provide a guide to help you set up your own video surveillance project.
We will provide tutorials for four different uses: Web camera, scheduled wake-up capture, push and pull RTSP streaming. However, before getting started, it is necessary to set up the Arduino working environment.
To set up the Arduino environment, we can complete the basic software installation by following the first step in the Arduino IDE environment setup tutorial. And then install the "M5Stack board management" and the "TimerCam-Arduino library" in the Library Manager, or manually clone it from the GitHub link and install it into the "C:\Users\PC\Documents\Arduino\libraries" directory.
1. Set up your webcam
1). Using the code below, we will explain how to initialize the camera, capture a frame of image data, and enable the Webserver Demo for image preview.
// Include the necessary header files
#include "battery.h"
#include "esp_camera.h"
#include <WiFi.h>
#include "soc/soc.h"
#include "soc/rtc_cntl_reg.h"
#include "camera_pins.h"
//Configure the Wi-Fi information for the camera to connect to
const char *ssid = "******";
const char *password = "******";
void startCameraServer( );
void setup( ) {
Serial.begin(115200);
WRITE_PERI_REG(RTC_CNTL_BROWN_OUT_REG, 0); // disable detector
bat_init();
// After starting the TimerCAM, set the power pin to a high level to maintain power supply.
bat_hold_output();
Serial.setDebugOutput(true);
Serial.println();
pinMode(2, OUTPUT);
digitalWrite(2, HIGH);
// Configuration of the camera includes settings for pins, image size, and compression format.
//Setting a large image size or high image quality may result in insufficient memory allocation, leading to initialization failure.
camera_config_t config;
config.ledc_channel = LEDC_CHANNEL_0;
config.ledc_timer = LEDC_TIMER_0;
config.pin_d0 = Y2_GPIO_NUM;
config.pin_d1 = Y3_GPIO_NUM;
config.pin_d2 = Y4_GPIO_NUM;
config.pin_d3 = Y5_GPIO_NUM;
config.pin_d4 = Y6_GPIO_NUM;
config.pin_d5 = Y7_GPIO_NUM;
config.pin_d6 = Y8_GPIO_NUM;
config.pin_d7 = Y9_GPIO_NUM;
config.pin_xclk = XCLK_GPIO_NUM;
config.pin_pclk = PCLK_GPIO_NUM;
config.pin_vsync = VSYNC_GPIO_NUM;
config.pin_href = HREF_GPIO_NUM;
config.pin_sscb_sda = SIOD_GPIO_NUM;
config.pin_sscb_scl = SIOC_GPIO_NUM;
config.pin_pwdn = PWDN_GPIO_NUM;
config.pin_reset = RESET_GPIO_NUM;
config.xclk_freq_hz = 20000000;
config.pixel_format = PIXFORMAT_JPEG;
config.frame_size = FRAMESIZE_UXGA;
config.jpeg_quality = 10;
config.fb_count = 2;
// Initialize the camera
esp_err_t err = esp_camera_init(&config);
if (err != ESP_OK) {
Serial.printf("Camera init failed with error 0x%x", err);
return;
}
sensor_t *s = esp_camera_sensor_get();
// Initially flip the sensor vertically and adjust brightness and saturatio
s->set_vflip(s, 1); // flip it back
s->set_brightness(s, 1); // up the blightness just a bit
s->set_saturation(s, -2); // lower the saturation
// Set Frame Size
s->set_framesize(s, FRAMESIZE_QVGA);
Serial.printf("Connect to %s, %s\r\n", ssid, password);
// Connect WiFi
WiFi.begin(ssid, password);
while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}
Serial.println("");
Serial.println("WiFi connected");
// If you don't have access to a Wi-Fi network to connect to, you can switch to using the following code to enable the camera to create its own Access Point (AP)
// WiFi.softAP(ssid, password);
// IPAddress IP = WiFi.softAPIP();
// Serial.print("AP IP address: ");
// Serial.println(IP);
// enable the Web server
startCameraServer();
}
void loop() {
// After startup, you can view the IP address assigned to the camera by serial communication. Here's the code that will continuously print the IP address for easy viewing
Serial.print("Camera Ready! Use 'http://");
Serial.print(WiFi.localIP());
Serial.println("' to connect");
delay(1000);
digitalWrite(2, HIGH);
delay(1000);
digitalWrite(2, LOW);
}
2). Modify the code with the WiFi information section, and compile and burn the program to the device. Then, you can use the serial monitor to view the IP address assigned to the camera.
WiFi connected
Camera Ready! Use 'http://192.168.31.11' to connect
For devices on the same network, you can access 192.168.31.11 through a web browser to access the control page, where can obtain real-time images and adjust image properties.
(Note: You need replace the IP address with the actual IP address printed on the serial monitor).
2. Scheduled wake-up capture
To achieve scheduled wake-up and capture using the RTC (Real-Time Clock) functionality for extended battery life, you can refer the code below. It captures an image during the period between camera startup and entering sleep mode. You can then transmit the image data to another location using a method such as HTTP POST for scheduled capture.
#include "battery.h"
#include "esp_camera.h"
#include <WiFi.h>
#include "soc/soc.h"
#include "soc/rtc_cntl_reg.h"
#include "led.h"
#include "camera_pins.h"
#include "bmm8563.h"
void setup() {
Serial.begin(115200);
WRITE_PERI_REG(RTC_CNTL_BROWN_OUT_REG, 0); // disable detector
bat_init();
led_init(CAMERA_LED_GPIO);
bmm8563_init();
// Configuration of the camera includes settings for pins, image size, and compression format.
// Setting a large image size or high image quality may result in insufficient memory allocation, leading to initialization failure.
camera_config_t config;
config.ledc_channel = LEDC_CHANNEL_0;
config.ledc_timer = LEDC_TIMER_0;
config.pin_d0 = Y2_GPIO_NUM;
config.pin_d1 = Y3_GPIO_NUM;
config.pin_d2 = Y4_GPIO_NUM;
config.pin_d3 = Y5_GPIO_NUM;
config.pin_d4 = Y6_GPIO_NUM;
config.pin_d5 = Y7_GPIO_NUM;
config.pin_d6 = Y8_GPIO_NUM;
config.pin_d7 = Y9_GPIO_NUM;
config.pin_xclk = XCLK_GPIO_NUM;
config.pin_pclk = PCLK_GPIO_NUM;
config.pin_vsync = VSYNC_GPIO_NUM;
config.pin_href = HREF_GPIO_NUM;
config.pin_sscb_sda = SIOD_GPIO_NUM;
config.pin_sscb_scl = SIOC_GPIO_NUM;
config.pin_pwdn = PWDN_GPIO_NUM;
config.pin_reset = RESET_GPIO_NUM;
config.xclk_freq_hz = 20000000;
config.pixel_format = PIXFORMAT_JPEG;
config.frame_size = FRAMESIZE_UXGA;
config.jpeg_quality = 10;
config.fb_count = 2;
// Initialize the camera
esp_err_t err = esp_camera_init(&config);
if (err != ESP_OK) {
Serial.printf("Camera init failed with error 0x%x", err);
return;
}
sensor_t *s = esp_camera_sensor_get();
// Initially flip the sensor vertically and adjust brightness and saturatio
s->set_vflip(s, 1); // flip it back
s->set_brightness(s, 1); // up the blightness just a bit
s->set_saturation(s, -2); // lower the saturation
// Set Frame Size
s->set_framesize(s, FRAMESIZE_QVGA);
camera_fb_t *fb = NULL;
esp_err_t res = ESP_OK;
// Get a frame of image data
fb = esp_camera_fb_get();
if (!fb) {
Serial.println("Camera capture failed");
}
Serial.println("Camera capture OK");
// Acquired image data
uint8_t *data_buffer = fb->buf;
size_t data_len = fb->len;
//...................
// You can perform data processing in this section and send it to the server using the HTTP method.
//...................
// Set a 5-second wake-up interval.
bmm8563_setTimerIRQ(5);
delay(1000);
}
void loop( ) {
// Power off.
// The device enters sleep mode and wakes up after 5 seconds to start executing the program from the beginning. (This only applies when powered by a battery.)
bat_disable_output();
}
3. Push and pull RTSP streaming
RTSP, short for Real-Time Streaming Protocol, is a network transmission protocol used to control the real-time transmission of data in multimedia applications. It is commonly used in conjunction with streaming media servers and clients to achieve real-time streaming and playback of audio and video content. Here is a brief description of the applications of RTSP and the meanings related to push and pull:
RTSP Applications:
Streaming Media Transmission: RTSP is widely used in streaming media applications such as online video streaming, video-on-demand, and video conferencing. It enables clients to work collaboratively with streaming media servers by negotiating session parameters, controlling playback status, and data transmission methods, thus achieving real-time media data transmission and playback.
Surveillance Systems: RTSP is commonly used in surveillance cameras and camera systems, allowing users to remotely monitor video streams over the network. This is particularly useful for home security, enterprise security, and public safety.
Video Conferencing: RTSP is used in video conferencing applications, allowing multiple participants to share audio and video data in real-time, enabling remote collaboration.
Audio Streaming: RTSP not only supports video streaming but also facilitates the transmission of audio streams. This is important for applications such as audio broadcasting and audio conferences.
Push and Pull
Push: Push refers to the process of sending multimedia data (typically audio and video) from a source to the network, allowing other devices or users to access and play it in real-time. Typically, the media source generates data and then pushes it to a streaming media server using a streaming media transfer protocol (such as RTSP, RTMP, HLS, etc.). The process from the source to the server is called "push".
Pull: Pull refers to the process of retrieving multimedia data from a streaming media server and decoding and playing it at the receiving end. Users or client devices request specific media content from the streaming media server using the same streaming media transfer protocol. This process is called "pull".
In summary, RTSP is an essential protocol for real-time streaming transmission widely used in the multimedia domain, enabling users to transmit and play audio and video data in real-time over the internet. Push involves sending media data to the network, while pull involves retrieving and playing media data from the network. Together, they form the core of streaming media services.
Using the Camera as an RTSP Server
By running the examples -> rtsp_stream code, you can configure the device as an RTSP server. Devices on the same network can access the real-time image by using a media player (such as VLC Player) and accessing rtsp://192.168.xxx.xxx:8554/mjpeg/1 (Note: Please replace the IP address with the actual IP address obtained from the serial monitor).
« ..WiFi connected
RTSP URL: rtsp://192.168.2.175:8554/mjpeg/1
LinkedListElement (0x3ffdb9ac)->(0x3ffdb9ac)->(0x3ffdb9ac)
Creating TSP streamer
Created streamer width=640, height=480
Relevant Links
rtsp_stream relies on the Micro-RTSP library, which can be installed by following the dependency prompts when installing the TimerCam-arduino library. Alternatively, you can manually clone and install it using the GitHub link provided. VLC Player is a powerful media player that we will use for pulling/streaming tests in the subsequent testing phase.
- Micro-RTSP
- VLC player
VLC Player Pull Streaming
Configuration of Streaming Relay Server
Distributing HTTP Streaming Sources
In the previous demo, we used the camera as an RTSP server, but there are limitations in terms of performance, especially when multiple clients want to pull the stream, it can be challenging. In some cases, you may want to distribute media resources to external servers or live streaming platforms, or achieve stronger multi-device access capabilities. In the following, we will use an open-source RTSP server project combined with the ffmpeg tool to implement streaming (forwarding TimerCAM data to the server) and pulling (clients pulling video resources from the server).
Here we need to burn the camera with the first web_cam demo program mentioned at the beginning of the article, and we can directly access the image stream through http://IP:81/stream.
Visit EasyDarwin - Github releases, download the release version to your local machine, and extract it. Run it as a service and start the server. (Note: Please use the sudo command to run it, otherwise, you may not have permission to open the port.)
cd EasyDarwin
sudo ./start.sh
#sudo ./stop.sh
Then please use ffmpeg to configure forwarding, and use the IP and port used in the previous demo for TimerCAM's running port and IP. The latter is the IP of the RTSP server (EasyDarwin) (default port 554, followed by a customizable ID number).
Note: Before executing this command, make sure to start the camera and ensure that the image can be previewed correctly on the webpage.
ffmpeg -re -i http://192.168.2.175:81/stream -rtsp_transport tcp -vcodec h264 -f rtsp rtsp://192.168.2.89:554/666
After completing the previous configuration, open a browser and enter http://IP:10008 to access the EasyDarwin control page. The default username and password are admin/admin. (Replace IP with the IP address of the Linux host).
By refreshing the page, we can see a new streaming address added to the control page. We can use general media player software such as VLC to fill in the corresponding streaming address to pull the video and locally cache the recording. Additionally, you can use multiple clients simultaneously for streaming playback.
Distributing Pull Sources
If the camera is being used as an RTSP server, you can also directly configure the pull forwarding in the EasyDarwin backend. For more details, please refer to the EasyDarwin GitHub repository.
What is ESP32 CAM Used For?
The biggest contributor to indoor air pollution is not formaldehyde or PM2.5 but the often-overlooked carbon dioxide. Once carbon dioxide reaches a certain level, it can pose a serious health risk, and no air purifier can effectively filter it. It is crucial to understand the health hazards, normal ranges, and solutions regarding indoor carbon dioxide concentrations.
What are the typical indoor and outdoor carbon dioxide concentrations? Within the normal range, carbon dioxide is harmless to the human body. In the natural environment, the concentration of carbon dioxide is approximately 0.04% (400 PPM), which may reach around 500 PPM in urban areas. In unoccupied indoor environments, the carbon dioxide concentration usually ranges from 500 to 700 PPM.
At what PPM level does carbon dioxide become harmful to health? The human body is highly sensitive to increases in carbon dioxide, with every 0.5% increase noticeably affecting the body. When the concentration reaches 1% (1000 PPM), individuals may experience stuffiness, lack of concentration, and palpitations. At 1500-2000 PPM, symptoms such as breathlessness, headaches, and dizziness may occur. Concentrations exceeding 5000 PPM can lead to cognitive impairment and confusion.
In real-life scenarios, carbon dioxide concentrations often exceed safe levels. For instance, when two individuals sleep overnight in a sealed bedroom, carbon dioxide concentrations can easily reach 2000 PPM. When the carbon dioxide concentration in an office space reaches 2000 PPM, employees may experience fatigue, lack of concentration, and mental exhaustion. Beyond 2000 PPM, individuals may even feel disinclined to continue working, and their cognitive abilities can significantly decline.
Maintaining good ventilation, regularly opening windows for fresh air and using air purifiers are effective methods of reducing indoor carbon dioxide levels. Among these methods, the carbon dioxide sensor is an important tool.
Today, we are introducing two CO2 measuring sensors for detecting carbon dioxide concentrations: CO2L Unit and TVOC/eCO2 Unit.
CO2L Unit is a digital CO2 concentration detection unit with a low-power mode designed for single-shot measurements. It features the Sensirion SCD41 sensor and a voltage regulator circuit, and communicates via I2C. This unit is suitable for measuring environmental conditions, with a typical accuracy of ±(40 ppm + 5% of the reading) for CO2 measurements. The measurement range for CO2 is 400 ppm to 5000 ppm, and it can also measure ambient temperature and humidity simultaneously.
TVOC/eCO2 mini Unit is a digital multi-pixel gas sensor unit that integrates the SGP30 sensor internally. It is primarily designed for measuring the concentrations of various volatile organic compounds (VOCs) and H2 in the air. Through programming, it allows for the measurement of TVOC (Total Volatile Organic Compounds) and eCO2 (Equivalent Carbon Dioxide) concentrations. The typical measurement accuracy within the measurement range is 15%. The SGP30 sensor communicates using the I2C protocol and has an on-chip humidity compensation feature that can be enabled with an external humidity sensor. The SGP30 also has a built-in calibration function, allowing users to calibrate it based on known measurement sources. Once internally calibrated, the SGP30 provides stable long-term output. Additionally, it's important to note that eCO2 is derived from H2 concentration, so the TVOC/eCO2 mini Unit cannot fully replace a CO2 sensor.
CO2 Monitoring Solution:
Here, we will introduce three methods to monitor the CO2 levels in the environment using the CO2L Unit and TVOC/eCO2 Unit and display the data on M5Stack Basic.
Method one: Use EasyLoader to get started.
This is the simplest and fastest way, let’s get it started!
Steps:
1. Open the documentation for the CO2L Unit and TVOC/eCO2 Unit .
2. Download the Easyloader program for each unit, which is a quick verification program.
3. Click to install when the download is complete.
4. Select the port (here we choose COM34, but it's worth noting that different computers may display different COM ports, so please select the appropriate port), then click "burn" to start the program burning process.
It’s downloading and burning now. Once completed, the screen will display "Successfully".
Then, the sensor will begin collecting carbon dioxide data from the air and display it on the Basic. The display effect will be as shown in the following image.
Method two: using source code in Arduino IDE
Next, I’ll lead the way to burn the firmware using the source code. We will use Arduino IDE as the programming environment.
Program CO2L Unit in Arduino IDE
1. The first step is to install the M5Stack development board in the Arduino IDE, which has been covered in our previous article.
2. Open the official documentation for the CO2L Unit , where we provide information about CO2L Unit and its relative code.
3. At the bottom of the documentation page, there are links to download the Arduino sample code. Since we are using the Core series Basic host today, please click on the first link.
4. Open the link and go to the entire project file.
5. Please click on the "Code" here to download the compressed file.
6. Please extract the compressed file into the "libraries" folder within the Arduino installation directory.
7. Open Arduino IDE, and click File>Examples>M5Unit-ENV>Unit_CO2_M5Core
8. Select the board
Select M5Stack-Core-ESP32 and the corresponding port (in this case, it is COM34, but the COM port may differ on different computers). Click OK.
9. Click the right arrow icon to upload the code.
When the upload is complete, we can see that the M5Stack Basic host screen is already displaying the CO2 concentration, as shown in the picture.
ProgramTVOC/eCO2 Unit in Arduino IDE
Next, we will continue to use the TVOC/eCO2 Unit to display the CO2 concentration.
1. Similarly, the first step is to install the M5Stack development board in the Arduino IDE, which has been covered in our previous article .
2. Open the documentation for the TVOC/eCO2 Unit. You can find information about the product and related code.
3. At the bottom of the documentation, there is a link to download the code.
4. Open the link and go to the entire project file.
5. Please click on the "Code" here to download the compressed file.
6. Please extract the downloaded installation package into the "libraries" folder within the Arduino installation directory.
7. Open Arduino IDE, and click File>Examples>M5Stack>Unit>TVOC-SGP30
8. Select the board
Select M5Stack-Core-ESP32 and the corresponding port (in this case, it is COM34, but the COM port may differ on different computers). Click OK.
9. Click the right arrow icon to upload the code.
When the upload is complete, we can see that the M5Stack Basic host screen is already displaying the CO2 concentration, as shown in the picture.
Method three: using EasyLoader to get started
Finally, we introduce M5Stack’s graphical programming software UIFlow. It is convenient for those who are not familiar with coding.
1.To begin with, you need to install the firmware burning tool "Burner".
Note that different operating systems require different versions of Burner to be downloaded.
M5Burner_Windows: https://m5burner.m5stack.com/app/M5Burner-v3-beta-win-x64.zip
M5Burner_MacOS: https://m5burner.m5stack.com/app/M5Burner-v3-beta-mac-x64.zip
M5Burner_Linux: https://m5burner.m5stack.com/app/M5Burner-v3-beta-linux-x64.zip
Note:
For macOS users, after installing Burner, please move the application to the "Applications" folder as shown in the following image.
For Linux users, navigate to the extracted file directory and run "./M5Burner" in the terminal to launch the application.
2. Firmware Burning
Double-click to open the Burner firmware burning tool. In the left-side menu, select the corresponding device category and choose the firmware that matches your device, and click the“Download”button.
Connect the device to your computer using a Type-C data cable. Burner will automatically select the corresponding COM port. You can use the default configuration for the baud rate in M5Burner. Click "Burn" to start the burning process.
During the firmware burning stage, you need to enter the WiFi information in the WiFi configuration box. The WiFi information will be burned and saved to your M5Stack device along with the firmware.
Then, click "Start" to begin the burning process. Note: If a timeout occurs during the burning process, you can try lowering the baud rate to 115200.
When the burning log displays "Burn Successfully," it indicates that the firmware has been successfully burned.
If this is the first time burning or if the firmware program is running abnormally, you can click on "Erase" in the top right corner to erase the flash memory. In subsequent firmware updates, there is no need to erase again. However, please note that erasing the flash memory will delete the saved Wi-Fi information and refresh the API key.
3. Obtaining API Key
Please connect your M5Stack device to the computer using a Type-C data cable and select the corresponding COM port.
1). Click on "Configuration" to view the API Key information, which will appear in the configuration box. (Please copy and save the API Key as it will be used as credentials for UIFlow communication going forward).
2). Set the "Start Mode" to "Internet Mode." After completing this configuration, the device will automatically restart and enter online programming mode.
3). For further explanation of other configuration options in the configuration box, please refer to the configuration instructions below.
4. M5Burner Configuration Instructions
If you need to modify the configuration file, please connect your M5 device to the computer using a Type-C data cable and select the corresponding COM port. Then, you can click on "Configuration" to make the modifications.
APIKEY: The communication credentials for M5Stack device when using UIFlow web programming.
Start Mode: Configurable startup mode after booting.
Quick Start: Option to enable quick start to skip the startup interface.
Server: Selection of the server.
WiFi: Configuration of WiFi SSID and password.
COMX: Option to enable COMX.LTE network (this feature requires stacking the COMX.LTE module, for detailed instructions, please refer to the "Network Over COM.LTE Tutorial").
APN: Configuration of APN access point for COMX.LTE module.
5. After completing the above steps, you can now start using UIFlow for programming.
Enter the UIFlow website URL in your browser: https://flow.m5stack.com/
Here, we will choose UIFlow 1.0 for now, as the list of supported devices for UIFlow 2.0 is still being expanded.
① In Step 3, we have got an API Key, and here we enter it in the bottom-left corner of the screen.
Then the screen will display “Connected”.
② At the "Add Units" section, add the "CO2L Unit" and select "OK."
Click “Load Examples”
④ Click on "Run" or "Download" (running is for testing the code and you can see the results on the host, but the code will not be saved on the device if power is disconnected. Downloading, on the other hand, will save the code on the device, and it will be retained even if power is disconnected. Choose based on your needs. If you choose to modify the code and upload it again, you will need to re-burn the firmware, which is discussed in Step 2).
The device will now start working as shown in the following image.
For the TVOC/eCO2 mini Unit, just follow the same steps as mentioned above, with the difference being the sensor selection during the unit addition. After completing the addition, select the example code, click "Run," and the device will start functioning normally.
Today's tutorial is complete here.
For an introduction to UIFlow statements, you can refer to https://docs.m5stack.com/en/quick_start/m5core/uiflow.
In the future, we will have a dedicated section specifically for explaining UIFlow statements. Stay tuned for that!
What does a CO2 sensor do?
Source: Svet Kompjutera (World of Computers)
Author: Dejan Petrovic
Link: M5Stack Core2 - Slaganje cigala i u mreži - SVET KOMPJUTERA (sk.rs)
Translate: M5Stack
M5Stack is a company engaged in the production of hardware and software in the field of the Internet of Things (IoT). Their most famous product series is the stackable devices, hence the name. These devices can be microcontroller boards, development boards with screens, sensors, and more. There are various solutions available with different sizes, power, and hardware functionalities (Stack, Stick, Atom). The common feature is that they can be stacked together. This allows for ready-made solutions suitable for different needs and projects. We obtained the Core2 from M5Stack, which is a standalone and complete device.
One impressive aspect of Core2 is the availability and completeness of the hardware and software created by M5Stack...
The Core2 is a compact device, measuring approximately 54x54x16 millimeters and enclosed in a white plastic casing. At the heart of the system lies the Espresif ESP32-D0WDQ6-V3 microcontroller. This dual-core 32-bit Xtensa LX6 chip operates at a frequency of 240 megahertz. M5Stack has added additional memory, including 16 megabytes of flash memory and 8 megabytes of PSRAM.
Unlike typical ESP32 modules found in the market (with onboard antennas), the Core2 doesn't follow that form factor. Instead, it provides an interface for an external antenna, allowing the manufacturer to have flexibility in antenna design. In this case, M5Sttack have opted for a 3D antenna, which is clearly a superior solution compared to a printed antenna. The ESP32 itself can connect to Wi-Fi and Bluetooth, although only one radio can be used at a time, with both sharing the same antenna.
Core2 utilizes a USB-C interface for programming and power supply, which uses the CH9102F UART for communication with a computer and is equipped with a circuit for automatically downloading user programs. There is also a JST connector on the board for the same purpose. It is worth noting that M5Stack can be stacked, and the USB interface can be extended using a cable. Core2 can be powered by a battery, and surprisingly, it is equipped with a 390 milliamp-hour lithium-ion battery integrated into the bottom gray casing cover. The AXP192 chip is responsible for battery management, and this programmable circuit is connected to the ESP32 chip via the I2C interface. The chip controls power consumption and notifies the status through the PWR LED. Additionally, it also allows for device shutdown through software. The SY7088 is used as a boost converter. There are two buttons on the casing, 'RST' and 'PWR', with the latter connected to the AXP192. Furthermore, the Core2 casing is secured with internal hex screws and comes with an accompanying wrench with a data cable.
Core2 comes with a rich set of features, and the bottom cover is labeled with tags. Despite being small, each aspect of the device is clearly marked, including pin layouts and other identifiers. If Core2 is used as a clock, it is equipped with the BM8563 real-time clock (RTC) chip, onnected to the ESP32 via the I2C interface. We haven't utilized the RTC functionality yet, but there are corresponding libraries available on the Arduino IDE. Additionally, there is a microSD card slot, a vibration motor, and a speaker. The speaker faces the NS4168 I2S audio driver, providing excellent sound effects. The motor is directly connected to the AXP192. In Core2, the AXP192 plays a more important role, with many EN pins connected to it. This applies to the NS4168, BM8563, and even the LED.
However, the most notable feature is undoubtedly the 2-inch color screen with an integrated capacitive touchscreen (FT6336U). The screen has a resolution of 320x240 pixels and is driven by the ILI9342C driver. We are very pleased with the screen display; although it may not compare to smartphone screens, it is excellent for the purpose of a development board. If you find that the screen calibration and touch sensitivity are not satisfactory, you can download M5TOOL from the official DOCS page to upgrade the firmware. There are three clearly marked touch areas below the screen that can be programmed as needed.
Core2 is equipped with two expansion ports. The smaller four-pin Grove on the side is actually an I2C interface. Grove is a variant of Seeedstudio, similar to QWIIC, STEMMA, easyC, and others. However, unlike other listed variants, M5Stack's Grove has a wider pin spacing and is not compatible with other brands. At the bottom, there is a large 2x15 female header, which is connected to the unused pins of the ESP32. All labels are clearly printed on the bottom, and Core2 can be powered using regulated voltage through the 5V pin. This header can also be used to stack additional modules, and these modules can have any functionality. Core2 comes with a smaller base (M5GOBottom2) that can fit perfectly into the casing and act as a cover for the header. It features the MPU6886 and SPM1423 chips. The former is a motion-tracking sensor that combines a three-axis accelerometer and gyroscope, while the latter is a microphone.
All M5Stack development boards are available in the ESP32 package in the Arduino IDE. For full hardware functionality, M5Stack provides corresponding Arduino libraries. However, M5Stack recommends adding special support through the JSON software package:
https://m5stack.oss-cn-shenzhen.aliyuncs.com/resource/arduino/package_m5stack_index.json,
which helps reduce the hassle when programming and interacting with the internal hardware of Core2. The same approach applies to libraries added for the specific hardware used, such as M5Core2, through "Include Library -> Manage Libraries...". The list of libraries to be installed is quite long. Hardware management is divided into five sections: AXP192, CORE2 LCD, Button, TOUCH, and RTC, each with its own corresponding and well-documented library available. For example, printing "Hello World" typically requires only a few lines of code:
#include <M5Core2.h>
Void setup(){
M5.begin();
M5.Lcd.print("Hello World!");
}
Void loop(){
}
The graphics API does not adhere to the familiar AdafruitGFX, but it has very detailed documentation and allows for creative freedom. It enables drawing various geometric shapes and also supports loading bitmaps from the microSD card. The documentation page (DOCS) is highly detailed, and we really have no complaints in this regard.
Arduino is not the only starting point for learning programming with this device. M5Stack offers UIFlow, MicroPython, and .NET nanoFramework as alternative options. MicroPython does not have a dedicated compiler but can utilize the general compiler of the ESP32. We are not familiar with this approach and have not had any experience with it. However, the most interesting option is undoubtedly UIFlow (www.flow.m5stack.com). This "programming language" is actually a visual "blocks" language. If you recall our discussion about BBC micro:bit and MakeCode, there are many similarities here. It's similar to MIT App Inventor as well. It's a visual block-based approach but based on Python. Above the toolbar, besides the project name, there is a tab to switch between the "block world" and the "Python world" editors. Before any programming, you need to download the M5Burner tool, which is used to load the necessary firmware and the interface for interacting with the "blocks" into the Core2, as well as local network data. We know that these parameters are not cleared when loading user programs. In addition to input parameters, M5Burner also displays the API key, which is important for establishing a connection between UIFlow and Core2.
Let's continue discussing UIFlow. The top toolbar of UIFlow contains various tools and shortcuts. Here, you can open new projects, save existing projects, and more. However, the most important option is "Settings," where you can select the device, port, and enter the API key. After that, you can choose whether to connect Core2 to the computer via a data cable or program it without connecting the data cable. Yes, Core2 supports wireless programming (Over the Air, OTA), similar to MikroElektronika's CodeGrip (although CodeGrip is actually something else). After opening Core2, three options are displayed on the screen: App, UIFlow, and Setup. We are interested in the second option, where we can choose the programming mode, either USB or Wi-Fi. We choose Wi-Fi and disconnect the USB cable from Core2. There is a detailed tutorial on the assembly of "blocks" on the DOCS page, so we won't go into detail here. The UIFlow interface consists of a left section, which can be called a graphical drag-and-drop screen designer, and the middle section is a strip of basic blocks that we can simply drag into the editor on the right. Once the "construction" is complete, the "modules" are loaded onto Core2 almost instantly (in less than a second) by clicking the "Run" button.
We are absolutely thrilled with the availability of M5Stack in terms of hardware and software. The efforts put into it have yielded significant results. It is fascinating, especially with Core2, as it can be used directly as a finished product without any modifications. For instance, it can display data from a server and more, without even requiring a case. It is evident that it can be flexibly stacked according to needs. What's even more interesting is that it can be programmed anywhere as long as it is connected to the internet. We highly recommend it without a doubt.
Building with Blocks: Core2 - Unleashing Endless Expansion with ESP32
The ESP32 microcontroller is widely used in IoT projects and offers a flexible and powerful platform for development. Sometimes, people may need to erase the flash memory of their esp32 devices, such as removing existing firmware or preparing the device for new code.
When we are developing our project, we may store some data in the flash, such as when we use the NVS functionality to store information in the flash, but when we need to download new firmware to test this device as a new one, this previous information is not overwritten. So we need to erase the flash completely and then download the new firmware.
In this article, we will lead to erase ESP32 flash memory and provide step-by-step instructions. Here, we introduce a tool called esptool.
To erase the flash memory of an ESP32 device, there are currently three common methods available:
Esptool.py, a command line tool (suitable for MacOS and Linux systems).
Esptool-js, a web-based tool (suitable for MacOS, Linux and Windows systems).
Flash Download Tools, a GUI-based tool based on Esptool (suitable for Windows system).
Next, we will provide detailed instructions for these three tools. In this article, we will use the M5Stack Core2 as an example. The M5Stack Core2 is a popular ESP32-based controller that features a 2.0-inch integrated capacitive touch screen and a wide range of built-in functions.
Esptool.py
Introduction:
Esptool.py is a Python-based, open-source, platform-independent utility for communicating with the ROM boot loader in Espressif SoCs.
It can do a number of things, for example:
- Read, write, erase, and verify binary data stored in flash.
- Read chip features and other related data such as MAC address or flash chip ID.
- Read and write the one-time-programmable efuses.
- Prepare binary executable images ready for flashing.
- Analyze, assemble, and merge binary images.
How to use Esptool.py to erase the Flash chip in M5Core2
1). Install esptool.
Open the Terminal application and type the following installation command at the command line.
pip install esptool
After the installation, we can test it with the following command. If it returns the correct version, it indicates a successful installation.
esptool version
2). Get the PORT number of M5Core2.
Use the following command to find out the USB serial port number of the M5Core2. In this step, please ensure that M5Core2 is the only device connected to your computer.
ls /dev/cu.usb*
*The serial port number in the image above is for the MacOS system. If your computer is running a different operating system, you will need to replace the serial port number with the appropriate one.
3). Execute the erase command to erase the Flash chip in M5Core2.
esptool.py --chip auto -p /dev/cu.usbserial-56D40013521 erase_flash
The Chip Auto automatically detects the chip type, making it easy to use. When you see the message "Chip erase completed successfully" in the terminal, it indicates a successful erase. The time required for erasing may vary depending on the actual capacity of the flash chip, so please be patient and wait a while. And now we have successfully erased the flash chip in M5Core2.
Esptool-js
Introduction:
Esptool-js is a Javascript implementation of esptool, a serial flasher utility for Espressif chips. esptool-js is based on Web Serial API and works in Google Chrome and Microsoft Edge version 89 or later browsers.
Unlike the Python-based esptool, esptool-js doesn't implement generation of binary images out of ELF files.
In the following steps, we'll erase the ESP32 flash chip using a web-based demo provided by Espressif Systems..
How to use Esptool-js to erase the Flash chip of M5Core2
1). Open the following web link:
ESP Tool (espressif.github.io)
2). Connect M5Core2 with USB cable
Select a lower baud rate and then click the Connect button.
Select the serial port number of M5Core2 in the pop-up window.
3). Erase
Once connected, the next page will show the correct model and version of the M5Core2's ESP32 chip.
Click the Erase Flash button to start erasing the Flash chip!
When "Chip erase completed successfully ..." is displayed, it means that the M5Core2 flash chip has been successfully erased. As mentioned earlier, the erasing process may take some time due to the different actual capacities of the flash chip. Please be patient and wait a while. In addition, this website is not limited to the erase function, but also allows you to burn firmware. You can explore this functionality separately, as it is beyond the scope of this discussion.
Now, we have successfully used Esptool-js to erase the Flash chip of M5Core2.
Next, we will present the final method.
Flash Download Tools
Introduction:
Flash Download Tools is a GUI tool designed for the Windows platform. This tool can be used to program not only ESP32 series chips but also chips such as ESP8266 and ESP8285. It also provides batch programming for mass production. In this article, we will only discuss how to erase the flash chip.
To get started, you will need to download the tool from the following link:Tools | Espressif Systems
How to use Flash Download Tools to erase the Flash chip of M5Core2
1). We need to extract the downloaded files.
Once the extraction is complete, we will see the list of files shown in the image below.
This tool does not need to be installed. You can simply double-click it to run it. The documentation can be found in the red box.
2). View the serial port number in Device Manager
Connect M5Core2 to your computer using a USB cable, and then open Device Manager.
The serial port number here is COM28, the numbers may vary for different devices. Please check the actual serial port number on your computer. If you have multiple devices connected, please disconnect the others and ensure that only one M5Core2 device is connected to the computer.
3). Open the tool and begin to erase!
Here we select "ESP32" for ChipType. If you are using a device with a different chip model, select the specific chip model accordingly. For WorkMode and LoadMode you can leave the default options. The tool interface will look like the image below.
At the bottom right, select the serial port number we checked in step two from the COM drop-down menu. If you have more than one device connected, make sure you do not select the wrong one to avoid accidentally erasing another device's flash or causing an error. Once you have made your selection, click the ERASE button to start the erasing process. Wait a while and when you see "FINISH" it means that the flash chip has been successfully erased.
Congratulations! You have successfully used Flash Download Tools to erase the Flash chip in M5Core2.
Summary:
In this tutorial, using M5Core2 as an example, we have presented three methods for erasing the ESP32 flash chip. Each method can be used and you can choose the one that suits you best.
How to Erase ESP32 Flash Memory
We often come across many excellent IoT projects that utilize ESP32 and Arduino. These two platforms clearly hold significant importance. So, what are they, and how can we utilize them together？
Introducing ESP32
ESP32 is a powerful microcontroller module developed by Espressif Systems, which comes with integrated Wi-Fi and Bluetooth connectivity for a wide range of applications, and highly integrating with in-built antenna switches, RF balun, power amplifier, low-noise receive amplifier, filters, and power management modules. It can interface with other systems to provide Wi-Fi and Bluetooth functionality through its SPI / SDIO or I2C / UART interfaces. ESP32 is widely used in mobile devices, wearable electronics and IoT applications.
M5Stack is a renowned company that specializes in providing hardware and software for rapid prototyping and IoT applications. M5Stack products are widely recognized for their integration, simplicity, and versatility, allowing users to stack or connect different modules/units together to build customized and scalable solutions. These modules cover a wide range of functionalities, including displays, sensors, communication interfaces, input devices, and more. By combining these modules, users can quickly create prototypes or even deploy complete IoT systems with minimal effort.
One of the standout features is many M5Stack controllers built around the ESP32, leveraging its powerful processing capabilities, wireless connectivity, and extensive ecosystem. This compatibility grants users access to a vast library of code, examples, and community support, making development with M5Stack devices efficient and user-friendly.
Introducing Arduino
Arduino is an open-source electronics platform based on easy-to-use hardware and software. In the past years, countless of projects, ranging from simple household items to intricate scientific instruments, have used Arduino as their brain. Over time, Arduino has accumulated a vast user base worldwide including students, hobbyists, artists, programmers, and professionals, who have gathered around this open-source platform to contribute an incredible amount of accessible knowledge that can be of great help to novices and experts alike.
How to start
By leveraging the capabilities of both platforms, developers can create innovative IoT projects that benefit from the wireless connectivity of the ESP32 and the ease of development offered by Arduino. This combination opens up possibilities for remote monitoring, home automation systems, sensor networks, and much more.
In this tutorial, we will provide detailed steps and practical tips to help you correctly program ESP32 (take M5Stack Basic for example) with Arduino IDE. Let's start!
1. Download the Arduino IDE
First, go to the Arduino website (https://www.arduino.cc/en/Main/Software) to download Arduino IDE that corresponds to your operating system.
2. Preparing Arduino IDE
① Open the Arduino IDE and go to File -> Preferences -> Settings.
② Copy the following board manager URL and paste it into the Additional Board Manager URLs:
https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_dev_index.json
In this turial, we use M5Stack’s development boards,so in this step, just copy the following M5Stack board manager URL and paste it into the Additional Board Manager URLs:https://m5stack.oss-cn-shenzhen.aliyuncs.com/resource/arduino/package_m5stack_index.json
3.Select Tools -> Board -> Board Manager
4. Installing ESP32 Board in Arduino IDE
In this tutorial, M5Stack's Basic Core is an example for leading. Thus, in this step, please enter "M5Stack" in the search field and click Install.
And if you use other ESP32 controllers, please enter "ESP32" in the search field and click Install.
5. Selecting the Board
In this step, please select Tools -> Board -> M5Stack Arduino -> M5Stack-Core-ESP32. And currently, various M5Stack controller options are available for selection.
6. Programming ESP32 with Arduino IDE
Now, you can program the device using Arduino IDE and conveniently use it alongside hardware like Arduino Uno to unlock additional functionalities. In this step, an example demo of Basic Core is uploaded, and you can see, the code is synchronized with the device. Now, you can start your own programming projects.
Step-by-Step Guide: How to Program ESP32 with Arduino IDE?
Born on July 2, 2021, the adorable Stack-chan has just celebrated its second birthday!
What is Stack-chan?
The name Stack-chan (スタックチャン) may sound strange, and what is its relationship with M5Stack?
Actually, Stack-chan is an open-source robot project created by a user of M5Stack named Shinya Ishikawa. The name "Stack-chan" comes from the fact that it is built using M5Stack hardware, which is a modular system that allows users to stack different modules together to create custom electronic devices.
"Chan" is the Romanized pronunciation of the Japanese honorific suffix "ちゃん", which is a suffix in Japanese that is often used as a term of endearment or to show familiarity, similar to "dear" or "sweetie" in English.
So, "Stack-chan" is a cute and friendly name that reflects the robot's playful and approachable nature. Due to its cute and interesting appearance, it has gained a lot of popularity among users and even formed a unique subculture.
The exclusive Twitter account for Stack-chan: https://twitter.com/stack_chan
"It's just so cute, you can't stop loving it."
At first, Shinya Ishikawa simply wanted to create a 100% open-source robot, but he never expected that this little robot would be loved by so many people, and even have the potential for mass production in the future.
Shinya noticed that most of the communication robots on the market are "closed", dependent on specific proprietary services, or their specifications are not disclosed to the public, and reaching the end of life as their backend services go by.
"Why don't they make communication robots more open and hackable?" It is the problem and why Stackchan was born. As a solution, He decided to create an open-source robot that anyone could build from scratch. This means that open community, rather than a closed, specific company or individual, will collaborate to grow the robot.
Based on this idea, in 2021, the prototype of Stack-chan was created. The robot consists of a case, an M5Stack’s controller Basic, which is a modular, stackable, and portable device with an ESP32-based microcontroller, a dedicated expansion board, and firmware. Each component is fully customizable. The functionality as a communication robot is provided in the form of a framework, which users can easily access through applications (mods). M5Basic is equipped with wireless communication functions such as Wi-Fi and BLE, so it can be used with external services, smartphones, and other robots.
The most important feature of Stack-chan is that everything is open.
Stack-chan is open in two aspects.
First, All the resources of Stack-chan are distributed under Apache-2.0 license, including the schematics, the 3D model of the case and the firmware.
Second, Shinya opened up not only the source code and model data for Stack-chan but also the entire process of creating it. In other words, he shared widely the background issues, the decisions I made, the troubles he had, and the mistakes he made so that users can learn how to make and customize Stack-chan. People can follow the process by searching its official Twitter hashtags #stackchan, #ｽﾀｯｸﾁｬﾝ on Twitter.
As a result, more than 30 enthusiasts soon began making Stack-chan, with applications ranging from voice assistants to quadruped robots, making Stack-chan's applications diverse and interesting. To date, over 500 users have joined Stack-chan's Discord group.
AI Stack-chan
https://twitter.com/robo8080/status/1631224076005179393
As more and more users joined, Stack-chan's form and use became more diverse. Earlier this year, Chat-GPT became popular, and many users started trying to connect M5Stack devices to OpenAI's API. User @robo8080 combined Stack-chan and Chat-GPT to create an AI version of Stack-chan. The intelligence level of the AI version of Stack-chan was significantly improved, and it quickly gained a lot of attention and popularity.
https://twitter.com/lewangdev/status/1675709684664369153
Stack-chan themselves has no special mission to solve. They just live. They have multiple communication modalities such as speech and gaze. In despite of its small size, Stack-chan has a very lifelike appearance with its eyes and breathing.
This behavior is achieved by simulating neurophysiological phenomena such as saccadic eye movements.
But who cares about the detail? However, what truly matters is that everyone treats Stack-chan as a real child and loves it dearly. In fact, some users have even started discussing what style of commemorative shirts to create for Stack-chan.
Stack-chan's Journey: How It Became a Beloved Robot and Created a Subculture
In today’s digital economy, It is more important to be very accurate about measuring service quality. Especially for enterprises, they will likely require increasingly strict performance for real-time and ultra-reliable applications.
Developing and assurance to meet new quality in service requirements are critical to leadership in the IoT era. The accuracy of measuring service quality is of greater importance than ever before. Monitoring requires highly granular and proactive measurements to detect problems as they arise and before they will affect customer service.
Software and Automation are essential for driving customer satisfaction and simplifying operations. Service operations need to be able to identify, understand, eliminate and resolve the issues before they impact your service and customer experience.
Ericsson IoT Accelerator enables enterprises to easily deploy, manage and scale their global IoT business from a unified IoT platform. In order to achieve more together. M5 working together with Ericsson on an application, offering active assurance and works by measuring end-to-end service quality through reading data from embedded sensors and showing them on a dashboard, managing connectivity on a subscription and network-level through IoT Accelerator APIs.
Whether you have an established modern service assurance framework or not. Learn more about how to use proactive assurance to optimize cost predictability and increase service security that enable a proactive, service-centric operating model.
Read our Quick user guide to register M5Stack+COM.LTE to AWS IoT platform to learn more.
E2E Use Case of ERICSSON IoT Accelerator integrated with M5Stack Core, AWS IoT, and NodeRed
The smallest ESP32 dev board ATOM is already launched. It is mainly designed for portable embedded systems and IoT development projects. ATOM is more of a complete system rather than a single embedded functional module.There are some awesome projects for ATOM. In case you missed it！
MUST SEE ATOM PROJECTS
M5Stack Atom Matrix Running MicroPython Meets LoRaWAN
Google Cloud Platform Getting Data from an M5Stack ATOM Sensing the Air-quality
A Simple IMU Sensor Game for the M5ATOM
The internal IMU sensor for M5ATOM Matrix used to detect tilt. If the display shows more red pixels than green pixels, the device has to be tilted to the right. If there are more green pixels, then the unit must be tilted to the left.
M5Atom PS4 Macro Controller Mod
UPCOMING ITEMS
We are planning to develop more extension boards for ATOM such as ATOMIC and AtomEcho. It is expected that they will be available on this Friday!
Furthermore, our engineers will be developing new gadgets for ATOM to play with! AtomFLY, TailBat and Tail485！
Must See ATOM Projects And Upcoming Items
iotAs a result of the coronavirus outbreak, have you been asked to stay at home during this period? While staying at home it would be better if you developed helpful projects related to COVID-19 to play with for the coming months! Here’s what we have to say about the projects.
COVID-19 Data Monitor
This project shows how the current data of the COVID-19 pandemic can be visualized with ESP32 M5Stack. Time series data of confirmed infections and deaths during the COVID-19 pandemic strongly illustrate the seriousness of the situation.
If you want to compare the data of certain countries directly in one graph. You could write a software to load and display the data of 5 countries as combined graphs on a M5Stack. More details for this project you could find in Hackster.
Measuring Temperature
Our user designed the project to measure staff's temperature for office.
The Thermal Camera Unit communicates with the M5Core through the Grove A interface.
The COVID-19 creates enormous demands for non-contact and thermal imaging.
Wash Your Hands Properly Using Automatic Hand-Washing Reminder
During a global pandemic, one of the cheapest, easiest, and most important ways to prevent the spread of a virus is to wash your hands properly and frequently. Here’s everything you need to know about how to wash your hands the right way.
Washing your hands can protect you and your loved ones.
You can make something cool yourself. Use the above information to make your own awesome project. Have you made something interesting, then share your project with people in Hackster.
Additionally, the COVID-19 continues to spread and we want to let you know that M5Stack is still operational, and that all orders are shipping out daily as usual. We will update this message should this change at any point. Click to check the latest situation.
COVID-19 Updates-31st March 2020
Helpful Projects Related to COVID-19