# Raspberry Pi 1 Bare-Metal Synthesizer

This project turns an original Raspberry Pi (Model 1 B/B+, Zero, or Zero W) into an instant-on, single-voice synthesizer that runs without any operating system (bare metal).

It boots in under two seconds and produces sound and graphics with minimal external components.

## Features

- **Instant-On**: Boots directly into the synth application in ~1-2 seconds.
- **Audio Output**: Generates a sawtooth waveform on the 3.5mm composite audio jack.
- **Video Output**: Displays a simple amplitude visualizer on the composite video output.
- **Looped Melody**: Plays a pre-programmed random melody, no input required.

## Requirements

### Hardware

- **Raspberry Pi**: Model 1 (A, B, B+), Pi Zero, or Pi Zero W. This code is for the **BCM2835** SoC and will **not** work on Pi 2, 3, 4, or 5.
- **SD Card**: A microSD or standard SD card (depending on your Pi model), 1GB is more than enough.
- **Power Supply**: A standard 5V micro-USB power supply.
- **Audio Cable**: A 3.5mm audio cable to connect to headphones or a speaker.

### Software

- **Distrobox**: Required for the automated setup script. It works on most Linux distributions and is pre-installed on systems like Fedora Silverblue/Kinoite and Bazzite.
- The provided scripts handle all other dependencies.

## Quick Start (Recommended)

This project includes scripts to automate the entire setup and deployment process.

### 1. Set Up the Development Environment (One-Time Setup)

The `setup-dev-env.sh` script creates a self-contained environment with all the necessary build tools, without altering your host operating system.
```sh
./setup-dev-env.sh
```

### 2. Build and Deploy to SD Card

Insert a FAT32-formatted SD card so that it is mounted by your system. The `deploy.sh` script will then build the kernel, download the necessary firmware, and interactively ask you which device to deploy to.

Run the script with `sudo` because it needs permission to unmount the drive when it's finished.
```sh
sudo ./deploy.sh
```
Follow the on-screen prompts to select your SD card. The script handles the rest.

## How the Automation Works

- **`setup-dev-env.sh`**: This script uses Distrobox to create a lightweight Ubuntu container named `pi-synth-dev`. Inside this container, it installs the `make` and `gcc-arm-none-eabi` toolchain required for cross-compiling. This isolates dependencies and keeps your host system clean.

- **`deploy.sh`**: This script orchestrates the entire build and deployment process from your host machine:
    1.  **Builds the Kernel**: It automatically enters the `pi-synth-dev` container to run `build.sh`, which compiles the source code into `kernel.img`.
    2.  **Fetches Firmware**: It checks for `bootcode.bin` and `start.elf`. If they are missing, it downloads them from the official Raspberry Pi firmware repository.
    3.  **Finds the SD Card**: It scans for *mounted* removable drives and presents an interactive menu for you to choose the correct SD card partition.
    4.  **Copies Files**: It copies `kernel.img`, `bootcode.bin`, and `start.elf` to the selected SD card.
    5.  **Unmounts**: It safely unmounts the SD card, making it ready for use in the Raspberry Pi.

## Manual Alternative

If you prefer not to use the scripts, you can perform the steps manually.

1.  **Install Toolchain**: Install `gcc-arm-none-eabi` and `make` on your system.
2.  **Get Firmware**: Download `bootcode.bin` and `start.elf` from the official Raspberry Pi firmware repository.
3.  **Build**: Run `make` to compile `kernel.img`.
4.  **Deploy**: Copy `kernel.img`, `bootcode.bin`, and `start.elf` to the root of a FAT32-formatted SD card.


## Hardware Connections

1.  **SD Card**: Insert the prepared SD card into your Raspberry Pi.
2.  **Audio**: Connect headphones or a speaker to the 3.5mm audio jack.
3.  **Video (Optional)**: Connect a composite video cable from the RCA jack (on Model B) or the 3.5mm jack (on later models) to a compatible display.
4.  **Power**: Connect the 5V micro-USB power supply. The Pi will boot immediately.

## Usage

Once powered on, the synthesizer will automatically start playing a random melody loop. The composite video output will show a simple red bar that visualizes the audio amplitude.

There is no user input required for this version of the code.

---

*This project is for educational purposes and demonstrates low-level hardware control on the BCM2835 SoC.*