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

Compare commits

base: ysimard:reel
Branches Tags
ysimard:master
ysimard:reel
ysimard:MB
ysimard:YA
..
compare: ysimard:master
Branches Tags
ysimard:master
ysimard:reel
ysimard:MB
ysimard:YA

4 commits
reel ... master

Author SHA1 Message Date
Yohan Simard
64ea0cbd78 accelerometer and display fix 2020-12-03 12:16:07 +01:00
Yohan Simard
c8ea3f3a91 clean project 2020-11-16 19:45:46 +01:00
Yohan Simard
542722584d Merge branch 'reel' 
# Conflicts:
#	MyDrivers/Timer.c
#	MyDrivers/Timer.h
#	Services/RFReceiver.c
 2020-11-16 18:55:44 +01:00
Arnaud Vergnet
4e69b9b112 improve doc 2020-11-15 16:53:55 +01:00
31 changed files with 593 additions and 378 deletions
Show stats Expand all files Collapse all files

96
MDK-ARM/Project.uvoptx
View file

@ -130,7 +130,7 @@
<SetRegEntry> <SetRegEntry>
<Number>0</Number> <Number>0</Number>
<Key>DLGTARM</Key> <Key>DLGTARM</Key>
<Name>(1010=-1,-1,-1,-1,0)(1007=-1,-1,-1,-1,0)(1008=204,363,702,652,0)(1009=-1,-1,-1,-1,0)(100=-1,-1,-1,-1,0)(110=-1,-1,-1,-1,0)(111=-1,-1,-1,-1,0)(1011=-1,-1,-1,-1,0)(180=-1,-1,-1,-1,0)(120=1045,583,1603,1080,0)(121=971,583,1529,1080,0)(122=-1,-1,-1,-1,0)(123=-1,-1,-1,-1,0)(140=-1,-1,-1,-1,0)(240=-1,-1,-1,-1,0)(190=-1,-1,-1,-1,0)(200=-1,-1,-1,-1,0)(170=-1,-1,-1,-1,0)(130=200,173,988,1026,0)(131=405,227,1193,1080,0)(132=161,47,949,900,0)(133=1013,172,1801,1025,0)(160=-1,-1,-1,-1,0)(161=-1,-1,-1,-1,0)(162=-1,-1,-1,-1,0)(210=-1,-1,-1,-1,0)(211=-1,-1,-1,-1,0)(220=-1,-1,-1,-1,0)(221=-1,-1,-1,-1,0)(230=-1,-1,-1,-1,0)(231=-1,-1,-1,-1,0)(232=-1,-1,-1,-1,0)(233=-1,-1,-1,-1,0)(150=320,247,1120,1026,0)(151=1120,301,1920,1080,0)</Name> <Name>(1010=-1,-1,-1,-1,0)(1007=-1,-1,-1,-1,0)(1008=204,363,702,652,0)(1009=-1,-1,-1,-1,0)(100=-1,-1,-1,-1,0)(110=-1,-1,-1,-1,0)(111=-1,-1,-1,-1,0)(1011=-1,-1,-1,-1,0)(180=-1,-1,-1,-1,0)(120=293,271,851,768,0)(121=854,376,1412,873,0)(122=-1,-1,-1,-1,0)(123=-1,-1,-1,-1,0)(140=-1,-1,-1,-1,0)(240=-1,-1,-1,-1,0)(190=-1,-1,-1,-1,0)(200=-1,-1,-1,-1,0)(170=-1,-1,-1,-1,0)(130=200,173,988,1026,0)(131=410,141,1198,994,0)(132=161,47,949,900,0)(133=966,188,1754,1041,0)(160=-1,-1,-1,-1,0)(161=-1,-1,-1,-1,0)(162=-1,-1,-1,-1,0)(210=-1,-1,-1,-1,0)(211=-1,-1,-1,-1,0)(220=-1,-1,-1,-1,0)(221=-1,-1,-1,-1,0)(230=-1,-1,-1,-1,0)(231=-1,-1,-1,-1,0)(232=-1,-1,-1,-1,0)(233=-1,-1,-1,-1,0)(150=320,247,1120,1026,0)(151=1120,301,1920,1080,0)</Name>
</SetRegEntry> </SetRegEntry>
<SetRegEntry> <SetRegEntry>
<Number>0</Number> <Number>0</Number>
@ -157,41 +157,9 @@
<Bp> <Bp>
<Number>0</Number> <Number>0</Number>
<Type>0</Type> <Type>0</Type>
<LineNumber>41</LineNumber>
<EnabledFlag>0</EnabledFlag>
<Address>134220664</Address>
<ByteObject>0</ByteObject>
<HtxType>0</HtxType>
<ManyObjects>0</ManyObjects>
<SizeOfObject>0</SizeOfObject>
<BreakByAccess>0</BreakByAccess>
<BreakIfRCount>1</BreakIfRCount>
<Filename>..\Services\Accelerometer.c</Filename>
<ExecCommand></ExecCommand>
<Expression>\\NUCLEO_F103RB\../Services/Accelerometer.c\41</Expression>
</Bp>
<Bp>
<Number>1</Number>
<Type>0</Type>
<LineNumber>33</LineNumber> <LineNumber>33</LineNumber>
<EnabledFlag>0</EnabledFlag> <EnabledFlag>0</EnabledFlag>
<Address>134231164</Address> <Address>134231986</Address>
<ByteObject>0</ByteObject>
<HtxType>0</HtxType>
<ManyObjects>0</ManyObjects>
<SizeOfObject>0</SizeOfObject>
<BreakByAccess>0</BreakByAccess>
<BreakIfRCount>1</BreakIfRCount>
<Filename>..\Services\Accelerometer.c</Filename>
<ExecCommand></ExecCommand>
<Expression>\\NUCLEO_F103RB\../Services/Accelerometer.c\33</Expression>
</Bp>
<Bp>
<Number>2</Number>
<Type>0</Type>
<LineNumber>33</LineNumber>
<EnabledFlag>0</EnabledFlag>
<Address>134231194</Address>
<ByteObject>0</ByteObject> <ByteObject>0</ByteObject>
<HtxType>0</HtxType> <HtxType>0</HtxType>
<ManyObjects>0</ManyObjects> <ManyObjects>0</ManyObjects>
@ -207,37 +175,12 @@
<Ww> <Ww>
<count>0</count> <count>0</count>
<WinNumber>1</WinNumber> <WinNumber>1</WinNumber>
<ItemText>windAngle,0x0A</ItemText> <ItemText>sailAngle,0x0A</ItemText>
</Ww> </Ww>
<Ww> <Ww>
<count>1</count> <count>1</count>
<WinNumber>1</WinNumber> <WinNumber>1</WinNumber>
<ItemText>angleDeg,0x0A</ItemText> <ItemText>dutyCycle</ItemText>
</Ww>
<Ww>
<count>2</count>
<WinNumber>1</WinNumber>
<ItemText>volts</ItemText>
</Ww>
<Ww>
<count>3</count>
<WinNumber>1</WinNumber>
<ItemText>angleRad</ItemText>
</Ww>
<Ww>
<count>4</count>
<WinNumber>1</WinNumber>
<ItemText>value,0x0A</ItemText>
</Ww>
<Ww>
<count>5</count>
<WinNumber>1</WinNumber>
<ItemText>speed,0x0A</ItemText>
</Ww>
<Ww>
<count>6</count>
<WinNumber>1</WinNumber>
<ItemText>TIMx-&gt;CCR2</ItemText>
</Ww> </Ww>
</WatchWindow1> </WatchWindow1>
<Tracepoint> <Tracepoint>
@ -397,7 +340,7 @@
<SetRegEntry> <SetRegEntry>
<Number>0</Number> <Number>0</Number>
<Key>DLGDARM</Key> <Key>DLGDARM</Key>
<Name>(1010=-1,-1,-1,-1,0)(1007=-1,-1,-1,-1,0)(1008=1554,213,1920,450,0)(1009=-1,-1,-1,-1,0)(100=-1,-1,-1,-1,0)(110=-1,-1,-1,-1,0)(111=-1,-1,-1,-1,0)(1011=-1,-1,-1,-1,0)(180=-1,-1,-1,-1,0)(120=129,555,687,1080,0)(121=924,444,1482,969,1)(122=-1,-1,-1,-1,0)(123=-1,-1,-1,-1,0)(140=-1,-1,-1,-1,0)(240=-1,-1,-1,-1,0)(190=-1,-1,-1,-1,0)(200=-1,-1,-1,-1,0)(170=-1,-1,-1,-1,0)(130=-1,-1,-1,-1,0)(131=-1,-1,-1,-1,0)(132=150,46,938,969,0)(133=-13,526,775,1449,1)(160=1046,190,1640,699,0)(161=-1,-1,-1,-1,0)(162=-1,-1,-1,-1,0)(210=-1,-1,-1,-1,0)(211=-1,-1,-1,-1,0)(220=-1,-1,-1,-1,0)(221=-1,-1,-1,-1,0)(230=-1,-1,-1,-1,0)(234=-1,-1,-1,-1,0)(231=-1,-1,-1,-1,0)(232=-1,-1,-1,-1,0)(233=-1,-1,-1,-1,0)(150=130,96,930,1019,0)(151=127,38,927,961,0)</Name> <Name>(1010=-1,-1,-1,-1,0)(1007=-1,-1,-1,-1,0)(1008=1554,213,1920,450,0)(1009=-1,-1,-1,-1,0)(100=-1,-1,-1,-1,0)(110=-1,-1,-1,-1,0)(111=-1,-1,-1,-1,0)(1011=-1,-1,-1,-1,0)(180=-1,-1,-1,-1,0)(120=129,555,687,1080,0)(121=924,444,1482,969,0)(122=-1,-1,-1,-1,0)(123=-1,-1,-1,-1,0)(140=-1,-1,-1,-1,0)(240=-1,-1,-1,-1,0)(190=-1,-1,-1,-1,0)(200=-1,-1,-1,-1,0)(170=-1,-1,-1,-1,0)(130=-1,-1,-1,-1,0)(131=-1,-1,-1,-1,0)(132=150,46,938,969,0)(133=0,157,788,1080,0)(160=1046,190,1640,699,0)(161=-1,-1,-1,-1,0)(162=-1,-1,-1,-1,0)(210=-1,-1,-1,-1,0)(211=-1,-1,-1,-1,0)(220=-1,-1,-1,-1,0)(221=-1,-1,-1,-1,0)(230=-1,-1,-1,-1,0)(234=-1,-1,-1,-1,0)(231=-1,-1,-1,-1,0)(232=-1,-1,-1,-1,0)(233=-1,-1,-1,-1,0)(150=130,96,930,1019,0)(151=127,38,927,961,0)</Name>
</SetRegEntry> </SetRegEntry>
<SetRegEntry> <SetRegEntry>
<Number>0</Number> <Number>0</Number>
@ -430,24 +373,7 @@
<Name>-U-O142 -O2254 -S0 -C0 -A0 -N00("ARM CoreSight SW-DP") -D00(1BA01477) -L00(0) -TO18 -TC10000000 -TP21 -TDS8007 -TDT0 -TDC1F -TIEFFFFFFFF -TIP8 -FO7 -FD20000000 -FC800 -FN1 -FF0STM32F10x_128.FLM -FS08000000 -FL020000 -FP0($$Device:STM32F103RB$Flash\STM32F10x_128.FLM)</Name> <Name>-U-O142 -O2254 -S0 -C0 -A0 -N00("ARM CoreSight SW-DP") -D00(1BA01477) -L00(0) -TO18 -TC10000000 -TP21 -TDS8007 -TDT0 -TDC1F -TIEFFFFFFFF -TIP8 -FO7 -FD20000000 -FC800 -FN1 -FF0STM32F10x_128.FLM -FS08000000 -FL020000 -FP0($$Device:STM32F103RB$Flash\STM32F10x_128.FLM)</Name>
</SetRegEntry> </SetRegEntry>
</TargetDriverDllRegistry> </TargetDriverDllRegistry>
<Breakpoint> <Breakpoint/>
<Bp>
<Number>0</Number>
<Type>0</Type>
<LineNumber>51</LineNumber>
<EnabledFlag>1</EnabledFlag>
<Address>134221038</Address>
<ByteObject>0</ByteObject>
<HtxType>0</HtxType>
<ManyObjects>0</ManyObjects>
<SizeOfObject>0</SizeOfObject>
<BreakByAccess>0</BreakByAccess>
<BreakIfRCount>1</BreakIfRCount>
<Filename>..\Src\Display.c</Filename>
<ExecCommand></ExecCommand>
<Expression>\\NUCLEO_F103RB\../Src/Display.c\51</Expression>
</Bp>
</Breakpoint>
<WatchWindow1> <WatchWindow1>
<Ww> <Ww>
<count>0</count> <count>0</count>
@ -503,8 +429,8 @@
<periodic>1</periodic> <periodic>1</periodic>
<aLwin>0</aLwin> <aLwin>0</aLwin>
<aCover>0</aCover> <aCover>0</aCover>
<aSer1>1</aSer1> <aSer1>0</aSer1>
<aSer2>1</aSer2> <aSer2>0</aSer2>
<aPa>0</aPa> <aPa>0</aPa>
<viewmode>1</viewmode> <viewmode>1</viewmode>
<vrSel>0</vrSel> <vrSel>0</vrSel>
@ -513,12 +439,12 @@
<AscS1>0</AscS1> <AscS1>0</AscS1>
<AscS2>0</AscS2> <AscS2>0</AscS2>
<AscS3>0</AscS3> <AscS3>0</AscS3>
<aSer3>1</aSer3> <aSer3>0</aSer3>
<eProf>0</eProf> <eProf>0</eProf>
<aLa>1</aLa> <aLa>0</aLa>
<aPa1>0</aPa1> <aPa1>0</aPa1>
<AscS4>0</AscS4> <AscS4>0</AscS4>
<aSer4>1</aSer4> <aSer4>0</aSer4>
<StkLoc>0</StkLoc> <StkLoc>0</StkLoc>
<TrcWin>0</TrcWin> <TrcWin>0</TrcWin>
<newCpu>0</newCpu> <newCpu>0</newCpu>

