goncalves/Projet_Voilier
2
2
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Compare commits

base: goncalves:596d8a93e8819ccd1cb4f39a76be11234e4efb01
Branches Tags
goncalves:master
..
compare: goncalves:d9b9abe94ae6fdfd275c85eeceb74ae64f05525d
Branches Tags
goncalves:master

5 commits
596d8a93e8 ... d9b9abe94a

Author SHA1 Message Date
leo
d9b9abe94a test_distance 2025-11-21 22:08:12 +01:00
leo
8720083f62 test 2025-11-21 21:53:16 +01:00
leo
8f4a6d8c6c Deuxième version plateau 2025-11-15 16:34:21 +01:00
leo
51e164d5e4 Deuxième version plateau 2025-11-15 16:24:52 +01:00
leo
203c1ffa3d test 2025-11-15 15:58:08 +01:00
12 changed files with 382 additions and 387 deletions
Show stats Expand all files Collapse all files

56
.gitignore vendored
View file

@ -1,30 +1,26 @@
*.obj *.obj
*.o *.o
*.bin *.bin
*.list *.list
*.map *.map
*.mk *.mk
*.makefile *.makefile
*.o *.o
*.su *.su
*.d *.d
*.elf *.elf
*.scvd *.scvd
*.crf *.crf
*.map *.map
*.sct *.sct
*.dbgconf *.dbgconf
*.axf *.axf
*.htm *.htm
*.lnp *.lnp
*.dep *.dep
*.uvguix.* *.uvguix.*
*.lst *.lst
*.iex *.iex
**/Objects/ **/Objects/
**/Listings/ **/Listings/
**/Debug/ **/Debug/

62
Services/Plateau.c
View file

@ -1,32 +1,32 @@
#include <stm32f10x.h> #include <stm32f10x.h>
#include <Plateau.h> #include <Plateau.h>
#include <MyTimer.h> #include <MyTimer.h>
#include <GPIO.h> #include <GPIO.h>
#include <ADC.h> #include <ADC.h>
#include <USART.h> #include <USART.h>
void handler_USART1 (void) { void handler_USART1 (void) {
//Pour le projet : Lancer PWM en fonction de la valeur du curseur //Pour le projet : Lancer PWM en fonction de la valeur du curseur
char data = USART1->DR; char data = USART1->DR;
char valabs; char valabs;
if (data & (1<<7)) { if (data & (1<<7)) {
MyGPIO_Set(GPIOA, 1); MyGPIO_Set(GPIOA, 1);
valabs = (1<<7) - (data & 0x7F); valabs = (1<<7) - (data & 0x7F);
Mytimer_PWM_cycle(TIM3, 3, valabs); Mytimer_PWM_cycle(TIM3, 3, valabs);
} }
else { else {
MyGPIO_Reset(GPIOA, 1); MyGPIO_Reset(GPIOA, 1);
Mytimer_PWM_cycle(TIM3, 3, data); Mytimer_PWM_cycle(TIM3, 3, data);
} }
} }
void Plateau_Init (void){ void Plateau_Init (void){
MyGPIO_Init(GPIOB,0,AltOut_Ppull); MyGPIO_Init(GPIOB,0,AltOut_Ppull);
MyGPIO_Init(GPIOA,1,Out_Ppull); MyGPIO_Init(GPIOA,1,Out_Ppull);
MyTimer_Init(TIM3, 360, 10); MyTimer_Init(TIM3, 360, 10);
Mytimer_PWM(TIM3, 3); Mytimer_PWM(TIM3, 3);
My_USART_Init(USART1); My_USART_Init(USART1);
MyUSART_ActiveIT(USART1, 6, &handler_USART1); MyUSART_ActiveIT(USART1, 6, &handler_USART1);
MyTimer_Base_Start(TIM3); MyTimer_Base_Start(TIM3);
} }

12
Services/Plateau.h
View file

@ -1,7 +1,7 @@
#ifndef MYPLATEAU_H #ifndef MYPLATEAU_H
#define MYPLATEAU_H #define MYPLATEAU_H
void Plateau_Init (void); void Plateau_Init (void);
void handler_USART1 (void); void handler_USART1 (void);
#endif #endif

