Construire une centrale type Motogadget

OK, c'est clair

Si vous avez des idées de fonction pouvant être contrôlées par l'arduino, n'hésitez pas!

Pour l'instant, on a vu qu'on pouvait assez facilement ajouter une alarme et un déclencheur automatique de feux stop au rétrogradage.?

Je me disais qu'en bidouillant un peu, on doit assez facilement ajouter un compte tour "barre de LEDs" et un compteur de vitesse avec un petit moteur pas à pas et une aiguille. Ca sent les nuits blanches ce projets!

Un allumage électronique ?
Pour arrêter de s'embêter avec les rupteurs et le régulateur centrifuge...

Bravo trop fort Benjamin, quelle type diode pour le feux arriere.
Du coup ton feux arriere ne fonctionne qu apres avoir demarre?
Merci

Pour le feux Ar, des diodes tout ce qu'il y a de plus basique. Mais capable de tenir un minimum de charge. (calculez le I qui passe dedans en fonction de la puissance de votre feux Ar: Sachant que U=RxI et P=UxI) Si vous avez un feux Ar à LEDs ou à Ampoule, le calibre sera différent car la puissance consommée différente.

Bon voici ou j'en suis!:




Je suis finalement parti sur une Arduino Nano, moins encombrante que la Mega et déjà 16 input/Output donc bien de quoi faire!
Ca se trouve pour 8€ FDP inclus sur ebay (clone funduino).

Donc avec le bloc de relais, on est à 17€ de matos :) Dur! Je me demande bien ce que motogadget met dans son boitier pour justifier les 233€ de plus!

J'ai symbolisé sur ma Breadboard les fonctions de la Moto par des LEDs. Au final, ces fils iront vers les commandes de mon petit bloc de relais que je n'ai pas encore reçu. Mais de toute façon, le programme sera le même donc ça ne m’empêche pas d'avancer.

Je me suis aussi fendu d'un acceleromètre 3 axes (pour gérer l'alarme et les feux stop automatiques) ainsi qu'un capteur à effet Hall qui viendra compter les impulsions dans le fil de ma bobine HT pour ainsi faire évoluer une chenille de 6 LEDs qui fera office de compte tour. Le boitier bleu, c'est un petit relais. 

Les 4 petits boutons en bas symbolisent les comodos, et l'inter à levier la clé de contact.

Je ne vais pas intègrer tout de suite l'acceleromètre et le compte tour. Mais ça devrait venir assez rapidement.

Quand au prog principal, il devrait arriver dans le WE!

Une démonstration Vidéo dès que ça fonctionne!

A+

Bravo, suis admiratif devant tes travaux

Salut à tous!

Le programme me prends un peu plus de temps que prévu!! J'ai voulu faire la malin, mais c'est un peu plus compliqué à programme que la Ti82 fx du college!! (quoique c'est assez proche finalement)

Bon voici en tous cas le shémas de montage sur une moto:

Le boitier sera donc compose de l'Arduino, du bloc de relais et d'une petite plaque percée d'electronique pour y souder les resistances et condensateurs couples au boutons poussoirs. Ils servent à metre en charge ou non les entrées (pour decoder le signal) et à éviter les effets de rebonds au presage du bouton. du coup, on risqué de dépasser le budget de 16€ de 1 ou 2€... j'espère que vous ne m'en tiendrez pas rigueur

Il reste encore des fusibles à ajouter ou enlever, on verra ça plus tard, ce n'est pas le plus important.




Ce qui me pose le plus de problem, dans le programme, c'est la gestion des clignotants.

Je veux utiliser l'arduino pour gerer le clignotement, et pas utiliser de clignoteur en dehors, mais ça fou la merde dans le programme car ça bloque aussi les autres fonctions. Je n'ai pas encore trouvé comment règler ça mais je sais que c'est possible.

La suite au plus vite!

Bonne journée!!

Tu veux dire que dans le code, pendant la boucle du clignotement, l'arduino ne peux pas gérer d'autre bouton ?!
Si c'est ça, dans un premier temps tu peux mettre une tempo pour sortir de la boucle et retrouver les autres fonctions.

Ouai c'est ça mon souci.

Pour faire clignoter, j'utilise cette fonction

digitalWrite (Cligno,HIGH);
delay(500)
digitalWrite(Cligno,LOW);
delay(500)

Sauf que lorsque que la function delay bloque tout le programme. Ce qui veut dire que pendant que le cligno clignote, je ne peux rien faire avec les autres fonctions et ça fou la merde!  Je ne sais pas encore comment gèrer plusieurs boucles en //.

Mais bon je totalise tout juste 4 jours de pratique du langage Arduino, donc je pense que d'ici quelque temps, j'aurais le niveau qui me permettra de gèrer tout ça facilement!

ça vient petit à petit :)

