TONER KEBAB WIKI

Outils pour utilisateurs

Outils du site

Piste: • manipuler-un-tableau-en-c
wiki:tutoriels:arduino:manipuler-un-tableau-en-c

Différences

Ci-dessous, les différences entre deux révisions de la page.

Lien vers cette vue comparative

Les deux révisions précédentes Révision précédente
Prochaine révision 		Révision précédente
wiki:tutoriels:arduino:manipuler-un-tableau-en-c [2021/06/01 17:05]
damien.muti [Passage de tableaux à une fonction] 		wiki:tutoriels:arduino:manipuler-un-tableau-en-c [2024/06/06 09:34] (Version actuelle)
damien.muti [Version 3]
Ligne 60: Ligne 60:
     int tableau[4] = {0}; // Toutes les cases du tableau seront initialisées à 0     int tableau[4] = {0}; // Toutes les cases du tableau seront initialisées à 0
 </code> </code>
 +
 +==== Allocation dynamique d'un tableau ====
 +Toutes les explications sur l'allocation dynamique d'un tableau sont sur le lien suivant : [[https://openclassrooms.com/fr/courses/19980-apprenez-a-programmer-en-c/16595-lallocation-dynamique|Openclassrooms]].
 +
 +Il faut utiliser la fonction: 
 +  * //malloc(sizeof(type))//
 +
 +En résumé :
 +
 +__**Déclaration du tableau (entiers)**__:
 +
 +<code>
 +int* tableau = NULL; // Ce pointeur va servir de tableau après l'appel du malloc
 +</code>
 +
 +__**Création du tableau (entiers)**__:
 +En supposant que //tailleDuTableau// ait été défini :
 +<code>
 +tableau = = malloc(tailleDuTableau * sizeof(int)); // On alloue de la mémoire pour le tableau; 
 +</code>
 +
 +__**Initialisation du tableau (entiers)**__:
 +<code>
 +for (i = 0 ; i < nombreDAmis ; i++){
 +   tableau[i] = 0;
 +}
 +</code>
 +
 +Le programme total est le suivant :
 +
 +<code>
 +int main(int argc, char *argv[])
 +{
 +    int nombreDAmis = 0, i = 0;
 +    int* ageAmis = NULL; // Ce pointeur va servir de tableau après l'appel du malloc
 +
 +    // On demande le nombre d'amis à l'utilisateur
 +    printf("Combien d'amis avez-vous ? ");
 +    scanf("%d", &nombreDAmis);
 +
 +    if (nombreDAmis > 0) // Il faut qu'il ait au moins un ami (je le plains un peu sinon :p)
 +    {
 +        ageAmis = malloc(nombreDAmis * sizeof(int)); // On alloue de la mémoire pour le tableau
 +        if (ageAmis == NULL) // On vérifie si l'allocation a marché ou non
 +        {
 +            exit(0); // On arrête tout
 +        }
 +
 +        // On demande l'âge des amis un à un
 +        for (i = 0 ; i < nombreDAmis ; i++)
 +        {
 +            printf("Quel age a l'ami numero %d ? ", i + 1);
 +            scanf("%d", &ageAmis[i]);
 +        }
 +
 +        // On affiche les âges stockés un à un
 +        printf("\n\nVos amis ont les ages suivants :\n");
 +        for (i = 0 ; i < nombreDAmis ; i++)
 +        {
 +            printf("%d ans\n", ageAmis[i]);
 +        }
 +
 +        // On libère la mémoire allouée avec malloc, on n'en a plus besoin
 +        free(ageAmis);
 +    }
 +
 +    return 0;
 +}
 +</code>
 +
  
 ==== Passage de tableaux à une fonction ==== ==== Passage de tableaux à une fonction ====
  
-Pour envoyer en paramètre d'entrée un  tableau en C, il faut envoyer l'adresse du tableau (&tableau) et sa talle (sizeof(tableau)). +Pour envoyer en paramètre d'entrée un  tableau en C, il faut envoyer l'adresse du tableau (&tableau) et sa taille (sizeof(tableau)). 
  
 La fonction doit être capable d'initialiser un tableau de n'importe quelle taille. Or, dans cette fonction, on ne connaît, a priori, pas la taille du tableau en paramètre d'entrée. C'est pour cela qu'il faut envoyer en plus une variable qu'on appelle par "//exempletailleTableau//". La fonction doit être capable d'initialiser un tableau de n'importe quelle taille. Or, dans cette fonction, on ne connaît, a priori, pas la taille du tableau en paramètre d'entrée. C'est pour cela qu'il faut envoyer en plus une variable qu'on appelle par "//exempletailleTableau//".
Ligne 98: Ligne 168:
 void affiche(int tableau[], int tailleTableau) void affiche(int tableau[], int tailleTableau)
 </code> </code>
 +
 +===== Enregistrement de données et calcul de moyenne =====
 +
 +La mesure d'une valeur issue d'un capteur peut être affectée par du bruit, ce qui entraîne des variations significatives autour d'une valeur moyenne. Pour atténuer cet effet, il est utile de conserver les N dernières mesures et d'en calculer la moyenne.
 +
 +
 +Lorsqu'une valeur est mesurée par un capteur, il est nécessaire de mettre à jour le tableau de mesures en décalant les valeurs des indices 0 à N-1 vers les indices 1 à N, afin de libérer la case à l'indice 0. La nouvelle valeur est ensuite enregistrée dans cette case d’indice 0.
 +
 +==== Version 1 ====
 +
 +<code>
 +float *tab_mesures;
 +#define NB_MOYENNE 20
 +float moy = 1.0;
 +
 +void mettreAJourTableau(float nouvelleValeur) {
 +  // Décaler les valeurs vers la gauche
 +  for (int i = 0; i < NB_MOYENNE - 1; i++) {
 +    tab_mesures[i] = tab_mesures[i + 1];
 +  }
 +  // Ajouter la nouvelle valeur à la fin du tableau
 +  tab_mesures[NB_MOYENNE - 1] = nouvelleValeur;
 +}
 +
 +float calculerMoyenne() {
 +  float somme = 0;
 +  for (int i = 0; i < NB_MOYENNE; i++) {
 +    somme += tab_mesures[i];
 +  }
 +  float moyenne = somme / NB_MOYENNE;
 +  return moyenne;
 +}
 +
 +
 +void setup(){
 +  // création du tableau de mesures des volumes du micros (volts)
 +  tab_mesures = (float *)malloc(sizeof(float) * NB_MOYENNE);
 +  // initialisation du tableau de moyenne
 +  for (int i = 0; i < NB_MOYENNE; i++) {
 +    tab_mesures[i] = 1.5;
 +  }
 +}
 +
 +void loop(){
 +  int mesure = analogRead(A0);
 +  mettreAJourTableau(mesure);
 +  float moy = calculerMoyenne();
 +  Serial.println(moy);
 +
 +}
 +
 +</code>
 +
 +
 +==== Version 2 ====
 +
 +<code>
 +const int N_moy = 10;  // Taille du tableau
 +int valeurs[N_moy];    // Tableau pour stocker les valeurs
 +
 +void setup() {
 +  Serial.begin(9600);
 +  for (int i = 0; i < N_moy; i++) {
 +    valeurs[i] = 0;  // Initialisation du tableau à 0
 +  }
 +}
 +
 +void loop() {
 +  int valeur_lue = lireCapteur();  // Lire la valeur du capteur digital
 +  mettreAJourTableau(valeur_lue, valeurs);  // Mettre à jour le tableau avec la nouvelle valeur
 +  float moyenne = calculerMoyenne(valeurs);  // Calculer la moyenne des valeurs
 +  Serial.print("Moyenne: ");
 +  Serial.println(moyenne);
 +  
 +  delay(1000);  // Attendre 1 seconde avant la prochaine mesure
 +}
 +
 +int lireCapteur() {
 +  // Remplacez ceci par le code pour lire votre capteur digital
 +  // Exemple : int valeur = digitalRead(pinDuCapteur);
 +  int valeur = random(0, 1023);  // Générer une valeur aléatoire pour l'exemple
 +  return valeur;
 +}
 +
 +void mettreAJourTableau(int nouvelleValeur, int tableau[]) {
 +  // Décaler les valeurs vers la gauche
 +  for (int i = 0; i < N_moy - 1; i++) {
 +    tableau[i] = tableau[i + 1];
 +  }
 +  // Ajouter la nouvelle valeur à la fin du tableau
 +  tableau[N_moy - 1] = nouvelleValeur;
 +}
 +
 +float calculerMoyenne(int tableau[]) {
 +  int somme = 0;
 +  for (int i = 0; i < N_moy; i++) {
 +    somme += tableau[i];
 +  }
 +  return (float)somme / N_moy;
 +}
 +
 +
 +</code>
 +
 +==== Version 3 ====
 +
 +<code>
 +const int N_moy = 10;  // Taille du tableau
 +int valeurs[N_moy];    // Tableau pour stocker les valeurs
 +
 +void setup() {
 +  Serial.begin(9600);
 +  for (int i = 0; i < N_moy; i++) {
 +    valeurs[i] = 0;  // Initialisation du tableau à 0
 +  }
 +}
 +
 +void loop() {
 +  int valeur_lue = lireCapteur();  // Lire la valeur du capteur digital
 +  mettreAJourTableau(valeur_lue, valeurs);  // Mettre à jour le tableau avec la nouvelle valeur
 +  float moyenne = calculerMoyenne(valeurs);  // Calculer la moyenne des valeurs
 +  Serial.print("Moyenne: ");
 +  Serial.println(moyenne);
 +  
 +  delay(1000);  // Attendre 1 seconde avant la prochaine mesure
 +}
 +
 +int lireCapteur() {
 +  // Remplacez ceci par le code pour lire votre capteur digital
 +  // Exemple : int valeur = digitalRead(pinDuCapteur);
 +  int valeur = random(0, 1023);  // Générer une valeur aléatoire pour l'exemple
 +  return valeur;
 +}
 +
 +void mettreAJourTableau(int nouvelleValeur, int *tableau) {
 +  // Décaler les valeurs vers la gauche
 +  for (int i = 0; i < N_moy - 1; i++) {
 +    tableau[i] = tableau[i + 1];
 +  }
 +  // Ajouter la nouvelle valeur à la fin du tableau
 +  tableau[N_moy - 1] = nouvelleValeur;
 +}
 +
 +float calculerMoyenne(int *tableau) {
 +  int somme = 0;
 +  for (int i = 0; i < N_moy; i++) {
 +    somme += tableau[i];
 +  }
 +  return (float)somme / N_moy;
 +}
 +
 +
 +</code>
 +
 +==== Détails Techniques ====
 +
 +**Tableaux et Pointeurs en C/C++** : Lorsque vous passez un tableau à une fonction, vous passez en fait un pointeur vers le premier élément du tableau. Ainsi, int tableau[] et int *tableau sont équivalents dans le contexte des paramètres de fonction. Les deux notations permettent à la fonction de modifier les éléments du tableau original.
 +
 +
 +**Accès aux éléments** : Vous pouvez accéder aux éléments du tableau en utilisant l'indexation habituelle (tableau[i]) dans les deux cas.
 +
 +
 +En résumé, vous pouvez utiliser l'une ou l'autre notation, celle avec le pointeur (int *tableau) est souvent préférée pour des raisons de clarté dans le contexte de la programmation en C/C++, bien que les deux soient correctes.
wiki/tutoriels/arduino/manipuler-un-tableau-en-c.1622559947.txt.gz · Dernière modification: 2021/06/01 17:05 de damien.muti

Outils de la page

Sauf mention contraire, le contenu de ce wiki est placé sous les termes de la licence suivante : CC Attribution-Noncommercial 4.0 International
CC Attribution-Noncommercial 4.0 International Donate Powered by PHP Valid HTML5 Valid CSS Driven by DokuWiki