Leaderboard

On continue de jouer au chat et à la souris des fuites de LDR Mais on reste malgré tout « corporate» 😁

Rassemblement près de la maison avec sa sœur jumelle.

Enfin un peu de beau temps …j en ai profité pour faire un bon nettoyage et ça fait du bien ensuite montage des bavettes à l arrière et de plaques conforme…les autorités locales sont devenues chatouilleuses avec la zfe et gare à toi si tu n es Pas en règle donc les plaques noires ressortiront quand elles auront le droit d être posées j ai pas réussi monter les bavettes à l avant pourtant ce sont les bonnes mais je suis gêné par les fixations de mes bas de caisse … si qq un à une photo de sont montage je suis preneur. Bonne fin de journée à tous

J'ai fait un tri dans les pièces ré-utilisables ou plus genre des pistons / chemises : En tapant comme un gros c*n: Bon, ça m'a permis de récupérer des bielles Du coup, j'ai rempli un bac de maçon de déchets (et gagné de la place dans le garage): Ensuite, j'ai déposé la barre anti roulis et toutes les tôles de chassis à sabler / repeindre en époxy: J'attends le retour... Me suis attaqué à la bavette côté conducteur, vu le prix (50€ la paire...) Décapage, apprêt + gabarit: Du caoutchouc commandé sur le internet: Découpé: Positionné: Rivetage: Puis pose sur la voiture. Ensuite, un petit moment: Sortie de la voiture du garage pour lui faire faire 1/2 tour et permettre d'attaquer le côté droit et finaliser le compartiment moteur. Le rendu est sympa à la lumière du jour:

On poursuit.... Derrière, même opération, mais ça a été la misère... Vraiment... C'est crade... Et le joint est mort: Va falloir se taper une merde de refab qui ne se montera probablement pas bien... Nettoyé: Nettoyage des chromes: On pose le joint profilé en "U" qui est en feutre (collé au PU et riveté ) et la glace fixe et la glace coulissante et la réglette de coulisse (le tout avec ... 2 mains ) Y'a pas à dire: ça habille: Ensuite, montage aile arrière et jonc (là aussi je me suis marré ... 3 jours...) Le jonc est livré droit, il faut le former, puis il se "pince" entre l'aile et la caisse avec une partie caoutchouc ... blcnhe... evidemment... Qu'on aperçoit si on le cherche.. Ca ira bien... Ensuite, le sabot d'aile: Positionné et formé Nettoyé et posé: Briqué: (C'est de l'alu) Puis ... la boite de vitesses... qui s'est vidée par terre... On dépose le couvercle: (Tourner la tête de 180°) Joint qui a servi (extrait de la pochette): Joint taillé dans une feuille: Une bonne beurrée de pa^te: Ce produit est top: C'est épais et collant comme de la pâte à pare brise (donc on s'en met partout ) mais ça à l'air sacrément efficace On remonte: Puis pose du bas de caisse (faut pas oublier, c'est une "Sport" ) Au final, ça donne bien: Par contre, quand je la retournerai faudra tout recommencer....

On ne l'a pas bien perçu plus haut, mais la baguette de porte arrière est posée: J'ai reçu ce qu'il fallait pour le volant, pratique pour tourner... (c'était l'objectif: retourner la voiture....) Le moyeu amorti: Montage puis nettoyage de la bague (cassée 😢 ) Le centre de volant a été rafraîchi, avant: Après: Merci le rénovateur de phares Montage: Puis positionnement du cendreier: Il est sale et pas ... repeint... Nettoyage: Et montage: C'est mieux Bon, maintenant: chantier de merde.... Rien ne s'ajuste, rien ne tombe en face, donc, faut y aller avec patience et délicatesse, pas toujours mes vertus premières 1ères mustaches: Puis 2ème: Et 3ème: Ah, ben là, ça ressemble plus à une 4cv maintenant ... Bon, on voit pas tout mais en zoomant.... Quand on est con, on est con.... Bon, c'est réglé On s'attaque aux vitrages: Nettoyage et nourrissage des joints (que je vais récupérer): N-I-C-K-E-L Pré-positionnement: Notez les cales en cartonnette... J'ai tout collé au butyl au cours de la pose. Vitres fixe posée: Pose du triangle: Et de l'encadrement pour fermer le tout: J'adore

