/********************************
 *
 * Steuerung Kugeltransport
 *
 ********************************/

#include <stdio.h>
#include <stdlib.h>
#include <stdio.h>
#include <htc.h>
#include <string.h>
#include <ctype.h>

// Allgemeines
#define Aus     0
#define Ein     1

#define TRUE		1
#define FALSE		0

// Hardware
#define SENSOR1				1
#define SENSOR2				2
#define SENSOR3				3
#define SENSOR4				4

#define AKTOR1				1
#define AKTOR2				2
#define AKTOR3				3
#define AKTOR4				4

#define Steht					0
#define Links					1
#define Rechts				2

// Abfragen & HAL
#define Sensor1				RA3
#define Sensor2				RA2
#define Sensor3				RA1
#define Sensor4				RA0

#define	MotorEN				RB0
#define	MotorIn1      RB1
#define	MotorIn2      RB2

#define AktorOut1			RC7
#define AktorOut2			RC6
#define AktorOut3			RC4
#define AktorOut4			RC5

#define TASTE					RB4

#define Signal1				RC3
#define Signal2				RC2
#define Signal3				RC1
#define Signal4				RC0

#define LED						RB5

#define MAGNETSENSOR	SENSOR2
#define SENSOROBEN		SENSOR4
#define SENSORUNTEN		SENSOR3

// Konfiguration: Externer Quarz, Watchdog, Debugger, Brownout 2.7V, PWM2 auf RC1
__CONFIG(FOSC_INTOSCCLK & WDTE_ON & CP_ON & BOREN_ON & BORV_27 & DEBUG_ON & CCP2MX_RC1 & PWRTE_ON);

// Variablen
char Blinktoggle = 0;
int Blinkzaehler = 0;
volatile unsigned long Timerticks = 0;									// Systemticker alle 10ms


/**************************
 *
 * Systemticker erhöhen
 *
 **************************/
void Systemticker (void)
 {
  Timerticks++;
 }

/**************************
 *
 * Systemticker auslesen
 *
 **************************/
long GetTicker (void)
 {
  return (Timerticks);
 }

/*************************************
 *
 * Verzögern im Millisekundenbereich
 *
 *************************************/
void Delayms (int time)
 {
  unsigned long ticker;

  ticker = GetTicker ();

  while ( (ticker + (time / 10)) > GetTicker () )
   {
    CLRWDT ();
   }
 }

/****************
 *
 * Zentrale ISR
 *
 ****************/
