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!

Consumo elettrico della stampante 3D

Quando è possibile, specie se la stampa 3D richiede molto tempo, si cerca di stampare di notte. Oppure, altro caso durante il week-end per poi tornare lunedì in ufficio e vedere il lavoro terminato.

Questo significa che la stampante, dopo aver lavorato, rimarrà accesa per diverse ore. Ma quanto costa?

L’unico modo di scoprirlo è fare delle prove e misure.

 

PROVA STAMPANTE 3D

Per la prova dei consumi elettrici ho utilizzato una stampante Overlord PRO. Si tratta di una macchina di concezione recente: dotata di livellamento automatico (Z-gap) e piatto riscaldato veloce.

 

 

 

 

COME VIENE PROVATA?

È stato sezionato il collegamento sulla spina 220 (T12) ed inserito un amperometro analogico. Le misure effettuate sono quattro:

  • spenta
  • stand-by
  • riscaldamento piatto
  • riscaldamento crogiolo

QUANTO CONSUMA UNA STAMPANTE 3D?

Ecco i risultati:

  1. spenta: 60mA
  2. stand-by: 90mA
  3. riscaldamento piatto: 750mA
  4. riscaldamento crogiolo: 740mA

Adesso possiamo distinguere tre fasi e i relativi consumi:

  1. spenta (come sopra) 60mA
  2. stand-by: (come sopra) 90mA
  3. in stampa (ABS): 750+740 mA = 1.49A

Chiaramente questi sono consumi istantanei, ciò significa che se la stampa dura 10 ore il suo consumo in kW sarà

((1.49x220)/1000) x 10 = 3.278kW/h

QUANTO MI COSTA QUANDO STAMPA?

Se ci si collega al portale https://www.strompreis.elcom.admin.ch è possibile vedere le tariffe elettriche per tipologia di impianto (p.es. H3).

Indicativamente il costo medio-alto per kW/h è di 20cts. Di conseguenza la nostra stampa ha inciso sulla bolletta elettrica per

0.20 x 3.278 = 0.6556CHF

poco più di mezzo franco, e stampando ABS (o simili).

 

E QUANTO MI COSTA IN STAND-BY

Quasi tutte le stampanti 3D hanno l’interruttore di accensione che interrompe solo il circuito di bassa tensione, e cioè a valle dell’alimentatore. Di conseguenza l’alimentatore avrà comunque un consumo minimo, ma comunque presente. Infatti l’alimentatore della stampante, così come quelli di tanti altri apparecchi, è del tipo switching (solitamente in flyback) il cui consumo elettrico del ramo primario è variabile in funzione della potenza assorbita. Nel nostro esempio la potenza assorbita a stampante spenta è 1/25 del consumo a piano regime e quindi avere la stampante collegata, ma spenta per 10 ore ci costerà

0.6556CHF / 25 = 0.026224CHF

 

ALTRE SOLUZIONI

Lasciare l’alimentatore collegato non è certo una buona pratica, oltre che rappresentare un, seppur, piccolo consumo.

Esistono delle soluzioni, una di queste è un nuovo dispositivo: mioswitch. Si tratta di una scheda che al ridursi dei consumo si autosgancia dalla rete elettrica, in pratica “stacca la spina”. Questo dispositivo, come già altri, opera nell’ambito del M2M o machine-to-machine, un comparto dell’IoT.

Come dicevo ci sono anche altre soluzioni, per esempio Octoprint, ma di questo ne parleremo un altra volta.

E poi per chi mastica di c’è sempre la possibilità di autocostruirlo: in fin dei conti è facile! Qualcuno se la sente?!

 

E buon risparmio elettrico a tutti!

 

 

 

 

Salva

Semaforo con Arduino

Negli esercizi di programmazione di automazione, il controllo semaforico è un classico esempio.

Usare il semaforo come esempio è utile perchè permettere di comprendere i meccanismi (a volte sofisticati) che un oggetto molto comune contiene. Solitamente per gli automobilisti il semaforo è una seccatura che non finisce mai.

Oggi vediamo come realizzane un semplice semaforo con una normale scheda Arduino UNO.

