OpenIoT Specification

Version 0.9
Revision 1
01 Oct 2023

Contents

Introduction

OpenIoT is an open specification for smart and IoT electronic devices.

It defines a set of standard functions for specification-compatible devices to support and defines the operational parameters for their implementation.

OpenIoT offers structure and unification for the process of developing electronic devices and establishes a new approach for quicker, easier and cheaper development.

It standardizes devices as end-user products and specifies a common way of interaction with them, such that any OpenIoT-compliant device, connected client or terminal can operate with any OpenIoT-compliant device.

Property Model

The property model has a central place in the OpenIoT specification, as it's used to handle signifficant operational values of a device.
This includes

Data Types

None

Reserved type
Identifier code: 0

Action

Reserved type
Identifier code: 1
Reserved for actions

Integer

Identifier code: 2
32-bit integer, signed, little endian, least signifficant bit first

Float

Identifier code: 3
32-bit floating point

Bool

Identifier code: 4
8-bit boolean

Data

Identifier code: 5
Variable bit length, multi-purpose
Usage and interpretation depend on the particular use-case

Type Code Bits Notes
None 0 - Reserved
Action 1 - Reserved
Integer 2 32 Signed, Little endian, LSB first
Float 3 32 Floating point
Bool 4 8 0: false, non-zero: true
Data 5 Variable Multi-purpose

Flags

A property can additionally have specific flags, which complement its features

Flag Value Feature
Read 0x01 Property can be read
Write 0x02 Property can be set
EEPRom 0x40 Property is to be stored in persistent memory.
This means the property should retain after the device loses power.
Subscribed 0x80 The device should send events to connected clients when a subscribed property's value changes

Properties

A property is defined by

A property is complemented by

Peripherals Model

The Peripherals model is the way OpenIoT defines the wiring of a device and more precisely, how all the hardware modules (peripherals) are wired to the main device (the board).

A peripheral in OpenIoT is any electronic component - simple or complex - which is wired to the main board and performs some user-relevant function.
For example, a simple LED might be a peripheral, and a complex GPS module might be a peripheral too.
In the first case, the peripheral wiring is one pin and is controlled simply by enabling or disabling power supply on that pin.
In the second case, the peripheral wiring is on multiple pins and is controlled by a relatively complex communication protocol.
For an OpenIoT device however, these are both the same thing - a peripheral with a wiring interface.

Wiring interfaces

A peripheral can have any number of wiring interfaces.
A wiring interface can represent any pin configuration, like for example, a single pin or a communication interface (like UART, I2C, SPI).

Properties

A peripheral can have any number properties and each property can be any of the available property types.
The properties of a peripheral represent its user interface and as such, they hold the values which are of practical importance to the user.
The properties can be read and changed from outside the device by a client connected to the device or from inside by binding them to other properties - either of the same peripheral or of another.

Settings

A peripheral can have any number properties and each property can be any of the available property types.

Peripherals

A peripheral is a sum of Wiring interfaces, Properties and settings and a device is a sum of a main board and attached peripherals.

OpenIoT does not restrict how peripherals are serialized and how they operate, as this is a matter for the specific OpenIoT implementation.
In OpenIoT device however must expose its peripherals' properties, so that users can interact with them and through them - with the hardware itself.

Chunk Protocol

The Chunk Protocol is the basis for communication between OpenIoT device and other devices.
It simply organized data flow into chunks and introduces a checksum for each chunk to make sure the data is correct.
The checksum is simple CRC16 and it doesn't do error-correction. The data should arrive in the order it was sent.
Thd protocol is quick and simple and is more of an extra measure to ensure the proper data is coming.

Structure

Data comes in series of chunks, each chunk consisting of useful data, an ending id 0xE671, useful data size and a checksum.
Each time an ending id is encountered in the data stream, the following bytes of the data stream should tried and tested as useful data size and checksum against the already received data.
If it's a match, then the received data is valid and can be safely processed. If it's not a match, then receiving data should continue as usual until the next encountered ending id.
The chunks have a fixed maximum size of 255 bytes. If the size of the received data outgrows this maximum size before encountering a matching chunk end, then an error must have occurred somewhere, in which case the reading process should be reset.