Avec l’aide previeuse de @totof59, greffe de nouvelles rotules avants. Les précédentes étaient bien usées et la différence de comportement se ressent immédiatement. C’est beaucoup plus précis et moins flottant. Vivement la pose de ses nouvelles coupelles et amortisseurs le 18 🤩 Par contre on a découvert que mes cardans, sûrement ceux d’origine, sont vraiment à bout de souffle donc un item de plus dans la liste de la remise à niveau avant le CT.

Je ne sais pas s'il y a des gens qui s'intéressent à la 4Cv ici, mais je vais détailler le montage, le texte ne suffit pas toujours. De base (sur chaîne de montage), c'est comme ça: Tambour taraudé + moyeu percé + étoile percée. On monte le moyeu sur le tambour: Puis l'étoile (elle prend en sandwich le moyeu...). Le tout est serré avec 10 vis de M8... J'attaque donc la roue gauche: Centrée: Puis mise en pression du couple moyeu + tambour pour retirer les vis et mettre l'étoile: Vérif du tambour pour être sûr qu'il n'ait pas bougé: 14/100°, ça va, c'est pas non plus une Formule 1... Et remontage: Par contre, j'ai une vise de roue qui est vraiment excentrée (1.5 mm), je l'ai repérée, je mettrai le jeu de la jante à cet endroit pour compenser. Au final: Les jantes font vraiment pourrav', mais je les ferai en dernier (avec les pneus aussi, je crois que ça passera pas au CT ) L'aile avant gauche est retirée pour faire l'électricité du faisceau avant. J'avoue que je suis soulagé, ces étoiles m'ont vraiment donné du fil à retordre, alors qu'au final, c'est pas si compliqué que ça...

Mon volant est de retour de chez le cordonnier à qui j'avais confié un peu de cuir venant de chez Mchris. le résultat est pas mal du tout

C'est sur ! on va déjà rouler un peu comme ça pour voir si ça tient bon et on avisera par la suite... Maintenant que je suis lancé, j'ai comme envie de me remettre un peu à la GTX...

Après 1 an d'arrêt miss r9 est de retour ! Redémarrage laborieux, gros claquement moteur le tempes que ça ce lubrifie correctement, j'ai du pomper 45 fois sur les freins histoire que ça freine mais j'ai pu la ramener chez mes parents ! Programme du week-end prochain : changement de tout le trains avant qui n'a pas apprécié le combo rabaissement/conduite un peu muscle. Ensuite géométrie et je la prendrais le temps de faire un peu de mécanique sur l'audi

Décidément, on est gaté avec le temps en ce moment, allez hop bavettes à l’avant et coup de propre à l’intérieur…. J’adore quand elle est comme ça Je remonterai les bulles au printemps, il faut que je fasse des encoches pour les enfiler correctement (titre??) et pour les plier sans les casser on va laisser le mercure remonté un peu mais ça me démange forcement

Petit tour aujourd'hui, capricieuse à démarrer après plusieurs jours d'arrêt. Séance photo sous l'une des arches de l'aqueduc de maintenon.

Bonjour à tous, ma sup' n'est pas encore collection et à partir du premier janvier la ZFE et bien c'est ma rue....et tous ce qui n'est CRIT n'a pas le droit de rouler 24/7 La Mel de Lille a mis en place plusieurs dérogations dont une pour petit rouleur, c'est à dire moins de 8000 km par an Facile, il ne demande que les deux derniers CT, la carte grise et un justif de dom. 48h plus tard, un petit cadeau de Noél en avance et 3 ans peinard

