#define SPI_MASTER                   SPI1
#include "stm32f10x.h" 
#include "LCD.h"
#include "stm32f10x_conf.h"
#define ADC1_DR_Address    ((uint32_t)0x4001244C)
#define ADC2_DR_Address    ((uint32_t)0x40013C4C)

#define BufferSize  32


GPIO_InitTypeDef GPIO_InitStructure;
DMA_InitTypeDef  DMA_InitStructure;
SPI_InitTypeDef  SPI_InitStructure;


uint8_t SPI_MASTER_Buffer[BufferSize] = {0x01, 0x02, 0x03, 0x04, 0x05, 0x06,
                                            0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C,
                                            0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12,
                                            0x13, 0x14, 0x15, 0x16, 0x17, 0x18,
                                            0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E,
                                            0x1F, 0x20};  

uint8_t TxIdx = 0;



int a = 0;
int b	= 0;
int E = 0;
int H = 0;
int T = 0;
int Z = 0;
int Sample[1000];
int i;
int j;
int adcmode = 1;
int ADC1ConvertedValue = 0;
int z;
////////////////////////////////////////////////////////////////////////////////////////////////////////
//------------------------ RCC konfigurieren ---------------------------------------------------------//
////////////////////////////////////////////////////////////////////////////////////////////////////////
																																																			//
										void RCC_konfigurieren(void)																											//
																																																			//
	{																																																		//
																																																			//
		RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);																							//
		RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);																							//
		RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC, ENABLE);																							//
		RCC_APB2PeriphClockCmd(RCC_APB2Periph_ADC1 | RCC_APB2Periph_ADC2 |	RCC_APB2Periph_ADC3, ENABLE);	//
		RCC_AHBPeriphClockCmd (RCC_AHBPeriph_DMA1  , ENABLE);																							//
		RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO | RCC_APB2Periph_SPI1, ENABLE);	
		RCC_ADCCLKConfig(RCC_PCLK2_Div4); 																																//
																																																			//
		/* PCLK2 = HCLK/2 */
		RCC_PCLK2Config(RCC_HCLK_Div2); 
	
	}																																																		//
////////////////////////////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////////////////////////////
//------------------------ GPIO	konfigurieren --------------------------------------------------------//
////////////////////////////////////////////////////////////////////////////////////////////////////////
																																																			//
											void GPIO_konfigurieren(void)																										//
																																																			//
	{ 																																																	//
																																																			//
		GPIO_InitTypeDef GPIO_InitStructure;																															//
																																																			//
//------------------------ LCD-Port konfigurieren ----------------------------------------------------//
		GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10 | GPIO_Pin_11 | GPIO_Pin_12 |														//
																	GPIO_Pin_13 | GPIO_Pin_14 | GPIO_Pin_15;														//
		GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;																									//
		GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;																									//
		GPIO_Init(GPIOB, &GPIO_InitStructure);																														//
																																																			//
		GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6;																													//
		GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;																									//
		GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;																									//
		GPIO_Init(GPIOC, &GPIO_InitStructure);																														//
																																																			//
																																																			//
//------------------------ ADC-Port konfigurieren ----------------------------------------------------//		
		GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0 | GPIO_Pin_1 | GPIO_Pin_2;																//
		GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AIN;																											//
		GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;																									//
		GPIO_Init(GPIOC, &GPIO_InitStructure);																														//
		
		


  /* Configure SPI_MASTER pins: NSS, SCK and MOSI */
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_4 | GPIO_Pin_5 | GPIO_Pin_7 | GPIO_Pin_6;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
  GPIO_Init(GPIOA, &GPIO_InitStructure);
		
		
	}																																																		//
//----------------------------------------------------------------------------------------------------//
////////////////////////////////////////////////////////////////////////////////////////////////////////



////////////////////////////////////////////////////////////////////////////////////	
//------------------------ Warteschleife erstellen -------------------------------//
////////////////////////////////////////////////////////////////////////////////////
																																									//
												void	mwait_ms(int wartezeit)															//
																																									//
	{																																								//
																																									//
		int i;																																				//
		int j;																																				//
		for (i=0; i<wartezeit; i++)																										//
			{																																						//
			for (j=0; j<5000; j++)																											//
				{}																																				//
			}																																						//
																																									//
	}																																								//
