DOMOSYS.ORG

Matrix RSS

2026-03-30T00:00:00+02:00

c’est un article bidon

Dans Element (application de messagerie instantannée sécurisée sur le réseau Matrix), il y a la possiblité d’ajouter des widgets à base d’URL fournies, notamment pour les flux RSS

Or il s’avère que le site www.domosys.org a un flux RSS d’intégré.

Voilà pourquoi j’écris cet article : pour voir la réaction à la création du présent article

C’est juste un test, quoi ^^’

Pareil, mais mieux

Donc : ça fonctionne bien :

Maintenant, le mieux est quand même de faire un template un peu plus évolué

Sans trop charger non plus

Emails et PGP

2026-02-27T00:00:00+01:00

Introduction

Personne ne signe ni ne chiffre ses e-mails. Je ne comprends pas.

Comme nous l’avons vu, l’ordinateur est l’ Outil de Traitement de l’Information

En ce sens que : les mails sont formés selon des conventions d’écriture du contenu, comme du protocole de communication, afin d’en assurer l’échange.

Les standards sont publiés à l’IETF :

RFC 5322 – Format des messages Internet (en-têtes, corps, etc.)
RFC 5321 – Simple Mail Transfer Protocol (SMTP)
etc

Mais il est alors facile de se faire passer pour quelqu’un d’autre lors de l’envoi du mail, en changeant simplement la clause ‘From:’.

C’est là qu’intervient le PGP (Pretty Good Privacy), de Philip Zimmermann, depuis 1991.

Commentaire

Oui oui : '91 !😳
Càd : on a tout ce qu'il faut depuis des lustres, mais on magouille de nouveaux "services", ou des retours de mail en confirmation
et autres "entrez votre code reçu par mail/SMS"

"Est-ce bien vous qui avez envoyé le mail ?"
- Oui c'est moi ! Mon mail est signé.

On a déjà un code : PGP : il est unique et vérifiable.

C'est un peu comme TOUT dans cette société ... Du Climat aux pesticides, en passant par les "services", on ajoute des rustines à des problèmes qu'on a nous-mêmes engendrés, quitte à les aggraver, en ayant balayé d'un revers de main la base des connaissances ... 👍️

Mais qui de mieux que les spécialistes des mails sécurisés pour vous en expliquer le procédé : Proton Mail

Mais il n’y a aucun problème à ce que vous puissiez faire ça vous-même, au contraire : personne ne peut/doit le faire à votre place : votre clé privée doit rester entre vos mains et lisible par personne d’autre.

GNU Privacy Guard

sudo apt install gpg

Hack caméra PTZ

2026-02-25T00:00:00+01:00

Introduction

J’avais fait l’acquisition, il y a longtemps, d’une caméra-dôme PTZ (Pan-Tilt-Zoom) de surveillance, sur IP ethernet -pas WIFI-, placée à l’extérieur, à l’angle du toit pour un angle de vue maximal.

Problème : son interface de gestion est en Java, et je n’ai jamais eu l’intention de faire tourner du java sur mes PC.

Par chance, cette caméra possède un accès SSH.

J’ai donc entrepris d’investiguer son fonctionnement.

Fonctionnement interne

Sans la moindre surprise : c’est du Linux !

parfeu iptables
connexion SSH
flux caméra rtsp (avec login/passwd)
Pilotage PTZ sur DBus
Commandes internes CGI, pour la partie http

HTTP

Au début, j’avais juste fait un hack en “auditant” les commandes passées par http sur le site

Bilan : la session est renégociée à chaque fois, ce qui fait que le temps de réaction est assez pénible.

SSH

Même chose : une commande passée individuellement, renégocie le login (ça reste une petite machine) → latence importante.

DBus

Il y a de quoi faire :

