open source hardware electromenagers (four electrique, micro onde..... )

ce sujet presentera des projets et programmes finis pour realiser des appareils electromenagers ou la commande sera open source en Arduino

Réparation d’un four électrique avec afficheur LCD et carte Relais.

Voici les schémas électriques de notre carte afficheur avec 4 boutons poussoirs, un relais, 3 leds et un buzzer

voici le typon double face

Cette carte afficheur pourrait etre remplacé par la carte suivante

Mais il n’y a pas le buzzer et seulement 2 boutons poussoirs sur cette carte precedente.

Avec une carte relais qui permet de commander la puissance pour 10 euros de plus.

https://www.amazon.com/Elegoo-Channel-Optocoupler-Arduino-Raspberry/dp/B01HCFJC0Y/ref=pd_lpo_vtph_147_tr_t_2/146-4521376-6542309?_encoding=UTF8&psc=1&refRID=HVQFNKKFXQW1YS31JGWP

Le schéma électrique de la carte relais supplémentaire

http://www.elegoo.com/tutorial/Elegoo%208%20Channel%20DC%205V%20Relay%20Module%20with%20Optocoupler%20for%20Arduino%20UNO%20R3%20MEGA%202560.pdf

Voici le schéma de simulation sous Proteus électronique ISIS qui permet de débuguer le programme.
Telechargeable ici

Attention : le schéma électrique en simulation est très simplifié.

La mesure de la température se fera par l’intermédiaire de PT1000 qui sera simulé par un potentiometre.

Remarque : Le four pouvant atteindre 350°C, il n’est pas possible d’utiliser des capteurs à semi-conducteur LM35 (TO220) par exemple. Il faut souder les fils du capteur avec du fil silicone pouvant supporter la température du fil.

Les capteurs de températures sont relativement chers


Mais il est possible d’en trouver peu onéreux….
http://www.conrad.fr/ce/fr/product/181286/Platine-capteur-de-temprature-PT1000-Heraeus-32209342-70-500-C-sortie-radiale-1-pcs?ref=list
https://www.heraeus.com/media/media/group/doc_group/products_1/hst/m_sensors/us_3/MR_828__845_-e.pdf

Les thermocouples type K coute bien moins cher mais il faut un amplificateur tel que le AD 595 ou AD 8495

Il est possible d’utiliser un CI avec Serial Peripheral Interface pour etre moins bruité.

2 capteurs de températures seront utilisés par sécurité.
De plus, au niveau câblage, Il y a aussi un thermo rupteur à 550°C qui comme l’alimentation de puissance et qui pourrait être diagnostiqué come défaillant par l’Arduino

I Programme TEST du Four et du cablage.

Le premier programme permet juste de vérifier le câblage et le bon fonctionnement des cartes électroniques.

Algorithme ;

* Une routine d’interruption de 1ms est utilisée pour faire une horloge simple mais aussi pour tester le Buzzer

* Lors de l’appuie sur BP1 toutes les leds sont actionnées et les relays.
* Lors de l’appuie sur BP2 toutes les leds sont desactivés ainsi que les relays.
* Lors de l’appuie sur BP3 le buzzer est actionné pendant 1 seconde avec une frequence de 250Hz et commutera le petit relays de la carte afficheur.
* Lors de l’appuie sur BP4 le buzzer est actionné pendant 0.5 seconde avec une frequence de 500Hz.
* L’affichage de la tension du capteur de température sera effectuée (can 10 bits).

Programme test :

#include <LiquidCrystal.h>
#include <SoftwareSerial.h>
#include <TimerOne.h>
 
#define SERIAL_PORT_LOG_ENABLE 1
#define Led13     13       // 13 pour la led jaune sur la carte
#define buzzer    29       // 
#define BP1     30       // 30 BP1
#define BP2     31       // 31 BP2           
#define BP3     32       // 32 BP3
#define BP4     26       // 26 BP4
#define LEDV    33       // 33 led
#define LEDJ    34       // 34 led
#define LEDR    35       // 35 led
#define relay   36       // 36 relay
#define relay1   38 
#define relay2   39 
#define relay3  40 
#define relay4  41
#define relay5  42 
#define relay6  43
#define door    49         
#define PWM10    10      //11   timer2    

LiquidCrystal lcd(27, 28, 25, 24, 23, 22); // RS=12, Enable=11, D4=5, D5=4, D6= 3, D7=2, BPpoussoir=26
// Configuration des variables


unsigned    int temps=0;
            byte seconde=30;
            byte minute=59;
            byte heure=24;
            int tempsbruit=1;
            byte periode=1;
            byte tempsperiode=1;
unsigned int temperature=0;           
           

// the setup function runs once when you press reset or power the board
void setup() {

  pinMode(Led13, OUTPUT);   //led carte arduino
  pinMode(LEDV, OUTPUT);
  pinMode(LEDR, OUTPUT);
  pinMode(LEDJ, OUTPUT);
  pinMode(relay, OUTPUT);
  pinMode(relay1, OUTPUT);
  pinMode(relay2, OUTPUT);
  pinMode(relay3, OUTPUT);
  pinMode(relay4, OUTPUT);
  pinMode(relay5, OUTPUT);
  pinMode(relay6, OUTPUT); 
  pinMode(buzzer, OUTPUT);  //le signal du busser est carré 
 
  digitalWrite(relay1,1); //relays inactif
  digitalWrite(relay2,1); //relays inactif
  digitalWrite(relay3,1); //relays inactif
  digitalWrite(relay4,1); //relays inactif
  digitalWrite(relay5,1); //relays inactif
  digitalWrite(relay6,1); //relays inactif
    
//  digitalWrite(LEDV,LOW);
  Timer1.initialize(1000);           // initialize timer1, and set a 0,1 second period =>  100 000  pour 0.01s  10 000
  Timer1.attachInterrupt(callback);   // attaches callback() as a timer overflow interrupt
  lcd.begin(16, 4);                   //modifier pour un afficheur 20x4
  Serial1.begin(9600); 

  TCCR2B = (TCCR2B & 0b11111000) | 0x01;         //pin 10  32khz    http://playground.arduino.cc/Main/TimerPWMCheatsheet
                                                  //http://www.pobot.org/Modifier-la-frequence-d-un-PWM.html
  //   analogWriteResolution(bits)      https://www.arduino.cc/en/Reference/AnalogWriteResolution

}

// Interruptions  tous les 0.001s fait par le timer1
void callback()  {
temps++;
tempsperiode++;
tempsbruit--;
//clignotement de la led 13  à 500Hz=2/0.001s
//if ((digitalRead(Led13))==1) {digitalWrite(Led13, 0);} else {digitalWrite(Led13, 1);}  
digitalWrite(Led13, !digitalRead(Led13));

//creation d'un signal carré  pour le buzzer                    
if (tempsbruit<=2)
   {digitalWrite(buzzer,0); 
   tempsbruit=1;}
else if (tempsperiode>=periode)
      {  digitalWrite(buzzer, !digitalRead(buzzer));
      tempsperiode=0;} 
 
}//fin routine




