Ajout du README.md

README.md

@@ -1 +1,44 @@
 # Projet-Voilier-3
+Dans le cadre de la matière "Microcontrôleur", nous réalisons un projet sur un voilier.
+Pour cela, nous avons travaillé sur une carte nucléo avec un micro STM32F103RB. 
+
+Durant ce projet, nous avons réalisé des fichiers génériques qui sont des drivers.
+Chacun d'eux a été codé et testé avec différentes solutions (simulation + tests réels).
+Chaque périphérique a été exploité à l'aide de drivers.
+
+
+Les différentes fonctionnalités validés du projet répondant au cahier des charges sont :
+- Le réglage des voiles en fonction de l'angle de la girouette positionnée au bout du mat du bateau.
+- La gestion de de la vitesse de rotation du plateau, en fonction de la consigne donnée par la télécommande.
+- La gestion de la communication avec la télécommande au travers d'un module XBEE
+
+Fonctionnalité manquante :
+- Réaction de repliment des voiles en cas de fort ballotage (Driver IMU opérationnel)
+
+Liste des drivers et de leur fonctionnalités.
+Driver GPIO :
+- Configurer la valeur des GPIO
+- Set/Reset des GPIO configurés en sortie
+- Lire la valeur des entrées
+
+Driver ADC :
+- Initialisation
+- Lancement de lecture & de la conversion
+- Lecture
+
+Driver Timer :
+- Initialisation générique des Timers et passage de l'adresse d'une fonction appelé lors de l'interruption.
+- Start & Stop du timer.
+- Génération de PWM
+- Lecture d'un encoder incrémental
+
+Driver UART :
+- Initialisation
+- Envoi d'un octet
+- Envoi d'une chaine de caractères (X octets qui composent les X caractères de la chaine)
+- Reception d'un octet
+
+Driver IMU :
+- Envoi de 2 octets successif (adresse registre + valeur) par SPI
+- Initialisation du module par communication SPI (configuration de registres du module)
+- Lecture de valeurs successives (x,y,z), puis leur stockage dans un tableau.

driver/Driver_IMU.c

@@ -0,0 +1,62 @@
+#include "MySpi.h"
+
+const char POWER_CTL = 0x2D; // Power Control Register
+const char BW_RATE = 0x2C;
+const char DATA_FORMAT = 0x31;
+
+/*fonction écriture registre IMU*/
+void driver_IMU_write_register(char registerAddress, char value)
+{
+    // On s'assure que le Chip Select est bien au niveau bas
+    MySPI_Clear_NSS();
+    // Envoi de l'adresse du registre par SPI
+    MySPI_Send(registerAddress);
+    // Envoi de la valeur désirée du registre par SPI
+    MySPI_Send(value);
+    // On active le chip select
+    MySPI_Set_NSS();
+}
+
+/* Fonction d'initialisation*/
+void driver_IMU_init(void)
+{
+    /* FSCK = 281kHz, Repos SCK = '1', Front actif = up
+                     Gestion /CS logicielle à part, configure les 4 IO
+                     - SCK, MOSI : Out Alt push pull
+                     - MISO : floating input
+                     - /NSS (/CS) : Out push pull */
+    MySPI_Init(SPI1);
+    // Paramètrage du registre POWER_CTL
+    driver_IMU_write_register(POWER_CTL, 0x08);
+    // Paramètrage du registe BW_RATE
+    driver_IMU_write_register(BW_RATE, 0x0A);
+    // Paramètrage du registre DATA_FORMAT
+    driver_IMU_write_register(BW_RATE, 0x08); // Full resolution, et alignement à droite
+}
+
+/* Fonction de lecture des données*/
+/*
+@param *values : Les valeurs x, y, z sont chacune stockée sur 2 octets dans le tableau values
+    x = values[1]<<8 & value[0];
+    y = values[3]<<8 & value[2];
+    z = values[5]<<8 & value[4];
+@param numBytes : Le nombre de registre à lire à partir de registerAddress
+@param registerAddress : Adresse du premier registre à lire*/
+void driver_IMU_read(char registerAddress, int numBytes, unsigned char *values)
+{
+    int i;
+    // Pour effectuer une lecture des registre, on doit mettre les bits R/W et MB à 1
+    char trame = registerAddress | 0x80;
+    trame = trame | 0x40;
+    // On active le chip select (niveau bas)
+    MySPI_Clear_NSS();
+    // Envoie de la config
+    MySPI_Send(trame);
+    // On effectue la lecture
+    for (i = 0; i < numBytes; i++)
+    {
+        values[i] = MySPI_Read();
+    }
+    // On met le Chip Select au niveau haut
+    MySPI_Set_NSS();
+}

driver/Driver_IMU.h

@@ -0,0 +1,26 @@
+#ifndef IMU_H_
+#define IMU_H_
+
+#include "stm32f10x.h"
+
+/**
+*************************************************************************************************
+* @brief Fonction d'initialisation de l'IMU
+* @param -> none
+* @Note -> Fonction a appelé avant l'utilisation du périphérique
+*************************************************************************************************
+*/
+void driver_IMU_init(void);
+
+/**
+*************************************************************************************************
+* @brief Fonction de lecture des données de l'IMU
+* @param -> char registerAddress : adresse du registre
+* 			 -> int numBytes : nombre de bytes à recevoir
+*				 -> unsigned char * values : tableau où les valeurs seront stockés
+* @Note ->
+*************************************************************************************************
+*/
+void driver_IMU_read(char registerAddress, int numBytes, unsigned char *values);
+
+#endif

