Ciao Daniele e grazie sempre e comunque per il supporto. Ovviamente l'ultimo codice postato era di esempio...ho provato con il simbolo che mi hai consigliato, ma non mi cambia nulla (forse è il browser).

Allora, le 5 *.py che gestiscono altrettanti processi le ho testate con altrettante shell linux facendole partire singolarmente.

Questa sorta di "parallelizzazione cavernicola" ha comportato un utilizzo della cpu del 30% circa. E' stata monitorata con "Gestore Processi" di Raspbian (Debian) che è molto simile a "gestione attività" di windows.

Come ti dicevo, aldilà dell'aspetto puramente esperienziale, anche in un solo file il codice porterebbe agli stessi problemi.

Tutte le py, di per se, effettuano un lavoro continuo (log, streaming video, ecc) o attendono (ad esempio chiamate Voip).

Quindi la chiamata a una di queste funzioni bloccherebbe tutto il resto. Facevo l'esempio dell'avvio della connessione, che logga all'infinito fino al termine della connessione stessa.


In breve, dopo un'ulteriore giornata di tentativi anche con l'esempio di codice banale e non significativo di cui sopra, sono ancora stuccato al punto di partenza...


--- Ultima modifica di DarthUFO in data 2017-01-24 16:53:46 ---

In breve avrei bisogno di far funzionare funzioni "in parallelo" in in modo non bloccante.
Ad esempio, riducendo banalmente al caso di due funzioni che stampano il numero di ciclo in parallelo:


from threading import Thread
#import multiprocessing
import time


def ciclo_primo():
i=0
while i<100:
print("Ciclo Primo n ", i)
i += 1
time.sleep(1)


def ciclo_secondo():
i=0
while i<100:
print("Ciclo Secondo n ", i)
i += 1
time.sleep(1)


thread1 = Thread(target=ciclo_primo())
thread2 = Thread(target=ciclo_secondo())

try:
thread1.start()
thread2.start()
#thread1.join()
#thread2.join()

except(KeyboardInterrupt, SystemExit): #si esce quando viene premuto ctrl-c
print("Richiesta chiusura del programma")


Mi sarei aspettato che in parallelo (o quasi) venissero stampati messaggi del tipo:

('Ciclo Primo n ', 0)
('Ciclo Secondo n ', 0)

('Ciclo Primo n ', 1)
('Ciclo Secondo n ', 1)
...
('Ciclo Primo n ', 99)
('Ciclo Secondo n ', 99)


e via dicendo. Invece vengono stampati solo i messaggi relativi alla prima funzione fino alla conclusione del suo ciclo. Solo dopo vengono stampati quelli relativi alla seconda funzione/ciclo.
Cosa sto sbagliando?


--- Ultima modifica di DarthUFO in data 2017-01-24 15:34:43 ---

Ciao Daniele,
grazie mille per i link.

Ho provato a leggere tutto, in particolare il primo link che ben prometteva, ma ahimè il mio livello da principiante rende tutto tremendamente più lento.
E anche San Google finora non mi ha aiutato granchè (forse per lo stesso motivo).

Nel timore di non essermi spiegato del tutto, quindi, giù ogni freno inibitore e cercherò di esplicitare meglio le mie necessità.

- Si tratta del "solito" Raspberry 3 che deve pilotare e gestire più dispositivi e relativi processi contemporaneamente.
- Questi dispositivi/processi non scambiano (al momento) dati tra loro.
- Le singole classi di ciascun dispositivo le ho già implementate e sembrano singolarmente funzionanti.
- facendo partire i singoli file *.py tutti in parallelo tutto sembra funzionare a dovere, la CPU ha un carico di circa il 30-40%.

L'unica cosa che questi dispositivi debbono "condividere" sono le fasi: inizializzazione, funzionamento a regime e chiusura. Per questo vorrei gestirli tutti tramite un solo file *.py "main" (passatemi la volgarità da non programmatore).

In comune hanno inoltre la connessione internet (spediscono dati verso un server) ottenuta tramite dongle 3G.

E per fare un esempio della necessità/problematica di avviarli in parallelo, ecco il primo intoppo.
La connessione sfrutta Wvdial, che è un dialer per PPP gestibile da riga di comando.
Per avviare la connessione, da Python richiamo tramite il modulo os il seguente comando:

import os
os.system('sudo wvdial 3gconnect').

A questo punto parte il log di wvdial.
Parte e continua fino alla chiusura della connessione o al kill di wvdial, bloccando di fatto tutte le istruzioni successive...

Se questo e altri processi di attesa e acquisizione funzionassero in maniera indipendente, ovviamente ciò non accadrebbe, e ciascuna acquisizione/log/monitoring avverrebbe in modo autonomo e verrebbe chiuso nella fase finale... Eventualmente "creperebbe" anche in modo autonomo non bloccando gli altri processi in corso.

Insomma, per questo tipo di attività che conviene fare?
Gestire più processi/thread o sono costretto a lanciare beceramente, grottescamente, pecorecciamente più *.py in parallelo?
Grazie e scusate la probabile banalità delle mie domande


--- Ultima modifica di DarthUFO in data 2017-01-23 23:52:32 ---

Salve a tutti,
sto scrivendo un programma che inizializza e/o utilizza diverse periferiche e quindi diversi processi tra loro indipendenti. In particolare:

- Inizializza un modulo seriale

- Inizializza e monitora la connessione da un dongle 3g (processo con "monitoring" continuo)

- Inizializza e acquisisce un ricevitore GPS (processo con acquisizione continua)

- Inizializza e attende o effettua chiamate VOIP.

Ogni periferica/processo utilizza una classe differente e metodi di inizializzazione, uso e chiusura dedicati.

E' chiaro che, trattandosi gli ultimi 3 di processi di attesa completamente eterogenei e provenienti da periferiche diverse, mettermi in attesa su uno significherebbe non far partire mai gli altri.

Ora, ho letto qualcosa sulle classi Threading e Multiprocessing.

Potrebbero fare al caso mio?O comunque, avete suggerimenti in merito?

Grazie infinite!


--- Ultima modifica di DarthUFO in data 2017-01-23 15:25:58 ---