Go Down

Topic: open source hardware electromenagers (four electrique, micro onde..... ) (Read 2148 times) previous topic - next topic

iutgeiisoissons

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.
https://www.elektormagazine.com/labs/remake-arduino-course-shield-160593

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
https://drive.google.com/open?id=1VsmmglSRHmY2npUyDTXDtvaHtcI2Oa6L
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

http://fr.farnell.com/labfacility/pt46x150/sonde-pt100/dp/560170?MER=bn_level5_5NP_EngagementRecSingleItem_4

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
http://www.electronicwings.com/arduino/thermocouple-interfacing-with-arduino-uno
Il est possible d'utiliser un CI avec Serial Peripheral Interface pour etre moins bruité.
https://cdn-shop.adafruit.com/datasheets/MAX6675.pdf

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




iutgeiisoissons

#1
Mar 04, 2018, 04:37 pm Last Edit: Mar 15, 2018, 05:59 pm by iutgeiisoissons
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 ;
Code: [Select]

* 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 :
Code: [Select]

#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é
https://drive.google.com/open?id=1fRUCjONFsuRx2WxmhZoOcrkFnsLZLMwq



iutgeiisoissons

#2
Mar 04, 2018, 04:54 pm Last Edit: Mar 08, 2018, 02:07 pm by iutgeiisoissons
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 :
https://drive.google.com/open?id=1Ef0xDwM8BA2bM1pBm6BqecG2N6i0VDQN


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)/(2*R0+DR)=>5*( 0.5+(DR/2*R0))
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.625*T(°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 :
Code: [Select]

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
Code: [Select]

  
//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
https://drive.google.com/open?id=1QOQSEvDsu6dxxCdohJraKXsxDXgumVJy

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


iutgeiisoissons

#3
Mar 08, 2018, 03:13 pm Last Edit: Mar 08, 2018, 06:00 pm by iutgeiisoissons
Four à micro onde sans résistance chauffante

Lien sur le fonctionnement d'un four à micro-onde et de sa technologie
http://ww2.ac-poitiers.fr/electronique/IMG/pdf/Micro-onde.pdf


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

Code: [Select]
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.
https://drive.google.com/open?id=1pZUioO00m1DT2eWHhdjbtARcno_nd6UA




le programme en entier en fichier joint
la partie de la gestion des boutons et de la puissance
Code: [Select]


//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……






iutgeiisoissons

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.
http://www.instructables.com/id/Arduino-Nano-USB-Not-Recognizing-Fix/
http://www.wch.cn/download/CH341SER_EXE.html


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 :
https://drive.google.com/open?id=1lX48lEbqo2JlPfl2_pe9kLxHBfHyFsm7



les programmes sont en fichiers attachés
mais voici l'algorithme
Code: [Select]

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.



iutgeiisoissons

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
https://surtrtech.com/2018/01/27/how-to-simply-use-ds1302-rtc-module-with-arduino-board-and-lcd-screen/

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.

Code: [Select]

//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....



iutgeiisoissons

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
Code: [Select]

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
Code: [Select]

// 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
https://drive.google.com/open?id=1jUgcSpI7OdA-sSPIgRoHVwYL45iHyk1o




le programme complet du réveil arrive

Dorian98

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
Code: [Select]

// 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.


iutgeiisoissons

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
https://gist.github.com/nicksort/4736535
https://gist.github.com/baojie/4522173


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.

Code: [Select]

#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

RClementZ

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

Code: [Select]
#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


Pierre-J

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:

Code: [Select]
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

ARTNOW

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 .

Go Up