Bienvenue aux nouveaux arrivants sur FantasPic !

- Pensez à lire les règles durant votre visite, il n'y en a pas beaucoup, mais encore faut-il les respecter .
- N’hésitez pas à faire des remarques et/ou suggestions sur le Forum, dans le but de l'améliorer et de rendre vos prochaines visites plus agréables.
- Vous pouvez regarder votre "panneau de l'utilisateur" afin de configurer vos préférences.
- Un passage par "l'utilisation du forum" est recommandé pour connaître les fonctionnalités du forum.

--- L’équipe FantasPic ---
Forum général sur le langage C !

Modérateur : Jérémy

Comprendre les bases de la programmation PIC
PEDRO
Amateur
Amateur
Messages : 127
Enregistré en : septembre 2015
Localisation : P.A.C.A

#61 Message par PEDRO » sam. 9 janv. 2021 16:28

djviper16 a écrit :Source du message Tout ce système doit être simplement utilisable par mon papa qui n'y connait rien en électronique, alors je lui imprimerai un tableau avec les différentes valeurs correspondantes.


Pour encore plus lui simplifier la vie, tu prends ça CARTE UNIVERSELLE, tu mets 2 potars multitours et tu affiches le réglage Ton et Toff sur l'afficheur, tu peux meme te payer le luxe de programmer un compte à rebours pour que l'on sache combien il reste de temps avant le prochaine changement d'état.
Bon, ce n'était pas la question d'origine exit

Comprendre les bases de la programmation PIC
djviper16
Débutant
Débutant
Messages : 60
Enregistré en : décembre 2020

#62 Message par djviper16 » sam. 9 janv. 2021 17:20

PEDRO a écrit :Et mettre 4 BP au lieu de 2, ce ne serait pas plus simple, surtout que si j'ai bien vu, sur ton 16F684 c'est faisable


Non pas possible, j'utilise déjà toutes les entrées dispo, puis je le veux à 2 boutons, ça me permet d'apprendre.

PEDRO a écrit :Pour encore plus lui simplifier la vie, tu prends ça CARTE UNIVERSELLE, tu mets 2 potars multitours et tu affiches le réglage Ton et Toff sur l'afficheur, tu peux meme te payer le luxe de programmer un compte à rebours pour que l'on sache combien il reste de temps avant le prochaine changement d'état.


Oui bien-sûr, mais je préfère faire à 100% mon projet, avec le matos à ma disposition, c'est bien plus gratifiant.
C'est un truc qu'il va programmer une fois, après il ne va plus y toucher. J'aurais même pu faire quelque chose de non programmable, en programmant les Ton et Toff directement dans le programme une fois pour toute mais j'ajoute du défi :lol:

Comprendre les bases de la programmation PIC
satinas
Expert
Expert
Messages : 1225
Enregistré en : novembre 2015

#63 Message par satinas » sam. 9 janv. 2021 18:29

Ce qui manque, c'est la visualisation des durées programmées, il faut le faire en morse avec les leds :)
Une pin doit pouvoir piloter à la fois une input et une output led.

Comprendre les bases de la programmation PIC
PEDRO
Amateur
Amateur
Messages : 127
Enregistré en : septembre 2015
Localisation : P.A.C.A

#64 Message par PEDRO » sam. 9 janv. 2021 19:46

djviper16 a écrit :Source du message Non pas possible, j'utilise déjà toutes les entrées dispo, puis je le veux à 2 boutons, ça me permet d'apprendre.

Autant j'avais raté le message sur le changement de référence du PIC, autant là je confirme ce que j'ai dit.

Tu as un 16F684, PIC à 14 pins, dont 2 d'alim, reste 12 I/O
Tu utilises 8 entrées pour le DipSwitch, 1 pour le relais, 1 pour la led, il en reste donc 2 pour tes 2 BP.

Puisque tu veux apprendre, tu vas donc apprendre une astuce :
Tu prends 2 résistances de 1K, tu les montes en série entre le 0V et le +5V et tu relies le point de connexion de tes 2 résistances à une entrée analogique.
Tu viens ensuite cabler chaque BP sur une résistance, de manière à la shunter lorsque l'on appuie dessus.
Au repos, tu aura 2.5V sur ton entrée analogique, et lorsque tu appuiera sur l'un ou l'autre des BP, tu obtiendras soit 0V soit +5V.
Ceci est un exemple simplifié, mais tu peux avoir beaucoup plus de résistances et de BP sur un seul circuit, à titre d'exemple j'avais fait un capteur de niveau de liquide avec 16 résistances en série, des ILS pour les shunter et un flotteur contenant un aimant, le tout en utilisant une seule entrée analogique.

Tu pourrais donc mettre les 4 BP sur une seule entrée, et du coup libérer 1 pin pour remplacer ta led normale par une led bicolore, ce qui apportera de l'ergonomie

Comprendre les bases de la programmation PIC
djviper16
Débutant
Débutant
Messages : 60
Enregistré en : décembre 2020

#65 Message par djviper16 » dim. 10 janv. 2021 01:14

satinas a écrit :Source du message Ce qui manque, c'est la visualisation des durées programmées, il faut le faire en morse avec les leds :)
Une pin doit pouvoir piloter à la fois une input et une output led.

C'est surtout pour programmer que ça me manque, il n'y a pas un moyen de voir en temps réel ce qui est présent dans les variables et les registres ? :lol:

PEDRO a écrit :Source du message Autant j'avais raté le message sur le changement de référence du PIC, autant là je confirme ce que j'ai dit.

Tu as un 16F684, PIC à 14 pins, dont 2 d'alim, reste 12 I/O
Tu utilises 8 entrées pour le DipSwitch, 1 pour le relais, 1 pour la led, il en reste donc 2 pour tes 2 BP.

Puisque tu veux apprendre, tu vas donc apprendre une astuce :
Tu prends 2 résistances de 1K, tu les montes en série entre le 0V et le +5V et tu relies le point de connexion de tes 2 résistances à une entrée analogique.
Tu viens ensuite cabler chaque BP sur une résistance, de manière à la shunter lorsque l'on appuie dessus.
Au repos, tu aura 2.5V sur ton entrée analogique, et lorsque tu appuiera sur l'un ou l'autre des BP, tu obtiendras soit 0V soit +5V.
Ceci est un exemple simplifié, mais tu peux avoir beaucoup plus de résistances et de BP sur un seul circuit, à titre d'exemple j'avais fait un capteur de niveau de liquide avec 16 résistances en série, des ILS pour les shunter et un flotteur contenant un aimant, le tout en utilisant une seule entrée analogique.

