//-------------------------------------------------------------------------
// 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 : 
// Programmer: 
// Port : 
//-------------------------------------------------------------------------
#define F_CPU 3686400 //14745600 //
#include <avr\io.h>
#include <stdio.h>			
#include <stdlib.h>			
#include <avr\interrupt.h>
#include <string.h>

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

#define aus		PORTB=0b00000000;

#define Zelle1  	PORTB=0b00010000;
#define Zelle2  	PORTB=0b00110000;
#define Zelle3  	PORTB=0b00011000;
#define Zelle4  	PORTB=0b00111000;
#define Zelle5  	PORTB=0b00010100;
#define Zelle6  	PORTB=0b00110100;
#define Zelle7  	PORTB=0b00011100;
#define Zelle8  	PORTB=0b00111100;

#define Zelle9  	PORTB=0b00000010;
#define Zelle10  	PORTB=0b00100010;
#define Zelle11  	PORTB=0b00001010;
#define Zelle12  	PORTB=0b00101010;
#define Zelle13  	PORTB=0b00000110;
#define Zelle14  	PORTB=0b00100110;
#define Zelle15  	PORTB=0b00001110;
#define Zelle16  	PORTB=0b00101110;

#define Zelle17 	PORTB=0b00000001;
#define Zelle18 	PORTB=0b00100001;
#define Zelle19 	PORTB=0b00001001;
#define Zelle20		PORTB=0b00101001;
#define Zelle21 	PORTB=0b00000101;
#define Zelle22 	PORTB=0b00100101;
#define Zelle23 	PORTB=0b00001101;
#define Zelle24 	PORTB=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;					//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#

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

	// UART initialisieren
	UBRRL  = 1;         	//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;
	ADCSRA=(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;
}
//----------------------------------------------------------------------

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: Zelle1;
		break;

		case 2: Zelle2;
		break;

		case 3: Zelle3;
		break;

		case 4: Zelle4;
		break;

		case 5: Zelle5;
		break;

		case 6: Zelle6;
		break;

		case 7: Zelle7;
		break;

		case 8: Zelle8;
		break;

		case 9: Zelle9;
		break;

		case 10: Zelle10;
		break;

		case 11: Zelle11;
		break;

		case 12: Zelle12;
		break;

		case 13: Zelle13;
		break;

		case 14: Zelle14;
		break;

		case 15: Zelle15;
		break;

		case 16: Zelle16;
		break;

		case 17: Zelle17;
		break;

		case 18: Zelle18;
		break;

		case 19: Zelle19;
		break;

		case 20: Zelle20;
		break;

		case 21: Zelle21;
		break;

		case 22: Zelle22;
		break;

		case 23: Zelle23;
		break;

		case 24: Zelle24;
		break;

		default: aus;
		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;

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

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

	{

		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
		}

		result=spannung();

		i_zellspannungen[count]=result;

		itoa(count,c_buffer,10);
		print(c_buffer);
		putChar(' ');	
		print("<< Zellzahl Zellspannung >>");
		putChar(' ');
		itoa(i_zellspannungen[count],c_buffer,10);
		print(c_buffer);
		putChar(' ');

		if (count==24)	//Regle erst nachdem alle Zellen getastet sind
		{
		i_temp=getChar();	//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;
		}

		//----------------------------------------------------------------------	
		/*print("Set");
		itoa(i_pidsetpoint,c_buffer,10);
		print(c_buffer);
		putChar(' ');*/

		for (i_index=0;i_index<25;i_index++)
		{
			/*itoa(i_zellspannungen[i_index],c_buffer,10);	<<<<<<<<<<<<<<<<<<
			print(c_buffer);
			putChar(' ');*/
			if (i_zellspannungen[i_index]<i_volt_setpoint)
			{

				i_low_volt=i_zellspannungen[i_index];

				/*print("Zelle");					//Ausgabe der Zelle mit der geringsten Spannung
				itoa(i_low_volt,c_buffer,10);
				print(c_buffer);
				putChar(' ');*/
			}
		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);

		/*print("Sense");
		itoa(i_pidsense,c_buffer,10);
		print(c_buffer);
		putChar(' ');*/

		// 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);
		/*print("Out");
		itoa(f_pidoutput,c_buffer,10);
		print(c_buffer);
		putChar(' ');*/

		f_help=f_pidoutput/65;

		// Signalbegrenzung

		if (f_help>1023)	
		{
			f_help=1023; 
		}
	else if (f_help<1)	
		{
			f_help=1; 
		}
		/*	print("Help");
		itoa(f_help,c_buffer,10);
		print(c_buffer);
		putChar(' ');*/
		OCR1A=f_help;

		
		}

		count++;

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

	}
	//end mainloop
}
//======================================================================