Zuweisung an Volatile Struct Array

Moin,

ich habe eine Struct, daraus erstell ich eine Variable und ein Array, dann weise ich einem Array Element diese Variable zu.. das funktioniert wie erwartet ! Kennzeichen ich allerdings die genannten als volatile funktioniert es nicht mehr... Warum ?

Mit einer einfachen byte Variable und einem Byte Array funktioniert es immer ( egal ob volatile oder nicht)

Der Compiler schmeißt folgenden Meldung:
ambiguous overload for 'operator=' (operand types are 'volatile frame' and 'volatile frame')

 struct frame {
  uint8_t ID ;
  uint8_t PID;
  uint8_t DATA[8];
  uint8_t LEN;
  uint8_t CHECKSUM;
  int TIMESTAMP;
};

  volatile frame myFrame; 

  volatile frame myFrameBuffer[63];

  volatile byte testVar;
  volatile byte testArray[8];


void setup() {

testVar = 123;
// Das Funktioniert, egal ob volatile oder nicht !  
testArray[0]= testVar;
  
myFrame.ID = 20;
//Das funktioniert nur wenn nicht volatile !
myFrameBuffer[0] = myFrame;
}

void loop() {
}

Cooles Problem. Die Lösung von da funktioniert auch nicht:

Lustiger Weise funktioniert's mit memcpy:
memcpy(&myFrame,&myFrameBuffer[0],sizeof(frame));

stefan_n:
ambiguous overload for 'operator=' (operand types are 'volatile frame' and 'volatile frame')

  int TIMESTAMP;

Warum int TIMESTAMP?

zwieblum:
Lustiger Weise funktioniert’s mit memcpy:
memcpy(&myFrame,&myFrameBuffer[0],sizeof(frame));

Super danke ! ;D das hilft mir schon sehr viel weiter !!

my_xy_projekt:
Warum int TIMESTAMP?

oh, muß **unsigned **long sein , danke :wink:

Ich denke daß Du Dich entscheiden solltest, welche Variablen tatsächlich volatile sein müssen. Das Ändern von volatile Variablen sollte nur in Interrupts o.ä. erfolgen, sonst sollten sie nur gelesen werden (mit abgeschalteten Interrupts). Ich weiß nicht ob der Compiler prüft oder prüfen kann, ob Interrupts abgeschaltet sind, vermutlich nicht.

Das Ändern von volatile Variablen sollte nur in Interrupts o.ä. erfolgen, sonst sollten sie nur gelesen werden (mit abgeschalteten Interrupts).

Hmmm....
Da möchte ich mal einen vorsichtigen Einspruch einlegen.

Allerdings:

welche Variablen tatsächlich volatile sein müssen.

Da stimme ich zu.

Ich vermute ja, dass folgendes eigentlich gemeint ist.

struct frame {
  volatile uint8_t ID ;
  volatile uint8_t PID;
  volatile uint8_t DATA[8];
  volatile uint8_t LEN;
  volatile uint8_t CHECKSUM;
  volatile int TIMESTAMP;
};

Dann klappts auch ohne memcpy()

Falls auch das nicht das gewünschte ist...
Findet sich hier und hier eine Beschreibung, was der volatile Modifikator ist, oder auch wann er verloren geht.
Gerade bei dem zweiten "hier" sollte man beachten, dass ein Array Bezeichner zu einem Pointer zerfällt, und die feld[index] Syntax Äquivalent zur Pointer Syntax *(index+feld) ist. Also keinen Unterschied im Code macht.
Zudem unterscheiden sich struct und class nur durch die defaultmäßigen Sichtbarkeitsregeln, nicht in den volatile Bedeutungen.

GCC frisst die volatile struct, G++ nicht.