Salut à tous,

Encore un ptit projet qui finit avec un arduino dedans!!

Le contexte: J'ai fabriqué un petit kart électrique pour mon fil de 4 ans, avec un moteur-roue de trottinette électrique brushless 350w commandé par un contrôleur chinois de vélo à assistance electrique qu'on trouve à pas cher sur ali express.

Problème: C'est beaucoup trop puissant pour apprendre! Et trop rapide (jusqu'à près de 40km/h a fond) Et une fois le kart parti, je ne peux plus l’arrêter (s'il décide de s'enfuir sur la route par exemple)

Du coup, j'ai réfléchi à un tas de solutions pour brider l'affaire.

J'ai d'abord installé un petit module avec un relais piloté par une radio qui me permet de contrôler à distance la sortie High Brake du contrôleur. En clair, lorsque j'appuie sur le bouton, un relais sur le kart connecte la sortie "HIGH Brake" au +5V du contrôleur et ce en // du signal du capteur à effet hall de la poignée de freins. Cela a pour effet de couper la commande de gaz et activer le frein moteur électrique. cela me permet de l’empêcher de s'enfuir, ou de la l’arrêter s'il fonce droit sur un arbre. C'est facile à faire, pas cher, mais ça n'exploite que le frein moteur et ça a tendance à sacader lorsque le kart est proche d'être hors de portée de la commande radio.

https://www.amazon.fr/Demiawaking-433-MHz-commutateur-%C3%A9metteur-r%C3%A9cepteur/dp/B075NK6DK6/ref=sr_1_5?__mk_fr_FR=%C3%85M%C3%85%C5%BD%C3%95%C3%91&dchild=1&keywords=relais+remote+12V&qid=1588232359&sr=8-5

J'ai ensuite voulu exploiter les freins à tambour des roues avant, mais sa jambe n'avait pas assez de force pour actionner les 2 d'un coup mécaniquement en tirant les câbles. DU coup, j'ai ajouté 3 élements:

- Une nouvelle pédale identique à celle de gaz (effet hall signal 0-4.5V) pour actionner les freins

- Un arduino nano

- Une paire de servos de modélisme 20kg/cm avec une petite alim 6V 3A dédiée.

Avec ces éléments, le petit peut désormais utiliser les freins avant via la nouvelle pédale sans devoir forcer, et lorsque j'appuie sur le bouton de ma télécommande, je bloque les gaz, le frein électrique ar et les 2 freins mécaniques avant. J'ai aussi ajouté une tempo de 5 secondes pour éviter le sautillement du signal de la télécommande.

Voici le code de l'arduino qui fonctionne bien pour ça. En gros, ça commande 2 servos (sens opposé car ils sont disposés de manière symétrique sur le voiture) en fonction de la valeur d'un effet hall + ça envoit du 5V à la commande de frein moteur dès que le frein méca est activé. Et en cas d'appuie bouton (via le relais de la télécommande) ça bloque tout 5 secondes. C'est très certainement fortement optimisable, mais ça fonctionne bien tel quel.

#include <Servo.h>

Servo myservoL;  // création servo Gauche
Servo myservoR;  // création servo Droit

int potpin = A0;  // Pin de lecture de la poignée de commande de freins (effet hall)
int valL;    // Variable pour le servo Gauche
int valR;    // Variable pour le servo Droit

const int analogOutPin = 6; // Pin qui va vers l'input freins du controlleur
int outputValue = 0;        // Mise à 0 de la sortie freins

int pinStop; //déclaration de la variable "Pinstop"



void setup() {
  myservoL.attach(9);  // Commande Servo Gauche attachée au pin 9
  myservoR.attach(10);  // Commande Servo Droit attachée au pin 10
  pinStop=5; // entrée du signal de STOP attaché au pin 5

  pinMode(pinStop,INPUT); // configuartion du Pin de STOP en INPUT
  
  
  Serial.begin(9600); // etalonage du moniteur série
}

void loop() {

  boolean etatStop=digitalRead(pinStop); // lecture de l'état de la commande de stop
   valL = analogRead(potpin); // lecture de la valeur de la pédale pour la variable ValL
   valR = analogRead(potpin); // lecture de la valeur de la pédale pour la variable ValR
   
  Serial.println("pedale");
  Serial.println(valL);

  Serial.println("Stop");
  Serial.println(outputValue);

  if (etatStop==LOW)//test si bouton relaché = commande STOP non active
{
  
  valL = analogRead(potpin);            // Lecture de la valeur de la poignée pour servo Gauche (0% => 166 et 100% => 870)
  valL = map(valL, 0, 1024, 60, 0);     //  Echelle du servo Gauche (value between 0 and 60°)
  
  valR = analogRead(potpin);            // Lecture de la valeur de la poignée pour servo Droit (0% => 166 et 100% => 870)
  valR = map(valR, 0, 1024, 0, 60);     //  Echelle du servo Droit (value between 60 and 0°)
  
  myservoL.write(valL);                  // ordre donné au servo Gauche
  myservoR.write(valR);                  // ordre donné au servo Droit

  outputValue = map(valL, 50, 900, 0, 1024); // conversion de la valeur de la pédale
  
  analogWrite(analogOutPin, outputValue);

  
  delay(15);                           //   pause 

}

if (etatStop==HIGH)//test si bouton appuyé

{
  valL = 1024;            // Lecture de la valeur de la poignée pour servo Gauche (0% => 166 et 100% => 870)
  valL = map(valL, 0, 1024, 60, 0);     //  Echelle du servo Gauche (value between 0 and 90°)
  
  valR = 1024;            // Lecture de la valeur de la poignée pour servo Droit (0% => 166 et 100% => 870)
  valR = map(valR, 0, 1024, 0, 60);     //  Echelle du servo Droit (value between 0 and 90°)


  myservoL.write(valL);                  // ordre donné au servo Gauche
  myservoR.write(valR);                  // ordre donné au servo 
  
  
  outputValue = 150;
  analogWrite(analogOutPin, outputValue);
  delay(5000);
}


  
}