///////////////////////////////////////////// Boucle correspondant à la fonction main 
void loop() {  
//scutation des etats  des Boutons Poussoirs
if ((digitalRead(BP1))==1) 
{lcd.setCursor(0,0);   //colonne, ligne,
lcd.print("BP1");
digitalWrite(LEDV,1);   // mettre toutes les leds à active
digitalWrite(LEDR,1);
digitalWrite(LEDJ,1);
digitalWrite(relay1,0);  //relay actif
digitalWrite(relay2,0); 
digitalWrite(relay3,0);  
digitalWrite(relay4,0);  
digitalWrite(relay5,0);  
digitalWrite(relay6,0);  
delay(100);             //attendre pour eviter les rebonds du 
}

if ((digitalRead(BP2))==1) 
{lcd.setCursor(0,0);
lcd.print("BP2");
digitalWrite(LEDV,0);   // desactive toutes les leds
digitalWrite(LEDR,0);
digitalWrite(LEDJ,0);
digitalWrite(relay1,1); //relay inactifs
digitalWrite(relay2,1);  
digitalWrite(relay3,1);  
digitalWrite(relay4,1);  
digitalWrite(relay5,1);  
digitalWrite(relay6,1);  
tone(A5, 2000,500);   //tone(pin, frequency, duration)
delay(100);             
}

if ((digitalRead(BP3))==1) 
{lcd.setCursor(0,0);
lcd.print("BP3");
digitalWrite(relay, !digitalRead(relay));  //inversion de l'etat relay toggle
tempsbruit=1000;  periode=2; //faire un bruit de 500ms avec une frenquence de F=periode*2/0.001s
delay(100);
}

if ((digitalRead(BP4))==0)   //actif à l'etat "0"
{lcd.setCursor(0,0);
lcd.print("BP4");
tempsbruit=500;  periode=1; //faire un bruit de 500ms avec une frenquence de F=periode*2/0.001s
delay(100);
}

if ((digitalRead(door))==1) {lcd.setCursor(0,3);lcd.print("door open"); }
else {lcd.setCursor(0,3); lcd.print("         ");}
   
//gestion de l'heure avec routine d'interruption timer 0.001 seconde
if (temps>=1000) {
seconde++; temps=0;
if (seconde>=60) {minute++; seconde=0; }
if (minute>=60)   {heure++;minute=0; }
if (heure>=25) {heure=0;}


lcd.setCursor(0,1);  //colonne, ligne,
if (heure<10) {lcd.print(" "); }  //decalage
lcd.print(heure);
lcd.print("h");
if (minute<10) {lcd.print(" "); }
lcd.print(minute);
lcd.print("m");
if (seconde<10) {lcd.print(" "); }
lcd.print(seconde);
lcd.print("s");

temperature=analogRead(A0); //mesure temperature toutes les secondes
lcd.setCursor(5,0);  // colonne, ligne,
lcd.print("Nu=");
lcd.print(temperature);
lcd.print("   ");


}//fin if temps>1000
   
} // fin loop

Le programme test est telechargeable sur ce lien mais aussi en fichier attaché

sketch_four_test.ino (5.14 KB)

four V2.doc (399 KB)

II Le programme avec la régulation de la température et la gestion buzzer.

La régulation de température est fait tout ou rien à cause des relais qui sont utilisés pour commander les résistances du four.

Le schéma de modélisation sous Simulink Matlab est le suivant :
Attention le correcteur tout ou rien a une hystérésis de -3°C à +3°C passe d’une puissance nulle à une puissance de 2500W. Cette hystérésis provoque une commutation du relay toutes des 30secondes environ.

Le fichier Simulink de simulation peut être téléchargeable sur ce lien :

L’évolution de la température et de la puissance peuvent être observée sur la figure suivante avec une échelle 1/10 pour la puissance. On peut observer qu’il faut 300secondes pour passer de la température ambiante à la température de 200°C ce qui correspond au temps de préchauffage. Puis, autour de 200°C, il y a la régulation autour des 6°C de l’hystérésis.

Avec une résistance PT1000 qui vaut 1000ohms pour 0°C, l’évolution de la température est une fonction affine qui ne passe pas par 0.
Pour la rendre linéaire, il faudrait utiliser un pont de Wheatstone et un AOP soustracteur ce qui n’est pas notre cas.

Le modele mathématique de la résistance PT1000 s’écrit :
R(T)=R0*(1+a*T) avec T=Température (°C) et Ro(0°C)=1000ohms
R(T)= R0+DR avec DR variation de la résistance en fonction de la température

Sachant que R(100°C)=1385 ohms la valeur du coefficient "a" est de 0.385%
Une résistance de pull up de 1000Ω est utilisée pour avoir la meilleure sensibilité du capteur.

La tension AN0 en fonction et correspond à l’equation suivante :
VAN0=5*( R0+DR)/(2R0+DR)=>5( 0.5+(DR/2R0))
Avec une linéarisation entre 0°C et 300°C, l’équation précédente à la valeur suivante.
VAN0=2.5+0.003
Température (°C)
Avec la conversation analogique => numérique en 10 bits donne l’equation suivante
AN0=512+0.625T(°C) (equ 1)
Par conséquent, la valeur de la température sera déterminée par l’équation suivante
T(°C)=AN0
16/10-819 (equ 2)
Mais en fonction du placement du capteur thermique, il y a des différences entre la théorie et la pratique. Donc, il faut faire quelques points de mesures pour avoir correctement l’équation de l’équation 1 et en déduire l’équation 2.

algorithme :

incrementer ou decrementer de la consigne

cuisson si start=1 par BP4

regulation et actionnement 

decremetation du temps de cuisson et arret lorsque celui –ci est à 0.

Gestion de la lumiere, du refroidisseur exterieur, catalyseur

voici la partie decremetation du temps et la regulation de la temperature