C'est ce que tu appelles la "tempo pour sortir de la boucle" ? Tu veux dire que lorsqu'on lance les clignos, ils clignotent seulement pendant un temps donné?

Oui c'est ça, je ne connais pas le code pour l'arduino mais il me semble que ça ressemble au C.
J'imagine qu'on peux créer une boucle qui prend en charge le clignotement et au bout de X secondes, on sort de la boucle. du coup, le clignotement s'arrête et l'arduino fonctionne correctement de nouveau.

De plus, il serait intéressant d'intégrer une nouvelle entrée pour les warning (dans le cas ou le pilote n'a pas de bouton poussoir pour les cligno)

Peut être que la solution est de gérer des "interruptions" avec la fonction attachInterrupt.
Ainsi lorsqu'on appuie sur un autre bouton, la boucle de clignotement s'arrête pour exécuter la nouvelle tâche est reprend là où elle s'est arrêté.

...Je sais, plus facile à dire qu'à faire

Ca ressemble au C+ en fait.    Ah je vois! Oui c'est pas mal, mais c'est pas bon! Parxce que si mon cligno est allumé, je dois pouvoir klaxonner ou metre mes phares etc... hors comme ça, ça ne marche pas. Il faut carrement un second programme //

Sinon pour les Warning, c'est déjà prévu. Et pas besoin d'INPUT, c'est juste du code. En gros en français, si les deux boutons de clignos sont pressé en meme temps plus d'une demi seconde, les deux sorties Cligno droit et cligno gauche s'activent. Et ce juqu'à ce qu'un des boutons de clignos soit préssé de nouveau, ce qui lance un cligno tout seul (droit au gauche suivant le bouton). Bouton qu'on  pressera une deuxième fois pour les couper complètement.

Tom31 a écrit:Peut être que la solution est de gérer des "interruptions" avec la fonction attachInterrupt.
Ainsi lorsqu'on appuie sur un autre bouton, la boucle de clignotement s'arrête pour exécuter la nouvelle tâche est reprend là où elle s'est arrêté.

...Je sais, plus facile à dire qu'à faire

Oui ça, ça me semble déjà plus adapté!! mais effectivement, c'est plus facile à dire que ce que je suis capable de faire pour le moment!! Mais ça va venir vite!

Salut à tous!

Bon après discussion avec des pros de l'électroniques, ya de spetites choses qui ne vont pas dans mon shémas!

1) D'après eux, mieux vaut ne pas brancher l'alim 5V du bloc de relais directement sur l'arduino. Car si les 8 relais sont alimentés en meme temps, cela risqué de griller le convertisseur linéaire 12V/5V de l'aduino.

le calcul qui accompagne:

Le régulateur aura à ses bornes 12 V (batterie) - 5 V (en sortie) soit 7 V de chute de tension,
faisons le calcul de puissance dissipée dans le régulateur : 7 V x 0,576 A = 4 W
Paff le régulateur de l'arduino! Il est pas capable de dissiper 4W de chaleur...

Donc on va utiliser un petit convertisseur 12Vdc/5Vdc automobile comme il y en a des kilos sur ebay à quelques €:



Celui ci est capable de tenir 3A (15W de puissance au bout) ce qui est largement assez pour allimenter nos 8 relais!

Ensuite, il m'ont allerté sur un risqué de rebond au presage des boutons lié à mon couple R 10kOhms / capa 10nF sur les boutons d'entrée. On va donc passer à 20kOhms pour s'assurer que le temps de déchargement des capas soit supperieur a la plage de temps de rebond des boutons. Ainsi, l'arduino recevra un signal bien proper et l'utilisation sera bien fluide.

On arrive donc au shémas de câblage suivant:



Pour le code, ça vient ça vient!!!  J'espère fini et rode avant la fin du grand WE!

Bonne journée!!

Bon j'en suis la!!:


Ça marche :)

