/*****************************************************************************/
/*                                                                           */
/*                    Endtest für die ISAC-Cubes                             */
/*                    ==========================                             */
/*                                                                           */
/*    Name:	       End-Test.c                                                */
/*    Funktion:    Routinen zum End-Test der ISAC-Cubes                      */
/*    Autor:       B.v.B. / P.G.                                             */
/*    Stand:       19.09.01                                                  */
/*                                                                           */
/*                                                                           */
/*****************************************************************************/


 /*** Allgemeine Festlegungen für den Compiler ***/
#pragma DEBUG OBJECTEXTEND CODE

/*** Einbinden von Include-Dateien ***/
#include <ADuC812.h>                   // Register-Definitionen für ADuC812
#include <stdio.h>                     // Standard I/O Funktionen

// Port-Festlegungen für den Drehgeber-Betrieb
sbit KA = P2^0;							// Kanal A = P2.0
sbit KB = P2^1;							// Kanal B = P2.1
sbit S = P2^2;							// Schalter S = P2.2

/*** Globale Variablen ***/
signed int i0,i1;



/*****************************************************************************/
/*** Selbstgeschriebene Funktionen *******************************************/
/*****************************************************************************/

/*** Initialisierung der ser. Schnittstelle auf:   ***************************/
/**   9600 Bd, 8 Datenbits, keine Parität          ***************************/

void ser_init(void)
{
	SCON=0x52;
	TMOD |=0x20;
	TH1=0xfd;
	TR1=1;
	TI=1;
}

/*****************************************************************************/

/*** Wartezeit: Vielfaches von 10ms ******************************************/

void wait_10ms(unsigned char Multiplikator) 
  {
  unsigned char a;
  unsigned int	i;
  for(a=0;a<Multiplikator;a++)
   {	 
    for(i=0;i<20000;i++);
   }
  }

/*****************************************************************************/

/*** Bildschirm löschen ***/

void clear_screen(void)
{
   printf("\x1b\x48\x1b\x4a");         // Bildschirm löschen
}

/********************************************************************************/

/*** Bildschirm-Cursor positionieren ***/

void set_cursor(unsigned char z, unsigned char s)
{

    printf("\x1b\x59%c%c",(32+z),(32+s));
}

/*********************************************************************************/

/*** Haupt-Menü-Bild  ********************************************************/

void haupt_menue_bild(void)

{
    clear_screen();
	printf("Routinen zum Endtest des ISAC-Cubes\n");
	printf("===================================\n\n");
	printf("  Bitte waehlen Sie:\n\n");
	printf("    1) Test des D/A-Wandlers\n");
	printf("    2) Test des A/D-Wandlers\n");
	printf("    3) Test der Tastatur am Analogeingang AIN-7\n");
	printf("    4) Test des digitalen Drehimpulsgebers MRTC25\n");
	printf("    5) Messung der Chip-Umgebungstemperatur\n");

}

/****************************************************************************/

/*** Ausgabe eines Wertes an einen der DAC´s   *******************************/

void dac_set(unsigned char kanal, unsigned int wert, unsigned char aufl)

{
   unsigned int low, high;

   // Auflösung auswerten
   if (aufl==0)                // 8 Bit Auflösung
       {
           // Kanal-Auswahl
           if (kanal==0)
               {
                   DAC0L=wert;
               }
             else
               {
                   DAC1L=wert;
               }  
       }
     else                      // 12 Bit Auflösung
       {
           // Übergebenen Wert aufbereiten in High- und Low-Anteil
          high=wert/256;
          low=wert-(high*256);
              
          // Kanal-Auswahl
          if (kanal==0)
               {
                   DAC0H=high;
                   DAC0L=low;
               }
             else
               {
                   DAC1H=high;
                   DAC1L=low;
               } 
       }
}
   
/*****************************************************************************/

/*** Ausgabe eines Sägezahn-Signales an DAC0 mit 12 Bit Auflösung   **********/

void sz_out_12 (void)
{

   printf("\n   Saegezahn (12 Bit) laeuft, Stop mit Reset !");

   i0=0;

   while (1)
       {
          // DAC0 setzen
          dac_set(0,i0,1);
   
          i0++;
          
          if (i0==4096) i0=0;
       }
}

/*****************************************************************************/

/*** Ausgabe eines Sägezahn-Signales an DAC0 mit 8 Bit Auflösung   ***********/

void sz_out_8 (void)
{

   printf("\n   Saegezahn (8 Bit) laeuft, Stop mit Reset !");

   // DAC´s auf 8 Bit Auflösung umstellen
   DACCON=0xff;

   i0=0;

   while (1)
       {
          // DAC0 setzen
          dac_set(0,i0,0);
   
          i0++;
          
          if (i0==256) i0=0;
       }
}

