//-------------------------------------------------------------------------
// Titel : Einzelspannungserfassung 24-Zeller
//-------------------------------------------------------------------------
// Funktion : auslesen eines Multiplexers
// Schaltung : Einzelspannungserfassung 24-Zeller v0.91 (Eigenbau)
//-------------------------------------------------------------------------
// Prozessor : ATmega8
// Takt : 14745600 Hz
// Sprache : Deutsch
// Datum : 18.03.2008
// Version : 1.5
// Autor : Johan Mol
// Programmer: 
// Port : 
//-------------------------------------------------------------------------
#define F_CPU 14745600 // 3686400 //
#include <avr\io.h>
#include <stdio.h>			
#include <stdlib.h>			
#include <avr\interrupt.h>
#include <string.h>
//#include <avr\delay.h>

// Defines für Multiplexeransteuerung
// Aufbau: PORTB=0b|00(externer Quarz)|A0|EN0|A1|A2|EN1|EN2;

#define aus PORTD&=~(1<<DDD7)|(1<<DDD6);
#define aus2 PORTB&=~(1<<DDB7)|(1<<DDB6)|(1<<DDB5)|(1<<DDB4)|(1<<DDB3)|(1<<DDB2);

#define Zelle1  	do {PORTB=(1<<DDB4);} while (0)//PORTB=0b00010000;
#define Zelle2  	do {PORTB=(1<<DDB5)|(1<<DDB4);} while (0)//PORTB=0b00110000;
#define Zelle3  	do {PORTB=(1<<DDB3)|(1<<DDB4);} while (0)//PORTB=0b00011000;
#define Zelle4  	do {PORTB=(1<<DDB3)|(1<<DDB3)|(1<<DDB4);} while (0)//PORTB=0b00111000;
#define Zelle5  	do { PORTB=(1<<DDB4); PORTD = (1<<DDD6); } while (0)	//PORTB=0b00010100
#define Zelle6  	do { PORTB=(1<<DDB5)|(1<<DDB4); PORTD = (1<<DDD6); } while (0)	//PORTB=0b00110100
#define Zelle7  	do { PORTB=(1<<DDB4)|(1<<DDB3); PORTD = (1<<DDD6); } while (0)	//PORTB=0b00011100
#define Zelle8  	do { PORTB=(1<<DDB5)|(1<<DDB4)|(1<<DDB3); PORTD = (1<<DDD6); } while (0)	//PORTB=0b00111100

#define Zelle9  	do { PORTD = (1<<DDD7); } while( 0 ) //PORTB=0b00000010;//
#define Zelle10  	do { PORTB = (1<<DDB5); PORTD = (1<<DDD7); } while( 0 ) //PORTB=0b00100010;//
#define Zelle11  	do { PORTB = (1<<DDB3); PORTD = (1<<DDD7); } while( 0 ) //PORTB=0b00001010;// 
#define Zelle12  	do { PORTB = (1<<DDB5)|(1<<DDB3); PORTD = (1<<DDD7); } while( 0 ) //PORTB=0b00101010;//
#define Zelle13  	do { PORTD = (1<<DDD7)|(1<<DDD6); } while( 0 ) //PORTB=0b00000110;//
#define Zelle14  	do { PORTB = (1<<DDB5); PORTD = (1<<DDD7)|(1<<DDD6); } while( 0 ) //PORTB=0b00100110;//
#define Zelle15  	do { PORTB = (1<<DDB3); PORTD = (1<<DDD7)|(1<<DDD6); } while( 0 ) //PORTB=0b00001110;//
#define Zelle16  	do { PORTB = (1<<DDB3)|(1<<DDB5); PORTD = (1<<DDD7)|(1<<DDD6); } while( 0 ) //PORTB=0b00101110;//

#define Zelle17 	do {PORTB=(1<<DDB0); } while( 0 )//0b00000001;
#define Zelle18 	do {PORTB=(1<<DDB5)|(1<<DDB0); } while( 0 )//0b00100001;
#define Zelle19 	do {PORTB=(1<<DDB3)|(1<<DDB0); } while( 0 )//0b00001001;
#define Zelle20		do {PORTB=(1<<DDB5)|(1<<DDB3)|(1<<DDB0); } while( 0 )//0b00101001;
#define Zelle21 	do {PORTB=(1<<DDB0); PORTD = (1<<DDD6); } while( 0 )//0b00000101;
#define Zelle22 	do {PORTB=(1<<DDB5)|(1<<DDB0); PORTD = (1<<DDD6);} while( 0 )//0b00100101;
#define Zelle23 	do {PORTB=(1<<DDB3)|(1<<DDB0); PORTD = (1<<DDD6);} while( 0 )//0b00001101;
#define Zelle24 	do {PORTB=(1<<DDB5)|(1<<DDB3)|(1<<DDB0); PORTD = (1<<DDD6);} while( 0 )//0b00101101;

