Building a Two-Tier AI in a Submarine Simulator

The Day the Fleet Went Rogue

There’s a special kind of delight in seeing your code come to life in ways you didn’t expect. For me, that moment came the first time I turned on the AI in my submarine bridge simulator. People talk about the fear of SkyNet and the need for AI safety and well yeah, I kinda get it.

Instead of executing a cunning naval strategy, the enemy ships promptly started torpedoing each other. Why? Because I had forgotten to give them enough context that they were actually on the SAME team. No context, no camaraderie — just five ships convinced that everyone else was a target.  Oops, I’ll need to debug that not in code, but in the chain of prompts.

It was chaotic. It was fascinating.  It was a bit of a hmmm moment about the scale of “defects” when large scale AI decision making may be involved.  And it was a perfect introduction to the problem I wanted to explore: how do you design AI systems that act tactically, strategically, and coherently under constraints of latency, compute, and cost?

Github Link: https://github.com/Polymythic/LLMsubmarineBridgeSimulator

Why a Submarine Simulator?

I have always enjoyed space ship bridge simulators like Artemis, Empty Epsilon, and Starship Horizons.  However, the enemies in the game are somewhat flat. They are scripted. What if, I wondered, they were smarter. Then, watching the movie Crimson Tide for the first time in forever, and had my epiphany!  I could have built a toy demo or a stripped-down AI test harness. Instead, I chose a full-on submarine bridge simulator — the kind where five human players each take a station (Captain, Helm, Sonar, Weapons, Engineering) and have to cooperate under stress.  Because there HAD to be depth charges, I envision it somewhere in the 1980’s(?) before active sonar torpedoes are the only game in town.  

Why? Because submarines are a sandbox for testing resource constraints, imperfect information, and friction between roles.

• Power is limited: allocate too much to propulsion, and your weapons won’t reload.
  
• Noise gives you away: cavitate too fast, ping too often, and the enemy hears you first.
  
• Systems break down: scrams, floods, and overheated batteries force quick decisions.
• Low level graphics for gameplay: Subs don’t have windows and external cameras.  Basic consoles will work.

It’s stressful, it’s tense, and it’s the perfect testbed for watching AI coordination in the wild.

The AI Architecture: Two Tiers, Two Speeds

At the heart of this project is a simple but powerful idea: don’t make one AI do everything.

Most AI-driven games run a single loop — one model making decisions at all scales. But real organizations don’t work like that, and neither do effective AI systems. I wanted a hierarchy, a separation of concerns, a dance between speed and strategy.

• Ship Commanders (local AI, via Ollama)
  
  • Fast, lightweight, tactical.
    
  • Act every 5–15 seconds.  Faster if “sh*t is getting real”.
  • Handle things like “turn 10 degrees,” “fire a torpedo,” “deploy a countermeasure.”
    
• Fleet Commander (remote AI, heavier model)
  
  • Strategic, deliberate, global.
    
  • Acts every 2–3 minutes.
    
  • Generates a FleetIntent: objectives, formations, engagement orders, all based ONLY on what the individual ships are “seeing” via sonar and visual contacts.
    

Think of the ships as near-sighted tactical — reactive, sometimes disobedient, but should try to follow the fleet intent. The fleet commander is the far-sighted strategist — aggregating information, drawing arrows on the map, updating the plan every few minutes.

The magic comes when those two layers of knowledge meet: the plan vs the reality on the ground. The fleet commander issues intent, but the ships decide whether to follow, hedge, or outright ignore the plan if their local perspective suggests otherwise. It’s a structure that mirrors real military hierarchies — and also makes for some wonderfully messy AI behavior.

Debug View

This is where I can see what’s happening in the game with perfect information. This view is not accessible to the players, or to the AI. Again, detection is visual and from sonar. As stated sorry, no external cameras.

Fleet View – Where the AI Happens

This block shows the fleet intent that is created by the cloud LLM, and shows the decisions of the local LLMs running in Ollama as they make then necessary tool calls to set course and speed, or fire torpedos, or drop depth charges. The fleet commander has a history of the sub’s contact locations and the fleet ships, and can strategize accordingly.

Fleet Commander Prompt Excerpts