/*****************************************************************************/

/*** Ausgabe eines Dreieck-Signales an DAC1 mit 12 Bit Auflsöung   **********/

void dr_out_12(void)
{

   signed char k;
   
   printf("\n   Dreieck (12 Bit) laeuft, Stop mit Reset !");

   i1=0;
   k=1;

   while (1)
       {
           // DAC1 setzen
           dac_set(1,i1,1);
   
           i1=i1+k;
          
           if (i1==4096)
               {
                   i1=4094;
                   k=-1;
               }
           if (i1==-1)
               {
                   i1=1;
                   k=1;
               }
           
       }
}

/*****************************************************************************/

/*** Ausgabe eines Dreieck-Signales an DAC1 mit 8 Bit Auflsöung   **********/

void dr_out_8(void)
{

   signed char k;
   
   printf("\n   Dreieck (8 Bit) laeuft, Stop mit Reset !");

   // DAC´s auf 8 Bit Auflösung umstellen
   DACCON=0xff;

   i1=0;
   k=1;

   while (1)
       {
           // DAC1 setzen
           dac_set(1,i1,0);
   
           i1=i1+k;
          
           if (i1==256)
               {
                   i1=254;
                   k=-1;
               }
           if (i1==-1)
               {
                   i1=1;
                   k=1;
               }
           
       }
}

/*****************************************************************************/

/*** Test des D/A-Wandlers  **************************************************/

void da_w_test(void)

{
   unsigned char c;
   
   // Titel-Meldung
   clear_screen();
   printf("Test des D/A-Wandlers:\n");
   printf("======================\n\n");
	
   // Grundinitialisierung für die DAC-Funktionsbaugruppe:
       /*  - 12 Bit Mode für beide DAC´s
           - DAC1-Ausgang: 0 ... VDD (+5V)
           - DAC0-Ausgang: 0 ... VDD (+5V)
           - DAC1-Ausgang normal
           - DAC0-Ausgang normal
           - Beide DAC´s nicht synchronisiert
           - DAC1 eingeschaltet
           - DAC0 eingeschaltet  ====>
       */
   DACCON=0x7f;                        // Für 8 Bit Auflösung: 0xff

	// Endlos-Schleife
	while(1)
	    {
           printf("   1) Saegezahn an DAC0 (12 Bit)\n");
           printf("   2) Dreieck an DAC1 (12 Bit)\n\n");
           printf("   3) Saegezahn an DAC0 ( 8 Bit)\n");
           printf("   4) Dreieck an DAC1 ( 8 Bit)\n");
           printf("\n Bitte waehlen Sie: ");
  
           // Eingabe
           c=_getkey();
		   printf("\n");
           
           // Auswertung
           switch (c)
               {
                   case '1':   sz_out_12();               // Sägezahn an DAC0 (12 Bit) ausgeben
                               break;
                   case '2':   dr_out_12();               // Dreieck an DAC1 (12 Bit) ausgeben    
                               break;
                   case '3':   sz_out_8();                // Sägezahn an DAC0 (8 Bit) ausgeben
                               break;
                   case '4':   dr_out_8();                // Dreieck an DAC1 (8 Bit) ausgeben
                               break; 
               }
       }
}

/*****************************************************************************/

/*** Einlesen eines A/D-Wandler-Kanals ***************************************/

unsigned int adc_in (unsigned int knr)
{

   unsigned int mw;
   
   // Kanal einstellen
   	switch (knr)
	    	{
               case '0':   CS3=0; CS2=0; CS1=0; CS0=0;
                           break;
               case '1':   CS3=0; CS2=0; CS1=0; CS0=1;
                           break;
               case '2':   CS3=0; CS2=0; CS1=1; CS0=0;
                           break;
               case '3':   CS3=0; CS2=0; CS1=1; CS0=1;
                           break;  	
               case '4':   CS3=0; CS2=1; CS1=0; CS0=0;
                           break;
               case '5':   CS3=0; CS2=1; CS1=0; CS0=1;
                           break;  
               case '6':   CS3=0; CS2=1; CS1=1; CS0=0;
                           break;
               case '7':   CS3=0; CS2=1; CS1=1; CS0=1;
                           break;
               case '8':   CS3=1; CS2=0; CS1=0; CS0=0;
                           break;
           }

           // Start der Wandlung: Single Conversion
           SCONV=1;
           
           // Warten auf ´NOT Busy´ ==> BUSY-Bit = 0, dann fertig
           while (ADCCON3!=0);

           // Ergebnis einlesen und auswerten
           mw=(ADCDATAH & 0x0f)*256+ADCDATAL;     // Meßwert bestimmen
           
           // Rückgabewert
           return(mw);

}

