Virtualization on entangledDEV

101 Guide To Microcontroller Programming Inside Virtual Machines

Mon, 25 Nov 2024 03:21:54 +0000

Introduction

Hey everyone, I’m back with a new entry. This time, I’d like to guide you on how to create a simple hello world program for the ESP32-C6 inside a Virtual Machine.

Having all the toolchain inside a VM is a great way to unclutter your host machine. Programming inside a VM or containers for web development is quite common, but for microcontrollers, it’s a thing I don’t encounter that often.

What we need

For this tutorial, we will need:

Fedora Server 41 ARM
UTM
ESP32-C6
USB-C cable

Creating the Virtual Machine

Let’s start by creating the Virtual Machine. To archive this, you need a software capable of virtualizing your OS environment. Get UTM from the macOS Apple Store or directly from their website.

We also need to get the ISO we are going to use to create the VM. In this tutorial, we are using Fedora Server. Download the ARM ISO from here.

We will follow similar steps to install the OS similar to the ones on this post I made some time ago. We can follow along, with the difference that we are selecting Virtualize this time.

Once the OS is ready and SSH is working, let’s install the dependencies!

Installing dependencies inside the VM

Once you’re inside the VM, let’s run the following commands:

# Update the virtual OS
sudo dnf update -y
# Installing the needed software
sudo dnf install -y python3 python3-pip
# Install the udev needed to connect to the microcontrollers
curl -fsSL https://raw.githubusercontent.com/platformio/platformio-core/develop/platformio/assets/system/99-platformio-udev.rules | sudo tee /etc/udev/rules.d/99-platformio-udev.rules
# Install PlatformIO Core CLI
curl -fsSL -o get-platformio.py https://raw.githubusercontent.com/platformio/platformio-core-installer/master/get-platformio.py python3 get-platformio.py

We are using the PlatformIO CLI because the graphical interface installed by the plugin doesn’t work by default inside the VM. As a workaround, you could run pio home --host 0.0.0.0 --port 8008 to access the VSCode plugin GUI interface from your host browser.

Creating our basic project template

Once we have finished installing the tooling, we can start creating our hello world project.

As a first step, let’s activate the Python environment created by PlatformIO, to achieve that run:

# Activate the Python environment for PlatformIO
source ~/.platformio/penv/bin/activate

Then let’s create our project, navigate to the directory where you want to host the project, and run the following:

# Find the name of your microcontroller from the supported list, copy this name
pio boards | grep "YOUR_BOARD_NAME_HERE"
# We use pio to create the basic template project
pio project init --project-dir . --board "YOUR_BOARD_NAME_HERE"
# Open your project in VSCode
code .

As simple as that, we have our base project ready for us, now let’s do some code!

Programming the Hello World

Once you have opened the project, open the file called main.c located inside /src/ and add the following:

#include <stdio.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"

void app_main() {
    while (true) {
        printf("Hello world\n");
        vTaskDelay(1000 / portTICK_PERIOD_MS);
    }
}

The ESP32-C6 is an ARM device, so we are using the Espressif framework instead of the Arduino framework. Check with your manufacturer the type of architecture your board uses.

This program will print to the serial bus the string Hello world\n every second.

We also need to specify the baud rate so that we can monitor the output correctly. Open the file called platformio.ini and append at the end the following line:

monitor_speed = 115200

With all this done, we are one step closer to seeing our awesome code working!

Compiling, flashing, and monitoring the microcontroller

Now it’s time to connect our board via USB to the VM:

Connect the board using USB to your host machine.
Open the VM window in UTM and, in the top right, press the USB plug icon and connect your board to the VM.
Check that the board is read by Fedora by running lsusb. You should see the same name that appeared on the UTM menu.

We can use the PlatformIO extension to make the next steps easier. Install the extension inside the VM. After reloading, you will see at the bottom left these 3 icons: check mark, right arrow, and electric plug.

Now let’s do the final steps!

Press the check mark to build the project.
Press the right arrow to flash your board (some boards may need to press some buttons on the board to activate the flash mode).
Press the electric plug icon to see the hello world string being sent to the serial monitor every second!

Congratulations, now you can start developing inside a VM for your microcontrollers.

Conclusion

Developing for microcontrollers inside a virtual machine not only helps keep your host system clean and organized but also creates a portable and reproducible development environment. By following this guide, you’ve set up a Fedora Server VM with all the necessary tools to program an ESP32-C6, created a basic “Hello World” project, and successfully flashed it to your board.

This approach combines the flexibility of modern tools like PlatformIO with the advantages of virtualization, providing a robust setup for any microcontroller project. Whether you’re just starting with embedded systems or looking for a cleaner workflow, this method proves that virtual machines are a practical solution for microcontroller development.

Now that you’ve mastered the basics, you can explore more complex projects, experiment with different boards, or even automate your setup further. Happy coding, and enjoy building your next microcontroller masterpiece!