4
MyDrivers/ADC.c
View file

@ -15,10 +15,10 @@ void ADC_conf(ADC_TypeDef *adc)
// Division de la frequence // Division de la frequence
RCC->CFGR |= RCC_CFGR_ADCPRE_DIV6; RCC->CFGR |= RCC_CFGR_ADCPRE_DIV6;
// Fixe le nombre de conversion à 1 // Fixe le nombre de conversion <EFBFBD> 1
adc->SQR1 &= ADC_SQR1_L; adc->SQR1 &= ADC_SQR1_L;
// Calibration // Calibration (ne fonctionne pas, mais pas necessaire donc ok)
// adc->CR2 |= ADC_CR2_CAL_Msk; // adc->CR2 |= ADC_CR2_CAL_Msk;
// while ((adc->CR2 & ADC_CR2_CAL_Msk)); // while ((adc->CR2 & ADC_CR2_CAL_Msk));
} }

34
MyDrivers/ADC.h
View file

@ -3,12 +3,46 @@
#include "stm32f1xx_ll_adc.h" #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); 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); 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); 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); 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); float ADC_convertToVolt(uint16_t value);

24
MyDrivers/GPIO.c
View file

@ -1,37 +1,37 @@
#include "GPIO.h" #include "GPIO.h"
#include "stm32f1xx_ll_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; LL_GPIO_InitTypeDef init;
//Activation de l'horloge //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 //Configuration du PIN
LL_GPIO_StructInit(&init); LL_GPIO_StructInit(&init);
init.Pin = PINx; init.Pin = pin;
init.Mode = mode; init.Mode = mode;
//init.Speed = ; //init.Speed = ;
init.OutputType = outputType; init.OutputType = outputType;
init.Pull = pullMode; 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) { if (output) {
LL_GPIO_SetOutputPin(GPIOx, PINx); LL_GPIO_SetOutputPin(gpio, pin);
} else { } 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 * @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 * @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 #endif

111
MyDrivers/Timer.c
View file

@ -45,37 +45,18 @@ void TIM4_IRQHandler(void)
} }
/**
* @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) void Timer_IT_enable(TIM_TypeDef * timer)
{ {
LL_TIM_EnableIT_UPDATE(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) void Timer_IT_disable(TIM_TypeDef * timer)
{ {
LL_TIM_DisableIT_UPDATE(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) void Timer_IT_conf(TIM_TypeDef * timer, void (*it_callback) (void), int prio)
{ {
// affectation de la fonction // affectation de la fonction
@ -85,7 +66,7 @@ void Timer_IT_conf(TIM_TypeDef * timer, void (*it_callback) (void), int prio)
else it_callback_TIM4 = it_callback; else it_callback_TIM4 = it_callback;
// Blocage IT (il faudra la d<EFBFBD>bloquer voir fct suivante) // Blocage IT (il faudra la debloquer voir fct suivante)
LL_TIM_DisableIT_UPDATE(timer); LL_TIM_DisableIT_UPDATE(timer);
// validation du canal NVIC // validation du canal NVIC
@ -106,36 +87,17 @@ void Timer_IT_conf(TIM_TypeDef * timer, void (*it_callback) (void), int prio)
* TIMER * 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) void Timer_start(TIM_TypeDef * timer)
{ {
LL_TIM_EnableCounter(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) void Timer_stop(TIM_TypeDef * timer)
{ {
LL_TIM_DisableCounter(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) void Timer_conf(TIM_TypeDef * timer, int arr, int psc)
{ {
LL_TIM_InitTypeDef init_struct; LL_TIM_InitTypeDef init_struct;
@ -165,9 +127,10 @@ void Timer_conf(TIM_TypeDef * timer, int arr, int psc)
/**************************************************************************** /****************************************************************************
* PWM INPUT * PWM INPUT
***************************************************************************/ ***************************************************************************/
void 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). 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 // Validation horloge locale
if (TIMx == TIM1) LL_APB2_GRP1_EnableClock(LL_APB2_GRP1_PERIPH_TIM1); if (TIMx == TIM1) LL_APB2_GRP1_EnableClock(LL_APB2_GRP1_PERIPH_TIM1);
@ -177,49 +140,49 @@ void PWMi_conf(TIM_TypeDef * TIMx, int channel){
if (channel == 1) { if (channel == 1) {
//
TIMx -> CCMR1 |= TIM_CCMR1_CC1S_0;
TIMx -> CCMR1 |= TIM_CCMR1_CC2S_1;
//TIM_CCMR1_IC1F_0; Potentiellement utile, à voir plus tard TIMx->CCMR1 |= TIM_CCMR1_CC1S_0;
TIMx->CCMR1 |= TIM_CCMR1_CC2S_1;
//On met le channel principal en rising edge, le secondaire en falling edge // TIM_CCMR1_IC1F_0; Potentiellement utile, à voir plus tard
TIMx -> CCER &= ~TIM_CCER_CC1P;
TIMx -> CCER |= TIM_CCER_CC2P;
TIMx -> SMCR |= TIM_SMCR_TS_0 | TIM_SMCR_TS_2; //101 // On met le channel principal en rising edge, le secondaire en falling edge
TIMx -> SMCR |= TIM_SMCR_SMS_2; //100 TIMx->CCER &= ~TIM_CCER_CC1P;
TIMx->CCER |= TIM_CCER_CC2P;
TIMx->SMCR |= TIM_SMCR_TS_0 | TIM_SMCR_TS_2; //101
TIMx->SMCR |= TIM_SMCR_SMS_2; //100
} }
else { 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_IC1PSC;
TIMx -> CCMR1 &= ~TIM_CCMR1_IC2PSC; TIMx -> CCMR1 &= ~TIM_CCMR1_IC2PSC;
TIMx -> CCER |= TIM_CCER_CC1E | TIM_CCER_CC2E; 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;
} }
float PWMi_getDutyCycle(TIM_TypeDef * TIMx) { float Timer_pwmi_getDutyCycle(TIM_TypeDef * TIMx) {
const int arr = LL_TIM_GetAutoReload(TIMx); const float arr = (float)LL_TIM_GetAutoReload(TIMx);
float duty_cycle = (float)TIMx->CCR2 / (float)arr; float duty_cycle = (float)TIMx->CCR2 / arr;
return duty_cycle; return duty_cycle;
} }
@ -266,10 +229,14 @@ float Timer_pwmo_getDutyCycle(TIM_TypeDef * timer, int channel)
{ {
int compare = 0; int compare = 0;
const int arr = LL_TIM_GetAutoReload(timer); const int arr = LL_TIM_GetAutoReload(timer);
if (channel == LL_TIM_CHANNEL_CH1) compare = LL_TIM_OC_GetCompareCH1(timer); if (channel == LL_TIM_CHANNEL_CH1)
else if (channel == LL_TIM_CHANNEL_CH2) compare = LL_TIM_OC_GetCompareCH2(timer); compare = LL_TIM_OC_GetCompareCH1(timer);
else if (channel == LL_TIM_CHANNEL_CH3) compare = LL_TIM_OC_GetCompareCH3(timer); else if (channel == LL_TIM_CHANNEL_CH2)
else compare = LL_TIM_OC_GetCompareCH4(timer); 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); return ((float) compare) / ((float) arr);
} }
@ -279,6 +246,8 @@ float Timer_pwmo_getDutyCycle(TIM_TypeDef * timer, int channel)
void Timer_encoder_conf(TIM_TypeDef * timer) void Timer_encoder_conf(TIM_TypeDef * timer)
{ {
// L'encodeur compte 2 tours quand on en fait qu'un, donc on divise l'angle
// par deux avant de le renvoyer. Il faut donc un autoreload de 360 * 2 = 720
Timer_conf(timer, 719, 0); Timer_conf(timer, 719, 0);
LL_TIM_ENCODER_InitTypeDef init_struct; LL_TIM_ENCODER_InitTypeDef init_struct;
LL_TIM_ENCODER_StructInit(&init_struct); LL_TIM_ENCODER_StructInit(&init_struct);
@ -290,6 +259,8 @@ void Timer_encoder_conf(TIM_TypeDef * timer)
int Timer_encoder_getAngle(TIM_TypeDef * timer) int Timer_encoder_getAngle(TIM_TypeDef * timer)
{ {
// L'encodeur compte 2 tours quand on en fait qu'un, donc on divise l'angle
// par deux avant de le renvoyer
return LL_TIM_GetCounter(timer)/2; return LL_TIM_GetCounter(timer)/2;
} }

71
MyDrivers/Timer.h
View file

@ -14,10 +14,30 @@ enum CounterDirection {
* INTERRUPTIONS * 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); 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); 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); 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 * 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 * @note
* @param TIM_TypeDef Timer : indique le timer <EFBFBD> utiliser par le chronom<EFBFBD>tre, TIM1, TIM2, TIM3 ou TIM4 * @param TIM_TypeDef Timer : indique le timer <EFBFBD> utiliser par le chronom<EFBFBD>tre, TIM1, TIM2, TIM3 ou TIM4
* @retval None * @retval None
*/ */
void Timer_start(TIM_TypeDef * timer); void Timer_start(TIM_TypeDef * timer);
/** /**
* @brief Arr<EFBFBD>t le timer consid<EFBFBD>r<EFBFBD> * @brief Arrête le timer considéré
* @note * @note
* @param TIM_TypeDef Timer : indique le timer <EFBFBD> utiliser par le chronom<EFBFBD>tre, TIM1, TIM2, TIM3 ou TIM4 * @param TIM_TypeDef Timer : indique le timer <EFBFBD> utiliser par le chronom<EFBFBD>tre, TIM1, TIM2, TIM3 ou TIM4
* @retval None * @retval None
*/ */
void Timer_stop(TIM_TypeDef * timer); 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 * 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 (pas LL)
* @retval None
*/
void Timer_pwmi_conf(TIM_TypeDef * timer, int channel);
float 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
*/
float 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 * PWM OUTPUT

