Il modulo RF consiste in un modulo trasmettitore e ricevitore RF a 433 MHz. Questi sono moduli RF di tipo ASK (Amplitude shift keying) o OOK (Of Hook Keying). Durante la trasmissione dello zero logico il trasmettitore sopprime completamente la frequenza portante e quindi consuma solo una bassa potenza nel funzionamento a batteria. Quando la logica uno è trasmessa il trasmettitore è ON, e la frequenza portante è piena e quindi, ci sarà un’alta alimentazione che è nell’ordine di circa 4.5mA con un’alimentazione di 3V.

Il trasmettitore e il ricevitore sono necessari per essere interfacciati con microcontrollori per il trasferimento dati. I dati sono inviati in serie dal trasmettitore e sono ricevuti da un ricevitore sintonizzato. Il trasmettitore RF riceve i dati seriali da un microcontrollore e li trasmette al ricevitore attraverso un’antenna collegata al 4° pin del trasmettitore. Il ricevitore riceve i dati attraverso un’antenna e li dà al microcontrollore ad esso collegato.

Questi moduli RF operano ad una frequenza specifica di 433MHz. I segnali RF possono viaggiare tra il trasmettitore e il ricevitore anche quando c’è un’ostruzione. Questi moduli sono utilizzati per comunicazioni a corto raggio, a basso budget e basate sul simplex. Il basso consumo energetico li rende ideali per implementazioni basate su batterie. È usato in varie aree come controlli di illuminazione a distanza, RFID a lungo raggio, sistemi di allarme e sicurezza wireless, ecc. La comunicazione RF è usata nella comunicazione mobile e può avere una comunicazione a lungo raggio ed è ciò che li rende adatti a costruire applicazioni basate sull’IoT. Quindi qui stiamo iniziando con un articolo introduttivo sui moduli RF e su come i moduli RF possono essere utilizzati con Arduino per inviare e ricevere dati.

Modulo trasmettitore RF a 433 MHz

Questo piccolo modulo è il trasmettitore RF. È molto semplice. Il risonatore SAW che è sintonizzato per il funzionamento a 433.xx MHz è il cuore del modulo. C’è un transistor di commutazione e alcuni componenti passivi su di esso.

Quando viene dato un ALTO logico come ingresso DATA, l’oscillatore è ON e produce un’onda portante RF costante in uscita a 433.xx MHz e quando l’ingresso DATA è logico BASSO, l’oscillatore è OFF, quindi non viene prodotta alcuna portante. Questa tecnica è chiamata Amplitude Shift Keying (ASK).

Specifiche

  • Tensione di lavoro: 3V – 12V
  • Corrente di lavoro: max Meno di 40mA, e min 9mA
  • Modo di risonanza: (SAW)
  • Modalità di modulazione: ASK
  • Frequenza di lavoro: 433.92MHz
  • Potenza di trasmissione: 25mW
  • Errore di frequenza: +150kHz (max)
  • Velocità: meno di 10Kbps
  • Gamma di trasmissione: 90m (in spazio aperto)

Modulo ricevitore RF 433 MHz

Questo è il modulo ricevitore RF. Anche se sembra complesso, è semplice come il modulo trasmettitore. Consiste in un circuito sintonizzatore RF, amplificatori operazionali e un PLL. Un paio di OP-Amp sono usati per amplificare l’onda portante ricevuta dal trasmettitore. Il segnale amplificato viene poi alimentato a un PLL (Phase Lock Loop) che permette al decodificatore di “agganciare” un flusso di bit digitali che dà una migliore uscita decodificata e immunità al rumore.

Specifiche

  • Tensione di lavoro: 5.0VDC +0.5V
  • Corrente di lavoro: ≤5.5mA max
  • Modo di modulazione: OOK/ASK
  • Frequenza di lavoro: 433.92MHz
  • Bandwidth: 2MHz
  • Sensibilità: supera -100dBm (50Ω)

Componenti necessari

  • Arduino Nano (2)
  • Modulo trasmettitore RF 433MHz
  • Modulo ricevitore RF 433MHz
  • Potenziometro
  • LED (5)
  • Fili di collegamento

Schema del circuito

Lo schema del circuito per il trasmettitore RF usando Arduino Nano è dato sotto. Qui un potenziometro è collegato per variare i valori da inviare al ricevitore usando il trasmettitore RF.

Di seguito i dettagli delle connessioni dei pin tra il trasmettitore RF e Arduino

  • Pinotto D12 di Arduino – pin DATA del trasmettitore RF
  • VCC di Arduino – VCC del trasmettitore RF
  • GND di Arduino – GND del trasmettitore RF
  • GND di Arduino – primo pin del potenziometro
  • Pinotto A2 di Arduino – secondo pin del potenziometro
  • VCC di Arduino – terzo pin del potenziometro

Lo schema del circuito per il ricevitore RF usando Arduino Nano è mostrato sotto. Qui abbiamo una serie di LED. I LED sono spostati in base ai valori del potenziometro ricevuti dal ricevitore.

Di seguito ci sono i dettagli delle connessioni dei pin tra il ricevitore RF e Arduino

  • Pinotto D11 di Arduino – pin DATA del ricevitore RF.
  • VCC di Arduino – VCC del ricevitore RF.
  • GND di Arduino – GND del ricevitore RF.
  • I cavi positivi dei LED sono collegati ai pin digitali D2, D3, D4, D5 e D6
  • I cavi negativi dei LED sono messi a terra.

