/*
 * main.c / Tankanzeige2
 *
 * Created: 1/9/2023 8:09:52 PM - Feb. 2023
 *  Author: Wulf D.
 */ 

#include <xc.h>
#include <avr/interrupt.h>
#include <avr/eeprom.h>
#include <avr/pgmspace.h>

#define Tank 0      // PWM Ausgang fuer die analoge Tankuhr
#define UbTaster 4  // Doppelfunktion: Betriebsspannung messen (KL15 aus) und Tasterabfrage, ADC-Eingang
#define Druck 2		// ADC-Eingang Drucksensor
#define Luft  3		// Schaltausgang Luftpumpe
#define LED_leer 1  // Schaltausgang LED, Tankwarnung
#define ADCMUX_Druck 1
#define ADCMUX_UbTaster 1
#define ADCTRIGGER 30		/* ADC-Einheiten fuer Ereignis */
#define KEYSHORTTIME 50		/* Timerticks, je ca 12ms, eines kurzen Tastendrucks */
#define ADCSUM 8*ADCTRIGGER /* Ereignissumme */
#define ABGVEKTORDIM 20 /* Max Zahl der Stuetzstellen der Tankfuellung */
#define DRMITTELDIM 16  /* Stuetzstellenzahl Mittelwertbildung */
#define TIMEIRQ 8		/* Multiplikator Timerticks bis 1/10s */
/* key task Byte */
#define keypressed 0
#define keyshort 1
#define keylong 2
#define abgleichDa 3
#define abgleichImGang 4
#define pumpeImGang 5
#define messungStehtAn 6
#define initerror 7
/* task Byte */
#define adctst     0
#define UbEinbruch 1
#define pwmupdate 2
#define pumpcycle 3
#define mittelwert 4

/* OCR0A Wert der PWM mit Zeigerreaktion
 64 erste Zeigerreaktion
 76 0 - Linie   Diff 12
 84 1/8               8
 92 1/4               8
 98 3/8               6
104 1/2               6
111 5/8               9
120 3/4				 11
132 7/8              12
161 voll			 29
190 zeigerstrichbreit über voll
*/
const uint8_t anzArray[] PROGMEM={64,76,84,92,98,104,111,120,132,161,190};
	
void timer_setup(void);
void adc_setup(void);
void adctest(void);
void tstkeyrelease(void);
void pumpe(void);
void pumpezyk(void);
void messung(void);
void mittelwertbildung(void);
int16_t tankkurve (uint8_t druck);
uint8_t anzeigekurve (int16_t tankwert);
uint16_t ticker,sec=0,zeitstempel,keytime,pumpenzeit; 
int16_t test16; /* bildet den berechneten PWM-Wert für die Stromquelle des Anzeigeinstruments ab */
uint8_t intr_count=0,intr_c10=0, pumpzyklus, blinkzyklus;
uint8_t adcDruck;			/* gemittelter Druckwert vom ADC */
uint8_t adcUbtast,adcTrigger,adcUbtasta[8],TastVeri,UbLowVeri,adcindex;
uint8_t key, task;			/* Task-Bytes */
uint8_t indexdr=DRMITTELDIM-1;
uint8_t indexab, abgvektor[ABGVEKTORDIM],drmittel[DRMITTELDIM]; /*RAM-Schatten des eeabpara, ADC-Druckmittelwerte*/

uint8_t eeabzahl EEMEM;					/* Zahl der Tank-Kallibrierungs-Stuetzstellen */
uint8_t eeabpara[ABGVEKTORDIM] EEMEM;	/* Tankstuetzstellen im EEPROM der Kallibrierung */