85
drivers/ADC.c
View file

@ -1,43 +1,42 @@
#include <stm32f10x.h> #include <stm32f10x.h>
#include <ADC.h> #include <ADC.h>
void (*ptr_function) (void); void (*ptr_function) (void);
void MyADC_Init(ADC_TypeDef *ADC, char channel){ void MyADC_Init(ADC_TypeDef *ADC, char channel){
if (ADC == ADC1) RCC->APB2ENR |= RCC_APB2ENR_ADC1EN; if (ADC == ADC1) RCC->APB2ENR |= RCC_APB2ENR_ADC1EN;
else if (ADC == ADC2) RCC->APB2ENR |= RCC_APB2ENR_ADC2EN; else if (ADC == ADC2) RCC->APB2ENR |= RCC_APB2ENR_ADC2EN;
RCC->CFGR |= RCC_CFGR_ADCPRE_DIV6; // Passage de l'horloge a 12MHz RCC->CFGR |= RCC_CFGR_ADCPRE_DIV6; // Passage de l'horloge a 12MHz
ADC->CR2 |= ADC_CR2_ADON; // Démarrage ADC ADC->CR2 |= ADC_CR2_ADON; // Démarrage ADC
ADC->SQR1 &= ADC_SQR1_L; // Fixe nb de conversion à faire : 1 ADC->SQR1 &= ADC_SQR1_L; // Fixe nb de conversion à faire : 1
ADC->SQR3 = channel; // Fixe la voie à convertir ADC->SQR3 = channel; // Fixe la voie à convertir
} }
void start_conversion(ADC_TypeDef *ADC){ void start_conversion(ADC_TypeDef *ADC){
ADC->CR2 |= ADC_CR2_EXTSEL; ADC->CR2 |= ADC_CR2_EXTSEL;
ADC->CR2 |= ADC_CR2_EXTTRIG; // Permettre le démarage externe ADC->CR2 |= ADC_CR2_EXTTRIG; // Permettre le démarage externe
ADC->CR2 |= ADC_CR2_SWSTART; // demander une conversion externe ADC->CR2 |= ADC_CR2_SWSTART; // demander une conversion externe
//Si on veut faire par scrutation et non par intéruption, laisser les lignes suivantes //Si on veut faire par scrutation et non par intéruption, laisser les lignes suivantes
//while(!(ADC->SR & ADC_SR_EOC)); // attendre la fin (EOC = 1) //while(!(ADC->SR & ADC_SR_EOC)); // attendre la fin (EOC = 1)
//ADC->SR &=~ ADC_SR_EOC; // clear EOC //ADC->SR &=~ ADC_SR_EOC; // clear EOC
//return ADC->DR &~ (0xF << 12); // retourne 12 bits //return ADC->DR &~ (0xF << 12); // retourne 12 bits
} }
void MyADC_ActiveIT(ADC_TypeDef *ADC, int prio, void (*IT_function) (void)){ void MyADC_ActiveIT(ADC_TypeDef *ADC, int prio, void (*IT_function) (void)){
ptr_function = IT_function; ptr_function = IT_function;
NVIC->ISER[0] |= 1<<18; NVIC->ISER[0] |= 1<<18;
NVIC->IPR[25] |= prio << 4; NVIC->IPR[25] |= prio << 4;
ADC->CR1 |= ADC_CR1_EOCIE; ADC->CR1 |= ADC_CR1_EOCIE;
} }
void ADC1_2_IRQHandler(void){ void ADC1_2_IRQHandler(void){
ADC1->CR1 &=~ ADC_SR_EOC; ADC1->CR1 &=~ ADC_SR_EOC;
ptr_function(); ptr_function();
} }
//void Set_samp_ts(ADC_TypeDef *ADC, int Rain){ //void Set_samp_ts(ADC_TypeDef *ADC, int Rain){
// float ts; // float ts;
// float cylcle; // float cylcle;
// ts = 9.010913347*(Rain +1000.00)*0.000000000008; // ts = 9.010913347*(Rain +1000.00)*0.000000000008;
// cycle = ts*12/0.000001; // cycle = ts*12/0.000001;
// ADC->SMPR1 |= // ADC->SMPR1 |=
//}

