[Python] Logica PLC

Ven 30 Dic 2016 15:40:21 CET

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.menegon a tecnoemmesnc.it> ha scritto:

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 a lists.python.it
http://lists.python.it/mailman/listinfo/python

-------------- parte successiva --------------
Un allegato HTML è stato rimosso...
URL: <http://lists.python.it/pipermail/python/attachments/20161230/92921835/attachment.html>