Per complicare un pochino le cose, il nostro semaforo potrà essere regolato in maniera da avere cicli (=tempi) variabili a nostro piacimento. A proposito: scrivendo di tempi del semaforo, mi è venuto in mente quello di Via Cattaneo a Lugano: sembra eterno!

 

COSA SERVE?

  • Arduino UNO
  • 7 resistenze 1/4W 1KΩ
  • 6 LED bianchi (da colorare con acrilico) oppure 2 coppie R/V/G
  • jumper
  • potenziometro 5-10KΩ A

Tutto materiale facilmente reperibile presso rivenditori oppure qui.

In questo esempio ho utilizzato solo LED bianchi, che ho poi colorato. La scelta di usare gli stessi LED (bianchi) è stata fatta per non dover variare le resistenze di caduta dei LED: come noto i LED di diversi colori hanno diverse cadute di tensione.

CIRCUITO

La disposizione dei componenti sulla breadboard è molto semplice: basterà fare attenzione alla denominazione dei pins:

 

semaforo fzz

POTENZIOMETRO

Nella scelta del potenziomentro, magari recuperato da un vecchio circuito, bisogna ricordarsi di usarne uno di tipo lineare (A) e non logaritrmico (B).

IL CODICE

Il programma è composto dalle due funzioni canoniche di Sketching: setup e loop.

In particolare, setup non contiene solo l’impostazione delle porte e modalità, ma anche una piccola parte di processo. Infatti in setup troviamo il lampeggio dei LED gialli, prologo al funzionamento successivo col verde e rosso. In pratica all’inizio (setup), il nostro semaforo lavorerà in modalità notturna per passare poi, dopo alcuni cicli, in modalità diurna.

Una nota merita il potenziomentro. Questo componente, lavorando come partitore resistivo, fornirà una tensione variabile al pin analogico 0. Su questo pin avremo una tensione che va da 0 a 4.7Vdc che varierà proporzionalmente alla rotazione della manopola per tutto l’arco (che nei potenziometri rotativi è di 270°).

 

/*
  FLW,2016
mauro rossolato
  
   project:    lab13_ard1
  file name:  som_lab13_00.ino
  porpouse:   light traffic
 
who       when        what 
---------------------------------------------
mr       16.07.2016   creates 


*/

#define msem1v 13
#define msem1g 12
#define msem1r 11
#define msem2v 10
#define msem2g 9
#define msem2r 8
#define mratepot 0

void setup() {
  int wjell;
  int wspeed;
  float wratio;
  float wratepot;
  pinMode(msem1v, OUTPUT);
pinMode(msem1g,OUTPUT);
pinMode(msem1r, OUTPUT);
 pinMode(msem2v, OUTPUT); 
 pinMode(msem2g, OUTPUT);
 pinMode(msem2r, OUTPUT);
  digitalWrite(msem1v, LOW);
 digitalWrite(msem1g, LOW);
 digitalWrite(msem1r, LOW);
 
 pinMode(mratepot, INPUT);
 
     Serial.begin(9600);
Serial.print( "Sensore pot: ");
// pinMode(6, OUTPUT);
// pinMode(7, OUTPUT);

 for (wjell=0;wjell<10;wjell++) {
   digitalWrite(msem1g, LOW);
     digitalWrite(msem2g, LOW);
   delay(500);
   digitalWrite(msem1g, HIGH);
     digitalWrite(msem2g, HIGH);
   delay(500);
 }
 // sem 1
 digitalWrite(msem1v, HIGH);
 digitalWrite(msem1g, LOW);
 digitalWrite(msem1r, LOW);
 // sem2
 digitalWrite(msem2v, LOW);
 digitalWrite(msem2g, LOW);
 digitalWrite(msem2r, HIGH);
 delay(4000);
}

void loop() {
  // read rate
  float wratepot;
  float wspeed;
  wratepot = analogRead(mratepot);
  wspeed = (wratepot *100)/1023;
    Serial.print("valore: ");
  Serial.println(wratepot); 
  // sem 1
  digitalWrite(msem1v, HIGH);
  digitalWrite(msem1g, LOW);
  digitalWrite(msem1r, LOW);  
  digitalWrite(msem2v, LOW);
  digitalWrite(msem2g, LOW);
  digitalWrite(msem2r, HIGH);  
  delay(50*wspeed);  
  digitalWrite(msem1g, HIGH);
  digitalWrite(msem2g, HIGH);  
  delay(50*wspeed);  
  digitalWrite(msem1v, LOW);
  digitalWrite(msem1g, LOW);
  digitalWrite(msem1r, HIGH);  
  digitalWrite(msem2v, HIGH);
  digitalWrite(msem2g, LOW);
  digitalWrite(msem2r, LOW);  
  delay(50*wspeed);  
  digitalWrite(msem1g, HIGH);
  digitalWrite(msem2g, HIGH);  
  delay(50*wspeed);
}

E buon controllo traffico a tutti!

 

 

Salva

Corsi per adulti – Stampa 3D – Lugano 2016a

Questo autunno è partito il corso per Progettazione e stampa 3D a Lugano, organizzato del CPA.

cpapage

Ci ha ospitati, per tutte le cinque lezioni, il Liceo 1, in  Via Cattaneo.

L’obiettivo, come al solito, è quello di passare “dalle parole ai fatti”, quindi dal disegno alla stampa 3D, cercando di realizzare oggetti utili al proprio lavoro oppure al proprio hobby.

 

DIVERSE ESIGENZE

È mia abitudine chiedere ai partecipanti di proporre essi stessi degli oggetti, cercando di evitare, se possibile, il solo download dell’STL.

Ecco quindi, chi ha bisogno di un prototipo meccanico, chi di un articolo di design, chi di un giocattolo…

 

…E DIVERSE STAMPE

Per le stampe dei progetti sono state usate alcune delle macchine presenti nel Fab-Lab di Grono:

  • Makerbot Replicator 2
  • Overlord PRO
  • ZMorph 3D
  • CreateBot MID

Queste macchine sono state configurate con parametri di stampa differenti, in particolare per quanto riguarda il dZ: dai 200μm ai 90μm. Per quanto riguarda i polimeri invece, sono stati utilizzati: PLA, ABS e HIPS.

dsc_0018

 

in evidenza la struttura di supporto
in evidenza la struttura di supporto

dsc_0022

dsc_0023

dsc_0025

dsc_0026

dsc_0027

dsc_0028

dsc_0030

dsc_0033

dsc_0041

dsc_0043

dsc_0044

dsc_0037

dsc_0046

 

Arduino – codice della lezione del 10.11.2016

Come promesso ecco due dei programmi che abbiamo visto nell’ultima lezione.

Il primo è stato modificato con la esplicitazione del blocco-codice (e non codice di blocco!), mentre il secondo riguarda l’uso del sensore PIR con allarme a tono variabile.

 

IL PRIMO

Come suggeritomi nell’ultima lezione, ho apportato una picocla modifica al programmino per il lampeggio dei LED.

Lo inserirò nel prossimo rilascio, e per il momento eccolo qui:

/*
  Moesa d'Ur SA
  
  engineering staff of M'AU
  
  project:    lab02_ard1
  file name:  som_lab01_00a.ino
  porpouse:   flashing led
 
who       when        what 
---------------------------------------------
mr       16.07.2016   creates 
mr            11.11.2016        code-block added


*/

// questo è un commento
// =====================================
// cambiare per nuova skeda...
int led = 13;         //  valore di uscita

int mctl = 11;
int wloop = 1;

void setup() {
    pinMode(led, OUTPUT);
     pinMode(mctl, INPUT);
 
}
 
// the loop routine runs over and over again forever:
void loop() {
  if (digitalRead(mctl)==HIGH ) {
//  11.11.2016 - mr - modificata per migliore lettura
//    if (wloop == 10)  wloop = 0;
        if (wloop == 10)  {
            wloop = 0;
        }
// fine modifica        
    wloop++;
    digitalWrite(led, HIGH); 
    delay(50*wloop);
    digitalWrite(led, LOW);
    delay(100*wloop);
    }
}

IL SECONDO

Questo secondo esempio è stato scritto “al volo” quindi è un po’ “grezzo”

