NAV Navbar
C++ (C-API) C++ Python Java Android ObjC C# Delphi Go Duktape

Общая информация

Драйвер контрольно-кассовой техники v.10 (дККТ10) - интеграционный компонент, предоставляющий удобный API (программный интерфейс) для работы с контрольно-кассовой техникой (ККТ) для самых популярных программных и аппаратных платформ и языков программирования. В их числе операционные системы Linux, Windows, macOS, Android и iOS, архитектуры i386, amd64 и arm.

За счет того, что драйвер разработан на языках C/С++ и имеет C-API, его подключение к любым официально неподдерживаемым языкам программирования осуществляется очень просто.

В данной документации приведены примеры использования драйвера на следующих языках:

Для интеграции, помимо драйвера ККТ, можно использовать основанные на нем приложения:

Минимальные поддерживаемые версии ОС:

Дистрибутивы

Windows

Дистрибутив для Windows (x86, x64) построен на базе NSIS и включает в себя:

Тихий режим

Дистрибутив поддерживает тихую установку. Для этого необходимо его запустить с ключем /S. В тихом режиме по умолчанию устанавливаются только те компоненты, от установки которых отказаться нельзя. Установкой остальных компонентов можно управлять с помощью ключей инсталлятора:

При тихой установке инсталлятор может вернуть следующие ошибки (ErrorLevel):

Linux

Для Linux предоставляются deb- и rpm-пакеты под архитектуры x86, x64, arm64 и armhf:

macOS

Для macOS предоставляется dmg-пакет с тестовым приложением, а также фреймворк с библиотеками драйвера. Тестовое приложение не зависит от наличия установленного фреймворка драйвера и может работать без него.

Настройки логирования

Состав файла fptr10_log.properties по умолчанию. ${WORK_DIRECTORY} - рабочий каталог драйвера.

log4cpp.rootCategory=ERROR, file
log4cpp.category.FiscalPrinter=INFO, file
log4cpp.category.Transport=INFO, file
log4cpp.category.EthernetOverTransport=INFO, ofd
log4cpp.category.DeviceDebug=INFO, device_debug
log4cpp.category.1C=INFO, file1C

log4cpp.appender.console=ConsoleAppender
log4cpp.appender.console.layout=PatternLayout
log4cpp.appender.console.layout.ConversionPattern=%d{%Y.%m.%d %H:%M:%S.%l} T:%t %-5p [%c] %m%n

log4cpp.appender.file=DailyRollingFileAppender
log4cpp.appender.file.fileName=${WORK_DIRECTORY}/logs/fptr10.log
log4cpp.appender.file.maxDaysKeep=14
log4cpp.appender.file.layout=PatternLayout
log4cpp.appender.file.layout.ConversionPattern=%d{%Y.%m.%d %H:%M:%S.%l} T:%t %-5p [%c] %m%n

log4cpp.appender.ofd=DailyRollingFileAppender
log4cpp.appender.ofd.fileName=${WORK_DIRECTORY}/logs/ofd.log
log4cpp.appender.ofd.maxDaysKeep=14
log4cpp.appender.ofd.layout=PatternLayout
log4cpp.appender.ofd.layout.ConversionPattern=%d{%Y.%m.%d %H:%M:%S.%l} T:%t %-5p [%c] %m%n

log4cpp.appender.device_debug=DailyRollingFileAppender
log4cpp.appender.device_debug.fileName=${WORK_DIRECTORY}/logs/device_debug.log
log4cpp.appender.device_debug.maxDaysKeep=14
log4cpp.appender.device_debug.layout=PatternLayout
log4cpp.appender.device_debug.layout.ConversionPattern=%d{%Y.%m.%d %H:%M:%S.%l} T:%t %-5p [%c] %m%n

log4cpp.appender.fptr1C=DailyRollingFileAppender
log4cpp.appender.fptr1C.fileName=${WORK_DIRECTORY}/logs/fptr1C.log
log4cpp.appender.fptr1C.maxDaysKeep=14
log4cpp.appender.fptr1C.layout=PatternLayout
log4cpp.appender.fptr1C.layout.ConversionPattern=%d{%Y.%m.%d %H:%M:%S.%l} T:%t %-5p [%c] %m%n

На ОС Android ко всем категориям добавляется LogCatAppender

log4cpp.appender.logcat=LogCatAppender
log4cpp.appender.logcat.layout=PatternLayout
log4cpp.appender.logcat.layout.ConversionPattern=T:%t %-5p [%c] %m%n

На ОС iOS ко всем категориям добавляется NSLogAppender

log4cpp.appender.nslog=NSLogAppender
log4cpp.appender.nslog.layout=PatternLayout
log4cpp.appender.nslog.layout.ConversionPattern=T:%t %-5p [%c] %m%n

При первом запуске драйвер создает файл с настройками логирования в рабочем каталоге драйвера:

Также драйвер предоставляет возможность указать явно расположение файла fptr10_log.properties при работе на ОС Windows, Linux и MacOS. Для этого пользователю нужно задать переменную среды с названием DTO10_LOG_CONFIG_FILE и значением полного пути к файлу (например, C:\fptr10_log.properties). Файл в этом случае должен существовать заранее и быть корректно сформирован.

Для логирования используется библиотека log4cpp, описание файла настроек можно прочитать на её сайте (http://log4cpp.sourceforge.net/). Здесь будет приведено короткое описание настройки, а также список тегов (категорий логов), по которым драйвер производит логирование.

С помощью log4cpp, драйвер позволяет логировать информацию следующим образом:

Для каждой категории можно настроить подробность логирования. На данный момент поддерживаются следующие:

В случае с категориями Transport и FiscalPrinter на уровне INFO в логе фиксируется базовая информация об обмене с ККТ, а на уровне DEBUG - подробная информация об обмене. Для категорий, отвечающих за каналы обмена (USB, COM и т.п.) не рекомендуется включать логирования без особой надобности, т.к. это может замедлить и нарушить таймауты обмена с ККТ.

Специфичные настройки каждого из Appender-ов представлены в таблице ниже:

Appender Описание Параметры Описание параметров
RollingFileAppender Логирование в файл с ротацией по размеру fileName Путь к файлу лога
maxFileSize Максимальный размер файла лога до ротации
maxBackupIndex Максимальное количество файлов логов
DailyRollingFileAppender Логирование в файл с ротацией по времени (раз в день, в полночь) fileName Путь к файлу лога
maxDaysKeep Количество файлов для хранения
ConsoleAppender Логирование в консоль (stdout)
LogCatAppender Логирование в logcat
NSLogAppender Логирование в Apple System Log

В случае разделения логов между экземплярами драйвера к названиям файлов логов будут добавлены идентификаторы, заданные при создании объекта драйвера. Консольные варианты логирования не поменяются.

Дополнительно, к каждому из Appender-ов можно добавить формат выводимых строк лога - Layout. Тип Layout-а нужно записать в параметр layout Appender-а и указать его настройки. Ниже приведено описание формата PatternLayout:

Поддерживаемые теги (категории) для настройки:

Начало работы с драйвером

Подключение к проекту

C/C++

Для использования драйвера из проекта, написанного на C/C++, нужно добавить в зависимости к нему библиотеку fptr10.dll (libfptr10.so) соответствующей архитектуры и подключить заголовочный файл libfptr10.h. Для C++ можно использовать отдельную обертку.

С++-обёртке можно передать путь к библиотеке драйвера (до каталога или до файла). Если путь не передан (или он пустой), обёртка будет искать драйвер в следующих каталогах по очереди:

  1. Рядом с исполняемым файлом приложения
  2. В каталоге, указанном при установке драйвера с инсталлятора
  3. В системных каталогах ОС

Поддерживается работа на Windows, Linux, MacOS.

Python

Для использования драйвера из Python-проекта, необходимо подключить модуль libfptr10.py. Минимальные поддерживаемые версии Python - 2.6 и 3.0.

Обёртке можно передать путь к библиотеке драйвера (до каталога или до файла). Если путь не передан (или он пустой), обёртка будет искать драйвер в следующих каталогах по очереди:

  1. В каталоге, указанном при установке драйвера с инсталлятора
  2. В системных каталогах ОС

Поддерживается работа на Windows, Linux, MacOS.

Java (JVM)

Для подключения драйвера к Java-проекту необходимо подключить библиотеку libfptr10.jar. Поддерживается работа на Windows, Linux, MacOS. Минимальная поддерживаемая версия Java - 1.6.

При работе на Windows, Linux и MacOS обёртке можно передать путь к библиотеке драйвера (до каталога или до файла). Если путь не передан (или он пустой), обёртка будет искать драйвер в следующих каталогах по очереди:

  1. В java.library.path и системных каталогах
  2. В каталоге, указанном при установке драйвера с инсталлятора

Для подключения драйвера к Android-проекту необходимо импортировать в проект библиотеку libfptr10.aar. В данной библиотеке (Android Archive, AAR) содержатся нативные библиотеки под все аппаратные платформы Android, а также набор Activity для настройки драйвера. Минимальная поддерживаемая версия Android - 4.0 (API 14).

.NET и .NET Core

Для подключения драйвера к .NET-проекту необходимо добавить в проект библиотеку Atol.Drivers10.Fptr.dll. Для .NET Framework и .NET Standard используются разные библиотеки. Минимальные поддерживаемые версии .NET Framework - 2.0, .NET Standard - 2.0.

Обёртке можно передать путь к библиотеке драйвера (до каталога или до файла). Если путь не передан (или он пустой), обёртка будет искать драйвер в следующих каталогах по очереди:

  1. Рядом с исполняемым файлом приложения
  2. В каталоге, указанном при установке драйвера с инсталлятора
  3. В системных каталогах ОС

Если на момент запуска приложения в его области видимости уже есть подходящая библиотека, будет использоваться она.

Поддерживается работа на Windows, Linux, MacOS.

COM-объект

Для подключения драйвера как COM-объект необходимо зарегистрировать в системе библиотеку addin_fptr10_x86.dll (addin_fptr10_x64.dll в случае 64-битного приложения) с помощью команды regsvr32.exe. Библиотека может сама обнаружить установленный через инсталлятор драйвер. Также инсталлятор автоматически регистрирует компонент заданной архитектуры в процессе установки. В проекте необходимо создать объект типа ActiveX (или OLE) класса AddIn.Fptr10. В данной документации описаны примеры работы с драйвером в виде OLE-объекта на языке Delphi.

Поддерживается работа только на Windows.

Go

Для подключения драйвера к проекту на Go необходимо добавить в каталог src проекта пакет fptr10 (atol.ru/drivers10/fptr). Go-обертка распространяется в виде исходных кодов.

Обёртке можно передать путь к библиотеке драйвера (до каталога или до файла). Если путь не передан (или он пустой), обёртка будет искать драйвер в следующих каталогах по очереди:

  1. Рядом с исполняемым файлом приложения
  2. В каталоге, указанном при установке драйвера с инсталлятора
  3. В системных каталогах ОС

Поддерживается работа на Windows, Linux, MacOS.

Objective C

Для подключения драйвера к Objective C-проекту необходимо добавить в проект фреймворк fptr10.framework и использовать заголовочный файл libfptr10_objc.h

Поддерживается работа на iOS, MacOS.

Фреймворк поставляется в следующих сборках:

Фреймворк включает в себя:

Можно объединить несколько сборок библиотеки fptr10 в одну с помощью lipo:

lipo -create -output <итоговый файл> <входной файл 1> <входной файл 2> ...

Инициализация драйвера

Инициализация драйвера

#include "libfptr10.h"

libfptr_handle fptr;
libfptr_create(&fptr);

#include "fptr10.h"

// Можно загрузить обертку с указанием пути к библиотеке драйвера
Fptr fptr_lib("C:\\path\\to\\libraries\\directory\\fptr10.dll");
// Можно - с указанием каталога библиотеки
Fptr fptr_path("C:\\path\\to\\libraries\\directory");
// А можно без, чтобы обертка нашла драйвер по стандартным путям
Fptr fptr_common;

from libfptr10 import IFptr

# Можно загрузить обертку с указанием пути к библиотеке драйвера
fptr_lib = IFptr(r"C:\path\to\libraries\directory\fptr10.dll")
# Можно - с указанием каталога библиотеки
fptr_dir = IFptr(r"C:\path\to\libraries\directory")
# А можно без, чтобы обертка нашла драйвер по стандартным путям
fptr_common = IFptr("")

import ru.atol.drivers10.fptr.Fptr;
import ru.atol.drivers10.fptr.IFptr;

// Можно загрузить обертку с указанием пути к библиотеке драйвера
IFptr fptr_lib = new Fptr("C:\\path\\to\\libraries\\directory\\fptr10.dll");
// Можно - с указанием каталога библиотеки
IFptr fptr_dir = new Fptr("C:\\path\\to\\libraries\\directory");
// А можно без, чтобы обертка нашла драйвер по стандартным путям
IFptr fptr_common = new Fptr();

import ru.atol.drivers10.fptr.Fptr;
import ru.atol.drivers10.fptr.IFptr;

IFptr fptr = new Fptr(getApplicationContext());

IFptr *fptr = [[IFptr alloc] init];

using Atol.Drivers10.Fptr;

// Можно загрузить обертку с указанием пути к библиотеке драйвера
IFptr fptr_lib = new Fptr(@"C:\path\to\libraries\directory\fptr10.dll");
// Можно - с указанием каталога библиотеки
IFptr fptr_dir = new Fptr(@"C:\path\to\libraries\directory");
// А можно без, чтобы обертка нашла драйвер по стандартным путям
IFptr fptr_common = new Fptr();

var
    fptr: OleVariant;
begin
    fptr := CreateOleObject('AddIn.Fptr10');
end;

import "atol.ru/drivers10/fptr"

// Можно загрузить обертку с указанием пути к библиотеке драйвера
fptr_lib, err := fptr10.NewWithPath("C:\\path\\to\\libraries\\directory\\fptr10.dll")
if err != nil {
    return err
}

// Можно - с указанием каталога библиотеки
fptr_lib, err := fptr10.NewWithPath("C:\\path\\to\\libraries\\directory")
if err != nil {
    return err
}

// А можно без, чтобы обертка нашла драйвер по стандартным путям
fptr, err := fptr10.NewSafe()
if err != nil {
    return err
}

Инициализация не требуется, методы драйвера доступны через глобальный объект Fptr

Инициализация драйвера с указанием идентификатора (KKT1)

#include "libfptr10.h"

libfptr_handle fptr;
libfptr_create_with_id(&fptr, L"KKT1");

#include "fptr10.h"

// Можно загрузить обертку с указанием пути к библиотеке драйвера
Fptr fptr_lib(fptr_id_t(L"KKT1"), L"C:\\path\\to\\libraries\\directory\\fptr10.dll");
// Можно - с указанием каталога библиотеки
Fptr fptr_path(fptr_id_t(L"KKT1"), L"C:\\path\\to\\libraries\\directory");
// А можно без, чтобы обертка нашла драйвер по стандартным путям
Fptr fptr_common(fptr_id_t(L"KKT1"));

from libfptr10 import IFptr

# Можно загрузить обертку с указанием пути к библиотеке драйвера
fptr_lib = IFptr(r"C:\path\to\libraries\directory\fptr10.dll", "KKT1")
# Можно - с указанием каталога библиотеки
fptr_dir = IFptr(r"C:\path\to\libraries\directory", "KKT1")
# А можно без, чтобы обертка нашла драйвер по стандартным путям
fptr_common = IFptr("", "KKT1")

import ru.atol.drivers10.fptr.Fptr;
import ru.atol.drivers10.fptr.IFptr;

// Можно загрузить обертку с указанием пути к библиотеке драйвера
IFptr fptr_lib = new Fptr("KKT1", "C:\\path\\to\\libraries\\directory\\fptr10.dll");
// Можно - с указанием каталога библиотеки
IFptr fptr_dir = new Fptr("KKT1", "C:\\path\\to\\libraries\\directory");
// А можно без, чтобы обертка нашла драйвер по стандартным путям
IFptr fptr_common = new Fptr("KKT1", null);

import ru.atol.drivers10.fptr.Fptr;
import ru.atol.drivers10.fptr.IFptr;

IFptr fptr = new Fptr(getApplicationContext(), "KKT1");

IFptr *fptr = [[IFptr alloc] initWithID:"KKT1"];

using Atol.Drivers10.Fptr;

// Можно загрузить обертку с указанием пути к библиотеке драйвера
IFptr fptr_lib = new Fptr("KKT1", @"C:\path\to\libraries\directory\fptr10.dll");
// Можно - с указанием каталога библиотеки
IFptr fptr_dir = new Fptr("KKT1", @"C:\path\to\libraries\directory");
// А можно без, чтобы обертка нашла драйвер по стандартным путям
IFptr fptr_common = new Fptr("KKT1", null);

var
    fptr: OleVariant;
begin
    fptr := CreateOleObject('AddIn.NamedFptr10');
    fptr.initWithID('KKT1'); // Только в этой строке будет 
                             // создан объект драйвера, 
                             // до её вызова остальные 
                             // методы работать не будут
end;

import "atol.ru/drivers10/fptr"

// Можно загрузить обертку с указанием пути к библиотеке драйвера
fptr_lib, err := fptr10.NewWithIDAndPath("KKT1", il"C:\\path\\to\\libraries\\directory\\fptr10.dll")
if err != nil {
    return err
}

// Можно - с указанием каталога библиотеки
fptr_lib, err := fptr10.NewWithIDAndPath("KKT1", "C:\\path\\to\\libraries\\directory")
if err != nil {
    return err
}

// А можно без, чтобы обертка нашла драйвер по стандартным путям
fptr, err := fptr10.NewWithID("KKT1")
if err != nil {
    return err
}

Инициализация не требуется, методы драйвера доступны через глобальный объект Fptr

В начале работы необходимо инициализировать рабочий экземпляр драйвера.

Все дальнейшие операции производятся именно над этим экземпляром.

В случае использования варианта с передачей идентификатора все записанные драйвером логи будут разделяться по разным файлам. Строка идентификатора может содержать только строчные и заглавные латинские буквы и цифры, а также символы тире и подчеркивания ([a-zA-Z0-9_-]). Если идентификатор не удовлетворяет требованиям, драйвер вернёт код результата -2, а языковые обертки вернут ошибки/выбросят исключения средствами соответствующего языка. При передаче пустого идентификатора создание объекта отрабатывает аналогично созданию без идентификатора.

Запрос версии драйвера

Запрос версии драйвера

char *version = libfptr_get_version_string();

std::string version = fptr.version();

version = fptr.version()

String version = fptr.version();

String version = fptr.version();

NSString *version = [fptr version];

String version = fptr.version();

var
    version: String;
begin
    version = fptr.version();
end;

version := fptr.Version()

version = Fptr.version();

Драйвер позволяет получить свою версию в виде строки.

Деинициализация драйвера

Деинициализация драйвера

libfptr_destroy(&fptr);

// Деинициализируется автоматически в деструкторе

del fptr

fptr.destroy();

fptr.destroy();

[fptr release];

fptr.destroy();

fptr := Unassigned

fptr.Destroy()

Не требуется

Когда работа с ККТ более не требуется, можно уничтожить рабочий экземпляр. При этом автоматически разорвется соединение с ККТ. После выполнения метода дальнейшая работа с данным экземпляром драйвера невозможна.

Настройка драйвера

Настройка драйвера, способ первый

wchar_t settings[1024] = {0};
swprintf(&settings[0], 1024, L"{\"%ls\": %d, \"%ls\": %d, \"%ls\": \"%ls\", \"%ls\": %d}",
    LIBFPTR_SETTING_MODEL, LIBFPTR_MODEL_ATOL_AUTO,
    LIBFPTR_SETTING_PORT, LIBFPTR_PORT_COM,
    LIBFPTR_SETTING_COM_FILE, L"COM5",
    LIBFPTR_SETTING_BAUDRATE, LIBFPTR_PORT_BR_115200);
libfptr_set_settings(fptr, settings);

wchar_t settings[1024] = {0};
swprintf(&settings[0], 1024, L"{\"%ls\": %d, \"%ls\": %d, \"%ls\": \"%ls\", \"%ls\": %d}",
    LIBFPTR_SETTING_MODEL, LIBFPTR_MODEL_ATOL_AUTO,
    LIBFPTR_SETTING_PORT, LIBFPTR_PORT_COM,
    LIBFPTR_SETTING_COM_FILE, L"COM5",
    LIBFPTR_SETTING_BAUDRATE, LIBFPTR_PORT_BR_115200);
fptr.setSettings(settings);

# Можно передать как строку
settings = "{{\"{}\": {}, \"{}\": {}, \"{}\": \"{}\", \"{}\": {}}}".format(
    IFptr.LIBFPTR_SETTING_MODEL, IFptr.LIBFPTR_MODEL_ATOL_AUTO,
    IFptr.LIBFPTR_SETTING_PORT, IFptr.LIBFPTR_PORT_COM,
    IFptr.LIBFPTR_SETTING_COM_FILE, "COM5",
    IFptr.LIBFPTR_SETTING_BAUDRATE, IFptr.LIBFPTR_PORT_BR_115200)
fptr.setSettings(settings)

# А можно как dict
settings = {
    IFptr.LIBFPTR_SETTING_MODEL: IFptr.LIBFPTR_MODEL_ATOL_AUTO,
    IFptr.LIBFPTR_SETTING_PORT: IFptr.LIBFPTR_PORT_COM,
    IFptr.LIBFPTR_SETTING_COM_FILE: "COM5",
    IFptr.LIBFPTR_SETTING_BAUDRATE: IFptr.LIBFPTR_PORT_BR_115200
}
fptr.setSettings(settings)

settings = String.format("{\"%s\": %d, \"%s\": %d, \"%s\": \"%s\", \"%s\": %d}",
    IFptr.LIBFPTR_SETTING_MODEL, IFptr.LIBFPTR_MODEL_ATOL_AUTO,
    IFptr.LIBFPTR_SETTING_PORT, IFptr.LIBFPTR_PORT_COM,
    IFptr.LIBFPTR_SETTING_COM_FILE, "COM5",
    IFptr.LIBFPTR_SETTING_BAUDRATE, IFptr.LIBFPTR_PORT_BR_115200);
fptr.setSettings(settings);

settings = String.format("{\"%s\": %d, \"%s\": %d, \"%s\": \"%s\", \"%s\": %d}",
    IFptr.LIBFPTR_SETTING_MODEL, IFptr.LIBFPTR_MODEL_ATOL_AUTO,
    IFptr.LIBFPTR_SETTING_PORT, IFptr.LIBFPTR_PORT_COM,
    IFptr.LIBFPTR_SETTING_COM_FILE, "COM5",
    IFptr.LIBFPTR_SETTING_BAUDRATE, IFptr.LIBFPTR_PORT_BR_115200);
fptr.setSettings(settings);

NSString *settings = [NSString stringWithFormat:@"{\"%@\": %d, \"%@\": %d, \"%@\": \"%@\", \"%@\": %d}",
    LIBFPTR_SETTING_MODEL, LIBFPTR_MODEL_ATOL_AUTO,
    LIBFPTR_SETTING_PORT, LIBFPTR_PORT_TCPIP,
    LIBFPTR_SETTING_IPADDRESS, @"192.168.1.110",
    LIBFPTR_SETTING_IPPORT, 5555];
[fptr setSettings:settings];

settings = String.Format("{\"{0}\": {1}, \"{2}\": {3}, \"{4}\": \"{5}\", \"{6}\": {7}}",
    Constants.LIBFPTR_SETTING_MODEL, Constants.LIBFPTR_MODEL_ATOL_AUTO,
    Constants.LIBFPTR_SETTING_PORT, Constants.LIBFPTR_PORT_COM,
    Constants.LIBFPTR_SETTING_COM_FILE, "COM5",
    Constants.LIBFPTR_SETTING_BAUDRATE, Constants.LIBFPTR_PORT_BR_115200);
fptr.setSettings(settings);

var 
    settings: String;
begin
  settings := Format('{"%s": %s, "%s": %s, "%s": "%s", "%s": %s}',
    [fptr.LIBFPTR_SETTING_MODEL, IntToStr(fptr.LIBFPTR_MODEL_ATOL_AUTO),
    fptr.LIBFPTR_SETTING_PORT, IntToStr(fptr.LIBFPTR_PORT_COM),
    fptr.LIBFPTR_SETTING_COM_FILE, 'COM5',
    fptr.LIBFPTR_SETTING_BAUDRATE, IntToStr(fptr.LIBFPTR_PORT_BR_115200)]);
  fptr.setSettings(settings);
end;

settings := fmt.Sprintf("{ \"%v\": %d, \"%v\": %d, \"%v\": \"%s\", \"%v\": %d }",
    fptr10.LIBFPTR_SETTING_MODEL, fptr10.LIBFPTR_MODEL_ATOL_AUTO,
    fptr10.LIBFPTR_SETTING_PORT, fptr10.LIBFPTR_PORT_COM,
    fptr10. LIBFPTR_SETTING_COM_FILE, "COM5",
    fptr10.LIBFPTR_SETTING_BAUDRATE, fptr10.LIBFPTR_PORT_BR_115200)
fptr.SetSettings(settings)

// Метод недоступен

Настройка драйвера, способ второй

libfptr_set_single_setting(fptr, LIBFPTR_SETTING_MODEL, std::to_wstring(LIBFPTR_MODEL_ATOL_AUTO).c_str());
libfptr_set_single_setting(fptr, LIBFPTR_SETTING_PORT, std::to_wstring(LIBFPTR_PORT_COM).c_str());
libfptr_set_single_setting(fptr, LIBFPTR_SETTING_COM_FILE, L"COM5");
libfptr_set_single_setting(fptr, LIBFPTR_SETTING_BAUDRATE, LIBFPTR_PORT_BR_115200);
libfptr_apply_single_settings(fptr);

fptr.setSingleSetting(LIBFPTR_SETTING_MODEL, std::to_wstring(LIBFPTR_MODEL_ATOL_AUTO));
fptr.setSingleSetting(LIBFPTR_SETTING_PORT, std::to_wstring(LIBFPTR_PORT_COM));
fptr.setSingleSetting(LIBFPTR_SETTING_COM_FILE, L"COM5");
fptr.setSingleSetting(LIBFPTR_SETTING_BAUDRATE, LIBFPTR_PORT_BR_115200);
fptr.applySingleSettings();

fptr.setSingleSetting(IFptr.LIBFPTR_SETTING_MODEL, str(IFptr.LIBFPTR_MODEL_ATOL_AUTO))
fptr.setSingleSetting(IFptr.LIBFPTR_SETTING_PORT, str(IFptr.LIBFPTR_PORT_COM))
fptr.setSingleSetting(IFptr.LIBFPTR_SETTING_COM_FILE, "COM5")
fptr.setSingleSetting(IFptr.LIBFPTR_SETTING_BAUDRATE, str(IFptr.LIBFPTR_PORT_BR_115200))
fptr.applySingleSettings()

fptr.setSingleSetting(IFptr.LIBFPTR_SETTING_MODEL, String.valueOf(IFptr.LIBFPTR_MODEL_ATOL_AUTO));
fptr.setSingleSetting(IFptr.LIBFPTR_SETTING_PORT, String.valueOf(IFptr.LIBFPTR_PORT_COM));
fptr.setSingleSetting(IFptr.LIBFPTR_SETTING_COM_FILE, "COM5");
fptr.setSingleSetting(IFptr.LIBFPTR_SETTING_BAUDRATE, String.valueOf(IFptr.LIBFPTR_PORT_BR_115200));
fptr.applySingleSettings();

fptr.setSingleSetting(IFptr.LIBFPTR_SETTING_MODEL, String.valueOf(IFptr.LIBFPTR_MODEL_ATOL_AUTO));
fptr.setSingleSetting(IFptr.LIBFPTR_SETTING_PORT, String.valueOf(IFptr.LIBFPTR_PORT_COM));
fptr.setSingleSetting(IFptr.LIBFPTR_SETTING_COM_FILE, "COM5");
fptr.setSingleSetting(IFptr.LIBFPTR_SETTING_BAUDRATE, String.valueOf(IFptr.LIBFPTR_PORT_BR_115200));
fptr.applySingleSettings();

[fptr setSingleSetting:LIBFPTR_SETTING_MODEL, value:[NSString stringWithFormat:@"%d", LIBFPTR_MODEL_ATOL_AUTO]];
[fptr setSingleSetting:LIBFPTR_SETTING_PORT, value:[NSString stringWithFormat:@"%d", LIBFPTR_PORT_TCPIP));
[fptr setSingleSetting:LIBFPTR_SETTING_IPADDRESS, value:@"192.168.1.110");
[fptr setSingleSetting:LIBFPTR_SETTING_IPPORT, value:[NSString stringWithFormat:@"%d", 5555]];
[fptr applySingleSettings];

fptr.setSingleSetting(Constants.LIBFPTR_SETTING_MODEL, Constants.LIBFPTR_MODEL_ATOL_AUTO.ToString());
fptr.setSingleSetting(Constants.LIBFPTR_SETTING_PORT, Constants.LIBFPTR_PORT_COM.ToString());
fptr.setSingleSetting(Constants.LIBFPTR_SETTING_COM_FILE, "COM5");
fptr.setSingleSetting(Constants.LIBFPTR_SETTING_BAUDRATE, Constants.LIBFPTR_PORT_BR_115200.ToString());
fptr.applySingleSettings();

begin
    fptr.setSingleSetting(fptr.LIBFPTR_SETTING_MODEL, IntToStr(fptr.LIBFPTR_MODEL_ATOL_AUTO));
    fptr.setSingleSetting(fptr.LIBFPTR_SETTING_PORT, IntToStr(fptr.LIBFPTR_PORT_COM));
    fptr.setSingleSetting(fptr.LIBFPTR_SETTING_COM_FILE, 'COM5');
    fptr.setSingleSetting(fptr.LIBFPTR_SETTING_BAUDRATE, IntToStr(fptr.LIBFPTR_PORT_BR_115200));
    fptr.applySingleSettings;
end;

fptr.SetSingleSetting(fptr10.LIBFPTR_SETTING_MODEL, strconv.Itoa(fptr10.LIBFPTR_MODEL_ATOL_AUTO))
fptr.SetSingleSetting(fptr10.LIBFPTR_SETTING_PORT, strconv.Itoa(fptr10.LIBFPTR_PORT_COM))
fptr.SetSingleSetting(fptr10.LIBFPTR_SETTING_COM_FILE, "COM5")
fptr.SetSingleSetting(fptr10.LIBFPTR_SETTING_BAUDRATE, strconv.Itoa(fptr10.LIBFPTR_PORT_BR_115200))
fptr.ApplySingleSettings()

// Метод недоступен

Настройка через вызов окна настройки

libfptr_show_properties(fptr, LIBFPTR_GUI_PARENT_NATIVE, <дескриптор окна>);

fptr.showProperties(LIBFPTR_GUI_PARENT_NATIVE, <дескриптор окна>);

fptr.showProperties(IFptr.LIBFPTR_GUI_PARENT_NATIVE, <дескриптор окна>)

fptr.showProperties(IFptr.LIBFPTR_GUI_PARENT_NATIVE, <дескриптор окна>);

public class MainActivity extends AppCompatActivity implements View.OnClickListener {
  private static final int REQUEST_SHOW_SETTINGS = 1;
  private IFptr fptr;

  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
    // ....
    // Создание объекта драйвера
    fptr = new Fptr(getApplication());

    // Вызываем Activity настройки
    findViewById(R.id.btnShowSettings).setOnClickListener(new View.OnClickListener {
        @Override
        public void onClick(View view) {
          Intent intent = new Intent(getApplication(), SettingsActivity.class);
          // Передаем текущие настройки в SettingsActivity.
          // Если не передать - будет показана SettingsActivity с настройками по умолчанию
          intent.putExtra(SettingsActivity.DEVICE_SETTINGS, fptr.getSettings());
          startActivityForResult(intent, REQUEST_SHOW_SETTINGS);
        }
      }
    );
  }

  public void onActivityResult(int requestCode, int resultCode, Intent data) {
    if (requestCode == REQUEST_SHOW_SETTINGS && resultCode == Activity.RESULT_OK) {
      // Записываем настройки в объект
      fptr.setSettings(data.getStringExtra(SettingsActivity.DEVICE_SETTINGS));
    }
  }
}

// Не поддерживается

fptr.showProperties(Constants.LIBFPTR_GUI_PARENT_NATIVE, <дескриптор окна>);

begin
    fptr.showProperties(fptr.LIBFPTR_GUI_PARENT_NATIVE, <дескриптор окна>);
end;

fptr.ShowProperties(fptr10.LIBFPTR_GUI_PARENT_NATIVE, <дескриптор окна>)

// Метод недоступен

Для того, чтобы начать работу с ККТ, требуется настроить соединение с устройством. Есть несколько способов передать в драйвер настройки.

Первый способ - передача всех настроек в виде json. Способ удобен тем, что настройки в таком виде можно запросить у драйвера, сохранить, и при следующей работе с ККТ передать их в драйвер заново как есть. При передаче настроек драйвер разорвет связь с ККТ, если она установлена, изменит настройки и подключится заново. Если по новым настройкам подключиться не удаётся, то драйвер попробует восстановить связь по старым настройкам и вернёт ошибку. Есть некоторая вероятность, что подключиться по старым настройкам также не удастся. В этом случае будет возвращена ошибка, соединение сброшено, а метод isOpened() будет возвращать false.

Второй способ - передача настроек по одной с их применением в конце. Результат и поведение будут идентичны первому способу.

Третий способ - вызов окна настройки связи с ККТ. В случае использования метода showProperties() требуется передать дескриптор родительского окна для отображения модального диалога и указать его тип.

Для передачи дескриптора родительского окна типа QWidget (Qt) требуется указать тип окна LIBFPTR_GUI_PARENT_QT.

Для передачи дескриптора родительского окна типа HWND (WinApi) требуется указать тип окна LIBFPTR_GUI_PARENT_NATIVE. Использование типа окна LIBFPTR_GUI_PARENT_NATIVE на Linux на данный момент не поддерживается.

При передаче нулевого дескриптора диалог настройки будет немодальным.

Метод возвращает следующие значения:

Выгрузка настроек

Выгрузка настроек, способ первый

std::vector<wchar_t> settings(1024);
int size = libfptr_get_settings(fptr, &settings[0], settings.size());
if (size > settings.size())
{
    settings.resize(size);
    libfptr_get_settings(fptr, &settings[0], settings.size());
}

std::wstring settings = fptr.getSettings();

# getSettings() возвращает dict
settings = fptr.getSettings()

# getSettingsStr() возвращает строку
settings = fptr.getSettingsStr()

String settings = fptr.getSettings();

String settings = fptr.getSettings();

NSString *settings = [fptr getSettings];

String settings = fptr.getSettings();

var
    settings: String;
begin
    settings := fptr.getSettings;
end;

settings := fptr.GetSettings()

settings = Fptr.getSettings();

Выгрузка настроек, способ второй (на примере получения IP-адреса и порта)

std::wstring ipAddress, ipPort;

std::vector<wchar_t> setting(1024);
int size = libfptr_get_single_setting(fptr, LIBFPTR_SETTING_IPADDRESS, &setting[0], setting.size());
if (size > settings.size())
{
    setting.resize(size);
    libfptr_get_single_setting(fptr, LIBFPTR_SETTING_IPADDRESS, &setting[0], setting.size());
}
ipAddress = std::wstring(&setting[0]);

int size = libfptr_get_single_setting(fptr, LIBFPTR_SETTING_IPPORT, &setting[0], setting.size());
if (size > settings.size())
{
    setting.resize(size);
    libfptr_get_single_setting(fptr, LIBFPTR_SETTING_IPPORT, &setting[0], setting.size());
}
ipPort = std::wstring(&setting[0]);

std::wstring ipAddress = fptr.getSingleSetting(LIBFPTR_SETTING_IPADDRESS);
std::wstring ipPort = fptr.getSingleSetting(LIBFPTR_SETTING_IPPORT);

ipAddress = fptr.getSingleSetting(IFptr.LIBFPTR_SETTING_IPADDRESS)
ipPort = fptr.getSingleSetting(IFptr.LIBFPTR_SETTING_IPPORT)

String ipAddress = fptr.getSingleSetting(IFptr.LIBFPTR_SETTING_IPADDRESS);
String ipPort = fptr.getSingleSetting(IFptr.LIBFPTR_SETTING_IPPORT);

String ipAddress = fptr.getSingleSetting(IFptr.LIBFPTR_SETTING_IPADDRESS);
String ipPort = fptr.getSingleSetting(IFptr.LIBFPTR_SETTING_IPPORT);

NSString *ipAddress = [fptr getSingleSetting:LIBFPTR_SETTING_IPADDRESS];
NSString *ipPort = [fptr getSingleSetting:LIBFPTR_SETTING_IPPORT];

String ipAddress = fptr.getSingleSetting(Constants.LIBFPTR_SETTING_IPADDRESS);
String ipPort = fptr.getSingleSetting(Constants.LIBFPTR_SETTING_IPPORT);

var
    ipAddress:  String;
    ipPort:     String;
begin
    ipAddress   := fptr.getSingleSetting(fptr.LIBFPTR_SETTING_IPADDRESS);
    ipPort      := fptr.getSingleSetting(fptr.LIBFPTR_SETTING_IPPORT);
end;

ipAddress := fptr.GetSingleSetting(fptr10.LIBFPTR_SETTING_IPADDRESS)
ipPort := fptr.GetSingleSetting(fptr10.LIBFPTR_SETTING_IPPORT)

ipAddress = Fptr.getSingleSetting(Fptr.LIBFPTR_SETTING_IPADDRESS);
ipPort = Fptr.getSingleSetting(Fptr.LIBFPTR_SETTING_IPPORT);

Выгрузить настройки также можно двумя способами.

Первый позволяет получить все настройки разом в виде json.

Используя второй способ, можно получить отдельно значение каждой настройки.

Список настроек

Все настройки можно поделить на несколько категорий.

К первой относятся общие настройки драйвера, которые отвечают непосредственно за его поведение.

Это следующие настройки:

Ко второй относятся настройки связи с ККТ.

Третья - настройки подключения к серверу удалённого доступа (подробнее - Сервер удалённого доступа):

Методы и параметры драйвера

Установка целочисленного параметра

libfptr_set_param_int(fptr, LIBFPTR_PARAM_TAX_TYPE, LIBFPTR_TAX_VAT18);

fptr.setParam(LIBFPTR_PARAM_TAX_TYPE, LIBFPTR_TAX_VAT18);

fptr.setParam(IFptr.LIBFPTR_PARAM_TAX_TYPE, IFptr.LIBFPTR_TAX_VAT18)

fptr.setParam(IFptr.LIBFPTR_PARAM_TAX_TYPE, IFptr.LIBFPTR_TAX_VAT18);

fptr.setParam(IFptr.LIBFPTR_PARAM_TAX_TYPE, IFptr.LIBFPTR_TAX_VAT18);

[fptr setParam:LIBFPTR_PARAM_TAX_TYPE intParam:LIBFPTR_TAX_VAT18];

fptr.setParam(Constants.LIBFPTR_PARAM_TAX_TYPE, Constants.LIBFPTR_TAX_VAT18);

begin
    fptr.setParam(fptr.LIBFPTR_PARAM_TAX_TYPE, fptr.LIBFPTR_TAX_VAT18);
end;

fptr.SetParam(fptr10.LIBFPTR_PARAM_TAX_TYPE, fptr10.LIBFPTR_TAX_VAT18)

Fptr.setParam(Fptr.LIBFPTR_PARAM_TAX_TYPE, Fptr.LIBFPTR_TAX_VAT18);

Установка целочисленного реквизита ФН (без печати на чековой ленте)

libfptr_set_non_printable_param_int(fptr, 1229, 500);

fptr.setNonPrintableParam(1229, 500);

fptr.setNonPrintableParam(1229, 500)

fptr.setNonPrintableParam(1229, 500);

fptr.setNonPrintableParam(1229, 500);

[fptr setNonPrintableParam:1229 intParam:500];

fptr.setNonPrintableParam(1229, 500);

begin
    fptr.setNonPrintableParam(1229, 500);
end;

fptr.SetNonPrintableParam(1229, 500)

Fptr.setParam(1229, 500);

Установка дробного параметра

libfptr_set_param_double(fptr, LIBFPTR_PARAM_PRICE, 123.45);

fptr.setParam(LIBFPTR_PARAM_PRICE, 123.45);

fptr.setParam(IFptr.LIBFPTR_PARAM_PRICE, 123.45)

fptr.setParam(IFptr.LIBFPTR_PARAM_PRICE, 123.45);

fptr.setParam(IFptr.LIBFPTR_PARAM_PRICE, 123.45);

[fptr setParam:LIBFPTR_PARAM_PRICE doubleParam:123.45];

fptr.setParam(Constants.LIBFPTR_PARAM_PRICE, 123.45);

begin
    fptr.setParam(fptr.LIBFPTR_PARAM_PRICE, 123.45);
end;

fptr.SetParam(fptr10.LIBFPTR_PARAM_PRICE, 500)

Fptr.setParam(Fptr.LIBFPTR_PARAM_PRICE, 500);

Установка логического параметра

libfptr_set_param_bool(fptr, LIBFPTR_PARAM_FONT_DOUBLE_WIDTH, true);

fptr.setParam(LIBFPTR_PARAM_FONT_DOUBLE_WIDTH, true);

fptr.setParam(IFptr.LIBFPTR_PARAM_FONT_DOUBLE_WIDTH, True)

fptr.setParam(IFptr.LIBFPTR_PARAM_FONT_DOUBLE_WIDTH, true);

fptr.setParam(IFptr.LIBFPTR_PARAM_FONT_DOUBLE_WIDTH, true);

[fptr setParam:LIBFPTR_PARAM_FONT_DOUBLE_WIDTH boolParam:true];

fptr.setParam(Constants.LIBFPTR_PARAM_FONT_DOUBLE_WIDTH, true);

begin
    fptr.setParam(fptr.LIBFPTR_PARAM_FONT_DOUBLE_WIDTH, True);
end;

fptr.SetParam(fptr10.LIBFPTR_PARAM_FONT_DOUBLE_WIDTH, true)

Fptr.setParam(Fptr.LIBFPTR_PARAM_FONT_DOUBLE_WIDTH, true);

Установка строкового параметра

libfptr_set_param_str(fptr, LIBFPTR_PARAM_COMMODITY_NAME, L"Товар");

fptr.setParam(LIBFPTR_PARAM_COMMODITY_NAME, L"Товар");

fptr.setParam(IFptr.LIBFPTR_PARAM_COMMODITY_NAME, "Товар")

fptr.setParam(IFptr.LIBFPTR_PARAM_COMMODITY_NAME, "Товар");

fptr.setParam(IFptr.LIBFPTR_PARAM_COMMODITY_NAME, "Товар");

[fptr setParam:LIBFPTR_PARAM_COMMODITY_NAME NSStringParam:@"Товар"];

fptr.setParam(Constants.LIBFPTR_PARAM_COMMODITY_NAME, "Товар");

begin
    fptr.setParam(fptr.LIBFPTR_PARAM_COMMODITY_NAME, 'Товар');
end;

fptr.SetParam(fptr10.LIBFPTR_PARAM_COMMODITY_NAME, "Товар")

Fptr.setParam(Fptr.LIBFPTR_PARAM_COMMODITY_NAME, "Товар");

Установка строкового реквизита ФН (без печати на чековой ленте)

libfptr_set_non_printable_param_str(fptr, 1191, L"Позиция №1");

fptr.setNonPrintableParam(1191, L"Позиция №1");

fptr.setNonPrintableParam(1191, "Позиция №1")

fptr.setNonPrintableParam(1191, "Позиция №1");

fptr.setNonPrintableParam(1191, "Позиция №1");

[fptr setNonPrintableParam:1191 NSStringParam:@"Позиция №1"];

fptr.setNonPrintableParam(1191, "Позиция №1");

begin
    fptr.setNonPrintableParam(1191, 'Позиция №1');
end;

fptr.SetNonPrintableParam(1191, "Позиция №1")

Fptr.setNonPrintableParam(1191, "Позиция №1");

Установка параметра дата / время

time_t t = time(NULL);
struct tm tm = *localtime(&t);
libfptr_set_param_datetime(fptr, LIBFPTR_PARAM_DATE_TIME, tm.tm_mon + 1, tm.tm_mday, tm.tm_hour, tm.tm_min, tm.tm_sec);

std::time_t t = time(nullptr);
std::tm tm = *localtime(&t);
fptr.setParam(LIBFPTR_PARAM_DATE_TIME, tm);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATE_TIME, datetime.datetime.now())

Calendar c = Calendar.getInstance();
fptr.setParam(IFptr.LIBFPTR_PARAM_DATE_TIME, c.getTime());

Calendar c = Calendar.getInstance();
fptr.setParam(IFptr.LIBFPTR_PARAM_DATE_TIME, c.getTime());

NSDate *now = [NSDate date];
[fptr setParam:LIBFPTR_PARAM_DATE_TIME NSDateParam:now];

fptr.setParam(Constants.LIBFPTR_PARAM_DATE_TIME, DateTime.Now);

begin
    fptr.setParam(fptr.LIBFPTR_PARAM_DATE_TIME, date);
end;

fptr.SetParam(fptr10.LIBFPTR_PARAM_DATE_TIME, time.Now())

Fptr.setParam(Fptr.LIBFPTR_PARAM_DATE_TIME, Date.now());

Установка массива байтов

uchar command[] = {0x91, 0x13, 0x00, 0x00};
libfptr_set_param_bytearray(fptr, LIBFPTR_PARAM_COMMAND_BUFFER, 
                            &command[0], sizeof(command) / sizeof(command[0]));

fptr.setParam(LIBFPTR_PARAM_COMMAND_BUFFER, {0x91, 0x13, 0x00, 0x00});
fptr.setParam(LIBFPTR_PARAM_COMMAND_BUFFER, std::vector<uchar>{0x91, 0x13, 0x00, 0x00});
uchar command[] = {0x91, 0x13, 0x00, 0x00};
fptr.setParam(LIBFPTR_PARAM_COMMAND_BUFFER, &command[0], sizeof(command) / sizeof(command[0]));

fptr.setParam(IFptr.LIBFPTR_PARAM_COMMAND_BUFFER, [0x91, 0x13, 0x00, 0x00])

fptr.setParam(IFptr.LIBFPTR_PARAM_COMMAND_BUFFER, new byte[]{0x91, 0x13, 0x00, 0x00});

fptr.setParam(IFptr.LIBFPTR_PARAM_COMMAND_BUFFER, new byte[]{0x91, 0x13, 0x00, 0x00});

uchar command[] = {0x91, 0x13, 0x00, 0x00};
[fptr setParam:LIBFPTR_PARAM_COMMAND_BUFFER NSDataParam:[NSData dataWithBytes:(const void*)command length:sizeof(command)]];

fptr.setParam(Constants.LIBFPTR_PARAM_COMMAND_BUFFER, new byte[]{0x91, 0x13, 0x00, 0x00});

var
    command_byte_array:    Array[0 .. 3] of Byte = ($91, $13, $00, $00);
    command_variant:       Variant;
    i:                     Integer;
begin
    command_variant := VarArrayCreate([0, high(command_byte_array)], varByte);
    for i := VarArrayLowBound(command_variant, 1) to VarArrayHighBound(command_variant, 1) do
    begin
        VarArrayPut(command_variant, command_byte_array[i], [i]);
    end;
    fptr.setParam(fptr.LIBFPTR_PARAM_COMMAND_BUFFER, command_variant);
end;

fptr.SetParam(fptr10.LIBFPTR_PARAM_COMMAND_BUFFER, []byte{0x91, 0x13, 0x00, 0x00})

Fptr.setParam(Fptr.LIBFPTR_PARAM_COMMAND_BUFFER, new Uint8Array([0x91, 0x13, 0x00, 0x00]));

Установка байтового реквизита ФН (без печати на чековой ленте)

libfptr_set_param_str(fptr, 1085, L"Название реквизита");
libfptr_set_param_str(fptr, 1086, L"Значение реквизита");
libfptr_util_form_tlv(fptr);

std::vector<uchar> userAttribute(128);
int size = libfptr_get_param_bytearray(fptr, LIBFPTR_PARAM_TAG_VALUE, &userAttribute[0], userAttribute.size());
if (size > userAttribute.size())
{
    userAttribute.resize(size);
    libfptr_get_param_bytearray(fptr, LIBFPTR_PARAM_TAG_VALUE, &userAttribute[0], userAttribute.size());
}
userAttribute.resize(size);

// ...
libfptr_set_non_printable_param_bytearray(fptr, 1084, &userAttribute[0], userAttribute.size());

fptr.setParam(1085, L"Название реквизита");
fptr.setParam(1086, L"Значение реквизита");
fptr.utilFormTlv();
std::vector<uchar> userAttribute = fptr.getParamByteArray(LIBFPTR_PARAM_TAG_VALUE);

# ...
fptr.setNonPrintableParam(1084, userAttribute);

fptr.setParam(1085, "Название реквизита");
fptr.setParam(1086, "Значение реквизита");
fptr.utilFormTlv()
userAttribute = fptr.getParamByteArray(IFptr.LIBFPTR_PARAM_TAG_VALUE)

# ...
fptr.setNonPrintableParam(1084, userAttribute)

fptr.setParam(1085, "Название реквизита");
fptr.setParam(1086, "Значение реквизита");
fptr.utilFormTlv();
byte[] userAttribute = fptr.getParamByteArray(IFptr.LIBFPTR_PARAM_TAG_VALUE);

// ...
fptr.setNonPrintableParam(1084, userAttribute);

fptr.setParam(1085, "Название реквизита");
fptr.setParam(1086, "Значение реквизита");
fptr.utilFormTlv();
byte[] userAttribute = fptr.getParamByteArray(IFptr.LIBFPTR_PARAM_TAG_VALUE);

// ...
fptr.setNonPrintableParam(1084, userAttribute);

[fptr setParam:1085 NSStringParam:@"Название реквизита"];
[fptr setParam:1086 NSStringParam:@"Значение реквизита"];
[fptr utilFormTlv];
NSData *userAttribute = [fptr getParamByteArray:LIBFPTR_PARAM_TAG_VALUE];

// ...
[fptr setNonPrintableParam:1084 NSDataParam:userAttribute];

fptr.setParam(1085, "Название реквизита");
fptr.setParam(1086, "Значение реквизита");
fptr.utilFormTlv();
byte[] userAttribute = fptr.getParamByteArray(Constants.LIBFPTR_PARAM_TAG_VALUE);

// ...
fptr.setNonPrintableParam(1084, userAttribute);

var
    userAttribute: Variant;
begin
    fptr.setParam(1085, 'Название реквизита');
    fptr.setParam(1086, 'Значение реквизита');
    fptr.utilFormTlv;

    userAttribute := fptr.getParamByteArray(fptr.LIBFPTR_PARAM_TAG_VALUE);

    // ...

    fptr.setNonPrintableParam(1084, userAttribute);
end;

fptr.SetParam(1085, "Название реквизита")
fptr.SetParam(1086, "Значение реквизита")
fptr.UtilFormTlv()
userAttribute := fptr.GetParamByteArray(fptr10.LIBFPTR_PARAM_TAG_VALUE)

// ...
fptr.SetNonPrintableParam(1084, userAttribute)

Fptr.setParam(1085, "Название реквизита");
Fptr.setParam(1086, "Значение реквизита");
Fptr.utilFormTlv();
userAttribute = Fptr.getParamByteArray(Fptr.LIBFPTR_PARAM_TAG_VALUE);

// ....
Fptr.setNonPrintableParam(1084, userAttribute);

Получение целочисленного параметра

uint lineLength = libfptr_get_param_int(fptr, LIBFPTR_PARAM_RECEIPT_LINE_LENGTH);

uint lineLength = fptr.getParamInt(LIBFPTR_PARAM_RECEIPT_LINE_LENGTH);

lineLength = fptr.getParamInt(IFptr.LIBFPTR_PARAM_RECEIPT_LINE_LENGTH)

// На самом деле драйвер возвращает unsigned int, но, из-за отсутствия в Java unsigned-типов, возвращается long
long lineLength = fptr.getParamInt(IFptr.LIBFPTR_PARAM_RECEIPT_LINE_LENGTH);

// На самом деле драйвер возвращает unsigned int, но, из-за отсутствия в Java unsigned-типов, возвращается long
long lineLength = fptr.getParamInt(IFptr.LIBFPTR_PARAM_RECEIPT_LINE_LENGTH);

uint lineLength = [fptr getParamInt:LIBFPTR_PARAM_RECEIPT_LINE_LENGTH];

uint lineLength = fptr.getParamInt(Constants.LIBFPTR_PARAM_RECEIPT_LINE_LENGTH);

var
    lineLength: Longint;
begin
    lineLength := fptr.getParamInt(fptr.LIBFPTR_PARAM_RECEIPT_LINE_LENGTH);
end;

lineLength := fptr.GetParamInt(fptr10.LIBFPTR_PARAM_RECEIPT_LINE_LENGTH)

lineLength = Fptr.getParamInt(Fptr.LIBFPTR_PARAM_RECEIPT_LINE_LENGTH);

Получение дробного параметра

double cashSum = libfptr_get_param_double(fptr, LIBFPTR_PARAM_SUM);

double cashSum = fptr.getParamDouble(LIBFPTR_PARAM_SUM);

cashSum = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_SUM)

double cashSum = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_SUM);

double cashSum = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_SUM);

double cashSum = [fptr getParamDouble:LIBFPTR_PARAM_SUM];

double cashSum = fptr.getParamDouble(Constants.LIBFPTR_PARAM_SUM);

var
    cashSum: Double;
begin
    cashSum := fptr.getParamDouble(fptr.LIBFPTR_PARAM_SUM);
end;

cashSum := fptr.GetParamDouble(fptr10.LIBFPTR_PARAM_SUM)

cashSum = Fptr.getParamDouble(Fptr.LIBFPTR_PARAM_SUM);

Получение логического параметра

bool coverOpened = (libfptr_get_param_bool(fptr, LIBFPTR_PARAM_COVER_OPENED) != 0);

bool coverOpened = fptr.getParamBool(LIBFPTR_PARAM_COVER_OPENED);

coverOpened = fptr.getParamBool(IFptr.LIBFPTR_PARAM_COVER_OPENED)

boolean coverOpened = fptr.getParamBool(IFptr.LIBFPTR_PARAM_COVER_OPENED);

boolean coverOpened = fptr.getParamBool(IFptr.LIBFPTR_PARAM_COVER_OPENED);

bool coverOpened = [fptr getParamBool:LIBFPTR_PARAM_COVER_OPENED];

bool coverOpened = fptr.getParamBool(Constants.LIBFPTR_PARAM_COVER_OPENED);

var
    coverOpened: LongBool;
begin
    coverOpened := fptr.getParamBool(fptr.LIBFPTR_PARAM_COVER_OPENED);
end;

coverOpened := fptr.GetParamBool(fptr10.LIBFPTR_PARAM_COVER_OPENED)

coverOpened = Fptr.getParamBool(Fptr.LIBFPTR_PARAM_COVER_OPENED);

Получение строкового параметра

std::vector<wchar_t> str(64);
int size = libfptr_get_param_str(fptr, LIBFPTR_PARAM_UNIT_VERSION, &str[0], str.size());
if (size > str.size())
{
    unitVersion.resize(size);
    libfptr_get_param_str(fptr, LIBFPTR_PARAM_UNIT_VERSION, &str[0], str.size());
}
std::wstring unitVersion = std::wstring(&str[0]);

std::wstring unitVersion = fptr.getParamString(LIBFPTR_PARAM_UNIT_VERSION);

unitVersion = fptr.getParamString(IFptr.LIBFPTR_PARAM_UNIT_VERSION)

String unitVersion = fptr.getParamString(IFptr.LIBFPTR_PARAM_UNIT_VERSION);

String unitVersion = fptr.getParamString(IFptr.LIBFPTR_PARAM_UNIT_VERSION);

NSString *unitVersion = [fptr getParamString:LIBFPTR_PARAM_UNIT_VERSION];

String unitVersion = fptr.getParamString(Constants.LIBFPTR_PARAM_UNIT_VERSION);

var
    unitVersion: String;
begin
    unitVersion := fptr.getParamString(fptr.LIBFPTR_PARAM_UNIT_VERSION);
end;

unitVersion := fptr.GetParamString(fptr10.LIBFPTR_PARAM_UNIT_VERSION)

unitVersion = Fptr.getParamString(Fptr.LIBFPTR_PARAM_UNIT_VERSION);

Получение параметра дата / время

int year, month, day, hour, minute, second;
libfptr_get_param_datetime(fptr, LIBFPTR_PARAM_DATE_TIME, &year, &month, &day, &hour, &minute, &second);

std::tm dateTime = fptr.getParamDateTime(LIBFPTR_PARAM_DATE_TIME);

dateTime = fptr.getParamDateTime(IFptr.LIBFPTR_PARAM_DATE_TIME)

Date dateTime = fptr.getParamDateTime(IFptr.LIBFPTR_PARAM_DATE_TIME);

Date dateTime = fptr.getParamDateTime(IFptr.LIBFPTR_PARAM_DATE_TIME);

NSDate *dateTime = [fptr getParamDateTime:LIBFPTR_PARAM_DATE_TIME];

DateTime dateTime = fptr.getParamDateTime(Constants.LIBFPTR_PARAM_DATE_TIME);

var
    dateTime: TDateTime;
begin
    dateTime := fptr.getParamDateTime(fptr.LIBFPTR_PARAM_DATE_TIME);
end;

dateTime := fptr.GetParamDateTime(fptr10.LIBFPTR_PARAM_DATE_TIME)

dateTime = Fptr.getParamDateTime(Fptr.LIBFPTR_PARAM_DATE_TIME);

Получение массива байтов

std::vector<uchar> commandAnswer(32);
int size = libfptr_get_param_bytearray(fptr, LIBFPTR_PARAM_ANSWER_BUFFER, 
                                       &commandAnswer[0], commandAnswer.size());
if (size > commandAnswer.size())
{
    commandAnswer.resize(size);
    libfptr_get_param_bytearray(fptr, LIBFPTR_PARAM_ANSWER_BUFFER, 
                                &commandAnswer[0], commandAnswer.size());
}
commandAnswer.resize(size);

std::vector<uchar> commandAnswer = fptr.getParamByteArray(LIBFPTR_PARAM_ANSWER_BUFFER);

commandAnswer = fptr.getParamByteArray(IFptr.LIBFPTR_PARAM_ANSWER_BUFFER)

byte[] commandAnswer = fptr.getParamByteArray(IFptr.LIBFPTR_PARAM_ANSWER_BUFFER);

byte[] commandAnswer = fptr.getParamByteArray(IFptr.LIBFPTR_PARAM_ANSWER_BUFFER);

NSData *commandAnswer = [fptr getParamByteArray:LIBFPTR_PARAM_ANSWER_BUFFER];

byte[] commandAnswer = fptr.getParamByteArray(Constants.LIBFPTR_PARAM_ANSWER_BUFFER);

var
    commandAnswer: Variant;
begin
    commandAnswer := fptr.getParamByteArray(fptr.LIBFPTR_PARAM_ANSWER_BUFFER);
end;

commandAnswer := fptr.GetParamByteArray(fptr10.LIBFPTR_PARAM_ANSWER_BUFFER)

commandAnswer = Fptr.getParamByteArray(Fptr.LIBFPTR_PARAM_ANSWER_BUFFER);

Работа с ККТ производится с помощью методов и их параметров.

Каждый метод, в зависимости от своих параметров, выполняет определенные операции с устройством. Параметры бывают входные и выходные. Входные параметры влияют на выполняемую операцию, а выходные - это её результат.

Список входных параметров очищается сразу после выполнения метода. Список выходных - перед выполнением следующего.

Каждый метод возвращает 0, если метод выполнился удачно, и -1, если произошла ошибка. Метод showProperties() может вернуть также значение 1. Метод isOpened() не возвращает признак результата, вместо этого он возвращает признак установленного соединения с ККТ.

Параметры бывают следующих типов:

Описания параметров представлены в описании каждого метода.

При работе с драйвером в виде COM-объекта поддерживаются (с помощью типа VARIANT) следующие типы параметров:

При работе с драйвером из Go-обертки поддерживаются (с помощью типа interface{}) следующие типы параметров:

Некоторые реквизиты ФН можно передавать в ККТ с пометкой, что их не нужно печатать на чековой ленте. В драйвер такая возможность поддержана с помощью дополнительных функций установки параметров. Если ККТ не поддерживает такой механизм, что реквизит будет напечатан, а ошибка возвращена не будет.

При работе в JavaScript (Duktape) у методов setParam(), setNonPrintableParam() и setUserParam() добавлен необязательный параметр - флаги. Туда можно передать константу IGNORE_IF_EMPTY, которая отключит передачу параметра в драйвер, если он принимает одно из следующих значений:

Обработка ошибок

Вызов метода

if (libfptr_print_text(fptr) < 0)
{
    int errorCode = libfptr_error_code(fptr);

    std::vector<wchar_t> errorDescription(32);
    int size = libfptr_error_description(fptr, &errorDescription[0], errorDescription.size());
    if (size > errorDescription.size())
    {
        errorDescription.resize(size);
        libfptr_error_description(fptr, &errorDescription[0], errorDescription.size());
    }

    std::wcout << L"Ошибка - " 
               << errorCode 
               << L" [" << std::wstring(&errorDescription[0]) << L"]" 
               << std::endl;
}

if (fptr.printText() < 0) 
{
    std::wcout << L"Ошибка - " 
               << fptr.errorCode() 
               << L" [" << fptr.errorDescription() << L"]" 
               << std::endl;
}

if fptr.printText() < 0:
    print("{} [{}]".format(fptr.errorCode(), fptr.errorDescription()))

if (fptr.printText() < 0) {
    System.out.println(String.format("%d [%s]", fptr.errorCode(), fptr.errorDescription()));
}

if (fptr.printText() < 0) {
    Log.d(TAG, String.format("%d [%s]", fptr.errorCode(), fptr.errorDescription()));
}

if ([fptr printText] < 0) {
    NSLog(@"%d [%@]", [fptr errorCode], [fptr errorDescription]);
}

if (fptr.printText() < 0) {
    Console.WriteLine(String.Format("{0} [{1}]", fptr.errorCode(), fptr.errorDescription()));
}

begin
    if fptr.printText < 0 then
        showmessage('"' + IntToStr(fptr.errorCode) + ' [' + fptr.errorDescription + ']"');
end;

if err := fptr.PrintText(); err != nil {
    switch e := err.(type) {
    case *fptr10.Error:
        log.Println(e)
        return
    }
}

log.Println(fptr.ErrorCode())
log.Println(fptr.ErrorDescription())

if (Fptr.printText() < 0) {
    Fptr.logWrite("FiscalPrinter", Fptr.LIBFPTR_LOG_ERROR, Fptr.errorCode().toString() + " [" + Fptr.errorDescription() + "]");
}

Каждый метод драйвера возвращает индикатор результата выполнения. Этот индикатор может принимать значения 0 и -1.

В случае, если индикатор не равен 0, выполнение метода завершилось с ошибкой и есть возможность получить подробности о ней. Для этого у драйвера можно запросить код последней ошибки (метод errorCode()) и её текстовое описание (метод errorDescription()).

В случае с Go, метод возвращает error с типом fptr10.Error, в котором содержатся код ошибки и описание ошибки.

Драйвер хранит информацию об ошибке до следующего вызова метода - после него информация об ошибке обновляется. Для явного сброса информации о последней ошибки нужно использовать метод resetError().

Список кодов ошибок приведен в приложении Список кодов ошибок.

Соединение с ККТ

Установка соединения с ККТ

libfptr_open(fptr);

fptr.open();

fptr.open()

fptr.open();

fptr.open();

[fptr open];

fptr.open();

begin
    fptr.open;
end;

fptr.Open()

// Метод недоступен

Проверка состояния логического соединения

bool isOpened = (libfptr_is_opened(fptr) != 0);

bool isOpened = fptr.isOpened();

isOpened = fptr.isOpened()

boolean isOpened = fptr.isOpened();

boolean isOpened = fptr.isOpened();

bool isOpened = [fptr isOpened];

bool isOpened = fptr.isOpened();

var
    isOpened: LongBool;
begin
    isOpened := fptr.isOpened;
end;

isOpened := fptr.IsOpened()

// Метод недоступен

Завершение соединения с ККТ

libfptr_close(fptr);

fptr.close();

fptr.close()

fptr.close();

fptr.close();

[fptr close];

fptr.close();

begin
    fptr.close;
end;

fptr.Close()

// Метод недоступен

После настройки рабочего экземпляра можно подключиться к ККТ. Для этого требуется вызвать метод open(). После подключения к ККТ можно выполнять различные операции с ККТ, а также, при соответствующих настройках, драйвер организует для ККТ канал для обмена с ОФД. До вызова данного метода все другие операции с ККТ будет завершаться с ошибкой LIBFPTR_ERROR_CONNECTION_DISABLED.

Чтобы узнать состояние соединения, нужно использовать метод isOpened(). Результат метода не отражает текущее состояние подключения - если с ККТ была разорвана связь, то метод все также будет возвращать true, но методы, выполняющие какие-либо операции над ККТ, будут возвращать ошибку LIBFPTR_ERROR_NO_CONNECTION.

Для завершения соединения с ККТ нужно вызвать метод close(). драйвер вернется в изначальное состояние, как до вызова open(). Канал с ОФД, установленный с его помощью, будет закрыт и отправка документов в ОФД будет прервана.

Запрос информации о ККТ

У ККТ можно запрашивать различную информацию, в том числе текущее состояние, значения счетчиков и общую информацию. Для этого нужно вызвать метод queryData() с определенными параметрами.

Общая информация и статус

Запрос общей информации и статуса ККТ

libfptr_set_param_int(fptr, LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_STATUS);
libfptr_query_data(fptr);

uint operatorID         = libfptr_get_param_int(fptr, LIBFPTR_PARAM_OPERATOR_ID);
uint logicalNumber      = libfptr_get_param_int(fptr, LIBFPTR_PARAM_LOGICAL_NUMBER);
uint shiftState         = libfptr_get_param_int(fptr, LIBFPTR_PARAM_SHIFT_STATE);
uint model              = libfptr_get_param_int(fptr, LIBFPTR_PARAM_MODEL);
uint mode               = libfptr_get_param_int(fptr, LIBFPTR_PARAM_MODE);
uint submode            = libfptr_get_param_int(fptr, LIBFPTR_PARAM_SUBMODE);
uint receiptNumber      = libfptr_get_param_int(fptr, LIBFPTR_PARAM_RECEIPT_NUMBER);
uint documentNumber     = libfptr_get_param_int(fptr, LIBFPTR_PARAM_DOCUMENT_NUMBER);
uint shiftNumber        = libfptr_get_param_int(fptr, LIBFPTR_PARAM_SHIFT_NUMBER);
uint receiptType        = libfptr_get_param_int(fptr, LIBFPTR_PARAM_RECEIPT_TYPE);
uint lineLength         = libfptr_get_param_int(fptr, LIBFPTR_PARAM_RECEIPT_LINE_LENGTH);
uint lineLengthPix      = libfptr_get_param_int(fptr, LIBFPTR_PARAM_RECEIPT_LINE_LENGTH_PIX);

double receiptSum = libfptr_get_param_double(fptr, LIBFPTR_PARAM_RECEIPT_SUM);

bool isFiscalDevice         = (libfptr_get_param_bool(fptr, LIBFPTR_PARAM_FISCAL) != 0);
bool isFiscalFN             = (libfptr_get_param_bool(fptr, LIBFPTR_PARAM_FN_FISCAL) != 0);
bool isFNPresent            = (libfptr_get_param_bool(fptr, LIBFPTR_PARAM_FN_PRESENT) != 0);
bool isInvalidFN            = (libfptr_get_param_bool(fptr, LIBFPTR_PARAM_INVALID_FN) != 0);
bool isCashDrawerOpened     = (libfptr_get_param_bool(fptr, LIBFPTR_PARAM_CASHDRAWER_OPENED) != 0);
bool isPaperPresent         = (libfptr_get_param_bool(fptr, LIBFPTR_PARAM_RECEIPT_PAPER_PRESENT) != 0);
bool isPaperNearEnd         = (libfptr_get_param_bool(fptr, LIBFPTR_PARAM_PAPER_NEAR_END) != 0);
bool isCoverOpened          = (libfptr_get_param_bool(fptr, LIBFPTR_PARAM_COVER_OPENED) != 0);
bool isPrinterConnectionLost= (libfptr_get_param_bool(fptr, LIBFPTR_PARAM_PRINTER_CONNECTION_LOST) != 0);
bool isPrinterError         = (libfptr_get_param_bool(fptr, LIBFPTR_PARAM_PRINTER_ERROR) != 0);
bool isCutError             = (libfptr_get_param_bool(fptr, LIBFPTR_PARAM_CUT_ERROR) != 0);
bool isPrinterOverheat      = (libfptr_get_param_bool(fptr, LIBFPTR_PARAM_PRINTER_OVERHEAT) != 0);
bool isDeviceBlocked        = (libfptr_get_param_bool(fptr, LIBFPTR_PARAM_BLOCKED) != 0)

int year, month, day, hour, minute, second;
libfptr_get_param_datetime(fptr, LIBFPTR_PARAM_DATE_TIME, &year, &month, &day, &hour, &minute, &second);

std::vector<wchar_t> str(1024);
int size = libfptr_get_param_str(fptr, LIBFPTR_PARAM_SERIAL_NUMBER, &str[0], str.size());
if (size > str.size())
{
    str.resize(size);
    libfptr_get_param_str(fptr, LIBFPTR_PARAM_SERIAL_NUMBER, &str[0], str.size());
}
std::wstring serialNumber = std::wstring(&str[0]);

size = libfptr_get_param_str(fptr, LIBFPTR_PARAM_MODEL_NAME, &str[0], str.size());
if (size > str.size())
{
    str.resize(size);
    libfptr_get_param_str(fptr, LIBFPTR_PARAM_MODEL_NAME, &str[0], str.size());
}
std::wstring modelName = std::wstring(&str[0]);

size = libfptr_get_param_str(fptr, LIBFPTR_PARAM_UNIT_VERSION, &str[0], str.size());
if (size > str.size())
{
    str.resize(size);
    libfptr_get_param_str(fptr, LIBFPTR_PARAM_UNIT_VERSION, &str[0], str.size());
}
std::wstring firmwareVersion = std::wstring(&str[0]);

fptr.setParam(LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_STATUS);
fptr.queryData();

uint operatorID      = fptr.getParamInt(LIBFPTR_PARAM_OPERATOR_ID);
uint logicalNumber   = fptr.getParamInt(LIBFPTR_PARAM_LOGICAL_NUMBER);
uint shiftState      = fptr.getParamInt(LIBFPTR_PARAM_SHIFT_STATE);
uint model           = fptr.getParamInt(LIBFPTR_PARAM_MODEL);
uint mode            = fptr.getParamInt(LIBFPTR_PARAM_MODE);
uint submode         = fptr.getParamInt(LIBFPTR_PARAM_SUBMODE);
uint receiptNumber   = fptr.getParamInt(LIBFPTR_PARAM_RECEIPT_NUMBER);
uint documentNumber  = fptr.getParamInt(LIBFPTR_PARAM_DOCUMENT_NUMBER);
uint shiftNumber     = fptr.getParamInt(LIBFPTR_PARAM_SHIFT_NUMBER);
uint receiptType     = fptr.getParamInt(LIBFPTR_PARAM_RECEIPT_TYPE);
uint lineLength      = fptr.getParamInt(LIBFPTR_PARAM_RECEIPT_LINE_LENGTH);
uint lineLengthPix   = fptr.getParamInt(LIBFPTR_PARAM_RECEIPT_LINE_LENGTH_PIX);

double receiptSum = fptr.getParamDouble(LIBFPTR_PARAM_RECEIPT_SUM);

bool isFiscalDevice          = fptr.getParamBool(LIBFPTR_PARAM_FISCAL);
bool isFiscalFN              = fptr.getParamBool(LIBFPTR_PARAM_FN_FISCAL);
bool isFNPresent             = fptr.getParamBool(LIBFPTR_PARAM_FN_PRESENT);
bool isInvalidFN             = fptr.getParamBool(LIBFPTR_PARAM_INVALID_FN);
bool isCashDrawerOpened      = fptr.getParamBool(LIBFPTR_PARAM_CASHDRAWER_OPENED);
bool isPaperPresent          = fptr.getParamBool(LIBFPTR_PARAM_RECEIPT_PAPER_PRESENT);
bool isPaperNearEnd          = fptr.getParamBool(LIBFPTR_PARAM_PAPER_NEAR_END);
bool isCoverOpened           = fptr.getParamBool(LIBFPTR_PARAM_COVER_OPENED);
bool isPrinterConnectionLost = fptr.getParamBool(LIBFPTR_PARAM_PRINTER_CONNECTION_LOST);
bool isPrinterError          = fptr.getParamBool(LIBFPTR_PARAM_PRINTER_ERROR);
bool isCutError              = fptr.getParamBool(LIBFPTR_PARAM_CUT_ERROR);
bool isPrinterOverheat       = fptr.getParamBool(LIBFPTR_PARAM_PRINTER_OVERHEAT);
bool isDeviceBlocked         = fptr.getParamBool(LIBFPTR_PARAM_BLOCKED);

std::tm dateTime = fptr.getParamDateTime(LIBFPTR_PARAM_DATE_TIME);

std::wstring serialNumber    = fptr.getParamString(LIBFPTR_PARAM_SERIAL_NUMBER);
std::wstring modelName       = fptr.getParamString(LIBFPTR_PARAM_MODEL_NAME);
std::wstring firmwareVersion = fptr.getParamString(LIBFPTR_PARAM_UNIT_VERSION);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_STATUS)
fptr.queryData()

operatorID      = fptr.getParamInt(IFptr.LIBFPTR_PARAM_OPERATOR_ID)
logicalNumber   = fptr.getParamInt(IFptr.LIBFPTR_PARAM_LOGICAL_NUMBER)
shiftState      = fptr.getParamInt(IFptr.LIBFPTR_PARAM_SHIFT_STATE)
model           = fptr.getParamInt(IFptr.LIBFPTR_PARAM_MODEL)
mode            = fptr.getParamInt(IFptr.LIBFPTR_PARAM_MODE)
submode         = fptr.getParamInt(IFptr.LIBFPTR_PARAM_SUBMODE)
receiptNumber   = fptr.getParamInt(IFptr.LIBFPTR_PARAM_RECEIPT_NUMBER)
documentNumber  = fptr.getParamInt(IFptr.LIBFPTR_PARAM_DOCUMENT_NUMBER)
shiftNumber     = fptr.getParamInt(IFptr.LIBFPTR_PARAM_SHIFT_NUMBER)
receiptType     = fptr.getParamInt(IFptr.LIBFPTR_PARAM_RECEIPT_TYPE)
lineLength      = fptr.getParamInt(IFptr.LIBFPTR_PARAM_RECEIPT_LINE_LENGTH)
lineLengthPix   = fptr.getParamInt(IFptr.LIBFPTR_PARAM_RECEIPT_LINE_LENGTH_PIX)

receiptSum = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_RECEIPT_SUM)

isFiscalDevice          = fptr.getParamBool(IFptr.LIBFPTR_PARAM_FISCAL)
isFiscalFN              = fptr.getParamBool(IFptr.LIBFPTR_PARAM_FN_FISCAL)
isFNPresent             = fptr.getParamBool(IFptr.LIBFPTR_PARAM_FN_PRESENT)
isInvalidFN             = fptr.getParamBool(IFptr.LIBFPTR_PARAM_INVALID_FN)
isCashDrawerOpened      = fptr.getParamBool(IFptr.LIBFPTR_PARAM_CASHDRAWER_OPENED)
isPaperPresent          = fptr.getParamBool(IFptr.LIBFPTR_PARAM_RECEIPT_PAPER_PRESENT)
isPaperNearEnd          = fptr.getParamBool(IFptr.LIBFPTR_PARAM_PAPER_NEAR_END)
isCoverOpened           = fptr.getParamBool(IFptr.LIBFPTR_PARAM_COVER_OPENED)
isPrinterConnectionLost = fptr.getParamBool(IFptr.LIBFPTR_PARAM_PRINTER_CONNECTION_LOST)
isPrinterError          = fptr.getParamBool(IFptr.LIBFPTR_PARAM_PRINTER_ERROR)
isCutError              = fptr.getParamBool(IFptr.LIBFPTR_PARAM_CUT_ERROR)
isPrinterOverheat       = fptr.getParamBool(IFptr.LIBFPTR_PARAM_PRINTER_OVERHEAT)
isDeviceBlocked         = fptr.getParamBool(IFptr.LIBFPTR_PARAM_BLOCKED)

dateTime = fptr.getParamDateTime(IFptr.LIBFPTR_PARAM_DATE_TIME)

serialNumber    = fptr.getParamString(IFptr.LIBFPTR_PARAM_SERIAL_NUMBER)
modelName       = fptr.getParamString(IFptr.LIBFPTR_PARAM_MODEL_NAME)
firmwareVersion = fptr.getParamString(IFptr.LIBFPTR_PARAM_UNIT_VERSION)

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_STATUS);
fptr.queryData();

long operatorID      = fptr.getParamInt(IFptr.LIBFPTR_PARAM_OPERATOR_ID);
long logicalNumber   = fptr.getParamInt(IFptr.LIBFPTR_PARAM_LOGICAL_NUMBER);
long shiftState      = fptr.getParamInt(IFptr.LIBFPTR_PARAM_SHIFT_STATE);
long model           = fptr.getParamInt(IFptr.LIBFPTR_PARAM_MODEL);
long mode            = fptr.getParamInt(IFptr.LIBFPTR_PARAM_MODE);
long submode         = fptr.getParamInt(IFptr.LIBFPTR_PARAM_SUBMODE);
long receiptNumber   = fptr.getParamInt(IFptr.LIBFPTR_PARAM_RECEIPT_NUMBER);
long documentNumber  = fptr.getParamInt(IFptr.LIBFPTR_PARAM_DOCUMENT_NUMBER);
long shiftNumber     = fptr.getParamInt(IFptr.LIBFPTR_PARAM_SHIFT_NUMBER);
long receiptType     = fptr.getParamInt(IFptr.LIBFPTR_PARAM_RECEIPT_TYPE);
long lineLength      = fptr.getParamInt(IFptr.LIBFPTR_PARAM_RECEIPT_LINE_LENGTH);
long lineLengthPix   = fptr.getParamInt(IFptr.LIBFPTR_PARAM_RECEIPT_LINE_LENGTH_PIX);

double receiptSum = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_RECEIPT_SUM);

boolean isFiscalDevice          = fptr.getParamBool(IFptr.LIBFPTR_PARAM_FISCAL);
boolean isFiscalFN              = fptr.getParamBool(IFptr.LIBFPTR_PARAM_FN_FISCAL);
boolean isFNPresent             = fptr.getParamBool(IFptr.LIBFPTR_PARAM_FN_PRESENT);
boolean isInvalidFN             = fptr.getParamBool(IFptr.LIBFPTR_PARAM_INVALID_FN);
boolean isCashDrawerOpened      = fptr.getParamBool(IFptr.LIBFPTR_PARAM_CASHDRAWER_OPENED);
boolean isPaperPresent          = fptr.getParamBool(IFptr.LIBFPTR_PARAM_RECEIPT_PAPER_PRESENT);
boolean isPaperNearEnd          = fptr.getParamBool(IFptr.LIBFPTR_PARAM_PAPER_NEAR_END);
boolean isCoverOpened           = fptr.getParamBool(IFptr.LIBFPTR_PARAM_COVER_OPENED);
boolean isPrinterConnectionLost = fptr.getParamBool(IFptr.LIBFPTR_PARAM_PRINTER_CONNECTION_LOST);
boolean isPrinterError          = fptr.getParamBool(IFptr.LIBFPTR_PARAM_PRINTER_ERROR);
boolean isCutError              = fptr.getParamBool(IFptr.LIBFPTR_PARAM_CUT_ERROR);
boolean isPrinterOverheat       = fptr.getParamBool(IFptr.LIBFPTR_PARAM_PRINTER_OVERHEAT);
boolean isDeviceBlocked         = fptr.getParamBool(IFptr.LIBFPTR_PARAM_BLOCKED);

Date dateTime = fptr.getParamDateTime(IFptr.LIBFPTR_PARAM_DATE_TIME);

String serialNumber    = fptr.getParamString(IFptr.LIBFPTR_PARAM_SERIAL_NUMBER);
String modelName       = fptr.getParamString(IFptr.LIBFPTR_PARAM_MODEL_NAME);
String firmwareVersion = fptr.getParamString(IFptr.LIBFPTR_PARAM_UNIT_VERSION);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_STATUS);
fptr.queryData();

long operatorID      = fptr.getParamInt(IFptr.LIBFPTR_PARAM_OPERATOR_ID);
long logicalNumber   = fptr.getParamInt(IFptr.LIBFPTR_PARAM_LOGICAL_NUMBER);
long shiftState      = fptr.getParamInt(IFptr.LIBFPTR_PARAM_SHIFT_STATE);
long model           = fptr.getParamInt(IFptr.LIBFPTR_PARAM_MODEL);
long mode            = fptr.getParamInt(IFptr.LIBFPTR_PARAM_MODE);
long submode         = fptr.getParamInt(IFptr.LIBFPTR_PARAM_SUBMODE);
long receiptNumber   = fptr.getParamInt(IFptr.LIBFPTR_PARAM_RECEIPT_NUMBER);
long documentNumber  = fptr.getParamInt(IFptr.LIBFPTR_PARAM_DOCUMENT_NUMBER);
long shiftNumber     = fptr.getParamInt(IFptr.LIBFPTR_PARAM_SHIFT_NUMBER);
long receiptType     = fptr.getParamInt(IFptr.LIBFPTR_PARAM_RECEIPT_TYPE);
long lineLength      = fptr.getParamInt(IFptr.LIBFPTR_PARAM_RECEIPT_LINE_LENGTH);
long lineLengthPix   = fptr.getParamInt(IFptr.LIBFPTR_PARAM_RECEIPT_LINE_LENGTH_PIX);

double receiptSum = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_RECEIPT_SUM);

boolean isFiscalDevice          = fptr.getParamBool(IFptr.LIBFPTR_PARAM_FISCAL);
boolean isFiscalFN              = fptr.getParamBool(IFptr.LIBFPTR_PARAM_FN_FISCAL);
boolean isFNPresent             = fptr.getParamBool(IFptr.LIBFPTR_PARAM_FN_PRESENT);
boolean isInvalidFN             = fptr.getParamBool(IFptr.LIBFPTR_PARAM_INVALID_FN);
boolean isCashDrawerOpened      = fptr.getParamBool(IFptr.LIBFPTR_PARAM_CASHDRAWER_OPENED);
boolean isPaperPresent          = fptr.getParamBool(IFptr.LIBFPTR_PARAM_RECEIPT_PAPER_PRESENT);
boolean isPaperNearEnd          = fptr.getParamBool(IFptr.LIBFPTR_PARAM_PAPER_NEAR_END);
boolean isCoverOpened           = fptr.getParamBool(IFptr.LIBFPTR_PARAM_COVER_OPENED);
boolean isPrinterConnectionLost = fptr.getParamBool(IFptr.LIBFPTR_PARAM_PRINTER_CONNECTION_LOST);
boolean isPrinterError          = fptr.getParamBool(IFptr.LIBFPTR_PARAM_PRINTER_ERROR);
boolean isCutError              = fptr.getParamBool(IFptr.LIBFPTR_PARAM_CUT_ERROR);
boolean isPrinterOverheat       = fptr.getParamBool(IFptr.LIBFPTR_PARAM_PRINTER_OVERHEAT);
boolean isDeviceBlocked         = fptr.getParamBool(IFptr.LIBFPTR_PARAM_BLOCKED);

Date dateTime = fptr.getParamDateTime(IFptr.LIBFPTR_PARAM_DATE_TIME);

String serialNumber    = fptr.getParamString(IFptr.LIBFPTR_PARAM_SERIAL_NUMBER);
String modelName       = fptr.getParamString(IFptr.LIBFPTR_PARAM_MODEL_NAME);
String firmwareVersion = fptr.getParamString(IFptr.LIBFPTR_PARAM_UNIT_VERSION);

[fptr setParam:LIBFPTR_PARAM_DATA_TYPE intParam:LIBFPTR_DT_STATUS];
[fptr queryData];

uint operatorID      = [fptr getParamInt:LIBFPTR_PARAM_OPERATOR_ID];
uint logicalNumber   = [fptr getParamInt:LIBFPTR_PARAM_LOGICAL_NUMBER];
uint shiftState      = [fptr getParamInt:LIBFPTR_PARAM_SHIFT_STATE];
uint model           = [fptr getParamInt:LIBFPTR_PARAM_MODEL];
uint mode            = [fptr getParamInt:LIBFPTR_PARAM_MODE];
uint submode         = [fptr getParamInt:LIBFPTR_PARAM_SUBMODE];
uint receiptNumber   = [fptr getParamInt:LIBFPTR_PARAM_RECEIPT_NUMBER];
uint documentNumber  = [fptr getParamInt:LIBFPTR_PARAM_DOCUMENT_NUMBER];
uint shiftNumber     = [fptr getParamInt:LIBFPTR_PARAM_SHIFT_NUMBER];
uint receiptType     = [fptr getParamInt:LIBFPTR_PARAM_RECEIPT_TYPE];
uint lineLength      = [fptr getParamInt:LIBFPTR_PARAM_RECEIPT_LINE_LENGTH];
uint lineLengthPix   = [fptr getParamInt:LIBFPTR_PARAM_RECEIPT_LINE_LENGTH_PIX];

double receiptSum = [fptr getParamDouble:LIBFPTR_PARAM_RECEIPT_SUM];

bool isFiscalDevice          = [fptr getParamBool:LIBFPTR_PARAM_FISCAL];
bool isFiscalFN              = [fptr getParamBool:LIBFPTR_PARAM_FN_FISCAL];
bool isFNPresent             = [fptr getParamBool:LIBFPTR_PARAM_FN_PRESENT];
bool isInvalidFN             = [fptr getParamBool:LIBFPTR_PARAM_INVALID_FN];
bool isCashDrawerOpened      = [fptr getParamBool:LIBFPTR_PARAM_CASHDRAWER_OPENED];
bool isPaperPresent          = [fptr getParamBool:LIBFPTR_PARAM_RECEIPT_PAPER_PRESENT];
bool isPaperNearEnd          = [fptr getParamBool:LIBFPTR_PARAM_PAPER_NEAR_END];
bool isCoverOpened           = [fptr getParamBool:LIBFPTR_PARAM_COVER_OPENED];
bool isPrinterConnectionLost = [fptr getParamBool:LIBFPTR_PARAM_PRINTER_CONNECTION_LOST];
bool isPrinterError          = [fptr getParamBool:LIBFPTR_PARAM_PRINTER_ERROR];
bool isCutError              = [fptr getParamBool:LIBFPTR_PARAM_CUT_ERROR];
bool isPrinterOverheat       = [fptr getParamBool:LIBFPTR_PARAM_PRINTER_OVERHEAT];
bool isDeviceBlocked         = [fptr getParamBool:LIBFPTR_PARAM_BLOCKED];

NSDate *dateTime = [fptr getParamDateTime:LIBFPTR_PARAM_DATE_TIME];

NSString *serialNumber    = [fptr getParamString:LIBFPTR_PARAM_SERIAL_NUMBER];
NSString *modelName       = [fptr getParamString:LIBFPTR_PARAM_MODEL_NAME];
NSString *firmwareVersion = [fptr getParamString:LIBFPTR_PARAM_UNIT_VERSION];

fptr.setParam(Constants.LIBFPTR_PARAM_DATA_TYPE, Constants.LIBFPTR_DT_STATUS);
fptr.queryData();

uint operatorID      = fptr.getParamInt(Constants.LIBFPTR_PARAM_OPERATOR_ID);
uint logicalNumber   = fptr.getParamInt(Constants.LIBFPTR_PARAM_LOGICAL_NUMBER);
uint shiftState      = fptr.getParamInt(Constants.LIBFPTR_PARAM_SHIFT_STATE);
uint model           = fptr.getParamInt(Constants.LIBFPTR_PARAM_MODEL);
uint mode            = fptr.getParamInt(Constants.LIBFPTR_PARAM_MODE);
uint submode         = fptr.getParamInt(Constants.LIBFPTR_PARAM_SUBMODE);
uint receiptNumber   = fptr.getParamInt(Constants.LIBFPTR_PARAM_RECEIPT_NUMBER);
uint documentNumber  = fptr.getParamInt(Constants.LIBFPTR_PARAM_DOCUMENT_NUMBER);
uint shiftNumber     = fptr.getParamInt(Constants.LIBFPTR_PARAM_SHIFT_NUMBER);
uint receiptType     = fptr.getParamInt(Constants.LIBFPTR_PARAM_RECEIPT_TYPE);
uint lineLength      = fptr.getParamInt(Constants.LIBFPTR_PARAM_RECEIPT_LINE_LENGTH);
uint lineLengthPix   = fptr.getParamInt(Constants.LIBFPTR_PARAM_RECEIPT_LINE_LENGTH_PIX);

double receiptSum = fptr.getParamDouble(Constants.LIBFPTR_PARAM_RECEIPT_SUM);

bool isFiscalDevice          = fptr.getParamBool(Constants.LIBFPTR_PARAM_FISCAL);
bool isFiscalFN              = fptr.getParamBool(Constants.LIBFPTR_PARAM_FN_FISCAL);
bool isFNPresent             = fptr.getParamBool(Constants.LIBFPTR_PARAM_FN_PRESENT);
bool isInvalidFN             = fptr.getParamBool(Constants.LIBFPTR_PARAM_INVALID_FN);
bool isCashDrawerOpened      = fptr.getParamBool(Constants.LIBFPTR_PARAM_CASHDRAWER_OPENED);
bool isPaperPresent          = fptr.getParamBool(Constants.LIBFPTR_PARAM_RECEIPT_PAPER_PRESENT);
bool isPaperNearEnd          = fptr.getParamBool(Constants.LIBFPTR_PARAM_PAPER_NEAR_END);
bool isCoverOpened           = fptr.getParamBool(Constants.LIBFPTR_PARAM_COVER_OPENED);
bool isPrinterConnectionLost = fptr.getParamBool(Constants.LIBFPTR_PARAM_PRINTER_CONNECTION_LOST);
bool isPrinterError          = fptr.getParamBool(Constants.LIBFPTR_PARAM_PRINTER_ERROR);
bool isCutError              = fptr.getParamBool(Constants.LIBFPTR_PARAM_CUT_ERROR);
bool isPrinterOverheat       = fptr.getParamBool(Constants.LIBFPTR_PARAM_PRINTER_OVERHEAT);
bool isDeviceBlocked         = fptr.getParamBool(Constants.LIBFPTR_PARAM_BLOCKED);

DateTime dateTime = fptr.getParamDateTime(Constants.LIBFPTR_PARAM_DATE_TIME);

String serialNumber    = fptr.getParamString(Constants.LIBFPTR_PARAM_SERIAL_NUMBER);
String modelName       = fptr.getParamString(Constants.LIBFPTR_PARAM_MODEL_NAME);
String firmwareVersion = fptr.getParamString(Constants.LIBFPTR_PARAM_UNIT_VERSION);

var
    operatorID:       Longint;
    logicalNumber:    Longint;
    shiftState:       Longint;
    model:            Longint;
    mode:             Longint;
    submode:          Longint;
    receiptNumber:    Longint;
    documentNumber:   Longint;
    shiftNumber:      Longint;
    receiptType:      Longint;
    lineLength:       Longint;
    lineLengthPix:    Longint;

    receiptSum: Double;

    isFiscalDevice:          LongBool;
    isFiscalFN:              LongBool;
    isFNPresent:             LongBool;
    isInvalidFN:             LongBool;
    isCashDrawerOpened:      LongBool;
    isPaperPresent:          LongBool;
    isPaperNearEnd:          LongBool;
    isCoverOpened:           LongBool;
    isPrinterConnectionLost: LongBool;
    isPrinterError:          LongBool;
    isCutError:              LongBool;
    isPrinterOverheat:       LongBool;
    isDeviceBlocked:         LongBool;

    dateTime: TDateTime;

    serialNumber:       String;
    modelName:          String;
    firmwareVersion:    String;
begin
    fptr.setParam(fptr.LIBFPTR_PARAM_DATA_TYPE, fptr.LIBFPTR_DT_STATUS);
    fptr.queryData;

    operatorID      := fptr.getParamInt(fptr.LIBFPTR_PARAM_OPERATOR_ID);
    logicalNumber   := fptr.getParamInt(fptr.LIBFPTR_PARAM_LOGICAL_NUMBER);
    shiftState      := fptr.getParamInt(fptr.LIBFPTR_PARAM_SHIFT_STATE);
    model           := fptr.getParamInt(fptr.LIBFPTR_PARAM_MODEL);
    mode            := fptr.getParamInt(fptr.LIBFPTR_PARAM_MODE);
    submode         := fptr.getParamInt(fptr.LIBFPTR_PARAM_SUBMODE);
    receiptNumber   := fptr.getParamInt(fptr.LIBFPTR_PARAM_RECEIPT_NUMBER);
    documentNumber  := fptr.getParamInt(fptr.LIBFPTR_PARAM_DOCUMENT_NUMBER);
    shiftNumber     := fptr.getParamInt(fptr.LIBFPTR_PARAM_SHIFT_NUMBER);
    receiptType     := fptr.getParamInt(fptr.LIBFPTR_PARAM_RECEIPT_TYPE);
    lineLength      := fptr.getParamInt(fptr.LIBFPTR_PARAM_RECEIPT_LINE_LENGTH);
    lineLengthPix   := fptr.getParamInt(fptr.LIBFPTR_PARAM_RECEIPT_LINE_LENGTH_PIX);

    receiptSum := fptr.getParamDouble(fptr.LIBFPTR_PARAM_RECEIPT_SUM);

    isFiscalDevice          := fptr.getParamBool(fptr.LIBFPTR_PARAM_FISCAL);
    isFiscalFN              := fptr.getParamBool(fptr.LIBFPTR_PARAM_FN_FISCAL);
    isFNPresent             := fptr.getParamBool(fptr.LIBFPTR_PARAM_FN_PRESENT);
    isInvalidFN             := fptr.getParamBool(fptr.LIBFPTR_PARAM_INVALID_FN);
    isCashDrawerOpened      := fptr.getParamBool(fptr.LIBFPTR_PARAM_CASHDRAWER_OPENED);
    isPaperPresent          := fptr.getParamBool(fptr.LIBFPTR_PARAM_RECEIPT_PAPER_PRESENT);
    isPaperNearEnd          := fptr.getParamBool(fptr.LIBFPTR_PARAM_PAPER_NEAR_END);
    isCoverOpened           := fptr.getParamBool(fptr.LIBFPTR_PARAM_COVER_OPENED);
    isPrinterConnectionLost := fptr.getParamBool(fptr.LIBFPTR_PARAM_PRINTER_CONNECTION_LOST);
    isPrinterError          := fptr.getParamBool(fptr.LIBFPTR_PARAM_PRINTER_ERROR);
    isCutError              := fptr.getParamBool(fptr.LIBFPTR_PARAM_CUT_ERROR);
    isPrinterOverheat       := fptr.getParamBool(fptr.LIBFPTR_PARAM_PRINTER_OVERHEAT);
    isDeviceBlocked         := fptr.getParamBool(fptr.LIBFPTR_PARAM_BLOCKED);

    dateTime := fptr.getParamDateTime(fptr.LIBFPTR_PARAM_DATE_TIME);

    serialNumber    := fptr.getParamString(fptr.LIBFPTR_PARAM_SERIAL_NUMBER);
    modelName       := fptr.getParamString(fptr.LIBFPTR_PARAM_MODEL_NAME);
    firmwareVersion := fptr.getParamString(fptr.LIBFPTR_PARAM_UNIT_VERSION);
end;

fptr.SetParam(fptr10.LIBFPTR_PARAM_DATA_TYPE, fptr10.LIBFPTR_DT_STATUS)
fptr.QueryData()

operatorID      := fptr.GetParamInt(fptr10.LIBFPTR_PARAM_OPERATOR_ID)
logicalNumber   := fptr.GetParamInt(fptr10.LIBFPTR_PARAM_LOGICAL_NUMBER)
shiftState      := fptr.GetParamInt(fptr10.LIBFPTR_PARAM_SHIFT_STATE)
model           := fptr.GetParamInt(fptr10.LIBFPTR_PARAM_MODEL)
mode            := fptr.GetParamInt(fptr10.LIBFPTR_PARAM_MODE)
submode         := fptr.GetParamInt(fptr10.LIBFPTR_PARAM_SUBMODE)
receiptNumber   := fptr.GetParamInt(fptr10.LIBFPTR_PARAM_RECEIPT_NUMBER)
documentNumber  := fptr.GetParamInt(fptr10.LIBFPTR_PARAM_DOCUMENT_NUMBER)
shiftNumber     := fptr.GetParamInt(fptr10.LIBFPTR_PARAM_SHIFT_NUMBER)
receiptType     := fptr.GetParamInt(fptr10.LIBFPTR_PARAM_RECEIPT_TYPE)
lineLength      := fptr.GetParamInt(fptr10.LIBFPTR_PARAM_RECEIPT_LINE_LENGTH)
lineLengthPix   := fptr.GetParamInt(fptr10.LIBFPTR_PARAM_RECEIPT_LINE_LENGTH_PIX)

receiptSum := fptr.GetParamDouble(fptr10.LIBFPTR_PARAM_RECEIPT_SUM)

isFiscalDevice          := fptr.GetParamBool(fptr10.LIBFPTR_PARAM_FISCAL)
isFiscalFN              := fptr.GetParamBool(fptr10.LIBFPTR_PARAM_FN_FISCAL)
isFNPresent             := fptr.GetParamBool(fptr10.LIBFPTR_PARAM_FN_PRESENT)
isInvalidFN             := fptr.GetParamBool(fptr10.LIBFPTR_PARAM_INVALID_FN);
isCashDrawerOpened      := fptr.GetParamBool(fptr10.LIBFPTR_PARAM_CASHDRAWER_OPENED)
isPaperPresent          := fptr.GetParamBool(fptr10.LIBFPTR_PARAM_RECEIPT_PAPER_PRESENT)
isPaperNearEnd          := fptr.GetParamBool(fptr10.LIBFPTR_PARAM_PAPER_NEAR_END)
isCoverOpened           := fptr.GetParamBool(fptr10.LIBFPTR_PARAM_COVER_OPENED)
isPrinterConnectionLost := fptr.GetParamBool(fptr10.LIBFPTR_PARAM_PRINTER_CONNECTION_LOST)
isPrinterError          := fptr.GetParamBool(fptr10.LIBFPTR_PARAM_PRINTER_ERROR)
isCutError              := fptr.GetParamBool(fptr10.LIBFPTR_PARAM_CUT_ERROR)
isPrinterOverheat       := fptr.GetParamBool(fptr10.LIBFPTR_PARAM_PRINTER_OVERHEAT)
isDeviceBlocked         := fptr.GetParamBool(fptr10.LIBFPTR_PARAM_BLOCKED)

dateTime := fptr.GetParamDateTime(fptr10.LIBFPTR_PARAM_DATE_TIME)

serialNumber    := fptr.GetParamString(fptr10.LIBFPTR_PARAM_SERIAL_NUMBER)
modelName       := fptr.GetParamString(fptr10.LIBFPTR_PARAM_MODEL_NAME)
firmwareVersion := fptr.GetParamString(fptr10.LIBFPTR_PARAM_UNIT_VERSION)

Fptr.setParam(Fptr.LIBFPTR_PARAM_DATA_TYPE, Fptr.LIBFPTR_DT_STATUS);
Fptr.queryData();

operatorID      = Fptr.getParamInt(Fptr.LIBFPTR_PARAM_OPERATOR_ID);
logicalNumber   = Fptr.getParamInt(Fptr.LIBFPTR_PARAM_LOGICAL_NUMBER);
shiftState      = Fptr.getParamInt(Fptr.LIBFPTR_PARAM_SHIFT_STATE);
model           = Fptr.getParamInt(Fptr.LIBFPTR_PARAM_MODEL);
mode            = Fptr.getParamInt(Fptr.LIBFPTR_PARAM_MODE);
submode         = Fptr.getParamInt(Fptr.LIBFPTR_PARAM_SUBMODE);
receiptNumber   = Fptr.getParamInt(Fptr.LIBFPTR_PARAM_RECEIPT_NUMBER);
documentNumber  = Fptr.getParamInt(Fptr.LIBFPTR_PARAM_DOCUMENT_NUMBER);
shiftNumber     = Fptr.getParamInt(Fptr.LIBFPTR_PARAM_SHIFT_NUMBER);
receiptType     = Fptr.getParamInt(Fptr.LIBFPTR_PARAM_RECEIPT_TYPE);
lineLength      = Fptr.getParamInt(Fptr.LIBFPTR_PARAM_RECEIPT_LINE_LENGTH);
lineLengthPix   = Fptr.getParamInt(Fptr.LIBFPTR_PARAM_RECEIPT_LINE_LENGTH_PIX);

receiptSum = Fptr.getParamDouble(Fptr.LIBFPTR_PARAM_RECEIPT_SUM);

isFiscalDevice          = Fptr.getParamBool(Fptr.LIBFPTR_PARAM_FISCAL);
isFiscalFN              = Fptr.getParamBool(Fptr.LIBFPTR_PARAM_FN_FISCAL);
isFNPresent             = Fptr.getParamBool(Fptr.LIBFPTR_PARAM_FN_PRESENT);
isInvalidFN             = Fptr.getParamBool(Fptr.LIBFPTR_PARAM_INVALID_FN);
isCashDrawerOpened      = Fptr.getParamBool(Fptr.LIBFPTR_PARAM_CASHDRAWER_OPENED);
isPaperPresent          = Fptr.getParamBool(Fptr.LIBFPTR_PARAM_RECEIPT_PAPER_PRESENT);
isPaperNearEnd          = Fptr.getParamBool(Fptr.LIBFPTR_PARAM_PAPER_NEAR_END);
isCoverOpened           = Fptr.getParamBool(Fptr.LIBFPTR_PARAM_COVER_OPENED);
isPrinterConnectionLost = Fptr.getParamBool(Fptr.LIBFPTR_PARAM_PRINTER_CONNECTION_LOST);
isPrinterError          = Fptr.getParamBool(Fptr.LIBFPTR_PARAM_PRINTER_ERROR);
isCutError              = Fptr.getParamBool(Fptr.LIBFPTR_PARAM_CUT_ERROR);
isPrinterOverheat       = Fptr.getParamBool(Fptr.LIBFPTR_PARAM_PRINTER_OVERHEAT);
isDeviceBlocked         = Fptr.getParamBool(Fptr.LIBFPTR_PARAM_BLOCKED);

dateTime = Fptr.getParamDateTime(Fptr.LIBFPTR_PARAM_DATE_TIME);

serialNumber    = Fptr.getParamString(Fptr.LIBFPTR_PARAM_SERIAL_NUMBER);
modelName       = Fptr.getParamString(Fptr.LIBFPTR_PARAM_MODEL_NAME);
firmwareVersion = Fptr.getParamString(Fptr.LIBFPTR_PARAM_UNIT_VERSION);

Для запроса общей информации и статуса необходимо вызвать метод queryData() с типом запроса LIBFPTR_PARAM_DATA_TYPE равным LIBFPTR_DT_STATUS.

Результатом этого запроса будет следующая информация:

Параметр Описание Тип
LIBFPTR_PARAM_OPERATOR_ID Номер кассира int
LIBFPTR_PARAM_LOGICAL_NUMBER Номер ККТ в магазине int
LIBFPTR_PARAM_DATE_TIME Дата и время ККТ datetime
LIBFPTR_PARAM_FISCAL Флаг регистрации ККТ bool
LIBFPTR_PARAM_FN_FISCAL Флаг фискализации ФН bool
LIBFPTR_PARAM_FN_PRESENT Флаг наличия ФН в ККТ bool
LIBFPTR_PARAM_INVALID_FN Флаг корректности ФН bool
LIBFPTR_PARAM_SHIFT_STATE Состояние смены int
LIBFPTR_PARAM_CASHDRAWER_OPENED Денежный ящик открыт bool
LIBFPTR_PARAM_RECEIPT_PAPER_PRESENT Наличие бумаги bool
LIBFPTR_PARAM_PAPER_NEAR_END Бумага скоро закончится. Если датчика скорого окончания бумаги в ККТ нет, то будет всегда возвращаться false bool
LIBFPTR_PARAM_COVER_OPENED Крышка открыта bool
LIBFPTR_PARAM_SERIAL_NUMBER Заводской номер ККТ string
LIBFPTR_PARAM_MODEL Номер модели ККТ int
LIBFPTR_PARAM_MODE Режим ККТ int
LIBFPTR_PARAM_SUBMODE Подрежим ККТ int
LIBFPTR_PARAM_RECEIPT_NUMBER Номер чека (внутренний счетчик ККТ) int
LIBFPTR_PARAM_DOCUMENT_NUMBER Номер документа (внутренний счетчик ККТ) int
LIBFPTR_PARAM_SHIFT_NUMBER Номер открытой смены или номер последней закрытой смены + 1 int
LIBFPTR_PARAM_RECEIPT_TYPE Тип открытого чека int
LIBFPTR_PARAM_RECEIPT_SUM Сумма текущего чека double
LIBFPTR_PARAM_RECEIPT_LINE_LENGTH Ширина чековой ленты, симв. int
LIBFPTR_PARAM_RECEIPT_LINE_LENGTH_PIX Ширина чековой ленты, пикс. int
LIBFPTR_PARAM_MODEL_NAME Название ККТ string
LIBFPTR_PARAM_UNIT_VERSION Версия ПО ККТ string
LIBFPTR_PARAM_PRINTER_CONNECTION_LOST Потеряно соединение с печатным механизмом bool
LIBFPTR_PARAM_PRINTER_ERROR Невосстановимая ошибка печатного механизма bool
LIBFPTR_PARAM_CUT_ERROR Ошибка отрезчика bool
LIBFPTR_PARAM_PRINTER_OVERHEAT Перегрев печатного механизма bool
LIBFPTR_PARAM_BLOCKED ККТ заблокирована из-за ошибок bool

Значение LIBFPTR_PARAM_CASH_DRAWER_STATUS может быть инвертировано по настройке LIBFPTR_SETTING_INVERT_CASH_DRAWER_STATUS.

Возможные значения для состояния смены (LIBFPTR_PARAM_SHIFT_STATE):

Возможные значения для типа открытого чека (LIBFPTR_PARAM_RECEIPT_TYPE):

Возможные значения для номера модели (LIBFPTR_PARAM_MODEL) представлены в разделе Список настроек.

Короткий запрос статуса ККТ

Короткий запрос статуса ККТ

libfptr_set_param_int(fptr, LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_SHORT_STATUS);
libfptr_query_data(fptr);

bool isCashDrawerOpened     = (libfptr_get_param_bool(fptr, LIBFPTR_PARAM_CASHDRAWER_OPENED) != 0);
bool isPaperPresent         = (libfptr_get_param_bool(fptr, LIBFPTR_PARAM_RECEIPT_PAPER_PRESENT) != 0);
bool isPaperNearEnd         = (libfptr_get_param_bool(fptr, LIBFPTR_PARAM_PAPER_NEAR_END) != 0);
bool isCoverOpened          = (libfptr_get_param_bool(fptr, LIBFPTR_PARAM_COVER_OPENED) != 0);

fptr.setParam(LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_SHORT_STATUS);
fptr.queryData();

bool isCashDrawerOpened = fptr.getParamBool(LIBFPTR_PARAM_CASHDRAWER_OPENED);
bool isPaperPresent     = fptr.getParamBool(LIBFPTR_PARAM_RECEIPT_PAPER_PRESENT);
bool isPaperNearEnd     = fptr.getParamBool(LIBFPTR_PARAM_PAPER_NEAR_END);
bool isCoverOpened      = fptr.getParamBool(LIBFPTR_PARAM_COVER_OPENED);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_SHORT_STATUS)
fptr.queryData()

isCashDrawerOpened      = fptr.getParamBool(IFptr.LIBFPTR_PARAM_CASHDRAWER_OPENED)
isPaperPresent          = fptr.getParamBool(IFptr.LIBFPTR_PARAM_RECEIPT_PAPER_PRESENT)
isPaperNearEnd          = fptr.getParamBool(IFptr.LIBFPTR_PARAM_PAPER_NEAR_END)
isCoverOpened           = fptr.getParamBool(IFptr.LIBFPTR_PARAM_COVER_OPENED)

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_SHORT_STATUS);
fptr.queryData();

boolean isCashDrawerOpened      = fptr.getParamBool(IFptr.LIBFPTR_PARAM_CASHDRAWER_OPENED);
boolean isPaperPresent          = fptr.getParamBool(IFptr.LIBFPTR_PARAM_RECEIPT_PAPER_PRESENT);
boolean isPaperNearEnd          = fptr.getParamBool(IFptr.LIBFPTR_PARAM_PAPER_NEAR_END);
boolean isCoverOpened           = fptr.getParamBool(IFptr.LIBFPTR_PARAM_COVER_OPENED);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_SHORT_STATUS);
fptr.queryData();

boolean isCashDrawerOpened      = fptr.getParamBool(IFptr.LIBFPTR_PARAM_CASHDRAWER_OPENED);
boolean isPaperPresent          = fptr.getParamBool(IFptr.LIBFPTR_PARAM_RECEIPT_PAPER_PRESENT);
boolean isPaperNearEnd          = fptr.getParamBool(IFptr.LIBFPTR_PARAM_PAPER_NEAR_END);
boolean isCoverOpened           = fptr.getParamBool(IFptr.LIBFPTR_PARAM_COVER_OPENED);

[fptr setParam:LIBFPTR_PARAM_DATA_TYPE intParam:LIBFPTR_DT_SHORT_STATUS];
[fptr queryData];

bool isCashDrawerOpened      = [fptr getParamBool:LIBFPTR_PARAM_CASHDRAWER_OPENED];
bool isPaperPresent          = [fptr getParamBool:LIBFPTR_PARAM_RECEIPT_PAPER_PRESENT];
bool isPaperNearEnd          = [fptr getParamBool:LIBFPTR_PARAM_PAPER_NEAR_END];
bool isCoverOpened           = [fptr getParamBool:LIBFPTR_PARAM_COVER_OPENED];

fptr.setParam(Constants.LIBFPTR_PARAM_DATA_TYPE, Constants.LIBFPTR_DT_SHORT_STATUS);
fptr.queryData();

bool isCashDrawerOpened      = fptr.getParamBool(Constants.LIBFPTR_PARAM_CASHDRAWER_OPENED);
bool isPaperPresent          = fptr.getParamBool(Constants.LIBFPTR_PARAM_RECEIPT_PAPER_PRESENT);
bool isPaperNearEnd          = fptr.getParamBool(Constants.LIBFPTR_PARAM_PAPER_NEAR_END);
bool isCoverOpened           = fptr.getParamBool(Constants.LIBFPTR_PARAM_COVER_OPENED);

var
    isCashDrawerOpened:      LongBool;
    isPaperPresent:          LongBool;
    isPaperNearEnd:          LongBool;
    isCoverOpened:           LongBool;
begin
    fptr.setParam(fptr.LIBFPTR_PARAM_DATA_TYPE, fptr.LIBFPTR_DT_SHORT_STATUS);
    fptr.queryData;

    isCashDrawerOpened      := fptr.getParamBool(fptr.LIBFPTR_PARAM_CASHDRAWER_OPENED);
    isPaperPresent          := fptr.getParamBool(fptr.LIBFPTR_PARAM_RECEIPT_PAPER_PRESENT);
    isPaperNearEnd          := fptr.getParamBool(fptr.LIBFPTR_PARAM_PAPER_NEAR_END);
    isCoverOpened           := fptr.getParamBool(fptr.LIBFPTR_PARAM_COVER_OPENED);
end;

fptr.SetParam(fptr.LIBFPTR_PARAM_DATA_TYPE, fptr.LIBFPTR_DT_SHORT_STATUS)
fptr.QueryData()

isCashDrawerOpened      := fptr.GetParamBool(fptr10.LIBFPTR_PARAM_CASHDRAWER_OPENED)
isPaperPresent          := fptr.GetParamBool(fptr10.LIBFPTR_PARAM_RECEIPT_PAPER_PRESENT)
isPaperNearEnd          := fptr.GetParamBool(fptr10.LIBFPTR_PARAM_PAPER_NEAR_END)
isCoverOpened           := fptr.GetParamBool(fptr10.LIBFPTR_PARAM_COVER_OPENED)

Fptr.setParam(Fptr.LIBFPTR_PARAM_DATA_TYPE, Fptr.LIBFPTR_DT_STATUS);
Fptr.queryData();

isCashDrawerOpened      = Fptr.getParamBool(Fptr.LIBFPTR_PARAM_CASHDRAWER_OPENED);
isPaperPresent          = Fptr.getParamBool(Fptr.LIBFPTR_PARAM_RECEIPT_PAPER_PRESENT);
isPaperNearEnd          = Fptr.getParamBool(Fptr.LIBFPTR_PARAM_PAPER_NEAR_END);
isCoverOpened           = Fptr.getParamBool(Fptr.LIBFPTR_PARAM_COVER_OPENED);

Для короткого запроса статуса ККТ необходимо вызвать метод queryData() с типом запроса LIBFPTR_PARAM_DATA_TYPE равным LIBFPTR_DT_SHORT_STATUS.

Результатом этого запроса будет следующая информация:

Параметр Описание Тип
LIBFPTR_PARAM_CASHDRAWER_OPENED Денежный ящик открыт bool
LIBFPTR_PARAM_RECEIPT_PAPER_PRESENT Наличие бумаги bool
LIBFPTR_PARAM_PAPER_NEAR_END Бумага скоро закончится. Если датчика скорого окончания бумаги в ККТ нет, то будет всегда возвращаться false bool
LIBFPTR_PARAM_COVER_OPENED Крышка открыта bool

Значение LIBFPTR_PARAM_CASH_DRAWER_STATUS может быть инвертировано по настройке LIBFPTR_SETTING_INVERT_CASH_DRAWER_STATUS.

Сумма наличных в денежном ящике

Запрос суммы наличных в денежном ящике

libfptr_set_param_int(fptr, LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_CASH_SUM);
libfptr_query_data(fptr);

double cashSum = libfptr_get_param_double(fptr, LIBFPTR_PARAM_SUM);

fptr.setParam(LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_CASH_SUM);
fptr.queryData();

double cashSum = fptr.getParamDouble(LIBFPTR_PARAM_SUM);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_CASH_SUM)
fptr.queryData()

cashSum = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_SUM)

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_CASH_SUM);
fptr.queryData();

double cashSum = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_SUM);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_CASH_SUM);
fptr.queryData();

double cashSum = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_SUM);

[fptr setParam:LIBFPTR_PARAM_DATA_TYPE intParam:LIBFPTR_DT_CASH_SUM];
[fptr queryData];

double cashSum = [fptr getParamDouble:LIBFPTR_PARAM_SUM];

fptr.setParam(Constants.LIBFPTR_PARAM_DATA_TYPE, Constants.LIBFPTR_DT_CASH_SUM);
fptr.queryData();

double cashSum = fptr.getParamDouble(Constants.LIBFPTR_PARAM_SUM);

var
    cashSum: Double;
begin
    fptr.setParam(fptr.LIBFPTR_PARAM_DATA_TYPE, fptr.LIBFPTR_DT_CASH_SUM);
    fptr.queryData;

    cashSum := fptr.getParamDouble(fptr.LIBFPTR_PARAM_SUM);
end;

fptr.SetParam(fptr10.LIBFPTR_PARAM_DATA_TYPE, fptr10.LIBFPTR_DT_CASH_SUM)
fptr.QueryData()

cashSum := fptr.GetParamDouble(fptr10.LIBFPTR_PARAM_SUM)

Fptr.setParam(Fptr.LIBFPTR_PARAM_DATA_TYPE, Fptr.LIBFPTR_DT_CASH_SUM);
Fptr.queryData();

cashSum = Fptr.getParamDouble(Fptr.LIBFPTR_PARAM_SUM);

Для запроса суммы наличности в денежном ящике необходимо вызвать метод queryData() с типом запроса LIBFPTR_PARAM_DATA_TYPE равным LIBFPTR_DT_CASH_SUM.

Результатом этого запроса будет следующая информация:

Параметр Описание Тип
LIBFPTR_PARAM_SUM Сумма наличных в ДЯ double

Версия модуля

Запрос версии прошивки

libfptr_set_param_int(fptr, LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_UNIT_VERSION);
libfptr_set_param_int(fptr, LIBFPTR_PARAM_UNIT_TYPE, LIBFPTR_UT_FIRMWARE);
libfptr_query_data(fptr);

std::vector<wchar_t> str(1024);
int size = libfptr_get_param_str(fptr, LIBFPTR_PARAM_UNIT_VERSION, &str[0], str.size());
if (size > str.size())
{
    str.resize(size);
    libfptr_get_param_str(fptr, LIBFPTR_PARAM_UNIT_VERSION, &str[0], str.size());
}
std::wstring firmwareVersion = std::wstring(&str[0]);

fptr.setParam(LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_UNIT_VERSION);
fptr.setParam(LIBFPTR_PARAM_UNIT_TYPE, LIBFPTR_UT_FIRMWARE);
fptr.queryData();

std::wstring firmwareVersion = fptr.getParamString(LIBFPTR_PARAM_UNIT_VERSION);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_UNIT_VERSION)
fptr.setParam(IFptr.LIBFPTR_PARAM_UNIT_TYPE, IFptr.LIBFPTR_UT_FIRMWARE)
fptr.queryData()

firmwareVersion = fptr.getParamString(IFptr.LIBFPTR_PARAM_UNIT_VERSION)

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_UNIT_VERSION);
fptr.setParam(IFptr.LIBFPTR_PARAM_UNIT_TYPE, IFptr.LIBFPTR_UT_FIRMWARE);
fptr.queryData();

String firmwareVersion = fptr.getParamString(IFptr.LIBFPTR_PARAM_UNIT_VERSION);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_UNIT_VERSION);
fptr.setParam(IFptr.LIBFPTR_PARAM_UNIT_TYPE, IFptr.LIBFPTR_UT_FIRMWARE);
fptr.queryData();

String firmwareVersion = fptr.getParamString(IFptr.LIBFPTR_PARAM_UNIT_VERSION);

[fptr setParam:LIBFPTR_PARAM_DATA_TYPE intParam:LIBFPTR_DT_UNIT_VERSION];
[fptr setParam:LIBFPTR_PARAM_UNIT_TYPE intParam:LIBFPTR_UT_FIRMWARE];
[fptr queryData];

NSString *firmwareVersion = [fptr getParamString:LIBFPTR_PARAM_UNIT_VERSION];

fptr.setParam(Constants.LIBFPTR_PARAM_DATA_TYPE, Constants.LIBFPTR_DT_UNIT_VERSION);
fptr.setParam(Constants.LIBFPTR_PARAM_UNIT_TYPE, Constants.LIBFPTR_UT_FIRMWARE);
fptr.queryData();

String firmwareVersion = fptr.getParamString(Constants.LIBFPTR_PARAM_UNIT_VERSION);

var
    firmwareVersion: String;
begin
    fptr.setParam(fptr.LIBFPTR_PARAM_DATA_TYPE, fptr.LIBFPTR_DT_UNIT_VERSION);
    fptr.setParam(fptr.LIBFPTR_PARAM_UNIT_TYPE, fptr.LIBFPTR_UT_FIRMWARE);
    fptr.queryData;

    firmwareVersion := fptr.getParamString(fptr.LIBFPTR_PARAM_UNIT_VERSION);
end;

fptr.SetParam(fptr10.LIBFPTR_PARAM_DATA_TYPE, fptr10.LIBFPTR_DT_UNIT_VERSION)
fptr.SetParam(fptr10.LIBFPTR_PARAM_UNIT_TYPE, fptr10.LIBFPTR_UT_FIRMWARE)
fptr.QueryData()

firmwareVersion := fptr.GetParamString(fptr10.LIBFPTR_PARAM_UNIT_VERSION)

Fptr.setParam(Fptr.LIBFPTR_PARAM_DATA_TYPE, Fptr.LIBFPTR_DT_UNIT_VERSION);
Fptr.setParam(Fptr.LIBFPTR_PARAM_UNIT_TYPE, Fptr.LIBFPTR_UT_FIRMWARE);
Fptr.queryData();

firmwareVersion = Fptr.getParamString(Fptr.LIBFPTR_PARAM_UNIT_VERSION);

Запрос версии конфигурации

libfptr_set_param_int(fptr, LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_UNIT_VERSION);
libfptr_set_param_int(fptr, LIBFPTR_PARAM_UNIT_TYPE, LIBFPTR_UT_CONFIGURATION);
libfptr_query_data(fptr);

std::vector<wchar_t> str(1024);
int size = libfptr_get_param_str(fptr, LIBFPTR_PARAM_UNIT_VERSION, &str[0], str.size());
if (size > str.size())
{
    str.resize(size);
    libfptr_get_param_str(fptr, LIBFPTR_PARAM_UNIT_VERSION, &str[0], str.size());
}
std::wstring configurationVersion = std::wstring(&str[0]);

int size = libfptr_get_param_str(fptr, LIBFPTR_PARAM_UNIT_RELEASE_VERSION, &str[0], str.size());
if (size > str.size())
{
    str.resize(size);
    libfptr_get_param_str(fptr, LIBFPTR_PARAM_UNIT_RELEASE_VERSION, &str[0], str.size());
}
std::wstring releaseVersion = std::wstring(&str[0]);

fptr.setParam(LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_UNIT_VERSION);
fptr.setParam(IBFPTR_PARAM_UNIT_TYPE, LIBFPTR_UT_CONFIGURATION);
fptr.queryData();

std::wstring configurationVersion = fptr.getParamString(LIBFPTR_PARAM_UNIT_VERSION);
std::wstring releaseVersion = fptr.getParamString(LIBFPTR_PARAM_UNIT_RELEASE_VERSION);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_UNIT_VERSION)
fptr.setParam(IFptr.LIBFPTR_PARAM_UNIT_TYPE, IFptr.LIBFPTR_UT_CONFIGURATION)
fptr.queryData()

configurationVersion = fptr.getParamString(IFptr.LIBFPTR_PARAM_UNIT_VERSION)
releaseVersion = fptr.getParamString(IFptr.LIBFPTR_PARAM_UNIT_RELEASE_VERSION)

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_UNIT_VERSION);
fptr.setParam(IFptr.LIBFPTR_PARAM_UNIT_TYPE, IFptr.LIBFPTR_UT_CONFIGURATION);
fptr.queryData();

String configurationVersion = fptr.getParamString(IFptr.LIBFPTR_PARAM_UNIT_VERSION);
String releaseVersion = fptr.getParamString(IFptr.LIBFPTR_PARAM_UNIT_RELEASE_VERSION);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_UNIT_VERSION);
fptr.setParam(IFptr.LIBFPTR_PARAM_UNIT_TYPE, IFptr.LIBFPTR_UT_CONFIGURATION);
fptr.queryData();

String configurationVersion = fptr.getParamString(IFptr.LIBFPTR_PARAM_UNIT_VERSION);
String releaseVersion = fptr.getParamString(IFptr.LIBFPTR_PARAM_UNIT_RELEASE_VERSION);

[fptr setParam:LIBFPTR_PARAM_DATA_TYPE intParam:LIBFPTR_DT_UNIT_VERSION];
[fptr setParam:LIBFPTR_PARAM_UNIT_TYPE intParam:LIBFPTR_UT_CONFIGURATION];
[fptr queryData];

NSString *configurationVersion = [fptr getParamString:LIBFPTR_PARAM_UNIT_VERSION];
NSString *releaseVersion = [fptr getParamString:LIBFPTR_PARAM_UNIT_RELEASE_VERSION];

fptr.setParam(Constants.LIBFPTR_PARAM_DATA_TYPE, Constants.LIBFPTR_DT_UNIT_VERSION);
fptr.setParam(Constants.LIBFPTR_PARAM_UNIT_TYPE, Constants.LIBFPTR_UT_CONFIGURATION);
fptr.queryData();

String configurationVersion = fptr.getParamString(Constants.LIBFPTR_PARAM_UNIT_VERSION);
String releaseVersion = fptr.getParamString(Constants.LIBFPTR_PARAM_UNIT_RELEASE_VERSION);

var
    configurationVersion: String;
    releaseVersion: String;
begin
    fptr.setParam(fptr.LIBFPTR_PARAM_DATA_TYPE, fptr.LIBFPTR_DT_UNIT_VERSION);
    fptr.setParam(fptr.LIBFPTR_PARAM_UNIT_TYPE, fptr.LIBFPTR_UT_CONFIGURATION);
    fptr.queryData;

    configurationVersion := fptr.getParamString(fptr.LIBFPTR_PARAM_UNIT_VERSION);
    releaseVersion := fptr.getParamString(fptr.LIBFPTR_PARAM_UNIT_RELEASE_VERSION);
end;

fptr.SetParam(fptr10.LIBFPTR_PARAM_DATA_TYPE, fptr10.LIBFPTR_DT_UNIT_VERSION)
fptr.SetParam(fptr10.LIBFPTR_PARAM_UNIT_TYPE, fptr10.LIBFPTR_UT_CONFIGURATION)
fptr.QueryData()

configurationVersion    := fptr.GetParamString(fptr10.LIBFPTR_PARAM_UNIT_VERSION)
releaseVersion          := fptr.GetParamString(fptr10.LIBFPTR_PARAM_UNIT_RELEASE_VERSION)

Fptr.setParam(Fptr.LIBFPTR_PARAM_DATA_TYPE, Fptr.LIBFPTR_DT_UNIT_VERSION);
Fptr.setParam(Fptr.LIBFPTR_PARAM_UNIT_TYPE, Fptr.LIBFPTR_UT_CONFIGURATION);
Fptr.queryData();

configurationVersion = Fptr.getParamString(Fptr.LIBFPTR_PARAM_UNIT_VERSION);
releaseVersion = Fptr.getParamString(Fptr.LIBFPTR_PARAM_UNIT_RELEASE_VERSION);

Запрос версии движка шаблонов

libfptr_set_param_int(fptr, LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_UNIT_VERSION);
libfptr_set_param_int(fptr, LIBFPTR_PARAM_UNIT_TYPE, LIBFPTR_UT_TEMPLATES);
libfptr_query_data(fptr);

std::vector<wchar_t> str(1024);
int size = libfptr_get_param_str(fptr, LIBFPTR_PARAM_UNIT_VERSION, &str[0], str.size());
if (size > str.size())
{
    str.resize(size);
    libfptr_get_param_str(fptr, LIBFPTR_PARAM_UNIT_VERSION, &str[0], str.size());
}
std::wstring templatesVersion = std::wstring(&str[0]);

fptr.setParam(LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_UNIT_VERSION);
fptr.setParam(LIBFPTR_PARAM_UNIT_TYPE, LIBFPTR_UT_TEMPLATES);
fptr.queryData();

std::wstring templatesVersion = fptr.getParamString(LIBFPTR_PARAM_UNIT_VERSION);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_UNIT_VERSION)
fptr.setParam(IFptr.LIBFPTR_PARAM_UNIT_TYPE, IFptr.LIBFPTR_UT_TEMPLATES)
fptr.queryData()

templatesVersion = fptr.getParamString(IFptr.LIBFPTR_PARAM_UNIT_VERSION)

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_UNIT_VERSION);
fptr.setParam(IFptr.LIBFPTR_PARAM_UNIT_TYPE, IFptr.LIBFPTR_UT_TEMPLATES);
fptr.queryData();

String templatesVersion = fptr.getParamString(IFptr.LIBFPTR_PARAM_UNIT_VERSION);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_UNIT_VERSION);
fptr.setParam(IFptr.LIBFPTR_PARAM_UNIT_TYPE, IFptr.LIBFPTR_UT_TEMPLATES);
fptr.queryData();

String templatesVersion = fptr.getParamString(IFptr.LIBFPTR_PARAM_UNIT_VERSION);

[fptr setParam:LIBFPTR_PARAM_DATA_TYPE intParam:LIBFPTR_DT_UNIT_VERSION];
[fptr setParam:LIBFPTR_PARAM_UNIT_TYPE intParam:LIBFPTR_UT_TEMPLATES];
[fptr queryData];

NSString *templatesVersion = [fptr getParamString:LIBFPTR_PARAM_UNIT_VERSION];

fptr.setParam(Constants.LIBFPTR_PARAM_DATA_TYPE, Constants.LIBFPTR_DT_UNIT_VERSION);
fptr.setParam(Constants.LIBFPTR_PARAM_UNIT_TYPE, Constants.LIBFPTR_UT_TEMPLATES);
fptr.queryData();

String templatesVersion = fptr.getParamString(Constants.LIBFPTR_PARAM_UNIT_VERSION);

var
    templatesVersion: String;
begin
    fptr.setParam(fptr.LIBFPTR_PARAM_DATA_TYPE, fptr.LIBFPTR_DT_UNIT_VERSION);
    fptr.setParam(fptr.LIBFPTR_PARAM_UNIT_TYPE, fptr.LIBFPTR_UT_TEMPLATES);
    fptr.queryData;

    templatesVersion := fptr.getParamString(fptr.LIBFPTR_PARAM_UNIT_VERSION);
end;

fptr.SetParam(fptr10.LIBFPTR_PARAM_DATA_TYPE, fptr10.LIBFPTR_DT_UNIT_VERSION)
fptr.SetParam(fptr10.LIBFPTR_PARAM_UNIT_TYPE, fptr10.LIBFPTR_UT_TEMPLATES)
fptr.QueryData()

templatesVersion := fptr.GetParamString(fptr10.LIBFPTR_PARAM_UNIT_VERSION)

Fptr.setParam(Fptr.LIBFPTR_PARAM_DATA_TYPE, Fptr.LIBFPTR_DT_UNIT_VERSION);
Fptr.setParam(Fptr.LIBFPTR_PARAM_UNIT_TYPE, Fptr.LIBFPTR_UT_TEMPLATES);
Fptr.queryData();

templatesVersion = Fptr.getParamString(Fptr.LIBFPTR_PARAM_UNIT_VERSION);

Запрос версии блока управления

libfptr_set_param_int(fptr, LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_UNIT_VERSION);
libfptr_set_param_int(fptr, LIBFPTR_PARAM_UNIT_TYPE, LIBFPTR_UT_CONTROL_UNIT);
libfptr_query_data(fptr);

std::vector<wchar_t> str(1024);
int size = libfptr_get_param_str(fptr, LIBFPTR_PARAM_UNIT_VERSION, &str[0], str.size());
if (size > str.size())
{
    str.resize(size);
    libfptr_get_param_str(fptr, LIBFPTR_PARAM_UNIT_VERSION, &str[0], str.size());
}
std::wstring controlUnitVersion = std::wstring(&str[0]);

fptr.setParam(LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_UNIT_VERSION);
fptr.setParam(LIBFPTR_PARAM_UNIT_TYPE, LIBFPTR_UT_CONTROL_UNIT);
fptr.queryData();

std::wstring controlUnitVersion = fptr.getParamString(LIBFPTR_PARAM_UNIT_VERSION);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_UNIT_VERSION)
fptr.setParam(IFptr.LIBFPTR_PARAM_UNIT_TYPE, IFptr.LIBFPTR_UT_CONTROL_UNIT)
fptr.queryData()

controlUnitVersion = fptr.getParamString(IFptr.LIBFPTR_PARAM_UNIT_VERSION)

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_UNIT_VERSION);
fptr.setParam(IFptr.LIBFPTR_PARAM_UNIT_TYPE, IFptr.LIBFPTR_UT_CONTROL_UNIT);
fptr.queryData();

String controlUnitVersion = fptr.getParamString(IFptr.LIBFPTR_PARAM_UNIT_VERSION);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_UNIT_VERSION);
fptr.setParam(IFptr.LIBFPTR_PARAM_UNIT_TYPE, IFptr.LIBFPTR_UT_CONTROL_UNIT);
fptr.queryData();

String controlUnitVersion = fptr.getParamString(IFptr.LIBFPTR_PARAM_UNIT_VERSION);

[fptr setParam:LIBFPTR_PARAM_DATA_TYPE intParam:LIBFPTR_DT_UNIT_VERSION];
[fptr setParam:LIBFPTR_PARAM_UNIT_TYPE intParam:LIBFPTR_UT_CONTROL_UNIT];
[fptr queryData];

NSString *controlUnitVersion = [fptr getParamString:LIBFPTR_PARAM_UNIT_VERSION];

fptr.setParam(Constants.LIBFPTR_PARAM_DATA_TYPE, Constants.LIBFPTR_DT_UNIT_VERSION);
fptr.setParam(Constants.LIBFPTR_PARAM_UNIT_TYPE, Constants.LIBFPTR_UT_CONTROL_UNIT);
fptr.queryData();

String controlUnitVersion = fptr.getParamString(Constants.LIBFPTR_PARAM_UNIT_VERSION);

var
    controlUnitVersion: String;
begin
    fptr.setParam(fptr.LIBFPTR_PARAM_DATA_TYPE, fptr.LIBFPTR_DT_UNIT_VERSION);
    fptr.setParam(fptr.LIBFPTR_PARAM_UNIT_TYPE, fptr.LIBFPTR_UT_CONTROL_UNIT);
    fptr.queryData;

    controlUnitVersion := fptr.getParamString(fptr.LIBFPTR_PARAM_UNIT_VERSION);
end;

fptr.SetParam(fptr10.LIBFPTR_PARAM_DATA_TYPE, fptr10.LIBFPTR_DT_UNIT_VERSION)
fptr.SetParam(fptr10.LIBFPTR_PARAM_UNIT_TYPE, fptr10.LIBFPTR_UT_CONTROL_UNIT)
fptr.QueryData()

controlUnitVersion := fptr.GetParamString(fptr10.LIBFPTR_PARAM_UNIT_VERSION)

Fptr.setParam(Fptr.LIBFPTR_PARAM_DATA_TYPE, Fptr.LIBFPTR_DT_UNIT_VERSION);
Fptr.setParam(Fptr.LIBFPTR_PARAM_UNIT_TYPE, Fptr.LIBFPTR_UT_CONTROL_UNIT);
Fptr.queryData();

controlUnitVersion = Fptr.getParamString(Fptr.LIBFPTR_PARAM_UNIT_VERSION);

Запрос версии загрузчика

libfptr_set_param_int(fptr, LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_UNIT_VERSION);
libfptr_set_param_int(fptr, LIBFPTR_PARAM_UNIT_TYPE, LIBFPTR_UT_BOOT);
libfptr_query_data(fptr);

std::vector<wchar_t> str(1024);
int size = libfptr_get_param_str(fptr, LIBFPTR_PARAM_UNIT_VERSION, &str[0], str.size());
if (size > str.size())
{
    str.resize(size);
    libfptr_get_param_str(fptr, LIBFPTR_PARAM_UNIT_VERSION, &str[0], str.size());
}
std::wstring bootVersion = std::wstring(&str[0]);

fptr.setParam(LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_UNIT_VERSION);
fptr.setParam(LIBFPTR_PARAM_UNIT_TYPE, LIBFPTR_UT_BOOT);
fptr.queryData();

std::wstring bootVersion = fptr.getParamString(LIBFPTR_PARAM_UNIT_VERSION);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_UNIT_VERSION)
fptr.setParam(IFptr.LIBFPTR_PARAM_UNIT_TYPE, IFptr.LIBFPTR_UT_BOOT)
fptr.queryData()

bootVersion = fptr.getParamString(IFptr.LIBFPTR_PARAM_UNIT_VERSION)

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_UNIT_VERSION);
fptr.setParam(IFptr.LIBFPTR_PARAM_UNIT_TYPE, IFptr.LIBFPTR_UT_BOOT);
fptr.queryData();

String bootVersion = fptr.getParamString(IFptr.LIBFPTR_PARAM_UNIT_VERSION);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_UNIT_VERSION);
fptr.setParam(IFptr.LIBFPTR_PARAM_UNIT_TYPE, IFptr.LIBFPTR_UT_BOOT);
fptr.queryData();

String bootVersion = fptr.getParamString(IFptr.LIBFPTR_PARAM_UNIT_VERSION);

[fptr setParam:LIBFPTR_PARAM_DATA_TYPE intParam:LIBFPTR_DT_UNIT_VERSION];
[fptr setParam:LIBFPTR_PARAM_UNIT_TYPE intParam:LIBFPTR_UT_BOOT];
[fptr queryData];

NSString *bootVersion = [fptr getParamString:LIBFPTR_PARAM_UNIT_VERSION];

fptr.setParam(Constants.LIBFPTR_PARAM_DATA_TYPE, Constants.LIBFPTR_DT_UNIT_VERSION);
fptr.setParam(Constants.LIBFPTR_PARAM_UNIT_TYPE, Constants.LIBFPTR_UT_BOOT);
fptr.queryData();

String bootVersion = fptr.getParamString(Constants.LIBFPTR_PARAM_UNIT_VERSION);

var
    bootVersion: String;
begin
    fptr.setParam(fptr.LIBFPTR_PARAM_DATA_TYPE, fptr.LIBFPTR_DT_UNIT_VERSION);
    fptr.setParam(fptr.LIBFPTR_PARAM_UNIT_TYPE, fptr.LIBFPTR_UT_BOOT);
    fptr.queryData;

    bootVersion := fptr.getParamString(fptr.LIBFPTR_PARAM_UNIT_VERSION);
end;

fptr.SetParam(fptr10.LIBFPTR_PARAM_DATA_TYPE, fptr10.LIBFPTR_DT_UNIT_VERSION)
fptr.SetParam(fptr10.LIBFPTR_PARAM_UNIT_TYPE, fptr10.LIBFPTR_UT_BOOT)
fptr.QueryData()

bootVersion := fptr.GetParamString(fptr10.LIBFPTR_PARAM_UNIT_VERSION)

Fptr.setParam(Fptr.LIBFPTR_PARAM_DATA_TYPE, Fptr.LIBFPTR_DT_UNIT_VERSION);
Fptr.setParam(Fptr.LIBFPTR_PARAM_UNIT_TYPE, Fptr.LIBFPTR_UT_BOOT);
Fptr.queryData();

bootVersion = Fptr.getParamString(Fptr.LIBFPTR_PARAM_UNIT_VERSION);

Для запроса версии модуля необходимо вызвать метод queryData() с типом запроса LIBFPTR_PARAM_DATA_TYPE равным LIBFPTR_DT_UNIT_VERSION и указать один из модулей в параметре LIBFPTR_PARAM_UNIT_TYPE:

Результатом этого запроса будет следующая информация:

Параметр Описание Тип
LIBFPTR_PARAM_UNIT_VERSION Версия модуля string
LIBFPTR_PARAM_UNIT_RELEASE_VERSION Версия релиза (только для запроса LIBFPTR_UT_CONFIGURATION) string

Параметры массива картинок

Запрос параметров картинок

libfptr_set_param_int(fptr, LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_PICTURES_ARRAY_INFO);
libfptr_query_data(fptr);

int count = libfptr_get_param_int(fptr, LIBFPTR_PARAM_COUNT);

fptr.setParam(LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_PICTURES_ARRAY_INFO);
fptr.queryData();

uint count = fptr.getParamInt(LIBFPTR_PARAM_COUNT);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_PICTURES_ARRAY_INFO)
fptr.queryData()

count = fptr.getParamInt(IFptr.LIBFPTR_PARAM_COUNT)

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_PICTURES_ARRAY_INFO);
fptr.queryData();

long count = fptr.getParamInt(IFptr.LIBFPTR_PARAM_COUNT);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_PICTURES_ARRAY_INFO);
fptr.queryData();

long count = fptr.getParamInt(IFptr.LIBFPTR_PARAM_COUNT);

[fptr setParam:LIBFPTR_PARAM_DATA_TYPE intParam:LIBFPTR_DT_PICTURES_ARRAY_INFO];
[fptr queryData];

uint count = [fptr getParamInt:LIBFPTR_PARAM_COUNT];

fptr.setParam(Constants.LIBFPTR_PARAM_DATA_TYPE, Constants.LIBFPTR_DT_PICTURES_ARRAY_INFO);
fptr.queryData();

uint count = fptr.getParamInt(Constants.LIBFPTR_PARAM_COUNT);

var
    count:  Longint;
begin
    fptr.setParam(fptr.LIBFPTR_PARAM_DATA_TYPE, fptr.LIBFPTR_DT_PICTURES_ARRAY_INFO);
    fptr.queryData;

    count := fptr.getParamInt(fptr.LIBFPTR_PARAM_COUNT);
end;

fptr.SetParam(fptr10.LIBFPTR_PARAM_DATA_TYPE, fptr10.LIBFPTR_DT_PICTURES_ARRAY_INFO)
fptr.QueryData()

count := fptr.GetParamInt(fptr10.LIBFPTR_PARAM_COUNT)

Fptr.setParam(Fptr.LIBFPTR_PARAM_DATA_TYPE, Fptr.LIBFPTR_DT_PICTURES_ARRAY_INFO);
Fptr.queryData();

count = Fptr.getParamInt(Fptr.LIBFPTR_PARAM_COUNT);

Для запроса параметров массива картинок необходимо вызвать метод queryData() с типом запроса LIBFPTR_PARAM_DATA_TYPE равным LIBFPTR_DT_PICTURES_ARRAY_INFO.

Результатом этого запроса будет следующая информация:

Параметр Описание Тип
LIBFPTR_PARAM_COUNT Количество картинок int

Параметры картинки в памяти

Запрос параметров картинки в памяти ККТ

libfptr_set_param_int(fptr, LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_PICTURE_INFO);
libfptr_set_param_int(fptr, LIBFPTR_PARAM_PICTURE_NUMBER, 1);
libfptr_query_data(fptr);

int width = libfptr_get_param_int(fptr, LIBFPTR_PARAM_WIDTH);
int height = libfptr_get_param_int(fptr, LIBFPTR_PARAM_HEIGHT);

fptr.setParam(LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_PICTURE_INFO);
fptr.setParam(LIBFPTR_PARAM_PICTURE_NUMBER, 1);
fptr.queryData();

uint width = fptr.getParamInt(LIBFPTR_PARAM_WIDTH);
uint height = fptr.getParamInt(LIBFPTR_PARAM_HEIGHT);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_PICTURE_INFO)
fptr.setParam(IFptr.LIBFPTR_PARAM_PICTURE_NUMBER, 1)
fptr.queryData()

width = fptr.getParamInt(IFptr.LIBFPTR_PARAM_WIDTH)
height = fptr.getParamInt(IFptr.LIBFPTR_PARAM_HEIGHT)

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_PICTURE_INFO);
fptr.setParam(IFptr.LIBFPTR_PARAM_PICTURE_NUMBER, 1);
fptr.queryData();

long width = fptr.getParamInt(IFptr.LIBFPTR_PARAM_WIDTH);
long height = fptr.getParamInt(IFptr.LIBFPTR_PARAM_HEIGHT);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_PICTURE_INFO);
fptr.setParam(IFptr.LIBFPTR_PARAM_PICTURE_NUMBER, 1);
fptr.queryData();

long width = fptr.getParamInt(IFptr.LIBFPTR_PARAM_WIDTH);
long height = fptr.getParamInt(IFptr.LIBFPTR_PARAM_HEIGHT);

[fptr setParam:LIBFPTR_PARAM_DATA_TYPE intParam:LIBFPTR_DT_PICTURE_INFO];
[fptr setParam:LIBFPTR_PARAM_PICTURE_NUMBER intParam:1];
[fptr queryData];

uint width = [fptr getParamInt:LIBFPTR_PARAM_WIDTH];
uint height = [fptr getParamInt:LIBFPTR_PARAM_HEIGHT];

fptr.setParam(Constants.LIBFPTR_PARAM_DATA_TYPE, Constants.LIBFPTR_DT_PICTURE_INFO);
fptr.setParam(Constants.LIBFPTR_PARAM_PICTURE_NUMBER, 1);
fptr.queryData();

uint width = fptr.getParamInt(Constants.LIBFPTR_PARAM_WIDTH);
uint height = fptr.getParamInt(Constants.LIBFPTR_PARAM_HEIGHT);

var
    width:  Longint;
    height: Longint;
begin
    fptr.setParam(fptr.LIBFPTR_PARAM_DATA_TYPE, fptr.LIBFPTR_DT_PICTURE_INFO);
    fptr.setParam(fptr.LIBFPTR_PARAM_PICTURE_NUMBER, 1);
    fptr.queryData;

    width  := fptr.getParamInt(fptr.LIBFPTR_PARAM_WIDTH);
    height := fptr.getParamInt(fptr.LIBFPTR_PARAM_HEIGHT);
end;

fptr.SetParam(fptr10.LIBFPTR_PARAM_DATA_TYPE, fptr10.LIBFPTR_DT_PICTURE_INFO)
fptr.SetParam(fptr10.LIBFPTR_PARAM_PICTURE_NUMBER, 1)
fptr.QueryData()

width  := fptr.GetParamInt(fptr10.LIBFPTR_PARAM_WIDTH)
height := fptr.GetParamInt(fptr10.LIBFPTR_PARAM_HEIGHT)

Fptr.setParam(Fptr.LIBFPTR_PARAM_DATA_TYPE, Fptr.LIBFPTR_DT_PICTURE_INFO);
Fptr.setParam(Fptr.LIBFPTR_PARAM_PICTURE_NUMBER, 1);
Fptr.queryData();

width = Fptr.getParamInt(Fptr.LIBFPTR_PARAM_WIDTH);
height = Fptr.getParamInt(Fptr.LIBFPTR_PARAM_HEIGHT);

Для запроса параметров картинки из памяти ККТ необходимо вызвать метод queryData() с типом запроса LIBFPTR_PARAM_DATA_TYPE равным LIBFPTR_DT_PICTURE_INFO и указать номер картинки в параметре LIBFPTR_PARAM_PICTURE_NUMBER.

Результатом этого запроса будет следующая информация:

Параметр Описание Тип
LIBFPTR_PARAM_WIDTH Ширина картинки, пикс. int
LIBFPTR_PARAM_HEIGHT Высота картинки, пикс. int

Состояние лицензии ККТ

Запрос состояния кода защиты / лицензии

libfptr_set_param_int(fptr, LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_LICENSE_ACTIVATED);
libfptr_set_param_int(fptr, LIBFPTR_PARAM_LICENSE_NUMBER, 4);
libfptr_query_data(fptr);

bool entered = (libfptr_get_param_bool(fptr, LIBFPTR_PARAM_LICENSE_ENTERED) != 0);
int yearFrom, monthFrom, dayFrom;
libfptr_get_param_datetime(fptr, LIBFPTR_PARAM_LICENSE_VALID_FROM, &yearFrom, &monthFrom, &dayFrom);
int yearUntil, monthUntil, dayUntil;
libfptr_get_param_datetime(fptr, LIBFPTR_PARAM_LICENSE_VALID_UNTIL, &yearUntil, &monthUntil, &dayUntil);

fptr.setParam(LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_LICENSE_ACTIVATED);
fptr.setParam(LIBFPTR_PARAM_LICENSE_NUMBER, 4);
fptr.queryData();

bool entered = fptr.getParamBool(LIBFPTR_PARAM_LICENSE_ENTERED);
std::tm dateFrom = fptr.getParamDateTime(LIBFPTR_PARAM_LICENSE_VALID_FROM);
std::tm dateUntil= fptr.getParamDateTime(LIBFPTR_PARAM_LICENSE_VALID_UNTIL);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_LICENSE_ACTIVATED)
fptr.setParam(IFptr.LIBFPTR_PARAM_LICENSE_NUMBER, 4)
fptr.queryData()

entered = fptr.getParamBool(IFptr.LIBFPTR_PARAM_LICENSE_ENTERED)
dateFrom = fptr.getParamDateTime(IFptr.LIBFPTR_PARAM_LICENSE_VALID_FROM)
dateUntil= fptr.getParamDateTime(IFptr.LIBFPTR_PARAM_LICENSE_VALID_UNTIL)

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_LICENSE_ACTIVATED);
fptr.setParam(IFptr.LIBFPTR_PARAM_LICENSE_NUMBER, 4);
fptr.queryData();

boolean entered = fptr.getParamBool(IFptr.LIBFPTR_PARAM_LICENSE_ENTERED);
Date dateFrom = fptr.getParamDateTime(IFptr.LIBFPTR_PARAM_LICENSE_VALID_FROM);
Date dateUntil= fptr.getParamDateTime(IFptr.LIBFPTR_PARAM_LICENSE_VALID_UNTIL);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_LICENSE_ACTIVATED);
fptr.setParam(IFptr.LIBFPTR_PARAM_LICENSE_NUMBER, 4);
fptr.queryData();

boolean entered = fptr.getParamBool(IFptr.LIBFPTR_PARAM_LICENSE_ENTERED);
Date dateFrom = fptr.getParamDateTime(IFptr.LIBFPTR_PARAM_LICENSE_VALID_FROM);
Date dateUntil= fptr.getParamDateTime(IFptr.LIBFPTR_PARAM_LICENSE_VALID_UNTIL);

[fptr setParam:LIBFPTR_PARAM_DATA_TYPE intParam:LIBFPTR_DT_LICENSE_ACTIVATED];
[fptr setParam:LIBFPTR_PARAM_LICENSE_NUMBER intParam:4];
[fptr queryData];

bool entered = [fptr getParamBool:LIBFPTR_PARAM_LICENSE_ENTERED];
NSDate *dateFrom = [fptr getParamDateTime:LIBFPTR_PARAM_LICENSE_VALID_FROM];
NSDate *dateUntil = [fptr getParamDateTime:LIBFPTR_PARAM_LICENSE_VALID_UNTIL];

fptr.setParam(Constants.LIBFPTR_PARAM_DATA_TYPE, Constants.LIBFPTR_DT_LICENSE_ACTIVATED);
fptr.setParam(Constants.LIBFPTR_PARAM_LICENSE_NUMBER, 4);
fptr.queryData();

bool entered = fptr.getParamBool(Constants.LIBFPTR_PARAM_LICENSE_ENTERED);
DateTime dateFrom = fptr.getParamDateTime(Constants.LIBFPTR_PARAM_LICENSE_VALID_FROM);
DateTime dateUntil = fptr.getParamDateTime(Constants.LIBFPTR_PARAM_LICENSE_VALID_UNTIL);

var
    entered: LongBool;
    dateFrom, dateUntil: TDateTime;
begin
    fptr.setParam(fptr.LIBFPTR_PARAM_DATA_TYPE, fptr.LIBFPTR_DT_LICENSE_ACTIVATED);
    fptr.setParam(fptr.LIBFPTR_PARAM_LICENSE_NUMBER, 4);
    fptr.queryData;

    entered := fptr.getParamBool(fptr.LIBFPTR_PARAM_LICENSE_ENTERED);
    dateFrom := fptr.getParamDateTime(fptr.LIBFPTR_PARAM_LICENSE_VALID_FROM);
    dateUntil := fptr.getParamDateTime(fptr.LIBFPTR_PARAM_LICENSE_VALID_UNTIL);
end;

fptr.SetParam(fptr10.LIBFPTR_PARAM_DATA_TYPE, fptr10.LIBFPTR_DT_LICENSE_ACTIVATED)
fptr.SetParam(fptr10.LIBFPTR_PARAM_LICENSE_NUMBER, 4)
fptr.QueryData();

entered := fptr.GetParamBool(Constants.LIBFPTR_PARAM_LICENSE_ENTERED)
dateFrom := fptr.GetParamDateTime(fptr10.LIBFPTR_PARAM_LICENSE_VALID_FROM)
dateUntil := fptr.GetParamDateTime(fptr10.LIBFPTR_PARAM_LICENSE_VALID_UNTIL)

Fptr.setParam(Fptr.LIBFPTR_PARAM_DATA_TYPE, Fptr.LIBFPTR_DT_LICENSE_ACTIVATED);
Fptr.setParam(Fptr.LIBFPTR_PARAM_LICENSE_NUMBER, 1);
Fptr.queryData();

entered = Fptr.getParamBool(Fptr.LIBFPTR_PARAM_LICENSE_ENTERED);
dateFrom = Fptr.getParamDateTime(Fptr.LIBFPTR_PARAM_LICENSE_VALID_FROM);
dateUntil = Fptr.getParamDateTime(Fptr.LIBFPTR_PARAM_LICENSE_VALID_UNTIL);

Для запроса состояния кода защиты / лицензии необходимо вызвать метод queryData() с типом запроса LIBFPTR_PARAM_DATA_TYPE равным LIBFPTR_DT_LICENSE_ACTIVATED и указать номер кода защиты / лицензии в параметре LIBFPTR_PARAM_LICENSE_NUMBER. После выполнения метода параметр LIBFPTR_PARAM_LICENSE_ENTERED примет значение true, если код защиты введен, и false, если нет.

Результатом этого запроса будет следующая информация:

Параметр Описание Тип
LIBFPTR_PARAM_LICENSE_ENTERED Лицензия введена bool
LIBFPTR_PARAM_LICENSE_VALID_FROM Дата начала действия лицензии datetime
LIBFPTR_PARAM_LICENSE_VALID_UNTIL Дата окончания действия лицензии datetime

Если одну из дат получить не удалось, её значение будет равно 1970.01.01 00:00:00 (unixtime(0)).

Счетчики регистраций

Запрос суммы регистраций в чеках прихода (продажи)

libfptr_set_param_int(fptr, LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_REGISTRATIONS_SUM);
libfptr_set_param_int(fptr, LIBFPTR_PARAM_RECEIPT_TYPE, LIBFPTR_RT_SELL);
libfptr_query_data(fptr);

double sum = libfptr_get_param_double(fptr, LIBFPTR_PARAM_SUM);

fptr.setParam(LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_REGISTRATIONS_SUM);
fptr.setParam(LIBFPTR_PARAM_RECEIPT_TYPE, LIBFPTR_RT_SELL);
fptr.queryData();

double sum = fptr.getParamDouble(LIBFPTR_PARAM_SUM);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_REGISTRATIONS_SUM)
fptr.setParam(IFptr.LIBFPTR_PARAM_RECEIPT_TYPE, IFptr.LIBFPTR_RT_SELL)
fptr.queryData()

sum = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_SUM)

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_REGISTRATIONS_SUM);
fptr.setParam(IFptr.LIBFPTR_PARAM_RECEIPT_TYPE, IFptr.LIBFPTR_RT_SELL);
fptr.queryData();

double sum = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_SUM);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_REGISTRATIONS_SUM);
fptr.setParam(IFptr.LIBFPTR_PARAM_RECEIPT_TYPE, IFptr.LIBFPTR_RT_SELL);
fptr.queryData();

double sum = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_SUM);

[fptr setParam:LIBFPTR_PARAM_DATA_TYPE intParam:LIBFPTR_DT_REGISTRATIONS_SUM];
[fptr setParam:LIBFPTR_PARAM_RECEIPT_TYPE intParam:LIBFPTR_RT_SELL];
[fptr queryData];

double sum = [fptr getParamDouble:LIBFPTR_PARAM_SUM];

fptr.setParam(Constants.LIBFPTR_PARAM_DATA_TYPE, Constants.LIBFPTR_DT_REGISTRATIONS_SUM);
fptr.setParam(Constants.LIBFPTR_PARAM_RECEIPT_TYPE, Constants.LIBFPTR_RT_SELL);
fptr.queryData();

double sum = fptr.getParamDouble(Constants.LIBFPTR_PARAM_SUM);

var
    sum: Double;
begin
    fptr.setParam(fptr.LIBFPTR_PARAM_DATA_TYPE, fptr.LIBFPTR_DT_REGISTRATIONS_SUM);
    fptr.setParam(fptr.LIBFPTR_PARAM_RECEIPT_TYPE, fptr.LIBFPTR_RT_SELL);
    fptr.queryData;

    sum := fptr.getParamDouble(fptr.LIBFPTR_PARAM_SUM);
end;

fptr.SetParam(fptr10.LIBFPTR_PARAM_DATA_TYPE, fptr10.LIBFPTR_DT_REGISTRATIONS_SUM)
fptr.SetParam(fptr10.LIBFPTR_PARAM_RECEIPT_TYPE, fptr10.LIBFPTR_RT_SELL)
fptr.QueryData()

sum := fptr.GetParamDouble(fptr10.LIBFPTR_PARAM_SUM)

Fptr.setParam(Fptr.LIBFPTR_PARAM_DATA_TYPE, Fptr.LIBFPTR_DT_REGISTRATIONS_SUM);
Fptr.setParam(Fptr.LIBFPTR_PARAM_RECEIPT_TYPE, Fptr.LIBFPTR_RT_SELL);
Fptr.queryData();

sum = Fptr.getParamDouble(Fptr.LIBFPTR_PARAM_SUM);

Запрос количества регистраций в чеках расхода (покупки)

libfptr_set_param_int(fptr, LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_REGISTRATIONS_COUNT);
libfptr_set_param_int(fptr, LIBFPTR_PARAM_RECEIPT_TYPE, LIBFPTR_RT_BUY);
libfptr_query_data(fptr);

int count = libfptr_get_param_int(fptr, LIBFPTR_PARAM_COUNT);

fptr.setParam(LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_REGISTRATIONS_COUNT);
fptr.setParam(LIBFPTR_PARAM_RECEIPT_TYPE, LIBFPTR_RT_BUY);
fptr.queryData();

uint count = fptr.getParamInt(IFptr.LIBFPTR_PARAM_COUNT);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_REGISTRATIONS_COUNT)
fptr.setParam(IFptr.LIBFPTR_PARAM_RECEIPT_TYPE, IFptr.LIBFPTR_RT_BUY)
fptr.queryData()

count = fptr.getParamInt(IFptr.LIBFPTR_PARAM_COUNT)

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_REGISTRATIONS_COUNT);
fptr.setParam(IFptr.LIBFPTR_PARAM_RECEIPT_TYPE, IFptr.LIBFPTR_RT_BUY);
fptr.queryData();

long count = fptr.getParamInt(IFptr.LIBFPTR_PARAM_COUNT);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_REGISTRATIONS_COUNT);
fptr.setParam(IFptr.LIBFPTR_PARAM_RECEIPT_TYPE, IFptr.LIBFPTR_RT_BUY);
fptr.queryData();

long count = fptr.getParamInt(IFptr.LIBFPTR_PARAM_COUNT);

[fptr setParam:LIBFPTR_PARAM_DATA_TYPE intParam:LIBFPTR_DT_REGISTRATIONS_COUNT];
[fptr setParam:LIBFPTR_PARAM_RECEIPT_TYPE intParam:LIBFPTR_RT_BUY];
[fptr queryData];

uint count = [fptr getParamInt:LIBFPTR_PARAM_COUNT];

fptr.setParam(Constants.LIBFPTR_PARAM_DATA_TYPE, Constants.LIBFPTR_DT_REGISTRATIONS_COUNT);
fptr.setParam(Constants.LIBFPTR_PARAM_RECEIPT_TYPE, Constants.LIBFPTR_RT_BUY);
fptr.queryData();

uint count = fptr.getParamInt(Constants.LIBFPTR_PARAM_COUNT);

var
    count: Longint;
begin
    fptr.setParam(fptr.LIBFPTR_PARAM_DATA_TYPE, fptr.LIBFPTR_DT_REGISTRATIONS_COUNT);
    fptr.setParam(fptr.LIBFPTR_PARAM_RECEIPT_TYPE, fptr.LIBFPTR_RT_BUY);
    fptr.queryData;

    count := fptr.getParamInt(fptr.LIBFPTR_PARAM_COUNT);
end;

fptr.SetParam(fptr10.LIBFPTR_PARAM_DATA_TYPE, fptr10.LIBFPTR_DT_REGISTRATIONS_COUNT)
fptr.SetParam(fptr10.LIBFPTR_PARAM_RECEIPT_TYPE, fptr10.LIBFPTR_RT_BUY)
fptr.QueryData()

count := fptr.GetParamInt(fptr10.LIBFPTR_PARAM_COUNT)

Fptr.setParam(Fptr.LIBFPTR_PARAM_DATA_TYPE, Fptr.LIBFPTR_DT_REGISTRATIONS_COUNT);
Fptr.setParam(Fptr.LIBFPTR_PARAM_RECEIPT_TYPE, Fptr.LIBFPTR_RT_BUY);
Fptr.queryData();

counted = Fptr.getParamInt(Fptr.LIBFPTR_PARAM_COUNT);

Для запроса суммы регистраций необходимо вызвать метод queryData() с типом запроса LIBFPTR_PARAM_DATA_TYPE равным LIBFPTR_DT_REGISTRATIONS_SUM и указать тип чека в параметре LIBFPTR_PARAM_RECEIPT_TYPE.

Результатом этого запроса будет следующая информация:

Параметр Описание Тип
LIBFPTR_PARAM_SUM Сумма регистраций double

Для запроса количества регистраций необходимо вызвать метод queryData() с типом запроса LIBFPTR_PARAM_DATA_TYPE равным LIBFPTR_DT_REGISTRATIONS_COUNT и указать тип чека в параметре LIBFPTR_PARAM_RECEIPT_TYPE.

Результатом этого запроса будет следующая информация:

Параметр Описание Тип
LIBFPTR_PARAM_COUNT Количество регистраций int

Тип чека (LIBFPTR_PARAM_RECEIPT_TYPE) может принимать следующие значения:

Счетчики оплат

Запрос суммы наличных платежей в чеках прихода (продажи)

libfptr_set_param_int(fptr, LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_PAYMENT_SUM);
libfptr_set_param_int(fptr, LIBFPTR_PARAM_PAYMENT_TYPE, LIBFPTR_PT_CASH);
libfptr_set_param_int(fptr, LIBFPTR_PARAM_RECEIPT_TYPE, LIBFPTR_RT_SELL);
libfptr_query_data(fptr);

double sum = libfptr_get_param_double(fptr, LIBFPTR_PARAM_SUM);

fptr.setParam(LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_PAYMENT_SUM);
fptr.setParam(LIBFPTR_PARAM_PAYMENT_TYPE, LIBFPTR_PT_CASH);
fptr.setParam(LIBFPTR_PARAM_RECEIPT_TYPE, LIBFPTR_RT_SELL);
fptr.queryData();

double sum = fptr.getParamDouble(LIBFPTR_PARAM_SUM);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_PAYMENT_SUM)
fptr.setParam(IFptr.LIBFPTR_PARAM_PAYMENT_TYPE, IFptr.LIBFPTR_PT_CASH)
fptr.setParam(IFptr.LIBFPTR_PARAM_RECEIPT_TYPE, IFptr.LIBFPTR_RT_SELL)
fptr.queryData()

sum = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_SUM)

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_PAYMENT_SUM);
fptr.setParam(IFptr.LIBFPTR_PARAM_PAYMENT_TYPE, IFptr.LIBFPTR_PT_CASH);
fptr.setParam(IFptr.LIBFPTR_PARAM_RECEIPT_TYPE, IFptr.LIBFPTR_RT_SELL);
fptr.queryData();

double sum = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_SUM);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_PAYMENT_SUM);
fptr.setParam(IFptr.LIBFPTR_PARAM_PAYMENT_TYPE, IFptr.LIBFPTR_PT_CASH);
fptr.setParam(IFptr.LIBFPTR_PARAM_RECEIPT_TYPE, IFptr.LIBFPTR_RT_SELL);
fptr.queryData();

double sum = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_SUM);

[fptr setParam:LIBFPTR_PARAM_DATA_TYPE intParam:LIBFPTR_DT_PAYMENT_SUM];
[fptr setParam:LIBFPTR_PARAM_PAYMENT_TYPE intParam:LIBFPTR_PT_CASH];
[fptr setParam:LIBFPTR_PARAM_RECEIPT_TYPE intParam:LIBFPTR_RT_SELL];
[fptr queryData];

double sum = [fptr getParamDouble:LIBFPTR_PARAM_SUM];

fptr.setParam(Constants.LIBFPTR_PARAM_DATA_TYPE, Constants.LIBFPTR_DT_PAYMENT_SUM);
fptr.setParam(Constants.LIBFPTR_PARAM_PAYMENT_TYPE, Constants.LIBFPTR_PT_CASH);
fptr.setParam(Constants.LIBFPTR_PARAM_RECEIPT_TYPE, Constants.LIBFPTR_RT_SELL);
fptr.queryData();

double sum = fptr.getParamDouble(Constants.LIBFPTR_PARAM_SUM);

var
    sum: Double;
begin
    fptr.setParam(fptr.LIBFPTR_PARAM_DATA_TYPE, fptr.LIBFPTR_DT_PAYMENT_SUM);
    fptr.setParam(fptr.LIBFPTR_PARAM_PAYMENT_TYPE, fptr.LIBFPTR_PT_CASH);
    fptr.setParam(fptr.LIBFPTR_PARAM_RECEIPT_TYPE, fptr.LIBFPTR_RT_SELL);
    fptr.queryData;

    sum := fptr.getParamDouble(fptr.LIBFPTR_PARAM_SUM);
end;

fptr.SetParam(fptr10.LIBFPTR_PARAM_DATA_TYPE, fptr10.LIBFPTR_DT_PAYMENT_SUM)
fptr.SetParam(fptr10.LIBFPTR_PARAM_PAYMENT_TYPE, fptr10.LIBFPTR_PT_CASH)
fptr.SetParam(fptr10.LIBFPTR_PARAM_RECEIPT_TYPE, fptr10.LIBFPTR_RT_SELL)
fptr.QueryData()

sum := fptr.GetParamDouble(fptr10.LIBFPTR_PARAM_SUM)

Fptr.setParam(Fptr.LIBFPTR_PARAM_DATA_TYPE, Fptr.LIBFPTR_DT_PAYMENT_SUM);
Fptr.setParam(Fptr.LIBFPTR_PARAM_PAYMENT_TYPE, Fptr.LIBFPTR_PT_CASH);
Fptr.setParam(Fptr.LIBFPTR_PARAM_RECEIPT_TYPE, Fptr.LIBFPTR_RT_SELL);
Fptr.queryData();

sum = Fptr.getParamDouble(Fptr.LIBFPTR_PARAM_SUM);

Для запроса суммы платежей необходимо вызвать метод queryData() с типом запроса LIBFPTR_PARAM_DATA_TYPE равным LIBFPTR_DT_PAYMENT_SUM и указать тип чека в параметре LIBFPTR_PARAM_RECEIPT_TYPE и способ расчета в параметре LIBFPTR_PARAM_PAYMENT_TYPE.

Результатом этого запроса будет следующая информация:

Параметр Описание Тип
LIBFPTR_PARAM_SUM Сумма оплат double

Тип чека (LIBFPTR_PARAM_RECEIPT_TYPE) может принимать следующие значения:

Способ расчета (LIBFPTR_PARAM_PAYMENT_TYPE) может принимать следующие значения:

Счетчики внесений и выплат

Запрос суммы внесений

libfptr_set_param_int(fptr, LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_CASHIN_SUM);
libfptr_query_data(fptr);

double sum = libfptr_get_param_double(fptr, LIBFPTR_PARAM_SUM);

fptr.setParam(LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_CASHIN_SUM);
fptr.queryData();

double sum = fptr.getParamDouble(LIBFPTR_PARAM_SUM);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_CASHIN_SUM)
fptr.queryData()

sum = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_SUM)

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_CASHIN_SUM);
fptr.queryData();

double sum = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_SUM);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_CASHIN_SUM);
fptr.queryData();

double sum = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_SUM);

[fptr setParam:LIBFPTR_PARAM_DATA_TYPE intParam:LIBFPTR_DT_CASHIN_SUM];
[fptr queryData];

double sum = [fptr getParamDouble:LIBFPTR_PARAM_SUM];

fptr.setParam(Constants.LIBFPTR_PARAM_DATA_TYPE, Constants.LIBFPTR_DT_CASHIN_SUM);
fptr.queryData();

double sum = fptr.getParamDouble(Constants.LIBFPTR_PARAM_SUM);

var
    sum: Double;
begin
    fptr.setParam(fptr.LIBFPTR_PARAM_DATA_TYPE, fptr.LIBFPTR_DT_CASHIN_SUM);
    fptr.queryData;

    sum := fptr.getParamDouble(fptr.LIBFPTR_PARAM_SUM);
end;

fptr.SetParam(fptr10.LIBFPTR_PARAM_DATA_TYPE, fptr10.LIBFPTR_DT_CASHIN_SUM)
fptr.QueryData()

sum := fptr.GetParamDouble(fptr10.LIBFPTR_PARAM_SUM)

Fptr.setParam(Fptr.LIBFPTR_PARAM_DATA_TYPE, Fptr.LIBFPTR_DT_CASHIN_SUM);
Fptr.queryData();

sum = Fptr.getParamDouble(Fptr.LIBFPTR_PARAM_SUM);

Запрос суммы выплат

libfptr_set_param_int(fptr, LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_CASHOUT_SUM);
libfptr_query_data(fptr);

double sum = libfptr_get_param_double(fptr, LIBFPTR_PARAM_SUM);

fptr.setParam(LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_CASHOUT_SUM);
fptr.queryData();

double sum = fptr.getParamDouble(LIBFPTR_PARAM_SUM);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_CASHOUT_SUM)
fptr.queryData()

sum = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_SUM)

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_CASHOUT_SUM);
fptr.queryData();

double sum = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_SUM);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_CASHOUT_SUM);
fptr.queryData();

double sum = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_SUM);

[fptr setParam:LIBFPTR_PARAM_DATA_TYPE intParam:LIBFPTR_DT_CASHOUT_SUM];
[fptr queryData];

double sum = [fptr getParamDouble:LIBFPTR_PARAM_SUM];

fptr.setParam(Constants.LIBFPTR_PARAM_DATA_TYPE, Constants.LIBFPTR_DT_CASHOUT_SUM);
fptr.queryData();

double sum = fptr.getParamDouble(Constants.LIBFPTR_PARAM_SUM);

var
    sum: Double;
begin
    fptr.setParam(fptr.LIBFPTR_PARAM_DATA_TYPE, fptr.LIBFPTR_DT_CASHOUT_SUM);
    fptr.queryData;

    sum := fptr.getParamDouble(fptr.LIBFPTR_PARAM_SUM);
end;

fptr.SetParam(fptr10.LIBFPTR_PARAM_DATA_TYPE, fptr10.LIBFPTR_DT_CASHOUT_SUM)
fptr.QueryData()

sum := fptr.GetParamDouble(fptr10.LIBFPTR_PARAM_SUM)

Fptr.setParam(Fptr.LIBFPTR_PARAM_DATA_TYPE, Fptr.LIBFPTR_DT_CASHOUT_SUM);
Fptr.queryData();

sum = Fptr.getParamDouble(Fptr.LIBFPTR_PARAM_SUM);

Запрос количества внесений

libfptr_set_param_int(fptr, LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_CASHIN_COUNT);
libfptr_query_data(fptr);

int count = libfptr_get_param_int(fptr, LIBFPTR_PARAM_DOCUMENTS_COUNT);

fptr.setParam(LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_CASHIN_COUNT);
fptr.queryData();

uint count = fptr.getParamInt(LIBFPTR_PARAM_DOCUMENTS_COUNT);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_CASHIN_COUNT)
fptr.queryData()

count = fptr.getParamInt(IFptr.LIBFPTR_PARAM_DOCUMENTS_COUNT)

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_CASHIN_COUNT);
fptr.queryData;

long count = fptr.getParamInt(IFptr.LIBFPTR_PARAM_DOCUMENTS_COUNT);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_CASHIN_COUNT);
fptr.queryData;

long count = fptr.getParamInt(IFptr.LIBFPTR_PARAM_DOCUMENTS_COUNT);

[fptr setParam:LIBFPTR_PARAM_DATA_TYPE intParam:LIBFPTR_DT_CASHIN_COUNT];
[fptr queryData];

uint count = [fptr getParamInt:LIBFPTR_PARAM_DOCUMENTS_COUNT];

fptr.setParam(Constants.LIBFPTR_PARAM_DATA_TYPE, Constants.LIBFPTR_DT_CASHIN_COUNT);
fptr.queryData();

uint count = fptr.getParamInt(Constants.LIBFPTR_PARAM_DOCUMENTS_COUNT);

var
    count: Longint;
begin
    fptr.setParam(fptr.LIBFPTR_PARAM_DATA_TYPE, fptr.LIBFPTR_DT_CASHIN_COUNT);
    fptr.queryData;

    count := fptr.getParamInt(fptr.LIBFPTR_PARAM_DOCUMENTS_COUNT);
end;

fptr.SetParam(fptr10.LIBFPTR_PARAM_DATA_TYPE, fptr10.LIBFPTR_DT_CASHIN_COUNT)
fptr.QueryData()

count := fptr.GetParamInt(fptr10.LIBFPTR_PARAM_DOCUMENTS_COUNT)

Fptr.setParam(Fptr.LIBFPTR_PARAM_DATA_TYPE, Fptr.LIBFPTR_DT_CASHIN_COUNT);
Fptr.queryData();

count = Fptr.getParamInt(Fptr.LIBFPTR_PARAM_DOCUMENTS_COUNT);

Запрос количества выплат

libfptr_set_param_int(fptr, LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_CASHOUT_COUNT);
libfptr_query_data(fptr);

int count = libfptr_get_param_int(fptr, LIBFPTR_PARAM_DOCUMENTS_COUNT);

fptr.setParam(LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_CASHOUT_COUNT);
fptr.queryData();

uint count = fptr.getParamInt(LIBFPTR_PARAM_DOCUMENTS_COUNT);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_CASHOUT_COUNT)
fptr.queryData()

count = fptr.getParamInt(IFptr.LIBFPTR_PARAM_DOCUMENTS_COUNT)

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_CASHOUT_COUNT);
fptr.queryData();

long count = fptr.getParamInt(IFptr.LIBFPTR_PARAM_DOCUMENTS_COUNT);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_CASHOUT_COUNT);
fptr.queryData();

long count = fptr.getParamInt(IFptr.LIBFPTR_PARAM_DOCUMENTS_COUNT);

[fptr setParam:LIBFPTR_PARAM_DATA_TYPE intParam:LIBFPTR_DT_CASHOUT_COUNT];
[fptr queryData];

uint count = [fptr getParamInt:LIBFPTR_PARAM_DOCUMENTS_COUNT];

fptr.setParam(Constants.LIBFPTR_PARAM_DATA_TYPE, Constants.LIBFPTR_DT_CASHOUT_COUNT);
fptr.queryData();

uint count = fptr.getParamInt(Constants.LIBFPTR_PARAM_DOCUMENTS_COUNT);

var
    count: Longint;
begin
    fptr.setParam(fptr.LIBFPTR_PARAM_DATA_TYPE, fptr.LIBFPTR_DT_CASHOUT_COUNT);
    fptr.queryData;

    count := fptr.getParamInt(fptr.LIBFPTR_PARAM_DOCUMENTS_COUNT);
end;

fptr.SetParam(fptr10.LIBFPTR_PARAM_DATA_TYPE, fptr10.LIBFPTR_DT_CASHOUT_COUNT)
fptr.QueryData()

count := fptr.GetParamInt(Constants.LIBFPTR_PARAM_DOCUMENTS_COUNT)

Fptr.setParam(Fptr.LIBFPTR_PARAM_DATA_TYPE, Fptr.LIBFPTR_DT_CASHOUT_COUNT);
Fptr.queryData();

count = Fptr.getParamInt(Fptr.LIBFPTR_PARAM_DOCUMENTS_COUNT);

Для запроса суммы внесений или выплат необходимо вызвать метод queryData() с типом запроса LIBFPTR_PARAM_DATA_TYPE равным LIBFPTR_DT_CASHIN_SUM (или LIBFPTR_DT_CASHOUT_SUM соответственно).

Результатом этих запросов будет следующая информация:

Параметр Описание Тип
LIBFPTR_PARAM_SUM Сумма внесений/выплат double

Для запроса количества внесений или выплат необходимо вызвать метод queryData() с типом запроса LIBFPTR_PARAM_DATA_TYPE равным LIBFPTR_DT_CASHIN_COUNT (или LIBFPTR_DT_CASHOUT_COUNT соответственно).

Результатом этих запросов будет следующая информация:

Параметр Описание Тип
LIBFPTR_PARAM_DOCUMENTS_COUNT Количество документов внесений/выплат int

Сумма выручки

Запрос суммы выручки

libfptr_set_param_int(fptr, LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_REVENUE);
libfptr_query_data(fptr);

double revenue = libfptr_get_param_double(fptr, LIBFPTR_PARAM_SUM);

fptr.setParam(LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_REVENUE);
fptr.queryData();

double revenue = fptr.getParamDouble(LIBFPTR_PARAM_SUM);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_REVENUE)
fptr.queryData()

revenue = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_SUM)

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_REVENUE);
fptr.queryData();

double revenue = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_SUM);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_REVENUE);
fptr.queryData();

double revenue = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_SUM);

[fptr setParam:LIBFPTR_PARAM_DATA_TYPE intParam:LIBFPTR_DT_REVENUE];
[fptr queryData];

double revenue = [fptr getParamDouble:LIBFPTR_PARAM_SUM];

fptr.setParam(Constants.LIBFPTR_PARAM_DATA_TYPE, Constants.LIBFPTR_DT_REVENUE);
fptr.queryData();

double revenue = fptr.getParamDouble(Constants.LIBFPTR_PARAM_SUM);

var
    revenue: Double;
begin
    fptr.setParam(fptr.LIBFPTR_PARAM_DATA_TYPE, fptr.LIBFPTR_DT_REVENUE);
    fptr.queryData;

    revenue := fptr.getParamDouble(fptr.LIBFPTR_PARAM_SUM);
end;

fptr.SetParam(fptr10.LIBFPTR_PARAM_DATA_TYPE, fptr10.LIBFPTR_DT_REVENUE)
fptr.QueryData()

revenue := fptr.GetParamDouble(fptr10.LIBFPTR_PARAM_SUM)

Fptr.setParam(Fptr.LIBFPTR_PARAM_DATA_TYPE, Fptr.LIBFPTR_DT_REVENUE);
Fptr.queryData();

revenue = Fptr.getParamDouble(Fptr.LIBFPTR_PARAM_SUM);

Для запроса суммы выручки необходимо вызвать метод queryData() с типом запроса LIBFPTR_PARAM_DATA_TYPE равным LIBFPTR_DT_REVENUE.

Результатом этого запроса будет следующая информация:

Параметр Описание Тип
LIBFPTR_PARAM_SUM Сумма выручки double

Текущие дата и время ККТ

Запрос текущих даты и времени ККТ

libfptr_set_param_int(fptr, LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_DATE_TIME);
libfptr_query_data(fptr);

int year, month, day, hour, minute, second;
libfptr_get_param_datetime(fptr, LIBFPTR_PARAM_DATE_TIME, &year, &month, &day, &hour, &minute, &second);

fptr.setParam(LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_DATE_TIME);
fptr.queryData();

std::tm dateTime = fptr.getParamDateTime(LIBFPTR_PARAM_DATE_TIME);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_DATE_TIME)
fptr.queryData()

# Тип переменной datetime - datetime.datetime
dateTime = fptr.getParamDateTime(IFptr.LIBFPTR_PARAM_DATE_TIME)

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_DATE_TIME);
fptr.queryData();

Date dateTime = fptr.getParamDateTime(IFptr.LIBFPTR_PARAM_DATE_TIME);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_DATE_TIME);
fptr.queryData();

Date dateTime = fptr.getParamDateTime(IFptr.LIBFPTR_PARAM_DATE_TIME);

[fptr setParam:LIBFPTR_PARAM_DATA_TYPE intParam:LIBFPTR_DT_DATE_TIME];
[fptr queryData];

NSDate *dateTime = [fptr getParamDateTime:LIBFPTR_PARAM_DATE_TIME];

fptr.setParam(Constants.LIBFPTR_PARAM_DATA_TYPE, Constants.LIBFPTR_DT_DATE_TIME);
fptr.queryData();

DateTime dateTime = fptr.getParamDateTime(Constants.LIBFPTR_PARAM_DATE_TIME);

var
    dateTime:   TDateTime;
begin
    fptr.setParam(fptr.LIBFPTR_PARAM_DATA_TYPE, fptr.LIBFPTR_DT_DATE_TIME);
    fptr.queryData;

    dateTime := fptr.getParamDateTime(fptr.LIBFPTR_PARAM_DATE_TIME);
end;

fptr.SetParam(fptr10.LIBFPTR_PARAM_DATA_TYPE, fptr10.LIBFPTR_DT_DATE_TIME)
fptr.QueryData()

dateTime := fptr.GetParamDateTime(fptr10.LIBFPTR_PARAM_DATE_TIME)

Fptr.setParam(Fptr.LIBFPTR_PARAM_DATA_TYPE, Fptr.LIBFPTR_DT_DATE_TIME);
Fptr.queryData();

dateTime = Fptr.getParamDateTime(Fptr.LIBFPTR_PARAM_DATE_TIME);

Для запроса текущих даты и времени в ККТ необходимо вызвать метод queryData() с типом запроса LIBFPTR_PARAM_DATA_TYPE равным LIBFPTR_DT_DATE_TIME.

Результатом этого запроса будет следующая информация:

Параметр Описание Тип
LIBFPTR_PARAM_DATE_TIME Текущие дата и время в ККТ datetime

Состояние смены

Запрос состояния смены

libfptr_set_param_int(fptr, LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_SHIFT_STATE);
libfptr_query_data(fptr);

int state   = libfptr_get_param_int(fptr, LIBFPTR_PARAM_SHIFT_STATE);
int number  = libfptr_get_param_int(fptr, LIBFPTR_PARAM_SHIFT_NUMBER);
int year, month, day, hour, minute, second;
libfptr_get_param_datetime(fptr, LIBFPTR_PARAM_DATE_TIME, &year, &month, &day, &hour, &minute, &second);

fptr.setParam(LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_SHIFT_STATE);
fptr.queryData();

uint state       = fptr.getParamInt(LIBFPTR_PARAM_SHIFT_STATE);
uint number      = fptr.getParamInt(LIBFPTR_PARAM_SHIFT_NUMBER);
std::tm dateTime = fptr.getParamDateTime(LIBFPTR_PARAM_DATE_TIME);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_SHIFT_STATE)
fptr.queryData()

state       = fptr.getParamInt(IFptr.LIBFPTR_PARAM_SHIFT_STATE)
number      = fptr.getParamInt(IFptr.LIBFPTR_PARAM_SHIFT_NUMBER)
# Тип переменной datetime - datetime.datetime
dateTime    = fptr.getParamDateTime(IFptr.LIBFPTR_PARAM_DATE_TIME)

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_SHIFT_STATE);
fptr.queryData();

long state       = fptr.getParamInt(IFptr.LIBFPTR_PARAM_SHIFT_STATE);
long number      = fptr.getParamInt(IFptr.LIBFPTR_PARAM_SHIFT_NUMBER);
Date dateTime    = fptr.getParamDateTime(IFptr.LIBFPTR_PARAM_DATE_TIME);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_SHIFT_STATE);
fptr.queryData();

long state       = fptr.getParamInt(IFptr.LIBFPTR_PARAM_SHIFT_STATE);
long number      = fptr.getParamInt(IFptr.LIBFPTR_PARAM_SHIFT_NUMBER);
Date dateTime    = fptr.getParamDateTime(IFptr.LIBFPTR_PARAM_DATE_TIME);

[fptr setParam:LIBFPTR_PARAM_DATA_TYPE intParam:LIBFPTR_DT_SHIFT_STATE];
[fptr queryData];

uint state          = [fptr getParamInt:LIBFPTR_PARAM_SHIFT_STATE];
uint number         = [fptr getParamInt:LIBFPTR_PARAM_SHIFT_NUMBER];
NSDate *dateTime    = [fptr getParamDateTime:LIBFPTR_PARAM_DATE_TIME];

fptr.setParam(Constants.LIBFPTR_PARAM_DATA_TYPE, Constants.LIBFPTR_DT_SHIFT_STATE);
fptr.queryData();

uint state          = fptr.getParamInt(Constants.LIBFPTR_PARAM_SHIFT_STATE);
uint number         = fptr.getParamInt(Constants.LIBFPTR_PARAM_SHIFT_NUMBER);
DateTime dateTime   = fptr.getParamDateTime(Constants.LIBFPTR_PARAM_DATE_TIME);

var
    state:      Longint;
    number:     Longint;
    dateTime:   TDateTime;
begin
    fptr.setParam(fptr.LIBFPTR_PARAM_DATA_TYPE, fptr.LIBFPTR_DT_SHIFT_STATE);
    fptr.queryData;

    state       := fptr.getParamInt(fptr.LIBFPTR_PARAM_SHIFT_STATE);
    number      := fptr.getParamInt(fptr.LIBFPTR_PARAM_SHIFT_NUMBER);
    dateTime    := fptr.getParamDateTime(fptr.LIBFPTR_PARAM_DATE_TIME);
end;

fptr.SetParam(fptr10.LIBFPTR_PARAM_DATA_TYPE, fptr10.LIBFPTR_DT_SHIFT_STATE)
fptr.QueryData()

state       := fptr.GetParamInt(fptr10.LIBFPTR_PARAM_SHIFT_STATE)
number      := fptr.GetParamInt(fptr10.LIBFPTR_PARAM_SHIFT_NUMBER)
dateTime    := fptr.GetParamDateTime(fptr10.LIBFPTR_PARAM_DATE_TIME)

Fptr.setParam(Fptr.LIBFPTR_PARAM_DATA_TYPE, Fptr.LIBFPTR_DT_SHIFT_STATE);
Fptr.queryData();

state    = Fptr.getParamInt(Fptr.LIBFPTR_PARAM_SHIFT_STATE);
number   = Fptr.getParamInt(Fptr.LIBFPTR_PARAM_SHIFT_NUMBER);
dateTime = Fptr.getParamDateTime(Fptr.LIBFPTR_PARAM_DATE_TIME);

Для запроса состояния смены необходимо вызвать метод queryData() с типом запроса LIBFPTR_PARAM_DATA_TYPE равным LIBFPTR_DT_SHIFT_STATE.

Результатом этого запроса будет следующая информация:

Параметр Описание Тип
LIBFPTR_PARAM_SHIFT_STATE Состояние смены int
LIBFPTR_PARAM_SHIFT_NUMBER Номер смены int
LIBFPTR_PARAM_DATE_TIME Дата и время истечения текущей смены datetime

Состояние смены (LIBFPTR_PARAM_SHIFT_STATE) может принимать следующие значения:

Значение параметра LIBFPTR_PARAM_SHIFT_NUMBER зависит от состояния смены. Если смена закрыта, то его значением будет номер последней закрытой смены. Если смена открыта или истекла, то его значением будет номер текущей смены.

Параметр LIBFPTR_PARAM_DATE_TIME имеет смысл только при открытой или истекшей смене.

Состояние чека

Запрос состояния чека

libfptr_set_param_int(fptr, LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_RECEIPT_STATE);
libfptr_query_data(fptr);

int receiptType     = libfptr_get_param_int(fptr, LIBFPTR_PARAM_RECEIPT_TYPE);
int receiptNumber   = libfptr_get_param_int(fptr, LIBFPTR_PARAM_RECEIPT_NUMBER);
int documentNumber  = libfptr_get_param_int(fptr, LIBFPTR_PARAM_DOCUMENT_NUMBER);
int sum             = libfptr_get_param_double(fptr, LIBFPTR_PARAM_RECEIPT_SUM);
int remainder       = libfptr_get_param_double(fptr, LIBFPTR_PARAM_REMAINDER);
int change          = libfptr_get_param_double(fptr, LIBFPTR_PARAM_CHANGE);

fptr.setParam(LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_RECEIPT_STATE);
fptr.queryData();

uint receiptType    = fptr.getParamInt(LIBFPTR_PARAM_RECEIPT_TYPE);
uint receiptNumber  = fptr.getParamInt(LIBFPTR_PARAM_RECEIPT_NUMBER);
uint documentNumber = fptr.getParamInt(LIBFPTR_PARAM_DOCUMENT_NUMBER);
double sum          = fptr.getParamDouble(LIBFPTR_PARAM_RECEIPT_SUM);
double remainder    = fptr.getParamDouble(LIBFPTR_PARAM_REMAINDER);
double change       = fptr.getParamDouble(LIBFPTR_PARAM_CHANGE);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_RECEIPT_STATE)
fptr.queryData()

receiptType     = fptr.getParamInt(IFptr.LIBFPTR_PARAM_RECEIPT_TYPE)
receiptNumber   = fptr.getParamInt(IFptr.LIBFPTR_PARAM_RECEIPT_NUMBER)
documentNumber  = fptr.getParamInt(IFptr.LIBFPTR_PARAM_DOCUMENT_NUMBER)
sum             = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_RECEIPT_SUM)
remainder       = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_REMAINDER)
change          = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_CHANGE)

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_RECEIPT_STATE);
fptr.queryData();

long receiptType    = fptr.getParamInt(IFptr.LIBFPTR_PARAM_RECEIPT_TYPE);
long receiptNumber  = fptr.getParamInt(IFptr.LIBFPTR_PARAM_RECEIPT_NUMBER);
long documentNumber = fptr.getParamInt(IFptr.LIBFPTR_PARAM_DOCUMENT_NUMBER);
double sum          = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_RECEIPT_SUM);
double remainder    = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_REMAINDER);
double change       = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_CHANGE);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_RECEIPT_STATE);
fptr.queryData();

long receiptType    = fptr.getParamInt(IFptr.LIBFPTR_PARAM_RECEIPT_TYPE);
long receiptNumber  = fptr.getParamInt(IFptr.LIBFPTR_PARAM_RECEIPT_NUMBER);
long documentNumber = fptr.getParamInt(IFptr.LIBFPTR_PARAM_DOCUMENT_NUMBER);
double sum          = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_RECEIPT_SUM);
double remainder    = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_REMAINDER);
double change       = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_CHANGE);

[fptr setParam:LIBFPTR_PARAM_DATA_TYPE intParam:LIBFPTR_DT_RECEIPT_STATE];
[fptr queryData];

uint receiptType        = [fptr getParamInt:LIBFPTR_PARAM_RECEIPT_TYPE];
uint receiptNumber      = [fptr getParamInt:LIBFPTR_PARAM_RECEIPT_NUMBER];
uint documentNumber     = [fptr getParamInt:LIBFPTR_PARAM_DOCUMENT_NUMBER];
double documentNumber   = [fptr getParamDouble:LIBFPTR_PARAM_RECEIPT_SUM];
double remainder        = [fptr getParamDouble:LIBFPTR_PARAM_REMAINDER];
double change           = [fptr getParamDouble:LIBFPTR_PARAM_CHANGE];

fptr.setParam(Constants.LIBFPTR_PARAM_DATA_TYPE, Constants.LIBFPTR_DT_RECEIPT_STATE);
fptr.queryData();

uint receiptType    = fptr.getParamInt(Constants.LIBFPTR_PARAM_RECEIPT_TYPE);
uint receiptNumber  = fptr.getParamInt(Constants.LIBFPTR_PARAM_RECEIPT_NUMBER);
uint documentNumber = fptr.getParamInt(Constants.LIBFPTR_PARAM_DOCUMENT_NUMBER);
double sum          = fptr.getParamDouble(Constants.LIBFPTR_PARAM_RECEIPT_SUM);
double remainder    = fptr.getParamDouble(Constants.LIBFPTR_PARAM_REMAINDER);
double change       = fptr.getParamDouble(Constants.LIBFPTR_PARAM_CHANGE);

var
    receiptType:    Longint;
    receiptNumber:  Longint;
    documentNumber: Longint;
    sum:            Double;
    remainder:      Double;
    change:         Double;
begin
    fptr.setParam(fptr.LIBFPTR_PARAM_DATA_TYPE, fptr.LIBFPTR_DT_RECEIPT_STATE);
    fptr.queryData;

    receiptType     := fptr.getParamInt(fptr.LIBFPTR_PARAM_RECEIPT_TYPE);
    receiptNumber   := fptr.getParamInt(fptr.LIBFPTR_PARAM_RECEIPT_NUMBER);
    documentNumber  := fptr.getParamInt(fptr.LIBFPTR_PARAM_DOCUMENT_NUMBER);
    sum             := fptr.getParamDouble(fptr.LIBFPTR_PARAM_RECEIPT_SUM);
    remainder       := fptr.getParamDouble(fptr.LIBFPTR_PARAM_REMAINDER);
    change          := fptr.getParamDouble(fptr.LIBFPTR_PARAM_CHANGE);
end;

fptr.SetParam(fptr10.LIBFPTR_PARAM_DATA_TYPE, fptr10.LIBFPTR_DT_RECEIPT_STATE)
fptr.QueryData()

receiptType     := fptr.GetParamInt(fptr10.LIBFPTR_PARAM_RECEIPT_TYPE)
receiptNumber   := fptr.GetParamInt(fptr10.LIBFPTR_PARAM_RECEIPT_NUMBER)
documentNumber  := fptr.GetParamInt(fptr10.LIBFPTR_PARAM_DOCUMENT_NUMBER)
sum             := fptr.GetParamDouble(fptr10.LIBFPTR_PARAM_RECEIPT_SUM)
remainder       := fptr.GetParamDouble(fptr10.LIBFPTR_PARAM_REMAINDER)
change          := fptr.GetParamDouble(fptr10.LIBFPTR_PARAM_CHANGE)

Fptr.setParam(Fptr.LIBFPTR_PARAM_DATA_TYPE, Fptr.LIBFPTR_DT_RECEIPT_STATE);
Fptr.queryData();

receiptType    = fptr.getParamInt(Fptr.LIBFPTR_PARAM_RECEIPT_TYPE);
receiptNumber  = fptr.getParamInt(Fptr.LIBFPTR_PARAM_RECEIPT_NUMBER);
documentNumber = fptr.getParamInt(Fptr.LIBFPTR_PARAM_DOCUMENT_NUMBER);
sum            = fptr.getParamDouble(Fptr.LIBFPTR_PARAM_RECEIPT_SUM);
remainder      = fptr.getParamDouble(Fptr.LIBFPTR_PARAM_REMAINDER);
change         = fptr.getParamDouble(Fptr.LIBFPTR_PARAM_CHANGE);

Для запроса состояния чека необходимо вызвать метод queryData() с типом запроса LIBFPTR_PARAM_DATA_TYPE равным LIBFPTR_DT_RECEIPT_STATE.

Результатом этого запроса будет следующая информация:

Параметр Описание Тип
LIBFPTR_PARAM_RECEIPT_TYPE Тип чека int
LIBFPTR_PARAM_RECEIPT_NUMBER Номер чека int
LIBFPTR_PARAM_DOCUMENT_NUMBER Номер документа int
LIBFPTR_PARAM_RECEIPT_SUM Текущая сумма чека double
LIBFPTR_PARAM_REMAINDER Неоплаченный остаток double
LIBFPTR_PARAM_CHANGE Сдача по чеку double

Тип чека (LIBFPTR_PARAM_RECEIPT_TYPE) может принимать следующие значения:

Значения счетчиков LIBFPTR_PARAM_RECEIPT_NUMBER и LIBFPTR_PARAM_DOCUMENT_NUMBER не относятся к фискальному накопителю и содержат значения внутренних счетчиков ККТ. Данные счетчики могут увеличиваться вместе с печатью нефискальных и служебных документов. Для получения номеров фискальных документов нужно использовать метод fnQueryData() с типом запроса LIBFPTR_PARAM_FN_DATA_TYPE равным LIBFPTR_FNDT_LAST_DOCUMENT.

Значения параметров LIBFPTR_PARAM_RECEIPT_SUM, LIBFPTR_PARAM_REMAINDER и LIBFPTR_PARAM_CHANGE актуальны только при открытом чеке.

Заводской номер

Запрос заводского номера

libfptr_set_param_int(fptr, LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_SERIAL_NUMBER);
libfptr_query_data(fptr);

std::vector<wchar_t> str(1024);
int size = libfptr_get_param_str(fptr, LIBFPTR_PARAM_SERIAL_NUMBER, &str[0], str.size());
if (size > str.size())
{
    str.resize(size);
    libfptr_get_param_str(fptr, LIBFPTR_PARAM_SERIAL_NUMBER, &str[0], str.size());
}
std::wstring serialNumber = std::wstring(&str[0]);

fptr.setParam(LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_SERIAL_NUMBER);
fptr.queryData();

std::wstring serialNumber = fptr.getParamString(LIBFPTR_PARAM_SERIAL_NUMBER);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_SERIAL_NUMBER)
fptr.queryData()

serialNumber = fptr.getParamString(IFptr.LIBFPTR_PARAM_SERIAL_NUMBER)

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_SERIAL_NUMBER);
fptr.queryData();

String serialNumber = fptr.getParamString(IFptr.LIBFPTR_PARAM_SERIAL_NUMBER);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_SERIAL_NUMBER);
fptr.queryData();

String serialNumber = fptr.getParamString(IFptr.LIBFPTR_PARAM_SERIAL_NUMBER);

[fptr setParam:LIBFPTR_PARAM_DATA_TYPE intParam:LIBFPTR_DT_SERIAL_NUMBER];
[fptr queryData];

NSString *serialNumber = [fptr getParamString:LIBFPTR_PARAM_SERIAL_NUMBER];

fptr.setParam(Constants.LIBFPTR_PARAM_DATA_TYPE, Constants.LIBFPTR_DT_SERIAL_NUMBER);
fptr.queryData();

String serialNumber = fptr.getParamString(Constants.LIBFPTR_PARAM_SERIAL_NUMBER);

var
    serialNumber: String;
begin
    fptr.setParam(fptr.LIBFPTR_PARAM_DATA_TYPE, fptr.LIBFPTR_DT_SERIAL_NUMBER);
    fptr.queryData;

    serialNumber = fptr.getParamString(fptr.LIBFPTR_PARAM_SERIAL_NUMBER);
end;

fptr.SetParam(fptr10.LIBFPTR_PARAM_DATA_TYPE, fptr10.LIBFPTR_DT_SERIAL_NUMBER)
fptr.QueryData()

serialNumber := fptr.GetParamString(fptr10.LIBFPTR_PARAM_SERIAL_NUMBER)

Fptr.setParam(Fptr.LIBFPTR_PARAM_DATA_TYPE, Fptr.LIBFPTR_DT_SERIAL_NUMBER);
Fptr.queryData();

serialNumber = fptr.getParamString(Fptr.LIBFPTR_PARAM_SERIAL_NUMBER);

Для запроса заводского номера ККТ необходимо вызвать метод queryData() с типом запроса LIBFPTR_PARAM_DATA_TYPE равным LIBFPTR_DT_SERIAL_NUMBER.

Результатом этого запроса будет следующая информация:

Параметр Описание Тип
LIBFPTR_PARAM_SERIAL_NUMBER Заводской номер string

Информация о модели ККТ

Запрос информации о модели ККТ

libfptr_set_param_int(fptr, LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_MODEL_INFO);
libfptr_query_data(fptr);

int model = libfptr_get_param_int(fptr, LIBFPTR_PARAM_MODEL);

std::vector<wchar_t> str(1024);
int size = libfptr_get_param_str(fptr, LIBFPTR_PARAM_MODEL_NAME, &str[0], str.size());
if (size > str.size())
{
    str.resize(size);
    libfptr_get_param_str(fptr, LIBFPTR_PARAM_MODEL_NAME, &str[0], str.size());
}
std::wstring modelName = std::wstring(&str[0]);

int size = libfptr_get_param_str(fptr, LIBFPTR_PARAM_UNIT_VERSION, &str[0], str.size());
if (size > str.size())
{
    str.resize(size);
    libfptr_get_param_str(fptr, LIBFPTR_PARAM_UNIT_VERSION, &str[0], str.size());
}
std::wstring firmwareVersion = std::wstring(&str[0]);

fptr.setParam(LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_MODEL_INFO);
fptr.queryData();

uint model                   = fptr.getParamInt(LIBFPTR_PARAM_MODEL);
std::wstring modelName       = fptr.getParamString(LIBFPTR_PARAM_MODEL_NAME);
std::wstring firmwareVersion = fptr.getParamString(LIBFPTR_PARAM_UNIT_VERSION);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_MODEL_INFO)
fptr.queryData()

model           = fptr.getParamInt(IFptr.LIBFPTR_PARAM_MODEL)
modelName       = fptr.getParamString(IFptr.LIBFPTR_PARAM_MODEL_NAME)
firmwareVersion = fptr.getParamString(IFptr.LIBFPTR_PARAM_UNIT_VERSION)

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_MODEL_INFO);
fptr.queryData();

long model             = fptr.getParamInt(IFptr.LIBFPTR_PARAM_MODEL);
String modelName       = fptr.getParamString(IFptr.LIBFPTR_PARAM_MODEL_NAME);
String firmwareVersion = fptr.getParamString(IFptr.LIBFPTR_PARAM_UNIT_VERSION);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_MODEL_INFO);
fptr.queryData();

long model             = fptr.getParamInt(IFptr.LIBFPTR_PARAM_MODEL);
String modelName       = fptr.getParamString(IFptr.LIBFPTR_PARAM_MODEL_NAME);
String firmwareVersion = fptr.getParamString(IFptr.LIBFPTR_PARAM_UNIT_VERSION);

[fptr setParam:LIBFPTR_PARAM_DATA_TYPE intParam:LIBFPTR_DT_MODEL_INFO];
[fptr queryData];

uint model                = [fptr getParamInt:LIBFPTR_PARAM_MODEL];
NSString *modelName       = [fptr getParamString:LIBFPTR_PARAM_MODEL_NAME];
NSString *firmwareVersion = [fptr getParamString:LIBFPTR_PARAM_UNIT_VERSION];

fptr.setParam(Constants.LIBFPTR_PARAM_DATA_TYPE, Constants.LIBFPTR_DT_MODEL_INFO);
fptr.queryData();

uint model             = fptr.getParamInt(Constants.LIBFPTR_PARAM_MODEL);
String modelName       = fptr.getParamString(Constants.LIBFPTR_PARAM_MODEL_NAME);
String firmwareVersion = fptr.getParamString(Constants.LIBFPTR_PARAM_UNIT_VERSION);

var
    model:              Longint;
    modelName:          String;
    firmwareVersion:    String;
begin
    fptr.setParam(fptr.LIBFPTR_PARAM_DATA_TYPE, fptr.LIBFPTR_DT_MODEL_INFO);
    fptr.queryData;

    model                   := fptr.getParamInt(fptr.LIBFPTR_PARAM_MODEL);
    String modelName        := fptr.getParamString(fptr.LIBFPTR_PARAM_MODEL_NAME);
    String firmwareVersion  := fptr.getParamString(fptr.LIBFPTR_PARAM_UNIT_VERSION);
end;

fptr.SetParam(fptr10.LIBFPTR_PARAM_DATA_TYPE, fptr10.LIBFPTR_DT_MODEL_INFO)
fptr.QueryData()

model           := fptr.GetParamInt(fptr10.LIBFPTR_PARAM_MODEL)
modelName       := fptr.GetParamString(fptr10.LIBFPTR_PARAM_MODEL_NAME)
firmwareVersion := fptr.GetParamString(fptr10.LIBFPTR_PARAM_UNIT_VERSION)

Fptr.setParam(Fptr.LIBFPTR_PARAM_DATA_TYPE, Fptr.LIBFPTR_DT_MODEL_INFO);
Fptr.queryData();

model           = Fptr.getParamInt(Fptr.LIBFPTR_PARAM_MODEL);
modelName       = Fptr.getParamString(Fptr.LIBFPTR_PARAM_MODEL_NAME);
firmwareVersion = Fptr.getParamString(Fptr.LIBFPTR_PARAM_UNIT_VERSION);

Для запроса информации о модели ККТ необходимо вызвать метод queryData() с типом запроса LIBFPTR_PARAM_DATA_TYPE равным LIBFPTR_DT_MODEL_INFO.

Результатом этого запроса будет следующая информация:

Параметр Описание Тип
LIBFPTR_PARAM_MODEL Номер модели ККТ int
LIBFPTR_PARAM_MODEL_NAME Наименование ККТ string
LIBFPTR_PARAM_UNIT_VERSION Версия ПО ККТ string

Возможные значения для номера модели (LIBFPTR_PARAM_MODEL) представлены в разделе Список настроек.

Ширина чековой ленты

Запрос ширины чековой ленты

libfptr_set_param_int(fptr, LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_RECEIPT_LINE_LENGTH);
libfptr_query_data(fptr);

int charLineLength  = libfptr_get_param_int(fptr, LIBFPTR_PARAM_RECEIPT_LINE_LENGTH);
int pixLineLength   = libfptr_get_param_int(fptr, LIBFPTR_PARAM_RECEIPT_LINE_LENGTH_PIX);

fptr.setParam(LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_RECEIPT_LINE_LENGTH);
fptr.queryData();

uint charLineLength = fptr.getParamInt(LIBFPTR_PARAM_RECEIPT_LINE_LENGTH);
uint pixLineLength  = fptr.getParamInt(LIBFPTR_PARAM_RECEIPT_LINE_LENGTH_PIX);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_RECEIPT_LINE_LENGTH)
fptr.queryData()

charLineLength  = fptr.getParamInt(IFptr.LIBFPTR_PARAM_RECEIPT_LINE_LENGTH)
pixLineLength   = fptr.getParamInt(IFptr.LIBFPTR_PARAM_RECEIPT_LINE_LENGTH_PIX)

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_RECEIPT_LINE_LENGTH);
fptr.queryData();

long charLineLength  = fptr.getParamInt(IFptr.LIBFPTR_PARAM_RECEIPT_LINE_LENGTH);
long pixLineLength   = fptr.getParamInt(IFptr.LIBFPTR_PARAM_RECEIPT_LINE_LENGTH_PIX);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_RECEIPT_LINE_LENGTH);
fptr.queryData();

long charLineLength  = fptr.getParamInt(IFptr.LIBFPTR_PARAM_RECEIPT_LINE_LENGTH);
long pixLineLength   = fptr.getParamInt(IFptr.LIBFPTR_PARAM_RECEIPT_LINE_LENGTH_PIX);

[fptr setParam:LIBFPTR_PARAM_DATA_TYPE intParam:LIBFPTR_DT_RECEIPT_LINE_LENGTH];
[fptr queryData];

uint charLineLength = [fptr getParamInt:LIBFPTR_PARAM_RECEIPT_LINE_LENGTH];
uint pixLineLength = [fptr getParamInt:LIBFPTR_PARAM_RECEIPT_LINE_LENGTH_PIX];

fptr.setParam(Constants.LIBFPTR_PARAM_DATA_TYPE, Constants.LIBFPTR_DT_RECEIPT_LINE_LENGTH);
fptr.queryData();

uint charLineLength  = fptr.getParamInt(Constants.LIBFPTR_PARAM_RECEIPT_LINE_LENGTH);
uint pixLineLength   = fptr.getParamInt(Constants.LIBFPTR_PARAM_RECEIPT_LINE_LENGTH_PIX);

var
    charLineLength: Longint;
    pixLineLength:  Longint;
begin
    fptr.setParam(fptr.LIBFPTR_PARAM_DATA_TYPE, fptr.LIBFPTR_DT_RECEIPT_LINE_LENGTH);
    fptr.queryData;

    charLineLength  := fptr.getParamInt(fptr.LIBFPTR_PARAM_RECEIPT_LINE_LENGTH);
    pixLineLength   := fptr.getParamInt(fptr.LIBFPTR_PARAM_RECEIPT_LINE_LENGTH_PIX);
end;

fptr.SetParam(fptr10.LIBFPTR_PARAM_DATA_TYPE, fptr10.LIBFPTR_DT_RECEIPT_LINE_LENGTH)
fptr.QueryData()

charLineLength  := fptr.GetParamInt(fptr10.LIBFPTR_PARAM_RECEIPT_LINE_LENGTH)
pixLineLength   := fptr.GetParamInt(fptr10.LIBFPTR_PARAM_RECEIPT_LINE_LENGTH_PIX)

Fptr.setParam(Fptr.LIBFPTR_PARAM_DATA_TYPE, Fptr.LIBFPTR_DT_RECEIPT_LINE_LENGTH);
Fptr.queryData();

charLineLength = Fptr.getParamInt(Fptr.LIBFPTR_PARAM_RECEIPT_LINE_LENGTH);
pixLineLength  = Fptr.getParamInt(Fptr.LIBFPTR_PARAM_RECEIPT_LINE_LENGTH_PIX);

Для запроса ширины чековой ленты необходимо вызвать метод queryData()** с типом запроса LIBFPTR_PARAM_DATA_TYPE равным LIBFPTR_DT_RECEIPT_LINE_LENGTH.

Результатом этого запроса будет следующая информация:

Параметр Описание Тип
LIBFPTR_PARAM_RECEIPT_LINE_LENGTH Ширина чековой ленты, симв. int
LIBFPTR_PARAM_RECEIPT_LINE_LENGTH_PIX Ширина чековой ленты, пикс. int

Ресурс отрезчика

Запрос постоянного ресурса отрезчика

libfptr_set_param_int(fptr, LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_CUTTER_RESOURCE);
libfptr_set_param_int(fptr, LIBFPTR_PARAM_COUNTER_TYPE, LIBFPTR_CT_ROLLUP);
libfptr_query_data(fptr);

int count = libfptr_get_param_int(fptr, LIBFPTR_PARAM_COUNT);

fptr.setParam(LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_CUTTER_RESOURCE);
fptr.setParam(LIBFPTR_PARAM_COUNTER_TYPE, LIBFPTR_CT_ROLLUP);
fptr.queryData();

uint count = fptr.getParamInt(LIBFPTR_PARAM_COUNT);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_CUTTER_RESOURCE)
fptr.setParam(IFptr.LIBFPTR_PARAM_COUNTER_TYPE, IFptr.LIBFPTR_CT_ROLLUP)
fptr.queryData()

count = fptr.getParamInt(IFptr.LIBFPTR_PARAM_COUNT)

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_CUTTER_RESOURCE);
fptr.setParam(IFptr.LIBFPTR_PARAM_COUNTER_TYPE, IFptr.LIBFPTR_CT_ROLLUP);
fptr.queryData();

long count = fptr.getParamInt(IFptr.LIBFPTR_PARAM_COUNT);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_CUTTER_RESOURCE);
fptr.setParam(IFptr.LIBFPTR_PARAM_COUNTER_TYPE, IFptr.LIBFPTR_CT_ROLLUP);
fptr.queryData();

long count = fptr.getParamInt(IFptr.LIBFPTR_PARAM_COUNT);

[fptr setParam:LIBFPTR_PARAM_DATA_TYPE intParam:LIBFPTR_DT_CUTTER_RESOURCE];
[fptr setParam:LIBFPTR_PARAM_COUNTER_TYPE intParam:LIBFPTR_CT_ROLLUP];
[fptr queryData];

uint count = [fptr getParamInt:LIBFPTR_PARAM_COUNT];

fptr.setParam(Constants.LIBFPTR_PARAM_DATA_TYPE, Constants.LIBFPTR_DT_CUTTER_RESOURCE);
fptr.setParam(Constants.LIBFPTR_PARAM_COUNTER_TYPE, Constants.LIBFPTR_CT_ROLLUP);
fptr.queryData();

uint count = fptr.getParamInt(Constants.LIBFPTR_PARAM_COUNT);

var
    count: Longint;
begin
    fptr.setParam(fptr.LIBFPTR_PARAM_DATA_TYPE, fptr.LIBFPTR_DT_CUTTER_RESOURCE);
    fptr.setParam(fptr.LIBFPTR_PARAM_COUNTER_TYPE, fptr.LIBFPTR_CT_ROLLUP);
    fptr.queryData;

    count := fptr.getParamInt(fptr.LIBFPTR_PARAM_COUNT);
end;

fptr.SetParam(fptr10.LIBFPTR_PARAM_DATA_TYPE, fptr10.LIBFPTR_DT_CUTTER_RESOURCE)
fptr.SetParam(fptr10.LIBFPTR_PARAM_COUNTER_TYPE, fptr10.LIBFPTR_CT_ROLLUP)
fptr.QueryData()

count := fptr.GetParamInt(fptr10.LIBFPTR_PARAM_COUNT)

Fptr.setParam(Fptr.LIBFPTR_PARAM_DATA_TYPE, Fptr.LIBFPTR_DT_CUTTER_RESOURCE);
Fptr.SetParam(Fptr.LIBFPTR_PARAM_COUNTER_TYPE, Fptr.LIBFPTR_CT_ROLLUP);
Fptr.queryData();

count = Fptr.getParamInt(Fptr.LIBFPTR_PARAM_COUNT);

Запрос сбрасываемого ресурса отрезчика

libfptr_set_param_int(fptr, LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_CUTTER_RESOURCE);
libfptr_set_param_int(fptr, LIBFPTR_PARAM_COUNTER_TYPE, LIBFPTR_CT_RESETTABLE);
libfptr_query_data(fptr);

int count = libfptr_get_param_int(fptr, LIBFPTR_PARAM_COUNT);

fptr.setParam(LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_CUTTER_RESOURCE);
fptr.setParam(LIBFPTR_PARAM_COUNTER_TYPE, LIBFPTR_CT_RESETTABLE);
fptr.queryData();

uint count = fptr.getParamInt(LIBFPTR_PARAM_COUNT);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_CUTTER_RESOURCE)
fptr.setParam(IFptr.LIBFPTR_PARAM_COUNTER_TYPE, IFptr.LIBFPTR_CT_RESETTABLE)
fptr.queryData()

count = fptr.getParamInt(IFptr.LIBFPTR_PARAM_COUNT)

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_CUTTER_RESOURCE);
fptr.setParam(IFptr.LIBFPTR_PARAM_COUNTER_TYPE, IFptr.LIBFPTR_CT_RESETTABLE);
fptr.queryData();

long count = fptr.getParamInt(IFptr.LIBFPTR_PARAM_COUNT);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_CUTTER_RESOURCE);
fptr.setParam(IFptr.LIBFPTR_PARAM_COUNTER_TYPE, IFptr.LIBFPTR_CT_RESETTABLE);
fptr.queryData();

long count = fptr.getParamInt(IFptr.LIBFPTR_PARAM_COUNT);

[fptr setParam:LIBFPTR_PARAM_DATA_TYPE intParam:LIBFPTR_DT_CUTTER_RESOURCE];
[fptr setParam:LIBFPTR_PARAM_COUNTER_TYPE intParam:LIBFPTR_CT_RESETTABLE];
[fptr queryData];

uint count = [fptr getParamInt:LIBFPTR_PARAM_COUNT];

fptr.setParam(Constants.LIBFPTR_PARAM_DATA_TYPE, Constants.LIBFPTR_DT_CUTTER_RESOURCE);
fptr.setParam(Constants.LIBFPTR_PARAM_COUNTER_TYPE, Constants.LIBFPTR_CT_RESETTABLE);
fptr.queryData();

uint count = fptr.getParamInt(Constants.LIBFPTR_PARAM_COUNT);

var
    count: Longint;
begin
    fptr.setParam(fptr.LIBFPTR_PARAM_DATA_TYPE, fptr.LIBFPTR_DT_CUTTER_RESOURCE);
    fptr.setParam(fptr.LIBFPTR_PARAM_COUNTER_TYPE, fptr.LIBFPTR_CT_RESETTABLE);
    fptr.queryData;

    count := fptr.getParamInt(fptr.LIBFPTR_PARAM_COUNT);
end;

fptr.SetParam(fptr10.LIBFPTR_PARAM_DATA_TYPE, fptr10.LIBFPTR_DT_CUTTER_RESOURCE)
fptr.SetParam(fptr10.LIBFPTR_PARAM_COUNTER_TYPE, fptr10.LIBFPTR_CT_RESETTABLE)
fptr.QueryData()

count := fptr.GetParamInt(fptr10.LIBFPTR_PARAM_COUNT)

Fptr.setParam(Fptr.LIBFPTR_PARAM_DATA_TYPE, Fptr.LIBFPTR_DT_CUTTER_RESOURCE);
Fptr.SetParam(Fptr.LIBFPTR_PARAM_COUNTER_TYPE, Fptr.LIBFPTR_CT_RESETTABLE);
Fptr.queryData();

count = Fptr.getParamInt(Fptr.LIBFPTR_PARAM_COUNT);

Для запроса ресурса отрезчика необходимо вызвать метод queryData() с типом запроса LIBFPTR_PARAM_DATA_TYPE равным LIBFPTR_DT_CUTTER_RESOURCE и указать тип счетчика LIBFPTR_PARAM_COUNTER_TYPE.

Тип счетчика (LIBFPTR_PARAM_COUNTER_TYPE) может принимать следующие значения:

Результатом этого запроса будет следующая информация:

Параметр Описание Тип
LIBFPTR_PARAM_COUNT Количество отрезов int

Ресурс шагового двигателя

Запрос постоянного ресурса ШД для всех шагов

libfptr_set_param_int(fptr, LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_STEP_RESOURCE);
libfptr_set_param_int(fptr, LIBFPTR_PARAM_COUNTER_TYPE, LIBFPTR_CT_ROLLUP);
libfptr_set_param_int(fptr, LIBFPTR_PARAM_STEP_COUNTER_TYPE, LIBFPTR_SCT_OVERALL);
libfptr_query_data(fptr);

int count = libfptr_get_param_int(fptr, LIBFPTR_PARAM_COUNT);

fptr.setParam(LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_STEP_RESOURCE);
fptr.setParam(LIBFPTR_PARAM_COUNTER_TYPE, LIBFPTR_CT_ROLLUP);
fptr.setParam(LIBFPTR_PARAM_STEP_COUNTER_TYPE, LIBFPTR_SCT_OVERALL);
fptr.queryData();

uint count = fptr.getParamInt(LIBFPTR_PARAM_COUNT);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_STEP_RESOURCE)
fptr.setParam(IFptr.LIBFPTR_PARAM_COUNTER_TYPE, IFptr.LIBFPTR_CT_ROLLUP)
fptr.setParam(IFptr.LIBFPTR_PARAM_STEP_COUNTER_TYPE, IFptr.LIBFPTR_SCT_OVERALL)
fptr.queryData()

count = fptr.getParamInt(IFptr.LIBFPTR_PARAM_COUNT)

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_STEP_RESOURCE);
fptr.setParam(IFptr.LIBFPTR_PARAM_COUNTER_TYPE, IFptr.LIBFPTR_CT_ROLLUP);
fptr.setParam(IFptr.LIBFPTR_PARAM_STEP_COUNTER_TYPE, IFptr.LIBFPTR_SCT_OVERALL);
fptr.queryData();

long count = fptr.getParamInt(IFptr.LIBFPTR_PARAM_COUNT);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_STEP_RESOURCE);
fptr.setParam(IFptr.LIBFPTR_PARAM_COUNTER_TYPE, IFptr.LIBFPTR_CT_ROLLUP);
fptr.setParam(IFptr.LIBFPTR_PARAM_STEP_COUNTER_TYPE, IFptr.LIBFPTR_SCT_OVERALL);
fptr.queryData();

long count = fptr.getParamInt(IFptr.LIBFPTR_PARAM_COUNT);

[fptr setParam:LIBFPTR_PARAM_DATA_TYPE intParam:LIBFPTR_DT_STEP_RESOURCE];
[fptr setParam:LIBFPTR_PARAM_COUNTER_TYPE intParam:LIBFPTR_CT_ROLLUP];
[fptr setParam:LIBFPTR_PARAM_STEP_COUNTER_TYPE intParam:LIBFPTR_SCT_OVERALL];
[fptr queryData];

uint count = [fptr getParamInt:LIBFPTR_PARAM_COUNT];

fptr.setParam(Constants.LIBFPTR_PARAM_DATA_TYPE, Constants.LIBFPTR_DT_STEP_RESOURCE);
fptr.setParam(Constants.LIBFPTR_PARAM_COUNTER_TYPE, Constants.LIBFPTR_CT_ROLLUP);
fptr.setParam(Constants.LIBFPTR_PARAM_STEP_COUNTER_TYPE, Constants.LIBFPTR_SCT_OVERALL);
fptr.queryData();

uint count = fptr.getParamInt(Constants.LIBFPTR_PARAM_COUNT);

var
    count: Longint;
begin
    fptr.setParam(fptr.LIBFPTR_PARAM_DATA_TYPE, fptr.LIBFPTR_DT_STEP_RESOURCE);
    fptr.setParam(fptr.LIBFPTR_PARAM_COUNTER_TYPE, fptr.LIBFPTR_CT_ROLLUP);
    fptr.setParam(fptr.LIBFPTR_PARAM_STEP_COUNTER_TYPE, fptr.LIBFPTR_SCT_OVERALL);
    fptr.queryData;

    count := fptr.getParamInt(fptr.LIBFPTR_PARAM_COUNT);
end;

fptr.SetParam(fptr10.LIBFPTR_PARAM_DATA_TYPE, fptr10.LIBFPTR_DT_STEP_RESOURCE)
fptr.SetParam(fptr10.LIBFPTR_PARAM_COUNTER_TYPE, fptr10.LIBFPTR_CT_ROLLUP)
fptr.SetParam(fptr10.LIBFPTR_PARAM_STEP_COUNTER_TYPE, fptr10.LIBFPTR_SCT_OVERALL)
fptr.QueryData()

count := fptr.GetParamInt(fptr10.LIBFPTR_PARAM_COUNT)

Fptr.setParam(Fptr.LIBFPTR_PARAM_DATA_TYPE, Fptr.LIBFPTR_DT_CUTTER_RESOURCE);
Fptr.SetParam(Fptr.LIBFPTR_PARAM_COUNTER_TYPE, Fptr.LIBFPTR_CT_ROLLUP);
Fptr.SetParam(Fptr.LIBFPTR_PARAM_STEP_COUNTER_TYPE, Fptr.LIBFPTR_SCT_OVERALL);
Fptr.queryData();

count = Fptr.getParamInt(Fptr.LIBFPTR_PARAM_COUNT);

Запрос постоянного ресурса ШД для шагов вперед

libfptr_set_param_int(fptr, LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_STEP_RESOURCE);
libfptr_set_param_int(fptr, LIBFPTR_PARAM_COUNTER_TYPE, LIBFPTR_CT_ROLLUP);
libfptr_set_param_int(fptr, LIBFPTR_PARAM_STEP_COUNTER_TYPE, LIBFPTR_SCT_FORWARD);
libfptr_query_data(fptr);

int count = libfptr_get_param_int(fptr, LIBFPTR_PARAM_COUNT);

fptr.setParam(LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_STEP_RESOURCE);
fptr.setParam(LIBFPTR_PARAM_COUNTER_TYPE, LIBFPTR_CT_ROLLUP);
fptr.setParam(LIBFPTR_PARAM_STEP_COUNTER_TYPE, LIBFPTR_SCT_FORWARD);
fptr.queryData();

uint count = fptr.getParamInt(LIBFPTR_PARAM_COUNT);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_STEP_RESOURCE)
fptr.setParam(IFptr.LIBFPTR_PARAM_COUNTER_TYPE, IFptr.LIBFPTR_CT_ROLLUP)
fptr.setParam(IFptr.LIBFPTR_PARAM_STEP_COUNTER_TYPE, IFptr.LIBFPTR_SCT_FORWARD)
fptr.queryData()

count = fptr.getParamInt(IFptr.LIBFPTR_PARAM_COUNT)

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_STEP_RESOURCE);
fptr.setParam(IFptr.LIBFPTR_PARAM_COUNTER_TYPE, IFptr.LIBFPTR_CT_ROLLUP);
fptr.setParam(IFptr.LIBFPTR_PARAM_STEP_COUNTER_TYPE, IFptr.LIBFPTR_SCT_FORWARD);
fptr.queryData();

long count = fptr.getParamInt(IFptr.LIBFPTR_PARAM_COUNT);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_STEP_RESOURCE);
fptr.setParam(IFptr.LIBFPTR_PARAM_COUNTER_TYPE, IFptr.LIBFPTR_CT_ROLLUP);
fptr.setParam(IFptr.LIBFPTR_PARAM_STEP_COUNTER_TYPE, IFptr.LIBFPTR_SCT_FORWARD);
fptr.queryData();

long count = fptr.getParamInt(IFptr.LIBFPTR_PARAM_COUNT);

[fptr setParam:LIBFPTR_PARAM_DATA_TYPE intParam:LIBFPTR_DT_STEP_RESOURCE];
[fptr setParam:LIBFPTR_PARAM_COUNTER_TYPE intParam:LIBFPTR_CT_ROLLUP];
[fptr setParam:LIBFPTR_PARAM_STEP_COUNTER_TYPE intParam:LIBFPTR_SCT_FORWARD];
[fptr queryData];

uint count = [fptr getParamInt:LIBFPTR_PARAM_COUNT];

fptr.setParam(Constants.LIBFPTR_PARAM_DATA_TYPE, Constants.LIBFPTR_DT_STEP_RESOURCE);
fptr.setParam(Constants.LIBFPTR_PARAM_COUNTER_TYPE, Constants.LIBFPTR_CT_ROLLUP);
fptr.setParam(Constants.LIBFPTR_PARAM_STEP_COUNTER_TYPE, Constants.LIBFPTR_SCT_FORWARD);
fptr.queryData();

uint count = fptr.getParamInt(Constants.LIBFPTR_PARAM_COUNT);

var
    count: Longint;
begin
    fptr.setParam(fptr.LIBFPTR_PARAM_DATA_TYPE, fptr.LIBFPTR_DT_STEP_RESOURCE);
    fptr.setParam(fptr.LIBFPTR_PARAM_COUNTER_TYPE, fptr.LIBFPTR_CT_ROLLUP);
    fptr.setParam(fptr.LIBFPTR_PARAM_STEP_COUNTER_TYPE, fptr.LIBFPTR_SCT_FORWARD);
    fptr.queryData;

    count := fptr.getParamInt(fptr.LIBFPTR_PARAM_COUNT);
end;

fptr.SetParam(fptr10.LIBFPTR_PARAM_DATA_TYPE, fptr10.LIBFPTR_DT_STEP_RESOURCE)
fptr.SetParam(fptr10.LIBFPTR_PARAM_COUNTER_TYPE, fptr10.LIBFPTR_CT_ROLLUP)
fptr.SetParam(fptr10.LIBFPTR_PARAM_STEP_COUNTER_TYPE, fptr10.LIBFPTR_SCT_FORWARD)
fptr.QueryData()

count := fptr.GetParamInt(fptr10.LIBFPTR_PARAM_COUNT)

Fptr.setParam(Fptr.LIBFPTR_PARAM_DATA_TYPE, Fptr.LIBFPTR_DT_CUTTER_RESOURCE);
Fptr.SetParam(Fptr.LIBFPTR_PARAM_COUNTER_TYPE, Fptr.LIBFPTR_CT_ROLLUP);
Fptr.SetParam(Fptr.LIBFPTR_PARAM_STEP_COUNTER_TYPE, Fptr.LIBFPTR_SCT_FORWARD);
Fptr.queryData();

count = Fptr.getParamInt(Fptr.LIBFPTR_PARAM_COUNT);

Запрос сбрасываемого ресурса ШД для всех шагов

libfptr_set_param_int(fptr, LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_STEP_RESOURCE);
libfptr_set_param_int(fptr, LIBFPTR_PARAM_COUNTER_TYPE, LIBFPTR_CT_RESETTABLE);
libfptr_set_param_int(fptr, LIBFPTR_PARAM_STEP_COUNTER_TYPE, LIBFPTR_SCT_OVERALL);
libfptr_query_data(fptr);

int count = libfptr_get_param_int(fptr, LIBFPTR_PARAM_COUNT);

fptr.setParam(LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_STEP_RESOURCE);
fptr.setParam(LIBFPTR_PARAM_COUNTER_TYPE, LIBFPTR_CT_RESETTABLE);
fptr.setParam(LIBFPTR_PARAM_STEP_COUNTER_TYPE, LIBFPTR_SCT_OVERALL);
fptr.queryData();

uint count = fptr.getParamInt(LIBFPTR_PARAM_COUNT);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_STEP_RESOURCE)
fptr.setParam(IFptr.LIBFPTR_PARAM_COUNTER_TYPE, IFptr.LIBFPTR_CT_RESETTABLE)
fptr.setParam(IFptr.LIBFPTR_PARAM_STEP_COUNTER_TYPE, IFptr.LIBFPTR_SCT_OVERALL)
fptr.queryData()

count = fptr.getParamInt(IFptr.LIBFPTR_PARAM_COUNT)

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_STEP_RESOURCE);
fptr.setParam(IFptr.LIBFPTR_PARAM_COUNTER_TYPE, IFptr.LIBFPTR_CT_RESETTABLE);
fptr.setParam(IFptr.LIBFPTR_PARAM_STEP_COUNTER_TYPE, IFptr.LIBFPTR_SCT_OVERALL);
fptr.queryData();

long count = fptr.getParamInt(IFptr.LIBFPTR_PARAM_COUNT);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_STEP_RESOURCE);
fptr.setParam(IFptr.LIBFPTR_PARAM_COUNTER_TYPE, IFptr.LIBFPTR_CT_RESETTABLE);
fptr.setParam(IFptr.LIBFPTR_PARAM_STEP_COUNTER_TYPE, IFptr.LIBFPTR_SCT_OVERALL);
fptr.queryData();

long count = fptr.getParamInt(IFptr.LIBFPTR_PARAM_COUNT);

[fptr setParam:LIBFPTR_PARAM_DATA_TYPE intParam:LIBFPTR_DT_STEP_RESOURCE];
[fptr setParam:LIBFPTR_PARAM_COUNTER_TYPE intParam:LIBFPTR_CT_RESETTABLE];
[fptr setParam:LIBFPTR_PARAM_STEP_COUNTER_TYPE intParam:LIBFPTR_SCT_OVERALL];
[fptr queryData];

uint count = [fptr getParamInt:LIBFPTR_PARAM_COUNT];

fptr.setParam(Constants.LIBFPTR_PARAM_DATA_TYPE, Constants.LIBFPTR_DT_STEP_RESOURCE);
fptr.setParam(Constants.LIBFPTR_PARAM_COUNTER_TYPE, Constants.LIBFPTR_CT_RESETTABLE);
fptr.setParam(Constants.LIBFPTR_PARAM_STEP_COUNTER_TYPE, Constants.LIBFPTR_SCT_OVERALL);
fptr.queryData();

uint count = fptr.getParamInt(Constants.LIBFPTR_PARAM_COUNT);

var
    count: Longint;
begin
    fptr.setParam(fptr.LIBFPTR_PARAM_DATA_TYPE, fptr.LIBFPTR_DT_STEP_RESOURCE);
    fptr.setParam(fptr.LIBFPTR_PARAM_COUNTER_TYPE, fptr.LIBFPTR_CT_RESETTABLE);
    fptr.setParam(fptr.LIBFPTR_PARAM_STEP_COUNTER_TYPE, fptr.LIBFPTR_SCT_OVERALL);
    fptr.queryData;

    count := fptr.getParamInt(fptr.LIBFPTR_PARAM_COUNT);
end;

fptr.SetParam(fptr10.LIBFPTR_PARAM_DATA_TYPE, fptr10.LIBFPTR_DT_STEP_RESOURCE)
fptr.SetParam(fptr10.LIBFPTR_PARAM_COUNTER_TYPE, fptr10.LIBFPTR_CT_RESETTABLE)
fptr.SetParam(fptr10.LIBFPTR_PARAM_STEP_COUNTER_TYPE, fptr10.LIBFPTR_SCT_OVERALL)
fptr.QueryData()

count := fptr.GetParamInt(fptr10.LIBFPTR_PARAM_COUNT)

Fptr.setParam(Fptr.LIBFPTR_PARAM_DATA_TYPE, Fptr.LIBFPTR_DT_CUTTER_RESOURCE);
Fptr.SetParam(Fptr.LIBFPTR_PARAM_COUNTER_TYPE, Fptr.LIBFPTR_CT_RESETTABLE);
Fptr.SetParam(Fptr.LIBFPTR_PARAM_STEP_COUNTER_TYPE, Fptr.LIBFPTR_SCT_OVERALL);
Fptr.queryData();

count = Fptr.getParamInt(Fptr.LIBFPTR_PARAM_COUNT);

Запрос сбрасываемого ресурса ШД для шагов вперед

libfptr_set_param_int(fptr, LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_STEP_RESOURCE);
libfptr_set_param_int(fptr, LIBFPTR_PARAM_COUNTER_TYPE, LIBFPTR_CT_RESETTABLE);
libfptr_set_param_int(fptr, LIBFPTR_PARAM_STEP_COUNTER_TYPE, LIBFPTR_SCT_FORWARD);
libfptr_query_data(fptr);

int count = libfptr_get_param_int(fptr, LIBFPTR_PARAM_COUNT);

fptr.setParam(LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_STEP_RESOURCE);
fptr.setParam(LIBFPTR_PARAM_COUNTER_TYPE, LIBFPTR_CT_RESETTABLE);
fptr.setParam(LIBFPTR_PARAM_STEP_COUNTER_TYPE, LIBFPTR_SCT_FORWARD);
fptr.queryData()

uint count = fptr.getParamInt(LIBFPTR_PARAM_COUNT);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_STEP_RESOURCE)
fptr.setParam(IFptr.LIBFPTR_PARAM_COUNTER_TYPE, IFptr.LIBFPTR_CT_RESETTABLE)
fptr.setParam(IFptr.LIBFPTR_PARAM_STEP_COUNTER_TYPE, IFptr.LIBFPTR_SCT_FORWARD)
fptr.queryData()

count = fptr.getParamInt(IFptr.LIBFPTR_PARAM_COUNT)

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_STEP_RESOURCE);
fptr.setParam(IFptr.LIBFPTR_PARAM_COUNTER_TYPE, IFptr.LIBFPTR_CT_RESETTABLE);
fptr.setParam(IFptr.LIBFPTR_PARAM_STEP_COUNTER_TYPE, IFptr.LIBFPTR_SCT_FORWARD);
fptr.queryData();

long count = fptr.getParamInt(IFptr.LIBFPTR_PARAM_COUNT);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_STEP_RESOURCE);
fptr.setParam(IFptr.LIBFPTR_PARAM_COUNTER_TYPE, IFptr.LIBFPTR_CT_RESETTABLE);
fptr.setParam(IFptr.LIBFPTR_PARAM_STEP_COUNTER_TYPE, IFptr.LIBFPTR_SCT_FORWARD);
fptr.queryData();

long count = fptr.getParamInt(IFptr.LIBFPTR_PARAM_COUNT);

[fptr setParam:LIBFPTR_PARAM_DATA_TYPE intParam:LIBFPTR_DT_STEP_RESOURCE];
[fptr setParam:LIBFPTR_PARAM_COUNTER_TYPE intParam:LIBFPTR_CT_RESETTABLE];
[fptr setParam:LIBFPTR_PARAM_STEP_COUNTER_TYPE intParam:LIBFPTR_SCT_FORWARD];
[fptr queryData];

uint count = [fptr getParamInt:LIBFPTR_PARAM_COUNT];

fptr.setParam(Constants.LIBFPTR_PARAM_DATA_TYPE, Constants.LIBFPTR_DT_STEP_RESOURCE);
fptr.setParam(Constants.LIBFPTR_PARAM_COUNTER_TYPE, Constants.LIBFPTR_CT_RESETTABLE);
fptr.setParam(Constants.LIBFPTR_PARAM_STEP_COUNTER_TYPE, Constants.LIBFPTR_SCT_FORWARD);
fptr.queryData();

uint count = fptr.getParamInt(Constants.LIBFPTR_PARAM_COUNT);

var
    count: Longint;
begin
    fptr.setParam(fptr.LIBFPTR_PARAM_DATA_TYPE, fptr.LIBFPTR_DT_STEP_RESOURCE);
    fptr.setParam(fptr.LIBFPTR_PARAM_COUNTER_TYPE, fptr.LIBFPTR_CT_RESETTABLE);
    fptr.setParam(fptr.LIBFPTR_PARAM_STEP_COUNTER_TYPE, fptr.LIBFPTR_SCT_FORWARD);
    fptr.queryData;

    count := fptr.getParamInt(fptr.LIBFPTR_PARAM_COUNT);
end;

fptr.SetParam(fptr10.LIBFPTR_PARAM_DATA_TYPE, fptr10.LIBFPTR_DT_STEP_RESOURCE)
fptr.SetParam(fptr10.LIBFPTR_PARAM_COUNTER_TYPE, fptr10.LIBFPTR_CT_RESETTABLE)
fptr.SetParam(fptr10.LIBFPTR_PARAM_STEP_COUNTER_TYPE, fptr10.LIBFPTR_SCT_FORWARD)
fptr.QueryData()

count := fptr.GetParamInt(fptr10.LIBFPTR_PARAM_COUNT)

Fptr.setParam(Fptr.LIBFPTR_PARAM_DATA_TYPE, Fptr.LIBFPTR_DT_CUTTER_RESOURCE);
Fptr.SetParam(Fptr.LIBFPTR_PARAM_COUNTER_TYPE, Fptr.LIBFPTR_CT_RESETTABLE);
Fptr.SetParam(Fptr.LIBFPTR_PARAM_STEP_COUNTER_TYPE, Fptr.LIBFPTR_SCT_FORWARD);
Fptr.queryData();

count = Fptr.getParamInt(Fptr.LIBFPTR_PARAM_COUNT);

Для запроса ресурса шагового двигателя необходимо вызвать метод queryData() с типом запроса LIBFPTR_PARAM_DATA_TYPE равным LIBFPTR_DT_STEP_RESOURCE и указать тип счетчика LIBFPTR_PARAM_COUNTER_TYPE и тип счетчика шагов LIBFPTR_PARAM_STEP_COUNTER_TYPE.

Тип счетчика (LIBFPTR_PARAM_COUNTER_TYPE) может принимать следующие значения:

Тип счетчика шагов (LIBFPTR_PARAM_STEP_COUNTER_TYPE) может принимать следующие значения:

Результатом этого запроса будет следующая информация:

Параметр Описание Тип
LIBFPTR_PARAM_COUNT Количество шагов int

Ресурс ТПГ

Запрос постоянного ресурса ТПГ

libfptr_set_param_int(fptr, LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_TERMAL_RESOURCE);
libfptr_set_param_int(fptr, LIBFPTR_PARAM_COUNTER_TYPE, LIBFPTR_CT_ROLLUP);
libfptr_query_data(fptr);

int count = libfptr_get_param_int(fptr, LIBFPTR_PARAM_COUNT);

fptr.setParam(LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_TERMAL_RESOURCE);
fptr.setParam(LIBFPTR_PARAM_COUNTER_TYPE, LIBFPTR_CT_ROLLUP);
fptr.queryData();

uint count = fptr.getParamInt(LIBFPTR_PARAM_COUNT);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_TERMAL_RESOURCE)
fptr.setParam(IFptr.LIBFPTR_PARAM_COUNTER_TYPE, IFptr.LIBFPTR_CT_ROLLUP)
fptr.queryData()

count = fptr.getParamInt(IFptr.LIBFPTR_PARAM_COUNT)

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_TERMAL_RESOURCE);
fptr.setParam(IFptr.LIBFPTR_PARAM_COUNTER_TYPE, IFptr.LIBFPTR_CT_ROLLUP);
fptr.queryData();

long count = fptr.getParamInt(IFptr.LIBFPTR_PARAM_COUNT);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_TERMAL_RESOURCE);
fptr.setParam(IFptr.LIBFPTR_PARAM_COUNTER_TYPE, IFptr.LIBFPTR_CT_ROLLUP);
fptr.queryData();

long count = fptr.getParamInt(IFptr.LIBFPTR_PARAM_COUNT);

[fptr setParam:LIBFPTR_PARAM_DATA_TYPE intParam:LIBFPTR_DT_TERMAL_RESOURCE];
[fptr setParam:LIBFPTR_PARAM_COUNTER_TYPE intParam:LIBFPTR_CT_ROLLUP];
[fptr queryData];

uint count = [fptr getParamInt:LIBFPTR_PARAM_COUNT];

fptr.setParam(Constants.LIBFPTR_PARAM_DATA_TYPE, Constants.LIBFPTR_DT_TERMAL_RESOURCE);
fptr.setParam(Constants.LIBFPTR_PARAM_COUNTER_TYPE, Constants.LIBFPTR_CT_ROLLUP);
fptr.queryData();

uint count = fptr.getParamInt(Constants.LIBFPTR_PARAM_COUNT);

var
    count: Longint;
begin
    fptr.setParam(fptr.LIBFPTR_PARAM_DATA_TYPE, fptr.LIBFPTR_DT_TERMAL_RESOURCE);
    fptr.setParam(fptr.LIBFPTR_PARAM_COUNTER_TYPE, fptr.LIBFPTR_CT_ROLLUP);
    fptr.queryData;

    count := fptr.getParamInt(fptr.LIBFPTR_PARAM_COUNT);
end;

fptr.SetParam(fptr10.LIBFPTR_PARAM_DATA_TYPE, fptr10.LIBFPTR_DT_TERMAL_RESOURCE)
fptr.SetParam(fptr10.LIBFPTR_PARAM_COUNTER_TYPE, fptr10.LIBFPTR_CT_ROLLUP)
fptr.QueryData()

count := fptr.GetParamInt(fptr10.LIBFPTR_PARAM_COUNT)

Fptr.setParam(Fptr.LIBFPTR_PARAM_DATA_TYPE, Fptr.LIBFPTR_DT_TERMAL_RESOURCE);
Fptr.SetParam(Fptr.LIBFPTR_PARAM_COUNTER_TYPE, Fptr.LIBFPTR_CT_ROLLUP);
Fptr.queryData();

count = Fptr.getParamInt(Fptr.LIBFPTR_PARAM_COUNT);

Запрос сбрасываемого ресурса ТПГ

libfptr_set_param_int(fptr, LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_TERMAL_RESOURCE);
libfptr_set_param_int(fptr, LIBFPTR_PARAM_COUNTER_TYPE, LIBFPTR_CT_RESETTABLE);
libfptr_query_data(fptr);

int count = libfptr_get_param_int(fptr, LIBFPTR_PARAM_COUNT);

fptr.setParam(LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_TERMAL_RESOURCE);
fptr.setParam(LIBFPTR_PARAM_COUNTER_TYPE, LIBFPTR_CT_RESETTABLE);
fptr.queryData();

uint count = fptr.getParamInt(LIBFPTR_PARAM_COUNT);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_TERMAL_RESOURCE)
fptr.setParam(IFptr.LIBFPTR_PARAM_COUNTER_TYPE, IFptr.LIBFPTR_CT_RESETTABLE)
fptr.queryData()

count = fptr.getParamInt(IFptr.LIBFPTR_PARAM_COUNT)

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_TERMAL_RESOURCE);
fptr.setParam(IFptr.LIBFPTR_PARAM_COUNTER_TYPE, IFptr.LIBFPTR_CT_RESETTABLE);
fptr.queryData();

long count = fptr.getParamInt(IFptr.LIBFPTR_PARAM_COUNT);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_TERMAL_RESOURCE);
fptr.setParam(IFptr.LIBFPTR_PARAM_COUNTER_TYPE, IFptr.LIBFPTR_CT_RESETTABLE);
fptr.queryData();

long count = fptr.getParamInt(IFptr.LIBFPTR_PARAM_COUNT);

[fptr setParam:LIBFPTR_PARAM_DATA_TYPE intParam:LIBFPTR_DT_TERMAL_RESOURCE];
[fptr setParam:LIBFPTR_PARAM_COUNTER_TYPE intParam:LIBFPTR_CT_RESETTABLE];
[fptr queryData];

uint count = [fptr getParamInt:LIBFPTR_PARAM_COUNT];

fptr.setParam(Constants.LIBFPTR_PARAM_DATA_TYPE, Constants.LIBFPTR_DT_TERMAL_RESOURCE);
fptr.setParam(Constants.LIBFPTR_PARAM_COUNTER_TYPE, Constants.LIBFPTR_CT_RESETTABLE);
fptr.queryData();

uint count = fptr.getParamInt(Constants.LIBFPTR_PARAM_COUNT);

var
    count: Longint;
begin
    fptr.setParam(fptr.LIBFPTR_PARAM_DATA_TYPE, fptr.LIBFPTR_DT_TERMAL_RESOURCE);
    fptr.setParam(fptr.LIBFPTR_PARAM_COUNTER_TYPE, fptr.LIBFPTR_CT_RESETTABLE);
    fptr.queryData;

    count := fptr.getParamInt(fptr.LIBFPTR_PARAM_COUNT);
end;

fptr.SetParam(fptr10.LIBFPTR_PARAM_DATA_TYPE, fptr10.LIBFPTR_DT_TERMAL_RESOURCE)
fptr.SetParam(fptr10.LIBFPTR_PARAM_COUNTER_TYPE, fptr10.LIBFPTR_CT_RESETTABLE)
fptr.QueryData()

count := fptr.GetParamInt(fptr10.LIBFPTR_PARAM_COUNT)

Fptr.setParam(Fptr.LIBFPTR_PARAM_DATA_TYPE, Fptr.LIBFPTR_DT_TERMAL_RESOURCE);
Fptr.SetParam(Fptr.LIBFPTR_PARAM_COUNTER_TYPE, Fptr.LIBFPTR_CT_RESETTABLE);
Fptr.queryData();

count = Fptr.getParamInt(Fptr.LIBFPTR_PARAM_COUNT);

Для запроса ресурса ТПГ необходимо вызвать метод queryData() с типом запроса LIBFPTR_PARAM_DATA_TYPE равным LIBFPTR_DT_TERMAL_RESOURCE и указать тип счетчика LIBFPTR_PARAM_COUNTER_TYPE.

Тип счетчика (LIBFPTR_PARAM_COUNTER_TYPE) может принимать следующие значения:

Результатом этого запроса будет следующая информация:

Параметр Описание Тип
LIBFPTR_PARAM_COUNT Ресурс int

Сумма налога за смену

Запрос суммы налога НДС 18% за смену для чеков прихода

libfptr_set_param_int(fptr, LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_SHIFT_TAX_SUM);
libfptr_set_param_int(fptr, LIBFPTR_PARAM_RECEIPT_TYPE, LIBFPTR_RT_SELL);
libfptr_set_param_int(fptr, LIBFPTR_PARAM_TAX_TYPE, LIBFPTR_TAX_VAT18);
libfptr_query_data(fptr);

double sum = libfptr_get_param_double(fptr, LIBFPTR_PARAM_SUM);

fptr.setParam(LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_SHIFT_TAX_SUM);
fptr.setParam(LIBFPTR_PARAM_RECEIPT_TYPE, LIBFPTR_RT_SELL);
fptr.setParam(LIBFPTR_PARAM_TAX_TYPE, LIBFPTR_TAX_VAT18);
fptr.queryData();

double sum = fptr.getParamDouble(LIBFPTR_PARAM_SUM);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_SHIFT_TAX_SUM)
fptr.setParam(IFptr.LIBFPTR_PARAM_RECEIPT_TYPE, IFptr.LIBFPTR_RT_SELL)
fptr.setParam(IFptr.LIBFPTR_PARAM_TAX_TYPE, IFptr.LIBFPTR_TAX_VAT18)
fptr.queryData()

sum = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_SUM)

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_SHIFT_TAX_SUM);
fptr.setParam(IFptr.LIBFPTR_PARAM_RECEIPT_TYPE, IFptr.LIBFPTR_RT_SELL);
fptr.setParam(IFptr.LIBFPTR_PARAM_TAX_TYPE, IFptr.LIBFPTR_TAX_VAT18);
fptr.queryData();

double sum = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_SUM);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_SHIFT_TAX_SUM);
fptr.setParam(IFptr.LIBFPTR_PARAM_RECEIPT_TYPE, IFptr.LIBFPTR_RT_SELL);
fptr.setParam(IFptr.LIBFPTR_PARAM_TAX_TYPE, IFptr.LIBFPTR_TAX_VAT18);
fptr.queryData();

double sum = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_SUM);

[fptr setParam:LIBFPTR_PARAM_DATA_TYPE intParam:LIBFPTR_DT_SHIFT_TAX_SUM];
[fptr setParam:LIBFPTR_PARAM_RECEIPT_TYPE intParam:LIBFPTR_RT_SELL];
[fptr setParam:LIBFPTR_PARAM_TAX_TYPE intParam:LIBFPTR_TAX_VAT18];
[fptr queryData];

double sum = [fptr getParamDouble:LIBFPTR_PARAM_SUM];

fptr.setParam(Constants.LIBFPTR_PARAM_DATA_TYPE, Constants.LIBFPTR_DT_SHIFT_TAX_SUM);
fptr.setParam(Constants.LIBFPTR_PARAM_RECEIPT_TYPE, Constants.LIBFPTR_RT_SELL);
fptr.setParam(Constants.LIBFPTR_PARAM_TAX_TYPE, Constants.LIBFPTR_TAX_VAT18);
fptr.queryData();

double sum = fptr.getParamDouble(Constants.LIBFPTR_PARAM_SUM);

var
    sum: Double;
begin
    fptr.setParam(fptr.LIBFPTR_PARAM_DATA_TYPE, fptr.LIBFPTR_DT_SHIFT_TAX_SUM);
    fptr.setParam(fptr.LIBFPTR_PARAM_RECEIPT_TYPE, fptr.LIBFPTR_RT_SELL);
    fptr.setParam(fptr.LIBFPTR_PARAM_TAX_TYPE, fptr.LIBFPTR_TAX_VAT18);
    fptr.queryData;

    sum := fptr.getParamDouble(fptr.LIBFPTR_PARAM_SUM);
end;

fptr.SetParam(fptr10.LIBFPTR_PARAM_DATA_TYPE, fptr10.LIBFPTR_DT_SHIFT_TAX_SUM)
fptr.SetParam(fptr10.LIBFPTR_PARAM_RECEIPT_TYPE, fptr10.LIBFPTR_RT_SELL)
fptr.SetParam(fptr10.LIBFPTR_PARAM_TAX_TYPE, fptr10.LIBFPTR_TAX_VAT18)
fptr.QueryData()

sum := fptr.GetParamDouble(fptr10.LIBFPTR_PARAM_SUM)

Fptr.setParam(Fptr.LIBFPTR_PARAM_DATA_TYPE, Fptr.LIBFPTR_DT_SHIFT_TAX_SUM);
Fptr.setParam(Fptr.LIBFPTR_PARAM_RECEIPT_TYPE, Fptr.LIBFPTR_RT_SELL);
Fptr.setParam(Fptr.LIBFPTR_PARAM_TAX_TYPE, Fptr.LIBFPTR_TAX_VAT18);
Fptr.queryData();

sum = Fptr.getParamDouble(Fptr.LIBFPTR_PARAM_SUM);

Для запроса суммы налога за смену необходимо вызвать метод queryData() с типом запроса LIBFPTR_PARAM_DATA_TYPE равным LIBFPTR_DT_SHIFT_TAX_SUM и указать тип чека LIBFPTR_PARAM_RECEIPT_TYPE и тип налога LIBFPTR_PARAM_TAX_TYPE.

Тип чека (LIBFPTR_PARAM_RECEIPT_TYPE) может принимать следующие значения:

Тип налога (LIBFPTR_PARAM_TAX_TYPE) может принимать следующие значения:

Результатом этого запроса будет следующая информация:

Параметр Описание Тип
LIBFPTR_PARAM_SUM Сумма налога double

Сумма налога за чек

Запрос суммы налога НДС 18% последнего чека

libfptr_set_param_int(fptr, LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_RECEIPT_TAX_SUM);
libfptr_set_param_int(fptr, LIBFPTR_PARAM_TAX_TYPE, LIBFPTR_TAX_VAT18);
libfptr_query_data(fptr);

double sum = libfptr_get_param_double(fptr, LIBFPTR_PARAM_SUM);

fptr.setParam(LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_RECEIPT_TAX_SUM);
fptr.setParam(LIBFPTR_PARAM_TAX_TYPE, LIBFPTR_TAX_VAT18);
fptr.queryData();

double sum = fptr.getParamDouble(LIBFPTR_PARAM_SUM);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_RECEIPT_TAX_SUM)
fptr.setParam(IFptr.LIBFPTR_PARAM_TAX_TYPE, IFptr.LIBFPTR_TAX_VAT18)
fptr.queryData()

sum = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_SUM)

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_RECEIPT_TAX_SUM);
fptr.setParam(IFptr.LIBFPTR_PARAM_TAX_TYPE, IFptr.LIBFPTR_TAX_VAT18);
fptr.queryData();

double sum = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_SUM);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_RECEIPT_TAX_SUM);
fptr.setParam(IFptr.LIBFPTR_PARAM_TAX_TYPE, IFptr.LIBFPTR_TAX_VAT18);
fptr.queryData();

double sum = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_SUM);

[fptr setParam:LIBFPTR_PARAM_DATA_TYPE intParam:LIBFPTR_DT_RECEIPT_TAX_SUM];
[fptr setParam:LIBFPTR_PARAM_TAX_TYPE intParam:LIBFPTR_TAX_VAT18];
[fptr queryData];

double sum = [fptr getParamDouble:LIBFPTR_PARAM_SUM];

fptr.setParam(Constants.LIBFPTR_PARAM_DATA_TYPE, Constants.LIBFPTR_DT_RECEIPT_TAX_SUM);
fptr.setParam(Constants.LIBFPTR_PARAM_TAX_TYPE, Constants.LIBFPTR_TAX_VAT18);
fptr.queryData();

double sum = fptr.getParamDouble(Constants.LIBFPTR_PARAM_SUM);

var
    sum: Double;
begin
    fptr.setParam(fptr.LIBFPTR_PARAM_DATA_TYPE, fptr.LIBFPTR_DT_RECEIPT_TAX_SUM);
    fptr.setParam(fptr.LIBFPTR_PARAM_TAX_TYPE, fptr.LIBFPTR_TAX_VAT18);
    fptr.queryData;

    sum := fptr.getParamDouble(fptr.LIBFPTR_PARAM_SUM);
end;

fptr.SetParam(fptr10.LIBFPTR_PARAM_DATA_TYPE, fptr10.LIBFPTR_DT_RECEIPT_TAX_SUM)
fptr.SetParam(fptr10.LIBFPTR_PARAM_TAX_TYPE, fptr10.LIBFPTR_TAX_VAT18)
fptr.QueryData()

sum := fptr.GetParamDouble(fptr10.LIBFPTR_PARAM_SUM)

Fptr.setParam(Fptr.LIBFPTR_PARAM_DATA_TYPE, Fptr.LIBFPTR_DT_RECEIPT_TAX_SUM);
Fptr.setParam(Fptr.LIBFPTR_PARAM_TAX_TYPE, Fptr.LIBFPTR_TAX_VAT18);
Fptr.queryData();

sum = Fptr.getParamDouble(Fptr.LIBFPTR_PARAM_SUM);

Для запроса суммы налога за чек необходимо вызвать метод queryData() с типом запроса LIBFPTR_PARAM_DATA_TYPE равным LIBFPTR_DT_RECEIPT_TAX_SUM и указать тип налога LIBFPTR_PARAM_TAX_TYPE.

Тип налога (LIBFPTR_PARAM_TAX_TYPE) может принимать следующие значения:

Результатом этого запроса будет следующая информация:

Параметр Описание Тип
LIBFPTR_PARAM_SUM Сумма налога double

Необнуляемая сумма

Запрос необнуляемой суммы по чекам прихода

libfptr_set_param_int(fptr, LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_NON_NULLABLE_SUM);
libfptr_set_param_int(fptr, LIBFPTR_PARAM_RECEIPT_TYPE, LIBFPTR_RT_SELL);
libfptr_query_data(fptr);

double sum = libfptr_get_param_double(fptr, LIBFPTR_PARAM_SUM);

fptr.setParam(LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_NON_NULLABLE_SUM);
fptr.setParam(LIBFPTR_PARAM_RECEIPT_TYPE, LIBFPTR_RT_SELL);
fptr.queryData();

double sum = fptr.getParamDouble(LIBFPTR_PARAM_SUM);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_NON_NULLABLE_SUM)
fptr.setParam(IFptr.LIBFPTR_PARAM_RECEIPT_TYPE, IFptr.LIBFPTR_RT_SELL)
fptr.queryData()

sum = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_SUM)

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_NON_NULLABLE_SUM);
fptr.setParam(IFptr.LIBFPTR_PARAM_RECEIPT_TYPE, IFptr.LIBFPTR_RT_SELL);
fptr.queryData();

double sum = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_SUM);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_NON_NULLABLE_SUM);
fptr.setParam(IFptr.LIBFPTR_PARAM_RECEIPT_TYPE, IFptr.LIBFPTR_RT_SELL);
fptr.queryData();

double sum = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_SUM);

[fptr setParam:LIBFPTR_PARAM_DATA_TYPE intParam:LIBFPTR_DT_NON_NULLABLE_SUM];
[fptr setParam:LIBFPTR_PARAM_RECEIPT_TYPE intParam:LIBFPTR_RT_SELL];
[fptr queryData];

double sum = [fptr getParamDouble:LIBFPTR_PARAM_SUM];

fptr.setParam(Constants.LIBFPTR_PARAM_DATA_TYPE, Constants.LIBFPTR_DT_NON_NULLABLE_SUM);
fptr.setParam(Constants.LIBFPTR_PARAM_RECEIPT_TYPE, Constants.LIBFPTR_RT_SELL);
fptr.queryData();

double sum = fptr.getParamDouble(Constants.LIBFPTR_PARAM_SUM);

var
    sum: Double;
begin
    fptr.setParam(fptr.LIBFPTR_PARAM_DATA_TYPE, fptr.LIBFPTR_DT_NON_NULLABLE_SUM);
    fptr.setParam(fptr.LIBFPTR_PARAM_RECEIPT_TYPE, fptr.LIBFPTR_RT_SELL);
    fptr.queryData;

    sum := fptr.getParamDouble(fptr.LIBFPTR_PARAM_SUM);
end;

fptr.SetParam(fptr10.LIBFPTR_PARAM_DATA_TYPE, fptr10.LIBFPTR_DT_NON_NULLABLE_SUM)
fptr.SetParam(fptr10.LIBFPTR_PARAM_RECEIPT_TYPE, fptr10.LIBFPTR_RT_SELL)
fptr.QueryData()

sum := fptr.GetParamDouble(fptr10.LIBFPTR_PARAM_SUM)

Fptr.setParam(Fptr.LIBFPTR_PARAM_DATA_TYPE, Fptr.LIBFPTR_DT_NON_NULLABLE_SUM);
Fptr.setParam(Fptr.LIBFPTR_PARAM_RECEIPT_TYPE, Fptr.LIBFPTR_RT_SELL);
Fptr.queryData();

sum = Fptr.getParamDouble(Fptr.LIBFPTR_PARAM_SUM);

Запрос необнуляемой суммы по чекам прихода по оплатам наличными

libfptr_set_param_int(fptr, LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_NON_NULLABLE_SUM_BY_PAYMENTS);
libfptr_set_param_int(fptr, LIBFPTR_PARAM_RECEIPT_TYPE, LIBFPTR_RT_SELL);
libfptr_set_param_int(fptr, LIBFPTR_PARAM_PAYMENT_TYPE, LIBFPTR_PT_CASH);
libfptr_query_data(fptr);

double sum = libfptr_get_param_double(fptr, LIBFPTR_PARAM_SUM);

fptr.setParam(LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_NON_NULLABLE_SUM_BY_PAYMENTS);
fptr.setParam(LIBFPTR_PARAM_RECEIPT_TYPE, LIBFPTR_RT_SELL);
fptr.setParam(LIBFPTR_PARAM_PAYMENT_TYPE, LIBFPTR_PT_CASH);
fptr.queryData();

double sum = fptr.getParamDouble(LIBFPTR_PARAM_SUM);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_NON_NULLABLE_SUM_BY_PAYMENTS)
fptr.setParam(IFptr.LIBFPTR_PARAM_RECEIPT_TYPE, IFptr.LIBFPTR_RT_SELL)
fptr.setParam(IFptr.LIBFPTR_PARAM_PAYMENT_TYPE, IFptr.LIBFPTR_PT_CASH)
fptr.queryData()

sum = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_SUM)

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_NON_NULLABLE_SUM_BY_PAYMENTS);
fptr.setParam(IFptr.LIBFPTR_PARAM_RECEIPT_TYPE, IFptr.LIBFPTR_RT_SELL);
fptr.setParam(IFptr.LIBFPTR_PARAM_PAYMENT_TYPE, IFptr.LIBFPTR_PT_CASH);
fptr.queryData();

double sum = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_SUM);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_NON_NULLABLE_SUM_BY_PAYMENTS);
fptr.setParam(IFptr.LIBFPTR_PARAM_RECEIPT_TYPE, IFptr.LIBFPTR_RT_SELL);
fptr.setParam(IFptr.LIBFPTR_PARAM_PAYMENT_TYPE, IFptr.LIBFPTR_PT_CASH);
fptr.queryData();

double sum = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_SUM);

[fptr setParam:LIBFPTR_PARAM_DATA_TYPE intParam:LIBFPTR_DT_NON_NULLABLE_SUM_BY_PAYMENTS];
[fptr setParam:LIBFPTR_PARAM_RECEIPT_TYPE intParam:LIBFPTR_RT_SELL];
[fptr setParam:LIBFPTR_PARAM_PAYMENT_TYPE intParam:LIBFPTR_PT_CASH];
[fptr queryData];

double sum = [fptr getParamDouble:LIBFPTR_PARAM_SUM];

fptr.setParam(Constants.LIBFPTR_PARAM_DATA_TYPE, Constants.LIBFPTR_DT_NON_NULLABLE_SUM_BY_PAYMENTS);
fptr.setParam(Constants.LIBFPTR_PARAM_RECEIPT_TYPE, Constants.LIBFPTR_RT_SELL);
fptr.setParam(Constants.LIBFPTR_PARAM_PAYMENT_TYPE, Constants.LIBFPTR_PT_CASH);
fptr.queryData();

double sum = fptr.getParamDouble(Constants.LIBFPTR_PARAM_SUM);

var
    sum: Double;
begin
    fptr.setParam(fptr.LIBFPTR_PARAM_DATA_TYPE, fptr.LIBFPTR_DT_NON_NULLABLE_SUM_BY_PAYMENTS);
    fptr.setParam(fptr.LIBFPTR_PARAM_RECEIPT_TYPE, fptr.LIBFPTR_RT_SELL);
    fptr.setParam(fptr.LIBFPTR_PARAM_PAYMENT_TYPE, fptr.LIBFPTR_PT_CASH);
    fptr.queryData;

    sum := fptr.getParamDouble(fptr.LIBFPTR_PARAM_SUM);
end;

fptr.SetParam(fptr10.LIBFPTR_PARAM_DATA_TYPE, fptr10.LIBFPTR_DT_NON_NULLABLE_SUM_BY_PAYMENTS)
fptr.SetParam(fptr10.LIBFPTR_PARAM_RECEIPT_TYPE, fptr10.LIBFPTR_RT_SELL)
fptr.SetParam(fptr10.LIBFPTR_PARAM_PAYMENT_TYPE, fptr10.LIBFPTR_PT_CASH)
fptr.QueryData()

sum := fptr.GetParamDouble(fptr10.LIBFPTR_PARAM_SUM)

Fptr.setParam(Fptr.LIBFPTR_PARAM_DATA_TYPE, Fptr.LIBFPTR_DT_NON_NULLABLE_SUM_BY_PAYMENTS);
Fptr.setParam(Fptr.LIBFPTR_PARAM_RECEIPT_TYPE, Fptr.LIBFPTR_RT_SELL);
fptr.SetParam(Fptr.LIBFPTR_PARAM_PAYMENT_TYPE, Fptr.LIBFPTR_PT_CASH);
Fptr.queryData();

sum = Fptr.getParamDouble(Fptr.LIBFPTR_PARAM_SUM);

Для запроса необнуляемой суммы необходимо вызвать метод queryData() с типом запроса LIBFPTR_PARAM_DATA_TYPE равным LIBFPTR_DT_NON_NULLABLE_SUM и указать тип чека LIBFPTR_PARAM_RECEIPT_TYPE.

Для запроса необнуляемой суммы по заданному типу оплаты необходимо вызвать метод queryData() с типом запроса LIBFPTR_PARAM_DATA_TYPE равным LIBFPTR_DT_NON_NULLABLE_SUM_BY_PAYMENTS и указать тип чека LIBFPTR_PARAM_RECEIPT_TYPE.

Тип чека (LIBFPTR_PARAM_RECEIPT_TYPE) может принимать следующие значения:

Способ расчета (LIBFPTR_PARAM_PAYMENT_TYPE) может принимать следующие значения:

Результатом этого запроса будет следующая информация:

Параметр Описание Тип
LIBFPTR_PARAM_SUM Сумма налога double

Количество чеков

Запрос количества чеков прихода

libfptr_set_param_int(fptr, LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_RECEIPT_COUNT);
libfptr_set_param_int(fptr, LIBFPTR_PARAM_RECEIPT_TYPE, LIBFPTR_RT_SELL);
libfptr_query_data(fptr);

int count = libfptr_get_param_int(fptr, LIBFPTR_PARAM_DOCUMENTS_COUNT);

fptr.setParam(LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_RECEIPT_COUNT);
fptr.setParam(LIBFPTR_PARAM_RECEIPT_TYPE, LIBFPTR_RT_SELL);
fptr.queryData();

uint count = fptr.getParamInt(LIBFPTR_PARAM_DOCUMENTS_COUNT);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_RECEIPT_COUNT)
fptr.setParam(IFptr.LIBFPTR_PARAM_RECEIPT_TYPE, IFptr.LIBFPTR_RT_SELL)
fptr.queryData()

count = fptr.getParamInt(IFptr.LIBFPTR_PARAM_DOCUMENTS_COUNT)

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_RECEIPT_COUNT);
fptr.setParam(IFptr.LIBFPTR_PARAM_RECEIPT_TYPE, IFptr.LIBFPTR_RT_SELL);
fptr.queryData();

long count = fptr.getParamInt(IFptr.LIBFPTR_PARAM_DOCUMENTS_COUNT);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_RECEIPT_COUNT);
fptr.setParam(IFptr.LIBFPTR_PARAM_RECEIPT_TYPE, IFptr.LIBFPTR_RT_SELL);
fptr.queryData();

long count = fptr.getParamInt(IFptr.LIBFPTR_PARAM_DOCUMENTS_COUNT);

[fptr setParam:LIBFPTR_PARAM_DATA_TYPE intParam:LIBFPTR_DT_RECEIPT_COUNT];
[fptr setParam:LIBFPTR_PARAM_RECEIPT_TYPE intParam:LIBFPTR_RT_SELL];
[fptr queryData];

uint count = [fptr getParamInt:LIBFPTR_PARAM_DOCUMENTS_COUNT];

fptr.setParam(Constants.LIBFPTR_PARAM_DATA_TYPE, Constants.LIBFPTR_DT_RECEIPT_COUNT);
fptr.setParam(Constants.LIBFPTR_PARAM_RECEIPT_TYPE, Constants.LIBFPTR_RT_SELL);
fptr.queryData();

uint count = fptr.getParamInt(Constants.LIBFPTR_PARAM_DOCUMENTS_COUNT);

var
    count: Longint;
begin
    fptr.setParam(fptr.LIBFPTR_PARAM_DATA_TYPE, fptr.LIBFPTR_DT_RECEIPT_COUNT);
    fptr.setParam(fptr.LIBFPTR_PARAM_RECEIPT_TYPE, fptr.LIBFPTR_RT_SELL);
    fptr.queryData;

    count := fptr.getParamInt(fptr.LIBFPTR_PARAM_DOCUMENTS_COUNT);
end;

fptr.SetParam(fptr10.LIBFPTR_PARAM_DATA_TYPE, fptr10.LIBFPTR_DT_RECEIPT_COUNT)
fptr.SetParam(fptr10.LIBFPTR_PARAM_RECEIPT_TYPE, fptr10.LIBFPTR_RT_SELL)
fptr.QueryData()

count := fptr.GetParamInt(fptr10.LIBFPTR_PARAM_DOCUMENTS_COUNT)

Fptr.setParam(Fptr.LIBFPTR_PARAM_DATA_TYPE, Fptr.LIBFPTR_DT_RECEIPT_COUNT);
Fptr.setParam(Fptr.LIBFPTR_PARAM_RECEIPT_TYPE, Fptr.LIBFPTR_RT_SELL);
Fptr.queryData();

count = Fptr.getParamInt(Fptr.LIBFPTR_PARAM_DOCUMENTS_COUNT);

Для запроса количества чеков необходимо вызвать метод queryData() с типом запроса LIBFPTR_PARAM_DATA_TYPE равным LIBFPTR_DT_RECEIPT_COUNT и указать тип чека LIBFPTR_PARAM_RECEIPT_TYPE.

Тип чека (LIBFPTR_PARAM_RECEIPT_TYPE) может принимать следующие значения:

Результатом этого запроса будет следующая информация:

Параметр Описание Тип
LIBFPTR_PARAM_DOCUMENTS_COUNT Количество чеков int

Количество отмененных чеков

Запрос количества отмененных чеков прихода

libfptr_set_param_int(fptr, LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_CANCELLATION_COUNT);
libfptr_set_param_int(fptr, LIBFPTR_PARAM_RECEIPT_TYPE, LIBFPTR_RT_SELL);
libfptr_query_data(fptr);

int count = libfptr_get_param_int(fptr, LIBFPTR_PARAM_DOCUMENTS_COUNT);

fptr.setParam(LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_CANCELLATION_COUNT);
fptr.setParam(LIBFPTR_PARAM_RECEIPT_TYPE, LIBFPTR_RT_SELL);
fptr.queryData();

uint count = fptr.getParamInt(LIBFPTR_PARAM_DOCUMENTS_COUNT);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_CANCELLATION_COUNT)
fptr.setParam(IFptr.LIBFPTR_PARAM_RECEIPT_TYPE, IFptr.LIBFPTR_RT_SELL)
fptr.queryData()

count = fptr.getParamInt(IFptr.LIBFPTR_PARAM_DOCUMENTS_COUNT)

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_CANCELLATION_COUNT);
fptr.setParam(IFptr.LIBFPTR_PARAM_RECEIPT_TYPE, IFptr.LIBFPTR_RT_SELL);
fptr.queryData();

long count = fptr.getParamInt(IFptr.LIBFPTR_PARAM_DOCUMENTS_COUNT);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_CANCELLATION_COUNT);
fptr.setParam(IFptr.LIBFPTR_PARAM_RECEIPT_TYPE, IFptr.LIBFPTR_RT_SELL);
fptr.queryData();

long count = fptr.getParamInt(IFptr.LIBFPTR_PARAM_DOCUMENTS_COUNT);

[fptr setParam:LIBFPTR_PARAM_DATA_TYPE intParam:LIBFPTR_DT_CANCELLATION_COUNT];
[fptr setParam:LIBFPTR_PARAM_RECEIPT_TYPE intParam:LIBFPTR_RT_SELL];
[fptr queryData];

uint count = [fptr getParamInt:LIBFPTR_PARAM_DOCUMENTS_COUNT];

fptr.setParam(Constants.LIBFPTR_PARAM_DATA_TYPE, Constants.LIBFPTR_DT_CANCELLATION_COUNT);
fptr.setParam(Constants.LIBFPTR_PARAM_RECEIPT_TYPE, Constants.LIBFPTR_RT_SELL);
fptr.queryData();

uint count = fptr.getParamInt(Constants.LIBFPTR_PARAM_DOCUMENTS_COUNT);

var
    count: Longint;
begin
    fptr.setParam(fptr.LIBFPTR_PARAM_DATA_TYPE, fptr.LIBFPTR_DT_CANCELLATION_COUNT);
    fptr.setParam(fptr.LIBFPTR_PARAM_RECEIPT_TYPE, fptr.LIBFPTR_RT_SELL);
    fptr.queryData;

    count := fptr.getParamInt(fptr.LIBFPTR_PARAM_DOCUMENTS_COUNT);
end;

fptr.SetParam(fptr10.LIBFPTR_PARAM_DATA_TYPE, fptr10.LIBFPTR_DT_CANCELLATION_COUNT)
fptr.SetParam(fptr10.LIBFPTR_PARAM_RECEIPT_TYPE, fptr10.LIBFPTR_RT_SELL)
fptr.QueryData()

count := fptr.GetParamInt(fptr10.LIBFPTR_PARAM_DOCUMENTS_COUNT)

Fptr.setParam(Fptr.LIBFPTR_PARAM_DATA_TYPE, Fptr.LIBFPTR_DT_CANCELLATION_COUNT);
Fptr.setParam(Fptr.LIBFPTR_PARAM_RECEIPT_TYPE, Fptr.LIBFPTR_RT_SELL);
Fptr.queryData();

count = Fptr.getParamInt(Fptr.LIBFPTR_PARAM_DOCUMENTS_COUNT);

Запрос общего количества отмененных чеков

libfptr_set_param_int(fptr, LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_CANCELLATION_COUNT_ALL);
libfptr_query_data(fptr);

int count = libfptr_get_param_int(fptr, LIBFPTR_PARAM_DOCUMENTS_COUNT);

fptr.setParam(LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_CANCELLATION_COUNT_ALL);
fptr.queryData();

uint count = fptr.getParamInt(LIBFPTR_PARAM_DOCUMENTS_COUNT);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_CANCELLATION_COUNT_ALL)
fptr.queryData()

count = fptr.getParamInt(IFptr.LIBFPTR_PARAM_DOCUMENTS_COUNT)

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_CANCELLATION_COUNT_ALL);
fptr.queryData();

long count = fptr.getParamInt(IFptr.LIBFPTR_PARAM_DOCUMENTS_COUNT);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_CANCELLATION_COUNT_ALL);
fptr.queryData();

long count = fptr.getParamInt(IFptr.LIBFPTR_PARAM_DOCUMENTS_COUNT);

[fptr setParam:LIBFPTR_PARAM_DATA_TYPE intParam:LIBFPTR_DT_CANCELLATION_COUNT_ALL];
[fptr queryData];

uint count = [fptr getParamInt:LIBFPTR_PARAM_DOCUMENTS_COUNT];

fptr.setParam(Constants.LIBFPTR_PARAM_DATA_TYPE, Constants.LIBFPTR_PARAM_DOCUMENTS_COUNT
fptr.queryData();

uint count = fptr.getParamInt(Constants.LIBFPTR_PARAM_DOCUMENTS_COUNT);

var
    count: Longint;
begin
    fptr.setParam(fptr.LIBFPTR_PARAM_DATA_TYPE, fptr.LIBFPTR_PARAM_DOCUMENTS_COUNT);
    fptr.queryData;

    count := fptr.getParamInt(fptr.LIBFPTR_PARAM_DOCUMENTS_COUNT);
end;

fptr.SetParam(fptr10.LIBFPTR_PARAM_DATA_TYPE, fptr10.LIBFPTR_DT_CANCELLATION_COUNT_ALL)
fptr.QueryData()

count := fptr.GetParamInt(fptr10.LIBFPTR_PARAM_DOCUMENTS_COUNT)

Fptr.setParam(Fptr.LIBFPTR_PARAM_DATA_TYPE, Fptr.LIBFPTR_DT_CANCELLATION_COUNT_ALL);
Fptr.queryData();

count = Fptr.getParamInt(Fptr.LIBFPTR_PARAM_DOCUMENTS_COUNT);

Для запроса количества отмененных чеков с заданным типом необходимо вызвать метод queryData() с типом запроса LIBFPTR_PARAM_DATA_TYPE равным LIBFPTR_DT_CANCELLATION_COUNT и указать тип чека LIBFPTR_PARAM_RECEIPT_TYPE.

Тип чека (LIBFPTR_PARAM_RECEIPT_TYPE) может принимать следующие значения:

Для запроса общего количества отмененных чеков необходимо вызвать метод queryData() с типом запроса LIBFPTR_PARAM_DATA_TYPE равным LIBFPTR_DT_CANCELLATION_COUNT_ALL.

Результатом этих запросов будет следующая информация:

Параметр Описание Тип
LIBFPTR_PARAM_DOCUMENTS_COUNT Количество чеков int

Сумма отмененных чеков

Запрос суммы отмененных чеков прихода

libfptr_set_param_int(fptr, LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_CANCELLATION_SUM);
libfptr_set_param_int(fptr, LIBFPTR_PARAM_RECEIPT_TYPE, LIBFPTR_RT_SELL);
libfptr_query_data(fptr);

double sum = libfptr_get_param_double(fptr, LIBFPTR_PARAM_SUM);

fptr.setParam(LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_CANCELLATION_SUM);
fptr.setParam(LIBFPTR_PARAM_RECEIPT_TYPE, LIBFPTR_RT_SELL);
fptr.queryData();

double sum = fptr.getParamDouble(LIBFPTR_PARAM_SUM);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_CANCELLATION_SUM)
fptr.setParam(IFptr.LIBFPTR_PARAM_RECEIPT_TYPE, IFptr.LIBFPTR_RT_SELL)
fptr.queryData()

sum = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_SUM)

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_CANCELLATION_SUM);
fptr.setParam(IFptr.LIBFPTR_PARAM_RECEIPT_TYPE, IFptr.LIBFPTR_RT_SELL);
fptr.queryData();

double sum = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_SUM);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_CANCELLATION_SUM);
fptr.setParam(IFptr.LIBFPTR_PARAM_RECEIPT_TYPE, IFptr.LIBFPTR_RT_SELL);
fptr.queryData();

double sum = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_SUM);

[fptr setParam:LIBFPTR_PARAM_DATA_TYPE intParam:LIBFPTR_DT_CANCELLATION_SUM];
[fptr setParam:LIBFPTR_PARAM_RECEIPT_TYPE intParam:LIBFPTR_RT_SELL];
[fptr queryData];

double sum = [fptr getParamDouble:LIBFPTR_PARAM_SUM];

fptr.setParam(Constants.LIBFPTR_PARAM_DATA_TYPE, Constants.LIBFPTR_DT_CANCELLATION_SUM);
fptr.setParam(Constants.LIBFPTR_PARAM_RECEIPT_TYPE, Constants.LIBFPTR_RT_SELL);
fptr.queryData();

double sum = fptr.getParamDouble(Constants.LIBFPTR_PARAM_SUM);

var
    sum: Double;
begin
    fptr.setParam(fptr.LIBFPTR_PARAM_DATA_TYPE, fptr.LIBFPTR_DT_CANCELLATION_SUM_ALL);
    fptr.setParam(fptr.LIBFPTR_PARAM_RECEIPT_TYPE, fptr.LIBFPTR_RT_SELL);
    fptr.queryData;

    sum := fptr.getParamDouble(fptr.LIBFPTR_PARAM_SUM);
end;

fptr.SetParam(fptr10.LIBFPTR_PARAM_DATA_TYPE, fptr10.LIBFPTR_DT_CANCELLATION_SUM)
fptr.SetParam(fptr10.LIBFPTR_PARAM_RECEIPT_TYPE, fptr10.LIBFPTR_RT_SELL)
fptr.QueryData()

sum := fptr.GetParamDouble(fptr10.LIBFPTR_PARAM_SUM)

Fptr.setParam(Fptr.LIBFPTR_PARAM_DATA_TYPE, Fptr.LIBFPTR_DT_CANCELLATION_SUM);
Fptr.setParam(Fptr.LIBFPTR_PARAM_DATA_TYPE, Fptr.LIBFPTR_RT_SELL);
Fptr.queryData();

sum = Fptr.getParamDouble(Fptr.LIBFPTR_PARAM_SUM);

Запрос общей суммы отмененных чеков

libfptr_set_param_int(fptr, LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_CANCELLATION_SUM_ALL);
libfptr_query_data(fptr);

double sum = libfptr_get_param_double(fptr, LIBFPTR_PARAM_SUM);

fptr.setParam(LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_CANCELLATION_SUM_ALL);
fptr.queryData();

double sum = fptr.getParamDouble(LIBFPTR_PARAM_SUM);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_CANCELLATION_SUM_ALL)
fptr.queryData()

sum = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_SUM)

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_CANCELLATION_SUM_ALL);
fptr.queryData();

double sum = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_SUM);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_CANCELLATION_SUM_ALL);
fptr.queryData();

double sum = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_SUM);

[fptr setParam:LIBFPTR_PARAM_DATA_TYPE intParam:LIBFPTR_DT_CANCELLATION_SUM_ALL];
[fptr queryData];

double sum = [fptr getParamDouble:LIBFPTR_PARAM_SUM];

fptr.setParam(Constants.LIBFPTR_PARAM_DATA_TYPE, Constants.LIBFPTR_DT_CANCELLATION_SUM_ALL);
fptr.queryData();

double sum = fptr.getParamDouble(Constants.LIBFPTR_PARAM_SUM);

var
    sum: Double;
begin
    fptr.setParam(fptr.LIBFPTR_PARAM_DATA_TYPE, fptr.LIBFPTR_DT_CANCELLATION_SUM_ALL);
    fptr.queryData;

    sum := fptr.getParamDouble(fptr.LIBFPTR_PARAM_SUM);
end;

fptr.SetParam(fptr10.LIBFPTR_PARAM_DATA_TYPE, fptr10.LIBFPTR_DT_CANCELLATION_SUM_ALL)
fptr.QueryData()

sum := fptr.GetParamDouble(fptr10.LIBFPTR_PARAM_SUM)

Fptr.setParam(Fptr.LIBFPTR_PARAM_DATA_TYPE, Fptr.LIBFPTR_DT_CANCELLATION_SUM_ALL);
Fptr.queryData();

sum = Fptr.getParamDouble(Fptr.LIBFPTR_PARAM_SUM);

Для запроса суммы отмененных чеков с заданным типом необходимо вызвать метод queryData() с типом запроса LIBFPTR_PARAM_DATA_TYPE равным LIBFPTR_DT_CANCELLATION_SUM и указать тип чека LIBFPTR_PARAM_RECEIPT_TYPE.

Тип чека (LIBFPTR_PARAM_RECEIPT_TYPE) может принимать следующие значения:

Для запроса общей суммы отмененных чеков необходимо вызвать метод queryData() с типом запроса LIBFPTR_PARAM_DATA_TYPE равным LIBFPTR_DT_CANCELLATION_SUM_ALL.

Результатом этих запросов будет следующая информация:

Параметр Описание Тип
LIBFPTR_PARAM_SUM Сумма чеков double

Состояние источника питания

Запрос состояния аккумуляторов

libfptr_set_param_int(fptr, LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_POWER_SOURCE_STATE);
libfptr_set_param_int(fptr, LIBFPTR_PARAM_POWER_SOURCE_TYPE, LIBFPTR_PST_BATTERY);
libfptr_query_data(fptr);

int charge      = libfptr_get_param_int(fptr, LIBFPTR_PARAM_BATTERY_CHARGE);
double voltage  = libfptr_get_param_double(fptr, LIBFPTR_PARAM_VOLTAGE);
bool useBattery = (libfptr_get_param_bool(fptr, LIBFPTR_PARAM_USE_BATTERY) != 0);
bool isCharging = (libfptr_get_param_bool(fptr, LIBFPTR_PARAM_BATTERY_CHARGING) != 0);
bool canPrint   = (libfptr_get_param_bool(fptr, LIBFPTR_PARAM_CAN_PRINT_WHILE_ON_BATTERY) != 0);

fptr.setParam(LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_POWER_SOURCE_STATE);
fptr.setParam(LIBFPTR_PARAM_POWER_SOURCE_TYPE, LIBFPTR_PST_BATTERY);
fptr.queryData();

uint charge      = fptr.getParamInt(LIBFPTR_PARAM_BATTERY_CHARGE);
double voltage   = fptr.getParamDouble(LIBFPTR_PARAM_VOLTAGE);
bool useBattery  = fptr.getParamBool(LIBFPTR_PARAM_USE_BATTERY);
bool isCharging  = fptr.getParamBool(LIBFPTR_PARAM_BATTERY_CHARGING);
bool canPrint    = fptr.getParamBool(LIBFPTR_PARAM_CAN_PRINT_WHILE_ON_BATTERY);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_POWER_SOURCE_STATE)
fptr.setParam(IFptr.LIBFPTR_PARAM_POWER_SOURCE_TYPE, IFptr.LIBFPTR_PST_BATTERY)
fptr.queryData()

charge      = fptr.getParamInt(IFptr.LIBFPTR_PARAM_BATTERY_CHARGE)
voltage     = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_VOLTAGE)
useBattery  = fptr.getParamBool(IFptr.LIBFPTR_PARAM_USE_BATTERY)
isCharging  = fptr.getParamBool(IFptr.LIBFPTR_PARAM_BATTERY_CHARGING)
canPrint    = fptr.getParamBool(IFptr.LIBFPTR_PARAM_CAN_PRINT_WHILE_ON_BATTERY)

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_POWER_SOURCE_STATE);
fptr.setParam(IFptr.LIBFPTR_PARAM_POWER_SOURCE_TYPE, IFptr.LIBFPTR_PST_BATTERY);
fptr.queryData();

long charge         = fptr.getParamInt(IFptr.LIBFPTR_PARAM_BATTERY_CHARGE);
double voltage      = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_VOLTAGE);
boolean useBattery  = fptr.getParamBool(IFptr.LIBFPTR_PARAM_USE_BATTERY);
boolean isCharging  = fptr.getParamBool(IFptr.LIBFPTR_PARAM_BATTERY_CHARGING);
boolean canPrint    = fptr.getParamBool(IFptr.LIBFPTR_PARAM_CAN_PRINT_WHILE_ON_BATTERY);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_POWER_SOURCE_STATE);
fptr.setParam(IFptr.LIBFPTR_PARAM_POWER_SOURCE_TYPE, IFptr.LIBFPTR_PST_BATTERY);
fptr.queryData();

long charge         = fptr.getParamInt(IFptr.LIBFPTR_PARAM_BATTERY_CHARGE);
double voltage      = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_VOLTAGE);
boolean useBattery  = fptr.getParamBool(IFptr.LIBFPTR_PARAM_USE_BATTERY);
boolean isCharging  = fptr.getParamBool(IFptr.LIBFPTR_PARAM_BATTERY_CHARGING);
boolean canPrint    = fptr.getParamBool(IFptr.LIBFPTR_PARAM_CAN_PRINT_WHILE_ON_BATTERY);

[fptr setParam:LIBFPTR_PARAM_DATA_TYPE intParam:LIBFPTR_DT_POWER_SOURCE_STATE];
[fptr setParam:LIBFPTR_PARAM_POWER_SOURCE_TYPE intParam:LIBFPTR_PST_BATTERY];
[fptr queryData];

uint charge         = [fptr getParamInt:LIBFPTR_PARAM_BATTERY_CHARGE];
double voltage      = [fptr getParamDouble:LIBFPTR_PARAM_VOLTAGE];
bool useBattery     = [fptr getParamBool:LIBFPTR_PARAM_USE_BATTERY];
bool isCharging     = [fptr getParamBool:LIBFPTR_PARAM_BATTERY_CHARGING];
bool canPrint       = [fptr getParamBool:LIBFPTR_PARAM_CAN_PRINT_WHILE_ON_BATTERY];

fptr.setParam(Constants.LIBFPTR_PARAM_DATA_TYPE, Constants.LIBFPTR_DT_POWER_SOURCE_STATE);
fptr.setParam(Constants.LIBFPTR_PARAM_POWER_SOURCE_TYPE, Constants.LIBFPTR_PST_BATTERY);
fptr.queryData();

uint charge         = fptr.getParamInt(Constants.LIBFPTR_PARAM_BATTERY_CHARGE);
double voltage      = fptr.getParamDouble(Constants.LIBFPTR_PARAM_VOLTAGE);
bool useBattery     = fptr.getParamBool(Constants.LIBFPTR_PARAM_USE_BATTERY);
bool isCharging     = fptr.getParamBool(Constants.LIBFPTR_PARAM_BATTERY_CHARGING);
bool canPrint       = fptr.getParamBool(Constants.LIBFPTR_PARAM_CAN_PRINT_WHILE_ON_BATTERY);

var
    temperaturer:   Integer;
    voltage:        Double;
    useBattery:     LongBool;
    isCharging:     LongBool;
    canPrint:       LongBool;  
begin
    fptr.setParam(fptr.LIBFPTR_PARAM_DATA_TYPE, fptr.LIBFPTR_DT_POWER_SOURCE_STATE);
    fptr.setParam(fptr.LIBFPTR_PARAM_POWER_SOURCE_TYPE, fptr.LIBFPTR_PST_BATTERY);
    fptr.queryData;

    charge          := fptr.getParamInt(fptr.LIBFPTR_PARAM_BATTERY_CHARGE);
    voltage         := fptr.getParamDouble(fptr.LIBFPTR_PARAM_VOLTAGE);
    useBattery      := fptr.getParamBool(fptr.LIBFPTR_PARAM_USE_BATTERY);
    isCharging      := fptr.getParamBool(fptr.LIBFPTR_PARAM_BATTERY_CHARGING);
    canPrint        := fptr.getParamBool(fptr.LIBFPTR_PARAM_CAN_PRINT_WHILE_ON_BATTERY);
end;

fptr.SetParam(fptr10.LIBFPTR_PARAM_DATA_TYPE, fptr10.LIBFPTR_DT_POWER_SOURCE_STATE)
fptr.SetParam(fptr10.LIBFPTR_PARAM_POWER_SOURCE_TYPE, fptr10.LIBFPTR_PST_BATTERY)
fptr.QueryData()

charge      := fptr.GetParamInt(fptr10.LIBFPTR_PARAM_BATTERY_CHARGE)
voltage     := fptr.GetParamDouble(fptr10.LIBFPTR_PARAM_VOLTAGE)
useBattery  := fptr.GetParamBool(fptr10.LIBFPTR_PARAM_USE_BATTERY)
isCharging  := fptr.GetParamBool(fptr10.LIBFPTR_PARAM_BATTERY_CHARGING)
canPrint    := fptr.GetParamBool(fptr10.LIBFPTR_PARAM_CAN_PRINT_WHILE_ON_BATTERY)

Fptr.setParam(Fptr.LIBFPTR_PARAM_DATA_TYPE, Fptr.LIBFPTR_DT_POWER_SOURCE_STATE);
Fptr.setParam(Fptr.LIBFPTR_PARAM_POWER_SOURCE_TYPE, Fptr.LIBFPTR_PST_BATTERY);
Fptr.queryData();

charge     = fptr.getParamInt(Fptr.LIBFPTR_PARAM_BATTERY_CHARGE);
voltage    = fptr.getParamDouble(Fptr.LIBFPTR_PARAM_VOLTAGE);
useBattery = fptr.getParamBool(Fptr.LIBFPTR_PARAM_USE_BATTERY);
isCharging = fptr.getParamBool(Fptr.LIBFPTR_PARAM_BATTERY_CHARGING);
canPrint   = fptr.getParamBool(Fptr.LIBFPTR_PARAM_CAN_PRINT_WHILE_ON_BATTERY);

Для запроса состояния источника питания необходимо вызвать метод queryData() с типом запроса LIBFPTR_PARAM_DATA_TYPE равным LIBFPTR_DT_POWER_SOURCE_STATE и указать тип источника LIBFPTR_PARAM_POWER_SOURCE_TYPE.

Тип источника (LIBFPTR_PARAM_POWER_SOURCE_TYPE) может принимать следующие значения:

Результатом этого запроса будет следующая информация:

Параметр Описание Тип
LIBFPTR_PARAM_BATTERY_CHARGE Заряд аккумулятора, проценты int
LIBFPTR_PARAM_VOLTAGE Напряжения источника питания, В. double
LIBFPTR_PARAM_USE_BATTERY Работа от аккумулятора bool
LIBFPTR_PARAM_BATTERY_CHARGING Аккумуляторы заряжаются bool
LIBFPTR_PARAM_CAN_PRINT_WHILE_ON_BATTERY ККТ может печатать при текущем заряде аккумулятора bool

Температура ТПГ

Запрос температуры ТПГ

libfptr_set_param_int(fptr, LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_PRINTER_TEMPERATURE);
libfptr_query_data(fptr);

int temperature = libfptr_get_param_int(fptr, LIBFPTR_PARAM_PRINTER_TEMPERATURE);

fptr.setParam(LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_PRINTER_TEMPERATURE);
fptr.queryData();

uint temperature = fptr.getParamInt(LIBFPTR_PARAM_PRINTER_TEMPERATURE);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_PRINTER_TEMPERATURE)
fptr.queryData()

temperature = fptr.getParamInt(IFptr.LIBFPTR_PARAM_PRINTER_TEMPERATURE)

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_PRINTER_TEMPERATURE);
fptr.queryData();

long temperature = fptr.getParamInt(IFptr.LIBFPTR_PARAM_PRINTER_TEMPERATURE);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_PRINTER_TEMPERATURE);
fptr.queryData();

long temperature = fptr.getParamInt(IFptr.LIBFPTR_PARAM_PRINTER_TEMPERATURE);

[fptr setParam:LIBFPTR_PARAM_DATA_TYPE intParam:LIBFPTR_DT_PRINTER_TEMPERATURE];
[fptr queryData];

uint temperature = [fptr getParamInt: LIBFPTR_PARAM_PRINTER_TEMPERATURE];

fptr.setParam(Constants.LIBFPTR_PARAM_DATA_TYPE, Constants.LIBFPTR_DT_PRINTER_TEMPERATURE);
fptr.queryData();

uint temperature = fptr.getParamInt(Constants.LIBFPTR_PARAM_PRINTER_TEMPERATURE);

var
    temperaturer: Longint;
begin
    fptr.setParam(fptr.LIBFPTR_PARAM_DATA_TYPE, fptr.LIBFPTR_DT_PRINTER_TEMPERATURE);
    fptr.queryData;

    temperature := fptr.getParamInt(fptr.LIBFPTR_PARAM_PRINTER_TEMPERATURE);
end;

fptr.SetParam(fptr10.LIBFPTR_PARAM_DATA_TYPE, fptr10.LIBFPTR_DT_PRINTER_TEMPERATURE)
fptr.QueryData()

temperature := fptr.GetParamInt(fptr10.LIBFPTR_PARAM_PRINTER_TEMPERATURE)

Fptr.setParam(Fptr.LIBFPTR_PARAM_DATA_TYPE, Fptr.LIBFPTR_DT_PRINTER_TEMPERATURE);
Fptr.queryData();

temperature = Fptr.getParamInt(Fptr.LIBFPTR_PARAM_PRINTER_TEMPERATURE);

Для запроса температуры ТПГ необходимо вызвать метод queryData() с типом запроса LIBFPTR_PARAM_DATA_TYPE равным LIBFPTR_DT_PRINTER_TEMPERATURE.

Результатом этого запроса будет следующая информация:

Параметр Описание Тип
LIBFPTR_PARAM_PRINTER_TEMPERATURE Температура ТПГ, градусы int

Фатальные ошибки

Запрос фатальных ошибок

libfptr_set_param_int(fptr, LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_FATAL_STATUS);
libfptr_query_data(fptr);

bool noSerialNumber         = (libfptr_get_param_bool(fptr, LIBFPTR_PARAM_NO_SERIAL_NUMBER) != 0);
bool rtcFault               = (libfptr_get_param_bool(fptr, LIBFPTR_PARAM_RTC_FAULT) != 0);
bool settingsFault          = (libfptr_get_param_bool(fptr, LIBFPTR_PARAM_SETTINGS_FAULT) != 0);
bool counterFault           = (libfptr_get_param_bool(fptr, LIBFPTR_PARAM_COUNTERS_FAULT) != 0);
bool userMemoryFault        = (libfptr_get_param_bool(fptr, LIBFPTR_PARAM_USER_MEMORY_FAULT) != 0);
bool serviceCountersFault   = (libfptr_get_param_bool(fptr, LIBFPTR_PARAM_SERVICE_COUNTERS_FAULT) != 0);
bool attributesFault        = (libfptr_get_param_bool(fptr, LIBFPTR_PARAM_ATTRIBUTES_FAULT) != 0);
bool fnFault                = (libfptr_get_param_bool(fptr, LIBFPTR_PARAM_FN_FAULT) != 0);
bool invalidFN              = (libfptr_get_param_bool(fptr, LIBFPTR_PARAM_INVALID_FN) != 0);
bool hardFault              = (libfptr_get_param_bool(fptr, LIBFPTR_PARAM_HARD_FAULT) != 0);
bool memoryManagerFault     = (libfptr_get_param_bool(fptr, LIBFPTR_PARAM_MEMORY_MANAGER_FAULT) != 0);
bool scriptFault            = (libfptr_get_param_bool(fptr, LIBFPTR_PARAM_SCRIPTS_FAULT) != 0);
bool waitForReboot          = (libfptr_get_param_bool(fptr, LIBFPTR_PARAM_WAIT_FOR_REBOOT) != 0);
bool universalCountersFault = (libfptr_get_param_bool(fptr, LIBFPTR_PARAM_UNIVERSAL_COUNTERS_FAULT) != 0);
bool commoditiesTableFault  = (libfptr_get_param_bool(fptr, LIBFPTR_PARAM_COMMODITIES_TABLE_FAULT) != 0);

fptr.setParam(LIBFPTR_PARAM_DATA_TYPE, LIBFPTR_DT_FATAL_STATUS);
fptr.queryData();

bool noSerialNumber         = fptr.getParamBool(LIBFPTR_PARAM_NO_SERIAL_NUMBER);
bool rtcFault               = fptr.getParamBool(LIBFPTR_PARAM_RTC_FAULT);
bool settingsFault          = fptr.getParamBool(LIBFPTR_PARAM_SETTINGS_FAULT);
bool counterFault           = fptr.getParamBool(LIBFPTR_PARAM_COUNTERS_FAULT);
bool userMemoryFault        = fptr.getParamBool(LIBFPTR_PARAM_USER_MEMORY_FAULT);
bool serviceCountersFault   = fptr.getParamBool(LIBFPTR_PARAM_SERVICE_COUNTERS_FAULT);
bool attributesFault        = fptr.getParamBool(LIBFPTR_PARAM_ATTRIBUTES_FAULT);
bool fnFault                = fptr.getParamBool(LIBFPTR_PARAM_FN_FAULT);
bool invalidFN              = fptr.getParamBool(LIBFPTR_PARAM_INVALID_FN);
bool hardFault              = fptr.getParamBool(LIBFPTR_PARAM_HARD_FAULT);
bool memoryManagerFault     = fptr.getParamBool(LIBFPTR_PARAM_MEMORY_MANAGER_FAULT);
bool scriptFault            = fptr.getParamBool(LIBFPTR_PARAM_SCRIPTS_FAULT);
bool waitForReboot          = fptr.getParamBool(LIBFPTR_PARAM_WAIT_FOR_REBOOT);
bool universalCountersFault = fptr.getParamBool(LIBFPTR_PARAM_UNIVERSAL_COUNTERS_FAULT);
bool commoditiesTableFault  = fptr.getParamBool(LIBFPTR_PARAM_COMMODITIES_TABLE_FAULT);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_FATAL_STATUS)
fptr.queryData()

noSerialNumber          = fptr.getParamBool(IFptr.LIBFPTR_PARAM_NO_SERIAL_NUMBER)
rtcFault                = fptr.getParamBool(IFptr.LIBFPTR_PARAM_RTC_FAULT)
settingsFault           = fptr.getParamBool(IFptr.LIBFPTR_PARAM_SETTINGS_FAULT)
counterFault            = fptr.getParamBool(IFptr.LIBFPTR_PARAM_COUNTERS_FAULT)
userMemoryFault         = fptr.getParamBool(IFptr.LIBFPTR_PARAM_USER_MEMORY_FAULT)
serviceCountersFault    = fptr.getParamBool(IFptr.LIBFPTR_PARAM_SERVICE_COUNTERS_FAULT)
attributesFault         = fptr.getParamBool(IFptr.LIBFPTR_PARAM_ATTRIBUTES_FAULT)
fnFault                 = fptr.getParamBool(IFptr.LIBFPTR_PARAM_FN_FAULT)
invalidFN               = fptr.getParamBool(IFptr.LIBFPTR_PARAM_INVALID_FN)
hardFault               = fptr.getParamBool(IFptr.LIBFPTR_PARAM_HARD_FAULT)
memoryManagerFault      = fptr.getParamBool(IFptr.LIBFPTR_PARAM_MEMORY_MANAGER_FAULT)
scriptFault             = fptr.getParamBool(IFptr.LIBFPTR_PARAM_SCRIPTS_FAULT)
waitForReboot           = fptr.getParamBool(IFptr.LIBFPTR_PARAM_WAIT_FOR_REBOOT)
universalCountersFault  = fptr.getParamBool(IFptr.LIBFPTR_PARAM_UNIVERSAL_COUNTERS_FAULT)
commoditiesTableFault   = fptr.getParamBool(IFptr.LIBFPTR_PARAM_COMMODITIES_TABLE_FAULT)

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_FATAL_STATUS);
fptr.queryData();

boolean noSerialNumber          = fptr.getParamBool(IFptr.LIBFPTR_PARAM_NO_SERIAL_NUMBER);
boolean rtcFault                = fptr.getParamBool(IFptr.LIBFPTR_PARAM_RTC_FAULT);
boolean settingsFault           = fptr.getParamBool(IFptr.LIBFPTR_PARAM_SETTINGS_FAULT);
boolean counterFault            = fptr.getParamBool(IFptr.LIBFPTR_PARAM_COUNTERS_FAULT);
boolean userMemoryFault         = fptr.getParamBool(IFptr.LIBFPTR_PARAM_USER_MEMORY_FAULT);
boolean serviceCountersFault    = fptr.getParamBool(IFptr.LIBFPTR_PARAM_SERVICE_COUNTERS_FAULT);
boolean attributesFault         = fptr.getParamBool(IFptr.LIBFPTR_PARAM_ATTRIBUTES_FAULT);
boolean fnFault                 = fptr.getParamBool(IFptr.LIBFPTR_PARAM_FN_FAULT);
boolean invalidFN               = fptr.getParamBool(IFptr.LIBFPTR_PARAM_INVALID_FN);
boolean hardFault               = fptr.getParamBool(IFptr.LIBFPTR_PARAM_HARD_FAULT);
boolean memoryManagerFault      = fptr.getParamBool(IFptr.LIBFPTR_PARAM_MEMORY_MANAGER_FAULT);
boolean scriptFault             = fptr.getParamBool(IFptr.LIBFPTR_PARAM_SCRIPTS_FAULT);
boolean waitForReboot           = fptr.getParamBool(IFptr.LIBFPTR_PARAM_WAIT_FOR_REBOOT);
boolean universalCountersFault  = fptr.getParamBool(IFptr.LIBFPTR_PARAM_UNIVERSAL_COUNTERS_FAULT);
boolean commoditiesTableFault   = fptr.getParamBool(IFptr.LIBFPTR_PARAM_COMMODITIES_TABLE_FAULT);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_FATAL_STATUS);
fptr.queryData();

boolean noSerialNumber          = fptr.getParamBool(IFptr.LIBFPTR_PARAM_NO_SERIAL_NUMBER);
boolean rtcFault                = fptr.getParamBool(IFptr.LIBFPTR_PARAM_RTC_FAULT);
boolean settingsFault           = fptr.getParamBool(IFptr.LIBFPTR_PARAM_SETTINGS_FAULT);
boolean counterFault            = fptr.getParamBool(IFptr.LIBFPTR_PARAM_COUNTERS_FAULT);
boolean userMemoryFault         = fptr.getParamBool(IFptr.LIBFPTR_PARAM_USER_MEMORY_FAULT);
boolean serviceCountersFault    = fptr.getParamBool(IFptr.LIBFPTR_PARAM_SERVICE_COUNTERS_FAULT);
boolean attributesFault         = fptr.getParamBool(IFptr.LIBFPTR_PARAM_ATTRIBUTES_FAULT);
boolean fnFault                 = fptr.getParamBool(IFptr.LIBFPTR_PARAM_FN_FAULT);
boolean invalidFN               = fptr.