La comunicazione seriale RS232 è un modo semplice per permettere alla nostra board Arduino di comunicare con il computer piuttosto che con sensori o altri dispositivi.
Principalmente Arduino UNO possiede una sola porta seriale, implementata in hardware sul chip Atmega328, e disponibile sui pin0 (Rx) e pin1 (Tx) della scheda.
Sebbene, il più delle volte, una porta seriale sia sufficiente, può essere necessario instaurare un’ulteriore comunicazione seriale, ad esempio, per motivi di debugging o monitoring con un altro dispositivo o computer.
In questo caso ci viene in aiuto la libreria SoftwareSerial (Software Serial Library) che permette di impiegare ulteriori pin disponibili sulla scheda per definire una porta seriale aggiuntiva.

Per utilizzarla è fondamentale inserire nello sketch il riferimento alla libreria tramite la parola chiave #include:

#include <SoftwareSerial.h>

successivamente si definisce una variabile utilizzando il costruttore SoftwareSerial:

SoftwareSerial PortaSeriale = SoftwareSerial(pin_RX, pin_TX);

dove PortaSeriale è il nome dell’oggetto, pin_RX definisce il pin per ricevere i dati e pin_TX definisce il pin per la trasmissione dati.

Ora nella funzione Setup(), tramite pinMode, definiamo il pin previsto per la ricezione come input, e il pin previsto per la trasmissione come output. Specifichiamo inoltre la velocità di trasmissione a 9600bps.

void setup()
{
pinMode(pin_RX, INPUT);
pinMode(pin_TX, OUTPUT);

PortaSeriale.begin(9600);
}

Per leggere e scrivere sulla seriale vengono utilizzati gli stessi metodi implementati per Serial().

Di seguito l’esempio completo che permette di testare questa funzionalità impiegando i pin7 per la ricezione ed il pin8 per la trasmissione

#include <SoftwareSerial.h>

//creo una nuova porta seriale via software
SoftwareSerial PortaSeriale =  SoftwareSerial(7, 8);

//variabile
char EchoChar = 0;

void setup()  {
//definisco il pin7(RX) come ingresso
pinMode(7, INPUT);
//definisco il pin8(TX) come uscita
pinMode(8, OUTPUT);
//setto la velocita della seriale software
PortaSeriale.begin(9600);
}

void loop() {
//leggo dalla seriale(pin7)
EchoChar = PortaSeriale.read();
//invio il dato letto
PortaSeriale.print(EchoChar);

delay(10);

}

il circuito di per il test è rappresentato nell’illustrazione seguente:

Avendo altri pin disponibili nulla ci vieta di definire un’ulteriore porta seriale o più.

Nonostante l’utilità di questa libreria, ci sono alcune limitazioni che bisogna conoscere, per evitare errori di programmazione e di progettazione:

• E’ possibile utilizzare per la porta solamente la velocità di 9600bps
• Non è possibile sapere se ci sono dati disponibili per la lettura come avviene per la funzione Serial.available()
• Il metodo read() è bloccante, quindi il codice si ferma fintanto che non arriva un byte da poter leggere
• Non essendo presente un buffer di ricezione il metodo read() deve essere richiamato velocemente per evitare la perdita di dati.

Queste limitazioni potrebbero far ripensare l’utilizzo della libreria, ma credo che sia comunque importante conoscerne il funzionamento per valutare, a seconda dei circuiti, se impiegarla o meno.
Personalmente l’ho trovata molto utile per inviare dati ad altri dispositivi come funzione di monitoring, difatti potete utilizzare solamente la funzione print e tralasciare la read().

The post Arduino aggiungere porta seriale con Software Serial Library appeared first on Esperimenti con logiche programmabili.

L’interfaccia RS232 è un protocollo standard che permette lo scambio, a bassa velocità, tra dispositivi digitali. Lo standard RS232 nacque nei prima anni 60 e nonostante sia un protocollo piuttosto vecchio è ancora oggi utilizzato per la comunicazione tra microcontrollori, dispositivi industriali e da svariati circuiti che non necessitano di elevate velocità di comunicazione.
Il termine seriale significa che i bit vengono trasferiti uno dopo l’altro su un singolo filo elettrico.

Il segnale RS232 è rappresentato nella figura seguente e può essere visualizzato tramite un comune oscilloscopio

Come possiamo vedere i valori di tensione del segnale RS232 vanno da -12Vdc a 12Vdc. Il segnale è composto sempre da un bit di start seguito da 8 bit di dati. Il bit 1 (Alto) è identificato da una tensione di -12Vdc mentre il bit 0 (Basso) corrisponde ad un livello di tensione di +12Vdc.

La velocità della comunicazione seriale è espressa in bps (bit per second) ed indica, appunto, la quantità di bit inviati in un secondo. La durata di un singolo bit dipende dalla velocità scelta per la trasmissione. Se per i nostri scopi abbiamo bisogno di una comunicazione seriale a 9600bps il singolo bit avrà una larghezza di 104us (1/9600).

