Interfacciare Arduino con Visual Basic

In questo tutorial vedremo come è possibile interfacciare Arduino con Visual Basic utilizzando la comunicazione seriale attraverso la porta usb.

E’ possibile stabilire questo genere di comunicazione in tutte le versioni di Visual Basic, dalla mitica versione 6 alle più recenti versioni .net; i componenti da utilizzare sono sempre gli stessi per tutte le versioni, a parte eventuali piccole differenze di sintassi o di nomi dei metodi da invocare.

Visual Basic 2008 express. In questo tutorial vedremo un esempio di comunicazione seriale tra Arduino Uno ed un piccolo programmino scritto in Visual Basic 2008 express. La scelta di utilizzare questa versione di Visual Basic nasce da alcuni vantaggi che essa offre:

• è una versione abbastanza avanzata ed evoluta, ma contemporaneamente molto snella;
• è gratuita, scaricabile dal sito Microsoft, e non richiede particolari licenze d’uso;
• richiede il framework 3.5 che è già presente in Windows 7 e successivi e che non è eccessivamente pesante se installato in pc più vecchi o con Windows xp (il framework 4.0 è un po’ più pesante e potrebbe creare rallentamenti nel caso di utilizzo in pc con processori più lenti o con meno Ram);
• rispetto al vb6 (immagino gli amanti di vb6 desiderosi di non abbandonare questa versione) non presenta un inconveniente di cui parleremo tra poco che renderebbe poco fruibile il programma.

Funzionamento. Iniziamo subito col dire che qualunque versione di Visual Basic decidiamo di utilizzare, il principio di funzionamento della comunicazione tra Arduino e Visual Basic sarà sempre lo stesso: si innescherà la comunicazione seriale tra i due sistemi. Visual Basic invierà ad Arduino una richiesta e Arduino risponderà di conseguenza.

Comandi e interrogazioni. Solo per una questione di semplicità e chiarezza, e per fissare meglio le idee, distingueremo in questo tutorial due generi di richieste: comandi e interrogazioni.

Un comando sarà la richiesta di effettuare qualcosa, ad esempio settare un pin o eseguire una procedura presente nello sketch di Arduino.

L’interrogazione sarà la richiesta di avere restituito in risposta da Arduino una stringa, che può contenere ad esempio il valore di una o più variabili, oppure lo stato di un sensore.

E’ sempre bene comunque prevedere, anche nel caso di comandi, una risposta da parte di Arduino, che può essere di semplice conferma se il comando è stato eseguito correttamente oppure un codice di errore nel caso qualcosa non sia andato per il verso giusto.

Carattere contro Stringa. Fatta questa premessa è necessario fare un’ulteriore precisazione prima di passare a vedere concretamente dei semplici esempi per realizzare quello di cui stiamo parlando: Arduino in generale riesce a leggere dalla seriale un carattere alla volta (diciamo un byte alla volta), però è in grado di scrivere sulla seriale diversi byte tutti insieme (ad esempio una stringa intera anche abbastanza lunga).

Dal lato suo, Visual Basic è in grado di scrivere e di leggere dalla seriale stringhe intere senza grossi problemi, quindi per mettere d’accordo le esigenze di entrambi procederemo così: Visual Basic invierà la propria richiesta scrivendo un byte sulla seriale (convenendo una certa codifica, ad esempio ‘T’ significa ‘restituiscimi il valore della temperatura‘, oppure ‘R’ significa ‘fai scattare il relè‘ oppure ‘3’ significa ‘cambia lo stato del pin 3‘, ecc…) e riceverà da Arduino una stringa che potrà contenere la conferma di avvenuta esecuzione di un comando oppure la risposta all’interrogazione fatta.

Pronti? Via! Dato che esistono diversi sensori, ciascuno con le proprie sintassi e configurazioni, partiamo da un esempio molto semplice che non richiede alcuna componente aggiuntiva.

Come per ogni “Hello World” che si rispetti, scriviamo un programma in Visual Basic che possa fare accendere e spegnere il led del pin 13 di Arduino e che possa anche interrogarlo sullo stato attuale del pin.

In Arduino. Dopo avere scelto il pin e settato le variabili di rito, nel loop il metodo Serial.available() ci dice se ci sono byte in arrivo sulla seriale.

In questo esempio stiamo convenendo che un punto interrogativo ‘?’ deve dire ad Arduino di leggere lo stato del pin e restituirlo.

Una ‘A’ deve fare accendere il pin, una ‘S’ deve farlo spegnere, una ‘C’ deve cambiarne lo stato. In ogni caso deve poi fornire una risposta di conferma che conveniamo debba finire con un punto e virgola.

In ogni caso deve poi fornire una risposta di conferma che conveniamo debba finire con un punto e virgola.

#define OFF LOW //spento
#define ON HIGH // acceso
#define PinLed 13 //pin da comandare
char* Risp; // risposta di Arduino
byte data; // carattere ricevuto

void setup() {
 pinMode(PinLed,OUTPUT);
 Serial.begin(9600);
}

void loop() {
 if(Serial.available()>0) //se arriva un byte dal pc
 {
   Risp="?;";
   data = Serial.read(); // leggo dalla seriale
 
   if (data=='?'){
     if (digitalRead(PinLed)==ON) Risp="ON;";
     else Risp="OFF;";
   }
 
   if (data=='A'){ // accendi il led
     digitalWrite(PinLed,ON);
     Risp="ON;";
   }
 
   if (data=='S'){ // spegni il led
     digitalWrite(PinLed,OFF);
     Risp="OFF;";
   } 
 
   if (data=='C'){ // cambia lo stato del led
     if (digitalRead(PinLed)==ON)
       {
       digitalWrite(PinLed,OFF);
       Risp="OFF;";
       }
   else 
      {
       digitalWrite(PinLed,ON);
       Risp="ON;";
      }
   }
 
   if (data=='T'){
      // in base al vostro sensore di temperatura
      // scrivete il codice opportuno
      //leggi la temperatura dal sensore e poi
     Risp="Temperatura...;";
   }

   //altri if e poi...
  
   Serial.write(Risp); // restituiamo la risposta

  } // if serial.available
} // loop

