NAV Navbar
C/C++ Python Java Android Objective-C C# COM (Delphi)

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

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

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

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

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

СКАЧАТЬ:

Онлайн тестовая касса с МГН v1.1 КАЗНАЧЕЙ ФА

Видео обучающие материалы КАЗНАЧЕЙ

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

Состав файла 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=%d{%Y.%m.%d %H:%M:%S.%l} T:%t %-5p [%c] %m%n

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

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

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

Для логирования используется библиотека 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.

Python

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

Java

Для подключения драйвера к Java-проекту необходимо подключить библиотеку libfptr10.jar, а также обеспечить нахождение нативных компонентов (libfptr10.so / fptr10.dll и их зависимостей) в java.library.path. Библиотека может сама обнаружить установленный через инсталлятор драйвер. Минимальная поддерживаемая версия Java - 1.6.

Android

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

iOS

Для подключения драйвера к iOS-проекту необходимо добавить в проект фреймворк fptr10.framework и использовать заголовочный файл libfptr10_objc.h. Минимальная поддерживаемая версия iOS - 8. Фреймворк поставляется в следующих сборках:

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

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

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

.NET

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

COM-объект

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

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

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

  #include "libfptr10.h"

  libfptr_handle fptr;
  libfptr_create(&fptr);

  from libfptr10 import IFptr
  import os

  LIBRARY_PATH = os.path.dirname(os.path.abspath(__file__))

  fptr = IFptr(os.path.join(LIBRARY_PATH, "fptr10.dll"))

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

  IFptr fptr = 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 = new Fptr();

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

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

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

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

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

  libfptr_destroy(&fptr);

  del fptr

  fptr.destroy();

  fptr.destroy();

  [fptr release];

  fptr.destroy();

  fptr := Unassigned

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

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

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

  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);

  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)

  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_COM,
    LIBFPTR_SETTING_COM_FILE, @"COM5",
    LIBFPTR_SETTING_BAUDRATE, LIBFPTR_PORT_BR_115200];
  [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 := 
        '{"' + 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;

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

  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(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_COM));
  [fptr setSingleSetting:LIBFPTR_SETTING_COM_FILE, value:@"COM5");
  [fptr setSingleSetting:LIBFPTR_SETTING_BAUDRATE, value:[NSString stringWithFormat:@"%d", LIBFPTR_MODEL_ATOL_AUTO]];
  [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;

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

  libfptr_show_properties(fptr, 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;

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

Первый способ - передача всех настроек в виде json. Способ удобен тем, что настройки в таком виде можно запросить у драйвера, сохранить, и при следующей работе с ККТ передать их в драйвер заново как есть. При передаче настроек драйвер разорвет связь с ККТ, если она установлена, изменит настройки и подключится заново.

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

Третий способ - вызов окна настройки связи с ККТ. В случае использования метода 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());
}

settings = fptr.getSettings()

String settings = fptr.getSettings();

String settings = fptr.getSettings();

NSString *settings = [fptr getSettings];

String settings = fptr.getSettings();

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

Выгрузка настроек, способ второй (на примере получения 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]);

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;

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

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

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

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

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

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

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

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

Настройка обмена с ОФД

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

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

Настройка ККТ Настройка драйвера Пояснение
USB (EoU) LIBFPTR_OFD_CHANNEL_NONE Для работы требуется утилита EoU. Драйвер в обмене не участвует.
Ethernet LIBFPTR_OFD_CHANNEL_NONE Для работы требуется, чтобы ККТ была подключена к сети через Ethernet-кабель. Драйвер в обмене не участвует.
Wi-Fi LIBFPTR_OFD_CHANNEL_NONE Для работы требуется, чтобы ККТ была подключена к сети через Wi-Fi. Драйвер в обмене не участвует.
GSM-модем LIBFPTR_OFD_CHANNEL_NONE Для работы требуется, чтобы в ККТ была установлена SIM-карта. Драйвер в обмене не участвует.
EthernetOverTransport LIBFPTR_OFD_CHANNEL_PROTO В этом случае для пеередачи данных в ОФД будет использоваться канал хоста, на котором установлен драйвер. Для работы требуется, чтобы драйвер постоянно держал соединение с ККТ.

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

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

libfptr_set_param_int(fptr, 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, IFptr.LIBFPTR_TAX_VAT18);

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

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

libfptr_set_param_double(fptr, 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;

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

libfptr_set_param_bool(fptr, 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;

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

libfptr_set_param_str(fptr, 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;

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

libfptr_set_param_datetime(fptr, LIBFPTR_PARAM_DATE_TIME, 2017, 1, 2, 12, 13, 45);

fptr.setParam(IFptr.LIBFPTR_PARAM_DATE_TIME, datetime.datetime(2017, 1, 2, 12, 13, 45))

Calendar c = Calendar.getInstance();
c.set(2017, 1, 2, 12, 13, 45);
fptr.setParam(IFptr.LIBFPTR_PARAM_DATE_TIME, c.getTime());

Calendar c = Calendar.getInstance();
c.set(2017, 1, 2, 12, 13, 45);
fptr.setParam(IFptr.LIBFPTR_PARAM_DATE_TIME, c.getTime());

NSCalendar *calendar = [NSCalendar currentCalendar];
NSDateComponents *components = [[NSDateComponents alloc] init];
[components setYear:[2017 intValue]];
[components setMonth:[1 intValue]];
[components setDay:[2 intValue]];
[components setHour:[12 intValue]];
[components setMinute:[13 intValue]];
[components setSecond:[45 intValue]];
[fptr setParam:LIBFPTR_PARAM_DATE_TIME, NSDateParam:[calendar dateFromComponents:components]];

DateTime date = new DateTime(2017, 1, 2, 12, 13, 45);
fptr.setParam(Constants.LIBFPTR_PARAM_DATE_TIME, date);

var
    date: TDateTime;
begin
    date := StrToDateTime('02.01.2017 12:13:45');
    fptr.setParam(fptr.LIBFPTR_PARAM_DATE_TIME, date);
end;

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

uchar command[] = {0x91, 0x13, 0x00, 0x00};
libfptr_set_param_bytearray(fptr, 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)]];

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

var
    command_byte_array:    Array[0 .. 3] of Byte;
    command_variant:       Variant;
    i:                     Integer;
begin
    command_byte_array[0] := 0x91;
    command_byte_array[1] := 0x13;
    command_byte_array[2] := 0x00;
    command_byte_array[2] := 0x00;
    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(1174, command_variant); 

    fptr.setParam(fptr.LIBFPTR_PARAM_COMMAND_BUFFER, command);
end;

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

uint lineLength = libfptr_get_param_int(fptr, 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;

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

double cashSum = libfptr_get_param_double(fptr, 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;

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

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

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;

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

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

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;

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

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

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;

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

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);

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;

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

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

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

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

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

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

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

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

Вызов метода

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:
    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;

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

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

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

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

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

libfptr_open(fptr);

fptr.open()

fptr.open();

fptr.open();

[fptr open];

fptr.open();

begin
    fptr.open;
end;

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

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

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;

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

libfptr_close(fptr);

fptr.close()

fptr.close();

fptr.close();

[fptr close];

fptr.close();

begin
    fptr.close;
end;

После настройки рабочего экземпляра можно подключиться к ККТ. Для этого требуется вызвать метод 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 shiftState         = 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 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 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(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)
shiftState      = 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)
isCashDrawerOpened      = fptr.getParamBool(IFptr.LIBFPTR_PARAM_CASHDRAWER_OPENED)
isPaperPresent          = fptr.getParamBool(IFptr.LIBFPTR_PARAM_RECEIPT_PAPER_PRESENT)
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 shiftState      = 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 isCashDrawerOpened      = fptr.getParamBool(IFptr.LIBFPTR_PARAM_CASHDRAWER_OPENED);
boolean isPaperPresent          = fptr.getParamBool(IFptr.LIBFPTR_PARAM_RECEIPT_PAPER_PRESENT);
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 shiftState      = 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 isCashDrawerOpened      = fptr.getParamBool(IFptr.LIBFPTR_PARAM_CASHDRAWER_OPENED);
boolean isPaperPresent          = fptr.getParamBool(IFptr.LIBFPTR_PARAM_RECEIPT_PAPER_PRESENT);
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 shiftState      = [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 isCashDrawerOpened      = [fptr getParamBool:LIBFPTR_PARAM_CASHDRAWER_OPENED];
bool isPaperPresent          = [fptr getParamBool:LIBFPTR_PARAM_RECEIPT_PAPER_PRESENT];
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 shiftState      = 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 isCashDrawerOpened      = fptr.getParamBool(Constants.LIBFPTR_PARAM_CASHDRAWER_OPENED);
bool isPaperPresent          = fptr.getParamBool(Constants.LIBFPTR_PARAM_RECEIPT_PAPER_PRESENT);
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;
    shiftState:       Longint;
    receiptType:      Longint;
    lineLength:       Longint;
    lineLengthPix:    Longint;

    receiptSum: Double;

    isFiscalDevice:          LongBool;
    isFiscalFN:              LongBool;
    isFNPresent:             LongBool;
    isCashDrawerOpened:      LongBool;
    isPaperPresent:          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);
    shiftState      := 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);
    isCashDrawerOpened      := fptr.getParamBool(fptr.LIBFPTR_PARAM_CASHDRAWER_OPENED);
    isPaperPresent          := fptr.getParamBool(fptr.LIBFPTR_PARAM_RECEIPT_PAPER_PRESENT);
    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;

Для запроса общей информации и статуса необходимо вызвать метод 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_SHIFT_STATE Состояние смены int
LIBFPTR_PARAM_CASHDRAWER_OPENED Денежный ящик открыт bool
LIBFPTR_PARAM_RECEIPT_PAPER_PRESENT Наличие бумаги 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_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 isCoverOpened          = (libfptr_get_param_bool(fptr, LIBFPTR_PARAM_COVER_OPENED) != 0);

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)
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 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 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 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 isCoverOpened           = fptr.getParamBool(Constants.LIBFPTR_PARAM_COVER_OPENED);

var
    isCashDrawerOpened:      LongBool;
    isPaperPresent:          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);
    isCoverOpened           := fptr.getParamBool(fptr.LIBFPTR_PARAM_COVER_OPENED);
end;

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

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

Параметр Описание Тип
LIBFPTR_PARAM_CASHDRAWER_OPENED Денежный ящик открыт bool
LIBFPTR_PARAM_RECEIPT_PAPER_PRESENT Наличие бумаги bool
LIBFPTR_PARAM_COVER_OPENED Крышка открыта bool

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

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

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(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;

Для запроса суммы наличности в денежном ящике необходимо вызвать метод 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(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;

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

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]);

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)

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);

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);

[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];

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);

var
    configurationVersion: 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);
end;

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

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(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;

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

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(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;

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

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(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;

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

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

Параметр Описание Тип
LIBFPTR_PARAM_UNIT_VERSION Версия модуля 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(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;

Для запроса параметров массива картинок необходимо вызвать метод 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(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;

Для запроса параметров картинки из памяти ККТ необходимо вызвать метод 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);

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)

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);

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);

[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];

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);

var
    entered: LongBool;
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);
end;

Для запроса состояни кода защиты необходимо вызвать метод 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_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(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;

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

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(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;

Для запроса суммы регистраций необходимо вызвать метод 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(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;

Для запроса суммы платежей необходимо вызвать метод 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(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;

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

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(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;

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

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(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;

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

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(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;

Для запроса суммы внесений или выплат необходимо вызвать метод 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(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;

Для запроса суммы выручки необходимо вызвать метод 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;
ibfptr_get_param_datetime(fptr, LIBFPTR_PARAM_DATE_TIME, &year, &month, &day, &hour, &minute, &second);

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
    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;

Для запроса текущих даты и времени в ККТ необходимо вызвать метод 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(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;

Для запроса состояния смены необходимо вызвать метод 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 type            = 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(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_RECEIPT_STATE)
fptr.queryData()

type            = 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 type           = 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 type           = 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 type               = [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 type           = 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
    type:           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;

    type            := 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;

Для запроса состояния чека необходимо вызвать метод 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(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;

Для запроса заводского номера ККТ необходимо вызвать метод 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(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;

Для запроса информации о модели ККТ необходимо вызвать метод 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(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;

Для запроса ширины чековой ленты необходимо вызвать метод 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(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;

Запрос сбрасываемого ресурса отрезчика

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(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;

Для запроса ресурса отрезчика необходимо вызвать метод 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(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;

Запрос постоянного ресурса ШД для шагов вперед

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(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;

Запрос сбрасываемого ресурса ШД для всех шагов

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(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;

Запрос сбрасываемого ресурса ШД для шагов вперед

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(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;

Для запроса ресурса шагового двигателя необходимо вызвать метод 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(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;

Запрос сбрасываемого ресурса ТПГ

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(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;

Для запроса ресурса ТПГ необходимо вызвать метод 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(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;

Для запроса суммы налога за смену необходимо вызвать метод 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(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;

Для запроса суммы налога за чек необходимо вызвать метод 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(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;

Запрос необнуляемой суммы по чекам прихода по оплатам наличными

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(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;

Для запроса необнуляемой суммы необходимо вызвать метод 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(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;

Для запроса количества чеков необходимо вызвать метод 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(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;

Запрос общего количества отмененных чеков

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(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;

Для запроса количества отмененных чеков с заданным типом необходимо вызвать метод 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(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;

Запрос общей суммы отмененных чеков

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(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;

Для запроса суммы отмененных чеков с заданным типом необходимо вызвать метод 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(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;

Для запроса состояния источника питания необходимо вызвать метод 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(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;

Для запроса температуры ТПГ необходимо вызвать метод 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);

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)

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);

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);

[fptr setParam:LIBFPTR_PARAM_DATA_TYPE, intParam: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];

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

bool noSerialNumber          = fptr.getParamBool(Constants.LIBFPTR_PARAM_NO_SERIAL_NUMBER);
bool rtcFault                = fptr.getParamBool(Constants.LIBFPTR_PARAM_RTC_FAULT);
bool settingsFault           = fptr.getParamBool(Constants.LIBFPTR_PARAM_SETTINGS_FAULT);
bool counterFault            = fptr.getParamBool(Constants.LIBFPTR_PARAM_COUNTERS_FAULT);
bool userMemoryFault         = fptr.getParamBool(Constants.LIBFPTR_PARAM_USER_MEMORY_FAULT);
bool serviceCountersFault    = fptr.getParamBool(Constants.LIBFPTR_PARAM_SERVICE_COUNTERS_FAULT);
bool attributesFault         = fptr.getParamBool(Constants.LIBFPTR_PARAM_ATTRIBUTES_FAULT);
bool fnFault                 = fptr.getParamBool(Constants.LIBFPTR_PARAM_FN_FAULT);
bool invalidFN               = fptr.getParamBool(Constants.LIBFPTR_PARAM_INVALID_FN);
bool hardFault               = fptr.getParamBool(Constants.LIBFPTR_PARAM_HARD_FAULT);
bool memoryManagerFault      = fptr.getParamBool(Constants.LIBFPTR_PARAM_MEMORY_MANAGER_FAULT);
bool scriptFault             = fptr.getParamBool(Constants.LIBFPTR_PARAM_SCRIPTS_FAULT);
bool waitForReboot           = fptr.getParamBool(Constants.LIBFPTR_PARAM_WAIT_FOR_REBOOT);

var
    noSerialNumber:         LongBool;
    rtcFault:               LongBool;
    settingsFault:          LongBool;
    counterFault:           LongBool;
    userMemoryFault:        LongBool;
    serviceCountersFault:   LongBool;
    attributesFault:        LongBool;
    fnFault:                LongBool;
    invalidFN:              LongBool;
    hardFault:              LongBool;
    memoryManagerFault:     LongBool;
    scriptFault:            LongBool;
    waitForReboot:          LongBool;
begin
    fptr.setParam(fptr.LIBFPTR_PARAM_DATA_TYPE, fptr.LIBFPTR_DT_FATAL_STATUS);
    fptr.queryData;

    noSerialNumber          := fptr.getParamBool(fptr.LIBFPTR_PARAM_NO_SERIAL_NUMBER);
    rtcFault                := fptr.getParamBool(fptr.LIBFPTR_PARAM_RTC_FAULT);
    settingsFault           := fptr.getParamBool(fptr.LIBFPTR_PARAM_SETTINGS_FAULT);
    counterFault            := fptr.getParamBool(fptr.LIBFPTR_PARAM_COUNTERS_FAULT);
    userMemoryFault         := fptr.getParamBool(fptr.LIBFPTR_PARAM_USER_MEMORY_FAULT);
    serviceCountersFault    := fptr.getParamBool(fptr.LIBFPTR_PARAM_SERVICE_COUNTERS_FAULT);
    attributesFault         := fptr.getParamBool(fptr.LIBFPTR_PARAM_ATTRIBUTES_FAULT);
    fnFault                 := fptr.getParamBool(fptr.LIBFPTR_PARAM_FN_FAULT);
    invalidFN               := fptr.getParamBool(fptr.LIBFPTR_PARAM_INVALID_FN);
    hardFault               := fptr.getParamBool(fptr.LIBFPTR_PARAM_HARD_FAULT);
    memoryManagerFault      := fptr.getParamBool(fptr.LIBFPTR_PARAM_MEMORY_MANAGER_FAULT);
    scriptFault             := fptr.getParamBool(fptr.LIBFPTR_PARAM_SCRIPTS_FAULT);
    waitForReboot           := fptr.getParamBool(fptr.LIBFPTR_PARAM_WAIT_FOR_REBOOT);
end;

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

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

Параметр Описание Тип
LIBFPTR_PARAM_NO_SERIAL_NUMBER Не введен ЗН ККТ bool
LIBFPTR_PARAM_RTC_FAULT Ошибка часов реального времени bool
LIBFPTR_PARAM_SETTINGS_FAULT Ошибка настроек bool
LIBFPTR_PARAM_COUNTERS_FAULT Ошибка счетчиков bool
LIBFPTR_PARAM_USER_MEMORY_FAULT Ошибка пользовательской памяти bool
LIBFPTR_PARAM_SERVICE_COUNTERS_FAULT Ошибка сервисных регистров bool
LIBFPTR_PARAM_ATTRIBUTES_FAULT Ошибка реквизитов bool
LIBFPTR_PARAM_FN_FAULT Фатальная ошибка ФН bool
LIBFPTR_PARAM_INVALID_FN Установлен ФН из другой ККТ bool
LIBFPTR_PARAM_HARD_FAULT Фатальная аппаратная ошибка bool
LIBFPTR_PARAM_MEMORY_MANAGER_FAULT Ошибка диспетчера памяти bool
LIBFPTR_PARAM_SCRIPTS_FAULT Скрипты повреждены или отсутствуют bool
LIBFPTR_PARAM_WAIT_FOR_REBOOT Требуется перезагрузка bool

MAC-адрес Ethernet

Запрос MAC-адреса Ethernet

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

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

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

mac = fptr.getParamString(IFptr.LIBFPTR_PARAM_MAC_ADDRESS)

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

String mac = fptr.getParamString(IFptr.LIBFPTR_PARAM_MAC_ADDRESS);

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

String mac = fptr.getParamString(IFptr.LIBFPTR_PARAM_MAC_ADDRESS);

[fptr setParam:LIBFPTR_PARAM_DATA_TYPE, intParam:LIBFPTR_DT_MAC_ADDRESS];
[fptr queryData];

NSString *mac = [fptr getParamString: LIBFPTR_PARAM_MAC_ADDRESS];

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

String mac = fptr.getParamString(Constants.LIBFPTR_DT_MAC_ADDRESS);

var
    uptime: String;
begin
    fptr.setParam(fptr.LIBFPTR_PARAM_DATA_TYPE, fptr.LIBFPTR_DT_MAC_ADDRESS);
    fptr.queryData;

    mac := fptr.getParamString(fptr.LIBFPTR_DT_MAC_ADDRESS);
end;

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

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

Параметр Описание Тип
LIBFPTR_PARAM_MAC_ADDRESS MAC-адрес string

Время работы ККТ

Запрос времени работы ККТ

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

uint uptime = libfptr_get_param_int(fptr, LIBFPTR_PARAM_DEVICE_UPTIME);

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

uptime = fptr.getParamInt(IFptr.LIBFPTR_PARAM_DEVICE_UPTIME)

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

long uptime = fptr.getParamInt(IFptr.LIBFPTR_PARAM_DEVICE_UPTIME);

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

long uptime = fptr.getParamInt(IFptr.LIBFPTR_PARAM_DEVICE_UPTIME);

[fptr setParam:LIBFPTR_PARAM_DATA_TYPE, intParam:LIBFPTR_DT_DEVICE_UPTIME];
[fptr queryData];

uint uptime = [fptr getParamInt: LIBFPTR_PARAM_DEVICE_UPTIME];

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

uint uptime = fptr.getParamInt(Constants.LIBFPTR_PARAM_DEVICE_UPTIME);

var
    uptime: Longint;
begin
    fptr.setParam(fptr.LIBFPTR_PARAM_DATA_TYPE, fptr.LIBFPTR_DT_DEVICE_UPTIME);
    fptr.queryData;

    uptime := fptr.getParamInt(fptr.LIBFPTR_PARAM_DEVICE_UPTIME);
end;

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

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

Параметр Описание Тип
LIBFPTR_PARAM_DEVICE_UPTIME Время работы ККТ, с. int

Суммы скидок и надбавок за смену

Запрос сумм скидок и надбавок за смену

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

double discountSum = libfptr_get_param_double(fptr, LIBFPTR_PARAM_DISCOUNT_SUM);
double surchargeSum = libfptr_get_param_double(fptr, LIBFPTR_PARAM_SURCHARGE_SUM);

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

discountSum = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_DISCOUNT_SUM)
surchargeSum = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_SURCHARGE_SUM)

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

double discountSum = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_DISCOUNT_SUM);
double surchargeSum = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_SURCHARGE_SUM);

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

double discountSum = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_DISCOUNT_SUM);
double surchargeSum = fptr.getParamDouble(IFptr.LIBFPTR_PARAM_SURCHARGE_SUM);

[fptr setParam:LIBFPTR_PARAM_DATA_TYPE, intParam:LIBFPTR_DT_DISCOUNT_AND_SURCHARGE_SUM];
[fptr queryData];

double discountSum = [fptr getParamDouble:LIBFPTR_PARAM_DISCOUNT_SUM];
double surchargeSum = [fptr getParamDouble:LIBFPTR_PARAM_SURCHARGE_SUM];

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

double discountSum = fptr.getParamDouble(Constants.LIBFPTR_PARAM_DISCOUNT_SUM);
double surchargeSum = fptr.getParamDouble(Constants.LIBFPTR_PARAM_SURCHARGE_SUM);

var
    discountSum: Double;
    surchargeSum: Double;
begin
    fptr.setParam(fptr.LIBFPTR_PARAM_DATA_TYPE, fptr.LIBFPTR_DT_DISCOUNT_AND_SURCHARGE_SUM);
    fptr.queryData;

    discountSum := fptr.getParamDouble(fptr.LIBFPTR_PARAM_DISCOUNT_SUM);
    surchargeSum := fptr.getParamDouble(fptr.LIBFPTR_PARAM_SURCHARGE_SUM);
end;

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

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

Параметр Описание Тип
LIBFPTR_PARAM_DISCOUNT_SUM Сумма скидок за смену double
LIBFPTR_PARAM_SURCHARGE_SUM Сумма надбавок за смену double

Код привязки к личному кабинету

Запрос кода привязки к ЛК

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

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

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

codeLK = fptr.getParamString(IFptr.LIBFPTR_PARAM_LK_USER_CODE)

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

String codeLK = fptr.getParamString(IFptr.LIBFPTR_PARAM_LK_USER_CODE);

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

String codeLK = fptr.getParamString(IFptr.LIBFPTR_PARAM_LK_USER_CODE);

[fptr setParam:LIBFPTR_PARAM_DATA_TYPE, intParam:LIBFPTR_DT_LK_USER_CODE];
[fptr queryData];

NSString *codeLK = [fptr getParamString: LIBFPTR_PARAM_LK_USER_CODE];

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

String codeLK = fptr.getParamString(Constants.LIBFPTR_PARAM_LK_USER_CODE);

var
    codeLK: String;
begin
    fptr.setParam(fptr.LIBFPTR_PARAM_DATA_TYPE, fptr.LIBFPTR_DT_LK_USER_CODE);
    fptr.queryData;

    codeLK := fptr.getParamString(fptr.LIBFPTR_PARAM_LK_USER_CODE);
end;

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

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

Параметр Описание Тип
LIBFPTR_PARAM_LK_USER_CODE Код привязки к ЛК string

Дата и время последнего успешного обмена с ОФД

Запрос даты и времени последнего успешного обмена с ОФД

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

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

fptr.setParam(IFptr.LIBFPTR_PARAM_DATA_TYPE, IFptr.LIBFPTR_DT_LAST_SENT_OFD_DOCUMENT_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_LAST_SENT_OFD_DOCUMENT_DATE_TIME);
fptr.queryData();

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

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

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

[fptr setParam:LIBFPTR_PARAM_DATA_TYPE, intParam:LIBFPTR_DT_LAST_SENT_OFD_DOCUMENT_DATE_TIME];
[fptr queryData];

NSDate *dateTime    = [fptr getParamDateTime:LIBFPTR_PARAM_DATE_TIME];

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

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

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

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

Для запроса даты и времени последнего успешного обмена с ОФД необходимо вызвать метод queryData() с типом запроса LIBFPTR_PARAM_DATA_TYPE равным LIBFPTR_DT_LAST_SENT_OFD_DOCUMENT_DATE_TIME.

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

Параметр Описание Тип
LIBFPTR_PARAM_DATE_TIME Дата и время последнего успешного обмена с ОФД datetime

Регистрация кассира

Регистрация кассира

libfptr_set_param_str(fptr, 1021, L"Кассир Иванов И.");
libfptr_set_param_str(fptr, 1203, L"123456789047");
libfptr_operator_login(fptr); 

fptr.setParam(1021, "Кассир Иванов И.")
fptr.setParam(1203, "123456789047")
fptr.operatorLogin()

fptr.setParam(1021, "Кассир Иванов И.");
fptr.setParam(1203, "123456789047");
fptr.operatorLogin();

fptr.setParam(1021, "Кассир Иванов И.");
fptr.setParam(1203, "123456789047");
fptr.operatorLogin();

[fptr setParam:1021, NSStringParam:@"Кассир Иванов И."];
[fptr setParam:1203, NSStringParam:@"123456789047"];
[fptr operatorLogin];

fptr.setParam(1021, "Кассир Иванов И.");
fptr.setParam(1203, "123456789047");
fptr.operatorLogin();

begin
    fptr.setParam(1021, 'Кассир Иванов И.');
    fptr.setParam(1203, '123456789047');
    fptr.operatorLogin;
end;

Для регистрации кассира необходимо вызвать метод operatorLogin().

Операции со сменой

Открыть смену

Открытие смены

libfptr_set_param_str(fptr, 1021, L"Кассир Иванов И.");
libfptr_set_param_str(fptr, 1203, L"123456789047");
libfptr_operator_login(fptr);

libfptr_open_shift(fptr);

libfptr_check_document_closed();
// ...

fptr.setParam(1021, "Кассир Иванов И.")
fptr.setParam(1203, "123456789047")
fptr.operatorLogin()

fptr.openShift()

fptr.checkDocumentClosed()
# ...

fptr.setParam(1021, "Кассир Иванов И.");
fptr.setParam(1203, "123456789047");
fptr.operatorLogin();

fptr.openShift();

fptr.checkDocumentClosed();
// ...

fptr.setParam(1021, "Кассир Иванов И.");
fptr.setParam(1203, "123456789047");
fptr.operatorLogin();

fptr.openShift();

fptr.checkDocumentClosed();
// ...

[fptr setParam:1021, NSString:@"Кассир Иванов И."];
[fptr setParam:1203, NSString:@"123456789047"];
[fptr operatorLogin];

[fptr openShift];

[fptr checkDocumentClosed];
// ...

fptr.setParam(1021, "Кассир Иванов И.");
fptr.setParam(1203, "123456789047");
fptr.operatorLogin();

fptr.openShift();

fptr.checkDocumentClosed();
// ...

begin
    fptr.setParam(1021, 'Кассир Иванов И.');
    fptr.setParam(1203, '123456789047');
    fptr.operatorLogin;

    fptr.openShift;

    fptr.checkDocumentClosed;
    // ...
end;

Для открытия смены необходимо вызвать метод openShift(). Метод возвращает ошибку, если смена уже открыта. Открывать смену необязательно, т.к. она будет открыта первой фискальной операцией автоматически.

Закрыть смену

Закрытие смены

libfptr_set_param_str(fptr, 1021, L"Кассир Иванов И.");
libfptr_set_param_str(fptr, 1203, L"123456789047");
libfptr_operator_login(fptr);

libfptr_set_param_int(fptr, LIBFPTR_PARAM_REPORT_TYPE, LIBFPTR_RT_CLOSE_SHIFT);
libfptr_report(fptr);

libfptr_check_document_closed();
// ...

fptr.setParam(1021, "Кассир Иванов И.")
fptr.setParam(1203, "123456789047")
fptr.operatorLogin()

fptr.setParam(IFptr.LIBFPTR_PARAM_REPORT_TYPE, IFptr.LIBFPTR_RT_CLOSE_SHIFT)
fptr.report()

fptr.checkDocumentClosed()
# ...

fptr.setParam(1021, "Кассир Иванов И.");
fptr.setParam(1203, "123456789047");
fptr.operatorLogin();

fptr.setParam(IFptr.LIBFPTR_PARAM_REPORT_TYPE, IFptr.LIBFPTR_RT_CLOSE_SHIFT);
fptr.report();

fptr.checkDocumentClosed();
// ...

fptr.setParam(1021, "Кассир Иванов И.");
fptr.setParam(1203, "123456789047");
fptr.operatorLogin();

fptr.setParam(IFptr.LIBFPTR_PARAM_REPORT_TYPE, IFptr.LIBFPTR_RT_CLOSE_SHIFT);
fptr.report();

fptr.checkDocumentClosed();
// ...

[fptr setParam:1021, NSString:@"Кассир Иванов И."];
[fptr setParam:1203, NSString:@"123456789047"];
[fptr operatorLogin];

[fptr setParam:LIBFPTR_PARAM_REPORT_TYPE, intParam:LIBFPTR_RT_CLOSE_SHIFT];
[fptr report];

[fptr checkDocumentClosed];
// ...

fptr.setParam(1021, "Кассир Иванов И.");
fptr.setParam(1203, "123456789047");
fptr.operatorLogin();

fptr.setParam(Constants.LIBFPTR_PARAM_REPORT_TYPE, Constants.LIBFPTR_RT_CLOSE_SHIFT);
fptr.report();

fptr.checkDocumentClosed();
// ...

begin
    fptr.setParam(1021, 'Кассир Иванов И.');
    fptr.setParam(1203, '123456789047');
    fptr.operatorLogin;

    fptr.setParam(fptr.LIBFPTR_PARAM_REPORT_TYPE, fptr.LIBFPTR_RT_CLOSE_SHIFT);
    fptr.report;

    fptr.checkDocumentClosed;
    // ...
end;

Для закрытия смены требуется вызвать метод report() с типом отчета LIBFPTR_PARAM_REPORT_TYPE равным LIBFPTR_RT_CLOSE_SHIFT Автоматически может напечататься так же и Z-отчет.

Операции с чеком

Общий алгоритм формирования чека

Формирование чека состоит из следующих операций:

Формирование чека коррекции (ФФД 1.0, 1.05) состоит из следующих операций:

Открыть чек

Открытие печатного чека

libfptr_set_param_str(fptr, 1021, L"Кассир Иванов И.");
libfptr_set_param_str(fptr, 1203, L"123456789047");
libfptr_operator_login(fptr); 

libfptr_set_param_int(fptr, LIBFPTR_PARAM_RECEIPT_TYPE, LIBFPTR_RT_SELL);
libfptr_open_receipt(fptr);

fptr.setParam(1021, "Кассир Иванов И.")
fptr.setParam(1203, "123456789047")
fptr.operatorLogin()

fptr.setParam(IFptr.LIBFPTR_PARAM_RECEIPT_TYPE, IFptr.LIBFPTR_RT_SELL)
fptr.openReceipt()

fptr.setParam(1021, "Кассир Иванов И.");
fptr.setParam(1203, "123456789047");
fptr.operatorLogin();

fptr.setParam(IFptr.LIBFPTR_PARAM_RECEIPT_TYPE, IFptr.LIBFPTR_RT_SELL);
fptr.openReceipt();

fptr.setParam(1021, "Кассир Иванов И.");
fptr.setParam(1203, "123456789047");
fptr.operatorLogin();

fptr.setParam(IFptr.LIBFPTR_PARAM_RECEIPT_TYPE, IFptr.LIBFPTR_RT_SELL);
fptr.openReceipt();

[fptr setParam:1021, NSStringParam:@"Кассир Иванов И."];
[fptr setParam:1203, NSStringParam:@"123456789047"];
[fptr operatorLogin];

[fptr setParam:LIBFPTR_PARAM_RECEIPT_TYPE, intParam:LIBFPTR_RT_SELL];
[fptr openReceipt]

fptr.setParam(1021, "Кассир Иванов И.");
fptr.setParam(1203, "123456789047");
fptr.operatorLogin();

fptr.setParam(Constants.LIBFPTR_PARAM_RECEIPT_TYPE, Constants.LIBFPTR_RT_SELL);
fptr.openReceipt();

begin
    fptr.setParam(1021, 'Кассир Иванов И.');
    fptr.setParam(1203, '123456789047');
    fptr.operatorLogin;

    fptr.setParam(fptr.LIBFPTR_PARAM_RECEIPT_TYPE, fptr.LIBFPTR_RT_SELL);
    fptr.openReceipt;
end;

Открытие электронного чека

libfptr_set_param_int(fptr, LIBFPTR_PARAM_RECEIPT_TYPE, LIBFPTR_RT_SELL);
libfptr_set_param_bool(fptr, LIBFPTR_PARAM_RECEIPT_ELECTRONICALLY, true);
libfptr_set_param_str(fptr, 1008, L"client@mail.ru");
libfptr_open_receipt(fptr);

fptr.setParam(IFptr.LIBFPTR_PARAM_RECEIPT_TYPE, IFptr.LIBFPTR_RT_SELL)
fptr.setParam(IFptr.LIBFPTR_PARAM_RECEIPT_ELECTRONICALLY, True)
fptr.setParam(1008, "client@mail.ru")
fptr.openReceipt()

fptr.setParam(IFptr.LIBFPTR_PARAM_RECEIPT_TYPE, IFptr.LIBFPTR_RT_SELL);
fptr.setParam(IFptr.LIBFPTR_PARAM_RECEIPT_ELECTRONICALLY, true);
fptr.setParam(1008, "client@mail.ru");
fptr.openReceipt();

fptr.setParam(IFptr.LIBFPTR_PARAM_RECEIPT_TYPE, IFptr.LIBFPTR_RT_SELL);
fptr.setParam(IFptr.LIBFPTR_PARAM_RECEIPT_ELECTRONICALLY, true);
fptr.setParam(1008, "client@mail.ru");
fptr.openReceipt();

[fptr setParam:LIBFPTR_PARAM_RECEIPT_TYPE, intParam:LIBFPTR_RT_SELL];
[fptr setParam:LIBFPTR_PARAM_RECEIPT_ELECTRONICALLY, boolParam:true];
[fptr setParam:1008, NSStringParam:@"client@mail.ru"];
[fptr openReceipt]

fptr.setParam(Constants.LIBFPTR_PARAM_RECEIPT_TYPE, Constants.LIBFPTR_RT_SELL);
fptr.setParam(Constants.LIBFPTR_PARAM_RECEIPT_ELECTRONICALLY, true);
fptr.setParam(1008, "client@mail.ru");
fptr.openReceipt();

begin
    fptr.setParam(fptr.LIBFPTR_PARAM_RECEIPT_TYPE, fptr.LIBFPTR_RT_SELL);
    fptr.setParam(fptr.LIBFPTR_PARAM_RECEIPT_ELECTRONICALLY, True);
    fptr.setParam(1008, 'client@mail.ru');
    fptr.openReceipt;
end;

Открытие чека коррекции прихода (ФФД 1.0 и ФФД 1.05)

libfptr_set_param_str(fptr, 1177, L"Документ основания коррекции");
libfptr_set_param_datetime(fptr, 1178, 2018, 1, 2, 0, 0, 0);
libfptr_set_param_str(fptr, 1179, L"№1234");
libfptr_util_form_tlv(fptr);

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

libfptr_set_param_int(fptr, LIBFPTR_PARAM_RECEIPT_TYPE, LIBFPTR_RT_SELL_CORRECTION);
libfptr_set_param_int(fptr, 1173, 1);
libfptr_set_param_bytearray(fptr, 1174, &correctionInfo[0], correctionInfo.size());
libfptr_open_receipt(fptr);

fptr.setParam(1177, "Документ основания коррекции")
fptr.setParam(1178, datetime.datetime(2018, 1, 2))
fptr.setParam(1179, "№1234")
fptr.utilFormTlv()

correctionInfo = fptr.getParamByteArray(IFptr.LIBFPTR_PARAM_TAG_VALUE)

fptr.setParam(IFptr.LIBFPTR_PARAM_RECEIPT_TYPE, IFptr.LIBFPTR_RT_SELL_CORRECTION)
fptr.setParam(1173, 1)
fptr.setParam(1174, correctionInfo)
fptr.openReceipt()

Calendar c = Calendar.getInstance();
c.set(2018, 1, 2);
fptr.setParam(1177, "Документ основания коррекции");
fptr.setParam(1178, c.getTime());
fptr.setParam(1179, "№1234");
fptr.utilFormTlv();
byte[] correctionInfo = fptr.getParamByteArray(IFptr.LIBFPTR_PARAM_TAG_VALUE);

fptr.setParam(IFptr.LIBFPTR_PARAM_RECEIPT_TYPE, IFptr.LIBFPTR_RT_SELL_CORRECTION);
fptr.setParam(1173, 1);
fptr.setParam(1174, correctionInfo);
fptr.openReceipt();

Calendar c = Calendar.getInstance();
c.set(2018, 1, 2);
fptr.setParam(1177, "Документ основания коррекции");
fptr.setParam(1178, c.getTime());
fptr.setParam(1179, "№1234");
fptr.utilFormTlv();
byte[] correctionInfo = fptr.getParamByteArray(IFptr.LIBFPTR_PARAM_TAG_VALUE);

fptr.setParam(IFptr.LIBFPTR_PARAM_RECEIPT_TYPE, IFptr.LIBFPTR_RT_SELL_CORRECTION);
fptr.setParam(1173, 1);
fptr.setParam(1174, correctionInfo);
fptr.openReceipt();

NSCalendar *calendar = [NSCalendar currentCalendar];
NSDateComponents *components = [[NSDateComponents alloc] init];
[components setYear:[2018 intValue]];
[components setMonth:[1 intValue]];
[components setDay:[2 intValue]];

[fptr setParam:1177, NSStringParam:@"Документ основания коррекции"];
[fptr setParam:1178, NSDateParam:[calendar dateFromComponents:components]];
[fptr setParam:1179, NSStringParam:@"№1234"];
[fptr utilFormTlv];
NSData *correctionInfo = [fptr getParamByteArray:LIBFPTR_PARAM_TAG_VALUE];

[fptr setParam:LIBFPTR_PARAM_RECEIPT_TYPE, intParam:LIBFPTR_RT_SELL_CORRECTION];
[fptr setParam:1173, intParam:1];
[fptr setParam:1174, NSDataParam:correctionInfo];
[fptr openReceipt];

DateTime date = new DateTime(2018, 1, 2);
fptr.setParam(1177, "Документ основания коррекции");
fptr.setParam(1178, date);
fptr.setParam(1179, "№1234");
fptr.utilFormTlv();
byte[] correctionInfo = fptr.getParamByteArray(Constants.LIBFPTR_PARAM_TAG_VALUE);

fptr.setParam(Constants.LIBFPTR_PARAM_RECEIPT_TYPE, Constants.LIBFPTR_RT_SELL_CORRECTION);
fptr.setParam(1173, 1);
fptr.setParam(1174, correctionInfo);
fptr.openReceipt();

var
    date: TDateTime;
    correctionInfo: Variant;
begin
    date := StrToDate('02.01.2018');
    fptr.setParam(1177, 'Документ основания коррекции');
    fptr.setParam(1178, date);
    fptr.setParam(1179, '№1234');
    fptr.utilFormTlv;
    correctionInfo := fptr.getParamByteArray(fptr.LIBFPTR_PARAM_TAG_VALUE);

    fptr.setParam(fptr.LIBFPTR_PARAM_RECEIPT_TYPE, fptr.LIBFPTR_RT_SELL_CORRECTION);
    fptr.setParam(1173, 1);
    fptr.setParam(1174, correctionInfo);
    fptr.openReceipt;
end;

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

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

Чтобы чек не печатался (электронный чек), нужно установить параметру LIBFPTR_PARAM_RECEIPT_ELECTRONICALLY значение true и передать реквизит 1008 (электронный адрес или телефон получателя).

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

Реквизит Описание Тип
1008 Электронный адрес / телефон получателя string
1227 Наименование получателя string
1228 ИНН получателя string
1117 Электронный адрес отправителя чека string
1055 Применяемая система налогообложения (СНО) int
1187 Место расчета string
1060 Адрес сайта ФНС string
1057 Признак агента int
1171 Телефон поставщика string
1044 Операция платежного агента string
1073 Телефон платежного агента (может повторяться несколько раз) string
1005 Адрес оператора перевода string
1016 ИНН оператора перевода string
1026 Наименование оператора перевода string
1075 Телефон оператора перевода (может повторяться несколько раз) string
1074 Телефон оператора по приему платежей (может повторяться несколько раз) string
1084 Дополнительный реквизит пользователя bytearray
1192 Дополнительный реквизит чека (БСО) string

Реквизит 1084 составной и состоит из следующих реквизитов:

Реквизит Описание Тип
1085 Наименование дополнительного реквизита пользователя string
1086 Значение дополнительного реквизита пользователя string

Реквизит 1055 может принимать следующие значения:

Реквизит 1057 может принимать следующие значения:

Для чеков коррекций допустимы следующие реквизиты:

Реквизит Описание Тип
1055 Применяемая система налогообложения int
1173 Тип коррекции int
1174 Основание для коррекции bytearray

Реквизит 1174 составной и состоит из следующих реквизитов:

Реквизит Описание Тип
1177 Наименование основания для коррекции string
1178 Дата документа основания коррекции datetime
1179 Номер документа основания коррекции string

Отменить чек

Отмена чека

libfptr_cancel_receipt(fptr);

fptr.cancelReceipt()

fptr.cancelReceipt();

fptr.cancelReceipt();

[fptr cancelReceipt]

fptr.cancelReceipt();

begin
    fptr.cancelReceipt;
end;

Для отмены чека требуется вызвать метод cancelReceipt().

Зарегистрировать позицию

Регистрация позиции без указания суммы налога

libfptr_set_param_str(fptr, LIBFPTR_PARAM_COMMODITY_NAME, L"Товар");
libfptr_set_param_double(fptr, LIBFPTR_PARAM_PRICE, 100);
libfptr_set_param_double(fptr, LIBFPTR_PARAM_QUANTITY, 5.15);
libfptr_set_param_int(fptr, LIBFPTR_PARAM_TAX_TYPE, LIBFPTR_TAX_VAT0);
libfptr_registration(fptr);

fptr.setParam(IFptr.LIBFPTR_PARAM_COMMODITY_NAME, "Товар")
fptr.setParam(IFptr.LIBFPTR_PARAM_PRICE, 100)
fptr.setParam(IFptr.LIBFPTR_PARAM_QUANTITY, 5.15)
fptr.setParam(IFptr.LIBFPTR_PARAM_TAX_TYPE, IFptr.LIBFPTR_TAX_VAT0)
fptr.registration()

fptr.setParam(IFptr.LIBFPTR_PARAM_COMMODITY_NAME, "Товар");
fptr.setParam(IFptr.LIBFPTR_PARAM_PRICE, 100);
fptr.setParam(IFptr.LIBFPTR_PARAM_QUANTITY, 5.15);
fptr.setParam(IFptr.LIBFPTR_PARAM_TAX_TYPE, IFptr.LIBFPTR_TAX_VAT0);
fptr.registration();

fptr.setParam(IFptr.LIBFPTR_PARAM_COMMODITY_NAME, "Товар");
fptr.setParam(IFptr.LIBFPTR_PARAM_PRICE, 100);
fptr.setParam(IFptr.LIBFPTR_PARAM_QUANTITY, 5.15);
fptr.setParam(IFptr.LIBFPTR_PARAM_TAX_TYPE, IFptr.LIBFPTR_TAX_VAT0);
fptr.registration();

[fptr setParam:LIBFPTR_PARAM_COMMODITY_NAME, NSStringParam:@"Товар"];
[fptr setParam:LIBFPTR_PARAM_PRICE, doubleParam:100];
[fptr setParam:LIBFPTR_PARAM_QUANTITY, doubleParam:5.15];
[fptr setParam:LIBFPTR_PARAM_TAX_TYPE, intParam:LIBFPTR_TAX_VAT0];
[fptr registration]

fptr.setParam(Constants.LIBFPTR_PARAM_COMMODITY_NAME, "Товар");
fptr.setParam(Constants.LIBFPTR_PARAM_PRICE, 100);
fptr.setParam(Constants.LIBFPTR_PARAM_QUANTITY, 5.15);
fptr.setParam(Constants.LIBFPTR_PARAM_TAX_TYPE, Constants.LIBFPTR_TAX_VAT10);
fptr.registration();

begin
    fptr.setParam(fptr.LIBFPTR_PARAM_COMMODITY_NAME, 'Товар');
    fptr.setParam(fptr.LIBFPTR_PARAM_PRICE, 100);
    fptr.setParam(fptr.LIBFPTR_PARAM_QUANTITY, 5.15);
    fptr.setParam(fptr.LIBFPTR_PARAM_TAX_TYPE, fptr.LIBFPTR_TAX_VAT0);
    fptr.registration;
end;

Регистрация позиции с указанием суммы налога

libfptr_set_param_str(fptr, LIBFPTR_PARAM_COMMODITY_NAME, L"Товар");
libfptr_set_param_double(fptr, LIBFPTR_PARAM_PRICE, 100);
libfptr_set_param_double(fptr, LIBFPTR_PARAM_QUANTITY, 5.15);
libfptr_set_param_int(fptr, LIBFPTR_PARAM_TAX_TYPE, LIBFPTR_TAX_VAT10);
libfptr_set_param_double(fptr, LIBFPTR_PARAM_TAX_SUM, 51.5);
libfptr_registration(fptr);

fptr.setParam(IFptr.LIBFPTR_PARAM_COMMODITY_NAME, "Товар")
fptr.setParam(IFptr.LIBFPTR_PARAM_PRICE, 100)
fptr.setParam(IFptr.LIBFPTR_PARAM_QUANTITY, 5.15)
fptr.setParam(IFptr.LIBFPTR_PARAM_TAX_TYPE, IFptr.LIBFPTR_TAX_VAT10)
fptr.setParam(IFptr.LIBFPTR_PARAM_TAX_SUM, 51.5)
fptr.registration()

fptr.setParam(IFptr.LIBFPTR_PARAM_COMMODITY_NAME, "Товар");
fptr.setParam(IFptr.LIBFPTR_PARAM_PRICE, 100);
fptr.setParam(IFptr.LIBFPTR_PARAM_QUANTITY, 5.15);
fptr.setParam(IFptr.LIBFPTR_PARAM_TAX_TYPE, IFptr.LIBFPTR_TAX_VAT10);
fptr.setParam(IFptr.LIBFPTR_PARAM_TAX_SUM, 51.5);
fptr.registration();

fptr.setParam(IFptr.LIBFPTR_PARAM_COMMODITY_NAME, "Товар");
fptr.setParam(IFptr.LIBFPTR_PARAM_PRICE, 100);
fptr.setParam(IFptr.LIBFPTR_PARAM_QUANTITY, 5.15);
fptr.setParam(IFptr.LIBFPTR_PARAM_TAX_TYPE, IFptr.LIBFPTR_TAX_VAT10);
fptr.setParam(IFptr.LIBFPTR_PARAM_TAX_SUM, 51.5);
fptr.registration();

[fptr setParam:LIBFPTR_PARAM_COMMODITY_NAME, NSStringParam:@"Товар"];
[fptr setParam:LIBFPTR_PARAM_PRICE, doubleParam:100];
[fptr setParam:LIBFPTR_PARAM_QUANTITY, doubleParam:5.15];
[fptr setParam:LIBFPTR_PARAM_TAX_TYPE, intParam:LIBFPTR_TAX_VAT10];
[fptr setParam:LIBFPTR_PARAM_TAX_SUM, doubleParam:51.5];
[fptr registration]

fptr.setParam(Constants.LIBFPTR_PARAM_COMMODITY_NAME, "Товар");
fptr.setParam(Constants.LIBFPTR_PARAM_PRICE, 100);
fptr.setParam(Constants.LIBFPTR_PARAM_QUANTITY, 5.15);
fptr.setParam(Constants.LIBFPTR_PARAM_TAX_TYPE, Constants.LIBFPTR_TAX_VAT10);
fptr.setParam(Constants.LIBFPTR_PARAM_TAX_SUM, 51.5);
fptr.registration();

begin
    fptr.setParam(fptr.LIBFPTR_PARAM_COMMODITY_NAME, 'Товар');
    fptr.setParam(fptr.LIBFPTR_PARAM_PRICE, 100);
    fptr.setParam(fptr.LIBFPTR_PARAM_QUANTITY, 5.15);
    fptr.setParam(fptr.LIBFPTR_PARAM_TAX_TYPE, fptr.LIBFPTR_TAX_VAT0);
    fptr.setParam(fptr.LIBFPTR_PARAM_TAX_SUM, 51.5);
    fptr.registration;
end;

Регистрация позиции без расчета суммы налога

libfptr_set_param_str(fptr, LIBFPTR_PARAM_COMMODITY_NAME, L"Товар");
libfptr_set_param_double(fptr, LIBFPTR_PARAM_PRICE, 100);
libfptr_set_param_double(fptr, LIBFPTR_PARAM_QUANTITY, 5.15);
libfptr_set_param_int(fptr, LIBFPTR_PARAM_TAX_TYPE, LIBFPTR_TAX_VAT18);
libfptr_set_param_int(fptr, LIBFPTR_PARAM_USE_ONLY_TAX_TYPE, true);
libfptr_registration(fptr);

// ...

libfptr_set_param_int(fptr, LIBFPTR_PARAM_TAX_TYPE, LIBFPTR_TAX_VAT18);
libfptr_set_param_double(fptr, LIBFPTR_PARAM_TAX_SUM, 78.56);
libfptr_receipt_tax(fptr);

fptr.setParam(IFptr.LIBFPTR_PARAM_COMMODITY_NAME, "Товар")
fptr.setParam(IFptr.LIBFPTR_PARAM_PRICE, 100)
fptr.setParam(IFptr.LIBFPTR_PARAM_QUANTITY, 5.15)
fptr.setParam(IFptr.LIBFPTR_PARAM_TAX_TYPE, IFptr.LIBFPTR_TAX_VAT0)
fptr.setParam(IFptr.LIBFPTR_PARAM_USE_ONLY_TAX_TYPE, True)
fptr.registration()

# ...

fptr.setParam(IFptr.LIBFPTR_PARAM_TAX_TYPE, IFptr.LIBFPTR_TAX_VAT18)
fptr.setParam(IFptr.LIBFPTR_PARAM_TAX_SUM, 78.56)
fptr.receiptTax()

fptr.setParam(IFptr.LIBFPTR_PARAM_COMMODITY_NAME, "Товар");
fptr.setParam(IFptr.LIBFPTR_PARAM_PRICE, 100);
fptr.setParam(IFptr.LIBFPTR_PARAM_QUANTITY, 5.15);
fptr.setParam(IFptr.LIBFPTR_PARAM_TAX_TYPE, IFptr.LIBFPTR_TAX_VAT0);
fptr.setParam(IFptr.LIBFPTR_PARAM_USE_ONLY_TAX_TYPE, true);
fptr.registration();

// ...

fptr.setParam(IFptr.LIBFPTR_PARAM_TAX_TYPE, IFptr.LIBFPTR_TAX_VAT18);
fptr.setParam(IFptr.LIBFPTR_PARAM_TAX_SUM, 78.56);
fptr.receiptTax();

fptr.setParam(IFptr.LIBFPTR_PARAM_COMMODITY_NAME, "Товар");
fptr.setParam(IFptr.LIBFPTR_PARAM_PRICE, 100);
fptr.setParam(IFptr.LIBFPTR_PARAM_QUANTITY, 5.15);
fptr.setParam(IFptr.LIBFPTR_PARAM_TAX_TYPE, IFptr.LIBFPTR_TAX_VAT0);
fptr.setParam(IFptr.LIBFPTR_PARAM_USE_ONLY_TAX_TYPE, true);
fptr.registration();

// ...

fptr.setParam(IFptr.LIBFPTR_PARAM_TAX_TYPE, IFptr.LIBFPTR_TAX_VAT18);
fptr.setParam(IFptr.LIBFPTR_PARAM_TAX_SUM, 78.56);
fptr.receiptTax();

[fptr setParam:LIBFPTR_PARAM_COMMODITY_NAME, NSStringParam:@"Товар"];
[fptr setParam:LIBFPTR_PARAM_PRICE, doubleParam:100];
[fptr setParam:LIBFPTR_PARAM_QUANTITY, doubleParam:5.15];
[fptr setParam:LIBFPTR_PARAM_TAX_TYPE, intParam:LIBFPTR_TAX_VAT0];
[fptr setParam:LIBFPTR_PARAM_USE_ONLY_TAX_TYPE, boolParam:true];
[fptr registration]

// ...

[fptr setParam:LIBFPTR_PARAM_TAX_TYPE, intParam:LIBFPTR_TAX_VAT18];
[fptr setParam:LIBFPTR_PARAM_TAX_SUM, doubleParam:78.56];
[fptr receiptTax]

fptr.setParam(Constants.LIBFPTR_PARAM_COMMODITY_NAME, "Товар");
fptr.setParam(Constants.LIBFPTR_PARAM_PRICE, 100);
fptr.setParam(Constants.LIBFPTR_PARAM_QUANTITY, 5.15);
fptr.setParam(Constants.LIBFPTR_PARAM_TAX_TYPE, Constants.LIBFPTR_TAX_VAT0);
fptr.setParam(Constants.LIBFPTR_PARAM_USE_ONLY_TAX_TYPE, true);
fptr.registration();

// ...

fptr.setParam(Constants.LIBFPTR_PARAM_TAX_TYPE, Constants.LIBFPTR_TAX_VAT18);
fptr.setParam(Constants.LIBFPTR_PARAM_TAX_SUM, 78.56);
fptr.receiptTax();

begin
    fptr.setParam(fptr.LIBFPTR_PARAM_COMMODITY_NAME, 'Товар');
    fptr.setParam(fptr.LIBFPTR_PARAM_PRICE, 100);
    fptr.setParam(fptr.LIBFPTR_PARAM_QUANTITY, 5.15);
    fptr.setParam(fptr.LIBFPTR_PARAM_TAX_TYPE, fptr.LIBFPTR_TAX_VAT0);
    fptr.setParam(fptr.LIBFPTR_PARAM_USE_ONLY_TAX_TYPE, True);
    fptr.registration;

    // ...

    fptr.setParam(fptr.LIBFPTR_PARAM_TAX_TYPE, fptr.LIBFPTR_TAX_VAT18);
    fptr.setParam(fptr.LIBFPTR_PARAM_TAX_SUM, 78.56);
    fptr.receiptTax;
end;

Регистрация позиции с агентом и поставщиком

libfptr_set_param_str(fptr, 1005, L"Улица Свободы, д.1");
libfptr_set_param_str(fptr, 1016, L"123456789047");
libfptr_set_param_str(fptr, 1026, L"ООО Оператор");
libfptr_set_param_str(fptr, 1075, L"+79161234567");
libfptr_set_param_str(fptr, 1075, L"+79169876543");
libfptr_util_form_tlv(fptr);

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

libfptr_set_param_str(fptr, 1171, L"+79113456789");
libfptr_set_param_str(fptr, 1225, L"ООО Поставщик");
libfptr_util_form_tlv(fptr);

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

libfptr_set_param_str(fptr, LIBFPTR_PARAM_COMMODITY_NAME, L"Товар");
libfptr_set_param_double(fptr, LIBFPTR_PARAM_PRICE, 100);
libfptr_set_param_double(fptr, LIBFPTR_PARAM_QUANTITY, 5.15);
libfptr_set_param_int(fptr, LIBFPTR_PARAM_TAX_TYPE, LIBFPTR_TAX_VAT18);
libfptr_set_param_int(fptr, 1222, LIBFPTR_AT_ANOTHER);
libfptr_set_param_bytearray(fptr, 1223, &agentInfo[0]. agentInfo.size());
libfptr_set_param_str(fptr, 1226, L"123456789047");
libfptr_set_param_bytearray(fptr, 1224, &suplierInfo[0]. suplierInfo.size());
libfptr_registration(fptr);

fptr.setParam(1005, "Улица Свободы, д.1")
fptr.setParam(1016, "123456789047")
fptr.setParam(1026, "ООО Оператор")
fptr.setParam(1075, "+79161234567")
fptr.setParam(1075, "+79169876543")
fptr.utilFormTlv()
agentInfo = fptr.getParamByteArray(IFptr.LIBFPTR_PARAM_TAG_VALUE)

fptr.setParam(1171, "+79113456789")
fptr.setParam(1225, "ООО Поставщик")
fptr.utilFormTlv()
suplierInfo = fptr.getParamByteArray(IFptr.LIBFPTR_PARAM_TAG_VALUE)

fptr.setParam(IFptr.LIBFPTR_PARAM_COMMODITY_NAME, "Товар")
fptr.setParam(IFptr.LIBFPTR_PARAM_PRICE, 100)
fptr.setParam(IFptr.LIBFPTR_PARAM_QUANTITY, 5.15)
fptr.setParam(IFptr.LIBFPTR_PARAM_TAX_TYPE, IFptr.LIBFPTR_TAX_VAT18)
fptr.setParam(1222, IFptr.LIBFPTR_AT_ANOTHER)
fptr.setParam(1223, agentInfo)
fptr.setParam(1226, "123456789047")
fptr.setParam(1224, suplierInfo)
fptr.registration()

fptr.setParam(1005, "Улица Свободы, д.1");
fptr.setParam(1016, "123456789047");
fptr.setParam(1026, "ООО Оператор");
fptr.setParam(1075, "+79161234567");
fptr.setParam(1075, "+79169876543");
fptr.utilFormTlv();
byte[] agentInfo = fptr.getParamByteArray(IFptr.LIBFPTR_PARAM_TAG_VALUE);

fptr.setParam(1171, "+79113456789");
fptr.setParam(1225, "ООО Поставщик");
fptr.utilFormTlv();
byte[] suplierInfo = fptr.getParamByteArray(IFptr.LIBFPTR_PARAM_TAG_VALUE);

fptr.setParam(IFptr.LIBFPTR_PARAM_COMMODITY_NAME, "Товар");
fptr.setParam(IFptr.LIBFPTR_PARAM_PRICE, 100);
fptr.setParam(IFptr.LIBFPTR_PARAM_QUANTITY, 5.15);
fptr.setParam(IFptr.LIBFPTR_PARAM_TAX_TYPE, IFptr.LIBFPTR_TAX_VAT18);
fptr.setParam(1222, IFptr.LIBFPTR_AT_ANOTHER);
fptr.setParam(1223, agentInfo);
fptr.setParam(1226, "123456789047");
fptr.setParam(1224, suplierInfo);
fptr.registration();

fptr.setParam(1005, "Улица Свободы, д.1");
fptr.setParam(1016, "123456789047");
fptr.setParam(1026, "ООО Оператор");
fptr.setParam(1075, "+79161234567");
fptr.setParam(1075, "+79169876543");
fptr.utilFormTlv();
byte[] agentInfo = fptr.getParamByteArray(IFptr.LIBFPTR_PARAM_TAG_VALUE);

fptr.setParam(1171, "+79113456789");
fptr.setParam(1225, "ООО Поставщик");
fptr.utilFormTlv();
byte[] suplierInfo = fptr.getParamByteArray(IFptr.LIBFPTR_PARAM_TAG_VALUE);

fptr.setParam(IFptr.LIBFPTR_PARAM_COMMODITY_NAME, "Товар");
fptr.setParam(IFptr.LIBFPTR_PARAM_PRICE, 100);
fptr.setParam(IFptr.LIBFPTR_PARAM_QUANTITY, 5.15);
fptr.setParam(IFptr.LIBFPTR_PARAM_TAX_TYPE, IFptr.LIBFPTR_TAX_VAT18);
fptr.setParam(1222, IFptr.LIBFPTR_AT_ANOTHER);
fptr.setParam(1223, agentInfo);
fptr.setParam(1226, "123456789047");
fptr.setParam(1224, suplierInfo);
fptr.registration();

[fptr setParam:1005, NSStringParam:@"Улица Свободы, д.1"];
[fptr setParam:1016, NSStringParam:@"123456789047"];
[fptr setParam:1026, NSStringParam:@"ООО Оператор"];
[fptr setParam:1075, NSStringParam:@"+79161234567"];
[fptr setParam:1075, NSStringParam:@"+79169876543"];
[fptr utilFormTlv];
NSData *agentInfo = [fptr getParamByteArray:LIBFPTR_PARAM_TAG_VALUE];

[fptr setParam:1171, NSStringParam:@"+79113456789"];
[fptr setParam:1225, NSStringParam:@"ООО Поставщик"];
[fptr utilFormTlv];
NSData *suplierInfo = [fptr getParamByteArray:LIBFPTR_PARAM_TAG_VALUE];

[fptr setParam:LIBFPTR_PARAM_COMMODITY_NAME, NSStringParam:@"Товар"];
[fptr setParam:LIBFPTR_PARAM_PRICE, doubleParam:100];
[fptr setParam:LIBFPTR_PARAM_QUANTITY, doubleParam:5.15];
[fptr setParam:LIBFPTR_PARAM_TAX_TYPE, intParam:LIBFPTR_TAX_VAT18];
[fptr setParam:1222, intParam:LIBFPTR_AT_ANOTHER];
[fptr setParam:1223, NSDataParam:agentInfo];
[fptr setParam:1226, NSStringParam:@"123456789047"];
[fptr setParam:1224, NSDataParam:suplierInfo];
[fptr registration]

fptr.setParam(1005, "Улица Свободы, д.1");
fptr.setParam(1016, "123456789047");
fptr.setParam(1026, "ООО Оператор");
fptr.setParam(1075, "+79161234567");
fptr.setParam(1075, "+79169876543");
fptr.utilFormTlv();
byte[] agentInfo = fptr.getParamByteArray(Constants.LIBFPTR_PARAM_TAG_VALUE);

fptr.setParam(1171, "+79113456789");
fptr.setParam(1225, "ООО Поставщик");
fptr.utilFormTlv();
byte[] suplierInfo = fptr.getParamByteArray(Constants.LIBFPTR_PARAM_TAG_VALUE);

fptr.setParam(Constants.LIBFPTR_PARAM_COMMODITY_NAME, "Товар");
fptr.setParam(Constants.LIBFPTR_PARAM_PRICE, 100);
fptr.setParam(Constants.LIBFPTR_PARAM_QUANTITY, 5.15);
fptr.setParam(Constants.LIBFPTR_PARAM_TAX_TYPE, Constants.LIBFPTR_TAX_VAT18);
fptr.setParam(1222, Constants.LIBFPTR_AT_ANOTHER);
fptr.setParam(1223, agentInfo);
fptr.setParam(1226, "123456789047");
fptr.setParam(1224, suplierInfo);
fptr.registration();

var
    agentInfo:      Variant;
    suplierInfo:    Variant;
begin
    fptr.setParam(1005, 'Улица Свободы, д.1');
    fptr.setParam(1016, '123456789047');
    fptr.setParam(1026, 'ООО Оператор');
    fptr.setParam(1075, '+79161234567');
    fptr.setParam(1075, '+79169876543');
    fptr.utilFormTlv;
    agentInfo := fptr.getParamByteArray(fptr.LIBFPTR_PARAM_TAG_VALUE);

    fptr.setParam(1171, '+79113456789');
    fptr.setParam(1225, 'ООО Поставщик');
    fptr.utilFormTlv;
    suplierInfo := fptr.getParamByteArray(fptr.LIBFPTR_PARAM_TAG_VALUE);

    fptr.setParam(fptr.LIBFPTR_PARAM_COMMODITY_NAME, 'Товар');
    fptr.setParam(fptr.LIBFPTR_PARAM_PRICE, 100);
    fptr.setParam(fptr.LIBFPTR_PARAM_QUANTITY, 5.15);
    fptr.setParam(fptr.LIBFPTR_PARAM_TAX_TYPE, fptr.LIBFPTR_TAX_VAT18);
    fptr.setParam(1222, fptr.LIBFPTR_AT_ANOTHER);
    fptr.setParam(1223, agentInfo);
    fptr.setParam(1226, '123456789047');
    fptr.setParam(1224, suplierInfo);
    fptr.registration;
end;

Для регистрации позиции требуется вызвать метод registration().

Обязательными входными параметрами для метода являются:

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

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

Ниже представлен список дополнительных параметров позиции (могут не поддерживаться в ККТ - в этом случае будет выдана ошибка):

Также в данном методе можно передать следущие реквизиты ФН:

Реквизит Описание Тип
1162 Код товарной номенклатуры bytearray
1222 Признак агента по предмету расчета int
1223 Данные агента bytearray
1224 Данные поставщика bytearray
1226 ИНН поставщика string
1197 Единицы измерения предмета расчета string
1212 Признак предмета расчета int
1214 Признак способа расчета int
1229 Акциз double
1230 Код страны происхождения string
1231 Номер таможенной декларации string

Реквизит 1222 может принимать следующие значения:

Реквизит 1223 составной и состоит из следующих реквизитов:

Реквизит Описание Тип
1005 Адрес оператора перевода string
1016 ИНН оператора перевода string
1026 Наименование оператора перевода string
1044 Операция платежного агента string
1073 Телефон платежного агента (может повторяться несколько раз) string
1074 Телефон оператора по приему платежей (может повторяться несколько раз) string
1075 Телефон оператора перевода (может повторяться несколько раз) string

Реквизит 1224 составной и состоит из следующих реквизитов:

Реквизит Описание Тип
1171 Телефон поставщика (может повторяться несколько раз) string
1225 Наименование поставщика string

Зарегистрировать оплату

Оплата чека

libfptr_set_param_int(fptr, LIBFPTR_PARAM_PAYMENT_TYPE, LIBFPTR_PT_CASH);
libfptr_set_param_double(fptr, LIBFPTR_PARAM_PAYMENT_SUM, 100.00);
libfptr_payment(fptr);

fptr.setParam(IFptr.LIBFPTR_PARAM_PAYMENT_TYPE, IFptr.LIBFPTR_PT_CASH)
fptr.setParam(IFptr.LIBFPTR_PARAM_PAYMENT_SUM, 100.00)
fptr.payment()

fptr.setParam(IFptr.LIBFPTR_PARAM_PAYMENT_TYPE, IFptr.LIBFPTR_PT_CASH);
fptr.setParam(IFptr.LIBFPTR_PARAM_PAYMENT_SUM, 100.00);
fptr.payment();

fptr.setParam(IFptr.LIBFPTR_PARAM_PAYMENT_TYPE, IFptr.LIBFPTR_PT_CASH);
fptr.setParam(IFptr.LIBFPTR_PARAM_PAYMENT_SUM, 100.00);
fptr.payment();

[fptr setParam:LIBFPTR_PARAM_PAYMENT_TYPE, intParam:LIBFPTR_PT_CASH];
[fptr setParam:LIBFPTR_PARAM_PAYMENT_SUM, doubleParam:100.00];
[fptr payment]

fptr.setParam(Constants.LIBFPTR_PARAM_PAYMENT_TYPE, Constants.LIBFPTR_PT_CASH);
fptr.setParam(Constants.LIBFPTR_PARAM_PAYMENT_SUM, 100.00);
fptr.payment();

begin
    fptr.setParam(fptr.LIBFPTR_PARAM_PAYMENT_TYPE, fptr.LIBFPTR_PT_CASH);
    fptr.setParam(fptr.LIBFPTR_PARAM_PAYMENT_SUM, 100.00);
    fptr.payment;
end;

Для регистрации оплаты чека требуется вызвать метод payment(), передав тип оплаты в параметре LIBFPTR_PARAM_PAYMENT_TYPE и сумму оплаты в параметре LIBFPTR_PARAM_PAYMENT_SUM.

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

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

Параметр Описание Тип
LIBFPTR_PARAM_REMAINDER Неоплаченный остаток чека double
LIBFPTR_PARAM_CHANGE Сдача по чеку double

Зарегистрировать налог на чек

Регистрация налога на чек

libfptr_set_param_int(fptr, LIBFPTR_PARAM_TAX_TYPE, LIBFPTR_TAX_VAT18);
libfptr_set_param_double(fptr, LIBFPTR_PARAM_TAX_SUM, 100.00);
libfptr_receipt_tax(fptr);

fptr.setParam(IFptr.LIBFPTR_PARAM_TAX_TYPE, IFptr.LIBFPTR_TAX_VAT18)
fptr.setParam(IFptr.LIBFPTR_PARAM_TAX_SUM, 100.00)
fptr.receiptTax()

fptr.setParam(IFptr.LIBFPTR_PARAM_TAX_TYPE, IFptr.LIBFPTR_TAX_VAT18);
fptr.setParam(IFptr.LIBFPTR_PARAM_TAX_SUM, 100.00);
fptr.receiptTax();

fptr.setParam(IFptr.LIBFPTR_PARAM_TAX_TYPE, IFptr.LIBFPTR_TAX_VAT18);
fptr.setParam(IFptr.LIBFPTR_PARAM_TAX_SUM, 100.00);
fptr.receiptTax();

[fptr setParam:LIBFPTR_PARAM_TAX_TYPE, intParam:LIBFPTR_TAX_VAT18];
[fptr setParam:LIBFPTR_PARAM_TAX_SUM, doubleParam:100.00];
[fptr receiptTax]

fptr.setParam(Constants.LIBFPTR_PARAM_TAX_TYPE, Constants.LIBFPTR_TAX_VAT18);
fptr.setParam(Constants.LIBFPTR_PARAM_TAX_SUM, 100.00);
fptr.receiptTax();

begin
    fptr.setParam(fptr.LIBFPTR_PARAM_TAX_TYPE, fptr.LIBFPTR_TAX_VAT18);
    fptr.setParam(fptr.LIBFPTR_PARAM_TAX_SUM, 100.00);
    fptr.receiptTax;
end;

Для регистрации налога на чек требуется вызвать метод receiptTax(), передав тип налога в параметре LIBFPTR_PARAM_TAX_TYPE и сумму налога в параметре LIBFPTR_PARAM_TAX_SUM.

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

Зарегистрировать итог

Регистрация итога чека

libfptr_set_param_double(fptr, LIBFPTR_PARAM_SUM, 1000.00);
libfptr_receipt_total(fptr);

fptr.setParam(IFptr.LIBFPTR_PARAM_SUM, 1000.00)
fptr.receiptTotal()

fptr.setParam(IFptr.LIBFPTR_PARAM_SUM, 1000.00);
fptr.receiptTotal();

fptr.setParam(IFptr.LIBFPTR_PARAM_SUM, 1000.00);
fptr.receiptTotal();

[fptr setParam:LIBFPTR_PARAM_SUM, intParam:1000.00];
[fptr receiptTotal]

fptr.setParam(Constants.LIBFPTR_PARAM_SUM, 1000.00);
fptr.receiptTotal();

begin
    fptr.setParam(fptr.LIBFPTR_PARAM_SUM, 1000.00);
    fptr.receiptTotal;
end;

Для регистрации итога чека требуется вызвать метод receiptTotal(), передав сумму чека в параметре LIBFPTR_PARAM_SUM.

Допускается регистрация итога меньше суммы чека, но только в рамках копеек. Т.е., если общая сумма чека равна 1000.57, то можно зарегистрировать итог от 1000.00 до 1000.57.

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

Закрыть чек

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

libfptr_set_param_int(fptr, LIBFPTR_PARAM_PAYMENT_TYPE, LIBFPTR_PT_ELECTRONICALLY);
libfptr_close_receipt(fptr);

fptr.setParam(IFptr.LIBFPTR_PARAM_PAYMENT_TYPE, IFptr.LIBFPTR_PT_ELECTRONICALLY)
fptr.closeReceipt()

fptr.setParam(IFptr.LIBFPTR_PARAM_PAYMENT_TYPE, IFptr.LIBFPTR_PT_ELECTRONICALLY);
fptr.closeReceipt();

fptr.setParam(IFptr.LIBFPTR_PARAM_PAYMENT_TYPE, IFptr.LIBFPTR_PT_ELECTRONICALLY);
fptr.closeReceipt();

[fptr setParam:LIBFPTR_PARAM_PAYMENT_TYPE, intParam:LIBFPTR_PT_ELECTRONICALLY];
[fptr closeReceipt]

fptr.setParam(Constants.LIBFPTR_PARAM_PAYMENT_TYPE, Constants.LIBFPTR_PT_ELECTRONICALLY);
fptr.closeReceipt();

begin
    fptr.setParam(fptr.LIBFPTR_PARAM_PAYMENT_TYPE, fptr.LIBFPTR_PT_ELECTRONICALLY);
    fptr.closeReceipt;
end;

Закрытие полностью оплаченного чека

libfptr_close_receipt(fptr);

fptr.closeReceipt()

fptr.closeReceipt();

fptr.closeReceipt();

[fptr closeReceipt]

fptr.closeReceipt();

begin
    fptr.closeReceipt;
end;

Для закрытия чека требуется вызвать метод closeReceipt().

Если чек оплачен не полность или не оплачен совсем (не зарегистрирована ни одна оплата), то чек будет автоматически оплачен / доплачен заданным в параметре LIBFPTR_PARAM_PAYMENT_TYPE типом оплаты и закрыт. Если в этом случае тип оплаты не передан, будет использован наличный тип оплаты (LIBFPTR_PT_CASH). Если чек уже полностью оплачен, то значение параметра LIBFPTR_PARAM_PAYMENT_TYPE ни на что не влияет.

Проверить закрытие документа

Проверка закрытия документа (на примере закрытия фискального чека)

// Вспомогательная функция для чтения текста ошибки
std::wstring getErrorDescription(libfptr_handle fptr)
{
    std::vector<wchar_t> str(32);
    int size = libfptr_error_description(fptr, &str[0], str.size());
    if (size > str.size())
    {
        str.resize(size);
        libfptr_error_description(fptr, &str[0], str.size());
    }
    return std::wstring(&str[0]);
}

libfptr_close_receipt(fptr);

while (libfptr_check_document_closed(fptr) < 0) {
  // Не удалось проверить состояние документа. Вывести пользователю текст ошибки, попросить устранить неполадку и повторить запрос
  std::wcout << getErrorDescription(fptr) << std::endl;
  continue;
}

if (libfptr_get_param_bool(fptr, LIBFPTR_PARAM_DOCUMENT_CLOSED) == 0) {
  // Документ не закрылся. Требуется его отменить (если это чек) и сформировать заново
  libfptr_cancel_receipt(fptr);
  return;
}

if (libfptr_get_param_bool(fptr, LIBFPTR_PARAM_DOCUMENT_PRINTED) == 0) {
  // Можно сразу вызвать метод допечатывания документа, он завершится с ошибкой, если это невозможно
  while (libfptr_continue_print(fptr) < 0) {
    // Если не удалось допечатать документ - показать пользователю ошибку и попробовать еще раз.
    std::wcout << L"Не удалось напечатать документ (Ошибка \""<< getErrorDescription(fptr) << L"\"). Устраните неполадку и повторите."; 
    continue;
  }
}

fptr.closeReceipt()

while fptr.checkDocumentClosed() < 0:
  # Не удалось проверить состояние документа. Вывести пользователю текст ошибки, попросить устранить неполадку и повторить запрос
  print(fptr.errorDescription())
  continue

if not fptr.getParamBool(IFptr.LIBFPTR_PARAM_DOCUMENT_CLOSED):
  # Документ не закрылся. Требуется его отменить (если это чек) и сформировать заново
  fptr.cancelReceipt()
  return

if not fptr.getParamBool(IFptr.LIBFPTR_PARAM_DOCUMENT_PRINTED):
  # Можно сразу вызвать метод допечатывания документа, он завершится с ошибкой, если это невозможно
  while fptr.continuePrint() < 0:
    # Если не удалось допечатать документ - показать пользователю ошибку и попробовать еще раз.
    print('Не удалось напечатать документ (Ошибка "%s"). Устраните неполадку и повторите.', fptr.errorDescription())
    continue

fptr.closeReceipt();

while (fptr.checkDocumentClosed() < 0) {
    // Не удалось проверить состояние документа. Вывести пользователю текст ошибки, попросить устранить неполадку и повторить запрос
    System.out.println(fptr.errorDescription());
    continue;
}

if (!fptr.getParamBool(IFptr.LIBFPTR_PARAM_DOCUMENT_CLOSED)) {
    // Документ не закрылся. Требуется его отменить (если это чек) и сформировать заново
    fptr.cancelReceipt();
    return;
}

if (!fptr.getParamBool(IFptr.LIBFPTR_PARAM_DOCUMENT_PRINTED)) {
    // Можно сразу вызвать метод допечатывания документа, он завершится с ошибкой, если это невозможно
    while (fptr.continuePrint() < 0) {
        // Если не удалось допечатать документ - показать пользователю ошибку и попробовать еще раз.
        System.out.println(String.format("Не удалось напечатать документ (Ошибка \"%s\"). Устраните неполадку и повторите.", fptr.errorDescription()));
        continue;
    }
}

fptr.closeReceipt();

while (fptr.checkDocumentClosed() < 0) {
    // Не удалось проверить состояние документа. Вывести пользователю текст ошибки, попросить устранить неполадку и повторить запрос
    Log.d(TAG, fptr.errorDescription());
    continue;
}

if (!fptr.getParamBool(IFptr.LIBFPTR_PARAM_DOCUMENT_CLOSED)) {
    // Документ не закрылся. Требуется его отменить (если это чек) и сформировать заново
    fptr.cancelReceipt();
    return;
}

if (!fptr.getParamBool(IFptr.LIBFPTR_PARAM_DOCUMENT_PRINTED)) {
    // Можно сразу вызвать метод допечатывания документа, он завершится с ошибкой, если это невозможно
    while (fptr.continuePrint() < 0) {
        // Если не удалось допечатать документ - показать пользователю ошибку и попробовать еще раз.
        Log.d(TAG, String.format("Не удалось напечатать документ (Ошибка \"%s\"). Устраните неполадку и повторите.", fptr.errorDescription()));
        continue;
    }
}

[fptr closeReceipt];

while ([fptr checkReceiptClosed] < 0) {
    // Не удалось проверить состояние документа. Вывести пользователю текст ошибки, попросить устранить неполадку и повторить запрос
    NSLog([fptr errorDescription]);
    continue;
}

if (![fptr getParamBool:LIBFPTR_PARAM_DOCUMENT_CLOSED]) {
    // Документ не закрылся. Требуется его отменить (если это чек) и сформировать заново
    [fptr cancelReceipt];
    return;
}

if (![fptr getParamBool:LIBFPTR_PARAM_DOCUMENT_PRINTED]) {
    // Можно сразу вызвать метод допечатывания документа, он завершится с ошибкой, если это невозможно
    while ([fptr continuePrint] < 0) {
        // Если не удалось допечатать документ - показать пользователю ошибку и попробовать еще раз.
        NSLog(@"Не удалось напечатать документ (Ошибка \"%@\"). Устраните неполадку и повторите.", [fptr errorDescription]);
        continue;
    }
}

fptr.closeReceipt();

while (fptr.checkDocumentClosed() < 0)
{
    // Не удалось проверить состояние документа. Вывести пользователю текст ошибки, попросить устранить неполадку и повторить запрос
    Console.WriteLine(fptr.errorDescription());
    continue;
}

if (!fptr.getParamBool(Constants.LIBFPTR_PARAM_DOCUMENT_CLOSED))
{
    // Документ не закрылся. Требуется его отменить (если это чек) и сформировать заново
    fptr.cancelReceipt();
    return;
}

if (!fptr.getParamBool(Constants.LIBFPTR_PARAM_DOCUMENT_PRINTED))
{
    // Можно сразу вызвать метод допечатывания документа, он завершится с ошибкой, если это невозможно
    while (fptr.continuePrint() < 0)
    {
        // Если не удалось допечатать документ - показать пользователю ошибку и попробовать еще раз.
        Console.WriteLine(String.Format("Не удалось напечатать документ (Ошибка \"{0}\"). Устраните неполадку и повторите.", fptr.errorDescription()));
        continue;
    }
}

begin
    fptr.closeReceipt;

    While fptr.checkDocumentClosed <> 0 do
    begin
        // Не удалось проверить состояние документа. Вывести пользователю текст ошибки, попросить устранить неполадку и повторить запрос
        showmessage(fptr.errorDescription);
        Continue;
    end;

    if not fptr.getParamBool(fptr.LIBFPTR_PARAM_DOCUMENT_CLOSED) then
    begin
        // Документ не закрылся. Требуется его отменить (если это чек) и сформировать заново
        fptr.cancelReceipt;
        exit;
    end;

    if not fptr.getParamBool(fptr.LIBFPTR_PARAM_DOCUMENT_PRINTED) then
    begin
        // Можно сразу вызвать метод допечатывания документа, он завершится с ошибкой, если это невозможно
        While fptr.continuePrint <> 0 do
        begin
            // Если не удалось допечатать документ - показать пользователю ошибку и попробовать еще раз.
            showmessage('Не удалось напечатать документ (Ошибка "' + fptr.errorDescription + '"). Устраните неполадку и повторите.');
            Continue;
        end;
    end;
end;

В ряде ситуаций (окончание бумаги, потеря связи с ККТ в момент регистрации документа) состояние документа остается неизвестным. Он может закрыться в ФН (что является необратимой операцией), но не напечататься на чековой ленте. Данный метод сверяет счетчики ККТ с сохраненными до закрытия документа копиями и вычисляет, закрылся ли он, а также проверяет состояние печати документа. Объект драйвера не должен разрушаться, создаваться заново и перенастраиваться между вызовами методов закрытия / формирования документа и checkDocumentClosed() для корректной работы метода.

Метод применим для:

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

Параметр Описание Тип
LIBFPTR_PARAM_DOCUMENT_CLOSED Документ закрылся bool
LIBFPTR_PARAM_DOCUMENT_PRINTED Документ допечатался bool

Допечатать документ

Допечатывание документа

libfptr_continue_print(fptr);

fptr.continuePrint()

fptr.continuePrint();

fptr.continuePrint();

[fptr continuePrint];

fptr.continuePrint();

begin
    fptr.continuePrint;
end;

Для допечатывания фискального документа требуется вызвать метод continuePrint().

Внесения и выплаты

Внесение

libfptr_set_param_double(fptr, LIBFPTR_PARAM_SUM, 100.00);
libfptr_cash_income(fptr);

fptr.setParam(IFptr.LIBFPTR_PARAM_SUM, 100.00)
fptr.cashIncome()

fptr.setParam(IFptr.LIBFPTR_PARAM_SUM, 100.00);
fptr.cashIncome();

fptr.setParam(IFptr.LIBFPTR_PARAM_SUM, 100.00);
fptr.cashIncome();

[fptr setParam:LIBFPTR_PARAM_SUM doubleParam:100.00];
[fptr cashIncome];

fptr.setParam(Constants.LIBFPTR_PARAM_SUM, 100.00);
fptr.cashIncome();

begin
    fptr.setParam(fptr.LIBFPTR_PARAM_SUM, 100.00);
    fptr.cashIncome;
end;

Для регистрации внесения требуется вызвать метод cashIncome() и указать сумму внесения в параметре LIBFPTR_PARAM_SUM.

Выплата

libfptr_set_param_double(fptr, LIBFPTR_PARAM_SUM, 100.00);
libfptr_cash_outcome(fptr);

fptr.setParam(IFptr.LIBFPTR_PARAM_SUM, 100.00)
fptr.cashOutcome()

fptr.setParam(IFptr.LIBFPTR_PARAM_SUM, 100.00);
fptr.cashOutcome();

fptr.setParam(IFptr.LIBFPTR_PARAM_SUM, 100.00);
fptr.cashOutcome();

[fptr setParam:LIBFPTR_PARAM_SUM doubleParam:100.00];
[fptr cashOutcome];

fptr.setParam(Constants.LIBFPTR_PARAM_SUM, 100.00);
fptr.cashOutcome();

begin
    fptr.setParam(fptr.LIBFPTR_PARAM_SUM, 100.00);
    fptr.cashOutcome;
end;

Для регистрации выплаты требуется вызвать метод cashOutcome() и указать сумму выплаты в параметре LIBFPTR_PARAM_SUM.

Печать отчетов

Для печати отчета необходим заполнить тип отчета (параметр LIBFPTR_PARAM_REPORT_TYPE) и дополнительные параметры отчета (если они требуются) и вызвать метод report().

X-отчет

X-отчет

libfptr_set_param_int(fptr, LIBFPTR_PARAM_REPORT_TYPE, LIBFPTR_RT_X);
libfptr_report(fptr);

fptr.setParam(IFptr.LIBFPTR_PARAM_REPORT_TYPE, IFptr.LIBFPTR_RT_X)
fptr.report()

fptr.setParam(IFptr.LIBFPTR_PARAM_REPORT_TYPE, IFptr.LIBFPTR_RT_X);
fptr.report();

fptr.setParam(IFptr.LIBFPTR_PARAM_REPORT_TYPE, IFptr.LIBFPTR_RT_X);
fptr.report();

[fptr setParam:LIBFPTR_PARAM_REPORT_TYPE, intParam:LIBFPTR_RT_X];
[fptr report];

fptr.setParam(Constants.LIBFPTR_PARAM_REPORT_TYPE, Constants.LIBFPTR_RT_X);
fptr.report();

begin
    fptr.setParam(fptr.LIBFPTR_PARAM_REPORT_TYPE, fptr.LIBFPTR_RT_X);
    fptr.report;
end;

Для печати X-отчета требуется вызвать метод report() с типом отчета LIBFPTR_PARAM_REPORT_TYPE равным LIBFPTR_RT_X.

Копия последнего документа

Копия последнего документа

libfptr_set_param_int(fptr, LIBFPTR_PARAM_REPORT_TYPE, LIBFPTR_RT_LAST_DOCUMENT);
libfptr_report(fptr);

fptr.setParam(IFptr.LIBFPTR_PARAM_REPORT_TYPE, IFptr.LIBFPTR_RT_LAST_DOCUMENT)
fptr.report()

fptr.setParam(IFptr.LIBFPTR_PARAM_REPORT_TYPE, IFptr.LIBFPTR_RT_LAST_DOCUMENT);
fptr.report();

fptr.setParam(IFptr.LIBFPTR_PARAM_REPORT_TYPE, IFptr.LIBFPTR_RT_LAST_DOCUMENT);
fptr.report();

[fptr setParam:LIBFPTR_PARAM_REPORT_TYPE, intParam:LIBFPTR_RT_LAST_DOCUMENT];
[fptr report];

fptr.setParam(Constants.LIBFPTR_PARAM_REPORT_TYPE, Constants.LIBFPTR_RT_LAST_DOCUMENT);
fptr.report();

begin
    fptr.setParam(fptr.LIBFPTR_PARAM_REPORT_TYPE, fptr.LIBFPTR_RT_LAST_DOCUMENT);
    fptr.report;
end;

Для печати копии последнего документа требуется вызвать метод report() с типом отчета LIBFPTR_PARAM_REPORT_TYPE равным LIBFPTR_RT_LAST_DOCUMENT.

Отчет о состоянии расчетов

Отчет о состоянии расчетов

libfptr_set_param_int(fptr, LIBFPTR_PARAM_REPORT_TYPE, LIBFPTR_RT_OFD_EXCHANGE_STATUS);
libfptr_report(fptr);

fptr.setParam(IFptr.LIBFPTR_PARAM_REPORT_TYPE, IFptr.LIBFPTR_RT_OFD_EXCHANGE_STATUS)
fptr.report()

fptr.setParam(IFptr.LIBFPTR_PARAM_REPORT_TYPE, IFptr.LIBFPTR_RT_OFD_EXCHANGE_STATUS);
fptr.report();

fptr.setParam(IFptr.LIBFPTR_PARAM_REPORT_TYPE, IFptr.LIBFPTR_RT_OFD_EXCHANGE_STATUS);
fptr.report();

[fptr setParam:LIBFPTR_PARAM_REPORT_TYPE, intParam:LIBFPTR_RT_OFD_EXCHANGE_STATUS];
[fptr report];

fptr.setParam(Constants.LIBFPTR_PARAM_REPORT_TYPE, Constants.LIBFPTR_RT_OFD_EXCHANGE_STATUS);
fptr.report();

begin
    fptr.setParam(fptr.LIBFPTR_PARAM_REPORT_TYPE, fptr.LIBFPTR_RT_OFD_EXCHANGE_STATUS);
    fptr.report;
end;

Для печати отчета о состоянии расчетов требуется вызвать метод report() с типом отчета LIBFPTR_PARAM_REPORT_TYPE равным LIBFPTR_RT_OFD_EXCHANGE_STATUS.

Демо-печать

Демо-печать

libfptr_set_param_int(fptr, LIBFPTR_PARAM_REPORT_TYPE, LIBFPTR_RT_KKT_DEMO);
libfptr_report(fptr);

fptr.setParam(IFptr.LIBFPTR_PARAM_REPORT_TYPE, IFptr.LIBFPTR_RT_KKT_DEMO)
fptr.report()

fptr.setParam(IFptr.LIBFPTR_PARAM_REPORT_TYPE, IFptr.LIBFPTR_RT_KKT_DEMO);
fptr.report();

fptr.setParam(IFptr.LIBFPTR_PARAM_REPORT_TYPE, IFptr.LIBFPTR_RT_KKT_DEMO);
fptr.report();

[fptr setParam:LIBFPTR_PARAM_REPORT_TYPE, intParam:LIBFPTR_RT_KKT_DEMO];
[fptr report];

fptr.setParam(Constants.LIBFPTR_PARAM_REPORT_TYPE, Constants.LIBFPTR_RT_KKT_DEMO);
fptr.report();

begin
    fptr.setParam(fptr.LIBFPTR_PARAM_REPORT_TYPE, fptr.LIBFPTR_RT_KKT_DEMO);
    fptr.report;
end;

Для демо-печати требуется вызвать метод report() с типом отчета LIBFPTR_PARAM_REPORT_TYPE равным LIBFPTR_RT_KKT_DEMO.

Печать информации о ККТ

Печать информации о ККТ

libfptr_set_param_int(fptr, LIBFPTR_PARAM_REPORT_TYPE, LIBFPTR_RT_KKT_INFO);
libfptr_report(fptr);

fptr.setParam(IFptr.LIBFPTR_PARAM_REPORT_TYPE, IFptr.LIBFPTR_RT_KKT_INFO)
fptr.report()

fptr.setParam(IFptr.LIBFPTR_PARAM_REPORT_TYPE, IFptr.LIBFPTR_RT_KKT_INFO);
fptr.report();

fptr.setParam(IFptr.LIBFPTR_PARAM_REPORT_TYPE, IFptr.LIBFPTR_RT_KKT_INFO);
fptr.report();

[fptr setParam:LIBFPTR_PARAM_REPORT_TYPE, intParam:LIBFPTR_RT_KKT_INFO];
[fptr report];

fptr.setParam(Constants.LIBFPTR_PARAM_REPORT_TYPE, Constants.LIBFPTR_RT_KKT_INFO);
fptr.report();

begin
    fptr.setParam(fptr.LIBFPTR_PARAM_REPORT_TYPE, fptr.LIBFPTR_RT_KKT_INFO);
    fptr.report;
end;

Для печати информации о ККТ требуется вызвать метод report() с типом отчета LIBFPTR_PARAM_REPORT_TYPE равным LIBFPTR_RT_KKT_INFO.

Диагностика соединения с ОФД

Диагностика соединения с ОФД

libfptr_set_param_int(fptr, LIBFPTR_PARAM_REPORT_TYPE, LIBFPTR_RT_OFD_TEST);
libfptr_report(fptr);

fptr.setParam(IFptr.LIBFPTR_PARAM_REPORT_TYPE, IFptr.LIBFPTR_RT_OFD_TEST)
fptr.report()

fptr.setParam(IFptr.LIBFPTR_PARAM_REPORT_TYPE, IFptr.LIBFPTR_RT_OFD_TEST);
fptr.report();

fptr.setParam(IFptr.LIBFPTR_PARAM_REPORT_TYPE, IFptr.LIBFPTR_RT_OFD_TEST);
fptr.report();

[fptr setParam:LIBFPTR_PARAM_REPORT_TYPE, intParam:LIBFPTR_RT_OFD_TEST];
[fptr report];

fptr.setParam(Constants.LIBFPTR_PARAM_REPORT_TYPE, Constants.LIBFPTR_RT_OFD_TEST);
fptr.report();

begin
    fptr.setParam(fptr.LIBFPTR_PARAM_REPORT_TYPE, fptr.LIBFPTR_RT_OFD_TEST);
    fptr.report;
end;

Для печати лиагностики соединения с ОФД требуется вызвать метод report() с типом отчета LIBFPTR_PARAM_REPORT_TYPE равным LIBFPTR_RT_OFD_TEST.

Печать документа из ФН

Печать документа из ФН

libfptr_set_param_int(fptr, LIBFPTR_PARAM_REPORT_TYPE, LIBFPTR_RT_FN_DOC_BY_NUMBER);
libfptr_set_param_int(fptr, LIBFPTR_PARAM_DOCUMENT_NUMBER, 12);
libfptr_report(fptr);

fptr.setParam(IFptr.LIBFPTR_PARAM_REPORT_TYPE, IFptr.LIBFPTR_RT_FN_DOC_BY_NUMBER)
fptr.setParam(IFptr.LIBFPTR_PARAM_DOCUMENT_NUMBER, 12)
fptr.report()

fptr.setParam(IFptr.LIBFPTR_PARAM_REPORT_TYPE, IFptr.LIBFPTR_RT_FN_DOC_BY_NUMBER);
fptr.setParam(IFptr.LIBFPTR_PARAM_DOCUMENT_NUMBER, 12);
fptr.report();

fptr.setParam(IFptr.LIBFPTR_PARAM_REPORT_TYPE, IFptr.LIBFPTR_RT_FN_DOC_BY_NUMBER);
fptr.setParam(IFptr.LIBFPTR_PARAM_DOCUMENT_NUMBER, 12);
fptr.report();

[fptr setParam:LIBFPTR_PARAM_REPORT_TYPE, intParam:LIBFPTR_RT_FN_DOC_BY_NUMBER];
[fptr setParam:LIBFPTR_PARAM_DOCUMENT_NUMBER, intParam:12];
[fptr report];

fptr.setParam(Constants.LIBFPTR_PARAM_REPORT_TYPE, Constants.LIBFPTR_RT_FN_DOC_BY_NUMBER);
fptr.setParam(Constants.LIBFPTR_PARAM_DOCUMENT_NUMBER, 12);
fptr.report();

begin
    fptr.setParam(fptr.LIBFPTR_PARAM_REPORT_TYPE, fptr.LIBFPTR_RT_FN_DOC_BY_NUMBER);
    fptr.setParam(fptr.LIBFPTR_PARAM_DOCUMENT_NUMBER, 12);
    fptr.report;
end;

Для печати документа из архива фискального накопителя требуется вызвать метод report() с типом отчета LIBFPTR_PARAM_REPORT_TYPE равным LIBFPTR_RT_FN_DOC_BY_NUMBER.

Для указания номер документа используется параметр LIBFPTR_PARAM_DOCUMENT_NUMBER.

Отчет количеств

Отчет количеств

libfptr_set_param_int(fptr, LIBFPTR_PARAM_REPORT_TYPE, LIBFPTR_RT_QUANTITY);
libfptr_report(fptr);

fptr.setParam(IFptr.LIBFPTR_PARAM_REPORT_TYPE, IFptr.LIBFPTR_RT_QUANTITY)
fptr.report()

fptr.setParam(IFptr.LIBFPTR_PARAM_REPORT_TYPE, IFptr.LIBFPTR_RT_QUANTITY);
fptr.report();

fptr.setParam(IFptr.LIBFPTR_PARAM_REPORT_TYPE, IFptr.LIBFPTR_RT_QUANTITY);
fptr.report();

[fptr setParam:LIBFPTR_PARAM_REPORT_TYPE, intParam:LIBFPTR_RT_QUANTITY];
[fptr report];

fptr.setParam(Constants.LIBFPTR_PARAM_REPORT_TYPE, Constants.LIBFPTR_RT_QUANTITY);
fptr.report();

begin
    fptr.setParam(fptr.LIBFPTR_PARAM_REPORT_TYPE, fptr.LIBFPTR_RT_QUANTITY);
    fptr.report;
end;

Для печати отчета количеств требуется вызвать метод report() с типом отчета LIBFPTR_PARAM_REPORT_TYPE равным LIBFPTR_RT_QUANTITY.

Отчет по секциям

Отчет по секциям

libfptr_set_param_int(fptr, LIBFPTR_PARAM_REPORT_TYPE, LIBFPTR_RT_DEPARTMENTS);
libfptr_report(fptr);

fptr.setParam(IFptr.LIBFPTR_PARAM_REPORT_TYPE, IFptr.LIBFPTR_RT_DEPARTMENTS)
fptr.report()

fptr.setParam(IFptr.LIBFPTR_PARAM_REPORT_TYPE, IFptr.LIBFPTR_RT_DEPARTMENTS);
fptr.report();

fptr.setParam(IFptr.LIBFPTR_PARAM_REPORT_TYPE, IFptr.LIBFPTR_RT_DEPARTMENTS);
fptr.report();

[fptr setParam:LIBFPTR_PARAM_REPORT_TYPE, intParam:LIBFPTR_RT_DEPARTMENTS];
[fptr report];

fptr.setParam(Constants.LIBFPTR_PARAM_REPORT_TYPE, Constants.LIBFPTR_RT_DEPARTMENTS);
fptr.report();

begin
    fptr.setParam(fptr.LIBFPTR_PARAM_REPORT_TYPE, fptr.LIBFPTR_RT_DEPARTMENTS);
    fptr.report;
end;

Для печати отчета по секциям требуется вызвать метод report() с типом отчета LIBFPTR_PARAM_REPORT_TYPE равным LIBFPTR_RT_DEPARTMENTS.

Отчет по кассирам

Отчет по кассирам

libfptr_set_param_int(fptr, LIBFPTR_PARAM_REPORT_TYPE, LIBFPTR_RT_OPERATORS);
libfptr_report(fptr);

fptr.setParam(IFptr.LIBFPTR_PARAM_REPORT_TYPE, IFptr.LIBFPTR_RT_OPERATORS)
fptr.report()

fptr.setParam(IFptr.LIBFPTR_PARAM_REPORT_TYPE, IFptr.LIBFPTR_RT_OPERATORS);
fptr.report();

fptr.setParam(IFptr.LIBFPTR_PARAM_REPORT_TYPE, IFptr.LIBFPTR_RT_OPERATORS);
fptr.report();

[fptr setParam:LIBFPTR_PARAM_REPORT_TYPE, intParam:LIBFPTR_RT_OPERATORS];
[fptr report];

fptr.setParam(Constants.LIBFPTR_PARAM_REPORT_TYPE, Constants.LIBFPTR_RT_OPERATORS);
fptr.report();

begin
    fptr.setParam(fptr.LIBFPTR_PARAM_REPORT_TYPE, fptr.LIBFPTR_RT_OPERATORS);
    fptr.report;
end;

Для печати отчета по кассирам требуется вызвать метод report() с типом отчета LIBFPTR_PARAM_REPORT_TYPE равным LIBFPTR_RT_OPERATORS.

Отчет по часам

Отчет по часам

libfptr_set_param_int(fptr, LIBFPTR_PARAM_REPORT_TYPE, LIBFPTR_RT_HOURS);
libfptr_report(fptr);

fptr.setParam(IFptr.LIBFPTR_PARAM_REPORT_TYPE, IFptr.LIBFPTR_RT_HOURS)
fptr.report()

fptr.setParam(IFptr.LIBFPTR_PARAM_REPORT_TYPE, IFptr.LIBFPTR_RT_HOURS);
fptr.report();

fptr.setParam(IFptr.