18
drivers/ADC.h
View file

@ -1,10 +1,10 @@
#ifndef MYADC_H #ifndef MYADC_H
#define MYADC_H #define MYADC_H
#include <stm32f10x.h> #include <stm32f10x.h>
void MyADC_Init(ADC_TypeDef *ADC, char channel); void MyADC_Init(ADC_TypeDef *ADC, char channel);
void start_conversion(ADC_TypeDef *ADC); void start_conversion(ADC_TypeDef *ADC);
void MyADC_ActiveIT(ADC_TypeDef *ADC, int prio, void (*IT_function) (void)); void MyADC_ActiveIT(ADC_TypeDef *ADC, int prio, void (*IT_function) (void));
//void Set_samp_ts(ADC_TypeDef *ADC, int Rain); //void Set_samp_ts(ADC_TypeDef *ADC, int Rain);
#endif #endif

114
drivers/GPIO.c
View file

@ -1,58 +1,58 @@
#include <stm32f10x.h> #include <stm32f10x.h>
#include <GPIO.h> #include <GPIO.h>
void MyGPIO_Init(GPIO_TypeDef *GPIO, char pin, char conf){ void MyGPIO_Init(GPIO_TypeDef *GPIO, char pin, char conf){
if (GPIO == GPIOA) {RCC->APB2ENR |= (RCC_APB2ENR_IOPAEN);} if (GPIO == GPIOA) {RCC->APB2ENR |= (RCC_APB2ENR_IOPAEN);}
else if (GPIO == GPIOB) {RCC->APB2ENR |= (RCC_APB2ENR_IOPBEN);} else if (GPIO == GPIOB) {RCC->APB2ENR |= (RCC_APB2ENR_IOPBEN);}
else if (GPIO == GPIOC) {RCC->APB2ENR |= (RCC_APB2ENR_IOPCEN);} else if (GPIO == GPIOC) {RCC->APB2ENR |= (RCC_APB2ENR_IOPCEN);}
else if (GPIO == GPIOD) {RCC->APB2ENR |= (RCC_APB2ENR_IOPDEN);} else if (GPIO == GPIOD) {RCC->APB2ENR |= (RCC_APB2ENR_IOPDEN);}
if (pin < 8) { if (pin < 8) {
if (conf == 0xF) { if (conf == 0xF) {
GPIO->CRL&=~(0xF<<4*pin); GPIO->CRL&=~(0xF<<4*pin);
GPIO->CRL|=(0x8<<4*pin); GPIO->CRL|=(0x8<<4*pin);
GPIO->ODR|=(1<<pin); GPIO->ODR|=(1<<pin);
} }
else if (conf == 0x8) { else if (conf == 0x8) {
GPIO->CRL&=~(0xF<<4*pin); GPIO->CRL&=~(0xF<<4*pin);
GPIO->CRL|=(conf<<4*pin); GPIO->CRL|=(conf<<4*pin);
GPIO->ODR&=~(1<<pin); GPIO->ODR&=~(1<<pin);
} }
else { else {
GPIO->CRL&=~(0xF<<4*pin); GPIO->CRL&=~(0xF<<4*pin);
GPIO->CRL|=(conf<<4*pin); GPIO->CRL|=(conf<<4*pin);
} }
} }
else { else {
if (conf == 0xF) { if (conf == 0xF) {
GPIO->CRH&=~(0xF<<4*(pin-8)); GPIO->CRH&=~(0xF<<4*(pin-8));
GPIO->CRH|=(0x8<<4*(pin-8)); GPIO->CRH|=(0x8<<4*(pin-8));
GPIO->ODR|=(1<<pin); GPIO->ODR|=(1<<pin);
} }
else if (conf == 0x8) { else if (conf == 0x8) {
GPIO->CRH&=~(0xF<<4*(pin-8)); GPIO->CRH&=~(0xF<<4*(pin-8));
GPIO->CRH|=(conf<<4*(pin-8)); GPIO->CRH|=(conf<<4*(pin-8));
GPIO->ODR&=~(1<<pin); GPIO->ODR&=~(1<<pin);
} }
else { else {
GPIO->CRH&=~(0xF<<4*(pin-8)); GPIO->CRH&=~(0xF<<4*(pin-8));
GPIO->CRH|=(conf<<4*(pin-8)); GPIO->CRH|=(conf<<4*(pin-8));
} }
} }
} }
int MyGPIO_Read(GPIO_TypeDef *GPIO, char GPIO_Pin){ int MyGPIO_Read(GPIO_TypeDef *GPIO, char GPIO_Pin){
return (GPIO->IDR&(1<<GPIO_Pin)); return (GPIO->IDR&(1<<GPIO_Pin));
} }
void MyGPIO_Set(GPIO_TypeDef *GPIO, char GPIO_Pin){ void MyGPIO_Set(GPIO_TypeDef *GPIO, char GPIO_Pin){
GPIO->BSRR=(1<<GPIO_Pin); GPIO->BSRR=(1<<GPIO_Pin);
} }
void MyGPIO_Reset(GPIO_TypeDef *GPIO, char GPIO_Pin){ void MyGPIO_Reset(GPIO_TypeDef *GPIO, char GPIO_Pin){
GPIO->BSRR=(1<<(GPIO_Pin+16)); GPIO->BSRR=(1<<(GPIO_Pin+16));
} }
void MyGPIO_Toggle(GPIO_TypeDef *GPIO, char GPIO_Pin){ void MyGPIO_Toggle(GPIO_TypeDef *GPIO, char GPIO_Pin){
if (((GPIO->ODR>>GPIO_Pin)&1) == 1) MyGPIO_Reset(GPIO, GPIO_Pin); if (((GPIO->ODR>>GPIO_Pin)&1) == 1) MyGPIO_Reset(GPIO, GPIO_Pin);
else MyGPIO_Set(GPIO, GPIO_Pin); else MyGPIO_Set(GPIO, GPIO_Pin);
} }

