Modulo RF 433 MHz Arduino: trasmettitore, ricevitore e antenna

Un modulo RF 433 MHz è il modo più economico per aggiungere un collegamento wireless a un progetto Arduino: un kit composto da un trasmettitore (FS1000A) e un ricevitore (XY-MK-5V) costa pochissimo, si collega con un solo filo di dati e, con un'antenna a filo di 17 cm, porta il segnale a decine di metri. Anche prese radiocomandate, campanelli wireless, telecomandi delle tapparelle, sensori di apertura di porte e finestre e i sensori esterni delle stazioni meteo usano quasi sempre la stessa frequenza. Con questi moduli puoi quindi inviare dati tra due Arduino e anche leggere i codici dei telecomandi che hai in casa per poi ritrasmetterli da Arduino.

In questa guida scoprirai come funzionano i moduli con la modulazione ASK (OOK), perché l'antenna deve essere lunga 17,3 cm e come collegarli ad Arduino Uno, ESP32 e Raspberry Pi Pico. Poi invierai testo e dati dei sensori tra due Arduino con la libreria RadioHead, leggerai e clonerai il codice del telecomando di una presa con la libreria RCSwitch, vedrai come aumentare la portata e confronterai il modulo con l'nRF24L01.

Cos'è un modulo RF 433 MHz e come funziona?

Il kit è formato da due schede separate. Il piccolo trasmettitore quadrato FS1000A (venduto anche come XY-FST) accende e spegne un'onda portante a 433,92 MHz in base al segnale sul suo pin DATA. Il ricevitore XY-MK-5V, più lungo, capta questo segnale dall'aria e lo restituisce come 0 e 1 sul suo pin DATA. In altre parole, i moduli non hanno né protocollo, né indirizzo, né controllo degli errori; il loro unico compito è portare un segnale digitale senza fili dall'altra parte. Impacchettare, verificare e decodificare i dati è compito della libreria su Arduino. La comunicazione è unidirezionale: il trasmettitore invia soltanto e il ricevitore ascolta soltanto.

I due pin DATA del ricevitore sono collegati tra loro sulla scheda: non importa quale usi. L'XY-MK-5V è un ricevitore a superreazione economico ma poco selettivo: la sua frequenza è fissata da una bobina regolabile sulla scheda ed è facilmente disturbato dalle interferenze vicine. Non girare la vite di questa bobina; se si perde la taratura di fabbrica, il ricevitore non sente più il trasmettitore. Per risultati più stabili, i ricevitori supereterodina come l'RXB6 sono più sensibili e funzionano anche a 3,3 V. Il kit esiste anche in versione a 315 MHz; trasmettitore e ricevitore devono avere la stessa frequenza, e sul risonatore metallico del trasmettitore di solito è stampata la frequenza.

Modulazione ASK (OOK): perché ti serve una libreria?

