IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Arduino Discussion :

Projet tracker Solaire un seul axe Zénith, contrôler avec fichier de données csv


Sujet :

Arduino

Vue hybride

Message précédent Message précédent   Message suivant Message suivant
  1. #1
    Membre averti
    Homme Profil pro
    Agriculteur
    Inscrit en
    Juillet 2020
    Messages
    23
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 49
    Localisation : France, Loire Atlantique (Pays de la Loire)

    Informations professionnelles :
    Activité : Agriculteur

    Informations forums :
    Inscription : Juillet 2020
    Messages : 23
    Par défaut Projet tracker Solaire un seul axe Zénith, contrôler avec fichier de données csv
    Bonjour à tous,

    Comme le titre l'indique je commence un projet sur le montage d'un tracker solaire un seul axe, j'aimerais avoir votre opinion sur le choix du matériel et beaucoup d'aide sur la programmation.
    Le but étant d'avoir un panneau qui suit le soleil sur l'axe Zénith avec un moteur pas à pas, une tige fileté raccordé du moteur à la partie haute du panneau pour jouer sur l'inclinaison.
    Pour commencer j'ai pris un Arduino Uno, un shield L298P, un moteur pas à pas Nema 17, pour finir un data logger de chez Adafruit.
    L'idée de départ étais de mettre un fichier csv emprunté sur le site sunearthtools.com sur la carte sd, pour transformer les degrés élévation en nombres de pas.
    Pour le moment j'ai comme l'impression que le matériel choisi n'est pas compatible, l'heure à été réglé , le moteur tourne, mais pas de détection de la carte sd !!

    Merci beaucoup de partager de votre temps.

  2. #2
    Membre Expert
    Avatar de jpbbricole
    Homme Profil pro
    Retraité des réseaux informatiques
    Inscrit en
    Février 2013
    Messages
    1 017
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Suisse

    Informations professionnelles :
    Activité : Retraité des réseaux informatiques
    Secteur : High Tech - Électronique et micro-électronique

    Informations forums :
    Inscription : Février 2013
    Messages : 1 017
    Par défaut
    Bonsoir Forexgum

    As-tu essayé avec le data logger seul?
    Il faudrait voire s'il y a des pin communes entre les 2 shields?

    A+
    Cordialement
    jpbbricole

  3. #3
    Membre Expert
    Avatar de jpbbricole
    Homme Profil pro
    Retraité des réseaux informatiques
    Inscrit en
    Février 2013
    Messages
    1 017
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Suisse

    Informations professionnelles :
    Activité : Retraité des réseaux informatiques
    Secteur : High Tech - Électronique et micro-électronique

    Informations forums :
    Inscription : Février 2013
    Messages : 1 017
    Par défaut
    Bonjour Forexgum

    Pour ton information, voici les pin utilisées par les shields:

    Data logger
    13 SCK
    12 MISO
    11 MOSI
    10 SD CS
    A4 i2C SDA
    A5 i2C SCL

    Shield L298P
    13 Direction moteur B
    12 Direction moteur A
    11 PWM moteur B
    10 PWM moteur A
    4 Buzzer

    Donc aucune chance que les 2 fonctionnent convenablement ensemble.
    Si tu n'as qu'un moteur pas à pas, pourquoi ne pas prendre juste un driver du genre A4988 que tu pourras même installer sur le shield du data logger et utiliser des pin libres pour le commander?

    Cordialement
    jpbbricole

  4. #4
    Membre averti
    Homme Profil pro
    Agriculteur
    Inscrit en
    Juillet 2020
    Messages
    23
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 49
    Localisation : France, Loire Atlantique (Pays de la Loire)

    Informations professionnelles :
    Activité : Agriculteur

    Informations forums :
    Inscription : Juillet 2020
    Messages : 23
    Par défaut
    Bonjour jpbbricole,

    Merci beaucoup pour tes réponses très intéressantes,

    très bonne idée ! la commande pour un driver A4988 est parti

    pour la détection de ma carte sd même raccordé en direct su ma carte Arduino !? rien. Il me demande si ma carte est bien installée, je fait mes testes avec Cardinfo.

    J'ai lu que d'autres avait eu le même problème sans solution !

    J'attend mon driver pour la suite

    A très vite !

    Cordialement.

    Forexgum.

  5. #5
    Membre Expert
    Avatar de jpbbricole
    Homme Profil pro
    Retraité des réseaux informatiques
    Inscrit en
    Février 2013
    Messages
    1 017
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Suisse

    Informations professionnelles :
    Activité : Retraité des réseaux informatiques
    Secteur : High Tech - Électronique et micro-électronique

    Informations forums :
    Inscription : Février 2013
    Messages : 1 017
    Par défaut
    Citation Envoyé par Forexgum Voir le message
    pour la détection de ma carte sd même raccordé en direct su ma carte Arduino !? rien. Il me demande si ma carte est bien installée, je fait mes testes avec Cardinfo.

    J'ai lu que d'autres avait eu le même problème sans solution !
    Dans l'exemple Cardinfo as-tu bien fait attention à
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    // change this to match your SD shield or module;
    // Arduino Ethernet shield: pin 4
    // Adafruit SD shields and modules: pin 10
    // Sparkfun SD shield: pin 8
    // MKRZero SD: SDCARD_SS_PIN
    const int chipSelect = 8;
    donc
    const int chipSelect = 10;

    Cordialement
    jpbbricole

  6. #6
    Membre averti
    Homme Profil pro
    Agriculteur
    Inscrit en
    Juillet 2020
    Messages
    23
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 49
    Localisation : France, Loire Atlantique (Pays de la Loire)

    Informations professionnelles :
    Activité : Agriculteur

    Informations forums :
    Inscription : Juillet 2020
    Messages : 23
    Par défaut
    Champion du monde !!

    Problème résolu pour la carte sd, merci beaucoup jpbbricole

    Une erreur de pur débutant ! ce que je suis d'ailleurs

    Cdt.

    Forexgum.

  7. #7
    Expert confirmé

    Homme Profil pro
    mad scientist :)
    Inscrit en
    Septembre 2019
    Messages
    2 908
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Etats-Unis

    Informations professionnelles :
    Activité : mad scientist :)

    Informations forums :
    Inscription : Septembre 2019
    Messages : 2 908
    Par défaut
    Salut

    Si vous étes prêts à mouliner un peu les données (éventuellement dans le même programme Arduino) pour les stocker en format binaire dans un autre fichier alors ce serait possible avec un petit Arduino. Ce moulinage ne se ferait qu'une seule fois par an pour générer un fichier dans un format exploitable par un ordinateur de manière optimisée (ou si vous êtes capable de produire le même fichier pour 10 ans, une fois tous les 10 ans )

    En effet pour le moment les données sont formatées assez simplement: des chaines de caractères, séparées par des ';' et un retour à la ligne pour passer au jour suivant de l'année. L'en tête des colonnes se répète on a E (Elevation/zenith) puis A (azimuth) pour chaque heure et chaque ligne représente un jour de l'année 2020.

    Le gros souci pour savoir où se positionner dans le fichier pour lire en fonction d'un jour et d'une heure le E et le A est lié au fait que les données étant en ASCII, chaque champ a une longueur différente.. Impossible donc de calculer où aller dans le fichier sans tout lire à chaque fois... Sauter le bon nombre de lignes en fonction du jour de l'année, puis sauter le bon nombre de ';' pour trouver E et A... c'est faisable mais lourd et lent.

    Cela dit, en y regardant de plus près, en pratique chaque champ est un nombre à virgule avec 2 chiffres après la virgule - ça tient donc sans perte de précision sur un float (4 octets) et là on aurait une taille constante pour chaque donnée.

    L'approche consisterait à faire une lecture séquentielle des champs du fichier et générer un fichier élévations e.dat, et un fichier azimuths a.dat avec les données stockées en binaire.

    Par exemple le fichier Elévation par exemple comprendrait les octets suivant

    E(J000,H00) // l'élévation sur 4 octets du 1er Janvier à 0h (@octet #0)
    E(J000,H01) // l'élévation sur 4 octets du 1er Janvier à 1h (@octet #4)
    E(J000,H02) // l'élévation sur 4 octets du 1er Janvier à 2h (@octet #8)
    E(J000,H03) // l'élévation sur 4 octets du 1er Janvier à 3h (@octet #12)
    ...
    E(J000,H23) // l'élévation sur 4 octets du 1er Janvier à 23h (@octet 92)
    E(J001,H00) // l'élévation sur 4 octets du 2 Janvier à 0h (@octet #96)
    E(J001,H01) // l'élévation sur 4 octets du 2 Janvier à 1h (@octet #100)
    E(J001,H02) // l'élévation sur 4 octets du 2 Janvier à 2h (@octet #104)
    ...

    etc. On a donc les uns à la suite des autres les séquences de 4 octets qui représentent la valeur de l'élévation (Le fichier azimuth serait similaire mais avec les valeurs des azimuths bien sûr).

    Une fois que l'on a cela, une simple formule de math permet de trouver le bon octet à lire dans le fichier: si on veut aller chercher l'élévation du J-ème jour (0 à 365) de l'année à l'heure H (0 à 23)
    octetDeDépart(J, H) = (J*24+H)*sizeof(float) (même adresse dans le fichier pour l'Azimuth).

    par exemple pour le 2 Janvier 2020 à 2h du matin: J=1, H=2 ==> (1*24+2)*4 = 26*4 = 104 (on retrouve bien le 104 de ci dessus)

    D'un point de vue programmation il suffit donc d'ouvrir les 2 fichiers en lecture, de regarder la date et l'heure, et de faire un fseek() au bon octet puis de lire un float.

    Ensuite je rejoins @JP —*si vous n'avez pas encore choisi le matériel, partir sur un ESP est une bonne idée. ça pédale vite, ça comprend le bluetooth et le wifi et certaines versions embarquent un écran comme le dit @JP ... et pour ne rien gâter, ça ne coute pas vraiment plus cher qu'un Arduino.

    Seuls points éventuels de discussion par rapport aux suggestions de JP:

    - à mon avis Lora ne vous sera pas d'une grande utilité donc je prendrais un ESP32 TTGO juste avec un écran LCD

    Nom : TTGO.png
Affichages : 1307
Taille : 1,75 Mo

    - il y a un petit port pour lire les cartes TF (carte TransFlash qui est le terme générique pour carte SD (SanDisk)) donc pas la peine de lecteur de carte "SD", mais à mon avis ce n'est pas la peine: vous pouvez vous passer de la carte car il y a assez de mémoire flash dans l'ESP32 et on peut stocker le fichier en fatFS ou SPIFFS directement sur l'ESP depuis l'environnement Arduino.



    L'écriture de l'analyseur du fichier ASCII pour générer les 2 fichiers binaire n'est pas hors de portée et si vous voulez vous engager sur cette voie et que vous n'y arrivez pas je suis sûr que le forum saura vous aider.

    Bonne continuation

  8. #8
    Membre Expert
    Avatar de jpbbricole
    Homme Profil pro
    Retraité des réseaux informatiques
    Inscrit en
    Février 2013
    Messages
    1 017
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Suisse

    Informations professionnelles :
    Activité : Retraité des réseaux informatiques
    Secteur : High Tech - Électronique et micro-électronique

    Informations forums :
    Inscription : Février 2013
    Messages : 1 017
    Par défaut
    Bonjour Forexgum

    Peux-tu expliquer à l’ignare que je suis en cette matière, comment calculer la position du moteur pas à pas en fonction de l'élévation et de l’azimut.

    A plus
    Cordialement
    jpbbricole

  9. #9
    Expert confirmé

    Homme Profil pro
    mad scientist :)
    Inscrit en
    Septembre 2019
    Messages
    2 908
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Etats-Unis

    Informations professionnelles :
    Activité : mad scientist :)

    Informations forums :
    Inscription : Septembre 2019
    Messages : 2 908
    Par défaut
    Citation Envoyé par jpbbricole Voir le message
    Peux-tu expliquer à l’ignare que je suis en cette matière, comment calculer la position du moteur pas à pas en fonction de l'élévation et de l’azimut.
    Salut JP, je suppose qu'il a 2 moteurs qui pilotent 2 axes de son montage un (l'azimuth) qui oriente "à plat" vers le bon point cardinal par rapport au Nord et l'autre (l'élévation) qui fait s'incliner le montage par rapport à la verticale.

    ==> C'est comme pour régler une antenne parabolique et la faire pointer sur un satellite sauf que là il vise le soleil sans doute.



    EDIT: j'ai relu son post d'origine
    Le but étant d'avoir un panneau qui suit le soleil sur l'axe Zénith avec un moteur pas à pas, une tige fileté raccordé du moteur à la partie haute du panneau pour jouer sur l'inclinaison.
    donc un seul moteur

    cf aussi les montures azimutales ou équatoriales des télescopes

  10. #10
    Membre Expert
    Avatar de jpbbricole
    Homme Profil pro
    Retraité des réseaux informatiques
    Inscrit en
    Février 2013
    Messages
    1 017
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Suisse

    Informations professionnelles :
    Activité : Retraité des réseaux informatiques
    Secteur : High Tech - Électronique et micro-électronique

    Informations forums :
    Inscription : Février 2013
    Messages : 1 017
    Par défaut
    Salut Jay M
    Citation Envoyé par Jay M Voir le message
    Salut JP, je suppose qu'il a 2 moteurs qui pilotent 2 axes de son montage...
    Le titre dit Projet tracker Solaire un seul axe Zénith..., d'où ma question.

    Cordialement
    jpbbricole

  11. #11
    Expert confirmé

    Homme Profil pro
    mad scientist :)
    Inscrit en
    Septembre 2019
    Messages
    2 908
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Etats-Unis

    Informations professionnelles :
    Activité : mad scientist :)

    Informations forums :
    Inscription : Septembre 2019
    Messages : 2 908
    Par défaut
    si ça vous intéresse, je me suis amusé à lire le fichier pour générer comme suggéré ci dessous un fichier binaire pour les élévations et un autre pour les azimuths.

    Pour ce faire j'ai pris votre fichier zip ci dessous, ouvert dans un tableur et extrait uniquement les données brutes (le contenu de lignes et colonnes sans les en-tetes, donc sans la première colonne ni la première ligne). J'ai mis cela dans un nouveau fichier tableur.

    J'ai remplacé les '--' par un 'X' (avec un rechercher / remplacer) pour me simplifier la vie et j'ai exporté tout cela dans un fichier data.txt que j'ai mis sur une carte SD formatée pour lecture correcte sur Arduino (avec l'utilitaire d'exemple de formatage de la bibliothèque SDFat).

    J'ai connecté ensuite sur un Arduino Uno R3 un lecteur de carte SD en SPI.

    J'ai ensuite écrit un petit programme sur un Arduino Uno qui lit ce fichier texte et génère 2 fichiers binaires :
    - e.bin pour les élévations
    - a.bin pour les azimuths

    Voici le code de génération
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    #include <SPI.h>
    #include <SdFat.h>
    #define CS_PIN SS
     
    SdFat SD;
    const char* nomOrigine = "data.txt"; // E\tA\tE\tA...\tE\tA<cr><lf>
    File fichierOrigine;
     
    const char* nomElevation = "e.bin";
    File fichierElevation;
     
    const char* nomAzimuth = "a.bin";
    File fichierAzimuth;
     
    void erreurFatale(const __FlashStringHelper *message)
    {
      Serial.print(F("ERREUR: ")); Serial.println(message);
      while (true); // on meurt là
    }
     
     
    void setup() {
      unsigned long chrono = millis();
      Serial.begin(115200);
     
      // on configure le lecteur de carte SD
      if (!SD.begin(CS_PIN)) erreurFatale(F("lecteur SD introuvable"));
     
      if (SD.exists(nomElevation)) Serial.println(F("Le fichier binaire des élévations  existe, il sera supprimé."));
      fichierElevation = SD.open(nomElevation, O_WRITE | O_CREAT | O_TRUNC); // ouverture en écriture et détruire le fichier s'il existe
      if (!fichierElevation) erreurFatale(F("Création Fichier Elevation impossible"));
     
      if (SD.exists(nomAzimuth)) Serial.println(F("Le fichier binaire des azimuths  existe, il sera supprimé."));
      fichierAzimuth = SD.open(nomAzimuth, O_WRITE | O_CREAT | O_TRUNC); // ouverture en lecture seule
      if (!fichierAzimuth) erreurFatale(F("Création Fichier Azimuth impossible"));
     
     
      fichierOrigine = SD.open(nomOrigine, O_RDONLY); // ouverture en lecture seule
      if (!fichierOrigine) erreurFatale(F("Fichier Origine introuvable"));
     
      uint16_t numJour = 0;
      uint8_t numHeure = 0;
      float elevation, azimuth;
      uint16_t e = 0, a = 0;
     
      while (fichierOrigine.available() > 0) {
        char caractereSuivant = fichierOrigine.peek(); // on regarde l'octet à venir
        if (caractereSuivant == '\n') { // fin de ligne
          fichierOrigine.read(); // on saute la fin de ligne
          numJour++; // on passe au jour suivante
          numHeure = 0; // et l'heure revient à 0
          Serial.print(F("Lecture Jour ")); Serial.println(numJour);
        }
        else if ((caractereSuivant == '\r') || isspace(caractereSuivant)) fichierOrigine.read(); // on ignore le CR ou les espaces  else { // on lit une paire de E <TAB> A mais on peut avoir un X
        else { // on a une paire de E et A séparés par une tabulation
          if (caractereSuivant == 'X') {
            fichierOrigine.read(); // on saute le X
            elevation = NAN; // on met "Not a Number" dans la valeur binaire
          } else {
            elevation = fichierOrigine.parseFloat(); // sinon on lit le nombre
          }
     
          fichierOrigine.read(); // on saute la tabulation
     
          caractereSuivant = fichierOrigine.peek(); // on regarde l'octet à venir
          if (caractereSuivant == 'X') {
            fichierOrigine.read(); // on saute le X
            azimuth = NAN; // on met "Not a Number" dans la valeur binaire
          } else {
            azimuth = fichierOrigine.parseFloat(); // on lit le nombre
          }
     
          if (fichierElevation.write(&elevation, sizeof(float)) != sizeof(float)) erreurFatale(F("Erreur écriture Elevation"));
          e++;
     
          if (fichierAzimuth.write(&azimuth, sizeof(float)) != sizeof(float)) erreurFatale(F("Erreur écriture Azimuth"));
          a++;
     
          //      Serial.write('J'); Serial.print(numJour);
          //      Serial.print(F("\tH")); Serial.print(numHeure);
          //      Serial.write('\t');
          //      if (isnan(elevation)) Serial.write('X');
          //      else Serial.print(elevation, 2);
          //      Serial.write('\t');
          //      if (isnan(azimuth)) Serial.write('X');
          //      else Serial.print(azimuth, 2);
          //      Serial.println();
     
          numHeure++;
        }
      }
     
      fichierOrigine.close();
      fichierElevation.close();
      fichierAzimuth.close();
      Serial.print(F("FIN DE GENERATION DES FICHIERS BINAIRES EN "));
      Serial.print((millis() - chrono) / 1000.0) ;
      Serial.println(F("s"));
     
      Serial.print(F("-> écriture de ")); Serial.print(e); Serial.println(F(" élévations"));
      Serial.print(F("-> écriture de ")); Serial.print(a); Serial.println(F(" azimuths"));
    }
     
     
     
    void loop() {}
    (ce code n'est pas robuste en ce sens qu'il attend un fichier bien formé - mais c'est le cas de l'export)

    C'est lent bien entendu... près de deux minutes plus tard, la console série ouverte à 115200 bauds affichera la lecture des jours et un résumé.

    1
    2
    3
    ...
    363
    364
    365
    FIN DE GENERATION DES FICHIERS BINAIRES EN 117.76s
    -> écriture de 8784 élévations
    -> écriture de 8784 azimuths


    On avait 366 jours x 24 heures ==> 366 x 24 = 8784 on a donc bien lu le bon nombre de données.

    on a maintenant sur la carte SD deux fichiers, a.bin et e.bin correspondant aux 8784 valeurs. Si je les copie sur mon Mac et que je regarde leur taille, je vois 35136 ce qui correspond bien à 8784 valeurs x 4 octets par enregistrement

    (attention si vous relancez l'arduino, ça efface les 2 fichiers binaires et ça les génère à nouveau).

    -----------------

    Une fois que l'on a ces 2 fichiers binaires, on peut relire le contenu assez simplement. Voici un petit code qui vous permet de relire toutes les élévations, puis après tous les azimuths:

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    #include <SPI.h>
    #include <SdFat.h>
    #define CS_PIN SS
     
    SdFat SD;
     
    const char* nomElevation = "e.bin";
    File fichierElevation;
     
    const char* nomAzimuth = "a.bin";
    File fichierAzimuth;
     
    void erreurFatale(const __FlashStringHelper *message)
    {
      Serial.print(F("ERREUR: ")); Serial.println(message);
      while (true); // on meurt là
    }
     
     
    void setup() {
      Serial.begin(115200);
     
      // on configure le lecteur de carte SD
      if (!SD.begin(CS_PIN)) erreurFatale(F("lecteur SD introuvable"));
     
      uint16_t numJour;
      uint8_t numHeure;
      float elevation, azimuth;
      uint16_t e = 0, a = 0;
     
      unsigned long chrono = millis();
      // relecture des élévations
     
      fichierElevation = SD.open(nomElevation, O_RDONLY); // ouverture en lecture seule
      if (!fichierElevation) erreurFatale(F("Fichier Elevation introuvable"));
     
      numJour = 0;
      numHeure = 0;
      Serial.write('J'); Serial.print(numJour); Serial.write('\t');
      while (fichierElevation.available() > 0) {
        if (fichierElevation.read(&elevation, sizeof(float)) == sizeof(float)) {
          e++;
          if (isnan(elevation)) Serial.write('X');
          else Serial.print(elevation, 2);
          if (++numHeure >= 24) {
            numHeure = 0;
            numJour++;
            if ((fichierElevation.available() > 0)) {
              Serial.print(F("\nJ"));
              Serial.print(numJour);
              Serial.write('\t');
            }
          } else Serial.write(' ');
        }
      }
      fichierElevation.close();
      Serial.println(F("\nFIN DE FICHIER ELEVATION\n\n"));
     
     
      // relecture des azimuths
     
      fichierAzimuth = SD.open(nomAzimuth, O_RDONLY); // ouverture en lecture seule
      if (!fichierAzimuth) erreurFatale(F("Fichier Elevation introuvable"));
     
      numJour = 0;
      numHeure = 0;
      Serial.write('J'); Serial.print(numJour); Serial.write('\t');
      while (fichierAzimuth.available() > 0) {
        if (fichierAzimuth.read(&azimuth, sizeof(float)) == sizeof(float)) {
          a++;
          if (isnan(azimuth)) Serial.write('X');
          else Serial.print(azimuth, 2);
          if (++numHeure >= 24) {
            numHeure = 0;
            numJour++;
            if ((fichierAzimuth.available() > 0)) {
              Serial.print(F("\nJ"));
              Serial.print(numJour);
              Serial.write('\t');
            }
          } else Serial.write(' ');
        }
      }
      fichierAzimuth.close();
      Serial.println(F("\nFIN DE FICHIER AZIMUTH"));
     
      Serial.print(F("FIN DE LECTURE DES FICHIERS BINAIRES EN "));
      Serial.print((millis() - chrono) / 1000.0) ;
      Serial.println(F("s"));
      Serial.print(F("-> Lecture de ")); Serial.print(e); Serial.println(F(" élévations"));
      Serial.print(F("-> Lecture de ")); Serial.print(a); Serial.println(F(" azimuths"));
    }
     
    void loop() {}
    Si vous le lancez la console vous dira

    J0 X X X X X X X X X -0.06 7.58 13.66 17.75 19.45 18.60 15.28 9.82 2.65 X X X X X X
    J1 X X X X X X X X X -0.06 7.59 13.70 17.81 19.53 18.70 15.40 9.94 2.78 X X X X X X
    J2 X X X X X X X X X -0.06 7.62 13.74 17.87 19.62 18.81 15.52 10.08 2.92 X X X X X X
    J3 X X X X X X X X X -0.04 7.65 13.79 17.95 19.72 18.92 15.65 10.21 3.07 X X X X X X
    J4 X X X X X X X X X -0.02 7.69 13.85 18.03 19.82 19.04 15.78 10.36 3.21 X X X X X X
    ...
    J362 X X X X X X X X X -0.02 7.57 13.59 17.61 19.24 18.33 14.95 9.45 2.26 X X X X X X
    J363 X X X X X X X X X -0.04 7.56 13.60 17.64 19.30 18.40 15.05 9.56 2.38 X X X X X X
    J364 X X X X X X X X X -0.06 7.56 13.63 17.68 19.36 18.49 15.15 9.67 2.50 X X X X X X
    J365 X X X X X X X X X -0.06 7.57 13.65 17.73 19.44 18.58 15.25 9.79 2.62 X X X X X X
    FIN DE FICHIER ELEVATION


    J0 X X X X X X X X X 125.30 136.81 149.42 163.11 177.56 192.13 206.13 219.11 230.98 X X X X X X
    J1 X X X X X X X X X 125.16 136.68 149.28 162.98 177.44 192.03 206.05 219.06 230.94 X X X X X X
    J2 X X X X X X X X X 125.02 136.54 149.14 162.85 177.32 191.93 205.98 219.00 230.91 X X X X X X
    J3 X X X X X X X X X 124.88 136.40 149.00 162.72 177.21 191.83 205.91 218.96 230.88 X X X X X X
    ...
    J363 X X X X X X X X X 125.59 137.11 149.71 163.40 177.82 192.36 206.32 219.26 231.09 X X X X X X
    J364 X X X X X X X X X 125.46 136.98 149.58 163.27 177.70 192.25 206.23 219.19 231.04 X X X X X X
    J365 X X X X X X X X X 125.33 136.85 149.45 163.14 177.59 192.15 206.15 219.13 230.99 X X X X X X
    FIN DE FICHIER AZIMUTH
    FIN DE LECTURE DES FICHIERS BINAIRES EN 6.59s
    -> Lecture de 8784 élévations
    -> Lecture de 8784 azimuths


    On a bien réussi à relire toutes nos 8784 données binaires et si vous comparer l'affichage avec ce qu'il y a dans votre fichier d'origine, vous verrez que ça correspond.

    Vous voyez que la lecture des l'ensemble des 17 568 données et leur impression se fait en mois de 7 secondes, c'est déjà plus rapide donc que la génération.

    ---------------------------------

    Enfin, il faut connecter une RTC et voir comment on s'en sert pour aller chercher les deux valeurs.

    J'ai donc rajouté une RTC DS3231 (qui est bcp plus stable dans le temps (dérive peu dans l'année) que la DS1307 comme l'a dit @JPBricole) et j'ai utilisé la bibliothèque Adafruit RTCLib.

    Voici un code d'exemple
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    #include <RTClib.h>
    RTC_DS3231 rtc;
    const char* nomDesJours[] = {"Dimanche", "Lundi", "Mardi", "Mercredi", "Jeudi", "Vendredi", "Samedi"};
    
    DateTime premierJanvier(2020, 1, 1, 0, 0, 0); // point de référence 1er Janvier à 0h00
    
    #include <SPI.h>
    #include <SdFat.h>
    #define CS_PIN SS
    
    SdFat SD;
    
    
    
    const char* nomElevation = "e.bin";
    File fichierElevation;
    
    const char* nomAzimuth = "a.bin";
    File fichierAzimuth;
    
    void erreurFatale(const __FlashStringHelper *message)
    {
      Serial.print(F("ERREUR: ")); Serial.println(message);
      while (true); // on meurt là
    }
    
    void afficherSurDeuxChiffres(uint16_t nombre)
    {
      if (nombre < 10) Serial.write('0');
      Serial.print(nombre);
    }
    
    float lireElevation(int16_t jour, uint8_t heure)
    {
      float e;
      uint32_t premierOctet = (24UL * jour + heure) * sizeof(float);
    
      fichierElevation = SD.open(nomElevation, O_RDONLY); // ouverture en lecture seule
      if (!fichierElevation) erreurFatale(F("Fichier Elevation introuvable"));
      fichierElevation.seekSet(premierOctet);
      if (fichierElevation.read(&e, sizeof(float)) != sizeof(float)) e = NAN;
      fichierElevation.close();
      return e;
    }
    
    float lireAzimuth(int16_t jour, uint8_t heure)
    {
      float a;
      uint32_t premierOctet = (24UL * jour + heure) * sizeof(float);
    
      fichierAzimuth = SD.open(nomAzimuth, O_RDONLY); // ouverture en lecture seule
      if (!fichierAzimuth) erreurFatale(F("Fichier Azimuth introuvable"));
      fichierAzimuth.seekSet(premierOctet);
      if (fichierAzimuth.read(&a, sizeof(float)) != sizeof(float)) a = NAN;
      fichierAzimuth.close();
      return a;
    }
    
    void setup() {
      Serial.begin(115200);
    
      if (! rtc.begin()) erreurFatale(F("Horloge RTC introuvable"));
      rtc.adjust(DateTime(F(__DATE__), F(__TIME__))); // à faire UNE FOIS si votre RTC n'est pas à jour pour la mettre à l'heure sinon commenter.
      // rtc.adjust(DateTime(2020, 1, 2, 10, 30, 0)); // ou pour essayer une date précise, ici le 2 janvier à 10h30
      // rtc.adjust(DateTime(2020, 1, 3, 21, 45, 0)); // ou pour essayer une date précise, ici le 3 janvier à 21h45
    
      if (!SD.begin(CS_PIN)) erreurFatale(F("lecteur SD introuvable"));
    
      // on vérifie que les fichiers sont là
      fichierElevation = SD.open(nomElevation, O_RDONLY); // ouverture en lecture seule
      if (!fichierElevation) erreurFatale(F("Fichier Elevation introuvable"));
      fichierElevation.close();
    
      fichierAzimuth = SD.open(nomAzimuth, O_RDONLY); // ouverture en lecture seule
      if (!fichierAzimuth) erreurFatale(F("Fichier Elevation introuvable"));
      fichierAzimuth.close();
    }
    
    void loop()
    {
      int16_t numJour;
      uint8_t numHeure;
      float elevation, azimuth;
    
      DateTime maintenant = rtc.now(); // l'heure actuelle
      TimeSpan depuisLePremierJanvier = maintenant - premierJanvier; // la différence de temps entre maintenant et le 1/1/2020
      numJour = depuisLePremierJanvier.days();
      numHeure = maintenant.hour();
    
      Serial.print(nomDesJours[maintenant.dayOfTheWeek()]);
      Serial.write(' ');
      Serial.print(maintenant.day());
      Serial.write('/');
      Serial.print(maintenant.month());
      Serial.write('/');
      Serial.print(maintenant.year());
      Serial.write('\t');
      Serial.print(maintenant.hour());
      Serial.write(':');
      afficherSurDeuxChiffres(maintenant.minute());
      Serial.write(':');
      afficherSurDeuxChiffres(maintenant.second());
      Serial.write('\t');
    
    
      Serial.print(F("Jour N° ")); Serial.print(numJour);
      Serial.write(' ');
      Serial.print(F("Heure N° ")); Serial.print(numHeure);
      Serial.print(F(""));
    
      uint32_t chrono = millis();
      elevation = lireElevation(numJour, numHeure);
      azimuth = lireAzimuth(numJour, numHeure);
    
      Serial.print(F("-> E:"));
      if (isnan(elevation)) Serial.print(F("--")); else Serial.print(elevation, 2);
      Serial.print(F(" A="));
      if (isnan(azimuth)) Serial.print(F("--")); else Serial.print(azimuth, 2);
      Serial.print(F(" ("));
      Serial.print((millis() - chrono)) ;
      Serial.println(F("ms)"));
    
      delay(5000);
    }
    Si vous le lancez la console vous dira
    Mardi 14/7/2020 18:26:53 Jour N° 195 Heure N° 18 -> E:27.80 A=272.21 (6ms)
    Mardi 14/7/2020 18:26:58 Jour N° 195 Heure N° 18 -> E:27.80 A=272.21 (7ms)
    Mardi 14/7/2020 18:27:03 Jour N° 195 Heure N° 18 -> E:27.80 A=272.21 (6ms)
    ...


    ça lit l'heure sur l'horloge puis ça fait un petit calcul pour savoir combien de jours se sont écoulés depuis le 1er Janvier 2020 et avec l'heure courante j'appelle la fonction lireElevation() ou lireAzimuth() qui vont chercher l'info dans le fichier binaire.

    par défaut je conserve les fichiers fermés, ce qui ralentit sans doute un peu la lecture, mais on voit qu'on arrive à lire les 2 valeurs en 6ms.

    Si je ne me suis pas trompé, le 14 Juillet 2020 à 18h l'élévation vaut 27.80 et l'azimuth serait de 272.21 (ça a l'air de correspondre dans votre fichier d'origine)


    Comme le dit le compilateur, sur un UNO:
    - Le croquis utilise 15768 octets (48%) de l'espace de stockage de programmes. Le maximum est de 32256 octets.
    - Les variables globales utilisent 1201 octets (58%) de mémoire dynamique, ce qui laisse 847 octets pour les variables locales. Le maximum est de 2048 octets.


    Comme l'a dit @JPBricole, suivant la complexité du reste de votre code de pilotage des moteurs et gestion de l'interface utilisateur, peut-être que ça ne rentrera pas. Vous pourriez partir sur une MEGA, mais l'ESP32 permet de vous simplifier la vie quand même et faire sans doute un truc bien plus sympa.



    ---------------------------------

    Je vous mets en PJ le fichier data + les 2 fichiers binaire dans un zip.
    Fichiers attachés Fichiers attachés

  12. #12
    Expert confirmé

    Homme Profil pro
    mad scientist :)
    Inscrit en
    Septembre 2019
    Messages
    2 908
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Etats-Unis

    Informations professionnelles :
    Activité : mad scientist :)

    Informations forums :
    Inscription : Septembre 2019
    Messages : 2 908
    Par défaut
    Oui CF mon édit de mon post

    Sinon j’ai fait le test aur UNO - en bidouillant le fichier c’est jouable mais tout va dépendre ensuite de la complexité du reste du code

  13. #13
    Membre Expert
    Avatar de jpbbricole
    Homme Profil pro
    Retraité des réseaux informatiques
    Inscrit en
    Février 2013
    Messages
    1 017
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Suisse

    Informations professionnelles :
    Activité : Retraité des réseaux informatiques
    Secteur : High Tech - Électronique et micro-électronique

    Informations forums :
    Inscription : Février 2013
    Messages : 1 017
    Par défaut
    Salut Jay M
    Citation Envoyé par Jay M Voir le message
    Oui CF mon édit de mon post

    Sinon j’ai fait le test aur UNO - en bidouillant le fichier c’est jouable mais tout va dépendre ensuite de la complexité du reste du code
    C'est programmer avec ce risque permanent d'avoir un programme qui fait des choses "bizzares" d'ès que l'on rajoute des fonctions. Il ne faut pas oublier que l'on est dans un forum "Arduino" ou, souvent les gens se déclarent débutants, alors faisons simple. C'est d'ailleurs ce que je pense faire vu mon ignorance des arcanes du C.
    C'est pour ça que j'ai tout de suite changé de machine pour travailler "confortable" et avec beaucoup d'intéressantes possibilités comme le Bluetooth, le wifi etc.
    Pour ce qui est des ESP32 avec lecteur SD, j'en ai aussi, je trouve ça un peu "fragile" et, surtout, si l'on veut mettre le tout en boîtier, c'e n'est pas évident de rendre ce lecteur accessible.

    Cordialement
    jpbbricole

  14. #14
    Expert confirmé

    Homme Profil pro
    mad scientist :)
    Inscrit en
    Septembre 2019
    Messages
    2 908
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Etats-Unis

    Informations professionnelles :
    Activité : mad scientist :)

    Informations forums :
    Inscription : Septembre 2019
    Messages : 2 908
    Par défaut
    C'est programmer avec ce risque permanent d'avoir un programme qui fait des choses "bizzares" d'ès que l'on rajoute des fonctions.
    Si on pense comme cela on ne fait plus rien avec un UNO ou MEGA

    Au prix où ça coûte, c'est vrai que ce serait bête de se priver de l'ESP et toutes ses possibilités, mais il faut quand même garder à l'esprit qu'il y a bcp plus de bonnes bibliothèques et tutos (et bénévoles sur les forums) pour UNO ou MEGA que pour ESP32.

    Un autre inconvénient des ESP32 c'est que l'OS est complexe (multi-core), les pins utilisables très dépendantes du fournisseur de la carte et il y en a toute une fournée !
    Nom : ESP32.png