Useful data, up to 255 bytes End ID 0xE671, 16bit Useful data size, 8bit Checksum, 16bit

Checksum

The checksum at the end of a chunk is a 16bit value with initial seed of 0x1D0F
It's re-calculated for each incoming byte as follows:

x = (checksum >> 8) ^ incoming_byte;
x = x ^ (x >> 4);
checksum = (checksum << 8) ^ (x << 12) ^ (x << 5) ^ x;

Data flow

The protocol allows for processing data on the fly as it comes, but it is technically possible for a checksum mismatch to occur, making the previously received chunk invalid.
That's why, data may be processed after confirmed with a proper checksum.

Command Protocol

The Command Protocol builds upon the Chunk Protocol and introduces the definition of Commands.
Commands can be passed within a chunk and a single chunk can contain one or more commands.

Command

A command starts with an 8bit CommandCode, followed by 8bit DataSize and Data of length equal to DataSize.
If DataSize is 0, then there is no following Data

CommandCode, 8bit DataSize, 8bit Data, variable size

Property Protocol

The Property protocol builds upon the Command protocol and uses commands for interaction with properties.
An OpenIoT - compatible device with various properties can be communicated with and have its properties read and updated by using the Property protocol.

The Property protocol introduces a few commands for live connection with a device and for exchanging property information like listing, reading and updating properties.
It is in fact a Command protocol with certain commands defined.

Commands

A device can receive incoming commands or send outgoing commands.

Incoming

These are the incoming commands, which a Property protocol compatible device can accept from other devices connected to it.

Name

Notes

Code Data

Ping

When the device receives the Ping command, it sends back an outgoing Ping response, containing the same data it received, unaltered.
Can be used to verify the device is responsive, as well as for measuring connection latency by sending a timestamp from the connected device.

0x10 Any data

Info

When the device receives the Info command, it sends an outgoing response, containing meta information about the device.
The information at Property protocol level is the name of the board of the device.

0x11

QueryParamsInfo

When the device receives the QueryParamsInfo command, it sends an outgoing response, containing bulk information about a provided number of its properties, starting from certain property index.
If the returned properties are less than the queried count, this means it's the end of the properties list.

0x21
  • Start index, 8bit
  • Property count, 8bit

QueryParamsValues

When the device receives the QueryParamsValues command, it sends an outgoing response, containing the values of the requested properties.
The exact properties which are requested are defined in the Data by their Property identifiers.

0x22
  • Property count, 8bit
  • List of property identifiers, 8bit each

SetParamsValues

When the device receives the SetParamsValues command, it sets the requested properties with the provided values.
The exact properties which are requested are defined in the Data by their Property identifiers.

0x23
  • Property count, 8bit
  • List of property identifiers, 8bit each

SetParamsSubscription

When the device receives the SetParamsSubscription command, it either subscribes or unsubscribes the connected client for receiving live information when a certain properties value changes.
A boolean value in Data defines whether the properties are to be subscribed or unsubscribed and the exact properties which are to be affected are defined in Data by their Property identifiers.
The device will send outgoing commands to the connected client when a subscribed property's value changes.

0x24
  • Subscription enabled, boolean, 8bit
  • Property count, 8bit
  • List of property identifiers, 8bit each

ResetParamsSubscription

When the device receives the ResetParamsSubscription command, it indiscriminately unsubscribes the connected client from all of its properties.

0x25

Outgoing

These are the outgoing commands, which a Property protocol compatible device sends to other devices connected to it.
Some of these commands would be sent in response to an incoming command, while others are initiated within the device.
Many of the outgoing commands, which are a response of an incoming command, have a code which is similar to the respective incoming command code, but with its most signifficant bit set to 1.

Name

Notes

Code Data

Ping

Sent in response to an incoming Ping command, sends back the input data exactly as it was received.

0x90 Any data received by the Ping request

Info

