#include "main.h"

UART_HandleTypeDef huart2;
TIM_HandleTypeDef htim1;
GPIO_TypeDef* oneWire_PORT;

float TempC, Humidity;
char uartData[50];
uint16_t oneWire_PIN;
uint8_t oneWirePin_Idx;

int main(void)
{
  HAL_Init();
  SystemClock_Config();
  MX_GPIO_Init();
  MX_USART2_UART_Init();
  MX_TIM1_Init();
  HAL_TIM_Base_Start(&htim1);
  DHT22_Init(GPIOA, GPIO_PIN_9);
  while (1)
  {
    if (DHT22_GetTemp_Humidity(&TempC, &Humidity) == 1)
    {
      sprintf(uartData, "\r\nTemp (C) =\t %.1f\r\nHumidity (%%) =\t %.1f%%\r\n", TempC, Humidity);
      HAL_UART_Transmit(&huart2, (uint8_t *)uartData, strlen(uartData), 10);
    }
    else
    {
      sprintf(uartData, "\r\nCRC Error!\r\n");
      HAL_UART_Transmit(&huart2, (uint8_t *)uartData, strlen(uartData), 10);
    }
    HAL_GPIO_TogglePin(GPIOC, GPIO_PIN_13);

    HAL_Delay(1000);

  }
}

void SystemClock_Config(void)
{
  RCC_OscInitTypeDef RCC_OscInitStruct = {0};
  RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};
  RCC_PeriphCLKInitTypeDef PeriphClkInit = {0};

  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE | RCC_OSCILLATORTYPE_LSI;
  RCC_OscInitStruct.HSEState = RCC_HSE_ON;
  RCC_OscInitStruct.LSIState = RCC_LSI_ON;
  RCC_OscInitStruct.HSEPredivValue = RCC_HSE_PREDIV_DIV1;
  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
  RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
  RCC_OscInitStruct.PLL.PLLMUL = RCC_PLL_MUL9;
  if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
  {
    Error_Handler();
  }
  RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK | RCC_CLOCKTYPE_SYSCLK | RCC_CLOCKTYPE_PCLK1 | RCC_CLOCKTYPE_PCLK2;
  RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
  RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
  RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV2;
  RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;

  if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_2) != HAL_OK)
  {
    Error_Handler();
  }
  PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_RTC | RCC_PERIPHCLK_ADC;
  PeriphClkInit.RTCClockSelection = RCC_RTCCLKSOURCE_LSI;
  PeriphClkInit.AdcClockSelection = RCC_ADCPCLK2_DIV6;
  if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInit) != HAL_OK)
  {
    Error_Handler();
  }
}

void SysTick_Handler(void)
{
  HAL_IncTick();
}

void MX_USART2_UART_Init(void) {
  __HAL_RCC_USART2_CLK_ENABLE();
  huart2.Instance = USART2;
  huart2.Init.BaudRate = 115200;
  huart2.Init.WordLength = UART_WORDLENGTH_8B;
  huart2.Init.StopBits = UART_STOPBITS_1;
  huart2.Init.Parity = UART_PARITY_NONE;
  huart2.Init.Mode = UART_MODE_TX_RX;
  huart2.Init.HwFlowCtl = UART_HWCONTROL_NONE;
  huart2.Init.OverSampling = UART_OVERSAMPLING_16;
  HAL_UART_Init(&huart2);
}

void MX_GPIO_Init(void)
{

  GPIO_InitTypeDef GPIO_InitStruct;

  __HAL_RCC_GPIOC_CLK_ENABLE();
  __HAL_RCC_GPIOA_CLK_ENABLE();
  __HAL_RCC_GPIOB_CLK_ENABLE();

  GPIO_InitStruct.Pin = GPIO_PIN_13;
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);


}

void MX_TIM1_Init(void)
{
  __TIM1_CLK_ENABLE();

  TIM_ClockConfigTypeDef sClockSourceConfig = {0};
  TIM_MasterConfigTypeDef sMasterConfig = {0};

  htim1.Instance = TIM1;
  htim1.Init.Prescaler = 71;
  htim1.Init.CounterMode = TIM_COUNTERMODE_UP;
  htim1.Init.Period = 65534;
  htim1.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
  htim1.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
  if (HAL_TIM_Base_Init(&htim1) != HAL_OK)
  {
    Error_Handler();
  }

  sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;
  if (HAL_TIM_ConfigClockSource(&htim1, &sClockSourceConfig) != HAL_OK)
  {
    Error_Handler();
  }
  sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
  sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
  if (HAL_TIMEx_MasterConfigSynchronization(&htim1, &sMasterConfig) != HAL_OK)
  {
    Error_Handler();
  }
}

void delay_us (uint16_t us)
{
  __HAL_TIM_SET_COUNTER(&htim1, 0);
  while ((uint16_t)__HAL_TIM_GET_COUNTER(&htim1) < us);
}

void DHT22_Init(GPIO_TypeDef* DataPort, uint16_t DataPin)
{
  oneWire_PORT = DataPort;
  oneWire_PIN = DataPin;
  for (uint8_t i = 0; i < 16; i++)
  {
    if (DataPin & (1 << i))
    {
      oneWirePin_Idx = i;
      break;
    }
  }
}

void ONE_WIRE_PinMode(OnePinMode_Typedef mode)
{
  GPIO_InitTypeDef GPIO_InitStruct;
  GPIO_InitStruct.Pin = oneWire_PIN;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  GPIO_InitStruct.Pull = GPIO_NOPULL;

  if (mode == ONE_OUTPUT)
  {
    GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  }
  else if (mode == ONE_INPUT)
  {
    GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
  }
  HAL_GPIO_Init(oneWire_PORT, &GPIO_InitStruct);
}

void ONE_WIRE_Pin_Write(bool state)
{
  if (state) HAL_GPIO_WritePin(oneWire_PORT, oneWire_PIN, GPIO_PIN_SET);
  else HAL_GPIO_WritePin(oneWire_PORT, oneWire_PIN, GPIO_PIN_RESET);
}

bool ONE_WIRE_Pin_Read(void)
{
  return (1 & HAL_GPIO_ReadPin(oneWire_PORT, oneWire_PIN));
}

void DHT22_StartAcquisition(void)
{
  ONE_WIRE_PinMode(ONE_OUTPUT);
  ONE_WIRE_Pin_Write(0);
  delay_us(500);
  ONE_WIRE_Pin_Write(1);
  delay_us(30);
  ONE_WIRE_PinMode(ONE_INPUT);
}

void DHT22_ReadRaw(uint8_t *data)
{
  uint32_t rawBits = 0UL;
  uint8_t checksumBits = 0;

  delay_us(40);
  while (!ONE_WIRE_Pin_Read());
  while (ONE_WIRE_Pin_Read());
  for (int8_t i = 31; i >= 0; i--)
  {
    while (!ONE_WIRE_Pin_Read());
    delay_us(40);
    if (ONE_WIRE_Pin_Read())
    {
      rawBits |= (1UL << i);
    }
    while (ONE_WIRE_Pin_Read());
  }

  for (int8_t i = 7; i >= 0; i--)
  {
    while (!ONE_WIRE_Pin_Read());
    delay_us(40);
    if (ONE_WIRE_Pin_Read())
    {
      checksumBits |= (1UL << i);
    }
    while (ONE_WIRE_Pin_Read());
  }

  data[0] = (rawBits >> 24) & 0xFF;
  data[1] = (rawBits >> 16) & 0xFF;
  data[2] = (rawBits >> 8) & 0xFF;
  data[3] = (rawBits >> 0) & 0xFF;
  data[4] = (checksumBits) & 0xFF;
}

bool DHT22_GetTemp_Humidity(float *Temp, float *Humidity)
{
  uint8_t dataArray[6], myChecksum;
  uint16_t Temp16, Humid16;
  DHT22_StartAcquisition();
  DHT22_ReadRaw(dataArray);
  myChecksum = 0;
  for (uint8_t k = 0; k < 4; k++)
  {
    myChecksum += dataArray[k];
  }
  if (myChecksum == dataArray[4])
  {
    Temp16 = (dataArray[2] << 8) | dataArray[3];
    Humid16 = (dataArray[0] << 8) | dataArray[1];
    *Temp = Temp16 / 10.0f;
    *Humidity = Humid16 / 10.0f;
    return 1;
  }
  return 0;
}

void Error_Handler()
{
  while (1)
  {
  }
}