Trackeur GPS pour la cartographie de locaux

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.