RI_SDK_sensor_VoltageSensor_ReadRegBytes

Информация

RI_SDK - библиотека Robo Intellect Software Development Kit
sensor - название группы устройств датчиков
VoltageSensor - название устройства датчика тока, напряжения и мощности
ReadRegBytes - название метода чтения массива байт по указанному регистру

Сигнатура функции:

Golang DLL
Golang gRPC

RI_SDK_sensor_VoltageSensor_ReadRegBytes(descriptor, reg, buf, len, readBytesLen, errorText):errorCode

RI_SDK_Sensor_VoltageSensor_ReadRegBytes(descriptor int64, reg byte, len int64) (buf []byte, errorText string, errorCode int64, err error)

Описание метода

Чтение массива байтов из регистра.

Читает len байт по регистру reg у датчика тока, напряжения и мощности с дескриптором descriptor. Записывает прочитанные байты в буфер buf.

Параметры и возвращаемые значения

Параметр	Тип для Shared object	Тип для Golang gRPC	Описание
descriptor	int (тип C)	int64	Дескриптор компонента, в котором будет производиться чтение
reg	uint8_t (тип C)	uint8	Регистр, по которому будет производиться чтение
buf	*long long unsigned[len] (тип C)	[]byte	Указатель на массив байт для чтения
len	int (тип C)	int64	Длина массива buf
readBytesLen	*int (тип C)	int64	Указатель на количество прочитанных байтов
errorText	char[1000] (тип C)	string	Текст ошибки (передается как параметр, если происходит ошибка метод записывает в этот параметр текст ошибки)
errorCode	int (тип C)	int64	Код ошибки

Схема регистров датчика тока, напряжения и мощности ina219

Адрес регистра	Название регистра	Назначение регистра	Тип
0x00	Configuration	Сброс всех регистров, настройка диапазона измерений, усиления PGA, разрешения АЦП и фильтрации.	Чтение/Запись
0x01	Shunt voltage	Хранит измеренное значение напряжения на шунтирующем резисторе 0,1 Ом.	Чтение
0x02	Bus voltage	Хранит измеренное значение напряжения шины.	Чтение
0x03	Power	Хранит измеренное значение мощности.	Чтение
0x04	Current	Содержит значение силы тока, протекающего через шунтирующий резистор.	Чтение
0x05	Calibration	Калибровочный регистр. Задаёт диапазон измерений и позволяет осуществлять калибровку системы.	Чтение/Запись

Примеры

Пример №1 - Чтение массива байт buf на датчике тока на 0 регистре

В данном примере осуществляется чтение массива байт buf на датчике тока на 0 регистре. Выводиться значение прочитанных байтов.

# Чтение массива байт buf длиной 2 на датчике тока на 0 регистре
lenBuf = 2
b = c_ulonglong()
errCode = lib.RI_SDK_sensor_VoltageSensor_ReadRegBytes(voltageSensor, 0x00, b, lenBuf, readBytesLen, errTextC)
if errCode != 0:
    print(errCode, errTextC.raw.decode())
    sys.exit(2)
