DEV Community: Erick Andrés Obregón Fonseca

AI+Microcontrollers: A practical example with Arduino

Erick Andrés Obregón Fonseca — Tue, 29 Dec 2020 20:43:53 +0000

Introduction

Artificial Intelligence has become more and more important in now-days. In this case, I'll show you how to implement a Perceptron inside a microcontroller. Albeit I'm doing this for an Arduino Uno, you can follow these step to do it in any other microcontroller, like ATmega, PIC, STM, and so on.

What is a Microcontroller (MCU)?

You can see a Microcontroller Unit or MCU as a small computer embedded in an integrated circuit (IC) chip. A Microcontroller could have one or more Central Processing Unit (CPU), a system clock, memory, peripherals (inputs/outputs), and so on. While computers can execute multiple tasks at the same time, MCUs are typically dedicated to a specific task.

Blocks Diagram of the 8051 microcontroller.

Pin Diagram of the 8051 microcontroller.

8051 microcontroller.

What is a Perceptron?

The Perceptron Algorithm was created in 1957 by Frank Rosenblatt. This was the forerunner of modern neural networks, our grandpa or granny.

The Perceptron is based on the mathematical abstraction of a neuron at the biological level. We've got a serial of inputs m̄ = [m0 m1 ... mD]^T which are linearly combined by a vector of weights (or synaptic bonds) w̄ = [w0 w1 ... wD]^T in the network function:

\gamma (m) = \sum_{i=0}^D m_i w_i = \vec{w}^T \vec{m}

A neuron is excited according to an activation function f(γ), which receives as input the result of the network function γ, and can correspond, for example, to the signum function:

In this case, our simple Perceptron will solve a classification problem for K=2, where K is the number of classes. The classification problem aims to assign a label (class) to an input of size n. You can view this as if someone has given you pictures of dogs, cats, rabbits, and so on. and you would have the task of assigning a class to each photo.

The vector of weights will be created with random values and will be updated if the classification was incorrect. I won't explain how this all works in-depth as it would be out of my goal, but you can read the original paper: The perceptron: a probabilistic model for information storage and organization in the brain by Frank Rosenblatt or this post written by smakosh.

Build your perceptron neural net from scratch

smakosh ・ Oct 10 '17

#ai #machinelearning #deeplearning #neuralnetworks

Perceptron Code

class Perceptron
{
public:
  // Inputs vector
  float* inputs;

  // Perceptron constructor
  // int ninputs - number of inputs
  Perceptron(int ninputs)
  {
    // Default learning rate
    alpha = 0.001;
    // Set the number of inputs
    n = ninputs + 1;

    // Asking for memory
    inputs = new float[n];
    weights = new float[n];

    // Bias
    inputs[n - 1] = 1;
    // Start with random weights
    randomize();
  }

  // Random weights
  void randomize()
  {
    for (int i = 0; i < n; i++)
    {
      weights[i] = (float) random(-1000, 1000) / 1000.0;
    }
  }

  // Training function
  void train(int T, float predicted)
  {
    float error = T - predicted;

    // Update weights
    for (int i = 0; i < n; i++)
    {
      weights[i] += alpha*error*inputs[i];
    }
  }

  // Forward function
  int feed_forward()
  {
    float sum = 0.0;

    for (int i = 0; i < n; i++)
    {
      sum += inputs[i]*weights[i];
    }

    return activate(sum);
  }

private:
  // Random weights vector
  float* weights;
  // Inputs number
  int n;
  // Learning rate
  float alpha;

  // Activation function
  int activate(float sum)
  {
    // Signum function
    return (sum >= 0) ? 1:-1;
  }
};

Circuit Schema

In this example, we will train our model to classify a distance into near (-1) and far (1). This distance will be taken by the ultrasonic sensor HC-SR04 and we will say that any distance that is greater than 150cm will be far and for values less than or equal to 150cm we will say that it is near. To indicate this, when the distance is far we will turn on the red LED and when it is near the green LED.

Arduino Code

Here we've got the code. We have trained our Perceptron before to predict to see the results quickly. You can also train the model by adding a button to tell it when has made a wrong prediction and needs to learn, so it can learn what is happening.

#include "perceptron.h"

// Constant values
const int ECHO_PIN = 5;
const int TRIGGER_PIN = 6;
const int GREEN_LED_PIN = 12;
const int RED_LED_PIN = 11;

// Vars
float distance;
long time;

// Our perceptron
Perceptron perceptron(1);

