Control Deck

Overview

Control Deck is an interactive game experience that blends physical hardware inputs with a digital Unity-based cockpit game. The project centers around a custom-built “control deck” filled with switches, buttons, dials, and sliders. Players receive rapid-fire commands inside a stylized submarine environment and must locate and activate the correct physical input in time to progress.

Introduction

Control Deck is a programmable control interface and Unity game prototype designed around the aesthetics and logic of submarine operations. The player is tasked with completing system commands under time pressure using real-world physical controls. Each button, dial, and switch corresponds to an instruction within the Unity-based simulation, creating a hybrid interaction model that blends tactile input with digital event handling.

The project explores the experiential qualities of physical interfaces: how tactile switches, mechanical feedback, and spatial layouts alter the cognitive and sensory experience of interacting with software. Where traditional game interfaces favor speed and abstraction, Control Deck focuses on precision, procedure, and operator behavior.

During gameplay, Unity sends context-driven commands (e.g., “PRESS Button D8”, “SET Dial A2 to MID”, “FLIP Switch D29”), and the system waits for the user to locate and operate the correct physical control. The task emphasizes recognition, memory, reaction time, and state awareness, similar to industrial and navigational control systems.

This approach invites reflection on tangible interfaces in simulation environments, showing how physical input can promote immersion through materiality instead of solely through graphics or audio feedback.

Methods

Control Deck integrates hardware, firmware, and software to create a cohesive physical–digital control loop. The system consists of a physical control board, an Arduino Mega for IO handling, a custom serial protocol, and a Unity game client. Several components were developed to support real-time communication:

• Arduino Firmware: scans digital and analog inputs and transmits updates using a parsable serial protocol
• SerialManager.cs: handles asynchronous serial reading and input validation inside Unity
• CommandManager.cs: generates time-based tasks and checks correctness of inputs
• UI Feedback System: displays active commands and response indicators to the player
• Hardware Input Map: defines the mapping between physical pin numbers and in-game identifiers

The Arduino firmware outputs hardware state messages in a consistent format:

• BTN,pin,value: momentary button inputs
• SW,pin,value: toggle switch states
• ANA,index,value: analog dial readings

In Unity, these messages are parsed into actionable events. Controls are organized into three categories reflecting submarine interface logic:

• Buttons: trigger single actions (acknowledge, fire, confirm, etc.)
• Switches: represent persistent subsystem states (arm/disarm, open/closed, on/off)
• Dials: simulate variable instrumentation (depth, pressure, signal tuning, etc.)

To maintain readability and immersion, Unity renders commands visually and waits for valid responses. Reaction timing, precision, and correctness form the basis of scoring and difficulty scaling.

On the hardware side, inputs are handled through a structured pin map:

• Digital Buttons: D2–D24 (INPUT_PULLUP)
• Toggle Switches: D26–D35
• Analog Dials: A0–A6

A custom debounce and change-detection strategy was implemented for switches and buttons, while analog noise was controlled through step-based value thresholds to prevent excessive serial traffic.

Digital Fabrication

The physical control board for Control Deck was built as a fully custom hardware interface containing over fifty inputs across approximately ten distinct component types. These included momentary buttons, toggle switches, rotary dials, and other analog controls. Because each category required a unique wiring approach, the entire board was hand-assembled—cutting, crimping, and routing individual wires into an Arduino Mega acting as the main IO controller.

To house the components, a bespoke enclosure was designed and fabricated using a combination of laser cutting and 3D printing workflows. The process began with hand sketches that emphasized visual density, chaos, and the overwhelming variety of submarine-style controls. This layout was then converted into a precise CAD model in Fusion 360, allowing dimensions and component spacing to be resolved before fabrication. The resulting vector linework was exported to Adobe Illustrator for laser cutting preparation, including kerf adjustments and color-coded cut/engrave paths.

The final structure was laser-cut and assembled into a rigid unit capable of supporting all physical controls. Several custom knobs, sliders, and button caps were also modeled in Fusion 360 and 3D-printed on a Prusa i3 MK3S to achieve an authentic mechanical feel. All components terminate inside the enclosure and route through the Arduino, allowing the entire panel to operate as a self-contained USB device.

This build represents a functional prototype that informed future industrial considerations such as cable management, mounting, and material selection. Planned revisions will explore hard-wired harnesses, higher-durability substrates, improved enclosure tolerances, and long-term materials such as acrylic sheets and metal hardware for sustained use in interactive installations.

Takeaways

Control Deck required development across multiple disciplines, including embedded programming, serial communication, Unity architecture, and physical fabrication. Coordinating these components provided valuable insight into how hardware design and software systems negotiate timing, reliability, and interaction patterns.

A key takeaway involved designing interaction behaviors that respect human input. Physical interfaces introduce momentum, dexterity, and hesitation- factors rarely considered in digital UX. Building timing buffers, analog settling windows, and validation logic ensured the system responded like real control equipment rather than an arcade button panel.

Another major area of learning came from Unity’s threading and serial IO constraints. Managing asynchronous input streams while keeping the UI responsive demanded careful architectural decisions around queues, state machines, and command validation.

Ultimately, Control Deck demonstrated how meaningful physical interaction can reshape gameplay. The project now serves as a foundation for future work in tangible interfaces, simulation training, and interactive installations. Planned enhancements include expanding the panel’s physical footprint, introducing modular subsystems, and refining the in-game scenario logic to support more complex operations.