433 lines
11 KiB
C
433 lines
11 KiB
C
/* 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 */
|
|
|