Firmware output
Generated OpenWrt images, rootfs archives, checksums, build metadata, and board profile artifacts.
Embedded Linux Portfolio Project
Custom OpenWrt Platform for a Custom Board
Complete OpenWrt-based firmware platform with bootloader support, generated firmware images, custom kernel drivers, native services, network configuration, and a SkyLog300 browser UI for board operation.
Overview
A full embedded Linux product stack, from boot to web interface.
This project extended OpenWrt into a firmware platform tailored to Zynq-based hardware. The system produces board-specific image artifacts, boots over serial, brings up Ethernet interfaces, loads custom packet processing drivers, and exposes status, logging, and configuration through a branded SkyLog300 web interface.
Custom drivers
Network TAP, packet filter, MDIO, and traffic controller drivers probe successfully during target boot.
SkyLog300 dashboard
Custom LuCI pages expose system status, memory, routing, firewall, logging, and SkyLogger workflows.
My Work
What I implemented inside the OpenWrt build.
Custom board target and image flow
Connected the board to the OpenWrt build system so output artifacts include board images, rootfs packages, build information, profiles, and checksums.
U-Boot and hardware initialization
Added a U-Boot defconfig, bootloader device tree, SD boot commands, flash support, and hardware initialization for clocks, memory, pins, and peripherals.
Kernel device tree and hardware description
Defined board memory, Ethernet, serial, SD card, and programmable-logic blocks required by the OpenWrt Linux image.
Custom Linux drivers
Integrated custom Network TAP, packet filter, MDIO, and traffic controller drivers and verified successful probe messages on boot.
C applications and board services
Packaged target-side services for device logic, diagnostics, logging, network control, and board-specific operations.
Web UI application
Customized the LuCI experience into a SkyLog300 interface with status, network, and SkyLogger pages for browser-based operation.
Bring-Up Evidence
From firmware artifacts to a running OpenWrt target.
Image generation
The build produces board-specific OpenWrt images, rootfs archives, metadata, profiles, and checksums ready for deployment.
Kernel boot
Serial logs confirm the Linux image starts, initializes subsystems, mounts storage, and reaches the OpenWrt runtime.
Network access
The target exposes interfaces through OpenWrt networking, including a configured bridge address for browser access.
Firmware image -> board image artifacts -> OpenWrt rootfs -> package metadata -> custom network drivers -> SkyLog300 web interface -> SkyLogger capture workflow
Technical Scope
Skills demonstrated by the project.
OpenWrt build integration
Board profiles, package recipes, generated image artifacts, rootfs contents, and target-specific firmware output.
Bootloader engineering
U-Boot SPL, board defconfig, boot scripts, FIT image booting, QSPI/SD boot paths, and hardware initialization.
Kernel and drivers
Device tree binding, custom network driver packaging, module integration, probe validation, and runtime diagnostics.
Application layer
C utilities, system services, LuCI customization, board controls, logs, status views, and capture workflows.
Project Gallery
Firmware, boot, network, driver, and UI evidence.
Zynq-based embedded hardware targeted by the custom OpenWrt firmware build.
LuCI-based dashboard showing model, architecture, firmware version, uptime, and memory status.
Build output includes packages, profiles, checksums, rootfs, and board-specific OpenWrt images.
Target console showing Linux subsystem initialization and OpenWrt boot progress.
OpenWrt shell output showing bridge and Ethernet interfaces, packet counters, and configured access address.
Kernel log output confirming Network TAP, packet filter, MDIO, and traffic controller drivers loaded successfully.
Browser UI for packet log capture, file listing, and log management inside the custom OpenWrt application.
Things I Learned
Linux-side lessons from bringing OpenWrt onto custom hardware.
This project strengthened my understanding of how an embedded Linux system moves from bootloader handoff to kernel initialization, driver probing, network availability, and user-space services.
Kernel boot flow
I learned how to read serial boot logs carefully, identify where Linux is in the init sequence, and separate bootloader, kernel, driver, and user-space issues.
Device tree debugging
I improved how I describe board hardware to Linux, especially memory, Ethernet, serial, SD card, and programmable-logic peripherals used by custom drivers.
Driver integration
I learned how custom kernel modules fit into an OpenWrt image, how probe messages confirm hardware binding, and how logs reveal missing resources or mapping issues.
OpenWrt networking
I gained practical experience with Linux interfaces, bridge configuration, IP assignment, packet counters, Ethernet status, and browser access to the target device.
Root filesystem packaging
I learned how OpenWrt packages kernel modules, C utilities, scripts, and UI files into the root filesystem so the deployed image contains the complete product stack.
Target-side diagnostics
I became faster at using console output, module probe logs, interface status, and generated firmware artifacts to prove whether each Linux layer is working correctly.
Outcome
A production-style firmware platform for custom hardware.
The final result is a board-specific OpenWrt firmware build that boots reliably, produces deployable firmware artifacts, loads custom network drivers, configures Ethernet access, and gives users a SkyLog300 browser interface for monitoring and packet logging.
Discuss a Project