Discussion :

[sluke]

Bonjour à tous,

Je bricole pas mal avec Arduino en ce moment pour de la domotique.

J'ai d'un côté un Arduino que je peux commander via une liaison série avec pyserial. Le fonctionnement est de type transactionnel, une requête renvoie une réponse.

De l'autre, une application Django pour la partie Front. Chaque Model correspond à un objet côté Arduino. Je capte donc le signal pre-save sur tous les Models mappés côté Arduino pour envoyer un message sur le port série. La réponse Arduino reçue valide ou non l'appel à .save().

Le problème est que je dois gérer l'accès exclusif du port série car je peux potentiellement avec de la concurrence via la partie front.

Quelle est la bonne façon de faire de ce genre de cas ? (tout en me laissant l'opportunité de créer des "Management Commands" utilisant l'accès au port série).

D'avance merci pour votre aide.

[wiztricks]

Salut,

Quelle est la bonne façon de faire de ce genre de cas ? (tout en me laissant l'opportunité de créer des "Management Commands" utilisant l'accès au port série).

Mettre le port série sous le contrôle d'un "serveur" qui sérialisera les commandes/réponses à passer au port (et qui éventuellement mémorisera le retour de certaines requêtes un certain temps).
L'application Django se contente de discuter avec le "serveur".

- W

[sluke]

Merci wiztricks,

J'ai suivi ton conseil, ça fonctionne très bien. Voici le code pour ceux que ça intéresserait.

le serveur :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
from datetime import datetime
import socket
import sys
import threading
 
import serial
 
HOST = 'localhost'
PORT = 2000
 
class SerialServer:
 
    def __init__(self, device, baudrate=115200, timeout=0.11, eol="\r\n", encoding="utf-8"):
        self.device = device
        self.baudrate = baudrate
        self.timeout = timeout
        self.eol = eol
        self.encoding = encoding
        self.lock = threading.Lock()
        self.connected = False
 
    def connect(self):
        if self.connected:
            return
 
        self.lock.acquire()
        self.serial = serial.Serial(self.device, self.baudrate, timeout=self.timeout)
        self.connected = True
        self.lock.release()
 
    def disconnect(self):
        if not self.connect:
            return
 
        self.lock.acquire()
        self.serial.close()
        self.connected = False
        self.lock.release()
 
    def send(self, msg):
        if not self.connected:
            self.connect()
        msg += self.eol
 
        self.lock.acquire()
        self.serial.write(msg.encode())
        response = self.serial.readline().decode(self.encoding).strip(self.eol)
        self.lock.release()
 
        return response
 
 
class ThreadClient(threading.Thread):
 
    def __init__(self, conn, serial_server):
        threading.Thread.__init__(self)
        self.conn = conn
        self.serial_server = serial_server
 
    def run(self):
        ip, port = self.conn.getsockname()
        with self.conn:
            with self.conn.makefile('r') as f_in:
                request = f_in.readline().strip('\n')
                print(f"{datetime.now()} RECEIVED FROM {ip}:{port} : {request}")
 
            response = self.serial_server.send(request)
 
            with self.conn.makefile('w') as f_out:
                f_out.write(f"{response}\n")
                f_out.flush()
            print(f"{datetime.now()} SENDED TO {ip}:{port} : {response}")
 
 
 
serial_server = SerialServer("/dev/ttyACM0")
 
with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
    try:
        s.bind((HOST, PORT))
    except socket.error as e:
        print(e)
        sys.exit()
 
    s.listen()
 
    try:
        while True:
            conn, addr = s.accept()
            th = ThreadClient(conn, serial_server)
            th.start()
    except KeyboardInterrupt:
        serial_server.close()
        sys.exit()

le client :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
from datetime import datetime
import socket
import sys
 
 
def send_to_arduino(host, port, message):
    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
        s.connect((host, port))
        with s.makefile('w') as f_out:
            print(f"{datetime.now()} REQUEST TO {host}:{port} : {message}")
            f_out.write(f"{message}\n")
            f_out.flush()
 
        with s.makefile('r') as f_in:
            response = f_in.readline().strip('\n')
            print(f"{datetime.now()} RESPONSE FROM {host}:{port} : {response}")
 
 
send_to_arduino("localhost", 2000, "/api?model=ArduinoSensorDHT&id=1")

A+