Merge remote-tracking branch 'origin/MB'

MyDrivers/GPIO.c

@@ -1,2 +1,35 @@
 #include "GPIO.h"
+#include "stm32f1xx_ll_gpio.h"
 
+void GPIO_conf(GPIO_TypeDef * GPIOx, uint32_t PINx, uint32_t mode, uint32_t outputType, uint32_t pullMode){
+	
+	LL_GPIO_InitTypeDef init;
+	
+	//Activation de l'horloge
+	if (GPIOx == GPIOA) LL_APB2_GRP1_EnableClock(LL_APB2_GRP1_PERIPH_GPIOA);
+	else if (GPIOx == GPIOB) LL_APB2_GRP1_EnableClock(LL_APB2_GRP1_PERIPH_GPIOB);
+	else if (GPIOx == GPIOC) LL_APB2_GRP1_EnableClock(LL_APB2_GRP1_PERIPH_GPIOC);
+	else if (GPIOx == GPIOD) LL_APB2_GRP1_EnableClock(LL_APB2_GRP1_PERIPH_GPIOD);
+	
+	//Configuration du PIN
+	LL_GPIO_StructInit(&init);
+	init.Pin = PINx;
+	init.Mode = mode;
+	//init.Speed = ;
+	init.OutputType = outputType;
+	init.Pull = pullMode;
+	LL_GPIO_Init(GPIOx, &init);
+}
+
+void GPIO_setPin(GPIO_TypeDef * GPIOx, uint32_t PINx, int output){
+	
+	if (output) LL_GPIO_SetOutputPin(GPIOx, PINx);
+	else LL_GPIO_ResetOutputPin(GPIOx,PINx);
+	
+};
+
+int GPIO_readPin(GPIO_TypeDef * GPIOx, uint32_t PINx){
+	
+	return LL_GPIO_IsOutputPinSet(GPIOx, PINx);
+	
+}

MyDrivers/GPIO.h

@@ -1,4 +1,23 @@
 #ifndef GPIO_H
 #define GPIO_H
 
+#include "stm32f103xb.h"
+#include "stm32f1xx_ll_gpio.h"
+#include "stm32f1xx_ll_bus.h"
+
+
+/**
+	* @brief  Configure le GPIO considéré
+	* @note   
+	* @param  GPIO_TypeDef * GPIOx indique le GPIO à configurer : GPIOA, GPIOB, GPIOC ou GPIOD
+	uint32_t PINx indique le PIN à configurer, sous la forme LL_GPIO_PIN_x
+	Pour une liste des modes disponibles, consulter la librairie LL
+	* @retval None
+	*/
+void GPIO_conf(GPIO_TypeDef * GPIOx, uint32_t PINx, uint32_t mode, uint32_t outputType, uint32_t pullMode);
+
+void GPIO_setPin(GPIO_TypeDef * GPIOx, uint32_t PINx, int output);
+
+int GPIO_readPin(GPIO_TypeDef * GPIOx, uint32_t PINx);
+
 #endif

MyDrivers/Timer.c

@@ -1,182 +1,247 @@
-// TOUT A FAIRE !! //
-
-/*
- indispensable pour pouvoir adresser les registres des périphériques.
- Rem : OBLIGATION d'utiliser les définitions utiles contenues dans ce fichier (ex : TIM_CR1_CEN, RCC_APB1ENR_TIM2EN ...)
- pour une meilleure lisibilité du code.
-
- Pour les masques, utiliser également les définitions proposée
- Rappel : pour mettre à 1  , reg = reg | Mask (ou Mask est le représente le ou les bits à positionner à 1)
-				  pour mettre à 0  , reg = reg&~ Mask (ou Mask est le représente le ou les bits à positionner à 0)
- 
-*/ 
-
 #include "Timer.h"
 #include "stm32f1xx_ll_bus.h" // Pour l'activation des horloges
-#include "stm32f1xx_ll_tim.h" 
+#include "stm32f1xx_ll_tim.h" // Pour les timers
 
 
-// variable pointeur de fonction permettant de mémoriser le callback à appeler depuis
+/****************************************************************************
+	*																	INTERRUPTIONS
+	***************************************************************************/
+
+
+// variable pointeur de fonction permettant de m<>moriser le callback <20> appeler depuis
 // le handler d'IT
