Pages: [1]   Go Down
Author Topic: Arduino Einführung  (Read 1642 times)
0 Members and 1 Guest are viewing this topic.
Offline Offline
Newbie
*
Karma: 0
Posts: 3
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

.
« Last Edit: January 07, 2014, 02:00:09 pm by Schnix » Logged

Offline Offline
Faraday Member
**
Karma: 128
Posts: 4146
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

Am besten du steigst erst mal von String Objekten auf C-Strings um, d.h. char Arrays:
http://arduino.cc/en/Reference/String

Die Trennung des strings könnte man zwar einfach mit substring() machen (und eventuell indexOf() wenn die Position des Trennzeichens nicht bekannt ist), aber dann muss man das noch in Float wandeln. Und dazu braucht du wahrscheinlich sowieso den Umweg über toCharArray():
http://arduino.cc/en/Reference/StringToCharArray

Da kann man sich die Trennung mit den StringObject Methoden auch sparen und gleich den ganzen String in einen C-String wandeln. Oder am besten eben gleich zeichenweise in ein char Array einlesen.

Von einem char Array auf Float kommst du mit atof():
http://www.nongnu.org/avr-libc/user-manual/group__avr__stdlib.html#ga689c9d3c4c04463aa31d329937789d06


EDIT:
Wenn man C-Strings hat kann man die Trennung einfach so machen:
Code:
char str[] = "Wert_1.2345";
char* pch = strchr(str, '_');           //gibt einen const Pointer auf die Position von '_' zurück
double d = atof(pch + 1);

Das folgende geht auch wenn der Anfangs-String ("Wert_") immer die gleiche Länge hat, da str ein Pointer auf das erste Zeichen ist und und die Zahl 5 Zeichen weiter rechts beginnt.:
double d = atof(str + 5);
« Last Edit: October 22, 2013, 02:07:12 pm by Serenifly » Logged

Germany
Offline Offline
Faraday Member
**
Karma: 59
Posts: 3072
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

Quote
   char wert[]="Wert_";
   while (Serial.available()){
     char Eingabewert=Serial.read();
     if (Eingabewert==wert){
     }

Ja,  das funktioniert so nicht:
1.  Ist ein char array was anderes als ein char
2. Funktioniert das == nicht so wie du denkst.
3. Solltest du die  2 Zeilen
Code:
  char* pointer = strchr(wert,'_'); //gibt einen const Pointer auf die Position von '_' zurück
  double d = atof(pointer + 1);

ausführen, nachdem du deine Eingabe in einen Puffer
Code:
char wert[20]; // Platz für "Wert_12.3456"
eingelesen hast.
Logged

Germany S-H
Offline Offline
Faraday Member
**
Karma: 172
Posts: 3245
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

Habe schonmal ein bisschen rumprobiert, aber bisher ohne Erfolg.

Schön, dass Du schon mal selbst probiert hast, denn Programmieren lernt man nur durch Programmieren.

Allerdings scheinen Dir ganz wesentliche Grundkenntnisse zu über Programmierung allgemein und die Programmierung in C im besonderen zu fehlen. Und darüber hinaus läßt Du Dich von den Arduino-Machern völlig in die Irre leiten.

Erstens mal "String": Die Arduino-Macher propagieren aus mir völlig unerfindlichen Gründen "String-Objekte", die so deklariert werden:
  String Eingabebefehl;
Diese String-Objekte sind der letzte Dreck. Erstens verbrauchen die viel zu viel RAM-Speicher, wenn man sie verwendet. Zweitens sind sie kaum in irgendeiner brauchbaren Form kompatibel zur C-String Implementation der Standard-Library des GCC-Compilers. Standardmäßig arbeiten C-Compiler mit C-Strings, das sind einfach char-Arrays. Sämtliche Funktionen der GCC-Standardlibrary mit dem Namen "AVR libc" arbeiten nur und ausschließlich mit C-Strings und NICHT mit String-Objekten. Es handelt sich bei der "AVR libc" um eine sehr mächtige Library, und gegen das, was die AVR libc Library an Funktionen zur Stringbehandlung und Stringumwandlung bietet, sind die handvoll "Komfortfunktionen" für String-Objekte ein lächerlicher Witz. Die Dokumentation der kompletten "AVR libc" findest Du hier:
http://www.nongnu.org/avr-libc/user-manual/modules.html

Wenn Du ernsthaft mit Arduino programmieren möchtest, solltest Du schon so 10 bis 20 Funktionen dieser Library anwenden können (insgesamt sind es hunderte Funktionen).

Zweitens mal: Das wichtige sind beim Programmieren nicht nur die Algorithmen, also was wie programmiert und manipuliert wird, sondern ganz wichtig ist es zu Anfang, sich geeignete DATENSTRUKTUREN zu überlegen. Denn am Ende hängt es an den Datenstrukturen, wie diese be- und verarbeitet werden können.

Und Drittens mal: Wenn Du eine komplexe Aufgabe hast, zerlege sie in sinnvolle und kleinere Teilaufgaben. Und mache für jede Teilaufgabe eine Funktion.

Hast du dafür mal ein zusammenhängendes Codebeispiel?

Ich habe mal für Deinen Fall ein  Codebeispiel gemacht, und mir dazu folgendes überlegt:

1. Datenstrukturen
Ich habe mir überlegt, dass Du eine bestimmte Anzahl verschiedener "Wertenamen" verwalten möchtest, für die jeweils ein "Wert" gespeichert werden soll. Dazu habe ich mir überlegt, diese jeweils als C-Strings zu verwalten, mit einer Länge von 8 (7 Zeichen plus das Nullzeichen, das bei C-Strings für das Ende des Strings steht).  Im Beispiel gibt es drei verschiedene "wert", "abc" und "def", falls mehr als drei benötigt werden, kann man das in der Datenstruktur leicht anpassen:

#define STRLEN 8 // Maximale Länge der Strings (inkluse Nullzeichen am Ende)
#define STRNUM 3 // Anzahl der Strings
char strings[STRNUM][STRLEN]={"wert","abc","def"};
char values[STRNUM][STRLEN];

Durch die Deklaration eines zweidimensionalen Char-Arrays deklarierst Du nicht ein "Array of chars" als einen C-String, sondern ein "Array of Array of chars", also ein "Array of C-Strings".

Ich bin mal davon ausgegangen, dass Du mehr als nur eine Variable "wert" verwalten möchtest, sondern es mehrere verschiedene werden.

2. Teilaufgaben
Als zu erledigende Teilaufgaben habe ich mir überlegt:
- eine serielle Zeile komplett einlesen
- wenn die Zeile komplett empfangen wurde nachsenen:
- ist ein "_" in der Zeile enthalten ==> Funktion aufrufen zum "Lernen"  des Werts
- ist ein "?" in der Zeile enthalten ==> Funktion aufrufen zum "Zurückliefern" des Werts

3. Alle Teilaufgaben in eine eigene Funktion "serialTask();" packen, die dann aus der loop heraus aufgerufen wird.

Code:
#define STRLEN 8 // Maximale Länge der Strings (inkluse Nullzeichen am Ende)
#define STRNUM 3 // Anzahl der Strings
char strings[STRNUM][STRLEN]={"wert","abc","def"};
char values[STRNUM][STRLEN];

char* receiveBuffer()
#define ZEILENTRENNZEICHEN 13   // 13 ist Steuerzeichen CR (Carriage Return)
{
  static char lineBuffer[25]; // Maximale Zeilenlänge festlegen
  static byte counter=0;
  char c;
  if (Serial.available()==0) return NULL; // Nullpointer zurück
  if (counter==0) memset(lineBuffer,0,sizeof(lineBuffer));// Puffer vor Benutzung löschen
  c=Serial.read();
  if (c==ZEILENTRENNZEICHEN)
  {
    counter=0;
    return lineBuffer;
  }
  else if (c>=32) // kein Steuerzeichen?
  {
    lineBuffer[counter]=c; // Zeichen im Zeilenpuffer einfügen
    if (counter<sizeof(lineBuffer)-2) counter++;
  }
  return NULL;
}

void setup()
{
  Serial.begin(9600);
}

void learnValue(char* str, char* val)
{
  for (int i=0;i<STRNUM;i++)
  {
    char* found=strstr(str,strings[i]);
    if (found==str)
    {
      strncpy(values[i],val,STRLEN);
//      Serial.println(values[i]);
    }
  }  
}

char* returnValue(char* str)
{
  for (int i=0;i<STRNUM;i++)
  {
    char* found=strstr(str,strings[i]);
    if (found==str)
    {
//      Serial.println(values[i]);
      return values[i];
    }
  }
  return NULL;  
}

void serialTask()
{
  char* string;
  char* value;
  char* text=receiveBuffer();
  if (text==NULL) return;
  // Testen auf "_"
  string=strtok(text,"_");
  value =strtok(NULL,"_");
  if (value!=NULL) learnValue(string,value);
  // Testen auf "?"
  if (strchr(text,'?')!=NULL)
  {
    value=returnValue(string);
    if (value==NULL)
      Serial.println("Value not found");
    else
    {  
      Serial.print("Value for ");
      Serial.print(text);
      Serial.print(" is: ");
      Serial.println(value);
    }
  }  
}

void loop()
{
  serialTask();  
}

Hinweise:
Bei der Eingabe des Wertenamens kommt es auf die Groß- und Kleinschreibung an, d.h. wenn der Wertename "wert" deklariert ist, wird er in derselben Schreibweise erwartet, und "wert", "Wert", "wErt" etc. wären verschiedene Wertenamen.

Wernn Du die "Werte" nicht als Strings benötigst, sondern als Gleitkommazahlen, hilft die AVR libc "atof()" bei der Umwandlung von C-String ("array of chars")  nach float. Der Funktionsname "atof" steht dabei als Kurzbegriff für "array to float", als kleine Merkhilfe, was die Funktion macht:
http://www.nongnu.org/avr-libc/user-manual/group__avr__stdlib.html#ga689c9d3c4c04463aa31d329937789d06

P.S.: Der Demo-Code macht reichlich Gebrauch von char-Pointern, das sind im Prinzip Zeiger auf ein char-Array, das seine Speicherinhalte an anderer Stelle haben. Kurze Erläuterungen im Kommentar:
char lineBuffer[25]; // Ein char-Array mit 25 reservierten Stellen im RAM-Speicher
char* text; // Ein "Zeiger auf ein char Array" (ohne reservierten Speicher)
Char-Zeiger (Pointer) sind nützlich, da sie in vielen Fällen von Standardfunktionen als Rückgabewert zurückgeliefert werden, z.B. von Suchfunktionen.  Ein spezieller char-Pointer ist dabei die Konstante "NULL", die auf "keine Speicherstelle" verweist, z.B. wenn eine Suchfunktion "nicht gefunden" zurückliefert.
« Last Edit: October 23, 2013, 05:43:59 am by jurs » Logged

Offline Offline
God Member
*****
Karma: 14
Posts: 591
View Profile
WWW
 Bigger Bigger  Smaller Smaller  Reset Reset

... Diese String-Objekte sind der letzte Dreck.

Hallo,

würde ich zwar nicht so hart formulieren, aber dem Kern Deiner Aussage stimme ich zu. Die String-Objekte vergisst man am besten.

Wernn Du die "Werte" nicht als Strings benötigst, sondern als Gleitkommazahlen, hilft die AVR libc "atof()" bei der Umwandlung von C-String ("array of chars")  nach float.

Sorry, atof() konvertiert nach double nicht nach float.

Gruß,
Ralf
Logged

Es gibt 10 Arten von Menschen, die einen verstehen Binär, die anderen nicht...

Offline Offline
Faraday Member
**
Karma: 128
Posts: 4146
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

Wobei man das in der Arduino IDE nicht mitbekommt. Float und Double haben beide 4 Byte und es wird automatisch umgewandelt. Und die IDE gibt keine Warnings aus. Also werden eventuelle Warnungen wie "truncation from double to float" nicht angezeigt.


P.S.:
Was oben wegen "==" angesprochen wurde. == vergleicht anders als bei String Objekten nicht den Inhalt sondern die Gleichheit des Pointers. Um den Inhalt von C-Strings zu vergleichen gibt es strcmp() - string compare. Ist übrigens in Java genauso (nur mit equals()).
« Last Edit: October 23, 2013, 09:08:16 am by Serenifly » Logged

Germany
Offline Offline
Faraday Member
**
Karma: 59
Posts: 3072
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

Da wir so ins Grundsätzliche gehen, die Vorgabe
Wert_<eineGleitkomma-Zahl>
zu übertragen und auszuwerten, verursacht für Anfänger wie dich, Schnix, erstmal unnötige Probleme:

- Muss es Float sein ?
- Was ist der Sinn von "Wert_" davor ?
- Woran erkennst du, dass die Zahl zu Ende ist ?
Logged

Germany S-H
Offline Offline
Faraday Member
**
Karma: 172
Posts: 3245
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

Sieht für mich erstmal ziemlich kompliziert aus smiley

An der Anzahl der Funktionen kann es eigentlich nicht liegen, da sind nur drei Stück relevant
- eine Funktion zum Einlesen einer Zeile
- eine Funktion zum Lernen von Variableninhalten
- eine Funktion zum Ausliefern von Variableninhalten
Das kann man an den Fingern einer Hand abzählen.

Was vielleicht kompliziert ist, ist der Umgang mit C-Strings, C-String-Funktionen und Pointern. Das ist natürlich etwas gewöhnungsbedürftig.

-es soll 3 feste Eingabebefehle geben
 z.B. Wert1_float Zahlenwert
         Wert2_float Zahlenwert
         Wert3_float Zahlenwert
  und es soll leider alles in einer Eingabezeile eingelesen werden.

Du solltest vielleicht mal prüfen, ob überhaupt jedesmal "Namen" mit übertragen werden müssen, oder ob es nicht ausreicht, nur die "Werte" zu übertragen. Wenn nämlich immer alle drei (und immer dieselben) Namen mit immer drei (zu denselben Namen gehörenden) Werten übertragen werden, dann kannst Du die Namen auch weglassen.

Statt:
wert1_47.12 wert2_47.13 wert3_47.14
überträgst Du einfach
47.12 47.13 47.14
Und dann ordnest Du drei in einer Zeile ankommenden Werten in Deinem Sketch die passenden Variablen zu.

Wenn Du es auch vertauscht auswerten möchtest, also z,B.:
wert2_47.13 wert1_47.12 wert3_47.14
oder es fehlt mal ein Wert:
wert2_47.13 wert3_47.14
oder es stehen auch "falsche Namen" in einer Zeile dabei, die unberücksichtigt bleiben sollen:
wert5_47.12 wert4_47.13 wert3_47.14 wert1_47.12 wert2_47.13
dann wird die Auswertung natürlich komplexer als wenn einfach nur drei Zahlen in immer derselben Anzahl und Reihenfolge zu erfassen sind.

-sagen wir die float Zahl benötigt etwa 5 Ziffern nach dem Komma

Die einfach genauen Gleitkommazahlen von AVR GCC haben überhaupt nur 6-7 signifikante Stellen. Wenn Du also fünf Stellen nach dem Komma brauchst, dann darf die Zahl nur eine einzige Stelle vor dem Komma haben, wenn sie sie unter allen Umständen zuverlässig reproduzierbar als "float" speichern möchtest.
Logged

Germany
Offline Offline
Faraday Member
**
Karma: 59
Posts: 3072
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

Quote
nur diese 3 Kommandos sollen möglich sein.
Dann nimm doch (erstmal) nur einen Buchstaben + Zahl

D12.234
P23.4567
R0.00001

oder so.
Mit einem einzigen Serial.read() weisst du, woran du bist und kannst direkt *)  anschlessend z.B. Serial.parseFloat() aufrufen.

