FACILEPLC (microPLC)

Ecco come costruire un microPLC per hobbystica varia con un piccolo microprocessore della serie PIC e poi programmarlo in un linguaggio FPLC simile all' AWL ma più semplice dell 'assembler.

ARDUOPLC

Disponibile da Febbraio 2012 su "www.arduoplc.blogspot.it" simile progetto creato per il kit Arduino Uno e K8055 della Velleman con simulatore e generatore di codice per Windows

Translate

schema scheda hardware FPLC

lunedì 19 luglio 2010

Free e OPEN SOURCE

Pubblicato da Giuseppe G.

1 commento:

meccman137 agosto 2015 alle ore 21:52
Ottimo progetto.
E' possibile avere le sorgenti per sviluppare ulteriormente il tuo progetto?
RispondiElimina
Risposte

Aggiungi commento

Carica altro...

Post più vecchio Home page

Iscriviti a: Commenti sul post (Atom)

Lettori fissi

Archivio blog

▼ 2010 (2)
- ▼ luglio (2)
  - Free e OPEN SOURCE
  - micro PLC con PIC16F84A programmabile in AWL

DOWNLOAD DIMOSTRATIVO

Download Completo FACILEPLC.ZIP

Se il download non funziona segnalatelo a "cimice96@hotmail.it". Grazie!

Informazioni

Data: 21/07/2010 Editor:G&G
Rev.Doc: 0.0
FACILEPLC_PRO By G&G

http://facileplc.blogspot.com
E-Mail:cimice96@hotmail.it

Come realizzare un MICROPLC professionale a 5 ingressi e 5 uscite.

Salve a tutti.

Inizio con lo specificare che l' utilizzo di quanto riportato, sarà e dovrà essere solo a scopo
didattico personale, non finalizzato ad altri usi.

Declino ogni mia responsabilità di utilizzo per scopi diversi da quello ditattico,
compreso malfunzionamenti e modifiche non preavvisate di questo KIT.

Il progetto nasce dall' esigenza di utilizzare un micro plc per applicazioni molto semplici
come ad esempio luci decorative, simulazioni per modellismo, apricancelli, antifurti, ecc.
ma senza spendere una fortuna.
Nella versione precedente, FACILEPLC demo, veniva presentato un micro PLC per uso
didattico dimostrativo molto semplice, per comprendere quanto avevo creato.

Se fino adesso abbiamo giocato, ora iniziamo a fare sul serio!!!!