/*
segnalatore presenza tramite PIR.
regole:
- emette un suono (porta 11) di frequenza proporzionale alla
persistenza del PIR.
MATERIALE:
- sensore PIR
- connettore minijack connesso alla porta 11

*/

int mpir =10;
int maudio = 11;
int mloop = 0;

void setup() {
  // put your setup code here, to run once:
pinMode(mpir, INPUT);
pinMode(maudio, OUTPUT);

}

void loop() {
int wpir=LOW;
wpir = digitalRead( mpir);
if ( wpir==HIGH) {
  mloop++;
  }
else {
  mloop = 0;
  
}

if (mloop > 0) {
  tone(maudio, mloop *10,100);
  delay(100);
  noTone(maudio);
}

}

 

 

 

 

 

 

Come aumentare la precisione dei cilindri in Sketchup

Per chi usa SkechtUp, ed è alle prime armi o click, sarà senz’altro capitato di disegnare dei cilindri, o coni, e poi in fase di CAE rimanere un po’ deluso. Deluso perchè lo sviluppo della circonferenza è “poligonale” e non circolare come dovrebbe.

Quindi il tema di oggi è come aumentare la precisione o definizione dei cilindri in SkechtUp, per evitare che diventino in stampa dei poligoni.

GUI “scarna”

Il problema è che questa caratteristica non è ben presentata nella gui (Graphical User Inferface) del programma. La gui è l’interfaccia grafica, quella con la quale interagiamo durante il lavoro: dove vediamo gli oggetti e dove inseriamo i comandi (tastiera, tavoletta, mouse, ecc.).

Come dicevo, la gui di SketchUp è un po’ scarna: manca di chiederci (o di farci vedere) la definizione adottata per le curve.

PERCHÈ I POLIGONI?

Prima di proseguire è bene comprendere la ragione di questo comportamento del programma. Il motivo è semplice: usando i

poligoni per costruire la circonferenza si diminuiscono i tempi di calcolo. Diciamo che di default SkecthUp cerca di farci risparmiare tempo e nel contempo di essere veloce: traslare e visualizzare un solido circolare richiede molti più cicli macchina e quindi tempo. Quindi è un comportamento “by design”.

CIRCONFERENZA “POLIGONALE”

 

Apriamo SkecthUp e creiamo un cerchio e poi lo estrudiamo. Le operazioni sono scelta della primitiva “cerchio” e poi il simbolo

 

di estrusione. Tutto grafico e tutto facilissimo.

Proseguendo, esportiamo in STL e poi importiamo nel nostro programma CAE (p.es. NetFabb):

Così non va, ci vuole dell’altro…

FINESTRELLA MAGICA

Per risolvere il nostro problema dobbiamo usare la finestrella-comandi che si trova in basso a destra:

 

Riapriamo una nuova sessione di SkecthUp e creiamo due cilindri: il primo allo stesso modo di quello precedente (default), mentre per il secondo useremo la finestrella, ma attenzione ai passaggi ed ai click di mouse. Ecco i passaggi:

  • dal menu, click su cerchio
  • trasciniamo il cerchio su un punto del piano
  • adesso premiamo il tasto SX del mouse e tenendolo premuto creiamo una circonferenza
  • TENIAMO sempre premuto il tasto SX del mouse ed inseriamo nella finestrella”40mm;90s”

A questo punto avremo un cerchio simile al precedente, ma con una caratteristica al momento non visibile: il numero dei lati.

CREIAMO L’STL

Come al solito, estrudiamo il cerchio e poi lo esportiamo in STL (v. articolo precedente).

Apriamo ora il nostro CAE ed importiamo il file STL appena creato:

 

ora va già meglio, ed è quello che effettivamente otterremo in stampa 3D.

 

COSA È SUCCESSO?

La soluzione al nostro problema è data da quel piccolo parametro inserito nella finestrella di SkechtUp: “90s“. Il suo significato è: 90 sides (o facce). Per la maggior parte delle circonferenze il valore 90 è congruo, ma volendo può essere aumentato.

 

Tutto qui, e buona circonferenya a tutti!

Salva

Salva

Salva

Salva

Salva