//gestion de l'heure avec routine d'interruption timer 0.001 seconde
if (temps>=1000) {                    //1000 pour etre à la seconde
temps=0;     
if (seconde>=1) {seconde--;}         //decomptage du temps
if (minute>0)   {if (seconde==0) {minute--; seconde=60; }}
if (minute==0)  {if (heure>0)  {heure--;minute=60;} }

lcd.setCursor(0,1);  //colonne, ligne,
if (heure<10) {lcd.print(" "); }  //decalage
lcd.print(heure);
lcd.print("h");
if (minute<10) {lcd.print(" "); }
lcd.print(minute);
lcd.print("m");
if (seconde<10) {lcd.print(" "); }
lcd.print(seconde);
lcd.print("s");

// arret du chauffage+ bruit
if (seconde==0 && minute==0 && heure==0 && start1==1)  
{start1=0;nbrbeep=4;}


temperature=analogRead(A0);      //mesure temperature
lcd.setCursor(6,0);                       // colonne, ligne,
temperature=((temperature*16)/10)-819;    //conversion de la valeur numerique en temperature
lcd.print("T=");
lcd.print(temperature);
lcd.print("   ");

if (start1==1)
{
erreur=(consigne-temperature);    //plus facile de faire des superieur mais c'est pour coller à la modelisation

if (erreur>3) {
digitalWrite(relay1,0);  //relay actif chauffage
digitalWrite(relay2,0);
lcd.setCursor(12,0);
lcd.print("P");          //indique qu'il y a la puissance
              } 
  
if (erreur<-3) {
digitalWrite(relay1,1);  //relay inactif
digitalWrite(relay2,1); 
lcd.setCursor(12,0);
lcd.print("N");          //indique qu'il n'y a pas de puissance
               } 
             
}//fin start1>1

//le catalyseur et le ventillateur exterieur  doit rester en fontion si la temperature >50°C 
if (temperature>50) { digitalWrite(relay4,0); digitalWrite(relay6,0); } 
else  {digitalWrite(relay4,1); digitalWrite(relay6,1); } 

//ligt
if (start1==1 || (digitalRead(door)==1) ) { digitalWrite(relay5,0);} 
else  {digitalWrite(relay5,1);}

Le programme de la regulation est telechargeable sur ce lien suivant ou dans le fichier attaché suivant

L’afficheur 20 caracteres*4 lignes est peu utilisé par ce programme pour l’instant.

III Premiere Conclusion :

Le plus dur est de modifier la carcasse mécanique pour insérer la carte afficheur, pour que ce soit propre de l'exterieur. Par ma part, il faut placer la carte Arduino et l’afficheur dans le flux de la ventilation extérieure pour que celle-ci ne soit pas impacter pas la chaleur du four.
Il faut faire un peu de math pour avoir une linéarisation par partie du capteur.
Puis, des tests doivent etre effectué avec un capteur optique thermique pour connaitre la différence entre la température interne et la température mesurée. Ces tests demandent un peu de temps.
En effet, en fonction du positionnement des capteurs des températures, il y a une différence entre les valeurs théoriques et pratique. Donc il faut corriger l’équation 1 et l’équation 2.
Avec le terminal qui reçoit lorsqu’il y a le relais de puissance sont actionnées et la température mesurée qui sont enregistrées en fichier texte. Puis, lu dans Excel, il est très facile de modéliser le système Afin d’optimiser la commande donc d’affiner la valeur de l’hystérésis

Avec seulement des fonctions condition (if else), le programme précèdent a pu être effectué mais avec les menus du four, la fonction (switch(var) case()) va être primordiale ce qui va alourdir le programme et sa compréhension.

Perspectives :
Maintenant, il reste à faire le programme des menus pour faire les fonctions suivantes (gestion du temps de chauffage, chaleur tournante, grille, pyrolyse….) ainsi que la gestion sécuritaire avec 2 capteurs.
De plus par sécurité, un capteur de fumé serait intéressant au-dessus du catalyseur pour éviter une erreur de programmation du four.
Une notification par Bluetooth pourrait être effectuée sur smartphone pour dire que le préchauffage est fini ou pour indiquer que le temps de cuisson est fini.
Avoir une horloge synchronisée sur le secteur http://f5mna.free.fr/hor_mere_Secteur.htm

En esperant que ce sujet inspire du monde.

Remarque:
la programmation pour un four micro-onde est relativement similaire à celui d’un four encastrable, sauf qu’l n’y a pas de gestion de température donc de la puissance qui est fait par un commutation sur le magnétron.

mais est ce que cela existe des appareil electromenagers vendu dans le commerce avec des cartes Arduino et des programmes Open source ?
rien trouvé en francais ni en anglais.....que des projets jamais aboutis

sketch_four_regulation.ino (6.31 KB)

[b]Four à micro onde sans résistance chauffante[/b]

Lien sur le fonctionnement d’un four à micro-onde et de sa technologie

Schema electrique d’un four de base avec moteur minuterie

Explication schéma électrique :
Si le contact de la minuterie est fermé alors le moteur du plateau tournant, le moteur ventilateur qui refroidit le magnétron, la lampe sont tous alimentés.
Il y a 3 mini rupteurs (interrupteur de position) qui test si la porte est bien fermée pour que le magnétron soit alimentée.
Si le mini rupteur de contrôle ne fonctionne plus, il grille le fusible d’alimentation.
Le moteur de la minuterie actionne le contact de puissance avec une période de 30seconde avec les 4 modes suivant

1 thermostat de sécurité sur le magnétron et 1 autre de cavité est utilisé si le moto ventilateur ne fonctionne plus.
Un relais de pré coupure avec une résistance de 20 ohms permet de minimiser la pointe de courant du transformateur alimentant le magnétron.

On peut observer sur la figure suivante un autre schéma électrique mais commandé par une minuterie électronique.

Le prix d’une minuterie pour micro-onde vaut 120€ ??????
https://www.sos-accessoire.com/pieces-detachees-four-micro-ondes/brandt/?p=2

Le programmateur electronique aussi cher que le mecanique ????

algorithme

Une routine d’interruption de 1ms est utilisée :
- pour faire une horloge avec decompte du temps de chauffe 
- gerer le Buzzer

Lors de l’appuie sur BP1   incrementation de la consigne de puissance (tous les 10%)
Lors de l’appuie sur BP2   incrementation du temps de fonctionnement du micro onde.
Lors de l’appuie sur BP3  decrementation du temps du micro onde.
Lors de l’appuie sur BP4  start/stop

Gestion de la puissance et de l’arret en fin de chauffage

Gestion de l’affichage LCD

Il n’y a que 9cm sur le coté pour pourvoir mettre l’electonique donc un affichage LCD de 16 carateres à du etre utilisé.
On peut observer la gestion de l’afficheur sur la figure suivante qui a permis de simuler le programme.
le capteur de temperature n'est pas utile.

le programme en entier en fichier joint
la partie de la gestion des boutons et de la puissance

//scutation des etats  des Boutons Poussoirs
if ((digitalRead(BP1))==1)   // changement puissance
{power=power+10;
if (power>100) {power=10;}
delay(300);            
}

if ((digitalRead(BP2))==1)    //incremeter le temps
{
seconde=seconde+30;
if (seconde>=60) {minute++; seconde=0; }
if (minute>=60)   {heure++;minute=0; }
if (heure>=25) {heure=0;}
delay(50);                 //permet une incremetation assez lente 
}

if ((digitalRead(BP3))==1)     //decremeter
{
if (seconde>=1) {seconde=seconde-1;}         //decomptage du temps
if (minute>0)   {if (seconde==0) {minute--; seconde=60; }}
if (minute==0)  {if (heure>0)  {heure--;minute=60;} }
delay(50);
}


if ((digitalRead(BP4))==0)   //START STOP
{
if (start1==0) {start1=1;periodepower=0;} else {start1=0;}   //changement d'etat
tempsbruit=500;  periode=2; //faire un bruit de 500ms avec une frenquence de F=periode*2/0.001s
lcd.setCursor(0,2);  //colonne, ligne,
delay(300);
}


//  decompte du temps de chauffage  avec routine d'interruption timer 0.001 seconde
if (temps>=1000 && start1==1 ) {                    //1000 pour etre à la seconde
temps=0;     
if (seconde>=1) {seconde--;}                //decomptage du temps de chauffage
if (minute>0)   {if (seconde==0) {minute--; seconde=60; }}
if (minute==0)  {if (heure>0)  {heure--;minute=60;} }
digitalWrite(Led13, !digitalRead(Led13));  peremet de savoir si la carte arduino compte.
}//fin if temps>1000

// variation de la puissance tout ou rien   avec echauffement par conduction
// le magnetron fonctionne en tout ou rien donc pour chauffer doucement avec une certaine conduction, 
// il faut commander le magnetron avec un rapport cyclique sur une periode de 30s
// power=10% correspond puissance 3s sur 30s donc rapport cyclique de 0.1
if (periodepower>30000)  {periodepower=0;} //periode      
power1=power*300 ;      //power1=100%*300=30000milliseconde=30seconde
// arret si start1 est different de 1 et si le temps est inferieur à la puissance 
if ((periodepower<=(power1)) && (start1==1) && (digitalRead(door)==1)) 
{digitalWrite(relay1,0); digitalWrite(LEDV,1); digitalWrite(LEDR,0);} else  {digitalWrite(relay1,1);digitalWrite(LEDV,0); digitalWrite(LEDR,1);}     

// si la porte est ouverte arret du decomptage et obligation de rajouter sur start ; mais pas obligatoire
//if (digitalRead(door)==0) {start1=0; digitalWrite(relay1,1);}

// arret du chauffage + bruit buzzer
if (seconde==0 && minute==0 && heure==0 && start1==1)  
{start1=0;nbrbeep=4; digitalWrite(relay1,1);}

//gestion de la lumiere
// sur un micro-onde classique des que la porte est ouverte la lumiere s'eteint  mais en programmation
if ((start1==1) || (digitalRead(door)==1))
{ digitalWrite(relay5,0); digitalWrite(LEDJ,1); } else {digitalWrite(relay5,1); digitalWrite(LEDJ,0); }
//pas la peine de passer par le microcontroleur pour le ventillateur de refoidisseur et de du plateau tournant

Conclusions et perspectives

Le prix moyen d’un micro onde est d’environ de 100€. Est-ce que cela vaut le cout de le réparer ?
est ce que de base, s' il avait une carte arduino ce ne serait pas mieux ?
il vaudrait mieux utiliser un arduino micro qu'un arduino mega.....

les fours à micro-onde n'ont a pas de régulation de température, mais une régulation de puissance.
A partir d’un capteur infrarouge, il serait intéressant d’avoir une régulation de la température de l’aliment. Mais, le capteur doit être protégé des micro ondes……

sketch_four_micro_onde.ino (6.98 KB)

Four à micro onde avec carte Arduino Nano

Un Arduino nano va couté bien moins cher qu’une carte Mega.
Attention aux clones arduino Nano, il faudra telecharger le driver ou pilote comme ici appelé USB serial2.0 à cause du circuit CH340.

Pour plus de facilité, il faut mieux prendre 4 boutons poussoirs autocollant en claviers (Touch Pad dimensions : 68 x 20 mm ) avec un fil flexible comme on peut observer sur la figure suivante :

De plus, il suffit d’un seul relais pour commander le four à micro onde, mais ils sont souvent vendu par 5.

Dans ISIS, il n’y a pas de clavier 4 boutons poussoirs, mais il est possible de faire la simulation avec un key pad numérique qui sera actif à l’état « 0 ». Il faudra mettre un petit filtre analogique pour éviter les rebonds. Si en simulation, ce n'est pas necessaire, on les a mis pour ne pas les oublier.

Il est possible de mettre une horloge synchronisée avec la frequence secteur utilisant une routine d’interruption externe et d’afficher l’heure en permanence comme on peut l’observer sur la figure suivante :
Le réglage de l’heure et des minutes sont effectuée en maintenant le bouton poussoir BP1 et BP2.
Fichier ISIS with Arduino nano download :
four micro onde nano V1.DSN - Google Drive

les programmes sont en fichiers attachés
mais voici l'algorithme

Routine interruption externe synchronisé par le 100 hz de la tension reseau via un transformateur 9V
Incrementation horloge

Une routine d’interruption de 1ms est utilisée :
-	temps de decompte du temps de chauffe 
-	gerer le Buzzer

Lors de l’appuie sur BP1   incrementation de la consigne de puissance (tous les 10%)
Lors de l’appuie sur BP2   incrementation du temps de fonctionnement du micro onde.
Lors de l’appuie sur BP3  decrementation du temps du micro onde.
Lors de l’appuie sur BP4  start/stop
Lors de l’appuie sur BP1 et BP2 incrementation des minutes de  horloges   
Lors de l’appuie sur BP1 et BP3 incrementation de l’heure de horloges   

Gestion de la puissance et de l’arret en fin de chauffage

Gestion de l’horloge

Gestion de l’affichage LCD

Perspectives :

Evidemment, lorsqu’il y a une coupure d’électricité, il faudra régler l’heure.
Par contre, en utilisant un module RTC (Real Time Clock) avec une batterie lithium, l’heure sera sauvegardée. (le circuit DS3232 ou DS 1302 peuvent etre simulé sous ISIS)

De plus, étant donné que le clavier à 12 Boutons poussoirs ou à 4 boutons poussoirs est pratiquement au même tarif.
Un clavier 12 boutons permettra de regler l’heure plus facilement ainsi que le temps de chaufage.

Enfin, à la place de gérer le buzzer AC dans la routine d’interruption timer, autant avoir un buzzer DC

Conclusions :

Pour à peine 15 euros, il est possible de remplacer l’électronique d’un micro onde.
Mais il faut passer un peu de temps pour réaliser le programme et avoir quelques connaissances en électricité pour faire le câblage. De plus, il faut un peu de temps en mécanique pour refaire un beau tableau avec l’afficheur et les boutons poussoirs de l’appareil électroménager.

four_micro_onde_nano_horloge.ino (6.92 KB)

sketch_four_micro_onde_nano.ino (6.18 KB)

Four à micro-onde avec Arduino avec RTC 1302 et LCD

Il y a des sites comme celui-ci qui explique le fonctionnement du real Real Time Clock

On n’est pas obligé de mettre les alimentations et le quartz pour que cela fonctionne en simulation sur avec le logiciel ISIS comme on peut l’observer sur la figure suivante :

Il faut telecharger la biblotheques virtuabotixRTC.h

Evidemment, la date ne nous intéresse pas mais c’était pour l’exemple.
Voici le programme qui permet de mettre à l’heure avec le clavier BP1.

//This code is to use with DS1302 RTC module, it permits you to setup the actual time and date
//And you can visualize them on the serial monitor
//This code is a modified version of the code provided in virtuabotixRTC library
//Refer to Surtrtech Youtube chhannel/Facebook page for more information

#include <LiquidCrystal.h>
#include  <virtuabotixRTC.h>  //Library used

virtuabotixRTC myRTC(2, A2, A3); //Wiring      virtuabotixRTC myRTC(SCLK, I/O , CE or  Reset)

LiquidCrystal lcd(3, 8, 4, 5, 6, 7);   // LiquidCrystal lcd(rs, en, d4, d5, d6, d7);

#define BP1     11       

void setup() {
  Serial.begin(9600);
  lcd.begin(16, 2);  
  // Set the current date, and time in the following format:
            // seconds, minutes, hours, day of week, day of the month, month, year
 myRTC.setDS1302Time(15, 22, 23, 7, 14, 1, 2018);  //Here you write your actual time/date as shown above 
}

void loop() {

myRTC.updateTime();          // This allows for the update of variables for time or accessing the individual elements.     

lcd.setCursor(0,0);  //colonne, ligne,
if (myRTC.hours<10) {lcd.print(" "); }  //decalage
lcd.print(myRTC.hours);
lcd.print("h");
if (myRTC.minutes<10) {lcd.print(" "); }
lcd.print(myRTC.minutes);
lcd.print("m");
if (myRTC.seconds<10) {lcd.print(" "); }
lcd.print(myRTC.seconds);
lcd.print("s");

//changement de l'heure en appuyant sur BP1
if ((digitalRead(BP1))==0) 
{myRTC.minutes++;
if (myRTC.minutes>=60)  {myRTC.hours++; myRTC.minutes=0;   }
if (myRTC.hours>=24)    {myRTC.hours=0;   }
 myRTC.setDS1302Time(15, myRTC.minutes, myRTC.hours, 7, 14, 1, 2018);
}


  // Delay so the program doesn't print non-stop
  delay(100);
}

Pour le programme du four du micro-onde avec le DS 1302
Il n’y a pas de probleme que l'on peut telecharger en fichier attaché

Conclusions :

Voila 3 programmes pour le four à micro onde qui sont des bases de programmation et qui permettent de faire un programme de presque n’importe quels materiels electromenagers.
Le dernier programme avec DS1302 permettrait de faire un reveil, un programmateur universel....

RTC_DS1302_four.ino.ino (6.57 KB)

RTC_DS1302_clavier.ino (1.97 KB)

Réveil avec buzzer et afficheur LCD. (alarm clock)

Pas si facile de réparer un radio reveil. Par contre assez facile de faire un réveil, mais pour faire une mélodie, il faut tester le buzzer car à cause de sa bande passante et des harmoniques du signal carré, la note qui sort du buzzer peut etre celle de l’harmonique mais ne correspondra pas à celle de la fondamentale
Puis, il y a la gestion du temps et celle de l’heure ou l’on veut la melodie ou l’alarme.

Voici le programme du test du buzzer à partir 4 boutons poussoirs sachant que chaque note de musique suit l’équation mathématique suivante :
Note =32.7 Hz*2^(N/6) avec chaque gamme correspondant à 6 notes.
avec ce programme, il est possible avec un decibelmetre de mesurer la puissance du buzzer utilisé pour chaque frequence

remarque ;
tone() utilise le timer 2 et delay() utilise le timer 0 ainsi que la fonction Millis(). mais avec une routine d'interruption timer, il n'y a pas besoin de delay dans le programme.

Algorithme du test du buzzer

Une routine d’interruption de 1ms  utilisée par le timer 1 :
- gestion d’un signal 500Hz, 250hz, 166 Hz, 125Hz, 100Hz….

Lors de l’appuie sur BP1   genere toutes les notes de musique de 32.7Hz à 7900Hz de façon automatique avec un temps de 1 seconde
Lors de l’appuie sur BP2   fait juste un bruit de 2KHz pendant 0.5s
Lors de l’appuie sur BP3  fait une melody avec frequence et durée differente 
Lors de l’appuie sur BP4  fait un bruit à partir du timer

Affichage  l’heure sur le  LCD grace au timer 1.

le programme de test du buzzer

// include the library code:
#include <LiquidCrystal.h>
#include <SoftwareSerial.h>
#include <TimerOne.h>
 
#define SERIAL_PORT_LOG_ENABLE 1
#define Led13     13       // 13 pour la led jaune sur la carte
#define buzzer    A5       // 
#define BP1       11       //  Bouton Poussoir 
#define BP2       10       //            
#define BP3        9       // 
#define BP4       12       // 
#define LEDV      A4          // 

#define horloge   2
 
#define relay1    A0      //relay magnetron
#define door      A1      // capteur porte fermée 

LiquidCrystal lcd(3, 8, 4, 5, 6, 7);   // LiquidCrystal lcd(rs, en, d4, d5, d6, d7);
// Configuration des variables


unsigned    int temps=0;
            byte seconde=30;
            byte minute=59;
            byte heure=24;
            int tempsbruit=1;
            byte periode=1;
            byte tempsperiode=1;
            byte thisNote=0;
int melody [ ] = {  523, 587, 658, 740, 830, 931, 1026, 1174, 1318, 1480   };    
int Durations[] ={  1000, 2000, 3000, 500, 750, 500, 500,   500, 500 ,  500   };  
//1 ronde = 1 seconde, 1 blanche = 0.5s, 1 noire =0.25s, 1 croche =0.125s         
            float var=1;
            float var1=1;
            float expo=0.1666;
            float N=1;
// the setup function runs once when you press reset or power the board
void setup() {

  pinMode(Led13, OUTPUT);   //led carte arduino
  pinMode(LEDV, OUTPUT);
//  pinMode(LEDR, OUTPUT);
//  pinMode(LEDJ, OUTPUT);
//  pinMode(relay, OUTPUT);
  pinMode(relay1, OUTPUT);

//  digitalWrite(LEDV,LOW);
  Timer1.initialize(1000);           // initialize timer1, and set a 0,1 second period =>  100 000  pour 0.01s  10 000
  Timer1.attachInterrupt(callback);   // attaches callback() as a timer overflow interrupt
  lcd.begin(16, 2);                   //modifier pour un afficheur 20x4
 // Serial1.begin(9600); 

  TCCR2B = (TCCR2B & 0b11111000) | 0x01;         //pin 10  32khz    http://playground.arduino.cc/Main/TimerPWMCheatsheet
                                                  //http://www.pobot.org/Modifier-la-frequence-d-un-PWM.html
  //   analogWriteResolution(bits)      https://www.arduino.cc/en/Reference/AnalogWriteResolution

}

// Interruptions  tous les 0.001s fait par le timer1
void callback()  {
temps++;
tempsperiode++;
tempsbruit--;



//creation d'un signal carré  pour le buzzer                    
if (tempsbruit<=2)
   {digitalWrite(buzzer,0); 
   tempsbruit=1;}
else if (tempsperiode>=periode)
      {  digitalWrite(buzzer, !digitalRead(buzzer));
      tempsperiode=0;} 
 
}//fin routine




///////////////////////////////////////////// Boucle correspondant à la fonction main 
void loop() {  
//scutation des etats  des Boutons Poussoirs

if ((digitalRead(BP1))==1) 
{lcd.setCursor(0,0);   //colonne, ligne,
lcd.print("BP1");
lcd.print("    ");
digitalWrite(LEDV,1);   // mettre toutes les leds à active
digitalWrite(relay1,0);  //relay actif
N++;
var=pow (2, expo*N);        // 2 exposant  expo*N
lcd.setCursor(10,1);
var1=var*32.7;             //32.7Hz  voir note de musique wilipedia
lcd.print(var1,0);
tone ( A5 ,var1  , 1000 ) ;
if (N>=48)  {N=0;lcd.setCursor(10,1);lcd.print("    ");}  //balaye toute les note de 37hz à 7900 hz
delay(1000);             //attendre pour eviter les rebonds du 
}

if ((digitalRead(BP2))==1) 
{lcd.setCursor(0,0);
lcd.print("BP2");
digitalWrite(LEDV,0);   // desactive toutes les leds
digitalWrite(relay1,1); //relay inactifs
tone(A5, 2000,500);   //tone(pin, frequency, duration)
delay(200);             
}

if ((digitalRead(BP3))==1) 
{lcd.setCursor(0,0);
lcd.print("BP3");
digitalWrite(relay1, !digitalRead(relay1));  //inversion de l'etat relay toggle
for ( byte thisNote = 0 ; thisNote <= 9 ; thisNote ++ ) {
  tone ( A5 , melody [ thisNote ] , Durations[thisNote] ) ; 
  lcd.setCursor(10,0);
  lcd.print(melody [ thisNote ]);
  lcd.print("  ");                                                                                                   
  delay(Durations[thisNote]);                           }
}

if ((digitalRead(BP4))==0)   //actif à l'etat "0"
{lcd.setCursor(0,0);
lcd.print("BP4");
tempsbruit=2000;  periode=1; //faire un bruit de 500ms avec une frenquence de F=periode*2/0.001s
delay(200);
}


   
//gestion de l'heure avec routine d'interruption timer 0.001 seconde
if (temps>=1000) {
seconde++; temps=0;
if (seconde>=60) {minute++; seconde=0; }
if (minute>=60)   {heure++;minute=0; }
if (heure>=25) {heure=0;}

lcd.setCursor(0,1);  //colonne, ligne,
if (heure<10) {lcd.print(" "); }  //decalage
lcd.print(heure);
lcd.print("h");
if (minute<10) {lcd.print(" "); }
lcd.print(minute);
lcd.print("m");
if (seconde<10) {lcd.print(" "); }
lcd.print(seconde);
lcd.print("s");
lcd.print(" ");


//if (thisNote>8) {thisNote=0; }

//test que le programme tourne
if ((digitalRead(Led13))==1) {digitalWrite(Led13, 0);} else {digitalWrite(Led13, 1);} 
}//fin if temps>1000



   
} // fin loop

la simulation du programme de test du buzzer sous ISIS en image

le programme complet du réveil arrive

sketch_LCD_test.ino (4.47 KB)

Suite aux conclusions précédentes, voici un programme de réveil open source :

Cette 1ére version permet de régler l’heure et l’alarme. Elle offre aussi la possibilité d’activer ou non l’alarme.
L’alarme s’éteint au bout d’une minute. On peut aussi arrêter l’alarme plus tôt par appuie sur le bouton BP4.
Voici l’affichage du programme sur l’écran LCD :

Nous souhaitons utiliser la fonction « tone » qui se sert du timer2 et un allumage progressif d’une LED 3 Watt qui permet de se réveiller en douceur mais qui utilise le timer0. Donc, le programme devra se passer de la fonction « delay » car celle-ci utilise le timer0.
Par conséquent, nous utilisons le timer1 pour l’horloge.

Voici une photo de la simulation de ISIS ou il y a le réveil à partir de 5 minutes.

Voici le programme

// include the library code:
#include <LiquidCrystal.h>
#include <SoftwareSerial.h>
#include <TimerOne.h>

#define SERIAL_PORT_LOG_ENABLE 1
#define Led13     13       // 13 pour la led jaune sur la carte
#define buzzer    A5       // A5 pour le buzzer
#define BP1       11       // Bouton Poussoir 
#define BP2       10                   
#define BP3        9       
#define BP4       12        
#define LEDV      A4       // A4 pour la led verte


#define horloge   2
#define LEDPWM   5

LiquidCrystal lcd(3, 8, 4, A1, 6, 7);   // LiquidCrystal lcd(rs, en, d4, d5, d6, d7);

// Configuration des variables

unsigned    int  temps=0;
            byte seconde=50;
            byte minute=4;
            byte heure=0;
            int  tempsbruit=1;
            byte periode=1;
            byte tempsperiode=1;
            byte Alarm_ON=0;
            byte heure_Alarm=0;    
            byte minute_Alarm=5;
            int tempsdelay=0;
            byte luminosite=0;
            
void setup() 
{

  pinMode(Led13, OUTPUT);             //led carte arduino
  pinMode(LEDV, OUTPUT);  
  pinMode(LEDPWM, OUTPUT);               

  Timer1.initialize(1000);            // initialize timer1, and set a 0,1 second period =>  100 000  pour 0.01s  10 000
  Timer1.attachInterrupt(callback);   // attaches callback() as a timer overflow interrupt
  lcd.begin(16, 2);                   // modifier pour un afficheur 20x4 




}


// Interruptions  tous les 0.001s fait par le timer1
void callback()  
{  
  temps++;  
  tempsdelay++;
}
//fin routine

void loop() 
{

  //gestion de l'heure avec routine d'interruption timer 0.001 seconde
  if (temps>=1000) 
  {
    
    seconde++; temps=0;                                                 // Gestion temps : heure, minute, seconde
    if (seconde>=60) {minute++; seconde=0; }
    if (minute>=60)   {heure++;minute=0; }
    if (heure>=24) {heure=0;}

    if (minute_Alarm >= 60) {heure_Alarm++; minute_Alarm=0;}            // Gestion temps alarme : heure, minute
    if (heure_Alarm>=24) {heure_Alarm=0;}

                                                                        // Affichage heure
    lcd.setCursor(4,0);                 //colonne, ligne
    if (heure<10) {lcd.print(" "); }    //decalage
    lcd.print(heure);
    lcd.print("h");
    if (minute<10) {lcd.print(" "); }
    lcd.print(minute);
    lcd.print("m");
    if (seconde<10) {lcd.print(" "); }
    lcd.print(seconde);
    lcd.print("s");
    lcd.print(" ");


    lcd.setCursor(0,1);                                                 // Affichage heure de l'alarme
    if (heure_Alarm<10) {lcd.print(" "); }  //decalage
    lcd.print(heure_Alarm);
    lcd.print("h");
    if (minute_Alarm<10) {lcd.print(" "); }
    lcd.print(minute_Alarm);
    lcd.print("m");
    lcd.print(" ");

    if (Alarm_ON==1)                                                    // Gestion affichage Alarm_ON / OFF
    {
      lcd.setCursor(7,1); 
      lcd.print("Alarm_ON "); 
    }
    else 
    {
      lcd.setCursor(7,1); 
      lcd.print("Alarm_OFF"); 
    }
  
    if ((digitalRead(Led13))==1) {digitalWrite(Led13, 0);} else {digitalWrite(Led13, 1);}               //test que le programme tourne
    
  }                                                                                                     //fin if temps>1000



  if ((digitalRead(BP1))==1 && (digitalRead(BP2))==1)                     // Gestion incrémentation heure
  {
    minute++; 
    tempsdelay=0;
    while (tempsdelay<=100) { lcd.setCursor(0,0); lcd.print(" "); }
  }

 
  if ((digitalRead(BP1))==1 && (digitalRead(BP3))==1)                     // Gestion décrémentation heure
  {
    if (minute==0 && heure==0)
    {
      heure=23;
      minute=59;
    }
    
    if (minute==0)                                          
    {                                                        
      minute=59;
      heure--;
      
      tempsdelay=0;   
      while (tempsdelay<=100) { lcd.setCursor(0,0); lcd.print(" "); }              
    }

    minute--;
    
    tempsdelay=0;       
    while (tempsdelay<=100) { lcd.setCursor(0,0); lcd.print(" "); }
  }

  if ((digitalRead(BP4))==0 && (digitalRead(BP2))==1)                   // Gestion incrémentation heure de l'alarme
  {
    minute_Alarm++;
    tempsdelay=0;   
    while (tempsdelay<=100) { lcd.setCursor(0,0); lcd.print(" "); }
  }

  if ((digitalRead(BP4))==0 && (digitalRead(BP3))==1)                   // Gestion décrémentation heure de l'alarme
  {   
    if (minute_Alarm==0 && heure_Alarm==0)
    {
      heure_Alarm=23;
      minute_Alarm=59;
    }
    
    if (minute_Alarm==0)                                          
    {                                                        
      minute_Alarm=59;
      heure_Alarm--;                 
    }
    
    minute_Alarm--;
    
    tempsdelay=0;                                                       // tempsdelay : permet d'eviter l'utilisation de delay
    while (tempsdelay<=100) { lcd.setCursor(0,0); lcd.print(" "); }
  }

  if ((digitalRead(BP4))==0)                                            // Gestion ativation alarme par appuie sur BP4
  {
     if (Alarm_ON==0) { Alarm_ON=1; }
     else { Alarm_ON=0; }
     tempsdelay=0;
     while (tempsdelay<=500) { lcd.setCursor(0,0); lcd.print(" "); }
     noTone(A5);
  }

  if (heure==heure_Alarm && minute==minute_Alarm && Alarm_ON==1)            // Gestion Alarme d'une durée de 1 minute, s'arrete avant si appuie bouton BP4
  { 
    //tone(A5, 1000);                                                         //tone(pin, frequency)
    analogWrite(LEDPWM, luminosite);
    luminosite++;
    tempsdelay=0;                                                       
    while (tempsdelay<=100) { lcd.setCursor(0,0); lcd.print(" "); }          // Luminosite de la led passe de 0 à 255 en 5 minutes                 
  }

}

Conclusions :
Dans le programme précédent, la PWM de la LED 3 watt est à 100%.
Une PWM progressive de 5 minutes pour se réveiller en « douceur » serait plus pertinente.
Perspectives :
La mélodie est à finaliser. De plus, à la place d’utiliser un buzzer, il serait plus intéressant d’avoir un petit haut-parleur avec un ampli pour avoir un meilleur son.

Cela prend du temps de retranscrire des partitions pour faire une melody
Mais heureusement, il y a déjà pas mal de melody qui sont retranscrit sur internet

Voici le programme de la mélodie de star war tout en sous-programme pour pouvoir l’intégré dans le réveil précèdent.

#include <LiquidCrystal.h>
 
const int c = 261;
const int d = 294;
const int e = 329;
const int f = 349;
const int g = 391;
const int gS = 415;
const int a = 440;
const int aS = 455;
const int b = 466;
const int cH = 523;
const int cSH = 554;
const int dH = 587;
const int dSH = 622;
const int eH = 659;
const int fH = 698;
const int fSH = 740;
const int gH = 784;
const int gSH = 830;
const int aH = 880;
 
const int buzzerPin = A5;
 
  LiquidCrystal lcd(3, 8, 4, 5, 6, 7);     // LiquidCrystal lcd(rs, en, d4, d5, d6, d7);
 
void setup()
{
  //Setup pin modes
  pinMode(buzzerPin, OUTPUT);
 lcd.begin(16, 2);  
}

 
void firstSection()  //melody de star war
{
  beep(a, 500);
  beep(a, 500);    
  beep(a, 500);
  beep(f, 350);
  beep(cH, 150);  
  beep(a, 500);
  beep(f, 350);
  beep(cH, 150);
  beep(a, 650);
 
  delay(500);
 
  beep(eH, 500);
  beep(eH, 500);
  beep(eH, 500);  
  beep(fH, 350);
  beep(cH, 150);
  beep(gS, 500);
  beep(f, 350);
  beep(cH, 150);
  beep(a, 650);
 
  delay(500);
}
 
void secondSection()
{
  beep(aH, 500);
  beep(a, 300);
  beep(a, 150);
  beep(aH, 500);
  beep(gSH, 325);
  beep(gH, 175);
  beep(fSH, 125);
  beep(fH, 125);    
  beep(fSH, 250);
 
  delay(325);
 
  beep(aS, 250);    //250
  beep(dSH, 500);
  beep(dH, 325);  
  beep(cSH, 175);  
  beep(cH, 125);  
  beep(b, 125);     //125
  beep(cH, 250);  
 
  delay(350);
}


void loop()
{
firstSection();      //Play first section star war
 
secondSection();     //Play second section
}
 
void beep(int note, int duration)  //sous programme
{
  //Play tone on buzzerPin
  tone(buzzerPin, note, duration);
lcd.setCursor(0,0);   //colonne, ligne,
lcd.print(note);
lcd.print(" ");
lcd.print(duration);
delay(duration);

//Stop tone on buzzerPin
noTone(buzzerPin);
 
delay(50);  //temps entre 2 notes
 
}

Conclusions ;
Pour améliorer la qualité du son, un petit haut –parleur avec un empli de 5Watt sera bien mieux que le buzrer

Il est aussi possible d'utiliser un clavier en le branchant sur arduino. Cela va nous permettre de sélectionner la valeur voulue rapidement.

écran LCD + clavier matricielle


Arduino DUE

Nous avons réalisé un programme de test

#include <Keypad.h>
#include <LiquidCrystal.h>

const byte ROWS = 4; //four rows
const byte COLS = 3; //three columns
char keys[ROWS][COLS] = {
  {'1','2','3'},
  {'4','5','6'},
  {'7','8','9'},
  {'*','0','#'}
};
byte rowPins[ROWS] = {8, 7, 6, 5}; //connect to the row pinouts of the keypad
byte colPins[COLS] = {4, 3, 2}; //connect to the column pinouts of the keypad

Keypad keypad = Keypad( makeKeymap(keys), rowPins, colPins, ROWS, COLS );


LiquidCrystal lcd(27, 28, 25, 24, 23, 22);

void setup() {
  // put your setup code here, to run once:
lcd.begin(40,2);
}

void loop() {
  // put your main code here, to run repeatedly:
char key = keypad.getKey();
  if (key != NO_KEY){
    lcd.setCursor(0,1);
    lcd.print(key);}
}

Ce code permet de choisir le numéro qui est affiché sur l'écran LCD

byte rowPins[ROWS] = {8, 7, 6, 5}; //déclare les pins sur lesquels les broches doivent être connecté pour les lignes
byte colPins[COLS] = {4, 3, 2}; //déclare les pins sur lesquels les broches doivent être connecté pour les colonnes

clavier.ino (731 Bytes)

Suite au conclusion précédentes voici l'affichage des différent menus, la sélection de la température, sélections du temps de cuissons avec activation et désactivation des relais (uniquement selon le temps et non la température)

Nous avons utilisé une Arduino Méga 2560 et un écran LCD de 20x4

Voici l’algorithme du programme:

algo:

Lors de l'appuie sur BP1   séléction du menu (liste en boucle)
Lors de l'appuie sur BP2   incrémentation de la valeur en cours de modification (température, temps de cuissons)
Lors de l'appuie sur BP3   décrémentation de la valeur en cours de modification (température, temps de cuissons)
Lors de l'appuie sur BP4   validation du choix pour température (active a 0L)
Lors de l'appuie sur BP5   validation du choix pour temps de cuisson (active a 0L)

ordre de séléction:

BP1 menu validation 
BP4 pour choix température
BP5 pour choix du temps
dés que le temps de cuisson est > 0 alors activation des relay et message "GO" pour indiqué que c'est en cours 
lorsque le temps de cuissons arrive a 0 le buzzer sonne


les different flag:

flag1 // front montant de BP1
flag4 et flag 5 // à chaque appuis de BP4 ou BP5 flag4, flag5 change respectivement d'état
flagTemps //indication que le temps de cuisson a été modifié

c'est deux dernier flag permettent d'aller et venir dans le menu du choix de la température et de du temps par le même bouton

Affichage  l'heure sur le  LCD grace au timer 1.
décrémentation du temps de cuisson séléctionné grace au timer 1.

j'ai rajouté une petite touche personnel qui est le déplacement vers la gauche d'un texte de bienvenu pour l’esthétique

le programme se trouve attaché au post

L'ajout d'un bouton fut obligatoire pour sélectionner le temps de cuisson.
Sinon la structure du programme est plutot classique, un simple switch case pour les différent menus et des If pour la sélection de sous menus (température, temps).
J'ai utilisé des flag comme expliqué dans l’algorithme pour pouvoir aller et venir dans un sous menu via le même bouton, on peut donc revenir a tout moment a la sélection du menu
Pour des raisons obscure et mystérieuses la sélection du temps ne s'effectue pas lorsque elle se fait via un sous programme, j'ai donc été obligé de l'intégré dans les différent switch cases.
La gestion des relais a été effectué mais uniquement selon le temps de cuisson, c'est à dire quand le temps de cuisson sélectionné est différent de 0 alors les relais s'activent et se désactive lorsque que temps est écoulé où une alarme résonne pendant 1s.
Pour la décrémentation je n'ai pas ajouter de Timer, j'ai utilisé le même Timer que celui de l'horloge, j'ai simplement ajouté un If à part avec des conditions différetes pour que la décrémentation se fasse au dixième de seconde près (selon si la modification du temps de cuissons se fait au début ou a la fin de la seconde en cours).

Voici quelques images des différents menu:

Conclusion:

il est possible d'intégrer un clavier numérique afin de sélectionner la température et le temps directement
il faut contrôler les relais selon la température interne du four
possiblement modifié l'affichage pour que cela soit plus universelle pour les différentes taille d’écran LCD et qu'il soit plus ergonomique

algo.txt (2.59 KB)

selection_menus.ino (15.1 KB)

1 Like

Bonjour , c'est vraiment un superbe boulot ......petit bémol , pour le micro ondes je suis très réservé , il ne faut pas qu'il puisse fonctionné porte ouverte , sur les micro ondes classique , il y à plusieurs rupteurs (fin de courses) qui protèges l'utilisateur , de façons à empêcher le fonctionnement du magnétron si la porte est ouverte.

J'ai dépanner plus de 12 ans de l’électroménager pro (en cuisine pro) avec des très gros magnétron , ce n'est pas de la rigolade , je me rappelle que les fins de courses étaient calibrés en ouverture et fermeture de sorte qu'une ouverture de porte litigieuse provoque un court circuit franc pour faire fondre le fusible de la commande et ainsi mettre l'utilisateur en sécurité .

Je ne remet pas en question ton travail , c'est juste une mise en garde , les micro ondes , c'est dangereux ......

Bonne continuation .

il n'y a pas que l'electromenager, il y a aussi tous les produits de la santé sur le marché en ce moment...

un dossier a été fait avec un arduino et un capteur cardio et oxygneation du sang.
en voici , un premier jet

Il y un grand nombre de site qui inique comment réparer sa cafetière Senseo

Il y a un grand nombre de site qui propose de remplacer l’électronique propriétaire par un Arduino

Étant donné que l’on n’avait pas de Senseo sous la main, on a placé un Arduino sur une cafetière basique qui gère un programmateur

Voici le dossier d’étude

et voici le programme

#include <LiquidCrystal.h>
#include <DS1302.h>

// Init DS1302
DS1302 rtc(A3, A2, 2); // Déclaration de broches du DS1302
Time t;
int LM35 = A1; //LM35 brancher en A1
int chauf;
int temps = 0; // variable temps
int relai = 9; //broche associé au relai
float temperature; //variable de température
int bouton = 10; //broche du bouton
LiquidCrystal lcd(3,8,4,5,6,7); // liaison 4 bits de données
void setup() {
  Serial.begin(9600); 
  pinMode(bouton,INPUT); //bouton définit en entrée
  pinMode(relai,OUTPUT); //relais en sortie
  pinMode(LM35, INPUT); //LM35 en entrée
  lcd.begin(16,2); //initialisation de l'écran LCD
  rtc.halt(false);
  rtc.writeProtect(false);
}

void loop() {
  bool boutton = digitalRead(bouton); //recherche d'un appui sur le bouton
if(boutton == 0) //Si bouton est appuyé
{
  lcd.setCursor(0,0);
  lcd.println("Le cafe");
  lcd.setCursor(0,1);
  lcd.println("se prepare"); //Afficher "le café se prépare"
  delay(2000);
  temps = 0;
  while(temps<=1500) //Boucle tant que pour atteindre environs 5 minutes pour le café
  {
  int valeur_brut = analogRead(LM35);  //lecture de la broche LM35 afin de déterminer la température
  temperature = valeur_brut * (5.0 / 1023.0 * 100.0); //Conversion de la valeur numérique en une valeur exploitable
  if(LM35 <= 75) //Si le capteur est à moins de 75°C allume le relai
  {
  digitalWrite(relai,HIGH);
  temps = temps + 1;
  delay(200);
  int valeur_brut = analogRead(LM35);
  }
  if(LM35 >= 75) //Si le capteur est au dessus des 75°C éteint le relai
  {
  digitalWrite(relai,LOW);
  
  temps = temps + 1;
  delay(200);
  int valeur_brut = analogRead(LM35);
  }
  }
  digitalWrite(relai,LOW); // Afficher "Votre café est prêt"
  lcd.clear();
  lcd.setCursor(0,0);
  lcd.print("votre cafe");
  lcd.setCursor(0,1);
  lcd.print("est prêt");
  delay(5000);
  lcd.clear(); //nettoie l'écran pour ne plus rien afficher
}
if(boutton == 1)
{
  t = rtc.getTime(); //affichage de l'heure exact grâce au DS1302
  lcd.print(t.hour, DEC); //heure
  lcd.print("h ");
  lcd.print(t.min, DEC); //minute
  lcd.print("m ");
  lcd.println(t.sec, DEC); //seconde
}
delay(1000);
lcd.clear();
}
1 Like

Remplacer un thermostat propriétaire de radiateur électrique par un Arduino est très facile en programmation…..
En effet, c’est un peu idiot de jeter un radiateur, juste parce que la régulation de température ne fonctionne plus. Mais souvent, il est impossible de retrouver l’électronique du thermostat du fabricant
Pourtant, sur le net, on ne trouve pas de programme de régulation
Voici ce que j’ai trouvé…..cela manque d’information
https://www.studentcompanion.net/fr/systeme-de-controle-automatique-de-la-temperature-utilisant-arduino-flowcode/

Par contre, nombreux programmes pour la commande de radiateur par fil pilote, délestage, et commande par smartphone

Voici, un programme de base de la régulation tout ou rien d’un radiateur électrique avec un relais et un potentiomètre qui donne la consigne réglable de température. Un hystérise de 1°C sera utilisé. C’est-à-dire que si la température mesurée ambiante est supérieur à 1°C alors le relais sera coupé.
Le potentiomètre règlera la température désirée qui sera appelé consigne (1V correspondra à10°C)
Un Bouton poussoir mettra on ou off le radiateur

L’algo de la régulation est relativement simple

Lire l’information de température du capteur LM35
Lire la consigne 
Si la température mesurée<temperature de consigne   alors resistance radiateur alimenté donc relais on
Si par le bluetooth (vitual terminal) le caractere 1 est envoyé alors la reulation est en route.
Par contre, si le bluetooth reçoit 0 alors la regulation est sur off

Voici le schéma de la simulation sous ISIS

Voici le code

#include <Wire.h>
#include <LiquidCrystal.h>
#include <SoftwareSerial.h>
#include <TimerOne.h>

#define BP2        2      //
#define relais    A3       //  
#define LED13     13       
LiquidCrystal lcd(9, 8, 4, 5, 6, 7);   // LiquidCrystal lcd(rs, en, d4, d5, d6, d7);

unsigned    int    temps=0; 
            bool flagON=0;
            byte communication=0;
float temperature;
float consigne;

            

void setup() {
  pinMode(LED13, OUTPUT);
  pinMode(relais, OUTPUT);
  pinMode (BP2, INPUT_PULLUP);


  Timer1.initialize(1000000);           //  
  Timer1.attachInterrupt(callback);   // attaches callback() as a timer overflow interrupt
  lcd.begin(16, 4);                   //modifier pour un afficheur 20x4
  
  Serial.begin(9600); 
  TCCR2B = (TCCR2B & 0b11111000) | 0x01;         //pin 3  32khz    http://playground.arduino.cc/Main/TimerPWMCheatsheet

//attachInterrupt(0, interrup2, FALLING);   // broche2
 
  lcd.setCursor(0,0);    
  lcd.print("thermostat radia");

}


/*void interrup2() // la fonction appelée par l'interruption externe n°0
{

}*/

// Interruptions  tous les 1s ***********************************
void callback()  {
if ( digitalRead(13)== 1 ) {digitalWrite(13,LOW);}  else {digitalWrite(13,HIGH);}
//digitalWrite(LED13,HIGH);     
temperature=analogRead(A2);     
temperature=(temperature/2); 

consigne=analogRead(A1);                
consigne=(consigne/20.4);                                                                            
        
//digitalWrite(13,LOW);
temps++;
if (temps>=5)   { Serial.print(temperature);Serial.println(";");temps=0; }   //affiche sur le virtal terminal 

}//fin routine


///////////////////////////////////////////// Boucle correspondant à la fonction main 
void loop() {  

lcd.setCursor(0,1);
lcd.print("T:");
lcd.print(temperature);
lcd.print((char)223);
lcd.print("C "); 

 lcd.setCursor(0,2);
 lcd.print("C:");
 lcd.print(consigne);
lcd.print((char)223);
lcd.print("C "); 

if (digitalRead(BP2)==0  &&  flagON==0)  {flagON=1;digitalWrite(relais,LOW);delay(200);}   
if (digitalRead(BP2)==0  &&  flagON==1)  {flagON=0;delay(200);  }

if (flagON==1) {lcd.setCursor(0,3); lcd.print("ON ");
//hysteresis plus ou moins 1 degres
if (temperature<(consigne-1))  {digitalWrite(relais,HIGH); } 
if (temperature>(consigne+1))  {digitalWrite(relais,LOW); } 
                }
if (flagON==0) {lcd.setCursor(0,3); lcd.print("OFF");digitalWrite(relais,LOW); }    

if (Serial.available()>0){          //lecture  le virtual terminal
      communication=Serial.read();Serial.println(";");  
      if (communication==48) {flagON=0; }   //48 correspond au caratere ascii de 0
      if (communication==49) {flagON=1; }
                        }
                
} // fin loop

Evidemment, on peut remplacer le relais par un triac qui permet d’alimenter la résistante du radiateur lorsque la tension AC 220V est nulle pour ne pas faire de pic de courant dans la résistance du radiateur qui provoque des perturbations électromagnétiques.
Evidemment, il est possible de faire une horloge pour faire un chauffage avec horodateur.
Si la mesure de la température est sur le radiateur, il faut placer le capteur en bas de celui-ci pour ne pas que le chauffage de radiateur influence la mesure de la température.
Evidemment, une mesure de la température par Bluetooth qui mesure la température de la pièce est aussi intéressante à faire.
Mais tout cela sera d’autres histoires

J’ai demandé à mes etudiants en DS de faire cela en 1.5heures suite aux nombreux exercices qu'il avait fait dans le "bar"
https://forum.arduino.cc/index.php?topic=675752.0
donc, voici une correction qui peut interesser d'autres personnes et qui va bien dans ce sujet

1 Like

Avant de changer la commande d’un four avec un Arduino comment réparer la résistance « infrarouge » quartz d’un four.
En effet, impossible de trouver chez les fournisseurs et sur internet, la bonne dimension.
En effet, j’ai eu plusieurs système ou la résistance est coupé à l’intérieur pourtant mon four c’est de l’electrolux ????
Quel est le matériau du fil chauffant ? Ou puis-je le commander ?
Ma résistance a une longueur de 29cm avec un diamètre interne de 10mm et fait 500W pour 110V
Les 2 résistances sont en séries dans le four, il n’aurait pas pu mettre 2 résistances de 500W/220V

La deuxième résistance est correcte
l]

