Mfcttrf

I have created myJSON library to simplify read and write values from/ to FLASH of my ESP8266 NodeMCU/ Wemos Mini.

I do not want to "mess up" the question, posting my entire code/ library - but to try to explain what happens -

I get a 0 value when reading a specific key (and not its saved value ). My assumption is that is has nothing to do with myJSON library, but my understanding in returning a value from a function.

Code is as follows:

(some explanations first):

1) json is an instance of myJSON library.

2) json.setValue(key, value) - gets a key and a value ( char/ int) and save it to FLASH.

3)json.getINTValue(key, return_var)- gets a key and return its int value to return_var. function return 1 - for successful read, and 0 when not.

inside setup()

int int_val;
// json.setValue("int_key",343); // commented out after first run - to be sure is is saved and read from flash.
Serial.println(json.getINTValue("int_key",int_val)); // NOTE 2
Serial.print("Value is: "); // NOTE 3
Serial.println(int_val); // NOTE 3

myJSON ( only relevant code )

bool myJSON::getINTValue (const char *key, int retval)
 StaticJsonDocument<DOC_SIZE> tempJDOC;
 myJSON::readJSON_file(tempJDOC);
 bool hasKey = tempJDOC.containsKey(key);
 if (hasKey)
 retval = tempJDOC[key];
 Serial.print("retval :"); // NOTE 1
 Serial.println(retval); // NOTE 1
 return 1;
 
 else 
 return 0; // when key is not present
 


void myJSON::setValue(const char *key, char *value)
 StaticJsonDocument<DOC_SIZE> tempJDOC;
 myJSON::readJSON_file(tempJDOC);
 tempJDOC[key]=value;
 myJSON::saveJSON2file(tempJDOC);

void myJSON::setValue(const char *key, int value)
 StaticJsonDocument<DOC_SIZE> tempJDOC;
 myJSON::readJSON_file(tempJDOC);
 tempJDOC[key]=value;
 myJSON::saveJSON2file(tempJDOC);

result is (SEE NOTATIONS):

21:01:03.198 -> retval :343 // OUTPUT NOTE 1
21:01:03.198 -> 1 // OUTPUT NOTE 2 
21:01:03.198 -> Value is: 0 // OUTPUT NOTE 3

As far a I could understand :

1) setValue works as needed ( inc. saving to flash ).
2) unexplained besides getting value = 0, is when setting a char value ( there are 2 myJSON::setValue functions to deal with int and char), code works as needed.

Appreciate any help ( and sorry for my English ).

Guy

the parameters of a function call are copied into parameters in the function. if the pointer is copied it still points to a memory where you write the data. if int is copied then changing the value changes the copy, not the variable used as parameter. reference is kind of pointer

how to make an in-out parameter by passing a parameter by reference

void setup() 

 Serial.begin(115200);
 int x = 3;
 fnc(x);
 Serial.println(x);


void loop() 



void fnc(int &x) 
 x = 5;

prints 5

example with a complex type

#include <IPAddress.h>

void setup() 

 Serial.begin(115200);
 IPAddress ip(192, 168, 1, 5);
 fnc(ip);
 Serial.println(ip);


void loop() 



void fnc(IPAddress& ip) 
 ip = IPAddress(192, 168, 1, 3);

with &ip it prints 192.168.1.3. without & it prints 192.168.1.5

Your problem is not directly how to return a variable, but how to give a variable from outsite the function as parameter to be filled by the function. There are basically 2 types how you can give a variable to a function: by value or by reference

The definition of getINTValue() says

getINTValue (const char *key, int retval)

so retval will be an integer and is called by value. This means, that a local variable with that name is created and filled with the value from the function call parameters. You are writing to this variable, but it get's thrown away when the function returns. And the writing to the local variable didn't change the outsite variable.

You need to use a call by reference. Your function must take a pointer to an integer variable. Then you dereference it and write to it:

getINTValue (const char *key, int *retval)
 ...
 *retval = tempJDOC[key];
 ...

When you call the getINTValue() function, it must be done like this:

int value;
bool result = getINTValue("int_key", &value);

The & operator gets you the pointer to the variable value, which the function then uses to write a value at that memory location.

char* is different, because you give an array to the function in this case. The compiler sees, that the used variable is an array and uses the pointer to the first element of the array as parameter. That is a common way, because you can iterate over an array by using pointers (without index numbers). You can do the same with any array of any type, but in this case you only have a single variable, not an array.