Changement (temporaire) de sujet, juste pour vous partager ma petite satisfaction de la soirée... Depuis quelques temps, mon autoradio (un Pioneer KE-4630B) fait un 'clac clac clac clac' désagréable lors de la lecture de cassettes. Ayant deux autoradios de ce type, je démonte celui que j'ai en stock pour voir si ça se démonte bien, ou si je risque de me retrouver avec 12 ressorts qui volent et qui sont impossibles à remonter. Tout est au vert, donc on entame l'inspection ... Difficile de localiser la source du bruit. Je remarque qu'avec 3 vis, on peut sortir facilement l'ensemble de lecture de cassette ! Une fois déposé, j'identifie rapidement le coupable : la poulie réceptrice de la courroie d'entrainement, qui a cassé avec le temps (regardez au milieu, au dessus du truc en plastic vert)... Et bien sur, c'est cassé sur les deux : une maladie, comme on dit... 😞 Je me dégonfle pas, je suis expert en réparation de plastiques par fonderie avec mon vieux fer à souder. On va faire un lecteur fonctionnel à partir de deux. Je récupère donc un bout de plastique sur la poulie du poste sacrifié, qui me servira de plastique d'apport. Je dépose la poulie et on attaque la boucherie. Après plusieurs itération, et un bon ponçage pour gommer toute aspérité (au premier remontage, c'était pire, ma poulie n'était pas assez lisse et frottait contre un truc), j'obtiens un résultat relativement satisfaisant (j'y croyais pas, franchement) : J'ai réparé 3 endroits fendus au final. Un test au banc se révèle satisfaisant : plus un bruit ! Une fois reposé dans la voiture, ça marche bien. J'ai finalement swappé les mécanismes entre les deux postes, mais celui que j'ai remonté me semble un poil lent. Je vais surement les re-swapper, en swappant également les poulies... z'avez suivi 😅 Bref, Pioneer c'est (c'était ?) de la bonne came, facile à réparer. Vous me direz, pourquoi tu t'emmerdes, t'aurais pu acheter une merde Alpine à 20 balles sur Amaz.... mais je l'aime moi ce poste, mes parents avaient ce modèle dans notre R9 😄 Le truc bien, c'est que du coup je sais aussi remplacer la courroie (mais les deux étaient nickel, étonnament) voilà, je ne sais pas si ce message servira un jour à quelqu'un, mais j'étais juste content d'avoir pu réparer un truc que j'imaginais compliqué à démonter avec tous ces mécanismes. Avec un peu de patience, on arrive à faire plein de choses sur nos vieux trucs 😎 Bonne soirée !

On poursuit la remise au propre du faisceau électrique: Puis mise en place aile + cuvelage de phare + files: Je remercie Rétr'Optic ( https://www.retroptic-auto.com/fr/ ) pour la fourniture de connecteur spécial (avec veilleuse intégrée) et du verre de phare de rechange:: Un ebayeur Espagnol pour les ampoules CE avec dégagement de la veilleuse: Montage du phare: Cablage et test de la veilleuse LED: Test du reste: Ca a meilleure mine: Pose des butées de capot: Voilà pour le moment....

Petite photo de la miss

Stickers posés... 👍

Elle est plus "alignée de l’arrière"...voila un joli monogramme tout neuf et une petite vitro sur la droite Joli c*l !!!

Sois le bienvenu ici ! Moi j'approuve l'idée de la refaire en gardant le kit, parce que ça fait partie de son histoire . Et parce que j'en ai marre des talibans de l'origine qui se pignolent en gonflant les prix et en spéculant !

la mise en apprêt et peinture reste plus cas attendre un jour ensoleiller pour des tof du résultat final 😉

Salut, Petit retour d'expérience suite à la mise en place du système piloté par thermostat. Premier avantage, la sonde continue de fonctionner moteur en marche, contrairement au thermomètre à 5 euros d'Aliexpress 😅 J'ai fait un montage rapide sous la platine de servitude : La sonde est accolée au pied de carbu, du coté pompe à essence, donc à l'opposé de là où il y a le tuyau qui aspire. Le thermostat est alimenté sur la batterie, via un fusible de 5A et un interrupteur sous le volant. Ça me permet de ne pas le laisser tout le temps allumé. Il consomme environ 70 mA, donc avant de vider la batterie, ça va, mais je préfère pouvoir le couper. J'ai configuré le thermostat de la manière suivante : seuil de d'enclenchement du ventilateur fixé à 55 degrés, durée minimale de déclenchement de 5 minutes, afin d'éviter des cycles on-off-on-off permanent, ça simule un hystérésis. Je n'ai pas encore fait de gros trajets, mais moteur chaud, en roulant entre 50 et 90 km/h, la température se régule toute seule autour de 50 degrés dans l'environnement du pied de carbu, sans besoin d'extraction. Et dès qu'on s'arrête, et qu'on coupe le moteur, la température monte assez fortement et très rapidement, c'est l'effet convection du collecteur d'échappement, j'imagine. Le ventilo se met donc en marche et extrait l'air chaud au niveau de la roue avant gauche. J'ai rallongé le tuyau de sortie (j'ai trouvé du flexible à la déchetterie 😄). Là il fait entre 10 et 15 degrés dehors, et le ventilo met bien une vingtaine de minutes en fonctionnement avant de stabiliser la température autour de 35 degrés... je ne m'attendais pas à si long. Il faut environ 3-4 cycles pour réussir à ramener la température sous les 40 degrés. Le thermostat permet de piloter deux sorties, je pourrais donc implémenter assez facilement deux vitesses selon la température lue, une première via le régulateur de tension, la seconde en direct 12v. Je pense que ce sera nécessaire en été. Mais après l'extracteur fait un sacré boucan quand il est sous 12v. En tout cas pour l'instant je suis content du montage, bien plus fiable que le truc à base de relai temporisé que j'avais imaginé initialement. J'ai fait une petit vidéo qui illustre le passage du seuil, on voit bien la vitesse à laquelle la température monte avant de passer 55 degrés. Ensuite, elle se stabilise puis redescend doucement une fois l'extracteur en route. https://stash.netnix.in/f/26e2ecb22d854dcfb9a9/ À+ !