38
drivers/GPIO.h
View file

@ -1,20 +1,20 @@
#ifndef MYGPIO_H #ifndef MYGPIO_H
#define MYGPIO_H #define MYGPIO_H
#include <stm32f10x.h> #include <stm32f10x.h>
#define In_Floating 0x4 #define In_Floating 0x4
#define In_PullDown 0x8 #define In_PullDown 0x8
#define In_PullUp 0xF #define In_PullUp 0xF
#define In_Analog 0x0 #define In_Analog 0x0
#define Out_Ppull 0x2 #define Out_Ppull 0x2
#define Out_OD 0x6 #define Out_OD 0x6
#define AltOut_Ppull 0xA #define AltOut_Ppull 0xA
#define AltOut_OD 0xE #define AltOut_OD 0xE
void MyGPIO_Init(GPIO_TypeDef *GPIO, char pin, char conf); void MyGPIO_Init(GPIO_TypeDef *GPIO, char pin, char conf);
int MyGPIO_Read(GPIO_TypeDef *GPIO, char GPIO_Pin); int MyGPIO_Read(GPIO_TypeDef *GPIO, char GPIO_Pin);
void MyGPIO_Set(GPIO_TypeDef *GPIO, char GPIO_Pin); void MyGPIO_Set(GPIO_TypeDef *GPIO, char GPIO_Pin);
void MyGPIO_Reset(GPIO_TypeDef *GPIO, char GPIO_Pin); void MyGPIO_Reset(GPIO_TypeDef *GPIO, char GPIO_Pin);
void MyGPIO_Toggle(GPIO_TypeDef *GPIO, char GPIO_Pin); void MyGPIO_Toggle(GPIO_TypeDef *GPIO, char GPIO_Pin);
#endif #endif

