Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://github.com/Pyrograf below:

Website Navigation

• Overview
• Repositories 36
• Projects 0
• Packages 0
• Stars 105
• Overview
• Repositories 36
• Projects 0
• Packages 0
• Stars 105

Pyrograf (Piotr) · GitHub

I'm a backend / rendering / systems engineer with an embedded background — now focused on Rust backend, tooling, and systems development. I've designed ARM drivers, built cloud-connected firmware, created CLI and web tools, and automated real-world processes.

🚧

In early development

Techs: Rust, Tokio, TCP, Axum

Key features:

• Asynchronous server built with Tokio
• User account management using Axum
• Character ingame control using TCP
• ECS world structuring
• Database adapter for testability

Overview

Audio Spectrum remote controller with visualization

Techs: C, ESP-IDF, ESP32C3/S3, ESP-NOW WiFi packets, Remote control, DSP, FFT, RGB animation

Key features:

• Custom enclosure & matrix design
• ESP32S3 responsible for sampling, source selection, FFT, effect drawing, sending pixels colors
• ESP32C3 responsible for receiving pixels colors and controlling the matrix
• Real-time analog/digital audio sampling
• 2048 FFT float 32 signal processing
• 399-pixel WS2812B RGB LED matrix with custom animation effects
• LCD HMI for gain adjustment and effect selection
• sources: simulation, microphone, ADC wired

Overview

The continuation of device to visualize audio signal using real-time FFT on an ESP32 platform, driving a 399-pixel RGB LED matrix with animated effects with additional WiFipackets communication.

Gameplay 4 players: 3 hiders one seeker

Techs: Rust, Tokio, TCP, Serde, WGPU, Clap, thiserror

Key features:

• Asynchronous server built with Tokio
• WGPU-powered game client with real-time rendering
• CLI client alternative
• TCP communication using a JSON-based protocol
• Fully tested: unit and integration tests for client–server interaction

Overview

A multiplayer mini-game built from scratch in Rust, featuring a custom async game server and real-time graphical and CLI clients.

The game includes a lobby system, game state transitions, basic NPC behavior, and separate GUI roles depending on player type.

Project Scope

• Async server handling multiple client connections and managing game world state
• In-game chat system distinguishing between server and client messages
• Shared client logic with both CLI and WGPU-based GUI frontends
• Decoupled client connections from in-game character state
• Procedural world generation
• Basic NPC AI logic and movement
• Game state transitions: lobby → active game → summary
• Reward system and scoring logic for winning players

Techs: Rust, Axum, Serde, PDF, Clap, thiserror, palette, image

Key features:

• Uploads a source image
• Converts image into a printable diamond painting pattern
• Generates a DMC color palette and Bill of Materials
• (Coming soon) User accounts for project storage

Overview

A personal project inspired by my wife’s hobby.

Users can upload an image, select available DMC colors, and receive a ready-to-print pattern along with a Bill of Materials (BOM) listing all required diamond colors and quantities.

Project Scope

• REST API with endpoints for uploading images and tracking processing status
• Image analysis and dithering using DMC-compatible palettes
• Color quantization and matching using perceptual color distance
• Generates high-resolution PDF output for printing
• Optional UI planned for future use

Techs: Rust, Tokio, Clap, thiserror, GDB

Key features:

• CLI tool to upload binary files to external memory via J-Link and GDB
• Interacts with GDB using subprocess communication
• Chunks binary files to match memory page alignment
• Supports uploading files up to 4MiB

Overview

Command-line utility for uploading binary data to external NOR Flash on ARM-based devices using a J-Link debugging probe.

The upload process is mediated through a dedicated C-based upload API integrated into the firmware, which is called directly from the host via GDB during a debug session.

Responsibilities

• Studied and leveraged GDB’s ability to call target-resident C functions via `call` commands
• Wrote a set of C functions exposed in the target firmware to receive and write memory chunks
• Implemented GDB subprocess automation and communication from Rust
• Designed chunked, page-aligned transfer with status feedback
• Built a robust CLI around this mechanism for ease of use in production/test environments

Techs: C, C++, RTOS, Azure IoT HUB/DPS, TouchGFX, MQTT, HTTP, WebSocket, CRUD, TLS, STM32, ESP32

Key features:

• Responsive modern HMI,
• Logging to USB MSC & cloud
• Sterilization process selection

Overview

Firmware for an Internet-connected steam sterilizer. Responsible for end-to-end embedded system design, including control logic, connectivity, and modern responsible user interface.

Responsibilities

