/* 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 "main.h"
#include "crc.h"
#include "dma.h"
#include "tim.h"
#include "gpio.h"

/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */
#include <stdbool.h>
#include "spi.h"
#include "stm32f0xx_ll_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 */


const uint16_t version = 42;

bool toggle = false;
uint16_t counter = 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};
uint16_t mem[12] = {0xFFF, 0xFF, 0xFFF, 0xFF, 0xFFF, 0xFF, 0xFFF, 0xFF, 0xFFF, 0xFF, 0xFFF, 0xFF};

uint16_t conf[8] = {version, 0, 0, 0, 0, 0, 0, 0};

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

void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin) {
    if(GPIO_Pin == SPI_INT_Pin) {
        hspi2.Instance->CR1 |= SPI_CR1_SSI;
        HAL_GPIO_WritePin(INIT_OUT_GPIO_Port, INIT_OUT_Pin, GPIO_PIN_SET);
        for (volatile int i = 0; i < 3; i++);
        hspi2.Instance->CR1 &= ~SPI_CR1_SSI;
        HAL_GPIO_WritePin(INIT_OUT_GPIO_Port, INIT_OUT_Pin, GPIO_PIN_RESET);
    }
}

typedef union {
    struct {
        unsigned dat: 12;
        unsigned addr: 4;
    } __attribute__((packed));
    uint16_t _;
} cc48x6_frame;

typedef enum {
    CMD_NONE = 0,
    CMD_READ = 1,
    CMD_WRITE = 2,
    CMD_INIT = 3,
    CMD_RESET = 4,
    CMD_VERSION = 5,
    CMD_CONFIG = 6,
    CMD_PING = 7
} bus_cmd;

typedef union {
    struct {
        unsigned dat: 16;
        unsigned addr: 8;
        unsigned cmd: 8;
    } __attribute__((packed));
    uint32_t _;
} request_frame;

typedef union {
    struct {
        unsigned dat: 16;
        unsigned addr: 8;
        unsigned flags: 7;
        unsigned: 1;
    } __attribute__((packed));
    uint32_t _;
} reply_frame;

uint8_t addr = 0;

void HAL_SPI_CpltCallback(SPI_HandleTypeDef *hspi) {

    request_frame req = {._ = ((uint32_t) RX_Buffer[0]) << 16 | (uint32_t) RX_Buffer[1]};
    reply_frame rep = {._ = 0};

    if(addr == 0) {
        bool init = HAL_GPIO_ReadPin(INIT_IN_GPIO_Port, INIT_IN_Pin);
        if(init && req.cmd == CMD_INIT) {
            addr = req.addr;
        } else if(init) {
            rep.flags = 5;
        } else {
            rep.flags = 7;
        }
    } else if(addr == req.addr) {
        if(req.cmd == CMD_PING){
            rep.dat = req.dat;
        }else {
            cc48x6_frame frame = {._=req.dat};

            counter++;

            toggle = !toggle;
            if(toggle) {
                HAL_GPIO_WritePin(SIGNAL_LED_GPIO_Port, SIGNAL_LED_Pin, GPIO_PIN_SET);
            } else {
                HAL_GPIO_WritePin(SIGNAL_LED_GPIO_Port, SIGNAL_LED_Pin, GPIO_PIN_RESET);
            }

            if(frame.addr <= 6 && frame.addr >= 1) {
                frame.addr--;
                if(frame.dat > 0x300) {
                    mem[frame.addr * 2 + 1] = 0xFF;
                    mem[frame.addr * 2] = frame.dat;
                } else {
                    mem[frame.addr * 2 + 1] = (frame.dat * 0xFF) / 0x300;
                    mem[frame.addr * 2] = 0x300;
                }

                dirty = true;
                rep.dat = req.dat;

            } else if(frame.addr == 15 && frame.dat < 8) {
                TX_Buffer[0] = conf[frame.dat];
            }
        }


    }

    TX_Buffer[0] = rep._ >> 16;
    TX_Buffer[1] = rep._ & 0xFFFF;

    HAL_SPI_TransmitReceive_DMA(&hspi2, TX_Buffer, RX_Buffer, 2);

    HAL_GPIO_WritePin(INIT_OUT_GPIO_Port, INIT_OUT_Pin, GPIO_PIN_SET);
    for (volatile int i = 0; i < 3; i++);
    HAL_GPIO_WritePin(INIT_OUT_GPIO_Port, INIT_OUT_Pin, GPIO_PIN_RESET);

}

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, 2);
}

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 */

/**
  * @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, 2);





    /* USER CODE END 2 */

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

        /* USER CODE BEGIN 3 */


#if 1
        //if(dirty) {
        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_MUL12;
    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_DIV1;
    RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1;

    if(HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_1) != 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 */