Généralités

Cela fait maintenant près de 15 ans que je m'intéresse aux machines d'usinage à commande numérique et aux solutions logicielles et matérielles pour piloter celles-ci. Cela m'a donné l'occasion de mettre en œuvre sur des machines diverses des solutions logicielles complètes que ce soit sur PC sous Linux ou Windows ( LinuxCNC/EMC2, Mach 2, Mach3, Mach4), que des solutions sur OrangePi (AllWinCNC), aussi bien que des solutions embarquées avec interface légère (GRBL, TinyG2, Marlin, Smoothieware, etc..).

Sur cette durée, c'est assez spectaculaire comme il est devenu de plus en plus aisé de manipuler ces technologies. Les limitations de départ (prix, bugs, vitesse d'interprétation et nombre d'entrées sorties) sont repoussées à chaque itération.

Une bonne partie des solutions fonctionnant sur des cartes autonomes ont été largement inspirées par GRBL. Ce petit logiciel sur Arduino a en effet démontré la possibilité d'interpréter du GCODE (langage de programmation des machines à commande numérique) et de piloter des moteurs avec un petit microprocesseur. Il a servi de base ou inspiré des générations de makers et est à la base du développement de l'impression 3D grand public et de bien des machines low cost. Il a été depuis porté sur de nombreuses plateformes matérielles (autres microprocesseurs que celui de l'Arduino) ou adapté pour répondre à des besoins spécifiques. GRBL a de plus profité de la démocratisation des processeurs 32 bits en étant porté sur de plus puissants processeurs que ceux d'ATMEL/Arduino (STM32, ESP32, Texas, LPC1769, etc...).

Cette fois ci nous allons nous intéresser à la dernière évolution du logiciel de Bart Ding : FluidNC. Le portage de GRBL sur esp32 ayant manifestement atteint ses limites, un tout nouveau projet a été créé, avec une communauté de près d'une trentaine de développeurs pilotée par Mitch Bradley et Bart Ding. Et le moins qu'on puisse dire, c'est qu'avec l'expérience acquise, ils sont allés très vite pour proposer une solution hors du commun.

ESP32 ?

L'ESP32 est un SOC (System on Chip) embarquant 2 processeurs Tensilica Xtensa LX6 fonctionnant jusqu'à 160 Mhz. L'un est dédié aux télécommunications (Wifi), l'autre aux programmes utilisateur, bien que l'on puisse tout à fait utiliser les 2 cœurs dans une application. Avec ses nombreux périphériques, c'est un ordinateur complet dans une seule puce.

Le LX6 est en fait un SIP (Semiconductor Interllectual Property core), c'est à dire le "code source silicium" permettant de fabriquer un processeur. Il est commercialisé sous licence par Cadence. Tout comme l'ESP8266 (son prédécesseur et petit frère monocœur), Il repose sur une architecture Harvard ( https://fr.wikipedia.org/wiki/Architecture_Harvard ).

Les 2 processeurs peuvent chacun accéder à la mémoire et au périphériques sur un bus partagé. La plupart des périphériques ont eux même un accès direct à la mémoire par DMA (Direct memory Access) ce qui en fait une architecture très performante. (pour plus d'infos, voir https://en.wikipedia.org/wiki/ESP32 )

Avec une fréquence de 160Mhz (240 sur certains produits), du Wifi et du Bluetooth 4 LE intégré, cela fait une solution idéale pour motoriser bon nombre de projets DIY et même pro. On est donc très loin de l'Arduino de base 8 bits / 16 Mhz ! Surtout à 5 euros la carte....

FluidNC

FluidNC est le logiciel que nous allons installer sur notre ESP32 pour piloter une CNC ou découpe laser.

Caractéristiques :

FluidNC, reprend les bonnes idées de GRBL/ESP32 et ajoute d'autres fonctionnalités :

  • Pas de nécessité de compiler le firmware pour s'adapter à une carte particulière. C'est un fichier de configuration au format YAML qui est lu au démarrage pour le paramétrer. C'était une idée clé de Smoothieware, qui n'a pas été beaucoup utilisée ailleurs et qui se révèle bien pratique pour les makers en herbe. En effet, plus besoin de compiler le firmware pour l'adapter à votre matériel, c'est le même pour tout le monde. C'est du coup également très simple pour le mettre à jour.
  • Mise à jour par USB ou OTA (wofi, over the air) du firmware.
  • Conception orientée objet, favorisant l'extensibilité. Une fonctionnalité = un objet logiciel.
  • Couche d’abstraction matérielle pour les fonctionnalités machines comme les broches, lasers, moteurs, et contrôleurs moteurs pas à pas. Il est doc facile de lier un objet aux ressources matérielles.
  • Support des cinématiques cartésiennes, corexy, midtbot, wallplotter permettant de faire des machines aux caractéristiques et géométries les plus diverses.
  • Multiples interface de contrôle :
    • Interfaces série via usb, la plus classique
    • Interface Wifi ou Bluetooth (2 firmwares différents, car l'ESP32 ne peut faire que l'un ou l'autre, mais pas les 2)
      • en Wifi: interfaces complémentaires Webui (port 80), websocket (port 81), telnet (port 23), et donc possibilité de contrôler la machine par des solutions suportant le Wifi (Lightburn, bCNC, etc..)
      • en bluetooth, profil serial BT, et utilisation par une application mobile (pour le moment Android only...)
  • Support d'une carte SD externe pour le stockage des fichiers d'usinage / gravure, accessible par une interface web (WebUI). On peut ainsi lancer des fichier par l'interface web sur des fichiers stockés sur carte SD, la machine devenant autonome dans l'exécutiion, sans ordinateur branché.
  • Support d'un système de fichiers interne et indépendant de la carte SD pour stocker les fichiers de configuration, accessible également par WebUI
  • Dans la WebUI, pilotage de base de la machine (jog, recherche d'origine machine, déclenchement des broches, lasers et autres, et surtout lancement de l’exécution d'un fichier Gcode stocké sur carte SD. Il est également possible de créer des macros assignables à des boutons personnalisés.
  • Documentation très complète sur http://wiki.fluidnc.com/

Broches d'usinages / lasers:

Un grand nombre de types d'outils / broches sont supportés par Fluid NC:

  • 0>10V - Pilotage d'une broche avec vitesse proportionnelle à une tension (classique sur le contrôleurs VFD=Variable Frequency Drive).
  • PWM - Modulation de largeur d'impulsion, pour pilotage moteur DC
  • BESC - Pilotage d'un moteur Brushless de modélisme par contrôleur ESC (Electronic Speed Controler)
  • VFD - Pilotage de divers systèmes de commandes de broche VFD (Variable Frequency Drive) dialoguant en RS485 (laisiion série) comme les Huanyang, H100, YL620. Très bien pour piloter les plus grosses broches (jusqu'à 5Kw!)
  • DAC - Tension continue de 0>3.3V (8 bits)
  • HBridge - Pont en H en PWM. Supporte vitesse variable et 2 sens de rotation (ce qui permet un pilotage simplifié de moteur à courant continu à vitesse variable)
  • Relais - Le plus classique. On off, et peut supporter le sens de rotation avec 2 relais (On CW, On CCW). Permet aussi de supporter un solénoide (par exemple pour faire un pen up / down sur un wall plotter)
  • Laser - Pilotage en PWM, et active le mode "Laser" de FLuidNC (M3= constant power, M4 = Puissance variable). Le mode M4 supporte notamment la modulation de la puissance du laser durant l'accélération afin de maintenir constant le rapport vitesse / puissance pour ne pas bruler le modèle à basse vitesse pendant une accélération.

Moteurs Pas à Pas:

FluidNC est capable de piloter des moteurs avec une grande variété de possibilités :

  • Contrôleurs externes, pilotés par les classiques signaux STEP (pas) et DIR (direction)
  • Support d'un "Global Enable" qui permet de couper les moteurs lorsque la machine est en veille.
  • Support des Stepstick, très utilisés sur les imprimantes 3D, comme les A4988, DRV8825, TB67S249FTG
  • Support des Trinamic contrôlés en mode SPI (TMC2130 et TMC5160)
  • Support des Trinamic en mode UART (TMC2209)
  • Les Trinamic en mode Step/Dir, peuvent être utilisés en mode "Steptick", à condition de les avoir préparamétrés avant.
  • RC Servo (servo moteur type modélisme), en mode PWM
  • Dynamixel Servo en mode série.
  • Solenoid
  • Moteurs unipolaires.

Maquette de test :

La mécanique

Pour les tests, j'ai réalisé une petite machine à 3 axes. Elle a tout d'abord été dessinée sous Sketchup (fichier ICI: TinyFluid.skp). J'ai finalement mis un axe Z (ex: https://www.aliexpress.com/item/1005004533356691.html ) trouvé d'occasion sur le bon coin pour 15 euros. A ce prix, et avec le moteur, pas la peine de concevoir quoi que ce soit. Des interrupteurs de détection d'origine ont étés ajoutés sur les 3 axes (X0, Y0, Z max) après le dessin initial. Cela donne ceci sans les fins de courses et l'axe Z:

L'électronique

Le Wiki de FuildNC décrit pas mal de solutions matérielles supportant plus ou moins bien FluidNC: http://wiki.fluidnc.com/en/hardware/existing_hardware.

Pour la mise en œuvre du logiciel, j'ai choisi une carte MKS DLC32 V2.1 (15 euros) qui supporte 3 axes dont un double avec des contrôleurs pas à pas Stepstick ou externes, peut piloter une petit broche d'usinage (sur une sortie de puissance commandée par un MOSFET) ou un laser (en PWM). Elle n'est pas open hardware au sens littéral du terme, puisque les schémas sont à peine publiés. Néanmoins la documentation est plus que suffisante pour mettre en œuvre FluidNC sans surprise.

J'ai réalisé une petite boite pour héberger la carte et son câblage, un ventilateur de refroidissement pour les stepsticks (DRV8825), un arrêt d'urgence, un marche arrêt et une antenne wifi externe. Les découpes permettent un accès à la prise d'alimentation, prise USB, carte SD, et les sorties des fils. Elle a été réalisée avec une découpe laser K40 sur du contreplaqué de 3mm. En voici les plans en format Sketchup, DXF et au format Lightburn

Le logiciel: FluidNC

Le wiki de FluicNC est assez clair sur la méthode d'installation: Page d'installation.

Le logiciel est à prendre de https://github.com/bdring/FluidNC . A droite se trouve un bloc "Releases" avec lien direct de téléchargement sur la dernière. Pour une première installation, prendre "fluidnc-vx.y.z-win64.zip". Puis :

  • Le décompresser.
  • Connecter la carte en USB, et l'alimenter en 12, 19 ou 24V, En effet, le câble USB ne permet pas d'alimenter la partie logique, mais seulement de communiquer. Il nous faut donc brancher les 2...
  • Lancer install-wifi.bat (ou install-bt.bat pour une connexion Bluetooth uniquement)
  • Si c'est une première installation sur la carte, lancer install-fs.bat, qui va créer la partition spiffs pour stocker les fichiers de configuration. Ne le faire que lors de la première installation, sinon vos fichiers de config seront effacés.

A l'issue, votre carte est installée sous FluidNC mais :

  • N'est pas encore connectée à votre réseau WIfi
  • N'a pas encore de fichier de configuration pour faire fonctionner votre machine;
  • N'a pas encore l'interface HTML "WebUI" fonctionnelle.

Pour le Wifi, cela va être assez simple à paramétrer. A la fin de l'installation, le logiciel lance un terminal qui va nous permettre de communiquer avec la carte afin de paramétrer le wifi grâce à quelques commandes qu'il vous suffira de lancer dans la console. Si vous l'avez fermé, pas de soucis, il suffit de lancer "fluidterm.bat" pour le ré-ouvrir.

Les commandes Wifi sont dans le WIKI: http://wiki.fluidnc.com/en/features/wifi_bt . C'est en lançant quelques unes de ces commandes que nous allons pouvoir paramétrer le wifi (supprimer les commentaires à la fin avant de lancer les commandes... et remplacez les données par les vôtres):

$Hostname=FluidNC  ' nom d'hôte de la carte
$WiFi/Mode=STA    ' Connectée à un réseau domestique
$Sta/SSID=SSIDdeMonReseau   ' Votre SSID
$Sta/Password=MonMotDePasse  ' Votre mit de passe wifi
$Sta/IPMode=DHCP   ' Adresse attribuée automatiquement
$HTTP/Enable=1     ' interface web adctivée
$HTTP/Port=80    ' sur le port 80
$HTTP/BlockDuringMotion=1   ' n'actualise pas le web durant les déplacements
$Telnet/Enable=1     ' telnet activé 
$Telnet/Port=23     ' sur le port 23

Il est également possible de passe en IP Fixe à l'aide des commande complémentaires suivantes :

$Sta/IPMode=Static
$Sta/IP=192.168.0.2
$Sta/Gateway=192.168.0.1
$Sta/Netmask=255.255.255.0

Après redémarrage, la carte est désormais joignable sur votre réseau Wifi. Toutefois, il lui manque encore un fichier pour qu'elle dispose de l'interface web. Celui-ci est livré dans l'archive, dans le sous répertoire "wifi/index.html.gz'. Il suffit de suivre la procédure "Upgrading Firmware" dans le Wiki.

Après avoir redémarré la carte, vous devriez maintenant voir l'interface web en vous connectant sur http://fluidnc.local :

Il est temps de créer le fichier de configuration. L'ESP32 ne disposant pas d'un grand nombre de sorties, une astuce a été mise en oeuvre par MKS sur la carte DLC32, à savoir utiliser le port i2S (normalement réservé à une sortie audio numérique) et mettre un composant qui désérialise les données pour avoir plusieurs sorties en parallèle. Cela permet d'avoir 8 sorties supplémentaires qui seront utilisées pour les moteurs.

Voici l'affectation des entrées sorties de la carte, avec les fonctions des signaux et leurs noms. Ceci a été synthétisé à partir du schéma et de diverses inforamtions, n'état pas directment mis à dispoition par MKS :

Port /
connecteur		 Nom signal IO Commentaire
Port I2S I2S_WS GPIO.17 Pour référence uniquement, ne pas utiliser.
  I2S_BCK GPIO.16 Utilisé pour fournir 8 sorties (I2SO.0 à 7). 
  I2S_DATA GPIO.21  
Port SPI  MISO_PIN GPIO.12 Pour référence uniquement, ne pas utiliser.
  MOSI_PIN GPIO.13 Port SPI déjà utilisé par la carte SD 
  SCK_PIN GPIO.14  
  CS GPIO.15  
  CARD_DETECT GPIO.39  
Moteur X Enable (shared)  I2SO.0 1 sortie drv externe + 1 sortie moteur X1
  Step I2SO.1  
  Dir I2SO.2  
Moteur Y Enable (shared)  I2SO.0 1 sortie drv externe + 2 sorties moteur Y1 Y2
  Step I2SO.5  
  Dir I2SO.6  
Moteur Z Enable (shared)  I2SO.0 1 sortie drv externe + 1 sortie moteur Z1
  Step I2SO.3  
  Dir I2SO.4  
Limites X- GPIO.36  Sur connecteur [J9]
  Y- GPIO.35  Sur connecteur [J10]
  Z- GPIO.34 Sur connecteur [J11]
Probe 1 +5V Sur connecteur [J12]
  2 GND  
  3 GPIO.22  
Spindle  1 +12V permanent Sur connecteur [J7]
  2 GND (cmd par GPIO.32) , coupure de masse par mosfet
Spindle TTL 1 +12V Sur connecteur [J18]
  2 GND  
  3 GPIO.32 (TTL)  
Disable F1 Fuse 1 In power Sur connecteur [J3],
enlever le fuse et connecter un M/A
  2 Ext power  
Bus I2C 1 3V3 Sur connecteur [J2]
  2 GND  
  3 - I2C_SDA GPIO.0  
  4 - I2C_SCL GPIO.4  
Reset 1 GND Sur connecteur [J5]
  2 RESET  
Beeper  1 GND (cmd  par I2SO.7) Sur connecteur [J4]
  2 +12V permanent  

C'est à partir de cette information que nous allons pouvoir batir le fichier texte de configuration "config.yaml" qui va être envoyé à la carte pour lui documenter comment sont utilisées les différente broches :

board: MKS-DLC32 V2.1
name: Hybrid CNC/Laser JPC 335x275x53mm - 
meta: (24/09/2022) 09:00

kinematics:
  Cartesian:

stepping:
  engine: I2S_STATIC
  idle_ms: 0
  pulse_us: 4
  dir_delay_us: 1
  disable_delay_us: 0
axes:
  shared_stepper_disable_pin: I2SO.0
  x:
    steps_per_mm: 80
    max_rate_mm_per_min: 20000.000
    acceleration_mm_per_sec2: 1500.000
    max_travel_mm: 335.000
    soft_limits: true
    homing:
      cycle: 2
      positive_direction: false
      mpos_mm: 0.000
      feed_mm_per_min: 200.000
      seek_mm_per_min:2000.000
      settle_ms: 500
      seek_scaler: 1.100
      feed_scaler: 1.100

    motor0:
      limit_neg_pin: gpio.36:low
      hard_limits: false
      pulloff_mm: 2.000
      stepstick:
        step_pin: I2SO.5
        direction_pin: I2SO.6

  y:
    steps_per_mm: 80
    max_rate_mm_per_min: 20000.000
    acceleration_mm_per_sec2: 1500.000
    max_travel_mm: 275.000
    soft_limits: true
    homing:
      cycle: 2
      positive_direction: false
      mpos_mm: 0.000
      feed_mm_per_min: 200.000
      seek_mm_per_min: 2000.000
      settle_ms: 500
      seek_scaler: 1.100
      feed_scaler: 1.100

    motor0:
      limit_neg_pin: gpio.35:low
      hard_limits: false
      pulloff_mm: 2.000
      stepstick:
        step_pin: I2SO.1
        direction_pin: I2SO.2
       
  z:
    steps_per_mm: 1600.00
    max_rate_mm_per_min: 2000.000
    acceleration_mm_per_sec2: 100.000
    max_travel_mm: 53.000
    soft_limits: true
    homing:
      cycle: 1
      positive_direction: true
      mpos_mm: 0.000
      feed_mm_per_min: 200.000
      seek_mm_per_min: 500.000
      settle_ms: 500
      seek_scaler: 1.100
      feed_scaler: 1.100

    motor0:
      limit_neg_pin: gpio.34:low
      hard_limits: false
      pulloff_mm: 1.000
      stepstick:
        step_pin: I2SO.3
        direction_pin: I2SO.4

i2so:
  bck_pin: gpio.16
  data_pin: gpio.21
  ws_pin: gpio.17

spi:
  miso_pin: gpio.12
  mosi_pin: gpio.13
  sck_pin: gpio.14

sdcard:
  cs_pin: gpio.15
  card_detect_pin: NO_PIN

control:
  safety_door_pin: NO_PIN
  reset_pin: NO_PIN
  feed_hold_pin: NO_PIN
  cycle_start_pin: NO_PIN
  macro0_pin: NO_PIN
  # macro0_pin: gpio.33:low:pu
  macro1_pin: NO_PIN
  macro2_pin: NO_PIN
  macro3_pin: NO_PIN

macros:
  startup_line0:
  startup_line1:
  macro0: $SD/Run=lasertest.gcode
  macro1: $SD/Run=home.gcode
  macro2:
  macro3:

coolant:
  flood_pin: NO_PIN
  mist_pin: NO_PIN
  delay_ms: 0

probe:
# Sonde raccordée en J12
  pin: gpio.22
  check_mode_start: true

Laser:
# PWM à 1Khz.
  pwm_hz: 1000
# Laser raccordé sur connecteur J18
  output_pin: gpio.32
  enable_pin: NO_PIN
  disable_with_s0: false
  s0_with_disable: false
  tool_num: 0
  speed_map: 0=0.000% 1000=100.000%

pwm:
  pwm_hz: 5000
  direction_pin: NO_PIN
# Broche 12V (ou 24V) raccordée au connecteur J7.
# Attention à ne pas dépasser la puissance du  MOSFET.
  output_pin: gpio.32
  enable_pin: NO_PIN
  disable_with_s0: false
  s0_with_disable: true
  spinup_ms: 0
  spindown_ms: 0
  tool_num: 1
  speed_map: 0=0.000% 10000=100.000%

user_outputs:
  analog0_pin: NO_PIN
  analog1_pin: NO_PIN
  analog2_pin: NO_PIN
  analog3_pin: NO_PIN
  analog0_hz: 5000
  analog1_hz: 5000
  analog2_hz: 5000
  analog3_hz: 5000
  digital0_pin: NO_PIN
  digital1_pin: NO_PIN
  digital2_pin: NO_PIN
  digital3_pin: NO_PIN

start:
  must_home: true

Cette implémentation fait appel à plsuieurs astuces :

  • L'axe X de la machine étant piloté par 2 moteurs, il sera drivé par la seule sortie ayant 2 connecteurs de sortie moteurs : Y
  • De ce fait l'axe X machine est piloté par l'axe Y de la carte (permutation...).
  • 2 outils ont été définits, un laser (outil 0) et un moteur de broche (outil 1). Pour en sélectionner, il suffit d'envoyer un GCODE M6 Tx (ex : "M6 T0" pour le laser)
  • La puissance de sortie du laser étant senseiblement linéaire lorsque l'on module sa puissance en PWM, speed_map définit une courbe de transfert droite. Il est tout à fait possible de spéciier autre chose.
  • Les 2 outils sont racordés sur la même sortie. Il ne pourront donc pas fonctionner en même temps. Mais vous pourriez utiliser une autre sortie de la carte pour le moteur de broche en mettant un relais sstatique externe par exemple pour contourner cela.
  • l"outil "Laser" active automatiquement le "Laser Mode" de FluidNC, c'est à dire la capacité à changer la puissance du laser à la volée sans faire d'arrêt. Ceci n'est bien sur pas posisble sur une CNC (et donc sur l'outil broche "PWM").

Je vous encourage à consulter le wiki sur la syntaxe de ce fichier YAML pour bien comprendre ce qui a été fait ci dessus : http://wiki.fluidnc.com/en/config/overview

Ce fichier config.yaml doit ensuite être envoyé à la carte, par l'interface web. La prodécure est documentée également dans le wiki ("Overview" / "Uploading". Des changements minimes à la volée pourront être faits directemnet par l'interface web, afin de tester des paramètres par exemple ("Overview" / "Live changes"). Bien que cela soit possible, je ne vous encorage pas à sauver ces changements dans l'interface car le formatage de votre fichier de config et ses commentaires seront perdus. Dès que vous avez trouvé les bons réglages, reportez les dans votre "config.yaml" et renvoyez le à la carte. Vous pouvez égalemetn mettre plusieurs fichier de configuration sur la carte, et les activer par "$Config/Filename" dans le réglages. Attention toutefois, la mémoire interne est très faible, vous ne pourrez pas stocker beaucoup de fichiers différents dessus.

Branchement d'un afficheur OLED

Les versions récentes de FluidNC permettent le raccordement d'un petit afficheur OLED basé sur un SSD1306 avec 128X64 pixels. Disponibles à 2€ en 0.96 et 4 euros en 1.3 , il vont permettent d'afficher l'adresse IP ainsi que les coordonnées machine en temps réel. Pratique. Le raccordement est aisé puisqu'il suffit de se brancher sur le connecteur J2 et de raccorder les broches de même nom entre elles (SD > SDA, SCL > SCL, DND > GND, 3.3V > VCC).

Quelques lignes ajoutées à la fin du fichier config.yaml vont faire le reste de la magie. Attention à l'adresse de l'afficheur, qui ne sera peut être pas la même pour le votre. Elle est généralement marquée sur la sérigraphie du circuit imprimée. Ici donnée pour un 0.96''.

i2c0:
   sda_pin: gpio.0
   scl_pin: gpio.4


oled:
   i2c_num: 0
# 3C en hexa = 60
# 78 en hexa = 120
   i2c_address: 60
   width: 128
   height: 64
   radio_delay_ms: 1000

Logiciel de pilotage

J'ai testé la découpe laser avec succès sur Lightburn ( https://lightburnsoftware.com/ ). Pour que la compatibilité soit parfaite il suffit de choir GRBL. Cerise sur le gateau, il sera ensuite possble de piloter la machine soit en USB (port sériie sur USB), et même en réseau en donnant l'adresse de la machine ( choisir "Ethernet/TCP" et donner l'adresse IP de la machine).

A noter qu'en WIFI, le débit de transmission de commande vers la machine est beaucoup plus faible. Ce n'est pas un soucis lorsque l'on fait de la découpe, mais peut le devenir lorsque l'on fait de la gravure en mode "raster" d'un image par exemple. En effet, dans ce mode chaque changement de puissance du laser sur un trait continu donnera lieu à l'envoi de commandes... Du coup la machine peut s'arrêter brièvement, laser allumé ce qui est claiement un soucis. Pour faire du gravage sans niveau de gris c'est fonctionnel (ex: sérigraphie de textes sur une face avant d'appareil).

Il est aussi possible dde sauver le fichie GCODE produit par l'outil et de l'envoyer par l'interface web sur la carte SD. La machine devient ainsi autonome, et cela coutourne la limitation du straming de commande via Wifi.

En mode CNC, j'ai travaillé avec un logiciel écrit en Python qui se nomme BCNC: (voir https://github.com/vlachoudis/bCNC) C'est un peu pénible à installer dans les dernières versions mais marche plutot pas mal !

  • Installer Python 3.10 dernière version de https://www.python.org/downloads/
  • Lancer un interpréteur de commande
  • Taper la commadne suivante
	pip install --upgrade bCNC
  • Le lanceur de bCNC se trouve dans (copier coller le chimin dans la barre d'adresse de l'explorateur windows)
	%LocalAppData%\Programs\Python\Python310\Lib\site-packages\bCNC\bCNC.bat

A noter que :

  • BCNC permet la connexion part port série (classique) mais aussi par réseau (ex: socket://192.168.xx.yy:23) sur le port telnet.
  • BCNC supporte l'auto level avec une sonde qui peut être raccordée à J12, ce qui permet de corriger des défauts de planéité de la machine / table. Voir procédure : https://github.com/vlachoudis/bCNC/wiki/AutoLevel

Voila, j'espère vous avoir donné envie d'essayer, et les clés pour démarrer. Bonne bidouille!