EXP C03 — Repartir sur de bonnes bases : Raspberry Pi OS Bookworm 32 bits

EXP C03 — Repartir sur de bonnes bases : Raspberry Pi OS Bookworm 32 bits

Après notre première tentative avec Debian Trixie 64 bits, nous avions une décision à prendre.

Fallait-il continuer à chercher une solution dans cet environnement ?

Ou fallait-il repartir sur une base différente, mieux adaptée à notre objectif ?

La question n’était finalement pas de savoir si le 64 bits était « meilleur » que le 32 bits.

La vraie question était :

Quel environnement nous donne les meilleures chances de faire fonctionner une imprimante et un pilote vieux de vingt ans ?

Notre réponse fut :

Raspberry Pi OS (Legacy) Lite — Bookworm — 32 bits.

Ce choix pouvait sembler moins moderne que Trixie 64 bits.

En réalité, il était beaucoup plus cohérent avec notre projet.

Pourquoi revenir au 32 bits ?

La Raspberry Pi Zero 2 W possède un processeur capable de fonctionner en 64 bits.

Mais notre serveur d’impression n’avait pas besoin des possibilités supplémentaires qu’aurait pu offrir une architecture 64 bits.

Nous avions besoin de quelques éléments essentiels :

Raspberry Pi Zero 2 W
        │
        ├── Linux system
        ├── network
        ├── print server
        └── Canon driver

Le dernier élément était justement celui qui posait problème.

Les anciens pilotes Canon n’étaient plus disponibles directement dans Debian, et les paquets historiques visaient essentiellement les architectures x86/i386. Sur ARM, la situation était donc beaucoup plus compliquée.

Une possibilité restait cependant particulièrement intéressante :

Compiler nous-mêmes le pilote libre CAPT de Nicolas Boichat.

Pour cela, nous voulions partir sur l’environnement qui introduisait le moins de complications possibles.

Le vieux pilote change la donne.

Le projet CAPT que nous avions retrouvé appartenait à une autre génération de Linux.

Nous ne savions pas encore exactement quelles adaptations seraient nécessaires pour le compiler sur notre Raspberry.

Mais une chose était claire : plus le logiciel est ancien, plus l’environnement dans lequel on tente de le compiler devient important.

Nous avions donc décidé de privilégier un environnement 32 bits.

Il ne s’agissait surtout pas de déclarer :

« Le 32 bits est meilleur que le 64 bits. »

Notre raisonnement était beaucoup plus simple :

« Pour ce projet précis, le 32 bits nous donne probablement de meilleures chances. »

La compilation du pilote allait ensuite permettre de vérifier cette hypothèse.

Bookworm plutôt que Trixie.

Nous avons donc choisi de revenir à une génération précédente de Raspberry Pi OS basée sur Debian Bookworm.

Le choix était volontairement conservateur.

Bookworm restait suffisamment moderne pour constituer une base sérieuse pour notre serveur, tout en nous donnant un environnement que nous jugions plus favorable à l’utilisation d’un logiciel Linux historique.

Notre raisonnement pouvait se résumer ainsi :

Debian Trixie 64-bit
        │
        │ modern system
        │ very old driver
        ▼
      doubt
        │
        ▼
Raspberry Pi OS Bookworm 32-bit
        │
        │ compromise
        ▼
     CAPT driver

Nous ne cherchions plus le système le plus récent.

Nous cherchions le terrain le plus favorable à notre vieille Canon.

Installation de Raspberry Pi OS Lite.

Cette fois, nous avons également voulu garder le Raspberry aussi simple que possible.

Nous n’avions absolument pas besoin d’un environnement graphique.

Le serveur devait être :

• petit ;
• silencieux ;
• économe ;
• administrable à distance ;
• dédié à l’impression.

Nous avons donc choisi :

Raspberry Pi OS (Legacy) Lite — Bookworm — 32 bits.

L’installation a été réalisée avec Raspberry Pi Imager.

Le système était configuré pour démarrer avec notre utilisateur admin, le Wi-Fi et SSH étant déjà préparés par l’outil.

Le nouveau serveur a reçu le nom :

PrintLBP

et l’adresse IP :

192.168.1.40

Pas de bureau graphique.

Pas d’applications inutiles.

Simplement une petite machine Linux destinée à devenir notre serveur d’impression.

C’était exactement l’esprit du projet depuis le début :

small board
   +
small system
   +
small service
   =
small print server

Première vérification : quelle architecture avons-nous réellement ?

Une fois le nouveau système installé, nous avons immédiatement voulu vérifier que nous étions bien dans l’environnement choisi.

Deux commandes suffisaient :

uname -m

puis :

dpkg --print-architecture

Le Raspberry nous répondit :

armv7l

puis :

armhf

