SE3Binome2023-5

Projet Groupe 5 : Voiture Programmable

Cette page est consacrée à la présentation du projet SE3 réalisé par BOURSAULT Rémi & LECOMTE Antoine, qui est porté sur la création d'une voiture contrôlé par programmation.

Présentation :

Objectifs

Les objectifs du projets sont :

• Concevoir une voiture fonctionnant sur batterie, avec un ATMega.
• Intégrer des clignotants fonctionnels.
• Permettre à la voiture d'avancer ou reculer, toujours en utilisant l'ATMega.
• Ajout d'un gyrophare.

Ressources

Pour atteindre ces différents objectifs, nous aurons besoins des ressources suivantes :

• Un microcontrôleur ATMega16U4/ATMega32U4
• Des LEDS
• Deux moteurs à courant continu
• Un châssis
• Des dipôles classiques
• Un gyrophare

Après avoir choisi notre projet et nos différents objectifs pour ce projet, nous avons commencé à travailler sur le schéma de montage sur KiCAD afin de pouvoir ensuite faire le PCB et le routage qui sera envoyé à une usine pour imprimer nos cartes. Les fonctions et composants principaux de notre projet sont les suivants.

Fonction sur le schéma :

Microcontrôleur

La partie indispensable de tous montages électroniques, le cerveau de la voiture. Sans le microcontrôleur rien dans ce projet n'est possible, il permet de gérer les informations. qui sont transmises dans toutes la carte. C'est un microcontrôleur ATMega32u4, ce n'est pas le plus puissant, mais pour la taille du projet que nous faisons c'est bien assez. Il possède assez d'entrées/sorties pour ce que nous voulons en faire.

Schéma du microcontrôleur

Configuration des pins sur l'atmega

Commande Moteur

Ce bloc est celui qui actionne les moteurs et leur dit quand s'arrêter. Celui-ci est composé d'un TB6612FNG, un driver pour moteur qui ne sert qu'à ça. Il prend sept signaux en entrée trois pour gérer chaque moteur et un signal de standby. Nous avons utilisé la datasheet pour savoir comment le schématiser et quels composants utilisé pour que celui-ci fonctionne dans des conditions optimales.

Il est nécessaire d'ajouter ce composant, car les signaux de sortie délivrés par l'ATMega sont trop faibles pour alimenter un moteur. Ce driver vient, à partir d'une tension d'alimentation Vcc amplifier le signal de commande délivré par l'ATMega pour que les moteurs aient l'alimentation adéquate.

PCB routé de la carte

Schéma du bloc de commande des moteurs

Chargeur LI-PO

Comme notre voiture fonctionnera sur batterie, il faut un moyen de la recharger, ceci se faisant par l'intermédiaire d'un port USB, il faut un bloc pour adapter le courant que reçoit l'USB pour que cela corresponde aux caractéristiques de notre batterie.

Schéma du chargeur

Utilisation de la Batterie

Ce bloc permet de séparer l'alimentation en USB et sur batterie. Lorsqu'un cavalier est présent sur J6, VBAT est directement relié à Vcc et ainsi la batterie sert d'alimentation pour la carte. Il est impératif de débrancher l'USB avant de mettre le cavalier, pour éviter tout court-circuit. Lorsqu'on enlève le cavalier, on peut brancher l'USB et la carte fonctionne en filaire.

Schéma du switch batterie

Connecteur USB

On dispose de deux connecteurs USB, un pour recharger la batterie, et un autre pour transmettre les données, qui servira à implanter un programme dans notre microcontrôleur.

Schéma des connecteur USB

Connecteur ISP

Pour charger le bootloader sur le microcontrôleur si besoin.

Schéma du connecteur ISP

Diodes Électroluminescentes

Schéma des LEDS

PCB et routage :

Après avoir fini toutes nos fonctions et le schéma, nous nous sommes attaqué au PCB de la carte, il nous a fallu quelque essais pour obtenir une disposition qui nous convienne et qui facilite le routage.

Vue 3D de la carte

PCB routé de la carte

Brasage des composants

Une fois les cartes reçues, nous nous sommes attaqués à la brasure des différents composants. Nous avons commencé par le microcontrôleur, le cristal et les résistances et capacités associées. Dès le départ nous avons eu des problèmes avec le brasage, des pattes soudées entre elles, le cristal mal posé. Mais notre plus gros problème a été l'allocation des pins du microcontrôleur. Nous ne le savions pas au moment de la création de notre PCB et nous n'y avons pas fait attention, mais des pins sont spécialement attribuées au MISO, MOSI et SOCKET. Pins que nous devons utilisés pour envoyer le bootloader sur la microcontrôleur via le programmateur ISP (en orange sur le schéma). Nous avons donc dû improviser une solution. Nous avons coupé les pistes et relié par des fils les broches de l'ISP aux pins correspondantes. À cause de cette erreur nos LEDs D2 et D3 ne sont plus utilisables.

Pins de l'atmega utilisés pour l'ISP

Une fois ce problème réglé, nous avons pu passer à la suite, la gestion des moteurs. Pour ce faire il n'y a pas eu autant de problèmes que sur la partie microcontrôleur, nous avons simplement soudé le contrôleur de moteurs, un TB6612FNG, puis les broches sur lesquelles nous allons venir brancher les moteurs, et enfin les fils directement sur les broches des moteurs. Nous avons également utilisé du plastique thermo rétractable pour que les fils soient protégés et restent soudés aux moteurs durant toute la durée du projet. Les moteurs étant prêt à l'emploi, nous les avons testé pour savoir si tout était fonctionnelle. Une fois confirmé, ayant en tête le contexte écologique actuel, nous avons pris des bouchons de bouteilles comme roues et mis des élastiques autour pour avoir de la traction lors de nos différents essais.

Moteurs et roues

Pour tester toute notre carte, nous avons créé un code sous le nom de helloworld.c qui rempli différente fonctions (disponible sur le GIT), allumer ou faire clignoter les LEDs en fonction du déplacement de la voiture et, bien évidemment, déplacer la voiture. La voiture réagissant comme nous le souhaitons, nous décidons donc de passer à l'étape suivante, le fonctionnement sur batterie. Ce n'est pas la partie la plus compliquée, il suffit de braser les broches permettant d'accueillir la batterie puis celles destinées au cavalier. Une fois le tout installé sur notre carte, nous la testons et tout fonctionne normalement.

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

#define PWM1 PB7
#define PWM2 PD0
#define AIN1 PF6
#define AIN2 PF7
#define BIN1 PF4
#define BIN2 PF1
#define STBY PF5
#define D3 PB0
#define D2 PE6
#define D6 PC6
#define D7 PC7
#define D8 PD4
#define D9 PD6
#define START PF0


void blink_droit()
{
    for(int i = 0; i<50; i++)
    {
        PORTB |= (1<<D3);
        PORTC |= (1<< D7);
        _delay_ms(200);
        PORTB &= ~(1<<D3);
        PORTC &= ~(1<< D7);
        _delay_ms(200);
    }
}

void blink_gauche()
{
    for(int i = 0; i<50; i++)
    {
        PORTD |= (1<<D8);
        _delay_ms(200);
        PORTD &= ~(1<<D8);
        _delay_ms(200);
    }
}

void avancer(int time)
{
    PORTB |= (1<< PWM1);
    PORTF |= (1<< AIN2) | (1<< BIN1) | (1<< STBY);
    PORTF &= ~(1<< AIN1);
    PORTF &= ~(1<< BIN2);
    PORTE |= (1<< D2);
    PORTD |= (1<<PWM2);
    _delay_ms(time);
    PORTE &= ~(1<< D2);
    PORTF &= ~(1<< STBY);
}