Sent in response to an incoming Info command, sends back meta information about the device.
The information at Property protocol level is the name of the board of the device.

0x91 Name of the host board of the OpenIoT device

QueryParamsInfo

Sent in response to an incoming QueryParamsInfo command, sends information on the requested properties.

0xA1 A data stream of properties info blocks, each with the following structure:
  • Property Identifier, 8bit
  • Property type, 8bit
  • Property flags, 8bit
  • Property value size - only for property of type Data
  • Property value, size depending on Property type

QueryParamsValues

Sent in response to an incoming QueryParamsValues command, sends the values of the requested properties
Note that properties can be unreadable if they don't have their Read flag set. In this case the property value would not be sent

0xA2 A data stream of property value blocks, each with the following structure:
  • Property index, 8bit
  • Property value size - only for property of type Data
  • Property value, size depending on Property type
Note, that in this case, the property is defined by an index, rather than its identifier.
This index matches the [StartPropertyIndex .. PropertyCount] range of the request.

SetParamsValues

Sent in response to an incoming QueryParamsValues command, sets the provided values to the requested properties
Note that properties can be unwritable if they don't have their Write flag set. In this case the property value would not be set

0xA3

SetParamsSubscription

Sent in response to an incoming SetParamsSubscription command, after the request has been completed

0xA4

ResetParamsSubscription

Sent in response to an incoming ResetParamsSubscription command, after the request has been completed

0xA5

OpenIoT protocol

The OpenIoT protocol builds upon the Property protocol and adds commands for device management.
While the Property protocol's commands operate in the domain of individual properties and collection of properties, the OpenIoT protocol operates in the domain of a full-featured OpenIoT device and introduces commands for interacting with such device.

Configuration properties

Note, that here we'll be referring to the term configuration properties.
These are different from the properties handled at Property protocol level.
The configuration properties refer to the device's inherent configuration parameters, while the properties of the Property protocol domain are a feature of the user-uploaded device logic.

The configuration properties can be set via the SetDeviceProperties command.
They are not set automatically by the device, except when the device is reset and they get zeroed.
Depending on implementation, there may be size limitaions.

Here are the configuration properties of an OpenIoT device

Name Code Description Notes
DeviceUid 0x11 Unique identifier of the device Byte data
Recommended minimum size is 16 bytes
DeviceName 0x12 Name of the device String
Password 0x13 Password for accessing the device from a client connection String, write only
ProjectUid 0x14 Unique identifier of the operational logic, which is loaded into the device Byte data
Recommended minimum size is 16 bytes
ProjectName 0x15 Name of the operation logic, which is loaded into the device String
ProjectHash 0x16 Hash of the operational logic loaded into the device. Byte data
Recommended minimum size is 4 bytes.
ProjectHash provides a signature for the contents of the operational logic locaded into the device
UserUid 0x17 Unique identifier of the user, whom the device belongs to Byte data.
Recommended minimum size is 16 bytes.
FirmwareName 0x21 Name of the firmware running on the device. For example "OpenIoT" String, Read only
FirmwareVendor 0x22 Name of the vendor, providing the firmware on the device String, Read only
FirmwareVersion 0x23 Version of the firmware on the device Byte data, Read only.
Recommended minimum size is 4 bytes. Most to less signifficant byte maps to major to minor version number
BoardName 0x31 Name of the board on which the firmware is running. For example "ESP32" String, Read only

Commands

The OpenIoT protocol extends the Property protocol and introduces commands for working with a device's configuration, for uploading device operational logic and for other device-related functionality

As with Property protocol, a device can receive incoming commands or send outgoing commands.

Incoming

These are the incoming commands, which an OpenIoT device can accept from other devices in addition to the commands inherited from the Property Protocol

Name

Notes

Code Data

SetDeviceProperties

Sets one or more of the device's configuration properties.
Sends an outgoing response with the set propertes and their new values in the same format.

0x41 Stream of one or more data blocks, one data block per property, each in the format
  • Property code, 8bit
  • Value size, 8bit
  • Value data, size equal to Value size

GetDeviceProperties

