How to send data in little endian order C

Question

I am communicating with a board that requires I send it 2 signed byte.

explaination of data type
what I need to send

Would I need to bitwise manipulation or can I just send 16bit integer as the following?

int16_t rc_min_angle = -90; 
int16_t rc_max_angle = 120;

write(fd, &rc_min_angle, 2); 
write(fd, &rc_max_angle, 2);

Answer 1

int16_t has the correct size but may or may not be the correct endianness. To ensure little endian order use macros such as the ones from endian.h:

#define _BSD_SOURCE
#include <endian.h>

...

uint16_t ec_min_angle_le = htole16(ec_min_angle);
uint16_t ec_max_angle_le = htole16(ec_max_angle);

write(fd, &ec_min_angle_le, 2);
write(fd, &ec_max_angle_le, 2);

Here htole16 stands for "host to little endian 16-bit". It converts from the host machine's native endianness to little endian: if the machine is big endian it swaps the bytes; if it's little endian it's a no-op.

Also note that you have you pass the address of the values to write(), not the values themselves. Sadly, we cannot inline the calls and write write(fd, htole16(ec_min_angle_le), 2).

Answer 2

If endian functions are not available, simply write the bytes in little endian order.

Perhaps with a compound literal.

//         v------------- compound literal ---------------v
write(fd, &(uint8_t[2]){rc_min_angle%256, ec_min_angle/256}, 2);
write(fd, &(uint8_t[2]){rc_max_angle%256, ec_max_angle/256}, 2);
//                      ^-- LS byte ---^  ^-- MS byte ---^
//        &

I added the & assuming the write() is a like write(2) - Linux.

Answer 3

If you don't need to have it type-generic, you can simply do:

#include <stdint.h>
#include <unistd.h>

/*most optimizers will turn this into `return 1;`*/
_Bool little_endian_eh() { uint16_t x = 1; return *(char *)&x; }

void swap2bytes(void *X) { char *x=X,t; t=x[0]; x[0]=x[1]; x[1]=t; }

int main()
{
    int16_t rc_min_angle = -90; 
    int16_t rc_max_angle = 120;

    //this'll very likely be a noop since most machines
    //are little-endian
    if(!little_endian_eh()){
        swap2bytes(&rc_min_angle);
        swap2bytes(&rc_max_angle);
    }

    //TODO error checking on write calls
    int fd =1;
    write(fd, &rc_min_angle, 2); 
    write(fd, &rc_max_angle, 2);
}

Answer 4

To send little-endian data, you can just generate the bytes manually:

int write_le(int fd, int16_t val) {
    unsigned char val_le[2] = {
      val & 0xff, (uint16_t) val >> 8
    };

    int nwritten = 0, total = 2;
    while (nwritten < total) {
      int n = write(fd, val_le + nwritten, total - nwritten);
      if (n == -1)
        return nwritten > 0 ? nwritten : -1;
      nwritten += n;
    }
    return nwritten;
}

A good compiler will recognize that the code does nothing and compile the bit manipulation to no-op on a little-endian platform. (See e.g. gcc generating the same code for the variant with and without the bit-twiddling.)

Note also that you shouldn't ignore the return value of write() - not only can it encounter an error, it can also write less than you gave it to, in which case you must repeat the write.