// Пины для имитации выходов энкодера
#define pinA 8
#define pinB 9
#define pinZ 10
#define pinR 11                                          // Канал для реверса направления

const int pulsesPerRevolution = 5000;                    // Количество импульсов на один оборот (например, 5000 импульсов)

int pulseCount = 0;                                      // Счётчик импульсов для канала Z

void setup() {

  pinMode(pinA, OUTPUT);
  pinMode(pinB, OUTPUT);
  pinMode(pinZ, OUTPUT);

  digitalWrite(pinA, LOW);
  digitalWrite(pinB, LOW);
  digitalWrite(pinZ, LOW);
}

void loop() {

   generateEncoderSignals();                               // Генерация импульсов на каналах A и B

  if (pulseCount >= pulsesPerRevolution) {
    pulseCount = 0;                                        // Сброс после полного оборота
    generateZSignal();                                     // Генерация сигнала Z
  }

  delay(55);                                               // Настроить для регулировки скорости
}

void generateEncoderSignals() {
  int delays = 55;
  if (digitalRead(pinR)) {                                    // Вращение по часовой стрелке (A опережает B)
    digitalWrite(pinA, HIGH);
    delay(delays);                                          // Половина периода сигнала
    digitalWrite(pinB, HIGH);
    delay(delays);
    digitalWrite(pinA, LOW);
    delay(delays);
    digitalWrite(pinB, LOW);
  } else {                                                  // Вращение против часовой стрелки (B опережает A)
    digitalWrite(pinB, HIGH);
    delay(delays);                                          // Половина периода сигнала
    digitalWrite(pinA, HIGH);
    delay(delays);
    digitalWrite(pinB, LOW);
    delay(delays);
    digitalWrite(pinA, LOW);
  }

  pulseCount++;                                             // Увеличение счётчика импульсов
}

void generateZSignal() {                                    // Имитация индекса (Z) — один импульс на оборот
  digitalWrite(pinZ, HIGH);
  delay(10);                                               
  digitalWrite(pinZ, LOW);
}

package vgc.cyberex.encoder_app;

import android.annotation.SuppressLint;
import android.bluetooth.BluetoothAdapter;
import android.bluetooth.BluetoothDevice;
import android.bluetooth.BluetoothGatt;
import android.bluetooth.BluetoothGattCallback;
import android.bluetooth.BluetoothGattCharacteristic;
import android.bluetooth.BluetoothGattDescriptor;
import android.bluetooth.BluetoothGattService;
import android.bluetooth.BluetoothManager;
import android.content.Context;
import android.content.pm.PackageManager;
import android.util.Log;

import androidx.core.app.ActivityCompat;

import java.nio.charset.StandardCharsets;
import java.util.Objects;
import java.util.UUID;

import vgc.cyberex.encoder_app.service.DataCallback;

public class BLEManager {

    private static final UUID SERVICE_UUID = UUID.fromString("4fafc201-1fb5-459e-8fcc-c5c9c331914b");
    private static final UUID CHARACTERISTIC_UUID = UUID.fromString("beb5483e-36e1-4688-b7f5-ea07361b26a8");

    private final Context context;
    private BluetoothAdapter bluetoothAdapter;
    private BluetoothGatt bluetoothGatt;
    private BluetoothGattCharacteristic characteristic;
    private boolean connected;
    private boolean presend;
    private final DataCallback callback;

    public BLEManager(Context context, DataCallback callback) {
        this.context = context;
        this.callback = callback;
        BluetoothManager bluetoothManager = (BluetoothManager) context.getSystemService(Context.BLUETOOTH_SERVICE);
        if (bluetoothManager != null) {
            bluetoothAdapter = bluetoothManager.getAdapter();
        }
    }


    public void connectToDevice(String mac) {
        if (bluetoothAdapter == null || !bluetoothAdapter.isEnabled()) {
            return;
        }
        if (!Objects.equals(mac, "00:00:00:00:00")) {
            BluetoothDevice device = bluetoothAdapter.getRemoteDevice(mac);
            if (ActivityCompat.checkSelfPermission(context, android.Manifest.permission.BLUETOOTH_CONNECT) != PackageManager.PERMISSION_GRANTED) {
                // TODO: Consider calling
                //    ActivityCompat#requestPermissions
                // here to request the missing permissions, and then overriding
                //   public void onRequestPermissionsResult(int requestCode, String[] permissions,
                //                                          int[] grantResults)
                // to handle the case where the user grants the permission. See the documentation
                // for ActivityCompat#requestPermissions for more details.
                return;
            }
            bluetoothGatt = device.connectGatt(context, false, gattCallback);
        }
    }

