/* ANKS Anklappssteuerung fuer Aussenspiegel                           */
/*                       __    _                                       */                     
/*            __________/ /_  (_)________   ___  __  __                */       
/*           / ___/ ___/ __ \/ / ___/ __ \ / _ \/ / / /                */ 
/*          (__  ) /__/ / / / / /  / /_/ //  __/ /_/ /                 */ 
/*         /____/\___/_/ /_/_/_/  / .___(_)___/\__,_/                  */ 
/*                               /_/                                   */ 
/*                                                                     */ 
/* (c) C.Schirp released under the creative commons BY-NC-SA license   */
/*     for further details see                                         */ 
/*     http://creativecommons.org/licenses/by-nc-sa/3.0/               */ 
/*     schirp.eu must be named in derived software coyright notes      */
/*                                                                     */
/* V1.0 Erstausgabe                                                    */
/* V1.1 Änderung der Unterspannungserkennung HW1.3 erforderlich        */
/* V1.2 Entprellen der Eingangsinale, schneller Wechsel in Sleep       */
/*                                                                     */
/*                                                                     */

#include <c:\projekte\picsel\cc5\16F819.h>
#include <c:\projekte\picsel\cc5\int16CXX.h>
#include <c:\projekte\picsel\cc5\inline.h>

#pragma config = 0x3F38 
// INTIO2


/* Port- Defines */

#define TR1    0b.0001.0000	// PA Transistor 1 (L) linkslauf
#define TR2    0b.0000.1000	// PA Transistor 2 (L) rechtslauf
#define TR3    0b.0000.0100	// PA Transistor 3 (H) rechtslauf
#define TR4    0b.0000.0010	// PA Transistor 4 (H) linkslauf

#define IN_UNTER  0b.0100.0000	// PA Unterspannungssignal IN
#define PU_UNTER  0b.1000.0000	// PA Unterspannungssignal Pullup


#define INP_A  0b.0001.0000	// PB Eingang A
#define INP_B  0b.0010.0000	// PB Eingang B
#define INP_AB 0b.0011.0000	// PB beide Eingaenge


/* Programmkonstanten */
#define MOTORSTROM_H	80	// 1,2A x 0,33R
#define MOTORSTROM_L	10	// 1,2A x 0,33R
#define MOTORZEIT_H	60	// Max laufzeit in 100ms-Schritten

#define	ST_IDLE		0	// Stati-Defines
#define ST_ANKLAPP	1
#define ST_AUSKLAPP	2

#define END_STROM	0xFF	// Werte für Abbruch eines Klappvorganges in main()
#define END_ZEIT	0xFE
#define END_RICHTUNG	0xFD
#define END_SLEEP	0xDC


#define PWM_MAX  100		// Max-Tastgrad/Auflösung fuer Soft-PWM



/* Funktionsprototypen */
void Eingang_testen(void);

/* Variablen */
uns8 dummy, dummy2;	// Hilfsvariablen

uns8 Motorstrom;	// Ergebnis des Medianfilters
uns8 med_a;		// Filterwerte
uns8 med_b;
uns8 med_c;

uns8 soll_status;	// Resultat der Eingangspegelauswertung
uns8 result;		// Zwischenergebnis der Eingangsauswertung
uns8 i;			// for-index fuer Verzoegerung in Eingangsauswertung

uns8 laufzeit;		// Zähler für die Laufzeitüberwachung in main()

uns8 takt, cyc, duty;	// Fuer Soft-PWM

bank0 uns8 Blink:1;	// Bitcounter 

/*------------------------------------------------------------------*/
/*   II  N   N TTTTT                                                */
/*   II  NN  N   T                                                  */
/*   II  N N N   T                                                  */
/*   II  N  NN   T                                                  */
/*   II  N   N   T                                                  */
/*------------------------------------------------------------------*/
#pragma origin 4
interrupt int_server(void)
{
	int_save_registers
	
	// wenn int-on-change, dann status auswerten
	Eingang_testen();
	
	
	int_restore_registers
}



/*------------------------------------------------------------------*/
/*   II  N   N  II TTTTT                                            */
/*   II  NN  N  II   T                                              */
/*   II  N N N  II   T                                              */
/*   II  N  NN  II   T                                              */
/*   II  N   N  II   T                                              */
/*------------------------------------------------------------------*/

