Initializes the CAN bus using the default pins and bitrate defined in the board package. Automatically performs the power-on sequence (raises 3.3V rail, then 24V rail, waits for stabilization). Returns true on success.

if (!iotv.begin()) {
  Serial.println("CAN error");
  while (true);
}

Full overload. Specify custom CAN pins and bitrate. Set doPowerOn = false to skip the power-on sequence (useful when the bus is already powered or in lab bench setups).

iotv.begin(17, 18, 100000, false); // skip power-on

Stops the TWAI driver, deletes FreeRTOS queues and dispatcher task, then powers off (24V first, then 3.3V).

Converts a 4-bit binary string to an address byte (0–15).

uint8_t a = iotv.addr("0101"); // → 5

Configures the operating mode of both sides of a digital vertebra. Sends one or two CAN frames as required by the protocol.

iotv.dsetup(addr, DIN, DOUT); // A=input, B=output
iotv.dsetup(addr, PWM, DIN);  // A=PWM output, B=input

Reads the firmware version string from a digital vertebra (e.g. "1.5"). Returns "" on timeout.

Reads the current configuration from the vertebra and returns a human-readable string (e.g. "A:din, B:dout").

Sends an RTR request and waits up to 500 ms for the vertebra to reply with the 8-bit input state (active-high corrected). Returns 0 on timeout. Also updates the internal memory so a subsequent idin() reflects this read.

uint8_t v = iotv.din(addr, SIDE_A);

Returns the last digital input value stored in internal memory by the dispatcher. Does not send any CAN frame — safe to call every loop iteration. Returns 0 if no data has been received yet for this address.

Returns a single bit (0 or 1) from the internal digital memory. bit is 0–7 (LSB first).

uint8_t b = iotv.idinbit(addr, SIDE_A, 3); // bit 3

Writes a full byte to a digital output side. All 8 outputs are updated in a single CAN frame.

iotv.dout(addr, SIDE_B, 0b00001111); // bits 0-3 ON

Writes a single output bit without affecting the others. bit is 0–7, val is 0 or 1.

iotv.doutbit(addr, SIDE_B, 2, 1); // set bit 2

Writes a PWM duty cycle (0–255) to a single output bit on a side configured as PWM. The side must have been set to PWM mode via dsetup().

Registers a callback invoked by the internal dispatcher (core 0) whenever a spontaneous digital change notification is received. Do not call Serial or other non-thread-safe functions inside the callback. Use a volatile flag and process it in loop().

volatile bool changed = false;
volatile uint8_t lastA, lastB;

void onChange(uint8_t addr, uint8_t a, uint8_t b) {
  lastA = a; lastB = b; changed = true; // no Serial here!
}
iotv.onDinChange(onChange);

Sends an RTR request and returns the ADC reading in volts (range −10.0 to +10.0 V, 2 decimal places). Waits up to 500 ms. Note: ADC stabilizes ~330 ms after a DAC write; the first read after power-on may return −10.00 V.

float v = iotv.ainv(addr, SIDE_A, 1); // channel 1

Same as ainv() but returns the raw 16-bit ADC value (0–26624). Use ain2v() to convert.

Returns the last analog value (in volts) stored in internal memory by the async dispatcher. Requires setAinFreq() to be called first. Returns 0.0 if no data yet. Safe to call every loop iteration.

// In setup:
iotv.setAinFreq(addr, 200); // 200 ms period
// In loop:
float v = iotv.iainv(addr, SIDE_A, 1);

Commands the analog vertebra to start pushing ADC readings autonomously every periodMs milliseconds. The dispatcher (running on core 0) receives these frames and updates internal memory. Pass periodMs = 0 to disable. Recommended: 50–500 ms.

Writes a voltage (0.0–10.0 V) to a DAC channel. The library converts to the 12-bit raw value (0–4095) and clamps to avoid accidental EEPROM writes on the vertebra firmware. ADC stabilization takes ~330 ms after a write.

iotv.aoutv(addr, SIDE_B, 1, 5.0f); // 5V on ch1

Raw DAC write. val is 0–4095 (0 V to 10 V). Use v2aout() to convert from volts.

Returns the analog vertebra firmware version string (e.g. "1.5").

Returns the analog vertebra side configuration as a string (e.g. "A:ain, B:aout").

Converts raw ADC (0–26624) to voltage (−10.0 to +10.0 V, 2 decimal places). Formula: ((20×raw)/26624)−10.

Converts voltage (0.0–10.0 V) to raw DAC value (0–4095), clamped to avoid out-of-range values.