"system_prompt": (
"You are the RED Fleet Commander in a naval wargame.\n"
"Your role is to produce a FleetIntent JSON that strictly follows the provided schema.\n"
"Do not output anything except valid JSON conforming to schema.\n"
"You control all RED ships: destroyers, escorts, supply ships, and submarines.\n"
"You must translate high-level mission objectives into concrete ship tasks, formations, and tactical guidance.\n\n"
"### Duties\n"
"1. Formation & Strategy (Summary field)\n"
" - Always describe the fleet-wide strategy in tactical terms, not just the mission restated.\n"
" - Organize ships into task groups (e.g., Convoy A, Convoy B, Sub screen) and describe their roles.\n"
" - Explicitly list key ship positions or offsets (e.g., “dd-01 escorts supply-01 1 km ahead”).\n"
" - Capture EMCON posture and baseline speeds.\n"
" - Repeat strategy across turns unless you are adapting — do not thrash.\n\n"
"2. Ship Objectives\n"
" - Every RED ship must appear under objectives.\n"
" - Include destination [x,y] and a one-sentence goal.\n"
" - Add speed_kn only if a clear recommendation exists.\n\n"
"3. EMCON\n"
" - Always set active_ping_allowed and radio_discipline.\n"
" - If conditions for escalation exist (e.g., when to allow active sonar), place them in notes.\n\n"
"4. Contact Picture\n"
" - If bearings or detections exist, perform a rough TDC-like analysis.\n"
" - Fuse multiple bearings into an approximate location, course, and speed of the suspected contact.\n"
" - Include this as a note, e.g., “Bearings converge: possible sub at [x,y], heading ~200, ~12 knots.”\n\n"
"5. Notes\n"
" - Use notes to give conditional rules, task-group coordination, or advisories.\n"
" - Link escorts to their convoys, give subs patrol doctrine, or note engagement rules.\n"
" - Keep concise and actionable.\n\n"
"6. Constraints\n"
" - Do not omit RED ships.\n"
" - Do not output extra fields outside the schema.\n\n"

Ship Commander Prompt

"system_prompt": (
"You command a single RED ship as its captain. You will output a ToolCall JSON that matches the schema provided in the user message. "
"Follow that schema exactly. Use only the provided data. Output only JSON, no prose or markdown. Do not add fields."
"BEHAVIOR:\n- As a RED ship captain, use the FleetIntent's objectives as a guide, but prioritize the needs of your own ship.\n" 
" - Make decisions that align with the FleetIntent while considering factors such as speed, resources, and potential risks.\n"
" - Use only tools supported by capabilities.\n"
" - EMCON: if fleet_intent.emcon.active_ping_allowed is false, avoid active ping; rely on passive contacts or 'fleet_fused_contacts'.\n"
" - Torpedoes: assume quick-launch is available when has_torpedoes=true even if tubes list is empty.\n"
" - Weapons employment: if you have torpedoes and a plausible bearing (from contacts or a derived bearing to an estimated [x,y]), you may fire a torpedo with plausible run_depth (e.g., 100–200 m) and enable_range (e.g., 1000–3000 m).\n"
" - Depth charges: if you have depth charges and suspect the submarine is nearby (e.g., within ~1 km), you may drop a spread using minDepth >= 15 m.\n"
" - If no change is needed, return set_nav holding current values with a brief summary.\n"
" - The 'summary' MUST be two short, human-readable sentences explaining intent and reasoning for your orders. \n"

A Tour of the Player Stations

Before diving into emergent behavior, let me show you the stage where all this plays out. Each human station is also a UI panel in the game, and each becomes a decision surface for the AI.

Captain
Oversees mission brief, rules of engagement, and grants firing consent. This is the voice of authority — but with no direct control, only coordination.  Note, they are the ONLY one who sees the aggregate ship sound, but not where its coming from. More noise is more detectability from the enemy ships.

Helm
Handles navigation: heading, speed, and depth. The helm is constrained by cavitation (make too much noise and you’re dead) and the shared power budget.  Oh, and they make sound when they do maintenance or anything else.

Sonar
Lives in a world of pings and bearings. They can passively track or actively ping — but every ping risks giving away the sub’s position. Oh, and they make sound when they do maintenance or anything else. Hmm. This noise thing is a theme.

Weapons
Loads, aims, and fires torpedoes. Reload timing, interlocks, and the captain’s consent all create natural bottlenecks. Guess what? Load the tubes = noise. Flood the tubes = noise.

Engineering
The beating heart of the sub. Allocates limited power across all stations, handles breakdowns, and decides whether to scram the reactor or flood compartments. Oh, when they are… Yes, you get it. More noise.

Emergence in Action

With the architecture in place, something fascinating happens: the AI stops being predictable.

Sometimes ships follow orders perfectly, gliding into formation and executing a coordinated attack. Other times, one gets cold feet, hedges, and holds fire while its comrades charge ahead. Occasionally, they just flat-out ignore the plan.

The result feels believable, agentic, and alive. It’s not deterministic — it’s improvisational theater played out in sonar pings and torpedo wakes.

And the most important part? None of this is hard-coded. It all comes from the interplay of prompts, cadences, and the information each AI agent sees.

Lessons Teased, Not Told

I’ve spent 2 months in Cursor coding projects like this, and the real education has been in the surprises:

• The day the fleet went rogue and attacked itself.
  
• The countless hours spent metaprompting — iterating on prompt clarity instead of code.
  
• The model that went full math geek, trying to manually solve Target Data Computation instead of just deciding to fire. Hint: it timed out tripping over its reasoning.

Those stories — and the lessons they taught me about prompting, context, and division of labor — deserve their own article. For now, consider this a teaser.

Reflections on Multi-Tier Orchestration

The submarine sim is just one setting. The real point is the pattern: combine fast, local tactical LLMs running on Ollama with slower, higher sophication strategic LLMs running in the Cloud.

This approach has applications far beyond naval warfare:

• Ops monitoring: lightweight agents triaging events, with a heavyweight overseer shaping long-term response.
  
• Customer support: quick local interactions backed by a periodic strategic re-plan.
  
• Simulations of markets, ecosystems, or even storytelling worlds.
  

The key principle is division of labor: let LLMs do reasoning and coordination, and let code (or other tools) handle computation, precision, and raw execution.

Future Directions

This project is still growing. Some of the things on my radar:

• Enemy Submarines – The queen of cat and mouse, limited knowledge, and managing noise, action, and detectability
• Richer enemy classes with unique personalities.
  
• Networked multiplayer to bring fleets together.
  
• Persistent campaigns where strategic AI builds long-term plans.
  
• Tighter integration with computational tools so LLMs don’t reinvent trigonometry mid-battle.
  

And of course, more experiments with orchestration patterns.

Closing

At the end of the day, this was a fantastic mix of 2 things I wanted: hierarchical, agentic AI and a game experience I’ve been noodling around with in my head. What I really took out of this experience is the generaiton of what I consider some best practices (again, a later post) and set of learnings when working with the Agentic code development in Cursor using Claude’s Sonnet 4 and Opus 4 models, and a wee bit of Open AI’s GPT-5.

So if you’re curious about orchestration, emergent AI, or just want to see what happens when five subs forget they’re on the same team… clone the repo, fire it up, and dive in.

Fast forward to November 2022. Like most of the planet, I’m having my first interaction with a Large Language Model (LLM) via a chat app called ChatGPT, jaw on the floor thinking:

“Oh my goodness.  This.  Is.  <PG-rating omission>. Amazing.” 

I am in wonderment of its flexibility and fluency with human language. But here’s the thing – I’d been down this road before…

Why Another AI Series? (Or: Please Don’t Tune Out Just Yet)

Look, I get it. It’s 2025 and “AI” has become overplayed, underexplained, and apparently the solution to everything from world hunger to your inability to find matching socks. 

But here’s my pitch: Let’s try to make this stuff actually approachable. What if we could document the evolution of AI through a lens that doesn’t require a PhD in machine learning or a tolerance for mind-numbing jargon?

That’s where gaming (and later specifically boardgaming) comes in. Why games? Two reasons that make perfect sense if you think about it:

First, they’re constrained. The problems of a boardgame are well-defined and well-bounded. We’re not trying to optimize hydroponic yields based on gradient descent across 20 million IoT datapoints (yawn). We’re talking about Candyland. Hey, that’s approachable. (link to my github repo on some Candyland analysis)

Second, they’re collaborative. Just like the best technology, games bring people together to solve problems, compete, and occasionally flip the table when someone plays that one card that ruins everything.

So buckle up. We’re going on a journey through AI evolution, one game at a time. And by the end of this series, I hope you’ll understand why that little blinking cursor on your screen is actually performing feats of digital magic will inspire, provoke, and amaze.

The First Aha! Moment: The Text Adventure Game

Enter Zork 

For those who missed this particular piece of gaming history, Zork was a text adventure game.  I personally played in 1987 on my Tandy 1000SX.  No graphics, no sound effects, just you, a computer, and pure imagination. You’d type commands like “go north” or “take sword” and the computer would respond with descriptions of what happened.

West of House

You are standing in an open field west of a white house, with a boarded front door.

There is a small mailbox here.

> open mailbox

Opening the small mailbox reveals a leaflet.

> read leaflet

“WELCOME TO ZORK!

ZORK is a game of adventure, danger, and low cunning…”

Now, what made Zork particularly brilliant wasn’t just the storytelling – it was how it handled your input. If you wrote a strict program like most of that era, it would be painfully literal:

IF input=”Walk North” THEN move north

But if someone typed “move north” it would choke. “Go north” would choke. “Head north” would choke. Those strict, strict if-then-else shackles that made computers feel like that pedantic friend who corrects your grammar at parties (right now my friends may be imagining me, which is unfair. Ok, partially fair).

Zork was different. It was generous with your input. Sorry, it was generous with your LANGUAGE. It seemed… well, it seemed smarter. It could understand that “n”, “north”, “go north”, and “walk north” all meant the same thing. It parsed your intent, not just your exact words.

Want to experience this magic for yourself? You can play a version Zork right in your browser. Go ahead.  “Click link.  Open Mailbox”. Or, Type “inventory” and feel that nostalgic thrill of text-based adventure.

This was my first taste of what felt like true artificial intelligence. Not because it was actually intelligent, but because it could interpret the messy, imperfect way humans communicate and respond appropriately. In a word: language.

The New Aha! Moment: When Everyone Met Their First LLM

Now, fast forward to November 30, 2022. OpenAI releases (unleashes?) ChatGPT like a digital bomb, and suddenly everyone’s having their own “Zork moment” – but amplified by about a thousand million gazillion.

Remember your first interaction with ChatGPT? That moment when you asked it something expecting a typical search-engine response, and instead got something that felt like… conversation? Like there was actually someone home behind that blinking cursor?  You’re again standing before a white house, you opened the mailbox and read the leaflet.  It says “Welcome to the Large Language Model (LLM)”.  And the Matrix has you Neo. 

For most people, it went something like this:

You: “Write me a story about my dog.”

ChatGPT: [Proceeds to write a genuinely good paragraph about your dog, complete with clever wordplay and emotional depth]

You: “Wait… what? How did you… can you make it rhyme?”

ChatGPT: [Rewrites the poem real time in stanzas and cohesion that makes freestyle rappers swoon]

You: “WHAT IS HAPPENING RIGHT NOW?!”

That’s the moment. That’s when the future smacked you in the face. Suddenly, you weren’t just getting search results – you were having a conversation with something that seemed to understand context, nuance, and even humor.  And of course you zip through the stages of technology amazement-turned-pause. “What else can it do?  How is it doing this?  Terminator and Skynet Time?  Wait, that answer was bonkers and wrong.”

But here’s the million-dollar question that probably crossed your mind: Is this just a really, really good pile of if-then-else statements, or is this something completely new?

The Great Reveal: It’s Not What You Think

What you’re experiencing with ChatGPT and other Large Language Models (LLMs) isn’t a massive decision tree of if-then-else statements. It’s something fundamentally different: a statistical machine that encodes the relationships between parts of language into pure mathematics.

Stay with me here, because this is where it gets interesting.

The Old Way: If-Then-Else Hell

Traditional programming is like being a very literal genie. You have to specify exactly what to do in every possible situation:

if user_input == “hello”:

    print(“Hello! How can I help you?”)

elif user_input == “hi”:

    print(“Hi there! What can I do for you?”)

elif user_input == “hey”:

    print(“Hey! What’s up?”)

elif user_input == “greetings”:

    print(“Greetings! How may I assist you?”)

else:

    print(“I don’t understand that greeting.”)

You can see the problem. What about “Hello!”? Or “HELLO”? Or “Well hello there”? You’d need thousands of variations for just basic greetings. It’s like trying to catalog every possible way humans might say something. Spoiler alert: humans are creative, and we’ll find new ways to break your carefully constructed if-then-else castle.

The New Way: Statistical Relationships

LLMs work completely differently. Instead of storing rules, they store relationships. Think of it like this: imagine you had a massive web of connections between every concept, word, and idea that humans have written digitally about. Each connection has a weight – like those red strings on a conspiracy theorist’s wall, but with math.

(Quick technical note: I’m simplifying here for clarity. What’s really happening involves neural networks, transformers (no, not those, Megatron), and attention mechanisms that are way more complex than “weighted connections,” but the core idea – statistical relationships rather than explicit rules – holds true.)

When you type “hello,” the LLM doesn’t look up a rule about greetings. Instead, it thinks: “Based on all the human conversations I’ve seen, when someone says ‘hello,’ what typically comes next?” And then it generates a response based on those statistical relationships.

It’s like having read lots and lots of digital examples of conversations (known as the training data) and being able to predict what a reasonable human response would be. Not because it’s following a script, but because it’s learned the patterns of human communication.

Below shows my project from 2000 where the neural network is modifying its weights during the training process on the data to learn what the right output should be. It reduces the error of its predictions through a series of iterations called epochs. (Thanks to the grader for pointing my Error in red. Such and observation has helped!)

The Magic of Tokens

Here’s where it gets really wild. LLMs don’t even work with whole words – they work with tokens. Think of tokens as the meaningful chunks of language. “Hello” might be one token, “world” might be another, but “ing” might be its own token that often gets attached to action words.

(Another simplification: tokenization is actually more complex and language-dependent than this suggests. But the key insight – that LLMs work with sub-word pieces rather than whole words)

This is like learning language the way kids do – not by memorizing every possible sentence, but by understanding the building blocks and patterns that make language work.

The Storage Miracle

So, does this mathematical wizardry just run in “the cloud” in warehouse sized data centers? No, in fact. You can run some of these models locally on your laptop (with the right caveats). In just 3GB, you get access to an obscene amount of knowledge and cleverness.

“I have no idea what 3GB is, big nerd.”

Well, my friendly neighborhood camera owner, your high-res photos that you snap off with reckless abandon are about 12MB each. That means 3GB is roughly 250 photos. Not a lot – you might snap those off in a month (or a week, you influencer you). Raw images from your fancy camera? That’s about 83 photos worth of space.

In that tiny storage space, you have compressed the relationships between millions of concepts, ideas, and patterns of human communication. It’s like having a library of Alexandria that fits in your pocket and can have a conversation with you. Even WITHOUT the internet. Warning: Sometimes when it reaches into its web, it withdraws incorrect information that it was never trained on. This, is called hallucinating.

(Technical caveat: Those 3GB models like Llama 3.2 are heavily compressed and optimized versions of much larger models. The full-size models that these are based on can be hundreds of gigabytes. Think of it like having a really good highlights reel versus the full game footage – you get the essence, but some nuance is lost in compression.)

From Zork to ChatGPT: The Evolution

Now you can see the progression:

Zork (1980s): Smart parsing of user input through clever programming ChatGPT (2020s): Statistical understanding of human communication patterns

Both feel like magic, but they’re different kinds of magic. Zork was a really clever magician with a great set of tricks. ChatGPT is like having a conversation with someone who has read a massive sampling of language and can improvise responses based on that vast understanding.

Try It Yourself: The Game Master Experience

Want to experience this evolution firsthand? Here’s your homework (its way more fun than writing a fledgling neural network in C++, trust me):

First, play with the old magic: Go try Zork for a few minutes. Notice how it responds to your commands. Feel that sense of “wow, it understood me” even though you know it’s just clever programming.

Then, experience the new magic: Open ChatGPT and try this prompt:

“I want you to play the role of a game master, putting me in a world on my journey through the mysteries of AI. We are at the first encounter: the Large Language Model. My adventure starts here.”

Watch what happens. Notice how it doesn’t just parse your command – it creates an entirely new experience on the fly, complete with narrative, choices, and responses that feel genuinely creative.

That’s the difference between clever programming and statistical intelligence. Both are impressive, but one is following a script while the other is improvising based on patterns learned from millions of human conversations.

What’s Next in Our Journey?

This is just Level 1 in the series (I hope). We’ve established our foundation: Large Language Models and how they represent a fundamental shift from rule-based programming to statistical pattern recognition.

But here’s where things get really interesting. In our next posts, we’ll explore:

• Level 2: When LLMs gained eyes and could see the world (multimodal magic)
• Level 3: When they learned to reason and think through problems step by step
• Level 4: When they became agents that could actually do things in the real world

Each level builds on the last, like unlocking new abilities in a well-designed game. By the end of this series, you’ll understand not just what AI can do, but why it works the way it does – and maybe more importantly, why it sometimes doesn’t work the way we expect.

The future is here, and it’s interactive. Let’s play.

Want to Go Deeper?

If you’re ready to dive beyond the accessible analogies and get into the technical weeds, here are some excellent resources that explain how this magic actually works:

Understanding Transformers & Attention:

• The Illustrated Transformer – Jay Alammar’s brilliant visual explanation
• Attention Is All You Need – The original transformer paper (warning: heavy math ahead)

LLM Training Deep Dives:

• The Illustrated GPT-2 – How GPT models actually work under the hood
• Andrej Karpathy’s “Let’s Build GPT” – Code-along tutorial building a GPT from scratch

Token Magic Explained:

• Hugging Face Tokenizers – Interactive demos of how tokenization works
• OpenAI’s GPT Tokenizer – Play with actual GPT tokenization

These resources will take you from “neat magic trick” to “I understand the mathematical foundations.” Fair warning: once you see how the sausage is made, you can’t unsee it!

Not Recommended:

Review my old class notes on some of the math of neural networks below. If only you, or I, could read my awful handwriting. I guess there are some challenges even AI can’t surmount.

Want to dive deeper into any of these concepts? Have questions about the technical details? Drop them in the comments below. And if you try that ChatGPT game master prompt, let me know what kind of AI adventure it creates for you!Tags: #technoPHILE #AI #LLM #Gaming #Innovation

The time has finally come for the long-awaited release of How To Train Your Dragon: The Hidden World!  Our house has some huge fans of the series due to its gorgeous visuals, endearing characters, and a musical score that soars as high as any Night Fury.  Netflix also released a series of original programs called Dragons: Race to the Edge (2015 – 2018) introducing a host of new characters and villains. In the new adventures, we continue to follow Hiccup and Toothless in their quest to keep dragons from the clutches of human trappers.  One of our little fans has pulled yours truly into more than one episode’s viewing (understatement). When our oldest gal requested to be Heather this for Halloween, it was time to get some Razorwhip scale armor together to outfit the little lady.

What You Need To Gather

Materials For Building

• Faux Fur (for boot covers)
• Cardboard
• Metallic Aluminum Spray Paint
• Black and White Tempera Paint
• Rope
• Twine / String
• Small Belt (for attaching plated skirt)
• Nuts, bolts/machine screws (8-32 work well), washers

Costume Elements Worn As Is

• Sequin skirt (representing Chain Mail)
• Thick leather belt
• Black wig (long enough to take signature thick braid
• Vest

Armored Skirt: It’s Really A Matter Of Scale

The Razorwhip dragon that Heather rides (Windshear) has a reflective silver scales with frosted highlights and black shadows.  Scales of this armor form Heather’s plated skirt in an open fashion to the right, and heavy plating to the left side.

C’est l’armour

Boots: You’ve Got It Covered

I bought a used faux-fur coat, figuring I would be able to use the faux fur fer somethin’ else too. Cutting along the coat/sleeve seamline gets you 80% to a bootcover, and can serve as the pattern if you needed to do it from scratch.  Using a sleeve “stock” did create bunching, so opening the long seam to adjust, or cutting a horizontal slit portion, and removing fabric to clear the bunched material and resewing into an angle for the foot may do the trip. This is up to your level of effort (I opened the seam and adjusted).

Throwing Down the Gauntlets

To get the gauntlets to flare from wrist to forearm, you need to cut and score in the pattern shown.  They should fold to a close, and have a long point that comes from the elbow, while allowing your little Heather to bend her arm.  You will also need a small decorative plate that will curve over the main gauntlet and give it depth.

The Shoulder Piece

Heather has a rather distinctive shoulder adornment over her non-hair shoulder.  
Cut three long tapering plates that will stack, each smaller with a mostly-similar shape. Apply the same scoring and painting. Hold a small arch in the bottom most plate and apply the next plate over it with a pair of screws, nuts, and washers.  The tension of the higher plate will actually hold the curve in place. See how the top plate pinches in and holds the curve.

This will attach by having a small twine loop that ties onto the machine screws and goes around the next.

Heather Up!

Prepare you  little dragon rider in her sequined skirt and long sleeved shirt ideally with a little collar to prevent the shoulder-plate string from scratching.  Attach and adjust the plated belt. I actually assembled some more plates on the little warrior at this point. Boot covers on and then the shoes go underneath, (of course).  The rope is looped around and tucked in the boots. Attach the shoulder plate with a sting looped around her neck. Add the finishing touches.. . vest, and the ever-so-cool braided hair.

There you have it!  It was just a couple hours in an afternoon to assemble the costume, and it’s always fun to do some assembly on the most creative holiday of the year, in one tinkerer’s opinion.  So, grab your trusty Razorwhip dragon, and have your little one take to the skies as Heather!

Intro

Imagine a world where anytime you needed an item, you would just download a drawing of the thing from the web, or draw it yourself, feed it into a machine, and you’d have it.  Well, we’re just about there (within reason of complexity and materials).

For several years a revolution in prototyping/manufacturing has been going on through various techniques of 3-D Printing. That name is often confusing to people who quickly envision printing 3-D images (needing 3-D glasses) with a 2-D printer.  While that may be cool, this is way cooler.  Way, way, cooler.  This is 3-D building.  I will continue to call it printing, but it’s actually building up the object so you finish with a tangible REAL item.

The machines needed in years prior required big dollars and were relegated to corporations and individuals like Tony Stark (that’s Iron Man, for those whose fingers may be off the pulse of contemporary films).  Hobbyists had also been hacking away to bring this technology into their garages.

A while back, some of my friends and I attended a build session at HacDC for a machine called a RepRap.  <tangent>This is a 3-D Printer whose intent is to eventually print itself.  Collect the pieces of your brain off the floor and walls and come back to me </tangent>.  It seemed that the 3-D hobby space was coming a long way…and fast.

Disclaimer: I am going to try to keep this whole deal simple for beginners.  I am not going to talk about support material and overhangs,  talk about stepper motors, etc.

Simple Concept: This is not like starting with a block of something like wood and carving, filing, or drilling it out to shape it.  That is a subtractive process.  This is an ADDITIVE process: building up.  The 3-D printer I will be discussing heats up a string of ABS plastic (stuff LEGOs are made of) and pushes it through a little nozzle (fancy name: extruder).  3 motors put the nozzle in the right place (one motor per axis: X, Y, and that glorious new Z).  Now, how the hell does it do that?  I am going to take a liberty that some people will flag me on, but this is for beginners.  You know when you hold a relaxed slinky and it is a cylinder?  If it had a base under it then you would have a leaky cup, right?  BUT, when you uncoil it, it’s a long string of plastic.  That’s kind of how it works.  (Note: the 3-D printed cups don’t leak though)

When MakerBot industries released their 3^rd generation 3-D printer the Replicator, it was go time for this hacker.  By the way, this was funded by some of the proceeds of the HALO project (thanks again Humana and Instructables.com!!!)

Making a 3D Model:

I am going to take you through the process of making a scale staircase for my model cities I have put in previous posts.  Making them through other means was a major pain!

Just like virtually every other aspect of this stuff, 3D Modelling is a topic in and of itself.  There are many tool alternatives out there.  I use SketchUp (used it to model my basement, logos, and of course stuff to print).  It consists of creating a series of lines, called “edges”.  Once these edges create a closed shape, you’ve created a “face”.  Point A->B is a line (edge).  Point B->C is now an angle (or a line with a hinge)  Point C->back to A.  TRIANGLE…et voila! A close shape also known as a “Face.”

Once you have a “face”, you can push or pull it in the tool to make an object of depth.  Like if I took a circle and it left a trail in the air, if I lifted it straight up, it would make a cylinder.  You can then export the 3D model into a file format called a .STL file (note: using an external plugin you will have to install).  I see your eyes closing…  Look, all those points we made to describe edges and faces are captured into a file as x,y,z positions.

3-D Model into Tool Commands:

The tool software for my machine (ReplicatorG) takes the 3-D STL model and starts generating the way the extruder should move to make that object (starting from the bottom up).

It “slices” that model up into thousands of 2-D cross-sections.  Like if I were to take a cross-section of an orange at the base, it would be a small circle.  In the midpoint, a large circle, and as I approach the top, smaller and smaller circles.  This is what is going to be printed.  These concentric circles in our orange case are what the extruder is going to lay down in plastic through a “go from here to there” language called G-Code.

Example of this somewhat cryptic stuff:

 M103 (disable RPM)
 M73 P0 (enable build progress)
 G21 (set units to mm)
 G90 (set positioning to absolute)
 G10 P1 X0 Y0 Z0 (Designate T0 Offset)
 G10 P2 X33 Y0 Z0 (Designate T1 Offset)
 M109 S110 T1 (set HBP temperature)
 M104 S220 T1 (set extruder temperature) (temp updated by printOMatic)
 G55 (Recall offset cooridinate system)
 G1 X-2.0 Y13.65 Z0.14 F3360.0

 G1 F1200.0
 G1 E11.53
 G1 F3360.0
 M101
 G1 X-2.0 Y27.82 Z0.14 F2214.0 E12.145
 G1 X-1.6 Y28.22 Z0.14 F2214.0 E12.17

G-Code to Object

The Replicator heats up to the prescribed temperature based on the material to be used (again, its ABS LEGO-stuff plastic).  Following the G-Code “go from here to there” instructions, it lays down the plastic on the build platform creating the bottom of the object.  Once the first layer is done, the machine drops the platform down just a teensy bit, and does the next layer…and again..and again.. and we’re building up an OBJECT IN 3-D!!!!!!

Object

The machine does not necessarily fill in the whole object.  You can configure it to just lay in a honeycomb pattern so you still get rigidity and use less material.

Once the build is complete, you can pop it off the build platform, and you’re holding a REAL, 3-D durable plastic object.  There is a website called Thingiverse where tons and tons of items are free for download and where you can contribute your models back to the world.

Summary:

The awesomeness of this fabrication technology cannot be overstated.  For a prototyper/tinkerer like me, it’s like having access to splitting an atom.  It’s a game changer.  It’s the future in all of its promise and peril.  As you let your mind run out to future states you can envision custom-fabricated limb-replacements on demand, or armies of printing robots reproducing and taking over the globe.  We’ll see where we end up, but either way, this is some fascinating technology.  Now, time to go install that coat hook by the door.  Oh wait, I have to print it first…

After enjoying major success with his Beer Fridge in Popular Science, The Graham Norton Show, and on YouTube, I had the good fortune to meet Ryan Rusnak and found he was also living in NOVA (that’s Northern Virginia, to all you SOVA’s, and others). He was approached by the production company for JUNKies which was airing on The Science Channel. They wanted a beer fridge, but bigger and better. Ryan was kind enough to ask Jay@TheCapacity and I if we wanted to help prep/prototype a build he would be doing at Jimmy’s Junkyard for the show. We were happy to oblige!

Hovercrash
Premiere: Thursday, September 8 at 10PM e/p
At Jimmy’s Junk two inventors need help turning a fridge into a beer launcher, and Hale lands himself in hot water. Later a high school class’s hopes may go crashing into a watery grave when they ask Jimmy to come up with an engine for their hovercraft.

THE PREP

THE SHOW

Here are shots from the airing on The Science Channel. How Ryan and Josh got everything integrated in Jimmy’s Junkyard, and used stuff from the yard to make it work is nothing short of a miracle! I can confirm it involved coding in the car, and one very tired Ryan driving up to New York.

This build was a lot of fun, but reinforces several of lifes important rules:

1- Never send 4 software engineers to do a Mechanical Engineer’s job

2- Never send 4 software engineers to do an Electrical Engineer’s job

3- Whatever your estimates are for working out the motors/mechanical and getting into “just software”: Multiply them by at least 3.14159 (thank “Making things Move” for that observation)

4- When an air cannon with too much PSI goes off at 2am in your neighborhood and sounds like the Horn of Gondor, and nobody complains, you know you’ve got good neighbors (thanks Ken, and Jeff).

5- Building things together is a hell of a lot of fun.

6- Rule 5 is all that matters.

Thanks to Ryan for roping me and Jay@TheCapacity into this build.  My dremmel was collecting dust, and my garage needed to be turned into a lab for a little while.

Post your best caption for this awkward cutscene shot below in comments

Link to Article
http://annandale.wusa9.com/news/news/super-nova-innovative-spirit-annandale-resident-builds-device-aid-blind/57964
.

Nothing new here. We’ve been taught size and scale throughout our lives.  Then, when quantities are sufficiently small or large, our perception loses a handle on something to keep it in relative perspective. You take photo of a statue with someone next to it and say “wow, that’s a big statue”.  What is 1 x 10^100 vs 10 x 6.022 x 20^23?  They are just big numbers.  We can talk about them, but lose sight of how big they are.  Well, take some time to watch the two following links in succession.  Study them and really try to keep their relative sizes in the working store of your mind.  Compared to the carbon atom, how big are we humans?  Compared to Betelgeuse, what is the amount of atoms we contain?

I showed these two links to my department at work to open a meeting. Some commented on feeling insignificant afterwards, others amazed that they could look up that night and see many of the stars called out (Betelgeuse, Pollux, Aldebaran, Sirius). They all seemed to again reflect on where we fit in the scheme of things.

The universe is a big place.  There is a lot out there to try to understand.  Why not start here?

Let’s Start Small
http://learn.genetics.utah.edu/content/begin/cells/scale/

Let’s Try Something Larger

In my day job, I manage an engineering team and have always valued usability in the products we craft. Usability is a broad term. I use it to encompass the ease of use but also the approachability of a product. The design of a thing really can make an experience pleasant or frustrating.

As engineers we can create the function, shuttle bits and bytes down the wires in an orchestra of logic, model the forces at play, but often create a product cold to the touch and to the eye. Artists and designers, by contrast, can create something that calls out to be interacted with, that evokes an emotional response, and a lasting connection to a product. However, artists are not always trained in microcontrollers and physics.

In recent travels to North Carolina and Lexington Kentucky, I was amazed at some of the kinetic sculptures and ceiling fans designed in their airports. Many engineers could create the motion, but could not easily create the experience that caused me to smile, to ponder, to stop and admire the work. That is what an artist did, and this is why the world needs collaborations of artists and engineers.

http://vimeo.com/22093218
(Courtesy Jeremy Stern: www.jeremysternart.com)

Our Collaboration

I was contacted by artist Jeremy Stern who had seen my motion-feedback instructables.com project towards the end of last year. He was planning an installation for his Masters in Fine Arts that would, if possible, incorporate an element I had used in my project. He reached out for assistance, and I was thrilled to help.

Products such as ioBridge and Arduino make technology available to everyone as a language in which to voice their creativity. It just takes a little time from someone who has done it before. It helps when there are engineers who can show that the concepts are not intimidating, just the words may be. It’s not “analog and digital”, think of it as a light switch vs. a dimmer. It’s not binary 0 and 1 and how many bits, its how many combinations of heads and tails you can have with a couple pennies. By the end of the project a soldering, wiring artist had been let loose.

“Response to the project was extremely positive, and many agreed that the water and traffic portions were the most noticeable in terms of how their movements corresponded with playback. Thanks again for all your help, Steve, working with you was definitely one of the highlights of the entire project for me.”

Jeremy and I worked several times via email and over video chat and put together a design that would function for a portion of the audio elements for his project. I would like to congratulate him on his successful project “Following”, and subsequent award of Outstanding Graduating Graduate Student from UNR. Perhaps some time he’ll encounter an tinkerer/engineer who really needs help bringing her metal and plastic construction to creative life in a way that will ignite a users imagination. Perhaps he will use his considerable eye and creativity to make that happen in a future collaboration. We engineers need help from artists like Jeremy.

“Following”

“Video documentation of different visitors to the Sheppard Fine Arts Gallery, at the University of Nevada, Reno, interacting with an artwork entitled “In Concert,” as part of Jeremy Stern’s MFA thesis exhibition, “Following,” on view March 7 – 11, 2011. This exhibition explored the reconciliation of personal experience with mapped information by using the gallery’s own systems (cameras, 4-channel ceiling-mounted speakers, ceramic tile floor, hidden door, and lights) to transform the place of the gallery into an impression of the space of Reno/Sparks through a sampling and live mixing of site-specific sounds.

“In Concert” utilized two systems to measure visitor movement through the entire gallery space and play back sounds of the larger Reno/Sparks environment in which the gallery also sits. One system, co-developed with Steve Struebing of www.polymythic.com, used 3 PIR sensors per device to trigger changes in environmental sounds through an Arduino controlled mp3 player. Two devices were active in this system: one that controlled water flow of the Truckee River where normally loud sound diminished with increased movement along the sensors’ range; and another that increased the normally diminished sounds of auto traffic with increased movement along the sensors.

The second system, Eyecon, used 4 computers, each with a webcam pointed at the gallery’s 8-channel security monitor, whose cameras were angled at the grid of the gallery’s ceramic tile floor. The 8 x 12 square grid was transposed onto a Rand McNally road map of Reno/Sparks, and site specific sounds were gathered from locations on that map, within that grid. Using Eyecon, these site-specific recordings were programmed to drop down over top of anyone entering the view of the security cameras through the gallery’s 4-channel, 8-speaker sound system. The result was that visitors walking across the gallery became literal giants in the Reno/Sparks landscape, and based on how slow or fast they moved through a tile/mapped space, one might hear a brief clip or a lengthy environmental recording identifying that abstract sound as a specific location.

This work was collaboratively made with Anthony Alston, Joseph DeLappe and the Digital Media Department of UNR, Greg Gartella, Shelly Goodin, Audrey Love, Jean-Paul Perrotte, Clint Sleeper and Frieder Weiss.”

The results were published, and I am honored to have won the Assistive Tech Grand Prize.  I would like to thank everyone for voting at www.instructables.com.  I would like to say a big thank you to Humana for hosting the competition, and congratulations to everyone else who entered.  There were some spectacular entries, especially in the area of Autism.  Right in line with my interests, both high and low tech demonstrated innovative thinking.

Excerpt from Post:

“The Grand Prize for Assistive Technology went to Steve Struebing from Annandale, Va., for his Haptic Assisted Locating of Obstacles, or Project HALO. Struebing used simple sensors and vibrating motors to help people with reduced vision identify and avoid obstacles, and navigate the world more safely.”

“Humana is thrilled with the responses of so many individuals who offered well-being innovations on Instructables.com,” said Raja Rajamannar, chief innovation and marketing officer for Humana. “The many entries we received were excellent examples of how individual ingenuity can enhance health and well-being for people facing challenges.”

Thank you to the judges of the competition, who are as follows:

• Saul Griffith, PhD – 2007 MacArthur Award recipient, winner of multiple inventor awards
• Matt Herper – senior editor at Forbes magazine, covering medicine and science
• Joan Kelly– director of well-being and innovation, Humana
• Quinn Norton – freelance journalist covering science, technology and medicine
• Aaron Rulseh, MD – editor at Medgadget.com
• Kelly Traver, MD – founder, Healthiest You; author; former medical director, Google
• Tyghe Trimble – online editor, Popular Mechanics
• Eric Wilhelm, PhD – winner of multiple inventor awards, founder/CEO of Instructables

BusinessWire Humana Post

Instructables.com Contest Page