Serialize internal variables to i2c

Question

I'm currently working on creating an I2C network between a few microcontrollers (Atmega32), For start I'm just trying to interface it between a slave and master. I have a sensor connected to the slave which gives me data in an unsigned int format but the data transmission happens in unsigned char format.

I'm not able to figure out how to transmit data which I get in an unsigned int format in a network which works in an unsigned char format.

Any sort of help would be helpful.

Answer 1

Divide Decimal number by 2 until it becomes 0 and save each divisions remainder in an array & reverse the array to get the Binary number of that decimal number. Suppose your decimal number is 7.

7/2=3 remainder=1
3/2=1 remainder=1
1/2=0 remainder=1

So array=11100000
After reverse binary is= 00000111

In c it will be like this:

int des=7,binary[8],indexNo=0;
while(des!=0)
{
    binary[indexNo]=des%2;
    des/=2;
    indexNo++;
}
now inverse the binary[] or you can directly start indexNo from last index
(Ex: 8)

Answer 2

I think I understand now better after your comment. What you need is not a binary to ASCII-string conversion, but a binary transmission format.

Note that this is an XY-problem: asking for X, but requiring Y.

For this, you just have to preceed each data element with a type-prefix (byte).

// This enum must be known to all transmitters and receivers, of course!
typedef enum {
    DATA_TYPE_uint16 = 0,
    DATA_TYPE_int8,
    ...
} DataType;

So, for instance, an uint16_t is transfered as:

uint8_t tx_buffer[MAX_BUFFER_SIZE];
uint16_t internal_var1;

...

tx_buffer[0] = DATA_TYPE_uint16;            // type being sent
tx_buffer[1] = (uint8_t)internal_var1;      // lower 8 bits
tx_buffer[2] = (uint8_t)(internal_var1>>8); // lower 8 bits
send_i2c(3, tx_buffer);

Receivers' code:

uint8_t rx_buffer[MAX_BUFFER_SIZE];
uint16_t internal_var1;

// read the next frame (i2c delimts frames automatically)
receive(MAX_BUFFER_SIZE, rx_buffer);  // do not overflow the buffer

switch ( rx_buffer[0] ) {
    case DATA_TYPE_uint16:
        internal_var1 = (uint16_t)rx_buffer[1] | (uint16_t)rx_buffer[2] << 8;
        break;
    ...
    default:
        // invalid frame format (error handling!)
}

Note that the data is sent little endian (lowest byte first). This is common practice in embedded programming. It is much more compact (i.e. faster sent) than packing each bit into a byte and much easier&faster to process on either side.

You can extend this to any kind of datatype actually. So you can send a struct as a single type by packing its single elements as I showed for the uint16_t. Do not follow the temptation to pass data as a binary string! This is the way to desaster in communication protocols.

This is actually called "marshalling" (serializing structured data). Note to use only portable operations.

Answer 3

Most communications physical layers are byte oriented - that does not prevent the transport of larger data structures or types.

For example to split and reassemble a 16 bit integer to/from byte components:

word8_msb = (word16 >> 8) ; 
word8_lsb = (word16 & 0xFF) ; 

word16 = (word8_msb << 8) | word8_lsb) ;

Moreover if the byte-order of the two nodes happens to be the same you can simply cast the data to/from a byte array:

Sending an integer array as a byte stream:

uint16_t integer_data[] = { 1u ,2u ,3u ,4u } ;
uint8_t byte_data = (uint8_t*)integer_data ;
size_t data_length_bytes = sizeof(integer_data) * sizeof(*integer_data) ;
for( int i = 0; i < data_length_bytes )
{
    send_byte( byte_data[i] ) ;
}

Receiving a byte stream to an integer array:

uint16_t integer_data[4] ;
uint8_t byte_data = (uint8_t*)integer_data ;
size_t data_length_bytes = sizeof(integer_data) * sizeof(*integer_data) ;
for( int i = 0; i < data_length_bytes )
{
    byte_data[i] = read_byte() ;
}

In most cases however it is not as simple as that; some sort of a protocol is required at least to indicate the start of data or synchronisation (so data is not misaligned), and often data is transferred in packets that contain the data and meta-data to ensure reliable data transfer.