Создаём программу дистанционного управления роботом EV3 с заводской прошивкой

Brick brick = new Brick(new UsbCommunication());

//Поворачиваем мотор, подключенный к порту A, 5 сек. с мощностью 50%.
await brick.DirectCommand.TurnMotorAtPowerAsync(OutputPort.A, 50, 5000);

//Устанавливаем датчику касания режим возврата количества нажатий.
brick.Ports[InputPort.One].SetMode(TouchMode.Bumps);

//Выводим значение датчика, подключенного к порту 1.
Debug.WriteLine(brick.Ports[InputPort.One].SIValue);

//Подписываемся на событие.
brick.BrickChanged += OnBrickChanged;
 
...
 
void OnBrickChanged(object sender, BrickChangedEventArgs e)
{
    //Выводим значение датчика, подключенного к порту 1.
    Debug.WriteLine(e.Ports[InputPort.One].SIValue);
}

var ev3 = new Brick<Sensor,Sensor,Sensor,Sensor>("usb");
ev3.Connection.Open();

//Включаем мотор A.
ev3.MotorA.On(50);
//Ждём 3 секунды.
System.Threading.Thread.Sleep(3000); 
//Выключаем мотор A.
ev3.MotorA.Off();

//Задаём свойства транспортного средства.
ev3.Vehicle.LeftPort = MotorPort.OutA;
ev3.Vehicle.RightPort = MotorPort.OutD;
ev3.Vehicle.ReverseLeft = false;
ev3.Vehicle.ReverseRight = false;
//Едем вперёд.
ev3.Vehicle.Forward(50);
System.Threading.Thread.Sleep(3000); 
//Вращаемся на месте вправо.
ev3.Vehicle.SpinRight(50);
System.Threading.Thread.Sleep(3000);
//Поворачиваем налево
ev3.Vehicle.TurnLeftForward(50, 50);
System.Threading.Thread.Sleep(3000);
//Останавливаемся.
ev3.Vehicle.Off();

ev3.Sensor1 = new IRSensor(IRMode.Proximity); 
ev3.Sensor2 = new TouchSensor(); 
ev3.Sensor3 = new ColorSensor(ColorMode.Color); 
ev3.Sensor4 = new GyroSensor(GyroMode.Angle); 
Console.WriteLine("S1: " + ev3.Sensor1.ReadAsString()); 
Console.WriteLine("S2: " + ev3.Sensor2.ReadAsString()); 
Console.WriteLine("S3: " + ev3.Sensor3.ReadAsString()); 
Console.WriteLine("S4: " + ev3.Sensor4.ReadAsString());

var ev3 = new Brick<TouchSensor,ColorSensor,IRSensor,Sensor> ("usb"); 
ev3.Connection.Open();
ev3.Sensor1.Mode = TouchMode.Count;
ev3.Sensor2.Mode = ColorMode.Color;
ev3.Sensor3.Mode = IRMode.Seek;
ev3.Sensor1.Reset();
Console.WriteLine("S1: " + ev3.Sensor1.ReadAsString());
Color color = ev3.Sensor2.ReadColor();
int value = ev3.Sensor3.Read();

ev3.Mailbox.Send("mailbox1", input, false);

ev3.MotorA.DaisyChainLayer = DaisyChainLayer.First; 
ev3.MotorA.On(50); 
Thread.Sleep(2000); 
ev3.MotorA.Off(); 
ev3.Sensor1.DaisyChainLayer = DaisyChainLayer.Second; 
Console.WriteLine(ev3.Sensor1.ReadAsString()); 
ev3.Connection.Close();

public void onButtonClick(View v) throws IOException, InterruptedException {
    //Ищем EV3 среди подключенных устройств по имени (Bluetooth должен быть включён).
    BluetoothDevice ev3device = null;
    for (BluetoothDevice device : BluetoothAdapter.getDefaultAdapter().getBondedDevices()) {
        if (device.getName().compareTo("EV3") == 0) {
            ev3device = device;
            //Выдаём сообщение, что EV3 найден.
            Toast.makeText(getApplicationContext(), "EV3 найден :)", Toast.LENGTH_LONG).show();
            break;
        }
    }
    if (ev3device != null) {
        //Подключаемся к EV3 (требуется разрешение BLUETOOTH).
        BluetoothSocket socket = ev3device.createRfcommSocketToServiceRecord(
                UUID.fromString("00001101-0000-1000-8000-00805F9B34FB"));
        socket.connect();
        try {
            //Отправляем сообщение с командой на проигрывание звука.
            socket.getOutputStream().write(new byte[]{14, 0, 0, 0, -128, 0, 0, -108, 1, 2, -126, -24, 3, -126, -24, 3});
        }
        finally {
            //Отключаемся от EV3.
            socket.close();
        }
    }
}

//Перед отправкой сообщения не забудьте приставить к датчику какую-нибудь цветную деталь, допустим, красную.
//Отправляем сообщение с командой на измерение цвета: 0D000100000400991D000000020160
socket.getOutputStream().write(new byte[]{13, 0, 1, 0, 0, 4, 0, -103, 29, 0, 0, 0, 2, 1, 96});
//Считываем первые два байта, чтобы узнать размер ответного сообщения.
//В случае успешного выполнения команды в массиве будет: 0700
//Т.е. ещё семь байт.
byte[] replySizeBytes = new byte[2];
socket.getInputStream().read(replySizeBytes, 0, 2);
//Перекладываем число из массива в переменную (первый байт - младший, второй - старший).
int replySize = (replySizeBytes[0] < 0 ? (int)replySizeBytes[0] + 256 : (int)replySizeBytes[0])
        | ((replySizeBytes[1] < 0 ? (int)replySizeBytes[1] + 256 : (int)replySizeBytes[1]) << 8);
//Создаём массив нужного размера.
byte[] replyBytes = new byte[replySize];
//Считываем остальную часть сообщения в массив.
socket.getInputStream().read(replyBytes, 0, replySize);
//На выходе получим следующий массив: 0100020000A040
//Первые два байта (0x01 и 0x00) - это номер сообщения, третий байт (0x02) - это тип результата, остальные байты – значения переменных.
if (replyBytes[2] == 2) //Если результат 2, значит команда выполнена успешно.
{
    //Результат будем считывать с помощью класса ByteBuffer.
    ByteBuffer byteBuffer = ByteBuffer.wrap(replyBytes);
    //Устанавливаем порядок байтов (первый байт - младший, второй - старший).
    byteBuffer.order(ByteOrder.LITTLE_ENDIAN);
    //В последних четырёх байтах результат - это число с плавающей запятой (тип float, порядок байт Little Endian).
    //Цвет указывается в пределах 0 - 8.
    float f = byteBuffer.getFloat(3);
    //Заносим в строку название цвета.
    String color = "";
    switch ((int)f)
    {
        case 0: color = "нет цвета"; break;
        case 1: color = "чёрный"; break;
        case 2: color = "синий"; break;
        case 3: color = "зелёный"; break;
        case 4: color = "жёлтый"; break;
        case 5: color = "красный"; break;
        case 6: color = "белый"; break;
        case 7: color = "коричевый"; break;
    }
    //Выводим сообщение с результатом.
    //Для красного цвета, на экране появится сообщение "Цвет: 5.0 - красный".
    Toast.makeText(getApplicationContext(),
            "Цвет: " + Float.toString(f) + " - " + color,
            Toast.LENGTH_LONG).show();
}

//Записывает unsigned byte.
private void writeUByte(OutputStream _stream, int _ubyte) throws IOException {
    _stream.write(_ubyte > Byte.MAX_VALUE ? _ubyte - 256 : _ubyte);
}
 
//Записывает byte.
private void writeByte(OutputStream _stream, byte _byte) throws IOException {
    _stream.write(_byte);
}
 
//Записывает unsigned short.
private void writeUShort(OutputStream _stream, int _ushort) throws IOException {
    writeUByte(_stream, _ushort & 0xFF);
    writeUByte(_stream, (_ushort >> 8) & 0xFF);
}
 
//Записывает short.
private void writeShort(OutputStream _stream, short _short) throws IOException {
    byte bytes[] = new byte[2];
    ByteBuffer byteBuffer = ByteBuffer.wrap(bytes);
    byteBuffer.order(ByteOrder.LITTLE_ENDIAN);
    byteBuffer.putShort(_short);
    _stream.write(bytes);
}
 
//Записывает команду.
private void writeCommand(OutputStream _stream, int opCode) throws IOException {
    writeUByte(_stream, opCode);
}
 
//Записывает команду и специфический параметр команды.
private void writeCommand(OutputStream _stream, int opCode, int cmd) throws IOException {
    writeUByte(_stream, opCode);
    writeUByte(_stream, cmd);
}
 
