#include <stdio.h>
#include <stdint.h>
#include <string.h>
#include <stm32c0xx_hal.h>

/* ================== ХЭНДЛЫ ПЕРИФЕРИИ ================== */

UART_HandleTypeDef huart2;
TIM_HandleTypeDef htim3;
ADC_HandleTypeDef hadc1;

/* ================== ОПРЕДЕЛЕНИЯ ПИНОВ ================== */

#define LED1_PORT GPIOA
#define LED1_PIN  GPIO_PIN_4    /* A2 — зелёный  */
#define LED2_PORT GPIOA
#define LED2_PIN  GPIO_PIN_5    /* D13 — жёлтый  */
#define LED3_PORT GPIOA
#define LED3_PIN  GPIO_PIN_6

#define BTN_MOTOR_PORT GPIOA
#define BTN_MOTOR_PIN  GPIO_PIN_1   /* A1 */

#define STEP_PORT  GPIOA
#define STEP1_PIN  GPIO_PIN_9    /* D1 → A+ */
#define STEP2_PIN  GPIO_PIN_10   /* D0 → A- */
#define STEP3_PIN  GPIO_PIN_11   /* D8 → B+ */
#define STEP4_PIN  GPIO_PIN_12   /* D2 → B- */
#define STEP_ALL   (STEP1_PIN | STEP2_PIN | STEP3_PIN | STEP4_PIN)

/* ================== ПРОТОТИПЫ ================== */

void SystemClock_Config(void);
void MX_GPIO_Init(void);
void MX_USART2_UART_Init(void);
void MX_ADC1_Init(void);
void MX_TIM3_PWM_Init(void);
void TIM14_Init(void);
void delay_us(uint16_t us);
void update_leds(uint32_t adc_value);
void stepper_step(void);

/* ================== printf → USART2 ================== */

int _write(int file, uint8_t *ptr, int len) {
  HAL_UART_Transmit(&huart2, ptr, len, HAL_MAX_DELAY);
  return len;
}

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

/* ================== МИКРОСЕКУНДНАЯ ЗАДЕРЖКА (TIM14) ================== */

void TIM14_Init(void) {
  __HAL_RCC_TIM14_CLK_ENABLE();
  TIM14->PSC = 47;
  TIM14->ARR = 0xFFFF;
  TIM14->CR1 |= TIM_CR1_CEN;
}

void delay_us(uint16_t us) {
  TIM14->CNT = 0;
  while (TIM14->CNT < us);
}

/* ================== СВЕТОВАЯ ИНДИКАЦИЯ ================== */

void update_leds(uint32_t adc_value) {
  HAL_GPIO_WritePin(LED1_PORT, LED1_PIN,
    adc_value > 0 ? GPIO_PIN_SET : GPIO_PIN_RESET);
  HAL_GPIO_WritePin(LED2_PORT, LED2_PIN,
    adc_value > 1365 ? GPIO_PIN_SET : GPIO_PIN_RESET);
  HAL_GPIO_WritePin(LED3_PORT, LED3_PIN,
    adc_value > 2730 ? GPIO_PIN_SET : GPIO_PIN_RESET);
}

/* ================== ШАГОВЫЙ ДВИГАТЕЛЬ ================== */

void stepper_step(void) {
  HAL_GPIO_WritePin(STEP_PORT, STEP4_PIN, GPIO_PIN_RESET);
  HAL_GPIO_WritePin(STEP_PORT, STEP1_PIN, GPIO_PIN_SET);
  delay_us(1500);

  HAL_GPIO_WritePin(STEP_PORT, STEP1_PIN, GPIO_PIN_RESET);
  HAL_GPIO_WritePin(STEP_PORT, STEP3_PIN, GPIO_PIN_SET);
  delay_us(1500);

  HAL_GPIO_WritePin(STEP_PORT, STEP3_PIN, GPIO_PIN_RESET);
  HAL_GPIO_WritePin(STEP_PORT, STEP2_PIN, GPIO_PIN_SET);
  delay_us(1500);

  HAL_GPIO_WritePin(STEP_PORT, STEP2_PIN, GPIO_PIN_RESET);
  HAL_GPIO_WritePin(STEP_PORT, STEP4_PIN, GPIO_PIN_SET);
  delay_us(1500);
}

/* ================== ИНИЦИАЛИЗАЦИЯ ================== */

void SystemClock_Config(void) {
  RCC_OscInitTypeDef o = {0};
  RCC_ClkInitTypeDef c = {0};
  o.OscillatorType = RCC_OSCILLATORTYPE_HSI;
  o.HSIState = RCC_HSI_ON;
  o.HSIDiv = RCC_HSI_DIV1;
  o.HSICalibrationValue = RCC_HSICALIBRATION_DEFAULT;
  HAL_RCC_OscConfig(&o);
  c.ClockType = RCC_CLOCKTYPE_HCLK | RCC_CLOCKTYPE_SYSCLK | RCC_CLOCKTYPE_PCLK1;
  c.SYSCLKSource = RCC_SYSCLKSOURCE_HSI;
  c.SYSCLKDivider = RCC_SYSCLK_DIV1;
  c.AHBCLKDivider = RCC_HCLK_DIV1;
  c.APB1CLKDivider = RCC_APB1_DIV1;
  HAL_RCC_ClockConfig(&c, FLASH_LATENCY_1);
}

