/**************************************************************************************************************
 *
 * Sodbrenner III
 *
 * Autor : Finger, mailto:finger@fingers-welt.de
 *
 *************************************************************************************************************/

#include	<pic18.h>
#include 	<string.h>
#include	<ctype.h>
#include	<math.h>
#include	<stdlib.h>
#include	<stdio.h>
#include  "defines.h"                                     

#define	XTAL_FREQ	4MHZ		// Crystal frequency in MHz, in diesem Projekt völliger Quark. Muß erstmal so bleiben !
#define	MHZ	*1000			    // number of kHz in a MHz

#define	DelayUs(x)	{ unsigned int _dcnt; \
			  _dcnt = (x)/(12MHZ/(XTAL_FREQ))|1; \
			  while(--_dcnt != 0) \
				  continue; }

#define MOTOR			RD0
#define ZUENDER			RD1
#define EKELIGEBLAUELED	RD2
#define SERVO			RC2

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

//-------------
// Allgemeines
//-------------
long Timerticks = 0;
volatile char LEDFlag = FALSE; 
volatile int LEDCounter = 0;

volatile int PWMEinCounter = 0;
volatile int PWMAuscounter = 0;
volatile int PWMCounter;
volatile char PWMRichtung = FALSE;

#define ServoAuf		1
#define ServoZu			3	

volatile int PWMPERIODE = 40;
volatile int PWMWert = ServoZu;

char Buchstaben [27][6];					// Codedefinitionen für die Buchstaben A..Z
char Zahlen [11][6];								// Codes für Zahlen 0..9

char outpbuf [20];
int i;

//-------------------------------------------------
// Konfiguration des Controllers
//-------------------------------------------------
__CONFIG(1, OSCEN & HSPLL);       // Quarz 10 Mhz mit PLL = 40 Mhz
__CONFIG(2, BORDIS & WDTDIS);      // Kein Watchdog, kein BrownOut
__CONFIG(4, LVPDIS & STVREN);      // Kein LowVoltageProgramm, Reset bei StackOverflow


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

 }

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

/***************************************************************************************************************
 *
 * Verzögern im Millisekundenbereich
 *
 ***************************************************************************************************************/
void Delayms (long time)
 {
  long ticker;
  Timerticks = 0;	
  ticker = Get_Ticker ();
  while ( (ticker + (time / 1)) > Get_Ticker () );
 }

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

      Systemticker ();                                  // Systemticker erhöhen, siehe MISC.C

	  LEDCounter++;	
	  if (LEDCounter > 400)
	   {
	    LEDCounter = 0;
	    if (LEDFlag)  LEDFlag = FALSE; else LEDFlag = TRUE;
		EKELIGEBLAUELED	= LEDFlag;
	   }	

	  PWMCounter++;
	  if (PWMCounter > 2)
	   {
	    PWMCounter = 0; 
		
		// -----------------------------------------------------
		
		if (PWMRichtung)
		 {
		   PWMEinCounter++;
		   if (PWMEinCounter > PWMWert)
		    {
			 PWMEinCounter = 0;
			 PWMAuscounter = 0;
			 SERVO = 0;
			 PWMRichtung = FALSE;
			}
		 } else
		 {
		   PWMAuscounter++;
		   if (PWMAuscounter > (PWMPERIODE - PWMWert))
		    {
			 PWMEinCounter = 0;
			 PWMAuscounter = 0;
			 SERVO = 1;
			 PWMRichtung = TRUE;
			}
		 } // Von else If (PWMRichtung)
	   
	   // -----------------------------------------------------
	   
	   } // Von if (PWMCounter > 20)
	
      TMR1IF=0;                                         // Clear Interrupt-Flag
      TMR1L=0xEC;                                       // Timer 1 neu vorladen (0xF3B4 = 5ms)
      TMR1H=0xFD;                                       // n = 2^16 - t [s] * 625000

   	} // From Timer 1 Überlauf

   return;									                            // Zurück zum Hauptprogramm
 }



/*************************************************************************************************
 *
 * Globale Initialisierungen
 *
 *************************************************************************************************/