//Записывает количество зарезервированных байт для глобальных и локальных переменных.
private void writeVariablesAllocation(OutputStream _stream, int globalSize, int localSize) throws IOException {
    writeUByte(_stream, globalSize & 0xFF);
    writeUByte(_stream, ((globalSize >> 8) & 0x3) | ((localSize << 2) & 0xFC));
}
 
//Записывает индекс глобальной переменной.
private void writeGlobalIndex(OutputStream _stream, int index) throws IOException {
    if (index <= 31)
        writeUByte(_stream, index | 0x60);
    else if (index <= 255) {
        writeUByte(_stream, 0xE1);
        writeUByte(_stream, index);
    }
    else if (index <= 65535) {
        writeUByte(_stream, 0xE2);
        writeUShort(_stream, index);
    }
    else {
        writeUByte(_stream, 0xE3);
        writeUByte(_stream, index & 0xFF);
        writeUByte(_stream, (index >> 8) & 0xFF);
        writeUByte(_stream, (index >> 16) & 0xFF);
        writeUByte(_stream, (index >> 24) & 0xFF);
    }
}
 
//Записывает параметр с типом unsigned byte со значением в интервале 0-31 с помощью короткого формата.
private void writeParameterAsSmallByte(OutputStream _stream, int value) throws IOException {
    if (value < 0 && value > 31)
        throw new IllegalArgumentException("Значение должно быть в интервале от 0 до 31.");
    writeUByte(_stream, value);
}
 
//Записывает параметр с типом unsigned byte.
private void writeParameterAsUByte(OutputStream _stream, int value) throws IOException {
    if (value < 0 && value > 255)
        throw new IllegalArgumentException("Значение должно быть в интервале от 0 до 255.");
    writeUByte(_stream, 0x81);
    writeUByte(_stream, value);
}
 
//Записывает параметр с типом byte.
private void writeParameterAsByte(OutputStream _stream, int value) throws IOException {
    if (value < Byte.MIN_VALUE && value > Byte.MAX_VALUE)
        throw new IllegalArgumentException("Значение должно быть в интервале от "
                + Byte.MIN_VALUE + " до " + Byte.MAX_VALUE + ".");
    writeUByte(_stream, 0x81);
    writeByte(_stream, (byte)value);
}
 
//Записывает параметр с типом unsigned short.
private void writeParameterAsUShort(OutputStream _stream, int value) throws IOException {
    if (value < 0 && value > 65535)
        throw new IllegalArgumentException("Значение должно быть в интервале от 0 до 65535.");
    writeUByte(_stream, 0x82);
    writeUShort(_stream, value);
}
 
//Записывает параметр с типом short.
private void writeParameterAsShort(OutputStream _stream, int value) throws IOException {
    if (value < Short.MIN_VALUE && value > Short.MAX_VALUE)
        throw new IllegalArgumentException("Значение должно быть в интервале от "
                + Short.MIN_VALUE + " до " + Short.MAX_VALUE + ".");
    writeUByte(_stream, 0x82);
    writeShort(_stream, (short)value);
}
 
//Записывает параметр с типом int.
private void writeParameterAsInteger(OutputStream _stream, int value) throws IOException {
    writeUByte(_stream, 0x83);
    writeUByte(_stream, value & 0xFF);
    writeUByte(_stream, (value >> 8) & 0xFF);
    writeUByte(_stream, (value >> 16) & 0xFF);
    writeUByte(_stream, (value >> 24) & 0xFF);
}
 
//Читает unsigned byte.
private int readUByte(InputStream _stream) throws IOException {
    byte bytes[] = new byte[1];
    _stream.read(bytes);
    return bytes[0] < 0 ? (int)bytes[0] + 256 : (int)bytes[0];
}
 
//Читает unsigned short.
private int readUShort(InputStream _stream) throws IOException {
    return readUByte(_stream) | (readUByte(_stream) << 8);
}

//Записываем сообщение в память (размер посчитаем потом).
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
//Записываем номер сообщения.
writeUShort(byteArrayOutputStream, 0);
//Записываем тип команды (0x80 - прямая команда, ответ не требуется).
writeUByte(byteArrayOutputStream, 0x80);
//Записываем размер зарезервированного места для переменных (здесь ничего не резервируется).
writeVariablesAllocation(byteArrayOutputStream, 0, 0);
//Записываем код команды.
writeCommand(byteArrayOutputStream, 0x94/*opSound*/, 0x01/*TONE*/);
//Остальные параметры команды.
writeParameterAsSmallByte(byteArrayOutputStream, 2);//Громкость звука.
writeParameterAsShort(byteArrayOutputStream, 1000);//Частота звука.
writeParameterAsShort(byteArrayOutputStream, 1000);//Длительность в мс.
//Отправляем сообщение на EV3.
OutputStream outputStream = socket.getOutputStream();
//Сначала отправляем размер сообщения.
writeUShort(outputStream, byteArrayOutputStream.size());
//Затем отправляем само сообщение.
byteArrayOutputStream.writeTo(outputStream);