/*****************************************************************************/

/*** Test des A/D-Wandlers  **************************************************/

void ad_w_test(void)

{
   unsigned int c,mw;

   // Titel-Meldung
   clear_screen();
   printf("Test des A/D-Wandlers:\n");
   printf("======================\n\n");

   // Einstellung des ADC´s:
   /*  ADCCON1:    - ADC - Normal Mode
                   - ADC-Clock-Divider: 2
                   - ADC-Track-and-Hold-Time: 2
                   - T2-Conversion-Bit: disable
                   - External Trigger: disable
                   ===>                            */
   ADCCON1=0x54;
   
   // Kanal-Auswahl
	printf("  Bitte Kanal angeben (0 ... 8): ");
	c=_getkey();            // Kanal-Nr. im ASCII-Code einlesen !
	printf("\n\n");

	// Endlos-Schleife
	while(1)
	    {

           // Erst eine 'Blind-Wandlung': Single Conversion
           mw=adc_in(c);
                      
           // Start der Haupt-Wandlung: Single Conversion
           mw=adc_in(c);
           
           // Ergebnis ausgeben
           printf("  Kanal-Nr.: %i  Messwert (dez):  %i    Messwert (hex):  %x\n\n",c-48,mw,mw);

           // Warten: ca. 1 sec.
           wait_10ms(10);

       }

}

/*****************************************************************************/

/*** Test der Tastatur am Analog-Eingang  ************************************/

void ana_tast_test(void)

{
   unsigned int wert;

   // Bildschirm löschen
   clear_screen();

   // Titel-Meldung
   printf("Test der Tastatur am Analog-Eingang AIN-7:\n");
   printf("==========================================\n\n\n");

   // Einstellung des ADC´s:
   /*  ADCCON1:    - ADC - Normal Mode
                   - ADC-Clock-Divider: 2
                   - ADC-Track-and-Hold-Time: 2
                   - T2-Conversion-Bit: disable
                   - External Trigger: disable
                   ===>                            */
   ADCCON1=0x54;
   
	// Endlos-Schleife
	while(1)
	    {

           // Erst eine 'Blind-Wandlung': Single Conversion
           wert=adc_in('7');
                      
           // Start der Haupt-Wandlung: Single Conversion
           wert=adc_in('7');

           // Vergleich: Meßwert <---> gedrückte Taste                       
           if (wert >= 3937 ) printf("-");	// Wurde Taste betätigt? Nein, dann "-" ausgeben!
	          else 							// Wenn ja, Textausgabe Taste x!
   		    {
	    	      if (wert < 185 ) printf("\n   Taste 0! ");
		          else if (wert < 605 ) printf("\n   Taste 1! ");
		          else if (wert < 1000) printf("\n   Taste 2! ");
   		      	  else if (wert < 1427) printf("\n   Taste 3! ");
                  else if (wert < 1847) printf("\n   Taste 4! ");
		          else if (wert < 2263) printf("\n   Taste 5! ");
		          else if (wert < 2692) printf("\n   Taste 6! ");
   		          else if (wert < 3103) printf("\n   Taste 7! ");
	    	      else if (wert < 3511) printf("\n   Taste 8! ");
		          else if (wert < 3937) printf("\n   Taste 9! ");
                 printf("  # %i #\n",wert);
			 }
	        wait_10ms(3);
        }
}

/*****************************************************************************/

/*** Aufbau der Bildschirmmaske ***/

void bs_mask(void)
{
    unsigned int zw;
    zw=0;

    clear_screen();
    printf("Test des digitalen Drehimpulsgebers MRTC25\n");
    printf("==========================================\n");
    printf("  (Zaehlbereich:  -128 ..... +127)");
    set_cursor(10,2);
    printf("Bisher richtungsabhaengig gezaehlte Impulse:");
    set_cursor(13,2);
    printf("Betaetigung des Tasters:");
    set_cursor(13,28); printf("O");
    set_cursor(10,49);
    printf("%4d",zw);
}

/********************************************************************************/

/*** Test des digitalen Drehimpulsgebers *************************************/

void dreh_imp_test(void)

{

    // Definition der verwendeten Variablen 
    signed int z,z_alt,t;

	// I/O-Ports parametrieren 
    // Beachten: nach einem Reset sind die I/O-Ports immer auf Eingang geschaltet !
    
    // Parameter-Werte 
    z=0;
    z_alt=-100;
    t=0;

    // Bildschirmmaske aufrufen
    bs_mask();

    // Endloschleife zur Erfassung der Impulse
    while (1)
	  {
        while(KA==0)				// Warten auf Kanal A = 1
		  {
		    if (S==0)				// Abfrage des Tasters
			  {	
			    set_cursor(13,28);
				if (t==0)
				  {
					printf("X");
					t=1;
			      }
				  else
					{
					  printf("O");
					  t=0;
				    }
	 	          wait_10ms(5);	    // 500 Millisekunden Wartezeit
			  }
		  }
	
		
		if (KB==1)					// Untersuchung von Kanal B
		  {
			z=z-1;					// links rum
  			if (z==-129) z=127;
		  }
		  else
		 	{
			  z=z+1;				// rechts rum
  			  if (z==128) z=-128;
  	 		}
	
		if (z!=z_alt)				// Neuen Zählwert ausgeben 
		  {
		    set_cursor(10,49);
           printf("%4d",z);         
			z_alt=z;
		  }
		
		while((KA!=0) || (KB!=0));	// Warten, bis beide Kanäle wieder = 0
		
 	  }
    
}

/*****************************************************************************/

/*** Test des ON-Chip-Temperatur-Sensors *************************************/

void temp_sens_test(void)

{
   unsigned int temp;
   unsigned int kanal;
   float t,m,b;							// Parameter für die Geradengleichung

   // Eingabe der Geraden-Parameter m und b
   clear_screen();
   printf("Eingabe der Parameterwerte fuer die Temperatur-Geradengleichung\n");
   printf("===============================================================\n\n");
   printf("  Bitte die Werte fuer m und b eingeben:\n\n");
   printf("  Standardwerte gem. Datenblatt fuer 5V-Ref.spg. eingetragen:\n\n");
   printf("       m= -0.4000     b= 221.8\n\n\n"); 
   m=-0.4;	b=221.8;   

   // Titel-Meldung
   clear_screen();
   printf("ADuC812-Umgebungstemperatur:\n");
   printf("============================\n\n");

   // Einstellung des ADC´s:
   /*  ADCCON1:    - ADC - Normal Mode
                   - ADC-Clock-Divider: 2
                   - ADC-Track-and-Hold-Time: 2
                   - T2-Conversion-Bit: disable
                   - External Trigger: disable
                   ===>                            */
   ADCCON1=0x54;
   
   /*  ADCCON1:    - Kanal-Nr:  8 !! */
   CS3=1;  CS2=0;  CS1=0;  CS0=0;

   // Endlos-Schleife
   while(1)
	    {

           // Erst eine 'Blind-Wandlung': Single Conversion
           SCONV=1;
           
           // Warten auf ´NOT Busy´ ==> BUSY-Bit = 0, dann fertig
           while (ADCCON3!=0);

           // Start der Haupt-Wandlung: Single Conversion
           SCONV=1;
           
           // Warten auf ´NOT Busy´ ==> BUSY-Bit = 0, dann fertig
           while (ADCCON3!=0);

           // Ergebnis einlesen und auswerten
           kanal=ADCDATAH & 0xf0;      // Kanal-Nr. bestimmen
           kanal=kanal >> 4;

           temp=(ADCDATAH & 0x0f)*256+ADCDATAL;     // Temperaturwert bestimmen
           
           // Digitales Ergebnis ausgeben
           printf("  Kanal-Nr.: %u  Temp.-Wert (dez):  %u    Temp.-Wert (hex):  %x\n",kanal,temp,temp);

		   // Berechnung der Geradengleichung
		   t=m*temp + b;
		   printf("  Temperatur: %4.1f  Grad Celsius\n\n",t);

           // Warten: ca. 1 sec.
          wait_10ms(10);

       }

}

/*****************************************************************************/

/*****************************************************************************/
/*****************************************************************************/


/*****************************************************************************/
/* Start des Hauptprogramms                                                  */
/*****************************************************************************/


void main(void)
{

	// Variablen für main
	unsigned char c;

	// Initialisierung der ser. Schnittstelle 
	ser_init();

	// Endlosschleife
	while(1)
		{
			// Hauptmenü
			haupt_menue_bild();
			printf("\n\n  Ihre Auswahl:  ");
		
			// Eingabe abfragen
		    c=_getkey();
		           
		    // Auswertung der Eingabe
		    switch (c)
				{
					case '1':   da_w_test();                // Test des D/A-Wandlers
		                        break;
					case '2':	ad_w_test();				// Test des A/D-Wandlers
								break;
					case '3':	ana_tast_test();			// Test der Tastatur am Analogeingang
								break;
					case '4':	dreh_imp_test();			// Test des digitalen Drehimpulsgebers
								break;
					case '5':	temp_sens_test();			// Test des ON-Chip-Temperartursensors
								break;
		        }	
		
		}
	
// Ende des Hauptprogramms
}