Forum Mustang

Voila je résume déja qques mois de développement , donc pavé  ;D
Ceci était sur le post du Fastback 65 , je fais ce post spécifique sur le développement d'un controleur pour mon moteur à base d'Arduino Mega 2560 : pour ceux qui ne connaissent pas mon moteur , je roule beaucoup et descend souvent en Camargue avec la Mustang et les canicules sont sévères , le but étant d'avoir une clim fonctionnelle ( chien dans la voiture ) par 40 - 45 °C à l'arret dans les bouchons .
Donc ne voulant pas trouer mon tablier et y mettre un gros radia , j'essaye d'autres voies .

Et je vous rassure , si c'est en panne , la voiture fonctionne normalement , juste ventilo moteur et pompe manuel ON/OFF LOL Je n'ai pas quitté la S5 pour me remmetre des ordis lol

Il y a à controler de manière active :

- Ventilo Spal brushless en primary fan controlé en PWM , régulation type PI ou PID sur capteur de tempé. ( actuellement controlé par un VSFM002 de Lingenfelter )

- Pompe à eau électrique brushless en ligne Stewart d'appoint ( celle des Funny cars , Dragster and co ) qui permet une circulation conséquente de LDR au ralenti ou même moteur stoppé afin de refroidir efficacement le moteur avec la pompe à eau méca au ralenti. (actuellement controlée par un thermostat Mishimoto ) Je l'ai essayée pour descendre chez @toine10 , bluffant.

- Clim passage en automatique plutot que manuel , actuellement manuel , par la suite Arduino

Le reste du role de l'Arduino c'est essentiellement du recueil d'infos et de paramètres.
Je précise que j'ai un carbu et déja un AFR avec sonde wideband et une pompe à vide Star Machine pour limiter le blowby ( pareil matos de funny cars ou de Dragsters )

Niveau paramètres à surveiller/datalogger par l'Arduino via écran TFT tactile :

- tempé LDR si possible au niveau de l'intake repiquage sur la sonde d'origine, assez facile à programmer une fois la courbe RΩ/T°F ou °C connue
- rpm en % du max du ventilo Spal, avec réglage sur écran tactile de la fenètre si modif necessaire, car celle ci sera controlée en PI ou PID, donc accès de bas niveau au Kp, Ki voir Kd sans remmètre l'Arduino sur l'ordi.
- pompe à eau d'appoint Stewart enclenchée ou non , avec réglage de la fenètre de tempé sur écran tactile, pas de PID là , c'est du ON/OFF
- tempé et pression d'huile moteur , facile.
- tempé huile boite C4, facile
- tempé int / ext voiture avec accès aux réglages de la clim, moins facile
- Vacuum level du bloc moteur vu la pompe à vide , je suis sur une régule à - 8 inches Hg pour un usage street, après 2000 km comme ça c'est parfait.
- voltage batterie , facile.

Ouf voila , le cahier des charges appelé à varier éventuellement.

Donc je programme ,  @geloche m'aide bien par ses conseils
Ca progresse , j'espère les premiers tests cet hiver.

Ci après résumé du développement qui était à la base sur la poste du Fastback

Donc tout ce qui est en dessous est un flashback ;)

_________________________________________________

Capteur de tempé , essai thermocouple K , afficheur , mesure de tension commande relai de puissance
C'est dur d'apprendre un langage qd on est vieux ;D
Il est dynamique l'affichage , mais j'ai pas fait de vidéo exprès pas la peine