Bonsoir tous le monde, Merci pour votre accueil ! Je reste un peu sur ma faim car j'ai très/trop peu roulé jusqu'à présent la faute à une température d'eau élevée sur le compteur. D'ailleurs il n'y a que ça et le compte tours qui marche sur ce compteur. En attendant la réception des pièces j'ai attaqué ce weekend le polissage des feux arrière, démontage de la banquette arrière et passage à l'aspirateur extracteur. Démontage des joints de coffre, feux ar pour nettoyage et traitement. J'ai aussi changé l'isolant thermique du capot. J'ai reçu aussi aujourd'hui les SB de barre stabilisatrice de chez Powerflex et j'attends encore pas mal de pièces de chez Auxal, Flexeo et Kustomorphose...

Des nouvelles ! De retour sur les routes ! Au passage elle a gagné des roues en 16 pouces, des lave phares, et surtout 2 cylindres ! Bon vous l'aurez compris j'en ai racheté une. Le choc a quand même été violent, côté droit elle a reculé de presque 20cm. Le boîtier de calculateur qui se trouvait derrière le phare a été pulvérisé, conduite de DA et radiateur percés, collecteur d'admission cassé et potentiellement le longeron qui a bougé. Côté gauche la batterie a reculé dans la boîte à fusible qui a reculé dans la tourelle. Dans le choc le capot a cassé le pare brise. Sur la face avant les seuls trucs récupérables sont l'antibrouillard gauche et la lame en caoutchouc sous le pare choc. Avis du carrossier "bien motivé tout est réparable mais ça coûtera plus cher que d'en racheter une..." Du coup quitte à faire je me suis fait plaisir ! Il s'agit donc d'une V6 194ch, boîte mécanique, avec 223 000km de décembre 1998. Soit la première voiture plus jeune que moi que je possède (ça se joue à 2 mois mais quand même !) toujours gris Thallium comme l'autre, intérieur cuir noir électrique cette fois-ci, système audio JBL, rétroviseur electrochrome et essuies glaces automatiques. Pratique ces trucs d'ailleurs. A priori elle serait d'origine allemande mais première immatriculation en France. Elle a un attelage Peugeot, dont les étiquettes de charge sont en allemand. Étiquette de pression des pneus en français et allemand aussi... Alarme montée la veille de son immatriculation (désactivée,on prend pas de risque) Pour le moment, j'ai changé le volant qui était complètement HS. J'ai remis un pommeau d'origine et mon accoudoir. Changé les répétiteurs d'ailes qui étaient noirs, les vérins de capot et de coffre et remis une bride de batterie et un cache. Mécaniquement parlant elle est vraiment nickel, bougies et bobines faites la semaine précédent l'achat, émetteur récepteur d'embrayage changé, etc... Petite photo du moteur qui fait quand même plaisir

Petit bricolage du jour remise en place de mon horloge d origine …je me suis lassé des aiguilles et puis avec le froid elle avait tendance à retarder pas mal Peut être ma batterie est un peu faiblarde… problème le + contact n´ était pas relié(le jaune), la faute à cette p….. d alarme qui ne fonctionne plus mais qui a monopolisé ce branchement quand je démonterai le tdb je l enlèverai c est pas la première fois qu elle m emmerde !!! donc ok pour l heure mais sans rétro éclairage la visibilité est nulle j ai récupéré le + contact sur l allume cigare et la lumière fut… ha oui j ai désormais une roue de secours version comète… chez mon fournisseur habituel