-void (*Ptr_ItFct_TIM1)(void); 
-void (*Ptr_ItFct_TIM2)(void); 
-void (*Ptr_ItFct_TIM3)(void); 
-void (*Ptr_ItFct_TIM4)(void); 
+void (*it_callback_TIM1)(void); 
+void (*it_callback_TIM2)(void); 
+void (*it_callback_TIM3)(void); 
+void (*it_callback_TIM4)(void); 
 
 
-
-
-/**
-	* @brief  Active l'horloge et règle l'ARR et le PSC du timer visé
-  * @note   Fonction à lancer avant toute autre. Le timer n'est pas encore lancé (voir MyTimerStart)
-	* @param  TIM_TypeDef Timer : indique le timer à utiliser par le chronomètre, TIM1, TIM2, TIM3 ou TIM4
-	* 				int Arr   : valeur à placer dans ARR
-	*					int Psc   : valeur à placer dans PSC
-  * @retval None
-  */
-void MyTimer_Conf(TIM_TypeDef * Timer,int Arr, int Psc)
-{
-	LL_TIM_InitTypeDef My_LL_Tim_Init_Struct;
-	
-	// Validation horloge locale
-	if (Timer==TIM1) LL_APB2_GRP1_EnableClock(LL_APB2_GRP1_PERIPH_TIM1);
-	else if (Timer==TIM2) LL_APB1_GRP1_EnableClock(LL_APB1_GRP1_PERIPH_TIM2);
-	else if (Timer==TIM3) LL_APB1_GRP1_EnableClock(LL_APB1_GRP1_PERIPH_TIM3);
-	else  LL_APB1_GRP1_EnableClock(LL_APB1_GRP1_PERIPH_TIM4);
-	
-	// chargement structure Arr, Psc, Up Count
-	My_LL_Tim_Init_Struct.Autoreload=Arr;
-	My_LL_Tim_Init_Struct.Prescaler=Psc;
-	My_LL_Tim_Init_Struct.ClockDivision=LL_TIM_CLOCKDIVISION_DIV1;
-	My_LL_Tim_Init_Struct.CounterMode=LL_TIM_COUNTERMODE_UP;
-	My_LL_Tim_Init_Struct.RepetitionCounter=0;
-	
-	LL_TIM_Init(Timer,&My_LL_Tim_Init_Struct);
-	
-
-	// Blocage IT
-	LL_TIM_DisableIT_UPDATE(Timer);
-	
-	
-	// Blocage Timer
-	LL_TIM_DisableCounter(Timer);
-	
-
-		
-}
-
-
-/**
-	* @brief  Démarre le timer considéré
-  * @note   
-	* @param  TIM_TypeDef Timer : indique le timer à utiliser par le chronomètre, TIM1, TIM2, TIM3 ou TIM4
-  * @retval None
-  */
-void MyTimer_Start(TIM_TypeDef * Timer)
-{
-		LL_TIM_EnableCounter(Timer);
-}
-
-/**
-	* @brief  Arrêt le timer considéré
-  * @note   
-	* @param  TIM_TypeDef Timer : indique le timer à utiliser par le chronomètre, TIM1, TIM2, TIM3 ou TIM4
-  * @retval None
-  */
-void MyTimer_Stop(TIM_TypeDef * Timer)
-{
-	LL_TIM_DisableCounter(Timer);
-}
-
-
-/**
-	* @brief  Configure le Timer considéré en interruption sur débordement.
-  * @note   A ce stade, les interruptions ne sont pas validés (voir  MyTimer_IT_Enable )
-	* @param  TIM_TypeDef Timer : indique le timer à utiliser par le chronomètre, TIM1, TIM2, TIM3 ou TIM4
-	* 				void (*IT_function) (void) : nom (adresse) de la fonction à lancer sur interruption
-	*         int Prio : priorité associée à l'interruption
-  * @retval None
-  */
-void MyTimer_IT_Conf(TIM_TypeDef * Timer, void (*IT_function) (void),int Prio)
-{
-	// affectation de la fonction
-	if (Timer==TIM1) Ptr_ItFct_TIM1=IT_function;
-	else if (Timer==TIM2)	Ptr_ItFct_TIM2=IT_function;
-	else if (Timer==TIM3)	Ptr_ItFct_TIM3=IT_function;
-	else  Ptr_ItFct_TIM4=IT_function;
-
-	
-	// Blocage IT (il faudra la débloquer voir fct suivante)
-	LL_TIM_DisableIT_UPDATE(Timer);
-	
-	// validation du canal NVIC
-	IRQn_Type TIM_irq;
-	
-	if (Timer==TIM1) TIM_irq=TIM1_UP_IRQn;
-	else if (Timer==TIM2)	TIM_irq=TIM2_IRQn;
-	else if (Timer==TIM3)	TIM_irq=TIM3_IRQn;
-	else 	TIM_irq=TIM4_IRQn;
-	
-	NVIC_SetPriority(TIM_irq, Prio);
-	NVIC_EnableIRQ(TIM_irq);
-
-	
-}
-
-
-/**
-	* @brief  Autorise les interruptions
-  * @note   
-	* @param  TIM_TypeDef Timer : indique le timer à utiliser par le chronomètre, TIM1, TIM2, TIM3 ou TIM4
-  * @retval None
-  */
-void MyTimer_IT_Enable(TIM_TypeDef * Timer)
-{
-		LL_TIM_EnableIT_UPDATE(Timer);
-}
-
-
-/**
-	* @brief  Interdit les interruptions
-  * @note   
-	* @param  TIM_TypeDef Timer : indique le timer à utiliser par le chronomètre, TIM1, TIM2, TIM3 ou TIM4
-  * @retval None
-  */
-void MyTimer_IT_Disable(TIM_TypeDef * Timer)
-{
-			LL_TIM_DisableIT_UPDATE(Timer); 
-}	
-
-
-/*
-============ LES INTERRUPTIONS =================================
-
-*/
-
 void TIM1_UP_IRQHandler(void)
 {
 	// rabaisser le flag d'IT
 	LL_TIM_ClearFlag_UPDATE(TIM1);
-	(*Ptr_ItFct_TIM1)();
+	(*it_callback_TIM1)();
 }	
 
 void TIM2_IRQHandler(void)
 {
 	// rabaisser le flag d'IT
 	LL_TIM_ClearFlag_UPDATE(TIM2);
-	(*Ptr_ItFct_TIM2)();
+	(*it_callback_TIM2)();
 }	
 
 void TIM3_IRQHandler(void)
 {
 	// rabaisser le flag d'IT
 	LL_TIM_ClearFlag_UPDATE(TIM3);
-	(*Ptr_ItFct_TIM3)();
+	(*it_callback_TIM3)();
 }	
 
 void TIM4_IRQHandler(void)
 {
 	// rabaisser le flag d'IT
 	LL_TIM_ClearFlag_UPDATE(TIM4);
-	(*Ptr_ItFct_TIM4)();
+	(*it_callback_TIM4)();
 }	
