ATL-2026 Rev 2.0
Request CV

Atilla Basut

U1 ATL-2026 / Rev 2.0

Embedded systems. Third-year computer engineering student at Erciyes University.

I write embedded software for STM32 microcontrollers: peripheral drivers (GPIO, ADC with DMA, UART) tested on the host and in CI, and rocket software with Kalman filter sensor fusion on FreeRTOS. Now writing SPI and I2C drivers. I also work with Linux.

Looking for Embedded software internship

Experience: software unit coordinator, ARFESA rocket team.

Latest public work: stm32f407-custom-drivers, a hand-written GPIO, ADC + DMA and UART driver layer for the STM32F4DISCOVERY.

atillabasut0@gmail.com https://github.com/atillab1 https://www.linkedin.com/in/atilla-basut-8b0258296

Request CV Email GitHub LinkedIn
U1: ATL-2026 in an LQFP-64 package, top view Four pins are links. Pin 4 is GitHub, pin 13 is LinkedIn, pin 45 is email and pin 36 is the CV. GITHUB PIN 4 LINKEDIN PIN 13 EMAIL PIN 45 CV PIN 36
U1, LQFP-64, top view. Pins 4, 13, 36 and 45 are links.

Experience

RKT1 Launch rail

Software unit coordinator

to

ARFESA rocket team, Erciyes University

Work
Wrote software for the team's rocket in the A2 medium-altitude category on STM32, with Kalman filter sensor fusion and FreeRTOS.
  • STM32
  • Kalman filter
  • FreeRTOS
Code
Team project. The code is not public.

Skills

U2 to U7 Populated parts

What is on the board, and where each part can be checked. Work that is not public yet is marked in progress or planned.

  • STM32F407

    U2

    Target microcontroller for the peripheral drivers.

    • Arm Cortex-M4
    • STM32F4DISCOVERY

    Evidence stm32f407-custom-drivers and the test firmware in embedded-ai-workspace, both on the STM32F4DISCOVERY (STM32F407VGT6), and the STM32 repository: 19 practice projects for GPIO, external interrupts, ADC, timers, SysTick, ADC with DMA and UART.

  • Peripheral drivers

    U3

    Driver development for GPIO, SPI, I2C and UART.

    GPIO
    stm32f407-custom-drivers: io driver, button and LED state with non-blocking software debounce.
    UART
    stm32f407-custom-drivers: uart driver, interrupt-driven RX and TX on two circular buffers, printf output.
    SPI
    in progress SPI driver for stm32f407-custom-drivers, being written now.
    I2C
    in progress I2C driver for stm32f407-custom-drivers, being written now.

  • DMA

    U4

    DMA-based data transfer.

    Evidence stm32f407-custom-drivers: adc driver, ADC1 + DMA five-channel scan with sample averaging.

  • Sensor fusion

    U5

    Sensor fusion with a Kalman filter.

    Evidence ARFESA rocket team (Sep 2025 to Jun 2026): Kalman filter sensor fusion in the rocket software for the A2 medium-altitude category, on STM32. Team project, not public.

  • FreeRTOS

    U6

    Real-time operating system on the microcontroller.

    Evidence ARFESA rocket team (Sep 2025 to Jun 2026): FreeRTOS in the rocket software for the A2 medium-altitude category, on STM32. Team project, not public.

    Next planned Run the drivers from stm32f407-custom-drivers under FreeRTOS.

  • Linux

    U7

    Linux build and test tooling for firmware.

    Evidence GitHub Actions jobs on Ubuntu runners in all three projects: firmware builds with the Arm GNU toolchain (gcc-arm-none-eabi, make), host unit tests and cppcheck. The hardware-in-the-loop runner in embedded-ai-workspace documents its Ubuntu setup (stlink-tools, dialout group, /dev/ttyUSB0).

Projects

MOD1 to MOD3 Plug-in modules

Three public repositories. Each module states what it is, the hardware and stack, what it does, how it is tested and what went wrong on the way. Everything here comes from the repositories: code, READMEs, commit history and CI runs.

