Skip to main content

Device Capabilities

The AT1000 Series consists of multiple test sequencer devices, each with its own set of capabilities. Currently, the AT1032S is the only available model, but future models will be introduced with varying features. Understanding a device’s capabilities is essential for configuring test sequences effectively.

Retrieving Device Information​

Users can retrieve comprehensive information about an AT1000 device, including its capabilities, by querying its specifications. The device returns a structured object containing hardware specifications, firmware information, and system status.

Device Object Structure​

The device information is returned as an object with the following top-level fields:

FieldDescription
modelDevice model name (e.g., "AT1032S").
serial_numberUnique serial identifier of the device.
firmware_versionCurrent firmware version installed on the device.
firmware_commitGit commit hash of the firmware build.
disk_totalTotal disk space available on the device in bytes.
disk_usedDisk space currently used on the device in bytes.
docker_usedDisk space used by Docker containers and images in bytes.
capabilitiesObject containing detailed hardware capabilities (see below).

Capabilities Structure​

The capabilities object within the device information contains the following fields:

CapabilityDescription
nameDevice model name (e.g., "AT1032S").
serial_numberUnique serial identifier of the device.
io.countNumber of available general-purpose I/O pins.
io.input_voltageObject defining the general-purpose I/O input voltage range in Volts (e.g., { min: -24, max: 24 }).
io.output_voltageObject defining the general-purpose I/O output voltage range in Volts (e.g., { min: 0, max: 24 }).
relays.countNumber of available dry relay contacts.
relays.max_currentMaximum current per relay contact in Amperes (e.g., 2.0).
relays.max_voltageMaximum voltage per relay contact in Volts (e.g., 60).
relays.on_resistanceTypical on-resistance per relay contact in Ohms (e.g., 0.2).
usb_ports[]Array of USB port objects. Each object typically contains:
   .type      Type of USB port (e.g., "3.0").
   .count      Number of available USB ports of this type.
ethernet[]Array of Ethernet interface objects. Each object typically contains:
   .type      Type of Ethernet interface (e.g., "100BASE-T").
   .count      Number of available Ethernet ports of this type.
communication[]Array of communication interface objects. Each object typically contains:
   .type      Type of interface (e.g., "can", "rs232", "rs485", "i2c", "spi", "uart").
   .count      Number of available interfaces of this type.
power_supply.countNumber of programmable power supplies.
power_supply.output_voltageObject defining the programmable power supply output voltage range in Volts (e.g., { min: 1.5, max: 24 }).
power_supply.current.maxMaximum output current in Amperes for the programmable power supply (e.g., 10).
current_measurement[]Array of current measurement capability objects. Each object typically contains:
   .type      Type of current measurement (e.g., "low_precision", "high_precision").
   .source      Source of the current measurement (e.g., "Power Supply", "USB 1").
   .resolution      Resolution of the current measurement in Amperes.
hmi.display.typeType of HMI display (e.g., "LCD").
hmi.display.sizeObject defining HMI display size in pixels (e.g., { width: 160, height: 80 }).
hmi.input.countNumber of HMI input elements.
hmi.input.typeType of HMI input (e.g., "rotary,push").
hmi.speaker.countNumber of HMI speaker elements.
hmi.speaker.typeType of HMI speaker (e.g., "buzzer").

Example Device Object for AT1032S​

Below is an example of the complete device object returned for the AT1032S:

{
  model: 'AT1032S',
  serial_number: '12345678',
  firmware_version: '1.2.3',
  firmware_commit: 'a1b2c3d4',
  disk_total: 32000000000,
  disk_used: 8500000000,
  docker_used: 2100000000,
  capabilities: {
    name: 'AT1032S',
    serial_number: '12345678',
    io: {
      count: 32,
      input_voltage: { min: -24, max: 24 },
      output_voltage: { min: 0, max: 24 }
    },
    relays: { count: 8, max_current: 2, max_voltage: 60, on_resistance: 0.2 },
    usb_ports: [ { type: '3.0', count: 2 } ],
    ethernet: [ { type: '100BASE-T', count: 1 } ],
    communication: [
      { type: 'can', count: 1 },
      { type: 'rs232', count: 2 },
      { type: 'rs485', count: 2 },
      { type: 'i2c', count: 2 },
      { type: 'spi', count: 2 },
      { type: 'uart', count: 2 }
    ],
    power_supply: {
      count: 1,
      output_voltage: { min: 1.5, max: 24 },
      current: { max: 10 }
    },
    current_measurement: [
      { type: 'low_precision', source: 'Power Supply', resolution: 0.01 },
      { type: 'low_precision', source: 'USB 1', resolution: 0.01 },
      { type: 'low_precision', source: 'USB 2', resolution: 0.01 },
      { type: 'high_precision', source: 'Relay 4', resolution: 0.001 }
    ],
    hmi: {
      display: { type: 'LCD', size: { width: 160, height: 80 } },
      input: { count: 1, type: 'rotary,push' },
      speaker: { count: 1, type: 'buzzer' }
    }
  }
}

How to Query Device Information in Code​

Users can programmatically retrieve complete device information (including capabilities) using the API. Below are examples in both Node.js and Python.

import AT1000 from '@ikalogic/at1000';

let devices = await AT1000.findDevices(500);
if (devices.length == 0) {
    console.log("No devices found");
    process.exit(1);
}

// Loop through devices and print their capabilities in detail
devices.forEach((device, index) => {
    console.log(`\n${"=".repeat(60)}`);
    console.log(`Device ${index + 1}: ${device.device.model}`);
    console.log(`Serial Number: ${device.device.serial_number}`);
    console.log(`Firmware: ${device.device.firmware_version} (${device.device.firmware_commit})`);
    console.log(`${"=".repeat(60)}\n`);
    
    console.log("CAPABILITIES:");
    console.log(JSON.stringify(device.device.capabilities, null, 2));
});

Why Checking Device Information is Important​

  • Future-Proofing: New AT1000 models may have different specifications.
  • Preventing Errors: Ensures your test sequence doesn't exceed device limits.
  • Optimizing Tests: Use the correct power supply, I/O, and voltage ranges for your DUT.
  • System Monitoring: Track disk usage, firmware versions, and system resources.
  • Diagnostics: Access firmware commit information for troubleshooting.

By retrieving device information dynamically, users can write scripts that adapt to different AT1000 models and monitor system health without requiring hardcoded values.