// Verilog Implementation Example
module software_defined_rom #(
    parameter ADDR_WIDTH = 16,
    parameter DATA_WIDTH = 8,
    parameter NUM_IMAGES = 4
)(
    input wire clk,
    input wire reset,
    
    // ROM Interface
    input wire [ADDR_WIDTH-1:0] addr,
    output reg [DATA_WIDTH-1:0] data,
    input wire ce_n,
    input wire oe_n,
    
    // Control Interface
    input wire [1:0] image_select,
    input wire load_enable,
    input wire [DATA_WIDTH-1:0] load_data,
    input wire [ADDR_WIDTH-1:0] load_addr
);

// Memory array for multiple ROM images
reg [DATA_WIDTH-1:0] rom_memory [0:NUM_IMAGES-1][0:(1<

#!/usr/bin/env python3
"""
Software Defined ROM Emulator for Raspberry Pi
Emulates multiple ROM images with GPIO interface
"""

import RPi.GPIO as GPIO
import time
import threading
import json
from pathlib import Path

class SoftwareDefinedROM:
    def __init__(self, config_file="rom_config.json"):
        self.config = self.load_config(config_file)
        self.rom_images = {}
        self.current_image = 0
        self.running = False
        
        # GPIO Configuration
        self.addr_pins = self.config['gpio']['address_pins']
        self.data_pins = self.config['gpio']['data_pins']
        self.control_pins = self.config['gpio']['control_pins']
        
        self.setup_gpio()
        self.load_rom_images()
        
    def load_config(self, config_file):
        """Load configuration from JSON file"""
        with open(config_file, 'r') as f:
            return json.load(f)
    
    def setup_gpio(self):
        """Initialize GPIO pins"""
        GPIO.setmode(GPIO.BCM)
        GPIO.setwarnings(False)
        
        # Address pins as input
        for pin in self.addr_pins:
            GPIO.setup(pin, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)
        
        # Data pins as output (initially high-Z)
        for pin in self.data_pins:
            GPIO.setup(pin, GPIO.OUT, initial=GPIO.LOW)
        
        # Control pins as input
        for pin_name, pin_num in self.control_pins.items():
            GPIO.setup(pin_num, GPIO.IN, pull_up_down=GPIO.PUD_UP)
    
    def load_rom_images(self):
        """Load ROM images from files"""
        for image_id, image_info in self.config['rom_images'].items():
            file_path = Path(image_info['file'])
            if file_path.exists():
                with open(file_path, 'rb') as f:
                    self.rom_images[int(image_id)] = list(f.read())
                print(f"Loaded ROM image {image_id}: {image_info['name']}")
            else:
                print(f"Warning: ROM image file not found: {file_path}")
    
    def read_address(self):
        """Read current address from GPIO pins"""
        address = 0
        for i, pin in enumerate(self.addr_pins):
            if GPIO.input(pin):
                address |= (1 << i)
        return address
    
    def write_data(self, data):
        """Write data to GPIO data pins"""
        for i, pin in enumerate(self.data_pins):
            GPIO.output(pin, (data >> i) & 1)
    
    def set_data_direction(self, output=True):
        """Set data pins direction"""
        for pin in self.data_pins:
            if output:
                GPIO.setup(pin, GPIO.OUT)
            else:
                GPIO.setup(pin, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)
    
    def rom_access_handler(self):
        """Main ROM access handling loop"""
        while self.running:
            # Check control signals
            ce_n = GPIO.input(self.control_pins['CE_N'])
            oe_n = GPIO.input(self.control_pins['OE_N'])
            
            if not ce_n and not oe_n:  # ROM access active
                address = self.read_address()
                
                # Get data from current ROM image
                if (self.current_image in self.rom_images and 
                    address < len(self.rom_images[self.current_image])):
                    data = self.rom_images[self.current_image][address]
                else:
                    data = 0xFF  # Default value for unmapped addresses
                
                # Output data
                self.set_data_direction(output=True)
                self.write_data(data)
                
            else:
                # High-Z state when not accessed
                self.set_data_direction(output=False)
            
            time.sleep(0.000001)  # 1μs delay for timing
    
    def switch_rom_image(self, image_id):
        """Switch to different ROM image"""
        if image_id in self.rom_images:
            self.current_image = image_id
            print(f"Switched to ROM image {image_id}")
            return True
        else:
            print(f"ROM image {image_id} not found")
            return False
    
    def start(self):
        """Start ROM emulation"""
        self.running = True
        self.rom_thread = threading.Thread(target=self.rom_access_handler)
        self.rom_thread.daemon = True
        self.rom_thread.start()
        print("Software Defined ROM started")
    
    def stop(self):
        """Stop ROM emulation"""
        self.running = False
        if hasattr(self, 'rom_thread'):
            self.rom_thread.join()
        GPIO.cleanup()
        print("Software Defined ROM stopped")

# Configuration file example (rom_config.json)
config_example = {
    "gpio": {
        "address_pins": [2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17],
        "data_pins": [18, 19, 20, 21, 22, 23, 24, 25],
        "control_pins": {
            "CE_N": 26,
            "OE_N": 27
        }
    },
    "rom_images": {
        "0": {"name": "BASIC ROM", "file": "basic.rom"},
        "1": {"name": "Game ROM", "file": "game.rom"},
        "2": {"name": "Utility ROM", "file": "utility.rom"},
        "3": {"name": "Test ROM", "file": "test.rom"}
    }
}

# Main execution
if __name__ == "__main__":
    try:
        # Create ROM emulator instance
        rom_emulator = SoftwareDefinedROM()
        
        # Start emulation
        rom_emulator.start()
        
        # Interactive control loop
        while True:
            command = input("Enter command (switch , status, quit): ").strip().lower()
            
            if command == "quit":
                break
            elif command == "status":
                print(f"Current ROM image: {rom_emulator.current_image}")
                print(f"Available images: {list(rom_emulator.rom_images.keys())}")
            elif command.startswith("switch "):
                try:
                    image_id = int(command.split()[1])
                    rom_emulator.switch_rom_image(image_id)
                except (IndexError, ValueError):
                    print("Invalid command format. Use: switch ")
            else:
                print("Unknown command")
    
    except KeyboardInterrupt:
        print("\nShutting down...")
    finally:
        rom_emulator.stop()