c'est quoi ce "bazar" (
)? les boutons sont déjà lus et la vitesse est dans la variable vitesse. il suffit juste d'appeler affichage(vitesse);
vous avez un lien vers votre 7-segments?
Je ne sais pas car je fait mes essais avec l arduino non branché au pc car je n ai pas de cordon assez long...
Mais mon code fonctionne tel quel... c est juste que je ne sais pas comment ajouter la fonction de réglage...
Dans l ideal... j'aimerais pouvoir sélectionner ma vitesse avec les palettes... puis avec 2 autres bp... régler l angle du servo et que ce réglage reste en mémoire ...
Merci pour l info pour l afficheur....je vais potasser ça 
pensez vous que ça peut dériver dans le temps ? si oui il faudra conserver la fonctionnalité de calibrage sur la version finale, si non - il suffit de le faire une fois en tâtonnant un peu mais pas besoin du code dans le code final.
un encodeur rotatif serait peut-être plus simple que deux boutons : vous choisissez une vitesse, vous tournez à droite au gauche l'encodeur pour régler le servo pour cette vitesse, vous appuyez sur le bouton de l'encodeur pour enregistrer cela. On met le tout en EEPROM pour la prochaine fois.
Bhen comme je suis une quiche en programmation... j ai juste pris un code d afficheur sur le net que j ai modifié et mixé avec ton code 
C est pas très pro mais ça fonctionne
Voici mon afficheur...
AERZETIX - C44176 - Lot de 4 - Afficheur Numérique - Module - Panneaux Lumineux - 19x12.6mm - LED 7 Segments - Rouge - THT - Nombre de Chiffre 1 https://www.amazon.fr/dp/B08L4MG2K3/ref=cm_sw_r_cp_apan_glt_i_PPYFJPP7X435NJMTYMN2?_encoding=UTF8&psc=1
Ca me paraît compliqué et je n ai pas d encodeur en stock...
En fait j ai juste besoin de 2bp pour un reglage fin ( par paliers de un ou 2 degrés) de la vitesse active...
c'est pas compliqué mais si vous n'en avez pas alors c'est une bonne raison de ne pas prendre cette option
dans votre code, digitalWrite(a, OUTPUT);n'est pas bon - c'est pinMode() qu'il faudrait utiliser
Pourriez vous déjà tester cela pour l'affichage des vitesses:
#include <Servo.h>
Servo levierVitesse;
const byte pinServo = 5;
#include <simpleBouton.h> // cf @bricoleau @ http://forum.arduino.cc/index.php?topic=375232.0
const byte pinPalettePlus = 2; //Cablage : pin 4 --- bouton --- GND
const byte pinPaletteMoins = 3; //Cablage : pin 5 --- bouton --- GND
simpleBouton boutonPlus(pinPalettePlus);
simpleBouton boutonMoins(pinPaletteMoins);
const byte pin7Seg[] = {12, 11, 10, 9, 8, 7, 6};
const byte chiffres7Seg[] = {0b1110111, 0b0010101, 0b0110000, 0b1101101, 0b1111001, 0b0110011, 0b1011011, 0b1011111, 0b0, 0b0};
void affichageChiffre(byte chiffre) { // de 0 à 7 seulement
if (chiffre >= sizeof chiffres7Seg) chiffre = (sizeof chiffres7Seg) - 1;
for (byte b = 0; b < sizeof pin7Seg; b++) digitalWrite(pin7Seg[b], bitRead(chiffres7Seg[chiffre], b) ? HIGH : LOW);
}
const int boite[] = {700, 930, 1160, 1390, 1620, 1850, 2080}; // les valeurs d'angles en µs
const byte nombreDeVitesses = sizeof boite / sizeof boite[0];
byte vitesse = 1; // vitesse par défaut
inline void reglerVitesse() {
levierVitesse.writeMicroseconds(boite[vitesse]);
Serial.print(F("Vitesse ")); Serial.print(vitesse);
Serial.print(F("\tangle ")); Serial.println(boite[vitesse]);
affichageChiffre(vitesse);
}
void plus() {
if (vitesse < nombreDeVitesses - 1) {
vitesse++;
reglerVitesse();
}
}
void moins() {
if (vitesse > 0) {
vitesse--;
reglerVitesse();
}
}
void gestionPalettes() {
boutonPlus.actualiser();
if (boutonPlus.vientDEtreEnfonce()) plus();
else {
boutonMoins.actualiser();
if (boutonMoins.vientDEtreEnfonce()) moins();
}
}
void setup() {
for (byte b = 0; b < sizeof pin7Seg; b++) pinMode(pin7Seg[b],OUTPUT);
Serial.begin(115200);
reglerVitesse();
levierVitesse.attach(pinServo);
}
void loop() {
gestionPalettes();
}
Tenez voici une version du code qui rajoute 2 boutons sur A0 et A1 pour régler l'angle associé à la vitesse actuelle. c'est tapé ici en faisant copier coller de ce que l'on fait pour la vitesse, donc totalement non testé.
/*
Câblage
PIN
0 NC (Rx)
1 NC (Tx)
2 pinPalettePlus pin 2 --- bouton --- GND
3 pinPaletteMoins pin 3 --- bouton --- GND
4 NC
5 pinServo pin 5 --- pin contrôle angle servo
6 7 Segment 'a' Prévoir résistance de limitation de courant (cf https://eskimon.fr/tuto-arduino-205-afficheurs-7-segments)
7 7 Segment 'b' Prévoir résistance de limitation de courant
8 7 Segment 'c' Prévoir résistance de limitation de courant
9 7 Segment 'd' Prévoir résistance de limitation de courant
10 7 Segment 'e' Prévoir résistance de limitation de courant
11 7 Segment 'f' Prévoir résistance de limitation de courant
12 7 Segment 'g' Prévoir résistance de limitation de courant
13 NC Led interne
A0 pinReglagePlus pin A0 --- bouton --- GND
A1 pinReglageMoins pin A1 --- bouton --- GND
A2
A3
A4
A5
*/
#include <Servo.h>
Servo levierVitesse;
const byte pinServo = 5;
#include <simpleBouton.h> // cf @bricoleau @ http://forum.arduino.cc/index.php?topic=375232.0
// le changement de vitesse
const byte pinPalettePlus = 2; //Cablage : pin 2 --- bouton --- GND
const byte pinPaletteMoins = 3; //Cablage : pin 3 --- bouton --- GND
simpleBouton boutonPlus(pinPalettePlus);
simpleBouton boutonMoins(pinPaletteMoins);
// le réglage de l'angle du servo
const byte pinReglagePlus = A0;
const byte pinReglageMoins = A1;
simpleBouton boutonReglagePlus(pinReglagePlus);
simpleBouton boutonReglageMoins(pinReglageMoins);
const byte pin7Seg[] = {12, 11, 10, 9, 8, 7, 6};
const byte chiffres7Seg[] = {0b1110111, 0b0010101, 0b0110000, 0b1101101, 0b1111001, 0b0110011, 0b1011011, 0b1011111, 0b0, 0b0};
void affichageChiffre(byte chiffre) { // de 0 à 7 seulement
if (chiffre >= sizeof chiffres7Seg) chiffre = (sizeof chiffres7Seg) - 1;
for (byte b = 0; b < sizeof pin7Seg; b++) digitalWrite(pin7Seg[b], bitRead(chiffres7Seg[chiffre], b) ? HIGH : LOW);
}
int boite[] = {700, 930, 1160, 1390, 1620, 1850, 2080}; // les valeurs d'angles en µs
const byte nombreDeVitesses = sizeof boite / sizeof boite[0];
byte vitesse = 1; // vitesse par défaut
inline void reglerVitesse() {
levierVitesse.writeMicroseconds(boite[vitesse]);
Serial.print(F("Vitesse ")); Serial.print(vitesse);
Serial.print(F("\tangle ")); Serial.println(boite[vitesse]);
affichageChiffre(vitesse);
}
void vitessePlus() {
if (vitesse < nombreDeVitesses - 1) {
vitesse++;
reglerVitesse();
}
}
void vitesseMoins() {
if (vitesse > 0) {
vitesse--;
reglerVitesse();
}
}
void reglagePlus() {
boite[vitesse]++;
reglerVitesse();
}
void reglageMoins() {
boite[vitesse]--;
reglerVitesse();
}
void gestionPalettes() {
boutonPlus.actualiser();
if (boutonPlus.vientDEtreEnfonce()) vitessePlus();
else {
boutonMoins.actualiser();
if (boutonMoins.vientDEtreEnfonce()) vitesseMoins();
}
}
void gestionAngle() {
boutonReglagePlus.actualiser();
if (boutonReglagePlus.vientDEtreEnfonce()) reglagePlus();
else {
boutonReglageMoins.actualiser();
if (boutonReglageMoins.vientDEtreEnfonce()) reglageMoins();
}
}
void setup() {
for (byte b = 0; b < sizeof pin7Seg; b++) pinMode(pin7Seg[b], OUTPUT);
Serial.begin(115200);
reglerVitesse();
levierVitesse.attach(pinServo);
}
void loop() {
gestionPalettes();
gestionAngle();
}
comme il commence à y avoir pas mal de fils, j'ai rajouté en début du code un tableau récapitulatif de ce qui doit être branché sur quelle pin (NC = Non Connecté)
Il n'y a pas la sauvegarde en EEPROM, il suffirait d'écrire le tableau boite en mémoire.
Merci énormément !
Je testerais ça ce soir je pense
Par contre pour la mise en mémoire je doit ajouter encore un bouton pour valider ou ca peut se faire automatiquement ?
on peut le faire automatiquement à chaque modification d'angle. Une case EEPROM peut-être écrite 100,000 fois ensuite elle ne fonctionne plus, donc faudra pas abuser du réglage - mais si c'est fait à la main 100,000 c'est déjà beaucoup...
On pourrait aussi faire que si les 2 boutons sont appuyés en même temps ou un double click alors ça sauvegarde en EEPROM. comme ça il y aurait moins d'écritures
Les 2 boutons en même temps me parais êtres une bonne solution...
Les boutons de réglages ne seront pas accessibles et resteront dans la boîte plexo que j ai prevus pour l arduino et le pont en H , et donc pas de risques de fausse manip...
Et tout cas je te remercie encore de me mâcher autant le travail !
Le projet seras grâce à toi très probablement fonctionnel pour notre course du 11 et 12 septembre
Ca fait vraiment plaisir de tomber sur des personnes comme toi qui donne de leur temps comme ca !!!
Ca se fait rare de nos jours....
Et d ailleurs... pour te remercier... si tu a besoin de petites pièces en impression 3d... je suis a ta disposition
Si non pour info... mon servo diy est fonctionel...
Mais... forcément...encore un mais...
J ai un peu sous-estimé la puissance nécessaire à manipuler la boite avec mon motreducteur...
Donc je repart sur l équipe gagnante et la bidouille dejas tester et approuvé... c est a dire un moteur d essuie glace couplé à un servo dont la mécanique est hs
Dans ce cas, comment est alimenté l'ARDUINO ?
J utilise un transfo 220v/12v qui alimente une alim 12v/5v de cette platine dessai :
AZDelivery MB 102 Kit Électronique: Platine d'essai à 830 Points Breadboard + adaptateur secteur (3,3V/5V) + 65 morceaux de câbles (Connecteurs) compatible avec Arduino incluant un E-Book! https://www.amazon.fr/dp/B01N4VCYUK/ref=cm_sw_r_cp_apan_glt_i_EZ7MBCXZFQP4K0QMHQ9B?_encoding=UTF8&psc=1
J ai pas tester en alimentant l arduino direct en 12v....
Pour le tracteur j ai prevus un regulateur 12v 3A pour l alimenter...
Mais j aurais aussi un autre regulateur 12v vers 5v 3A qui me serviras a alimenter mes rubans led adressable effet k2000 qui sert a rien a part faire joli et passer pour un boufon... mais je m en fout... j aime l autodersion et passer pour un con sans l être
Avec 7 segments allumés, le besoin est de 70mA (avec des résistances de 470Ω).
La tension entre entrée et sortie du régulateur = 12V - 5V = 7V.
La puissance qu'il doit dissiper est de 7V * 70mA = 490mW, ce qui est largement supportable par la plupart des régulateurs du type AMS1117 (ce qui est probablement le cas de ton adaptateur).
A moins que ton bloc secteur ne produise une tension largement supérieure à 12V (à vérifier).
Pour ma part, allumer tous les segments d'un afficheur avec les sorties d'une UNO alimentée par USB produit la même luminosité qu'un segment seul alimenté sous 5V (avec résistances de 220Ω dans les deux cas).
Il est tout de même dommage de devoir débrancher l'ARDUINO du PC pour faire des tests, et de devoir se passer du moniteur série..
Peut-être rapprocher la maquette du PC ?
je trouve que le projet est fun donc ça m'amuse de vous aider ! (sinon je ne fais généralement pas de code à la demande).
tenez, voici une nouvelle version plus aboutie:
/*
Câblage
PIN
0 NC (Rx)
1 NC (Tx)
2 pinPalettePlus pin 2 --- bouton --- GND
3 pinPaletteMoins pin 3 --- bouton --- GND
4 NC
5 pinServo pin 5 --- pin contrôle angle servo
6 7 Segment 'a' Prévoir résistance de limitation de courant (cf https://eskimon.fr/tuto-arduino-205-afficheurs-7-segments)
7 7 Segment 'b' Prévoir résistance de limitation de courant
8 7 Segment 'c' Prévoir résistance de limitation de courant
9 7 Segment 'd' Prévoir résistance de limitation de courant
10 7 Segment 'e' Prévoir résistance de limitation de courant
11 7 Segment 'f' Prévoir résistance de limitation de courant
12 7 Segment 'g' Prévoir résistance de limitation de courant
13 NC Led interne
A0 pinReglagePlus pin A0 --- bouton --- GND
A1 pinReglageMoins pin A1 --- bouton --- GND
A2
A3
A4
A5
*/
// Gestion de la sauvegarde
#include <EEPROM.h>
const uint32_t motClef = 0xDEADBEEF;
const uint16_t adresseMotClef = 0x10;
const uint16_t adresseDesParametres = adresseMotClef + sizeof motClef;
// Gestion du Servo
#include <Servo.h>
Servo levierVitesse;
const byte pinServo = 5;
// Gestion des boutons
#include <simpleBouton.h> // cf @bricoleau @ http://forum.arduino.cc/index.php?topic=375232.0
const uint8_t delaiDebounce = 40;
// le changement de vitesse
const byte pinPalettePlus = 2; //Cablage : pin 2 --- bouton --- GND
const byte pinPaletteMoins = 3; //Cablage : pin 3 --- bouton --- GND
boutonAction boutonPlus(pinPalettePlus, delaiDebounce);
boutonAction boutonMoins(pinPaletteMoins, delaiDebounce);
// le réglage de l'angle du servo
const byte pinReglagePlus = A0;
const byte pinReglageMoins = A1;
boutonAction boutonReglagePlus(pinReglagePlus, delaiDebounce);
boutonAction boutonReglageMoins(pinReglageMoins, delaiDebounce);
const byte pin7Seg[] = {12, 11, 10, 9, 8, 7, 6};
const byte chiffres7Seg[] = {0b1110111, 0b0010101, 0b0110000, 0b1101101, 0b1111001, 0b0110011, 0b1011011, 0b1011111, 0b0, 0b0};
void affichageChiffre(byte chiffre) { // de 0 à 7 seulement
if (chiffre >= sizeof chiffres7Seg) chiffre = (sizeof chiffres7Seg) - 1;
for (byte b = 0; b < sizeof pin7Seg; b++) digitalWrite(pin7Seg[b], bitRead(chiffres7Seg[chiffre], b) ? HIGH : LOW);
}
byte vitesse = 1; // vitesse par défaut
const byte nombreDeVitesses = 7;
struct __attribute__ ((packed)) _paramS {
int boite[nombreDeVitesses];
} lesParametres;
// --- EEPROM ----
void imprimerConfiguration()
{
Serial.print(F("ANGLES SERVO = "));
for (byte v = 0; v < nombreDeVitesses; v++) {
Serial.print(lesParametres.boite[v]);
Serial.write(' ');
}
Serial.println();
}
void ecrireConfiguration() {
Serial.println("Sauvegarde");
EEPROM.put(adresseMotClef, 0x0ul);
EEPROM.put(adresseDesParametres, lesParametres);
EEPROM.put(adresseMotClef, motClef);
imprimerConfiguration();
}
void lireConfiguration()
{
uint32_t lectureMotClef;
EEPROM.get(adresseMotClef, lectureMotClef);
if (lectureMotClef == motClef) {
// EEPROM déjà initialisée, on charge les paramètres
EEPROM.get(adresseDesParametres, lesParametres);
} else {
// EEPROM incohérente, on établit des valeurs par défaut
// un servo reçoit généralement une valeur entre 1000 et 2000, 1500 étant 90°
// on met des valeurs à la louche entre 1200 et 1800
for (byte v = 0; v < nombreDeVitesses; v++)
lesParametres.boite[v] = map(v, 0, nombreDeVitesses - 1, 1200, 1800);
ecrireConfiguration();
}
imprimerConfiguration();
}
// --- VITESSES ----
void reglerVitesse() {
levierVitesse.writeMicroseconds(lesParametres.boite[vitesse]);
Serial.print(F("Vitesse ")); Serial.print(vitesse);
Serial.print(F("\tangle ")); Serial.println(lesParametres.boite[vitesse]);
affichageChiffre(vitesse);
}
void vitessePlus() {
if (vitesse < nombreDeVitesses - 1) {
vitesse++;
reglerVitesse();
}
}
void vitesseMoins() {
if (vitesse > 0) {
vitesse--;
reglerVitesse();
}
}
// --- CONFIGURATION ----
void reglagePlus() {
lesParametres.boite[vitesse]++;
reglerVitesse();
}
void reglageMoins() {
lesParametres.boite[vitesse]--;
reglerVitesse();
}
void gestionBoutons() {
boutonPlus.actualiser();
boutonMoins.actualiser();
boutonReglagePlus.actualiser();
boutonReglageMoins.actualiser();
}
void setup() {
for (byte b = 0; b < sizeof pin7Seg; b++) pinMode(pin7Seg[b], OUTPUT);
boutonPlus.attacher(vitessePlus);
boutonMoins.attacher(vitesseMoins);
boutonReglagePlus.activerRepetition();
boutonReglageMoins.activerRepetition();
boutonReglagePlus.attacher(reglagePlus, ecrireConfiguration);
boutonReglageMoins.attacher(reglageMoins, ecrireConfiguration);
Serial.begin(115200);
Serial.println();
lireConfiguration();
reglerVitesse();
levierVitesse.attach(pinServo);
}
void loop() {
gestionBoutons();
}
- les boutons sur les pins 2 et 3 sont pour la palette (+ et -)
- les boutons sur les pins A0 et A1 sont pour la configuration des angles (+ et -) et la sauvegarde en EEPROM par double click sur un des boutons (n'importe lequel).
- les boutons A0 et A1 savent gérer la répétition avec accélération donc si vous en tenez un appuyé l'angle va augmenter ou diminuer tout seul (de plus en plus en plus vite), pas besoin de faire des tonnes de clicks. bien sûr un click "solitaire" marche aussi pour régler finement.
Une fois qu'un angle est bon, faites un double click sur un des boutons de réglage et la config est mémorisée, même si vous éteignez l'Arduino.
Tout cela est possible en quelques lignes grace à la bibliothèque de @bricoleau. C'est lui qu'il faut remercier
Dites moi si ça compile et fonctionne, je n'ai pas testé
Je me demmande si ce n est pas la mon erreur...
C est un transfo chinoi de récup de 1A max...
Et ta réponse viens de me faire tilter...
Entre la conso de la platine, de l arduino et de l afficheur... le pb viens sûrement de la ...
Je vais me pencherai la dessus... merci à toi...
Merci... et content que ça te plaise... mais STP... arrête de me vouvoyer
Et encore une fois ... merci à toi !!!
J apprécie vraiment énormément !!!
N hezite vraiment pas a me contacter si tu a besoin des compétences que je maîtrise à peu près comme l impression 3d , le modélisme en général, ou les énergies alternatives comme le photovoltaïque ou les modif de moteurs thermiques pour tourner a l ethanol E85
Au passage ... mes 2 tracteurs (gp1 et gp3) , mon groupe électrogène de secours pour l installation solaire, ainsi que ma 2cv me servant tous les jours tournent à l ethanol ...
MERCI J-M-L !!!!
Tu est un génie !!!!
Non seulement ton code fonctionne a merveille...
Mais en plus... vas savoir pourquoi... cela a résolu mon pb de luminosité sur l afficheur...
Donc avec les résistances... il s affiche normalement
Un seul bémol mais qui n en est pas un...
Le reglage des vitesses est très long ... et il faut rester appuier longtemps pour que le servo commence à bouger...
Mais c est pas plus mal... au contraire... cela évite les fausses manips....
Bref... c est vraiment parfait !!!
Dommage que je n ai pas le temps de finaliser tout ça pour ce week-end...
Et oui on vas faire les idiots sur nos tracteurs ce week-end sur un terrain privé puisque notre chère président a forcé une autre asso à annuler une autre grosse course du côté de Bordeaux... 
Salut, cool si ça fonctionne !
si vous trouvez que ça va trop lentement, vous pouvez changer
lesParametres.boite[vitesse]++;
en
lesParametres.boite[vitesse] += 10;
ça augmentera de 10 en 10
idem pour l'autre sens:
lesParametres.boite[vitesse]--;
en
lesParametres.boite[vitesse] -= 10;
mais on perdra en granularité.
J'ai pas regardé mais peut-être que vous appeliez constamment l'affichage et que ça générait un "clignottement" imperceptible à cause de la persistence rétinienne mais comme ce n'était pas stable, vous n'avez pas toute la luminosité
En récompense pour le travail du forum on veut un reportage photo sur la course
EDIT: oups, j'ai encore dit vous... désolé mais c'est l'habitude des "vieux"
PS/ je ne suis pas sûr que notre président soit directement impliqué dans ces décisions...
Pas de soucis...
D ailleurs les courses seront normalement, comme l année dernière, retransmisent en direct sur YouTube
Mais je ne manquerai pas de poster ici une vidéo des essais de la boite séquentielle
Salut...
Bon j ai pas encore monté le système sur le tracteur... mais ça s'annonce bien
En attendant, une petite vidéo de ce week-end de la rencontre inter-association a Langon
1 Like
Petit essai de mon servo 2.0 a base de moteur d essuie glace :
Ce coup ci il est largement asser puissant pour manipuler ma boite...
Il ne reste plus qu a monter tout ça sur le tracteur pour passer aux choses sérieuses
Et au passage... impression en 3d d une pièce pour l afficheur 7 segments pour le volant
Vivement vendredi...!!! C est les congés !!!