improve doc

MyDrivers/ADC.h

@@ -3,12 +3,46 @@
 
 #include "stm32f1xx_ll_adc.h"
 
+/**
+	* @brief  Active l'horloge et calibre l'ADC donné
+  * @note   
+	* @param  ADC_TypeDef adc : indique l'ADC à utiliser
+  * @retval None
+  */
 void ADC_conf(ADC_TypeDef *adc);
+
+/**
+	* @brief  Démarre l'ADC donné
+  * @note   
+	* @param  ADC_TypeDef adc : indique l'ADC à utiliser
+  * @retval None
+  */
 void ADC_start(ADC_TypeDef *adc);
 
+/**
+	* @brief  Récupère la valeur brute donnée par l'ADC
+  * @note   
+	* @param  ADC_TypeDef adc : indique l'ADC à utiliser
+	* 				int channel 		: le channel à lire
+  * @retval Valeur brute lue
+  */
 uint16_t ADC_readRaw(ADC_TypeDef *adc, int channel);
+
+/**
+	* @brief  Récupère la valeur en volts donnée par l'ADC
+  * @note   
+	* @param  ADC_TypeDef adc : indique l'ADC à utiliser
+	* 				int channel 		: le channel à lire
+  * @retval Valeur lue en volts
+  */
 float ADC_readVolt(ADC_TypeDef *adc, int channel);
 
+/**
+	* @brief  Converti la valeur brute donnée en volts
+  * @note   
+	* @param  int value : La valeur à convertir
+  * @retval La conversion en volts
+  */
 float ADC_convertToVolt(uint16_t value);
 
 

MyDrivers/GPIO.c

@@ -1,37 +1,37 @@
 #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)
