#include "laser_hw.h"
#include "app_state.h"   /* hadc1, hadc3 — нужны для Get_ADC */

/* --- Set_LTEC, MPhD_T, Get_ADC, OUT_trigger из main.c --- */
void OUT_trigger(uint8_t out_n)
{
	switch (out_n)
	{
	case 0:
		HAL_GPIO_WritePin(OUT_0_GPIO_Port, OUT_0_Pin, GPIO_PIN_SET);
		HAL_GPIO_WritePin(OUT_0_GPIO_Port, OUT_0_Pin, GPIO_PIN_RESET);
	break;

	case 1:
		HAL_GPIO_WritePin(OUT_1_GPIO_Port, OUT_1_Pin, GPIO_PIN_SET);
		HAL_GPIO_WritePin(OUT_1_GPIO_Port, OUT_1_Pin, GPIO_PIN_RESET);
	break;

	case 2:
		HAL_GPIO_WritePin(OUT_2_GPIO_Port, OUT_2_Pin, GPIO_PIN_SET);
		HAL_GPIO_WritePin(OUT_2_GPIO_Port, OUT_2_Pin, GPIO_PIN_RESET);
	break;

	case 3:
		HAL_GPIO_WritePin(OUT_3_GPIO_Port, OUT_3_Pin, GPIO_PIN_SET);
		
		HAL_GPIO_WritePin(OUT_3_GPIO_Port, OUT_3_Pin, GPIO_PIN_RESET);
	break;

	case 4:
		HAL_GPIO_WritePin(OUT_4_GPIO_Port, OUT_4_Pin, GPIO_PIN_SET);
		HAL_GPIO_WritePin(OUT_4_GPIO_Port, OUT_4_Pin, GPIO_PIN_RESET);
	break;

	case 5:
		HAL_GPIO_WritePin(OUT_5_GPIO_Port, OUT_5_Pin, GPIO_PIN_SET);
		HAL_GPIO_WritePin(OUT_5_GPIO_Port, OUT_5_Pin, GPIO_PIN_RESET);
	break;

	case 6:
		HAL_GPIO_WritePin(OUT_6_GPIO_Port, OUT_6_Pin, GPIO_PIN_SET);
		HAL_GPIO_WritePin(OUT_6_GPIO_Port, OUT_6_Pin, GPIO_PIN_RESET);
	break;

	case 7:
		HAL_GPIO_WritePin(OUT_7_GPIO_Port, OUT_7_Pin, GPIO_PIN_SET);
		HAL_GPIO_WritePin(OUT_7_GPIO_Port, OUT_7_Pin, GPIO_PIN_RESET);
	break;

	case 8:
		HAL_GPIO_WritePin(OUT_8_GPIO_Port, OUT_8_Pin, GPIO_PIN_SET);
		HAL_GPIO_WritePin(OUT_8_GPIO_Port, OUT_8_Pin, GPIO_PIN_RESET);
	break;

	case 9:
		HAL_GPIO_WritePin(OUT_9_GPIO_Port, OUT_9_Pin, GPIO_PIN_SET);
		HAL_GPIO_WritePin(OUT_9_GPIO_Port, OUT_9_Pin, GPIO_PIN_RESET);
	break;
	}
}