Spiegazione del codice

Il codice completo di Arduino per il trasmettitore e il ricevitore RF sono dati alla fine di questo tutorial, qui stiamo spiegando il programma completo per capire il funzionamento del progetto. Ma prima di iniziare con il codice prima dobbiamo installare una libreria in Arduino IDE.

Qui stiamo usando la libreria filo virtuale. Scarica la libreria virtual wire dal seguente link

https://www.resistorpark.com/content/Arduino_Libraries/Arduino_Wireless_Communication_Libraries/VirtualWire.zip

VirtualWire è una libreria Arduino che fornisce le caratteristiche per inviare brevi messaggi, senza indirizzamento, riconoscimento o ritrasmissione. I messaggi sono inviati come UDP su wireless usando ASK (amplitude shift keying). Questa libreria supporta una serie di trasmettitori e ricevitori radio poco costosi.

Per aggiungere la libreria in Arduino IDE vai su Sketch>>Include library>>Aggiungi libreria .ZIP poi carica la libreria che hai scaricato dal link sopra.

Dopo aver caricato il programma aprite il monitor seriale su entrambi i lati e vedrete le uscite come mostrato qui sotto.

L’uscita alla sezione del trasmettitore RF mostra i valori del potenziometro.

E l’uscita al ricevitore mostra il valore del sensore ricevuto. I LED sono spostati secondo la gamma dei valori del sensore. Qui abbiamo dato un range di 200 per ogni LED.

Quindi questo è come Arduino può essere usato nella comunicazione basata su RF, controlla altri progetti IoT basati su Arduino qui.

Codice

Codice per la sezione trasmettitore RF
#include <VirtualWire.h>
const int SensorPin = A2; // pin del potenziometro
int SensorData;
char SensorCharMsg;
void setup()
{
pinMode(SensorPin,INPUT);
// per debug
Serial.begin(9600);
// VirtualWire setup
vw_setup(2000); // Bit per sec
}
void loop()
{
// Leggi e memorizza i dati del sensore 1
SensorData = analogRead(SensorPin);
// Convertire dati interi in array Char direttamente
itoa(SensorData,SensorCharMsg,10);
// DEBUG
Serial.print(“Sensor Integer: “);
Serial.print(SensorData); // stampa i dati del sensore
Serial.print(” Sensor CharMsg: “);
Serial.print(SensorCharMsg); //stampa l’array di char
Serial.println(” “);
delay(100);
// END DEBUG
vw_send((uint8_t *)SensorCharMsg, strlen(SensorCharMsg)); // invia il messaggio
vw_wait_tx(); // aspetta che l’intero messaggio sia finito
delay(200);
} // END void loop

Codice per la sezione Ricevitore RF
#include <VirtualWire.h>
int SensorData; // Sensors
char SensorCharMsg; // RF Transmission container
const int led1 = 2;
const int led2 = 3;
const int led3 = 4;
const int led4 = 5;
const int led5 = 6;
void setup()
{
Serial.begin(9600);
pinMode(led1, INPUT);
pinMode(led2, INPUT);
pinMode(led3, INPUT);
pinMode(led4, INPUT);
pinMode(led5, INPUT);
// VirtualWire
// Inizializza l’IO e l’ISR
/ Necessario per DR3100
vw_set_ptt_inverted(true);
// Bit per sec
vw_setup(2000);
// Avvia il PLL del ricevitore in esecuzione
vw_rx_start();
} // END void setup

void loop()
{
uint8_t buf;
uint8_t buflen = VW_MAX_MESSAGE_LEN;
// Non-blocking
if (vw_get_message(buf, &buflen))
{
int i;
// Messaggio con un buon checksum ricevuto, scaricarlo.
for (i = 0; i < buflen; i++)
{
// Riempire SensorCharMsg Char array con i corrispondenti
// caratteri del buffer.
SensorCharMsg = char(buf);
}
// Null termina l’array di char
// Questo deve essere fatto altrimenti ci saranno problemi
// quando i messaggi in arrivo hanno meno cifre di quelli
// precedenti.
SensorCharMsg = ‘\0’;
// Converte l’array di caratteri Sensor1CharMsg in intero
SensorData = atoi(SensorCharMsg);
// DEBUG
Serial.print(“Sensor “);
Serial.println(SensorData);
// FINE DEBUG
}
if (SensorData <= 200)
{
digitalWrite(led1, HIGH);
}
else
digitalWrite(led1, LOW);
se ( SensorData > 200 && SensorData <= 400)
{
digitalWrite(led2, HIGH);
}
else
digitalWrite(led2, LOW);
if ( SensorData > 400 && SensorData <= 600)
{
digitalWrite(led3, HIGH);
}
else
digitalWrite(led3, LOW);
if ( SensorData > 600 && SensorData <= 800)
{
digitalWrite(led4, HIGH);
}
else
digitalWrite(led4, LOW);
if ( SensorData > 800 && SensorData <= 1023)
{
digitalWrite(led5, HIGH);
}
else
digitalWrite(led5, LOW);
}

Video

By: adminPosted on

Lascia un commento

Il tuo indirizzo email non sarà pubblicato.