user53504: Here's the example data I've read in H-Term:
\r\n
\r\n
NO:0015\r\n    
G:   5.97kg\r\n    
T:   0.00kg\r\n    
N:   5.97kg\r\n
\r\n
\r\n

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

user34401: 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:

Model the input data
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 {
  NoType,
  NO,
  G,
  T,
  N,
} Type;

// Units
typedef enum {
  NoUnit,
  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);
        else
          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.
      break;
    default:
      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);
    break;
    //
    // add your additonal Type implementations...
    //
  default:
    // 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]))
      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;
      break;
    case 'g':
      pPacket->unit = Unit::uG;
      break;
    default:
      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.

53504: <p>Here's the example data I've read in H-Term:</p>

<pre><code>\r\n
\r\n
NO:0015\r\n    
G:   5.97kg\r\n    
T:   0.00kg\r\n    
N:   5.97kg\r\n
\r\n
\r\n
</code></pre>

<p>How to save the number including "kg" to each variable (NO, G, T, N)?</p>
 34401: <p>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. </p>

<p>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.</p>

<p>There are two main problems you face:</p>

<ol>
<li>Model the input data</li>
<li>Process the data</li>
</ol>

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

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

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

<pre><code>// Types
typedef enum {
  NoType,
  NO,
  G,
  T,
  N,
} Type;

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

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

<p>Given the basics above, let's model a Packet:</p>

<pre><code>// 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;
</code></pre>

<p>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.</p>

<p>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.</p>

<p>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.</p>

<pre><code>// 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 &amp;&amp; pPacket) {
    char tmp[10];
    char* psz = (char*)pszBuffer;
    char* pszTmp = 0;
    byte len = 0;
    // initialize packet
    pPacket-&gt;type = Type::NoType;
    pPacket-&gt;unit = Unit::NoUnit;
    pPacket-&gt;valid = 0;
    pPacket-&gt;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-&gt;expectUnit)
          pPacket-&gt;valid = processUnit(pPacket, psz);
        else
          pPacket-&gt;valid = 1;
      }

    } // Type not found

    isvalid = pPacket-&gt;valid;
  }
  return isvalid;
}
</code></pre>

<p>OK that's not a lot.  The logic is</p>

<ul>
<li>Get the packet Type</li>
<li>IFF a packet Type was found, get the packet Value</li>
<li>IFF a value was found, get the Unit if required</li>
</ul>

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

<pre><code>// processType
// Sets pPacket-&gt;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-&gt;type = Type::G;
      pPacket-&gt;expectUnit = 1; // unit should be given.
      break;
    default:
      pPacket-&gt;type = Type::NoType;
      pResult = 0; // fail, didn't find a known type.
    }
  }

  return pResult;
}
</code></pre>

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

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

<pre><code>// Sets pPacket-&gt;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-&gt;type) {
  case Type::G:
    ptr = processFloat(pPacket, psz);
    break;
    //
    // add your additonal Type implementations...
    //
  default:
    // invalid, set psz to null.
    ptr = 0;
  }
  return ptr;
}
</code></pre>

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

<pre><code>// Sets pPacket-&gt;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]))
      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-&gt;value.dval = atof(buf);
      // advance ptr past the decimal characters for return valie.
      ptr += index;
    }
    else ptr = 0; // fail
  }
  return ptr;
}
</code></pre>

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

<pre><code>// Sets pPacket-&gt;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-&gt;unit =  Unit::NoUnit;
  if (psz) {
    switch ((char)*psz) {
    case 'k':
      pPacket-&gt;unit = Unit::uKg;
      break;
    case 'g':
      pPacket-&gt;unit = Unit::uG;
      break;
    default:
      break; // unit initialized to NoUnit.
    }
  }
  return pPacket-&gt;unit != Unit::NoUnit;
}
</code></pre>

<p>Here's a <a href="https://gist.github.com/TennesseeJed/980dbc68aa2e0002399e35c81ef8c0eb" rel="nofollow noreferrer">GIST</a> of an arduino sketch using the code above.</p>

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