Quand tout sera ok, si tu es d’accord, je suis prêt à faire le testeur (si c’est pas trop dur à monter) et si cela fonctionne bien, ton premier client .
A suivre…
A voir , pour moi aussi 
j en connais qui vont casser du d-max 
Y en aura pour tout le monde, quand tout sera au point pil poil.
Je veux pas vous filer un truc qui pète ouqui accélère tout seul quand il faut pas.
Vendre est un grand mot, je suis pas comme ça, juste le juste prix des composants, et si on est pas trop loin une rencontre merguez le temps d’un week end. Voir une grosse livraison à la prochaine AG.
// appel bibliotheque control servo
#include <Servo.h>
// déclaration des variables temps
long temps;
// definition pates
boolean frein =2;
boolean on =3;
boolean plus = 4;
boolean moins = 5;
boolean cpmh = 6;
boolean buzz = 7;
boolean led =13;
// definition variable
boolean buzzytps=0 ;
boolean autorisation=0;
unsigned int tpstourref=0;
unsigned int tpstour=0;
unsigned int tpstour1=0;
unsigned char etat=0;
int delta=0;
// definition servo
Servo moteur;
// ***********************************************************************************************
void setup() //fonction d’initialisation de la carte
{
moteur.attach(8,1000,2000); //on déclare l’entrée du servo connectée sur la broche 8
Serial.begin(9600); //on oublie pas de démarrer la liaison série 
//initialisation broches entrée
pinMode(frein, INPUT);
pinMode(on, INPUT);
pinMode(plus, INPUT);
pinMode(moins, INPUT);
pinMode(cpmh, INPUT);
// activation Rt pull-up
digitalWrite(frein, HIGH);
digitalWrite(on, HIGH);
digitalWrite(plus, HIGH);
digitalWrite(moins, HIGH);
digitalWrite(cpmh, HIGH);
//initialisation broches sortie
pinMode(buzz, OUTPUT);
moteur.write(etat);
// definition broches interruption
attachInterrupt(frein, pedalefrein, FALLING);
attachInterrupt(on, bouton_on, FALLING);
}
// ******************************************************************************************
void loop() //fonction principale, elle se répète (s’exécute) à l’infini
{
while (autorisation = 1)
{
vitesse_reel;
delta_vitesse;
action;
interaction;
}
}
// interruption pedela de frein**************************************************
void pedalefrein()
{
etat=0;
moteur.write(etat);
boolean buzzytps=0 ;
tpstourref=0;
tpstour=0;
tpstour1=0;
delta=0;
autorisation =0;
}
// interruption bouton on****************************************
void bouton_on()
{
autorisation = ! autorisation; // sauvegarde appui bouton on/off
if (autorisation ==1)
{
vitesse_initiale; // appel fonction vitesse_initiale
precharge; // appel fonction precharge
}
else pedalefrein;
}
// ***************************************************************************************
void vitesse_initiale() // calcul vitesse initiale
{
while (digitalRead(cpmh)== FALLING); //attente capteur soit dégagé
temps = millis(); //on stocke la nouvelle heure
while (digitalRead(cpmh)== RISING); //attente tour terminé
tpstourref = millis() - temps;
tpstour1 = tpstourref;
}
// *******************************************************************************************
void precharge() // calcul précharge
{
if (tpstourref > 1000) etat = 0;
if (tpstourref > 900) etat = 5;
if (tpstourref > 800) etat = 10;
if (tpstourref > 700) etat = 15;
moteur.write(etat);
}
// ****************************************************************************************
void vitesse_reel() // calcul vitesse reel
{
while (digitalRead(cpmh)==FALLING); //attente capteur soit dégagé
temps = millis(); //on stocke la nouvelle heure
while (digitalRead(cpmh)==RISING); //attente tour terminé
tpstour = millis() - temps;
}
// ****************************************************************************************
void delta_vitesse() // calcul delta vitesse
{
delta = tpstour-tpstour1;
tpstour1 = tpstour; // memoire tps precedent
}
// *****************************************************************************************
void action() // calcul action du servo
{
if ((etat >= 90) || (etat <= 0)) buzzytps = !buzzytps; // inverseur buzzytps
else buzzytps =0;
buzzer; // appel fonction buzzer
if ((delta > 60) && ( etat < 90)) etat=etat +1;// accelerer 1 cran petit ecart +1
if ((delta > 80) && ( etat < 90))etat=etat +1;// accelerer 1 cran de plus moyen ecart +1+1
if ((delta > 99) && ( etat < 90))etat=etat +1;// accelerer encore 1 cran de plus grand ecart +1+1+1
if ((delta < 20) && ( etat > 0))etat=etat -1;// lacher 1 cran
if ((delta < 40) && ( etat > 0))etat=etat -1;// lacher 1 cran
if ((delta < 60) && ( etat > 0))etat=etat -1;// lacher 1 cran
moteur.write(etat); //envoyer info
}
// ***************************************************************************************
void interaction() // interaction
{
if (digitalRead(plus)==0) ( tpstourref= tpstourref - (tpstourref0.01));
if (digitalRead(moins)==0) ( tpstourref= tpstourref + (tpstourref0.01));
}
// *************************************************************************************
void buzzer() // buzzer alarme
{
digitalWrite(buzz, buzzytps);
}
nico…ton avis?
ça ressemble plus à un programme que le précédent jet non?
d’après le compilateur, il tourne presque 2 fois plus vite que l’ancien.
il me reste le problème touref tourref1 à régler et ça devrai coller…
Salut,
voila mes quelques remarques, j’ai regardé le début du code seulement…
Déclaration des variables pour les broches => plutôt des int que des boolean (Ca passe la compil?)
Fonction loop:
Vu qu’autorisation est initialisée à 0, tu vas rentrer dans la fonction et en sortir immédiatement => pas de boucle infinie, sauf si appui sur le bouton ON/OFF simultané avec lancement fonction
faudrait faire une boucle sans fin, récupérer l’état de la variable autorisation puis ensuite définir les instructions fonction de cette variable.
je me souviens du “switch…Case” qu’est assez adapté je pense pour ça (ça évite des batteries de if / else…)
void loop()
{
while (1) /* boucle infini, le seul moyen de sortir => couper l’alim*/
{
switch(autorisation)
{
case 0: /* si autorisation =0*/
pedalefrein;
break;
case 1: /* si autorisation =1 (soit bouton ON/off appuyé fonctions précharge et vitesse_initiale exécutées*/
vitesse_reel;
delta_vitesse;
action;
interaction;
break;
default:
pedalefrein; /* dans le doute on désactive */
}
}
}
Calcul de la vitesse réelle:
J’ai demandé à gogole des infos sur arduino, falling et rising correspondent à des changements d’états, pour voir passer digitalread(…) à vrai, il faut que l’instruction soit exécutée au moment où il y a un front montant ou descendant sur le capteur CMPH. (pb similaire ds toutes les fonctions ou il y a falling ou rising…)
Pas évident… faudrait mieux regarder un état du capteur à chaque passage dans une boucle, t’auras peut être un peu de retard sur la transition du capteur mais on parle de millisecondes…
il faudrait aussi se baser sur un comptage uniquement lorsque le capteur est masqué au PMH (plus facile à gérer)
ça donne un truc du genre
void vitesse_reel()
{
boolean stop=0;
boolean passage_low=0;
int i = 0;
While (stop !=1) /* boucle tant stop différent de 1*/
{
switch (digitalread(cmph)) /lecture de l’état de cmph/
{
case LOW: /si capteur à l’état bas/
passage_low=1 /* on indique qu’on est passé à l’état bas*/
break; /sortie du switch, passage dans la boucle suivante/
case HIGH: /si capteur à l’état haut/
if(i==0){
i++;
passage_low=0 /* si premier passage à l’état haut, on ne fait rien ça permet de se synchroniser au mieux avec le PMH au tour suivant*/
}
if (i==1 && passage_low){/* seconde détection du capteur à l’état haut après passage par l’état bas et synchro /
i++;
}
if ((i==2) && passage_low){ / confirmation de l’état haut du capteur*/
temps=millis(); /* on lance le comptage /
i++;
passage_low=0; / évite de calculer temps tour si prochaine scrutation se fait au moment ou le capteur est actif*/
}
if (i==3 && passage_low){/* détection capteur état haut après un tour*/
i++;
}
if((i==4) && passage_low){ /* confirmation capteur état haut et calcul du temps au tour*/
tpstour = millis() - temps;
stop =1; /* commande la sortie de la boucle au prochain passage dans while*/
}
break; /sortie du switch, passage dans la boucle suivante/
default: /si ni l’un ni l’autre…/
/* sortie du switch et passage dans la boucle suivante*/
}
}
}
Voila pour ce soir on en rediscute demain…
Ps dans la doc arduino que j’ai téléchargé je viens de voir que la fonction loop permettait de réaliser une boucle sans fin… donc ton code tel quel marche pour cette fonction 
!
ahhhh,ces electroniciens!!!
j y comprend rien à vos trucs!!!
je prefere l electricite que l electronique
à me faire mal,je prefere me faire electrocuter que eletroniq…r… 
Moi j’aime electroniquer 
moi aussi pais pas ME FAIRE…
j’en connais qui va bien s’amuser par ce jour d’intempérie…
pfff après 5H00 de prise de tête, j’ai modifier mon premier projet.
juste faire clignoter ma led un certain nombre de fois.
et bien…j’y suis arrivé
et il faut dire tout ça…
// ********** init pate
boolean bout_on=2; // pate de l’interruption n°2 nommé 0
boolean bout_plus=4; // pate classique
boolean led =6; // pate classique
// ********* variables
boolean autorisation=0; // taille 1 bit
boolean etat=1;
char x=1; // taille 4 bits
char y=3;
// ********* init platine
void setup()
{
pinMode(led, OUTPUT); // pate sortie
pinMode(bout_on, INPUT); // pate entrée
pinMode(bout_plus, INPUT); // pate entrée
digitalWrite(bout_plus, HIGH); // activation Resistance tirage interne
digitalWrite(bout_on, HIGH); // activ Rt interne
attachInterrupt(0, off, FALLING); // activation interruption 0 sur pate 2 qui appelle fonction off sur front descendant
} // grrr ici ne pas mettre () derriere nom de fonction
// ********* boucle infinie
void loop()
{
while (autorisation==1)
{
if (digitalRead(bout_plus)==0) boutplus(); // grrr ici mettre () derriere fonction
for (x=0;x<y;x++)
{
digitalWrite(led, etat);
etat=!etat;
delay(400);
digitalWrite(led, etat);
etat=!etat;
delay(400);
}
delay(1000);
}
}
// *********fonction off
void off()
{
autorisation =!autorisation;
y=3;
}
// *********fonction boutplus
void boutplus()
{
y++ ;
}
je ne me souvenais pas qu’il y avait autant de petits détails en programmation…
mettre ou non des parenthèses suivant si c’est un appel ou une déclaration de fonction…
quand on compare une valeur il faut doubler “==”
et tout plein de truc à la 
maintenant que la base marche, je vais pouvoir avancer vite.
la vidéo dans 10 min de ma led qui clignote
la preuve de mon truc qui m’a pris 5H00 !!!
La lumière fut …
T’inquietes nous non plus!!!
Bon la base tourne, lundi c’est monté dans le dmax
A+
comprend pas non plus, et plus ça avance plus je me dis que vous êtes des fou les gars
continue comme ça et tu va en avoir de la commande, surtout si ça pourra aussi aller sur mon L200
Boite auto+régulateur de vitesse, c’est tout ce qu’il me faut, je suis un gros fainéant , à quand le pilote automatique, j’ai pas les moyens de me payer un chauffeur
Oui ça sera adaptable sur tout modèle.