You are browsing as a guest. Sign up (or log in) to start making projects!

Ibrahim281

@Ibrahim281

Joined June 21st, 2026

  • 4Devlogs
  • 4Projects
  • 0Ships
  • 0Votes
Open comments for this post

1h 27m 24s logged

Devlog #1: From Macropad Inspiration to Standalone Hardware

💡 The Spark of Inspiration

Initially, I wanted to build a simple 4-button macropad with a volume knob using an Arduino Uno. But as I started thinking about what would actually be useful day-to-day, I pivoted the idea into a Physical Money Tracker—a desktop device that lets me quickly log financial transactions with the twist of a dial and the press of a single button.

I decided to challenge myself: Ax the PC and PyCharm entirely. I wanted a 100% standalone hardware device that works on raw micro-controller logic and remembers my balance even if I unplug it.


🛠️ Designing the Architecture

Instead of hiding data on a computer screen, I dug out a 5461AS 4-digit 7-segment display to show my data directly on my desk.

The control flow is clean and tactile:

  • The Dial (B10K Potentiometer): Acts as an amount selector. Turning it scrolls through transaction amounts (-20, -10, 0, +10, +20).
  • The Confirmation (Push Button): Acts as the “Enter” key to commit the transaction.
  • The Feedback (Active Buzzer): Gives a tiny “click” sound when shifting between numbers, and a satisfying double-beep when a transaction successfully saves.

Because I wanted it to be standalone, I utilized the Arduino’s EEPROM memory so my balance data survives power loss.


🎛️ Mapping the Complex Matrix

The hardest part of the prototype was figuring out the routing for the 5461AS display. Without a dedicated driver chip, it requires 12 independent pin connections. I mapped out a custom configuration to keep the standard digital pins (D2 and D3) free for my tactile inputs:

  • Digits (Left to Right): Pins 12, 13, A1, A2 -> Connected to D12, D13, A1, A2
  • Segments (A through G + DP): Connected to D4, D5, D6, D7, D8, D9, D10, D11
  • Inputs: Potentiometer on A0, Button on D2, Buzzer on D3

💻 Prototype Core Firmware Logic

I integrated the SevSeg library to handle the rapid background multiplexing needed to keep the display lit without flickering. Here is the core operational loop of the system:

void loop() {
  int potValue = analogRead(POT_PIN);
  int potZone = potValue / 205; 
  
  switch(potZone) {
    case 0: selectedAction = -20; break;
    case 1: selectedAction = -10; break;
    case 2: selectedAction = 0;   break;
    case 3: selectedAction = 10;  break;
    case 4: selectedAction = 20;  break;
  }

  // Handle Button Press and Save to EEPROM
  int buttonState = digitalRead(BUTTON_PIN);
  if (buttonState == LOW && lastButtonState == HIGH) {
    currentBalance += selectedAction;
    saveBalance(currentBalance); // EEPROM storage
    
    sevSeg.blank();
    tone(BUZZER_PIN, 2700); delay(80); noTone(BUZZER_PIN);     
    delay(40);
    tone(BUZZER_PIN, 2700); delay(80); noTone(BUZZER_PIN);
  }
  lastButtonState = buttonState;

  if (buttonState == HIGH) {
     sevSeg.setNumber(selectedAction); 
  } else {
     sevSeg.setNumber(currentBalance);
  }
  sevSeg.refreshDisplay(); 
}
0
0
0
Open comments for this post

21m 24s logged

🌌 Mission Log: NASA Stardance Space Clock

Engineering Log 03: Assembling the First Physical Prototype
Date: June 2026 | Crew: Mohammed Ibrahim (Solo Mission)


🛠️ 1. From Blueprints to the Breadboard

With the core multiplexing software compiled, today was all about bringing the project into the physical world. Building the first hardware prototype is where theory meets reality—and where dealing with a massive matrix of jumper wires becomes the ultimate test of patience.

The goal for this log was to fully wire up the hardware components on a single breadboard and achieve a fully functional, live-running physical prototype.


🔌 2. The Prototype Wiring Matrix

Connecting a standalone 4-digit 7-segment display (5416AS) manually requires routing a ton of overlapping connections. Because the display shares segment pins across all four digits, one wrong wire could short the system or light up the wrong number.

⚡ Hardware Layout & Connections:

  • The Chronometer Link: The DS3231 RTC module was wired into the Arduino Uno’s I2C lines (SDA and SCL) to feed steady time telemetry.
  • The Current Shield: Added 220Ω protective resistors in series with each segment line to keep the common cathode display from drawing too much current and burning out.
  • The Control Panel: Tied the analog potentiometer to pin A0 and a tactile push-button to digital pin 2 to act as the interface controls.

🔍 3. First Run & Troubleshooting the Bugs

Powering up the prototype for the first time brought some classic hardware engineering challenges that I had to solve solo:

  • The Ghosting Issue: Initially, numbers looked blurry and bled into each other. I adjusted the multiplexing delay in the code down to a few milliseconds, making the rapid switching invisible to the human eye so the display looks solid.
  • The Wire Nest: Managing over 15 individual jumper wires on a compact breadboard made it easy to accidentally bump connections loose. I carefully re-routed the cables into clean parallel paths to stabilize the signals.

Once the tweaks were made, the prototype worked flawlessly! Turning the dial instantly changes the countdown target, and pressing the button cycles through the operational states exactly as planned.


📈 4. Telemetry Log & Project Status

Current Status: 🟢 Phase 3 Complete

  • Successfully mapped and wired the 5416AS display pins on the breadboard.
  • Synced the physical DS3231 RTC module over the I2C bus.
  • Fixed display ghosting and flickering by calibrating multiplexing microsecond intervals.
  • Verified full interaction loop between the button, dial, and display.
  • Construct the final console enclosure box to secure the loose wires.

🚀 Next Mission Phase: Structural Hull Integration

Now that Prototype Alpha is running perfectly on the testbench, the next phase is packaging! In Devlog 04, I will be building a space-themed control console enclosure to house the messy wire harness and cleanly mount the screen, dial, and buttons for a finished look.


Proudly shipped solo for the Hack Club Stardance Challenge.

0
0
2
Open comments for this post

2h 26m logged

🌌 Mission Log: NASA Stardance Space Clock

Engineering Log 02: Solo Flight, Code Completion & Prototype Alpha
Date: June 2026 | Crew Update: Mohammed Ibrahim (Solo Mission)


🧭 1. Mission Update: Going Solo

Every space mission faces unexpected variables. Due to a sudden change in crew availability, Dhanvir has stepped down from the project. While losing a co-pilot changes the timeline dynamics, the launch parameters remain exactly the same.

The NASA Stardance Space Clock is officially a solo flight operation. I have taken over 100% of the hardware routing and code execution to bring this prototype to life.


💻 2. Software Architecture & Code Completion

The core codebase is officially written and compiled! Because controlling a 5416AS 4-digit 7-segment display manually requires a lot of heavy lifting, the software is structured around two critical engineering pillars:

⏱️ High-Frequency Multiplexing

A 4-digit display shares its segment pins (A-G) across all digits. To display a 4-digit number like 1 2 : 0 0, the code flashes each individual digit one at a time at microsecond intervals. Because it happens so incredibly fast, the human eye perceives it as a solid, unified display face with zero flickering.

🔄 The State Machine Loop

The code is built around a non-blocking millis() timing loop that continuously tracks three operational states:

  1. Clock Mode: Pulls precision hours and minutes from the DS3231 RTC chip via I2C.
  2. Timer Setup Mode: Reads the analog position of the potentiometer and maps it dynamically from $0\text{–}60$ minutes.
  3. Countdown Mode: Decrements time sequentially and checks if the system needs to flag the alarm state.

🔌 3. Prototype Alpha: The First Physical Run

With the code fully written, I completed the physical test bench wiring.

0
0
2
Open comments for this post

17m logged

🌌 Mission Log: NASA Stardance Space Clock

Engineering Log 01: Mission Concept & System Architecture > Date: June 2026 | Crew: Mohammed Ibrahim & Dhanvir


🚀 1. The Mission Objective

For our Hack Club Stardance project, we are engineering an interactive, standalone NASA Space Clock using an Arduino. The goal is to build a piece of physical hardware that looks and feels like an authentic mission control console while managing accurate time and interactive mission parameters.

🎯 Key Project Goals

  • Retro Control Room Vibe: Avoid standard modern LCD screens; use a physical digital layout.
  • Zero Host Dependence: The hardware must retain exact time even if disconnected from the computer.
  • On-the-Fly Configuration: Use analog dials and tactile inputs to set timers and adjust settings without rewriting code.

🛠️ 2. Hardware Manifest & Design Choices

To achieve our goals, we selected a rugged, minimal component layout. By using smart wiring techniques, we are keeping our pin footprint as small as possible.

Component Purpose Technical Detail Arduino Uno Main Flight Computer Processes state logic and multiplexing 5416AS Display Mission Dashboard 4-digit, 7-segment Common Cathode layout DS3231 RTC Chronometer High-precision I2C Real-Time Clock with battery backup Potentiometer Telemetry Dial Analog input mapped dynamically from $0\text{–}60$ minutes Tactile Button Mode Selector Leverages internal INPUT_PULLUP resistor Buzzer Comm Chime / Alarm Outputs audio frequencies for system alerts

We explicitly chose the 5416AS 7-segment display to mimic retro NASA launch countdowns. However, a 4-digit display normally demands 12 dedicated digital pins! To keep pins open for our modules, we are implementing custom multiplexing code—flashing the digits sequentially at microsecond intervals so they appear solidly lit to the human eye.


🎛️ 3. System States & Logic Flow

The clock is designed around a continuous Finite State Machine (FSM). A single physical button press shifts the system through its operational modes:

0
0
4

Followers

Loading…