Tips on how to Handle an M5Stack Core2 for AWS

On this sequence of articles, we contemplate the professionals and cons of various methods to handle an M5Stack controller to construct a machine studying utility related to the AWS IoT cloud. The sequence contains 6 manuals with totally different languages, instruments, and methods.

Introduction to the M5Stack controller

M5Stack Core2 ESP32 IoT Improvement Equipment for AWS IoT EduKit is a small controller primarily based on ESP32 twin core ESP32-D0WDQ6-V3 processors with 8MB PSRAM and 16MB flash on board, devoted to the AWS IoT EduKit program. It’s small, not-so-powerful, but it surely has a small touchscreen, card reader, microphone, speaker, vibration engine, accelerometer, gyroscope, 2.4Ghz Wi-Fi, and a few colourful LEDs, so it’s good for use as an IoT system for schooling.

Sadly, as a consequence of ESP32 structure, it additionally has a number of important limitations. The controller can’t be used as an IoT edge system for AWS Greengrass as a result of there isn’t a AWS Greengrass Core library for ESP32 up to now. Moreover that, it can also’t deal with TinyML out of the field – all well-known studying libraries (like Tensorflow Lite or scikit-learn) require no less than ARM processors to function. The very best you are able to do is to make use of Tensorflow Lite for Microcontrollers in C/C++ code or write your personal ML logic in Micropython. If you wish to use M5Stack to construct a “be taught on IoT edge” stream, you should have no less than an ARM-based Raspberry Pi (or related) in your IoT community and use M5Stack to gather and pre-process knowledge solely.

Tips on how to work with M5Stack? The system is completely open, and you may flash the interior reminiscence with all the things you need. In fact, you should cross-compile your software program for ESP32, and it’s clever so as to add some M5Stack-related modules to deal with no less than the display screen or some LED to know if it really works. Based on the documentation, there are just a few advisable methods to handle your M5Stack system, so let’s talk about these potentialities and discover the professionals and cons.

UiFlow

The straightforward method first. UiFlow is a browser-based software with a user-friendly block editor that makes use of OTA updates to ship Micropython code to the system. There may be additionally a desktop software in case you want to make use of USB cable greater than OTA updates, but it surely’s already deprecated.

Preparation

To make use of UiFlow, you should set up correct firmware to M5Stack first. It’s essential to set up a CP210x_VCP driver devoted to your OS in your pc (Home windows, MacOS, and Linux variations can be found) after which obtain and begin a burning software (small, transportable app). You will discover all of these on the official web page https://docs.m5stack.com/en/quick_start/core2_for_aws/uiflow. 

Now you possibly can join M5Stack controller to a USB port and confirm the connection. To try this, open the burning software and open the “COM Monitor” from the menu within the high proper nook. If the system is related, it’s best to see the COM port connected to it by your OS. In my case, it’s COM3. The identical port needs to be chosen by default within the drop-down menu within the high left nook. 

If one thing is improper, confirm the driving force set up, test your antivirus guidelines, and ensure the system is turned on. Generally, while you’ve made some mistake, the system seems to be like a bricked one (no LED, no display screen), and it’s arduous to acknowledge whether or not it’s really enabled or not.

Utilizing the software, it’s best to set up software program ready for Core2 solely. It’s a very good second to mess around and attempt to obtain and set up, e.g., Core2_Tools (to check sensors) or some good previous recreation ready by the group. Remember that a lot of the firmwares out there within the burning software are written for a fundamental M5Stack single-core controller, so that you’ll be capable to burn it to the system, but it surely gained’t begin in any respect. Don’t fear; in such a case, you possibly can at all times burn one other one. The official documentation suggests lowering the bitrate in case of burning errors, however I by no means had to try this.

Please notice the debugging messages throughout burning. The software makes use of esptool.py to burn firmware to the system, so normally, you are able to do the identical out of your console if you would like.

Utilizing UiFlow

Now, let’s burn UIFlow_Core2 firmware.

