Projet Si


Projet Chronométrage #log1, le Dimanche 03 Janvier 2016 à 14:48 par Th3maz1ng

Présentation : 
Nous avons pour objectif de réaliser un système permettant de chronométrer le temps parcouru par une voiture entre deux points bien précis.
Pour cela nous aurons à notre disposition :

  1. Une carte raspberry pi II
  2. Une caméra
  3. Un émetteur/capteur à ultrasson 
  4. Un potentiomètre 
  5. Un servomoteur

Le principe est le suivant, le capteur à ultrasson aura pour but de mesurer la distance entre la caméra et les deux plot qui délimiterons la zone de chronométrage.
Ensuite, on relève l'angle avec un potentiomètre et à l'aide du théorème d'
al kashi on en déduit la longueur de la piste qui est à la base inconnue.

Voici un schéma : 


La caméra quand à elle servira à démarrer le chronométrage quand la voiture dépassera le premier plot et arrêtera se dernier lorsque la voiture dépassera le deuxième plot.


Les contraintes que nous avons sont les suivantes :

  1. Piste de 10m à 100m
  2. Montage, réglage et démontage en moins de 5 minutes
  3. Masse du système n'excedant pas 10 kg
  4. Précision de la mesure à 0,01 s

Nous travaillerons donc sous un environnement linux (raspbian) (DEBIAN), documentation sur les commandes linux : ici
avec processing pour le traîtement d'image.


Projet Chronométrage #log2, le Lundi 04 Janvier 2016 à 22:17 par Th3maz1ng

Présentation :
Voici le contenu de la seconde séance.
Nous avons, durant cette dernière, fait une batterie de test avec un capteur à ultrasson, un potentiomètre et une carte arduino afin de calculer la longueur de la piste.
La fonction de chacun :

Nous avons pour celà utilisé le théorème d'al kachi qui s'applique dans n'importe quel triangle.

Nous avons également relevé de façon plus pécise les caracéristiques de la raspberry pi 2 model B :


Projet Chronométrage #log3, le Vendredi 18 Mars 2016 à 16:00 par Th3maz1ng

Avancement :
Nous avons depuis le dernier log fait une série de paramétrage et de test avec la raspberry:

  1. Paramétrage :

Nous avons commencé par installer le système d'exploitation sur la carte SD de la raspberry. Nous avons choisi la variante avec une interface graphique car se serait plus simple de faire les test avec la camera dans ces conditions.

Ceci étant fait, nous avons ensuite connecté la raspberry, à l'aide d'un cable RJ45, au réseau afin de permettre à tout les membres du groupe de prendre la main sur la raspberry depuis n'importe quel ordinateur afin de travailler sur le projet en même temps. Cette connexion établie par SSH nous a également permit d'utiliser un client FTP (File Transfer Protocol) tel que FileZilla pour envoyer des fichier directement sur la raspberry. Nous avions donc la possibilité de coder sur un ordinateur avec un éditeur de code tel que notepad++ et de tout simplement transférer le fichier sur la raspberry.

      2. Tests

Partie capteur ultrasson

Le premier test à été, de lire le capteur à ultrasson, par l'intermédiaire de l'interface GPIO (
General Purpose Input/Output). Pour cela, nous avons travaillé à partir d'un code type en python :
Le voici  :

#!/usr/bin/python
#+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
#|R|a|s|p|b|e|r|r|y|P|i|-|S|p|y|.|c|o|.|u|k|
#+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
#
# ultrasonic_1.py
# Measure distance using an ultrasonic module
#
# Author : Matt Hawkins
# Date   : 09/01/2013

# Import required Python libraries
import time
import RPi.GPIO as GPIO

# Use BCM GPIO references
# instead of physical pin numbers
GPIO.setmode(GPIO.BCM)

# Define GPIO to use on Pi
GPIO_TRIGGER = 23
GPIO_ECHO = 24

print "Ultrasonic Measurement"

# Set pins as output and input
GPIO.setup(GPIO_TRIGGER,GPIO.OUT)  # Trigger
GPIO.setup(GPIO_ECHO,GPIO.IN)      # Echo

# Set trigger to False (Low)
GPIO.output(GPIO_TRIGGER, False)

# Allow module to settle
time.sleep(0.5)

# Send 10us pulse to trigger
GPIO.output(GPIO_TRIGGER, True)
time.sleep(0.00001)
GPIO.output(GPIO_TRIGGER, False)
start = time.time()
while GPIO.input(GPIO_ECHO)==0:
  start = time.time()

while GPIO.input(GPIO_ECHO)==1:
  stop = time.time()

# Calculate pulse length
elapsed = stop-start

# Distance pulse travelled in that time is time
# multiplied by the speed of sound (cm/s)
distance = elapsed * 34000

# That was the distance there and back so halve the value
distance = distance / 2

print "Distance : %.1f" % distance

