🖥️ FPGA Multi-Mode Interactive System

🎯 A tidy little FPGA system with three working personalities

Built on Efinix Trion T35F324, this project combines real-time camera capture, DDR3 frame buffering, HDMI display, touch interaction, UART motion control, and physical execution in a single Verilog RTL design.

✍️ Write @ 🎨 Draw # 🎮 Tic-Tac-Toe X

⚡ Quick Peek
🥇 Best demo: physical Tic-Tac-Toe
🛤️ Active path: AR0135 DVP → DDR3 → HDMI
🦴 Shared backbone: video, UART, and 3-axis motion
📖 Best first read: T35_Sensor_DDR3_LCD_Test.v + uart_screen.v

🗺️ Quick Navigation · 🚀 Quick Start · 📊 Current Status · 🔨 Build & Simulation

📸 Project Snapshot

Tip

💡 Think of this repository as one FPGA backbone wearing three different hats: @ for careful writing, # for faster drawing, and X for closed-loop robotic play.

✍️

Write
@
_{slower and steadier pen tracing over UART XY paths}

🎨

Draw
#
_{the same coordinate pipeline, tuned for quicker sketching}

🎮

Tic-Tac-Toe
X
_{camera sensing, move planning, and physical pick-and-place}

This repository exposes three interactive modes over a shared Verilog RTL backbone: camera capture, DDR3 buffering, HDMI display, UART communication, and 3-axis stepper motion.

The checked-in project is most complete in its physical Tic-Tac-Toe path, which closes the loop from live video all the way to piece manipulation. The Write and Draw modes share the same UART motion backend and are fully functional for coordinate-driven XY motion; they differ mainly in stepper speed (Write is slower for controlled pen strokes, Draw is faster for sketching).

🗺️ Quick Navigation

💭 If you want to...	📂 Start here
🔍 check what is already wired and demoable	Current Status
🧭 find the main RTL route into each mode	Key entry points
🔨 rebuild synthesis, PnR, or bitstream output	Build and Simulation
🕹️ drive Write / Draw motion over UART	Control Reference
🔬 peek into the closed-loop game flow	System Internals

🚀 Quick Start

🎯 Scenario	👣 First move
📖 Read the active design	Start with `Source/T35_Sensor_DDR3_LCD_Test.v`, then follow `uart_screen.v` into the mode-specific logic
🖊️ Bring up pen motion	Select `@` or `#` on the touch screen, then send XY packets on the motion UART
🤖 Demo physical Tic-Tac-Toe	Enter `X`, choose side and turn order, then start the round with `S`
🔁 Rebuild the FPGA image	Use the scripts in `Efinity/work_syn` and `Efinity/work_pnr` after adjusting the exported paths for your machine

Note

📚 Best first-read files: Source/T35_Sensor_DDR3_LCD_Test.v, Source/bsp/uart_screen.v, Source/bsp/tictactoe_game_top.v

✨ Highlights

🏷️ Area	✅ What is included
📹 Video pipeline	CMOS camera input, crop, DDR3 frame buffer, HDMI/LCD output
✍️ Write mode	UART XY-coordinate parser, precision-speed stepper motion for pen tracing
🎨 Draw mode	Same coordinate pipeline as Write, higher stepper speed for sketching
🧠 Game logic	Board sampling, move strategy, winner check, game-state control
👆 Interaction	Touch-screen mode selection and control commands over UART
⚙️ Motion	3-axis stepper coordination (XY interpolation + Z pen lift), piece pickup/release
📦 Build assets	Efinity project, timing constraints, generated IP, archived reports

📊 Current Status

📋 Item	🚦 Status	📝 Notes
🔝 Top-level build	✅ Active	`Source/T35_Sensor_DDR3_LCD_Test.v`
📡 Active sensor path	✅ Ready	`AR0135` DVP → crop → DDR3 → HDMI/LCD
🎮 Tic-Tac-Toe mode	🏆 Most complete	Detection, strategy, winner check, XYZ execution
✍️ Write mode	✅ Ready	Selectable via `@`, UART XY coordinate parser + slower precision stepper motion
🎨 Draw mode	✅ Ready	Selectable via `#`, same UART protocol as Write + faster stepper motion
🗂️ Alternate sensor LUTs	📎 Included	`OV5640`, `SC130GS`, `MT9M001`, `IMX219`
🔌 MIPI path	🚧 Partial scaffolding	Ports and constraints remain, but DVP/AR0135 is the active path