180
drivers/MyTimer.c
View file

@ -1,91 +1,91 @@
#include <stm32f10x.h> #include <stm32f10x.h>
#include <MyTimer.h> #include <MyTimer.h>
void (*Ptr_fct_t1) (void); void (*Ptr_fct_t1) (void);
void (*Ptr_fct_t2) (void); void (*Ptr_fct_t2) (void);
void (*Ptr_fct_t3) (void); void (*Ptr_fct_t3) (void);
void (*Ptr_fct_t4) (void); void (*Ptr_fct_t4) (void);
void MyTimer_Init(TIM_TypeDef *Timer, unsigned short ValARR, unsigned short ValPSC){ void MyTimer_Init(TIM_TypeDef *Timer, unsigned short ValARR, unsigned short ValPSC){
if (Timer == TIM2) {RCC->APB1ENR |= RCC_APB1ENR_TIM2EN;} if (Timer == TIM2) {RCC->APB1ENR |= RCC_APB1ENR_TIM2EN;}
else if (Timer == TIM3) {RCC->APB1ENR |= (RCC_APB1ENR_TIM3EN);} else if (Timer == TIM3) {RCC->APB1ENR |= (RCC_APB1ENR_TIM3EN);}
else if (Timer == TIM4) {RCC->APB1ENR |= (RCC_APB1ENR_TIM4EN);} else if (Timer == TIM4) {RCC->APB1ENR |= (RCC_APB1ENR_TIM4EN);}
else if (Timer == TIM1) {RCC->APB2ENR |= (RCC_APB2ENR_TIM1EN);} else if (Timer == TIM1) {RCC->APB2ENR |= (RCC_APB2ENR_TIM1EN);}
Timer->ARR=ValARR-1; Timer->ARR=ValARR-1;
Timer->PSC=ValPSC-1; Timer->PSC=ValPSC-1;
} }
void MyTimer_ActiveIT (TIM_TypeDef *Timer, char Prio, void (*IT_function) (void)){ void MyTimer_ActiveIT (TIM_TypeDef *Timer, char Prio, void (*IT_function) (void)){
if (Timer == TIM2){ if (Timer == TIM2){
Ptr_fct_t2 = IT_function; Ptr_fct_t2 = IT_function;
NVIC->ISER[0] |= 1<<28; NVIC->ISER[0] |= 1<<28;
NVIC->IPR[35] = Prio<<4; NVIC->IPR[35] = Prio<<4;
} }
else if (Timer == TIM3){ else if (Timer == TIM3){
Ptr_fct_t3 = IT_function; Ptr_fct_t3 = IT_function;
NVIC->ISER[0] |= 1<<29; NVIC->ISER[0] |= 1<<29;
NVIC->IPR[36] = Prio<<4; NVIC->IPR[36] = Prio<<4;
} }
else if (Timer == TIM4){ else if (Timer == TIM4){
Ptr_fct_t4 = IT_function; Ptr_fct_t4 = IT_function;
NVIC->ISER[0] |= 1<<30; NVIC->ISER[0] |= 1<<30;
NVIC->IPR[37] = Prio<<4; NVIC->IPR[37] = Prio<<4;
} }
else if (Timer == TIM1){ else if (Timer == TIM1){
Ptr_fct_t1 = IT_function; Ptr_fct_t1 = IT_function;
NVIC->ISER[0] |= 1<<25; NVIC->ISER[0] |= 1<<25;
NVIC->IPR[32] = Prio<<4; NVIC->IPR[32] = Prio<<4;
} }
Timer->DIER|=TIM_DIER_UIE; Timer->DIER|=TIM_DIER_UIE;
} }
void Mytimer_PWM(TIM_TypeDef *Timer, char Channel){ void Mytimer_PWM(TIM_TypeDef *Timer, char Channel){
if (Channel == 1) { if (Channel == 1) {
Timer->CCMR1 &=~ TIM_CCMR1_OC1M; Timer->CCMR1 &=~ TIM_CCMR1_OC1M;
Timer->CCMR1 |= 0x6 << 4; Timer->CCMR1 |= 0x6 << 4;
Timer->CCER |= TIM_CCER_CC1E; Timer->CCER |= TIM_CCER_CC1E;
} }
else if (Channel == 2) { else if (Channel == 2) {
Timer->CCMR1 &=~ TIM_CCMR1_OC2M; Timer->CCMR1 &=~ TIM_CCMR1_OC2M;
Timer->CCMR1 |= 0x6 << 12; Timer->CCMR1 |= 0x6 << 12;
Timer->CCER |= TIM_CCER_CC2E; Timer->CCER |= TIM_CCER_CC2E;
} }
else if (Channel == 3) { else if (Channel == 3) {
Timer->CCMR2 &=~ TIM_CCMR2_OC3M; Timer->CCMR2 &=~ TIM_CCMR2_OC3M;
Timer->CCMR2 |= 0x6 << 4; Timer->CCMR2 |= 0x6 << 4;
Timer->CCER |= TIM_CCER_CC3E; Timer->CCER |= TIM_CCER_CC3E;
} }
else if (Channel == 4) { else if (Channel == 4) {
Timer->CCMR2 &=~ TIM_CCMR2_OC4M; Timer->CCMR2 &=~ TIM_CCMR2_OC4M;
Timer->CCMR2 |= 0x6 << 12; Timer->CCMR2 |= 0x6 << 12;
Timer->CCER |= TIM_CCER_CC4E; Timer->CCER |= TIM_CCER_CC4E;
} }
} }
void Mytimer_PWM_cycle(TIM_TypeDef *Timer, char Channel, int pulse){ void Mytimer_PWM_cycle(TIM_TypeDef *Timer, char Channel, int pulse){
if (Channel == 1) Timer->CCR1 = Timer->ARR*pulse/100; if (Channel == 1) Timer->CCR1 = Timer->ARR*pulse/100;
else if (Channel == 2) Timer->CCR2 = Timer->ARR*pulse/100; else if (Channel == 2) Timer->CCR2 = Timer->ARR*pulse/100;
else if (Channel == 3) Timer->CCR3 = (Timer->ARR)*pulse/100; else if (Channel == 3) Timer->CCR3 = (Timer->ARR)*pulse/100;
else if (Channel == 4) Timer->CCR4 = Timer->ARR*pulse/100; else if (Channel == 4) Timer->CCR4 = Timer->ARR*pulse/100;
} }
void TIM2_IRQHandler(void){ void TIM2_IRQHandler(void){
TIM2->SR&=~TIM_SR_UIF; TIM2->SR&=~TIM_SR_UIF;
Ptr_fct_t2(); Ptr_fct_t2();
} }
void TIM1_UP_IRQHandler(void){ void TIM1_UP_IRQHandler(void){
TIM1->SR&=~TIM_SR_UIF; TIM1->SR&=~TIM_SR_UIF;
Ptr_fct_t1(); Ptr_fct_t1();
} }
void TIM3_IRQHandler(void){ void TIM3_IRQHandler(void){
TIM3->SR&=~TIM_SR_UIF; TIM3->SR&=~TIM_SR_UIF;
Ptr_fct_t3(); Ptr_fct_t3();
} }
void TIM4_IRQHandler(void){ void TIM4_IRQHandler(void){
TIM4->SR&=~TIM_SR_UIF; TIM4->SR&=~TIM_SR_UIF;
Ptr_fct_t4(); Ptr_fct_t4();
} }

