ESH10000543 - Fixture Link Module

Overview

The ESH10000543 is a communication interface module providing UART connectivity and power management for intelligent test fixtures with multi-channel fixture detection, ready status monitoring, and individual I²C channel control.

Description

The Fixture Link module serves as the communication bridge between Accordion test systems and intelligent test fixtures. It provides UART-based communication, fixture power management, presence detection for up to 4 fixtures, ready status monitoring, and independent I²C channel enable control, making it ideal for distributed fixture architectures and automated test equipment integration.

Key Features:

• UART Communication: High-speed RS232 communication link

  • Baudrate: 9600 (default)
  • Device: /dev/serial0
  • Enable control (UART_ENn signal)

• Multi-Fixture Support: 4-channel fixture interface

  • Presence detection (PIDET1-4)
  • Ready status monitoring (READY1-4)
  • Individual fixture identification
  • Hot-plug detection capability

• Power Management: Centralized fixture power control

  • Power enable control (POWER_EN)
  • Power fault detection (POWFAULTn, active-low)
  • Automatic power latch reset (25ms delay on module reset)

• I²C Channel Control: 4 independent I²C channel enables

  • Individual enable control (I2C1-4_EN)
  • Dedicated communication paths per fixture
  • Isolated channel operation

• Visual Indication: Status LED control

  • Blue LED for system status (BLUE_LEDn, active-low)
  • User-controllable via GPIO

Note: All GPIO control signals (UART_ENn, POWER_EN, I2C1-4_EN, READY1-4, PIDET1-4, POWFAULTn, BLUE_LEDn) are currently configured as ReadOnlySystemControl but can be changed to UserAllocatable by modifying the usage flag in the source code.

Hardware Details

GPIO Expander:

• Chip: NXP PI4IOE5V6416
• I²C Address: 0x20
• Channels: 16 digital I/O (2 ports × 8 pins)
• Communication: I²C bus
• Purpose: Fixture control, status monitoring, power management, LED control

UART Interface:

• Device: /dev/serial0 (system UART)
• Bus Type: RS232
• Baudrate: 9600 (default)
• Enable: Active-low UART_ENn signal
• Communication: Delegated to parent control module

Channel Naming Convention

All channels follow the naming pattern: {ModuleIndex}.ESH10000543.{ChannelName}

Where:

• {ModuleIndex} is the position of the module in the system (e.g., 0, 1, 2...)
• ESH10000543 is the module type identifier
• {ChannelName} is the specific channel name from the table below

Example: Module at position 0, UART channel would be: 0.ESH10000543.UART

User-Accessible Channels

Total User Channels: 1 (UART only)

Note: Currently, only the UART channel is exposed as UserAllocatable. All GPIO control signals are ReadOnlySystemControl and not directly accessible to users, but this can be changed in the source code by modifying the usage variable in the SetupGpioExpander() method (line 50-51).

Internal Channels (Not User-Accessible)

The following channels are used for internal system control and are currently hidden from users (all ReadOnlySystemControl):

Communication & Power Control:

• UART_ENn (OUT, default=true): UART enable control (active-low, false=enabled)
• POWER_EN (OUT, default=false): Fixture power enable (true=enabled)

I²C Channel Control:

• I2C1_EN (OUT, default=false): I²C channel 1 enable
• I2C2_EN (OUT, default=false): I²C channel 2 enable
• I2C3_EN (OUT, default=false): I²C channel 3 enable
• I2C4_EN (OUT, default=false): I²C channel 4 enable

Fixture Status Monitoring:

• READY1 (IN): Fixture 1 ready status
• READY2 (IN): Fixture 2 ready status
• READY3 (IN): Fixture 3 ready status
• READY4 (IN): Fixture 4 ready status

Fixture Presence Detection:

• PIDET1 (IN): Fixture 1 presence detection
• PIDET2 (IN): Fixture 2 presence detection
• PIDET3 (IN): Fixture 3 presence detection
• PIDET4 (IN): Fixture 4 presence detection

Power & Status:

• POWFAULTn (IN): Power fault indicator (active-low, false=fault detected)
• BLUE_LEDn (OUT, default=true): Blue status LED (active-low, false=on)

Channel Configuration

UART Configuration

Configure UART communication parameters:

ConfigureChannels(new[] {
    new UartChannel {
        NetName = "0.ESH10000543.UART",
        Enabled = true,
        BusType = UartBusTypes.RS232,
        Baudrate = 115200,  // Change from default 9600
        DeviceName = "/dev/serial0"
    }
});

Programming Interface

UART Communication:

// Send command to fixture
SetValues(
    new[] { "0.ESH10000543.UART" },
    new[] { "FIXTURE_CMD:INIT\r\n" }
);

