First 60 Minutes: From Installation to a Supportable Run

This is the recommended first-launch checklist for a new ChargeLink Native workstation. The goal is not only to prove that the software starts, but to leave the machine in a state that another engineer can understand, repeat, and support.

Use this page on a clean customer workstation. Do not skip a failed step and continue. A later protocol error is much harder to diagnose if installation, licensing, networking, or the gRPC service was never proven first.

What you will prove

By the end of the hour you should have evidence that:

• the installed CLI can be located and executed;
• the installed version and license are known;
• the environment doctor passes or has understood warnings;
• charger profiles can be discovered;
• the native gRPC agent starts and answers health requests;
• a deterministic local EVSE/EVCC flow can run without physical power hardware;
• artifacts can be found and retained;
• the workstation can produce a support bundle if the next step fails.

0-10 minutes — establish the installation identity

Open PowerShell as the normal ChargeLink operator account.

$CL = 'C:\Program Files\ChargeLink Native\bin\chargelink.exe'
$Data = 'C:\ChargeLinkData'
$License = "$Data\licenses\customer.cllic"

Test-Path $CL
& $CL --version
& $CL --help

Expected result:

• Test-Path returns True.
• --version prints the installed ChargeLink Native version.
• --help shows the customer CLI commands.

If Test-Path is false, stop and return to Install and Activate. Do not copy an executable from another machine as a workaround.

Create the customer data roots once:

New-Item -ItemType Directory -Force "$Data\runtime" | Out-Null
New-Item -ItemType Directory -Force "$Data\artifacts" | Out-Null
New-Item -ItemType Directory -Force "$Data\support" | Out-Null

10-20 minutes — prove licensing and environment health

& $CL --json license verify --file $License
& $CL --json license status
& $CL --json license entitlements
& $CL --json doctor

For a stricter workstation check:

& $CL --json doctor --strict

Expected result:

• the supplied license verifies;
• active entitlements correspond to the purchased product variant;
• the doctor command returns no unexplained fatal condition.

A warning is not automatically a failure. For example, a physical CAN adapter can be absent on a workstation used only for ISO 15118 Ethernet testing. Record why each warning is acceptable.

20-30 minutes — discover profiles before starting a protocol

Never assume a profile ID from an old test procedure. Ask the installed release:

& $CL --json profile list
& $CL profile connectors

Then inspect the profile you plan to use:

& $CL profile show iso15118_20_dc

If your installed build uses another profile ID, use the ID returned by profile list. A profile is the operating contract for role, charging mode, authorization/security behavior, limits, and protocol-specific defaults.

30-40 minutes — start and prove the gRPC agent

Open PowerShell window 1 and keep it running:

& $CL `
  --runtime-root "$Data\runtime" `
  --artifact-root "$Data\artifacts" `
  integration serve `
  --listen 127.0.0.1:50051 `
  --state-root "$Data\runtime\grpc"

Open PowerShell window 2:

& $CL --json integration health --endpoint http://127.0.0.1:50051
& $CL --json integration capabilities --endpoint http://127.0.0.1:50051
& $CL --json integration session-smoke `
  --endpoint http://127.0.0.1:50051 `
  --protocol iso15118-20 `
  --role evse

Expected result:

• health returns a healthy server identity/version;
• capabilities returns the services and product capabilities available in the installed edition;
• session-smoke completes a create/start/stop/delete lifecycle through the public gRPC API.

If health fails, do not continue to VeriStand or external automation. Resolve the gRPC service first.

40-50 minutes — run a safe local protocol proof

First validate the EVSE configuration without opening a live charging connection:

& $CL --json `
  --runtime-root "$Data\runtime" `
  --artifact-root "$Data\artifacts" `
  evse start `
  --dry-run `
  --protocol iso15118-20 `
  --profile-id iso15118_20_dc

Then inspect and stop the dry-run state:

& $CL --json evse status
& $CL --json evse list-state
& $CL --json evse stop

Now run the deterministic loopback flow:

& $CL --json evcc local-loopback-smoke `
  --protocol iso15118-20 `
  --profile-id iso15118_20_dc `
  --peer-ipv6 '::1' `
  --tcp-port 50118 `
  --max-steps 6 `
  --battery-model constant_power_reference `
  --battery-capacity-kwh 80 `
  --initial-soc-pct 20 `
  --target-soc-pct 80 `
  --requested-power-kw 50 `
  --battery-step-seconds 1

This is a software proof. It does not prove PLC hardware, physical CAN, high-voltage behavior, a third-party EV/EVSE, or certificate trust with an external peer.

50-60 minutes — prove evidence and supportability

List recent artifacts:

Get-ChildItem "$Data\artifacts" -Recurse -File |
  Sort-Object LastWriteTime -Descending |
  Select-Object -First 30 FullName,Length,LastWriteTime

Record workstation identity and diagnostics:

$Stamp = Get-Date -Format yyyyMMdd-HHmmss
$Out = "$Data\support\first-60-minutes-$Stamp"
New-Item -ItemType Directory -Force $Out | Out-Null

& $CL --version | Out-File -Encoding utf8 "$Out\version.txt"
& $CL --json license status | Out-File -Encoding utf8 "$Out\license-status.json"
& $CL --json license entitlements | Out-File -Encoding utf8 "$Out\license-entitlements.json"
& $CL --json doctor | Out-File -Encoding utf8 "$Out\doctor.json"
& $CL --json runtime list | Out-File -Encoding utf8 "$Out\runtime.json"
& $CL --json integration health --endpoint http://127.0.0.1:50051 |
  Out-File -Encoding utf8 "$Out\grpc-health.json"

Get-ComputerInfo | Out-File -Encoding utf8 "$Out\windows.txt"
Get-NetAdapter | Format-Table -AutoSize | Out-File -Encoding utf8 "$Out\network-adapters.txt"

First-hour sign-off

Do not move to a physical DUT until all applicable rows are understood.

Next, run the Environment and Bench Preflight for the actual protocol and hardware you intend to connect.