Voiture VigiCar

Notre projet est une voiture commandée par USB. Lorsqu'elle détecte un obstacle, elle s'arrête et déclenche un signal d'alerte (Warning). Quand l'obstacle est enlevé, elle continue son chemin.

L'utilisateur peut donner différentes instructions : avancer, reculer, s’arrêter pendant une durée définie, ou exécuter une instruction tant qu'aucun obstacle n'est détecté.

Limitations et fonctionnalités

Taille de la carte : 10x10 cm maximum

Éclairage :
- 4 LEDs oranges à l'avant et à l'arrière pour les feux de warning
- 2 LEDs jaunes à l'avant pour les phares avant
- 2 LEDs blanches à l'arrière pour les feux de recul
- 2 LEDs rouges à l'arrière pour les feux stop

Programmation : Par USB
Gestion de l’énergie : Par batterie LiPo
Détection d'obstacles : Capteur de proximité placé à l'avant

Matériel

Batterie LiPo
Puce de contrôle MAX1811
4 LEDs oranges
2 LEDs jaunes (qui ressortent oranges au final)
2 LEDs blanches
2 LEDs rouges
2 Mini moteurs continus & Pilotes des moteurs
Capteur de proximité
Port USB

Déroulé du Projet

Séance du 5 Mars 2024

Nous avons choisi d'intégrer un capteur de proximité à notre voiture pour améliorer sa réactivité aux obstacles. Pour assurer une autonomie adéquate, nous utiliserons une alimentation par batterie. De plus, la voiture sera capable d'exécuter divers programmes prédéfinis, lui permettant de naviguer de manière autonome tout en répondant aux commandes de l'utilisateur.

Séance du 12 Mars 2024

Nous avons finalisé le choix des composants et commencé la conception du schéma électrique de notre PCB. Cependant, le problème qu'il pourrait y avoir en mettant les LEDs en série comme nous l'avons fait est qu'elle ne seront pas alimentées correctement. Nous allons donc les mettre en parallèle afin de résoudre cette complication. Dans tout les cas, cela ne posera pas de problème pour la programmation des LEDs.

Séance du 19 Mars 2024

Le schéma électrique est terminé. Nous avons corrigé le layout du PCB en respectant les contraintes de taille, le problème d'alimentation des LEDs, et nous avons rajouté les éléments manquants tels que l'alimentation et le contrôleur moteur.

Séance du 2 Avril 2024

Création de notre archive GIT pour la gestion des versions et le suivi du projet.

Voici notre lien git : VigiCar Git Archive

Séance du 7 Mai 2024

Nous avons reçu notre PCB. Nous commençons à souder les composants (ATmega16u4, Quartz, Port USB, ISP, etc.). L'ATmega16u4 a déjà un Bootloader préinstallé.

Séance du 14 Mai 2024

Nous avons continué les soudures, en particulier le contrôleur de moteur. Il reste maintenant à le tester.

Séance du 21 Mai 2024

Lors de la séance précédente, nous avions fini de souder le contrôleur de moteur. Nous soudons un des moteurs à l'aide de fils que nous replierons sur eux-mêmes à la fin. Pour tester le moteur, nous écrivons un programme.

Dans un premier temps, nous écrivons un programme qui consiste seulement à faire tourner le moteur :

Ensuite, nous cherchons à manipuler la vitesse de rotation du moteur. Nous écrivons un programme permettant d'augmenter progressivement la vitesse de ce dernier :

Séance du 28 Mai 2024

Lors de cette séance, nous nous sommes séparés pour, d'une part, réparer les problèmes de soudure des LEDs, souder le capteur de proximité et d'autre part, préparer un code pour manipuler les LEDs et vérifier leur fonctionnement.

Concernant la soudure du capteur de proximité, nous avons opté pour du "bricolage". En effet, le capteur devant être monté à la verticale, il faut relier les PINs du dessus à la carte. Pour cela nous utiliserons des fils.

A la première tentative, le capteur ne fonctionnait pas, nous avons donc cherché la cause de ce problème (test de la camera, mesure de la tension dans les PINs, etc.). En regardant la datasheet du capteur nous voyons que le capteur ne supporte une température de 260°C que pendant 10 secondes. Nous l'avions donc bien rendu inutilisable. Nous testons un nouveau capteur avant toute soudure. Nous le mettons en place sur la carte:

Nous avons donc ressoudé un autre capteur en faisant plus attention. Reste maintenant à le programmer. Voici une première version de notre code :

#include <util/delay.h>
#include <avr/io.h>

