diff --git a/Processus/exJoinAliveEtc.py b/Processus/exJoinAliveEtc.py
new file mode 100644
index 0000000000000000000000000000000000000000..a228b05376f74f5e4426a8e7d96378b0de348a3d
--- /dev/null
+++ b/Processus/exJoinAliveEtc.py
@@ -0,0 +1,42 @@
+import threading
+# inspire de http://www.xavierdupre.fr/app/teachpyx/helpsphinx/c_parallelisation/thread.html#premier-thread
+class MyThread1(threading.Thread):
+
+ def __init__(self):
+ threading.Thread.__init__(self) # ne pas oublier cette ligne
+ # (appel au constructeur de la classe mère)
+ self.nom="A" # self.name exite deja
+
+ def run(self):
+ print('debut ',self.nom)
+
+ print ('milieu ',self.nom)
+
+ print ('fin ',self.nom)
+
+class MyThread2(threading.Thread):
+
+ def __init__(self):
+ threading.Thread.__init__(self) # ne pas oublier cette ligne
+ # (appel au constructeur de la classe mère)
+ self.nom="B" # self.name exite deja
+
+ def run(self):
+ print('debut ',self.nom)
+
+ print ('milieu ',self.nom)
+
+ print ('fin ',self.nom)
+
+
+
+def test():
+ a = MyThread1()
+ b=MyThread2()
+ print(a.is_alive())
+ a.start()
+ print("2",a.is_alive())
+ b.start()
+ a.join()
+ b.join()
+ print(a.is_alive())
\ No newline at end of file
diff --git a/Processus/exclumutPb.py b/Processus/exclumutPb.py
new file mode 100644
index 0000000000000000000000000000000000000000..2cac23e2fd506d688081fb9e0af7dde7d38c5752
--- /dev/null
+++ b/Processus/exclumutPb.py
@@ -0,0 +1,36 @@
+import threading
+
+class Sdpartagee():
+ def __init__(self,taille):
+ self.ouEstCe=0
+ self.data=[0]*taille
+
+class Producteur(threading.Thread):
+ def __init__(self,nom,tablo,nbLecture):
+ # ne pas oublier cette ligne
+ # (appel au constructeur de la classe mère)
+ threading.Thread.__init__(self)
+ self.nom=nom # self.name exite deja
+ self.SD=tablo
+ self.nbLecture=nbLecture
+ def run(self):
+ print('debut ',self.nom)
+ for i in range(self.nbLecture):
+ ou=self.SD.ouEstCe
+ self.SD.data[ou]=self.nom
+ ou+=1
+ self.SD.ouEstCe=ou
+ print('fin',self.nom)
+
+
+nbP=5
+nbL=1000000
+sd=Sdpartagee(nbP*nbL)
+stat = dict()
+stat[0]=0
+for i in range(nbP):
+ Producteur("Nom"+str(i),sd,nbL).start()
+ stat["Nom"+str(i)]=0 # init° des stat
+
+for i in range(nbP*nbL):
+ stat[sd.data[i]]+=1
\ No newline at end of file
diff --git a/Processus/exclumutPbSemaphore.py b/Processus/exclumutPbSemaphore.py
new file mode 100644
index 0000000000000000000000000000000000000000..e4a43fe1aae564e5eb5a6168390e9e8a3a1e9e8e
--- /dev/null
+++ b/Processus/exclumutPbSemaphore.py
@@ -0,0 +1,40 @@
+import threading
+
+class Sdpartagee():
+ def __init__(self,taille):
+ self.ouEstCe=0
+ self.data=[0]*taille
+
+class Producteur(threading.Thread):
+ def __init__(self,nom,tablo,nbLecture,mutex):
+ # ne pas oublier cette ligne
+ # (appel au constructeur de la classe mère)
+ threading.Thread.__init__(self)
+ self.nom=nom # self.name exite deja
+ self.SD=tablo
+ self.nbLecture=nbLecture
+ self.mutex=mutex
+ def run(self):
+ print('debut ',self.nom)
+ for i in range(self.nbLecture):
+ self.mutex.acquire()
+ ou=self.SD.ouEstCe
+ self.SD.data[ou]=self.nom
+ ou+=1
+ self.SD.ouEstCe=ou
+ self.mutex.release()
+ print('fin',self.nom)
+
+
+nbP=5
+nbL=1000000
+mutex= threading.Semaphore(1)
+sd=Sdpartagee(nbP*nbL)
+stat = dict()
+stat[0]=0
+for i in range(nbP):
+ Producteur("Nom"+str(i),sd,nbL,mutex).start()
+ stat["Nom"+str(i)]=0 # init° des stat
+
+for i in range(nbP*nbL):
+ stat[sd.data[i]]+=1
\ No newline at end of file
diff --git a/Processus/lancement.py b/Processus/lancement.py
new file mode 100644
index 0000000000000000000000000000000000000000..55cd137747a597f695dd668ed3c63bb30d3110f5
--- /dev/null
+++ b/Processus/lancement.py
@@ -0,0 +1,38 @@
+# inspire de http://www.xavierdupre.fr/app/teachpyx/helpsphinx/c_parallelisation/thread.html#premier-thread
+
+import threading
+
+class MyThread1(threading.Thread):
+ def __init__(self):
+ threading.Thread.__init__(self) # ne pas oublier cette ligne (appel au constructeur de la classe mère)
+ self.nom="A" # self.name exite deja
+ def run(self):
+ print('debut ',self.nom)
+ print ('milieu ',self.nom)
+ print ('fin ',self.nom)
+
+def test1():
+ a = MyThread1()
+ print("test1 avant start")
+ a.start()
+ print("test1 apres start")
+
+class MyThread2(threading.Thread):
+
+ def __init__(self):
+ threading.Thread.__init__(self) # ne pas oublier cette ligne
+ # (appel au constructeur de la classe mère)
+ self.nom="B" # self.name exite deja
+
+ def run(self):
+ print('debut ',self.nom)
+
+ print ('milieu ',self.nom)
+
+ print ('fin ',self.nom)
+
+def test():
+ a = MyThread1()
+ b=MyThread2()
+ a.start()
+ b.start()
\ No newline at end of file
diff --git a/Processus/partageObj.py b/Processus/partageObj.py
new file mode 100644
index 0000000000000000000000000000000000000000..83ba4ca689358d76bef14c608525b5609d70e073
--- /dev/null
+++ b/Processus/partageObj.py
@@ -0,0 +1,27 @@
+import threading
+
+class Objetpartage():
+ def __init__(self,v):
+ self.v=v
+ def myMeth(self,val):
+ self.v+=val
+
+class UtilisateurObjetPartage(threading.Thread):
+ def __init__(self,objToShare,id):
+ threading.Thread.__init__(self)
+ self.obj=objToShare
+ self.id=id
+ def doStg(self):
+ self.obj.myMeth(self.id)
+ def run(self):
+ self.doStg()
+def test():
+ o=Objetpartage(2)
+ util1=UtilisateurObjetPartage(o,11)
+ util2 = UtilisateurObjetPartage(o,22)
+ util1.start()
+ util2.start()
+ print("valeur avant join", o.v)
+ util1.join()
+ util2.join()
+ print("valeur à la fin",o.v)
diff --git a/Processus/pingpong.py b/Processus/pingpong.py
new file mode 100644
index 0000000000000000000000000000000000000000..efc5fb5e54b65dd357d119e71f4dbc76ecd41859
--- /dev/null
+++ b/Processus/pingpong.py
@@ -0,0 +1,42 @@
+
+import threading
+# inspire de http://www.xavierdupre.fr/app/teachpyx/helpsphinx/c_parallelisation/thread.html#premier-thread
+class Ping(threading.Thread):
+
+ def __init__(self,name,semaphore1,semaphore2):
+ threading.Thread.__init__(self) # ne pas oublier cette ligne
+ # (appel au constructeur de la classe mère)
+ self.nom=name # self.name exite deja
+ self.s1 = semaphore1
+ self.s2 = semaphore2
+
+ def run(self):
+ for i in range (10):
+ self.s1.acquire()
+ print('Ping ',self.nom)
+ self.s2.release()
+
+
+class Pong(threading.Thread):
+
+ def __init__(self, name, semaphore1, semaphore2):
+ threading.Thread.__init__(self) # ne pas oublier cette ligne
+ # (appel au constructeur de la classe mère)
+ self.nom = name # self.name exite deja
+ self.s1 = semaphore1
+ self.s2 = semaphore2
+
+ def run(self):
+ for i in range(10):
+ self.s1.acquire()
+ print('Pong ', self.nom)
+ self.s2.release()
+
+def test():
+ s1= threading.Semaphore(1)
+ s2=threading.Semaphore(0)
+ ping=Ping('ppp',s1,s2)
+ pong = Pong('gg', s2, s1)
+ ping.start()
+ pong.start()
+
diff --git a/TP1/TP2/.gitkeep b/TP1/TP2/.gitkeep
deleted file mode 100644
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..0000000000000000000000000000000000000000
diff --git a/TP2/Armoire5.py b/TP2/Armoire5.py
new file mode 100644
index 0000000000000000000000000000000000000000..6d70146d0860aadaff5b1c3ce2ee8a83f7e7c74b
--- /dev/null
+++ b/TP2/Armoire5.py
@@ -0,0 +1,154 @@
+# -*- coding: utf-8 -*-
+"""
+Created on Mon Jun 22 16:40:33 2020
+
+@author: chevrier6
+"""
+from bitManip import *
+from easymodbus.modbusClient import ModbusClient
+from easymodbus.modbusClient import convert_registers_to_float
+
+
+class AutomateException(Exception):
+ def __init__(self, message):
+ self.message = message
+
+
+class Armoire5():
+ # ici les adresse des mesure commence a ZERO (pas UN comme en java)
+
+ def __init__(self):
+ self.nbCharge = 7 # de 0 a 6
+ self.ipAdresse = "100.75.155.115"
+ self.adresseMesure = 2
+ self.adresseTOR = 32000
+ self.adresseMesureSecteur1 = 7 # attention vraie adresse ()
+ self.adresseMesureSecteur2 = 8 # attention vraie adresse
+
+ self.debutAdrCharge = 9
+ self.debutAdrSource = 0
+
+ def okCharge(self, i):
+ return 0 <= i <= 6
+
+ def resetAll(self):
+ self.writeTOR(0)
+
+ def resetSource(self):
+ for i in range(self.nbCharge):
+ self.setSource1(i)
+
+ def resetCharge(self):
+ for i in range(self.nbCharge):
+ self.unsetCharge(i)
+
+ def setCharge(self, charge: int):
+ if not self.okCharge(charge):
+ raise AutomateException("numero charge pas compris entre 0 et 6")
+ val = self.readTOR()
+ val = setBit(val, charge + self.debutAdrCharge)
+ self.writeTOR(val)
+
+ def unsetCharge(self, charge):
+ if not self.okCharge(charge):
+ raise AutomateException("numero charge pas compris entre 0 et 6")
+ val = self.readTOR()
+ val = clearBit(val, charge + self.debutAdrCharge)
+ self.writeTOR(val)
+
+ def toggleCharge(self, charge):
+ if not self.okCharge(charge):
+ raise AutomateException("numero charge pas compris entre 0 et 6")
+ val = self.readTOR()
+ val = toggleBit(val, charge + self.debutAdrCharge)
+ self.writeTOR(val)
+
+ def setSource1(self, charge):
+ if not self.okCharge(charge):
+ raise AutomateException("numero charge pas compris entre 0 et 6")
+ val = self.readTOR()
+ val = clearBit(val, charge + self.debutAdrSource)
+ self.writeTOR(val)
+
+ def setSource2(self, charge):
+ if not self.okCharge(charge):
+ raise AutomateException("numero charge pas compris entre 0 et 6")
+ val = self.readTOR()
+ val = setBit(val, charge + self.debutAdrSource)
+ self.writeTOR(val)
+
+ def togglesource(self, charge):
+ if not self.okCharge(charge):
+ raise AutomateException("numero charge pas compris entre 0 et 6")
+ val = self.readTOR()
+ val = toggleBit(val, charge + self.debutAdrSource)
+ self.writeTOR(val)
+
+ ################################
+
+ def writeTOR(self, val):
+ modbusclient = ModbusClient(self.ipAdresse, 502)
+ modbusclient.connect()
+ modbusclient.write_single_register(self.adresseTOR, val)
+ modbusclient.close()
+ # some tempo to wait measure to stabilize
+ from time import sleep
+ sleep(2.)
+
+ def readTOR(self):
+ modbusclient = ModbusClient(self.ipAdresse, 502)
+ modbusclient.connect()
+ inputRegisters = modbusclient.read_inputregisters(self.adresseTOR, 1)
+ modbusclient.close()
+ return (int)(inputRegisters[0])
+
+ ###############################################
+ def readSecteur1(self):
+ addr = self.adresseMesure + (self.adresseMesureSecteur1) * 8
+ return self.lireValeurAdresse(addr + 2), self.lireValeurAdresse(addr), self.lireValeurAdresse(
+ addr + 4), self.lireValeurAdresse(addr + 6)
+
+ def readSecteur2(self):
+ addr = self.adresseMesure + (self.adresseMesureSecteur2) * 8
+ return self.lireValeurAdresse(addr + 2), self.lireValeurAdresse(addr), self.lireValeurAdresse(
+ addr + 4), self.lireValeurAdresse(addr + 6)
+
+ def readMesureCourant(self, source: int):
+ if not self.okCharge(source):
+ raise AutomateException("numero charge pas compris entre 0 et 6")
+ return self.lireValeur(source, 0)
+
+ def readMesureTension(self, source: int):
+ if not self.okCharge(source):
+ raise AutomateException("numero charge pas compris entre 0 et 6")
+ return self.lireValeur(source, 2)
+
+ def readMesurePactive(self, source: int):
+ if not self.okCharge(source):
+ raise AutomateException("numero charge pas compris entre 0 et 6")
+ return self.lireValeur(source, 4)
+
+ def readMesurePreactive(self, source: int):
+ if not self.okCharge(source):
+ raise AutomateException("numero charge pas compris entre 0 et 6")
+ return self.lireValeur(source, 6)
+
+ def readMesure(self, source):
+ return self.readMesureTension(source), self.readMesureCourant(source), self.readMesurePactive(
+ source), self.readMesurePreactive(source)
+
+ def lireValeur(self, source, offset):
+
+ addr = self.adresseMesure + (source) * 8 + offset
+ return self.lireValeurAdresse(addr)
+
+ def lireValeurAdresse(self, addr):
+
+ modbusclient = ModbusClient(self.ipAdresse, 502)
+ modbusclient.connect()
+ data = modbusclient.read_holdingregisters(addr, 2)
+ modbusclient.close()
+ res = convert_registers_to_float(data)
+
+ return res[0]
+
diff --git a/TP2/Armoire6.py b/TP2/Armoire6.py
new file mode 100644
index 0000000000000000000000000000000000000000..54e835fc424dc3659e58d4a5f63f1bd4b596b89a
--- /dev/null
+++ b/TP2/Armoire6.py
@@ -0,0 +1,157 @@
+# -*- coding: utf-8 -*-
+"""
+Created on Mon Jun 22 16:40:33 2020
+
+@author: chevrier6
+"""
+from bitManip import *
+from easymodbus.modbusClient import ModbusClient
+from easymodbus.modbusClient import convert_registers_to_float
+
+class AutomateException(Exception):
+ def __init__(self, message):
+ self.message = message
+
+
+
+
+
+class Armoire6():
+ # ici les adresse des mesure commence a ZERO (pas UN comme en java)
+
+
+ def __init__(self):
+ self.nbCharge=7 # de 0 a 6
+ self.ipAdresse="100.75.155.116"
+ self.adresseMesure=0
+ self.adresseTOR=32000
+ self.adresseMesureSecteur1=7 # attention vraie adresse ()
+ self.adresseMesureSecteur2=8 # attention vraie adresse
+
+ self.debutAdrCharge=0
+ self.debutAdrSource=7
+
+ def okCharge(self,i):
+ return 0 <= i <= 6
+
+ def resetAll(self):
+ self.writeTOR(0)
+
+ def resetSource(self):
+ for i in range(self.nbCharge):
+ self.setSource1(i)
+
+ def resetCharge(self):
+ for i in range(self.nbCharge):
+ self.unsetCharge(i)
+
+ def setCharge(self, charge : int ):
+ if not self.okCharge(charge):
+ raise AutomateException("numero charge pas compris entre 0 et 6")
+ val=self.readTOR()
+ val=setBit(val,charge+self.debutAdrCharge)
+ self.writeTOR(val)
+
+
+ def unsetCharge(self,charge):
+ if not self.okCharge(charge):
+ raise AutomateException("numero charge pas compris entre 0 et 6")
+ val=self.readTOR()
+ val=clearBit(val,charge+self.debutAdrCharge)
+ self.writeTOR(val)
+
+ def toggleCharge(self, charge):
+ if not self.okCharge(charge):
+ raise AutomateException("numero charge pas compris entre 0 et 6")
+ val = self.readTOR()
+ val = toggleBit(val, charge+self.debutAdrCharge)
+ self.writeTOR(val)
+
+ def setSource1(self,charge):
+ if not self.okCharge(charge):
+ raise AutomateException("numero charge pas compris entre 0 et 6")
+ val=self.readTOR()
+ val=clearBit(val,charge+self.debutAdrSource)
+ self.writeTOR(val)
+
+ def setSource2(self, charge):
+ if not self.okCharge(charge):
+ raise AutomateException("numero charge pas compris entre 0 et 6")
+ val = self.readTOR()
+ val = setBit(val, charge +self.debutAdrSource)
+ self.writeTOR(val)
+
+
+
+ def togglesource(self,charge):
+ if not self.okCharge(charge):
+ raise AutomateException("numero charge pas compris entre 0 et 6")
+ val=self.readTOR()
+ val=toggleBit(val,charge+self.debutAdrSource)
+ self.writeTOR(val)
+
+ ################################
+
+
+ def writeTOR(self,val):
+ modbusclient =ModbusClient(self.ipAdresse,502)
+ modbusclient.connect()
+ modbusclient.write_single_register(self.adresseTOR,val)
+ modbusclient.close()
+ # some tempo to wait measure to stabilize
+ from time import sleep
+ sleep(2.)
+
+
+ def readTOR(self):
+ modbusclient =ModbusClient(self.ipAdresse,502)
+ modbusclient.connect()
+ inputRegisters = modbusclient.read_inputregisters(self.adresseTOR, 1)
+ modbusclient.close()
+ return (int)(inputRegisters[0])
+
+###############################################
+ def readSecteur1(self):
+ from time import sleep
+ addr = self.adresseMesure + (self.adresseMesureSecteur1 ) * 8
+ return self.lireValeurAdresse(addr + 2), self.lireValeurAdresse(addr), self.lireValeurAdresse(addr + 4), self.lireValeurAdresse(addr + 6)
+ def readSecteur2(self):
+ addr = self.adresseMesure + (self.adresseMesureSecteur2 ) * 8
+ return self.lireValeurAdresse(addr+2),self.lireValeurAdresse(addr),self.lireValeurAdresse(addr+4),self.lireValeurAdresse(addr+6)
+
+ def readMesureCourant(self,source :int):
+ if not self.okCharge(source):
+ raise AutomateException("numero charge pas compris entre 0 et 6")
+ return self.lireValeur(source,0 )
+ def readMesureTension(self,source :int):
+ if not self.okCharge(source):
+ raise AutomateException("numero charge pas compris entre 0 et 6")
+ return self.lireValeur(source,2 )
+ def readMesurePactive(self,source :int):
+ if not self.okCharge(source):
+ raise AutomateException("numero charge pas compris entre 0 et 6")
+ return self.lireValeur(source,4 )
+ def readMesurePreactive(self,source :int):
+ if not self.okCharge(source):
+ raise AutomateException("numero charge pas compris entre 0 et 6")
+ return self.lireValeur(source,6 )
+
+ def readMesure(self,source):
+ return self.readMesureTension(source),self.readMesureCourant(source),self.readMesurePactive(source),self.readMesurePreactive(source)
+
+ def lireValeur(self,source,offset):
+
+ addr= self.adresseMesure + (source ) *8+offset
+ return self.lireValeurAdresse(addr)
+ def lireValeurAdresse(self,addr):
+
+
+ modbusclient =ModbusClient(self.ipAdresse,502)
+ modbusclient.connect()
+ data=modbusclient.read_holdingregisters(addr,2)
+ modbusclient.close()
+ res =convert_registers_to_float(data)
+
+ return res[0]
+
+
\ No newline at end of file
diff --git a/TP2/bitManip.py b/TP2/bitManip.py
new file mode 100644
index 0000000000000000000000000000000000000000..2f8ceb26ce056109e127d98f179d807daf0acc0f
--- /dev/null
+++ b/TP2/bitManip.py
@@ -0,0 +1,38 @@
+# -*- coding: utf-8 -*-
+"""
+Created on Mon Jun 22 16:43:58 2020
+
+@author: chevrier6
+"""
+
+######################
+def mask16(v):
+ "same as setBit(v,0)"
+ b=1
+ for i in range(v):
+ b*=2
+ return b
+
+# 4 next functions from https://wiki.python.org/moin/BitManipulation
+# testBit() returns a nonzero result, 2**offset, if the bit at 'offset' is one.
+def testBit(int_type, offset):
+ mask = 1 << offset
+ return(int_type & mask)
+
+ # setBit() returns an integer with the bit at 'offset' set to 1.
+
+def setBit(int_type, offset):
+ mask = 1 << offset
+ return(int_type | mask)
+
+ # clearBit() returns an integer with the bit at 'offset' cleared.
+
+def clearBit(int_type, offset):
+ mask = ~(1 << offset)
+ return(int_type & mask)
+
+ # toggleBit() returns an integer with the bit at 'offset' inverted, 0 -> 1 and 1 -> 0.
+
+def toggleBit(int_type, offset):
+ mask = 1 << offset
+ return(int_type ^ mask)
\ No newline at end of file
diff --git a/TP2/docArmoirePython.md b/TP2/docArmoirePython.md
new file mode 100644
index 0000000000000000000000000000000000000000..95dcaa37bce4bb21c22dbbf1a0cdd999900f58d4
--- /dev/null
+++ b/TP2/docArmoirePython.md
@@ -0,0 +1,43 @@
+# Une armoire c'est quoi ?
+
+- c'est un appareil électrique commandable à distance
+- il dispose de 7 charges différentes (numérotées de 0 à 6) et de deux source d'alimentation
+(source1 et source2)
+
+- chaque charge peut être en marche ou pas et soit sur source 1 soit sur source 2 indépendament des autres
+- on peut connaitre des infos sur chaque charges (U,I,P,PR) et sur chaque source (i.e. le cumul des charges en marche sur la source concernée)
+# Documentation code python de manipulation des armoires
+
+
+## Prerequis logiciel
+
+- utilisation de la librairie EasyModbus.py
+- utilisation d'un code bitManip.py
+
+## Code disponible
+
+### Note
+Actuellemnt seul le code pour l'armoire 6 est opérationnel
+
+### Utilisation
+
+- charger le fichier correspondant à l'armoire à utiliser (exemple Armoire6.py) et ses dépendances
+
+**Méthodes**
+
+* Constructeur *ArmoireX()* où X vaut 6
+
+* actions générales
+ - **resetAll**: remet tout à l'état d'origine
+ - **resetSource** / **resetCharge**: remet la partie source/charge à l'état d'origine
+ * actions sur les charges
+ - **setCharge** / **unsetCharge** / **toggleCharge**(*n°charge*): met sur ON/OFF/état inverse la charge. *N°charge* doit être compris entre 0 et 6
+* Actions sur les sources
+ - **setSource1** / **setSource2** / **togglesource**(*n°charge*): met sur l'alimentaion 1/l'alimentation 2/inverse la source. *N°charge* doit être compris entre 0 et 6
+* Actions sur les sources
+
+* lecture de valeurs (
+retourne une liste de valeurs [U,I,PA,PR])
+ - **readSecteur1**: mesure pour la source 1
+ - **readSecteur2**: mesure pour la source 2
+ - **readMesure**(*n°charge*): mesure pour la charge paramètre (compris en 0 et 6)
\ No newline at end of file
diff --git a/TP2/test5.py b/TP2/test5.py
new file mode 100644
index 0000000000000000000000000000000000000000..70ef3be131ceb282098aa9ad4d4b6f2f02dec95d
--- /dev/null
+++ b/TP2/test5.py
@@ -0,0 +1,90 @@
+# -*- coding: utf-8 -*-
+"""
+Seule Test est à utiliser
+
+@author: chevrier6
+"""
+
+from Armoire5 import *
+#
+# a=Armoire6()
+# a.resetAll()
+# i=0
+# a.setCharge(i)
+# s=a.readMesure(i)
+# print(s)
+#
+# def chenillard():
+# a=Armoire6()
+# for i in range(a.nbCharge):
+# a.setCharge(i)
+# s=a.readMesure(i)
+# print(s)
+
+def pprint(mesure):
+ output="U={:.2f} I={:.2f} PA={:.2f} PR={:.2f}"
+ return output.format(mesure[0],mesure[1],mesure[2],mesure[3])
+
+def test(charge):
+
+ a=Armoire5()
+ a.resetAll()
+ print("charge ",charge)
+ a.setCharge(charge)
+ s=a.readMesure(charge)
+ print(pprint(s), "\nS1" ,pprint(a.readSecteur1()),"\nS2", pprint(a.readSecteur2()),"\n")
+ a.setSource2(charge)
+ s=a.readMesure(charge)
+ print(pprint(s), "\nS1" ,pprint(a.readSecteur1()),"\nS2", pprint(a.readSecteur2()),"\n")
+ a.unsetCharge(charge)
+
+#
+# def chenillard2():
+# a=Armoire6()
+# a.resetAll()
+# for i in range(a.nbCharge):
+# print("charge ",i)
+# a.setCharge(i)
+# s=a.readMesure(i)
+# print(s, "S1" ,a.readSecteur1(),"S2", a.readSecteur2())
+# a.setSource2(i)
+# s=a.readMesure(i)
+# print(s, "S1" ,a.readSecteur1(),"S2", a.readSecteur2())
+# a.unsetCharge(i)
+#
+#
+# def chenillard3():
+# a=Armoire6()
+# a.resetAll()
+# for charge in range(a.nbCharge):
+# print("charge ",charge)
+# a.setCharge(charge)
+# u,i,pa,pr=a.readMesure(charge)
+# u1,i1,pa1,pr1=a.readSecteur1()
+# u2,i2,pa2,pr2=a.readSecteur2()
+# print((u,i,pa,pr), "S1" ,a.readSecteur1(),"S2", a.readSecteur2())
+# print(u-u1,i-i1,pa-pa1,pr-pr1)
+# print(u-u2,i-i2,pa-pa2,pr-pr2)
+# a.setSource2(charge)
+# u,i,pa,pr=a.readMesure(charge)
+# u1,i1,pa1,pr1=a.readSecteur1()
+# u2,i2,pa2,pr2=a.readSecteur2()
+# print((u,i,pa,pr), "S1" ,a.readSecteur1(),"S2", a.readSecteur2())
+# print(u-u1,i-i1,pa-pa1,pr-pr1)
+# print(u-u2,i-i2,pa-pa2,pr-pr2)
+# a.unsetCharge(charge)
+#
+# def chenillard2b():
+# a=Armoire6()
+# a.resetAll()
+# for i in range(a.nbCharge):
+# print("charge ",i)
+# a.toggleCharge(i)
+# s=a.readMesure(i)
+# print(s, "S1" ,a.readSecteur1(),"S2", a.readSecteur2())
+# a.setSource2(i)
+# s=a.readMesure(i)
+# print(s, "S1" ,a.readSecteur1(),"S2", a.readSecteur2())
+# a.unsetCharge(i)
+
+#chenillard2b()
\ No newline at end of file
diff --git a/TP2/test6.py b/TP2/test6.py
new file mode 100644
index 0000000000000000000000000000000000000000..6473506ae4be3db666fd8252d440f3fb1547f7c0
--- /dev/null
+++ b/TP2/test6.py
@@ -0,0 +1,90 @@
+# -*- coding: utf-8 -*-
+"""
+
+
+@author: chevrier6
+"""
+
+from Armoire6 import *
+#
+# a=Armoire6()
+# a.resetAll()
+# i=0
+# a.setCharge(i)
+# s=a.readMesure(i)
+# print(s)
+#
+# def chenillard():
+# a=Armoire6()
+# for i in range(a.nbCharge):
+# a.setCharge(i)
+# s=a.readMesure(i)
+# print(s)
+
+def pprint(mesure):
+ output="U={:.2f} I={:.2f} PA={:.2f} PR={:.2f}"
+ return output.format(mesure[0],mesure[1],mesure[2],mesure[3])
+
+def test(charge):
+
+ a=Armoire6()
+ a.resetAll()
+ print("charge ",charge)
+ a.setCharge(charge)
+ s=a.readMesure(charge)
+ print(pprint(s), "\nS1" ,pprint(a.readSecteur1()),"\nS2", pprint(a.readSecteur2()),"\n")
+ a.setSource2(charge)
+ s=a.readMesure(charge)
+ print(pprint(s), "\nS1" ,pprint(a.readSecteur1()),"\nS2", pprint(a.readSecteur2()),"\n")
+ a.unsetCharge(charge)
+
+#
+# def chenillard2():
+# a=Armoire6()
+# a.resetAll()
+# for i in range(a.nbCharge):
+# print("charge ",i)
+# a.setCharge(i)
+# s=a.readMesure(i)
+# print(s, "S1" ,a.readSecteur1(),"S2", a.readSecteur2())
+# a.setSource2(i)
+# s=a.readMesure(i)
+# print(s, "S1" ,a.readSecteur1(),"S2", a.readSecteur2())
+# a.unsetCharge(i)
+#
+#
+# def chenillard3():
+# a=Armoire6()
+# a.resetAll()
+# for charge in range(a.nbCharge):
+# print("charge ",charge)
+# a.setCharge(charge)
+# u,i,pa,pr=a.readMesure(charge)
+# u1,i1,pa1,pr1=a.readSecteur1()
+# u2,i2,pa2,pr2=a.readSecteur2()
+# print((u,i,pa,pr), "S1" ,a.readSecteur1(),"S2", a.readSecteur2())
+# print(u-u1,i-i1,pa-pa1,pr-pr1)
+# print(u-u2,i-i2,pa-pa2,pr-pr2)
+# a.setSource2(charge)
+# u,i,pa,pr=a.readMesure(charge)
+# u1,i1,pa1,pr1=a.readSecteur1()
+# u2,i2,pa2,pr2=a.readSecteur2()
+# print((u,i,pa,pr), "S1" ,a.readSecteur1(),"S2", a.readSecteur2())
+# print(u-u1,i-i1,pa-pa1,pr-pr1)
+# print(u-u2,i-i2,pa-pa2,pr-pr2)
+# a.unsetCharge(charge)
+#
+# def chenillard2b():
+# a=Armoire6()
+# a.resetAll()
+# for i in range(a.nbCharge):
+# print("charge ",i)
+# a.toggleCharge(i)
+# s=a.readMesure(i)
+# print(s, "S1" ,a.readSecteur1(),"S2", a.readSecteur2())
+# a.setSource2(i)
+# s=a.readMesure(i)
+# print(s, "S1" ,a.readSecteur1(),"S2", a.readSecteur2())
+# a.unsetCharge(i)
+
+#chenillard2b()
\ No newline at end of file
diff --git a/TP3/appli1.py b/TP3/appli1.py
new file mode 100644
index 0000000000000000000000000000000000000000..19436dbcfe51f0f6e15436fd5ace2f55b06388a0
--- /dev/null
+++ b/TP3/appli1.py
@@ -0,0 +1,44 @@
+
+
+# see https://openweathermap.org/api
+# what is possible : https://openweathermap.org/price#weather
+
+import requests
+
+
+# some simple manipulations
+
+# 1 get info on current weather
+# test code : print("Teste1",requests.get("https://api.openweathermap.org/data/2.5/weather?lat=35&lon=139&appid=a2cabf37326f4cf77d2948c17c62705a").text)
+
+
+## some parameters
+id = "6c7536caec8cea574d9b049fde683a35" # Api id Chevrier Thanks to use your own id ... :-)
+idSEG="a2cabf37326f4cf77d2948c17c62705a"
+lat = "48.650002" # latitude
+lon="6.18333" # longitude
+
+
+
+# websevice parameters
+wslon="lon="+lon
+wslat="lat="+lat
+wsappid="appid="+id
+
+# first request
+#--------------------------------
+requestTxt="https://api.openweathermap.org/data/2.5/weather?"+wslat+"&"+wslon+"&"+wsappid
+print("essai2", requestTxt)
+answer=requests.get(requestTxt)
+print(answer.text)
+
+
+# other example
+
+
+
+# exo 1
+requestSol=requestTxt+"&lang=fr"
+answer=requests.get(requestSol)
+print("sol",answer.text)
+
diff --git a/TP3/arguement.py b/TP3/arguement.py
new file mode 100644
index 0000000000000000000000000000000000000000..6d3d737afdb0f0de760125e5da794b937444b822
--- /dev/null
+++ b/TP3/arguement.py
@@ -0,0 +1,48 @@
+import json
+
+from flask import Flask, request, jsonify # on importe le necessaire
+
+app = Flask(__name__) # notre appli
+
+@app.route('/service0') # l'adresse sera service0 sur le serveur, le code en dessous sera la fonction appelée
+def requete():
+ args = request.args
+ print ("print info",args.values(),args.keys(),args.items()) # For debugging
+ rep=""
+ for k,v in args.items():
+ print (k,v)
+ rep+="("+k+","+v+")"
+ return rep
+# http://127.0.0.1:5000/exercise0 # exemple de texte à saisir dans un navigateur si host pas précisé
+# sinon voir l'adresse indiquée
+
+
+@app.route('/exemple3')
+def exemple3():
+ data=request.args
+ print( data['valeur'])
+# Modifiez pour renvoyer le nombre de minute
+ return "plouf"
+#http://127.0.0.1:5000//exemple3?valeur={"hour": 8, "min": 53, "second": 17, "text": "Coucou ! il est "}
+
+
+
+@app.route('/exemple4') #
+def mini():
+ args = request.args
+ liste=args['liste']
+ val=json.loads(liste)
+ mini=min(val)
+ return jsonify(min=mini)
+#http://127.0.0.1:5000//exemple4?liste=[3,75,-9]
+
+@app.route('/exemple5') #
+def somme():
+ args = request.args
+ a=int(args['a'])
+ b=int(args['b'])
+
+ return jsonify(somme=a+b)
+#http://127.0.0.1:5000//exemple5?a=12&b=2
+
+app.run(debug=True)
\ No newline at end of file
diff --git a/TP3/askex1.py b/TP3/askex1.py
new file mode 100644
index 0000000000000000000000000000000000000000..51e6f26d8a062ccbd0f68726164f6ce7dfb1131b
--- /dev/null
+++ b/TP3/askex1.py
@@ -0,0 +1,13 @@
+
+#exemple de requete
+import requests
+
+requetes =["http://127.0.0.1:5000/",
+"http://127.0.0.1:5000/bonjour",
+"http://127.0.0.1:5000/bonjour?nom=vincent"]
+
+
+for txt in requetes:
+ r = requests.get(txt)
+ print(r.text)
+
diff --git a/TP3/asksarg.py b/TP3/asksarg.py
new file mode 100644
index 0000000000000000000000000000000000000000..bdc3a66f4d03cb801d6777b88d9062f5c9d10094
--- /dev/null
+++ b/TP3/asksarg.py
@@ -0,0 +1,9 @@
+import requests
+
+
+test2="http://127.0.0.1:5000/service0?a=4&c=34"
+adresse=test2
+
+
+r = requests.get(adresse)
+print(r.text)
\ No newline at end of file
diff --git a/TP3/askservice1.py b/TP3/askservice1.py
new file mode 100644
index 0000000000000000000000000000000000000000..172e8053b7c8fd4a168421c844645fd9b1db615c
--- /dev/null
+++ b/TP3/askservice1.py
@@ -0,0 +1,10 @@
+import requests
+import time
+
+test2="http://127.0.0.1:5000/service1"
+adresse=test2
+
+for i in range(10):
+ time.sleep(1)
+ r = requests.get(adresse)
+ print(r.text)
\ No newline at end of file
diff --git a/TP3/askservice1j.py b/TP3/askservice1j.py
new file mode 100644
index 0000000000000000000000000000000000000000..5a39ec9a53490ab629f1a6da934a65ae4cd56f68
--- /dev/null
+++ b/TP3/askservice1j.py
@@ -0,0 +1,12 @@
+import requests
+import time
+
+test2="http://127.0.0.1:5000/service1j"
+adresse=test2
+
+for i in range(10):
+ time.sleep(1)
+ r = requests.get(adresse)
+ rep= r.json()
+
+ print(r.text, rep['text'],rep['hour']+rep['min'],rep.get('inconnu'))
\ No newline at end of file
diff --git a/TP3/docu.md b/TP3/docu.md
new file mode 100644
index 0000000000000000000000000000000000000000..d80495546365b340b38b46ec0aaee72c55c5585d
--- /dev/null
+++ b/TP3/docu.md
@@ -0,0 +1,86 @@
+# Documentation for the examples
+*V Chevrier Dec 21*
+
+## What to know
+In python, use of **requests** package that enables call to web service (as html addresses do)
+and use of **flask** package for web services.
+
+## Examples Client side
+### File appli1.py
+Simple call to a distant web service : ask for weather in Nancy
+see https://openweathermap.org/current#geo for more information
+
+
+
+#### Questions
+
+- Explain why we need to write ***print(answer.text)***
+- what means the string output format ?
+#### Exercise:
+
+ 1. Change response format to XML, the language as French
+ 2. learn how to ask for weather forecast (with free version)
+ 3. What happens if you type the following as address in your favorite web browser ?
+ https://api.openweathermap.org/data/2.5/weather?lat=35&lon=139&appid=a2cabf37326f4cf77d2948c17c62705a
+ 4. Explain how to pass parameters to a web service
+
+#### API reference
+[https://openweathermap.org/api](https://openweathermap.org/price#weather)
+have a look on it to learn what is **possible** and how
+
+1. all requests need an id
+2. there is a limit on the number of requests each day
+
+## Examples: learn how to define services (and how to call them)
+
+### A) exemple1 (and askex1)
+basic service (just returns a string) and code for requests
+
+### B) argument.py / askarg.py
+A server to illustrate the use of arguments.
+
+Services :
+- service0
+ Shows how to build a simple service that
+ - gets the parameters and their values
+ - returns them as a list of couple ou value
+
+ The returned values are as text format.
+
+- exemple3
+ How to get the value of a parameter
+
+ Note that the parameter are in Json format
+ What is the type of the values we get ??
+
+ - exemple 4 et exemple5 shows how to get typed values
+
+### C) service1.py/askservice1.py
+Simple service to show that returned value can change over time
+The returned values are as **text** format.
+
+
+### C') service1j.py/askservice1j.py
+Simple service to show that returned value can change over time.
+The returned values are as **json** format.
+
+In askservice1 client
+ - How is managed the json format?
+ - Can you see an advantage to use it?
+
+### service3.py
+##More interesting
+### The shutdown problem
+When the server is running it uses a givent port on the machine and forbids another server to be run.
+
+According to your programmig environment, it can be very difficult to shutdown/kill the server.
+
+The file ***servershutdown.py*** shows how to integrate a shutdown service in the server.
+
+### Non local server
+
+serverNonLocal.py illustates how to have a non local server
+
+Shows how to build a server with several services
+
+See how the root return results as html
diff --git a/TP3/exemple1.py b/TP3/exemple1.py
new file mode 100644
index 0000000000000000000000000000000000000000..100136d7ab8eca2ce3861b433c3842ee904bbeb1
--- /dev/null
+++ b/TP3/exemple1.py
@@ -0,0 +1,23 @@
+
+from flask import Flask, request
+
+app = Flask(__name__)
+
+@app.route('/')
+def index():
+ return "Hello ! serveur de test"
+
+
+@app.route('/bonjour')
+def dire_bonjour():
+ args = request.args
+ nom = args.get('nom')
+ if nom==None:
+ nom='inconnu'
+ return 'bonjour '+nom
+
+#exemple de requete
+#http://127.0.0.1:5000/
+#http://127.0.0.1:5000/bonjour
+#http://127.0.0.1:5000/bonjour?nom=vincent
+app.run(debug=True)
\ No newline at end of file
diff --git a/TP3/serverNonLocal.py b/TP3/serverNonLocal.py
new file mode 100644
index 0000000000000000000000000000000000000000..c2af3ca796cf2ce0c2bee31d29695e66fcbfb41a
--- /dev/null
+++ b/TP3/serverNonLocal.py
@@ -0,0 +1,17 @@
+
+from flask import Flask, request # on importe le necessaire
+
+app = Flask(__name__) # notre appli
+
+@app.route('/service0') # l'adresse sera service0 sur le serveur, le code en dessous sera la fonction appelée
+def requete():
+ args = request.args
+ print ("print info",args.values(),args.keys(),args.items()) # For debugging
+ rep=""
+ for k,v in args.items():
+ print (k,v)
+ rep+="("+k+","+v+")"
+ return rep
+# http://127.0.0.1:5000/service0?a=4&c=34 # exemple de texte à saisir dans un navigateur
+#changer l'adresse avec celle fournie dans le shell
+app.run(debug=True,host='0.0.0.0')
\ No newline at end of file
diff --git a/TP3/servershutdown.py b/TP3/servershutdown.py
new file mode 100644
index 0000000000000000000000000000000000000000..d06651d057c0ce331b45ddf5d237fff339458043
--- /dev/null
+++ b/TP3/servershutdown.py
@@ -0,0 +1,30 @@
+
+from flask import Flask, request # on importe le necessaire
+
+app = Flask(__name__) # notre appli
+
+# from http://web.archive.org/web/20190706125149/http://flask.pocoo.org/snippets/67
+def shutdown_server():
+ func = request.environ.get('werkzeug.server.shutdown')
+ if func is None:
+ raise RuntimeError('Not running with the Werkzeug Server')
+ func()
+
+
+@app.get('/shutdown')
+def shutdown():
+ shutdown_server()
+ return 'Server shutting down...'
+
+
+@app.route('/service0') # l'adresse sera service0 sur le serveur, le code en dessous sera la fonction appelée
+def requete():
+ args = request.args
+ print ("print info",args.values(),args.keys(),args.items()) # For debugging
+ rep=""
+ for k,v in args.items():
+ print (k,v)
+ rep+="("+k+","+v+")"
+ return rep
+# http://127.0.0.1:5000/service0?a=4&c=34 # exemple de texte à saisir dans un navigateur
+app.run(debug=True)
\ No newline at end of file
diff --git a/TP3/service0Nonlovcal.py b/TP3/service0Nonlovcal.py
new file mode 100644
index 0000000000000000000000000000000000000000..37fc74c430b04f5dd8bc438ff2f847e5fba2966c
--- /dev/null
+++ b/TP3/service0Nonlovcal.py
@@ -0,0 +1,16 @@
+
+from flask import Flask, request # on importe le necessaire
+
+app = Flask(__name__) # notre appli
+
+@app.route('/service0') # l'adresse sera service0 sur le serveur, le code en dessous sera la fonction appelée
+def requete():
+ args = request.args
+ print ("print info",args.values(),args.keys(),args.items()) # For debugging
+ rep=""
+ for k,v in args.items():
+ print (k,v)
+ rep+="("+k+","+v+")"
+ return rep
+# http://127.0.0.1:5000/service0?a=4&c=34 # exemple de texte à saisir dans un navigateur
+app.run(debug=True)
\ No newline at end of file
diff --git a/TP3/service1.py b/TP3/service1.py
new file mode 100644
index 0000000000000000000000000000000000000000..a404035122ba5a2acd830cdf8877938a219db44e
--- /dev/null
+++ b/TP3/service1.py
@@ -0,0 +1,13 @@
+
+from flask import Flask
+from datetime import datetime
+
+app = Flask(__name__) # notre appli
+
+@app.route('/service1') # service (service1) et la fonction associé
+def dire_coucou():
+ myTime =datetime.today()
+ txt=str(myTime.hour)+"h "+str(myTime.minute)+"min "+str( myTime.second)+"s"
+ return 'Coucou ! il est '+ txt
+#http://127.0.0.1:5000/service1 # appel
+app.run(debug=True)
\ No newline at end of file
diff --git a/TP3/service1j.py b/TP3/service1j.py
new file mode 100644
index 0000000000000000000000000000000000000000..ad9bbe738b5b42f539aaa51ef24473974cafd0e9
--- /dev/null
+++ b/TP3/service1j.py
@@ -0,0 +1,13 @@
+
+from flask import Flask,jsonify
+
+from datetime import datetime
+
+app = Flask(__name__)
+
+@app.route('/service1j')
+def dire_coucou():
+ myTime =datetime.today()
+ return jsonify(text='Coucou ! il est ',hour=myTime.hour,min=myTime.minute,second=myTime.second)
+#http://127.0.0.1:5000/service1j
+app.run(debug=True)
\ No newline at end of file
diff --git a/annuaireFichier.md b/annuaireFichier.md
new file mode 100644
index 0000000000000000000000000000000000000000..c3dd36eb49fcbb98ff4d60df1192e73cea5939ec
--- /dev/null
+++ b/annuaireFichier.md
@@ -0,0 +1,22 @@
+# Annuaire des fichiers
+
+***REMARQUE IMPORTANTE***: la gestion des imports de module est à revoir pour les fichiers (la structure des répertoire de vos projets n'est pas forcément celle du git )
+
+## Code relatif au cours sur les processus (repertoire processus)
+- utilisation des processus : lancement et partageObj
+- exemple du cours (exclusion mutuelle et sa solution avec sémaphore): exclumutPb et exclumutPbSemaphore
+- exemple de syncrhonisation (pingpong et exJoinAlive)
+
+## Code relatif au TP2 (répertoire TP2)
+
+Vous trouverez:
+- une documentation
+
+et les fichiers suivants (besoin du module easymodbus)
+- Armoire5, Armoire6 code source pour accéder aux armoires 5 et 6
+- bitManip utilitaire
+- test5 et test6: code exemple d'utilisation des armoires
+
+##Code relatif au TP3 (répertoire TP3)
+
+Voir docu.md
\ No newline at end of file