Logiciel Juqiao Glove : pilote, API Python, ROS2

Étape 1 — Installation

Installez le package juqiao-glove

Le gant communique via USB CDC série – pas de modules de noyau, pas de pilotes personnalisés. Le package Python se termine pysérie et gère le protocole de trame binaire.

Tout système d'exploitation pris en charge Le gant apparaît comme un périphérique série CDC-ACM standard. Windows, macOS et Linux l'énumèrent tous automatiquement avec les pilotes de la boîte de réception. Aucun installateur de pilote fournisseur requis.

# Python 3.10+ recommended
installateur pip juqiao-gant

# Or with optional visualization extras (matplotlib, numpy)
pip install "juqiao-gant[viz]"

# Or with ROS2 bridge extras (requires ROS2 Humble or later)
pip installe "juqiao-glove[ros2]"

Vérifiez l'installation :

python -c "importer juqiao_glove; print(juqiao_glove.__version__)"
# Expected: 0.4.x or later

Étape 2 — Détection des ports

Détection du port USB

Branchez le gant via le câble USB-C de 1,5 m. L'appareil est répertorié comme un port série CDC-ACM.

OS	Nom de port typique	Remarques
Linux	/dev/ttyACM0	Ajouter un utilisateur à numérotation groupe si autorisation refusée
macOS	/dev/tty.usbmodem*	Utiliser ls /dev/tty.usb* pour trouver le nom exact
Fenêtres	COM3 (plongeuses)	Vérifiez le Gestionnaire de périphériques → Ports (COM et LPT)

Détecter automatiquement le gant depuis Python :

de juqiao_glove importateur JuqiaoGlove

# Auto-scan all serial ports and return the first Juqiao device found
gant = JuqiaoGlove.find() imprimer (gant.port)   # → '/dev/ttyACM0' or 'COM3' etc.
imprimer(gant.info()) # → firmware version, node count, sample rate

Ou spécifiez le port explicitement :

avec = JuqiaoGlove(port="/dev/ttyACM0", débit en bauds=3000000)

Erreur d'autorisation Linux ? Courir sudo usermod -aG numérotation $USER puis déconnectez-vous et reconnectez-vous. Vous pouvez également utiliser sudo chmod 666 /dev/ttyACM0 pour une solution de contournement en une seule session.

Étape 3 — API de diffusion en continu

API de diffusion Python

Le gant diffuse à 200 Hz. Chaque image contient un tableau de pression de 64 éléments (ADC 16 bits, normalisé 0,0 à 1,0) plus un horodatage.

de juqiao_glove importer JuqiaoGlove heure d'importation gant = JuqiaoGlove.find() gant.connect()

# Single-frame read
frame = gant.read_frame() imprimer (frame.timestamp)          # float, seconds since epoch
imprimer (cadre.pressions)          # np.ndarray shape (64,), float32, range 0.0-1.0
imprimer(frame.pressions.reshape(8, 8)) # 8×8 spatial grid

# Continuous callback stream
def on_frame(cadre): max_node = frame.pressions.argmax() print(f"t={frame.timestamp:.4f} Peak_node={max_node} val={frame.pressions[max_node]:.3f}") gant.stream(callback=on_frame, durée=5.0)  # stream for 5 seconds

# Or use as an iterator
avec Glove.stream() comme frames : pour cadre dans cadres : processus (cadre) si c'est fait : pause gant.disconnect()

Référence de l'objet cadre

Attribut	Cône	Description
frame.timestamp	flotter	Temps de réception côté hôte (secondes, époque Unix)
cadre.pressions	np.ndarray (64,)	Pression normalisée par nœud, 0,0 (aucun) à 1,0 (max)
frame.pressions_raw	np.ndarray (64,)	Nombre brut d'ADC 16 bits (0 à 65 535)
cadre.contact_mask	np.ndarray(64,) combinateur	Vrai lorsque la pression dépasse le seuil (par défaut 0,05)
frame.contact_nodes	Liste[int]	Indices des nœuds actuellement en contact
frame.grasp_region	str ou Aucun	Région heuristique : "palmier", "pouce", "indice", "milieu", "anneau", "pinky", Aucune
frame.séquence	int	Compteur de trames (boucle à 65535) ; utiliser pour détecter les images perdues

