Je cherche à faire une régulation train d'ondes pour régler la température de chauffe d'une résistance.
Après une petite recherche je suis tombé sur ce sujet mais il ne correspond pas vraiment à mon cas. En effet, la puissance maximale de ma résistance chauffante est de 1653W sauf que je dois éviter de générer plus de 400W si je ne veux pas endommager mon installation.
Etant donné que la puissance max de consigne est 4 fois inférieure à la puissance max possible j'ai essayé de bricoler un bout de code simulant du PWM. Si j'ai fais ça c'est pour pouvoir tourner le potentiomètre de réglage sans avoir à me préoccuper de l'angle à ne pas dépasser (90° max, c'est pas beaucoup).
Je tiens à préciser que je débute, ma seule pratique vient des démonstrations fournit dans le Livre de projets Arduino.
int tpsConduction = 0;
const int potentiometre = A0;
const int consigneTemp = 12;
void setup (){
Serial.begin(9600);
pinMode(potentiometre, OUTPUT);
pinMode(consigneTemp, OUTPUT);
}
void loop() {
Serial.print(consigneTemp);
int reglagePotar = analogRead(potentiometre);
int tpsConduction = map(reglagePotar, 0, 1023, 0, 1000);
//pendant une boucle de 4000ms (soit l'équivalent d'une période), le microcontrolleur conduit seulement pendant un temps T (compris entre [0-10]% de la boucle while) définit par le potentiomètre et le reste du temps ne conduit pas.
while (millis() <4000){
if (millis() <= tpsConduction) {
digitalWrite (consigneTemp, HIGH);
}
else {
(digitalWrite (consigneTemp, LOW));
}
}
Serial.print("Temps de conduction");
Serial.print(tpsConduction);
}
J'ai mis des durée assez longues parce que je souhaitais simuler mon chauffage avec une résistance et une LED en série. Dans ma tête, avec ce code je définissait la période T totale (4000ms) et limite la durée maximale de conduction que le potentiomètre peut régler (entre 0 et 1000ms).
Je suis désolé, mais je ne peux que vous faire une réponse partielle: votre code a l'air de fonctionner, mais seulement 4 secondes après la mise sous tension de l'Arduino.
millis() donne le nombre de millisecondes écoulées depuis ... la mise sous tension
Vous devriez garder trace de l'etat de votre machine
byte etatMachine; // qui sera HIGH ou LOW
noter le temps où vous avez changé d'état et, à chaque changement d'état, calculer le temps suivant.
L'exemple blinkWithoutDelay a l'air facile à adapter (il vous fait un rapport cyclique de 50%; comme il est très lisible, vous pouvez essayer de l'adapter -je trouve plus sympa d'adapter que d'avoir une solution magique "clé en main"-)
Par contre, je suis un peu inquiet quand je vous vois travailler sur le secteur (que se passe-t-il si l'arduino casse ou un fil partant de l'Arduino casse?)
vous voulez faire plutôt un calcul de différence entre le moment du lancement et le moment présent pour trouver une durée
Je ne comprend pas bien votre question. Ce que je souhaitais faire à l'origine c'était juste moduler le temps de conduction (tpsConduction sur le croquis) entre [0-25]% de la période que j'ai artificiellement fixée (millis sur le croquis).
Si je comprends bien il faudrait que je transforme millis() en long(), sauvegarder le temps de commutation de la précédente boucle tout en incrémentant de T (la période) la boucle suivante à chaque fois c'est ça ?
En fait, je pensais qu'il était possible d'implanter des compteurs qui se reset à chaque boucle. Je me suis planté apparemment
Je vais brancher l'Arduino sur la partie commande d'un relais statique. C'est lui qui s'occupe d'alimenter ou non la résistance. La résistance quant à elle est immergée et avec une protection thermique (c'est un chauffe-eau instantané).
En activant pendant 4s tu vas consommer 1600W pendant ces 4s. Ton installation va sans doute le sentir. Ce n'est pas pareil que jouer sur l'ouverture d'un triac.
En ce qui concerne l'usage de millis(), le plus simple c'est de prendre le principe du programme de démo installé avec l'IDE nommé blinkWithoutDelay
Définition de millis() que l'on trouve dans le site Arduino ici :
C'est le créateur de la fonction qui a estimé qu'il fallait utiliser un "unsigned long".
Il faut appliquer ce qu'il a décidé.
Voici ce que l'on trouve à l'adresse indiquée.
Note : c'est valable pour toutes les fonctions arduino.
Description
Returns the number of milliseconds passed since the Arduino board began running the current program. This number will overflow (go back to zero), after approximately 50 days.
Syntax
time = millis()
Parameters
None
Returns
.Number of milliseconds passed since the program started.
Data type: unsigned long.
oui mais pas (simplement) avec millis. il ne fait que progresser jusqu'à retomber à 0 dans une cinquantaine de jours si vous laissez votre arduino allumé
➜ il faut donc travailler par différence
vous voulez boucler sur un truc comme cela:
on allume et on note dans debut = la valeur de millis() à l'allumage
le potar sert à régler la durée millis() - debut (un nombre entre 0 et 1000) et quand on dépasse cette valeur, on éteint
on reste éteint jusqu'à ce que millis() - début dépasse 4s.
J'ai l'impression qu'il va faire une espèce de maquette lente, avec une LED, pour comprendre, et ensuite passer à une vitesse supérieure (remplacer ( non : ceci est faux 4000 par xxx) et jouer sur le calcul de tpsConduction.)
Déjà, je vois un blème, hors sécurité:
Serial.print (environ 25 cars) va lui prendre, à 9600 bauds (1 car/seconde, en gros) ... 25 msecondes - une période du secteur en France est de 20 ms - qui vont semer un beau désordre dans ses boucles de temporisation; passer à 115200 bauds ferait moins de désordre (qu'une impression de débugging cause une bug n'est pas sympa)
Exactement, l'idée était de voir le temps d'allumage de la LED par rapport au temps étant en fonction de valeur du potentiomètre. J'ai mis 4000 pour voir les changement d'état mais dans l'absolu que ce soit une période de 4sec avec un temps de conduction de 1sec max ou T=40sec et conduction = 10sec c'est pareil. Je dois juste faire varier la puissance entre [0-25]% de la puissance max.
Serial.print (environ 25 cars) va lui prendre, à 9600 bauds (1 car/seconde, en gros) ... 25 msecondes - une période du secteur en France est de 20 ms - qui vont semer un beau désordre dans ses boucles de temporisation; passer à 115200 bauds ferait moins de désordre (qu'une impression de débugging cause une bug n'est pas sympa)
J'avais mis Serial.print parce qu'au début j'espérais pouvoir suivre les commutations sur l'ordi. C'est après que j'ai pensé à la DEL. Entre temps j'ai oublié d'enlever ce bout de code qui ne me sert à rien.
Merci beaucoup, je vais pouvoir essayer ça en grandeur nature car sur la breadboard ça fonctionne super bien.
Je vais aussi pouvoir réfléchir au pourquoi du comment du fonctionnement.
je partage le malaise de @coloneldeguerlasse - attention quand on joue avec autre chose qu'une LED... le 230V tue... Soyez prudent et assurez vous d'avoir les bons composants normés pour piloter de la puissance ...
Alors je suis peut-être débutant en code Arduino mais je suis électrotechnicien de formation. Je suis plus à l'aise avec des résistances chauffantes qu'avec un microcontroleur.
L'arduino commandera un relais statique "normalement ouvert" acheté sur RadioSpare donc si un fil sur l'arduino se déconnecte, le relais s'ouvre et le circuit de puissance n'est plus alimenté. La partie puissance sera bien sûr câblé avec des cosses électriques, installé sur rail DIN. Histoire d'avoir quelque chose de robuste.
En tout cas encore merci. Mention spécial à J-M-L.
Je serais pleinement rassuré si son câblage était visible (les methodes employées ont l'air saines, il eu droit à un très bon programme simulé sur un nouveau simulateur, ce serait dommage qu'il subsiste un tout petit risque dû à un mauvais branchement que certains yeux peuvent détecter -et beaucoup d'autres admireraient, me semble-t-il)
Un petit message pour vous informer que mon montage fonctionne parfaitement. Le programme de J-M-L est super (encore merci d'ailleurs), il faut juste que je vérifie si la puissance délivrée me permet d'atteindre la température souhaitée. Mais bon ça c'est juste une question de réglage.
