Chaîne Bois

La Chaîne Logicielle

De l’idée de départ jusqu’à la fabrication de la pièce sur votre machine CNC, tout va se passer sur l’ordinateur, utilisant différents logiciels selon l’étape du processus à effectuer, constituant ainsi une chaîne logicielle.

LA Chaîne logicielle, dans l’absolu, n’existe pas. Il y a la vôtre, celle que vous allez petit à petit adopter, qui vous sera la plus familière. Même si, selon les cas particuliers, vous allez sans doute avoir besoin de l‘adapter.

Dans cet article, La Chaîne Logicielle est générique. Nous allons voir les différentes étapes nécessaires pour transformer une idée en objet fini, et évoquer les différents outils logiciels qui peuvent être utilisés. Certains logiciels permettent d’effectuer TOUTES les étapes, où presque, alors que d’autres ne permettent qu’une seule opération. Nous reviendrons plus en détail sur certains de ces logiciels dans le futur.

Il existe aussi de nombreux utilitaires, permettant de passage d’une étape à une autre, comme la conversion d’un fichier DXF en GCode, mais je n’en parlerais pas dans cet article, dans la mesure où le but est d’avoir le MINIMUM d’étapes. Je vais donc me focaliser sur les outils plus complets, par rapport à des utilitaires ne remplissant qu’une seule fonction. Le Forum est là pour en parler, une discussion me semble plus appropriée qu’un article, qui ne peut brosser qu’un tableau générique.

Étapes de Création

  1. Conception/Dessin 2D.
  2. Passage au 3D (ou Conception 3D directement).
  3. Génération des chemins de l’outil (des outils), création du GCode.
  4. Envoi du GCode à la machine.
  5. Interprétation du GCode et transformation en mouvements sur la machine.

Nous allons surtout nous intéresser aux 3 premières étapes, indépendantes des étapes 4 et 5, nécessaires quelle que soit la machine et technique utilisée (Fraisage, découpe laser où même impression 3D). Mon but n’est pas d’être exhaustif et de citer tous les logiciels possible pour une étape particulière, mais de proposer une découverte de certains outils particulièrement adaptés à une utilisation amateur/semi-professionnelle, de par leur prix et (ou) leur simplicité d’utilisation.

C’est l’ensemble des logiciels et utilitaires permettant d’effectuer au mieux chacune de ces étapes qui vont constituer votre chaîne logicielle.

Étape 1 : Conception/Dessin 2D

C’est sans doute pour cette première étape que la palette de choix possibles est la plus vaste, puisque pratiquement n’importe quel logiciel de dessin peut-être utilisé. La difficulté risque d’être le passage aux étapes suivantes, il vaut donc mieux choisir d’entrée un outil connu pour son intégration aisée dans l’ensemble du processus.

Pour cette raison, il paraît nécessaire d’éliminer d’emblée les logiciels de dessins “matriciels” (raster) pour se pencher vers les outils de dessin vectoriels (vectors, lignes). Pendant qu’on y est, autant se focaliser sur les outils type dessins industriels, plutôt qu’artistiques, selon vos buts, bien sûr. Il existe de nombreuses solutions permettant de passer de l’un à l’autre, simplement cela rajoute une étape, donc de la complexité, du temps et une source d’erreurs supplémentaire.

    • Inkscape

      • Pourtant, le premier logiciel que je veux présenter est justement un de ceux qui permettent cette conversion, mais il est capable de bien plus! Je veux parler de Inkscape, qui est un logiciel de dessin vectoriel Open Source et gratuit. Attention, il ne s’agit pas de dessin paramétré, type dessin industriel, mais de dessin libre, “artistique”, ce qui peut parfaitement vous convenir, pour réaliser des signaux, panneaux, logos, etc…
      • Étant capable d’exporter les créations en fichier SVG et DXF, il pourra s’intégrer avec tous les outils dont nous allons parler par la suite.
    • Draftsight

      • Créé par Dassault Systèmes, Draftsight est un équivalent très proche des fameux Autocad et Autocad LT. On ne parle plus de dessin “artistique” ici, mais de toute la puissance nécessaire à la CAO, avec toutes les fonctionnalités habituellement trouvées dans ce genre d’outils. Il a l’avantage d’avoir une version gratuite. La seule vraie différence entre la version gratuite et la version professionnelle est LISP, un langage de programmation permettant d’automatiser de nombreuses taches répétitive de dessin.

Étape 2: Conception/Modélisation 3D