# Reset GPIO settings
GPIO.cleanup()

Nous avons donc réussi à relever la distance séparant le capteur et d'un objet avec une précision acceptable (1/2cm).

Partie servomoteur

Nous sommes ensuite passé sur la phase de controle du servomoteur. Pour cela nous avons également utilisé un code type lui aussi en python afin de réaliser les premiers essais avec ce périphérique. Nous utilisons cette fois encore l'interface GPIO.
Le voici :

#!/usr/bin/env python
# -*- coding: latin-1 -*-

'''
Contrôle d'un servomoteur avec un Raspberry Pi
Le servo tourne lentement dans une direction, et
retourne rapidement à sa position de départ.
electroniqueamateur.blogspot.com
'''

import RPi.GPIO as GPIO
import time

servo_pin = 12  # gpio18

depart = 3      # rapport cyclique pour que le servo 
                # soit au début de son mouvement
                # à ajuster pour votre servo!

arrivee = 11    # rapport cyclique pour que le servo 
                # soit à la fin de son mouvement
                # à ajuster pour votre servo!
     
GPIO.setmode(GPIO.BOARD)  # notation board plutôt que BCM

GPIO.setup(servo_pin, GPIO.OUT)  # pin configurée en sortie

pwm = GPIO.PWM(servo_pin, 50)  # pwm à une fréquence de 50 Hz
position = depart   # on commence à la position de départ

pwm.start(depart)  # on commence le signal pwm



while True:

    if position < arrivee:  # si nous ne sommes pas pas arrivés, 
                            # nous avançons un peu
         pwm.ChangeDutyCycle(float(position))  
         position = position + 0.1
         time.sleep (0.1)
    else:
         position = depart  # si nous sommes arrivés, 
                            # retour à la position de départ
pwm.stop

 Ce code nous a permis d'évaluer la précision du servo moteur. Mais nous avons rencontré un problème : le servo moteur tremble de facon importante lorsqu'il doit conserver une position précise. Or, ce tremblement est tres dérangent pour effectuer des mesures d'angles et de distances précises (Alkachi). Ce tremblement est dû au fait que la raspberry gère plusieurs files d'executions en même temps, en d'autre thermes, elle est incapable de se concentrer sur un thread en particulier. La pwm n'est donc pas assez régulière pour conserver une position précise.

Nous avons donc chercher une autre alternative pour controler le servomoteur. Nous avons donc pensé à controler ce dernier par l'intermédiaire d'une carte arduino qui serait connecté à la raspberry pour pouvoir récupérer la valeur de l'angle. Nous pourrions également commander l'émetteur à ultrasson par l'intermédiaire de cette dernière. Nous sommes donc encore, à l'heure actuelle, dans la recherche de la solution au niveaux informatique et compatible avec la raspberry.

Partie caméra

Pendant ce temps, le second groupe a travaillé sur le traîtement d'image sur la raspberry. Nous avons donc commencé par connecter avec succès la camera fournie pour le model que nous avions. Nous avons ensuite travaillé avec une librairie graphique en python très simple d'utilisation. Nous sommes parvenue à capturer une image et a en faire l'analyse. Cette analyse consistait à recuperer la valeur RGB de chaques pixel composant l'image pour détecter la gomette de couleur présente sur le vehicule. Maleuhresement pour une image de  360x300 pixel (108000), il fallait 9 secondes pour faire l'analyse. Cette lenteur est une contrainte majeur pour la précision du chronométrage.
voici un exemple de code :

from imgproc import *

# open the webcam
my_camera = Camera(360, 300)
# grab an image from the camera
my_image = my_camera.grabImage()

# open a view, setting the view to the size of the captured image
my_view = Viewer(my_image.width, my_image.height, "Basic image processing")

# display the image on the screen
my_view.displayImage(my_image)

# wait for 5 seconds, so we can see the image
waitTime(5000)

Cette bibliothèque graphique était donc simple d'utlisation, mais peu performante et optimisé. Par conséquent nous avons décidé de chercher une équivalence. Nous avons donc trouvé pygame et opencv. Nous n'avons pas encore eu le temps de les tester.


Projet Chronométrage #log4, le Jeudi 12 Mai 2016 à 10:06 par Th3maz1ng

Code pour la mesure avec arduino
Voici le code que nous avons utilisé pour faire les mesures avec arduino.

Ce code effectue les actions suivantes dans l'ordre :

  1. Positionner le servo moteur en position centrale;
  2. Faire tourner le servo moteur du centre vers la droite degré par degré et mesurer les distances à chaque degré;
  3. Comparer la distance précédente avec la distance suivante afin de détecter un obstacle;
  4. Relever la distance et l'angle lors de la détection de l'obstacle;
  5. Remettre le servo moteur en position centrale;
  6. Faire tourner le servo moteur du centre vers la gauche degré par degré et mesurer les distances à chaque degré;
  7. Comparer la distance précédente avec la distance suivante afin de détecter un obstacle;
  8. Relever la distance et l'angle lors de la détection du second obstacle;
  9. Remettre le servo moteur en position centrale;
  10. Appliquer le théorême d'alkachi pour trouver la longueur de la piste;
  11. Afficher le résultat;
