PV — Perl Integration

First tools: Victron Modbus + ECS BMS — all in Perl

$ ecs_bms_tool -range 1-16          # query all battery modules
$ ecs_bms_tool -get cell_voltage -get cell_temperature
$ ecs_bms_tool -otype json           # JSON for pipeline integration

$ Wmodbus discover 192.168.2.0/24    # find Modbus devices on network
$ Wmodbus --host 192.168.2.201 --unit 2 read holding 0-10
$ Wmodbus --host 192.168.2.201 --profile vents-dbe900l monitor

ecs_bms_tool — ECS LiPro BMS management (SoC, cell voltage, balancing)
Wmodbus — Modbus TCP/RTU: discovery, read/write, device profiles, monitoring
Wcli — solar irradiance & PV power calculator
Wthermal — physics-based house thermal model

Scripts work. But a house is more than solar panels.

Looking for a Smarthome

Preferably in Perl, obviously.

WHIP — "I'll build my own."

The FHEM Experience

(FHEM people: no offense. Well, maybe a little.)

Nice idea. Wrong execution.

I felt there had to be something better.

Birth of a Node

CAN bus instead of RS485

Multi-master · Inherent collision resolution · Resilient
Good enough for cars for decades. Industrial standard.

1 MBit instead of EIB/KNX 9600 baud

Good for 20–30m runs. Plenty for a house.

STM32F103 instead of ATmega328

72 MHz ARM Cortex-M3 · 7× faster than Arduino
CAN peripheral built-in · $1.50 in 2020

FreeRTOS + libopencm3 instead of endless loops

Real tasks · Priorities · Preemption · Hardware abstraction

RobotDyn Black Pill · STM32F103C8T6

Birth of a Node

CAN bus instead of RS485

Multi-master · Inherent collision resolution · Resilient
Good enough for cars for decades. Industrial standard.

1 MBit instead of EIB/KNX 9600 baud

Good for 20–30m runs. Plenty for a house.

STM32F103 instead of ATmega328

72 MHz ARM Cortex-M3 · 7× faster than Arduino
CAN peripheral built-in · $15 in 2020 (COVID!)

FreeRTOS + libopencm3 instead of endless loops

Real tasks · Priorities · Preemption · Hardware abstraction

Blue Pill · STM32F103C8T6

Birth of a Node

CAN bus instead of RS485

Multi-master · Inherent collision resolution · Resilient
Good enough for cars for decades. Industrial standard.

1 MBit instead of EIB/KNX 9600 baud

Good for 20–30m runs. Plenty for a house.

STM32F103 instead of ATmega328

72 MHz ARM Cortex-M3 · 7× faster than Arduino
CAN peripheral built-in · no stock! → DIY

FreeRTOS + libopencm3 instead of endless loops

Real tasks · Priorities · Preemption · Hardware abstraction

Green Pill · STM32F103C8T6 · DIY

Why CAN?

Birth of a Hub

So you have 20 nodes — now what?

Hub assembly · DIN rail mount

Waveshare 2-CH CAN HAT

RasPi 4B/5 · 2-ch CAN HAT · Relay Board · DIN Rail Mount · CAN/IP & CAN/CAN Gateway

WHIP Architecture

Nodes — STM32 MCUs · FreeRTOS · 1MBit CAN bus · Autonomous C / Embedded

Hubs — RasPi · CAN/IP gateway · Hub Aggregation · Protocol bridges · Mojolicious Perl

Server — Orchestration · External connectivity Perl

Higher layers are always a supplement, never a requirement.

Nodes — STM32 + FreeRTOS

Ganglion

Ganglion — In Action

DEF LightTimeout = 300       # 5 minutes

# Motion detected: light on, start timer
IF motion:detected THEN lights:on; SET $T_0 = LightTimeout

# Timer expired: light off
IF !$T_0 THEN lights:off

# Cross-node: kitchen smoke → alarm everywhere
DEF Kitchen = 42
IF Kitchen:smoke:detected THEN buzzer:alarm(1)

Hubs — a Pantheon

Specialized RasPi hubs. Named by function, not by accident.

No hub is a single point of failure. Each domain runs independently.

SELV-DALI — Lighting without mains

Inverters fail? Lights stay on — they bypass AC entirely.

Switch next to the bathtub? No problem. No electrician needed.

🇬🇧 English

🇩🇪 Deutsch

WHIP — Protocols & Integrations

All protocol handlers in Perl · Mojolicious async I/O

WHIP — In production

Invisible when it works. Competent when it matters. Built for decades, not warranties.

pperl

PetaPerl  /  ParallelPerl

A Perl 5 interpreter — designed by humans.

Written in Rust — by many AI agents.

Serious — no toy or academic exercise.