On aborde ici les outils les plus spectaculaires, longtemps réservés aux seules entreprises capables de s’offrir des outils dont la licence dépassait allégrement les 10 000 € par poste. Cela a bien changé récemment, mais pas pour tout le monde! Tout d’abord, une distinction importante: Conception et Modélisation 3D ne sont pas la même chose. La conception permet d’élaborer, dessiner, visualiser un objet en 3 dimensions. La modélisation va plus loin, permettant de modéliser des mouvements des objets en relation les uns avec les autres, de simuler des efforts, etc. Autrement dit, tous les outils de conception 3D ne sont pas nécessairement aussi des outils de modélisation.

    • SketchUp

      • Le plus connu des outils de conception 3D (mais PAS de modélisation) est certainement SketchUp. La version “Make” est gratuite, et il existe beaucoup de tutoriels et d’exemples sur le Net. Son principal inconvénient, de mon point de vue, est qu’il s’agit plus d’un logiciel de “dessin” en 3D, que d’un logiciel de “Conception”, ce qui le rend parfaitement adapté à l’architecture, mais pas autant à l’assemblage mécanique. Ce que je veux dire, c’est que SketchUp manipule des volumes ( un cube est un assemblage de 6 faces carrées) et pas réellement des objets, où un cube est un solide dont toutes les dimensions sont égales. Cela peut sembler, à la lecture, de petites nuances, mais en pratique, dans l’utilisation quotidienne, c’est une vraie différence.
      • L’autre inconvénient, c’est la difficulté à exporter sous des formats standards en vue de la fabrication et la génération de GCode.
      • Personnellement, c’est avec SketchUp que j’ai commencé la conception 3D, mais je suis très heureux d’avoir découvert Fusion 360 dont je ne pourrais plus me passer.
    • SolidWorks

      • Passons maintenant au Français de la série, SolidWorks, lui aussi produit par Dassault Systèmes. On a ici affaire à un véritable outil industriel, capable de modéliser des solides. Il est utilisé par un certain nombre de modélistes connus, comme Laurent Buissyne, dont tous les plans récents publiés dans RC Pilot sont créés avec SolidWorks.
      • Je n’ai personnellement aucune expérience avec cet outil, mais à voir les résultats produits, je n’ai aucun doute sur ces capacités. Les inconvénients sont, tout d’abord, le prix de la licence, qui dépend des modules choisis, mais tourne autour de 7 000€ (sauf si vous pouvez bénéficier d’une licence éducation). Ensuite, il n’y a pas de module de fabrication directement intégré, il va donc falloir passer par un export en fichier d’échange (DXF), puis l’utilisation d’un autre outil logiciel pour générer les passages d’outils et le GCode.
    • Autodesk Inventor

      • Concurrent direct de SolidWorks, Inventor est aussi parfaitement adapté à nos besoins, même si lui non plus ne comporte pas de module capable de générer le GCode. N’ayant pas non plus d’expérience personnelle avec cet outil, je ne peux que vous renvoyer à cette comparaison. Au final, tout dépend de vos besoins particuliers, qu’il vaut mieux avoir identifiés correctement, puisqu’au final, sur 5 ans, vous aurez dépensé plus de 12 000 $US

 

    • Gamme Vectric (Cut2D, VCarve, Aspire, Cut3D)

      • Spécialement conçus pour le fraisage en 2 et 3D, les divers logiciels de cette gamme n’ont pas toutes les possibilités d’outils comme SolidWorks ou Inventor, mais ils permettent d’effectuer toutes les étapes nécessaires, depuis le dessin de base, jusqu’à la génération du GCode. Ils comportent aussi (de base où en complément) de généreuses librairies de pièces décoratives que vous pouvez incorporer dans votre création, où juste fraiser pour elles même. Ils sont complétement orienté bois, et TRES faciles d’emploi. Pour des débuts avec une fraiseuse CNC de table, Cut2D Desktop (135€), vous permettra d’obtenir des résultats immédiatement, puisqu’à lui tout seul il est capable de l’ensemble des opérations.
    • Fusion 360

      • Le petit dernier parmi les grands, et de ce fait le moins connu, Fusion 360 est le plus complet au regard de nos besoins, dans la mesure où c’est le seul à intégrer directement un module de génération de GCode, mais pas seulement! Il peut aussi piloter directement une imprimante 3D, générer du GCode adapté à la découpe laser où plasma. C’est donc non seulement un outil de Conception/Modélisation 3D évolué, avec simulation des joints/articulations entre pièces, mais aussi un outil de fabrication des pièces modélisées. Le Gode peut aussi être généré pour du VRAI 3D, pas juste du 2.5D ( X, Y et Z) comme la plupart des autres outils le font.
      • Il a aussi l’immense avantage, pour nous, d’être gratuit, pour autant que vous où votre entreprise ne fassiez pas plus de 100 000 $US/An (ou que vous puissiez justifier d’un statut Étudiant/Professeur). J’aurais l’occasion d’expliquer cela en détail dans un futur article. ATTENTION, vous ne pouvez bénéficier de cette possibilité que si vous utilisez le lien ci-dessus, PAS LE SITE FRANCAIS!
    • CamBam

      • Selon vos besoins, CamBam peut s’avérer suffisant, c’est pour cette raison que je le cite ici. Il ne s’agit pas réellement de “conception 3D”, mais plutôt de dessins 2D auxquels on affecte une épaisseur. Il peut aussi importer des fichiers DXF et est capable d’importer un certains nombre de formats de fichiers 3D, que vous ne pourrez cependant pas modifier dans CamBam. Très connu et très utilisé, CamBam n’est pas gratuit.

Étape 3: Génération des chemins de l’outil et du GCode

Tout d’un coup, il y a beaucoup moins de monde pour cette étape! Si vous tapez dans Google “generate GCode from DXF” vous allez avoir une foultitude de résultats (79 700 exactement!). Pour une recherche un peu moins restrictive (“GCode generator”) vous obtenez 274 000 résultats! Pourquoi dire qu’il y a beaucoup moins de monde, au vu de ces résultats? Tout simplement parce qu’il s’agit, à 99%, d’utilitaires plus où moins bien ficelés, relativement limités et manquants de souplesse. La encore, votre expérience peut différer, et je vous invite à utiliser le Forum pour partager votre expérience et poser des question à ce sujet. je me limiterais donc, dans cet article, aux 2 outils déjà cités.

CamBam

C’est le but premier de CamBam, parfaitement capable de générer des chemins complexes, tenant correctement compte des fraises utilisées et des machines auxquelles le GCode est destiné. La licence est abordable, et il existe maintenant en Français. Étant largement répandu, il est assez facile de trouver de l’aide à son sujet, notamment au travers de discussions sur Usinages. Le seul véritable inconvénient de CamBam, par rapport à un module intégré comme dans Fusion 360, est que toute modification de dernière minute va nécessiter l’utilisation de plusieurs logiciels et la régénération de fichiers d’échange.

Exemple: j’ai prévu des percements de diamètre 5mm, et je me rends compte qu’il vaut mieux percer à 6mm. Avec CamBam, il faut

  1. Modifier le dessin d’origine dans DraftSight (par exemple)
  2. Exporter en fichier DXF
  3. Aller dans CamBam
  4. Importer le Fichier DXF
  5. Refaire les opérations nécessaires pour générer le GCode depuis ce nouveau fichier.

Fusion 360

Le module CAM de Fusion 360 est pratiquement un rêve devenu réalité. Pour comparer avec les étapes de l’exemple précédent, voici les étapes nécessaires:

  1. Modifier le diamètre des trous dans le module Model
  2. Retourner dans le module CAM et régénérer les chemins d’outils.

C’est tout! N’oubliez pas non plus que vous pouvez directement imprimer (ou faire imprimer par des entreprises spécialisées) en 3D vos objets conçus avec Fusion 360, depuis le module Model. Selon vos besoins, vous pourrez trouver Fusion 360 un peu lourd, même si l’interface utilisateur me semble très réussie. Il y a beaucoup de possibilités, donc beaucoup à apprendre. Mais CamBam demande aussi un apprentissage non négligeable.

Gamme Vectric

Je ne veux pas répéter ce que j’ai écrit plus haut, mais l’ensemble de la gamme Vectric est à classer ici aussi.

Étape 4: Envoi du GCode à la machine CNC

Les étapes 4 et 5 ne sont distinctes, pratiquement, qu’avec GRBL, qui ne comporte pas d’interface utilisateur. Pour tous les autres programmes couramment utilisés par les amateurs et artisans (par différence avec l’industrie), c’est le même logiciel qui va effectuer ces 2 étapes, bien que généralement la partie “envoi des impulsions aux moteurs” va être gérée par le firmware de la carte externe branchée sur le PC. L’étape 4 commence donc avec l’existence d’un fichier GCode (généralement avec une extension .NC où .CNC), dont il nous faut maintenant “faire quelque chose avec”….

Si vous utilisez GRBL, du fait qu’il “tourne” sur un Arduino, vous allez avoir besoin d’un logiciel interface utilisateur, pour communiquer et contrôler GRBL.

  • Panneau de Contrôle GRBL

    • Ce logiciel est le seul a être francisé (à ma connaissance) . Vous pouvez le télécharger ici. Il comporte tous les contrôles nécessaire au pilotage d’une fraiseuse CNC, tels qu’on peut les trouver sur des machines industrielles. Il évolue constamment. Bien qu’il ne comporte pas la visualisation de la pièce travaillée et de la position de l’outil, il reste mon préféré.
  • grblControl / Candle

    • Relativement récent parmi ces logiciels “envoyeurs de GCode”, il a l’avantage de pouvoir fonctionner aussi sur Linux, en plus de Windows. Il permet aussi de visualiser graphiquement le GCode, mais est un peu moins complet en ce qui concerne l’interaction avec GRBL. Vous pouvez le télécharger directement depuis son répertoire GitHub, puisqu’il est Open Source, tout comme GRBLPanel / Panneau de Contrôle GRBL

Comme dit précédemment, il existe de nombreux autres outils remplissant cette fonction. Vous pouvez accéder à la liste ici, complète (ou à très peu près, je crois).

Étape 5: Interprétation du GCode et envoi des impulsions aux pilotes des Moteurs

Ne nous y trompons pas, dans pratiquement tous les cas de figure (pratiquement, parce qu’avec le Raspberry PI et équivalents, on voit commencer à apparaître des solutions complétement intégrées), c’est une carte reliée au PC qui va effectivement envoyer les commandes aux drivers. Et le code se trouve dans le firmware de la carte. Pas vraiment de différences donc avec GRBL, dans le principe. La vraie différence vient du type de liaison entre le PC et la carte électronique (généralement propriétaire), ainsi que du Firmware lui même, bien sûr.

  • Mach3, Mach 4

    • Plus aucun PC, et encore moins de portable/tablette ne comportent maintenant de port parallèle, qui fait un peu figure d’antiquité. Pourtant Mach3, comme Mach4, bien plus récent, ont tous deux besoin d’un port parallèle, dans leurs versions de base. Il existe des plugins et différentes cartes permettant d’utiliser un port USB, mais il me semble préférable d’utiliser un logiciel conçu dès l’origine pour utiliser un port USB où un port Ethernet. Ces logiciels sont complets, même si un peu complexes à mettre en œuvre au départ. Ils peuvent piloter jusqu’à 6 axes, ce qui dépasse très largement les besoins amateurs et même professionnels en fraisage courant.
  • PlanetCNC

    • Alternative relativement peu connue, PlanetCNC conçoit et fabrique ses propres cartes contrôleurs USB, et diffuse son propre logiciel (gratuit) compatible avec ces cartes. L’ensemble est d’un fonctionnement robuste et sans soucis particuliers, après avoir proprement paramétré le logiciel en fonction de sa machine.
  • CNCdrive

    • Alternative intéressante et moderne à Mach3, avec une licence à 55€ en ce moment, le logiciel de CNCdrive, UCCNC peut importer les réglages faits pour Mach3. Certaines des cartes proposées sont compatibles avec Mach3, elles existent pour port USB où pour port Ethernet. L’utilisation d’in port Ethernet comporte plusieurs avantages (par rapport à un port USB), notamment la possibilité d’accroître la distance entre le PC et la carte sans risques, et une connexion plus stable, sans bruits électriques.
  • GRBL

    • Il n’est bien sur pas question d’oublier GRBL, qui est le seul à ne pas avoir besoin de carte propriétaire, mais de l’Open Source Arduino. Un Uno suffit, et le simple fait que toutes ces fonctionnalités “tiennent” dans cette mémoire ridiculement petite est complétement étonnant. La version actuelle, 1.1, est disponilbe sur Github ici. GRBL va évoluer vers l’utilisation d’un Atmel (Arduino Due)

 

Tableau Récapitulatif de possibles composants de votre Chaîne Logicielle

Logiciels / Etapes Conception 2D Conception / Modélisation 3D Génération GCode Envoi GCode Interprétation GCode – Impulsions Moteurs Hardware
InkScape X
DraftSight X
TurboCAD Standard X
SketchUp X (Conception)
SolidWorks X X
Inventor X X
Fusion 360 X X X
Vectric Cut 2 D X X
Vectric VCarve X X
Vectric Aspire X X (Pas de modélisation) X
Vectric Cut3D Lecture uniquement fichiers 3D X
CAMBAM X (Conception simple 2.5D) X
Panneau de Contrôle GRBL X
GrblControl X
GRBL X Arduino Uno – USB-Série
Mach3 et Mach 4 X X Cartes Contrôleurs, Port // ou USB avec Plugin
PlanetCNC X X Carte USB propriétaire
CNCdrive X X Cartes USB et Ethernet

J’espère que cet article aide à clarifier qui fait quoi, et comment. Surtout, n’hésitez pas a commenter et à poser des questions, ci-dessous, dans les commentaires, ou dans le Forum, qui est particulièrement adapté à ce genre de discussion.




Panneau de contrôle Grbl en Français

Panneau de Contrôle Grbl

Comme je l’ai évoqué dans mon article précédent, Grbl est un logiciel “firmware”, exécuté sur un Arduino, qui analyse le GCode reçu, construit un modèle mathématique des actions à effectuer, et exécute ces mouvements en envoyant un flot continu de pulsions haute fréquences aux moteurs pas à pas. Le seul petit détail, c’est que Grbl n’a aucune interface utilisateur, par différence avec Mach3, PlanetCNC où encore LinuxCNC, qui tous répondent à la même définition, mais permettent de piloter la machine depuis des écrans appropriés. Il faut donc disposer d’un autre logiciel, exécuté sur une autre machine, en liaison avec Arduino, pour pouvoir interagir avec la machine. Il existe plusieurs de ces logiciels, mais aujourd’hui je veux vous présenter le “Panneau de Contrôle Grbl” (Grbl-Panel, en Anglais) logiciel Open source dont je viens de finir la traduction complète.

Présentation

Le Panneau de Contrôle Grbl n’est pas le plus “joli” des divers logiciels interfaces pour Grbl qui existent, par contre il est certainement le plus “professionnel”, dans la mesure où il intègre de nombreuses fonctions habituellement trouvées sur des machines industrielles. Il “clone” plus où moins un panneau physique comme on pourrait le trouver sur une machine Fanuc où Haas. Tous les outils nécessaires au réglage et au fraisage sont organisés de manière claire, correspondant à l’expérience acquise par la pratique de dizaines d’années d’organisation d’un poste de machiniste. L’interface est épurée et ne comprend pas la partie graphique qui flatte l’œil mais n’apporte pas grand chose de concret à l’interface home machine.

Le Panneau de Contrôle Grbl est compatible avec Grbl 0.9g et suivants, et intègre notamment les nouvelles possibilités de Grbl v1.1, dont nous parlerons plus loin dans cet article. Il donne aussi la possibilité de switcher la disposition des contrôles de manière à être mieux adapté à un(e) gaucher(ère).

Survol Rapide

Une opération de fraisage typique requière le déplacement manuel par petits pas (jogging) au point origine 0 pour la pièce considérée. Souvent cela demande une mise au point sur chacun des axes. C’est pour cette raison qu’il y a un bouton zéro près de chaque axe. Une fois que vous exécutez un fichier GCode, vous ne devriez plus être capable de “jogger” où d’envoyer des commandes manuelles. ici les 2 sont liés, une opération bloque l’autre. Lorsque qu’une condition d’alarme est détectée par Grbl, l’exécution du GCode est stoppée. Les boutons de contrôle et la visualisation est groupée en sous-panneaux qui sont activés/désactivés en fonction de ce que le Panneau de Contrôle Grbl est en train de faire. Un onglet pour les réglages fourni un certain nombre de zones éditables qui modifient le fonctionnement du panneau, où ce qui est envoyé à Grbl. Bien sûr vous pouvez aussi modifier directement les réglages internes à Grbl depuis ce même onglet.