Tu pourrais donc mettre les 4 BP sur une seule entrée, et du coup libérer 1 pin pour remplacer ta led normale par une led bicolore, ce qui apportera de l'ergonomie

Oui c'est vrai on pourrait le faire. Au lieu d'utiliser des niveaux logiques tu utilises des niveaux analogiques.

J'aime bien l'idée de programmer 2 fonctions avec un seul bouton ne m'en veut pas :sifflotte:
Mais je vais bien trouver un projet un jour pour utiliser le CAN :-)

J'ai presque terminé mon programme, tout fonctionne comme prévu. Sur une heure de fonctionnement j'ai 12 secondes de décalage, ce qui n'est pas si mal pour un programme non optimisé qui tourne sur oscillateur interne.
Sauf qu'en cas de coupure de courant le programme perd ses paramètres, donc la dernière étape sera de stocker la valeur des variables Ton / Toff / BaseTon / BaseToff dans l'EEPROM.

Code : Tout sélectionner

#include <16F684.h> 

#use delay(clock=4000000)    //fréquence de l'oscillateur interne : 4MHz
#fuses INTRC_IO,NOWDT,NOPUT,NOBROWNOUT,NOMCLR,NOPROTECT,NOCPD,NOPUT,NOIESO,NOFCMEN,BROWNOUT_NOSL    //il faut tous les mettre sinon ça marche pas
#use fast_io(A)                // permet d'utiliser set_tris_X(), sinon CCS affecte automatiquement les ports.
#use fast_io(C)                // permet d'utiliser set_tris_X(), sinon CCS affecte automatiquement les ports.


#bit MCLRE = 0x2007.5            //RA3 pull-up is enabled when MCLRE is ‘1’
#bit RAPU = 0x81.7
#byte ANSEL = 0x91
#byte CMCON0 = 0x19


//////TIMER0 REGISTRES//////
#byte OPTION_REG = 0x81
#byte TMR0 = 0x01
#bit T0IF = 0x0B.2


//////TIMER1 REGISTRES//////
#byte INTCON = 0x0B            //INTCON REGISTER adresse 10h
#byte T1CON = 0x10            //T1CON REGISTER adresse 10h 
#byte TMR1L = 0x0E            //TMR1L REGISTER adresse 0Eh
#byte TMR1H = 0x0F            //TMR1H REGISTER adresse 0Fh
#byte PIR1 = 0x0C            //PIR1 REGISTER adresse 0Ch
#byte PIE1 = 0x8C            //PIE1 REGISTER adresse 8Ch
#bit TMR1IF = 0x0C.0        //bit Flag quand le timer déborde


//////ADRESSES PORTS ET BITS E/S//////
#byte portA=5                //adresse du port A
#byte WPUA=95                //adresse WPUA
#byte IOCA=96                //adresse IOCA
#byte portC=7                //adresse du port C
#bit RA0=portA.0            //affectation du RA0
#bit RA1=portA.1            //affectation du RA1
#bit RA2=portA.2            //affectation du RA2
#bit RA3=portA.3            //affectation du RA3
#bit RA4=portA.4            //affectation du RA4
#bit RA5=portA.5            //affectation du RA5
#bit RC0=portC.0            //affectation du RC0
#bit RC1=portC.1            //affectation du RC1
#bit RC2=portC.2            //affectation du RC2
#bit RC3=portC.3            //affectation du RC3
#bit RC4=portC.4            //affectation du RC4
#bit RC5=portC.5            //affectation du RC5



//////DECLARATION VARIABLES//////
int demisec;                //variable 0 à 2 -> pour compter le nombre de flag levés (un flag toutes les 0.5 sec)
int sec;                    //variable 0 à 59 -> pour faire une minute
int min;                    //variable 0 à 59 -> pour faire une heure
int hr;                         //variable 0 à 24
int Ton;                    //variable Tempo ON
int Toff;                    //variable Tempo OFF
int BaseTon;
int BaseToff;
int nbFlagTimer0;





void clignotements_led_courts()        //routine clignotements courts après appui court
{
RA1=1;
delay_ms(100);
RA1=0;
delay_ms(100);
RA1=1;
delay_ms(100);
RA1=0;
delay_ms(100);
RA1=1;
delay_ms(100);
RA1=0;
delay_ms(100);
RA1=1;
delay_ms(100);
RA1=0;
delay_ms(100);
RA1=1;
delay_ms(100);
RA1=0;
delay_ms(100);
RA1=1;
delay_ms(100);
RA1=0;
}






void clignotements_led_longs()        //routine clignotements longs après appui long
{
RA1=1;
delay_ms(500);
RA1=0;
delay_ms(500);
RA1=1;
delay_ms(500);
RA1=0;
delay_ms(500);
RA1=1;
delay_ms(500);
RA1=0;
}





