I2C

I2C es un bus: un par de cables que comparten varios dispositivos. Tu placa hace de controlador y habla con cada dispositivo por su dirección.

SDA y SCL: los dos cables del bus. SDA lleva los datos y SCL el reloj (los pulsos que marcan el ritmo de la comunicación). Todos los dispositivos comparten esos mismos dos cables.
Dirección: número único de cada dispositivo en el bus, casi siempre en hexadecimal (p. ej. 0x68, que es 104 en decimal). La trae el datasheet.
Registro: “casilla” numerada dentro de un dispositivo donde viven sus datos o su configuración. Para leer una medición sueles decir “dame el registro X”.

El patrón típico es: escribir qué registro quieres y luego leer la respuesta.

1. Configurar el bus: `i2cConfig(...)`

Como tu código se reinicia en cada guardado, abre el bus al inicio. Dos formas:

// Forma simple: el número es un retraso en microsegundos entre operaciones.
board.i2cConfig(0); // 0 sirve para la mayoría de dispositivos

// Forma con objeto (casos especiales):
board.i2cConfig({
  delay: 0,
  address: 0x68,
  settings: { stopTX: false }, // no soltar el bus entre escribir y leer
});

stopTX: false se usa con dispositivos que exigen mantener viva la conexión entre “te pido el registro” y “dame los bytes”. Si un sensor devuelve datos sin sentido, pruébalo.

2. Escribir

Dos formas, equivalentes:

// a) Enviar un arreglo de bytes (el 1.º suele ser el registro):
board.i2cWrite(0x68, [0x6B, 0x00]); // "en el registro 0x6B, escribe 0x00"

// b) Más explícito: dirección, registro y un byte:
board.i2cWriteReg(0x68, 0x6B, 0x00);

3. Leer

i2cReadOnce lee una sola vez; el callback recibe un arreglo de bytes:

// "Del dispositivo 0x68, registro 0x3B, dame 6 bytes" — una vez
board.i2cReadOnce(0x68, 0x3B, 6, (data) => {
  // data = [b0, b1, b2, b3, b4, b5]
  varG.aceleracionX = (data[0] << 8) | data[1]; // combinar 2 bytes en un número
});

Qué hace (data[0] << 8) | data[1]: muchos sensores parten un número de 16 bits en dos bytes, uno “alto” y uno “bajo”.

data[0] << 8 desplaza el byte alto 8 posiciones a la izquierda (equivale a multiplicarlo por 256). << es el operador de desplazamiento de bits.
| data[1] suma el byte bajo. | es un OR bit a bit; como el byte alto ya ocupa las posiciones de arriba, aquí funciona como una suma de las dos mitades.
El resultado es el número completo. Si tu sensor usa el orden inverso (primero el bajo), harías (data[1] << 8) | data[0]: el datasheet lo indica.

i2cRead tiene la misma forma pero lee de forma continua (se relee según el intervalo de muestreo). Para detenerla:

board.i2cStop(0x68);

Resumen de métodos

Método	Qué hace
`i2cConfig(delay)` o `i2cConfig({...})`	abre el bus
`i2cWrite(addr, bytes[])`	escribe bytes
`i2cWriteReg(addr, reg, byte)`	escribe un byte en un registro
`i2cReadOnce(addr, [reg], n, cb)`	lee `n` bytes una vez
`i2cRead(addr, [reg], n, cb)`	lee `n` bytes en continuo
`i2cStop(addr)`	detiene la lectura continua

Errores típicos

Olvidar i2cConfig: sin él nada funciona.
Dirección equivocada: revísala en el datasheet; en algunos módulos cambia con un puente de soldadura.
Leer datos sin sentido: prueba stopTX: false, un delay mayor, o invierte el orden de los bytes al combinarlos.

Si tu módulo ya tiene un componente en frvn componentes, suele ser más cómodo usarlo.