Arduino (page 3)
Page publiée le : 12/10/2013
Réchauffeur
Réchauffer de l’eau avec une résistance de puissance ?
Oui, dans quel but ? Après tout un thermoplongeur ferait bien mieux, c’est vrai. Alors quel est le fond ?
Faire « d’une pierre, deux coups ». D’abord une liaison entre IDE Arduino et Processing et en suite se servir du réchauffeur pour le générateur HHO. Il serait dommage que l’eau gèle en hiver, d’où plus de générateur et plus de HHO pour le moteur.
Récapitulons :
L’idée est de programmer un truc qui réchauffe de l’eau de quelques degrés et un autre truc qui affiche des informations sur un écran d’ordinateur,comme la température de cette eau, le courant consommé par le montage, et la durée de l’expérience.
L’idée de fond est surtout de placer un système antigel dans le générateur HHO qui est censé être embarqué sous le capot moteur d’un véhicule. Une mesure de température de l’eau et donc nécessaire, et pour la réchauffer, une élément chauffant piloté par la carte arduino.
Et pour la mise au point il est bon d’afficher les données sur un écran.
Bref, ça donne ceci :
Schéma :
Ecran processing :
Bien sur, pour réaliser ce petit projet il vous faudra :
- Les composants du schéma ci-dessus
- le logiciel libre, pour écrire, éditer, compiler et programmer la carte Arduino,
- le logiciel libre Processing.
Le capteur de température KTY81 a une courbe presque linéaire.
Ce « presque » est très gênant dès que le delta en température dépasse 10°. Aussi il a fallu établir une courbe la plus proche possible à l’aide d’un fonction du second degré et en déduire les paramètres.
Ceci a donné lieu à la programmation d’une fonction « fmap » qui exécutera la correction de la tension relevée sur le port A0 afin de donner la bonne température.
- La température est calculée en fonction de la tension amenée en A0.
- Le courant instantané est calculé en fonction de la tension mesurée aux bornes de la R de 1ohm 4W.
- Cette tension est amenée en A1.
- La durées des impulsions provient de la sortie PWM D09.
- Elle est ici à 80% niveau haut et 20% niveau bas et donc l'inverse sur le Drain de l'IRFP240
Et on démarre par le programme pour la carte Arduino.
Structure du programme
Il se décompose en 4 parties :
- les déclarations
- une routine configuration (setup) exécutée une seule fois,
- Une fonction de paramétrage pour un le calcul de la température.
- le cœur du programme contenu dans la boucle « loop ».
Les déclarations :
- affectation de nom aux broches de commande des afficheurs.
#define pwm 9 // pour la cadence PWM de pilotage de l'IRFP
#define FH 2 // rqp de signal PWM
float val; // valeur analogique (température / millivoltmètre)
float tcapteur = 0; // température capteur
float amps = 0; // ampères arrondis à l'entier.
char datas[10]; // datas envoyées sur le port série
int front ; // identification "front" signal PWM
La fonction "setup()" :
Serial.begin(9600);
analogWrite(pwm, 50);
La fonction "fmap()" :
float fmap(float x, float in_min, float in_max, float out_min, float out_max){
float valeur;
valeur = (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min;
return valeur;
}
La fonction "loop()" :
// lecture de la valeur sur la broche A0 (température eau)
val = analogRead(0);
// Calcul de la température
tcapteur = (val * val * 0.00080648)+ (val * (-0.38963492)) - 1.1239556;
// lecture de la valeur sur la broche A1 (tension aux bornes du shunt)
val = analogRead(1);
// Transformation millivolts en ampères
amps = abs(fmap(val, 0.0, 1023.0, 0.0, 6.0));
// envoie, par le port USB, la valeur de la température, pour l'affichage crée sous "processing"
Serial.print("t");
Serial.print(tcapteur);
delay(750);
// envoie, par le port USB, la valeur du courant consommé, pour l'affichage crée sous "processing"
Serial.print("a");
Serial.print(amps);
delay(750);
// attente d'un front bas du PWM pour lire les entrées analogiques
front = 1;
while (front == 1)
{
front = digitalRead(FH);
}
Et maintenant le programme pour la partie affichage sur écran d’ordinateur.
Ce programme est réalisée sous Processing.
Structure du programme
Il se décompose en 4 parties :
- les déclarations
- une routine configuration (setup) exécutée une seule fois,
- le cœur du programme contenu dans la boucle « draw » qui est l'équivalente de la fonction « loop » pour arduino .
- Différentes fonctions :
Les déclarations :
- Définition d’une police de caractères
- affectation de nom aux broches de commande des afficheurs.
PFont f; // STEP 2 Declare PFont variable
import processing.serial.*;
Serial myPort; // Create object from Serial class
int val; // Data received from the serial port
String datas, v; // pour les conversions
int i;
int h1, m1, s1; // heure initiale
int s2; // seconde en cours
int h, m, s; // temps écoulé
String ht, mt , st; // temps écoulé formaté
String inString; // réception chaine du serial port
char afficheur; // afficheur concerné
La fonction "setup()" :
size(600,480);
Panneau(); // appelle la fonction Panneau
// initialise l’heure, minute, seconde
h1 = hour();
m1 = minute();
s1 = second();
s2 = s1; // initialise s2 avec s1
v = "";
textFont(createFont("Georgia", 36)); // Create the font
String portName = Serial.list()[1]; // liste de toutes les variables disponibles
myPort = new Serial(this, portName, 9600); // ouvre le port utilisé à 9600 bauds
myPort.buffer(10); // nombre de datas lues avant de lire à
// nouveau le port
myPort.buffer(10);
La fonction "draw()" :
//Récupère les octets s'il y en a
if (myPort.available() > 0)
{
datas = "";
afficheur = myPort.readChar(); // lit le premier caractère reçu
while (myPort.available() > 0) // tant qu'il y a des données,
{
val = myPort.read(); // les lire et les stocker dans val
datas = datas + char(val); // ajoute les données dans une chaîne.
}
switch(afficheur)
{
case 't' :
t_eau(); // appelle la fonction d'affichage de la T° de l'eau
break;
case 'a' :
amperes(); // appelle la fonction d'affichage du courant instantané
break;
}
}
temps_ecoule(); // appelle la fonction d'affichage du temps écoulé depuis le
// lancement du programme
La fonction "Panneau()" :
- Met un titre aux afficheurs.
background(125);
f = createFont("Arial",16,true);
textFont(f,32);
fill(250);
text("Ampères",50,35);
text("T° eau",440,35);
text("Temps écoulé",330,200);
La fonction "t_eau()" :
- dessine l’afficheur.
- affiche la température
strokeWeight(3);
fill(200);
rect(420, 45, 170, 80, 10);
fill(0);
rect(423, 48, 164, 74, 10);
textFont(f,64);
fill(150,240,30);
text(datas,425,107);
La fonction "ampere()" :
- dessine l’afficheur.
- affiche le courant instantané
strokeWeight(3);
fill(200);
rect(20, 45, 190, 80, 10);
fill(0);
rect(23, 48, 184, 74, 10);
textFont(f,64);
fill(150,240,30);
text(datas,35,107);
La fonction "temps_ecoule()" : (cette fonction n’est pas utile au fonctionnement ni au contrôle du système)
- dessine l’afficheur.
- affiche le temps écoulé depuis la mise en route du chauffage.
strokeWeight(3);
fill(200);
rect(290, 210, 277, 80, 10);
fill(0);
rect(293, 213, 271, 74, 10);
textFont(f,64);
fill(150,240,30);
Temps(); // appel de la fonction "temp()" pour le calcul du temps écoulé
formatage_temps(); // appel de la fonction "formatage_temps()"
text(ht + ":" + mt + ":" + st, 305, 272);
La fonction "temps()" :
- Calcule le temps écoulé.
s1 = second();
if (s1 - s2 == 1)
{
s2 = s1;
s++;
}
else if (s1 - s2 == -59)
{
s2 = 0;
s++;
}
if (s == 60)
{
s = 0;
m++;
if (m == 60)
{
m = 0;
h++;
}
}
La fonction "formatage()" :
- formate le temps pour l’afficher
//formatage des secondes
if (s < 10)
{
st = "0" + str(s);
}
else
{
st = str(s);
}
//formatage des minutes
if (m < 10)
{
mt = "0" + str(m);
}
else
{
mt = str(m);
}
//formatage des heures
if (h < 10)
{
ht = "0" + str(h);
}
else
{
ht = str(h);
}
Il y a quelques erreurs dans la transmission des données.
Certainement une mauvaise programmation de ma part.
* * * * *
Haut de page