user52168: Using Seed studio CAN shield to read and convert CAN data to dec value.
Example of expected result: 
Full CAN message is 70 3B F1 FF 00 00 00 00 , using little endian first 4 bytes gives: FFF13B70 , which should be equal to converted dec value of -0.967824 (using factor of 0.000001).
Here is code to extract the text value I am using. 
CAN.readMsgBuf(&len, buf);
unsigned char len = 0;
unsigned char buf[8];
    {
           String reg0 = String (buf[0], HEX);
           String reg1 = String (buf[1], HEX);
           String reg2 = String (buf[2], HEX);   
           String reg3 = String (buf[3], HEX);
           Serial.print(reg3);
           Serial.print("\t");
           Serial.print(reg2);
           Serial.print("\t");
           Serial.print(reg1);
           Serial.print("\t");
           Serial.print(reg0);
           Serial.print("\t");
           String regsumm = (reg3 + reg2 + reg1 + reg0);

           Serial.println(regsumm);
        }

As result I got only text string which couldn't be converted into dec. Any other ways how do it?

user4143: You have taken completely the wrong tack. You don't want to convert your data into text and then convert it back into data again - it's already data.
You can combine your first four buffer bytes into a single 32-bit signed integer with just:
int32_t val = ((int32_t)buf[3] << 24) | ((int32_t)buf[2] << 16) | 
              ((int32_t)buf[1] << 8) | (int32_t)buf[0];

That gives you the value -967824, which is 0xFFF13B70 in hex notation, or 11111111 11110001 00111011 0111000 in binary.  All of them are the same thing and are just a number.
You can then multiply that result by your "factor" into a float variable:
float dec = val * 0.000001;

Chances are it won't give you -0.967824 due to the nature of floating point values, so you may be better off keeping it as -967824 and working in "micro-units" instead of "units".

user7508: Since the bytes you received in the buffer are in little endian order,
and your Uno is itself little endian, you don't even need to move bytes
around: you can just reinterpret the bytes you already have as an
int32_t:
union {
    uint8_t bytes[8];
    int32_t numbers[2];
} buffer;
unsigned char len = 0;

CAN.readMsgBuf(&len, buffer.bytes);
Serial.println(buffer.numbers[0] * 1e-6, 6);

This prints -0.967824 to the serial port.
Note that this code will not work as expected on a big endian platform.
If you want something portable, the usual solution is to build the
result using bit shifts, as in Majenko's answer.

52168: <p>Using Seed studio CAN shield to read and convert CAN data to dec value.</p>

<p>Example of expected result: </p>

<p>Full CAN message is 70 3B F1 FF 00 00 00 00 , using little endian first 4 bytes gives: FFF13B70 , which should be equal to converted dec value of -0.967824 (using factor of 0.000001).</p>

<p>Here is code to extract the text value I am using. </p>

<pre><code>CAN.readMsgBuf(&amp;len, buf);
unsigned char len = 0;
unsigned char buf[8];
    {
           String reg0 = String (buf[0], HEX);
           String reg1 = String (buf[1], HEX);
           String reg2 = String (buf[2], HEX);   
           String reg3 = String (buf[3], HEX);
           Serial.print(reg3);
           Serial.print("\t");
           Serial.print(reg2);
           Serial.print("\t");
           Serial.print(reg1);
           Serial.print("\t");
           Serial.print(reg0);
           Serial.print("\t");
           String regsumm = (reg3 + reg2 + reg1 + reg0);

           Serial.println(regsumm);
        }
</code></pre>

<p>As result I got only text string which couldn't be converted into dec. Any other ways how do it?</p>
 4143: <p>You have taken completely the wrong tack. You don't want to convert your data into text and then convert it back into data again - it's already data.</p>

<p>You can combine your first four buffer bytes into a single 32-bit signed integer with just:</p>

<pre><code>int32_t val = ((int32_t)buf[3] &lt;&lt; 24) | ((int32_t)buf[2] &lt;&lt; 16) | 
              ((int32_t)buf[1] &lt;&lt; 8) | (int32_t)buf[0];
</code></pre>

<p>That gives you the value -967824, which is 0xFFF13B70 in hex notation, or <code>11111111 11110001 00111011 0111000</code> in binary.  All of them are the same thing and are just a number.</p>

<p>You can then multiply that result by your "factor" into a float variable:</p>

<pre><code>float dec = val * 0.000001;
</code></pre>

<p>Chances are it won't give you -0.967824 due to the nature of floating point values, so you may be better off keeping it as -967824 and working in "micro-units" instead of "units".</p>
 7508: <p>Since the bytes you received in the buffer are in little endian order,
and your Uno is itself little endian, you don't even need to move bytes
around: you can just reinterpret the bytes you already have as an
<code>int32_t</code>:</p>

<pre><code>union {
    uint8_t bytes[8];
    int32_t numbers[2];
} buffer;
unsigned char len = 0;

CAN.readMsgBuf(&amp;len, buffer.bytes);
Serial.println(buffer.numbers[0] * 1e-6, 6);
</code></pre>

<p>This prints <code>-0.967824</code> to the serial port.</p>

<p>Note that this code will not work as expected on a big endian platform.
If you want something portable, the usual solution is to build the
result using bit shifts, as in Majenko's answer.</p>
