String, char, etc

who_took_my_nick · February 23, 2022, 1:11pm

I am using ESP8266 for years and while sending GET requests to a server, I had zero problems. Now, I have a project where some of the URL address needs to be in an EEPROM. What could possibly go wrong? Well, everything.

When I form an URL address from the EEPROM data, glue a line or two to it, on Serial I get the address I want, but it just doesn't work. When I tried to copy that address from the Serial, I get only part of it. Not the whole address. So it is whole here printed, but I can not copy it. In the example here I provide, I can copy the first part or the second one. But not whole.

Say I have something like this:
www somesite com/index.php
(dots are removed for not making a link)
in EEPROM, which I read as a String (i expect sh*t storm now, please spare me).

String servicePath ;
for (int r = addr_espPathService; r < addr_espPathService + 150; ++r){
    servicePath += char(EEPROM.read(r));
  }

Now, when using:

String serverPathService = servicePath+"?upit=ssid&id=2";
Serial.println(serverPathService);
    if (http.begin(client, serverPathService.c_str())) {

On Serial I get the whole string, which I can not copy as a whole. But that string obviously passes only this servicePath, and not the rest. The part I can copy.

I know, it is about the data type.
I know, String...

But what I do not know is how to fix it.

johnwasser · February 23, 2022, 1:29pm

A String acts weird when it contains null characters. I suspect the String has a bunch of null characters after the string contents. To fix that, store the length of the string in EEPROM and read that first. Then only read 'n' characters into your String instead of reading all 150.

who_took_my_nick · February 23, 2022, 1:47pm

I have never messed up with this you suggest. Can you give me an example or a link?
If I get you correctly, I should store in EEPROM a length and while reading it later to use that as an end of reading so not read nullls?

johnwasser · February 23, 2022, 2:11pm

Yes.

eastpark · February 23, 2022, 2:17pm

String servicePath ;
char readChar;
for (int r = addr_espPathService; r < addr_espPathService + 150; ++r){
    readChar = char(EEPROM.read(r));
    servicePath += readChar;
  // stop after first if you use zero terminated string
   if (readChar == 0x00 ) break;
  }

johnwasser · February 23, 2022, 2:48pm

Don't put the null terminator in the String.

  // stop after first if you use zero terminated string
  if (readChar == 0x00 ) break;
  servicePath += readChar;

J-M-L · February 23, 2022, 2:53pm

and make sure the EEPROM has a trailing null char added when you saved the String.
if you need to store multiple data, this might become an issue if the String length varies..
using a struct with a fixed length buffer for a cString would make your life easy

johnwasser · February 23, 2022, 3:00pm

You can avoid String completely:

  char servicePath[150];
  for (size_t i = 0; i < 150; i++)
  {
    servicePath[i] = EEPROM.read(addr_espPathService + i);
  }
  strcat(servicePath, "?upit=ssid&id=2");
  Serial.println(servicePath);
  if (http.begin(client, servicePath))
  {
  }

J-M-L · February 23, 2022, 3:05pm

better use

  strlcat(servicePath, "?upit=ssid&id=2", 150);

to avoid buffer overflow (in case the EEPROM stuff was really long)

gfvalvo · February 23, 2022, 3:07pm

johnwasser:

You can avoid String completely:

  char servicePath[150];
  for (size_t i = 0; i < 150; i++)
  {
    servicePath[i] = EEPROM.read(addr_espPathService + i);
  }
  strcat(servicePath, "?upit=ssid&id=2");
  Serial.println(servicePath);
  if (http.begin(client, servicePath))
  {
  }

That works if the char string read from EEPROM contains a NULL before reaching the end of they 150 bytes in the 'for' loop. scrcat() will use that NULL as the starting point for concatenation. If that's the case, why read all 150 bytes at all? 'break' the loop after the NULL is read and stored in 'servicePath'.

J-M-L · February 23, 2022, 3:18pm

yep.. so may be more like

  char servicePath[150];
  servicePath[149] ='\0'; // just to be on the "safe" side
  for (size_t i = 0; i < 149; i++)  {
    servicePath[i] = EEPROM.read(addr_espPathService + i);
    if (servicePath[i] == '\0') break;
  }
  strlcat(servicePath, "?upit=ssid&id=2",150);
  Serial.println(servicePath);
  if (http.begin(client, servicePath)) {
  }

PaulRB · February 23, 2022, 4:03pm

You don't want to add the null char to the String...

String servicePath ;
char readChar;
for (int r = addr_espPathService; r < addr_espPathService + 150; ++r){
    readChar = char(EEPROM.read(r));
    // stop after first if you use zero terminated string
    if (readChar == 0x00 ) break;
    else servicePath += readChar;
  }

J-M-L · February 23, 2022, 5:05pm

use reserve to avoid constantly growing your String in the heap and copy operations

String servicePath ;
char readChar;
servicePath.reserve(150);
for (uint16_t r = addr_espPathService; r < addr_espPathService + 150; ++r){
    readChar = EEPROM.read(r);
    // stop after first if you use zero terminated string
    if (readChar == 0x00 ) break;
    else servicePath += readChar;
  }

who_took_my_nick · February 24, 2022, 10:28am

You guys rock!!!

I used this last example, although all work as well. Tried all of this here.

One last thing.
There is an additional problem that came across. I can collect the data from the server and while replacing some of them in the EEPROM, others are erased.

The structure of the EEPROM I made in this case is:

int addr_espID = 0;
int addr_espSSID = 50;
int addr_espPASS = 100;
int addr_espPATH = 200;
int addr_espPathService = 350;

So, when I write this SSID, it somehow erases everything from the addr_espSSID till the end.


for (int y = addr_espSSID; y < 99; y++ ){
            EEPROM.write(y, 0);
            EEPROM.commit();
            }
          for (int i = 0; i < payload.length(); i++) { 
             EEPROM.write(addr_espSSID + i, payload[i]); //addr_espSSID
             EEPROM.commit();
          }

This should erase only from 50 to 99, and write only from 50 until the payload.length(). In my case, it is 8. So it should write from 50 to 57. What am I doing wrong?

J-M-L · February 24, 2022, 11:09am

prove to yourself that payload.length() is actually 8 by printing it
what's the payload type ?
(posting snippets does not help provide good advice ➜ Snippets R Us!)

who_took_my_nick · February 25, 2022, 2:30pm

Sry,

Yes, I am sure it is, say 8. It could be more. Depends on the SSID name in this case.

--
String payload;
--
  void getNewCredentials(){
    WiFiClient client;
    HTTPClient http;
    Serial.print("[HTTP] begin...\n");
String serverPathService = servicePath+"?upit=ssid&id=2";
    Serial.println(serverPathService);
    if (http.begin(client, serverPathService.c_str())) {  // HTTP
      Serial.print("[HTTP] GET...\n");
      int httpCode = http.GET();
      if (httpCode > 0) {
        Serial.printf("[HTTP] GET... code: %d\n", httpCode);
        if (httpCode == HTTP_CODE_OK || httpCode == HTTP_CODE_MOVED_PERMANENTLY) {
          payload = http.getString();
          Serial.print("ESP ssid: ");
          Serial.println(payload);
          Serial.print("Length: ");
          Serial.println(payload.length());
          for (int y = addr_espSSID; y < 99; y++ ){
            EEPROM.write(y, 0);
            EEPROM.commit();
            }
          for (int i = 0; i < payload.length(); i++) { 
             EEPROM.write(addr_espSSID + i, payload[i]); //addr_espSSID
             EEPROM.commit(); 
          }
        }
      } else {
        Serial.printf("[HTTP] GET... failed, error: %s\n", http.errorToString(httpCode).c_str());
      }
      http.end();
     
    } else {
      Serial.printf("[HTTP} Unable to connect\n");
    }
  }

Here is the whole code that I use for downloading a new SSID and writing it in the EPROM.

who_took_my_nick · February 26, 2022, 12:53pm

This:

for (int y = 0; y < 49; y++ ){
            EEPROM.write(50+y, 0);
            EEPROM.commit();
            }

erases everything from 50 till the end. With barebone sketch. How to erase only a part from an EEPROM?

UKHeliBob · February 26, 2022, 3:40pm

You cannot actually erase the values in the EEPROM, only write a value of your choice to a range of locations of your choice

So, use a for loop whose value is from the first to last address of your choice and write a value of your choice to each EEPROM location in that range. From your use of EEPROM.commit() I assume that you are not using an AVR based Arduino board

Example

for (int currentLocation = firstLocation; currentLocation <= lastLocation; currentLocation++)
{
  EEPROM.write(currentLocation, yourValue);
}
EEPROM.commit();

who_took_my_nick · February 26, 2022, 4:05pm

That is fine.

But, what are the differences between your and mine examples?
In my example, it should erase everything between 50 and 100. Isn't it?

cattledog · February 26, 2022, 5:13pm

Please post that barebones sketch so that we may test on our hardware.

Topic		Replies	Views
EEPROM Strings Programming	4	2353	May 6, 2021
Write and Read the Arduino EEPROM Programming	4	728	May 5, 2021
write and read char to/from EEPROM doesn´t work Programming	4	688	May 5, 2021
How to put data from eeprom into a char variable Programming	4	2349	May 5, 2021
conversion from 'char' to 'String' is ambiguous Programming	3	7805	May 5, 2021

String, char, etc

Related topics