(https://www.trechph.ovh/images/mustang/IMG_0456.jpeg)

_______________________________________________

Hier me suis amusé avec le PWM sur une diode, bref j'apprends tout ce qui m'interesse comme modules pour controler les trucs dans la voiture, tu as des trucs sympas , style capteur de proximité qui t'envoie un SMS quand on ouvre le capot , tout ce que tu peux imaginer etc ... Bon un cadenas ça marche aussi LOL

(https://www.trechph.ovh/images/mustang/pwm_diode.jpeg)

(https://www.trechph.ovh/images/mustang/IMG_0455.jpeg)

_______________________________________________

Bon développement µcontroleur LOL

J'ai commandé un touch screen TFT capacitif 320X240 Adafruit 2.8"( matos conçu pour l'Arduino , c'est plug and play , ça aide )  pour me faire boutons et menus tactiles https://www.mouser.fr/datasheet/2/737/adafruit_2_8_tft_touch_shield_v2-1396541.pdf (https://www.mouser.fr/datasheet/2/737/adafruit_2_8_tft_touch_shield_v2-1396541.pdf) , seulement il me bouffe presque toutes les E/S du Uno , il ne me reste plus assez d'E/S analogiques ou digitales pour gérer mon bazard  sbhy LOL
De plus j'ai réussi à saturer la flash avec un tableau tournant 500X500 hier lol
Je change donc de carte je passe du L4 au V8 ;D , j'ai commandé un Arduino Mega, compatibilité complète des prog , l'écran se broche direct dessus et il me reste plusieurs 10zaines d'E/S libres et mémoire doublée , voila , c'est pas ruineux 35€ la carte ...
Ca avance mine de rien  bien1

Voila le tft sur le Uno , comme on peut le voir ...problème LOL

(https://www.trechph.ovh/images/mustang/tft_sur_uno.png)


Le voici sur le Mega , rien à voir , je garde plein de développement et d'E/S bien1

(https://www.trechph.ovh/images/mustang/tft_sur_mega.png)

_______________________________________________


Voila la simulation de régulation PI ou PID est prète

Ci dessous le moteur résistance de 1Ω 100 W , ça chauffe bien, ventilo de PC pour qu'elle se stabilise plus vite en refroidissement, un thermocouple et un relay MOSFET avec optocoupleur largement dimensionné 30V 160A !!! qui alimentera la résistance en PWM dont la variation est commandé par l'Arduino en fonction de la tempé de la résistance ;D

Le but stabiliser la tempé de la résistance à la consigne demandée 85 °C par variation du duty cycle du PWM de 122 Hz

2ème tof une alim stabilisée largement dimenssionnée ( aliexpress pas chère du tout, c'est fout ça coutait une blinde ces trucs avant, elle régule en courant constant aussi ) qui fournira le courant pour la résistance via le MOSFET et donc les variations de tempé à réguler

Ouf y a plus qu'à écrire les programmes , trouver le Kp , le Ki peut être le Kd , mais ça simule un moteur sur un bureau ( en gros ) l'alim faisant varier la puissance demandée au moteur , le PWM doit s'adapter tout seul pour que la résistance reste à 85°C

(https://www.trechph.ovh/images/mustang/IMG_0465.jpeg)

(https://www.trechph.ovh/images/mustang/IMG_0466.jpeg)

J'ai reçu et dompté le méga2560 , à peu près je recherche les adresses des Timers , y en a 5 ... en 8 et 16 bits , c'est un peu hard pour trouver la doc pour les modifs à bas niveau des timers, j'ai réussi pour le Timer 5 qui laisse les broches 44 à 46 compatibles PWM  libres avec l'écran en place. J'ai réussi à les passer à 122Hz pour le Spal bien1
Bon les prog du Uno tournent moyennant la rectification des E/S
J'ai réussi à le faire tourner à 122 Hz sur les 3 sorties dépendantes du timer 5, 44 - 46 ( y en a 100 des E/S ...) , mon prog PWM fonctionne sans pb, j'attend avec impatience l'écran tactile pour avancer , faire des lectures et des menus de commandes  :D

_______________________________________________


J'ai reçu le touch sreen capacitif TFT 320 X 240 , pas simple j'ai passé tout l'AM pour m'en sortir et finir par comprendre que les images , c'est du .bmp couleurs 16 bit c'est 65 536 couleurs.
Plus touts les pb de code "de base" pour faire tourner ce bazard, il y a une microSD card qui stocke les photos et donc les fonds d'écrans , jauges , boutons etc ... Qu'on s'est soit même dessiné, et oui , j'ai du reprendre une mise à jour pour mon vieux Graphic Converter LOL
Mais grand pas de fait !  :v:  suis bien content !
Du coup pas touché à la voiture hier !

Le pb ET le défaut de l'open source , c'est que il y a TOUT sur TOUT mais c'est réparti PARTOUT , on passe qques heures à la pèche au code !!!

(https://www.trechph.ovh/images/mustang/IMG_0472.jpeg)

_______________________________________________


Bon ajd j'ai bossé ( boulot je veux dire ... ) mais ce soir j'ai gérer le touch , jusqu'à présent j'avais exploré l'affichage, mais les 2 vont être liés.
J'ai compris qu'il rafraichissait à 80 Hz , d'où les points, j'ai passé le doigt trop vite ;D , bon pas fait pour la vidéo LOL mais pour cliquer des touches ou régler des bargraph nickel
Très agréable l'écran capacitif, comme un smartphone , mais surement très fragile aussi le verre, va falloir trouver un boitier adapté ...

J'ai corrigé les couleurs 16 bit bmp c'est 65 536 couleurs, ça va ;D

(https://www.trechph.ovh/images/mustang/IMG_0477.jpeg)


J'ai super progressé sur le touchscreen , je déssine les formes souhaitées , je mets des photos , et surtout je gère le touch en récupérant les coordonnées getPoint() pour les utiliser en variables , c'est la passerelle pour piloter ce que je veux en matos
il me reste l'écriture , pas trop compliqué , l'affichage m'a demandé bcp de temps pour comprendre , les lecteur SD aussi, purée la ligne code pour limiter l'ESP32 à 25 MHz , j'ai passé des h dessus , je ne savais pas que c'était l'origine de mon blocage lecture de SD card , je l'ai sortie des limbes de l'internet celle là , ça a débloqué la SD card , aucun risque pour que je l'oublie dans le code final LOL , le touch facile 3h cet AM
2 clips , traçage de ligne et récup des coordonnées , exportées sur le serial monitor en bas pour être visibles
C'est bête , mais c'est comme ça qu'on commande des pompes des tempé , des PWM etc ...

Va falloir que je pioche des beaux fonds de jauges sur internet

L'action

https://youtu.be/iypqxOzqUWU


Et le résultat

https://youtu.be/C8AzI1SZETc


bon, le but approche , la question est j'affiche quoi ??? je peux avoir plusieurs pages no pb et afficher 100 paramètres ce n'est pas le pb , il faut que ce soit ergonomique et informatif pour les données essentielles, après il y a la touche graphique pour faire beau mais , ça c'est pas dur , y a des milliers de jauges sur internet.

Voila , bravo à ceux qui sont arrivé au bout , désormais ça se passe ici le développement de l'Arduino

Bon, très interessant sujet mais il te manque le déverrouillage des portes avec une RFID et le démarrage de la Stang avec une reco biométrique 😀😀😀
👍👍👍
Vib

Tu rigoles , ça existe , capteur d'empreinte pour Arduino , ça coute rien et il y a pas mal Library de programmes pour les utiliser LOL

De même le détecteur de présence à ondes courtes, le RFID , GPS, GSM etc ... C'est pas le choix qui manque

Salut

J'ai commencé la régule PID cet AM , alors hyper facile , y a un mec qui s'appelle Brett Beauregard qui a fait une Library et des commandes ( https://github.com/br3ttb/Arduino-PID-Library (https://github.com/br3ttb/Arduino-PID-Library) ) , en 20 lignes de code c'est réglé  msk Y en a même une autre autotune PID qui calcule Kp Ki et Kd mais à priori je n'en aurais pas besoin.
Merci à lui.
J'ai aussi testé donc le PID et forcément un module MOSFET sur ma résistance 1 Ω 100 W , ça marche bien , il peut la réguler en PWM à 122 Hz sur le duty cycle le tempé de ma résistance qui est mesurée par un thermocouple K et transmise à l'Arduino. Suis monté à 12V 60 W sans pb sauf radiateur à monter sur le MOSFET. Le MOSFET n'est là que pour l'expérimentation, l'Arduino pourra piloter directement l'entrée PWM du Spal qui ne demande que qques mA, pratique .
En fait je me suis cassé les pieds à avoir une freq d'une horloge à 122 Hz en changeant les registres diviseurs , alors qu'il suffisait de travailler avec la commande millis() ( milisecondes ) pour fixer le cycle ... Je vais peut être faire cela.
Les briques du prog total se précisent.
Donc là j'ai toutes les options documentées , reste plus qu'à écrire le code initial et tester , ce sera en virtuel les premiers tests , c'est prévu cet hiver la version opérationnelle.
Va y avoir un gros débuggage je pense LOL
A suivre

Bon 2 jours de pluie et ma voiture étant terminée ( mais pas lavée ... )  = 2 jours de théorie Arduino ,  C++ , Python , j'ai la tête comme une citrouille  sroll
Opérateurs, variables, déclarations, fonctions , types de données, condition d'état, boucles etc .... j'ai au moins 40 pages de notes structurées.
Mais ce n'est pas en vain , très interessant et de toutes façons pour parler à un Arduino , il faut apprendre son langage , être poli et ne pas faire de faute ni de syntaxe , ni d'orthographe LOL
Toujours aussi top ce truc et quand un essai ou une amélioration fonctionne trop bien bien1

Hier j'ai réussi à controler une charge inductive via opto coupleur et MOSFET en duty cycle en fonction de la tempé mais pas en PID encore , charge courbe jaune , Arduino courbe bleue, pas mécontent :D

(https://www.trechph.ovh/images/mustang/IMG_0495.jpeg)

Salut

Y a pas c'est vraiment le controle de l'écran qui demande le plus de boulot . Surtout l'affichage, le touch est assez simple à gérer. Par contre les couleurs , l'orientation etc ... pas simple mais en contre partie Powerfull bien1
J'ai bossé sur les pixels ajd, je sais bien qu'il y a des fonctions pour tracer des lignes, des cercles des rectangles, des boutons , pas grave, je voulais enchainer quadrillage sur 5 pixels et diagonales pareil , écran noir avant la dernière diagonale car les pixels sont déja en jaune  et ce uniquement avec la fonction drawPixel.
Ca oblige à programmer, j'ai du utiliser les boucles while et for pour y arriver plus les opérateurs boléens.
Succès mais j'y ai passé l'AM , je connais le code maintenant  :D
En fait après pleins de complications et de plantages, la solution est simple, toujours pareil le codage , simple et élégant , 20 lignes et c'est bon.
Je finis toujours mes prog par un écran noir pour ne pas marquer le TFT.
Demain , lignes, cercles , boutons , écriture etc ... ça avance

https://youtu.be/0GkOnQveu_U

Salut

L'écran 2.8" est vraiment trop petit pour afficher suffisamment d'infos lisibles dans le secteur du cendrier ... j'ai bien progressé dans son maniement bien1

Je passe au 7" 800 X 480 toujours en touch screen ( taille livre de poche pour situer ) et son controleur , ça coute que dale ... toujours un cendrier chinois modifié en support, c'est parfait , pas de trous rien et démontable en 5 sec , par contre encore du code à apprendre , mais largement similaire entre les écrans , pas trop de pb.

Du coup l'Arduino lui même sera séparé de l'écran, seul le controleur sera pluggé dessus.

(https://www.trechph.ovh/images/mustang/tft800X480.png)

(https://www.trechph.ovh/images/mustang/ra8875.png)

Salut , la journée dessus , nouevel écran 7" tft 800X480 et interface depuis ce matin  :v:

(https://www.trechph.ovh/images/mustang/IMG_0501.jpeg)

Un peu ( beaucoup ) difficile pour la calibration du touch , j'ai utilisé un logiciel spécifique ( 350 lignes ... ) puis récupéré la matrice puis j'ai pu faire une formule simple pour tous mes sketchs  cool
Par contre , une fois les pb de pin résolus , dessins, boutons tout ça , ça roule super
Les points blancs c'est mon doigt qui a touché , et ils sont au bon endroit ,cool pour les boutons
Ce WE j'essayerais la carte SD avec + des pullup mais pas bcp d'espoir faudra un tri state buffer par ex : J'apprends le code en même temps et à corriger les conneries des ex pour les adapter à ma bête . Y a un truc ou je seche , je voudrais mettre la calib de mon écran en EEPROM, Je peux lire écrire mais je suis à la ramasse là ... pas bien grave j'ai 10 lignes pour recalibrer avant chaque sketch, m'enfin bon ... Il est sympa, ça c'est la voie à suivre pour les multichip select  https://www.pjrc.com/better-spi-bus-design-in-3-steps/ (https://www.pjrc.com/better-spi-bus-design-in-3-steps/)
Mais si je n'y arrive pas il me reste la solution de 74HC125 tri-state buffer chip, controlled by the 2 chip selects.
Ca ca marche.
Voila une journée de boulot écran calibré et fonctionnel 🤣 c'est plus que ce que j'es espèrais

pas bien grave j'ai 10 lignes pour recalibrer avant chaque sketche, m'enfin bon ... en EEPROM c'est plus cool
J'ai la tête comme une citrouille, mais le l'ai pris en main clairement, il est sympa
@+ suis naze  sroll

J'ai beaucoup progressé sur l'arduino , j'en suis à éditer les fichier .h et .cpp pour arriver a ce que je veux avec du matos pas toujours conforme ...

J'en suis aux boutons : c'est réglé via new .h et .cpp , Library RA8875.h du controleur de mon écran pourrie mais c'est la seule qui gère les 800x480 , incapable de m'afficher les label des boutons ... Et pas de choix de polices ...
J'ai fini par trouver , via édition du fichier .h et .cpp pour faire appel a des polices externes et les centrer sur mes boutons msk ( c'est pour Geloche ça ...)

Photo useless juste que ça marche, 20 lignes de code pour ça :D juste 2 for(){}; Je ferais des boutons finaux conformes à mes souhaits.

En plus malgré mes modif du .h et .cpp, le textMode() de l'écran fonctionne toujours avec leur unique police ( pas la même que les boutons ) , cf le "Hello,World! " !!! trop cool LOL

(https://www.trechph.ovh/images/arduino/IMG_0513_1.jpeg)

Salut , reprise du développement , ça avance , controle d'un Spal brushless 12" par l'Arduino Uno , en fait je dissocie , l'Uno s'occupe du refroidissement , pas besoin d'écran, je branche l'ordi en USB si modif et après il s'autogère.
Je garde le Mega pour un écran multiparamètres.
C'est super pratique , je mets les Spal en route à 50% si clim moteur froid, dès que le moteur est à 85°C c'est la régulation normale qui prend le relai. Pour la pompe Stewart , je vais me la faire de MOSFET aussi ,  un branchement sur le fil rpm moteur et conditions de mise en route rpm < 900 / mn et tempé > 100°C et basta :D
Tout ça pour moins de 50 € ( sans les Spal LOL )

Question @geloche si tu as un avis , je fais une relation linéaire rpm Spal 20% - 100% pour fenetre de tempé 80 - 100°C ??? Ou j'essaye un PI(D) , ça complique un peu le prog, pour le moment je ne maitrise pas , j'ai la Library qui va bien , le problème c'est de me faire un modèle expérimental pour essais plus sophistiqué que le Spal branché à l'arrache et je me demande si la solution simple , une fois qques adaptations faites n'irait pas très bien ?
Merci

L'arduino uno et le thermocouple, je fais un rafraichissement toutes les 2 secondes .... Je pourrais faire 10 - 30 sec sans pb , j'ai pu baisser la fréquence du pin 3 à 122 Hz compatible avec le PWM du Spal .

(https://www.trechph.ovh/images/arduino/IMG_0585.jpeg)

Exemple de Duty cycle à 21,59 % , oui c'est un duty cycle négatif , car le MOSFET et l'optocoupleur me l'inversent et j'ai un DT positif en 12 V à la sortie MOSFET.

(https://www.trechph.ovh/images/arduino/IMG_0582.jpeg)

Le relais MOSFET avec optocoupleur isole l'Arduino du Spal et du 12 V , alim pour le Spal derrière, vous constatez que sans précharge il consomme peu à 21 %

(https://www.trechph.ovh/images/arduino/IMG_0583.jpeg)


Une petite vidéo en chauffant le thermocouple , les coupures du Spal et de l'oscillo c'est moi qui touche le thermocouple avec le pistolet de soudure pb de terre, pas assez de main ni d'yeux LOL

https://youtu.be/429b75cZ0PA

Ah j'ai compris tu veux mettre ca sous la Mustang  "Là où on va, on n'a pas besoin de route !"  smk  smk 

Ouais , comme dans Avatar mais planqués dessous les hélices LOL

Voila j'ai trouvé un modèle expérimental pour le PID, le Spal refroidit le thermocouple chauffé par par le pistolet air chaud

Purée "yapuka" programmer ;D et intégrer la clim et le régime moteur , heureusement j'ai tout ce qu'il faut pour simuler ça :D

Je peux aussi faire un cas particulier , rpm >= 4000 ou 4500 durant X secondes ventilos direct 100%

J ai mis rafraichissement tt les 30 sec ça lisse bcp mieux


https://youtu.be/A-t-4mhlGD8

Voila régule Spal PID à 88°C ( expérimental ), c'est vraiment hypersimple avec la Library dédiée , juste les coef K à affiner mais à +/- 0.5°C c'est bon, là y a Kp = 2 , Ki = 5, Kd =1.

https://youtu.be/WWX-69aoYMA

Salut le prog complet est quasi terminé avec un petit affichage plus simple pour les réglages. PID sur 88°C , controle PWM des 2 Spal, controle de la clim moteur froid, et de la pompe électrique au ralenti moteur au dessus de 100°C

C'est pas la mort 130 lignes de prog avec plein de commentaires, le "bug" des 2 C pour la tempé , c'est que le C de plus de 100°C persiste quand ça repasse à 2 chiffres ... ah ah ...réglé y en a plus qu'un.
Je vais mettre ça sur un nano ( même code et mêmes sorties ) monté sur un shield avec bornier à vis , puis tout dans une boite et voila.


https://youtu.be/AlMiRoGvgGk

Salut , après plusieurs jours de debuggage GPS intégré

En fait explication finale flooding du hardware serial port par trop de données , il marchait sur le Mega ou j'ai 4 hardware serial ports , mais un seul sur le uno et pareil sur le nano ( celui du boitier final ) , j'ai mis longtemps à trouver , comme j'utiliserais le nano dans le version définitive , je suis passé en software serial ports. Heureusement , pleins de possibilités.
Ca va enfin , le nano est plein à 75% mais je vais élaguer , j'ai plein de scripts de debuggage.
Vous saurez même où j'habite les plus adroits LOL

Je vais pouvoir intégrer la variable "speed" pour controler ventilo and co c'est cool et hyper utile :D Le reste du GPS peut aussi dévier sur alarme etc ...

17:23:23.231 -> Time: 15:23:23.000
17:23:23.264 -> Date: 25/9/2023
17:23:23.264 -> Fix: 1 quality: 2
17:23:23.264 -> Temperature = 25.25°C
17:23:23.296 -> Location: 4859.5107N, 208.4787E
17:23:23.296 -> Speed km/h : 0
17:23:23.296 -> Angle: 186.10
17:23:23.296 -> Altitude: 97.50
17:23:23.296 -> Satellites: 6
17:23:23.296 -> Antenna status: 2
17:23:23.296 -> $GPRMC,152323.000,A,4859.5106,N,00208.4787,E,0.03,186.10,250923$PCD,11,2*65
17:23:24.153 -> $GPGGA,152324.000,4859.5106,N,00208.4787,E,2,06,1.51,97.5,M,47.2,M,,*51
17:23:24.252 -> $GPRMC,152324.000,A,4859.5106,N,00208.4787,E,0.01,186.10,250923,,,D*6C
17:23:25.143 -> $PCD,11,2*65
17:23:25.143 -> $GPGGA,152325.000,4859.5106,N,00208.4787,E,2,06,1.51,97.5,M,47.2,M,,*50

(https://www.trechph.ovh/images/mustang/IMG_0590.jpeg)

Je suis jaloux :)
Super boulot !
Oui les possibilités de ces jouets sont infinies, on n'arrive pas à s'arrêter.
Faut vraiment que je m'y mette un jour.

Citation de: geloche le 25 Septembre 2023 à 20:41:42Je suis jaloux :)
Super boulot !
Oui les possibilités de ces jouets sont infinies, on n'arrive pas à s'arrêter.
Faut vraiment que je m'y mette un jour.

Citation de: filou96 le 25 Septembre 2023 à 20:16:48Salut , après plusieurs jours de debuggage GPS intégré
j'ai plein de scripts de debuggage.
Vous saurez même où j'habite les plus adroits

C'est sur si tu nous file ta position GPS😀😀
En tout les cas chapeau bas !
Vib

Voila le schéma de principe , peut être avec encore qques conneries ... Sur ma breadboard ça marche bien1

Un piège , il faut savoir que une pin non connectée , n'est pas LOW en fait , il faut intégrer ce détail, elle est "flottante" pour ça qu'il faut parfois des ponts ou des résistances tout court pour avoir une masse si le 5 ou 12 v est coupé, on aura alors la condition LOW stable et donc les commandes qui en découlent effectuées.
J'ai intégré un refroidissement automatique du bloc moteur après coupure du contact si le LDR qui circule est > 80°C ( valeur au pif à voir à l'usage ) grace à la pompe à eau électrique et les ventilos, ça évite de se retrouver avec une montée de 85°C à 110°C dans le bloc à l'arrèt quand on a bien roulé.

Entouré en jaune dans la boite à gant
Entouré en bleu relais automobiles normaux
Entouré en rouge : éléments extérieurs

Tout le reste c'est dans une boite pas très grande 10 X 8 X 7 cm avec couvercle transparent pour l'écran. Cliquez sur l'image pour agrandir.

(https://www.trechph.ovh/images/arduino/ECU_sch%C3%A9ma1.jpg)

Vla le code brut pour les connaisseurs , évolutif bien sur et adaptable, attentio il y a plein de commentaires et de sections de debuggage pour le Serial monitor.
Elles sont moins visibles et ne sont pas compliées : prédédées de soit // pour la ligne ou alors /* paragraphe et */ à la fin, tout ça blabla ou debuggabe ;)
A la fin y a 1/3 du code qui vire, là juste pour le développement .

/* programme final pour le controle des ventilos , pompe stewart et divers paramètres
selon tempé , vitesse, RPM etc , je limite le debuggage la *************************/

#include <Adafruit_GPS.h>
#include <SoftwareSerial.h> // pas assez de tx/rx sauf sur le Mega
#include "max6675.h"  // chargement de la library thermocouple et PID
#include <PID_v1.h>   // pour le PID
#include <LiquidCrystal_I2C.h>    //Library écran i2c, consommation ++++++++++++écran 45 mA++++++++++++


SoftwareSerial mySerial(12, 2);   //création de l'instance GPS l'ordre c'est mySerial(Rx, Tx) Rx GPS est connecté à Tx Serial et Tx GPS est connecté à Rx serial
Adafruit_GPS GPS(&mySerial);

// Set GPSECHO to 'false' to turn off echoing the GPS data to the Serial console
// Set to 'true' if you want to debug and listen to the raw GPS sentences
//in the car it will be on "false"
#define GPSECHO false

LiquidCrystal_I2C lcd(0x27,20,4);     //déclaration écran i2c 20 caractères, 4 lignes
                                      //SDA = A4 = D18 , SCL = A5 = D19

double Setpoint, temperature, PWMval, PWMval1;     //déclaration variables PID, double = X.00

double Kp = 2, Ki = 5, Kd = 1;      //j'ai pris les K de base de l'exemple
PID myPID(&temperature, &PWMval, &Setpoint, Kp, Ki, Kd, DIRECT);    //déclaration du PID

const uint8_t soPin = 4;                         // thermocouple serial out
const uint8_t csPin = 5;                         // chip select
const uint8_t sckPin = 6;                        // serial clock pin
MAX6675 Module(sckPin, csPin, soPin);  // create instance object of MAX6675 thermocouple

unsigned long pHigh, pLow;       //variables diverses , plus pratique et code plus lisible
uint16_t RPM;
bool clim, pompe, contact;
const uint8_t pinClim = 10;     //entrée via entrée via pont de résistances 100 k et 47 kΩ  mise en route clim
const uint8_t pinContact = 9;   // + 12 V contact entrée via pont de résistances 100 k et 47 kΩ
const uint8_t pinPWM = 3;       // pin de qortie de commande des Spal en PWM via MOSFET et optocoupleur
const uint8_t pinRPM = 8;       //entrée via entrée via pont de résistances 100 k et 47 kΩ  capture RPM
const uint8_t pinPompe = 7;     //sortie mise en route de la pompe par relais
const uint8_t pinBat = 14;      // ou A0 maintien de 12V après arret en différé
const uint8_t pin3V = 15;
const uint8_t pin7V = 16;
const uint8_t pin12V = 17;
double tens3V, tens7V, tens12V ;
uint8_t speed;  //normes GPS en knots
uint8_t dutyCycle;
uint8_t count;


// make a cute degree symbol en décimal matrice 5X8 et e accent = é correct
// faire en binaire matrice 5X8 facile , le [8] signifie tableau de 8 octets
  byte degree[8] = {
    B01100,
    B10010,
    B10010,
    B01100,
    B00000,
    B00000,
    B00000,
    B00000,
    };

    byte eaccent[8] = {
      B00010,
      B00100,
      B01110,
      B10001,
      B11111,
      B10000,
      B01110,
      B00000,
    };



void setup()
{
 

lcd.init();
lcd.backlight();
  lcd.createChar(1, degree);
  lcd.createChar(2, eaccent);

  pinMode(pinRPM, INPUT);      //entrée signal RPM

  pinMode(pinPompe, OUTPUT);     //sortie signal mise en route pompe stewart
  digitalWrite(pinPompe, LOW);   //mise à l'arret de base de la pompe

  pinMode(pinClim, INPUT);     //détection clim ou pas
  digitalWrite(pinClim, LOW);   //au cas où mais pont de résistances
  clim = false;

  pinMode(pinContact, INPUT);
  digitalWrite(pinContact, LOW);    //au cas où mais pont de résistances

  pinMode(pinBat, OUTPUT);
  digitalWrite(pinBat, HIGH);   //si il a démaré c'est que le contact est mis , donc j'actionne le relai

  pinMode(pin3V, INPUT);
  pinMode(pin7V, INPUT);
  pinMode(pin12V, INPUT);

  Setpoint = 88;          //déclaration température cible en °C sur la voiture 90°C
  myPID.SetOutputLimits(120, 220);    //déclaration des limites du PWM Spal sur la voiture 255 = arret du Spal , min speed 25% pour DT 10% = 229 max speed pour DT 90% = 25 donc je mets (0, 255)
  myPID.SetMode(AUTOMATIC);

   /*********************ATTENTION PIN 11 AUSSI A 122 Hz donc ne pas utiliser***************************/

  pinMode(pinPWM, OUTPUT);   // passage du pin3 ( et 11 ) à 122 Hz pour commande PWM des Spal en DT
  TCCR2B &= 0b11111000;     
  TCCR2B |= 0b00000110;

  count = 0;

  //comment all Serial on the car, uncomment for debug

  // connect at 115200 so we can read the GPS fast enough and echo without dropping chars
  // also spit it out
  Serial.begin(115200);
  delay(5000);
  //Serial.println("Adafruit GPS library basic parsing test!");

  // 9600 NMEA is the default baud rate for Adafruit MTK GPS's- some use 4800
  //I think keep these lines
  GPS.begin(9600);
  // uncomment this line to turn on RMC (recommended minimum) and GGA (fix data) including altitude
  GPS.sendCommand(PMTK_SET_NMEA_OUTPUT_RMCGGA);
  // uncomment this line to turn on only the "minimum recommended" data
  //GPS.sendCommand(PMTK_SET_NMEA_OUTPUT_RMCONLY);
  // For parsing data, we don't suggest using anything but either RMC only or RMC+GGA since
  // the parser doesn't care about other sentences at this time
  // Set the update rate
  GPS.sendCommand(PMTK_SET_NMEA_UPDATE_1HZ); // 1 Hz update rate
  // For the parsing code to work nicely and have time to sort thru the data, and
  // print it out we don't suggest using anything higher than 1 Hz

  // Request updates on antenna status, comment out to keep quiet comment on car
  GPS.sendCommand(PGCMD_ANTENNA);

  delay(1000);

  // Ask for firmware version, comment on car
  //mySerial.println(PMTK_Q_RELEASE);




}

  uint32_t timer = millis();
  uint32_t timer1 = millis();
 



void loop() // uncomment for GPS data serial read for debug
{
  // read data from the GPS in the 'main loop'
  char c = GPS.read();
  // if you want to debug, this is a good time to do it! on the car comment this
  //if ((c) && (GPSECHO))
    //Serial.write(c);

  // if a sentence is received, we can check the checksum, parse it...
  if (GPS.newNMEAreceived()) {
    // a tricky thing here is if we print the NMEA sentence, or data
    // we end up not listening and catching other sentences!
    // so be very wary if using OUTPUT_ALLDATA and trying to print out data
    //Serial.print(GPS.lastNMEA()); // this also sets the newNMEAreceived() flag to false
    if (!GPS.parse(GPS.lastNMEA())) // this also sets the newNMEAreceived() flag to false
      return; // we can fail to parse a sentence in which case we should just wait for another
  }

  // approximately every 2 seconds or so, print out the current stats, on the car comment all
  /*if (millis() - timer > 2000) {
    timer = millis(); // reset the timer

    Serial.print("\nTime: ");
    if (GPS.hour < 10) { Serial.print('0'); }
    Serial.print(GPS.hour, DEC); Serial.print(':');
    if (GPS.minute < 10) { Serial.print('0'); }
    Serial.print(GPS.minute, DEC); Serial.print(':');
    if (GPS.seconds < 10) { Serial.print('0'); }
    Serial.print(GPS.seconds, DEC); Serial.print('.');
    if (GPS.milliseconds < 10) {
      Serial.print("00");
    } else if (GPS.milliseconds > 9 && GPS.milliseconds < 100) {
      Serial.print("0");
    }
    Serial.println(GPS.milliseconds);
    Serial.print("Date: ");
    Serial.print(GPS.day, DEC); Serial.print('/');
    Serial.print(GPS.month, DEC); Serial.print("/20");
    Serial.println(GPS.year, DEC);
    Serial.print("Fix: "); Serial.print((int)GPS.fix);
    Serial.print(" quality: "); Serial.println((int)GPS.fixquality);
    Serial.print("Temperature = "); Serial.print(temperature); Serial.println("°C");
    if (GPS.fix) {
      Serial.print("Location: ");
      Serial.print(GPS.latitude, 4); Serial.print(GPS.lat);
      Serial.print(", ");
      Serial.print(GPS.longitude, 4); Serial.println(GPS.lon);
      Serial.print("Speed km/h : "); Serial.println(speed);
      Serial.print("Angle: "); Serial.println(GPS.angle);
      Serial.print("Altitude: "); Serial.println(GPS.altitude);
      Serial.print("Satellites: "); Serial.println((int)GPS.satellites);
      Serial.print("Antenna status: "); Serial.println((int)GPS.antenna);    //modifié : 2 antenne ext, 1 antenne interne , 0 dysfonctionnement
    }
  }*/

  if (millis() - timer1 > 5000) {           //obligé de faire le reste des controles toutes les 5 sec
                                            //sinon le GPS a pas le temps de se mettre à jour et de transmettre
  timer1 = millis();

  contact = digitalRead(pinContact);
 
  pompe = digitalRead(pinPompe);

  temperature = ((Module.readCelsius()) - 4);  //lecture tempé, sonde 4° trop haut, i can change timer on the car, no serial pb

  dutyCycle = round(((255-PWMval1)/255)*100);

  if (contact == true ) {

  digitalWrite(pinBat, HIGH);
     
  speed = round(GPS.speed*1.852);     //passage knots en km/h

  clim = digitalRead(pinClim);       //le + 12 V clim rentrera ici via pont de résistances 100k - 47kΩ pour l'amener à 5V et qques mA


if (GPS.fix == 1) {     /****************obligé de séparer GPS.fix ou pas pour speed et tunnels ou autres pb de GPS*****************/

/**********************PID et PWM , l'analog ne doit pas être connecté**************************************/
/********POUR OVERRIDE si panne il faut mettre le PWM à la masse et l'analogue au plus ********************/

    if ((( speed >= 60 ) || ( speed < 60 && temperature < 50 )) && (clim == false)) { PWMval1 = 255; analogWrite(pinPWM, PWMval1); }


    if ( speed < 60 && temperature >= 50 ) {                       //je commence à 50°C qu'il ai le temps
        myPID.Compute();                    //le PID fait son taf mais pas forcément répercuté sur le ventilo
          if ( PWMval>=200 && clim == true ) { PWMval1 = 200; analogWrite(pinPWM, PWMval1);}           //et il calcule le PWMval soit le PWM qui ne sera appliqué que si il est inf à 200 si clim ON
            else { analogWrite(pinPWM, PWMval); PWMval1 = PWMval; }
   
    }
     
     
 
/************************CLIMATISATION ou NON****************************/

  if ( speed < 60 && clim == true && temperature<50 ) { PWMval1 = 200; analogWrite(pinPWM, PWMval1); }      // mise du Spal à 50% soit 127 dans la voiture si speed < 50 km/h
 
      else { analogWrite(pinPWM, PWMval); PWMval1 = PWMval; }      // mise du Spal à la vitesse du PWM

}

else {        /****************si GPS.fix == 0 j'utilise les RPM *****************/

  if ((( RPM >= 1500 ) || ( RPM < 1500 && temperature < 50 )) && (clim == false)) { PWMval1 = 255; analogWrite(pinPWM, PWMval1); }


    if ( RPM < 1500 && temperature >= 50 ) {                       //je commence à 50°C qu'il ai le temps
        myPID.Compute();                    //le PID fait son taf mais pas forcément répercuté sur le ventilo
          if ( PWMval>=200 && clim == true ) { PWMval1 = 200; analogWrite(pinPWM, PWMval1);}           //et il calcule le PWMval soit le PWM qui ne sera appliqué que si il est inf à 200 si clim ON
            else { analogWrite(pinPWM, PWMval); PWMval1 = PWMval; }
   
    }
     
     
 
/************************CLIMATISATION ou NON****************************/

  if ( RPM < 1500 && clim == true && temperature<50 ) { PWMval1 = 200; analogWrite(pinPWM, PWMval1); }      // mise du Spal à 50% soit 127 dans la voiture si speed < 50 km/h
 
      else { analogWrite(pinPWM, PWMval); PWMval1 = PWMval; }      // mise du Spal à la vitesse du PWM


}

/************************POMPE STEWART*********************************/

  pHigh = pulseIn(pinRPM, HIGH);   //temps en µs du signal haut du RPM
  pLow = pulseIn(pinRPM, LOW);      //temps en µs du signal bas du RPM
  RPM = ((1000000/(pHigh+pLow))*2);   //calcul RPM
 
  if ( (temperature > 90) && ((speed < 10 && GPS.fix == 1)  || (RPM < 1000)  ))  { digitalWrite(pinPompe, HIGH); } else { digitalWrite(pinPompe, LOW); }    //conditions de mise en route de la pompe Stewart par le pin 7 moins de 1000 rpm et temp >= 100°C
 

 
 }          //fin du if (contact == true)

  /*******************calcul des voltages***************************************/

  tens3V = ((analogRead (pin3V)) * 0.0046);   //normalement 0.0049 v par unité de 0 à 1053 , en fait pas vraiment car on a plutot 4.67V
  tens7V = ((analogRead (pin7V)) * 0.0098);
  tens12V = ((analogRead (pin12V)) * 0.0153);

     /******************    écriture de l'écran  , une page par passage / 5 sec   ******************************/

  if (count <= 3) {
   

 if (count == 2) {
 
  lcd.clear();
  lcd.setCursor(0,0);
  lcd.print("Temp"); lcd.write(2); lcd.print("rature = ");
  lcd.print(round(temperature)); lcd.write(1); lcd.print("C ");
  lcd.setCursor(0,1);
  lcd.print("Duty cycle = "); lcd.print(dutyCycle); lcd.print(" %  ");
  lcd.setCursor(0,2);
  lcd.print("KM/H : "); lcd.print(speed);  lcd.print(" RPM "); lcd.print(RPM); lcd.print("   ");
  lcd.setCursor(0,3);
  lcd.print("Clim : "); lcd.print(clim); lcd.print(" Pompe : "); lcd.print(pompe);
 }

 if (count == 3) {

  lcd.clear();
  lcd.setCursor(0,0);
  lcd.print("Reg 3V = "); lcd.print(tens3V); lcd.print("V");
  lcd.setCursor(0,1);
  lcd.print("Reg 7V = "); lcd.print(tens7V); lcd.print("V");
  lcd.setCursor(0,2);
  lcd.print("Volts Batt = "); lcd.print(tens12V);  lcd.print("V");
  lcd.setCursor(0,3);
  lcd.print("Fix "); lcd.print(GPS.fix); lcd.print(" Sat "); lcd.print(GPS.satellites); lcd.print(" Ant "); lcd.print(GPS.antenna);
}

if (count == 1) {

    lcd.clear();
    lcd.setCursor(0,0);
    lcd.print("Date: ");
    lcd.print(GPS.day); lcd.print('/');
    lcd.print(GPS.month); lcd.print("/20");
    lcd.print(GPS.year);
    lcd.setCursor(0,2);
    lcd.print("Time GMT  : ");
    if (GPS.hour < 10) { lcd.print('0'); }
    lcd.print(GPS.hour); lcd.print(':');
    if (GPS.minute < 10) { lcd.print('0'); }
    lcd.print(GPS.minute); lcd.print(':');
    if (GPS.seconds < 10) { lcd.print('0'); }
    lcd.print(GPS.seconds);
    lcd.setCursor(0,3);
    lcd.print("Time local: ");
    if ((GPS.hour+2) < 10) { lcd.print('0'); }
    lcd.print(GPS.hour+2); lcd.print(':');
    if (GPS.minute < 10) { lcd.print('0'); }
    lcd.print(GPS.minute); lcd.print(':');
    if (GPS.seconds < 10) { lcd.print('0'); }
    lcd.print(GPS.seconds);
   
   
}


}
else {count = 0;}
count++;
 
  }
 
   
    if ( (contact == false) && (temperature > 20)) {
     
      PWMval1 = 127; analogWrite(pinPWM, PWMval1);      //ventilos mi-régime
      digitalWrite(pinPompe, HIGH);                     //mise en route de la pompe

    }

    if ((contact == false) && (temperature <= 20)) {
      delay(5000);                   //vérif que ventilos OK et pompe OK penda t 5 sec
      digitalWrite(pinBat, LOW);     //coupure totale alim batterie arduino sauf pour le GPS en 3V
     
    }

 
}



J'ai pas lu en détail (je le ferai) mais c'est super simple !!!!
Ca vaut vraiment le coup d'utiliser Arduino.

Merci , j'utilise ces carte là , µPESY pour le montage , super bien bien1 Et entretoises 2 et 3 mm. Là on voit un des 2 régulateurs step down réglables , donc 3V permanent pour garder l'horloge du GPS et 7V pour le Vin Arduino, ça consomme qques µA.

Entre temps dans le code , j'ai intégré la surveillance des tensions 3 , 7 et 12-14 V Batterie , de même que le fix du GPS et le nombre de satellites , sur 2 écrans tournants de l'afficheur;

Pour situer mon Nano est plein à 64 % pour le prog et 78% pour les variables ( j'aurais pu faire à moins mais j'ai préféré tout déclarer ... plus facile , le nom déja , on sait de quoi il s'agit , puis si on change le pin dans les déclaration , c'est une fois pas partout, à l'inverse , ça remplit la mémoire , Y a encore de la place LOL

(https://www.trechph.ovh/images/arduino/IMG_0595.jpeg)

(https://www.trechph.ovh/images/arduino/IMG_0596.jpeg)

Tu sais que pendant très longtemps des systèmes électroniques de très haut niveau étaient soudés sur des cartes de ce genre (mais avec des picots) avec des fils qu'on enroulait sur les picots (avec un pistolet spécial) et qu'on soudait. Et ca tenait une éternité dans des environnements très rudes. Donc ne t'emmerdes pas à faire un pcb, soude une carte propre avec des fils.

Du Wrapping soudé en fait

Oui je me case pas la tête, ces circuits sont bien, les trous double face, donc je fais les liaisons en AWG 24 soudé, et les entrées ext en borniers à vis;
Tout ce qui est module est soudé avec des picots.
Faut juste que je réfléchisse à l'implantation dans ma boite la plus ergonomique ;D

Oui faut quand même placer et router.
Alors un GROS conseil: sur une carte, et surtout qui fonctionne dans un environnement hostile (voiture), le plus important c'est l'alimentation. Cherche des explications sur comment ca doit être fait. En gros: distance physique minimale entre la masse et le vcc, jamais de boucles dans chacun des fils gnd/vcc, fils de bonne section pour les gnd/vcc, capa régulièrement (en distance physique) sur la paire gnd/vcc. On place pour optimiser gnd/vcc au plus court ou en étoile. Le reste tu fais au plus court. Jamais de boucles sur n'importe quel fil signal.

OK Merci .

Tiens , encore un futur bug du code qui me vient à l'esprit : les tunnels, pas pensé avant ou la perte du signal GPS, faut que je vérifie la portée de ma variable "speed", elle va tomber à 0 , faut je relise le code à ce sujet , il y a les RPM pratiques pour la sécuriser et aussi le GPS.fix qui va passer de 1 à 0, mais c'est pas immédiat ??? Je sais pas , test à faire en masquant l'antenne. .

J'ai le même problème avec l'indicateur de vitesse gps tête haute (un super truc): dans les tunnels la vitesse tombe doucement à 0.

Sympa ton devel, arduino ca rox pour ce genre de projet!  bien1

Citation de: filou96 le 02 Octobre 2023 à 08:59:09OK Merci .

Tiens , encore un futur bug du code qui me vient à l'esprit : les tunnels, pas pensé avant ou la perte du signal GPS, faut que je vérifie la portée de ma variable "speed", elle va tomber à 0 , faut je relise le code à ce sujet , il y a les RPM pratiques pour la sécuriser et aussi le GPS.fix qui va passer de 1 à 0, mais c'est pas immédiat ??? Je sais pas , test à faire en masquant l'antenne. .

pour le fun et la beauté du truc, je rajouterai un accéléromètre  (c'est comme ça que les montres GPS évitent les trous de position). Ca existe pour l'arduino, mais faut voir la précision...

Ah ok, oui c'est vrai, pas pensé , Merci, au point où j'en suis je regarde  bien1

Surtout qu'en fait avec l'override , je déconnecte tout et passe en manuel si pb

Ceci dit ma boite est pleine , je pense même mettre les régul 3V et 7V à part ... les 2 bazards sur le coté LOL et virer le thermocouple pour une simple PT1000 à courbe linéaire au moins entre 70 et 110°C , directement sur une entrée ( +/- une R en série selon les mA ) une carte en moins ...

(https://www.trechph.ovh/images/arduino/IMG_0597.jpeg)

(https://www.trechph.ovh/images/arduino/IMG_0598.jpeg)

Citation de: machbill le 02 Octobre 2023 à 20:01:36pour le fun et la beauté du truc, je rajouterai un accéléromètre  (c'est comme ça que les montres GPS évitent les trous de position). Ca existe pour l'arduino, mais faut voir la précision...

Bon , je n'ai plus assez de pin et mémoire sur le nano , faudrait je reprenne le Mega ... Bof , je mets ça en standby, merci, là les RPM sont pratiques pour savoir si je roule
Il y a même des combos qui font accéléromètre, gyroscope, magnétomètre de la taille d'une pièce de 2 € ... Par contre ça bouffe entrées et mémoire +++ Faut le Mega là.

Déja le GPS , j'ai passé des heures dessus, car il ne fixait pas dans mon prog mais fixait sa pb sur les exemples avec la même partie de code ??? , en fait il envoie une multitude de données des différents réseaux + heure date fix sat etc ....  il lui faut le temps , au moins 1 secondes pour être sur d'avoir 1 flux complet sans donnée manquante, il est d'ailleurs sur 1Hz.
Donc si on balance le code + la gestion moteur on a rien niveau GPS, c'est bouffé par le code gestion moteur.

Là maintenant , j'ai trouvé la soluce, je laisse le GPS bosser 5 s, il accumule ses données puis le code moteur + affichage écran 1 fois toutes les 5 secondes s'exécute ( largement suffisant ), comme ça ça marche.
Je pourrais faire moins de 5 s , typiquement 2 secondes, mais c'est plus agréable pour lire les 3 pages de l'écran qui défilent toutes les 5 sec.

Donc je rajoute rien ça marche, mais c'est très addictif , pas dit que le Méga replace le nano un jour et , j'ai bien envie de tester le combo qui fait accéléromètre, gyroscope, magnétomètre de la taille d'une pièce de 2 € sur le Mega ... A suivre LOL

Edit , j'ai pris celle là pour me faire la main avec le Méga : https://learn.adafruit.com/adafruit-lsm9ds1-accelerometer-plus-gyro-plus-magnetometer-9-dof-breakout/ (https://learn.adafruit.com/adafruit-lsm9ds1-accelerometer-plus-gyro-plus-magnetometer-9-dof-breakout/)

en fait, il te faudrait une architecture multiprocesseurs, y'a moyen de se faire très plaisir mais la mise au point peut être laborieuse. En tout cas bravo pour le dév.  ap:lo

Pour l'instant en arduino :
- j'ai remplacé le hardware d'une vieux volant à retour de force, les drivers n'existent plus, l'arduino fait le job sauf pour le retour de force, j'ai encore des bugs.
- j'ai une régulation pour la ventilation de la cave (pour la raffraichir si la t° extérieure est plus basse), j'avais fait ça au départ avec des amplis opérationnels (la vieille école), mais c'était pas stable et puis l'arduino c'est fun.

en projet :
- télécommande centralisé pour les volets, avec en option une petite intelligence pour fermer au soleil (quand il fait chaud et surtout pas l'hiver bien sûr).
- wattmètre pour mesurer des consommations sur le secteur,
- joystick à retour de force (je fais aussi du simu Microsoft et DCS)

Eh bon, avec tout ça la mustang n'avance pas, mais ça me permet de repose les tendinites.

Merci  bien1

Citation de: machbill le 03 Octobre 2023 à 17:13:34en fait, il te faudrait une architecture multiprocesseurs, y'a moyen de se faire très plaisir mais la mise au point peut être laborieuse. En tout cas bravo pour le dév.  ap:lo

Pour l'instant en arduino :
- j'ai remplacé le hardware d'une vieux volant à retour de force, les drivers n'existent plus, l'arduino fait le job sauf pour le retour de force, j'ai encore des bugs.
- j'ai une régulation pour la ventilation de la cave (pour la raffraichir si la t° extérieure est plus basse), j'avais fait ça au départ avec des amplis opérationnels (la vieille école), mais c'était pas stable et puis l'arduino c'est fun.

en projet :
- télécommande centralisé pour les volets, avec en option une petite intelligence pour fermer au soleil (quand il fait chaud et surtout pas l'hiver bien sûr).
- wattmètre pour mesurer des consommations sur le secteur,
- joystick à retour de force (je fais aussi du simu Microsoft et DCS)

Eh bon, avec tout ça la mustang n'avance pas, mais ça me permet de repose les tendinites.

Le pb c'est la doc technique de ton volant ... Pour moi Spal Italie m'a envoyé le pdf ingé des Spal, ce qui fait que j'ai toutes les normes soit en digital soit en analogique pour les gérer , ce sont des brushless 4 fils avec une UC et donc je SAIS quoi demander à l'Arduino. En plus j'ai la conso que de qques mA. Sans ces document faut monter l'oscillo sur un montage fonctionnel et regarder et prendre des notes LOL

Je commande le plus souvent des modules Adafruit car ils développent des Libraries pour tous les environnements et un paquet d'exemples de code , on apprend mieux et plus vite ;D

J'ai du commander pas mal de vis M3 de toutes longueurs + rondelles frein , les vis essentielles je mettrais du frein filet. La boite Arduino sera dans l'habitacle en fait , plus cool pour elle , j'ai aussi commandé du fil blindé pour RPM et PWM etc ... Il manque toujours un truc ...

Sinon la Mustang ça va elle ronronne , les canicules sont passées , j'attends le radia wide core 24" qui est en fabrication et qui avec les 2 Spal brushless sera le complément du dev Arduino.

Y a aussi des choses pratiques à faire comme la gestion de l'eclairage de la cabine avec une tempo, l'allumage des feux la nuit quand on veut ouvrir la voiture et qu'on cherche le trou de la clés, l'éclairage du tdb et des commandes en fonction de la lumière du jour, les alarmes de vitesse par rapport aux limitation (sans le gps), la surveillance des feux grillés (ca a existé sur des voitures chères), même une clim automatique, l'allumage à distance du dégivrage. La liste est sans fin.

Ca me tente pas , j'ai 2 trucs + 1 éventuel : l'Audio , c'est fait 2 X 100 W numérique + caisson de basse invisible avec facade d'époque qui envoie du lourd  :D

Et la gestion moteur , car c'est le coeur de l'engin. Sans rentrer dans l'EFI , c'est perso , nostagie des carbus et ça marche super bien bien1

Si je dois rajouter un truc , c'est la clim auto , ça c'est pratique , elle est manuelle actuellement et se gère bien comme ça , mais bon , j'avoue , tu règles une tempé l'Arduino fait le reste , à ceci près que les bagnoles modernes en auto le compreseur fonctionne H24.

La lunette arrière , j'ai jamais eu de buée et un coup de defrost à fond devant et y a plus rien à l'arrière en 5 mn.

Ici en hiver il fait souvent sec mais ça gèle la nuit et le givre reste jusqu'à midi.
Comme je te l'avais dit tu peux gérer la richesse du carbu et probablement aussi le regime du ralenti (qui change avec la tempé ambiante). Après en allumage il y a des choses à faire mais ca devient plus costaud, c'est du hard real-time, pas mal de choses à apprendre sur la gestion des moulins.
Moi déjà j'aimerais faire descendre la conso vers 10-11L/100. Je vais enrichir et mettre davantage d'avance. Je suis à 13, c'est trop avec une AOD.

Merci
C'est pas tombé dans l'oreille d'un sourd pour le carbu bien1 Je ne connaissais pas du tout, donc Merci merci , j'ai tout noté  , mais j'avoue mon AFR n'a jamais pris l'EDL en défaut , à croire qui est pile poil fait pour ce moteur 331ci 9.7 de RV , 8.3 de dynamic RV , ça tourne terrible , bougies nickel pas de trous , conso 12 - 15 en "normal"
Donc je touche à rien ;D

Purée y a que l'AOD , suis jaloux grave ... Mais j'ai pas les ronds pour le moment ::) Suis allé voir ta boite de trans US , tip top , mais ça douille grave , enfin prix "normaux" vu le matos top ; mais shipment + taxes ouille à l'arrivée ...

Je ne sais pas comment tu peux calculer le dynamique RV, ca dépend d'un tas de choses. Même l'instant où l'air commence à remplir la chambre est inconnu.
12 avec une C4 c'est déjà très bien si tu roules à 110km/h. Le 331 c'est l'alesage du 289 ? T'as quoi comme réglage de l'avance ?

14° 750 - 800 RPM y a que comme ça que ça tourne rond avec une dépression correcte.

Oui même alésage course plus longe , mais compression height plus petite et long rods

Dynamic RV calcul en ligne avec données AAC et flux connus culasse etc ...

14 degrés, et ensuite ?
Combien d'avance centrifuge max et à quel régime ?
Combien d'avance de dépression ?
Je ne devrais pas poser ces question dans ce thread. Désolé

Non non
Bushing 36° max @ 3000 rpm centrifuge
Dépression 1° à 16° entre 6 et 12 inchesHg
Prise capsule au dessus des papillons
Désolé sur tél pas facile

J'ai pareil, mais je vais descendre le max de la centrifuge vers 2500. Je lis partout que 3000 c'est trop prudent sur le 289.
Par contre comme le carbu est trop gros je vais faire tourner le ralenti avec la depression (du coup à plus de 20 deg d'avance) pour ne pas être riche en toutes petites charges. Sinon à 90km/h j'ai l'AFR à 12. J'ai déjà fait un essai ça à l'air de tenir le ralenti.

Ouais j'ai aussi lu avance centrifuge max better @ 2500 RPM , bon avec les ressorts que j'avais je me contente de 3000 LOL

Je mets un faible et un moyen. Le max devrait être dans les 2750. Je verrai. Après un ressort ça se bricole.

Ca avance gentiment , j'ai reçu vis et entretoises et j'ai fait mes essais de montage à blanc, ça va.

Faut je colle un bornier à vis 8 fils à l'extérieur du boitier + micro USB chassis, pas me prendre la tête à ouvrir le boitier à chaque modif. La boite sera dans la boite à gant au chaud et au sec et à l'abri des vibrations , l'écran est indicatif , pas besoin de l'avoir sous le nez sauf si pb , j'ouvre la boite à gant, d'ailleurs capteur courtoisie light boite à gant pour allumage/extinction écran cool LOL
J'ai prévu fils blindés RPM et PWM et thermocouple.

J'ai reçu accéléromètre, magnétomètre , gyroscope , purée impressionnant dans 2 cm2 , il ira pas dans le montage car bouffe trop d'entrée et de mémoire mais je vais bien jouer avec sur le Mega, le Uno va aussi si y a que ça, tout comme le Nano , mais il est full le Nano là ;D  bien1

Ouais qques rayures .... dérapage de dremel  ::)

(https://www.trechph.ovh/images/arduino/IMG_0600.jpeg)

(https://www.trechph.ovh/images/arduino/IMG_0601.jpeg)

Salut,

Les connecteurs c'est une véritable jungle !!! sur Mouser ou Digikey y en a style 65 000 différents !!!!

Ca m'a bien pris 2h pour trouver , je me suis concentré sur une marque à la fin : Phoenix , leur site est cool avec des modèles 3D en présentation, j'ai pris ce couple enfichable 10 contacts , la partie bornier à vis externe avec une partie femelle qui rentre dans la boite et la 2eme partie avec picots à 90° dessous à souder sur CI ( on les voit pas sur la photo ). Les 2 fixées par 2 vis qui servent aussi de fixation sur la boite ... OUffff

(https://www.trechph.ovh/images/arduino/phoenix2.png)

(https://www.trechph.ovh/images/arduino/phoenix1.png)

Salut

Beau progrès aujourd'hui , j'ai supprimé une carte !!  rnr libéré des pin , thermocouple viré ^^

Test avec sonde de tempé automobile AEM ( celle qu'il y a sur la voiture ) et calcul de corrélation ( merci l'ordi car y a des logarithmes )
Courbe parfaite , testé en vrai sur breadboard , affiche au degré près sans carte, juste la sonde sur une entrée et 2 résistances  msk L'Arduino calcule les log comme une fleur :D , pourtant ils ne figurent pas dans le Language Reference ???
Calcul ci dessous , formule en haut du graphe indice de précision R² = 0.999  bien1

(https://www.trechph.ovh/images/arduino/correlation_sonde.png)

Progrès du soir , l'acquisition des tempé se fait maintenant de 0°C à 110°C à 1°C près maintenant avec la sonde AEM direct pas de cartes.
Ca mange 1 pin et 1 ligne de prog !!! je vais pas m'en priver, tempé BVA, tempé ext , int, pour clim.
Huile moteur franchement pour mon moteur pas la peine LOL
Tempé BVA plus curieux à suivre  bien1

Ne pouvant corréler de 0 à 110 °C avec un formule , sauf moyenne glissante flottante , mais là je rentrais dans du lourd de lourd en prog ..., tableaux tournants and co , et ça me dépasse un peu , j'ai trouvé d'autres bonnes solutions

J'ai fait 2 zones, y a pas de formule  qui fait tout sauf la moyenne glissante flottante , complexe ...

Basse tempé corrélée à 1°C de 0°C à 65°C, formules polynomiales pour les 2 en fait . Sur le breadboard ça roule nickel , une fois debuggé , tout plantait au début ..... fallait passer certaines variables de unit8_t et uint16_t ( pour économiser mémoire ...)  en float pour les calculs ... J'ai mis qques h à trouver ce bug. Les def de variables c'est tout une histoire !!!

(https://www.trechph.ovh/images/arduino/corre2.png)

Tempé d'utilisation

(https://www.trechph.ovh/images/arduino/corre1.png)

En général on ne s'emmerde pas avec les formules pour les sondes dans les boitiers des moteurs. Le fabricant de la sonde donne un tableau avec une dizaines de points, on la copie et on fait sa cuisine avec. La précision pour les températures n'a pas d'importance, sauf pour les tempés de déclenchement des ventilos (95 ou 100 degrés c'est pas pareil). Les sondes de tempé ne sont pas précises (5-10%), seuls les thermocontacts sont précis.

Oui j'y ai pensé au tableau, à 5°C près ça suffit clairement on est d'accord, mais je me suis dit que j'allais avant regarder si pas de corrélation. A vrai dire j'ai été surpris d'en trouver une tout de suite ;D

A l'arrivée un tableau et son utilisation mangent plus de mémoire qu'une formule unique, un peu ;D ... C'était l'option B le tableau si pas de corrélation , l'option formule est parfaite et tient en 1 ligne de prog.

Après je me suis dit pourquoi ne pas l'étendre aux tempé BVA, clim et extérieures. Pour ça que je suis descendu à 0°C , pour le moteur 70 - 110°C suffisent

Les sondes AEM sont parfaites pour l'Arduino, on balance les 5V régulés de l'Arduino dedans ( qques mA ) et on récupère les tensions en mV des graphes selon la tempé sur une pullup de 2.2kΩ , y a plus qu'à les rentrer dans une pin analogique.

Le seul pb c'est que le logarithme est très cher en temps de calcul sur un petit cpu, et en RAM de la stack je pense. Si tu ne fais pas de temps réel ce n'est pas un pb. Une table comme ça c'est 20 bytes dans la rom.
Toutes les sondes NTC se branchent comme tu le décris.

Je fais un calcul toutes les 5 sec pour tout ce qui est relevés moteur , pas besoin de plus et un peu obligé sinon le GPS bugge il n'a pas le temps , il lui faut presque 1 sec pour balancer ttes ses données, il rafraichit à 1 Hz.

Les dernières formules sont polynomiales et n'ont pas de log ,

Oui le gps a un encodage hyper lourd (genre 60bit par bit de donnée) donc c'est lent. Normalement les gps des téléphones utilisent les accéléromètres pour interpoler entre les acquisitions.

Même avec tes formules sans log le flottant c'est cher y compris en RAM (sur un petit 8bit).

Oui j'essaye de faire gaffe aux variables, mais il y a qques float. J'ai qd même encore un peu de marge sur le Nano

Sketch uses 19786 bytes (64%) of program storage space. Maximum is 30720 bytes.
Global variables use 1670 bytes (81%) of dynamic memory, leaving 378 bytes for local variables. Maximum is 2048 bytes.

J'ai monté accéléromètre , SD card prog en dataloging , GPS et le reste .....Ben oupssssss hein35

Sketch uses 31584 bytes (102%) of program storage space. Maximum is 30720 bytes.
Global variables use 2517 bytes (122%) of dynamic memory, leaving -469 bytes for local variables. Maximum is 2048 bytes.
Sketch too big; see https://support.arduino.cc/hc/en-us/articles/360013825179 for tips on reducing it.
text section exceeds available space in board

Compilation error: text section exceeds available space in board

LOL je regarde si le Mega rentre dans la boite , Nano is too nano LOL

Avec le Dataloging et l'accéléromètre et le GPS , je peux extrapoler la puissance moteur :D et d'autres choses , c'est bien tentant.

Faut vraiment que je sécurise ce qui est gestion moteur de base : tempé , ventilo etc ...

Et tout le reste juste là pour m'amuser ...

Je peux aussi envisager 2 Arduino mais c'est casse pied , 2 boitiers , récupérer certaines variables qui vont aux 2 etc ... que de fils ...

Le Gps et même l'accéléromètre pour mesurer la puissance marche très mal, l'erreur et la dispersion sont énormes. La seule façon précise c'est de relever (au min 10 fois par seconde) le rpm ou la vitesse à partir de l'allumage ou du capteur d'abs, et de recalculer en utilisant le poid, les rapports de la transmission et la taille des roues. Et même comme ça c'est pas simple.

Je n'ai pas compris, ton log est envoyé sur le pc ?

L'accéléromètre c'est bien pour mesurer la performance du chassis: les accels laterales dans les virages, les deccel du freinage. C'est très utilisé pour régler la suspension. Ou pour améliorer le pilotage sur circuit.

Réponse partielle
J ai un module SD Card qui enregistre les log des variables sélectionnées
Le Mega gère sans pb occupation mém peanuts

Salut ,

J'ai voulu faire le montage définitif avec le Nano, donc j'ai voulu optimiser le programme final et là il me saoule  sbhy  sbhy  sbhy

Je ne peux pas mettre la SD card because mémoire full ( bon OK pas un drame, je le savais , donc pas de datalogging )

Les données du GPS pompent bcp de ressources et la liaison en softwareSerial ( pas de Rx Tx dispo sur le Nano ) n'arrange rien, si je branche le GPS en Tx Rx , ça marche mais c'est la ligne qui sert au Serial Monitor de l'IDE sur l'ordinateur, là ou on écrit le prog et où on lit ce que le Nano raconte via l'USB , donc plus d'upload de prog possible sans débrancher le GPS ... Bref il me saoule.
Pendant ce temps évidemment , il ça retentit sur le reste du prog de gestion moteur qui a du mal à passer entre les gouttes.

J'ai passé pleins d'heures à debugger le truc , je vais essayer le multitask , c'est à dire faire effectuer les taches les unes après les autres par périodes définies par le compteur millis() et non en routine permanente. Je vais me pencher sur la création de Fonctions_perso , une fois crées il suffira de les appeler dans le loop() bcp plus simple et compact.

Si ça va pas , je fais avec le Mega , là par de pb ...

A suivre ;D

Passes à un cpu plus gros. Software serial doit bouffer beaucoup de cpu, ca peut commencer à déconner si tu charges trop en calcul. Faire du multitask dans ces conditions c'est compliqué. Certe tu vas beaucoup apprendre mais au prix de beaucoup beaucoup de jours de debug.

Ben écoute , franchement , multitask de base sans fonctions , juste avec les millis() et surtout , j'ai passé toutes mes constantes style chaines de texte que ce soit écran ou Serial monitor de la RAM vers la Flash et ça tourne ! Ca a libéré pas mal de RAM , c'est elle qui saturait

J'espère même sans trop y croire du coup y caser la SD card en plus, enfin essayer  , c'est sympa pour lire des log bien1
A suivre

Salut,

Je progresse après 1000 heures de lecture et de debuggage. Donc c'est le Nano sans SD card , ça va et ça m'arrange. Le log ci dessous est de l'ordi.
Ces derniers 4 j j'ai appris les bases du multitask et des interrupt() internes ou externes ( pratique qd on a un bouton poussoir et que le prog tourne ailleurs ... )

Drolement bien, pour les RPM , je les ai au tour près entre noInterrupt() et interrupt() car c'est calculé avec pulseIn() qui travaille à la µs, donc pas de taches parralèles possibles sans avoir des RPM baladeurs ... à +/- 200 - 300 près ...  bien1

Pour le bouton poussoir de changement d'affichage , éviter le bounce , faire qu'il note que je veux switcher la page , même en plein compute de variables, il me la change parfois 5 sec après mais c'est pas grave, il a pris l'info en RAM dès que je l'ai pressé grace à l'attachInterrupt() qui lui est lié, je represse : la page d'après et dernière page le met en veille.

Bon faut pas en abuser des interrupt() dans un prog car ça met le proc et en pause, il enregistre là ou il en est et reprend après. La avec 2 petits ça passe nickel

Cool  rnr

J'ai aussi testé la régule des ventilos grandeur nature avec les vraies valeurs , réglé sur 88°C , je vous abreuve pas de log , mais ça marche super bien.
Y aura des bugs encore sûr et des seuils à ajuster mais ça roule nickel, juste un extrait de log , le Spal gère la tempé de la sonde AEM à 0,5°C près, il faut environ 1 mn au PID pour caler les ventilos sur un régime constant à qques % de variation près.
J'ai choisis l'option de les couper au dessus de 70 km/h , ça fera des ampères en moins , et ile ne feront pas frein avec le shroud , sauf tempé indécente bien sur ( ce qui ne devrait pas arriver normalement LOL )

18:10:17.159 -> Time: 16:10:16.000
18:10:17.159 -> Date: 17/10/2023
18:10:17.159 -> Fix: 1 quality: 2
18:10:17.159 -> Location: 4859.5229N, 208.4770E
18:10:17.192 -> Speed (knots): 40.49
18:10:17.192 -> Angle: 17.91
18:10:17.192 -> Altitude: 53.50
18:10:17.224 -> Satellites: 8
18:10:17.224 -> Antenna status: 2
18:10:17.224 -> tempAEM = 88.44°C
18:10:17.256 -> PWMval1 = 157.97 Dutycycle = 38%
18:10:17.256 -> Contact = 1 Clim = 1 pompe = 0 12V Batterie : 1
18:10:17.288 ->  RPM = 3011 pHigh = 996 pLow = 3985
18:10:17.288 -> interruptScreenCount = 15 screenCount = 3

Là je crois que je suis bon pour rentrer tout ça dans la boite  :v:

Y a plusieurs façons de filtrer les glitch des boutons. Les deux les plus simples: sur une durée on compte les 0 et les 1 et on compare, ou alors on remplis un shift reg de bit d'acquisition et on veut un FF ou FFFF. Les filtres anti-glitch hardware utilisent un shift reg.

Bah j'ai fait simple,  interruptScreenCount = 15 : c'est la variable DANS la fonction de l'interrupt stockée en RAM , tu peux voir 15 rebonds du bouton LOL

le screenCount = 3 c'est le N° de la page affichée , en gros je récupère interruptScreenCount dans le loop() , si >0 j'incrémente le screenCount de 1 et je remets interruptScreenCount à 0 et voila , jusqu'au prochain appui de bouton.

Citation de: geloche le 17 Octobre 2023 à 19:00:49Y a plusieurs façons de filtrer les glitch des boutons. Les deux les plus simples: sur une durée on compte les 0 et les 1 et on compare, ou alors on remplis un shift reg de bit d'acquisition et on veut un FF ou FFFF. Les filtres anti-glitch hardware utilisent un shift reg.

oui de mémoire avec l'électronique c'est la bascule de schmitt, mais là c'est quand tu veux des informations d'entrées fiables, dans ton cas, si j'ai bien compris, c'est le comptage des tours moteurs.

Oui
J ai 2 interrupt()
1 soft pour les pulseIn() qui me donnent les RPM
Et 1 hard externe pour le bouton qui switche les pages du display ;)

Geloche me parle en assembleur arghhh

Je parlais de comment on filtre les glitchs des boutons.

Oui merci bien1
Mais j en suis pas à l assembleur ;D
Là ça tourne

Citation de: filou96 le 17 Octobre 2023 à 20:18:19Oui merci bien1
Mais j en suis pas à l assembleur ;D
Là ça tourne

Aucun rapport avec l'assembleur. Ca dépend de ce que t'as comme libs pour ce genre de taches.
Entre le C que tu utilises sur un 8bit et l'assembleur il n'y a une grosse distance. A part pour les multiplications et autree calculs complexes

Salut , ça avance , cablage fait à 80% manque la platine des relais avec optocoupleurs et les 2 régulateurs

A gauche l'interface qui sert à brancher la prise 10 broches et supporte aussi les ponts de résistance et le le MOSFET optocoupleur qui pilote le PWM des ventilos, au centre l'Arduino Nano sur son shield ou est aussi soudé le module GPS , à dte l'écran.

J'attends la plaque de fond du boitier pour monter les entretoises. Ca ne saurait tarder.

J'ai aussi le schéma Fritzing qui va bien avec les N° repères, les couleurs de fil etc ..... Sinon c'est mort LOL J'ai pris une boite de fils AWG24, je ne travaille que sur des mA et mV , sinon y a du 3V, 5V, 8V et 12-14V max, et  aussi du µV , donc boite ( chinoise of course ) 6 couleurs de fils seulement , donc faut gérer .

La puissance est gérée par des relais externe automobiles.

Ce qui est top , je branche mon ordi en USB, fais les modif, reboot et voila aussi simple :D

(https://www.trechph.ovh/images/arduino/IMG_0606.jpeg)

(https://www.trechph.ovh/images/arduino/prog_Nano_pro_5_V2.png)

Salut ,

Comme toujours , on monte la V1 , plein de pb à résoudre , du coup à la fin ça marche mais c'est moche avec des défauts, fils à la volée , d'autre coupés etc ... , donc on remonte une V2 en tenant compte des pb rencontrés et là elle semble correcte, malgré qque debuggage et fonctionne bien1

Y a plus qu'à la mettre dans la boite , elle est sur sa platine là , faut que je monte un connecteur 4 broches pour l'écran.

(https://www.trechph.ovh/images/arduino/IMG_0611.jpeg)


On voit les 2 alim step down verticales de chaque coté à G pour le 3V permanent horloge GPS, à dte le 8V Vin de l'Arduino, la platine des relais dessous et tout en bas le shield de l'Arduino.

(https://www.trechph.ovh/images/arduino/IMG_0612.jpeg)

(https://www.trechph.ovh/images/arduino/IMG_0613.jpeg)

Prochaine étape , mise en boite , cet AM vu le temps ...

Voila LOL

A pas fallu longtemps et miracle ça fonctionne encore  bien1 Je vais rester sur les mini Wago pour l'écran

La vidéo arrive le temps que Youtube fasse les vérif  ;D Oui je sais le "Local Time" est à l'heure d'été ;D J'aime pas l'heure d'hiver

https://youtu.be/dfKrF3saVjs

(https://www.trechph.ovh/images/arduino/IMG_0615.jpeg)

Bravo  ap:lo

Salut Filou96 j'espère que tous va bien de ton coté, car plus de nouvelles depuis 1 mois   

Ben oui c'est vrai.....il est ou Filou , ta santé va bien au moins ?

Je lui ai passé un p'tit MP depuis déjà un bon moment, Et aucune réponse  ???

Oui c'est pas normal, j'espère surtout que sa santé va bien

Ce n'est pas dans ses habitudes d'être aux abonnés absents...

Salut , oui je sais , la Mustang va bien , je vend ma maison ... Trop d'escaliers avec les années ... le développement de l'interface Arduino occupe mes journées avec un écran 10" tactile , c'est super addictif lol 🤣
Désolé pour mon absence , mais quand je n'ai pas le temps de suivre , je lache un peu ...
J'ai un peu laché le forum car mis à part le dev Arduino , se passe rien et j'aurais pas pu suivre ... Mais je vais revenir dans pas longtemps .
L'Arduino est carrément passé au stade supérieur  ;D
Ca progresse , moi aussi forcement plongé dans les doc ATMEL de 1000 pages ...
Je suis passé sur Due et écran capacitif de 10"
Bref, succès du jour passez les sorties PWM à 100 Hz au lieu de 1000 Hz , pas mal de méthodes , beaucoup s'en servent pour piloter les moteurs de leur servos en PWM.
Vu que je n'avais pas besoin de plusieurs fréquences, j'ai fait dans le hard modif fichier système variant.h, tout mes PWM sont à 100 Hz ...
Autant l'écran est puissant : 10 pages en SDRAM 1024X600 , on exécute le code que l'on veut sur chaque page en background , on affiche des swap de pages ou de morceaux de pages comme on veux , on peut bien jouer avec, mais faut s'accrocher pour le code ... Avantage c'est fluide et immédiat et on ne puise pas les ressources de l'Arduino .
La compréhension de ses fonctions et leur mise en oeuvre c'est encore 600 pages de bouquin ... Les Libraries chinoises aident au début , mais je les ai largement modifiées.
Le Due ( c'est un ARM ) fait merveille , le Nano ben à la ramasse ... seul inconvénient pas grave il bosse sur du 3.3V I/O.

Vous avez le duty cycle sur l'oscillo à G à 100 Hz indexé sur la vitesse pour essai
Vous aurez compris , vitesse en haut , RPM en bas ... C'est pas encore écrit, le flocon qui change de couleur c'est clim ON/OFF

L'idée c'est ça , il y aura d'autres pages pour modifier les paramètres en tactile

(https://www.trechph.ovh/images/arduino/proto_dessin.png)

Prochaine étape dans pas longtemps le Raspberry Pi

https://youtu.be/3p6FBx6U7eg

Capteur de tempé 5V adapté au 3.3V

https://youtu.be/j1I5DzHyVas

A bientot

Les joies de la programmation  bien1  bien1

j'adore il est fou !  :o   bien1  bien1

Le professeur Tournesol  ;D

Botus et mouche cousue !! La prochaine étape, comment aller sur la lune en mustang !!

Ouais je veux ramener le sportster Tesla et Bowie avec  :D  smk

https://youtu.be/eH9OGQADzkA

Salut , j'ai bien avancé sur le graphisme des jauges , surtout pour la fluidité.
C'est une simulation bien sur , même si le PWM et les sondes tempé fonctionnent elle me disent 22°C dans la pièce et pas besoin des Spal LOL

https://youtu.be/6T11f8GeHx8

 bien1  bien1