Ricevere Palloni Sonda RS41 con il TTGO LoRa32
Come trasformare un TTGO LoRa32 da ~20€ in una stazione di ricezione professionale per i palloni sonda Vaisala RS41-SG: dal flash del firmware alla decodifica live di GPS, temperatura e umidità, fino all'upload automatico su SondeHub.
Cosa sono i palloni sonda e la RS41-SG
Due volte al giorno — alle 00:00 UTC e alle 12:00 UTC — stazioni meteorologiche di tutto il mondo lanciano un pallone riempito di elio che trasporta in quota una piccola unità elettronica chiamata radiosonda. In Italia l'Aeronautica Militare usa la Vaisala RS41-SG, lo standard meteorologico attuale.
Durante la salita (circa 5 m/s, fino a oltre 35 km di quota) la sonda trasmette ininterrottamente via radio i valori di:
- Temperatura dell'aria (precisione ±0.3°C)
- Umidità relativa (±3% RH)
- Posizione GPS — latitudine, longitudine, altitudine
- Vento — velocità e direzione, calcolati dalla derivata del GPS
- Pressione (modelli SGP, stimata nella SG da GPS+temperatura)
- Numero seriale univoco del dispositivo (es.
S3210504)
La trasmissione radio della RS41-SG avviene con questi parametri fissi:
Modulazione : GFSK (Gaussian FSK)
Baud rate : 4800 baud
Deviazione : 2.4 kHz (peak, single-sided) → 4.8 kHz peak-to-peak
Frequenza : 400–406 MHz (assegnata dalla stazione, tipicamente in Italia 402–405 MHz)
Potenza TX : ~60 mW EIRP
Cadenza : 1 frame/secondo
Frame size : 240 byte (RS41-SG standard)
Sync word : 0x10 0xB6 0xCA 0x11 0x22 0x96 0x12 0xF8
ECC : Reed-Solomon (255,231)L'etichetta "433MHz" indica la banda LoRa per cui la scheda è ottimizzata, ma il chip radio Semtech SX1276 in modalità FSK copre l'intero range da 137 a 1020 MHz. I palloni sonda trasmettono a 400–406 MHz: all'interno di quel range, e il SX1276 li riceve perfettamente in modalità FSK. Nessun modifica hardware necessaria.
Stazioni di lancio italiane e frequenze
In Italia ci sono 8 stazioni di radiosondaggio attive, tutte con lancio alle 00 e
alle 12 UTC (le 02:00 e le 14:00 ora italiana in estate, 01:00 e 13:00 in inverno). Le frequenze
sono assegnate e possono variare: usa sempre SondeHub (sondehub.org) o Radiosondy
(radiosondy.info) per verificare la frequenza attuale in tempo reale.
# Stazione WMO Frequenze tipiche (MHz)
Cuneo – Levaldigi 16080 402.800 / 405.000
Cameri – Novara 16090 404.800 / 403.000
Udine – Rivolto 16044 403.000 / 405.700
S.Pietro Capofiume BO 16144 403.400 / 404.200
Pratica di Mare (RM) 16245 403.000 / 405.800
Galatina – Lecce 16320 402.000 / 404.000
Trapani – Birgi 16429 402.500 / 403.800
Cagliari-Decimomannu 16560 402.800 / 403.500La portata di ricezione a terra dipende dall'altitudine della sonda: con un'antenna omnidirezionale semplice si riceve spesso fino a 300–400 km di distanza quando la sonda è in quota. Con la sonda vicina al suolo serve essere a meno di 50–60 km.
Vai su sondehub.org o radiosondy.info, seleziona la tua area geografica e cerca le sonde attive nelle ultime ore. La frequenza esatta di ogni lancio è mostrata nei dettagli della sonda. Annota le frequenze delle stazioni più vicine a te: le userai nella configurazione.
Via rapida — firmware rdzTTGOsonde
Il firmware open-source rdzTTGOsonde (di DL9RDZ) è la soluzione più completa e immediata. Trasforma il TTGO in un decoder standalone per RS41, RS92, DFM06/09/17 e altri tipi di sonda, con interfaccia web, scansione automatica e upload diretto su SondeHub. Nessuna riga di codice da scrivere.
Passo 1 — Scarica l'ultima release precompilata dalla pagina GitHub:
# Clona il repo o scarica direttamente la release .bin dalla pagina GitHub
# https://github.com/dl9rdz/rdz_ttgo_sonde/releases
# Installa esptool se non già presente
pip install esptool --break-system-packages
# Trova la porta seriale del TTGO (Linux/macOS)
ls /dev/tty* | grep -i usb
# Su Windows: Gestione dispositivi → Porte COM (COMx)Passo 2 — Flash del firmware. Sostituisci /dev/ttyUSB0 con la porta
rilevata e firmware.bin con il nome del file scaricato:
esptool.py --chip esp32 \
--port /dev/ttyUSB0 \
--baud 921600 \
--before default_reset \
--after hard_reset \
write_flash -z \
--flash_mode dio \
--flash_freq 80m \
--flash_size detect \
0x1000 firmware.binLe versioni recenti del firmware non supportano i board con cristallo a 26
MHz (TTGO LoRa32 v1, Heltec v1/v2). Se hai una v1, usa la release
rdz_ttgo_sonde-0.8.x o inferiore. Le versioni v2 e v2.1 (cristallo 32 MHz)
funzionano con le release correnti senza problemi.
Passo 3 — Al primo avvio il TTGO crea un proprio access point WiFi:
SSID : RDZsonde
Password : RDZsonde
URL : http://192.168.4.1/Connettiti a questa rete con il tuo PC o smartphone, poi apri il browser all'indirizzo
http://192.168.4.1/. Apparirà l'interfaccia web di configurazione.
Configurazione via interfaccia web
L'interfaccia web ha diverse schede. Queste sono le impostazioni fondamentali da modificare prima di iniziare a ricevere.
Scheda WiFi — Aggiungi la tua rete domestica per permettere al TTGO di connettersi e accedere a Internet (necessario per SondeHub):
SSID 1 : NomeRetaCasaTua
Pass 1 : PasswordWiFi
# Puoi aggiungere fino a 3 reti (es. hotspot dello smartphone per uso mobile)Scheda QRG — Configura i canali da monitorare. Inserisci le frequenze delle stazioni vicino a te:
# Formato: frequenza (MHz) | tipo sonda
CH 1 : 402.800 RS41 # Cuneo – frequenza principale
CH 2 : 404.800 RS41 # Cameri/Novara
CH 3 : 405.000 RS41 # Cuneo – frequenza secondaria
CH 4 : 403.000 RS41 # Udine / Pratica di Mare
# Aggiorna sempre le frequenze guardando sondehub.orgScheda Config → General — Imposta la posizione fissa della tua stazione (necessario per SondeHub):
WiFi Mode : 3 # Connettiti alla rete esistente
Latitude : 45.4654 # La tua latitudine (es. Milano)
Longitude : 9.1859 # La tua longitudine
Altitude : 122 # Altitudine in metri sul mareScheda Config → SondeHub — Abilita l'upload dei dati alla community globale:
SondeHub reporting : 1 # Attiva upload
SondeHub location : 1 # Posizione fissa
Callsign : TUO-CALL # Nominativo o pseudonimo
Antenna : 1/4 wave GP # Descrizione antenna
# Import frequenze automatico da SondeHub (opzionale ma comodo)
SondeHub freq. import : 1
Import frequency : 5 # Ogni 5 minuti
Import max distance : 300 # km di raggioSalva le modifiche e vai su Config → Control → Reboot. Al riavvio il TTGO si collegherà alla tua rete WiFi e il display mostrerà l'indirizzo IP locale. Naviga a quell'IP per accedere all'interfaccia anche quando sei connesso alla stessa rete.
In modalità scan il TTGO scorre automaticamente tutti i canali configurati cercando una sonda attiva. Quando ne trova una, si blocca su quella frequenza, il display mostra ID, coordinate GPS e RSSI, e i dati vengono inviati a SondeHub. Diventi un punto verde sulla mappa globale dei ricevitori.
Navigare le modalità con i pulsanti
Il TTGO ha tre pulsanti fisici. Il pulsante RESET (button 3) riavvia il dispositivo. Il pulsante principale (button 2) controlla le modalità operative:
- Pressione breve singola — In modalità spettro: passa a scan. In scan: passa a decoder su quel canale. In decoder: passa al canale successivo nella lista.
- Doppia pressione rapida — Torna sempre alla modalità scan automatico.
- Pressione media (~3 sec) — Apre la modalità spettro (visualizza il segnale RF grezzo).
- Pressione lunga (>5 sec) — Riavvia la connessione WiFi (utile se il TTGO non si connette alla rete).
Sul display OLED, nella barra in fondo, vengono mostrati gli ultimi 18 frame ricevuti: |
= decodifica riuscita, . = frame non ricevuto, E = errore CRC.
Nell'interfaccia web la scheda Data mostra in tempo reale tutti i parametri decodificati: ID sonda, frame number, latitudine, longitudine, altitudine, velocità verticale, temperatura, umidità e RSSI del segnale. È la vista più utile per monitorare la ricezione da PC.
Approccio da zero — ricevere RS41 con Arduino e RadioLib
Se vuoi capire il meccanismo e costruire il tuo decoder, ecco come impostare il SX1276 in modalità FSK per ricevere i frame RS41. Questo approccio richiede più lavoro ma ti dà pieno controllo sul parsing dei dati.
Il SX1276 viene configurato in modalità FSK con i parametri esatti della RS41. La libreria RadioLib gestisce la ricezione a livello di chip; il decoding del frame è compito del tuo codice.
Dipendenze in platformio.ini:
[env:ttgo-lora32-v21]
platform = espressif32
board = ttgo-lora32-v1
framework = arduino
monitor_speed = 115200
lib_deps =
jgromes/RadioLib
adafruit/Adafruit SSD1306
adafruit/Adafruit GFX LibrarySketch — configurazione SX1276 in FSK e ricezione raw frame RS41:
#include <RadioLib.h>
#include <Wire.h>
#include <Adafruit_SSD1306.h>
// Pin TTGO LoRa32 v2.1
#define LORA_SS 18
#define LORA_DIO0 26
#define LORA_RST 23
#define LORA_DIO1 33
#define OLED_SDA 21
#define OLED_SCL 22
#define OLED_RST 16
// Frequenza RS41 della stazione più vicina (cambia in base alla tua posizione)
#define RS41_FREQ 402.800 // Cuneo – verifica sempre su sondehub.org
// Dimensione frame RS41 standard (240 byte)
#define RS41_FRAME_LEN 240
SX1276 radio = new Module(LORA_SS, LORA_DIO0, LORA_RST, LORA_DIO1);
Adafruit_SSD1306 display(128, 64, &Wire, OLED_RST);
// Sync word RS41: 8 byte (usati i primi 2 configurabili nel SX1276)
uint8_t rs41SyncWord[] = { 0x10, 0xB6 };
volatile bool rxFlag = false;
void IRAM_ATTR onReceive() {
rxFlag = true;
}
void setup() {
Serial.begin(115200);
// Init OLED
Wire.begin(OLED_SDA, OLED_SCL);
display.begin(SSD1306_SWITCHCAPVCC, 0x3C);
display.clearDisplay();
display.setTextSize(1);
display.setTextColor(SSD1306_WHITE);
display.println("RS41 Receiver");
display.printf("Freq: %.3f MHz\n", RS41_FREQ);
display.display();
// Init SX1276 in modalità FSK con parametri RS41
SPI.begin(5, 19, 27, LORA_SS); // SCK, MISO, MOSI, SS
int state = radio.beginFSK(
RS41_FREQ, // frequenza MHz
4.8, // baud rate kbps
2.4, // deviazione kHz (single-sided)
12.5, // bandwidth RX kHz — minimo che copre 4.8+2.4*2
10, // potenza TX dBm (irrilevante in RX)
16 // lunghezza preamble (in byte)
);
if (state != RADIOLIB_ERR_NONE) {
Serial.printf("Init fallito: %d\n", state);
display.println("ERRORE init radio!");
display.display();
while (true);
}
// Sync word RS41 (2 byte configurabili nel SX1276)
radio.setSyncWord(rs41SyncWord, 2);
// Lunghezza pacchetto fissa (RS41 frame = 240 byte incluso sync)
radio.fixedPacketLengthMode(RS41_FRAME_LEN);
radio.disableCRC(); // CRC gestito internamente dal frame RS41
// Callback interrupt su ricezione completata
radio.setPacketReceivedAction(onReceive);
radio.startReceive();
Serial.println("In ascolto...");
display.println("In ascolto...");
display.display();
}
void loop() {
if (!rxFlag) return;
rxFlag = false;
uint8_t frame[RS41_FRAME_LEN];
int state = radio.readData(frame, RS41_FRAME_LEN);
if (state != RADIOLIB_ERR_NONE) {
Serial.printf("Errore ricezione: %d\n", state);
radio.startReceive();
return;
}
float rssi = radio.getRSSI();
Serial.printf("Frame ricevuto! RSSI: %.1f dBm\n", rssi);
// Stampa hex del frame grezzo — utile per debug e sviluppo del parser
Serial.print("RAW: ");
for (int i = 0; i < RS41_FRAME_LEN; i++) {
Serial.printf("%02X ", frame[i]);
}
Serial.println();
// Il frame RS41 è whitened (XOR con sequenza pseudo-casuale)
// e contiene blocchi con CRC-16. Il parsing completo è nella sezione 7.
display.clearDisplay();
display.setCursor(0, 0);
display.printf("RS41 %.3f MHz\n", RS41_FREQ);
display.printf("RSSI: %.0f dBm\n", rssi);
display.printf("Frame: %02X%02X\n", frame[6], frame[7]);
display.display();
radio.startReceive();
}I byte ricevuti dal SX1276 non sono i dati grezzi della sonda: l'RS41 applica una whitening sequence (XOR con una sequenza pseudo-casuale nota) per distribuire uniformemente gli 0 e gli 1 nel segnale. Prima di poter leggere qualsiasi dato bisogna invertire questa operazione. Vedi la sezione 7 per il codice di de-whitening.
Struttura e parsing del frame RS41
Ogni frame RS41 ha una struttura precisa. Dopo il sync word (8 byte) arriva il dato vero e proprio, organizzato in blocchi tipati con CRC individuale. Prima di leggere qualsiasi campo va applicata la de-whitening sequence.
Offset Len Contenuto
0x00 8 Sync word: 10 B6 CA 11 22 96 12 F8
0x08 2 Header di frame (tipo, lunghezza)
0x0A 2 Numero frame (incrementa ogni secondo)
--- Blocco STATUS (0x79) ---
0x0C 1 Tipo blocco: 0x79
0x0D 1 Lunghezza blocco
0x0E 8 Serial number sonda (ASCII, es. "S3210504")
... ... Stato batteria, burst kill, etc.
-- 2 CRC-16 del blocco STATUS
--- Blocco MEAS (0x7A) — dati PTU ---
-- 1 Tipo blocco: 0x7A
... ... Frequenza sensore T, sensore RH (raw ADC)
-- 2 CRC-16 del blocco MEAS
--- Blocco GPSPOS (0x7C) — posizione GPS ---
-- 1 Tipo blocco: 0x7C
-- 4 Longitudine (int32, gradi × 1e7)
-- 4 Latitudine (int32, gradi × 1e7)
-- 4 Altitudine (uint32, mm sul mare)
-- 4 Velocità E-W (mm/s)
-- 4 Velocità N-S (mm/s)
-- 4 Velocità verticale (mm/s)
-- 1 Satelliti in uso
-- 2 CRC-16 del blocco GPSPOSEcco il codice C++ per il de-whitening e il parsing dei campi principali. La sequenza XOR è definita nello standard RS41 ed è nota e pubblica:
// Sequenza di de-whitening RS41 (primi 256 byte, completa 512 byte)
static const uint8_t RS41_WHITENING[] = {
0x96, 0x83, 0x3E, 0x51, 0xB1, 0x49, 0x08, 0x98,
0x32, 0x05, 0x59, 0x0E, 0xF9, 0x44, 0xC6, 0x26,
0x21, 0x60, 0xC2, 0xEA, 0x79, 0x5D, 0x6D, 0xA1,
0x54, 0x69, 0x47, 0x0C, 0xDC, 0xE8, 0x5C, 0xF1,
// ... continua per 512 byte totali
// Lista completa: github.com/bazjo/RS41_Decoding
};
// Struttura dati RS41 parsata
struct RS41Frame {
char serial[9]; // Numero seriale (es. "S3210504")
uint16_t frameNum; // Contatore frame (0..65535, poi riparte)
float lat; // Latitudine in gradi decimali
float lon; // Longitudine in gradi decimali
float alt; // Altitudine in metri
float velV; // Velocità verticale in m/s (+ = salita)
uint8_t sats; // Numero di satelliti GPS
bool valid; // CRC ok su almeno un blocco
};
// CRC-16 CCITT-FALSE (polynom 0x1021, init 0xFFFF)
uint16_t crc16(const uint8_t *data, int len) {
uint16_t crc = 0xFFFF;
for (int i = 0; i < len; i++) {
crc ^= (uint16_t)data[i] << 8;
for (int b = 0; b < 8; b++)
crc = (crc & 0x8000) ? (crc << 1) ^ 0x1021 : crc << 1;
}
return crc;
}
bool parseRS41(uint8_t *raw, int len, RS41Frame &out) {
// 1. De-whitening: XOR con la sequenza nota, saltando i primi 8 byte (sync)
for (int i = 8; i < len; i++)
raw[i] ^= RS41_WHITENING[i - 8];
// 2. Numero frame (offset 0x08, 2 byte little-endian)
out.frameNum = raw[8] | (raw[9] << 8);
// 3. Blocco STATUS (tipo 0x79, inizia a offset 0x0C)
if (raw[0x0C] == 0x79) {
memcpy(out.serial, &raw[0x0E], 8);
out.serial[8] = '\0';
// TODO: verifica CRC-16 del blocco STATUS
}
// 4. Cerca il blocco GPSPOS (tipo 0x7C) scorrendo il frame
out.valid = false;
for (int i = 0x0C; i < len - 4; i++) {
if (raw[i] == 0x7C) {
uint8_t blen = raw[i + 1];
if (i + blen + 4 > len) break;
// Verifica CRC-16 del blocco GPS
uint16_t crcGot = raw[i + 2 + blen] | (raw[i + 3 + blen] << 8);
uint16_t crcCalc = crc16(&raw[i], blen + 2);
if (crcGot != crcCalc) break;
// Leggi i campi GPS (little-endian int32)
int32_t lonRaw, latRaw, altRaw, velVRaw;
memcpy(&lonRaw, &raw[i + 2], 4);
memcpy(&latRaw, &raw[i + 6], 4);
memcpy(&altRaw, &raw[i + 10], 4);
memcpy(&velVRaw,&raw[i + 22], 4);
out.lon = lonRaw / 1e7f;
out.lat = latRaw / 1e7f;
out.alt = altRaw / 1000.0f;
out.velV = velVRaw / 1000.0f;
out.sats = raw[i + 26];
out.valid = true;
break;
}
}
return out.valid;
}Con parseRS41() nel loop puoi stampare sul display e sulla porta seriale i dati
decodificati:
RS41Frame sonde;
if (parseRS41(frame, RS41_FRAME_LEN, sonde) && sonde.valid) {
Serial.printf("[%s] #%u | %.5f,%.5f | Alt: %.0f m | V: %+.1f m/s | Sat: %u\n",
sonde.serial, sonde.frameNum,
sonde.lat, sonde.lon, sonde.alt,
sonde.velV, sonde.sats);
display.clearDisplay();
display.setCursor(0, 0);
display.printf("%s #%u\n", sonde.serial, sonde.frameNum);
display.printf("%.4f,%.4f\n", sonde.lat, sonde.lon);
display.printf("Alt: %.0f m\n", sonde.alt);
display.printf("V: %+.1f m/s Sat:%u\n", sonde.velV, sonde.sats);
display.printf("RSSI: %.0f dBm\n", rssi);
display.display();
}Antenna — elemento critico per la ricezione
L'antenna è il fattore più importante per la portata di ricezione. Le RS41 trasmettono a ~402–405 MHz: la lunghezza d'onda è di circa 74 cm, quindi un quarto d'onda equivale a 18.5 cm.
Opzione 1 — Filo verticale (la più semplice): collega un filo di rame da 18.5 cm al connettore SMA del TTGO, tienilo verticale. È la soluzione minima ma funzionante per sonde vicine o in alta quota.
Opzione 2 — Ground plane antenna (consigliata): un dipolo verticale con 4 radiali a 45°. Guadagno circa 2 dBi, costruzione economica:
Elemento verticale : 18.5 cm (λ/4)
Radiali (× 4) : 19.0 cm (leggermente più lunghi, inclinati a 45°)
Materiale : filo di rame da 1–1.5 mm, oppure spinotti
Connettore : SMA maschio (adattatore SMA → filo saldato)
Guadagno stimato : ~2.2 dBiOpzione 3 — Antenna Yagi-Uda direttiva: per il "radiosonde chasing" (recupero fisico delle sonde) una Yagi da 5–7 elementi per 403 MHz offre 8–10 dBi di guadagno. Puntandola verso il cielo nella direzione della sonda si guadagnano molti chilometri di portata aggiuntiva.
La banda 400–406 MHz è riservata alle operazioni meteorologiche e scientifiche. Il TTGO in modalità ricezione (firmware rdzTTGOsonde o sketch Arduino senza LoRa.beginPacket) non trasmette e non richiede licenze. Qualsiasi trasmissione in questa banda richiede autorizzazione ministeriale.
Verifica — output atteso e troubleshooting
Con il firmware rdzTTGOsonde attivo e una sonda in area, il monitor seriale (115200 baud) mostrerà qualcosa di simile a questo ogni secondo:
[S3210504] #1842 | lat:44.6201 lon:7.6587 | alt:8234m | Tv:-0.1m/s | RSSI:-82dBm
[S3210504] #1843 | lat:44.6195 lon:7.6601 | alt:8239m | Tv:-0.1m/s | RSSI:-83dBm
[S3210504] #1844 | lat:44.6188 lon:7.6614 | alt:8244m | Tv: 0.0m/s | RSSI:-82dBm
Sondehub upload OK (3 frames)Se non ricevi nulla, segui questa lista di controllo:
- Nessuna sonda attiva nell'area — controlla
sondehub.orgper verificare se ci sono lanci in corso nelle prossime ore vicino a te. I lanci avvengono alle 00 e 12 UTC. - Frequenza errata — le frequenze cambiano ad ogni lancio. Verifica sempre su SondeHub o abilita l'import automatico nella configurazione.
- Antenna sconnessa o assente — il SX1276 senza antenna non riesce a ricevere segnali deboli. Collega almeno un filo da 18.5 cm.
- RSSI troppo basso (< -110 dBm) — la sonda è troppo lontana o sotto
l'orizzonte. In modalità ricezione scan il TTGO lo segnalerà con molti punti (
.) nella barra in fondo al display. - Frequenza leggermente off — il quarzo del SX1276 può avere tolleranza di ±10 ppm (~4 kHz a 403 MHz). Se ricevi ma con molti errori CRC, prova a spostare la frequenza di ±5 kHz.
Se vedi i frame decodificati e SondeHub reporting è attivo, apri sondehub.org e
cerca il seriale della sonda. Vedrai la traiettoria in tempo reale con il tuo contributo — e
il tuo nominativo come stazione ricevente. Benvenuto nella community dei radiosonde hunters!
Risorse e passi successivi
Ora che hai la stazione funzionante, questi sono i riferimenti più utili per approfondire:
- github.com/dl9rdz/rdz_ttgo_sonde — firmware principale con wiki e lista board supportate
- sondehub.org — tracker globale in tempo reale con dati meteorologici e mappa ricevitori
- radiosondy.info — tracker alternativo con archivio storico e notifiche lancio
- github.com/bazjo/RS41_Decoding — documentazione completa del frame RS41 con tutti i blocchi e campi
- RS Hunters — gruppo Telegram italiano di radioamatori specializzati nel recupero e studio delle radiosonde (cerca "RS Hunters" su Telegram)
- iz2fly.altervista.org/radiosonde/ — risorsa italiana completa con firmware, manuali e community locale
Il passo naturale successivo è il radiosonde chasing: seguire fisicamente la sonda durante la discesa per recuperarla prima che atterri. Con rdzTTGOsonde in modalità "chase" (posizione GPS dinamica), il TTGO continua a decodificare i dati mentre sei in movimento, e SondeHub mostra la previsione di atterraggio aggiornata in tempo reale.
In Italia le radiosonde sono materiale dell'Aeronautica Militare. Se ne recuperi una, segui le istruzioni riportate sul dispositivo stesso per il reso o contatta la stazione di lancio. Mediamente solo il 20% delle sonde viene recuperato. Quelle non restituite possono essere riutilizzate dai radioamatori per sperimentazione, inclusa la riprogrammazione per APRS o altri usi amatoriali.