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

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

    Informations professionnelles :
    Activité : Agriculteur

    Informations forums :
    Inscription : Juillet 2020
    Messages : 23
    Points : 6
    Points
    6
    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 émérite
    Avatar de jpbbricole
    Homme Profil pro
    Retraité des réseaux informatiques
    Inscrit en
    Février 2013
    Messages
    1 012
    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 012
    Points : 2 341
    Points
    2 341
    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
    L'expérience est la seule chose qu'il ne faut acheter que d'occasion!

  3. #3
    Membre émérite
    Avatar de jpbbricole
    Homme Profil pro
    Retraité des réseaux informatiques
    Inscrit en
    Février 2013
    Messages
    1 012
    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 012
    Points : 2 341
    Points
    2 341
    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
    L'expérience est la seule chose qu'il ne faut acheter que d'occasion!

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

    Informations professionnelles :
    Activité : Agriculteur

    Informations forums :
    Inscription : Juillet 2020
    Messages : 23
    Points : 6
    Points
    6
    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 émérite
    Avatar de jpbbricole
    Homme Profil pro
    Retraité des réseaux informatiques
    Inscrit en
    Février 2013
    Messages
    1 012
    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 012
    Points : 2 341
    Points
    2 341
    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
    L'expérience est la seule chose qu'il ne faut acheter que d'occasion!

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

    Informations professionnelles :
    Activité : Agriculteur

    Informations forums :
    Inscription : Juillet 2020
    Messages : 23
    Points : 6
    Points
    6
    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
    Membre émérite
    Avatar de jpbbricole
    Homme Profil pro
    Retraité des réseaux informatiques
    Inscrit en
    Février 2013
    Messages
    1 012
    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 012
    Points : 2 341
    Points
    2 341
    Par défaut
    Bonjour Forexgum

    Super
    Citation Envoyé par Forexgum Voir le message
    Une erreur de pur débutant ! ce que je suis d'ailleurs
    Pour te rassurer, on est tous passés par là
    Pour la suite, quand tu auras ton driver, la bibliothèque AccelStepper te rendra service.

    Tracker Solaire un seul axe Zénith, pour moi, c'est du chinois, mais je suis sure que ce sera passionnant!

    A+
    Cordialement
    jpbbricole
    L'expérience est la seule chose qu'il ne faut acheter que d'occasion!

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

    Informations professionnelles :
    Activité : Agriculteur

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

    De retour aujourd'hui avec tout le matériel :

    une carte Arduino UNO
    un shield SD+RTC data logger de chez Adafruit
    un driver A4988
    un moteur Nema 17

    Nom : A4988-Arduino-stepper-motor-wiring-schematic-diagram-pinout.jpg