Dans le Détail

1- Installation

Il n’y a pas encore de procédure d’installation, ce qui va venir. Pour l’instant il faut donc télécharger ici un fichier ZIP, et le décompacter, de préférence dans votre répertoire C:\Program Files (x86), ou tout simplement c:\Programmes sur une machine 32 bits. Par la suite, vous trouverez la version francisée sur GitHub, avec la version originale de Grbl-Panel.

2 – Connection

Pour effectuer la liaison série avec l’Arduino, il vous faut brancher un câble USB entre votre Ordi et Arduino. Le driver USB/Série est installé avec l’IDE Arduino, sinon, un Windows récent comme Windows 7 où Windows 10 devrait être capable de le trouver et l’installer tout seul comme un grand, lorsque vous branchez votre micro-contrôleur. Vous avez certainement remarqué un onglet IP, permettant d’effectuer la liaison série au travers d’un module WiFi pour Arduino. Nous reviendrons plus tard sur cette possibilité, et comment effectuer ce lien coté Arduino. A ma connaissance, Le Panneau de Contrôle Grbl est le seul à offrir cette option. Avant de cliquer sur “Connecter”, tous les boutons et panneaux sont désactivés, aucune des diverses options n’est disponible.

3 – Réglages

Panneau de Controle Grbl - RéglagesLe sous panneau des réglages comporte 2 cotés distincts. Sur la gauche, vous retrouvez les paramètres internes de Grbl, que vous pouvez obtenir en tapant “$$” dans un terminal série, comme expliqué dans l’article à ce sujet. Un certain nombre de paramètres, plus bas dans la liste, permettent d’indiquer des valeurs interactivement alors qu’auparavant il fallait aller modifier le fichier config.h, comme pour les courses maximum (Valable depuis Grbl 1.1). Pour modifier une valeur, cliquez sur la case valeur, pour la sélectionner, une 2ème fois pour l’éditer, puis un double-clic rapide pour aller écrire la nouvelle valeur dans Grbl. Beaucoup plus simple, vous pouvez simplement appuyer sur la touche entrée. Vous pouvez vérifier que la nouvelle valeur a bien été prise en compte et cliquant sur “charge réglages.

Sur la partie droite figurent un certain nombre de réglages qui vont modifier ce que le Panneau de Contrôle envoi à Grbl, et non directement Grbl lui même. Comme cet article n’est pas un manuel utilisateur, ni un manuel d’apprentissage de GCode, je ne vais pas entrer dans le détail de chacun des réglages. Je vais par contre évoquer rapidement leur utilisation:

Sous Panneau Position. Les commandes GCode G28 et G30 sont communément utilisées pour indiquer la position de repos, où de départ et de fin. Nous verrons par la suite comment indiquer à Grbl quelles sont ces positions sur votre machine. Les autres commandes font ce qui est indiqué à coté. Plongez-vous dans un manuel sur GCode pour comprendre quels sont les ordres envoyés à la machine, mais à priori je ne changerais rien ici, sauf cas particulier.
Sous Panneau Divers. La aussi, sauf à savoir vraiment ce que vous faites, je ne changerais rien ici, sauf pour la dernière ligne “Ext Fic. par Défaut”. Cette entrée est destinée à faciliter la recherche des fichiers GCode, sur la page Interface. Suivant vos habitudes et préférences, entrez “nc”, où “cnc”, sans le point devant. Les autres paramètres concernent: la fréquence de rafraîchissement des données en provenance de Grbl, la taille de la Queue de commandes envoyées, et le buffer mémoire dans lequel ces commandes sont stockées, et le délai au démarrage, en millisecondes.

Parmi les cases à cocher au bas du panneau, il est préférable de laisser celles cochées par défaut. Si vous cochez “connecte à l’ouverture”, le panneau de contrôle essayera de se connecter comme il l’est maintenant la prochaine fois que vous le lancez. Si vous cochez interface Utilisateur pour gaucher, sur la page Interface, les panneaux Position et Grbl Jogging s’intervertissent, pour avoir Jogging à gauche et Position à droite.

Sous Panneau Jogging. Tout d’abord la case à cocher métrique, qui signifie que tout ce que vous allez faire avec le jogging est en dimension métriques. Sinon, tout est en pouces. ATTENTION, cela ne concerne que le jogging. Les incréments d’avance sont les différents nombre de millimètres (pour les valeurs métriques) d’avance que vous voulez commander. Les taux d’avance, est la vitesse, en millimètres/minutes, à laquelle vous voulez que le déplacement s’effectue. Ces choix sont ceux proposés sur la page Interface, dans le sous panneau jogging. Par exemple, si vous sélectionnez 10 comme Incrément, et 100 comme Taux, un appui sur X+ provoquera un mouvement de 10 millimètres sur l’Axe des X à une vitesse de 100 millimètres/minutes. il faudra donc (100/60) x 10, soit 16.66 secondes pour effectuer ce déplacement.
Le taux de répétition concerne le nombre de fois où l’ordre est envoyé, par seconde. La case à cocher dessous permet d’utiliser les flèches clavier pour ces déplacements; Pratique sur un ordi, pas vraiment sur une tablette….

Sous Panneau Décalage. Nous venons de voir ci-dessus que les commandes GCode G28 et G30 permettent de dire à la machine d’aller se positionner sur une position préalablement définie, qui pourrait correspondre à celui d’une sonde d’outil, par exemple, où tout simplement au coin supérieur gauche de repos de la machine (sans déclencher les fins de course). Pour définir cette position, positionnez (par jogging) la broche exactement où vous le souhaitez, puis revenez sur cette page réglage, et appuyez sur le bouton “Ré”, pour entrer ce réglage. Par la suite, à la fin de votre programme GCode (si votre générateur ne le fait pas), ajoutez cette commande G28, et la machine retournera à cette position que vous venez de définir. Même chose pour G30.

Comme indiqué au-dessus de ces sous-panneaux, ces réglages sont sauvegardés à chaque fois que vous quittez le programme, vous n’avez donc rien à faire pour les conserver.

4 – Fonctionnement

Nous aurons d’autres occasions de revenir plus en détail sur les différentes manières de régler et faire fonctionner une machine, et donc de revenir sur décalages (offsets), référencements (homing), etc. Pour l’instant nous allons simplement expliquer les bases du fonctionnement du Panneau de Contrôle Grbl pour faire fonctionner votre machine. En gros, on a 2 manières principales de piloter sa machine au travers de Grbl depuis le panneau de contrôle: “manuellement”, en envoyant directement des commandes GCode, où par un fichier de programme GCode.

La partie “manuelle” comporte la partie “Jogging”, mais aussi la zone de saisie “Commande Manuelle”, où vous pouvez saisir vous-même une commande, où une suite de commandes, qui sont envoyées à la machine lorsque vous pressez le bouton Envoi. Il comporte aussi la partie “Macros”, qui peut s’avérer très pratique pour de petites opérations “semi manuelles”. Vous définissez une macro dans l’onglet du même nom, et vous verrez apparaître, sous la zone de saisie de commande manuelle, un bouton du nom de votre macro. Appuyer sur ce bouton envoi à la machine la suite de commandes GCode définie dans votre macro.

Panneau de Contrôl Grbl en action
Le panneau de Contrôle prêt à lancer l’exécution d’un programme GCode

La partie “automatique”, où Fichier GCode, commence par la sélection d’un fichier GCode, en cliquant l’icone ressemblant à un document. Une fois le fichier chargé, les éventuelles lignes de statut créées par l’envoi de commandes manuelles sont remplacées par les lignes du programme GCode. La colonne statut passe de “Sent”, lorsqu’elle à été envoyée à Grbl, à “OK” une fois exécutée, où à ‘’Err” si GRBL n’a pas pu comprendre/exécuter la commande. Selon l’erreur, vous pouvez sélectionner la ligne de code suivante, et presse la flèche envoi à nouveau, pour poursuivre l’exécution du programme. J’ai personnellement expérimenté avec un programmes GCode dépassant allégrement le million de lignes sans rencontrer le moindre problème. Le dernier commentaire rencontré s’affiche dessous “Message”.

Pendant l’exécution d’un programme GCode, tous les boutons, zones, etc. , sont désactivés sauf les boutons pause et arrêt, qui vont respectivement mettre en pause le déroulement de la lecture des lignes de GCode, où complétement arrêter le programme.

Conclusion

Ce contrôleur pour Grbl n’est certainement le plus connu des divers programmes existants ayant la même fonction, mais c’est à mon sens le plus complet, offrant des possibilités inconnues des autres logiciels du même type, telles que macros et plusieurs décalages pré-réglés. Il intègre déjà toutes les nouvelles fonctions de la version 1.1 de Grbl, et est entièrement en Français (si votre Windows est réglé pour être en Français).

Vous pouvez télécharger les sources de Grbl-Panel sur GitHub: https://github.com/gerritv/Grbl-Panel, et compiler/modifier avec Visual Studio. Peut-être plus pratique pour beaucoup, vous pouvez télécharger les fichiers binaires ici, sur le site, mais aussi sur Github, en téléchargeant la dernière mise à jour, V1.0.9.8.

Un petit mot, pour finir, sur le futur du Panneau de Contrôle Grbl. Gerrit et moi avons pas mal discuté pendant mon travail de localisation/traduction, qui va permettre à ce logiciel d’être maintenant traduit dans d’autres langues que juste Anglais et Français. Il nous apparaît évident à tous deux qu’il est beaucoup plus pratique, et conforme aux pratiques “modernes”, de piloter sa machine CNC depuis une tablette que depuis un vieux PC coincé à l’atelier, prenant poussière et toiles d’araignées…. C’est pourquoi le Grbl-Panel, en dehors d’autres améliorations ponctuelles, va être porté en C# avec Xamarin, de manière à pouvoir être exécuté depuis n’importe quel matériel fonctionnant sous Windows où sous Android, en communiquant avec l’Arduino par Bluetooth (donc sans fil), et peut-être aussi sous Apple/IoS.

Autrement dit, le Panneau de Contrôle GRBL est bien vivant, et va continuer à évoluer. Si vous avez des remarques, suggestions, souhaits, n’hésitez pas à en faire part, nous ferons de notre mieux, avec Gerrit, pour en tenir compte si cela apparaît faisable, et souhaitable…

[product id=5474]




Configurer et Paramètrer GRBL

C’est une question qui revient souvent, après avoir installé GRBL. Comment dois-je faire pour configurer et paramètrer GRBL pour ma machine? Bien sûr, chaque machine est différente, dans ses courses, dimensions, moteurs, vitesse dont elle est capable, etc.…

Il y a deux types différents de “réglages” possible: “En dur”, à la compilation, en modifiant des valeurs dans un fichier, et en interactif, alors que le programme s’exécute. Dans la suite de cet article, et pour mieux différencier les deux, on va appeler les réglages en dur “configuration”, et ceux en interactif “paramétrage”, même si cette différence de vocabulaire est un peu arbitraire. J’espère simplement que cela contribuera à la compréhension.

Configuration

On va commencer par décrire ce qui ne l’est pas très souvent, la modification de valeurs dans certains fichiers qui seront compilés avec GRBL lorsque vous le flashez sur l’Arduino. Si vous avez déjà installé GRBL dans votre Arduino, vous l’avez certainement compilé et flashé tel que, sans faire de modifications. Très bien, cela fonctionne, et ce n’est pas un problème particulier. Il peut cependant être utile de savoir comment modifier la configuration de base, et en quoi cela peut vous aider.

Dans votre IDE (Visual Studio pour moi), ouvrez le fichier config.h qui doit se trouver dans votre répertoire GRBL.  C’est un assez long fichier (+- 400 lignes) extrêmement bien commenté, en Anglais bien sûr. Nous allons isoler ici les paramètres de configuration les plus importants pour s’adapter au mieux à votre machine spécifique.

Tout d’abord, si vous liez en parallèle 2 interrupteurs de butée pour 1 même axe, au lieu d’avoir un switch câblé séparément pour chaque extrémité, il faut dé-commenter la ligne commençant par define, ci-dessous, en supprimant les “//”

// If your machine has two limits switches wired in parallel to one axis, you will need to enable
// this feature. Since the two switches are sharing a single pin, there is no way for Grbl to tell
// which one is enabled. This option only effects homing, where if a limit is engaged, Grbl will
// alarm out and force the user to manually disengage the limit switch. Otherwise, if you have one
// limit switch for each axis, don't enable this option. By keeping it disabled, you can perform a
// homing cycle while on the limit switch and not have to move the machine off of it.
// #define LIMITS_TWO_SWITCHES_ON_AXES

Ensuite, et toujours en liaison avec vos interrupteurs de fin de course, il faut définir si vous câblez vos switches en “normalement ouvert”, où en “normalement fermé”. Par défaut, GRBL est défini pour utiliser des switches normalement ouverts. Dé-commentez la ligne pour un fonctionnement en normalement fermé:

// Inverts pin logic of the control command pins. This essentially means when this option is enabled
// you can use normally-closed switches, rather than the default normally-open switches.
// NOTE: If you require individual control pins inverted, keep this macro disabled and simply alter
// the CONTROL_INVERT_MASK definition in cpu_map.h files.
// #define INVERT_ALL_CONTROL_PINS // Default disabled. Uncomment to enable.

 

Depuis peu, GRBL est capable de gérer (s’il reçoit les commandes G-Code correspondantes) la vitesse de rotation de la broche. Si vous vous servez de cette fonction, laissez là activée (elle l’est par défaut), sinon désactivez-là. Si vous la laissez activée, il vous faudra aussi définir la plage de vitesses dont votre broche est capable:

// Enables variable spindle output voltage for different RPM values. On the Arduino Uno, the spindle
// enable pin will output 5V for maximum RPM with 256 intermediate levels and 0V when disabled.
// NOTE: IMPORTANT for Arduino Unos! When enabled, the Z-limit pin D11 and spindle enable pin D12 switch!
// The hardware PWM output on pin D11 is required for variable spindle output voltages.
#define VARIABLE_SPINDLE // Default enabled. Comment to disable.

// Used by the variable spindle output only. These parameters set the maximum and minimum spindle speed
// "S" g-code values to correspond to the maximum and minimum pin voltages. There are 256 discrete and
// equally divided voltage bins between the maximum and minimum spindle speeds. So for a 5V pin, 1000
// max rpm, and 250 min rpm, the spindle output voltage would be set for the following "S" commands:
// "S1000" @ 5V, "S250" @ 0.02V, and "S625" @ 2.5V (mid-range). The pin outputs 0V when disabled.
// BG Note: As the spindle max speed is said to be 12K, that's what I set here. Should never go that fast in the GCode, but I will test.

#define SPINDLE_MAX_RPM 18000.0 // Max spindle RPM. This value is equal to 100% duty cycle on the PWM.
#define SPINDLE_MIN_RPM 0.0 // Min spindle RPM. This value is equal to (1/256) duty cycle on the PWM

Jusqu’à présent, je n’ai pas eu besoin de m’intéresser de près aux autres paramètres du fichier config.h, mais sachez que vous avez peut-être là la solution à certaines difficultés que vous pourriez rencontrer en utilisant GRBL

Paramétrage

Le paramétrage se fait alors que l’Arduino est branché et que vous êtes en liaison série avec lui. Il existe beaucoup de logiciels différents permettant d’envoyer le G-Code et de contrôler GRBL, que ce soit depuis un PC, un Mac où une machine Linux. Pour éviter d’entrer de suite dans d’autres considérations de choix pour ces logiciels, nous allons paramétrer GRBL le plus simplement du monde avec un terminal série, en envoyant manuellement les commandes.

Réponse de GRBL lors d'une connection sérieLorsque vous vous connectez avec un terminal série sur votre Arduino, si le flashage s’est passé correctement, vous devriez obtenir une réponse Grbl 0.9j [‘$’ for help], tel que vous  pouvez le voir ici.

Pour lister l’ensemble des paramètres qui vous permettront d’adapter Grbl aux spécificités de votre machine, il vous suffit de taper $$. Grbl va répondre en renvoyant la liste visible ci-dessous.

Paramètres 100, 101 et 102, nombre de pas par millimètre.

Nous allons tout d’abord nous intéresser aux paramètres 100, 101 et 102. Ces paramètres, comme indiqué dans le commentaire Liste des constantes de réglage dans GRBL, obtenue par $$entre parenthèses, définissent le nombre de pas (des moteurs pas à pas) nécessaires pour parcourir une distance de 1 millimètre sur l’axe indiqué. La plupart du temps, 100 et 101 (X et Y) seront identiques, alors que Z (102) aura une valeur différente. Pour vous faciliter la tache, vous trouverez au bas de l’article un calculateur pour trouver cette valeur, mais la formule est assez simple:

Valeur = Nombre de pas (du moteur) pour faire 360°/Pas de la Visse sans fin (où nombre de dents de la poulie * espace dents chaîne où courroie)

Résultat = Valeur x Micro Pas.

Exemple: Moteur Nema 17, 1.8° par pas, soit 200 pas pour 360°

Courroie dentée, 2mm d’espace entre dents.

Poulie 20 dents

Opération: (200/40) * 4 (par exemple) = 5

Dans cet exemple, il faut 5 pas des moteurs pour parcourir une distance de 1 millimètre. Attention, dans GRBL, tout est en millimètres, donc, si vous avez des dimensions en pouces (inches), n’oubliez pas de multiplier par 25,4 avant de faire vos opérations.

Paramètres 130, 131 et 132. Distance maximum à parcourir sur chacun des axes.

Ici, il n’y a pas de calcul à faire, il suffit d’entrer en millimètres  la longueur de coupe sur cet axe. En théorie, et en l’absence de fausses manipulations, si ces distances sont entrées correctement, les détecteurs de fin de course devraient être inutiles.

Paramètres 110, 111 et 112. Vitesse maximum sur X, Y et Z.

Ici on entre plus dans le domaine de l’expérimentation personnelle que dans le purement rationnel. Il s’agit ici de vitesse de déplacement maximum, HORS TRAVAIL, c’est à dire pour se repositionner, et pas pour couper. Il y a de nombreuses discussions sur les forums à ce sujet, et nombreux sont ceux qui soutiennent que des valeurs de 12 000 à 14 000 sont parfaitement acceptables, alors que d’autres pensent que 5 000 est bien suffisant. Tout dépend de votre mécanique ET de votre électronique. Pour commencer, une valeur de 8 000 me semble correcte, et la moitié, 4 000, pour l’axe des Z. Expérimentez avec des commandes manuelles pour voir comment votre machine se comporte.

Paramètres 24, 25, 26 et 27.  Homing. Comme dans E.T., « maison »!

La procédure de homing (retour à la maison, plus techniquement, point 0, où X= 0, Y = 0 et Z = 0), est importante, et pas le plus simple réglage à effectuer, mais il n’est pas obligatoire, simplement il faudra, s’il n’est pas utilisé, que tous vos fichiers G-Code soient générés pour exprimer des coordonnées relatives, et pas absolues, un concept sur lequel nous reviendrons plus tard. Tout d’abord, ces paramètres ne seront pris en compte que si le paramètre 22 est à 1 (activé), et il faut que vous ayez câblé vos fins de course.

La procédure de Homing va déplacer le portique sur X et Y, d’abord relativement vite, jusqu’à ce qu’il touche les fins de course, puis plus lentement pour détecter le point exact où l’interrupteur se déclenche, en effectuant des mouvements lents de va et vient.

  • Le paramètre 24 correspond à cette vitesse lente. 25 mm/min devrait fonctionner. Le but est d’obtenir une localisation exacte et répétable à chaque fois.
  • Le paramètre 25 correspond à la vitesse de déplacement jusqu’à déclencher les interrupteurs. Une vitesse trop élevée, et votre portique risque de heurter violemment vos fins de course. Une vitesse trop lente, et le processus va prendre trop de temps. Expérimentez, 500 à 600 mm/min sont de bonnes valeurs de départ.
  • Le paramètre 26 est la valeur en millisecondes pendant laquelle le signal électrique de l’interrupteur peut « rebondir » lorsqu’il est déclenché. Ce bruit peut (et devrait!) être filtré électroniquement, mais GRBL utilise ce court délai pour laisser le temps au signal de se stabiliser.
  • Le paramètre 27 est la valeur de laquelle le processus de homing va se décaler des fins de course, de manière à éviter un déclenchement accidentel des fins de course, une fois que le processus à été achevé.

