# Tutorat de microprocesseurs - Sujet 8 - Thermostat
## DJERABA Taky - HUBERT Thomas - PREUD'HOMME&nbsp;Geoffrey

# Sujet

Le projet consiste à réaliser un thermostat pour la commande du chauffage d'une maison individuelle. Le dispositif devra d'abord afficher alternativement la température et l'heure chaque 10s, sur des afficheurs 7-segments. Notre thermostat devra aussi permettre le réglage de la température pour chaque heure de la journée, selon deux modes : jour et nuit, dont les températures seront réglée par l'utilisateur. Enfin, la commande permettant l'allumage de la chaudière se fera en fonction de la température mesurée. Si celle-ci est de 0.5°C inférieure à la consigne fixée, la chaudière s'allume. Si la température mesurée dépasse la consigne de 0.5°C, la chaudière s'eteint.

De plus nous nous sommes fixés un objectif supplémentaire afin de faire programme qui consomme un minimum d'énergie. Bien que ce genre de système est branché en permanence au secteur et la consommation du micro-contrôleur est négligeable par rapport à celle de la chaudière, on considère que programmer de manière optimisée est une bonne pratique à adopter. On s'arrêtera dans cet objectif à l'optimisation des instructions assembleurs, procédé qui s'automatise facilement.

Enfin, afin de vérifier la validité de notre algorithme et de nos configurations, nous avons recréé une simulation du système avec une Arduino Mega 2560, qui est la carte que nous avons utilisé pour les TP de microprocesseurs, et que nous avons programmé en utilisant les mêmes outils utilisés pendant lesdits TP.


# Architecture matérielle

Voici à quoi ressemble la simulation du système que nous avons recréée :

![Schéma de la modélisation](montage.svg)

Voyons en détails ses composants :

## Entrées

On utilisera 4 boutons pour pouvoir modifier les paramètres : pour valider, revenir en arrière, incrémenter et décrémenter.

Pour chaque bouton, nous allons associer une résistance pull-up. Elle a pour rôle de maintenir la valeur en entrée du bouton à 5v quand le bouton n'est pas actionné, tout en lui permettant de prendre la valeur 0 sans qu'il se passe de court-circuit quand le bouton est pressé. En conséquence, quand le bouton n'est pas pressé, l'entrée digitale est branché à une résistance en série avec du 5V. Et comme aucun courant ne passe dans l'entrée digitale, il n'y a pas de chutes de tension aux bornes de la resistance. Quand le bouton est actionné, comme l'autre pin du bouton est branché à la masse, le broche lu est à la masse, mais du courant circule dans la resistance, qui dissipe donc de l'énergie. Par conséquent, pour limiter le courant et la puissance dissipée à l'appui du bouton, nous avons choisi des résistances élevées, soit de $1 M\Omega$.

Les boutons ont ensuite posé des problèmes à cause de leurs rebonds. Comme ils déclenchent des interruptions, tout phénomène de rebond - qui crée une suite de fronts montants et descendants -  est à supprimer pour éviter que plusieurs interruptions se déclenchent d'affilée à l'appui du bouton. Il faut donc lisser la tension, ce qui se fait en ajoutant une capacité entre les pattes des boutons. Pour le choix de nos valeurs, nous avons pu prendre des capacités de petites valeurs, car nos résistances pull-up avec une grosse valeur limitent fortement le courant pour charger les capacités. Nous avons choisi des capacités de $10 \nu F$, qui associées aux résistances de $1 M\Omega$, lissent la tension efficacement.

Afin de lire la température réelle pour pouvoir faire un asservissement, on utilisera un capteur de température analogique, qui peut lire de 5,0°C à 30,6°C (correspondant à une plage de 0 à 5 V). Pour la simulation, nous avons utilisé un potentiomètre, ce qui nous permet de simuler plus facilement les différents cas.

![Schéma des entrées](Entrees_bb.svg)

## Sorties

