creating strings with char[]

Projects Programming
1

goal: trying to output things with a string input over telnet

problem: serial won't print anything

for the sake of putting the whole code:

#include <SPI.h>
#include <EthernetV2_0.h>

// Enter a MAC address and IP address for your controller below.
// The IP address will be dependent on your local network.
// gateway and subnet are optional:
byte mac[] = { 
  0x00, 0xAA, 0xBB, 0xCC, 0xDE, 0x02 };
IPAddress ip(192,168,1, 177);
IPAddress gateway(192,168,1, 1);
IPAddress subnet(255, 255, 255, 0);

// telnet defaults to port 23
EthernetServer server(23);
boolean gotAMessage = false; // whether or not you got a message from the client yet
#define W5200_CS  10
#define SDCARD_CS 4
    
void setup() {
  // Open serial communications and wait for port to open:
  Serial.begin(9600);
  pinMode(SDCARD_CS,OUTPUT);
 digitalWrite(SDCARD_CS,HIGH);//Deselect the SD card
  // this check is only needed on the Leonardo:
   while (!Serial) {
    ; // wait for serial port to connect. Needed for Leonardo only
  }


  // start the Ethernet connection:
  Serial.println("Trying to get an IP address using DHCP");
  if (Ethernet.begin(mac) == 0) {
    Serial.println("Failed to configure Ethernet using DHCP");
    // initialize the ethernet device not using DHCP:
    Ethernet.begin(mac, ip, gateway, subnet);
  }
  // print your local IP address:
  Serial.print("My IP address: ");
  ip = Ethernet.localIP();
  for (byte thisByte = 0; thisByte < 4; thisByte++) {
    // print the value of each byte of the IP address:
    Serial.print(ip[thisByte], DEC);
    Serial.print("."); 
  }
  Serial.println();
  // start listening for clients
  server.begin();
 
}

void loop() {
  // wait for a new client:
  EthernetClient client = server.available();

  // when the client sends the first byte, say hello:
  if (client) {
    if (!gotAMessage) {
      Serial.println("We have a new client");
      client.println("Hello, client!"); 
      gotAMessage = true;
    }

    // read the bytes incoming from the client:
    char thisChar = client.read();
    // echo the bytes back to the client:
    //server.write(thisChar);
    // echo the bytes to the server as well:
    //Serial.print(thisChar);
    int j;
    for(int i=0; thisChar!='\r'; i++)
    {
        j=i;
    }
    char input[j];
    for(int i=0; thisChar!='\r'; i++)
    {
    input[i] = thisChar;
    }
    if(input=="hello")
    {
        Serial.println("welcome");
        delay(2000);
        Serial.println("there");
    }
    if(input=="u")
    {
        Serial.print("HI THER GUY");
    }

  }
}

part i need help on:

    int j;
    for(int i=0; thisChar!='\r'; i++)
    {
        j=i;
    }
    char input[j];
    for(int i=0; thisChar!='\r'; i++)
    {
    input[i] = thisChar;
    }
    if(input=="hello")
    {
        Serial.println("welcome");
        delay(2000);
        Serial.println("there");
    }
    if(input=="u")
    {
        Serial.print("HI THER GUY");
    }

  }
}
2 
    if(input=="hello")

Yes, but that is not how you compare strings. Google "strcmp".

3 
    int j;
    for(int i=0; thisChar!='\r'; i++)
    {
        j=i;
    }

You've read one letter, and stored it in thisChar. If that character is not a \r, j will still be undefined.

If the character IS \r, the loop will never end.

    char input[j];

So, how big IS this array?

    for(int i=0; thisChar!='\r'; i++)
    {
    input[i] = thisChar;
    }

If you get REAL lucky, and j was some reasonable value, this loop repeats the same idiocy from above. Either the loop iterates 0 times, storing 0 copies of the same value, or it repeats forever, trashing memory you don't own, until the Arduino crashes.

    if(input=="hello")

Aside from the fact that this is not how to compare strings, how can n copies of the same letter ever equal a collection of n different characters?

You need to ditch the idea that you can dynamically create an array to hold whatever the client sent this time. You MUST create a static array (or global), and initialize that array to an empty string (by putting a NULL in position 0) and set the array index to 0 when the client first connects.

As you read data from the client, you store it in the array where the NULL is, increment the index, and store another NULL (to keep the string NULL terminated). When the complete client response is received, and not a moment sooner, you can parse what the client sent.