//--------------------------------------------------------------------------------//
////////////////////////////////////////////////////////////////////////////////////	

	
////////////////////////////////////////////////////////////////////////////////////
//------------------------ DMA konfigurieren -------------------------------------//
////////////////////////////////////////////////////////////////////////////////////
																																									//
											void DMA_konfigurieren(void)																//
																																									//
		{																																							//	
																																									//
			DMA_InitTypeDef DMA_InitStructure;																					//
																																									//
//--------------------- DMA1 channel1 konfigurieren ------------------------------//
			DMA_DeInit(DMA1_Channel1);																									//
			DMA_InitStructure.DMA_PeripheralBaseAddr = ADC1_DR_Address;									//
			DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t)&ADC1ConvertedValue;				//
			DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralSRC;													//
			DMA_InitStructure.DMA_BufferSize = 1;																				//
			DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;						//
			DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Disable;										//
			DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_HalfWord;	//
			DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_HalfWord;					//
			DMA_InitStructure.DMA_Mode = DMA_Mode_Circular;															//
			DMA_InitStructure.DMA_Priority = DMA_Priority_High;													//
			DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;																//
			DMA_Init(DMA1_Channel1, &DMA_InitStructure);  															//
																																									//
			DMA_Cmd(DMA1_Channel1, ENABLE);										// Enable DMA1 channel1 	//
																																									//	
	}
//--------------------------------------------------------------------------------//
////////////////////////////////////////////////////////////////////////////////////
		
		
		
////////////////////////////////////////////////////////////////////////////////////		
//------------------------ ADC konfigurieren -------------------------------------//
////////////////////////////////////////////////////////////////////////////////////
																																									//
											void ADC_konfigurieren(void)																//
		{																																							//
																																									//
			ADC_InitTypeDef ADC_InitStructure;																					//
																																									//
//------------------------ ADC1 konfigurieren ------------------------------------//
			ADC_InitStructure.ADC_Mode = ADC_Mode_Independent;													//
			ADC_InitStructure.ADC_ScanConvMode = DISABLE;																//
			ADC_InitStructure.ADC_ContinuousConvMode = ENABLE;													//
			ADC_InitStructure.ADC_ExternalTrigConv = ADC_ExternalTrigConv_None;					//
			ADC_InitStructure.ADC_DataAlign = ADC_DataAlign_Right;											//
			ADC_InitStructure.ADC_NbrOfChannel = 1;																			//
			ADC_Init(ADC1, &ADC_InitStructure);																					//
																																									//
			ADC_DMACmd(ADC1, ENABLE);																										//
																																									//
			ADC_Cmd(ADC1, ENABLE);																											// Enable ADC1
			ADC_ResetCalibration(ADC1);																									// Enable ADC1 reset calibration register
			while(ADC_GetResetCalibrationStatus(ADC1));																	// Check the end of ADC1 reset calibration register
			ADC_StartCalibration(ADC1);																									// Start ADC1 calibration
			while(ADC_GetCalibrationStatus(ADC1));																			// Check the end of ADC1 calibration
																																									//
			ADC_SoftwareStartConvCmd(ADC1, ENABLE);																			// Start ADC1 Software Conversion
																																									//
		}																																							//
//--------------------------------------------------------------------------------//
////////////////////////////////////////////////////////////////////////////////////

		
////////////////////////////////////////////////////////////////////////////////////
//---------------------------- Werte Sampelen ------------------------------------//
////////////////////////////////////////////////////////////////////////////////////
																																									//
														void WerteSamplen(void)																//
																																									//
			{																																						//
				for( i = 0; i < 1000; i++)																								//
					{																																				//
						Sample[i]=ADC1ConvertedValue;																					//
																																									//
					}																																				//
				a = 0;																																		//
				for( j = 0; j < 1000; j++)																								//
					{																																				//
						a = a + Sample[j];																										//
					}																																				//
				a = a /1000;																															//
			}																																						//	
