Fragen zu Arduino EEprom Programmierung

[C-Wiedereinsteiger (Gast)]

Hallo zusammen,
ich hab da mal ein paar Fragen zu meinem Programmcode.

Erst aber mal ein paar Hintergrundinfos zu mir.
Ich habe jetzt wieder das 'programmieren' angefangen was ich seit mind. 
25 Jahre nicht mehr gemacht habe.
Damals hatte ich sehr viel in C programmiert, etwas Assembler, Basic ...
Die neuere C 'Dialekte' (C++ usw.) sind an mir etwas vorbei gegangen.
Ich tu mich gerade aber etwas schwer in 'mein' C wieder rein zu kommen.

Deshalb mal an ein paar Fragen:
Ich schreibe gerade ein kleines Programm für ein Arduino-NANO-Board 
welches ein paar Programmparameter in seinem internen EEprom Speicher 
ablegen soll und nach wieder einschalten dann diese Werte lesen soll.

Die Programmparameter möchte ich gerne alle in einer Struct-Variable 
speichern.
Falls dann im Programm noch ein Parameter dazu kommt oder entfällt 
möchte ich nicht jedes mal dann die Speicherfunktion ändern müssen.
So wie sie jetzt ist funktioniert es im Prinzip ja...,
aber irgend wie gefällt mir das so überhaupt nicht.

Ich übergebe einfach die Struct an die Funktion und schreibe dann, 
entsprechend der Struct-Länge, die Anzahl der Bytes ins EEprom.
Der Funktion 'save_to_EEprom' ist dabei egal welche Variablen in der 
Struct sind bzw. wie gross die Struct ist, aber...

Das komplette Programm ist allerdings sehr viel grösser (enthällt noch 
CRC Prüfung und wear leveling ...), aber die Parameterübergabe an die 
Funktion 'save_to_EEprom' ist genau so.

Sind die Variablen in der Struct immer direkt hintereinander im 
Programmspeicher?
Gibt es eventuell sogar eine einfache Bibliothek dafür? (möchte aber 
eigentlich keine dafür verwenden)
Wäre für einen Tipp dankbar wie man das richtig (eleganter) schreibt.
Wenn möglich aber in 'einfachem' C.

Danke schon mal.

#include <EEPROM.h>

struct Prog_Daten
{
  int  Parameter1;
  byte Parameter2;
  bool Parameter3;
  char Parameter4;
  char Parameter5[10];
} Daten;


void setup() 
{  
  Daten.Parameter1 = 0x1234;
  Daten.Parameter2 = 0x55;
  Daten.Parameter3 = true;
  Daten.Parameter4 = 'A';
  strcpy(Daten.Parameter5,"Hallo");

  // Daten ins EEprom schreiben

  save_to_EEprom((byte *) &Daten, sizeof(Daten));
}

void save_to_EEprom(byte *data, int len)
{
  int EEprom_adr = 0;
  
  while(len--)
    EEPROM[EEprom_adr++] = *data++;
}

void loop() { 
}

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

C-Wiedereinsteiger schrieb:
> So wie sie jetzt ist funktioniert es im Prinzip ja...
Glaube ich nicht.
Ist das im Datenblatt so beschrieben, dass man da einfach mit einem 
Pointer drauf losgehen kann? Oder gibt es da ein paar Register wie z.B. 
das EEDR, die beachtet und beschrieben werden müssen?

> Wäre für einen Tipp dankbar wie man das richtig (eleganter) schreibt.
Das Ding namens "Google" kennst du schon?
Damit findest du ganz schnell zwei Dinge:
1. passenden Code:
https://gist.github.com/PhirePhly/781405
und
2. die fertige Library für den AVR und wie man sie anwendet:
http://avr-programmieren-rh.de/tutorials/eeprom/

Denn wenn du es tatsächlich selbst machen willst, warum machst du es 
dann nicht? Dazu gehört dann aber auch das Lesen, Verstehen und Anwenden 
der Informationen im Datenblatt.

[C-Wiedereinsteiger (Gast)]

Lieber Herr Moderator,
danke für deine TOLLE Antwort.
Sehr typisch für dieses Forum!!!

Wenn du es nicht glauben willst ist das dein Problem, es funktioniert 
aber trotzdem.

Es ist das interne EEprom, da gibts keine Register, sorry.
Einfach:
EEPROM[Adresse] = x
Mehr muß ich da nicht angeben.

Es gibt allerdings auch noch andere Methoden mit put und get ...

Und stell dir vor, ich kenne auch Google...
Hat mir mit meinem Problem aber nicht weitergeholfen.
Danke für deine Belehrung.

Falls noch jemand mir wirklich helfen kann wie man das richtig schreibt 
wäre ich immer noch dankbar.

[Rufus Τ. F. (rufus)]

C-Wiedereinsteiger schrieb:
> Es ist das interne EEprom, da gibts keine Register, sorry.

Aha. Was soll das für ein µC sein?

Oder wo kommt Deine "EEPROM.h" her?

Enthält die zufälligerweise einen überladenen []-Operator?

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Rufus Τ. F. schrieb:
> Oder wo kommt Deine "EEPROM.h" her?
Und wie ist die Variable EEPROM definiert?

C-Wiedereinsteiger schrieb:
> Wenn du es nicht glauben willst ist das dein Problem, es funktioniert
> aber trotzdem.
Schalt mal den Strom aus und lies die "gespeicherten" Werte.

C-Wiedereinsteiger schrieb:
> Falls noch jemand mir wirklich helfen kann wie man das richtig schreibt
Was sollte man denn berichtigen? Funktionert es doch nicht?


> Sehr typisch für dieses Forum!!!
Es gibt mir zu denken, dass du offenbar immer solche "typischen 
Antworten" bekommst. Seis drum.

[JimKnopf (Gast)]

C-Wiedereinsteiger schrieb:

> Es gibt allerdings auch noch andere Methoden mit put und get ...

> Falls noch jemand mir wirklich helfen kann wie man das richtig schreibt
> wäre ich immer noch dankbar.

Das verstehe ich jetzt nicht. Wenn du die Arduino EEPROM Core Library 
Methoden 'get' und 'put' gesehen hast, dann verwende sie doch und 
übergib ihnen dein Struct.

Was soll denn da noch 'richtiger' sein?

[C-Wiedereinsteiger (Gast)]

Gaaaanz Ruhig Brauner...

Wie ich geschrieben habe geht es um einen Arduinio NANO.
Hab für dich sogar ein Bild angehängt falls du es noch nicht kennst.

Auf dem ist ein Mega328P-AU.
Hier ein Link zum Datenblatt:
http://ww1.microchip.com/downloads/en/DeviceDoc/Atmel-7810-Automotive-Microcontrollers-ATmega328P_Datasheet.pdf

Da steht auf der ersten Seite:
1Kbytes EEPROM

Und wenn ich den Strom ausschalte und wieder einschalte sind die Daten 
alle noch da.
Ein Wunder???

Und wie ich auch geschrieben habe funktioniert es ja, mir gefällt aber 
nicht der Funktionsaufruf. Das geht bestimmt besser, eleganter.

Lesen, Verstehen ... (ach lassen wir das lieber)

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

C-Wiedereinsteiger schrieb:
> Da steht auf der ersten Seite:
> 1Kbytes EEPROM
Wenn du mit der ersten Seite dann durch bist, dann blätter doch mal um 
auf Seite 20 Kapitel 7.4.

[Einer K. (Gast)]

C-Wiedereinsteiger schrieb:
> Und wie ich auch geschrieben habe funktioniert es ja, mir gefällt aber
> nicht der Funktionsaufruf. Das geht bestimmt besser, eleganter.

Ja!

Verwende put und get !!!!

#include <EEPROM.h>

struct Prog_Daten
{
  int  Parameter1;
  byte Parameter2;
  bool Parameter3;
  char Parameter4;
  char Parameter5[10];
};

Prog_Daten eemDaten EEMEM {0x1234,0x55,true,'A',"Hallo"}; // struktur im EEPROM, Arduino erzeugt *.eep Datei
Prog_Daten ramDaten; // struktur im RAM

void setup() 
{  
  ramDaten.Parameter1 = 0x1234;
  ramDaten.Parameter2 = 0x55;
  ramDaten.Parameter3 = true;
  ramDaten.Parameter4 = 'A';
  strcpy(ramDaten.Parameter5,"Hallo");

  // Daten ins EEprom schreiben
  EEPROM.put((int)&eemDaten,ramDaten);


 // Daten aus dem EEprom lesen
  EEPROM.get((int)&eemDaten,ramDaten);

  
}

void loop() { 
}

Die erzeugte *.eep Datei kann man per ISP ins EEPROM brennen.

[Einer K. (Gast)]

Rufus Τ. F. schrieb:
> Oder wo kommt Deine "EEPROM.h" her?

Lothar M. schrieb:
> Und wie ist die Variable EEPROM definiert?

Das kann ich euch zeigen!!
https://github.com/arduino/ArduinoCore-avr/blob/master/libraries/EEPROM/src/EEPROM.h

Könnte euch auch als Hinweis dienen, wo ihr in Zukunft die AVR 
spezifischen Libs, und auch den Arduino AVR Core, findet.

[C-Wiedereinsteiger (Gast)]

@Moderator:
Und wie soll mir das jetzt helfen?
Mich interessiern die Register überhaupt nicht.
Das schreiben und lesen geht ja, nur der Funktionsaufruf gefällt mir so 
nicht.

Ich verwende die EEPROM-Library.
https://www.arduino.cc/en/Reference/EEPROM

Jetzt kommt bestimmt wieder irgend etwas von der Wurst (Salami o.s.)

Aber ich denke wer mein Anfangspost gelesen hat, hat auch Arduino NANO 
und im Programm eine EEprom.h gelesen.