// Globale Variablen

volatile uint32_t mittelwert; //merker der letzten Zellspannung
volatile int fallunterscheidung;
volatile int16_t i_pidsetpoint=0;	//Sollwert
volatile int i_abbruch;				//Abbruchkriterium für Timer
volatile int16_t i_pidsense=0;					//gucken ob global nötig ist
volatile int16_t i_hold_value;		//Backupvariable für Setpoint, kann ggf gelöscht werden

//------------------------------------------------------------------------
// Initialisierungen
//------------------------------------------------------------------------
void init()
{
	// Ports initialisieren
	sbi(DDRB,0); 	// (Enable Zelle 17-24)
	//sbi(DDRB,1); 	// (Enable Zelle  9-16)
	//sbi(DDRB,2); 	// Multiplexer A2 
	sbi(DDRB,3); 	// Multiplexer A1 
	sbi(DDRB,4); 	// (Enable Zelle  1-8)
	sbi(DDRB,5); 	// Multiplexer A0#
	sbi(DDRD,6);	// Multiplexer A2
	sbi(DDRD,7);	// (Enable Zelle 9-16)

	// Port Belegung Regelung
	//DDRB|=(1<<DDB1);	// PWM
	DDRC&=~(1<<DDC2);	// Lem Strom Pidsense
	DDRC&=~(1<<DDC0);	// Lem Strom Pidsense
	//----------------------------------------------------------

	// UART initialisieren
	UBRRL  = 7;         	//7-->115200 Baud siehe Baudratentabelle//3-->230400
	UCSRB = 8 + 16;           //Sender enable UCSRB / UCR bei z.B.: 2313
}
//----------------------------------------------------------------------
void putChar(unsigned char data)
{
	//warte bis UDR leer ist UCSRA / USR bei z.B.: 2313
	while (!(UCSRA&32));
	//sende
	UDR=data;
}

void print(char buffer[])
{
	for (int i=0;buffer[i]!=0;i++)
		putChar(buffer[i]);
}

//----------------------------------------------------------------------

//UART Funktion
unsigned char getChar()
{
	char data=0;
	//warte bis RX-complete RXC
	while (!(UCSRA&128));
	//empfangen
	data=UDR;
	return data;
}
//----------------------------------------------------------------------

//----------------------------------------------------------------------

// Timer 2 initialisieren
void init_timer_2()
{
	TCCR2=0x06;// 0x06;  	// Teiler 1/256
	TIMSK|=0b01000000; 	// Interrupt bei Überlauf
	//--- Interrupts erlauben ---
	sei();
}
//----------------------------------------------------------------------

// Timer 2 Interruptroutine
ISR(TIMER2_OVF_vect)
{
	i_abbruch=0;
}
//----------------------------------------------------------------------

// ADC einlesen
/*uint16_t einlesen (uint8_t i_spg_plex)

{
int i_index;
uint16_t i_ergebnis=0;
ADCSRA=0b10000101;//(1<<ADEN)|(1<<ADPS2)|(1<<ADPS0);
ADMUX= i_spg_plex;
ADMUX|=(1<<REFS0); //Beide auf 1 gesetzt, damit gilt interne Referenzspannung
ADCSRA|=(1<<ADSC);

while (ADCSRA & (1<<ADSC))
{
; //wartet bis Wandlung abgeschlossen ist
}

for (i_index=0;i_index<10;i_index++)
{
//Anfang For-Schleife

ADCSRA|=(1<<ADSC);
while (ADCSRA &(1<<ADSC))
{
;
}
i_ergebnis+=ADCW;

}
//Ende For-Schleife

ADCSRA &=~(1<<ADEN);  //ADC auf Low setzten, ADC kann wieder als I/O genutzt werden

i_ergebnis /=10;
return i_ergebnis;
}*/
//----------------------------------------------------------------------