//--------------------------------------------------------------------------------//
////////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////////		
			void Zahlausgeben(void)																											//
			{																																						//	
				E = a - ((int) a/10)*10;																									//
				Z = a - ((int) a/100)*100 - E;																						//
				H = a - ((int) a/1000)*1000 - Z - E;																			//
				T = a - H - Z - E;																												//
																																									//
				curserpos(1,0); 																													//
				send_data(0x30+T/1000); //Tausender																				//
				send_data(0x30+H/100); 	//Hunderter																				//
				send_data(0x30+Z/10); 	//Zehner																					//
				send_data(0x30+E); 			//Einer																						//
			}																																						//
//--------------------------------------------------------------------------------//
////////////////////////////////////////////////////////////////////////////////////

					
////////////////////////////////////////////////////////////////////////////////////
																																									//
			void ADCModus ()																														//
			{																																						//
//------------------------ ADC1 verwenden ----------------------------------------//		
			if (adcmode == 1)																														//
			ADC_RegularChannelConfig(ADC1, ADC_Channel_10, 1, ADC_SampleTime_28Cycles5);//
																																									//
																																									//
//------------------------ ADC2 verwenden ----------------------------------------//
			if (adcmode == 2)																														//
			ADC_RegularChannelConfig(ADC1, ADC_Channel_11, 1, ADC_SampleTime_28Cycles5);//
																																									//
																																									//
//------------------------ ADC3 verwenden ----------------------------------------//
			if (adcmode == 3)																														//
			ADC_RegularChannelConfig(ADC1, ADC_Channel_12, 1, ADC_SampleTime_28Cycles5);//
			}																																						//
//--------------------------------------------------------------------------------//
////////////////////////////////////////////////////////////////////////////////////
			
			
			



void SPI_Configuration(void)
{
   /* SPI_MASTER configuration ------------------------------------------------------*/
  SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;//SPI_Direction_2Lines_FullDuplex; //SPI_Direction_1Line_Tx;
  SPI_InitStructure.SPI_Mode = SPI_Mode_Master;
  SPI_InitStructure.SPI_DataSize = SPI_DataSize_16b;
  SPI_InitStructure.SPI_CPOL = SPI_CPOL_High;
  SPI_InitStructure.SPI_CPHA = SPI_CPHA_1Edge;
  SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;
  SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_16;
  SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;
  SPI_InitStructure.SPI_CRCPolynomial = 8;
  SPI_Init(SPI_MASTER, &SPI_InitStructure);   
  
  /* Enable SPI_MASTER NSS output for master mode */
  SPI_SSOutputCmd(SPI_MASTER, ENABLE);
  /* Enable SPI_MASTER */
  SPI_Cmd(SPI_MASTER, ENABLE);  
}


	
			
////////////////////////////////////////////////////////////////////////////////////
/////////////////////// M A I N ////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////
	int main(void) 																																	//
	{																																								//
		RCC_konfigurieren();																													//
		GPIO_konfigurieren();																													//
		DMA_konfigurieren();																													//
		ADC_konfigurieren();																													//
		SPI_Configuration();

////////////////////////////////////////////////////////////////////////////////////
																																									//
		lcd_init_4Bit();																															//
		send_data('V');																																//
		send_data('o');																																//
		send_data('l');																																//
		send_data('t');																																//
		send_data(' ');																																//
		send_data(':');																																//
																																									//
//--------------------------------------------------------------------------------//
////////////////////////////////////////////////////////////////////////////////////
	
				
		
////////////////////////////////////////////////////////////////////////////////////
		while(1)																																			//
		{																																							//
																																									//
			ADCModus ();																																//
			WerteSamplen();																															//
																																									//
			if (a < 1)																																	//
				adcmode = 2;																															//
				ADCModus ();																															//
																																									//
			WerteSamplen();																															//
																																									//
			if (a < 1)																																	//
				adcmode = 1;																															//
				ADCModus ();																															//
																																									//
			WerteSamplen();																															//
			a = (a*3000)/4095;																													//
			Zahlausgeben();																															//
			
			
			
			
			    z = 0;
                 
   
    while (TxIdx < BufferSize)
    {

        while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_BSY) == SET);     
        /* Send SPI_MASTER data */
        SPI_I2S_SendData(SPI_MASTER, SPI_MASTER_Buffer[TxIdx++]);
       

                
        for (z=0; z<= TxIdx; z++)
        {


        }       
    }
			
			
			
			
			
		} 																																						
}	
////////////////////////////////////////////////////////////////////////////////////