/* Includes ------------------------------------------------------------------*/
#include "main.h"
#include "wifi_interface.h"
#include "stdio.h"
#include "string.h"
#include "wifi_module.h"
#include <stdlib.h>
#include <errno.h>

#define APPLICATION_DEBUG_MSG            1

uint32_t timerValue;
char strValue[50];
int g_ADCValue;
int g_MeasurementNumber;

/* UART handler declaration */
UART_HandleTypeDef UartHandle;
/* Current seconds value */
char str[100];

void SystemClock_Config(void);
extern UART_HandleTypeDef UartMsgHandle;
extern char print_msg_buff[100000];
/* Private functions ---------------------------------------------------------*/
#define print_uart(arg)    { memset(print_msg_buff, 0x00, sizeof(print_msg_buff)); \
                         sprintf((char*)print_msg_buff,arg);   \
                         HAL_UART_Transmit(&UartMsgHandle, (uint8_t*)print_msg_buff, strlen(print_msg_buff), 100000); }

char console_input[5], console_count = 0;

ADC_HandleTypeDef g_AdcHandle;

void ConfigureADC() {
	GPIO_InitTypeDef gpioInit;

	__GPIOA_CLK_ENABLE()
	;
	__ADC1_CLK_ENABLE()
	;

	gpioInit.Pin = GPIO_PIN_1;
	gpioInit.Mode = GPIO_MODE_ANALOG;
	gpioInit.Pull = GPIO_NOPULL;
	HAL_GPIO_Init(GPIOA, &gpioInit);

	HAL_NVIC_SetPriority(ADC_IRQn, 0, 0);
	HAL_NVIC_EnableIRQ(ADC_IRQn);

	ADC_ChannelConfTypeDef adcChannel;

	g_AdcHandle.Instance = ADC1;

	g_AdcHandle.Init.ClockPrescaler = ADC_CLOCKPRESCALER_PCLK_DIV2;
	g_AdcHandle.Init.Resolution = ADC_RESOLUTION_12B;
	g_AdcHandle.Init.ScanConvMode = DISABLE;
	g_AdcHandle.Init.ContinuousConvMode = ENABLE;
	g_AdcHandle.Init.DiscontinuousConvMode = DISABLE;
	g_AdcHandle.Init.NbrOfDiscConversion = 0;
	g_AdcHandle.Init.ExternalTrigConvEdge = ADC_EXTERNALTRIGCONVEDGE_NONE;
	g_AdcHandle.Init.ExternalTrigConv = ADC_EXTERNALTRIGCONV_T1_CC1;
	g_AdcHandle.Init.DataAlign = ADC_DATAALIGN_RIGHT;
	g_AdcHandle.Init.NbrOfConversion = 1;
	g_AdcHandle.Init.DMAContinuousRequests = ENABLE;
	g_AdcHandle.Init.EOCSelection = DISABLE;

	HAL_ADC_Init(&g_AdcHandle);

	adcChannel.Channel = ADC_CHANNEL_1;
	adcChannel.Rank = 1;
	adcChannel.SamplingTime = ADC_SAMPLETIME_144CYCLES;
	adcChannel.Offset = 0;

	if (HAL_ADC_ConfigChannel(&g_AdcHandle, &adcChannel) != HAL_OK) {
		asm("bkpt 255");
	}
}
DMA_HandleTypeDef g_DmaHandle;
DMA_HandleTypeDef DMA_Uart_Handle;
void ConfigureDMA_ADC() {
	__DMA2_CLK_ENABLE()
	;
	g_DmaHandle.Instance = DMA2_Stream4;

	g_DmaHandle.Init.Channel = DMA_CHANNEL_0;
	g_DmaHandle.Init.Direction = DMA_PERIPH_TO_MEMORY;
	g_DmaHandle.Init.PeriphInc = DMA_PINC_DISABLE;
	g_DmaHandle.Init.MemInc = DMA_MINC_ENABLE;
	g_DmaHandle.Init.PeriphDataAlignment = DMA_PDATAALIGN_WORD;
	g_DmaHandle.Init.MemDataAlignment = DMA_MDATAALIGN_WORD;
	g_DmaHandle.Init.Mode = DMA_CIRCULAR;
	g_DmaHandle.Init.Priority = DMA_PRIORITY_HIGH;
	g_DmaHandle.Init.FIFOMode = DMA_FIFOMODE_DISABLE;
	g_DmaHandle.Init.FIFOThreshold = DMA_FIFO_THRESHOLD_HALFFULL;
	g_DmaHandle.Init.MemBurst = DMA_MBURST_SINGLE;
	g_DmaHandle.Init.PeriphBurst = DMA_PBURST_SINGLE;

	HAL_DMA_Init(&g_DmaHandle);

	__HAL_LINKDMA(&g_AdcHandle, DMA_Handle, g_DmaHandle);

	HAL_NVIC_SetPriority(DMA2_Stream4_IRQn, 0, 0);
	HAL_NVIC_EnableIRQ(DMA2_Stream4_IRQn);
}