En sortie, nous avons utilisé 4 afficheurs 7-segments, lesquels permettront l'affichage de l'heure, de la température, et du mode de fonctionnement. Les afficheurs permettent aussi à l'utilisateur de régler le thermostat en faisant défiler les options de réglages (heure, date, réglage de la température en fonction de l'heure de la journée). Pour la simulation, nous avons utilisé un quadruple affichage 7-segments (et point) de 12 broches : 8 pour la selection des segments, et 4 pour la selection de l'afficheur.

Le fonctionnement de l'afficheur est simple. On envoie une valeur de tension positive sur les pattes des segments à allumer, et on met les pattes de selection de l'afficheur à la masse, pour que le courant passe entre les deux. Ainsi, les segments de l'afficheur sélectionné  seront allumés. On a ajouté des résistances à chaque patte de sélection d'afficheur pour limiter le courant débité, car il n'y a pas de résistances internes.

Pour utiliser cet afficheur, il suffira donc d'envoyer des 1 logiques pour les segments à afficher, et des 0 logiques pour les afficheurs à sélectionner. Il est intéressant de signaler que des diodes internes empêchent les courants de passer en sens inverse, quand le segment non allumé, donc à 0, est sur un afficheur non sélectionné, donc à 1, ce qui crée une tension négative aux bornes des résistances.

Enfin, le système ne serait rien sans la chaudière, qui se commande simplement par un signal logique (allumé ou éteint). On la simule avec une simple LED, mise en série avec une résitance pour en limiter le courant.

![Schéma des sorties](Sorties_bb.svg)

# Étude du fonctionnement

Avant de configurer les interfaces et d'écrire un algorithme, nous devons définir plus en détails comment notre système devra se comporter.

## Contrôle de la température

Concernant la régulation de la température, il a été prévu que celle-ci se fasse toutes les 10 secondes (soit au même moment que l'état de veille change, pour simplifier l'algorithme), car la température n'est pas un paramètre qui change très rapidement. Puisque l'allumage de la chaudière est asservi en température, notre dispositif utilise un capteur de température, lequel fournit une tension variant de 0 à 5V, correspondant à une plage de température allant de 5 à 30.6°C. 

La température mesurée est comparée aux valeurs $\text{température de référence} - 0.5\degree C$ et $\text{température de référence} + 0.5\degree C$ afin de savoir si il faut activer la chaudière ou non. Cela permet de créer un phénomène d'hysteresis afin d'éviter d'allumer et d'éteindre la chaudière trop fréquemment. Pour éviter un dépassement de capacité lors de la comparaison, on oblige l'utilisateur à choisir une température entre 5.5°C et 30.0°C.

## Menu

Pour pouvoir afficher et modifier les différentes valeurs que l'utilisateur a accès, on créé un menu, dont voici la hiérarchie :

- Veille
    - Association mode ↔ heure de la semaine
        - Lundi
        - Mardi
        - Mercredi
        - Jeudi
        - Vendredi
        - Samedi
        - Dimanche
    - Température du mode jour
    - Témpérature du mode nuit
    - Réglage de la date et heure
        - Jour de la semaine
        - Heures
        - Minutes

On peut passer d'un menu à son menu hiérarchiquement supérieur (parent) avec le bouton Retour. On passe d'un menu à un autre de niveau identique mais de même parent (frère) avec les boutons Incrémenter et Décrémenter. Lorsque l'on appuie sur le bouton Valider, deux choses peuvent se produire : si le menu possède des sous-menus (enfants), il passe au premier enfant, sinon, il permettra l'édition d'une valeur que l'on poura incrémenter ou décrémenter avec les boutons du même nom, et qui seront sauvegardées à l'aide du bouton retour. Même si ce menu peut sembler simple à en voir sa vue d'ensemble, il est beaucoup plus difficile à comprendre lorsqu'il est réduit à 4 afficheurs 7 segments. On oubliera pas de mettre ce genre d'information dans un guide si jamais ce système doit être utilisé par quelqu'un d'autre.

