Homebrew CPUs are common, but building a homebrew transistor-transistor logic (TTL) graphics card on a breadboard is unique.
Key Components
Transistor-Transistor Logic (TTL): Implemented using integrated circuits (ICs) that run on 5V and perform various functions like boolean logic, counting, and arithmetic operations.
Graphics Card: Takes video data and generates a displayable output. The project’s graphics card won’t be card-like but will serve similar purposes.
Breadboard: A prototyping board with horizontal and vertical connected pins to build the graphics card circuit.
Understanding Composite Video Signal
PAL Composite Video Signal: Analog signal that uses variable voltage (0V to 1V) rather than digital zeros and ones. It is interlaced and runs at 50 Hz.
Frame and Resolution: Sends 50 frames per second, alternating between even and odd lines. The project will use a low resolution of 208x240 pixels.
Black and White Video: Will not handle color, simplifying the process and saving on video memory since each pixel will be 1 bit (black or white).
Research and Preparations
Screen Procurement: Sourced an old monitor that supports the composite video signal.
Software Simulation on Arduino: Used an Arduino to simulate the video signal in software before moving to hardware. As Arduino's typical language and IDE were too slow, switched to coding in C.
Initial Tests: Successfully generated a basic video signal, improving from a white square to stable vertical lines.
Circuit Design
Clock and Counters: Used a 4 MHz clock, along with two counters:
10-Bit Counter (HSC Counter): Counts every half scan line up to 624 per frame.
8-Bit Counter (TKC Counter): Counts 256 times per scan line, resetting every 64 microseconds.
Signal Structure: Divided into sync, back porch, actual data, and front porch segments, tracked using comparators and SR latches.
Read-Only Memory (ROM): Used ROM for storing pixel data, accessible via counters to generate the video output.
Building the Circuit
Design in Larterson Simulator: Created a circuit diagram, though had to use tunnels to manage complexity.
Live Stream Assembly: Built the circuit in real-time on a live stream, correcting mistakes with viewer input.
Challenges: Faced issues like non-functional ICs, floating voltages, and unqualified handling but finally got a basic image output.
EEPROM Programming: Built an Arduino-based EEPROM programmer for storing image data.
Debugging: Faced issues like gray lines and data errors, eventually identifying the EEPROM’s slow speed as the main limitation.
Conclusion
Final Output: Despite challenges, achieved a functional although imperfect display output.
Future Work: Plans to build the rest of the computer components while further optimizing and debugging the graphics card.
Next Steps: Continue improving and documenting the project.