Ich finde es übrigens super, dass du deinen eigenen Code auch selbst richtig verstehen willst. smiley-wink


*) direkt ist relativ, am einfachsten schätzt du erstmal, wie lange die serielle Übertragung dauert und wartest also ein paar millisekunden
Logged

Offline Offline
Faraday Member
**
Karma: 128
Posts: 4146
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

read() liest einen character ein! Keinen ganzen string. Du musst da vorher ein char array anlegen und dann Zeichenweise einlesen. Wo du aufpassen musst, ist das serielle Kommunikation mehrere Millisekunden pro Zeichen dauert. Daher kannst du nicht wenn das erste Zeichen eintrifft gleich das zweite einlesen. Deshalb ließt man i.d.R. Zeichen ein bis man auf ein Linefeed und/oder Carriage Return trifft.

Nimm einfach die receiveBuffer() Methode aus dem Code von jurs. Die gibt NULL zurück bis sie fertig ist. Einfacher und viel besser wird es nicht. Die Auswertung des Arrays kannst du dann anders machen.


Dann gibt noch readBytesUntil() das automatisch bis zu einem Terminator liest.

Und die ParesInt/Float Methoden, die Zahlen gleich konvertieren:
http://arduino.cc/en/Serial/ParseFloat
Da muss man aber auch aufpassen, dass die Zahl schon komplett im Puffer ist (mit available()) und nicht noch gesendet wird.
« Last Edit: October 27, 2013, 11:37:26 am by Serenifly » Logged