Affichages : 1078
Taille : 137,0 Ko

    Le montage sans le shield Adafruit qui est en réalité inséré au-dessus de la carte Arduino.

    Tous les éléments ont été testés un par un, tout est ok.

    Maintenant place à la programmation !

    Le rôle du code à écrire est d'aller chercher dans la carte SD une info pour la transformer en nombre de tours sur le moteur.

    Un début de code :

    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
     
    #include <SPI.h>
    #include <SD.h>
    #define dirPin 2
    #define stepPin 3
    #define stepsPerRevolution 200
     
    RTC_DS1307 RTC;
    File fichier;
    const byte SDCARD_CS_PIN = 10;
     
     
    int i=0;
    int a=0;
    double pos=1378;
    double agzen=0;
     
    char *p1;
    char *p2;
    double nbp2;
     
    static char buf[40]
    double Zenith[49]
     
     
    void setup() {
     
      pinMode(stepPin, OUTPUT);
      pinMode(dirPin, OUTPUT);
      pinMode(10, OUTPUT);
      digitalWrite(10, HIGH);
     
      Serial.begin(9600);
     
      if (!SD.begin(10))
      {
        Serial.println(F("FAIL"));
        for(;;);
      }
       Serial.println(F("OK"));
       if(SD.exists("solar.csv"))
       {
        Serial.println(F("Fichier OK));
       }
       else
       {
        Serial.println(F("Fichier introuvable"));
       }
     
       File fichier = SD.open("solar.csv", FILE_READ);
       if(!fichier)
       {
        Serial.println(F("Impossible d'ouvrir le fichier"));
        for(;;);
       }
     
       fichier.seek(pos);
     
       while(fichier.available())
       {
        for(i=0;fichier.available() && i< sizeof buf-1;i++)
        {
          buf[i]= fichier.read();
          if(buf[i]==';')
          break;
        }
        buf[i] = 0;
     
            p1=strtok(buf,";");
     
            if((cpt%2)==0)
            {
              nbp2=atof(p1);
              zenith=nbp2;
              Serial.print(F("zenith="));
              Serial.println(zenith);
              flag_zen=1;
            }
     
            delay(1);
       }
     
    }
     
    void loop(){
     
    if ((zenith[a]>0)
            {
              agzen=(zenith[a]/2);
              steppin.write(agzen);
              Serial.print(F("zenith="));
              Serial.println(agzen);
              delay(50);
            }
     
            else
            {
              steppin.write(0);
            }
     
            delay(500);
     
            a++;
     
    trzen=(  (  (58.5-sqrt(3400-3000 * cos(((90-zenith/2)* M_PI )/180) )  )/0.125 )*200 ) - trzen_preced;
    trzen_preced=trzen ;
    Serial.print(F("trzen="));
    Serial.println(trzen);
     
    digitalWrite(2,HIGH);
    digitalWrite(3,HIGH);
    monMoteur.step(trzen);
    digitalWrite(2,LOW);
    digitalWrite(3,LOW);
    }

    j'ai t'enter de prendre plusieurs bouts de code et les coller ensemble, bien sur rien ne se passe.
    A votre avis je devrais repartir de zéro où l'on peut faire quelque chose avec ce code ?

    Cdt.

    Forexgum.

  9. #9
    Membre émérite
    Avatar de jpbbricole
    Homme Profil pro
    Retraité des réseaux informatiques
    Inscrit en
    Février 2013
    Messages
    1 012
    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 012
    Points : 2 341
    Points
    2 341
    Par défaut
    Bonjour Forexgum

    C'est parti!!!
    Citation Envoyé par Forexgum Voir le message
    j'ai t'enter de prendre plusieurs bouts de code et les coller ensemble, bien sur rien ne se passe.
    A votre avis je devrais repartir de zéro où l'on peut faire quelque chose avec ce code ?
    Pour moi, c'est mieux de faire du neuf, ton programme, tel qu'il est, va vite être difficile à faire évoluer.
    On peut le scinder en plusieurs parties, lecture SD, moteur pas à pas etc.
    Mais surtout, expliques les phases de son exécution.
    Dernière chose, mets un exemple de fichier CSV sur le forum, ça peut aider

    Cordialement
    jpbbricole
    L'expérience est la seule chose qu'il ne faut acheter que d'occasion!

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

    Informations professionnelles :
    Activité : Agriculteur

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

    Je n'arrive pas à mettre un exemple de fichier csv sur le forum,

    je met une capture d'écran du fichier.







    Nom : Zenith.jpg
Affichages : 1022
Taille : 509,1 Ko








    Dans la première colonne les dates,
    La première ligne les heures avec soi un E (Elevation/zenith) ou un A (azimuth),







    Nom : Zenith.jpg
Affichages : 1044
Taille : 881,7 Ko




    J'aimerais récupérer la date et l'heure interne du RTC de mon shield, pour comparer et me positionner dans mon fichier au bon endroit,
    je ne trouve pas grand-chose sur le net pour le moment sur le sujet,

    Je ne vois pas du tout comment mis prendre

    Cdt.

    Forexgum.

  11. #11
    Membre émérite
    Avatar de jpbbricole
    Homme Profil pro
    Retraité des réseaux informatiques
    Inscrit en
    Février 2013
    Messages
    1 012
    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 012
    Points : 2 341
    Points
    2 341
    Par défaut
    Bonsoir Forexgum

    Le mieux c'est de "zipper" fichier et d'utiliser l'icône trombone pour l'insérer.
    Je vais faire le montage, pour pouvoir t'aider au mieux.

    Cordialement
    jpbbricole
    L'expérience est la seule chose qu'il ne faut acheter que d'occasion!

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

    Informations professionnelles :
    Activité : Agriculteur

    Informations forums :
    Inscription : Juillet 2020
    Messages : 23
    Points : 6
    Points
    6

  13. #13
    Membre émérite
    Avatar de jpbbricole
    Homme Profil pro
    Retraité des réseaux informatiques
    Inscrit en
    Février 2013
    Messages
    1 012
    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 012
    Points : 2 341
    Points
    2 341
    Par défaut
    Bonjour Forexgum

    Alors, voilà, j'ai étudié un peu un programme pour reprendre les données de ton fichier CSV, avec un Arduio et une carte data logger similaire à la tienne, avec une RTC DS1307.
    Ma conclusion (d'amateur) est que, du fait de la grandeur des données à traiter, le ménage UNO SD RTC amène le UNO à sa limite, je n'ai pas pu lire de façon fiable les données sur la carte SD, problème de quantité de mémoire? Et tu serait assez vite limité pour de futurs développements.

    J'ai repris le tout mais avec un ESP32, une RTC DS3231 (plus précise que la DS1307) et un lecteur de cartes SD et ça rend la chose beaucoup plus aisée.
    Les avantages de l'ESP32 sont la puissance, le modèle proposé a un affichage OLED, le Bluetooth, le Wifi et LORA.
    Pour ton application, s'il y a du wifi dans le coin, c'est de disposer d'une horloge Internet.
    Avec le bluetooth, la possibilité de commender ton système depuis un smartphone etc...
    Cet ESP32 se programme aussi facilement qu'un Arduino.
    Ce module ESP32 gère également la charge de son accu, s'il y en a un.

    Maintenant, question importante, quelles sont tes connaissances "en Arduimo", en électronique?

    A+
    Cordialement
    jpbbricole
    L'expérience est la seule chose qu'il ne faut acheter que d'occasion!

  14. #14
    Expert confirmé

    Homme Profil pro
    mad scientist :)
    Inscrit en
    Septembre 2019
    Messages
    2 711
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : mad scientist :)

    Informations forums :
    Inscription : Septembre 2019
    Messages : 2 711
    Points : 5 390
    Points
    5 390
    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 : 1017
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

  15. #15
    Membre émérite
    Avatar de jpbbricole
    Homme Profil pro
    Retraité des réseaux informatiques
    Inscrit en
    Février 2013
    Messages
    1 012
    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 012
    Points : 2 341
    Points
    2 341
    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
    L'expérience est la seule chose qu'il ne faut acheter que d'occasion!

  16. #16
    Expert confirmé

    Homme Profil pro
    mad scientist :)
    Inscrit en
    Septembre 2019
    Messages
    2 711
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : mad scientist :)

    Informations forums :
    Inscription : Septembre 2019
    Messages : 2 711
    Points : 5 390
    Points
    5 390
    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

  17. #17
    Expert confirmé

    Homme Profil pro
    mad scientist :)
    Inscrit en
    Septembre 2019
    Messages
    2 711
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : mad scientist :)

    Informations forums :
    Inscription : Septembre 2019
    Messages : 2 711
    Points : 5 390
    Points
    5 390
    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

  18. #18
    Membre émérite
    Avatar de jpbbricole
    Homme Profil pro
    Retraité des réseaux informatiques
    Inscrit en
    Février 2013
    Messages
    1 012
    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 012
    Points : 2 341
    Points
    2 341
    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
    L'expérience est la seule chose qu'il ne faut acheter que d'occasion!

  19. #19
    Expert confirmé

    Homme Profil pro
    mad scientist :)
    Inscrit en
    Septembre 2019
    Messages
    2 711
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : mad scientist :)

    Informations forums :
    Inscription : Septembre 2019
    Messages : 2 711
    Points : 5 390
    Points
    5 390
    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

  20. #20
    Membre émérite
    Avatar de jpbbricole
    Homme Profil pro
    Retraité des réseaux informatiques
    Inscrit en
    Février 2013
    Messages
    1 012
    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 012
    Points : 2 341
    Points
    2 341
    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
    L'expérience est la seule chose qu'il ne faut acheter que d'occasion!

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