Sets one or more of the device's configuration properties
Sends an outgoing response with the requested properties.

0x42 Stream of one or more 8bit property id

UploadSchemeLogic

Uploads the wiring scheme of the operational logic to run on the device.
Sends an outgoing response when done.

0x43 Stream of data complying to the Peripheral model

UploadProgramLogic

Uploads the Virtual processor program for the operational logic to run on the device.
Sends an outgoing response when done.

0x44 Stream of data complyng to the Virtual processor instruction specification

ResetLogic

Erases the operational logic on the device. Affects the logic uploaded by both UploadSchemeLogic and UploadProgramLogic.
Sends an outgoing response when done.

0x45

Reset

Resets the device as if started anew. Does not erase operational logic.
Sends an outgoing response when done.

0x46

Outgoing

These are the outgoing commands, which an OpenIoT compatible device sends in addition to the commands inherited from the Property Protocol.
These commands are generally sent in response to an incoming command.
Many of the outgoing commands, which are a response of an incoming command, have a code which is similar to the respective incoming command code, but has its most signifficant bit set to 1.

Name

Notes

Code Data

SetDeviceProperties

Sent in response to an incoming SetDeviceProperties command, sends the requested device properties which were set, along with their new values in the same format as in the request

0xC1 Stream of one or more data blocks, one data block per property, each in the format
  • Property code, 8bit
  • Value size, 8bit
  • Value data, size equal to Value size

GetDeviceProperties

Sent in response to an incoming GetDeviceProperties command, sends the requested device properties

0xC2 Stream of one or more data blocks, one data block per property, each in the format
  • Property code, 8bit
  • Value size, 8bit
  • Value data, size equal to Value size

UploadSchemeLogic

Sent in response to an incoming UploadSchemeLogic command, after the scheme logic is loaded on the device.

0xC3

UploadProgramLogic

Sent in response to an incoming UploadProgramLogic command, after the program logic is loaded on the device.

0xC4

ResetLogic

Sent in response to an incoming ResetLogic command, after the logic has been reset on the device.

0xC5

Reset

Sent in response to an incoming Reset command, after the device has been reset.

0xC6

Virtual Processor

Operation

The Virtual Processor operates by executing its code on an isolated memory segment, which is byte code containing instructions and values and can be thought of as being both code segment and heap.

The instructions operational memory is a data stack with elements of variable size.
Instructions can read and write from heap, as well as pop and push the stack.

Typically, the Virtual Processor reads an instruction code form the current position of the heap and executes the corresponding instruction

For example, here's how adding two variables and assigning the result to a third variable can go:

  1. IPushAddress - Read the address of the variable for holding the result and push it in stack
    Stack contents: [address]
  2. IPushAddressValue - Read the first variable's value from heap and push it in stack
    Stack contents: [address, value1]
  3. IPushAddressValue - Read the second variable's value from heap and push it in stack
    Stack contents: [address, value1, value2]
  4. IAdd - Pop the two values from stack, add them and push the sum in stack
    Stack contents: [address, sum]
  5. ISet - Pop the sum from stack, pop the address from stack and write the sum in the heap at the address
    Stack contents: [ ]

CallOuts

The Virtual Processor allows for executing code outside of its virtual environment by calling functions from the native program.

These CallOut functions are defined in the Virtual Processor's code by an identifier and when such function is about to be executed by the Virtual Processor, a function in native code gets called with a parameter holding the CallOut identifier.
From that point on, it's the native code's job to execute the CallOut function.

CallOuts are teh Virtual Processor's way to interact with the native environment.
The Callout can work with the stack of the Virtual Processor, effectively enabling the exchange of values between both worlds.

Instruction Set

Following is the full set of instructions of the Virtual Processor
The Code and Heap Input columns are what constitues the compiled code and what actually goes to the code segment. Adhering to these two columns covers the specificaton.
The rest of the columns are given as an implementation example.

Name

Notes

Code Heap Input Heap Output Stack Input Stack Output

Reserved

0

NOP

No operation, does nothing

1

JMP

Unconditional jump to Offset