## Stockage des données

Les accès à la RAM nécessitant plus d'instructions et donc étant plus gourmands en énergie, on stockera un maximum d'informations dans les registres, de préférences les données étant lues/écrites les plus fréquemment. On y utilisera donc :

- `d3`, `d2`, `d1` et `d0` : les 4 digits de l'afficheur 7 segments en cours d'affichage. Ces informations devant être récupérées 4 fois toutes les quelques millisecondes, on ne calculera leur représentation que lors de leur changement et on les stockera dans ces registres.
- `PORTC` : afficheur 7 segment actuellement en cours d'affichage. Cela permet d'alterner les 4 dans l'ordre. Pour économiser un registre d'utilisation générale, on utilisera le fait que le port C est considéré comme un registre et sauvegarde les états qui lui sont envoyés.
- `t2`, `t1` et `t0` : stockage du temps actuel. Il y a $7 \times 24 \times 60 \times 60$ $=604800$ valeurs possibles pour ce compteur de temps. On a donc besoin de 3 registres $\left( 2^{8 \times 2} = 65536 < 604800 < 16777216 = 2^{8 \times 3} \right)$ pour stocker cette valeur. Afin de simplifier, sur le premier registre on utilisera 3 bits pour stocker le jour de la semaine, 5 bits pour l'heure du jour, on utilisera le deuxième registre pour stocker la minute de l'heure, et le troisième pour stocker les secondes de la minute. Cela permet de simplifier les calculs et d'éviter de faire des opérations sur des entiers de 24 bits.
- `etat` et `compteur` : ils permettent de stocker l'état actuel du menu.
- `reference` : contient la température désirée actuelle (c'est à dire pour le mode de l'heure actuelle). Étant comparée toutes les 10 secondes avec la température réelle et le calcul de sa valeur nécessitant de connaître le temps actuel, le mode associé à ce temps et la température associée à ce mode, on a jugé avantageux de le stocker dans un registre qui sera mis à jour au besoin.
- `temp` : registre dédié à certaines opérations temporaires. Malgré son nom, il n'a pas de rapport (la plupart du temps) avec la température.

Les associations de chaque heure de la semaine à son mode (jour/nuit) seront stockées dans la RAM. Bien qu'en théorie nous n'avons besoin que de $\frac{ \text{nb jours/semaine} \times \text{nb heures/jour} \times \text{nb bits pour stocker le mode} }{ \text{nb bits stockables sur une adresse} }$ $=\frac{7 \times 24 \times 1 }{ 8 }$ $=\frac{168}{8}$ $=21$ adresses pour stocker ces informations, on préfèrera utiliser une adresse par heure de la semaine, soit $168$ adresses. Bien que l'on perd en espace mémoire disponible, on garde en rapidité d'éxecution (et donc en énergie), en effet il n'est pas nécessaire d'utiliser des masques pour récupérer la valeur des bits individuels. Dans notre cas le microprocesseur n'abritera aucun autre programme avec qui il devra partager la RAM, et la consommation énergétique ne change pas selon le nombre d'adresses utilisées, il n'y a donc que des avantages à utiliser cette technique.

Enfin, on stockera les températures des deux modes dans la RAM également, car on y accède que toutes les heures (ou lors de leur modification), le registre `reference` agissant comme intermédiaire.

## Économies d'énergie

On s'est donné comme objectif d'économiser un maximum d'énergie. Pour cela, on préfèrera utiliser des interruptions plutôt que des scrutations, et ne déclencher les lectures que lorsque nécessaire. On n'activera aucune interface si nous n'en avons pas le besoin.

# Configuration des interfaces

## Interruptions externes

Pour éviter des scrutations, nos boutons sont branchés sur les ports d'interruptions `INT0` à `INT3`. On active donc les interruption au niveau du micro-contrôleur avec la directive `SEI` (qui servira aussi pour les autres interfaces mais on ne le rappelera pas). Ensuite, on active les interruptions sur front montant des entrées `INT0` à `INT3`, qui déclencheront une fonction dans le code.