driver/Driver_UART.c

@@ -1,13 +1,19 @@
 #include "Driver_UART.h"
 
-void MyUART_Init(MyUART_Struct_TypeDef *UART) {
+void MyUART_Init(MyUART_Struct_TypeDef *UART)
+{
   // Active l'horloge du périphérique UART
 
-  if (UART->UART == USART1) {
+  if (UART->UART == USART1)
+  {
     RCC->APB2ENR |= RCC_APB2ENR_USART1EN;
-  } else if (UART->UART == USART2) {
+  }
+  else if (UART->UART == USART2)
+  {
     RCC->APB1ENR |= RCC_APB1ENR_USART2EN;
-  } else if (UART->UART == USART3) {
+  }
+  else if (UART->UART == USART3)
+  {
     RCC->APB1ENR |= RCC_APB1ENR_USART3EN;
   }
 
@@ -15,41 +21,45 @@ void MyUART_Init(MyUART_Struct_TypeDef *UART) {
   UART->UART->CR1 |= USART_CR1_UE;
 
   // Configure la vitesse de transmission en utilisant la valeur de BRR
-  UART->UART->BRR = 7500/2; // Note : Certains UARTs sont connectés au 72Mhz/2 
+  UART->UART->BRR = 7500 / 2; // Note : Certains UARTs sont connectés au 72Mhz/2
 
   // Configure le format des données transmises/reçues : 8 bits de données, 1 bit de stop, pas de parité
   UART->UART->CR1 &= ~(USART_CR1_M | USART_CR1_PS);
 
-
   UART->UART->CR1 |= USART_CR1_TE | USART_CR1_RE;
 
   UART->UART->CR2 &= ~(0x11 << 12);
 
   USART3->CR1 |= USART_CR1_RXNEIE | USART_CR1_TXEIE; // Active les interruptions de l'UART
 
-  __enable_irq();// Active les interruptions globales
+  __enable_irq(); // Active les interruptions globales
-
 }
 
-void MyUART_SendByte(MyUART_Struct_TypeDef *UART, uint8_t data) {
+void MyUART_SendByte(MyUART_Struct_TypeDef *UART, uint8_t data)
+{
   // Envoyer la donnée
   UART->UART->DR = data;
 
   // Attendre que la transmission soit terminée
-  while ((UART->UART->SR & USART_SR_TC) == 0);
+  while ((UART->UART->SR & USART_SR_TC) == 0)
+    ;
 }
 
-void MyUART_SendString(MyUART_Struct_TypeDef *UART, const char *str) {
+void MyUART_SendString(MyUART_Struct_TypeDef *UART, const char *str)
+{
   // Envoyer chaque caractère de la chaîne
-  while (*str != '\0') {
+  while (*str != '\0')
+  {
     MyUART_SendByte(UART, *str);
     str++;
   }
 }
 
-uint8_t MyUART_ReceiveByte(MyUART_Struct_TypeDef *UART) {
+uint8_t MyUART_ReceiveByte(MyUART_Struct_TypeDef *UART)
+{
   // Attendre que le registre de données soit rempli avec une nouvelle donnée
-  while (!(UART->UART->SR & USART_SR_RXNE));
+  while (!(UART->UART->SR & USART_SR_RXNE))
+    ;
 
   // Lire la donnée reçue
   uint8_t data = (uint8_t)(UART->UART->DR & 0xFF);
@@ -61,13 +71,13 @@ uint8_t MyUART_ReceiveByte(MyUART_Struct_TypeDef *UART) {
   return data;
 }
 
-void USART3_IRQHandler(void) {
+void USART3_IRQHandler(void)
-  if (USART3->SR & USART_SR_RXNE) {
+{
-    
+  if (USART3->SR & USART_SR_RXNE)
+  {
   }
 
-  if (USART3->SR & USART_SR_TXE) {
+  if (USART3->SR & USART_SR_TXE)
-   
+  {
   }
 }
-

projet-voilier/Driver_ADC.c

@@ -1,40 +0,0 @@
-#include "Driver_ADC.h"
-#include "stm32f10x.h"
-#include "stdio.h"
-
-void init_adc1 (void)
-{
-	//Activation de l'external trig
-	ADC1->CR2 |= ADC_CR2_EXTTRIG;
-	//Activation SWSTART
-	ADC1->CR2 |= ADC_CR2_EXTSEL;
-	//On règle la fréquence à 12Mhz
-	RCC->CFGR |= RCC_CFGR_ADCPRE_DIV6;
-	//Activation de l'ADC
-	ADC1->CR2 |= ADC_CR2_ADON;
-	//Fixe le nb de conversion, ici 1
-	ADC1->SQR1 &= ADC_SQR1_L;
-	//Numéro de voie à convertir
-	ADC1->SQR3 |= 1;
-	//Lancement de la calibration
-	ADC1->CR2 |= ADC_CR2_CAL;
-	//Attente de la fin de la calibration
-	while((ADC1->CR2 & ADC_CR2_CAL));
-	//Activation de l'intéruption sur le flag EOC
-	ADC1->CR1 |= ADC_CR1_EOCIE;
-}
-
-void launch_read_adc1 (void)
-{
-	//Lancement de la conversion
-	ADC1->CR2 |= ADC_CR2_SWSTART;
-}
-
-int read_adc1 (void)
-{
-	
-	//On abaisse le flag pour la prochaine lecture
-	ADC1->SR &= ~ADC_SR_EOC;
-	//Retour de la conversion
-	return ADC1->DR &~ ((0x0F) << 12);
-}