Trasmissione dati con moduli 433 MHz ed Arduino

Ho scritto due semplici shield Arduino per i moduli TX/RX a 433 MHz che si trovano ormai dovunque a pochi euro.

La mia necessita' era quella di leggere la tensione di una batteria direttamente nella stanza dove tengo il pc che e' a 5 metri dal locale dove e' posizionata la batteria e che quindi mi costringeva ogni volta ad alzarmi per  controllarla.

 

Ho fatto un primo giretto su Google ed ho trovato la libreria VirtualWire che mi ha dato lo spunto per  risolvere il problema.

 

Considerato che la tensione della batteria e' di 24 Volt ed Arduino accetta tensioni massime di 5 Volt sugli ingressi analogici , ho calcolato un semplice partitore resistivo 30/5 che mi consente di stare abbastanza largo con le tensioni.

 

Ho utilizzato per la R1 il valore di 10 K mentre per la R2 il valore di 2 K facilmente ottenibile mettendo in serie due resistenze da 1 K.

 

Sarebbe comunque opportuno mettere in serie al piedino di ingresso di Arduino uno zener da 5,1 Volt a protezione (non si sa mai).

Ho preparato quindi il layout che si vede in foto collegando due moduli Arduino Uno  come segue :

 

il modulo a sinistra e' quello che rileva la tensione dalla batteria tramite il partitore (io ho usato un alimentatore variabile per fare le prove) e trasmette il valore tramite il modulo TX 433 MHz.

 

Il modulo a destra invece e' quello che riceve i valori ed utilizza il modulo RX 433 MHz.

Allego qui la prima shield cioe' quella che va caricata sul modulo Arduino di sinistra (rileva tensione , converte il valore della tensione letta in char e lo trasmette mediante il modulo TX.

 

/*
Shield per leggere e trasmettere in remoto la tensione letta sul pin A1 proveniente da alimentatore con partitore di tensione.
Il valore della tensione contenuto nella variabile voltage che e' definita float DEVE essere convertito da float a char ; viene quindi utilizzata la funzione dtostrf contenuta nella libreria stdio.h.
Il modulo tx viene connesso al pin 12
*/

#include <VirtualWire.h>//libreria per moduli RTX
#include <stdio.h>//libreria necessaria per la funzione dtostrf

void setup() {
  Serial.begin(9600); //inizializzo seriale
  vw_setup(2000); //inizializzo la trasmissione a 2000 bits per secondo
}

void loop() {
 
char risultato[5]; //definisco il buffer che conterra' il valore del float convertito in stringa

int grezzo = analogRead(A1); //registro nella variablie grezzo (int) il valore di tensione presente al piedino di ingresso analogico A1


float voltage = grezzo * (35.5 / 1023.0); // lo converto e lo memorizzo in voltage (float) considerato che puo' contenere decimali


Serial.println(voltage); //visualizzo il valore di voltage (float) su monitor seriale


dtostrf(voltage, 5, 2, risultato);//converto da voltage (float) a risultato (char)
 
send(risultato);//trasmetto via rf il contenuto di risultato (char)


delay(500);// attesa 1/2 secondo

}
 
void send (char *message)
{
  vw_send((uint8_t *)message, strlen(message));
  vw_wait_tx(); // Wait until the whole message is gone
}

 

-----------------------------------------------------------------------------------------------------------------------------

 

Qui invece la shield da caricare sul modulo Arduino di destra cioe' quello che deve ricevere il dato tramite in modulo RX 433 MHz :

 

/*
  Con questo shield arduino riceve il valore della tensione rilevata che viene trasmesso
  dall'altro shield denominato trasmissione.
  In questo caso il modulo RX si connette ad arduino al pin 11.
*/
#include <VirtualWire.h> //

byte message[VW_MAX_MESSAGE_LEN];    // a buffer to hold the incoming messages
byte msgLength = VW_MAX_MESSAGE_LEN; // the size of the message


void setup()
{
    Serial.begin(9600);
    Serial.println("Ready");

    // Initialize the IO and ISR
    vw_setup(2000);             // Bits per sec
    vw_rx_start();              // Start the receiver
}

void loop()
{
    if (vw_get_message(message, &msgLength)) // Non-blocking
    {
        Serial.print("Tensione letta : ");
    for (int i = 0; i < msgLength; i++)
    {
        Serial.write(message[i]);
    }
    Serial.println();
    }
}

 

Questa shield e' stata praticamente ricopiata dagli esempi della libreria VirtualWire.

 

La tensione viene letta tramite monitor seriale ma niente vieta di scrivere altre due righe di codice e traslare l'output su lcd o su quello che si vuole.

 

 

 

 

 

 

 

 

 

 

 

 

Per effettuare le prove ho regolato l'alimentatore a 7,4 Volt ed ho allegato le foto del risultato.

 

 

 

 

 

 

 

 

 

 

 

Qui invece altre due foto con il display dell'alimentatore a 11,3 Volt ed il monitor seriale che indica la tensione rilevata.

A questo punto il piu' e' fatto.

 

Non rimane che scegliere come visualizzare in remoto il dato ed utilizzarlo al meglio.

 

Buon divertimento.