## Ports parallèles

Nos afficheurs 7 segments se contrôlent par 12 broches. 8 servent à choisir les segments à afficher, elles seront branchées sur le port A de `PA0` à `PA7`, et 4 broches commandés en logique inversée servent à choisir l'afficheur à utiliser. Nous brancherons ces derniers sur le port C de `PC0` à `PC3`. Ces deux ports sont configurés en sortie.

Enfin, le signal de contrôle de la chaudière est branchée sur un port parallèle, un non utilisé par l'afficheur 7 segments pour simplifier éviter de faire des opérations d'entrée/sortie avec des masques. Pour la simulation, nous avons utilisé une LED branchée sur le port G (`PG0`), qui est donc configuré en sortie.

## Analogic to Digital Converter (ADC)

Le thermostat est branché sur l'entrée analgique `ADC0`. Pour éviter d'utiliser de l'énergie inutilement, on désactivera les autres convertisseurs analogique→numérique avec les directives `DIR0` et `DIR2`.

On configurera les registres concernant l'ADC  de manière à mettre les 8 bits de points forts sur un seul registre (`ADCH`). En effet, les valeurs de témpératures allant de 5,0 à 30,6°C, en choisissant une précision de 0,1° on obient 257 valeurs possibles, ce qui peut se stocker sur un seul régistre en faisant abstraction d'une valeur. Une précision supplémentaire ne semble pas nécessaire et de plus compliquée à gérer.

Il sera configuré pour s'activer sur demande, ici toutes les dix secondes. En effet, la température étant un paramètre variant très lentemenent, il n'est pas nécessaire et de plus énergivore de la lire continuellement. Enfin, il sera de plus configuré pour déclencher une interruption dès que la conversion est terminée afin d'éviter toute scrutation.

## Watchdog

Le Watchdog doit permettre de changer l'état de veille toutes les 10 secondes ainsi que garder la trace de la minute actuelle, on peut donc le configurer pour qu'il active une interruptions toutes les deux secondes (facteur de 10 et de 60).

Mais on s'est rendu compte que la fréquence d'appel était ~100× plus élevé que ce qui devrait être. N'ayant pas réussi à corriger ce comportement (que l'on a pu aussi constater en TP), nous avons dû trouver un autre moyen de procéder.

## Timer

Pour le timer, nous avons utilisé un prescaler à 256, ce qui nous permet d'avoir une fréquence égale à $\frac{16 MHz}{256^2}=244.140625Hz$, ce qui correspond à $4.1 ms$. Cela nous permet d'avoir un affichage complet tous les 16ms, ce qui est le maximum pour que la persistence rétinienne fasse effet et que le cerveau perçoive un affichage qui ne clignote pas. On le configure ainsi pour qu'il déclenche une interruptions à la fin de sa période (mode overflow).

# Algorithme

Voici la fonction principale du programme :

```avrasmplus
boucle:
    sleep
    jmp boucle
```

En effet, nous avons dit que pour économiser l'énergie, toutes les actions seraient gérées par des interruptions ; le reste du temps le micro-contrôleur ne fait que dormir. On peut se le permettre car les actions sont très courtes, et il n'y a donc peu de risque de conflit au cas où deux interruptions se déclencheraient en même temps.