2 Offset: 32bit int

JZ

Jumps to Offset if Condition is zero

3 Offset: 32bit int Condition: 32bit int

JNZ

Jumps to Offset if Condition is non-zero

4 Offset: 32bit int Condition: 32bit int

Call

Unconditional jump to Offset. Saves Address in Stack

5 Offset: 32bit int Address: 32bit int

RET

Reads address saved in Stack and jumps to it

6 Offset: 32bit int

CallOut

Reads a CallOutId and executes the correspondng CallOut

7 CallOutId: 8bit uint
Integer

IToF

Pops int value from stack and pushes it back as float

8 Value: 32bit int Value: 32bit float

IPushAddress

Reads 32bit int from heap and pushes it to stack

9 Address: 32bit int Address: 32bit int

IU8PushAddress

Reads 8bit int from heap and pushes it to stack

10 Address: 8bit int Address: 8bit int

IPushIndexedAddress

Reads 32bit int from heap, pops 32bit int from stack and pushes their sum in stack

11 Address: 32bit int Offset: 32bit int Address: 32bit int

IPushAddressValue

Reads Address from heap, reads the int Value at this address in heap and pushes it in stack

12 Address: 32bit int Value: 32bit int

IPushIndexedAddressValue

Reads 32bit Address from heap, pops 32bit Offset from stack, reads the int Value at Address + Offset in heap, and pushes it in stack

13

Address: 32bit int Offset: 32bit int Value: 32bit int
Integer Evaluation

INot

Reads Value from heap, performs bitwise NOT, pushes Result in stack

14 Value: 32bit int Result: 32bit int

IAnd

Pops two 32bit values from stack, performs bitwise AND, pushes Result in stack

15 Arg1: 32bit int
Arg2: 32bit int		 Result: 32bit int

IOr

Pops two 32bit values from stack, performs bitwise OR, pushes Result in stack

16 Arg1: 32bit int
Arg2: 32bit int		 Result: 32bit int

IXor

Pops two 32bit values from stack, performs bitwise XOR, pushes Result in stack

17 Arg1: 32bit int
Arg2: 32bit int		 Result: 32bit int

IShl

Pops two 32bit values from stack, performs Result = Arg1 << Arg2, pushes Result in stack

18 Arg1: 32bit int
Arg2: 32bit int		 Result: 32bit int

IShr

Pops two 32bit values from stack, performs Result = Arg1 >> Arg2, pushes Result in stack

19 Arg1: 32bit int
Arg2: 32bit int		 Result: 32bit int

IDiv

Pops two 32bit values from stack, performs Result = Arg1 / Arg2, pushes Result in stack

20 Arg1: 32bit int
Arg2: 32bit int		 Result: 32bit int

IMod

Pops two 32bit values from stack, performs Result = Arg1 % Arg2, pushes Result in stack

21 Arg1: 32bit int
Arg2: 32bit int		 Result: 32bit int

IMul

Pops two 32bit values from stack, performs Result = Arg1 * Arg2, pushes Result in stack

22 Arg1: 32bit int
Arg2: 32bit int		 Result: 32bit int

ISub

Pops two 32bit values from stack, performs Result = Arg1 - Arg2, pushes Result in stack

23 Arg1: 32bit int
Arg2: 32bit int		 Result: 32bit int

IAdd

Pops two 32bit values from stack, performs Result = Arg1 + Arg2, pushes Result in stack

24 Arg1: 32bit int
Arg2: 32bit int		 Result: 32bit int

ILogicalNot

Pops Value from stack, performs logical NOT, pushes Result in stack

25 Value: 32bit int Result: 32bit int

ILogicalAnd

Pops two 32bit values from stack, performs logical AND, pushes Result in stack

26 Arg1: 32bit int
Arg2: 32bit int		 Result: 32bit int

ILogicalOr

Pops two 32bit values from stack, performs logical OR, pushes Result in stack

27 Arg1: 32bit int
Arg2: 32bit int		 Result: 32bit int

IGreater

