Ciao forum,
scusate se non sono un assiduo frequentatore

Dunque, la storia:
Ho un SBC, ho installato home assistant, python 3.7 con Archlinuxarm , dopo qualche sudata per riuscirci, il sistema va. Il problema è di aggiungere un nuovo modulo che mi faccia vedere l' hardware che comanda le uscite dei GPIO, per poi pilotare dei carichi.
Hass funziona discretamente se l' SBC è un Raspberry PI, ma per il tinker non c'è il modulo.
Il problema:
Rifatto il modulo imitando quello di RPi, non funziona perché l'accesso ai GPIO è una faccenda delicata che deve accedere a /dev/kmem /dev/mem e /dev/gpiomem (quindi storie da linux). L'ultimo non esiste neppure.
Il fatto è che si può attuare coi GPIO solo da amministratore, ovvero privilegi da root. Ora ho trovato anche un modulo carino che fa quello che sta facendo il wiringPI in c++. Il problema è sempre coi permessi.

Allora ho cominciato a pensare un modulo avviato da root da interfacciare al resto che serve a home assistant (ovvero quello che sto modificando).
Avrei pensato di usare il metodo con multiprocessing.connection, del quale uno sarebbe avviato con i privilegi da amministratore e il resto lo mando dal client sulle operazioni da eseguire.

Ho il problema che il server deve rispondere a qualche verifica dall'hardware, questo dice che devo avere la comunicazione in entrambe i sensi.
Questo snippet non funziona:

#!/usr/bin/env python

from multiprocessing.connection import Listener, Client
PASSWORD = b'secret password'

def comm(conn):
    ''' Little test with a connection. '''
    msg= conn.recv()
    if msg.startswith('!') and 'stop' in msg.lower():
        return
    if msg:
        print(msg)
    conn.close()
    return 'end'

def main(args):
    address1 = ('localhost', int(args0))
    address2 = ('localhost', int(args1))
    listener = Listener(address1, authkey=PASSWORD)
    print('connection accepted from', listener.last_accepted)
    while True:
        try:
            conn = Client(address2, authkey=PASSWORD)
            if comm(conn) == 'end':
                return
        except (ConnectionRefusedError, OSError):
            pass
        except (KeyboardInterrupt, EOFError):
            return
        msg= input('"!stop" will exit > ')
        if msg.startswith('!') and 'stop' in msg.lower():
            break
        server = listener.accept()
        server.send(msg)

    conn.close()
    listener.close()

if __name__ == '__main__':
    import sys
    args = sys.argv[1:]
    sys.exit(main(args))

In teoria dovrei passare i parametri delle porte in modo incrociato e uno scrive sulla sua porta. Mentre è chiaro che manca qualcosa per far stare il server in attesa anche se ancora il client non è ancora attivo.
Ho cercato anche altri metodi, del tipo pipes o iscriversi al dbus e non vorrei andare nei meandri di pacchetti che non son parte di python 3.7. Per esempio ho visto che rpyc fa un bel lavoro, ma trovo che potrebbe diventare un bel peso per un arm7l.

Poi ci sono altri metodi semplici che permettono di dialogare di due programmi, meglio se quello coi privilegi alti stesse in attesa come un demone in un service. Del resto dovrebbe avere una latenza piccola, per non avere effetti dilungati per attivare o spegnere delle luci, per esempio..

Quindi, quali suggerimenti per la comunicazione tra due processi, del tipo tcp, pipe, daemon o dbus...



--- Ultima modifica di F _ in data 2019-07-14 06:38:22 ---

--- Ultima modifica di F _ in data 2019-07-14 06:40:54 ---

Direi da cominciare a studiare le funzioni di python.
Fai una ricerca da qui, con i nomi che ha suggerito pypy

Troppo diversivo, eh ?

In dual boot, si ha l' opzione di poter fare con entrambe i SO. Poi il Mac, mi sembra non esageratamente diffuso.

Perché non installare Linux sul Mac?
Magari in dual boot.

Scrivi un esempio, magari si capisce meglio

Allora è tkinter. Che non ho citato.

Subprocess, potrà servire per killare l'applicativo in esecuzione. Ma di windows non ne so.

Se metti il percorso intero sei sicuro che lo apre in quella posizione

f = open('/tmp/miofile.txt', 'w')

Stai sicuro che lo troverai in /tmp

Sono da classificare come frana paleolitica , la mia memoria perde colpi. Perché infatti la ricerca viene da Stackoverflow.
Nella quale pagina c'è anche il metodo oneliner con la lambda.
Siccome, non fatto tanto ragionamento sulle finezze di python, ho preso una che mi sembrava più comprensibile al momento della scelta. Lo scopo era di trovare una soluzione in pochi minuti a scapito di altre condizioni di miglioramento.


Ora andando a vedere la finezza nell'usare un loop, si può persino ridurre il ciclo di ricerche in una lista ordinata, dividendo la lista per ogni ciclo dal lato che il valore è minore. Alla apparenza sembra di minor lavoro, ma se contiamo che un sort() fa il suo bel loop comunque. Tutto sommato ci sarà sempre un certo quantitativo di loop per aver la risposta, da script o dai builtin di python.


Per finire, la funzione creata si orienta ad un valore che si avvicina la parametro richiesto,

che comunque potrebbe essere anche zero . Infatti zero è la necessità del programma per ottenere il valore più vicino al quello dato dalla CLI. In pratica diff sarebbe abs(i) senza la sottrazione da n.

Se non mi sbaglio, hai scritto qualcosa anche per micro controllori.....

Lo scopo del programma se si riesce a capirlo, serve a determinare quale saranno i due parametri che servono al microcontrollore per impostare il voluto baud rate. la formula della immagine, mi determina un metodo per il divisore a 64, ma c'è anche l' opzione per il divisore a 16, che richiede di impostare il prescaler in modo diverso.

Allora il programma ha due passaggi, quello che determina la deriva, dovuta al fatto che si può usare solo numeri interi e la scelta del tipo di divisore da impostare al prescaler. Infatti c'è l'opzione che con un divisore si possa avvicinarsi meglio al baud rate scelto.


Non so se esiste una computazione diversa per trovare la risposta. Io ho preso questo percorso. Che poi ho aggiunto i 5 tentativi per capire quale possa avvicinarsi meglio.
Rientrando nel discorso del sorgente, il risultato non ritorna corretto, tenendo conto che i numeri negativi non sono più vicini allo zero. Forse è la scelta dell'indice nel dizionario, perché l'indice della lista è corretto. Solo che non mi serve il valore dell'indice della lista o il suo contenuto, ma il risultato del parametro che si abbina nel dizionario.


Esempio di inserire il valore di 20 MHz e il baudrate a 38400, il valore ottimale sarebbe 32:

$ python baudratecalc.py 20 38400
Low baudrate list
35.63%  5       0
16.26%  6       1
1.73%   7       2
-9.58%  8       3
-18.62% 9       4
High baudrate list
8.51%   29      5
5.01%   30      6
1.73%   31      7
-1.36%  32      8
-4.26%  33      9
0.013573232323232294
Preferred 31

Provo a vedere se con enumerate() riesco a sincronizzare l'indice del dizionario con il valore percent, oppure se devo fare un costrutto con uno zip().




--- Ultima modifica di F _ in data 2019-01-09 14:25:38 ---

Non credo che trovi una risposta mirata senza dire che framework stai usando per fare l' interfaccia grafica.
È wxpython, pyqt, pyside, pygtk ?