+void GPIO_conf(GPIO_TypeDef * gpio, uint32_t pin, 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);
+	if (gpio == 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 (gpio == 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 (gpio == GPIOC) LL_APB2_GRP1_EnableClock(LL_APB2_GRP1_PERIPH_GPIOC);
-	else if (GPIOx == GPIOD) LL_APB2_GRP1_EnableClock(LL_APB2_GRP1_PERIPH_GPIOD);
+	else if (gpio == GPIOD) LL_APB2_GRP1_EnableClock(LL_APB2_GRP1_PERIPH_GPIOD);
 	
 	//Configuration du PIN
 	LL_GPIO_StructInit(&init);
-	init.Pin = PINx;
+	init.Pin = pin;
 	init.Mode = mode;
 	//init.Speed = ;
 	init.OutputType = outputType;
 	init.Pull = pullMode;
-	LL_GPIO_Init(GPIOx, &init);
+	LL_GPIO_Init(gpio, &init);
 }
 
-void GPIO_setPin(GPIO_TypeDef * GPIOx, uint32_t PINx, int output)
+void GPIO_setPin(GPIO_TypeDef * gpio, uint32_t pin, int output)
 {
 	if (output) {
-		LL_GPIO_SetOutputPin(GPIOx, PINx);
+		LL_GPIO_SetOutputPin(gpio, pin);
 	} else {
-		LL_GPIO_ResetOutputPin(GPIOx,PINx);
+		LL_GPIO_ResetOutputPin(gpio,pin);
 	}
 };
 
-int GPIO_readPin(GPIO_TypeDef * GPIOx, uint32_t PINx)
+int GPIO_readPin(GPIO_TypeDef * gpio, uint32_t pin)
 {
-	return LL_GPIO_IsOutputPinSet(GPIOx, PINx);
+	return LL_GPIO_IsOutputPinSet(gpio, pin);
 	
 }

MyDrivers/GPIO.h

@@ -7,17 +7,31 @@
 
 
 /**
-	* @brief  Configure le GPIO considéré
+	* @brief  Active l'horloge du GPIO et configure le pin donné
 	* @note   
-	* @param  GPIO_TypeDef * GPIOx indique le GPIO à configurer : GPIOA, GPIOB, GPIOC ou GPIOD
+	* @param  GPIO_TypeDef * gpio	: indique le GPIO à configurer : GPIOA, GPIOB, GPIOC ou GPIOD
-	uint32_t PINx indique le PIN à configurer, sous la forme LL_GPIO_PIN_x
+	*					uint32_t pin 				: 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_conf(GPIO_TypeDef * gpio, uint32_t pin, uint32_t mode, uint32_t outputType, uint32_t pullMode);
 
-void GPIO_setPin(GPIO_TypeDef * GPIOx, uint32_t PINx, int output);
+/**
+	* @brief  Mets le PIN à la valeur donnée
+	* @note   
+	* @param  GPIO_TypeDef * gpio	: indique le GPIO à configurer : GPIOA, GPIOB, GPIOC ou GPIOD
+	*					uint32_t pin 				: indique le PIN à configurer, sous la forme LL_GPIO_PIN_x
+	*					int output	 				: valeur du pin à mettre
+	* @retval None
+	*/
+void GPIO_setPin(GPIO_TypeDef * gpio, uint32_t pin, int output);
 
-int GPIO_readPin(GPIO_TypeDef * GPIOx, uint32_t PINx);
+/**
+	* @brief  Récupère la valeur du PIN
+	* @note   
+	* @param  GPIO_TypeDef * gpio	: indique le GPIO à configurer : GPIOA, GPIOB, GPIOC ou GPIOD
+	*					uint32_t pin 				: indique le PIN à configurer, sous la forme LL_GPIO_PIN_x
+	* @retval 0 ou 1
+	*/
+int GPIO_readPin(GPIO_TypeDef * gpio, uint32_t pin);
 
 #endif

MyDrivers/Timer.c

@@ -44,38 +44,16 @@ void TIM4_IRQHandler(void)
 	(*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
@@ -106,36 +84,16 @@ void Timer_IT_conf(TIM_TypeDef * timer, void (*it_callback) (void), int prio)
 	*																	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;
@@ -165,9 +123,10 @@ void Timer_conf(TIM_TypeDef * timer, int arr, int psc)
 /****************************************************************************
 	*																	PWM INPUT
 	***************************************************************************/
-void PWMi_conf(TIM_TypeDef * TIMx, int channel){
+
-	
+void Timer_pwmi_conf(TIM_TypeDef * TIMx, int channel)
-	//Periode à recuperer dans TIMx_CCR1, duty cycle dans TIMx_CCR2. Seul les 2 premiers channels peuvent être utilisés (cf 315).
+{
+	// Periode à recuperer dans TIMx_CCR1, duty cycle dans TIMx_CCR2. Seul les 2 premiers channels peuvent être utilisés (cf 315).
 	
 	// Validation horloge locale
 	if (TIMx == TIM1) LL_APB2_GRP1_EnableClock(LL_APB2_GRP1_PERIPH_TIM1);
@@ -178,48 +137,48 @@ void PWMi_conf(TIM_TypeDef * TIMx, int channel){
 	
 	if (channel == 1) {
 		//
-		TIMx -> CCMR1 |= TIM_CCMR1_CC1S_0;
+		TIMx->CCMR1 |= TIM_CCMR1_CC1S_0;
-		TIMx -> CCMR1 |= TIM_CCMR1_CC2S_1;
+		TIMx->CCMR1 |= TIM_CCMR1_CC2S_1;
 
-		//TIM_CCMR1_IC1F_0; Potentiellement utile, à voir plus tard
+		// TIM_CCMR1_IC1F_0; Potentiellement utile, à voir plus tard
 
-		//On met le channel principal en rising edge, le secondaire en falling edge
+		// On met le channel principal en rising edge, le secondaire en falling edge
-		TIMx -> CCER &= ~TIM_CCER_CC1P; 	
+		TIMx->CCER &= ~TIM_CCER_CC1P; 	
-		TIMx -> CCER |= TIM_CCER_CC2P;
+		TIMx->CCER |= TIM_CCER_CC2P;
 		
-		TIMx -> SMCR |= TIM_SMCR_TS_0 | TIM_SMCR_TS_2; //101
+		TIMx->SMCR |= TIM_SMCR_TS_0 | TIM_SMCR_TS_2; //101
-		TIMx -> SMCR |= TIM_SMCR_SMS_2; //100
+		TIMx->SMCR |= TIM_SMCR_SMS_2; //100
 	}
 	
 	else {
-		TIMx -> CCMR1 |= TIM_CCMR1_CC1S_1;
+		TIMx->CCMR1 |= TIM_CCMR1_CC1S_1;
-		TIMx -> CCMR1 |= TIM_CCMR1_CC2S_0;
+		TIMx->CCMR1 |= TIM_CCMR1_CC2S_0;
 		
-		TIMx -> CCER |= TIM_CCER_CC1P; 	
+		TIMx->CCER |= TIM_CCER_CC1P; 	
-		TIMx -> CCER &= ~TIM_CCER_CC2P;
+		TIMx->CCER &= ~TIM_CCER_CC2P;
 
-		TIMx -> SMCR |= TIM_SMCR_TS_1 | TIM_SMCR_TS_2; //110
+		TIMx->SMCR |= TIM_SMCR_TS_1 | TIM_SMCR_TS_2; //110
-		TIMx -> SMCR |= TIM_SMCR_SMS_2; //100
+		TIMx->SMCR |= TIM_SMCR_SMS_2; //100
 	}
 	
-	//On met les prescalers à 0, on veut compter chaque transition
+	// On met les prescalers à 0, on veut compter chaque transition
 	TIMx -> CCMR1 &= ~TIM_CCMR1_IC1PSC;
 	TIMx -> CCMR1 &= ~TIM_CCMR1_IC2PSC;
 	
 	TIMx -> CCER |= TIM_CCER_CC1E | TIM_CCER_CC2E;
 	
-	//TIMx -> DIER |= TIM_DIER_CC1IE; gestion des interrupts, probablement pas utile
+	// TIMx -> DIER |= TIM_DIER_CC1IE; gestion des interrupts, probablement pas utile
-  //TIM_DIER_CC1DE_Pos; Probablement pas utile
+  // TIM_DIER_CC1DE_Pos; Probablement pas utile
 }
 
-int PWMi_getPeriod(TIM_TypeDef * TIMx) {
+int Timer_pwmi_getPeriod(TIM_TypeDef * TIMx)
-	
+{
-	return TIMx -> CCR1;
+	return TIMx->CCR1;
 }
 
-int PWMi_getDutyCycle(TIM_TypeDef * TIMx) {
+int Timer_pwmi_getDutyCycle(TIM_TypeDef * TIMx)
-	
+{
-	return TIMx -> CCR2;
+	return TIMx->CCR2;
 }
 
 /****************************************************************************

MyDrivers/Timer.h

@@ -14,10 +14,30 @@ enum CounterDirection {
 	*																	INTERRUPTIONS
 	***************************************************************************/
 
+/**
+	* @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);
 
+/**
+	* @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);
 
+/**
+	* @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);
 
 
@@ -25,45 +45,60 @@ void Timer_IT_conf(TIM_TypeDef * timer, void (*it_callback) (void), int prio);
 	*																	TIMER
 	***************************************************************************/
 
-
 /**
-	* @brief  Active l'horloge et r<EFBFBD>gle l'ARR et le PSC du timer vis<EFBFBD>
+	* @brief  Démarre le timer considéré
-	* @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>
+	* @brief  Arrête le timer considéré
 	* @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);
 
+/**
+	* @brief  Active l'horloge et regle l'ARR et le PSC du timer visé
+	* @param  TIM_TypeDef Timer : indique le timer à utiliser
+	* 				int Arr   : valeur à placer dans ARR
+	*					int Psc   : valeur à placer dans PSC
+	* @retval None
+	*/
+void Timer_conf(TIM_TypeDef * timer, int arr, int psc);
+
 
 /****************************************************************************
 	*																PWM INPUT
 	***************************************************************************/
 
-void PWMi_conf(TIM_TypeDef * timer, int channel);
+/**
+	* @brief  Configure le timer en mode PWM input
+  * @note   
+	* @param  TIM_TypeDef Timer : indique le timer à utiliser : TIM1, TIM2, TIM3 ou TIM4
+	*					int channel 			: Le channel utilisé par la PWM
+  * @retval None
+  */
+void Timer_pwmi_conf(TIM_TypeDef * timer, int channel);
 
-int PWMi_getDutyCycle(TIM_TypeDef * timer);
+/**
+	* @brief  Récupère le duty cycle de la PWM donnée
+  * @note   
+	* @param  TIM_TypeDef Timer : indique le timer à utiliser
+  * @retval None
+  */
+int Timer_pwmi_getDutyCycle(TIM_TypeDef * timer);
 
-int PWMi_getPeriod(TIM_TypeDef * TIMx);
+/**
+	* @brief  Récupère la période de la PWM donnée
+  * @note   
+	* @param  TIM_TypeDef Timer : indique le timer à utiliser
+  * @retval None
+  */
+int Timer_pwmi_getPeriod(TIM_TypeDef * timer);
 
 /****************************************************************************
 	*																PWM OUTPUT

MyDrivers/USART.c

@@ -3,22 +3,22 @@
 #include "stm32f1xx_ll_bus.h" 	// Pour horloge
 
 
-void Usart_conf(USART_TypeDef *USARTx)
+void USART_conf(USART_TypeDef *usart)
 {
 	int txPin;
 	GPIO_TypeDef *usartGpio;
 	
-	if (USARTx == USART1) {
+	if (usart == USART1) {
 		LL_APB2_GRP1_EnableClock(LL_APB2_GRP1_PERIPH_USART1);
 		LL_APB2_GRP1_EnableClock(LL_APB2_GRP1_PERIPH_GPIOA);
 		txPin = LL_GPIO_PIN_9;
 		usartGpio = GPIOA;
-	} else if (USARTx == USART2) {
+	} else if (usart == USART2) {
 		LL_APB1_GRP1_EnableClock(LL_APB1_GRP1_PERIPH_USART2);
 		LL_APB2_GRP1_EnableClock(LL_APB2_GRP1_PERIPH_GPIOA);
 		txPin = LL_GPIO_PIN_2;
 		usartGpio = GPIOA;
-	} else if (USARTx == USART3) {
+	} else if (usart == USART3) {
 		LL_APB1_GRP1_EnableClock(LL_APB1_GRP1_PERIPH_USART3);
 		LL_APB2_GRP1_EnableClock(LL_APB2_GRP1_PERIPH_GPIOB);
 		txPin = LL_GPIO_PIN_10;	
@@ -30,30 +30,26 @@ void Usart_conf(USART_TypeDef *USARTx)
 	usartInit.DataWidth = LL_USART_DATAWIDTH_8B;
 	usartInit.BaudRate = 9600;
 	usartInit.TransferDirection = LL_USART_DIRECTION_TX_RX;
-	LL_USART_Init(USARTx, &usartInit);
+	LL_USART_Init(usart, &usartInit);
 	
 	GPIO_conf(usartGpio, txPin, LL_GPIO_MODE_ALTERNATE, LL_GPIO_OUTPUT_PUSHPULL, LL_GPIO_PULL_UP);
 }
 
-
+void USART_start(USART_TypeDef *usart)
-
-void Usart_enable(USART_TypeDef *USARTx)
 {
-		LL_USART_Enable(USARTx);
+		LL_USART_Enable(usart);
 }
 
-
+void sendChar(USART_TypeDef *usart, char c)
-void sendChar(USART_TypeDef *USARTx, char c)
 {
-	LL_USART_TransmitData8(USARTx, c);
+	LL_USART_TransmitData8(usart, c);
-	while (!LL_USART_IsActiveFlag_TXE(USARTx)) {}
+	while (!LL_USART_IsActiveFlag_TXE(usart)) {}
 }
 
-
+void USART_send(USART_TypeDef *usart, char *msg, int length)
-void Usart_send(USART_TypeDef *USARTx, char *msg, int length)
 {
 	for (int i = 0; i < length; i++) {
-		sendChar(USARTx, msg[i]);
+		sendChar(usart, msg[i]);
 	}
 }
 

MyDrivers/USART.h

@@ -3,8 +3,30 @@
 
 #include "stm32f1xx_ll_usart.h"
 
-void Usart_conf(USART_TypeDef *USARTx);
+/**
-void Usart_enable(USART_TypeDef *USARTx);
+	* @brief  Active l'horloge de l'USART et configure le pin associé
-void Usart_send(USART_TypeDef *USARTx, char *msg, int length);
+	* @note   
+	* @param  USART_TypeDef * usart	: indique l'USART à configurer
+	* @retval None
+	*/
+void USART_conf(USART_TypeDef *USARTx);
+
+/**
+	* @brief  Démarre l'USART
+	* @note   
+	* @param  USART_TypeDef * usart	: indique l'USART à configurer
+	* @retval None
+	*/
+void USART_start(USART_TypeDef *USARTx);
+
+/**
+	* @brief  envoie le message donné par l'USART
+	* @note   
+	* @param  USART_TypeDef * usart	: indique l'USART à configurer
+	*					char msg 							: Le message à envoyer
+	*					int length						: La longueur du message
+	* @retval None
+	*/
+void USART_send(USART_TypeDef *USARTx, char *msg, int length);
 
 #endif

Services/Accelerometer.h

@@ -4,10 +4,32 @@
 #include "GPIO.h"
 #include "stm32f1xx_ll_adc.h"
 
+/**
+	* @brief  Configure l'ADC et les GPIO de l'accéléromètre
+  * @note   
+	* @param  adc 	: ADC utilisé pour convertir les valeurs
+	*					gpio 	: Gpio utilisé par l'accéléromètre
+	*					pinx 	: Pin pour l'axe X
+	*					piny 	: Pin pour l'axe Y
+  * @retval None
+  */
 void Accelerometer_conf(ADC_TypeDef *adc, GPIO_TypeDef * gpio, int pinx, int piny);
 
+/**
+	* @brief  Démarre l'ADC de l'accéléromètre
+  * @note   
+	* @param  None
+  * @retval None
+  */
 void Accelerometer_start(ADC_TypeDef *adc);
 
+/**
+	* @brief  Récupère l'angle de l'accéléromètre lié au channel donné
+  * @note   
+	* @param  adc 			: ADC utilisé pour convertir les valeurs
+	*					channel 	: channel utilisé par l'axe
+  * @retval L'ange en degrès de l'axe choisi
+  */
 int Accelerometer_getAngle(ADC_TypeDef *adc, int channel);
 
 #endif

Services/DCMotor.h

@@ -4,10 +4,39 @@
 #include "GPIO.h"
 #include "Timer.h"
 
+/**
+	* @brief  Configure le Timer et le GPIO du DCmotor
+  * @note   
+	* @param  timer 	: Timer utilisé pour controler le moteur
+	*					channel : channel du timer
+	*					gpio 		: GPIO utilisé pour régler le sens du moteur
+	*					pin 		: Pin pour l'axe Y
+  * @retval None
+  */
 void DCMotor_conf(TIM_TypeDef * timer, int channel, GPIO_TypeDef * gpio, int pin);
 
+/**
+	* @brief  Configure le Timer et le GPIO du DCmotor
+  * @note   
+	* @param  timer 	: Timer utilisé pour controler le moteur
+	*					channel : channel du timer
+	*					gpio 		: GPIO utilisé pour régler le sens du moteur
+	*					pin 		: Pin pour l'axe Y
+	*					speed		: vitesse voulue
+  * @retval None
+  */
 void DCMotor_setSpeed(TIM_TypeDef * timer, int channel, GPIO_TypeDef * gpio, int pin, float speed);
 
+/**
+	* @brief  Récupère la vitesse actuelle du moteur
+  * @note   
+	* @param  timer 	: Timer utilisé pour controler le moteur
+	*					channel : channel du timer
+	*					gpio 		: GPIO utilisé pour régler le sens du moteur
+	*					pin 		: Pin pour l'axe Y
+	*					speed		: vitesse voulue
+  * @retval None
+  */
 float DCMotor_getSpeed(TIM_TypeDef * timer, int channel, GPIO_TypeDef * gpio, int pin);
 
 #endif

Services/IncrementalEncoder.h

@@ -4,17 +4,19 @@
 #include "stm32f103xb.h"
 
 /**
-	* @brief  Configure le codeur incrémental associé au timer donné
+	* @brief  Configure le timer et le pin du gpio pour le codeur incrémental
   * @note   
-	* @param  TIM_TypeDef Timer : indique le timer à utiliser : TIM1, TIM2, TIM3 ou TIM4
+	* @param  TIM_TypeDef timer : le timer à utiliser
+	* 				GPIO_TypeDef gpio : le gpio à utiliser pour le zero
+	* 				int pin 					: le pin associé au GPIO pour le zero
   * @retval None
   */
 void IncrementalEncoder_conf(TIM_TypeDef * timer, GPIO_TypeDef * gpio, int pin);
 
 /**
-	* @brief  Démarre le codeur incrémental associé au timer donné
+	* @brief  Démarre le timer pour le codeur incrémental
   * @note   
-	* @param  TIM_TypeDef Timer : indique le timer à utiliser : TIM1, TIM2, TIM3 ou TIM4
+	* @param  TIM_TypeDef timer : le timer à utiliser
   * @retval None
   */
 void IncrementalEncoder_start(TIM_TypeDef * timer);
@@ -22,16 +24,16 @@ 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
+	* @param  TIM_TypeDef timer : le timer à utiliser
-  * @retval int angle
+  * @retval L'angle en degrès
   */
 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
+	* @param  TIM_TypeDef timer : le timer à utiliser
-  * @retval int dir
+  * @retval la direction actuelle du codeur
   */
 enum CounterDirection IncrementalEncoder_getDirection(TIM_TypeDef * timer);
 

Services/RFEmitter.c

@@ -6,12 +6,12 @@ void RFEmitter_conf(USART_TypeDef * usart, GPIO_TypeDef *gpioTXEnable, int pinTX
 	// Configuration du pin TXEnable
 	GPIO_conf(gpioTXEnable, pinTXEnable, LL_GPIO_MODE_OUTPUT, LL_GPIO_OUTPUT_PUSHPULL, 0);
 	// Configuration de l'USART
-	Usart_conf(usart);
+	USART_conf(usart);
 }
 
 void RFEmitter_start(USART_TypeDef * usart)
 {
-	Usart_enable(usart);
+	USART_start(usart);
 }
 
 void RFEmitter_send(USART_TypeDef * usart, char * message, int longueur, GPIO_TypeDef *gpioTXEnable, int pinTXEnable)
@@ -20,7 +20,7 @@ void RFEmitter_send(USART_TypeDef * usart, char * message, int longueur, GPIO_Ty
 	GPIO_setPin(gpioTXEnable, pinTXEnable, 1);
 
 	// Envoi du message
-	Usart_send(usart, message, longueur);
+	USART_send(usart, message, longueur);
 	
 	// reset PA11 (TXEnable)
 	GPIO_setPin(gpioTXEnable, pinTXEnable, 0);

Services/RFEmitter.h

@@ -3,10 +3,34 @@
 
 #include "USART.h"
 
+/**
+	* @brief  Configure l'USART et le pin du gpio pour l'émetteur
+  * @note   
+	* @param  USART_TypeDef usart 			: l'usart à utiliser pour transmettre les informations
+	* 				GPIO_TypeDef gpioTXEnable : le gpio à utiliser pour activer l'emetteur
+	* 				int pinTXEnable 					: le pin associé au GPIO
+  * @retval None
+  */
 void RFEmitter_conf(USART_TypeDef * usart, GPIO_TypeDef *gpioTXEnable, int pinTXEnable);
-	
+
+/**
+	* @brief  Démarre l'USART l'émetteur
+  * @note   
+	* @param  USART_TypeDef usart 			: l'usart à utiliser pour transmettre les informations
+  * @retval None
+  */
 void RFEmitter_start(USART_TypeDef * usart);
 
+/**
+	* @brief  Envoie le message donnée par l'émetteur
+  * @note   
+	* @param  USART_TypeDef usart 			: l'usart à utiliser pour transmettre les informations
+	* 				char message 							: le message à envoyer
+	* 				int longueur 							: la longueur du message
+	* 				GPIO_TypeDef gpioTXEnable : le gpio à utiliser pour activer l'emetteur
+	* 				int pinTXEnable 					: le pin associé au GPIO
+  * @retval None
+  */
 void RFEmitter_send(USART_TypeDef * usart, char * message, int longueur, GPIO_TypeDef *gpioTXEnable, int pinTXEnable);
 
 #endif

Services/RFReceiver.c

@@ -2,14 +2,14 @@
 
 void RFReceiver_conf(TIM_TypeDef * timer, int channel)
 {
-	PWMi_conf(timer, channel);
+	Timer_pwmi_conf(timer, channel);
 }
 
 float RFReceiver_getData(TIM_TypeDef * timer)
 {
-	const int duty_cycle = PWMi_getDutyCycle(timer);
+	const int dutyCycle = Timer_pwmi_getDutyCycle(timer);
-	const int period = PWMi_getPeriod(timer);
+	const int period = Timer_pwmi_getPeriod(timer);
-	const float duree_impulsion = duty_cycle * period;
+	const float impulseLength = dutyCycle * period;
 	
-	return (duree_impulsion -1) * 200 - 100;
+	return (impulseLength -1) * 200 - 100;
 }

Services/RFReceiver.h

@@ -3,8 +3,21 @@
 
 #include "Timer.h"
 
+/**
+	* @brief  Configure le timer en PWM pour recevoir des données
+  * @note   
+	* @param  TIM_TypeDef timer	: le timer à utiliser
+	* 				int channel				: le channel du timer
+  * @retval None
+  */
 void RFReceiver_conf(TIM_TypeDef * timer, int channel);
 
+/**
+	* @brief  Lis les données envoyées à la PWM par le recepteur
+  * @note   
+	* @param  TIM_TypeDef timer	: le timer à utiliser
+  * @retval la durée de l'impulsion
+  */
 float RFReceiver_getData(TIM_TypeDef * timer);
 	
 #endif

Services/Scheduler.h

@@ -12,7 +12,7 @@
 void Scheduler_conf(void (*it_callback) (void));
 
 /**
-	* @brief  Démarre ordonanceur
+	* @brief  Démarre l'ordonanceur
   * @note   
 	* @param  None
   * @retval None

Services/ServoMotor.h

@@ -6,7 +6,7 @@
 #include "GPIO.h"
 
 /**
-	* @brief  Configure le servo moteur associé au timer donné
+	* @brief  Configure le timer PWM et le GPIO pour le 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
@@ -17,7 +17,7 @@
 void ServoMotor_conf(TIM_TypeDef * timer, int channel, GPIO_TypeDef * gpio, int pin);
 
 /**
-	* @brief  Démarre les servo moteurs associés au timer donné
+	* @brief  Démarre la PWM du servo moteur
   * @note   
 	* @param  TIM_TypeDef Timer : indique le timer à utiliser : TIM1, TIM2, TIM3 ou TIM4
   * @retval None
@@ -39,7 +39,7 @@ void ServoMotor_setAngle(TIM_TypeDef * timer, int channel, int angle);
   * @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
+  * @retval L'angle en degrès
   */
 int ServoMotor_getAngle(TIM_TypeDef * timer, int channel);
 

Services/Voltage.h

@@ -4,10 +4,30 @@
 #include "ADC.h"
 #include "GPIO.h"
 
+/**
+	* @brief  Configure le GPIO et l'ADC pour lire les données de la batterie
+  * @note   
+	* @param  ADC_TypeDef adc		: l'ADC à utiliser
+	* 				GPIO_TypeDef gpio	: le GPIO à utiliser
+	* 				int pin						: le pin à utiliser
+  * @retval None
+  */
 void Voltage_conf(ADC_TypeDef * adc, GPIO_TypeDef * gpio, int pin);
 
+/**
+	* @brief  Démarre l'ADC pour lire les données de la batterie
+  * @note   
+	* @param  ADC_TypeDef adc		: l'ADC à utiliser
+  * @retval None
+  */
 void Voltage_start(ADC_TypeDef * adc);
 
+/**
+	* @brief  Récupère la tension de la batterie
+  * @note   
+	* @param  ADC_TypeDef adc		: l'ADC à utiliser
+  * @retval La tension
+  */
 float Voltage_getVoltage(ADC_TypeDef * adc, int channel);
 
 #endif

Src/Display.c

@@ -5,10 +5,12 @@
 #include "stdio.h"
 #include "string.h"
 
+// Composants utilisés par l'emetteur
 USART_TypeDef * EMITTER_USART = USART1;
 GPIO_TypeDef * EMITTER_GPIO = GPIOA;
 const int EMITTER_PIN = LL_GPIO_PIN_11;
 
+// Composants utilisés par la batterie
 ADC_TypeDef * VOLTAGE_ADC = ADC2;
 const int VOLTAGE_CHANNEL = 12;
 GPIO_TypeDef * VOLTAGE_GPIO = GPIOC;

Src/Display.h

@@ -1,10 +1,29 @@
 #ifndef DISPLAY_H
 #define DISPLAY_H
 
+/**
+	* @brief  Configure l'ADC de la batterie et le RFEmitter pour l'affichage
+  * @note   
+	* @param  None
+  * @retval None
+  */
 void Display_conf(void);
 
+/**
+	* @brief  Démarre l'ADC de la batterie et le RFEmitter
+  * @note   
+	* @param  None
+  * @retval None
+  */
 void Display_start(void);
 
-void Display_background(int msCounter);
+/**
+	* @brief  Envoie au pupitre toutes les 3 secondes le bordage et la tension de la batterie.
+	*					Si jamais l'alarme de roulis est déclenchée, elle sera tout de suite envoyée au pupitre.
+  * @note   
+	* @param  secCounter : Nombre de secondes écoulées depuis le début du programme
+  * @retval None
+  */
+void Display_background(int secCounter);
 
 #endif

Src/Orientation.c

@@ -3,9 +3,11 @@
 
 #define THRESHOLD 30
 
+//  Recepteur
 TIM_TypeDef * RECEIVER_TIMER = TIM4;
 const int RECEIVER_CHANNEL = LL_TIM_CHANNEL_CH1;
 
+// Moteur
 TIM_TypeDef * DCMOTOR_TIMER = TIM2;
 const int DCMOTOR_CHANNEL = LL_TIM_CHANNEL_CH2;
 GPIO_TypeDef * DCMOTOR_GPIO = GPIOA;

Src/Orientation.h

@@ -4,8 +4,20 @@
 #include "DCMotor.h"
 #include "RFReceiver.h"
 
+/**
+	* @brief  Configure le moteur continu et le RFReceiver pour l'orientation du voilier
+  * @note   
+	* @param  None
+  * @retval None
+  */
 void Orientation_conf(void);
 
+/**
+	* @brief  Récupère la vitesse demandée par l'utilisateur et la transmets au moteur DC
+  * @note   
+	* @param  None
+  * @retval None
+  */
 void Orientation_background(void);
 
 #endif

Src/Roll.h

@@ -1,12 +1,36 @@
 #ifndef ROLL_H
 #define ROLL_H
 
+/**
+	* @brief  Configure l'accelerometre pour la détection de roulis
+  * @note   
+	* @param  None
+  * @retval None
+  */
 void Roll_conf(void);
 
+/**
+	* @brief  Démarre l'accelerometre pour la détection de roulis
+  * @note   
+	* @param  None
+  * @retval None
+  */
 void Roll_start(void);
 
+/**
+	* @brief  Récupère l'état d'alarme de dépassement de roulis
+  * @note   
+	* @param  None
+  * @retval 1 si l'alarme est active, 0 sinon
+  */
 int Roll_getEmergencyState(void);
 
+/**
+	* @brief  Récupère l'angle de roulis et déclenche l'alarme si il dépasse le seuil autorisé
+  * @note   
+	* @param  None
+  * @retval None
+  */
 void Roll_background(void);
 
 #endif

Src/Sail.c

@@ -41,6 +41,17 @@ int Sail_getSailAngle(void)
 	return ServoMotor_getAngle(MOTOR_TIMER, MOTOR_CHANNEL);
 }
 
+void Sail_setEmergency(int state)
+{
+	Sail_isEmergencyState = state;
+	if (Sail_isEmergencyState)
+		ServoMotor_setAngle(MOTOR_TIMER, MOTOR_CHANNEL, RESET_ANGLE);
+}
+
+int Sail_getEmergencyState()
+{
+	return Sail_isEmergencyState;
+}
 
 void Sail_background()
 {
@@ -54,15 +65,3 @@ void Sail_background()
 	else
 			ServoMotor_setAngle(MOTOR_TIMER, MOTOR_CHANNEL, windToSailAngle(windAngle));
 }
-
-void Sail_setEmergency(int state)
-{
-	Sail_isEmergencyState = state;
-	if (Sail_isEmergencyState)
-		ServoMotor_setAngle(MOTOR_TIMER, MOTOR_CHANNEL, RESET_ANGLE);
-}
-
-int Sail_getEmergencyState()
-{
-	return Sail_isEmergencyState;
-}

Src/Sail.h

@@ -2,7 +2,7 @@
 #define SAIL_H
 
 /**
-	* @brief  Configure la voile
+	* @brief  Configure le servo moteur et le codeur incrémental pour la manipulation de la voile
   * @note   
 	* @param  None
   * @retval None
@@ -10,31 +10,44 @@
 void Sail_conf(void);
 
 /**
-	* @brief  Execute la tache de fond des voiles en fonction des valeurs récupérées par les drivers
+	* @brief  Démarre le servo moteur et le codeur incrémental pour la manipulation de la voile
-  * @note   
-	* @param  None
-  * @retval None
-  */
-void Sail_background(void);
-
-/**
-	* @brief  Mets la voile à 90 degres
-  * @note   
-	* @param  None
-  * @retval None
-  */
-void Sail_setEmergency(int state);
-
-int Sail_getEmergencyState(void);
-
-int Sail_getSailAngle(void);
-
-/**
-	* @brief  Réinitialise la voile à sa position initiale
   * @note   
 	* @param  None
   * @retval None
   */
 void Sail_start(void);
 
+/**
+	* @brief  Active le mode urgence des voiles pour les détendre
+  * @note   
+	* @param  None
+  * @retval None
+  */
+void Sail_setEmergency(int state);
+
+/**
+	* @brief  Retourne l'état d'alarme de la voile
+  * @note   
+	* @param  None
+  * @retval 1 si l'alarme est active, 0 sinon
+  */
+int Sail_getEmergencyState(void);
+
+/**
+	* @brief  Retourne l'angle du servo moteur de la voile
+  * @note   
+	* @param  None
+  * @retval angle en degrès entre 0 (tendu) et 90 (détendu)
+  */
+int Sail_getSailAngle(void);
+
+/**
+	* @brief  Ajuste l'angle du servo moteur de la voile en fonction de l'angle du vent capté par la girouette
+  * @note   
+	* @param  None
+  * @retval None
+  */
+void Sail_background(void);
+
+
 #endif

Src/main.c

@@ -26,20 +26,26 @@
 #include "Orientation.h"
 
 #include "Scheduler.h"
-#include "ADC.h"
-#include "GPIO.h"
 #include "Accelerometer.h"
 #include "RFEmitter.h"
 #include "stdio.h"
 
 void  SystemClock_Config(void);
 
+// Compteur de secondes
 int secCounter = 0;
 
 /* Private functions ---------------------------------------------------------*/
 
+/**
+	* @brief  Effectue la tache de fond (programmée toutes les 1ms)
+  * @note   
+	* @param  None
+  * @retval None
+  */
 void backgroundTask()
 {
+	// Compte les millisecondes et secondes
 	static int msCounter;
 	msCounter++;
 	if (msCounter == 1000) {
@@ -51,6 +57,12 @@ void backgroundTask()
 	Orientation_background();
 }
 
+/**
+	* @brief  Configure les périphériques
+  * @note   
+	* @param  None
+  * @retval None
+  */
 void configurePeripherals()
 {
 	Sail_conf();
@@ -59,6 +71,12 @@ void configurePeripherals()
 	Orientation_conf();
 }
 
+/**
+	* @brief  Démarre les périphériques
+  * @note   
+	* @param  None
+  * @retval None
+  */
 void startPeripherals()
 {
 	Sail_start();