Bonne nouvelle, j'ai fini par trouver un hayon de la bonne couleur (et même avec le monogramme GTR 😎) J'attends d'avoir un week-end avec un peu de temps (et pas trop de pluie) pour le monter. En attendant j'ai fait divers bricoles, dont trouver un enjoliveur pentagone ! C'est pas simple de trouver ça, même en étant au taquet sur les alertes le bon coin, il m'a fallu bien 3 semaines pour en trouver un seul et qui était cassé. Il lui manquait une patte de fixation, je l'ai donc réparé et j'en ai profité pour réparer un des autres qui avait le meme soucis de patte. J'ai greffé des pattes qui provenaient d'un autre enjoliveur. J'ai testé un collage à la colle cyano et pour l'autre j'ai fait un collage à la résine, avec une peu de mat polyester. Ici le collage résine + mat polyester Je pense que le deux tiendront, on verra à l'usage. Les enjoliveurs rayés ont aussi eu droit à un bon coup d’efface rayure. C'est pas la panacée mais ça se voit vachement moins de loin. Sinon moins drôle: la rouille ! Après avoir tombé le pare choc et démonté la structure de l'attelage (quelle merde ce truc), j'ai vu que sous le pare choc, l'aile droite était bien attaquée. Rien de visible en si le PC est en place. Je ne sais pas s'il y a deux couches de tôle superposées à cet endroit ou si c'est juste la peinture qui est très épaisse, mais il y a une belle couche qui est partie J'ai traité et je verrai si je peux repeindre. Aussi, on voit la route depuis le coffre, je savais déjà que c'était perforant par là, je pensais pas c'était si grand. Pas cool. J'ai tout décapé, traité et mis un coup de peinture pour pas que ça se propage. J'ai l'impression que l'humidité s'est bien développée sur tout la zone au dessus du pot d'échappement. Dans le coffre ça à l'air d'être bien pris à plusieurs endroits, dont une partie de l'angle entre le fond de coffre et le passage de roue. On dirait que sous l'espèce de mastic / joint c'est la foire à la rouille. Mais bon, à part le trou que j'ai décapé, rien d'autre ne semble être perforant. Il faudra bien que je décape tous les petits points de rouilles qui démarrent dans le plancher du coffre. La zone trouée du coffre, traitée et peinte des 2 côtés, ainsi que la zone rouillée de l'aile ARD, juste traitée. A part la zone du coffre et de l'aile droite, l'arrière semble plutôt sain vu du dessous, juste quelques zones rouillées en surface. Meme sous les platines qui servaient à fixer l'attelage c'était pas si terrible. J'ai gratté et traité ce qui était rouillé en surface. Pour info, j'ai traité au Frameto, je compte peindre ensuite les zones traitées. Le frameto c'est bien mais je pense pas que ça tiendra dans le temps. Sachant que je n'ai ni le matos ni les compétences pour souder ça, je verrais comment reboucher le trou après avoir fait le tour de toute la voiture (en espérant que ce soit le seul et unique trou de rouille 🤞 Ah et j'oubliais ! Le pyromane a été identifié, c'est pas une histoire marrante mais ça présente un avantage pour moi : la franchise est remboursée. En terme de réparation des dégats de l'incendie je devrais donc rentrer dans mes frais.

J avais oublié à quelle point une petite sup va bien sur la neige ..

Renault 6l de 1979 type r1180 moteur billancourt 800 03, 845cm3. Arrêtée faute de temps réservoir plein de rouille.

Retex après 3000 km au E85 J'avais promis un retour d'expérience ; le voici. J'ai donc commencé à donner du E85 à ma charriote, à raison de 20 à 25 % dans le 95, puis 40% pour voir... J'ai fait cela durant un cycle complet de saisons, allant du presque négatif (par chez moi ça ne descend que rarement en dessous de -1°C ou -2°C), au bien chaud d'été entre 32 et 35°C. Après avoir eu l'idée qui a, semble-t-il, troublé nombre d'intervenants, de connecter l'entrée d'air du filtre à la prise hiver du collecteur d'échappement, ceci afin de compenser un dysfonctionnement par temps froid (et jamais déconnecté même par temps chaud), le moteur a fonctionné normalement en dépit d'une possible faible perte de puissance, dont je me moque totalement (pour rouler à 80 km/h, y'en a toujours assez). Bizarrement, la consommation très stable au 95 est devenue fantaisiste, passant de moins de 5 L à plus de 6. Je n'ai aucune explication et ne peut corréler cela avec les conditions climatiques. Mon bilan est que l'économie financière réalisée est très marginale, vu que je ne roule plus beaucoup (8 à 12 000 km) ; on peut tabler sur 100 à 150 euros épargnés / an. Pour certains c'est une somme, pour moi non, parce que mon budget carburant le permet. En revanche, la chiantrie de mélanger mes petits bidons à chaque plein est incommensurable et vaut beaucoup plus qu'une maigre économie. J'ai donc arrêté cette expérimentation à la fin de mon dernier bidon de E85 et ne la reprendrai sûrement pas. La mécanique ne semble pas avoir souffert de cette expérience, sachant que je réalise des vidanges d'huile tous les 6 000 km avec filtre et que le carbu a été refait à neuf peu de temps avant. Une petite précision pour les septiques qui doutent de mon intervention. Je ré-répète que je ne vends rien et n'ai aucun intérêt à passer pour un découvreur. Mon métier durant 3 décennies consistait à tester et évaluer des véhicules (motos et autos). J'en conserve un certain sens de l'analyse et un feeling pour le ressenti de fonctionnement. Je ne donne pas des chiffres au doigt mouillé, mais relate les notes prise au fil de mon expérimentation. J'ai annoncé avoir roulé 715 km avec 35 litres de 95 coupés à 40% de 85 (soit 4,9 l/100), c'est que c'est ainsi. Je n'en tire pas de gloire, mais constate que les théories établies sont parfois mises en difficulté par un petit exemple têtu, genre caillou dans la godasse. Mais aussi il est arrivé que cette voiture consomme 6,4 litres/100 sans changement notable de conduite. Je le relate, mais m'abstiens de tenter la moindre explication. Depuis que j'ai repris l'usage exclusif du 95, la consommation est redevenue stable, entre 4,9 et 5,2 l/100. En conclusion, je ne recommande pas l'apport de E85 avec la mécanique Cléon carbu.

Petite sortie de parking pour ma petite Automatic, et surtout l'occasion de mettre à niveau mon éclairage intérieur avec des LEDs: du chaud pour les "éclairages d'ambiance" et du froid pour les liseuses. C'est une configuration que j'avais testée sur l'Espace, ça me plait bien. L'habitacle reste convivial et on ajoute une touche de modernité sur les liseuses. Quelques photos de nuit: La différence entre chaud et froid: Dans la boite à gants, j'ai mis du froid aussi: Mais dans le coffre: chaud Et quand il n'y a que la liseuse à l'avant qui est allumée, ça balaye large mais sans trop en mettre dans les yeux du conducteur: Et enfin, pour le plaisir, une photo globale. Ce soir: remplacement du liquide de frein!

En ce moment c'est l'euphorie !! J'ai eu la chance de pouvoir mettre Mlle sur un pont, pour 2 sujet. Le premier checker l'état des sous bassement.....PAS UN PET DE ROUILLE YOUHOU !!!!, elle est nickel et ça fait plaisir Le deuxième point était de fixer le cache sous le moteur, celui trouvé l'hiver dernier pour pas trop cher au vu de la rareté en bon état. Et hop ça c'est fait aussi !!! encore et toujours qq photos et merci à mon meilleur ami pour le pont, on l'aurait bien fait plus tôt mais son cabriolet 504 prenez la place...

Tout commence par une caméra de surveillance qui voit un mec allongé sous une voiture sur chandelles dans les graviers... Bref, le but était de déposer la boîte pour remplacer l'embrayage. Armé de la RTA et du M.R. 242, je me sentais invincible... Bon, j'ai un peu galéré, mais ça va ! Déjà, un bon levage bien haut et sécurisé Démonter tout les trains, c'est la partie facile et fun. Le plus chiant, c'est les supports, surtout l'arrière, puis réussir à sortir cette JB3 en montant/descendant le moteur. À un moment, le moteur reposait contre la cloison pare-feu par le ... carbu 😱 une sangle entre la culasse et la traverse avant au niveau du capot m'a permis de le refaire basculer vers l'avant... après 5h de taff, elle est sortie ! L'ancien embrayage était pour ainsi dire neuf ... mais le diaphragme était dur comme pierre. Allez, dégraissage du volant moteur, graissage du pivot de fourchette, du guide de butée, centrage, serrage à 45 Nm et zou, le Luk est posé ! Puis la suite plus tard ... je me suis arrêté là pour aujourd'hui 😅

