Skip to content

Final Project

July, 3rd


This are the project guidelines proposed by the FAB ACADEMY Team: What will it do? Who’s done what beforehand? What will you design? What materials and components will be used? Where will come from? How much will they cost? What parts and systems will be made? What processes will be used? What questions need to be answered? How will it be evaluated? Your project should incorporate 2D and 3D design, additive and subtractive fabrication processes, electronics design and production, microcontroller interfacing and programming, system integration and packaging Where possible, you should make rather than buy the parts of your project; Projects can be separate or joint, but need to show individual mastery of the skills, and be independently operable


This catamaran called aqua, presented to FAB ACADEMY comunity last june, 19th (video here), will be used for research and investigation for high schools sudents, profession and polytechnic schools at the University level. There are several similar projects, at the educational and academic level as well as at the professional industry world. Same of them are documented at the first assignment here. I design all the structure in 3D, the electronics boards and the programing. The materials used for the structure were the ususal PLA polymer used at 3D printing, ESP walls heat isolation and cork, milled with a CNC and 3D printed. Of course, electronics components, like leds, resistors, capacitors, BLE chip, ATmega328, thermistors, phototransistors, servos, drivers, wires and DC motors. They were bought at local and online stores and it costs arround 1200 euros. I made the hull, the electronics boards, the wiring, soldering and the programing. The main processes will be directly related to Digital Fabrication, namely, 3D design and printing, electronics design and production, CNC miling and cutting, as well as molding and casting. The main question is to know if it is possible to build a small catamaran, as ecological as possible and strong enought, to be used for research and educational purposes. Evaluation of this project will be done comparing the starting idea with the pausing point at the end of this course, that is, today! The project incorporate 2D and 3D design, additive and subtractive fabrication processes, electronics design and production, microcontroller interfacing and programming, system integration and packaging. This project were built by my own responsability with several contributors.

list of files: Central body slices, EASEL files portboard hull here at my own account) and the Starboard hull here

All the zipped files, SCH, BRD and GCODE, can be found here and here; or at my personal google drive.


The main purpose of this opensource unmanned robot solar catamaran boat is to be used as an affordable maritime platform for education and scientific research. This platform prototype is designed to be 80% ecofriendly, built using Digital Fabrication tools, processes and cooperative opensource projects already in place and developed.

first modelling


Aqua final Fab Academy 2019 project, includes fabrication procedures and operation, hardware and software applied for the board at the boat to control the boat, the inflatable system (water presence inside the hulls), the safety lights and measure light intensity, UVA and air and water temperature.

António Gonçalves 3/7/2019

© Lab Aberto Fab Lab 2019 This work may be reproduced, modified, distributed, performed, and displayed for any purpose. Copyright is retained and must be preserved. The work is provided as is; no warranty is provided, and users accept all liability.


It uses 3D printed with PLA (materials more environment friendly) and the inner hull structures are made with MDF/Cardboard laser cutted. The molds and casts resins we are planned to use are also environmental friendly. It will have control board for temperature sensor, UV index output and safety control.

It can be controlled by GPS way points or radio using Opensource projects available online, like ROS and ARDUPILOT. Does have telemetry and video.

The design enables to transport an inner platform where it is possible to assembly several types of sensors for water quality, microplastics detection, sonar or just to test electronics, avoidance systems and programing.

This is a prototype of a catamaran of 1,5 m long, a width of 1 m and 0,8 m heigh. It weights around 50 kg, it has a maximum payload of 15 kg with a max volume 60L (L500xW400xH300mm) and can move at speed of 1 m/s.


It has two security buttons to stop running and two inflatable bags in the case of sink.

The main source of energy is solar but it can be charged when docked. It as two DC motors of 100 W each.

This project can be promoted as an assembled vessel or DIY kit.

compare the idea with the outcame

Looking at the initial idea the final outcame is far from it but I manage to do a major step in order to start a crucial project at our Fab Lab, not yet a Fab Lab, but in the making, lab aberto. Its mostly a breakthrough into the tecnology, electronics, programing and digital fabrication. This does not mean that all the goals were completed, far from it. In my view I did only ¼ of all the catamaran goals, and the 80% eco boat was just completed half way.

The initial idea:

The result for the starboard hull:

Positive and negative