Il connettore disponibile in molti pc desktop è un DB9 maschio ed è composto da nove pin, i quali svolgono delle funzioni specifiche:

Quelli che ora ci interessano, per testare la nostra comunicazione seriale con il Netduino, sono il pin 2 (RX), il pin 3 (TX) ed il pin 5 (GND).
Il Netduino ha due ‘porte’ seriali disponibili tramite i pin 0 e 1 (UART1) e i pin 2 e 3 (UART2). Questi piedini lavorano con logica TTL e non possono essere collegati direttamente al connettore DB9 del pc, ma si ha bisogno di un componente esterno che converta il segnale TTL (0/5 Vdc) in un segnale RS232 (-12/+12 Vdc).
Ci sono diversi componenti che permettono questa conversione, io solitamente uso il MAX233 il cui circuito di impiego (pagina 21 del datasheet) è molto semplice e non necessita di ulteriori componenti esterni (condensatori o resistenze).

Lo schema elettrico del progetto è il seguente e risulta molto semplice nei collegamenti:

La trasmissione dei dati avviene tramite il pin 1 del Netduino, che è collegato all’ingresso 3 del MAX233; l’uscita RS232 è disponibile sul pin 5 del MAX233 ed è collegata al pin 2 del connettore DB9 femmina (corrispondente al pin RX del PC). Viceversa il PC trasmette sul pin 3 del connettore DB9 maschio che è collegato tramite il connettore DB9 femmina al pin 4 del MAX233 che provvederà a convertire il segnale RS233 in TTL, l’uscita TTL del MAX233 disponibile sul pin 3 è collegata al pin 0 del Netduino.

Ora che il circuito è pronto, passiamo alla creazione del software di esempio per testare la comunicazione seriale tra Netduino e PC.
Avviamo un nuovo progetto con Visual C#.
Prima di scrivere il codice aggiungiamo un riferimento alla libreria Microsoft.SPOT.Hardware.SerialPort. In esplora soluzioni clicchiamo con il pulsante destro del mouse sulla voce Riferimenti, dal menu contestuale visualizzato, clicchiamo su Aggiungi Riferimento…, verrà visualizzata la finestra Add Reference. Clicchiamo sul tab .Net, poi sul componente Microsoft.SPOT.Hardware.SerialPort e confermiamo con il pulsante OK.

Ora apriamo il file Program.cs ed iniziamo a scrivere il codice che permetterà al Netduino di inviare, ad intervalli di tempo regolari, una serie di caratteri al pc:

using System;
using System.Threading;
using Microsoft.SPOT;
using Microsoft.SPOT.Hardware;
using SecretLabs.NETMF.Hardware;
using SecretLabs.NETMF.Hardware.Netduino;

using System.IO.Ports;
using System.Text;

namespace NetduinoApplication1
{
public class Program
{
public static void Main()
{
SerialPort UART1 = new SerialPort("COM1", 9600, Parity.None,
8, StopBits.One);
OutputPort led = new OutputPort(Pins.ONBOARD_LED, false);

UART1.Open();
String Messaggio = "Ciao!";
Byte[] bytesMessaggio = Encoding.UTF8.GetBytes(Messaggio);

while(true)
{
led.Write(true);
UART1.Write(bytesMessaggio, 0, bytesMessaggio.Length);
Thread.Sleep(100);
led.Write(false);

Thread.Sleep(500);
}

UART1.Close();
}

}
}

La prima cosa da fare è caricare il namespace System.IO.Ports (per accedere alla porta seriale) e System.Text (per convertire una stringa in un array di bytes e viceversa) (righe di codice 8 e 9).
UART1 è l’oggetto che ci permette di accedere alla porta COM1 del Netduino (pin 0 e 1, mentre COM 2 è riferita ai pin 2 e 3) impostata per lavorare ad una velocità di 9600bps, con nessuna parità, 8 bit di dati ed un bit di stop.
Queste impostazioni devono essere identiche a quelle della seriale del pc.
Per avviare la comunicazione è necessario aprire la porta seriale, con il metodo Open() dell’oggetto UART1, mentre per spedire i dati dobbiamo utilizzare il metodo Write(). Questo metodo accetta un array di byte e bisogna specificare l’offset di questo array da spedire.
L’oggetto led indica quando vengono spediti i dati sulla porta del Netduino, il metodo Sleep() crea invece un ritardo tra una spedizione e l’altra.

Avviamo il debug(F5) per fare girare il programma sul Netduino.

I dati vengono inviati al pc, per visualizzarli utilizziamo il programma HyperTerminal. Per i possessori di Windows Xp, dovete andare in:
Start->Tutti i programmi->Accessori->Comunicazioni->HyperTerminal

all’avvio il programma chiede di dare un nome alla sessione, mettiamone uno indicativo e clicchiamo sul pulsante OK

La schermata seguente chiede quale porta seriale vogliamo usare, solitamente i pc odierni hanno una sola porta indicata come COM1 (verificate sul manuale della scheda madre), clicchiamo sul pulsante OK.