$ grep -E "<(interface|method|property|signal)" PTZ.Coordinator.xml
  <interface name="org.freedesktop.DBus.Introspectable">
    <method name="Introspect">
  <interface name="org.freedesktop.DBus.Properties">
    <method name="Get">
    <method name="Set">
    <method name="GetAll">
  <interface name="com.axis.PTZ.Coordinator">
    <method name="Command">
    <method name="UpdateStaticProperties">
    <method name="GetStaticProperties">
    <method name="RegisterDriver">
    <method name="Queue">
    <method name="GetDriverName">
    <method name="GetSupportParameters">
    <method name="SetDevicePreset">
    <method name="RemovePresetNumber">
    <method name="RemovePresetName">
    <method name="UpdatePreset">
    <method name="CreatePreset">
    <method name="SetPresetNumber">
    <method name="SetPresetName">
    <method name="OsdMenu">
    <method name="FieldAngles">
    <method name="QueryZoomDelim">
    <method name="QueryPosition">
    <method name="QueryPresets">
    <method name="QuerySpeed">
    <method name="AreaZoom">
    <method name="GetAuxiliary">
    <method name="Auxiliary">
    <method name="Image">
    <method name="GotoHome">
    <method name="GotoDevicePreset">
    <method name="GotoPresetNumber">
    <method name="GotoPresetName">
    <method name="MoveLL">
    <method name="MoveCmd">
    <method name="Move">
    <method name="MovePTZ">
    <signal name="PtzStaticPropsUpdated">
    <signal name="PtzParametersSetup">
    <signal name="DriverUninstalled">
    <signal name="DriverState">
    <signal name="DriverCapabilities">
    <signal name="SpeedControlEnable">
    <signal name="DefaultSpeed">
    <signal name="PtzPreset">
    <signal name="PtzAction">
    <signal name="PtzMoveEnabledChanged">
    <signal name="PtzLockedChanged">
    <signal name="PtzEnabledChanged">
    <signal name="CamPort">
    <signal name="TiltFlipped">
    <signal name="PanFlipped">
    <signal name="CtlQueueEnabled">
    <property name="TiltFlipped" type="b" access="read"/>
    <property name="PanFlipped" type="b" access="read"/>
    <property name="DriverExtraCapabilities" type="i" access="read"/>
    <property name="DriverMoveCapabilities" type="i" access="read"/>
    <property name="Name" type="s" access="readwrite"/>
    <property name="PTZEnabled" type="b" access="readwrite"/>
    <property name="PTZLocked" type="b" access="readwrite"/>
    <property name="CamPort" type="i" access="readwrite"/>
    <property name="Various" type="s" access="write"/>
    <property name="Support" type="s" access="write"/>

Méthode

Je créé donc une instance SSH persistante (avec échange de clés), à partir d’un petit script bash, appelé par mon appli Python/GTK :

#!/bin/sh
START_CMD='ssh -M -S ~/.ssh/cam_mux -fNT user@cam'
STOP_CMD='ssh -S ~/.ssh/cam_mux -O exit user@cam'
case "$1" in
  start) eval $START_CMD ;;
  stop)  eval $STOP_CMD  ;;
  *) echo "usage: $0 [start|stop]"; exit 2 ;;
esac

Dans l’application :

cmd = f'ssh -S {self.ssh_socket} {self.user}@{self.host} \
            dbus-send --system {command_line}'

Et voilà !

IA de détection

En ce qui concerne l’IA de détection, j’utilise tensorflow, avec le modèle très light :

ssd_mobilenet_v2_coco_quant_postprocess.tflite 6,2M

à cette adresse :

https://github.com/google-coral/edgetpu/tree/master/test_data

Pour mon petit ordi, ça fait le taf, sans être trop gourmand en ressources (sur CPU -pas de GPU-)

Le Code

Aujourd’hui, j’ai au final une interface GTK de pilotage complet, avec IA de détection de présence et identification⁽¹⁾, tracking automatique, tours de garde, enregistrement automatique et alerte via un bot sur mobile avec snapshot (capture d’image).

⁽¹⁾ Je ne fais pas pour l’heure de véritable contrôle d’identité automatisée (ça reste encore intrusif et peu légal). Uniquement de l’identification de formes : chat/chien/voiture/personne/…

y’a écrit “cat” - ‘faut que je change la couleur 😋 -

Améliorations en cours

En ayant installé sur mon VPS un serveur matrix-synapse (matrix.domosys.org), j’ai pu développer un bot en Python pour l’y connecter.

Ainsi, à détection de présence, le bot nous envoit un message via l’application Element sur mobile, avec une capture d’image. Nous pouvons alors lui passer un appel en Visio-conférence, et nous avons la caméra en direct.

Conclusion

Évidemment la caméra d’origine ne faisait pas tout ça, et le modèle n’est même plus vendu, ni même mis à jour… Merci !

J’étais bon pour en acheter une autre, alors qu’elle fonctionne parfaitement et que j’ai pas les moyens !

Finalement, je me suis tout simplement retrouvé dans la même situation que Richard Stallman avec sa Xerox -histoire bien connue des Libristes : c’est la base de tout !-.

Et enfin, mon obligation morale tiendrait de fournir le code de mon hack, sous licence GNU/GPL. Il me faudra m’employer à le finaliser et le poster en ligne, afin que d’autres personnes dans le Monde possesseur du même modèle, bénéficient de ce travail.

NON : pas sur Github qui appartient à Micro$oft qui a donc là une mine de travail et d’idées gratuits, pour vous vendre ses produits -payés avec vos impôts- !

Maison Ossature Bois

2026-02-24T00:00:00+01:00

Préambule

Nous avons eu à déménager 5 fois en une seule et même année.

Alors nous avons décidé de faire nous-mêmes notre lieu de vie.

Conception 3D

Nous avons entrepris de construire notre propre maison.

Le premier modèle 3D, comprenait un salon à l’étage, un escalier en colimaçon, une coursive panoramique, des fenêtres à hublot style bateau, et tout un tas d’autres idées farfelues.