// Read response from fixture
string[] response = GetValues(new[] { "0.ESH10000543.UART" });
Console.WriteLine($"Fixture response: {response[0]}");

UART Transaction Examples:

// Configure fixture
SetValues(
    new[] { "0.ESH10000543.UART" },
    new[] { "CONFIG:MODE,AUTO\r\n" }
);

Thread.Sleep(100);  // Allow fixture to process

// Query fixture status
SetValues(
    new[] { "0.ESH10000543.UART" },
    new[] { "STATUS?\r\n" }
);

string[] status = GetValues(new[] { "0.ESH10000543.UART" });

Internal Operation

Power Management

The module implements automatic power management during reset:

// Reset sequence (internal)
System.Threading.Thread.Sleep(25);  // Sleep to reset power latch (if tripped)
SetGpio("POWER_EN", true);  // Enable fixture power

This 25ms delay allows the power latch to reset if a fault condition previously triggered.

I²C Channel Enablement

All I²C channels are enabled by default on reset:

// Default I²C configuration (internal)
SetGpio("I2C1_EN", true);
SetGpio("I2C2_EN", true);
SetGpio("I2C3_EN", true);
SetGpio("I2C4_EN", true);

Status LED Control

The blue status LED is turned on (active-low) during reset:

// LED control (internal)
SetGpio("BLUE_LEDn", false);  // LED on (active-low)

UART Enable/Disable Delegation

UART enable/disable is delegated to the parent control module:

public override void EnableChannel(DeviceTypes type, string sourceBusChannel, byte channel)
{
    Parent.EnableChannel(type, sourceBusChannel, channel);  // Delegate to Control module

    if (type == DeviceDefinitions.DeviceTypes.UART)
    {
        SetGpio("UART_ENn", false);  // Active-low enable
        gpio.Update();
    }
}

Invalidate() Monitoring

The module includes (currently disabled) polling for fixture status and power faults:

// Status monitoring (disabled by default, commented out in code)
if (!GetGpio("POWFAULTn"))
{
    Logger.Warn(log4net, "Power fault detected on Fixture link");
}

// Poll ready status for all fixtures
Logger.Info(log4net, $"READY1 => {GetGpio("READY1")}");
Logger.Info(log4net, $"READY2 => {GetGpio("READY2")}");
Logger.Info(log4net, $"READY3 => {GetGpio("READY3")}");
Logger.Info(log4net, $"READY4 => {GetGpio("READY4")}");

// Poll presence detection for all fixtures
Logger.Info(log4net, $"PIDET1 => {GetGpio("PIDET1")}");
Logger.Info(log4net, $"PIDET2 => {GetGpio("PIDET2")}");
Logger.Info(log4net, $"PIDET3 => {GetGpio("PIDET3")}");
Logger.Info(log4net, $"PIDET4 => {GetGpio("PIDET4")}");

Note: This monitoring is currently disabled (early return in Invalidate() method) but can be enabled by removing the return; statement on line 138.

Error Handling

The module validates operations and provides error messages:

• Channel Not Found: Throws exception if channel does not exist
• Unsupported Channel Type: Digital and UART channels only
• Boolean Parse Errors: Digital channels require valid boolean values
• GPIO Communication Errors: Logged and propagated to caller

Best Practices

1. UART configuration: Set appropriate baudrate before communication
2. Power sequencing: Module automatically enables power on reset with 25ms latch reset delay
3. I²C channel management: All I²C channels enabled by default; disable unused channels if needed
4. Fault monitoring: Enable Invalidate() polling to monitor power faults and fixture status
5. Fixture detection: Use PIDET signals to detect fixture presence before attempting communication
6. Ready status: Check READY signals before sending commands to fixtures
7. Status LED: Use BLUE_LEDn for visual system status indication
8. Channel exposure: Modify source code to change GPIO channels from ReadOnlySystemControl to UserAllocatable if direct access is needed

Module Initialization Sequence

On Reset(), the module performs:

1. Clear existing channel list
2. Setup GPIO expander (PI4IOE5V6416 at 0x20):
   • Create 16 digital channels (all currently ReadOnlySystemControl):
     • Port 0: UART_ENn, POWER_EN, I2C1-4_EN, READY1-2
     • Port 1: READY3-4, PIDET1-4, POWFAULTn, BLUE_LEDn
   • Reset and update GPIO expander
   • Add channels to module collection
3. Power management:
   • Sleep 25ms to reset power latch (if previously tripped)
   • Enable fixture power (POWER_EN = true)
4. I²C channel configuration:
   • Enable all I²C channels (I2C1-4_EN = true)
5. Status LED:
   • Turn on blue LED (BLUE_LEDn = false, active-low)