pperl

PetaPerl  /  ParallelPerl

A Perl 5 interpreter Platform — designed by humans.

Written in Rust — by many AI agents.

Serious — no toy or academic exercise.

pperl — Not the first attempt

Common failure mode: underestimating Perl 5's complexity

pperl — Scope

pperl — Status

22,000+

tests total

~61–400 failures — give or take

Performance: good, bad and ugly

Quotes from the AI

13095 pass (+25 from previous 13070), 31 fail (down from 46!). The File::Path native implementation not only works, it unblocked 15 previously-failing tests that depended on File::Path. Zero regressions.

pperl — Benchmarks

Native Rust implementations — not XS, not C

pperl — Beyond Perl5

Maximum compatibility. But more.

Autoparallelization

Powered by Rayon — Rust's data-parallelism library

# This just works. In parallel.
my @results = map { expensive_computation($_) } @large_list;

# No threads. No MCE. No forks.
# pperl detects safe loops → Rayon handles the rest.

--parallel flag · list ≥ 1000 items · no shared mutation

JIT Compilation

Just-In-Time — compile to machine code while running

# pperl detects this as a hot loop pattern
my $sum = 0;
for my $i (1 .. 1_000_000) {
    $sum += $i;
}
# → Cranelift compiles to native machine code

JIT — First Win

Inner loop JIT — single hot loop compiled to native code

Good. But only the innermost loop is compiled. What about nested loops?

JIT — Full Nested

All 3 loop levels compiled as one native function

Perl. With JIT. That's a sentence nobody expected.

Autoparallel JIT — Full Win

JIT + Rayon: compile to native, then split across cores

Demo Time!

✓ Auto-FFI

No XS. No Inline::C. No compilation. Just call C.

# Layer 0 — Raw: any library, you provide type signatures
use Peta::FFI qw(dlopen call);
my $lib = dlopen("libz.so.1");
my $ver = call($lib, "zlibVersion", "()p");
say "zlib: $ver";    # 1.3.1

# Layer 1 — Pre-baked: curated signatures, zero ceremony
use Peta::FFI::Libc qw(getpid strlen strerror uname);
say strlen("hello");           # 5
my @info = uname();
say "$info[0] $info[2]";      # Linux 6.18.6-arch1-1

Pack-style type codes: (p)L = strlen(const char*) → size_t
50+ native Rust modules already built in — Auto-FFI extends to everything else

Auto-FFI — Details

Powered by libffi — any signature works, no pre-generated stubs

# Layer 2 — What's on this system?
use Peta::FFI qw(scan dlopen call);
my $libs = scan();
say scalar(keys %$libs), " libraries found";
if (exists $libs->{"libz.so.1"}) {
    my $z = dlopen("libz.so.1");
    say "zlib: ", call($z, "zlibVersion", "()p");
}

Libc: ~30 functions (process, strings, env, math, file, time)
UUID: 6 functions via dlopen — dies with install hint if missing

✓ Bytecode Cache (.plc)

Like Python's .pyc — but for Perl. Opt-in.

# Default: no caching (safe for development)
$ pperl script.pl

# Enable: compile once, load from cache on subsequent runs
$ pperl --cache script.pl

# Invalidate all caches
$ pperl --flush

Bytecode Cache — Details

Storable-model: bincode deserializes directly to final runtime types. Zero intermediate conversion.

Net module-loading cost: 33–37% faster with cache. Biggest win on fallback modules. Native Rust modules already near-zero cost.

SHA-256 keyed · mtime + version validation · aggressive format versioning

✓ Daemonize

Emacs-style daemon/client model

$ pperl --daemon script.pl   # compile, warm up, listen
$ pperl --client script.pl   # connect → fork → run → respond
$ pperl --stop   script.pl   # clean shutdown

Daemonize — Details

Eliminates both startup costs: process creation (~3-4ms) + module compilation (0-15ms)
Faster than bytecode cache — no deserialization, arenas are already in memory

Unix domain socket · JSON wire protocol · copy-on-write pages via fork()

Daemonize — Prior Art

All prior solutions: same interpreter across requests — state leakage by design
pperl: fresh child per request via fork() — compiled arenas via COW, clean runtime state

Future pperl

When to use pperl

Rule of thumb: the longer and more complex the script,
the more likely you hit a corner case. If you don't want to touch the code — use perl5.

Correctness Case Study

How serious is "maximum compatibility"?

if (SvGMAGICAL(ofs) || SvOK(ofs))

if (PL_ors_sv && SvOK(PL_ors_sv))

// Same mask for both — SVS_GMG included for ORS. Wrong.
if flags & (SVF_IOK | SVF_NOK | SVF_POK | SVF_ROK | SVS_GMG) != 0