Désormais, je voudrais aussi piloter la commande des gaz via l'arduino, pour pouvoir la moduler et surtout la limiter à ma convenance. L'idée, c'est de rajouter un potard qui selon sa position en 0 et 100% limite le signal en sortie "Gaz" à ce même pourcentage. 

Ex: ma pédale envoit un signal entre 0 et 4,5V. Lorsque le potard est à 50% je veux qu'elle marche normalement jusqu'à 2,25V et qu'ensuite ça reste à 2,25V si on enfonce plus le pied.

J'ai fait ce bout de code, mais il ne fonctionne pas bien. Notamment un signal pas très stable sur la sortie. Y verriez-vous des pistes d'amélioration? (le delay de 1000, c'est surtout pour avoir le temps de bien lire sur le moniteur série lors des tests) 

int potPin = A0;  // Pin de lecture du potard de bridage
int gazPin = A1; // Pin de lecture de la poignée de gaz
int stopPin = A2; // Pin de lecture de la commande de stop
int brakePin = A3; // Pin de lecture du Hall Effect de frein
int speedPin = A4; // Pin de lecture du retour de vitesse

int OutGazPin = 3; // Pin out de consigne de gaz
int OutBrakePin = 2; // Pin out de consigne de frein

int valPotPin; // Valeur lue sur le pin du Potard
int valGazPin; // Valeur lue sur le pin de Gaz
int valBrakePin; // Valeur lue sur le pin de frein
int valSpeedPin; // Valeur lue sur le pin de vitesse
int valGazMax;  // Valeur définie de Gaz Maximum


const int outputBrakeValue = 2; // Pin qui va vers l'input freins du controlleur
const int outputGazValue = 3; // Pin qui va vers l'input Gaz du controlleur

int valGazReal;



void setup() {
  // put your setup code here, to run once:

  int outputBrakeValue = 0;        // Mise à 0 de la sortie freins
  int outputGazValue = 0;        // Mise à 0 de la sortie Gaz

  pinMode(potPin,INPUT);
  pinMode(gazPin,INPUT);
  pinMode(stopPin,INPUT);
  pinMode(brakePin,INPUT);
  pinMode(speedPin,INPUT);

  pinMode(OutGazPin,OUTPUT);
  pinMode(OutBrakePin,OUTPUT);

  
  
Serial.begin(9600);

}

void loop() {
  // put your main code here, to run repeatedly:

  valPotPin = analogRead(potPin);
  Serial.println("potard");
  Serial.println(valPotPin);
  valGazPin = analogRead(gazPin);
  Serial.println("Gaz");
  Serial.println(valGazPin);

  valGazMax = map(valPotPin, 0, 1024, 330, 700);
  Serial.println("Gaz Max");
  Serial.println(valGazMax);
  

 

      if (valGazPin<=valGazMax)//test si le gaz est inférieur au gaz max
      {
              analogWrite(OutGazPin, valGazPin);
      }
      if (valGazPin > valGazMax)
      {
              analogWrite(OutGazPin, valGazMax);    
      }
      
      valGazReal = analogRead(OutGazPin);
      Serial.println("Gaz réel");
      Serial.println(valGazReal);
      Serial.println("______________________________");

      
      delay(1000);
        
    

}

Bonjour,

Voilà ce que j'ai pu lire sur un site :

"la fiche technique de l'Atmega met en garde également contre un basculement des broches analogiques peu de temps avant de faire une conversion analogique-numérique (analogRead) sur une autre broche analogique. Ceci pourra créer un bruit électrique et introduire une vibration dans le système analogique. Il peut être désirable, après avoir manipulé les broches analogique en (mode numérique), d'ajouter un court délai de pose avant d'utiliser l'instruction analogRead() pour lire les autres broches."  

Peut être une piste ???

Benoît

Salut,

Très interessant et quel papa formidable 

C'est toi qui avait fait un truc sur ta moto avec Arduino il y a quelques mois, non ?

Je suis très loin de ton niveau donc, je n'ai pas bien saisi le code Arduino mais delay est bloquant. Tu bloques 5 secondes. En reprenant l'aspect sécuritaire, un obstacle dangereux qui mesure 1m, 1m en 5s c'est, 20cmps soit même pas 1 km/h. Entre 1 et 40 km/h il y a beaucoup de vitesse. La fonction millis() ne serait pas plus appropriée pour garder la main sur le programme ?