Eerie Leap: a CAN data logger and dash platform you can script

read

Your sensors, and every module on the car's bus.

compute

Calibration, math and Lua, running on the unit.

show

On a gauge with the screens you designed.

log

In MDF4, the format analysis tools already open.

send

Back onto the bus, as new or rewritten messages.

one platform, four jobs

on the dash

a dash of your own design

Take values from the ECU, or from any other module on the bus, and put them in front of you on screens you lay out yourself.

on the track

a data logger

Pressures, temperatures and bus traffic, logged in MDF4. Plot the logs in Gefera, or in the analysis tool you use now.

on the bus

a sensor hub

Add the sensors a car lacks and send their values onto the bus, for the ECU, a dash or a logger that is already there.

between buses

a CAN gateway

Sit between two buses or two modules: pass messages through, rewrite them with a script, or translate one side for the other.

how it fits together

your sensors

Pressures, temperatures, levels and switches, on analog and digital inputs.

the car's buses

The ECU and every other module that talks on CAN. LIN is planned.

the units

a unit that reads, computes and logs

Calibrates each input, runs your math and Lua, writes the log and talks on the bus.

a unit that shows

A gauge with the screens you designed, and touch controls of its own.

out

a gauge you design

Dials, bars, readouts and charts.

MDF4 logs

To plot in Gefera or in your own tools.

messages on the bus

New ones, or the car's own, rewritten.

Gefera, the app

Sets up every unit over Bluetooth, from a computer or a phone, and plots the logs.

fig. 02 · the system in one picture

set up in an app, not in code

Every input, message, screen and logging rule is a setting. Change it in Gefera, write it to the unit over Bluetooth, and it runs. There is no firmware to build.

Gefera on the desktop: a tachometer on the gauge editor's canvas, its needle climbing until the red zone lights up, then the gauge's other screens — fig. 03 · Gefera on the desktop: designing a gauge

Gefera on a phone: the sensors of a unit, then one sensor's calibration table and its curve — fig. 04 · and on a phone

Part of a system map: sensors, math expressions and the wires between them

the whole system on one map

Every unit, input, message, sensor and gauge widget, and the wires between them. Draw a wire to connect two things.

A sensor's calibration: a table of voltages and temperatures, and the curve through them

a calibration for every sensor

A lookup table (LUT) for each input: type in the points from a sender's data sheet and see the curve the unit reads it by.

Logging settings: how often values are written and how large a file may grow

logging, the way you want it

Pick the sensors, how often they are written and what starts a log. Then plot the logs in the same app.

as deep as you want to go

configure
Inputs, calibration tables, bus messages, gauge screens and logging are all settings in the app.
add math
A math expression on any sensor: scale it, combine it with others, or turn a value into a warning.
x * 4 + 1.6temp > 90 ? 1 : 0
script it
Lua on a sensor or on a bus message, running on the unit, for whatever a setting can't say.
change the firmware
The firmware is open source. Developers can build on it, port it to other hardware and run it in a simulator.
the firmware, and its docs

step 3 · a sensor script, from the firmware docs

function post_process_sensor_value(sensor_id, value)
    if value == nil then
        return nil
    end

    local rpm = get_sensor_value("engine_rpm")
    if rpm == nil then
        return -1 -- the other sensor has no value yet
    end

    return math.min(value, 100.0) * rpm
end

what it can do

inputs: Analog and digital sensors: pressures, temperatures, levels and switches. Every analog input has a calibration table (LUT) of its own.
buses: CAN bus: read and send messages from any module in the car, with DBC files in and out.LIN · planned
computed values: Values worked out from other values, with a math expression or a Lua script, then shown, logged and sent like any sensor.
gauge: Screens you design yourself: dials, bars, readouts, charts, images and touch controls.
logging: MDF4 files, which analysis tools open. You choose what is logged, how often, and what starts and stops a log.
gateway: Sits between two buses: reads on one, sends on the other, and can change a message on the way.
network: Connect several units together and they organize themselves into one network.
setup: Wireless, over Bluetooth, from a computer or a phone.
log plots: Plot your logs in the app: zoom in, measure, compare runs, and watch values live.
updates: Over-the-air firmware updates, through the app.

where it stands

running

firmware

What this page describes runs on it today, except where it says planned.

built

Gefera for desktop

Windows, macOS and Linux. Its first release is being prepared.

in development

Gefera for phones

For Android and iOS.