All you should do is to choose the proper firmware, obtain it and burn. The burning software will ask you in your Wi-Fi credentials. Keep in mind, the system doesn’t assist 5Ghz frequency, so you should have a 2,4Ghz or 2,4/5Ghz combined community to maneuver on.

Now, it’s time to configure the firmware. Below the “configuration” button within the burning software, you possibly can choose certainly one of three modes: App, USB, or Web. Within the App mode, you can begin some utility from the interior reminiscence or configure USB or Web mode straight utilizing the controller’s display screen. Within the USB mode, you possibly can add and begin an utility out of your pc (test Micropython and FreeRTOS sections). Web mode is the way in which to make use of the web-based UiFlow.

After beginning the controller within the Web mode, it’s best to see three essential items of data.

On the high bar, you possibly can see the Wi-Fi icon and cloud synchronization icon. Each needs to be inexperienced. If the primary one is pink, you should test your Wi-Fi configuration and just be sure you use a 2,4Ghz community and that the password is right. In some uncommon instances, the system could also be incompatible together with your native router. It shouldn’t occur however effectively… It occurred to me as soon as, and I had to make use of one other router to proceed. If the cloud icon is pink, possibly your native community isn’t related to the Web, or UiFlow servers are quickly down.

Within the heart a part of the display screen, you possibly can see the API KEY. You need to use this identifier in your browser to replace the system over-the-air. If you should rotate your API KEY as a result of e.g., you might have compromised the important thing by posting a photograph of your system with it within the weblog article, and now everybody can replace your system OTA, you need to use the “Erase” button within the burning software and burn the UiFlow_Core2 picture once more.

Now, you possibly can open https://stream.m5stack.com in a browser and begin coding. In the course of the first begin, the applying ought to ask you to offer the API KEY and choose your M5Stack mannequin.

You may modify these settings later utilizing a small button within the backside left nook.

The online software is sort of {powerful}.

On the heart of the highest bar, you possibly can select whether or not you wish to use the block editor or in case you want to put in writing the Micropython code by yourself. Within the block mode, utilizing the left bar, you possibly can handle further modules you probably have some. Within the code Python mode, you can too add some small information to the system. You may run your code on the backside proper nook or open a Python console (utilizing a COM port, not the Web connection).

The highest left part is the WYSIWYG editor – you possibly can drag&drop UI parts to your system’s display screen.

Instance

Let’s use UiFlow to implement some utility. The purpose is to attach the controller to the AWS IoT Core. The applying will work in each methods – it’s going to present on the system’s display screen texts despatched from the cloud through MQTT and ship again the system place (from the built-in gyroscope). It’s simply an instance of both-way communication you need to use for extra advanced duties.

Let’s begin from the AWS facet. You need to use a free tier account for this utility in case you don’t have a correct account but.

Open the AWS console after which the IoT Core service. From the left menu, choose Handle -> All units -> Issues.

Create a brand new, single Factor (it’s sufficient for our use case up to now). My Factor title is “UiFlow_test”. You need to use no matter you need – we’re going to make use of the title at a later level. You may depart the remainder of the Factor configuration with the default settings (no shadow, generate certificates, and many others.). On the insurance policies display screen, create a brand new coverage and copy-paste the next coverage JSON definition:

{
  "Model": "2012-10-17",
  "Assertion": [
    {
      "Effect": "Allow",
      "Action": "iot:*",
      "Resource": "*"
    }
  ]
}

Utilizing allow-all coverage is redundant for our use-case, so you possibly can attempt to slim your permissions if wanted. It’s essential to obtain certificates throughout the Factor creation wizard, as a result of it gained’t be doable later.

After downloading, rename the certificates and personal key information to one thing shorter, as a result of UiFlow doesn’t like lengthy file names. It’s possible you’ll obtain the Root CA certificates too. These will probably be helpful at a later stage.

OK, let’s create some code.

You’ll want all blocks from “IoTCloud -> AWS” part from the Blockly left menu, and likewise:

• “Occasion -> Loop”,
• “Timer -> Wait (s)”,
• “JSON -> dumps”,
• “Map -> create map”,
• 3x “Textual content -> empty”
• “Hardwares -> IMU -> Get X Gyr”,
• “Hardwares -> IMU -> Get Y Gyr”,
• “Hardwares -> IMU -> Get Z Gyr”,
• “UI -> Label -> Label present”.

The final one will seem within the menu after drag&drop’ing a label part from the very left menu to the controller preview display screen.

Now, let’s do the puzzle and fill within the vital knowledge: Factor title, host URL, and matter names. I’ve person matter names: IoT_to_AWS and AWS_to_IoT. The endpoint URL is seen on the setting web page within the AWS IoT console.

Please notice you should use the small “+” button within the AWS initialization block to add the personal key and certificates information earlier than you possibly can choose them for the “keyFile” and “certFile” fields, and you may add message fragments by clicking a much bigger “+” button within the “create map” part. Your block editor ought to appear like that:

The generated code is as follows:

from m5stack import *
from m5stack_ui import *
from uiflow import *
from IoTcloud.AWS import AWS
import json

import time
import imu

display screen = M5Screen()
display screen.clean_screen()
display screen.set_screen_bg_color(0xFFFFFF)

imu0 = imu.IMU()

label0 = M5Label('label0', x=134, y=109, coloration=0x000, font=FONT_MONT_14, mother or father=None)

def fun_AWS_to_IoT_(topic_data):
  # international params
  label0.set_text(str(topic_data))
  move

aws = AWS(things_name="UiFlow_test", host=XXX-ats.iot.eu-west-1.amazonaws.com, port=8883, keepalive=60, cert_file_path="/flash/res/certificates.pem.crt", private_key_path="/flash/res/personal.pem.key")
aws.subscribe(str('AWS_to_IoT'), fun_AWS_to_IoT_)
aws.begin()
whereas True:
  aws.publish(str('IoT_to_AWS'),str((json.dumps(({'x':(imu0.gyro[0]),'y':(imu0.gyro[1]),'z':(imu0.gyro[2])})))))
  wait(5)
  wait_ms(2)

OK, let’s run the applying and see what occurs. If the controller doesn’t reset after your browser’s “resetting” message, you should restart it manually and check out once more.

In the event you see the “label0” message on the controller’s display screen, it’s time to open the AWS console and test the communication.

Go to the MQTT check consumer within the left menu of the AWS IoT service. Now you possibly can subscribe to the IoT_to_AWS matter to gather the gyroscope knowledge from the system, and you may publish one thing to the AWS_to_IoT matter to vary the label on the system’s display screen.

It’s all about your creativeness; what do you wish to do with the IoT system related to the AWS cloud?

Micropython

We’ve discovered the primary steps with our M5Stack controller within the earlier handbook. This time, let’s depart the UI and use the great previous IDE and console solely.

To make use of this method you should burn the UIFlow_Core2 firmware in the identical method as when configuring UiFlow. Wait a second… We already used this firmware and even wrote a Micropython code, so why does it deserve one other part? This time we’re not going to make use of a elaborate, block, web-based OTA software however a very good previous Visible Studio Code.

Let’s begin with the controller. All you should do is to burn the UIFlow_Core2 and configure it in USB mode.

Now, let’s set up VSCode and join the controller. You may set up the IDE straight from the official web page https://code.visualstudio.com/. In the event you’re engaged on a Home windows machine with WSL, the IDE will probably be out there in each (Home windows and Linux) environments. As we may have some further libraries, simpler to handle in Linux, let’s use VSCode from WSL. Let’s open WSL and run ‘code’. The latest IDE will probably be downloaded (in case your model is out of date) and run.

Up to now, so good, however there is a crucial impediment when utilizing WSL. First, you want WSL2, so please comply with the official handbook to improve: https://be taught.microsoft.com/en-us/home windows/wsl/set up.

The second challenge is USB forwarding. By default, USB ports usually are not out there within the WSL atmosphere. To alter it, you should use usbip. This software will redirect all USB site visitors through IP protocol to your Linux atmosphere.

In WSL, you should set up two packages and set the default path for usbip.