void MX_GPIO_Init(void) {
  __HAL_RCC_GPIOA_CLK_ENABLE();

  GPIO_InitTypeDef g = {0};

  g.Pin = BTN_MOTOR_PIN;
  g.Mode = GPIO_MODE_INPUT;
  g.Pull = GPIO_PULLUP;
  HAL_GPIO_Init(GPIOA, &g);

  g.Pin = LED1_PIN | LED2_PIN | LED3_PIN;
  g.Mode = GPIO_MODE_OUTPUT_PP;
  g.Pull = GPIO_NOPULL;
  g.Speed = GPIO_SPEED_FREQ_LOW;
  HAL_GPIO_Init(GPIOA, &g);

  g.Pin = STEP_ALL;
  g.Speed = GPIO_SPEED_FREQ_HIGH;
  HAL_GPIO_Init(STEP_PORT, &g);
}

void MX_USART2_UART_Init(void) {
  __HAL_RCC_USART2_CLK_ENABLE();

  GPIO_InitTypeDef g = {0};
  g.Pin = GPIO_PIN_2 | GPIO_PIN_3;
  g.Mode = GPIO_MODE_AF_PP;
  g.Pull = GPIO_NOPULL;
  g.Speed = GPIO_SPEED_FREQ_LOW;
  g.Alternate = GPIO_AF1_USART2;
  HAL_GPIO_Init(GPIOA, &g);

  huart2.Instance = USART2;
  huart2.Init.BaudRate = 9600;
  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_ADC1_Init(void) {
  __HAL_RCC_ADC_CLK_ENABLE();

  GPIO_InitTypeDef g = {0};
  g.Pin = GPIO_PIN_0;
  g.Mode = GPIO_MODE_ANALOG;
  g.Pull = GPIO_NOPULL;
  HAL_GPIO_Init(GPIOA, &g);

  hadc1.Instance = ADC1;
  hadc1.Init.ClockPrescaler = ADC_CLOCK_SYNC_PCLK_DIV2;
  hadc1.Init.Resolution = ADC_RESOLUTION_12B;
  hadc1.Init.DataAlign = ADC_DATAALIGN_RIGHT;
  hadc1.Init.ScanConvMode = ADC_SCAN_DISABLE;
  hadc1.Init.EOCSelection = ADC_EOC_SINGLE_CONV;
  hadc1.Init.ContinuousConvMode = DISABLE;
  hadc1.Init.DiscontinuousConvMode = DISABLE;
  hadc1.Init.Overrun = ADC_OVR_DATA_OVERWRITTEN;
  hadc1.Init.SamplingTimeCommon1 = ADC_SAMPLETIME_79CYCLES_5;
  HAL_ADC_Init(&hadc1);

  ADC1->CHSELR = ADC_CHSELR_CHSEL0;
  HAL_ADCEx_Calibration_Start(&hadc1);
}

TIM_HandleTypeDef htim17;

void MX_TIM17_PWM_Init(void) {
  __HAL_RCC_TIM17_CLK_ENABLE();

  GPIO_InitTypeDef g = {0};
  g.Pin = GPIO_PIN_7;
  g.Mode = GPIO_MODE_AF_PP;
  g.Pull = GPIO_NOPULL;
  g.Speed = GPIO_SPEED_FREQ_HIGH;
  g.Alternate = GPIO_AF5_TIM17;
  HAL_GPIO_Init(GPIOA, &g);

  htim17.Instance = TIM17;
  htim17.Init.Prescaler = 47;
  htim17.Init.CounterMode = TIM_COUNTERMODE_UP;
  htim17.Init.Period = 999;
  htim17.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
  htim17.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_ENABLE;
  htim17.Init.RepetitionCounter = 0;
  HAL_TIM_PWM_Init(&htim17);

  TIM_OC_InitTypeDef oc = {0};
  oc.OCMode = TIM_OCMODE_PWM1;
  oc.Pulse = 0;
  oc.OCPolarity = TIM_OCPOLARITY_HIGH;
  oc.OCFastMode = TIM_OCFAST_DISABLE;
  HAL_TIM_PWM_ConfigChannel(&htim17, &oc, TIM_CHANNEL_1);

  __HAL_TIM_MOE_ENABLE(&htim17);
}

/* ================== MAIN ================== */

int main(void) {
  HAL_Init();
  SystemClock_Config();
  MX_GPIO_Init();
  MX_USART2_UART_Init();
  MX_ADC1_Init();
  MX_TIM17_PWM_Init();
  TIM14_Init();

  HAL_TIM_PWM_Start(&htim17, TIM_CHANNEL_1);

  printf("ADC Monitor Started\r\n");

  uint32_t last_led_time = 0;

  while (1) {
    HAL_ADC_Start(&hadc1);
    uint32_t adc_value = 0;
    if (HAL_ADC_PollForConversion(&hadc1, 100) == HAL_OK) {
      adc_value = HAL_ADC_GetValue(&hadc1);
    }
    HAL_ADC_Stop(&hadc1);

    uint32_t pwm_duty = (adc_value * 100) / 4095;
    __HAL_TIM_SET_COMPARE(&htim17, TIM_CHANNEL_1, (adc_value * 999) / 4095);

    char msg[48];
    snprintf(msg, sizeof(msg), "ADC: %lu, PWM: %lu%%\r\n", adc_value, pwm_duty);
    HAL_UART_Transmit(&huart2, (uint8_t*)msg, strlen(msg), 100);

    uint32_t now = HAL_GetTick();
    if (now - last_led_time >= 100) {
      last_led_time = now;
      update_leds(adc_value);
    }

    if (HAL_GPIO_ReadPin(BTN_MOTOR_PORT, BTN_MOTOR_PIN) == GPIO_PIN_RESET) {
      stepper_step();
    } else {
      HAL_GPIO_WritePin(STEP_PORT, STEP4_PIN, GPIO_PIN_SET);
      HAL_GPIO_WritePin(STEP_PORT, STEP1_PIN | STEP2_PIN | STEP3_PIN, GPIO_PIN_RESET);
    }

    HAL_Delay(200);
  }
}