/* USER CODE BEGIN Header */
/**
  ******************************************************************************
  * @file           : main.c
  * @brief          : Main program body
  ******************************************************************************
  * @attention
  *
  * Copyright (c) 2022 STMicroelectronics.
  * All rights reserved.
  *
  * This software is licensed under terms that can be found in the LICENSE file
  * in the root directory of this software component.
  * If no LICENSE file comes with this software, it is provided AS-IS.
  *
  ******************************************************************************
  */
/* USER CODE END Header */
/* Includes ------------------------------------------------------------------*/
#include <stdbool.h>
#include "main.h"
#include "crc.h"
#include "dma.h"
#include "tim.h"
#include "gpio.h"

/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */

#include "spi.h"
/* USER CODE END Includes */

/* Private typedef -----------------------------------------------------------*/
/* USER CODE BEGIN PTD */

/* USER CODE END PTD */

/* Private define ------------------------------------------------------------*/
/* USER CODE BEGIN PD */
/* USER CODE END PD */

/* Private macro -------------------------------------------------------------*/
/* USER CODE BEGIN PM */

/* USER CODE END PM */

/* Private variables ---------------------------------------------------------*/

/* USER CODE BEGIN PV */

/* USER CODE END PV */

/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
/* USER CODE BEGIN PFP */

/* USER CODE END PFP */

/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */

bool dirty = true;
//uint16_t mem[12] = {0xFFF, 0xFF, 0xFFF, 0xFF, 0xFFF, 0xFF, 0xFFF, 0xFF, 0xFFF, 0xFF, 0xFFF, 0xFF};
uint16_t mem[12] = {0x300, 0x40, 0x300, 0x40, 0x300, 0x40, 0x300, 0x40, 0x300, 0x40, 0x300, 0x40};

#define BUFFER_SIZE 64
uint16_t RX_Buffer[BUFFER_SIZE] = {0};
uint16_t TX_Buffer[BUFFER_SIZE] = {0};

void HAL_SPI_CpltCallback(SPI_HandleTypeDef *hspi) {

    if(RX_Buffer[0]) {
        union {
            struct {
                unsigned data: 16;
                unsigned addr: 12;
                unsigned op: 4;
            } __attribute__((packed));
            struct {
                uint16_t high;
                uint16_t low;
            } __attribute__((packed));

        } frame = {.low=RX_Buffer[0], .high = RX_Buffer[1]};

        if(frame.op == 0xA && frame.addr <= 16) {
            mem[frame.addr] = frame.data;
            dirty = true;
        }

    }
    HAL_SPI_Receive_DMA(&hspi2, (uint8_t *) RX_Buffer, 4);
}

void HAL_SPI_RxCpltCallback(SPI_HandleTypeDef *hspi) {
    HAL_SPI_CpltCallback(hspi);
}

void HAL_SPI_TxRxCpltCallback(SPI_HandleTypeDef *hspi) {
    HAL_SPI_CpltCallback(hspi);
}

void HAL_SPI_TxCpltCallback(SPI_HandleTypeDef *hspi) {
    //HAL_SPI_Transmit_DMA(&hspi2, (uint8_t *) TX_Buffer, 4);
}

void setDAC(uint8_t channel, uint16_t val) {
    uint16_t frame = (val & 0x0FFF) | (0x7000 & (channel << 12));
    HAL_SPI_Transmit(&hspi1, (uint8_t * ) & frame, 1, 100);
}

/* USER CODE END 0 */


static uint8_t pwm_lookup[] = {0, 1, 2, 3, 10, 11, 12, 20, 21, 32, 32, 42, 42, 52, 52, 61, 61, 70, 70, 79, 79, 88, 88,
                               98, 98, 107, 107, 117, 117, 127, 127, 137, 137, 147, 147, 157, 157, 167, 167, 177, 177,
                               187, 187, 197, 197, 207, 207, 217, 217, 227, 227, 237, 237, 247, 247, 255, 255};

/**
  * @brief  The application entry point.
  * @retval int
  */