void Init (void)
 {

 // Morsedefinitionen belegen
  memset (Buchstaben, '\0', sizeof (Buchstaben)); // Puffer leeren
  sprintf (Buchstaben [0]  , ".-");
  sprintf (Buchstaben [1]  , "-...");
  sprintf (Buchstaben [2]  , "-.-.");
  sprintf (Buchstaben [3]  , "-..");
  sprintf (Buchstaben [4]  , ".");
  sprintf (Buchstaben [5]  , "..-.");
  sprintf (Buchstaben [6]  , "--.");
  sprintf (Buchstaben [7]  , "....");
  sprintf (Buchstaben [8]  , "..");
  sprintf (Buchstaben [9]  , ".---");
  sprintf (Buchstaben [10] , "-.-");
  sprintf (Buchstaben [11] , ".-..");
  sprintf (Buchstaben [12] , "--");
  sprintf (Buchstaben [13] , "-.");
  sprintf (Buchstaben [14] , "---");
  sprintf (Buchstaben [15] , ".--.");
  sprintf (Buchstaben [16] , "--.-");
  sprintf (Buchstaben [17] , ".-.");
  sprintf (Buchstaben [18] , "...");
  sprintf (Buchstaben [19] , "-");
  sprintf (Buchstaben [20] , "..-");
  sprintf (Buchstaben [21] , "...-");
  sprintf (Buchstaben [22] , ".--");
  sprintf (Buchstaben [23] , "-..-");
  sprintf (Buchstaben [24] , "-.--");
  sprintf (Buchstaben [25] , "--..");

  memset (Zahlen, '\0', sizeof (Zahlen)); // Puffer leeren
  sprintf (Zahlen [0] , "-----");
  sprintf (Zahlen [1] , ".----");
  sprintf (Zahlen [2] , "..---");
  sprintf (Zahlen [3] , "...--");
  sprintf (Zahlen [4] , "....-");
  sprintf (Zahlen [5] , ".....");
  sprintf (Zahlen [6] , "-....");
  sprintf (Zahlen [7] , "--...");
  sprintf (Zahlen [8] , "---..");
  sprintf (Zahlen [9] , "----.");

  //-----------
  // Port-Init
  //-----------

   PORTA=0;
   PORTB=0;
   PORTC=0;

   TRISA = 0b11111111;								              // Alles Eingang
   TRISB = 0b00000000;							              	// Alles Ausgang
   TRISC = 0b00000000;      	           	  			  // Alles Ausgang
   TRISD = 0b00000000;
   
   //------------
   // Timer-Init
   //------------
   TMR1IE=1;									                      // enable Interrupt of TMR1
   T1CON=1;									                      	  // Prescaler=1:8 + Timer on (49)

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

   //--------------------------
   // AD-Wandler-Einstellungen
   //--------------------------
   ADCON0 = 0x00;
   ADCON1 = 0x07;

   	

 }


/******************************
 *
 * Einen Buchstaben raushauen
 *
 ******************************/
void Morsen (char Zeichen)
 {
  int i;
  
  #define KURZ				4000
  #define LANG				(int)(2.1*(float)KURZ)
  #define DITPAUSE			KURZ
  #define BUCHSTABENPAUSE	4*KURZ	
  #define WORTPAUSE			8*KURZ	
  
  for (i=0; i < strlen (Buchstaben [Zeichen-65]); i++)
   {
    PWMWert = ServoAuf; ZUENDER = 1;
    if (Buchstaben [Zeichen-65][i] == '.') Delayms (KURZ); else Delayms (LANG);
	
	PWMWert = ServoZu;ZUENDER = 0;
	Delayms (DITPAUSE);
	
   }
   
  Delayms (BUCHSTABENPAUSE);
  
 }

/************************************************************************
 *
 * Main
 *
 ************************************************************************/
void main (void)
{

  Init ();

  // Warten, bis der Motor hinreichend gepumpt hat
  PWMWert = ServoZu;ZUENDER = 0;	
  for (i=0; i < 10; i++) Delayms (10000);	

  while (1)
   {
   
	 sprintf (outpbuf, "WELTHERRSCHAFT");
	 for (i=0; i < strlen (outpbuf); i++)	Morsen (outpbuf [i]);
	 Delayms (WORTPAUSE);
   
	 Delayms (10000);

	 sprintf (outpbuf, "FINGERSWELT");
	 for (i=0; i < strlen (outpbuf); i++)	Morsen (outpbuf [i]);
	 Delayms (WORTPAUSE);
   
	 Delayms (10000);


   } // Von While (1)

}

// That´s all folks !