stm32f407-custom-drivers

MOD1C / created

A hand-written driver library for the STM32F4DISCOVERY board (STM32F407VGT6), a main application that uses it, and nine timer, PWM and UART example projects.

Hardware and stack
STM32F4DISCOVERY, STM32F407VGT6 (Arm Cortex-M4F), on-board ST-LINK. C with the STM32Cube HAL, built in STM32CubeIDE and from the command line with the Arm GNU toolchain.
  • C
  • STM32Cube HAL
  • STM32CubeIDE
  • cppcheck
  • GitHub Actions
What it does
  • io: button and LED state in structs, non-blocking software debounce.
  • adc: ADC1 + DMA five-channel scan (PA2, PA3, temperature sensor, VREFINT, VBAT), sample averaging, VDDA computed from VREFINT.
  • circular_buffer: ISR-safe single-producer, single-consumer byte queue.
  • uart: interrupt-driven RX and TX on two circular buffers, printf-style output.
  • Nine example projects: timer external clock, trigger and slave modes, input capture, output compare, PWM and UART printf.
  • in progress SPI and I2C drivers.
How it is tested
Host-side unit tests for the hardware-independent code (make -C tests). CI on every push and pull request: unit tests, cppcheck static analysis of drivers/, and Debug and Release firmware builds of all ten projects.
Configuration
Configured values from the repository README. These are settings, not measurements.
ParameterSettingType
System clock, main application168 MHz (HSI 16 MHz, PLL)configured
USART3, PB10 TX / PB11 RX115200 baud, 8N1configured
Button debounce100 msconfigured
ADC averaging64 samplesconfigured
Test results
Four host unit tests for the circular buffer: empty at start, a zero byte is valid data, 511-byte capacity with FIFO order, and wrap-around. The latest CI run on main passed on : unit tests, cppcheck, and Debug and Release builds of all ten projects.
Problems found and fixed
  • TX race: TXE is set whenever DR is empty, so an interrupt raised for a received byte also ran the TX code while UARTx_Write() was using the same buffer. The ISR now also checks that the TXE interrupt is enabled.
  • UART overrun: the HAL handler switches the RXNE interrupt off on an overrun, so reception stopped. HAL_UART_ErrorCallback() now clears the flag and switches it back on.
  • Shared state between interrupts and the main loop: the circular buffer indices and the ADC DMA flag are now volatile, and the buffer reads each index once.
  • Input capture: inside the callback HAL sets Channel to the active-channel value, not TIM_CHANNEL_1, so the callback guard never matched. Fixed in the input capture and output compare examples.
  • Reference manual check: RM0090 limits the ETR input to a quarter of the timer clock, so the 8 MHz MCO1 signal in example 002 can lose pulses at a 16 MHz timer clock. The README documents the DIV4 prescaler as the fix.
Repository
https://github.com/atillab1/stm32f407-custom-drivers

embedded-mcp

MOD2Python / created

A Model Context Protocol (MCP) server that lets an AI assistant such as Claude Desktop or Claude Code read, command and debug a microcontroller over a serial port.

Hardware and stack
Any board with a UART or USB-serial link, for example an STM32. Python 3.10+, pyserial, MCP over stdio. Flashing through st-flash, probe-rs or OpenOCD.
  • Python
  • pyserial
  • MCP
  • CMSIS-SVD
  • pytest
What it does
  • Lists serial ports, reads what the firmware prints, sends a command line to the UART shell and returns the reply.
  • Decodes a raw register value into named bit fields, also by register name from a vendor CMSIS-SVD file.
  • Flashes firmware through an installed flasher. Dry run by default: it returns the exact command first.
  • Opens the port only for the duration of a call, so an IDE serial monitor can share it.