Il progetto FACILEPLC_PRO sarà una versione vera e propria di un micro PLC quasi
professionale, con 5 ingressi optoisolati e 5 uscite a relè, un led di segnalazione RUN e un
led di segnalazione PGM, con tanto di selettore RUN/PGM. Si ha a disposizione un
connettore dedicato al collegamento con porta seriale per la programmazione diretta, senza
rimuovere il PIC ed i relativi connettori per interfacciarsi con gli input / output
galvanicamente isolati.
Il kit sarà quindi utilizzabile per piccole applicazioni, sempre ad uso personale .
Il progetto è correlato di uno schema della scheda (CPU) chiamata BOARD_FPCL_PRO,
uno schema della scheda di espansione per gli ingressi ed uscite chiamata EXP_FPLC_PRO
e dei relativi master per la realizzazione vera e propria, per testare i propri progetti.
Costi e tempi per la realizzazione del progetto PRO.
Il progetto avrà un costo maggiore rispetto la versione precedente demo, in quanto il
materiale utilizzato sarà quello base + il materiale necessario a realizzare lo stadio di input e
output galvanicamente isolato che comunque si aggira intorno ai 35-40Euro circa, a meno
che abbiate già tutto in casa.
Occorre poi contare il tempo dedicato alla realizzazione e al montaggio, che per i più bravi,
si aggira intorno alle 6-10 ore.
Evoluzioni del progetto.
La prossima relase avrà come nome FACILEPLC_PRO_EVO, dove verrà utilizzato un PIC
più grande, con molti più ingressi / uscite digitali, ingressi analogici, uscite analogiche e con
funzioni matematiche.
(Non abbiate timore, partecipate alla realizzazione, non ho bisogno di scienziati e non
c'è nulla da perdere, nè da guadagnare: www.facileplc.blogspot.com)

Nome del Progetto. FACILEPLC_PRO
Descrizione del progetto.
Scopo: Tralasciare il complicato assembler ed utilizzare un linguaggio logico molto
semplice ed intuitivo, alla portata di tutti "o quasi", semplificando così la
programmazione del PIC per utilizzi simili ai classici PLC.
(Vedi ESEMPIO1 Programmazione in FPLC a pag. 5)

Funzione: Tramite un interprete software dei comandi in linguaggio FPLC
(una sorta di AWL) , occorre per prima cosa testare la logica con un
simulatore per poi creare il relativo file in linguaggio macchina da trasferire al microprocessore (CPU) per eseguire gli stessi comandi logici programmati in modalità completamente FREE.
In sostanza questa è la procedura utilizzata dai più famosi software di programmazione per PLC, che eseguono prima di trasferire il programma vero e proprio nella CPU.
I programmi realizzati da me, funzionano anche sotto Win XP, e con l' utilizzo di un programma free, chiamato PICProg (che gestisce le API driver), si può trasferire il programma del PIC direttamente alla scheda Board_FPLC_PRO.
Materiale Necessario:
A) Un PC con porta o adattatore USB/seriale per installare il kit software
B) Sistema operativo Win98, WinME, XP.
C) Compilatore Qbasic FREE o Vbasic (Es.: QB45 Free o QB71 Free) nel caso si voglia partecipare a migliorare il software
D) Un semplice programma di editor di testi (files.TXT), per verificare la generazione corretta del sorgente in linguaggio assembler con estensione".ASM" (Es.:EDIT.EXE)
E) Un simulatore, per testare la logica di funzionamento del sorgente in FPLC (.OB1)
F) Un programma per creare il linguaggio assembler specifico al microprocessore
utilizzato con il relativo interprete per creare le funzioni logiche inserite nel programma sorgente(.OB1).
G) Un compilatore free per generare il file in linguaggio macchina (Es.: MPASM)
H) Un programmatore per microprocessori tipo JDM seriale ed il relativo software
(Es.: PPIC.EXE in versione Free per DOS o PICProg.EXE in versione free per XP)
I) 2 PCB completi dei relativi componenti dove: un circuito hardware sarà l'unità di controllo (CPU); un secondo, una espansione per gestire gli ingressi e le uscite digitali.

Realizzazione Software:
1) Il progetto prevede un simulatore FPLCSIM.EXE del linguaggio FPLC (non proprio standard) realizzato appositamente da me per testare il programma prima di compilarlo e trasferirlo sul PIC. Un compilatore FPLCPIC.EXE utilizzato per creare il programma programma relativo in assembler (da OB1 in .ASM).
2) Un compilatore MPASM.EXE versione free utilizzato per creare il programma in linguaggio macchina da trasferire al microprocessore PIC (da .ASM in .HEX) fornito dalla Microcip Corporation.
3) Un programma free per trasferire il linguaggio macchina (.HEX) alla CPU
I files sorgenti del compilatore FPLCPIC ed il relativo simulatore FPLCSIM (in Qbasic),
saranno forniti da me a chi è interessato a partecipare, a migliorare ed ampliare il progetto.

Limitazioni Firmware (legate al PIC utilizzato Es. PIC16F84A)
5 ingressi hardware
5 uscite hardware
Max 32 memorie interne
Max 8 counter con set e reset
Max 8 timer impuls con set e reset
Max 950 linee di programmazione in assembler (.ASM)

Il file scaricabile FACILEPLC_PRO.ZIP è completo di tutto l'occorrente per realizzare un prototipo.

Naturalmente il progetto è OPEN-SOURCE.

Chiunque ha un pò di tempo libero e voglia di cimentarsi in questo progetto per migliorare, tradurre in altre lingue, può liberamente partecipare, iscrivendosi semplicemente al blog http://facileplc.blogspot.com .
(PS.:Naturalmente gratuitamente).
Per chiarimenti e/o consultazioni, mi trovate a questo indirizzo Mail: cimice96@hotmail.it

NB.: Il kit è correlato di un progetto di defaul (FPLCPIC.OB1) che simula la logica di un cancello scorrevole funzionante!!!!!!!
Elenco istruzioni LS (Logica Semplice) Linguaggio FPLC utilizzabili.

