Difference between revisions of "e-puck2 radio module development"
|Line 82:||Line 82:|
==Controlling the robot==
==Controlling the robot==
Revision as of 08:23, 17 February 2021
Espressif provides the Espressif IoT Development Framework (ESP-IDF for short), that is a framework for developing applications based on the Espressif ESP32 chip. The firmwares developed for the e-puck2 radio module are based on this framework.
The software development framework provided by Espressif is intended for rapidly developing Internet of Things (IoT) applications, with Wi-Fi, Bluetooth, flexible power management and other advanced system features.
Users can develop applications in Windows, Linux and MacOS based on ESP-IDF.
C programming language is used to develop code for the radio module of the e-puck2 robot and the ESP-IDF includes the FreeRTOS real time operating system.
In order to build the firmware you need to install the toolchain for your OS, refer to http://esp-idf.readthedocs.io/en/latest/get-started/#setup-toolchain.
Once installed you can issue the command
make flash from the directory
Projects\ESP32_E-Puck_2 to build the firmware.
For more information have a look at http://esp-idf.readthedocs.io/en/latest/get-started/#build-and-flash.
You can debug your code by printing some information on the serial port from your code, then from the PC you can read these information by opening the
Serial Monitor port with a terminal program (have a look at the chapter Finding the USB serial ports used to know what ports are availables).
Get the source code
The radio module firmware source code can be downloaded with the command:
git clone --recursive https://github.com/e-puck2/esp-idf.git
The radio module wifi firmware source code can be downloaded with the command:
git clone -b wifi --recursive https://github.com/e-puck2/esp-idf.git
Communication with main microcontroller
The radio module and the main microcontroller are connected via 2 channels: UART and SPI. SPI is dedicated solely for exchanging the images captured by the main microcontroller, the UART channel instead is used to receive all sensors data and send commands.
The UART communication protocol is based on the advanced sercom protocol.
The following figure shows the sensors packet received from the main microcontroller via UART. The packet size is 104 bytes. For more information about the values of each field refer to the WiFi communication protocol section:
The following figure shows the packet format to send to the main microcontroller via UART. For more information about the values of each field refer to the WiFi communication protocol section:
Refer to the WiFi branch of the radio module firmware as implementation reference.
The UART communication is implemented in the
uart_e-puck2.c (separated task). First of all you need to initialize the channel with
uart_init();, then you can exchange data by using the functions
uart_get_data_ptr to respectively send commands to the robot and receive sensors information.
We implemented some basic concepts of local infection transmission and proximity tracing exploiting Bluetooth 4 on our robot e-puck2. The goal is to provide an open source framework and to visualize the positive effect of proximity tracing APP within a pandemic such as COVID-19. Such a simulation and demonstration can be extended by the community and we do not pretend that this initial effort is scientifically valid. However already with the initial parameters it becomes clear that self-quarantine triggered by a proximity tracing APP is beneficial.
We implemented a simplified version of the DP-3T protocol (no actual code used from this repo).The following image shows a general overview of the architecture:
We use Bluetooth for both proximity tracing, as in reality, and infectivity, that is encoded in the advertisement packet together with the robot ID. The proximity of a robot is detected using the BLE signal strength. A computer is designed for acting as the DP-3T server, listening for incoming WiFi connections (TCP) from the robots and maintaining the list of infected robots. No privacy handling is involved.
Here is a list of interesting features exploited from the robot capabilities:
- simultaneous BLE scanning and advertising
- BLE and WiFi cohexistence
- proximity detection through BLE signal strength (RSSI)
For running the demo you need a computer acting as the server and at least 3 robots, even if the more robots you have, the better.
For each e-puck2 robot you need to:
- program the main microcontroller with the factory firmware
- program the radio module with the following firmware esp32_covid.zip (20.05.20), refer to section Radio module - Firmware update for more information on how to flash the radio module
On the computer you need to install Python 3 in order to run the server script that you can download from here server.py.
Prepare an arena big enough to contain all the robots that will move around avoiding obstacles once turned on.
There are 3 roles available for the simulation; each role is chosen by using the selector position:
- patient zero: this is the robot that will start the infection spread by starting being contagious; this is thought to be only one robot; selector position 0
- DP-3T actor: one or more robots; selector position 15
- no DP-3T actor: one or more robots; any selector position, but 15 and 0
For running the demo follow these steps:
- Run the Python script on the computer
- Take the robot chosen to be the patient zero; put the selector in position 15 then turn it on (the robot must be turned on with the selector in position 15); after start, the top front LED will turn on for 3 seconds, during this period you need to select the role, in this case place the selector in position 0; then the LED will turn off and the robot will start moving around avoiding obstacles
- Take the robot chosen to be a DP-3T actor; put the selector in position 15 then turn it on (the robot must be turned on with the selector in position 15); after start, the top front LED will turn on for 3 seconds, during this period you need to select the role, in this case keep the selector in position 15; then the LED will turn off and the robot will start moving around avoiding obstacles. The robot will connect also to the server, beware that the server IP address is hard-coded in the software (192.168.1.8), thus if your server has a different IP address then you need to rebuild the firmware, refer to section COVID19 - Building
- Take the robot chosen to be a no-DP-3T actor; put the selector in position 15 then turn it on (the robot must be turned on with the selector in position 15); after start, the top front LED will turn on for 3 seconds, during this period you need to select the role, in this case put the selector in position e.g. 14; then the LED will turn off and the robot will start moving around avoiding obstacles
- Repeat step 3 and 4 for all the robots you want to use for each role
Now have fun seeing how the simulation evolves. You can have a look at the following video as an example:
The following state diagrams illustrate the details of the simulation; you can analyze them to deeply understand what is happening for each role.
In order to build the radio module firmware, follow these steps:
- install the toolchain for your OS, refer to http://esp-idf.readthedocs.io/en/latest/get-started/#setup-toolchain
- clone the
ESP-IDF(ESP32 framework) repository by issueing the command
git clone --recursive https://github.com/espressif/esp-idf.git
- clone the COVID-19 example repository into the
examplesdirectory of the
ESP-IDFby issueing the command
git clone https://github.com/e-puck2/COVID-19.git
- move to the directory
esp-idf/examples/COVID-19/esp32_covidand issue the command
idf.py buildto build the project, beware that you need to set up the environment variables (refer to step-4-set-up-the-environment-variables)
- once the project is built, take the files
build/partition-table/partition-table.binand follow the instructions in the following link  to flash the radio module; beware that you need to change the programming script in order to reflect the correct file names
Controlling the robot