C'est nickel!! La jsuis en train de cogiter pour remplacer les relais par des MOSFETs, moins encombrants, pas bruitants et progressifs.

La suite bientôt :)

Bonsoir Benjamin,
Tu n'as donc pas trouvé la solution pour gérer les cligno sans bloquer le programme ?!!
J'ai un peu de temps en début de semaine, j’essaierai de voir si je trouve une solution.
En tout cas, beau boulot !! et super projet !

Ouai je galere avec ça!!! je n'ai que 2 semaines d'expérience!
Mais j'ai un collègue qui touche bien en prog arduino, et il sera la cette semaine au bureau donc je compte y arriver avec lui! Ya aussi mon prog des phares à terminer, pour gérer les appels de phares, et l'extinction par appuie long. Du coup, je travaille surtout actuellement à remplacer les relais par des MOSFETs pour supprimer cet encombrant bloc de relais, et ne plus avoir les petits bruits de switch mécanique à chaque fois. D'ailleurs, j'ai ma solution, il me faudra deux transistors par sortie. Un petit PNP qui vient commander un gros NPN, de manière à gérer le + des accessoires et non le moins, et donc pouvoir tout brancher à la masse et ne pas doubler le nombre de fils. un truc de ce goût la:



Bon par contre l'inconvéniant, c'est que ce circuit n'existe pas en standard déjà fait. Il faudra donc souder quelques composants sur un bout de plaque cuivrée. Enfin rien de très méchant. C'est juste plus chiants, pour ceux qui voudraient se faire le même, que de simplement brancher le bloc de relais tout fait.

Pour ton aide sur le code, elle est la bienvenue!!! voici le début de mon code (celui mis en oeuvre dans la vidéo, adapté à une Arduino Mega)

Code:

const int boutonA = A0;
const int boutonB = A1;
const int boutonC = A2;
const int boutonD = A3;
const int contactStop = A4;
const int contactPin = A5;

const int clignoDroitPin = 22;
const int clignoGauchePin = 29 ;
const int pharePin = 25;
const int codesPin = 26;
const int feuxStopPin = 24;
const int klaxonPin = 23;
const int auxPin = 28;
const int demarreurPin =27 ;

int etatBoutonA;
int etatBoutonB;
int etatBoutonC;
int etatBoutonD;
int etatContactStop;
int etatContact;

int etatClignoDroit;
int etatClignoGauche;
int etatPhare;
int etatCodes;
int etatFeuxStop;
int etatKlaxon;
int etatAux;
int etatDemarreur;



boolean phareON  = false;
boolean codesON = true;
             
void setup()
{

  pinMode (boutonA, INPUT);
  pinMode (boutonB, INPUT);
  pinMode (boutonC, INPUT);
  pinMode (boutonD, INPUT);
  pinMode (contactStop, INPUT);
  pinMode (contactPin,INPUT);
 
  pinMode (clignoDroitPin, OUTPUT);
  pinMode (clignoGauchePin, OUTPUT);
  pinMode (pharePin, OUTPUT);
  pinMode (codesPin, OUTPUT);
  pinMode (feuxStopPin, OUTPUT);
  pinMode (klaxonPin, OUTPUT);
  pinMode (auxPin, OUTPUT);
  pinMode (demarreurPin, OUTPUT);
 
  digitalWrite(boutonA, HIGH);
  digitalWrite(boutonB, HIGH);
  digitalWrite(boutonC, HIGH);
  digitalWrite(boutonD, HIGH);
  digitalWrite(contactStop, HIGH);
  digitalWrite(contactPin, HIGH);

}

