Published May 21, 2026 © Apache-2.0

I Built a Drone Where the PCB Frame IS the Circuit Board

Designing a quadcopter where the PCB arms are the airframe - what I learned about rigidity, PID tuning, and flying something I built myself.

IntermediateFull instructions providedOver 4 days38

I Built a Drone Where the PCB Frame IS the Circuit Board

Things used in this project

Hardware components

Espressif ESP32

Anu PCB Drone

Inertial Measurement Unit (IMU) (6 deg of freedom)

Core le

Battery, 3.7 V

Software apps and online services

Arduino IDE

Edge Impulse Studio

Hand tools and fabrication machines

Soldering iron (generic)

Digilent Mastech MS8217 Autorange Digital Multimeter

Story

Why I Built a Drone Where the PCB Is the Airframe

Most quadcopters follow the same pattern - a carbon fibre or plastic frame, a flight controller board mounted in the middle, ESCs on the arms, motors at the tips. It works well. It's repairable. It's the right approach for serious flying.

But I wasn't building a serious drone. I was building a learning tool.

I wanted something a student or hobbyist could pick up and immediately understand - how a flight controller works, how PID loops stabilise a quad, how IMU data feeds into motor outputs. A traditional multi-part frame hides a lot of that complexity. So I asked a simple question: what if the frame and the circuit board were the same object?

That question became the ANU PCB Drone.

The Design

The concept is straightforward - the PCB arms are the airframe inspired from lightwing drone. An ESP32 module sits at the centre as the flight controller. Four coreless brushed motors mount directly to the board corners. No separate frame. No wiring harness. One board does everything.

The PCB is manufactured in FR4 - standard fibreglass PCB material. It's stiffer than you'd expect for the arm lengths we're using, and light enough to fly on coreless motors with a 1S LiPo battery.

Why coreless brushed motors instead of BLDCs?

Deliberate choice. Coreless brushed motors can be driven directly with PWM from the ESP32 GPIO pins - no ESC needed. That keeps the PCB simpler, the component count down, and the firmware easier to understand. For a learning platform doing indoor hover and short flights, they're perfectly adequate. Anyone wanting to scale up to BLDCs has a clear next project ahead of them.

The Design Challenges

1. Rigidity

FR4 is stiffer than most people expect. For the arm lengths on this drone, flex wasn't the problem I anticipated. The PCB material handles the static load well.

Vibration was the real issue. At higher throttle the motor harmonics transmit directly through the board to the IMU. The MPU-6050 was picking up significant noise before we soft-mounted it with foam tape. That single change made a dramatic difference to flight stability and PID loop performance.

2. Motor mount integrity

The motor mount holes are a stress concentration point. On the first prototype, we saw micro-cracking around the mount holes after several flights. Adding copper reinforcement pours around each mount point solved this — the copper distributes the stress across a larger area of the board.

3. Weight distribution

Centre of gravity matters on any quadcopter. On a traditional build you can slide the flight controller and battery to adjust CoG. On an integrated PCB design, CoG is fixed by component placement at layout time. We ran several CoG calculations before committing the ESP32 module position to the final layout.

4. Repairability

The honest trade-off — if an arm cracks, you replace the whole board. For a learning and prototyping platform that's acceptable. For a field drone flying aggressively outdoors, it's not the right design. We're clear about this with everyone who builds one.

The Firmware

The flight controller firmware is written in Arduino C++ and fully open source on GitHub. It covers:

PID loop for pitch, roll, and yaw stabilisation
MPU-6050 gyroscope and accelerometer integration
Motor mixing algorithm for quadcopter geometry
WiFi telemetry over UDP - streams live flight data to a browser dashboard
Standard arming and safety logic

PID tuning took two weeks.

This was the hardest part of the whole project. Every change to the P, I, or D gains changes flight behaviour in ways that are hard to predict without flying. We ended up building a simple web interface to adjust PID gains over WiFi without reflashing - that alone saved hours of iteration time.

The WiFi telemetry dashboard streams attitude, motor outputs, and battery voltage to any browser on the same network. Open 192.168.x.x, and you can watch exactly what the flight controller is doing in real time. For learning and debugging PID behaviour, this is genuinely useful.

Specifications.

What I Learned

Soft mounting the IMU is not optional. On a PCB airframe the vibration path from motors to IMU is very short. Without isolation the gyroscope data is too noisy for stable PID control.

Copper reinforcement around motor mounts is worth doing from day one. We learned this the hard way on prototype one.

WiFi telemetry is more useful than I expected. Being able to watch live motor outputs and attitude in a browser while someone else flies made PID tuning significantly faster.

FR4 is a surprisingly capable structural material at small scale. I expected more flex problems than we got. The limiting factor was vibration, not rigidity.

The integrated design genuinely simplifies the learning experience.

A student can look at this board and understand the whole system — power, processing, sensing, and actuation — in one object. That was the goal and it works.

Take It Further

Add a camera — mount an ESP32-CAM module and stream a first-person video feed over WiFi
Upgrade to BLDCs — add ESCs and rewrite the motor mixing for brushless control
Tune your own PID — use the WiFi dashboard to adjust gains in real time without reflashing
Add more sensors — barometer for altitude hold, optical flow for position hold

About CoreStack

The ANU PCB Drone is part of CoreStack — a 5-board embedded learning kit I've been building for the past year. It covers Arduino Uno R4 WiFi, Raspberry Pi Pico 2, CYD touch display, ESP32-CAM, and STM32 Nucleo across 5 learning stages — from beginner to edge AI.

Click here

The full kit includes the drone, 145+ components, 35+ GitHub projects, and a dedicated learning platform with video courses.

CoreStack is currently on Kickstarter - follow the pre-launch page to get notified when early bird pricing opens:

kickstarter pre-launch

Early bird starts at $99 for the Core Kit.

Code

code

#include <FU68xx.h>
#include "foc.h"
#include "foc-cfg.h"
#include "adc.h"
#include "q15-math.h"
#include "pu-quantities.h"

static struct q15_ramp_s m_vq_ramp_s;
static struct q15_ramp_s m_theta_comp_s;
static int16_t m_current_offset = 0;
static int16_t m_theta_comp;

void
foc_init(void)
{
  q15_ramp_init(&m_vq_ramp_s,_Q15(0.3),_Q15(0.000156));
  q15_ramp_init(&m_theta_comp_s,_Q15(0.0),1);
  m_theta_comp = THETA_COMP;
	/* deadtime set */
	TIM0_DTR = PWM_LOAD_DEADTIME;
	
	/*enable FOC register set*/	
	FOCEN	= 1;
  FOC_SET1 = (1<<FOCFR);
	
	CLR(FOC_SR,FUIF);
	SET(FOC_IER,FUIE);
		
	PFOC1 = 0;
	PFOC0 = 1;
		
	/* set FOC register */
	FOC_CR1 = 0;
  FOC_CR2 = 0;
	FOC_IDREF = 0;
	FOC_IQREF = 0;

	FOC_THETA = 0;
	FOC_RTHEACC = 0;
	FOC_RTHESTEP = 0;
	FOC_RTHECNT = 0;
	FOC_THECOMP = 0;
	FOC_THECOR = 2;

	FOC_ARR = PWM_VALUE_LOAD;
	FOC_POWKLPF = _Q15(0.00392699);
	
	/* current loop parameter set */
	FOC_DKP = D_KP;
	FOC_DKI = D_KI;
	FOC_DMAX = DOUTMAX;
	FOC_DMIN = DOUTMIN;
	
	FOC_QKP = Q_KP;
	FOC_QKI = Q_KI;
	FOC_QMAX = QOUTMAX;
	FOC_QMIN = QOUTMIN;
		
	/* estimate parameter set */
	FOC_EK1 = OBS_K1T;
	FOC_EK2 = OBS_K2T;
	FOC_EK3 = OBS_K3T;
	FOC_EK4 = OBS_K4T;

	FOC_FBASE = OBS_FBASE;
	FOC_OMEKLPF = SPEED_KLPF;
	FOC_EBMFK = OBS_KLPF;
	FOC_EKP = OBSW_KP_GAIN;
	FOC_EKI = OBSW_KI_GAIN;

  /* driver mode and active level set*/
	SET_BIT(FOC_CMR,CCPH,0);
	SET_BIT(FOC_CMR,CCPL,0);

	/* Estimate Algorithm PLL */
	FOC_KSLIDE = OBSE_PLLKP_GAIN;
  FOC_EKLPFMIN = OBSE_PLLKI_GAIN;
	
  /* single shunt mode */
	SET_BIT(FOC_CR1,CSM,0);
	FOC_TSMIN = PWM_TS_LOAD;
	FOC_TRGDLY = 2;
	SET_BIT(FOC_CR2,F5SEG,0);

  if (m_current_offset)
  {
    CLR(FOC_CHC,CSOC1);
    CLR(FOC_CHC,CSOC0);
    FOC_CSO = m_current_offset;
  }

  /* Enable PWM 6 channel output */
	SET_BIT(FOC_CMR,CC3EH,1);
	SET_BIT(FOC_CMR,CC3EL,1);
	SET_BIT(FOC_CMR,CC2EH,1);
	SET_BIT(FOC_CMR,CC2EL,1);
	SET_BIT(FOC_CMR,CC1EH,1);
  SET_BIT(FOC_CMR,CC1EL,1);
	
	/* enable I/O port output */
	P3_AN |= 0xC0;
	MOE = 1;
}