//Записываем сообщение в память (размер посчитаем потом).
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
//Записываем номер сообщения.
writeUShort(byteArrayOutputStream, 1);
//Записываем тип команды (прямая команда, требуется ответ).
writeUByte(byteArrayOutputStream, 0x00);
//Записываем количество зарезервированных байт для переменных (4 байта для глобальной переменной).
writeVariablesAllocation(byteArrayOutputStream, 4, 0);
//Записываем код команды.
writeCommand(byteArrayOutputStream, 0x99/*opInput_Device*/, 0x1D/*READY_SI*/);
//Записываем номер модуля EV3.
writeParameterAsSmallByte(byteArrayOutputStream, 0);
//Записываем номер порта (1-й порт).
writeParameterAsSmallByte(byteArrayOutputStream, 0);
//Записываем тип устройства (0 – означает, что тип менять не нужно).
writeParameterAsSmallByte(byteArrayOutputStream, 0);
//Записываем режим работы датчика (чтение цвета).
writeParameterAsSmallByte(byteArrayOutputStream, 2);
//Записываем количество возвращаемых переменных (одна переменная).
writeParameterAsSmallByte(byteArrayOutputStream, 1);
//Записываем индекс глобальной переменной.
writeGlobalIndex(byteArrayOutputStream, 0);
//Отправляем сообщение на EV3.
OutputStream outputStream = socket.getOutputStream();
//Сначала отправляем размер сообщения.
writeUShort(outputStream, byteArrayOutputStream.size());
//Затем отправляем само сообщение.
byteArrayOutputStream.writeTo(outputStream);

//Записываем сообщение в память (размер посчитаем потом).
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
//Записываем номер сообщения.
writeUShort(byteArrayOutputStream, 2);
//Записываем тип команды (прямая команда, ответ не требуется).
writeUByte(byteArrayOutputStream, 0x80);
//Записываем количество зарезервированных байт для переменных (здесь ничего не резервируется).
writeVariablesAllocation(byteArrayOutputStream, 0, 0);
//Записываем код команды.
writeCommand(byteArrayOutputStream, 0xAE/*opOutput_Step_Speed*/);
//Записываем номер модуля EV3.
writeParameterAsSmallByte(byteArrayOutputStream, 0);
//Записываем номера портов (порты B и C).
writeParameterAsSmallByte(byteArrayOutputStream, 0x02 | 0x04);
//Записываем мощность (от -100 до 100).
writeParameterAsByte(byteArrayOutputStream, 50);
//Записываем, сколько оборотов двигатель будет разгоняться (0 - разгоняться будет моментально).
writeParameterAsInteger(byteArrayOutputStream, 0);
//Записываем, сколько оборотов двигатель будет крутиться на полной скорости (2,5 оборота, т.е. 900 градусов).
writeParameterAsInteger(byteArrayOutputStream, 900);
//Записываем, сколько оборотов двигатель будет замедляться (0,5 оборота, т.е. 180 градусов).
writeParameterAsInteger(byteArrayOutputStream, 180);
//Записываем, нужно ли тормозить в конце (1 - тормозить, 0 - не тормозить).
writeParameterAsUByte(byteArrayOutputStream, 1);
//Отправляем сообщение на EV3.
OutputStream outputStream = socket.getOutputStream();
//Сначала отправляем размер сообщения.
writeUShort(outputStream, byteArrayOutputStream.size());
//Затем отправляем само сообщение.
byteArrayOutputStream.writeTo(outputStream);