void reculer(int time)
{
    PORTB |= (1<< PWM1);
    PORTF |= (1<< AIN1) | (1<< BIN2) | (1<< STBY);
    PORTF &= ~(1<< AIN2);
    PORTC |= (1<< D6);
    PORTF &= ~(1<< BIN1);
    PORTD |= (1<<PWM2) | (1<< D9);
    _delay_ms(time);
    PORTC &= ~(1<< D6);
    PORTD &= ~(1<< D9);
    PORTF &= ~(1<< STBY);
}

void gauche(int time)
{
    PORTB |= (1<< PWM1);
    PORTF |= (1<< AIN1) | (1<< BIN1) | (1<< STBY);
    PORTF &= ~(1<< AIN2);
    PORTF &= ~(1<< BIN2);
    PORTD |= (1<<PWM2);
   // blink_gauche();
    _delay_ms(time);
    PORTF &= ~(1<< STBY);
}

void droite(int time)
{
    PORTB |= (1<< PWM1);
    PORTF |= (1<< AIN2) | (1<< BIN2) | (1<< STBY);
    PORTF &= ~(1<< AIN1);
    PORTF &= ~(1<< BIN1);
    PORTD |= (1<<PWM2);
   // blink_droit();
    _delay_ms(time);
    PORTF &= ~(1<< STBY);
}

int main()
{
    uint16_t time = 4000, half = 1200, full = 2400;
    CLKSEL0 = 0b00010101;
    CLKSEL1 = 0b00001111;
    CLKPR = 0b10000000;
    CLKPR = 0;

    MCUCR |= (1<<JTD);
    MCUCR |= (1<<JTD);


    DDRB |= (1<< PWM1) | (1<< PB0);
    DDRF |= (1<< AIN1) | (1<< AIN2) | (1<< BIN1) | (1<<BIN2) | (1<< STBY);
    DDRF &= ~(1<<START);
    PORTF |= (1<<START);
    DDRD |= (1<< PWM2) | (1<< D8) | (1<< D9);
    DDRE |= (1<< D2);
    DDRC |= (1<< D6) | (1<< D7);

    while(1)
    {
        if(~(PINF>>START) & 1)
        {
            avancer(time);
            _delay_ms(1000);
            reculer(time);
            _delay_ms(1000);
            gauche(half);
            _delay_ms(1000);
            droite(full);
            _delay_ms(1000);
        }
    }
    return 0;
}

LED allumée en fonctionnement sur batterie

Voiture fonctionnant sur batterie

Comme il nous reste encore un peu de temps, nous décidons de nous attaquer à la dernière partie, la recharge de la batterie. Comme pour la partie de fonctionnement sur batterie, il n'y a aucune partie de code, il suffit de souder des composants en plus sur la carte pour que la nouvelle fonctionnalité soit active. Donc nous nous y sommes mis et encore une fois il n'y a aucun problème.

Voiture déchargée

Voiture en charge

Voiture après recharge

CONCLUSION

Lors de ce projet, nous avons pu acquérir des compétences de base dans la Conception Assistée par Ordinateur et nous avons appris beaucoup sur la manière dont un système embarqué fonctionne précisément, notamment sur le fonctionnement nomade. Grâce à nos erreurs concernant l'attribution de certains PINs (les PINs MISO MOSI et SLK, et la non utilisation de port adaptés au PWM pour le réglage de la puissance délivrée par les moteurs), nous avons compris l'extrême importance de porter la plus grande attention à la CAO, pour éviter d'avoir de gros problèmes par la suite. Nous avons tout de même réussi à atteindre les objectifs fixés dans les temps, et l'intégralité des modules présents sur la carte ont bien été intégrés sur le prototype.

GIT

Vous trouverez dans le lien GIT de notre projet, tous les fichiers de création de la carte se trouvent dans le dossier projet_voiture, le code envoyé pour tester la voiture dans le dossier cod.