# Конвертируем полученное значение c_ulonglong в массив байт
buf = b.value.to_bytes(readBytesLen.value, "little")
print("read bytes: ", buf)
    

      // Чтение массива байт buf длиной 2 на датчике тока на 0 регистре
      int lenBuf = 16;
      unsigned long long b;
      errCode = RI_SDK_sensor_VoltageSensor_ReadRegBytes(sensorDescriptor, 0x00, &b, lenBuf, &readBytesLen, errorText);
      if (errCode) {
      printf("errorText:%s\n", errorText);
      return errCode;
  }

      // Чтение массива байт buf длиной 2 на датчике тока на 0 регистре
      int lenBuf = 16;
      unsigned long long b;
      errCode = RI_SDK_sensor_VoltageSensor_ReadRegBytes(sensorDescriptor, 0x00, &b, lenBuf, &readBytesLen, errorText);
      if (errCode) {
      printf("errorText:%s\n", errorText);
      return errCode;
  }

        // Чтение массива байт buf длиной 2 на датчике тока на 0 регистре
        lenBuf = 16
        b := C.ulonglong(0)
        errCode = C.sensor_VoltageSensor_ReadRegBytes(sensorDescriptor, 0x00, &b, lenBuf, &readBytesLen, &errorText[0])
        if errCode != 0 {
        fmt.Printf("errorCode:%d - errorText:%s\n", errCode, C.GoString(&errorText[0]))
        return
    }
        fmt.Println("read bytes len: ", readBytesLen)

        // Конвертируем полученное значение c_ulonglong в массив байт и выводим
        var readBuffer = make([]byte, 0)
        ptr := uintptr(b)
        for i := 0; i < int(readBytesLen); i++ {
        value := *(*byte)(unsafe.Pointer(ptr)) // получаем значение по указателю
        readBuffer = append(readBuffer, value)
        ptr = ptr + 1 //сдвигаем указатель на следующий элемент буфера
    }

      // Чтение массива байт buf длиной 16 на датчике тока по регистру 0
      var lenBuf int64 = 16
      readBuf, errText, errCode, err := client.RoboSdkApi.RI_SDK_Sensor_VoltageSensor_ReadRegBytes(inaSensorDescriptor, 0x0, lenBuf)
      if errText != "" || errCode != 0 || err != nil {
      fmt.Printf("errText: %s; errCode:%d; err: %s", errText, errCode, err)
      return
  }

        // Чтение массива байт buf длиной 2 на датчике тока на 0 регистре
        $b = $ffi->new('unsigned long long int', 0);
        $lenBuf = 2;
        $readBytesLen = $ffi->new("int", 0);

        $errCode = $ffi->RI_SDK_sensor_VoltageSensor_ReadRegBytes($sensorDescriptor->cdata, 0x0, FFI::addr($b), $lenBuf, FFI::addr($readBytesLen), $errorText);
        if ($errCode) {
        print("errorText:" . FFI::string($errorText) . " errCode: " . $errCode . " \n");
        return;
    }

Полный текст примера

from ctypes.util import find_library
import platform
import sys
from ctypes import *

# Подключаем внешнюю библиотеку для работы с SDK
platform = platform.system()
if platform == "Windows":
    libName = "librisdk.dll"
if platform == "Linux":
    libName = "librisdk.so"

pathLib = find_library(libName)
lib = cdll.LoadLibrary(pathLib)


# Указываем типы аргументов для функций библиотеки RI_SDK
lib.RI_SDK_InitSDK.argtypes = [c_int, c_char_p]
lib.RI_SDK_CreateModelComponent.argtypes = [c_char_p, c_char_p, c_char_p, POINTER(c_int), c_char_p]
lib.RI_SDK_LinkVoltageSensorToController.argtypes = [c_int, c_int, c_uint8, c_char_p]
lib.RI_SDK_DestroySDK.argtypes = [c_bool, c_char_p]
lib.RI_SDK_sensor_VoltageSensor_ReadRegBytes.argtypes = [c_int, c_uint8, POINTER(c_ulonglong), c_int, POINTER(c_int), c_char_p]

def main():
    errTextC = create_string_buffer(1000)  # Текст ошибки. C type: char*
    i2c = c_int()
    voltageSensor = c_int()
    readBytesLen = c_int()

    # Инициализация библиотеки RI SDK с уровнем логирования 3
    errCode = lib.RI_SDK_InitSDK(3, errTextC)
    if errCode != 0:
        print(errCode, errTextC.raw.decode())
        sys.exit(2)

    # Создание компонента i2c адаптера модели ch341
    errCode = lib.RI_SDK_CreateModelComponent("connector".encode(), "i2c_adapter".encode(), "ch341".encode(), i2c, errTextC)
    if errCode != 0:
        print(errCode, errTextC.raw.decode())
        sys.exit(2)

    print("i2c: ", i2c.value)

    # Создание компонента датчика тока, напряжения и мощности модели ina219
    errCode = lib.RI_SDK_CreateModelComponent("sensor".encode(), "voltage_sensor".encode(), "ina219".encode(), voltageSensor, errTextC)
    if errCode != 0:
        print(errCode, errTextC.raw.decode())
        sys.exit(2)

    print("voltage_sensor: ", voltageSensor.value)

    # Связывание i2c с датчиком тока, напряжения и мощности
    errCode = lib.RI_SDK_LinkVoltageSensorToController(voltageSensor, i2c, 0x41, errTextC)
    if errCode != 0:
        print(errCode, errTextC.raw.decode())
        sys.exit(2)

    # Чтение массива байт buf длиной 2 на датчике тока на 0 регистре
    lenBuf = 2
    b = c_ulonglong()
    errCode = lib.RI_SDK_sensor_VoltageSensor_ReadRegBytes(voltageSensor, 0x00, b, lenBuf, readBytesLen, errTextC)
    if errCode != 0:
        print(errCode, errTextC.raw.decode())
        sys.exit(2)
    # Конвертируем полученное значение c_ulonglong в массив байт
    buf = b.value.to_bytes(readBytesLen.value, "little")
    print("read bytes: ", buf)

    # Удаление библиотеки со всеми компонентами
    errCode = lib.RI_SDK_DestroySDK(True, errTextC)
    if errCode != 0:
        print(errCode, errTextC.raw.decode())
        sys.exit(2)

    print("Success")

main()

      #include <stdlib.h>
      #include <stdio.h>
      #include <unistd.h>
      #include <string.h>
      #include <dlfcn.h>
      #include <stdint.h>

      int (*RI_SDK_InitSDK)(int logLevel, char *errorText);

      int (*RI_SDK_CreateModelComponent)(char *group, char *device, char *model, int *descriptor, char *errorText);

      int
      (*RI_SDK_LinkVoltageSensorToController)(int sensorDescriptor, int i2cAdapterDescriptor, uint8_t addr, char *errorText);

      int (*RI_SDK_sensor_VoltageSensor_ReadRegBytes)(int descriptorC, uint8_t reg, long long unsigned int* bufferPtrC, int length, int* readBytesLength, char* errorText);

      int initLibrary() {
      void *handle;
      char *LIB_RISDK = getenv("LIB_RISDK");
      handle = dlopen(strcat(LIB_RISDK, "librisdk.so"), RTLD_NOW);
      if (!handle) {
      /* fail to load the library */
      fprintf(stderr, "Error: %s\n", dlerror());
      return -1;
  }

      *(void **) (&RI_SDK_InitSDK) = dlsym(handle, "RI_SDK_InitSDK");
      *(void **) (&RI_SDK_CreateModelComponent) = dlsym(handle, "RI_SDK_CreateModelComponent");
      *(void **) (&RI_SDK_LinkVoltageSensorToController) = dlsym(handle, "RI_SDK_LinkVoltageSensorToController");
      *(void **) (&RI_SDK_sensor_VoltageSensor_ReadRegBytes) = dlsym(handle, "RI_SDK_sensor_VoltageSensor_ReadRegBytes");
      return 0;
  }

      char errorText[1000]; // текст ошибки. Передается как входной параметр,при возникновении ошибки в эту переменную будет записан текст ошибки
      int sensorDescriptor;
      int i2cDescriptor;
      int readBytesLen;

      int main() {
      int initErr;
      initErr = initLibrary();
      if (initErr != 0) {
      printf("fail to load init library");
      return initErr;
  }

      int errCode; //код ошибки

      // Инициализация библиотеки RI SDK
      errCode = RI_SDK_InitSDK(3, errorText);
      if (errCode != 0) {
      printf("errorText:%s\n", errorText);
      return errCode;
  }

      // Создание компонента i2c адаптера модели ch341
      errCode = RI_SDK_CreateModelComponent("connector", "i2c_adapter", "ch341", &i2cDescriptor, errorText);
      if (errCode) {
      printf("errorText:%s\n", errorText);
      return errCode;
  }

      // Создание компонента датчика тока, напряжения и мощности модели ina219
      errCode = RI_SDK_CreateModelComponent("sensor", "voltage_sensor", "ina219", &sensorDescriptor, errorText);
      if (errCode) {
      printf("errorText:%s\n", errorText);
      return errCode;
  }

      // Связывание i2c с датчиком тока, напряжения и мощности
      errCode = RI_SDK_LinkVoltageSensorToController(sensorDescriptor, i2cDescriptor, 0x41, errorText);
      if (errCode) {
      printf("errorText:%s\n", errorText);
      return errCode;
  }

      // Чтение массива байт buf длиной 2 на датчике тока на 0 регистре
      int lenBuf = 16;
      unsigned long long b;
      errCode = RI_SDK_sensor_VoltageSensor_ReadRegBytes(sensorDescriptor, 0x00, &b, lenBuf, &readBytesLen, errorText);
      if (errCode) {
      printf("errorText:%s\n", errorText);
      return errCode;
  }

      printf("readBytesLen: %d", readBytesLen);
      return 0;
  }

      #include <stdlib.h>
      #include <stdio.h>
      #include <unistd.h>
      #include <string.h>
      #include <dlfcn.h>
      #include <stdint.h>

      int (*RI_SDK_InitSDK)(int logLevel, char *errorText);

      int (*RI_SDK_CreateModelComponent)(char *group, char *device, char *model, int *descriptor, char *errorText);

      int
      (*RI_SDK_LinkVoltageSensorToController)(int sensorDescriptor, int i2cAdapterDescriptor, uint8_t addr, char *errorText);

      int (*RI_SDK_sensor_VoltageSensor_ReadRegBytes)(int descriptorC, uint8_t reg, long long unsigned int *bufferPtrC,
      int length, int *readBytesLength, char *errorText);

      int initLibrary() {
      void *handle;
      char *LIB_RISDK = getenv("LIB_RISDK");
      handle = dlopen(strcat(LIB_RISDK, "librisdk.so"), RTLD_NOW);
      if (!handle) {
      /* fail to load the library */
      fprintf(stderr, "Error: %s\n", dlerror());
      return -1;
  }

      *(void **) (&RI_SDK_InitSDK) = dlsym(handle, "RI_SDK_InitSDK");
      *(void **) (&RI_SDK_CreateModelComponent) = dlsym(handle, "RI_SDK_CreateModelComponent");
      *(void **) (&RI_SDK_LinkVoltageSensorToController) = dlsym(handle, "RI_SDK_LinkVoltageSensorToController");
      *(void **) (&RI_SDK_sensor_VoltageSensor_ReadRegBytes) = dlsym(handle, "RI_SDK_sensor_VoltageSensor_ReadRegBytes");
      return 0;
  }

      char errorText[1000]; // текст ошибки. Передается как входной параметр,при возникновении ошибки в эту переменную будет записан текст ошибки
      int sensorDescriptor;
      int i2cDescriptor;
      int readBytesLen;

      int main() {
      int initErr;
      initErr = initLibrary();
      if (initErr != 0) {
      printf("fail to load init library");
      return initErr;
  }

      int errCode; //код ошибки

      // Инициализация библиотеки RI SDK
      errCode = RI_SDK_InitSDK(3, errorText);
      if (errCode != 0) {
      printf("errorText:%s\n", errorText);
      return errCode;
  }

      // Создание компонента i2c адаптера модели ch341
      char i2cGroup[] = "connector";
      char i2cDevice[] = "i2c_adapter";
      char i2cModel[] = "ch341";
      errCode = RI_SDK_CreateModelComponent(i2cGroup, i2cDevice, i2cModel, &i2cDescriptor, errorText);
      if (errCode) {
      printf("errorText:%s\n", errorText);
      return errCode;
  }

      // Создание компонента датчика тока, напряжения и мощности модели ina219
      char sensor[] = "sensor";
      char voltage_sensor[] = "voltage_sensor";
      char ina219[] = "ina219";
      errCode = RI_SDK_CreateModelComponent(sensor, voltage_sensor, ina219, &sensorDescriptor, errorText);
      if (errCode) {
      printf("errorText:%s\n", errorText);
      return errCode;
  }

      // Связывание i2c с датчиком тока, напряжения и мощности
      errCode = RI_SDK_LinkVoltageSensorToController(sensorDescriptor, i2cDescriptor, 0x41, errorText);
      if (errCode) {
      printf("errorText:%s\n", errorText);
      return errCode;
  }

      // Чтение массива байт buf длиной 2 на датчике тока на 0 регистре
      int lenBuf = 16;
      unsigned long long b;
      errCode = RI_SDK_sensor_VoltageSensor_ReadRegBytes(sensorDescriptor, 0x00, &b, lenBuf, &readBytesLen, errorText);
      if (errCode) {
      printf("errorText:%s\n", errorText);
      return errCode;
  }

      printf("readBytesLen: %d", readBytesLen);
      return 0;
  }

        package main

        /*
        #cgo LDFLAGS: -ldl
        #include <stdlib.h>
        #include <stdio.h>
        #include <unistd.h>
        #include <string.h>
        #include <dlfcn.h>
        #include <stdint.h>

        int (*RI_SDK_InitSDK)(int logLevel, char *errorText);

        int (*RI_SDK_CreateModelComponent)(char *group, char *device, char *model, int *descriptor, char *errorText);

        int
        (*RI_SDK_LinkVoltageSensorToController)(int sensorDescriptor, int i2cAdapterDescriptor, uint8_t addr, char *errorText);

        int (*RI_SDK_sensor_VoltageSensor_ReadRegBytes)(int descriptorC, uint8_t reg, long long unsigned int* bufferPtrC, int length, int* readBytesLength, char* errorText);


        int InitSDK(int logLevel, char *errorText){
        RI_SDK_InitSDK(logLevel,errorText);
    }

        int CreateModelComponent(char *group, char *device, char *model, int *descriptor, char *errorText){
        RI_SDK_CreateModelComponent(group,device,model,descriptor,errorText);
    }

        int LinkVoltageSensorToController(int sensorDescriptor, int i2cAdapterDescriptor, uint8_t addr, char *errorText){
        RI_SDK_LinkVoltageSensorToController(sensorDescriptor,i2cAdapterDescriptor,addr,errorText);
    }

        int sensor_VoltageSensor_ReadRegBytes(int descriptorC, uint8_t reg, long long unsigned int* bufferPtrC, int length, int* readBytesLength, char* errorText){
        RI_SDK_sensor_VoltageSensor_ReadRegBytes(descriptorC,reg,bufferPtrC,length,readBytesLength,errorText);
    }


        int initLibrary() {
        void *handle;
        char *LIB_RISDK = getenv("LIB_RISDK");
        handle = dlopen(strcat(LIB_RISDK, "librisdk.so"), RTLD_NOW);
        if (!handle) {
        fprintf(stderr, "Error: %s\n", dlerror());
        return -1;
    }

        *(void **) (&RI_SDK_InitSDK) = dlsym(handle, "RI_SDK_InitSDK");
        *(void **) (&RI_SDK_CreateModelComponent) = dlsym(handle, "RI_SDK_CreateModelComponent");
        *(void **) (&RI_SDK_LinkVoltageSensorToController) = dlsym(handle, "RI_SDK_LinkVoltageSensorToController");
        *(void **) (&RI_SDK_sensor_VoltageSensor_ReadRegBytes) = dlsym(handle, "RI_SDK_sensor_VoltageSensor_ReadRegBytes");
        return 0;
    }
        */
        import "C"
        import "fmt"
        import "unsafe"

        func main() {
        var (
        errorText        [1000]C.char // текст ошибки. Передается как входной параметр,при возникновении ошибки в эту переменную будет записан текст ошибки
        errCode          C.int        //код ошибки
        sensorDescriptor C.int
        i2cDescriptor    C.int
        initErr          C.int
        readBytesLen     C.int
        lenBuf           C.int
        )

        initErr = C.initLibrary()
        if initErr != 0 {
        fmt.Printf("fail to load init library")
    }

        // Инициализация библиотеки RI SDK
        errCode = C.InitSDK(3, &errorText[0])
        if errCode != 0 {
        fmt.Printf("errorCode:%d - errorText:%s\n", errCode, C.GoString(&errorText[0]))
        return
    }

        // Создание компонента i2c адаптера модели ch341
        errCode = C.CreateModelComponent(C.CString("connector"), C.CString("i2c_adapter"), C.CString("ch341"), &i2cDescriptor, &errorText[0])
        if errCode != 0 {
        fmt.Printf("errorCode:%d - errorText:%s\n", errCode, C.GoString(&errorText[0]))
        return
    }

        // Создание компонента датчика тока, напряжения и мощности модели ina219
        errCode = C.CreateModelComponent(C.CString("sensor"), C.CString("voltage_sensor"), C.CString("ina219"), &sensorDescriptor, &errorText[0])
        if errCode != 0 {
        fmt.Printf("errorCode:%d - errorText:%s\n", errCode, C.GoString(&errorText[0]))
        return
    }

        // Связывание i2c с датчиком тока, напряжения и мощности
        errCode = C.LinkVoltageSensorToController(sensorDescriptor, i2cDescriptor, 0x41, &errorText[0])
        if errCode != 0 {
        fmt.Printf("errorCode:%d - errorText:%s\n", errCode, C.GoString(&errorText[0]))
        return
    }

        // Чтение массива байт buf длиной 2 на датчике тока на 0 регистре
        lenBuf = 16
        b := C.ulonglong(0)
        errCode = C.sensor_VoltageSensor_ReadRegBytes(sensorDescriptor, 0x00, &b, lenBuf, &readBytesLen, &errorText[0])
        if errCode != 0 {
        fmt.Printf("errorCode:%d - errorText:%s\n", errCode, C.GoString(&errorText[0]))
        return
    }
        fmt.Println("read bytes len: ", readBytesLen)

        // Конвертируем полученное значение c_ulonglong в массив байт и выводим
        var readBuffer = make([]byte, 0)
        ptr := uintptr(b)
        for i := 0; i < int(readBytesLen); i++ {
        value := *(*byte)(unsafe.Pointer(ptr)) // получаем значение по указателю
        readBuffer = append(readBuffer, value)
        ptr = ptr + 1 //сдвигаем указатель на следующий элемент буфера
    }

    }

      package main

      import (
      "fmt"
      "github.com/rbs-ri/go-risdk"
      )

      func main() {
      //Открываем соединение для работы с API SDK по RPC
      client := risdk.GetClientRPC()
      //Закрываем соединение с RPC
      defer client.Client.Kill()

      // Создание компонента i2c адаптера модели ch341
      i2cDescriptor, errText, errCode, err := client.RoboSdkApi.RI_SDK_CreateModelComponent("connector", "i2c_adapter", "ch341")
      if errText != "" || errCode != 0 || err != nil {
      fmt.Printf("errText: %s; errCode:%d; err: %s", errText, errCode, err)
      return
  }

      // Создание компонента датчика тока, напряжения и мощности модели ina219
      inaSensorDescriptor, errText, errCode, err := client.RoboSdkApi.RI_SDK_CreateModelComponent("sensor", "voltage_sensor", "ina219")
      if errText != "" || errCode != 0 || err != nil {
      fmt.Printf("errText: %s; errCode:%d; err: %s", errText, errCode, err)
      return
  }

      // Связывание i2c с датчиком тока, напряжения и мощности
      errText, errCode, err = client.RoboSdkApi.RI_SDK_LinkVoltageSensorToController(inaSensorDescriptor, i2cDescriptor, 0x41)
      if errText != "" || errCode != 0 || err != nil {
      fmt.Printf("errText: %s; errCode:%d; err: %s", errText, errCode, err)
      return
  }

      // Чтение массива байт buf длиной 16 на датчике тока по регистру 0
      var lenBuf int64 = 16
      readBuf, errText, errCode, err := client.RoboSdkApi.RI_SDK_Sensor_VoltageSensor_ReadRegBytes(inaSensorDescriptor, 0x0, lenBuf)
      if errText != "" || errCode != 0 || err != nil {
      fmt.Printf("errText: %s; errCode:%d; err: %s", errText, errCode, err)
      return
  }

      fmt.Printf("readBuf: %v", readBuf)

      return
  }

        <?php
        // Подключаем внешнюю библиотеку для работы с SDK
        $LIB_RISDK_ENV = "LIB_RISDK";
        if (empty(getenv($LIB_RISDK_ENV))) {
        print("Не указана переменная среды LIB_RISDK - выполнение программы невозможно");
        return;
    }

        $libname = '';
        if (strtoupper(substr(PHP_OS, 0, 3)) === 'WIN') {
        $libname = '\librisdk.dll';
    } else {
        $libname = "librisdk.so";
    }

        $ffi = FFI::cdef("int RI_SDK_InitSDK(int level,char* errText);
        int RI_SDK_CreateModelComponent(char* group, char* device, char* model, int* descriptor, char* errorTextC);
        int RI_SDK_LinkVoltageSensorToController(int sensorDescriptor, int i2cAdapterDescriptor, uint8_t addr, char* errorTextC);
        int RI_SDK_sensor_VoltageSensor_ReadRegBytes(int descriptorC, uint8_t regC, long long unsigned int* bufferPtrC, int lengthC, int* readedBytesLengthC, char* errorTextC);"
        , getenv($LIB_RISDK_ENV) . $libname);

        $errorText = $ffi->new('char[1000]', 0); // Выделяем память на строку с ошибкой. Передается как входной параметр,при возникновении ошибки в эту переменную будет записан текст ошибки
        $logLevel = 3; // уровень логирования
        $sensorDescriptor = $ffi->new('int', 0);
        $i2cDescriptor = $ffi->new('int', 0);
        $current = $ffi->new('float', 0);

        // Инициализируем SDK
        $errCode = $ffi->RI_SDK_InitSDK($logLevel, $errorText);
        if ($errCode) {
        print("errorText:" . FFI::string($errorText) . " errCode: " . $errCode . " \n");
        return;
    }

        // Создание компонента i2c адаптера модели ch341
        $errCode = $ffi->RI_SDK_CreateModelComponent("connector", "i2c_adapter", "ch341", FFI::addr($i2cDescriptor), $errorText);
        if ($errCode) {
        print("errorText:" . FFI::string($errorText) . " errCode: " . $errCode . " \n");
        return;
    }

        // Создание компонента датчика тока, напряжения и мощности модели ina219
        $errCode = $ffi->RI_SDK_CreateModelComponent("sensor", "voltage_sensor", "ina219", FFI::addr($sensorDescriptor), $errorText);
        if ($errCode) {
        print("errorText:" . FFI::string($errorText) . " errCode: " . $errCode . " \n");
        return;
    }

        // Связывание i2c с датчиком тока, напряжения и мощности
        $errCode = $ffi->RI_SDK_LinkVoltageSensorToController($sensorDescriptor->cdata, $i2cDescriptor->cdata, 0x41, $errorText);
        if ($errCode) {
        print("errorText:" . FFI::string($errorText) . " errCode: " . $errCode . " \n");
        return;
    }

        // Чтение массива байт buf длиной 2 на датчике тока на 0 регистре
        $b = $ffi->new('unsigned long long int', 0);
        $lenBuf = 2;
        $readBytesLen = $ffi->new("int", 0);

        $errCode = $ffi->RI_SDK_sensor_VoltageSensor_ReadRegBytes($sensorDescriptor->cdata, 0x0, FFI::addr($b), $lenBuf, FFI::addr($readBytesLen), $errorText);
        if ($errCode) {
        print("errorText:" . FFI::string($errorText) . " errCode: " . $errCode . " \n");
        return;
    }

        print("read bytes len: " . $readBytesLen->cdata . "\n");

Сигнатура функции:​

Описание метода​

Параметры и возвращаемые значения​

Схема регистров датчика тока, напряжения и мощности ina219​

Примеры​

Пример №1 - Чтение массива байт buf на датчике тока на 0 регистре​