Dans l’ensemble, je m’essayais surtout à la conception sous Blender, qui n’était pas vraiment fait pour à l’époque, mais qui pour moi, promettait monts et merveilles. (Aujourd’hui, de nombreuses améliorations faciliteraient grandement le travail !)

Mais problème primaire : le budget.

Une fois chiffré, j’ai repris tous les plans, pour faire quelque-chose de beaucoup plus simple, de moins cher, et de réalisable en autonomie sans y laisser tout notre temps, ni nous ruiner. (minimaliste, donc)

Après 2ans de conception, de budgétisation, et avoir trouvé un terrain, nacquis ce plan final.

J’avais un bon PC à l’époque…

Aujourd’hui, avec l’équipement que j’ai, je ne peux plus me permettre de tels projets…

Tout est pensé :

légèreté de l’ensemble (solivages, et pas de tuiles), adapté à la structure du terrain (pur argile)
souplesse tout bois (pour pallier aux rétractions/gonflements de l’argile)
isolation maximale (fibre de bois dans les murs, ouate de cellulose toit et sol, plaques de lin-chanvre dans les cloisons intérieures -isolation phonique-)
toit membrane blanche (réverbération du soleil)
mur de refend pour le solivage au sol, où le poêle de masse a été disposé en conséquence, avec orientation 45° pour optimiser le rayonnement infrarouge.
portée des poutres au plafond, calculée à l’aide d’un logiciel spécialisé en bureau d’études.
positions des pièces N-S/E-O, en fonction du confort voulu (ex: chambre au Nord-ouest pour plus de fraîcheur)
toilettes dites-sèches (Toilettes à litière bio-maîtrisée) -économie d’eau-
phyto-épuration -élaboration d’un dossier complet destiné au SPANC, avec contrôle-
parfaitement ajustée et aux mesures du plan du cadastre (projection sur un scan).
la terrasse a été conçue à postériori, ses angles sont une optimisation pour un total de 27m²

J’avais l’idée d’un toit végétalisé, mais niveau budget, ça m’obligeait à doubler l’ossature.

Orientation au Soleil

J’avais fait une animation en simulation des 3 courses du Soleil pour visualiser les projections d’ombres et ensoleillement résultant -économies de chauffage-

Solstice d’été
Équinoxe
Solstice d’hiver

Oui le Dérèglement Climatique nous rattrape. Heureusement que j’ai opté pour une membrane PVC/EPDM blanche pour le toit.

D’ailleurs le site lot.cadastre-solaire.fr nous considère comme un parking de castine… Amusant

Plan

La précision des cotes a permis de tout ajuster sans erreur (cloisons et autres dépendances), au centimètre près.

J’avais fait une édition des plans résultants sous QCAD, sur un eeePC qui est resté sur le chantier tout le long des travaux.

Visite virtuelle

À l’époque Blender avait encore des briques logiques d’interraction. (Même si j’ai beaucoup “scripté” en Python -gestion plus exhaustive-)

J’avais donc fait un “bonhomme” -rapide, pas un personnage complet-, qui nous permettait de nous déplacer dans la maison, donc de nous projeter pour mieux évaluer les déplacements fonctionnels quotidiens.

accéder à la cuisine avec les courses
aérer les toilettes le cas échéant (nous n’avions encore aucune expérience pratique pour les toilettes-sèches)
accès aux toilettes depuis l’extérieur -pour éviter de patauger-, et à part du reste de la maison
concevoir intelligemment le sens des ouvertures des portes
etc

Mobilier

Les meubles / objets (que nous avions déjà et ceux rapportés) ont été modélisés sur mesure.

Cuisine

La cuisine, a été élaborée en partenariat avec une cuisiniste.

une promo, évidemment

La 3D a été ajoutée à posteriori, avec des photos des matériaux, pour les textures.

Il manque les crédences et des pourtours de fenêtres.

Réel

le 8 août 2014:

J’ai inversé la porte du frigo et finalisé le montage de la hotte aspirante après la photo… :-)

Salon

Il manque quelques détails dans cette vue du salon.
ex: la plaque de protection sous le poêle.

Travaux

Nous avons fait, avec mon épouse, tout l’intérieur, à livraison de l’ossature.

17 mars 2011

2 avril 2011

5 avril 2011

20 avril 2011

Oui : on a abandonné le garage : tout simplement pas les moyens -on a tout misé sur l’isolation-.

Évidemment, on ne peut pas accueillir grand-monde, et niveau matériel, tout est également minimaliste.

La porte d’accès est donc condamnée de l’intérieur, en attente de moyens…

18 mai 2011

27 mai 2011

9 juin 2011

Avec les moyens du bord : mon fil à plomb : un tournevis percé par le manche, des rondelles en lestage, au bout d’une ficelle… Ça marche !

Un soin particulièrement apporté à ne pas percer inconsidérément le pare-vapeur.

NB: aujourd’hui, on fait de meilleurs matériaux de pare-vapeur…

10 juin 2011

18 juillet 2011

Quand j’ai reçu les plaques, j’étais seul.

Déposées dehors, il s’est mis à pleuvoir.

Je les ai toutes rentrées en 4ème vitesse, mais de part d’autre du mur de refend.

Je me suis rendu compte que ça fléchissait sous le poids.

Je les ai toutes remanipulées pour le répartir.

Exercice

28 juillet 2011

Le poêle bien positionné sur le mur de refend central, tout tournera autour…

Les premiers rails des cloisons, sont fixés selon les plans -décalage dû à la pente de toit, prévu-.

Les gaines: vers les prises et interrupteurs …

30 juillet 2011

Protection supplémentaire en laine-de-roche spécifique.

(j’ai déjà travaillé dans la pose de cheminées/inserts… dans la charpente/couverture aussi…)

3 août 2011

14 août 2011

Tout est prévu.

29 août 2011

Ça prend tournure…

1er septembre 2011

Oui : la longueur des plaques de BA13 était anticipée.

De même que le type :

ignifuge et isolation laine de roche derrière le poêle.
hydrofuge et isolation lin-chanvre pour la salle de bain

8 septembre 2011

Décrochage en faux-plafond esthétique, mais également en passage de gaines et ventilation…

12 septembre 2011

… en pensant cantonner les odeurs de cuisine à une zone cubique.

8 novembre 2011

Pose parquet … à 3 jours de l’installation…

12 novembre 2011

Oui : nous nous sommes installés le 11-11-11… presque.

24 décembre 2011

Mieux vaut un bain que de tenter de mitiger la température de l’eau…

5 février 2012

Première fois qu’il neige autant dans ma région (de mémoire -la mienne-)…

Le Dérèglement Climatique se manifeste…

7 février 2015

Bref : nous y sommes.

Sprite

2026-02-24T00:00:00+01:00

Pas une boisson

Il me semble intéressant de connaître ce concept, tant je trouve amusant d’avoir conscience de la façon dont ont été formalisés les modes d’affichage d’éléments à l’écran.

TODO

Fstrim

2026-02-23T00:00:00+01:00

Introduction

Un disque SSD (Solid State Disk), comme les disques M.2 (SATA ou NVMe), ne sont pas forcément synchronisés entre le contrôleur et votre kernel.

La commande fstrim permet donc d’informer le contrôleur que certains blocs logiques (NAND) sont libres.

Contrôle de disque

$ lsblk --discard
NAME              DISC-ALN DISC-GRAN DISC-MAX DISC-ZERO
sda                      0        0B       0B         0
└─sda1                   0        0B       0B         0
sdb                      0      512B       2G         0
├─sdb1                   0      512B       2G         0
└─sdb2                   0      512B       2G         0
  ├─vgsteel-sys          0      512B       2G         0
  ├─vgsteel-swap         0      512B       2G         0
  ├─vgsteel-home         0      512B       2G         0
  └─vgsteel-local        0      512B       2G         0
sdc                      0        0B       0B         0
└─sdc1                   0        0B       0B         0
sr0                      0        0B       0B         0

Ici, mon disque sdb présente :

DISC-GRAN (Discard Granularity)

👉 Taille minimale que le périphérique accepte pour une opération TRIM. Il accepte des TRIM à partir de 512 octets minimum. (c’est très précis)

DISC-MAX (Discard Maximum)

👉 Taille maximale qu’on peut envoyer en une seule commande TRIM. Le kernel peut envoyer jusqu’à 2 Go de discard en une seule commande. (c’est bien)

Les autres disques sont des disques-durs classiques (à disques magnétiques), et ne sont donc pas concernés.

sous Debian

Debian a un contrôle programmé, pré-installé :

