Please note: Levitezer Protocol is under development, definitions are subjected to be changed

• Levitezer Protocol
  • Message Structure
    • Header
    • Data
    • Checksum
  • Parameter Descriptions
    • Data Provided by Gimbal
    • Gimbal Control Parameters
    • Black Magic Camera Parameters
    • Black Magic Camera Parameters New
    • Controller Parameters
  • Examples
    • Trigger Camera Recording
    • Gimbal Joystick Control
    • Gimbal Angle Control
    • Moving Gimbal on Geopoint mode

Any message between two systems is compound of

|___Header___||___Data___||__End_of_message__||__Checksum__|

There is 2 Modes for the Messages:

• Standard Mode
• Binary Mode

The byte order is always "little endian". Meaning the least significant byte is always first in any parameter. For example a 16 bit integer must be transmitted like this

    int16 n = 0xF137;
    byte data[]{
        n & 0xFF,  /* this is 0x37 */
        n >> 8     /* this is 0xF1 */
    }

Then on the other end it can be reassembled:

int16 n = (data[0] | data[1] << 8);

This message is in standard mode, is meant for Camera id 7 and contains 2 parameters in the data payload

Header is the firs 6 bytes of the message and it tells "who" sent this message (or "who" should receive it) and how to read it.

• Starting_Bytes: this is a sequence of 3 bytes which values are always 255 or FF in hexadecimal. This identifies the starting of the message.

• Device_ID: Identifies the device which will receive the message (or from which the message came). This id can be given by the user

• Device_Type: it can be one of the following:

Every device has its own set of parameters which is up to 254 parameters.

• Counter+Mode: Packed on the same byte is the counter and the mode
  • counter: a counter that overflows every 127 messages. This may be useful to keep track of the message order
  • mode: message uses standard or binary data.

Data is between the header and the end of the message. Here are the parameters of the device. Each parameter value is always 16 bits (little endian order) preceded by an 8 bit id. Therefore every data field is 3 bytes. All the parameters must be for the same device and it cannot be more than 254 parameters.

... <ID_0> <VALUE_0>, <ID_1> <VALUE_1> ... <ID_x> <VALUE_X> ...

Example: send the farthest focus. The id is '2'. and the max value is '2047' ('0800' in hexadecimal). Then the data field are the three bytes following bytes (note the low byte is first):

This mode is meant to transmit data that is not convenient on the standard 16 bit parameter mode. Such as big, grouped parameters and the ones that required conversion. The binary Mode uses the following structure after the header (every number is a byte):

01 MM MM 02 DD DD 03 DD DD 04 DD DD 05 DD DD .... 00 CS CS

each 'DD' is a byte of data. The data bytes are between a sequence of numbers as shown above. The first two bytes of data MM MM after 01 are a 16 bit integer Id that identifies the data.

Note that data starts after 02 sequence number. The sequence numbers can get up to 254. Which makes the maximum data size 2*254 = 508 bytes

The last part of the message is the checksum, right after the data, there is the end of message byte which is a 00, then the 16 bit checksum. The checksum is calculated as a sum of all bytes on the message but the <Starting_Bytes> using modulo 65536 operation (0x10000).

Example

// msg contains already a levitezer message but the checksum
uint8_t msg[100]
uint16_t msg_size = 40;
uint16_t checksum = 0; // a 16 bit variable overflows automaticaly

for(int i = 3; i < msg_size-3; i++){
    checksum += msg[i];
}
msg[msg_size-2] = checksum & 0xff;
msg[msg_size-1] = checksum >> 8;

Notes: When controling the gimbal on speed mode you should send CONTROL_MODE=1 + speed axis. Also use a high rate send in the range of 50-100 Hz.

When controling the gimbal on angle mode you should send CONTROL_MODE=2 + speed axis + angle axis. On this case the speed will use to reach the target angle.

GPS data is sent on Binary mode. There is 2 Ids; one for the Gimbal coordinates and the other for target coordinates.

Both GPS binary message are the same structure. The parameters are based on C language types and they are packet on the same order as in the following table

Since datatypes are C language based. You can take advantage of C Unions to pack and receive the data without doing any extra conversions. you just need to copy the binary data to the dataArray field inside the Union, after that all parameters are available. And the other way around also works; you set every parameter and dataArray is ready to be sent with all the data.

