module Lignite::Ev3Ops

Bytecodes implemented by EV3

Constants

MULTIPLEX_ARRAY
MULTIPLEX_COM_GET
MULTIPLEX_COM_READ
MULTIPLEX_COM_SET
MULTIPLEX_COM_WRITE
MULTIPLEX_FILE
MULTIPLEX_FILENAME
MULTIPLEX_INFO
MULTIPLEX_INPUT_DEVICE
MULTIPLEX_MATH
MULTIPLEX_PROGRAM_INFO
MULTIPLEX_SOUND
MULTIPLEX_STRINGS
MULTIPLEX_TST
MULTIPLEX_UI_BUTTON
MULTIPLEX_UI_DRAW
MULTIPLEX_UI_READ
MULTIPLEX_UI_WRITE

Public Instance Methods

add16(source1, source2, destination) click to toggle source

Add two 16-bit values DESTINATION = SOURCE1 + SOURCE2 @param source1 [PAR16] (in) @param source2 [PAR16] (in) @param destination [PAR16] (out)

# File lib/lignite/ev3_ops.rb, line 383
def add16(source1, source2, destination)
  logger.debug do
    args = [source1, source2, destination]
    "called add16 with #{args.inspect}"
  end

  bytes = u8(0x11)
  bytes += param_simple(source1)
  bytes += param_simple(source2)
  bytes += param_simple(destination)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
add32(source1, source2, destination) click to toggle source

Add two 32-bit values DESTINATION = SOURCE1 + SOURCE2 @param source1 [PAR32] (in) @param source2 [PAR32] (in) @param destination [PAR32] (out)

# File lib/lignite/ev3_ops.rb, line 401
def add32(source1, source2, destination)
  logger.debug do
    args = [source1, source2, destination]
    "called add32 with #{args.inspect}"
  end

  bytes = u8(0x12)
  bytes += param_simple(source1)
  bytes += param_simple(source2)
  bytes += param_simple(destination)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
add8(source1, source2, destination) click to toggle source

Add two 8-bit values DESTINATION = SOURCE1 + SOURCE2 @param source1 [PAR8] (in) @param source2 [PAR8] (in) @param destination [PAR8] (out)

# File lib/lignite/ev3_ops.rb, line 365
def add8(source1, source2, destination)
  logger.debug do
    args = [source1, source2, destination]
    "called add8 with #{args.inspect}"
  end

  bytes = u8(0x10)
  bytes += param_simple(source1)
  bytes += param_simple(source2)
  bytes += param_simple(destination)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
addf(source1, source2, destination) click to toggle source

Add two floating point values DESTINATION = SOURCE1 + SOURCE2 @param source1 [PARF] (in) @param source2 [PARF] (in) @param destination [PARF] (out)

# File lib/lignite/ev3_ops.rb, line 419
def addf(source1, source2, destination)
  logger.debug do
    args = [source1, source2, destination]
    "called addf with #{args.inspect}"
  end

  bytes = u8(0x13)
  bytes += param_simple(source1)
  bytes += param_simple(source2)
  bytes += param_simple(destination)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
and16(source1, source2, destination) click to toggle source

And two 16 bit values DESTINATION = SOURCE1 & SOURCE2 @param source1 [PAR16] (in) @param source2 [PAR16] (in) @param destination [PAR16] (out)

# File lib/lignite/ev3_ops.rb, line 725
def and16(source1, source2, destination)
  logger.debug do
    args = [source1, source2, destination]
    "called and16 with #{args.inspect}"
  end

  bytes = u8(0x25)
  bytes += param_simple(source1)
  bytes += param_simple(source2)
  bytes += param_simple(destination)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
and32(source1, source2, destination) click to toggle source

And two 32 bit values DESTINATION = SOURCE1 & SOURCE2 @param source1 [PAR32] (in) @param source2 [PAR32] (in) @param destination [PAR32] (out)

# File lib/lignite/ev3_ops.rb, line 743
def and32(source1, source2, destination)
  logger.debug do
    args = [source1, source2, destination]
    "called and32 with #{args.inspect}"
  end

  bytes = u8(0x26)
  bytes += param_simple(source1)
  bytes += param_simple(source2)
  bytes += param_simple(destination)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
and8(source1, source2, destination) click to toggle source

And two 8 bit values DESTINATION = SOURCE1 & SOURCE2 @param source1 [PAR8] (in) @param source2 [PAR8] (in) @param destination [PAR8] (out)

# File lib/lignite/ev3_ops.rb, line 707
def and8(source1, source2, destination)
  logger.debug do
    args = [source1, source2, destination]
    "called and8 with #{args.inspect}"
  end

  bytes = u8(0x24)
  bytes += param_simple(source1)
  bytes += param_simple(source2)
  bytes += param_simple(destination)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
array(*args) click to toggle source
# File lib/lignite/ev3_ops.rb, line 7796
def array(*args)
  logger.debug "called array with #{args.inspect}"
  cvalue = args.shift
  csym = MULTIPLEX_ARRAY.fetch(cvalue)
  __send__("array_#{csym}", *args)
end
array_append(handle, value) click to toggle source

Array element append @param handle [PAR16] (in) Array handle @param value [PARV] (in) Value (new element) to append - type depends on type of array

# File lib/lignite/ev3_ops.rb, line 7842
def array_append(handle, value)
  logger.debug do
    args = [handle, value]
    "called array_append with #{args.inspect}"
  end

  bytes = u8(0xC4)
  bytes += param_simple(handle)
  bytes += param_simple(value)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
array_copy(hsource, hdest) click to toggle source

@param hsource [PAR16] (in) Source array Handle @param hdest [PAR16] (out) Destination array handle

# File lib/lignite/ev3_ops.rb, line 7562
def array_copy(hsource, hdest)
  logger.debug do
    args = [hsource, hdest]
    "called array_copy with #{args.inspect}"
  end

  bytes = u8(0xC1)
  bytes += param_simple(7)
  bytes += param_simple(hsource)
  bytes += param_simple(hdest)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
array_create16(elements, handle) click to toggle source

@param elements [PAR32] (in) Number of elements @param handle [PAR16] (out) Array handle

# File lib/lignite/ev3_ops.rb, line 7467
def array_create16(elements, handle)
  logger.debug do
    args = [elements, handle]
    "called array_create16 with #{args.inspect}"
  end

  bytes = u8(0xC1)
  bytes += param_simple(2)
  bytes += param_simple(elements)
  bytes += param_simple(handle)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
array_create32(elements, handle) click to toggle source

@param elements [PAR32] (in) Number of elements @param handle [PAR16] (out) Array handle

# File lib/lignite/ev3_ops.rb, line 7486
def array_create32(elements, handle)
  logger.debug do
    args = [elements, handle]
    "called array_create32 with #{args.inspect}"
  end

  bytes = u8(0xC1)
  bytes += param_simple(3)
  bytes += param_simple(elements)
  bytes += param_simple(handle)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
array_create8(elements, handle) click to toggle source

@param elements [PAR32] (in) Number of elements @param handle [PAR16] (out) Array handle

# File lib/lignite/ev3_ops.rb, line 7448
def array_create8(elements, handle)
  logger.debug do
    args = [elements, handle]
    "called array_create8 with #{args.inspect}"
  end

  bytes = u8(0xC1)
  bytes += param_simple(1)
  bytes += param_simple(elements)
  bytes += param_simple(handle)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
array_createf(elements, handle) click to toggle source

@param elements [PAR32] (in) Number of elements @param handle [PAR16] (out) Array handle

# File lib/lignite/ev3_ops.rb, line 7505
def array_createf(elements, handle)
  logger.debug do
    args = [elements, handle]
    "called array_createf with #{args.inspect}"
  end

  bytes = u8(0xC1)
  bytes += param_simple(4)
  bytes += param_simple(elements)
  bytes += param_simple(handle)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
array_delete(handle) click to toggle source

@param handle [PAR16] (in) Array handle

# File lib/lignite/ev3_ops.rb, line 7413
def array_delete(handle)
  logger.debug do
    args = [handle]
    "called array_delete with #{args.inspect}"
  end

  bytes = u8(0xC1)
  bytes += param_simple(0)
  bytes += param_simple(handle)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
array_destroy(handle) click to toggle source

@param handle [PAR16] (in) Array handle

# File lib/lignite/ev3_ops.rb, line 7430
def array_destroy(handle)
  logger.debug do
    args = [handle]
    "called array_destroy with #{args.inspect}"
  end

  bytes = u8(0xC1)
  bytes += param_simple(0)
  bytes += param_simple(handle)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
array_fill(handle, value) click to toggle source

@param handle [PAR16] (in) Array handle @param value [PARV] (in) Value to write - type depends on type of array

# File lib/lignite/ev3_ops.rb, line 7543
def array_fill(handle, value)
  logger.debug do
    args = [handle, value]
    "called array_fill with #{args.inspect}"
  end

  bytes = u8(0xC1)
  bytes += param_simple(6)
  bytes += param_simple(handle)
  bytes += param_simple(value)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
array_init16(handle, index, elements, *values) click to toggle source

@param handle [PAR16] (in) Array handle @param index [PAR32] (in) Index to element to write @param elements [PAR32] (in) Number of elements to write @param values [PARVALUES] (in)

# File lib/lignite/ev3_ops.rb, line 7606
def array_init16(handle, index, elements, *values)
  logger.debug do
    args = [handle, index, elements, *values]
    "called array_init16 with #{args.inspect}"
  end

  bytes = u8(0xC1)
  bytes += param_simple(9)
  bytes += param_simple(handle)
  bytes += param_simple(index)
  bytes += param_simple(elements)
  bytes += param_multiple(*values)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
array_init32(handle, index, elements, *values) click to toggle source

@param handle [PAR16] (in) Array handle @param index [PAR32] (in) Index to element to write @param elements [PAR32] (in) Number of elements to write @param values [PARVALUES] (in)

# File lib/lignite/ev3_ops.rb, line 7629
def array_init32(handle, index, elements, *values)
  logger.debug do
    args = [handle, index, elements, *values]
    "called array_init32 with #{args.inspect}"
  end

  bytes = u8(0xC1)
  bytes += param_simple(10)
  bytes += param_simple(handle)
  bytes += param_simple(index)
  bytes += param_simple(elements)
  bytes += param_multiple(*values)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
array_init8(handle, index, elements, *values) click to toggle source

@param handle [PAR16] (in) Array handle @param index [PAR32] (in) Index to element to write @param elements [PAR32] (in) Number of elements to write @param values [PARVALUES] (in)

# File lib/lignite/ev3_ops.rb, line 7583
def array_init8(handle, index, elements, *values)
  logger.debug do
    args = [handle, index, elements, *values]
    "called array_init8 with #{args.inspect}"
  end

  bytes = u8(0xC1)
  bytes += param_simple(8)
  bytes += param_simple(handle)
  bytes += param_simple(index)
  bytes += param_simple(elements)
  bytes += param_multiple(*values)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
array_initf(handle, index, elements, *values) click to toggle source

@param handle [PAR16] (in) Array handle @param index [PAR32] (in) Index to element to write @param elements [PAR32] (in) Number of elements to write @param values [PARVALUES] (in)

# File lib/lignite/ev3_ops.rb, line 7652
def array_initf(handle, index, elements, *values)
  logger.debug do
    args = [handle, index, elements, *values]
    "called array_initf with #{args.inspect}"
  end

  bytes = u8(0xC1)
  bytes += param_simple(11)
  bytes += param_simple(handle)
  bytes += param_simple(index)
  bytes += param_simple(elements)
  bytes += param_multiple(*values)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
array_read(handle, index, value) click to toggle source

Array element read @param handle [PAR16] (in) Array handle @param index [PAR32] (in) Index to first byte to write @param value [PARV] (out) Value to read - type depends on type of array

# File lib/lignite/ev3_ops.rb, line 7825
def array_read(handle, index, value)
  logger.debug do
    args = [handle, index, value]
    "called array_read with #{args.inspect}"
  end

  bytes = u8(0xC3)
  bytes += param_simple(handle)
  bytes += param_simple(index)
  bytes += param_simple(value)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
array_read_content(prgid, handle, index, bytes, array) click to toggle source

@param prgid [PAR16] (in) Program slot number (must be running) @param handle [PAR16] (in) Array handle @param index [PAR32] (in) Index to first byte to read @param bytes [PAR32] (in) Number of bytes to read @param array [PAR8] (out) First byte of array to receive data

# File lib/lignite/ev3_ops.rb, line 7714
def array_read_content(prgid, handle, index, bytes, array)
  logger.debug do
    args = [prgid, handle, index, bytes, array]
    "called array_read_content with #{args.inspect}"
  end

  bytes = u8(0xC1)
  bytes += param_simple(13)
  bytes += param_simple(prgid)
  bytes += param_simple(handle)
  bytes += param_simple(index)
  bytes += param_simple(bytes)
  bytes += param_simple(array)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
array_read_size(prgid, handle, bytes) click to toggle source

@param prgid [PAR16] (in) Program slot number (must be running) @param handle [PAR16] (in) Array handle @param bytes [PAR32] (out) Number of bytes in array

# File lib/lignite/ev3_ops.rb, line 7762
def array_read_size(prgid, handle, bytes)
  logger.debug do
    args = [prgid, handle, bytes]
    "called array_read_size with #{args.inspect}"
  end

  bytes = u8(0xC1)
  bytes += param_simple(15)
  bytes += param_simple(prgid)
  bytes += param_simple(handle)
  bytes += param_simple(bytes)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
array_resize(handle, elements) click to toggle source

@param handle [PAR16] (in) Array handle @param elements [PAR32] (in) Total number of elements

# File lib/lignite/ev3_ops.rb, line 7524
def array_resize(handle, elements)
  logger.debug do
    args = [handle, elements]
    "called array_resize with #{args.inspect}"
  end

  bytes = u8(0xC1)
  bytes += param_simple(5)
  bytes += param_simple(handle)
  bytes += param_simple(elements)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
array_set_size(handle, elements) click to toggle source

@param handle [PAR16] (in) Array handle @param elements [PAR32] (out) Total number of elements in array

# File lib/lignite/ev3_ops.rb, line 7692
def array_set_size(handle, elements)
  logger.debug do
    args = [handle, elements]
    "called array_set_size with #{args.inspect}"
  end

  bytes = u8(0xC1)
  bytes += param_simple(12)
  bytes += param_simple(handle)
  bytes += param_simple(elements)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
array_size(handle, elements) click to toggle source

@param handle [PAR16] (in) Array handle @param elements [PAR32] (out) Total number of elements in array

# File lib/lignite/ev3_ops.rb, line 7673
def array_size(handle, elements)
  logger.debug do
    args = [handle, elements]
    "called array_size with #{args.inspect}"
  end

  bytes = u8(0xC1)
  bytes += param_simple(12)
  bytes += param_simple(handle)
  bytes += param_simple(elements)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
array_write(handle, index, value) click to toggle source

Array element write @param handle [PAR16] (in) Array handle @param index [PAR32] (in) Index to first byte to write @param value [PARV] (in) Value to write - type depends on type of array

# File lib/lignite/ev3_ops.rb, line 7807
def array_write(handle, index, value)
  logger.debug do
    args = [handle, index, value]
    "called array_write with #{args.inspect}"
  end

  bytes = u8(0xC2)
  bytes += param_simple(handle)
  bytes += param_simple(index)
  bytes += param_simple(value)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
array_write_content(prgid, handle, index, bytes, array) click to toggle source

@param prgid [PAR16] (in) Program slot number (must be running) @param handle [PAR16] (in) Array handle @param index [PAR32] (in) Index to first byte to write @param bytes [PAR32] (in) Number of bytes to write @param array [PAR8] (in) First byte of array to deliver data

# File lib/lignite/ev3_ops.rb, line 7739
def array_write_content(prgid, handle, index, bytes, array)
  logger.debug do
    args = [prgid, handle, index, bytes, array]
    "called array_write_content with #{args.inspect}"
  end

  bytes = u8(0xC1)
  bytes += param_simple(14)
  bytes += param_simple(prgid)
  bytes += param_simple(handle)
  bytes += param_simple(index)
  bytes += param_simple(bytes)
  bytes += param_simple(array)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
bp0() click to toggle source

Display globals or object locals on terminal

# File lib/lignite/ev3_ops.rb, line 4799
def bp0
  logger.debug do
    args = []
    "called bp0 with #{args.inspect}"
  end

  bytes = u8(0x88)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
bp1() click to toggle source

Display globals or object locals on terminal

# File lib/lignite/ev3_ops.rb, line 4811
def bp1
  logger.debug do
    args = []
    "called bp1 with #{args.inspect}"
  end

  bytes = u8(0x89)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
bp2() click to toggle source

Display globals or object locals on terminal

# File lib/lignite/ev3_ops.rb, line 4823
def bp2
  logger.debug do
    args = []
    "called bp2 with #{args.inspect}"
  end

  bytes = u8(0x8A)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
bp3() click to toggle source

Display globals or object locals on terminal

# File lib/lignite/ev3_ops.rb, line 4835
def bp3
  logger.debug do
    args = []
    "called bp3 with #{args.inspect}"
  end

  bytes = u8(0x8B)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
bp_set(prgid, no, address) click to toggle source

Set break point in byte code program @param prgid [PAR16] (in) Program slot number @param no [PAR8] (in) Breakpoint number [0..2] (3 = trigger out on TP4) @param address [PAR32] (in) Address (Offset from start of image) (0 = remove breakpoint)

# File lib/lignite/ev3_ops.rb, line 4850
def bp_set(prgid, no, address)
  logger.debug do
    args = [prgid, no, address]
    "called bp_set with #{args.inspect}"
  end

  bytes = u8(0x8C)
  bytes += param_simple(prgid)
  bytes += param_simple(no)
  bytes += param_simple(address)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
call(objid, *parameters) click to toggle source

Calls byte code subroutine @param objid [PAR16] (in) Object id @param parameters [PARNO] (in) Number of parameters

# File lib/lignite/ev3_ops.rb, line 135
def call(objid, *parameters)
  logger.debug do
    args = [objid, *parameters]
    "called call with #{args.inspect}"
  end

  bytes = u8(0x09)
  bytes += param_simple(objid)
  bytes += param_n_multiple(*parameters)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
com_get(*args) click to toggle source
# File lib/lignite/ev3_ops.rb, line 8664
def com_get(*args)
  logger.debug "called com_get with #{args.inspect}"
  cvalue = args.shift
  csym = MULTIPLEX_COM_GET.fetch(cvalue)
  __send__("com_get_#{csym}", *args)
end
com_get_connec_item(hardware, item, length, name, type) click to toggle source

@param hardware [PAR8] () @param item [PAR8] () @param length [PAR8] () @param name [PAR8] () @param type [PAR8] ()

# File lib/lignite/ev3_ops.rb, line 8584
def com_get_connec_item(hardware, item, length, name, type)
  logger.debug do
    args = [hardware, item, length, name, type]
    "called com_get_connec_item with #{args.inspect}"
  end

  bytes = u8(0xD3)
  bytes += param_simple(18)
  bytes += param_simple(hardware)
  bytes += param_simple(item)
  bytes += param_simple(length)
  bytes += param_simple(name)
  bytes += param_simple(type)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
com_get_connec_items(hardware, items) click to toggle source

@param hardware [PAR8] () @param items [PAR8] ()

# File lib/lignite/ev3_ops.rb, line 8562
def com_get_connec_items(hardware, items)
  logger.debug do
    args = [hardware, items]
    "called com_get_connec_items with #{args.inspect}"
  end

  bytes = u8(0xD3)
  bytes += param_simple(17)
  bytes += param_simple(hardware)
  bytes += param_simple(items)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
com_get_favour_item(hardware, item, length, name, paired, connected, type) click to toggle source

Get favourite item information. @param hardware [PAR8] (in) Hardware Transport Layer @param item [PAR8] (in) Item - index in favourite list @param length [PAR8] (in) Max length of returned string @param name [PAR8] (out) First character in character string @param paired [PAR8] (out) Paired [0,1] @param connected [PAR8] (out) Connected [0,1] @param type [PAR8] (out) Bluetooth Device Type

# File lib/lignite/ev3_ops.rb, line 8433
def com_get_favour_item(hardware, item, length, name, paired, connected, type)
  logger.debug do
    args = [hardware, item, length, name, paired, connected, type]
    "called com_get_favour_item with #{args.inspect}"
  end

  bytes = u8(0xD3)
  bytes += param_simple(11)
  bytes += param_simple(hardware)
  bytes += param_simple(item)
  bytes += param_simple(length)
  bytes += param_simple(name)
  bytes += param_simple(paired)
  bytes += param_simple(connected)
  bytes += param_simple(type)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
com_get_favour_items(hardware, items) click to toggle source

Get no of item in favourite list. @param hardware [PAR8] (in) Hardware Transport Layer @param items [PAR8] (out) No of items in seach list

# File lib/lignite/ev3_ops.rb, line 8409
def com_get_favour_items(hardware, items)
  logger.debug do
    args = [hardware, items]
    "called com_get_favour_items with #{args.inspect}"
  end

  bytes = u8(0xD3)
  bytes += param_simple(10)
  bytes += param_simple(hardware)
  bytes += param_simple(items)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
com_get_get_brickname(length, name) click to toggle source

Gets the name of the brick @param length [PAR8] (in) Max length of returned string @param name [PAR8] (out) First character in brick name

# File lib/lignite/ev3_ops.rb, line 8478
def com_get_get_brickname(length, name)
  logger.debug do
    args = [length, name]
    "called com_get_get_brickname with #{args.inspect}"
  end

  bytes = u8(0xD3)
  bytes += param_simple(13)
  bytes += param_simple(length)
  bytes += param_simple(name)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
com_get_get_encrypt(hardware, item, type) click to toggle source

Returns the encryption mode of the hardware. WIFI only @param hardware [PAR8] (in) Hardware Transport Layer @param item [PAR8] (in) Item - index in favourite list @param type [PAR8] (out) Encryption type

# File lib/lignite/ev3_ops.rb, line 8542
def com_get_get_encrypt(hardware, item, type)
  logger.debug do
    args = [hardware, item, type]
    "called com_get_get_encrypt with #{args.inspect}"
  end

  bytes = u8(0xD3)
  bytes += param_simple(16)
  bytes += param_simple(hardware)
  bytes += param_simple(item)
  bytes += param_simple(type)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
com_get_get_id(hardware, length, string) click to toggle source

Get bluetooth address information @param hardware [PAR8] (in) Hardware Transport Layer @param length [PAR8] (in) Max length of returned string @param string [PAR8] (out) First character in BT adr string

# File lib/lignite/ev3_ops.rb, line 8458
def com_get_get_id(hardware, length, string)
  logger.debug do
    args = [hardware, length, string]
    "called com_get_get_id with #{args.inspect}"
  end

  bytes = u8(0xD3)
  bytes += param_simple(12)
  bytes += param_simple(hardware)
  bytes += param_simple(length)
  bytes += param_simple(string)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
com_get_get_incoming(hardware, length, name, type) click to toggle source

Returns the encryption mode of the hardware. WIFI only @param hardware [PAR8] (in) Hardware Transport Layer @param length [PAR8] (in) Max length of returned string @param name [PAR8] (in) First character in name @param type [PAR8] (out) Encryption type

# File lib/lignite/ev3_ops.rb, line 8608
def com_get_get_incoming(hardware, length, name, type)
  logger.debug do
    args = [hardware, length, name, type]
    "called com_get_get_incoming with #{args.inspect}"
  end

  bytes = u8(0xD3)
  bytes += param_simple(19)
  bytes += param_simple(hardware)
  bytes += param_simple(length)
  bytes += param_simple(name)
  bytes += param_simple(type)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
com_get_get_mode2(hardware, active) click to toggle source

@param hardware [PAR8] (in) Hardware Transport Layer @param active [PAR8] (out) Active [0,1], 1 = on, 0 = off

# File lib/lignite/ev3_ops.rb, line 8629
def com_get_get_mode2(hardware, active)
  logger.debug do
    args = [hardware, active]
    "called com_get_get_mode2 with #{args.inspect}"
  end

  bytes = u8(0xD3)
  bytes += param_simple(20)
  bytes += param_simple(hardware)
  bytes += param_simple(active)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
com_get_get_network(hardware, length, name, mac, ip) click to toggle source

Gets the network information. WIFI only @param hardware [PAR8] (in) Hardware Transport Layer @param length [PAR8] (in) Max length of returned string @param name [PAR8] (out) First character in AP name @param mac [PAR8] (out) First character in MAC address string @param ip [PAR8] (out) First character in IP address string

# File lib/lignite/ev3_ops.rb, line 8500
def com_get_get_network(hardware, length, name, mac, ip)
  logger.debug do
    args = [hardware, length, name, mac, ip]
    "called com_get_get_network with #{args.inspect}"
  end

  bytes = u8(0xD3)
  bytes += param_simple(14)
  bytes += param_simple(hardware)
  bytes += param_simple(length)
  bytes += param_simple(name)
  bytes += param_simple(mac)
  bytes += param_simple(ip)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
com_get_get_on_off(hardware, active) click to toggle source

Get active state @param hardware [PAR8] (in) Hardware Transport Layer @param active [PAR8] (out) Active [0,1]

# File lib/lignite/ev3_ops.rb, line 8258
def com_get_get_on_off(hardware, active)
  logger.debug do
    args = [hardware, active]
    "called com_get_get_on_off with #{args.inspect}"
  end

  bytes = u8(0xD3)
  bytes += param_simple(1)
  bytes += param_simple(hardware)
  bytes += param_simple(active)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
com_get_get_pin(hardware, name, length, pincode) click to toggle source

Get pin code. @param hardware [PAR8] (in) Hardware Transport Layer @param name [PAR8] (in) First character in character string @param length [PAR8] (in) Max length of returned string @param pincode [PAR8] (out) First character in character string

# File lib/lignite/ev3_ops.rb, line 8319
def com_get_get_pin(hardware, name, length, pincode)
  logger.debug do
    args = [hardware, name, length, pincode]
    "called com_get_get_pin with #{args.inspect}"
  end

  bytes = u8(0xD3)
  bytes += param_simple(5)
  bytes += param_simple(hardware)
  bytes += param_simple(name)
  bytes += param_simple(length)
  bytes += param_simple(pincode)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
com_get_get_present(hardware, ok) click to toggle source

Return if hardare is present. WIFI only @param hardware [PAR8] (in) Hardware Transport Layer @param ok [PAR8] (out) Present [0,1]

# File lib/lignite/ev3_ops.rb, line 8522
def com_get_get_present(hardware, ok)
  logger.debug do
    args = [hardware, ok]
    "called com_get_get_present with #{args.inspect}"
  end

  bytes = u8(0xD3)
  bytes += param_simple(15)
  bytes += param_simple(hardware)
  bytes += param_simple(ok)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
com_get_get_result(hardware, item, result) click to toggle source

Get status. @param hardware [PAR8] (in) Hardware Transport Layer @param item [PAR8] (in) Name index @param result [PAR8] (out) Results

# File lib/lignite/ev3_ops.rb, line 8297
def com_get_get_result(hardware, item, result)
  logger.debug do
    args = [hardware, item, result]
    "called com_get_get_result with #{args.inspect}"
  end

  bytes = u8(0xD3)
  bytes += param_simple(4)
  bytes += param_simple(hardware)
  bytes += param_simple(item)
  bytes += param_simple(result)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
com_get_get_visible(hardware, visible) click to toggle source

Get visibility state @param hardware [PAR8] (in) Hardware Transport Layer @param visible [PAR8] (out) Visible [0,1]

# File lib/lignite/ev3_ops.rb, line 8277
def com_get_get_visible(hardware, visible)
  logger.debug do
    args = [hardware, visible]
    "called com_get_get_visible with #{args.inspect}"
  end

  bytes = u8(0xD3)
  bytes += param_simple(2)
  bytes += param_simple(hardware)
  bytes += param_simple(visible)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
com_get_list_state(hardware, state) click to toggle source

Gets a list state value. This can be compared to previous values to determine if items are added or removed from a list since the last call. @param hardware [PAR8] (in) Hardware Transport Layer @param state [PAR16] (out) Value that represents the current state

# File lib/lignite/ev3_ops.rb, line 8340
def com_get_list_state(hardware, state)
  logger.debug do
    args = [hardware, state]
    "called com_get_list_state with #{args.inspect}"
  end

  bytes = u8(0xD3)
  bytes += param_simple(7)
  bytes += param_simple(hardware)
  bytes += param_simple(state)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
com_get_search_item(hardware, item, length, name, paired, connected, type, visible) click to toggle source

Get search item informations. @param hardware [PAR8] (in) Hardware Transport Layer @param item [PAR8] (in) Item - index in search list @param length [PAR8] (in) Max length of returned string @param name [PAR8] (out) First character in character string @param paired [PAR8] (out) Paired [0,1] @param connected [PAR8] (out) Connected [0,1] @param type [PAR8] (out) Bluetooth Device Type @param visible [PAR8] (out) Visible [0,1]

# File lib/lignite/ev3_ops.rb, line 8384
def com_get_search_item(hardware, item, length, name, paired, connected, type, visible)
  logger.debug do
    args = [hardware, item, length, name, paired, connected, type, visible]
    "called com_get_search_item with #{args.inspect}"
  end

  bytes = u8(0xD3)
  bytes += param_simple(9)
  bytes += param_simple(hardware)
  bytes += param_simple(item)
  bytes += param_simple(length)
  bytes += param_simple(name)
  bytes += param_simple(paired)
  bytes += param_simple(connected)
  bytes += param_simple(type)
  bytes += param_simple(visible)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
com_get_search_items(hardware, items) click to toggle source

Get number of item from search. @param hardware [PAR8] (in) Hardware Transport Layer @param items [PAR8] (out) No of items in seach list

# File lib/lignite/ev3_ops.rb, line 8359
def com_get_search_items(hardware, items)
  logger.debug do
    args = [hardware, items]
    "called com_get_search_items with #{args.inspect}"
  end

  bytes = u8(0xD3)
  bytes += param_simple(8)
  bytes += param_simple(hardware)
  bytes += param_simple(items)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
com_read(*args) click to toggle source
# File lib/lignite/ev3_ops.rb, line 5381
def com_read(*args)
  logger.debug "called com_read with #{args.inspect}"
  cvalue = args.shift
  csym = MULTIPLEX_COM_READ.fetch(cvalue)
  __send__("com_read_#{csym}", *args)
end
com_read_command(length, image, global, flag) click to toggle source

@param length [PAR32] (in) Maximal code stream length @param image [PAR32] (out) Address of image @param global [PAR32] (out) Address of global variables @param flag [PAR8] (out) Flag that tells if image is ready

# File lib/lignite/ev3_ops.rb, line 5361
def com_read_command(length, image, global, flag)
  logger.debug do
    args = [length, image, global, flag]
    "called com_read_command with #{args.inspect}"
  end

  bytes = u8(0x91)
  bytes += param_simple(14)
  bytes += param_simple(length)
  bytes += param_simple(image)
  bytes += param_simple(global)
  bytes += param_simple(flag)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
com_readdata(value1, value2, value3, value4) click to toggle source

This code does not exist in normal program @param value1 [PAR8] () @param value2 [PAR8] () @param value3 [PAR16] () @param value4 [PAR8] ()

# File lib/lignite/ev3_ops.rb, line 8217
def com_readdata(value1, value2, value3, value4)
  logger.debug do
    args = [value1, value2, value3, value4]
    "called com_readdata with #{args.inspect}"
  end

  bytes = u8(0xD1)
  bytes += param_simple(value1)
  bytes += param_simple(value2)
  bytes += param_simple(value3)
  bytes += param_simple(value4)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
com_ready(hardware, name) click to toggle source

Test if communication is busy @param hardware [PAR8] (in) Hardware transport layer @param name [PAR8] (in) Name of the remote/own device

# File lib/lignite/ev3_ops.rb, line 8199
def com_ready(hardware, name)
  logger.debug do
    args = [hardware, name]
    "called com_ready with #{args.inspect}"
  end

  bytes = u8(0xD0)
  bytes += param_simple(hardware)
  bytes += param_simple(name)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
com_remove(hardware, remote_name) click to toggle source

Removes a know remote device from the brick @param hardware [PAR8] () @param remote_name [PAR8] () Pointer to remote brick name

# File lib/lignite/ev3_ops.rb, line 8947
def com_remove(hardware, remote_name)
  logger.debug do
    args = [hardware, remote_name]
    "called com_remove with #{args.inspect}"
  end

  bytes = u8(0xD6)
  bytes += param_simple(hardware)
  bytes += param_simple(remote_name)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
com_set(*args) click to toggle source
# File lib/lignite/ev3_ops.rb, line 8919
def com_set(*args)
  logger.debug "called com_set with #{args.inspect}"
  cvalue = args.shift
  csym = MULTIPLEX_COM_SET.fetch(cvalue)
  __send__("com_set_#{csym}", *args)
end
com_set_set_brickname(name) click to toggle source

Sets the name of the brick @param name [PAR8] (in) First character in character string

# File lib/lignite/ev3_ops.rb, line 8794
def com_set_set_brickname(name)
  logger.debug do
    args = [name]
    "called com_set_set_brickname with #{args.inspect}"
  end

  bytes = u8(0xD4)
  bytes += param_simple(8)
  bytes += param_simple(name)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
com_set_set_connection(hardware, name, connection) click to toggle source

Initiate or close the connection request to a remote device by the specified name. @param hardware [PAR8] (in) Hardware Transport Layer @param name [PAR8] (in) First character in character string @param connection [PAR8] (in) Connect [0,1], 1 = Connect, 0 = Disconnect

# File lib/lignite/ev3_ops.rb, line 8775
def com_set_set_connection(hardware, name, connection)
  logger.debug do
    args = [hardware, name, connection]
    "called com_set_set_connection with #{args.inspect}"
  end

  bytes = u8(0xD4)
  bytes += param_simple(7)
  bytes += param_simple(hardware)
  bytes += param_simple(name)
  bytes += param_simple(connection)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
com_set_set_encrypt(hardware, item, encrypt) click to toggle source

Sets the encryption type for an item in a list. @param hardware [PAR8] (in) Hardware Transport Layer @param item [PAR8] (in) Index in table @param encrypt [PAR8] (in) Encryption type

# File lib/lignite/ev3_ops.rb, line 8851
def com_set_set_encrypt(hardware, item, encrypt)
  logger.debug do
    args = [hardware, item, encrypt]
    "called com_set_set_encrypt with #{args.inspect}"
  end

  bytes = u8(0xD4)
  bytes += param_simple(11)
  bytes += param_simple(hardware)
  bytes += param_simple(item)
  bytes += param_simple(encrypt)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
