diff --git a/CMakeLists.txt b/CMakeLists.txt index 3907e43..6aeb086 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -16,7 +16,8 @@ set(CPU_PARAMETERS -mfloat-abi=hard ) -set(STARTUP_SCRIPT ${CMAKE_CURRENT_SOURCE_DIR}/MX/H753ZIT6/startup_stm32h753xx.S) +set(STARTUP_SCRIPT ${CMAKE_CURRENT_SOURCE_DIR}/MX/H753ZIT6/startup_stm32h753xx.S + SHAL/Src/User_Config.h) set(MCU_LINKER_SCRIPT ${CMAKE_CURRENT_SOURCE_DIR}/MX/H753ZIT6/stm32h753zitx_flash.ld) set(EXECUTABLE ${CMAKE_PROJECT_NAME}) @@ -40,8 +41,6 @@ set(PROJECT_INCLUDE_DIRECTORIES SHAL/Include/Peripheral/I2C SHAL/Include/Peripheral/I2C/Reg -SHAL/Include/Peripheral/ADC -SHAL/Include/Peripheral/ADC/Reg SHAL/Include/Peripheral/EXT SHAL/Include/Peripheral/EXT/Reg ]]# @@ -52,6 +51,9 @@ SHAL/Include/Peripheral/EXT/Reg SHAL/Include/Peripheral/Timer/Reg SHAL/Include/Peripheral/UART SHAL/Include/Peripheral/UART/Reg + SHAL/Include/Peripheral/ADC + SHAL/Include/Peripheral/ADC/Reg + SHAL/Src ${CMAKE_CURRENT_SOURCE_DIR}/SHAL/Include ) @@ -67,6 +69,7 @@ file(GLOB_RECURSE PROJECT_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/SHAL/Src/${MCU_FAMILY}/Peripheral/GPIO/*.cpp ${CMAKE_CURRENT_SOURCE_DIR}/SHAL/Src/${MCU_FAMILY}/Peripheral/Timer/*.cpp ${CMAKE_CURRENT_SOURCE_DIR}/SHAL/Src/${MCU_FAMILY}/Peripheral/UART/*.cpp + ${CMAKE_CURRENT_SOURCE_DIR}/SHAL/Src/${MCU_FAMILY}/Peripheral/ADC/*.cpp ${CMAKE_CURRENT_SOURCE_DIR}/SHAL/Src/${MCU_FAMILY}/Core/*.cpp ) diff --git a/SHAL/Include/Core/SHAL_CORE.h b/SHAL/Include/Core/SHAL_CORE.h index 9444dbc..76e8142 100644 --- a/SHAL/Include/Core/SHAL_CORE.h +++ b/SHAL/Include/Core/SHAL_CORE.h @@ -76,12 +76,22 @@ bool SHAL_wait_for_condition_ms(Condition cond, uint32_t timeout_ms) { return false; // timeout } +bool SHAL_check_bit(const volatile uint32_t* reg, uint32_t mask); + +bool SHAL_wait_for_bit_set_us(const volatile uint32_t* reg, uint32_t mask, uint16_t timeout); + +bool SHAL_wait_for_bit_clear_us(const volatile uint32_t* reg, uint32_t mask, uint16_t timeout); + +bool SHAL_wait_for_bit_set_ms(const volatile uint32_t* reg, uint32_t mask, uint16_t timeout); + +bool SHAL_wait_for_bit_clear_ms(const volatile uint32_t* reg, uint32_t mask, uint16_t timeout); + #define SHAL_set_bits(reg, size, bits, offset) \ do { \ if ((reg) != NULL) { \ - uint32_t _mask = ((1U << (size)) - 1U); \ + uint32_t _mask = (size == 32) ? 0xFFFFFFFFU : ((1U << (size)) - 1U); \ *(reg) &= ~((uint32_t)(_mask) << (offset)); \ *(reg) |= ((uint32_t)(bits) << (offset)); \ } \ @@ -115,6 +125,13 @@ bool SHAL_wait_for_condition_ms(Condition cond, uint32_t timeout_ms) { *(reg) |= (mask); \ } while (0) +#define SHAL_clear_register_value(reg) \ + do { \ + if ((reg) != NULL) { \ + *(reg) = 0; \ + } \ + } while (0) + #define SHAL_set_register_value(reg, value) \ do { \ if ((reg) != NULL) { \ diff --git a/SHAL/Include/Peripheral/ADC/Reg/SHAL_ADC_REG_H753ZI.h b/SHAL/Include/Peripheral/ADC/Reg/SHAL_ADC_REG_H753ZI.h new file mode 100644 index 0000000..d31f058 --- /dev/null +++ b/SHAL/Include/Peripheral/ADC/Reg/SHAL_ADC_REG_H753ZI.h @@ -0,0 +1,213 @@ +// +// Created by Luca on 10/8/2025. +// + +#ifndef SHMINGO_HAL_SHAL_ADC_REG_H753ZI_H +#define SHMINGO_HAL_SHAL_ADC_REG_H753ZI_H + +#include "SHAL_CORE.h" +#include "SHAL_ADC_TYPES.h" +#include "stm32h753xx.h" + +#define SHAL_ADC1 SHAL_ADC(1) +#define SHAL_ADC2 SHAL_ADC(2) +#define SHAL_ADC3 SHAL_ADC(3) + +#define NUM_ADCS 3 +#define NUM_ADC_CHANNELS 16 + +enum class SHAL_ADC_Channel : uint32_t { + CH0 = 0, + CH1, + CH2, + CH3, + CH4, + CH5, + CH6, + CH7, + CH8, + CH9, + CH10, + CH11, + CH12, + CH13, + CH14, + CH15, + CH16, + CH17, + CH18, + CHTemp, + CHRef, + CHBat, + NO_ADC_MAPPING +}; + +enum class ADC_Key : uint8_t{ + S_ADC1 = 0, + S_ADC2 = 1, + S_ADC3 = 2, + NUM_ADC = 3, + INVALID = 255 +}; + +enum class SHAL_ADC_Resolution : uint8_t { //TODO figure out what to do with this difference + B16 = 0x00, + B14 = 0x01, + B12 = 0x02, + B10 = 0x03, + B8 = 0x04, + B6 = 0x05, +}; + +enum class SHAL_ADC_Clock_Mode { + ASYNC = 0x00, + SYNC_BY_1 = 0x01, + SYNC_BY_2 = 0x02, + SYNC_BY_4 = 0x03, +}; + + +static volatile ADC_TypeDef* ADC_TABLE[3] = { //Lookup table for ADCs + ADC1, + ADC2, + ADC3, +}; + +static volatile ADC_Common_TypeDef* ADC_CCR_TABLE[3] = { //Common registers + ADC12_COMMON, //1 and 2 share a common register + ADC12_COMMON, + ADC3_COMMON, +}; + +enum class ADC_Clock_Source : uint32_t { + SHAL_NO_CLOCK = 0x00, + SHAL_PLLSAI1 = 0x01, + SHAL_PLLSYS = 0x02, + SHAL_SYSCLK = 0x03, +}; + +static SHAL_ADC_Common_Control_Reg getADCCommonControl(ADC_Key key) { + + SHAL_ADC_Common_Control_Reg res = { + .reg = nullptr, + .VoltageRefEnable = ADC_CCR_VREFEN, + .TempSensorEnable = ADC_CCR_TSEN, + .VBatteryEnable = ADC_CCR_VBATEN, + .clock_mode_position = ADC_CCR_CKMODE_Pos + }; + + res.reg = &ADC_CCR_TABLE[static_cast(key)]->CCR; + return res; +} + +static inline SHAL_ADC_RCC_Enable_Reg getADCRCCEnableRegister(const ADC_Key key){ + switch (key) { + case ADC_Key::S_ADC1: + case ADC_Key::S_ADC2: + return {&RCC->AHB1ENR, RCC_AHB1ENR_ADC12EN}; + case ADC_Key::S_ADC3: + return {&RCC->AHB4ENR, RCC_AHB4ENR_ADC3EN}; + default: + __builtin_unreachable(); + } +} + +static inline SHAL_ADC_Control_Reg getADCControlReg(ADC_Key key) { + + SHAL_ADC_Control_Reg res = {nullptr, ADC_CR_ADEN, + ADC_CR_ADSTP, + ADC_CR_ADDIS, + ADC_CR_ADCAL, + ADC_CR_ADSTART, + ADC_CR_DEEPPWD, + ADC_CR_ADVREGEN, + ADC_CR_ADCALDIF}; + + res.reg = &(ADC_TABLE[static_cast(key)]->CR); + return res; +} + +static inline SHAL_ADC_Config_Reg getADCConfigReg(ADC_Key key) { + + //NOTE offset of 33 means the function is deprecated + SHAL_ADC_Config_Reg res = {nullptr, + ADC_CFGR_CONT, + ADC_CFGR_RES_Pos, + 0, //TODO 0 is broken, shouldnt have alignment + ADC_CFGR_CONT_Msk + }; + + res.reg = &(ADC_TABLE[static_cast(key)]->CFGR); + return res; +} + +static inline SHAL_ADC_ISR_Reg getADCISRReg(ADC_Key key){ + SHAL_ADC_ISR_Reg res = {nullptr, + ADC_ISR_EOC, + ADC_ISR_EOS, + ADC_ISR_ADRDY, + ADC_ISR_OVR, + ADC_ISR_LDORDY}; + + res.reg = &(ADC_TABLE[static_cast(key)]->ISR); + return res; +} + +static inline SHAL_ADC_Data_Reg getADCDataReg(ADC_Key key){ + SHAL_ADC_Data_Reg res = {nullptr, 0xFFFF}; + + res.reg = &(ADC_TABLE[static_cast(key)]->DR); + return res; +} + +static inline SHAL_ADC_Channel_Sampling_Time_Reg getADCChannelSamplingTimeRegister(ADC_Key key, SHAL_ADC_Channel channel){ + volatile ADC_TypeDef* ADCReg = ADC_TABLE[static_cast(key)]; + + volatile uint32_t* SMPReg = nullptr; + uint32_t pos; + + auto channelNum = static_cast(channel); + + if (channelNum <= 9) { + SMPReg = &ADCReg->SMPR1; + pos = (channelNum * 3); + } else { + SMPReg = &ADCReg->SMPR2; + pos = ((channelNum - 10) * 3); + } + + return {SMPReg, pos}; +} + +static inline SHAL_ADC_Sequence_Amount_Reg getADCSequenceAmountRegister(ADC_Key key){ + SHAL_ADC_Sequence_Amount_Reg res = {nullptr, ADC_SQR1_L_Pos}; + + res.reg = &(ADC_TABLE[static_cast(key)]->SQR1); + return res; +} + +static SHAL_ADC_Sequence_Reg getADCSequenceRegister(ADC_Key key, uint32_t conversionNum){ + + volatile ADC_TypeDef* adc_reg = ADC_TABLE[static_cast(key)]; + + volatile uint32_t* sqr[4] = {&adc_reg->SQR1, + &adc_reg->SQR2, + &adc_reg->SQR3, + &adc_reg->SQR4, + }; + + const uint8_t sqrIndex = conversionNum / 5; //CONVERSION NUM STARTS AT 1! AS PER DATASHEET REFERENCING IT AS SQ1 + const uint32_t offset = (((conversionNum) % 5) * 6); + + return {sqr[sqrIndex], offset}; +} + +static SHAL_ADC_Preselect_Reg getADCPreselectRegister(ADC_Key key, SHAL_ADC_Channel channel) { + SHAL_ADC_Preselect_Reg res = {nullptr, static_cast(channel)}; + + res.reg = &(ADC_TABLE[static_cast(key)]->PCSEL); + + return res; +} + +#endif //SHMINGO_HAL_SHAL_ADC_REG_H753ZI_H \ No newline at end of file diff --git a/SHAL/Include/Peripheral/ADC/SHAL_ADC.h b/SHAL/Include/Peripheral/ADC/SHAL_ADC.h index 8cf6af1..e321aaa 100644 --- a/SHAL/Include/Peripheral/ADC/SHAL_ADC.h +++ b/SHAL/Include/Peripheral/ADC/SHAL_ADC.h @@ -16,19 +16,21 @@ class SHAL_ADC { public: - SHAL_Result init(ADC_Key key); + SHAL_Result init(ADC_Key key, SHAL_ADC_Sample_Mode mode); - SHAL_Result calibrate(); + SHAL_Result calibrate(SHAL_ADC_Sample_Mode sampleMode) const; - SHAL_Result configureResolution(SHAL_ADC_Resolution resolution); + SHAL_Result configureResolution(SHAL_ADC_Resolution resolution) const; - SHAL_Result configureAlignment(SHAL_ADC_Alignment alignment); + SHAL_Result configureAlignment(SHAL_ADC_Alignment alignment) const; + + SHAL_Result preselectChannel(SHAL_ADC_Channel channel) const; /// Performs analog to digital conversion on a single channel, one time /// \param channel Channel to be converted /// \param time SHAL_ADC_SampleTime - amount of clock cycles per conversion /// \return resulting value - uint16_t singleConvertSingle(SHAL_ADC_Channel channel, SHAL_ADC_SampleTime time = SHAL_ADC_SampleTime::C8); + uint32_t singleConvertSingle(SHAL_ADC_Channel channel, SHAL_ADC_SampleTime time = SHAL_ADC_SampleTime::C8) const; /// Performs analog to digital conversion on multiple channels, one time /// \param channels Pointer to an array of channels to convert @@ -46,29 +48,29 @@ private: ADC_Key m_ADCKey = ADC_Key::INVALID; //Checks to see if instance is initialized with a proper ADC peripheral tag - bool isValid(); + bool isValid() const; //Enabled peripheral - SHAL_Result enable(); + SHAL_Result enable() const; //Disables peripheral - SHAL_Result disable(); + SHAL_Result disable() const; //Wake up ADC from initial deep sleep state - SHAL_Result wakeFromDeepSleep(); + SHAL_Result wakeFromDeepSleep() const; - SHAL_Result startConversion(); + SHAL_Result startConversion() const; /// Adds an ADC channel to the conversion sequence /// \param channel Channel to add - /// \param index Index to add channel to (ADC channel will be the nth channel to convert + /// \param conversionNumber Index to add channel to (ADC channel will be the nth channel to convert /// \return Result - SHAL_Result addADCChannelToSequence(SHAL_ADC_Channel channel, uint32_t index); + SHAL_Result addADCChannelToSequence(SHAL_ADC_Channel channel, uint32_t conversionNumber) const; /// Sets the amount of ADC channels to convert /// \param amount Number of channels to convert /// \return - SHAL_Result setADCSequenceAmount(uint32_t amount); + SHAL_Result setADCSequenceAmount(uint32_t amount) const; }; @@ -83,7 +85,6 @@ public: static SHAL_ADC& getByIndex(int index); - ADCManager() = delete; private: diff --git a/SHAL/Include/Peripheral/ADC/SHAL_ADC_REG.h b/SHAL/Include/Peripheral/ADC/SHAL_ADC_REG.h index 46b7227..1654a4f 100644 --- a/SHAL/Include/Peripheral/ADC/SHAL_ADC_REG.h +++ b/SHAL/Include/Peripheral/ADC/SHAL_ADC_REG.h @@ -88,6 +88,50 @@ #elif defined(STM32L4S7xx) #include "stm32l4s7xx.h" #elif defined(STM32L4S9xx) +#elif defined(STM32H743xx) + #include "stm32h743xx.h" +#elif defined(STM32H753xx) + #include "SHAL_ADC_REG_H753ZI.h" +#elif defined(STM32H750xx) + #include "stm32h750xx.h" +#elif defined(STM32H742xx) + #include "stm32h742xx.h" +#elif defined(STM32H745xx) + #include "stm32h745xx.h" +#elif defined(STM32H745xG) + #include "stm32h745xg.h" +#elif defined(STM32H755xx) + #include "stm32h755xx.h" +#elif defined(STM32H747xx) + #include "stm32h747xx.h" +#elif defined(STM32H747xG) + #include "stm32h747xg.h" +#elif defined(STM32H757xx) + #include "stm32h757xx.h" +#elif defined(STM32H7B0xx) + #include "stm32h7b0xx.h" +#elif defined(STM32H7B0xxQ) + #include "stm32h7b0xxq.h" +#elif defined(STM32H7A3xx) + #include "stm32h7a3xx.h" +#elif defined(STM32H7B3xx) + #include "stm32h7b3xx.h" +#elif defined(STM32H7A3xxQ) + #include "stm32h7a3xxq.h" +#elif defined(STM32H7B3xxQ) + #include "stm32h7b3xxq.h" +#elif defined(STM32H735xx) + #include "stm32h735xx.h" +#elif defined(STM32H733xx) + #include "stm32h733xx.h" +#elif defined(STM32H730xx) + #include "stm32h730xx.h" +#elif defined(STM32H730xxQ) + #include "stm32h730xxq.h" +#elif defined(STM32H725xx) + #include "stm32h725xx.h" +#elif defined(STM32H723xx) + #include "stm32h723xx.h" #else #error "Please select first the target STM32F0xx device used in your application (in stm32f0xx.h file)" #endif diff --git a/SHAL/Include/Peripheral/ADC/SHAL_ADC_TYPES.h b/SHAL/Include/Peripheral/ADC/SHAL_ADC_TYPES.h index f9d7f70..3cc64d3 100644 --- a/SHAL/Include/Peripheral/ADC/SHAL_ADC_TYPES.h +++ b/SHAL/Include/Peripheral/ADC/SHAL_ADC_TYPES.h @@ -5,12 +5,15 @@ #ifndef SHMINGO_HAL_SHAL_ADC_TYPES_H #define SHMINGO_HAL_SHAL_ADC_TYPES_H +#include "SHAL_CORE.h" + //Common register among all ADC peripherals struct SHAL_ADC_Common_Control_Reg { volatile uint32_t* reg; uint32_t VoltageRefEnable; uint32_t TempSensorEnable; uint32_t VBatteryEnable; + uint32_t clock_mode_position; }; //Register controlling the ADC peripheral clock @@ -29,7 +32,7 @@ struct SHAL_ADC_Control_Reg { uint32_t start_mask; uint32_t deep_power_down_mask; uint32_t voltage_regulator_mask; - uint32_t differential_mode_mask; + uint32_t sample_mode_offset; }; //Register controlling ADC configuration @@ -55,6 +58,7 @@ struct SHAL_ADC_ISR_Reg { uint32_t end_of_sequence_mask; uint32_t ready_mask; uint32_t overrun_mask; + uint32_t ldo_ready_mask; }; //Register controlling the clock source for the ADC @@ -79,9 +83,13 @@ struct SHAL_ADC_Sequence_Amount_Reg { *reg 1 + offset 1 *Any sections after the last one (for example, max for a 16 channel register is reg 4 offset 2*/ struct SHAL_ADC_Sequence_Reg { - volatile uint32_t* regs[6]; + volatile uint32_t* reg; + uint32_t sequence_offset; +}; - uint32_t offsets[5]; +struct SHAL_ADC_Preselect_Reg { + volatile uint32_t* reg; + uint32_t channel_offset; }; @@ -98,16 +106,14 @@ enum class SHAL_ADC_SampleTime : uint32_t { C8 = 0x07 //239.5 cycles }; -enum class SHAL_ADC_Resolution : uint8_t { - B12 = 0x00, - B10 = 0x01, - B8 = 0x02, - B6 = 0x03, -}; - enum class SHAL_ADC_Alignment : uint8_t { RIGHT = 0x00, LEFT = 0x01, }; +enum class SHAL_ADC_Sample_Mode { + SINGLE_ENDED = 0, + DIFFERENTIAL = 1, +}; + #endif //SHMINGO_HAL_SHAL_ADC_TYPES_H diff --git a/SHAL/Include/Peripheral/GPIO/SHAL_GPIO.h b/SHAL/Include/Peripheral/GPIO/SHAL_GPIO.h index d9e01f1..efbf2e9 100644 --- a/SHAL/Include/Peripheral/GPIO/SHAL_GPIO.h +++ b/SHAL/Include/Peripheral/GPIO/SHAL_GPIO.h @@ -17,31 +17,33 @@ class SHAL_GPIO{ public: - void toggle() volatile; + void toggle() const volatile; //TODO replace stupid offset hack from APB - void setHigh(); - void setLow(); + void setHigh() const; + void setLow() const; /// Uses the ADC to read an analog voltage value /// \param sampleTime The amount of clock cycles to use for the ADC /// \return ADC result //uint16_t analogRead(SHAL_ADC_SampleTime sampleTime = SHAL_ADC_SampleTime::C8); TODO Reimplement - uint16_t digitalRead(); + uint16_t digitalRead() const; - void setAlternateFunction(GPIO_Alternate_Function AF) volatile; + void setAlternateFunction(GPIO_Alternate_Function AF) const volatile; //void setAlternateFunction(GPIO_Alternate_Function_Mapping AF) volatile; //TODO reimplement? - void setOutputType(PinType type) volatile; + void setOutputType(PinType type) const volatile; - void setOutputSpeed(OutputSpeed speed) volatile; + void setOutputSpeed(OutputSpeed speed) const volatile; - void setInternalResistor(InternalResistorType type) volatile; + void setInternalResistor(InternalResistorType type) const volatile; //void useAsExternalInterrupt(TriggerMode mode, EXTICallback callback); TODO reimplement - SHAL_Result setPinMode(PinMode mode) volatile; + SHAL_Result setPinMode(PinMode mode) const volatile; + + [[nodiscard]] GPIO_Key getKey() const {return m_GPIO_KEY;}; private: @@ -73,6 +75,9 @@ class GPIOManager{ public: static SHAL_GPIO& get(GPIO_Key); + static SHAL_GPIO& get(uint8_t portNum, uint8_t pinNum); + + static void initGPIO(GPIO_Key key); //static SHAL_ADC getGPIOADC(){ return m_GPIO_ADC;} TODO Reimplement diff --git a/SHAL/Include/Peripheral/Timer/Reg/SHAL_TIM_REG_H753xx.h b/SHAL/Include/Peripheral/Timer/Reg/SHAL_TIM_REG_H753xx.h index 6d9ab95..c55af9f 100644 --- a/SHAL/Include/Peripheral/Timer/Reg/SHAL_TIM_REG_H753xx.h +++ b/SHAL/Include/Peripheral/Timer/Reg/SHAL_TIM_REG_H753xx.h @@ -19,8 +19,13 @@ enum class Timer_Key : uint8_t { //For STM32F072 S_TIM1 = 0, S_TIM2 = 1, S_TIM3 = 2, + S_TIM4, + S_TIM5, S_TIM6, S_TIM7, + S_TIM8, + S_TIM12, + S_TIM13, S_TIM14, S_TIM15, S_TIM16, @@ -32,19 +37,29 @@ enum class Timer_Key : uint8_t { //For STM32F072 #define SHAL_TIM1 TimerManager::get(Timer_Key::S_TIM1) #define SHAL_TIM2 TimerManager::get(Timer_Key::S_TIM2) #define SHAL_TIM3 TimerManager::get(Timer_Key::S_TIM3) +#define SHAL_TIM4 TimerManager::get(Timer_Key::S_TIM4) +#define SHAL_TIM5 TimerManager::get(Timer_Key::S_TIM5) #define SHAL_TIM6 TimerManager::get(Timer_Key::S_TIM6) #define SHAL_TIM7 TimerManager::get(Timer_Key::S_TIM7) +#define SHAL_TIM8 TimerManager::get(Timer_Key::S_TIM8) +#define SHAL_TIM12 TimerManager::get(Timer_Key::S_TIM12) +#define SHAL_TIM13 TimerManager::get(Timer_Key::S_TIM13) #define SHAL_TIM14 TimerManager::get(Timer_Key::S_TIM14) #define SHAL_TIM15 TimerManager::get(Timer_Key::S_TIM15) #define SHAL_TIM16 TimerManager::get(Timer_Key::S_TIM16) #define SHAL_TIM17 TimerManager::get(Timer_Key::S_TIM17) -static SHAL_TIM_Info TIM_INFO_TABLE[9] = { +static SHAL_TIM_Info TIM_INFO_TABLE[14] = { {TIM1,TIM1_TRG_COM_IRQn,4}, {TIM2,TIM2_IRQn,4}, {TIM3,TIM3_IRQn,4}, + {TIM3,TIM4_IRQn,4}, + {TIM3,TIM5_IRQn,4}, {TIM6,TIM6_DAC_IRQn,0}, {TIM7,TIM7_IRQn,0}, + {TIM8,TIM8_TRG_COM_TIM14_IRQn,6}, + {TIM12,TIM8_BRK_TIM12_IRQn,2}, + {TIM13,TIM8_UP_TIM13_IRQn,1}, {TIM14,TIM8_TRG_COM_TIM14_IRQn,1}, {TIM15,TIM15_IRQn,2}, {TIM16,TIM16_IRQn,1}, @@ -67,9 +82,14 @@ static SHAL_TIM_RCC_Register getTimerRCC(Timer_Key t) { case Timer_Key::S_TIM1: return {&RCC->APB2ENR, RCC_APB2ENR_TIM1EN}; case Timer_Key::S_TIM2: return {&RCC->APB1LENR, RCC_APB1LENR_TIM2EN}; case Timer_Key::S_TIM3: return {&RCC->APB1LENR, RCC_APB1LENR_TIM3EN}; + case Timer_Key::S_TIM4: return {&RCC->APB1LENR, RCC_APB1LENR_TIM4EN}; + case Timer_Key::S_TIM5: return {&RCC->APB1LENR, RCC_APB1LENR_TIM5EN}; case Timer_Key::S_TIM6: return {&RCC->APB1LENR, RCC_APB1LENR_TIM6EN}; case Timer_Key::S_TIM7: return {&RCC->APB1LENR, RCC_APB1LENR_TIM7EN}; - case Timer_Key::S_TIM14: return {&RCC->APB1LENR, RCC_APB1LENR_TIM14EN}; + case Timer_Key::S_TIM8: return {&RCC->APB1LENR, RCC_APB2ENR_TIM8EN}; + case Timer_Key::S_TIM14: return {&RCC->APB1LENR, RCC_APB1LENR_TIM12EN}; + case Timer_Key::S_TIM12: return {&RCC->APB1LENR, RCC_APB1LENR_TIM13EN}; + case Timer_Key::S_TIM13: return {&RCC->APB1LENR, RCC_APB1LENR_TIM14EN}; case Timer_Key::S_TIM15: return {&RCC->APB2ENR, RCC_APB2ENR_TIM15EN}; case Timer_Key::S_TIM16: return {&RCC->APB2ENR, RCC_APB2ENR_TIM16EN}; case Timer_Key::S_TIM17: return {&RCC->APB2ENR, RCC_APB2ENR_TIM17EN}; diff --git a/SHAL/Include/Peripheral/Timer/SHAL_TIM.h b/SHAL/Include/Peripheral/Timer/SHAL_TIM.h index 66b2fb0..398383d 100644 --- a/SHAL/Include/Peripheral/Timer/SHAL_TIM.h +++ b/SHAL/Include/Peripheral/Timer/SHAL_TIM.h @@ -21,18 +21,19 @@ public: /// Initializes a timer /// \param prescaler The amount of times the base clock has to cycle before the timer adds one to the count /// \param autoReload The number of timer counts before the count is reset and IRQ is called - void init(uint16_t prescaler, uint16_t autoReload); + void init(uint32_t prescaler, uint32_t autoReload); + void init() const; //Empty init (enable RCC) /// Simple function to set a timer in basic PWM mode /// @param channel Channel to output on /// @param prescaler Divider from sysclock /// @param autoReload Counter value to reset at /// @param captureCompareThreshold PWM trigger value (duty cycle = this / autoReload) - void configurePWM(SHAL_Timer_Channel channel, uint16_t prescaler, uint16_t autoReload, uint16_t captureCompareThreshold); + void configurePWM(SHAL_Timer_Channel channel, uint32_t prescaler, uint32_t autoReload, uint32_t captureCompareThreshold); - void configureOneshot(SHAL_Timer_Channel channel, uint16_t prescaler, uint16_t autoReload, uint16_t captureCompareThreshold); + void configureOneshot(SHAL_Timer_Channel channel, uint32_t prescaler, uint32_t autoReload, uint32_t captureCompareThreshold); //Starts the counter void start(); @@ -41,16 +42,16 @@ public: void stop() const; //Set prescaler value - void setPrescaler(uint16_t presc) const; + void setPrescaler(uint32_t presc) const; //Set auto reload register - void setARR(uint16_t arr) const; + void setARR(uint32_t arr) const; //Enable interrupts void enableInterrupt(); //Capture Compare Functions - void setCaptureCompareValue(SHAL_Timer_Channel channel, uint16_t value); + void setCaptureCompareValue(SHAL_Timer_Channel channel, uint32_t value) const; void enableChannel(SHAL_Timer_Channel channel, SHAL_Timer_Channel_Main_Output_Mode mainOutputMode, SHAL_Timer_Channel_Complimentary_Output_Mode complimentaryOutputMode); void setOutputCompareMode(SHAL_Timer_Channel channel, SHAL_TIM_Output_Compare_Mode outputCompareMode); diff --git a/SHAL/Include/Peripheral/UART/Reg/SHAL_UART_REG_H753ZI.h b/SHAL/Include/Peripheral/UART/Reg/SHAL_UART_REG_H753ZI.h index 89e404f..f7453c0 100644 --- a/SHAL/Include/Peripheral/UART/Reg/SHAL_UART_REG_H753ZI.h +++ b/SHAL/Include/Peripheral/UART/Reg/SHAL_UART_REG_H753ZI.h @@ -63,7 +63,8 @@ static SHAL_UART_Control_Register_1 getUARTControlRegister1(const UART_Pair_Key USART_CR1_TE, USART_CR1_RE, USART_CR1_M0, - USART_CR1_M1 + USART_CR1_M1, + USART_CR1_RXNEIE }; res.reg = &getUARTPair(key).USARTReg->CR1; @@ -90,7 +91,7 @@ static SHAL_UART_ISR getUARTISR(const UART_Pair_Key key) { //TODO Support for mu } static SHAL_UART_Transmit_Data_Register getUARTTransmitDataRegister(const UART_Pair_Key key) { - return {&getUARTPair(key).USARTReg->CR1}; + return {&getUARTPair(key).USARTReg->TDR}; } static diff --git a/SHAL/Include/Peripheral/UART/SHAL_UART.h b/SHAL/Include/Peripheral/UART/SHAL_UART.h index ff04f5e..a56c1a7 100644 --- a/SHAL/Include/Peripheral/UART/SHAL_UART.h +++ b/SHAL/Include/Peripheral/UART/SHAL_UART.h @@ -23,10 +23,9 @@ public: void begin(uint32_t baudRate, SHAL_USART_Word_Length wordLength) const volatile; //Sends a string - void sendString(const char* s) volatile; + void sendString(const char* s) const volatile; - //Sends a char - void sendChar(char c) volatile; + void sendChar(char c) const volatile; private: diff --git a/SHAL/Include/Peripheral/UART/SHAL_UART_TYPES.h b/SHAL/Include/Peripheral/UART/SHAL_UART_TYPES.h index a5c100c..37366aa 100644 --- a/SHAL/Include/Peripheral/UART/SHAL_UART_TYPES.h +++ b/SHAL/Include/Peripheral/UART/SHAL_UART_TYPES.h @@ -29,6 +29,7 @@ struct SHAL_UART_Control_Register_1 { uint32_t receive_enable_mask; uint32_t m0_mask; uint32_t m1_mask; + uint32_t Rx_interrupt_enable_mask; }; struct SHAL_UART_Baud_Rate_Generation_Register { diff --git a/SHAL/Include/SHAL.h b/SHAL/Include/SHAL.h index fce6277..751b34d 100644 --- a/SHAL/Include/SHAL.h +++ b/SHAL/Include/SHAL.h @@ -11,7 +11,7 @@ #include "SHAL_TIM.h" #include "SHAL_GPIO.h" #include "SHAL_UART.h" -//#include "SHAL_ADC.h" +#include "SHAL_ADC.h" diff --git a/SHAL/Src/STM32H7xx/Core/SHAL_CORE.cpp b/SHAL/Src/STM32H7xx/Core/SHAL_CORE.cpp index 0b6d591..7133ae2 100644 --- a/SHAL/Src/STM32H7xx/Core/SHAL_CORE.cpp +++ b/SHAL/Src/STM32H7xx/Core/SHAL_CORE.cpp @@ -4,6 +4,8 @@ #include "SHAL_CORE.h" +#include + void SHAL_init(){ systick_init(); //Just this for now @@ -53,3 +55,36 @@ void SHAL_delay_ms(uint32_t ms){ SHAL_delay_us(1000); } } + +bool SHAL_wait_for_bit_set_us(const volatile uint32_t* reg, const uint32_t mask, const uint16_t timeout) { + if(SHAL_WAIT_FOR_CONDITION_US((*reg & mask) != 0, timeout)){ + return true; + } + return false; +} + +bool SHAL_wait_for_bit_clear_us(const volatile uint32_t* reg, const uint32_t mask, const uint16_t timeout) { + if(SHAL_WAIT_FOR_CONDITION_US((*reg & mask) == 0, timeout)){ + return true; + } + return false; +} + +bool SHAL_wait_for_bit_set_ms(const volatile uint32_t* reg, const uint32_t mask, const uint16_t timeout) { + if(SHAL_WAIT_FOR_CONDITION_MS((*reg & mask) != 0, timeout)){ + return true; + } + return false; +} + +bool SHAL_wait_for_bit_clear_ms(const volatile uint32_t* reg, const uint32_t mask, const uint16_t timeout) { + if(SHAL_WAIT_FOR_CONDITION_MS((*reg & mask) == 0, timeout)){ + return true; + } + return false; +} + +bool SHAL_check_bit(const volatile uint32_t* reg, const uint32_t mask) { + if ((*reg & mask) != 0) return true; + return false; +} diff --git a/SHAL/Src/STM32H7xx/Peripheral/ADC/SHAL_ADC.cpp b/SHAL/Src/STM32H7xx/Peripheral/ADC/SHAL_ADC.cpp new file mode 100644 index 0000000..b11ae90 --- /dev/null +++ b/SHAL/Src/STM32H7xx/Peripheral/ADC/SHAL_ADC.cpp @@ -0,0 +1,271 @@ +// +// Created by Luca on 9/21/2025. +// + +#include "SHAL_ADC.h" +#include "SHAL_GPIO.h" +#include "SHAL_UART.h" +#include + +bool SHAL_ADC::isValid() const { + if(m_ADCKey == ADC_Key::INVALID || m_ADCKey == ADC_Key::NUM_ADC){ + return false; + } + return true; +} + +SHAL_Result SHAL_ADC::init(const ADC_Key key, SHAL_ADC_Sample_Mode mode){ + + m_ADCKey = key; + + if(!isValid()){ + return SHAL_Result::ERROR; + } + + auto rcc = getADCRCCEnableRegister(m_ADCKey); //Clock enable + auto ccr = getADCCommonControl(m_ADCKey); + + SHAL_apply_bitmask(rcc.reg,rcc.mask); //Enable clock + + wakeFromDeepSleep(); //Wake and enable LDO + + //Configure clock source + SHAL_set_bits(ccr.reg,2,static_cast(SHAL_ADC_Clock_Mode::SYNC_BY_2),ccr.clock_mode_position); //TODO take as param? + + configureResolution(SHAL_ADC_Resolution::B12); //Configure resolution + SHAL_apply_bitmask(ccr.reg,ccr.VoltageRefEnable); + + if(calibrate(mode) != SHAL_Result::OKAY){ //Calibrate + return SHAL_Result::ERROR; + } + + if(enable() != SHAL_Result::OKAY){ + return SHAL_Result::ERROR; + } + + return SHAL_Result::OKAY; +} + +SHAL_Result SHAL_ADC::calibrate(SHAL_ADC_Sample_Mode sampleMode) const { + const SHAL_ADC_Control_Reg control_reg = getADCControlReg(m_ADCKey); + + if(disable() != SHAL_Result::OKAY){ + return SHAL_Result::ERROR; + } + + SHAL_set_bits(control_reg.reg, 1, static_cast(sampleMode), control_reg.sample_mode_offset); //Set sample mode (differential or single ended) + + SHAL_apply_bitmask(control_reg.reg, control_reg.calibration_mask); //Start calibration + + if (!SHAL_wait_for_bit_clear_us(control_reg.reg, control_reg.calibration_mask, 100)) { //Wait for calibration + return SHAL_Result::ERROR; + } + + return SHAL_Result::OKAY; +} + +uint32_t SHAL_ADC::singleConvertSingle(SHAL_ADC_Channel channel, SHAL_ADC_SampleTime time) const { + + auto data_reg = getADCDataReg(m_ADCKey); + auto ISR_reg = getADCISRReg(m_ADCKey); + + auto sampleTimeReg = getADCChannelSamplingTimeRegister(m_ADCKey, channel); + + SHAL_set_bits(sampleTimeReg.reg, 3, static_cast(time), sampleTimeReg.channel_offset); //Set sample time + + if(setADCSequenceAmount(1) == SHAL_Result::ERROR) { return 0; } //Set sequence amount to 1 + + addADCChannelToSequence(channel, 1); + + startConversion(); + + if (!SHAL_wait_for_bit_set_us(ISR_reg.reg, ISR_reg.end_of_conversion_mask, 200)) { + return 0; + } + + uint32_t result = *data_reg.reg; + + return result; +} + +SHAL_Result SHAL_ADC::multiConvertSingle(SHAL_ADC_Channel* channels, int numChannels, uint16_t* result, SHAL_ADC_SampleTime time) { + auto data_reg = getADCDataReg(m_ADCKey); //Where our output will be stored + + setADCSequenceAmount(numChannels); //Convert the correct amount of channels + + for(int i = 0; i < numChannels; i++){ + auto channel = channels[i]; + + auto sampleTimeReg = getADCChannelSamplingTimeRegister(m_ADCKey,channel); + + SHAL_set_bits(sampleTimeReg.reg,3,static_cast(time),sampleTimeReg.channel_offset); //Set sample time register TODO un-hardcode bit width? + + addADCChannelToSequence(channel,i); //Use index 0 to convert channel + } + + startConversion(); //Start ADC conversion + + auto ISR_reg = getADCISRReg(m_ADCKey); + + for(int i = 0; i < numChannels; i++) { + if (!SHAL_WAIT_FOR_CONDITION_US(((*ISR_reg.reg & ISR_reg.end_of_conversion_mask) != 0),500)) { //Wait for conversion + return SHAL_Result::ERROR; //Failed conversion + } + result[i] = *data_reg.reg; + } + + if (!SHAL_WAIT_FOR_CONDITION_US(((*ISR_reg.reg & ISR_reg.end_of_sequence_mask) != 0),500)) { //Wait for conversion + return SHAL_Result::ERROR; //Failed sequence + } + + return SHAL_Result::OKAY; +} + +SHAL_Result SHAL_ADC::enable() const { + + if(!isValid()){ + return SHAL_Result::ERROR; + } + + const SHAL_ADC_Control_Reg control_reg = getADCControlReg(m_ADCKey); + const SHAL_ADC_ISR_Reg ISR_reg = getADCISRReg(m_ADCKey); + + SHAL_apply_bitmask(ISR_reg.reg, ISR_reg.ready_mask); //Clear ready flag (write is correct as per datasheet) + + SHAL_apply_bitmask(control_reg.reg, control_reg.enable_mask); //Enable mask + + if (!SHAL_wait_for_bit_set_us(ISR_reg.reg,ISR_reg.ready_mask,500)) { //Check ADRDY + return SHAL_Result::ERROR; + } + + return SHAL_Result::OKAY; +} + +/// Disables the ADC +/// @return +SHAL_Result SHAL_ADC::disable() const { + if(!isValid()){ + return SHAL_Result::ERROR; + } + + const auto control_reg = getADCControlReg(m_ADCKey); + + //Stop any ongoing conversion + if (SHAL_check_bit(control_reg.reg, control_reg.start_mask)) { + SHAL_apply_bitmask(control_reg.reg, control_reg.stop_mask); + } + + if (SHAL_check_bit(control_reg.reg,control_reg.enable_mask)) { //DO NOT disable if the ADC is already disabled + SHAL_apply_bitmask(control_reg.reg, control_reg.disable_mask); + + if (!SHAL_wait_for_bit_clear_ms(control_reg.reg,(control_reg.enable_mask | control_reg.disable_mask),50)) { + return SHAL_Result::ERROR; + } + } + + return SHAL_Result::OKAY; +} + +SHAL_Result SHAL_ADC::wakeFromDeepSleep() const { + + const SHAL_ADC_Control_Reg control_reg = getADCControlReg(m_ADCKey); //ADC Control register + const SHAL_ADC_ISR_Reg ISR_reg = getADCISRReg(m_ADCKey); + + SHAL_clear_bitmask(control_reg.reg,control_reg.deep_power_down_mask); //Wake ADC from sleep + + SHAL_apply_bitmask(control_reg.reg,control_reg.voltage_regulator_mask); + + if (!SHAL_wait_for_bit_set_us(ISR_reg.reg,ISR_reg.ldo_ready_mask,50)) { //Wait for LDO + return SHAL_Result::ERROR; + } + + return SHAL_Result::OKAY; +} + +SHAL_Result SHAL_ADC::startConversion() const { + auto control_reg = getADCControlReg(m_ADCKey); + + SHAL_apply_bitmask(control_reg.reg,control_reg.start_mask); + + return SHAL_Result::OKAY; +} + + +SHAL_Result SHAL_ADC::configureResolution(SHAL_ADC_Resolution resolution) const { + if(!isValid()){ + return SHAL_Result::ERROR; + } + + const SHAL_ADC_Config_Reg config_reg = getADCConfigReg(m_ADCKey); + /* + SHAL_set_bits(config_reg.reg,2,static_cast(resolution),config_reg.resolution_offset); + + char buff[20]; + snprintf(buff,16,"CFGR: %lu\r\n", (unsigned long)ADC1->CFGR); + SHAL_UART3.sendString(buff); + */ + + SHAL_set_register_value(config_reg.reg, 0); + + return SHAL_Result::OKAY; +} + +SHAL_Result SHAL_ADC::configureAlignment(SHAL_ADC_Alignment alignment) const { + if(!isValid()){ + return SHAL_Result::ERROR; + } + + const SHAL_ADC_Config_Reg config_reg = getADCConfigReg(m_ADCKey); + + //TODO check if this needs to be abstracted (Do other platforms have >2 resolution possibilities? + SHAL_set_bits(config_reg.reg,1,static_cast(alignment),config_reg.alignment_offset); + + return SHAL_Result::OKAY; +} + +SHAL_Result SHAL_ADC::preselectChannel(SHAL_ADC_Channel channel) const { + auto preselect = getADCPreselectRegister(ADC_Key::S_ADC1, SHAL_ADC_Channel::CH15); + SHAL_set_bits(preselect.reg,1,1,preselect.channel_offset); + + return SHAL_Result::OKAY; +} + +SHAL_Result SHAL_ADC::setADCSequenceAmount(uint32_t amount) const { + if(!isValid()){return SHAL_Result::ERROR;} + + if(amount == 0){ + return SHAL_Result::ERROR; + } + + SHAL_ADC_Sequence_Amount_Reg sequence_amount_reg = getADCSequenceAmountRegister(m_ADCKey); + + SHAL_set_bits(sequence_amount_reg.reg, 4, amount - 1, 0); //Sequence amount reg is just SQR1 least significant 4 bits, this offset should always be 0 + + return SHAL_Result::OKAY; +} + +SHAL_Result SHAL_ADC::addADCChannelToSequence(SHAL_ADC_Channel channel, const uint32_t conversionNumber) const { + if(!isValid()) { return SHAL_Result::ERROR; } + + auto sqr = getADCSequenceRegister(m_ADCKey, conversionNumber); + auto channelNum = static_cast(channel); + + + SHAL_wait_for_bit_clear_ms(&ADC1->CR,ADC_CR_ADSTART,50); + + SHAL_set_bits(sqr.reg, 5, channelNum, sqr.sequence_offset); //Set regular sequence register + + return SHAL_Result::OKAY; +} + +SHAL_ADC &ADCManager::get(ADC_Key key) { + return m_ADCs[static_cast(key)]; +} + +SHAL_ADC& ADCManager::getByIndex(int index) { + + if(index < static_cast(ADC_Key::NUM_ADC)){ + return m_ADCs[index]; + } + return m_ADCs[0]; +} \ No newline at end of file diff --git a/SHAL/Src/STM32H7xx/Peripheral/GPIO/SHAL_GPIO.cpp b/SHAL/Src/STM32H7xx/Peripheral/GPIO/SHAL_GPIO.cpp index 4fff8b5..7037fdc 100644 --- a/SHAL/Src/STM32H7xx/Peripheral/GPIO/SHAL_GPIO.cpp +++ b/SHAL/Src/STM32H7xx/Peripheral/GPIO/SHAL_GPIO.cpp @@ -18,44 +18,46 @@ SHAL_GPIO::SHAL_GPIO(GPIO_Key key) : m_GPIO_KEY(key) { SHAL_apply_bitmask(GPIORCCEnable.reg,GPIORCCEnable.mask); } -void SHAL_GPIO::setLow() { +void SHAL_GPIO::setLow() const { auto outputDataReg = getGPIOOutputDataRegister(m_GPIO_KEY); SHAL_set_bits(outputDataReg.reg,1,0,outputDataReg.offset); } -void SHAL_GPIO::setHigh() { +void SHAL_GPIO::setHigh() const { auto outputDataReg = getGPIOOutputDataRegister(m_GPIO_KEY); SHAL_set_bits(outputDataReg.reg,1,1,outputDataReg.offset); } -void SHAL_GPIO::toggle() volatile { +void SHAL_GPIO::toggle() const volatile { auto outputDataReg = getGPIOOutputDataRegister(m_GPIO_KEY); SHAL_flip_bits(outputDataReg.reg,1,outputDataReg.offset); } -void SHAL_GPIO::setOutputType(PinType type) volatile { +void SHAL_GPIO::setOutputType(PinType type) const volatile { auto outputTypeReg = getGPIOOutputTypeRegister(m_GPIO_KEY); SHAL_set_bits(outputTypeReg.reg,2,static_cast(type),outputTypeReg.offset); } -void SHAL_GPIO::setOutputSpeed(OutputSpeed speed) volatile { +void SHAL_GPIO::setOutputSpeed(OutputSpeed speed) const volatile { auto outputSpeedReg = getGPIOOutputSpeedRegister(m_GPIO_KEY); SHAL_set_bits(outputSpeedReg.reg,2,static_cast(speed),outputSpeedReg.offset); } -void SHAL_GPIO::setInternalResistor(InternalResistorType type) volatile { +void SHAL_GPIO::setInternalResistor(InternalResistorType type) const volatile { auto pupdreg = getGPIOPUPDRegister(m_GPIO_KEY); SHAL_set_bits(pupdreg.reg,2,static_cast(type),pupdreg.offset); } -void SHAL_GPIO::setAlternateFunction(GPIO_Alternate_Function AF) volatile { +void SHAL_GPIO::setAlternateFunction(GPIO_Alternate_Function AF) const volatile { auto alternateFunctionReg = getGPIOAlternateFunctionRegister(m_GPIO_KEY); SHAL_set_bits(alternateFunctionReg.reg,4,static_cast(AF),alternateFunctionReg.offset); } -SHAL_Result SHAL_GPIO::setPinMode(PinMode mode) volatile { +SHAL_Result SHAL_GPIO::setPinMode(PinMode mode) const volatile { auto pinModeReg = getGPIOModeRegister(m_GPIO_KEY); + GPIOManager::initGPIO(m_GPIO_KEY); + /* if(mode == PinMode::ANALOG_MODE && getGPIOPortInfo(m_GPIO_KEY).ADCChannel == SHAL_ADC_Channel::NO_ADC_MAPPING){ char buff[100]; @@ -69,6 +71,12 @@ SHAL_Result SHAL_GPIO::setPinMode(PinMode mode) volatile { return SHAL_Result::OKAY; } +uint16_t SHAL_GPIO::digitalRead() const { + auto offset = getGPIOPinNumber(m_GPIO_KEY); + + return (SHAL_check_bit(getGPIOInputDataRegister(m_GPIO_KEY).reg, 1 << offset)) ? 1 : 0; +} + /* TODO Fix implementation for STM32F072 void SHAL_GPIO::useAsExternalInterrupt(TriggerMode mode, EXTICallback callback) { @@ -116,10 +124,20 @@ uint16_t SHAL_GPIO::analogRead(SHAL_ADC_SampleTime sampleTime) { SHAL_ADC_Channel channel = getGPIOPortInfo(m_GPIO_KEY).ADCChannel; return GPIOManager::getGPIOADC().singleConvertSingle(channel,sampleTime); + return GPIOManager::getGPIOADC().singleConvertSingle(channel,sampleTime); } */ -SHAL_GPIO& GPIOManager::get(GPIO_Key key) { +SHAL_GPIO& GPIOManager::get(const uint8_t portNum, const uint8_t pinNum) { + + uint8_t pinIndex = (PINS_PER_PORT * portNum) + pinNum; + + initGPIO(static_cast(pinIndex)); + + return m_gpios[portNum][pinNum]; +} + +void GPIOManager::initGPIO(GPIO_Key key) { unsigned int gpioPort = getGPIOPortNumber(key); uint8_t gpioPin = getGPIOPinNumber(key); @@ -127,6 +145,12 @@ SHAL_GPIO& GPIOManager::get(GPIO_Key key) { if (m_gpios[gpioPort][gpioPin].m_GPIO_KEY == GPIO_Key::INVALID){ m_gpios[gpioPort][gpioPin] = SHAL_GPIO(key); } - - return m_gpios[gpioPort][gpioPin]; +} + + +SHAL_GPIO& GPIOManager::get(const GPIO_Key key) { + + initGPIO(key); + + return m_gpios[getGPIOPortNumber(key)][getGPIOPinNumber(key)]; } diff --git a/SHAL/Src/STM32H7xx/Peripheral/Timer/SHAL_TIM.cpp b/SHAL/Src/STM32H7xx/Peripheral/Timer/SHAL_TIM.cpp index 3c0b257..e044aae 100644 --- a/SHAL/Src/STM32H7xx/Peripheral/Timer/SHAL_TIM.cpp +++ b/SHAL/Src/STM32H7xx/Peripheral/Timer/SHAL_TIM.cpp @@ -14,49 +14,56 @@ Timer::Timer() : m_key(Timer_Key::S_TIM_INVALID){ } void Timer::start() { + auto control_reg = getTimerControlRegister1(m_key); + auto event_reg = getTimerEventGenerationRegister(m_key); + auto status_reg = getTimerStatusRegister(m_key); + auto bdtr_reg = getTimerBreakDeadTimeRegister(m_key); + auto rcc_reg = getTimerRCC(m_key); - auto control_reg = getTimerControlRegister1(m_key); - auto event_generation_reg = getTimerEventGenerationRegister(m_key); - auto status_reg = getTimerStatusRegister(m_key); - auto break_time_dead_reg = getTimerBreakDeadTimeRegister(m_key); + SHAL_apply_bitmask(event_reg.reg, event_reg.update_generation_mask); + SHAL_clear_bitmask(status_reg.reg, status_reg.update_interrupt_flag_mask); - auto rcc_reg = getTimerRCC(m_key); + SHAL_apply_bitmask(control_reg.reg, control_reg.auto_reload_preload_enable_mask); - SHAL_apply_bitmask(control_reg.reg, control_reg.counter_enable_mask); //Enable counter - SHAL_apply_bitmask(control_reg.reg, control_reg.auto_reload_preload_enable_mask); //Preload enable (buffer) - SHAL_apply_bitmask(event_generation_reg.reg, event_generation_reg.update_generation_mask); - - SHAL_clear_bitmask(status_reg.reg,status_reg.update_interrupt_flag_mask); - - SHAL_apply_bitmask(rcc_reg.reg,rcc_reg.enable_mask); - SHAL_apply_bitmask(break_time_dead_reg.reg,break_time_dead_reg.main_output_enable_mask); + SHAL_apply_bitmask(rcc_reg.reg, rcc_reg.enable_mask); + SHAL_apply_bitmask(control_reg.reg, control_reg.counter_enable_mask); + SHAL_apply_bitmask(bdtr_reg.reg, bdtr_reg.main_output_enable_mask); enableInterrupt(); } void Timer::stop() const { - auto rcc_reg = getTimerRCC(m_key); + auto control_reg = getTimerControlRegister1(m_key); - SHAL_clear_bitmask(rcc_reg.reg,rcc_reg.enable_mask); + SHAL_clear_bitmask(control_reg.reg, control_reg.counter_enable_mask); + getTimerRegister(m_key)->CNT = 0; + + // Force an update event to flush shadow registers NOW + auto event_reg = getTimerEventGenerationRegister(m_key); + SHAL_apply_bitmask(event_reg.reg, event_reg.update_generation_mask); + + auto rcc_reg = getTimerRCC(m_key); + SHAL_clear_bitmask(rcc_reg.reg, rcc_reg.enable_mask); } -void Timer::setPrescaler(const uint16_t presc) const { +void Timer::setPrescaler(const uint32_t presc) const { auto prescalerReg = getTimerPrescalerRegister(m_key); - SHAL_set_bits(prescalerReg.reg,16,presc,0); + SHAL_set_register_value(prescalerReg.reg,presc); } -void Timer::setARR(const uint16_t arr) const { +void Timer::setARR(const uint32_t arr) const { auto autoReloadReg = getTimerAutoReloadRegister(m_key); - SHAL_set_bits(autoReloadReg.reg,16,arr,0);} + SHAL_set_register_value(autoReloadReg.reg,arr); +} void Timer::enableInterrupt() { getTimerRegister(m_key)->DIER |= TIM_DIER_UIE; NVIC_EnableIRQ(getIRQn(m_key)); } -void Timer::init(uint16_t prescaler, uint16_t autoReload) { +void Timer::init(uint32_t prescaler, uint32_t autoReload) { SHAL_TIM_RCC_Register rcc = getTimerRCC(m_key); SHAL_apply_bitmask(rcc.reg,rcc.enable_mask); @@ -65,18 +72,23 @@ void Timer::init(uint16_t prescaler, uint16_t autoReload) { setARR(autoReload); } -void Timer::configurePWM(SHAL_Timer_Channel channel, uint16_t prescaler, uint16_t autoReload, uint16_t captureCompareThreshold) { +void Timer::init() const { + SHAL_TIM_RCC_Register rcc = getTimerRCC(m_key); + + SHAL_apply_bitmask(rcc.reg,rcc.enable_mask); +} + +void Timer::configurePWM(SHAL_Timer_Channel channel, uint32_t prescaler, uint32_t autoReload, uint32_t captureCompareThreshold) { setPrescaler(prescaler); setARR(autoReload); + setCaptureCompareValue(channel, captureCompareThreshold); setOutputCompareMode(channel, SHAL_TIM_Output_Compare_Mode::PWMMode1); enableChannel(channel,SHAL_Timer_Channel_Main_Output_Mode::Polarity_Normal,SHAL_Timer_Channel_Complimentary_Output_Mode::Disabled); - - setCaptureCompareValue(channel, captureCompareThreshold); } -void Timer::configureOneshot(SHAL_Timer_Channel channel, uint16_t prescaler, uint16_t autoReload, uint16_t captureCompareThreshold) { +void Timer::configureOneshot(SHAL_Timer_Channel channel, uint32_t prescaler, uint32_t autoReload, uint32_t captureCompareThreshold) { setPrescaler(prescaler); setARR(autoReload); @@ -111,13 +123,13 @@ void Timer::enableChannel(SHAL_Timer_Channel channel, SHAL_Timer_Channel_Main_Ou setValue |= (static_cast(mainOutputMode) << ((channelNum - 1) * channelStride)); //xxBB shifted by c - 1 setValue |= (static_cast(complimentaryOutputMode) << (((channelNum - 1) * channelStride) + 2)); //BBxx shifted by c - 1 - SHAL_set_bits(captureCompareEnableReg.reg,16,setValue,0); + SHAL_set_register_value(captureCompareEnableReg.reg,setValue); } -void Timer::setCaptureCompareValue(SHAL_Timer_Channel channel, uint16_t value) { +void Timer::setCaptureCompareValue(SHAL_Timer_Channel channel, uint32_t value) const { auto captureCompareReg = getTimerCaptureCompareRegister(m_key,channel); - SHAL_set_bits(captureCompareReg.reg,16,value,0); + SHAL_set_register_value(captureCompareReg.reg,value); } diff --git a/SHAL/Src/STM32H7xx/Peripheral/UART/SHAL_UART.cpp b/SHAL/Src/STM32H7xx/Peripheral/UART/SHAL_UART.cpp index caae3cc..846e1c0 100644 --- a/SHAL/Src/STM32H7xx/Peripheral/UART/SHAL_UART.cpp +++ b/SHAL/Src/STM32H7xx/Peripheral/UART/SHAL_UART.cpp @@ -45,6 +45,9 @@ void SHAL_UART::begin(uint32_t baudRate, SHAL_USART_Word_Length wordLength) cons SHAL_apply_bitmask(CR.reg, static_cast(wordLength)); SHAL_apply_bitmask(CR.reg, CR.receive_enable_mask); SHAL_apply_bitmask(CR.reg, CR.transmit_enable_mask); + SHAL_apply_bitmask(CR.reg, CR.Rx_interrupt_enable_mask); + + SHAL_set_register_value(getUARTTransmitDataRegister(m_key).reg,0); //Clear TDR uint16_t baud = SystemCoreClock / (1 * baudRate); SHAL_set_bits_16(BRR.reg, 16, baud, 0); @@ -52,34 +55,23 @@ void SHAL_UART::begin(uint32_t baudRate, SHAL_USART_Word_Length wordLength) cons SHAL_apply_bitmask(CR.reg, CR.usart_enable_mask); //Enable } -void SHAL_UART::sendString(const char *s) volatile { +void SHAL_UART::sendString(const char *s) const volatile { const auto ISR = getUARTISR(m_key); while (*s) sendChar(*s++); //Send chars while we haven't reached end of s - if(!SHAL_WAIT_FOR_CONDITION_US((*ISR.reg & ISR.transmission_complete_mask) != 0, 1000)){ + if (!SHAL_wait_for_bit_set_us(ISR.reg, ISR.transmit_data_register_empty_mask, 500)) { assert(false); } } -void SHAL_UART::sendChar(char c) volatile { +void SHAL_UART::sendChar(const char c) const volatile { - /* TODO fix old - auto ISR = getUARTISR(m_key); + const auto ISR = getUARTISR(m_key); - if(!SHAL_WAIT_FOR_CONDITION_US((*ISR.reg & ISR.transmit_data_register_empty_mask) == 0, 20)){ //TODO check if this is too slow for this? Need to check busy reg - assert(false); - } + SHAL_wait_for_bit_set_us(ISR.reg,ISR.transmit_data_register_empty_mask,500); - - *getUARTTransmitDataRegister(m_key).reg = c; //Send character - */ - /* Wait until TXE (Transmit Data Register Empty) */ - while (!(USART3->ISR & USART_ISR_TXE_TXFNF)) - { - /* spin */ - } - USART3->TDR = (uint32_t)(uint8_t)c; + SHAL_set_register_value(getUARTTransmitDataRegister(m_key).reg,static_cast(c)); } diff --git a/SHAL/Src/User_Config.h b/SHAL/Src/User_Config.h new file mode 100644 index 0000000..f241ede --- /dev/null +++ b/SHAL/Src/User_Config.h @@ -0,0 +1,27 @@ +// +// Created by luca.lizaranzu on 3/20/2026. +// + +#ifndef SHMINGO_HAL_USER_CONFIG_H +#define SHMINGO_HAL_USER_CONFIG_H + +#include "SHAL.h" + +//EDIT CONFIG HERE -------------------------------------------------------------------------------------------------------------------------------------------- + +constexpr int NUM_TIMER_GPIOS = 1; +constexpr int NUM_ADC_PINS = 2; + +constexpr gpioTimerMap gpioTimerInfo[NUM_TIMER_GPIOS] = { //Add a GPIO config if you want to use it with a timer output (inverted channels not supported yet + {GPIO_Key::A3,"TIM2",SHAL_Timer_Channel::CH4, GPIO_Alternate_Function::AF1} +}; + +constexpr adcMap adcInfo[NUM_ADC_PINS] = { + {GPIO_Key::A1, SHAL_ADC_Channel::CH17}, + {GPIO_Key::A3, SHAL_ADC_Channel::CH15}, +}; + + +//\\EDIT CONFIG HERE ------------------------------------------------------------------------------------------------------------------------------------------ + +#endif //SHMINGO_HAL_USER_CONFIG_H \ No newline at end of file diff --git a/SHAL/Src/main.cpp b/SHAL/Src/main.cpp index 5325f96..8b98e63 100644 --- a/SHAL/Src/main.cpp +++ b/SHAL/Src/main.cpp @@ -1,23 +1,274 @@ #include "SHAL.h" +#include +#include +#include + + +char UARTRxBytes[60]; +int curr_uart_char = 0; + +void UARTCommandHandler(const char* string); + +extern "C" void USART3_IRQHandler(void) +{ + // Check RXNE flag (receive register not empty) + + if (USART3->ISR & USART_ISR_RXNE_RXFNE) + { + auto byte = static_cast((USART3->RDR & 0xFF)); + + + if (byte == '\r' || byte == '\n'){ //Enter case + SHAL_UART3.sendString("\r\n"); + + UARTCommandHandler(UARTRxBytes); + + for (char & UARTRxByte : UARTRxBytes) { //Clear array + UARTRxByte = 0; + } + curr_uart_char = 0; + } + + else if (byte == 0x7F || byte == 0x08){ //Backspace case + if (curr_uart_char > 0) { + UARTRxBytes[--curr_uart_char] = 0; + SHAL_UART3.sendChar(0x08); //Move cursor back + SHAL_UART3.sendChar(' '); //Send space + SHAL_UART3.sendChar(0x08); //Move cursor back + } + } + + + else { + SHAL_UART3.sendChar(byte); + UARTRxBytes[curr_uart_char] = byte; + curr_uart_char++; + } + } +} + +struct timerInfo { + const char* name{}; + Timer timer; +}; + +struct gpioTimerMap { + GPIO_Key key; + const char* timerName; + SHAL_Timer_Channel channel; + GPIO_Alternate_Function af; +}; + +struct adcMap { + GPIO_Key key; + SHAL_ADC_Channel channel; +}; + +constexpr int NUM_TIMERS = 14; + +const timerInfo timers[NUM_TIMERS] = { + {"TIM1", SHAL_TIM1}, + {"TIM2", SHAL_TIM2}, + {"TIM3", SHAL_TIM3}, + {"TIM4", SHAL_TIM4}, + {"TIM5", SHAL_TIM5}, + {"TIM6", SHAL_TIM6}, + {"TIM7", SHAL_TIM7}, + {"TIM8", SHAL_TIM8}, + {"TIM12", SHAL_TIM12}, + {"TIM13", SHAL_TIM13}, + {"TIM14", SHAL_TIM14}, + {"TIM15", SHAL_TIM15}, + {"TIM16", SHAL_TIM16}, + {"TIM17", SHAL_TIM17}, +}; + +#include "User_Config.h" + +void UARTCommandHandler(const char* string) +{ + char words[10][12]; //10 words max, 6 chars + null terminator + int curr_word = 0; + int curr_char = 0; + + for (size_t i = 0; i < 60 && curr_word < 10; i++) + { + char c = string[i]; + + if (c == ' ' || c == '\0') + { + if (curr_char > 0) // Ignore multiple spaces + { + words[curr_word][curr_char] = '\0'; // Null terminate + curr_word++; + curr_char = 0; // Reset for next word + } + + if (c == '\0') break; //End of string + } + else if (curr_char < 11) + { + words[curr_word][curr_char++] = c; + } + } + + if (words[0][0] == 'P') { //Pin starts with P + //Check for valid pin + const uint8_t portNum = static_cast(words[0][1]) - 'A'; //Port number + const auto pinNum = atoi((words[0] + 2)); //Pin number + + if ((portNum < AVAILABLE_PORTS - 1) && (pinNum < PINS_PER_PORT)) { //Valid pin + + auto pin = GPIOManager::get(portNum,pinNum); //Get GPIO pin + + if (strcmp(words[1], "SET") == 0) { //SET ------------------------------------------ + + if (curr_word < 3) return; //No subcommand, seg fault + + pin.setPinMode(PinMode::OUTPUT_MODE); + + if (strcmp(words[2], "HIGH") == 0) { //GPIO toggle + pin.setHigh(); + } + else if (strcmp(words[2], "LOW") == 0) { + pin.setLow(); + } + } + else if (strcmp(words[1], "TOG") == 0) { //TOGGLE ------------------------------------------ + pin.setPinMode(PinMode::OUTPUT_MODE); + pin.toggle(); + } + else if (strcmp(words[1], "READ") == 0) { //TOGGLE ------------------------------------------ + pin.setPinMode(PinMode::INPUT_MODE); + + SHAL_delay_us(10); + + const uint16_t val = pin.digitalRead(); + char buff[8]; + snprintf(buff, 8, "%d\r\n", val); + SHAL_UART3.sendString(buff); + } + else if (strcmp(words[1], "ADC") == 0) { //ADC READ ------------------------------------------- + pin.setPinMode(PinMode::ANALOG_MODE); + + SHAL_ADC_Channel channel; + bool found = false; + + for (adcMap map : adcInfo) { + if (pin.getKey() == map.key) { + channel = map.channel; + found = true; + } + } + + if (!found) { + SHAL_UART3.sendString("INVALID ADC\r\n"); + return; + } + + const auto res = SHAL_ADC1.singleConvertSingle(channel, SHAL_ADC_SampleTime::C8); + + char buff[32]; + uint32_t millivolts = ((uint32_t)res * 3300) / 65535; + snprintf(buff, sizeof(buff), "%lu.%03lu V\r\n", millivolts / 1000, millivolts % 1000); + SHAL_UART3.sendString(buff); + } + }else { + SHAL_UART3.sendString("INVALID PIN"); + } + } + else if (strncmp(words[0],"TIM",3) == 0) { //Timer control --------------------------------------------- + const char* timNumStr = words[0]; + int timerNum = 0; + bool validTimer = false; + + for (int i = 0; i < NUM_TIMERS; i++) { //Num timers + if (strcmp(timers[i].name,timNumStr) == 0) { + validTimer = true; + timerNum = i; + break; + } + } + + if (!validTimer) { + SHAL_UART3.sendString("INVALID TIMER\r\n"); + return; + } + + Timer currTimer = timers[timerNum].timer; //get our timer + + if (strcmp(words[1], "START") == 0) { //SET ------------------------------------------ + currTimer.init(); + + currTimer.start(); + + SHAL_UART3.sendString("Started timer\r\n"); + } + else if (strcmp(words[1], "STOP") == 0) { + currTimer.stop(); + SHAL_UART3.sendString("Stopped timer\r\n"); + + } + else if (strncmp(words[1], "CH",2) == 0) { //Channel selection + + int channelNum = atoi((words[1] + 2)); + auto timerChannel = static_cast(channelNum); + + if (strcmp(words[2], "PWM") == 0) { + currTimer.stop(); + + for (int i = 0; i < NUM_TIMER_GPIOS; i++) { + if (strcmp(gpioTimerInfo[i].timerName,words[0]) == 0) { + if (gpioTimerInfo[i].channel == timerChannel) { + + auto gpio_key = gpioTimerInfo[i].key; + auto gpio = GPIOManager::get(gpio_key); + + gpio.setPinMode(PinMode::ALTERNATE_FUNCTION_MODE); + gpio.setAlternateFunction(gpioTimerInfo[i].af); + + break; + + } + } + } + + const uint32_t psc = atoi(words[3]); + const uint32_t arr = atoi(words[4]); + const uint32_t cc = atoi(words[5]); + + currTimer.init(); + + currTimer.configurePWM(timerChannel,psc,arr,cc); + + currTimer.start(); + } + } + else { + SHAL_UART3.sendString("BAD TIM COMMAND\r\n"); + return; + } + } +} + int main() { SHAL_init(); - PIN(C0).setPinMode(PinMode::OUTPUT_MODE); + NVIC_SetPriority(USART3_IRQn, 1); //Enable UART interrupts + NVIC_EnableIRQ(USART3_IRQn); SHAL_UART3.init(UART_Pair_Key::Tx3D8_Rx3D9); SHAL_UART3.begin(115200,SHAL_USART_Word_Length::Bits_8); - SHAL_UART3.sendChar('a'); + SHAL_ADC1.init(ADC_Key::S_ADC1, SHAL_ADC_Sample_Mode::SINGLE_ENDED); + + for (const adcMap map : adcInfo) { + SHAL_ADC1.preselectChannel(map.channel); + } while (true) { - SHAL_UART3.sendString("Hello"); - - PIN(C0).toggle(); - - SHAL_delay_ms(500); } - return 0; } \ No newline at end of file