Istruzione Funzione Logica Indirizzo
O OR I/U/M/C/W
ON OR-NOT I/U/M/C/W
A AND I/U/M/C/W
AN AND-NOT I/U/M/C/W
= ASSEGNA STATO RLC U/M/T/Z
=N ASSEGNA STATO RLC NEGATO U/M/T/Z
S SET imposta a 1 se RLC = 1 U/M/T/Z
R RESET imposta a 0 se RLC = 0 U/M/T/Z
I INGRESSO hardware pin PIC (max8)
U USCITA hardware pin PIC (max8)
M MEMORIA INTERNA (max32)
T TIMER INTERNO (max8)
W CONTATTO TIMER (max8)
Z COUNTER INTERNO (max8)
C CONTATTO COUNTER (max8)
# MASTER RELE (trasporto dello stato di RLC) --------
G _xxxx SALTO CONDIZIONATO (se RLC=1) (max 4 caratterri)
_xxxx ETICHETTA SALTO CONDIZIONATO (max 4 caratterri)
\ Note di informazioni listato programma --------
SET Imposta lo stato di RLC a 1 --------
CLR Imposta lo stato di RLC a 0 --------
NOT Nega lo stato di RLC (0=1 e 1=0) --------
NB.: Le funzioni logiche di comando, essendo di tipo semplice, non prevedono le parentesi come il vero AWL, ma comunque ben 32 memorie interne per realizzare circuiti e logiche più complessi.

Elenco file forniti e correlati al kit completo FACILEPLC_PRO:
FPLCPIC.EXE eseguibile compilatore per PIC
FPLCSIM.EXE eseguibile simulatore programma in FPLC
PPIC.EXE eseguibile free DOS per programmare il PIC tramite seriale 232
PICProg.EXE eseguibile free WIN per programmare il PIC tramite seriale 232
(con adattatore tipo JDM)
MPASM.EXE eseguibile free DOS per compilare il file ASM fornito da Microchip
FPLCPIC.CFG file di riferimento di default delle configurazioni I/O
FPLCPIC.REF sorgente configurazione PIC16F84A in assembler (ASM)
FPLCSEL.PRG file di riferimento selezione programma di FPLCSIM.EXE
COMPILA.BAT file batch di appoggio per compilazione automatica con MPASM
P16F84A.INC file standard di configurazione della Microcip per il PIC16F84A
SCH_BOARD.JPG schema di riferimento scheda hardware didattica
FPLCSIM.TXT file di help pag. 1 di FPLCSIM
FPLCCOM.TXT file di help pag. 2 di FPLCSIM
FPLC_ITA.PDF sorta di istruzioni con esempi di scrittura in FPLC ed utilizzo SW
INST_INFO.TXT informazioni per la corretta intallazione
\PROJ\ cartella di archivio progetti (max 100) con 1 progetto funzionante
FPLCPIC.OB1 file simulazione cancello scorrevole in linguaggio FPLC (.OB1)
FPLCPIC.ASM file simulazione cancello scorrevole in linguaggio assembler (.ASM)
FPLCPIC.HEX file simulazione cancello scorrevole in linguaggio macchina (.HEX)
FPLCPIC.CFG file di riferimento info configurazione I/O simulatore cancello scorr.
(se registrati al blog)
\FILE_SOURCE_CORRELATI cartella con file sorgenti in Qbasic e Pascal

Eccovi un esempio di programmazione nei vari linguaggi di una piccola funzione logica.
LINGUAGGIO LADDER: (standard per tutti i PLC)
i1 i2 o1
---| |-------|/|-------( )---

LINGUAGGIO AWL Siemens: (tedesco forzato)
O E0.0 ingresso 1 denominato E0.0
UN E0.1 AND NOT ingresso 2 denominato E0.1
= A0.0 assegna uscita 1 denominata A0.0

LINGUAGGIO FPLC: (in italiano)
O I0.0 dove IO.O corrisponde a Ingresso 1 (E0.0 per Siemens)
AN I0.1 AND NOT dove IO.1 corrisponde a Ingresso 2 (E0.1 per Siemens)
= U0.0 dove UO.O corrisponde a Uscita 1 (A0.0 per Siemens)

LINGUAGGIO ASSEMBLER: (standard PIC per realizzare la logica dei PLC)
bcf RLC,0 cancella lo stato logico RLC (Risultato Logico Controllato)
btfsc I0,0 verifica se ingresso 1 è = 0, se = 0 salta istruzione seguente
bsf RLC,0 assegna il valore di vero = 1 allo stato logico RLC
btfsc I0,1 verifica se ingresso 1 è = 0, se = 0 salta istruzione seguente
bcf RLC,0 assegna il valore di falso = 0 allo stato logico RLC
bcf U0.0 azzera lo stato dell' uscita 1
btfsc RLC,0 verifica se lo stato logico di RLC = 0, se = 0 salta istruzione
bsf U0,0 assegna il valore di 1 all' uscita 1

PERCHE' UTILIZZARE IL LINGUAGGIO FPLC per i PIC?
Qui di seguito, viene descritto uno dei motivi per il quale diventa necessario dover utilizzare il linguaggio FPLC di programmazione per i microprocessori dedicati ad applicazioni orientate all' automazione.
Il linguaggio LADDER può essere un buon metodo, ma non versatile come FPLC .

Premessa.
In tanto, per programmare in LADDER basta avere le basi di elettromeccanica, per comprendere il funzionamento del circuito elettrico rappresentato con la simbologia grafica appunto LADDER, mentre per comprendere il linguaggio FPLC, è necessario avere anche delle basi di elettronica.
Con questo, non voglio dire che il linguaggio FPLC è meno comprensibile, ma ben più versatile e svincolato dalla rappresentazione grafica del LADDER stesso.
Dove il linguaggio LADDER rappresenta graficamente la logica da noi pensata, il linguaggio FPLC tende a rappresentare una funzione matematica sequenziale, molto simile al linguaggio dei PLC ed alla loro logica di funzionamento.

Vediamo ora un esempio pratico.
ESEMPIO 1:
Dobbiamo far accendere e spegere un led (uscita 1) ogni secondo, ed ogni 2 lampeggi di questo, accendere e poi spegnere un altro led (uscita 2).

Sequenza:
start led1-2 off
dopo un secondo led 1 on, 2 off
dopo un secondo led 1 off, 2 off
dopo un secondo led 1 on, 2 on
dopo un secondo led 1 off, 2 on
dopo un secondo led 1 on, 2 on
dopo un secondo led 1 off, 2 on
dopo un secondo led 1 on, 2 off
goto start

E' possibile utilizzare un ingresso per per resettare i timer ed i counter che useremo.

Variabili utilizzate Funzione
Ingresso 1 I0.0 reset control
Uscita 1 U0.0 led 1
Uscita 2 U0.1 led 2
Timer 1 T0.0 conteggio 1 secondo
Timer 2 T0.1 conteggio 2 secondi
Counter 1 Z0.0 contatore configurato 2 impilsi
Counter 2 Z0.1 contatore configurato 3 impilsi (primo nullo)
G&G Progetto FACILEPLC_PRO Rev.0.1.A Pag. 6 di 10

LISTATO DEL PROGRAMMA IN FPLC.
\START PROGRAM
O W0.0
= Z0.0
ON I0.0
= T0.0
ON I0.0
= T0.1
O W0.1
O I0.0
R T0.0
#
S T0.0
1
O W0.1
O I0.0
R T0.1
#
S T0.1
2
O I0.0
O C0.1
R Z0.0
#
S Z0.0
2
O I0.0
O C0.1
R Z0.1
#
S Z0.1
3
O C0.0
A W0.0
= Z0.1
O W0.0
= U0.0
O C0.0
= U0.1
\
\
\
\
\
\
\
\
\
BE

ESAMINIAMO IL LISTATO in FPLC:
Per prima cosa occorre creare il clock del secondo.
Per semplificare la comprensione useremo 2 timer, uno che conta 1 secondo ed attiva l'uscita 1 e l'altro, 2 secondi che comanda il reset di entrambe, disattivando così luscita 1.

O W0.0 verifichiamo lo stato del timer 1, se = 1 (conteggio eseguito) porta RLC a 1 = Z0.0 se lo stato logico RLC = 1 , decrementiamo il contatore 1
ON I0.0 se non è attivo l'ingresso 1, portia lo stato logico RLC a 1
= T0.0 se lo stato logico RLC = 1 , decrementiamo il timer 1 al trascorrere de secondo
ON I0.0 se non è attivo l'ingresso 1, portia lo stato logico RLC a 1
= T0.1 se lo stato logico RLC = 1 , decrementiamo il timer 2 al trascorrere de secondo
O W0.1 verifichiamo lo stato del timer 2, se = 1 (conteggio eseguito) porta RLC a 1
O I0.0 verifichiamo lo stato dell'ingresso 1, se = 1 (conteggio eseguito) porta RLC a 1
R T0.0 se lo stato logico RLC = 1 , resetta il stato del contatto del temporizzatore 1 (W0.0)
# trasporta lo stato di RLC alla funzione seguente
S T0.0 se lo stato logico RLC = 1 , imposta il valore seguente al temporizzatore 1 (T0.0)
1 valore di set del temporizzatore 1
O W0.1 verifichiamo lo stato del timer 2, se = 1 (conteggio eseguito) porta RLC a 1
O I0.0 verifichiamo lo stato dell'ingresso 1, se = 1 (conteggio eseguito) porta RLC a 1
R T0.1 se lo stato logico RLC = 1 , resetta il stato del contatto del temporizzatore 2 (W0.1)
# trasporta lo stato di RLC alla funzione seguente
S T0.1 se lo stato logico RLC = 1 , imposta il valore seguente al temporizzatore 2 (T0.1)
2 valore di set del temporizzatore 2
Sarebbe bastato inserire un solo temporizzatore che si autoresetta, ma la visualizzazione del conteggio nel simulatore, è troppo veloce e non si sarebbe compreso correttamente il
funzionamente esatto.
Ora cerchiamo di gestire gli ipulsi generati dai due temporizzatori che farà accendere e spegnere, l'uscita 2 ogni 2 secondi.
O I0.0 verifichiamo lo stato dell'ingresso 1, se = 1 (conteggio eseguito) porta RLC a 1
O C0.1 verifichiamo lo stato del counter 2, se = 1 (conteggio eseguito) porta RLC a 1
R Z0.0 se lo stato logico RLC = 1 , resetta il stato del contatto del counter 1 (W0.0)
# trasporta lo stato di RLC alla funzione seguente
S Z0.0 se lo stato logico RLC = 1 , imposta il valore seguente al counter 1 (T0.0)
2 valore di set del counter 1
O I0.0 verifichiamo lo stato dell'ingresso 1, se = 1 (conteggio eseguito) porta RLC a 1
O C0.1 verifichiamo lo stato del counter 2, se = 1 (conteggio eseguito) porta RLC a 1
R Z0.1 se lo stato logico RLC = 1 , resetta il stato del contatto del counter 2 (W0.1)
# trasporta lo stato di RLC alla funzione seguente
S Z0.1 se lo stato logico RLC = 1 , imposta il valore seguente al counter 2 (T0.1)
3 valore di set del counter 2 (3 perchè il primo viene conteg. con il secondo di Z0.0)
O C0.0 verifichiamo lo stato del counter 1, se = 1 (conteggio eseguito) porta RLC a 1
A W0.0 verifichiamo anche lo stato del counter 1, se = 1 AND RLC = 1, lascia RLC = 1
= Z0.1 se lo stato logico RLC = 1 , decrementiamo il contatore 2
G&G Progetto FACILEPLC_PRO Rev.0.1.A Pag. 8 di 10
Ora, non ci resta che assegnare il risultato della logica eseguita.
O W0.0 verifichiamo lo stato del timer 1, se = 1 (conteggio eseguito) porta RLC a 1
= U0.0 assegnamo lo stato logico RLC all'uscita 1
O C0.0 verifichiamo lo stato del counter 1, se = 1 (conteggio eseguito) porta RLC a 1
= U0.1 assegnamo lo stato logico RLC all'uscita 2
\
\ ********************************************************************
\ programma dimostrativo di comprensione del linguaggio FPLC
\ ideato da Giuseppe & G.
\ il 20/07/2010
\ rev. 0.0
\ progetto FACILEPLC_PRO
\ ********************************************************************
\
BE fine del programma

DIAMO UNO SGUARDO AL PROGRAMMA IN ASSEMBLER PER REALIZZARE LA STESSA LOGICA MA CON IL RAGIONAMENTO EFFETTUATO DAL microPLC e dalla CPU PIC16F84:

NB.: Tralasciamo la parte di configurazione del PIC e conteggio tempo ed entriamo subito nel dettaglio. (circa 100 istruzioni in assembler, uguali per tutti i PIC)

CICLO:
CLRF RLC ;*** INIZIO ***
;\START PROGRAM
BTFSC CT,0
BSF RLC,0
BTFSC CZ,0
GOTO FINEZ0
BTFSS RLC,0
BCF ZM,0
BTFSS RLC,0
GOTO FINEZ0
BTFSC ZM,0
GOTO FINEZ0
BSF ZM,0
BSF CZ,0
DECFSZ Z0
BCF CZ,0
FINEZ0:
BCF RLC,0 ; *** STR ***
BTFSS I,0
BSF RLC,0
BTFSS SEC,0
GOTO FINET0
BTFSC CT,0
GOTO FINET0
BTFSS RLC,0
GOTO FINET0
BSF CT,0
DECFSZ T0
BCF CT,0
FINET0:
G&G Progetto FACILEPLC_PRO Rev.0.1.A Pag. 9 di 10
BCF RLC,0 ; *** STR ***
BTFSS I,0
BSF RLC,0
BTFSS SEC,0
GOTO FINET1
BTFSC CT,1
GOTO FINET1
BTFSS RLC,0
GOTO FINET1
BSF CT,1
DECFSZ T1
BCF CT,1
FINET1:
BCF RLC,0 ; *** STR ***
BTFSC CT,1
BSF RLC,0
BTFSC I,0
BSF RLC,0
BTFSC RLC,0
BCF CT,0
;*** # ***
MOVLW 1
BTFSC RLC,0
MOVWF T0
BCF RLC,0 ; *** STR ***
BTFSC CT,1
BSF RLC,0
BTFSC I,0
BSF RLC,0
BTFSC RLC,0
BCF CT,1
;*** # ***
MOVLW 2
BTFSC RLC,0
MOVWF T1
BCF RLC,0 ; *** STR ***
BTFSC I,0
BSF RLC,0
BTFSC CZ,1
BSF RLC,0
BTFSC RLC,0
BCF CZ,0
;*** # ***
MOVLW 2
BTFSC RLC,0
MOVWF Z0
BCF RLC,0 ; *** STR ***
BTFSC I,0
BSF RLC,0
BTFSC CZ,1
BSF RLC,0
BTFSC RLC,0
BCF CZ,1
G&G Progetto FACILEPLC_PRO Rev.0.1.A Pag. 10 di 10
;*** # ***
MOVLW 3
BTFSC RLC,0
MOVWF Z1
BCF RLC,0 ; *** STR ***
BTFSC CZ,0
BSF RLC,0
BTFSS CT,0
BCF RLC,0
BTFSC CZ,1
GOTO FINEZ1
BTFSS RLC,0
BCF ZM,1
BTFSS RLC,0
GOTO FINEZ1
BTFSC ZM,1
GOTO FINEZ1
BSF ZM,1
BSF CZ,1
DECFSZ Z1
BCF CZ,1
FINEZ1:
BCF RLC,0 ; *** STR ***
BTFSC CT,0
BSF RLC,0
BCF O,0
BTFSC RLC,0
BSF O,0
BCF RLC,0 ; *** STR ***
BTFSC CZ,0
BSF RLC,0
BCF O,1
BTFSC RLC,0
BSF O,1
;\
;\ ********************************************************************
;\ programma dimostrativo di comprensione del linguaggio FPLC
;\ ideato da Giuseppe & G.
;\ il 20/07/2010
;\ rev. 0.0
;\ progetto FACILEPLC_PRO
;\ ********************************************************************
;\
RETURN
END

COMMENTI FINALI:
Giusto qualche istruzione in più rispetto al linguaggio FPLC inserito a pagina 2 ed esattamente in questo caso, i 2/3 in più delle singole istruzioni (circa il 60%).
Di sicuro si potrebbe semplificare e ridurre le istruzioni in assembler, ma senza utilizzare una logica sequenziale, quale quella dei PLC e comunque non in così poche istruzioni come il linguaggio FPLC (38 in FPLC = 113 in Assembler).

Giuseppe & G.