// Train the perceptron
void train()
{
  int distance_step = 5;

  // Train for 160 epochs
  for (int epoch = 0; epoch < 160; epoch++)
  {
    for (int d = 0; d < 340; d += distance_step)
    {
      // Set the input in the model
      perceptron.inputs[0] = d;

      // Make a prediction
      int predicted = perceptron.feed_forward();

      if ((d <= 150 && predicted == -1) || (d > 150 && predicted == 1))
      {
        perceptron.train(-predicted, predicted);
      }
    }
  }
}

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

  // Set the pins
  pinMode(TRIGGER_PIN, OUTPUT);
  pinMode(ECHO_PIN, INPUT);
  pinMode(GREEN_LED_PIN, OUTPUT);
  pinMode(RED_LED_PIN, OUTPUT);

  // Train the model before 
  train();
}

void loop()
{
  // Send a pulse to activate the sensor
  digitalWrite(TRIGGER_PIN, HIGH);
  delayMicroseconds(10);
  digitalWrite(TRIGGER_PIN, LOW);

  // Measure response pulse
  time = pulseIn(ECHO_PIN, HIGH)/2; 

  // Calculate the distance in cm
  // d = v * t
  // Speed of sound = 343m/s
  // Time is microseconds
  distance = float(time*0.0343);
  Serial.print("Distance: ");
  Serial.println(distance);

  // Set the input in the model
  perceptron.inputs[0] = distance;

  // Classify
  int predicted = perceptron.feed_forward();

  Serial.print("Predicted: ");
  Serial.println(predicted);

  if (predicted == -1)
  {
    digitalWrite(GREEN_LED_PIN, LOW);
    digitalWrite(RED_LED_PIN, HIGH);
  }
  else
  {
    digitalWrite(GREEN_LED_PIN, HIGH);
    digitalWrite(RED_LED_PIN, LOW);
  }

  delay(1000);
}

Training Results

We can see how the green LED lights up with a distance of 74.7cm, and the red LED with a distance of 244.9cm.

You can also play with the model in TinkerCAD.

Final thoughts

The Perceptron convergence theorem states that the vector of weights converges after a finite number of iterations, even when a change in such vector involves one or more new errors in samples that were correctly classified in previous iterations. This only if the set of samples to be classified is linearly separable. In this way, a simple Perceptron is not enough for complex problems, this is where I introduce the Multilayer Perceptron, but this is a topic for another post.

Yocto Project Tutorial: Baking a Minimal Linux Image from Scratch

Erick Andrés Obregón Fonseca — Sun, 27 Dec 2020 21:27:34 +0000

Introduction

Even though I am still a student, I always wanted to share a little of the knowledge that I have acquired throughout my university studies. This is why I’ve decided to write this, my first blog. In this case, I bring a tool that I learned to use in the Introduction to Embedded Systems course and that I found very interesting. This is a copy and paste of a post that I did in Medium.

Yocto Project Tutorial 1: Baking a Minimal Linux Image from Scratch | by Erick Andrés Obregón Fonseca | Medium

Erick Andrés Obregón Fonseca ・ Mar 4, 2022 ・
erickof.Medium

What is the Yocto Project?

The Yocto Project is an open-source collaboration project that helps you to create custom Linux-based systems regardless of the hardware architecture [1].

As they say on their page, the Yocto Project is not an embedded Linux distribution, instead, it creates a custom one for you.

The Yocto Project has several releases. I’ll mention the last five releases but you can find all in [2].

Codename	Version	Release Date	Current Version	Poky Version
Hardknott	3.3	April 2021	-	25.0
Gatesgarth	3.2	October 2020	-	24.0
Dunfell	3.1	April 2020	3.1.3	23
Zeus	3.0	October 2019	3.0.4	22.0.3
Warrior	2.7	April 2019	2.7.4	21.0

As you can see, the Hardknott version has yet to be released (at least by the time I wrote this post).

The Yocto Project through the OpenEmbedded build system provides an open-source development environment targeting the ARM, MIPS, PowerPC and x86 architectures for a variety of platforms including x86–64 and emulated ones. You can use components from the Yocto Project to design, develop, build, debug, simulate, and test the complete software stack using Linux, the X Window System, GTK+ frameworks, and Qt frameworks [3].

The Yocto Project Development Environment. Taken from [3]

For this tutorial, we will use Poky Dunfell because I have worked with it before and had no problems.

Why should I use my own custom Linux image?

General-purpose operating systems, such as Windows, macOS, or most Linux distributions, have several tasks to run in the background, as well as multiple installed applications that we don’t need or will never use on our embedded systems. All these reasons, together with the limited resources of our systems, make these operating systems inefficient or excessive for our poor hardware. Think that you don’t need a text editor, an office package, or a PDF reader in your embedded system if you will work with an IoT device.

Building our own operating systems allows us to install only the dependencies and software that we need. This makes it easier for us to better control and take advantage of our limited hardware and make our system more efficient by executing only the tasks it needs.

Before we start

Environment

Before starting to work with Yocto, we must make sure that we meet some requirements:

A supported Linux version (like Fedora, OpenSUSE, CentOS, Debian, or Ubuntu). You can check them in [4].
The OpenEmbedded build system should be able to run on any modern distribution that has the following versions for Git 1.7.8 or greater, tar 1.24 or greater, and Python 2.7.3 or greater [4].
At least 50 GB of free disk space for image creation.