interrupt void INT_(void)
 {
   //--------------------
   // Timer 1 Überlauf ?
   //--------------------
   if (TMR1IF)
   	{

      Systemticker ();                                  // Systemticker erhöhen

      TMR1IF=0;                                         // Clear Interrupt-Flag

      // Werte für 10 MHz
      TMR1L=0xCB;                                       // Timer 1 neu vorladen (0xF3CB = 10ms)
      TMR1H=0xF3;                                       // n = 2^16 - t [s] * 625000

      // LED blinken lassen bis der Arzt kommt *Röchel*
      Blinkzaehler++;
      if (Blinkzaehler > 20)
       {
        Blinkzaehler = 0;
        if (Blinktoggle) { (Blinktoggle = FALSE; LED = 0;} else {Blinktoggle = TRUE; LED = 1; }
       }

   	} // From Timer 1 Überlauf

   return;									                            // Zurück zum Hauptprogramm
 }


/**************************
 *
 * Timer 1 als Systemtakt
 *
 **************************/
void TimerInit (void)
{
  TMR1IE=1;					// enable Interrupt of TMR1
  T1CON=49;					// Prescaler=1:8 + Timer on (49)
  PEIE=1;          	// Peripherie Int=on
  GIE=1;						// Define Interupts
}

/**************************************************
 *
 * Liefert TRUE, wenn ein Sensor auf High steht
 * Enthält eine unglaublich beschissen programmierte
 * Entprellung
 *
 **************************************************/
char GetSensor (char SensorNum)
 {
  if ( (SensorNum == SENSOR4) && (Sensor4))
   {
    Delayms (50);
    if (Sensor4) return (TRUE);
   }
  if ( (SensorNum == SENSOR3) && (Sensor3))
   {
    Delayms (50);
    if (Sensor3) return (TRUE);
   }
  if ( (SensorNum == SENSOR2) && (Sensor2))
   {
    Delayms (50);
    if (Sensor2) return (TRUE);
   }
  if ( (SensorNum == SENSOR1) && (Sensor1))
   {
    Delayms (50);
    if (Sensor1) return (TRUE);
   }

  return (FALSE);
 }

/*********************
 *
 * Aktor 1-4 steuern
 *
 *********************/
void Aktor (char AktorNum,  char Art)
 {

  if (AktorNum == AKTOR1)
   {
    if (Art) AktorOut1 = TRUE; else AktorOut1 = FALSE;
   }

  if (AktorNum == AKTOR2)
   {
    if (Art) AktorOut2 = TRUE; else AktorOut2 = FALSE;
   }

  if (AktorNum == AKTOR3)
   {
    if (Art) AktorOut3 = TRUE; else AktorOut3 = FALSE;
   }

  if (AktorNum == AKTOR4)
   {
    if (Art) AktorOut4 = TRUE; else AktorOut4 = FALSE;
   }

 }

/**************************
 *
 * Steuert die Motorbrücke
 *
 **************************/
void Motor (char Richtung)
 {
   switch (Richtung)
    {
     case Steht  : { MotorIn1 = 0; MotorIn2 = 0; MotorEN = 1; } break;
     case Links  : { MotorIn1 = 0; MotorIn2 = 1; MotorEN = 1; } break;
     case Rechts : { MotorIn1 = 1; MotorIn2 = 0; MotorEN = 1; } break;
    }
 }


/*******************************************************************************
 *
 * Hat der schwabbelige Jusa etwa seine unegalen Wichsgriffel auf dem Taster?
 *
 *******************************************************************************/
char GetTaste (void)
 {
  if (!TASTE) return (TRUE); else return (FALSE);
 }


/***********************
 *
 * Reiss an den Eimer!
 *
 ***********************/
void Sysinit (void)
 {
  unsigned int TimeoutTicker = 0;

	TRISA = 0xFF;
	TRISB = 0b00011000;
	TRISC = 0;

  ADCON1 = 0x0F;							// Alles digital, kein ADC

	MotorEN = 1;
	MotorIn1 = 0;
	MotorIn2 = 0;

  OSCCON = 0b01110000;				// Interner Oszilator mit 8MHz

  // Systemtakt starten
  TimerInit ();

  // Alles aus
  Aktor (AKTOR1, Aus);
  Aktor (AKTOR2, Aus);
  Aktor (AKTOR3, Aus);
  Aktor (AKTOR4, Aus);

	// Kleine Show für den Anfang. Mach mal Pffffffiiiiiiihhhhhhhh
	Aktor (AKTOR1, Ein);Delayms (200);Aktor (AKTOR1, Aus);
	Aktor (AKTOR2, Ein);Delayms (200);Aktor (AKTOR2, Aus);
	Aktor (AKTOR3, Ein);Delayms (200);Aktor (AKTOR3, Aus);
	Aktor (AKTOR4, Ein);Delayms (200);Aktor (AKTOR4, Aus);

   //--------------------------------------------------------------
   // Heber wieder einfahren bis unten
   // Natürlich nur, wenn nicht schon unten ist. Failsafe geschaltet!
   //--------------------------------------------------------------
   if (!(GetSensor (SENSORUNTEN)))
    {
   	 Motor (Links); 													 		 // Nach unten
   	 Delayms (200);																 // Pause
   	 TimeoutTicker = 0;                            // Zähler auf Null, 10 Sekunden Timeout
   	 while ((!(GetSensor (SENSORUNTEN))) && (TimeoutTicker < 800))
      {
       CLRWDT ();
       Delayms (10);
       TimeoutTicker++;
      }
   	Motor (Steht);														 		 // Motor aus
	 }

}


/**************************************
 *
 * Na, was soll das hier wohl sein???
 *
 **************************************/
void main (void)
 {
  unsigned int TimeoutTicker = 0;
  Sysinit ();

  while (1)
   {

   	//---------------------------------------
   	// Taste gedrückt? Dann einmal heben...
   	//---------------------------------------
   	if (GetTaste ())
   	 {
         Aktor (AKTOR3, Ein);

   	     //--------------------------------------------------------------
   	     // Heber ausfahren bis oben -> Kugel fällt heraus *Polter*
   	     // Natürlich nur, wenn nicht schon oben. Failsafe geschaltet!
   	     //--------------------------------------------------------------
   	     if  (!(GetSensor (SENSOROBEN)))
   	      {
     	     Motor (Rechts); 													 		// Und aufwärts
     	     Delayms (200);																// Pause
    			 TimeoutTicker = 0;														// Zähler auf Null, 10 Sekunden Timeout
    			 while ((!(GetSensor (SENSOROBEN))) && (TimeoutTicker < 800))
    			  {
    			   CLRWDT ();
    			   Delayms (10);
    			   TimeoutTicker++;
    			  }
    			 Motor (Steht);														 		// Motor aus
    			}

  			 Delayms (400);														 		  // Kurze Pause

   	     //--------------------------------------------------------------
				 // Heber wieder einfahren bis unten
   	     // Natürlich nur, wenn nicht schon unten ist. Failsafe geschaltet!
   	     //--------------------------------------------------------------
         if (!(GetSensor (SENSORUNTEN)))
          {
   				 Motor (Links); 													 		 // Nach unten
   				 Delayms (200);																 // Pause
     			 TimeoutTicker = 0;                            // Zähler auf Null, 10 Sekunden Timeout
     			 while ((!(GetSensor (SENSORUNTEN))) && (TimeoutTicker < 800))
    			  {
    			   CLRWDT ();
    			   Delayms (10);
    			   TimeoutTicker++;
    			  }
     			 Motor (Steht);														 		 // Motor aus
     			}

         Aktor (AKTOR3, Aus);
   	 } // Von if (GetTaste ())

	 CLRWDT ();
	} // Von while (1)

 }