Pops two 32bit values from stack, pushes 1 in stack if first value is greater, otherwise pushes 0

28 Arg1: 32bit int
Arg2: 32bit int		 Result: 32bit int

ILesser

Pops two 32bit values from stack, pushes 1 in stack if first value is lesser, otherwise pushes 0

29 Arg1: 32bit int
Arg2: 32bit int		 Result: 32bit int

IEqual

Pops two 32bit values from stack, pushes 1 in stack if the values are equal, otherwise pushes 0

30 Arg1: 32bit int
Arg2: 32bit int		 Result: 32bit int

INotEqual

Pops two 32bit values from stack, pushes 1 in stack if the values are not equal, otherwise pushes 0

31 Arg1: 32bit int
Arg2: 32bit int		 Result: 32bit int

IGreaterEqual

Pops two 32bit values from stack, pushes 1 in stack if first value is greater or equal to the second, otherwise pushes 0

32 Arg1: 32bit int
Arg2: 32bit int		 Result: 32bit int

ILesserEqual

Pops two 32bit values from stack, pushes 1 in stack if first value is lesser or equal than the second, otherwise pushes 0

33 Arg1: 32bit int
Arg2: 32bit int		 Result: 32bit int
Integer Assignment
ISet

Pops 32bit Value and 32bit Address from stack, writes Value in heap at the Address

34 Value: 32bit int Value: 32bit int
Address: 32bit int

IAddAdd

Pops 32bit Address from stack, reads Value at Address from heap, increments the Value with 1 and Writes the incremented value at Address in heap heap

35 Value: 32bit int Value: 32bit int Address: 32bit int

ISubSub

Pops 32bit Address from stack, reads Value at Address from heap, decrements the Value with 1 and Writes the incremented value at Address in heap heap

36 Value: 32bit int Value: 32bit int Address: 32bit int

IAddEquals

Pops 32bit Value and 32bit Address from stack, reads Value1 at Address from heap, writes the sum Result = Value1 + Value2 at Address in heap

37 Value1: 32bit int Result: 32bit int Address: 32bit int, Value2: 32bit int

ISubEquals

Pops 32bit Value and 32bit Address from stack, reads Value1 at Address from heap, writes the difference Result =f Value1 - Value2 at Address in heap

38 Value1: 32bit int Result: 32bit int Address: 32bit int, Value2: 32bit int

IMulEquals

Pops 32bit Value and 32bit Address from stack, reads Value1 at Address from heap, writes the product Result = Value1 * Value2 at Address in heap

39 Value1: 32bit int Result: 32bit int Address: 32bit int, Value2: 32bit int

IModEquals

Pops 32bit Value and 32bit Address from stack, reads Value1 at Address from heap, writes the modulus Result = Value1 % Value2 at Address in heap

40 Value1: 32bit int Result: 32bit int Address: 32bit int, Value2: 32bit int

IDivEquals

Pops 32bit Value and 32bit Address from stack, reads Value1 at Address from heap, writes the quotient Result = Value1 / Value2 at Address in heap

41 Value1: 32bit int Result: 32bit int Address: 32bit int, Value2: 32bit int

IXorEquals

Pops 32bit Value and 32bit Address from stack, reads Value1 at Address from heap, writes the bitwise xor Result = Value1 XOR Value2 at Address in heap

42 Value1: 32bit int Result: 32bit int Address: 32bit int, Value2: 32bit int

IOrEquals

Pops 32bit Value and 32bit Address from stack, reads Value1 at Address from heap, writes the bitwise or Result = Value1 OR Value2 at Address in heap

43 Value1: 32bit int Result: 32bit int Address: 32bit int, Value2: 32bit int

IAndEquals

Pops 32bit Value and 32bit Address from stack, reads Value1 at Address from heap, writes the bitwise Result = Value1 AND Value2 at Address in heap

44 Value1: 32bit int Result: 32bit int Address: 32bit int, Value2: 32bit int
Floating point

FToI

Pops 32bit int value from stack and pushes it as a float value back to stack

45 Value: 32bit int Value: 32bit float

FPushAddress

