Storing byte array from serial and converting to a floating point number
Two things I see wrong:


  Serial1.write('O');                                            //Send command 'A' to device *noting Serial1 not Serial


No, you send O not A... ???


  for(int n = 0; Serial1.available() &lt; 8; n++)                   


While there are less than 8 bytes available in the buffer read one. 

Erm...  The buffer starts off empty - empty is less than 8. It remains empty (always less than 8) until a byte finally arrives. Then it's still less than 8. I can't really see this ever working, and your array will overflow instantly and clobber the entirety of the rest of your RAM. I guess it finally finished when the serial object itself gets clobbered and available() returns some garbage number. In the meantime your array is just full of nothingness.

You need to completely rewrite that whole section. The simplest way is to wait until there are 8 bytes in the buffer (which will take some time - serial is slooooow):

while (Serial1.available() &lt; 8);


You now have 8 bytes available to read, so you can go ahead and read them.

A better way is to look to see if there is at least one byte available, then read it into the right place in your array - and keep count of how many bytes you have read:

int n = 0;
while (n &lt; 8) {
    if (Serial1.available()) {
        incomingByteA[n++] = Serial1.read();
    }
}


Of course, it's better to add some form of timeout in there too - so if nothing arrives soon enough your program doesn't lock up - or if you miss a byte it doesn't get completely out of sync. Also purging your read buffer before sending the command can help to prevent sync issues:

// Purge any old data
while (Serial1.available()) {
    Serial1.read();
}

Serial1.write('A');

int n = 0;
uint32_t start = millis();
while (n &lt; 8) {
    // 1 second timeout
    if (millis() - start &gt; 1000) {
        break;
    }
    if (Serial1.available()) {
        incomingByteA[n++] = Serial1.read();
    }
}

if (n == 8) {
    // We got the data - do something with it
} else {
    // It timed out
}


Now when it comes to converting to a pair of floats there's better ways than your byte-wise manipulation.  For instance, you could use a union:

union FloatPair {
    struct {
        float a;
        float b;
    };
    char bytes[8];
} __attribute__((packed));

FloatPair data;


Now you can use:

data.bytes[n]


to access the memory directly, and

data.a;
data.b;


to access the float values.

You can also do something similar with casting:

struct FloatPair {
    float a;
    float b;
};

FloatPair data;

char *bytes = (char *)&amp;data;


bytes is now a byte-wise view of the memory used by a pair of floats.

You can even work the other way around:

char data[8] __attribute__((aligned(4)));


The aligned attribute will force the address of the array to be on a 4-byte boundary. Not important for a little 8-bitter, but vital if you ever port to a 32-bit MCU since a float always has to be on a 4-byte boundary, so a good habit to get into.

Now you can map floats into that memory space:

float *a = (float *)(&amp;data[0]);
float *b = (float *)(&amp;data[4]);


and access the floats as *a and *b. The * dereferences the pointers back into real numbers.

One thing to note: these methods all depend on the endianness of your data matching the endianness of your MCU - if they differ then you will have no choice but to do it all with manual byte-wise mapping.