void main()
{
//////PORTS ET BITS E/S//////    
ANSEL=0x00;
CMCON0=0xFF;
SET_TRIS_A(0xFC);              //(0)en décimal / (0x00)en hexa / (0b00000000) en binaire / PORT A en sortie
SET_TRIS_C(0xFF);


MCLRE=0;                    //0 = RA3/MCLR pin function is digital input, MCLR internally tied to VDD
RAPU=0;                        //0 = PORTA pull-ups are enabled by individual port latch values
WPUA=0xFF;                     //1 = Pull-up enabled


//////VALEURS VARIABLES//////
demisec=0;
sec=0;
min=0;
hr=0;
Ton=0x00;
Toff=0xFF;
nbFlagTimer0=0;
BaseTon=0b00000100;
BaseToff=0b00000100;




//////TIMERS//////
INTCON=0xE0;                    //GIE et PEIE à 1 pour activer interruptions (bits 7 et 6)du Timer1
                                //T0IE : 1 = Enables the TMR0 interrupt
                                //INTE : 0 = Disables the RA2/INT external interrupt
                                //RAIE : 0 = Disables the PORTA change interrupt
                                //T0IF : 0 = TMR0 register did not overflow
                                //INTF : 0 = The RA2/INT external interrupt did not occur
                                //RAIF : 0 = None of the PORTA <5:0> pins have changed state


//////TIMER0 REGISTRES//////
OPTION_REG=0b00000111;
TMR0=0x3C;        //0x3C=60    60 à 255 pour 0.05 secondes


//////TIMER1 REGISTRES//////
T1CON=0x35;
TMR1L=0xDC;
TMR1H=0xFF;        //0x0B
PIR1=0x00;
PIE1=0x00;
TMR1IF=0;


RA0=0;                            //relais inactif
RA1=0;                            //led éteinte



    
while(1)                
    {


        if (
TMR1IF==1)
        {    
demisec++;
            
TMR1IF=0;
            
TMR1L=0xDC;
            
TMR1H=0x0B;

            if (
demisec==2)
            {    
sec++;
                
demisec=0;
            }
            if (
sec==60)
            {    
min++;
            
sec=0;
            }
            if (
min==60)
            {    
hr++;
            
min=0;
            }
            if (
hr==24)
            {    
hr=0;
            }                
        }    

        
        



////////////////////Si appui sur BP gauche (Ton)///////////////////////
        
if (RA2==0)                //BP de gauche
            
{
            
delay_ms(10);

            if (
T0IF==1)
                {
                
nbFlagTimer0++;
                
T0IF=0;
                }

            if (
RA2==& (nbFlagTimer0<20))                //Si quand on relâche le BP, le flag a été déclenché moins de 20 fois, programmation Ton
                
{
                
nbFlagTimer0=0;
                
Ton = (RC3<<0) | (RC4<<1) | (RC5<<2) | (RA3<<3) | (RA4<<4) | (RA5<<5) | (RC1<<6) | (RC2<<7);        //on écrit l'état des 8 interrupteurs
                
clignotements_led_courts();
                }    

            if (
RA2==& (nbFlagTimer0>20))                 //Si quand on relâche le BP, le flag a été déclenché plus de 20 fois, programmation BaseTon
                
{
                
nbFlagTimer0=0;
                
BaseTon = (RC3<<0) | (RC4<<1) | (RC5<<2) | (RA3<<3) | (RA4<<4) | (RA5<<5) | (RC1<<6) | (RC2<<7);        //on écrit l'état des 8 interrupteurs
                
clignotements_led_longs();
                }
        
            
sec=0;
            
min=0;
            
hr=0;
            }    



////////////////////Si appui sur BP droite (Toff)///////////////////////
        
if (RC0==0)                //BP de droite
            
{
            
delay_ms(10);

            if (
T0IF==1)
                {
                
nbFlagTimer0++;
                
T0IF=0;
                }

            if (
RC0==& (nbFlagTimer0<20))                //Si quand on relâche le BP, le flag a été déclenché moins de 20 fois, programmation Toff
                
{
                
nbFlagTimer0=0;
                
Toff = (RC3<<0) | (RC4<<1) | (RC5<<2) | (RA3<<3) | (RA4<<4) | (RA5<<5) | (RC1<<6) | (RC2<<7);        //on écrit l'état des 8 interrupteurs
                
clignotements_led_courts();
                }    

            if (
RC0==& (nbFlagTimer0>20))                //Si quand on relâche le BP, le flag a été déclenché plus de 20 fois, programmation BaseToff
                
{
                
nbFlagTimer0=0;
                
BaseToff = (RC3<<0) | (RC4<<1) | (RC5<<2) | (RA3<<3) | (RA4<<4) | (RA5<<5) | (RC1<<6) | (RC2<<7);        //on écrit l'état des 8 interrupteurs
                
clignotements_led_longs();
                }

            
sec=0;
            
min=0;
            
hr=0;
            }    




////////////////////Si les conditions sont réunies pour basculement état sortie///////////////////////
        
if ((sec>=Ton) && (RA0==1) && (BaseTon==0b00000001))
            {
            
RA0=0;
            
RA1=0;
            
sec=0;
            
min=0;
            
hr=0;
            }
        if ((
sec>=Toff) && (RA0==0) && (BaseToff==0b00000001))
            {
            
RA0=1;
            
RA1=1;
            
sec=0;
            
min=0;
            
hr=0;
            }
        if ((
min>=Ton) && (RA0==1) && (BaseTon==0b00000010))
            {
            
RA0=0;
            
RA1=0;
            
sec=0;
            
min=0;
            
hr=0;
            }
        if ((
min>=Toff) && (RA0==0) && (BaseToff==0b00000010))
            {
            
RA0=1;
            
RA1=1;
            
sec=0;
            
min=0;
            
hr=0;
            }
        if ((
hr>=Ton) && (RA0==1) && (BaseTon==0b00000100))
            {
            
RA0=0;
            
RA1=0;
            
sec=0;
            
min=0;
            
hr=0;
            }
        if ((
hr>=Toff) && (RA0==0) && (BaseToff==0b00000100))
            {
            
RA0=1;
            
RA1=1;
            
sec=0;
            
min=0;
            
hr=0;
            }
    }
}


 

Comprendre les bases de la programmation PIC
satinas
Expert
Expert
Messages : 1225
Enregistré en : novembre 2015

#66 Message par satinas » dim. 10 janv. 2021 06:31

bonjour

L'interruption timer est autorisée dans INTCON, mais pas d'ISR prévue, heureusement que CCS doit en mettre une par défaut, sinon plantage. Tu devrais d'abord installer une ISR, avant de commencer à gérer les nombreux boutons. Ou t'en passer mais alors laisser INTCON à 0.

Dans la doc, il est précisé qu'il est préférable d'arrêter le timer avant d'écrire TMR1H et TMR1L, car en modifiant octet par octet un registre 16 bits, il peut y avoir des erreurs.

Pour debugger, voir la doc, d'après la photo tu as un PicKit2, pourtant dans les dernières versions de CCS, il semble ne plus être reconnu. Et pour les PicKit3 et PicKit4, ils parlent d'installer MpLabX pour les utiliser depuis l'IDE CCS, je sens l'usine à gaz arriver.
Sur cette page il y a un plugin pour compiler et sans doute debugger avec CCS dans l'IDE Mplab+PicKit2. http://www.ccsinfo.com/downloads.php#progDebug

Comprendre les bases de la programmation PIC
paulfjujo
Avatar de l’utilisateur
Expert
Expert
Messages : 2589
Âge : 73
Enregistré en : juillet 2015
Localisation : 01800
Contact :

#67 Message par paulfjujo » dim. 10 janv. 2021 12:01

bonjour à tous,

je ne connais pas CCS ...

Satinas a écrit : Et pour les PicKit3 et PicKit4, ils parlent d'installer MpLabX pour les utiliser


voir avec MPLAB IPE V5.30 ..programme autonome, ne necessite pas d'installer MPLABX .
pour charger le *.HEX dans le PIC via Pickit3 ou Pickit4

Retard de 12sec par heure ?

il faut traiter timer1 en interruption plutot qu'en pooling,
car il y a trop de (duree de) traitement entre chaque test du flag TMR1

