Test program done

SHAL/Src/STM32H7xx/Core/SHAL_CORE.cpp

@@ -4,6 +4,8 @@
 
 #include "SHAL_CORE.h"
 
+#include <cassert>
+
 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;
+}

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 <cstdio>
+
+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<uint32_t>(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<uint32_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(key)];
+}
+
+SHAL_ADC& ADCManager::getByIndex(int index) {
+
+    if(index < static_cast<int>(ADC_Key::NUM_ADC)){
+        return m_ADCs[index];
+    }
+    return m_ADCs[0];
+}

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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<GPIO_Key>(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)];
 }

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<uint8_t>(mainOutputMode) << ((channelNum - 1) * channelStride)); //xxBB shifted by c - 1
     setValue |= (static_cast<uint8_t>(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);
 }
 
 

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<uint32_t>(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<uint32_t>(c));
 }
 
 

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

SHAL/Src/main.cpp

@@ -1,23 +1,274 @@
 #include "SHAL.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+
+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<uint8_t>((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<uint8_t>(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<SHAL_Timer_Channel>(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;
 }