union GpsDataUnion{
    struct  GpsData{
        double lat;
        double lon;
        double alt;
        float heading;
        float speed;
        uint32_t timestamp;
        uint8_t day;
        uint8_t month;
        uint8_t year;
        uint8_t status;
    } data;
    uint8_t dataArray[sizeof(GpsData)];
};

Also on python we also can use c unions through ctypes.

from ctypes import (
        Union, Array, Structure,
        c_uint8, c_uint32, c_float, c_double
)

ARRAY_SIZE = 40

class uint8_array(Array):
        _type_ = c_uint8
        _length_ = ARRAY_SIZE

class gps_data(Structure):
        _fields_ = (
		("lat", c_double),
		("lon", c_double),
		("alt", c_double),
		("heading", c_float),
		("speed", c_float),
		("timestamp", c_uint32),
		("day", c_uint8),
		("month", c_uint8),
		("year", c_uint8),
		("status", c_uint8)
		)
  
class gps_data_union(Union):
    _fields_ = (
    ("data", gps_data),
    ("byteArray", uint8_array)
    )

The following parameters controls cameras using the Blackmagic SDI and Bluetooth Camera Control Protocol. Camera parameters must be send at rates below 24 Hz. If they are sent at higher frequency for short period, they will be enqueued and eventually sent to camera, but if the queue gets full then new data will be dropped.

Usually a BMD camera can be given an Id in the 1-99 range. This is the id that must be used on the Header "device id" field. A special case is a Bluetooth camera. Messages sent to bluetooth cameras use id 100.

Some parameters should be sent grouped in the same message always, these are indicatd by the hint (grouped)

The following parameters must be send on groups

Exposure time in microseconds. Signed 32 bit parameter divided in 2 ids.
Min value 1.
Max value 42000.

Shutter angle in degrees, multiplied by 100. Signed 32 bit parameter divided in 2 Ids.
Min value 100.
Max value 36000.

Value as a fraction of 1, i.g 50 for 1/50th of a second. Signed 32 bit parameter divided in 2 ids.
Min value 24.
Max value 2000.

ISO value. Signed 32 bit parameter divided in 2 ids.
Min value 0.
Max value 2147483647.

This is the recomended way to set the Video Mode using (130-134 Ids) as opposed to Id 50.

sets resolution and framerate. all the settings are in groups of bits as show from the smallest bit:

• 3 bits -> FPS: 0=24, 1=25, 2=30, 3=50, 4=60
• 1 bit -> M-Rate: 0=regular, 1=M-rate
• 3 bits -> Dimension: 0=NTSC, 1=PAL, 2=720, 3=1080, 4=2k, 5=2k DCI, 6=4k, 7=4k DCI
• 1 bit -> interlaced: 0=progressive, 1=interlaced
• 4 bits -> colourspace: 0=YUV

     // if videomode is a variable that represents the parameter
     videomode
     
     // to get the values from videomode parameter
     fps =            videomode & 0b0000000000000111
     mrate =         (videomode & 0b0000000000001000) >> 3
     resolution =    (videomode & 0b0000000001110000) >> 4
     interlased =    (videomode & 0b0000000010000000) >> 7
     colorspace =    (videomode & 0b0000111100000000) >> 8
     
     // to set the values to videomode parameter
     videomode = (fps | (mrate << 3) | (resolution << 4) | (interlased << 7) | (colorspace << 8)
     

FPS values are from first bit to the 3rd, M-rate is the 4th bit, resolution from the 5 fifth to the 7th and so.

This is a signed integer 32 bit value separated on the two folowings IDs. It sets the offset in pixels

Real Time Clock Time, it is divided between 2 Ids. Format: BCD - HHMMSSFF (UCT).
Real Time Clock Date, it is divided between 2 Ids. Format: BCD - YYYYMMDD.

This is a signed integer 32 bit value separated on the two folowings IDs. It sets the time offset in minutes

These parameters handle recording and playback control

Send This (Binary) command to a device that has a bluetooth module or it's bluetooth ready.

Each scan resut contains a name, a service UUID and a mac address. The Structure goes like this: 40 bytes for the camera name + 16 bytes for the bluetooth service + 6 bytes for the bluetooth mac address.

The C representation of the structure:

struct scanned_device {
    char short_name[40];
    uint8_t service[16];
    uint8_t mac[6];
} __attribute__((packed));

Sending this message will reset all previouly send, The message must contain the complete mapping for all 8 cameras when using mode 3.

The default Mode. The messages are forwarded difrectly to SDI, no limitation on available camera numbers, no automatic resending of the parameters, the last sent parameters cannot be requested. Only send Operation Mode set to 1. No Camera mapping is necessary.

Camera with Id numbers 1 to 8 will be supported. Last sent parameters will be maintained on memory, they will be periodically send and they can be requested. No Camera mapping is necessary.

Same as Mode 2. But the user defines the supported 8 camera numbers. Mapping of the cameras is required

Disables the camera communication and switches off the SDI shield. Only send Operation Mode set to 255. No Camera mapping is necessary.

8 cameras

//camera number    1   2   3   4   5   6   7   8
//camera id        10, 22, 54, 34, 67, 70, 55, 45 
uint16_t mapping1 = 10 | (67 << 8) // camera 1 and 5
uint16_t mapping2 = 22 | (70 << 8) // camera 2 and 6
uint16_t mapping3 = 54 | (55 << 8) // camera 3 and 7
uint16_t mapping4 = 34 | (45 << 8) // camera 4 and 8

3 cameras

//camera number    1   2   3 
//camera id        10, 22, 54
uint16_t mapping1 = 10 
uint16_t mapping2 = 22 
uint16_t mapping3 = 54 
uint16_t mapping4 = 0 

The following parameters controls cameras using the Blackmagic SDI and Bluetooth Camera Control Protocol. Most parameters are sent as 16 bits. bigger than 16 bits parameters use a byte delimiter '254' (0xFE) between every 16 bits of data. For example, consider each 'XX' is a byte of arbitrary data.

   ID       ID                                  ID       ID
...11 XX XX 0A XX XX FE XX XX FE XX XX FE XX XX 10 XX XX A3 XX XX ...

int16_t focus = 1000; 
uint8_t msg[100];
int i = 0;
// header here
msg[5] = 1 // ID
msg[6] = (focus >> 0) & 0xff; //Lowest byte
msg[7] = (focus >> 8) & 0xff; //Highest byte
// end of message here

int32_t iso = 25600; 
uint8_t msg[100];

// header here
msg[5 ] = 44 // ID
msg[6 ] = (iso >> 0) & 0xff; //Lowest byte
msg[7 ] = (iso >> 8) & 0xff; 
msg[8 ] = 254;
msg[9 ] = (iso >> 16) & 0xff;
msg[10] = (iso >> 24) & 0xff; //Highest byte
// end of message here

Video Mode has 5 subparameters that must be sent at once: fps, m-rate, dimensions, interlaced and colorspace

int16_t fps = 60; 
int16_t mRate = 1; 
int16_t dimensions = 3; 
int16_t inter = 0; 
int16_t colorspace = 0; 
uint8_t msg[100];

// header here
msg[5 ] = 30 // ID
msg[6 ] = (fps        >> 0) & 0xff; //Lowest byte
msg[7 ] = (fps        >> 8) & 0xff; //Highest byte
msg[8 ] = 254;
msg[9 ] = (mRate      >> 0) & 0xff; //Lowest byte
msg[10] = (mRate      >> 8) & 0xff; //Highest byte
msg[11] = 254;
msg[12] = (dimensions >> 0) & 0xff; //Lowest byte
msg[13] = (dimensions >> 8) & 0xff; //Highest byte
msg[14] = 254;
msg[15] = (inter      >> 0) & 0xff; //Lowest byte
msg[17] = (inter      >> 8) & 0xff; //Highest byte
msg[18] = 254;
msg[19] = (colorspace >> 0) & 0xff; //Lowest byte
msg[20] = (colorspace >> 8) & 0xff; //Highest byte
// end of message here

Lift Adjust has 4 subparameters that must be sent at once: red, green, blue and luma

const int fix16_unit = 2048;
float f_red = 0.5; 
float f_grn = -0.5; 
float f_blu = 1.0; 
float f_lum = 0;
// convert from float to int16
int16_t red = round(f_red * fix16_unit); 
int16_t grn = round(f_grn * fix16_unit); 
int16_t blu = round(f_blu * fix16_unit); 
int16_t lum = round(f_lum * fix16_unit); 
uint8_t msg[100];

// header here
msg[5 ] = 140 // ID
msg[6 ] = (red >> 0) & 0xff; //Lowest byte
msg[7 ] = (red >> 8) & 0xff; //Highest byte
msg[8 ] = 254;
msg[9 ] = (grn >> 0) & 0xff; //Lowest byte
msg[10] = (grn >> 8) & 0xff; //Highest byte
msg[11] = 254;
msg[12] = (blu >> 0) & 0xff; //Lowest byte
msg[13] = (blu >> 8) & 0xff; //Highest byte
msg[14] = 254;
msg[15] = (lum >> 0) & 0xff; //Lowest byte
msg[16] = (lum >> 8) & 0xff; //Highest byte
// end of message here

Location has 2 subparameters that must be sent at once: latitude and longitude

int64_t latitude = 6012839123383242; 
int64_t longitude = 5012839123383242; 
uint8_t msg[];

// header here
msg[5 ] = 133 // ID
msg[6 ] = (latitude  >> 0) & 0xff; //Lowest byte
msg[7 ] = (latitude  >> 8) & 0xff;
msg[8 ] = 254;
msg[9 ] = (latitude  >> 16) & 0xff;
msg[10] = (latitude  >> 24) & 0xff;
msg[11] = 254;
msg[12] = (latitude  >> 32) & 0xff;
msg[13] = (latitude  >> 40) & 0xff;
msg[14] = 254;
msg[15] = (latitude  >> 48) & 0xff;
msg[16] = (latitude  >> 56) & 0xff; //Highest byte
msg[17] = 254;
msg[18] = (longitude >> 0) & 0xff;  //Lowest byte
msg[19] = (longitude >> 8) & 0xff;
msg[20] = 254;
msg[21] = (longitude >> 16) & 0xff;
msg[22] = (longitude >> 24) & 0xff;
msg[23] = 254;
msg[24] = (longitude >> 32) & 0xff;
msg[25] = (longitude >> 40) & 0xff;
msg[26] = 254;
msg[27] = (longitude >> 48) & 0xff;
msg[28] = (longitude >> 56) & 0xff; //Highest byte
// end of message here

This message will set Project Name to "LEVITEZER". Project Name can have up to 29 characters.

uint8_t msg[100];
// header here
msg[5 ] = 208 // ID
msg[6 ] = 'L'; // first char
msg[7 ] = 'E';
msg[8 ] = 254; 
msg[9 ] = 'V';
msg[10] = 'I';
msg[11] = 254; 
msg[12] = 'T';
msg[13] = 'E';
msg[14] = 254; 
msg[15] = 'Z';
msg[16] = 'E';
msg[17] = 254; 
msg[18] = 'R'; // last char of the new name, the rest should be zeros
msg[19] = 0
msg[20] = 254; 
msg[21] = 0
msg[22] = 0
msg[23] = 254; 
msg[24] = 0
msg[25] = 0
msg[26] = 254; 
msg[27] = 0
msg[28] = 0
msg[29] = 254; 
msg[30] = 0
msg[31] = 0
msg[32] = 254; 
msg[33] = 0
msg[34] = 0
msg[35] = 254; 
msg[36] = 0
msg[37] = 0
msg[38] = 254; 
msg[39] = 0
msg[40] = 0
msg[41] = 254; 
msg[42] = 0
msg[43] = 0
msg[44] = 254; 
msg[45] = 0
msg[46] = 0
msg[47] = 254; 
msg[48] = 0; // 29th char 
msg[49] = 0; // extra char to keep the message structure even
// end of message here

Usually a BMD camera can be given an Id in the 1-99 range. This is the id that must be used on the Header "device id" field. A special case is a Bluetooth camera. Messages sent to bluetooth cameras use id 100.

-32768 | 32767

Simple camera record trigger. will record for 5 seconds

import socket
import array
import time
UDP_IP = "192.168.137.222"
UDP_PORT = 50505

global counter
counter = 0

#To send to a bluetooth camera we use id 100.
#To use SDI camera id must be 1-99 and it has to be set on the camera menu.
CAMERA_ID = 100

# parameter id
TRANSPORT_MODE = 142

# values
START_RECORDING = 2
STOP_RECORDING = 0

def createRecordMsg(value):
    global counter


    deviceType = 2
    endOfMessage = 0
    message = array.array('B', [0xff, 0xff, 0xff, CAMERA_ID, deviceType, counter,
            TRANSPORT_MODE, value, 0,
            endOfMessage, 0, 0])

    #calculate checksum starting in 3rd index
    checksum = 0
    for i in range(3, len(message)):
        checksum = (checksum + message[i]) & 0xFFFF # 16 bit overflow 
   
   #set the 16bit checksum at the end of the array
    message[-2] = checksum & 0xff
    message[-1] = checksum >> 8

    # add to the counter
    counter = (counter+1) & 127  # counter overflows after 127 (7 bit counter)

    return message.tostring()


# create socket
print "UDP target IP:", UDP_IP
print "UDP target port:", UDP_PORT
sock = socket.socket(socket.AF_INET,socket.SOCK_DGRAM)

# Record for 5 seconds
print "Recording..."
sock.sendto(createRecordMsg(START_RECORDING), (UDP_IP, UDP_PORT))
time.sleep(5)
print "stopping..."
sock.sendto(createRecordMsg(STOP_RECORDING), (UDP_IP, UDP_PORT))

This example can be used to build a joytick control, feeding x and y axis values in a 50Hz - 100Hz rate

import socket
import array
import time
from math import sin
UDP_IP = "192.168.137.222"
UDP_PORT = 50505
#ids
JOYSTICK_TYPE = 1
SPEED_X = 2
SPEED_Y = 3
GIMBAL_MODE = 32
# values
JOYSTICK_WII_TYPE = 1
MODE_FIX_FRAME = 0
MODE_GEOPOINT = 1
MODE_NONE = 2

SPEED_UNIT = 0.1220740379 #degree/sec

global counter
counter = 0

def calc_checksum(arr):
        global counter

        #calculate checksum starting in 3rd index
        checksum = 0
        aSum = 0
        for i in range(3, len(arr)):
                aSum += arr[i]
        #set the 16bit checksum at the end of the array
        checksum = aSum & 0xffff  # simulate 16bit overflow
        arr[-2] = checksum & 0xff
        arr[-1] = checksum >> 8

        # add to the counter
        counter += 1
        counter &= 0x7f # simulate 7bit overflow (counter is 7bits)

def send_mode(mode):
        """Gimbal message: configure mode"""
        global counter
        message = array.array('B', [0xff, 0xff, 0xff, 101, 1, counter,
                        GIMBAL_MODE, mode, 0,
                        0, 0, 0])
        calc_checksum(message)


        return message.tostring()

def send_speed(x, y):
        """ Joystick message: """
        global counter
        x = int(x)
        y = int(y)        
        message = array.array('B', [0xff, 0xff, 0xff, 1, 3, counter,
                        JOYSTICK_TYPE, JOYSTICK_WII_TYPE, 0,
                        SPEED_X, x & 0xff, x >> 8 & 0xff,
                        SPEED_Y, y & 0xff, y >> 8 & 0xff,
                        0, 0, 0]) 

        calc_checksum(message)

        return message.tostring()


# create socket
print "UDP target IP:", UDP_IP
print "UDP target port:", UDP_PORT
sock = socket.socket(socket.AF_INET,socket.SOCK_DGRAM)

# set mode
sock.sendto(send_mode(MODE_FIX_FRAME), (UDP_IP, UDP_PORT))

# move continuously to same speed
print "Moving gimbal yaw to 5deg/s and pitch to -1 deg/s"
for i in range(1000):
        x = round(5.0/SPEED_UNIT)  #   5 deg/s
        y = round(1.0/SPEED_UNIT) #  -1 deg/s
        sock.sendto(send_speed(x, y), (UDP_IP, UDP_PORT))
        time.sleep(0.02) # speed messages should be sent 50Hz-100Hz

The following python 2.7 script moves the gimbal several times on the yaw axis, sending the control messages trough UDP using the following gimbal parameters:

• ROLL
• PICH
• YAW
• SPEED_ROLL
• SPEED_PICH
• SPEED_YAW
• CONTROL_MODE

import socket
import array
import time
UDP_IP = "192.168.137.222"
UDP_PORT = 50505

global counter
counter = 0

def getAngleMessage(angle):
    global counter
    if angle > 720 or angle < -720:
        print "no valid angle range"
        return ""

    # convert angle to raw value
    rawYaw = int(angle / 0.02197265625)

    gimbalId = 101
    gimbalType = 1
    mode = 2
    endOfMessage = 0
    message = array.array('B', [0xff, 0xff, 0xff, gimbalId, gimbalType, counter,
            4, 0, 0, 5, 0, 0, 6, rawYaw & 0xff, rawYaw >> 8, 10, 0, 0, 11, 0, 0, 12, 255, 3, 16, mode, 0,
            endOfMessage, 0, 0])

    #calculate checksum starting in 3rd index
    checksum = 0
    for i in range(3, len(message)):
        checksum = (checksum + message[i]) & 0xFFFF # 16 bit overflow 
   
   #set the 16bit checksum at the end of the array
    message[-2] = checksum & 0xff
    message[-1] = checksum >> 8

    # add to the counter
    counter = (counter+1) & 127  # counter overflows after 127 (7 bit counter)

    return message.tostring()


# create socket
print "UDP target IP:", UDP_IP
print "UDP target port:", UDP_PORT
sock = socket.socket(socket.AF_INET,socket.SOCK_DGRAM)

# move to 0
sock.sendto(getAngleMessage(0), (UDP_IP, UDP_PORT))
# move to 90
time.sleep(3)
sock.sendto(getAngleMessage(90), (UDP_IP, UDP_PORT))
# move to 180
time.sleep(2)
sock.sendto(getAngleMessage(180), (UDP_IP, UDP_PORT))
# move to 270
time.sleep(2)
sock.sendto(getAngleMessage(270), (UDP_IP, UDP_PORT))

This is not a functional example. But just an example of how moving the gimbal on Geopoint mode is done. Language is C.

There are 8 commands to be send defined below, the device type to use when sending the message is Controller (id 3) not Gimbal (id 1). The device id can be anything in (1-253) joystic_x_input_here and joystic_y_input_here are your inputs

// commands
int JOYSTICK_TYPE          = 1;
int JOYSTICK0_X            = 2;
int JOYSTICK0_Y            = 3;
int JPITCH                 = 31;
int JYAW                   = 32;
int JDELTA_PITCH           = 34;
int JDELTA_YAW             = 35;
int JDELTA_TIME            = 36;
// device type
int CONTROLLER_TYPE = 3
// variables
double yaw = 0;
double pitch = 0;
double roll = 0;
uint32_t sampleTime = 0;
uint32_t startingSampleTime = 0;
uint64_t mainTimer = 0;
uint8_t levitezer_counter;
uint8_t messageOut[700];
double delta_yaw = 0;
double delta_pitch = 0;
// Note:  micros() is function that returs time since boot in microseconds

while(true){
// the following happens every 10 ms
    if(micros() - mainTimer > 10000){
        yawSpeed =   ((joystic_x_input_here));    // from -32767 to 32768
        pitchSpeed = ((joystic_y_input_here));    // from -32767 to 32768

        /* Angle and time calculation */
        sampleTime = micros() - startingSampleTime;
        //               speed         time(microsec)                speed unit
        delta_yaw =   yawSpeed * (sampleTime/1000000.0) * 0.1220740379 ;
        delta_pitch = pitchSpeed * (sampleTime/1000000.0) * 0.1220740379 ;
        yaw   = yaw +     delta_yaw ;
        pitch = pitch +   delta_pitch;
        startingSampleTime = micros();
        int16_t yawSpeedInt = round(yawSpeed);
        int16_t pitchSpeedInt = round(pitchSpeed);
        int16_t yawInt = round((yaw/0.02197265625));
        int16_t pitchInt = round((pitch/0.02197265625));
        int16_t delta_yawInt = round(delta_yaw*5000.0);
        int16_t delta_pitchInt = round(delta_pitch*5000.0);

        /* Msg sending, sendLevitezerMessage16 creates the levitezer message from ids and values */
        uint8_t ids   [8] {JOYSTICK_TYPE, JOYSTICK0_X, JOYSTICK0_Y,  JPITCH, JYAW,     JDELTA_PITCH,       JDELTA_YAW,    JDELTA_TIME};
        int16_t values[8] {1,           yawSpeedInt, pitchSpeedInt,  pitchInt, yawInt, delta_pitchInt, delta_yawInt, (int16_t)sampleTime};
        //                    id(any), device_type                          message size
        sendLevitezerMessage16(2, CONTROLLER_TYPE, ids, ((uint16_t*)values),     8);
    }
}