Traceur de dessin

Manuel

apprentiLAB dispose de traceurs de dessin de récup, un Roland DXY-1100, un DXY-1200, et un DXY-1250 mais ce dernier ne semble pas fonctionner.

Ils permettent de faire des tracés 2D au stylo (ou autre) sur du papier.

Ce sont de vieilles machines, mais il existe quelques hacks pour adapter des fichiers SVG et la piloter depuis une Raspberry Pi notamment.

Exemples emblématiques, exemples inspirants de ce qui se fait ailleurs avec ce type de machine :

• Superbe installation de la biennale Nemo 2021, un traceur dessinant des paysages martiens à l'aide d'un algorithme qui rend des vues topographiques depuis des données transmises par satellite : http://www.glkitty.com/pages/orbistertius-fr.html
• (en) Un DXY-990 qui écrit automatiquement les tweets d'un hashtag Twitter : https://noise.getoto.net/tag/liege-hackerspace/
• (en) Des plans de cadastre : https://alex.nisnevich.com/blog/2018/09/15/plotting_land_use_maps.html
• (en) Les tableaux de l'artiste Vera Molnár dans les années 70 : https://www.surfacemag.com/articles/vera-molnar-in-thinking-machines-at-moma/
• (en) un peu d'art génératif avec Michelle Chandra : https://www.dirtalleydesign.com/blogs/news/how-to-draw-prints-with-an-axidraw-pen-plotter
• et on peut scroller sans fin sur le hashtag #plottertwitter, où on trouve pas mal d'art génératif au plotter → https://twitter.com/hashtag/plottertwitter

Le DXY-1200 possède un plateau électrostatique, qui permet de maintenir le papier plaqué lorsque la machine est branchée et le bouton Paper Hold allumé. NE JAMAIS LE NETTOYER AVEC DE L'EAU, sous peine de l'abîmer.

Le DXY-1100 possède lui un plateau magnétique, on peut maintenir le papier à laide de bandelettes métalliques

C'est la partie mobile de la machine, avec une pince pour saisir un stylo

8 emplacements pour disposer différentes couleurs ou qualités de stylos / feutres / crayons.

La machine possède deux ports d'entrée : un série et un parallèle. On utilisera le port série, qui a un connecteur DB-25 femelle. Il nous faut donc un adaptateur pour le raccorder en USB à notre ordinateur. Les connecteur se trouvent sous la machine.

C'est une série d'interrupteurs qui se trouvent sous la machine, et servent à la configurer. On trouve également un tableau de configuration des DIP switches moulé en relief dans le plastique sous la machine. Celui-ci n'étant pas forcément très lisible, nous l'avons décalqué :

On lit ces paramètres de droite à gauche, voici quelques explications mais c'est également bien détaillé dans le manuel utilisateur Roland :

• Switch-2 :
  • Baud Rate : vitesse de transmission de données pour la communication. Valeurs possibles : 150, 300, 600, 1200, 2400, 4800, 9600 baud. On le met en général à 9600 (001), car c'est le réglage standard dans les libs qu'on va utiliser (notamment Chiplotle), et que c'est le réglage le plus rapide. Plus d'explications : https://fr.wikipedia.org/wiki/Baud_(mesure)
  • Dataflow : Normal (0) ou Y-drop. Le mode Y-drop c'est quand un ordinateur est connecté à un terminal, et qu'on raccorde le plotter en Y, ce n'est à priori pas un cas de figure qu'on reproduirait aujourd'hui.
  • Parity : None, Even ou Odd (Nulle, Paire ou Impaire). On choisit ce réglage selon comment c'est réglé sur le logiciel ou driver qu'on utilise pour la communication série sur l'ordi (avec Chiplotle, None (00), mais on peut aussi le changer dans la config de Chiplotle…).
  • Data : 8 bits ou 7 bits. Idem, vérifier au niveau du logiciel/driver… Ici 8 bits (0)
  • Stop bit : 1 bit ou 2 bits. Idem, le plus souvent 1 bit (0)
  • Command mode : type de commandes RD-GL I (0) ou DXY-GL, RD-GL I est proche du HPGL, plus standard et utilisé par Chiplotle (les commandes sont des mots de 2 lettres séparées par un ;). Explications simples par ici : https://lesporteslogiques.net/wiki/materiel/plotter_roland_dxy-1200#langage_de_commande
  • Unit : seulement pour le mode DXY-GL, mais ce n'est pas celui qu'on utilise, laisser donc à 0
• Switch-1 :
  • Character : jeu de caractères, voir l'appendice C de la référence RD-GL : https://archive.org/details/rolanddxy130012001100commandreferencemanualaf/page/n143/mode/2up. Le jeu de caractère peut aussi être réglé par la commande CS, passant alors outre ce réglage du DIP switch, on peut donc le laisser sur le jeu 0000, l'ASCII de base.
  • Input : depuis quelle entrée on va lire les commandes, or on se branche sur le port série, donc 1
  • Expand : pour utiliser toute la surface de dessin, et bypasser le format de papier (voir ci-dessous). 1 pour activer ce paramètre
  • Paper size : format du papier, on aura en général du A4 (01) ou A3 (00). Ce réglage n'est pas actif si Expand l'est.
  • Kanji mode : pour le japonais, inutile, laisser à 00

Config par défaut de Chiplotle. Fichier de config dans $HOME/.chiplotle/config.py (pour trouver $HOME : echo $HOME) :

baudrate = 9600
bytesize = 8
parity = 'N'
stopbits = 1
timeout = 1
xonxoff = 1
rtscts = 0

Donc config des DIP switches : 0010000000 ; 0000110000

• Mot : description

La pince à crayon/stylo/feutre de la machine est assez large, et ne peut pas saisir n'importe quel stylo qu'on utilise pour écrire à la main. La machine est normalement fournie avec des stylos (dont certans rechargeables avec des cartouches d'encre de stylo plume) adaptés qui se fixent dans les emplacements prévus à cet effet.

Il faudrait donc acheter des stylos pour plotter Roland DXY :

• Rotring (rechargeables) https://www.shanelty.com/index.php?route=product/product&product_id=7626
• Feutres, pas en stock : https://www.walmart.com/ip/Alvin-Pen-Plotter-3mm-Hp-Asst-Fine/824306393
• Lot de 5 bille noirs : https://signwarehouse.com/collections/plotter-pens/products/ball-point-pens-standard-black-5-pack
• Bille, noir, pressurisé : https://signwarehouse.com/products/graphtec-pressurized-ball-point-pen

Ils sont tous assez chers, il vaudrait mieux faire un adaptateur pour stylos, par exemple des feutres stabilo à pointe fine.

Tentative en cours sur le nuage : https://nuage.apprentilab.cnam.fr/s/zt6SeoKxtSrTJqi — 2022/09/15 : le stylo rentre ! par contre la pince a du mal à le reposer, sans doute est-il trop gros… Le petit rebord s'imprime assez mal, peut-être que ça bloque aussi car il est plus large que prévu à cause des bavures → supports, ou faire en deux parties…

— 2022/10/03 : nouvelle version, minimale, plus rapide à imprimer. Il faudra virer le petit rebord et rallonger légèrement le corps pour que ce soit plus facile à mettre dans le magasin.

Ressources :

• https://www.thingiverse.com/thing:3217072/files → trop étroit, tester quand même si la machine le prend
• https://www.thingiverse.com/thing:2061432 → pas le bon stylo
• Modèles paramétriques avec OpenSCAD : https://github.com/juliendorra/3D-printable-plotter-adapters-for-pens-and-refills
• (en) (video) Refilling or Replacing Vintage HP Plotter Pens, il y a notamment des cotes pour un adaptateur maison, ce sont à peu pour HP et Roland : https://www.youtube.com/watch?v=h-oj4HrTH14

Pour brancher le port série (RS232, DB-25) de la machine à un ordinateur moderne sans port série, il faut passer par l'USB. Ça n'est pas du tout trivial…

Il est difficile de trouver des convertisseurs-adaptateurs USB ↔ DB-25, alors on va mettre dans un premier temps un adaptateur DB-25 ↔ DB-9 (le DB-9 a moins de broche et est plus répandu), puis un adaptateur Null Modem (DB-9 DB-9), puis un convertisseur DB-9 ↔ USB. Ça tombe bien, il y avait justement tout ça dans un carton avec les machines. Le seul câble qui manque pour l'instant c'est un DB-9 femelle-femelle car on doit raccorder le Null modem (mâle) au convertisseur (mâle), on l'a donc fait avec des jumpers F/F pour l'instant…

Le convertisseur USB doit avoir un chip FTDI, comme requis par chiplotle : https://chiplotle.readthedocs.io/en/latest/chapters/hardware/index.html#usb-to-serial-adapters Celui qu'on a n'est pas étiqueté, on ne savait donc pas s'il y avait un chip dedans, cependant, quand on va dans le device manager de Windows, le driver du port COM qui apparait s'appelle FTDI, donc c'est bon…

Pour plus de détails, voir la section Câblage

• papier
• dimensions max : A3

• Inkscape : pour dessiner en vectoriel et convertir
• Processing + lib HPGL : pour générer des dessins depuis le langage graphique Processing → https://github.com/ciaron/HPGLGraphics — ref : https://micycle1.github.io/PGS/allclasses.html
• HPGL viewer : pour visualiser un fichiers HPGL → http://service-hpglview.web.cern.ch/service-hpglview/
• hp2xx : idem → https://www.gnu.org/software/hp2xx/
• Python : pour communiquer des commandes à la machine, à l'aide la lib Chiplotle
  • (en) site de Chiplotle, installation, etc. : http://sites.music.columbia.edu/cmc/chiplotle/
  • (en) documentation : https://chiplotle.readthedocs.io/en/latest/index.html
• WinLine : driver propriétaire Windows pour utiliser le plotter comme une imprimante → https://www.winline.com/
• HPGL Sender : pour envoyer des fichiers HPGL à son plotter Roland via une interface web (sur Raspberry Pi) : https://github.com/LgHS/hpgl-sender

Régler la taille de la page dans les propriétés du document (A4 ou A3, format portrait ou paysage).

Dessiner en vectoriel, voir la page de Inkscape pour plus de détails…

On ne va pas faire un guide de programmation sous Processing, il y a déjà des super ressources pour ça sur le site officiel : https://processing.org/tutorials Pour commencer rapidement à prendre en main le langage, aller voir dans Fichier/Examples, ou encore parcourir les démos créées par les utilisateurs sur https://openprocessing.org/

Coder ou trouver un sketch intéressant et adapté au traçage (voir les règles plus bas). On ne va générer qu'une seule image, on n'a donc pas besoin de la boucle draw(), on peut tout faire dans le setup().

Pas de background(….

Attention, on ne pourra pas utiliser les fill pour “couvrir” des éléments, il faudra trouver des techniques pour contourner, par exemple les opérations booléennes de la lib PGS.

Les techniques de tramages peuvent être intéressantes pour cette machine, surtout celles à base de hachures : Tramage d'une image pour la sérigraphie ou la gravure de tampons

Éviter de convertir bêtement un PDF (par exemple un export de fiche technique avec vues en coupe de FreeCAD, etc. Les résultats sont souvent mauvais, car les objets sont parfois constitués de formes superposées, ou de traits qui sont en réalité des chemins pleins…

Convertir son fichier en .HPGL (Fichier/Exporter… choisir le format HPGL)

Importer la lib HPGL Graphics

import hpglgraphics.*;

Puis, dans le setup, déclarer un objet HPGL :

void setup() {
  HPGLGraphics hpgl = (HPGLGraphics) createGraphics(width, height, HPGLGraphics.HPGL);
  hpgl.setPaperSize("A4"); // Format du papier
  hpgl.setPath("NOMDUFICHIERHPGL.hpgl"); // Nom du fichier output

Mettre le code du dessin à l'intérieur d'un record :

  beginRecord(hpgl);
  // on écrira ici le code de dessin, les beginShape, shape(...), etc.
  endRecord();

Le logiciel permet de visualiser le rendu de son fichier HPGL. Différentes couleurs sont utilisées pour les différents stylos (pens), ça peut se régler dans Edit/Options/HPGL Pens. Je n'ai pas l'impression qu'on puisse visualiser les commandes, en afficher l'ordre, etc.

Vérifier les marges en déplaçant la souris dans les coins du dessin et en regardant les coordonnées en bas à gauche (le logiciel n'affiche que le dessin, pas les limites de la page selon le format : A4…).

Brancher la machine en USB.

Allumer.

Placer les stylos dans les bons emplacements.

Placer le papier : bouger la tête à la position 0,0 (à l'aide des flèches) pour voir ou se situe le coin inférieur gauche, et bien aligner le reste de la page. Appuyer sur le bouton Paper Hold une fois que c'est placé, la table électrostatique s'active. Vérifier que le coin supérieur droit est bien à 29.7 , 21 (A4, paysage), ou autre si format portrait ou A3.

Ouvrir un terminal (Powershell sous Windows) et entrer chiplotle.

Pour lancer le fichier HGPL, entrer plotter.write_file('CHEMIN_VERS_LE_FICHIER_HGPL') (remplacer avec le bon chemin…)

Vérifier que tout se passe bien et notamment que le plotter prend bien les stylos.

Pour entrer des commandes à la main, utiliser l'API de Chiplotle, par exemple plotter.write(hpgl.SP(1)) pour prendre le feutre 1.

Ces commandes peuvent nous permettre d'écrire des scripts de dessin avec Python, ou encore d'utiliser les commandes d'écriture de texte de la machine (sans passer par un logiciel qui utilise une font, etc.).

Notons qu'il existe des fonctions “raccourcis”, par exemple plotter.select_pen(1) au lieu de plotter.write(hpgl.SP(1)). On peut aussi écrire plotter.write('SP1').

Plus de détails sur les commandes HPGL plus loin

On peut écrire du texte avec la commande LB. Il faut finir par un caractère ETX (x03, ♥).

Par exemple cette commande :

plotter.write('LBCOMMANDE CHIPLOTLE : ♥')

Donnera ceci : “COMMANDE CHIPLOTLE : ”

Réglages quand on a récupéré les machines : 9600 baud, Parity Odd, 8 bit data, Stop 1, Command RD-GL, 0.25mm unit ; French/German, Serial, Expand on, ISO A3, Kanji disabled

Réglages dans l'article Hackaday sur le DXY-990 :

• SW-2 (left one in picture above): 100 (baud 9600), 0 (D), 1 (EN), 1 (even parity), 1 (7 data bits), 0 (1 stopbit)
• SW-1 (right one in picture above): 0000 (charset), 1 (serial), 0 (reserved), 11 (A4; 10 = A3), 00 (reserved)

Depuis Martian Wabbit (David Diaz) :

• Baudrate 9600, Databits 8, Parity None, Stop Bits 1, DTR and RTS ON.

Réglages finaux, adaptés à Chiplotle :

Il a été assez difficile de comprendre comment brancher la machine à l'ordinateur, sachant que celle-ci utilise un port série DB-25, que les ordinateurs modernes n'ont plus de port série, et encore moins en DB-25, et que la machine était stockée avec un lot divers d'adaptateurs. Après avoir essayé de les raccorder au pif, ça ne marchait pas, il a donc fallu creuser un peu la question. Au final, le problème venait surtout du fait qu'on avait à un moment de la chaîne d'adaptateurs, une fiche mâle à brancher sur une autre fiche mâle, c'était pas très intuitif à trouver au pif…

Il fallait aussi comprendre que dans notre cas de figure, on branche deux DTE (voir https://fr.wikipedia.org/wiki/%C3%89quipement_terminal_de_traitement_de_donn%C3%A9es) ensemble, et que ça nécessite donc de ne pas câbler droit nos fiches série, mais d'utiliser un adaptateur Null Modem. Plus de détails et de super schémas par ici (en) → http://wilbo666.pbworks.com/w/page/49320712/RS232.

Schéma récapitulatif de nos branchements :

Brochage du port Série sur l'appareil :

Quelques explications sur le brochage : https://fr.wikipedia.org/wiki/RS-232#Brochage — (en) la version anglaise a de meilleurs schémas : https://en.wikipedia.org/wiki/RS-232#Data_and_control_signals

On pourrait alléger les branchements en achetant un DB-25 Mâle ↔ DB-9 Femelle Null Modem. Par exemple chez Netram avec qui nous avons un marché : https://www.netram.fr/Catalogue-produits/Connectique/Adaptateur/Adaptateur-Audio-Vid-o/Cordon-s-rie-Null-Modem-DB9F-DB25M-1-80m.html

↑ Revenir à la section sur les adaptateurs

Récap de quelques commandes HPGL / RD-GL usuelles, afin de pouvoir se repérer dans nos fichiers HPGL :

• IN; : initialisation
• SP1; → Select Pen #1 : prend le stylo n°1 (de 1 à 8)
• PD;, PDXXXX,YYYY; → Pen Down : abaisse le stylo (pour tracer) et déplace la tête jusqu'au point de coordonnées XXXX,YYYY
• PU;, PUXXXX,YYYY; → Pen Up : remonte le stylo (pour se déplacer sans tracer) et déplace la tête jusqu'au point de coordonnées XXXX,YYYY
• formes :
  • lettre + mode + param : la première lettre indique le type de forme (cercle, rectangle plein, etc.), la deuxième lettre indique le mode (absolu A, relatif R), puis les paramètres sont en général les coordonnées
    • EA → Edge Rectangle Absolute : rectangle vide absolu
    • RR → Rectangle Relative : rectangle plein relatif
    • AA / AR : arc absolu/relatif autour d'un point central (XXXX,YYYY), selon un angle (-360 à 360), avec une résolution (précision de l'arc, qui sera en réalité une série de segments.
  • CI : cercle vide, avec un rayon et une résolution
• LB → Label : passe en mode écriture. Le point actuel devient le coin inférieur gauche du premier caractère qui suivra, jusqu'à réception d'un code d'interruption (par défaut  = x03 = ♥).

Voir aussi la liste des commandes supportées par Chiplotle : https://chiplotle.readthedocs.io/en/latest/chapters/api/hpgl.html

Référence complète des commandes de la machine : https://archive.org/details/rolanddxy130012001100commandreferencemanualaf/page/n47/mode/2up

(en) HP-GL Reference Guide : https://www.isoplotec.co.jp/HPGL/eHPGL.htm

• (fr) Plotter Roland DXY-1200 : doc similaire sur le wiki des Portes Logiques → https://lesporteslogiques.net/wiki/materiel/plotter_roland_dxy-1200
• (en) DXY-1150 User manual → https://www.manua.ls/roland/dxy-1150a/manual
• (en) DXY-990 User manual → https://archive.org/details/roland-dxy-990
• (en) DXY-980 User manual → https://archive.org/details/rolanddxy980operationmanual
• (en) DXY-880 User manual → https://archive.org/details/RolandDXY880PlotterOperationManual
• (en) Command reference → https://archive.org/details/rolanddxy130012001100commandreferencemanualaf/page/n7/mode/2up
• (en) Ressources sur le site de Roland (drivers, etc.) → https://www.rolanddga.com/support/products/cutting/dxy-1150-a-b-size-flatbed-pen-plotter
• (en) (vidéo) Roland DXY-1200 Pen Plotter controlled by Raspberry Pi using Chiplotle! → https://www.youtube.com/watch?v=_uQxSS-u3RQ
• (en) 1980s vintage pen plotter: quick start guide → https://hackaday.io/project/12276-roland-dg-dxy-990
• (en) Notes on a Roland DXY-1150 → https://martianwabbit.com/2019/10/25/notes-on-a-roland-dxy-1150.html
• (en) Getting a HP 7550A plotter to work under Linux (infos sur le brochage des connecteurs DB notamment) → http://www.alfredklomp.com/technology/plotter/
• (en) list of resources and tools for plotter and drawing robot enthusiasts → https://drawingbots.net/resources
• (en) (video) Set up a vintage Roland DXY-980A Pen Plotter Using a USB to Serial Port Adapter to run on Windows (avec WinLine, quelques infos sur le câblage) → https://www.youtube.com/watch?v=Wvy2IBB9ecw
• (en) An Intro to Pen Plotters : intro sur les commandes HPGL, quelques exemples en commandes puis avec Processing → https://medium.com/quarterstudio/an-intro-to-pen-plotters-29b6bd4327ba
• (en) Awesome plotters : dans la série des Awesome lists, cette page sur Github liste des ressources de qualité, triées. On y trouve à la fois des ressources hardware, pour fabriquer des plotters soi-même, software, pour dessiner/contrôler son plotter, mais encore des références d'évènements, d'artistes qui utilisent ces machines, etc. → https://github.com/beardicus/awesome-plotters#inspiration-instruction-and-research
• (en) HP-GL Reference Guide → https://www.isoplotec.co.jp/HPGL/eHPGL.htm

• (en) Pen Plotter Art & Algorithms, Part 1 → https://mattdesl.svbtle.com/pen-plotter-1 — Part 2 → https://mattdesl.svbtle.com/pen-plotter-2
• (en) HackSpace magazine — Issue 55 : Build a plotter → https://hackspace.raspberrypi.com/issues/55
• (en) Surface Projection : liste et tutos d'algorithmes de projection avec des dessins vectoriels en une seul ligne, très adapté au plotter → https://nb.paulbutler.org/surface-projection/
• (en) TSP Art : Traveling Salesman Problem Art, ou comment générer des images en dessin vectoriels en une ligne à l'aide du problème du voyageur de commerce : https://wiki.evilmadscientist.com/TSP_art