TIM_HandleTypeDef TIM_Handle;

uint32_t count = 0;
void TIM4_IRQHandler(void) {

	if (__HAL_TIM_GET_FLAG(&TIM_Handle, TIM_FLAG_UPDATE) != RESET) //In case other interrupts are also running
		if (count == 60000000) {
			printf("%ld\r\n", count);
		}
	{

		if (__HAL_TIM_GET_ITSTATUS(&TIM_Handle, TIM_IT_UPDATE) != RESET) {
			__HAL_TIM_CLEAR_FLAG(&TIM_Handle, TIM_FLAG_UPDATE);
			count = count + 2;

		}
	}

}
int ADC_BUFFER_LENGTH = 2048;
int i;
int sum = 0;
uint32_t g_ADCBuffer[2048];
void HAL_ADC_ConvCpltCallback(ADC_HandleTypeDef* AdcHandle) {
	for (i = 0; i < 2048; ++i) {
		//printf("%ld\r\n", g_ADCBuffer[i]);

	}

	g_MeasurementNumber += ADC_BUFFER_LENGTH;
}
/*void DMA1_Stream6_IRQHandler() {
 HAL_DMA_IRQHandler(UartHandle.hdmatx);

 }*/
void DMA2_Stream4_IRQHandler() {
	HAL_DMA_IRQHandler(&g_DmaHandle);
	//printf("ccc");
}
void DMA1_Stream6_IRQHandler() {
	HAL_DMA_IRQHandler(UartHandle.hdmatx);
	HAL_UART_Transmit_DMA(&UartHandle, (uint8_t*) sum, 10);

}

void ADC_IRQHandler() {
	HAL_ADC_IRQHandler(&g_AdcHandle);
}
void USART_IRQHandler(void) {
	HAL_UART_IRQHandler(&UartHandle);
}
/*void HAL_ADC_ConvCpltCallback(ADC_HandleTypeDef* AdcHandle) {
 g_ADCValue = HAL_ADC_GetValue(AdcHandle);
 if (g_ADCValue < 1500 || g_ADCValue > 2800) {
 printf("%d,%ld\r\n", g_ADCValue, count);
 }
 g_MeasurementNumber++;

 }*/

int main(void) {

	__TIM4_CLK_ENABLE()
	;
	TIM_Handle.Init.Prescaler = 0;
	TIM_Handle.Init.ClockDivision = 0;
	TIM_Handle.Init.CounterMode = TIM_COUNTERMODE_UP;
	TIM_Handle.Init.Period = 31;
	TIM_Handle.Init.RepetitionCounter = 0;
	TIM_Handle.Instance = TIM4;   //Same timer whose clocks we enabled
	HAL_TIM_Base_Init(&TIM_Handle);     // Init timer
	HAL_TIM_Base_Start_IT(&TIM_Handle); // start timer interrupts
	HAL_NVIC_SetPriority(TIM4_IRQn, 0, 1);
	HAL_NVIC_EnableIRQ(TIM4_IRQn);

	HAL_Init();
	ConfigureADC();
	ConfigureDMA_ADC();
	HAL_ADC_Start_DMA(&g_AdcHandle, g_ADCBuffer, ADC_BUFFER_LENGTH);
	//HAL_ADC_Start_IT(&g_AdcHandle);

	if (HAL_UART_Init(&UartHandle) != HAL_OK) {
		/* Initialization Error */
		Error_Handler();
	}

	/* configure the timers  */
	Timer_Config();
	UART_Configuration(115200);
#ifdef USART_PRINT_MSG
	UART_Msg_Gpio_Init();
	USART_PRINT_MSG_Configuration(115200);
#endif

	SystemClock_Config();
	__HAL_TIM_SetCounter(&TIM_Handle, 0);
	//scanf("%s", console_input);
	//console_input[4] = 0;

	//count = *((int *) console_input);

	while (1) {

	}
}
void SystemClock_Config(void) {

	RCC_ClkInitTypeDef RCC_ClkInitStruct;
	RCC_OscInitTypeDef RCC_OscInitStruct;

	RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_LSI
			| RCC_OSCILLATORTYPE_HSE;
	RCC_OscInitStruct.HSEState = RCC_HSE_ON;
	RCC_OscInitStruct.LSIState = RCC_LSI_ON;
	RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
	RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
	RCC_OscInitStruct.PLL.PLLM = 18;
	RCC_OscInitStruct.PLL.PLLN = 302;
	RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV4;
	RCC_OscInitStruct.PLL.PLLQ = 4;
	HAL_RCC_OscConfig(&RCC_OscInitStruct);

	RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_SYSCLK | RCC_CLOCKTYPE_PCLK1;
	RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
	RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV2;
	HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_2);

}