Center Aligned (#503)

* some changes to make work centeraligned

* added a new pwm_type called is_center_aligned

* Add dual center PWM and revert changes to phased config

* take values as references in for loop

---------

Co-authored-by: jmaralo <martinezalonsojn@gmail.com>
Co-authored-by: Juan Martinez <114561048+jmaralo@users.noreply.github.com>

Author: oganigl

Inc/HALAL/HALAL.hpp

@@ -10,6 +10,7 @@
 #include "HALAL/Services/ADC/ADC.hpp"
 #include "HALAL/Services/PWM/PWM/PWM.hpp"
 #include "HALAL/Services/PWM/DualPWM/DualPWM.hpp"
+#include "HALAL/Services/PWM/DualCenterPWM/DualCenterPWM.hpp"
 #include "HALAL/Services/PWM/PhasedPWM/PhasedPWM.hpp"
 #include "HALAL/Services/PWM/DualPhasedPWM/DualPhasedPWM.hpp"
 #include "HALAL/Services/Time/Time.hpp"

Inc/HALAL/Models/TimerPeripheral/TimerPeripheral.hpp

@@ -30,7 +30,8 @@ class TimerPeripheral {
 public:
 	enum PWM_MODE : uint8_t {
 		NORMAL = 0,
-		PHASED = 1
+		PHASED = 1,
+		CENTER_ALIGNED = 2
 	};
 
 	enum TIM_TYPE {

Inc/HALAL/Services/PWM/DualCenterPWM/DualCenterPWM.hpp

@@ -0,0 +1,10 @@
+#pragma once
+
+#include "HALAL/Services/PWM/DualPWM/DualPWM.hpp"
+
+class DualCenterPWM : public DualPWM {
+   public:
+    DualCenterPWM(Pin& pin, Pin& pin_negated);
+
+    void set_frequency(uint32_t freq_in_hz);
+};

Inc/HALAL/Services/PWM/PWM/PWM.hpp

@@ -20,6 +20,7 @@ class PWM {
 	float duty_cycle;
 	uint32_t frequency;
 	bool is_on = false;
+	bool is_center_aligned = false;
 	static constexpr float CLOCK_FREQ_MHZ_WITHOUT_PRESCALER = 275;
 	static constexpr float clock_period_ns = (1/CLOCK_FREQ_MHZ_WITHOUT_PRESCALER)*1'000;
 	bool is_initialized = false;

Src/HALAL/Models/TimerPeripheral/TimerPeripheral.cpp

@@ -47,17 +47,21 @@ void TimerPeripheral::init() {
 		handle->Instance = handle_to_timer[handle];
 		handle->Init.Prescaler = init_data.prescaler;
 		handle->Init.CounterMode = TIM_COUNTERMODE_UP;
-		for (PWMData pwm_data : init_data.pwm_channels) {
+		handle->Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
+        for (PWMData &pwm_data : init_data.pwm_channels) {
 			if (pwm_data.mode == PHASED) {
 				handle->Init.CounterMode = TIM_COUNTERMODE_CENTERALIGNED1;
+			    break;
+			} else if (pwm_data.mode == CENTER_ALIGNED) {
+				handle->Init.CounterMode = TIM_COUNTERMODE_CENTERALIGNED3;
+				handle->Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_ENABLE;
 				break;
 			}
 		}
 		handle->Init.Period = init_data.period;
-		handle->Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
-		handle->Init.RepetitionCounter = 0;
-		handle->Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
-
+        handle->Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
+        handle->Init.RepetitionCounter = 0;
+		
 		if (init_data.type == BASE) {
 			if (HAL_TIM_Base_Init(handle) != HAL_OK){
 				ErrorHandler("Unable to init base timer on %d", name.c_str());
@@ -87,7 +91,7 @@ void TimerPeripheral::init() {
 			ErrorHandler("Unable to configure master synchronization on %d", name.c_str());
 		}
 
-		for (pair<uint32_t, uint32_t> channels_rising_falling : init_data.input_capture_channels) {
+		for (pair<uint32_t, uint32_t> &channels_rising_falling : init_data.input_capture_channels) {
 			sConfigIC.ICPolarity = TIM_INPUTCHANNELPOLARITY_RISING;
 			sConfigIC.ICPrescaler = TIM_ICPSC_DIV1;
 			sConfigIC.ICFilter = 0;
@@ -103,7 +107,7 @@ void TimerPeripheral::init() {
 			}
 		}
 
-		for (PWMData pwm_data : init_data.pwm_channels) {
+		for (PWMData &pwm_data : init_data.pwm_channels) {
 			sConfigOC.OCPolarity = init_data.polarity;
 			sConfigOC.OCNPolarity = init_data.negated_polarity;
 			sConfigOC.OCFastMode = TIM_OCFAST_DISABLE;
@@ -155,7 +159,7 @@ void TimerPeripheral::init() {
 }
 
 void TimerPeripheral::start() {
-	for (TimerPeripheral timer : timers) {
+	for (TimerPeripheral &timer : timers) {
 		if (timer.is_registered()) {
 			timer.init();
 		}

Src/HALAL/Services/PWM/DualCenterPWM/DualCenterPWM.cpp

@@ -0,0 +1,37 @@
+#include "HALAL/Services/PWM/DualCenterPWM/DualCenterPWM.hpp"
+
+DualCenterPWM::DualCenterPWM(Pin& pin, Pin& pin_negated) {
+    if (not TimerPeripheral::available_dual_pwms.contains({pin, pin_negated})) {
+        ErrorHandler(
+            "Pins %s and %s are not registered as an available Dual PWM",
+            pin.to_string(), pin_negated.to_string());
+    }
+
+    TimerPeripheral& timer =
+        TimerPeripheral::available_dual_pwms.at({pin, pin_negated}).first;
+    TimerPeripheral::PWMData& pwm_data =
+        TimerPeripheral::available_dual_pwms.at({pin, pin_negated}).second;
+
+    peripheral = &timer;
+    channel = pwm_data.channel;
+
+    if (pwm_data.mode != TimerPeripheral::PWM_MODE::CENTER_ALIGNED) {
+        ErrorHandler(
+            "Pins %s and %s are not registered as a CENTER ALIGNED PWM",
+            pin.to_string(), pin_negated.to_string());
+    }
+
+    Pin::inscribe(pin, TIMER_ALTERNATE_FUNCTION);
+    Pin::inscribe(pin_negated, TIMER_ALTERNATE_FUNCTION);
+    timer.init_data.pwm_channels.push_back(pwm_data);
+
+    duty_cycle = 0;
+}
+
+void DualCenterPWM::set_frequency(uint32_t freq_in_hz) {
+    this->frequency = freq_in_hz;
+    TIM_TypeDef& timer = *peripheral->handle->Instance;
+    timer.ARR =
+        (HAL_RCC_GetPCLK1Freq() * 2 / (timer.PSC + 1)) / (frequency * 2);
+    set_duty_cycle(duty_cycle);
+}

Src/HALAL/Services/PWM/PWM/PWM.cpp

@@ -19,8 +19,11 @@ PWM::PWM(Pin& pin) {
 	TimerPeripheral& timer = TimerPeripheral::available_pwm.at(pin).first;
 	TimerPeripheral::PWMData& pwm_data = TimerPeripheral::available_pwm.at(pin).second;
 
-	if (pwm_data.mode != TimerPeripheral::PWM_MODE::NORMAL) {
-		ErrorHandler("Pin %s is not registered as a NORMAL PWM", pin.to_string());
+    if (pwm_data.mode == TimerPeripheral::PWM_MODE::CENTER_ALIGNED) {
+		is_center_aligned = true;
+	}
+	if(pwm_data.mode == TimerPeripheral::PWM_MODE::PHASED){
+		ErrorHandler("Pin %s is registered as Phased being a single PWM", pin.to_string());
 	}
 
 	peripheral = &timer;
@@ -59,9 +62,12 @@ void PWM::set_duty_cycle(float duty_cycle) {
 }
 
 void PWM::set_frequency(uint32_t frequency) {
+	if(is_center_aligned){
+		frequency = 2*frequency;
+	}
 	this->frequency = frequency;
 	TIM_TypeDef& timer = *peripheral->handle->Instance;
-	timer.ARR = (HAL_RCC_GetPCLK1Freq()*2 / (timer.PSC+1)) / frequency;
+    timer.ARR = (HAL_RCC_GetPCLK1Freq() * 2 / (timer.PSC + 1)) / frequency;
 	set_duty_cycle(duty_cycle);
 }