sudo apt set up linux-tools-5.15.0-47-generic hwdata
sudo update-alternatives --install /usr/native/bin/usbip usbip /usr/lib/linux-tools/5.15.0-47-generic/usbip 20

Now, please restart your WSL – shut the terminal, name wsl –shutdown from the Home windows command line and open the WSL terminal once more. Please notice, that the latest kernel model for me is 5.15.0-47 however you possibly can have one other one put in in your machine. Furthermore, you should set up linux-tools-xxx-generic. You’ll see latest packages for not-generic utilization out there, but it surely’s not you’re on the lookout for.

Now, utilizing PowerShell console you should set up usbip and connect the proper port. It’s form of unusual, however you possibly can set up the software and redirect the port utilizing customary person privileges, however to detach the already connected port, you should open PowerShell as Administrator. Subsequently, it’s simpler to start out the PowerShell console as Administrator and name the next instructions.

winget set up usbipd
usbipd checklist

The output ought to appear like that:

PS C:WINDOWSsystem32> usbipd checklist
Linked:
BUSID  VID:PID    DEVICE                                                        STATE
1-1    10c4:ea60  Silicon Labs CP210x USB to UART Bridge (COM3)                 Not shared
1-2    046d:c52b  Logitech USB Enter System, USB Enter System                   Not shared
1-10   0a5c:5834  Dell ControlVault w/ Fingerprint Contact Sensor, Microsoft...   Not shared
1-11   0c45:6717  Built-in Webcam                                             Not shared
1-14   8087:0aaa  Intel(R) Wi-fi Bluetooth(R)                                Not shared

Continued:
GUID                                  DEVICE

usbipd: warning: Unknown USB filter 'edevmon' could also be incompatible with this software program; 'bind --force' could also be required.

The warning within the final line is typical and there may be nothing to be frightened about. What we want is the busid of the CP210x system. In my case, the id is 1-1.

To connect and detach the controller to and from WSL atmosphere, use following instructions within the PowerShell console.

usbipd wsl connect –busid 1-1
usbipd unbind -b 1-1

If the system is connected, open your WSL console and run ‘lsusb’ for verification. The output ought to incorporates one thing just like:

Bus 001 System 002: ID 10c4:ea60 Silicon Labs CP210x UART Bridge

The system is related, however up to now, it’s out there for root solely.

It’s essential to name ‘sudo chmod 666 /dev/ttyUSB0’ in your WSL to permit all customers (and the IDE) to make use of it. If it doesn’t work, name ‘ls /dev/ttyUSB*’ to test the right title of your USB connector.

Now you possibly can open VSCode (with ‘code’ command in WSL) and set up the official vscode-m5stack-mpy plugin. Be sure, you might have additionally the ‘WSL’ extension put in (it needs to be there by default).

When your IDE is ready up, it’s best to see a brand new button “Add M5Stack” within the backside menu.

Hit it and choose the proper /dev/ttyUSB* system from the checklist. Now, within the Explorer view within the IDE, there’s a new part known as “M5Stack system”. Right here you possibly can straight handle the system reminiscence utilizing the Micropython language.

You need to use the code from the UiFlow description for testing functions. Simply paste it to the primary.py file on the controller and put the certificates and the personal key information within the correct listing (in line with the trail in your code).

To run the code, click on “Run in M5Stack” button within the high proper nook.

Abstract

UiFlow is a user-friendly web-based IDE with a block editor, WYSIWYG display screen designer, and easy code administration. It’s {powerful}; nevertheless, it’s additionally restricted to superior utilization. You may as well use VS Code as a correct, standard IDE to create your utility. You may mess around with it, blink some LED in your controller or accumulate some further knowledge from exterior modules (you probably have some). It’s essential to bear in mind that Micropython shouldn’t be the total Python however nonetheless preserves a developer-friendly syntax and a few widespread libraries. Nonetheless, alternatively, there isn’t a solution to set up any further library to your code, so we will’t use TensorFlow with Micropython this manner. We’ll attempt to deal with this challenge within the subsequent chapter of this text.