Cet après midi notre cher @Promeneur est venu me filer un coup de main pour un changement de radiateur Je pense que vous en conviendrez, ca ira bien mieux qu'avec un radiateur de Five !!! Du coup vidange de LDR ,changement carlostat, sonde de ventilo et une durite, les autres attendront.... Ah oui l'arrivée d'air est enfin à nouveau en place ... Un grand merci à @Promeneur

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 d'accélération adaptée à l'écart entre l'actuel et la cible (en tours par minute, à arrondir à la dizaine) #define MARGEINFPOTLENT 5 // 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 255 // 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 50 // Variateur pour le moteur via la pin PWM pour l'accélération lente. (Valeur comprise entre 0 et 255, mini 60) #define VARIATLENTMOINS 25 // Variateur pour le moteur via la pin PWM pour la décélération lente. (Valeur comprise entre 0 et 255) #define MARGEACCELINIT 25 // Valeur ajoutée à la variation VARIATLENTPLUS pour l'accélération initiale (à calculer de façon à avoir 70 minimum) //---------------------------------------------------------------------------------------------------------------------------- // 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 + MARGEACCELINIT), 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 + MARGEACCELINIT); } 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), MARGESUPVITRAPID, 2000, VARIATLENTMOINS, VARIATRAPIDMOINS); // Calcul de la valeur de variation à adopter (sur un écart de MARGESUPVITRAPID à 2000 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), MARGEINFVITRAPID, 2000, VARIATLENTPLUS, VARIATRAPIDPLUS); // Calcul de la valeur de variation à adopter (sur un écart de MARGEINFVITRAPID à 2000 tours entre la valeur actuelle et la valeur cible) if (variationPwm > 255) { // Si la valeur calculée dépasse la valeur maximum (255), on force à 255 variationPwm = 255; } } else { // Sinon on reste sur la valeur minimum variationPwm = VARIATLENTPLUS; } 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(); } }

38 ans de terre séchée. C est ça sui fait pourrir.Nettoyage en règle.

On continue avec le compteur, la minutie et la patience sont les ingrédients essentiels. Ça va être pas mal cette couleur.

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

Elle a eu son ct ok hier la petite

En attendant, madame à passé sa contre-visite de CT haut la main aujourd’hui 🥳 On va profiter du beau temps pour aller bosser avec les prochaines semaines.

Des nouvelles de la Sup! Elle continue à faire son bout de chemin avec 185000km au compteur. Ce dimanche après avoir vu des voitures anciennes passer devant chez moi je me suis rendu compte qu'un rassemblement + de 30ans (les voitures hein) avait lieu juste a côté de chez moi! Un coup de Karcher et c'est parti pour son premier rassemblement! Elle a très rapidement trouvée une copine, une Super 5 GTR avec 50000km au compteur et pas une ride a la peinture! J'ai pensé à sortir les cartes du forum et mon casque qui porte le logo Renault! Un petit panache des photos prises lors du rasso: Notre Ferrari française! Matra rancho obligatoire si proche de Romorantin-Lanthenay

Bonjour à tous, Effectivement j'ai changé ces deux courroies en février. Et je n'ai pas pris le temps de faire le tuto Je l'ai encore bien en tête cela dit et j'ai les photos qui vont bien Va bien voir la discussion sur mon post pour la réf des courroies, moi j'avais pris ces trois la. Je pense que le propriétaire précédent avait du mettre une avec la mauvaise référence mais je l'ai prise quand meme...il reste un doute sur ce point la Pour résumé il faut sortir l'alternateur, rien de compliqué, et ensuite c'est la pompe de Direction assistée qui bascule pour tendre la courroie. Selon les cas c'est plus ou moins long à faire car c'est souvent grippé à cet endroit la A dispo biensur si tu as besoin de moi

Ça fait presque un an que je n'avais pas donné de nouvelles de ma brave petite Automatic! Elle est toujours dans son box en région toulousaine, et elle est même bloquée dedans car le portail de la résidence ne s'ouvre plus Son CT est périmé depuis janvier, et je n'ai pas le temps de m'en occuper (du moins pas avant cet été). Ça ne l'a pas empêchée de démarrer comme une fleur après réamorce du circuit de carburant (vive la pompe électrique ), sans brouter comme elle avait pu le faire il y a quelques temps. Bref elle ne demandait qu'à sortir se dégourdir les roues, brave petite!

Y'a un peux de soleil donc des Tof pour les amoureux D'images🥰 avec retour des autocollants SAGA pour les jonc chromé vas falloir que je ruse apparemment

ouaip, tout le monde a l'air d'accord, donc ok pour la pompe (et bien sûr distri). Le reste on verra si ça fonctionne lorsque ça lâchera...