28
MyDrivers/USART.c
View file

@ -3,22 +3,22 @@
#include "stm32f1xx_ll_bus.h" // Pour horloge #include "stm32f1xx_ll_bus.h" // Pour horloge
void Usart_conf(USART_TypeDef *USARTx) void USART_conf(USART_TypeDef *usart)
{ {
int txPin; int txPin;
GPIO_TypeDef *usartGpio; 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_USART1);
LL_APB2_GRP1_EnableClock(LL_APB2_GRP1_PERIPH_GPIOA); LL_APB2_GRP1_EnableClock(LL_APB2_GRP1_PERIPH_GPIOA);
txPin = LL_GPIO_PIN_9; txPin = LL_GPIO_PIN_9;
usartGpio = GPIOA; usartGpio = GPIOA;
} else if (USARTx == USART2) { } else if (usart == USART2) {
LL_APB1_GRP1_EnableClock(LL_APB1_GRP1_PERIPH_USART2); LL_APB1_GRP1_EnableClock(LL_APB1_GRP1_PERIPH_USART2);
LL_APB2_GRP1_EnableClock(LL_APB2_GRP1_PERIPH_GPIOA); LL_APB2_GRP1_EnableClock(LL_APB2_GRP1_PERIPH_GPIOA);
txPin = LL_GPIO_PIN_2; txPin = LL_GPIO_PIN_2;
usartGpio = GPIOA; usartGpio = GPIOA;
} else if (USARTx == USART3) { } else if (usart == USART3) {
LL_APB1_GRP1_EnableClock(LL_APB1_GRP1_PERIPH_USART3); LL_APB1_GRP1_EnableClock(LL_APB1_GRP1_PERIPH_USART3);
LL_APB2_GRP1_EnableClock(LL_APB2_GRP1_PERIPH_GPIOB); LL_APB2_GRP1_EnableClock(LL_APB2_GRP1_PERIPH_GPIOB);
txPin = LL_GPIO_PIN_10; txPin = LL_GPIO_PIN_10;
@ -30,30 +30,26 @@ void Usart_conf(USART_TypeDef *USARTx)
usartInit.DataWidth = LL_USART_DATAWIDTH_8B; usartInit.DataWidth = LL_USART_DATAWIDTH_8B;
usartInit.BaudRate = 9600; usartInit.BaudRate = 9600;
usartInit.TransferDirection = LL_USART_DIRECTION_TX_RX; 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); 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++) { 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" #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 #endif

10
Services/Accelerometer.c
View file

@ -1,6 +1,7 @@
#include "Accelerometer.h" #include "Accelerometer.h"
#include "ADC.h" #include "ADC.h"
#include "math.h" #include "math.h"
#include "stdio.h"
#define M_PI 3.14159265358979323846 #define M_PI 3.14159265358979323846
@ -8,8 +9,10 @@
// Donc sensibilité de +- 480 mv/g // Donc sensibilité de +- 480 mv/g
const float ZERO_G = 1.65; // 0 g const float ZERO_G = 1.27; // 0 g
const float SENSITIVITY = 0.48; const float SENSITIVITY = 1.35-0.9;
// max: 1.75
// min: 0.935
void Accelerometer_conf(ADC_TypeDef *adc, GPIO_TypeDef * gpio, int pinx, int piny) void Accelerometer_conf(ADC_TypeDef *adc, GPIO_TypeDef * gpio, int pinx, int piny)
{ {
@ -35,7 +38,8 @@ float voltsToG(float volts)
int Accelerometer_getAngle(ADC_TypeDef *adc, int channel) int Accelerometer_getAngle(ADC_TypeDef *adc, int channel)
{ {
const float readG = voltsToG(ADC_readVolt(adc, channel)); const float readV = ADC_readVolt(adc, channel);
const float readG = voltsToG(readV);
float angleRad = asin(readG); float angleRad = asin(readG);
int angleDeg = angleRad * (180/M_PI); int angleDeg = angleRad * (180/M_PI);

22
Services/Accelerometer.h
View file

@ -4,10 +4,32 @@
#include "GPIO.h" #include "GPIO.h"
#include "stm32f1xx_ll_adc.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); 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); 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); int Accelerometer_getAngle(ADC_TypeDef *adc, int channel);
#endif #endif

20
Services/DCMotor.c
View file

@ -1,18 +1,20 @@
#include "DCMotor.h" #include "DCMotor.h"
#include "math.h" #include "math.h"
void DCMotor_conf(TIM_TypeDef * timer, int channel, GPIO_TypeDef * gpio, int pin) const int MOTOR_PWM_FREQ = 50;
void DCMotor_conf(TIM_TypeDef * timer, int channel, GPIO_TypeDef * gpioPwm, int pinPwm, GPIO_TypeDef * gpioDirection, int pinDirection)
{ {
//On règle la vitesse en valeur absolue, ici à 0 // On regle la vitesse en valeur absolue, ici a 0
Timer_pwmo_conf(timer, channel, 50, 0); Timer_pwmo_conf(timer, channel, MOTOR_PWM_FREQ, 0);
// Configuration du GPIO // Configuration du GPIO
GPIO_conf(GPIOA, LL_GPIO_PIN_1, LL_GPIO_MODE_ALTERNATE, LL_GPIO_OUTPUT_PUSHPULL, LL_GPIO_PULL_UP); GPIO_conf(gpioPwm, pinPwm, LL_GPIO_MODE_ALTERNATE, LL_GPIO_OUTPUT_PUSHPULL, LL_GPIO_PULL_UP);
//On règle le sens du moteur, ici sens direct (?) // On regle le sens du moteur
GPIO_conf(gpio, pin, LL_GPIO_MODE_OUTPUT, LL_GPIO_OUTPUT_PUSHPULL, LL_GPIO_PULL_DOWN); GPIO_conf(gpioDirection, pinDirection, LL_GPIO_MODE_OUTPUT, LL_GPIO_OUTPUT_PUSHPULL, LL_GPIO_PULL_DOWN);
GPIO_setPin(gpio, pin, 0); GPIO_setPin(gpioDirection, pinDirection, 0);
Timer_start(timer); Timer_start(timer);
} }
@ -21,8 +23,7 @@ void DCMotor_conf(TIM_TypeDef * timer, int channel, GPIO_TypeDef * gpio, int pin
void DCMotor_setSpeed(TIM_TypeDef * timer, int channel, GPIO_TypeDef * gpio, int pin, float speed) void DCMotor_setSpeed(TIM_TypeDef * timer, int channel, GPIO_TypeDef * gpio, int pin, float speed)
{ {
const int dir = (speed > 0.) ? 1 : 0; const int dir = speed > 0.0;
Timer_pwmo_setDutyCycle(timer, channel, fabs(speed)); Timer_pwmo_setDutyCycle(timer, channel, fabs(speed));
GPIO_setPin(gpio, pin, dir); GPIO_setPin(gpio, pin, dir);
} }
@ -31,6 +32,5 @@ float DCMotor_getSpeed(TIM_TypeDef * timer, int channel, GPIO_TypeDef * gpio, in
{ {
const float speedAbs = Timer_pwmo_getDutyCycle(timer, channel); const float speedAbs = Timer_pwmo_getDutyCycle(timer, channel);
const int dir = GPIO_readPin(gpio, pin); const int dir = GPIO_readPin(gpio, pin);
return dir ? speedAbs : -speedAbs; return dir ? speedAbs : -speedAbs;
} }

31
Services/DCMotor.h
View file

@ -4,10 +4,39 @@
#include "GPIO.h" #include "GPIO.h"
#include "Timer.h" #include "Timer.h"
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 utilise pour controler le moteur
* channel : channel du timer
* gpio : GPIO utilise pour regler le sens du moteur
* pin : Pin pour l'axe Y
* @retval None
*/
void DCMotor_conf(TIM_TypeDef * timer, int channel, GPIO_TypeDef * gpioPwm, int pinPwm, GPIO_TypeDef * gpioDirection, int pinDirection);
/**
* @brief Configure le Timer et le GPIO du DCmotor
* @note
* @param timer : Timer utilise pour controler le moteur
* channel : channel du timer
* gpio : GPIO utilise pour regler 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); void DCMotor_setSpeed(TIM_TypeDef * timer, int channel, GPIO_TypeDef * gpio, int pin, float speed);
/**
* @brief Recupere la vitesse actuelle du moteur
* @note
* @param timer : Timer utilise pour controler le moteur
* channel : channel du timer
* gpio : GPIO utilise pour regler 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); float DCMotor_getSpeed(TIM_TypeDef * timer, int channel, GPIO_TypeDef * gpio, int pin);
#endif #endif

22
Services/IncrementalEncoder.h
View file

@ -4,34 +4,36 @@
#include "stm32f103xb.h" #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 incremental
* @note * @note
* @param TIM_TypeDef Timer : indique le timer à utiliser : TIM1, TIM2, TIM3 ou TIM4 * @param TIM_TypeDef timer : le timer a utiliser
* GPIO_TypeDef gpio : le gpio a utiliser pour le zero
* int pin : le pin associe au GPIO pour le zero
* @retval None * @retval None
*/ */
void IncrementalEncoder_conf(TIM_TypeDef * timer, GPIO_TypeDef * gpio, int pin); void IncrementalEncoder_conf(TIM_TypeDef * timer, GPIO_TypeDef * gpio, int pin);
/** /**
* @brief Démarre le codeur incrémental associé au timer donné * @brief Demarre le timer pour le codeur incremental
* @note * @note
* @param TIM_TypeDef Timer : indique le timer à utiliser : TIM1, TIM2, TIM3 ou TIM4 * @param TIM_TypeDef timer : le timer a utiliser
* @retval None * @retval None
*/ */
void IncrementalEncoder_start(TIM_TypeDef * timer); void IncrementalEncoder_start(TIM_TypeDef * timer);
/** /**
* @brief Récupère l'angle du codeur incrémental associé au timer donné * @brief Recupere l'angle du codeur incremental associe au timer donne
* @note * @note
* @param TIM_TypeDef Timer : indique le timer à utiliser : TIM1, TIM2, TIM3 ou TIM4 * @param TIM_TypeDef timer : le timer a utiliser
* @retval int angle * @retval L'angle en degres
*/ */
int IncrementalEncoder_getAngle(TIM_TypeDef * timer); int IncrementalEncoder_getAngle(TIM_TypeDef * timer);
/** /**
* @brief Récupère la direction du codeur incrémental associé au timer donné * @brief Recupere la direction du codeur incremental associe au timer donne
* @note * @note
* @param TIM_TypeDef Timer : indique le timer à utiliser : TIM1, TIM2, TIM3 ou TIM4 * @param TIM_TypeDef timer : le timer a utiliser
* @retval int dir * @retval la direction actuelle du codeur
*/ */
enum CounterDirection IncrementalEncoder_getDirection(TIM_TypeDef * timer); 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 // Configuration du pin TXEnable
GPIO_conf(gpioTXEnable, pinTXEnable, LL_GPIO_MODE_OUTPUT, LL_GPIO_OUTPUT_PUSHPULL, 0); GPIO_conf(gpioTXEnable, pinTXEnable, LL_GPIO_MODE_OUTPUT, LL_GPIO_OUTPUT_PUSHPULL, 0);
// Configuration de l'USART // Configuration de l'USART
Usart_conf(usart); USART_conf(usart);
} }
void RFEmitter_start(USART_TypeDef * 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) 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); GPIO_setPin(gpioTXEnable, pinTXEnable, 1);
// Envoi du message // Envoi du message
Usart_send(usart, message, longueur); USART_send(usart, message, longueur);
// reset PA11 (TXEnable) // reset PA11 (TXEnable)
GPIO_setPin(gpioTXEnable, pinTXEnable, 0); GPIO_setPin(gpioTXEnable, pinTXEnable, 0);

24
Services/RFEmitter.h
View file

@ -3,10 +3,34 @@
#include "USART.h" #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); 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); 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); void RFEmitter_send(USART_TypeDef * usart, char * message, int longueur, GPIO_TypeDef *gpioTXEnable, int pinTXEnable);
#endif #endif

8
Services/RFReceiver.c
View file

@ -2,14 +2,10 @@
void RFReceiver_conf(TIM_TypeDef * timer, int channel) void RFReceiver_conf(TIM_TypeDef * timer, int channel)
{ {
PWMi_conf(timer, channel); Timer_pwmi_conf(timer, channel);
} }
float RFReceiver_getData(TIM_TypeDef * timer) float RFReceiver_getData(TIM_TypeDef * timer)
{ {
const float duty_cycle = PWMi_getDutyCycle(timer); return Timer_pwmi_getDutyCycle(timer);
// const int period = PWMi_getPeriod(timer);
// const float duree_impulsion = duty_cycle * period;
return duty_cycle;
} }

13
Services/RFReceiver.h
View file

@ -3,8 +3,21 @@
#include "Timer.h" #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); 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); float RFReceiver_getData(TIM_TypeDef * timer);
#endif #endif

2
Services/Scheduler.h
View file

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

10
Services/ServoMotor.c
View file

@ -14,7 +14,13 @@ void ServoMotor_start(TIM_TypeDef * timer)
} }
float convertAngleToDutyCycle(int angle) { float convertAngleToDutyCycle(int angle) {
return ((float) angle) / 90.0 / 20 + 0.05; // fonction lineaire [0 - 90] -> [0.05 - 0.1]
return (float)angle / 1800.0 + 0.05;
}
int convertDutyCycleToAngle(float dutyCycle) {
// fonction lineaire [0.049 - 0.1] -> [0 - 90]
return (dutyCycle - 0.049) * 1800;
} }
void ServoMotor_setAngle(TIM_TypeDef * timer, int channel, int angle) void ServoMotor_setAngle(TIM_TypeDef * timer, int channel, int angle)
@ -25,5 +31,5 @@ void ServoMotor_setAngle(TIM_TypeDef * timer, int channel, int angle)
int ServoMotor_getAngle(TIM_TypeDef * timer, int channel) int ServoMotor_getAngle(TIM_TypeDef * timer, int channel)
{ {
const float dutyCycle = Timer_pwmo_getDutyCycle(timer, channel); const float dutyCycle = Timer_pwmo_getDutyCycle(timer, channel);
return 359 * dutyCycle; return convertDutyCycleToAngle(dutyCycle);
} }

6
Services/ServoMotor.h
View file

@ -6,7 +6,7 @@
#include "GPIO.h" #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 * @note
* @param TIM_TypeDef Timer : indique le timer à utiliser : TIM1, TIM2, TIM3 ou TIM4 * @param TIM_TypeDef Timer : indique le timer à utiliser : TIM1, TIM2, TIM3 ou TIM4
* int channel : Le channel utilisé par le servo moteur * 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); 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 * @note
* @param TIM_TypeDef Timer : indique le timer à utiliser : TIM1, TIM2, TIM3 ou TIM4 * @param TIM_TypeDef Timer : indique le timer à utiliser : TIM1, TIM2, TIM3 ou TIM4
* @retval None * @retval None
@ -39,7 +39,7 @@ void ServoMotor_setAngle(TIM_TypeDef * timer, int channel, int angle);
* @note * @note
* @param TIM_TypeDef Timer : indique le timer à utiliser : TIM1, TIM2, TIM3 ou TIM4 * @param TIM_TypeDef Timer : indique le timer à utiliser : TIM1, TIM2, TIM3 ou TIM4
* int channel : Le channel utilisé par le servo moteur * 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); int ServoMotor_getAngle(TIM_TypeDef * timer, int channel);

