Pass structure pointer as an argument to a function in c
Remove your casting, and change your message parameter to be rs485_message_t *:

int16_t proto485Compare(rs485_message_t * message, uint8_t* comparec, uint8_t* comparea, uint8_t* comaprev) {
    int j = 0;
    rs485_message_t rs485Msg;
    char res; 
    uint8_t FWmsg[9] = {0x09,0x31,0x30,0x30,0x30,0x30,0x33,0x30,0x34};           
    uint8_t arduinodata[9] = {0x09,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30}; 

    if(proto485ValidCheckSum(message))) { ...


And when you call it, simply:

res =  proto485Compare(&amp;rs485Msg, command, action, value);      


To get at the individual bytes you can then cast a new variable:

uint8_t *messageAsBytes = (uint8_t *)message;


Then you can use:

messageAsBytes[i]


etc.

However another cleaner way is to create a union in your structure:

struct rs485_message_t {
    union {
        uint8_t bytes[9];
        struct {
            uint8_t AB;     ///&lt; Address byte (Start byte)
            uint8_t CB;     ///&lt; Command (index) "ASCII-byte"
            uint8_t SI;     ///&lt; Action (sub index) "ASCII-byte"
            uint8_t PH1;    ///&lt; Payload "ASCII-byte" of the high nibble of the high byte of the raw payload
            uint8_t PH0;    ///&lt; Payload "ASCII-byte" of the low nibble of the high byte of the raw payload
            uint8_t PL1;    ///&lt; Payload "ASCII-byte" of the high nibble of the low byte of the raw payload
            uint8_t PL0;    ///&lt; Payload "ASCII-byte" of the low nibble of the low byte of the raw payload
            uint8_t CS1;    ///&lt; Checksum "ASCII-byte" of the high nibble of the raw checksum
            uint8_t CS0;    ///&lt; Checksum "ASCII-byte" of the low nibble of the raw checksum
        };
    };
};   


So you can now access message-&gt;CS0, etc, as well as message-&gt;bytes[3].

You should also pass a pointer when you call proto485ValidCheckSum - purely to save memory.

uint8_t proto485ValidCheckSum(rs485_message_t *message)
{ 
  uint8_t rawChecksum = (message-&gt;CB - OFFSET_ASCII) + (message-&gt;SI - OFFSET_ASCII) +
    (message-&gt;PH1 - OFFSET_ASCII) + (message-&gt;PH0 - OFFSET_ASCII) +
      (message-&gt;PL1 - OFFSET_ASCII) + (message-&gt;PL0 - OFFSET_ASCII);

  uint8_t res = (((rawChecksum &amp; 0xF0) &gt;&gt; 4) + OFFSET_ASCII) == message-&gt;CS1 &amp;&amp;
    ((rawChecksum &amp; 0x0F) + OFFSET_ASCII) == message-&gt;CS0;

  return res;
}


And again call it with a pointer, which the first block of code does anyway.

In general, it's better to pass a single pointer to a struct around from function to function instead of cloning it each time.

You can also use "pass by reference" if you like, but I find it's better to stick to pointers when passing something around alot like this.