Il n’est normalement pas nécessaire de toucher aux autres paramètres, sauf cas très particuliers, sur lesquels nous reviendrons éventuellement à l’occasion.

Paramètres GRBL modidiés 110, 111 et 112Comment changer les paramètres?

Il suffit de taper $nombre du paramètre = nouvelle valeur, par exemple $110=10000. Faites à nouveau $$ pour vérifier les nouvelles valeurs. Comme vous pouvez le voir sur cette copie d’écran les paramètres 110, 111 et 112 ont été modifiés.

Conclusion

J’espère que cet article aura levé certaines difficultés à l’utilisation de Grbl. Bien que ce programme ne nécessite qu’un Arduino Uno, il est assez complet et permet de piloter des machines CNC « comme les grands ». Dans un prochaine article, nous évoquerons différents programmes pilotant l’Arduino par le biais d’une interface graphique, et examinerons l’un deux plus en détails, sa version Française devant être disponible sous peu.

[CP_CALCULATED_FIELDS id= »6″]

Bien que tout ce qui précède soit relatif à GRBL, un certain nombre de principes et de calculs sont valables pour TOUTES les machine CNC.



Visual Micro pour coder Arduino avec Visual Studio

Je ne sais pas pour vous, mais ces cartes microcontrôleur qui nous envahissent sous différentes formes sont extrêmement séduisantes pour ceux qui aiment “bidouiller”, d’autant qu’elles ouvrent la porte à tout un monde de capteurs divers et variés, circuits, montages, etc. Visual Micro permet de coder ces cartes depuis la Rolls des environnements de développement, Visual Studio.

 Pour quelqu’un qui vient, comme moi, d’une informatique de gestion, principalement, pouvoir faire clignoter une LED avec un petit bout de code à quelque chose de magique. Il était donc logique de s’intéresser à la plus répandue de ces cartes, très bon marché, qui est maintenant toute une famille, l’Arduino. Plus spécifiquement, dans mon cas, l’Arduino Uno, puisque mes besoins ne nécessitent pas plus, mais ce que je vais décrire dans cet article est valable pour toute la famille, et bon nombre de clones.

