FlintyLemming/PLFM_RADAR
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
eb8e063f37a5bf5a52817fd63368412964ec0f4f
PLFM_RADAR/14_RADAR_Old_version/Firmware/Microcontroller/main.cpp
T
NawfalMotii79 b17e29e810 Add files via upload
2026-03-19 01:21:46 +00:00

907 lines
34 KiB
C++
Raw Blame History

/* USER CODE BEGIN Header */
/**
******************************************************************************
* @file : main.c
* @brief : Main program body
******************************************************************************
* @attention
*
* Copyright (c) 2025 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"
/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */
#include "si5351.h"
#include "parameters.h"
#include "adf4382.h"
#include "adar1000.h"
#include "hardware_config.h"
#include "no_os_delay.h"
#include "no_os_alloc.h"
#include "no_os_print_log.h"
#include "no_os_error.h"
#include "no_os_units.h"
#include "no_os_dma.h"
#include "no_os_spi.h"
#include "no_os_uart.h"
#include "no_os_util.h"
#include <stdint.h>
#include <errno.h>
#include <math.h>
#include <stdio.h>
#include <string.h>
#include <inttypes.h>
#include <iostream>
#include <vector>
/* USER CODE END Includes */
/* Private typedef -----------------------------------------------------------*/
/* USER CODE BEGIN PTD */
#define debug_uart 1
#define BUFFER_SIZE 16 //ADAR
#define Delay_scan 1 //Delay between each TX,RX scan// 1 corresponds to 15.6 ns// check delay_15ns() function
#define Delay_scan_rx 1 //Delay between each TX,RX scan// 1 corresponds to 15.6 ns// check delay_15ns() function
Si5351 si5351;
////////////////////////////////////////////////////////////////////////////////
///////////////////////////////ADF4382//////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
struct no_os_uart_init_param adf4382_uart_ip = {
.device_id = UART_DEVICE_ID,
.irq_id = UART_IRQ_ID,
.asynchronous_rx = true,
.baud_rate = UART_BAUDRATE,
.size = NO_OS_UART_CS_8,
.parity = NO_OS_UART_PAR_NO,
.stop = NO_OS_UART_STOP_1_BIT,
.platform_ops = UART_OPS,
.extra = UART_EXTRA,
};
struct no_os_spi_init_param adf4382_spi_ip = {
.device_id = SPI_DEVICE_ID,
.max_speed_hz = 4000000,
.chip_select = SPI_CS,
.mode = NO_OS_SPI_MODE_0,
.bit_order = NO_OS_SPI_BIT_ORDER_MSB_FIRST,
.platform_ops = SPI_OPS,
.extra = SPI_EXTRA,
};
struct adf4382_init_param adf4382_ip = {
.spi_init = &adf4382_spi_ip,
.spi_3wire_en = false,
.cmos_3v3 = false,
.ref_freq_hz = 100000000,
.freq = 10500000000ULL,
.ref_doubler_en = 1,
.ref_div = 1,
.cp_i = 15,
.bleed_word = 4903,
.ld_count = 10,
.id = ID_ADF4382A,
};
struct adf4382_dev *adf4382_device = NULL; // Pointer to device
////////////////////////////////////////////////////////////////////////////////
//////////////////////////////ADAR1000//////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
uint8_t txBuffer[BUFFER_SIZE] = {0xA1, 0xB2, 0xC3, 0xD4}; // Example data
uint8_t rxBuffer1[BUFFER_SIZE] = {0}; // Receive buffer
uint8_t rxBuffer2[BUFFER_SIZE] = {0}; // Receive buffer
uint8_t rxBuffer3[BUFFER_SIZE] = {0}; // Receive buffer
uint8_t rxBuffer4[BUFFER_SIZE] = {0}; // Receive buffer
uint32_t SpiTransferFunction(uint8_t *p_txData, uint8_t *p_rxData, uint32_t size) {
HAL_GPIO_WritePin(GPIO_ADAR, CS_ADAR_1, GPIO_PIN_RESET);
HAL_GPIO_WritePin(GPIO_ADAR, CS_ADAR_2, GPIO_PIN_RESET);
HAL_GPIO_WritePin(GPIO_ADAR, CS_ADAR_3, GPIO_PIN_RESET);
HAL_GPIO_WritePin(GPIO_ADAR, CS_ADAR_4, GPIO_PIN_RESET);
HAL_StatusTypeDef status = HAL_SPI_TransmitReceive(&hspi1, p_txData, p_rxData, size, HAL_MAX_DELAY);
HAL_GPIO_WritePin(GPIO_ADAR, CS_ADAR_1, GPIO_PIN_SET);
HAL_GPIO_WritePin(GPIO_ADAR, CS_ADAR_2, GPIO_PIN_SET);
HAL_GPIO_WritePin(GPIO_ADAR, CS_ADAR_3, GPIO_PIN_SET);
HAL_GPIO_WritePin(GPIO_ADAR, CS_ADAR_4, GPIO_PIN_SET);
return (status == HAL_OK) ? 0 : 1; // Return 0 on success, 1 on failure
}
/// Generic ADAR device that contains a hardware address, SPI transfer function
/// and a pointer to a buffer to receive data into.
// Define the ADAR1000 device instance
const AdarDevice ADAR1 = {
.dev_addr = 0x00, // Example hardware address
.Transfer = SpiTransferFunction, // Assign SPI function pointer
.p_rx_buffer = rxBuffer1 // Assign receive buffer
};
const AdarDevice ADAR2 = {
.dev_addr = 0x01, // Example hardware address
.Transfer = SpiTransferFunction, // Assign SPI function pointer
.p_rx_buffer = rxBuffer2 // Assign receive buffer
};
const AdarDevice ADAR3 = {
.dev_addr = 0x10, // Example hardware address
.Transfer = SpiTransferFunction, // Assign SPI function pointer
.p_rx_buffer = rxBuffer3 // Assign receive buffer
};
const AdarDevice ADAR4 = {
.dev_addr = 0x11, // Example hardware address
.Transfer = SpiTransferFunction, // Assign SPI function pointer
.p_rx_buffer = rxBuffer4 // Assign receive buffer
};
AdarBiasCurrents ADAR_BC ={ //bias current
.rx_lna = 8, ///< nominal: 8, low power: 5
.rx_vm = 5, ///< nominal: 5, low power: 2
.rx_vga = 10, ///< nominal: 10, low power: 3
.tx_vm = 5, ///< nominal: 5, low power: 2
.tx_vga = 5, ///< nominal: 5, low power: 5
.tx_drv = 6 ///< nominal: 6, low power: 3
};
/* 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 ---------------------------------------------------------*/
I2C_HandleTypeDef hi2c1;
SPI_HandleTypeDef hspi1;
TIM_HandleTypeDef htim1;
UART_HandleTypeDef huart2;
/* USER CODE BEGIN PV */
/* USER CODE END PV */
/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_I2C1_Init(void);
static void MX_SPI1_Init(void);
static void MX_TIM1_Init(void);
static void MX_USART2_UART_Init(void);
/* USER CODE BEGIN PFP */
void delay_15ns(volatile long unsigned int ns){
__HAL_TIM_SET_COUNTER(&htim1,0); // set the counter value a
while (__HAL_TIM_GET_COUNTER(&htim1) < ns); // //Clock TIMx -> AHB/APB1 is set to 64MHz/presc+1 presc = 0
//delay_15ns(1) would perform a delay of 15.6ns
}
/* USER CODE END PFP */
/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */
/* 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_I2C1_Init();
MX_SPI1_Init();
MX_TIM1_Init();
MX_USART2_UART_Init();
/* USER CODE BEGIN 2 */
HAL_TIM_Base_Start(&htim1);
//////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////Votage Enable////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////
//3.3V to ADAR should be set before -5V
HAL_GPIO_WritePin(GPIO_VR, EN_32, GPIO_PIN_SET);//active high
HAL_GPIO_WritePin(GPIO_VR, EN_42, GPIO_PIN_SET);//active High
//////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////SI5351///////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////
si5351.init(SI5351_CRYSTAL_LOAD_8PF, 0, 0);
HAL_GPIO_WritePin(GPIO_si5351, SI5351_CLK_EN, GPIO_PIN_RESET);//active low
HAL_GPIO_WritePin(GPIO_si5351, SI5351_SS_EN, GPIO_PIN_SET);//active High (Spread Spectrum)
//each unity on set_freq(unityULL, SI5351_CLK4) represents 0.01Hz
si5351.set_freq(10000000000ULL, SI5351_CLK4);//set FPGA main clock to 100MHz
si5351.set_freq(10000000000ULL, SI5351_CLK6);//ADF4382 clock
si5351.update_status();
HAL_Delay(500);
if(debug_uart)
{ //When the synthesizers are locked and the Si5351 is working correctly, you'll see an output similar to this one (the REVID may be different):
//SYS_INIT: 0 LOL_A: 0 LOL_B: 0 LOS: 0 REVID: 3
char buffer[10];
HAL_UART_Transmit(&huart2, (uint8_t*)"PLLA: " , strlen("PLLA: ") , 10);
HAL_UART_Transmit(&huart2, (uint8_t*)buffer, sprintf(buffer, "%llu", si5351.plla_freq/100), 10);
HAL_UART_Transmit(&huart2, (uint8_t*)" PLLB: " , strlen(" PLLB: ") , 10);
HAL_UART_Transmit(&huart2, (uint8_t*)buffer, sprintf(buffer, "%llu", si5351.pllb_freq/100), 10);
HAL_UART_Transmit(&huart2, (uint8_t*)" SYS_INIT: " , strlen(" SYS_INIT: ") , 10);
HAL_UART_Transmit(&huart2, (uint8_t*)buffer, sprintf(buffer, "%u", si5351.dev_status.SYS_INIT), 10);
HAL_UART_Transmit(&huart2, (uint8_t*)" LOL_A: " , strlen(" LOL_A: ") , 10);
HAL_UART_Transmit(&huart2, (uint8_t*)buffer, sprintf(buffer, "%u", si5351.dev_status.LOL_A), 10);
HAL_UART_Transmit(&huart2, (uint8_t*)" LOL_B: " , strlen(" LOL_B ") , 10);
HAL_UART_Transmit(&huart2, (uint8_t*)buffer, sprintf(buffer, "%u", si5351.dev_status.LOL_B), 10);
HAL_UART_Transmit(&huart2, (uint8_t*)" LOS: " , strlen(" LOS: ") , 10);
HAL_UART_Transmit(&huart2, (uint8_t*)buffer, sprintf(buffer, "%u", si5351.dev_status.LOS), 10);
HAL_UART_Transmit(&huart2, (uint8_t*)" REVID: " , strlen(" REVID: ") , 10);
HAL_UART_Transmit(&huart2, (uint8_t*)buffer, sprintf(buffer, "%u", si5351.dev_status.REVID), 10);
HAL_UART_Transmit(&huart2, (uint8_t*)"\r\n" , strlen("\r\n" ) , 10);
}
//////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////ADF4382//////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////
int status = adf4382_init(&adf4382_device ,&adf4382_ip);
if (status != 0) {
// Handle initialization error
}
status = adf4382_set_freq(adf4382_device);
if (status != 0) {
// Handle frequency setting error
}
adf4382_set_en_chan(adf4382_device, 0, true);
adf4382_set_en_chan(adf4382_device, 1, true);
HAL_GPIO_WritePin(GPIO_ADF, ADF_CE, GPIO_PIN_SET);//active High
//HAL_GPIO_WritePin(GPIO_ADF, ADF_DELSTR, GPIO_PIN_SET);
//HAL_GPIO_WritePin(GPIO_ADF, ADF_DELADJ, GPIO_PIN_SET);
//////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////LTC5552 Mixers///////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////
HAL_GPIO_WritePin(GPIO_DIG, DIG_2, GPIO_PIN_SET); //Enable RX Mixer
HAL_GPIO_WritePin(GPIO_DIG, DIG_3, GPIO_PIN_SET); //Enable TX Mixer
//////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////ADAR1000/////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////
//phase_step = 0 => phase = 0°
//phase_step = 127 => phase = 360°
//steering angle (rad)= arcsin(phase_dif/Pi)
uint8_t matrix1[22][16];
uint8_t vector_0[16]={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
uint8_t matrix2[22][16];
for(int j=0; j<15;j++){
for(int i=0; i<21;i++){
matrix1[i][j]=(2*(i+1)*(15-j))%127;
matrix2[i][j]=matrix1[i][15-j];
i++;
}
j++;
}
Adar_AdcInit(&ADAR1, BROADCAST_OFF);//init. ADC
Adar_AdcInit(&ADAR2, BROADCAST_OFF);//init. ADC
Adar_AdcInit(&ADAR3, BROADCAST_OFF);//init. ADC
Adar_AdcInit(&ADAR4, BROADCAST_OFF);//init. ADC
uint8_t Temp1 = Adar_AdcRead(&ADAR1,BROADCAST_OFF);//Read ADC from single ADAR
uint8_t Temp2 = Adar_AdcRead(&ADAR2,BROADCAST_OFF);
uint8_t Temp3 = Adar_AdcRead(&ADAR3,BROADCAST_OFF);
uint8_t Temp4 = Adar_AdcRead(&ADAR4,BROADCAST_OFF);
if(debug_uart){
char buffer[10];
HAL_UART_Transmit(&huart2, (uint8_t*)"Temp1: " , strlen("Temp1: ") , 10);
HAL_UART_Transmit(&huart2, (uint8_t*)buffer, sprintf(buffer, "%u", Temp1), 10);
HAL_UART_Transmit(&huart2, (uint8_t*)" Temp2: " , strlen(" Temp2: ") , 10);
HAL_UART_Transmit(&huart2, (uint8_t*)buffer, sprintf(buffer, "%u", Temp2), 10);
HAL_UART_Transmit(&huart2, (uint8_t*)" Temp3: " , strlen(" Temp3: ") , 10);
HAL_UART_Transmit(&huart2, (uint8_t*)buffer, sprintf(buffer, "%u", Temp3), 10);
HAL_UART_Transmit(&huart2, (uint8_t*)" Temp4: " , strlen(" Temp4: ") , 10);
HAL_UART_Transmit(&huart2, (uint8_t*)buffer, sprintf(buffer, "%u", Temp4), 10);
HAL_UART_Transmit(&huart2, (uint8_t*)"\r\n" , strlen("\r\n" ) , 10);
}
Adar_SetBiasCurrents(&ADAR1,&ADAR_BC,BROADCAST_OFF);
Adar_SetBiasCurrents(&ADAR2,&ADAR_BC,BROADCAST_OFF);
Adar_SetBiasCurrents(&ADAR3,&ADAR_BC,BROADCAST_OFF);
Adar_SetBiasCurrents(&ADAR4,&ADAR_BC,BROADCAST_OFF);
uint8_t bias_on_voltage [5] = {0x39, 0x39, 0x39, 0x39, 0x00};//V_PA = -1.1V; V_LNA = 0V
uint8_t bias_off_voltage [5] = {0x85, 0x85, 0x85, 0x85, 0x68};//V_PA = -2.5V; V_LNA = -2V
HAL_GPIO_WritePin(GPIO_DIG, DIG_0, GPIO_PIN_RESET);//reset TR pin on FPGA for RX mode
Adar_SetBiasVoltages(&ADAR1, bias_on_voltage, bias_off_voltage);
Adar_SetBiasVoltages(&ADAR2, bias_on_voltage, bias_off_voltage);
Adar_SetBiasVoltages(&ADAR3, bias_on_voltage, bias_off_voltage);
Adar_SetBiasVoltages(&ADAR4, bias_on_voltage, bias_off_voltage);
Adar_SetRxVgaGain(&ADAR1, 1, 16, BROADCAST_OFF);//16dB is the max
Adar_SetRxVgaGain(&ADAR1, 2, 16, BROADCAST_OFF);
Adar_SetRxVgaGain(&ADAR1, 3, 16, BROADCAST_OFF);
Adar_SetRxVgaGain(&ADAR1, 4, 16, BROADCAST_OFF);
Adar_SetRxVgaGain(&ADAR2, 1, 16, BROADCAST_OFF);//16dB is the max
Adar_SetRxVgaGain(&ADAR2, 2, 16, BROADCAST_OFF);
Adar_SetRxVgaGain(&ADAR2, 3, 16, BROADCAST_OFF);
Adar_SetRxVgaGain(&ADAR2, 4, 16, BROADCAST_OFF);
Adar_SetRxVgaGain(&ADAR3, 1, 16, BROADCAST_OFF);//16dB is the max
Adar_SetRxVgaGain(&ADAR3, 2, 16, BROADCAST_OFF);
Adar_SetRxVgaGain(&ADAR3, 3, 16, BROADCAST_OFF);
Adar_SetRxVgaGain(&ADAR3, 4, 16, BROADCAST_OFF);
Adar_SetRxVgaGain(&ADAR4, 1, 16, BROADCAST_OFF);//16dB is the max
Adar_SetRxVgaGain(&ADAR4, 2, 16, BROADCAST_OFF);
Adar_SetRxVgaGain(&ADAR4, 3, 16, BROADCAST_OFF);
Adar_SetRxVgaGain(&ADAR4, 4, 16, BROADCAST_OFF);
Adar_SetTxBias(&ADAR1, BROADCAST_OFF);//set to nominal...check adar1000.c
Adar_SetTxBias(&ADAR2, BROADCAST_OFF);
Adar_SetTxBias(&ADAR3, BROADCAST_OFF);
Adar_SetTxBias(&ADAR4, BROADCAST_OFF);
Adar_SetTxVgaGain(&ADAR1, 1, 0x7D, BROADCAST_OFF);//0xFF = max
Adar_SetTxVgaGain(&ADAR1, 2, 0x7D, BROADCAST_OFF);
Adar_SetTxVgaGain(&ADAR1, 3, 0x7D, BROADCAST_OFF);
Adar_SetTxVgaGain(&ADAR1, 4, 0x7D, BROADCAST_OFF);
Adar_SetTxVgaGain(&ADAR2, 1, 0x7D, BROADCAST_OFF);//0xFF = max
Adar_SetTxVgaGain(&ADAR2, 2, 0x7D, BROADCAST_OFF);
Adar_SetTxVgaGain(&ADAR2, 3, 0x7D, BROADCAST_OFF);
Adar_SetTxVgaGain(&ADAR2, 4, 0x7D, BROADCAST_OFF);
Adar_SetTxVgaGain(&ADAR3, 1, 0x7D, BROADCAST_OFF);//0xFF = max
Adar_SetTxVgaGain(&ADAR3, 2, 0x7D, BROADCAST_OFF);
Adar_SetTxVgaGain(&ADAR3, 3, 0x7D, BROADCAST_OFF);
Adar_SetTxVgaGain(&ADAR3, 4, 0x7D, BROADCAST_OFF);
Adar_SetTxVgaGain(&ADAR4, 1, 0x7D, BROADCAST_OFF);//0xFF = max
Adar_SetTxVgaGain(&ADAR4, 2, 0x7D, BROADCAST_OFF);
Adar_SetTxVgaGain(&ADAR4, 3, 0x7D, BROADCAST_OFF);
Adar_SetTxVgaGain(&ADAR4, 4, 0x7D, BROADCAST_OFF);
/* USER CODE END 2 */
/* Infinite loop */
/* USER CODE BEGIN WHILE */
while (1)
{
//////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////ADAR1000/////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////
//phase_step = 0 => phase = 0°
//phase_step = 127 => phase = 360°
//steering angle (rad)= arcsin(phase_dif/Pi)
HAL_GPIO_WritePin(GPIO_DIG, DIG_1, GPIO_PIN_SET); // Send to FPGA_FT2232HQ start frame from ADC Matrix
HAL_Delay(1);
HAL_GPIO_WritePin(GPIO_DIG, DIG_1, GPIO_PIN_RESET); // Send to FPGA_FT2232HQ start frame from ADC Matrix
for(int i = 0; i<21; i++){
Adar_SetTxPhase(&ADAR1,1 ,matrix1[i][0] , BROADCAST_OFF);
Adar_SetTxPhase(&ADAR1,2 ,matrix1[i][1] , BROADCAST_OFF);
Adar_SetTxPhase(&ADAR1,3 ,matrix1[i][2] , BROADCAST_OFF);
Adar_SetTxPhase(&ADAR1,4 ,matrix1[i][3] , BROADCAST_OFF);
Adar_SetTxPhase(&ADAR2,1 ,matrix1[i][4] , BROADCAST_OFF);
Adar_SetTxPhase(&ADAR2,2 ,matrix1[i][5] , BROADCAST_OFF);
Adar_SetTxPhase(&ADAR2,3 ,matrix1[i][6] , BROADCAST_OFF);
Adar_SetTxPhase(&ADAR2,4 ,matrix1[i][7] , BROADCAST_OFF);
Adar_SetTxPhase(&ADAR3,1 ,matrix1[i][8] , BROADCAST_OFF);
Adar_SetTxPhase(&ADAR3,2 ,matrix1[i][9] , BROADCAST_OFF);
Adar_SetTxPhase(&ADAR3,3 ,matrix1[i][10] , BROADCAST_OFF);
Adar_SetTxPhase(&ADAR3,4 ,matrix1[i][11] , BROADCAST_OFF);
Adar_SetTxPhase(&ADAR4,1 ,matrix1[i][12] , BROADCAST_OFF);
Adar_SetTxPhase(&ADAR4,2 ,matrix1[i][13] , BROADCAST_OFF);
Adar_SetTxPhase(&ADAR4,3 ,matrix1[i][14] , BROADCAST_OFF);
Adar_SetTxPhase(&ADAR4,4 ,matrix1[i][15] , BROADCAST_OFF);
HAL_GPIO_WritePin(GPIO_DIG, DIG_0, GPIO_PIN_SET);//set TR pin on FPGA for TX mode
HAL_GPIO_TogglePin(GPIO_LED, LED_1);
delay_15ns(Delay_scan);
Adar_SetRxPhase(&ADAR1,1 ,matrix1[i][0] , BROADCAST_OFF);
Adar_SetRxPhase(&ADAR1,2 ,matrix1[i][1] , BROADCAST_OFF);
Adar_SetRxPhase(&ADAR1,3 ,matrix1[i][2] , BROADCAST_OFF);
Adar_SetRxPhase(&ADAR1,4 ,matrix1[i][3] , BROADCAST_OFF);
Adar_SetRxPhase(&ADAR2,1 ,matrix1[i][4] , BROADCAST_OFF);
Adar_SetRxPhase(&ADAR2,2 ,matrix1[i][5] , BROADCAST_OFF);
Adar_SetRxPhase(&ADAR2,3 ,matrix1[i][6] , BROADCAST_OFF);
Adar_SetRxPhase(&ADAR2,4 ,matrix1[i][7] , BROADCAST_OFF);
Adar_SetRxPhase(&ADAR3,1 ,matrix1[i][8] , BROADCAST_OFF);
Adar_SetRxPhase(&ADAR3,2 ,matrix1[i][9] , BROADCAST_OFF);
Adar_SetRxPhase(&ADAR3,3 ,matrix1[i][10] , BROADCAST_OFF);
Adar_SetRxPhase(&ADAR3,4 ,matrix1[i][11] , BROADCAST_OFF);
Adar_SetRxPhase(&ADAR4,1 ,matrix1[i][12] , BROADCAST_OFF);
Adar_SetRxPhase(&ADAR4,2 ,matrix1[i][13] , BROADCAST_OFF);
Adar_SetRxPhase(&ADAR4,3 ,matrix1[i][14] , BROADCAST_OFF);
Adar_SetRxPhase(&ADAR4,4 ,matrix1[i][15] , BROADCAST_OFF);
HAL_GPIO_WritePin(GPIO_DIG, DIG_0, GPIO_PIN_RESET);//reset TR pin on FPGA for RX mode
HAL_GPIO_TogglePin(GPIO_LED, LED_2);
delay_15ns(Delay_scan_rx);
}
for(int i = 0; i<15; i++){
Adar_SetTxPhase(&ADAR1,1 ,vector_0[0] , BROADCAST_OFF);
Adar_SetTxPhase(&ADAR1,2 ,vector_0[1] , BROADCAST_OFF);
Adar_SetTxPhase(&ADAR1,3 ,vector_0[2] , BROADCAST_OFF);
Adar_SetTxPhase(&ADAR1,4 ,vector_0[3] , BROADCAST_OFF);
Adar_SetTxPhase(&ADAR2,1 ,vector_0[4] , BROADCAST_OFF);
Adar_SetTxPhase(&ADAR2,2 ,vector_0[5] , BROADCAST_OFF);
Adar_SetTxPhase(&ADAR2,3 ,vector_0[6] , BROADCAST_OFF);
Adar_SetTxPhase(&ADAR2,4 ,vector_0[7] , BROADCAST_OFF);
Adar_SetTxPhase(&ADAR3,1 ,vector_0[8] , BROADCAST_OFF);
Adar_SetTxPhase(&ADAR3,2 ,vector_0[9] , BROADCAST_OFF);
Adar_SetTxPhase(&ADAR3,3 ,vector_0[10] , BROADCAST_OFF);
Adar_SetTxPhase(&ADAR3,4 ,vector_0[11] , BROADCAST_OFF);
Adar_SetTxPhase(&ADAR4,1 ,vector_0[12] , BROADCAST_OFF);
Adar_SetTxPhase(&ADAR4,2 ,vector_0[13] , BROADCAST_OFF);
Adar_SetTxPhase(&ADAR4,3 ,vector_0[14] , BROADCAST_OFF);
Adar_SetTxPhase(&ADAR4,4 ,vector_0[15] , BROADCAST_OFF);
HAL_GPIO_WritePin(GPIO_DIG, DIG_0, GPIO_PIN_SET);//set TR pin on FPGA for TX mode
HAL_GPIO_TogglePin(GPIO_LED, LED_1);
delay_15ns(Delay_scan);
Adar_SetRxPhase(&ADAR1,1 ,vector_0[0] , BROADCAST_OFF);
Adar_SetRxPhase(&ADAR1,2 ,vector_0[1] , BROADCAST_OFF);
Adar_SetRxPhase(&ADAR1,3 ,vector_0[2] , BROADCAST_OFF);
Adar_SetRxPhase(&ADAR1,4 ,vector_0[3] , BROADCAST_OFF);
Adar_SetRxPhase(&ADAR2,1 ,vector_0[4] , BROADCAST_OFF);
Adar_SetRxPhase(&ADAR2,2 ,vector_0[5] , BROADCAST_OFF);
Adar_SetRxPhase(&ADAR2,3 ,vector_0[6] , BROADCAST_OFF);
Adar_SetRxPhase(&ADAR2,4 ,vector_0[7] , BROADCAST_OFF);
Adar_SetRxPhase(&ADAR3,1 ,vector_0[8] , BROADCAST_OFF);
Adar_SetRxPhase(&ADAR3,2 ,vector_0[9] , BROADCAST_OFF);
Adar_SetRxPhase(&ADAR3,3 ,vector_0[10] , BROADCAST_OFF);
Adar_SetRxPhase(&ADAR3,4 ,vector_0[11] , BROADCAST_OFF);
Adar_SetRxPhase(&ADAR4,1 ,vector_0[12] , BROADCAST_OFF);
Adar_SetRxPhase(&ADAR4,2 ,vector_0[13] , BROADCAST_OFF);
Adar_SetRxPhase(&ADAR4,3 ,vector_0[14] , BROADCAST_OFF);
Adar_SetRxPhase(&ADAR4,4 ,vector_0[15] , BROADCAST_OFF);
HAL_GPIO_WritePin(GPIO_DIG, DIG_0, GPIO_PIN_RESET);//reset TR pin on FPGA for RX mode
HAL_GPIO_TogglePin(GPIO_LED, LED_2);
delay_15ns(Delay_scan_rx);
}
for(int i = 0; i<21; i++){
Adar_SetTxPhase(&ADAR1,1 ,matrix2[i][0] , BROADCAST_OFF);
Adar_SetTxPhase(&ADAR1,2 ,matrix2[i][1] , BROADCAST_OFF);
Adar_SetTxPhase(&ADAR1,3 ,matrix2[i][2] , BROADCAST_OFF);
Adar_SetTxPhase(&ADAR1,4 ,matrix2[i][3] , BROADCAST_OFF);
Adar_SetTxPhase(&ADAR2,1 ,matrix2[i][4] , BROADCAST_OFF);
Adar_SetTxPhase(&ADAR2,2 ,matrix2[i][5] , BROADCAST_OFF);
Adar_SetTxPhase(&ADAR2,3 ,matrix2[i][6] , BROADCAST_OFF);
Adar_SetTxPhase(&ADAR2,4 ,matrix2[i][7] , BROADCAST_OFF);
Adar_SetTxPhase(&ADAR3,1 ,matrix2[i][8] , BROADCAST_OFF);
Adar_SetTxPhase(&ADAR3,2 ,matrix2[i][9] , BROADCAST_OFF);
Adar_SetTxPhase(&ADAR3,3 ,matrix2[i][10] , BROADCAST_OFF);
Adar_SetTxPhase(&ADAR3,4 ,matrix2[i][11] , BROADCAST_OFF);
Adar_SetTxPhase(&ADAR4,1 ,matrix2[i][12] , BROADCAST_OFF);
Adar_SetTxPhase(&ADAR4,2 ,matrix2[i][13] , BROADCAST_OFF);
Adar_SetTxPhase(&ADAR4,3 ,matrix2[i][14] , BROADCAST_OFF);
Adar_SetTxPhase(&ADAR4,4 ,matrix2[i][15] , BROADCAST_OFF);
HAL_GPIO_WritePin(GPIO_DIG, DIG_0, GPIO_PIN_SET);//set TR pin on FPGA for TX mode
HAL_GPIO_TogglePin(GPIO_LED, LED_1);
delay_15ns(Delay_scan);
Adar_SetRxPhase(&ADAR1,1 ,matrix2[i][0] , BROADCAST_OFF);
Adar_SetRxPhase(&ADAR1,2 ,matrix2[i][1] , BROADCAST_OFF);
Adar_SetRxPhase(&ADAR1,3 ,matrix2[i][2] , BROADCAST_OFF);
Adar_SetRxPhase(&ADAR1,4 ,matrix2[i][3] , BROADCAST_OFF);
Adar_SetRxPhase(&ADAR2,1 ,matrix2[i][4] , BROADCAST_OFF);
Adar_SetRxPhase(&ADAR2,2 ,matrix2[i][5] , BROADCAST_OFF);
Adar_SetRxPhase(&ADAR2,3 ,matrix2[i][6] , BROADCAST_OFF);
Adar_SetRxPhase(&ADAR2,4 ,matrix2[i][7] , BROADCAST_OFF);
Adar_SetRxPhase(&ADAR3,1 ,matrix2[i][8] , BROADCAST_OFF);
Adar_SetRxPhase(&ADAR3,2 ,matrix2[i][9] , BROADCAST_OFF);
Adar_SetRxPhase(&ADAR3,3 ,matrix2[i][10] , BROADCAST_OFF);
Adar_SetRxPhase(&ADAR3,4 ,matrix2[i][11] , BROADCAST_OFF);
Adar_SetRxPhase(&ADAR4,1 ,matrix2[i][12] , BROADCAST_OFF);
Adar_SetRxPhase(&ADAR4,2 ,matrix2[i][13] , BROADCAST_OFF);
Adar_SetRxPhase(&ADAR4,3 ,matrix2[i][14] , BROADCAST_OFF);
Adar_SetRxPhase(&ADAR4,4 ,matrix2[i][15] , BROADCAST_OFF);
HAL_GPIO_WritePin(GPIO_DIG, DIG_0, GPIO_PIN_RESET);//reset TR pin on FPGA for RX mode
HAL_GPIO_TogglePin(GPIO_LED, LED_2);
delay_15ns(Delay_scan_rx);
}
//Send commands to the auxilliary board to set motor position and get GPS data
/* USER CODE END WHILE */
/* USER CODE BEGIN 3 */
}
/* USER CODE END 3 */
}
/**
* @brief System Clock Configuration
* @retval None
*/
void SystemClock_Config(void)
{
RCC_OscInitTypeDef RCC_OscInitStruct = {0};
RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};
/** Configure LSE Drive Capability
*/
HAL_PWR_EnableBkUpAccess();
/** Configure the main internal regulator output voltage
*/
__HAL_RCC_PWR_CLK_ENABLE();
__HAL_PWR_VOLTAGESCALING_CONFIG(PWR_REGULATOR_VOLTAGE_SCALE3);
/** Initializes the RCC Oscillators according to the specified parameters
* in the RCC_OscInitTypeDef structure.
*/
RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
RCC_OscInitStruct.HSEState = RCC_HSE_ON;
RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
RCC_OscInitStruct.PLL.PLLM = 4;
RCC_OscInitStruct.PLL.PLLN = 64;
RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV2;
RCC_OscInitStruct.PLL.PLLQ = 2;
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_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();
}
}
/**
* @brief I2C1 Initialization Function
* @param None
* @retval None
*/
static void MX_I2C1_Init(void)
{
/* USER CODE BEGIN I2C1_Init 0 */
/* USER CODE END I2C1_Init 0 */
/* USER CODE BEGIN I2C1_Init 1 */
/* USER CODE END I2C1_Init 1 */
hi2c1.Instance = I2C1;
hi2c1.Init.Timing = 0x00707CBB;
hi2c1.Init.OwnAddress1 = 0;
hi2c1.Init.AddressingMode = I2C_ADDRESSINGMODE_7BIT;
hi2c1.Init.DualAddressMode = I2C_DUALADDRESS_DISABLE;
hi2c1.Init.OwnAddress2 = 0;
hi2c1.Init.OwnAddress2Masks = I2C_OA2_NOMASK;
hi2c1.Init.GeneralCallMode = I2C_GENERALCALL_DISABLE;
hi2c1.Init.NoStretchMode = I2C_NOSTRETCH_DISABLE;
if (HAL_I2C_Init(&hi2c1) != HAL_OK)
{
Error_Handler();
}
/** Configure Analogue filter
*/
if (HAL_I2CEx_ConfigAnalogFilter(&hi2c1, I2C_ANALOGFILTER_ENABLE) != HAL_OK)
{
Error_Handler();
}
/** Configure Digital filter
*/
if (HAL_I2CEx_ConfigDigitalFilter(&hi2c1, 0) != HAL_OK)
{
Error_Handler();
}
/* USER CODE BEGIN I2C1_Init 2 */
/* USER CODE END I2C1_Init 2 */
}
/**
* @brief SPI1 Initialization Function
* @param None
* @retval None
*/
static void MX_SPI1_Init(void)
{
/* USER CODE BEGIN SPI1_Init 0 */
/* USER CODE END SPI1_Init 0 */
/* USER CODE BEGIN SPI1_Init 1 */
/* USER CODE END SPI1_Init 1 */
/* SPI1 parameter configuration*/
hspi1.Instance = SPI1;
hspi1.Init.Mode = SPI_MODE_MASTER;
hspi1.Init.Direction = SPI_DIRECTION_2LINES;
hspi1.Init.DataSize = SPI_DATASIZE_8BIT;
hspi1.Init.CLKPolarity = SPI_POLARITY_LOW;
hspi1.Init.CLKPhase = SPI_PHASE_1EDGE;
hspi1.Init.NSS = SPI_NSS_SOFT;
hspi1.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_16;
hspi1.Init.FirstBit = SPI_FIRSTBIT_MSB;
hspi1.Init.TIMode = SPI_TIMODE_DISABLE;
hspi1.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE;
hspi1.Init.CRCPolynomial = 7;
hspi1.Init.CRCLength = SPI_CRC_LENGTH_DATASIZE;
hspi1.Init.NSSPMode = SPI_NSS_PULSE_ENABLE;
if (HAL_SPI_Init(&hspi1) != HAL_OK)
{
Error_Handler();
}
/* USER CODE BEGIN SPI1_Init 2 */
/* USER CODE END SPI1_Init 2 */
}
/**
* @brief TIM1 Initialization Function
* @param None
* @retval None
*/
static void MX_TIM1_Init(void)
{
/* USER CODE BEGIN TIM1_Init 0 */
/* USER CODE END TIM1_Init 0 */
TIM_ClockConfigTypeDef sClockSourceConfig = {0};
TIM_MasterConfigTypeDef sMasterConfig = {0};
/* USER CODE BEGIN TIM1_Init 1 */
/* USER CODE END TIM1_Init 1 */
htim1.Instance = TIM1;
htim1.Init.Prescaler = 0;
htim1.Init.CounterMode = TIM_COUNTERMODE_UP;
htim1.Init.Period = 65535;
htim1.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
htim1.Init.RepetitionCounter = 0;
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.MasterOutputTrigger2 = TIM_TRGO2_RESET;
sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
if (HAL_TIMEx_MasterConfigSynchronization(&htim1, &sMasterConfig) != HAL_OK)
{
Error_Handler();
}
/* USER CODE BEGIN TIM1_Init 2 */
/* USER CODE END TIM1_Init 2 */
}
/**
* @brief USART2 Initialization Function
* @param None
* @retval None
*/
static void MX_USART2_UART_Init(void)
{
/* USER CODE BEGIN USART2_Init 0 */
/* USER CODE END USART2_Init 0 */
/* USER CODE BEGIN USART2_Init 1 */
/* USER CODE END USART2_Init 1 */
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;
huart2.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
huart2.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
if (HAL_UART_Init(&huart2) != HAL_OK)
{
Error_Handler();
}
/* USER CODE BEGIN USART2_Init 2 */
/* USER CODE END USART2_Init 2 */
}
/**
* @brief GPIO Initialization Function
* @param None
* @retval None
*/
static void MX_GPIO_Init(void)
{
GPIO_InitTypeDef GPIO_InitStruct = {0};
/* USER CODE BEGIN MX_GPIO_Init_1 */
/* USER CODE END MX_GPIO_Init_1 */
/* GPIO Ports Clock Enable */
__HAL_RCC_GPIOC_CLK_ENABLE();
__HAL_RCC_GPIOH_CLK_ENABLE();
__HAL_RCC_GPIOA_CLK_ENABLE();
__HAL_RCC_GPIOB_CLK_ENABLE();
__HAL_RCC_GPIOD_CLK_ENABLE();
/*Configure GPIO pin Output Level */
HAL_GPIO_WritePin(GPIOC, GPIO_PIN_4|GPIO_PIN_5|GPIO_PIN_6|GPIO_PIN_7, GPIO_PIN_RESET);
/*Configure GPIO pin Output Level */
HAL_GPIO_WritePin(GPIOB, GPIO_PIN_14|GPIO_PIN_15|GPIO_PIN_4|GPIO_PIN_5, GPIO_PIN_RESET);
/*Configure GPIO pin Output Level */
HAL_GPIO_WritePin(GPIOD, GPIO_PIN_10|GPIO_PIN_11|GPIO_PIN_12|GPIO_PIN_13
|GPIO_PIN_0|GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3, GPIO_PIN_RESET);
/*Configure GPIO pin Output Level */
HAL_GPIO_WritePin(GPIOA, GPIO_PIN_8|GPIO_PIN_9|GPIO_PIN_10|GPIO_PIN_11, GPIO_PIN_RESET);
/*Configure GPIO pins : PC4 PC5 PC6 PC7 */
GPIO_InitStruct.Pin = GPIO_PIN_4|GPIO_PIN_5|GPIO_PIN_6|GPIO_PIN_7;
GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
GPIO_InitStruct.Pull = GPIO_NOPULL;
HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);
/*Configure GPIO pins : PC0 PC1 PC2 PC3 */
GPIO_InitStruct.Pin = GPIO_PIN_0|GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3;
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);
/*Configure GPIO pins : PB14 PB15 PB4 PB5 */
GPIO_InitStruct.Pin = GPIO_PIN_14|GPIO_PIN_15|GPIO_PIN_4|GPIO_PIN_5;
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
/*Configure GPIO pins : PD10 PD11 PD12 PD13
PD0 PD1 PD2 PD3 */
GPIO_InitStruct.Pin = GPIO_PIN_10|GPIO_PIN_11|GPIO_PIN_12|GPIO_PIN_13
|GPIO_PIN_0|GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3;
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
HAL_GPIO_Init(GPIOD, &GPIO_InitStruct);
/*Configure GPIO pins : PA8 PA9 PA10 PA11 */
GPIO_InitStruct.Pin = GPIO_PIN_8|GPIO_PIN_9|GPIO_PIN_10|GPIO_PIN_11;
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
/* USER CODE BEGIN MX_GPIO_Init_2 */
/* USER CODE END MX_GPIO_Init_2 */
}
/* 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 */
Reference in New Issue View Git Blame Copy Permalink