+
+
+/**
+	* @brief  Autorise les interruptions
+	* @note   
+	* @param  TIM_TypeDef Timer : indique le timer <EFBFBD> utiliser par le chronom<EFBFBD>tre, TIM1, TIM2, TIM3 ou TIM4
+	* @retval None
+	*/
+void Timer_IT_enable(TIM_TypeDef * timer)
+{
+	LL_TIM_EnableIT_UPDATE(timer);
+}
+
+
+/**
+	* @brief  Interdit les interruptions
+	* @note   
+	* @param  TIM_TypeDef Timer : indique le timer <EFBFBD> utiliser par le chronom<EFBFBD>tre, TIM1, TIM2, TIM3 ou TIM4
+	* @retval None
+	*/
+void Timer_IT_disable(TIM_TypeDef * timer)
+{
+	LL_TIM_DisableIT_UPDATE(timer); 
+}
+
+/**
+	* @brief  Configure le Timer consid<EFBFBD>r<EFBFBD> en interruption sur d<EFBFBD>bordement.
+	* @note   A ce stade, les interruptions ne sont pas valid<EFBFBD>s (voir  MyTimer_IT_Enable )
+	* @param  TIM_TypeDef Timer : indique le timer <EFBFBD> utiliser par le chronom<EFBFBD>tre, TIM1, TIM2, TIM3 ou TIM4
+	* 				void (*IT_function) (void) : nom (adresse) de la fonction <EFBFBD> lancer sur interruption
+	*         int Prio : priorit<EFBFBD> associ<EFBFBD>e <EFBFBD> l'interruption
+	* @retval None
+	*/
+void Timer_IT_conf(TIM_TypeDef * timer, void (*it_callback) (void), int prio)
+{
+	// affectation de la fonction
+	if (timer == TIM1) it_callback_TIM1 = it_callback;
+	else if (timer == TIM2)	it_callback_TIM2 = it_callback;
+	else if (timer == TIM3)	it_callback_TIM3 = it_callback;
+	else  it_callback_TIM4 = it_callback;
+
+	
+	// Blocage IT (il faudra la d<>bloquer voir fct suivante)
+	LL_TIM_DisableIT_UPDATE(timer);
+	
+	// validation du canal NVIC
+	IRQn_Type TIM_irq;
+	
+	if (timer == TIM1) TIM_irq = TIM1_UP_IRQn;
+	else if (timer == TIM2)	TIM_irq = TIM2_IRQn;
+	else if (timer == TIM3)	TIM_irq = TIM3_IRQn;
+	else 	TIM_irq = TIM4_IRQn;
+	
+	NVIC_SetPriority(TIM_irq, prio);
+	NVIC_EnableIRQ(TIM_irq);
+
+	
+}
+
+/****************************************************************************
+	*																	TIMER
+	***************************************************************************/
+
+/**
+	* @brief  D<EFBFBD>marre le timer consid<EFBFBD>r<EFBFBD> et active les interruptions
+	* @note   
+	* @param  TIM_TypeDef Timer : indique le timer <EFBFBD> utiliser par le chronom<EFBFBD>tre, TIM1, TIM2, TIM3 ou TIM4
+	* @retval None
+	*/
+void Timer_start(TIM_TypeDef * timer)
+{
+	LL_TIM_EnableCounter(timer);
+}
+
+/**
+	* @brief  Arr<EFBFBD>t le timer consid<EFBFBD>r<EFBFBD>  et d<EFBFBD>sactive les interruptions
+	* @note   
+	* @param  TIM_TypeDef Timer : indique le timer <EFBFBD> utiliser par le chronom<EFBFBD>tre, TIM1, TIM2, TIM3 ou TIM4
+	* @retval None
+	*/
+void Timer_stop(TIM_TypeDef * timer)
+{
+	LL_TIM_DisableCounter(timer);
+}
+
+/**
+	* @brief  Active l'horloge et r<EFBFBD>gle l'ARR et le PSC du timer vis<EFBFBD>.
+	* @note   Fonction <EFBFBD> lancer avant toute autre. Le timer n'est pas encore lanc<EFBFBD> (voir Timer_start)
+	* @param  TIM_TypeDef Timer : indique le timer <EFBFBD> utiliser par le chronom<EFBFBD>tre, TIM1, TIM2, TIM3 ou TIM4
+	* 				int Arr   : valeur <EFBFBD> placer dans ARR
+	*					int Psc   : valeur <EFBFBD> placer dans PSC
+	* @retval None
+	*/
+void Timer_conf(TIM_TypeDef * timer, int arr, int psc)
+{
+	LL_TIM_InitTypeDef init_struct;
+	
+	// Validation horloge locale
+	if (timer == TIM1) LL_APB2_GRP1_EnableClock(LL_APB2_GRP1_PERIPH_TIM1);
+	else if (timer == TIM2) LL_APB1_GRP1_EnableClock(LL_APB1_GRP1_PERIPH_TIM2);
+	else if (timer == TIM3) LL_APB1_GRP1_EnableClock(LL_APB1_GRP1_PERIPH_TIM3);
+	else  LL_APB1_GRP1_EnableClock(LL_APB1_GRP1_PERIPH_TIM4);
+	
+	// chargement structure Arr, Psc, Up Count
+	init_struct.Autoreload = arr;
+	init_struct.Prescaler = psc;
+	init_struct.ClockDivision = LL_TIM_CLOCKDIVISION_DIV1;
+	init_struct.CounterMode = LL_TIM_COUNTERMODE_UP;
+	init_struct.RepetitionCounter = 0;
+	
+	LL_TIM_Init(timer,&init_struct);
+
+	// Blocage interruptions
+	Timer_IT_disable(timer);
+	
+	// Blocage Timer
+	Timer_stop(timer);
+}
+
+/****************************************************************************
+	*																	PWM INPUT
+	***************************************************************************/
+
+
+/****************************************************************************
+	*																	PWM OUTPUT
+	***************************************************************************/
+
+int getArrFromFreq(float freq)
+{
+	return (72000000 / freq) - 1;
+}
+
+void Timer_pwmo_conf(TIM_TypeDef * timer, int channel, float freq, float dutyCycle)
+{
+	const int arr = getArrFromFreq(freq);
+	Timer_conf(timer, arr, 1000);
+	LL_TIM_OC_InitTypeDef init_struct;
+	LL_TIM_OC_StructInit(&init_struct);
+	
+	init_struct.OCMode = LL_TIM_OCMODE_PWM1;
+	init_struct.OCState = LL_TIM_OCSTATE_ENABLE;
+	init_struct.CompareValue= dutyCycle * arr;
+	
+	LL_TIM_OC_Init(timer, channel, &init_struct);
+}
+
+void Timer_pwmo_setFreq(TIM_TypeDef * timer, float freq)
+{
+	const int arr = getArrFromFreq(freq);
+	LL_TIM_SetAutoReload(timer, arr);
+}
+
+void Timer_pwmo_setDutyCycle(TIM_TypeDef * timer, int channel, float dutyCycle)
+{
+	const int arr = LL_TIM_GetAutoReload(timer);
+	int compare = dutyCycle * arr;
+	if (channel == LL_TIM_CHANNEL_CH1) LL_TIM_OC_SetCompareCH1(timer, compare);
+	else if (channel == LL_TIM_CHANNEL_CH2) LL_TIM_OC_SetCompareCH2(timer, compare);
+	else if (channel == LL_TIM_CHANNEL_CH3) LL_TIM_OC_SetCompareCH3(timer, compare);
+	else  LL_TIM_OC_SetCompareCH4(timer, compare);
+}
+
+float Timer_pwmo_getDutyCycle(TIM_TypeDef * timer, int channel)
+{
+	int compare = 0;
+	const int arr = LL_TIM_GetAutoReload(timer);
+	if (channel == LL_TIM_CHANNEL_CH1) compare = LL_TIM_OC_GetCompareCH1(timer);
+	else if (channel == LL_TIM_CHANNEL_CH2) compare = LL_TIM_OC_GetCompareCH2(timer);
+	else if (channel == LL_TIM_CHANNEL_CH3) compare = LL_TIM_OC_GetCompareCH3(timer);
+	else  compare = LL_TIM_OC_GetCompareCH4(timer);
+	return ((float) compare) / ((float) arr);
+}
+
+/****************************************************************************
+	*																ENCODER
+	***************************************************************************/
+
+void Timer_encoder_conf(TIM_TypeDef * timer)
+{
+	Timer_conf(timer, 359, 0);
+	LL_TIM_ENCODER_InitTypeDef init_struct;
+	LL_TIM_ENCODER_StructInit(&init_struct);
+	
+	init_struct.EncoderMode = LL_TIM_ENCODERMODE_X2_TI1;
+	
+	LL_TIM_ENCODER_Init(timer, &init_struct);
+}
+
+int Timer_encoder_getAngle(TIM_TypeDef * timer)
+{
+	return LL_TIM_GetCounter(timer);
+}
+
+enum CounterDirection Timer_encoder_getDirection(TIM_TypeDef * timer)
+{
+	const int dir = LL_TIM_GetDirection(timer);
+	if (dir == LL_TIM_COUNTERDIRECTION_UP)
+		return CLOCKWISE;
+	else
+		return COUNTER_CLOCKWISE;
+}