L'algorithme étant assez lourd et redondant, on ne présentera que les principes clefs et quelques exemples d'astuces utilisés. Le code complet (et les outils utilisés pour l'ensemble du projet) sont disponibles à l'adresse suivante : <https://archives.plil.fr/gbontoux/s6-mp-tutorat/blob/master/principal.txt>.

## Interruptions

Voici les différentes fonctions qui sont appelées par le micro-contrôleur lui-même, et une vue d'ensemble de ce qu'elles sont censées faire.

### Timer

Déclenchée toutes les ~4 ms, elle change le digit de l'afficheur 4 × 7 segments actuellement affiché en modifiant la configuration du port C, et cenvoie sur le port A les données du registre `dX` correspondant.

```avrasmplus
timer:
    ; Notre composant requiert d'envoyer 0 sur PC7-4
    ; afin d'activer le digit qui y est connecté

    ; Affiche le digit suivant sur l'afficheur 7seg
    temp <- PORTC@IO ; On lis l'état précédent du port
    lsr temp ; On change de digit
    ; Il y a 4 digits et 8 bits, on doit donc boucler plus tôt
    si temp < 0b00001111 alors temp <- 0b11110111
    PORTC@IO <- temp
    ; On envoie le registre correpspondant
    si temp = 0b11110111 alors PORTA@IO <- d3
    si temp = 0b01111011 alors PORTA@IO <- d2
    si temp = 0b00111101 alors PORTA@IO <- d1
    si temp = 0b00011110 alors PORTA@IO <- d0
```

### Watchdog

Le watchdog ne fonctionnant pas, nous avons donc étendu l'interruption du timer pour pouvoir compter les secondes. Pour cela, un utilise un registre supplémentaire, `tt`, qui est incrémenté à chacune des interruptions du timer. Sa fréquence exacte étant de de $244.140625 Hz$, dès que `tt` a depassé $244$ on appelle donc la fonction qui était censée être appelée par le watchdog, `agir1s` qui gère les éxecute les fonctions dépendant du temps.

D'un point de vue énergétique, cette approche est beaucoup moins efficace car elle rajoute des instructions supplémentaires à l'interruption du timer, qui est la fonction « critique » du système car appelée $244$ fois par seconde.

### Convertisseur analogique→numérique

Cette interruption est déclenchée à chaque fois qu'une conversion analogique→numérique est terminée. Elle est donc déclenchée à peu près toutes les 10 secondes car les conversions ne sont demandées que depuis la fonction `agir10s`. Elle s'occupe d'activer ou de désactiver la chaudière en fonction de la température récupérée lors de la conversion, en se basant sur le registre `reference`. Par exemple, la chaudière est éteinte si la température dépasse de plus de 0,5 degrés la température de référence. Dans le code, on vérifiera si `ADCH > reference + 5`, car 0,1°C correspond à une unité. On remarque que l'on peut obtenir un dépassement si jamais `reference > 250`, ce qui n'est pas censé arriver car on ne propose à l'utilisateur que de choisir une température entre 5,5 et 30,0°C, `reference` est donc compris entre 5 et 250. Si jamais la température est comprise dans l'intervalle, le port G conserve l'état de la chaudière actuel.

*Note : Vous pourrez constater dans le code que cette interruption en déclenche une autre afin d'avoir un retour immédiat sur nos actions. Cela a été fait pour simplifier la présentation orale.*

### Boutons

À chaque bouton est associé une interruption, et chacune modifie l'affichage, les registres `etat` et/ou `compteur`, et éventuellement les valeurs de fonctionnement du système (heure actuelle, température des modes...), et ce en fonction des registres `etat` et `compteur` précédents.

## Fonction d'agissement

Certaines actions sont prises selon une base horaire. Elles sont déclenchées par l'interruption du timer (normalement celle du watchdog), lorsque leur intervalle de temps coïncide.

- `agir1s` : déclenchée toutes les secondes, elle met à jour les registres de temps, et appelle les fonctions `agir10s` et `agirHeure` si besoin
- `agir10s` : déclenchée toutes les dix secondes, elle change l'état de veille (affichage de l'heure ou température) si l'appareil est en veille. Dans tous les cas, elle déclenche une conversion analogique numérique pour lire le capteur de température.
- `agirHeure` : elle recharge depuis la RAM le mode actuel, et met à jour le registre `reference` contenant la température à utiliser.