int main(void)
{
DDRB |= (1<<Tank) | (1<<Luft) | (1<<LED_leer);	// Ausgaenge Setzen
	
// PWM Setzen
TCCR0A = (1<<COM0A1)|(1<<WGM01)|(1<<WGM00);  // Output PB0, fast PWM
TCCR0B = (1<<CS01)|(1<<CS00); // Prescaler Counter 0
// OCR0A bestimmt Ausgangspegel
timer_setup();
adc_setup();
indexab = eeprom_read_byte (&eeabzahl); /* Kallibierwerte ins RAM holen */
if (indexab>ABGVEKTORDIM || indexab<3) 
	{indexab=ABGVEKTORDIM;
	key |= (1 << initerror);
	DDRB &= ~(1<<Luft);
	}
else {eeprom_read_block  (abgvektor, eeabpara, indexab);}
task |= (1 << pumpcycle);
pumpenzeit=sec+6;
PORTB|=(1<<Luft);
				
    while(1)
    {
    if ( task &(1<<adctst) ) adctest();
	if ( key & (1<<keypressed) ) tstkeyrelease();
	if ( key & (1<<pumpeImGang)) pumpe();
	if ( key & (1<<messungStehtAn)) messung();
	if ( task &(1<<pumpcycle)) pumpezyk();
	if ( task &(1<<mittelwert)) mittelwertbildung();
	if ((task &(1<<pwmupdate))&&!(key&(1<<initerror)))
				{test16=tankkurve (adcDruck);
		         OCR0A=anzeigekurve(test16);
				 task &= ~(1<<pwmupdate);
				}
    }
}

/* Auswertung des Unterspannungsereignisses: wenn Spannungseinbruch, dann
   Ausgaenge auf AUS zwecks Stromsparen, damit Controller noch eine Weile
   auf Lade-C laeuft: soll unnoetige Luftpumpenlaeufe bei mehrfachen Motor-
   startversuchen mit Kl. 15 ein-aus-ein verhindern, damit sich kein 
   explosives Gemisch im Tank bilden kann.
   Wenn Tasterbetaetigung erkannt, dann die Tastlaengenueberwachung starten
   */
void adctest(void)
{
	int sum=adcUbtasta[0];
	uint8_t stetig=1;
	if ((adcTrigger==1) &&!(task & (1 << UbEinbruch)))
	{
		for (uint8_t i=1; i<8;i++)
			{
			sum+= adcUbtasta[i];
			if 	(adcUbtasta[i]>adcUbtasta[i-1])stetig=0;
			}
		if (sum<5)
			{
			key |= (1 << keypressed);
			keytime=ticker;
			}
		else if (stetig)
			{
			task |= (1 << UbEinbruch);
			key &= ~(1 << keypressed)|(1<<keyshort)|(1<<keylong);
			}
	}
	adcTrigger=0;
	if (ticker-zeitstempel>400) task &= ~(1 << adctst);
}

/* ADC wird sowohl fuer die Druckmessung, der Unterspannungserkennung als auch zur 
   Taster-Erkennung genutzt. Die Doppelbelegung Taster vs Unterspannung liegt auf 
   dem selben Eingang und muss durch Verhalten unterschieden werden. 
   Das erfolgt hauptsaechlich in Funktion adctest */

ISR (ADC_vect)  /* ADC Conversion ready */
{
	if (ADMUX==0xA1)
	{
		adcUbtast = ADCH;
		ADMUX=0xA2;
		
		// Aufzeichnung bei starkem ADC-Abfall, um Tastendruck bzw KL15-aus.
		if ((ADCH<ADCTRIGGER) &&! (task&(1<<adctst)))
			{if(!adcTrigger) /* Unterspannungsereignias oder Taster? */
				{
				zeitstempel=ticker;
				adcTrigger=1;
				adcindex=0;
				}
			adcUbtasta[adcindex]=ADCH;
			adcindex++;	/* Unterspannungsverlauf aufzeichnen, zwecks spaeterer Auswertung*/
			if (adcindex==8) task |= (1<<adctst);
			}
		if (ADCH>=ADCTRIGGER) adcTrigger=0;
	}
	else
	{
		drmittel[indexdr]=ADCH;
		if (!indexdr)
		{indexdr=DRMITTELDIM;
			task |= (1<<mittelwert);
		}
		indexdr--;
		ADMUX=0xA1;
	}
}


