Студия веб-разработки
← Все посты
45

Kyocera TASKalfa 1800 на Linux: полное лекарство для GDI-принтера

Kyocera TASKalfa 1800 на Linux: полное лекарство для GDI-принтера

Kyocera TASKalfa 1800 на Linux: полное лекарство для GDI-принтера

У нас в хозяйстве появился МФУ Kyocera TASKalfa 1800 — офисная рабочая лошадка. На Windows она заводится с диска, а на Linux нас ждал квест длиной в два дня: принтер то печатал чёрные листы, то валил задания с «PRINT FAILED», то перед каждым листом вставал в позу «Загрузите бумагу в кассету 1». В этом посте — готовый комплект, который лечит всё, и детективная история про один байт, который оказался причиной последней болячки.

Почему этот принтер — особый случай

TASKalfa 1800/2200 — GDI-принтер: он не понимает ни PCL, ни PostScript, только фирменный протокол Kyocera KPSL. Поэтому:

  • в мастере «Добавить принтер» в CUPS/KDE/GNOME его нет;
  • «родовые» драйверы (Gutenprint, foomatic, generic) с ним не работают;
  • единственный официальный Linux-драйвер — пакет Kyocera 8.1305 (2013 года!), состоящий из PPD и проприетарного фильтра rastertokpsl_A3.

Свежих версий нет: в текущем списке KyoceraLinuxPackages остались только PCL/KPDL-модели, а пакет в AUR умер вместе со старыми ссылками на сайт Kyocera (сайт переехал, старые URL отдают 404).

Симптомы → диагнозы

Симптом Причина Лечение
Принтера нет в мастере установки GDI/KPSL, модели нет в базе CUPS официальный PPD + фильтр rastertokpsl_A3
Лист выходит чёрным / негативом фильтр 2013 года печатает современный CUPS-растр инвертированной полярностью обёртка пропускает растр как есть — родная полярность фильтра, вопреки ожиданиям, правильная
«PRINT FAILED» на файлах с длинными русскими именами переполнение буфера ~48 байт в имени задания (argv[3] фильтра), glibc убивает процесс (SIGABRT); с латинскими короткими именами не воспроизводится обёртка подрезает имена длиннее 40 байт
Перед каждым листом замирает с «Загрузите бумагу в кассету 1» (лечится нажатием «Старт») баг фильтра: флаг в KPSL-записи P вычисляется по пиксельному содержимому страницы и иногда получается «плохим» обёртка принудительно ставит правильный флаг (об этом ниже)
Печатает, но содержимое смещено влево PPD из коробки с Letter-полями и full-bleed-эксперименты PPD с честными полями A4 и A4 по умолчанию

Быстрая установка (комплект из одного архива)

Скачайте kyocera-taskalfa1800-linux-kit.zip, распакуйте и выполните одну команду:

cd kit
sudo bash install.sh          # добавить --test, чтобы сразу ушла тестовая страница

После этого воткните принтер по USB и печатайте — очередь называется Kyocera-TASKalfa-1800.

Что проверяет установщик: видимость принтера (lsusb → 0482:0606), наличие /dev/usb/lp0, очередь в CUPS. gcc и заголовки libcups не обязательны — при их отсутствии возьмётся готовый бинарник обёртки из комплекта.

Ручной путь (без архива)

Если архива под рукой нет, всё собирается из официальных источников:

  1. Скачайте официальный драйвер «Linux driver 8.1305» со страницы загрузок TASKalfa 1800 на kyoceradocumentsolutions.eu (файл Linux_TASKalfa1800_2200_v8_1305_zip.download.zip, ~6 МБ).
  2. Из архива возьмите Global/English/Kyocera TASKalfa 1800GDI.ppd и filter/64bit/rastertokpsl_A3 (внутри tar.gz для вашего языка).
  3. Пропатчите PPD (Letter → A4 и наш фильтр):
sed -i -E 's/^(\*Default(PageSize|ImageableArea|PaperDimension):) Letter/\1 A4/' 'Kyocera TASKalfa 1800GDI.ppd'
sed -i 's|/usr/lib/cups/filter/rastertokpsl_A3|/usr/lib/cups/filter/kyocera-inv-rastertokpsl|' 'Kyocera TASKalfa 1800GDI.ppd'
  1. Положите rastertokpsl_A3 в /usr/lib/cups/filter/, соберите обёртку (исходник ниже) и установите её туда же как kyocera-inv-rastertokpsl.bin, плюс шим kyocera-inv-rastertokpsl и бэкенд lp0direct.
  2. Убедитесь, что модуль ядра usblp не в блэклисте и загружен (ls /dev/usb/lp0).
  3. Создайте очередь:
lpadmin -p Kyocera-TASKalfa-1800 -v lp0direct:/ -P 'Kyocera TASKalfa 1800GDI.ppd'
cupsenable Kyocera-TASKalfa-1800 && cupsaccept Kyocera-TASKalfa-1800

Важный нюанс, съевший у нас час: в современных CUPS у lpadmin флаг -m — это имя из каталога моделей, а не путь к файлу (путь он склеивает со своим префиксом и падает). Для локального PPD — флаг -P.

Детектив: один байт, который ломал всю печать

Самое интересное. После исправления инверсии и падений принтер всё равно перед каждым листом замирал: «Загрузите бумагу в кассету 1» — и ждал нажатия «Старт». При этом тот же принтер, подключённый к ноутбуку, печатал молча.

Мы прогнали полную программу подозреваемых:

  • Геометрия растра — выровняли байт-в-байт по ноутбучному заданию (600 dpi, поля, ровно тот же размер): не помогло.
  • Данные — сгенерировали KPSL-поток из одного и того же растра на обеих машинах: md5 совпал. Поток одинаковый — поведение разное?!
  • Транспорт — переписали бэкенд CUPS на прямую запись в /dev/usb/lp0: не помогло.
  • Аргументы фильтра — воспроизвели точную командную строку, с которой его зовёт cupsd: не они.

А дальше сработала старая метода: дифф двух потоков — «молчаливого» (ручная подача в порт, аппарат молчит) и «спрашивающего» (через CUPS). Разбор потока на записи ESC $ 0 <тип> показал: последовательности записей идентичны, пиксельные данные чуть отличаются (на тестовой странице печатается текущая дата/время!) — и в одной-единственной служебной записи P различается четыре байта.

Запись P — параметры страницы: ширина и высота листа в десятых миллиметра (A4 = 2099×2970) и следом u32-флаг:

ESC $ 0 P | 03 00 00 00 40 40 40 40 00 00 00 00
          | <u16 ширина 0.1мм> <u16 высота 0.1мм> <u32 ФЛАГ>
                                          ^^^^^^^^
                          08 00 00 00 → аппарат молча берёт кассету
                          00 00 00 00 → замирает с «загрузите бумагу»

Фильтр Kyocera вычисляет этот флаг по пиксельному содержимому страницы: одна и та же геометрия, но чуть другие пиксели (другая дата на тестовой странице!) — и флаг уже другой. Отсюда и мистика «принтер сам не знает, чего хочет», и «магия» ноутбука, которому просто везло с растрами.

Доказательство получили хирургически: в живом «спрашивающем» потоке поменяли один байт 00 → 08 и скормили аппарату — он напечатал молча. С тех пор обёртка перехватывает вывод фильтра и принудительно ставит 08 00 00 00 во все записи P.

Попутное открытие для тех, кто будет отлаживать принтеры по USB: у Kyocera работает двунаправленный PJL-канал (@PJL INFO STATUS через /dev/usb/lp0), который возвращает код и точный текст с дисплея — бесценно, когда нужно понять, что аппарат думает прямо сейчас.

Диагностика

# что на дисплее аппарата прямо сейчас (нужен загруженный usblp)
sudo python3 pjl_status.py
# CODE=10001 DISPLAY="Готов."        — всё хорошо
# CODE=41200 DISPLAY="Загрузите..."  — смотрите таблицу симптомов

# следы конвейера (создаются при каждой печати):
#   /tmp/kyo_args.log  — аргументы, с которыми звали фильтр
#   /tmp/lp0_last.kpsl — копия потока, ушедшего в принтер
#   /tmp/kyo_last.raster — последний растр до фильтра

Исходники комплекта

Установщик — проверяет всё, ставит файлы, создаёт очередь:

#!/bin/bash
# ============================================================================
# Установка драйвера Kyocera TASKalfa 1800 / 2200 (GDI/KPSL) на Linux.
# Комплект лечит: инверсию печати, падения на длинных именах файлов,
# вечный запрос «Загрузите бумагу в кассету 1».
#
# Использование:  sudo bash install.sh [--test]
#   --test  — после установки отправить тестовую страницу
# ============================================================================
set -e
[ "$(id -u)" = 0 ] || { echo "Запусти с правами root:  sudo bash $0"; exit 1; }