Positive Negative
Knowledge about programing, electronics and digital fabrication Final project to much ambitious
Experiencing and testing new processes Time managment
Need to do: improve the browser code, include Bluetooth, Calibrate the sensors and Test it on water


For the future, this catamaran shoul be tested in a context of researh and education and should be controlled by radio and GPS (using Opensource projects available online, like ROS and ARDUPILOT), Integrate video, include the transport of a inner platform, test the possibility of use cardboard to make the hulls, include security buttons to stop the operation and assembly a solar pannel. Hope that in ficve years this project will achieve a very robust phase.


Starboard Hull

The hull was made in three parts, two of them 3D printed, and the central was previously sliced and cutted at CNC machine.

First modeling:

first modelling


The preliminary CAD design is here

And the STL of the preliminary versions 2 and version 4

The 7th version can be found here

Boat design reference:

Newest profile:

One of the parts at the CURA software:

Glued together all the 3D printed parts before glue them to the central CNC milled part:


Becarefull to glue the parts correctly because in my case on of the parts should be more up then the others, so the cover dooesn’t fit well as you can see on the videos and in this pic:


The 3D design of hull the central body was slided using the Autodesk SLICER (part of the FUSION360).

Filipe Help clean the slicer fusion dxf plans with AUTOCAD in order to be used in the online EASEL (files here at my own account).

The slicer plan files:

Were milled at this X-Carve:


Be carefull with the thickness of the parts when you are analysing the files to cut: increase it or you will have a hull with dangerous thickness.

After all the 2D parts were glued you have to sanding to adjust the parts to the hull original curves before you resin it:

The 3D parts were separated in smaller STL files in order to be possible to print them at our own 3D printers.

For the PortBoard Hull in the 7th version, the slice files are here.

I will test the use, instead of EPS, as in the starboard hull, I will use cork.


Since I use a cover for the bow, the slicer includes that lines that are not needed. I use this time QCAD to remove that extra lines. There is always a need to **clean*+ the file.

The clean files can be found here.


To use this files with easel from Fusion 360 slicer Filipe help with the Autodesk command overkill and join in order to kill all the sobrepositions and join the points in the same line in only one line.

Testing feed rate, spindle speed for cork:

Result: I found that cork is very friendly to feedrates of 1000 mm/min and a spindle speed of 3 or 4 in the scale of the XCARVE spindle.

Cutting files here:

Glue testing:

They seem to glue the cork very well but the one that is more robust in contact with water is the UHU glue at the right on the photo.

I’ve try it also with resin as a glue component and it seems to work fine, very resistent:


Portboard hull rising parts:

Next stop: glue it! Glue it with a normal glue:

And press it!

Testing the cork glued just with epoxi resin, the results are very good. Need to test in the water.

Since the waals are to thin and the cork is not homogeneous dense this problems might happen: broken parts:

The solution was to cut this parts and mill a wall and glue it all together.

Assembly the catamaran

(to be continued)


The main board include the ATmega328p processor, the BLE RN4871, terminals with 8 V, 5 V and 3.3 V, for the servo, the processor and the BLE. It comunicates thougth serial by I2C and FTDI, Future Technology Devices International. It as four extra terminals, 6 terminals for the air and water temperature, 2 terminals for the water sensor, and 6 pins for UVA (VEML6070 sensor) and visible light sensor (phototransistor): SCL, SDK, ACK, power and light sensor pinout


Debuging and soldering:

This video is helpfull: Soldering:

If you need this: PCB trace calculations

Ending this board was a major major achievement!

All the files can be found here

More details at this assignment.


At the debuging I found to errors: one related with the powering the LED lights for the security, and the other related with RX TX of the BLE: they need to be exchanged.

The final board with the problems solved can be found here and the files pictures are this one’s:


The Arduino programing measures the data related to the sensors refered above, controll the board with letter’s:

  • if a, command to measure data
  • if b, command to stop reading data
  • if c, activate servo,
  • if d, turn leds on,
  • if e. turn leds off;

It reacts in the presence of water inside the hull and lights up the security lights when its dark.

In the future it will have a phone and a better web interface using the BLE RN4871.

The browser doesn’t communicate directly with the serial so there is a need to create websockets and callback functions, that react to serialport events:

list – the program asks for a list of ports.
connected – when the sketch connects to a webSocket-to-serial server
open – a serial port is opened
close – a serial port is closed
data – new data arrives in a serial port
error – something goes wrong.

On this part I will use libraries and arduino IDE scripting that has a major problem, it could be so heavy that the atmega328 can have enought memory.

The sensors that I be using for the boat operation are listed at this next table.

| sensors | Outcame | Operation | note |
| UVA | UVA readings at the console | It should operate when the user push a button at the console | UV index: |
| Water Temperature | Water temperature at the console | It should operate when the user push a button at the console | |
| Air Temperature | Water temperature at the console | It should operate when the user push a button at the console | |
| Light sensor | Boat safety lights on, aknowledge at the console | Always in operation, readings each 5 minutes; the user should turn them on from the console | |
| Water sensor | Push the valve that ignites the inflatable bag, readings each minute | Should work when the hulls are flooded or when the user push the safety button | This sensor is positioned at half the hight of the hull |


mk dir aquaSerial

cd aquaSerial

touch index.js


This video shows what it does at this moment:

Arduino Programing ``` // // Aqua final Fab Academy 2019 project, software for the board at the boat //to control the inflatable system (water prensence inside the hulls) the safety // lights and measure light intensity, UVA and air and water temperature. // References: // // Based on this work: // // António Gonçalves // 19/6/2019 // // © Lab Aberto Fab Lab 2019 // This work may be reproduced, modified, distributed, // performed, and displayed for any purpose. Copyright is // retained and must be preserved. The work is provided // as is; no warranty is provided, and users accept all // liability.

#include <Arduino.h>

#include <math.h>

//#include <RN487x_BLE.h>

//U2C communication with UVA sensor, VEML6070
#include <Wire.h>
#include "Adafruit_VEML6070.h"

Adafruit_VEML6070 uv = Adafruit_VEML6070();

// state
char state = "b";//default state variable, BT not listening for the comands from the console, state has its own protocol
  //if a, command to measure data
  //if b, command to stop reading data
  //if c, activate servo,   
  //if d, turn leds on,
  //if e. turn leds off;


int airPinT = 15;//Arduino 15 ou A1 atmega328p pin 24, PC1, interrupt PCINT9
float airTADC = 0;
const float  maxADC = 1023;
int waterPinT = 14;//Arduino 14 ou A0 atmega328p pin 23, PC0, interrupt PCINT8
const float beta = 3530;//beta constante, see NTC thermistor datacheet
const float R25 = 10000;//Resistor value at 25ºC, important value for the sensor linearization

int lightLevel = 670;
float lightSensor;//analog reading variable of lightPin
int lightPIN = 16; //25, PC2, arduino IDE 16 or A2, measure ADC light level which defines when to turn on the boat security lights

//Security lights
int lights = 5;// turn on the lights trought mosfet transistor, pin 9, PD5 atmega 328p;


//TX RX comunication
#include <SoftwareSerial.h>

int interruptPin = 8;
volatile byte inflate = HIGH;//if LOW, inflates the security bag

int servo = 9;    // servo connected to digital pin 9

void setup() {

//FTDI serial

//Arduino pin 8 react to change with interrupt at atmega328p pin 12,PB0
pinMode(interruptPin, INPUT_PULLUP);//avoid floating, pin interrupt to actuate the inflatable system

uv.begin(VEML6070_1_T);  // pass in the integration time constant for 125 ms, its a 16-bit value relating to how much UV was detected, need calibration

 //pinMode(airPinT, INPUT);
 //pinMode(waterPinT, INPUT);

//Security lights
  pinMode(lightPIN, INPUT);
  pinMode(lights, OUTPUT);

//inflate servo system
 pinMode(servo, OUTPUT);

}//ends Setup

void loop() {

  bool inflate = digitalRead(interruptPin);//Read the interrupt pin

  lightSensor = analogRead(lightPIN);//arduino pin 16, pin 25 of atmega328
  //turn lights on if its dark
  if (lightSensor > lightLevel){
  Serial.println(F("Lights on!"));
  else if(lightSensor <= lightLevel)
  Serial.println(F("Lights OFF!"));
  if (inflate == LOW) {
  digitalWrite(servo, HIGH);
    delayMicroseconds(1000);//check if this corresponds to 45º
    digitalWrite(servo, LOW);
  Serial.println(F("I'm sinking! Inflatable security enable"));

  Serial.println(F("Ready: waiting for your commands"));
  state =;

  //if a data measure
  //if b stop reading data (default)
  //if c, activate servo,   
  //if d, turn leds on,
  //if e. turn leds off;
  //if f, deactivates servo

  if (state == 'd') {
    Serial.println(F("lights ON"));
  else if (state == 'a' || state == 'b' || state == 'c' || state == 'e' || state == 'f') {

  //if a data measure
  //if b stop reading data (default)
  //if c, activate servo,   
  //if d, turn leds on,
  //if e. turn leds off;
  //if f, deactivates servo
}//void loop ends


//read sensors

void comando (char state) {
switch (state) {
  case 'a':{
    Serial.println(F("Measuring data"));
    airTADC = analogRead(airPinT);//ADC value pin 15 atmega328p;
    float airTR = R25/(maxADC/airTADC-1); //air temperature thermistor resistance in OHM
    const float A = 0.9139054E-3 ;//coeficients according to
    const float B = 2.5163340E-4;
    const float D = 1.5676323E-7;
    float airTemperature = A + B*log(airTR) + D*pow(log(airTR),3); //
    //Steinhart-Hart equation, C set to 0, in the standard form, A + B*ln(R/Rt) + C*ln(R/Rt)2 + D*ln(R/Rt)3
    airTemperature = 1/airTemperature - 273.15;

    int waterTADC = analogRead(waterPinT);//pin 14 atmega328p;
    float waterTR = R25*(maxADC/waterTADC-1); //air temperature thermistor resistance: formula different because the voltage divider is different in the connection to GGND
    float waterTemperature =  A + B*log(waterTR) + D*pow(log(waterTR),3);
    waterTemperature = 1/waterTemperature - 273.15;

    lightSensor = analogRead(lightPIN);//pin 25 atmega328
    //float lightR = R25*(maxADC/lightADC - 1);//voltage divider
    Serial.println(uv.readUV());//pins I2C
  case 'b':
    Serial.println(F("readings stopped"));
  case 'c':
    digitalWrite(servo, HIGH);
    delayMicroseconds(1000);//check if this corresponds to 45º
    digitalWrite(servo, LOW);
  case 'e':
     Serial.println(F("lights OFF"));
  case 'f':
    digitalWrite(servo, HIGH);
    // wait for 30 milliseconds to see the dimming effect
    digitalWrite(servo, LOW);
    state = 'b';

This two JS programs comunicate with a local host using node to execute the files and NANO to edit them.



var serialport = require('serialport');// include the library

var WebSocketServer = require('ws').Server;
var SERVER_PORT = 8081;               // port number for the webSocket server
var wss = new WebSocketServer({port: SERVER_PORT}); // the webSocket server
var connections = new Array;          // list of connections to the server

var SerialPort = serialport;
// get port name from the command line:
var portName = process.argv[2];

var myPort = new SerialPort(portName, 9600);

var Readline = SerialPort.parsers.Readline; // make instance of Readline parser
var parser = new Readline(); // make a new parser to read ASCII lines
myPort.pipe(parser); // pipe the serial stream to the parser

myPort.on('open', showPortOpen);
parser.on('data', readSerialData);
myPort.on('close', showPortClose);
myPort.on('error', showError);

wss.on('connection', handleConnection);

function showPortOpen() {
   console.log('port open. Data rate: ' + myPort.baudRate);

function readSerialData(data) {

function showPortClose() {
   console.log('port closed.');

function showError(error) {
   console.log('Serial port error: ' + error);

function handleConnection(client) {
 console.log("New Connection"); // you have a new client
 connections.push(client); // add this client to the connections array

 client.on('message', sendToSerial); // when a client sends a message,

 client.on('close', function() { // when a client closes its connection
 console.log("connection closed"); // print it out
 var position = connections.indexOf(client); // get the client's position in th$
 connections.splice(position, 1); // and delete it from the array

function sendToSerial(data) {
 console.log("sending to serial: " + data);

function readSerialData(data) {
   // if there are webSocket connections, send the serial data
   // to all of them:
   if (connections.length > 0) {

// This function broadcasts messages to all webSocket clients
function broadcast(data) {
 for (var myConnection in connections) {   // iterate over the array of connect$
  connections[myConnection].send(data); // send the data to each connection

listserial.js ``` var serialport = require(‘serialport’);

