API Python

Activa la interfície CAN (can0) a 100 kbps. Executa sudo ip link set up can0 type can bitrate 100000. Cal cridar-la al principi de qualsevol programa.

Atura tots els listeners actius, tanca el bus CAN i executa sudo ifconfig can0 down. El tancament també es fa automàticament en sortir del programa (atexit).

Llegeix les 8 entrades digitals d'un costat. Les entrades arriben en actiu baix des de la vèrtebra; la biblioteca les inverteix i retorna el byte en actiu alt com a string de 8 bits.

val = iotv.din('0000', 'B')  # ex: '00100100'
di1 = bool(int(val[6]))        # bit DI1 (posició 6 des de l'esquerra)

Escriu el byte complet (0–255) a un costat de sortida digital. Els 8 LEDs/relès s'actualitzen en un sol missatge CAN.

iotv.dout('0000', 'A', 0xFF)  # tots encesos
iotv.dout('0000', 'A', 0x00)  # tots apagats

Escriu un bit individual de sortida sense afectar els altres. posbyte és 0 (DO0) a 7 (DO7). value és 0 o 1.

for bit in range(8):
    iotv.doutbit('0000', 'A', bit, 1)
    time.sleep(0.1)
    iotv.doutbit('0000', 'A', bit, 0)

Configura els modes de treball dels dos costats d'una vèrtebra digital. El costat A pot ser 'din', 'dout', 'pwm' o 'dfast'. El costat B afegeix 'touch'. Restriccions: PWM només pot estar a un costat; 'touch' només al costat B; 'dfast' (costella de motor pas a pas, nou a v2.3) només pot estar a un costat — vegeu la categoria Costella dfast més avall.

iotv.dsetup('0000', 'dout', 'din')
iotv.dsetup('0001', 'pwm', 'din')
iotv.dsetup('0001', 'dout', 'dfast')  # B = costella dfast (motor pas a pas)

Llegeix la configuració actual de la vèrtebra digital i retorna un string llegible. Des de v2.3, distingeix correctament 'dfast' de 'dout'/'din'/'pwm'/'touch' (fa una consulta CAN addicional a get_dfast_side() internament).

iotv.getdsetup('0000')  # 'A:dout, B:din'
iotv.getdsetup('0001')  # 'A:dout, B:dfast'

Retorna la versió del firmware de la vèrtebra digital (ex: '1.5'), o '0.0' en timeout.

Declara quin costat porta la costella dfast. Equivalent a cridar dsetup() amb 'dfast' en un dels dos costats, però sense tocar l'altre costat. Es desa a l'EEPROM de la vèrtebra (persisteix entre reinicis).

iotv.dfast_setup('0001', 'B')

Desactiva la costella dfast en aquesta vèrtebra: el costat que la portava queda alliberat i disponible per configurar de nou amb dsetup(); l'altre costat no es veu afectat en cap moment.

iotv.dfast_clear('0001')

Consulta quin costat porta la costella dfast ara mateix.

iotv.get_dfast_side('0001')  # 'B'

Engega el motor pas a pas: finit (nombre de passos concret) o infinit (gira fins stepper_stop()). El firmware aplica un mínim de 250 µs entre flancs.

iotv.stepper_start('0001', 'B', 4000, 300)  # 4000 passos horaris, 300us
iotv.stepper_start('0001', 'B', 0, 500, infinit=True, clockwise=False)  # infinit, antihorari

Atura el motor (finit o infinit). Per defecte manté el parell de manteniment habilitat (ENA); amb disable_ena=True el deshabilita també, deixant l'eix lliure de girar a mà.

iotv.stepper_stop('0001', 'B')              # atura, mantenint parell
iotv.stepper_stop('0001', 'B', True)        # atura i deshabilita ENA

Canvia el temps entre flancs en calent (amb el motor girant o aturat), sense interrompre el moviment. Pensada per tancar un llaç de control (PID) des de la Raspberry Pi.

iotv.stepper_set_speed('0001', 'B', 300)

Canvia el sentit de gir en calent, sense aturar el motor. El canvi s'aplica sempre entre polsos, mai a mig pols.

iotv.stepper_set_direction('0001', 'B', False)  # antihorari

Registra un callback per a canvis d'entrada digital espontanis de la vèrtebra a addr. El callback rep tres arguments: addr (int, adreça i2c), val_a (byte del costat A, actiu alt), val_b (byte del costat B, actiu alt). El callback s'executa en un thread de fons (core separat del while True principal).

seq_running = False
last_di1    = None