Affichages : 687
Taille : 344,3 Ko

    Enfin vous avez une gestion du 3.3V pas toujours évidente en fonction des capteurs utilisés (bcp sont en 5V), et la carte est plus sensibles aux perturbations (I2C pas stable par exemple sans rajouter des pull-ups).


    La façon dont je regarde cela c'est qu'il y a deux approches: la première qui est d'essayer d'estimer ce qui est nécessaire et voir si ça rentre, ou se dire que qui peut le plus peut le moins et sur-dimensionner la plateforme.

    Là le code proposé ci dessous sur UNO prend la moitié de la mémoire en gros. Je me suis amusé à rajouter une instance de moteur avec AccelStepper. ça emmène à 58% de l'espace de stockage de programmes et 63% de mémoire SRAM.

    => On a encore 753 octets pour les variables locales ce qui reste confortable mais faut pas faire n'importe quoi.

    En passant sur une MEGA on occuperait 7% de l'espace de stockage de programmes et 15% de mémoire dynamique. Donc là on serait large sans doute.

    Sur un ESP32 on aurait 18% de l'espace de stockage de programmes (faut embarquer l'OS) et les variables globales utilisent 5% de mémoire dynamique.

    Si c'était moi et que le besoin se limite à rajouter le pilotage du moteur en fonction de l'heure et qu'il n'y a pas besoin d'un écran, clavier, WiFi, bluetooth etc alors je resterai sur équivalent Arduino Uno (en prenant un Nano ou Pro-Mini) pour limiter la place physique occupée - et je pense que ça rentrera.

    Si ça ne rentre pas ou que les besoins sont plus riches, alors je prendrais effectivement un ESP (8286 ou 32 suivant le besoin).

    s'il y a besoin d'un joli boitier, d'un écran, du WiFi, de boutons, d'une batterie etc alors là sans hésitation je partirai sur un M5Stack et donc un ESP32 ==> C'est un peu plus cher mais bien intégré et donc ça simplifie la vie.

  15. #15
    Membre averti
    Homme Profil pro
    Agriculteur
    Inscrit en
    Juillet 2020
    Messages
    23
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 49
    Localisation : France, Loire Atlantique (Pays de la Loire)

    Informations professionnelles :
    Activité : Agriculteur

    Informations forums :
    Inscription : Juillet 2020
    Messages : 23
    Par défaut
    Bonsoir à vous et tout d'abord j'aimerais vous remercier pour vôtre implication dans mon projet.

    Désolé pour ne pas avoir répondu avant, beaucoup de boulot en ce moment, mais je suis toujours là

    Je vient de lire tout vos messages, je pense que je vais les relire pour tout comprendre,

    A ce que j'ai compris au première abord, je crois que vous voulez que je vous explique comment je vois le montage du moteur pas à pas,



    Nom : cadre_3.jpg
Affichages : 643
Taille : 126,3 Ko

    Cet un exemple pris sur internet.


    Un moteur pas à pas, une tige fileté, un panneau miroir,

    Point 0 : panneau position vertical,

    On ne s'occupe pas de l'azimut, il faut faire comme si le soleil ne fait que monter et descendre,

    Les rayons solaires qui arrive sur le panneau miroir doit ce refléter à l'horizontal en permanence.

    Le but de cette installation est de suivre le soleil même si des nuages sont présent.

    Je ne sais pas si mes explications vont suffire!

    Je retourne jeter un œil aux messages précèdent essayer de tout comprendre.

    Encore MERCI

    Cdt.

    Forexgum.

  16. #16
    Membre averti
    Homme Profil pro
    Agriculteur
    Inscrit en
    Juillet 2020
    Messages
    23
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 49
    Localisation : France, Loire Atlantique (Pays de la Loire)

    Informations professionnelles :
    Activité : Agriculteur

    Informations forums :
    Inscription : Juillet 2020
    Messages : 23
    Par défaut
    Re Bonsoir,

    Après avoir relu les postes précédent,

    Il n'y as en effet qu'un seul moteur qui vas incliner le panneau juste une programmation du zenith, pas de pivotement !

    Je n'ai pas besoin de wifi, bluetooth ou de boitier,

    J'ai commander le matériel pour mettre en place les idées de Jay M. Je le reçois pour samedi normalement.

    Encore merci à vous deux .

    Cdt.

    Forexgum.

  17. #17
    Expert confirmé

    Homme Profil pro
    mad scientist :)
    Inscrit en
    Septembre 2019
    Messages
    2 908
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Etats-Unis

    Informations professionnelles :
    Activité : mad scientist :)

    Informations forums :
    Inscription : Septembre 2019
    Messages : 2 908
    Par défaut
    JP vous êtes trop modeste !

    En gros la fonction ci dessous retourne l’élévation - c’est à dire la valeur que vous alliez lire dans le fichier texte pour un jour et une heure donnée.

    Le reste de votre code reste globalement valide - il faudrait éventuellement adapter la fonction Linéaire qui calcule le nombre de pas mais en première interprétation on n’est pas vraiment loin. Avec un capteur d’angle c’est sans doute plus simple il suffit de bouger dans le bon sens jusqu’à ce que le capteur corresponde à l’élévation

  18. #18
    Expert confirmé

    Homme Profil pro
    mad scientist :)
    Inscrit en
    Septembre 2019
    Messages
    2 908
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Etats-Unis

    Informations professionnelles :
    Activité : mad scientist :)

    Informations forums :
    Inscription : Septembre 2019
    Messages : 2 908
    Par défaut
    Ok - ca sert à renvoyer de la luminosité dans une pièce ?

    S’il n’y a pas besoin d’interface utilisateur et juste bouger un moteur en fonction de l’heure ça peut tenir sur un uno (ou similaire) avec la modif dès fichiers ci dessous.

    Jeu suppose que vous l’orientez à la main vers le sud et que ce n’est pas à 2 ou 3 degrés près et donc l’azimut ne sert pas vraiment ?

  19. #19
    Membre averti
    Homme Profil pro
    Agriculteur
    Inscrit en
    Juillet 2020
    Messages
    23
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 49
    Localisation : France, Loire Atlantique (Pays de la Loire)

    Informations professionnelles :
    Activité : Agriculteur

    Informations forums :
    Inscription : Juillet 2020
    Messages : 23
    Par défaut
    Bonjour,

    Tout à fait c'est plus un réflecteur de lumière, avec un seul axe pour éclairé une baie vitré,

    La base ne tournera pas, pour balayer la pièce toute la journée des rayons solaire,

    Cdt.

    Forexgum.

  20. #20
    Expert confirmé

    Homme Profil pro
    mad scientist :)
    Inscrit en
    Septembre 2019
    Messages
    2 908
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Etats-Unis

    Informations professionnelles :
    Activité : mad scientist :)

    Informations forums :
    Inscription : Septembre 2019
    Messages : 2 908
    Par défaut
    Citation Envoyé par Forexgum Voir le message
    Bonjour,
    Tout à fait c'est plus un réflecteur de lumière, avec un seul axe pour éclairer une baie vitré,
    La base ne tournera pas, pour balayer la pièce toute la journée des rayons solaire,
    Ok donc vous n'avez besoin que du fichier élévation sur votre Arduino. On peut donc améliorer l'approche:

    si vous regardez les élévations, il n'y a pas le soleil avant 6h du matin ni après 20h
    si vous regardez les variations journalières pour une heure donnée elles varient entre ±1° sur quelques jours (5 à 10 jours)

    -> vous pourriez regrouper par semaine les valeurs entre 6h et 20h. on aurait alors 52 ou 53 groupes de 7 jours (à la louche) et 15 valeurs par jour, soit 37*15 = 795 valeurs

    j'imagine que votre système ne sera pas précis au centième de degrés, si vous êtes calé au degrés près ce serait déjà bien et donc au lieu de stocker les élévations en float (4 octets) on pourrait les stocker sous forme d'entiers (2 octets) et si on regarde les valeurs en jeu, la plus petite est -0,79 et le max 65,89.

    --> si on arrondit en entier, ça fait entre -1 et 66 ce qui tient sans problème sur un octet signé (int8_t ou signed char)

    vous avez donc en gros 795 octets à stocker de manière permanente sur votre Arduino => au lieu d'utiliser la carte SD vous pourriez utiliser directement l'EEPROM qui est capable de stocker 1024 octets donc on a de la marge (vous pourriez passer en groupes de 6 jours soit 366/6 = 61 groupes de 15 valeurs = 915 et ça rentrerait encore).

    ça vous permettrait d'éliminer le lecteur de carte SD (qui est un composant fragile puisque vous avez des contacts sur une pièce mobile et que si votre système est à l'extérieur il sera soumis aux variation de température, condensation etc).

    Ensuite pour améliorer le système, si on regarde d'une heure à l'autre dans la journée, on a une assez grosse variation d'angle qui peut monter à plus de 10°. Il serait donc bon de calculer l'angle non pas toutes les heures mais par exemple toutes les 5 ou 10 minutes et faire une interpolation linéaire entre l'angle de l'heure courante et l'heure suivante pour suivre le soleil plus finement (vous pouvez utiliser la fonction map() pour cela). Comme c'est du calcul, assez simple, ça ne mangera pas bcp de mémoire.

    Votre système électronique pourrait donc être juste un Arduino Nano, un contrôleur de moteur pas à pas, une RTC 3231 et un boîtier qui rend tout cela bien étanche.

    (il existe des solutions toutes montées - cf la société espaciel par exemple)

Discussions similaires

  1. Changer [FontSize] d'un seul axe
    Par Newenda dans le forum MATLAB
    Réponses: 3
    Dernier message: 11/08/2009, 09h27
  2. Réponses: 1
    Dernier message: 07/07/2009, 11h09
  3. regrouper deux projet JSF en un seul !
    Par King_T dans le forum NetBeans
    Réponses: 0
    Dernier message: 19/06/2009, 19h33
  4. afficher des courbes sur un seul "axes" d'une interface utilisateur
    Par Angel30 dans le forum Interfaces Graphiques
    Réponses: 4
    Dernier message: 06/06/2009, 23h49
  5. Réponses: 2
    Dernier message: 08/06/2008, 20h01

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo