Tuteurs: Stéphane BAZEILLE et Nicolas VERRIER
Groupe: Yassine AMIAR et Farès KHALFALLAH
Sommaire :
I) Présentation générale du projet
- Contexte et principe
- Liste de matériel et logiciel utilisé
- Diagramme de bête à cornes
- Diagramme pieuvre
II) Gestion et réalisation du projet
- Exploitation et activation des capteurs
- GPS
- Caméra
- Centrale inertielle
- Programmation
- Coordonnées GPS
- Photos
- Interface
- Finalisation
- Difficultés rencontrées
III) Conclusion
- Remerciements
I) Présentation générale du projet
- Contexte et principe
Le projet trackeur GPS pour la cartographie de locaux a pour objectifs grâce à un dispositif créées par nos soins d’enregistrer le parcours fait lors de déplacement, dans notre cas nous avons parcouru l’enceinte de l’IUT. Suite à cela les informations du parcours sont enregistré et retranscrites sur un site internet ainsi que sur un fichier dans la mémoire de la Raspberry PI. Pour mettre à bien ce projet nous sommes compose d’un binôme.
Le principe est de retracer le trajet parcouru par l’utilisateur. Pour ce faire, il faut tout d’abord commencer par étudier les comportements des différents capteurs ( GPS, Centrale Inertielle, Caméra), puis de la carte Raspberry PI. Une fois ces tâches achevées, il faut programmer chaque capteur dans un programme différent afin d’arriver à ses fins sans risques de perdre toute la progression sur une petite erreur. Pour finir, il faut créer une interface afin de pouvoir lancer l’application et visualiser quelques données.
- Liste de matériel et logiciel utilisé:
- Raspberry PI
- Batterie externe
- Caméra
- Boîtier
- Ecran
- Langage Python
- GPS
- Diagramme bête à cornes
- Diagramme pieuvre
A partir du diagramme pieuvre on réalise le tableau des fonctions pieuvre le tout en détaillant chaque fonction principale dite FP dans notre cas seulement FP1 mais également les fonctions contraintes dite FC qui vont de FC1 à FC7 dans notre cas.
II) Gestion et réalisation du projet
- Exploitation et activation des capteurs
- GPS
Pour commencer, nous avons tout d’abord pris connaissance du module GPS dont nous disposions.
Après avoir pris connaissance du GPS, il a fallu le configurer sur la Raspberry PI afin de pouvoir récupérer les coordonnées sur la carte.
Pour cela, il a tout d’abord fallu installer le module GPSD grâce à cette ligne de commande:
sudo apt-get install gpsd gpsd-clients python-gps
Puis désactiver le gps:
sudo systemctl stop gpsd.socket
sudo systemctl disable gpsd.socket
Ensuite le réactiver :
sudo systemctl enable gpsd.socket
sudo systemctl start gpsd.socket
Finalement, nous avons pu visualiser les données obtenues grâce au GPS:
gpsmon
Voici ce que nous obtenons:
Nous remarquons que grâce au GPS, nous obtenons la date, l’heure ainsi que les coordonnées longitude, latitude et l’altitude. Nous verrons plus tard comment exploiter ces données pour notre projet.
- Exploitation et activation des capteurs
- Caméra
Pour régler la caméra, il faut tout d’abord l’autoriser à communiquer avec la Raspberry Pi en la paramétrant en rentrant la commande:
sudo raspi-config
Puis ensuite paramétrer ainsi:
Une fois ceci fait, nous pouvons brancher la PiCaméra à la Raspberry PI puis redémarrer le système.
Nous verrons plus tard en détail le programme qui permet de photographier avec la PiCaméra.
- Exploitation et activation des capteurs
- Centrale inertielle
Afin de nous repérer et pouvoir guider l’utilisateur à l’intérieur d’un bâtiment de l’IUT, nous avons pensé à utiliser une centrale inertielle qui calculerait la trajectoire lorsque l’on perd le signal GPS car il est impossible d’obtenir un signal GPS au sein d’un bâtiment avec un tel module GPS.
Nous avons tout d’abord essayé d’étudier la précision du capteur. Pour ce faire, nous avons placé le capteur sur un banc afin de pouvoir effectuer des trajectoires droites dans une seule direction verticale et horizontale (x ou y). Nous avons donc branché le capteur aux bonnes entrées de la Raspberry PI grâce à des câbles puis créer un petit programme afin de relever les données obtenues avec ce capteur.
Suite à un changement de groupe et donc une baisse d’effectif dans le groupe de ce projet, nous avons été contraints d’abandonner cette partie du projet…
- Programmation
- Coordonnées GPS
Dans cette partie, nous verrons les différents programmes utilisés pour ce projet. Commençons par le GPS.
Pour le GPS, nous devions tout d’abord récupérer les données captées par le GPS (Longitude, Latitude) grâce à ce programme trouvé sur internet que nous avons adapté à nos beoins:
port = '/dev/ttyAMA0' #Sélection du port du GPS
gpsd = gps(mode=WATCH_ENABLE|WATCH_NEWSTYLE)
list_lat = [] #création de listes pour stocker les coordonnées
list_lon = []
x = [] #Coordonnées X
y = [] #Coordonnées Y
D = [] #Distance parcourue
i=1
try:
while True:
report = gpsd.next() #
if report['class'] == 'TPV':
lat = getattr(report, 'lat', 0.0) #Récup latitude
lon = getattr(report, 'lon', 0.0) #Récup longitude
Temps = getattr(report, 'time','') #Récup temps
Cependant, les coordonnées récupérées de cette manière sont des coordonnées brutes avec lesquelles nous ne pouvons pas nous repérer et tracer le trajet effectué. Pour remédier à cela, nous devons convertir les coordonnées GPS en coordonnées cartésiennes:
calc_lat = (6371*cos(float(lat))*cos(float(lon))) #conversion latitude calc_lon = (6371*cos(float(lat))*sin(float(lon))) #conversion longitude list_lat.append(calc_lat) #stock les données converties dans les listes list_lon.append(calc_lon) #Conversion des données converties en points cartésiens X et Y x1 = float(list_lat[0]-list_lat[i-1]) y1 = float(list_lon[0]-list_lon[i-1]) x.append(x1) y.append(y1) #Calcul de la distance parcourue grâce à un calcul de distance entre deux vecteurs qui calcule la distance entre le point actuel et le point précédent puis qui s'additionne au fil du temps. calc_dist = sqrt((x[i-1])**2+(y[i-1])**2) D.append(calc_dist)
Ensuite, nous affichons les valeurs que nous avons calculé:
print "Coordonnees x : ",x[i-1] print "Coordonnees y : ",y[i-1] print "Distance parcourue : ",D[0]+D[i-1]," m" i=i+1 #Incrémentation pour mesure d'un nouveau point de position
Pour avoir le tracé du parcours effectué, nous devons tracer un « graphique » des points x et y et l’afficher ensuite:
plt.plot(x,y) #Traçage d'un point en fonction de x et y
time.sleep(1) #Attente d'une seconde pour recommencer la boucle
os.system("clear") #Actualisation de la fenêtre d'affichage
Nous affichons simplement le tracé final une fois que nous fermons l’application:
plt.show() #Affichage du tracé
Grâce à ce programme simple, nous pouvons déjà obtenir un tracé du parcours effectué, avec en temps réel la distance parcourue et la position cartésienne x et y. Cependant, les coordonnées obtenues contenaient beaucoup de chiffres après la virgule, pour y remédier nous avons fait ainsi:
xi=str(x[i-1]) yi=str(y[i-1]) di=str(D[0]+D[i-1]) #Ensuite nous affichons seulement les 6 premiers caractères de ces données: print "...",xi[0:5] print "...",yi[0:5] print "...",di[0:5]
- Programmation
- Photos
Pour la prise de photos lors du trajet, nous avons fait un programme simple de prise de photos. Ceci est un programme pour prendre 5 photos à une intervalle de 30 secondes entre chaque photos. Il faut ensuite l’adapter à nos besoins, c’est-à-dire, prendre des photos du début du trajet jusqu’à la fin.
from picamer import PiCamera #Importation des librairies nécessaires
from time import sleep
camera = Picamera() #Choix de la caméra
camera.resolution = (1024,768) #Choix de la résolution de la caméra
camera.rotation = 180 #Rotation de la caméra à 180° selon sa position car elle est placée à l'envers
i=0
while i<5:
#Choix de la direction des photos
chaine1=('/home/pi/Desktop/Photos_projet/image%d.jpeg')%i
#Prévisualisation de la photo
camera.start_preview(fullscreen = False, window = (50,50,640,480))
sleep(1.5) #Attente de 1,5 seconde pour la visualisation
camera.capture(chaine1) #Prise de la photo
camera.stop_preview() #Arret de la visualisation
print ('photo numero ', i+1, 'prise')
i=i+1 #Incrémentation du numéro de la photo
sleep(30) #Attente de 30s pour la prochaine photos
Une fois ce programme adapté à nos besoins, nous l’ajoutons au programme principal. Pour notre cas, il fallait le rajouter au programme principal, nous avons donc choisi cette solution:
j=0
#Effectuer cette tâche uniquement lorsque i est un multiple de 30 (soit toutes les 30 secondes)
if i%30==0 :
chaine1=('/home/pi/Desktop/Photos_projet/image%d.jpeg')%i
camera.capture(chaine1)
j = j+1 #Comptage du nombre de photos prises
- Programmation
- Interface
Pour une question d’esthétique, nous créons une interface afin de visualiser le tout sur une seule fenêtre. Nous utilisons ici la librairie Tkinter fin de la créer. Voici le programme crée pour l’interface:
from Tkinter import*
fenetre = Tk()
fenetre.title('Trackeur GPS') #Titre de la fenêtre d'interface
#Création du label fenetre qui contiendra les objets (frame)
champ_label = label(fenetre)
cadre = Frame(fenetre, width=300, height=150, borderwidth=1)
cadre.pack(fill=BOTH)
#Création du premier 'frame' qui contiendra du texte
pos_x = Frame(fenetre, width=20, height=50, borderwidth=1)
ligne_texte = Label(pos_x, text=("position x = "+str(x[i-1])),width=30
ligne texte.pack(side="left")
pos_x.pack(fill=BOTH)
#Création du deuxième 'frame' qui contiendra du texte
pos_y = Frame(fenetre, width=20, height=50, borderwidth=1)
ligne_texte2=Label(pos_y, text=("Position y = "+str(y[i-1])), width=30)
ligne_texte2.pack(side="left")
pos_y.pack(fill=BOTH)
#Création du troisième 'frame' qui contiendra du texte
dist = Frame(fenetre, width=20, height=50, borderwidth=1)
ligne_texte3=Label(dist, text=("Distance parcourue = "+str(D[0]+D[i-1])+" m"), width=30)
ligne_texte3.pack(side="left")
dist.pack(fill=BOTH)
#Création du quatrième 'frame' qui contiendra le nombre de photos prises depuis le début du trajet
nb_ph = Frame(fenetre, width=20, height=50, borderwidth=1)
ligne_texte4=Label(dist, text=("Photos prises : "+str(j)), width=30)
ligne_texte4.pack(side="left")
dist.pack(fill=BOTH)
#Création d'un bouton 'Quitter'
Bouton_Quitter = Button(cadre, fg="red", text = "quitter", command = fenetre.destroy
Bouton_Quitter.pack(side="right")
champ_label.pack()
fenetre.update() #Actualisation de la fenêtre
Une fois tous ces programmes achevés, nous les mettons ensemble sur un seul programme afin d’avoir la totalité de l’application sur un seul programme, ce qui nous permettra de lancer un trajet et de l’arrêter lorsqu’on le souhaite.
- Finalisation
Le système terminé, il ne fonctionne malheureusement pas comme on le souhaiterait. En effet, l’interface ne fonctionne pas comme prévu car lorsque les positions se mettent à jour, l’interface précédente reste présente et les nouvelles s’accumulent en dessous de celle-ci.
De plus, le module GPS que nous utilisons n’est pas très stable au vu de sa position dans le boîtier car il est « enfermé » ce qui crée des perturbations et donc fausse les données du tracking.
- Difficultés rencontrées
Nous avons rencontré plusieurs difficultés au cours de ce projet. Premièrement, nous ne connaissions rien à propos de la Raspberry PI, ce fut pour nous une très bonne découverte.
De plus, le changement de groupe nous a contraint à devoir abandonner une partie du projet. Cela nous a aussi quelque peu ralenti.
Le module GPS met beaucoup de temps pour capter des satellites lors de la mise en tension. Ceci est encore plus ralenti lorsque le ciel est couvert.
III) Conclusion
Pour conclure, malgré que le projet ne soit pas fonctionnel à 100% et ne fonctionne pas comme nous le voudrions, nous avons beaucoup avancé et il nous a vraiment plu car il était très agréable à réaliser et il nous a permis de développer des compétences en programmation ainsi que de découvrir ce qu’est le Raspberry PI et toutes ces fonctionnalités. Il nous a aussi permis d’effectuer un agréable travail d’équipe, ce qui est très intéressant.
- Remerciements
Nous tenons à remercier tout d’abord M.VERRIER Nicolas et M.BAZEILLE Stéphane non seulement pour nous avoir aidé mais également guidé tout au long du projet. Nous tenons à remercier également M.DE SABBATA qui nous a laissé accès à l’IUT LAB sans modération.
