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 ---