Offline Offline
Faraday Member
**
Karma: 128
Posts: 4146
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

Rein zum Auslesen reicht der Teil:

Code:
#define ZEILENTRENNZEICHEN 13   // 13 ist Steuerzeichen CR (Carriage Return)

char* receiveBuffer()
{
  static char lineBuffer[25]; // Maximale Zeilenlänge festlegen
  static byte counter=0;
  char c;
  if (Serial.available()==0) return NULL; // Nullpointer zurück
  if (counter==0) memset(lineBuffer,0,sizeof(lineBuffer));// Puffer vor Benutzung löschen
  c=Serial.read();
  if (c==ZEILENTRENNZEICHEN)
  {
    counter=0;
    return lineBuffer;
  }
  else if (c>=32) // kein Steuerzeichen?
  {
    lineBuffer[counter]=c; // Zeichen im Zeilenpuffer einfügen
    if (counter<sizeof(lineBuffer)-2) counter++;
  }
  return NULL;
}

void setup()
{
  Serial.begin(9600);
}
 
void loop()
{
  char* text=receiveBuffer();
  if (text !=NULL)
  {
      ...Auswertung
  }

}

receiveBuffer() wird ständig aufgerufen und bis was anderes als NULL zurück kommt. Dann kann man den Puffer auswerten. Zu erwähnen ist vielleicht, dass man normalerweise keine Pointer auf lokale Variablen zurückgeben kann. Das geht hier nur weil das als "static" definiert ist und damit auch zwischen den Funktionsaufrufen existiert (d.h. der Speicher wird nach dem Ende der Methode nicht freigegeben).