/* Bildet den Druckwert des Sensors auf den Wertebereich 0-1152 (9*128) ab.
   0 entspricht dem Leerdruck bei der Kalibrierung, 1152 dem letzten Wert
   vor Abschluss der Kalibierung. Die Kalibrierungstabelle ist abgvektor.
   Es wird abschnittsweise linear interpoliert, um die Tankgeometrie zu
   linearisieren. Leicht negative und minimal >1024 Werte sind möglich.
*/
int16_t tankkurve (uint8_t druck)
{
uint8_t i;
int16_t z, n, q, scale;
for (i=0; i<indexab; i++)
	{if (druck < abgvektor[i]) break;
	}
if (i==0) i=1;
if (i>=indexab)	i=indexab-1;
scale=1152/(indexab-1);
z=druck-abgvektor[i-1];
n=abgvektor[i]-abgvektor[i-1];
q = (z*scale)/n;
q = q+scale*(i-1);
return q;
}

/* Bildet den linearisierten Fuellstand des Tanks auf den Wertebereich
   der PWM der Tankuhr-Ansteuerung ab. Die Eichkurve anzArray der Anzeige
   wurde optisch in 8 Fuellständen von 0 bis F, plus zwei Staenden Zeiger
   bewegt sich gerade und Zeiger ein Strich ueber voll, optisch ermittelt
   und im Programmspeicher statisch abgelegt.
   Abschnittsweise linearisiert, da die PWM-Ansteuerung mit Stromquelle
   sowohl Offset hat als auch nach oben hin deutlich nichtlinear ist.
   Auf "optische Reserve" ausgelegt, d.h. ganz leer ist Linksanschlag <0.
*/
uint8_t anzeigekurve (int16_t tankwert)
{
int8_t i;
int16_t rest,z,q;
if ( (key & (1<<initerror)) || (task & (1 << UbEinbruch))) return 0;
i=tankwert/128;   // Fuellstand in neunteln
rest=tankwert-i*128;
if (i<0) i=0;
if (i>9) i=9;
z=anzArray[i+1]-anzArray[i];
q=z*rest/128;
q=q+anzArray[i];
return (uint8_t)q;	
}


void mittelwertbildung (void)
{
uint16_t sum=0;
task &= ~(1<<mittelwert);
	for (uint8_t i=0; i<DRMITTELDIM;i++)
		{sum+=drmittel[i];	
		}
	adcDruck=(uint8_t)(sum/DRMITTELDIM);	
}

/* Tastlaengenermittlung und Teile der Kalibrierroutine
   Ablauf der Kalibrierung (Auslitern) der Tank-Stuetzstellen:
   
   1. Langer Druck auf die Taste leitet ein (abgleichImGang). 
      LED_leer blinkt in 1/10s, Pumpe läuft 6s, 
      Anschließend Leermessung Druck.
   2. Bestimmte, konstante Menge Sprit (z.B. 5l) einfuellen
   3. Kurzer (!) Tastendruck.
      Pumpe läuft 3s, nach kurzer Wartezeit Druckmessung.
	  LED_leer blinkt mit einer Auslueckung (da erste Messung)
   4. Kurzer Tastendruck. Zyklus nach 3. wiederholt sich.
      LED_leer blinkt mit Auslueckung nach zwei Lichtblitzen.
   5. Vorgang solange wiederholen bis Tank voll.
      Wegen Arraylaenge nur max 20 Stuetzstellen moeglich.
      Wenn voll, nur langen Tastendruck. Kalibriersequenz 
	  abgeschlossen, Druckwerte werden im EEPROM abgespeichert.
*/
void tstkeyrelease(void)
{
if 	(adcUbtast> 50)  // magic number!
	{ // Taste geloest
	if (ticker-keytime<KEYSHORTTIME)
		{
		key |= (1 << keyshort);
		if ( key & (1<<abgleichImGang) )
			{
			PORTB|=(1<<Luft);
			key |= (1<<pumpeImGang);
			pumpenzeit=sec+2;	
			}
		}
	else
		{
		key |= (1 << keylong);
		DDRB |= (1<<Luft);
		if ( key & (1<<abgleichImGang) )
			{
			PORTB &= ~(1<<Luft);
			key &= ~(1 << abgleichImGang);
			if ( indexab>2 )
				{
				eeprom_write_byte (&eeabzahl, indexab);
				eeprom_write_block (abgvektor, eeabpara, indexab);	
				key &= ~(1 << initerror);
				}
			}
		else
			{
			PORTB|=(1<<Luft);
			pumpenzeit=sec+5;
			key |= ((1<<abgleichImGang)|(1<<pumpeImGang));
			indexab=0;
			}		
		}
	key &= ~(1 << keypressed)|(1<<keyshort)|(1<<keylong);	
	}
}

