/**************
 *
 * Balltruhe
 *
 *************/
#include	<pic18.h>
#include 	<string.h>
#include	<ctype.h>
#include	<math.h>
#include	<stdlib.h>
#include	<stdio.h>

// Standard-defines
#define ON  							1
#define TRUE 						 ON
#define OFF 							0
#define FALSE 					OFF


//-----
// HAL
//-----
#define DISPLAY		PORTD

#define  MV1			PORTAbits.RA0
#define  MV2			PORTAbits.RA1

#define INDUKT1		PORTCbits.RC2
#define INDUKT2		PORTCbits.RC3
#define S1				PORTCbits.RC4
#define S2				PORTCbits.RC5
#define S3				PORTCbits.RC6
#define S4				PORTCbits.RC7

#define LAUNCH		PORTCbits.RC0
#define START			PORTCbits.RC1

/*********************
 *
 * Globale Variablen
 *
 *********************/

// Diverses
volatile unsigned long Timerticks = 0;																		// Interne Uhr (10ms Takt)
volatile char BallAnzahl = 0;																							// Wieviele Kugeln liegen in der Truhe (incl. vor dem Abschuss)
volatile char Blinkticker = 0;																						// Blinkende Ausgabe der Ballanzahl
volatile char Blinker = FALSE;
 
//---------------------------------
// Konfiguration des Controllers
//---------------------------------
__CONFIG (1, OSC_EC);
__CONFIG (2, BOREN & BORV_27 & WDTEN);
__CONFIG (4, LVPDIS);

/**************************************
 *
 * Eine Zahl auf dem Display ausgeben
 *
 **************************************/
void DisplayNum (char Num)
 {
    if (Num == 0) DISPLAY = 0b00111111; else
	if (Num == 1) DISPLAY = 0b00000110; else
	if (Num == 2) DISPLAY = 0b01011011; else
	if (Num == 3) DISPLAY = 0b01001111; else
	if (Num == 4) DISPLAY = 0b01100110; else
	if (Num == 5) DISPLAY = 0b01101101; else
	if (Num == 6) DISPLAY = 0b01111101; else
	if (Num == 7) DISPLAY = 0b00000111; else
	if (Num == 8) DISPLAY = 0b11111111; else
	if (Num == 9) DISPLAY = 0b01101111; else DISPLAY = 0;
 }

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

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

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

  Count = time / 2;
  tickertime = GetTicker ();

  while ( (tickertime + (unsigned long)Count) > GetTicker () ) CLRWDT ();
 }


/***************************************************************
 *
 * Wieviele Kugeln befinden sich in Truhe und Auswurf *Hust* ?
 *
 ***************************************************************/
char Get_Anzahl (void)
 {
		char Summe = 0;
		if (INDUKT1) Summe++;
		if (INDUKT2) Summe++;		
		if (S1) Summe++;				
		if (S2) Summe++;				
		if (S3) Summe++;				
		if (S4) Summe++;				
		return (Summe);
 }

/************************************************ 
 *
 * Ermittelt die Anzahl Kugeln mit Fehlercheck
 *
 ************************************************/
void CheckTruhe (void)
 {
  char Summe = 0;
	
	Summe = Get_Anzahl ();Delayms (100);
	while (Summe != Get_Anzahl ()) 
	 {
	  Delayms (100);
	  Summe = Get_Anzahl ();
   }
	 
	 BallAnzahl = Summe;
	 
	} 

/*****************
 *
 * Zentrale ISR
 *
 *****************/
interrupt void INT_ (void)
 {

   //--------------------
   // Timer 1 Überlauf ?
   //--------------------
   if (TMR1IF)
   	{
      Systemticker ();                                  // Systemticker erhöhen, siehe MISC.C

			Blinkticker++;
			if (Blinkticker > 50)
			 {
			  Blinkticker = 0;
				if (Blinker) 
				 {
			         // DisplayNum (BallAnzahl);				// Aktuelle Zahl anzeigen
					 Blinker = FALSE;
					} else 
					{
					 // DisplayNum (10);								// Display aus
					 Blinker = TRUE;
					}
			 }

      TMR1IF=0;                                         // Clear Interrupt-Flag
      TMR1L=0x8E;                                       // Timer 1 neu vorladen 1ms
      TMR1H=0xFD;

			TMR1IF = 0;
   	} // From Timer 1 Überlauf
   
   return;									                     // Zurück zum Hauptprogramm
 }

/******************************
 *
 * Globale Initialisierungen
 *
 ******************************/
void Init (void)
 {
    //-----------
  // Port-Init
  //-----------
  PORTA=8;
  PORTB=0;
  PORTC=0;
	PORTD = 0;
	
  TRISB = 0;							              	         // Noch frei
	TRISA = 0;						               	 					 // Magnetventile, Strippen zum Host
  TRISC = 0xFF;                              			 // Sensoren etc
	TRISD = 0;																			 // 7-Sgement-Anzeige	
	
  //--------------------------
  // AD-Wandler-Einstellungen
  //--------------------------
  ADCON0 = 0x00;
  ADCON1 = 0x07;

  //------------
  // Timer-Init
  //------------
  TMR1IE=1;									                      // enable Interrupt of TMR1
  T1CON=49;									                      // Prescaler=1:8 + Timer on (49)

  //---------------
  // Interrupts an
  //---------------
  PEIE=1;          							                  // Peripherie Int=on
  GIE=1;										                      // Define Interupts
 }

/*******************************
 *
 * Start-Bedingung erfüllt ?
 *
 *******************************/
void CheckStartBall (void)
 {
		if (START)
		 {
		   Delayms (50);
			 if ( (START) && (BallAnzahl > 0) && (INDUKT2) )
			  {  // Startanforderung war gültig, eine Kugel auswerfen
					MV1 = 1;														// Ventil öffnen	
					Delayms (300);											// Pause	
					MV1 = 0;														// Ventil wieder dichtmachen
					Delayms (100);
					// Ballanzahl--;												// 10 kleine Negerlein.....		
				}
			while (START)	Delayms (10);							// Warten, bis das Signal wieder weg ist
		 }

 }

/*********************************
 *
 * Abschuss-Bedingung erfüllt ?
 *
 *********************************/
void LaunchBall (void)
 {
		if (LAUNCH)
		 {
		   Delayms (50);
			 if ( (LAUNCH) && (BallAnzahl > 0) && (INDUKT1) )
			  {  // Startanforderung war gültig, eine Kugel ins Spiel kotzen
					MV2 = 1;														// Ventil öffnen	
					Delayms (300);											// Pause	
					MV2 = 0;														// Ventil wieder dichtmachen
					Delayms (100);
					// Ballanzahl--;												// 10 kleine Negerlein.....		
				}
			while (LAUNCH)	Delayms (10);							// Warten, bis das Signal wieder weg ist
		 }
 }


/*********
 *
 * Main
 *
 *********/
void main (void)
{
  char i = 0;
  Init ();

	for (i=0; i < 10; i++)
	 {
	  DisplayNum (i);
		CLRWDT ();
		Delayms (150);
	 }

  while (1)
	 {
		CLRWDT ();
		CheckTruhe ();																// Schau mal, wieviele von der Baggage überhaupt zuhause sind....
		DisplayNum (BallAnzahl);
		CheckStartBall ();														// Soll ein Ball Richtung Abschuss gebracht werden?
		LaunchBall ();																// Soll mit dem Baby gespielt werden? *Fummel*	
   }
	 
}

// That´s all folks !