Code : Tout sélectionner


volatile char sec
=0;

void Interrupt()
{
  if (TMR1IF_bit)
  { 
    TMR1IF_bit 
= 0;
    TMR1H     = 0x0B;
    TMR1L     = 0xDC;
   demisec++;            // je prefere le Brut
   if (demisec >1)
   {  sec++;
   demis_Sec=0
   
}
 }
}


armer TMR1IE et GIE bits ...

nota: toute la mise à l'heure pourrait etre traitée dans l'interruption
Aide toi, le ciel ou FantasPic t'aidera

Comprendre les bases de la programmation PIC
djviper16
Débutant
Débutant
Messages : 60
Enregistré en : décembre 2020

#68 Message par djviper16 » dim. 10 janv. 2021 21:57

satinas a écrit :Source du message L'interruption timer est autorisée dans INTCON, mais pas d'ISR prévue, heureusement que CCS doit en mettre une par défaut, sinon plantage. Tu devrais d'abord installer une ISR, avant de commencer à gérer les nombreux boutons. Ou t'en passer mais alors laisser INTCON à 0.

Dans la doc, il est précisé qu'il est préférable d'arrêter le timer avant d'écrire TMR1H et TMR1L, car en modifiant octet par octet un registre 16 bits, il peut y avoir des erreurs.

Pour debugger, voir la doc, d'après la photo tu as un PicKit2, pourtant dans les dernières versions de CCS, il semble ne plus être reconnu. Et pour les PicKit3 et PicKit4, ils parlent d'installer MpLabX pour les utiliser depuis l'IDE CCS, je sens l'usine à gaz arriver.
Sur cette page il y a un plugin pour compiler et sans doute debugger avec CCS dans l'IDE Mplab+PicKit2. http://www.ccsinfo.com/downloads.php#progDebug


Merci ! J'ai corrigé tout ça.
Je tourne sous MPLAB IDE v8.1. Effectivement MPLABX ne prend pas en charge le pickit2.

paulfjujo a écrit :Source du message il faut traiter timer1 en interruption plutot qu'en pooling,
car il y a trop de (duree de) traitement entre chaque test du flag TMR1

Bonne idée !

Du coup j'ai tenu compte de vos remarques et j'ai intégré l'enregistrement des variables utilisateur dans l'EEPROM.
À moins que vous ne trouviez des erreurs ou des améliorations, le programme est terminé. :-)

Code : Tout sélectionner

#include <16F684.h> 

#use delay(clock=4000000)    //fréquence de l'oscillateur interne : 4MHz
#fuses INTRC_IO,NOWDT,NOPUT,NOBROWNOUT,NOMCLR,NOPROTECT,NOCPD,NOPUT,NOIESO,NOFCMEN,BROWNOUT_NOSL    //il faut tous les mettre sinon ça marche pas
#use fast_io(A)                // permet d'utiliser set_tris_X(), sinon CCS affecte automatiquement les ports.
#use fast_io(C)                // permet d'utiliser set_tris_X(), sinon CCS affecte automatiquement les ports.


#bit MCLRE = 0x2007.5        
#bit RAPU = 0x81.7
#byte ANSEL = 0x91
#byte CMCON0 = 0x19


//////TIMER0 REGISTRES//////
#byte OPTION_REG = 0x81
#byte TMR0 = 0x01
#bit T0IF = 0x0B.2


//////TIMER1 REGISTRES//////
#byte INTCON = 0x0B            //INTCON REGISTER adresse 10h
#byte T1CON = 0x10            //T1CON REGISTER adresse 10h 
#byte TMR1L = 0x0E            //TMR1L REGISTER adresse 0Eh
#byte TMR1H = 0x0F            //TMR1H REGISTER adresse 0Fh
#byte PIR1 = 0x0C            //PIR1 REGISTER adresse 0Ch
#byte PIE1 = 0x8C            //PIE1 REGISTER adresse 8Ch
#bit TMR1IF = 0x0C.0        //adresse du bit Flag quand le timer déborde
#bit TMR1IE = 0x8C.0        //adresse du bit d'activation des interruptions
#bit GIE = 0x0B.7
#bit PEIE = 0x0B.6


//////EEPROM//////
#byte EEDAT = 0x9A
#byte EEADR = 0x9B
#byte EECON1 = 0x9C
#byte EECON2 = 0x9D
#bit EEIF = 0x0C.7
#bit WREN = 0x9C.2
#bit WR = 0x9C.1
#bit RD = 0x9C.0

//////ADRESSES PORTS ET BITS E/S//////
#byte portA=5                //adresse du port A
#byte WPUA=95                //adresse WPUA
#byte IOCA=96                //adresse IOCA
#byte portC=7                //adresse du port C
#bit RA0=portA.0            //affectation du RA0
#bit RA1=portA.1            //affectation du RA1
#bit RA2=portA.2            //affectation du RA2
#bit RA3=portA.3            //affectation du RA3
#bit RA4=portA.4            //affectation du RA4
#bit RA5=portA.5            //affectation du RA5
#bit RC0=portC.0            //affectation du RC0
#bit RC1=portC.1            //affectation du RC1
#bit RC2=portC.2            //affectation du RC2
#bit RC3=portC.3            //affectation du RC3
#bit RC4=portC.4            //affectation du RC4
#bit RC5=portC.5            //affectation du RC5



//////DECLARATION VARIABLES//////
int8 demisec;                //variable 0 à 2 -> pour compter le nombre de flag levés (un flag toutes les 0.5 sec)
int8 sec;                    //variable 0 à 59 -> pour faire une minute
int8 min;                    //variable 0 à 59 -> pour faire une heure
int8 hr;                     //variable 0 à 24
int8 Ton;                    //variable Tempo ON
int8 Toff;                    //variable Tempo OFF
int8 BaseTon;
int8 BaseToff;
int8 nbFlagTimer0;





void clignotements_led_courts()        //routine clignotements courts après appui court
{
RA1=1;
delay_ms(100);
RA1=0;
delay_ms(100);
RA1=1;
delay_ms(100);
RA1=0;
delay_ms(100);
RA1=1;
delay_ms(100);
RA1=0;
delay_ms(100);
RA1=1;
delay_ms(100);
RA1=0;
delay_ms(100);
RA1=1;
delay_ms(100);
RA1=0;
delay_ms(100);
RA1=1;
delay_ms(100);
RA1=0;
}



void clignotements_led_longs()        //routine clignotements longs après appui long
{
RA1=1;
delay_ms(500);
RA1=0;
delay_ms(500);
RA1=1;
delay_ms(500);
RA1=0;
delay_ms(500);
RA1=1;
delay_ms(500);
RA1=0;
}



void sequence_write_EEPROM()        //séquence écriture EEPROM
{
WREN=1;                                //autorise écriture
GIE=0;                                //désactive interruptions générales
EECON2=0x55;
EECON2=0xAA;
WR=1;                                //start écriture
EEIF=0;                                //Write Complete Interrupt Flag bit
GIE=1;                                //ré-activer les interruptions
}



#int_timer1
void interrupt_timer1()                //routine d'interruption Timer1
{
    if(TMR1IF==1)
        {
            demisec++;                                                            //j'assume le nom de ma variable ;)
            TMR1IF=0;                //flag du Timer1 à 0
            T1CON=0x34;                //0b00110100 Timer1 arrêté
            TMR1L=0xDC;                //config compteur 16 bits
            TMR1H=0x0B;                //0x0B
            T1CON=0x35;                //0b00110100 Timer1 démarré

            if (demisec==2)
            {    sec++;
                demisec=0;
            }
            if (sec==60)
            {    min++;
            sec=0;
            }
            if (min==60)
            {    hr++;
            min=0;
            }
            if (hr==24)
            {    hr=0;
            }            
        
}    
}


void main()
{
//////PORTS ET BITS E/S//////    
ANSEL=0x00;                        //désactive les entrées analogiques
CMCON0=0xFF;                    //désactive les comparateurs
SET_TRIS_A(0xFC);                  //RA0 et RA1 en sorties, RA2, RA3, RA4, RA5 en entrées
SET_TRIS_C(0xFF);                //tout le portC en entrée
//MCLRE=0;                        //0 = RA3/MCLR pin function is digital input, MCLR internally tied to VDD
RAPU=0;                            //0 = PORTA pull-ups are enabled by individual port latch values
WPUA=0xFF;                         //1 = Pull-up enabled


//////VALEURS VARIABLES//////
demisec=0;
sec=0;
min=0;
hr=0;
//Ton=0x00;
//Toff=0xFF;
nbFlagTimer0=0;
BaseTon=0b00000100;
BaseToff=0b00000100;




//////TIMERS//////
INTCON=0xC0;                    //GIE et PEIE à 1 pour activer interruptions (bits 7 et 6)du Timer1
                                //T0IE : 0 = Disables the TMR0 interrupt
                                //INTE : 0 = Disables the RA2/INT external interrupt
                                //RAIE : 0 = Disables the PORTA change interrupt
                                //T0IF : 0 = TMR0 register did not overflow
                                //INTF : 0 = The RA2/INT external interrupt did not occur
                                //RAIF : 0 = None of the PORTA <5:0> pins have changed state


//////TIMER0 REGISTRES//////
OPTION_REG=0b00000111;
TMR0=0x3C;        //0x3C=60    60 à 255 pour 0.05 secondes


//////TIMER1 REGISTRES//////
T1CON=0x34;                        //0b00110100 Timer1 arrêté
TMR1L=0xDC;                        //config compteur 16 bits
TMR1H=0x0B;                        //0x0B
T1CON=0x35;                        //0b00110100 Timer1 démarré
PIR1=0x00;
PIE1=0x00;
TMR1IF=0;                        //flag du Timer1
TMR1IE=1;                        //1 = Enables the Timer1 overflow interrupt

RA0=0;                            //relais inactif
RA1=0;                            //led éteinte


//////EEPROM//////
EEADR=0x00;                        //adresse Ton EEPROM
RD=1;                            //autorise lecture
Ton=EEDAT;
EEADR=0x01;                        //adresse Toff EEPROM
EECON1=0b00000001;                //autorise écriture, initialise lecture EEPROM
Toff=EEDAT;
EEADR=0x02;                        //adresse BaseTon EEPROM
EECON1=0b00000001;                //autorise écriture, initialise lecture EEPROM
BaseTon=EEDAT;
EEADR=0x03;                        //adresse BaseToff EEPROM
EECON1=0b00000001;                //autorise écriture, initialise lecture EEPROM
BaseToff=EEDAT;

if(
Toff==0x00)                    //
    {Toff=0xFF;                    //Permet de ne pas passer à Ton au premier démarrage
    BaseToff=0b00000100;        //quand l'EEPROM n'est pas encore programmée
    }                            //


//////////////////Boucle principale/////////////////////
    while(1)                
    
{






////////////////////Si appui sur BP gauche (Ton)///////////////////////
        if (RA2==0)                //BP de gauche
            {
            delay_ms(10);

            if (T0IF==1)
                {
                nbFlagTimer0++;
                T0IF=0;
                }

            if (RA2==& (nbFlagTimer0<20))                //Si quand on relâche le BP, le flag a été déclenché moins de 20 fois, programmation Ton
                {
                nbFlagTimer0=0;
                Ton = (RC3<<0) | (RC4<<1) | (RC5<<2) | (RA3<<3) | (RA4<<4) | (RA5<<5) | (RC1<<6) | (RC2<<7);        //on écrit l'état des 8 interrupteurs
                clignotements_led_courts();
                EEADR=0x00;                        //adresse Ton EEPROM
                EEDAT=Ton;
                sequence_write_EEPROM();

                }    

            if 
(RA2==& (nbFlagTimer0>20))                 //Si quand on relâche le BP, le flag a été déclenché plus de 20 fois, programmation BaseTon
                {
                nbFlagTimer0=0;
                BaseTon = (RC3<<0) | (RC4<<1) | (RC5<<2) | (RA3<<3) | (RA4<<4) | (RA5<<5) | (RC1<<6) | (RC2<<7);        //on écrit l'état des 8 interrupteurs
                clignotements_led_longs();
                EEADR=0x02;                        //adresse Ton EEPROM
                EEDAT=BaseTon;
                sequence_write_EEPROM();

                }
        
            sec
=0;
            min=0;
            hr=0;
            }    



////////////////////Si appui sur BP droite (Toff)///////////////////////
        if (RC0==0)                //BP de droite
            {
            delay_ms(10);

            if (T0IF==1)
                {
                nbFlagTimer0++;
                T0IF=0;
                }

            if (RC0==& (nbFlagTimer0<20))                //Si quand on relâche le BP, le flag a été déclenché moins de 20 fois, programmation Toff
                {
                nbFlagTimer0=0;
                Toff = (RC3<<0) | (RC4<<1) | (RC5<<2) | (RA3<<3) | (RA4<<4) | (RA5<<5) | (RC1<<6) | (RC2<<7);        //on écrit l'état des 8 interrupteurs
                clignotements_led_courts();
                EEADR=0x01;                        //adresse Ton EEPROM
                EEDAT=Toff;
                sequence_write_EEPROM();

                }    

            if 
(RC0==& (nbFlagTimer0>20))                //Si quand on relâche le BP, le flag a été déclenché plus de 20 fois, programmation BaseToff
                {
                nbFlagTimer0=0;
                BaseToff = (RC3<<0) | (RC4<<1) | (RC5<<2) | (RA3<<3) | (RA4<<4) | (RA5<<5) | (RC1<<6) | (RC2<<7);        //on écrit l'état des 8 interrupteurs
                clignotements_led_longs();
                EEADR=0x03;                        //adresse Ton EEPROM
                EEDAT=BaseToff;
                sequence_write_EEPROM();

                }

            sec=0;
            min=0;
            hr=0;
            }    




////////////////////Si les conditions sont réunies pour basculement état sortie///////////////////////
        if ((sec>=Ton) && (RA0==1) && (BaseTon==0b00000001))
            {
            RA0=0;
            RA1=0;
            sec=0;
            min=0;
            hr=0;
            }
        if ((sec>=Toff) && (RA0==0) && (BaseToff==0b00000001))
            {
            RA0=1;
            RA1=1;
            sec=0;
            min=0;
            hr=0;
            }
        if ((min>=Ton) && (RA0==1) && (BaseTon==0b00000010))
            {
            RA0=0;
            RA1=0;
            sec=0;
            min=0;
            hr=0;
            }
        if ((min>=Toff) && (RA0==0) && (BaseToff==0b00000010))
            {
            RA0=1;
            RA1=1;
            sec=0;
            min=0;
            hr=0;
            }
        if ((hr>=Ton) && (RA0==1) && (BaseTon==0b00000100))
            {
            RA0=0;
            RA1=0;
            sec=0;
            min=0;
            hr=0;
            }
        if ((hr>=Toff) && (RA0==0) && (BaseToff==0b00000100))
            {
            RA0=1;
            RA1=1;
            sec=0;
            min=0;
            hr=0;
            }
    }
}