void pumpe(void)
{
if (sec>pumpenzeit)
	{
	key &= ~((1<<keypressed)|(1<<keyshort)|(1<<keylong)|(1<<pumpeImGang));	
	PORTB &= ~(1<<Luft);
	pumpenzeit=sec+5;		// Messung verzoegern
	key |= (1<<messungStehtAn);
	}
}

void pumpezyk(void)
{
if (sec>pumpenzeit)
	{
	task &= ~(1<<pumpcycle);	
	PORTB &= ~(1<<Luft);
	}
}

void messung(void)
{
if (sec>pumpenzeit)
	{
	if ( key & (1<<abgleichImGang) )
		{
		abgvektor[indexab]= adcDruck;
		indexab++;
		}
	key &= ~(1<<messungStehtAn);
	}
}

void adc_setup()
{
	ADMUX|=(1<<REFS1)|(1<<ADLAR)|(1<<MUX0); // 1.1Vref, 0xA1, configuring PB2 to take input, left adjust result
	ADCSRB=0x00;           //Configuring free running mode
	ADCSRA|=(1<<ADEN)|(1<<ADSC)|(1<<ADIE)|(1<<ADATE)|(1<<ADPS2)|(1<<ADPS0); //Start ADC conversion and ADC interrupt enable
}  //(1<<ADPS2)|(1<<ADPS0) heisst /32 prescaler, etwa alle 0,4ms eine Konvertierung.

void timer_setup()
{
	TCCR1=0x00; //Normal mode
	TCCR1 |= (1<<CS12)|(1<<CS11);   //prescaling with 512
	sei(); //enabling global interrupt
	TCNT1=0;
	TIMSK|=(1<<TOIE1); //enabling timer1 interrupt
}

/* zwei Timerstufen: ticker ca 12ms, sec ca 1s
	Außerdem 1/10s Blinkmuster während Kalibrierung und n * 1s Takte Pumpensteuerung
*/
ISR (TIMER1_OVF_vect)    // ca 12ms Interrupt vector for Timer0
{
ticker++;
if (intr_count==TIMEIRQ) // ca 1/10 sec Takt
	{
	intr_count=0; //making intr_count=0 to repeat the count
	
	if (intr_c10==9)
		{				// ca 1 sec Takt
		intr_c10=0;
		++sec;
		if (key & (1<<abgleichImGang) && blinkzyklus) PORTB^=(1<<LED_leer);		
		if (!blinkzyklus) blinkzyklus=(indexab<<1)+1;		
		blinkzyklus--;
		++pumpzyklus;
		if (!pumpzyklus){ /* schaltet alle 256s für 3s die Luftpumpe ein */
						task |= (1 << pumpcycle);
						pumpenzeit=sec+3;
						PORTB|=(1<<Luft);
						}
		if (task & (1 << UbEinbruch))
			{if (adcUbtast>111) task &= ~(1<<UbEinbruch);// Spannungeinbrucherkennung aus
			}
		}
	else intr_c10++;
	if (key&(1<<initerror)&& !(key&(1<<abgleichImGang))) PORTB^=(1<<LED_leer);//toggling the LED	
	task |= (1<<pwmupdate);
	}
else  intr_count++;	
}