CamiSCADA

Avevo iniziato con un precedente post su Processing e SCADA, ed ora la continuazione

L’INIZIO

Il progetto si chiama CamiSCADA perchè le prime righe di codice le ho scritte a Camignolo, presso la Scuola Media, in questa primavera.

In questo articolo descrivo più dettagliatamente il progetto, ma prima di tutto…a che serve?

Cosa si può fare con CamiSCADA

CamiSCADA è una applicazione scritta in linguaggio Java, o meglio in Processing, che si occupa di visualizzare l’andamento di controllori, quali PLC ed Arduini varii.

In pratica uno SCADA è una sorta di “cruscotto” che permette di avere la “visione d’insieme”.

La novità di CamiSCADA è…

CamiSCADA integra una interessante funzionalità: la modalità demo.

è possibile quindi simulare il funzionamento di un sistema facendolo apparire come se il tutto stesse funzionando: tank che si riempiono , valvole che si aprono e via dicendo.

Primo demo: birrificio

Il primo demo simula un birrificio ad una linea di maltatura e tre linee di fermentazione.

Per eseguire la demo “birrificio” basterà copiare (=sostituire) i due file “camiscada.dat” e “camiscada.ini” nella directory home di CamiSCADA.

Video esempio

Un video-esempio è stato caricato su Youtube: questo è il link.

Secondo demo: creazione filamenti

In questo caso si simula la produzione di filamenti polimerici per estrusione a bassa pressione.

Anche in questo caso per eseguire la demo basterà copiare (=sostituire) i due file “camiscada.dat” e “camiscada.ini” nella directory home di CamiSCADA.

Come installare

Scompattare il file zip ( cliccare qui per scaricarlo ) in una directory, per esempio “camiscada”. Verranno automaticamente create le sotto-directory relative.
Dopo l’installazione è già “in linea” la demo per il birrificio, quindi basterà avviare Processing e successivamente caricare lo script presente nella directory “som_lab50_10”: som_lab50_10.pde.

Requisiti

Processing richiede poche risorse, è parsimonioso. Unica nota è la versione di Processing che deve essere almeno la 5.3.

Codice

Il codice, o sorgente, di CamiSCADA, è diviso in due parti: oggetti e run-time.

Oggetti

Gli oggetti sono tipicamente delle macchine, per esempio un tank è un oggetto. allo stesso modo una saldatrice automatica è un oggetto, così come lo è una valvola.

Tra gli oggetti vi sono i diversi apparati che si possono incontrare in questi ambiti: tank, valvole e tubi.
Ogni oggetto è provvisto di “maniglie” per poter effettuare il legame con gli oggetti.

Struttura oggetti

Tutti gli oggetti di CamiSCADA, sono dotati di due tipi di attributi:

  • attuatori
  • sensori

I metodi principali sono:

  • mshow – per visualizzare graficamente
  • mgethole – per conoscere le coordinate delle “maniglie”
  • minfo – per visualizzare i testi

Sensori

I sensori inviano dei valori alla console SCADA. La tipologia ed il numero dei sensori possono variare da oggetto ad oggetto: per esempio un tank avrà tre tipi di sensori:

if ( match(wparm[0], "CAP") != null  ) {
  this.wfiller=float(wparm[1]);
}
if ( match(wparm[0], "TEM") != null  ) {
  this.wtempc=float(wparm[1]);
}
if ( match(wparm[0], "BAR") != null  ) {
  this.wpress=float(wparm[1]);

dove TEM è una sonda termica, BAR per la pressione e CAP per il livello.

Struttura camiscada.ini

è il file che contiene l’elenco degli oggetti e la loro disposizione (layout). Si tratta di un file di testo, strutturato e diviso in due sezioni.
Nella prima sezione troviamo gli oggetti, menre nella seconda i collegamenti.
Una riga della prima sezione ha la forma:


TANK;p1b1d1m1c1;90;50;HLT


dove “TANK” è il tipo di oggetto (ed è definito all’interno del programma), poi “p1b1d1m2c1” è il codice di questo tank. La coppia di numeri identifica il punto da dove verrà disegnato il tank, nel formato x e y. Ultimo “HLT” è il nome col quale verrà visualizzato il tank.

Per la seconda sezione, i raccordi la struttura è un po’ diversa:


PIPE;p1b1d1m4c6;p1b1d1m1c3;DX;p1b1d1m3c6;SX;to_pump3a

anche qui “PIPE” è il tipo di oggetto, “p1b1d1m4c6” è il nome del raccordo.
La coppia “p1b1d1m1c3;DX” indica che il raccordo partirà dalla maniglia DX dell’oggetto “p1b1d1m1c3” e si raccorderà alla SX di “p1b1d1m3c6”.
Infine “to_pump3a” è il nome che verrà visualizzato.

Denominazione dispositivi

Per assegnare un codice ai diversi dispositivi ho utilizzato una codifica già presente: la DNP3. In sintesi una stringa “p1b1d1m1c1” significa:

  • p1 = impianto
  • b1 = building, edificio
  • d1 = department, settore
  • m1= machine
  • c1 = component, parte della macchina, sensore o attuatore.

Ovviamente il numero è un progressivo quindi un nome possibile potrebbe essere: p1b4d2m21c5.

Struttura camiscada.dat

Questo file è opzionale in quanto contiene i comandi che l’applicazione riceve e che dovrà visualizzare.

La posizione di questo file è la stessa dalla quale viene avviata l’applicazione ovvero dove si trova il file som_lab50_10.pde.

è possibile inserire dei commenti all’interno del file, tramite il simbolo “#” posto all’inizio della riga.

# camiscada demo brewery
# 2019
 p1b1d1m1c1;CAP=10
 p1b1d1m1c1;CAP=20
 p1b1d1m1c1;CAP=30
 p1b1d1m1c1;CAP=40
 p1b1d1m1c1;CAP=50
 p1b1d1m1c1;CAP=60
 p1b1d1m1c1;CAP=70
 p1b1d1m1c1;CAP=80
 p1b1d1m1c1;CAP=90
# tank HLT al max

Collegamento con Arduino

Il collegamento con Arduino avviene attraverso porta USB. Il formato dell’informazione è quello già descritto in camiscada.dat, quindi il modulo Arduino dovrà rispettare il protocollo utilizzando la corretta sintassi:

Serial.println("p1b1d1m1c1;CAP=90");

In questo caso il codice del dispositivo (p1b1d1m1c1) è cablato nello sketch di Arduino. In alternativa è possibile associare il codice dispositivo ad una specifica porta USB.

Conclusione

Per usare Processing è necessaria una seppur minima conoscenza di Java e programmazione ad oggetti.

Il vantaggio di utilizzare una libreria consiste nel fatto che molto del lavoro è già stato fatto e si tratta solo di adattamenti.

Il discorso cambia quando è necessario creare un nuovo oggetto: in questo caso basterà duplicarne uno già esistente ed apportare le necessarie variazioni.

L’argomento sulla modifica degli oggetti verrà affrontato in un articolo successivo.

Arduino diventa un PLC

In diversi casi Arduino può sostituire un PLC. Per coloro ai quali la sigla PLC suona strana, si tratta dell’acronimo di Programmable Logic Controller. In sostanza un PLC è un dispositivo industriale, un controller, in grado di automatizzare semplici sistemi quali caldaie, cancelli, macchine automatiche per la produzione, ecc.

 

 

SVILUPPO SOFTWARE PLC

In un certo senso il PLC utilizzano un circuito-codice: una sorta incrocio tra il circuito elettrico che gestiranno ed i relativi simboli. Infatti i PLC in qualche maniera sono la continuazione di quello era prima il campo di applicazione dei relais (normalmente aperti, normalmente chiusi, passo-passo, timer, ecc.).

Per quanto concerne il codice vero e proprio, i PLC possono essere programmati utilizzando due tipi di interfacce:

  • editor semplice, ASCII – linguaggio AWL
  • ambiente grafico – linguaggio Ladder

Un semplice editor di testo andrà bene per linguaggi quali AWL, dove tutto il carico di comprendere il circuito-codice è compito dello sviluppatore, mentre per la codifica ladder bisognerà utilizzare un software dedicato.

I produttori dei dispositivi forniscono la suite completa per lo sviluppo e quindi basterà scaricare, ed aggiornare il software che ci verrà messo a disposizione.

Nel nostro caso esploreremo delle soluzioni OpenSource o free.

 

AMBIENTI GRAFICI

Tra i diversi software in rete sono disponibili:

Putroppo si tratta di applicazioni con parecchie pecche specie per quanto concerne l’interfaccia utente, che per un ambiente grafico, non è poco. Così, per esempio, Autoware non fornisce l’help on line per l’inserimento delle label, anche se l’help sembrerebbe essere disponibile. Per quanto riguarda SoapBox, più ricco graficamente, ma molto caduco sotto Windows 8. Infine LDmicro, anch’esso, dal punto di vista grafico, scarsamente funzionale.

 

LIMITE DEL FREE

Purtroppo queste applicazioni risentono, con molta probabilità, della scarsità di mezzi (economici),  e conseguentemente dalla motivazione all’upgrade. Infatti si tratta di applicazioni (chi più e chi meno) datate, poco aggiornate in pratica: chi sviluppa non ha avuto un sostegno economico, magari anche minimo.

Questo è un punto focale: se un progetto software (applicazione) ci interessa, va sostenuto anche con un piccolo contributo. Altrimenti poi non ci si deve lamentare se si deve acquistare un software proprietario con tutti i “lucchetti” possibili ed immaginabili (p.es. licenza singola gestita in Rete), il cui costo è solitamente elevato.

Tornerò su questo argomento perchè è un capitolo troppo importante, proprio anche per lo sviluppo tecnologico.

 

PLCLIB

Questo software, ma è più corretto dire libreria, integrabile nella IDE di Arduino.

Essendo una libreria non avremo altre voci aggiunte nel menu della IDE, ma dovrà essere inglobato nel nostro programma tramite la direttiva “include”.

plcLib è un modo diverso di scrivere il codice per PLC: una sorta di via di mezzo tra sketching e AWL. Concettualmente è più vicino al modo di pensare di chi usa Arduino e quindi ai costrutti del C/C++.

 

INSTALLARE PLCLIB

La libreria plcLib può scaricata passando dalla pagina Software.

Il file deve rimanere “zippato”, magari nella cartella “download” (a seconda del browser e sistema operativo usato).

Eh si, plcLib gira su tutti i sistemi dove gira la IDE, e questo particolare lo interessante rispetto agli altri software.

A questo punto aprire la IDE e dal menu selezionare Sketch e poi “add library” ed infine selezionare il file zip scaricato. Tutto qui.

USARE PLCLIB

Con la IDE aperta, selezionare File / Nuovo, poi Sketch / Import library. Per importare la libreria plcLib bisognerà selezionare la voce “plcLib”.

A queso punto il sketch diventerà:

 

PROVA ARDUINO-PLC

Colleghiamo il nostro Arduino (p.es. UNO) e scriviamo il codice

/*
  Moesa d'Ur SA
  
  engineering staff of M'AU
  
  project:    lab18_ard1
  file name:  som_lab18_00.ino
  porpouse:   PLC emulator.
 
who       when        what 
---------------------------------------------
mr       11.11.2016   creates 


*/
#include <plcLib.h>

void setup() {
  setupPLC();             // Setup inputs and outputs
}

void loop() {
  in(X0);                 // Read switch connected to Input 0 (Set input - Input 0)
 // andNotBit(X1);      // Latch command, Output = AUX0, Reset = AUX1 (Input 1)
   andBit(X1);    
  out(Y0);
}

 NOTE SUL CODICE

Proviamo a comprendere le poche e semplice righe del programmino.

La riga

#include <plcLib.h>

è una direttiva al preprocessore il quale viene istruito per caricare il file plcLib.h che verra cercato nella cartella “libraries” secondo la regola:

home_dir/arduino/libraries

ad esempio in ambiente Windows il persorso potrebbe essere:

C:UsersmauroDocumentsArduinolibraries

Successivamente la funzione “canonica” Setup contiene una funzione che appartiene alla libreria appena installata. Si tratta di un Setup specifico che dovremo per forza includere perchè sarà lui, tra l’altro, ad impostare le porte utilizzate dal plcLib:

const int X0 = A0;
const int X1 = A1;
const int X2 = A2;
const int X3 = A3;

const int Y0 = 3;
const int Y1 = 5;
const int Y2 = 6;
const int Y3 = 9;

Andiamo oltre.

La funzione loop contiene solo tre righe: nella prima viene letto il valore di A0 (vedi tabella precedente). Questo valore viene salvato automaticamente dalla libreria in una variabile interna (che è stata definita dalla libreri plcLib). Allo stesso modo la funzione andBit(X1) leggerà A1 e salverà il risultato dell’AND tra A0 e A1.

Come noto la funzione booleana AND ritorna un valore alto solo se tutti gli ingressi (A0 e A1) sono alti.

L’ultima istruzione out(Y0) scriverà il risultato ottenuto dalla precedente riga (andBit).

 

MATERIALI E COLLEGAMENTI

Piccola lista della spesa

  • Arduino UNO
  • 2 resistenze 1K 1/4W (il disegno riporta 220Ohm, ma 1K è meglio…)
  • led 5mm
  • jumper, quanto basta…

Collegare così:

 

Sul circuito elettrico le osservazioni sono davvero poche fatta eccezione la resistenza di pull-up che dovrà garantire la stabilità dell’input su A0.

e buon PLC-Open a tutti!