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").
hostnameDevice network hostname (e.g., "AT1032S-000022").
serial_numberUnique serial identifier of the device.
firmware_versionCurrent firmware version installed on the device.
firmware_commitGit commit hash of the firmware build.
hardware_versionHardware revision of the device.
epoch_secondsCurrent device time as a Unix epoch timestamp in seconds.
disk_usedDisk space currently used on the device in bytes.
disk_totalTotal disk space available on the device in bytes.
docker_usedDisk space used by Docker containers and images in bytes.
ram_usedRAM currently used on the device in bytes.
ram_totalTotal RAM available on the device in bytes.
cpu_temperatureCurrent CPU temperature in degrees Celsius.
capabilitiesObject containing detailed hardware capabilities (see below).

Capabilities Structure​

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

CapabilityDescription
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: 0, max: 24 }). The usable programmable range is 1.6–13 V, or a fixed 24 V.
power_supply.current.maxMaximum output current in Amperes for the programmable power supply (e.g., 2).
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',
  hostname: 'AT1032S-000022',
  serial_number: '4010328000022',
  firmware_version: '0.3.3',
  firmware_commit: '11b6715',
  hardware_version: '1',
  epoch_seconds: 1723754835,
  disk_used: 2617159680,
  disk_total: 25798799360,
  docker_used: 2100000000,
  ram_used: 512000000,
  ram_total: 2048000000,
  cpu_temperature: 42.5,
  capabilities: {
    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: 1 },
      { type: 'rs485', count: 2 },
      { type: 'i2c', count: 2 },
      { type: 'spi', count: 2 },
      { type: 'uart', count: 2 }
    ],
    power_supply: {
      count: 1,
      output_voltage: { min: 0, max: 24 },
      current: { max: 2 }
    },
    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 0', resolution: 1e-6 }
    ],
    hmi: {
      display: { type: 'LCD', size: { width: 160, height: 80 } },
      input: { count: 1, type: 'rotary,push' },
      speaker: { count: 1, type: 'buzzer' }
    }
  }
}
note

The capabilities report describes the interface that is controllable through the API. The ethernet count shown above (1) is what the device actually returns from GET /management/info.

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();
if (devices.length == 0) {
    console.log("No devices found");
    process.exit(1);
}

// Loop through discovered hosts, open each, and print its capabilities
for (const [index, host] of devices.entries()) {
    const tester = await AT1000.open(host, { readonly: true });
    // `tester.info` is cached at open; `tester.management.info()` fetches fresh data
    const info = tester.info;
    console.log(`\n${"=".repeat(60)}`);
    console.log(`Device ${index + 1}: ${info.model}`);
    console.log(`Serial Number: ${info.serial_number}`);
    console.log(`Firmware: ${info.firmware_version} (${info.firmware_commit})`);
    console.log(`${"=".repeat(60)}\n`);

    console.log("CAPABILITIES:");
    console.log(JSON.stringify(info.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.