#include 
#define pos_milieu 85
/*Définition pin servo motor*/
const int Servo_socket = 3;
/*Définition pin ultrasson*/
const int trigPin = 2,echoPin = 4;
/*Variables for the measurement*/
long timer = 0,cm = 0, distance_snapshot = 0, distancePiste = 0, angleTotal = 0;

/*Servo def         inition*/
Servo servo_ultrasson;
/*Angle setup*/
int angle = pos_milieu,on_off = true , longueurPlot1 = 0, longueurPlot2 = 0;
/*Angle min : 13
Angle max :167*/


void setup() 
{
  // put your setup code here, to run once:
  servo_ultrasson.attach(Servo_socket);
  /*Mise a la position 0*/
  servo_ultrasson.write(angle); 
  /* initialize serial communication:*/
  Serial.begin(9600);

}

void loop() 
{
   /*Temps de preparation*/
   delay(1000);
  if(on_off)
  {
     //Code scan servomotor
     for(angle; angle>=13; angle--)
     {
        distance_snapshot = distanceMeasurement();
        servo_ultrasson.write(angle);
        delay(100);
        Serial.print(distance_snapshot);
        Serial.print("cm");
        Serial.println();
        if(distance_snapshot<100)
        {
          Serial.println();
          Serial.print(20+(85-angle)*1.25);
          Serial.print(" angle 1er plot");
          Serial.println();
          /*Save angle and distance*/
          angleTotal = 20+(85-angle)*1.25;
          longueurPlot1 = distance_snapshot;
          break;
        }
     }
     
     
     /*Mise a la position 0*/
     servo_ultrasson.write(angle = pos_milieu);
     delay(500);
     

     for(angle; angle<=167; angle++)
     {
        distance_snapshot = distanceMeasurement();
        servo_ultrasson.write(angle);
        delay(100);
        Serial.print(distance_snapshot);
        Serial.print("cm");
        Serial.println();
        
        if(distance_snapshot<100)
        {
          Serial.println();
          Serial.print(12+(angle-85)*1.25);
          Serial.print(" angle 2eme plot");
          Serial.println();
          /*Save angle and distance*/
          angleTotal += 12+(angle-85)*1.25;
          longueurPlot2 = distance_snapshot;
          break;
        }
     }

     /*Mise a la position 0*/
     servo_ultrasson.write(angle = pos_milieu);
     /*Afficher longueur piste*/
     distancePiste = sqrt(longueurPlot1*longueurPlot1+longueurPlot2*longueurPlot2-2*longueurPlot1*longueurPlot2*cos(PI*(angleTotal)/180));
     Serial.println();
     Serial.print(distancePiste);
     Serial.print("------> Longueur piste");
     Serial.println();
      
  }
  on_off = false;
}

int distanceMeasurement()
{
  // put your main code here, to run repeatedly:
  // The sensor is triggered by a HIGH pulse of 10 or more microseconds.
  // Give a short LOW pulse beforehand to ensure a clean HIGH pulse:
  pinMode(trigPin, OUTPUT);
  digitalWrite(trigPin, LOW);
  delayMicroseconds(2);
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);

  // Read the signal from the sensor: a HIGH pulse whose
  // duration is the time (in microseconds) from the sending
  // of the ping to the reception of its echo off of an object.
  pinMode(echoPin, INPUT);
  timer = pulseIn(echoPin, HIGH);

  // convert the time into a distance
  cm = microsecondsToCentimeters(timer);

  return cm;
  
  delay(200);
}

long microsecondsToCentimeters(long microseconds)
{
  // The speed of sound is 340 m/s or 29 microseconds per centimeter.
  // The ping travels out and back, so to find the distance of the
  // object we take half of the distance travelled.
  return microseconds / 29 / 2;
}

 Voici l'algorigramme correspondant :Lien de téléchargement : Algorigramme

Données mesurés :

Mesures Réalité
76 82
74 76
69 71
86 88
92 95


Code recherche identifiant, le Jeudi 12 Janvier 2017 à 14:39 par Th3maz1ng

int rechercherIdentifiantJeuxLibre(Jeux jeux,const char *typeJeu)
{
    Bool estTrouve = false;

    while(jeux != NULL)
    {
        if(strcmp(typeJeu, jeux->typeJeu) == 0)
        {
            estTrouve = true;
            if(jeux->estLibre == 1)
            {
                return jeux->referenceJeu;
            }
        }
        jeux = jeux->prochain;
    }

    if(estTrouve)
        printf("Le jeu est libre, mais pas disponible\n");
    else
        printf("Jeu non trouve\n");
    return -1;
}