MyDrivers/Timer.h

@@ -1,70 +1,137 @@
-// RIEN A MODIFIER //
-
 #ifndef TIMER_H
 #define TIMER_H
 
-/*
-Driver pour Timer 1 à 4 du STM32F103RB
-
-*/
-
 #include "stm32f103xb.h" 
+#include "stm32f1xx_ll_tim.h" // Pour les timers
 
-/**
-	* @brief  Active l'horloge et règle l'ARR et le PSC du timer visé
-  * @note   Fonction à lancer avant toute autre. Le timer n'est pas encore lancé (voir MyTimerStart)
-	* @param  TIM_TypeDef Timer : indique le timer à utiliser par le chronomètre, TIM1, TIM2, TIM3 ou TIM4
-	* 				int Arr   : valeur à placer dans ARR
-	*					int Psc   : valeur à placer dans PSC
-  * @retval None
-  */
-void MyTimer_Conf(TIM_TypeDef * Timer,int Arr, int Psc);
+enum CounterDirection {
+	CLOCKWISE = LL_TIM_COUNTERDIRECTION_UP,
+	COUNTER_CLOCKWISE = LL_TIM_COUNTERDIRECTION_DOWN,
+};
+
+
+/****************************************************************************
+	*																	INTERRUPTIONS
+	***************************************************************************/
+
+void Timer_IT_enable(TIM_TypeDef * timer);
+
+void Timer_IT_disable(TIM_TypeDef * timer);
+
+void Timer_IT_conf(TIM_TypeDef * timer, void (*it_callback) (void), int prio);
+
+
+/****************************************************************************
+	*																	TIMER
+	***************************************************************************/
 
 
 /**
-	* @brief  Démarre le timer considéré
+	* @brief  Active l'horloge et r<EFBFBD>gle l'ARR et le PSC du timer vis<EFBFBD>
+	* @note   Fonction <EFBFBD> lancer avant toute autre. Le timer n'est pas encore lanc<EFBFBD> (voir MyTimerStart)
+	* @param  TIM_TypeDef Timer : indique le timer <EFBFBD> utiliser par le chronom<EFBFBD>tre, TIM1, TIM2, TIM3 ou TIM4
+	* 				int Arr   : valeur <EFBFBD> placer dans ARR
+	*					int Psc   : valeur <EFBFBD> placer dans PSC
+	* @retval None
+	*/
+void Timer_conf(TIM_TypeDef * timer, int arr, int psc);
+
+
+/**
+	* @brief  D<EFBFBD>marre le timer consid<EFBFBD>r<EFBFBD>
+	* @note   
+	* @param  TIM_TypeDef Timer : indique le timer <EFBFBD> utiliser par le chronom<EFBFBD>tre, TIM1, TIM2, TIM3 ou TIM4
+	* @retval None
+	*/
+void Timer_start(TIM_TypeDef * timer);
+
+
+/**
+	* @brief  Arr<EFBFBD>t le timer consid<EFBFBD>r<EFBFBD>
+	* @note   
+	* @param  TIM_TypeDef Timer : indique le timer <EFBFBD> utiliser par le chronom<EFBFBD>tre, TIM1, TIM2, TIM3 ou TIM4
+	* @retval None
+	*/
+void Timer_stop(TIM_TypeDef * timer);
+
+
+/****************************************************************************
+	*																PWM INPUT
+	***************************************************************************/
+
+void PWMi_conf(TIM_TypeDef * timer, int channel);
+
+int PWMi_getDutyCycle(TIM_TypeDef * timer, int channel);
+
+/****************************************************************************
+	*																PWM OUTPUT
+	***************************************************************************/
+
+/**
+	* @brief  Configure le timer en mode PWM output <EFBFBD> la fr<EFBFBD>quence donn<EFBFBD>e
   * @note   
-	* @param  TIM_TypeDef Timer : indique le timer à utiliser par le chronomètre, TIM1, TIM2, TIM3 ou TIM4
+	* @param  TIM_TypeDef Timer : indique le timer <EFBFBD> utiliser : TIM1, TIM2, TIM3 ou TIM4
+	*					int channel 			: Le channel utilis<EFBFBD> par la PWM
+	*					float freq  			: Fr<EFBFBD>quence en Hz (entre 2Hz et pas trop grand svp)
+	*					float dutyCycle 	: Valeur entre 0 et 1
   * @retval None
   */
