Jump to content

Leaderboard

Popular Content

Showing content with the highest reputation since 06/24/2024 in all areas

  1. 38 ans de terre séchée. C est ça sui fait pourrir.Nettoyage en règle.
    4 points
  2. On continue avec le compteur, la minutie et la patience sont les ingrédients essentiels. Ça va être pas mal cette couleur.
    4 points
  3. On finalise le remontage avec, étape du jour rénovation des boutons qui receveront des nouvelles ampoules. Bon, plus tôt j’ai passé 45 minutes à me battre avec mon horloge dont la lumière ne s’allumait pas jusqu’à ce que je me rappelle qu’elle ne s’allume qu’avec le contact 😅 #boulet
    4 points
  4. Mesdames, messieurs, j'ai l'honneur de vous partager ma fierté du moment: mon régulateur de régime moteur est parfaitement fonctionnel Je ne suis pas mécontent du résultat, loin de là! Bon certes il y a quelques petits détails qui mériteraient d'être revus, qui sont surtout dus à des limitations techniques. Mais globalement, j'ai un truc fonctionnel dont l'ergonomie s'approche de très près d'un régulateur qu'on trouve sur des voitures récentes et surtout (point crucial!) qui réagisse au doigt et à l'oeil pour se désactiver! Bien entendu, il faudra aussi que je peaufine certains paramètres, mais là, je crois que mon code est suffisamment robuste pour ne pas avoir à subir de modifications majeures. J'ai essayé de l'optimiser au maximum de mes compétences dans ce langage, et quand je compare la réactivité du rafraîchissement de l'affichage et de la réponse aux commandes avec ce que j'avais au début, je me dis que ce sera difficile de faire mieux. Je suis aussi content de voir que la prise en compte de l'optocoupleur n'a pas été si difficile que ça. J'ai eu un moment de frayeur au moment de mesurer la tension "de sortie" avec mon oscilloscope, car on passait de 6,5V (au compte tours, et qui est une tension trop élevée pour l'Arduino, d'où le pont diviseur de tension et l'optocoupleur) à 2,5V (ce qui est limite il me semble pour que l'Arduino puisse détecter quelque chose), mais ça marche impeccable! Avant de partager mon code (pour lequel je fais quand même une déclaration de non responsabilité s'il devait y avoir une réutilisation et un accident lié à son usage), voici deux vidéos du régulateur en action: https://dai.ly/krgwIx6xSHEzYNB8Vj2 https://dai.ly/k1PN0CIP65nboyB8Vj4 Et donc le code, adapté à mon montage et à ma voiture, et donc pour lequel je décline toute responsabilité encore une fois s'il devait y avoir un usage qui occasionnerait un quelconque accident ou détérioration: //##################################################################### //## Déclaration des variables d'environnement ## //##################################################################### #include <UTFT.h> // Bibliothèque écran #define TEMPS_MAINTIENLONG 1500 // Temps de maintien en appui long #define TEMPS_CHRONOOFF 2000 // Durée d'attente pour la fonction Off #define TEMPS_CHRONOLIMIT 3000 // Durée d'affichage du message LIMITE #define TAILLETABLE 5 // Nombre de valeurs de vitesse enregistrées pour faire le lissage #define CMDELECTROAIMANT 2 // Commande relais électroaimant de sécurité #define CMDDECELERATION 3 // Commande sens décélération (A-) #define CMDACCELERATION 6 // Commande sens accélération (A+) #define ECRANRES 8 // Ecran RES #define PWMMOTEUR 9 // PWM Moteur pour variation de vitesse #define ECRANCS 10 // Ecran CS #define ECRANSDA 11 // Ecran SDA #define ECRANDC 12 // Ecran DC #define ECRANSCL 13 // Ecran SCL #define VITESSE A1 // (Analogique) Compte tours ou vitesse #define POSITIONMOTEUR 3 // (Analogique) Résistance asservissement servomoteur #define BTNMEMO 4 // (Analogique) Bouton MEMO #define BTNPLUS 5 // (Analogique) Bouton + #define BTNMOINS 6 // (Analogique) Bouton - #define BTNOFF 7 // (Analogique) Bouton OFF (relais des pédales de frein et d'embrayage + bouton Off de la commande au volant) #define VITESSEMINI 1000 // Vitesse minimum pour l'activation du régulateur de vitesse (en tours par minute, à arrondir à la dizaine) #define VITESSEMAXI 4000 // Vitesse maximum pour l'activation du régulateur de vitesse (en tours par minute, à arrondir à la dizaine) #define CTRLVITMINI 100 // Vitesse minimum pour déclanchement de l'erreur à la lecture de la vitesse (en tours par minute, à arrondir à la dizaine) #define CTRLVITMAXI 5500 // Vitesse maximum pour déclanchement de l'erreur à la lecture de la vitesse (en tours par minute, à arrondir à la dizaine) #define PASVITESSE 10 // Pas avec lequel on incrémente ou diminue la valeur de vitesse (en tours par minute, à arrondir à la dizaine) #define GDPASVITESSE 50 // Pas avec lequel on incrémente ou diminue la valeur de vitesse lors d'appui long (en tours par minute, à arrondir à la dizaine) #define POSITIONSERVOMIN 1 // Position du servomoteur minimum au potentiomètre (en %) #define POSITIONSERVOMAX 99 // Position du servomoteur minimum au potentiomètre (en %) #define MARGESUPVITLENT 10 // Marge supérieure de vitesse avant décélération lente (en tours par minute, à arrondir à la dizaine) #define MARGEINFVITLENT 10 // Marge inférieure de vitesse avant accélération lente (en tours par minute, à arrondir à la dizaine) #define MARGESUPVITRAPID 40 // Seuil au delà duquel on calculera une valeur de décélération adaptée à l'écart entre l'actuel et la cible (en tours par minute, à arrondir à la dizaine) #define MARGEINFVITRAPID 30 // Seuil au delà duquel on calculera une valeur de décélération adaptée à l'écart entre l'actuel et la cible (en tours par minute, à arrondir à la dizaine) #define MARGEINFPOTLENT 7 // Marge inférieure de position accélérateur avant accélération rapide (pour accélération initiale) (en %) #define MARGEINFPOTRAPID 1 // Marge inférieure de position accélérateur avant accélération lente (pour accélération initiale) (en %) #define VARIATRAPIDPLUS 230 // Variateur maximum pour le moteur via la pin PWM pour l'accélération "rapide". (Valeur comprise entre 0 et 255) #define VARIATRAPIDMOINS 170 // Variateur maximum pour le moteur via la pin PWM pour la décélération "rapide". (Valeur comprise entre 0 et 255) #define VARIATLENTPLUS 75 // Variateur pour le moteur via la pin PWM pour l'accélération lente. (Valeur comprise entre 0 et 255, mini 60) #define VARIATLENTMOINS 35 // Variateur pour le moteur via la pin PWM pour la décélération lente. (Valeur comprise entre 0 et 255) //---------------------------------------------------------------------------------------------------------------------------- // Structure permettant de définir les propriétés d'un bouton //---------------------------------------------------------------------------------------------------------------------------- struct Bouton { int entree; // Entrée où le bouton est connecté bool boutonAppuye; // Etat du bouton unsigned long date; // Date à laquelle on a commencé à appuyer sur le bouton }; //---------------------------------------------------------------------------------------------------------------------------- // Définition des boutons //---------------------------------------------------------------------------------------------------------------------------- Bouton off; // Bouton OFF (relais des pédales de frein et d'embrayage + bouton Off de la commande au volant) Bouton memo; // Définition du bouton de mémorisation vitesse Bouton plus; // Définition du bouton + Bouton moins; // Définition du bouton - //---------------------------------------------------------------------------------------------------------------------------- // Définition des fonctions qu'on associe aux boutons //---------------------------------------------------------------------------------------------------------------------------- enum FonctionBouton { RIEN, // Fontion neutre, il n'y a rien à faire OFF, // Fonction OFF MEMO, // Fonction mémorisation vitesse MEMOLONG, // Fonction associée à l'appui long sur le bouton mémorisation PLUS, // Fonction + PLUSLONG, // Fonction appui long sur + MOINS, // Fonction - MOINSLONG, // Fonction appui long sur - }; //---------------------------------------------------------------------------------------------------------------------------- // Type énuméré permettant de définir les états des boutons //---------------------------------------------------------------------------------------------------------------------------- enum EtatBouton { RELACHE, // Le bouton est relâché (circuit ouvert) APPUYE, // Le bouton est appuyé (circuit fermé) MAINTIEN_LONG, // Le bouton est maintenu appuyé (circuit fermé) }; //---------------------------------------------------------------------------------------------------------------------------- // Type énuméré permettant de définir les messages affichés //---------------------------------------------------------------------------------------------------------------------------- enum MessageAffiche { MSGVIDE, INITMEMO, INITMOINS, INITPLUS, INITOFF, INITOK, INITVITKO, INITPOTKO, INITERR, PRET, APPUIOFF, REGUL, LIMITE, REINIT, MSGERR, }; //---------------------------------------------------------------------------------------------------------------------------- // Type énuméré permettant de définir les dessins affichés //---------------------------------------------------------------------------------------------------------------------------- enum DessinAffiche { DESVIDE, SABLIER, PAUSE, PLAY, ERREUR, }; //---------------------------------------------------------------------------------------------------------------------------- // Déclarations relatives à l'affichage //---------------------------------------------------------------------------------------------------------------------------- extern uint8_t SmallFont[]; // Police extern uint8_t BigFont[]; // Police UTFT myGLCD(ST7735S_4L_80160,ECRANSDA,ECRANSCL,ECRANCS,ECRANRES,ECRANDC); // Initialisation écran LCD: 4Line serial interface SDI SCL /CS /RST D/C NOTE:Only support DUE MEGA UNO int color = 0; word colorlist[] = {VGA_WHITE, VGA_BLACK, VGA_RED, VGA_BLUE, VGA_GREEN, VGA_FUCHSIA, VGA_YELLOW, VGA_AQUA}; int bsize = 4; char voltageDisplay[7] = ""; //---------------------------------------------------------------------------------------------------------------------------- // Déclaration des variables globales utilisées dans le code //---------------------------------------------------------------------------------------------------------------------------- bool erreur = true; // Variable d'erreur bool erreurmemo = false; // Variable d'erreur pour le bouton MEMO et empêcher le reset automatique s'il est détecté bloqué à l'initialisation bool boolsetup = false; // Indicateur de la phase setup, pour l'affichage des messages d'initialisation bool regulation = false; // Régulateur actif ou non bool reinitialisation = false; // Autorisation de réinitialisation en cas d'erreur détectée bool accelInitial = false; // Autorisation de l'accélération sur la base de la position (course en %) de l'accélérateur int vitesseMemoire = 0; // Vitesse mise en mémoire pour la régulation int vitesseLue = 0; // Vitesse actuelle (lue) (pour rafraichissement écran) int tableVitesse[TAILLETABLE] = {0, 0, 0, 0, 0}; // Liste des valeurs de vitesse pour le calcul de leur moyenne byte n = 0; // Curseur pour parcourir la table lors de l'acquisition de la vitesse FonctionBouton precfonc = RIEN; // Fonction bouton à n-1 DessinAffiche desEnCours = DESVIDE; // Dessin affiché à l'écran (pour éviter les rafraichissements intempestifs) unsigned long chronoOff = 0; // Chronomètre pour la fonction Off (au lieu d'utiliser un delay) unsigned long chronoLimit = 0; // Chronomètre pour l'affichage du message LIMITE String espace = ""; String message1prec = espace; // Message 1 précédement affiché (pour rafraichissement écran) String message2prec = espace; // Message 2 précédement affiché (pour rafraichissement écran) String message3prec = espace; // Message 3 précédement affiché (pour rafraichissement écran) String message4prec = espace; // Message 4 précédement affiché (pour rafraichissement écran) //##################################################################### //## Déclaration des fonctions ## //##################################################################### /////////////////// // Affichage // /////////////////// //---------------------------------------------------------------------------------------------------------------------------- // Fonction "dessinVide" de dessin d'un rectangle blanc //---------------------------------------------------------------------------------------------------------------------------- void dessinVide () { int xcoinsuperieur = 5; int ycoinsuperieur = 5; int xcoininferieur = 72; int ycoininferieur = 72; // Arrière plan du symbole myGLCD.setColor(255, 255, 255); // Couleur du symbole dessiné (red, green, blue) myGLCD.fillRoundRect(xcoinsuperieur, ycoinsuperieur, xcoininferieur, ycoininferieur); // Position x1, y1, x2, y2 } //---------------------------------------------------------------------------------------------------------------------------- // Fonction "dessinSablier" de dessin du symbole attente //---------------------------------------------------------------------------------------------------------------------------- void dessinSablier () { int xcoinsuperieur = 5; int ycoinsuperieur = 5; int xcoininferieur = 72; int ycoininferieur = 72; int x1 = 0; int y1 = 0; int x2 = 0; int y2 = 0; int x3 = 0; int y3 = 0; int x4 = 0; int y4 = 0; int x5 = 0; int y5 = 0; int y6 = 0; int y7 = 0; int y8 = 0; int y9 = 0; int ya = 0; // Arrière plan du symbole myGLCD.setColor(255, 255, 255); // Couleur du symbole dessiné (red, green, blue) myGLCD.fillRoundRect(xcoinsuperieur, ycoinsuperieur, xcoininferieur, ycoininferieur); // Position x1, y1, x2, y2 // Sablier: Deux rectangles et deux triangles, remplis par un triangle et un rectangle x1 = 0.3 * (xcoininferieur - xcoinsuperieur) + xcoinsuperieur; x2 = 0.7 * (xcoininferieur - xcoinsuperieur) + xcoinsuperieur; x3 = 0.5 * (xcoininferieur - xcoinsuperieur) + xcoinsuperieur; x4 = 0.35 * (xcoininferieur - xcoinsuperieur) + xcoinsuperieur; x5 = 0.65 * (xcoininferieur - xcoinsuperieur) + xcoinsuperieur; y1 = 0.1 * (ycoininferieur - ycoinsuperieur) + ycoinsuperieur; y2 = 0.3 * (ycoininferieur - ycoinsuperieur) + ycoinsuperieur; y3 = 0.7 * (ycoininferieur - ycoinsuperieur) + ycoinsuperieur; y4 = 0.9 * (ycoininferieur - ycoinsuperieur) + ycoinsuperieur; y5 = 0.55 * (ycoininferieur - ycoinsuperieur) + ycoinsuperieur; y6 = 0.45 * (ycoininferieur - ycoinsuperieur) + ycoinsuperieur; y7 = 0.5 * (ycoininferieur - ycoinsuperieur) + ycoinsuperieur; y8 = 0.8 * (ycoininferieur - ycoinsuperieur) + ycoinsuperieur; y9 = 0.85 * (ycoininferieur - ycoinsuperieur) + ycoinsuperieur; // Deux rectangles (à l'échelle) myGLCD.setColor(200, 100, 100); // Couleur du symbole dessiné (red, green, blue) myGLCD.fillRect(x1, y1, x2, y2); // Premier rectangle coordonnées x1, y1, x2, y2 myGLCD.fillRect(x1, y3, x2, y4); // Deuxième rectangle coordonnées x1, y1, x2, y2 // Deux triangles myGLCD.fillTriangle(x1, y2, x2, y2, x3, y5); // Triangle plein myGLCD.fillTriangle(x1, y3, x2, y3, x3, y6); // Triangle plein // Un triangle et un rectangle myGLCD.setColor(230, 230, 020); // Couleur du symbole dessiné (red, green, blue) myGLCD.fillTriangle(x4, y2, x5, y2, x3, y7); // Triangle plein myGLCD.fillRect(x4, y8, x5, y9); // Premier rectangle coordonnées x1, y1, x2, y2 } //---------------------------------------------------------------------------------------------------------------------------- // Fonction "dessinPlay" de dessin du symbole play //---------------------------------------------------------------------------------------------------------------------------- void dessinPlay () { int xcoinsuperieur = 5; int ycoinsuperieur = 5; int xcoininferieur = 72; int ycoininferieur = 72; int x1 = 0; int y1 = 0; int y2 = 0; int x3 = 0; int y3 = 0; // Arrière plan du symbole myGLCD.setColor(255, 255, 255); // Couleur du symbole dessiné (red, green, blue) myGLCD.fillRoundRect(xcoinsuperieur, ycoinsuperieur, xcoininferieur, ycoininferieur); // Position x1, y1, x2, y2 // Triangle (à l'échelle) myGLCD.setColor(0, 255, 0); // Couleur du symbole dessiné (red, green, blue) x1 = 0.1 * (xcoininferieur - xcoinsuperieur) + xcoinsuperieur; x3 = 0.9 * (xcoininferieur - xcoinsuperieur) + xcoinsuperieur; y1 = 0.1 * (ycoininferieur - ycoinsuperieur) + ycoinsuperieur; y2 = 0.9 * (ycoininferieur - ycoinsuperieur) + ycoinsuperieur; y3 = 0.5 * (ycoininferieur - ycoinsuperieur) + ycoinsuperieur; myGLCD.fillTriangle(x1, y1, x1, y2, x3, y3); // Triangle plein } //---------------------------------------------------------------------------------------------------------------------------- // Fonction "dessinPause" de dessin du symbole pause //---------------------------------------------------------------------------------------------------------------------------- void dessinPause () { int xcoinsuperieur = 5; int ycoinsuperieur = 5; int xcoininferieur = 72; int ycoininferieur = 72; int x1 = 0; int y1 = 0; int x2 = 0; int y2 = 0; int x3 = 0; int x4 = 0; // Arrière plan du symbole myGLCD.setColor(255, 255, 255); // Couleur du symbole dessiné (red, green, blue) myGLCD.fillRoundRect(xcoinsuperieur, ycoinsuperieur, xcoininferieur, ycoininferieur); // Position x1, y1, x2, y2 // Deux rectangles (à l'échelle) myGLCD.setColor(100, 020, 255); // Couleur du symbole dessiné (red, green, blue) x1 = 0.15 * (xcoininferieur - xcoinsuperieur) + xcoinsuperieur; x2 = 0.42 * (xcoininferieur - xcoinsuperieur) + xcoinsuperieur; x3 = 0.57 * (xcoininferieur - xcoinsuperieur) + xcoinsuperieur; x4 = 0.85 * (xcoininferieur - xcoinsuperieur) + xcoinsuperieur; y1 = 0.15 * (ycoininferieur - ycoinsuperieur) + ycoinsuperieur; y2 = 0.85 * (ycoininferieur - ycoinsuperieur) + ycoinsuperieur; myGLCD.fillRect(x1, y1, x2, y2); // Premier rectangle coordonnées x1, y1, x2, y2 myGLCD.fillRect(x3, y1, x4, y2); // Deuxième rectangle coordonnées x1, y1, x2, y2 } //---------------------------------------------------------------------------------------------------------------------------- // Fonction "dessinErreur" de dessin du symbole attention //---------------------------------------------------------------------------------------------------------------------------- void dessinErreur () { int xcoinsuperieur = 5; int ycoinsuperieur = 5; int xcoininferieur = 72; int ycoininferieur = 72; int x1 = 0; int y1 = 0; int x2 = 0; int y2 = 0; int x3 = 0; int x4 = 0; int y4 = 0; int x5 = 0; int y5 = 0; int y6 = 0; int y7 = 0; // Arrière plan du symbole myGLCD.setColor(255, 255, 255); // Couleur du symbole dessiné (red, green, blue) myGLCD.fillRoundRect(xcoinsuperieur, ycoinsuperieur, xcoininferieur, ycoininferieur); // Position x1, y1, x2, y2 // Triangle (à l'échelle) myGLCD.setColor(255, 0, 0); // Couleur du symbole dessiné (red, green, blue) x1 = 0.1 * (xcoininferieur - xcoinsuperieur) + xcoinsuperieur; x2 = 0.5 * (xcoininferieur - xcoinsuperieur) + xcoinsuperieur; x3 = 0.9 * (xcoininferieur - xcoinsuperieur) + xcoinsuperieur; y1 = 0.9 * (ycoininferieur - ycoinsuperieur) + ycoinsuperieur; y2 = 0.1 * (ycoininferieur - ycoinsuperieur) + ycoinsuperieur; myGLCD.fillTriangle(x1, y1, x2, y2, x3, y1); // Triangle plein // Point exclamation (à l'échelle) x4 = 0.5 * (xcoininferieur - xcoinsuperieur) + xcoinsuperieur - 0.05 * (xcoininferieur - xcoinsuperieur); x5 = 0.5 * (xcoininferieur - xcoinsuperieur) + xcoinsuperieur + 0.05 * (xcoininferieur - xcoinsuperieur); y4 = 0.4 * (ycoininferieur - ycoinsuperieur) + ycoinsuperieur; y7 = 0.85 * (ycoininferieur - ycoinsuperieur) + ycoinsuperieur; y6 = y7 - (x5 - x4); y5 = y6 - 0.85 * (x5 - x4); myGLCD.setColor(255, 255, 050); // Couleur du symbole dessiné (red, green, blue) myGLCD.fillRect(x4, y4, x5, y5); // Premier rectangle coordonnées x1, y1, x2, y2 myGLCD.fillRect(x4, y6, x5, y7); // Deuxième rectangle coordonnées x1, y1, x2, y2 } //---------------------------------------------------------------------------------------------------------------------------- // Fonction "dessinLogo" qui dessine le logo associé au paramètre d'entrée //---------------------------------------------------------------------------------------------------------------------------- void dessinLogo (DessinAffiche typeDessin) { switch (typeDessin) { case DESVIDE : { if (!erreur) { // Si on n'est pas en erreur (pour éviter d'écraser le dessin du symbole d'erreur) if (desEnCours != DESVIDE) { // Si le symbole "VIDE" est déjà affiché, inutile de le dessiner à nouveau dessinVide(); desEnCours = DESVIDE; } } } break; case SABLIER : { if (!erreur) { // Si on n'est pas en erreur (pour éviter d'écraser le dessin du symbole d'erreur) if (desEnCours != SABLIER) { // Si le sablier est déjà affiché, inutile de le dessiner à nouveau dessinSablier(); desEnCours = SABLIER; } } } break; case PAUSE : { if (!erreur) { // Si on n'est pas en erreur (pour éviter d'écraser le dessin du symbole d'erreur) if (desEnCours != PAUSE) { // Si le symbole pause est déjà affiché, inutile de le dessiner à nouveau dessinPause(); desEnCours = PAUSE; } } } break; case PLAY : { if (!erreur) { // Si on n'est pas en erreur (pour éviter d'écraser le dessin du symbole d'erreur) if (desEnCours != PLAY) { // Si le symbole play est déjà affiché, inutile de le dessiner à nouveau dessinPlay(); desEnCours = PLAY; } } } break; case ERREUR : { if (desEnCours != ERREUR) { // Si le symbole erreur est déjà affiché, inutile de le dessiner à nouveau dessinErreur(); desEnCours = ERREUR; } } break; default : { if (!erreur) { // Si on n'est pas en erreur (pour éviter d'écraser le dessin du symbole d'erreur) if (desEnCours != DESVIDE) { // Si le symbole "VIDE" est déjà affiché, inutile de le dessiner à nouveau dessinVide(); desEnCours = DESVIDE; } } } break; } } //---------------------------------------------------------------------------------------------------------------------------- // Fonction "ecritureMessage1" qui écrit sur la première ligne de l'écran (10 caractères max visibles) //---------------------------------------------------------------------------------------------------------------------------- void ecritureMessage1 (String message) { if (message == espace) { myGLCD.setBackColor(125, 125, 125); // Couleur de l'arrière plan de la zone de texte (red, green, blue), ici gris } else { myGLCD.setBackColor(0, 0, 0); // Couleur de l'arrière plan de la zone de texte (red, green, blue), ici noir } myGLCD.setColor(255, 255, 255); // Couleur de texte (red, green, blue) myGLCD.setFont(SmallFont); if (message.length() > 9) { // Tronquer le message s'il dépasse message[10] = NULL; } myGLCD.print(F(" "), 75, 5); // Effacement du texte précédent if (message != espace) { // N'écrire le texte que s'il est différent d'un espace myGLCD.print(message, 75, 5); // text, position x, position y } Serial.print(F("Message 1: ")); Serial.println(message); } //---------------------------------------------------------------------------------------------------------------------------- // Fonction "ecritureMessage2" qui écrit sur la deuxième ligne de l'écran (5 caracères max visibles) //---------------------------------------------------------------------------------------------------------------------------- void ecritureMessage2 (String message) { if (message == espace) { myGLCD.setBackColor(125, 125, 125); // Couleur de l'arrière plan de la zone de texte (red, green, blue), ici gris } else { myGLCD.setBackColor(0, 0, 0); // Couleur de l'arrière plan de la zone de texte (red, green, blue), ici noir pour quand on affichera le texte } myGLCD.setColor(255, 255, 255); // Couleur de texte (red, green, blue) myGLCD.setFont(BigFont); if (message.length() > 4) { // Tronquer le message s'il dépasse message[5] = NULL; } myGLCD.print(F(" "), 75, 20); // Effacement du texte précédent if (message != espace) { // N'écrire le texte que s'il est différent d'un espace myGLCD.print(message, 75, 20); // text, position x, position y } Serial.print(F("Message 2: ")); Serial.println(message); } //---------------------------------------------------------------------------------------------------------------------------- // Fonction "ecritureMessage3" qui écrit sur la troisième ligne de l'écran (10 caracères max visibles) //---------------------------------------------------------------------------------------------------------------------------- void ecritureMessage3 (String message) { myGLCD.setBackColor(125, 125, 125); // Couleur de l'arrière plan de la zone de texte (red, green, blue) myGLCD.setColor(0, 0, 0); // Couleur de texte (red, green, blue) myGLCD.setFont(SmallFont); if (message.length() > 9) { // Tronquer le message s'il dépasse message[10] = NULL; } myGLCD.print(F(" "), 75, 39); // Effacement du texte précédent if (message != espace) { // N'écrire le texte que s'il est différent d'un espace myGLCD.print(message, 75, 39); // text, position x, position y } Serial.print(F("Message 3: ")); Serial.println(message); } //---------------------------------------------------------------------------------------------------------------------------- // Fonction "ecritureMessage4" qui écrit sur la quatrième ligne de l'écran (5 caracères max visibles) //---------------------------------------------------------------------------------------------------------------------------- void ecritureMessage4 (String message) { myGLCD.setBackColor(125, 125, 125); // Couleur de l'arrière plan de la zone de texte (red, green, blue) myGLCD.setColor(0, 0, 0); // Couleur de texte (red, green, blue) myGLCD.setFont(BigFont); if (message.length() > 4) { // Tronquer le message s'il dépasse message[5] = NULL; } myGLCD.print(F(" "), 75, 54); // Effacement du texte précédent if (message != espace) { // N'écrire le texte que s'il est différent d'un espace myGLCD.print(message, 75, 54); // text, position x, position y } Serial.print(F("Message 4: ")); Serial.println(message); } //---------------------------------------------------------------------------------------------------------------------------- // Fonction "ecritureMessage" qui écrit les 4 lignes sur l'écran en fonction du type de message //---------------------------------------------------------------------------------------------------------------------------- void ecritureMessage (MessageAffiche typeMessage) { String message1 = espace; String message2 = espace; String message3 = espace; String message4 = espace; String memoAffich = String(vitesseMemoire); vitesseLue = lectureVitesse(); String actuelAffich = String(vitesseLue); if ((!boolsetup) && (millis() - chronoLimit < TEMPS_CHRONOLIMIT)) { // Si on est toujours dans le timing pour l'affichage du message LIMITE, on le force (sauf pour Off, les cas d'erreurs, et l'initialisation) if ((typeMessage == MSGVIDE) || (typeMessage == PRET) || (typeMessage == REGUL)) { typeMessage = LIMITE; } } switch (typeMessage) { // Message vide: on n'affiche rien case MSGVIDE : { if (vitesseMemoire != 0) { message1 = "Memo:"; message2 = memoAffich; } else { message1 = "Actuel:"; message2 = actuelAffich; } message3 = espace; message4 = espace; } break; // Message "cmde Memo" à l'initialisation case INITMEMO : { message1 = "Cmde"; message2 = "Memo"; message3 = espace; message4 = espace; } break; // Message "cmde Moins" à l'initialisation case INITMOINS : { message1 = "Cmde"; message2 = "Moins"; message3 = espace; message4 = espace; } break; // Message "cmde Plus" à l'initialisation case INITPLUS : { message1 = "Cmde"; message2 = "Plus"; message3 = espace; message4 = espace; } break; // Message "cmde Off" à l'initialisation case INITOFF : { message1 = "Cmde"; message2 = "Off"; message3 = espace; message4 = espace; } break; // Message "Erreur" à l'initialisation case INITERR : { message1 = espace; message2 = "Erreur"; message3 = espace; message4 = espace; } break; // Message "Lect vitesse impossible" à l'initialisation case INITVITKO : { message1 = "Lecture"; message2 = "vit."; message3 = "impossible"; message4 = espace; } break; // Message "Lect vitesse impossible" à l'initialisation case INITPOTKO : { message1 = "Lecture"; message2 = "posit"; message3 = "impossible"; message4 = espace; } break; // Message "..." à l'initialisation (Vitesse OK) case INITOK : { message1 = espace; message2 = espace; message3 = espace; message4 = "..."; } break; // Message "Pret" case PRET : { if (vitesseMemoire != 0) { message1 = "Memo:"; message2 = memoAffich; } else { message1 = "Actuel:"; message2 = actuelAffich; } message3 = espace; message4 = "Pret"; } break; // Message "Off" case APPUIOFF : { if (vitesseMemoire != 0) { message1 = "Memo:"; message2 = memoAffich; } else { message1 = "Actuel:"; message2 = actuelAffich; } message3 = espace; message4 = "Off"; } break; // Message affichant l'état des paramètres lors de la régulation de vitesse case REGUL : { message1 = "Memo:"; message2 = memoAffich; message3 = "Actuel:"; message4 = actuelAffich; } break; // Message avertissant du dépassement des limites de régulation autorisées case LIMITE : { if (vitesseMemoire != 0) { message1 = "Memo:"; message2 = memoAffich; } else { message1 = "Actuel:"; message2 = actuelAffich; } message3 = "Hors"; message4 = "limit"; } break; // Message "Reinitialisation OK" dans le cas d'erreur case MSGERR : { if (vitesseMemoire != 0) { message1 = "Memo:"; message2 = memoAffich; } else { message1 = "Actuel:"; message2 = actuelAffich; } message3 = "Autorise"; message4 = "reset"; } break; // Message "3 sec." au moment de la réinitialisation après erreur case REINIT : { message1 = espace; message2 = "3"; message3 = "sec."; message4 = espace; } break; // Par défaut: on n'affiche rien default : { if (vitesseMemoire != 0) { message1 = "Memo:"; message2 = memoAffich; } else { message1 = "Actuel:"; message2 = actuelAffich; } message3 = espace; message4 = espace; } break; } // Ecriture des messages pour tous les cas, en ne rafraichissant que les lignes nécessaires if (message1prec != message1) { ecritureMessage1(message1); message1prec = message1; } if (message2prec != message2) { ecritureMessage2(message2); message2prec = message2; } if (message3prec != message3) { ecritureMessage3(message3); message3prec = message3; } if (message4prec != message4) { ecritureMessage4(message4); message4prec = message4; } } //////////////////////// // Lecture paramètres // //////////////////////// //---------------------------------------------------------------------------------------------------------------------------- // Fonction "etatDuBouton" qui gère les états des boutons (revoie un des états contenus dans la variable énumérée EtatBouton) //---------------------------------------------------------------------------------------------------------------------------- EtatBouton etatDuBouton (Bouton *boutonATraiter) { EtatBouton etat = RELACHE; // Valeur qui sera renvoyée comme résultat de cette fonction, par défaut RELACHE bool etatSignal = !analogRead(boutonATraiter->entree); // Lire l'état de l'entrée dans une nouvelle variable temporaire if (etatSignal) { // Si le bouton semble avoir été appuyé (pas de signal, ou signal = 0/false) if (!boutonATraiter->boutonAppuye) { // Si c'est la première fois que le bouton est détecté appuyé, on lance un chrono boutonATraiter->date = millis(); } boutonATraiter->boutonAppuye = true; // On attribue au bouton l'état appuyé if (millis() - boutonATraiter->date > TEMPS_MAINTIENLONG) { // Si le bouton est appuyé depuis plus du temps défini etat = MAINTIEN_LONG; // Renvoyer l'état appui long } else { // Sinon on est sur un simple appui etat = APPUYE; // Renvoyer l'état appuyé } } else { // Si le bouton n'est pas appuyé boutonATraiter->boutonAppuye = false; // On attribue au bouton l'état non appuyé etat = RELACHE; // Renvoyer l'état relaché } return etat; // Renvoyer l'état du bouton en sortie de fonction } //---------------------------------------------------------------------------------------------------------------------------- // Fonction "lectureCommande" qui contrôle les instructions données par le bouton multiposition //---------------------------------------------------------------------------------------------------------------------------- FonctionBouton lectureCommande () { FonctionBouton fonction = RIEN; // Fonction renvoyée (par défaut: RIEN) // Lecture des états des boutons EtatBouton etatoff = etatDuBouton( &off ); EtatBouton etatmemo = etatDuBouton( &memo ); EtatBouton etatplus = etatDuBouton( &plus ); EtatBouton etatmoins = etatDuBouton( &moins ); // Définition des fonctions en fonction de l'état des boutons // Etat OFF if (etatoff == RELACHE) { fonction = OFF; } // Etat MEMO if (etatmemo == APPUYE) { fonction = MEMO; } else if (etatmemo == MAINTIEN_LONG) { fonction = MEMOLONG; } // Etat PLUS if (etatplus == APPUYE) { fonction = PLUS; } else if (etatplus == MAINTIEN_LONG) { fonction = PLUSLONG; } // Etat MOINS if (etatmoins == APPUYE) { fonction = MOINS; } else if (etatmoins == MAINTIEN_LONG) { fonction = MOINSLONG; } // Renvoi de la fonction associée return fonction; } //---------------------------------------------------------------------------------------------------------------------------- // Fonction "lecturePotentiometre" qui lit et transforme en % la valeur du potentiomètre du moteur du régulateur pour la position //---------------------------------------------------------------------------------------------------------------------------- int lecturePotentiometre () { int valeurLue = analogRead(POSITIONMOTEUR); int positionMoteur = 0; acquisitionVitesse(); // Continuer en permanence à faire l'acquisition des vitesses pour les mettre à jour (surtout dans les boucles while) if ((valeurLue < 0) || (valeurLue > 1023)) { // Si la valeur est incohérente (en dehors de la plage 0 - 1023), on lève l'erreur erreur = true; } positionMoteur = map(valeurLue,0,1023,100,0); // Conversion en pourcentage Serial.print(F("Position régulateur (%):")); Serial.println(positionMoteur); return positionMoteur; } //---------------------------------------------------------------------------------------------------------------------------- // Fonction "acquisitionVitesse" qui lit la valeur de vitesse de la voiture et l'enregistre dans une table utilisée pour la lecture //---------------------------------------------------------------------------------------------------------------------------- void acquisitionVitesse () { unsigned long etat_haut = pulseIn(VITESSE, HIGH); // Mesure de la durée de l'impulsion haute unsigned long etat_bas = pulseIn(VITESSE, LOW); // Mesure de la durée de l'impulsion basse long periode = etat_haut + etat_bas; // Calcul de la période long frequence = 0; if (periode == 0) { frequence = 0; } else { frequence = 1000000 / periode; // Calcul de la fréquence } int vitesse = map(frequence, 0, 900, 0, 4000); // Conversion en tours minute (fréquence mini, frequence maxi, RPM mini, RPM maxi) vitesse = round(vitesse / 10) * 10; // Arrondi de la valeur de la vitesse à la dizaine tableVitesse[n] = vitesse; // Remplissage de la table des vitesses n++; // Incrémentation de l'ordre if (n == TAILLETABLE) { // Quand on arrive à la taille maximale de la table, on repart à zéro (pour écraser les valeurs précédentes) n = 0; } } //---------------------------------------------------------------------------------------------------------------------------- // Fonction "lectureVitesse" qui lisse les valeurs de vitesse relevées //---------------------------------------------------------------------------------------------------------------------------- int lectureVitesse () { int valeurVitesse = 0; // Vitesse calculée int sommeVitesse = 0; // Somme des vitesses contenues dans la table byte i = 0; // Curseur de la table acquisitionVitesse(); // Continuer en permanence à faire l'acquisition des vitesses pour les mettre à jour (surtout dans les boucles while) for (i=0; i<TAILLETABLE; i++) { // Addition de toutes les valeurs contenues dans la table sommeVitesse = sommeVitesse + tableVitesse[i]; } valeurVitesse = sommeVitesse / TAILLETABLE; // Division par le nombre d'entrées pour obtenir la moyenne valeurVitesse = round(valeurVitesse / 10) * 10; // Arrondi de la valeur de la vitesse à la dizaine if ((valeurVitesse < CTRLVITMINI) || (valeurVitesse > CTRLVITMAXI)) { // Si la valeur de la vitesse est en dehors des clous, on lève l'erreur erreur = true; } // Pour info: calcul des vitesses associées en km/h int vitesseTrois = map(valeurVitesse, 0, 4000, 0, 100); // Conversion en km/h pour la 3ème (RPM mini, RPM maxi, vitesse mini, vitesse maxi) int vitesseQuatre = map(valeurVitesse, 0, 4000, 0, 138); // Conversion en km/h pour la 4ème (RPM mini, RPM maxi, vitesse mini, vitesse maxi) int vitesseCinq = map(valeurVitesse, 0, 4000, 0, 160); // Conversion en km/h pour la 5ème (RPM mini, RPM maxi, vitesse mini, vitesse maxi) Serial.print(F("Vitesse RPM:")); Serial.println(valeurVitesse); Serial.print(F("Vitesse en 3:")); Serial.println(vitesseTrois); Serial.print(F("Vitesse en 4:")); Serial.println(vitesseQuatre); Serial.print(F("Vitesse en 5:")); Serial.println(vitesseCinq); return valeurVitesse; } /////////////////// // Actions // /////////////////// //---------------------------------------------------------------------------------------------------------------------------- // Fonction "fonctionOff" qui gère les sorties pour couper le régulateur //---------------------------------------------------------------------------------------------------------------------------- void fonctionOff () { digitalWrite(CMDACCELERATION, LOW); digitalWrite(CMDDECELERATION, LOW); digitalWrite(CMDELECTROAIMANT, LOW); // Rappel: pour le module relais, "Low level trigger". Donc HIGH = repos, LOW = allumé. regulation = false; // On coupe la régulation accelInitial = true; // On autorise le déclanchement de la fonction d'accélération initiale } //---------------------------------------------------------------------------------------------------------------------------- // Fonction "fonctionAccelInitiale" qui accélère la première fois pour assurer le relais à l'activation du régulateur //---------------------------------------------------------------------------------------------------------------------------- void fonctionAccelInitale (int vitesse) { int positionMemo = map(vitesse, 0, 1750, 0, 50); // Position approximative de l'accélérateur à avoir en fonction de la vitesse demandée int positionLue = lecturePotentiometre(); FonctionBouton surveillCmd = lectureCommande(); // Pour surveiller si on appuie sur un bouton pendant la régulation int variationPwm = 0; // Pour le calcul de la valeur de variation PWM // Accélération if (positionMemo - positionLue > MARGEINFPOTLENT) { while (positionMemo - positionLue > MARGEINFPOTLENT) { // Si l'écart entre la position désirée et la postion actuelle est supérieure à la marge "lente": il faut accélérer if (positionMemo - positionLue > MARGEINFPOTRAPID) { // Si on est au delà de la marge rapide, on va calculer la valeur de variation à adopter variationPwm = map((positionMemo - positionLue), 0, 100, VARIATLENTPLUS, VARIATRAPIDPLUS); // Calcul de la valeur de variation à adopter (sur un écart de 0 à 100 % entre la valeur cible et la valeur actuelle) } else { // Sinon, on conserve la valeur minimum variationPwm = VARIATLENTPLUS; } fonctionAccel(variationPwm); positionLue = lecturePotentiometre(); surveillCmd = lectureCommande(); if (surveillCmd != RIEN) { // Si une commande est sollicitée, on sort de la boucle fonctionLectureCmd(surveillCmd); positionLue = 0; positionMemo = 0; break; } } if (surveillCmd != OFF) { fonctionOn(); // Pour stopper l'accélération (sauf si on a demandé le OFF) } } variationPwm = 0; // Réinitialisation de la valeur à 0 par sécurité accelInitial = false; // Une fois qu'elle a tourné, on n'y revient plus } //---------------------------------------------------------------------------------------------------------------------------- // Fonction "fonctionAccel" qui gère les sorties pour accélérer (variable d'entrée: valeur du PWM) //---------------------------------------------------------------------------------------------------------------------------- void fonctionAccel (int variation) { if (lecturePotentiometre() < POSITIONSERVOMAX) { // Si le potentiomètre est avant la position maximum, on peut accélérer digitalWrite(CMDACCELERATION, HIGH); } else { // Sinon, le potentiomètre est en position maximum, on n'accélère plus digitalWrite(CMDACCELERATION, LOW); } digitalWrite(CMDDECELERATION, LOW); analogWrite(PWMMOTEUR, variation); digitalWrite(CMDELECTROAIMANT, HIGH); // Rappel: pour le module relais, "Low level trigger". Donc HIGH = repos, LOW = allumé. } //---------------------------------------------------------------------------------------------------------------------------- // Fonction "fonctionDecel" qui gère les sorties pour décélérer (variable d'entrée: valeur du PWM) //---------------------------------------------------------------------------------------------------------------------------- void fonctionDecel (int variation) { digitalWrite(CMDACCELERATION, LOW); if (lecturePotentiometre() > POSITIONSERVOMIN) { // Si le potentiomètre est après la position minimum, on peut décélérer digitalWrite(CMDDECELERATION, HIGH); } else { // Sinon, le potentiomètre est en position minimum, on ne décélère plus digitalWrite(CMDDECELERATION, LOW); } analogWrite(PWMMOTEUR, variation); digitalWrite(CMDELECTROAIMANT, HIGH); // Rappel: pour le module relais, "Low level trigger". Donc HIGH = repos, LOW = allumé. } //---------------------------------------------------------------------------------------------------------------------------- // Fonction "fonctionOn" qui gère les sorties pour maintenir l'accélération //---------------------------------------------------------------------------------------------------------------------------- void fonctionOn () { digitalWrite(CMDACCELERATION, LOW); digitalWrite(CMDDECELERATION, LOW); digitalWrite(CMDELECTROAIMANT, HIGH); // Rappel: pour le module relais, "Low level trigger". Donc HIGH = repos, LOW = allumé. } //---------------------------------------------------------------------------------------------------------------------------- // Fonction "fonctionRegulation" qui ajuste la position de l'accélérateur //---------------------------------------------------------------------------------------------------------------------------- void fonctionRegulation () { int positionLue = lectureVitesse(); int positionMemo = vitesseMemoire; FonctionBouton surveillCmd = lectureCommande(); // Pour surveiller si on appuie sur un bouton pendant la régulation int variationPwm = 0; // Pour le calcul de la valeur de variation PWM if (surveillCmd == RIEN) { // Si aucune commande n'est sollicitée, on gère la régulation if (accelInitial) { // Si l'accélération initiale est autorisée, on l'exécute fonctionAccelInitale(positionMemo); } // Décéleration if (positionLue - positionMemo > MARGESUPVITLENT) { while (positionLue - positionMemo > MARGESUPVITLENT) { // Si l'écart entre la vitesse actuelle et la vitesse désirée est supérieure à la marge "lente": il faut décélérer if (positionLue - positionMemo > MARGESUPVITRAPID) { // Si on est au dessus de la marge définie pour une décélération "rapide", on calcule la valeur du PWM à adopter variationPwm = map((positionLue - positionMemo), 0, 3000, VARIATLENTMOINS, VARIATRAPIDMOINS); // Calcul de la valeur de variation à adopter (sur un écart de 0 à 3000 tours entre la valeur actuelle et la valeur cible) } else { // Sinon on reste sur la valeur minimum variationPwm = VARIATLENTMOINS; } fonctionDecel(variationPwm); positionLue = lectureVitesse(); surveillCmd = lectureCommande(); if (surveillCmd != RIEN) { // Si une commande est sollicitée, on sort de la boucle while fonctionLectureCmd(surveillCmd); positionLue = 0; positionMemo = 0; break; } } if (surveillCmd != OFF) { fonctionOn(); // Pour stopper la décélération (sauf si on a demandé le OFF) } } // Accélération else if (positionMemo - positionLue > MARGEINFVITLENT) { while (positionMemo - positionLue > MARGEINFVITLENT) { // Si l'écart entre la vitesse désirée et la vitesse actuelle est supérieure à la marge "lente": il faut accélérer if (positionMemo - positionLue > MARGEINFVITRAPID) { // Si on est au dessus de la marge définie pour une accélération "rapide", on calcule la valeur du PWM à adopter variationPwm = map((positionMemo - positionLue), 0, 3000, VARIATLENTMOINS, VARIATRAPIDMOINS); // Calcul de la valeur de variation à adopter (sur un écart de 0 à 3000 tours entre la valeur actuelle et la valeur cible) } else { // Sinon on reste sur la valeur minimum variationPwm = VARIATLENTMOINS; } fonctionAccel(variationPwm); positionLue = lectureVitesse(); surveillCmd = lectureCommande(); if (surveillCmd != RIEN) { // Si une commande est sollicitée, on sort de la boucle fonctionLectureCmd(surveillCmd); positionLue = 0; positionMemo = 0; break; } } if (surveillCmd != OFF) { fonctionOn(); // Pour stopper l'accélération (sauf si on a demandé le OFF) } variationPwm = 0; // Réinitialisation de la valeur à 0 par sécurité } } else { // Sinon on traite la commande fonctionLectureCmd(surveillCmd); } } //---------------------------------------------------------------------------------------------------------------------------- // Fonction "fonctionNormal" qui s'exécute en temps normal, quand il n'y a pas d'erreur //---------------------------------------------------------------------------------------------------------------------------- void fonctionNormal () { acquisitionVitesse(); // Remplissage de la table des vitesses if (millis() - chronoOff < TEMPS_CHRONOOFF) { // Si on est toujours dans le timing pour la prise en charge de la fonction OFF, on la maintient histoire d'être sur que l'electroaimant soit bien désactivé fonctionOff(); dessinLogo(PAUSE); } else { // Sinon on gère la régulation de vitesse if (regulation) { // Si la régulation est activée, on régule la vitesse (qui gère d'elle même la lecture des commandes si elle sont sollicitées) int controleVitesse = lectureVitesse(); // Contrôle de la vitesse pour n'effectuer la régulation que dans la plage autorisée if ((controleVitesse > CTRLVITMINI) && (controleVitesse < CTRLVITMAXI)) { dessinLogo(PLAY); // On dessine le logo Play fonctionRegulation(); ecritureMessage(REGUL); // Affichage de l'état de régulation } else { regulation = false; ecritureMessage(LIMITE); chronoLimit = millis(); // Top chrono pour l'affichage du message LIMITE } } else { // Si la régulation n'est pas active, on lit la commande dessinLogo(PAUSE); // On dessine le logo Pause car la régulation est désactivée ecritureMessage(PRET); // Affichage du message Pret fonctionLectureCmd(lectureCommande()); } } } //---------------------------------------------------------------------------------------------------------------------------- // Fonction "fonctionErreur" qui s'exécute quand il y a une erreur détectée, et autorise la réinitialisation //---------------------------------------------------------------------------------------------------------------------------- void fonctionErreur () { fonctionOff(); // On coupe tout par sécurité dessinLogo(ERREUR); // Affichage du logo sur l'écran Serial.println(F("Arrêt d'Urgence dans le loop")); // Si on appuie longtemps sur MEMO, on peut réinitialiser le régulateur if (!erreurmemo) { // Si le bouton n'était pas bloqué à l'initalisation, on autorise la réinitialisation ecritureMessage(MSGERR); if (lectureCommande() == MEMOLONG) { // Si on a appuyé longtemps sur MEMO, on va autoriser la réinitialisation reinitialisation = true; Serial.println(F("Réinitialisation autorisée")); } if (reinitialisation) { while (lectureCommande() == MEMOLONG) { // Tant qu'on maintient en position longue le bouton MEMO (pour la réinitialisation), on actuallise le chrono (pour éviter de reset l'Arduino alors qu'on est encore appuyé et ainsi risquer de lever "erreurmemo") chronoOff = millis(); // (On recycle le chronoOff pour éviter de déclarer une nouvelle variable) Serial.println(F("MEMOLONG demandé, réinitialisation 3 secondes après lacher du bouton")); ecritureMessage(REINIT); } if (millis() - chronoOff > 3000) { // Après 3 secondes asm volatile("jmp 0x00"); // Réinitialisation depuis le début } } } else { ecritureMessage(MSGVIDE); // Effacement de l'écran (sauf valeurs mémorisées) } } //---------------------------------------------------------------------------------------------------------------------------- // Fonction "fonctionLectureCmd" qui interprête la commande demandée //---------------------------------------------------------------------------------------------------------------------------- void fonctionLectureCmd (FonctionBouton commandeDemandee) { switch (commandeDemandee){ // On lit la commande qui retournera quelque chose différent de RIEN si un bouton a été appuyé case OFF : { fonctionOff(); if (precfonc != OFF) { // Si ce n'était pas déjà "OFF" chronoOff = millis(); // On réinitialise le chronomètre pour Off (utilisé pour maintenir la fonction Off quelques temps) //Serial.println(F("Loop: OFF")); ecritureMessage(APPUIOFF); } precfonc = OFF; } break; case MEMO : { if (precfonc != MEMO) { // Si on n'était pas en MEMO au tour précédent //Serial.println(F("Loop: MEMO")); } if (vitesseMemoire == 0) { // Si aucune vitesse n'a déjà été mémorisée, on va lire la vitesse actuelle. Sinon ça rappellera automatiquement la vitesse précédemment enregistrée vitesseMemoire = lectureVitesse(); // Mémorisation de la vitesse actuelle if (vitesseMemoire < VITESSEMINI) { // Si la vitesse mémorisée est inférieure à la vitesse minimum vitesseMemoire = VITESSEMINI; // On force la vitesse minimum } if (vitesseMemoire > VITESSEMAXI) { // Si la vitesse mémorisée est supérieure à la vitesse maximum vitesseMemoire = VITESSEMAXI; // On force la vitesse maximum } } precfonc = MEMO; // Pour le "if" du début du cas } break; case MEMOLONG : { if (precfonc != MEMOLONG) { // Si on n'était pas en MEMOLONG au tour précédent //Serial.println(F("Loop: MEMOLONG")); } vitesseMemoire = lectureVitesse(); // Mémorisation de la vitesse actuelle. Dans ce cas, on écrase la valeur mémorisée pour la remplacer par la nouvelle if (vitesseMemoire < VITESSEMINI) { // Si la vitesse mémorisée est inférieure à la vitesse minimum vitesseMemoire = VITESSEMINI; // On force la vitesse minimum } if (vitesseMemoire > VITESSEMAXI) { // Si la vitesse mémorisée est supérieure à la vitesse maximum vitesseMemoire = VITESSEMAXI; // On force la vitesse maximum } precfonc = MEMOLONG; // Pour le "if" du début du cas } break; case PLUS : { if (precfonc != PLUS) { // Si on n'était pas en PLUS au tour précédent //Serial.println(F("Loop: PLUS")); if (!regulation) { // Si on n'était pas en régulation vitesseMemoire = lectureVitesse(); // Mémorisation de la vitesse actuelle if (vitesseMemoire < VITESSEMINI) { // Si la vitesse mémorisée est inférieure à la vitesse minimum vitesseMemoire = VITESSEMINI; // On force la vitesse minimum } if (vitesseMemoire > VITESSEMAXI) { // Si la vitesse mémorisée est supérieure à la vitesse maximum vitesseMemoire = VITESSEMAXI; // On force la vitesse maximum } } } vitesseMemoire = vitesseMemoire + PASVITESSE; // Incrémentation de la vitesse if (vitesseMemoire > VITESSEMAXI) { // Si la vitesse mémorisée est supérieure à la vitesse maximum vitesseMemoire = VITESSEMAXI; // On force la vitesse maximum } precfonc = PLUS; // Pour le "if" du début du cas } break; case PLUSLONG : { if (precfonc != PLUSLONG) { // Si on n'était pas en PLUSLONG au tour précédent //Serial.println(F("Loop: PLUSLONG")); } vitesseMemoire = vitesseMemoire + GDPASVITESSE; // Incrémentation de la vitesse rapidement if (vitesseMemoire > VITESSEMAXI) { // Si la vitesse mémorisée est supérieure à la vitesse maximum vitesseMemoire = VITESSEMAXI; // On force la vitesse maximum } precfonc = PLUSLONG; // Pour le "if" du début du cas } break; case MOINS : { if (precfonc != MOINS) { // Si on n'était pas en MOINS au tour précédent //Serial.println(F("Loop: MOINS")); if (!regulation) { vitesseMemoire = lectureVitesse(); // Mémorisation de la vitesse actuelle if (vitesseMemoire < VITESSEMINI) { // Si la vitesse mémorisée est inférieure à la vitesse minimum vitesseMemoire = VITESSEMINI; // On force la vitesse minimum } if (vitesseMemoire > VITESSEMAXI) { // Si la vitesse mémorisée est supérieure à la vitesse maximum vitesseMemoire = VITESSEMAXI; // On force la vitesse maximum } } } vitesseMemoire = vitesseMemoire - PASVITESSE; // Décrémentation de la vitesse if (vitesseMemoire < VITESSEMINI) { // Si la vitesse mémorisée est inférieure à la vitesse minimum vitesseMemoire = VITESSEMINI; // On force la vitesse minimum } precfonc = MOINS; // Pour le "if" du début du cas } break; case MOINSLONG : { if (precfonc != MOINSLONG) { // Si on n'était pas en MOINSLONG au tour précédent //Serial.println(F("Loop: MOINSLONG")); } vitesseMemoire = vitesseMemoire - GDPASVITESSE; // Déncrémentation de la vitesse rapidement if (vitesseMemoire < VITESSEMINI) { // Si la vitesse mémorisée est inférieure à la vitesse minimum vitesseMemoire = VITESSEMINI; // On force la vitesse minimum } precfonc = MOINSLONG; // Pour le "if" du début du cas } break; default : { if (precfonc != RIEN) { // Si on n'était pas en RIEN au tour précédent //Serial.println(F("Loop: ON")); if (precfonc != OFF) { // Activation de la régulation dès que l'une des précédentes fonctions: Moins Moinslong Plus Pluslong Memo Memolong regulation = true; // Activation de la régulation } } fonctionOn(); precfonc = RIEN; // Pour le "if" du début du cas } break; } } //##################################################################### //## Initialisation du circuit (fonction setup) ## //##################################################################### void setup () { Serial.begin(9600); // Ouvre le port série boolsetup = true; // 1) Initialisation de l'écran myGLCD.InitLCD(); myGLCD.fillScr(125, 125, 125); // Fond écran ecritureMessage(MSGVIDE); // Ecriture message vide (pour initialiser la fonction) dessinLogo(DESVIDE); // Dessin symbole vide (pour initialiser la fonction) Serial.println(F("Ecran initialisé")); // 2) Déclaration des pins: // a) pour les boutons pinMode(BTNOFF, INPUT); // On déclare le pin "BTNOFF" comme un pin d'entrée pinMode(BTNMEMO, INPUT); // On déclare le pin "BTNMEMO" comme un pin d'entrée pinMode(BTNPLUS, INPUT); // On déclare le pin "BTNPLUS" comme un pin d'entrée pinMode(BTNMOINS, INPUT); // On déclare le pin "BTNMOINS" comme un pin d'entrée off.entree = BTNOFF; memo.entree = BTNMEMO; plus.entree = BTNPLUS; moins.entree = BTNMOINS; // b) pour les relais et module L293D pinMode(CMDELECTROAIMANT, OUTPUT); pinMode(PWMMOTEUR, OUTPUT); pinMode(CMDACCELERATION, OUTPUT); pinMode(CMDDECELERATION, OUTPUT); // c) pour l'asservissement du servomoteur et le capteur de vitesse: pas besoin, ce sont des entrées analogiques. AMD: la vitesse est déclarée en entrée dans l'exemple trouvé pour la détermination de la fréquence pinMode(VITESSE, INPUT); Serial.println(F("Pins initialisés")); // 3) Initialisation erreur erreur = false; // 4) Initialisation commandes fonctionOff(); // 5) Dessin sablier pour identifier le début de l'initialisation dessinLogo(SABLIER); // 6) Test de lecture des paramètres d'entrée // Vitesse: for (n=0; n<TAILLETABLE; n++) { // Lecture de premières vitesses pour tester la fonction acquisitionVitesse(); } n=0; // Réinitialisation de n int testVitesse = lectureVitesse(); if ((testVitesse >= CTRLVITMINI) && (testVitesse <= CTRLVITMAXI)) { // Si la vitesse dans les clous ecritureMessage(INITOK); Serial.println(F("Vitesse OK")); delay (500); // On prend 1/2 seconde pour lire le message (et tant pis si on stoppe le code, on n'est qu'au stade de l'initialisation, ce n'est pas grave) } else { // Sinon on informe que l'erreur est levée // Message "Lecture vitesse impossible" -> réinitialiser le régulateur (l'erreur est levée directement dans la fonction lecture) ecritureMessage(INITVITKO); delay (3000); // On prend 3 secondes pour lire le message d'erreur (et tant pis si on stoppe le code, on n'est qu'au stade de l'initialisation, ce n'est pas grave) } // Potentiomètre: int testPotentiometre = lecturePotentiometre(); if ((testPotentiometre >= 0) && (testPotentiometre <= 100)) { // Si la position (en %) dans les clous ecritureMessage(INITOK); Serial.println(F("Potard OK")); delay (1000); // On prend 1 seconde pour lire le message (et tant pis si on stoppe le code, on n'est qu'au stade de l'initialisation, ce n'est pas grave) } else { // Sinon on informe que l'erreur est levée // Message "Lecture position impossible" -> réinitialiser le régulateur (l'erreur est levée directement dans la fonction lecture) ecritureMessage(INITPOTKO); delay (3000); // On prend 3 secondes pour lire le message (et tant pis si on stoppe le code, on n'est qu'au stade de l'initialisation, ce n'est pas grave) } // 7) Commandes: // a) Vérification de la commande MEMO if (!analogRead(memo.entree)) { erreurmemo = true; // Le bouton MEMO détecté "bloqué" au démarrage doit pouvoir empêcher la réinitialisation dans le loop // Affichage sur l'écran ecritureMessage(INITMEMO); delay (5000); // On prend 5 secondes pour lire le message (et tant pis si on stoppe le code, on n'est qu'au stade de l'initialisation, ce n'est pas grave) // Ne pas laisser le régulateur fonctionner si ce bouton est appuyé au départ erreur = true; } // b) Vérification de la commande MOINS if (!analogRead(moins.entree)) { // Affichage sur l'écran ecritureMessage(INITMOINS); delay (5000); // On prend 5 secondes pour lire le message (et tant pis si on stoppe le code, on n'est qu'au stade de l'initialisation, ce n'est pas grave) // Ne pas laisser le régulateur fonctionner si ce bouton est appuyé au départ erreur = true; } // c) Vérification de la commande PLUS if (!analogRead(plus.entree)) { // Affichage sur l'écran ecritureMessage(INITPLUS); delay (5000); // On prend 5 secondes pour lire le message (et tant pis si on stoppe le code, on n'est qu'au stade de l'initialisation, ce n'est pas grave) // Ne pas laisser le régulateur fonctionner si ce bouton est appuyé au départ erreur = true; } // d) Vérification de la commande OFF (on ne bloque pas celle là, car on peut rester appuyé sur le frein ou l'embrayage, par contre on met juste un message à l'écran) if (analogRead(off.entree)) { // Affichage sur l'écran ecritureMessage(INITOFF); delay (1000); // On prend 1 seconde pour lire le message (et tant pis si on stoppe le code, on n'est qu'au stade de l'initialisation, ce n'est pas grave) } // Si on n'a pas eu d'erreur (dans les if précédents) et qu'on n'a pas appuyé sur OFF, on affiche qu'aucune commande n'a été appuyée else if (!erreur) { // Affichage sur l'écran ecritureMessage(INITOK); delay (1000); // On prend 1 seconde pour lire le message (et tant pis si on stoppe le code, on n'est qu'au stade de l'initialisation, ce n'est pas grave) } // 8) Si pas d'erreur à l'initialisation, on informe que tout est prêt if (!erreur) { // Affichage sur l'écran ecritureMessage(PRET); } else { // Affichage sur l'écran ecritureMessage(INITERR); } boolsetup = false; } //##################################################################### //## Fonction loop ## //##################################################################### void loop () { if (!erreur) { // Si pas d'erreur détectée soit dans le setup soit dans le loop fonctionNormal(); } else { // En cas d'erreur relevée, on stoppe le régulateur fonctionErreur(); } }
    2 points
  5. Petite présentation.Avant et après nettoyage
    2 points
  6. Bonsoir à tous ! Voilà, nous sommes bien rentrés en Lorraine après 3 semaines de vacances avec notre Super 5 GTX !!!😁 Nous avons parcouru 2600 kms. Tout s'est bien passé ; aucun problème... beaucoup de gens sont venus nous voir pour poser des questions ; d'autres pour nous dire qu'ils avaient eu eux aussi une Super 5... Bref, que du bonheur ! Maintenant, elle se repose dans le garage. Bonnes vacances à tous
    2 points
  7. Passé récupérer cette après midi toutes les factures reparation et entretien. Yapuka faire une belle farde de suivi.
    2 points
  8. Bon j'ai fini par trouver, un peu brillant mais un coup de bombe satin améliorera ça en tout c'est la couleur que je voulais Le sujet est clôturé pour moi, voila une photo avec la référence pour ceux qui voudrait l'utiliser.
    2 points
  9. Petite vue de l interieur de la cinq.
    2 points
  10. Un petit bonjour d'Espelette !
    2 points
  11. Nettoyage moteur ok Crémaillère remplacée Kit frein arrière remplacé Armature siège avant remplacée Lèves vitres remplacés Enjoliveurs remplacés part des saturnes en attendant des soleils ou jantes alu zenith Reste Gros Nettoyage carrosserie Traitement plastiques Pose autoradio Remplacement pc arrière Et plus tard remplacer la baie de parebrise
    2 points
  12. Kit de frein arrière remplacé Et acheté une donneuse la 38eme une gtl 1.1 de 87
    2 points
  13. C'est dommage et pour m'être séparé d une il y a qq années, je comprends ce que tu peux ressentir. Maintenant, une belle île a une sacrée cote et les temps sont difficiles, ça se comprend ....
    2 points
  14. Du simple dernièrement: Retraite méritée pour les HP avants d’origine, place à du Pioneer en solde 😂
    1 point
  15. Bonjour a tous.Jack 53 balais;dépanneur auto pour une grande societé en Belgique depuis 25 ans.35ans de mécanique dans les pattes;le temps passe vite😗 Je viens de faire l aquisition d une petite super 5TL rouge grenade de 1986.Achetée chez une mamy de 90 ans.51.000KM d origine;premier propriétaire;carnet d entretien a l agence uniquement,facture d achat.....Mamy a juste rectifié l aile avant droite mais ca reste un détail.La voila en photo.Ca change du gabarit de mon Hudson de 1934 🙄
    1 point
  16. Oh là là, ça fait un moment que j'avais pas donné de nouvelles par ici... Ce brave véhicule roule toujours aussi bien, et je n'ai pas manqué de m'en occuper bien entendu: - Sonde de température extérieure qui rendait l'ame, - Réparation d'une matrice chauffante de rétroviseur, - Révision clim, - Recollage des mousses de sièges AV (encore), - Mise en service de mes lave phares, - Et pour ceux qui ont suivi sur l'autre topic: avancement sur le régulateur de vitesse. Pour la sonde de température, voici le genre de fantaisie à laquelle j'avais droit: Bon, heureusement, c'est standard. Une sonde d'occasion, et deux soudures plus tard, c'est revenu dans l'ordre. Passons à la matrice chauffante, qui comme pour les lunettes AR a droit à son stylo correcteur pour refaire les connexions là où la piste était coupée par l'oxydation. Mais pour ça à terme, je refabriquerai une matrice chauffante à l'aide de fil résistif chauffant, car je ne suis pas convaincu de la durabilité Pour la clim, j'avais donc une fuite que j'avais identifié au niveau du condenseur (j'avais une fuite d'huile à ce niveau, pas besoin de lampe UV pour confirmer ). J'avais peur que ça vienne du raccord, puis après test (mise sous pression), a priori pas de problème. J'ai suivi mon tutoriel de recharge de clim avec le Duracool, et pour ça il me fallait identifier mon compresseur: Après l'avoir nettoyé et rechargé en huile, changement de tous les joints du circuit: Remontage du condenseur après une petite peinture au zinc toute neuve: Là aussi c'est propre: Une bouteille déshydratante neuve aussi tant qu'à faire: Et c'est parti, on attaque la mise sous vide: La pression avait du mal à tenir, mais c'est juste parce que mes raccords étaient fuyards. Quel boulet, j'avais pas vérifié Mais bon, au moins ce n'était pas dans le circuit en lui même! Et voilà, la clim marche très bien, et heureusement, car on en a eu besoin un jour où nous étions bloqué dans 45 minutes de bouchons par 40 degrés en descendant à Toulouse Test largement validé, y compris pour ce brave J8S qui n'a pas bu une goutte de LDR pendant tout ce temps! Côté lave phare, j'ai enfin connecté la pompe, tout simplement Côté trajets, beaucoup de km parcourus ces 2 derniers mois: un A/R Bretagne - Toulouse - Nimes en juin, et un A/R Bretagne - Toulouse en juillet. Lors de ce dernier trajet, on franchissait un cap: 330 000 km: Mais juste avant, en allant à Nimes, elle s'était prise une bonne douche de sable saharien Heureusement le trajet de retour à la maison l'a un peu rincée: Et sur la route en Bretagne, on trouve des particularités amusantes, et locales Enfin, tous ces trajets ont été l'occasion de peaufiner les tests du régulateur de vitesse! Voici la version qui permet de garder l'accélérateur appuyé. Les valeurs sur l'écran correspondent à la position de l'accélérateur en %, en haut la valeur mémorisée, en bas, la valeur actuelle. Le logo permet de savoir si le régulateur est activé (Play) ou en attente (Pause): https://dai.ly/kCZY3HyS228mgsB7OTu Et à venir donc, la vidange! Et oui, il faut continuer à lui faire son entretien normal aussi
    1 point
  17. Petites news. Il roule toujours bien et assure ses différents rôles toujours sans problème. J'ai enfin fait l'effort de le laver, il ne ressemble plus à un gros rocher couvert de mousse... La Mazda aussi par la même occasion, 2 ans de crasse accumulée. Mais surtout j'ai fait le chantier kit distri, kit accessoires, et pompe à eau, ça m'a pris toute la journée d'hier et comme c'était une journée très chaude, j'ai pris mes précautions: à noter que les 2 kits n'avaient que 25 000km... mais de 2018, date de la casse, donc comme j'ai pas envie de réitérer, mieux vaut mettre ceinture et bretelle. L'occasion aussi de recaler la distri comme il faut maintenant que j'ai l'outil de blocage des poulies d'AAC, et j'ai pu constater au démontage que c'était vraiment mal calé depuis la dernière fois!! Le bruit moteur est déjà plus agréable et il devrait retrouver un peu de pêche!
    1 point
  18. Le joint au fond du voile de jante est fait.Plus de possibilité de retour de rouille avec le traitement fait.Et le joint fait.Une fois bien durci. La jante de secours,fond traité mais joint pas fait.Ca vous permet de visualiser
    1 point
  19. Sinon,elle a bien son protège carter d origine, 1986.Juste un gugusse qui a fait un trou pour faire vidange sans demonter🙄
    1 point
  20. https://www.leboncoin.fr/ad/voitures/2786640541 Annonce soignée et voiture qui a l'air propre mis à part le PC avant de ph2. Si la boite va bien, le prix ne me parait pas excessif, surtout quand il est stipulé que c'est négociable !
    1 point
  21. News du jours .. Filtre à air = Remplacer Balais d'essuie glace = Remplacer Reste donc à faire Disque de frein + plaquette + vis + étrier Refixer l'antibrouillard avant gauche = tentative de vol .. Refixer la baguette de porte AVD et Aile avant droite Bref , pour se qui est des baguette .. un petit plaisantin à vu quel se déclipser au niveau de l'aile .. et à donc décider de tirer dessus .. puis est aller , retourner les rétro de 2 voiture devant le centre de formation .. résultat , quand j'ai ouvert la porte avant droite pour passer l'aspirateur , et bien crac la baguette de porte est venu arracher la baguette de l'aile , et donc la baguette de porte à sauter .. Résultat , les 2 baguette sont dans le coffre , et y resteront très certainement .. car impossible de remplacer la baguette de porte , vu que la dite porte est enfoncer et que les anciens proprio l'ont redresser de façon quelque peu ... discutable ...
    1 point
  22. Merci beaucoup, effectivement l'explication est plus détaillée que dans le Haynes Mais au final j'y suis parvenu ce matin ! J'avais lu, je ne sais plus où (peut-être ici) un commentaire de quelqu'un qui utilisait des petites rondelles pour "caler" l'arrêtoir dans la fusée, avant de venir clipser la transmission. Alors j'ai essayé de m'en inspirer : La tête (fusée) de cardan maintenue dans un étau, j'ai empilé à l'intérieur 6 rondelles à l'aide d'un petit tournevis, puis, toujours avec les tournevis j'ai placé l'arrêtoir par dessus ma "pile" de rondelles. Ensuite j'ai présenté la transmission bien en face et appuyé, en tournant un peu pour faire rentrer les pattes dans leurs logements. Au premier essai, les trois pattes se sont clipsées du premier coup ...Seulement j'avais oublié de remettre la cale au milieu du cardan Deuxième essai, avec cette fois la cale en place, deux pattes sur trois de clipsées... Solution, j'ai rajouté des rondelles au fond de la fusée et penché le cardan vers la patte à clipser pour la mettre en appuie sur les rondelles : elle n'a alors pas eu d'autres choix que de rentrer dans son logement ! Après ça, j'ai sortie l'ensemble de l'étau, je l'ai retourné et j'ai secoué pour récupérer mes 12 rondelles Maintenant plus qu'à le remonter sur la voiture !
    1 point
  23. Mamy.38 ans aujourd'hui. Nettoyage continue,ici les boulons roue arrière droite.Top le chrome d époque.
    1 point
  24. tu nous fait vraiment plaisir de nous faire profiter en photos de cette si belle super5, je l'adore
    1 point
  25. Bonjour, Oui allumage a contrôler. Tu as bien les fils dans le bon ordre ? Quand le Piston N°1 est en haut. le doigt d'allumeur doit être vers l'avant Si ce n'est pas vers l'avant c'est qu'il est mal monter Ça explique la mise en place d'une tête d'allumage
    1 point
  26. Magnifique, on dirait que tu es tombé sur une belle perle qui en plus tombe sur quelqu’un de soigneux 😉
    1 point
  27. Tu restaures plus vite que ton ombre, il faut que tu en fasses ton travail
    1 point
  28. L'essentiel c'est qu'elle ne soir pas bleue 🤣😂
    1 point
  29. Miss r9 est passé en geo ya 15 jours maintenant et roule tout les jours depuis ! Ras à part la nappe à l'arrière du compteur qui a décédé, au fur et à mesure je perdais des infos. Donc aujourd'hui cablage du compteur de la r11. Pour que ça soit drôle c'est absolument pas plug and play ! Non seulement les cosses sont pas au bon endroit dans les connecteur mais les connecteurs sont différents et les cosses aussi... Bref 2 petites heures de cablage et un coup de scie à métaux dans le tableau de bord plus tard c'est posé et fonctionnel ! Au passage elle a perdu 10000km Il me restera plus qu'à modifié la casquette de compteur (le compteur de ronze est plus large et moins haut que celui de 9) et ça sera nickel !
    1 point
  30. La petite 89 au milieu de la praire comme Charles Hingalls 😄 Et ensuite apres un bon nettoyage;a la main et a l eponge et ensuite un petit polissage a la machine pour avoir les piéces nickel a mettre en stock.J avais pensé récupérer le rétro droit.Mais pas la meme forme sur phase 2 .Ma phase 1 n en posséde pas.Les ailes avant également.Rivetée sur ma phase 1;boulonnée avec des vis torx sur la phase 2.
    1 point
  31. Bon! J’ai trouvé ! c’était les contacts de la prise du cartier! Voiture demarrée elle calait lorsque je tripotais la prise… du coup j’ai fais en sorte d’assurer les 4 contacts et finalement je peux accélérer j’avoue que j’ai eu du pot de trouver aussi vite.
    1 point
  32. J ai un moulin moi si sa t interese et il doit avoir dans les 80mklm aussi Il etait monter sur mon autre sp5 auto
    1 point
  33. Il semble y avoir une autre référence chez Valéo qui corresponde mieux, je vais en prendre un pour voir : 578076 https://www.auto-doc.fr/valeo/1088404 https://www.amazon.fr/Valeo-578076-Adaptateur-balai-dessuie-glace/dp/B00DQH0YJG
    1 point
  34. Sujet déplacé dans ATELIER EQUIPEMENT Quel que soit le modèle de la Super 5, à sa sortie d'usine, si elle avait l'option "vitres teintées", tous les vitrages étaient teintés vert (du pare brise jusqu'au hayon), sinon tous les vitrages étaient complètement transparents. Après, si la vitre a déjà été remplacée, il n'est pas impossible que ce soit la première venue qui ait été montée, sans faire attention à sa couleur.
    1 point
  35. tu va voir a cette adresse https://www.auxal.fr/page-d-articles/joint-joints-clip-clips-vitre-custode-renault-5-r5-gt-turbo-rear-quarter-glass tu a juste un clip a enlever a l’intérieur avec un petit tournevis enlevé pas le 3 cars si carreaux tombe il casse lol
    1 point
  36. Salut, Essaie de shinter le thermocontact qui est vissé en bas du radiateur. Si le ventilateur s'allume, c'est sûrement le thermocontact qui doit être remplacé. Une purge mal faite peut aussi amener le liquide à bouillir avant que le ventilateur ne se déclanche.
    1 point
  37. ok je regarde l’état comment il sont sur la gte sinon tu peux en trouver des nouveaux chez auxal
    1 point
  38. Tu as bien nettoyé le plan de joint ? Léger ponçage au grain 800 voire 1000 ?
    1 point
  39. Madame n’avais pas roulé depuis 11 mois alors le beau temps m’a persuadé d’aller la laver rapidement et de lui faire faire un petit tour et lui dégourdir les jambes. Toujours vaillante elle démarre au poil. Le niveau de LDR a baissé du max au milieu du bocal pendant ce temps, je table sur une micro fuite ou des durites devenues poreuses mais rien d’inquiétant. Il me faut toute ma volonté pour la ranger afin de rester concentré sur la GTX pour l’été 2024 et ainsi éviter de m’égarer sur plusieurs chantiers à la fois. 😅
    1 point
  40. Petits travaux du jour : - remplacement des vérins de coffre. en acheter sur le bon coin tout droit sortis d'une épave immobilisée depuis 10 ans, c'était pas l'idée du siècle. J'ai eu un doute sur le sens de montage, alors j'ai fouillé dans mes archives et j'ai retrouvé la NT qui explique tout : Et hop, tout beaux tout neuf, avec un dégivrage arrière qui fonctionne probablement pas moins bien qu'avant mais on verra cet hiver 🤣 - Remplacement du raccord du tuyau de dépression sur le mastervac : - j'ai également remplacé la courroie d'accessoire que je n'avais pas encore faite, parce que c'était tellement facile à faire que j'avais toujours à temps de le faire plus tard. 😅 Il me restera à changer les deux flexible de frein arrière qui sont craquelés (ils ne l'avaient pas vu au CT 😞 ) que j'ai reçu avec cette commande, mais c'est une opération plus importante que je ferai ... une autre fois 😅 Au menu pour la suite : - remplacement des feux de croisement et d'un feu de route (chrome corrodé) - peut-être enfin un vrai gros nettoyage des moquettes intérieur qui font peine - réparation de la plage arrière qui part en lambeaux, mais c'est quasi introuvable surtout dans cette couleur (sable) ... 😞 Puis après, j'aimerais réussir à refaire la banquette arrière dont les mousses d'assise sont HS mais je ne sais pas trop comment m'y prendre, puis changer l'aile AVD, réparer l'AVG, et repeindre tout l'avant dont le capot. Mais ça ... 2025 ! Bordel, que d'argent dépensé en pièces dans cette voiture qui pourtant ne vaut rien ... mais je ne sais pas pourquoi, je l'adore 🥰 ... À+ Thomas
    1 point
  41. Bon déshabillage de la porte ce soir. Je me suis un peu emporté le gars y était pas pour grand chose. Mais je peux pas croire qu'il ait rien entendu... Le moteur et son mécanisme tiennent par 4 rivets acier sur la voiture. L'un d'entre eux était cassé depuis longtemps de ce que j'ai vu. Et la vitre s'est mise en vrac parce que 2 autres se sont cassés net lorsqu'il a ouvert la vitre. Ça a dû faire un sacré bruit... Ensuite j'ai galéré à la régler, elle remontait presque 3cm trop haut et redescendait direct. J'appelle mon frère qui me dit de baisser la vitre, débrancher et rebrancher la batterie puis de remonter la vitre. Ça marche du premier coup... J'ai galéré pendant 1h avant ça... Enfin bon ça marche, j'ai presque fini de la remonter et on sera bon
    1 point
  42. Hello ! Nous sommes bien arrivés à St Maurice de Gourdan sans encombres !!! Nous avons parcouru 387 kms en 7h30. Consommation 12 litres !🤣
    1 point
  43. Et on reprend..... Avec l'ampoule qui va bien: Elles ont le culot évidé pour faire passer la lumière de la veilleuse: Ce qui donne: Et en code: Et en phare: Fixation de l'aile, dessous: Sur le côté supérieur: Et au moment de fermer le capot: Ca touche et il manque 15 mm On s'affole pas, on verra ça plus tard, un peu d'esthétique: Frotte frotte frotte... Montage: Peinture / vernissage de ce qui remplacera les cartons de radiateur: Décapage cuvelage de phare gauche: Mise en peinture (pour le fun, histoire de....) Plus "hard", cela fait bien plusieurs semaines (qui se sont transformées en mois) que je cogite à une idée... Récup des étoiles avant: (Elles ne viennent pas de Moscou ) Le truc, c'est que les trous ( x10 ) sont ceux qui la fixent sur le moyeu, MAIS les vis qui la tiennent, tiennent aussi le tambour sur le moyeu.... Merci à l'apprenti d'avoir démonté une pièce qui ne se démonte pas (centrée d'usine....) Du coup, pour recentrer 2 pièces fixées par les mêmes vis sur une 3° pièce, je vous laisse imaginer le casse tête.... Possible au tour, mais avec beaucoup d'heures.... J'ai tenté une autre approche: Réduire le diamètre des vis pour serrer via des entretoise le tambour sur 5 points. Ensuite, passer l'étoile, la centrer et tus serrer.... J'ai donc acheté 5 réducteurs de filets ( de M8 à M6): Utilisé des entretoises et des vis longues: Vous savez quoi? ben ça marche pas 🥵 Enième plan B (on doit en être au ZZ en fait.....) Usinage d'un arbre pour caler les roulements (coniques....), et positionner le tambour: On prépare la manip: Le mieux que ce que j'ai pu faire: Je ne suis pas mécontent Ensuite, je bride cet ensemble par le centre de façon hard: Positionnement et centrage de l'étoile: Je contrôle: Maxi du tambour après serrage: Et maxi de l'étoile: Je considère que c'est bon. Je n'ai plus qu'à faire la seconde roue.... Franchement, c'est un soulagement, je ne voyais pas comment j'allais m'en sortir... Ca mérite un peu de repos...
    1 point
  44. J’ai eu ça pour une bouchée de pain sur LBC cette semaine, pas sûr dans quelle Sup’ il finira mais ça a l’air pas moche avec la gtx.
    1 point
  45. Un an plus tard... Un peu de nouveau sur celle-ci ! Les antibrouillards qui étaient dessus étaient complètement morts. Pris l'eau, rouillé etc... Donc on change ! J'ai opté pour des ducellier jaunes d'époque. Parce que je les avais en stock, ça aide à prendre la décision. J'en ai profité pour refaire le câblage qui va avec et qui avait a moitié brûlé dans le tableau de bord. Du coup remplacement des câbles, on branche l'interrupteur d'origine et on installe une boîte à relais dans la baie moteur pour être plus propre. J'ai aussi récupéré un faisceau de pare chocs dans la xantia épave de mon frère. J'ai donc un beau faisceau installé sur la traverse, c'est bien mieux même si ça se voit pas ! Et depuis hier elle est comme ça. On démarre le compte à rebours. Dans un mois elle doit être remontée avec tous les plastiques refaits proprement. À l'heure actuelle ils sont tous posés dans le garage et la peinture est dans un camion de transport. Ah oui, je dois les emmener chez mes parents à 240km de chez moi pour le faire...
    1 point
  46. J'avais quelques photos en attente pour celle ci de mon dernier passage à Toulouse C'était en février et il faisait un peu froid. Combiné à une voiture poussiéreuse et dont la peinture est morte, ça donne un aspect chevelu un peu marrant Avant de la remiser à nouveau dans son box, je l'ai bien entendu lavée (à l'extérieur), ça ne se voyait pas trop, mais elle en avait bien besoin.
    1 point
This leaderboard is set to Paris/GMT+02:00
×
×
  • Create New...

Important Information

By using this site, you agree to our terms Terms of Use of use and privacy policy Privacy Policy.