Installing dependencies

First, we need to install the necessary packages to run Yocto. Let’s open a terminal and copy and paste the next line:

$ sudo apt-get install gawk wget git-core diffstat unzip texinfo gcc-multilib build-essential chrpath socat libsdl1.2-dev xterm

In my case, I already had all packages installed.

Installing QEmu

This is the easiest part, you only need to run:

$ sudo apt-get install qemu

Downloading Poky Dunfell

There are two options to download Poky Dunfell. The first one is to go on this link and download the tar.bz compressed file or type in a terminal:

$ wget http://downloads.yoctoproject.org/releases/yocto/yocto-3.1.2/poky-dunfell-23.0.2.tar.bz2

I will download it to my user folder. It could take a while depending on your connection speed, so be patient.

Now, we need to unzip the downloaded file.

$ tar -xvf poky-dunfell-23.0.2.tar.bz2

This will create a new folder called poky-dunfell-23.0.2 (you can change the name if you want, but it is not necessary). Now let’s enter the directory and show its content.

Baking our Image

Now, we will create a couple of directories to work with. The first is a folder where Yocto will download all our packages and dependencies (downloads folder), and the second one will be used for our image (qemu-arm folder). You can name them as you want.

$ mkdir downloads
$ mkdir qemu-arm

We need to execute the script to configure the environment necessary for variables and commands of the Yocto Project, this is the oe-init-build-env file. This will go into the qemu-arm folder.

$ . oe-init-build-env qemu-arm

Make sure to run this command every time you need to build or rebuild the image.

If we take a glance inside the conf folder, we can see some configuration files. For this tutorial, we are only interested in the local.conf file where we can set the machine architecture and the download folder path. In this, we need to add the following lines to the end of the file changing <user> for your user:

DL_DIR ?= “/home/<user>/poky-dunfell-23.0.2/downloads”
INHERIT += “rm_work”
MACHINE ?= “qemuarm”

You could use other test architectures that come in the local.conf file like:

Comments are written with # at the beginning. Another setting you can do is to use the default directory for downloads.

Finally, we can build our image. This process can take a while… 2–6 hours… depending on your internet connection and the processing power of your workstation (in this case, your computer). But don’t be overwhelmed, thankfully, every time you make a change or add new recipes (set of instructions for building packages [5]), Yocto will simply rebuild the changes and not the entire project, making this process less time-consuming.

$ bitbake core-image-minimal

You can rerun the command to see that it will only take a couple of minutes to build.

Testing our Image

Now, let’s test our image. Since our image is not graphic but console, we must specify it so that it does not produce an error.

$ runqemu qemuarm nographic

Now, type root, and we are done.

Bibliographic References

[1] "Yocto Project — It's not an embedded Linux distribution — it creates a custom one for you", Yoctoproject.org. [Online]. Available: https://www.yoctoproject.org/. [Accessed: 23- Oct- 2020].

[2] "Releases — Yocto Project", Wiki.yoctoproject.org. [Online]. Available: https://wiki.yoctoproject.org/wiki/Releases. [Accessed: 23- Oct- 2020].

[3] "Yocto Project Quick Start", Yoctoproject.org. [Online]. Available: https://www.yoctoproject.org/docs/1.8/yocto-project-qs/yocto-project-qs.html. [Accessed: 25- Oct- 2020].

[4] "Yocto Project Reference Manual", Yoctoproject.org. [Online]. Available: https://www.yoctoproject.org/docs/1.8/ref-manual/ref-manual.html. [Accessed: 25- Oct- 2020].

[5] "Yocto Project Development Manual", Yoctoproject.org. [Online]. Available: https://www.yoctoproject.org/docs/1.6/dev-manual/dev-manual.html. [Accessed: 26- Oct- 2020].

DEV Community: Erick Andrés Obregón Fonseca

AI+Microcontrollers: A practical example with Arduino

Introduction

What is a Microcontroller (MCU)?

What is a Perceptron?

Build your perceptron neural net from scratch

smakosh ・ Oct 10 '17

Perceptron Code

Circuit Schema

Arduino Code

Training Results

Final thoughts

Yocto Project Tutorial: Baking a Minimal Linux Image from Scratch

Introduction

Yocto Project Tutorial 1: Baking a Minimal Linux Image from Scratch | by Erick Andrés Obregón Fonseca | Medium

Erick Andrés Obregón Fonseca ・ Mar 4, 2022 ・ erickof.Medium

What is the Yocto Project?

Why should I use my own custom Linux image?

Before we start

Environment

Installing dependencies

Installing QEmu

Downloading Poky Dunfell

Baking our Image

Testing our Image

Bibliographic References

Erick Andrés Obregón Fonseca ・ Mar 4, 2022 ・
erickof.Medium