Avant de pouvoir commencer réellement l'écriture de la structurée, il faut d'abord
étudier les datasheets des trois circuits spécialisés que nous allons utiliser,
pour en ressortir les protocoles.
C'est grâce à ces protocoles que nous pourrons écrire notre structurée.
Etude du MC14489 : Circuit d'affichage à 5 Digits LED 7 segments
----------------------------------------------------------------
La lecture du datasheet nous indique que la commande se fera en mode série, avec
l'envoi du bit de poids fort en premier.
Suivant nos besoins, nous pouvons envoyer soit un octet (qui programmera le registre
de configuration), soit trois octets (qui programmerons l'afficheur proprement dit).
Pour ce qui est du protocole "électrique", il est assez traditionnel.
1 - La pin ENABLE est mise à l'état "BAS" pour activer le circuit.
2 - Puis, le premier bit est présenté sur la pin DATA.
3 - Un "Flanc Montant" sur l'entrée CLOCK permet au registre à décalage
de s'incrémenter.
4 - Les points 2 et 3 sont répétés 8 fois ou 24 fois suivant que
l'on envoie une "configuration" ou des "données".
5 - Enfin, la pin ENABLE est mise à l'état "HAUT", ce qui a pour effet
de "latcher" soit le registre de configuration, soit les sorties.
Si l'on envoie un seul octet il sera donc considéré comme une octet de commande.
Cet octet de commande est décomposé de la manière suivante :
- Bit 7 : Voir remarque 1 pour afficheurs 4 et 5
- Bit 6 : Voir remarque 1 pour afficheur 1, 2 et 3
- Bit 5 : Voir remarque 2 pour afficheur 5
- Bit 4 : Voir remarque 2 pour afficheur 4
- Bit 3 : Voir remarque 2 pour afficheur 3
- Bit 2 : Voir remarque 2 pour afficheur 2
- Bit 1 : Voir remarque 2 pour afficheur 1
- Bit 0 : 1 = Mode Normal, 0 = Mode Faible Puissance
Remarque 1 : 0 = Pas de décodage, ce mode est utilisé lorsque l'on utilise
des leds séparées et non pas des afficheurs 7 segments.
Dans ce mode, il est possible de commander 20 leds (5X4)
avec un circuit MC14489. En matriçant sur les banks 1 à 5
et les segments a, b, c et d.
1 = Décodage suivant les options choisies par les bits 7 à 1.
Remarque 2 : 0 = Décodage Hexadécimal (0,1,2,3,4,5,6,7,8,9,A,b,C,d,E,F)
1 = Décodage "spécial" ( ,c,H,h,J,L,n,o,P,r,U,u,y,-,=,°)
Si l'on envoie trois octets, se seront alors des valeurs envoyées à l'afficheur.
Ces trois octets sont en fait divisés en 6 Nibbles.
Le premier Nibble envoyé reprend la luminosité de l'afficheur et les points
décimaux (segment h) selon la décomposition suivante :
- Bit 3 : 0 = Leds "dimmées", 1 = Leds éclairées à fond
- Bit 2 : / Selon valeur de 0 à 7 | 0= pas de points | 1=Point afficheur 1
- Bit 1 : < 2=Point afficheur 2 | 3=Point afficheur 3 | 4=Point afficheur 4
- Bit 0 : \ 5=Point afficheur 5 | 6=Point affi 1 et 2 | 7=Point sur tous
Les cinq Nibbles suivants reprennent les valeurs à afficher sur les 5 digits.
Selon le cahier des charges, nous voyons que l'afficheur pourra avoir trois formats
différents : "HH=MM" , "TTT°", "-TT°", suivant les demandes. "H", "M" et "T"
représente des simples digits (de 0 à 9), et nous avons en plus les signes
"=", "-" et "°" qui sont des caractères "spéciaux".
Le datasheet nous indique que les 5 afficheurs sont numérotés 1 à 5 de droite
à gauche. Donc, suivant nos besoins, nous aurons trois possibilités :
1 - Affichage de l'heure
- Envoi d'un octet de configuration selon le format :
1 - 1 - 0 - 0 - 1 - 0 - 0 - 1 ($C9) (201)
(soit décodage normal pour les digits 5, 4, 2, et 1
et décodage "spécial" pour le digit 3)
- Envoi des 6 Nibbles de données selon le format :
$8 - $H - $H - $E - $M - $M
(ou chaque Nibble $H représente un digit de l'Heure,
chaque Nibble $M représente un digit des minutes,
le premier $8 représente "pas de points décimaux"
et allumage des digits à pleine puissance,
et $E représente le signe "=")
2 - Affichage des températures Positives
- Envoi d'un octet de configuration selon le format :
1 - 1 - 1 - 0 - 0 - 0 - 1 - 1 ($E3) (227)
(soit décodage normal pour les digits 4, 3, et 2
et décodage "spécial" pour le digit 5 et 1)
- Envoi des 6 Nibbles de données selon le format :
$8 - $0 - $T - $T - $T - $F
(ou chaque Nibble $T représente un digit de Température,
le premier $8 représente "pas de points décimaux"
et allumage des digits à pleine puissance, $0 représente
digit éteint et $F représente le signe "°")
3 - Affichage des températures Négatives
- Envoi d'un octet de configuration selon le format :
1 - 1 - 1 - 1 - 0 - 0 - 1 - 1 ($F3) (243)
(soit décodage normal pour les digits 3, et 2
et décodage "spécial" pour le digit 5, 4 et 1)
- Envoi des 6 Nibbles de données selon le format :
$8 - $0 - $D - $T - $T - $F
(ou chaque Nibble $T représente un digit de Température,
le premier $8 représente "pas de points décimaux"
et allumage des leds à pleine puissance, $0 représente
digit éteint, $D représente le signe "-" et $F représente "°")
Etude du DS1302 : Horloge temps réel Charge et RAM
--------------------------------------------------
Dans le projet qui nous occupe, nous n'utiliserons ni la ram, ni le circuit
de charge. Nous allons donc nous concentrer uniquement sur la partie RTC,
"horloge temps réel".
Comme pour le circuit précédent, la commande se fait sous forme série, mais ici,
c'est le bit de poids faible qui est envoyé en premier.
Le protocole "électrique", fonctionne de manière différente suivant qu'il s'agit
d'une lecture ou d'une écriture.
Lors d'une écriture nous avons les actions suivantes :
1 - La pin ENABLE est mise à l'état "HAUT" pour activer le circuit.
2 - Puis, le premier bit est présenté sur la pin I/O.
3 - Un "Flanc Montant" sur l'entrée CLOCK permet l'écriture du bit présent
sur la pin I/O dans le registre.
4 - Les points 2 et 3 sont répétés 16 fois.
5 - Enfin, la pin ENABLE est remise à l'état "BAS", ce qui a pour effet
de confirmer l'écriture et de désactiver le circuit.
Lors d'une Lecture, nous avons une petite différence. Le cycle commencera par une
écriture, il faut d'abord écrire l'adresse :
1 - La pin ENABLE est mise à l'état "HAUT" pour activer le circuit.
2 - Puis, le premier bit est présenté sur la pin I/O.
3 - Un "Flanc Montant" sur l'entrée CLOCK permet l'écriture du bit présent
sur la pin I/O dans le registre.
4 - Les points 2 et 3 sont répétés 8 fois.
Puis, nous passons à la lecture de l'octet envoyé par le circuit.
5 - Présentation d'un "Flanc Descendant" sur l'entrée clock du circuit
6 - Lecture du bit envoyé sur la Pin I/O.
7 - Les points 5 et 6 sont répétés 8 fois.
8 - Enfin, la pin ENABLE est remise à l'état "BAS".
Deux modes sont disponibles. Le mode BURST qui permet de lire ou écrire tous les
octets de la ram ou tous les registres de la RTC d'une seule traite. Le deuxième
mode est le mode normal qui permet de lire ou d'écrire un seul octet à la fois.
Dans application, nous utiliserons le mode normal. Puisque sur les 9 registres
de l'horloge, seul 3 registres seront utilisé de manière courante (Les heures,
les minutes et les secondes).
Le format de lecture ou d'écriture est composé de deux octets. Le premier octet
envoyé à l'adresse et constitue toujours une écriture vers le circuit.
Le deuxième octet constitue la donnée, et sera envoyé ou reçu, selon qu'il
s'agisse d'une écriture ou d'une lecture.
L'octet d'adresse possède la structure suivante :
- Bit 7 : toujours à 1
- Bit 6 : 0 = RTC, 1 = Ram
- Bit 5 : A4
- Bit 4 : A3
- Bit 3 : A2
- Bit 2 : A1
- Bit 1 : A0
- Bit 0 : 0 = Ecriture, 1 = Lecture
Où A0-A4 représente l'adresse de registre ou de Ram.
Donc, nous pouvons dire que les adresses $80 à $BF (10xxxxxx) concernent la RTC
et que les adresse $C0 à $FF (11xxxxxx) concernent la RAM, les adresses paires
correspondant à des écritures, et les impaires à des lectures.
Pour la partie RTC, nous avons les adresses suivantes :
1 - 00000 : Secondes (de 0 à 59)
2 - 00001 : Minutes (de 0 à 59)
3 - 00010 : Heures (de 1 à 12 ou de 0 à 23)
4 - 00011 : Date (de 1 à 31)
5 - 00100 : Mois (de 1 à 12)
6 - 00101 : Jour (de 1 à 7)
7 - 00110 : Année (de 0 à 99)
8 - 00111 : Protection en écriture de la RAM
9 - 01000 : Programmation du circuit de charge
Dans notre application, nous utiliserons les registres des secondes, minutes et
heures, soit respectivement les adresses $80(128), $82(130), $84(132) en écriture
et les adresses $81(129), $83(131), $85(133) en lecture.
Pour les secondes et les minutes, les bits 0 à 3 contiennent les unités, et les
bits 4 à 6 les dizaines (0 à 5), le bit 7 étant toujours à 0.
Pour les heures, nous travaillerons en mode 12 heures. Dans ce mode, les bits 0 à 3
contiennent les unités, le Bit 4 contient les dizaines d'heures (0 ou 1), le Bit 5
contient le moment de la journée 0 = AM et 1 = PM, le Bit 6 est toujours à 0 et le
Bit 7 est mis à 1 pour forcer le mode 12 heures.
Le mode 12 heures à été sélectionné parce que nous travaillons avec un STAMP qui
travaille en 16 bits. Si nous décidons de travailler en mode secondes, nous avons
24 X 60 X 60 secondes en une journée, soit 86400 secondes. Or, une variable Word
ne peut compter que jusque 65535. Par contre, en mode 12 heures, nous aurons
43200 secondes par tranche de calcul, ce qui ne pose pas de problème dans une
variable 16 bits.
Donc, en résumé, nous aurons pour ce circuit :
1 - Lecture des secondes :
Ecriture de $81, puis lecture de $SS sur 2 Nibbles.
2 - Lecture des Minutes :
Ecriture de $83, puis lecture de $MM sur 2 Nibbles.
3 - Lecture des Heures :
Ecriture de $85, puis lecture de $HH sur 4 bits et 1 Nibble.
4 - Remise à zéro des secondes :
Ecriture de $80, puis écriture de $00.
5 - Ecriture des Minutes :
Ecriture de $82, puis écriture de $MM.
6 - Ecriture des Heures :
Ecriture de $84, puis écriture de $HH.
NB : Les valeurs $SS, $MM et $HH étant les valeurs converties
en hexadécimal des secondes, minutes et heures.
Etude du DS1620 : Thermomètre digital et thermostat.
----------------------------------------------------
Le DS1620 Possède deux modes de fonctionnement :
- Un mode "Stand-Alone" qui lui permet de fonctionner seul.
- Un Mode "Trois fils" dans lequel il fonctionne raccordé à un µcontrôleur.
Pour notre application, nous utiliserons le mode 3 fils.
De plus, nous utiliserons ce circuit dans un mode très simple, puisque
les fonctions thermostatiques ne serons pas utilisées, et que le circuit
sera mis en mode de conversion permanente. Dans ces conditions, il nous suffira
de lire la température à chaque fois que nous en aurons besoin.
Comme pour les deux autres circuits, le DS1620 fonctionne en mode série avec
l'envoi du bit de poids faible en premier.
Le protocole électrique est le même que pour le DS1302.
Dans le DS1620, la conversion se fait sur 9 bits. La précision est le demi degré
et la variable 9 bit utilisée est en fait une variable définie en mode signé.
Le 9ieme bit représente le signe (0=Positif, 1=Négatif).
En mode positif, les conversion se font naturellement ($00=0°C, $01=0,5°C,
$FA=125°C). Par contre, en mode négatif, la conversion se fait sur le
complémentaire à deux, c'est à dire, l'inverse de la lecture + 1,
ce qui nous donne : $FF=-0,5°C, $CC=-26°C et $92=-55°C.
La gamme de mesure s'étend de -55°C jusque 125°C.
Lors de l'utilisation du DS1620, nous allons toujours lui envoyer une commande,
en mode écriture, suivi soit d'une deuxième écriture, soit d'une lecture suivant
la commande envoyée. Pratiquement, dans notre application, nous n'utiliserons que
deux commandes :
1 - Tout au début du programme, l'écriture de la configuration dans
le registre de commande du DS1620. Soit $0C (Write config),
suivi de $EA (Mode CPU en conversion continue)
2 - Pendant le programme, lecture de la température, ce qui nous donne
l'écriture de la commande $AA (Lecture de la température), suivi de
la lecture de la valeur de la température sur 9 Bits !!!
Ceci étant fait, nous pouvons commencer à écrire notre structurée
*******************************************************************************
Liste des Sous Routines
***********************
SUB Initstamp
Initialisation des entrées et sorties du Stamp
SUB Initvar
' Initialisation des constantes
' Initialisation des variables
SUB Initcirc
' Initialisation hardware des circuits.
' En entrée, cette routine a besoin des constantes hardware
' PEnbA, PDatA, PClkA, PEnbH, PDatH, PClkH, PEnbT, PDatT et PClkT.
' Il n'y a pas de variable de sortie.
' Cette routine utilise les routines AFFIHEURE, READHEURE.
SUB WRITEAFFI
' Routine d'écriture des valeurs dans l'afficheur.
' En entrée, cette routine à besoin des
' constantes "Hardware" : PEnbA, PDatA et PClkA
' et des variables "Software" Comser et Digit(n).
' La variable de travail i est modifiée.
' Il n'y a pas de variable de Sortie.
SUB WRITEHEURE
' Routine d'écriture de l'heure dans le DS1302.
' En Entrée, cette routine à besoin des
' variables Moment, Heures et minutes
' et des constantes "hardware" : PEnbH, PDatH et PClkA.
' Les variables de travail i et j sont modifiées.
' Il n'y a pas de variable de Sortie.
SUB READHEURE
' Routine de lecture de l'heure dans le DS1302.
' En Entrée, cette routine à besoin des
' constantes "Hardware" : PEnbH, PDatH et PClkH
' Les variables de travail Precmoment, i, j et k sont modifiées.
' En sortie, les variables Moment, Heures, Minutes , Secondes
' et Tempstot sont mises à jour.
SUB READTEMP
' Routine de lecture de la température dans le DS1620.
' En Entrée, cette routine à besoin des
' constantes "Hardware" : PEnbT, PDatT et PClkT.
' La variable de travail i est modifiée.
' En sortie, les variables Température et Signtemp
' sont mises à jour.
SUB LECTURE
' Routine de lecture des touches et du Pot
' En Entrée, cette routine à besoin des
' constantes "hardware" : BoutonUP, BoutonDN et Pot
' Les variables de travail i, j et k sont modifiées
' En sortie, les variables TempoM et Touche
' sont modifiées.
SUB AFFIHEURE
' Routine d'affichage des heures.
' En entrée, cette routine à besoin des variables
' Heures et Minutes.
' Les variables Comser et Digit(4) sont modifiées.
' Il n'y a pas de variables de sortie.
' Cette routine utilise la routine WRITEAFFI
SUB AFFITEMP
' Routine d'affichage de la température
' En entrée cette routine à besoin des variables
' Température et Signtemp
' Les variables Comser et Digit(4) sont modifiées.
' Il n'y a pas de variables de sortie.
' Cette routine utilise la routine WRITEAFFI
SUB CHANGEHEURE
' Routine qui effectue le changement d'heure, et qui
' met à jour le circuit DS1302
' En entrée, la routine à besoin de la variable touche
' et de la constante Timemax
' Les variables Timeout, Compteur, Moment, Heures, Minutes,
' Secondes et Anttouche sont modifiées.
' Il n'y a pas de variables de sortie.
' Cette routine utilise les routines WRITEHEURE, AFFIHEURE
' et LECTURE.
Structure du programme
**********************
BEGIN
DECLARE PEnbA AS Nibble ' Constante : n° de pin Enable de l'afficheur
DECLARE PDatA AS Nibble ' Constante : n° de pin Data de l'afficheur
DECLARE PClkA AS Nibble ' Constante : n° de pin Clock de l'afficheur
DECLARE PEnbH AS Nibble ' Constante : n° de pin Enable de l'horloge
DECLARE PDatH AS Nibble ' Constante : n° de pin Data de l'horloge
DECLARE PClkH AS Nibble ' Constante : n° de pin Clock de l'horloge
DECLARE PEnbT AS Nibble ' Constante : n° de pin Enable du Thermomètre
DECLARE PDatT AS Nibble ' Constante : n° de pin Data du Thermomètre
DECLARE PClkT AS Nibble ' Constante : n° de pin Clock du Thermomètre
DECLARE BoutonUP AS Nibble ' Constante : n° de pin du bouton poussoir UP
DECLARE BoutonDN AS Nibble ' Constante : n° de pin du bouton Poussoir DOWN
DECLARE Pot AS Nibble ' Constante : n° de pin du potentiomètre
DECLARE Timemax AS Byte ' Constante : Butée de Timeout pour la lecture
' Cette constante est à définir pour obtenir
' la temporisation de timeout voulue
' dans la routine de lecture
DECLARE Comser AS Byte ' Variable : commande pour les circuits séries
DECLARE Digit(4) AS Nibble ' Variable : Contenu des 5 digits à afficher
DECLARE Tempstot AS Word ' Variable : Temps total en secondes
DECLARE TempoT AS Word ' Variable : Temps de démarrage de la Tempo
DECLARE Moment AS Bit ' Variable : Indique AM=0 et PM=1
DECLARE Precmoment AS Bit ' Variable : Moment de la journée précédent
' (Pour le changement AM - PM )
DECLARE Heures AS Byte ' Variable : Heures (0 à 24)
DECLARE Minutes AS Byte ' Variable : Minutes (0 à 59)
DECLARE Secondes AS Byte ' Variable : secondes (0 à 59)
DECLARE Température AS Byte ' Variable : Valeur de la température (0 à 125)
DECLARE Signtemp AS Bit ' variable : Signe de la température 0=+, 1=-
DECLARE TempoM As Nibble ' Variable : Mesure de la Tempo en fonction du Pot
DECLARE Touche AS Nibble ' Variable : Etat des touches
' (0 : Pas de touche, 1 : Touche UP et 2 Touche DOWN)
DECLARE Anttouche AS Nibble ' Variable : Touche antérieure
DECLARE Compteur AS Byte ' Variable : Nombre d'appuis sur une touche
DECLARE Timeout AS Byte ' Variable : Compteur pour le timeout dans la lecture
DECLARE i AS Word ' Variable de travail
DECLARE j AS Word ' Variable de travail
DECLARE k AS Word ' Variable de travail
GOSUB Initstamp ' Initialisation du Stamp
GOSUB InitVar ' Initialisation des variables
GOSUB InitCirc ' Initialisation des périphériques
' Début réel du programme Principal.
DO WHILE i=i ' boucle "infinie"
' Partie de programme pour l'affichage de l'heure
GOSUB READHEURE ' Lecture de l'heure
GOSUB AFFIHEURE ' Affichage de l'heure
LET TempoT = Tempstot ' Initialisation de la tempo
' pour le changement d'affichage
LET Precmoment = Moment ' Initialisation du moment précédent
' (Le moment avant de rentrer dans la boucle)
DO ' Début de la boucle d'affichage
GOSUB LECTURE ' Lecture des touches et du POT
IF Touche > 0 THEN ' Si appuis d'une touche
GOSUB CHANGEHEURE ' Aller à la routine changement d'heure
ENDIF '
GOSUB READHEURE ' Lecture de l'heure
GOSUB AFFIHEURE ' Affichage de l'heure
IF Moment <> Precmoment THEN ' Si changement de moment (AM - PM)
LET TempoT = O ' Remise à zéro de tempoT
ENDIF ' (Petite erreur, mais acceptable)
UNTIL Tempstot > TempoT + TempoM ' Bouclage tant qu'il n'y a pas de
' dépassement de la tempo fixée par le POT
' Partie de programme pour l'affichage de la température
LET TempoT = Tempstot ' Initialisation de la tempo
' pour le changement d'affichage
LET Precmoment = Moment ' Initialisation du moment précédent
DO ' Début de la boucle d'affichage
GOSUB READHEURE ' Lecture de l'heure (pour Tempstot)
GOSUB READTEMP ' Lecture de la température
GOSUB AFFITEMP ' Affichage de la température
IF Moment <> Precmoment THEN ' Si changement de moment (AM - PM)
LET TempoT = O ' Remise à zéro de tempoT
ENDIF ' (Petite erreur, mais acceptable)
UNTIL Tempstot > TempoT + TempoM ' Bouclage tant qu'il n'y a pas de
' dépassement de la tempo fixée par le POT
ENDDO
END
SUB Initstamp
définir P00 en sortie ' Serial data (commun au DS1302 et DS1620)
définir P01 en sortie ' Serial Clock (commun au DS1302 et DS1620)
définir P02 en sortie ' RST-1302 (Contrôle du DS1302)
définir P03 en sortie ' RST-1620 (Contrôle du DS1620)
définir P04 en sortie ' ENB-14489 (Contrôle du MC14489)
définir P05 en sortie ' CLK-14489 (Serial Clock du MC14489)
définir P06 en sortie ' DATA-14489 (Serial Data du MC14489)
définir P07 en entrée ' * Pas Utilisé toujours mettre en entrée par sécurité
Définie P08 en entrée ' Bouton Up
Définie P09 en entrée ' Bouton Down
définir P10 en entrée ' * Pas Utilisé * toujours mettre en entrée par sécurité
définir P11 en entrée ' * Pas Utilisé * toujours mettre en entrée par sécurité
définir P12 en entrée ' * Pas Utilisé * toujours mettre en entrée par sécurité
définir P13 en entrée ' * Pas Utilisé * toujours mettre en entrée par sécurité
définir P14 en entrée ' * Pas Utilisé * toujours mettre en entrée par sécurité
Définie P15 en entrée ' Potentiomètre
Mettre P02 à l'état Bas ' Met le DS1302 en attente
Mettre P03 à l'état Bas ' Met le DS1620 en attente
Mettre P04 à l'état haut ' Met le MC14489 en attente
ENDSUB
SUB Initvar
' Initialisation des constantes
LET PEnbA = 4 ' N° de Pin Enable du MC14489
LET PDatA = 6 ' N° de Pin Data du MC14489
LET PClkA = 5 ' N° de Pin Clock du MC14489
LET PEnbH = 2 ' N° de Pin Enable du DS1302
LET PDatH = 0 ' N° de Pin Data du DS1302
LET PClkH = 1 ' N° de Pin Clock du DS1302
LET PEnbT = 3 ' N° de Pin Enable du DS1620
LET PDatT = 0 ' N° de Pin Data du DS1620
LET PClkT = 1 ' N° de Pin Clock du DS1620
LET BoutonUP = 8 ' N° de Pin du Poussoir UP
LET BoutonDN = 9 ' N° de Pin du Poussoir DOWN
LET Pot = 15 ' N° de Pin du potentiomètre
' Initialisation des variables
LET i = 0 ' Initialisation
LET j = 0 ' des
LET k = 0 ' variables
LET l = 0 ' de travail
DO WHILE i<=4 ' début de boucle de mise à zéro des digits
LET Digit(4) = 0 ' mise à zéro des digits
ENDDO ' fin de boucle
LET Comser = 0 ' \
LET Moment = 0 ' |
LET Heures = 0 ' |
LET Minutes = 0 ' | initialisation
LET Secondes = 0 ' \ des
LET Température = 0 ' / différentes
LET Signtemp = 0 ' | variables
LET Tempstot = 0 ' |
LET Touche = 0 ' |
LET TempoM = 1 ' /
ENDSUB
SUB Initcirc
' Initialisation hardware des circuits.
' En fait, Seul le DS1620 (Température) doit être
' initialisé. Mais, par sécurité, nous effectuerons
' la lecture et l'affichage de l'heure, ce qui
' nous permettra de tester les circuits DS1302 et MC14489.
' En entrée, cette routine a besoin des constantes hardware
' PEnbA, PDatA, PClkA, PEnbH, PDatH, PClkH, PEnbT, PDatT et PClkT.
' Cette routine utilise les routines AFFIHEURE, READHEURE.
Pin PenbT mise à l'état haut ' Activation du DS1620
Envoi de $OC en mode série sur les pins PDatT et PClkT
' Commande "Write Config"
Envoi de $EA en mode série sur les pins PDatT et PClkT
' Commande "Mode CPU en conversion continue"
Pin PenbT mise à l'état bas ' désactivation du DS620
GOSUB READHEURE
GOSUB AFFIHEURE
ENDSUB
SUB WRITEAFFI
' Routine d'écriture des valeurs dans l'afficheur.
' L'envoi des données se fait en deux temps.
' D'abord, un octet de commande (conser) est envoyé
' Puis après une courte pose, les 6 nibbles
' de datas ($8 et Digit(4)) sont envoyés.
' En entrée, cette routine à besoin des
' constantes "Hardware" : PEnbA, PDatA et PClkA
' et des variables "Software" Comser et Digit(n).
' La variable de travail i est modifiée.
' Il n'y a pas de variable de Sortie.
Pin PEnbA mise à l'état bas ' Activation de l'afficheur
Envoi de la variable comser en mode série sur les pins PDatA et PClkA
' La variable Comser sera mise à $F7, $DD
' ou $CD, suivant le type d'affichage
' (Heure, T° positives ou T° négatives)
Pin PEnbA mise à l'état haut ' Latch des valeurs dans l'afficheur
Pause de 1 ms ' Séparation de la commande et des datas
Pin PEnbA mise à l'état bas ' Activation de l'afficheur
Envoi de la valeur $8 sur un nibble en mode série sur les pins PDatA et pclkA
' Ecriture de "Pas de points décimaux"
LET i = 0 ' Initialisation de boucle
DO WHILE i<=4 ' début de boucle d'envoi des valeurs
Envoi de la variable Digit(i) en mode série sur les pins pDatA et PClkA
LET i = i+1 ' Incrémentation du compteur de boucle
ENDDO ' fin de boucle
Pin PEnbA mise à l'état haut ' Latch des valeurs dans l'afficheur
ENDSUB
SUB WRITEHEURE
' Routine d'écriture de l'heure dans le DS1302.
' L'envoi des données du circuit se fait en trois temps.
' Le registre des secondes est d'abord remis à zéro,
' puis le registre des minutes est mis à jour et
' enfin le registre des heures est mis à jour.
' En Entrée, cette routine à besoin des
' variables Moment, Heures et minutes
' et des constantes "hardware" : PEnbH, PDatH et PClkH.
' Les variables de travail i et j sont modifiées.
' Il n'y a pas de variable de Sortie.
i = ENT(Minutes/10)*16 + (Minutes - ENT(Minutes/10)*10)
' Conversion des Minutes en "BCD"
j = ENT(Heures/10)*16 + (Heures - ENT(Heures/10)*10) + Moment*32 + 128
' Conversion des Heures en "BCD"
Pin PEnbH mise à l'état haut ' Activation du DS1302
Envoi de $80, puis $00 en mode série sur les pins PDatH et PClkH
' Remise à zéro des secondes
Pin PenbH mise à l'état bas ' désactivation du DS1302
Pause de 1mS ' Pause pour "CE inactive Time"
Pin PEnbH mise à l'état haut ' Activation du DS1302
Envoi de $82, puis i en mode série sur les pins PDatH et PClkH
' Ecriture des Minutes
Pin PenbH mise à l'état bas ' désactivation du DS1302
Pause de 1mS ' Pause pour "CE inactive Time"
Pin PEnbH mise à l'état haut ' Activation du DS1302
Envoi de $84, puis j en mode série sur les pins PDatH et PClkH
' Ecriture des Heures
Pin PenbH mise à l'état bas ' désactivation du DS1302
ENDSUB
SUB READTEMP
' Routine de lecture de la température dans le DS1620.
' Le mode "simple" étant utilisé, il suffit d'envoyer
' l'octet de commande de lecture, puis rentrer sur les
' mêmes lignes série, la valeur de la température
' Ensuite, les variables Signtemp et Température
' sont calculées.
' En Entrée, cette routine à besoin des
' constantes "Hardware" : PEnbT, PDatT et PClkT.
' La variable de travail i est modifiée.
' En sortie, les variables Température et Signtemp
' sont mises à jour.
Pin PenbT mise à l'état haut ' Activation du DS1620
Envoi de $AA en mode série sur les pins PDatT et PClkT
' Commande "lecture de la température"
Lecture de i en mode série sur les pins pDatT et PClkT
' Lecture de température sur 9 bits
Pin PenbT mise à l'état bas ' désactivation du DS620
Signtemp = ENT(i/256)*256 >> 1 ' Extraction du 9ième bit de i
i = i - Signtemp*256 ' Recalcul de i sur 8 bits
IF Signtemp = 0 ' Si température positive
Température = ENT(i/2) ' Calcul de la température
ELSE ' Si température négative
Température = ENT((~i+1)/2) ' Complémentaire à 2
ENDIF
ENDSUB
SUB READHEURE
' Routine de lecture de l'heure dans le DS1302.
' La lecture des valeurs se fait en deux temps.
' Il faut d'abord écrire l'adresse du registre
' puis lire la valeur de ce registre.
' Cette opération est répétée 3 fois, pour lire
' successivement les heures, minutes et secondes.
' Ensuite, les variables Moment, Heures, Minutes
' et secondes sont calculées.
' En Entrée, cette routine à besoin des
' constantes "Hardware" : PEnbH, PDatH et PClkA
' Les variables de travail Precmoment, i, j et k sont modifiées.
' En sortie, les variables Moment, Heures, Minutes , Secondes
' et Tempstot sont mises à jour.
Pin PEnbH mise à l'état haut ' Activation du DS1302
Envoi de $81 en mode série sur les pins PDatH et PClkH
' Commande "Lecture des secondes"
Lecture de i en mode série sur les pins pDatH et PClkH
' Lecture des secondes
Pin PenbH mise à l'état bas ' désactivation du DS1302
Pause de 1 ms ' Pause pour sécuriser la lecture
Pin PEnbH mise à l'état haut ' Activation du DS1302
Envoi de $83 en mode série sur les pins PDatH et PClkH
' Commande "Lecture des Minutes"
Lecture de j en mode série sur les pins pDatH et PClkH
' Lecture des Minutes
Pin PenbH mise à l'état bas ' désactivation du DS1302
Pause de 1 ms ' Pause pour sécuriser la lecture
Pin PEnbH mise à l'état haut ' Activation du DS1302
Envoi de $85 en mode série sur les pins PDatH et PClkH
' Commande "Lecture des heures"
Lecture de k en mode série sur les pins pDatH et PClkH
' Lecture des Heures
Pin PenbH mise à l'état bas ' désactivation du DS1302
Secondes = ENT(i/16)*10 + (i - ENT(i/16)*16)
' Calcul du nombre de secondes
' Conversion BCD -> Décimale
Minutes = ENT(j/16)*10 + (j - ENT(j/16)*16)
' Calcul du nombre de Minutes
' Conversion BCD -> Décimale
Moment = Bit5 de k ' Extraction de AM ou PM
K = K >> 5 ' K = les 5 bits de poids faible de K
Heures = ENT(k/16)*10 + (k - ENT(k/16)*16)
' Calcul du nombre d'Heures
' Conversion BCD -> Décimale
Tempstot = heures*3600 + Minutes*60 + Secondes
ENDSUB
SUB LECTURE
' Routine de lecture des touches et du Pot
' Cette routine effectue les lectures sur les entrées touches et pot
' et calcule l'état des variables Touche et TempoM
' En Entrée, cette routine à besoin des
' constantes "hardware" : BoutonUP, BoutonDN et Pot
' Les variable de travail i, j et k sont modifiées
' En sortie, les variables TempoM et Touche
' sont modifiées.
LET i = 0
LET j = 0
LET k = 0
LET Touche = 0
Lecture de la valeur du Pot dans i ' Lecture de l'entrée "Pot"
Lecture de l'entrée BoutonUP dans j ' Lecture de l'entrée (0 ou 1)
Lecture de l'entrée BoutonDN dans k ' Lecture de l'entrée (0 ou 1)
LET TempoM = ENT(i/"N") + "M" ' Le facteur N devra être définit par
' le "hardware" associé. C'est ce facteur
' qui définira le temps maximal de
' l'alternance de l'affichage, le
' facteur M définira la valeur minimale
' Exemple: nous souhaitons une temporistion allant de 5 à 10 secondes, donc M = 5
' et que i Max ( lecture du Pot ) = 530, dans ce cas, N = 530/5 = 106
IF j = 1 THEN ' Test si appuis sur la touche "UP"
Touche = 1 ' Mise à jour de la variable Touche
ELSE ' (Donc, Touche UP Prioritaire)
IF k = 1 THEN ' Test si appuis sur la touche "DOWN"
Touche = 2 ' Mise à jour de la variable Touche
ENDIF
ENDIF
ENDSUB
SUB AFFIHEURE
' Routine d'affichage des heures.
' En entrée, cette routine à besoin des variables
' Heures et Minutes.
' Les variables Comser et Digit(4) sont modifiées.
' Cette routine utilise la routine WRITEAFFI
LET Comser = 201 ' Commande pour affichage de l'heure
LET Digit(0) = ENT(Heures/10) ' Màj du Digit(0) (Dizaine d'heures)
LET Digit(1) = Heures - Digit(0) ' Màj du Digit(1) (Unités d'heures)
LET Digit(2) = $E ' Màj du Digit(2) (Signe "=")
LET Digit(3) = ENT(Minutes/10) ' Màj du Digit(3) (Dizaines de minutes)
LET Digit(4) = Minutes - Digit(3) ' Màj du Digit(4) (Unités de minutes)
GOSUB WRITEAFFI ' Rafraîchissement de l'afficheur
ENDSUB
SUB AFFITEMP
' Routine d'affichage de la température
' En entrée cette routine à besoin des variables
' Température et Signtemp
' Les variables Comser et Digit(4) sont modifiées.
' Cette routine utilise la routine WRITEAFFI
IF Signtemp = 0 THEN ' Si Température positive
LET Comser = 227 ' Commande d'Affi pour T° Positives
LET Digit(0) = $0 ' Màj du Digit(0) (Digit éteint)
LET Digit(1) = ENT(Température/100) ' Màj du Digit(1) (Centaine de degré)
LET Digit(2) = ENT((Température-Digit(1)*100)/10)
' Màj du Digit(2) (Dizaine de degré)
LET Digit(3) = Température-Digit(1)*100-Digit(2)*10
' Màj du Digit(3) (Unité de degré)
LET Digit(4) = $F ' Màj du Digit(4) (Signe "°")
GOSUB WRITEAFFI ' Rafraîchissement de l'afficheur
ELSE ' Si Température négative
LET Comser = 243 ' Commande d'Affi pour T° Négatives
LET Digit(0) = $0 ' Màj du Digit(0) (Digit éteint)
LET Digit(1) = $D ' Màj du Digit(1) (Signe -)
LET Digit(2) = ENT((Température/10)
' Màj du Digit(2) (Dizaine de degré)
LET Digit(3) = Température-Digit(2)*10
' Màj du Digit(3) (Unité de degré)
LET Digit(4) = $F ' Màj du Digit(4) (Signe "°")
GOSUB WRITEAFFI ' Rafraîchissement de l'afficheur
ENDIF
ENDSUB
SUB CHANGEHEURE
' Routine qui effectue le changement d'heure, et qui met à jour le circuit DS1302
' Cette routine Incrémente ou Décrémente les minutes en fonction des touches
' appuyées. Ensuite, les secondes sont remises à zéro, le circuit DS1302 est
' mis à jour et la nouvelle heure est affichée. Cette routine effectue
' l'accélération de la mise à l'heure (si une touche est appuyée longtemps)
' et applique un timeout pour sortir de la routine.
' En entrée, la routine à besoin de la variable touche et de la constante Timemax
' Les variables Timeout, Compteur, Moment, Heures, Minutes, Secondes et Anttouche
' sont modifiées. Il n'y a pas de variables de sortie.
' Cette routine utilise les routines WRITEHEURE, AFFIHEURE et LECTURE.
LET Timeout = 0 ' Remise à zéro des variables
LET Compteur = 0 ' Timeout et compteur
DO ' Début de la boucle de mise à l'heure
IF Touche = 1 THEN ' Si touche "UP" appuyée
LET Timeout = 0 ' Remise à zéro du timeout
LET Minutes = Minutes + 1 ' Incrémentation des minutes
IF Anttouche = 1 THEN ' Si la touche précédente était "UP"
LET Compteur = Compteur + 1 ' Incrémentation du compteur d'appuis
ELSE ' Si la touche préc. n'était PAS "UP"
LET Compteur = 0 ' Remise à zéro du compteur d'appuis
ENDIF
IF Compteur > 14 ' Lorsque le compteur arrive à 15
LET Compteur = 15 ' remise à 15 du compteur d'appuis
' pour éviter un dépassement de valeur
' lorsque compteur arrive à 255.
LET Minutes = Minutes + 9 ' Incrémentation des minutes par (9+1)
' 10 minutes
ENDIF '
IF Minutes > 59 THEN ' Si les minutes dépassent 59
LET Minutes = Minutes - 60 ' Remise à jour des minutes et
LET Heures = Heures + 1 ' incrémentation des heures
IF Heures = 13 ' Si les heures dépassent 12
LET Heures = 0 ' Remise à zéro des heures et
LET Moment = ~ Moment ' Inversion du moment (AM - PM)
ENDIF '
ENDIF '
LET Anttouche = 1 ' Ajustement de la valeur de
' la touche précédente
ELSEIF Touche = 2 THEN ' Si touche "DOWN" appuyée
LET Timeout = 0 ' Remise à zéro du timeout
LET Minutes = Minutes - 1 ' Décrémentation des minutes
IF Anttouche = 2 THEN ' Si la touche précédente était "DOWN"
LET Compteur = Compteur + 1 ' Incrémentation du compteur d'appuis
ELSE ' Si la touche préc. n'était PAS "DOWN"
LET Compteur = 0 ' Remise à zéro du compteur d'appuis
ENDIF '
IF Compteur > 14 ' Lorsque le compteur arrive à 15
LET Compteur = 15 ' remise à 15 du compteur d'appuis
' pour éviter un dépassement de valeur
' lorsque compteur arrive à 255.
LET Minutes = Minutes - 9 ' Décrémentation des minutes par
' (-9-1) 10 minutes
ENDIF '
IF Minutes > 59 THEN ' Si les minutes dépassent 59
LET Minutes = Minutes + 60 ' Remise à jour des minutes et
LET Heures = Heures - 1 ' décrémentation des heures
IF Heures = 255 ' Si les heures passent
' en dessous de zéro
LET Heures = 0 ' Remise à zéro des heures et
LET Moment = ~ Moment ' Inversion du moment (AM - PM)
ENDIF '
ENDIF '
LET Anttouche = 2 ' Ajustement de la valeur de
' la touche précédente
ELSE ' Si aucune touche n'est appuyée
LET Anttouche = 0 ' Ajustement de la valeur de
' la touche précédente
LET Timeout = Timeout +1 ' Incrémentation du Timeout
ENDIF '
LET Secondes = 0 ' Remise à zéro des secondes
GOSUB WRITEHEURE ' Ecriture de l'heure dans le DS1302
GOSUB AFFIHEURE ' Affichage de l'heure
GOSUB LECTURE ' Lecture des touches et du POT
UNTIL Timeout > Timemax ' Bouclage tant que le Timeout
' n'est pas dépassé.
ENDSUB