6. Update GPIO hardware: Apply all settings
7. Add UART channel:
   • NetName: {ModuleIndex}.ESH10000543.UART
   • BusType: RS232
   • Baudrate: 9600
   • DeviceName: /dev/serial0
   • Usage: UserAllocatable

Typical Use Cases

1. Basic Fixture Communication:

// Send initialization command
SetValues(
    new[] { "0.ESH10000543.UART" },
    new[] { "INIT\r\n" }
);

Thread.Sleep(100);

// Read response
string[] response = GetValues(new[] { "0.ESH10000543.UART" });
Console.WriteLine($"Fixture initialized: {response[0]}");

2. Fixture Identification:

// Query fixture identity
SetValues(
    new[] { "0.ESH10000543.UART" },
    new[] { "*IDN?\r\n" }
);

Thread.Sleep(50);

string[] identity = GetValues(new[] { "0.ESH10000543.UART" });
Console.WriteLine($"Fixture: {identity[0]}");

3. Command-Response Pattern:

// Generic command helper
string SendCommand(string command)
{
    SetValues(
        new[] { "0.ESH10000543.UART" },
        new[] { command + "\r\n" }
    );

    Thread.Sleep(100);  // Allow fixture processing time

    string[] response = GetValues(new[] { "0.ESH10000543.UART" });
    return response[0];
}

// Usage
string version = SendCommand("VERSION?");
string status = SendCommand("STATUS?");
SendCommand("START_TEST");

4. Multi-Step Test Sequence:

// Configure fixture for test
void ConfigureFixture()
{
    SendCommand("RESET");
    Thread.Sleep(500);  // Allow reset

    SendCommand("SET:VOLTAGE,5.0");
    SendCommand("SET:CURRENT,1.0");
    SendCommand("SET:MODE,AUTO");

    string ready = SendCommand("READY?");
    if (ready.Contains("OK"))
        Console.WriteLine("Fixture configured and ready");
    else
        throw new Exception($"Fixture not ready: {ready}");
}

Debugging and Troubleshooting

Problem: UART communication fails

• Check: UART_ENn is properly controlled (active-low, false=enabled)
• Check: Baudrate matches fixture expectations (default 9600)
• Check: /dev/serial0 device exists and has proper permissions
• Action: Verify UART enable delegation to parent module

Problem: Fixture not responding

• Check: POWER_EN is enabled (should be true after reset)
• Check: POWFAULTn is not indicating fault (should be true/high)
• Check: Fixture is physically connected and powered
• Action: Enable Invalidate() monitoring to check READY status

Problem: Cannot access GPIO control signals

• Check: GPIO channels are currently ReadOnlySystemControl
• Action: Modify source code line 50-51 to set usage = MpioUsageTypes.UserAllocatable;
• Rebuild: Recompile module to expose GPIO channels

Problem: Power fault detected

• Check: POWFAULTn signal via internal monitoring
• Check: Fixture power consumption within limits
• Action: Module automatically attempts latch reset on next reset (25ms delay)
• Verify: Power supply to fixture is adequate

Problem: I²C channels not working

• Check: I2C1-4_EN signals are enabled (should be true after reset)
• Check: Individual I²C channel routing to fixtures
• Action: Verify I²C bus connections to fixture interfaces

Design Rationale

GPIO Access Limitation: The module currently sets all GPIO control channels to ReadOnlySystemControl (line 50) instead of UserAllocatable. This design choice:

• Prevents accidental misconfiguration of critical fixture control signals
• Ensures power and I²C enables are managed by the module's initialization sequence
• Can be easily changed by uncommenting line 51 (usage = MpioUsageTypes.UserAllocatable;)

Invalidate() Disabled: The fixture status monitoring in Invalidate() is disabled by default (line 138: return;). This:

• Reduces I²C bus traffic when status polling is not needed
• Allows users to enable monitoring on-demand by removing the early return
• Provides logging infrastructure for fault detection and fixture state tracking

Delegation Pattern: UART enable/disable operations are delegated to the parent control module, enabling:

• Centralized UART resource management
• Coordinated communication across multiple modules
• Simplified bus arbitration and conflict prevention

Comparison with Direct Fixture Interface

Revision History

• ESH10000543: Current production version
  • PI4IOE5V6416 GPIO expander (16 channels, I²C 0x20)
  • UART communication (RS232, 9600 baud, /dev/serial0)
  • 4-channel fixture support (PIDET1-4, READY1-4)
  • 4 independent I²C channel enables (I2C1-4_EN)
  • Power management (POWER_EN, POWFAULTn)
  • Blue status LED (BLUE_LEDn, active-low)
  • GPIO control (currently ReadOnlySystemControl)
  • Disabled status polling (can be enabled in source)