• Low-level memory driver:
  • Shared FMC bus: NOR + PSRAM with Read/Write management
  • Buffering and caching
  • External memory loading
  • Failsafe filesystem
  • Fragmentation monitoring
• WiFi connectivity:
  • Manage WiFi connection
  • Register device in Azure DPS using HTTPS
  • Send telemetry, chunking & receive notification from IoT Hub via MQTTS
  • Monitor new firmware & do OTA updates with backup
  • RED Directive & service tools
• Implement HMI project:
  • Custom TouchGFX components
  • Optimized rendering
  • External double framebuffer, external graphics data, FLASH write operations management
• Sterilization process control:
  • Implementation of PID and hysteresis
  • Heaters, pumps, valves control
  • Optimizing physical process for speed
• USB dual-role:
  • Host MSC to store process data, download firmware
  • Device CDC/ACM Modbus for production, testing, and service
• LED strips:
  • RGB animations

Techs: C, C++, CMake, Google Test, Linker script, STM32U5, Docker, VS Code, GDB server

Key features:

• Full DevContainer setup to replace legacy IDEs like STM32CubeIDE
• Streamlined VS Code tasks and launch configurations for building, flashing, and debugging
• Remote debugging via external GDB server
• Unit tests runnable both on host (Google Test) and target
• CMake-based build system compatible with CubeMX and TouchGFX code generation

Overview

Embedded projects are notoriously difficult to transfer between machines or contributors.

This setup isolates the entire development environment inside a Docker DevContainer, making the project reproducible and portable across systems.

It replaces heavier IDEs (e.g., Eclipse-based tools) with a modern, faster workflow using VS Code and Linux-based builds.

Due to USB device mapping limitations in containers, the GDB server is run outside the container — but integrates cleanly with the VS Code debugging workflow.

Responsibilities

• Indepth knowledge how ST-Link and J-Link works
• Built a CMake-based project structure compatible with STM32CubeMX and TouchGFX codegen
• Integrated remote debugging through ST-Link and J-Link
• Wrote custom VS Code tasks and launch configurations for building, flashing, and testing
• Automated host-side unit tests with Google Test
• Analyzed .elf and .map files to enable reliable external memory loading (NOR/PSRAM via FMC) using GDB
• Replaced legacy IDEs with reproducible, Docker-based environment

Techs: C, ESP-IDF, JavaScript, HTML/CSS, PNG, Dithering, Captive Portal

Key features:

• ESP32-C3-based image frame with E-Ink display
• Hosts its own WiFi Access Point and web server
• JavaScript-based captive portal with image preview and upload
• Uploads, crops, and dithers PNG files in-browser
• Renders processed image on the E-Ink display

Overview

A standalone E-Ink picture frame with built-in access point and web interface.

Designed to display user-uploaded images without needing external services.

The device serves a fully self-contained web app (HTML/CSS/JS), allowing users to crop, scale, dither, and upload images directly to the ESP32 for display.

Project Scope

• Developed embedded web server with JavaScript-based frontend
• Implemented captive portal for instant access after connecting
• Created image processing pipeline: crop → grayscale → dithering → upload
• Parsed and displayed PNG images on E-Ink display using custom rendering logic
• Designed minimal, UI-first UX for non-technical users

Techs: Python, PyGame, Tiled, TMX/TSX, Sprite animation, ECS-style design

Key features:

• Multilayer 2D RPG engine with animated pixel-art world
• Game object system using delegation over inheritance
• Custom property system for entity input, update, and render logic
• Support for TMX/TSX formats from Tiled map editor
• Collision system with object interaction and debug renderer
• Sprite + animation system with abstracted timing

Overview

A 2D RPG engine inspired by classic top-down games like *Zelda*.

Built in Python with Pygame, it features a layered tile-based world, animated entities, and a component-driven object system.

While the project remains in development, it has laid a strong foundation for a full pixel-art RPG engine.

Project Scope

• Implemented an extensible object model using Python properties and composition
• Integrated TMX/TSX map parsing for Tiled-based level design
• Built a collision system with layered obstacle detection and visual debugging
• Developed pixel-art rendering pipeline with global scaling logic
• Introduced modular animations and entity state management
• Designed and integrated custom tilesets and graphics (WIP)

30+ ⭐ on GitHub · Featured on Instructables with 36k+ views and 190+ likes See project on Instructables ↗

Techs: C, ESP-IDF, ESP32, DSP, FFT, RGB animation

Key features:

• Custom enclosure & matrix design
• Real-time analog/digital audio sampling
• FFT signal processing on microcontroller
• 399-pixel WS2812B RGB LED matrix with custom animation effects
• Planned support for raw WiFi 802.11 audio streaming (in development)

Overview

This project visualizes audio input using real-time FFT on an ESP32 platform, driving a 399-pixel RGB LED matrix with animated effects.

It’s designed for living room aesthetics, performance, and modular expandability

Techs: C++, ESP32, Bluetooth

Key features:

• Custom-built keyboard with programmable macro keys
• Sends hotkey combinations via Bluetooth HID profile
• Configurable actions for productivity

Overview

A compact, Bluetooth-enabled macro keyboard built using an ESP32 board.

Designed to trigger custom key sequences for automation, shortcuts, and productivity tasks.

Project Scope

• Implemented HID over Bluetooth communication
• Programmed hotkey mapping logic using C++

Representative image. Similar view was recorded by our vessel inside the flooded shaft. Source: gazetawroclawska.

Techs: C++, Arduino, CAN, 3D design, 3D print, Camera, RC, LED lighting

Key features:

• Custom remote-controlled vessel designed for underground exploration
• Equipped with real-time video streaming and lighting
• Operated via CAN from 20 meters below surface level
• Designed for harsh, low-visibility flooded environments

Overview

A commissioned project to explore a flooded mineshaft located ~20 meters underground in Lubań, Poland.

The vessel was designed to descend into the shaft via 10cm drill and transmit video footage for archaeological and safety assessment.

Project Scope

• Designed custom electronics and control system for vessel navigation
• Integrated video capture with LED lighting for visibility
• Built a watertight enclosure and propulsion system (partially successful)
• Supply power and control signals from the surface
• Contributed to one of the first serious technical attempts to explore the shaft — later fully successful in follow-up expeditions

Techs: Python, OpenCV, Custom GUI, 3D Design, 3D Printing

Key features:

• Real-time image processing for stain area detection
• Automated measurement of ink wear on printing drums
• Physical device designed and 3D-printed for stable imaging conditions

Overview

This project was commissioned by a printing company to simplify and speed up the process of evaluating wear on printing cylinders.

Previously, this required expensive equipment and manual measurements. The new solution involved a custom device with fixed camera distance and lighting conditions, paired with OpenCV-based analysis.

Responsibilities

• Designed and 3D-printed a custom enclosure to maintain consistent camera positioning
• Implemented a Python + OpenCV script to calculate ink stain surface area
• Tuned thresholding, perspective correction, and region isolation for robustness
• Delivered an affordable and replicable device that reduced measurement time and cost

Techs: Java, LWJGL (OpenGL), Custom GUI, 3D rendering, Shaders

Key features:

• Custom game loop and rendering pipeline (OpenGL + GLSL shaders)
• Basic 3D graphics algorithms and scene graph structure
• Mipmapping, geomipmapping, fresnel effect, bloom, skybox
• Entity-Component System for object behavior and modularity
• Audio system for positional 3D sound playback
• Input system with mouse and keyboard support
• Integrated level editor with in-engine GUI

Overview

A custom game engine and level editor built in Java using OpenGL and LWJGL. Developed over 2 years as a personal challenge to understand real-time rendering, ECS-like architecture, and cross-cutting systems like audio, terrain generation, and GUI handling.

The project helped me explore full-engine architecture and taught me key lessons about code structure, coupling, and the value of testing and separation of concerns.

Heavily inspired by ThinMatrix YouTube series.

Project Scope

• Custom OpenGL rendering pipeline and shader management
• Entity system for managing in-game objects
• Terrain rendering and water effects
• GUI and event system for in-engine editor tools
• Scene serialization and reloading
• Basic audio and camera logic

Competition video – Wrocław University of Science and Technology

📺 National TV feature – TVP Info

Techs: C++, Arduino, Inverse kinematics, Bluetooth

Key features:

• Custom mechanical design
• 3 degrees of freedom per leg
• Inverse kinematics for smooth body and leg motion
• Bluetooth-controlled via Android app
• Basic autonomous behavior using proximity sensors

Overview

A six-legged walking robot designed and built in high school — combining mechanical engineering, embedded software, and robotics. The project earned awards at robotics tournaments and received national media coverage.

Project Scope

• Designed mechanical structure for body and 6 legs
• Wrote control algorithms for inverse kinematics and walking gait
• Implemented Bluetooth communication protocol
• Implemented basic autonomous behavior using sensor feedback (feet and head proximity)

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4