void loop() {

  etatBoutonA = digitalRead(boutonA);
  etatBoutonB = digitalRead(boutonB);
  etatBoutonC = digitalRead(boutonC);
  etatBoutonD = digitalRead(boutonD);
  etatContactStop = digitalRead(contactStop);
  etatContact = digitalRead(contactPin);
  etatCodes = digitalRead(codesPin);
  etatPhare = digitalRead(pharePin);
 
// Coupure Contact

if (etatContact == HIGH)
{
  digitalWrite(auxPin,HIGH);
  digitalWrite(demarreurPin,HIGH);
  digitalWrite(klaxonPin,HIGH);
  digitalWrite(codesPin,HIGH);
  digitalWrite(pharePin,HIGH);
  digitalWrite(clignoDroitPin,HIGH);
  digitalWrite(clignoGauchePin,HIGH);
}

// prog Contact auxiliaire

if (etatContact == LOW)
{
  digitalWrite(auxPin,LOW);
}
else
{
  digitalWrite(auxPin,HIGH);
}

// prog Demmarreur:

if ((etatContact == LOW)&&(etatBoutonA == LOW)&&(etatBoutonB==LOW))

{
  digitalWrite(demarreurPin,LOW);
  digitalWrite(klaxonPin,HIGH);
  digitalWrite(feuxStopPin,HIGH);
  digitalWrite(codesPin,HIGH);
  digitalWrite(pharePin,HIGH);
  digitalWrite(clignoDroitPin,HIGH);
  digitalWrite(clignoGauchePin,HIGH);
}
else
{
  digitalWrite(demarreurPin,HIGH);
 
}

// prog Klaxon:

if ((etatContact == LOW)&&(etatBoutonC == LOW)&&(etatBoutonB == HIGH))
{
  digitalWrite(klaxonPin,LOW);
}
else
{
  digitalWrite(klaxonPin,HIGH);
}

// prog feux Stops:

if ((etatContact == LOW)&&(etatContactStop == LOW)&&(etatBoutonB == HIGH))
{
  digitalWrite(feuxStopPin,LOW);
}
else
{
  digitalWrite(feuxStopPin,HIGH);
}

// prog Phares:


if((etatContact == LOW)&&(etatBoutonB==LOW))
{

  delay(500);

  codesON=!codesON;
  phareON=!phareON;
 
  digitalWrite(codesPin,codesON);
  digitalWrite(pharePin,phareON);

}


}

Concrètement, une fois au guidon ça va pas commencer à être compliqué de mémoriser les séquences d'appui sur les boutons ?
Genre tu veux clignoter à droite et tu éteins le phare en klaxonnant...

off 4 boutons ça va encore!!! Si c'est ta moto tu la connais! Après c'est clair, c'est pas à monter sur des bécanes de location! (je doute qu'il y en ai beaucoup sur le forum).

Enfin du retour que j'ai eu de ceux qui utilisent le M-Unit en mode 4 boutons, ça ne pose aucun souci. Ils disent même être plus à l'aise avec le système cligno 2 boutons, que l'inverseur d'origine. Particulièrement avec des gros gants.

Pis quand on y reflechi bien c'est hyper simple!  Des deux boutons à l'exterieur, ce sont les clignos. Les deux autres, ce sont les phares à gauche et le klaxon à droite. Après le démarreur, ce n'est pas en roulant.

Les poussoirs pour les cligno ne sont pas appréciés de tout le monde. BMW les main tait depuis les GS et R100R et sur les 8 soupapes et le K mais apparement ce n'était pas apprécié par certains clients. 

Je trouve ça beaucoup plus pratique que le petit bidule à pousser à droite ou à gauche et surtout beaucoup plus ergonomique. 
Sur la 1100s, il y a même l'extinction automatique des clignos après une certaine distance. Le défaut de BMW est d'avoir ajouté un poussoir pour éteindre la clignos et un bouton distinct pour le warning.

Pour les identifier, on peut y mettre des pictogrammes et/ou des couleurs, tout dépend de l'humeur et du style qu'on recherche.

Je pense que c'est une question d'habitude, quand on a roulé des années sur une japonaise et qu'on passe sur une Harley, il faut un temps d'adaptation.
Perso, j'ai du mal avec les comodo BMW des série 7, où la position des boutons est soit HAUT soit BAS...et souvent on oublie de les repositionner au centre...

Salut Benjamin,

Super intéressant ton topic, je suis en train de prendre la même voie avec un arduino pour faire un feux arrière avec des leds à couleurs variables (feux et clignos combinés).

Pour la gestion des clignos, c'est la commande "delay" qui te fous dedans. Delay dit au proc de ne rien faire pour un certain temps, et pour le coup il ne fait vraiment rien...

Je te conseille ce tuto qui résout le problème en contournant la commande delay: https://learn.adafruit.com/multi-tasking-the-arduino-part-1/overview , il y a trois partie en tout et c'est très très intéressant!

Salut Gruduk!

