Featured On

Making Coin Collecting More Accessible

As a passionate numismatist and technology professional, I’ve become increasingly aware of the challenges faced by coin collectors with physical disabilities. Many collectors struggle to handle and examine coins, making enjoying the hobby difficult. This inspired me to leverage my technology and product management background to create Numi, an AI-powered application designed to make coin collecting more accessible and inclusive for individuals with physical limitations.

‍

The Evolution from Numi v1.0 to v2.0

Numi v1.0: AI-Powered Coin Grading

The first version of Numi focused on coin grading. Grading is a critical skill in numismatics, directly impacting a coin's value and helping collectors decide whether to invest in professional third-party grading. However, after extensive testing, I discovered severe limitations. Numi was excellent at grading coins in Mint State condition, but once a coin was in poorer condition, it became highly inaccurate.

Numi AI Grading Test Results

‍Upon encountering this limitation, I decided to take a step back while AI models continued to advance.

Numi AI Grading Test Results

Pivot to Numi v2.0: AI Coin Identification & Sorting Robot

In the following months, OpenAI continued to improve its GPT-4 model. After the release of GPT-4 + Vision and GPT-4o, I retested Numi to see if coin grading accuracy had improved. While the accuracy was still lacking, I noticed these AI models consistently identified coins. Thousands of tests convinced me that while AI coin grading is not yet ready, AI coin identification is.

This realization led to the development of Numi v2.0. Many collectors, especially beginners, are drawn to the hunt for rare key dates, errors, and varieties. However, novice collectors often don’t know what to look for. By creating an automated coin-sorting system, Numi v2.0 aims to make the coin-sorting process more efficient and accessible, particularly for popular series like Lincoln Wheat Cents.

‍

Initial Design Process

Before diving into the technical implementation, I began with a comprehensive design phase using Studio, a computer-aided design software for Lego projects. This approach allowed me to:

Prototype the entire system virtually, saving time and resources.
Leverage Studio's integration with Lego's part catalog to ensure all components were purchasable.
Streamline the transition from digital design to physical prototype.

Initial Prototype Design

Final Prototype Design

One of many Bricklink orders for Lego Technic pieces

System Overview

Numi v2.0 is designed to physically handle coins, capture images, analyze them using AI, and sort them based on predefined criteria. The initial use case is sorting Lincoln Wheat Cents. Below is a high-level overview of the system components:

Hardware:

Software:

Operating System:

PiOS (Raspberry Pi OS)

Development Environment: Windows 10, Visual Studio Code, PuTTY for SSH, GitHub for version control

Operating System

I chose the recently released Raspberry Pi 5 (October 2023) as the system's brain. The Pi 5’s significantly more powerful CPU was a critical factor in my decision. I wanted extra computing capacity if I decided to run a local LLM model on the Pi itself.

My Raspberry Pi 5 powering Numi 2.0

Cameras

I selected two Arducam IMX519 cameras for their autofocus capabilities and direct compatibility with the Pi's CSI interface. These cameras are positioned sequentially to capture images of both sides of each coin.

2 x Arducam IMX519 cameras

Lego Build Hat and Technic Parts

I used Lego Technic pieces to build a prototype quickly and affordably. The Lego Build Hat add-on for the Pi 5 allowed communication between the Pi and the Lego Technic pieces, including motors that move the coins. This setup was crucial for rapid prototyping and easy modifications.

While researching how to connect my Pi 5 with Lego pieces, I was pleasantly surprised to find numerous tutorial videos on YouTube created by kids interested in coding and engineering with the Lego Build Hat. It reminded me of my original goal: making numismatics accessible to everyone.

Lego Built Hat Addon for Raspberry Pi

Lighting

To ensure consistent, high-quality imaging, I upgraded from weak Pi-powered LEDs to two JOBY Beamo Mini LED lights, each capable of producing up to 1500 lumens. High-lumen output is critical for coin photography, allowing the camera to capture even the smallest details. This level of detail is essential for accurate analysis, as even subtle features can significantly affect coin identification.

2 x JOBY Beamo Mini LED lights

Software Architecture

Development Environment

The development environment consists of:

Visual Studio Code on Windows 10 for code editing
PuTTY for SSH connection to the Raspberry Pi
GitHub for version control

Python and Key Libraries

The system is coded in Python due to its versatility and extensive libraries supporting Raspberry Pi and Lego Technic pieces. Key libraries include:

libcamera: For capturing images on the cameras
base64: For encoding images for API requests
buildhat: For controlling the Lego components
google.generativeai: For interfacing with the Gemini Flash AI API

Numi 2.0 Operation Workflow

Numi 2.0 operates through a series of coordinated steps involving image capture, physical coin manipulation, and AI analysis. Here's a detailed breakdown of the workflow:

1. Initial Coin Placement

A coin is manually placed under Camera 0.

2. Image Capture - Side 1

Camera 0 activates with a 0.5-second preview and captures an image.