Emulating Ubuntu Server X86_64 on macOS ARM64

Tue, 19 Nov 2024 07:31:29 +0000

ARM processors are becoming more ubiquitous thanks to the introduction of Apple Silicon and Qualcomm Snapdragon. These new processors offer great performance, silent operation, and all-day battery life. On the other hand, not all software is ported to this new architecture, so there could be cases when we need to run or program x86_64 devices.

To solve this problem, we have several tools at our disposal. In this post, let’s explore one solution to emulate and run x86_64 software.

What we need

An ARM64 machine. In our case, any Apple Silicon Mac would suffice.
UTM App.
Any x86_64 OS ISO. In our case, we’re installing Ubuntu Server 24.10.

Installing UTM

The piece of software that will be doing the work for us is called UTM. This is a macOS app that uses QEMU under the hood for virtualization and emulation.

We can get this software from their website or directly from the macOS App Store. I find the former option the best.

Choose the option that best suits your needs.

Creating the emulated Virtual Machine

Once we have UTM installed, let’s download the ISO of the operating system we want to emulate. In our case, Ubuntu Server 24.10.

Next, let’s open UTM and click on Create a New Virtual Machine. Here, we just need to select emulation, select the downloaded ISO, and configure the virtualized hardware. The process is quite straightforward.

In the last screen, you can view the summary of the VM. If this looks good to you, press Create and start the VM on the main UTM window.

This will start the normal installation of the selected OS using the provided ISO.

It’s a good idea to install OpenSSH for Ubuntu Server.

Configuring SSH

Once we are logged into our VM, we can start configuring SSH. This will allow us to access our VM from our host OS and connect via VSCode to start programming.

First, we need to create our SSH key. For that, we can follow the GitHub tutorial here.

Once we have the SSH key ready, we can connect to the VM.

The previously added SSH server list is located in ~/.ssh/config

On VM, get the IP address using ip a. The IP should look similar to inet 192.168.1.10/24 (we don’t need the ending /24 part, just the numbers).
On macOS terminal, shh into the vm machine using ssh username@vm_ip_address.

If your VM doesn’t have OpenSSL installed, run the following inside your VM sudo apt update && sudo apt install openssh-server && sudo systemctl start ssh && sudo systemctl enable ssh && sudo systemctl status ssh. This will install SSH, run it, enable it on startup, and check its current status.

Coding an ASM example with VSCode

Now it’s time to do some x86_64 ASM to verify that our system is working properly.

Open VSCode and click on the lower left blue icon ><.
Select + Add New SSH Host... and add your VM host parameters using this structure ssh username@vm_ip_address.
Select the configuration file to save your new host (the first option is okay).
Once the host is added, click on Connect. (On macOS, you may need to give VSCode permission to access the network, allow it, and press retry).
Wait for the VSCode server to install on the VM.

Now that everything is ready, let’s make a hello world!

Open VSCode integrated terminal (CMD + BACKTICK) and create a new file called hello.asm (use touch hello.asm to create the file and code hello.asm to open the file on VSCode) with the following content:

section .data
    msg db 'Hello, World!', 0xA  ; Message to print with newline
    len equ $ - msg              ; Length of the message

section .text
    global _start                ; Entry point for the program

_start:
    mov rax, 1                   ; sys_write system call (1)
    mov rdi, 1                   ; File descriptor (stdout)
    mov rsi, msg                 ; Address of the message
    mov rdx, len                 ; Length of the message
    syscall                      ; Make the system call

    mov rax, 60                  ; sys_exit system call (60)
    xor rdi, rdi                 ; Exit code 0
    syscall                      ; Make the system call

Before continuing, install the assembler using sudo apt install nasm.

Now let’s run the program!

# Assembling the code
nasm -f elf64 hello.asm -o hello.o
# Linking the code
ld hello.o -o hello
# Running the code
./hello

If all went well, you should see on the integrated terminal the text Hello, World!. Congratulations, your emulated x86_64 system is working correctly!

Conclusion

ARM processors have revolutionized the computing landscape with their efficiency, performance, and battery life, making them an excellent choice for modern devices. However, their growing adoption doesn’t eliminate the need to run or develop software for the x86_64 architecture. With tools like UTM, we can easily emulate x86_64 systems on ARM-based devices, such as Apple Silicon Macs.

This post guided you through the process of setting up UTM, creating a virtual machine, configuring SSH, and even running an x86_64 assembly program. By following these steps, you’ve not only learned how to emulate a different architecture but also created a functional environment for programming and development.

The flexibility of emulation tools bridges the gap between architectures, ensuring that developers can maintain productivity regardless of the hardware they are using. This workflow demonstrates how we can adapt to and leverage the best of both ARM and x86_64 worlds. Happy coding!