/*uint16_t erfassung (uint8_t i_spg_plex)
{
uint8_t i_ergebnis=0;
ADCSRA=0b10000111;//(1<<ADEN)|(1<<ADPS2)|(1<<ADPS0)|(1<<ADPS1); //Divisionsfaktor 128
ADMUX= i_spg_plex;
ADMUX|=(1<<REFS0); //Beide auf 1 gesetzt, damit gilt interne Referenzspannung
ADCSRA|=(1<<ADSC);

while (ADCSRA & (1<<ADSC))
{
; //wartet bis Wandlung abgeschlossen ist
}
i_ergebnis=(ADC/4);
ADCSRA&=~(1<<ADEN);

return i_ergebnis;
}
*/
void initADC()
{
	ADCSRA=0b11000111;			//0b11000011, ADC-Clock, ADC ON
}

unsigned char spannung(void)		//Auswertung ADC...
{
	sbi	(ADCSRA,6);		// restart ADC
	while (ADCSRA & 0x40)
	{
	}			//ende warteschleife für AD-Wandlung

	return (unsigned char) (ADC/4);
}

int set_output(int celnumber)
{
	switch (celnumber)
	{

		case 1: do 
		{
		Zelle1; aus;aus2;
		}
		while(0);// Zelle1;
		break;

		case 2: do 
		{
		Zelle2; aus;aus2;
		}
		while(0);//Zelle2;
		break;

		case 3: do 
		{
		Zelle3; aus;aus2;
		}
		while(0);//Zelle3;
		break;

		case 4: do 
		{
		Zelle4; aus;aus2;
		}
		while(0);//Zelle4;
		break;

		case 5: do 
		{
		Zelle5; aus;aus2;
		}
		while(0);//Zelle5;
		break;

		case 6: do 
		{
		Zelle6; aus;aus2;
		}
		while(0);//Zelle6;
		break;

		case 7: do 
		{
		Zelle7; aus;aus2;
		}
		while(0);//Zelle7;
		break;

		case 8: do 
		{
		Zelle8; aus;aus2;
		}
		while(0);//Zelle8;
		break;

		case 9: do 
		{
		Zelle9; aus;aus2;
		}
		while(0);//Zelle9;
		break;

		case 10: do 
		{
		Zelle10; aus;aus2;
		}
		while(0);//Zelle10;
		break;

		case 11: do 
		{
		Zelle11; aus;aus2;
		}
		while(0);//Zelle11;
		break;

		case 12: do 
		{
		Zelle12; aus;aus2;
		}
		while(0);//Zelle12;
		break;

		case 13: do 
		{
		Zelle13; aus;aus2;
		}
		while(0);//Zelle13;
		break;

		case 14: do 
		{
		Zelle14; aus;aus2;
		}
		while(0);//Zelle14;
		break;

		case 15: do 
		{
		Zelle15; aus;aus2;
		}
		while(0);//Zelle15;
		break;

		case 16: do 
		{
		Zelle16; aus;aus2;
		}
		while(0);//Zelle16;
		break;

		case 17: do 
		{
		Zelle17; aus;aus2;
		}
		while(0);//Zelle17;
		break;

		case 18: do 
		{
		Zelle18; aus;aus2;
		}
		while(0);//Zelle18;
		break;

		case 19: do 
		{
		Zelle19; aus;aus2;
		}
		while(0);//Zelle19;
		break;

		case 20: do 
		{
		Zelle20; aus;aus2;
		}
		while(0);//Zelle20;
		break;

		case 21: do 
		{
		Zelle21; aus;
		}
		while(0);//Zelle21;
		break;

		case 22: do 
		{
		Zelle22; aus;aus2;
		}
		while(0);//Zelle22;
		break;

		case 23: do 
		{
		Zelle23; aus;aus2;
		}
		while(0);//Zelle23;
		break;

		case 24: do 
		{
		Zelle24; aus;aus2;
		}
		while(0);//Zelle24;
		break;

		default: do
		{
			aus;
		}
		while (0);

		break;

	}
	//end switch

}

//---------------------------------------------------------------------------
// Main-Funktion
//---------------------------------------------------------------------------

