Go Down

Topic: Limite mémoire Mega2560 (Read 596 times) previous topic - next topic

Geocramtou

Bonjour,
     Je suis dans  le flou sur les limite de la mémoire vive de l'arduino Mega2560.  :smiley-fat:
En gros j'ai compris qu'elle est de 8Kbytes donc 8 Ko?

     Mon problème est que je veux faire le plus de mesure possible dans un espace de temps donné.
Avec de valeur qui varie de - 3600 à 3600 durant environs 2 minutes.
Et les garder en mémoire afin de les exploiter plus tard.

Mon calcul:  :smiley-sweat:


8kByte de RAM
8ko - 1ko pour les autres fonctions = 7ko
2mn=120s
1 variable de type int = 4 ko
7000/(120*4) ~= 10 mesures par seconde

Je suis conscient de ne pas être forcement dans le vrai, alors j'espère que quelqu'un pourra m'éclairer!


fdufnews



1 variable de type int = 4 ko

une variable de type int = 2 octets.

haifger




1 variable de type int = 4 ko

une variable de type int = 2 octets.

Oui... mais en fait ça doit n'être qu'une erreur de frappe, parce que son calcul est correct :)

@ld_remi : il te suffit donc de remplacer 4 par 2 pour obtenir ta réponse. Un int « normal » sur 2 octets permet de stocker des valeurs entre -32768 et 32767, donc ça suffit pour ce que tu veux faire.

skywodd

Bonjour,

1) Pourquoi tout stocker en RAM ? Quel est le but final ?
2) 1Ko pour le reste du prog ... ok, mais sans code c'est difficile à dire si tu vises juste ou non.

Sans plus d'information te répondre tient de l'impossible.
Des news, des tutos et plein de bonnes choses sur http://skyduino.wordpress.com !

Christian_R

Tu peux enregistrer les mesures sur une carte SD  si la mémoire de la carte est trop petite.
Christian

Geocramtou

Merci pour vos réponses
Du coup je reprend:

8kByte de RAM
8ko - 1ko pour les autres fonctions = 7ko
2mn=120s
1 variable de type int = 2o
2 variables à mesurer
7000/(120*2*2) ~= 10 mesures par seconde

Mais lorsque que je compile, le programme prend environs 100 valeurs puis, renvois "start" (depuis ma boucle setup)

Voila mon code pour les plus courageux!

Code: [Select]
#include "encoder.h"

int val=0;
int ref=0;
int encoder0PinA = 3;
int encoder0PinB = 4;
int encoder0Pos = 0;
int Bp_rec = 5;
unsigned long t_rec =0;
unsigned long t =0;
unsigned long t_mes=0;


Codeur Codeur(encoder0PinA,encoder0PinB,encoder0Pos);
Tab Tab;


void setup()
{
   attachInterrupt(encoder0Pos, blink, RISING); //detection d'un tour de codeur
   attachInterrupt(Bp_rec, blink_rec , RISING); // detection bp enregistrement
   Serial.begin (57600);
   Serial.println ("start");
   
}

void loop()
{
   val= Codeur.pos(); // assignement de la valeur renvoyé par le codeur
  if ((val<=ref-100)||(val>=ref+100))
     {
       //Serial.println (val);
        ref=val;
      }
  if (Tab.Flag_rec==true&&(millis()-t_mes)>200)
  {
     
       //Serial.println (val);
    Tab.Mes(val);
    t_mes=millis();
 
   }       
}

void blink()
{
   Codeur.CodPos=0;
   //Serial.println("flag");
}

void blink_rec()
{
  if(millis()-t_rec>500)
  {
   Tab.Flag_rec = !Tab.Flag_rec;
   Serial.println(Tab.Flag_rec);
   t_rec=millis();
  }

}


Code: [Select]
//#include "arduino.h"
#include "encoder.h"

Codeur::Codeur(int pinA,int pinB,int pin0)
{
  _pinA=pinA;
  _pinB=pinB;
  _pin0=pin0;
  CodPos=0;
 
  pinMode (_pinA,INPUT);
  pinMode (_pinB,INPUT);
   
  int encoder0PinALast = LOW;
  int n = LOW;
}

int Codeur::pos()
{

  n = digitalRead(_pinA);
   if ((encoder0PinALast == LOW) && (n == HIGH))
   {
     if (digitalRead(_pinB) == LOW)
       {
       CodPos--;
       }
     else
       {
       CodPos++;
       }
   
     }
   encoder0PinALast = n;
   return CodPos;
}

Tab::Tab()
{
       Flag_rec=false;
       temps=0;
       i =0;
}

void Tab::Mes(int data)
{
 
/* if (Flag_rec==false)
   {
   i=0;
   }*/
  if (i<=50)
  {
  mes[i][0]=data;

  i=i++;
  }
  else
  {
    for(i=0;i<50;i++)
    {
     Serial.println(i);
     Serial.println(mes[i][0]);
    }
    i=0;
  }
}


Code: [Select]
#ifndef encoder_h
#define encoder_h
#include "arduino.h"
       
    class Codeur
    {
      public:
        Codeur(int pinA,int pinB,int pin0);
        int pos(); // renvoie la position du codeur
        int CodPos;
       
      private:
        int _pinA;
        int _pinB;
        int _pin0;

        int encoder0PinALast;
        int n ;
       

    };

     class Tab
     {
       public:
       Tab();
       void Mes(int data);//enregistre les mesures
       int mes[][2]; // tableau de mesures
       boolean Flag_rec;
       
       private:
       unsigned long temps;
       unsigned int i;
     };
     
    #endif



Geocramtou

Le setup a l'air de se réenclencher dès que je passe par l'interruption "blink"

cbrandt

dans la class TAB, le tableau mes[][2] n'est pas alloué puisque pas de taille max définie

deux solutions:
- allocation statique: mes[1000][2] pour 1000 mesures par ex.
- allocation dynamique: utiliser malloc (plus compliqué)

Geocramtou

Merci cbrand,
Ca fonctionne deja mieux.
j'ai fait une allocation statique.

Mais maintenant impossible de ranger les valeur dans le tableau...
Les valeur affichée sur le moniteur son les bonnes pour "val"
Code: [Select]
val= Codeur.pos();
    if ((val<=ref-100)||(val>=ref+100))
       {
        ref=val;
        Serial.println (val);       
       }

mais

Code: [Select]
if ((millis()-t_ref>200)&&(j<100)&&(Flag_rec=true))
      {
         Tab_Mes[j][1]=val;
         j++;
         t_ref=millis();
      }
   
   if(millis()-t_rec>3000&&digitalRead(30)==HIGH)
      {
         Flag_rec = !Flag_rec;
         Serial.println("Flag_rec");
         t_rec=millis();
         j=0;
     }


ca ne fonctionne pas du tout.

J'ai du mal suivre le cour sur les tableaux....

cbrandt

pourquoi avoir changé l'appel à Tab.Mes(val) ?
remets-le comme avant et ne change que la déclaration de mes[1000][2] dans la classe Tab…

sinon remets tout le code suite à tes modifs

Go Up