Danke an @JimKnopf und @Arduino Fanboy
Ich werde das mit put und geht noch mal prüfen ob das bei meiner 
Funktion save_to_EEprom auch passt. Ich verwende ja noch CRC Prüfung und 
wear leveling. Ist deswegen etwas umfangreicher die Funktion.

Hab irgend wie übersehen das ich da ja auch eine struct schreiben darf.


P.S.:
Und wie schreibt man jetzt in C eine Funktion, an die ich eine beliebige 
Variable (char, int, float, struct ...) übergeben will?
Bitte kein C++ (die EEprom.h versteh ich nicht)

[Rufus Τ. F. (rufus)]

Arduino Fanboy D. schrieb:
> Das kann ich euch zeigen!!

Das ist aber schön. Es wäre aber Aufgabe des "Wiedereinsteigers" 
gewesen.

C-Wiedereinsteiger schrieb:
> Und wie schreibt man jetzt in C eine Funktion

Du nutzt die Arduino-Umgebung, und damit C++.

[C-Wiedereinsteiger (Gast)]

Wenn du keine Ahnung hast dann halt doch einfach mal die Finger still.
Aber immer einen Senf dazu geben.

Sorry, aber das musste jetzt raus.

[Cyblord -. (cyblord)]

C-Wiedereinsteiger schrieb:
> Wenn du keine Ahnung hast dann halt doch einfach mal die Finger still.
> Aber immer einen Senf dazu geben.

Warum versuchst du nicht einen Wiedereinstieg im Gärtnern? z.B. Rosen 
züchten. Vielleicht kannst du ja da was.

> Sorry, aber das musste jetzt raus.
dito

[C-Wiedereinsteiger (Gast)]

Der nächste der nur rumtrollen will...

Ich denke wenn ich mir das hier so anschaue, wie einem sooo toll 
geholfen wird, sollte ich mir das wirklich überlegen.

[Rufus Τ. F. (rufus)]

C-Wiedereinsteiger schrieb:
> Wenn du keine Ahnung hast dann halt doch einfach mal die Finger still.

Du fragst hier um Hilfe.

Du vergreifst Dich zunehmend im Tonfall.


Das passt irgendwie nicht zusammen, meinst Du nicht auch?

[C-Wiedereinsteiger (Gast)]

Ja freilich frage ICH um Hilfe, sollte ja uch der Sinn eines Forums 
sein, das man Fragen stellt.
Oder?

Mir aber gleich Antworten:
- Glaub ich nicht
- Google erst mal
- Lesen, Verstehen, ...

Das war ja sehr höflich!
(Gut, warst du zwar nicht, aber dein Moderatorenkollege)

Wenn noch jemand meine letzte Frage unter P.S.: beantworten kann, wäre 
es immer noch schön.

Ansonsten wars das für mich.
Danke.

[Rufus Τ. F. (rufus)]

C-Wiedereinsteiger schrieb:
> sollte ja uch der Sinn eines Forums sein, das man Fragen stellt.
> Oder?

Ja. Aber man sollte dann versuchen, nicht diejenigen anzupissen, die 
einem zu helfen versuchen.

Wenn Du beispielsweise mir vorschlägst, doch "einfach mal die Finger 
still" zu halten, erlöscht meine Lust, Dir in irgendeiner Weise 
weiterzuhelfen.

Ich könnte es, aber warum sollte ich?

[Einer K. (Gast)]

Rufus Τ. F. schrieb:
> Arduino Fanboy D. schrieb:
>> Das kann ich euch zeigen!!
>
> Das ist aber schön. Es wäre aber Aufgabe des "Wiedereinsteigers"
> gewesen

Liebster Rufus...

Die EEPROM Lib gehört übrigens zum Arduino Standard, wie auch SPI, Wire 
und einige weitere.

Es ist völlig ok, wenn man keine Ahnung von der Arduino EEPROM 
Abhandlung hat.
(das geht jedem Baby so)
Es ging mir auch mal so.
Aber jetzt weißt du ja auch Bescheid, wie es mit der EEPROM Lib läuft.
Das ist Fein!
Dann werden uns solche Verwirrungen sicherlich in der Zukunft erspart 
bleiben.




----

Cyblord -. schrieb:
> Warum versuchst du nicht einen Wiedereinstieg im Gärtnern? z.B. Rosen
> züchten. Vielleicht kannst du ja da was.
Und du hast einen 3 wöchigen Urlaub auf einer Streckbank deiner Wahl 
verdient.

[Karl B. (gustav)]

Hi,
noch etwas Grundsätzliches zur AVR-Familie.
Sie sind keine PC-Prozessoren. Sie haben kein RAM, das beliebig 
beschrieben werden kann.
Es gibt demhingegen:
Codesegment
Datensegment
Epromsegment.

Für die Anspreche derselben gelten besondere Befehle, zum Teil auch 
andere Befehlsabarbeitungs-/Zugriffszeiten und Routinen.

Für Schreiben und Lesen auf und vom Epromsegment: (Es heißt korrekter 
EEPROM-Segment, ich nenne es hier einmal so.)

Beim Lesen muss durch "Polling" gefragt werden, ob nicht gerade ein 
Schreibvorgang läuft.

Beim Schreiben muss entsprechend durch "Polling" gefragt werden, ob 
nicht gerade ein Lesevorgang läuft.

So versehe ich das.
Das müsste jetzt in die entsprechende Programmiersprache "translated" 
werden.
Wenn man weiß, was man erzielen möchte, muss man auch unter Umständen 
erst einmal den "Standardworkaround" und die Konventionen beachten, die 
das Target instructionmäßig vorgibt.

ciao
gustav

[Einer K. (Gast)]

C-Wiedereinsteiger schrieb:
> Wenn noch jemand meine letzte Frage unter P.S.: beantworten kann, wäre
> es immer noch schön.

Du forderst unmögliches.

C Funktionen sind typisiert.

C++ Funktionstemplates könnten das evtl. leisten

[C-Wiedereinsteiger (Gast)]

Rufus Τ. F. schrieb:
> Ich könnte es, aber warum sollte ich?

Das glaube ich nicht!


Rufus Τ. F. schrieb:
> C-Wiedereinsteiger schrieb:
>> Und wie schreibt man jetzt in C eine Funktion
>
> Du nutzt die Arduino-Umgebung, und damit C++.

Das war doch schon deine Antwort.



@Arduino Fanboy
Danke, wenns in C nicht geht, dann gehts halt nicht.
Ist ok.


Jetzt aber,
Schluss, Aus, Ende...

[Einer K. (Gast)]

C-Wiedereinsteiger schrieb:
> @Arduino Fanboy
> Danke, wenns in C nicht geht, dann gehts halt nicht.
> Ist ok.

Wie schon gesagt wurde, Arduino ist eher C++ als C.
Es gibt also keinen Grund das auszublenden.

[Rufus Τ. F. (rufus)]

Arduino Fanboy D. schrieb:
> Liebster Rufus...

Achte auf Deinen Tonfall.

> Die EEPROM Lib gehört übrigens zum Arduino Standard, wie auch SPI, Wire
> und einige weitere.

Das ist mir bekannt. Aber anscheinend hat der "Wiedereinsteiger" 
keinen Bock, sich den Kram anzusehen, um zu verstehen, wie er 
funktioniert.

Ich habe die Fragen gestellt, in der Hoffnung, beim "Wiedereinsteiger" 
Denkprozesse anzuregen. Er hätte einfach in die "Lib" reingucken können, 
um zu sehen, wie das implementiert ist.

Ich gebe zu: Mit dem Anregen der Denkprozesse bin ich gescheitert.

C-Wiedereinsteiger schrieb:
> Das war doch schon deine Antwort.

Wenn Du die Antwort nicht verstehen willst, kann ich Dir auch nicht 
weiterhelfen.

[Ralph S. (jjflash)]

Immer wieder erstaunlich, wie sich die Menschen hier "anzicken" und 
bisweilen ein Moderator der erste ist, der "zickt" (sorry Lothar).

Bisweilen gibt es Kommentare die einen eine Kröte im Mund hinterlassen, 
die es gilt herunter zu schlucken (wenn man es denn kann), weil man wie 
ein Schulbub behandelt und/oder angesprochen wird.

Dann entwickelt sich der Thread vom fachlichen Thema weg und es geht nur 
ums "Recht haben".

Hier hat (wieder sorry Lothar) zuerst der Moderator etwas, sagen wir 
fingerspitzenlos, geantwortet:

Lothar M. schrieb:
> Glaube ich nicht.
> Ist das im Datenblatt so beschrieben, dass man da einfach mit einem
> Pointer drauf losgehen kann? Oder gibt es da ein paar Register wie z.B.
> das EEDR, die beachtet und beschrieben werden müssen?

Hier war schon klar, dass er einen Arduino verwendet und aus seinem Code 
ersichtlich, dass er die Software von Arduino nutzt.

Der Arduino-Benutzer hat mit den Registern (zumindest die Anfänger) 
nichts zu tun, die, die sogenannten Libs erstellen hingegen schon. Die 
Register werden vor dem Benutzer "versteckt".

Lothar M. schrieb:
> Das Ding namens "Google" kennst du schon?
> Damit findest du ganz schnell zwei Dinge:
> 1. passenden Code:
> https://gist.github.com/PhirePhly/781405
> und
> 2. die fertige Library für den AVR und wie man sie anwendet:
> http://avr-programmieren-rh.de/tutorials/eeprom/

Hier wird dann jemandem unterstellt, dass er zu dumm oder zu faul ist, 
selbst zu recherieren (was leider oft genug vorkommt), aber mir, wenn 
ich der TO wäre eben eine Kröte in den Mund steckt.