Allez en attendant un peu de temps sec ( je n'ose pas demander du soleil) voila mon phare droit en H4 qui vient d'arriver, il de marque SEIMA si j'ai bien vu. il n'y a plus qu'a trouver la copie conforme pour le gauche .Trouvé sur LBC pas trop cher 55 euros, merci @totof59 pour le repérage

Merci ! Je suis vraiment content de connaître ce forum honnêtement c’est cool de voir encore énormément de passionné, de savoir faire et un bon accueil 👍

Petit retour d'expérience après deux trajets autoroutiers. 10 degrés de température extérieure. - à 130 km/h, la température en pied de carburateur ne dépasse pas 45 degrés. - à allure plus modérée, on monte vers les 50 degrés, mais en gros tant qu'on roule à plus de 50-60 km/h, la température reste stable et pas excessive, le tout sans avoir besoin d'extraction bien entendu. - une fois à l'arrêt, il faut environ 3 cycles de 5 minutes d'extraction d'air pour que la température ne dépasse plus 55 degrés. Une heure plus tard il fait encore 40 degrés là dessous. Un point important à prendre en compte, c'est le fait que j'ai débranché le tuyau, utilisé normalement pour que l'admission prenne de l'air chaud au niveau du collecteur, de la boite à air pour le mettre derrière le motoventilateur de radiateur et ainsi amener de l'air au niveau du collecteur. Un impact notable, c'est que quand le motoventilateur se déclenche, la température dans la zone du pied de carbu monte en flèche. Forcément cela accélère la dissipation des calories contenus dans le collecteur ... Alors je me demande quoi faire de ce truc. Le virer ? Y amener de l'air vraiment frais qui ne traverse pas le radiateur ? Aspirer aussi ? En tout cas quand le ventilo tourne mon extracteur ne suffit pas et la température peut monter jusqu'à 70 degrés facile je pense. Et il ne fait pas encore chaud dehors ! Enfin bref, au final l'autoroute n'est pas un problème du tout (de toute façon on était déjà tous d'accord pour dire que le pb, ce sont les trajets lents dans les bouchons en pleine cagne), ça ne chauffe pas trop, et le cycle de refroidissement après arrêt est "comme d'habitude" (cad quand je fais des trajets plus courts autour de chez moi). Je suis donc pour l'instant super content de mon système ! À+

Je dirais que les nouvelles ne sont pas idéalement adaptées pour, mais elles se montent! Même telles quelles ça passe, après moi je recommanderais une légère modification pour favoriser l'aspiration de l'huile. Et ça, c'est dans le tuto

Mes durits ne sont toujours pas prêtes, mais devraient l'être la semaine prochaine... J'ai un peu hate je dois dire! Car il ne me manque plus que ça pour tout remonter. Entre temps j'ai fait quelques travaux d'amélioration/réparation, tant que le tableau de bord était tombé. Du style le pédalier qui avait un peu de jeu (pas genant, mais potentiellement source de panne à l'avenir). J'ai donc refait une des pattes de maintien: L'ancienne avait l'axe un peu bouffé (en fait j'ai juste soudé une nouvelle tige à la place de l'ancienne): J'ai aussi refait encore une fois (mais cette fois de façon durable, normalement), la jonction entre le cable d'embrayage et la pédale. Car là aussi, malgré le stock de graisse que j'avais mis, ça faisait métal contre métal, et la vis a pris un peu cher: Je l'avais refait il y a à peu près un an... Il n'en fallait pas plus. Donc on réinvente quelque chose, et on passe à la technologie "roulement à billes" Puis on le pointe pour ne pas qu'il se barre: Des deux côtés, car j'apprends à me servir d'un MIG que je viens d’acquérir, il ne faudrait pas que ça ne soit pas solide non plus Le roulement tourne bien, je peux mettre la patte qui accueillera le cable avec un système de goupille: Voilà, là je pense que ça ne s'usera pas tout de suite... Et tant que la pédale est démontée et le MIG sorti, je soude une patte métallique pour accueillir un contacteur de pédale d'embrayage Car souvenez vous, j'ai ça qui attend (et que j'ai optimisé aussi normalement pour réduire les éventuelles interférences): mon Arduino de régulateur de vitesse! Il va falloir le tester lui aussi dans cette nouvelle configuration: Il faudra aussi que je finisse le cablage pour le signal du compte tours... Et ça, ça se passera dans le topic dédié