Au début, je n’ai pas écrit grand chose, comme code, l’environnement de programmation, une application Java disponible sur le site officiel (https://www.arduino.cc/), me convenait très bien dans la mesure où il me permettait facilement de flasher la carte avec les exemples trouvés ici et là.

Au bout de quelque temps, lorsque des idées de projets personnels ont commencées à se bousculer, et donc qu’il me fallait actuellement coder, je n’ai pu m’empêcher de regretter les diverses fonctionnalités présentes dans l’éditeur de Visual Studio. (J’en profite pour indiquer à ceux qui ne le sauraient pas encore, qu’il existe une version gratuite, aussi puissante que la version pro, appelée Visual Studio Community. Disponible ici: https://www.visualstudio.com/fr-fr/products/visual-studio-community-vs.aspx ). La version Community, par différence avec les “anciennes” versions Express, accepte les plugins, et ne vous limite pas à un seul type de développement, comme c’était le cas.

Je me suis donc mis à rêver une extension permettant d’écrire du code pour Arduino, directement depuis Visual Studio. Comme bien souvent, ce rêve correspondait à un réel besoin, je n’étais donc sûrement pas le seul à l’avoir fait. Après quelques recherches (Google is my friend!), j’ai découvert un produit appelé “Visual Micro” http://www.visualmicro.com/, le nom d’un plugin développé exactement dans ce but.

Plus qu’un éditeur dédié à l’Arduino, utilisant les capacité de l’éditeur de Visual Studio, il s’agit d’un véritable environnement pour Arduino et compatibles, intégré à Visual Studio. Ce plugin est gratuit, mais si vous vous en servez régulièrement, vous voudrez sans doute acquérir la version Pro (ce que j’ai fait), elle comporte quelques fonctionnalités supplémentaires, notamment coté debugger.

Voyons donc comment installer, régler, et utiliser cet outil dont je ne pourrais plus me passer, maintenant que je m’y suis habitué.

Pré-requis et Installation

Tout d’abord, il faut que l’environnement Arduino déjà cité soit installé sur votre machine, puisqu’avec lui sont installés un certain nombre d’utilitaires et de librairies qui vont être utilisés par Visual Micro. Les dernières versions de Visual Micro vous permettent de télécharger et d’installer l’IDE Arduino directement depuis l’écran de setup, au cas où vous n’auriez pas encore installé Arduino sur votre machine. Nous allons voir ci-dessous ces différentes étapes, en partant de Visual Studio Community avec Visual Micro gratuit, sur une machine Windows 10 en 64 bits (A ma connaissance, aucune différence avec Windows 7 pour cette installation).

La première fois que vous lancez Visual Studio après avoir téléchargé et installé Visual Micro, l’écran de configuration va apparaître:

Il vous faut entrer les chemins correspondant à votre installation de l’IDE Arduino. Dans mon cas, l’Ide n’étant pas installé sur cette machine, je cliques sur le bouton “Download/Install Ide”, ce qui m’amène à la page de téléchargement du logiciel Arduino, où je choisis l’installateur pour Windows:

Une fois l’environnement Arduino installé, il vous faut indiquer les chemins. Par défaut, C:\Program Files (x86)\Arduino. Vous pouvez tester si votre environnement est correctement réglé dans Visual Micro en ouvrant Visual Micro Explorer (Il y a une nouvelle option dans le menu supérieur de Visual Studio, dénommée “vMicro”). Vous devriez voir la liste de toutes les cartes gérées, ainsi que l’ensemble des librairies installées:

Selon les cas, vous pouvez avoir à localiser l’emplacement où Arduino installe les librairies et “sketches”. Sur ma machine, c’est dans “C:\Users\USERNAME\Documents\Arduino”. Si c’est le cas, il vous faut indiquer ce chemin sur l’onglet “Configure”.

Maintenant, vous pouvez tester pour vérifier si votre installation est correcte. Branchez votre Arduino avec un câble USB, Windows doit le reconnaître (vous avez installé le driver à la fin de l’installation de l’IDE). Chargez un des exemples (Onglet Exemples). Le plus classique est “Blink.ino”. Commencez par créer un nouveau projet: Fichier/Nouveau Projet/ Arduino Project:

Le fichier Blink.ino est créé pour vous, vide. Il faut le supprimer, et faire ajout, pour aller chercher le fichier (déjà ouvert si vous avez cliqué sur son nom depuis Visual Micro Explorer) Si vous passez la souris sur le tab du nom du fichier, dans Visual Studio, le chemin est indiqué. Vous devez copier le fichier pour le mettre dans le répertoire du projet, à moins que vous n’exécutiez Visual Studio en mode Administrateur, ce qui n’est pas vraiment conseillé. Une autre solution est tout simplement de copier le contenu du fichier Blink exemple dans le fichier créé par Visual Studio.

Après avoir vérifié que le Port Com sélectionné est bien celui correspondant à votre Arduino, vous pouvez cliquez sur la petite flèche pour compiler et envoyer le code dans l’Arduino:

La fenêtre de sortie doit vous indiquer après quelque temps la réussite de l’opération, et vous devriez voir la led liée au Port 13 de l’Arduino clignoter toutes les secondes. Ce test est le plus classique parce qu’il ne nécessite aucun matériel en dehors de la carte elle-même.

Quels avantages? (Et éventuels inconvénients?)

Si vous êtes déjà familier avec Visual Studio, vous le savez déjà! Sinon, vous allez vite voir que c’est un excellent, si ce n’est le tout meilleur, environnement de développement actuellement disponible, et ce, complétement gratuitement! Voici une petite liste des fonctionnalités de Visual Micro avec Visual Studio:

  • Complétement compatible avec l’IDE Arduino, chaque projet de l’IDE Arduino est un projet Visual MIcro, et vice versa. Utilise les outils Arduino en arrière plan.
  • Interface utilisateur hautement configurable (Disposition des fenêtres, couleurs et fontes, barres d’outils..)
  • Supporte IntelliSense: Auto-suggestions, auto-complétions et nom des classes lorsque vous tapez
  • Vérification syntaxique “juste à temps”: Détecte, surligne et explique les erreurs de syntaxe immédiatement sans compilation
  • Support pour de multiples fichiers .ino, .cpp par projet, sous-dossiers de projet pour de plus grand projets.
  • Support pour un grand nombre de cartes: Arduino et compatibles, Teensy, Sparkfun, Adafruit, Intel,…
  • Débuggeur unique ( points d’arrêt, traçage, surveillance et changement de variables) [Uniquement dans la version pro, gratuit pendant une période d’essai.] Aucun matériel spécifique requis, fonctionne avec USB comme avec WiFi.
  • Puissant gestionnaire de librairies
    • Télécharge des libraires tierce et les intègres à Visual Micro
    • Recherche de librairies en-ligne
  • Gestionnaire de cartes: Téléchargez le support de nouvelles cartes directement depuis l’IDE, pas d’installation requise
  • Travailles avec plusieurs cartes simultanément
  • Création de nouvelles librairies Arduino en un clic
  • Support pour GIT et TFS
  • Partage de code avec d’autres projets
  • Base installée de plus de 10 000 utilisateurs
  • Support de programmateurs et boot loaders
  • Services Gratuits:
    • Support au travers d’un forum modéré
    • Mises à jour continues et gratuites pour une compatibilité certaine avec les dernières version de l’IDE Arduino
    • Documentation complète
  • Supporte Visual Studio 2012, 2013 et 2015

A cette liste déjà longue, je voudrais ajouter 2 éléments découverts à l’usage,

  1. Utilisation du système de “Solutions” de Visual Studio

Ce qui peut sembler un inconvénient, si on est habitué à l’IDE Arduino, apportant une certaine lourdeur au regard de la simplicité de “télé verser” un simple fichier vers la carte micro-contrôleur, est en fait, à l’usage, un immense avantage. Il est en effet très facile de regrouper divers projets dans la même solution, que ces projets soient Arduino, où pas! Cela vous permet d’avoir, par exemple, plusieurs projets Arduino regroupés sous la même solution. Très facile alors de tester divers exemples, et de développer votre propre code à partir de ceux-ci. Très pratique aussi dans le cas où vous développez un programme Windows dialoguant par communication série avec votre carte. Vous pouvez afficher simultanément les 2 codes l’un à coté de l’autre.

 

  1. Sur cette copie d’écran, vous pouvez voir 5 projets dans la même solution. Deux sont des projets Arduino et trois des projets Windows, comprenant deux librairies. Visual Studio permettant de passer très facilement d’un projet à l’autre (Définir comme projet de démarrage), vous pouvez compiler à la fois pour Windows et pour Arduino depuis la même solution.
  2. 2. Possibilité d’utiliser le contrôle de version, lié à Visual Studio

Si vous n’utilisez pas de système de contrôle de version, vous devriez! Vous pouvez créer un compte Visual Studio Team Services gratuitement et gérer autant de projet que vous voulez. Ce projet peut être partagé avec 4 autres personnes. Le service devient payant au-delà. Ce serait vraiment dommage de se priver de se service, d’autant que vous pouvez choisir d’utiliser Gît.

En guise de conclusion sur Visual Micro

Je ne me vois pas revenir à l’utilisation exclusive de l’IDE Arduino pour mes développements. Le simple fait de bénéficier d’IntelliSense suffirait sans doute à faire pencher la balance, pour moi. Mais toutes les fonctions apportées sont utiles, le contrôle de version étant sans doute dans le tiercé de tête. Si vous codez souvent pour l’Arduino, si vous avez un projet qui vous tient à cœur, essayez Visual Micro, et dites-moi ce que vous en pensez.

Petite précision pour la transparence: je n’ai strictement aucun intérêt financier, ni avec Visual Micro Limited, la société éditrice de ce plugin, ni avec Microsoft.




Salut du Bear.

Finalement!

Voilà, Le Bear CNC est maintenant “officiellement” en ligne. Oui, ça a mis longtemps, et non, c’est loin d’être complet et terminé. Terminé, le site ne le sera sans doute jamais. Il sera en évolution constante, en fonction de vos souhaits, de vos désirs, et.. de vos achats….

Notre but est de faire de ce site une plate-forme “incontournable”, comme on dit, en ce qui concerne la CNC amateur. Il existe plein de sites et de blogs où sont décrits soit des machines et des réalisations, soit des boutiques offrant divers produits “en vrac”, avec bien peu d’explications sur le pourquoi du comment, pourquoi des choix, comment utiliser. L’Idée derrière le Bear CNC est de ne proposer que des produits pour lesquels nous avons une expérience d’utilisation, que nous décrirons au travers d’articles techniques détaillés, et, selon les cas, appuyés par des vidéos explicatives. Certains de ces produits seront des réalisations “Made in Le Bear”, parce que nous aurons détecté un besoin spécifique.

Dans l’ensemble, la partie électronique et logicielle s’appuiera sur GRBL, le firmware écrit spécifiquement pour l’Arduino Uno. Il existe de nombreux logiciels pour envoyer le GCode et contrôler le déroulement des opérations avec GRBL. Nous aurons de nombreux articles à ce sujet, et vous proposerons un logiciel pour PC EN FRANCAIS (nous sommes sans doute les seuls à le faire) dans ce but. Cela ne veut pas dire que nous laisserons complétement tomber les utilisateurs de Mach3 où de PlanetCNC. Nous n’avons cependant aucune intention de “pousser” à l’utilisation de ces systèmes, à la fois pour des raisons de coût, et de flexibilité. En effet, même la plus moderne version de Mach3, Mach4, ne propose pas de version USB par défaut (il faut un module complémentaire), et encore moins de liaison sans fil.

Nous verrons au fur et à mesure les solutions possibles, ainsi que la chaîne logicielle complète, de l’idée de départ à la réalisation de la pièce par fraisage CNC.

Nous somme bien évidemment à l’écoute de vos remarques et commentaires. N’hésitez surtout pas à partager vos attentes et à faire part de vos critiques, constructives, bien sûr!