Problème ventilateur.

Salut, suite à vos conseils sur des ventilateurs, j'ai franchis le cap et j'en ai acheté deux.
Ce sont des BeQuiet PureWings 2 120mm PWM
Pas grand chose à dire, sauf que le connecteur d'un des ventilateur est mal fait, il nage un peu sur le port de la carte mère donc il ne ce connecte pas aux pins, bref le problème est réglé.

Le second ventilateur, tourne bien, même un peu trop, il était à 400tr/min sans utilisation poussée du PC, normal c'est ça vitesse à bas régime.
Mais après un reboot du PC il tourne à 1406 tours voir 1506, qui est sa vitesse maximale, impossible de gérer ça vitesse avec speedFan alors que l'autre ventilateur je peux.

J'ai cherché dans le BIOS, s'il y avait pas une variable à activer, il n'y en a pas.

Ma carte mère est une Intel DH77EB, et les ventilateurs PWM sont supportés, donc pas de soucis à ce niveau ci.

Si vous avez une idée d'où ce là proviens ou même comment résoudre ce petit problème, je vous en remercie d'avance.

Après une mise à jour de la carte mère, le problème persiste toujours, je commence à croire que la carte mère vieillis et qu'il est temps de la changer.

Ok, j'ai une petite question, alors voilà, j'ai développer un rhéobus pour la gestion de deux ventilateurs selon une température, il possède un mode auto et manuel, il aurait un écran de 3.95" tactile, le tout pour environs 17€, pensez vous qu'il vaut mieux en acheter un ou le faire moi même du coup ?

A ce prix la, je suis quand même étonné...
Tu te base sur quoi comme matériel pour faire ça ?

Je me base sur de l'arduino, mais des clones bien-sûr ca marche tout aussi bien et c'est moins cher.

admin-Guillaume écrit: idem ! le j'ai (développé m'a un peu perdu aussi)

Bah en arduino il faut développer le programme. A l'aide d'un logiciel de simulation sur le PC j'ai finalisé le projet de rhéobus, même si l'ecran tactile n'est pas présent sur le logiciel de simulation.

Si je viens à le faire et non en acheter un, je ferrai un topic pour montrer l'évolution et la création du rhéobus.

SIC toujours...
Je suis en train de faire un truc similaire pour mon PC à base d'Arduino Mega, et si je fais les comptes, je n'en suis pas à ce prix.
Surtout que je ne prévoit pas d'écran, et encore moins tactile.

Tu gère aussi des boutons matériels ?
Tu contrôle seulement le PWM, ou tu contrôle aussi l'allumage / extinction des ventilateurs sur la puissance ?
Tu as un retour sur leur vitesse avec une instruction pulseIn ?
Le PWM tu le modifie avec un analogwrite ou bien tu passe par les registres ?
Avoir du PWM c'est bien, mais si c'est pour définir des consignes de vitesses en dur, c'est inutile. C'est en boucle de contrôle que ça doit fonctionner => L'idée c'est de modifier la vitesse en fonction d'une température ici. Tu la mesure aussi ?
Ton programme, tu le code tout dans ton fichier principal ou bien tu utilise des fichiers externes ?

Bref, je suis preneur d'infos car ça pourrait me débloquer sur certains points chez moi.

Black_Wolf écrit: SIC toujours...
Je suis en train de faire un truc similaire pour mon PC à base d'Arduino Mega, et si je fais les comptes, je n'en suis pas à ce prix.
Surtout que je ne prévoit pas d'écran, et encore moins tactile.

Tu gère aussi des boutons matériels ?
Tu contrôle seulement le PWM, ou tu contrôle aussi l'allumage / extinction des ventilateurs sur la puissance ?
Tu as un retour sur leur vitesse avec une instruction pulseIn ?
Le PWM tu le modifie avec un analogwrite ou bien tu passe par les registres ?
Avoir du PWM c'est bien, mais si c'est pour définir des consignes de vitesses en dur, c'est inutile. C'est en boucle de contrôle que ça doit fonctionner => L'idée c'est de modifier la vitesse en fonction d'une température ici. Tu la mesure aussi ?
Ton programme, tu le code tout dans ton fichier principal ou bien tu utilise des fichiers externes ?

Bref, je suis preneur d'infos car ça pourrait me débloquer sur certains points chez moi.

Alors, j'utilise un capteur de température LM35 il n'est pas I&C, mais avec la librairie FlexiTimer2 on peut le mettre en interruption.
Pour la MLI (PWM), j'utilise un L298N pour gérer les deux ventilateurs que je possède. Donc oui j'utilise la fonction analogWrite.
J'ai juste fait une errer dans le calcul de la MLI comme j'ai fait le calcul sur un 1200tr/min et j'ai des 1500tr/min.
Et pour le programme, j'utilise les croquis, un croquis pour le capteur de température (je me suis développé une librairie en C++), et un croquis pour la MLI (ou asservissement selon les appellations).

