Closed-Loop Edge Automation for High-Volume PCBA Manufacturing.
Test Edge is a deterministic, 5-layer factory automation architecture deployed directly on shop-floor Ubuntu Edge Nodes. It standardizes instrument hardware abstraction (user_defined_hw_measure), central OTA recipe distribution, multi-port parallel execution, predictive X-in-Y fixture maintenance, rework quarantine, and ISO-9001 RBAC governance.
user_defined_hw_measure() HALFactory Telemetry Dashboard
Throughput & Yield Trend
Yield by Test Platform
Platform-Specific Checks
Yield by Central Program
| Program | Runs | Pass | FPY% |
|---|
Product Hierarchy
| Type | Gen | Sub-Ver | Runs | FPY% |
|---|
Lot / Batch Traceability
| Lot ID | SKUs | Runs | Fail | FPY% | Gate |
|---|
| Time | Serial / Port | Lot | Product | Platform/Stn | Program | Measurements | Status / Bin |
|---|
Visual Factory Flow & Live Station Status Map
Filter by Product to see which stations are producing which product (`NVME`, `SSD`, `DDR`, `PC_MB`, `GPU_AI`, `WIFI`), along with Active Lot, Test Program, Loading %, and Technician.
Central Station-to-Program Assignment
Bind Recipe & Limits to Platform / Station
Active Station-to-Recipe & Product Assignment Matrix
| Platform | Station | Product | Assigned Recipe | Mode | Ports | Action |
|---|
Multi-Port PCB Batch Execution & Live Progress Monitor
Test Program Creation Studio (OTPL / Free Python) & Visual Flowchart
Module A: Organize Test Node Types into a 2D Dictionary by (Test Platform × Product Type: NVME, SSD, DDR, PC_MB, GPU_AI, WIFI). Module B: Edit flow order (Up / Down / Delete / Duplicate / Merge to Subflow), assign Trigger Conditions (ON_PASS, ON_FAIL_RECOVERY, NESTED_SUBFLOW), and click any node in the Interactive Visual Flowchart to expand or edit.
Visualizes regular ON_PASS flow, ON_FAIL_RECOVERY branches, and expandable SUBFLOW blocks. Click any flowchart node or subflow below to edit its variables, trigger condition, and child steps directly.
Search All Registered Test Programs (OTPL & Python Recipes across NVME, SSD, DDR, PC_MB, GPU_AI, WIFI)
| Program ID | Platform | Format | SKU | Flow Nodes & Subflows | Stage | Action |
|---|
Test Program Release Status (Code Review / Pilot / Deploy) & Feature Planning
Plan upcoming test capabilities, assign target Product Phase (ES / QS / MP), and track readiness.
| Feature ID | Planned Capability | Platform | Target SKU | Target Milestone | Owner | Status |
|---|
Product Lifecycle Visualizer & Time-Mapped Test Programs
Tracks every Product Family from ES (Engineering Sample) → QS (Qualification Sample) → MP (Mass Production) with time-aligned Test Programs across all 4 Platforms.
TP-*-v1.x-ESTP-*-v2.x-QS / PILOTTP-*-v3.x/v4.x-MPTest Program Quality Performance (Cpk, Gage R&R, NTF & DPPM)
| Test Program ID | Platform | Product SKU | Sample Size | FPY % | Cpk Index | Gage R&R % | False Fail (NTF) | Avg Cycle vs SLA | Grade |
|---|
Test Failure Mode & Fail Bin Code Manager
| Bin Code | Platform | Failure Mode | Bound Test | Cross-Station Action | Hits |
|---|
Station Hardware Wear-Out Alerts (≥ X Fails in Last Y Tests)
Response Flowchart to Fix Hardware (By Fail Bin Code & X-in-Y Rule)
Interactive decision tree showing how a test failure maps to a Fail Bin Code, evaluates the X-in-Y wear-out rule, quarantines problem hardware, tags suspect PCBs for rework, and executes hardware repair.
Hardware Pending Fix: Decide Downtime → Fixing → Release Production
Manage worn or failing test stations/ports through 1) Scheduled Downtime (Quarantined), 2) Active Fixing & Spare Replacement, and 3) Golden-Unit Verification & Release to Production.
Test Hardware Inventory, Spare Stock & Health Status
Tracks active fixture modules, pogo sockets, probe pins, RF cables, and spare stock levels ready for Page 13 maintenance swaps.
| Part SKU | Component Name | Platform | Installed | Spare Stock | Min Safety | Status | Allocate |
|---|
PCB Rework & Retest Queue (Failed Due to Problem Hardware)
Automatically captures finished PCBs that failed on a degraded station/port prior to a Hardware Wear-Out alert so operators can clean, rework, and retest them on a healthy station instead of scrapping good boards.
| PCB Serial Number | Lot / Batch | Product SKU | Failed Station / Port | Fail Bin | Root Cause | Rework / Retest Status | Action |
|---|
Production Engineering Change Notice (ECN / PCN) Registry
| ISO Doc ID | Timestamp | Category | Target | Description & Rollback | Approved By |
|---|
SOP Training Qualification & Scope Access Control Matrix
Requires each role (Technician, Test Engineer, Test Lead, Product Owner) to read, understand, and digitally sign their scope SOPs to unlock module access.
Automated Operations Report (Day / Week / Month)
Filter by Product in Production (`NVME`, `SSD`, `DDR`, `PC_MB`, `GPU_AI`, `WIFI`) to inspect throughput, First-Pass Yield %, top Fail Bins, station utilization, and recovered rework PCBs.
OTPL Visualizer, Live .tpl Source Editor & Single-PCB Flow Simulator
Visualize and edit Advantest T2000 OTPL (Open Architecture Test System Test Programming Language) FlowItem nodes, edit variables, configure node characteristics (FAIL_STOP, EDC_LOG, CONTINUE_ON_FAIL, RETEST_1X), and push directly to Test Stations (Page 5).
MainFlow)
TP-FVT-NVME-v5.2.tpl
.tpl)
.py)
AUTO-TRANSPILED
Product Master Record: Team, Timeline, Technical Spec & Production Status
Centralized master record for each Product Type → Generation → Sub-Version (`DRAM/DDR`, `NVME`, `SSD`, `PC_MB`, `GPU_AI`, `WIFI`), logging engineering team ownership, lifecycle timeline, hardware specifications, live production status, and audit history.
| Record ID / Time | Product / Gen / Sub-Ver | Category | Master Record Details | Author / Rev |
|---|
Statistical Definitions (`Cpk`, `Gage R&R`, `NTF`, `DPPM`), Bad-HW Logic & Custom User Rules
Full engineering reference for all statistical formulas and hardware degradation algorithms used across Test Edge — plus an open rule builder for users to define and customize their own production rules.
Process Capability Index (`Cpk`)
Measures how well a hardware measurement (e.g. `3.30V rail` or `PCIe Eye UI`) fits inside its Upper/Lower Spec Limits (`USL`/`LSL`) relative to 3σ process spread.
Measurement Repeatability & Reproducibility
Quantifies how much variation comes from the test fixture/instrument (`EV` Repeatability across re-insertions + `AV` Reproducibility across stations/ports) vs actual PCB variation.
No Trouble Found / False Reject Rate
Percentage of PCBs that fail on 1st pass (`Port A`) but pass immediately when retested on a golden/alternate port (`Port B`) without any soldering rework.
Defective Parts Per Million
Projects outgoing defect escape rate per 1,000,000 shipped PCBs based on tail distribution beyond `LSL`/`USL` and final OQA audit sampling.
Define your own custom statistical quality gates or bad-hardware detection rules. Rules run continuously against incoming station telemetry and trigger automated shop-floor actions.
| Rule ID | Scope | Condition & Window | Automated Action | Active |
|---|
About Test Edge, Production Deployment Architecture & PostgreSQL Connectivity
Our mission, target manufacturing customers, end-to-end shop-floor data path, and how to connect to either your Customer Enterprise PostgreSQL Database or our Internal Edge Docker PostgreSQL Database.
Test Edge was built to eliminate fragmented, unversioned test scripts on factory floors. In traditional PCBA and semiconductor module manufacturing, test stations run isolated local scripts with no central OTA recipe control, no automatic detection of worn test sockets (`X-in-Y`), and manual spreadsheet reporting.
High-density multi-port FVT and Burn-In lines requiring per-slot eye margin, LDPC BER, and thermal soak tracking.
ComplexICT boundary-scan, multiphase VRM ripple, BMC IPMI handshake, and high-power liquid-cooled burn-in stations.
High-mix factories switching stations between customer SKUs daily that need instant OTA recipe binding and ISO-9001 RBAC locks.
Engineering teams bridging Advantest T2000 OTPL `.tpl` flows and Python `pytest` suites from ES/QS bring-up into Mass Production.
# 1. docker-compose.yml (Internal Edge PostgreSQL + FastAPI)
services:
postgres-edge:
image: postgres:16-alpine
environment:
POSTGRES_USER: edge_admin
POSTGRES_PASSWORD: edge_secret
POSTGRES_DB: test_edge_local
ports: ["5432:5432"]
volumes: ["pg_edge_data:/var/lib/postgresql/data"]
# 2. FastAPI Dual-Database Connector (app/db.py)
from sqlalchemy import create_engine, text
import os
EDGE_DB_URL = os.getenv("EDGE_DB_URL", "postgresql://edge_admin:edge_secret@localhost:5432/test_edge_local")
CUSTOMER_DB_URL = os.getenv("CUSTOMER_DB_URL", "postgresql://mes_writer:prod_pass@pg.customer.corp:5432/factory_mes_prod")
edge_engine = create_engine(EDGE_DB_URL, pool_pre_ping=True)
customer_engine = create_engine(CUSTOMER_DB_URL, pool_pre_ping=True) if CUSTOMER_DB_URL else None
def record_pcb_test_run(run_payload: dict):
sql = text("""
INSERT INTO pcb_test_runs
(run_id, sn, batch_id, prod_type, prod_gen, prod_subver, platform_id, station_id, port_id, program_id, overall_pass, fail_bin, cycle_time_s, measurements_json)
VALUES (:id, :sn, :batch, :prodType, :prodGen, :prodSubVer, :platform, :station, :portId, :program, :overallPass, :failBin, :cycleTime, CAST(:metrics AS jsonb))
""")
# Always commit to local Edge PostgreSQL first (< 2ms latency)
with edge_engine.begin() as conn:
conn.execute(sql, run_payload)
# Mirror to Customer Enterprise PostgreSQL (or queue if offline)
if customer_engine:
with customer_engine.begin() as cust_conn:
cust_conn.execute(sql, run_payload)
Simple, Modular Pricing Built for Manufacturing Teams
Start with the complete 23-page interactive UI portal, step up to the full Python + FastAPI + Pytest + PostgreSQL starter codebase, or engage our team for a turnkey factory floor deployment.
Complete Single-Page Industrial Dark-Mode HTML/JS/Tailwind UI Portal (`index.html`) with all 23 interactive modules, simulated telemetry, flowcharts, and OTPL/Python visual studio.
Includes everything in Tier 1 (`$500` UI) plus the working Python 3.10+ FastAPI backend, `pytest --json-report` subprocess runner, `user_defined_hw_measure()` HAL framework, and Docker Compose stack.
End-to-end engineering deployment on your factory floor across `PLT-ICT`, `PLT-FVT`, `PLT-BI`, and `PLT-RF-SYS`, integrated with your real test instruments and enterprise PostgreSQL / MES database.