Die Auswertung kannst du auch so ähnlich machen:

Code:
 //diese Variablen global definieren!
  char string1[8];
  char string2[8];
  char string3[8];
  float value1;
  float value2;
  float value3;

   ...

  char* string=strtok(text,"_");
  char* value =strtok(NULL,"_");

  if(strcmp(string, "Wert1") == 0)      //Strings gleich?
  {
       strcpy(string1, string);                //String-Anteil nach string1 kopieren
       value1 = atof(value);                   //Zahl-Anteil umwandeln
  }
  else  if(strcmp(string, "Wert2") == 0)  
  {
       strcpy(string2, string);    
       value2 = atof(value);
  }
  else if....


So sparst du dir die Sache mit dem zwei-dimensionalen Array. Das ist für dich besser verständlich.

Du kannst dir auch die Wandlung mit atof sparen und den Float Wert ebenfalls als String abspeichern. Das kommt dann darauf an was du damit auf dem Arduino sonst noch machen willst.

strtok, strcmp, und strcpy sind hier erklärt:
http://www.c-howto.de/tutorial-strings-zeichenketten-stringfunktionen.html

strcmp:
http://www.c-howto.de/tutorial-strings-zeichenketten-stringfunktionen-vergleichen-strcmp.html
strtok:
http://www.c-howto.de/tutorial-strings-zeichenketten-stringfunktionen-zerteilen-strtok.html
strcpy:
http://www.c-howto.de/tutorial-strings-zeichenketten-stringfunktionen-kopieren-strcpy.html
Logged

Germany S-H
Offline Offline
Faraday Member
**
Karma: 172
Posts: 3245
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

die char Arrays und Pointer stellen für mich momentan zu viel Neuland dar...hatte mich in die Arduino Befehle (u.a. String Objekte) eingearbeitet und gehofft das es damit geht.

Im Endeffekt geht es außer modular, erweiterungsfähig und effektiv auch auch gerade so für den Anwendungsfall gemacht, ohne Verwendung selbstgeschriebener Funktionen, mit schlechten Erweiterungsmöglichkeiten und reduzierter Effizienz durch Verwendung von delay() beim Einlesen.

Sogar Pointer-Deklarationen und Pointer-Zugriffe kann man weitgehend vermeiden. Und ob Du nun Char-Arrays oder String-Objekte verwendest, sooo gravierend unterschiedlich wird das Programm auch nicht, ob nun das eine oder das andere verwendet wird.

Einmal mit Char-Arrays:
Code:
char bef1[]="DEF_"; // Befehl-1
char bef2[]="REF_"; // Befehl-2
char bef3[]="PEF_"; // Befehl-3
char abf1[]="DEF?"; // Abfrage-1
char abf2[]="REF?"; // Abfrage-2
char abf3[]="PEF?"; // Abfrage-3
float f1,f2,f3; // Drei Gleitkommazahlen
char eingabe[81]; // Eine serielle Eingabezeile
int count; // Buchstabenzähler für die Eingabezeile

