I PLC sono microcontrollori e come tali non utilizzano thread.
Il ciclo viene gestito in pratica con una programmazione asincrona,
semplicemente ripetuto in maniera banale:1) Controllo tutti gli ingressi2)
Eseguo le operazioni di elaborazione (AND OR e controllo delle
temporizzazioni)4) Attivo le uscite interessate
Per gestire le temporizzazioni in maniera semplice basta fare un confronto con
il tempo, ad esempio nel seguente codice eseguo operazioni variea due
intervalli di tempo prestabiliti:
mio_intervallo_1 = 1 # 1 secondomio_intervallo_2 = 1 # 0.5 second1
orario_partenza_evento_1 = time.time()orario_partenza_evento_2 = time.time()
while(True) if (time.time() - orario_partenza_evento_1 > mio_intervallo_1):
eseguo_quello_che_voglio_1()
orario_partenza_evento_1 = time.time() if (time.time() -
orario_partenza_evento_2 > mio_intervallo_2):
eseguo_quello_che_voglio_2() orario_partenza_evento_2 = time.time()
Tutti i vari controlli
Chiaramente più la complessità del programma cresce, più tempo ci vorrà tra una
scansione e l'altra, se tu vuoi effettuare esattamente N controlli al secondo
puoi introdurre uno sleep alla fine di ogni ciclo e rallentare l'esecuzione del
programma.
Per completezza c'è da dire che esistono anche gli interrupt, ma in questo caso
non ne vedo la necessità.
Piergiorgio Pancino
Il Giovedì 29 Dicembre 2016 19:29, Attilio Menegon
<attilio.mene...@tecnoemmesnc.it> ha scritto:
<!--#yiv7258571022 _filtered #yiv7258571022 {font-family:"Cambria
Math";panose-1:2 4 5 3 5 4 6 3 2 4;} _filtered #yiv7258571022
{font-family:Calibri;panose-1:2 15 5 2 2 2 4 3 2 4;} _filtered #yiv7258571022
{font-family:Tahoma;panose-1:2 11 6 4 3 5 4 4 2 4;}#yiv7258571022
#yiv7258571022 p.yiv7258571022MsoNormal, #yiv7258571022
li.yiv7258571022MsoNormal, #yiv7258571022 div.yiv7258571022MsoNormal
{margin:0cm;margin-bottom:.0001pt;font-size:11.0pt;font-family:"Calibri",
"sans-serif";}#yiv7258571022 a:link, #yiv7258571022
span.yiv7258571022MsoHyperlink
{color:blue;text-decoration:underline;}#yiv7258571022 a:visited, #yiv7258571022
span.yiv7258571022MsoHyperlinkFollowed
{color:purple;text-decoration:underline;}#yiv7258571022
p.yiv7258571022MsoAcetate, #yiv7258571022 li.yiv7258571022MsoAcetate,
#yiv7258571022 div.yiv7258571022MsoAcetate
{margin:0cm;margin-bottom:.0001pt;font-size:8.0pt;font-family:"Tahoma",
"sans-serif";}#yiv7258571022
span.yiv7258571022StileMessaggioDiPostaElettronica17 {font-family:"Calibri",
"sans-serif";color:windowtext;}#yiv7258571022
span.yiv7258571022TestofumettoCarattere {font-family:"Tahoma",
"sans-serif";}#yiv7258571022 .yiv7258571022MsoChpDefault {} _filtered
#yiv7258571022 {margin:70.85pt 2.0cm 2.0cm 2.0cm;}#yiv7258571022
div.yiv7258571022WordSection1 {}-->Buonasera a tutti,Chiedo un chiarimento su
un concetto che mi sembra sfuggire.Volendo realizzare un programma in python
che legga e scriva degli I/O tipo quelli del GPIO del Raspberry, volendo
implementare delle logiche tipo PLC, mi chiedo come si gestiscano le
temporizzazioni ed altre situazioni simili.Mi spiego meglio: il programma nel
PLC cicla più volte al secondo dalle 10 alle 100 volte e nel esecuzione porta
avanti il controllo di eventuali eventi temporizzati che avvengono in processi
paralleli. L’esempio sono più funzioni / sottoprogrammi di tipo luci scale
temporizzate che vengono inizializzati da uno o più ingressi (che vanno alti) e
devono essere gestite in modo parallelo ed indipendente ed ogni istanza di
funzione processa il suo temporizzatore in modo indipendente mentre il
programma principale continua a girare in autonomia e quando la temporizzazione
termina il sottoprogramma passa il risultato al programma principale che di
conseguenza aggiorna lo stato delle uscite. In questo caso, io come
programmatore mi devo solo incaricare di impostare in sequenza le istruzioni o
lo schema a contatti, poi il compilatore fa tutto da solo e mi restituisce
l’eseguibile da scaricare nel PLC.Vorrei comprendere come implementare in modo
corretto tali esecuzioni parallele in un programma Python che giri su
PC.Attualmente ho visto solo dei piccoli esempi in cui la temporizzazione viene
fata con la funzione sleep che blocca l’esecuzione del programma per il tempo
richiesto e poi il programma riprende e cicla su se stesso, in questo modo non
si possono però eseguire più temporizzazioni contemporaneamente. Viceversa
penso sia corretto lanciare dei programmi paralleli ogni volta che viene
istanziato una temporizzazione e che questi eseguano in modo indipendente la
temporizzazione con la funzione SLEEP() e al suo termine restituiscano il
risultato aggiornando una variabile del programma principale che continua nel
frattempo a girare ad esempio al l’interno di un ciclo WHILE infinito.Quindi
chiedo delle dritte su come instanziare questi sottoprogrammi, recuperarne il
risultato e farsi restituire il programma. Ringrazio fin da ora per la
collaborazione Attilio Menegon
_______________________________________________
Python mailing list
Python@lists.python.it
http://lists.python.it/mailman/listinfo/python
_______________________________________________
Python mailing list
Python@lists.python.it
http://lists.python.it/mailman/listinfo/python