🔩 Hardware and Tools

🛠️ Toolchain

Efinix Efinity IDE 2023.2 or later

🧱 Hardware for the active build

Efinix Trion T35F324 development board
AR0135 camera module
HDMI display

🦾 Extra hardware for the physical Tic-Tac-Toe setup

touch screen using the documented UART protocol
3-axis stepper mechanism
electromagnet or equivalent end effector for piece pickup

Tip

💡 If you only want to inspect, simulate, or rebuild the video path, the motion hardware is not required.

🎛️ Mode Summary

🎭 Mode	⌨️ Command	⚡ Speed (DIV)	🧩 Core modules	📖 Description
✍️ Write	`@`	1000	`uart_screen`, `uart_fsm_top`, `XY_motion`, `motor_ctrl`	Precision-speed XY pen tracing via UART coordinates
🎨 Draw	`#`	800	Same as Write	Faster XY sketching via UART coordinates
🎮 Tic-Tac-Toe	`X`	800	All of the above + `tictactoe_game_top`, `Game_strategies`, `winner`, `transfer_data`	Vision + strategy + robotic execution

🔬 System Internals

🔄 System Flow

                  ┌─────────────────────────────────────┐
                  │     👆 Touch Screen (UART)            │
                  │  Mode: @ / # / X    Commands: S B W…  │
                  └─────────────┬───────────────────────┘
                                │
        ┌───────────────────────┼───────────────────────────┐
        │                       │                           │
        v                       v                           v
   ✍️ Write Mode (@)      🎨 Draw Mode (#)       🎮 Tic-Tac-Toe Mode (X)
   function_mode=0         function_mode=1          function_mode=2
        │                       │                           │
        │                       │                           v
        │                       │              📷 Camera → ✂️ Crop → 💾 DDR3 → 📺 HDMI
        │                       │                           │
        │                       │                           v
        │                       │                 📊 Board-State Sampling
        │                       │                   (9-cell, 18-bit)
        │                       │                           │
        │                       │                           v
        │                       │            🧠 Game Strategy + 🏆 Winner Check
        │                       │                           │
        v                       v                           v
        └───────────────────────┴───────────────────────────┘
                                │
                                v
                   📨 UART XY Coordinate Parser
               (X<int>.<dec>Y<int>.<dec> + Z<cmd>)
                                │
                                v
                 🔀 XY Interpolation + ⬆️⬇️ Z Lift Control
                      (3-axis stepper motors)
                                │
                                v
                       🤖 Physical Execution
                  (pen on paper / piece pick & place)

🧭 Mode routing in hardware

The top-level signal function_mode (2-bit) is decoded by uart_screen.v from the touch-screen UART commands @, #, and X. This single signal then gates behavior throughout the design:

motor_ctrl.v: selects stepper speed — DIV=1000 for Write, DIV=800 for Draw/Tic-Tac-Toe
Uart_Stepper.v: selects the XY motion source — UART FSM for Write/Draw, game logic for Tic-Tac-Toe
tictactoe_game_top.v: always instantiated; its AI-generated XY output is only forwarded to the motion path when function_mode == 2'd2

📁 Repository Layout

📦 T35_Write_Draw_Play/
├── 📂 Source/
│   ├── 📄 T35_Sensor_DDR3_LCD_Test.v      # Active top-level RTL
│   ├── 📄 T35_Sensor_DDR3_LCD_Test_tb.v   # Legacy top-level smoke testbench
│   ├── 📂 axi/                            # AXI4 control and interconnect
│   ├── 📂 bsp/                            # Tic-Tac-Toe, UART, motion control
│   ├── 📂 cmos_i2c/                       # Sensor config LUTs and capture helpers
│   ├── 📂 hdmi_ip/                        # HDMI wrapper IP
│   ├── 📂 rgb2dvi/                        # Adapted RGB2DVI IP
│   └── 📂 isp/                            # ISP blocks, including interpolation
└── 📂 Efinity/
    ├── 📄 T35_Sensor_DDR3_LCD_Test.xml    # Project file
    ├── 📄 T35_Sensor_DDR3_LCD_Test.sdc    # Timing constraints
    ├── 📄 T35_Sensor_DDR3_LCD_Test.peri.xml
    ├── 📂 ip/                             # Vendor-generated IP
    ├── 📂 work_syn/                       # Synthesis scripts
    ├── 📂 work_pnr/                       # Place-and-route scripts
    └── 📂 outflow/                        # Archived reports and outputs

🔑 Key entry points

🧬 Top-level RTL: Source/T35_Sensor_DDR3_LCD_Test.v
🧪 Testbench: Source/T35_Sensor_DDR3_LCD_Test_tb.v
🖥️ Screen command parser: Source/bsp/uart_screen.v
✍️🎨 Write/Draw — UART motion FSM: Source/bsp/uart_fsm_top.v
✍️🎨 Write/Draw — XY coordinate parser: Source/bsp/fsm_xy_decode.v
✍️🎨 Write/Draw — Z-axis parser: Source/bsp/fsm_z_decode.v
✍️🎨 Write/Draw — XY interpolation: Source/bsp/XY_motion.v
⚙️ Motion backend: Source/bsp/Uart_Stepper.v
🔩 Motor controller: Source/bsp/motor_ctrl.v
🎮 Tic-Tac-Toe — Game controller: Source/bsp/tictactoe_game_top.v
🎮 Tic-Tac-Toe — Move strategy: Source/bsp/Game_strategies.v
🎮 Tic-Tac-Toe — Winner detection: Source/bsp/winner.v
🎮 Tic-Tac-Toe — Coordinate mapping: Source/bsp/transfer_data.v

🔨 Build and Simulation

The repository already includes an Efinity project plus archived implementation outputs. The checked-in shell scripts are export artifacts from the original Windows environment, so you should expect to adjust tool paths and workspace paths before re-running them on another machine.

🧱 Synthesis

cd Efinity/work_syn
./run_efx_map.sh

Note

📝 run_efx_map.sh currently contains absolute D:/... and E:/... paths from the original setup, so treat it as a reference command line unless your environment matches that layout.

📐 Place and route

cd Efinity/work_pnr
./run_efx_pnr.sh

💿 Bitstream generation

cd Efinity/work_pnr
./run_efx_pgm.sh

🧪 Simulation

The repository includes a legacy top-level testbench at Source/T35_Sensor_DDR3_LCD_Test_tb.v. It is best treated as a smoke-test harness for clocks, DDR-side handshaking, and I2C bring-up rather than a faithful simulation of the currently active AR0135 DVP capture path.

It includes:

⏰ clock generation
📥 stubbed frame/input stimulus
🔌 I2C simulation support

For faster simulation turnaround, set SIM_I2C = 1 to shrink the I2C configuration sequence to 3 writes.

🕹️ Control Reference

👆 Touch-Screen Commands

Screen UART: 115200 bps, 8-N-1

⌨️ Command	⚙️ Function
`S`	🆕 Start a new game
`@`	✍️ Select Write mode
`#`	🎨 Select Draw mode
`X`	🎮 Select Tic-Tac-Toe mode
`B`	⚫ Set AI side to black (`2'b01`)
`W`	⚪ Set AI side to white (`2'b10`)
`N`	🤖 AI plays first
`M`	🧑 Human plays first
`C`	✅ Confirm the human move is finished
`$`	🏠 Trigger zero/home
`T`	⬆️ Request the touch-screen Z-up helper command
`D`	⬇️ Request the touch-screen Z-down helper command

📨 UART Motion Protocol (Write / Draw modes)

Write and Draw modes are driven by a second UART channel (motion control UART, 115200 bps, 8-N-1) that receives raw XY coordinate strings. This path is handled by Source/bsp/uart_fsm_top.v and its sub-modules fsm_xy_decode.v / fsm_z_decode.v.

📐 XY coordinate format

X<int>.<dec>Y<int>.<dec>\r\n

🏷️ Element	💬 Meaning	📋 Example
`X`	X-axis prefix	`X`
`<int>`	Integer part (signed, multi-digit)	`10`, `-5`
`.`	Decimal separator	`.`
`<dec>`	Decimal part (1–3 digits)	`500` (= 0.500), `0`
`Y`	Y-axis prefix	`Y`
`<int>.<dec>`	Y value (same format as X)	`-5.200`
`\r\n`	Terminator (CR+LF)	implicit

📝 Examples:

📨 Payload	💬 Meaning
`X10.500Y-5.200\r\n`	Move X+10.500, Y−5.200 (relative to current position)
`X0.0Y0.0\r\n`	No-op (zero displacement)
`X-3.0Y2.15\r\n`	Move X−3.000, Y+2.150

The fsm_xy_decode state machine parses each character on-the-fly:

🔍 Wait for X prefix → enter X integer parsing
⚡ On . → switch to X decimal parsing (counts digits for proper scaling)
🔍 On Y → switch to Y parsing
✅ On \r, \n, F, or Z → finalize, latch the parsed values as a relative displacement, and pulse out_en to the motion pipeline.

Each new XY packet computes a delta from the previously latched position, so the motion commands are inherently relative moves.

⬆️⬇️ Z-axis control

The Z-axis is controlled independently via the Z command on the same UART:

📨 Payload	⚡ Action
`Z0.00\r\n` or `Z<any positive>`	⬆️ Z up
`Z-4.00\r\n`	⬇️ Z down

The fsm_z_decode module handles these: a Z followed by - sets Z down; a Z followed by a digit sets Z up.

On the touch-screen UART, T and D are convenience commands that inject these Z messages into the motion UART path. They do not directly toggle the electromagnet in RTL. In Tic-Tac-Toe mode, the electromagnet output is driven by the game-state machine.

⚡ Speed difference: Write vs Draw

🎭 Mode	`function_mode`	⚙️ Stepper DIV	✨ Effect
✍️ Write	`2'b00`	1000	Slower, precise pen strokes for character tracing
🎨 Draw	`2'b01`	800	Faster motion for sketching shapes and lines

The speed is selected in motor_ctrl.v line 21:

assign CLK_DIV = (function_mode != 2'b0) ? 16'd800 : 16'd1000;

🔄 Typical Write / Draw workflow

⚡ Power on, wait for DDR3 calibration and video output to stabilize.
📲 Send @ (Write) or # (Draw) from the touch screen to select the mode.
📨 Send XY coordinate strings over the motion UART to trace the desired path.
⬆️⬇️ Use Z commands to lift and lower the pen between strokes.
🏠 Send $ at any time to zero/home the mechanism.

🎮 Tic-Tac-Toe Workflow

⚡ Power on the board and wait for sensor initialization.
⏳ Wait until DDR3 calibration and video output are stable.
📲 Send X to enter Tic-Tac-Toe mode.
⚫⚪ Send B or W to choose the AI side.
🤖🧑 Send N or M to choose turn order.
🆕 Send S to start a new game.
✅ After the human move, send C to confirm the board update.
🔄 The FPGA resamples the board, computes the next move, and drives the mechanism.
🏆 Winner and tie checks run after each confirmed move.

📋 Implementation Notes

🏗️ Architecture Notes

📹 Video path

📷 camera input is cropped by Source/Sensor_Image_XYCrop.v
💾 frames are buffered through DDR3 by Source/axi/axi4_ctrl.v
📺 display output is generated by Source/lcd_driver.v plus HDMI logic

🎛️ Mode selection

The top-level signal function_mode (2-bit) is decoded in Source/bsp/uart_screen.v from touch-screen UART:

// function_mode: Write=0, Draw=1, Tic-Tac-Toe=2
if (po_data == "@") function_mode <= 2'd0;   // Write
if (po_data == "#") function_mode <= 2'd1;   // Draw
if (po_data == "X") function_mode <= 2'd2;   // Tic-Tac-Toe

This signal controls speed selection in motor_ctrl.v and XY source selection in Uart_Stepper.v. The Tic-Tac-Toe controller remains instantiated at the top level; in practice, function_mode gates whether its generated XY moves are forwarded into the motion pipeline.

✍️🎨 Write / Draw: UART coordinate pipeline

📡 Source/bsp/uart_fsm_top.v: top-level UART motion FSM
📐 Source/bsp/fsm_xy_decode.v: XY coordinate string parser, outputs signed 20-bit integer + decimal pairs
⬆️⬇️ Source/bsp/fsm_z_decode.v: Z-axis command parser (Z- = down, Z<digit> = up)
➕ Source/bsp/add_inte_deci.v: signed fixed-point adder, computes relative displacement between consecutive packets
🗄️ Source/bsp/sync_fifo_cnt.v: FIFO buffer decoupling the UART receive rate from the motion execution rate

The parsed XY deltas feed into Source/bsp/XY_motion.v, which performs a Bresenham-like interpolation:

🔀 When both X and Y need to move, it steps both motors simultaneously (diagonal, D_XIE state).
➡️ When one axis is within 100 units of its target, it switches to single-axis correction (straight, D_ZHI state).
⚙️ Each motor is driven by a dedicated motor_ctrl instance that generates step/direction pulses.

🎮 Tic-Tac-Toe: game logic

🖥️ Source/bsp/uart_screen.v: touch-screen command decode
🎛️ Source/bsp/tictactoe_game_top.v: top-level game sequencing
🧠 Source/bsp/Game_strategies.v: move selection with priority win > block > first empty
🏆 Source/bsp/winner.v: winner and tie evaluation

📊 Board-state detection

The top-level RTL samples fixed video coordinates for the 9 cells and stores the result in an 18-bit current_board signal:

2'b01 = ⚫ black piece
2'b10 = ⚪ white piece
2'b00 = ⬜ empty

Detection thresholds use 40/140, while the HDMI overlay path uses 40/120 through yan_lcd_data for visualization.

⏰ Clocking

The design spans multiple clock domains. Relevant constraints are defined in Efinity/T35_Sensor_DDR3_LCD_Test.sdc.

🕐 Clock	🎯 Purpose
`Axi0Clk`	AXI4 and DDR3-side user logic
`Ddr0Clk`	DDR3 memory interface
`hdmi_clk1x_i`	HDMI pixel clock
`hdmi_clk2x_i`	HDMI serialization clock
`hdmi_clk5x_i`	HDMI TMDS bit clock
`cmos_pclk`	Camera pixel clock
`clk_cmos`	Camera support clock
`tx_slowclk`	UART and game-system clock
`tx_fastclk`	Faster control clock

MIPI-related clocks are still present for alternate sensor integration work.

📊 Resource Utilization

Figures below come from the archived Efinity reports in Efinity/outflow/, generated on November 30, 2024:

📦 Resource	📊 Utilization
🎯 Target device	Efinix Trion T35F324 (C4)
🧮 Logic elements	9122 / 31680 (28.79%)
📐 LUTs / adders	8703 / 31680 (27.47%)
🗂️ Registers	3642 / 30720 (11.86%)
💾 Memory blocks	18 / 288 (6.25%)
✖️ Multipliers / DSP	4 / 120 (3.33%)
🕐 PLLs used	4 (`AxiPLL`, `DdrPLL`, `HdmiPLL`, `MipiPLL`)

⚠️ Known Limitations

📡 The active checked-in capture path is AR0135 over DVP.
🗂️ Alternate sensor configuration files are included, but non-AR0135 paths still need top-level integration.
🔌 MIPI-related ports and constraints are present, but MIPI is not the active capture path.
✍️🎨 Write/Draw modes are functional for UART-driven XY motion; they do not include on-chip font rendering or G-code parsing — the host side must send pre-computed coordinate sequences.
🎮 Tic-Tac-Toe detection relies on fixed sampling coordinates and hard-coded thresholds.
🦾 The physical robot path assumes a calibrated mechanism and coordinate map.

📜 License

This repository includes third-party IP with their own licensing terms. Check file headers and bundled license files before redistribution or reuse.

Source/rgb2dvi/: Digilent license, see License.txt
LCD / I2C modules: CrazyBingo copyright notices
ISP modules: CrazyBird copyright notices
BSP game logic: project-specific competition code

_{🖥️ Built with Verilog HDL on Efinix Trion T35F324 | 🎯 Three modes, one backbone}

Name		Name	Last commit message	Last commit date
Efinity		Efinity
Source		Source
.gitignore		.gitignore
README.md		README.md
README_zh.md		README_zh.md

Latest commit

History

Folders and files

Repository files navigation