#define PWM_DDRB         DDRB
#define PWM_PORTB        PORTB
#define PWM_DDRD         DDRD
#define PWM_PORTD        PORTD
#define CAPTEUR         5
#define AIN1            6
#define AIN2            5
#define BIN1            1
#define BIN2            2
#define PWM1            7
#define PWM2            0

#define LED_G1 PF0
#define LED_G2 PF4
#define LED_D1 PC6
#define LED_D2 PD4
#define LED_STOP_G PF6
#define LED_STOP_D PD5
#define LED_PHARES_G PF1
#define LED_PHARES_D PC7
#define LED_RECUL_G PF7
#define LED_RECUL_D PD3
#define JTD 7

void PWM_init(void){               // Initialisation de la PWM
    PWM_DDRB |= (1<<PWM1);      // Les ports PWM sont des sorties
    PWM_DDRD |= (1<<PWM2);
    TCCR0A |= (1<<COM0A1)|(1<<COM0B1);   // Les ports PWM se comportent normalement
    TCCR0A |= (1<<WGM01)|(1<<WGM00);     // Minuteur mis en mode PWM
    TCCR0B |= (1<<CS00);                 // Pas de pré-diviseur, démarre le compteur
}

void LED_init(void)
{
    DDRD |= (1<<LED_D2) |(1<<LED_STOP_D)|(1<<LED_RECUL_D);
    DDRC |= (1<<LED_D1) |(1<<LED_PHARES_D);
    DDRF |= (1<<LED_G1) |(1<<LED_G2)|(1<<LED_STOP_G)|(1<<LED_PHARES_G) |(1<<LED_RECUL_G);
}

void capteur_init(void)
{
    DDRF &= ~(1<<CAPTEUR);
}
int main(void){

    CLKSEL0 = 0b00010101;   // sélection de l'horloge externe
    CLKSEL1 = 0b00001111;   // minimum de 8Mhz
    CLKPR = 0b10000000;     // modification du diviseur d'horloge (CLKPCE=1)
    CLKPR = 0;              // 0 pour pas de diviseur (diviseur de 1)
    
    MCUCR |= (1<<JTD);
    MCUCR |= (1<<JTD);
    PWM_init();
    LED_init();
    capteur_init();
    int pwm=0;
    PWM_DDRB |= (1<<AIN1)|(1<<AIN2);
    PWM_PORTB |= (1<<AIN1)|(0<<AIN2);
    PWM_DDRD |= (1<<BIN1)|(1<<BIN2);
    PWM_PORTD |= (0<<BIN1)|(1<<BIN2);
    while (1)
    {
        pwm++;
        if ((PORTF>>CAPTEUR) &1){
            pwm=0;
            PORTC|=0x00;
        }
        if (pwm >255) pwm=0;
        OCR0A=pwm;
        OCR0B=pwm;
        PORTC |=0b11000000;
        PORTD |=0b00111000; 
        PORTF |=0b11010011;  
        _delay_ms(100);
    }
    return 0;
}

Ce code nous a permi de vérifier le fonctionnement des LEDs mais pas celui du capteur pour le moment.

Séance du 4 Juin 2024

Aujourd'hui nous avons avancé sur le contrôle des LEDs et du capteur de proximité que nous avons enfin fait fonctionner. Nous avons désormais une voiture qui roule, phares allumés. Si elle rencontre un obstacle, elle s'arrête puis déclenche ses warnings. Elle possède aussi un bouton start qui lance le programme. Nous avons alors ajouter des fonctions à notre programme.

Cet ajout permet d'avoir une voiture qui s'arrête dès la détection d'un obstacle et qui donc allume ses feux stop.

void init_boutton(void)
{
    DDRD &= ~(1<<START);
    PORTD |= (1<<START);
}

void init_moteur(void)
{
        PWM_DDRB |= (1<<AIN1)|(1<<AIN2);
        PWM_DDRD |= (1<<BIN1)|(1<<BIN2);
}

void avancer(void)
{
    PWM_PORTB |= (1<<AIN1);
    PWM_PORTB &= ~(1<<AIN2);
    
    PWM_PORTD &= ~(1<<BIN1);
    PWM_PORTD |= (1<<BIN2);
    
    //PWM_PORTB |= (1<<AIN1)|(0<<AIN2);
    //PWM_PORTD |= (0<<BIN1)|(1<<BIN2);
    OCR0A=180;
    OCR0B=180;
}

