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