Merci d’avance

Je n’ai pas beaucoup de connaissances et d’expérience en fil chauffant:

il y a le Constantan compose de 60 % Cu - 40 % Ni qui tient seulement 650°C

Donc ne rayonnera pas assez pour votre application.

un autre Fil de résistance en alliage nickel-chrome 80/20 lui a une Températures d'utilisation jusqu'à 1 150°C, voir 1500°C

Le diamètre du fil est en fonction du courant

Or le courant est de I=P/V=500W/110V=4.54A

Il faut donc mettre un fil de diamètre de 0.5mm minimum sinon le fil fera fusible et il faudra une résistance de 24.2ohms

Suite à la datasheets suivant, il faut du 25SWG qui a une résistance de 5.8 ohm/m ou cette valeur évolue très peu en fonction de la température

Avec un espace entre les fils de 1.5mm, il faudra 193 spires et on retrouve la valeur résistance désirée.

bon bobinage et me faire savoir si mes calculs sont correctes

1 Like

J’ai diffèrent diamètre wire heating d’une entreprise m’a donné….

Voici une des bobines avec un diamètre de fil de 0.5mm et une résistance de de 5.6ohms/m

Pas trouvé grand-chose chez RESCAL

Voici les différents bobinages testés avec differents diametres de fils

Donc, des essais ont été effectués

