fourniture TP1

TP1/acquisition.py

+import numpy as np
+import time
+# Une liste de mesures. Chaque imesure est un couple
+# (nom, temps d'acquisition en secondes, n valeurs).
+MESURES = [
+    ("U", 5,4),
+    ("I", 5,4),
+    ("PA", 6,4),
+    ("PR", 6,4),
+]
+
+
+def getMesure(m,t,n):
+    sigma = 0.1
+    if m=='U':
+        mu = 5
+    elif m=='I':
+        mu = 1
+    elif m=='PA':
+        mu = 2
+    elif m=='PR':
+        mu = 3
+    time.sleep(t)
+    valeurs = np.random.normal(mu, sigma, n)
+    return valeurs
\ No newline at end of file

TP1/clientRPC.py

+import rpyc
+
+conn = rpyc.connect("localhost",18861)
+print(conn.root.f(2,4))
\ No newline at end of file

TP1/esclave.py

+import time
+import rpyc
+import numpy as np
+from acquisition import *
+
+def create_connection():
+    return rpyc.connect("localhost", 18861)
+
+
+def calcul_moyenne(id_, mesure, t, n):
+    print("Moyenne de {} est en préparation ({t}s)")
+    valeurs = getMesure(mesure,t,n)
+    moyenne = np.mean(valeurs)
+    return "Moyenne de {} est {:.2f}".format(mesure,moyenne)
+
+
+def send_result(conn, task, result):
+    # A compléter
+
+
+def ask_task(conn):
+    #A compléter
+
+
+def run(conn):
+    # `task` est un tuplet `(mesure, temps de préparation, nombre de valeurs)`.
+    task = ask_task(conn)
+
+    while task:
+        id_, mesure, t,n  = task
+
+        print("{} à calculer reçue {}".format(mesure,id_))
+        prepared_moyenne = calcul_moyenne(id_, mesure, t,n)
+
+        print(f"Moyenne de {} prête envoyée {}".format(mesure,id_))
+        send_result(conn, task, prepared_moyenne)
+
+        task = ask_task(conn)
+
+
+if __name__ == "__main__":
+    run(create_connection())

TP1/maitre.py

+from threading import Lock
+from rpyc.utils.server import ThreadedServer
+import rpyc
+import time
+from acquisition import MESUTRES
+tasks_to_do = [(i, *MESURES) for i, mesure in enumerate(MESURES)]
+tasks_being_done = []
+lock = Lock() # Pour protéger les listes de tâches
+start_time = None
+
+class MasterService(rpyc.Service):
+    def exposed_give_task(self):
+        global start_time
+        #A compléter
+
+        return task
+    def exposed_receive_result(self,task,result):
+        print(f"{result} reçue")
+        #A compléter
+
+
+def start():
+    server = ThreadedServer(MasterService, port=18861)
+    server.start()
+
+if __name__ == "__main__":
+    start()

TP1/seq.py

+import time
+from random import shuffle
+from acquisition import *
+import numpy as np
+
+def moyennes_mesures(mesures):
+    moyennes = {}
+    for mesure,t,n in mesures:
+        print("Collecte de {} valeurs de {} toutes les ({}s)...".format(n,mesure,t))
+        valeurs = getMesure(mesure,t,n)
+        moyenne = np.mean(valeurs)
+        print("Moyenne de {} est {:.2f}".format(mesure,moyenne))
+
+
+if __name__ == "__main__":
+    shuffle(MESURES)
+    print(MESURES)
+    start_time = time.time()
+    moyennes_mesures(MESURES)
+    end_time = time.time()
+    print("Temps de calcul: {:.1f}s".format(end_time - start_time))

TP1/serveurRPC.py

+import rpyc
+from rpyc.utils.server import ThreadedServer
+
+
+class MyService(rpyc.Service):
+    def exposed_f(self,x,y):
+        return x+y
+    def g(self):
+        return 43
+def start():
+    t = ThreadedServer(MyService, port=18861)
+    t.start()
+
+if __name__ == "__main__":
+    start()