void init (void)
{
	/* Oszillatorblock */
	
	OSCCON = 0b0110.0000;	// 4MHz Clock - wie 16F628 mit INTRC
	
	/* PORT A, B Config */
	PORTA =  0x00;	
	ADCON1 = 0b1000.1110;	// AD-Wandler rechtsbuendig, Clk, nur PIN AN0
	TRISA =  0b0110.0001;	// RA0, 5 und 6 input
	
	PORTB =  0b0000.0000;	//
	TRISB =  0b0011.0000; 	// 4 Inp_A, 5 Inp_b, Rest Ausgang

	/* ADC */
	
	ADCON0=	 0b0100.0000;	// Fosc/8, Channel AN0, Stopped, AD_ON

	/*sonstiges*/
	T1CON = 0x00;		// Timer disabled
	OPTION_REG = 0x04;	/* pull-up portB, falling edge int, no WDT prescaler, prescale=32 */
	INTCON = 0b.0000.1000; 	// int disabled und gelöscht nur Int-on-change aktiv

	/* Variablen initialisieren */

	med_a = MOTORSTROM_L;
	med_b = MOTORSTROM_L;
	med_c = MOTORSTROM_L;
	
	soll_status = ST_IDLE;	
	
}

/*------------------------------------------------------------------*/
/*                                                                  */
/*                                                                  */
/*                                                                  */
/*                                                                  */
/*                                                                  */
/*------------------------------------------------------------------*/

//
// Pause für ms Milisekunden
//
void Delay1ms(uns16 ms)
{
	while(ms)				// Schleife verlassen wen ms=0 ist
	{
	    OPTION = 2; 		// Vorteiler auf 8 einstellen
	    TMR0 = 131; 		// 125 * 8 = 1000 (= 1 ms)
	    while (TMR0);		// abwarten einer Milisekunde
	    ms--;				// "ms" mit jeder Milisekunde ernidrigen
	}
}

//
// 3-Tap Medianfilter für die Motorstromwerte
// ältestes Element ist a, neuestes ist c
//
void MedianFilter(void)
{
#pragma updateBank 0 /* OFF, all cores */

  // Medianfilter 

  if (med_a>med_b)
   if (med_a<med_c)
    Motorstrom = med_a;
   else
    if (med_b<med_c)
     Motorstrom = med_c;
    else
     Motorstrom = med_b;
  else
   if (med_a>med_c)
    Motorstrom = med_a;
   else
    if (med_b<med_c)
     Motorstrom = med_b;
    else
     Motorstrom = med_c;
     
   
   // Werteliste weiterschieben
   med_a = med_b;
   med_b = med_c;
     
#pragma updateBank 1 /* OFF, all cores */
}

//
// Testen der Eingänge INP_A, INP_B und UNTER
// setzen des Soll-Modus
//
void Eingang_testen(void)
{
	

	// hier etwas warten
	for (i = 0; i <200; i++)
	{
		nop();
	}
	
	result = PORTB;		// Port lesen
	RBIF = 0;	// Int on change-Request loeschen
	
	result &= INP_AB;	// Eingänge maskieren
		
	switch (result)
	{
		case INP_A: soll_status = ST_AUSKLAPP; break;
		case INP_B: soll_status = ST_ANKLAPP; break;
		default: break;
	}
}

//
// Sleepmode-Entry mit Abschalten der Peripherie
// und Rücksetzen der Portchange-Bedingungen
//
void goto_sleep(void)
{
	
	dummy = PORTB;	// Portb lesen fuer Reset des Wakeup on change
	RBIF = 0;	// Portchange-Request loeschen
	GIE = 0;	// Global Int sperren
	
	ADON = 0; 	// ADC ausschalten
	sleep();
	
	RBIF = 0;	// Portchange-Request loeschen
	GIE = 1;	// Global Int freigeben	
	
	// Todo: entweder hier etwas warten...oder in eingang_testen()
}


//
// Soft-PWM fuer rechts- und linkslauf
// Portmuster übergeben in dummy und dummy2
//
void do_pwm(void)
{
	for (takt = 0; takt<PWM_MAX; takt++)
	{
		duty = PWM_MAX-takt;
	
		PORTA &= dummy;	// Off
	
		for ( cyc = 0; cyc < duty; cyc++)
		{
			nop();
		}
	
		PORTA |= dummy2;	//On
		
		for ( cyc = duty; cyc < PWM_MAX; cyc++)
		{
			nop();
		}
	
	}
}

//
// Start des Anklappvorganges, Aufruf der Soft-PWM
// Portmuster werden übergeben in dummy und dummy2
//
void anklappen(void)
{
	PORTA = 0;	// Alle Treiber aus
	Delay1ms(1);	// 1ms warten
	
	// erst Highside und Pullup für Kompartor an
	PORTA = TR4 + PU_UNTER;
	Delay1ms(1);	// 1ms warten
	
	//
	// PWM-Rampe mit steigender ON-Zeit 0..100
	//
	dummy = 0xff - TR1; 	// Off
	dummy2 = TR1;		// On
	
	// Wenn Spannung am Drain von T3 okay, dann anklappen
	if (PORTA & IN_UNTER)
	{	
		do_pwm();
		laufzeit = 0;
	}
	else // ansonsten nichts tun
	{
		soll_status = ST_IDLE;
	}

}

//
// Start des Ausklappvorganges, Aufruf der Soft-PWM
// Portmuster werden übergeben in dummy und dummy2
//
void ausklappen(void)
{
	PORTA = 0;	// Alle Treiber aus
	Delay1ms(1);	// 1ms warten
	
	// erst Highside an, dann Lowside
	PORTA = TR3;
	Delay1ms(1);	// 1ms warten
	
	//
	// PWM-Rampe mit steigender ON-Zeit 0..100
	//
	
	dummy = 0xff - TR2;	// off
	dummy2 = TR2;		// on
	
	do_pwm();
	laufzeit = 0;

}

//
// Motor-Stopp mit beiden Lowside-Treibern
// Reset der Motorstrom-Filterwerte
//
void motor_stop(void)
{
	PORTA = 0;	// Alle Treiber und Pullup aus
	Delay1ms(1);	// 1ms warten
	
	PORTA = TR1 + TR2;	// Lowside-Treiber beide an
	Delay1ms(100);
	PORTA = 0;	// Alle Treiber aus
	
	med_a = MOTORSTROM_L;	// Filterwerte loeschen
	med_c = MOTORSTROM_L;	
	med_b = MOTORSTROM_L;
	
}

//
// Strommessung über ADC-Eingang AN0
// AD-Wert wird in das Filterelement C geschrieben
//
void strom_messen(void)
{
		
	ADCON0=	 0b0100.0001;	// Fosc/8, Channel AN0, GO, AD_ON
	GO = 1;			// Wandlung starten
	
	while (GO);		// Auf ADC warten
	
	// Overflow abfangen
	if (ADRESH)
	{
		med_c = 0xFF;	
	}
	else
	{
		med_c = ADRESL;
	}
	
}



/*------------------------------------------------------------------*/
/*     M     M    A    II  N   N                                    */
/*     MM   MM   A A   II  NN  N                                    */
/*     M M M M  A   A  II  N N N                                    */
/*     M  M  M  AAAAA  II  N  NN                                    */
/*     M     M  A   A  II  N   N                                    */
/*------------------------------------------------------------------*/

void main (void)
{

	uns8 akt_status;
		
	init();
	
		
	while (1)
	{
		
		// wenn nichts zu tun
		if (soll_status == ST_IDLE)
		{
			goto_sleep();	// Gehe schlafen
		
			Eingang_testen(); // teste Eingangspegel
		}
		
		
		if (soll_status != ST_IDLE)
		{
			laufzeit = END_SLEEP;	// default: sofort wieder einschlafen
			
			if (soll_status == ST_ANKLAPP)
				Delay1ms(5000); // 5s warten (wegen Fehlbedienung)
			
			if (soll_status == ST_AUSKLAPP)
			{
				// dann ausklappen
				ausklappen();
			}
			else if (soll_status == ST_ANKLAPP)
			{
				// ansonsten anklappen
				anklappen();
			}
						
			akt_status = soll_status;
			
			
			
			while (laufzeit < MOTORZEIT_H)
			{
				Delay1ms(100);	// warten 0,1s
				
				laufzeit++;	// Zeitscheiben zaehlen
				
				strom_messen(); // Motorstrom messen
				
				MedianFilter();	// Filtern
				
				// Endabschaltung?
				if (Motorstrom > MOTORSTROM_H)
					laufzeit = END_STROM;
					
				// Kein Strom koennte Leerlauf oder short to GND sein..: abschalten!	
				if (Motorstrom < MOTORSTROM_L)
					laufzeit = END_STROM;
				
				
				// hat sich das klappziel geändert?
				if (akt_status != soll_status)
					laufzeit = END_RICHTUNG;
				
			} // von while (laufzeit)
			
			// wenn Motor tatsächlich bewegt wurde, stoppen
			if (laufzeit != END_SLEEP)
				motor_stop();
			
			// bei Überstom und -zeit klappvorgang beenden
			if (laufzeit != END_RICHTUNG)
				soll_status = ST_IDLE;
			
			
		} // von if != IDLE
		
	}; // von while(immer)


}