Nous avions donc :

Kernel architecture : armv7l
Debian architecture : armhf

Autrement dit, notre Pi Zero 2 W fonctionnait désormais avec une pile 32 bits ARMHF.

C’était exactement l’environnement que nous avions choisi pour poursuivre l’expérience.

Pourquoi ARMHF était intéressant pour notre projet.

Le choix devenait particulièrement pertinent si nous devions réellement compiler le pilote CAPT.

Nous avions maintenant :

Raspberry Pi Zero 2 W
        │
        ├── ARMv7
        ├── armhf
        └── Raspberry Pi OS Bookworm

Et nous n’avions pas besoin d’émulation x86.

C’était important puisque les anciens paquets Canon propriétaires disponibles historiquement visaient essentiellement x86/i386.

Notre stratégie devenait donc :

Ne pas essayer de faire entrer artificiellement un ancien pilote x86 dans la Pi, mais utiliser directement son code source libre et le compiler pour notre environnement ARM.

La théorie était maintenant posée.

Il fallait passer à la pratique.

Construire le serveur avant de brancher l’imprimante.

Une autre décision importante fut de séparer les problèmes.

Nous n’avions toujours pas connecté la Canon.

C’était finalement une bonne chose.

Cela nous obligeait à construire le serveur proprement avant de nous précipiter sur le pilote.

Notre démarche devenait :

Raspberry Pi
     ↓
   system
     ↓
  network
     ↓
   CUPS
     ↓
   Avahi

et seulement ensuite :

USB
 ↓
Canon LBP-810
 ↓
CAPT
 ↓
driver

Cette séparation nous permettait de savoir exactement dans quelle couche chercher en cas de problème.

Et cette partie du socle était déjà fonctionnelle : sur notre installation fraîche, CUPS et Avahi étaient actifs, tandis que le pilote CAPT et la Canon restaient encore à mettre en place.

Le serveur commence à exister.

Pendant que nous attendions encore le câble USB, le Raspberry commençait donc à prendre sa forme définitive.

Le Wi-Fi fonctionnait.

Le système était en Bookworm 32 bits.

L’architecture était armhf.

CUPS et Avahi constituaient déjà la base du service.

L’objectif était désormais très clair :

   Home network
          │
          ▼
   Raspberry Pi Zero 2 W
          │
      Bookworm armhf
          │
   ┌────────┴────────┐
   │                 │
  CUPS              Avahi
   │                 │
   └────────┬────────┘
            │
           USB
            │
            ▼
       Canon LBP-810

À ce stade, le câble USB était encore attendu et le pilote n’était pas installé.

Mais le projet avait changé de nature.

Nous n’étions plus simplement en train d’essayer différentes distributions.

Nous avions maintenant une architecture.

Et maintenant, le câble.

C’est probablement à partir de là que le projet allait devenir vraiment concret.

Jusqu’ici, nous avions essentiellement travaillé sur le système.

La Canon était encore physiquement séparée du Raspberry.

Mais le câble était en route.

Et dès qu’il serait arrivé, nous n’allions surtout pas commencer par installer un pilote.

Notre premier réflexe serait beaucoup plus simple :

lsusb

Puis :

dmesg | tail -50

et :

lpinfo -v

Ces trois commandes allaient nous permettre de savoir si Linux reconnaissait réellement la Canon et si CUPS voyait un périphérique USB exploitable.

Avant le pilote, il fallait vérifier le matériel.

Une petite victoire avant même la première impression

Nous avions donc maintenant :

🟠 Debian Trixie 64-bit
        ↓
        ↓ change of strategy
        ↓
🟢 Raspberry Pi OS Bookworm
   32-bit / armhf
        ↓
🟢 Raspberry Pi Zero 2 W
        ↓
🟢 Wi-Fi network
        ↓
🟢 CUPS + Avahi
        ↓
🟠 Canon LBP-810
        ↓
🟠 CAPT driver

Et une chose était devenue très claire :

Nous ne faisions pas simplement fonctionner une vieille imprimante.

Nous étions en train de construire autour d’elle un petit serveur d’impression autonome.

Le plus amusant, c’est que nous ne savions absolument pas encore jusqu’où cette décision allait nous emmener.

À suivre …

(04) — Construire le serveur : CUPS, Avahi et PrintLBP

Le système est maintenant en place.

Dans le prochain chapitre, nous allons nous occuper de la partie réseau :

CUPS, Avahi, PrintLBP.local, le port 631 et l’accès au serveur depuis un autre ordinateur.

L’objectif est simple :

avoir un serveur d’impression fonctionnel avant même de brancher la Canon.

Et puis…

Le câble USB va enfin arriver.

AxehGo & DebIA — Independent Research & Experiments in Linux, AI and Statistical Computing