    private final BluetoothGattCallback gattCallback = new BluetoothGattCallback() {

        @Override
        public void onConnectionStateChange(BluetoothGatt gatt, int status, int newState) {
            super.onConnectionStateChange(gatt, status, newState);
            if (newState == BluetoothGatt.STATE_CONNECTED) {
                connected = true;
                callback.connectStatusBT(connected);
                if (ActivityCompat.checkSelfPermission(context, android.Manifest.permission.BLUETOOTH_CONNECT) != PackageManager.PERMISSION_GRANTED) {
                    // TODO: Consider calling
                    //    ActivityCompat#requestPermissions
                    // here to request the missing permissions, and then overriding
                    //   public void onRequestPermissionsResult(int requestCode, String[] permissions,
                    //                                          int[] grantResults)
                    // to handle the case where the user grants the permission. See the documentation
                    // for ActivityCompat#requestPermissions for more details.
                    return;
                }
                gatt.discoverServices();
            } else if (newState == BluetoothGatt.STATE_DISCONNECTED) {
                connected = false;
                callback.connectStatusBT(connected);
            }
        }

        @Override
        public void onServicesDiscovered(BluetoothGatt gatt, int status) {
            if (status == BluetoothGatt.GATT_SUCCESS) {
                BluetoothGattService service = gatt.getService(SERVICE_UUID);
                if (service != null) {
                    characteristic = service.getCharacteristic(CHARACTERISTIC_UUID);
                    if (characteristic != null) {
                        //readCharacteristic(characteristic);
                        //setCharacteristicNotification(characteristic,true);
                        process_time(characteristic);
                    }
                }
            }
        }

        @SuppressLint("MissingPermission")
        @Override
        public void onCharacteristicRead(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic, int status) {
            if (status == BluetoothGatt.GATT_SUCCESS) {
                byte[] data = characteristic.getValue();
                String dataString = new String(data, StandardCharsets.UTF_8);
                // Обработка данных
                try {
                    callback.onRData(dataString);
                } catch (Exception e) {
//                    throw new RuntimeException(e);
                }
              //  Log.d("BLEDataRead", "Received: " + dataString);
            }
        }

        private void readCharacteristic(BluetoothGattCharacteristic characteristic) {
            if (ActivityCompat.checkSelfPermission(context, android.Manifest.permission.BLUETOOTH_CONNECT) != PackageManager.PERMISSION_GRANTED) {
                // TODO: Consider calling
                //    ActivityCompat#requestPermissions
                // here to request the missing permissions, and then overriding
                //   public void onRequestPermissionsResult(int requestCode, String[] permissions,
                //                                          int[] grantResults)
                // to handle the case where the user grants the permission. See the documentation
                // for ActivityCompat#requestPermissions for more details.
                return;
            }
            bluetoothGatt.readCharacteristic(characteristic);
        }

    };

    private void setCharacteristicNotification(BluetoothGattCharacteristic characteristic, boolean enabled) {
        if (ActivityCompat.checkSelfPermission(context, android.Manifest.permission.BLUETOOTH_CONNECT) != PackageManager.PERMISSION_GRANTED) {
            // TODO: Consider calling
            //    ActivityCompat#requestPermissions
            // here to request the missing permissions, and then overriding
            //   public void onRequestPermissionsResult(int requestCode, String[] permissions,
            //                                          int[] grantResults)
            // to handle the case where the user grants the permission. See the documentation
            // for ActivityCompat#requestPermissions for more details.
            return;
        }
        bluetoothGatt.setCharacteristicNotification(characteristic, enabled);

        BluetoothGattDescriptor descriptor = characteristic.getDescriptor(UUID.fromString("00002902-0000-1000-8000-00805f9b34fb"));
        descriptor.setValue(enabled ? BluetoothGattDescriptor.ENABLE_NOTIFICATION_VALUE : BluetoothGattDescriptor.DISABLE_NOTIFICATION_VALUE);
        bluetoothGatt.writeDescriptor(descriptor);
    }
    @SuppressLint("MissingPermission")
    public void sendData(String data) {
        //setCharacteristicNotification(characteristic,false);
        if (bluetoothGatt != null && characteristic != null) {
            characteristic.setValue(data.getBytes());
            bluetoothGatt.writeCharacteristic(characteristic);
            this.presend = false;
            process_time(characteristic);

        }
    }

    @SuppressLint("MissingPermission")
    public void disconnect() {
        if (bluetoothGatt != null) {
            bluetoothGatt.disconnect();
            bluetoothGatt.close();
        }
    }
    public boolean isConnected() {
        return connected;
    }
    public void precends(boolean presends, String data ){
            this.presend = presends;
        long time = System.currentTimeMillis();
        while (System.currentTimeMillis() - time < 800 ){}
        sendData(data);
    }
    private void process_time(BluetoothGattCharacteristic characteristics){
        @SuppressLint("MissingPermission") Runnable runnable = () -> {
        long time = System.currentTimeMillis();
         while (!presend){
            if(System.currentTimeMillis() - time >= 1 ){
                bluetoothGatt.readCharacteristic(characteristics);
                time = System.currentTimeMillis();
            }
        }
    };
        Thread thread = new Thread(runnable);
        thread.start();
    }
}

• Приводной шкив энкодера (Dэ): ∅ 50 мм.
• Шкив на оси (Do): ∅ 15 мм.
• Измерительное колесо (Dи): ∅ 50 мм.
• Количество импульсов на оборот (PPR): 5000.

iрп = Dо / Dэ = 15 / 50 = 3,333

Cи = π × Dи = 3,1416 × 50 мм = 157,08 мм

Pопш = iрп × Cи = 3,333 × 157,08  = 523,547 мм

Kш = Pопш / PPR = 523,547 / 5000 = 0,1047 мм*имп