*Note : On a laissé la possibilité à l'utilisateur de changer de mode de veille avec les boutons Incrémenter / Décrémenter, mais `agir10s` ne prend pas en compte les modifications de l'utilisateur. Il est donc possible que l'utilisateur change d'état de veille et que le système revienne juste après à l'état précédent.*

## Gestion des états

Chacun des boutons provoque une interruption qui modifie l'affichage et les valeurs nécessaires en fonction de celui qui a été appuyé et de l'état précédent du menu. Il faut alors stocker dans quel état est le menu en mémoire. On utilisera pour cela un registre `etat`, qui prendra les valeurs suivantes :

- 0→1 : Veille (Heure / Température)
- 2 : Menu Association mode ↔ Heure de la semaine
- 3→9 : Menu jours (Lundi - Dimanche)
- 10→16 : Paramétrage des jours (Lundi - Dimanche)
- 17 : Menu température du mode jour
- 18 : Paramétrage température du mode jour
- 19 : Menu température du mode nuit
- 20 : Paramétrage température du mode nuit
- 21 : Menu réglage de la date et heure
- 22→24 : Menu réglage du jour / heure / minute
- 25→27 : Paramétrage du jour / heure / minute

On parle de menu quand l'écran affiche le nom de l'élément que l'utilisateur s'apprête à modifier, et de paramétrage lorsque l'utilisateur voit la valeur qu'il est en train de modifier. Pour les paramètrages, un registre nommé `compteur` accompagne le registre `etat`, et permet de stocker la valeur qui est en cours de modification. À chaque appui sur un bouton, une interruption est émise et le code associé effectue une tâche qui varie selon la valeur d'`etat`. L'interruption peut changer certaines variables du système (la température du mode jour par exemple, ou l'heure actuelle), ou bien l'état lui-même.

Pour chaque état on a défini plusieurs fonctions qui sont appelés par les différents boutons. Pour un état donné `Demo`, on aura alors :

- `etatDemoU` qui permet de changer l'affichage pour l'état courant, éventuellement en fonction de la valeur de compteur dans le cas d'un paramètrage. Cette fonction est appelé à la fin de toutes les autres fonctions que l'on définira par la suite.
- `etatDemo` est l'action éxecutée lorsque l'utilisateur arrive sur l'état : la valeur du registre `etat` est changée, et la valeur de compteur est chargée avec la variable du système correspondante dans le cas d'un paramètrage.
- `etatDemoC` (paramètrages seulement) est appelé lorsque la valeur de compteur est changée par les boutons Incrementer ou Decrementer. Elle fait appel aux fonctions `boundType` qui permettent de remettre dans les bornes la valeur si elle passe hors de l'intervalle de définition (par exemple si une minute est incrémentée à 60 elle repasse à 0). Ensuite elle sauvegarde dans le bon endroit de la mémoire (registres ou RAM) la valeur de compteur.

Pour certains états, on aura aussi un comportement plus spécifique. Par exemple, lorsqu'on fait Retour depuis les états 10 à 16, la valeur d'`etat` est décrémentée de 7. On créera donc deux fonctions : `etatMenuJours` qui est utilisé quand on arrive d'un niveau parent (on passe donc à l'état 3, Lundi par défaut), et `etatMenuJoursR` qui est utilisé quand on arrive d'un niveau enfant (on passe donc à l'état du menu correspondant au jour que l'on venait de modifier).

Voici un exemple, pour le menu et le paramètrage de la sélection de la température du mode jour :

```avrasmplus
; Appelé depuis l'état  2 après un appui sur le  bouton Incrémenter
;                      19                               Décrémenter
;                      18                               Valider
;                      18                               Retour
etatMenuTJour:
    etat <- 17
    d3 <- 0x3c ; "JOUR"
    d2 <- 0x5c
    d1 <- 0x1c
    d0 <- 0x44
    reti

; Appelé depuis l'état 17 après un appui sur Valider
etatParaTJour:
    etat <- 18
    compteur <- tempJour ; Lecture depuis la RAM
etatParaTJourU:
    call afficherTemperature
    reti

; Appelé depuis l'état 18 après un appui sur Incrementer ou Decrementer
etatParaTJourC:
    call boundTemperature ; Remet la température dans les bornes
    tempJour <- compteur ; Écriture vers la RAM
    call agirHeure ; Au cas où on change le mode de l'heure actuelle, on recharge la température de référence
    jmp etatParaTJourU
```

