Strings und Stringverarbeitung?

Kann mir mal bitte jemand verraten, ob und wie das mit den Strings in der Arduino IDE funktioniert? Ich habe die Version 1.0.1 für Mac.
Ich habe schon Alles an Includes probiert, was ich im Web finden konnte, aber der Typ “string” ist und bleibt unbekannt :frowning:

#include
#include
#include <string.h>
#include <String.h>
#include <WString.h>

… hilft Alles nix … “string” does not name a type … rrrrrrrrrrrrrrrrr

Der Datentyp heisst "String" mit einem großen "S". Dafür brauchst Du auch kein "#include", den kennt die IDE direkt. Siehe auch http://arduino.cc/en/Reference/StringObject und im Vergleich dazu: http://arduino.cc/en/Reference/String

Ich glaub's nicht. Alle anderen Datentypen schreibt man aber klein. Aber OK, es geht, danke. Nähste Frage: Wie kann ich einem String ein Char zuweisen? Man sollte annehmen "einfach so", denn ein String besteht doch auh Chars, oder? Aber ich ernte (abstruse) die Fehlermeldung

buf=c;

WebServer.cpp: In function 'void loop()': WebServer:59: error: invalid conversion from 'char' to 'const char*' WebServer:59: error: initializing argument 1 of 'String& String::operator=(const char*)'

Es geht um das Ethernetshield-Beispiel "Webserver". Ich will den Char c, in einen String kopieren, um übergebene Parameter in der URL zu suchen ...

Alle anderen Datentypen schreibt man aber klein

String ist auch kein Datentyp, sondern eine höchst gefährliche Objekt-Klasse, die dir deinen RAM zerfetzt, wenn du sie wie einen Datentyp benutzt.

Wenn du ein char brauchst, nimm keinen String.

invalid conversion from 'char' to 'const char*'

Ein char* ist ein Pointer, in der Regel der Anfang eines char array. ( Ein String -mit großem S- ist eine Klasse, die dynamisch solche char arrays erzeugt )

const ist ein anderes Thema, das sich dann evtl. von selbst löst.

Die "nativen" Datentypen werden klein geschrieben. "String" ist eine Klasse, also so eine Art "künstlicher" Datentyp, um den Umgang mit Zeichenketten zu vereinfachen. Allerdings hat diese Klasse einen schlechten Ruf, da sie als Speicher-Fragmentierer und Speicher-Fresser bekannt ist.

Zu Deinem konkreten Problem: Poste bitte mal den Code, der angemeckert wird, inkl. Deklaration der Variablen die Du verwendest. Alles andere wäre nur Raten.

#include <SPI.h>
#include <Ethernet.h>


// Enter a MAC address and IP address for your controller below.
// The IP address will be dependent on your local network:
byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
IPAddress ip(192,168,200, 177);
String buf;
char c;

// Initialize the Ethernet server library
// with the IP address and port you want to use 
// (port 80 is default for HTTP):
EthernetServer server(80);

void setup() {
  // Open serial communications and wait for port to open:
  Serial.begin(9600);



  // start the Ethernet connection and the server:
  Ethernet.begin(mac, ip);
  server.begin();
  Serial.print("server is at ");
  Serial.println(Ethernet.localIP());
}


void loop() {
  // listen for incoming clients
  EthernetClient client = server.available();
  if (client) {
    Serial.println("new client");
    // an http request ends with a blank line
    boolean currentLineIsBlank = true;
    while (client.connected()) {
      if (client.available()) {
        c = client.read();
        Serial.write(c);
        buf=c;
        // if you've gotten to the end of the line (received a newline
        // character) and the line is blank, the http request has ended,
        // so you can send a reply
        if (c == '\n' && currentLineIsBlank)
       ....

Das ist der Anfang um Code des Webservers, der in den Beispielen enthalten ist. Die (nach bisheriger Ansicht) Stringvariable “buf” sollte den Inhalt von c aufnehmen, damit ich darin mit Stringfunktionen nach übergebenen Argumenten an der URL suchen kann. Ich vergaß wohl, dass ich es mit einem Micro und nicht mit einen ausgewachsenen PC zu tun habe …
Das war nur ein erster Versuch. Was ich eigentlich vorhabe (Steuerung von Geräten übers Netz) werde ich wohl direkt mit Sockets machen. Dort werde ich die Kommunikation auf Bytes auslegen und parsen …

Abgesehen davon, das die Zuweisung nicht funktioniert, wäre sie auch sinnlos, da "c" ja nur ein einzelnes Zeichen enthalten kann. (Typ char). Damit würdest Du in jedem Schleifendurchlauf das in "buf" gespeicherte Zeichen durch das aktuell aus der Verbindung gelesene ersetzen.

Was Du ja vermutlich eigentlich willst, ist das aktuelle Zeichen in "c" an den String anhängen, um am Ende den kompletten String durchsuchen zu können.

Das geht durch den "+" Operator

buf = buf + c;

Allerdings ist das aus Speichersicht overkill. Besser ist es, einen passenden Buffer zu reservieren und den immer wieder zu verwenden. Das vermeidet das Fragmentieren des Speichers

char buf[100]; // 100 byte großer Puffer
...
void loop() {
  int index = 0 //zaehlindex für den puffer
  // listen for incoming clients
  EthernetClient client = server.available();
  if (client) {
    Serial.println("new client");
    // an http request ends with a blank line
    boolean currentLineIsBlank = true;
    while (client.connected()) {
      if (client.available()) {
        c = client.read();
        Serial.write(c);
        buf[index]=c;
        index++; // zusammengefasst auch als "buf[index++]=c"

        // if you've gotten to the end of the line (received a newline
        // character) and the line is blank, the http request has ended,
        // so you can send a reply
        if (c == '\n' && currentLineIsBlank)
       ....
       // string zu ende gelesen, dann NULL-Terminierung setzen
       // index ist in diesem fall die richtige stelle im puffer, da index vorher schon
       //um 1 erhöht wurde
       buf[index]=0

Dein char-Array "buf" ist dann ein "char*" string (klein) den Du z.B. prima mit den avr-libc Funktionen untersuchen kannst: http://www.nongnu.org/avr-libc/user-manual/group__avr__string.html Alternativ kannst Du auch ein

String text = buf;

machen (mit char* geht das ja dann jetzt auch) und die Methoden der Klasse String verwenden. Mit allen Problemen die diese Klasse bei langer Laufzeit macht.