Abgesehen davon beinhalten die beiden Links Software, die einen AVR 
NICHT über das Arduino-Framework programmieren und haben somit mit der 
Anfrage des TO nichts zu tun.

Lothar M. schrieb:
> Denn wenn du es tatsächlich selbst machen willst, warum machst du es
> dann nicht? Dazu gehört dann aber auch das Lesen, Verstehen und Anwenden
> der Informationen im Datenblatt.

Stimmt, aber es ging ja um die Programmiersprache und nicht um die 
Hardware. Wer sich mit der Hardware eines Controllers auseinandersetzt 
nimmt in den wenigsten Fällen das Arduino Frameworks (manche aber doch).

So, aber nach so einer Antwort, wie gesagt, sollte man die Kröte 
schlucken, und bei den Experten, das seid ihr liebe Mods (das ist postiv 
gemeint), nachhaken und verständlicher machen wo man sein Problem hat.

Der TO hat diese Kröte nicht geschluckt und dann ging es, wie so oft 
hier, wieder ab.

An den TO: glaub mir, alle die dir hier geantwortet haben, haben es 
"drauf", sie wissen aber nicht mit wem sie es "zu tun" haben, und was 
jemand anderes drauf hat oder nicht, oder wie sehr er sich angestrengt 
hat.

Hier, kommt es so pervers oft vor, dass jemand sich schlicht seine 
Arbeit von jemand anderem machen lassen mag.

Und: Arduino-Framework ist C++. C++ ist kein "Dialekt" von C, sondern in 
vielem einfach etwas ganz anderes, syntaktisch fast gleich, aber vom 
Ansatz her in der Programmablaufsteuerung mit komplett anderen Ansätzen.

Wenn du also C (und nicht C++) machen möchtest, solltest du dich vom 
Arduino verabschieden und dann doch wie Lothar das (aus meiner Sicht der 
Dinge etwas zickig) geschrieben hat, mit der Hardware und dem Datenblatt 
auseinander setzen und den Arduino Nano (der nicht viel mehr ist als ein 
auf einer steckbrettgerechtem Platine gelöteter ATmega328 mit 
Bootloader) außerhalb des Arduino-Frameworks mit purem C zu füttern.

Leider mußt du, wenn du hier Hilfe erwartest, etwas zurückhaltender 
sein/werden, auch um vllt. zu demonstrieren, dass du nicht jemanden 
verarscht und selbst bemüht bist, deine Probleme in den Griff zu 
bekommen.

[S. Landolt (Gast)]

(um zu signalisieren, dass Ralph S. mit seiner Meinung nicht alleine 
ist:)

Diesem Beitrag möchte ich mich anschließen, auch und besonders, was den 
ersten Teil betrifft.

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Ralph S. schrieb:
> Hier hat (wieder sorry Lothar) zuerst der Moderator etwas, sagen wir
> fingerspitzenlos, geantwortet
Ja, das ging schief. Ich habe aber schlicht das Problem nicht verstanden 
(und das ging nicht nur mir so), denn das eigentliche Problem hier ist 
ja nicht das Schreiben auf das EEPROM (insofern ist auch der Name der 
Funktion äusserst unglücklich gewählt und die Kommentare irreführend, 
weil im geposteten Code eben rein gar nichts auf irgendein EEPROM 
geschrieben wird).

Sondern es geht hier ganz einfach nur um die Frage, wie Strukturen 
aufgebaut sind und wie sie gehandhabt werden.

[auch Arduino Fan (Gast)]

Lothar M. schrieb:
> (insofern ist auch der Name der
> Funktion äusserst unglücklich gewählt und die Kommentare irreführend,
> weil im geposteten Code eben rein gar nichts auf irgendein EEPROM
> geschrieben wird).

Stimmt leider nicht.

Mit
EEPROM[adr] = Daten
wird ins interne EEprom geschrieben.

siehe Funktion von Eeprom.h
https://www.arduino.cc/en/Reference/EEPROMObject

Deswegen passt der Name und Kommentare schon.

[Rufus Τ. F. (rufus)]

auch Arduino Fan schrieb:
> siehe Funktion von Eeprom.h

Und was findet sich da?

struct EEPROMClass{
    //Basic user access methods.
    EERef operator[]( const int idx )    { return idx; }

...

static EEPROMClass EEPROM;

Na, hab ich's doch gesagt, der []-Operator wird überladen.

EEPROM ist eine statische Objektinstanz der Klasse EEPROMClass, deren 
[]-Operator ein Objekt vom Typ EERef zurückgibt. Und was macht das?

struct EERef{
    //Access/read members.
    uint8_t operator*() const            { return eeprom_read_byte( (uint8_t*) index ); }

...
    