24
drivers/MyTimer.h
View file

@ -1,13 +1,13 @@
#ifndef MYTIMER_H #ifndef MYTIMER_H
#define MYTIMER_H #define MYTIMER_H
#include <stm32f10x.h> #include <stm32f10x.h>
#define MyTimer_Base_Start(Timer) Timer->CR1|=TIM_CR1_CEN; #define MyTimer_Base_Start(Timer) Timer->CR1|=TIM_CR1_CEN;
#define MyTimer_Base_Stop(Timer) Timer->CR1&=~TIM_CR1_CEN; #define MyTimer_Base_Stop(Timer) Timer->CR1&=~TIM_CR1_CEN;
void MyTimer_Init(TIM_TypeDef *Timer, unsigned short ValARR, unsigned short ValPSC); void MyTimer_Init(TIM_TypeDef *Timer, unsigned short ValARR, unsigned short ValPSC);
void MyTimer_ActiveIT (TIM_TypeDef *Timer, char Prio, void (*IT_function) (void)); void MyTimer_ActiveIT (TIM_TypeDef *Timer, char Prio, void (*IT_function) (void));
void Mytimer_PWM(TIM_TypeDef *Timer, char Channel); void Mytimer_PWM(TIM_TypeDef *Timer, char Channel);
void Mytimer_PWM_cycle(TIM_TypeDef *Timer, char Channel, int CCR); void Mytimer_PWM_cycle(TIM_TypeDef *Timer, char Channel, int CCR);
#endif #endif

