eigene Funktion sblöcke

[Arduino (Gast)]

Hallo,

hab eine Frage zu Arduino,

ich möchte mehrere eigene Funktionensblöcke, unter anderem ein kleines 
Menüsystem, erstellen welche dann aus Loop heraus bei Bedarf einzeln 
aufgerufen werden sollen..

Wo müssen diese Funktionsblöcke stehen?

Zwischen Setup() und Loop()

oder kann ich zuerst Setup() dann in Loop() mein Hauptprogramm schreiben 
und meine ganzen Funktionsblöcke dann nach Loop anhängen?

Danke für Eure Antworten!

[Cyblord -. (cyblord)]

Heißen jetzt einfache Funktionen in Arduino-Deppensprech schon 
"Funktionsblöcke", oder ist das nur in deiner Welt so?

Und gibts da keine lib um eigene Funktionen zu schreiben? Wie soll das 
ein Arduino-Nutzer selber können?

Leg mal die Arduino Tutorials und das ganze andere hirnentleerte Zeug 
weg und lies ein C Buch.

[Karl H. (kbuchegg)]

Arduino schrieb:
> Hallo,
>
> hab eine Frage zu Arduino,
>
> ich möchte mehrere eigene Funktionensblöcke, unter anderem ein kleines
> Menüsystem, erstellen welche dann aus Loop heraus bei Bedarf einzeln
> aufgerufen werden sollen..
>
> Wo müssen diese Funktionsblöcke stehen?

Halte dich an zwei einfache Regel:

1) Der Compiler liest den Code von oben nach unten.
2) Verwendet werden kann nur, was bereits bekannt ist.


Wenn du also eine Funktion xyz() aufrufen willst, und zwar aus einer 
Funktion abc() heraus, dann ist es das einfachste die Funktion xyz() im 
Code räumlich VOR der Funktion abc() zu definieren

int xyz( int i )
{
  // mach was
  return 8; 
}

void abc()
{
  // mach auch was

  xyz( 5 );

  // irgendwas
}

liest man den Code von oben nach unten, so wird zuerst die Funktion 
xyz() 'eingeführt', so dass der Compiler weiß, das es die Funktion gibt, 
welche Parameter-Datentypen sie hat und ob sie einen Returnwert hat oder 
nicht.

Wenn dann in der Funktion abc() der Aufruf der Funktion steht, dann 
kennt daher der Compiler die Funktion xyz() bereits und kann überprüfen, 
ob die Art und Weise, wie du die Funktion benutzt konsistent dazu ist.

rufst du die Funktion abc() wiederrum von irgendeiner anderen Funktion 
heraus auf, dann steht die Funktion räumlich wieder vor diesem Aufruf

int xyz( int i )
{
  // mach was
  return 8;
}

void abc()
{
  // mach auch was

  xyz( 5 );

  // irgendwas
}

void loop()
{
  abc();
}

und wieder greift das gleiche Prinzip. Von oben nach unten und verwendet 
wird nur das, was bereits bekannt ist.

Kann man die Reihenfolge so nicht machen (oder will man sie aus 
irgendeinem Grund nicht so machen), dann muss man spezielle 
Deklarationen machen, sog. Funktionsprototypen, mit denen man das 
gleiche erreicht: Den Compiler davon informieren, dass es eine derartige 
Funktion gibt und wie die Argumente zu dieser Funktion aussehen.

Das sieht dann so aus

// ein Protoyp.

int xyz( int i );

// Er informiert den Compiler darüber, dass es eine Funktion namens 'xyz'
// tatsächlich gibt (könnte beim Aufruf ja auch ein Tippfehler sein),
// dass die Funktion 1 Argument übernimmt, welches vom Datentyp int ist
// und das die Funktion einen Returnwert liefert, der ebenfalls vom 
// Datentyp int ist


//
// Damit kann dann in der folgtenden Funktion der Funktionsaufruf
// überprüft und übersetzt werden, weil der Compiler ja die 'Signatur'
// der Funktion kennt .....
void abc()
{
  // mach auch was

  xyz( 5 );

  // irgendwas
}

...

// ..... auch wenn die eigentliche Funktion dann erst viel später
// im Code kommt
int xyz( int i )
{
  // mach was
  return 8;
}

> oder kann ich zuerst Setup() dann in Loop() mein Hauptprogramm schreiben
> und meine ganzen Funktionsblöcke dann nach Loop anhängen?

setup() und loop() sind nicht irgendwie speziell.
Am einfachsten ist es, wenn du den Code einer Funktion die du irgendwo 
benutzt, räumlich VOR der benutzenden Stelle hast. Denn dann musst du 
den Prototypen erstens nicht schreiben und zweitens nicht anpassen, wenn 
sich die Funktionssignatur verändert.


>
> Danke für Eure Antworten!

Kauf dir ein C++ Buch wenn du vernünftig Arduino programmieren willst. 
Die Sprache C++ ist unabhängig von Arduino, was alledings nicht heißt, 
dass man zumindest die Grundlagen der Sprache nicht kennen müsste.
Schon traurig, dass man so grundlegend einfache Konzepte einem 
sogenannten Programmierer erst noch erklären muss und er das nicht schon 
längst aus seiner Literatur weiß.

[Chris (Gast)]

Hallo Arduino!

Ich habe erst vor kurzem eine Steuerung mit Arduino programmiert, und 
habe die Arduino-IDE mit Processing verwendet.
Diese eigenen Funktionen können ganz einfach nach der loop-Funktion 
(nach der letzten geschweiften Klammer }  ) plaziert werden. Wenn die 
Funktion im loop aufgerufen wird, können die Parameter übergeben werden 
und es kommt auch ein Wert zurück.
Ich hatte nur zwei kleine Funktionen und wollte nicht extra eine 
Header-Datei schreiben.

mfg Chris

[Larry (Gast)]

Chris schrieb:
> Ich habe erst vor kurzem eine Steuerung mit Arduino programmiert

Das glaube ich nicht. Arduino und programmieren schließt sich aus.

Am besten wartet ihr. Es dauert bestimmt nicht lange bis man sich in der 
Arduino-"IDE" alles zusammenklicken kann. Die Tastatur für euren PC 
könnt ihr dann auch verkaufen und in einen weiteren Arduino investieren.