void
foc_motor_windmill_detect_init(void)
{
  FOCEN = 0;
  foc_init();

  FOC_IDREF = 0;
  FOC_IQREF = 0;

  FOC_EKP = OBSW_KP_GAIN_FREEWHEEL;
  FOC_EKI = OBSW_KI_GAIN_FREEWHEEL;

  FOC_CR2 |= (1<<ESCMS);
  /*sample shunt resister mode set*/
  FOC_CR1 	= 0x05;
  /*Estimate Algorithm set*/
  SET_BIT(FOC_CR1,ESEL,1);
}

void
foc_motor_start_align(int16_t angle)
{
  /* reset the foc module to clear the observer */
  FOCEN	= 0;
  foc_init();

  FOC_EKP = OBSW_KP_GAIN;
  FOC_EKI = OBSW_KI_GAIN;

  FOC_DKP = D_KP;
  FOC_DKI = D_KI;
  FOC_QKP = Q_KP;
  FOC_QKI = Q_KI;

  FOC_RTHEACC = 0x0000;
  FOC_RTHESTEP = 0x0000;
  FOC_THETA = angle;
  FOC_RTHECNT = 5;
  SET_BIT(FOC_CR1,EFAE,0);
  SET_BIT(FOC_CR1,RFAE,1);
  SET_BIT(FOC_CR1,ANGM,0);

  /*sample shunt resister mode set*/
  FOC_CR1 	= 0x05;

  /* exit wind milling detect mode */
  FOC_CR2 = 0x00;

  /*Estimate Algorithm set*/
  SET_BIT(FOC_CR1,ESEL,1);
}

void
foc_motor_start_open_loop(void)
{
  FOC_RTHEACC = OPEN_LOOP_THETA_ACC;
  FOC_RTHESTEP = OPEN_LOOP_START_SPEED;
  FOC_RTHECNT = THETA_OPEN_LOOP_CNT;

  FOC_EFREQACC = OPEN_LOOP_THETA_ACC;
  FOC_EFREQMIN = OPEN_LOOP_CUTIN_SPEED;
  FOC_EFREQHOLD = OPEN_LOOP_CUTIN_HOLD_SPEED;

  SET_BIT(FOC_CR1,EFAE,1);
  SET_BIT(FOC_CR1,RFAE,1);
  SET_BIT(FOC_CR1,ANGM,1);
}

void
foc_continue_open_loop(void)
{
  SET_BIT(FOC_CR1,EFAE,1);
  SET_BIT(FOC_CR1,RFAE,1);
  SET_BIT(FOC_CR1,ANGM,1);
}

void
foc_motor_windmill_start(void)
{
  q15_ramp_init(&m_vq_ramp_s,_Q15(0.9),_Q15(0.000156));
  FOC_EFREQACC = OPEN_LOOP_THETA_ACC;
  FOC_EFREQMIN = OPEN_LOOP_CUTIN_SPEED;
  FOC_EFREQHOLD = OPEN_LOOP_CUTIN_HOLD_SPEED;
  SET_BIT(FOC_CR1,EFAE,1);
  SET_BIT(FOC_CR1,RFAE,0);
  SET_BIT(FOC_CR1,ANGM,1);
}