Le diamètre de bobinages est de 7mm, la résistance thermique est déterminée en air libre comme sur la photo précédente. La mesure de la température est faite avec un thermocouple type k et vérifié par une caméra thermique.

Il est possible de doubler le bobinage comme sur la bobine la plus basse sur la photo

Voici les résultats avec 20 spires, pour diffèrent diamètre de fil.

On peut observer que la résistance à 20°C mesuré à l’ohmmètre n’est pas du tout identique à celle lorsqu’il y a plus de 150°C. On retrouve bien les valeurs en ohm/m donné par le constructeur
Capture1

on a augmenté le courant pour savoir si le fil chauffant allait faire fusible et quel rayonnement le fil allait faire ?
le rayonnement est bien plus jaune qu'auparavant car plus un corps est chaud est plus il rayonne.
de meme, plus la temperature augmente et plus la convection augmente donc la resistance thermique a legerement diminué.
Capture2

1 Like

A quelle puissance ou température, il y a le plus de rayonnement ?
C’est-à-dire à quelle température du fil chauffant, il y aura le plus de chauffage sans conduction, ni convection…..mais par rayonnement pour chauffer un plat ?

Je n’ai pas beaucoup de connaissance dans le chauffage par rayonnement ?

Voici un peu de théorie vulgarisé sur le chauffage infrarouge

Mais, le maximum de transfert par rayonnement correspondra au maximum de température du fil ? Avec de la luminance des d’ondes de l’infrarouges se situant entre 3,0 µm et 10 µm qui n’est sont pas visible….

Mais pour chauffer un plat, il y aura un ensemble de phénomène (convection, conduction, rayonnement à une certaine distance, réflexion…) que ne peuvent se séparer dans une enceinte relativement exiguë.

La bonne question serait :

Quel est le maximum de transfert thermique avec le minimum de perte, dans un minimum de temps ?

La réponse est simple éviter au maximum les déperditions de chaleur donc de faire une enceinte fermée ? En protégeant l’utilisateur contre les brulures

Donc tout l’inverse du chauffage à kebab ou des grilles pains…..

Mais il y a de l’inertie thermique dans les gros fours fermés…….

Attention à la limite de température du four, il faut utiliser de la gaine tressée fibre de verre, domino en silicone ou en céramique….pour isoler les fils électriques.
Voir refroidir l’enceinte extérieure pour protéger les personnes de brulure…..

D’ailleurs, c’est pour cela que l’electronique doit être éloignée des sources de chaleur et que des thermostats et horloges sont mécaniques
Capture1