Test Adapter

1 What is the Test Adapter?

The Test Adapter (ta_eolt_stripped) is a standalone binary you deploy to a Charge Controller over SSH. Once running, it exposes an HTTP API on port 8888.

Use the Test Adapter to:

Test hardware: buzzer, LEDs, RFID, contactors, CP/ADC, emergency opener, temperature sensors, and more
Read device info: MAC address, serial number, firmware version, system info
Write persistent settings: serial numbers, passwords, and other configuration parameters that survive reboots
Control peripherals: Modbus meters, PLC, GSM modems, WLAN, GPIO pins

All endpoint responses are returned as XML.

Key facts:

The HTTP API root is http://<controller-ip>:8888.
Exact endpoint paths are listed in the Test Adapter documentation PDF.
The binary runs from /tmp and is lost on every reboot.
Starting the Test Adapter stops the Controller software.
The Controller software resumes normal operation after a reboot.

info

Starting the Test Adapter interrupts normal Controller software operation until the next reboot. This is intended.

2 Test Adapter API overview

All endpoints use the HTTP API root http://<controller-ip>:8888. See the full PDF reference for all parameters and response formats.

Category⬍	Module⬍	Endpoint⬍	Description⬍
# Hardware testing	Buzzer	`/diag/buzzer`	Test buzzer output
# Hardware testing	CP and ADC	`/diag/cp`	Set CP pulse width and relay, read ADC channels
# Hardware testing	Contactor	`/diag/powerctrl`	Open or close the contactor on systems 5.10 and above
# Hardware testing	Emergency Opener	`/diag/eo`	Read EO state, control actuator, run EO test functions
# Configuration	FileIO	`/diag/fileio`	Read, write, and delete files on the controller
# Hardware testing	GPIO	`/diag/gpio`	Set direction and read/write GPIO pins
# Hardware testing	GPIO PIC	`/diag/picgpio`	Set direction and read/write PIC GPIO pins
# Communication	GSM	`/diag/gsm`	Read modem info, SIM status, network status, and execute AT commands
# Hardware testing	Heater	`/diag/heater`	Control heater percentage
# Hardware testing	LEDs	`/diag/leds`	Test LED states, colors, and patterns
# Communication	Modbus Meter	`/diag/meter`	Initialize meter communication and read Modbus registers
# Communication	Network	`/network/[interface]`	Read and configure network interfaces, MAC address, and ping
# Hardware testing	Phase Monitor	`/diag/phasemon`	Read phase monitor frequency, state, and rotation
# Communication	PLC	`/network/plc`	Set up and check PLC/qca0 communication
# Hardware testing	RCMB	`/diag/rcmb`	Read RCMB values, version, PE check, self-test, and reset functions
# Hardware testing	RFID	`/diag/rfid`	Read RFID tag from the RFID reader
# Device info	SysInfo	`/diag/sysinfo`	Check whether the system is safe to reboot during update workflows
# Hardware testing	Temperature	`/diag/temperature`	Read board temperature values
# Hardware testing	UART	`/diag/serial`	Open, close, send, and receive hex strings on UART devices
# Hardware testing	USB Devices	`/diag/usb`	Detect USB block devices and control smart hub ports
# Device info	Versions	`/diag/version`	Read software, kernel, hardware, and Test Adapter versions
# Configuration	Whitelist	`/diag/whitelist`	List, add, and clear RFID whitelist/cache entries
# Communication	WLAN	`/network/wifi`	Connect to Wi-Fi, kill DHCP client, and read WLAN status
# Hardware testing	I2C	`/diag/i2c`	Write, read, and write-read raw I2C data
# Configuration	Settings	`/diag/settings`	Read, write, and delete `persistency`, `nor_store`, and `otp` values

3 Limitations

GPIO that are configured in persistency are not accessible in Test Adapter mode.

4 Core reference documentation

The central reference for this method is the Test Adapter documentation PDF:

Test Adapter Documentation (V1.40 / V1.43.0)

Use this PDF as the primary reference for adapter/API behavior, endpoint paths, request parameters, response formats, and test-specific details.

5 Workflow overview

6 Streamlined example script

This script shows a basic single-unit workflow with SSH provisioning, Test Adapter deployment, Test Adapter API calls, and final verification.

# ── Configuration ──
$ControllerIp       = "192.168.123.123"
$ChargePointId      = "CC-UNIT-001"
$SerialNumber       = "SN-2026-00001"
$TestAdapterBinary  = "ta_eolt_stripped"
$Persistency        = "/home/charge/persistency"
$TestAdapterBaseUrl = "http://${ControllerIp}:8888"

# Taken from the SSH provisioning cookbook.
function Send-ConfigFile {
    param([string]$FileName, [string]$Value)

    Set-Content -Path ".\$FileName" -Value $Value -NoNewline
    scp -O ".\$FileName" "charge@${ControllerIp}:${Persistency}/${FileName}"
}

# ── 1. Set basic SSH provisioning values ──
Send-ConfigFile "ChargeBoxIdentity_custom" $ChargePointId
Send-ConfigFile "SerialNumberManufacturer_custom" $SerialNumber

ssh "charge@$ControllerIp" "sync"

# ── 2. Deploy and start the Test Adapter ──
scp -O ".\$TestAdapterBinary" "root@${ControllerIp}:/tmp/ta_eolt_stripped"