uint8_t
foc_motor_open_loop_complete(void)
{
  if(!GET_BIT(FOC_CR1,RFAE))
  {
    return (1);
  }
  return (0);
}

uint8_t
foc_motor_closed_loop_lock(void)
{
  if (FOC_EOME > FOC_EFREQMIN)
  {
    return (1);
  }
  return (0);
}

void
foc_motor_stop(void)
{
	FOC_CR1 = 0x00;
	FOCEN = 0;
	MOE = 0;
}

int16_t
foc_get_motor_speed(void)
{
  return ((int16_t)FOC_EOME);
}

void
foc_set_param(struct foc_idq_s ref_s)
{
  FOC_IDREF = ref_s.id;
  FOC_IQREF = ref_s.iq;
}

#ifndef EVENT_LOG_DISABLE
void
foc_set_theta_compensation(int16_t compensation)
{
  m_theta_comp = compensation;
}
#endif

void
foc_theta_compensation(void)
{
  FOC_THECOMP = q15_ramp(&m_theta_comp_s,m_theta_comp);
}

void
foc_motor_brake(void)
{
  FOC_SWDUTY = FOC_ARR;
  FOC_CR1 = (1 << FCE) | (1 << PWMSS);
}

int16_t
foc_get_backemf(void)
{
  return (FOC_ESQU);
}

int16_t
foc_get_power(void)
{
  return (FOC_POW);
}

void
foc_disable(void)
{
  FOCEN = 0;
}

void
foc_software_control_enable(void)
{
  DRV_OUT = 0x00;
}

void
foc_software_control(enum foc_sw_control_e active_vector)
{
  switch(active_vector)
  {
    case rt_yb_xx_e:
    {
      DRV_OUT = 0x09;
      break;
    }
    case rb_yt_xx_e:
    {
      DRV_OUT = 0x06;
      break;
    }
    case rt_xx_bb_e:
    {
      DRV_OUT = 0x21;
      break;
    }
    case rb_xx_bt_e:
    {
      DRV_OUT = 0x12;
      break;
    }
    case xx_yt_bb_e:
    {
      DRV_OUT = 0x24;
      break;
    }
    case xx_yb_bt_e:
    {
      DRV_OUT = 0x18;
      break;
    }
    case xx_xx_xx_e:
    {
      DRV_OUT = 0x00;
      break;
    }
  }
}

void
foc_current_offset_update(int16_t current_offset)
{
  m_current_offset = current_offset;
}

void
foc_vq_ramp(void)
{
  int16_t vq_ramp = q15_ramp(&m_vq_ramp_s,QOUTMAX);
  FOC_QMAX = vq_ramp;
}

Credits

sathishkumar

8 projects • 18 followers

Successful Kickstarter, 2 patents, 10+ yrs R&D at IITM & HCL, EV, IoT, CAN, HVAC, product design & dev expert. Contact: 9952093701

I Built a Drone Where the PCB Frame IS the Circuit Board

Things used in this project

Hardware components

Software apps and online services

Hand tools and fabrication machines

Story

Why I Built a Drone Where the PCB Is the Airframe

The Design

Why coreless brushed motors instead of BLDCs?

The Design Challenges

1. Rigidity

2. Motor mount integrity

3. Weight distribution

4. Repairability

The Firmware

PID tuning took two weeks.

Specifications.

What I Learned

The integrated design genuinely simplifies the learning experience.

Take It Further

About CoreStack

Schematics

schematics

Code

code

Credits

sathishkumar

Comments

Embed the widget on your own site

I Built a Drone Where the PCB Frame IS the Circuit Board

I Built a Drone Where the PCB Frame IS the Circuit Board

Things used in this project

Hardware components

Software apps and online services

Hand tools and fabrication machines

Story

Why I Built a Drone Where the PCB Is the Airframe

The Design

Why coreless brushed motors instead of BLDCs?

The Design Challenges

1. Rigidity

2. Motor mount integrity

3. Weight distribution

4. Repairability

The Firmware

PID tuning took two weeks.

Specifications.

What I Learned

The integrated design genuinely simplifies the learning experience.

Take It Further

About CoreStack

Schematics

schematics

Code

code

Credits

sathishkumar

Comments

Related channels and tags