Tiny File Manager

Back Back Up Advanced Editor

/****************************************************************/
/*                                                              */
/* TITRE : Dialogue avec un DS1302 de DALLAS par le PORTD       */
/*                                                              */
/* AUTEUR : Y.BOURNE                                            */
/*                                                              */
/* DATE : 24/11/1998 / V1.0                                     */
/*                                                              */
/* Remarques : PORTD2 = IO                                      */
/*             PORTD4 = CLK                                     */
/*             PORTD5 = CS                                      */
/*                                                              */
/****************************************************************/

/****************************************************************/
/* D�claration des variables globales 							*/
/****************************************************************/
unsigned char ANNEE, JOUR, MOIS, DATE, HEURES, MINUTES, SECONDES ;
unsigned char FlagIT ;

/****************************************************************/
/* R�cup�ration de la date                                      */
/****************************************************************/
void RECUPERATION_DATE_RTI(void)
{
    CS_RTI(1) ;

/* Lecture en "BURST" */
    ECRITURE_RTI(BURST) ;

SECONDES = LECTURE_RTI() ;
    MINUTES = LECTURE_RTI() ;
    HEURES = LECTURE_RTI() ;
    DATE = LECTURE_RTI() ;
    MOIS = LECTURE_RTI() ;
    JOUR = LECTURE_RTI() ;
    ANNEE = LECTURE_RTI() ;
    CS_RTI(0) ;
}

/****************************************************************/
/* Ecriture d'une valeur sur le DS1302                          */
/****************************************************************/
void ECRITURE_RTI(unsigned char valeur_a_ecrire)
{
unsigned char x, variable ;

DDRD = 0x34 ;
    for (x = 0 ; x < 8 ; x ++)
    {
        variable = (valeur_a_ecrire >> x) & 0x01 ;

if (variable == 0x00) PORTD &= 0xfb ;
        if (variable == 0x01) PORTD |= 0x04 ;

/* Front montant */
        PORTD |= 0x10 ;

/* Front descendant */
        PORTD &= 0xef ;
    }
    return ;
}

/****************************************************************/
/* Lecture d'une valeur sur le DS1302                           */
/****************************************************************/
unsigned char LECTURE_RTI(void)
{
unsigned char x, valeur_lue = 0 ;

DDRD = 0x30 ;
    for (x = 0 ; x < 8 ; x ++)
    {
        if ((PORTD & 0x04) == 0x04)
        {
            valeur_lue |= 1 << x ;
        }

/* Front montant */
        PORTD |= 0x10 ;
/* Front descendant */
        PORTD &= 0xef ;
    }
    return valeur_lue ;
}

/****************************************************************/
/* Autorisation d'�criture dans les registres                   */
/****************************************************************/
void WEN_RTI(void)
{
    DDRD = 0x34 ;
    CS_RTI(1) ;
    ECRITURE_RTI(0x8e) ;
    ECRITURE_RTI(0x00) ;
    CS_RTI(0) ;
}

/****************************************************************/
/* Inhibition d'�criture dans les registres                     */
/****************************************************************/
void WDIS_RTI(void)
{
    DDRD = 0x34 ;
    CS_RTI(1) ;
    ECRITURE_RTI(0x8e) ;
    ECRITURE_RTI(0x80) ;
    CS_RTI(0) ;
}

/****************************************************************/
/* Lancement de la CLK                                          */
/****************************************************************/
void LANCEMENT_CLK_RTI(void)
{
    CS_RTI(1) ;
    ECRITURE_RTI(0x80) ;
    ECRITURE_RTI(0x00) ;
    CS_RTI(0) ;

CS_RTI(1) ;
    ECRITURE_RTI(0x82) ;
    ECRITURE_RTI(0x00) ;
    CS_RTI(0) ;
}

/****************************************************************/
/* Positionnement du CS                                         */
/****************************************************************/
void CS_RTI(unsigned char valeur)
{
unsigned char attente ;

if (valeur == 0x00)
    {
        for (attente = 0 ; attente < 10 ; attente ++) ;
        PORTD &= 0xdf ;
    }
    else
    {
        PORTD |= 0x20 ;
        for (attente = 0 ; attente < 10 ; attente ++) ;
    }
}

/****************************************************************/
/* Ecriture dans une cellule RAM                                */
/****************************************************************/
void ECRITURE_RAM_RTI(unsigned numero, unsigned char valeur)
{
    CS_RTI(1) ;

ECRITURE_RTI(0xc0 + (numero * 2)) ;
    ECRITURE_RTI(valeur) ;

CS_RTI(0) ;
}

/****************************************************************/
/* Lecture d'une cellule RAM                                    */
/****************************************************************/
unsigned char LECTURE_RAM_RTI(unsigned numero)
{
    CS_RTI(1) ;
    ECRITURE_RTI(0xc1 + (numero * 2)) ;
    numero = LECTURE_RTI() ;
    CS_RTI(0) ;

return numero ;
}

