How to cast two uint8 into int16 in Simulink?

I have two uint8 as input of my system. Together, they represent an int16. How can I cast these two values into an int16? In MATLAB, I would convert them to uint16, shift the bits of the first one 8 to the left and the use bitwise OR to get the bit representation and finally apply a typecast to reinterpret the bits (with respect to two's complement). In MATLAB it works:

raw = uint8([255,255])
raw = uint16(raw)
myint16 = typecast(bitor(bitshift(raw(1),8), raw(2)), 'int16') %myint16 = -1

How do I implement this in Simulink? I am restricted to the slcilib (for Code Inspector Compliance). That's why I cannot use the typecast function. Finally, I found a solution, but it's a really complicated if-then-else stuff, with around four casts. Is there another easy way?

Answer 1

[Fangjun Jiang]

1. Use the ShiftArithmetic block in Simulink->Logic and Bit Operations.

2. Multiply the first number with 256 and then add to the second number.

[Markus]

Thanks for the answer! The way you propose works for unsigned values, but not for signed values, since negative numbers are stored using the two's complement.

If you use (1) or (2), you have to reinterpret the bits after that to get a signed value, but the simple "Data Type Conversion" block only does a normal cast which will lead to an overflow.

[Walter Roberson]

To produce a signed value, convert to unsigned in myuint16 and then

if myuint16 < 32768
  myint16 = int16(myuint16);
else
  myint16 = -int16(bitwise_not(myuint16)) - int16(1)
end

for appropriate bitwise_not routine

[Fangjun Jiang]

Would this be correct?

[Walter Roberson]

I am not sure of the purpose of the bitwise OR ?

[Markus]

@Fangjun Jian: This Simulink implementation was my first approach, too. However, it throws an overflow warning although the results are right. With more strict diagnostics, it doesn't simulate.

@Walter Roberson: The problem ist, that implemented in Simulink with the slcilib, this becomes a more complicated model. You need enabled subsystems to avoid calculation of branches where the overflow could occur. In the end, I get a code looking like that:

 Subsystem_B->RelationalOperator = (Subsystem_B->BitwiseOperator > ((uint16_T)
56      32767U));
57  
61    if (Subsystem_B->RelationalOperator) {
65      Subsystem_B->Subtract = (uint16_T)(((uint32_T)Subsystem_B->BitwiseOperator)
66        - ((uint32_T)((uint16_T)1U)));
69      Subsystem_B->BitwiseOperator1 = (uint16_T)(~Subsystem_B->Subtract);
70  
72      Subsystem_B->DataTypeConversion = (int16_T)Subsystem_B->BitwiseOperator1;
73    }
74  
78    Subsystem_B->LogicalOperator = !Subsystem_B->RelationalOperator;
79  
83    if (Subsystem_B->LogicalOperator) {
*/
85      Subsystem_B->DataTypeConversion3 = (int16_T)Subsystem_B->BitwiseOperator;
86    }
87  
91    if (Subsystem_B->BitwiseOperator > ((uint16_T)32767U)) {
93      Subsystem_Y->Out1 = Subsystem_B->DataTypeConversion;
94    } else {
96      Subsystem_Y->Out1 = Subsystem_B->DataTypeConversion3;
97    }
98  
100  }

Actually in manua code, it should just be sth. like myint16value = *(signed short *)&myuint16value;