Le code se trouve sur le document interface.py
Dans un premier temps, il y a l’importation des différentes librairies comme matplotlib pour définir des courbes ou encore tkinter pour créer une interface.

La classe principale se prénomme Graphique, on fait donc une fonction d'initialisation qui permet de determiner la forme de l'interface.

Ensuite, on souhaite que notre interface ait trois pages, on crée alors trois classes pour chacune des pages.

Première Page - Page d'accueil

La première est StartPage, ca sera la page d'accueil.
Dans cette page, on retrouve plusieurs boutons qui permettent de rediriger vers les autres pages.
On définit un bouton avec l'instruction tk.Button, elle s'appelle ainsi car on a importé tkinter en l'appelant tk (import tkinter as tk).
En paramètre, il y a le texte écrit sur le bouton et la page vers laquelle ce bouton redirige l'utilisateur.

  button = tk.Button(self, text = "Afficher la température", command = lambda: controller.show_frame(PageOne))

Par exemple, on peut lire Afficher la température sur ce bouton, il redirige vers une autre page , appelé PageOne (corresponsant au nom de la classe de cette page)

Deux autres boutons permettant de rediriger vers le controle des Leds et le formulaire fonctionnent de la même manière.

Un menu en haut à droite est aussi affiché.
On définit la place du menu, sa taille et sa couleur. grâce à zoneMenu.
On choisit ensuite différents onglets, ici il y en 4 (Fichier, Edition,Format,Affichage)
Chaque onglet dspose d'un menu déroulant qu'on déclare. Par exemple pour le menuAffichage:

   menuDeroulant1 = Menu(menuAffichage)

menuAffichage étant le nom du bouton de l'onglet.
Ainsi, pour chaque option du menu déroulant, on ajoute un label et une commande qui permettra d'executer la fonction voulue.
Pour l'affichage, on peut changer la couleur de fonc par exemple.

Des options plus utiles sont l'ouverture de fichier ou encore la fermeture de la fenêtre (avec quit).

Deuxième page, Affichage du graphe de la température

On nomme une deuxième classe PageOne
Cette page permettra à l'utilisateur d'actionner la prise de température et d'afficher les résultats sous forme de courbe.
On initialise cette page . Un label permet de mettre un titre en haut pour indiquer à l'utilisateur où il se trouve. On peut remplacer le titre en changeant le texte.

On trouve ensuite une fonction control, que j'expliquerais ensuite.
En arrivant sur cette page, on retrouve différents boutons. Il y a toujours les boutons de redirection vers d'autres pages. Un autre bouton,appelé Actionner déclenche la fonction control .
Lorsque l'on appuie sur ce bouton, on définit une variable qui prend en compte les valeurs de l'arduino :

• ser = serial.Serial('/dev/ttyACM0',9600)

On définit donc le port série de l'arduino (ici /dev/ttyACM0) afin de récuperer les données de l'arduino avec serial.Serial

Aussi, un nouveau label apparait grâce à l'instruction tk.Label, il est écrit: Combien de points souhaitez-vous mesurer ?
En bas de la page, un espace d'écriture est aussi apparu, il est la grâce à l'instruction Entry.
Ainsi, l'utilisateur peut répondre à la question dans l'espace dédié'appelé entree1', pour enregistrer la valeur prise, il faut appuyer sur le bouton Valider.
Ce bouton permet de déclencher la fonction getEntry().

Cette fonction permet d'abord de récupérer la valeur entrée par l'utilisateur grâce à la commande :

 - res = entree1.get()

Ainsi, cette valeur est stockée dans la variable res.
Le but ensuite de cette fonction est de récupérer les valeurs venant de l'arduino dans un fichier texte et d'afficher une courbe grâce à ce fichier.

On créé alors un tableau vide appelé rawdata dans lequel on va stocker les données.
On initialise un compteur (nommé compt) à 0.
Tant que le compteur est inférieur au nombre donné par l'utilisateur, le tableau rawdata récupère chaque ligne des datas envoyées par l'arduino grâce à la variable ser. Le compteur prend +1 à chaque tour de la boucle while.
On affiche ensuite ce rawdata sur le terminal.

Un problème est que rawdata s'affiche de cette manière sur le terminal :
["b'val1\\n'", "b'val2\\n'", "b'val\\n'"]
On voudrait la même chose sans le b et sans le \\n afin de récupérer les données de ce tableau.
Pour cela, on a crée la fonction nettoie.
Dans cette fonction, on définit d'abord un nouveau tableau newL, celui-ci est vide.
On utilise une boucle pour afin de parcourir notre tableau rawdata, et on remplit le nouveau tableau newL sans le b et sans le \\n .
On retourne ensuite ce nouveau tableau et on l'affiche dans le terminal.

L'objectif d'après est de remplir notre fichier texte. La fonction write existe pour cela.
On ouvre d'abord le fichieroù sont stockées les données (data.txt):

• file = open("data.txt", mode="w")

Ici, il est ouvert en mode écriture avec w .
Ensuite, on utilise une boucle pour afin de remplir chaque ligne de notre fichier avec chaque case du nouveau tableau nettoyé :

-     for i in range(len(L)):
                file.write(L[i]+'\n')

On ferme ensuite le fichier.

Ensuite, on peut afficher la courbe.
On définit d'abord le graphe avec l'instruction Figure

• f = Figure(figsize = (1,0.5), dpi = 25)

On determine ainsi la taille du graphe.
On souhaite avoir plusieurs courbes, pour cela, il exise la fonction add_subplot.
A notre courbe f, on pourra rajouter plus de courbes, avec en paramètre 111. Cela signifie que l'on ajoute une figure de taille 1 par 1 .
Tout ceci est stockée dans la variable a.
Enfin, on peut afficher cette courbe avec l'instruction plot:

• a.plot(np.loadtxt("data.txt",delimiter=' ',unpack=True))

On récupère donc les valeurs du fichier data.txt . Ne pas oublier le délimiteur, en effet, dans data.txt, il y a une valeur par ligne, ce qui délimite chaque valeur est donc un espace.

Avec

• FigureCanvasTkAgg(f,self)
• canvas.draw()

on affiche cette courbe.

Avec pack, on chosit l'emplacement de la courbe sur la page (TOP, LEFT ...)

Ensuite, on détermine une petite barre d'outil en bas de la page avec l'instruction NavigationToolbar2Tk(canvas,self). Elle permet de sauvegarder notre courbe avec le dernier petit onglet.

Si on veut afficher une deuxième ou troisème courbe, il suffit de renseigner de nouveau le nombre de points souhaités dans l'espace dédié et de valider cela grâce au bouton.

Deuxième Page - Le control des LEDS

On définit donc une classe PageTwo avec une fonction d'initialisation.
Un label permet d'indiquer que l'on est sur la page "Controler les LEDs"
Des boutons sont toujours présents pour rediriger vers d'autres pages.

On indique le port série utilisé, et on lit les données de ce port série grâce à serial.Serial, on stocke ces données dans la variable ser.
Sur cette page, il y a deux boutons en plus, un bouton on et un bouton off.
Le bouton on permet d'allumer la Led branchée sur la breadboard.
En effet, lors de notre code arduino on a indiqué que si les données envoyées étaient 1, la led s'allume, si les données sont 0, alors la led s'éteint.

Ainsi, lorsque l'on appuie sur le bouton on, on appelle la fonction on_button qui rajoute sur les données provenant d'arduino le chiffre 1.
Lorsque l'arduino lit cela, son code lui indique que la led doit s'allumer.

A l'inverse, si on appelle la fonction off_button en appuyant sur off, on rajoute un sur le serial, donc on indique à l'arduino que la led doit s'éteindre.

Troisième Page - formulaire

Cette page met en place un formulaire.
Un label indique que l'on est sur la page formulaire.
Un bouton permet de revenir à l'accueil.
Ici, les deux seules options du formulaire sont de rentrer un nom et un prénom. Ainsi, deux espaces d'écriture sont créés avec deux labels pour indiquer à quoi ils correspondent.
Ces espaces d'écritures sont créées grâce à l'instruction Entry().

Ce formulaire s'arrête ici. Cependant, une autre possibilité que je n'ai pas faite est de récupérer les données rentrées.
Pour cela, on se rappelle le nombre de points que veut l'utilisateur.
On définit alors un bouton Valider.
Ce bouton valider redirige vers une fonction que l'on appelle commme on le souhaite .
On récupère chaque donnée rentrée avec un .get et on le stocker dans une variable.
Par exemple, si le nom de notre espace d'écriture est donnee1.
Pour récuperer cette donnée, on inscrit dans la fonction :

• val = donnee1.get()

Si la valeur est un entier et que l'on souhaite s'en resservir, il faut forcer le typage. En effet, val est comprise ici comme une chaine de caractère, si on veut s'en servir comme un chiffre, on écrira int(val) au lieu de val.

Dernière partie

Une fois chaque page crééé, on affiche notre interface en appelant notre classe de départ Graphique et grâce à la fonction mainloop().

Pour déclencher le code, on se place dans le dossier correpondant et on rentre la commande suivante dans le terminal:

• python3 interface.py

Attention, si lorsque l'on lance le programme python , l'erreur suivante survient : ValueError: could not convert string to float: '' ,
Il faut ouvrir le fichier texte et vérifier qu'une ligne ne soit pas vide, ensuite il faut la remplacer avec un chiffre au hasard
Lors du déclenchement du bouton actionner, ces valeurs seront remplacées par les valeurs mesurées