*On remarque l'utilisation de `reti` et non de `ret`. Étant donné que ces fonctions sont les dernières appelées dans les interruptions des boutons, on fait de la sorte pour simplifier le code.*

## Fonctions usuelles

Pour clarifier le code et pouvoir le réutiliser, on définit un certain nombre de fonctions usuelles. Généralement, elles utilisent la valeur de compteur dans son contexte, et la modifie si besoin.

On y trouve les fonctions d'affichage, qui considèrent `compteur` comme une certaine donnée (un jour, une température, une minute) et l'affiche dans un format approprié. Par exemple, voici la fonction `afficherTemperature`, utiliser dans l'état de veille et pour paramétrer les températures des deux modes :

```avrasmplus
afficherTemperature:
    ; Considère le registre compteur comme une température et l'affiche
    d0 <- 0x63 ; Sigle degré
    d1 <- afficheur@ROM[compteur%10] ; Décimale
    temp <- compteur / 10 + 5 ; On stocke temporairement la partie entière pour simplifier
    d2 <- afficheur@ROM[temp%10] | 0b10000000 ; Chiffre des unités, auquel on ajoute le point
    d3 <- 0x00 ; On affiche le chiffre des dizaines si la température est > 10
    si temp > 10 alors d3 <- afficheur@ROM[temp/10]
    ret
```

Les boutons d'incrémentation et de décrémentation changent la valeur de `compteur` indépendamment du type de données qu'il contient. Il faut donc remettre à posteriori les valeurs dans leur intervalle de définition. Voici un exemple pour utilisé pour la modification de l'heure actuelle :

```avrasmplus
boundHeur:
    si compteur =  255 alors compteur <- 23
    si compteur >= 24  alors compteur <- 0
    ret
```

On utilise le fait qu'une décrémentation depuis la valeur 0 effectue un dépassement et remet le registre à 255. Nous ne pouvons pas utiliser le flag indiquant qu'un dépassement a eu lieu car l'incrémentation / la décrémentation de compteur s'effectue beaucoup plus tôt que la remise en borne. Pour faciliter la vie de l'utilisateur, lorsque l'on dépasse une des deux bornes, la valeur prend la borne opposée.

## Initialisation

Bien que ce genre de système n'est pas fait pour être redémarré (puisque les données ne sont pas enregistrées sur une mémoire morte), on préfère initialiser les paramètres du régulateur avec des valeurs par défaut, pour simplifier la vie de l'utilisateur. Par exemple par défaut le mode nuit est activé de minuit à 7h, et le mode jour le reste du temps. Cela lui permet d'éviter d'initialiser 168 valeurs à la main.

# Conclusion

Pour ce projet de thermostat, nous avons réalisé son architecture matérielle, son algorithme, et même réussi à en faire une simulation matérielle, ce qui a nécessite l'écriture de l'algorithme complet. Bien qu'un sujet similaire était proposé dans un des TP, on s'est rendu compte que l'ajout de certaines fonctions paraissant anodines (telles que la gestion du temps, ou un menu) nécessitent un gros travail pour tout coordonner. La réalisation de la simulation, a aussi posé quelques problèmes, mais elle a été utile pour se rendre compte que certains chemins envisagés au débuts n'étaient pas réalisables, et elle a permis de pouvoir tester notre algorithme. Au final ce fut une experience très enrichissante.

Si nous avions des ressources supplémentaires, nous aurions ajouté une mémoire morte pour sauvegarder les données même en cas de coupure de courant, et un module RTC (Real-Time Clock), pour un suivi plus précis du temps.