com_set_set_mode2(hardware, active) click to toggle source

Set active mode state, either active or not @param hardware [PAR8] (in) Hardware Transport Layer @param active [PAR8] (in) Active [0,1], 1 = on, 0 = off

# File lib/lignite/ev3_ops.rb, line 8890
def com_set_set_mode2(hardware, active)
  logger.debug do
    args = [hardware, active]
    "called com_set_set_mode2 with #{args.inspect}"
  end

  bytes = u8(0xD4)
  bytes += param_simple(13)
  bytes += param_simple(hardware)
  bytes += param_simple(active)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
com_set_set_movedown(hardware, item) click to toggle source

Moves the index in list one step down. @param hardware [PAR8] (in) Hardware Transport Layer @param item [PAR8] (in) Index in table

# File lib/lignite/ev3_ops.rb, line 8831
def com_set_set_movedown(hardware, item)
  logger.debug do
    args = [hardware, item]
    "called com_set_set_movedown with #{args.inspect}"
  end

  bytes = u8(0xD4)
  bytes += param_simple(10)
  bytes += param_simple(hardware)
  bytes += param_simple(item)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
com_set_set_moveup(hardware, item) click to toggle source

Moves the index in list one step up. @param hardware [PAR8] (in) Hardware Transport Layer @param item [PAR8] (in) Index in table

# File lib/lignite/ev3_ops.rb, line 8812
def com_set_set_moveup(hardware, item)
  logger.debug do
    args = [hardware, item]
    "called com_set_set_moveup with #{args.inspect}"
  end

  bytes = u8(0xD4)
  bytes += param_simple(9)
  bytes += param_simple(hardware)
  bytes += param_simple(item)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
com_set_set_on_off(hardware, active) click to toggle source

Set active state, either on or off @param hardware [PAR8] (in) Hardware Transport Layer @param active [PAR8] (in) Active [0,1], 1 = on, 0 = off

# File lib/lignite/ev3_ops.rb, line 8677
def com_set_set_on_off(hardware, active)
  logger.debug do
    args = [hardware, active]
    "called com_set_set_on_off with #{args.inspect}"
  end

  bytes = u8(0xD4)
  bytes += param_simple(1)
  bytes += param_simple(hardware)
  bytes += param_simple(active)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
com_set_set_passkey(hardware, accept) click to toggle source

Set pin code. @param hardware [PAR8] (in) Hardware Transport Layer @param accept [PAR8] (in) Acceptance [0,1] 0 = reject 1 = accept

# File lib/lignite/ev3_ops.rb, line 8755
def com_set_set_passkey(hardware, accept)
  logger.debug do
    args = [hardware, accept]
    "called com_set_set_passkey with #{args.inspect}"
  end

  bytes = u8(0xD4)
  bytes += param_simple(6)
  bytes += param_simple(hardware)
  bytes += param_simple(accept)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
com_set_set_pin(hardware, name, pincode) click to toggle source

Set pin code. @param hardware [PAR8] (in) Hardware Transport Layer @param name [PAR8] (in) First character in character string @param pincode [PAR8] (in) First character in character string

# File lib/lignite/ev3_ops.rb, line 8735
def com_set_set_pin(hardware, name, pincode)
  logger.debug do
    args = [hardware, name, pincode]
    "called com_set_set_pin with #{args.inspect}"
  end

  bytes = u8(0xD4)
  bytes += param_simple(5)
  bytes += param_simple(hardware)
  bytes += param_simple(name)
  bytes += param_simple(pincode)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
com_set_set_ssid(hardware, name) click to toggle source

Sets the SSID name. Only used for WIFI @param hardware [PAR8] (in) Hardware Transport Layer @param name [PAR8] (in) First character in character string

# File lib/lignite/ev3_ops.rb, line 8871
def com_set_set_ssid(hardware, name)
  logger.debug do
    args = [hardware, name]
    "called com_set_set_ssid with #{args.inspect}"
  end

  bytes = u8(0xD4)
  bytes += param_simple(12)
  bytes += param_simple(hardware)
  bytes += param_simple(name)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
com_set_set_visible(hardware, visible) click to toggle source

Set visibility state - Only available for bluetooth @param hardware [PAR8] (in) Hardware Transport Layer @param visible [PAR8] (in) Visible [0,1], 1 = visible, 0 = invisible

# File lib/lignite/ev3_ops.rb, line 8696
def com_set_set_visible(hardware, visible)
  logger.debug do
    args = [hardware, visible]
    "called com_set_set_visible with #{args.inspect}"
  end

  bytes = u8(0xD4)
  bytes += param_simple(2)
  bytes += param_simple(hardware)
  bytes += param_simple(visible)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
com_test(hardware, name, busy) click to toggle source

Test if communication is busy @param hardware [PAR8] (in) Hardware transport layer @param name [PAR8] (in) Name of the remote/own device @param busy [PAR8] (out) Busy flag

# File lib/lignite/ev3_ops.rb, line 8930
def com_test(hardware, name, busy)
  logger.debug do
    args = [hardware, name, busy]
    "called com_test with #{args.inspect}"
  end

  bytes = u8(0xD5)
  bytes += param_simple(hardware)
  bytes += param_simple(name)
  bytes += param_simple(busy)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
com_write(*args) click to toggle source
# File lib/lignite/ev3_ops.rb, line 5414
def com_write(*args)
  logger.debug "called com_write with #{args.inspect}"
  cvalue = args.shift
  csym = MULTIPLEX_COM_WRITE.fetch(cvalue)
  __send__("com_write_#{csym}", *args)
end
com_write_reply(image, global, status) click to toggle source

@param image [PAR32] (in) Address of image @param global [PAR32] (in) Address of global variables @param status [PAR8] (in) Status

# File lib/lignite/ev3_ops.rb, line 5395
def com_write_reply(image, global, status)
  logger.debug do
    args = [image, global, status]
    "called com_write_reply with #{args.inspect}"
  end

  bytes = u8(0x92)
  bytes += param_simple(14)
  bytes += param_simple(image)
  bytes += param_simple(global)
  bytes += param_simple(status)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
com_writedata(value1, value2, value3, value4) click to toggle source

This code does not exist in normal program @param value1 [PAR8] () @param value2 [PAR8] () @param value3 [PAR16] () @param value4 [PAR8] ()

# File lib/lignite/ev3_ops.rb, line 8237
def com_writedata(value1, value2, value3, value4)
  logger.debug do
    args = [value1, value2, value3, value4]
    "called com_writedata with #{args.inspect}"
  end

  bytes = u8(0xD2)
  bytes += param_simple(value1)
  bytes += param_simple(value2)
  bytes += param_simple(value3)
  bytes += param_simple(value4)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
com_writefile(hardware, remote_name, file_name, file_type) click to toggle source

Sends a file or folder to remote brick. @param hardware [PAR8] () @param remote_name [PAR8] () Pointer to remote brick name @param file_name [PAR8] () File/folder name to send @param file_type [PAR8] () File or folder type to send

# File lib/lignite/ev3_ops.rb, line 8965
def com_writefile(hardware, remote_name, file_name, file_type)
  logger.debug do
    args = [hardware, remote_name, file_name, file_type]
    "called com_writefile with #{args.inspect}"
  end

  bytes = u8(0xD7)
  bytes += param_simple(hardware)
  bytes += param_simple(remote_name)
  bytes += param_simple(file_name)
  bytes += param_simple(file_type)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
cp_eq16(left, right, flag) click to toggle source

If LEFT is equal to RIGTH - set FLAG @param left [PAR16] (in) @param right [PAR16] (in) @param flag [PAR8] (out)

# File lib/lignite/ev3_ops.rb, line 1367
def cp_eq16(left, right, flag)
  logger.debug do
    args = [left, right, flag]
    "called cp_eq16 with #{args.inspect}"
  end

  bytes = u8(0x4D)
  bytes += param_simple(left)
  bytes += param_simple(right)
  bytes += param_simple(flag)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
cp_eq32(left, right, flag) click to toggle source

If LEFT is equal to RIGTH - set FLAG @param left [PAR32] (in) @param right [PAR32] (in) @param flag [PAR8] (out)

# File lib/lignite/ev3_ops.rb, line 1385
def cp_eq32(left, right, flag)
  logger.debug do
    args = [left, right, flag]
    "called cp_eq32 with #{args.inspect}"
  end

  bytes = u8(0x4E)
  bytes += param_simple(left)
  bytes += param_simple(right)
  bytes += param_simple(flag)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
cp_eq8(left, right, flag) click to toggle source

If LEFT is equal to RIGTH - set FLAG @param left [PAR8] (in) @param right [PAR8] (in) @param flag [PAR8] (out)

# File lib/lignite/ev3_ops.rb, line 1349
def cp_eq8(left, right, flag)
  logger.debug do
    args = [left, right, flag]
    "called cp_eq8 with #{args.inspect}"
  end

  bytes = u8(0x4C)
  bytes += param_simple(left)
  bytes += param_simple(right)
  bytes += param_simple(flag)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
cp_eqf(left, right, flag) click to toggle source

If LEFT is equal to RIGTH - set FLAG @param left [PARF] (in) @param right [PARF] (in) @param flag [PAR8] (out)

# File lib/lignite/ev3_ops.rb, line 1403
def cp_eqf(left, right, flag)
  logger.debug do
    args = [left, right, flag]
    "called cp_eqf with #{args.inspect}"
  end

  bytes = u8(0x4F)
  bytes += param_simple(left)
  bytes += param_simple(right)
  bytes += param_simple(flag)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
cp_gt16(left, right, flag) click to toggle source

If LEFT is greater than RIGTH - set FLAG @param left [PAR16] (in) @param right [PAR16] (in) @param flag [PAR8] (out)

# File lib/lignite/ev3_ops.rb, line 1295
def cp_gt16(left, right, flag)
  logger.debug do
    args = [left, right, flag]
    "called cp_gt16 with #{args.inspect}"
  end

  bytes = u8(0x49)
  bytes += param_simple(left)
  bytes += param_simple(right)
  bytes += param_simple(flag)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
cp_gt32(left, right, flag) click to toggle source

If LEFT is greater than RIGTH - set FLAG @param left [PAR32] (in) @param right [PAR32] (in) @param flag [PAR8] (out)

# File lib/lignite/ev3_ops.rb, line 1313
def cp_gt32(left, right, flag)
  logger.debug do
    args = [left, right, flag]
    "called cp_gt32 with #{args.inspect}"
  end

  bytes = u8(0x4A)
  bytes += param_simple(left)
  bytes += param_simple(right)
  bytes += param_simple(flag)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
cp_gt8(left, right, flag) click to toggle source

If LEFT is greater than RIGTH - set FLAG @param left [PAR8] (in) @param right [PAR8] (in) @param flag [PAR8] (out)

# File lib/lignite/ev3_ops.rb, line 1277
def cp_gt8(left, right, flag)
  logger.debug do
    args = [left, right, flag]
    "called cp_gt8 with #{args.inspect}"
  end

  bytes = u8(0x48)
  bytes += param_simple(left)
  bytes += param_simple(right)
  bytes += param_simple(flag)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
cp_gteq16(left, right, flag) click to toggle source

If LEFT is greater than or equal to RIGTH - set FLAG @param left [PAR16] (in) @param right [PAR16] (in) @param flag [PAR8] (out)

# File lib/lignite/ev3_ops.rb, line 1583
def cp_gteq16(left, right, flag)
  logger.debug do
    args = [left, right, flag]
    "called cp_gteq16 with #{args.inspect}"
  end

  bytes = u8(0x59)
  bytes += param_simple(left)
  bytes += param_simple(right)
  bytes += param_simple(flag)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
cp_gteq32(left, right, flag) click to toggle source

If LEFT is greater than or equal to RIGTH - set FLAG @param left [PAR32] (in) @param right [PAR32] (in) @param flag [PAR8] (out)

# File lib/lignite/ev3_ops.rb, line 1601
def cp_gteq32(left, right, flag)
  logger.debug do
    args = [left, right, flag]
    "called cp_gteq32 with #{args.inspect}"
  end

  bytes = u8(0x5A)
  bytes += param_simple(left)
  bytes += param_simple(right)
  bytes += param_simple(flag)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
cp_gteq8(left, right, flag) click to toggle source

If LEFT is greater than or equal to RIGTH - set FLAG @param left [PAR8] (in) @param right [PAR8] (in) @param flag [PAR8] (out)

# File lib/lignite/ev3_ops.rb, line 1565
def cp_gteq8(left, right, flag)
  logger.debug do
    args = [left, right, flag]
    "called cp_gteq8 with #{args.inspect}"
  end

  bytes = u8(0x58)
  bytes += param_simple(left)
  bytes += param_simple(right)
  bytes += param_simple(flag)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
cp_gteqf(left, right, flag) click to toggle source

If LEFT is greater than or equal to RIGTH - set FLAG @param left [PARF] (in) @param right [PARF] (in) @param flag [PAR8] (out)

# File lib/lignite/ev3_ops.rb, line 1619
def cp_gteqf(left, right, flag)
  logger.debug do
    args = [left, right, flag]
    "called cp_gteqf with #{args.inspect}"
  end

  bytes = u8(0x5B)
  bytes += param_simple(left)
  bytes += param_simple(right)
  bytes += param_simple(flag)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
cp_gtf(left, right, flag) click to toggle source

If LEFT is greater than RIGTH - set FLAG @param left [PARF] (in) @param right [PARF] (in) @param flag [PAR8] (out)

# File lib/lignite/ev3_ops.rb, line 1331
def cp_gtf(left, right, flag)
  logger.debug do
    args = [left, right, flag]
    "called cp_gtf with #{args.inspect}"
  end

  bytes = u8(0x4B)
  bytes += param_simple(left)
  bytes += param_simple(right)
  bytes += param_simple(flag)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
cp_lt16(left, right, flag) click to toggle source

If LEFT is less than RIGTH - set FLAG @param left [PAR16] (in) @param right [PAR16] (in) @param flag [PAR8] (out)

# File lib/lignite/ev3_ops.rb, line 1223
def cp_lt16(left, right, flag)
  logger.debug do
    args = [left, right, flag]
    "called cp_lt16 with #{args.inspect}"
  end

  bytes = u8(0x45)
  bytes += param_simple(left)
  bytes += param_simple(right)
  bytes += param_simple(flag)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
cp_lt32(left, right, flag) click to toggle source

If LEFT is less than RIGTH - set FLAG @param left [PAR32] (in) @param right [PAR32] (in) @param flag [PAR8] (out)

# File lib/lignite/ev3_ops.rb, line 1241
def cp_lt32(left, right, flag)
  logger.debug do
    args = [left, right, flag]
    "called cp_lt32 with #{args.inspect}"
  end

  bytes = u8(0x46)
  bytes += param_simple(left)
  bytes += param_simple(right)
  bytes += param_simple(flag)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
cp_lt8(left, right, flag) click to toggle source

If LEFT is less than RIGTH - set FLAG @param left [PAR8] (in) @param right [PAR8] (in) @param flag [PAR8] (out)

# File lib/lignite/ev3_ops.rb, line 1205
def cp_lt8(left, right, flag)
  logger.debug do
    args = [left, right, flag]
    "called cp_lt8 with #{args.inspect}"
  end

  bytes = u8(0x44)
  bytes += param_simple(left)
  bytes += param_simple(right)
  bytes += param_simple(flag)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
cp_lteq16(left, right, flag) click to toggle source

If LEFT is less than or equal to RIGTH - set FLAG @param left [PAR16] (in) @param right [PAR16] (in) @param flag [PAR8] (out)

# File lib/lignite/ev3_ops.rb, line 1511
def cp_lteq16(left, right, flag)
  logger.debug do
    args = [left, right, flag]
    "called cp_lteq16 with #{args.inspect}"
  end

  bytes = u8(0x55)
  bytes += param_simple(left)
  bytes += param_simple(right)
  bytes += param_simple(flag)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
cp_lteq32(left, right, flag) click to toggle source

If LEFT is less than or equal to RIGTH - set FLAG @param left [PAR32] (in) @param right [PAR32] (in) @param flag [PAR8] (out)

# File lib/lignite/ev3_ops.rb, line 1529
def cp_lteq32(left, right, flag)
  logger.debug do
    args = [left, right, flag]
    "called cp_lteq32 with #{args.inspect}"
  end

  bytes = u8(0x56)
  bytes += param_simple(left)
  bytes += param_simple(right)
  bytes += param_simple(flag)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
cp_lteq8(left, right, flag) click to toggle source

If LEFT is less than or equal to RIGTH - set FLAG @param left [PAR8] (in) @param right [PAR8] (in) @param flag [PAR8] (out)

# File lib/lignite/ev3_ops.rb, line 1493
def cp_lteq8(left, right, flag)
  logger.debug do
    args = [left, right, flag]
    "called cp_lteq8 with #{args.inspect}"
  end

  bytes = u8(0x54)
  bytes += param_simple(left)
  bytes += param_simple(right)
  bytes += param_simple(flag)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
cp_lteqf(left, right, flag) click to toggle source

If LEFT is less than or equal to RIGTH - set FLAG @param left [PARF] (in) @param right [PARF] (in) @param flag [PAR8] (out)

# File lib/lignite/ev3_ops.rb, line 1547
def cp_lteqf(left, right, flag)
  logger.debug do
    args = [left, right, flag]
    "called cp_lteqf with #{args.inspect}"
  end

  bytes = u8(0x57)
  bytes += param_simple(left)
  bytes += param_simple(right)
  bytes += param_simple(flag)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
cp_ltf(left, right, flag) click to toggle source

If LEFT is less than RIGTH - set FLAG @param left [PARF] (in) @param right [PARF] (in) @param flag [PAR8] (out)

# File lib/lignite/ev3_ops.rb, line 1259
def cp_ltf(left, right, flag)
  logger.debug do
    args = [left, right, flag]
    "called cp_ltf with #{args.inspect}"
  end

  bytes = u8(0x47)
  bytes += param_simple(left)
  bytes += param_simple(right)
  bytes += param_simple(flag)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
cp_neq16(left, right, flag) click to toggle source

If LEFT is not equal to RIGTH - set FLAG @param left [PAR16] (in) @param right [PAR16] (in) @param flag [PAR8] (out)

# File lib/lignite/ev3_ops.rb, line 1439
def cp_neq16(left, right, flag)
  logger.debug do
    args = [left, right, flag]
    "called cp_neq16 with #{args.inspect}"
  end

  bytes = u8(0x51)
  bytes += param_simple(left)
  bytes += param_simple(right)
  bytes += param_simple(flag)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
cp_neq32(left, right, flag) click to toggle source

If LEFT is not equal to RIGTH - set FLAG @param left [PAR32] (in) @param right [PAR32] (in) @param flag [PAR8] (out)

# File lib/lignite/ev3_ops.rb, line 1457
def cp_neq32(left, right, flag)
  logger.debug do
    args = [left, right, flag]
    "called cp_neq32 with #{args.inspect}"
  end

  bytes = u8(0x52)
  bytes += param_simple(left)
  bytes += param_simple(right)
  bytes += param_simple(flag)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
cp_neq8(left, right, flag) click to toggle source

If LEFT is not equal to RIGTH - set FLAG @param left [PAR8] (in) @param right [PAR8] (in) @param flag [PAR8] (out)

# File lib/lignite/ev3_ops.rb, line 1421
def cp_neq8(left, right, flag)
  logger.debug do
    args = [left, right, flag]
    "called cp_neq8 with #{args.inspect}"
  end

  bytes = u8(0x50)
  bytes += param_simple(left)
  bytes += param_simple(right)
  bytes += param_simple(flag)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
cp_neqf(left, right, flag) click to toggle source

If LEFT is not equal to RIGTH - set FLAG @param left [PARF] (in) @param right [PARF] (in) @param flag [PAR8] (out)

# File lib/lignite/ev3_ops.rb, line 1475
def cp_neqf(left, right, flag)
  logger.debug do
    args = [left, right, flag]
    "called cp_neqf with #{args.inspect}"
  end

  bytes = u8(0x53)
  bytes += param_simple(left)
  bytes += param_simple(right)
  bytes += param_simple(flag)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
div16(source1, source2, destination) click to toggle source

Divide two 16 bit values DESTINATION = SOURCE1 / SOURCE2 @param source1 [PAR16] (in) @param source2 [PAR16] (in) @param destination [PAR16] (out)

# File lib/lignite/ev3_ops.rb, line 599
def div16(source1, source2, destination)
  logger.debug do
    args = [source1, source2, destination]
    "called div16 with #{args.inspect}"
  end

  bytes = u8(0x1D)
  bytes += param_simple(source1)
  bytes += param_simple(source2)
  bytes += param_simple(destination)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
div32(source1, source2, destination) click to toggle source

Divide two 32 bit values DESTINATION = SOURCE1 / SOURCE2 @param source1 [PAR32] (in) @param source2 [PAR32] (in) @param destination [PAR32] (out)

# File lib/lignite/ev3_ops.rb, line 617
def div32(source1, source2, destination)
  logger.debug do
    args = [source1, source2, destination]
    "called div32 with #{args.inspect}"
  end

  bytes = u8(0x1E)
  bytes += param_simple(source1)
  bytes += param_simple(source2)
  bytes += param_simple(destination)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
div8(source1, source2, destination) click to toggle source

Divide two 8 bit values DESTINATION = SOURCE1 / SOURCE2 @param source1 [PAR8] (in) @param source2 [PAR8] (in) @param destination [PAR8] (out)

# File lib/lignite/ev3_ops.rb, line 581
def div8(source1, source2, destination)
  logger.debug do
    args = [source1, source2, destination]
    "called div8 with #{args.inspect}"
  end

  bytes = u8(0x1C)
  bytes += param_simple(source1)
  bytes += param_simple(source2)
  bytes += param_simple(destination)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
divf(source1, source2, destination) click to toggle source

Divide two floating point values DESTINATION = SOURCE1 / SOURCE2 @param source1 [PARF] (in) @param source2 [PARF] (in) @param destination [PARF] (out)

# File lib/lignite/ev3_ops.rb, line 635
def divf(source1, source2, destination)
  logger.debug do
    args = [source1, source2, destination]
    "called divf with #{args.inspect}"
  end

  bytes = u8(0x1F)
  bytes += param_simple(source1)
  bytes += param_simple(source2)
  bytes += param_simple(destination)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
do(prgid, image, global) click to toggle source

Run byte code snippet @param prgid [PAR16] (in) Program slot number @param image [PAR32] (in) Address of image @param global [PAR32] (in) Address of global variables

# File lib/lignite/ev3_ops.rb, line 347
def do(prgid, image, global)
  logger.debug do
    args = [prgid, image, global]
    "called do with #{args.inspect}"
  end

  bytes = u8(0x0F)
  bytes += param_simple(prgid)
  bytes += param_simple(image)
  bytes += param_simple(global)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
dynload_entry_0(cmd, length_in, length_out, value) click to toggle source

Execute Entry Point function 0 in Third Party VM @param cmd [PAR8] (in) Sub command to be executed @param length_in [PAR8] (in) Amount of data passed to this opcode @param length_out [PAR16] (out) Amount of data returned @param value [PARV] (out) Data from opcode

# File lib/lignite/ev3_ops.rb, line 9253
def dynload_entry_0(cmd, length_in, length_out, value)
  logger.debug do
    args = [cmd, length_in, length_out, value]
    "called dynload_entry_0 with #{args.inspect}"
  end

  bytes = u8(0xF2)
  bytes += param_simple(cmd)
  bytes += param_simple(length_in)
  bytes += param_simple(length_out)
  bytes += param_simple(value)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
dynload_entry_1(cmd, length_in, length_out, value) click to toggle source

Execute Entry Point function 1 in Third Party VM @param cmd [PAR8] (in) Sub command to be executed @param length_in [PAR8] (in) Amount of data passed to this opcode @param length_out [PAR16] (out) Amount of data returned @param value [PARV] (out) Data from opcode

# File lib/lignite/ev3_ops.rb, line 9273
def dynload_entry_1(cmd, length_in, length_out, value)
  logger.debug do
    args = [cmd, length_in, length_out, value]
    "called dynload_entry_1 with #{args.inspect}"
  end

  bytes = u8(0xF3)
  bytes += param_simple(cmd)
  bytes += param_simple(length_in)
  bytes += param_simple(length_out)
  bytes += param_simple(value)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
dynload_entry_2(cmd, length_in, length_out, value) click to toggle source

Execute Entry Point function 2 in Third Party VM @param cmd [PAR8] (in) Sub command to be executed @param length_in [PAR8] (in) Amount of data passed to this opcode @param length_out [PAR16] (out) Amount of data returned @param value [PARV] (out) Data from opcode

# File lib/lignite/ev3_ops.rb, line 9293
def dynload_entry_2(cmd, length_in, length_out, value)
  logger.debug do
    args = [cmd, length_in, length_out, value]
    "called dynload_entry_2 with #{args.inspect}"
  end

  bytes = u8(0xF4)
  bytes += param_simple(cmd)
  bytes += param_simple(length_in)
  bytes += param_simple(length_out)
  bytes += param_simple(value)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
dynload_entry_3(cmd, length_in, length_out, value) click to toggle source

Execute Entry Point function 3 in Third Party VM @param cmd [PAR8] (in) Sub command to be executed @param length_in [PAR8] (in) Amount of data passed to this opcode @param length_out [PAR16] (out) Amount of data returned @param value [PARV] (out) Data from opcode

# File lib/lignite/ev3_ops.rb, line 9313
def dynload_entry_3(cmd, length_in, length_out, value)
  logger.debug do
    args = [cmd, length_in, length_out, value]
    "called dynload_entry_3 with #{args.inspect}"
  end

  bytes = u8(0xF5)
  bytes += param_simple(cmd)
  bytes += param_simple(length_in)
  bytes += param_simple(length_out)
  bytes += param_simple(value)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
dynload_entry_4(cmd, length_in, length_out, value) click to toggle source

Execute Entry Point function 4 in Third Party VM @param cmd [PAR8] (in) Sub command to be executed @param length_in [PAR8] (in) Amount of data passed to this opcode @param length_out [PAR16] (out) Amount of data returned @param value [PARV] (out) Data from opcode

# File lib/lignite/ev3_ops.rb, line 9333
def dynload_entry_4(cmd, length_in, length_out, value)
  logger.debug do
    args = [cmd, length_in, length_out, value]
    "called dynload_entry_4 with #{args.inspect}"
  end

  bytes = u8(0xF6)
  bytes += param_simple(cmd)
  bytes += param_simple(length_in)
  bytes += param_simple(length_out)
  bytes += param_simple(value)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
dynload_entry_5(cmd, length_in, length_out, value) click to toggle source

Execute Entry Point function 5 in Third Party VM @param cmd [PAR8] (in) Sub command to be executed @param length_in [PAR8] (in) Amount of data passed to this opcode @param length_out [PAR16] (out) Amount of data returned @param value [PARV] (out) Data from opcode

# File lib/lignite/ev3_ops.rb, line 9353
def dynload_entry_5(cmd, length_in, length_out, value)
  logger.debug do
    args = [cmd, length_in, length_out, value]
    "called dynload_entry_5 with #{args.inspect}"
  end

  bytes = u8(0xF7)
  bytes += param_simple(cmd)
  bytes += param_simple(length_in)
  bytes += param_simple(length_out)
  bytes += param_simple(value)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
dynload_entry_6(cmd, length_in, length_out, value) click to toggle source

Execute Entry Point function 6 in Third Party VM @param cmd [PAR8] (in) Sub command to be executed @param length_in [PAR8] (in) Amount of data passed to this opcode @param length_out [PAR16] (out) Amount of data returned @param value [PARV] (out) Data from opcode

# File lib/lignite/ev3_ops.rb, line 9373
def dynload_entry_6(cmd, length_in, length_out, value)
  logger.debug do
    args = [cmd, length_in, length_out, value]
    "called dynload_entry_6 with #{args.inspect}"
  end

  bytes = u8(0xF8)
  bytes += param_simple(cmd)
  bytes += param_simple(length_in)
  bytes += param_simple(length_out)
  bytes += param_simple(value)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
dynload_entry_7(cmd, length_in, length_out, value) click to toggle source

Execute Entry Point function 7 in Third Party VM @param cmd [PAR8] (in) Sub command to be executed @param length_in [PAR8] (in) Amount of data passed to this opcode @param length_out [PAR16] (out) Amount of data returned @param value [PARV] (out) Data from opcode

# File lib/lignite/ev3_ops.rb, line 9393
def dynload_entry_7(cmd, length_in, length_out, value)
  logger.debug do
    args = [cmd, length_in, length_out, value]
    "called dynload_entry_7 with #{args.inspect}"
  end

  bytes = u8(0xF9)
  bytes += param_simple(cmd)
  bytes += param_simple(length_in)
  bytes += param_simple(length_out)
  bytes += param_simple(value)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
dynload_entry_8(cmd, length_in, length_out, value) click to toggle source

Execute Entry Point function 8 in Third Party VM @param cmd [PAR8] (in) Sub command to be executed @param length_in [PAR8] (in) Amount of data passed to this opcode @param length_out [PAR16] (out) Amount of data returned @param value [PARV] (out) Data from opcode

# File lib/lignite/ev3_ops.rb, line 9413
def dynload_entry_8(cmd, length_in, length_out, value)
  logger.debug do
    args = [cmd, length_in, length_out, value]
    "called dynload_entry_8 with #{args.inspect}"
  end

  bytes = u8(0xFA)
  bytes += param_simple(cmd)
  bytes += param_simple(length_in)
  bytes += param_simple(length_out)
  bytes += param_simple(value)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
dynload_entry_9(cmd, length_in, length_out, value) click to toggle source

Execute Entry Point function 9 in Third Party VM @param cmd [PAR8] (in) Sub command to be executed @param length_in [PAR8] (in) Amount of data passed to this opcode @param length_out [PAR16] (out) Amount of data returned @param value [PARV] (out) Data from opcode

# File lib/lignite/ev3_ops.rb, line 9433
def dynload_entry_9(cmd, length_in, length_out, value)
  logger.debug do
    args = [cmd, length_in, length_out, value]
    "called dynload_entry_9 with #{args.inspect}"
  end

  bytes = u8(0xFB)
  bytes += param_simple(cmd)
  bytes += param_simple(length_in)
  bytes += param_simple(length_out)
  bytes += param_simple(value)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
dynload_get_vm(result) click to toggle source

Get the index of the currently loaded VM @param result [PAR8] (out) VM Index, Robotc = 0, Labview = 1, -1 for no loaded VM

# File lib/lignite/ev3_ops.rb, line 9450
def dynload_get_vm(result)
  logger.debug do
    args = [result]
    "called dynload_get_vm with #{args.inspect}"
  end

  bytes = u8(0xFC)
  bytes += param_simple(result)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
dynload_vmexit() click to toggle source

Clean up the dynamic VM loading system

# File lib/lignite/ev3_ops.rb, line 9237
def dynload_vmexit
  logger.debug do
    args = []
    "called dynload_vmexit with #{args.inspect}"
  end

  bytes = u8(0xF1)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
dynload_vmload(vmindex, result) click to toggle source

Load the selected VM @param vmindex [PAR8] (in) VM Index, Robotc = 0, Labview = 1 @param result [PAR8] (out) OK if VM loaded ok FAIL if it did not.

# File lib/lignite/ev3_ops.rb, line 9223
def dynload_vmload(vmindex, result)
  logger.debug do
    args = [vmindex, result]
    "called dynload_vmload with #{args.inspect}"
  end

  bytes = u8(0xF0)
  bytes += param_simple(vmindex)
  bytes += param_simple(result)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
error() click to toggle source

This code does not exist in normal program

# File lib/lignite/ev3_ops.rb, line 7
def error
  logger.debug do
    args = []
    "called error with #{args.inspect}"
  end

  bytes = u8(0x00)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
file(*args) click to toggle source
# File lib/lignite/ev3_ops.rb, line 7401
def file(*args)
  logger.debug "called file with #{args.inspect}"
  cvalue = args.shift
  csym = MULTIPLEX_FILE.fetch(cvalue)
  __send__("file_#{csym}", *args)
end
file_close(handle) click to toggle source

Close file @param handle [PAR16] (in) Handle to file

# File lib/lignite/ev3_ops.rb, line 6885
def file_close(handle)
  logger.debug do
    args = [handle]
    "called file_close with #{args.inspect}"
  end

  bytes = u8(0xC0)
  bytes += param_simple(7)
  bytes += param_simple(handle)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
file_close_log(handle, name) click to toggle source

Close data log file @param handle [PAR16] (in) Handle to file @param name [PAR8] (in) First character in file name (character string)

# File lib/lignite/ev3_ops.rb, line 7090
def file_close_log(handle, name)
  logger.debug do
    args = [handle, name]
    "called file_close_log with #{args.inspect}"
  end

  bytes = u8(0xC0)
  bytes += param_simple(17)
  bytes += param_simple(handle)
  bytes += param_simple(name)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
file_del_cache_file(string) click to toggle source

@param string [PAR8] (out) First character in character string

# File lib/lignite/ev3_ops.rb, line 7207
def file_del_cache_file(string)
  logger.debug do
    args = [string]
    "called file_del_cache_file with #{args.inspect}"
  end

  bytes = u8(0xC0)
  bytes += param_simple(23)
  bytes += param_simple(string)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
file_del_subfolder(name, item) click to toggle source

@param name [PAR8] (in) First character in folder name (ex “../prjs/”) @param item [PAR8] (in) Sub folder index [1..ITEMS]

# File lib/lignite/ev3_ops.rb, line 7225
def file_del_subfolder(name, item)
  logger.debug do
    args = [name, item]
    "called file_del_subfolder with #{args.inspect}"
  end

  bytes = u8(0xC0)
  bytes += param_simple(24)
  bytes += param_simple(name)
  bytes += param_simple(item)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
file_get_cache_file(item, length, string) click to toggle source

@param item [PAR8] (in) Cache index [1..ITEMS] @param length [PAR8] (in) Maximal string length @param string [PAR8] (out) First character in character string

# File lib/lignite/ev3_ops.rb, line 7188
def file_get_cache_file(item, length, string)
  logger.debug do
    args = [item, length, string]
    "called file_get_cache_file with #{args.inspect}"
  end

  bytes = u8(0xC0)
  bytes += param_simple(22)
  bytes += param_simple(item)
  bytes += param_simple(length)
  bytes += param_simple(string)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
