222 moduli Seeed Grove ora funzionano nel browser

Grove è il sistema plug-and-play di Seeed Studio: un connettore a quattro pin, un cavo e qualche centinaio di moduli che lo condividono. Un pulsante, un sensore di temperatura, un relè, un OLED, una termocamera e una radio LoRa si collegano tutti alla stessa presa, ed è per questo che tanti primi progetti si basano su di esso.

A settembre 2026, 222 dei 279 moduli nel catalogo Grove di Seeed funzionano in Velxio. Ognuno ha il proprio componente sulla tela, disegnato dalla foto del prodotto, una scheda datasheet con il link allo store di Seeed e un esempio della galleria adattato dal wiki di Seeed stesso, collegato a una scheda XIAO. Questo articolo esplora cosa significa in pratica.

Come appare un modulo Grove sulla tela

Ogni modulo è disegnato dalla foto del prodotto di Seeed, con il connettore, i componenti e la serigrafia dove si trovano sulla scheda, e porta l’esatto nome del prodotto Seeed. I pin sono le quattro linee del connettore, nominati come li nomina la serigrafia, così un filo da SIG o SDA arriva dove arriverebbe sul banco.

Cosa ottieni con ogni componente:

• Una scheda datasheet. Clicca il componente e la finestra di dialogo mostra cos’è il modulo, quale chip monta, il suo indirizzo I2C dove ne ha uno, e un pulsante Product page verso lo store di Seeed.
• I controlli che servirebbero a uno reale. Un sensore analogico riceve uno slider per la grandezza che misura. Un pulsante è cliccabile. Un relè scatta e accende il suo LED. Un display dipinge ciò che la sketch invia. Una radio riceve un pannello che riproduce l’altro capo del collegamento.
• Un esempio della galleria. Ogni modulo viene fornito con una sketch adattata dal wiki di Seeed, collegata a una XIAO ESP32-C6, con le librerie necessarie alla sketch già dichiarate. Aprila, premi Run e il modulo risponde.

Per trovarli, apri il selettore dei componenti e digita “Grove”, oppure apri la galleria degli esempi e filtra per Seeed Studio.

Provane tre

I passaggi sono gli stessi per ogni esempio:

1. Apri il link dell’esempio. Non ti serve un account.
2. Premi il pulsante play sulla barra degli strumenti. La sketch viene compilata sui server di Velxio e la scheda si avvia nel tuo browser.
3. Muovi gli slider del modulo, clicca i suoi pulsanti o guardalo disegnare.

Una termocamera. La MLX90640 è una matrice 32 per 24 di termopile. La sketch legge la EEPROM di calibrazione del sensore, acquisisce un frame ed esegue la matematica radiometrica di Melexis, e stampa il frame sul monitor seriale come ASCII art. Il componente mostra lo stesso frame come mappa di calore; lo slider imposta dove si trova il punto caldo e quanto è caldo.

Due motori su un solo driver. L’I2C Motor Driver monta un TB6612FNG dietro un piccolo STM32 che parla un protocollo di comandi. L’esempio fa girare due motori DC in avanti, indietro e in frenata; i rotori sulla tela girano alla velocità e nella direzione comandate, e la frenata li blocca.

Un OLED. L’SSD1315 da 0.96” è il display con cui viene fornita la maggior parte dei kit Grove. L’esempio è l’hello world u8g2 di Seeed: una riga di testo e un contatore, inviati via I2C a 0x3C, dipinti da un modello del controller.

Come viene emulato un modulo

Qui nulla è simulato a livello di libreria. La sketch viene compilata da un vero arduino-cli per la scheda che hai scelto, il firmware gira sull’emulatore di Velxio per quel SoC, e il modulo risponde sul filo come farebbe il componente reale. Ciò che cambia da modulo a modulo è cosa sia “il filo”:

• I moduli analogici (32 in tutto: luce, suono, umidità, gas, corrente, temperatura) mettono una tensione su SIG, impostata dallo slider. La sketch la legge con analogRead() attraverso il modello ADC della scheda.
• Gli input e output digitali sono un livello su SIG: pulsanti, interruttori, sensori PIR e touch da un lato, LED, relè e buzzer dall’altro.
• I moduli a impulsi e temporizzazione come l’Ultrasonic Ranger e la famiglia DHT usano un modello a linee: i fronti sono schedulati sul clock dell’CPU emulata, perché un frame DHT22 è di microsecondi e un frame del browser è di sedici millisecondi.
• I moduli NeoPixel e PWM decodificano la forma d’onda prodotta dalla sketch.
• I moduli I2C, UART e SPI sono il gruppo più numeroso: 84 moduli su 78 modelli di dispositivo scritti in C e compilati in WebAssembly. Ogni modello risponde alle letture di registro e ai comandi che invia il driver del produttore, e lo stesso sorgente C gira sia nel browser sia negli emulatori cloud di Velxio per le schede che girano lì.

I modelli di dispositivo sono brevi, perché la maggior parte dei componenti segue una delle poche forme possibili: una mappa di registri con un puntatore ad auto-incremento, un dispositivo a comandi in stile Sensirion con CRC-8 su ogni parola, oppure un frame piatto che il sensore trasmette in streaming. Il modello SHT31 è l’intero sensore di temperatura e umidità di Seeed, meno i commenti:

static uint32_t handle(sn_dev* d, uint16_t cmd, const uint16_t* args, uint32_t nargs, uint16_t* w) {
  (void)d; (void)args; (void)nargs;
  switch (cmd) {
    case 0x306D: heater = true;  return 0;
    case 0x3066: heater = false; return 0;
    case 0x30A2: heater = false; return 0;   /* soft reset */
    case 0x3093: return 0;                    /* break */
    case 0x3041: return 0;                    /* clear status */
    case 0xF32D: {                            /* status register */
      uint16_t st = heater ? 0x2000 : 0x0000;
      w[0] = st; return 1;
    }
    default: break;
  }
  /* Everything else is a measurement request (single shot, periodic, fetch). */
  double t = vx_attr_read(A_temp) + (heater ? 2.0 : 0.0);
  double h = vx_attr_read(A_hum);
  w[0] = gc_u16((gc_clamp(t, -45, 130) + 45.0) * 65535.0 / 175.0);
  w[1] = gc_u16(gc_clamp(h, 0, 100) * 65535.0 / 100.0);
  return 2;
}

A_temp e A_hum sono i due slider. La conversione è quella del datasheet dell’SHT31, eseguita al contrario: lo slider dice 25 gradi, il modello produce la parola grezza che il driver trasformerà di nuovo in 25 gradi, CRC incluso.

Da dove provengono i modelli

Ogni modello è scritto basandosi su un documento: il datasheet del componente, o la libreria del produttore che comunica con esso, letto riga per riga. Quando nessuno dei due esisteva, il modulo è stato escluso anziché ipotizzato. Tre casi mostrano cosa questo ha significato.

Le termocamere hanno dovuto essere derivate, non trascritte. Un driver termico non legge mai una temperatura. Estrae 832 word di EEPROM, ricava circa duecento costanti di calibrazione, legge 832 word di dati di frame ed esegue il modello del produttore. Quindi il modello MLX90640 fornisce una calibrazione degenere in cui ogni termine di correzione svanisce, e calcola la matematica al contrario dalla temperatura richiesta dallo slider fino alla word grezza che la produce. È stato verificato rispetto a un port del driver prima di scrivere qualsiasi C; un target da -20 a 300 gradi restituisce un valore entro 0,02 gradi. L’MLX90641 ha richiesto lo stesso trucco più una EEPROM con codifica Hamming, e l’MLX90621, per il quale Seeed non pubblica nulla, è derivato dal driver di riferimento di Melexis.

L’esempio del driver motore usa Wire grezzo. La libreria di Seeed per la scheda TB6612FNG include un helper I2C di epoca AVR che non compila per un ESP32, quindi l’esempio parla direttamente il protocollo. È un byte di comando e il suo payload:

const uint8_t ADDR = 0x14;
const uint8_t BRAKE = 0x00, CW = 0x02, CCW = 0x03;
const uint8_t STANDBY = 0x04, NOT_STANDBY = 0x05;
const uint8_t CHA = 0, CHB = 1;

void cmd(uint8_t c, const uint8_t* payload, uint8_t n) {
  Wire.beginTransmission(ADDR);
  Wire.write(c);
  for (uint8_t i = 0; i < n; i++) Wire.write(payload[i]);
  Wire.endTransmission();
  delay(1);
}

void run(uint8_t channel, int speed) {
  uint8_t p[2] = { channel, (uint8_t)(speed < 0 ? -speed : speed) };
  cmd(speed >= 0 ? CW : CCW, p, 2);
}

Il modulo CAN BUS non è un design Seeed. È stato inizialmente escluso perché Seeed non pubblica né un protocollo né una libreria per esso. La scheda è prodotta da Longan Labs, che pubblica entrambi, e il modello segue il loro layout di frame: 0xAA, una lunghezza, un comando, il payload e un CRC MODBUS.

Ogni modello ha un test che lo pilota come farebbe il suo driver, byte per byte: 1.804 in tutto il catalogo a settembre 2026. Gli esempi della galleria sono stati eseguiti anche sull’app distribuita, non solo nella suite di test.

Cosa non è nel catalogo

Essere chiari sulle lacune: 57 dei 279 SKU non sono modellati, e tre gruppi spiegano quelli che potrebbero esserlo.

• Il modulo DMX512. La scheda è un line driver; la parte difficile è che nessuna libreria Arduino produce un frame DMX su un XIAO nel modo in cui la scheda se lo aspetta.
• Il kit 433 MHz Simple RF Link. I suoi sketch usano VirtualWire, che non è nell’indice delle librerie Arduino, e la metà ricevente avrebbe bisogno che il modulo generi un flusso di bit verso la scheda anziché rispondergli.
• Tre schede vendute con il nome Grove: il Grove Beginner Kit, l’ Arduino Sensor Kit Base e il GrovePi+. Sono schede con un microcontrollore anziché moduli, e necessitano delle proprie definizioni di scheda.

Il resto sono cavi, hardware di montaggio e kit.

Dove andare adesso

• Il selettore dei componenti: premi Add Component sulla tela e digita “Grove”. Ogni scheda è un modulo; la descrizione dice cosa fa.
• La galleria di esempi su velxio.dev/examples, filtrata per Seeed Studio, ha un esempio per modulo.
• I moduli sono nello store di Seeed sotto Grove; la scheda del datasheet di ogni componente rimanda alla sua pagina.

Le illustrazioni dei moduli sono tratte dalle fotografie dei prodotti di Seeed Studio.