Carrefour numérique² - fablab

Cette page est en lecture seule. Vous pouvez afficher le texte source, mais pas le modifier. Contactez votre administrateur si vous pensez qu'il s'agit d'une erreur.
====== Shield simple pour arduino uno ======

<!-- Complétez la fiche projet ci dessous -->
{{{project
picture: {{:usager:tdasse:shield_arduino:arduino-shield.png?200|}}
machines: MMM30
materiaux: plaque FR4
logiciels: Kicad, Flatcam
fichiers: {{:usager:tdasse:kicad_tools:fablab_cn2.zip}} {{:usager:tdasse:shield_arduino:shieldarduinouno.zip}}
liens:
tags:
usager:thierry_dasse 
licence:cc-by-sa
}}}

** documentation en cours - dernière modification 30/08/2018 **

L'objectif de ce projet est de documenter toutes les étapes de conception et de réalisation d'un circuit électronique en utilisant : 

  * Kicad pour la conception du circuit imprimé
  * Flatcam pour générer les fichiers machines (gcode)
  * la fraiseuse MMM30 pour la gravure, le perçage et la découpe du circuit
  * Un fer à souder pour l'assemblage
  * l'IDE Arduino pour un programme utilisant le circuit


===== Conception =====

==== Le circuit ====

Pour ce tutoriel, nous avons choisi de réaliser un circuit assez simple sous la forme d'un shield (carte que l'on branche sur une autre carte pour ajouter des fonctionnalités) pour une carte arduino uno. Ce shield contiendra une led (avec une résistance de 150Ω en série) sur la sortie digitale 2, un bouton poussoir sur la sortie 3 et un potentiomètre sur l'entrée analogique A0.

Ce montage peut être réalisé sur breadboard de la façon suivante : 

{{:usager:tdasse:shield_arduino:shield_bb.png?200|}}

Pour réaliser ce shield, nous aurons besoin de données précises sur l'arduino uno et notamment des positions des pins d'entrées sorties.
Le schéma ci-dessous donne les informations nécessaires.

{{:usager:tdasse:shield_arduino:arduino_uno_drawing.png?200|}}


==== Conception avec Kicad ====

===Kicad?===

Kicad est un logiciel de dessin de circuit électronique. C'est un logiciel libre et gratuit développé initialement en 1992 par  Jean-Pierre Charras. Aujourd'hui Kicad est activement maintenu et mis à jour par une large communauté de développeurs ce qui rend cet outil très évolutif. Pour un descriptif plus détaillé de l'histoire de ce logiciel voir le lien suivant (en anglais): [[http://kicad-pcb.org/about/kicad/]]


Parmis les fonctionnalités intéressantes on peut noter:

-Dessin symbolique du schéma électrique

-Création de sa propre librairie de composants

-Connexion automatique des différents composants

-Visualisation 3D du rendu final du circuit

-...

Pourquoi l'utiliser?

-> Il est de plus en plus utilisé comme logiciel standard de développement au niveau professionnel, ce qui peut être intéressant pour celles et ceux qui veulent évoluer vers ce secteur d'activité.

-> Permet au "Makers" de produire des prototypes avec un niveau de finition "pro" (ça fait toujours plaisir).
  

===Liens Utiles===

Ce tuto est très orienté autour de notre projet de "Shield Arduino Uno". Pour cette raison, on ne pourra pas couvrir toutes les fonctionnalités du logiciel. Pour aller plus loin, vous pouvez vous orienter vers les liens suivants (valide le 12/07/2018):