void setup()
{
  Serial.begin(9600);
}

void loop() {
  if (Serial.available()) // Wenn mind. 1 Zeichen im Eingangspuffer
  {
    delay(100); // warten bis alle Zeichen im Eingangspuffer
    count=0;
    while (Serial.available()) // Zeichenweise auslesen
    {
      eingabe[count]=Serial.read();
      count++;
    }
  }
  else return; // Sonst vorzeitiges Ende der Loop
  // Code ab hier wird nur ausgeführt, nachdem etwas empfangen wurde
  // Es werden die ersten vier Zeichen aus der Eingabe mit dem Befehl / der Abfrage verglichen
  if (strncmp(eingabe,bef1,4)==0) // Befehl-1 erkannt
    f1=atof(&eingabe[4]); // Gleitkommazahl lernen
  if (strncmp(eingabe,bef2,4)==0) // Befehl-2 erkannt
    f2=atof(&eingabe[4]); // Gleitkommazahl lernen
  if (strncmp(eingabe,bef3,4)==0) // Befehl-3 erkannt
    f3=atof(&eingabe[4]); // Gleitkommazahl lernen

  if (strncmp(eingabe,abf1,4)==0) // Abfrage-1 erkannt
    Serial.println(f1);
  if (strncmp(eingabe,abf2,4)==0) // Abfrage-2 erkannt
    Serial.println(f2);
  if (strncmp(eingabe,abf3,4)==0) // Abfrage-3 erkannt
    Serial.println(f3);
}

Und einmal mit String-Objekten:
Code:
String bef1="DEF_"; // Befehl-1
String bef2="REF_"; // Befehl-2
String bef3="PEF_"; // Befehl-3
String abf1="DEF?"; // Abfrage-1
String abf2="REF?"; // Abfrage-2
String abf3="PEF?"; // Abfrage-3
String f1,f2,f3; // Drei Gleitkommazahlen
String eingabe; // Eine serielle Eingabezeile
int count; // Buchstabenzähler für die Eingabezeile

void setup()
{
  Serial.begin(9600);
}

void loop() {
  if (Serial.available()) // Wenn mind. 1 Zeichen im Eingangspuffer
  {
    delay(100); // warten bis alle Zeichen im Eingangspuffer
    eingabe="";
    while (Serial.available()) // Zeichenweise auslesen
    {
      char c=Serial.read();
      if (c>=32) eingabe=eingabe+c;
    }
  }
  else return; // Sonst vorzeitiges Ende der Loop
  // Code ab hier wird nur ausgeführt, nachdem etwas empfangen wurde
  // Es werden die ersten vier Zeichen aus der Eingabe mit dem Befehl / der Abfrage verglichen

  if (eingabe.startsWith(bef1))  // Befehl-1 erkannt
    f1=eingabe.substring(4,255); // Gleitkommazahl lernen
  if (eingabe.startsWith(bef2))  // Befehl-2 erkannt
    f2=eingabe.substring(4,255); // Gleitkommazahl lernen
  if (eingabe.startsWith(bef3))  // Befehl-3 erkannt
    f3=eingabe.substring(4,255); // Gleitkommazahl lernen

  if (eingabe.startsWith(abf1)) // Abfrage-1 erkannt
    Serial.println(f1);
  if (eingabe.startsWith(abf2)) // Abfrage-2 erkannt
    Serial.println(f2);
  if (eingabe.startsWith(abf3)) // Abfrage-3 erkannt
    Serial.println(f3);
}

Das Problem ist: Du mußt halt programmieren können, wenn Du etwas programmieren möchtest.

Wenn Du nicht programmieren kannst, kann man es lernen. Eine Programmiersprache zu lernen ist aber ungefähr so wie eine Fremdsprache zu lernen: Wenn Du nur drei Stunden die Woche reinsteckst, dann dauert es eben etwas länger, eine Unterhaltung in der Fremdsprache zu führen als wenn Du einen Intensiv-Sprachkurs mit 8 Stunden Sprachentraining jeden Tag machst.

Bevor Du in einer neuen Fremdsprache eine Unterhaltung führen, ein Interview geben oder eine Rede halten kannst, mußt Du die Fremdsprache lernen. Und mit einer Programmiersprache ist es genau dasselbe.  Wenn die Vokabeln und die Grammatik nicht sitzen, kommt am Ende nur Stuss dabei raus.
Logged

Pages: [1]   Go Up
Jump to: