PLC-PIC

LADDER per il PLC Micro-GT P876

scarica il PDF della documentazione tecnica di questa famiglia di PIC

Una volta realizzato il PLC_PIC Micro-GT P876 vi troverete nella necessità di poterlo programmare in maniera analoga a quella di un vero PLC commerciale.  Dopo una breve ricerca in internet ho trovato questo validissimo lavoro che riporto senza alcun tipo di modifica.

ATTENZIONE: QUANTO SEGUE NON E' OPERA PROPRIA MA SEMPLICEMENTE IL MIRROR DELLA PAGINA DISPONIBILE AL SEGUENTE INDIRIZZO: http://www.webalice.it/gino.mariani/LDmicro/LDmicroPIC_AVR_IT.html

LA PROPRIETA' INTELLETTUALE DI QUALSIASI COSA SOTTO RIPORTATA RIMANE DEI RISPETTIVI AUTORI CITATI NELLA PAGINA ORIGINALE.

----------------

Ladder Logic per PIC e AVR

Traduzione in italiano della pagina originale di Jonathan Westhues: http://cq.cx/index.pl

Il compilatore LDmicro è stato progettato per generare con facilità il codice nativo per micro-controllori PIC ed AVR partendo da un ladder grafico. Le funzioni e le caratteristiche del compilatore includono:

Clicca quì accanto per ottenere e provare una copia gratuita del programma. Oppure, per valutare la documentazione messa a tua disposizione:

Introduzione

I PLC sono spesso programmati in Ladder Logic. Questo è perché i PLC hanno sostituito il sistema di controllo dei relé e, ancora quaranta anni più tardi, non è stato abbandonato del tutto. Un PLC, come ogn micro-processore, esegue una serie di istruzioni in seguenza. Gli "arnesi" del Ladder Logic fanno proprio questo; infatti, si può programmare un PLC, cablandolo, sullo schermo, con i contatti e le bobbine, e mandando il PLC in esecuzione runtime simulando il circuito che si è disegnato. Alcuni contatti dei relé possono essere collegati a segnali in ingresso come se fossero collegati a reali apparecchiature; qualche altra bobina potrebbe essere collegata come uscita verso un carico. In questo modo si può realmente simulare il circuito mentre interagisce con altre aparecchiature, controllando veramente il loro comportamento in " campo". Queste sono le cose importanti che si possono fare, ma non solo queste.