main ()
{

	initADC();
	init();
	uint16_t result;

	//----------------------------------------------------------------------		

	// Timer 1 initialisieren
	/*TCCR1A=(1<<WGM11)|(1<<WGM10)|(1<<COM1A1);
	TCCR1B=(1<<DDB1);*/
	//----------------------------------------------------------------------	

	// Variablen deklarieren

	char c_buffer[20];
	char c_zeichen;
	float f_help=0;
	float f_pidoutput=0;
	float f_err_0=0;
	float f_err_1=0;
	float f_err_2=0;
	int i_P=20;
	int i_I=10;
	int i_D=5;
	int16_t i_temp;			//Sollwert Strom oder anzahl_zellen
	int i_anzahl_zellen;
	uint16_t i_zellspannungen[24];
	int i_volt_setpoint=250;

	//----------------------------------------------------------------------	

	uint16_t i_index=0;
	int i_delay;
	int count=0;
	int checksum=0;
	ADMUX=0b11000000; //ADC Kanal C0
	sbi	(ADCSRA,6);	// restart ADC
	count=1;
	while (true) // Mainloop

	{
		//_delay_ms(1);
		int i_low_volt=0;				//muss jeden Durchlauf auf 0 gesetzt werden für Regelung
		init_timer_2 ();				//aktivieren des Timers Zeile 121
		i_abbruch=1;					//Setzt Abbruchkriterium Zeile 63

		if (count>=25)		      //after cel 24 send result of conversion and end of string 
		{
			checksum+=result && 255;
			//putChar(result); <----AN
			//putChar((unsigned char) checksum); <----AN
			//putChar(22);
			count=1;                              //reset counter and checksum  <----AN
			checksum=0;
		}
		set_output(count);
		if (count==1)				//at first cel send header
		{
			//putChar(104); <----AN
			//putChar(24); <----AN
			//putChar(24); <----AN
			//putChar(104); <----AN
			//putChar(24); <----AN
		} 
		else
		{
			checksum+=result && 255;
			//putChar(result);                     //otherwise send conversion result. <----AN
		}

		/*for (i_delay=0; i_delay<10000; i_delay++)
		{
		;
		}*/
		result=spannung();//erfassung(0);//
		i_zellspannungen[count]=result;

		/*print("Zellzl. >>"); 
		putChar(' ');*/
		itoa(count,c_buffer,10);
		print(c_buffer);
		putChar(' ');	

		//print("Zellspg >>");
		//putChar(' ');
		itoa(i_zellspannungen[count],c_buffer,10);
		print(c_buffer);
		putChar(' ');                        
		//sbi	(ADCSRA,6);
		//i_pidsense=einlesen(2);

		if (count==24)	//Regle erst nachdem alle Zellen getastet sind
		{
			i_temp=10;	//Lese Regelparameter aus UART

			//----------------------------------------------------------------------	

			// Spezifikation des ankommenden Wertes	

			if (i_temp<=199 && i_temp>=0)
			{
				i_pidsetpoint=i_temp;	//Deklarierung des Sollwertes
				i_hold_value=i_pidsetpoint;

			}
		else if (i_temp>=200 && i_temp<=255)
			{

				i_anzahl_zellen=i_temp-200;
				i_pidsetpoint=i_hold_value;

			}
		else
			{
				i_pidsetpoint=i_hold_value;
				i_anzahl_zellen=0;
			}

			//----------------------------------------------------------------------	

			for (i_index=0;i_index<25;i_index++)
			{

				if (i_zellspannungen[i_index]<i_volt_setpoint)
				{

					i_low_volt=i_zellspannungen[i_index];

				}
			else if (i_index==24 && i_low_volt!=0)
				{
					i_pidsetpoint=i_pidsetpoint-10;
				}

			else
				i_pidsetpoint=i_pidsetpoint;
				//Drehe Daumen
			}

			// Beginn der Regelung

			//Istwert

			//i_pidsense=einlesen(2);

			// Regelung

			f_err_2=f_err_1;
			f_err_1=f_err_0;		
			f_err_0=i_pidsetpoint-i_pidsense; 

			f_pidoutput=f_pidoutput+i_P*(f_err_0-f_err_1);
			f_pidoutput=f_pidoutput+i_I*(f_err_1);
			f_pidoutput=f_pidoutput+i_D*(f_err_0-2*f_err_1+f_err_2);

			f_help=f_pidoutput/65;

			// Signalbegrenzung

			if (f_help>1023)	
			{
				f_help=1023; 
			}
		else if (f_help<1)	
			{
				f_help=1; 
			}

			//OCR1A=f_help;

		}

		do							//wartet so lange bis Timer übergelaufen
		{							//springt in Timer 2 Interruptroutine Zeile Zeile 131
		}while(i_abbruch!=0);			

		count++;
	}
	//end mainloop
}
//======================================================================