How it is tested
Unit tests with pytest and a GitHub Actions CI workflow. The register decoders run offline in examples/demo.py, no hardware needed.
Test results
12 pytest unit tests: register decoding, lookup by name from an SVD file, flasher command lines and the dry run. CI runs them on Python 3.10, 3.11 and 3.12; the latest run on main passed on .
Safety limits
A read window is capped at 30 s, so a call can never hang the client. Flashing is a dry run unless dry_run=False is passed. The port is opened per call and closed again.
Repository
https://github.com/atillab1/embedded-mcp

embedded-ai-workspace

MOD3TypeScript / created

AI tooling for STM32 firmware work, built around one question: did a firmware change break the board? Four parts that work alone or together.

Hardware and stack
STM32F4DISCOVERY (STM32F407VGT6), USART2 on PA2/PA3 through the ST-LINK virtual COM port or a USB-UART bridge. TypeScript on Node.js, local MiniLM embeddings with LanceDB, Arm GCC and st-flash, a self-hosted GitHub Actions runner.
  • TypeScript
  • MCP
  • LanceDB
  • st-flash
  • JUnit XML
What it does
  • MISRA-C:2012 review skill (Amendment 4) with ISR and DMA pitfalls.
  • Datasheet MCP: vector search over the RM0090 reference manual, structured register lookup and a lint for register writes.
  • Serial MCP: lists serial ports, sends UART commands, reads the replies.
  • Hardware-in-the-loop runner: flashes the firmware, drives UART test plans and writes JUnit XML. Uses a small command-driven STM32F4 test firmware.
How it is tested
GitHub Actions workflow with a build, smoke tests and a hardware-in-the-loop job on a self-hosted runner with the board attached; results are reported as JUnit XML.
Measured results
  • Datasheet MCP, 10 realistic queries in the automated dogfood script: 8 passed. The misses: an I2C clock-speed question returned an unrelated RCC section, and the bit fields of USART_BRR did not parse.
  • The 1757-page RM0090 reference manual is extracted in 3.6 s; about 280 registers across 23 peripherals are parsed; the full index builds in 85 s on the CPU and takes about 120 MB with the local model. No API cost.
Problems found and fixed
  • Table-of-contents and index pages polluted the search results. Three rounds of filters (dot-leader ratio, density of upper-case register names, page-number suffixes) removed most of them.
  • Remote embeddings needed a paid API key. Switching to the local all-MiniLM-L6-v2 model made the tool free to run.
  • The stlink v1.8.0 Windows build exits with STATUS_DLL_NOT_FOUND because its libusb DLL is missing; the v1.7.0 x86_64-w64-mingw32 build works, and the README says so.
Repository
https://github.com/atillab1/embedded-ai-workspace

GitHub activity

DS1 to DS3 Live readout

Public numbers read from the GitHub API when the page loads. The language bars count repositories by main language; they are data, not a skill rating.

Live numbers load from the GitHub API when JavaScript is on.

See github.com/atillab1

Timeline

Y1 Revision history

  1. Started at Erciyes University, Computer Engineering, with the preparatory year.

  2. Now

    Third-year computer engineering student at Erciyes University.

Absolute maximum ratings

F1 Do not exceed

Stresses above these ratings may cause permanent damage to the device. Exposure to maximum rating conditions for extended periods may affect device reliability.

F1. Absolute maximum ratings
SymbolParameterMaxUnit
NCOFFEECoffee intake4cups/day
tDEBUGContinuous debugging without a break6h
NCLAIM"It works on my board" claims accepted without a logic analyzer capture0-
NSKIPDatasheet pages skipped before wiring a sensor0pages

Contact

J1 4-pin header

Open to embedded software internships.

atillabasut0@gmail.com
Request CV Write an email

Operating limits for this part are in F1, absolute maximum ratings.

Contact pins on U1, top view Four pins are links. Pin 4 is GitHub, pin 13 is LinkedIn, pin 45 is email and pin 36 is the CV. GITHUB PIN 4 LINKEDIN PIN 13 EMAIL PIN 45 CV PIN 36
Contact pins: 4 GitHub, 13 LinkedIn, 36 CV, 45 email.