void arret(void)
{
    PWM_PORTB &= ~(1<<AIN1);
    PWM_PORTB &= ~(1<<AIN2);
    
    PWM_PORTD &= ~(1<<BIN1);
    PWM_PORTD &= ~(1<<BIN2);
    
    //PWM_PORTB |= (0<<AIN1)|(0<<AIN2);
    //PWM_PORTD |= (0<<BIN1)|(0<<BIN2);
    OCR0A=0;
    OCR0B=0;
}

Explication sur la programmation du capteur:

Dans notre programme, nous utilisons le capteur OPB733TR pour mesurer une condition spécifique en lisant des valeurs analogiques. Ces valeurs, qui représentent les informations captées par le capteur, sont converties en signaux numériques que notre microcontrôleur peut traiter. Pour réaliser cette conversion, nous utilisons un Convertisseur Analogique-Numérique (ADC) intégré.

L'ADC agit comme un traducteur qui transforme les niveaux de tension analogiques en valeurs numériques compréhensibles par le microcontrôleur. Cette opération se déroule très rapidement grâce à l'ADC de notre microcontrôleur, qui peut effectuer des conversions en un temps très court. Cela nous permet de capturer et de traiter les informations du capteur presque instantanément.

Dans notre boucle principale, le microcontrôleur lit périodiquement les valeurs analogiques converties par l'ADC. Ces valeurs sont comparées à une limite prédéfinie (`LIMITE`), configurée pour déclencher des actions spécifiques lorsque les conditions détectées par le capteur le nécessitent. Si le capteur détecte une certaine condition (définie lorsque les valeurs analogiques sont inférieures à la limite), notre programme réagit en arrêtant la voiture, activant les feux de stop, les clignotants et même en mettant la voiture en marche arrière si nécessaire.

En parallèle, un compteur est utilisé pour comptabiliser le nombre de fois où les lectures du capteur sont en dessous de la limite spécifiée. Lorsque ce compteur dépasse un certain seuil (7 dans ce cas), cela indique qu'un obstacle est présent. Cette gestion du compteur permet à notre système de prendre des décisions en fonction des conditions détectées par le capteur, garantissant ainsi la vigilance de notre VigiCar.

Ce processus en temps réel, facilité par l'ADC rapide et le compteur intégré, nous permet de surveiller efficacement les conditions environnementales et de répondre à la présence d'un obstacle en faisant reculer la voiture, qui par la même occasion allume ses feux de recul.

Séance du 6 Juin 2024

Lors de cette séance nous avons terminé notre VigiCar en installant l'alimentation par batterie.

Installation de la batterie

Pour ce faire, nous avons voulu isoler la partie du circuit concernant la batterie du reste. Pour cela nous avons donc décidé d’intégrer un deuxième port USB-mini consacré à la charge d’une batterie de 3.7V afin de garantir une alimentation non filaire. Afin de vérifier le bon rechargement de la batterie, nous avons installer une LED orange D4 qui s’allume en cas de recharge.

Pour utiliser l’alimentation sur batterie, il nous suffit de placer un cavalier sur le connecteur J9. Et pour la recharger, on doit en utiliser deux sur les connecteurs J5 et J6. Il faut cependant faire très attention au placement des cavaliers selon l’utilisation. Si on désire modifier le code (par USB donc), nous devons impérativement vérifier que le cavalier en J9 est bien enlevé. Si ce n’est pas le cas, nous avons donc donc deux alimentations simultanées (USB et batterie) ce qui peut provoquer des dysfonctionnements.

Nous avons également installer une diode (D5) pour envoyer le courant de la batterie dans le capteur IR en l’absence de source USB.

Enfin, nous avons décidé d’installer le connecteur de la batterie (J7) sous la carte pour des questions pratiques.

Amélioration de la voiture

Nous avons par la suite ajouter des roues sur notre voiture: une roue libre à l'avant et deux roues que nous avons créées en 3D sur le logiciel Blender puis imprimées. Nous avons aussi réutilisé des anciennes courroies d'imprimante 3D pour pouvoir entourer nos roues.

De plus, nous avons fixé la batterie sous la voiture.

Dernières améliorations du code

Ayant fini notre projet, nous avons decidé, après quelques conseils, de modifier la vitesse d'un des moteur par rapport à l'autre afin que la voiture tourne lorsqu'elle recule. Maintenant, elle recule plus rapidement et change sa trajectoire. Enfin, voici le rendu final de notre projet VigiCar :

Conclusion

Nous avons donc réussi à atteindre nos objectifs, tout en ajoutant des améliorations. Une remarque que nous nous sommes faite à la fin de ce projet est que nous aurions pu travailler sur la forme du PCB pour que la voiture évite et contourne mieux les obstacles.

SE3Binome2023-3

Sommaire