    //Assignment/write members.
    EERef &operator=( uint8_t in )       { return eeprom_write_byte( (uint8_t*) index, in ), *this;  }

...

Das ruft beim lesenden Dereferenzieren die Funktion eeprom_read_byte 
und beim Beschreiben die Funktion eeprom_write_byte auf.


Oh, aber um das herauszufinden, hätte man halt in die Datei eeprom.h 
sehen müssen. Das einzige, was man dem Arduino-System vorwerfen kann, 
ist, daß die grottige IDE keinen brauchbaren Weg vorsieht, genau das zu 
tun.

[Einer K. (Gast)]

Rufus Τ. F. schrieb:
> grottige

Erinnert mich irgendwie an c-hater....
Der schafft es auch (aus meiner Sicht) viel zu oft, in ein (an und für 
sich) sehr brauchbares Postings (da fachlich ok), mal eben noch am Ende 
eine Abwertung einzuflechten.

Soll ich mir das auch zum Vorbild nehmen?

Wenn das hier das gewünschte Verhalten ist, werde ich wohl 
Schwierigkeiten haben mir das anzugewöhnen. Denn das wäre mir schon ein 
wenig unangenehm, immer irgendwas in den Dreck ziehen zu müssen.
Zumindest anfangs.

Aber mit ein wenig Übung bekomme ich das schon hin.....
Das Problem ist nur, dass das dann festwächst, zum Automatismus wird.
Und da bin ich mir noch nicht sicher, ob diesen Automatismus etablieren 
möchte.

Rufus Τ. F. schrieb:
> Achte auf Deinen Tonfall.
Hi, ich hoffe inbrünstig, dass der Tonfall so ok ist.
Wenn nicht ok, dann muss ich wohl annehmen, dass es nicht der Tonfall 
ist, welcher Anstoß erregt, sondern die Kritik an sich. Dann hast du 
allerdings das Recht des stärkeren, den Boten zu töten, denn das hat 
Tradition.

[Rufus Τ. F. (rufus)]

Arduino Fanboy D. schrieb:
> mal eben noch am Ende eine Abwertung einzuflechten.

Hältst Du denn die "Abwertung" dieser IDE für unangemessen?

Hältst Du eine IDE, die all' das nicht kann, was andere IDEs schon seit 
Jahrzehnten können, für vorteilhaft?

Gerade wenn es darum geht, unbekannte Software zu untersuchen (hier: die 
"Library", die mit "eeprom.h" beschrieben wird), ist die Funktion "zeige 
mir die Definition / Deklaration eines Symbols" oder "öffne die Datei, 
deren Name unter dem Mauszeiger steht" elementar.

Ohne diese Funktionen muss man suchen. Und wenn man die Arduino-IDE auf 
dem Mac einsetzt, sind die "Libraries" auch noch im 
Applikationsverzeichnis versteckt, d.h. mit Bordmitteln nicht zu finden 
(die Finder-Suche durchsucht nicht den Inhalt von Programmen (*.app)).

Das bedeutet, daß der unbedarfte Nutzer, der etwas mehr darüber 
herausfinden will, wie etwas funktioniert, aktiv daran gehindert wird, 
das zu tun. Sicher, unter Windows/Linux werden die "Libraries" in einem 
durchsuchbaren Verzeichnis zu finden sein, aber auch dafür muss man die 
IDE verlassen und mit irgendwelchen anderen Werkzeugen danach suchen.

Und das ist meiner Ansicht nach ernsthaft kritikwürdig.

Kannst Du denn diese Aussage von mir widerlegen?

Rufus Τ. F. schrieb:
> Das einzige, was man dem Arduino-System vorwerfen kann, ist, daß die
> grottige IDE keinen brauchbaren Weg vorsieht, genau das zu tun.

[Einer K. (Gast)]

Rufus Τ. F. schrieb:
> Kannst Du denn diese Aussage von mir widerlegen?
Natürlich!

Jede Medaille hat (min) zwei Seiten.

Die Frage ist nur, ob du deine Sicht auch auf diese Aspekte richten 
kannst/willst/möchtest.

Aber das werden wir ja sehen.....

Rufus Τ. F. schrieb:
> Das bedeutet, daß der unbedarfte Nutzer, der etwas mehr darüber
> herausfinden will, wie etwas funktioniert, aktiv daran gehindert wird,
> das zu tun.

Ein "Feature" nicht ein zu programmieren, ist kein aktive Handlung, 
sondern eine passive.
Also ist die Aussage falsch.
Das war die erste Widerlegung.

Natürlich ist der Teil wahr, dass die IDE das Feature "zeige Definition" 
nicht hat.
Aber das hat den TE nicht davon abgehalten, sich die EEPROM.h 
anzuschauen.
Und wenn man auch nur ein klein wenig klug ist, kann man sich jede Datei 
im "Arduino Kontext" anschauen.
Das wird nicht aktiv unterbunden.
Das war die zweite Widerlegung.

So, der TE hat die Datei gefunden und sich angeschaut.
Aber nix verstanden.
(Was sicherlich ganz stark damit zusammen hängt, dass er C++ verweigert)
Du siehst: Das fehlende Feature, was die IDE für dich zu "grottig" 
macht, würde hier wirkungslos verpuffen.
Das angemeckerte Feature ist in diesem konkreten Fall also herzlich 
wenig hilfreich.

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

Dann gibt es ja auch noch das Mantra:
> Programmiere immer nur gegen das Interface einer Klasse
> und niemals gegen die Implementierung

Das darf man so weit treiben, dass einen die Implementierung nicht 
interessiert, sondern man nur die Interface Doku liest und die 
Klassen/Objekte/Templates stumpf verwendet.

Natürlich ist es dem Wissensdurstigen unbenommen, tief ins Uhrwerk zu 
schauen.

Vergleich am Rande:
Wieviel Prozent der C++ Programmierer, welche die STL verwenden, 
interessieren sich für den inneren Aufbau. Ist es es nicht eher so, dass 
die meisten da nur kurz rein schauen, und sich dann fix von der 
Implementierung der STL abwenden.

Oder gar so:
Das fehlende Feature verhindert wirkungsvoll unbeabsichtigte 
Manipulationen des Arduino Core durch Vollblut-Anfänger.
Durch eine rein passive Maßnahme.

----

Ich fasse zusammen:
Du möchtest nicht auf das (nice to have?) Feature verzichten.
Du projizierst deine Bedürfnisse auf zigtausende Arduino User.

Da die Arduino IDE dieses für dich lebenswichtige Feature nicht hat ist 
sie grottig.

Also arbeiten alle Arduino User mit grottigem Werkzeug.
Und das darf man denen auch sagen, denn wer freiwillig mit so grottigem 
Werkzeug arbeitet, der muss ja blöd sein.
Und das ist schließlich die reine Wahrheit.



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


Rufus Τ. F. schrieb:
> Hältst Du denn die "Abwertung" dieser IDE für unangemessen?
Hmmm....

Eigentlich halte ich generell Abwertungen für unangemessen.
Und Verallgemeinerungen liefern dann noch eine weitere Priese 
Geschmäckle.

Beispiel für eine angemessene Beurteilung:
> Spargel mag ich nicht.

Beispiel für eine unangemessene Beurteilung:
> Spargel schmeckt scheiße.

Anderes Beispiel:
Schon mal mit Leuten zusammen gearbeitet/kommuniziert, welche schlechte 
Laune haben?
So mit richtig übler Ausstrahlung?

Das überträgt sich auf eigene Wohlbefinden. Je nachdem, wie mental 
stabil man selber ist, kann es etwas dauern, aber irgendwann wird man 
dem Stänkerer die Meinung sagen.

Ja, ich glaube das ist so ziemlich der Kern....
Abwertungen verbreiten schlechte Stimmung.
Fördern eher Eskalationen, als den konstruktiven Dialog.
Und an der Stelle, solle man sich dann fragen, möchte ich Dialog, oder 
Eskalation?
Sich dann bewusst für eins von beidem entscheiden.

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

Rufus Τ. F. schrieb:
> Hältst Du denn die "Abwertung" dieser IDE für unangemessen?
Ja!
Wenn du sagen würdest:
> Mir ist sie zu schlicht.
> Sie bietet mir nicht genug, oder die richtigen, Features.
Dann hätte ich da überhaupt kein Problem mit.

Sogar volles Verständnis. Denn auch ich vermisse ein paar Features.
Weiß aber, dass ich sie mit (erheblichem Aufwand) vielleicht selber da 
einbauen könnte, wenn es denn unbedingt sein muss.





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

Rufus Τ. F. schrieb:
> Ohne diese Funktionen muss man suchen. Und wenn man die Arduino-IDE auf
> dem Mac einsetzt, sind die "Libraries" auch noch im
> Applikationsverzeichnis versteckt, d.h. mit Bordmitteln nicht zu finden
> (die Finder-Suche durchsucht nicht den Inhalt von Programmen (*.app)).

Ein MAC "Feature" oder eine Einschränkung des Finders auf Arduino im 
allgemeinen zu projizieren, ist aus meiner Sicht ungerecht.
Selbst ein MAC User ist in der Lage die EEPROM.h auf github zu 
finden.(sollte in der Lage sein)

Es macht den Eindruck, als würdest du jetzt anfangen immer mehr Dinge an 
den Haare herbeizuziehen, weil dir meine Kritik an deinen Abwertungen, 
an deinem Verhalten, so gar nicht schmeckt.

Übrigens, eins der Probleme ist hier benannt.
Siehe: https://www.arduino.cc/en/Guide/PortableIDE

Falls dir dafür eine gute Lösung einfällt, men los!
Niemand wird dich da aufhalten.



----

Rufus Τ. F. schrieb:
> Hältst Du eine IDE, die all' das nicht kann, was andere IDEs schon seit
> Jahrzehnten können, für vorteilhaft?
Weiß nicht....
Kann das eigentlich nur für mich beurteilen.
Mir reicht sie.

Am Rande:
Für absolute Anfänger ist die Arduino IDE sicherlich einfacher zu 
bedienen und zu nutzen, als diese Visual Studio, oder Eclipse, 
Klikibunti Monster.
Viel weniger Ablenkung. Weniger mögliche Irrfahrten im Angebot der 
Oberfläche.

Aber wie auch immer, die Arduino IDE ist keine Einbahnstraße.
Es Wechsel ist möglich, und damit stehen dann auch alle gewünschten 
Features zur Verfügung.

[Rufus Τ. F. (rufus)]

Arduino Fanboy D. schrieb:
> Ein "Feature" nicht ein zu programmieren, ist kein aktive Handlung,
> sondern eine passive.
> Also ist die Aussage falsch.
> Das war die erste Widerlegung.

Deine "Logik" ist kaputt. Auf dieser Ebene ist eine Diskussion mit Dir 
komplett sinnlos.

[Einer K. (Gast)]

Rufus Τ. F. schrieb:
> Deine "Logik" ist kaputt. Auf dieser Ebene ist eine Diskussion mit Dir
> komplett sinnlos.

Ja, das stimmt!
Wenn wir uns noch nicht mal über die Semantik, von aktiv und passiv, 
einigen können, dann hast du da vollkommen Wahr.
Dann ist es auch wenig Wunder, dass dir meine Logik als kaputt 
erscheint.

[Rufus Τ. F. (rufus)]

Es geht nicht um Semantik. Es geht um eine IDE, der wesentliche zum 
effektiven Arbeiten damit nötige Funktionen fehlen.

Praktisch jede andere IDE auf diesem Planeten bietet diese Funktionen.

Arduino Fanboy D. schrieb:
> Für absolute Anfänger ist die Arduino IDE sicherlich einfacher zu
> bedienen und zu nutzen, als diese Visual Studio, oder Eclipse,
> Klikibunti Monster.

Sicher. Aber das Hinzufügen der Funktionen "gehe zur Stelle, an der ein 
Symbol definiert bzw. deklariert wird" ist nichts, was so eine 
Einfach-IDE zu einem "klickibunti-Monster" verkommen lässt. Ebenso die 
"hier steht der Name einer Datei im Quelltext, mach' sie auf"-Funktion.

Beides würde den Arduino-Nutzern helfen, ihr Werkzeug besser zu 
verstehen.

[Einer K. (Gast)]

Rufus Τ. F. schrieb:
> Es geht nicht um Semantik.
Entschuldige bitte...
a. Du hast meine Logik für kaputt erklärt.
b. Und dazu die erste Widerlegung zitiert.
Und dieses Zitat bezieht sich eindeutig auf den semantischen Fehler, 
welcher dir da unterlaufen ist.
Und genau auf diese Bedeutungsverirrung bezieht sich ein Großteil deiner 
Argumentation.




Rufus Τ. F. schrieb:
> Es geht um eine IDE, der wesentliche zum
> effektiven Arbeiten damit nötige Funktionen fehlen.
Die für dich wesentlich sind.

---------

Rufus Τ. F. schrieb:
> Praktisch jede andere IDE auf diesem Planeten bietet diese Funktionen.
Nunja....
Es gibt ja auch noch die notepad++/make Fraktion.
Was hältst du denn von denen?

Das alte Sprichwort:
> Tausend Fliegen kön......
kennst du ja sicherlich auch.

----------

Rufus Τ. F. schrieb:
> Sicher. Aber das Hinzufügen der Funktionen "gehe zur Stelle, an der ein
> Symbol definiert bzw. deklariert wird" ist nichts, was so eine
> Einfach-IDE zu einem "klickibunti-Monster" verkommen lässt. Ebenso die
> "hier steht der Name einer Datei im Quelltext, mach' sie auf"-Funktion.

Zumindest ist es erst mal ein ordentliches Paket Arbeit welches 
geleistet werden muss, um der IDE das beizubringen.
Deine Kritik, am Fehlen, mal beiseite, wärst du denn in der Lage und 
auch willens das zu leisten?


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

Rufus Τ. F. schrieb:
> Beides würde den Arduino-Nutzern helfen, ihr Werkzeug besser zu
> verstehen.
Mmmm...
Ich glaube eher, dass Verstehen im Kopf passiert.
Dass es nicht so sehr von einem einzelnen Kontextmenü Eintrag abhängig 
ist.

Ja, ich hätte nichts dagegen, wenn du das Feature da einbauen würdest.
Es wäre bequem.
Das Klickfeldchen würde meiner Faulheit sehr entgegen kommen.

Aber Lernprozesse, die finden anders statt.
Dazu benötigt man ein möglichst entspanntes Umfeld.
Gute/Positive Stimmung.
Aufmunterung, statt Abwertung.


Am Rande:
> Gott, gib mir die Gelassenheit, Dinge hinzunehmen,
> die ich nicht ändern kann,
> den Mut, Dinge zu ändern, die ich ändern kann,
> und die Weisheit, das eine vom anderen zu unterscheiden.
Quelle: https://de.wikipedia.org/wiki/Gelassenheitsgebet