Référence — Disposition du capteur

Disposition du capteur à 64 nœuds

Les 64 taxels sont disposés sous forme d'une matrice de fibres tissées recouvrant la paume et les cinq segments des doigts. Les indices de nœuds suivent un ordre cohérent des rangées principales en vue dorsale.

0–12

Paume (pavé central)

13–23

Pouce (3 segments)

24–34

Indice

35–45

Majeur

46–54

Annulaire

55–63

Petit doigt

# Access region slices by name
à partir de juqiao_glove.layout importer REGION_SLICES palm_nodes = frame.pressions[REGION_SLICES["palm"]] thumb_nodes = frame.pressions[REGION_SLICES["thumb"]] index_nodes = frame.pressions[REGION_SLICES["index"]]

# Reshape to 8×8 spatial grid (dorsal view, row-major)
grille = frame.pressions.reshape(8, 8)

Facultatif — Visualisation

Visualisation de la carte thermique de pression

Le [à savoir] extra installe un moteur de rendu de carte thermique matplotlib en direct utile pour l'étalonnage et le débogage.

# Requires: pip install "juqiao-glove[viz]"
de juqiao_glove importer JuqiaoGlove à partir de juqiao_glove.viz importer PressureHeatmap gant = JuqiaoGlove.find() gant.connect() viz = PressureHeatmap(title="Gant Juqiao — Pression en direct") à savoir.show (gant)  # Opens a matplotlib window; press Q to quit

Pour les environnements sans interface graphique ou l'examen des données, enregistrez les images sous forme de vidéo :

depuis l'importateur juqiao_glove.viz record_heatmap_video record_heatmap_video( input_npy="session_pressions.npy",  # shape (N, 64) saved during recording
    output_mp4="heatmap.mp4", images par seconde = 30, colormap="inferno", )

Facultatif — ROS2

Interface ROS2

Le juqiao_glove_ros2 le package publie un fichier personnalisé TactileArray message à 200 Hz. Compatible avec ROS2 Humble et Iron.

# Install the package (requires ROS2 to be sourced)
pip installe "juqiao-glove[ros2]"

# Or build from source in your workspace
cd ~/ros2_ws/src clone git https://github.com/roboticscenter/juqiao_glove_ros2 cd ~/ros2_ws && colcon build --packages-select juqiao_glove_ros2

Lancez le nœud du pilote :

source /opt/ros/humble/setup.bash source ~/ros2_ws/install/setup.bash

# Auto-detect port
lancement de ros2 juqiao_glove_ros2 gants.launch.py

# Specify port explicitly
ros2 lance le port juqiao_glove_ros2 Glove.launch.py ​​​​​​:=/dev/ttyACM0

Sujets publiés :

Sujette	Type de message	Taux	Description
/juqiao_glove/tactile_array	juqiao_glove_ros2/TactileArray	200 Hz	Réseau de pression complet à 64 nœuds
/juqiao_glove/contact_mask	std_msgs/UInt8MultiArray	200 Hz	Contact binaire par nœud (0 ou 1)
/juqiao_glove/grasp_region	std_msgs/Chaîne	200 Hz	Heuristique de région active ou chaîne vide
/juqiao_glove/status	diagnostic_msgs/DiagnosticStatus	1 Hz	Version du micrologiciel, taux de chute d'images

Lancement combiné Orca Hand + Glove

Lorsque vous utilisez le gant avec l'Orca Hand pour un enregistrement synchronisé :

# Launch Orca Hand driver
ros2 lance orca_ros2 orca_hand.launch.py ​​​​​​​​port :=/dev/ttyUSB0

# In a second terminal, launch Juqiao Glove driver
ros2 lance le port juqiao_glove_ros2 Glove.launch.py ​​​​​​:=/dev/ttyACM0

# Verify synchronized topics
liste de sujets ros2 | grep -E "orque|juqiao" sujet ros2 hz /juqiao_glove/tactile_array sujet ros2 hz /orca_hand/joint_states

Étape 4 — Calibrage

Étalonnage de base

Le gant est livré avec un étalonnage en usine. Recalibrez si vous remarquez une dérive de la ligne de base (nœuds lisant une valeur différente de zéro au repos) ou après un stockage prolongé.

Retirez le gant avant de calibrer L'étalonnage capture la ligne de base de pression nulle. Ne portez pas et ne touchez pas le gant pendant la séquence d’étalonnage – posez-le à plat sur une surface.

# CLI calibration — lay glove flat, do not touch
python -m juqiao_glove.calibrate --port /dev/ttyACM0

# Or from Python
de juqiao_glove importer JuqiaoGlove gant = JuqiaoGlove.find() gant.connect() gant.calibrate_baseline (durée = 3,0)   # averages 3 seconds of idle frames
gant.save_calibration("~/.juqiao_glove_cal.json") gant.disconnect()

Charger l'étalonnage au moment de l'exécution :

gant = JuqiaoGlove.find() gant.connect() gant.load_calibration("~/.juqiao_glove_cal.json")

# Now frame.pressures reflects calibrated values
frame = gant.read_frame() print(frame.pressions.max())  # Should be ~0.0 at rest

Réglage du seuil

Le seuil de contact par défaut est de 0,05 (5 % de la pleine échelle). Ajuster par tâche :

# For delicate objects (lower threshold detects light touch)
gant.set_contact_threshold(0.02)

# For heavy manipulation tasks (reduce false positives)
gant.set_contact_threshold(0.10)

# Per-region thresholds
gant.set_contact_threshold({"paume": 0,08, "pouce": 0,03, "index": 0,03})

Dépannage

Problèmes courants

SerialException : [Errno 13] Autorisation refusée : '/dev/ttyACM0'

Courir sudo usermod -aG dialout $USER puis déconnectez-vous et reconnectez-vous. Alternativement : sudo chmod 666 /dev/ttyACM0 (se réinitialise au débranchement).

JuqiaoGlove.find() n'a renvoyé aucun - aucun appareil trouvé

Vérifiez la connexion USB. Courir dmesg | tail -20 (Linux) ou ls /dev/tty.usb* (macOS) pour vérifier que le système d'exploitation a énuméré le périphérique. Essayez un autre port ou câble USB (le connecteur est USB-C mais doit être un câble de données, et non un câble de charge uniquement).

Les 64 nœuds lisent 0,0 — aucune donnée de pression

Appel glove.info() pour confirmer que le firmware répond. Si c'est le cas, vérifiez que le fichier d'étalonnage ne soustrait pas trop. Supprimer ~/.juqiao_glove_cal.json et recalibrez avec le gant posé à plat.

Dérive de la ligne de base – les nœuds lisent 0,1 à 0,2 au repos

Recalibrer : poser le gant à plat sans pression et exécuter glove.calibrate_baseline(). Peut survenir après des changements de température ou un stockage prolongé. Si la dérive > 0,4 avec le gant à plat, le tissu de détection devra peut-être être remplacé (contactez l'assistance Juqiao).

Chutes d'images – saut des numéros de séquence

Vérifiez la qualité et le port du câble USB. Utilisez un port USB 3.0. Sous Linux, évitez les hubs USB avec d’autres périphériques à large bande passante. Assurez-vous que votre on_frame le rappel revient rapidement - effectuez un traitement lourd dans un thread séparé.

Le nœud ROS2 démarre mais aucun message sur /juqiao_glove/tactile_array

Vérifiez l'argument du port : ros2 launch juqiao_glove_ros2 glove.launch.py port:=/dev/ttyACM0. Vérifiez les journaux des nœuds : ros2 node info /juqiao_glove_driver. Assurer le dialout Le correctif de groupe a été appliqué à l'utilisateur exécutant le nœud ROS2.

Configuration du logiciel et du pilote