/****************************************************************/
/* Configuration du circuit de charge de l'accu                 */
/*                                                              */
/* on_off = 1 : charge autoris�e                                */
/* on_off = 0 : charge inhib�e                                  */
/*                                                              */
/* valeur_de_charge = 1 : 2Kohm                                 */
/* valeur_de_charge = 2 : 4Kohm                                 */
/* valeur_de_charge = 3 : 8Kohm                                 */
/*                                                              */
/****************************************************************/
void CONFIGURATION_CHARGE(unsigned char on_off, unsigned char valeur_de_charge)
{
    if (on_off == 1)
    {
        ECRITURE_RTI(0x90) ;
        ECRITURE_RTI(0xa4 + valeur_de_charge) ;
    }
    else
    {
        ECRITURE_RTI(0x90) ;
        ECRITURE_RTI(0x00) ;
    }
}

/********************************************************************************/
/* AFFICHE l'heure sur l'afficheur                                              */
/********************************************************************************/
void AFFICHE_HEURE(void)
{
    RECUPERATION_DATE_RTI() ;

AFFICHE(HEURES) ;
    AFFICHED(':') ;
    AFFICHE(MINUTES) ;
    AFFICHED(':') ;
    AFFICHE(SECONDES) ;
    gotoxy(22, 1) ;
}

/********************************************************************************/
/* AFFICHE la date sur l'afficheur                                              */
/********************************************************************************/
void AFFICHE_DATE(void)
{
    RECUPERATION_DATE_RTI() ;

switch(JOUR)
    {
        case 1 :
        {
            CHAINE("Lun ") ;
            break ;
        }
        case 2 :
        {
            CHAINE("Mar ") ;
            break ;
        }
        case 3 :
        {
            CHAINE("Mer ") ;
            break ;
        }
        case 4 :
        {
            CHAINE("Jeu ") ;
            break ;
        }
        case 5 :
        {
            CHAINE("Ven ") ;
            break ;
        }
        case 6 :
        {
            CHAINE("Sam ") ;
            break ;
        }
        case 7 :
        {
            CHAINE("Dim ") ;
            break ;
        }
    }

AFFICHE(DATE) ;
    AFFICHED('/') ;
    AFFICHE(MOIS) ;
    if (ANNEE < 0x99)
    {
        CHAINE("/20") ;
    }
    else
    {
        CHAINE("/19") ;
    }
    AFFICHE(ANNEE) ;
    gotoxy(22, 1) ;
}

/********************************************************************************/
/* AFFICHE une valeur d�cimale (0-99) sur l'afficheur                           */
/********************************************************************************/
void AFFICHE(unsigned char valeur_a_afficher)
{
unsigned char calcul ;

calcul = (valeur_a_afficher & 0xf0) >> 4 ;
    AFFICHED(calcul + 0x30) ;

calcul = valeur_a_afficher & 0x0f ;
    AFFICHED(calcul + 0x30) ;
}

