ysimard/projet_voilier
2
3
Fork 0
Code Issues Pull requests Releases Wiki Activity

improve doc

Browse source
This commit is contained in:
Arnaud Vergnet 2020-11-15 16:53:55 +01:00
parent e1773afbbe
commit 4e69b9b112
25 changed files with 441 additions and 182 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

34
MyDrivers/ADC.h
View file

@ -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);

24
MyDrivers/GPIO.c
View file

@ -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);
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);
if (gpio == GPIOA) LL_APB2_GRP1_EnableClock(LL_APB2_GRP1_PERIPH_GPIOA);
else if (gpio == GPIOB) LL_APB2_GRP1_EnableClock(LL_APB2_GRP1_PERIPH_GPIOB);
else if (gpio == GPIOC) LL_APB2_GRP1_EnableClock(LL_APB2_GRP1_PERIPH_GPIOC);
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);
}

28
MyDrivers/GPIO.h
View file

@ -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
uint32_t PINx indique le PIN à configurer, sous la forme LL_GPIO_PIN_x
Pour une liste des modes disponibles, consulter la librairie LL
* @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 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

53
MyDrivers/Timer.c
View file

@ -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,8 +123,9 @@ 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).
// Validation horloge locale
@ -212,13 +171,13 @@ void PWMi_conf(TIM_TypeDef * TIMx, int channel){
// TIM_DIER_CC1DE_Pos; Probablement pas utile
}
int PWMi_getPeriod(TIM_TypeDef * TIMx) {
int Timer_pwmi_getPeriod(TIM_TypeDef * TIMx)
{
return TIMx->CCR1;
}
int PWMi_getDutyCycle(TIM_TypeDef * TIMx) {
int Timer_pwmi_getDutyCycle(TIM_TypeDef * TIMx)
{
return TIMx->CCR2;
}

71
MyDrivers/Timer.h
View file

@ -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>
* @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>
* @brief Démarre 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_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

28
MyDrivers/USART.c
View file

@ -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_enable(USART_TypeDef *USARTx)
void USART_start(USART_TypeDef *usart)
{
LL_USART_Enable(USARTx);
LL_USART_Enable(usart);
}
void sendChar(USART_TypeDef *USARTx, char c)
void sendChar(USART_TypeDef *usart, char c)
{
LL_USART_TransmitData8(USARTx, c);
while (!LL_USART_IsActiveFlag_TXE(USARTx)) {}
LL_USART_TransmitData8(usart, c);
while (!LL_USART_IsActiveFlag_TXE(usart)) {}
}
void Usart_send(USART_TypeDef *USARTx, char *msg, int length)
void USART_send(USART_TypeDef *usart, char *msg, int length)
{
for (int i = 0; i < length; i++) {
sendChar(USARTx, msg[i]);
sendChar(usart, msg[i]);
}
}

28
MyDrivers/USART.h
View file

@ -3,8 +3,30 @@
#include "stm32f1xx_ll_usart.h"
void Usart_conf(USART_TypeDef *USARTx);
void Usart_enable(USART_TypeDef *USARTx);
void Usart_send(USART_TypeDef *USARTx, char *msg, int length);
/**
* @brief Active l'horloge de l'USART et configure le pin associé
* @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

22
Services/Accelerometer.h
View file

@ -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

29
Services/DCMotor.h
View file

@ -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

18
Services/IncrementalEncoder.h
View file

@ -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
* @retval int angle
* @param TIM_TypeDef timer : le timer à utiliser
* @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
* @retval int dir
* @param TIM_TypeDef timer : le timer à utiliser
* @retval la direction actuelle du codeur
*/
enum CounterDirection IncrementalEncoder_getDirection(TIM_TypeDef * timer);

6
Services/RFEmitter.c
View file

@ -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);

24
Services/RFEmitter.h
View file

@ -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

10
Services/RFReceiver.c
View file

@ -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 period = PWMi_getPeriod(timer);
const float duree_impulsion = duty_cycle * period;
const int dutyCycle = Timer_pwmi_getDutyCycle(timer);
const int period = Timer_pwmi_getPeriod(timer);
const float impulseLength = dutyCycle * period;
return (duree_impulsion -1) * 200 - 100;
return (impulseLength -1) * 200 - 100;
}

13
Services/RFReceiver.h
View file

@ -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

2
Services/Scheduler.h
View file

@ -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

6
Services/ServoMotor.h
View file

@ -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);

20
Services/Voltage.h
View file

@ -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

2
Src/Display.c
View file

@ -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;

21
Src/Display.h
View file

@ -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

2
Src/Orientation.c
View file

@ -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;

12
Src/Orientation.h
View file

@ -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

24
Src/Roll.h
View file

@ -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

23
Src/Sail.c
View file

@ -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;
}

57
Src/Sail.h
View file

@ -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
* @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
* @brief Démarre le servo moteur et le codeur incrémental pour la manipulation de la voile
* @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

22
Src/main.c
View file

@ -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();