Et comme je l'ai dit, j’achète en Chine mon matériel.

Je pars sur une arduino nano, comme l'écran est compatible Uno R3 et que la nano est identique niveau broches, elle ne m'as coutée que 3.53€ en chine. Le LM35 est aux environs de 1.2€, l'écran en Chine est lui à 7.X€ et le L298N lui est vers les 2.5€.

La nano, et le LM32 je les possède déjà donc il me reste environs 10€ à dépenser pour l'écran et le L298N.

Si tu as besoin d'aide niveau code je suis dispo, et je serai ravis de t'aider.

SI tu veux un écran, 3.95" tactile, et une mega regarde par là.

Pourquoi prends tu une arduino Mega? le programme est trop volumineux? utilisation de beaucoup de broches ?

Juste comme ça... Tu utilise un L298N ( je ne connais pas, j'ai fais une recherche google. ) pour piloter des ventilateurs 4 broches sur le circuit d'alimentation, ou je me trompe ?
Sur un ventilateur 4 broches, il suffit d'envoyer un signal PWM en 25kHz sur la quatrième broche et c'est bon. Avantage la sortie tachymétrique n'est pas erronée.
Si tu envois un signal PWM sur le +12V, ton capteur tachymétrique est faussé.

Mais je me trompe peut être car comme j'ai dit je ne connais pas le composant.

Pour ma part, j’envoie 6 signaux PWM en 25kHz. J'ai du toucher aux registres pour pousser un peu, mais ça fonctionne impeccable.
J'ai une résolution de 8bits ce qui est le maximum supporté par les ventilateurs et pompes de PC. Pour la coupure, j'utilise des transistors ou des ULN2803A suivant la puissance demandée.
Pour le choix du Méga, c'est du au nombre d'entrées / sorties que je désire gérer.
J'ai 6 groupes de pompes / ventilateurs, donc 6 sorties de coupure puissance et 6 sorties PWM.
J'ai 8 sondes de températures ( dont 2 LM35, mais sans utiliser FlexiTimer2 que je ne connaissait pas )
J'ai les 5 boutons du Cosmos II à brancher dessus ( Je viens de trouver un 74HC14 dans mon fourbis au boulot, je vais pouvoir tenter de supprimer les rebonds )
J'ai 9 leds d'état pour les boutons du boitier
J'ai les entrées tachymétrique des tous mes ventilateurs / pompes ( 9 en tout )
Et dans l'idéal, j'aimerais aussi interfacer la carte mère ( Marche / arrêt, les signaux des ventilateurs, etc... )

Pour le moment question code, j'en suis à couper mon fichier principal en petits modules. Il vas falloir que je me fasse un map des sondes, revoir un peu le code car je viens d'avoir l'idée de placer quelques valeurs de configuration dans la ROM, (re)tester les boutons avec le 74HC14, (re)écrire le code en travaillant sur les registres pour gagner en vitesse, et surtout trouver une alternative au PulseIn qui me plombe niveau temps !

Moi avec la MLI, j'ai fait un calcul pour que la la MLI soit proportionnelle à la température et a la vitesse du ventilateur.

Le L289N fonctionne comme une "vanne" selon la valeur du analogWrite il délivre une certaine tension, suffit juste de mettre du 12v dessus et le L298N délivra la tension souhaité.

Après, mes ventilateurs aussi sont PWM, et je sais qu'avec le L298 on peut le faire sans passer par les registres et booster les fréquences.

Mais je suis toujours sur le projet, et ta méthode m'intrigue je dois dire.

Si je ne me trompe pas, travailler avec les fréquences c'est de l'asservissement.

Pour ton pulseIn, essaye de travailler avec les interruptions, ce qui ce fait de manière ashynchrone et donc ne bloque pas le programme.

Et un conseil si tu utilise des delay, bah il faut éviter. Enfin moi j'essaye le plus possible des les éviter, pour éviter de bloquer le programme, comme arduino est un code procédurale, il exécute instruction par instruction.

Si tu veux que l'on en discute je peu te passer mon skype ou via MP.

Çà peut tourner ici, pas de soucis...

Voici une portion de mon code pour le PWM sur l'ATMéga. Pour le Nano, il faut consulter la datasheet pour connaître les registres !
( Soucis de mise en forme, les tabulations sont plus longues que la fenêtre du code )

Puis ensuite, il n'y as plus qu'à modifier la valeur du Duty cycle dans ton loop entre 0 et 79 ( au dessus il reste bloqué à 79 ) pour donner la consigne de vitesse, en fonction de tes besoins.

Si tu incrémente le duty cycle de 10 en 10, tu as ces valeurs qui correspondent aux valeurs des cartes mères de PC...
Et pour le moment, j'ai un soucis avec ma version de avr/pgmspace.h qui n'apprécie pas un truc... Faut que je trouve la version Arduino !

De mémoire, le seul delay que j'ai, c'est dans une routine de validation ( un bip d'un buzzer ) pour les tests...
Mon soucis avec PulseIn, c'est que j'en fait 9 de suite avec chacun un timeout de 250000. Il faut vraiment que je me plonge dans les interruptions...

Ha d'accord, la nano est identique à la uno, donc je pense que les registres ne changent pas trop.

Moi je fait plus simple, je pourrais même utiliser un ventilateur deux broches avec a méthode. Mais en simulation comme je n'ai pas les bonne infos de ventilateur je ne peux pas faire via la PWM et le tachymètre au niveau du codeur qui serait faux dans mon programme.

Je me suis inspiré d'un tuto pour la Uno il me semble au début.
http://forum.arduino.cc/index.php/topic,18742.0.html
Dedans il utilise TCCR2A = 0x23; TCCR2B = 0x09; c'est les tableaux de la datasheet qui définissent les valeurs. J'ai passé plusieurs jours ( à temps perdu ) à tenter de les comprendre exemples à l'appui.

Pour utiliser un ventilateur à deux broches, dans mon idée, tu part sur le même programme et tu place un transistor sur le +12V du ventilateur et tu le pilote avec ta sortie PWM. Mais après, ce n'est plus dans mes connaissances...
Déjà que je n'ai jamais codé en C++ ...

Black_Wolf écrit: Je me suis inspiré d'un tuto pour la Uno il me semble au début.
http://forum.arduino.cc/index.php/topic,18742.0.html
Dedans il utilise TCCR2A = 0x23; TCCR2B = 0x09; c'est les tableaux de la datasheet qui définissent les valeurs. J'ai passé plusieurs jours ( à temps perdu ) à tenter de les comprendre exemples à l'appui.

Pour utiliser un ventilateur à deux broches, dans mon idée, tu part sur le même programme et tu place un transistor sur le +12V du ventilateur et tu le pilote avec ta sortie PWM. Mais après, ce n'est plus dans mes connaissances...
Déjà que je n'ai jamais codé en C++ ...

Bah avec le L298 aussi le 2 broches ce gère, après il n'existe pas qu'une seule solution bien sûr, et pour avoir fait cette solution pendant ma première STI2D je sais quelle fonctionne.

Et Arduino du C++ pas trop, le C++ est plus différent, c'est plus du C++ simplifié.

Et puis modifier les fréquence de la carte je ne préfère pas, c'est comme tout, après ça chauffe un peu plus, c'est de l'overclocking quoi.

C++ ou C++ simplifié, ça ne change rien au fait que je n'ai jamais touché.
Heureusement que je suis doté d'un cerveau ( ça semble devenir rare de nos jours... ) et que je sais m'en servir, ainsi que recopier des trucs qui ont fonctionné pour les arranger à ma sauce.

Pour les fréquences, on n'overclock pas la carte. On joue sur la forme des courbes générées pour le PWM. Ce sont simplement des modes de fonctionnement différents supportés par le microcontrôleur.
Tout est expliqué dans la doc. Pour le Mega 2560, c'est le chapitre 17.9 ( 16-bit Timer/Counter (Timer/Counter 1, 3, 4, and 5 ) - ( Modes of Operation ).
Il suffit de chercher la doc pour le microcontrôleur de ton Nano et tu cherche ces sections. Il y as les différents modes expliqués, avec leur courbes et leur formule mathématiques.
Par contre, il faut jongler avec les tableaux après...

Il existe une librairie PWM, ou tu peux régler la fréquence de ton PIN, cela te permet de le mettre à 25kHz sans avoir trop de code.
A voir sur le Arduino Playground

Je crois que c'est assez minimal en fait niveau code pour 3 PWM différents sur un seul timer...
Le code fonctionne pour Arduino Mega. Les valeurs de TCCR4A et TCCR4B sont à adapter pour une autre carte.
Ce qu'il y as, c'est qu'il faut vérifier que l'on est bien sur les pins correspondant à un Timer. Mais merci pour l'info, je n'ai pas trop l'habitude de chercher des librairies pour Arduino. Je code mes fonctions, ça me permet d'apprendre en même temps.

Moi aussi avant je développais mes fonctions, dans arduino, maintenant, je me développe mes propres librairies.
Même si j'en utilise beaucoup quand même, je vais continuer a chercher pour le PWM sur la Nano.
comme ça plus besoin de L298, donc 2€ de gagnés .

Pour tes ventilateurs, tu branches directement l'entrée PWM du ventilateur sur l'Arduino, tu utilise des transistors, et des résistances, des diodes de roues libre ?

Sur mon montage, je branche l'entrée PWM du ventilateur directement sur la sortie PWM de l'Arduino et ça suffit.
J'ai juste placé un ULN2803A qui me coupe la masse du ventilateur quand je désire le stopper ( signal PWM à 0% ).

Lors des premiers essais... Pin 44 sur la photo. Piloté par le code mis plus haut, je modifie juste le OCR## rattaché à la pin à piloter pour faire changer la vitesse.

Ce code là devrait fonctionner chez toi.
Il semblerait que sur le Nano il n'y ai qu'un timer 16 bits relié sur les broches 9 et 10, et un timer 8 bits, relié sur les broches 6 (OCR0A) et 5 (OCR0B).
J'ai utilisé le timer 16 bits, en mode 14 avec un prescale de 8.
Tu n'as qu'à donner une valeur entre 0 et 79 à OCR1A ou OCR1B pour faire varier le ventilateur correspondant.

J'avoue que chez moi, j'utilise des valeurs entre 10 et 80 par pas de 10, par facilité. Au dessus de 79, il prend 79 comme valeur, donc 80 ça ne fausse pas trop le pourcentage final.
Avec des valeurs de 10 en 10, ça te fait 8 bits, et tu peut tenter d'utiliser le timer 0 en plus du 1. ça te permettras de piloter 4 sorties PWM en 25 kHz.
Bien sur, il faut vérifier les tableaux dans la datasheet pour être certain des valeurs à donner à TCCR0A et TCCR0B.

Black_Wolf écrit:

void setup () {
    TCCR1A = 0x52;
    TCCR1B = 0x1A;
    ICR1 = 79;

    pinMode( 9, OUTPUT );
    pinMode( 10, OUTPUT );
}

void loop () {
    OCR1A = VALUE_1;        // Le pourcentage de PWM pour la sortie 9
    OCR1B = VALUE_2;        // Le pourcentage de PWM pour la sortie 10
    ...
}

Ce code là devrait fonctionner chez toi.
Il semblerait que sur le Nano il n'y ai qu'un timer 16 bits relié sur les broches 9 et 10, et un timer 8 bits, relié sur les broches 6 (OCR0A) et 5 (OCR0B).
J'ai utilisé le timer 16 bits, en mode 14 avec un prescale de 8.
Tu n'as qu'à donner une valeur entre 0 et 79 à OCR1A ou OCR1B pour faire varier le ventilateur correspondant.

J'avoue que chez moi, j'utilise des valeurs entre 10 et 80 par pas de 10, par facilité. Au dessus de 79, il prend 79 comme valeur, donc 80 ça ne fausse pas trop le pourcentage final.
Avec des valeurs de 10 en 10, ça te fait 8 bits, et tu peut tenter d'utiliser le timer 0 en plus du 1. ça te permettras de piloter 4 sorties PWM en 25 kHz.
Bien sur, il faut vérifier les tableaux dans la datasheet pour être certain des valeurs à donner à TCCR0A et TCCR0B.

Oh ! Merci bien, il faudrait que je me plonge dans la compréhension de la modification des registre.
Le ULN2803A fonctionne comme un relais je présume.

Oui, il me semble que c'est un réseau de transistors montés en darlinghton. Mais je ne suis pas dans l'électronique.
Pour ce que j'en sais, je l'alimente en 5 ou 12 V suivant ce que je met derrière, et j'ai 8 "entrées" dessus.
Attention, c'est un retour à la masse !
Par précaution, pour des ventilateurs, je double les entrées / sorties sur le ULN.

Pour les registres, il te faut la datasheet de ton microproc (at328 il me semble avoir lu), et tu cherche le chapitre 8 bits ou 16 bits timers.
Après avoir lu la moitié, tu tomberas sur des tableaux pour TCCR#A, puis TCCR#B qui te disent quoi choisir en fonction de tes besoins. ( Mode 14 pour le FAST PWM, sans modification de la fréquence et 2 comparateurs de disponibles pour TCCR#A ), et prescale de 8 pour TCCR#B. Tu n'as pas besoin d'avoir de correction d'erreur donc tu peut laisser ces bits à 0.
Après avoir placé chaque tableaux, tu auras deux chiffres binaires de 8 bits qui seront tes valeurs pour TCCR#A et TCCR#B.
ICR# se calcule selon une formule, elle est donnée dans le lien que j'ai mit plus haut, j'ai la flemme de rechercher ce soir, mais pour ton application, ce seras 79.
Ensuite, le microproc compare la valeur de tes deux registres OCR#A et OCR#B à celle de ICR# pour ajuster le PWM.

Mais tu peut faire d'autres choses aussi, à toi de voir...

En tout cas, chez moi c'est sur ça que mon programme s'appuie, et c'est totalement transparent et rapide.
Je balancerait peut être le code quand j'aurais terminé, peut être qu'un pro saurait l'optimiser.
Mais pour le moment, c'est encore trop brouillon à mon gout.