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);

Overload of din() that also reports whether a valid reply arrived. Sets *ok = true if the vertebra responded within 500 ms, *ok = false on timeout (returned value is 0 and meaningless). Pass nullptr to behave identically to the two-argument version.

bool ok;
uint8_t v = iotv.din(addr, SIDE_A, &ok);
if (!ok) Serial.println("timeout");

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.

Reads all four analog channels of one side in a single CAN request (one RTR + one reply). Faster than calling ainv() four times. Fills out[0..3] with channels 1–4 in volts. Also updates internal memory so subsequent iainv() calls reflect the values. Returns true on success; false on timeout (out is left untouched).

float ch[4];
if (iotv.ainv4(addr, SIDE_A, ch)) {
  Serial.printf("ch1=%.2f ch2=%.2f\n", ch[0], ch[1]);
}

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);

Returns true if at least one analog reading has been received for the given address and side (via ainv(), ainv4(), or the async dispatcher). Allows distinguishing "no data yet" from a genuine 0.0 V reading, avoiding spurious publications at startup.

if (iotv.aMemValid(addr, SIDE_A)) {
  float v = iotv.iainv(addr, SIDE_A, 1);
  // guaranteed to be a real reading
}

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.