/********************************************************************************/
/* Reglage de la date et de l'heure                                             */
/********************************************************************************/
void REGLAGE_TIME(void)
{
unsigned char position, tampon, exit,MIN, MAX, ValeurAModifier ;

/* Modification de la date */
	position = 1 ;
	exit = 0 ;

while (exit == 0)
	{
		clrscr() ;
		CHAINE("Modif. date :") ;
		gotoxy(1, 2) ;
		AFFICHE_DATE() ;

gotoxy((position * 3) - 1, 2) ;
		switch (position)
		{
      	case 1 :
         {
         	ValeurAModifier = JOUR ;
            MIN = 1 ;
            MAX = 7 ;
            break ;
			}
         case 2 :
         {
         	ValeurAModifier = DATE ;
            MIN = 1 ;
            MAX = 0x31 ;
            break ;
			}
         case 3 :
         {
         	ValeurAModifier = MOIS ;
            MIN = 1 ;
            MAX = 0x12 ;
            break ;
         }
         case 4 :
         {
         	ValeurAModifier = ANNEE ;
            MIN = 0 ;
            MAX = 0x99 ;
            break ;
         }
      }

tampon = getch() ;
      switch (tampon)
      {
      	case BAS :
         {
         	if (ValeurAModifier > MIN)
            {
            	if ((ValeurAModifier & 0x0f) == 0x00)
               {
               	ValeurAModifier -= 7 ;
               }
               else
               {
               	ValeurAModifier -- ;
               }
            }
            else
            {
            	ValeurAModifier = MAX ;
         	}
            break ;
         }
         case HAUT :
         {
         	if (ValeurAModifier < MAX)
            {
            	if ((ValeurAModifier & 0x0f) == 0x09)
               {
               	ValeurAModifier += 7 ;
               }
               else
               {
               	ValeurAModifier ++ ;
               }
            }
            else
            {
            	ValeurAModifier = MIN ;
            }
            break ;
         }
         case GAUCHE :
         {
         	if (position > 1)
            {
            	position -- ;
            }
            else
            {
            	position = 4 ;
            }
            break ;
         }
         case DROITE :
         {
         	if (position < 4)
            {
            	position ++ ;
            }
            else
            {
            	position = 1 ;
            }
            break ;
         }
         case ENTREE :
         {
         	exit = 1 ;
            break ;
         }
      }

if ((tampon != GAUCHE) && (tampon != DROITE))
      {
      	switch (position)
         {
         	case 1 :
            {
            	JOUR = ValeurAModifier ;
               break ;
            }
            case 2 :
            {
            	DATE = ValeurAModifier ;
            	break ;
            }
            case 3 :
            {
            	MOIS = ValeurAModifier ;
               break ;
            }
            case 4 :
            {
            	ANNEE = ValeurAModifier ;
               break ;
            }
         }
      }

/* Sauvegarde de la date dans le DS1302 */
      CS_RTI(1) ;
      ECRITURE_RTI(0x86) ;
      ECRITURE_RTI(DATE) ;
      CS_RTI(0) ;
      CS_RTI(1) ;
      ECRITURE_RTI(0x88) ;
      ECRITURE_RTI(MOIS) ;
      CS_RTI(0) ;
      CS_RTI(1) ;
      ECRITURE_RTI(0x8a) ;
      ECRITURE_RTI(JOUR) ;
      CS_RTI(0) ;
      CS_RTI(1) ;
      ECRITURE_RTI(0x8c) ;
      ECRITURE_RTI(ANNEE) ;
      CS_RTI(0) ;
	}

/* Modification de l'heure */
   position = 1 ;
   exit = 0 ;
   while (exit == 0)
   {
   	clrscr() ;
      CHAINE("Modif. heure :") ;
      gotoxy(1, 2) ;
      AFFICHE_HEURE() ;

gotoxy((position * 3) - 1, 2) ;
      switch (position)
      {
      	case 1 :
         {
         	ValeurAModifier = HEURES ;
            MIN = 0 ;
            MAX = 0x24 ;
            break ;
         }
         case 2 :
         {
         	ValeurAModifier = MINUTES ;
            MIN = 0 ;
            MAX = 0x59 ;
            break ;
         }
         case 3 :
         {
         	ValeurAModifier = SECONDES ;
            MIN = 0 ;
            MAX = 0x59 ;
            break ;
         }
      }

tampon = getch() ;
      switch (tampon)
      {
      	case BAS :
         {
         	if (ValeurAModifier > MIN)
            {
            	if ((ValeurAModifier & 0x0f) == 0x00)
               {
               	ValeurAModifier -= 7 ;
               }
               else
               {
               	ValeurAModifier -- ;
               }
            }
            else
            {
            	ValeurAModifier = MAX ;
            }
            break ;
         }
         case HAUT :
         {
         	if (ValeurAModifier < MAX)
            {
            	if ((ValeurAModifier & 0x0f) == 0x09)
               {
               	ValeurAModifier += 7 ;
               }
               else
               {
              		ValeurAModifier ++ ;
            	}
            }
            else
            {
            	ValeurAModifier = MIN ;
            }
            break ;
         }
         case GAUCHE :
         {
         	if (position > 1)
            {
            	position -- ;
            }
            else
            {
            	position = 4 ;
            }
            break ;
         }
         case DROITE :
         {
         	if (position < 4)
            {
            	position ++ ;
            }
            else
            {
            	position = 1 ;
            }
            break ;
         }
         case ENTREE :
         {
         	exit = 1 ;
            break ;
         }
      }

if ((tampon != GAUCHE) && (tampon != DROITE))
      {
			switch (position)
         {
         	case 1 :
            {
            	HEURES = ValeurAModifier ;
               break ;
            }
            case 2 :
            {
            	MINUTES = ValeurAModifier ;
               break ;
            }
            case 3 :
            {
            	SECONDES = ValeurAModifier ;
               break ;
	          }
         }
      }

/* Sauvegarde de la date dans le DS1302 */
      CS_RTI(1) ;
      ECRITURE_RTI(0x80) ;
      ECRITURE_RTI(SECONDES) ;
      CS_RTI(0) ;
      CS_RTI(1) ;
      ECRITURE_RTI(0x82) ;
      ECRITURE_RTI(MINUTES) ;
      CS_RTI(0) ;
      CS_RTI(1) ;
      ECRITURE_RTI(0x84) ;
      ECRITURE_RTI(HEURES) ;
      CS_RTI(0) ;
	}
   clrscr() ;
}