How does the EEPROM store int and char ?

Projects General Guidance
1

I have a PC based App send in some data to my MEGA 2560 via Serial 1.

All good there and I am getting this into the MCU and then storing to EEPROM. The sample data is as below :

<C,1000,PU,4375,200,9375,HL,4375,400,0,PD,2500,200,9375,HL,2500,400,0,NU,625,200,9375,HL,625,400,0,ND,2500,200,9375,HL,2500,400,0,E>

Now I have defined the EEPROM storage space as all “int “ variables. So when I read back I am reading all numeric perfectly, but the Characters like C, PU etc are just reading zero. How to get the characters right.

For information I have given the code that stores the received characters on to the EEPROM below. I am not sure if this code needs to be corrected ?

while ((parsedMsg = strtok(NULL, ",")) != NULL) {
      editParam[paramCount] = atoi(parsedMsg);
      paramData = editParam[paramCount];  // paramData has now the next data in the array
      EEPROM.put(eeAddress, paramData);   // Save it to EEPROM
      eeAddress += sizeof(int);           // Incrememnt for the next data
      paramCount = paramCount + 1;
    }
2

If you want to store and retrieve char data then you probably need to define that part of the eeprom as holding char data. It's been a while but it's just a structure I think.

3

Easiest method is to have a struct that holds all the character and numeric variables, then use put() to store the entire struct to EEPROM.

4

The PU token is a string. How can you apply atoi() on it? You can't. For example:

char str[] = "C, 1000";
char delim[] = ",";
char *token;

token = strtok(str, delim);
Serial.println(atoi(token)); //shows: 0 because C is not a decimal digit
Serial.println(token); //shows: C
//---------------------------
token = strtok(NULL, delim); 
Serial.println(atoi(token)); //shows: 1000

You need to seperate the integer type tokens from that of the string type tokens using if-else structure.

5

That will make sense, and your question will be easiest to answer if you post the code.

EEPROM is addressed as bytes at the low level. Any other interpretation of stored bytes is up to you.

There are some functions for integers, I think.

Using struct (structured variable) has been mentioned. I mention it again.

a7

6

As @david_2018 suggests the optimum way of handling complex eeprom storage is to put all the data into a struct and store that. You may be able to send a struct from the pc, but the issues of cross platform compatibility may be troublesome.

Your issue is indeed the parsing of the input character string into the variables of the struct for storage. Your approach using strtok on the comma and then using either atoi or strcpy on the pieces should work.

<C,1000,PU,4375,200,9375,HL,4375,400,0,PD,2500,200,9375,HL,2500,400,0,NU,625,200,9375,HL,625,400,0,ND,2500,200,9375,HL,2500,400,0,E>

Can you explain to what variables you would assign the numbers and letters of the input string? What do you do with the data when you retrieve it from the EEPROM?

7

Additional question - can the line be presented with the tokens, and their values, in any order? Or can you be guaranteed the line will be as shown, in the order shown? Because it changes parsing a lot, if you have to read the token to decide which variable to write.

8

In programming, char is a single character. I see C at the beginning and E at the end. But all the ones in the middle have two characters: PU, HL, etc.

If they're all that short, the text can be encoded as a number. On AVR boards like Mega, an int is two bytes, so up to 32767 for a signed integer. If the numeric values are non-negative, that means you can use the sign bit to indicate the encoding of two 7-bit ASCII values in the same two bytes. So you use EEPROM to store/retrieve all as int, and then encode/decode appropriately.

ETA: 26 letters fit into five bits, so if it's just (case-insensitive) letters, you can squeeze three plus the sign bit into two bytes.

9

@Ardubit

Please, post your whole sketch so that it is possible to know the usage of your tokens and how you are saving them into EEPROM and retrieve.

10

I have gone through all the responses and thank each one of you for taking time to help !! I will now try and address all your queries in this reply to the extent possible :

The string that you see defines one complete pressure profile for one cycle and has these parts :

  1. C : Cycles . Other option is H for hours to execute
  2. 1000 : Number of Cycles to execute
  3. PU : Positive Up Ramp
  4. 4375 : End voltage of 4.375 at the end of Ramp
  5. 200 : Number of 5ms loops to execute
  6. 9375 : 0.009375 V to increment for each scan. ( Being BiPolar 2.5V is the Zero base )
  7. HL : Hold at the end of Ramp
  8. PD : Positive Down Ramp
  9. NU: Negative Up Ramp
  10. ND : Negative down ramp
  11. E : End of the cycle.

You should now get an idea of teh string … the cycle pattern is very random and the user will anyway break it down to up and down ramps and enter the values in the PC application which will then transfer the above string to the MCU.

The MCU then executes the pattern using a switch case for PU/PD/HL/NU/ND and using the number of scans and volt/scan input to generate the pattern.

I thought about the Structure but then the number of sequences per cycle is open ended and can be simple as above and get very complex. So I thought its better to have a uniform storage pattern for the EEPROM but in this process missed out the Char aspect.

If I were to avoid mixing up data types can I use the INT as the only type and cast the characters like C/PU/HL/PD/NU/ND/E to unique integers as 1/2/3/4/5/6/7 . These single digits can never be part of any sequence as all single precision voltage values are multiplied by 100 to convert to int and transmitted. I think that will be the easy way out ??

11

If you sepertae the numeric tokens (1000, 4375, …) from that of the alphabetic/string type tokens (C, PU, …), will it work? Save the tokens in their respective arrays, store them in EEPROM, retrieve them from EEPROM, and then use them.

String tokens:
C
PU
HL
PD
HL
NU
HL
ND
HL
E

Integer tokens:
1000
4375
200
9375
4375
400
0
2500
200
9375
2500
400
0
625
200
9375
625
400
0
2500
200
9375
2500
400
0
12

Sure, although "cast" has a specific meaning in C/C++, so maybe "translate" or "convert" instead. I do see zero as a numeric value.

You could use negative integers to have better separation. And there are plenty of them, so maybe -1 to -3 for E, C, H. -10 and so on for the two-letter ones, or start at -20 or -100, however you want to divide up the functionality.

13

Sorry about the word “cast” used casually here !!

Yes I will try and use negative single digit numbers to make them unique ! And go back to my original plan of saving all the parts of the sequence as only INT variables.