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
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
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
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
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
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
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
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
# 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 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
@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
@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
@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
@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
@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
@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
@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
@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
@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
@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
@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
@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 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
@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
@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
@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
@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
@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 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
@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
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
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
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
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
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
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
# 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
@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
@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
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
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
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
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
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
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
@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
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
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
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
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
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
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
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
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
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
# 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
@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
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
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
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
# 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
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
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
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
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
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
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
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
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
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
Starts or or stops the search for remote devices @param hardware [PAR8] (in) Hardware Transport Layer @param search [PAR8] (in) Search [0,1] 0 = stop search, 1 = start search
# File lib/lignite/ev3_ops.rb, line 8715 def com_set_set_search(hardware, search) logger.debug do args = [hardware, search] "called com_set_set_search with #{args.inspect}" end bytes = u8(0xD4) bytes += param_simple(3) bytes += param_simple(hardware) bytes += param_simple(search) logger.debug "returning bytecode: #{bytes.inspect}" bytes end
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
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
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
# 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
@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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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 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
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
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
@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
@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
@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
@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
@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
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
@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
@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
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
@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
@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
@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
@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
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
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
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
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
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
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
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
@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
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
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
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
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
@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
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
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
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
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
# 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
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
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
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
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
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
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
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
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
# 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
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
@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
@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
@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
@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
@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
@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
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
# 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
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
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
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
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
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
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
@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
@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
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
@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
@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
@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
@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
@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
@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
@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
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
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
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
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
@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
@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
@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
@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
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
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
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
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
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
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
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
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
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
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
@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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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 @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
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
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
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
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
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
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
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
# 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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
@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
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
@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
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
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
@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
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
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
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
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
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
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
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
@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
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
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
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
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
@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
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
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
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
# 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
@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
@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
@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
@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
@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
@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
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
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
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
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
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
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
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
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 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
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
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
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
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
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
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
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
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
# 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
# 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
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
# 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
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
@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
# 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
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
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
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
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
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
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
@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
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
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
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
@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
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
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
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
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
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
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
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
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
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
# 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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
# 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
@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
@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
@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
# 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
@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
@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
@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
@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
@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
@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
@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
@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
@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
@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
@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
@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
@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
@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
@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
@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
@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
@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
@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
@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
@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
@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
@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
@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
@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
# 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
@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
@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
@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
@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
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
# 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
@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
@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
@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
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
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
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
@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
@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
@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
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
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
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
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
@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
@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
@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
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
@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
@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
@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
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
@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
@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
@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
# 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
@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
@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
@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
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
@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
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
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
@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
@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
@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
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
@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
@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
@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
@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
@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
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
# 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
@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
@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
@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
@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
# 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
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
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
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
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
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
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
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