Structure des plages horaires pour le thermostat - 23/03/2011. -------------------------------------------------------------- Le principe de stockage en mémoire des différentes plages de chauffe, se fait dans la mémoire eeprom. Chaque bit représente un quart d'heure, s'il est à zéro, la température de consigne sera la température de nuit et s'il est à un, la température de consigne sera la température de jour. Le système reprend la mémoire de 4 cycles qui contiennent chacun les 7 jours de la semaine et chaque jour est divisé en 1/4 d'heures. Ce qui nous fait 24 * 4 bits pour une journée, soit 12 octets. Un cycle comprend 7 jours, soit 7 * 12 = 84 octets. Ce qui nous fait pour les 4 cycles 84 * 4 = 336 octets en tout. Remarque : Faire attention que dans chaque octet, les Msb et Lsb sont inversés par rapport à la logique "horaire". Dans chaque octet, le bit de poids fort, représente le premier quart d'heure de la première heure, et le bit de poids faible représente le quatrième quart d'heure de la deuxième heure de l'octet. Le système permet la création de 4 plages par jour. Une plage consiste à une zone de consigne de jour. (Cette limitation sera ajoutée dans le mode d'emploi) Liste des variables nécessaires aux calculs ******************************************* PlagAdresse : Adresse mémoire du premier octet PlagCycle : Cycle en cours (varie de 0 à 3) PlagJour : Jour en cours (varie de 0=Lu à 6=Di) PlagHeure : Heure en cours (varie de 0 à 23) PlagMinute : Minute en cours (varie de 0 à 59) PlagQuart : Quart d'heure en cours (Varie de 0 à 3) 0 = de 00 à 14 minutes 1 = de 15 à 29 minutes 2 = de 30 à 44 minutes 3 = de 45 à 59 minutes PlagPosCyc : Adresse de base du cycle PlagPosJou : Adresse de base du Jour dans le cycle PlagPosHeu : Adresse de base de l'heure dans le jour PlagPosMem : Adresse mémoire de l'octet contenant l'heure et les minutes PlagValMem : Valeur de l'octet contenant l'heure et les minutes PlagPosBit : Position du bit à adresser dans l'octet sélectionné PlagValBit : Valeur du bit dans l'octet sélectionné PlagPlDe(4) : Début de plage de consigne de jour pour la journée (Varie de 0 à 95) PlagPlDu(4) : Durée de plage de consigne de jour pour la journée (Varie de 0 à 95) PlagConsign : Etat de la consigne de chauffe - Nuit = 0 - Jour = 1 Calculs de base *************** Calcul de l'adresse de base du cycle. PlagPosCyc = (PlagCycle*84) Calcul de l'adresse de base du jour dans le cycle. PlagPosJou = INT(PlagJour*12) Calcul de l'adresse de l'octet contenant l'heure. PlagPosHeu = INT(PlagHeure/2) Calcul de l'octet à adresser en fonction du cycle, de la date et de l'heure. PlagPosMem = PlagAdresse + PlagPosCyc + PlagPosJou + PlagPosHeu Calcul du quart d'heure en cours. PlagQuart = INT(PlagMinute/15) Calcul du bit à adresser en fonction de l'heure. PlagPosBit = 7 - (PlagHeure-(INT(PlagHeure/2)*2)+PlagQuart) Mise à zéro du bit PlagValMem = PlagValMem .AND. (255-2^PlagPosBit) Mise à un du bit PlagValMem = PlagValMem .OR. (2^PlagPosBit) Inversion du bit PlagValMem = PlagValMem .XOR. (2^PlagPosBit) Pour Rappel ----------- Position | Valeurs(2^i) |Valeurs(255-2^i) du Bit | Binaire : Dec | Binaire : Dec ---------+----------------+--------------- 0 | 00000001 : 1 | 11111110 : 254 1 | 00000010 : 2 | 11111101 : 253 2 | 00000100 : 4 | 11111011 : 251 3 | 00001000 : 8 | 11110111 : 247 4 | 00010000 : 16 | 11101111 : 239 5 | 00100000 : 32 | 11011111 : 223 6 | 01000000 : 64 | 10111111 : 191 7 | 10000000 : 128 | 01111111 : 127 Routine de recherche des plages de consigne de jour *************************************************** Variables d'entrée Adresse : Adresse mémoire du premier octet Cycle : Cycle en cours (varie de 0 à 3) Jour : Jour en cours (varie de 0=Lu à 6=Di) Variables de sortie PlDe(4) : Début de plage de consigne de jour pour la journée PlDu(4) : Durée de plage de consigne de jour pour la journée Variables de travail I : Variable de comptage PosCyc : Adresse du cycle PosJou : Adresse du jour Plage : Numéro de la plage en cours de traitement AdrOct : Adresse de l'octet à adresser ValOct : Valeur de l'octet adressé AdrBit : Numéro du bit à tester BitAnt : Valeur du bit testé précédement Duree : Durée de la plage en cours de traitement Octet : Octet à adresser PosCyc = (Cycle*84) ' Calcul de l'adresse du cycle PosJou = INT(Jour*12) ' Calcul de l'adresse du jour LET I = 1 ' Initialisation remise à zéro DO WHILE I < 5 ' Début boucle de remise à zéro LET PlDe(I) = 0 ' Mise à zéro "début" LET PlDu(I) = 0 ' Mise à zéro "durée" LET I = I+1 ' Incrémentation compteur ENDDO ' Bouclage de raz LET Plage = 1 ' Initialisation compteur "Debut" LET BitAnt = 0 ' Initialisation du bit "antérieur" LET I = 0 ' Initialisation variable de boucle DO WHILE I <= 95 ' Boucle sur les 96 bits à tester LET Octet = INT(I/12) ' Calcul de l'octet à adresser LEt AdrBit = 7-(I-(Octet*8))' Calcul du numéro du bit à adresser LET AdrOct = Adresse+PosCyc+PosJou ' Cacul de l'adresse de l'octet à tester LET ValOct = ' Traitement de l'erreur trop de plages ENDIF ' Fin du test de dépassement du nombre de plages ENDIF ' Fin du test de changement de bit ENDIF ' Fin du test du bit LET I = I + 1 ' Incrémentation de la variable de boucle ENDDO ' Bouclage sur les 96 bits Ecriture ou effacement d'une plage en mémoire ********************************************* Variables d'entrée Adresse : Adresse mémoire du premier octet Cycle : Cycle en cours (varie de 0 à 3) Jour : Jour en cours (varie de 0=Lu à 6=Di) PlDe(Cycle) : Début de plage PlDu(Cycle) : Durée de plage BitAction : 0 = éffacement, 1 = écriture Variables de sortie (Aucune) Variables de travail PlI : Variable de travail PlOctCal : Octet en cours de calcul PlBitCal : Bit en cours de calcul PlPosCyc : Adresse de base du cycle PlPosJou : Adresse de base du Jour dans le cycle PlPosMem : Adresse mémoire de l'octet contenant l'heure et les minutes PlValMem : Valeur de l'octet contenant l'heure et les minutes PlPosBit : Position du bit à adresser dans l'octet sélectionné PlValBit : Valeur du bit dans l'octet sélectionné LET PlPosCyc = (Cycle*84) ' Calcul de l'adresse de base du cycle LET PlPosJou = INT(Jour*12) ' Calcul de l'adresse de base du jour dans le cycle LET PlI = PlDe(Cycle) ' Init. de la boucle DO While PlI < PlDe(Cycle) + PlDu(Cycle) ' Comptage sur la durée LET PlOctCal = INT(plDe(Cycle)/8) ' LET PlBitCal = 7 - (PlDe(Cycle)-(PlOctCal*8)) ' LET PlPosMem = PlAdresse + PlPosCyc + PlPosJou + PlOctCal ' ' Calcul de l'octet à adresser en fonction du cycle, de la date et l'heure. LET PlValMem = ' IF BitAction = 0 THEN ' Si action éffacement LET PlValMem = PlValMem .OR. (.AND. (255-2^PlBitCal)' Effacement (Reset) ELSE ' Si action écriture LET PlValMem = PlValMem .OR. (2^PlBitCal) ' Ecriture (Set) ENDIF ' Fin de test Set/Reset LET PlI = PlI + 1 LET Octect à l'adresse PlPosmem = PlValMem ENDDO Lecture d'un bit de consigne de température dans la mémoire *********************************************************** Variables d'entrée Adresse : Adresse mémoire du premier octet Cycle : Cycle en cours (varie de 0 à 3) Jour : Jour en cours (varie de 0=Lu à 6=Di) Heure : Heure en cours (varie de 0 à 23) Minute : Minute en cours (varie de 0 à 59) Variable de sortie PlConsign : Nuit = 0 ; Jour = 1 Variables de travail PlPosCyc : Adresse de base du cycle PlPosJou : Adresse de base du Jour dans le cycle PlPosMem : Adresse mémoire de l'octet contenant l'heure et les minutes PlPosHeu : Adresse de base de l'heure dans le jour PlQuart : Quart d'heure en cours (Varie de 0 à 3) PlValMem : Valeur de l'octet contenant l'heure et les minutes PlPosBit : Position du bit à adresser dans l'octet sélectionné LET PlPosCyc = (Cycle*84) ' Adresse de base du cycle LET PlPosJou = INT(Jour*12) ' Adresse du jour dans le cycle LET PlPosHeu = INT(Heure/2) ' Adresse de l'octet heure LET PlPosMem = PlAdresse + PlPosCyc + PlPosJou + PlPosHeu ' Adresse de l'Octet à adresser LET PlValMem = LET PlQuart = INT(Minute/15) ' Quart d'heure en cours LET PlPosBit = 7 - (Heure-(INT(Heure/2)*2)+Quart) ' Numéro du bit à adresser LET PlConsign = ******************************************************************************* ***************************************** Variables d'entrées : PlagAdresse, Cycle, PlagJour, PlagHeure, PlagMinute, Variables de sorties : PlagPlDe(), PlagPlDu() Variables de travail : PlagCycle, PlagQuart PlagPosCyc, PlagPosJou, PlagPosHeu, PlagPosMem PlagValMem, PlagPosBit, PlagValBit, PlagConsign Sousroutines appellées : SUB CreaVarPlag ' Début de la routine LET PlagCycle = Cycle - 1 ' Cycle en cours (varie de 0 à 3) LET PlagPosCyc = (PlagCycle*84) ' Adresse de base du cycle. LET PlagPosJou = INT(PlagJour*12) ' Adresse de base du jour dans le cycle. LET PlagPosHeu = INT(PlagHeure/2) ' Adresse de l'octet contenant l'heure. LET PlagPosMem = PlagAdresse + PlagPosCyc + PlagPosJou + PlagPosHeu ' Calcul de l'octet à adresser en fonction ' du cycle, de la date et de l'heure. LET PlagQuart = INT(PlagMinute/15)' Quart d'heure en cours. LET PlagPosBit = 7 - (PlagHeure-(INT(PlagHeure/2)*2)+PlagQuart) ' Bit à adresser en fonction de l'heure. ENDSUB ' Fin de la routine Mise à zéro du bit : PlagValMem = PlagValMem .AND. (255-2^PlagPosBit) Mise à un du bit : PlagValMem = PlagValMem .OR. (2^PlagPosBit) Inversion du bit : PlagValMem = PlagValMem .XOR. (2^PlagPosBit)