diff --git a/firmware/Embedded-Sharepoint b/firmware/Embedded-Sharepoint index 2bdaa5b..489ea13 160000 --- a/firmware/Embedded-Sharepoint +++ b/firmware/Embedded-Sharepoint @@ -1 +1 @@ -Subproject commit 2bdaa5be38e0ac249f0972ad1469ed4fa36dcb04 +Subproject commit 489ea138be7f6689cb8dc33dc3b8d95abdf291e5 diff --git a/firmware/PowerDistributionUnit_Mk1/Makefile b/firmware/PowerDistributionUnit_Mk1/Makefile index 36bdd8b..94733b7 100644 --- a/firmware/PowerDistributionUnit_Mk1/Makefile +++ b/firmware/PowerDistributionUnit_Mk1/Makefile @@ -25,8 +25,8 @@ TEST ?= main PROJECT_TARGET ?= stm32g473xx # SOURCE AND INCLUDE DIRECTORIES -PROJECT_C_INCLUDES = $(wildcard core/inc) $(wildcard ../driver/inc) -PROJECT_C_SOURCES = $(wildcard core/src/*.c) $(wildcard ../driver/src/*.c) +PROJECT_C_INCLUDES = $(wildcard core/inc) $(wildcard ../driver/inc) $(wildcard tasks/inc) +PROJECT_C_SOURCES = $(wildcard core/src/*.c) $(wildcard ../driver/src/*.c) $(wildcard tasks/src/*.c) PROJECT_MAIN_DIR ?= core/src # BUILD DIRECTORIES @@ -41,7 +41,7 @@ MADEFILE_DIR = ${MAKEFILE_DIR} # remove main and add test folders if running test ifneq ($(TEST), "main") PROJECT_C_SOURCES := $(filter-out $(PROJECT_MAIN_DIR)/main.c, $(PROJECT_C_SOURCES)) - PROJECT_C_SOURCES += $(wildcard test/src/${TEST}.c) + PROJECT_C_SOURCES += $(wildcard test/src/Test_${TEST}.c) PROJECT_C_INCLUDES += $(wildcard test/inc) endif diff --git a/firmware/PowerDistributionUnit_Mk1/core/inc/PDU_Mk1.h b/firmware/PowerDistributionUnit_Mk1/core/inc/PDU_Mk1.h index d988169..8c88a01 100644 --- a/firmware/PowerDistributionUnit_Mk1/core/inc/PDU_Mk1.h +++ b/firmware/PowerDistributionUnit_Mk1/core/inc/PDU_Mk1.h @@ -7,3 +7,5 @@ #define PDU_MK1_NUM_CHANNELS 16 #define PDU_MK1_REV_A true + +#define PDU_MK1_PRINT_STATUS_VIA_UART true diff --git a/firmware/PowerDistributionUnit_Mk1/core/inc/PDU_Mk1_CAN.h b/firmware/PowerDistributionUnit_Mk1/core/inc/PDU_Mk1_CAN.h new file mode 100644 index 0000000..f58dbe5 --- /dev/null +++ b/firmware/PowerDistributionUnit_Mk1/core/inc/PDU_Mk1_CAN.h @@ -0,0 +1,32 @@ +// PDU_Mk1_CAN.h +// ---------------------------------------------------------------------------- +// BBPDU Mk1 CAN stuff + +#pragma once + +#include "stm32xx_hal.h" + +// drivers +#include "CAN_FD.h" + +// DEFINES -------------------------------------------------------------------- + +#define PDU_MK1_CAN_ID_PDUSTATUS 0x350 +#define PDU_MK1_CAN_MSGLEN_PDUSTATUS 5 +#define PDU_MK1_CAN_PDUSTATUS_FAULT_LSHIFT 4 +#define PDU_MK1_CAN_PDUSTATUS_ENABLED_LSHIFT 5 +#define PDU_MK1_CAN_PDUSTATUS_VOLTAGE_INDEX 1 +#define PDU_MK1_CAN_PDUSTATUS_VOLTAGE_INVFACTOR 1000 // 1/0.001 = 1000 +#define PDU_MK1_CAN_PDUSTATUS_CURRENT_INDEX 3 +#define PDU_MK1_CAN_PDUSTATUS_CURRENT_INVFACTOR 1000 // 1/0.001 = 1000 + +// VARIABLE DECLARATIONS ------------------------------------------------------ + +// FUNCTIONS ------------------------------------------------------------------ + +/** + * @brief Initializes CAN stuff. + * @param None + * @retval bool: true if successful, false otherwise + */ +can_status_t PDU_Mk1_CAN_Init(); diff --git a/firmware/PowerDistributionUnit_Mk1/core/src/PDU_Mk1_CAN.c b/firmware/PowerDistributionUnit_Mk1/core/src/PDU_Mk1_CAN.c new file mode 100644 index 0000000..1b99411 --- /dev/null +++ b/firmware/PowerDistributionUnit_Mk1/core/src/PDU_Mk1_CAN.c @@ -0,0 +1,175 @@ +// PDU_Mk1_CAN.c + +#include "PDU_Mk1_CAN.h" +#include "printf.h" + +#define FDCAN_NVIC_PRIO configLIBRARY_MAX_SYSCALL_INTERRUPT_PRIORITY + 3 + +uint32_t HAL_RCC_FDCAN_CLK_ENABLED = 0; + +can_status_t PDU_Mk1_CAN_Init() +{ + can_status_t status; + hfdcan3->Instance = FDCAN3; + hfdcan3->Init.ClockDivider = FDCAN_CLOCK_DIV1; + hfdcan3->Init.FrameFormat = FDCAN_FRAME_CLASSIC; + hfdcan3->Init.Mode = FDCAN_MODE_EXTERNAL_LOOPBACK; + hfdcan3->Init.AutoRetransmission = DISABLE; + hfdcan3->Init.TransmitPause = DISABLE; + hfdcan3->Init.ProtocolException = DISABLE; + hfdcan3->Init.NominalPrescaler = 20; + hfdcan3->Init.NominalSyncJumpWidth = 1; + hfdcan3->Init.NominalTimeSeg1 = 13; + hfdcan3->Init.NominalTimeSeg2 = 2; + hfdcan3->Init.DataPrescaler = 1; + hfdcan3->Init.DataSyncJumpWidth = 1; + hfdcan3->Init.DataTimeSeg1 = 1; + hfdcan3->Init.DataTimeSeg2 = 1; + hfdcan3->Init.StdFiltersNbr = 1; + hfdcan3->Init.ExtFiltersNbr = 0; + hfdcan3->Init.TxFifoQueueMode = FDCAN_TX_FIFO_OPERATION; + + // FDCAN1 Filter Config + FDCAN_FilterTypeDef sFilterConfig; + sFilterConfig.IdType = FDCAN_STANDARD_ID; + sFilterConfig.FilterIndex = 0; + sFilterConfig.FilterType = FDCAN_FILTER_MASK; + sFilterConfig.FilterConfig = FDCAN_FILTER_TO_RXFIFO0; // directs frames to FIFO0 + sFilterConfig.FilterID1 = 0x000; + sFilterConfig.FilterID2 = 0x000; + + status = can_fd_init(hfdcan3, &sFilterConfig); + if(status != CAN_OK) + { + return status; + } + + status = can_fd_start(hfdcan3); + if(status != CAN_OK){ + return status; + } + + return CAN_OK; +} + +void HAL_FDCAN_MspInit(FDCAN_HandleTypeDef* fdcanHandle) +{ + + GPIO_InitTypeDef GPIO_InitStruct = {0}; + RCC_PeriphCLKInitTypeDef PeriphClkInit = {0}; + + if(0){ // placeholder for if else if there are no FDCANs defined + + } +#ifdef FDCAN1 + else if(fdcanHandle->Instance==FDCAN1) + { + + PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_FDCAN; + PeriphClkInit.FdcanClockSelection = RCC_FDCANCLKSOURCE_PCLK1; + if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInit) != HAL_OK) + { + Error_Handler(); + } + + /* FDCAN1 clock enable */ + HAL_RCC_FDCAN_CLK_ENABLED++; + if(HAL_RCC_FDCAN_CLK_ENABLED==1){ + __HAL_RCC_FDCAN_CLK_ENABLE(); + } + + __HAL_RCC_GPIOA_CLK_ENABLE(); + /**FDCAN1 GPIO Configuration + PA11 ------> FDCAN1_RX + PA12 ------> FDCAN1_TX + */ + GPIO_InitStruct.Pin = GPIO_PIN_11|GPIO_PIN_12; + GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; + GPIO_InitStruct.Pull = GPIO_NOPULL; + GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW; + GPIO_InitStruct.Alternate = GPIO_AF9_FDCAN1; + HAL_GPIO_Init(GPIOA, &GPIO_InitStruct); + + /* FDCAN1 interrupt Init */ + HAL_NVIC_SetPriority(FDCAN1_IT0_IRQn, FDCAN_NVIC_PRIO, 0); + HAL_NVIC_EnableIRQ(FDCAN1_IT0_IRQn); + HAL_NVIC_SetPriority(FDCAN1_IT1_IRQn, FDCAN_NVIC_PRIO, 0); + HAL_NVIC_EnableIRQ(FDCAN1_IT1_IRQn); + } +#endif // FDCAN1 +#ifdef FDCAN2 + else if(fdcanHandle->Instance==FDCAN2) + { + + PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_FDCAN; + PeriphClkInit.FdcanClockSelection = RCC_FDCANCLKSOURCE_PCLK1; + if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInit) != HAL_OK) + { + Error_Handler(); + } + + /* FDCAN2 clock enable */ + HAL_RCC_FDCAN_CLK_ENABLED++; + if(HAL_RCC_FDCAN_CLK_ENABLED==1){ + __HAL_RCC_FDCAN_CLK_ENABLE(); + } + + __HAL_RCC_GPIOB_CLK_ENABLE(); + /**FDCAN2 GPIO Configuration + PB12 ------> FDCAN2_RX + PB13 ------> FDCAN2_TX + */ + GPIO_InitStruct.Pin = GPIO_PIN_12|GPIO_PIN_13; + GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; + GPIO_InitStruct.Pull = GPIO_NOPULL; + GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW; + GPIO_InitStruct.Alternate = GPIO_AF9_FDCAN2; + HAL_GPIO_Init(GPIOB, &GPIO_InitStruct); + + /* FDCAN2 interrupt Init */ + HAL_NVIC_SetPriority(FDCAN2_IT0_IRQn, FDCAN_NVIC_PRIO, 0); + HAL_NVIC_EnableIRQ(FDCAN2_IT0_IRQn); + HAL_NVIC_SetPriority(FDCAN2_IT1_IRQn, FDCAN_NVIC_PRIO, 0); + HAL_NVIC_EnableIRQ(FDCAN2_IT1_IRQn); + + } +#endif // FDCAN2 + +#ifdef FDCAN3 + else if(fdcanHandle->Instance==FDCAN3) + { + /** Initializes the peripherals clocks + */ + PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_FDCAN; + PeriphClkInit.FdcanClockSelection = RCC_FDCANCLKSOURCE_PCLK1; + if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInit) != HAL_OK) + { + Error_Handler(); + } + + /* FDCAN3 clock enable */ + HAL_RCC_FDCAN_CLK_ENABLED++; + if(HAL_RCC_FDCAN_CLK_ENABLED==1){ + __HAL_RCC_FDCAN_CLK_ENABLE(); + } + + __HAL_RCC_GPIOA_CLK_ENABLE(); + /**FDCAN3 GPIO Configuration + PA8 ------> FDCAN3_RX + PA15 ------> FDCAN3_TX + */ + GPIO_InitStruct.Pin = GPIO_PIN_8|GPIO_PIN_15; + GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; + GPIO_InitStruct.Pull = GPIO_NOPULL; + GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW; + GPIO_InitStruct.Alternate = GPIO_AF11_FDCAN3; + HAL_GPIO_Init(GPIOA, &GPIO_InitStruct); + + /* FDCAN3 interrupt Init */ + HAL_NVIC_SetPriority(FDCAN3_IT0_IRQn, FDCAN_NVIC_PRIO, 0); + HAL_NVIC_EnableIRQ(FDCAN3_IT0_IRQn); + HAL_NVIC_SetPriority(FDCAN3_IT1_IRQn, FDCAN_NVIC_PRIO, 0); + HAL_NVIC_EnableIRQ(FDCAN3_IT1_IRQn); + } +#endif +} diff --git a/firmware/PowerDistributionUnit_Mk1/tasks/inc/Task_Blink.h b/firmware/PowerDistributionUnit_Mk1/tasks/inc/Task_Blink.h new file mode 100644 index 0000000..36b70db --- /dev/null +++ b/firmware/PowerDistributionUnit_Mk1/tasks/inc/Task_Blink.h @@ -0,0 +1,24 @@ +// Task_Blink.h +// ---------------------------------------------------------------------------- +// Task blinks LED at fixed interval. + +#pragma once + +// INCLUDES ------------------------------------------------------------------- + +#include "stm32xx_hal.h" + +#include "PDU_Mk1_Pins.h" + +// DEFINES -------------------------------------------------------------------- + +#define TASK_BLINK_STACK_SIZE configMINIMAL_STACK_SIZE +#define TASK_BLINK_PRIORITY tskIDLE_PRIORITY + 2 + +#define TASK_BLINK_INTERVAL_MS 500 + +// VARIABLE DECLARATIONS ------------------------------------------------------ + +// FUNCTIONS ------------------------------------------------------------------ + +void Task_Blink(void *argument); diff --git a/firmware/PowerDistributionUnit_Mk1/tasks/inc/Task_CanSendStatus.h b/firmware/PowerDistributionUnit_Mk1/tasks/inc/Task_CanSendStatus.h new file mode 100644 index 0000000..0d11c19 --- /dev/null +++ b/firmware/PowerDistributionUnit_Mk1/tasks/inc/Task_CanSendStatus.h @@ -0,0 +1,30 @@ +// Task_ReadCurrents.h +// ---------------------------------------------------------------------------- +// Task sends PDU status on CAN. + +#pragma once + +// INCLUDES ------------------------------------------------------------------- + +#include "stm32xx_hal.h" +#include "printf.h" + +#include "PDU_Mk1.h" +#include "PDU_Mk1_CAN.h" +#include "PDU_Mk1_CurrentSensing.h" +#include "PDU_Mk1_HSSControl.h" + +// DEFINES -------------------------------------------------------------------- + +#define TASK_CANSENDSTATUS_STACK_SIZE configMINIMAL_STACK_SIZE+200 +#define TASK_CANSENDSTATUS_PRIORITY tskIDLE_PRIORITY + 2 + +// sets how often the CAN status is sent +#define TASK_CANSENDSTATUS_CH_INTERVAL_MS 100 // single channel mode +// #define TASK_CANSENDSTATUS_INTERVAL_MS 1000 // spam all channels (doesn't work) + +// VARIABLE DECLARATIONS ------------------------------------------------------ + +// FUNCTIONS ------------------------------------------------------------------ + +void Task_CanSendStatus(void *argument); diff --git a/firmware/PowerDistributionUnit_Mk1/tasks/inc/Task_HSSControl.h b/firmware/PowerDistributionUnit_Mk1/tasks/inc/Task_HSSControl.h new file mode 100644 index 0000000..48b07ae --- /dev/null +++ b/firmware/PowerDistributionUnit_Mk1/tasks/inc/Task_HSSControl.h @@ -0,0 +1,26 @@ +// Task_HSSControl.h +// ---------------------------------------------------------------------------- +// Task controls PDU output channels. + +#pragma once + +// INCLUDES ------------------------------------------------------------------- + +#include "stm32xx_hal.h" +#include "printf.h" + +// BBPDU peripherals +#include "PDU_Mk1_HSSControl.h" + +// DEFINES -------------------------------------------------------------------- + +#define TASK_HSSCONTROL_STACK_SIZE configMINIMAL_STACK_SIZE+200 +#define TASK_HSSCONTROL_PRIORITY tskIDLE_PRIORITY + 2 + +#define TASK_HSSCONTROL_INTERVAL_MS 1000 + +// VARIABLE DECLARATIONS ------------------------------------------------------ + +// FUNCTIONS ------------------------------------------------------------------ + +void Task_HSSControl(void *argument); diff --git a/firmware/PowerDistributionUnit_Mk1/tasks/inc/Task_Init.h b/firmware/PowerDistributionUnit_Mk1/tasks/inc/Task_Init.h new file mode 100644 index 0000000..cdb13fc --- /dev/null +++ b/firmware/PowerDistributionUnit_Mk1/tasks/inc/Task_Init.h @@ -0,0 +1,50 @@ +// Task_Init.h +// ---------------------------------------------------------------------------- +// Task inits everything. + +#pragma once + +// INCLUDES ------------------------------------------------------------------- + +#include "stm32xx_hal.h" + +#include "PDU_Mk1_Pins.h" +#include "PDU_Mk1_GPIO.h" +#include "PDU_Mk1_SPI.h" +#include "PDU_Mk1_UART.h" +#include "PDU_Mk1_CAN.h" + +#include "PDU_Mk1_CurrentSensing.h" +#include "PDU_Mk1_HSSControl.h" + +// DEFINES -------------------------------------------------------------------- + +#define TASK_INIT_STACK_SIZE configMINIMAL_STACK_SIZE+1000 +#define TASK_INIT_PRIORITY tskIDLE_PRIORITY + 3 + +// VARIABLE DECLARATIONS ------------------------------------------------------ + +extern TaskHandle_t task_blink; +extern TaskHandle_t task_readcurrents; +extern TaskHandle_t task_cansendstatus; + +extern SemaphoreHandle_t spi1_mutex; // Mutex to prevent simultaneous SPI access +extern StaticSemaphore_t spi1_mutex_buffer; // Static buffer for mutex allocation +extern SemaphoreHandle_t spi1_done_sem; // Semaphore to signal SPI IT completion +extern StaticSemaphore_t spi1_done_sem_buffer; // Static buffer for completion semaphore + +extern SemaphoreHandle_t spi2_mutex; // Mutex to prevent simultaneous SPI access +extern StaticSemaphore_t spi2_mutex_buffer; // Static buffer for mutex allocation +extern SemaphoreHandle_t spi2_done_sem; // Semaphore to signal SPI IT completion +extern StaticSemaphore_t spi2_done_sem_buffer; // Static buffer for completion semaphore + +extern SemaphoreHandle_t spi3_mutex; // Mutex to prevent simultaneous SPI access +extern StaticSemaphore_t spi3_mutex_buffer; // Static buffer for mutex allocation +extern SemaphoreHandle_t spi3_done_sem; // Semaphore to signal SPI IT completion +extern StaticSemaphore_t spi3_done_sem_buffer; // Static buffer for completion semaphore + +// FUNCTIONS ------------------------------------------------------------------ + +void PDU_Mk1_StartTasks(); + +void Task_Init(void *argument); diff --git a/firmware/PowerDistributionUnit_Mk1/tasks/inc/Task_ReadCurrents.h b/firmware/PowerDistributionUnit_Mk1/tasks/inc/Task_ReadCurrents.h new file mode 100644 index 0000000..146d0ff --- /dev/null +++ b/firmware/PowerDistributionUnit_Mk1/tasks/inc/Task_ReadCurrents.h @@ -0,0 +1,28 @@ +// Task_ReadCurrents.h +// ---------------------------------------------------------------------------- +// Task reads ADC to get output currents at fixed interval. + +#pragma once + +// INCLUDES ------------------------------------------------------------------- + +#include "stm32xx_hal.h" +#include "printf.h" + +// BBPDU peripherals +#include "PDU_Mk1.h" +#include "PDU_Mk1_CurrentSensing.h" + +// DEFINES -------------------------------------------------------------------- + +#define TASK_READCURRENTS_STACK_SIZE configMINIMAL_STACK_SIZE+200 +#define TASK_READCURRENTS_PRIORITY tskIDLE_PRIORITY + 2 + +// sets how often the current reading ADC is sampled +#define TASK_READCURRENTS_INTERVAL_MS 500 + +// VARIABLE DECLARATIONS ------------------------------------------------------ + +// FUNCTIONS ------------------------------------------------------------------ + +void Task_ReadCurrents(void *argument); diff --git a/firmware/PowerDistributionUnit_Mk1/tasks/src/Task_Blink.c b/firmware/PowerDistributionUnit_Mk1/tasks/src/Task_Blink.c new file mode 100644 index 0000000..3027983 --- /dev/null +++ b/firmware/PowerDistributionUnit_Mk1/tasks/src/Task_Blink.c @@ -0,0 +1,13 @@ +// Task_Blink.c + +#include "Task_Blink.h" + +void Task_Blink(void *argument) +{ + for(;;) + { + HAL_GPIO_TogglePin(LED_PORT, LED_PIN); + + vTaskDelay(pdMS_TO_TICKS(TASK_BLINK_INTERVAL_MS)); + } +} diff --git a/firmware/PowerDistributionUnit_Mk1/tasks/src/Task_CANSendStatus.c b/firmware/PowerDistributionUnit_Mk1/tasks/src/Task_CANSendStatus.c new file mode 100644 index 0000000..dfbdf7c --- /dev/null +++ b/firmware/PowerDistributionUnit_Mk1/tasks/src/Task_CANSendStatus.c @@ -0,0 +1,99 @@ +// Task_CanSendStatus.c + +#include "Task_CanSendStatus.h" + +void Task_CanSendStatus(void *argument) +{ + // CAN peripheral must be ready before running task. + + FDCAN_TxHeaderTypeDef tx_header = {0}; + tx_header.Identifier = PDU_MK1_CAN_ID_PDUSTATUS; + tx_header.IdType = FDCAN_STANDARD_ID; + tx_header.TxFrameType = FDCAN_DATA_FRAME; + tx_header.DataLength = FDCAN_DLC_BYTES_5; + tx_header.ErrorStateIndicator = FDCAN_ESI_ACTIVE; + tx_header.BitRateSwitch = FDCAN_BRS_OFF; + tx_header.FDFormat = FDCAN_CLASSIC_CAN; + tx_header.TxEventFifoControl = FDCAN_STORE_TX_EVENTS; + tx_header.MessageMarker = 0; + + // single channel + uint8_t ch_to_send = 0; + uint8_t ch_data[PDU_MK1_CAN_MSGLEN_PDUSTATUS] = {0}; + + // spam all channels + // uint8_t data[PDU_MK1_NUM_CHANNELS][PDU_MK1_CAN_MSGLEN_PDUSTATUS] = {0}; + + for(;;) + { + // SINGLE CHANNEL + for(uint8_t i = 0; i < PDU_MK1_CAN_MSGLEN_PDUSTATUS; i++) + { + ch_data[i] = 0; + } + + ch_data[0] |= ch_to_send; + + if(PDU_Mk1_HSSControl_GetFaultState_Ch(ch_to_send) != HSSCONTROL_NOFAULT) + { + ch_data[0] |= (1 << PDU_MK1_CAN_PDUSTATUS_FAULT_LSHIFT); // FAULT + } + + if(PDU_Mk1_HSSControl_GetENState_Ch(ch_to_send) == HSSCONTROL_EN_ON) + { + ch_data[0] |= (1 << PDU_MK1_CAN_PDUSTATUS_ENABLED_LSHIFT); // ENABLED + } + + // *((uint16_t*) (ch_data+1)) = ((uint16_t) ((24+ch_to_send*0.1)*1000)); // dummy voltage data + // *((uint16_t*) (ch_data+3)) = ((uint16_t) ((ch_to_send*0.67)*1000)); // dummy current data + *((uint16_t*) (ch_data+PDU_MK1_CAN_PDUSTATUS_VOLTAGE_INDEX)) = ((uint16_t) (0)); // no voltage data yet + *((uint16_t*) (ch_data+PDU_MK1_CAN_PDUSTATUS_CURRENT_INDEX)) = ((uint16_t) (PDU_Mk1_CurrentSensing_GetCurrentsPtr()[ch_to_send]*PDU_MK1_CAN_PDUSTATUS_CURRENT_INVFACTOR)); + + if (can_fd_send(hfdcan3, &tx_header, ch_data, portMAX_DELAY) != CAN_OK){ + printf("ERROR:CAN_SEND_PDUSTATUS\n"); + Error_Handler(); + } + + ch_to_send++; + if(ch_to_send >= PDU_MK1_NUM_CHANNELS) + { + ch_to_send = 0; + } + + vTaskDelay(pdMS_TO_TICKS(TASK_CANSENDSTATUS_CH_INTERVAL_MS)); + + + + // // SPAM ALL CHANNELS (doesn't work) + // for(uint8_t ch = 0; ch < PDU_MK1_NUM_CHANNELS; ch++) + // { + // for(uint8_t i = 0; i < PDU_MK1_CAN_MSGLEN_PDUSTATUS; i++) + // { + // data[ch][i] = 0; + // } + + // data[ch][0] |= ch; + // data[ch][0] |= (0 << PDU_MK1_CAN_PDUSTATUS_FAULT_LSHIFT); // FAULT: TBD + // data[ch][0] |= (1 << PDU_MK1_CAN_PDUSTATUS_ENABLED_LSHIFT); // ENABLED: TBD + + // *((uint16_t*) data[ch]+1) = ((uint16_t) ((24+ch*0.1)*1000)); // dummy voltage data + // *((uint16_t*) data[ch]+3) = ((uint16_t) ((ch*0.67)*1000)); // dummy current data + // *((uint16_t*) data[ch]+3) = ((uint16_t) (PDU_Mk1_CurrentSensing_GetCurrentsPtr()[ch]*1000)); + // } + + // for(uint8_t ch = 0; ch < 4; ch++) + // { + // printf("try send %d\n", ch); + // if (can_fd_send(hfdcan3, &tx_header, data[ch], portMAX_DELAY) != CAN_OK){ + // while(1) + // { + // printf("ERROR:CAN_SEND_PDUSTATUS\n"); + // Error_Handler(); + // } + // } + // printf("did %d\n", ch); + // } + + // vTaskDelay(pdMS_TO_TICKS(TASK_CANSENDSTATUS_INTERVAL_MS)); + } +} diff --git a/firmware/PowerDistributionUnit_Mk1/tasks/src/Task_HSSControl.c b/firmware/PowerDistributionUnit_Mk1/tasks/src/Task_HSSControl.c new file mode 100644 index 0000000..632e2aa --- /dev/null +++ b/firmware/PowerDistributionUnit_Mk1/tasks/src/Task_HSSControl.c @@ -0,0 +1,17 @@ +// Task_HSSControl.c + +#include "Task_HSSControl.h" + +void Task_HSSControl(void *argument) +{ + for(;;) + { + if(PDU_Mk1_HSSControl_AllOn() != HSSCONTROL_🙂) + { + printf("FAIL:HSSCONTROL_ALLON"); + Error_Handler(); + } + + vTaskDelay(pdMS_TO_TICKS(TASK_HSSCONTROL_INTERVAL_MS)); + } +} diff --git a/firmware/PowerDistributionUnit_Mk1/tasks/src/Task_Init.c b/firmware/PowerDistributionUnit_Mk1/tasks/src/Task_Init.c new file mode 100644 index 0000000..47874ed --- /dev/null +++ b/firmware/PowerDistributionUnit_Mk1/tasks/src/Task_Init.c @@ -0,0 +1,81 @@ +// Task_Init.c + +#include "Task_Init.h" + +void Task_Init(void *argument) +{ + PDU_Mk1_GPIO_Init(); + + if(PDU_Mk1_UART_Printf_Init() != true) + { + printf("FAIL:UART_PRINTF_INIT\n"); + Error_Handler(); + } + + if(PDU_Mk1_CAN_Init() != CAN_OK) + { + printf("FAIL: CAN\n"); + Error_Handler(); + } + + if(PDU_Mk1_SPI2_ADC_Init() != true) + { + printf("FAIL:SPI2_INIT\n"); + Error_Handler(); + } + +#if (PDU_MK1_REV_A == false) // PDU_Mk1_REV_A has SPI pinout issue + if(PDU_Mk1_SPI3_ADC_Init() != true) + { + printf("FAIL:SPI3_INIT\n"); + Error_Handler(); + } +#endif + + if(SPI_RTOS_Mutex_Semaphore_Setup(&spi2_mutex, &spi2_mutex_buffer, &spi2_done_sem, &spi2_done_sem_buffer) != true) + { + printf("FAIL:MUTEX_SEMAPHORE_INIT\n"); + Error_Handler(); + } + + // SPI dummy send because CLK pin initializes high even when configured low for some reason + if(SPI_Init_Dummy_Send(&hspi2, spi2_mutex, spi2_done_sem) != true) + { + printf("FAIL:SPI2_INIT_DUMMY_SEND\n"); + Error_Handler(); + } + +#if (PDU_MK1_REV_A == false) // PDU_Mk1_REV_A has SPI pinout issue + if(SPI_RTOS_Mutex_Semaphore_Setup(&spi3_mutex, &spi3_mutex_buffer, &spi3_done_sem, &spi3_done_sem_buffer) != true) + { + printf("FAIL:MUTEX_SEMAPHORE_INIT\n"); + Error_Handler(); + } + + // SPI dummy send because CLK pin initializes high even when configured low for some reason + if(SPI_Init_Dummy_Send(&hspi3, spi3_mutex, spi3_done_sem) != true) + { + printf("FAIL:SPI3_INIT_DUMMY_SEND\n"); + Error_Handler(); + } +#endif + + if(PDU_Mk1_CurrentSensing_Init() != true) + { + printf("FAIL:ISENSE_INIT\n"); + Error_Handler(); + } + + if(PDU_Mk1_HSSControl_Init() != HSSCONTROL_🙂) + { + printf("FAIL:HSSCONTROL_INIT\n"); + Error_Handler(); + } + + printf("Initialization complete.\n"); + + // get this party started + PDU_Mk1_StartTasks(); + // task kills itself + vTaskDelete(NULL); +} diff --git a/firmware/PowerDistributionUnit_Mk1/tasks/src/Task_ReadCurrents.c b/firmware/PowerDistributionUnit_Mk1/tasks/src/Task_ReadCurrents.c new file mode 100644 index 0000000..44c7e30 --- /dev/null +++ b/firmware/PowerDistributionUnit_Mk1/tasks/src/Task_ReadCurrents.c @@ -0,0 +1,59 @@ +// Task_ReadCurrents.c + +#include "Task_ReadCurrents.h" + +void Task_ReadCurrents(void *argument) +{ + // magic delay required to make things work for some reason + // TODO: see if still required? add delay to init function instead? + vTaskDelay(pdMS_TO_TICKS(1)); + + for(;;) + { + if(PDU_Mk1_CurrentSensing_ReadCurrents() != true) + { + printf("FAIL:READ_CURRENTS\n"); + Error_Handler(); + } + +#if (PDU_MK1_PRINT_STATUS_VIA_UART) + float* currents = PDU_Mk1_CurrentSensing_GetCurrentsPtr(); + + printf("\nCurrents\n----------\n" + "CH0: %.4f A\n" + "CH1: %.4f A\n" + "CH2: %.4f A\n" + "CH3: %.4f A\n" + "CH4: %.4f A\n" + "CH5: %.4f A\n" + "CH6: %.4f A\n" + "CH7: %.4f A\n" + "CH8: %.4f A\n" + "CH9: %.4f A\n" + "CH10: %.4f A\n" + "CH11: %.4f A\n" + "CH12: %.4f A\n" + "CH13: %.4f A\n" + "CH14: %.4f A\n" + "CH15: %.4f A\n", + currents[0], + currents[1], + currents[2], + currents[3], + currents[4], + currents[5], + currents[6], + currents[7], + currents[8], + currents[9], + currents[10], + currents[11], + currents[12], + currents[13], + currents[14], + currents[15]); +#endif + + vTaskDelay(pdMS_TO_TICKS(TASK_READCURRENTS_INTERVAL_MS)); + } +} diff --git a/firmware/PowerDistributionUnit_Mk1/test/MakeAllTests_PowerDistributionUnit_Mk1.py b/firmware/PowerDistributionUnit_Mk1/test/MakeAllTests_PowerDistributionUnit_Mk1.py index 50714bb..8c4b6d0 100644 --- a/firmware/PowerDistributionUnit_Mk1/test/MakeAllTests_PowerDistributionUnit_Mk1.py +++ b/firmware/PowerDistributionUnit_Mk1/test/MakeAllTests_PowerDistributionUnit_Mk1.py @@ -39,7 +39,7 @@ def find_tests(tests_dir: Path): tests = [] for cfile in tests_dir.glob("*.c"): - tests.append(cfile.stem) + tests.append(cfile.stem.replace("Test_", "")) if not tests: error("Something is horribly wrong. No test files found in the tests directory.") diff --git a/firmware/PowerDistributionUnit_Mk1/test/src/ACS_Current_Sensing.c b/firmware/PowerDistributionUnit_Mk1/test/src/ACS_Current_Sensing.c deleted file mode 100644 index 8e73993..0000000 --- a/firmware/PowerDistributionUnit_Mk1/test/src/ACS_Current_Sensing.c +++ /dev/null @@ -1,269 +0,0 @@ -// Current_Sensing.c -// ---------------------------------------------------------------------------- -// Senses current through each channel on BBPDU Mk1 using the hall-effect -// current sensor (not HSS one) and prints to the serial monitor. - -// INCLUDES ------------------------------------------------------------------- - -#include "stm32xx_hal.h" -// stm32xx_hal.h contains includes for RTOS stuff. -#include -#include - -// BBPDU Peripherals -#include "PDU_Mk1_Pins.h" -#include "PDU_Mk1_SPI.h" -#include "PDU_Mk1_GPIO.h" -#include "PDU_Mk1_UART.h" -#include "PDU_Mk1_CurrentSensing.h" - -// drivers -#include "ADS131M08-Q1.h" -#include "ACS3704x-010B3.h" - -// DEFINES -------------------------------------------------------------------- - -#define TASKPRIORITY_INIT tskIDLE_PRIORITY + 3 -#define TASKSTACKSIZE_INIT configMINIMAL_STACK_SIZE+5000 - -#define TASKPRIORITY_BLINK tskIDLE_PRIORITY + 2 -#define TASKSTACKSIZE_BLINK configMINIMAL_STACK_SIZE - -#define TASKPRIORITY_CURRENT_SENSE tskIDLE_PRIORITY + 2 -#define TASKSTACKSIZE_CURRENT_SENSE configMINIMAL_STACK_SIZE+3000 - -#define INTERVAL_BLINK_MS 500 -#define INTERVAL_BLINK_ERROR_MS 50 -#define INTERVAL_CURRENT_SENSE_MS 500 - -// DECLARATIONS --------------------------------------------------------------- - -SPI_HandleTypeDef hspi1; -SPI_HandleTypeDef hspi2; -SPI_HandleTypeDef hspi3; - -extern ADS131M08Q1_HandleTypeDef adc_sns0; -extern ADS131M08Q1_HandleTypeDef adc_sns1; -float adc_results_sns0[8]; -float adc_results_sns1[8]; - -SemaphoreHandle_t spi1_mutex; // Mutex to prevent simultaneous SPI access -StaticSemaphore_t spi1_mutex_buffer; // Static buffer for mutex allocation - -SemaphoreHandle_t spi1_done_sem; // Semaphore to signal SPI IT completion -StaticSemaphore_t spi1_done_sem_buffer; // Static buffer for completion semaphore - -SemaphoreHandle_t spi2_mutex; // Mutex to prevent simultaneous SPI access -StaticSemaphore_t spi2_mutex_buffer; // Static buffer for mutex allocation - -SemaphoreHandle_t spi2_done_sem; // Semaphore to signal SPI IT completion -StaticSemaphore_t spi2_done_sem_buffer; // Static buffer for completion semaphore - -SemaphoreHandle_t spi3_mutex; // Mutex to prevent simultaneous SPI access -StaticSemaphore_t spi3_mutex_buffer; // Static buffer for mutex allocation - -SemaphoreHandle_t spi3_done_sem; // Semaphore to signal SPI IT completion -StaticSemaphore_t spi3_done_sem_buffer; // Static buffer for completion semaphore - -TaskHandle_t init_task; -StaticTask_t init_task_buffer; -StackType_t init_task_stack[TASKSTACKSIZE_INIT]; - -TaskHandle_t blink_task; -StaticTask_t blink_task_buffer; -StackType_t blink_task_stack[TASKSTACKSIZE_BLINK]; - -TaskHandle_t current_sense_task; -StaticTask_t current_sense_task_buffer; -StackType_t current_sense_task_stack[TASKSTACKSIZE_CURRENT_SENSE]; - -// TASKS ---------------------------------------------------------------------- - -// initialize stuff -void Init_Task(void *argument) -{ - PDU_Mk1_GPIO_Init(); - - if(PDU_Mk1_SPI2_ADC_Init() != true) - { - printf("FAIL:SPI2_INIT\n"); - Error_Handler(); - } - -#if (PDU_MK1_REV_A == false) // PDU_Mk1_REV_A has SPI pinout issue - if(PDU_Mk1_SPI3_ADC_Init() != true) - { - printf("FAIL:SPI3_INIT\n"); - Error_Handler(); - } -#endif - - if(PDU_Mk1_UART_Printf_Init() != true) - { - printf("FAIL:UART_PRINTF_INIT\n"); - Error_Handler(); - } - - if(SPI_RTOS_Mutex_Semaphore_Setup(&spi2_mutex, &spi2_mutex_buffer, &spi2_done_sem, &spi2_done_sem_buffer) != true) - { - printf("FAIL:MUTEX_SEMAPHORE_INIT\n"); - Error_Handler(); - } - - // SPI dummy send because CLK pin initializes high even when configured low for some reason - if(SPI_Init_Dummy_Send(&hspi2, spi2_mutex, spi2_done_sem) != true) - { - printf("FAIL:SPI2_INIT_DUMMY_SEND\n"); - Error_Handler(); - } - -#if (PDU_MK1_REV_A == false) // PDU_Mk1_REV_A has SPI pinout issue - if(SPI_RTOS_Mutex_Semaphore_Setup(&spi3_mutex, &spi3_mutex_buffer, &spi3_done_sem, &spi3_done_sem_buffer) != true) - { - printf("FAIL:MUTEX_SEMAPHORE_INIT\n"); - Error_Handler(); - } - - // SPI dummy send because CLK pin initializes high even when configured low for some reason - if(SPI_Init_Dummy_Send(&hspi3, spi3_mutex, spi3_done_sem) != true) - { - printf("FAIL:SPI3_INIT_DUMMY_SEND\n"); - while(1) - { - HAL_GPIO_TogglePin(LED_PORT, LED_PIN); - vTaskDelay(pdMS_TO_TICKS(INTERVAL_BLINK_ERROR_MS)); - } - } -#endif - - if(PDU_Mk1_CurrentSensing_Init() != true) - { - printf("FAIL:ISENSE_INIT\n"); - Error_Handler(); - } - - printf("Initialization complete.\n"); - - // get this party started - vTaskResume(blink_task); - vTaskResume(current_sense_task); - // task kills itself - vTaskDelete(NULL); -} - -// blink LED -void Blink_Task(void *argument) -{ - for(;;) - { - HAL_GPIO_TogglePin(LED_PORT, LED_PIN); - - vTaskDelay(pdMS_TO_TICKS(INTERVAL_BLINK_MS)); - } -} - -// read currents and print to serial -void Current_Sense_Task(void *argument) -{ - // magic delay required to make things work for some reason - vTaskDelay(pdMS_TO_TICKS(1)); - - for(;;) - { - if(PDU_Mk1_CurrentSensing_ReadCurrents() != true) - { - printf("FAIL:CURRENT_SAMPLING\n"); - Error_Handler(); - } - - float* currents = PDU_Mk1_CurrentSensing_GetCurrentsPtr(); - - printf("\nCurrents\n----------\n" - "CH0: %.4f A\n" - "CH1: %.4f A\n" - "CH2: %.4f A\n" - "CH3: %.4f A\n" - "CH4: %.4f A\n" - "CH5: %.4f A\n" - "CH6: %.4f A\n" - "CH7: %.4f A\n" - "CH8: %.4f A\n" - "CH9: %.4f A\n" - "CH10: %.4f A\n" - "CH11: %.4f A\n" - "CH12: %.4f A\n" - "CH13: %.4f A\n" - "CH14: %.4f A\n" - "CH15: %.4f A\n", - currents[0], - currents[1], - currents[2], - currents[3], - currents[4], - currents[5], - currents[6], - currents[7], - currents[8], - currents[9], - currents[10], - currents[11], - currents[12], - currents[13], - currents[14], - currents[15]); - - vTaskDelay(pdMS_TO_TICKS(INTERVAL_CURRENT_SENSE_MS)); - } -} - -// MAIN ----------------------------------------------------------------------- - -int main() -{ - HAL_Init(); - SystemClock_Config(); - - init_task = xTaskCreateStatic(Init_Task, - "Init Task", - TASKSTACKSIZE_INIT, - NULL, - TASKPRIORITY_INIT, - init_task_stack, - &init_task_buffer - ); - - blink_task = xTaskCreateStatic(Blink_Task, - "Blink Task", - TASKSTACKSIZE_BLINK, - NULL, - TASKPRIORITY_BLINK, - blink_task_stack, - &blink_task_buffer - ); - - current_sense_task = xTaskCreateStatic(Current_Sense_Task, - "Current Sense Task", - TASKSTACKSIZE_CURRENT_SENSE, - NULL, - TASKPRIORITY_CURRENT_SENSE, - current_sense_task_stack, - ¤t_sense_task_buffer - ); - - vTaskSuspend(blink_task); - vTaskSuspend(current_sense_task); - vTaskStartScheduler(); - - while(1) {} -} - -// ERROR HANDLER -------------------------------------------------------------- - -void Error_Handler(void) -{ - while(1) - { - HAL_GPIO_TogglePin(LED_PORT, LED_PIN); - vTaskDelay(pdMS_TO_TICKS(INTERVAL_BLINK_ERROR_MS)); - } -} diff --git a/firmware/PowerDistributionUnit_Mk1/test/src/ADS131M08Q1_Convert.c b/firmware/PowerDistributionUnit_Mk1/test/src/ADS131M08Q1_Convert.c deleted file mode 100644 index fbcb90b..0000000 --- a/firmware/PowerDistributionUnit_Mk1/test/src/ADS131M08Q1_Convert.c +++ /dev/null @@ -1,240 +0,0 @@ -// ADS131M08Q1_Convert.c -// ---------------------------------------------------------------------------- -// Reads ADC conversions for both ADCs on BBPDU Mk. 1 (ADC_SNS0 and ADC_SNS1) -// in continuous-conversion mode every 500 ms. Prints out results to serial -// monitor. - -// INCLUDES ------------------------------------------------------------------- - -#include "stm32xx_hal.h" -// stm32xx_hal.h contains includes for RTOS stuff. -#include -#include - -// BBPDU Peripherals -#include "PDU_Mk1_Pins.h" -#include "PDU_Mk1_SPI.h" -#include "PDU_Mk1_GPIO.h" -#include "PDU_Mk1_UART.h" -#include "PDU_Mk1_CurrentSensing.h" - -// drivers -#include "ADS131M08-Q1.h" - -// DEFINES -------------------------------------------------------------------- - -#define TASKPRIORITY_INIT tskIDLE_PRIORITY + 3 -#define TASKSTACKSIZE_INIT configMINIMAL_STACK_SIZE+5000 - -#define TASKPRIORITY_BLINK tskIDLE_PRIORITY + 2 -#define TASKSTACKSIZE_BLINK configMINIMAL_STACK_SIZE - -#define TASKPRIORITY_ADC_READ tskIDLE_PRIORITY + 2 -#define TASKSTACKSIZE_ADC_READ configMINIMAL_STACK_SIZE+3000 - -#define INTERVAL_BLINK_MS 500 -#define INTERVAL_BLINK_ERROR_MS 50 -#define INTERVAL_ADC_READ_MS 500 - -// DECLARATIONS --------------------------------------------------------------- - -SPI_HandleTypeDef hspi1; -SPI_HandleTypeDef hspi2; -SPI_HandleTypeDef hspi3; - -extern ADS131M08Q1_HandleTypeDef adc_sns0; -extern ADS131M08Q1_HandleTypeDef adc_sns1; -float adc_results_sns0[8]; -float adc_results_sns1[8]; - -SemaphoreHandle_t spi1_mutex; // Mutex to prevent simultaneous SPI access -StaticSemaphore_t spi1_mutex_buffer; // Static buffer for mutex allocation - -SemaphoreHandle_t spi1_done_sem; // Semaphore to signal SPI IT completion -StaticSemaphore_t spi1_done_sem_buffer; // Static buffer for completion semaphore - -SemaphoreHandle_t spi2_mutex; // Mutex to prevent simultaneous SPI access -StaticSemaphore_t spi2_mutex_buffer; // Static buffer for mutex allocation - -SemaphoreHandle_t spi2_done_sem; // Semaphore to signal SPI IT completion -StaticSemaphore_t spi2_done_sem_buffer; // Static buffer for completion semaphore - -SemaphoreHandle_t spi3_mutex; // Mutex to prevent simultaneous SPI access -StaticSemaphore_t spi3_mutex_buffer; // Static buffer for mutex allocation - -SemaphoreHandle_t spi3_done_sem; // Semaphore to signal SPI IT completion -StaticSemaphore_t spi3_done_sem_buffer; // Static buffer for completion semaphore - -TaskHandle_t init_task; -StaticTask_t init_task_buffer; -StackType_t init_task_stack[TASKSTACKSIZE_INIT]; - -TaskHandle_t blink_task; -StaticTask_t blink_task_buffer; -StackType_t blink_task_stack[TASKSTACKSIZE_BLINK]; - -TaskHandle_t adc_read_task; -StaticTask_t adc_read_task_buffer; -StackType_t adc_read_task_stack[TASKSTACKSIZE_ADC_READ]; - -// TASKS ---------------------------------------------------------------------- - -// initialize stuff -void Init_Task(void *argument) -{ - PDU_Mk1_GPIO_Init(); - - if(PDU_Mk1_SPI2_ADC_Init() != true) - { - printf("FAIL:SPI2_INIT\n"); - Error_Handler(); - } - - if(PDU_Mk1_SPI3_ADC_Init() != true) - { - printf("FAIL:SPI3_INIT\n"); - Error_Handler(); - } - - if(PDU_Mk1_UART_Printf_Init() != true) - { - printf("FAIL:UART_PRINTF_INIT\n"); - Error_Handler(); - } - - if(SPI_RTOS_Mutex_Semaphore_Setup(&spi2_mutex, &spi2_mutex_buffer, &spi2_done_sem, &spi2_done_sem_buffer) != true) - { - printf("FAIL:MUTEX_SEMAPHORE_INIT\n"); - Error_Handler(); - } - - // SPI dummy send because CLK pin initializes high even when configured low for some reason - if(SPI_Init_Dummy_Send(&hspi2, spi2_mutex, spi2_done_sem) != true) - { - printf("FAIL:SPI2_INIT_DUMMY_SEND\n"); - Error_Handler(); - } - - if(SPI_RTOS_Mutex_Semaphore_Setup(&spi3_mutex, &spi3_mutex_buffer, &spi3_done_sem, &spi3_done_sem_buffer) != true) - { - printf("FAIL:MUTEX_SEMAPHORE_INIT\n"); - Error_Handler(); - } - - // SPI dummy send because CLK pin initializes high even when configured low for some reason - if(SPI_Init_Dummy_Send(&hspi3, spi3_mutex, spi3_done_sem) != true) - { - printf("FAIL:SPI3_INIT_DUMMY_SEND\n"); - while(1) - { - HAL_GPIO_TogglePin(LED_PORT, LED_PIN); - vTaskDelay(pdMS_TO_TICKS(INTERVAL_BLINK_ERROR_MS)); - } - } - - if(PDU_Mk1_CurrentSensing_Init() != true) - { - printf("FAIL:ISENSE_INIT\n"); - Error_Handler(); - } - - printf("Initialization complete.\n"); - - // get this party started - vTaskResume(blink_task); - vTaskResume(adc_read_task); - // task kills itself - vTaskDelete(NULL); -} - -// blink LED -void Blink_Task(void *argument) -{ - for(;;) - { - HAL_GPIO_TogglePin(LED_PORT, LED_PIN); - - vTaskDelay(pdMS_TO_TICKS(INTERVAL_BLINK_MS)); - } -} - -// read conversion from ADC and print to serial -void ADC_Read_Task(void *argument) -{ - // magic delay required to make things work for some reason - // otherwise FAIL:CONV_RESULTS_SNS1 - vTaskDelay(pdMS_TO_TICKS(1)); - - for(;;) - { - if(ADS131M08Q1_ReadConversionResults(&adc_sns0, adc_results_sns0) != ADS131M08Q1_🙂) - { - printf("FAIL:CONV_RESULTS_SNS0\n"); - Error_Handler(); - } - - printf("\nADC Conv Results (ADC_SNS0)\n----------\nCH0: %.4f V\nCH1: %.4f V\nCH2: %.4f V\nCH3: %.4f V\nCH4: %.4f V\nCH5: %.4f V\nCH6: %.4f V\nCH7: %.4f V\n", adc_results_sns0[0], adc_results_sns0[1], adc_results_sns0[2], adc_results_sns0[3], adc_results_sns0[4], adc_results_sns0[5], adc_results_sns0[6], adc_results_sns0[7]); - - if(ADS131M08Q1_ReadConversionResults(&adc_sns1, adc_results_sns1) != ADS131M08Q1_🙂) - { - printf("FAIL:CONV_RESULTS_SNS1\n"); - Error_Handler(); - } - - printf("\nADC Conv Results (ADC_SNS1)\n----------\nCH0: %.4f V\nCH1: %.4f V\nCH2: %.4f V\nCH3: %.4f V\nCH4: %.4f V\nCH5: %.4f V\nCH6: %.4f V\nCH7: %.4f V\n", adc_results_sns1[0], adc_results_sns1[1], adc_results_sns1[2], adc_results_sns1[3], adc_results_sns1[4], adc_results_sns1[5], adc_results_sns1[6], adc_results_sns1[7]); - - vTaskDelay(pdMS_TO_TICKS(INTERVAL_ADC_READ_MS)); - } -} - -// MAIN ----------------------------------------------------------------------- - -int main() -{ - HAL_Init(); - SystemClock_Config(); - - init_task = xTaskCreateStatic(Init_Task, - "Init Task", - TASKSTACKSIZE_INIT, - NULL, - TASKPRIORITY_INIT, - init_task_stack, - &init_task_buffer - ); - - blink_task = xTaskCreateStatic(Blink_Task, - "Blink Task", - TASKSTACKSIZE_BLINK, - NULL, - TASKPRIORITY_BLINK, - blink_task_stack, - &blink_task_buffer - ); - - adc_read_task = xTaskCreateStatic(ADC_Read_Task, - "ADC Read Task", - TASKSTACKSIZE_ADC_READ, - NULL, - TASKPRIORITY_ADC_READ, - adc_read_task_stack, - &adc_read_task_buffer - ); - - vTaskSuspend(blink_task); - vTaskSuspend(adc_read_task); - vTaskStartScheduler(); - - while(1) {} -} - -// ERROR HANDLER -------------------------------------------------------------- - -void Error_Handler(void) -{ - while(1) - { - HAL_GPIO_TogglePin(LED_PORT, LED_PIN); - vTaskDelay(pdMS_TO_TICKS(INTERVAL_BLINK_ERROR_MS)); - } -} diff --git a/firmware/PowerDistributionUnit_Mk1/test/src/ADS131M08Q1_LockUnlock_Status.c b/firmware/PowerDistributionUnit_Mk1/test/src/ADS131M08Q1_LockUnlock_Status.c deleted file mode 100644 index 008e1d6..0000000 --- a/firmware/PowerDistributionUnit_Mk1/test/src/ADS131M08Q1_LockUnlock_Status.c +++ /dev/null @@ -1,233 +0,0 @@ -// ADS131M08Q1_LockUnlock_Status.c -// ---------------------------------------------------------------------------- -// Locks and unlocks the ADC SPI interface for ADC_SNS1 on BBPDU Mk1. using -// their respective commands. Checks the LOCK bit in the status register to -// verify (un)locking is successful. - -// INCLUDES ------------------------------------------------------------------- - -#include "stm32xx_hal.h" -// stm32xx_hal.h contains includes for RTOS stuff. -#include -#include - -// BBPDU Peripherals -#include "PDU_Mk1_Pins.h" -#include "PDU_Mk1_SPI.h" -#include "PDU_Mk1_GPIO.h" -#include "PDU_Mk1_UART.h" -#include "PDU_Mk1_CurrentSensing.h" - -// drivers -#include "ADS131M08-Q1.h" - -// DEFINES -------------------------------------------------------------------- - -#define TASKPRIORITY_INIT tskIDLE_PRIORITY + 2 -#define TASKSTACKSIZE_INIT configMINIMAL_STACK_SIZE+1500 - -#define TASKPRIORITY_BLINK tskIDLE_PRIORITY + 2 -#define TASKSTACKSIZE_BLINK configMINIMAL_STACK_SIZE - -#define TASKPRIORITY_ADC_LOCKUNLOCK_STATUS tskIDLE_PRIORITY + 2 -#define TASKSTACKSIZE_ADC_LOCKUNLOCK_STATUS configMINIMAL_STACK_SIZE+200 - -#define INTERVAL_BLINK_MS 500 -#define INTERVAL_BLINK_ERROR_MS 50 -#define INTERVAL_ADC_LOCKUNLOCK_STATUS 500 - -#define ADS131M08Q1_STATUS_LOCK_MASK 0x8000 - -// DECLARATIONS --------------------------------------------------------------- - -SPI_HandleTypeDef hspi1; -SPI_HandleTypeDef hspi2; -SPI_HandleTypeDef hspi3; - -extern ADS131M08Q1_HandleTypeDef adc_sns1; - -SemaphoreHandle_t spi1_mutex; // Mutex to prevent simultaneous SPI access -StaticSemaphore_t spi1_mutex_buffer; // Static buffer for mutex allocation - -SemaphoreHandle_t spi1_done_sem; // Semaphore to signal SPI IT completion -StaticSemaphore_t spi1_done_sem_buffer; // Static buffer for completion semaphore - -SemaphoreHandle_t spi2_mutex; // Mutex to prevent simultaneous SPI access -StaticSemaphore_t spi2_mutex_buffer; // Static buffer for mutex allocation - -SemaphoreHandle_t spi2_done_sem; // Semaphore to signal SPI IT completion -StaticSemaphore_t spi2_done_sem_buffer; // Static buffer for completion semaphore - -SemaphoreHandle_t spi3_mutex; // Mutex to prevent simultaneous SPI access -StaticSemaphore_t spi3_mutex_buffer; // Static buffer for mutex allocation - -SemaphoreHandle_t spi3_done_sem; // Semaphore to signal SPI IT completion -StaticSemaphore_t spi3_done_sem_buffer; // Static buffer for completion semaphore - -TaskHandle_t init_task; -StaticTask_t init_task_buffer; -StackType_t init_task_stack[TASKSTACKSIZE_INIT]; - -TaskHandle_t blink_task; -StaticTask_t blink_task_buffer; -StackType_t blink_task_stack[TASKSTACKSIZE_BLINK]; - -TaskHandle_t adc_lock_unlock_status_task; -StaticTask_t adc_lock_unlock_status_task_buffer; -StackType_t adc_lock_unlock_status_task_stack[TASKSTACKSIZE_ADC_LOCKUNLOCK_STATUS]; - -// TASKS ---------------------------------------------------------------------- - -// initialize stuff -void Init_Task(void *argument) -{ - printf("Starting Initialization...\n"); - - PDU_Mk1_GPIO_Init(); - - if(PDU_Mk1_SPI2_ADC_Init() != true) - { - printf("FAIL:SPI_INIT\n"); - Error_Handler(); - } - - if(PDU_Mk1_UART_Printf_Init() != true) - { - printf("FAIL:UART_PRINTF_INIT\n"); - Error_Handler(); - } - - if(SPI_RTOS_Mutex_Semaphore_Setup(&spi2_mutex, &spi2_mutex_buffer, &spi2_done_sem, &spi2_done_sem_buffer) != true) - { - printf("FAIL:MUTEX_SEMAPHORE_INIT\n"); - Error_Handler(); - } - - // SPI dummy send because CLK pin initializes high even when configured low for some reason - if(SPI_Init_Dummy_Send(&hspi2, spi2_mutex, spi2_done_sem) != true) - { - printf("FAIL:SPI_INIT_DUMMY_SEND\n"); - Error_Handler(); - } - - if(PDU_Mk1_CurrentSensing_Init() != true) - { - printf("FAIL:ISENSE_INIT\n"); - Error_Handler(); - } - - printf("Initialization complete.\n"); - - // get this party started - vTaskResume(blink_task); - vTaskResume(adc_lock_unlock_status_task); - // task kills itself - vTaskDelete(NULL); -} - -// blink LED -void Blink_Task(void *argument) -{ - for(;;) - { - HAL_GPIO_TogglePin(LED_PORT, LED_PIN); - - vTaskDelay(pdMS_TO_TICKS(INTERVAL_BLINK_MS)); - } -} - -// lock and unlock ADC SPI interface, checking if successful by bit on STATUS register -void ADC_LockUnlock_Task(void *argument) -{ - uint16_t status = 0; - - for(;;) - { - if(ADS131M08Q1_Lock(&adc_sns1) == ADS131M08Q1_😢) - { - printf("FAIL:LOCK_CMD\n"); - Error_Handler(); - } - - ADS131M08Q1_ReadStatus(&adc_sns1, &status); - // validate SPI interface locked using STATUS bit - if(!(status & ADS131M08Q1_STATUS_LOCK_MASK)) - { - printf("FAIL:LOCK_STATUS\n"); - Error_Handler(); - } - printf("Lock successful.\n"); - - vTaskDelay(pdMS_TO_TICKS(INTERVAL_ADC_LOCKUNLOCK_STATUS)); - - if(ADS131M08Q1_Unlock(&adc_sns1) == ADS131M08Q1_😢) - { - printf("FAIL:UNLOCK_CMD\n"); - Error_Handler(); - } - - ADS131M08Q1_ReadStatus(&adc_sns1, &status); - // validate SPI interface unlocked using STATUS bit - if(status & ADS131M08Q1_STATUS_LOCK_MASK) - { - printf("FAIL:UNLOCK_STATUS\n"); - Error_Handler(); - } - printf("Unlock successful.\n"); - - vTaskDelay(pdMS_TO_TICKS(INTERVAL_ADC_LOCKUNLOCK_STATUS)); - } -} - -// MAIN ----------------------------------------------------------------------- - -int main() -{ - HAL_Init(); - SystemClock_Config(); - - init_task = xTaskCreateStatic(Init_Task, - "Init Task", - TASKSTACKSIZE_INIT, - NULL, - TASKPRIORITY_INIT, - init_task_stack, - &init_task_buffer - ); - - blink_task = xTaskCreateStatic(Blink_Task, - "Blink Task", - TASKSTACKSIZE_BLINK, - NULL, - TASKPRIORITY_BLINK, - blink_task_stack, - &blink_task_buffer - ); - - adc_lock_unlock_status_task = xTaskCreateStatic(ADC_LockUnlock_Task, - "ADC Standby Wakeup Task", - TASKSTACKSIZE_ADC_LOCKUNLOCK_STATUS, - NULL, - TASKPRIORITY_ADC_LOCKUNLOCK_STATUS, - adc_lock_unlock_status_task_stack, - &adc_lock_unlock_status_task_buffer - ); - - vTaskSuspend(blink_task); - vTaskSuspend(adc_lock_unlock_status_task); - vTaskStartScheduler(); - - while(1) {} -} - -// ERROR HANDLER -------------------------------------------------------------- - -void Error_Handler(void) -{ - __disable_irq(); - while(1) - { - HAL_GPIO_TogglePin(LED_PORT, LED_PIN); - vTaskDelay(pdMS_TO_TICKS(INTERVAL_BLINK_ERROR_MS)); - } -} diff --git a/firmware/PowerDistributionUnit_Mk1/test/src/ADS131M08Q1_StandbyWakeup.c b/firmware/PowerDistributionUnit_Mk1/test/src/ADS131M08Q1_StandbyWakeup.c deleted file mode 100644 index 9aa1bbd..0000000 --- a/firmware/PowerDistributionUnit_Mk1/test/src/ADS131M08Q1_StandbyWakeup.c +++ /dev/null @@ -1,213 +0,0 @@ -// ADS131M08Q1_StandbyWakeup.c -// ---------------------------------------------------------------------------- -// Puts ADC_SNS1 on BBPDU Mk. 1 in and out of standby. Verify this is -// successful by probing the ~DRDY pin using a logic analyzer. ~DRDY should -// stay high when in standby, and spend most of the time low otherwise. - -// INCLUDES ------------------------------------------------------------------- - -#include "stm32xx_hal.h" -// stm32xx_hal.h contains includes for RTOS stuff. -#include -#include - -// BBPDU Peripherals -#include "PDU_Mk1_Pins.h" -#include "PDU_Mk1_SPI.h" -#include "PDU_Mk1_GPIO.h" -#include "PDU_Mk1_UART.h" -#include "PDU_Mk1_CurrentSensing.h" - -// drivers -#include "ADS131M08-Q1.h" - -// DEFINES -------------------------------------------------------------------- - -#define TASKPRIORITY_INIT tskIDLE_PRIORITY + 2 -#define TASKSTACKSIZE_INIT configMINIMAL_STACK_SIZE+1500 - -#define TASKPRIORITY_BLINK tskIDLE_PRIORITY + 2 -#define TASKSTACKSIZE_BLINK configMINIMAL_STACK_SIZE - -#define TASKPRIORITY_ADC_STANDBYWAKEUP tskIDLE_PRIORITY + 2 -#define TASKSTACKSIZE_ADC_STANDBYWAKEUP configMINIMAL_STACK_SIZE - -#define INTERVAL_BLINK_MS 500 -#define INTERVAL_BLINK_ERROR_MS 50 -#define INTERVAL_ADC_STANDBYWAKEUP 500 - -// DECLARATIONS --------------------------------------------------------------- - -SPI_HandleTypeDef hspi1; -SPI_HandleTypeDef hspi2; -SPI_HandleTypeDef hspi3; - -extern ADS131M08Q1_HandleTypeDef adc_sns1; - -SemaphoreHandle_t spi1_mutex; // Mutex to prevent simultaneous SPI access -StaticSemaphore_t spi1_mutex_buffer; // Static buffer for mutex allocation - -SemaphoreHandle_t spi1_done_sem; // Semaphore to signal SPI IT completion -StaticSemaphore_t spi1_done_sem_buffer; // Static buffer for completion semaphore - -SemaphoreHandle_t spi2_mutex; // Mutex to prevent simultaneous SPI access -StaticSemaphore_t spi2_mutex_buffer; // Static buffer for mutex allocation - -SemaphoreHandle_t spi2_done_sem; // Semaphore to signal SPI IT completion -StaticSemaphore_t spi2_done_sem_buffer; // Static buffer for completion semaphore - -SemaphoreHandle_t spi3_mutex; // Mutex to prevent simultaneous SPI access -StaticSemaphore_t spi3_mutex_buffer; // Static buffer for mutex allocation - -SemaphoreHandle_t spi3_done_sem; // Semaphore to signal SPI IT completion -StaticSemaphore_t spi3_done_sem_buffer; // Static buffer for completion semaphore - -TaskHandle_t init_task; -StaticTask_t init_task_buffer; -StackType_t init_task_stack[TASKSTACKSIZE_INIT]; - -TaskHandle_t blink_task; -StaticTask_t blink_task_buffer; -StackType_t blink_task_stack[TASKSTACKSIZE_BLINK]; - -TaskHandle_t adc_standby_wakeup_task; -StaticTask_t adc_standby_wakeup_task_buffer; -StackType_t adc_standby_wakeup_task_stack[TASKSTACKSIZE_ADC_STANDBYWAKEUP]; - -// TASKS ---------------------------------------------------------------------- - -// initialize stuff -void Init_Task(void *argument) -{ - printf("Starting Initialization...\n"); - - PDU_Mk1_GPIO_Init(); - - if(PDU_Mk1_SPI2_ADC_Init() != true) - { - printf("FAIL:SPI_INIT\n"); - Error_Handler(); - } - - if(PDU_Mk1_UART_Printf_Init() != true) - { - printf("FAIL:UART_PRINTF_INIT\n"); - Error_Handler(); - } - - if(SPI_RTOS_Mutex_Semaphore_Setup(&spi2_mutex, &spi2_mutex_buffer, &spi2_done_sem, &spi2_done_sem_buffer) != true) - { - printf("FAIL:MUTEX_SEMAPHORE_INIT\n"); - Error_Handler(); - } - - // SPI dummy send because CLK pin initializes high even when configured low for some reason - if(SPI_Init_Dummy_Send(&hspi2, spi2_mutex, spi2_done_sem) != true) - { - printf("FAIL:SPI_INIT_DUMMY_SEND\n"); - Error_Handler(); - } - - if(PDU_Mk1_CurrentSensing_Init() != true) - { - printf("FAIL:ISENSE_INIT\n"); - Error_Handler(); - } - - printf("Initialization complete.\n"); - - // get this party started - vTaskResume(blink_task); - vTaskResume(adc_standby_wakeup_task); - // task kills itself - vTaskDelete(NULL); -} - -// blink LED -void Blink_Task(void *argument) -{ - for(;;) - { - HAL_GPIO_TogglePin(LED_PORT, LED_PIN); - - vTaskDelay(pdMS_TO_TICKS(INTERVAL_BLINK_MS)); - } -} - -// put ADC in and out of standby -void ADC_StandbyWakeup_Task(void *argument) -{ - for(;;) - { - if(ADS131M08Q1_Standby(&adc_sns1) == ADS131M08Q1_😢) - { - printf("FAIL:STANDBY_CMD\n"); - Error_Handler(); - } - printf("ADC in standby.\n"); - - vTaskDelay(pdMS_TO_TICKS(INTERVAL_ADC_STANDBYWAKEUP)); - - if(ADS131M08Q1_Wakeup(&adc_sns1) == ADS131M08Q1_😢) - { - printf("FAIL:WAKEUP_CMD\n"); - Error_Handler(); - } - printf("ADC out of standby.\n"); - - vTaskDelay(pdMS_TO_TICKS(INTERVAL_ADC_STANDBYWAKEUP)); - } -} - -// MAIN ----------------------------------------------------------------------- - -int main() -{ - HAL_Init(); - SystemClock_Config(); - - init_task = xTaskCreateStatic(Init_Task, - "Init Task", - TASKSTACKSIZE_INIT, - NULL, - TASKPRIORITY_INIT, - init_task_stack, - &init_task_buffer - ); - - blink_task = xTaskCreateStatic(Blink_Task, - "Blink Task", - TASKSTACKSIZE_BLINK, - NULL, - TASKPRIORITY_BLINK, - blink_task_stack, - &blink_task_buffer - ); - - adc_standby_wakeup_task = xTaskCreateStatic(ADC_StandbyWakeup_Task, - "ADC Standby Wakeup Task", - TASKSTACKSIZE_ADC_STANDBYWAKEUP, - NULL, - TASKPRIORITY_ADC_STANDBYWAKEUP, - adc_standby_wakeup_task_stack, - &adc_standby_wakeup_task_buffer - ); - - vTaskSuspend(blink_task); - vTaskSuspend(adc_standby_wakeup_task); - vTaskStartScheduler(); - - while(1) {} -} - -// ERROR HANDLER -------------------------------------------------------------- - -void Error_Handler(void) -{ - __disable_irq(); - while(1) - { - HAL_GPIO_TogglePin(LED_PORT, LED_PIN); - vTaskDelay(pdMS_TO_TICKS(INTERVAL_BLINK_ERROR_MS)); - } -} diff --git a/firmware/PowerDistributionUnit_Mk1/test/src/HSSControl.c b/firmware/PowerDistributionUnit_Mk1/test/src/HSSControl.c deleted file mode 100644 index cec3280..0000000 --- a/firmware/PowerDistributionUnit_Mk1/test/src/HSSControl.c +++ /dev/null @@ -1,292 +0,0 @@ -// HSSControl.c -// ---------------------------------------------------------------------------- -// Tests HSS control via shift register for output enable and fault latching. - -// INCLUDES ------------------------------------------------------------------- - -#include "stm32xx_hal.h" -// stm32xx_hal.h contains includes for RTOS stuff. -#include -#include - -// BBPDU Peripherals -#include "PDU_Mk1_Pins.h" -#include "PDU_Mk1_SPI.h" -#include "PDU_Mk1_GPIO.h" -#include "PDU_Mk1_UART.h" - -// drivers -#include "ShiftRegister_SPI.h" -#include "PDU_Mk1_HSSControl.h" - -// DEFINES -------------------------------------------------------------------- - -#define TASKPRIORITY_INIT tskIDLE_PRIORITY + 2 -#define TASKSTACKSIZE_INIT configMINIMAL_STACK_SIZE+1500 - -#define TASKPRIORITY_BLINK tskIDLE_PRIORITY + 2 -#define TASKSTACKSIZE_BLINK configMINIMAL_STACK_SIZE - -#define TASKPRIORITY_SR_WRITE tskIDLE_PRIORITY + 2 -#define TASKSTACKSIZE_SR_WRITE configMINIMAL_STACK_SIZE+1000 - -#define INTERVAL_BLINK_MS 500 -#define INTERVAL_BLINK_ERROR_MS 50 -#define INTERVAL_SR_WRITE_MS 60000 - -// DECLARATIONS --------------------------------------------------------------- - -SPI_HandleTypeDef hspi1; -SPI_HandleTypeDef hspi2; -SPI_HandleTypeDef hspi3; - -SemaphoreHandle_t spi1_mutex; // Mutex to prevent simultaneous SPI access -StaticSemaphore_t spi1_mutex_buffer; // Static buffer for mutex allocation - -SemaphoreHandle_t spi1_done_sem; // Semaphore to signal SPI IT completion -StaticSemaphore_t spi1_done_sem_buffer; // Static buffer for completion semaphore - -SemaphoreHandle_t spi2_mutex; // Mutex to prevent simultaneous SPI access -StaticSemaphore_t spi2_mutex_buffer; // Static buffer for mutex allocation - -SemaphoreHandle_t spi2_done_sem; // Semaphore to signal SPI IT completion -StaticSemaphore_t spi2_done_sem_buffer; // Static buffer for completion semaphore - -SemaphoreHandle_t spi3_mutex; // Mutex to prevent simultaneous SPI access -StaticSemaphore_t spi3_mutex_buffer; // Static buffer for mutex allocation - -SemaphoreHandle_t spi3_done_sem; // Semaphore to signal SPI IT completion -StaticSemaphore_t spi3_done_sem_buffer; // Static buffer for completion semaphore - -TaskHandle_t init_task; -StaticTask_t init_task_buffer; -StackType_t init_task_stack[TASKSTACKSIZE_INIT]; - -TaskHandle_t blink_task; -StaticTask_t blink_task_buffer; -StackType_t blink_task_stack[TASKSTACKSIZE_BLINK]; - -TaskHandle_t sr_write_task; -StaticTask_t sr_write_task_buffer; -StackType_t sr_write_task_stack[TASKSTACKSIZE_SR_WRITE]; - -extern HSSControl_FaultState_t HSS_fault_state[PDU_MK1_NUM_CHANNELS]; - -// TASKS ---------------------------------------------------------------------- - -// initialize stuff -void Init_Task(void *argument) -{ - printf("Starting Initialization...\n"); - - PDU_Mk1_GPIO_Init(); - - if(PDU_Mk1_SPI2_HSS_SR_Init() != true) - { - printf("FAIL:SPI_INIT\n"); - Error_Handler(); - } - - if(PDU_Mk1_UART_Printf_Init() != true) - { - printf("FAIL:UART_PRINTF_INIT\n"); - Error_Handler(); - } - - if(SPI_RTOS_Mutex_Semaphore_Setup(&spi2_mutex, &spi2_mutex_buffer, &spi2_done_sem, &spi2_done_sem_buffer) != true) - { - printf("FAIL:MUTEX_SEMAPHORE_INIT\n"); - Error_Handler(); - } - - // SPI dummy send because CLK pin initializes high even when configured low for some reason - if(SPI_Init_Dummy_Send(&hspi2, spi2_mutex, spi2_done_sem) != true) - { - printf("FAIL:SPI_INIT_DUMMY_SEND\n"); - Error_Handler(); - } - - PDU_Mk1_HSSControl_Init(); - - printf("Initialization complete.\n"); - - // get this party started - vTaskResume(blink_task); - vTaskResume(sr_write_task); - // task kills itself - vTaskDelete(NULL); -} - -// blink LED -void Blink_Task(void *argument) -{ - for(;;) - { - HAL_GPIO_TogglePin(LED_PORT, LED_PIN); - - vTaskDelay(pdMS_TO_TICKS(INTERVAL_BLINK_MS)); - } -} - -// read conversion from ADC and print to serial -void SR_Write_Task(void *argument) -{ - HSS_fault_state[7] = HSSCONTROL_FAULT_HSS_TRIP; - - for(;;) - { - // [0] [15] - // expected EN: 0010 0011 0100 0010 (note: depends on PDU_Mk1_OutputConfig.h) - PDU_Mk1_HSSControl_CritOnly(); - - // expected LATCH: 1111 1111 1111 1111 - - vTaskDelay(pdMS_TO_TICKS(INTERVAL_SR_WRITE_MS)); - - // expected EN: 1111 1111 1111 1111 - PDU_Mk1_HSSControl_AllOn(); - - // expected LATCH: 1111 0111 1011 1111 - PDU_Mk1_HSSControl_WriteLatch_Ch(PDU_OUTPUT_2, HSSCONTROL_LATCH_NOCHANGE); - PDU_Mk1_HSSControl_WriteLatch_Ch(PDU_OUTPUT_4, HSSCONTROL_UNLATCHFAULT_AUTORETRY); - PDU_Mk1_HSSControl_WriteLatch_Ch(PDU_OUTPUT_6, HSSCONTROL_LATCHFAULT_STAYOFF); - PDU_Mk1_HSSControl_WriteLatch_Ch(PDU_OUTPUT_9, HSSCONTROL_UNLATCHFAULT_AUTORETRY); - - vTaskDelay(pdMS_TO_TICKS(INTERVAL_SR_WRITE_MS)); - - // expected EN: 0000 0000 0000 0000 - PDU_Mk1_HSSControl_AllOff(); - - // expected LATCH: 1111 1101 1011 1111 - PDU_Mk1_HSSControl_WriteLatch_Ch(PDU_OUTPUT_2, HSSCONTROL_LATCH_NOCHANGE); - PDU_Mk1_HSSControl_WriteLatch_Ch(PDU_OUTPUT_4, HSSCONTROL_LATCHFAULT_STAYOFF); - PDU_Mk1_HSSControl_WriteLatch_Ch(PDU_OUTPUT_6, HSSCONTROL_UNLATCHFAULT_AUTORETRY); - PDU_Mk1_HSSControl_WriteLatch_Ch(PDU_OUTPUT_9, HSSCONTROL_LATCH_NOCHANGE); - - vTaskDelay(pdMS_TO_TICKS(INTERVAL_SR_WRITE_MS)); - - // expected EN: 0100 0000 1010 0001 - PDU_Mk1_HSSControl_WriteOutputEN_Ch(PDU_OUTPUT_1, HSSCONTROL_EN_ON); - PDU_Mk1_HSSControl_WriteOutputEN_Ch(PDU_OUTPUT_8, HSSCONTROL_EN_ON); - PDU_Mk1_HSSControl_WriteOutputEN_Ch(PDU_OUTPUT_10, HSSCONTROL_EN_TOGGLE); - PDU_Mk1_HSSControl_WriteOutputEN_Ch(PDU_OUTPUT_11, HSSCONTROL_EN_OFF); - PDU_Mk1_HSSControl_WriteOutputEN_Ch(PDU_OUTPUT_15, HSSCONTROL_EN_ON); - - // expected LATCH: 1111 1100 1010 1111 - PDU_Mk1_HSSControl_OutputFaultRetry_Ch(PDU_OUTPUT_11); - PDU_Mk1_HSSControl_OutputFaultRelatch_Ch(PDU_OUTPUT_12); - PDU_Mk1_HSSControl_OutputFaultRetry_AllFaulted(); - - vTaskDelay(pdMS_TO_TICKS(INTERVAL_SR_WRITE_MS)); - - // expected EN: 0000 0000 0111 0001 - PDU_Mk1_HSSControl_WriteOutputEN_Ch(PDU_OUTPUT_1, HSSCONTROL_EN_OFF); - PDU_Mk1_HSSControl_WriteOutputEN_Ch(PDU_OUTPUT_8, HSSCONTROL_EN_TOGGLE); - PDU_Mk1_HSSControl_WriteOutputEN_Ch(PDU_OUTPUT_9, HSSCONTROL_EN_TOGGLE); - PDU_Mk1_HSSControl_WriteOutputEN_Ch(PDU_OUTPUT_11, HSSCONTROL_EN_ON); - PDU_Mk1_HSSControl_WriteOutputEN_Ch(PDU_OUTPUT_15, HSSCONTROL_EN_NOCHANGE); - - // expected LATCH: 1111 1101 1011 0111 - PDU_Mk1_HSSControl_OutputFaultRelatch_Ch(PDU_OUTPUT_11); - PDU_Mk1_HSSControl_OutputFaultRetry_Ch(PDU_OUTPUT_12); - PDU_Mk1_HSSControl_OutputFaultRelatch_AllFaulted(); - - vTaskDelay(pdMS_TO_TICKS(INTERVAL_SR_WRITE_MS)); - - // expected EN: 1010 0101 1010 1100 - HSSControl_EnState_t en_actions[PDU_MK1_NUM_CHANNELS] = { - HSSCONTROL_EN_ON, - HSSCONTROL_EN_NOCHANGE, - HSSCONTROL_EN_TOGGLE, - HSSCONTROL_EN_NOCHANGE, - HSSCONTROL_EN_OFF, - HSSCONTROL_EN_ON, - HSSCONTROL_EN_OFF, - HSSCONTROL_EN_TOGGLE, - HSSCONTROL_EN_TOGGLE, - HSSCONTROL_EN_OFF, - HSSCONTROL_EN_ON, - HSSCONTROL_EN_TOGGLE, - HSSCONTROL_EN_ON, - HSSCONTROL_EN_ON, - HSSCONTROL_EN_OFF, - HSSCONTROL_EN_OFF - }; - PDU_Mk1_HSSControl_WriteOutputEN_All(en_actions); - - // expected LATCH: 1000 1101 1101 0001 - HSSControl_LatchState_t latch_states[PDU_MK1_NUM_CHANNELS] = { - HSSCONTROL_LATCH_NOCHANGE, - HSSCONTROL_UNLATCHFAULT_AUTORETRY, - HSSCONTROL_UNLATCHFAULT_AUTORETRY, - HSSCONTROL_UNLATCHFAULT_AUTORETRY, - HSSCONTROL_LATCH_NOCHANGE, - HSSCONTROL_LATCH_NOCHANGE, - HSSCONTROL_UNLATCHFAULT_AUTORETRY, - HSSCONTROL_LATCHFAULT_STAYOFF, - HSSCONTROL_LATCHFAULT_STAYOFF, - HSSCONTROL_LATCHFAULT_STAYOFF, - HSSCONTROL_UNLATCHFAULT_AUTORETRY, - HSSCONTROL_LATCHFAULT_STAYOFF, - HSSCONTROL_UNLATCHFAULT_AUTORETRY, - HSSCONTROL_UNLATCHFAULT_AUTORETRY, - HSSCONTROL_UNLATCHFAULT_AUTORETRY, - HSSCONTROL_LATCHFAULT_STAYOFF - }; - PDU_Mk1_HSSControl_WriteLatch_All(latch_states); - - vTaskDelay(pdMS_TO_TICKS(INTERVAL_SR_WRITE_MS)); - } -} - -// MAIN ----------------------------------------------------------------------- - -int main() -{ - HAL_Init(); - SystemClock_Config(); - - init_task = xTaskCreateStatic(Init_Task, - "Init Task", - TASKSTACKSIZE_INIT, - NULL, - TASKPRIORITY_INIT, - init_task_stack, - &init_task_buffer - ); - - blink_task = xTaskCreateStatic(Blink_Task, - "Blink Task", - TASKSTACKSIZE_BLINK, - NULL, - TASKPRIORITY_BLINK, - blink_task_stack, - &blink_task_buffer - ); - - sr_write_task = xTaskCreateStatic(SR_Write_Task, - "SR Write Task", - TASKSTACKSIZE_SR_WRITE, - NULL, - TASKPRIORITY_SR_WRITE, - sr_write_task_stack, - &sr_write_task_buffer - ); - - vTaskSuspend(blink_task); - vTaskSuspend(sr_write_task); - vTaskStartScheduler(); - - while(1) {} -} - -// ERROR HANDLER -------------------------------------------------------------- - -void Error_Handler(void) -{ - while(1) - { - HAL_GPIO_TogglePin(LED_PORT, LED_PIN); - vTaskDelay(pdMS_TO_TICKS(INTERVAL_BLINK_ERROR_MS)); - } -} diff --git a/firmware/PowerDistributionUnit_Mk1/test/src/Test_CAN.c b/firmware/PowerDistributionUnit_Mk1/test/src/Test_CAN.c new file mode 100644 index 0000000..1eec74c --- /dev/null +++ b/firmware/PowerDistributionUnit_Mk1/test/src/Test_CAN.c @@ -0,0 +1,151 @@ +// Test_CAN.c +// ---------------------------------------------------------------------------- +// Transmits CAN status message with output channel state, current +// measurements. +// Prerequisites: CurrentSensing, HSSControl + +// INCLUDES ------------------------------------------------------------------- + +#include "stm32xx_hal.h" +// stm32xx_hal.h contains includes for RTOS stuff. +#include +#include + +// Tasks +#include "Task_Init.h" +#include "Task_Blink.h" +#include "Task_ReadCurrents.h" +#include "Task_HSSControl.h" +#include "Task_CanSendStatus.h" + +// DEFINES -------------------------------------------------------------------- + +#define INTERVAL_BLINK_ERROR_MS 50 + +// DECLARATIONS --------------------------------------------------------------- + +// SPI1 +SPI_HandleTypeDef hspi1; // Handle +SemaphoreHandle_t spi1_mutex; // Mutex to prevent simultaneous SPI access +StaticSemaphore_t spi1_mutex_buffer; // SPI mutex buffer +SemaphoreHandle_t spi1_done_sem; // Semaphore to signal SPI IT completion +StaticSemaphore_t spi1_done_sem_buffer; // SPI completion sempahore buffer + +// SPI2 +SPI_HandleTypeDef hspi2; +SemaphoreHandle_t spi2_mutex; +StaticSemaphore_t spi2_mutex_buffer; +SemaphoreHandle_t spi2_done_sem; +StaticSemaphore_t spi2_done_sem_buffer; + +// SPI3 +SPI_HandleTypeDef hspi3; +SemaphoreHandle_t spi3_mutex; +StaticSemaphore_t spi3_mutex_buffer; +SemaphoreHandle_t spi3_done_sem; +StaticSemaphore_t spi3_done_sem_buffer; + +// Task: Init +TaskHandle_t init_task; +StaticTask_t init_task_buffer; // Task buffer +StackType_t init_task_stack[TASK_INIT_STACK_SIZE]; // Task stack + +// Task: Blink +TaskHandle_t task_blink; +StaticTask_t task_blink_buffer; +StackType_t task_blink_stack[TASK_BLINK_STACK_SIZE]; + +// Task: Read Currents +TaskHandle_t task_readcurrents; +StaticTask_t task_readcurrents_buffer; +StackType_t task_readcurrents_stack[TASK_READCURRENTS_STACK_SIZE]; + +// Task: HSS Output Control +TaskHandle_t task_hsscontrol; +StaticTask_t task_hsscontrol_buffer; +StackType_t task_hsscontrol_stack[TASK_HSSCONTROL_STACK_SIZE]; + +// Task: Send CAN Status +TaskHandle_t task_cansendstatus; +StaticTask_t task_cansendstatus_buffer; +StackType_t task_cansendstatus_stack[TASK_CANSENDSTATUS_STACK_SIZE]; + +// MAIN ----------------------------------------------------------------------- + +int main() +{ + HAL_Init(); + SystemClock_Config(); + + init_task = xTaskCreateStatic(Task_Init, + "Init Task", + TASK_INIT_STACK_SIZE, + NULL, + TASK_INIT_PRIORITY, + init_task_stack, + &init_task_buffer + ); + + task_blink = xTaskCreateStatic(Task_Blink, + "Blink Task", + TASK_BLINK_STACK_SIZE, + NULL, + TASK_BLINK_PRIORITY, + task_blink_stack, + &task_blink_buffer + ); + + task_readcurrents = xTaskCreateStatic(Task_ReadCurrents, + "Current Sense Task", + TASK_READCURRENTS_STACK_SIZE, + NULL, + TASK_READCURRENTS_PRIORITY, + task_readcurrents_stack, + &task_readcurrents_buffer + ); + + task_hsscontrol = xTaskCreateStatic(Task_HSSControl, + "HSS Control Task", + TASK_HSSCONTROL_STACK_SIZE, + NULL, + TASK_HSSCONTROL_PRIORITY, + task_hsscontrol_stack, + &task_hsscontrol_buffer + ); + + task_cansendstatus = xTaskCreateStatic(Task_CanSendStatus, + "CAN Send Status task", + TASK_CANSENDSTATUS_STACK_SIZE, + NULL, + TASK_CANSENDSTATUS_PRIORITY, + task_cansendstatus_stack, + &task_cansendstatus_buffer + ); + + vTaskSuspend(task_blink); + vTaskSuspend(task_readcurrents); + vTaskSuspend(task_hsscontrol); + vTaskSuspend(task_cansendstatus); + vTaskStartScheduler(); + + while(1) {} +} + +void PDU_Mk1_StartTasks() +{ + vTaskResume(task_blink); + vTaskResume(task_readcurrents); + vTaskResume(task_hsscontrol); + vTaskResume(task_cansendstatus); +} + +// ERROR HANDLER -------------------------------------------------------------- + +void Error_Handler(void) +{ + while(1) + { + HAL_GPIO_TogglePin(LED_PORT, LED_PIN); + vTaskDelay(pdMS_TO_TICKS(INTERVAL_BLINK_ERROR_MS)); + } +} diff --git a/firmware/PowerDistributionUnit_Mk1/test/src/Test_CurrentSensing.c b/firmware/PowerDistributionUnit_Mk1/test/src/Test_CurrentSensing.c new file mode 100644 index 0000000..afed688 --- /dev/null +++ b/firmware/PowerDistributionUnit_Mk1/test/src/Test_CurrentSensing.c @@ -0,0 +1,118 @@ +// Test_CurrentSensing.c +// ---------------------------------------------------------------------------- +// Tests current sensing thorugh ADCs and hall-effect current sensors. Prints +// to UART. (Make sure PDU_MK1_PRINT_STATUS_VIA_UART is set to true in +// PDU_Mk1.h) +// Prerequisites: ACS_Current_Sensing + +// INCLUDES ------------------------------------------------------------------- + +#include "stm32xx_hal.h" +// stm32xx_hal.h contains includes for RTOS stuff. +#include +#include + +// Tasks +#include "Task_Init.h" +#include "Task_Blink.h" +#include "Task_ReadCurrents.h" + +// DEFINES -------------------------------------------------------------------- + +#define INTERVAL_BLINK_ERROR_MS 50 + +// DECLARATIONS --------------------------------------------------------------- + +// SPI1 +SPI_HandleTypeDef hspi1; // Handle +SemaphoreHandle_t spi1_mutex; // Mutex to prevent simultaneous SPI access +StaticSemaphore_t spi1_mutex_buffer; // SPI mutex buffer +SemaphoreHandle_t spi1_done_sem; // Semaphore to signal SPI IT completion +StaticSemaphore_t spi1_done_sem_buffer; // SPI completion sempahore buffer + +// SPI2 +SPI_HandleTypeDef hspi2; +SemaphoreHandle_t spi2_mutex; +StaticSemaphore_t spi2_mutex_buffer; +SemaphoreHandle_t spi2_done_sem; +StaticSemaphore_t spi2_done_sem_buffer; + +// SPI3 +SPI_HandleTypeDef hspi3; +SemaphoreHandle_t spi3_mutex; +StaticSemaphore_t spi3_mutex_buffer; +SemaphoreHandle_t spi3_done_sem; +StaticSemaphore_t spi3_done_sem_buffer; + +// Task: Init +TaskHandle_t init_task; +StaticTask_t init_task_buffer; // Task buffer +StackType_t init_task_stack[TASK_INIT_STACK_SIZE]; // Task stack + +// Task: Blink +TaskHandle_t task_blink; +StaticTask_t task_blink_buffer; +StackType_t task_blink_stack[TASK_BLINK_STACK_SIZE]; + +// Task: Read Currents +TaskHandle_t task_readcurrents; +StaticTask_t task_readcurrents_buffer; +StackType_t task_readcurrents_stack[TASK_READCURRENTS_STACK_SIZE]; + +// MAIN ----------------------------------------------------------------------- + +int main() +{ + HAL_Init(); + SystemClock_Config(); + + init_task = xTaskCreateStatic(Task_Init, + "Init Task", + TASK_INIT_STACK_SIZE, + NULL, + TASK_INIT_PRIORITY, + init_task_stack, + &init_task_buffer + ); + + task_blink = xTaskCreateStatic(Task_Blink, + "Blink Task", + TASK_BLINK_STACK_SIZE, + NULL, + TASK_BLINK_PRIORITY, + task_blink_stack, + &task_blink_buffer + ); + + task_readcurrents = xTaskCreateStatic(Task_ReadCurrents, + "Current Sense Task", + TASK_READCURRENTS_STACK_SIZE, + NULL, + TASK_READCURRENTS_PRIORITY, + task_readcurrents_stack, + &task_readcurrents_buffer + ); + + vTaskSuspend(task_blink); + vTaskSuspend(task_readcurrents); + vTaskStartScheduler(); + + while(1) {} +} + +void PDU_Mk1_StartTasks() +{ + vTaskResume(task_blink); + vTaskResume(task_readcurrents); +} + +// ERROR HANDLER -------------------------------------------------------------- + +void Error_Handler(void) +{ + while(1) + { + HAL_GPIO_TogglePin(LED_PORT, LED_PIN); + vTaskDelay(pdMS_TO_TICKS(INTERVAL_BLINK_ERROR_MS)); + } +} diff --git a/firmware/PowerDistributionUnit_Mk1/test/src/Test_HSSControl.c b/firmware/PowerDistributionUnit_Mk1/test/src/Test_HSSControl.c new file mode 100644 index 0000000..1fa3ec3 --- /dev/null +++ b/firmware/PowerDistributionUnit_Mk1/test/src/Test_HSSControl.c @@ -0,0 +1,115 @@ +// Test_HSSControl.c +// ---------------------------------------------------------------------------- +// Runs HSSControl task (which just turns all outputs on for now). + +// INCLUDES ------------------------------------------------------------------- + +#include "stm32xx_hal.h" +// stm32xx_hal.h contains includes for RTOS stuff. +#include +#include + +// Tasks +#include "Task_Init.h" +#include "Task_Blink.h" +#include "Task_HSSControl.h" + +// DEFINES -------------------------------------------------------------------- + +#define INTERVAL_BLINK_ERROR_MS 50 + +// DECLARATIONS --------------------------------------------------------------- + +// SPI1 +SPI_HandleTypeDef hspi1; // Handle +SemaphoreHandle_t spi1_mutex; // Mutex to prevent simultaneous SPI access +StaticSemaphore_t spi1_mutex_buffer; // SPI mutex buffer +SemaphoreHandle_t spi1_done_sem; // Semaphore to signal SPI IT completion +StaticSemaphore_t spi1_done_sem_buffer; // SPI completion sempahore buffer + +// SPI2 +SPI_HandleTypeDef hspi2; +SemaphoreHandle_t spi2_mutex; +StaticSemaphore_t spi2_mutex_buffer; +SemaphoreHandle_t spi2_done_sem; +StaticSemaphore_t spi2_done_sem_buffer; + +// SPI3 +SPI_HandleTypeDef hspi3; +SemaphoreHandle_t spi3_mutex; +StaticSemaphore_t spi3_mutex_buffer; +SemaphoreHandle_t spi3_done_sem; +StaticSemaphore_t spi3_done_sem_buffer; + +// Task: Init +TaskHandle_t init_task; +StaticTask_t init_task_buffer; // Task buffer +StackType_t init_task_stack[TASK_INIT_STACK_SIZE]; // Task stack + +// Task: Blink +TaskHandle_t task_blink; +StaticTask_t task_blink_buffer; +StackType_t task_blink_stack[TASK_BLINK_STACK_SIZE]; + +// Task: HSS Output Control +TaskHandle_t task_hsscontrol; +StaticTask_t task_hsscontrol_buffer; +StackType_t task_hsscontrol_stack[TASK_HSSCONTROL_STACK_SIZE]; + +// MAIN ----------------------------------------------------------------------- + +int main() +{ + HAL_Init(); + SystemClock_Config(); + + init_task = xTaskCreateStatic(Task_Init, + "Init Task", + TASK_INIT_STACK_SIZE, + NULL, + TASK_INIT_PRIORITY, + init_task_stack, + &init_task_buffer + ); + + task_blink = xTaskCreateStatic(Task_Blink, + "Blink Task", + TASK_BLINK_STACK_SIZE, + NULL, + TASK_BLINK_PRIORITY, + task_blink_stack, + &task_blink_buffer + ); + + task_hsscontrol = xTaskCreateStatic(Task_HSSControl, + "HSS Control Task", + TASK_HSSCONTROL_STACK_SIZE, + NULL, + TASK_HSSCONTROL_PRIORITY, + task_hsscontrol_stack, + &task_hsscontrol_buffer + ); + + vTaskSuspend(task_blink); + vTaskSuspend(task_hsscontrol); + vTaskStartScheduler(); + + while(1) {} +} + +void PDU_Mk1_StartTasks() +{ + vTaskResume(task_blink); + vTaskResume(task_hsscontrol); +} + +// ERROR HANDLER -------------------------------------------------------------- + +void Error_Handler(void) +{ + while(1) + { + HAL_GPIO_TogglePin(LED_PORT, LED_PIN); + vTaskDelay(pdMS_TO_TICKS(INTERVAL_BLINK_ERROR_MS)); + } +} diff --git a/firmware/PowerDistributionUnit_Mk1/test/src/LSOM_Blinky_Printy.c b/firmware/PowerDistributionUnit_Mk1/test/src/Test_LSOM_BlinkyPrinty.c similarity index 100% rename from firmware/PowerDistributionUnit_Mk1/test/src/LSOM_Blinky_Printy.c rename to firmware/PowerDistributionUnit_Mk1/test/src/Test_LSOM_BlinkyPrinty.c