//##############################################################################################################################################################
//BF set registers for ADC reading with correction values and value count
void Hardware::PREPARE_READADC(unsigned char correct1, unsigned char correct2, unsigned char correct3, unsigned char correct4, unsigned int count)
{
	return;
    asm("
            MOV		%r3, %i0
            MOV		%r4, %i1
            MOV		%r5, %i2
            MOV		%r6, %i3
            MOV		%r7, %i4
        ");
}
//##############################################################################################################################################################
//BF sort, correct and recalculate ADC-values
//BF changed by Stefan to avoid correction error in inverting and averaging mode
void Hardware::READADC_ALL(unsigned char which, unsigned char *DataArray1, unsigned char inverse, unsigned int zero, unsigned char averageval, unsigned char highspeed)
{
	unsigned long mask = 0xFEFEFEFE;  	//set MASK (but never use it???)
	unsigned int lw_count;			//number of longwords to work on, should be a parameter
	unsigned long *chan_addr;		//input-buffer			
	unsigned int loop, i;			//control
	unsigned char byte_data; 		//byte to work on
 	unsigned char temp_byte;		
	unsigned char correct[4];		//channeldependend correctionvalues
	unsigned int mem_offset[4];		//adc's addressoffset, timebase dependend
	unsigned char inc_dataarray;		//pointer's increment, depends on highspeed
	int temp_int;	
	
	// this was done bei PREPARE_READADC (now obsolete): load the channel's correctionvalues
	for (i = 0; i < 4; i++) correct[i] = ADC_Offset[(which - 1)][i];
	
	mem_offset[0] = 0;
	if (highspeed == 1) // timebase < 7
	{
		lw_count = 4096;
		mem_offset[1] = 1; mem_offset[2] = 2; mem_offset[3] = 3;
		inc_dataarray = 4;
	}
	else // timebase >= 7 
	{
		lw_count = 4096;
		mem_offset[1] = 4096; mem_offset[2] = 8192; mem_offset[3] = 12288;
		inc_dataarray = 1;	
	}
		
	chan_addr = ((unsigned long*)(0x00917440)); //channel_address = readout_sigbuf, READADC_ALL2 filled this buffer		
	for (loop = 0; loop < lw_count; loop++)		
	{			
		for (i = 0; i < 4; i++) // do the calculations for all 4 adcs
		{								
			byte_data = *(chan_addr + i);		//load one byte
			byte_data = ~byte_data;			//invert bitwise			
			if (byte_data > correct[i]) byte_data -= correct[i];	//offsetadjustment (stefan put it here)
			else byte_data = 0;		
			if (inverse == 1)
			{			
				temp_int = (zero << 1) - byte_data;
				if (temp_int < 0) temp_int = 0;		//limit to byte
				else if (temp_int > 255) temp_int = 255;	
				byte_data = temp_int;				
			}
			if (averageval != 0) //then start averaging
			{
				temp_byte = *(DataArray1 + mem_offset[i]);		//load old value as byte
				temp_int = temp_byte + ((byte_data - temp_byte)	>> averageval);
				if (temp_int < 0) temp_int = 0;		//limit to byte ???
				else if (temp_int > 255) temp_int = 255;	
				byte_data = temp_int;	
			}	
			*(DataArray1 + mem_offset[i]) = byte_data;	//store result			
		}
		DataArray1 += inc_dataarray;	
		chan_addr++;	
	}	
}

//#######################################################################################################
//BF -> get data from ADC
void Hardware::READADC_ALL2(unsigned char which, unsigned long *DataArray1, unsigned int count)
{
	unsigned long *source;
	unsigned int i;
		
	switch (which)
	{
		case  	1:
			source = ((unsigned long*)(0x00A00000)); 	//load address channel 1
			break;
			
		case	2:
			source = ((unsigned long*)( 0x00A00010));	//load address channel 2
			break;
			
		case	3:
			source = ((unsigned long*)(0x00A00020));	//load address channel 3
			break;
			
		case	4:
			source = ((unsigned long*)(0x00A00030)); 	//load address channel 4
			break;
	}	
	for (i = 0; i < count; i++)
	{
		DataArray1[i] = *source;		
	}
}

unsigned char Hardware::EXTRACTADCVAL(unsigned char which, unsigned long value)			
{
	unsigned long *temp;
	unsigned char res;
	
	*temp = value;	
	res = temp[(unsigned char)(4 - which)];
	return res;
}