void Set_LTEC(uint8_t num, uint16_t DATA)
{
	uint32_t tmp32;

	switch (num)
	{
		case 1:
			HAL_GPIO_WritePin(DAC_LD1_CS_GPIO_Port, DAC_LD1_CS_Pin, GPIO_PIN_RESET);//Start operation with LDAC1
			//tmp32=0;
			//while(tmp32<500){tmp32++;}
			tmp32 = 0;
			while((!LL_SPI_IsActiveFlag_TXE(SPI2))&&(tmp32<=500)) {tmp32++;}//When trans. last data cycle will be end.
			LL_SPI_TransmitData16(SPI2, DATA);//Transmit word to Laser1 DAC
			tmp32 = 0;
			while((!LL_SPI_IsActiveFlag_RXNE(SPI2))&&(tmp32<=500)) {tmp32++;}//When trans. last data cycle will be end.
			(void) SPI2->DR;
		break;
		case 2:
			//HAL_GPIO_TogglePin(OUT_11_GPIO_Port, OUT_11_Pin); //for debug purposes
			HAL_GPIO_WritePin(DAC_LD2_CS_GPIO_Port, DAC_LD2_CS_Pin, GPIO_PIN_RESET);//Start operation with LDAC2
			//tmp32=0;
			//while(tmp32<500){tmp32++;}
			tmp32 = 0;
			while((!LL_SPI_IsActiveFlag_TXE(SPI6))&&(tmp32<=500)) {tmp32++;}//When trans. last data cycle will be end.
			LL_SPI_TransmitData16(SPI6, DATA);//Transmit word to Laser1 DAC
			tmp32 = 0;
			while((!LL_SPI_IsActiveFlag_RXNE(SPI6))&&(tmp32<=500)) {tmp32++;}//When trans. last data cycle will be end.
			(void) SPI6->DR;
		break;
		case 3:
			HAL_GPIO_WritePin(DAC_TEC1_CS_GPIO_Port, DAC_TEC1_CS_Pin, GPIO_PIN_RESET);//Start operation with TECDAC1
			//tmp32=0;
			//while(tmp32<500){tmp32++;}
			tmp32 = 0;
			while((!LL_SPI_IsActiveFlag_TXE(SPI2))&&(tmp32<=500)) {tmp32++;}//When trans. last data cycle will be end.
			LL_SPI_TransmitData16(SPI2, DATA);//Transmit word to Laser1 DAC
			tmp32 = 0;
			while((!LL_SPI_IsActiveFlag_RXNE(SPI2))&&(tmp32<=500)) {tmp32++;}//When trans. last data cycle will be end.
			(void) SPI2->DR;
		break;
		case 4:
			HAL_GPIO_WritePin(DAC_TEC2_CS_GPIO_Port, DAC_TEC2_CS_Pin, GPIO_PIN_RESET);//Start operation with TECDAC2
			//tmp32=0;
			//while(tmp32<500){tmp32++;}
			tmp32 = 0;
			while((!LL_SPI_IsActiveFlag_TXE(SPI6))&&(tmp32<=500)) {tmp32++;}//When trans. last data cycle will be end.
			LL_SPI_TransmitData16(SPI6, DATA);//Transmit word to Laser1 DAC
			tmp32 = 0;
			while((!LL_SPI_IsActiveFlag_RXNE(SPI6))&&(tmp32<=500)) {tmp32++;}//When trans. last data cycle will be end.
			(void) SPI6->DR;
		break;
	}
	HAL_GPIO_WritePin(DAC_LD1_CS_GPIO_Port, DAC_LD1_CS_Pin, GPIO_PIN_SET);//End operation with LDAC1
	HAL_GPIO_WritePin(DAC_LD2_CS_GPIO_Port, DAC_LD2_CS_Pin, GPIO_PIN_SET);//End operation with LDAC2
	HAL_GPIO_WritePin(DAC_TEC1_CS_GPIO_Port, DAC_TEC1_CS_Pin, GPIO_PIN_SET);//End operation with TEC1
	HAL_GPIO_WritePin(DAC_TEC2_CS_GPIO_Port, DAC_TEC2_CS_Pin, GPIO_PIN_SET);//End operation with TEC2
}
uint16_t MPhD_T(uint8_t num)
{
	uint16_t P;
	uint32_t tmp32;
	HAL_GPIO_WritePin(SPI4_CNV_GPIO_Port, SPI4_CNV_Pin, GPIO_PIN_RESET);//Prepare conversion
	HAL_GPIO_WritePin(SPI5_CNV_GPIO_Port, SPI5_CNV_Pin, GPIO_PIN_RESET);//Prepare conversion
	tmp32=0;
	while(tmp32<500){tmp32++;}
	HAL_GPIO_WritePin(SPI4_CNV_GPIO_Port, SPI4_CNV_Pin, GPIO_PIN_SET);//Stop acqusition & start conversion
	HAL_GPIO_WritePin(SPI5_CNV_GPIO_Port, SPI5_CNV_Pin, GPIO_PIN_SET);//Stop acqusition & start conversion
	tmp32=0;
	while(tmp32<500){tmp32++;}
	if (num==1)//MPD1
	{
		HAL_GPIO_WritePin(ADC_ThrLD1_CS_GPIO_Port, ADC_ThrLD1_CS_Pin, GPIO_PIN_SET);
		HAL_GPIO_WritePin(ADC_MPD1_CS_GPIO_Port, ADC_MPD1_CS_Pin, GPIO_PIN_RESET);
		tmp32=0;
		while(tmp32<500){tmp32++;}
		//LL_SPI_TransmitData16(SPI4, 0xFFFF);//We must to clock the CLK output for collect RX data. We can do that only by transmitting data... 
		LL_SPI_Enable(SPI4);//Enable SPI for MPhD1 ADC
		tmp32 = 0;
		while(((!LL_SPI_IsActiveFlag_RXNE(SPI4))&&(tmp32<=1000))) {tmp32++;}//When rec. last data cycle will be end.
		LL_SPI_Disable(SPI4);//Enable SPI for MPhD1 ADC
		while(tmp32<500){tmp32++;}
		//HAL_SPI_Receive(&hspi4, &P[0], 1, 100);
		HAL_GPIO_WritePin(ADC_MPD1_CS_GPIO_Port, ADC_MPD1_CS_Pin, GPIO_PIN_SET);
		P = LL_SPI_ReceiveData16(SPI4);
	}
	else if (num==2)//MPD2
	{
		HAL_GPIO_WritePin(ADC_ThrLD2_CS_GPIO_Port, ADC_ThrLD2_CS_Pin, GPIO_PIN_SET);
		HAL_GPIO_WritePin(ADC_MPD2_CS_GPIO_Port, ADC_MPD2_CS_Pin, GPIO_PIN_RESET);
		tmp32=0;
		while(tmp32<500){tmp32++;}
		//LL_SPI_TransmitData16(SPI5, 0xFFFF);//We must to clock the CLK output for collect RX data. We can do that only by transmitting data... 
		LL_SPI_Enable(SPI5);//Enable SPI for MPhD2 ADC
		tmp32 = 0;
		while(((!LL_SPI_IsActiveFlag_RXNE(SPI5))&&(tmp32<=1000))) {tmp32++;}//When rec. last data cycle will be end.
		LL_SPI_Disable(SPI5);//Enable SPI for MPhD2 ADC
		while(tmp32<500){tmp32++;}
		//HAL_SPI_Receive(&hspi4, &P[0], 1, 100);
		HAL_GPIO_WritePin(ADC_MPD2_CS_GPIO_Port, ADC_MPD2_CS_Pin, GPIO_PIN_SET);
		P = LL_SPI_ReceiveData16(SPI5);
	}
	else if (num==3)//ThrLD1
	{
		HAL_GPIO_WritePin(ADC_MPD1_CS_GPIO_Port, ADC_MPD1_CS_Pin, GPIO_PIN_SET);
		HAL_GPIO_WritePin(ADC_ThrLD1_CS_GPIO_Port, ADC_ThrLD1_CS_Pin, GPIO_PIN_RESET);
		tmp32=0;
		while(tmp32<500){tmp32++;}
		//LL_SPI_TransmitData16(SPI4, 0xFFFF);//We must to clock the CLK output for collect RX data. We can do that only by transmitting data... 
		LL_SPI_Enable(SPI4);//Enable SPI for ThrLD1 ADC
		tmp32 = 0;
		while(((!LL_SPI_IsActiveFlag_RXNE(SPI4))&&(tmp32<=1000))) {tmp32++;}//When rec. last data cycle will be end.
		LL_SPI_Disable(SPI4);//Enable SPI for ThrLD1 ADC
		while(tmp32<500){tmp32++;}
		//HAL_SPI_Receive(&hspi4, &P[0], 1, 100);
		HAL_GPIO_WritePin(ADC_ThrLD1_CS_GPIO_Port, ADC_ThrLD1_CS_Pin, GPIO_PIN_SET);
		P = LL_SPI_ReceiveData16(SPI4);
	}
	else if (num==4)//ThrLD2
	{
		HAL_GPIO_WritePin(ADC_MPD2_CS_GPIO_Port, ADC_MPD2_CS_Pin, GPIO_PIN_SET);
		HAL_GPIO_WritePin(ADC_ThrLD2_CS_GPIO_Port, ADC_ThrLD2_CS_Pin, GPIO_PIN_RESET);
		tmp32=0;
		while(tmp32<500){tmp32++;}
		//LL_SPI_TransmitData16(SPI5, 0xFFFF);//We must to clock the CLK output for collect RX data. We can do that only by transmitting data... 
		LL_SPI_Enable(SPI5);//Enable SPI for ThrLD2 ADC
		tmp32 = 0;
		while(((!LL_SPI_IsActiveFlag_RXNE(SPI5))&&(tmp32<=1000))) {tmp32++;}//When rec. last data cycle will be end.
		LL_SPI_Disable(SPI5);//Enable SPI for ThrLD2 ADC
		while(tmp32<500){tmp32++;}
		//HAL_SPI_Receive(&hspi4, &P[0], 1, 100);
		HAL_GPIO_WritePin(ADC_ThrLD2_CS_GPIO_Port, ADC_ThrLD2_CS_Pin, GPIO_PIN_SET);
		P = LL_SPI_ReceiveData16(SPI5);
	}
	/*float I_LD, Ith, I0m, T0m, Inorm, Tnorm1, Tnorm2, P, T_C, A, Pnorm;
	
	Inorm = (float) (65535) / (float) (100);
	Tnorm1 = (float) (65535) / (float) (50);
	Tnorm2 = 4;
	Pnorm = (float)(65535) / (float)(20);
	I0m = 8.1568;//@4 C - lowest temperature of system
	T0m = 48.6282;
	T_C = (float) (T_LD) / Tnorm1 + Tnorm2;
	
	Ith = I0m * expf(T_C/T0m);
	I_LD = (float) (C_LD) / Inorm;
	
	if (I_LD > Ith)
	{
		A = (float) (2.24276128270098e-07) * T_C * T_C * T_C  - (float) (4.73392579025590e-05) * T_C * T_C + (float) (0.00157250618257057) * T_C + (float) (0.228565407377466);
		P = A * (I_LD - Ith) * Pnorm;
	}
	else
	{
		P = 0;
	}	*/
	return P;
}
/*static uint16_t Temp_LD(uint16_t T_LD_before, uint16_t T_LD, uint32_t Timer_before, uint32_t Timer)
{
	uint16_t Result;
//	uint8_t randf;
	
	randf = 0;
	for (uint8_t i = 0; i < 32; i++)
	{
		randf = ((Timer>>i)&0x0001)^randf;
	}
	
	Result = ((float)(T_LD - T_LD_before))*((float)(1-expf(((float)(Timer_before)-(float)(Timer))/((float)(100))))) + T_LD_before + (float)(randf);
	
	return (uint16_t)(Result);
}*/
uint16_t Get_ADC(uint8_t num)
{
	uint16_t OUT;
	switch (num)
		{
			case 0:
				HAL_ADC_Start(&hadc1); // Power on
			break;
			case 1:
				HAL_ADC_PollForConversion(&hadc1, 100); // Waiting for conversion
        OUT = HAL_ADC_GetValue(&hadc1); // Get value adc
			break;
			case 2:
				HAL_ADC_Stop(&hadc1); // Power off
			break;
			case 3:
				HAL_ADC_Start(&hadc3); // Power on
			break;
			case 4:
				HAL_ADC_PollForConversion(&hadc3, 100); // Waiting for conversion
        OUT = HAL_ADC_GetValue(&hadc3); // Get value adc
			break;
			case 5:
        HAL_ADC_Stop(&hadc3); // Power off
			break;
		}
	return OUT;
}