depot code TP2, TP3

Processus/exJoinAliveEtc.py

+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

Processus/exclumutPb.py

+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

Processus/exclumutPbSemaphore.py

+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

Processus/lancement.py

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

Processus/partageObj.py

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

Processus/pingpong.py

+
+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()
+

TP2/Armoire5.py

+# -*- 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]
+

TP2/Armoire6.py

+# -*- 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

TP2/bitManip.py

+# -*- 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

TP2/docArmoirePython.md

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

TP2/test5.py

+# -*- 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

TP2/test6.py

+# -*- 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

TP3/appli1.py

+
+
+# 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)
+

TP3/arguement.py

+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

TP3/askex1.py

+
+#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)
+

TP3/asksarg.py

+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

TP3/askservice1.py

+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

TP3/askservice1j.py

+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

TP3/docu.md

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