Reads 32bit Address from heap and pushes it to stack

46 Address: 32bit int Address: 32bit int

FPushIndexedAddress

Reads 32bit int from heap, pops 32bit int from stack and pushes their sum in stack

47 Address: 32bit int
Value: 32bit float		 Offset: 32bit int Address: 32bit int

FPushAddressValue

Reads 32bit Address from heap, reads the float Value at this address in heap and pushes it in stack

48 Address: 32bit int Value: 32bit float

FPushIndexedAddressValue

Reads 32bit Address from heap, pops 32bit Offset from stack, reads the float Value at Address + Offset in heap, and pushes it in stack

49 Address: 32bit int Offset: 32bit int Value: 32bit float
Floating point Evaluation

FDiv

Pops two 32bit float values from stack, performs Result = Arg1 / Arg2, pushes Result in stack

50 Arg1: 32bit float
Arg2: 32bit float		 Result: 32bit float

FMul

Pops two 32bit float values from stack, performs Result = Arg1 * Arg2, pushes Result in stack

51 Arg1: 32bit float
Arg2: 32bit float		 Result: 32bit float

FSub

Pops two 32bit float values from stack, performs Result = Arg1 - Arg2, pushes Result in stack

52 Arg1: 32bit float
Arg2: 32bit float		 Result: 32bit float

FAdd

Pops two 32bit float values from stack, performs Result = Arg1 + Arg2, pushes Result in stack

53 Arg1: 32bit float
Arg2: 32bit float		 Result: 32bit float

FGreater

Pops two 32bit float values from stack, pushes 1 in stack if first value is greater, otherwise pushes 0

54 Arg1: 32bit float
Arg2: 32bit float		 Result: 32bit float

FLesser

Pops two 32bit float values from stack, pushes 1 in stack if first value is lesser, otherwise pushes 0

55 Arg1: 32bit float
Arg2: 32bit float		 Result: 32bit float

FEqual

Pops two 32bit float values from stack, pushes 1 in stack if the two values are equal, otherwise pushes 0

56 Arg1: 32bit float
Arg2: 32bit float		 Result: 32bit float

FNotEqual

Pops two 32bit float values from stack, pushes 1 in stack if the two values are not equal, otherwise pushes 0

57 Arg1: 32bit float
Arg2: 32bit float		 Result: 32bit float

FGreaterEqual

Pops two 32bit float values from stack, pushes 1 in stack if first value is greater or equal to the second, otherwise pushes 0

58 Arg1: 32bit float
Arg2: 32bit float		 Result: 32bit float

FLesserEqual

Pops two 32bit float values from stack, pushes 1 in stack if first value is lesser or equal to the second, otherwise pushes 0

59 Arg1: 32bit float
Arg2: 32bit float		 Result: 32bit float
Floating point Assignment

FSet

Pops 32bit float Value and 32bit Address from stack, writes Value in heap at the Address

60 Value: 32bit float Value: 32bit float
Address: 32bit int

FAddEquals

Pops 32bit float Value2 and 32bit Address from stack, reads float Value1 at Address from heap, writes the float sum Result = Value1 + Value2 at Address in heap

61 Value1: 32bit float Result: 32bit float Address: 32bit int, Value2: 32bit float

FSubEquals

Pops 32bit float Value2 and 32bit Address from stack, reads float Value1 at Address from heap, writes the float difference Result = Value1 - Value2 at Address in heap

62 Value1: 32bit float Result: 32bit float Address: 32bit int, Value2: 32bit float

FMulEquals

Pops 32bit float Value2 and 32bit Address from stack, reads float Value1 at Address from heap, writes the float product Result = Value1 * Value2 at Address in heap

63 Value1: 32bit float Result: 32bit float Address: 32bit int, Value2: 32bit float

FDivEquals

Pops 32bit float Value2 and 32bit Address from stack, reads float Value1 at Address from heap, writes the float quotient Result = Value1 / Value2 at Address in heap

64 Value1: 32bit float Result: 32bit float Address: 32bit int, Value2: 32bit float