20
Services/Voltage.h
View file

@ -4,10 +4,30 @@
#include "ADC.h" #include "ADC.h"
#include "GPIO.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); 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); 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); float Voltage_getVoltage(ADC_TypeDef * adc, int channel);
#endif #endif

24
Src/Display.c
View file

@ -5,10 +5,12 @@
#include "stdio.h" #include "stdio.h"
#include "string.h" #include "string.h"
// Composants utilisés par l'emetteur
USART_TypeDef * EMITTER_USART = USART1; USART_TypeDef * EMITTER_USART = USART1;
GPIO_TypeDef * EMITTER_GPIO = GPIOA; GPIO_TypeDef * EMITTER_GPIO = GPIOA;
const int EMITTER_PIN = LL_GPIO_PIN_11; const int EMITTER_PIN = LL_GPIO_PIN_11;
// Composants utilisés par la batterie
ADC_TypeDef * VOLTAGE_ADC = ADC2; ADC_TypeDef * VOLTAGE_ADC = ADC2;
const int VOLTAGE_CHANNEL = 12; const int VOLTAGE_CHANNEL = 12;
GPIO_TypeDef * VOLTAGE_GPIO = GPIOC; GPIO_TypeDef * VOLTAGE_GPIO = GPIOC;
@ -26,7 +28,6 @@ void Display_start()
RFEmitter_start(EMITTER_USART); RFEmitter_start(EMITTER_USART);
} }
void Display_background(int secCounter) void Display_background(int secCounter)
{ {
static int previousEmergencyState = 0; static int previousEmergencyState = 0;
@ -34,20 +35,27 @@ void Display_background(int secCounter)
const int emergency = Sail_getEmergencyState(); const int emergency = Sail_getEmergencyState();
if (secCounter - prevSendSec == 3 || (emergency && !previousEmergencyState)) { if (secCounter - prevSendSec == 1 || (emergency && !previousEmergencyState)) {
previousEmergencyState = emergency;
prevSendSec = secCounter; prevSendSec = secCounter;
const float voltage = Voltage_getVoltage(VOLTAGE_ADC, VOLTAGE_CHANNEL); const float voltage = Voltage_getVoltage(VOLTAGE_ADC, VOLTAGE_CHANNEL);
const int sailAngle = Sail_getSailAngle(); const int sailAngle = Sail_getSailAngle();
const int relativeAngle = sailAngle >= 180 ? 360 - sailAngle : sailAngle; const int sailPercent = sailAngle * 100 / 90.0;
const int sailPercent = (90 - relativeAngle) * 100 / 90; // const int relativeAngle = sailAngle >= 180 ? 360 - sailAngle : sailAngle;
// const int sailPercent = (90 - relativeAngle) * 100 / 90;
char displayStr[100];
sprintf(displayStr, "Bordage actuel = %d%%\nTension de la batterie = %fV\n", sailPercent, voltage);
if (emergency)
sprintf(displayStr, "Limite de roulis atteinte !\n%s", displayStr);
char displayStr[100] = "";
char emergStr[30] = "";
if (emergency) {
sprintf(emergStr, "Limite de roulis atteinte !\n\r");
RFEmitter_send(EMITTER_USART, emergStr, strlen(emergStr), EMITTER_GPIO, EMITTER_PIN);
}
sprintf(displayStr, "Angle de la voile : %ddeg\n\rBordage actuel = %d%% \n\rTension de la batterie = %fV \n\r\n\r", sailAngle, sailPercent, voltage);
RFEmitter_send(EMITTER_USART, displayStr, strlen(displayStr), EMITTER_GPIO, EMITTER_PIN); RFEmitter_send(EMITTER_USART, displayStr, strlen(displayStr), EMITTER_GPIO, EMITTER_PIN);
} }

21
Src/Display.h
View file

@ -1,10 +1,29 @@
#ifndef DISPLAY_H #ifndef DISPLAY_H
#define 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); 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_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 #endif

23
Src/Orientation.c
View file

@ -1,23 +1,27 @@
#include "Orientation.h" #include "Orientation.h"
#include "math.h" #include "math.h"
#define THRESHOLD 0 const float THRESHOLD = 0.05;
const float MIN_DUTY_CYCLE = 0.05; const float MIN_DUTY_CYCLE = 0.05;
const float ZERO_DUTY_CYCLE = 0.075; const float ZERO_DUTY_CYCLE = 0.075;
const float MAX_DUTY_CYCLE = 0.1; const float MAX_DUTY_CYCLE = 0.1;
// Recepteur
TIM_TypeDef * RECEIVER_TIMER = TIM4; TIM_TypeDef * RECEIVER_TIMER = TIM4;
const int RECEIVER_CHANNEL = LL_TIM_CHANNEL_CH1; const int RECEIVER_CHANNEL = LL_TIM_CHANNEL_CH1;
// Moteur
TIM_TypeDef * DCMOTOR_TIMER = TIM2; TIM_TypeDef * DCMOTOR_TIMER = TIM2;
const int DCMOTOR_CHANNEL = LL_TIM_CHANNEL_CH2; const int DCMOTOR_CHANNEL = LL_TIM_CHANNEL_CH2;
GPIO_TypeDef * DCMOTOR_GPIO = GPIOA; GPIO_TypeDef * DCMOTOR_GPIO = GPIOA;
const int DCMOTOR_PIN = LL_GPIO_PIN_2; const int DCMOTOR_PIN_PWM = LL_GPIO_PIN_1;
const int DCMOTOR_PIN_DIRECTION = LL_GPIO_PIN_2;
void Orientation_conf() void Orientation_conf()
{ {
DCMotor_conf(DCMOTOR_TIMER, DCMOTOR_CHANNEL, DCMOTOR_GPIO, DCMOTOR_PIN); DCMotor_conf(DCMOTOR_TIMER, DCMOTOR_CHANNEL, DCMOTOR_GPIO, DCMOTOR_PIN_PWM, DCMOTOR_GPIO, DCMOTOR_PIN_DIRECTION);
RFReceiver_conf(RECEIVER_TIMER, LL_TIM_CHANNEL_CH1); RFReceiver_conf(RECEIVER_TIMER, LL_TIM_CHANNEL_CH1);
} }
@ -25,13 +29,12 @@ void Orientation_background()
{ {
const float duty_cycle = RFReceiver_getData(RECEIVER_TIMER); const float duty_cycle = RFReceiver_getData(RECEIVER_TIMER);
// Calcul de la vitesse du moteur (entre 0 et 1)
const float speed = (duty_cycle - ZERO_DUTY_CYCLE) / (MAX_DUTY_CYCLE - ZERO_DUTY_CYCLE); const float speed = (duty_cycle - ZERO_DUTY_CYCLE) / (MAX_DUTY_CYCLE - ZERO_DUTY_CYCLE);
//Si la vitesse (en valeur absolue) ne dépasse pas un certain seuil, on ne démarre pas le moteur // On ne demarre le moteur que si la vitesse depasse un certain seuil
if (THRESHOLD > fabs(speed)) { if (fabs(speed) > THRESHOLD)
DCMotor_setSpeed(DCMOTOR_TIMER, DCMOTOR_CHANNEL, DCMOTOR_GPIO, DCMOTOR_PIN, 0); DCMotor_setSpeed(DCMOTOR_TIMER, DCMOTOR_CHANNEL, DCMOTOR_GPIO, DCMOTOR_PIN_DIRECTION, speed);
} else
else { DCMotor_setSpeed(DCMOTOR_TIMER, DCMOTOR_CHANNEL, DCMOTOR_GPIO, DCMOTOR_PIN_DIRECTION, 0);
DCMotor_setSpeed(DCMOTOR_TIMER, DCMOTOR_CHANNEL, DCMOTOR_GPIO, DCMOTOR_PIN, speed);
}
} }

12
Src/Orientation.h
View file

@ -4,8 +4,20 @@
#include "DCMotor.h" #include "DCMotor.h"
#include "RFReceiver.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); 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); void Orientation_background(void);
#endif #endif

19
Src/Roll.c
View file

@ -29,14 +29,19 @@ int Roll_getEmergencyState(void)
return Roll_isEmergencyState; return Roll_isEmergencyState;
} }
int current = 0;
int angle= 0;
void Roll_background(void) void Roll_background(void)
{ {
const int xAngle = Accelerometer_getAngle(ROLL_ADC, ROLL_Y_CHANNEL); // const int xAngle = Accelerometer_getAngle(ROLL_ADC, ROLL_X_CHANNEL);
//const int yAngle = Accelerometer_getAngle(ROLL_ADC, ROLL_Y_CHANNEL); const int yAngle = Accelerometer_getAngle(ROLL_ADC, ROLL_Y_CHANNEL);
angle = yAngle;
const int currentState = abs(xAngle) >= 40; const int currentState = Roll_isEmergencyState ? abs(yAngle) >= 10 : abs(yAngle) >= 40;
if (Roll_isEmergencyState && !currentState) current = currentState;
Sail_setEmergency(1); if (Roll_isEmergencyState != currentState) {
else if (!Roll_isEmergencyState && currentState) Sail_setEmergency(currentState);
Sail_setEmergency(0); Roll_isEmergencyState = currentState;
}
} }

