Here's the example data I've read in H-Term:

G:   5.97kg\r\n    
T:   0.00kg\r\n    
N:   5.97kg\r\n

How to save the number including "kg" to each variable (NO, G, T, N)?

  • so you need to save strings? Jan 30 '19 at 8:49
  • yes, i need to save that into 4 variable represent each line
    – El Kazma
    Jan 30 '19 at 10:11
  • what did you try?
    – Juraj
    Jan 30 '19 at 12:39

This is an overly broad question which borders "write me the code" - this isn't a coding service - and if anything belongs on StackOverflow since it regards processing. That being said, this question would be flagging as overly broad there too.

I'm providing an answer because I believe it may help others here as it speaks to some fundamental programming concepts. This is not a perfect solution by any means, for example it doesn't take program size into account. See the end of the post for a sketch.

There are two main problems you face:

  1. Model the input data
  2. Process the data

Modeling the input data means structuring your expected input in a meaningful way. Looking at the input data provided, I see this format

  • 0-N chars indicate some metadata delimited by a colon (:)
  • 0-N white space
  • 0-N digits with optional decimal point (0015,5.97)
  • 0-N unit designation (kg)
  • data is delimited with a CRLF (\r\n)

Now think of each line as a packet of information. In that sense, let's create some data structures that describe the data of the packet.

// Types
typedef enum {
} Type;

// Units
typedef enum {
  uKg, // kilogram
  uG,  // gram
} Unit;

// Values - unions are handy to model variants.
typedef union {
  char str[5];
  float dval;
} Value;

Given the basics above, let's model a Packet:

// the data model for a CRLF delimited packet
typedef struct {
  Type type;
  Value value;
  Unit unit;
  byte valid;
  // metadata
  byte expectUnit; // 1 if a Value has a Unit; 0 otherwise.

} Packet;

OK, so that's a basic model of the input data. How to process? Always break down big problems to the smaller, manageable units to provide a solution.

Now there's a huge number of possibilities to parse/interpret your data packets. I am providing a bare bones, brute force approach that you may learn from, and hopefully improve upon. For example I am not providing much in the way of array overruns which can crash a program.

Here's the main processing function, which takes a string of input data (a line) and produces a Packet. In all I am only going to provide for the Type 'G' and leave the rest to you.

// readPacket processes the input string pszBuffer and fills pPacket accordingly.
// pszBuffer should be a string of characters delimited by \r\n.
// pPacket is a pointer to a Packet which is filled by this function.
// returns 1 if packet is valid, 0 otherwise.    
byte readPacket(Packet* pPacket, const char* pszBuffer) {
  byte isvalid = 0;
  if (pszBuffer && pPacket) {
    char tmp[10];
    char* psz = (char*)pszBuffer;
    char* pszTmp = 0;
    byte len = 0;
    // initialize packet
    pPacket->type = Type::NoType;
    pPacket->unit = Unit::NoUnit;
    pPacket->valid = 0;
    pPacket->expectUnit = 0;
    // get the Type
    psz = processType(pPacket, psz);
    if (psz) {
      // skip any space characters now.       
      psz = trimLeadingSpaces(psz);
      psz = processValue(pPacket, psz);     
      // if Type handled, check units and finish.
      if (psz) {
        if (pPacket->expectUnit)
          pPacket->valid = processUnit(pPacket, psz);
          pPacket->valid = 1;

    } // Type not found

    isvalid = pPacket->valid;
  return isvalid;

OK that's not a lot. The logic is

  • Get the packet Type
  • IFF a packet Type was found, get the packet Value
  • IFF a value was found, get the Unit if required

It's important to breakdown these steps in smaller, manageable functions. First, the code for getting the packet Type.

// processType
// Sets pPacket->type to the type found in psz.  Type is delimited by a colon (:)
// Returns 0 (null) if a known Type wasn't found.
// Otherwise a ptr to the data past colon delimiter.
char* processType(Packet* pPacket, const char* psz) {
  // find the colon (:) delimiter and return what it leads to.
  byte len = 0;

  char* ptr = strchr((char*)psz, ':');
  char* pResult = 0;
  if (ptr) {
    // found the colon.
    char buffer[4];
    byte len = (ptr - psz) / sizeof(char); // pointer math to find length.    
    strncpy(buffer, psz, len);
    // null term buff
    buffer[len] = 0;
    // assume succcess; default will rest to fail.      
    pResult = (char*)psz + len + 1; // +1 to skip colon character.
    switch (buffer[0]) {
    case 'G':
      pPacket->type = Type::G;
      pPacket->expectUnit = 1; // unit should be given.
      pPacket->type = Type::NoType;
      pResult = 0; // fail, didn't find a known type.

  return pResult;

So processType sets up the packet Type and adds information about whether to look for Unit information later.

If processType() found a valid Type, the next step is to get the value based in that type with the function processValue

// Sets pPacket->value according to the packet Type.
// Returns null (0) if type not supported or value not found,
// otherwise a pointer to the remaining characters following the value handled.
char* processValue(Packet* pPacket, const char* psz) {
  char* ptr = 0;
  // value is construed by Type
  switch (pPacket->type) {
  case Type::G:
    ptr = processFloat(pPacket, psz);
    // add your additonal Type implementations...
    // invalid, set psz to null.
    ptr = 0;
  return ptr;

Great. Now, let's look at a way to get the value for a float:

// Sets pPacket->value.dval 
// Returns 0 (null) if a value wasn't found.
// Otherwise a ptr past the last character of the decimal value.
char* processFloat(Packet* pPacket, const char* psz) {
  const char *float_chars = ".0123456789";
  char* ptr = (char*)psz;
  if (ptr) {
    // scan ptr until we don't find a match.
    byte index = 0;
    while (strchr(float_chars, (char)ptr[index]))

    if (index) {
      //  get the float using a temporary buffer.
      //  dangerous! assuming this will not overrun!
      char buf[10];
      strncpy(buf, ptr, index);
      // null term buff
      buf[index] = 0;
      pPacket->value.dval = atof(buf);
      // advance ptr past the decimal characters for return valie.
      ptr += index;
    else ptr = 0; // fail
  return ptr;

Finally if all went well, the code should look for the Unit if expected (based on the Type)

// Sets pPacket->unit to the unit given in psz.
// Returns 0 if no unit was found, non-zero otherwise.
byte processUnit(Packet* pPacket, const char* psz) {
  pPacket->unit =  Unit::NoUnit;
  if (psz) {
    switch ((char)*psz) {
    case 'k':
      pPacket->unit = Unit::uKg;
    case 'g':
      pPacket->unit = Unit::uG;
      break; // unit initialized to NoUnit.
  return pPacket->unit != Unit::NoUnit;

Here's a GIST of an arduino sketch using the code above.

Good luck, hope this helps. In the future, pose questions regarding processing on StackOverflow.

Not the answer you're looking for? Browse other questions tagged or ask your own question.