int main(void) {
    /* USER CODE BEGIN 1 */

    /* USER CODE END 1 */

    /* MCU Configuration--------------------------------------------------------*/

    /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
    HAL_Init();

    /* USER CODE BEGIN Init */

    /* USER CODE END Init */

    /* Configure the system clock */
    SystemClock_Config();

    /* USER CODE BEGIN SysInit */

    /* USER CODE END SysInit */

    /* Initialize all configured peripherals */
    MX_GPIO_Init();
    MX_CRC_Init();
    MX_TIM1_Init();
    MX_DMA_Init();
    MX_TIM3_Init();
    /* USER CODE BEGIN 2 */
    MX_SPI1_Init();
    MX_SPI2_Init();


    TIM1->ARR = 254;
    TIM1->CCR1 = 10;
    TIM1->CCR2 = 10;
    TIM1->CCR3 = 10;
    TIM1->CCR4 = 10;
    TIM1->CCMR1 = 0x6868;
    TIM1->CCMR2 = 0x6868;
    TIM1->CCER = 0x1111;
    TIM1->EGR |= TIM_EGR_UG;
    TIM1->BDTR |= TIM_BDTR_MOE;
    TIM1->CR1 |= TIM_CR1_CEN;

    TIM3->ARR = 254;
    TIM3->CCR1 = 10;
    TIM3->CCR2 = 10;

    TIM3->CCMR1 = 0x6868;
    TIM3->CCER = 0x1111;
    TIM3->EGR |= TIM_EGR_UG;
    TIM3->BDTR |= TIM_BDTR_MOE;
    TIM3->CR1 |= TIM_CR1_CEN;

    HAL_GPIO_WritePin(SIGNAL_LED_GPIO_Port, SIGNAL_LED_Pin, GPIO_PIN_RESET);

    uint16_t frame = 0b1001000000000000;
    HAL_SPI_Transmit(&hspi1, (uint8_t * ) & frame, 1, 100);

    for (int i = 0; i < 6; ++i) {
        setDAC(i, mem[i * 2]);
    }

    TIM1->CCR1 = 0xFF & mem[1];
    TIM1->CCR2 = 0xFF & mem[3];
    TIM1->CCR3 = 0xFF & mem[5];
    TIM1->CCR4 = 0xFF & mem[7];
    TIM3->CCR1 = 0xFF & mem[9];
    TIM3->CCR2 = 0xFF & mem[11];

    HAL_GPIO_WritePin(SIGNAL_LED_GPIO_Port, SIGNAL_LED_Pin, GPIO_PIN_SET);

    HAL_SPI_Receive_DMA(&hspi2, (uint8_t *) RX_Buffer, 4);

    /* USER CODE END 2 */

    /* Infinite loop */
    /* USER CODE BEGIN WHILE */
    while (1) {
        /* USER CODE END WHILE */

        /* USER CODE BEGIN 3 */

#if 1
        if(dirty) {
            HAL_GPIO_WritePin(SIGNAL_LED_GPIO_Port, SIGNAL_LED_Pin, GPIO_PIN_RESET);
            for (int i = 0; i < 6; ++i) {
                setDAC(i, mem[i * 2]);
            }

            TIM1->CCR1 = 0xFF & mem[1];
            TIM1->CCR2 = 0xFF & mem[3];
            TIM1->CCR3 = 0xFF & mem[5];
            TIM1->CCR4 = 0xFF & mem[7];
            TIM3->CCR1 = 0xFF & mem[9];
            TIM3->CCR2 = 0xFF & mem[11];

            dirty = false;

        }

#else

        setDAC(0, 50 << 4);
        setDAC(1, 50 << 4);
        setDAC(2, 50 << 4);
        setDAC(3, 50 << 4);
        setDAC(4, 50 << 4);
        setDAC(5, 50 << 4);

        HAL_GPIO_WritePin(SIGNAL_LED_GPIO_Port, SIGNAL_LED_Pin, GPIO_PIN_SET);

        for (int i = 0; i < sizeof(pwm_lookup); i++) {
            uint8_t j = pwm_lookup[i];

            TIM1->CCR1 = j;
            TIM1->CCR2 = j;
            TIM1->CCR3 = j;
            TIM1->CCR4 = j;
            TIM3->CCR1 = j;
            TIM3->CCR2 = j;

            HAL_Delay(5);
        }

        TIM1->CCR1 = 256;
        TIM1->CCR2 = 256;
        TIM1->CCR3 = 256;
        TIM1->CCR4 = 256;
        TIM3->CCR1 = 256;
        TIM3->CCR2 = 256;
        for (int i = 50; i < 256; i++) {
            setDAC(0, i << 4);
            setDAC(1, i << 4);
            setDAC(2, i << 4);
            setDAC(3, i << 4);
            setDAC(4, i << 4);
            setDAC(5, i << 4);
            HAL_Delay(5);
        }

        HAL_GPIO_WritePin(SIGNAL_LED_GPIO_Port, SIGNAL_LED_Pin, GPIO_PIN_RESET);

        HAL_Delay(200);

#endif

    }
    /* USER CODE END 3 */
}

/**
  * @brief System Clock Configuration
  * @retval None
  */
void SystemClock_Config(void) {
    RCC_OscInitTypeDef RCC_OscInitStruct = {0};
    RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};

    /** Initializes the RCC Oscillators according to the specified parameters
    * in the RCC_OscInitTypeDef structure.
    */
    RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSI;
    RCC_OscInitStruct.HSIState = RCC_HSI_ON;
    RCC_OscInitStruct.HSICalibrationValue = RCC_HSICALIBRATION_DEFAULT;
    RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
    RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSI;
    RCC_OscInitStruct.PLL.PLLMUL = RCC_PLL_MUL4;
    RCC_OscInitStruct.PLL.PREDIV = RCC_PREDIV_DIV1;
    if(HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK) {
        Error_Handler();
    }
    /** Initializes the CPU, AHB and APB buses clocks
    */
    RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK | RCC_CLOCKTYPE_SYSCLK
                                  | RCC_CLOCKTYPE_PCLK1;
    RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
    RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV16;
    RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1;

    if(HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_0) != HAL_OK) {
        Error_Handler();
    }
}

/* USER CODE BEGIN 4 */

/* USER CODE END 4 */

/**
  * @brief  This function is executed in case of error occurrence.
  * @retval None
  */
void Error_Handler(void) {
    /* USER CODE BEGIN Error_Handler_Debug */
    /* User can add his own implementation to report the HAL error return state */
    __disable_irq();
    while (1) {
    }
    /* USER CODE END Error_Handler_Debug */
}

#ifdef  USE_FULL_ASSERT
/**
  * @brief  Reports the name of the source file and the source line number
  *         where the assert_param error has occurred.
  * @param  file: pointer to the source file name
  * @param  line: assert_param error line source number
  * @retval None
  */
void assert_failed(uint8_t *file, uint32_t line)
{
  /* USER CODE BEGIN 6 */
  /* User can add his own implementation to report the file name and line number,
     ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
  /* USER CODE END 6 */
}
#endif /* USE_FULL_ASSERT */