DIR="$(cd "$(dirname "$0")" && pwd)/files"
Q="Kyocera-TASKalfa-1800"
say() { echo -e "\e[1;32m==>\e[0m $*"; }

# --- 1. Оригинальный фильтр Kyocera (проприетарный, v8.1305) ---------------
say "Фильтр Kyocera rastertokpsl_A3"
install -Dm755 "$DIR/rastertokpsl_A3" /usr/lib/cups/filter/rastertokpsl_A3

# --- 2. Обёртка с тремя фиксами: компилируем, иначе готовый бинарник -------
say "Обёртка kyocera-inv-rastertokpsl (фиксы инверсии/имён/P-флага)"
if gcc -O2 -o /tmp/kyo-wrapper-build "$DIR/inv_rastertokpsl.c" -lcups 2>/dev/null; then
    install -Dm755 /tmp/kyo-wrapper-build /usr/lib/cups/filter/kyocera-inv-rastertokpsl.bin
    rm -f /tmp/kyo-wrapper-build
    echo "    скомпилировано из исходника"
else
    install -Dm755 "$DIR/kyocera-inv-rastertokpsl.bin" /usr/lib/cups/filter/kyocera-inv-rastertokpsl.bin
    echo "    gcc/libcups-dev не найдены — использую готовый бинарник (x86_64)"
fi
install -Dm755 "$DIR/kyocera-inv-rastertokpsl" /usr/lib/cups/filter/kyocera-inv-rastertokpsl

# --- 3. Бэкенд прямой записи в /dev/usb/lp0 ---------------------------------
say "Бэкенд lp0direct"
install -Dm755 "$DIR/lp0direct" /usr/lib/cups/backend/lp0direct

# --- 4. PPD (A4 по умолчанию, поля 12/10/583/832, «1200dpi»=фикция→600) ----
say "PPD"
install -Dm644 "$DIR/Kyocera_TASKalfa_1800GDI.ppd" \
    /usr/share/cups/model/kyocera/Kyocera_TASKalfa_1800GDI.ppd

# --- 5. Модуль ядра usblp (должен быть загружен; снять блэклист) -----------
say "Модуль usblp"
for f in /etc/modprobe.d/usblp.conf; do
    [ -f "$f" ] && mv "$f" "$f.disabled" && echo "    блэклист $f отключён"
done
modprobe usblp 2>/dev/null || true

# --- 6. Перезапуск CUPS ------------------------------------------------------
say "Перезапуск CUPS"
systemctl restart cups 2>/dev/null || systemctl restart cupsd 2>/dev/null || service cups restart
sleep 2

# --- 7. Очередь печати --------------------------------------------------------
say "Очередь печати $Q"
# -P = локальный PPD-файл (NOT -m: он ждёт имя из каталога моделей,
# и этот CUPS склеивает путь двойной префикс, cups-driverd падает)
lpadmin -p "$Q" -v lp0direct:/ \
        -P "$DIR/Kyocera_TASKalfa_1800GDI.ppd"
cupsenable "$Q" 2>/dev/null || true
cupsaccept "$Q" 2>/dev/null || true

# --- 8. Проверки --------------------------------------------------------------
echo
if lpinfo -v 2>/dev/null | grep -qi kyocera; then
    echo "Принтер виден: $(lpinfo -v | grep -i kyocera | head -1)"
else
    echo "ВНИМАНИЕ: принтер по USB не виден. Воткни кабель/включи питание."
    echo "          (lsusb должен показать 0482:0606 Kyocera)"
fi
[ -e /dev/usb/lp0 ] && echo "Устройство /dev/usb/lp0 есть" \
                    || echo "ВНИМАНИЕ: /dev/usb/lp0 нет — принтер не подключён или usblp не загрузился"

echo
say "Готово. Печать:  lp -d $Q <файл>   (или выбери принтер в диалоге печати)"

if [ "$1" = "--test" ]; then
    for t in /usr/share/cups/data/testprint \
             /usr/share/cups/data/default-testpage \
             /usr/share/cups/data/default-testpage.pdf; do
        [ -f "$t" ] && { say "Тестовая страница..."; lp -d "$Q" "$t"; break; }
    done
fi

Обёртка фильтра — три фикса в одном (полярность, имена, P-флаг):

/*
 * kyocera-inv-rastertokpsl — CUPS filter wrapper for Kyocera KPSL GDI printers
 * (TASKalfa 1800/2200).
 *
 * Fixes applied to the legacy Kyocera rastertokpsl_A3 (v8.1305, 2013):
 *
 *  1. Polarity switch (KYO_NOINVERT=1): the filter's native polarity is
 *     correct for this device (proven 2026-11-02: sheets #15/16 printed
 *     inverted WITH inversion, #17+ normal without).
 *
 *  2. Job title overflow guard: the filter overflows a ~48-byte buffer on
 *     long job titles (argv[3]) and dies with SIGABRT ("PRINT FAILED",
 *     proven on Kubuntu 2026-10-08). Titles > 40 bytes are shortened.
 *
 *  3. THE PAPER-ASK FIX (2026-11-02): the filter emits a "P" record
 *     (page params; page size in 0.1mm units, e.g. A4 = 2099x2970):
 *
 *         ESC $ 0 P | 03 00 00 00 40 40 40 40 00 00 00 00
 *                  | <u16 W tenths-mm> <u16 H tenths-mm> <u32 FLAG>
 *
 *     Depending on raster pixel content the filter computes FLAG as
 *     00 00 00 00 or 08 00 00 00. With FLAG=0 the device stops and asks
 *     "Load paper in cassette 1" for every job; with FLAG=8 it prints
 *     silently (proven by a surgical 1-byte patch on a live stream).
 *     We force FLAG to 08 00 00 00 in every P record.
 *
 * Env: KYO_DUMP=/path — save the raster handed to rastertokpsl.
 *      KYO_NOINVERT=1 — pass raster through un-inverted.
 *
 * CUPS filter calling convention: job-id user title copies options [filename]
 */

#include <cups/raster.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <sys/wait.h>

#define KYO_FILTER "/usr/lib/cups/filter/rastertokpsl_A3"

static void
full_write(int fd, const unsigned char *p, size_t n)
{
  while (n > 0)
  {
    ssize_t w = write(fd, p, n);
    if (w < 0)
    {
      if (errno == EINTR)
        continue;
      _exit(1);
    }
    p += w;
    n -= (size_t)w;
  }
}

/*
 * Force the trailing FLAG u32 of every "ESC $ 0 P" record to 08 00 00 00.
 * Scans the WHOLE file (multi-page streams carry one P record per page;
 * pages 2+ live far beyond the first kilobytes). Windows overlap by the
 * marker+flag size so a record spanning a chunk boundary is still seen;
 * dedupe guards against patching the same record twice.
 * Returns the number of records patched.
 */
static int
patch_paper_flag(int fd)
{
  unsigned char buf[65536];
  int patched = 0;
  off_t size = lseek(fd, 0, SEEK_END);

  if (size < 24)
    return (0);
  off_t win = 0;
  off_t last_marker = -1;
  while (win < size)
  {
    ssize_t n = pread(fd, buf, sizeof(buf), win);
    if (n < 24)
      break;
    /*
     * Advance with a 23-byte overlap so a marker whose flag spans the
     * window edge is caught in the next window. Guard against zero
     * progress at the tail (n == 24 → advance 0 → infinite loop).
     */
    off_t adv = n - 23;
    if (adv < 1)
      break;
    for (ssize_t i = 0; i + 24 <= n; i ++)
    {
      off_t marker = win + i;
      if (marker == last_marker)
        continue;
      if (buf[i] != 0x1b || buf[i+1] != 0x24 || buf[i+2] != 0x30 ||
          buf[i+3] != 'P')
        continue;
      off_t off = marker + 4 + 16;             /* FLAG u32 inside P data */
      unsigned char f[4];
      if (pread(fd, f, 4, off) != 4)
        continue;
      last_marker = marker;
      if (f[0] != 0x08 || f[1] || f[2] || f[3])
      {
        static const unsigned char eight[4] = {8, 0, 0, 0};
        if (pwrite(fd, eight, 4, off) != 4)
          continue;
        patched ++;
        fprintf(stderr,
                "DEBUG: kyocera-inv: P-record flag %02x%02x%02x%02x -> 08000000\n",
                f[0], f[1], f[2], f[3]);
      }
    }
    win += adv;
  }
  return (patched);
}

int
main(int argc, char **argv)
{
  cups_raster_t	*in;
  cups_page_header2_t hdr;
  unsigned char *line, buf2[65536];
  char tmpl[] = "/tmp/kyocera-inv-XXXXXX";
  char outtmpl[] = "/tmp/kyocera-out-XXXXXX";
  int tmp_fd, out_fd;
  cups_raster_t *out;
  unsigned y, pages = 0;
  const char *dump, *opts;
  size_t n2;
  ssize_t w;
  int noinvert = getenv("KYO_NOINVERT") != NULL;

  /*
   * TUMBLE FIX: the device physically always flips duplex along the long
   * edge — the DuplexTumble direction byte the filter emits (J-record) is
   * ignored by the printer (proven 2026-11-04 with A/B sheets). So when a
   * short-edge (calendar) job is requested, we rotate every even page
   * (2nd, 4th, ... — the backs) by 180 degrees ourselves; after the
   * device's long-edge flip they come out short-edge, as ordered.
   */
  opts = (argc >= 6 && argv[5]) ? argv[5] : "";
  int tumblefix = (strstr(opts, "Duplex=DuplexTumble") != NULL ||
                   strstr(opts, "sides=two-sided-short-edge") != NULL);

  tmp_fd = mkstemp(tmpl);
  if (tmp_fd < 0)
  {
    perror("DEBUG: kyocera-inv: mkstemp");
    return (1);
  }
  unlink(tmpl);

  in = cupsRasterOpen(0, CUPS_RASTER_READ);
  out = cupsRasterOpen(tmp_fd, CUPS_RASTER_WRITE);
  if (!in || !out)
  {
    fprintf(stderr, "DEBUG: kyocera-inv: cannot open raster streams\n");
    return (1);
  }

  /*
   * Multi-page loop: a raster stream carries one header per page; process
   * every page (the first wrapper version took only page 1 and silently
   * dropped the rest of the document).
   */
  while (cupsRasterReadHeader2(in, &hdr))
  {
    unsigned line_size = hdr.cupsBytesPerLine;
    line = malloc(line_size);
    if (!line)
      return (1);
    /* even page (2nd, 4th, ...) of a short-edge job: buffer for rotation */
    int rotate = tumblefix && (pages % 2 == 1);
    unsigned char *pagebuf = NULL;
    if (rotate)
    {
      pagebuf = malloc((size_t)line_size * hdr.cupsHeight);
      if (!pagebuf)
        return (1);
    }
    if (!cupsRasterWriteHeader2(out, &hdr))
    {
      fprintf(stderr, "DEBUG: kyocera-inv: cannot write raster header\n");
      return (1);
    }
    for (y = 0; y < hdr.cupsHeight; y ++)
    {
      if (cupsRasterReadPixels(in, line, line_size) < 1)
      {
        fprintf(stderr, "DEBUG: kyocera-inv: short read on page %u row %u\n",
                pages + 1, y);
        return (1);
      }
      if (!noinvert)
        for (unsigned i = 0; i < line_size; i ++)
          line[i] = ~line[i];
      if (rotate)
        memcpy(pagebuf + (size_t)y * line_size, line, line_size);
      else
      if (cupsRasterWritePixels(out, line, line_size) < 1)
      {
        fprintf(stderr, "DEBUG: kyocera-inv: write failed on page %u row %u\n",
                pages + 1, y);
        return (1);
      }
    }
    if (rotate)
    {
      /* 180°: rows bottom-to-top, bytes right-to-left */
      for (y = hdr.cupsHeight; y > 0; y --)
      {
        unsigned char *row = pagebuf + (size_t)(y - 1) * line_size;
        for (unsigned i = 0; i < line_size; i ++)
          line[i] = row[line_size - 1 - i];
        if (cupsRasterWritePixels(out, line, line_size) < 1)
        {
          fprintf(stderr, "DEBUG: kyocera-inv: rotate write failed page %u\n",
                  pages + 1);
          return (1);
        }
      }
      free(pagebuf);
      fprintf(stderr, "DEBUG: kyocera-inv: page %u rotated 180 (tumblefix)\n",
              pages + 1);
    }
    free(line);
    pages ++;
  }

  cupsRasterClose(out);
  cupsRasterClose(in);
  fprintf(stderr, "DEBUG: kyocera-inv: %u page(s) processed\n", pages);

  if ((dump = getenv("KYO_DUMP")) != NULL)
  {
    FILE *df = fopen(dump, "wb");
    if (df)
    {
      lseek(tmp_fd, 0, SEEK_SET);
      while ((n2 = read(tmp_fd, buf2, sizeof(buf2))) > 0)
        fwrite(buf2, 1, n2, df);
      fclose(df);
      lseek(tmp_fd, 0, SEEK_SET);
    }
  }

  /* Run the Kyocera filter with stdin = raster tmp, stdout = out tmp. */
  out_fd = mkstemp(outtmpl);
  if (out_fd < 0)
  {
    perror("DEBUG: kyocera-inv: mkstemp out");
    return (1);
  }
  unlink(outtmpl);

  fflush(NULL);
  pid_t pid = fork();
  if (pid < 0)
  {
    perror("DEBUG: kyocera-inv: fork");
    return (1);
  }
  if (pid == 0)
  {
    /* child */
    /* CUPS filter argv: 1=job-id 2=user 3=title 4=copies 5=options [6=file] */
    if (argc >= 4 && argv[3] && strlen(argv[3]) > 40)
      argv[3] = (char *)"print-job";
    if (tmp_fd != 0)
    {
      dup2(tmp_fd, 0);
      close(tmp_fd);
    }
    lseek(0, 0, SEEK_SET);
    if (out_fd != 1)
    {
      dup2(out_fd, 1);
      close(out_fd);
    }
    lseek(1, 0, SEEK_SET);
    argv[0] = (char *)KYO_FILTER;
    execv(KYO_FILTER, argv);
    fprintf(stderr, "DEBUG: kyocera-inv: exec %s failed: %s\n", KYO_FILTER,
            strerror(errno));
    _exit(111);
  }

  int st;
  close(tmp_fd);
  while (waitpid(pid, &st, 0) < 0 && errno == EINTR)
    ;
  if (!WIFEXITED(st) || WEXITSTATUS(st) != 0)
  {
    fprintf(stderr, "DEBUG: kyocera-inv: filter failed (status %d)\n", st);
    return (WIFEXITED(st) ? WEXITSTATUS(st) : 1);
  }

  fprintf(stderr, "DEBUG: kyocera-inv: P-record(s) patched: %d\n",
          patch_paper_flag(out_fd));

  /* Stream the patched KPSL to CUPS. */
  lseek(out_fd, 0, SEEK_SET);
  while ((w = read(out_fd, buf2, sizeof(buf2))) > 0)
    full_write(1, buf2, (size_t)w);
  close(out_fd);
  return (0);
}

Шим, через который PPD зовёт обёртку:

#!/bin/bash
{ echo "=== $(date +%T)"; for a in "$@"; do echo "[$a]"; done; } >> /tmp/kyo_args.log
KYO_NOINVERT=1 KYO_DUMP=/tmp/kyo_last.raster exec /usr/lib/cups/filter/kyocera-inv-rastertokpsl.bin "$@"

Бэкенд CUPS — прямая запись в /dev/usb/lp0:

#!/bin/bash
# lp0direct — write print data straight to /dev/usb/lp0 (+tee for debugging)
device=/dev/usb/lp0
if [ "$#" -eq 0 ]; then
  echo "direct lp0direct \"Unknown\" \"Kyocera TASKalfa 1800 via $device (direct)\""
  exit 0
fi
if [ -n "$7" ]; then
  exec tee /tmp/lp0_last.kpsl < "$7" > "$device"
fi
exec tee /tmp/lp0_last.kpsl > "$device"

Опрос дисплея аппарата по PJL:

import fcntl, struct, select, sys, time

def read_status(f, timeout=1.5):
    out = b''
    end = time.time() + timeout
    while time.time() < end:
        r, _, _ = select.select([f], [], [], 0.3)
        if r:
            chunk = f.read(8192)
            if chunk:
                out += chunk
                end = time.time() + 0.4
    return out

pjl = (b'\x1b%-12345X@PJL\r\n'
       b'@PJL INFO STATUS\r\n'
       b'\x1b%-12345X')

with open('/dev/usb/lp0', 'r+b', buffering=0) as f:
    f.write(pjl)
    resp = read_status(f, 3.0).decode('cp437', 'replace')
    for line in resp.splitlines():
        if line.startswith('CODE=') or line.startswith('DISPLAY='):
            print(line)

Источники и лицензии

  • rastertokpsl_A3 и базовый PPD — официальные бинарники Kyocera из пакета Linux driver 8.1305 (проприетарные; комплект предназначен для использования с собственным аппаратом).
  • Обёртка, бэкенд и скрипты — написаны в ходе этой диагностики, используйте свободно.
  • Проверено на Manjaro (ядро 7.x, CUPS 2.4); та же связка PPD+фильтра месяцами работает на Kubuntu 26.04.

Печатайте молча. 🖨️