RS-485
Specifiche e principio di funzionamento.
In hardware, l'interfaccia RS-485 è implementata sui più comuni microcircuiti della famiglia MAX485. Esistono dozzine di varietà nella famiglia, differiscono per il numero di dispositivi massimi supportati, velocità massima, distanza, ordine di trasmissione duplex/half-duplex e così via. Considera il chip più famoso di questa famiglia, che si chiama MAX485.
Caratteristiche principali:
- Tensione di alimentazione - 5V.
- Consumo di corrente - 0,3 mA.
- Distanza di trasmissione - fino a 1200 m.
- La velocità dei dati dipende fortemente dalla distanza, da 62 kbps a 1200 m a 10000 kbps a 10 m.
- Fino a 32 ricetrasmettitori per bus (gli altri membri della famiglia supportano fino a 256).
Collegamento di due dispositivi:
Collegamento di più dispositivi:
Il bus dati è costituito da due fili collegati agli stessi punti del ricetrasmettitore A o B. L'essenza della tecnologia è che i segnali vengono inviati a questi due fili in modo sincrono ma con inversione, ovvero quando uno è 1, l'altro è 0 e viceversa. In questo modo semplice si garantisce un aumento della differenza di potenziale e un'elevata resistenza ai disturbi di modo comune, che interessano entrambi i fili contemporaneamente, senza modificare la differenza di potenziale. Affinché l'interferenza sia il più simultanea possibile, i fili devono essere posizionati il più vicino possibile l'uno all'altro, ovvero attorcigliati in un fascio.
Il microcircuito stesso richiede un semplice legame composto da più resistori per funzionare, inoltre, i trasmettitori finali devono contenere un resistore terminale da 120 Ohm che smorza i riflessi. Per semplificare la vita dei maestri del fai-da-te, gli amici cinesi hanno pensato premurosamente a un modulo di comunicazione già pronto basato su MAX485, contiene già tutto ciò di cui hai bisogno ed è pronto per funzionare così com'è. Questi sono i moduli che userò come esempio.
Collegamento ad Arduino.
Il modulo ha i seguenti pin:
- DI - trasmissione dati, si collega a TX.
- RO - riceve dati, si collega a RX.
- DE e RE - cambiano la direzione di trasmissione dei dati, per ricevere o per trasmettere, sono collegati da un ponticello e funzionano contemporaneamente, 1 - trasmissione, 0 - ricezione.
- GND - terra.
- VCC - alimentazione +5 V.
- A e B, canali bus dati.
Il principio di organizzazione del lavoro può essere descritto come segue: ogni dispositivo nella rete ha un proprio numero univoco con il quale è identificato. Nella rete un dispositivo è quello principale, è il Master, il resto dei satelliti, sono gli Slave. Il Master, a seconda del compito, impartisce un comando agli Slave (periodicamente) su un timer o su qualche evento. Il comando del Master sul bus è visto da tutti i dispositivi, ma rispondono solo quelli a cui si rivolge ad un indirizzo univoco. Se è richiesta una risposta, il Master passa in ascolto e lo Slave per inviare i dati, dopodiché il controllo viene nuovamente trasferito al Master. Ciò garantisce una comunicazione coerente con tutti i dispositivi sulla rete senza incroci e collisioni. Esistono tecnologie di relazione più complesse, ad esempio il trasferimento dello stato di Slave da dispositivo a dispositivo, reti multistrato e così via, il che è sufficiente per l'immaginazione degli sviluppatori. In questo articolo considereremo un esempio di rete semplice classica composta da un Master e due Slave con feedback.
Raccomandazioni per il cablaggio di rete:
- Minore è la distanza, meglio è.
- La topologia di rete dovrebbe preferibilmente essere lineare.
- I doppini intrecciati sono consigliati come fili.
- localizzare il bus, se possibile, lontano da fonti di interferenza elettromagnetica sotto forma di potenti consumatori, sorgenti di radiazioni e altro.
Esempio di utilizzo.
Creiamo la rete di lavoro più semplice di tre elementi. Il ruolo di Master e due Slave, userò Arduino UNO. Ciascuno degli Slave ha un pulsante e un LED, il Master ha due pulsanti e due LED.
Compito: premendo i pulsanti del dispositivo Master, dobbiamo attivare da remoto l'accensione dei led sugli Slave corrispondenti. Premendo i pulsanti sugli Slave, si accende il led corrispondente su Master.
Assemblaggio dello schema.
Master.
#define IN_OUT 6 // Interruttore di invio-ricezione.
byte BUT[2] = {9, 8}; // Pin pulsanti.
byte LED[2] = {13, 12}; // Pin LED.
byte MSG_IN[4];
byte MSG_OUT[4] = {0x10, 0, 0, 0x20}; // Modello: 0 - inizio, 1 - indirizzo Slave
, 2 - comando, 3 - fine.
void setup()
{
for (byte i = 0; i < 2; i++)
{
pinMode(BUT[i], INPUT_PULLUP);
pinMode(LED[i], OUTPUT);
}
pinMode(IN_OUT, OUTPUT);
digitalWrite(IN_OUT, LOW);
Serial.begin(9600);
}
void loop()
{
post(); // Invio periodico di comandi agli Slave.
if (Serial.available()) // Ricevere comandi dagli Slave.
{
// delay(1);
for (byte i = 0; i < 3; i++)
MSG_IN[i] = MSG_IN[i + 1];
MSG_IN[3] = Serial.read();
if (MSG_IN[0] == 0x10 && MSG_IN[3] == 0x20) // Ricevuto il messaggio completo.
{
digitalWrite(LED[MSG_IN[1]], !MSG_IN[2]);
//Esegue, invia al LED lo stato corrispondente all'indirizzo che è arrivato nel comando.
}
}
}
void post()
{
static unsigned long timerT;
static byte msg_num = 0;
if (timerT > millis() - 100) return; // Inviare in sequenza ogni 100 ms.
MSG_OUT[1] = msg_num;
MSG_OUT[2] = digitalRead(BUT[msg_num]);
msg_num = !msg_num;
digitalWrite(IN_OUT, HIGH); // Abilita l'invio.
for (byte i = 0; i < 4; i++) // Inviare 4 byte di messaggio.
{
Serial.write(MSG_OUT[i]);
}
// Attendere che il comando esca prima di passare da inviare a ricevere.
delay(5);
digitalWrite(IN_OUT, LOW); // Passare alla ricezione.
timerT = millis();
}
Slave 1.
#define IN_OUT 6 // Interruttore di invio-ricezione.
#define ADR 0 // Indirizzo Slave1
byte BUT = 2; // Pin pulsante
byte LED = 13; // Pin LED
byte MSG_IN[4];
byte MSG_OUT[4] = {0x10, ADR, 0, 0x20}; // Modello: 0 - inizio, 1 - indirizzo Slave, 2 - comando, 3 - fine.
void setup()
{
pinMode(BUT, INPUT_PULLUP);
pinMode(LED, OUTPUT);
pinMode(IN_OUT, OUTPUT);
digitalWrite(IN_OUT, LOW);
Serial.begin(9600);
}
void loop()
{
if (Serial.available())
{
// delay(1);
for (byte i = 0; i < 3; i++)
MSG_IN[i] = MSG_IN[i + 1];
MSG_IN[3] = Serial.read();
// Ricevuto il messaggio completo.
if (MSG_IN[0] == 0x10 && MSG_IN[1] == ADR && MSG_IN[3] == 0x20)
{
digitalWrite(LED, !MSG_IN[2]); // Eseguire, impostare lo stato ricevuto sul LED.
MSG_OUT[2] = digitalRead(BUT);
delay(5); // In attesa che il Master passi alla ricezione.
digitalWrite(IN_OUT, HIGH); // Avvia la trasmissione.
for (byte i = 0; i < 4; i++) // Trasmissione.
{
Serial.write(MSG_OUT[i]);
}
delay(5); // In attesa dell'invio del messaggio.
digitalWrite(IN_OUT, LOW); // Passare alla ricezione.
}
}
}
Slave 2.
#define IN_OUT 6 // Interruttore di invio-ricezione.
#define ADR 1 // Indirizzo Slave
2.
byte BUT = 2; // Pin pulsante.
byte LED = 13; // Pin LED
byte MSG_IN[4];
byte MSG_OUT[4] = {0x10, ADR, 0, 0x20}; // Modello: 0 - inizio, 1 - indirizzo Slave, 2 - comando, 3 - fine.
void setup()
{
pinMode(BUT, INPUT_PULLUP);
pinMode(LED, OUTPUT);
pinMode(IN_OUT, OUTPUT);
digitalWrite(IN_OUT, LOW);
Serial.begin(9600);
}
void loop()
{
if (Serial.available())
{
// delay(1);
for (byte i = 0; i < 3; i++)
MSG_IN[i] = MSG_IN[i + 1];
MSG_IN[3] = Serial.read();
// Ricevuto il messaggio completo.
if (MSG_IN[0] == 0x10 && MSG_IN[1] == ADR && MSG_IN[3] == 0x20)
{
// Eseguire, impostare lo stato ricevuto sul LED.
digitalWrite(LED, !MSG_IN[2]);
MSG_OUT[2] = digitalRead(BUT);
delay(5); // In attesa che il Master passi alla ricezione.
digitalWrite(IN_OUT, HIGH); // Avvia la trasmissione.
for (byte i = 0; i < 4; i++) // Trasmissione.
{
Serial.write(MSG_OUT[i]);
}
delay(5); // In attesa dell'invio del messaggio.
digitalWrite(IN_OUT, LOW); // Passare alla ricezione.
}
}
}