file_get_cache_files(items) click to toggle source

@param items [PAR8] (out) Number of files in cache

# File lib/lignite/ev3_ops.rb, line 7152
def file_get_cache_files(items)
  logger.debug do
    args = [items]
    "called file_get_cache_files with #{args.inspect}"
  end

  bytes = u8(0xC0)
  bytes += param_simple(20)
  bytes += param_simple(items)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
file_get_folders(name, items) click to toggle source

@param name [PAR8] (in) First character in folder name (ex “../prjs/”) @param items [PAR8] (out) No of sub folders

# File lib/lignite/ev3_ops.rb, line 7006
def file_get_folders(name, items)
  logger.debug do
    args = [name, items]
    "called file_get_folders with #{args.inspect}"
  end

  bytes = u8(0xC0)
  bytes += param_simple(13)
  bytes += param_simple(name)
  bytes += param_simple(items)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
file_get_handle(name, handle, write) click to toggle source

Get handle from filename @param name [PAR8] (in) First character in file name (character string) @param handle [PAR16] (out) Handle to file @param write [PAR8] (out) Open for write / append (0 = no, 1 = yes)

# File lib/lignite/ev3_ops.rb, line 6927
def file_get_handle(name, handle, write)
  logger.debug do
    args = [name, handle, write]
    "called file_get_handle with #{args.inspect}"
  end

  bytes = u8(0xC0)
  bytes += param_simple(9)
  bytes += param_simple(name)
  bytes += param_simple(handle)
  bytes += param_simple(write)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
file_get_image(name, prgid, item, ip) click to toggle source

@param name [PAR8] (in) First character in name (character string) @param prgid [PAR16] (in) Program id @param item [PAR8] (in) Sub folder index [1..ITEMS] @param ip [PAR32] (out) Address of image

# File lib/lignite/ev3_ops.rb, line 7111
def file_get_image(name, prgid, item, ip)
  logger.debug do
    args = [name, prgid, item, ip]
    "called file_get_image with #{args.inspect}"
  end

  bytes = u8(0xC0)
  bytes += param_simple(18)
  bytes += param_simple(name)
  bytes += param_simple(prgid)
  bytes += param_simple(item)
  bytes += param_simple(ip)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
file_get_item(name, string, item) click to toggle source

@param name [PAR8] (in) First character in name (character string) @param string [PAR8] (in) First character in item name string @param item [PAR8] (out) Sub folder index [1..ITEMS]

# File lib/lignite/ev3_ops.rb, line 7133
def file_get_item(name, string, item)
  logger.debug do
    args = [name, string, item]
    "called file_get_item with #{args.inspect}"
  end

  bytes = u8(0xC0)
  bytes += param_simple(19)
  bytes += param_simple(name)
  bytes += param_simple(string)
  bytes += param_simple(item)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
file_get_log_name(length, name) click to toggle source