154
drivers/USART.c
View file

@ -1,78 +1,78 @@
#include <stm32f10x.h> #include <stm32f10x.h>
#include <USART.h> #include <USART.h>
#include <GPIO.h> #include <GPIO.h>
void (*ptr_fct_u1) (void); void (*ptr_fct_u1) (void);
void (*ptr_fct_u2) (void); void (*ptr_fct_u2) (void);
void (*ptr_fct_u3) (void); void (*ptr_fct_u3) (void);
void My_USART_Init(USART_TypeDef *USART){ void My_USART_Init(USART_TypeDef *USART){
if (USART == USART1) { if (USART == USART1) {
RCC->APB2ENR |= RCC_APB2ENR_USART1EN; RCC->APB2ENR |= RCC_APB2ENR_USART1EN;
MyGPIO_Init(GPIOA,9,AltOut_Ppull); MyGPIO_Init(GPIOA,9,AltOut_Ppull);
MyGPIO_Init(GPIOA,10, In_Floating); MyGPIO_Init(GPIOA,10, In_Floating);
USART->BRR = 72000000/9600; USART->BRR = 72000000/9600;
} }
else if (USART == USART2) { else if (USART == USART2) {
RCC->APB1ENR |= RCC_APB1ENR_USART2EN; RCC->APB1ENR |= RCC_APB1ENR_USART2EN;
MyGPIO_Init(GPIOA,2,AltOut_Ppull); MyGPIO_Init(GPIOA,2,AltOut_Ppull);
MyGPIO_Init(GPIOA,3,In_Floating); MyGPIO_Init(GPIOA,3,In_Floating);
USART->BRR = 36000000/9600; USART->BRR = 36000000/9600;
} }
else if (USART == USART3) { else if (USART == USART3) {
RCC->APB1ENR |= RCC_APB1ENR_USART3EN; RCC->APB1ENR |= RCC_APB1ENR_USART3EN;
MyGPIO_Init(GPIOB,10,AltOut_Ppull); MyGPIO_Init(GPIOB,10,AltOut_Ppull);
MyGPIO_Init(GPIOB,11,In_Floating); MyGPIO_Init(GPIOB,11,In_Floating);
USART->BRR = 36000000/9600; USART->BRR = 36000000/9600;
} }
USART->CR1 |= USART_CR1_UE; // Activation de l'USART USART->CR1 |= USART_CR1_UE; // Activation de l'USART
USART->CR1 &= ~USART_CR1_M; // Choix d'une taille de 8 bits de données USART->CR1 &= ~USART_CR1_M; // Choix d'une taille de 8 bits de données
USART->CR2 &= USART_CR2_STOP; // Choix d'un seul bit de stop USART->CR2 &= USART_CR2_STOP; // Choix d'un seul bit de stop
USART->CR1 |= USART_CR1_TE; // Transmission validée USART->CR1 |= USART_CR1_TE; // Transmission validée
USART->CR1 |= USART_CR1_RE; // réception validée USART->CR1 |= USART_CR1_RE; // réception validée
} }
void send_USART(USART_TypeDef *USART, char data){ void send_USART(USART_TypeDef *USART, char data){
USART->DR |= data; // Ecriture de la donnée dans le registre DR USART->DR |= data; // Ecriture de la donnée dans le registre DR
while(!(USART->SR & USART_SR_TXE)) {} // Attente de la fin de transmission while(!(USART->SR & USART_SR_TXE)) {} // Attente de la fin de transmission
} }
char read_USART(USART_TypeDef *USART){ char read_USART(USART_TypeDef *USART){
while (!(USART->SR & USART_SR_RXNE)){} while (!(USART->SR & USART_SR_RXNE)){}
return USART->DR; return USART->DR;
} }
void MyUSART_ActiveIT(USART_TypeDef *USART, int Prio, void (*IT_function) (void)){ void MyUSART_ActiveIT(USART_TypeDef *USART, int Prio, void (*IT_function) (void)){
USART->CR1 |= USART_CR1_RXNEIE; USART->CR1 |= USART_CR1_RXNEIE;
if (USART == USART1){ if (USART == USART1){
ptr_fct_u1 = IT_function; ptr_fct_u1 = IT_function;
NVIC->ISER[1] |= 1<<5; NVIC->ISER[1] |= 1<<5;
NVIC->IPR[44] = Prio<<4; NVIC->IPR[44] = Prio<<4;
} }
else if (USART == USART2){ else if (USART == USART2){
ptr_fct_u2 = IT_function; ptr_fct_u2 = IT_function;
NVIC->ISER[1] |= 1<<6; NVIC->ISER[1] |= 1<<6;
NVIC->IPR[45] = Prio<<4; NVIC->IPR[45] = Prio<<4;
} }
else if (USART == USART3){ else if (USART == USART3){
ptr_fct_u3 = IT_function; ptr_fct_u3 = IT_function;
NVIC->ISER[1] |= 1<<7; NVIC->ISER[1] |= 1<<7;
NVIC->IPR[46] = Prio<<4; NVIC->IPR[46] = Prio<<4;
} }
} }
void USART2_IRQHandler(void){ void USART2_IRQHandler(void){
USART2->SR&=~USART_SR_RXNE; USART2->SR&=~USART_SR_RXNE;
ptr_fct_u2(); ptr_fct_u2();
} }
void USART1_IRQHandler(void){ void USART1_IRQHandler(void){
USART1->SR&=~USART_SR_RXNE; USART1->SR&=~USART_SR_RXNE;
ptr_fct_u1(); ptr_fct_u1();
} }
void USART3_IRQHandler(void){ void USART3_IRQHandler(void){
USART3->SR&=~USART_SR_RXNE; USART3->SR&=~USART_SR_RXNE;
ptr_fct_u3(); ptr_fct_u3();
} }

