Week 3 - Embedded Programming

Introduction

This week’s topic is embedded programming. As part of the assignment, I had two main tasks: (A) build a microcontroller, and (B) write and test programs that allow the microcontroller to interact and communicate. On the other hand, the group assignment has been to demonstrate and compare the toolchains and development workflows for available embedded architectures.

Group Assignment

For the group assignment, we met as a group on Thursday afternoon. We have uploaded our documentation here .

Individual Assignment

A - Microcontroller Assembly

To build my microcontroller, I attended the evening recitation (7–8:30 pm). The room was packed. Anthony kicked things off with a great demo on soldering, showing both flux and solder paste techniques. It all looked straightforward - until I tried myself.

After a great intro, I decided to assemble the QPad21 (ATSAMD21) , a custom ATSAMD21E board designed by Quentin. The components required included: USB micro-B connector, 3.3V regulator + capacitors, 10-pin SWD header, Resistors, LED screen. For assembly I used a soldering iron, flux, and tweezers – ended up not using hot air and solder paste.

It took me no less than an hour and half to assemble the board. The biggest challenge I had was by far removing solder bridges, which demanded extreme patience and precision.

In the end, after many reiterations (it was already 10 pm!) I tested the board with Quentin (huge thanks to him - super helpful!) and everything worked fine. Here’s the finished product:

B - Writing and Testing Programs

The next day, with the board assembled, I followed the documentation on Quentin’s QPad21 GitLab page. I decided to go with the Arduino IDE, and hence installed it and downloaded the necessary libraries.

Program 1 – make it blink

As a first test, I uploaded the sample “blink” code to check whether the board was functioning. Success! The LED started blinking. As Neil predicted, I was unexpectedly excited by something so simple.

Program 2 – make it write

Next, I tested the LED screen with the sample “Hello World” program. Again, seeing those words light up on my own board was majestic.

Program 3 – make it read (my finger pressure)

I then tested the code for reading pad pressure. When I pressed the pads and saw the red light respond, I was thrilled.

Program 4 – make it play

Finally, I wanted to push further by writing my own program. I decided to attempt a simple Flappy-Bird-like game. Why this choice? A few years ago, a friend applying to Bending Spoons was asked to recreate a Flappy Bird game during his interview – it was a take-home assignment and he had one week to hand it in. Inspired by that challenge, I gave myself around one hour to see how far I could get. My friend ChatGPT definitely made the heavy lifting of writing the structure of the code. Hence, the hardest part was tweaking parameters so that the game was actually playable. Gravity, sensitivity of the pads, and timing all needed adjustment. After ~10 iterations, I had a version that worked. Then came the fun part: playing. I spent around another hour testing it. After all this time, I got to a maximum score of 4 - and called it a day.

Full Source Code (Flappy-Bird-like)

#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
#include <Adafruit_FreeTouch.h>

// ---------- Display ----------
#define SCREEN_WIDTH 128
#define SCREEN_HEIGHT 64
#define SCREEN_ADDRESS 0x3C
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, -1);

// ---------- Input (FreeTouch) ----------
const uint8_t TOUCH_PIN = 2;               // touch pad you want to use
Adafruit_FreeTouch touch(TOUCH_PIN, OVERSAMPLE_1, RESISTOR_100K, FREQ_MODE_NONE);
const int TOUCH_THRESHOLD = 500;           // tune if needed
bool touchNow = false, touchPrev = false;  // edge detection

// ---------- Game constants ----------
const int   PLAYER_X = 24;    // fixed X for player
const float GRAVITY = 0.28;   // pixels/frame^2
const float FLAP     = -3.6;  // upward velocity on flap
const int   PIPE_W   = 16;
const int   GAP_H    = 26;    // gap height (adjust for difficulty)
const int   PIPE_SPACING = 54;// distance between pipes
const int   SCROLL_SPEED = 2; // pixels per frame

// ---------- Game state ----------
float playerY, playerV;
int   score, bestScore = 0;
bool  alive = true;
bool  started = false;

struct Pipe {
  int x;       // left edge
  int gapY;    // top of gap
};
const int N_PIPES = 3;
Pipe pipes[N_PIPES];

// ---------- Utility ----------
int randBetween(int a, int b) { // inclusive a..b
  return a + (rand() % (b - a + 1));
}

void spawnPipe(int i, int startX) {
  pipes[i].x = startX;
  // keep gaps fully on screen
  int minTop = 6;
  int maxTop = SCREEN_HEIGHT - GAP_H - 6;
  pipes[i].gapY = randBetween(minTop, maxTop);
}

void resetGame() {
  playerY = SCREEN_HEIGHT / 2;
  playerV = 0;
  score   = 0;
  alive   = true;
  started = false;

  // seed randomness from running micros
  srand((unsigned) micros());

  // place a train of pipes
  int x0 = SCREEN_WIDTH + 20;
  for (int i = 0; i < N_PIPES; i++) {
    spawnPipe(i, x0 + i * PIPE_SPACING);
  }
}

// Simple AABB collision with gap
bool collidesWithPipe() {
  for (int i = 0; i < N_PIPES; i++) {
    // player is a 4px circle; approximate with box 4x4
    int px0 = pipes[i].x;
    int px1 = pipes[i].x + PIPE_W;
    int pyGapTop = pipes[i].gapY;
    int pyGapBot = pipes[i].gapY + GAP_H;

    // is player inside pipe's X-range?
    if (PLAYER_X + 2 >= px0 && PLAYER_X - 2 <= px1) {
      // if player center Y is outside the gap (consider radius 2)
      if (playerY - 2 < pyGapTop || playerY + 2 > pyGapBot) {
        return true;
      }
    }
  }
  // floor/ceiling
  if (playerY < 2 || playerY > SCREEN_HEIGHT - 3) return true;
  return false;
}

void drawPipe(const Pipe& p) {
  // top rectangle
  display.fillRect(p.x, 0, PIPE_W, p.gapY, SSD1306_WHITE);
  // bottom rectangle
  int bottomH = SCREEN_HEIGHT - (p.gapY + GAP_H);
  display.fillRect(p.x, p.gapY + GAP_H, PIPE_W, bottomH, SSD1306_WHITE);
}

void drawScene() {
  display.clearDisplay();

  // ground line (just a thin baseline for style)
  display.drawLine(0, SCREEN_HEIGHT - 1, SCREEN_WIDTH, SCREEN_HEIGHT - 1, SSD1306_WHITE);

  // pipes
  for (int i = 0; i < N_PIPES; i++) drawPipe(pipes[i]);

  // player (a small filled circle)
  display.fillCircle(PLAYER_X, (int)playerY, 2, SSD1306_WHITE);

  // score
  display.setTextSize(1);
  display.setTextColor(SSD1306_WHITE);
  display.setCursor(0, 0);
  display.print("Score: ");
  display.print(score);
  display.setCursor(80, 0);
  display.print("Best: ");
  display.print(bestScore);

  if (!started) {
    display.setCursor(18, 28);
    display.print("Touch to start");
  }
  if (!alive) {
    display.setCursor(34, 40);
    display.print("Game Over");
    display.setCursor(20, 52);
    display.print("Touch to retry");
  }

  display.display();
}

void setup() {
  // Serial for debug (optional)
  Serial.begin(9600);

  // OLED
  if (!display.begin(SSD1306_SWITCHCAPVCC, SCREEN_ADDRESS)) {

Final Project

Please note that Embedded Programming is also a key part of my final project, where I use a PCB to drive a combat robot. Everything is documented in the Final Project page.

Back to main page.

WEEK 3