// list serial ports:
serialport.list(function (err, ports) {
  ports.forEach(function(port) {

This file index.html need more work! It reads the serial but doesn’t put the data on the wright place!

index.html ``` <!DOCTYPE html> aqua project interface

  <script src=""></scri$
  <script src="$
  <script src="$


var text;     // variable for the text div you'll create
var socket = new WebSocket("ws://localhost:8081");
var airTemperature;
var waterTemperature;
var uvA;
    var dayLightIntensity;
var serial;          // variable to hold an instance of the serialport library
var portName = '/dev/tty.usbserial-FTFPE355';  // fill in your serial port name$
var inData;

function setup() {

// The socket connection needs two event listeners:
   socket.onopen = openSocket;
   socket.onmessage = showData;

airTemperature  = createDiv("Air Temperature");

waterTemperature  = createDiv("Water Temperature");

uvA  = createDiv("UVA");

dayLightIntensity  = createDiv("Day Light Intensity");


function draw(){

function openSocket() {
    text.html("Socket open");
    socket.send("Hello server");

function serialEvent() {
  inData = Number(;

function showData(result) {
  var resultString =;
  // split it:
let numbers = split(resultString, "/");
// use the numbers:
airTemperature.html("Air temperature:  " + numbers[0]);
waterTemperature.html("Water temperature:  " + numbers[1]);
uvA.html("UVA:  " + numbers[2]);
dayLightIntensity.html("Day ligt intensity : " + numbers[3]);



Data Aqua Catamaran Interface
Fab Academy 2019 student António Gonçalves




Wrong turns and Miscelaneous


Advanced Reviews about Unmanned Boat (in time)

Qty Description Price (EUR) Link Notes
2 DC motors 100W + Drivers (20 A) T100 bluerobotics 322.80
1 100W Solar pannel
24 18650 Batteries 35.86
4 BMC batteries chargers
6 3D printing 100
1 Electronics 52,62
2 PCB 15.00
1 FPV - video 76.40
1 PIXWACK 2 300 Buyed for another project 3 years ago
1 Telemetry
2 Safety - Emergence STOP Interrupt Button
1 Safety - Boat rescue 43,21 West Coast Sailing Center, Inflatable system and floating cable
3 Safety - Electric cables and lights 30,28 Local store “Electrofoz”, Figueira da Foz, Coimbra, Portugal Lights
1 Safety retransmission antenna
4 UVA Light Sensor with I2C Interface 15.88
4 Hull - laser cutting
4 Hull - resins
4 Hull - tissues
4 Hull - aluminum transverse bars 38.57
1 Lab Security mask
1 transport 210
1 ATmega328p
1 Servo kit servo duplo eixo digital para robot 270º - Velleman VMA601 27.12

Electronic production

Done the sensors, the atmega soldering, flux, copper wire, debug, didn’t use the gun; start by the minimal components on the bord to make the bootloader with the ISP.

Convert smd (surface mount resistor) resistor:

Capacitor value, decoupling:

!!! Yikes! I wait this Yikes!!! First boot, didn’t work: miss one zero resistor! After debugging to see if the board were powered but find out that the processor was not.


AGND not GND! Soldering a master wire!!! ;)

not 3.3V… change regulator

signature p.244:

MORE ERRORS: AREF and AVCC not connected …

NEW board! Don’t give up!

Electrical characteristics

electrical motors: separate power supply;

System: 5V (LIGHT/UVA/thermistor/processor), 3.3V (BLE), servo (máx. 8V)

Regulator 5V circuit, p.8: NOT ADJUSTABLE!!!! see p.10 datasheet; SEE the reference: ZLDO1117QG50TA NOT adjustable: remove the resitors and put on zero resistor near the GND;

Regulator 3.3V circuit, p.11:





Student, Fab 2019, BLE:



communication BLE:

Header, footer on serial communications:

Power mosfet


Its easy to interchange p-Mosfet with n-Mosfet.

Power mosfet:

Power mosfet, LM3480IM 3, 3.3V:

N channel Mosfet:


ATMEGA328p pinout:

Or here:


The NTC thermistor provides a near optimum solution for temperature-dependent regulation. It is low-cost, readily available through a variety of suppliers (Murata, Panasonic, etc.), and available in small surface-mount packaging from 0402 size through 1206 size. Furthermore, with only a basic understanding, the NTC thermistor is straightforward to apply to your circuit. As the name implies, the thermistor is just a temperature-dependent resistor. Unfortunately, the dependence is very non-linear (see Figure 1) and, by itself, would not be very helpful for most applications. Fortunately, there are two easy techniques to linearize a thermistor’s behavior.

Linearizing An NTC thermistor is most easily utilized when applied in a linearizing circuit. There are two simple techniques for linearization: resistance mode and voltage mode.

Voltage Mode choosed:datasheet R25 value (datasheet page) R/R_25 = 1, the same as R_25, 10K: 10K\Omega; using analogic pin voltage divider: datasheet: not directly in contact with liquids: NTC thermistor library: NTC thermistor calculator Steinhart-Hart equation coeficients: source: sensor: more: measuring temperature. Tutprial NTC: adafruit: Steinhart-Hart equation:

Calculating thermistor resistor value: Thermistor:

Temperature readings:


Reference: arduino programing essentials:

Arduino arithmetic:

“nan” - not a number;


all variables in long/float type;

UVA readings

p.5, schematics:

Another schematics:

Schematics adafruit:

p.11: soldering recomendations:

Electronics, Capacitor:

Software tutorials:

UVA calibration (rude):


Sea surface Temperature:

Voltage Mode choosed, voltage divider: datasheet R25 value (datasheet page) R/R_25 = 1.2161, more or less 22% more then R_25: 12K\Omega; using analogic pin

visible Light SENSOR

LED reading light:

Simple leds as light sensors:

Phototransistor Cathode: blue line; Phototransistor explained:; datasheet:

LED simple explanation:


blue robotics T100




Boat Security Lights

PCB, boat hardware board


Always use a external clock.

avrdude: WARNING: invalid value for unused bits in fuse “efuse”, should be set to 1 according to datasheet This behaviour is deprecated and will result in an error in future version You probably want to use 0xfd instead of 0x05 (double check with your datasheet first).

Error: Could not find USBtiny device (0x1781/0xc9f) Error while burning bootloader.


Atmega with internal clock tutorial:

BLE, RN4871

After not detecting the BLE device I followed the Joris Navarro FAB ACADEMY 2018 page and this BLE tutorial ChipKIT.

AT firts I install Python for MAC here.

After this… (base) 10-22-208-96:Applications antoniocarlosgoncalves$ python -m pip install setuptools Requirement already satisfied: setuptools in /anaconda3/lib/python3.7/site-packages (40.8.0) (base) 10-22-208-96:Applications antoniocarlosgoncalves$

Install pyserial (base) 10-22-208-96:Applications antoniocarlosgoncalves$ pip install pyserial Collecting pyserial Downloading (193kB) 100% |████████████████████████████████| 194kB 2.0MB/s Installing collected packages: pyserial Successfully installed pyserial-3.4 (base) 10-22-208-96:Applications antoniocarlosgoncalves$

Find file on MAC… (base) 10-22-208-96:Applications antoniocarlosgoncalves$ sudo find /Users -name “” Password: /Users/antoniocarlosgoncalves/BEESOFT4/python-beeweb/bin/ /Users/antoniocarlosgoncalves/.Trash/pyserial-master 2/serial/tools/ /Users/antoniocarlosgoncalves/Downloads/pyserial-master/serial/tools/

STUCK here: after this commands at the terminal, python / /dev/tty.usbserial-FTFPE355 115200, I didn’t get what was expected at Navarro tutorial.

I change for this tutorial at this other spark fun tutorial. Installed coolTerm:


RX TX interchanged!!!

Example for BLE HM10:



  • Solar 12V, flexible pannel, 100 W

To be developed in the future in the FAB LAB network Reference:


The boat movement will be controlled by two ways: a radio remote control and GPS runned by PIXwack 2 with ARDUPILOT open source software control: - Pixwack I2C: - I2C: - ARDUPILOT - ROS

To be developed in the future in the FAB LAB network

BOAT Safety


General references

Similar student 2018 fabaaacademy,Joris Navarro,

OHM’s Law calculator:

Quality air monitor example:


Consultors (in order of appearance)

  • João Simões, Lab Aberto Fab Lab
  • Miguel Ramalho, Student at the IST Lisbon university, Mechanical Engineering
  • Paulo Teixeira, FAB LAB EDP head manager
  • Nuno Calado, FAB LAB EDP colaborator
  • Adrian Moldovan, FCT engineering student
  • Rafael Calado, FAB LAB Lisbon, Lisbon Portugal
  • Ferdi Meier, Mechanical Engineering