PS : Test effectué sur 12 minutes, j'ai à 1 ou 2 secondes d'avance maintenant. Sans importance pour l'utilisation prévue.
PS2 : Je viens de m'apercevoir d'un autre problème, c'est qu'avec mon programme actuel je ne peux pas faire par exemple 90 secondes, ou 90 minutes. Vu que mes variables "sec" et "min" s'arrêtent à 60 :(
Je vais tester ça pour voir :

Code : Tout sélectionner

             if (demisec==2)
            {    
sec++;
                
demisec=0;
            }
            if ((
sec==60) | (sec==120) | (sec==180) | (sec==240))
            {    
min++;
                if(
sec==240)
                {    
sec=0;}
            }
            if ((
min==60) | (min==120) | (min==180) | (min==240))
            {    
hr++;
                if(
min==240)
                {
min=0;}
            }
            if (
hr==24)
            {    
hr=0;
            }

Comprendre les bases de la programmation PIC
satinas
Expert
Expert
Messages : 1225
Enregistré en : novembre 2015

#69 Message par satinas » lun. 11 janv. 2021 08:01

Bonjour à tous

Pourquoi MCLRE est toujours là :)
Le if (TMR1IF==1) est superflu car seule l'interruption timer1 est autorisée. De plus la directive #int_timer1 doit le faire ce test.
En appelant le bit PORTA.0 relais au lieu de RA0, led au lieu de RA1, on y verrait plus clair. Idem pour RA2 et RC0;

Code : Tout sélectionner

    if (RA2==0) {                 //BP de gauche
      delay_ms(10);
      if (T0IF==1) {
        nbFlagTimer0++; T0IF=0;
      }
      if (RA2==1 & (nbFlagTimer0<20)) { //Si quand on relâche le BP, le flag a été déclenché moins de 20 fois, programmation Ton
        ...
      }
    }