24
Src/Roll.h
View file

@ -1,12 +1,36 @@
#ifndef ROLL_H #ifndef ROLL_H
#define ROLL_H #define ROLL_H
/**
* @brief Configure l'accelerometre pour la détection de roulis
* @note
* @param None
* @retval None
*/
void Roll_conf(void); void Roll_conf(void);
/**
* @brief Démarre l'accelerometre pour la détection de roulis
* @note
* @param None
* @retval None
*/
void Roll_start(void); 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); 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); void Roll_background(void);
#endif #endif

25
Src/Sail.c
View file

@ -11,7 +11,7 @@ TIM_TypeDef * ENCODER_TIMER = TIM3;
GPIO_TypeDef * ENCODER_GPIO = GPIOA; GPIO_TypeDef * ENCODER_GPIO = GPIOA;
const int ENCODER_PIN = LL_GPIO_PIN_5; const int ENCODER_PIN = LL_GPIO_PIN_5;
const int RESET_ANGLE = 90; const int RESET_ANGLE = 0;
int Sail_isEmergencyState = 0; int Sail_isEmergencyState = 0;
@ -41,6 +41,17 @@ int Sail_getSailAngle(void)
return ServoMotor_getAngle(MOTOR_TIMER, MOTOR_CHANNEL); 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() void Sail_background()
{ {
@ -54,15 +65,3 @@ void Sail_background()
else else
ServoMotor_setAngle(MOTOR_TIMER, MOTOR_CHANNEL, windToSailAngle(windAngle)); 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 #define SAIL_H
/** /**
* @brief Configure la voile * @brief Configure le servo moteur et le codeur incrémental pour la manipulation de la voile
* @note * @note
* @param None * @param None
* @retval None * @retval None
@ -10,31 +10,44 @@
void Sail_conf(void); 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 * @note
* @param None * @param None
* @retval None * @retval None
*/ */
void Sail_start(void); 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 #endif

26
Src/main.c
View file

@ -26,20 +26,26 @@
#include "Orientation.h" #include "Orientation.h"
#include "Scheduler.h" #include "Scheduler.h"
#include "ADC.h"
#include "GPIO.h"
#include "Accelerometer.h" #include "Accelerometer.h"
#include "RFEmitter.h" #include "RFEmitter.h"
#include "stdio.h" #include "stdio.h"
void SystemClock_Config(void); void SystemClock_Config(void);
// Compteur de secondes
int secCounter = 0; int secCounter = 0;
/* Private functions ---------------------------------------------------------*/ /* Private functions ---------------------------------------------------------*/
/**
* @brief Effectue la tache de fond (programmee toutes les ms)
* @note
* @param None
* @retval None
*/
void backgroundTask() void backgroundTask()
{ {
// Compte les millisecondes et secondes
static int msCounter; static int msCounter;
msCounter++; msCounter++;
if (msCounter == 1000) { if (msCounter == 1000) {
@ -51,6 +57,12 @@ void backgroundTask()
Orientation_background(); Orientation_background();
} }
/**
* @brief Configure les peripheriques
* @note
* @param None
* @retval None
*/
void configurePeripherals() void configurePeripherals()
{ {
Sail_conf(); Sail_conf();
@ -59,6 +71,12 @@ void configurePeripherals()
Orientation_conf(); Orientation_conf();
} }
/**
* @brief Demarre les peripheriques
* @note
* @param None
* @retval None
*/
void startPeripherals() void startPeripherals()
{ {
Sail_start(); Sail_start();
@ -84,7 +102,7 @@ int main(void)
Scheduler_start(); Scheduler_start();
while (1) { while (1) {
// Display_background(secCounter); Display_background(secCounter);
} }
@ -132,7 +150,7 @@ void SystemClock_Config(void)
/* Enable HSE oscillator */ /* Enable HSE oscillator */
// ********* Commenter la ligne ci-dessous pour MCBSTM32 ***************** // ********* Commenter la ligne ci-dessous pour MCBSTM32 *****************
// ********* Conserver la ligne si Nucléo********************************* // ********* Conserver la ligne si Nucleo*********************************
// LL_RCC_HSE_EnableBypass(); // LL_RCC_HSE_EnableBypass();
LL_RCC_HSE_Enable(); LL_RCC_HSE_Enable();
while(LL_RCC_HSE_IsReady() != 1) while(LL_RCC_HSE_IsReady() != 1)