def Remove(self):
# Popup de confirmation
confirmation = Popup(
self,
2,
texte="Souhaitez-vous confirmer la suppression du robot " +
self.robotSelected.get() + " ?",
valider="Oui",
fermer="Non")
if confirmation == False:
return
retour = self.root.dB.DeleteRobot(self.robotSelected.get())
# Vérification que la suppression a bien été effectuée
if retour == False:
Popup(self, 1, texte="Impossible de supprimer le dernier robot.")
return
Popup(self,
1,
texte="Le robot " + self.robotSelected.get() +
" a bien été supprimé.")
# Remise à zéro des menus déroulants
RefreshOptionMenu(self)
self.robotSelected.set(self.robotList[0])
self.root.mainMenuWindow.robotSelected.set(self.robotList[0])
self.root.maintenanceWindow.robotSelected.set(self.robotList[0])
def Close(self):
retour = Popup(self,
2,
texte="Toute calibration non validée sera perdue.",
fermer="Annuler",
valider="Quitter")
if retour == True:
self.root.maintenanceWindow.Open()
def Open(self):
if self.root.activeFrame == self.root.mainMenuWindow.masterFrame:
retour = Popup(
self,
2,
texte="ATTENTION: Ce menu est réservé aux personnel habilité.",
valider="Continuer",
fermer="Retour")
if retour == False:
return
SwitchWindow(self.masterFrame, self.root)
RefreshOptionMenu(self)
def Close(self):
# Popup de confirmation pour arrêter le programme et éteindre la Raspberry
arret = Popup(self,
2,
texte="Etes-vous sûr de vouloir arrêter le système ?",
valider="Oui",
fermer="Non")
if arret == True:
command = "/usr/bin/sudo /sbin/shutdown -h now"
process = subprocess.Popen(command.split(), stdout=subprocess.PIPE)
process.communicate()[0]
self.root.destroy()
def Open(self):
self.robotSelected = self.root.mainMenuWindow.robotSelected
if self.root.activeFrame == self.root.mainMenuWindow.masterFrame:
retour = Popup(self,
2,
texte="Démarrer le diagnostic du robot " +
str(self.robotSelected.get()) + " ?",
valider="Oui",
fermer="Non")
if retour == False:
return
SwitchWindow(self.masterFrame, self.root)
self.Refresh()
self.AutoDiag()
def AutomaticCalibration(self):
# Lancement de la calibration automatique après popup de vérification
validation = Popup(
self,
2,
texte=
"ATTENTION: Le processus de calibration ne peut pas être interrompu.",
valider="Continuer",
fermer="Annuler")
if validation == False:
return
validation = AutoCalib(self)
if validation == True:
self.Refresh()
Popup(
self,
1,
texte=
"La calibration automatique a été effectuée, vous pouvez rebrancher les capteurs."
)
else:
Popup(self,
1,
texte="Il y a eu une erreur lors de la calibration.")
def ValidateCalibration(self):
# Remise à zéro des listes de données pour éviter les duplicatas
self.sensorDict = {}
self.actuatorDict = {}
# On récupère la liste des valeurs des capteurs depuis les champs de texte
for sensor in self.sensorEntryVarList:
category = sensor[0].get()
subCategory = sensor[1].get()
try:
self.sensorDict[category]
except:
self.sensorDict[category] = {}
self.sensorDict[category][subCategory] = {}
for dataTuple in sensor[2:]:
if dataTuple[1].get() == None or dataTuple[1].get() == '':
self.sensorDict[category][subCategory][
dataTuple[0].get()] = float(0)
elif dataTuple[1].get() == 'None':
self.sensorDict[category][subCategory][
dataTuple[0].get()] = None
else:
try:
self.sensorDict[category][subCategory][
dataTuple[0].get()] = float(dataTuple[1].get())
except:
self.sensorDict[category][subCategory][
dataTuple[0].get()] = dataTuple[1].get()
# On récupère la liste des valeurs des actionneurs depuis les champs de texte
for actuator in self.actuatorEntryVarList:
category = actuator[0].get()
subCategory = actuator[1].get()
try:
self.actuatorDict[category]
except:
self.actuatorDict[category] = {}
self.actuatorDict[category][subCategory] = {}
for dataTuple in actuator[2:]:
if dataTuple[1].get() == None or dataTuple[1].get() == '':
self.actuatorDict[category][subCategory][
dataTuple[0].get()] = float(0)
elif dataTuple[1].get() == 'None':
self.actuatorDict[category][subCategory][
dataTuple[0].get()] = None
else:
try:
self.actuatorDict[category][subCategory][
dataTuple[0].get()] = float(dataTuple[1].get())
except:
self.actuatorDict[category][subCategory][
dataTuple[0].get()] = dataTuple[1].get()
# On ouvre une popup de validation et on récupère le choix de l'utilisateur
confirmation = Popup(self,
2,
texte="Souhaitez-vous confirmer la calibration ?",
valider="Oui",
fermer="Non")
# On modifie les valeurs de la robot dans la base de donnée via la fonction de robot_dB et on ouvre un popup de confirmation
if confirmation == True:
self.root.dB.ModifyRobot(self.robotSelected.get(),
self.nameRobot.get(),
int(self.gearsRobot.get()),
self.typeRobot.get(),
float(self.margin.get()), self.sensorDict,
self.actuatorDict)
Popup(self,
1,
texte="La calibration du robot " + self.nameRobot.get() +
" a été enregistré dans la base de données.")
# On réinitialise les listes de capteurs et d'actionneurs
self.sensorDict = {}
self.actuatorDict = {}
# On ferme la page de calibration
self.root.maintenanceWindow.Open()
def AutoCalib(self):
# On demande de vérifier le branchement des capteurs
self.centerFrame.place_forget()
self.centerSubFrameBis.pack(side= 'top', pady= 100)
self.diagConsole.delete(0, last= 'end')
self.diagConsole.insert('end', "[AutoCalib] : Initialisation de la calibration automatique pour le robot: " + self.robotAttributes['Name'] + '...')
self.root.update()
Popup(self, 1, texte= "Assurez vous que tous les capteurs sont branchés avant de continuer.", fermer= 'Continuer')
self.root.update()
# On éteint les relais
self.root.interface.GPIOReset()
# Récupération de la déviation des capteurs branchés
self.diagConsole.insert('end', "[AutoCalib] : Récupération de la déviation nominale des capteurs...")
self.root.update()
for category in self.robotAttributes['Sensors']:
for subCategory in self.robotAttributes['Sensors'][category]:
tempList = []
for i in range(1000):
tempList.append(self.root.interface.sensorClass[category][subCategory].Poll())
avgVal = mean(tempList)
variance = 0
for i in tempList:
variance += (i - avgVal)**2
variance = variance / len(tempList)
if round(variance**(0.5), 2) < 0.01:
self.robotAttributes['Sensors'][category][subCategory]['Deviation'] = 0.02
else:
self.robotAttributes['Sensors'][category][subCategory]['Deviation'] = round(variance**(0.5), 2)
self.diagConsole.insert('end', "[AutoCalib] : Déviation nominale des capteurs enregistrée.")
self.diagConsole.itemconfig('end', fg= 'green')
self.root.update()
if self.robotAttributes['Type'] != 'Electrique':
# Calibration du système de pression
self.diagConsole.insert('end', "[AutoCalib] : Initialisation de la calibration du système de pression...")
self.root.update()
pressureSensor = self.root.interface.sensorClass['Pression']['Robot']
pressureActuator = self.root.interface.actuatorClass['Electro_pompe']['Robot']
evDict = self.robotAttributes['Actuators']['Electrovanne']
evClassList = []
for subCategory in evDict:
evClassList.append(self.root.interface.actuatorClass['Electrovanne'][subCategory])
# Vidage de la pression
self.diagConsole.insert('end', "[AutoCalib] : Diminution de la pression...")
self.root.update()
for i in range(5):
for ev in evClassList:
ev.Set(state= 1)
sleep(0.5)
ev.Set(state= 0)
sleep(0.25)
# Sauvegarde de la pression minimale
self.robotAttributes['Sensors']['Pression']['Robot']['Min'] = pressureSensor.Poll(100)
minPressure = self.robotAttributes['Sensors']['Pression']['Robot']['Min']
self.diagConsole.insert('end', "[AutoCalib] : Pression minimale atteinte à " + str(minPressure) + "V .")
self.diagConsole.itemconfig('end', fg= 'green')
self.root.update()
# Détermination de la pression maximale et minimale
self.diagConsole.insert('end', "[AutoCalib] : Détermination de la pression maximale...")
self.root.update()
timer = 5
counter = 0
# Sélection d'un actionneur hydraulique
for actuator in evDict:
if '+' in actuator:
print(actuator)
positionSensor = self.root.interface.sensorClass['Position'][actuator.rstrip(' +-') + ' 1']
actuatorUp = self.root.interface.actuatorClass['Electrovanne'][actuator]
try:
actuatorDown = self.root.interface.actuatorClass['Electrovanne'][actuator.rstrip(' +') + ' -']
except:
actuatorDown = self.root.interface.actuatorClass['Electrovanne'][actuator]
objective = 4
# Récupération de son min et max
pressureActuator.Set(state = 1)
sleep(3)
pressureActuator.Set(state = 0)
val1 = positionSensor.Poll(5)
actuatorDown.Set(state= 1)
sleep(0.5)
val2 = positionSensor.Poll(5)
actuatorDown.Set(state= 0)
sleep(0.5)
val3 = positionSensor.Poll(5)
actuatorUp.Set(state= 1)
sleep(0.5)
val4 = positionSensor.Poll(5)
actuatorUp.Set(state= 0)
sleep(0.5)
val5 = positionSensor.Poll(5)
minSensor = min(val1, val2, val3, val4, val5)
maxSensor = min(val1, val2, val3, val4, val5)
# Vidage de la pression
scaling = self.robotAttributes['Sensors']['Pression']['Robot']['MarginScaling']
margin = self.robotAttributes['Margin']
while pressureSensor.Poll(100) > minPressure + margin*scaling:
for ev in evClassList:
ev.Set(state= 1)
sleep(0.5)
ev.Set(state= 0)
sleep(0.25)
# Augmentation de la pression max jusqu'à ce que l'actionneur effectue le nombre de va et vient ciblé
counter = 0
scalingSensor = self.robotAttributes['Sensors']['Position'][actuator.rstrip(' +-') + ' 1']['MarginScaling']
while counter < objective:
counter = 0
pressureActuator.Set(state = 1)
sleep(timer)
pressureActuator.Set(state = 0)
sleep(0.5)
self.robotAttributes['Sensors']['Pression']['Robot']['Max'] = pressureSensor.Poll(5)
print('new max pressure =', self.robotAttributes['Sensors']['Pression']['Robot']['Max'], 'timer =', timer)
while counter < objective:
val1 = positionSensor.Poll(5)
actuatorDown.Set(state= 1)
sleep(0.5)
val2 = positionSensor.Poll(5)
actuatorDown.Set(state= 0)
sleep(0.5)
val3 = positionSensor.Poll(5)
actuatorUp.Set(state= 1)
sleep(0.5)
val4 = positionSensor.Poll(5)
actuatorUp.Set(state= 0)
sleep(0.5)
val5 = positionSensor.Poll(5)
minTest = min(val1, val2, val3, val4, val5)
maxTest = min(val1, val2, val3, val4, val5)
if abs(minTest-minSensor) > margin*scalingSensor and abs(maxTest-maxSensor) > margin*scalingSensor:
break
counter += 1
print('counter = ', counter)
if counter != objective:
timer += 1
# Vidage de la pression
while pressureSensor.Poll(100) > minPressure + margin*scaling:
for ev in evClassList:
ev.Set(state= 1)
sleep(0.5)
ev.Set(state= 0)
sleep(0.25)
self.diagConsole.insert('end', "[AutoCalib] : Pression maximale atteinte à " + str(self.robotAttributes['Sensors']['Pression']['Robot']['Max']) + "V .")
self.diagConsole.itemconfig('end', fg= 'green')
self.root.update()
# Récupération du temps que met la pompe pour atteindre la pression max
self.diagConsole.insert('end', "[AutoCalib] : Détermination du temps de monté en pression...")
self.root.update()
self.robotAttributes['Actuators']['Electro_pompe']['Robot']['Time'] = self.root.interface.actuatorClass['Electro_pompe']['Robot'].GetTime(self.robotAttributes)
self.diagConsole.insert('end', "[AutoCalib] : La pompe met " + str(self.robotAttributes['Actuators']['Electro_pompe']['Robot']['Time']) + "sec à monter en pression.")
self.diagConsole.itemconfig('end', fg= 'green')
self.root.update()
# Détermination des min et max capteur position et de leur type
self.diagConsole.insert('end', "[AutoCalib] : Détermination du min/max des actionneurs et de leur type...")
self.root.update()
for subCategory in self.robotAttributes['Sensors']['Position']:
if self.robotAttributes['Type'] != 'Electrique':
pressureActuator.Set(state= 1)
while self.robotAttributes['Sensors']['Pression']['Robot']['Max'] > pressureSensor.Poll(50):
sleep(0.1)
pressureActuator.Set(state= 0)
self.robotAttributes['Sensors']['Position'][subCategory]['ActuatorType'] = self.root.interface.sensorClass['Position'][subCategory].GetActuatorType(self.robotAttributes)
if self.robotAttributes['Type'] != 'Electrique':
pressureActuator.Set(state= 1)
while self.robotAttributes['Sensors']['Pression']['Robot']['Max'] > pressureSensor.Poll(50):
sleep(0.1)
pressureActuator.Set(state= 0)
self.robotAttributes['Sensors']['Position'][subCategory]['Min'], self.robotAttributes['Sensors']['Position'][subCategory]['Max'] = self.root.interface.sensorClass['Position'][subCategory].GetMinMax(self.robotAttributes)
self.diagConsole.insert('end', "[AutoCalib] : Actionneur de " + str(subCategory) + " (Min: " + str(self.robotAttributes['Sensors']['Position'][subCategory]['Min']) + "V; Max: " + str(self.robotAttributes['Sensors']['Position'][subCategory]['Max']) + "V; Type: " + str(self.robotAttributes['Sensors']['Position'][subCategory]['ActuatorType']) + ").")
self.diagConsole.itemconfig('end', fg= 'green')
self.root.update()
self.robotAttributes['Sensors']['Vitesse']['Boîte de vitesses']['Min'], self.robotAttributes['Sensors']['Vitesse']['Boîte de vitesses']['Max'] = self.root.interface.sensorClass['Vitesse']['Boîte de vitesses'].GetMinMax(self.robotAttributes)
self.diagConsole.insert('end', "[AutoCalib] : Capteur de vitesse (Repos: " + str(self.robotAttributes['Sensors']['Vitesse']['Boîte de vitesses']['Min']) + "V; Nominal: " + str(self.robotAttributes['Sensors']['Vitesse']['Boîte de vitesses']['Max']) + "Hz).")
self.diagConsole.itemconfig('end', fg= 'green')
self.root.update()
# Récupération de la déviation des capteurs branchés
self.diagConsole.insert('end', "[AutoCalib] : Récupération de la déviation dégradée des capteurs...")
self.root.update()
print('début du calcul dev')
Popup(self, 1, texte= "Veuillez débrancher tous les capteurs et appuyer sur 'Continuer'", fermer= 'Continuer')
self.root.update()
for category in self.robotAttributes['Sensors']:
for subCategory in self.robotAttributes['Sensors'][category]:
tempList = []
for i in range(1000):
tempList.append(self.root.interface.sensorClass[category][subCategory].Poll())
avgVal = mean(tempList)
variance = 0
for i in tempList:
variance += (i - avgVal)**2
variance = variance / len(tempList)
self.robotAttributes['Sensors'][category][subCategory]['DeviationErr'] = round(variance**(0.5), 2)
print('fin du calcul dev')
print(self.robotAttributes)
self.diagConsole.insert('end', "[AutoCalib] : Déviation dégradée des capteurs enregistrée.")
self.diagConsole.itemconfig('end', fg= 'green')
self.root.update()
# Vidage de la pression
self.diagConsole.insert('end', "[AutoCalib] : Diminution de la pression...")
self.root.update()
for i in range(5):
for ev in evClassList:
ev.Set(state= 1)
sleep(0.5)
ev.Set(state= 0)
sleep(0.25)
self.diagConsole.insert('end', "[AutoCalib] : Fin de la calibration automatique.")
self.root.update()
self.centerFrame.place(relx = 0.20, rely= 0.20)
self.centerSubFrameBis.pack_forget()
return True
def Stop(self, pressureSensorTest=False):
# Affichage du nombre d'erreur avec un code couleur approrié
self.diagConsole.insert(
'end', "[AutoDiag] : Le diagnostic a trouvé " +
str(self.errCount) + " erreur(s).")
if self.errCount == 0:
self.diagConsole.itemconfig('end', fg='green')
self.root.update()
else:
self.diagConsole.itemconfig('end', fg='red')
self.root.update()
self.diagConsole.insert(
'end', "[AutoDiag] : Abaissement de la pression au minimum...")
self.root.update()
LowerPressure(self, pressureSensorTest)
self.diagConsole.insert(
'end', "[AutoDiag] : Création du résumé du diagnostic...")
self.root.update()
for category in self.sensorErrDict:
for subCategory in self.sensorErrDict[category]:
errors = self.sensorErrDict[category][subCategory]
if errors != []:
for error in errors:
self.diagConsole.insert(
'end', "[Conclusion] (" + category + ' ' +
subCategory + ") : " + error)
self.diagConsole.itemconfig('end', fg='blue')
self.root.update()
print('[Conclusion] (' + category + ' ' + subCategory +
') : ' + error)
for category in self.actuatorErrDict:
for subCategory in self.actuatorErrDict[category]:
errors = self.actuatorErrDict[category][subCategory]
if errors != []:
for error in errors:
self.diagConsole.insert(
'end', "[Conclusion] (" + category + ' ' +
subCategory + ") : " + error)
self.diagConsole.itemconfig('end', fg='blue')
self.root.update()
print('[Conclusion] (' + category + ' ' + subCategory +
') : ' + error)
self.diagConsole.insert('end',
"[AutoDiag] : Fin du diagnostic automatique.")
self.root.update()
sleep(0.5)
genRapport = Popup(self,
2,
texte="Voulez-vous générer un rapport ?",
valider="Oui",
fermer="Non")
if genRapport == True:
self.diagConsole.insert('end',
"[Rapport] : Génération du rapport...")
self.root.update()
pdf = PDF()
pdf.add_page()
pdf.setup()
pdf.add_robot(self.robotSelected.get())
for category in self.sensorErrDict:
for subCategory in self.sensorErrDict[category]:
errList = self.sensorErrDict[category][subCategory]
if len(errList) != 0:
for error in errList:
if 'Robot' in subCategory:
pdf.add_error('Pression', error)
elif 'Sélection' in subCategory:
pdf.add_error('Sélection', error)
elif 'Embrayage' in subCategory:
pdf.add_error('Embrayage', error)
elif 'Engagement' in subCategory:
pdf.add_error('Engagement', error)
else:
pdf.add_error('Autre', error)
for category in self.actuatorErrDict:
for subCategory in self.actuatorErrDict[category]:
errList = self.actuatorErrDict[category][subCategory]
if len(errList) != 0:
for error in errList:
if 'Robot' in subCategory:
pdf.add_error('Pression', error)
elif 'Sélection' in subCategory:
pdf.add_error('Sélection', error)
elif 'Embrayage' in subCategory:
pdf.add_error('Embrayage', error)
elif 'Engagement' in subCategory:
pdf.add_error('Engagement', error)
else:
pdf.add_error('Autre', error)
if pdf.errPre == 0:
if self.testPre:
pdf.add_error('Pression',
'Système hydraulique opérationnel')
else:
pdf.add_error('Pression', 'Système hydraulique non testé')
if pdf.errSel == 0:
if self.testSel:
pdf.add_error('Sélection',
'Système de sélection opérationnel')
else:
pdf.add_error('Sélection',
'Système de sélection non testé')
if pdf.errEmb == 0:
if self.testEmb:
pdf.add_error('Embrayage',
"Système d'embrayage opérationnel")
else:
pdf.add_error('Embrayage', "Système d'embrayage non testé")
if pdf.errEng == 0:
if self.testEng:
pdf.add_error('Engagement',
"Système d'engagement opérationnel")
else:
pdf.add_error('Engagement',
"Système d'engagement non testé")
if pdf.errAut == 0:
if self.testVit:
pdf.add_error('Autre', 'Capteur de vitesse opérationnel')
else:
pdf.add_error('Autre', 'Capteur de vitesse non testé')
self.diagConsole.insert('end',
"[Rapport] : Le rapport à été généré.")
self.root.update()
self.diagConsole.insert(
'end', "[Rapport] : Envoi du mail contenant le rapport...")
self.root.update()
pdf.set_receiver_email(
self.root.configDict['PDF_Generator']['ReceiverEmail'])
validation = pdf.done()
if validation:
self.diagConsole.insert(
'end', "[Rapport] : Le rapport à été envoyé.")
self.root.update()
else:
self.diagConsole.insert(
'end', "[Rapport] : Le rapport n'a pas pu être envoyé.")
self.root.update()
self.buttonRelancer.config(state='normal')
self.buttonRetour.config(state='normal')
return
def Valid(self):
# On rafraichit la page pour éviter les bugs
self.RefreshEntryNumber()
# On vide les listes de données pour éviter les duplicatas
self.sensorDict = {}
self.actuatorDict = {}
# On récupère le nombre de rapports et on vérifie qu'il vaut au moins 2
if self.numberOfGear.get() == '':
self.numberOfGear.set(0)
if int(self.numberOfGear.get()) < 2:
Popup(self, 1, texte="La robot doit avoir au moins deux rapports.")
return
# On ajoute les capteurs sélectionnés à notre liste de données capteurs et on vérifie qu'il n'y a pas de doublon
for i in range(len(self.sensorOMVarList)):
category = self.sensorOMVarList[i].get()
subCategory = self.sensorSubOMVarList[i].get()
try:
self.sensorDict[category]
except:
self.sensorDict[category] = {}
if subCategory in self.sensorDict[category]:
Popup(self,
1,
texte=
"La robot ne peut pas avoir deux fois le même capteur.")
return
self.sensorDict[category][subCategory] = (
self.root.interface.sensorClass[category]
[subCategory].GetdBValues())
# On ajoute les actionneurs sélectionnés à notre liste de données actionneurs et on vérifie qu'il n'y a pas de doublon
for i in range(len(self.actuatorOMVarList)):
category = self.actuatorOMVarList[i].get()
subCategory = self.actuatorSubOMVarList[i].get()
try:
self.actuatorDict[category]
except:
self.actuatorDict[category] = {}
if subCategory in self.actuatorDict[category]:
Popup(
self,
1,
texte=
"La robot ne peut pas avoir deux fois le même actionneur.")
return
for category in self.actuatorDict:
if subCategory in self.actuatorDict[category]:
Popup(
self,
1,
texte=
"La robot ne peut pas avoir deux actionneurs à la même position."
)
return
self.actuatorDict[category][subCategory] = (
self.root.interface.actuatorClass[category]
[subCategory].GetdBValues())
# On envoi le tout à la base de données et on vérifie qu'il n'y a pas eu d'erreur
retour = self.root.dB.AddRobot(self.nameRobot.get(),
int(self.numberOfGear.get()),
self.typeRobot.get(),
self.root.interface.margin,
self.sensorDict, self.actuatorDict)
if retour == False:
Popup(self,
1,
texte="La robot existe déjà ou le nom est invalide.")
return
Popup(self, 1, texte="La robot a bien été ajouté.")
# On remet à zéro la fenêtre
self.Reset()