Je pense que cela ne capte pas à tous les coups le relâchement du poussoir, si RA2 passe à 1 quand le programme est hors du test if (RA2==0) {.
Une fois entré dans ce test , tu peux attendre que RA2 passe à 1, grâce à l'interruption timer1 sec sera toujours incrémentée durant cette attente.

Pour la dernière question, je passerais sec, Ton, Toff en int32 (0 à 4294967295),
volatile int32 sec;
int32 Ton, Toff;
short started=1; // pour démarrer avec relais on
A chaque modif de configuration on recalcule Ton ou Toff en secondes.
Et on a uniquement 2 tests :

Code : Tout sélectionner

    if ((relais==0) && (Ton>0) && (started || (sec>=Toff))) {
      relais=1; led=1; sec=0; started = 0;
    }
    else if ((relais==1) && (Toff>0) && (sec>=Ton)) {
      relais=0; led=0; sec=0;
    }

PEDRO avait raison de dire qu'il fallait en discuter avant, mais bon, moi aussi, je me jette dans la programmation avant de réfléchir :-)

Comprendre les bases de la programmation PIC
djviper16
Débutant
Débutant
Messages : 60
Enregistré en : décembre 2020

#70 Message par djviper16 » mar. 12 janv. 2021 09:08

Bonjour,

J'ai éclairci un peu le programme selon tes bons conseils Satinas.

Par contre bizarrement sur 100 essais, le passage de RA2 à 1 est toujours capté.
Je comprends ce que tu veux dire d'ailleurs je ne pige pas pourquoi ça marche aussi bien comme j'ai fait.

La carte est partie chez mon père, donc plus d'essais possible à présent, et vu que ça fonctionne bien on va laisser comme ça.

Les dip switch me permettent de coder 255 valeurs uniquement, et mon programme en permet 240. C'est bien suffisant.

Tout ce système pour contrôler une turbine extracteur d'air, pour évacuer les poussières en suspension dans un élevage avicole, c'est déjà du luxe :lol:

Code : Tout sélectionner

#include <16F684.h> 

#use delay(clock=4000000)    //fréquence de l'oscillateur interne : 4MHz
#fuses INTRC_IO,NOWDT,NOPUT,NOBROWNOUT,NOMCLR,NOPROTECT,NOCPD,NOPUT,NOIESO,NOFCMEN,BROWNOUT_NOSL    //il faut tous les mettre sinon ça marche pas
#use fast_io(A)                // permet d'utiliser set_tris_X(), sinon CCS affecte automatiquement les ports.
#use fast_io(C)                // permet d'utiliser set_tris_X(), sinon CCS affecte automatiquement les ports.

    
#bit RAPU = 0x81.7
#byte ANSEL = 0x91
#byte CMCON0 = 0x19


//////TIMER0 REGISTRES//////
#byte OPTION_REG = 0x81
#byte TMR0 = 0x01
#bit T0IF = 0x0B.2


//////TIMER1 REGISTRES//////
#byte INTCON = 0x0B            //INTCON REGISTER adresse 10h
#byte T1CON = 0x10            //T1CON REGISTER adresse 10h 
#byte TMR1L = 0x0E            //TMR1L REGISTER adresse 0Eh
#byte TMR1H = 0x0F            //TMR1H REGISTER adresse 0Fh
#byte PIR1 = 0x0C            //PIR1 REGISTER adresse 0Ch
#byte PIE1 = 0x8C            //PIE1 REGISTER adresse 8Ch
#bit TMR1IF = 0x0C.0        //adresse du bit Flag quand le timer déborde
#bit TMR1IE = 0x8C.0        //adresse du bit d'activation des interruptions
#bit GIE = 0x0B.7
#bit PEIE = 0x0B.6


//////EEPROM//////
#byte EEDAT = 0x9A
#byte EEADR = 0x9B
#byte EECON1 = 0x9C
#byte EECON2 = 0x9D
#bit EEIF = 0x0C.7
#bit WREN = 0x9C.2
#bit WR = 0x9C.1
#bit RD = 0x9C.0

//////ADRESSES PORTS ET BITS E/S//////
#byte portA=5                //adresse du port A
#byte WPUA=95                //adresse WPUA
#byte IOCA=96                //adresse IOCA
#byte portC=7                //adresse du port C
#bit Relais_RA0=portA.0        //affectation du Relais_RA0
#bit Led_RA1=portA.1        //affectation du Led_RA1
#bit BP_Ton_RA2=portA.2        //affectation du BP_Ton_RA2
#bit RA3=portA.3            //affectation du RA3
#bit RA4=portA.4            //affectation du RA4
#bit RA5=portA.5            //affectation du RA5
#bit BP_Toff_RC0=portC.0    //affectation du BP_Toff_RC0
#bit RC1=portC.1            //affectation du RC1
#bit RC2=portC.2            //affectation du RC2
#bit RC3=portC.3            //affectation du RC3
#bit RC4=portC.4            //affectation du RC4
#bit RC5=portC.5            //affectation du RC5



//////DECLARATION VARIABLES//////
int8 demisec;                //variable 0 à 2 -> pour compter le nombre de flag levés (un flag toutes les 0.5 sec)
int8 sec;                    //variable 0 à 59 -> pour faire une minute
int8 min;                    //variable 0 à 59 -> pour faire une heure
int8 hr;                     //variable 0 à 24
int8 Ton;                    //variable Tempo ON
int8 Toff;                    //variable Tempo OFF
int8 BaseTon;
int8 BaseToff;
int8 nbFlagTimer0;





void clignotements_led_courts()        //routine clignotements courts après appui court
{
Led_RA1=1;
delay_ms(100);
Led_RA1=0;
delay_ms(100);
Led_RA1=1;
delay_ms(100);
Led_RA1=0;
delay_ms(100);
Led_RA1=1;
delay_ms(100);
Led_RA1=0;
delay_ms(100);
Led_RA1=1;
delay_ms(100);
Led_RA1=0;
delay_ms(100);
Led_RA1=1;
delay_ms(100);
Led_RA1=0;
delay_ms(100);
Led_RA1=1;
delay_ms(100);
Led_RA1=0;
}



void clignotements_led_longs()        //routine clignotements longs après appui long
{
Led_RA1=1;
delay_ms(500);
Led_RA1=0;
delay_ms(500);
Led_RA1=1;
delay_ms(500);
Led_RA1=0;
delay_ms(500);
Led_RA1=1;
delay_ms(500);
Led_RA1=0;
}



void sequence_write_EEPROM()        //séquence écriture EEPROM
{
WREN=1;                                //autorise écriture
GIE=0;                                //désactive interruptions générales
EECON2=0x55;
EECON2=0xAA;
WR=1;                                //start écriture
EEIF=0;                                //Write Complete Interrupt Flag bit
GIE=1;                                //ré-activer les interruptions
}



#int_timer1
void interrupt_timer1()                //routine d'interruption Timer1 (if TMR1IF==1)
{
demisec++;
TMR1IF=0;                            //flag du Timer1 à 0
T1CON=0x34;                            //0b00110100 Timer1 arrêté
TMR1L=0xDC;                            //config compteur 16 bits
TMR1H=0x0B;                            //0x0B
T1CON=0x35;                            //0b00110100 Timer1 démarré
if (demisec==2)
    {
sec++;
    
demisec=0;
    }
if ((
sec==60) | (sec==120) | (sec==180) | (sec==240))
    {
min++;
    if(
sec==240)
    {    
sec=0;}
    }
if ((
min==60) | (min==120) | (min==180) | (min==240))
    {
hr++;
    if(
min==240)
    {
min=0;}
    }
if (
hr==24)
    {
hr=0;}            
}


void main()
{
//////PORTS ET BITS E/S//////    
ANSEL=0x00;                        //désactive les entrées analogiques
CMCON0=0xFF;                    //désactive les comparateurs
SET_TRIS_A(0xFC);                  //Relais_RA0 et Led_RA1 en sorties, BP_Ton_RA2, RA3, RA4, RA5 en entrées
SET_TRIS_C(0xFF);                //tout le portC en entrée
RAPU=0;                            //0 = PORTA pull-ups are enabled by individual port latch values
WPUA=0xFF;                         //1 = Pull-up enabled


//////VALEURS VARIABLES//////
demisec=0;
sec=0;
min=0;
hr=0;
nbFlagTimer0=0;



//////TIMERS//////
INTCON=0xC0;                    //GIE et PEIE à 1 pour activer interruptions (bits 7 et 6)du Timer1
                                //T0IE : 0 = Disables the TMR0 interrupt
                                //INTE : 0 = Disables the BP_Ton_RA2/INT external interrupt
                                //RAIE : 0 = Disables the PORTA change interrupt
                                //T0IF : 0 = TMR0 register did not overflow
                                //INTF : 0 = The BP_Ton_RA2/INT external interrupt did not occur
                                //RAIF : 0 = None of the PORTA <5:0> pins have changed state


//////TIMER0 REGISTRES//////
OPTION_REG=0b00000111;
TMR0=0x3C;                        //0x3C=60    60 à 255 pour 0.05 secondes


//////TIMER1 REGISTRES//////
T1CON=0x34;                        //0b00110100 Timer1 arrêté
TMR1L=0xDC;                        //config compteur 16 bits
TMR1H=0x0B;                        //0x0B
T1CON=0x35;                        //0b00110100 Timer1 démarré
PIR1=0x00;
PIE1=0x00;
TMR1IF=0;                        //flag du Timer1
TMR1IE=1;                        //1 = Enables the Timer1 overflow interrupt

Relais_RA0=0;                            //relais inactif
Led_RA1=0;                        //led éteinte


//////EEPROM//////
EEADR=0x00;                        //adresse Ton EEPROM
RD=1;                            //autorise lecture
Ton=EEDAT;
EEADR=0x01;                        //adresse Toff EEPROM
EECON1=0b00000001;                //autorise écriture, initialise lecture EEPROM
Toff=EEDAT;
EEADR=0x02;                        //adresse BaseTon EEPROM
EECON1=0b00000001;                //autorise écriture, initialise lecture EEPROM
BaseTon=EEDAT;
EEADR=0x03;                        //adresse BaseToff EEPROM
EECON1=0b00000001;                //autorise écriture, initialise lecture EEPROM
BaseToff=EEDAT;

if(
Toff==0x00)                    //
    
{Toff=0xFF;                    //Permet de ne pas passer à Ton au premier démarrage
    
BaseToff=0b00000100;        //quand l'EEPROM n'est pas encore programmée
    
}                            //


//////////////////Boucle principale/////////////////////
    
while(1)                
    {

////////////////////Si appui sur BP gauche (Ton)///////////////////////
        
if (BP_Ton_RA2==0)                //BP de gauche
            
{
            
delay_ms(10);

            if (
T0IF==1)
                {
                
nbFlagTimer0++;
                
T0IF=0;
                }

            if (
BP_Ton_RA2==& (nbFlagTimer0<20))                //Si quand on relâche le BP, le flag a été déclenché moins de 20 fois, programmation Ton
                
{
                
nbFlagTimer0=0;
                
Ton = (RC3<<0) | (RC4<<1) | (RC5<<2) | (RA3<<3) | (RA4<<4) | (RA5<<5) | (RC1<<6) | (RC2<<7);        //on écrit l'état des 8 interrupteurs
                
clignotements_led_courts();
                
EEADR=0x00;                        //adresse Ton EEPROM
                
EEDAT=Ton;
                
sequence_write_EEPROM();
                }    

            if (
BP_Ton_RA2==& (nbFlagTimer0>20))                 //Si quand on relâche le BP, le flag a été déclenché plus de 20 fois, programmation BaseTon
                
{
                
nbFlagTimer0=0;
                
BaseTon = (RC3<<0) | (RC4<<1) | (RC5<<2) | (RA3<<3) | (RA4<<4) | (RA5<<5) | (RC1<<6) | (RC2<<7);        //on écrit l'état des 8 interrupteurs
                
clignotements_led_longs();
                
EEADR=0x02;                        //adresse Ton EEPROM
                
EEDAT=BaseTon;
                
sequence_write_EEPROM();
                }

            
sec=0;
            
min=0;
            
hr=0;
            }    



////////////////////Si appui sur BP droite (Toff)///////////////////////
        
if (BP_Toff_RC0==0)                //BP de droite
            
{
            
delay_ms(10);

            if (
T0IF==1)
                {
                
nbFlagTimer0++;
                
T0IF=0;
                }

            if (
BP_Toff_RC0==& (nbFlagTimer0<20))                //Si quand on relâche le BP, le flag a été déclenché moins de 20 fois, programmation Toff
                
{
                
nbFlagTimer0=0;
                
Toff = (RC3<<0) | (RC4<<1) | (RC5<<2) | (RA3<<3) | (RA4<<4) | (RA5<<5) | (RC1<<6) | (RC2<<7);        //on écrit l'état des 8 interrupteurs
                
clignotements_led_courts();
                
EEADR=0x01;                        //adresse Ton EEPROM
                
EEDAT=Toff;
                
sequence_write_EEPROM();
                }    

            if (
BP_Toff_RC0==& (nbFlagTimer0>20))                //Si quand on relâche le BP, le flag a été déclenché plus de 20 fois, programmation BaseToff
                
{
                
nbFlagTimer0=0;
                
BaseToff = (RC3<<0) | (RC4<<1) | (RC5<<2) | (RA3<<3) | (RA4<<4) | (RA5<<5) | (RC1<<6) | (RC2<<7);        //on écrit l'état des 8 interrupteurs
                
clignotements_led_longs();
                
EEADR=0x03;                        //adresse Ton EEPROM
                
EEDAT=BaseToff;
                
sequence_write_EEPROM();
                }

            
sec=0;
            
min=0;
            
hr=0;
            }    




////////////////////Si les conditions sont réunies pour basculement état sortie///////////////////////
        
if ((sec>=Ton) && (Relais_RA0==1) && (BaseTon==0b00000001))
            {
            
Relais_RA0=0;
            
Led_RA1=0;
            
sec=0;
            
min=0;
            
hr=0;
            }
        if ((
sec>=Toff) && (Relais_RA0==0) && (BaseToff==0b00000001))
            {
            
Relais_RA0=1;
            
Led_RA1=1;
            
sec=0;
            
min=0;
            
hr=0;
            }
        if ((
min>=Ton) && (Relais_RA0==1) && (BaseTon==0b00000010))
            {
            
Relais_RA0=0;
            
Led_RA1=0;
            
sec=0;
            
min=0;
            
hr=0;
            }
        if ((
min>=Toff) && (Relais_RA0==0) && (BaseToff==0b00000010))
            {
            
Relais_RA0=1;
            
Led_RA1=1;
            
sec=0;
            
min=0;
            
hr=0;
            }
        if ((
hr>=Ton) && (Relais_RA0==1) && (BaseTon==0b00000100))
            {
            
Relais_RA0=0;
            
Led_RA1=0;
            
sec=0;
            
min=0;
            
hr=0;
            }
        if ((
hr>=Toff) && (Relais_RA0==0) && (BaseToff==0b00000100))
            {
            
Relais_RA0=1;
            
Led_RA1=1;
            
sec=0;
            
min=0;
            
hr=0;
            }
    }
}


 


Retourner vers « Langage C »

Qui est en ligne

Utilisateurs parcourant ce forum : Aucun utilisateur enregistré et 29 invités