Fabriquer une trottinette électrique connectée

Fabriquer une trottinette électrique connectée

Il y a quelque temps déjà, j’ai acheté sur Leboncoin une trottinette électrique hors d’usage à seulement 3 euros.
Après quelques tests, j’ai pu conclure que les batteries étaient usagées et la carte électronique HS.
J’ai donc décidé de la réparer et d’en faire une trottinette connectée et sécurisée.
L’idée est simple, deux éléments permettront de sécuriser la trottinette : interrupteur à clé afin d’éviter une décharge des batteries non voulue, mais aussi système de déverrouillage par smartphone basé sur une application app inventor et un module Bluetooth HC05.

Dans cette documentation, je vous propose de découvrir indépendamment les différentes grandes parties qui composent le système électronique.
Vous pourrez ainsi créer une trottinette avec les fonctions que vous désirez.

  1. Contrôle du moteur

    La trottinette que j'ai récupérée comporte un petit moteur DC 24V 100W. Il est cependant préférable d'utiliser un moteur plus puissant pour assurer un meilleur confort d'utilisation.
    Le moteur sera contrôlé par une poignée d’accélération qui n’est autre qu’un potentiomètre.
    Un transistor mosfet N assurera un étage de puissance pour alimenter le moteur.
    Attention de choisir un mosfet adapté !
    Comme vous pouvez le remarquer sur les schéma, il faut mettre une résistance pull-down de 10k ohm entre les pattes G et S. Celle-ci permet de maintenir à zero l'état du mosfet.
    Il est également important de mettre une diode aux bornes du moteur pour protéger le mosfet. En effet, lorsque le moteur n'est plus alimenté, il peut garder de l'inertie et se comporter comme un générateur capable de griller le mosfet. La diode est là pour empecher cela.

    Voici le lien d’une documentation de « incroyable expérience » pour piloter un moteur DC avec une carte arduino : https://www.facebook.com/notes/les-incroyables-experiences/programme-arduino-pour-le-scooter-%C3%A9lectrique/1229058177106667/
    Dans le programme qu’ils proposent, ils incluent un seuil de sécurité pour couper le moteur en cas d’accélération trop forte. Après quelques tests avec ce code, je me suis rendu compte qu’il n’était pas très utile de fixer un seuil d’accélération maximale en raison de la très faible puissance du moteur que je vais utiliser (100W).
    J’ai donc opté pour un code plus basique que voici :

    int a=0; // Initialisation du rapport cyclique demandé à 0.
    void setup()
    {
    Serial.begin(9600);
    pinMode(3, OUTPUT); // Broche 3 réglée comme sortie numérique. Attention a bien choisir une broche compatible PWM
    }
    void loop()
    {
    a=analogRead(5); // Lecture de la valeur du l'accélérateur
    Serial.println(a); // Affichage de la valeur sur le moniteur série
    a = constrain(a, 250, 830); // Fixation des valeurs extrêmes de l'accélérateur. Cette instruction n’est pas nécessaire si votre les valeurs de l’accélérateur lues varient bien entre 0 et 1023.
    a = map(a, 250, 830, 0, 255); // Création du PWM
    Serial.println(a); // Affichage de la valeur sur le moniteur série
    delay(20); // délai de 20 milliseconde pour la souplesse de conduite
    analogWrite(3,a); // Ecriture sur la pin 3 du signal PWM
    }
  2. Lecture de la tension des batteries

    Une entrée analogique sur une carte arduino ne peut pas recevoir des tensions supérieures à 5V. Le résultat de cette mesure est donné sur 10 bits, soit entre 0 et 1023
    La trottinette est composée de 2 batteries de chacune 12V en tension nominative (soit 24V au total). A pleine charge, la tension maximale peut atteindre 29,8 V au total (par mesure de sécurité on peut arrondir à 30V). Il faut donc utiliser un pont diviseur de tension pour passer de 30V à 5V.

    On a donc R1 = 10k ohm R2 = 2k ohm
    Vout/Vin = 0.167

    Voici le code à utiliser:

    int input = 3; // entrée tension batteries
    int tension = 0; // variable pour stocker la valeur

    void setup()
    {
    Serial.begin(9600); // initialisation de la liaison série
    }

    void loop()
    {
    tension = analogRead(input); // lecture de la tension
    tension = tension / 1023 * 5 / 0.167 ; // conversion de la valeur pour retrouver la tension réelle des batteries
    Serial.println("tension"); // ici on affiche la valeur sur le moniteur
    }
  3. Utilisation de l’afficheur LCD

    L’afficheur LCD va permettre d’indiquer à l’utilisateur la tension des batteries ainsi que l’état de la connexion Bluetooth.
    Pour des raisons d’ergonomie, j’ai choisi d’utiliser un afficheur 1602 (2 lignes de chacune 12 caractères). L’objectif étant d’avoir un tableau de bord le plus simple possible.

    Voici un exemple de code :

    #include
    LiquidCrystal lcd(12,11,5,4,3,2);
    int tension = 24;

    void setup(){
    Serial.begin(9600);
    lcd.begin(16, 2);
    }

    void loop(){
    lcd.clear();
    lcd.setCursor(0, 0);
    lcd.print("Le texte que vous voulez");
    delay(1000);
    }
  4. Déverrouillage Bluetooth

    L’objectif de cette partie du système est d’empêcher tout utilisateur autre que le propriétaire d’utiliser la trottinette.
    Pour cela, une application "mit app inventor" permettra d’envoyer un message à l’arduino pour autoriser ou non le fonctionnement du moteur.
    Comme vous pouvez le constater sur le schéma, je n'utilise pas les pin rx et tx de l'arduino pour ne pas avoir à débrancher le module HC-05 à chaque fois que je téléverse un code sur l'arduino.

    Voici un exemple de code :

    #include

    SoftwareSerial HC05(2, 3); // RX | TX
    const char DOUT_LED = 4;
    String messageRecu;

    void setup() {
    Serial.begin(9600);
    HC05.begin(9600);
    pinMode(DOUT_LED, OUTPUT);
    digitalWrite(DOUT_LED, LOW);
    }

    void loop()
    {
    while(HC05.available())
    {
    delay(3);
    char c = HC05.read();
    messageRecu += c;
    }
    if (messageRecu.length() >0)
    {
    Serial.println(messageRecu);
    if (messageRecu == "deverrouiller")
    {digitalWrite(DOUT_LED, HIGH);} // Ici, si le message "deverrouiller" est envoyé, on allume une led. Dans le cas de la trottinette, on lira la valeur du potentiomètre d'accélérateur.
    if (messageRecu == "verrouiller")
    {digitalWrite(DOUT_LED, LOW);}
    messageRecu="";
    }
    }
  5. Application bluetooth

    Pour créer sur mesure une application dédiée à la trottinette, j'ai utilisé le site mit app inventor qui permet de créer facilement des applications simples.
    Pour résumer le fonctionnement, après s'être connecté à la trottinette, l'utilisateur peut envoyer au hc-05 le message "deverrouiller" ou "verrouiller" en cliquant sur l'un des boutons
    Je vous conseille de regarder quelques tutoriels pour mieux comprendre comment utiliser app inventor.

    Voici une photo de l'algorigramme de mon application :
  6. Pour télécharger l'application : https://drive.google.com/file/d/1P798ITkXOMWb_U5AXMGxOy_C0s08zrVy/view?usp=sharing
    Attention, seuls les smartphones sous android peuvent télécharger les applications app inventor.
    Noubliez pas d'autoriser les sources inconnues pour pouvoir télécharger ce fichier .apk non issue de Google Play

    Voici une photo de l'interface de l'application :
  7. Maintenant que vous maitrisez les différentes fonctions de la trottinette, il est temps de passer à la construction !
    Voici le schéma fonctionnel du système :
  8. J'ai tout d'abort commencé par nettoyer et repeindre le chassis de la trottinette qui était un peu rouillé.
    Il est important de bien poncer et dégraisser le chassis avant de le peindre.
  9. Puis, j'ai fait les différents tests électroniques :
  10. Ensuite, j'ai modélisé un boitier sur mesure pour contenir tout l'électronique.
  11. Et je l'ai ensuite imprimé en 3D.

    Hauteur de couche : 0.15mm
    Remplissage : 20%
    Filament : PLA noir Verbatim
    Vitesse d'impression : 60mm/s

    Voici un lien pour télécharger les fichiers stl : https://www.thingiverse.com/thing:3073639
  12. J'ai ensuite commencé à souder tous les composants et à assembler les différentes parties du système.
    Voici le mosfet. Il est fixé sous le châssis de la trottinette pour pouvoir refroidir le plus possible.
  13. Après de nombreuses heures de soudure, voici ce que ça donne !
    Comme vous pouvez le voir, en bas à droite du boitier, il y a quelques fils qui ne sont pas branchés. Ils sont là si jamais je souhaite rajouter un compteur de vitesse sur la trottinette avec un module infrarouge en guise de tachymètre optique.
  14. Et voici le résultat final
  15. Voici le code complet de la trottinette :

    #include
    #include
    LiquidCrystal lcd(12,11,5,4,3,2);
    SoftwareSerial HC05(8, 9); // RX | TX
    int a=0; // Initialisation du rapport cyclique demandé à 0.
    int autorisationmoteur = 0 ; // variable pour autoriser ou non le fonctionnement du moteur
    int pintension = 0; // entrée tension batteries
    float tension = 0; // variable pour stocker la valeur
    String messageRecu; // variable du message bluetooth envoyé par le smartphone
    unsigned long previousMillis = 0; // variable du compteur

    void setup() {
    Serial.begin(9600);
    HC05.begin(9600);
    Serial.begin(9600);
    pinMode(3, OUTPUT); // Broche 3 réglée comme sortie numérique. Attention a bien choisir une broche compatible PWM
    lcd.begin(16, 2); // Initialisation de l'écran
    }

    void loop(){

    while(HC05.available()){
    delay(3);
    char c = HC05.read();
    messageRecu += c;
    }
    if (messageRecu.length() >0){
    Serial.println(messageRecu);
    if (messageRecu == "deverrouiller") {
    autorisationmoteur = 1; // Autorisation de fonctionnement du moteur

    }
    if (messageRecu == "verrouiller") {
    autorisationmoteur = 0; // Mise à zero de l'autorisation de fonctionnement du moteur
    analogWrite(6,0); // mise ) Zero du signal PWM envoyé au moteur
    }
    messageRecu=""; // Reinitialisation du message reçu
    }


    if (autorisationmoteur == 1){ // Si le moteur est autorisé à fonctionner
    a=analogRead(5); // Lecture de la valeur du l'accélérateur
    Serial.println(a); // ici on affiche la valeur sur le moniteur
    a = constrain(a, 170, 870); // Fixation des valeurs extrêmes de l'accélérateur. Cette instruction n’est pas nécessaire si votre les valeurs de l’accélérateur lues varient bien entre 0 et 1023.
    a = map(a, 170, 870, 0, 255); // Création du PWM
    delay(10); // délai de 20 milliseconde pour la souplesse de conduite
    analogWrite(6,a); // Ecriture sur la pin 3 du signal PWM
    lcd.setCursor(0, 1);
    lcd.print("DEVERROUILLEE");
    }


    unsigned long currentMillis = millis();
    if (currentMillis - previousMillis >= 1000) // condition pour une temporisation de 1 seconde
    {
    previousMillis = currentMillis; // reinitialisation de la temporisation
    tension = analogRead(pintension); // lecture de la tension
    tension = tension / 1023 *5 / 0.167 ; // conversion de la valeur pour retrouver la tension réelle des batteries
    lcd.clear();
    lcd.setCursor(0, 0);
    lcd.print("Tension =");
    lcd.setCursor(10, 0);
    lcd.print(tension);
    lcd.setCursor(15, 0);
    lcd.print("V");
    }

    }

Rating: 4.8/5. From 3 votes.

Connectez-vous pour voter
Please wait...
Réalisé par
Posté le
Univers
IoT
Temps de fabrication
1 semaine
Niveau de difficulté
Avancé
Matériel(s)
1
Arduino UNO
1
Mosfet N
1
Potentiomètre
1
Afficheur LCD 1602
1
Batterie 12V 5Ah
1
Moteur DC 24V
1
Interrupteur à clé
1
Buck converteur
1
Module Bluetooth HC-05
1
PLA noir Verbatim
Outils
1
Fer à souder
1
Imprimante 3D

Aucun commentaire. Soyez le premier à en écrire un !

Vous devez être connecté pour laisser un commentaire.