24
drivers/USART.h
View file

@ -1,13 +1,13 @@
#ifndef MYUSART_H #ifndef MYUSART_H
#define MYUSART_H #define MYUSART_H
#include <stm32f10x.h> #include <stm32f10x.h>
#define send_USART_init(USART) USART->CR1 |= USART_CR1_TE; // Envoi de la première trame d'attente #define send_USART_init(USART) USART->CR1 |= USART_CR1_TE; // Envoi de la première trame d'attente
#define read_USART_init(USART) USART->CR1 |= USART_CR1_RE; // En attente du premier bit de start #define read_USART_init(USART) USART->CR1 |= USART_CR1_RE; // En attente du premier bit de start
void My_USART_Init(USART_TypeDef *USART); void My_USART_Init(USART_TypeDef *USART);
void send_USART(USART_TypeDef *USART, char data); void send_USART(USART_TypeDef *USART, char data);
char read_USART(USART_TypeDef *USART); char read_USART(USART_TypeDef *USART);
void MyUSART_ActiveIT(USART_TypeDef *USART, int Prio, void (*IT_function) (void)); void MyUSART_ActiveIT(USART_TypeDef *USART, int Prio, void (*IT_function) (void));
#endif #endif

2
readme.txt
View file

@ -1 +1 @@
Hello hey