Merci pour le lien!! Oui je connais bien le souci de la delay, c'est pour ça d'(ailleurs que j'utilise maintenant Milis, avec gestion des fronts montants et descendants. 9a fonctionne bien mieux.

Ahah je suis aussi en trained bosser en // sur une gestion de feux AR avec LEDs RGB haute lum. commandés par arduino.

Dans mon cas, ce sont deux "bouchons" qui viennent se loger dans les tubes diam 22 (coupés) d'une boucle Ar de 750 Suz. 5 LEDS RGB de chaque côté. Gérés avec les sorties pwm de l'arduino et alimentées par des MOSFETs et non des relays.

Du coup, en temps normal, les LEDs sont toutes rouges et à 65% de leur intensité. Quand on à besoin de feux STOP, ells passent à rouge 100% de leur intensité.

Quand on à besoin d'un cligno, 3 LED du côté concerné deviennent Orange/Jaune clignotantes et les autres restent rouges.

Par contre, ça t'oblige à gerer aussi les clignos avant avec l'arduino (par des sorties séparées) et de synchroniser les Av et Ar dans le programme. Sinon gros bordel de câblage en vue!

bonjour
 suis une nouille en informatique mais ton montage est super intéressant,merci de nous faire partager tout ca,et vivement qu on en colle un sur nos brèles on va économiser du cuivre...

Bon ça y est, tout fonctionne!

Avec le bloc de relais en tous cas. Je vais monter le premier proto sur une bécane ce WE si je trouve le temps. Sinon, ce sera après le Wheels and Waves donc à partir du 17

Mais bon je ne vois pas ce qui peut déconner, tout marche nickel sur ma maquette en 12V dc.

En // J'ai travaillé sur la version sans relais, avec mes assemblages de transistors MOSFETs.  Ca ne sera pas beaucoup plus compliqué à monter, et bien plus compacte. Par contre un poil plus cher car il faut commander le circuit imprimé chez un fournisseur genre TOULET qui sont très bien et très sympas: Liens vers la page de circuits sur mesure de chez TOULET www.circuit-electronique.fr

Le circuit va ressembler à ça:

(taille réelle: 89mm par 89mm)






En vert, ce sont les pistes du circuit (vues par transparence). En rouge, les ponts à souder (petits fils semi rigides) et en jaune, la trace des composants pour aider au montage.

on ajuste à y monter la petite arduino, 8 MOSFET de puissance, 8 MOSFET de commande, quelques résistances, une diode et un condo.

Avec un plan montage, un enfant pourrait le faire. Faut juste mettre les composants dans le bon sens et dans les bons trous...

Ensuite on relie les boutons au trous du bas, les éléments de la moto au trous du haut, le 12V à la batterie, la masse à la masse et Tadam! une centrale pour pas cher!

- l'arduino: 8€ (pour une Funduino nano sur ebay)

- Les gros mosfets: entre 2 et 5€ (REF

- les petits MOSFETs: entre 2 et 5€ (REF BS 170)

- les résistances: environ 5€ pour le tout (x14 10k Ohm et x8 1kOhm)

- le condo: - de 0.5€ (1000uF 25V radial chimique en diam 10)

- la diode: - de 0.2€ (une diode tout ce qu'il y a de plus basique)

- le circuit sur mesure: une petite trentaine d'€ fait en France chez Toulet, beaucoup moins fait par un équivalent en chine (mais avec 2/3 semaines de délais)

Pour faire ça ils vous manqué:

- le programme de l'arduino => je le rends accessible sous quelques jours, le temps de le fiabiliser

- le typon du circuit à envoyer au fournisseur pour qu'il le réalise. => ça aussi, je mets à dispo dès que j'ai fini mes éssais et que j'ai rode l'affaire.

Voila voila!  ça prend sérieusement forme!

Le concept est basique: les pins de l'arduino (les sorties) vienne metre sous tension ou non les petits mosfet (= transistors). Ainsi, ces petits mosfets viendrons commander des plus gros MOSFETs qui viendrons à leur tour allimenter ou non les sorties de la carte.

 

Les résistances servent juste à créer des petits courants de commande. Et le condo sert à alimenter l'arduino pendant les quelques millièmes de seconde ou le moteur du démarreur se lance, et pompe ainsi tout le jus de la batterie, risquant de créer une chute de tension que l'arduino n'aimerait pas! (ça ne la grillerait pas, mais elle risquerait de s'éteindre et donc de couper le programme).

Bonne journée !