-void MyTimer_Start(TIM_TypeDef * Timer);
-
+void Timer_pwmo_conf(TIM_TypeDef * timer, int channel, float freq, float dutyCycle);
 
 /**
-	* @brief  Arrêt le timer considéré
+	* @brief  Modifie la fr<EFBFBD>quence des PWMs associ<EFBFBD>es au timer donn<EFBFBD>
   * @note   
-	* @param  TIM_TypeDef Timer : indique le timer à utiliser par le chronomètre, TIM1, TIM2, TIM3 ou TIM4
+	* @param  TIM_TypeDef Timer : indique le timer <EFBFBD> utiliser : TIM1, TIM2, TIM3 ou TIM4
+	*					float freq  			: Fr<EFBFBD>quence en Hz (entre 2Hz et pas trop grand svp)
   * @retval None
   */
-void MyTimer_Stop(TIM_TypeDef * Timer);
-
+void Timer_pwmo_setFreq(TIM_TypeDef * timer, float freq);
 
 /**
-	* @brief  Configure le Timer considéré en interruption sur débordement.
-  * @note   A ce stade, les interruptions ne sont pas validés (voir  MyTimer_IT_Enable )
-	* @param  TIM_TypeDef Timer : indique le timer à utiliser par le chronomètre, TIM1, TIM2, TIM3 ou TIM4
-	* 				void (*IT_function) (void) : nom (adresse) de la fonction à lancer sur interruption
-	*         int Prio : priorité associée à l'interruption
-  * @retval None
-  */
-void MyTimer_IT_Conf(TIM_TypeDef * Timer, void (*IT_function) (void),int Prio);
-
-
-/**
-	* @brief  Autorise les interruptions
+	* @brief  Modifie le duty cycle de la PWM
   * @note   
-	* @param  TIM_TypeDef Timer : indique le timer à utiliser par le chronomètre, TIM1, TIM2, TIM3 ou TIM4
+	* @param  TIM_TypeDef Timer : indique le timer <EFBFBD> utiliser : TIM1, TIM2, TIM3 ou TIM4
+	*					int channel 			: Le channel utilis<EFBFBD> par la PWM
+	*					float dutyCycle 	: Valeur entre 0 et 1
   * @retval None
   */