Nella OOK (On-Off Keying), la forma più semplice di ASK (Amplitude Shift Keying, modulazione a spostamento d'ampiezza), la portante viene accesa per un bit 1 e spenta per un bit 0. Sembra facile, ma il ricevitore ha un'abitudine: il suo controllo automatico del guadagno (AGC), in assenza di segnale, porta il guadagno al massimo, scambia il rumore nell'aria per dati e manda di continuo impulsi casuali sul pin DATA. Per questo collegare il trasmettitore direttamente al pin TX di Arduino e il ricevitore al pin RX per comunicare con Serial.print di solito produce solo caratteri senza senso.

Il driver RH_ASK della libreria RadioHead risolve il problema così: prima di ogni pacchetto invia un preambolo di 36 bit e un simbolo di inizio di 12 bit per far assestare il guadagno del ricevitore. Poi converte ogni byte in due simboli da 6 bit bilanciati in continua (codifica da 4 a 6) e aggiunge un CRC a 16 bit alla fine del pacchetto. Il ricevitore scarta in silenzio i pacchetti con CRC errato, così ti arrivano solo dati integri. RCSwitch, invece, decodifica la codifica a larghezza d'impulso usata dai chip dei telecomandi: ogni bit è rappresentato da impulsi che restano HIGH e LOW per tempi precisi.

Lunghezza dell'antenna a 433 MHz: perché 17,3 cm?

I moduli non hanno un'antenna montata, ma solo una piazzola di saldatura marcata ANT. Senza antenna, un kit funziona solo a 1–3 metri. L'antenna semplice più efficiente è un filo dritto lungo un quarto della lunghezza d'onda: λ = c / f = 300.000.000 / 433.920.000 ≈ 0,69 m, e un quarto corrisponde a circa 17,3 cm. Per i moduli a 315 MHz lo stesso calcolo dà 23,8 cm. Salda un'estremità di un filo rigido unipolare alla piazzola ANT e tieni il filo dritto e verticale; salda un filo della stessa lunghezza anche al ricevitore e orienta le due antenne nella stessa direzione.

Collegamento del modulo RF 433 MHz: Arduino Uno, ESP32 e Pico

Il trasmettitore funziona senza problemi con un segnale a 3,3 V sul pin DATA: su ESP32 e Pico puoi quindi alimentarlo a 5 V e collegare DATA direttamente a un GPIO. La portata dipende soprattutto dalla tensione del trasmettitore: a 3,3 V si riduce nettamente, a 9–12 V aumenta di parecchie volte. Mettere un condensatore ceramico da 100 nF e uno elettrolitico da 10 µF proprio accanto ai pin VCC e GND del ricevitore riduce il rumore dell'alimentazione e migliora visibilmente la ricezione.

Inviare messaggi tra due Arduino con RadioHead

1. Apri il Gestore librerie dell'IDE Arduino, cerca RadioHead e installa la libreria di Mike McCauley. Per i dettagli consulta come aggiungere una libreria ad Arduino.
2. Collega il trasmettitore al primo Arduino: DATA → D12, VCC → 5V, GND → GND.
3. Collega il ricevitore al secondo Arduino: DATA → D11, VCC → 5V, GND → GND.
4. Salda un filo da 17,3 cm alla piazzola ANT di ciascun modulo.
5. Carica il codice del trasmettitore sulla prima scheda e quello del ricevitore sulla seconda, poi apri il Monitor seriale sul lato del ricevitore a 9600 baud.

1#include <RH_ASK.h>
2#include <SPI.h>                  // RadioHead derlemesi için / needed for RadioHead to compile
3
4RH_ASK rf(2000, 11, 12);          // hız (bps), RX pini, TX pini / speed (bps), RX pin, TX pin
5unsigned int sayac = 0;
6
7void setup() {
8  Serial.begin(9600);
9  if (!rf.init()) Serial.println("RF init hatasi / failed");
10}
11
12void loop() {
13  char mesaj[24];
14  snprintf(mesaj, sizeof(mesaj), "Merhaba %u", sayac++);
15  rf.send((uint8_t *)mesaj, strlen(mesaj));
16  rf.waitPacketSent();            // paket bitene kadar bekle / wait until the packet is sent
17  Serial.print("Gonderildi / sent: ");
18  Serial.println(mesaj);
19  delay(1000);
20}

1#include <RH_ASK.h>
2#include <SPI.h>                  // RadioHead derlemesi için / needed for RadioHead to compile
3
4RH_ASK rf(2000, 11, 12);          // vericiyle aynı hız / same speed as the transmitter
5
6void setup() {
7  Serial.begin(9600);
8  if (!rf.init()) Serial.println("RF init hatasi / failed");
9}
10
11void loop() {
12  uint8_t buf[RH_ASK_MAX_MESSAGE_LEN + 1];   // +1: metin sonu için / +1 for the string terminator
13  uint8_t len = RH_ASK_MAX_MESSAGE_LEN;      // her turda yeniden ayarla / reset on every pass
14  if (rf.recv(buf, &len)) {                  // yalnız CRC doğruysa true / true only if the CRC is valid
15    buf[len] = '\0';
16    Serial.print("Alindi / received: ");
17    Serial.println((char *)buf);
18  }
19}

Nel codice del ricevitore è importante reimpostare la variabile len a ogni giro: recv() vi scrive la dimensione del pacchetto ricevuto e alla chiamata successiva quel valore viene preso come dimensione del buffer; se non la reimposti, i messaggi più lunghi vengono troncati. Se tutto va bene, nel Monitor seriale vedrai ogni secondo le righe "Merhaba 0", "Merhaba 1". Se mancano dei numeri, alcuni pacchetti sono andati persi per strada; in quel caso controlla l'antenna e l'alimentazione.

Inviare dati dei sensori: un pacchetto con struct

Nei progetti reali inviare numeri è più efficiente che inviare testo. Puoi raccogliere le misure in una struct e inviarne i byte così come sono. Il trasmettitore qui sotto invia cinque volte al secondo il valore di una LDR o di un potenziometro su A0 e lo stato del pulsante su D2. Il ricevitore accende il LED su D13 quando viene premuto il pulsante remoto e si accorge dei pacchetti persi.

1#include <RH_ASK.h>
2#include <SPI.h>
3
4struct __attribute__((packed)) Paket {   // iki tarafta birebir aynı olmalı / must be identical on both sides
5  uint16_t no;                           // paket numarası / packet number
6  int16_t deger;                         // analog değer / analog value
7  uint8_t buton;                         // 1 = basılı / 1 = pressed
8};
9
10RH_ASK rf;                               // varsayılan: 2000 bps, RX 11, TX 12 / defaults
11Paket p = {0, 0, 0};
12
13void setup() {
14  pinMode(2, INPUT_PULLUP);              // buton D2-GND / button D2-GND
15  rf.init();
16}
17
18void loop() {
19  p.no++;
20  p.deger = analogRead(A0);              // örneğin LDR ya da potansiyometre / e.g. LDR or potentiometer
21  p.buton = (digitalRead(2) == LOW);
22  rf.send((uint8_t *)&p, sizeof(p));
23  rf.waitPacketSent();
24  delay(200);
25}

1#include <RH_ASK.h>
2#include <SPI.h>
3
4struct __attribute__((packed)) Paket {
5  uint16_t no;
6  int16_t deger;
7  uint8_t buton;
8};
9
10RH_ASK rf;
11const int LED = 13;
12uint16_t sonNo = 0;
13
14void setup() {
15  Serial.begin(9600);
16  pinMode(LED, OUTPUT);
17  rf.init();
18}
19
20void loop() {
21  Paket p;
22  uint8_t len = sizeof(p);
23  if (rf.recv((uint8_t *)&p, &len) && len == sizeof(p)) {
24    digitalWrite(LED, p.buton ? HIGH : LOW);   // uzaktaki buton LED'i yakar / remote button lights the LED
25    if (sonNo != 0 && p.no != (uint16_t)(sonNo + 1)) {
26      Serial.println("Paket kaybi / packet lost");
27    }
28    sonNo = p.no;
29    Serial.print(p.no);
30    Serial.print("  A0 = ");
31    Serial.println(p.deger);
32  }
33}

L'attributo __attribute__((packed)) impedisce al compilatore di inserire byte di riempimento tra i campi. È importante: la stessa struct può occupare 5 byte su Arduino Uno e 6 su ESP32, e quando comunicano due schede diverse i dati si sfasano. Grazie al numero di pacchetto il ricevitore può contare le perdite. Dato che i moduli a 433 MHz non hanno conferma di ricezione, è buona abitudine ripetere più volte i comandi importanti. Se metti trasmettitore e ricevitore su entrambi i lati, puoi anche creare una comunicazione con conferme e ritrasmissioni usando la classe RHReliableDatagram di RadioHead.

Leggere i codici dei telecomandi commerciali con RCSwitch

Molte prese radiocomandate, campanelli wireless, telecomandi di tapparelle e cancelli, oltre ai sensori di apertura e ai sensori PIR degli allarmi, usano chip codificatori come l'EV1527 o il PT2262. A ogni pressione questi chip inviano lo stesso codice da 12 a 24 bit più volte di seguito, separato da pause di sincronizzazione. La libreria RCSwitch (rc-switch nel Gestore librerie) decodifica questi codici. Su Arduino Uno collega il pin DATA del ricevitore a un pin di interrupt, cioè D2 o D3, e carica il codice seguente:

1#include <RCSwitch.h>
2
3RCSwitch rf = RCSwitch();
4
5void setup() {
6  Serial.begin(9600);
7  rf.enableReceive(digitalPinToInterrupt(2));   // alıcı DATA -> D2 (kesme pini) / receiver DATA -> D2 (interrupt pin)
8  Serial.println(F("Kumandanin tusuna bas / press a remote button"));
9}
10
11void loop() {
12  if (rf.available()) {
13    Serial.print(F("Kod / code: "));
14    Serial.print(rf.getReceivedValue());
15    Serial.print(F("  Bit: "));
16    Serial.print(rf.getReceivedBitlength());
17    Serial.print(F("  Protokol / protocol: "));
18    Serial.print(rf.getReceivedProtocol());
19    Serial.print(F("  Darbe / pulse: "));
20    Serial.print(rf.getReceivedDelay());
21    Serial.println(F(" us"));
22    rf.resetAvailable();                         // bir sonraki koda hazırlan / get ready for the next code
23  }
24}

Apri il Monitor seriale e premi un tasto del telecomando; vedrai una riga come "Kod / code: 5393 Bit: 24 Protokol / protocol: 1 Darbe / pulse: 350 us". Annota per ogni tasto codice, numero di bit, protocollo e durata dell'impulso: per clonarlo ti serviranno tutti e quattro. Nei telecomandi con EV1527, i primi 20 dei 24 bit sono l'identificativo del telecomando e gli ultimi 4 il tasto premuto; per questo i codici dei tasti dello stesso telecomando sono molto vicini. Nel protocollo 1 un'unità dura circa 350 µs: un bit 0 è 1 unità HIGH e 3 LOW, un bit 1 è 3 unità HIGH e 1 LOW, e la sincronizzazione è 1 unità HIGH e 31 LOW.

Inviare il codice del telecomando da Arduino

Per inviare il codice letto, collega il pin DATA del trasmettitore a D10 e due pulsanti tra D4 e D5 e GND. Ogni volta che premi un pulsante, Arduino ripete il codice 10 volte, proprio come il telecomando; i tasti di accensione e spegnimento della presa ora sono sul tuo Arduino:

1#include <RCSwitch.h>
2
3RCSwitch rf = RCSwitch();
4const int BTN_AC = 4;            // "aç" butonu D4-GND / "on" button D4-GND
5const int BTN_KAPAT = 5;         // "kapat" butonu D5-GND / "off" button D5-GND
6
7void setup() {
8  pinMode(BTN_AC, INPUT_PULLUP);
9  pinMode(BTN_KAPAT, INPUT_PULLUP);
10  rf.enableTransmit(10);         // verici DATA -> D10 / transmitter DATA -> D10
11  rf.setProtocol(1);             // önce protokol... / protocol first...
12  rf.setPulseLength(350);        // ...sonra okuduğun darbe süresi / ...then the pulse length you read
13  rf.setRepeatTransmit(10);      // her gönderim 10 kez tekrarlanır / each send is repeated 10 times
14}
15
16void loop() {
17  if (digitalRead(BTN_AC) == LOW) {
18    rf.send(5393, 24);           // okuduğun "aç" kodu ve bit sayısı / the "on" code and bit length you read
19    delay(300);
20  }
21  if (digitalRead(BTN_KAPAT) == LOW) {
22    rf.send(5396, 24);           // okuduğun "kapat" kodu / the "off" code you read
23    delay(300);
24  }
25}

Poiché setProtocol() riporta la durata dell'impulso al valore predefinito del protocollo, chiama sempre setPulseLength() dopo. Se la presa non risponde, inserisci prima esattamente la durata d'impulso letta (ad es. 320 o 420 µs), poi porta le ripetizioni a 15. Le prese ad autoapprendimento offrono un'altra scorciatoia: se metti la presa in modalità apprendimento e invii da Arduino un qualsiasi codice a 24 bit, la presa lo memorizza. Così puoi creare codici tuoi senza clonare alcun telecomando.

Ricevitore 433 MHz con ESP32: comandare un relè con il telecomando

L'ESP32 è un ponte ideale per portare i telecomandi a 433 MHz nel mondo Wi-Fi. RCSwitch funziona anche su ESP32 e, dato che tutti i suoi GPIO accettano interrupt, puoi collegare il ricevitore al pin sicuro che preferisci. Il codice seguente legge i codici da un ricevitore collegato a GPIO 27 (con partitore di tensione); quando arriva il codice del tuo telecomando, commuta il LED su GPIO 2 o un modulo relè. Poiché il telecomando invia il codice molte volte con una sola pressione, il programma non commuta di nuovo finché il codice non si è interrotto per 600 ms:

1#include <RCSwitch.h>
2
3RCSwitch rf = RCSwitch();
4const int RX_PIN = 27;              // alıcı DATA, gerilim bölücüyle / receiver DATA, through a divider
5const int ROLE_PIN = 2;             // dahili LED ya da röle girişi / onboard LED or relay input
6const unsigned long KOD = 5393;     // kendi kumandanın kodu / your own remote's code
7bool durum = false;
8unsigned long sonGorulme = 0;
9
10void setup() {
11  Serial.begin(115200);
12  pinMode(ROLE_PIN, OUTPUT);
13  rf.enableReceive(digitalPinToInterrupt(RX_PIN));   // ESP32'de her GPIO kesme alır / every GPIO takes interrupts on the ESP32
14}
15
16void loop() {
17  if (rf.available()) {
18    unsigned long kod = rf.getReceivedValue();
19    Serial.printf("Kod / code: %lu  %u bit  protokol %u\n", kod, rf.getReceivedBitlength(), rf.getReceivedProtocol());
20    if (kod == KOD) {
21      // kumanda kodu art arda tekrarlar; yalnız yeni basışta değiştir / the remote repeats the code; toggle only on a new press
22      if (millis() - sonGorulme > 600) {
23        durum = !durum;
24        digitalWrite(ROLE_PIN, durum ? HIGH : LOW);
25      }
26      sonGorulme = millis();
27    }
28    rf.resetAvailable();
29  }
30}

Su questa base puoi costruire molto: inoltra i codici ricevuti a Home Assistant tramite MQTT per aggiungere economici sensori porta a 433 MHz alla tua domotica, oppure comanda le prese dal telefono con un trasmettitore su GPIO 26. Anche RadioHead supporta l'ESP32; l'unica differenza è che devi scrivere esplicitamente i pin nel costruttore: RH_ASK rf(2000, 27, 26, 25); (ricevitore 27, trasmettitore 26 e 25 come pin libero per il PTT). Se l'ESP32 è una novità per te, dai un'occhiata a Cos'è l'ESP32?.

Trasmettitore 433 MHz con Raspberry Pi Pico e MicroPython

MicroPython non ha un equivalente pronto di RCSwitch, ma la temporizzazione del protocollo 1 è così semplice che puoi scriverla da solo in poche righe. Collega il VCC dell'FS1000A al pin VBUS (5 V) del Pico, DATA a GP15 e un pulsante tra GP16 e GND. Quando premi il pulsante, il Pico invia i 24 bit partendo dal più significativo, come fa RCSwitch, aggiunge l'impulso di sincronizzazione alla fine e ripete l'intero pacchetto 10 volte. Se non sai ancora come installare MicroPython sul Pico, parti da Cos'è il Raspberry Pi Pico?.

1from machine import Pin
2import time
3
4tx = Pin(15, Pin.OUT, value=0)        # FS1000A DATA -> GP15
5buton = Pin(16, Pin.IN, Pin.PULL_UP)  # buton GP16-GND / button GP16-GND
6T = 350                               # darbe süresi µs (RCSwitch protokol 1) / pulse length µs (RCSwitch protocol 1)
7
8def darbe(yuksek, dusuk):             # süreler T cinsinden / durations in units of T
9    tx.value(1)
10    time.sleep_us(yuksek * T)
11    tx.value(0)
12    time.sleep_us(dusuk * T)
13
14def gonder(kod, bit=24, tekrar=10):
15    for _ in range(tekrar):
16        for i in range(bit - 1, -1, -1):   # en anlamlı bitten başla / start from the most significant bit
17            if (kod >> i) & 1:
18                darbe(3, 1)                # "1" biti: 3T HIGH, 1T LOW / bit "1"
19            else:
20                darbe(1, 3)                # "0" biti: 1T HIGH, 3T LOW / bit "0"
21        darbe(1, 31)                       # senkron: 1T HIGH, 31T LOW / sync
22
23while True:
24    if buton.value() == 0:                 # butona basıldı / button pressed
25        gonder(5393)                       # okuduğun kodu yaz / put the code you read here
26        time.sleep_ms(300)

Per il processore a 125 MHz del Pico, impulsi da 350 µs sono un ritmo comodo; i piccoli ritardi di Python restano ben al di sotto della tolleranza del 60% dei ricevitori RCSwitch. Puoi provare subito il codice mettendogli accanto un Arduino con il codice lettore RCSwitch: nel Monitor seriale dovrebbe comparire il numero inviato. Per la ricezione dovresti misurare e decodificare la durata degli impulsi con dei timestamp; per questo è più pratico un Arduino o un ESP32 con RCSwitch.

Portata e interferenze: portare il segnale più lontano

• Non dimenticare l'antenna: salda un filo dritto da 17,3 cm su entrambi i lati; è ciò che incide di più sulla portata.
• Alza la tensione del trasmettitore: alimentare l'FS1000A a 9–12 V aumenta nettamente potenza e portata. Non dimenticare la massa comune.
• Riduci la velocità: usare 1000 bps invece di 2000 in RadioHead rende ogni bit più lungo e permette al ricevitore di decodificare segnali più deboli. Imposta la stessa velocità su entrambi i lati.
• Linea di vista e altezza: muri in cemento armato, scatole metalliche e montaggio vicino al suolo possono dimezzare la portata; porta le antenne fuori dai contenitori metallici e il più in alto possibile.
• Pulisci l'alimentazione: motori, relè e alimentatori switching rendono sordo il ricevitore. Dagli un'alimentazione filtrata e tieni i fili corti.
• Usa un ricevitore migliore: un ricevitore supereterodina come l'RXB6 al posto dell'XY-MK-5V spesso arriva molto più lontano con lo stesso trasmettitore.
• Invia più volte: dato che non c'è conferma, invia i comandi importanti 3–5 volte e scarta i duplicati sul ricevitore grazie al numero di pacchetto.

Ricorda che i 433 MHz sono una banda condivisa: la stazione meteo del vicino, le chiavi delle auto e i campanelli trasmettono sulla stessa frequenza. In Europa e in Turchia l'intervallo 433,05–434,79 MHz è libero da licenza per i dispositivi a corto raggio, ma la potenza è limitata a 10 mW (ERP) e non devi occupare il canale di continuo. Inviare i dati a intervalli, o solo quando qualcosa cambia, invece che in continuazione, rispetta le regole e allunga la durata della batteria; per un trasmettitore a batteria puoi usare il calcolatore di durata della batteria.

Modulo RF 433 MHz o nRF24L01?

In breve, se devi inviare in una sola direzione dati piccoli e poco frequenti (un pulsante, una temperatura, l'avviso che una porta è stata aperta) o lavorare con prese e sensori commerciali, il modulo a 433 MHz è la soluzione più economica e semplice. Per un'auto radiocomandata, un joystick o reti di sensori con molti nodi che richiedono una comunicazione veloce, bidirezionale e con conferma, l'nRF24L01 è la scelta migliore. Se ti servono chilometri di portata, guarda i moduli LoRa; per vedere tutte le opzioni a confronto, leggi moduli di comunicazione wireless per Arduino.

Idee di progetti con il modulo RF 433 MHz

• Campanello wireless: suona una melodia in casa quando il pulsante al cancello invia un segnale; per il suono basta un buzzer.
• Comandare le prese da Arduino: clona i codici delle prese radiocomandate e accendi o spegni le lampade in base all'ora o alla luce.
• Sensore porta wireless: metti sulla porta un interruttore reed e un piccolo Arduino con trasmettitore; quando la porta si apre, il lato ricevente fa scattare l'allarme.
• Antifurto per la casa: costruisci un sistema d'allarme con Arduino che riunisca in una centrale sensori PIR e di apertura a 433 MHz già pronti.
• Stazione di sensori per il giardino: invia in casa l'umidità del terreno o la temperatura ogni pochi minuti con un trasmettitore a batteria.
• Ponte da 433 MHz a Wi-Fi: comanda con un ESP32 tutti i dispositivi a 433 MHz di casa dal telefono e dal sistema domotico.

Errori comuni e soluzioni

I moduli RF a 433 MHz danno ai tuoi progetti un braccio wireless con una spesa minima e sono tra i pochi moduli in grado di dialogare con i dispositivi radiocomandati che hai già in casa. Una volta capita la logica del controllo wireless, imparerai facilmente altri metodi come i telecomandi IR e il Bluetooth. Nell'app BlueGrays trovi progetti come la comunicazione tra due Arduino, l'accensione di una lampadina a 220 V con il telecomando, un sensore porta con interruttore reed e un allarme di movimento con ESP32, con schemi elettrici e codice passo passo.