ssh "root@$ControllerIp" "chmod +x /tmp/ta_eolt_stripped && nohup /tmp/ta_eolt_stripped > /tmp/ta_eolt.log 2>&1 &"

Start-Sleep -Seconds 3

# ── 3. Run basic Test Adapter calls ──
Invoke-WebRequest "$TestAdapterBaseUrl/diag/version?cmd=get" -UseBasicParsing

Invoke-WebRequest "$TestAdapterBaseUrl/diag/settings?cmd=set&what=persistency&key=SerialNumber_custom&value=$SerialNumber" -UseBasicParsing
Invoke-WebRequest "$TestAdapterBaseUrl/diag/settings?cmd=get&what=persistency&key=SerialNumber_custom" -UseBasicParsing

# ── 4. Reboot to return to normal Controller software operation ──
ssh "root@$ControllerIp" "sync && reboot"

# ── 5. Wait for reboot, then verify via SSH ──
Write-Host "Waiting for controller to come back up..."
Start-Sleep -Seconds 90

ssh "charge@$ControllerIp" @"
echo '=== Firmware ==='
head -n 1 /tmp/.ebee_version_info.txt

echo '=== Charge Point ID ==='
head -n 1 /home/charge/persistency/ChargeBoxIdentity_custom

echo '=== Manufacturer Serial Number ==='
head -n 1 /home/charge/persistency/SerialNumberManufacturer_custom

echo '=== Controller Serial Number ==='
head -n 1 /home/charge/persistency/SerialNumber_custom

echo '=== MAC Address ==='
head -n 1 /sys/class/net/eth0/address
"@

7 Setup

Deploy the Test Adapter binary to the controller and start it.

7.1 1. Copy the binary

Shell
Python

scp -O ta_eolt_stripped root@192.168.123.123:/tmp/ta_eolt_stripped

import paramiko
from scp import SCPClient

def copy_test_adapter(host="192.168.123.123"):
    ssh = paramiko.SSHClient()
    ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
    ssh.connect(host, username="root", password="orange_zone")

    with SCPClient(ssh.get_transport()) as scp:
        scp.put("ta_eolt_stripped", "/tmp/ta_eolt_stripped")

    ssh.exec_command("chmod +x /tmp/ta_eolt_stripped")
    ssh.close()

copy_test_adapter()

7.2 2. Start the Test Adapter

Shell
Python

ssh root@192.168.123.123

chmod +x /tmp/ta_eolt_stripped
nohup /tmp/ta_eolt_stripped > /tmp/ta_eolt.log 2>&1 &

import paramiko

def start_test_adapter(host="192.168.123.123"):
    ssh = paramiko.SSHClient()
    ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
    ssh.connect(host, username="root", password="orange_zone")

    ssh.exec_command("chmod +x /tmp/ta_eolt_stripped")
    ssh.exec_command("nohup /tmp/ta_eolt_stripped > /tmp/ta_eolt.log 2>&1 &")
    ssh.close()

start_test_adapter()

The Test Adapter is now running. The Controller software is stopped and the HTTP API is available on port 8888.

8 Usage

8.1 Calling an endpoint

Every endpoint returns an XML response. The exact endpoint paths and parameters are listed in the Test Adapter documentation PDF.

Example: reading the firmware version (works on every controller, no additional hardware needed).

Shell
Python

curl "http://192.168.123.123:8888/diag/version?cmd=get"

Response:

<?xml version="1.0"?>
<response>
  <result>success</result>
  <sw_version>5.34.1</sw_version>
  <kernel_version>5.10.0</kernel_version>
  <hw_version>ICC1324</hw_version>
  <ta_version>1.43.0</ta_version>
</response>

import requests

response = requests.get("http://192.168.123.123:8888/diag/version?cmd=get")
print(response.text)

8.2 Writing a persistent setting

Use the Test Adapter settings endpoint to write values that persist across reboots, for example a controller serial number.

Shell
Python

# Write
curl "http://192.168.123.123:8888/diag/settings?cmd=set&what=persistency&key=SerialNumber_custom&value=12345"

# Read back
curl "http://192.168.123.123:8888/diag/settings?cmd=get&what=persistency&key=SerialNumber_custom"

import requests

base_url = "http://192.168.123.123:8888"

# Write
requests.get(
    f"{base_url}/diag/settings",
    params={
        "cmd": "set",
        "what": "persistency",
        "key": "SerialNumber_custom",
        "value": "12345",
    },
)

# Read back
response = requests.get(
    f"{base_url}/diag/settings",
    params={
        "cmd": "get",
        "what": "persistency",
        "key": "SerialNumber_custom",
    },
)

print(response.text)

8.3 When you're done

Reboot the controller to return to normal operation. The Test Adapter binary is removed automatically because it lives in /tmp.

Shell
Python

ssh root@192.168.123.123 "sync && reboot"

import paramiko

def reboot_controller(host="192.168.123.123"):
    ssh = paramiko.SSHClient()
    ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
    ssh.connect(host, username="root", password="orange_zone")

    ssh.exec_command("sync && reboot")
    ssh.close()

reboot_controller()

1 What is the Test Adapter?​

2 Test Adapter API overview​

3 Limitations​

4 Core reference documentation​

5 Workflow overview​

6 Streamlined example script​

7 Setup​

7.1 1. Copy the binary​

7.2 2. Start the Test Adapter​

8 Usage​

8.1 Calling an endpoint​

8.2 Writing a persistent setting​

8.3 When you're done​