//Записываем сообщение в память (размер посчитаем потом).
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
//Записываем номер сообщения.
writeUShort(byteArrayOutputStream, 3);
//Записываем тип команды (прямая команда, требуется ответ).
writeUByte(byteArrayOutputStream, 0x00);
//Записываем количество зарезервированных байт для переменных
//(здесь резервируется место для 16-ти однобайтовых переменных).
writeVariablesAllocation(byteArrayOutputStream, 16, 0);
//Записываем команды для всех датчиков и моторов.
for (int i = 0; i < 8; i++) {
    //Записываем код команду.
    writeCommand(byteArrayOutputStream, 0x99/*opInput_Device*/, 0x05/*GET_TYPEMODE*/);
    //Записываем номер модуля EV3.
    writeParameterAsSmallByte(byteArrayOutputStream, 0);
    //Записываем номер порта (0x00-0x03 - порты 1-4, 0x10-0x13 - порты A-B).
    writeParameterAsSmallByte(byteArrayOutputStream, i < 4 ? i : (i + 12));
    //Записываем индекс переменной, куда будет сохранён тип устройства ввода.
    writeGlobalIndex(byteArrayOutputStream, i * 2);
    //Записываем индекс переменной, куда будет сохранён режим измерения.
    writeGlobalIndex(byteArrayOutputStream, i * 2 + 1);
}
//Отправляем сообщение на EV3.
OutputStream outputStream = socket.getOutputStream();
//Сначала отправляем размер сообщения.
writeUShort(outputStream, byteArrayOutputStream.size());
//Затем отправляем само сообщение.
byteArrayOutputStream.writeTo(outputStream);
 
//Считываем ответ.
InputStream inputStream = socket.getInputStream();
//Считываем первые два байта, чтобы узнать размер ответного сообщения.
int replySize = readUShort(inputStream);
//Создаём массив нужного размера.
byte[] replyBytes = new byte[replySize];
//Считываем остальную часть сообщения в массив.
inputStream.read(replyBytes, 0, replySize);
//Первые два байта (0x03 и 0x00) - это номер сообщения, третий байт (0x02) - это тип результата.
if (replyBytes[2] == 2) { //Если результат 2, значит команда выполнена успешно.
    //Смотрим, что к какому порту подключено.
    String portInfo = "";
    for (int i = 0; i < 8; i++) {
        switch (i) {
            case 0: portInfo += "1: "; break;
            case 1: portInfo += "2: "; break;
            case 2: portInfo += "3: "; break;
            case 3: portInfo += "4: "; break;
            case 4: portInfo += "A: "; break;
            case 5: portInfo += "B: "; break;
            case 6: portInfo += "C: "; break;
            case 7: portInfo += "D: "; break;
        }
        int type = replyBytes[3 + i * 2];
        int mode = replyBytes[4 + i * 2];
        switch (type) {
            case 7: {
                portInfo += "большой мотор EV3, ";
                switch (type) {
                    case 0: portInfo += "градусы; "; break;
                    case 1: portInfo += "обороты; "; break;
                    case 2: portInfo += "мощность; "; break;
                }
                break;
            }
            case 8: {
                portInfo += "средний мотор EV3, ";
                switch (type) {
                    case 0: portInfo += "градусы; "; break;
                    case 1: portInfo += "обороты; "; break;
                    case 2: portInfo += "мощность; "; break;
                }
                break;
            }
            case 16: {
                portInfo += "датчик касания EV3, ";
                switch (type) {
                    case 0: portInfo += "нажат; "; break;
                    case 1: portInfo += "щелчок; "; break;
                }
                break;
            }
            case 29: {
                portInfo += "датчик цвета EV3, ";
                switch (type) {
                    case 0: portInfo += "отражённый свет; "; break;
                    case 1: portInfo += "освещённость; "; break;
                    case 2: portInfo += "цвет; "; break;
                }
                break;
            }
            case 30: {
                portInfo += "ультразвуковой датчик EV3, ";
                switch (type) {
                    case 0: portInfo += "сантиметры; "; break;
                    case 1: portInfo += "дюймы; "; break;
                    case 2: portInfo += "обнаружение; "; break;
                }
                break;
            }
            case 32: {
                portInfo += "гироскоп EV3, ";
                switch (type) {
                    case 0: portInfo += "угол; "; break;
                    case 1: portInfo += "скорость; "; break;
                }
                break;
            }
            case 0xff: {
                //Неизвестный датчик или статус.
                portInfo += "неизвестно; ";
                break;
            }
            case 0x7e: {
                //В порт ничего не подключено.
                portInfo += "порт пустой; ";
                break;
            }
            case 0x7d: {
                //Порт инициализируется.
                portInfo += "инициализируется; ";
                break;
            }
            case 0x7f: {
                //Датчик подключен в порт моторов или наоборот.
                portInfo += "неправильное подключение; ";
                break;
            }
        }
    }
    Toast.makeText(getApplicationContext(),
            "Информация о датчиках и моторах: " + portInfo,
            Toast.LENGTH_LONG).show();
}