La finestra successiva mostra i vari parametri configurabili per la porta COM1

Inseriamo gli stessi parametri che sono presenti nel codice C# relativi all’oggetto UART1

SerialPort UART1 = new SerialPort("COM1", 9600, Parity.None, 8, StopBits.One);

quindi:

Bit per secondo = 9600, Bit di dati = 8, Parità= Nessuno, Bit di Stop = 1, Controllo di Flusso = Nessuno.

Assicuriamoci che il cavo seriale colleghi il MAX233 ed il PC e confermiamo con il pulsante OK per avviare la ricezione dei dati dal Netduino

Certamente è una bella emozione (a noi fanatici prende così!!) aver avviato una comunicazione tra un dispositivo hardware ed il pc.
Il passo successivo è modificare il programma per dare la capacità al Netduino di ricevere comandi dal pc per creare una comunicazione bidirezionale completa.
Ecco l codice per poter predisporre il Netduino alla ricezione dei comandi.

using System;
using System.Threading;
using Microsoft.SPOT;
using Microsoft.SPOT.Hardware;
using SecretLabs.NETMF.Hardware;
using SecretLabs.NETMF.Hardware.Netduino;

using System.IO.Ports;
using System.Text;

namespace NetduinoApplication1
{
public class Program
{
public static void Main()
{
OutputPort led = new OutputPort(Pins.ONBOARD_LED, false);

SerialPort UART1 = new SerialPort("COM1", 9600, Parity.None,
8, StopBits.One);

UART1.Open();
String Messaggio = "RX OK!";
String MessaggioPC = "";
Int32 NumByteDisponibili = 0;
Byte[] bytesMessaggio = Encoding.UTF8.GetBytes(Messaggio);
Byte[] bytesRicevuti;

while(true)
{
if (UART1.BytesToRead > 0)
{
NumByteDisponibili = UART1.BytesToRead;
bytesRicevuti = new Byte[NumByteDisponibili];
UART1.Read(bytesRicevuti, 0, NumByteDisponibili);
MessaggioPC = new String(Encoding.UTF8.GetChars(bytesRicevuti));

Debug.Print("Byte nel buffer del Netduino = " +
 NumByteDisponibili.ToString());
Debug.Print("Messaggio da PC = " + MessaggioPC);

//Accendi il Led
if (MessaggioPC == "a")
{
led.Write(true);
}

//Spegni il led
if (MessaggioPC == "s")
{
led.Write(false);
}

//Blink
if (MessaggioPC == "b")
{
Boolean Stato = true;
for (Int32 Ciclo = 0; Ciclo <= 10; Ciclo++)
{
Stato = !Stato;
led.Write(Stato);
Thread.Sleep(100);
}
}

//invia al pc un informazione
UART1.Write(bytesMessaggio, 0, bytesMessaggio.Length);
}
Thread.Sleep(500);
}
UART1.Close();
}
}
}

Eseguiamo il debug(F5) per caricare il programma sul Netduino.

Per capire se il pc ha inviato dei dati al Netduino utilizziamo la proprietà BytesToRead dell’oggetto UART1; questa proprietà ci indica quanti byte sono presenti nel buffer della seriale del Netduino. Il codice verifica ciclicamente quando ci sono dei bytes nel buffer (UART1.BytesToRead > 0); in funzione del numero di byte presenti, creo un array della dimensione appropriate (bytesRicevuti = new Byte[NumByteDisponibili];).
Successivamente eseguo il metodo Read() che svuota il buffer della seriale e riempe l’arraybytesRicevuti.
Ora posso lavorare con i dati inviati dal pc!
Nel codice d’esempio accendo, spengo e faccio blinkare il led on board a seconda del dato inviato dal pc, utilizzando le varie istruzioni if. Da notare il metodo GetChar() che permette di codificare i byte nello standard UTF8.

Per comunicare con il Netduino posso sempre utilizzare HyperTerminal; nella configurazione standard HyperTerminal non visualizza i caratteri  digitati con la tastiera.
Modifichiamo questa caratteristica andando nelle opzioni del programma cliccando sul menu File e poi sulla voce Proprietà.

Nella finestra appena visualizzata clicchiamo sul tab Impostazioni e poi sul pulsante Impostazioni ASCII….

Questa finestra presenta varie opzioni, spuntiamo la voce Eco dei caratteri digitati localmente, e confermiamo con il pulsante OK.

Proviamo subito il codice!

Dalla finestra HyperTerminal digitiamo una a per accendere il led on board, una s per spegnerlo e la b per farlo blinkare. Il Netduino eseguirà queste operazioni e invierà al pc il testo RX OK! tramite l’istruzione UART1.Write(bytesMessaggio, 0, bytesMessaggio.Length);.

Questo semplice esperimento ci insegna le basi per iniziare ad interfacciare il pc con il Netduino e per capire come convertire il segnale TTL in segnale RS232.

Aspetto vostri commenti e consigli.

The post Netduino e collegamento alla seriale RS232 del pc appeared first on Esperimenti con logiche programmabili.