Salutations!

bon voila j ai un gros probléme en essayant de compiler mon code un msg d'erreur s'affiche :taking address of temporary array. Svp j ai vraiment besoin d'aide.

merci!!

Sans le code qui va avec l'erreur en question, cela va être compliqué de te dire comment corriger...

Donnes nous ton code en utilisant le bouton en forme de </> juste au dessus de la zone d'édition du message.

mon ce code consiste a vérifier si un point (gps) est a l’intérieur d'une zone ainsi que de vérifier si la vitesse ne dépasse pas la vitesse limite:

my_class.h:

class Vertex {
public:
  Vertex(float llat, float llng) {
    lat = llat;
    lng = llng;
  }
  float lat;
  float lng;
};

class SpeedZone {
public:
  SpeedZone(int s) {
    speedLimit = s;
  }
  void setVertices(int n, Vertex *v) {
    nVertices = n;
    vertices = v;
  }
  int nVertices;
  Vertex *vertices;
  int speedLimit;
};

le code principale:

#include <SoftwareSerial.h> 
#include <TinyGPS.h>
#include "my_class.h"
#define S_RX    4                
#define S_TX    3  
#define DEFAULT_SPEED_LIMIT 55
#define NSPEEDZONES 2

boolean debugMode = true;

boolean speeding = false;




SpeedZone *speedZones[NSPEEDZONES];
TinyGPS gps;
SoftwareSerial nss(S_RX, S_TX);


void setup() {
  Serial.begin(9600);
  setupSpeedZones();
  // Allow EM-406a to power up
  delay(3000);
  // Establish serial connection to EM-406a
  nss.begin(9600);
}



void setupSpeedZones() {
  speedZones[0] = &SpeedZone(45);
  speedZones[0]->setVertices(6, (Vertex[6]){
      Vertex(45.027162772967756, -93.48137855529785),
      Vertex(45.02946790848425, -93.4742546081543),
      Vertex(45.02955889877115, -93.46193790435791),
      Vertex(45.02861865883124, -93.46172332763672),
      Vertex(45.02861865883124, -93.47412586212158),
      Vertex(45.02649547957147, -93.48133563995361)});
//zone 2
speedZones[1] = &SpeedZone(65);
  speedZones[3]->setVertices(8, (Vertex[8]){
      Vertex(45.04453999302037, -93.45356941223145),
      Vertex(45.03950629768142, -93.45369815826416),
      Vertex(45.029255597252295, -93.45378398895264),
      Vertex(45.02594950646131, -93.45386981964111),
      Vertex(45.02616182995624, -93.4522819519043),
      Vertex(45.028921963725224, -93.45168113708496),
      Vertex(45.0390514238751, -93.4520673751831),
      Vertex(45.044267093182235, -93.45150947570801)});



  if (debugMode) {
    printSpeedZones();
  }

}


boolean inSpeedZone(int speedZone, float lat, float lng) {
  SpeedZone *s = speedZones[speedZone];

  int i, j;
  boolean inside = false;
  for (i = 0, j = s->nVertices-1; i < s->nVertices; j = i++) {
    if ( ((s->vertices[i].lat > lat) != (s->vertices[j].lat > lat)) &&
         (lng < (s->vertices[j].lng - s->vertices[i].lng) * (lat - s->vertices[i].lat) / (s->vertices[j].lat - s->vertices[i].lat) + s->vertices[i].lng) )
       inside = !inside;
  }

  return inside;
}


boolean inSpeedZone(int speedZone) {
  float lat, lng;
  unsigned long  fix_age;

  // retrieves +/- lat/long in 100,000ths of a degree
  gps.f_get_position(&lat, &lng, &fix_age);

  return inSpeedZone(speedZone, lat, lng);
}

void loop() {

  if (readGPS()) {
    if (debugMode) {
      debug();
    }
     Serial.print("getSpeedLimit() = ");
     Serial.println(getSpeedLimit());
    speeding = isSpeeding();
    if(isSpeeding()){
     Serial.println("oui");
   //lcd.clear();
   //lcd.setCursor(0, 1);
   //lcd.print("STOP DANGER");
  }
else
Serial.println("non");
  }
  }

bool readGPS() {
  while (nss.available()) {
    if (gps.encode(nss.read())) {
      return true;
    }
  }
  return false;
}

  
int getSpeedLimit() {
  boolean isInSpeedZone;

  for(int i=0;i<NSPEEDZONES;i++) {
    isInSpeedZone = inSpeedZone(i);
    if (isInSpeedZone) {
      return speedZones[i]->speedLimit;
    }
  }
  return DEFAULT_SPEED_LIMIT;
}

boolean isSpeeding() {
  int speed = (int)(gps.f_speed_mph() + 0.5);
  int speedLimit = getSpeedLimit();

  if (speed > speedLimit) {
    return true;
  }
  return false;
}

void printSpeedZones() {

  for(int i=0;i<NSPEEDZONES;i++) {
    SpeedZone *s = speedZones[i];
    Serial.println(s->speedLimit);
    for(int v=0;v<s->nVertices;v++) {
      Serial.print("(");
      Serial.print(s->vertices[v].lat);
      Serial.print(", ");
      Serial.print(s->vertices[v].lng);
      Serial.println(")");
    }
  }
}