$ systemctl status fstrim.timer
○ fstrim.timer - Discard unused filesystem blocks once a week
     Loaded: loaded (/usr/lib/systemd/system/fstrim.timer; enabled; preset: enabl>
     Active: inactive (dead)
        Job: 163
    Trigger: n/a
   Triggers: ● fstrim.service
       Docs: man:fstrim

$ systemctl cat fstrim.timer
# /usr/lib/systemd/system/fstrim.timer
[Unit]
Description=Discard unused filesystem blocks once a week
Documentation=man:fstrim
ConditionVirtualization=!container
ConditionPathExists=!/etc/initrd-release

[Timer]
OnCalendar=weekly
AccuracySec=1h
Persistent=true
RandomizedDelaySec=100min

[Install]
WantedBy=timers.target

On peut voir ici, qu’il est exécuté une fois par semaine.

[Timer]
OnCalendar=weekly

Conclusion

Debian se charge de ce nettoyage, mais la raison pour laquelle j’en suis venu à investiguer en ce sens, provient du fait que mon propre disque commence à montrer des signes de faiblesse :

$ sudo smartctl -a /dev/sdb | grep -E "197|198|194"
194 Temperature_Celsius     0x0022  042  051  000  Old_age  Always  -  42 (0 18 0 0 0)
197 Current_Pending_Sector  0x0012  100  100  000  Old_age  Always  -  2
198 Offline_Uncorrectable   0x0010  100  100  000  Old_age  Offline -  0

2 Pending Sectors → Pas bon !

$ sudo fstrim -v /
/ : 21,9 GiB (23496540160 octets) réduits

$ sudo smartctl -a /dev/sdb | grep -E "197|198|194"
194 Temperature_Celsius     0x0022  042  051  000  Old_age  Always  -  42 (0 18 0 0 0)
197 Current_Pending_Sector  0x0012  100  100  000  Old_age  Always  -  0
198 Offline_Uncorrectable   0x0010  100  100  000  Old_age  Offline -  0

→ Récupérés ! Soulagé !

Oui un disque qui montre des signes de faiblesse de la sorte, j’ai déjà connu ça : quand le crash se profile, sans sauvegardes, c’est le drame !

Espion Chinois

2026-02-21T00:00:00+01:00

un Routeur mal-routé

En 2024, après 6 mois de relances chez Free pour obtenir une connexion fibre chez moi, j’ai finit par couper les ponts.

J’ai alors décidé d’opter pour une connexion Internet via le réseau 4G, qui avec les smartphones, dépassait largement notre connexion ADSL en terme de débit.

Me voilà parti pour m’enquérir d’un routeur 4G.

Vu les prix, je finis par opter pour un routeur Tenda sur Amazon.

Je reçois l’appareil, jusque-là, tout va bien.

Installation et configuration

Je le connecte, suit la procédure pour le trouver sur le réseau, et commence à le configurer.

Puis là, je commence à déceler des comportements étranges !

En particulier, sur mon réseau, en ce qui concerne les requêtes DNS.

Quand vous tapez une adresse dans votre navigateur, la première étape est d’obtenir l’adresse IP correspondante, afin que votre navigateur puisse s’y rendre.

SAUF QUE : pour n’importe quel nom tapé (google.com ou n’importe quoi d’autre), la réponse était la même !

j’ai fait une capture d’écran :

Curieux de l’affaire, ne comprenant pas ce qu’il se passe, je me dis que le mieux est de savoir à qui appartient cette adresse IP !

sur Internet, pour savoir à qui appartient une adresse IP, il suffit de faire une requête ‘whois <adresse>‘, mais on peut faire la recherche directement sur des sites spécialisés

Voilà donc la capture d’écran de la requête ‘whois’ sur un site dédié :

l’Espion Chinois

Même si cette requête pourraît ne se faire que pour une pré-configuration de l’appareil, -ce qui reste une possibilité-, lorsque vous le branchez chez vous sans chercher à comprendre, vous annoncez donc directement votre présence à ce centre de recherche universitaire chinois !

Personnellement, je n’ai rien demandé !!

De plus, l’appareil s’impose directement sur le réseau : il me faisait sauter mes configurations DHCP locales !

le DHCP est un serveur qui fournit une adresse IP libre (ou fixée), sur votre réseau, en se chargeant de fournir les adresses de serveurs DNS, de l’adresse IP du routeur qui fera passerelle vers l’Internet, etc

Alors me voilà parti pour investiguer plus avant !

Je scanne alors les ports du routeur. -commençant vraiment à avoir de fameux doutes quant à la sécurité du fait de la présence de cette machine chez moi !

Une adresse IP possède 65 536 ports sur lesquels différents services (serveurs) peuvent écouter. Il y a des ports réservés -standards- et des ports aléatoirement choisis au-delà du port 1024. Ces ports aléatoires, sont ouverts pour le retour de communication avec les serveurs (en gros).

Et qu’est-ce que je découvre !?

Le port 12345 netbus est ouvert, disponible à la connexion !

le port 12345 netbus est historiquement un port utilisé pour ce que l’on appelle : une backdoor -porte dérobée pour Trojan-

Encore une piste que cet appareil est dangereux !!!

Même si on peut faire écouter n’importe quoi sur n’importe quel port, ce n’est de surcroît pas le seul…

Sécurisation

Alors je l’ai isolé de mon réseau en le plaçant sur un VLAN tagué, à l’aide de mon switch manageable.

Verrouillé toute connexion provenant directement de son IP avec le parefeu.

Et tout désactivé dessus : DNS, DHCP, WIFI, … TOUT sauf la connexion Internet ! (qu’il serve quand même à quelque-chose, sinon je n’avais plus le Net…🙄😬 )

Conclusion

Quand on achète des appareils dits-noname (qui ne sont pas garantis par une grande marque qui y perdrait toute légitimité), on se retrouve confronté à de graves enjeux de sécurité chez soi !

J’ai tenté d’alerter en écrivant un commentaire sur Amazon …

Il n’a jamais été accepté malgré mes insistances !

Et vous pouvez lire vous-mêmes les commentaires des autres possesseurs sur le site :

“Ça marche !”

– Oui oui… “ça marche”

Mais personne ne sait par où passent ses données (moi non plus malgré mes réglages -je ne peux pas faire mieux-), et je doute fortement qu’elles passent les tuyaux en toute transparence !

J’ai alerté l’ARCOM… J’attends toujours une réaction…

Alors je vous invite à vous informer sur ce qu’est un ordinateur.

Dépannage Souris

2026-02-11T00:00:00+01:00

Introduction

J’avais une vieille souris MX Master de chez Logitech, (du temps où j’avais tous les services en ligne possibles), en panne.

Diagnostic

Le curseur ne bougeait plus à l’écran. Pourtant, tous les boutons, eux, fonctionnaient. Donc : pas de problème d’alimentation, ni de communication avec le PC.

Typiquement un seul élément hors service.

2 possibilités pour une défaillance du dispositif de suivi du mouvement :

soit la carte électronique (PCB / chipset / …)
soit une des 2 LEDs (émission/réception)

Après démontage, rien d’anormal à l’intérieur. Pas de possibilité directe d’observer la LED émettrice (invisible : non rouge)

Après une simple observation, je vois, sous l’emplacement du support du pouce : une petite carte (PCB), avec indiqué dessus : “Hidden PCB”, soit “carte cachée”. (Amusant)

J’ai remarqué que le curseur se remettait à fonctionner, si je prenais garde de ne pas appuyer le pouce à son emplacement.

Après dévissage de la carte : effectivement, elle comporte un mini-interrupteur, qui, lorsqu’on appuie dessus, bloque le mouvement du curseur à l’écran.

Dépannage

J’ai tout simplement shunté l’interrupteur, et ma souris est repartie pour me servir quelques années encore !

Conclusion

Je ne vois pas d’autre explication qu’un énième dispositif d’obsolescence programmée. (en espérant me tromper !)

TuxKatana

2025-08-29T00:00:00+02:00

Introduction

Je possède un ampli guitare Boss Katana MK-II.

Les boutons d’interface permettent des réglages de base.

Mais en fait, il y a à l’intérieur tout un tas de programmes non référencés !

Pour les exploiter, il y a plusieurs applications :

l’application officielle (sous Window$) Boss Tone Studio
l’application mobile (Android) Librarian -notamment-
l’application sous Linux : FxFloorBoard

Bilan : évidemment, pour faire tourner l’application officielle, sous Linux, on peut le faire avec wine, mais c’est quelque-chose que je ne fais plus : me battre avec des systèmes que j’aborre : j’ai abdiqué.

J’utilisais alors Librarian sur une tablette Android.

Mais le sujet est quelque peu le même : une tablette Android, on ne maîtrise rien du tout. Même si j’avoue que cette aplication est plutôt bien faite.

Quant à FxFloorBoard, d’abord son aspect m’est assez peu ragoutant, mais surtout, elle fait chauffer mon CPU pour des raisons que j’ignore.

Alors j’ai décidé de développer ma propre application en #Python.

La méthode

J’ai tout d’abord fait fonctionner FxFloorBoard sur mon PC, connecté en USB au Boss Katana.

Ensuite, j’ai utilisé WireShark pour littéralement sniffer les communications entre les deux.

J’ai ensuite fait du reverse-engineering sur les trames enregistrées, en faisant plusieurs scripts me permettant de relever les variations et corrélations, jusqu’à pouvoir en déduire le fonctionnement du protocole.

Développement

Ceci fait, je n’ai plus eu qu’à créer des classes d’objet (notamment MIDI -128bits- en messages SysEx spécifiques)

class MIDI_Bytes

import logging
from lib.log_setup import LOGGER_NAME
log = logging.getLogger(LOGGER_NAME)

class MIDIBytes:
    def __init__(self, mb=None, length: int = None):
        if mb is None or mb == '':
            self.bytes = []
            return
        if isinstance(mb, int):
            if length is None:
                length = max(1, (mb.bit_length() + 6) // 7)
            mb = self.int_to_hexstring(mb, length)
        if isinstance(mb, list):
            mb = " ".join(f"{c:02X}" for c in mb).strip()
        parts = mb.strip().split()
        if not parts:
            self.bytes = []
            return
        try:
            vals = [int(p, 16) for p in parts]
        except ValueError:
            raise ValueError(f"Invalid Hex byte: {parts}")
        for v in vals:
            if v < 0 or v > 0x7F:
                raise ValueError(f"Invalid MIDI byte: 0 < {v} < 0x7F")
        if length and len(vals) < length:
            diff = length - len(vals)
            vals = [0]*diff + vals
            self.length = length
        self.bytes = vals

    def __str__(self):
        return " ".join(f"{b:02X}" for b in self.bytes)

    def __repr__(self):
        return f"{self.__class__.__name__}('{self.__str__()}')"

    def __eq__(self, other):
        if not isinstance(other, (Address,MIDIBytes,)):
            return NotImplemented
        return self.bytes == other.bytes

    def __lt__(self, other):
        if not isinstance(other, MIDIBytes):
            return NotImplemented
        return self.to_int() < other.to_int()

    def __le__(self, other):
        if not isinstance(other, MIDIBytes):
            return NotImplemented
        return self.to_int() <= other.to_int()

    def __gt__(self, other):
        if not isinstance(other, MIDIBytes):
            return NotImplemented
        return self.to_int() > other.to_int()

    def __ge__(self, other):
        if not isinstance(other, MIDIBytes):
            return NotImplemented
        return self.to_int() >= other.to_int()

    def __add__(self, other):
        if not isinstance(other, (int, MIDIBytes,)):
            return NotImplemented
        else:
            if isinstance(other, int):
                value = self.to_int() + other
                return MIDIBytes.from_int(value, len(self.bytes))
            else:
                return MIDIBytes(self.bytes + other.bytes)

    def __getitem__(self, i):
        return self.bytes[i]

    def __setitem__(self, i, value):
        if isinstance(i, slice):
            if isinstance(value, MIDIBytes):
                self.bytes[i] = value.bytes
            elif isinstance(value, list):
                self.bytes[i] = value
            else:
                raise TypeError("slice assignment requires list or MIDIBytes")
        else:
            if isinstance(value, int):
                if not (0 <= value <= 0x7F):
                    raise ValueError("MIDI byte must be in 0..127")
                self.bytes[i] = value
            else:
                raise TypeError("single item must be int")

    def __len__(self):
        return len(self.bytes)

    def __iter__(self):
        return iter(self.bytes)

    @property
    def int(self) → int:
        return self.to_int()

    @property
    def bool(self) → bool:
        if len(self.bytes) > 1:
            raise ValueError(f"Cannot convert multi-byte {self} to bool")
        if len(self.bytes) == 0:
            log.warning(f"midi_bytes.py:108- len(self.bytes) == 0")
            return False
        return self.bytes[0] != 0

    @property
    def str(self) → str:
        return str(self)

    def to_gtype(self, val_type: str):
        # log.debug(f"{val_type=}")
        if val_type == 'gboolean':
            return self.bool
        elif val_type == 'gint':
            return self.int
        elif val_type == 'gchararray':
            return self.str
        elif val_type == 'gdouble':
            return float(self.int)
        else:
            log.warning(f"midi_bytes.py:127-Not recognized GType: {val_type}")
            return self

    def to_int(self) → int:
        value = 0
        n = len(self.bytes)
        for i, b in enumerate(self.bytes):
            shift = 7 * (n - 1 - i)
            value |= (b & 0x7F) << shift
        return value

    def to_chars(self) → str:
        chars = ''.join(chr(b) for b in self.bytes)
        return chars

    @staticmethod
    def int_to_hexstring(value: int, length: int) → str:
        if not isinstance(value, int):
            raise TypeError("value must be int")
        if value < 0:
            raise ValueError("value must be >= 0")
        maxval = 1 << (7 * length)
        if value >= maxval:
            raise OverflowError(f"value {value} not containing in {length} 7bits bytes")

        parts = []
        for i in range(length):
            shift = 7 * (length - 1 - i)
            parts.append((value >> shift) & 0x7F)
        return " ".join(f"{b:02X}" for b in parts)

    @classmethod
    def from_int(cls, value: int, length: int = None):
        if length is None:
            length = max(1, (value.bit_length() + 6) // 7)
        return cls(cls.int_to_hexstring(value, length))

class Address(MIDIBytes):
    def __init__(self, addr=None):
        if isinstance(addr, Address):
            log.debug(f"Double declaration of {addr}")
            return
        super().__init__(addr, length=4)

    def __add__(self, other):
        if not isinstance(other, (int, MIDIBytes,)):
            return NotImplemented
        if isinstance(other, int):
            value = self.to_int() + other
            return Address.from_int(value, len(self.bytes))
        if isinstance(other, MIDIBytes):
            return MIDIBytes(self.bytes + other.bytes)

    def __hash__(self):
        return self.int

    def __sub__(self, other):
        if isinstance(other, Address):
            val_s = self.to_int()
            val_o = other.to_int()
            return abs(val_s - val_o)
        elif isinstance(other, int):
            value = self.to_int() - other
            return Address.from_int(value, len(self.bytes))
        return NotImplemented

le plus pénible en fait, c’est surtout l’organisation de l’interface, et le passage de messages entre classes, pour la prise en compte de tous les changements en messages Glib.

Disclaimer

Je n’ai pas totalement terminé : les enregistrement de presets ne sont pas fonctionnels, mais je m’en sers régulièrement en direct, pour me faire des réglages sur le vif, et ça fonctionne plutôt bien !

le petit plus miraculeux, étant le Tuner intégré !

Publication

le code est ici : https://framagit.org/s4mdf0o1/TuxKatana

et la doc générée par IA, ici : https://deepwiki.com/s4mdf0o1/TuxKatana

Il y a bien une vidéo de démo, mais de très très mauvaise qualité. Je voulais juste tenter, c’est pas du tout un truc qui m’amuse, donc… Peut-être que je retenterai un jour…

Postface

le code du Tuner, qui peut être utilisé à part, est ici : Guit_tunix

(j’en avais fait une version dans le terminal)

Iso-tuteur

2023-01-09T00:00:00+01:00

Passion Géodésique

J’ai un goût prononcé pour les structures géodésiques.

En effet, ce sont des structures, dont la légèreté par rapport à la solidité est sans égal.

Le principe étant une conception isocaédrique permettant une répartition parfaite des charge.

J’aimerais bien faire une serre-dôme, mais pour les tests, il me fallait faire une maquette, et tant qu’à faire : utile.

J’ai alors pensé à faire un support pour plante (ici un simple potos).

Tout ce qu’il me restait à faire, c’est concevoir les pièces sous #Blender, afin de pouvoir les imprimer en 3D.

Tests

D’abord quelques test de solidité d’accroche sur les baguettes bois sélectionnées (baguettes de ~2m en magasin de bricolage)

Modélisation 3D

Le diamètre des baguettes mesuré au pied à coulisse numérique, la longueur déterminée en fonction des étages voulus.

Et modélisation des supports en mesurant l’épaisseur et le diamètre du pot destinataire, modélisé, lui aussi :

NB: les couleurs sont celles dont je disposais en filament.

Capture d’écran de la modélisation sous #Blender :

Et on peut évidemment, monter à l’infini.

Impression 3D

Les pièces résultantes :

NB: j’ai passé un temps fou à tailler les impressions-support au cutter !

Montage

Les pièces destinées à être posées sur le rebord du pot, en pointe pour entrer dans la terre.

NB: j’ai pas forcé sur la qualité des impressions : le temps a déjà été bien assez conséquent (quand la pièce ne se décollait pas du plateau → au rebus !)

J’ai retiré la pièce rouge : le filament, un peu trop vieux, s’était chargé en humidité, et a fait des micro-bulles et des fils à l’impression, rendant la pièce cassante.

Final

Résultat au 23 janvier 2023

NB: les pièces blanches sont en fait phosphorescentes… Très pratique à l’extinction des feux ^^’

Aujourd’hui, ça a poussé ! (j’irai prendre une photo…)

Perchoir Béziers

2017-01-20T00:00:00+01:00

Simple expérimentation

En conception 3D sous Blender, il y a les courbes de Béziers.

Je les utilisait peu, j’ai juste voulu tester en y trouvant une utilité pratique.

Au final, pour les oiseaux, ce n’est pas si pratique… Trop petit 😕

Hack Roomba

2016-02-06T00:00:00+01:00

Introduction

On avait acheté un des premiers aspirateurs dits-autonomes :

un Roomba de chez I-robot.

Pas mal : il tournait dans la maison, seul, selon un parcours quelque-peu aléatoire, sans autre capteur que celui du choc frontal, et retournant à sa base de chargement, à partir de rayons infrarouges. (un truc du genre)

Sauf que : nos tabourets hauts (que vous pouvez voir dans la 3D), ont un pied circulaire au sol, dans lequels il avait tendance à se bloquer.

Sans compter, certainement un de mes pricipaux défauts : les câbles !

… une fâcheuse tendance à “avaler” les câbles. 😒

Dans cet esprit, je voulais voir s’il n’était pas possible d’améliorer son parcours … en le guidant moi-même.

Expérience

Je ne me souviens plus exactement, mais il me semble que j’avais trouvé sur Internet son protocole et le câblage de sa prise DIN d’administration sur le dessus.

Composants

C’était en février 2016 : il y avait encore peu de matériel Libre de disponible.

Mais j’avais sous la main une Rasperry Pi (model B, je crois), avec un dongle Wifi, alimentée par un adaptateur d’allume-cigare/USB de voiture (oui il y a un semblant de 12V continu de disponible à partir des batteries, et la Raspberry s’alimente en 5V via USB…).

Pour finir, un simple adaptateur USB-Serial TTL Arduino, le tout branché sur la DIN, et voilà !

Programme

J’ai retrouvé le code dans les “oldies” 😁

~src/oldies/hack_roomba/ $ tree pycreate/
pycreate/
├── controller.py
├── create.py
├── dance.py
├── graphics.py
├── light.py
├── move.py
├── readme.rst
├── sense.py
├── sound.py
├── test
│   ├── test_dance.py
│   ├── test_light.py
│   ├── test_move.py
│   ├── test_sense.py
│   ├── test_sound.py
│   └── test_via.py
├── test.py
├── via.py
└── wander.py

2 directories, 18 files

Un simple PySerial, qui envoit les codes appropriés.

Aujourd’hui, les équipements sont plus élaborés (et plus compliqués d’accès pour certains totalement fermés), mais la démarche est la même : c’est faisable !

Démo

Je sais qu’on a une vidéo filmée par mon épouse, sur laquelle je le démarre de mon PC portable… si je remets la main dessus…