Get the current open log filename @param length [PAR8] (in) Max string length (don't care if NAME is a HND) @param name [PAR8] (in) First First character in file name (character string or HND)

# File lib/lignite/ev3_ops.rb, line 7244
def file_get_log_name(length, name)
  logger.debug do
    args = [length, name]
    "called file_get_log_name with #{args.inspect}"
  end

  bytes = u8(0xC0)
  bytes += param_simple(25)
  bytes += param_simple(length)
  bytes += param_simple(name)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
file_get_log_sync_time(time, tick) click to toggle source

@param time [PAR32] (out) Sync time used in data log files @param tick [PAR32] (out) Sync tick used in data log files

# File lib/lignite/ev3_ops.rb, line 7025
def file_get_log_sync_time(time, tick)
  logger.debug do
    args = [time, tick]
    "called file_get_log_sync_time with #{args.inspect}"
  end

  bytes = u8(0xC0)
  bytes += param_simple(14)
  bytes += param_simple(time)
  bytes += param_simple(tick)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
file_get_pool(size, handle, ip) click to toggle source

@param size [PAR32] (in) Size of pool @param handle [PAR16] (out) Handle to file @param ip [PAR32] (out) Address of image

# File lib/lignite/ev3_ops.rb, line 6967
def file_get_pool(size, handle, ip)
  logger.debug do
    args = [size, handle, ip]
    "called file_get_pool with #{args.inspect}"
  end

  bytes = u8(0xC0)
  bytes += param_simple(11)
  bytes += param_simple(size)
  bytes += param_simple(handle)
  bytes += param_simple(ip)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
file_get_subfolder_name(name, item, length, string) click to toggle source

@param name [PAR8] (in) First character in folder name (ex “../prjs/”) @param item [PAR8] (in) Sub folder index [1..ITEMS] @param length [PAR8] (in) Maximal string length @param string [PAR8] (out) First character in character string

# File lib/lignite/ev3_ops.rb, line 7046
def file_get_subfolder_name(name, item, length, string)
  logger.debug do
    args = [name, item, length, string]
    "called file_get_subfolder_name with #{args.inspect}"
  end

  bytes = u8(0xC0)
  bytes += param_simple(15)
  bytes += param_simple(name)
  bytes += param_simple(item)
  bytes += param_simple(length)
  bytes += param_simple(string)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
file_load_image(prgid, name, size, ip) click to toggle source

@param prgid [PAR16] (in) Program id @param name [PAR8] (in) First character in name (character string) @param size [PAR32] (out) Size @param ip [PAR32] (out) Address of image

# File lib/lignite/ev3_ops.rb, line 6905
def file_load_image(prgid, name, size, ip)
  logger.debug do
    args = [prgid, name, size, ip]
    "called file_load_image with #{args.inspect}"
  end

  bytes = u8(0xC0)
  bytes += param_simple(8)
  bytes += param_simple(prgid)
  bytes += param_simple(name)
  bytes += param_simple(size)
  bytes += param_simple(ip)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
file_make_folder(name, success) click to toggle source

Make folder if not present @param name [PAR8] (in) First character in folder name (character string) @param success [PAR8] (out) Success (0 = no, 1 = yes)

# File lib/lignite/ev3_ops.rb, line 6947
def file_make_folder(name, success)
  logger.debug do
    args = [name, success]
    "called file_make_folder with #{args.inspect}"
  end

  bytes = u8(0xC0)
  bytes += param_simple(10)
  bytes += param_simple(name)
  bytes += param_simple(success)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
file_md5sum(name, md5sum, success) click to toggle source

Get md5 sum of a file @param name [PAR8] (in) First character in file name (character string) @param md5sum [PAR8] (out) First byte in md5 sum (byte array) @param success [PAR8] (out) Success flag (0 = no, 1 = yes)

# File lib/lignite/ev3_ops.rb, line 9206
def file_md5sum(name, md5sum, success)
  logger.debug do
    args = [name, md5sum, success]
    "called file_md5sum with #{args.inspect}"
  end

  bytes = u8(0xE6)
  bytes += param_simple(name)
  bytes += param_simple(md5sum)
  bytes += param_simple(success)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
file_move(source, dest) click to toggle source

Move file SOURCE to DEST @param source [PAR8] (in) First character in source file name (character string) @param dest [PAR8] (in) First character in destination file name (character string)

# File lib/lignite/ev3_ops.rb, line 7353
def file_move(source, dest)
  logger.debug do
    args = [source, dest]
    "called file_move with #{args.inspect}"
  end

  bytes = u8(0xC0)
  bytes += param_simple(31)
  bytes += param_simple(source)
  bytes += param_simple(dest)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
file_open_append(name, handle) click to toggle source

Create file or open for append @param name [PAR8] (in) First character in file name (character string) @param handle [PAR16] (out) Handle to file

# File lib/lignite/ev3_ops.rb, line 6737
def file_open_append(name, handle)
  logger.debug do
    args = [name, handle]
    "called file_open_append with #{args.inspect}"
  end

  bytes = u8(0xC0)
  bytes += param_simple(0)
  bytes += param_simple(name)
  bytes += param_simple(handle)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
file_open_log(name, syncedtime, syncedtick, nowtick, sample_interval_in_ms, duration_in_ms, sdata, handle) click to toggle source

Create file for data logging @param name [PAR8] (in) First character in file name (character string) @param syncedtime [PAR32] (in) @param syncedtick [PAR32] (in) @param nowtick [PAR32] (in) @param sample_interval_in_ms [PAR32] (in) @param duration_in_ms [PAR32] (in) @param sdata [PAR8] (in) First character in sensor type data (character string) @param handle [PAR16] (out) Handle to file

# File lib/lignite/ev3_ops.rb, line 7269
def file_open_log(name, syncedtime, syncedtick, nowtick, sample_interval_in_ms, duration_in_ms, sdata, handle)
  logger.debug do
    args = [name, syncedtime, syncedtick, nowtick, sample_interval_in_ms, duration_in_ms, sdata, handle]
    "called file_open_log with #{args.inspect}"
  end

  bytes = u8(0xC0)
  bytes += param_simple(27)
  bytes += param_simple(name)
  bytes += param_simple(syncedtime)
  bytes += param_simple(syncedtick)
  bytes += param_simple(nowtick)
  bytes += param_simple(sample_interval_in_ms)
  bytes += param_simple(duration_in_ms)
  bytes += param_simple(sdata)
  bytes += param_simple(handle)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
file_open_read(name, handle, size) click to toggle source

Open file for read @param name [PAR8] (in) First character in file name (character string) @param handle [PAR16] (out) Handle to file @param size [PAR32] (out) File size (0 = not found)

# File lib/lignite/ev3_ops.rb, line 6757
def file_open_read(name, handle, size)
  logger.debug do
    args = [name, handle, size]
    "called file_open_read with #{args.inspect}"
  end

  bytes = u8(0xC0)
  bytes += param_simple(1)
  bytes += param_simple(name)
  bytes += param_simple(handle)
  bytes += param_simple(size)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
file_open_write(name, handle) click to toggle source

Create file for write @param name [PAR8] (in) First character in file name (character string) @param handle [PAR16] (out) Handle to file

# File lib/lignite/ev3_ops.rb, line 6777
def file_open_write(name, handle)
  logger.debug do
    args = [name, handle]
    "called file_open_write with #{args.inspect}"
  end

  bytes = u8(0xC0)
  bytes += param_simple(2)
  bytes += param_simple(name)
  bytes += param_simple(handle)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
file_put_cache_file(string) click to toggle source

@param string [PAR8] (in) First character in character string

# File lib/lignite/ev3_ops.rb, line 7169
def file_put_cache_file(string)
  logger.debug do
    args = [string]
    "called file_put_cache_file with #{args.inspect}"
  end

  bytes = u8(0xC0)
  bytes += param_simple(21)
  bytes += param_simple(string)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
file_read_bytes(handle, bytes, destination) click to toggle source

Read a number of bytes from file @param handle [PAR16] (in) Handle to file @param bytes [PAR16] (in) Number of bytes to read @param destination [PAR8] (out) First byte in byte stream

# File lib/lignite/ev3_ops.rb, line 7295
def file_read_bytes(handle, bytes, destination)
  logger.debug do
    args = [handle, bytes, destination]
    "called file_read_bytes with #{args.inspect}"
  end

  bytes = u8(0xC0)
  bytes += param_simple(28)
  bytes += param_simple(handle)
  bytes += param_simple(bytes)
  bytes += param_simple(destination)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
file_read_text(handle, del, length, text) click to toggle source

Read text from file @param handle [PAR16] (in) Handle to file @param del [PAR8] (in) Delimiter code @param length [PAR16] (in) Maximal string length @param text [PAR8] (out) First character in text to read (character string)

# File lib/lignite/ev3_ops.rb, line 6844
def file_read_text(handle, del, length, text)
  logger.debug do
    args = [handle, del, length, text]
    "called file_read_text with #{args.inspect}"
  end

  bytes = u8(0xC0)
  bytes += param_simple(5)
  bytes += param_simple(handle)
  bytes += param_simple(del)
  bytes += param_simple(length)
  bytes += param_simple(text)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
file_read_value(handle, del, value) click to toggle source

Read floating point value from file @param handle [PAR16] (in) Handle to file @param del [PAR8] (in) Delimiter code @param value [PARF] (out) Value read

# File lib/lignite/ev3_ops.rb, line 6797
def file_read_value(handle, del, value)
  logger.debug do
    args = [handle, del, value]
    "called file_read_value with #{args.inspect}"
  end

  bytes = u8(0xC0)
  bytes += param_simple(3)
  bytes += param_simple(handle)
  bytes += param_simple(del)
  bytes += param_simple(value)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
file_remove(name) click to toggle source

Delete file @param name [PAR8] (in) First character in file name (character string)

# File lib/lignite/ev3_ops.rb, line 7335
def file_remove(name)
  logger.debug do
    args = [name]
    "called file_remove with #{args.inspect}"
  end

  bytes = u8(0xC0)
  bytes += param_simple(30)
  bytes += param_simple(name)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
file_set_log_sync_time(time, tick) click to toggle source

@param time [PAR32] (in) Sync time used in data log files @param tick [PAR32] (in) Sync tick used in data log files

# File lib/lignite/ev3_ops.rb, line 6987
def file_set_log_sync_time(time, tick)
  logger.debug do
    args = [time, tick]
    "called file_set_log_sync_time with #{args.inspect}"
  end

  bytes = u8(0xC0)
  bytes += param_simple(12)
  bytes += param_simple(time)
  bytes += param_simple(tick)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
file_write_bytes(handle, bytes, source) click to toggle source

Write a number of bytes to file @param handle [PAR16] (in) Handle to file @param bytes [PAR16] (in) Number of bytes to write @param source [PAR8] (in) First byte in byte stream to write

# File lib/lignite/ev3_ops.rb, line 7316
def file_write_bytes(handle, bytes, source)
  logger.debug do
    args = [handle, bytes, source]
    "called file_write_bytes with #{args.inspect}"
  end

  bytes = u8(0xC0)
  bytes += param_simple(29)
  bytes += param_simple(handle)
  bytes += param_simple(bytes)
  bytes += param_simple(source)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
file_write_log(handle, time, items, values) click to toggle source

Write time slot samples to file @param handle [PAR16] (in) Handle to file @param time [PAR32] (in) Relative time in mS @param items [PAR8] (in) Total number of values in this time slot @param values [PARF] (in) DATAF array (handle) containing values

# File lib/lignite/ev3_ops.rb, line 7069
def file_write_log(handle, time, items, values)
  logger.debug do
    args = [handle, time, items, values]
    "called file_write_log with #{args.inspect}"
  end

  bytes = u8(0xC0)
  bytes += param_simple(16)
  bytes += param_simple(handle)
  bytes += param_simple(time)
  bytes += param_simple(items)
  bytes += param_simple(values)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
file_write_text(handle, del, text) click to toggle source

Write text to file @param handle [PAR16] (in) Handle to file @param del [PAR8] (in) Delimiter code @param text [PAR8] (in) First character in text to write (character string)

# File lib/lignite/ev3_ops.rb, line 6866
def file_write_text(handle, del, text)
  logger.debug do
    args = [handle, del, text]
    "called file_write_text with #{args.inspect}"
  end

  bytes = u8(0xC0)
  bytes += param_simple(6)
  bytes += param_simple(handle)
  bytes += param_simple(del)
  bytes += param_simple(text)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
file_write_value(handle, del, value, figures, decimals) click to toggle source

Write floating point value to file @param handle [PAR16] (in) Handle to file @param del [PAR8] (in) Delimiter code @param value [PARF] (in) Value to write @param figures [PAR8] (in) Total number of figures inclusive decimal point @param decimals [PAR8] (in) Number of decimals

# File lib/lignite/ev3_ops.rb, line 6820
def file_write_value(handle, del, value, figures, decimals)
  logger.debug do
    args = [handle, del, value, figures, decimals]
    "called file_write_value with #{args.inspect}"
  end

  bytes = u8(0xC0)
  bytes += param_simple(4)
  bytes += param_simple(handle)
  bytes += param_simple(del)
  bytes += param_simple(value)
  bytes += param_simple(figures)
  bytes += param_simple(decimals)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
filename(*args) click to toggle source
# File lib/lignite/ev3_ops.rb, line 8045
def filename(*args)
  logger.debug "called filename with #{args.inspect}"
  cvalue = args.shift
  csym = MULTIPLEX_FILENAME.fetch(cvalue)
  __send__("filename_#{csym}", *args)
end
filename_check(filename, ok) click to toggle source

Check filename @param filename [PAR8] (in) First character in file name (character string) @param ok [PAR8] (out) Filename ok (0 = FAIL, 1 = OK)

# File lib/lignite/ev3_ops.rb, line 7967
def filename_check(filename, ok)
  logger.debug do
    args = [filename, ok]
    "called filename_check with #{args.inspect}"
  end

  bytes = u8(0xC6)
  bytes += param_simple(20)
  bytes += param_simple(filename)
  bytes += param_simple(ok)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
filename_exist(name, flag) click to toggle source

Test if file exists @param name [PAR8] (in) First character in file name (character string) @param flag [PAR8] (out) Exist (0 = no, 1 = yes)

# File lib/lignite/ev3_ops.rb, line 7877
def filename_exist(name, flag)
  logger.debug do
    args = [name, flag]
    "called filename_exist with #{args.inspect}"
  end

  bytes = u8(0xC6)
  bytes += param_simple(16)
  bytes += param_simple(name)
  bytes += param_simple(flag)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
filename_get_foldername(length, foldername) click to toggle source

Get current folder name @param length [PAR8] (in) Maximal length for the below parameter @param foldername [PAR8] (out) First character in folder name (character string)

# File lib/lignite/ev3_ops.rb, line 8020
def filename_get_foldername(length, foldername)
  logger.debug do
    args = [length, foldername]
    "called filename_get_foldername with #{args.inspect}"
  end

  bytes = u8(0xC6)
  bytes += param_simple(23)
  bytes += param_simple(length)
  bytes += param_simple(foldername)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
filename_merge(folder, name, ext, length, filename) click to toggle source

Merge Folder, name, extension into filename @param folder [PAR8] (in) First character in folder name (character string) @param name [PAR8] (in) First character in name (character string) @param ext [PAR8] (in) First character in extension (character string) @param length [PAR8] (in) Maximal length for the below parameter @param filename [PAR8] (out) First character in file name (character string)

# File lib/lignite/ev3_ops.rb, line 7945
def filename_merge(folder, name, ext, length, filename)
  logger.debug do
    args = [folder, name, ext, length, filename]
    "called filename_merge with #{args.inspect}"
  end

  bytes = u8(0xC6)
  bytes += param_simple(19)
  bytes += param_simple(folder)
  bytes += param_simple(name)
  bytes += param_simple(ext)
  bytes += param_simple(length)
  bytes += param_simple(filename)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
filename_pack(filename) click to toggle source

Pack file or folder into “raf” container @param filename [PAR8] (in) First character in file name (character string)

# File lib/lignite/ev3_ops.rb, line 7985
def filename_pack(filename)
  logger.debug do
    args = [filename]
    "called filename_pack with #{args.inspect}"
  end

  bytes = u8(0xC6)
  bytes += param_simple(21)
  bytes += param_simple(filename)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
filename_split(filename, length, folder, name, ext) click to toggle source

Split filename into Folder, name, extension @param filename [PAR8] (in) First character in file name (character string) @param length [PAR8] (in) Maximal length for each of the below parameters @param folder [PAR8] (out) First character in folder name (character string) @param name [PAR8] (out) First character in name (character string) @param ext [PAR8] (out) First character in extension (character string)

# File lib/lignite/ev3_ops.rb, line 7920
def filename_split(filename, length, folder, name, ext)
  logger.debug do
    args = [filename, length, folder, name, ext]
    "called filename_split with #{args.inspect}"
  end

  bytes = u8(0xC6)
  bytes += param_simple(18)
  bytes += param_simple(filename)
  bytes += param_simple(length)
  bytes += param_simple(folder)
  bytes += param_simple(name)
  bytes += param_simple(ext)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
filename_totalsize(name, files, size) click to toggle source

Calculate folder/file size @param name [PAR8] (in) First character in file name (character string) @param files [PAR32] (out) Total number of files @param size [PAR32] (out) Total folder size [KB]

# File lib/lignite/ev3_ops.rb, line 7897
def filename_totalsize(name, files, size)
  logger.debug do
    args = [name, files, size]
    "called filename_totalsize with #{args.inspect}"
  end

  bytes = u8(0xC6)
  bytes += param_simple(17)
  bytes += param_simple(name)
  bytes += param_simple(files)
  bytes += param_simple(size)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
filename_unpack(filename) click to toggle source

Unpack “raf” container @param filename [PAR8] (in) First character in file name (character string)

# File lib/lignite/ev3_ops.rb, line 8002
def filename_unpack(filename)
  logger.debug do
    args = [filename]
    "called filename_unpack with #{args.inspect}"
  end

  bytes = u8(0xC6)
  bytes += param_simple(22)
  bytes += param_simple(filename)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
info(*args) click to toggle source
# File lib/lignite/ev3_ops.rb, line 2349
def info(*args)
  logger.debug "called info with #{args.inspect}"
  cvalue = args.shift
  csym = MULTIPLEX_INFO.fetch(cvalue)
  __send__("info_#{csym}", *args)
end
info_errortext(number, length, destination) click to toggle source

Convert error number to text string @param number [PAR8] (in) Error number @param length [PAR8] (in) Maximal length of string returned (-1 = no check) @param destination [PAR8] (out) String variable or handle to string

# File lib/lignite/ev3_ops.rb, line 2256
def info_errortext(number, length, destination)
  logger.debug do
    args = [number, length, destination]
    "called info_errortext with #{args.inspect}"
  end

  bytes = u8(0x7C)
  bytes += param_simple(3)
  bytes += param_simple(number)
  bytes += param_simple(length)
  bytes += param_simple(destination)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
info_get_error(number) click to toggle source

@param number [PAR8] (out) Error number

# File lib/lignite/ev3_ops.rb, line 2237
def info_get_error(number)
  logger.debug do
    args = [number]
    "called info_get_error with #{args.inspect}"
  end

  bytes = u8(0x7C)
  bytes += param_simple(2)
  bytes += param_simple(number)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
info_get_minutes(value) click to toggle source

@param value [PAR8] (out) Minutes to sleep [0..120min] (0 = never)

# File lib/lignite/ev3_ops.rb, line 2309
def info_get_minutes(value)
  logger.debug do
    args = [value]
    "called info_get_minutes with #{args.inspect}"
  end

  bytes = u8(0x7C)
  bytes += param_simple(6)
  bytes += param_simple(value)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
info_get_volume(value) click to toggle source

@param value [PAR8] (out) Volume [0..100%]

# File lib/lignite/ev3_ops.rb, line 2275
def info_get_volume(value)
  logger.debug do
    args = [value]
    "called info_get_volume with #{args.inspect}"
  end

  bytes = u8(0x7C)
  bytes += param_simple(4)
  bytes += param_simple(value)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
info_set_error(number) click to toggle source

@param number [PAR8] (in) Error number

# File lib/lignite/ev3_ops.rb, line 2220
def info_set_error(number)
  logger.debug do
    args = [number]
    "called info_set_error with #{args.inspect}"
  end

  bytes = u8(0x7C)
  bytes += param_simple(1)
  bytes += param_simple(number)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
info_set_minutes(value) click to toggle source

@param value [PAR8] (in) Minutes to sleep [0..120min] (0 = never)

# File lib/lignite/ev3_ops.rb, line 2326
def info_set_minutes(value)
  logger.debug do
    args = [value]
    "called info_set_minutes with #{args.inspect}"
  end

  bytes = u8(0x7C)
  bytes += param_simple(7)
  bytes += param_simple(value)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
info_set_volume(value) click to toggle source

@param value [PAR8] (in) Volume [0..100%]

# File lib/lignite/ev3_ops.rb, line 2292
def info_set_volume(value)
  logger.debug do
    args = [value]
    "called info_set_volume with #{args.inspect}"
  end

  bytes = u8(0x7C)
  bytes += param_simple(5)
  bytes += param_simple(value)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
init_bytes(destination, length, *source) click to toggle source

Move LENGTH number of DATA8 from BYTE STREAM to memory DESTINATION START @param destination [PAR8] (out) First element in DATA8 array to be initiated @param length [PAR32] (in) Number of elements to initiate @param source [PARVALUES] (in) First element to initiate DATA8 array with

# File lib/lignite/ev3_ops.rb, line 869
def init_bytes(destination, length, *source)
  logger.debug do
    args = [destination, length, *source]
    "called init_bytes with #{args.inspect}"
  end

  bytes = u8(0x2F)
  bytes += param_simple(destination)
  bytes += param_simple(length)
  bytes += param_multiple(*source)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
input_device(*args) click to toggle source
# File lib/lignite/ev3_ops.rb, line 6192
def input_device(*args)
  logger.debug "called input_device with #{args.inspect}"
  cvalue = args.shift
  csym = MULTIPLEX_INPUT_DEVICE.fetch(cvalue)
  __send__("input_device_#{csym}", *args)
end
input_device_cal_default(type, mode) click to toggle source

Apply the default minimum and maximum raw value for device type to be used in scaling PCT and SI @param type [PAR8] (in) Device type id from typedata.rcf @param mode [PAR8] (in) Device mode [0..7]

# File lib/lignite/ev3_ops.rb, line 5646
def input_device_cal_default(type, mode)
  logger.debug do
    args = [type, mode]
    "called input_device_cal_default with #{args.inspect}"
  end

  bytes = u8(0x99)
  bytes += param_simple(4)
  bytes += param_simple(type)
  bytes += param_simple(mode)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
input_device_cal_max(type, mode, cal_max) click to toggle source

Apply new maximum raw value for device type to be used in scaling PCT and SI @param type [PAR8] (in) Device type id from typedata.rcf @param mode [PAR8] (in) Device mode [0..7] @param cal_max [PAR32] (in) 32 bit SI maximum value (Full scale)

# File lib/lignite/ev3_ops.rb, line 5733
def input_device_cal_max(type, mode, cal_max)
  logger.debug do
    args = [type, mode, cal_max]
    "called input_device_cal_max with #{args.inspect}"
  end

  bytes = u8(0x99)
  bytes += param_simple(8)
  bytes += param_simple(type)
  bytes += param_simple(mode)
  bytes += param_simple(cal_max)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
input_device_cal_min(type, mode, cal_min) click to toggle source

Apply new minimum raw value for device type to be used in scaling PCT and SI @param type [PAR8] (in) Device type id from typedata.rcf @param mode [PAR8] (in) Device mode [0..7] @param cal_min [PAR32] (in) 32 bit raw minimum value (Zero)

# File lib/lignite/ev3_ops.rb, line 5712
def input_device_cal_min(type, mode, cal_min)
  logger.debug do
    args = [type, mode, cal_min]
    "called input_device_cal_min with #{args.inspect}"
  end

  bytes = u8(0x99)
  bytes += param_simple(7)
  bytes += param_simple(type)
  bytes += param_simple(mode)
  bytes += param_simple(cal_min)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
input_device_cal_minmax(type, mode, cal_min, cal_max) click to toggle source

Apply new minimum and maximum raw value for device type to be used in scaling PCT and SI @param type [PAR8] (in) Device type id from typedata.rcf @param mode [PAR8] (in) Device mode [0..7] @param cal_min [PAR32] (in) 32 bit raw minimum value (Zero) @param cal_max [PAR32] (in) 32 bit raw maximum value (Full scale)

# File lib/lignite/ev3_ops.rb, line 5625
def input_device_cal_minmax(type, mode, cal_min, cal_max)
  logger.debug do
    args = [type, mode, cal_min, cal_max]
    "called input_device_cal_minmax with #{args.inspect}"
  end

  bytes = u8(0x99)
  bytes += param_simple(3)
  bytes += param_simple(type)
  bytes += param_simple(mode)
  bytes += param_simple(cal_min)
  bytes += param_simple(cal_max)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
input_device_clr_all(layer) click to toggle source

Clear all devices (e.c. counters, angle, …) @param layer [PAR8] (in) Daisy chain layer number [0..3]

# File lib/lignite/ev3_ops.rb, line 5783
def input_device_clr_all(layer)
  logger.debug do
    args = [layer]
    "called input_device_clr_all with #{args.inspect}"
  end

  bytes = u8(0x99)
  bytes += param_simple(10)
  bytes += param_simple(layer)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
input_device_clr_changes(layer, no) click to toggle source

Clear changes and bumps @param layer [PAR8] (in) Daisy chain layer number [0..3] @param no [PAR8] (in) Port number

# File lib/lignite/ev3_ops.rb, line 6030
def input_device_clr_changes(layer, no)
  logger.debug do
    args = [layer, no]
    "called input_device_clr_changes with #{args.inspect}"
  end

  bytes = u8(0x99)
  bytes += param_simple(26)
  bytes += param_simple(layer)
  bytes += param_simple(no)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
input_device_get_bumps(layer, no, value) click to toggle source

@param layer [PAR8] (in) Daisy chain layer number [0..3] @param no [PAR8] (in) Port number @param value [PARF] (out) Negative changes since last clear

# File lib/lignite/ev3_ops.rb, line 6148
def input_device_get_bumps(layer, no, value)
  logger.debug do
    args = [layer, no, value]
    "called input_device_get_bumps with #{args.inspect}"
  end

  bytes = u8(0x99)
  bytes += param_simple(31)
  bytes += param_simple(layer)
  bytes += param_simple(no)
  bytes += param_simple(value)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
input_device_get_changes(layer, no, value) click to toggle source

@param layer [PAR8] (in) Daisy chain layer number [0..3] @param no [PAR8] (in) Port number @param value [PARF] (out) Positive changes since last clear

# File lib/lignite/ev3_ops.rb, line 6010
def input_device_get_changes(layer, no, value)
  logger.debug do
    args = [layer, no, value]
    "called input_device_get_changes with #{args.inspect}"
  end

  bytes = u8(0x99)
  bytes += param_simple(25)
  bytes += param_simple(layer)
  bytes += param_simple(no)
  bytes += param_simple(value)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
input_device_get_connection(layer, no, conn) click to toggle source

Get device connection type (for test) @param layer [PAR8] (in) Daisy chain layer number [0..3] @param no [PAR8] (in) Port number @param conn [PAR8] (out) Connection type

# File lib/lignite/ev3_ops.rb, line 5823
def input_device_get_connection(layer, no, conn)
  logger.debug do
    args = [layer, no, conn]
    "called input_device_get_connection with #{args.inspect}"
  end

  bytes = u8(0x99)
  bytes += param_simple(12)
  bytes += param_simple(layer)
  bytes += param_simple(no)
  bytes += param_simple(conn)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
input_device_get_figures(layer, no, figures, decimals) click to toggle source

@param layer [PAR8] (in) Daisy chain layer number [0..3] @param no [PAR8] (in) Port number @param figures [PAR8] (out) Total number of figures (inclusive decimal point and decimals) @param decimals [PAR8] (out) Number of decimals

# File lib/lignite/ev3_ops.rb, line 5988
def input_device_get_figures(layer, no, figures, decimals)
  logger.debug do
    args = [layer, no, figures, decimals]
    "called input_device_get_figures with #{args.inspect}"
  end

  bytes = u8(0x99)
  bytes += param_simple(24)
  bytes += param_simple(layer)
  bytes += param_simple(no)
  bytes += param_simple(figures)
  bytes += param_simple(decimals)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
input_device_get_format(layer, no, datasets, format, modes, views) click to toggle source

@param layer [PAR8] (in) Daisy chain layer number [0..3] @param no [PAR8] (in) Port number @param datasets [PAR8] (out) Number of data sets @param format [PAR8] (out) Format [0..3] @param modes [PAR8] (out) Number of modes [1..8] @param views [PAR8] (out) Number of views [1..8]

# File lib/lignite/ev3_ops.rb, line 5600
def input_device_get_format(layer, no, datasets, format, modes, views)
  logger.debug do
    args = [layer, no, datasets, format, modes, views]
    "called input_device_get_format with #{args.inspect}"
  end

  bytes = u8(0x99)
  bytes += param_simple(2)
  bytes += param_simple(layer)
  bytes += param_simple(no)
  bytes += param_simple(datasets)
  bytes += param_simple(format)
  bytes += param_simple(modes)
  bytes += param_simple(views)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
input_device_get_minmax(layer, no, min, max) click to toggle source

@param layer [PAR8] (in) Daisy chain layer number [0..3] @param no [PAR8] (in) Port number @param min [PARF] (out) Min SI value @param max [PARF] (out) Max SI value

# File lib/lignite/ev3_ops.rb, line 6126
def input_device_get_minmax(layer, no, min, max)
  logger.debug do
    args = [layer, no, min, max]
    "called input_device_get_minmax with #{args.inspect}"
  end

  bytes = u8(0x99)
  bytes += param_simple(30)
  bytes += param_simple(layer)
  bytes += param_simple(no)
  bytes += param_simple(min)
  bytes += param_simple(max)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
input_device_get_modename(layer, no, mode, length, destination) click to toggle source

@param layer [PAR8] (in) Daisy chain layer number [0..3] @param no [PAR8] (in) Port number @param mode [PAR8] (in) Mode @param length [PAR8] (in) Maximal length of string returned (-1 = no check) @param destination [PAR8] (out) String variable or handle to string

# File lib/lignite/ev3_ops.rb, line 5941
def input_device_get_modename(layer, no, mode, length, destination)
  logger.debug do
    args = [layer, no, mode, length, destination]
    "called input_device_get_modename with #{args.inspect}"
  end

  bytes = u8(0x99)
  bytes += param_simple(22)
  bytes += param_simple(layer)
  bytes += param_simple(no)
  bytes += param_simple(mode)
  bytes += param_simple(length)
  bytes += param_simple(destination)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
input_device_get_name(layer, no, length, destination) click to toggle source

@param layer [PAR8] (in) Daisy chain layer number [0..3] @param no [PAR8] (in) Port number @param length [PAR8] (in) Maximal length of string returned (-1 = no check) @param destination [PAR8] (out) String variable or handle to string

# File lib/lignite/ev3_ops.rb, line 5917
def input_device_get_name(layer, no, length, destination)
  logger.debug do
    args = [layer, no, length, destination]
    "called input_device_get_name with #{args.inspect}"
  end

  bytes = u8(0x99)
  bytes += param_simple(21)
  bytes += param_simple(layer)
  bytes += param_simple(no)
  bytes += param_simple(length)
  bytes += param_simple(destination)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
input_device_get_raw(layer, no, value) click to toggle source

@param layer [PAR8] (in) Daisy chain layer number [0..3] @param no [PAR8] (in) Port number @param value [PAR32] (out) 32 bit raw value

# File lib/lignite/ev3_ops.rb, line 5802
def input_device_get_raw(layer, no, value)
  logger.debug do
    args = [layer, no, value]
    "called input_device_get_raw with #{args.inspect}"
  end

  bytes = u8(0x99)
  bytes += param_simple(11)
  bytes += param_simple(layer)
  bytes += param_simple(no)
  bytes += param_simple(value)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
input_device_get_symbol(layer, no, length, destination) click to toggle source

@param layer [PAR8] (in) Daisy chain layer number [0..3] @param no [PAR8] (in) Port number @param length [PAR8] (in) Maximal length of string returned (-1 = no check) @param destination [PAR8] (out) String variable or handle to string

# File lib/lignite/ev3_ops.rb, line 5690
def input_device_get_symbol(layer, no, length, destination)
  logger.debug do
    args = [layer, no, length, destination]
    "called input_device_get_symbol with #{args.inspect}"
  end

  bytes = u8(0x99)
  bytes += param_simple(6)
  bytes += param_simple(layer)
  bytes += param_simple(no)
  bytes += param_simple(length)
  bytes += param_simple(destination)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
input_device_get_typemode(layer, no, type, mode) click to toggle source

Get device type and mode @param layer [PAR8] (in) Daisy chain layer number [0..3] @param no [PAR8] (in) Port number @param type [PAR8] (out) Device type id from typedata.rcf @param mode [PAR8] (out) Device mode [0..7]

# File lib/lignite/ev3_ops.rb, line 5667
def input_device_get_typemode(layer, no, type, mode)
  logger.debug do
    args = [layer, no, type, mode]
    "called input_device_get_typemode with #{args.inspect}"
  end

  bytes = u8(0x99)
  bytes += param_simple(5)
  bytes += param_simple(layer)
  bytes += param_simple(no)
  bytes += param_simple(type)
  bytes += param_simple(mode)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
input_device_insert_type(typedata, force, error) click to toggle source

Insert type in table @param typedata [PAR8] (in) String variable or handle to string containing type data @param force [PAR8] (in) Force type insert even if present (0 = don't force, 1 = force) @param error [PAR8] (out) Error if not Third Party type (0 = no error, 1 = error or known)

# File lib/lignite/ev3_ops.rb, line 5576
def input_device_insert_type(typedata, force, error)
  logger.debug do
    args = [typedata, force, error]
    "called input_device_insert_type with #{args.inspect}"
  end

  bytes = u8(0x99)
  bytes += param_simple(1)
  bytes += param_simple(typedata)
  bytes += param_simple(force)
  bytes += param_simple(error)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
input_device_list(length, array, changed) click to toggle source

Read all available devices on input and output(chain) @param length [PAR8] (in) Maximum number of device types (normally 32) @param array [PAR8] (out) First element of DATA8 array of types (normally 32) @param changed [PAR8] (out) Changed status

# File lib/lignite/ev3_ops.rb, line 5555
def input_device_list(length, array, changed)
  logger.debug do
    args = [length, array, changed]
    "called input_device_list with #{args.inspect}"
  end

  bytes = u8(0x98)
  bytes += param_simple(length)
  bytes += param_simple(array)
  bytes += param_simple(changed)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
input_device_ready_iic(layer, no, wrlng, wrdata, rdlng, rddata, result) click to toggle source

Generic setup/read IIC sensors with result @param layer [PAR8] (in) Daisy chain layer number [0..3] @param no [PAR8] (in) Port number @param wrlng [PAR8] (in) No of bytes to write @param wrdata [PAR8] (in) DATA8 array (handle) of data to write @param rdlng [PAR8] (in) No of bytes to read (if negative -> byte order is reversed) @param rddata [PAR8] (out) DATA8 array (handle) to read into @param result [PAR8] (out) Write/read result (OK, FAIL)

# File lib/lignite/ev3_ops.rb, line 5891
def input_device_ready_iic(layer, no, wrlng, wrdata, rdlng, rddata, result)
  logger.debug do
    args = [layer, no, wrlng, wrdata, rdlng, rddata, result]
    "called input_device_ready_iic with #{args.inspect}"
  end

  bytes = u8(0x99)
  bytes += param_simple(15)
  bytes += param_simple(layer)
  bytes += param_simple(no)
  bytes += param_simple(wrlng)
  bytes += param_simple(wrdata)
  bytes += param_simple(rdlng)
  bytes += param_simple(rddata)
  bytes += param_simple(result)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
input_device_ready_pct(layer, no, type, mode, *values) click to toggle source

@param layer [PAR8] (in) Daisy chain layer number [0..3] @param no [PAR8] (in) Port number @param type [PAR8] (in) Device type id (0 = don't change type) @param mode [PAR8] (in) Device mode [0..7] (-1 = don't change mode) @param values [PARNO] (in) Number of return values

# File lib/lignite/ev3_ops.rb, line 6052
def input_device_ready_pct(layer, no, type, mode, *values)
  logger.debug do
    args = [layer, no, type, mode, *values]
    "called input_device_ready_pct with #{args.inspect}"
  end

  bytes = u8(0x99)
  bytes += param_simple(27)
  bytes += param_simple(layer)
  bytes += param_simple(no)
  bytes += param_simple(type)
  bytes += param_simple(mode)
  bytes += param_n_multiple(*values)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
input_device_ready_raw(layer, no, type, mode, *values) click to toggle source

@param layer [PAR8] (in) Daisy chain layer number [0..3] @param no [PAR8] (in) Port number @param type [PAR8] (in) Device type id (0 = don't change type) @param mode [PAR8] (in) Device mode [0..7] (-1 = don't change mode) @param values [PARNO] (in) Number of return values

# File lib/lignite/ev3_ops.rb, line 6077
def input_device_ready_raw(layer, no, type, mode, *values)
  logger.debug do
    args = [layer, no, type, mode, *values]
    "called input_device_ready_raw with #{args.inspect}"
  end

  bytes = u8(0x99)
  bytes += param_simple(28)
  bytes += param_simple(layer)
  bytes += param_simple(no)
  bytes += param_simple(type)
  bytes += param_simple(mode)
  bytes += param_n_multiple(*values)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
input_device_ready_si(layer, no, type, mode, *values) click to toggle source

@param layer [PAR8] (in) Daisy chain layer number [0..3] @param no [PAR8] (in) Port number @param type [PAR8] (in) Device type id (0 = don't change type) @param mode [PAR8] (in) Device mode [0..7] (-1 = don't change mode) @param values [PARNO] (in) Number of return values

# File lib/lignite/ev3_ops.rb, line 6102
def input_device_ready_si(layer, no, type, mode, *values)
  logger.debug do
    args = [layer, no, type, mode, *values]
    "called input_device_ready_si with #{args.inspect}"
  end

  bytes = u8(0x99)
  bytes += param_simple(29)
  bytes += param_simple(layer)
  bytes += param_simple(no)
  bytes += param_simple(type)
  bytes += param_simple(mode)
  bytes += param_n_multiple(*values)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
input_device_set_raw(layer, no, type, value) click to toggle source

@param layer [PAR8] (in) Daisy chain layer number [0..3] @param no [PAR8] (in) Port number @param type [PAR8] (in) Device type id (0 = don't change type) @param value [PAR32] (in)

# File lib/lignite/ev3_ops.rb, line 5965
def input_device_set_raw(layer, no, type, value)
  logger.debug do
    args = [layer, no, type, value]
    "called input_device_set_raw with #{args.inspect}"
  end

  bytes = u8(0x99)
  bytes += param_simple(23)
  bytes += param_simple(layer)
  bytes += param_simple(no)
  bytes += param_simple(type)
  bytes += param_simple(value)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
input_device_set_typemode(type, mode, newtype, newmode, error) click to toggle source

Set new type and mode on existing devices @param type [PAR8] (in) Existing type @param mode [PAR8] (in) Existing mode @param newtype [PAR8] (in) New type @param newmode [PAR8] (in) New mode @param error [PAR8] (out) Error if not Third Party type (0 = no error, 1 = error or not found)

# File lib/lignite/ev3_ops.rb, line 5864
def input_device_set_typemode(type, mode, newtype, newmode, error)
  logger.debug do
    args = [type, mode, newtype, newmode, error]
    "called input_device_set_typemode with #{args.inspect}"
  end

  bytes = u8(0x99)
  bytes += param_simple(14)
  bytes += param_simple(type)
  bytes += param_simple(mode)
  bytes += param_simple(newtype)
  bytes += param_simple(newmode)
  bytes += param_simple(error)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
input_device_setup(layer, no, repeat, time, write_len, write_data, read_len, read_data) click to toggle source

Generic setup/read IIC sensors @param layer [PAR8] (in) Daisy chain layer number [0..3] @param no [PAR8] (in) Port number @param repeat [PAR8] (in) Repeat setup/read “REPEAT” times (0 = infinite) @param time [PAR16] (in) Time between repeats [10..1000mS] (0 = 10) @param write_len [PAR8] (in) No of bytes to write @param write_data [PAR8] (in) DATA8 array (handle) of data to write @param read_len [PAR8] (in) No of bytes to read @param read_data [PAR8] (out) DATA8 array (handle) to read into

# File lib/lignite/ev3_ops.rb, line 5759
def input_device_setup(layer, no, repeat, time, write_len, write_data, read_len, read_data)
  logger.debug do
    args = [layer, no, repeat, time, write_len, write_data, read_len, read_data]
    "called input_device_setup with #{args.inspect}"
  end

  bytes = u8(0x99)
  bytes += param_simple(9)
  bytes += param_simple(layer)
  bytes += param_simple(no)
  bytes += param_simple(repeat)
  bytes += param_simple(time)
  bytes += param_simple(write_len)
  bytes += param_simple(write_data)
  bytes += param_simple(read_len)
  bytes += param_simple(read_data)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
input_device_stop_all(layer) click to toggle source

Stop all devices (e.c. motors, …) @param layer [PAR8] (in) Daisy chain layer number [0..3]

# File lib/lignite/ev3_ops.rb, line 5842
def input_device_stop_all(layer)
  logger.debug do
    args = [layer]
    "called input_device_stop_all with #{args.inspect}"
  end

  bytes = u8(0x99)
  bytes += param_simple(13)
  bytes += param_simple(layer)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
input_iic_read(layer, no, rdlng, rddata, result) click to toggle source

Read I2C data from specified port @param layer [PAR8] (in) Chain layer number [0..3] @param no [PAR8] (in) Port number @param rdlng [PAR8] (in) No of bytes to read @param rddata [PAR8] (out) DATA8 array (handle) to read into @param result [PAR8] (out) Write/read result (OK, FAIL, BUSY, STOP)

# File lib/lignite/ev3_ops.rb, line 9110
def input_iic_read(layer, no, rdlng, rddata, result)
  logger.debug do
    args = [layer, no, rdlng, rddata, result]
    "called input_iic_read with #{args.inspect}"
  end

  bytes = u8(0xE1)
  bytes += param_simple(layer)
  bytes += param_simple(no)
  bytes += param_simple(rdlng)
  bytes += param_simple(rddata)
  bytes += param_simple(result)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
input_iic_status(layer, no, result) click to toggle source

Read I2C status of specified port @param layer [PAR8] (in) Chain layer number [0..3] @param no [PAR8] (in) Port number @param result [PAR8] (out) Current I2C bus status (OK, FAIL, BUSY, STOP)

# File lib/lignite/ev3_ops.rb, line 9130
def input_iic_status(layer, no, result)
  logger.debug do
    args = [layer, no, result]
    "called input_iic_status with #{args.inspect}"
  end

  bytes = u8(0xE2)
  bytes += param_simple(layer)
  bytes += param_simple(no)
  bytes += param_simple(result)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
input_iic_write(layer, no, wrlng, wrdata, rdlng, result) click to toggle source

Write I2C data to specified port @param layer [PAR8] (in) Chain layer number [0..3] @param no [PAR8] (in) Port number @param wrlng [PAR8] (in) No of bytes to write @param wrdata [PAR8] (in) DATA8 array (handle) of data to write @param rdlng [PAR8] (in) No of bytes to read @param result [PAR8] (out) Write/read result (OK, FAIL, BUSY, STOP)

# File lib/lignite/ev3_ops.rb, line 9151
def input_iic_write(layer, no, wrlng, wrdata, rdlng, result)
  logger.debug do
    args = [layer, no, wrlng, wrdata, rdlng, result]
    "called input_iic_write with #{args.inspect}"
  end

  bytes = u8(0xE3)
  bytes += param_simple(layer)
  bytes += param_simple(no)
  bytes += param_simple(wrlng)
  bytes += param_simple(wrdata)
  bytes += param_simple(rdlng)
  bytes += param_simple(result)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
input_read(layer, no, type, mode, pct) click to toggle source

Read device value in Percent @param layer [PAR8] (in) Daisy chain layer number [0..3] @param no [PAR8] (in) Port number @param type [PAR8] (in) Device type id (0 = don't change type) @param mode [PAR8] (in) Device mode [0..7] (-1 = don't change mode) @param pct [PAR8] (out) Percent value from device

# File lib/lignite/ev3_ops.rb, line 6205
def input_read(layer, no, type, mode, pct)
  logger.debug do
    args = [layer, no, type, mode, pct]
    "called input_read with #{args.inspect}"
  end

  bytes = u8(0x9A)
  bytes += param_simple(layer)
  bytes += param_simple(no)
  bytes += param_simple(type)
  bytes += param_simple(mode)
  bytes += param_simple(pct)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
input_readext(layer, no, type, mode, format, *values) click to toggle source

Read device value @param layer [PAR8] (in) Daisy chain layer number [0..3] @param no [PAR8] (in) Port number @param type [PAR8] (in) Device type id (0 = don't change type) @param mode [PAR8] (in) Device mode [0..7] (-1 = don't change mode) @param format [PAR8] (in) Format (PCT, RAW, SI …) @param values [PARNO] (in) Number of return values

# File lib/lignite/ev3_ops.rb, line 6284
def input_readext(layer, no, type, mode, format, *values)
  logger.debug do
    args = [layer, no, type, mode, format, *values]
    "called input_readext with #{args.inspect}"
  end

  bytes = u8(0x9E)
  bytes += param_simple(layer)
  bytes += param_simple(no)
  bytes += param_simple(type)
  bytes += param_simple(mode)
  bytes += param_simple(format)
  bytes += param_n_multiple(*values)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
input_readsi(layer, no, type, mode, si) click to toggle source

Read device value in SI units @param layer [PAR8] (in) Daisy chain layer number [0..3] @param no [PAR8] (in) Port number @param type [PAR8] (in) Device type id (0 = don't change type) @param mode [PAR8] (in) Device mode [0..7] (-1 = don't change mode) @param si [PARF] (out) SI unit value from device

# File lib/lignite/ev3_ops.rb, line 6261
def input_readsi(layer, no, type, mode, si)
  logger.debug do
    args = [layer, no, type, mode, si]
    "called input_readsi with #{args.inspect}"
  end

  bytes = u8(0x9D)
  bytes += param_simple(layer)
  bytes += param_simple(no)
  bytes += param_simple(type)
  bytes += param_simple(mode)
  bytes += param_simple(si)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
input_ready(layer, no) click to toggle source

Wait for device ready (wait for valid data) @param layer [PAR8] (in) Daisy chain layer number [0..3] @param no [PAR8] (in) Port number

# File lib/lignite/ev3_ops.rb, line 6242
def input_ready(layer, no)
  logger.debug do
    args = [layer, no]
    "called input_ready with #{args.inspect}"
  end

  bytes = u8(0x9C)
  bytes += param_simple(layer)
  bytes += param_simple(no)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
input_sample(time, samples, init, devices, types, modes, datasets, values) click to toggle source

@param devices [PAR8] (in) DATA8 array (handle) with devices to sample @param types [PAR8] (in) DATA8 array (handle) with types @param modes [PAR8] (in) DATA8 array (handle) with modes @param datasets [PAR8] (in) DATA8 array (handle) with data sets @param values [PARF] (out) DATAF array (handle) with values

# File lib/lignite/ev3_ops.rb, line 5532
def input_sample(time, samples, init, devices, types, modes, datasets, values)
  logger.debug do
    args = [time, samples, init, devices, types, modes, datasets, values]
    "called input_sample with #{args.inspect}"
  end

  bytes = u8(0x97)
  bytes += param_simple(time)
  bytes += param_simple(samples)
  bytes += param_simple(init)
  bytes += param_simple(devices)
  bytes += param_simple(types)
  bytes += param_simple(modes)
  bytes += param_simple(datasets)
  bytes += param_simple(values)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
input_set_autoid(layer, no, enable) click to toggle source

Enabled or disable auto-id for a specific sensor port @param layer [PAR8] (in) Chain layer number [0..3] @param no [PAR8] (in) Port number @param enable [PAR8] (in) Boolean (0 disabled, 1 enable)

# File lib/lignite/ev3_ops.rb, line 9172
def input_set_autoid(layer, no, enable)
  logger.debug do
    args = [layer, no, enable]
    "called input_set_autoid with #{args.inspect}"
  end

  bytes = u8(0xE4)
  bytes += param_simple(layer)
  bytes += param_simple(no)
  bytes += param_simple(enable)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
input_set_conn(layer, no, conn) click to toggle source

Set the connection type for a specific port @param layer [PAR8] (in) Chain layer number [0..3] @param no [PAR8] (in) Port number @param conn [PAR8] (in) Connection type (CONN_NXT_IIC, CONN_NXT_DUMB or CONN_INPUT_DUMB)

# File lib/lignite/ev3_ops.rb, line 9090
def input_set_conn(layer, no, conn)
  logger.debug do
    args = [layer, no, conn]
    "called input_set_conn with #{args.inspect}"
  end

  bytes = u8(0xE0)
  bytes += param_simple(layer)
  bytes += param_simple(no)
  bytes += param_simple(conn)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
input_test(layer, no, busy) click to toggle source

Test if device busy (changing type or mode) @param layer [PAR8] (in) Daisy chain layer number [0..3] @param no [PAR8] (in) Port number @param busy [PAR8] (out) Device busy flag (0 = ready, 1 = busy)

# File lib/lignite/ev3_ops.rb, line 6225
def input_test(layer, no, busy)
  logger.debug do
    args = [layer, no, busy]
    "called input_test with #{args.inspect}"
  end

  bytes = u8(0x9B)
  bytes += param_simple(layer)
  bytes += param_simple(no)
  bytes += param_simple(busy)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
input_write(layer, no, bytes, data) click to toggle source

Write data to device (only UART devices) @param layer [PAR8] (in) Daisy chain layer number [0..3] @param no [PAR8] (in) Port number @param bytes [PAR8] (in) No of bytes to write [1..32] @param data [PAR8] (in) First byte in DATA8 array to write

# File lib/lignite/ev3_ops.rb, line 6306
def input_write(layer, no, bytes, data)
  logger.debug do
    args = [layer, no, bytes, data]
    "called input_write with #{args.inspect}"
  end

  bytes = u8(0x9F)
  bytes += param_simple(layer)
  bytes += param_simple(no)
  bytes += param_simple(bytes)
  bytes += param_simple(data)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
jr(offset) click to toggle source

Branch unconditionally relative @param offset [PAR32] (in)

# File lib/lignite/ev3_ops.rb, line 1141
def jr(offset)
  logger.debug do
    args = [offset]
    "called jr with #{args.inspect}"
  end

  bytes = u8(0x40)
  bytes += param_simple(offset)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
jr_eq16(left, right, offset) click to toggle source

Branch relative OFFSET if LEFT is equal to RIGHT @param left [PAR16] (in) @param right [PAR16] (in) @param offset [PAR32] (in)

# File lib/lignite/ev3_ops.rb, line 1949
def jr_eq16(left, right, offset)
  logger.debug do
    args = [left, right, offset]
    "called jr_eq16 with #{args.inspect}"
  end

  bytes = u8(0x6D)
  bytes += param_simple(left)
  bytes += param_simple(right)
  bytes += param_simple(offset)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
jr_eq32(left, right, offset) click to toggle source

Branch relative OFFSET if LEFT is equal to RIGHT @param left [PAR32] (in) @param right [PAR32] (in) @param offset [PAR32] (in)

# File lib/lignite/ev3_ops.rb, line 1967
def jr_eq32(left, right, offset)
  logger.debug do
    args = [left, right, offset]
    "called jr_eq32 with #{args.inspect}"
  end

  bytes = u8(0x6E)
  bytes += param_simple(left)
  bytes += param_simple(right)
  bytes += param_simple(offset)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
jr_eq8(left, right, offset) click to toggle source

Branch relative OFFSET if LEFT is equal to RIGHT @param left [PAR8] (in) @param right [PAR8] (in) @param offset [PAR32] (in)

# File lib/lignite/ev3_ops.rb, line 1931
def jr_eq8(left, right, offset)
  logger.debug do
    args = [left, right, offset]
    "called jr_eq8 with #{args.inspect}"
  end

  bytes = u8(0x6C)
  bytes += param_simple(left)
  bytes += param_simple(right)
  bytes += param_simple(offset)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
jr_eqf(left, right, offset) click to toggle source

Branch relative OFFSET if LEFT is equal to RIGHT @param left [PARF] (in) @param right [PARF] (in) @param offset [PAR32] (in)

# File lib/lignite/ev3_ops.rb, line 1985
def jr_eqf(left, right, offset)
  logger.debug do
    args = [left, right, offset]
    "called jr_eqf with #{args.inspect}"
  end

  bytes = u8(0x6F)
  bytes += param_simple(left)
  bytes += param_simple(right)
  bytes += param_simple(offset)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
jr_false(flag, offset) click to toggle source

Branch relative if FLAG is FALSE (zero) @param flag [PAR8] (in) @param offset [PAR32] (in)

# File lib/lignite/ev3_ops.rb, line 1156
def jr_false(flag, offset)
  logger.debug do
    args = [flag, offset]
    "called jr_false with #{args.inspect}"
  end

  bytes = u8(0x41)
  bytes += param_simple(flag)
  bytes += param_simple(offset)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
jr_gt16(left, right, offset) click to toggle source

Branch relative OFFSET if LEFT is greater than RIGHT @param left [PAR16] (in) @param right [PAR16] (in) @param offset [PAR32] (in)

# File lib/lignite/ev3_ops.rb, line 1877
def jr_gt16(left, right, offset)
  logger.debug do
    args = [left, right, offset]
    "called jr_gt16 with #{args.inspect}"
  end

  bytes = u8(0x69)
  bytes += param_simple(left)
  bytes += param_simple(right)
  bytes += param_simple(offset)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
jr_gt32(left, right, offset) click to toggle source

Branch relative OFFSET if LEFT is greater than RIGHT @param left [PAR32] (in) @param right [PAR32] (in) @param offset [PAR32] (in)

# File lib/lignite/ev3_ops.rb, line 1895
def jr_gt32(left, right, offset)
  logger.debug do
    args = [left, right, offset]
    "called jr_gt32 with #{args.inspect}"
  end

  bytes = u8(0x6A)
  bytes += param_simple(left)
  bytes += param_simple(right)
  bytes += param_simple(offset)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
jr_gt8(left, right, offset) click to toggle source

Branch relative OFFSET if LEFT is greater than RIGHT @param left [PAR8] (in) @param right [PAR8] (in) @param offset [PAR32] (in)

# File lib/lignite/ev3_ops.rb, line 1859
def jr_gt8(left, right, offset)
  logger.debug do
    args = [left, right, offset]
    "called jr_gt8 with #{args.inspect}"
  end

  bytes = u8(0x68)
  bytes += param_simple(left)
  bytes += param_simple(right)
  bytes += param_simple(offset)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
jr_gteq16(left, right, offset) click to toggle source

Branch relative OFFSET if LEFT is greater than or equal to RIGHT @param left [PAR16] (in) @param right [PAR16] (in) @param offset [PAR32] (in)

# File lib/lignite/ev3_ops.rb, line 2165
def jr_gteq16(left, right, offset)
  logger.debug do
    args = [left, right, offset]
    "called jr_gteq16 with #{args.inspect}"
  end

  bytes = u8(0x79)
  bytes += param_simple(left)
  bytes += param_simple(right)
  bytes += param_simple(offset)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
jr_gteq32(left, right, offset) click to toggle source

Branch relative OFFSET if LEFT is greater than or equal to RIGHT @param left [PAR32] (in) @param right [PAR32] (in) @param offset [PAR32] (in)

# File lib/lignite/ev3_ops.rb, line 2183
def jr_gteq32(left, right, offset)
  logger.debug do
    args = [left, right, offset]
    "called jr_gteq32 with #{args.inspect}"
  end

  bytes = u8(0x7A)
  bytes += param_simple(left)
  bytes += param_simple(right)
  bytes += param_simple(offset)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
jr_gteq8(left, right, offset) click to toggle source

Branch relative OFFSET if LEFT is greater than or equal to RIGHT @param left [PAR8] (in) @param right [PAR8] (in) @param offset [PAR32] (in)

# File lib/lignite/ev3_ops.rb, line 2147
def jr_gteq8(left, right, offset)
  logger.debug do
    args = [left, right, offset]
    "called jr_gteq8 with #{args.inspect}"
  end

  bytes = u8(0x78)
  bytes += param_simple(left)
  bytes += param_simple(right)
  bytes += param_simple(offset)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
jr_gteqf(left, right, offset) click to toggle source

Branch relative OFFSET if LEFT is greater than or equal to RIGHT @param left [PARF] (in) @param right [PARF] (in) @param offset [PAR32] (in)

# File lib/lignite/ev3_ops.rb, line 2201
def jr_gteqf(left, right, offset)
  logger.debug do
    args = [left, right, offset]
    "called jr_gteqf with #{args.inspect}"
  end

  bytes = u8(0x7B)
  bytes += param_simple(left)
  bytes += param_simple(right)
  bytes += param_simple(offset)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
jr_gtf(left, right, offset) click to toggle source

Branch relative OFFSET if LEFT is greater than RIGHT @param left [PARF] (in) @param right [PARF] (in) @param offset [PAR32] (in)

# File lib/lignite/ev3_ops.rb, line 1913
def jr_gtf(left, right, offset)
  logger.debug do
    args = [left, right, offset]
    "called jr_gtf with #{args.inspect}"
  end

  bytes = u8(0x6B)
  bytes += param_simple(left)
  bytes += param_simple(right)
  bytes += param_simple(offset)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
jr_lt16(left, right, offset) click to toggle source

Branch relative OFFSET if LEFT is less than RIGHT @param left [PAR16] (in) @param right [PAR16] (in) @param offset [PAR32] (in)

# File lib/lignite/ev3_ops.rb, line 1805
def jr_lt16(left, right, offset)
  logger.debug do
    args = [left, right, offset]
    "called jr_lt16 with #{args.inspect}"
  end

  bytes = u8(0x65)
  bytes += param_simple(left)
  bytes += param_simple(right)
  bytes += param_simple(offset)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
jr_lt32(left, right, offset) click to toggle source

Branch relative OFFSET if LEFT is less than RIGHT @param left [PAR32] (in) @param right [PAR32] (in) @param offset [PAR32] (in)

# File lib/lignite/ev3_ops.rb, line 1823
def jr_lt32(left, right, offset)
  logger.debug do
    args = [left, right, offset]
    "called jr_lt32 with #{args.inspect}"
  end

  bytes = u8(0x66)
  bytes += param_simple(left)
  bytes += param_simple(right)
  bytes += param_simple(offset)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
jr_lt8(left, right, offset) click to toggle source

Branch relative OFFSET if LEFT is less than RIGHT @param left [PAR8] (in) @param right [PAR8] (in) @param offset [PAR32] (in)

# File lib/lignite/ev3_ops.rb, line 1787
def jr_lt8(left, right, offset)
  logger.debug do
    args = [left, right, offset]
    "called jr_lt8 with #{args.inspect}"
  end

  bytes = u8(0x64)
  bytes += param_simple(left)
  bytes += param_simple(right)
  bytes += param_simple(offset)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
jr_lteq16(left, right, offset) click to toggle source

Branch relative OFFSET if LEFT is less than or equal to RIGHT @param left [PAR16] (in) @param right [PAR16] (in) @param offset [PAR32] (in)

# File lib/lignite/ev3_ops.rb, line 2093
def jr_lteq16(left, right, offset)
  logger.debug do
    args = [left, right, offset]
    "called jr_lteq16 with #{args.inspect}"
  end

  bytes = u8(0x75)
  bytes += param_simple(left)
  bytes += param_simple(right)
  bytes += param_simple(offset)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
jr_lteq32(left, right, offset) click to toggle source

Branch relative OFFSET if LEFT is less than or equal to RIGHT @param left [PAR32] (in) @param right [PAR32] (in) @param offset [PAR32] (in)

# File lib/lignite/ev3_ops.rb, line 2111
def jr_lteq32(left, right, offset)
  logger.debug do
    args = [left, right, offset]
    "called jr_lteq32 with #{args.inspect}"
  end

  bytes = u8(0x76)
  bytes += param_simple(left)
  bytes += param_simple(right)
  bytes += param_simple(offset)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
jr_lteq8(left, right, offset) click to toggle source

Branch relative OFFSET if LEFT is less than or equal to RIGHT @param left [PAR8] (in) @param right [PAR8] (in) @param offset [PAR32] (in)

# File lib/lignite/ev3_ops.rb, line 2075
def jr_lteq8(left, right, offset)
  logger.debug do
    args = [left, right, offset]
    "called jr_lteq8 with #{args.inspect}"
  end

  bytes = u8(0x74)
  bytes += param_simple(left)
  bytes += param_simple(right)
  bytes += param_simple(offset)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
jr_lteqf(left, right, offset) click to toggle source

Branch relative OFFSET if LEFT is less than or equal to RIGHT @param left [PARF] (in) @param right [PARF] (in) @param offset [PAR32] (in)

# File lib/lignite/ev3_ops.rb, line 2129
def jr_lteqf(left, right, offset)
  logger.debug do
    args = [left, right, offset]
    "called jr_lteqf with #{args.inspect}"
  end

  bytes = u8(0x77)
  bytes += param_simple(left)
  bytes += param_simple(right)
  bytes += param_simple(offset)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
jr_ltf(left, right, offset) click to toggle source

Branch relative OFFSET if LEFT is less than RIGHT @param left [PARF] (in) @param right [PARF] (in) @param offset [PAR32] (in)

# File lib/lignite/ev3_ops.rb, line 1841
def jr_ltf(left, right, offset)
  logger.debug do
    args = [left, right, offset]
    "called jr_ltf with #{args.inspect}"
  end

  bytes = u8(0x67)
  bytes += param_simple(left)
  bytes += param_simple(right)
  bytes += param_simple(offset)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
jr_nan(value, offset) click to toggle source

Branch relative if VALUE is NAN (not a number) @param value [PARF] (in) @param offset [PAR32] (in)

# File lib/lignite/ev3_ops.rb, line 1188
def jr_nan(value, offset)
  logger.debug do
    args = [value, offset]
    "called jr_nan with #{args.inspect}"
  end

  bytes = u8(0x43)
  bytes += param_simple(value)
  bytes += param_simple(offset)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
jr_neq16(left, right, offset) click to toggle source

Branch relative OFFSET if LEFT is not equal to RIGHT @param left [PAR16] (in) @param right [PAR16] (in) @param offset [PAR32] (in)

# File lib/lignite/ev3_ops.rb, line 2021
def jr_neq16(left, right, offset)
  logger.debug do
    args = [left, right, offset]
    "called jr_neq16 with #{args.inspect}"
  end

  bytes = u8(0x71)
  bytes += param_simple(left)
  bytes += param_simple(right)
  bytes += param_simple(offset)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
jr_neq32(left, right, offset) click to toggle source

Branch relative OFFSET if LEFT is not equal to RIGHT @param left [PAR32] (in) @param right [PAR32] (in) @param offset [PAR32] (in)

# File lib/lignite/ev3_ops.rb, line 2039
def jr_neq32(left, right, offset)
  logger.debug do
    args = [left, right, offset]
    "called jr_neq32 with #{args.inspect}"
  end

  bytes = u8(0x72)
  bytes += param_simple(left)
  bytes += param_simple(right)
  bytes += param_simple(offset)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
jr_neq8(left, right, offset) click to toggle source

Branch relative OFFSET if LEFT is not equal to RIGHT @param left [PAR8] (in) @param right [PAR8] (in) @param offset [PAR32] (in)

# File lib/lignite/ev3_ops.rb, line 2003
def jr_neq8(left, right, offset)
  logger.debug do
    args = [left, right, offset]
    "called jr_neq8 with #{args.inspect}"
  end

  bytes = u8(0x70)
  bytes += param_simple(left)
  bytes += param_simple(right)
  bytes += param_simple(offset)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
jr_neqf(left, right, offset) click to toggle source

Branch relative OFFSET if LEFT is not equal to RIGHT @param left [PARF] (in) @param right [PARF] (in) @param offset [PAR32] (in)

# File lib/lignite/ev3_ops.rb, line 2057
def jr_neqf(left, right, offset)
  logger.debug do
    args = [left, right, offset]
    "called jr_neqf with #{args.inspect}"
  end

  bytes = u8(0x73)
  bytes += param_simple(left)
  bytes += param_simple(right)
  bytes += param_simple(offset)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
jr_true(flag, offset) click to toggle source

Branch relative if FLAG is TRUE (non zero) @param flag [PAR8] (in) @param offset [PAR32] (in)

# File lib/lignite/ev3_ops.rb, line 1172
def jr_true(flag, offset)
  logger.debug do
    args = [flag, offset]
    "called jr_true with #{args.inspect}"
  end

  bytes = u8(0x42)
  bytes += param_simple(flag)
  bytes += param_simple(offset)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
keep_alive(minutes) click to toggle source

Keep alive @param minutes [PAR8] (out) Number of minutes before sleep

# File lib/lignite/ev3_ops.rb, line 5341
def keep_alive(minutes)
  logger.debug do
    args = [minutes]
    "called keep_alive with #{args.inspect}"
  end

  bytes = u8(0x90)
  bytes += param_simple(minutes)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
mailbox_close(no) click to toggle source

Closes mailbox indicated by NO @param no [PAR8] (in) Reference ID mailbox number

# File lib/lignite/ev3_ops.rb, line 9074
def mailbox_close(no)
  logger.debug do
    args = [no]
    "called mailbox_close with #{args.inspect}"
  end

  bytes = u8(0xDD)
  bytes += param_simple(no)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
mailbox_open(no, boxname, types, fifosize, values) click to toggle source

Open a mail box on the brick @param no [PAR8] (in) Reference ID for the mailbox. Maximum number of mailboxes is 30 @param boxname [PAR8] (in) Zero terminated string with the mailbox name @param types [PAR8] (in) Data type of the content of the mailbox @param fifosize [PAR8] (in) Not used @param values [PAR8] (in) Number of values of the type (specified by TYPE).

# File lib/lignite/ev3_ops.rb, line 8986
def mailbox_open(no, boxname, types, fifosize, values)
  logger.debug do
    args = [no, boxname, types, fifosize, values]
    "called mailbox_open with #{args.inspect}"
  end

  bytes = u8(0xD8)
  bytes += param_simple(no)
  bytes += param_simple(boxname)
  bytes += param_simple(types)
  bytes += param_simple(fifosize)
  bytes += param_simple(values)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
mailbox_read(no, length, *values) click to toggle source

Read data from mailbox specified by NO @param no [PAR8] (in) Messagebox ID of the message box you want to read @param length [PAR8] (in) Maximum bytes to be read @param values [PARNO] (in) Number of value to read

# File lib/lignite/ev3_ops.rb, line 9028
def mailbox_read(no, length, *values)
  logger.debug do
    args = [no, length, *values]
    "called mailbox_read with #{args.inspect}"
  end

  bytes = u8(0xDA)
  bytes += param_simple(no)
  bytes += param_simple(length)
  bytes += param_n_multiple(*values)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
mailbox_ready(no) click to toggle source

Waiting from message to be read @param no [PAR8] (in) Reference ID mailbox number

# File lib/lignite/ev3_ops.rb, line 9060
def mailbox_ready(no)
  logger.debug do
    args = [no]
    "called mailbox_ready with #{args.inspect}"
  end

  bytes = u8(0xDC)
  bytes += param_simple(no)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
mailbox_size(no, size) click to toggle source

Returns the size of the mailbox. @param no [PAR8] (in) Reference ID mailbox number @param size [PAR8] (out) Size in bytes of the contents of mailbox NO

# File lib/lignite/ev3_ops.rb, line 9189
def mailbox_size(no, size)
  logger.debug do
    args = [no, size]
    "called mailbox_size with #{args.inspect}"
  end

  bytes = u8(0xE5)
  bytes += param_simple(no)
  bytes += param_simple(size)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
mailbox_test(no, busy) click to toggle source

Tests if new message has been read @param no [PAR8] (in) Reference ID mailbox number @param busy [PAR8] (out) If Busy = TRUE then no new messages are received

# File lib/lignite/ev3_ops.rb, line 9045
def mailbox_test(no, busy)
  logger.debug do
    args = [no, busy]
    "called mailbox_test with #{args.inspect}"
  end

  bytes = u8(0xDB)
  bytes += param_simple(no)
  bytes += param_simple(busy)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
mailbox_write(brickname, hardware, boxname, type, *values) click to toggle source

Write to mailbox in remote brick @param brickname [PAR8] (in) Zero terminated string name of the receiving brick @param hardware [PAR8] (in) Transportation media @param boxname [PAR8] (in) Zero terminated string name of the receiving mailbox @param type [PAR8] (in) Data type of the values @param values [PARNO] (in) Number of values of the specified type to send

# File lib/lignite/ev3_ops.rb, line 9008
def mailbox_write(brickname, hardware, boxname, type, *values)
  logger.debug do
    args = [brickname, hardware, boxname, type, *values]
    "called mailbox_write with #{args.inspect}"
  end

  bytes = u8(0xD9)
  bytes += param_simple(brickname)
  bytes += param_simple(hardware)
  bytes += param_simple(boxname)
  bytes += param_simple(type)
  bytes += param_n_multiple(*values)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
math(*args) click to toggle source
# File lib/lignite/ev3_ops.rb, line 5300
def math(*args)
  logger.debug "called math with #{args.inspect}"
  cvalue = args.shift
  csym = MULTIPLEX_MATH.fetch(cvalue)
  __send__("math_#{csym}", *args)
end
math_abs(x, r) click to toggle source

Absolute r = fabs(x) @param x [PARF] (in) @param r [PARF] (out)

# File lib/lignite/ev3_ops.rb, line 4967
def math_abs(x, r)
  logger.debug do
    args = [x, r]
    "called math_abs with #{args.inspect}"
  end

  bytes = u8(0x8D)
  bytes += param_simple(6)
  bytes += param_simple(x)
  bytes += param_simple(r)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
math_acos(x, r) click to toggle source

ACos (R = acos(X)) @param x [PARF] (in) @param r [PARF] (out)

# File lib/lignite/ev3_ops.rb, line 5138
def math_acos(x, r)
  logger.debug do
    args = [x, r]
    "called math_acos with #{args.inspect}"
  end

  bytes = u8(0x8D)
  bytes += param_simple(15)
  bytes += param_simple(x)
  bytes += param_simple(r)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
math_asin(x, r) click to toggle source

ASin (R = asinf(X)) @param x [PARF] (in) @param r [PARF] (out)

# File lib/lignite/ev3_ops.rb, line 5119
def math_asin(x, r)
  logger.debug do
    args = [x, r]
    "called math_asin with #{args.inspect}"
  end

  bytes = u8(0x8D)
  bytes += param_simple(14)
  bytes += param_simple(x)
  bytes += param_simple(r)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
math_atan(x, r) click to toggle source

ATan (R = atanf(X)) @param x [PARF] (in) @param r [PARF] (out)

# File lib/lignite/ev3_ops.rb, line 5157
def math_atan(x, r)
  logger.debug do
    args = [x, r]
    "called math_atan with #{args.inspect}"
  end

  bytes = u8(0x8D)
  bytes += param_simple(16)
  bytes += param_simple(x)
  bytes += param_simple(r)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
math_ceil(x, r) click to toggle source

Ceiling r = ceil(x) @param x [PARF] (in) @param r [PARF] (out)

# File lib/lignite/ev3_ops.rb, line 4929
def math_ceil(x, r)
  logger.debug do
    args = [x, r]
    "called math_ceil with #{args.inspect}"
  end

  bytes = u8(0x8D)
  bytes += param_simple(4)
  bytes += param_simple(x)
  bytes += param_simple(r)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
math_cos(x, r) click to toggle source

Cos (R = cos(X)) @param x [PARF] (in) @param r [PARF] (out)

# File lib/lignite/ev3_ops.rb, line 5081
def math_cos(x, r)
  logger.debug do
    args = [x, r]
    "called math_cos with #{args.inspect}"
  end

  bytes = u8(0x8D)
  bytes += param_simple(12)
  bytes += param_simple(x)
  bytes += param_simple(r)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
math_exp(x, r) click to toggle source

e^x r = expf(x) @param x [PARF] (in) @param r [PARF] (out)

# File lib/lignite/ev3_ops.rb, line 4870
def math_exp(x, r)
  logger.debug do
    args = [x, r]
    "called math_exp with #{args.inspect}"
  end

  bytes = u8(0x8D)
  bytes += param_simple(1)
  bytes += param_simple(x)
  bytes += param_simple(r)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
math_floor(x, r) click to toggle source

Floor r = floor(x) @param x [PARF] (in) @param r [PARF] (out)

# File lib/lignite/ev3_ops.rb, line 4910
def math_floor(x, r)
  logger.debug do
    args = [x, r]
    "called math_floor with #{args.inspect}"
  end

  bytes = u8(0x8D)
  bytes += param_simple(3)
  bytes += param_simple(x)
  bytes += param_simple(r)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
math_ln(x, r) click to toggle source

Ln r = log(x) @param x [PARF] (in) @param r [PARF] (out)

# File lib/lignite/ev3_ops.rb, line 5043
def math_ln(x, r)
  logger.debug do
    args = [x, r]
    "called math_ln with #{args.inspect}"
  end

  bytes = u8(0x8D)
  bytes += param_simple(10)
  bytes += param_simple(x)
  bytes += param_simple(r)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
math_log(x, r) click to toggle source

Log r = log10(x) @param x [PARF] (in) @param r [PARF] (out)

# File lib/lignite/ev3_ops.rb, line 5024
def math_log(x, r)
  logger.debug do
    args = [x, r]
    "called math_log with #{args.inspect}"
  end

  bytes = u8(0x8D)
  bytes += param_simple(9)
  bytes += param_simple(x)
  bytes += param_simple(r)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
math_mod(x, y, r) click to toggle source

Modulo r = fmod(x,y) @param x [PARF] (in) @param y [PARF] (in) @param r [PARF] (out)

# File lib/lignite/ev3_ops.rb, line 4890
def math_mod(x, y, r)
  logger.debug do
    args = [x, y, r]
    "called math_mod with #{args.inspect}"
  end

  bytes = u8(0x8D)
  bytes += param_simple(2)
  bytes += param_simple(x)
  bytes += param_simple(y)
  bytes += param_simple(r)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
math_mod16(x, y, r) click to toggle source

Modulo DATA16 r = x % y @param x [PAR16] (in) @param y [PAR16] (in) @param r [PAR16] (out)

# File lib/lignite/ev3_ops.rb, line 5198
def math_mod16(x, y, r)
  logger.debug do
    args = [x, y, r]
    "called math_mod16 with #{args.inspect}"
  end

  bytes = u8(0x8D)
  bytes += param_simple(18)
  bytes += param_simple(x)
  bytes += param_simple(y)
  bytes += param_simple(r)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
math_mod32(x, y, r) click to toggle source

Modulo DATA32 r = x % y @param x [PAR32] (in) @param y [PAR32] (in) @param r [PAR32] (out)

# File lib/lignite/ev3_ops.rb, line 5219
def math_mod32(x, y, r)
  logger.debug do
    args = [x, y, r]
    "called math_mod32 with #{args.inspect}"
  end

  bytes = u8(0x8D)
  bytes += param_simple(19)
  bytes += param_simple(x)
  bytes += param_simple(y)
  bytes += param_simple(r)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
math_mod8(x, y, r) click to toggle source

Modulo DATA8 r = x % y @param x [PAR8] (in) @param y [PAR8] (in) @param r [PAR8] (out)

# File lib/lignite/ev3_ops.rb, line 5177
def math_mod8(x, y, r)
  logger.debug do
    args = [x, y, r]
    "called math_mod8 with #{args.inspect}"
  end

  bytes = u8(0x8D)
  bytes += param_simple(17)
  bytes += param_simple(x)
  bytes += param_simple(y)
  bytes += param_simple(r)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
math_negate(x, r) click to toggle source

Negate r = 0.0 - x @param x [PARF] (in) @param r [PARF] (out)

# File lib/lignite/ev3_ops.rb, line 4986
def math_negate(x, r)
  logger.debug do
    args = [x, r]
    "called math_negate with #{args.inspect}"
  end

  bytes = u8(0x8D)
  bytes += param_simple(7)
  bytes += param_simple(x)
  bytes += param_simple(r)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
math_pow(x, y, r) click to toggle source

Exponent r = powf(x,y) @param x [PARF] (in) @param y [PARF] (in) @param r [PARF] (out)

# File lib/lignite/ev3_ops.rb, line 5240
def math_pow(x, y, r)
  logger.debug do
    args = [x, y, r]
    "called math_pow with #{args.inspect}"
  end

  bytes = u8(0x8D)
  bytes += param_simple(20)
  bytes += param_simple(x)
  bytes += param_simple(y)
  bytes += param_simple(r)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
math_round(x, r) click to toggle source

Round r = round(x) @param x [PARF] (in) @param r [PARF] (out)

# File lib/lignite/ev3_ops.rb, line 4948
def math_round(x, r)
  logger.debug do
    args = [x, r]
    "called math_round with #{args.inspect}"
  end

  bytes = u8(0x8D)
  bytes += param_simple(5)
  bytes += param_simple(x)
  bytes += param_simple(r)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
math_sin(x, r) click to toggle source

Sin (R = sinf(X)) @param x [PARF] (in) @param r [PARF] (out)

# File lib/lignite/ev3_ops.rb, line 5062
def math_sin(x, r)
  logger.debug do
    args = [x, r]
    "called math_sin with #{args.inspect}"
  end

  bytes = u8(0x8D)
  bytes += param_simple(11)
  bytes += param_simple(x)
  bytes += param_simple(r)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
math_sqrt(x, r) click to toggle source

Squareroot r = sqrt(x) @param x [PARF] (in) @param r [PARF] (out)

# File lib/lignite/ev3_ops.rb, line 5005
def math_sqrt(x, r)
  logger.debug do
    args = [x, r]
    "called math_sqrt with #{args.inspect}"
  end

  bytes = u8(0x8D)
  bytes += param_simple(8)
  bytes += param_simple(x)
  bytes += param_simple(r)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
math_tan(x, r) click to toggle source

Tan (R = tanf(X)) @param x [PARF] (in) @param r [PARF] (out)

# File lib/lignite/ev3_ops.rb, line 5100
def math_tan(x, r)
  logger.debug do
    args = [x, r]
    "called math_tan with #{args.inspect}"
  end

  bytes = u8(0x8D)
  bytes += param_simple(13)
  bytes += param_simple(x)
  bytes += param_simple(r)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
math_trunc(x, p, r) click to toggle source

Truncate r = (float)((int)(x * pow(y))) / pow(y) @param x [PARF] (in) Value @param p [PAR8] (in) Precision [0..9] @param r [PARF] (out) Result

# File lib/lignite/ev3_ops.rb, line 5261
def math_trunc(x, p, r)
  logger.debug do
    args = [x, p, r]
    "called math_trunc with #{args.inspect}"
  end

  bytes = u8(0x8D)
  bytes += param_simple(21)
  bytes += param_simple(x)
  bytes += param_simple(p)
  bytes += param_simple(r)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
memory_read(prgid, objid, offset, size, array) click to toggle source

Read VM memory @param prgid [PAR16] (in) Program slot number (must be running) @param objid [PAR16] (in) Object id (zero means globals) @param offset [PAR32] (in) Offset (start from) @param size [PAR32] (in) Size (length of array to read) @param array [PAR8] (out) First element of DATA8 array to receive data

# File lib/lignite/ev3_ops.rb, line 2636
def memory_read(prgid, objid, offset, size, array)
  logger.debug do
    args = [prgid, objid, offset, size, array]
    "called memory_read with #{args.inspect}"
  end

  bytes = u8(0x7F)
  bytes += param_simple(prgid)
  bytes += param_simple(objid)
  bytes += param_simple(offset)
  bytes += param_simple(size)
  bytes += param_simple(array)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
memory_usage(total, free) click to toggle source

Get memory usage @param total [PAR32] (out) Total memory [KB] @param free [PAR32] (out) Free memory [KB]

# File lib/lignite/ev3_ops.rb, line 7858
def memory_usage(total, free)
  logger.debug do
    args = [total, free]
    "called memory_usage with #{args.inspect}"
  end

  bytes = u8(0xC5)
  bytes += param_simple(total)
  bytes += param_simple(free)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
memory_write(prgid, objid, offset, size, array) click to toggle source

Write VM memory @param prgid [PAR16] (in) Program slot number (must be running) @param objid [PAR16] (in) Object id (zero means globals) @param offset [PAR32] (in) Offset (start from) @param size [PAR32] (in) Size (length of array to write) @param array [PAR8] (in) First element of DATA8 array to write

# File lib/lignite/ev3_ops.rb, line 2614
def memory_write(prgid, objid, offset, size, array)
  logger.debug do
    args = [prgid, objid, offset, size, array]
    "called memory_write with #{args.inspect}"
  end

  bytes = u8(0x7E)
  bytes += param_simple(prgid)
  bytes += param_simple(objid)
  bytes += param_simple(offset)
  bytes += param_simple(size)
  bytes += param_simple(array)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
move16_16(source, destination) click to toggle source

Move 16 bit value from SOURCE to DESTINATION @param source [PAR16] (in) @param destination [PAR16] (out)

# File lib/lignite/ev3_ops.rb, line 966
def move16_16(source, destination)
  logger.debug do
    args = [source, destination]
    "called move16_16 with #{args.inspect}"
  end

  bytes = u8(0x35)
  bytes += param_simple(source)
  bytes += param_simple(destination)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
move16_32(source, destination) click to toggle source

Move 16 bit value from SOURCE to DESTINATION @param source [PAR16] (in) @param destination [PAR32] (out)

# File lib/lignite/ev3_ops.rb, line 982
def move16_32(source, destination)
  logger.debug do
    args = [source, destination]
    "called move16_32 with #{args.inspect}"
  end

  bytes = u8(0x36)
  bytes += param_simple(source)
  bytes += param_simple(destination)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
move16_8(source, destination) click to toggle source

Move 16 bit value from SOURCE to DESTINATION @param source [PAR16] (in) @param destination [PAR8] (out)

# File lib/lignite/ev3_ops.rb, line 950
def move16_8(source, destination)
  logger.debug do
    args = [source, destination]
    "called move16_8 with #{args.inspect}"
  end

  bytes = u8(0x34)
  bytes += param_simple(source)
  bytes += param_simple(destination)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
move16_f(source, destination) click to toggle source

Move 16 bit value from SOURCE to DESTINATION @param source [PAR16] (in) @param destination [PARF] (out)

# File lib/lignite/ev3_ops.rb, line 998
def move16_f(source, destination)
  logger.debug do
    args = [source, destination]
    "called move16_f with #{args.inspect}"
  end

  bytes = u8(0x37)
  bytes += param_simple(source)
  bytes += param_simple(destination)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
move32_16(source, destination) click to toggle source

Move 32 bit value from SOURCE to DESTINATION @param source [PAR32] (in) @param destination [PAR16] (out)

# File lib/lignite/ev3_ops.rb, line 1030
def move32_16(source, destination)
  logger.debug do
    args = [source, destination]
    "called move32_16 with #{args.inspect}"
  end

  bytes = u8(0x39)
  bytes += param_simple(source)
  bytes += param_simple(destination)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
move32_32(source, destination) click to toggle source

Move 32 bit value from SOURCE to DESTINATION @param source [PAR32] (in) @param destination [PAR32] (out)

# File lib/lignite/ev3_ops.rb, line 1046
def move32_32(source, destination)
  logger.debug do
    args = [source, destination]
    "called move32_32 with #{args.inspect}"
  end

  bytes = u8(0x3A)
  bytes += param_simple(source)
  bytes += param_simple(destination)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
move32_8(source, destination) click to toggle source

Move 32 bit value from SOURCE to DESTINATION @param source [PAR32] (in) @param destination [PAR8] (out)

# File lib/lignite/ev3_ops.rb, line 1014
def move32_8(source, destination)
  logger.debug do
    args = [source, destination]
    "called move32_8 with #{args.inspect}"
  end

  bytes = u8(0x38)
  bytes += param_simple(source)
  bytes += param_simple(destination)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
move32_f(source, destination) click to toggle source

Move 32 bit value from SOURCE to DESTINATION @param source [PAR32] (in) @param destination [PARF] (out)

# File lib/lignite/ev3_ops.rb, line 1062
def move32_f(source, destination)
  logger.debug do
    args = [source, destination]
    "called move32_f with #{args.inspect}"
  end

  bytes = u8(0x3B)
  bytes += param_simple(source)
  bytes += param_simple(destination)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
move8_16(source, destination) click to toggle source

Move 8 bit value from SOURCE to DESTINATION @param source [PAR8] (in) @param destination [PAR16] (out)

# File lib/lignite/ev3_ops.rb, line 902
def move8_16(source, destination)
  logger.debug do
    args = [source, destination]
    "called move8_16 with #{args.inspect}"
  end

  bytes = u8(0x31)
  bytes += param_simple(source)
  bytes += param_simple(destination)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
move8_32(source, destination) click to toggle source

Move 8 bit value from SOURCE to DESTINATION @param source [PAR8] (in) @param destination [PAR32] (out)

# File lib/lignite/ev3_ops.rb, line 918
def move8_32(source, destination)
  logger.debug do
    args = [source, destination]
    "called move8_32 with #{args.inspect}"
  end

  bytes = u8(0x32)
  bytes += param_simple(source)
  bytes += param_simple(destination)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
move8_8(source, destination) click to toggle source

Move 8 bit value from SOURCE to DESTINATION @param source [PAR8] (in) @param destination [PAR8] (out)

# File lib/lignite/ev3_ops.rb, line 886
def move8_8(source, destination)
  logger.debug do
    args = [source, destination]
    "called move8_8 with #{args.inspect}"
  end

  bytes = u8(0x30)
  bytes += param_simple(source)
  bytes += param_simple(destination)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
move8_f(source, destination) click to toggle source

Move 8 bit value from SOURCE to DESTINATION @param source [PAR8] (in) @param destination [PARF] (out)

# File lib/lignite/ev3_ops.rb, line 934
def move8_f(source, destination)
  logger.debug do
    args = [source, destination]
    "called move8_f with #{args.inspect}"
  end

  bytes = u8(0x33)
  bytes += param_simple(source)
  bytes += param_simple(destination)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
movef_16(source, destination) click to toggle source

Move floating point value from SOURCE to DESTINATION @param source [PARF] (in) @param destination [PAR16] (out)

# File lib/lignite/ev3_ops.rb, line 1094
def movef_16(source, destination)
  logger.debug do
    args = [source, destination]
    "called movef_16 with #{args.inspect}"
  end

  bytes = u8(0x3D)
  bytes += param_simple(source)
  bytes += param_simple(destination)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
movef_32(source, destination) click to toggle source

Move floating point value from SOURCE to DESTINATION @param source [PARF] (in) @param destination [PAR32] (out)

# File lib/lignite/ev3_ops.rb, line 1110
def movef_32(source, destination)
  logger.debug do
    args = [source, destination]
    "called movef_32 with #{args.inspect}"
  end

  bytes = u8(0x3E)
  bytes += param_simple(source)
  bytes += param_simple(destination)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
movef_8(source, destination) click to toggle source

Move floating point value from SOURCE to DESTINATION @param source [PARF] (in) @param destination [PAR8] (out)

# File lib/lignite/ev3_ops.rb, line 1078
def movef_8(source, destination)
  logger.debug do
    args = [source, destination]
    "called movef_8 with #{args.inspect}"
  end

  bytes = u8(0x3C)
  bytes += param_simple(source)
  bytes += param_simple(destination)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
movef_f(source, destination) click to toggle source

Move floating point value from SOURCE to DESTINATION @param source [PARF] (in) @param destination [PARF] (out)

# File lib/lignite/ev3_ops.rb, line 1126
def movef_f(source, destination)
  logger.debug do
    args = [source, destination]
    "called movef_f with #{args.inspect}"
  end

  bytes = u8(0x3F)
  bytes += param_simple(source)
  bytes += param_simple(destination)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
mul16(source1, source2, destination) click to toggle source

Multiply two 16 bit values DESTINATION = SOURCE1 * SOURCE2 @param source1 [PAR16] (in) @param source2 [PAR16] (in) @param destination [PAR16] (out)

# File lib/lignite/ev3_ops.rb, line 527
def mul16(source1, source2, destination)
  logger.debug do
    args = [source1, source2, destination]
    "called mul16 with #{args.inspect}"
  end

  bytes = u8(0x19)
  bytes += param_simple(source1)
  bytes += param_simple(source2)
  bytes += param_simple(destination)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
mul32(source1, source2, destination) click to toggle source

Multiply two 32 bit values DESTINATION = SOURCE1 * SOURCE2 @param source1 [PAR32] (in) @param source2 [PAR32] (in) @param destination [PAR32] (out)

# File lib/lignite/ev3_ops.rb, line 545
def mul32(source1, source2, destination)
  logger.debug do
    args = [source1, source2, destination]
    "called mul32 with #{args.inspect}"
  end

  bytes = u8(0x1A)
  bytes += param_simple(source1)
  bytes += param_simple(source2)
  bytes += param_simple(destination)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
mul8(source1, source2, destination) click to toggle source

Multiply two 8 bit values DESTINATION = SOURCE1 * SOURCE2 @param source1 [PAR8] (in) @param source2 [PAR8] (in) @param destination [PAR8] (out)

# File lib/lignite/ev3_ops.rb, line 509
def mul8(source1, source2, destination)
  logger.debug do
    args = [source1, source2, destination]
    "called mul8 with #{args.inspect}"
  end

  bytes = u8(0x18)
  bytes += param_simple(source1)
  bytes += param_simple(source2)
  bytes += param_simple(destination)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
mulf(source1, source2, destination) click to toggle source

Multiply two floating point values DESTINATION = SOURCE1 * SOURCE2 @param source1 [PARF] (in) @param source2 [PARF] (in) @param destination [PARF] (out)

# File lib/lignite/ev3_ops.rb, line 563
def mulf(source1, source2, destination)
  logger.debug do
    args = [source1, source2, destination]
    "called mulf with #{args.inspect}"
  end

  bytes = u8(0x1B)
  bytes += param_simple(source1)
  bytes += param_simple(source2)
  bytes += param_simple(destination)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
nop() click to toggle source

This code does absolutely nothing

# File lib/lignite/ev3_ops.rb, line 19
def nop
  logger.debug do
    args = []
    "called nop with #{args.inspect}"
  end

  bytes = u8(0x01)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
note_to_freq(note, freq) click to toggle source

Convert note to tone @param note [PAR8] (in) Note string (HND) (e.c. “C#4”) @param freq [PAR16] (out) Frequency [Hz]

# File lib/lignite/ev3_ops.rb, line 1770
def note_to_freq(note, freq)
  logger.debug do
    args = [note, freq]
    "called note_to_freq with #{args.inspect}"
  end

  bytes = u8(0x63)
  bytes += param_simple(note)
  bytes += param_simple(freq)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
object_end() click to toggle source

Stops current object

# File lib/lignite/ev3_ops.rb, line 149
def object_end
  logger.debug do
    args = []
    "called object_end with #{args.inspect}"
  end

  bytes = u8(0x0A)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
object_start(objid) click to toggle source

Start specific object @param objid [PAR16] (in) Object id

# File lib/lignite/ev3_ops.rb, line 80
def object_start(objid)
  logger.debug do
    args = [objid]
    "called object_start with #{args.inspect}"
  end

  bytes = u8(0x05)
  bytes += param_simple(objid)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
object_stop(objid) click to toggle source

Stops specific object @param objid [PAR16] (in) Object id

# File lib/lignite/ev3_ops.rb, line 66
def object_stop(objid)
  logger.debug do
    args = [objid]
    "called object_stop with #{args.inspect}"
  end

  bytes = u8(0x04)
  bytes += param_simple(objid)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
object_trig(objid) click to toggle source

Triggers object and run the object if fully triggered @param objid [PAR16] (in) Object id

# File lib/lignite/ev3_ops.rb, line 94
def object_trig(objid)
  logger.debug do
    args = [objid]
    "called object_trig with #{args.inspect}"
  end

  bytes = u8(0x06)
  bytes += param_simple(objid)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
object_wait(objid) click to toggle source

Wait until object has run @param objid [PAR16] (in) Object id

# File lib/lignite/ev3_ops.rb, line 108
def object_wait(objid)
  logger.debug do
    args = [objid]
    "called object_wait with #{args.inspect}"
  end

  bytes = u8(0x07)
  bytes += param_simple(objid)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
or16(source1, source2, destination) click to toggle source

Or two 16 bit values DESTINATION = SOURCE1 | SOURCE2 @param source1 [PAR16] (in) @param source2 [PAR16] (in) @param destination [PAR16] (out)

# File lib/lignite/ev3_ops.rb, line 671
def or16(source1, source2, destination)
  logger.debug do
    args = [source1, source2, destination]
    "called or16 with #{args.inspect}"
  end

  bytes = u8(0x21)
  bytes += param_simple(source1)
  bytes += param_simple(source2)
  bytes += param_simple(destination)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
or32(source1, source2, destination) click to toggle source

Or two 32 bit values DESTINATION = SOURCE1 | SOURCE2 @param source1 [PAR32] (in) @param source2 [PAR32] (in) @param destination [PAR32] (out)

# File lib/lignite/ev3_ops.rb, line 689
def or32(source1, source2, destination)
  logger.debug do
    args = [source1, source2, destination]
    "called or32 with #{args.inspect}"
  end

  bytes = u8(0x22)
  bytes += param_simple(source1)
  bytes += param_simple(source2)
  bytes += param_simple(destination)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
or8(source1, source2, destination) click to toggle source

Or two 8 bit values DESTINATION = SOURCE1 | SOURCE2 @param source1 [PAR8] (in) @param source2 [PAR8] (in) @param destination [PAR8] (out)

# File lib/lignite/ev3_ops.rb, line 653
def or8(source1, source2, destination)
  logger.debug do
    args = [source1, source2, destination]
    "called or8 with #{args.inspect}"
  end

  bytes = u8(0x20)
  bytes += param_simple(source1)
  bytes += param_simple(source2)
  bytes += param_simple(destination)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
output_clr_count(layer, nos) click to toggle source

Clearing tacho count when used as sensor @param layer [PAR8] (in) Daisy chain layer number [0..3] @param nos [PAR8] (in) Output bit field [0x00..0x0F]

# File lib/lignite/ev3_ops.rb, line 6688
def output_clr_count(layer, nos)
  logger.debug do
    args = [layer, nos]
    "called output_clr_count with #{args.inspect}"
  end

  bytes = u8(0xB2)
  bytes += param_simple(layer)
  bytes += param_simple(nos)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
output_get_count(layer, nos, tacho) click to toggle source

Getting tacho count when used as sensor - values are in shared memory @param layer [PAR8] (in) Daisy chain layer number [0..3] @param nos [PAR8] (in) Output bit field [0x00..0x0F] @param tacho [PAR32] (out) Tacho pulses [-MAX .. +MAX]

# File lib/lignite/ev3_ops.rb, line 6705
def output_get_count(layer, nos, tacho)
  logger.debug do
    args = [layer, nos, tacho]
    "called output_get_count with #{args.inspect}"
  end

  bytes = u8(0xB3)
  bytes += param_simple(layer)
  bytes += param_simple(nos)
  bytes += param_simple(tacho)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
output_get_type(layer, no, type) click to toggle source

@param layer [PAR8] (in) Daisy chain layer number [0..3] @param no [PAR8] (in) Port number @param type [PAR8] (out)

# File lib/lignite/ev3_ops.rb, line 6325
def output_get_type(layer, no, type)
  logger.debug do
    args = [layer, no, type]
    "called output_get_type with #{args.inspect}"
  end

  bytes = u8(0xA0)
  bytes += param_simple(layer)
  bytes += param_simple(no)
  bytes += param_simple(type)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
output_polarity(layer, nos, pol) click to toggle source

Set polarity of the outputs @param layer [PAR8] (in) Daisy chain layer number [0..3] @param nos [PAR8] (in) Output bit field [0x00..0x0F] @param pol [PAR8] (in) Polarity [-1,0,1]

# File lib/lignite/ev3_ops.rb, line 6447
def output_polarity(layer, nos, pol)
  logger.debug do
    args = [layer, nos, pol]
    "called output_polarity with #{args.inspect}"
  end

  bytes = u8(0xA7)
  bytes += param_simple(layer)
  bytes += param_simple(nos)
  bytes += param_simple(pol)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
output_position(layer, nos, pos) click to toggle source

@param layer [PAR8] (in) Daisy chain layer number [0..3] @param nos [PAR8] (in) Output bit field [0x00..0x0F] @param pos [PAR32] (out)

# File lib/lignite/ev3_ops.rb, line 6519
def output_position(layer, nos, pos)
  logger.debug do
    args = [layer, nos, pos]
    "called output_position with #{args.inspect}"
  end

  bytes = u8(0xAB)
  bytes += param_simple(layer)
  bytes += param_simple(nos)
  bytes += param_simple(pos)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
output_power(layer, nos, power) click to toggle source

Set power of the outputs @param layer [PAR8] (in) Daisy chain layer number [0..3] @param nos [PAR8] (in) Output bit field [0x00..0x0F] @param power [PAR8] (in) Power [-100..100%]

# File lib/lignite/ev3_ops.rb, line 6395
def output_power(layer, nos, power)
  logger.debug do
    args = [layer, nos, power]
    "called output_power with #{args.inspect}"
  end

  bytes = u8(0xA4)
  bytes += param_simple(layer)
  bytes += param_simple(nos)
  bytes += param_simple(power)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
output_prg_stop() click to toggle source

Program stop

# File lib/lignite/ev3_ops.rb, line 6720
def output_prg_stop
  logger.debug do
    args = []
    "called output_prg_stop with #{args.inspect}"
  end

  bytes = u8(0xB4)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
output_read(layer, no, speed, tacho) click to toggle source

@param layer [PAR8] (in) Daisy chain layer number [0..3] @param no [PAR8] (in) NO - Output no [0..3] @param speed [PAR8] (out) Speed [-100..100%] @param tacho [PAR32] (out) Tacho pulses [-MAX .. +MAX]

# File lib/lignite/ev3_ops.rb, line 6466
def output_read(layer, no, speed, tacho)
  logger.debug do
    args = [layer, no, speed, tacho]
    "called output_read with #{args.inspect}"
  end

  bytes = u8(0xA8)
  bytes += param_simple(layer)
  bytes += param_simple(no)
  bytes += param_simple(speed)
  bytes += param_simple(tacho)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
output_ready(layer, nos) click to toggle source

Wait for output ready (wait for completion) @param layer [PAR8] (in) Daisy chain layer number [0..3] @param nos [PAR8] (in) Output bit field [0x00..0x0F]

# File lib/lignite/ev3_ops.rb, line 6502
def output_ready(layer, nos)
  logger.debug do
    args = [layer, nos]
    "called output_ready with #{args.inspect}"
  end

  bytes = u8(0xAA)
  bytes += param_simple(layer)
  bytes += param_simple(nos)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
output_reset(layer, nos) click to toggle source

Resets the Tacho counts @param layer [PAR8] (in) Daisy chain layer number [0..3] @param nos [PAR8] (in) Output bit field [0x00..0x0F]

# File lib/lignite/ev3_ops.rb, line 6360
def output_reset(layer, nos)
  logger.debug do
    args = [layer, nos]
    "called output_reset with #{args.inspect}"
  end

  bytes = u8(0xA2)
  bytes += param_simple(layer)
  bytes += param_simple(nos)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
output_set_type(layer, no, type) click to toggle source

Set output type @param layer [PAR8] (in) Daisy chain layer number [0..3] @param no [PAR8] (in) Output no [0..3] @param type [PAR8] (out) Device type id from typedata.rcf

# File lib/lignite/ev3_ops.rb, line 6343
def output_set_type(layer, no, type)
  logger.debug do
    args = [layer, no, type]
    "called output_set_type with #{args.inspect}"
  end

  bytes = u8(0xA1)
  bytes += param_simple(layer)
  bytes += param_simple(no)
  bytes += param_simple(type)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
output_speed(layer, nos, speed) click to toggle source

Set speed of the outputs @param layer [PAR8] (in) Daisy chain layer number [0..3] @param nos [PAR8] (in) Output bit field [0x00..0x0F] @param speed [PAR8] (in) Speed [-100..100%]

# File lib/lignite/ev3_ops.rb, line 6413
def output_speed(layer, nos, speed)
  logger.debug do
    args = [layer, nos, speed]
    "called output_speed with #{args.inspect}"
  end

  bytes = u8(0xA5)
  bytes += param_simple(layer)
  bytes += param_simple(nos)
  bytes += param_simple(speed)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
output_start(layer, nos) click to toggle source

Starts the outputs @param layer [PAR8] (in) Daisy chain layer number [0..3] @param nos [PAR8] (in) Output bit field [0x00..0x0F]

# File lib/lignite/ev3_ops.rb, line 6430
def output_start(layer, nos)
  logger.debug do
    args = [layer, nos]
    "called output_start with #{args.inspect}"
  end

  bytes = u8(0xA6)
  bytes += param_simple(layer)
  bytes += param_simple(nos)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
output_step_power(layer, nos, power, step1, step2, step3, brake) click to toggle source

Set Ramp up, constant and rampdown steps and power of the outputs @param layer [PAR8] (in) Daisy chain layer number [0..3] @param nos [PAR8] (in) Output bit field [0x00..0x0F] @param power [PAR8] (in) Power [-100..100%] @param step1 [PAR32] (in) Tacho pulses [0..MAX] @param step2 [PAR32] (in) Tacho pulses [0..MAX] @param step3 [PAR32] (in) Tacho pulses [0..MAX] @param brake [PAR8] (in) 0 = Coast, 1 = BRAKE

# File lib/lignite/ev3_ops.rb, line 6541
def output_step_power(layer, nos, power, step1, step2, step3, brake)
  logger.debug do
    args = [layer, nos, power, step1, step2, step3, brake]
    "called output_step_power with #{args.inspect}"
  end

  bytes = u8(0xAC)
  bytes += param_simple(layer)
  bytes += param_simple(nos)
  bytes += param_simple(power)
  bytes += param_simple(step1)
  bytes += param_simple(step2)
  bytes += param_simple(step3)
  bytes += param_simple(brake)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
output_step_speed(layer, nos, speed, step1, step2, step3, brake) click to toggle source

Set Ramp up, constant and rampdown steps and power of the outputs @param layer [PAR8] (in) Daisy chain layer number [0..3] @param nos [PAR8] (in) Output bit field [0x00..0x0F] @param speed [PAR8] (in) Speed [-100..100%] @param step1 [PAR32] (in) Tacho pulses [0..MAX] @param step2 [PAR32] (in) Tacho pulses [0..MAX] @param step3 [PAR32] (in) Tacho pulses [0..MAX] @param brake [PAR8] (in) 0 = Coast, 1 = BRAKE

# File lib/lignite/ev3_ops.rb, line 6593
def output_step_speed(layer, nos, speed, step1, step2, step3, brake)
  logger.debug do
    args = [layer, nos, speed, step1, step2, step3, brake]
    "called output_step_speed with #{args.inspect}"
  end

  bytes = u8(0xAE)
  bytes += param_simple(layer)
  bytes += param_simple(nos)
  bytes += param_simple(speed)
  bytes += param_simple(step1)
  bytes += param_simple(step2)
  bytes += param_simple(step3)
  bytes += param_simple(brake)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
output_step_sync(layer, nos, speed, turn, step, brake) click to toggle source

@param layer [PAR8] (in) Daisy chain layer number [0..3] @param nos [PAR8] (in) Output bit field [0x00..0x0F] @param speed [PAR8] (in) Speed [-100..100%] @param turn [PAR16] (in) Turn Ratio [-200..200] @param step [PAR32] (in) Tacho Pulses [0..MAX] @param brake [PAR8] (in) 0 = Coast, 1 = BRAKE

# File lib/lignite/ev3_ops.rb, line 6644
def output_step_sync(layer, nos, speed, turn, step, brake)
  logger.debug do
    args = [layer, nos, speed, turn, step, brake]
    "called output_step_sync with #{args.inspect}"
  end

  bytes = u8(0xB0)
  bytes += param_simple(layer)
  bytes += param_simple(nos)
  bytes += param_simple(speed)
  bytes += param_simple(turn)
  bytes += param_simple(step)
  bytes += param_simple(brake)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
output_stop(layer, nos, brake) click to toggle source

Stops the outputs @param layer [PAR8] (in) Daisy chain layer number [0..3] @param nos [PAR8] (in) Output bit field [0x00..0x0F] @param brake [PAR8] (in) 0 = Coast, 1 = BRAKE

# File lib/lignite/ev3_ops.rb, line 6377
def output_stop(layer, nos, brake)
  logger.debug do
    args = [layer, nos, brake]
    "called output_stop with #{args.inspect}"
  end

  bytes = u8(0xA3)
  bytes += param_simple(layer)
  bytes += param_simple(nos)
  bytes += param_simple(brake)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
output_test(layer, nos, busy) click to toggle source

Testing if output is not used @param layer [PAR8] (in) Daisy chain layer number [0..3] @param nos [PAR8] (in) Output bit field [0x00..0x0F] @param busy [PAR8] (out) Output busy flag (0 = ready, 1 = Busy)

# File lib/lignite/ev3_ops.rb, line 6485
def output_test(layer, nos, busy)
  logger.debug do
    args = [layer, nos, busy]
    "called output_test with #{args.inspect}"
  end

  bytes = u8(0xA9)
  bytes += param_simple(layer)
  bytes += param_simple(nos)
  bytes += param_simple(busy)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
output_time_power(layer, nos, power, time1, time2, time3, brake) click to toggle source

Set Ramp up, constant and rampdown steps and power of the outputs @param layer [PAR8] (in) Daisy chain layer number [0..3] @param nos [PAR8] (in) Output bit field [0x00..0x0F] @param power [PAR8] (in) Power [-100..100%] @param time1 [PAR32] (in) Time in Ms [0..MAX] @param time2 [PAR32] (in) Time in Ms [0..MAX] @param time3 [PAR32] (in) Time in Ms [0..MAX] @param brake [PAR8] (in) 0 = Coast, 1 = BRAKE

# File lib/lignite/ev3_ops.rb, line 6567
def output_time_power(layer, nos, power, time1, time2, time3, brake)
  logger.debug do
    args = [layer, nos, power, time1, time2, time3, brake]
    "called output_time_power with #{args.inspect}"
  end

  bytes = u8(0xAD)
  bytes += param_simple(layer)
  bytes += param_simple(nos)
  bytes += param_simple(power)
  bytes += param_simple(time1)
  bytes += param_simple(time2)
  bytes += param_simple(time3)
  bytes += param_simple(brake)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
output_time_speed(layer, nos, speed, time1, time2, time3, brake) click to toggle source

Set Ramp up, constant and rampdown steps and power of the outputs @param layer [PAR8] (in) Daisy chain layer number [0..3] @param nos [PAR8] (in) Output bit field [0x00..0x0F] @param speed [PAR8] (in) Speed [-100..100%] @param time1 [PAR32] (in) Time in Ms [0..MAX] @param time2 [PAR32] (in) Time in Ms [0..MAX] @param time3 [PAR32] (in) Time in Ms [0..MAX] @param brake [PAR8] (in) 0 = Coast, 1 = BRAKE

# File lib/lignite/ev3_ops.rb, line 6619
def output_time_speed(layer, nos, speed, time1, time2, time3, brake)
  logger.debug do
    args = [layer, nos, speed, time1, time2, time3, brake]
    "called output_time_speed with #{args.inspect}"
  end

  bytes = u8(0xAF)
  bytes += param_simple(layer)
  bytes += param_simple(nos)
  bytes += param_simple(speed)
  bytes += param_simple(time1)
  bytes += param_simple(time2)
  bytes += param_simple(time3)
  bytes += param_simple(brake)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
output_time_sync(layer, nos, speed, turn, time, brake) click to toggle source

@param layer [PAR8] (in) Daisy chain layer number [0..3] @param nos [PAR8] (in) Output bit field [0x00..0x0F] @param speed [PAR8] (in) Speed [-100..100%] @param turn [PAR16] (in) Turn Ratio [-200..200] @param time [PAR32] (in) Time in ms [0..MAX] @param brake [PAR8] (in) 0 = Coast, 1 = BRAKE

# File lib/lignite/ev3_ops.rb, line 6668
def output_time_sync(layer, nos, speed, turn, time, brake)
  logger.debug do
    args = [layer, nos, speed, turn, time, brake]
    "called output_time_sync with #{args.inspect}"
  end

  bytes = u8(0xB1)
  bytes += param_simple(layer)
  bytes += param_simple(nos)
  bytes += param_simple(speed)
  bytes += param_simple(turn)
  bytes += param_simple(time)
  bytes += param_simple(brake)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
port_cnv_input(portin, layer, portout) click to toggle source

Convert encoded port to Layer and Port @param portin [PAR32] (in) EncodedPortNumber @param layer [PAR8] (out) Layer @param portout [PAR8] (out) 0-index port for use with VM commands

# File lib/lignite/ev3_ops.rb, line 1753
def port_cnv_input(portin, layer, portout)
  logger.debug do
    args = [portin, layer, portout]
    "called port_cnv_input with #{args.inspect}"
  end

  bytes = u8(0x62)
  bytes += param_simple(portin)
  bytes += param_simple(layer)
  bytes += param_simple(portout)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
port_cnv_output(portin, layer, bitfield, inverted) click to toggle source

Convert encoded port to Layer and Bitfield @param portin [PAR32] (in) EncodedPortNumber @param layer [PAR8] (out) Layer @param bitfield [PAR8] (out) Bitfield @param inverted [PAR8] (out) yes if left/right motor are inverted (ie, C&A)

# File lib/lignite/ev3_ops.rb, line 1734
def port_cnv_output(portin, layer, bitfield, inverted)
  logger.debug do
    args = [portin, layer, bitfield, inverted]
    "called port_cnv_output with #{args.inspect}"
  end

  bytes = u8(0x61)
  bytes += param_simple(portin)
  bytes += param_simple(layer)
  bytes += param_simple(bitfield)
  bytes += param_simple(inverted)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
probe(prgid, objid, offset, size) click to toggle source

Display globals or object locals on terminal @param prgid [PAR16] (in) Program slot number @param objid [PAR16] (in) Object id (zero means globals) @param offset [PAR32] (in) Offset (start from) @param size [PAR32] (in) Size (length of dump) zero means all (max 1024)

# File lib/lignite/ev3_ops.rb, line 328
def probe(prgid, objid, offset, size)
  logger.debug do
    args = [prgid, objid, offset, size]
    "called probe with #{args.inspect}"
  end

  bytes = u8(0x0E)
  bytes += param_simple(prgid)
  bytes += param_simple(objid)
  bytes += param_simple(offset)
  bytes += param_simple(size)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
program_info(*args) click to toggle source
# File lib/lignite/ev3_ops.rb, line 314
def program_info(*args)
  logger.debug "called program_info with #{args.inspect}"
  cvalue = args.shift
  csym = MULTIPLEX_PROGRAM_INFO.fetch(cvalue)
  __send__("program_info_#{csym}", *args)
end
program_info_get_prgname(prgid, name) click to toggle source

@param prgid [PAR16] (in) Program slot number @param name [PAR8] (out) Program name

# File lib/lignite/ev3_ops.rb, line 290
def program_info_get_prgname(prgid, name)
  logger.debug do
    args = [prgid, name]
    "called program_info_get_prgname with #{args.inspect}"
  end

  bytes = u8(0x0C)
  bytes += param_simple(26)
  bytes += param_simple(prgid)
  bytes += param_simple(name)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
program_info_get_prgresult(prgid, data) click to toggle source

@param prgid [PAR16] (in) Program slot number @param data [PAR8] (out) Program result [OK, BUSY, FAIL]

# File lib/lignite/ev3_ops.rb, line 254
def program_info_get_prgresult(prgid, data)
  logger.debug do
    args = [prgid, data]
    "called program_info_get_prgresult with #{args.inspect}"
  end

  bytes = u8(0x0C)
  bytes += param_simple(24)
  bytes += param_simple(prgid)
  bytes += param_simple(data)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
program_info_get_speed(prgid, data) click to toggle source

@param prgid [PAR16] (in) Program slot number @param data [PAR32] (out) Program speed [instr/S]

# File lib/lignite/ev3_ops.rb, line 235
def program_info_get_speed(prgid, data)
  logger.debug do
    args = [prgid, data]
    "called program_info_get_speed with #{args.inspect}"
  end

  bytes = u8(0x0C)
  bytes += param_simple(23)
  bytes += param_simple(prgid)
  bytes += param_simple(data)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
program_info_get_status(prgid, data) click to toggle source

@param prgid [PAR16] (in) Program slot number @param data [PAR8] (out) Program status

# File lib/lignite/ev3_ops.rb, line 216
def program_info_get_status(prgid, data)
  logger.debug do
    args = [prgid, data]
    "called program_info_get_status with #{args.inspect}"
  end

  bytes = u8(0x0C)
  bytes += param_simple(22)
  bytes += param_simple(prgid)
  bytes += param_simple(data)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
program_info_obj_start(prgid, objid) click to toggle source

@param prgid [PAR16] (in) Program slot number @param objid [PAR16] (in) Object id

# File lib/lignite/ev3_ops.rb, line 197
def program_info_obj_start(prgid, objid)
  logger.debug do
    args = [prgid, objid]
    "called program_info_obj_start with #{args.inspect}"
  end

  bytes = u8(0x0C)
  bytes += param_simple(4)
  bytes += param_simple(prgid)
  bytes += param_simple(objid)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
program_info_obj_stop(prgid, objid) click to toggle source

@param prgid [PAR16] (in) Program slot number @param objid [PAR16] (in) Object id

# File lib/lignite/ev3_ops.rb, line 178
def program_info_obj_stop(prgid, objid)
  logger.debug do
    args = [prgid, objid]
    "called program_info_obj_stop with #{args.inspect}"
  end

  bytes = u8(0x0C)
  bytes += param_simple(0)
  bytes += param_simple(prgid)
  bytes += param_simple(objid)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
program_info_set_instr(prgid) click to toggle source

Set number of instructions before VMThread change @param prgid [PAR16] (in) Program slot number

# File lib/lignite/ev3_ops.rb, line 272
def program_info_set_instr(prgid)
  logger.debug do
    args = [prgid]
    "called program_info_set_instr with #{args.inspect}"
  end

  bytes = u8(0x0C)
  bytes += param_simple(25)
  bytes += param_simple(prgid)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
program_start(prgid, size, ip, debug) click to toggle source

Start program id slot @param prgid [PAR16] (in) Program id @param size [PAR32] (in) Size of image @param ip [PAR32] (in) Address of image (value from opFILE(LOAD_IMAGE,..) ) @param debug [PAR8] (in) Debug mode (0=normal, 1=debug, 2=don't execute)

# File lib/lignite/ev3_ops.rb, line 49
def program_start(prgid, size, ip, debug)
  logger.debug do
    args = [prgid, size, ip, debug]
    "called program_start with #{args.inspect}"
  end

  bytes = u8(0x03)
  bytes += param_simple(prgid)
  bytes += param_simple(size)
  bytes += param_simple(ip)
  bytes += param_simple(debug)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
program_stop(prgid) click to toggle source

Stops specific program id slot @param prgid [PAR16] (in) Program id (GUI_SLOT = all, CURRENT_SLOT = current)

# File lib/lignite/ev3_ops.rb, line 32
def program_stop(prgid)
  logger.debug do
    args = [prgid]
    "called program_stop with #{args.inspect}"
  end

  bytes = u8(0x02)
  bytes += param_simple(prgid)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
random(min, max, value) click to toggle source

Get random value @param min [PAR16] (in) Minimum value @param max [PAR16] (in) Maximum value @param value [PAR16] (out) value

# File lib/lignite/ev3_ops.rb, line 5311
def random(min, max, value)
  logger.debug do
    args = [min, max, value]
    "called random with #{args.inspect}"
  end

  bytes = u8(0x8E)
  bytes += param_simple(min)
  bytes += param_simple(max)
  bytes += param_simple(value)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
read16(source, index, destination) click to toggle source

Read 16 bit value from SOURCE to DESTINATION @param source [PAR16] (in) First value in array of values @param index [PAR8] (in) Index to array member to read @param destination [PAR16] (out) Variable to receive read value

# File lib/lignite/ev3_ops.rb, line 8074
def read16(source, index, destination)
  logger.debug do
    args = [source, index, destination]
    "called read16 with #{args.inspect}"
  end

  bytes = u8(0xC9)
  bytes += param_simple(source)
  bytes += param_simple(index)
  bytes += param_simple(destination)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
read32(source, index, destination) click to toggle source

Read 32 bit value from SOURCE to DESTINATION @param source [PAR32] (in) First value in array of values @param index [PAR8] (in) Index to array member to read @param destination [PAR32] (out) Variable to receive read value

# File lib/lignite/ev3_ops.rb, line 8092
def read32(source, index, destination)
  logger.debug do
    args = [source, index, destination]
    "called read32 with #{args.inspect}"
  end

  bytes = u8(0xCA)
  bytes += param_simple(source)
  bytes += param_simple(index)
  bytes += param_simple(destination)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
read8(source, index, destination) click to toggle source

Read 8 bit value from SOURCE to DESTINATION @param source [PAR8] (in) First value in array of values @param index [PAR8] (in) Index to array member to read @param destination [PAR8] (out) Variable to receive read value

# File lib/lignite/ev3_ops.rb, line 8056
def read8(source, index, destination)
  logger.debug do
    args = [source, index, destination]
    "called read8 with #{args.inspect}"
  end

  bytes = u8(0xC8)
  bytes += param_simple(source)
  bytes += param_simple(index)
  bytes += param_simple(destination)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
readf(source, index, destination) click to toggle source

Read floating point value from SOURCE to DESTINATION @param source [PARF] (in) First value in array of values @param index [PAR8] (in) Index to array member to read @param destination [PARF] (out) Variable to receive read value

# File lib/lignite/ev3_ops.rb, line 8110
def readf(source, index, destination)
  logger.debug do
    args = [source, index, destination]
    "called readf with #{args.inspect}"
  end

  bytes = u8(0xCB)
  bytes += param_simple(source)
  bytes += param_simple(index)
  bytes += param_simple(destination)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
return() click to toggle source

Return from byte code subroutine

# File lib/lignite/ev3_ops.rb, line 121
def return
  logger.debug do
    args = []
    "called return with #{args.inspect}"
  end

  bytes = u8(0x08)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
rl16(source1, source2, destination) click to toggle source

Rotate left 16 bit value DESTINATION = SOURCE1 << SOURCE2 @param source1 [PAR16] (in) @param source2 [PAR16] (in) @param destination [PAR16] (out)

# File lib/lignite/ev3_ops.rb, line 833
def rl16(source1, source2, destination)
  logger.debug do
    args = [source1, source2, destination]
    "called rl16 with #{args.inspect}"
  end

  bytes = u8(0x2D)
  bytes += param_simple(source1)
  bytes += param_simple(source2)
  bytes += param_simple(destination)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
rl32(source1, source2, destination) click to toggle source

Rotate left 32 bit value DESTINATION = SOURCE1 << SOURCE2 @param source1 [PAR32] (in) @param source2 [PAR32] (in) @param destination [PAR32] (out)

# File lib/lignite/ev3_ops.rb, line 851
def rl32(source1, source2, destination)
  logger.debug do
    args = [source1, source2, destination]
    "called rl32 with #{args.inspect}"
  end

  bytes = u8(0x2E)
  bytes += param_simple(source1)
  bytes += param_simple(source2)
  bytes += param_simple(destination)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
rl8(source1, source2, destination) click to toggle source

Rotate left 8 bit value DESTINATION = SOURCE1 << SOURCE2 @param source1 [PAR8] (in) @param source2 [PAR8] (in) @param destination [PAR8] (out)

# File lib/lignite/ev3_ops.rb, line 815
def rl8(source1, source2, destination)
  logger.debug do
    args = [source1, source2, destination]
    "called rl8 with #{args.inspect}"
  end

  bytes = u8(0x2C)
  bytes += param_simple(source1)
  bytes += param_simple(source2)
  bytes += param_simple(destination)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
select16(flag, source1, source2, result) click to toggle source

If FLAG is set move SOURCE1 to RESULT else move SOURCE2 to RESULT @param flag [PAR8] (in) @param source1 [PAR16] (in) @param source2 [PAR16] (in) @param result [PAR16] (out)

# File lib/lignite/ev3_ops.rb, line 1658
def select16(flag, source1, source2, result)
  logger.debug do
    args = [flag, source1, source2, result]
    "called select16 with #{args.inspect}"
  end

  bytes = u8(0x5D)
  bytes += param_simple(flag)
  bytes += param_simple(source1)
  bytes += param_simple(source2)
  bytes += param_simple(result)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
select32(flag, source1, source2, result) click to toggle source

If FLAG is set move SOURCE1 to RESULT else move SOURCE2 to RESULT @param flag [PAR8] (in) @param source1 [PAR32] (in) @param source2 [PAR32] (in) @param result [PAR32] (out)

# File lib/lignite/ev3_ops.rb, line 1678
def select32(flag, source1, source2, result)
  logger.debug do
    args = [flag, source1, source2, result]
    "called select32 with #{args.inspect}"
  end

  bytes = u8(0x5E)
  bytes += param_simple(flag)
  bytes += param_simple(source1)
  bytes += param_simple(source2)
  bytes += param_simple(result)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
select8(flag, source1, source2, result) click to toggle source

If FLAG is set move SOURCE1 to RESULT else move SOURCE2 to RESULT @param flag [PAR8] (in) @param source1 [PAR8] (in) @param source2 [PAR8] (in) @param result [PAR8] (out)

# File lib/lignite/ev3_ops.rb, line 1638
def select8(flag, source1, source2, result)
  logger.debug do
    args = [flag, source1, source2, result]
    "called select8 with #{args.inspect}"
  end

  bytes = u8(0x5C)
  bytes += param_simple(flag)
  bytes += param_simple(source1)
  bytes += param_simple(source2)
  bytes += param_simple(result)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
selectf(flag, source1, source2, result) click to toggle source

If FLAG is set move SOURCE1 to RESULT else move SOURCE2 to RESULT @param flag [PAR8] (in) @param source1 [PARF] (in) @param source2 [PARF] (in) @param result [PARF] (out)

# File lib/lignite/ev3_ops.rb, line 1698
def selectf(flag, source1, source2, result)
  logger.debug do
    args = [flag, source1, source2, result]
    "called selectf with #{args.inspect}"
  end

  bytes = u8(0x5F)
  bytes += param_simple(flag)
  bytes += param_simple(source1)
  bytes += param_simple(source2)
  bytes += param_simple(result)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
sleep() click to toggle source

Breaks execution of current VMTHREAD

# File lib/lignite/ev3_ops.rb, line 161
def sleep
  logger.debug do
    args = []
    "called sleep with #{args.inspect}"
  end

  bytes = u8(0x0B)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
sound(*args) click to toggle source
# File lib/lignite/ev3_ops.rb, line 5489
def sound(*args)
  logger.debug "called sound with #{args.inspect}"
  cvalue = args.shift
  csym = MULTIPLEX_SOUND.fetch(cvalue)
  __send__("sound_#{csym}", *args)
end
sound_break() click to toggle source
# File lib/lignite/ev3_ops.rb, line 5425
def sound_break
  logger.debug do
    args = []
    "called sound_break with #{args.inspect}"
  end

  bytes = u8(0x94)
  bytes += param_simple(0)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
sound_ready() click to toggle source

Wait for sound ready (wait until sound finished)

# File lib/lignite/ev3_ops.rb, line 5511
def sound_ready
  logger.debug do
    args = []
    "called sound_ready with #{args.inspect}"
  end

  bytes = u8(0x96)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
sound_service() click to toggle source
# File lib/lignite/ev3_ops.rb, line 5469
def sound_service
  logger.debug do
    args = []
    "called sound_service with #{args.inspect}"
  end

  bytes = u8(0x94)
  bytes += param_simple(4)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
sound_test(busy) click to toggle source

Test if sound busy (playing file or tone @param busy [PAR8] (out) Sound busy flag (0 = ready, 1 = busy)

# File lib/lignite/ev3_ops.rb, line 5498
def sound_test(busy)
  logger.debug do
    args = [busy]
    "called sound_test with #{args.inspect}"
  end

  bytes = u8(0x95)
  bytes += param_simple(busy)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
sound_tone(volume, frequency, duration) click to toggle source

@param volume [PAR8] (in) Volume [0..100] @param frequency [PAR16] (in) Frequency [Hz] @param duration [PAR16] (in) Duration [mS]

# File lib/lignite/ev3_ops.rb, line 5443
def sound_tone(volume, frequency, duration)
  logger.debug do
    args = [volume, frequency, duration]
    "called sound_tone with #{args.inspect}"
  end

  bytes = u8(0x94)
  bytes += param_simple(1)
  bytes += param_simple(volume)
  bytes += param_simple(frequency)
  bytes += param_simple(duration)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
strings(*args) click to toggle source
# File lib/lignite/ev3_ops.rb, line 2601
def strings(*args)
  logger.debug "called strings with #{args.inspect}"
  cvalue = args.shift
  csym = MULTIPLEX_STRINGS.fetch(cvalue)
  __send__("strings_#{csym}", *args)
end
strings_add(source1, source2, destination) click to toggle source

Add two strings (SOURCE1 + SOURCE2 -> DESTINATION) @param source1 [PAR8] (in) String variable or handle to string @param source2 [PAR8] (in) String variable or handle to string @param destination [PAR8] (out) String variable or handle to string

# File lib/lignite/ev3_ops.rb, line 2382
def strings_add(source1, source2, destination)
  logger.debug do
    args = [source1, source2, destination]
    "called strings_add with #{args.inspect}"
  end

  bytes = u8(0x7D)
  bytes += param_simple(2)
  bytes += param_simple(source1)
  bytes += param_simple(source2)
  bytes += param_simple(destination)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
strings_compare(source1, source2, result) click to toggle source

Compare two strings @param source1 [PAR8] (in) String variable or handle to string @param source2 [PAR8] (in) String variable or handle to string @param result [PAR8] (out) Result (0 = not equal, 1 = equal)

# File lib/lignite/ev3_ops.rb, line 2403
def strings_compare(source1, source2, result)
  logger.debug do
    args = [source1, source2, result]
    "called strings_compare with #{args.inspect}"
  end

  bytes = u8(0x7D)
  bytes += param_simple(3)
  bytes += param_simple(source1)
  bytes += param_simple(source2)
  bytes += param_simple(result)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
strings_duplicate(source1, destination) click to toggle source

Duplicate a string (SOURCE1 -> DESTINATION) @param source1 [PAR8] (in) String variable or handle to string @param destination [PAR8] (out) String variable or handle to string

# File lib/lignite/ev3_ops.rb, line 2423
def strings_duplicate(source1, destination)
  logger.debug do
    args = [source1, destination]
    "called strings_duplicate with #{args.inspect}"
  end

  bytes = u8(0x7D)
  bytes += param_simple(5)
  bytes += param_simple(source1)
  bytes += param_simple(destination)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
strings_get_size(source1, size) click to toggle source

Get size of string (not including zero termination) @param source1 [PAR8] (in) String variable or handle to string @param size [PAR16] (out) Size

# File lib/lignite/ev3_ops.rb, line 2362
def strings_get_size(source1, size)
  logger.debug do
    args = [source1, size]
    "called strings_get_size with #{args.inspect}"
  end

  bytes = u8(0x7D)
  bytes += param_simple(1)
  bytes += param_simple(source1)
  bytes += param_simple(size)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
strings_number_formatted(value, format, size, destination) click to toggle source

Convert integer number to a formatted string @param value [PAR32] (in) Number to write @param format [PAR8] (in) Format string variable or handle to string @param size [PAR8] (in) Total size of destination string @param destination [PAR8] (out) String variable or handle to string

# File lib/lignite/ev3_ops.rb, line 2571
def strings_number_formatted(value, format, size, destination)
  logger.debug do
    args = [value, format, size, destination]
    "called strings_number_formatted with #{args.inspect}"
  end

  bytes = u8(0x7D)
  bytes += param_simple(12)
  bytes += param_simple(value)
  bytes += param_simple(format)
  bytes += param_simple(size)
  bytes += param_simple(destination)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
strings_number_to_string(value, figures, destination) click to toggle source

Convert integer value to a string @param value [PAR16] (in) Value to write @param figures [PAR8] (in) Total number of figures @param destination [PAR8] (out) String variable or handle to string

# File lib/lignite/ev3_ops.rb, line 2505
def strings_number_to_string(value, figures, destination)
  logger.debug do
    args = [value, figures, destination]
    "called strings_number_to_string with #{args.inspect}"
  end

  bytes = u8(0x7D)
  bytes += param_simple(9)
  bytes += param_simple(value)
  bytes += param_simple(figures)
  bytes += param_simple(destination)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
strings_string_to_value(source1, destination) click to toggle source

@param source1 [PAR8] (in) String variable or handle to string @param destination [PARF] (out) Value

# File lib/lignite/ev3_ops.rb, line 2466
def strings_string_to_value(source1, destination)
  logger.debug do
    args = [source1, destination]
    "called strings_string_to_value with #{args.inspect}"
  end

  bytes = u8(0x7D)
  bytes += param_simple(7)
  bytes += param_simple(source1)
  bytes += param_simple(destination)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
strings_strip(source1, destination) click to toggle source

Strip a string for spaces (SOURCE1 -> DESTINATION) @param source1 [PAR8] (in) String variable or handle to string @param destination [PAR8] (out) String variable or handle to string

# File lib/lignite/ev3_ops.rb, line 2485
def strings_strip(source1, destination)
  logger.debug do
    args = [source1, destination]
    "called strings_strip with #{args.inspect}"
  end

  bytes = u8(0x7D)
  bytes += param_simple(8)
  bytes += param_simple(source1)
  bytes += param_simple(destination)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
strings_sub(source1, source2, destination) click to toggle source

Return DESTINATION: a substring from SOURCE1 that starts were SOURCE2 ends @param source1 [PAR8] (in) String variable or handle to string @param source2 [PAR8] (in) String variable or handle to string @param destination [PAR8] (out) String variable or handle to string

# File lib/lignite/ev3_ops.rb, line 2526
def strings_sub(source1, source2, destination)
  logger.debug do
    args = [source1, source2, destination]
    "called strings_sub with #{args.inspect}"
  end

  bytes = u8(0x7D)
  bytes += param_simple(10)
  bytes += param_simple(source1)
  bytes += param_simple(source2)
  bytes += param_simple(destination)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
strings_value_formatted(value, format, size, destination) click to toggle source

Convert floating point value to a formatted string @param value [PARF] (in) Value to write @param format [PAR8] (in) Format string variable or handle to string @param size [PAR8] (in) Total size of destination string @param destination [PAR8] (out) String variable or handle to string

# File lib/lignite/ev3_ops.rb, line 2548
def strings_value_formatted(value, format, size, destination)
  logger.debug do
    args = [value, format, size, destination]
    "called strings_value_formatted with #{args.inspect}"
  end

  bytes = u8(0x7D)
  bytes += param_simple(11)
  bytes += param_simple(value)
  bytes += param_simple(format)
  bytes += param_simple(size)
  bytes += param_simple(destination)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
strings_value_to_string(value, figures, decimals, destination) click to toggle source

@param decimals [PAR8] (in) Number of decimals @param destination [PAR8] (out) String variable or handle to string

# File lib/lignite/ev3_ops.rb, line 2445
def strings_value_to_string(value, figures, decimals, destination)
  logger.debug do
    args = [value, figures, decimals, destination]
    "called strings_value_to_string with #{args.inspect}"
  end

  bytes = u8(0x7D)
  bytes += param_simple(6)
  bytes += param_simple(value)
  bytes += param_simple(figures)
  bytes += param_simple(decimals)
  bytes += param_simple(destination)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
sub16(source1, source2, destination) click to toggle source

Subtract two 16 bit values DESTINATION = SOURCE1 - SOURCE2 @param source1 [PAR16] (in) @param source2 [PAR16] (in) @param destination [PAR16] (out)

# File lib/lignite/ev3_ops.rb, line 455
def sub16(source1, source2, destination)
  logger.debug do
    args = [source1, source2, destination]
    "called sub16 with #{args.inspect}"
  end

  bytes = u8(0x15)
  bytes += param_simple(source1)
  bytes += param_simple(source2)
  bytes += param_simple(destination)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
sub32(source1, source2, destination) click to toggle source

Subtract two 32 bit values DESTINATION = SOURCE1 - SOURCE2 @param source1 [PAR32] (in) @param source2 [PAR32] (in) @param destination [PAR32] (out)

# File lib/lignite/ev3_ops.rb, line 473
def sub32(source1, source2, destination)
  logger.debug do
    args = [source1, source2, destination]
    "called sub32 with #{args.inspect}"
  end

  bytes = u8(0x16)
  bytes += param_simple(source1)
  bytes += param_simple(source2)
  bytes += param_simple(destination)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
sub8(source1, source2, destination) click to toggle source

Subtract two 8 bit values DESTINATION = SOURCE1 - SOURCE2 @param source1 [PAR8] (in) @param source2 [PAR8] (in) @param destination [PAR8] (out)

# File lib/lignite/ev3_ops.rb, line 437
def sub8(source1, source2, destination)
  logger.debug do
    args = [source1, source2, destination]
    "called sub8 with #{args.inspect}"
  end

  bytes = u8(0x14)
  bytes += param_simple(source1)
  bytes += param_simple(source2)
  bytes += param_simple(destination)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
subf(source1, source2, destination) click to toggle source

Subtract two floating point values DESTINATION = SOURCE1 - SOURCE2 @param source1 [PARF] (in) @param source2 [PARF] (in) @param destination [PARF] (out)

# File lib/lignite/ev3_ops.rb, line 491
def subf(source1, source2, destination)
  logger.debug do
    args = [source1, source2, destination]
    "called subf with #{args.inspect}"
  end

  bytes = u8(0x17)
  bytes += param_simple(source1)
  bytes += param_simple(source2)
  bytes += param_simple(destination)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
system(command, status) click to toggle source

Executes a system command @param command [PAR8] (in) Command string (HND) @param status [PAR32] (out) Return status of the command

# File lib/lignite/ev3_ops.rb, line 1716
def system(command, status)
  logger.debug do
    args = [command, status]
    "called system with #{args.inspect}"
  end

  bytes = u8(0x60)
  bytes += param_simple(command)
  bytes += param_simple(status)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
timer_read(time) click to toggle source

Read free running timer [mS] @param time [PAR32] (out) Value

# File lib/lignite/ev3_ops.rb, line 4786
def timer_read(time)
  logger.debug do
    args = [time]
    "called timer_read with #{args.inspect}"
  end

  bytes = u8(0x87)
  bytes += param_simple(time)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
timer_read_us(time) click to toggle source

Read free running timer [uS] @param time [PAR32] (out) Value

# File lib/lignite/ev3_ops.rb, line 5327
def timer_read_us(time)
  logger.debug do
    args = [time]
    "called timer_read_us with #{args.inspect}"
  end

  bytes = u8(0x8F)
  bytes += param_simple(time)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
timer_ready(timer) click to toggle source

Wait for timer ready (wait for timeout) @param timer [PAR32] (in) Variable used for timing

# File lib/lignite/ev3_ops.rb, line 4772
def timer_ready(timer)
  logger.debug do
    args = [timer]
    "called timer_ready with #{args.inspect}"
  end

  bytes = u8(0x86)
  bytes += param_simple(timer)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
timer_wait(time, timer) click to toggle source

Setup timer to wait TIME mS @param time [PAR32] (in) Time to wait [mS] @param timer [PAR32] (in) Variable used for timing

# File lib/lignite/ev3_ops.rb, line 4757
def timer_wait(time, timer)
  logger.debug do
    args = [time, timer]
    "called timer_wait with #{args.inspect}"
  end

  bytes = u8(0x85)
  bytes += param_simple(time)
  bytes += param_simple(timer)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
tst(*args) click to toggle source
# File lib/lignite/ev3_ops.rb, line 9727
def tst(*args)
  logger.debug "called tst with #{args.inspect}"
  cvalue = args.shift
  csym = MULTIPLEX_TST.fetch(cvalue)
  __send__("tst_#{csym}", *args)
end
tst_tst_accu_switch(active) click to toggle source

Read accu switch state @param active [PAR8] (out) State [0..1]

# File lib/lignite/ev3_ops.rb, line 9633
def tst_tst_accu_switch(active)
  logger.debug do
    args = [active]
    "called tst_tst_accu_switch with #{args.inspect}"
  end

  bytes = u8(0xFF)
  bytes += param_simple(19)
  bytes += param_simple(active)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
tst_tst_boot_mode2() click to toggle source

Turn on mode2

# File lib/lignite/ev3_ops.rb, line 9649
def tst_tst_boot_mode2
  logger.debug do
    args = []
    "called tst_tst_boot_mode2 with #{args.inspect}"
  end

  bytes = u8(0xFF)
  bytes += param_simple(20)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
tst_tst_close() click to toggle source

Disables test byte codes

# File lib/lignite/ev3_ops.rb, line 9481
def tst_tst_close
  logger.debug do
    args = []
    "called tst_tst_close with #{args.inspect}"
  end

  bytes = u8(0xFF)
  bytes += param_simple(11)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
tst_tst_close_mode2() click to toggle source

Closes mode2

# File lib/lignite/ev3_ops.rb, line 9681
def tst_tst_close_mode2
  logger.debug do
    args = []
    "called tst_tst_close_mode2 with #{args.inspect}"
  end

  bytes = u8(0xFF)
  bytes += param_simple(22)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
tst_tst_disable_uart() click to toggle source

Disable all UARTs

# File lib/lignite/ev3_ops.rb, line 9617
def tst_tst_disable_uart
  logger.debug do
    args = []
    "called tst_tst_disable_uart with #{args.inspect}"
  end

  bytes = u8(0xFF)
  bytes += param_simple(18)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
tst_tst_enable_uart(bitrate) click to toggle source

Enable all UARTs @param bitrate [PAR32] (in) Bit rate [2400..115200 b/S]

# File lib/lignite/ev3_ops.rb, line 9601
def tst_tst_enable_uart(bitrate)
  logger.debug do
    args = [bitrate]
    "called tst_tst_enable_uart with #{args.inspect}"
  end

  bytes = u8(0xFF)
  bytes += param_simple(17)
  bytes += param_simple(bitrate)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
tst_tst_open() click to toggle source

Enables test byte codes for 10 seconds

# File lib/lignite/ev3_ops.rb, line 9466
def tst_tst_open
  logger.debug do
    args = []
    "called tst_tst_open with #{args.inspect}"
  end

  bytes = u8(0xFF)
  bytes += param_simple(10)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
tst_tst_poll_mode2(status) click to toggle source

Read mode2 status @param status [PAR8] (out) State [0..2]

# File lib/lignite/ev3_ops.rb, line 9665
def tst_tst_poll_mode2(status)
  logger.debug do
    args = [status]
    "called tst_tst_poll_mode2 with #{args.inspect}"
  end

  bytes = u8(0xFF)
  bytes += param_simple(21)
  bytes += param_simple(status)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
tst_tst_ram_check(status) click to toggle source

Read RAM test status status @param status [PAR8] (out) State [0,1] 0 = FAIL, 1 = SUCCESS

# File lib/lignite/ev3_ops.rb, line 9697
def tst_tst_ram_check(status)
  logger.debug do
    args = [status]
    "called tst_tst_ram_check with #{args.inspect}"
  end

  bytes = u8(0xFF)
  bytes += param_simple(23)
  bytes += param_simple(status)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
tst_tst_read_adc(index, value) click to toggle source

Read raw count from ADC @param index [PAR8] (in) Input mapped index (see remarks) [0..15] @param value [PAR16] (out) Raw count [0..4095]

# File lib/lignite/ev3_ops.rb, line 9541
def tst_tst_read_adc(index, value)
  logger.debug do
    args = [index, value]
    "called tst_tst_read_adc with #{args.inspect}"
  end

  bytes = u8(0xFF)
  bytes += param_simple(14)
  bytes += param_simple(index)
  bytes += param_simple(value)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
tst_tst_read_pins(port, length, string) click to toggle source

Read connector pin status @param port [PAR8] (in) Input connector [0..3], output connector [16..19] @param length [PAR8] (in) Number of pins in returned string @param string [PAR8] (out) String variable start index ('0' = low, '1' = high)

# File lib/lignite/ev3_ops.rb, line 9499
def tst_tst_read_pins(port, length, string)
  logger.debug do
    args = [port, length, string]
    "called tst_tst_read_pins with #{args.inspect}"
  end

  bytes = u8(0xFF)
  bytes += param_simple(12)
  bytes += param_simple(port)
  bytes += param_simple(length)
  bytes += param_simple(string)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
tst_tst_read_uart(port, length, string) click to toggle source

Read data from port through UART @param port [PAR8] (in) Input connector [0..3] @param length [PAR8] (in) Length of string to write [0..63] @param string [PAR8] (out) String of data

# File lib/lignite/ev3_ops.rb, line 9582
def tst_tst_read_uart(port, length, string)
  logger.debug do
    args = [port, length, string]
    "called tst_tst_read_uart with #{args.inspect}"
  end

  bytes = u8(0xFF)
  bytes += param_simple(16)
  bytes += param_simple(port)
  bytes += param_simple(length)
  bytes += param_simple(string)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
tst_tst_write_pins(port, length, string) click to toggle source

Write to connector pin @param port [PAR8] (in) Input connector [0..3], output connector [16..19] @param length [PAR8] (in) Number of pins in returned string @param string [PAR8] (in) String variable start index ('0' = set low, '1' = set high, 'X' = tristate, '-' = don't touch)

# File lib/lignite/ev3_ops.rb, line 9521
def tst_tst_write_pins(port, length, string)
  logger.debug do
    args = [port, length, string]
    "called tst_tst_write_pins with #{args.inspect}"
  end

  bytes = u8(0xFF)
  bytes += param_simple(13)
  bytes += param_simple(port)
  bytes += param_simple(length)
  bytes += param_simple(string)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
tst_tst_write_uart(port, length, string) click to toggle source

Write data to port through UART @param port [PAR8] (in) Input connector [0..3] @param length [PAR8] (in) Length of string to write [0..63] @param string [PAR8] (in) String of data

# File lib/lignite/ev3_ops.rb, line 9561
def tst_tst_write_uart(port, length, string)
  logger.debug do
    args = [port, length, string]
    "called tst_tst_write_uart with #{args.inspect}"
  end

  bytes = u8(0xFF)
  bytes += param_simple(15)
  bytes += param_simple(port)
  bytes += param_simple(length)
  bytes += param_simple(string)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
ui_button(*args) click to toggle source
# File lib/lignite/ev3_ops.rb, line 3881
def ui_button(*args)
  logger.debug "called ui_button with #{args.inspect}"
  cvalue = args.shift
  csym = MULTIPLEX_UI_BUTTON.fetch(cvalue)
  __send__("ui_button_#{csym}", *args)
end
ui_button_flush() click to toggle source
# File lib/lignite/ev3_ops.rb, line 3637
def ui_button_flush
  logger.debug do
    args = []
    "called ui_button_flush with #{args.inspect}"
  end

  bytes = u8(0x83)
  bytes += param_simple(4)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
ui_button_get_back_block(blocked) click to toggle source

@param blocked [PAR8] (out) Get UI back button blocked flag (0 = not blocked, 1 = blocked)

# File lib/lignite/ev3_ops.rb, line 3757
def ui_button_get_back_block(blocked)
  logger.debug do
    args = [blocked]
    "called ui_button_get_back_block with #{args.inspect}"
  end

  bytes = u8(0x83)
  bytes += param_simple(11)
  bytes += param_simple(blocked)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
ui_button_get_bumbed(button, state) click to toggle source

@param button [PAR8] (in) @param state [PAR8] (out) Button has been pressed (0 = no, 1 = yes)

# File lib/lignite/ev3_ops.rb, line 3813
def ui_button_get_bumbed(button, state)
  logger.debug do
    args = [button, state]
    "called ui_button_get_bumbed with #{args.inspect}"
  end

  bytes = u8(0x83)
  bytes += param_simple(14)
  bytes += param_simple(button)
  bytes += param_simple(state)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
ui_button_get_bumped(button, state) click to toggle source

@param button [PAR8] (in) @param state [PAR8] (out) Button has been pressed (0 = no, 1 = yes)

# File lib/lignite/ev3_ops.rb, line 3832
def ui_button_get_bumped(button, state)
  logger.debug do
    args = [button, state]
    "called ui_button_get_bumped with #{args.inspect}"
  end

  bytes = u8(0x83)
  bytes += param_simple(14)
  bytes += param_simple(button)
  bytes += param_simple(state)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
ui_button_get_click(click) click to toggle source

Get and clear click sound request (internal use only) @param click [PAR8] (out) Click sound request (0 = no, 1 = yes)

# File lib/lignite/ev3_ops.rb, line 3850
def ui_button_get_click(click)
  logger.debug do
    args = [click]
    "called ui_button_get_click with #{args.inspect}"
  end

  bytes = u8(0x83)
  bytes += param_simple(15)
  bytes += param_simple(click)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
ui_button_get_horz(value) click to toggle source

@param value [PAR16] (out) Horizontal arrows data (-1 = left, +1 = right, 0 = not pressed)

# File lib/lignite/ev3_ops.rb, line 3687
def ui_button_get_horz(value)
  logger.debug do
    args = [value]
    "called ui_button_get_horz with #{args.inspect}"
  end

  bytes = u8(0x83)
  bytes += param_simple(7)
  bytes += param_simple(value)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
ui_button_get_vert(value) click to toggle source

@param value [PAR16] (out) Vertical arrows data (-1 = up, +1 = down, 0 = not pressed)

# File lib/lignite/ev3_ops.rb, line 3704
def ui_button_get_vert(value)
  logger.debug do
    args = [value]
    "called ui_button_get_vert with #{args.inspect}"
  end

  bytes = u8(0x83)
  bytes += param_simple(8)
  bytes += param_simple(value)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
ui_button_longpress(button, state) click to toggle source

@param button [PAR8] (in) @param state [PAR8] (out) Button has been pressed (0 = no, 1 = yes)

# File lib/lignite/ev3_ops.rb, line 3605
def ui_button_longpress(button, state)
  logger.debug do
    args = [button, state]
    "called ui_button_longpress with #{args.inspect}"
  end

  bytes = u8(0x83)
  bytes += param_simple(2)
  bytes += param_simple(button)
  bytes += param_simple(state)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
ui_button_press(button) click to toggle source

@param button [PAR8] (in)

# File lib/lignite/ev3_ops.rb, line 3653
def ui_button_press(button)
  logger.debug do
    args = [button]
    "called ui_button_press with #{args.inspect}"
  end

  bytes = u8(0x83)
  bytes += param_simple(5)
  bytes += param_simple(button)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
ui_button_pressed(button, state) click to toggle source

@param button [PAR8] (in) @param state [PAR8] (out) Button is pressed (0 = no, 1 = yes)

# File lib/lignite/ev3_ops.rb, line 3722
def ui_button_pressed(button, state)
  logger.debug do
    args = [button, state]
    "called ui_button_pressed with #{args.inspect}"
  end

  bytes = u8(0x83)
  bytes += param_simple(9)
  bytes += param_simple(button)
  bytes += param_simple(state)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
ui_button_release(button) click to toggle source

@param button [PAR8] (in)

# File lib/lignite/ev3_ops.rb, line 3670
def ui_button_release(button)
  logger.debug do
    args = [button]
    "called ui_button_release with #{args.inspect}"
  end

  bytes = u8(0x83)
  bytes += param_simple(6)
  bytes += param_simple(button)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
ui_button_set_back_block(blocked) click to toggle source

@param blocked [PAR8] (in) Set UI back button blocked flag (0 = not blocked, 1 = blocked)

# File lib/lignite/ev3_ops.rb, line 3740
def ui_button_set_back_block(blocked)
  logger.debug do
    args = [blocked]
    "called ui_button_set_back_block with #{args.inspect}"
  end

  bytes = u8(0x83)
  bytes += param_simple(10)
  bytes += param_simple(blocked)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
ui_button_shortpress(button, state) click to toggle source

@param button [PAR8] (in) @param state [PAR8] (out) Button has been pressed (0 = no, 1 = yes)

# File lib/lignite/ev3_ops.rb, line 3586
def ui_button_shortpress(button, state)
  logger.debug do
    args = [button, state]
    "called ui_button_shortpress with #{args.inspect}"
  end

  bytes = u8(0x83)
  bytes += param_simple(1)
  bytes += param_simple(button)
  bytes += param_simple(state)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
ui_button_testlongpress(button, state) click to toggle source

@param button [PAR8] (in) @param state [PAR8] (out) Button has been hold down(0 = no, 1 = yes)

# File lib/lignite/ev3_ops.rb, line 3794
def ui_button_testlongpress(button, state)
  logger.debug do
    args = [button, state]
    "called ui_button_testlongpress with #{args.inspect}"
  end

  bytes = u8(0x83)
  bytes += param_simple(13)
  bytes += param_simple(button)
  bytes += param_simple(state)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
ui_button_testshortpress(button, state) click to toggle source

@param button [PAR8] (in) @param state [PAR8] (out) Button has been hold down(0 = no, 1 = yes)

# File lib/lignite/ev3_ops.rb, line 3775
def ui_button_testshortpress(button, state)
  logger.debug do
    args = [button, state]
    "called ui_button_testshortpress with #{args.inspect}"
  end

  bytes = u8(0x83)
  bytes += param_simple(12)
  bytes += param_simple(button)
  bytes += param_simple(state)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
ui_button_wait_for_press() click to toggle source
# File lib/lignite/ev3_ops.rb, line 3622
def ui_button_wait_for_press
  logger.debug do
    args = []
    "called ui_button_wait_for_press with #{args.inspect}"
  end

  bytes = u8(0x83)
  bytes += param_simple(3)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
ui_draw(*args) click to toggle source
# File lib/lignite/ev3_ops.rb, line 4747
def ui_draw(*args)
  logger.debug "called ui_draw with #{args.inspect}"
  cvalue = args.shift
  csym = MULTIPLEX_UI_DRAW.fetch(cvalue)
  __send__("ui_draw_#{csym}", *args)
end
ui_draw_bmpfile(color, x0, y0, name) click to toggle source

@param color [PAR8] (in) Color [BG_COLOR..FG_COLOR] @param x0 [PAR16] (in) X start cord [0..LCD_WIDTH] @param y0 [PAR16] (in) Y start cord [0..LCD_HEIGHT] @param name [PAR8] (in) First character in filename (character string)

# File lib/lignite/ev3_ops.rb, line 4590
def ui_draw_bmpfile(color, x0, y0, name)
  logger.debug do
    args = [color, x0, y0, name]
    "called ui_draw_bmpfile with #{args.inspect}"
  end

  bytes = u8(0x84)
  bytes += param_simple(28)
  bytes += param_simple(color)
  bytes += param_simple(x0)
  bytes += param_simple(y0)
  bytes += param_simple(name)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
ui_draw_browse(type, x0, y0, x1, y1, length, item_type, string) click to toggle source

@param string [PAR8] (out) First character in string receiving selected item name

# File lib/lignite/ev3_ops.rb, line 4267
def ui_draw_browse(type, x0, y0, x1, y1, length, item_type, string)
  logger.debug do
    args = [type, x0, y0, x1, y1, length, item_type, string]
    "called ui_draw_browse with #{args.inspect}"
  end

  bytes = u8(0x84)
  bytes += param_simple(14)
  bytes += param_simple(type)
  bytes += param_simple(x0)
  bytes += param_simple(y0)
  bytes += param_simple(x1)
  bytes += param_simple(y1)
  bytes += param_simple(length)
  bytes += param_simple(item_type)
  bytes += param_simple(string)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
ui_draw_circle(color, x0, y0, r) click to toggle source

@param color [PAR8] (in) Color [BG_COLOR..FG_COLOR] @param x0 [PAR16] (in) X start cord [0..LCD_WIDTH] @param y0 [PAR16] (in) Y start cord [0..LCD_HEIGHT] @param r [PAR16] (in) Radius

# File lib/lignite/ev3_ops.rb, line 3972
def ui_draw_circle(color, x0, y0, r)
  logger.debug do
    args = [color, x0, y0, r]
    "called ui_draw_circle with #{args.inspect}"
  end

  bytes = u8(0x84)
  bytes += param_simple(4)
  bytes += param_simple(color)
  bytes += param_simple(x0)
  bytes += param_simple(y0)
  bytes += param_simple(r)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
ui_draw_clean() click to toggle source
# File lib/lignite/ev3_ops.rb, line 3907
def ui_draw_clean
  logger.debug do
    args = []
    "called ui_draw_clean with #{args.inspect}"
  end

  bytes = u8(0x84)
  bytes += param_simple(1)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
ui_draw_dotline(color, x0, y0, x1, y1 , on , off ) click to toggle source

@param color [PAR8] (in) Color [BG_COLOR..FG_COLOR] @param x0 [PAR16] (in) X start cord [0..LCD_WIDTH] @param y0 [PAR16] (in) Y start cord [0..LCD_HEIGHT] @param x1 [PAR16] (in) X end [0..LCD_WIDTH] @param y1 [PAR16] (in) Y end [0..LCD_HEIGHT] @param on [PAR16] (in) On pixels @param off [PAR16] (in) Off pixels

# File lib/lignite/ev3_ops.rb, line 4424
def ui_draw_dotline(color, x0, y0, x1, y1 , on , off )
  logger.debug do
    args = [color, x0, y0, x1, y1 , on , off ]
    "called ui_draw_dotline with #{args.inspect}"
  end

  bytes = u8(0x84)
  bytes += param_simple(21)
  bytes += param_simple(color)
  bytes += param_simple(x0)
  bytes += param_simple(y0)
  bytes += param_simple(x1)
  bytes += param_simple(y1 )
  bytes += param_simple(on )
  bytes += param_simple(off )
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
ui_draw_fillcircle(color, x0, y0, r) click to toggle source

@param color [PAR8] (in) Color [BG_COLOR..FG_COLOR] @param x0 [PAR16] (in) X start cord [0..LCD_WIDTH] @param y0 [PAR16] (in) Y start cord [0..LCD_HEIGHT] @param r [PAR16] (in) Radius

# File lib/lignite/ev3_ops.rb, line 4508
def ui_draw_fillcircle(color, x0, y0, r)
  logger.debug do
    args = [color, x0, y0, r]
    "called ui_draw_fillcircle with #{args.inspect}"
  end

  bytes = u8(0x84)
  bytes += param_simple(24)
  bytes += param_simple(color)
  bytes += param_simple(x0)
  bytes += param_simple(y0)
  bytes += param_simple(r)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
ui_draw_fillrect(color, x0, y0, x1, y1 ) click to toggle source

@param color [PAR8] (in) Color [BG_COLOR..FG_COLOR] @param x0 [PAR16] (in) X start cord [0..LCD_WIDTH] @param y0 [PAR16] (in) Y start cord [0..LCD_HEIGHT] @param x1 [PAR16] (in) X size [0..LCD_WIDTH - X0] @param y1 [PAR16] (in) Y size [0..LCD_HEIGHT - Y0]

# File lib/lignite/ev3_ops.rb, line 4094
def ui_draw_fillrect(color, x0, y0, x1, y1 )
  logger.debug do
    args = [color, x0, y0, x1, y1 ]
    "called ui_draw_fillrect with #{args.inspect}"
  end

  bytes = u8(0x84)
  bytes += param_simple(9)
  bytes += param_simple(color)
  bytes += param_simple(x0)
  bytes += param_simple(y0)
  bytes += param_simple(x1)
  bytes += param_simple(y1 )
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
ui_draw_fillwindow(color, y0, y1) click to toggle source

@param y0 [PAR16] (in) Y start cord [0..LCD_HEIGHT] @param y1 [PAR16] (in) X size [0..LCD_HEIGHT]

# File lib/lignite/ev3_ops.rb, line 4382
def ui_draw_fillwindow(color, y0, y1)
  logger.debug do
    args = [color, y0, y1]
    "called ui_draw_fillwindow with #{args.inspect}"
  end

  bytes = u8(0x84)
  bytes += param_simple(19)
  bytes += param_simple(color)
  bytes += param_simple(y0)
  bytes += param_simple(y1)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
ui_draw_graph_draw(view, actual, lowest, highest, average) click to toggle source

@param view [PAR8] (in) Dataset number to view (0=all) @param actual [PARF] (out) @param lowest [PARF] (out) @param highest [PARF] (out) @param average [PARF] (out)

# File lib/lignite/ev3_ops.rb, line 4663
def ui_draw_graph_draw(view, actual, lowest, highest, average)
  logger.debug do
    args = [view, actual, lowest, highest, average]
    "called ui_draw_graph_draw with #{args.inspect}"
  end

  bytes = u8(0x84)
  bytes += param_simple(31)
  bytes += param_simple(view)
  bytes += param_simple(actual)
  bytes += param_simple(lowest)
  bytes += param_simple(highest)
  bytes += param_simple(average)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
ui_draw_graph_setup(x0, x1, items, offset, span, min, max, sample) click to toggle source

@param min [PAR16] (in) DATAF array (handle) containing min values @param max [PAR16] (in) DATAF array (handle) containing max values @param sample [PAR16] (in) DATAF array (handle) containing sample values

# File lib/lignite/ev3_ops.rb, line 4635
def ui_draw_graph_setup(x0, x1, items, offset, span, min, max, sample)
  logger.debug do
    args = [x0, x1, items, offset, span, min, max, sample]
    "called ui_draw_graph_setup with #{args.inspect}"
  end

  bytes = u8(0x84)
  bytes += param_simple(30)
  bytes += param_simple(x0)
  bytes += param_simple(x1)
  bytes += param_simple(items)
  bytes += param_simple(offset)
  bytes += param_simple(span)
  bytes += param_simple(min)
  bytes += param_simple(max)
  bytes += param_simple(sample)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
ui_draw_icon(color, x0, y0, type, no) click to toggle source

@param color [PAR8] (in) Color [BG_COLOR..FG_COLOR] @param x0 [PAR16] (in) X start cord [0..LCD_WIDTH] @param y0 [PAR16] (in) Y start cord [0..LCD_HEIGHT] @param type [PAR8] (in) Icon type (pool) @param no [PAR8] (in) Icon number

# File lib/lignite/ev3_ops.rb, line 4019
def ui_draw_icon(color, x0, y0, type, no)
  logger.debug do
    args = [color, x0, y0, type, no]
    "called ui_draw_icon with #{args.inspect}"
  end

  bytes = u8(0x84)
  bytes += param_simple(6)
  bytes += param_simple(color)
  bytes += param_simple(x0)
  bytes += param_simple(y0)
  bytes += param_simple(type)
  bytes += param_simple(no)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
ui_draw_icon_question(color, x0, y0, state, icons) click to toggle source

@param color [PAR8] (in) Color [BG_COLOR..FG_COLOR] @param x0 [PAR16] (in) X start cord [0..LCD_WIDTH] @param y0 [PAR16] (in) Y start cord [0..LCD_HEIGHT] @param state [PAR8] (in) State 0 = INIT @param icons [PAR32] (in) bitfield with icons

# File lib/lignite/ev3_ops.rb, line 4566
def ui_draw_icon_question(color, x0, y0, state, icons)
  logger.debug do
    args = [color, x0, y0, state, icons]
    "called ui_draw_icon_question with #{args.inspect}"
  end

  bytes = u8(0x84)
  bytes += param_simple(27)
  bytes += param_simple(color)
  bytes += param_simple(x0)
  bytes += param_simple(y0)
  bytes += param_simple(state)
  bytes += param_simple(icons)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
ui_draw_inverserect(x0, y0, x1, y1 ) click to toggle source

@param x0 [PAR16] (in) X start cord [0..LCD_WIDTH] @param y0 [PAR16] (in) Y start cord [0..LCD_HEIGHT] @param x1 [PAR16] (in) X size [0..LCD_WIDTH] @param y1 [PAR16] (in) Y size [0..LCD_HEIGHT]

# File lib/lignite/ev3_ops.rb, line 4325
def ui_draw_inverserect(x0, y0, x1, y1 )
  logger.debug do
    args = [x0, y0, x1, y1 ]
    "called ui_draw_inverserect with #{args.inspect}"
  end

  bytes = u8(0x84)
  bytes += param_simple(16)
  bytes += param_simple(x0)
  bytes += param_simple(y0)
  bytes += param_simple(x1)
  bytes += param_simple(y1 )
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
ui_draw_keyboard(color, x0, y0, icon, length, default, charset, string) click to toggle source

@param string [PAR8] (out) First character in string receiving keyboard input

# File lib/lignite/ev3_ops.rb, line 4235
def ui_draw_keyboard(color, x0, y0, icon, length, default, charset, string)
  logger.debug do
    args = [color, x0, y0, icon, length, default, charset, string]
    "called ui_draw_keyboard with #{args.inspect}"
  end

  bytes = u8(0x84)
  bytes += param_simple(13)
  bytes += param_simple(color)
  bytes += param_simple(x0)
  bytes += param_simple(y0)
  bytes += param_simple(icon)
  bytes += param_simple(length)
  bytes += param_simple(default)
  bytes += param_simple(charset)
  bytes += param_simple(string)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
ui_draw_line(color, x0, y0, x1, y1 ) click to toggle source

@param color [PAR8] (in) Color [BG_COLOR..FG_COLOR] @param x0 [PAR16] (in) X start cord [0..LCD_WIDTH] @param y0 [PAR16] (in) Y start cord [0..LCD_HEIGHT] @param x1 [PAR16] (in) X end [0..LCD_WIDTH] @param y1 [PAR16] (in) Y end [0..LCD_HEIGHT]

# File lib/lignite/ev3_ops.rb, line 3948
def ui_draw_line(color, x0, y0, x1, y1 )
  logger.debug do
    args = [color, x0, y0, x1, y1 ]
    "called ui_draw_line with #{args.inspect}"
  end

  bytes = u8(0x84)
  bytes += param_simple(3)
  bytes += param_simple(color)
  bytes += param_simple(x0)
  bytes += param_simple(y0)
  bytes += param_simple(x1)
  bytes += param_simple(y1 )
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
ui_draw_notification(color, x0, y0, icon1, icon2, icon3, string, state) click to toggle source

@param color [PAR8] (in) Color [BG_COLOR..FG_COLOR] @param x0 [PAR16] (in) X start cord [0..LCD_WIDTH] @param y0 [PAR16] (in) Y start cord [0..LCD_HEIGHT] @param icon1 [PAR8] (in) First icon @param icon2 [PAR8] (in) Second icon @param icon3 [PAR8] (in) Third icon @param string [PAR8] (in) First character in notification string @param state [PAR8] (in) State 0 = INIT

# File lib/lignite/ev3_ops.rb, line 4172
def ui_draw_notification(color, x0, y0, icon1, icon2, icon3, string, state)
  logger.debug do
    args = [color, x0, y0, icon1, icon2, icon3, string, state]
    "called ui_draw_notification with #{args.inspect}"
  end

  bytes = u8(0x84)
  bytes += param_simple(11)
  bytes += param_simple(color)
  bytes += param_simple(x0)
  bytes += param_simple(y0)
  bytes += param_simple(icon1)
  bytes += param_simple(icon2)
  bytes += param_simple(icon3)
  bytes += param_simple(string)
  bytes += param_simple(state)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
ui_draw_picture(color, x0, y0, ip) click to toggle source

@param color [PAR8] (in) Color [BG_COLOR..FG_COLOR] @param x0 [PAR16] (in) X start cord [0..LCD_WIDTH] @param y0 [PAR16] (in) Y start cord [0..LCD_HEIGHT] @param ip [PAR32] (in) Address of picture

# File lib/lignite/ev3_ops.rb, line 4043
def ui_draw_picture(color, x0, y0, ip)
  logger.debug do
    args = [color, x0, y0, ip]
    "called ui_draw_picture with #{args.inspect}"
  end

  bytes = u8(0x84)
  bytes += param_simple(7)
  bytes += param_simple(color)
  bytes += param_simple(x0)
  bytes += param_simple(y0)
  bytes += param_simple(ip)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
ui_draw_pixel(color, x0, y0) click to toggle source

@param color [PAR8] (in) Color [BG_COLOR..FG_COLOR] @param x0 [PAR16] (in) X start cord [0..LCD_WIDTH] @param y0 [PAR16] (in) Y start cord [0..LCD_HEIGHT]

# File lib/lignite/ev3_ops.rb, line 3925
def ui_draw_pixel(color, x0, y0)
  logger.debug do
    args = [color, x0, y0]
    "called ui_draw_pixel with #{args.inspect}"
  end

  bytes = u8(0x84)
  bytes += param_simple(2)
  bytes += param_simple(color)
  bytes += param_simple(x0)
  bytes += param_simple(y0)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
ui_draw_popup(open) click to toggle source

@param open [PAR8] ()

# File lib/lignite/ev3_ops.rb, line 4610
def ui_draw_popup(open)
  logger.debug do
    args = [open]
    "called ui_draw_popup with #{args.inspect}"
  end

  bytes = u8(0x84)
  bytes += param_simple(29)
  bytes += param_simple(open)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
ui_draw_question(color, x0, y0, icon1, icon2, string, state, ok) click to toggle source

@param color [PAR8] (in) Color [BG_COLOR..FG_COLOR] @param x0 [PAR16] (in) X start cord [0..LCD_WIDTH] @param y0 [PAR16] (in) Y start cord [0..LCD_HEIGHT] @param icon1 [PAR8] (in) First icon @param icon2 [PAR8] (in) Second icon @param string [PAR8] (in) First character in question string @param state [PAR8] (in) State 0 = NO, 1 = OK @param ok [PAR8] (out) Answer 0 = NO, 1 = OK, -1 = SKIP

# File lib/lignite/ev3_ops.rb, line 4203
def ui_draw_question(color, x0, y0, icon1, icon2, string, state, ok)
  logger.debug do
    args = [color, x0, y0, icon1, icon2, string, state, ok]
    "called ui_draw_question with #{args.inspect}"
  end

  bytes = u8(0x84)
  bytes += param_simple(12)
  bytes += param_simple(color)
  bytes += param_simple(x0)
  bytes += param_simple(y0)
  bytes += param_simple(icon1)
  bytes += param_simple(icon2)
  bytes += param_simple(string)
  bytes += param_simple(state)
  bytes += param_simple(ok)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
ui_draw_rect(color, x0, y0, x1, y1 ) click to toggle source

@param color [PAR8] (in) Color [BG_COLOR..FG_COLOR] @param x0 [PAR16] (in) X start cord [0..LCD_WIDTH] @param y0 [PAR16] (in) Y start cord [0..LCD_HEIGHT] @param x1 [PAR16] (in) X size [0..LCD_WIDTH - X0] @param y1 [PAR16] (in) Y size [0..LCD_HEIGHT - Y0]

# File lib/lignite/ev3_ops.rb, line 4119
def ui_draw_rect(color, x0, y0, x1, y1 )
  logger.debug do
    args = [color, x0, y0, x1, y1 ]
    "called ui_draw_rect with #{args.inspect}"
  end

  bytes = u8(0x84)
  bytes += param_simple(10)
  bytes += param_simple(color)
  bytes += param_simple(x0)
  bytes += param_simple(y0)
  bytes += param_simple(x1)
  bytes += param_simple(y1 )
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
ui_draw_rectangle(color, x0, y0, x1, y1 ) click to toggle source

@param color [PAR8] (in) Color [BG_COLOR..FG_COLOR] @param x0 [PAR16] (in) X start cord [0..LCD_WIDTH] @param y0 [PAR16] (in) Y start cord [0..LCD_HEIGHT] @param x1 [PAR16] (in) X size [0..LCD_WIDTH - X0] @param y1 [PAR16] (in) Y size [0..LCD_HEIGHT - Y0]

# File lib/lignite/ev3_ops.rb, line 4144
def ui_draw_rectangle(color, x0, y0, x1, y1 )
  logger.debug do
    args = [color, x0, y0, x1, y1 ]
    "called ui_draw_rectangle with #{args.inspect}"
  end

  bytes = u8(0x84)
  bytes += param_simple(10)
  bytes += param_simple(color)
  bytes += param_simple(x0)
  bytes += param_simple(y0)
  bytes += param_simple(x1)
  bytes += param_simple(y1 )
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
ui_draw_restore(no) click to toggle source

@param no [PAR8] (in) Level number (N=0 -> Saved screen just before run)

# File lib/lignite/ev3_ops.rb, line 4545
def ui_draw_restore(no)
  logger.debug do
    args = [no]
    "called ui_draw_restore with #{args.inspect}"
  end

  bytes = u8(0x84)
  bytes += param_simple(26)
  bytes += param_simple(no)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
ui_draw_scroll(y) click to toggle source

@param y [PAR16] ()

# File lib/lignite/ev3_ops.rb, line 4401
def ui_draw_scroll(y)
  logger.debug do
    args = [y]
    "called ui_draw_scroll with #{args.inspect}"
  end

  bytes = u8(0x84)
  bytes += param_simple(20)
  bytes += param_simple(y)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
ui_draw_select_font(type) click to toggle source

@param type [PAR8] (in) Font type [0..2] font will change to 0 when UPDATE is called

# File lib/lignite/ev3_ops.rb, line 4345
def ui_draw_select_font(type)
  logger.debug do
    args = [type]
    "called ui_draw_select_font with #{args.inspect}"
  end

  bytes = u8(0x84)
  bytes += param_simple(17)
  bytes += param_simple(type)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
ui_draw_store(no) click to toggle source

@param no [PAR8] (in) Level number

# File lib/lignite/ev3_ops.rb, line 4528
def ui_draw_store(no)
  logger.debug do
    args = [no]
    "called ui_draw_store with #{args.inspect}"
  end

  bytes = u8(0x84)
  bytes += param_simple(25)
  bytes += param_simple(no)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
ui_draw_text(color, x0, y0, string) click to toggle source

@param color [PAR8] (in) Color [BG_COLOR..FG_COLOR] @param x0 [PAR16] (in) X start cord [0..LCD_WIDTH] @param y0 [PAR16] (in) Y start cord [0..LCD_HEIGHT] @param string [PAR8] (in) First character in string to draw

# File lib/lignite/ev3_ops.rb, line 3995
def ui_draw_text(color, x0, y0, string)
  logger.debug do
    args = [color, x0, y0, string]
    "called ui_draw_text with #{args.inspect}"
  end

  bytes = u8(0x84)
  bytes += param_simple(5)
  bytes += param_simple(color)
  bytes += param_simple(x0)
  bytes += param_simple(y0)
  bytes += param_simple(string)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
ui_draw_textbox(x0, y0, x1, y1, text, size, del, line) click to toggle source

@param x0 [PAR16] () @param y0 [PAR16] () @param x1 [PAR16] () @param y1 [PAR16] () @param text [PAR8] () @param size [PAR32] () @param del [PAR8] () @param line [PAR8] ()

# File lib/lignite/ev3_ops.rb, line 4691
def ui_draw_textbox(x0, y0, x1, y1, text, size, del, line)
  logger.debug do
    args = [x0, y0, x1, y1, text, size, del, line]
    "called ui_draw_textbox with #{args.inspect}"
  end

  bytes = u8(0x84)
  bytes += param_simple(32)
  bytes += param_simple(x0)
  bytes += param_simple(y0)
  bytes += param_simple(x1)
  bytes += param_simple(y1)
  bytes += param_simple(text)
  bytes += param_simple(size)
  bytes += param_simple(del)
  bytes += param_simple(line)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
ui_draw_topline(enable) click to toggle source

@param enable [PAR8] (in) Enable top status line (0 = disabled, 1 = enabled)

# File lib/lignite/ev3_ops.rb, line 4362
def ui_draw_topline(enable)
  logger.debug do
    args = [enable]
    "called ui_draw_topline with #{args.inspect}"
  end

  bytes = u8(0x84)
  bytes += param_simple(18)
  bytes += param_simple(enable)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
ui_draw_update() click to toggle source
# File lib/lignite/ev3_ops.rb, line 3892
def ui_draw_update
  logger.debug do
    args = []
    "called ui_draw_update with #{args.inspect}"
  end

  bytes = u8(0x84)
  bytes += param_simple(0)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
ui_draw_value(color, x0, y0, value, figures, decimals) click to toggle source

@param color [PAR8] (in) Color [BG_COLOR..FG_COLOR] @param x0 [PAR16] (in) X start cord [0..LCD_WIDTH] @param y0 [PAR16] (in) Y start cord [0..LCD_HEIGHT] @param value [PARF] (in) Value to write @param figures [PAR8] (in) Total number of figures inclusive decimal point @param decimals [PAR8] (in) Number of decimals

# File lib/lignite/ev3_ops.rb, line 4068
def ui_draw_value(color, x0, y0, value, figures, decimals)
  logger.debug do
    args = [color, x0, y0, value, figures, decimals]
    "called ui_draw_value with #{args.inspect}"
  end

  bytes = u8(0x84)
  bytes += param_simple(8)
  bytes += param_simple(color)
  bytes += param_simple(x0)
  bytes += param_simple(y0)
  bytes += param_simple(value)
  bytes += param_simple(figures)
  bytes += param_simple(decimals)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
ui_draw_vertbar(color, x0, y0, x1, y1, min, max, act) click to toggle source

@param color [PAR8] (in) Color [BG_COLOR..FG_COLOR] @param x0 [PAR16] (in) X start cord [0..LCD_WIDTH] @param y0 [PAR16] (in) Y start cord [0..LCD_HEIGHT] @param x1 [PAR16] (in) X size [0..LCD_WIDTH] @param y1 [PAR16] (in) Y size [0..LCD_HEIGHT] @param min [PAR16] (in) Minimum value @param max [PAR16] (in) Maximum value @param act [PAR16] (in) Actual value

# File lib/lignite/ev3_ops.rb, line 4298
def ui_draw_vertbar(color, x0, y0, x1, y1, min, max, act)
  logger.debug do
    args = [color, x0, y0, x1, y1, min, max, act]
    "called ui_draw_vertbar with #{args.inspect}"
  end

  bytes = u8(0x84)
  bytes += param_simple(15)
  bytes += param_simple(color)
  bytes += param_simple(x0)
  bytes += param_simple(y0)
  bytes += param_simple(x1)
  bytes += param_simple(y1)
  bytes += param_simple(min)
  bytes += param_simple(max)
  bytes += param_simple(act)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
ui_draw_view_unit(color, x0, y0, value, figures, decimals, length, string) click to toggle source

@param color [PAR8] (in) Color [BG_COLOR..FG_COLOR] @param x0 [PAR16] (in) X start cord [0..LCD_WIDTH] @param y0 [PAR16] (in) Y start cord [0..LCD_HEIGHT] @param value [PARF] (in) Value to write @param figures [PAR8] (in) Total number of figures inclusive decimal point @param decimals [PAR8] (in) Number of decimals @param length [PAR8] (in) Maximal string length @param string [PAR8] (in) First character in string to draw

# File lib/lignite/ev3_ops.rb, line 4481
def ui_draw_view_unit(color, x0, y0, value, figures, decimals, length, string)
  logger.debug do
    args = [color, x0, y0, value, figures, decimals, length, string]
    "called ui_draw_view_unit with #{args.inspect}"
  end

  bytes = u8(0x84)
  bytes += param_simple(23)
  bytes += param_simple(color)
  bytes += param_simple(x0)
  bytes += param_simple(y0)
  bytes += param_simple(value)
  bytes += param_simple(figures)
  bytes += param_simple(decimals)
  bytes += param_simple(length)
  bytes += param_simple(string)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
ui_draw_view_value(color, x0, y0, value, figures, decimals) click to toggle source

@param color [PAR8] (in) Color [BG_COLOR..FG_COLOR] @param x0 [PAR16] (in) X start cord [0..LCD_WIDTH] @param y0 [PAR16] (in) Y start cord [0..LCD_HEIGHT] @param value [PARF] (in) Value to write @param figures [PAR8] (in) Total number of figures inclusive decimal point @param decimals [PAR8] (in) Number of decimals

# File lib/lignite/ev3_ops.rb, line 4452
def ui_draw_view_value(color, x0, y0, value, figures, decimals)
  logger.debug do
    args = [color, x0, y0, value, figures, decimals]
    "called ui_draw_view_value with #{args.inspect}"
  end

  bytes = u8(0x84)
  bytes += param_simple(22)
  bytes += param_simple(color)
  bytes += param_simple(x0)
  bytes += param_simple(y0)
  bytes += param_simple(value)
  bytes += param_simple(figures)
  bytes += param_simple(decimals)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
ui_flush() click to toggle source

User Interface flush buffers

# File lib/lignite/ev3_ops.rb, line 2653
def ui_flush
  logger.debug do
    args = []
    "called ui_flush with #{args.inspect}"
  end

  bytes = u8(0x80)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
ui_read(*args) click to toggle source
# File lib/lignite/ev3_ops.rb, line 3146
def ui_read(*args)
  logger.debug "called ui_read with #{args.inspect}"
  cvalue = args.shift
  csym = MULTIPLEX_UI_READ.fetch(cvalue)
  __send__("ui_read_#{csym}", *args)
end
ui_read_get_address(value) click to toggle source

@param value [PAR32] (out) Address from lms_cmdin

# File lib/lignite/ev3_ops.rb, line 2885
def ui_read_get_address(value)
  logger.debug do
    args = [value]
    "called ui_read_get_address with #{args.inspect}"
  end

  bytes = u8(0x81)
  bytes += param_simple(13)
  bytes += param_simple(value)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
ui_read_get_code(length, image, global, flag) click to toggle source

@param length [PAR32] (in) Maximal code stream length @param image [PAR32] (out) Address of image @param global [PAR32] (out) Address of global variables @param flag [PAR8] (out) Flag tells if image is ready

# File lib/lignite/ev3_ops.rb, line 2905
def ui_read_get_code(length, image, global, flag)
  logger.debug do
    args = [length, image, global, flag]
    "called ui_read_get_code with #{args.inspect}"
  end

  bytes = u8(0x81)
  bytes += param_simple(14)
  bytes += param_simple(length)
  bytes += param_simple(image)
  bytes += param_simple(global)
  bytes += param_simple(flag)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
ui_read_get_event(event) click to toggle source

@param event [PAR8] ()

# File lib/lignite/ev3_ops.rb, line 2722
def ui_read_get_event(event)
  logger.debug do
    args = [event]
    "called ui_read_get_event with #{args.inspect}"
  end

  bytes = u8(0x81)
  bytes += param_simple(4)
  bytes += param_simple(event)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
ui_read_get_fw_build(length, destination) click to toggle source

Get firmware build string @param length [PAR8] (in) Maximal length of string returned (-1 = no check) @param destination [PAR8] (out) String variable or handle to string

# File lib/lignite/ev3_ops.rb, line 2848
def ui_read_get_fw_build(length, destination)
  logger.debug do
    args = [length, destination]
    "called ui_read_get_fw_build with #{args.inspect}"
  end

  bytes = u8(0x81)
  bytes += param_simple(11)
  bytes += param_simple(length)
  bytes += param_simple(destination)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
ui_read_get_fw_vers(length, destination) click to toggle source

Get firmware version string @param length [PAR8] (in) Maximal length of string returned (-1 = no check) @param destination [PAR8] (out) String variable or handle to string

# File lib/lignite/ev3_ops.rb, line 2829
def ui_read_get_fw_vers(length, destination)
  logger.debug do
    args = [length, destination]
    "called ui_read_get_fw_vers with #{args.inspect}"
  end

  bytes = u8(0x81)
  bytes += param_simple(10)
  bytes += param_simple(length)
  bytes += param_simple(destination)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
ui_read_get_hw_vers(length, destination) click to toggle source

Get hardware version string @param length [PAR8] (in) Maximal length of string returned (-1 = no check) @param destination [PAR8] (out) String variable or handle to string

# File lib/lignite/ev3_ops.rb, line 2810
def ui_read_get_hw_vers(length, destination)
  logger.debug do
    args = [length, destination]
    "called ui_read_get_hw_vers with #{args.inspect}"
  end

  bytes = u8(0x81)
  bytes += param_simple(9)
  bytes += param_simple(length)
  bytes += param_simple(destination)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
ui_read_get_ibatt(value) click to toggle source

@param value [PARF] (out) Battery current [A]

# File lib/lignite/ev3_ops.rb, line 2686
def ui_read_get_ibatt(value)
  logger.debug do
    args = [value]
    "called ui_read_get_ibatt with #{args.inspect}"
  end

  bytes = u8(0x81)
  bytes += param_simple(2)
  bytes += param_simple(value)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
ui_read_get_iint(iint) click to toggle source

@param iint [PARF] (out) Integrated battery current [A]

# File lib/lignite/ev3_ops.rb, line 2756
def ui_read_get_iint(iint)
  logger.debug do
    args = [iint]
    "called ui_read_get_iint with #{args.inspect}"
  end

  bytes = u8(0x81)
  bytes += param_simple(6)
  bytes += param_simple(iint)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
ui_read_get_imotor(value) click to toggle source

@param value [PARF] (out) Motor current [A]

# File lib/lignite/ev3_ops.rb, line 2773
def ui_read_get_imotor(value)
  logger.debug do
    args = [value]
    "called ui_read_get_imotor with #{args.inspect}"
  end

  bytes = u8(0x81)
  bytes += param_simple(7)
  bytes += param_simple(value)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
ui_read_get_ip(length, destination) click to toggle source

Get IP address string @param length [PAR8] (in) Maximal length of string returned (-1 = no check) @param destination [PAR8] (out) String variable or handle to string

# File lib/lignite/ev3_ops.rb, line 3040
def ui_read_get_ip(length, destination)
  logger.debug do
    args = [length, destination]
    "called ui_read_get_ip with #{args.inspect}"
  end

  bytes = u8(0x81)
  bytes += param_simple(27)
  bytes += param_simple(length)
  bytes += param_simple(destination)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
ui_read_get_lbatt(pct) click to toggle source

Get battery level in % @param pct [PAR8] (out) Battery level [0..100]

# File lib/lignite/ev3_ops.rb, line 2976
def ui_read_get_lbatt(pct)
  logger.debug do
    args = [pct]
    "called ui_read_get_lbatt with #{args.inspect}"
  end

  bytes = u8(0x81)
  bytes += param_simple(18)
  bytes += param_simple(pct)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
ui_read_get_os_build(length, destination) click to toggle source

Get os build string @param length [PAR8] (in) Maximal length of string returned (-1 = no check) @param destination [PAR8] (out) String variable or handle to string

# File lib/lignite/ev3_ops.rb, line 2867
def ui_read_get_os_build(length, destination)
  logger.debug do
    args = [length, destination]
    "called ui_read_get_os_build with #{args.inspect}"
  end

  bytes = u8(0x81)
  bytes += param_simple(12)
  bytes += param_simple(length)
  bytes += param_simple(destination)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
ui_read_get_os_vers(length, destination) click to toggle source

Get os version string @param length [PAR8] (in) Maximal length of string returned (-1 = no check) @param destination [PAR8] (out) String variable or handle to string

# File lib/lignite/ev3_ops.rb, line 2704
def ui_read_get_os_vers(length, destination)
  logger.debug do
    args = [length, destination]
    "called ui_read_get_os_vers with #{args.inspect}"
  end

  bytes = u8(0x81)
  bytes += param_simple(3)
  bytes += param_simple(length)
  bytes += param_simple(destination)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
ui_read_get_power(vbatt, ibatt, iint, imotor) click to toggle source

@param vbatt [PARF] (out) Battery voltage [V] @param ibatt [PARF] (out) Battery current [A] @param iint [PARF] (out) Integrated battery current [A] @param imotor [PARF] (out) Motor current [A]

# File lib/lignite/ev3_ops.rb, line 3061
def ui_read_get_power(vbatt, ibatt, iint, imotor)
  logger.debug do
    args = [vbatt, ibatt, iint, imotor]
    "called ui_read_get_power with #{args.inspect}"
  end

  bytes = u8(0x81)
  bytes += param_simple(29)
  bytes += param_simple(vbatt)
  bytes += param_simple(ibatt)
  bytes += param_simple(iint)
  bytes += param_simple(imotor)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
ui_read_get_sdcard(state, total, free) click to toggle source

@param state [PAR8] (out) SD card present [0..1] @param total [PAR32] (out) Kbytes in total @param free [PAR32] (out) Kbytes free

# File lib/lignite/ev3_ops.rb, line 3083
def ui_read_get_sdcard(state, total, free)
  logger.debug do
    args = [state, total, free]
    "called ui_read_get_sdcard with #{args.inspect}"
  end

  bytes = u8(0x81)
  bytes += param_simple(30)
  bytes += param_simple(state)
  bytes += param_simple(total)
  bytes += param_simple(free)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
ui_read_get_shutdown(flag) click to toggle source

@param flag [PAR8] ()

# File lib/lignite/ev3_ops.rb, line 2942
def ui_read_get_shutdown(flag)
  logger.debug do
    args = [flag]
    "called ui_read_get_shutdown with #{args.inspect}"
  end

  bytes = u8(0x81)
  bytes += param_simple(16)
  bytes += param_simple(flag)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
ui_read_get_string(length, destination) click to toggle source

Get string from terminal @param length [PAR8] (in) Maximal length of string returned @param destination [PAR8] (out) String variable or handle to string

# File lib/lignite/ev3_ops.rb, line 2791
def ui_read_get_string(length, destination)
  logger.debug do
    args = [length, destination]
    "called ui_read_get_string with #{args.inspect}"
  end

  bytes = u8(0x81)
  bytes += param_simple(8)
  bytes += param_simple(length)
  bytes += param_simple(destination)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
ui_read_get_tbatt(value) click to toggle source

@param value [PARF] (out) Battery temperature rise [C]

# File lib/lignite/ev3_ops.rb, line 2739
def ui_read_get_tbatt(value)
  logger.debug do
    args = [value]
    "called ui_read_get_tbatt with #{args.inspect}"
  end

  bytes = u8(0x81)
  bytes += param_simple(5)
  bytes += param_simple(value)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
ui_read_get_usbstick(state, total, free) click to toggle source

@param state [PAR8] (out) USB stick present [0..1] @param total [PAR32] (out) Kbytes in total @param free [PAR32] (out) Kbytes free

# File lib/lignite/ev3_ops.rb, line 3104
def ui_read_get_usbstick(state, total, free)
  logger.debug do
    args = [state, total, free]
    "called ui_read_get_usbstick with #{args.inspect}"
  end

  bytes = u8(0x81)
  bytes += param_simple(31)
  bytes += param_simple(state)
  bytes += param_simple(total)
  bytes += param_simple(free)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
ui_read_get_vbatt(value) click to toggle source

@param value [PARF] (out) Battery voltage [V]

# File lib/lignite/ev3_ops.rb, line 2669
def ui_read_get_vbatt(value)
  logger.debug do
    args = [value]
    "called ui_read_get_vbatt with #{args.inspect}"
  end

  bytes = u8(0x81)
  bytes += param_simple(1)
  bytes += param_simple(value)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
ui_read_get_version(length, destination) click to toggle source

Get version string @param length [PAR8] (in) Maximal length of string returned (-1 = no check) @param destination [PAR8] (out) String variable or handle to string

# File lib/lignite/ev3_ops.rb, line 3021
def ui_read_get_version(length, destination)
  logger.debug do
    args = [length, destination]
    "called ui_read_get_version with #{args.inspect}"
  end

  bytes = u8(0x81)
  bytes += param_simple(26)
  bytes += param_simple(length)
  bytes += param_simple(destination)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
ui_read_get_warning(warnings) click to toggle source

@param warnings [PAR8] ()

# File lib/lignite/ev3_ops.rb, line 2959
def ui_read_get_warning(warnings)
  logger.debug do
    args = [warnings]
    "called ui_read_get_warning with #{args.inspect}"
  end

  bytes = u8(0x81)
  bytes += param_simple(17)
  bytes += param_simple(warnings)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
ui_read_key(value) click to toggle source

@param value [PAR8] (out) Key value from lms_cmdin (0 = no key)

# File lib/lignite/ev3_ops.rb, line 2925
def ui_read_key(value)
  logger.debug do
    args = [value]
    "called ui_read_key with #{args.inspect}"
  end

  bytes = u8(0x81)
  bytes += param_simple(15)
  bytes += param_simple(value)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
ui_read_textbox_read(text, size, del, length, line, destination) click to toggle source

@param text [PAR8] () @param size [PAR32] () @param del [PAR8] () @param length [PAR8] () @param line [PAR16] () @param destination [PAR8] ()

# File lib/lignite/ev3_ops.rb, line 2998
def ui_read_textbox_read(text, size, del, length, line, destination)
  logger.debug do
    args = [text, size, del, length, line, destination]
    "called ui_read_textbox_read with #{args.inspect}"
  end

  bytes = u8(0x81)
  bytes += param_simple(21)
  bytes += param_simple(text)
  bytes += param_simple(size)
  bytes += param_simple(del)
  bytes += param_simple(length)
  bytes += param_simple(line)
  bytes += param_simple(destination)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
ui_write(*args) click to toggle source
# File lib/lignite/ev3_ops.rb, line 3573
def ui_write(*args)
  logger.debug "called ui_write with #{args.inspect}"
  cvalue = args.shift
  csym = MULTIPLEX_UI_WRITE.fetch(cvalue)
  __send__("ui_write_#{csym}", *args)
end
ui_write_address(value) click to toggle source

@param value [PAR32] (out)

# File lib/lignite/ev3_ops.rb, line 3296
def ui_write_address(value)
  logger.debug do
    args = [value]
    "called ui_write_address with #{args.inspect}"
  end

  bytes = u8(0x82)
  bytes += param_simple(13)
  bytes += param_simple(value)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
ui_write_allow_pulse(value) click to toggle source

@param value [PAR8] ()

# File lib/lignite/ev3_ops.rb, line 3364
def ui_write_allow_pulse(value)
  logger.debug do
    args = [value]
    "called ui_write_allow_pulse with #{args.inspect}"
  end

  bytes = u8(0x82)
  bytes += param_simple(17)
  bytes += param_simple(value)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
ui_write_code(array, length) click to toggle source

@param array [PAR8] (in) First byte in byte array to write @param length [PAR32] (in) Length of array

# File lib/lignite/ev3_ops.rb, line 3314
def ui_write_code(array, length)
  logger.debug do
    args = [array, length]
    "called ui_write_code with #{args.inspect}"
  end

  bytes = u8(0x82)
  bytes += param_simple(14)
  bytes += param_simple(array)
  bytes += param_simple(length)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
ui_write_download_end() click to toggle source

Send to brick when file down load is completed (plays sound and updates the UI browser)

# File lib/lignite/ev3_ops.rb, line 3331
def ui_write_download_end
  logger.debug do
    args = []
    "called ui_write_download_end with #{args.inspect}"
  end

  bytes = u8(0x82)
  bytes += param_simple(15)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
ui_write_floatvalue(value, figures, decimals) click to toggle source

@param value [PARF] (in) Value to write @param figures [PAR8] (in) Total number of figures inclusive decimal point @param decimals [PAR8] (in) Number of decimals

# File lib/lignite/ev3_ops.rb, line 3175
def ui_write_floatvalue(value, figures, decimals)
  logger.debug do
    args = [value, figures, decimals]
    "called ui_write_floatvalue with #{args.inspect}"
  end

  bytes = u8(0x82)
  bytes += param_simple(2)
  bytes += param_simple(value)
  bytes += param_simple(figures)
  bytes += param_simple(decimals)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
ui_write_graph_sample() click to toggle source

Update tick to scroll graph horizontally in memory when drawing graph in “scope” mode

# File lib/lignite/ev3_ops.rb, line 3518
def ui_write_graph_sample
  logger.debug do
    args = []
    "called ui_write_graph_sample with #{args.inspect}"
  end

  bytes = u8(0x82)
  bytes += param_simple(30)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
ui_write_init_run() click to toggle source

Start the “Mindstorms” “run” screen

# File lib/lignite/ev3_ops.rb, line 3454
def ui_write_init_run
  logger.debug do
    args = []
    "called ui_write_init_run with #{args.inspect}"
  end

  bytes = u8(0x82)
  bytes += param_simple(25)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
ui_write_led(pattern) click to toggle source

@param pattern [PAR8] (in) LED Pattern

# File lib/lignite/ev3_ops.rb, line 3485
def ui_write_led(pattern)
  logger.debug do
    args = [pattern]
    "called ui_write_led with #{args.inspect}"
  end

  bytes = u8(0x82)
  bytes += param_simple(27)
  bytes += param_simple(pattern)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
ui_write_power(value) click to toggle source

@param value [PAR8] (in) Value [0,1]

# File lib/lignite/ev3_ops.rb, line 3502
def ui_write_power(value)
  logger.debug do
    args = [value]
    "called ui_write_power with #{args.inspect}"
  end

  bytes = u8(0x82)
  bytes += param_simple(29)
  bytes += param_simple(value)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
ui_write_put_string(string) click to toggle source

@param string [PAR8] (in) First character in string to write

# File lib/lignite/ev3_ops.rb, line 3211
def ui_write_put_string(string)
  logger.debug do
    args = [string]
    "called ui_write_put_string with #{args.inspect}"
  end

  bytes = u8(0x82)
  bytes += param_simple(8)
  bytes += param_simple(string)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
ui_write_screen_block(status) click to toggle source

Set or clear screen block status (if screen blocked - all graphical screen action are disabled) @param status [PAR8] (in) Value [0 = normal,1 = blocked]

# File lib/lignite/ev3_ops.rb, line 3347
def ui_write_screen_block(status)
  logger.debug do
    args = [status]
    "called ui_write_screen_block with #{args.inspect}"
  end

  bytes = u8(0x82)
  bytes += param_simple(16)
  bytes += param_simple(status)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
ui_write_set_busy(value) click to toggle source

@param value [PAR8] (in) Value [0,1]

# File lib/lignite/ev3_ops.rb, line 3421
def ui_write_set_busy(value)
  logger.debug do
    args = [value]
    "called ui_write_set_busy with #{args.inspect}"
  end

  bytes = u8(0x82)
  bytes += param_simple(22)
  bytes += param_simple(value)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
ui_write_set_pulse(value) click to toggle source

@param value [PAR8] ()

# File lib/lignite/ev3_ops.rb, line 3381
def ui_write_set_pulse(value)
  logger.debug do
    args = [value]
    "called ui_write_set_pulse with #{args.inspect}"
  end

  bytes = u8(0x82)
  bytes += param_simple(18)
  bytes += param_simple(value)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
ui_write_set_testpin(state) click to toggle source

@param state [PAR8] (in) Value [0 = low,1 = high]

# File lib/lignite/ev3_ops.rb, line 3438
def ui_write_set_testpin(state)
  logger.debug do
    args = [state]
    "called ui_write_set_testpin with #{args.inspect}"
  end

  bytes = u8(0x82)
  bytes += param_simple(24)
  bytes += param_simple(state)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
ui_write_stamp(value) click to toggle source

@param value [PAR8] ()

# File lib/lignite/ev3_ops.rb, line 3194
def ui_write_stamp(value)
  logger.debug do
    args = [value]
    "called ui_write_stamp with #{args.inspect}"
  end

  bytes = u8(0x82)
  bytes += param_simple(3)
  bytes += param_simple(value)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
ui_write_terminal(state) click to toggle source

@param state [PAR8] (in) Value [0 = Off,1 = On]

# File lib/lignite/ev3_ops.rb, line 3534
def ui_write_terminal(state)
  logger.debug do
    args = [state]
    "called ui_write_terminal with #{args.inspect}"
  end

  bytes = u8(0x82)
  bytes += param_simple(31)
  bytes += param_simple(state)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
ui_write_textbox_append(text, size, del, source) click to toggle source

Append line of text at the bottom of a text box @param text [PAR8] (in) First character in text box text (must be zero terminated) @param size [PAR32] (in) Maximal text size (including zero termination) @param del [PAR8] (in) Delimiter code @param source [PAR8] (in) String variable or handle to string to append

# File lib/lignite/ev3_ops.rb, line 3401
def ui_write_textbox_append(text, size, del, source)
  logger.debug do
    args = [text, size, del, source]
    "called ui_write_textbox_append with #{args.inspect}"
  end

  bytes = u8(0x82)
  bytes += param_simple(21)
  bytes += param_simple(text)
  bytes += param_simple(size)
  bytes += param_simple(del)
  bytes += param_simple(source)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
ui_write_update_run() click to toggle source
# File lib/lignite/ev3_ops.rb, line 3469
def ui_write_update_run
  logger.debug do
    args = []
    "called ui_write_update_run with #{args.inspect}"
  end

  bytes = u8(0x82)
  bytes += param_simple(26)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
ui_write_value16(value) click to toggle source

@param value [PAR16] (in) Value to write

# File lib/lignite/ev3_ops.rb, line 3245
def ui_write_value16(value)
  logger.debug do
    args = [value]
    "called ui_write_value16 with #{args.inspect}"
  end

  bytes = u8(0x82)
  bytes += param_simple(10)
  bytes += param_simple(value)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
ui_write_value32(value) click to toggle source

@param value [PAR32] (in) Value to write

# File lib/lignite/ev3_ops.rb, line 3262
def ui_write_value32(value)
  logger.debug do
    args = [value]
    "called ui_write_value32 with #{args.inspect}"
  end

  bytes = u8(0x82)
  bytes += param_simple(11)
  bytes += param_simple(value)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
ui_write_value8(value) click to toggle source

@param value [PAR8] (in) Value to write

# File lib/lignite/ev3_ops.rb, line 3228
def ui_write_value8(value)
  logger.debug do
    args = [value]
    "called ui_write_value8 with #{args.inspect}"
  end

  bytes = u8(0x82)
  bytes += param_simple(9)
  bytes += param_simple(value)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
ui_write_valuef(value) click to toggle source

@param value [PARF] (in) Value to write

# File lib/lignite/ev3_ops.rb, line 3279
def ui_write_valuef(value)
  logger.debug do
    args = [value]
    "called ui_write_valuef with #{args.inspect}"
  end

  bytes = u8(0x82)
  bytes += param_simple(12)
  bytes += param_simple(value)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
ui_write_write_flush() click to toggle source
# File lib/lignite/ev3_ops.rb, line 3157
def ui_write_write_flush
  logger.debug do
    args = []
    "called ui_write_write_flush with #{args.inspect}"
  end

  bytes = u8(0x82)
  bytes += param_simple(1)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
write16(source, index, destination) click to toggle source

Write 16 bit value from SOURCE to DESTINATION @param source [PAR16] (in) Variable to write @param index [PAR8] (in) Index to array member to write @param destination [PAR16] (in) Array to receive write value

# File lib/lignite/ev3_ops.rb, line 8146
def write16(source, index, destination)
  logger.debug do
    args = [source, index, destination]
    "called write16 with #{args.inspect}"
  end

  bytes = u8(0xCD)
  bytes += param_simple(source)
  bytes += param_simple(index)
  bytes += param_simple(destination)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
write32(source, index, destination) click to toggle source

Write 32 bit value from SOURCE to DESTINATION @param source [PAR32] (in) Variable to write @param index [PAR8] (in) Index to array member to write @param destination [PAR32] (in) Array to receive write value

# File lib/lignite/ev3_ops.rb, line 8164
def write32(source, index, destination)
  logger.debug do
    args = [source, index, destination]
    "called write32 with #{args.inspect}"
  end

  bytes = u8(0xCE)
  bytes += param_simple(source)
  bytes += param_simple(index)
  bytes += param_simple(destination)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
write8(source, index, destination) click to toggle source

Write 8 bit value from SOURCE to DESTINATION @param source [PAR8] (in) Variable to write @param index [PAR8] (in) Index to array member to write @param destination [PAR8] (in) Array to receive write value

# File lib/lignite/ev3_ops.rb, line 8128
def write8(source, index, destination)
  logger.debug do
    args = [source, index, destination]
    "called write8 with #{args.inspect}"
  end

  bytes = u8(0xCC)
  bytes += param_simple(source)
  bytes += param_simple(index)
  bytes += param_simple(destination)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
writef(source, index, destination) click to toggle source

Write floating point value from SOURCE to DESTINATION @param source [PARF] (in) Variable to write @param index [PAR8] (in) Index to array member to write @param destination [PARF] (in) Array to receive write value

# File lib/lignite/ev3_ops.rb, line 8182
def writef(source, index, destination)
  logger.debug do
    args = [source, index, destination]
    "called writef with #{args.inspect}"
  end

  bytes = u8(0xCF)
  bytes += param_simple(source)
  bytes += param_simple(index)
  bytes += param_simple(destination)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
xor16(source1, source2, destination) click to toggle source

Exclusive or two 16 bit values DESTINATION = SOURCE1 ^ SOURCE2 @param source1 [PAR16] (in) @param source2 [PAR16] (in) @param destination [PAR16] (out)

# File lib/lignite/ev3_ops.rb, line 779
def xor16(source1, source2, destination)
  logger.debug do
    args = [source1, source2, destination]
    "called xor16 with #{args.inspect}"
  end

  bytes = u8(0x29)
  bytes += param_simple(source1)
  bytes += param_simple(source2)
  bytes += param_simple(destination)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
xor32(source1, source2, destination) click to toggle source

Exclusive or two 32 bit values DESTINATION = SOURCE1 ^ SOURCE2 @param source1 [PAR32] (in) @param source2 [PAR32] (in) @param destination [PAR32] (out)

# File lib/lignite/ev3_ops.rb, line 797
def xor32(source1, source2, destination)
  logger.debug do
    args = [source1, source2, destination]
    "called xor32 with #{args.inspect}"
  end

  bytes = u8(0x2A)
  bytes += param_simple(source1)
  bytes += param_simple(source2)
  bytes += param_simple(destination)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end
xor8(source1, source2, destination) click to toggle source

Exclusive or two 8 bit values DESTINATION = SOURCE1 ^ SOURCE2 @param source1 [PAR8] (in) @param source2 [PAR8] (in) @param destination [PAR8] (out)

# File lib/lignite/ev3_ops.rb, line 761
def xor8(source1, source2, destination)
  logger.debug do
    args = [source1, source2, destination]
    "called xor8 with #{args.inspect}"
  end

  bytes = u8(0x28)
  bytes += param_simple(source1)
  bytes += param_simple(source2)
  bytes += param_simple(destination)
  logger.debug "returning bytecode: #{bytes.inspect}"
  bytes
end