def capture_image(camera, filename):
    try:
        if camera == 0:
            command = [
                "libcamera-still", "--camera", "0", "--width", "3840", "--height", "2160",
                "--lens-position", "5", "--roi", "0.35,0.35,0.3,0.3", "--autofocus-mode", "manual",
                "-t", "500", "-o", filename, "--nopreview"
            ]
        # ... (similar setup for camera 1)
        result = subprocess.run(command, capture_output=True)
        return result.returncode == 0
    except Exception as e:
        print(f"Failed to capture image: {e}")
        return False

3. Coin Is Flipped

Motor A activates after Camera 0 finishes, pushing the coin down a ramp to the next level and flipping it.

def move_motor_a():
    motorA = Motor('A')
    motorA.run_for_rotations(speed=20, rotations=1)
    motorA.stop()

4. Image Capture - Side 2

Camera 1 activates after Motor A's run is complete, with a 0.5-second preview, and captures an image of the coin's other side.

5. Coin Positioning for Sorting

Motor B runs after Camera 1 finishes, positioning the coin for the sorting process.

6. AI Analysis & Response

Both captured images and a predefined prompt are sent to Google's AI for analysis.

def analyze_coin(image1_path, image2_path):
    with open(image1_path, "rb") as image_file1, open(image2_path, "rb") as image_file2:
        image1 = base64.b64encode(image_file1.read()).decode('utf-8')
        image2 = base64.b64encode(image_file2.read()).decode('utf-8')

    prompt = """
    Please provide the analysis for the provided images. Both images are of the same coin 
    and analysis should be done holistically

    - If the year on the coin is between 1909 and 1929, respond with position 1.
    - If the year on the coin is between 1930 and 1939, respond with position 2.
    - If the year on the coin is between 1940 and 1958, respond with position 3.
    - If you cannot determine the year on the coin, respond with position 4.
    - If you cannot determine what the coin is, respond with position 4.

    Example Format:
    {
        "Coin": {
            "Coin Type": "Lincoln Wheat Cent",
            "Country of Origin": "United States of America",
            "Coin Year": "1923",
            "Mint Mark": "Denver"
        },
        "Quick Fact": "This Lincoln Wheat Cent series started in 1909",
        "Position": 1
    }
    """

    response = genai.generate_content(
        model="gemini-pro-vision",
        contents=[prompt, {"mime_type": "image/jpeg", "data": image1}, 
                  {"mime_type": "image/jpeg", "data": image2}],
        generation_config={"temperature": 0.1}
    )
    return response.text

7. Coin Sorting

Motor C uses Google's AI response to determine the appropriate position and moves accordingly.

def move_motor_c(position):
    motorC = Motor('C')
    print(f"Moving Motor C to position {position}")
    if position == 1:
        motorC.run_for_rotations(speed=20, rotations=1)
    elif position == 2:
        motorC.run_for_rotations(speed=20, rotations=2.5)
    elif position == 3:
        motorC.run_for_rotations(speed=20, rotations=3.9)
    elif position == 4:
        motorC.run_for_rotations(speed=20, rotations=5.5)
    motorC.stop()
    print("Motor C stopped")

8. Final Coin Placement

Motor D runs based on the response from Google's AI, completing the sorting process.

‍

Watch the Numi v2.0 Workflow in Action!

To better understand how Numi v2.0 operates, check out my video walkthrough. In the video, I guide you through each workflow step—from coin placement, image capture, and AI analysis to the final sorting. You’ll get a behind-the-scenes look at the system in action and see how my integrated technology works in real-time.

Current Challenges and Future Work

While Numi v2.0 successfully processes and sorts individual coins, automating the coin-feeding process remains challenging. To address this, I've acquired a Money Controls SCH2 Coin Hopper.

Money Controls SCH2 Coin Hopper

However, integrating this legacy device (last revised in January 2005!) with its outdated ccTalk communication protocol has been challenging. I've had to navigate issues such as voltage mismatches between the Pi (which operates at 3.3V) and the hopper (which uses 5V). To ensure safe communication, I used a bi-directional voltage converter.

Zopsc 3.3V/5V to 3.6V/24V 4 Channel Voltage Converter

Additionally, I've had to dive deep into the ccTalk protocol documentation, learning how to implement the protocol from scratch, as there are no readily available Python libraries. This process has involved understanding the intricacies of serial communication, byte-level data manipulation, and error handling specific to the ccTalk protocol.

I am currently working on connecting the coin hopper to the Raspberry Pi so that after a coin is sorted, the hopper dispenses the next one for analysis. However, wrapping my head around the communications protocol has proven difficult.

Conclusion

Reflecting on the development of Numi v2.0, I'm proud of how far I've come. Although I’m not a software engineer or roboticist by trade, my perseverance has led to a prototype I could showcase at my local coin club!

Numi v2.0 Prototype Shown at the Denver Coin Club [July 2024]

Through this journey, I've created a tool for coin enthusiasts and deepened my understanding of hardware integration, computer vision, and AI applications. I’m excited to see how Numi will evolve and what its potential impact will be on the numismatic community.

If you want to follow my journey with Numi, check out my Instagram page. I post updates and my research.

Building Numi v2.0: Autonomous AI Coin Sorting Robot

Featured On