-void MyTimer_IT_Enable(TIM_TypeDef * Timer);	
-
+void Timer_pwmo_setDutyCycle(TIM_TypeDef * timer, int channel, float dutyCycle);
 
 /**
-	* @brief  Interdit les interruptions
+	* @brief  R<EFBFBD>cup<EFBFBD>re le duty cycle de la PWM
   * @note   
-	* @param  TIM_TypeDef Timer : indique le timer à utiliser par le chronomètre, TIM1, TIM2, TIM3 ou TIM4
+	* @param  TIM_TypeDef Timer : indique le timer <EFBFBD> utiliser : TIM1, TIM2, TIM3 ou TIM4
+	*					int channel 			: Le channel utilis<EFBFBD> par la PWM
+  * @retval float dutyCycle
+  */
+float Timer_pwmo_getDutyCycle(TIM_TypeDef * timer, int channel);
+
+/****************************************************************************
+	*																ENCODER
+	***************************************************************************/
+
+/**
+	* @brief  Configure le timer en mode encoder
+  * @note   
+	* @param  TIM_TypeDef Timer : indique le timer <EFBFBD> utiliser : TIM1, TIM2, TIM3 ou TIM4
   * @retval None
   */
-void MyTimer_IT_Disable(TIM_TypeDef * Timer);
+void Timer_encoder_conf(TIM_TypeDef * timer);
+
+/**
+	* @brief  R<EFBFBD>cup<EFBFBD>re l'angle, en degr<EFBFBD>s
+  * @note   
+	* @param  TIM_TypeDef Timer : indique le timer <EFBFBD> utiliser : TIM1, TIM2, TIM3 ou TIM4
+  * @retval None
+  */
+int Timer_encoder_getAngle(TIM_TypeDef * timer);
+
+/**
+	* @brief  R<EFBFBD>cup<EFBFBD>re la direction
+  * @note   
+	* @param  TIM_TypeDef Timer : indique le timer <EFBFBD> utiliser : TIM1, TIM2, TIM3 ou TIM4
+  * @retval None
+  */
+enum CounterDirection Timer_encoder_getDirection(TIM_TypeDef * timer);
 
 #endif

Services/Chrono.c

@@ -21,114 +21,109 @@ static TIM_TypeDef * Chrono_Timer=TIM1; // init par d
 void Chrono_Task_10ms(void);
 
 /**
-	* @brief  Configure le chronomètre. 
-  * @note   A lancer avant toute autre fonction.
-	* @param  Timer : indique le timer à utiliser par le chronomètre, TIM1, TIM2, TIM3 ou TIM4
-  * @retval None
-  */
+* @brief  Configure le chronomètre. 
+* @note   A lancer avant toute autre fonction.
+* @param  Timer : indique le timer à utiliser par le chronomètre, TIM1, TIM2, TIM3 ou TIM4
+* @retval None
+*/
 void Chrono_Conf(TIM_TypeDef * Timer)
 {
-	// Reset Time
-	Chrono_Time.Hund=0;
-	Chrono_Time.Sec=0;
-	Chrono_Time.Min=0;
-	
-	// Fixation du Timer
-	Chrono_Timer=Timer;
+// Reset Time
+Chrono_Time.Hund = 0;
+Chrono_Time.Sec = 0;
+Chrono_Time.Min = 0;
 
-	// Réglage Timer pour un débordement à 10ms
-	MyTimer_Conf(Chrono_Timer,999, 719);
-	
-	// Réglage interruption du Timer avec callback : Chrono_Task_10ms()
-	MyTimer_IT_Conf(Chrono_Timer, Chrono_Task_10ms,3);
-	
-	// Validation IT
-	MyTimer_IT_Enable(Chrono_Timer);
-	
-	
+// Fixation du Timer
+Chrono_Timer = Timer;
+
+// Réglage Timer pour un débordement à 10ms
+Timer_conf(Chrono_Timer, 999, 719);
+
+// Réglage des interruptions
+Timer_IT_conf(Chrono_Timer, Chrono_Task_10ms, 3);
+Timer_IT_enable(Chrono_Timer);
 }
 
 
 /**
-	* @brief  Démarre le chronomètre. 
-  * @note   si la durée dépasse 59mn 59sec 99 Hund, elle est remise à zéro et repart
-	* @param  Aucun
-  * @retval Aucun
-  */
+* @brief  Démarre le chronomètre. 
+* @note   si la durée dépasse 59mn 59sec 99 Hund, elle est remise à zéro et repart
+* @param  Aucun
+* @retval Aucun
+*/
 void Chrono_Start(void)
 {
-	MyTimer_Start(Chrono_Timer);
+Timer_start(Chrono_Timer);
 }
 
 
 /**
-	* @brief  Arrête le chronomètre. 
-  * @note   
-	* @param  Aucun
-  * @retval Aucun
-  */
+* @brief  Arrête le chronomètre. 
+* @note   
+* @param  Aucun
+* @retval Aucun
+*/
 void Chrono_Stop(void)
 {
-	MyTimer_Stop(Chrono_Timer);
+Timer_stop(Chrono_Timer);
 }
 
 
 /**
-	* @brief  Remet le chronomètre à 0 
-  * @note   
-	* @param  Aucun
-  * @retval Aucun
-  */
+* @brief  Remet le chronomètre à 0 
+* @note   
+* @param  Aucun
+* @retval Aucun
+*/
 void Chrono_Reset(void)
 {
-  // Arrêt Chrono
-	MyTimer_Stop(Chrono_Timer);
+// Arrêt Chrono
+Timer_stop(Chrono_Timer);
 
-	// Reset Time
-	Chrono_Time.Hund=0;
-	Chrono_Time.Sec=0;
-	Chrono_Time.Min=0;
+// Reset Time
+Chrono_Time.Hund=0;
+Chrono_Time.Sec=0;
+Chrono_Time.Min=0;
 }
 
 
 /**
-	* @brief  Renvoie l'adresse de la variable Time privée gérée dans le module Chrono.c
-  * @note   
-	* @param  Aucun
-  * @retval adresse de la variable Time
-  */
+* @brief  Renvoie l'adresse de la variable Time privée gérée dans le module Chrono.c
+* @note   
+* @param  Aucun
+* @retval adresse de la variable Time
+*/
 Time * Chrono_Read(void)
 {
-	return &Chrono_Time;
+return &Chrono_Time;
 }
 
 
 
 
 /**
-	* @brief  incrémente la variable privée Chron_Time modulo 60mn 
-  * @note   
-	* @param  Aucun
-  * @retval Aucun
-  */
+* @brief  incrémente la variable privée Chron_Time modulo 60mn 
+* @note   
+* @param  Aucun
+* @retval Aucun
+*/
 void Chrono_Task_10ms(void)
 { 
-	Chrono_Time.Hund++;
-	if (Chrono_Time.Hund==100)
-	{
-		Chrono_Time.Sec++;
-		Chrono_Time.Hund=0;
-	}
-	if (Chrono_Time.Sec==60)
-	{
-		Chrono_Time.Min++;
-		Chrono_Time.Sec=0;
-	}
-	if (Chrono_Time.Min==60)
-	{
-		Chrono_Time.Hund=0;
-	}
-	
+Chrono_Time.Hund++;
+if (Chrono_Time.Hund==100)
+{
+Chrono_Time.Sec++;
+Chrono_Time.Hund=0;
+}
+if (Chrono_Time.Sec==60)
+{
+Chrono_Time.Min++;
+Chrono_Time.Sec=0;
+}
+if (Chrono_Time.Min==60)
+{
+Chrono_Time.Hund=0;
 }
 
+}
 