-Documentation officielle: [[http://kicad-pcb.org/help/tutorials/]]

-Blog :[[http://dirtymarmotte.net/?s=Kicad]]

- Un très bon tutoriel est intégré dans kicad. Il est disponible dans le menu Aide/Démarrer avec Kicad

=== Installation du logiciel ===

Pour installer KiCad sur votre station de travail, le mieux c'est de passer par le site officiel de la page KiCad ou vous trouverez les liens de téléchargement correspondant à votre OS (lien valide le 12/07/2018):

[[http://kicad-pcb.org/download/]]

Pour rappel et pour simplifier voici en résumé les procédures d'installation pour **MacOsX** et **Linux-Ubuntu|Mint**

-Installation **MacOSX** (essai sur Os v10.11.6):

La façon la plus simple d'installer KiCad sur MacOS est de passer par la page de téléchargement officielle et de cliquer sur les liens listés dans le paragraphe "Stable Release" (Version Stable):

[[http://kicad-pcb.org/download/osx/]] 

Vous devez télécharger les deux fichiers **.dmg**. Après avoir cliqué sur le fichier **Kicad-4.*.*.dmg** vous suivez les instructions affichée à l'écran. Il vous faudra les droits d'écriture pour finaliser l'installation (root)


-Installation pour **Ubuntu, Linux Mint** : 

L'installation sur Linux proposée sur le site de kicad ([[http://kicad-pcb.org/download/ubuntu/]]) est extrêmement minimaliste. Elle ne comprend pas les librairies de composants et la documentation. Nous vous pproposons une installation plus complète de Kicad. Elle se fait en ligne de commande. Ouvrez un terminal de commande (raccourci **<ctrl>+<alt>+<T>**). Vérifier que vous possédez les droits administrateur (mot de passe demandé). Puis copiez-collez les lignes de commandes suivantes:

<code>
sudo add-apt-repository --yes ppa:js-reynaud/kicad-4
sudo apt-get update
sudo apt-get upgrade
sudo apt-get install kicad kicad-library kicad-demo extra-xdg-menus kicad-locale-fr kicad-doc-fr 
</code>

Votre mot de passe sera demandé à la suite de la première commande (avant exécution).

=== Les différentes étapes ===

Sur Kicad, la conception d'un circuit imprimé ou PCB (printed circuit board) se fait en deux grandes étapes. D'abord on crée un schéma qui défini les composants qui seront utilisés, les liaisons entre ces composants sans prendre en compte la forme réelle du composant, son type (traversant ou de surface) ou sa position sur la carte. Ensuite, on dessine le circuit en choisissant les composants réels, leur position et les trajets des pistes.

{{:usager:tdasse:shield_arduino:schema_pcb.png?200|}}

Pour commencer, on lance Kicad et on clique sur {{:usager:tdasse:shield_arduino:new_project.png?26|}} Nouveau Projet (**<ctrl>+<N>**)
Je vous conseille vivement de créer un dossier Kicad pour chaque projet car KIcad génère une dizaine de fichiers par projet.

=== Création d'un schéma ===

On crée le schéma en cliquant sur le bouton {{:usager:tdasse:shield_arduino:eeschema_editor.png?56|}}

On se retrouve sur une feuille de travail. Commençons, tout d'abord, par ajouter les premiers composants. Cela peut se faire en cliquant sur {{:usager:tdasse:shield_arduino:add_component.png?26|}} puis dans la page ou directement avec la touche **<A>**.

Commençons par insérer d'abord une led (**<A>** puis taper led dans le filtre) puis une résistance(**<A>** puis taper R dans le filtre)

{{:usager:tdasse:shield_arduino:add_led.png?150|}}

On peut ensuite déplacer le composant en utilisant la touche **<G>** ou **<M>** (**<G>** déplacera le composant avec ses liaisons, **<M>** le composant seul), le tourner avec **<R>** et lui faire subir une symétrie d'axe horizontal ou vertical avec les touches **<X>** et **<Y>**.

On peut également fixer la valeur de la résistance au survol du composant à l'aide de la touche **<V>** en remplaçant R par 150 et obtenir un début de schéma comme ci-dessous.

{{:usager:tdasse:shield_arduino:schema_step1.png?200|}}
 

On peut ensuite relier la résistance et la led avec l'outil {{:usager:tdasse:shield_arduino:add_line.png?26|}} ou avec la touche **<W>** à l'endroit de départ.

Si on souhaite ensuite créer le composant Arduino uno, on se rend compte qu'il n'existe pas dans les librairies Kicad. Nous avons à ce moment là deux options : chercher une librairie contenant le composant ou le créer nous même. Kicad contient un éditeur de composants performant et assez facile à utiliser. Nous opterons donc pour la deuxième solution.


=== Création d'un composant ===

La création d'un composant se fait dans l'éditeur de librairies schématiques {{:usager:tdasse:shield_arduino:library_editor.png?56|}} disponible sur la page principale ou directement dans l'éditeur de schéma.

On peut sélectionner une librairie de travail à l'aide de {{:usager:tdasse:shield_arduino:open_library.png?26|}} pour créer ou modifier des composants dans une librairie déjà existante. 
Nous allons plutôt opter pour créer nos composants dans une nouvelle librairie qui nous servira ensuite pour tous les nouveaux composants de nos projets. Pour cela il suffit de commencer à créer un composant avec {{:usager:tdasse:shield_arduino:add_component.png?26|}} que nous appelerons, par exemple, Arduino_uno de référence SH (utilisé pour la numérotation des composants).

Un composant est principalement constitué de pin d'entrée sortie. Il est important de spécifier un numéro de pin et/ou de renseigner un nom (VCC, GND, A0, ...). On ajoute un pin avec {{:usager:tdasse:shield_arduino:pin.png?26|}} ou la touche **<P>**.

On utilisera le schéma ci-dessous pour créer le composant.

{{:usager:tdasse:shield_arduino:arduino_uno_pinout.jpg?200|}}

[[http://carrefour-numerique.cite-sciences.fr/fablab/wiki/lib/exe/fetch.php?media=usager:tdasse:shield_arduino:arduino_uno_pinout.jpg|Afficher l'image]]
  
Après avoir ajouté les pins, on peut créer un rectangle avec {{:usager:tdasse:shield_arduino:add_rectangle.png?26|}}. Avec la touche **<E>** sur le rectangle, on peut modifier ses propriétés, notamment lui affecter une couleur d'arrière plan et obtenir le résultat ci-dessous.

{{:usager:tdasse:shield_arduino:arduino_uno_component.png?200|}}

Pour enregistrer la librairie, cliquer sur {{:usager:tdasse:shield_arduino:new_library.png?26|}} : Sauver le composant courant dans une nouvelle librairie. Je vous conseille de créer un répertoire pour les libraires kicad (en dehors de celui du projet) pour pouvoir les retrouver facilement pour d'autres projets. J'ai personnellement créé l'arborescence ci dessous sur mon disque et je m'y retrouve pas trop mal (le dossier fablab.pretty contiendra les empreintes des composants, ce dont nous parlerons plus loin). Vous pouvez ensuite fermer la fenêtre de l'éditeur de librairies.

{{:usager:tdasse:shield_arduino:folders.png?220|}} 

**Attention**, il ne suffit pas d'avoir créé une librairie pour pouvoir l'utiliser, il faut encore l'associer au projet.
Pour cela, Aller dans Préférences/Librairie de composants, ajouter le chemin contenant la librairie dans la deuxième partie de la fenêtre puis, ce chemin étant sélectionné, ajouter la librairie que vous avez créé (elle doit apparaître à la fin de la liste).
Cette librairie a été ajoutée pour le projet en cours, il faudra le faire pour chaque nouveau projet utilisant cette librairie.

Un bouton poussoir a 4 pattes n'étant pas disponible sur toutes les versions de Kicad, nous en avons également créé un comme ci-dessous.

{{:usager:tdasse:shield_arduino:switch_push.png?200|}}

Voici un zip de la librairie {{:usager:tdasse:kicad_tools:fablab_cn2.zip|fablab_cn2.zip}}


=== Retour au schéma ===

On peut maintenant reprendre la création du schéma en ajoutant les composants arduino_uno, switch_push et potentiomètre.

Pour relier les composants, on peut placer des fils comme vu précédemment ou ajouter un label avec {{:usager:tdasse:shield_arduino:add_line_label.png?26|}} ou **<L>**. Deux pins qui auront le même label seront reliés.

Nous pouvons maintenant réaliser le schéma proposé dans le paragraphe Le circuit situé plus haut.
De nombreux pins ne sont pas reliés dans le schéma. On indique à Kicad que c'est intentionnel avec le symbole {{:usager:tdasse:shield_arduino:no_connexion.png?26|}} de non connexion

On numérote ensuite les composants avec {{:usager:tdasse:shield_arduino:annotate.png?26|}}.

On vérifie enfin que le schéma respecte les règles de conception électrique avec {{:usager:tdasse:shield_arduino:erc.png?26|}}

A la fin, nous obtenons le schéma de notre circuit : 

{{:usager:tdasse:shield_arduino:schema_final_step.png?200|}}

=== Du schéma au circuit ===

Après avoir réalisé le schéma, nous allons passer au circuit réel en deux grandes étapes: d'abord, il faut associer à chaque composant une empreinte (zone de cuivre et perçage pour chaque patte du composant) ; ensuite, nous placerons les composants et tracerons les pistes pour les relier.

Que ce soit une résistance ou un microcontrôleur, les composants existent en plusieurs versions (traversant ou de surface), en plusieurs tailles et peuvent parfois être assemblés horizontalement ou verticalement. Il existe donc de nombreuses empreintes possible pour un même composant et il est parfois difficile de choisir tant les intitulés sont à rallonge et les différences difficiles à percevoir. De plus, la taille des pads (pastilles de cuivre percées ou non) n'est pas toujours des plus judicieuse. 

Aussi ai-je pris l'habitude de dessiner moi-même mes empreintes, c'est assez rapide et ça permet de faire d'avoir exactement la forme/taille voulue.
Les empreintes, comme les composants, sont évidemment réutilisables d'un projet à l'autre.

Les utilisateurs pressés ou qui préfèrent utiliser les empreintes existantes peuvent sauter le paragraphe précédent et se rendre directement à la partie sur Association de composants et d'empreintes

=== Créer une empreinte ===

On peut créer une empreinte en utilisant l'éditeur d'empreinte {{:usager:tdasse:shield_arduino:footprint_editor.png?56|}} dans le menu principal ou directement dans l'éditeur de schéma.

On peut sélectionner une librairie active avec {{:usager:tdasse:shield_arduino:open_library.png?26|}} afin d'ajouter une empreinte dans une librairie déjà existante.

Nous allons plutôt créer notre librairie. Contrairement aux librairies de composants où ces derniers sont stockés dans un fichier <nom_librairie>.lib que nous avons rangés dans un répertoire lib, les empreintes elles sont des fichiers <nom_empreinte>.kicad_mod stockés dans un répertoire nommé <nom_librairie>.pretty.

Commençons d'abord par créer une empreinte de la résistance en cliquant sur {{:usager:tdasse:shield_arduino:new_footprint.png?26|}} et la nommer, par exemple, Resistor_THT (THT:Through hole technology pour les composants traversants et SMD:surface mount device pour les composants de surface).

La taille des composants que nous avons créés n'avait pas d'importance car il s'agissait d'objets symboliques. Pour les empreintes au contraire, les dimensions sont essentielles. La plupart des dimensions en électronique sont plus simples en système impérial que métrique. L'unité usuelle, le pouce (inch) qui vaut 2.54cm, étant grand pour de l'électronique, les dimensions utilisées sont plutôt exprimées en mils (millièmes de pouces). Par exemple 100 mils, écartement fréquent pour les composants traversants, valent 2.54mm.

Commençons par mettre notre grille à 100 mils.
Déplaçons ensuite le nom de l'empreinte à 100 mils au dessous du centre du repère et <nowiki>REF***</nowiki> 100 mils au dessus afin de pouvoir centrer l'empreinte sur le repère.

Plaçons maintenant une première pastille avec {{:usager:tdasse:shield_arduino:new_pad.png?26|}} puis en cliquant dans la zone ou à l'aide de **<P>** avec les paramètres : 
  * Numéro de pad : 1
  * type Pad : pad traversant
  * Forme : Cercle
  * Position X : -5,08 mm (-200 mils), la position peut également être modifiée avec <M> au survol de la pastille.
  * Position Y : 0
  * Taille X : 1,8 mm (diamètre de la pastille correspondant à 0,5mm de cuivre autour d'un perçage de 0,8mm)

Perçage
  * Forme : Forme circulaire
  * Taille X : 0.8mm

Couches
  * Cuivre : Toutes couches cuivre

Pour placer une résistance 1/4W, un écartement de 400 mils convient. Placer donc une pastille numéro 2 à 200 mils à droite de l'origine (Position X : 5,08 mm)

On peut également dessiner l'encombrement du composant avec les outils {{:usager:tdasse:shield_arduino:add_poly.png?26|}}, {{:usager:tdasse:shield_arduino:add_circle.png?26|}} et {{:usager:tdasse:shield_arduino:add_arc.png?26|}} et obtenir une empreinte comme ci-dessous.

{{:usager:tdasse:shield_arduino:resistor_footprint.png?200|}}

Cliquez sur {{:usager:tdasse:shield_arduino:new_library.png?26|}} pour sauvegarder. Dans chemin de base, choisir votre répertoire de travail kicad et dans repertoire librairie ajouter le dossier /fablab_cn2 (il sera créé automatiquement avec ajout de l'extension .pretty).

On peut faire également les autres composants : 

{{:usager:tdasse:shield_arduino:led_5mm_footprint.png?200|}}
{{:usager:tdasse:shield_arduino:pot_footprint.png?200|}}
{{:usager:tdasse:shield_arduino:switch_button_footprint.png?200|}}
{{:usager:tdasse:shield_arduino:arduino_shield_footprint.png?200|}}

avec les paramètres suivants : 

^nom ^ visuel ^ espacement X ^ espacement Y ^ perçage ^ remarque ^
|led | {{:usager:tdasse:kicad_tools:led.jpg?100|}} | 100 mils = 2.54 mm |   | 0.8 mm | |
|resistance | {{:usager:tdasse:kicad_tools:resistor.jpg?100|}} | 400 mils = 10.16 mm |   | 0.8 mm | |
|potentiometre | {{:usager:tdasse:kicad_tools:pot.jpg?100|}} | 200 mils = 5.08 mm |   | 1.2mm | |
|bouton poussoir | {{:usager:tdasse:kicad_tools:switch_button.jpg?100|}} | 200 mils | 300 mils | 1.2mm | redresser les pattes |
|shield arduino | | | | 1 mm | voir le schéma en début de page |

                                                                             
La librairie complète est aussi disponible dans {{:usager:tdasse:kicad_tools:fablab_cn2.zip|fablab_cn2.zip}}

Commme pour les libraries de composants, il faut ajouter la librairie au projet pour pouvoir l'utiliser.\\
Dans Préférences/Gestionnaire de librairies d'empreintes, aller dans l'onglet Librairies spécifiques au projet
puis cliquer sur Ajouter librairie.\\
Dans Pseudo nom, saisir fablab_cn2 puis dans chemin de la librairie le chemin complet du typez .../kicad/fablab_cn2.pretty
puis valider et fermer la fenêtre pour revenir à l'éditeur de schéma.\\

=== Association de composants et d'empreintes ===

Le menu {{:usager:tdasse:shield_arduino:associate.png?26|}} dans l'editeur de schéma permet d'associer une empreinte à chaque composant.
Activer {{:usager:tdasse:shield_arduino:lib_filter.png?26|}} pour filtrer la liste des empreintes par librairie puis choisir la librairie contenant les empreintes (par exemple : fablab_cn2) dans la colonne de gauche (librairies) puis, pour chaque composant, double cliquer, dans la colonne de droite, sur l'empreinte qui convient.

Vous obtiendrez une liste comme ci-dessous :

{{:usager:tdasse:shield_arduino:shield_association.png?300|}}
                                                                                                                           
Il ne reste plus qu'à cliquer sur {{:usager:tdasse:shield_arduino:net.png?26|}} pour générer la netliste.

=== Le circuit imprimé (PCB) ===

L'outil Pcbnew de conception du circuit imprimé est accesible via {{:usager:tdasse:shield_arduino:pcb_editor.png?56|}} dans le menu principal ou directement dans l'éditeur de schéma.

Il faut d'abord lire la netliste précédemment créée en cliquant sur {{:usager:tdasse:shield_arduino:net.png?26|}}.
Les composants sont posés les uns sur les autres n'importe où sur la page. Commencez par les déplacer avec **<M>** pour les disposer à l'endroit voulu (l'utilisation de la grille peut être utile).

Dans le menu Règles de conception/Règles de conception, fixez la largeur de piste à 0,8 mm et l'isolation à 0,6 mm (ce sont des valeurs confortables, les pistes sont larges, le risque de problème à la fabrication est réduit. Pour un circuit de composants de surface, 0,4 mm de largeur piste et 0,4 mm d'isolation seront plus appropriés).

Dans l'onglet des couches, sélectionnez la couche B.Cu (cuivre en dessous pour les composants traversants).

A l'aide de l'outil {{:usager:tdasse:shield_arduino:add_track.png?26|}}, remplacez le chevelu (traits blancs reliant les coomposants) par le dessin des pistes afin d'obtenir un PCB (printed circuit board) comme ci-dessous.

A l'aide de l'outil de lignes et polygones {{:usager:tdasse:shield_arduino:add_edge.png?26|}}, dessinez le contour rectangulaire de la carte dans la couche Edge.cuts.

Avec placer/Origine des Coord de Perçage et Placement, ajouter une origine en bas à gauche du contour de la carte (cette origine est utile pour caler les fichiers de fraisage et perçage).

Il ne reste plus qu'a sauver et à exporter les fichiers de fabrication en cliquant sur {{:usager:tdasse:shield_arduino:trace.png?26|}}

Sélectionnez les couches B.Cu et Edge.cuts, activer l'option axe auxiliaire comme origine et cliquer sur tracer pour générer les fichiers Gerber <nomprojet>-B.Cu.gbr et <nomprojet>-Edge.Cuts.gbr.

Cliquez ensuite sur Créer fichier de perçage puis sur Fichier de perçage pour créer le fichier <nomprojet>.drl

Il faut maintenant transformer ces fichiers en un gcode puis passer en fabrication.

Vous pouvez télécharger le projet {{:usager:tdasse:shield_arduino:shieldarduinouno.zip|shieldarduinouno.zip}}

==== La génération des fichiers machine avec Flatcam ====

Flatcam est un logiciel open source de génération de gcode machine à partir de fichiers de conception de circuits électroniques (Gerber, Excellon, SVG) créé par Juan Pablo Caram. Ce programme est écrit en python 2.7 et devrait fonctionner sur toute machine incluant ce langage et les packages nécessaires (voir [[http://flatcam.org/manual/installation.html]]).

=== Installation de Flatcam ===

== Sous linux ==

Se placer dans le répertoire où l'on veut installer Flatcam. 
Importer le dépôt en faisant : 
<code ->
git clone https://bitbucket.org/jpcgt/flatcam.git
</code>
ou télécharger un .zip de [[https://bitbucket.org/jpcgt/flatcam/downloads/]] et le décompresser.

Installer ensuite les éléments requis en ligne de commande avec : 
<code ->
sudo setup_ubuntu.sh
</code>

Flatcam se lance en tapant: 
<code ->
python FlatCAM.py
</code>
 
Il est également possible de créer un raccourci dans le menu sous Linux Mint en ajoutant un fichier flatcam.desktop dans le répertoire /usr/share/applications (droits administrateur requis) contenant:

<code ->
[Desktop Entry]
Type=Application
Name=FlatCAM
GenericName=FlatCAM
Comment=Gcode generator
Exec=python <chemin_contenant_flatcam>/FlatCAM.py
Icon=<chemin_contenant_flatcam>/share/flatcam_icon48.ico
Terminal=false
Categories=Electronics;
</code>

== Sous Windows ==

voir [[http://flatcam.org/manual/installation.html]]

=== Importer les fichiers Gerber et Excellon ===

Dans FlatCAM, nous allons transformer les fichiers générés par kicad en gcode utilisable par une fraiseuse pour usiner le circuit en gravure dite à l'anglaise (on ne supprime par tout le cuivre inutile mais on isole juste chaque pastille ou piste en usinant son contour.

Commencez par ouvrir les fichiers <nomprojet>-B.Cu.gbr et <nomprojet>-Edge.Cuts.gbr avec File/Open Gerber...\\
Ouvrez ensuite le fichier <nomprojet>.drl avec File/Open Excellon...

Dans Kicad, nous avons conçu un circuit en vue de dessus. Or dans le cas des circuits à composant traversants, la couche de cuivre est situé en dessous. Il faut donc retourner le circuit, c'est à dire lui faire subir une symétrie d'axe vertical.

Pour cela, aller dans Tool et cliquez sur Double-Sided PCB Tool.

Dans l'outil Double-Sided PCB Tool, paramétrez :
<code ->
Bottom Layer: <nomprojet>-B.Cu.gbr
Mirror Axis: Y
Axis Location: Box
Point/Box: <nomprojet>-Edge.Cuts.gbr
</code>
Puis cliquez sur Mirror Object

Refaire de même avec le Bottom Layer: <nomprojet>.drl

=== Créer le Gcode ===

La génération du gcode gravure, perçage, découpe se fait en plusieurs étapes.\\ 

== La gravure ==

Dans l'onglet Project, double cliquez sur la ligne <nomprojet>-B.Cu.gbr.\\
Dans Isolation Routing, fixer le tool dia (diamètre d'outil, voir ci-dessous pour les fraises javelot). Pour augmenter la largeur de gravage, on peut faire plusieurs passes.

Pour notre projet, nous avons utilisé les paramètres ci-dessous:

{{:usager:tdasse:shield_arduino:flatcam_isolation_routing.png?200|}}

Cliquez sur Generate Geometry.

FlatCAM calcule les tracés de gravure à l'anglaise (tracé du contour des pistes afin de les isoler) et les affiche. En retournant dans l'onglet Project, on remarque que la liste s'est allongée d'un objet <nomprojet>-B.Cu.gbr_iso. Double cliquez dessus pour saisir les paramètres de fraisage : cutZ correspond à la profondeur de coupe, travelZ est la hauteur quand la fraise se déplace en dehors de la matière, feed rate la vitesse d'avance. 

Nous avons saisi les paramètres ci-dessous.

{{:usager:tdasse:shield_arduino:flatcam_generate_object.png?200|}}

Cliquez ensuite sur Generate. Les zones de cuivre qui seront retirées apparaissent en bleu. En examinant attentivement le circuit, on peut alors vérifier qu'il n'y a pas d'endroit où deux pistes seraient trop proches et que les pistes ne seraient pas séparées. Si c'est le cas, il faut modifier la conception du circuit dans kicad. 

Un nouvel objet <nomprojet>-B.Cu.gbr_iso_cnc est apparu dans l'onglet Project. En double cliquant dessus, il suffit de cliquer sur Export G-Code en bas de l'onglet pour enregistrer le fichier d'usinage sous le nom <nomprojet>-bcu.tap par exemple.

Diamètres d'outil pour les fraises javelots (valeurs obtenues par tests pour des plaques de cuivre d'épaisseur 35 microns) : 

^ angle ^ profondeur ^ largeur de piste ^
| 30° | 0.04 mm | 0.4 mm |
| 15° | 0.04 mm | 0.2 mm |


== Le perçage ==

Recommençons maintenant pour le perçage.

Double cliquez sur <nomprojet>.drl et choisissez un des diamètres à percer. réglez les paramètres, Cut Z étant la profondeur de perçage.

Nous avons utilisé les paramètres suivants.

{{:usager:tdasse:shield_arduino:flatcam_excellon_object.png?200|}}

Cliquez ensuite sur Generate. Dans l'onglet projet un objet <nomprojet>.drl_cnc est apparu. En double cliquant dessus on peut faire un Export G-Code et enregistrer le fichier sous <nomprojet>-drl-<diametre>.tap.

Il faut maintenant refaire de même pour chaque diamètre à percer et générer un fichier différent par diamètre.

== la découpe du circuit ==

Passons maintenant à l'étape découpe de contour.

Double cliquez sur <nomprojet>-Edge.Cuts.gbr. Dans l'outil Board cutout, reglez le Tool dia, margin (marge), Gap Size (longueur des pattes d'accrochages) et Gaps (pattes).

Pour notre circuit, nous avons utilisé les paramètres suivants

{{:usager:tdasse:shield_arduino:flatcam_board_cutout.png?200|}}

=== Modification de Gcode pour la fraiseuse MMM30 ===

La fraiseuse MMM30 accepte un langage type gcode avec des commandes type G00 pour les déplacements linéaires rapides hors matière et G01 pour les déplacements à vitesse contrôlée pendant l'usinage mais est un peu susceptible pour la fin du programme.

Entête générée par FlatCam : 
<code ->
G21 (coordonnées en mm)
G90 (mode distance absolue)
G94 (vitesse en millimètres par minute)
F80.00 (vitesse d'avance)
G00 Z1.0000 (déplacement rapide à z=1)
M03 (démarrage de la broche)
G4 P1 (pause de 1s)
</code>

Fin générée par FlatCam : 
<code ->
G00 Z1.0000 (déplacement rapide à z=1)
G00 X0Y0 (déplacement rapide à x=0,y=0)
M05 (arrêt de la broche)
</code>


<note tip>A tester</note>
La commande de fin M05 semble forcer un arrêt prématuré du programme. 
Il suffit de la remplacer par M30 et de renommer le fichier avec l'extension .tap pour que le programme fonctionne.

<note tip>La suite n'est qu'à l'état de plan/brouillon</note>

===== Réalisation =====


==== La fraiseuse MMM30 ====

==== Gravure des pistes ====


==== Le perçage ====


==== La découpe du contour ====

===== Souder les composants =====

===== La programmation =====

===== Compléments =====

==== Créer un des composants 3D pour avoir un rendu 3D de la carte ====
Carrefour numérique² - fablab

Outils d'utilisateurs

Outils du Site

Outils de la Page