Infatti, inoltre, è possibile incorporare temporizzatori e contatori, operazioni matematiche che non sarebbero facilmente implementabili manipolando semplicemente dei relé. Il concetto del circuito rimane sempre utile anche se, in parte proprio perché è intuitivo, fa risaltare i problemi legati ai nodi, alla ripetizioni delle coincidenze, ecc. . Guardiamo a questo segmento di combinazioni logiche:

         ||       Xa               Xb              Yout     ||
       1 ||-------] [------+-------] [------+-------( )------- ||
         ||                |                   |                  ||
         ||                |       Xc        |                   ||
         ||                +-------]/[------+                   ||

Questo è un semplice segmento di una composizione di combinazione logica. Gli ingressi sono tre , denominati: "Xa", " Xb" e "Xc"; mentre vi è solo un'uscita, denominata "Yout". Da cui l'espresione: Yout= Xa and ( Xb or ( not Xc )). Si pensi a Xa e Xb come contatti normarmante aperti e Xc come contatti normalmente chiusi e Yout come se fosse la bobima di un relè. Sicuramente è più complicato di questo:

         ||                                                             ||
         ||                                      Asetpoint         ||
       1 ||-------------------------------------{READ ADC}----||
         ||                                                             ||
         ||                                    Atemperature     ||
         ||-------------------------------------{READ ADC}---- ||
         ||                                                             ||
         ||                                                             ||
         ||                                                             ||
         ||                                                             ||
         ||                        {SUB  min_temp  :=}       ||
       2 ||------------------------{ Asetpoint - 20  }-----------||
         ||                                                             ||
         ||                        {ADD  max_temp  :=}      ||
         ||------------------------{ Asetpoint    + 20  }--------||
         ||                                                             ||
         ||                                                             ||
         ||                                                             ||
         ||                                                             ||
         ||[Atemperature >]                       Yheater  ||
       3 ||[ max_temp     ]+------------------------(R)-------||
         ||                         |                                   ||
         ||     Xenable         |                                   ||
         ||-------]/[---------------+                                  ||
         ||                                                             ||
         ||[Atemperature <]      Xenable   Yheater     ||
         ||[ min_temp     ]--------] [----------------(S)-------||
         ||                                                             ||
         ||                                                             ||
         ||                                                             ||
         ||                                                             ||
         ||                       {SUB  check_temp  :=}    ||
       4 ||-----------------------{ Asetpoint - 30    }----------||
         ||                                                             ||
         ||                                                             ||
         ||                                                             ||
         ||                                                             ||
         ||[Atemperature >]                       Yis_hot  ||
       5 ||[ check_temp   ]-------------------------( )--------||
         ||                                                             ||
         ||                                                             ||
         ||                                                             ||
         ||------[END]----------------------------------------------||
         ||                                                             ||
         ||                                                             ||

Qeusto è per un semplice termostato. Vi sono due ingressi analogici; uno di loro è per "settare il punto" in modo tale che potrebbe essere, per esempio, connesso ad un potenziometro così che, l'utilizzatore, può selezionere la temperatura desiderata. L'altro potrebbe essere utile per la misura della temperatura; ad esempio, potrebbe essere un semiconduttore sensore di temperatura, o un RTD al platino fornito da adeguato circuito di interfaccia. Si può vedere che vi è un uscita disgitale, Yheater. Questo potrebbe controllare un termosifone attraverso un interruttore adatto allo scopo (un TRIAC, oppure un solid-state relè, o qualunque altro dispositivo).

Il loop è chiuso con un semplice hysteretic (bang-bang ) controller. Sono stati selezionati più o meno 20 unità di Hysteretic.. Questo vuol dire che quando la temperatura scende al di sotto (setpoint +20), si accende il riscaldamneto e, viceversa, quando (setpoint + 20) raggiunge il limite da noi impostato, spegnerà il riscaldamento.

Come si vede nel grafico precedente sono stati aggiunti alcuni piccoli accorgimenti. Il primo riguarda un input forzato: il riscaldamento è costretto allo spegnimento quando Xenable è a livello basso. E' stata aggiunta anche una luce spia, Yis_hot, che indica che la temperatura in esercizio sia compresa all'interno della regolazione. In tal modo viene continuamente comparato il limite imposto (setpoint - 20) dalla soglia affinché la luce spia non si accenda durante i cicli normali del termostato.

Questo è un esempio a grandi linee, ma dovrebbe essere abbastanza chiaro che il linguaggio operativo è abbastanza espressivo. "Ladder Logic" non è un linguaggio di programmazione di tipo "general purpose" ma piuttosto è del tipo "Turing-complete", accettato nelle industrie, e, per un certo numero di classi di problemi (maggiormente "control-oriented"), è sorprendentemente conveniente.

Il Compiler Ladder Logic per i PIC16 e AVR

I moderni micro-controllori sub-3.00 USD probabilmente hanno la stessa potenza di calcolo dei PLC del 1975. Questi però mettono a disposizione molti più MIPS di quanti siano effettivamente siano necesari in esercizio in ladder logic ragionevolmente complessi con un cliclo di tempo di pochi millisecondi. Penso che di solito i PLC hanno un runtime abbastanza vicino ad un interprete o ad una machina virtuale, ma se dovessimo operare con una logica semplice su un microprocessore senza molta memoria, allora l'utilizzo un compilatore potrebbe essere una idea migliore.

Sulla base di queste considerazioni ho scritto un compiler. Si inizia con un rung vuoto(rungs = collegamenti orizzontali tra i montanti, detti pioli o rung, che contengono a sinistra dei contatti e a destra delle bobine.) . All'interno si aggiungono dei contatti (in genere a sinistra del rung) "inputs" e delle bobine (in genere a destra del rung) "outputs" o quant'altra struttura per costruire il propio programma. Nel compilatore è ben supportatto la configurazione del Timers (TON, TOFF, RTO) e la cui massima/minima durata dipende dal tempo ciclo del PLC; i Timers possono contare a partire da millisecondi a decine di minuti. Inoltre sono previsti contatori e operazioni artimetiche (addizione, sottrazione, divisione,ecc.ecc.).

Ogni elemento nel circuito può essere aggiunto, rispetto agli elementi di già inseriti, sia in serie che in parallelo agli elementi esistenti. Una lista di Inputs/Outputs (I/O) è prodotta dal grafico stesso. Si possono avere relè interni (Rfoo), i quali vengono automaticamente allocati in memoria, oppure ingressi (Xfoo) e uscite (Yfoo) per i quali è necessario assegnare il ccollegamento con i rispettivi pin del micro-controllore (famiglia Atmel - PIC); ovviamente, la disponibilità del numero di selezione dei pin dipende dal tipo di micro-controllore usato o che si intende usare. Nel mio compiler ho preso in cosiderazione le più popolari e più facilmente reperibili serìe di micro-controllori PIC e AVR (vedi più giù).

Editare il programma in forma grafica:

Il programma, una volta scritto, si può testare attraverso la simulazione in tempo reale; infatti, nella apposita sezione del menu, appena lanciata la simulazione, sullo schermo appaiono chiaramente evidenziate (true) i rami "energizzati" , e questo rende molto facile il processo di bebug (investigazione) del programma scritto. Lo stato di tutte le variabili sono mostrate in una sotto finestra in fondo alla schermo nell'apposita sezione - lista di I/O.

Una volta che nella selezione "simulazione " il programma si comporta come avevano stabilito si possono definitivamente assegnare i pin di ingresso e di uscita e generare, dirattamente da menu, il codice da tarsferire nel micro-controllore da noi adoperato, sia esso un PIC o un AVR. La generazione del codice non è affatto difficile, mentre l'editazione richiede più impegno e potrebbe essere necessario un pò di lavoro per ottenere una compilazione abbastanza sagace. Per la serie AVR una buona allocazione dei registri fornirà delle prestazioni più veloci. Se si desidera elaborare qualcosa più interessante allora si potrebbero applicare i criteri di "standard logic reduction algorithms" e, forse anche, "state reduction". I temporizzatori, comunque, tendono sempre ad accumulare .

Il prodotto della produzione di codice (back end) per gli AVR produce del codice per i PIC...per esempio: L'intero processo non si avvantaggia per niente del fatto che i micro-controllori AVR hanno più di un registro e qualche codice generato è imbarazzantemente "cattivo". Invece, il codice generato per i PIC è migliore, ma non realmente "grande". Niente di ciò importa molto a meno che si ha a che fare con dozzine di rungs di logica con tempi di ciclo veloci.

Con il mio compiler supporto l'A/D converter, unità di PWM, e l'UART in quei micro-controllori che sono forniti di queste periferiche. In breve, ciò vuol dire che si può scrivere delle istruzioni in Ladder Logic che leggano gli ingressi analogici, che inviìno e ricevino caratteri attraverso la porta seriale del micro (ad esempio, ad un PC se si aggiunge un idoneo level-shifter "commutatore di livelli del tipo MAX.232 o inviare dei caratteri ad un LCD). E' altrettanto possibile inviare arbitrarie stringhe lungo la seriale, come anche i valori di variabili di interi, come caratteri in formato ASCII. Finalmente, adesso è supportata la funzione di 'preserved variables' su dispositivi dotati di memoria EEPROM; adesso si può indicare che una particolare variabile deve essere auto-conservata (salvata), ogni qual volta essa cambia, nella memoria non volatile del dispositivo in tal modo il suo valore è persistente ed indifferente all'accenzione o al reset del dispositivo.

Limitazioni e de-responsabilizzazioni // Limitations and Disclaimer

Naturalmente un micro-controllore con questo software (firmware) non può fare tutto quello che un PLC fa. La gran parte di ambienti di programmazione per PLC offrono più funzioni e blocchi predefiniti dei miei, anche sotto il profilo harware. Solitamente gli ingressi e le uscite sono progettati per sopportare o essere esposti ad incredibili abusi elettrici. Si può acquistare un PIC16F877 corredato di scheda per dieci o venti USD, penso, e si può pagare abbastanza un pò di più per un PLC con le stesse capacità.

Sino ad ora io ho ricevuto molte poche segnalazioni di "bug" comparati al numero di persone le quali si sono rivolte a me per questioni o per richieste di funzioni. Rimangono grandi possibilità per difetti, specialmente negli obiettivi dei micro-controllori che io, proprio fisicamente, non ho (e perciò non posso testare). Certamente non si deve usare LDmicro per qualunque cosa che abbia a che fare con i punti critici della sicurezza oppure con qualunque cosa di costoso che, a causa di un'avaria, si potrebbe danneggiare .

Come è stato fatto notare più sopra, il codice che è generato è lontano dalla forma ottimale. Inoltre, non tutta la porzione della data RAM, nei didpositivi PIC16 è disponibile per il ladder logic program. Questo perché io non ho implementato molto supporto per tutte le "pagine" senza senso. Io ho, tuttavia, supportato il "program memory paging", il quale è necessario per accedere al "program memory locations" nei PIC16 oltre 2K.

Download

Il software è stato testato sotto WIndows XP. Notizie non confermate riportano che LDmicro lavora anche sotto windows '98. Il download è un .exe file; non sono richiesti altri files, e non c'é un programma d'installazione. Basta salvare il file .exe da qualche parte nel proprio computer, lanciarlo, ed esso lavorerà. Il manuale è incluso nel .exe file, ma se si crede lo si può scaricare separatamente.

Il compiler genera Intel IHEX files. Per quello che io so la gran parte dei software di programmazione si aspettano questo formato. Naturalmente occorrerà qualche "aggeggio" per tarsferire l'hex file nella memoria del chip. Olimex ne ha qualcuno a buon mercato. Io uso Pony Prog per AVRs connesso con STk300 dongle, mentre una PICALL per i PICs.

Sono apprezzati le notizie di "bug". I segurnti chips sono suppportati e testati:

 

 

I seguenti chips sono suppportati ma non testati; questi, dovrebbero lavorare ma non posso fornire alcuna garanzia. Nel caso se ne provi qualcuno di questi e và bene sarà apprezzata ogni notizia di successo.

 

 

Dal programma ladder è anche possibile del generare in C. Questo è meno conveniente, ma si potrebbe usare in ogni altro processore per il quale si ha un compilatore in C.

LDmicro può generare byte codice interpretabile. Nel caso si intendese scrivere un interprete allora si potrebbe usare questo per effettuare il proprio codice ladder su ogni tipo di "target". Non c'è molta documentazione, a questo proposito, ma ho fornito un campione di interprete per la gran parte di C "portabile" .

Il programma è quì:

 

 

(right-click to save any of these files)

Si prega di riferire ogni tipo di "bug". Questo software è freeware. Non ho avuto tutto l'hardware per effettuare dei test su tutti i micro elencati. Un bug che non è riferito sarà ben lontano dall'essere individuato //This is freeware, with no department in charge of quality control. I do not even have the hardware to test many of the targets myself. A bug that is not reported is unlikely to ever be fixed.

Ho anche messo a disposizione: tutorial, nel quale descrivo come iniziare un semplice grafico ladder, simulandolo, e quindi generando un IHEX file e programmare con questo file .hex un PIC. Questa è probabilmente la via più facile per iniziare con questo software

Traduzione in italiano della pagina originale di Jonathan Westhues: http://cq.cx/index.pl

 

 

---------------

  Pagina precedente