Services/Chrono.h

@@ -30,10 +30,10 @@ Les fonctions qui g
 
 /**
 	* @brief  polle les 3 entrées et gènère les actions à faire
-  * @note   Fct à lancer en tâche de fond (non bloquante)
+	* @note   Fct à lancer en tâche de fond (non bloquante)
 	* @param  None 
-  * @retval None
-  */
+	* @retval None
+	*/
 		
 void Chrono_Background(void);
 
@@ -55,10 +55,10 @@ typedef struct {
 
 /**
 	* @brief  Configure le chronomètre. 
-  * @note   A lancer avant toute autre fonction.
+	* @note   A lancer avant toute autre fonction.
 	* @param  TIM_TypeDef Timer : indique le timer à utiliser par le chronomètre, TIM1, TIM2, TIM3 ou TIM4
-  * @retval None
-  */
+	* @retval None
+	*/
 void Chrono_Conf(TIM_TypeDef * Timer);
 
 
@@ -68,37 +68,37 @@ void Chrono_Conf(TIM_TypeDef * Timer);
 
 /**
 	* @brief  Démarre le chronomètre. 
-  * @note   si la durée dépasse 59mn 59sec 99 cent, elle est remise à zéro et repart
+	* @note   si la durée dépasse 59mn 59sec 99 cent, elle est remise à zéro et repart
 	* @param  Aucun
-  * @retval Aucun
-  */
+	* @retval Aucun
+	*/
 void Chrono_Start(void);
 
 
 /**
 	* @brief  Arrête le chronomètre. 
-  * @note   
+	* @note   
 	* @param  Aucun
-  * @retval Aucun
-  */
+	* @retval Aucun
+	*/
 void Chrono_Stop(void);
 
 
 /**
 	* @brief  Remet le chronomètre à 0 
-  * @note   
+	* @note   
 	* @param  Aucun
-  * @retval Aucun
-  */
+	* @retval Aucun
+	*/
 void Chrono_Reset(void);
 
 
 /**
 	* @brief  Renvoie l'adresse de la variable Time privée gérée dans le module Chrono.c
-  * @note   
+	* @note   
 	* @param  Aucun
-  * @retval adresse de la variable Time
-  */
+	* @retval adresse de la variable Time
+	*/
 Time * Chrono_Read(void);
 
 

Services/IncrementalEncoder.c

@@ -1 +1,24 @@
 #include "IncrementalEncoder.h"
+
+#include "Timer.h"
+
+void IncrementalEncoder_conf(TIM_TypeDef * timer)
+{
+	Timer_encoder_conf(timer);
+	// TODO GPIO config
+}
+
+void IncrementalEncoder_start(TIM_TypeDef * timer)
+{
+	Timer_start(timer);
+}
+
+int IncrementalEncoder_getAngle(TIM_TypeDef * timer)
+{
+	return Timer_encoder_getAngle(timer);
+}
+
+enum CounterDirection IncrementalEncoder_getDirection(TIM_TypeDef * timer)
+{
+	return Timer_encoder_getDirection(timer);
+}

Services/IncrementalEncoder.h

@@ -1,4 +1,38 @@
 #ifndef INC_ENCODER_H
 #define INC_ENCODER_H
 
+#include "stm32f103xb.h"
+
+/**
+	* @brief  Configure le codeur incrémental associé au timer donné
+  * @note   
+	* @param  TIM_TypeDef Timer : indique le timer à utiliser : TIM1, TIM2, TIM3 ou TIM4
+  * @retval None
+  */
+void IncrementalEncoder_conf(TIM_TypeDef * timer);
+
+/**
+	* @brief  Démarre le codeur incrémental associé au timer donné
+  * @note   
+	* @param  TIM_TypeDef Timer : indique le timer à utiliser : TIM1, TIM2, TIM3 ou TIM4
+  * @retval None
+  */
+void IncrementalEncoder_start(TIM_TypeDef * timer);
+
+/**
+	* @brief  Récupère l'angle du codeur incrémental associé au timer donné
+  * @note   
+	* @param  TIM_TypeDef Timer : indique le timer à utiliser : TIM1, TIM2, TIM3 ou TIM4
+  * @retval int angle
+  */
+int IncrementalEncoder_getAngle(TIM_TypeDef * timer);
+
+/**
+	* @brief  Récupère la direction du codeur incrémental associé au timer donné
+  * @note   
+	* @param  TIM_TypeDef Timer : indique le timer à utiliser : TIM1, TIM2, TIM3 ou TIM4
+  * @retval int dir
+  */
+enum CounterDirection IncrementalEncoder_getDirection(TIM_TypeDef * timer);
+
 #endif

Services/ServoMotor.c

@@ -1 +1,25 @@
 #include "ServoMotor.h"
+#include "Timer.h"
+
+#define SERVO_MOTO_FREQ 50
+
+void ServoMotor_conf(TIM_TypeDef * timer, int channel)
+{
+	Timer_pwmo_conf(timer, channel, SERVO_MOTO_FREQ, 0);
+}
+
+void ServoMotor_start(TIM_TypeDef * timer)
+{
+	Timer_start(timer);
+}
+
+void ServoMotor_setAngle(TIM_TypeDef * timer, int channel, int angle)
+{
+	Timer_pwmo_setDutyCycle(timer, channel, ((float) angle) / 359.0);
+}
+
+int ServoMotor_getAngle(TIM_TypeDef * timer, int channel)
+{
+	const float dutyCycle = Timer_pwmo_getDutyCycle(timer, channel);
+	return 359 * dutyCycle;
+}

Services/ServoMotor.h

@@ -1,4 +1,42 @@
 #ifndef SERVO_MOTOR_H
 #define SERVO_MOTOR_H
 
+#include "stm32f103xb.h"
+
+/**
+	* @brief  Configure le servo moteur associé au timer donné
+  * @note   
+	* @param  TIM_TypeDef Timer : indique le timer à utiliser : TIM1, TIM2, TIM3 ou TIM4
+	*					int channel 			: Le channel utilisé par le servo moteur
+  * @retval None
+  */
+void ServoMotor_conf(TIM_TypeDef * timer, int channel);
+
+/**
+	* @brief  Démarre les servo moteurs associés au timer donné
+  * @note   
+	* @param  TIM_TypeDef Timer : indique le timer à utiliser : TIM1, TIM2, TIM3 ou TIM4
+  * @retval None
+  */
+void ServoMotor_start(TIM_TypeDef * timer);
+
+/**
+	* @brief  Modifie l'angle du servo moteur
+  * @note   
+	* @param  TIM_TypeDef Timer : indique le timer à utiliser : TIM1, TIM2, TIM3 ou TIM4
+	*					int channel 			: Le channel utilisé par le servo moteur
+	*					float angle			 	: .En degrès (Valeur entre 0 et 359)
+  * @retval None
+  */
+void ServoMotor_setAngle(TIM_TypeDef * timer, int channel, int angle);
+
+/**
+	* @brief  Récupère l'angle du servo moteur
+  * @note   
+	* @param  TIM_TypeDef Timer : indique le timer à utiliser : TIM1, TIM2, TIM3 ou TIM4
+	*					int channel 			: Le channel utilisé par le servo moteur
+  * @retval int angle
+  */
+int ServoMotor_getAngle(TIM_TypeDef * timer, int channel);
+
 #endif

Src/Sail.h

@@ -1,4 +1,36 @@
 #ifndef SAIL_H
 #define SAIL_H
 
+/**
+	* @brief  Configure la voile
+  * @note   
+	* @param  None
+  * @retval None
+  */
+void Sail_conf();
+
+/**
+	* @brief  Execute la tache de fond des voiles en fonction des valeurs récupérées par les drivers
+  * @note   
+	* @param  None
+  * @retval None
+  */
+void Sail_background();
+
+/**
+	* @brief  Mets la voile à 90 degres
+  * @note   
+	* @param  None
+  * @retval None
+  */
+void Sail_reset();
+
+/**
+	* @brief  Réinitialise la voile à sa position initiale
+  * @note   
+	* @param  None
+  * @retval None
+  */
+void Sail_start();
+
 #endif

Src/main.c

@@ -32,6 +32,7 @@ void  SystemClock_Config(void);
   * @retval None
   */
 	
+Time * time;
 
 int main(void)
 {
@@ -45,7 +46,7 @@ int main(void)
 	// Lancement chronomètre
 	Chrono_Start(); 
 	
-
+	time = Chrono_Read();
   
   /* Infinite loop */
   while (1)