Working across hardware, microcontrollers and bare-metal firmware — STM32 peripheral drivers written straight from datasheet register maps, communication protocols debugged on the wire, and RFID reader firmware in development.
Most of my firmware is written at the register level. I read the datasheet, map the peripheral, and bring it up without HAL or vendor abstractions — because that's where you actually understand what the silicon is doing.
My core is STM32 on ARM Cortex-M3/M4: peripheral drivers for GPIO, SPI, I²C and UART built from register maps, inter-MCU links debugged from logic-analyzer captures, and small real-time systems like an RTC-driven clock display. Alongside that I spent six months on drone firmware and hardware at ENORD — tuning ArduPilot, calibrating IMU, compass and GPS, and doing the soldering and bring-up that turns a bare frame into a flying system.
Now I'm extending that hardware-up approach toward RFID reader firmware, and eventually custom reader hardware and PCB design — moving from writing drivers to designing the boards they run on. Those pieces are in development, and I'm building them the way I learned everything else: from the signal up.
$ approach = read_datasheet → map_register → verify_on_scope
What I actually work with — grouped by domain. The RFID track is where I'm heading next, kept separate and marked honestly.
Bare-metal STM32 on ARM Cortex-M — no HAL, straight from register maps.
Moving bytes between devices — and debugging them on the wire.
From soldering iron to signal integrity.
The tools around the firmware.
Applying the same register-level approach to RFID readers.
The stack I work across — from a physical signal, up through the microcontroller and firmware, out to the host application. The RFID module is the layer I'm building toward now.
ARM Cortex-M3/M4
The core — an STM32 on ARM Cortex-M3/M4 — where every driver and control loop runs.
A hardware-up path: from electronics foundations to bare-metal firmware, drone work, and now RFID and custom hardware.
Diploma · Jamia Millia Islamia · 2021–2024
Electronic devices and circuits, microprocessors and microcontrollers, embedded systems — the groundwork for working close to the hardware.
Began writing STM32 peripheral drivers straight from register maps — GPIO, SPI, I²C, UART — with no HAL. Just the reference manual and the datasheet.
Built inter-MCU links and traced clock-polarity, ACK/NACK and baud-mismatch issues from logic-analyzer captures until they were solid.
ENORD · CIE, Jamia Millia Islamia · Jan–Jul 2026
Configured and tuned ArduPilot, calibrated IMU, compass and GPS, integrated flight controllers, ESCs, motors and GPS, and handled soldering, bring-up and troubleshooting.
Applying the same register-level approach to RFID reader modules — MCU init, UART links, and command/response protocol handling.
Learning to design the boards my firmware runs on: schematic capture, component selection, routing, power distribution and signal integrity.
Firmware and hardware projects, each written from the register level up. Open any card for the problem, the approach, and how it turned out.
Custom SPI, I²C and UART drivers built from datasheet register maps — no HAL, no vendor libraries — moving data between two microcontrollers.
A DS1307 real-time clock driven over a hand-written I²C driver, with live time and date rendered on an LCD.
A matrix-keypad driver using GPIO row/column scanning with software debouncing, mapping presses to characters on an LCD.
Jan – Jul 2026 · New Delhi
Six months configuring and tuning ArduPilot firmware and assembling drone hardware at ENORD (CIE, Jamia Millia Islamia).
The direction I'm building toward — RFID reader firmware and custom hardware. These are genuinely in progress or under study, kept separate so nothing here is overstated.
Extending my bare-metal driver work toward firmware for an STM32-based RFID reader — MCU init, UART links to the reader module, GPIO control and interrupt handling.
Studying reader modules such as the Impinj E310 and Silion SIM3500 — their command/response frames, protocol parsing and reader state.
A design exploration of a full reader stack — antenna → RFID IC/module → STM32 → USB/Ethernet → host — rather than relying entirely on off-the-shelf electronics.
Learning to design the boards my firmware runs on — schematic capture, component selection, routing, power distribution, grounding and signal integrity.
I don't reach for an abstraction until I understand what it's hiding. The habit started with bare-metal firmware — read the reference manual, write to the register, watch it on a logic analyzer — and it's how I approach every layer since. Learn the thing from the bottom, then build up. Slower at first, far more durable after.
Coursework behind the practice — each link goes straight to the issuer's verification page.
Every driver written from the register map, the protocol experiments, and the RFID work as it comes together. Browse the source and follow along.
Open to embedded, firmware and hardware roles — and to interesting problems close to the metal. The fastest way to reach me is email.