Per chi volesse fare un piccolo passo in più, conveniamo di leggere il valore della Temperatura dall’apposito sensore e restituirlo quando sulla seriale perviene una richiesta tramite il byte ‘T’.

Visual Basic. In un nuovo progetto Visual Basic, inseriamo nel Form principale (che chiameremo Desktop) un oggetto picture in cui alterneremo una qualunque coppia di immagini On e Off (su Google Immagini se ne trovano un milione).

Le immagini le salveremo nella stessa cartella dove verrà creato l’eseguibile con nomi on.jpg e off.jpg; i più ardimentosi potranno inserire un secondo oggetto picture con l’immagine di un termometro.

Poi ci serve una Label in cui visualizzare i messaggi di ritorno di Arduino.

Inseriamo nel progetto un oggetto SerialPort e conveniamo di associarlo alla Com7. Nel Form_Load dobbiamo settare le variabili e, nel caso la porta Com7 non fosse disponibile, diamo la possibilità all’utente di rettificare la scelta di default grazie all’intercettazione dell’errore 57.

Private Sub Desktop_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load
  On Error GoTo Errore
  With SerialPort
     .PortName = "COM7" ' oppure altra porta 
     .Open()
     Me.Text = "Serial 2008 Arduino - " & .PortName
  End With
  Dim OnOff As String
  OnOff = Invia("?")
  Img.Load(Application.StartupPath & "/" & OnOff & ".jpg")
  Label1.Text = OnOff
  Exit Sub
Errore:
  If Err.Number = 57 Then
    Dim Porta As String
    Porta = "" & InputBox(Err.Description & " Inserisci nome porta", , "COM7")
    If Porta <> "" Then
       SerialPort.PortName = Porta
       Resume
    End If
  End If
  MsgBox("[" & Err.Number & "] " & Err.Description)
End Sub

La funzione Invia prende come parametro una Stringa, ovvero il carattere da inviare ad Arduino tramite la scrittura sulla seriale.

Gestisce l’eventuale verificarsi di errori e restituisce una stringa che è la risposta di Arduino. Questa viene letta dalla seriale fino a che non arriva il punto e virgola che decreta la fine della trasmissione.

Nel Form_Load viene subito interrogato Arduino sullo stato attuale del pin, e viene visualizzata l’immagine on.jpg oppure off.jpg.

Private Function Invia(ByVal Carattere As String) As String
  If Carattere = "" Then
     Return ""
  End If
  Dim Risultato As String = ""
  Dim c As String = ""
  SerialPort.DiscardInBuffer()
  SerialPort.DiscardOutBuffer()
  Try
   SerialPort.Write(Carattere)
  Catch ex As Exception
   Return "Errore [" & Err.Number & "] " & Err.Description
  End Try

  While True
    While SerialPort.BytesToRead > 0
      c = Chr(SerialPort.ReadChar)
      If c = ";" Then
        Return Risultato
      Else
        Risultato = Risultato & c.ToString
      End If
    End While
  End While
  Return ""
End Function

Ora è facile associare al click dell’immagine l’invio di una “C” che faccia cambiare lo stato del pin e visualizzi la nuova jpg.

Private Sub Img_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Img.Click
  Dim OnOff As String
  OnOff = Invia("C")
  Label1.Text = OnOff
  Img.Load(Application.StartupPath & "" & OnOff & ".jpg")
End Sub

Analogamente, possiamo associare al click dell’immagine del termometro l’invio del carattere “T” e la visualizzazione della risposta sulla Label1

Private Sub Temperatura_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Temperatura.Click
  Label1.Text = Invia("T")
End Sub

Prendendo spunto da questi semplici comandi possiamo adesso arricchire il progetto di nuovi invii di caratteri avendo cura di creare apposite procedure nella corrispondente controparte in Arduino.

Un’ultima raccomandazione. Allo stato attuale, l’invio di un comando non riconosciuto da Arduino comporta la restituzione della stringa “?;” che verrà percepita da Visual Basic come una risposta che contiene un punto interrogativo.

Non dimentichiamo il punto e virgola finale quando Arduino invia una risposta a Visual Basic, altrimenti quest’ultimo riceve la risposta ma rimane in attesa del punto e virgola rischiando di bloccare la porta seriale in un loop infinito.

Agli amanti di vb6. Come promesso, mi rimane un ultimo debito da saldare nei confronti degli amanti di vb6.

Lo stesso progettino si può realizzare anche in vb6, anzi, vi confesso che anche io la prima volta l’ho scritto in vb6 per sbrigarmi presto.

Succede però un inconveniente: ogni volta che si lancia il programma in vb6 e viene stabilita la connessione seriale, Arduino si resetta. Ricarica il setup e poi regolarmente esegue il suo loop.

In questa maniera, se ad esempio abbiamo lasciato uno o più pin settati in un certo modo, non appena apriamo il vb6 si ritorna allo stato iniziale di setup.

Questo non è accettabile se il sistema deve mantenere la sua vita e la sua configurazione con continuità nel tempo.

In Visual Basic 2008 questo non succede.

Si può accendere un led, settare dei pin e uscire dal programma, quando si riapre il programma Arduino continua il suo lavoro.

La comunicazione seriale si comporta in maniera assolutamente trasparente e indolore, al contrario del vb6.