def on_din_change(addr, val_a, val_b):
    global seq_running, last_di1
    di1 = bool(val_b & 0x02)   # DI1 = bit 1 del costat B
    if di1 == last_di1: return
    last_di1 = di1
    if di1:
        seq_running = True
    else:
        seq_running = False
        iotv.dout('0000', 'A', 0x00)

iotv.can_on()
iotv.dsetup('0000', 'dout', 'din')
iotv.on_din_change('0000', on_din_change)

while True:
    if seq_running:
        # ... lògica de seqüència ...
        time.sleep(0.05)

Cancel·la el listener de canvis digitals per a l'adreça indicada. Atura el thread de fons de manera neta.

Cancel·la tots els listeners actius. Es crida automàticament a can_off().

Llegeix una entrada analògica. ndac és 1, 2, 3 o 4. Retorna el valor cru de 16 bits (0–26624) corresponent a −10V..+10V, o 'Error' en timeout.

raw = iotv.ain('0000', 'B', 1)
volts = iotv.ain2v(raw)   # ex: 4.98

Llegeix els 4 canals analògics d'un costat EN UNA SOLA petició CAN i retorna una llista de 4 valors crus (0–26624), índex 0 = canal 1. ain() ja fa aquesta mateixa petició internament i en descarta 3 — cridar-lo un cop per canal fa un round-trip CAN sencer per cadascun. Useu ainBatch() sempre que calgui més d'un canal del mateix costat.

valors = iotv.ainBatch('0000', 'B')   # [v1, v2, v3, v4], cru
volts = [iotv.ain2v(v) for v in valors]

Escriu un valor cru (0–4095) a un canal DAC. ndac és 1–4. Useu v2aout() per convertir des de volts. Per enregistrar un valor a l'EEPROM del DAC (default en reset), sumeu 4096 al valor. Limiteu les escriptures EEPROM a menys de 20.000 vegades.

iotv.aout('0000', 'B', 1, iotv.v2aout(5.0))  # 5V al canal 1
# Enregistrar 9.3V a l'EEPROM del DAC canal 4:
iotv.aout('0000', 'B', 4, 4096 + iotv.v2aout(9.3))

Retorna la versió del firmware de la vèrtebra analògica (ex: '1.4'), o '0.0' en timeout.

Llegeix la configuració de la vèrtebra analògica. Retorna string com 'A:ain, B:aout'.

Converteix el valor cru ADC (0–26624) a volts (−10.0 a +10.0 V, 2 decimals).

iotv.ain2v(26624)  # → 10.0
iotv.ain2v(13312)  # → 0.0
iotv.ain2v(0)      # → -10.0

Converteix una tensió entre 0 i 10 V al valor cru de 12 bits (0–4095) per al DAC. Els valors fora del rang es clampegen per evitar escriptures accidentals a l'EEPROM del DAC.

iotv.v2aout(10.0)  # → 4095
iotv.v2aout(5.0)   # → 2048
iotv.v2aout(0.0)   # → 0

Activa o desactiva l'enviament periòdic dels valors ADC d'un costat. side pot ser 'A', 'B' o 'AB' (ambdós alhora). period_ms es limita internament a 10–5000 ms. No bloqueja esperant resposta (fire-and-forget, igual que aout()/dout()).

iotv.set_async_adc('0000', 'A', True, 200)   # costat A cada 200ms
iotv.set_async_adc('0000', 'AB', False)      # desactiva els dos costats

Registra un listener passiu per als valors ADC d'un costat concret. A diferència de on_din_change() (una vèrtebra sencera), aquí cal un listener per costat — 'A' o 'B', mai els dos alhora. Requereix haver activat abans set_async_adc(addr, side, True, ...). El callback rep (addr, side, values), on values és una llista de 4 valors crus (0–26624), un per canal — useu ain2v() per convertir-los a volts. Si es torna a cridar amb la mateixa addr/side, el listener anterior es cancel·la automàticament.

def rebre_valors(addr, side, values):
    volts = [iotv.ain2v(v) for v in values]
    print(f"addr={addr} side={side} -> {volts} V")

iotv.set_async_adc('0000', 'A', True, 200)
iotv.on_ain_change('0000', 'A', rebre_valors)

Cancel·la el listener d'un costat concret. Nota: això només atura l'escolta al costat del Raspberry Pi — si voleu que la vèrtebra deixi de trametre, cal cridar també set_async_adc(addr, side, False).

Cancel·la tots els listeners ADC asíncrons actius. Es crida automàticament a can_off().