void debug() {
  long lat, lon;
  unsigned long fix_age, time, date, speed, course;

  gps.get_position(&lat, &lon, &fix_age);

  Serial.println(getSpeedLimit());

  Serial.print("lat: ");
  Serial.print(lat);
  Serial.print("    lng: ");
  Serial.print(lon);
  Serial.print("    speed: ");
  Serial.println(gps.f_speed_mph());
}

ainsi que l'erreur

T2:34:44: error: taking address of temporary array

   speedZones[0]->setVertices(6, (Vertex[6]){

                                            ^

       Vertex(45.027162772967756, -93.48137855529785),

       ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

       Vertex(45.02946790848425, -93.4742546081543),

       ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

       Vertex(45.02955889877115, -93.46193790435791),

       ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

       Vertex(45.02861865883124, -93.46172332763672),

       ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

       Vertex(45.02861865883124, -93.47412586212158),

       ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

       Vertex(45.02649547957147, -93.48133563995361)});

       ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

T2:43:44: error: taking address of temporary array

   speedZones[3]->setVertices(8, (Vertex[8]){

                                            ^

       Vertex(45.04453999302037, -93.45356941223145),

       ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

       Vertex(45.03950629768142, -93.45369815826416),

       ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

       Vertex(45.029255597252295, -93.45378398895264),

       ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

       Vertex(45.02594950646131, -93.45386981964111),

       ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

       Vertex(45.02616182995624, -93.4522819519043),

       ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

       Vertex(45.028921963725224, -93.45168113708496),

       ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

       Vertex(45.0390514238751, -93.4520673751831),

       ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

       Vertex(45.044267093182235, -93.45150947570801)});

       ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

cordialement 

-
Edité par HbYacine 27 juin 2020 à 11:35:19

Comme le montrent les messages d'erreur, la lignes 34 notamment pose problème:

  speedZones[0]->setVertices(6, (Vertex[6]){

Tu peux expliquer à quoi correspond "Vertex[6]", sachant que Vertex est une classe et pas un objet?

Expliquer, on peut. Vertex[6] est un tableau anonyme de 6 Vertex, initialisé parce qui est entre accolades derrière.

--

Le problème est facile à reproduire en petit :

class V {}; 

int main() {
	V * ptr  = (V[0]) {};	 
}

a.cc: In function ‘int main()’:
a.cc:4:20: error: taking address of temporary array
  V * ptr  = (V[0]) {};
                    ^~

(V[0]){} est un tableau temporaire.

Réparation

	V t[0] =  {};
	V * ptr  = t;

-
Edité par michelbillaud 27 juin 2020 à 12:22:30

Le problème, c'est que tu utilises une variable locale pour créer ton tableau.

Et comme toute variable locale, elle sera détruite à la fin de sa zone d'allocation, ce qui implique que ton pointeur sera invalide.

Pour éviter cela, il te faut utiliser l'allocation dynamique avec new.

Vertex *vtxs = new Vertex [6];
vtxs[0] = Vertex(45.027162772967756, -93.48137855529785);
vtxs[1] = Vertex(..., ...);
vtxs[2] = ...;
...
speedZones[0]->setVertices(6, vtxs);

Attention au fait qu'il ne faut pas oublier de désallouer la mémoire lorsque tu n'en as plus besoin.

Si tu ne le fait pas, ton arduino finira par ne plus avoir de mémoire disponible pour d'autres allocation.

Il est donc impératif d'éditer ta classe pour faire les delete :

class SpeedZone {
public:
  SpeedZone(int s) {
    speedLimit = s;
    vertices = nullptr;
  }
  ~SpeedZone() {
    if(vertices) {
      delete [] vertices;
    }
  }
  void setVertices(int n, Vertex *v) {
    if (vertices) {
      delete [] vertices;
    }
    nVertices = n;
    vertices = v;
  }
  int nVertices;
  Vertex *vertices;
  int speedLimit;
};

je vous remercie infiniment pour toutes vos réponses et je pense que je dois bien comprendre le fonctionnement du microcontrôleur (mémoire etc) pour pouvoir progresser.

Tu fais fausse route. Je ne trouve pas que ça ait vraiment rapport avec le fonctionnement interne d'un microcontrôleur.

L'allocation dynamique n'est pas nécessaire (et ça fait mauvais genre dans de l'embarqué), il suffit de déclarer le tableau, qui semble être un tableau de constantes, avant l'appel à setVertices.
en global, ou en static, si on veut qu'il survive après l'exécution de la fonction

Vertex v[6] = {
        Vertex(45.027162772967756, -93.48137855529785),
        Vertex(45.02946790848425, -93.4742546081543),
        Vertex(45.02955889877115, -93.46193790435791),
        Vertex(45.02861865883124, -93.46172332763672),
        Vertex(45.02861865883124, -93.47412586212158),
        Vertex(45.02649547957147, -93.48133563995361)};


void setupSpeedZones()
{
    SpeedZone s{12};

    s.setVertices(6, v);
}

(ou en static dans la fonction)

-
Edité par michelbillaud 29 juin 2020 à 9:14:47