Representing fixed point scaling of numbers|OPC UA Standard|Forum|OPC Foundation

I am implementing a minimal OPC-UA server in an embedded device (ARM Cortex-M4).  Our system uses almost entirely fixed-point arithmetic – that is 16 and 32 bit integers.  We use standard “Q Notation” for describing the scaling on each variable.

What is the best strategy to expose these fixed point variables over OPC-UA?

The objective is that the client application can easily and transparently view the value in SI / Engineering units and (generally) be oblivious to the underlying fixed point implementation.

More information:

All of our variables have an engineering units, say Volts, and a scale factor which is usually an exponent of 2.  For example, voltage_sense might be Int16 Q8, which means it has a range of [-128,128) volts, which a least significant bit of 2^-8 = 1/256 Volts. 

I have in the past worked in the automotive industry where  XCP/CCP/ASAM-MCD protocols are used and do somewhat similar function to the OPC-UA, although coming at the problem from a totally different direction.  In those protocols, each variable can define a “conversion function” on how to interpret the physical value.  In this example above, the conversion would be the factor of 2^-8.  This is all done client side transparently to the user/consumer who usually just wants to see the engineering value.

I make a clear distinction between the Represented Value (the 16 bit number) and the Physical Value (with SI units of Volts). 

I anticipated that the OPC-UA standard would also provide this capability, but now I’m half way through the implementation and I can’t find it anywhere.  This is a very big missing if this is the case and may preclude us from migrating from our custom system to the standard OPC-UA.

It would be very clean for ConversionFunction to be specified by the VariableType (or is it DataType?).  I could make up my own DataTypes that specify custom scaling, but I’m not sure that is useful unless clients actually read it. 

It is possible for us to just convert everything to floating point at the server interface: expose everything as double and scale and cast it on reading and writing.  I’ve been down that road before on other projects and it just introduces more problems than we want to go into.

If OPC-UA is really targeting nano devices, I expect others will want this and it wold be a standard feature.  Have I missed this somewhere in the standards?