Archives pour la catégorie Electronique

Installation d’Eagle 6.6 sur Ubuntu 16.04

Installer les paquets suivants :

sudo apt-get install libxrender1:i386 libxrandr2:i386 libxcursor1:i386 libfreetype6:i386 libfontconfig1:i386 libxext6:i386 libx11-6:i386 libxi6:i386 libssl1.0.0:i386 libstdc++6:i386 libgcc1:i386 libc6:i386 libc6-i386 libxfixes3:i386 libexpat1:i386 libxcb1:i386 libxdmcp6:i386 libxau6:i386

Rendre l’installer executable :

chmod +x eagle-lin-6.6.0.run

Lancer le script d’instalation :

sudo ./eagle-lin-6.6.0.run

Si lors de l’installation d’Eagle 6.5.0 sur Ubuntu 12.04 LTS 64 bits l’erreur suivante apparait :

ligne 108: /tmp/eagle-setup.9094/eagle-6.5.0/bin/eagle: Aucun fichier ou dossier de ce type

Cette erreur est due à des packages manquants et peut être facilement résolue en exécutant les commandes suivantes avant installation:

sudo apt-get install libssl1.0.0
sudo apt-get install libcrypto++9
sudo apt-get install build-essential perl gcc-multilib
sudo apt-get install ia32-libs lib32z1 lib32z1-dev

Lancer l’application:

/opt/eagle-6.6.0/bin/eagle

Ajouter l’icon dans le menu Unity puis éditer le fichier du lanceur:

gedit ~/.local/share/applications/eagle.desktop

Modifier l’icône dans le fichier:

Icon=/opt/eagle-6.6.0/bin/eagleicon50.png

Redémarrer le session pour que le changement d’icône soit pris en compte.

Préfixe des composants électroniques

Voici la liste des préfixes (standard reference designator) pour les schémas électriques:

BTBatterie
CCondensateur
DDiode
FFusible
JPCavalier (Jumper)
LInductance
MMoteur
QTransistor
RResistance
RTThermistance
SInterrupteur, switch, bouton poussoir.
TPTest point
UCircuit intégré (IC -Inseparable assembly)
VRRésistance variable (potentiomètre or rheostat)
XConnecteur
TQuartz ou oscillateur
ZDiode Zener

Fabricants de circuits imprimés à bas coût

OurPCB Tech. Ltd. fabrique et assemble vos circuits imprimés (production, assemblage et prototypage). Professionnel et expérimenté, OurPCB propose un service de qualité.

Voici une liste de fabricants de circuits imprimés (PCB) avec devis en ligne :

  • WellPCB est une société basée à Shijiazhuang Hebei en Chine. Les circuits imprimés sont fabriqués à Shenzhen en Chine.
    Formats supportés : Gerber, Protel 99se (.pcb), DXP (.pcbdoc) or CAM350 (.cam).
  • Multi-cb cette entreprise est basée à Poole (UK). Les circuits sont tous fabriqués en Angleterre.
    Formats supportés : Eagle CAD, Target 3001, Sprint Layout, Gerber, ODB++ et IPC-2581.
  • Beta-Layout / PCB Pool
    Formats supportés : DesignSpark PCB, Altium (PROTEL), Target, Eagle CAD (.brd), Orcad, UltiBOARD, Proteus, Sprint, Quickroute, EASY-PC, , EDWin, GC-Prevue, PCAD, Boardmaker, Pulsonix, Kicad, DipTrace, Fritzing and GERBER.
  • YouPCB : cette entreprise est basée à Toronto, Ontario au Canada. Les circuits sont fabriqués à Shenzhen en China.
    Formats supportés : Gerber.
  • FirstPCB : société basée à Hangzhou en Chine. Les circuits sont fabriqués à en Chine.
    Formats supportés : Gerber 274X , ODB++, Protel and Eagle CAD
  • DirtyPCB : société américaine avec des partenaires chinois. Les circuits sont fabriqués à Shenzhen et expédiés depuis Hong Kong.
    Formats supportés : Gerber et Eagle CAD (.brd).
  • JLCPCB
  • Eurocircuits :
  • PCBWay : société basée à Hangzhou en Chine. Les circuits sont fabriqués à Shenzhen et Hangzhou en Chine.
    Formats supportés : Gerber, Protel 99se (.pcb), DXP (.pcbdoc), CAM350 (.cam) et Eagle CAD (.brd).
  • ALLPCB : plateforme de fabrication de circuits imprimés qui travaille avec différents fabricants en Chine, specialisé dans la réalisation de circuits-imprimés avec un haut rapport qualité / prix aussi bien pour le prototypage que la production.
    Formats supportés : Gerber, Protel 99se (.pcb), DXP (.pcbdoc), CAM350 (.cam) et Eagle CAD (.brd)
  • Seeed Studio Fusion: Société basée en Chine avec une offre multi-services : circuits imprimés, assemblage, impression 3D …
  • Formats supportés : Gerber

Si une information ou un fabricant étaient erronés ou manquants, n’hésitez pas à me le signaler.

Script ULP les plus utilisés dans Eagle

Cet article présente les script UKP d’Eagle les plus utils.

Editeur de schéma

bom.ulp : génère la liste de composants (bill of material) pour le schéma courant.

Editeur de carte

cmd-snap-board.ulp : permet de réaligner les composants sur la grille.
drillegend-stack.ulp : crée la légende des perçages.
EagleIDFExporter.ulp : génère les fichiers IDF pour un export vers une CAO 3D.

Premiers pas avec EAGLE – Créer un modèle Solidworks 3D depuis Eagle.

Cet article fait partie d’un tutoriel sur le logiciel EAGLE. Le lecteur est invité à se référer aux autres sections de ce tutoriel en suivant ce lien : Premiers pas avec EAGLE
Cet article explique comment créer un modéle CAO 3D à partir d’un circuit imprimé conçu avec Eagle. Les versions des logiciels suivants ont été utilisées :
  • Eagle 6.6
  • Solidworks 2014 (avec CircuitWorks)

motorboard_002

Exporter depuis Eagle

Commencer par vérifier que le contour de la carte se trouve bien sur la couche 20 (Dimension). Si le contour ne s’y trouve pas, créer un contour fermé en utilisant l’outil Wire.

eagle

Exécuter EagleIDFExporter.ulp et suivre les instructions. Le script ulp doit générer deux fichiers avec les extensions .emn et .emp.

eagleidf_exporter

Importer dans Solidworks

Vérifier que le complément CirciutWorks (Circuiworks add-in) est démarré. S’il ne l’est pas, dans Outils>Compléments, sélectionner CircuitWorks (pour démarrer CircuitWorks à chaque session session, cocher CircuitWorks dans la colonne démarrage). Ouvrir le fichier .emn avec CircuitWorks (ouvrir un fichier ECAD). La carte apparaît dans la fenêtre.

circuitworks

Il est alors possible d’associer chaque composant de la carte à un modèle 3D. Lorsque l’association est terminée, cliquer sur Construire le modèle. CircuitWorks va automatiquement générer un nouvel assemblage dans la fenêtre principale de Solidworks:

solidworks

Normalisation des connecteurs pour le bus CAN

Normalisation du bus CAN

Cette normalisation utilise la série Mini50 de chez MOLEX.

overview

Brochage

CAN_BUS_pinout

Liste des composants

Connecteur vertical traversant

2376577-40 Molex : 34792-0040
Farnell : 2280626

Connecteur à angle droit traversant

34792-34793-_ISO Molex : 34793-0040
Farnell : 2280628

Connecteur monté en surface (CMS)

2376567-40 Molex : 34912-8040
Farnell : 2376567

Boitier pour connecteur filaire

2280624-40 Molex : 34791-0040
Farnell : 2280624

Contact à sertir femelle CTX50 0.22 – 0.37 mm²

560023-0421 Molex : 560023-0421
Farnell : 2280637

Pince à sertir CTX50

63823-0300 Molex : 63823-0300
Farnell : 2280638

MPU-9250 et Arduino (IMU 9 axes)

Cet article présente un simple example d’interfaçage du MPU-9250 avec une Arduino. La carte utilisée ici est fabriquée par Drotek : IMU 9DOF – MPU9250 breakout board. La vidéo suivante montre le résultat de cet interface avec l’algorithme AHRS de Sebastian Madgwick
 

Le MPU-9250 est constitué de plusieurs circuits encapsulé dans un seul boitier, il contient:

  • un accéléromètre 3 axes
  • un gyroscope 3 axes
  • un magnétomètre 3 axes

AxisOrientation

Câblage

Arduino mega

wiring

Codes sources

#include 

#define    MPU9250_ADDRESS            0x68
#define    MAG_ADDRESS                0x0C

#define    GYRO_FULL_SCALE_250_DPS    0x00  
#define    GYRO_FULL_SCALE_500_DPS    0x08
#define    GYRO_FULL_SCALE_1000_DPS   0x10
#define    GYRO_FULL_SCALE_2000_DPS   0x18

#define    ACC_FULL_SCALE_2_G        0x00  
#define    ACC_FULL_SCALE_4_G        0x08
#define    ACC_FULL_SCALE_8_G        0x10
#define    ACC_FULL_SCALE_16_G       0x18



// This function read Nbytes bytes from I2C device at address Address. 
// Put read bytes starting at register Register in the Data array. 
void I2Cread(uint8_t Address, uint8_t Register, uint8_t Nbytes, uint8_t* Data)
{
  // Set register address
  Wire.beginTransmission(Address);
  Wire.write(Register);
  Wire.endTransmission();
  
  // Read Nbytes
  Wire.requestFrom(Address, Nbytes); 
  uint8_t index=0;
  while (Wire.available())
    Data[index++]=Wire.read();
}


// Write a byte (Data) in device (Address) at register (Register)
void I2CwriteByte(uint8_t Address, uint8_t Register, uint8_t Data)
{
  // Set register address
  Wire.beginTransmission(Address);
  Wire.write(Register);
  Wire.write(Data);
  Wire.endTransmission();
}


// Initializations
void setup()
{
  // Arduino initializations
  Wire.begin();
  Serial.begin(115200);
  
  // Configure gyroscope range
  I2CwriteByte(MPU9250_ADDRESS,27,GYRO_FULL_SCALE_2000_DPS);
  // Configure accelerometers range
  I2CwriteByte(MPU9250_ADDRESS,28,ACC_FULL_SCALE_16_G);
  // Set by pass mode for the magnetometers
  I2CwriteByte(MPU9250_ADDRESS,0x37,0x02);
  
  // Request first magnetometer single measurement
  I2CwriteByte(MAG_ADDRESS,0x0A,0x01);


}


long int cpt=0;
// Main loop, read and display data
void loop()
{
  
  // _______________
  // ::: Counter :::
  
  // Display data counter
  Serial.print (cpt++,DEC);
  Serial.print ("\t");
  
 
 
  // ____________________________________
  // :::  accelerometer and gyroscope ::: 

  // Read accelerometer and gyroscope
  uint8_t Buf[14];
  I2Cread(MPU9250_ADDRESS,0x3B,14,Buf);
  
  
  // Create 16 bits values from 8 bits data
  
  // Accelerometer
  int16_t ax=-(Buf[0]<<8 | Buf[1]);
  int16_t ay=-(Buf[2]<<8 | Buf[3]);
  int16_t az=Buf[4]<<8 | Buf[5];

  // Gyroscope
  int16_t gx=-(Buf[8]<<8 | Buf[9]);
  int16_t gy=-(Buf[10]<<8 | Buf[11]);
  int16_t gz=Buf[12]<<8 | Buf[13];
  
    // Display values
  
  // Accelerometer
  Serial.print (ax,DEC); 
  Serial.print ("\t");
  Serial.print (ay,DEC);
  Serial.print ("\t");
  Serial.print (az,DEC);  
  Serial.print ("\t");
  
  // Gyroscope
  Serial.print (gx,DEC); 
  Serial.print ("\t");
  Serial.print (gy,DEC);
  Serial.print ("\t");
  Serial.print (gz,DEC);  
  Serial.print ("\t");

  
  // _____________________
  // :::  Magnetometer ::: 

  
  // Read register Status 1 and wait for the DRDY: Data Ready
  
  uint8_t ST1;
  do
  {
    I2Cread(MAG_ADDRESS,0x02,1,&ST1);
  }
  while (!(ST1&0x01));

  // Read magnetometer data  
  uint8_t Mag[7];  
  I2Cread(MAG_ADDRESS,0x03,7,Mag);
  

  // Create 16 bits values from 8 bits data
  
  // Magnetometer
  int16_t mx=-(Mag[3]<<8 | Mag[2]);
  int16_t my=-(Mag[1]<<8 | Mag[0]);
  int16_t mz=-(Mag[5]<<8 | Mag[4]);
  
  
  // Magnetometer
  Serial.print (mx+200,DEC); 
  Serial.print ("\t");
  Serial.print (my-70,DEC);
  Serial.print ("\t");
  Serial.print (mz-700,DEC);  
  Serial.print ("\t");
  
  
  
  // End of line
  Serial.println("");
//  delay(100);    
}

Contributions

Code source sur BitBucket ici.

Téléchargements



Calculateur de fréquence pour les capteurs à effet Hall des moteurs brushless

Les formulaires suivants permettent de calculer la vitesse d’un moteur brushless à partir des signaux produits par les capteurs à effet Hall et vice-versa.

BLDC_Hall_Signals

Speed to frequencies

Formules

 F_1[Hz]=N[rpm].N_{Poles}

 F_2[Hz]=2.N[rpm].N_{Poles}.N_{Phases}

Frequency to speed

Programmation des microcontrôlleurs AVR avec Qt-Creator sans makefile

Cet article explique comment compiler et programmer des microcontrôlleur ATMEL avec Qt-creator. Ce tutorial s’appuie sur les version suivantes de ces logiciels et nous supposerons qu’ils sont déjà installés:

  • Ubuntu 14.04 LTS
  • Qt Creator 3.0.1
  • avr-g++ (gcc version 4.8.2 (GCC))
  • avrdude 6.0.1

Création du projet

Créer un dossier pour le projet:

mkdir path/to/myproject

Se placer dans ce dossier:

cd path/to/myproject

Créer cinq fichiers vierges:

touch myproject.config myproject.creator myproject.files myproject.includes main.cpp

Ajouter le mot-clé [General] dans le fichier myproject.creator:

echo [General] > myproject.creator

Ajouter le nom du fichier source main.cpp dans le fichier myproject.files:

echo main.cpp > myproject.files

Démarrer Qt Creator et ouvrir le fichier myproject.creator. Vous pouvez aussi ouvrir le fichier avec un clic droit ou avec la commande suivante:

qtcreator myproject.creator

Lorsque Qt Creator est démarré, le project doit être visible. Editer le fichier main.cpp, voici un exemple de code très simple pour commencer:

/*
 * This simple program shows how to start with Qt-Creator, avr-g++ and avrdude
 *
 *
 *  Fuses configuration (Fuses OK (H:FF, E:DF, L:EE):
 *       Extended :      0xDF
 *       High :          0xFF
 *       Low :           0xEE
 *
 *
 * To compile the project :
 *   avr-g++ -mmcu=atmega32m1 -Os main.cpp -o output.elf
 *
 * To upload the file :
 *   avrdude -c avrispmkII -p m32m1 -P usb -U flash:w:output.elf
 *
 * To update the fuses :
 *   avrdude -c avrispmkII -p m32m1 -P usb -U flash:w:output.elf  -Ulfuse:w:0xeEE:m -Uhfuse:w:0xFF:m -Uefuse:w:0xDF:m
 *
 * Qt Creator project configuration:
 *
 *  Build steps (Custom Process Step)
 *      Command :               avr-g++
 *      Arguments :             -mmcu=atmega32m1 -Os main.cpp -o output.elf
 *      Working directory :     %{buildDir}
 *
 *  Clean steps(Custom Process Step)
 *      Command :               avrdude
 *      Arguments :             -c avrispmkII -p m32m1 -P usb -U flash:w:output.elf
 *      Working directory :     %{buildDir}
 *
 *  Run (Custom

 *
*/

// 8MHz oscillator
#define	F_CPU 8000000UL


#include 
#include 


int main()
{
    // Set bit 7 of PORTC as output
    DDRC=0x80;
    while (1)
    {
        // Invert the bit 7 of PORTC
        PORTC = PORTC ^ 0x80;

        // Wait 500ms (the leb connectod to the bit 7 of PORTC will blink at 1Hz)
        _delay_ms(1000);
    }
}

Configurer le projet

Dans l’onglet Project (sur la gauche) configurer Qt Creator en vous inspirant des captures d’écran suivantes:

build

Pour programmer la cible, deux options sont possibles (Deployment ou Run). J’ai utilisé Deployment car le résultat de la programation est directement intégrée à l’IDE Qt Creator (la barre devient rouge en cas de problème). Un exectuable doit être configuré, la commande echo sert ici de commande vide.
Notez également que cet exemple utilise un atmega32m1 qui n’est pas supporté nativement par cette version d’avrdude (remplacer par exemple m32m1 par m328p si vous souhaitez utiliser un atmega328p).

Screenshot from 2014-05-25 13:55:00

Programmer les atmega32m1 avec avrdude

Cet article explique comment programmer les atmega32m1 avec avrdude. Cette famille de de microcontrôlleurs (atmega16m1, atmega32m1 and atmega64m1) n’est pas nativement supportée par avrdude. Ce tutorial utilise les versions suivantes des logiciels:

  • Ubuntu 14.04 LTS
  • avrdude 6.0.1

Installer avrdude

Pour commencer, lancer un terminal (ctrl-alt-t) et installer avrdude:

sudo apt-get install avrdude

Patcher avrdude

Il est possible d’ajouter l’atmega32m1 dans avrdude en patchant le fichier avrdude.conf. Télécharger le patch écrit par Renato Caldas:

Avant de patcher, faire une copie de sauvegarde du fichier qui va être modifié:

sudo cp /etc/avrdude.conf /etc/avrdude.conf.backup

Maintenant, la commande suivante va ajouter la configuration de l’atmega32m1 dans avrdude:

sudo patch -p0 /etc/avrdude.conf avrdude_atmega32m1.patch

Test

Il est possible de lire la signature et les fusibles du microcontrôlleur. Dans l’exemple suivant, j’ai utilisé un AVRISP mkII pour programmer, mais cet exemple peut être adapté à d’autres programmateurs supportés par avrdude :

sudo avrdude -p m32m1 -c avrispmkII -P usbc

La signature doit correspondre : 0x1e8594:

Screenshot from 2014-05-25 11:31:00

Premiers pas avec EAGLE – Comprendre les calques

Cet article fait partie d’un tutoriel sur le logiciel EAGLE. Le lecteur est invité à se référer aux autres sections de ce tutoriel en suivant ce lien : Premiers pas avec EAGLE
Chaque calque d’EAGLE est dédié à une fonction précise et il est fortement recommandé de placer chaque élément dans le calque approprié. Cet article présente les 52 calques présents dans EAGLE. Nous allons prendre, à titre d’exemple la célébre carte Arduino MEGA 2560. Le lecteur remarquera que l’illustration ci-dessous n’est pas exactement identique au routage, mais est amplement suffisante à la compréhension de chaque calque:

  

ArduinoMega2650Front All
 

Layer 1 – Top

Le premier calque contient les pistes et le plan de masse (si utilisé) pour la face côté composants.

Layer_1

Layer 2 to 15 – Route

Il s’agit ici des couches internes (utilisé pour les cartes multi-couches).

Layer 16 – Bottom

Ce calque contient les pistes et le plan de masse (si utilisé) pour la face côté cuivre.

Layer_16

Layer 17 – Pads

Cette couche contient les pastilles des composants traversants (hors vias).

Layer_17

Layer 18 – Vias

Cette couche contient les pastilles des vias.

Layer_18

Layer 19 – Unrouted

Cette couche contient le chevelu, c’est à dire les pistes non routées. Sur l’exemple ci-dessous, la carte est presque finalisée, ce qui explique que peu de pistes restent non routées:

Layer_19

Layer 20 – Dimension

Cette couche contient les contours de la carte et les cercles des perçages non conducteurs.

Layer_20

Layer 21 – tPlace

Ce calque contient la sérigraphie pour le côté composants. Elle contient généralement les contours des composants. Il faut faire attention à ne pas recouvrir les zones à souder avec la sérigraphie. Une alternative consiste à ajouter de la sérigraphie détaillée à titre informatif sur le calque 51 (tDocu). Il est alors possible de recouvrir des zones de soudure car le calque 51 ne fait pas partie des données générés lors de la mise en production.

Layer_21

Layer 22 – bPlace

Ce calque contient la sérigraphie pour le côté cuivre (cf. calque 21 pour plus de détails).

Layer 23 – tOrigins

Ce calque contient le point origine de chaque élément placé côté composant. Les éléments ne peuvent être déplacé ou modifiés que si ce calque est visible.

Layer_23

Layer 24 – bOrigins

Ce calque contient le point origine (en fait une croix) de chaque composant placé côté cuivre. Les composants ne peuvent être déplacé que si ce calque est visible.

Layer 25 – tNames

Ce calque contient l’impression de service pour le côté composant. Ce calque est destiné à l’insertion des noms des composants et apparaît généralement sur la carte avec la sérigraphie

Layer_25

Layer 26 – bNames

Ce calque contient l’impression de service pour le côté cuivre (cf. calque 25 pour plus de détails).

Layer 27 – tValues

Ce calque est destiné à l’insertion des valeurs des composants sur la face côté composants et apparaît généralement sur la carte avec la sérigraphie.

Layer_27

Layer 28 – bValues

Ce calque contient les valeurs des composant pour la face côté cuivre. (cf. calque 27 pour plus de détails).

Layer 29 – tStop

Ce calque contient le masque pour le vernis épargne (la laque, généralement verte, qui recouvre les circuits imprimés) pour la face côté composants. Les données sont créées automatiquement avec les pastilles des composants, qu’ils soient traversants ou montés en surface, est éventuellement les vias (selon la configuration).

Layer_29

Layer 30 – bStop

Ce calque contient le masque pour le vernis épargne pour la face côté cuivre (cf. calque 29 pour plus de détails)

Layer 31 – tCream

Ce calque contient le masque de soudure (le masque d’étamage) pour la face côté composants. Il est utilisé pour créer le pochoir dédié à la pâte à souder, principalement pour les composants CMS. Les données sont créées automatiquement avec les pastilles. Cette zone doit être un peu plus petite que le calque 29 car le vernis épargne ne doit pas recouvrir les zones de soudure.

Layer_31

Layer 32 – bCream

Ce calque contient le masque de soudure (le masque d’étamage) pour la face côté cuivre. (cf. calque 31 pour plus de détails).

Layer 33 – tFinish

Ce calque est dédié aux finitions spéciales (or plaqué, argent…) pour la face côté composants. Il peut aussi être utiliser lorsque des pastilles nécessitent un placage or par immersion. Ce calque n’est pas généré automatiquement.

Layer 34 – bFinish

Ce calque est dédié aux finitions spéciales (or plaqué, argent…) côté cuivre (cf. calque 33 pour plus de détails).

Layer 35 – tGlue

Ce calque contient le masque permettant de déposer la colle sur la face côté composants. Lorsque les composants CMS sont soudés à la vague, ils doivent préalablement être collés. Généralement, un point au centre des petits composant est suffisant ou plusieurs sous les circuits intégrés. ce calque n’est pas généré automatiquement et doit être ajouté lors de la création des bibliothèques.

Layer_35

Layer 36 – bGlue

Ce calque contient le masque permettant de déposer la colle sur la face côté cuivre (cf. calque 35 pour plus de détails).

Layer 37 – tTest

Ce calque est dédié aux tests et réglages ICT (In Circuit Test) pour la face côté composants.

Layer 38 – bTest

Ce calque est dédié aux tests et réglages ICT (In Circuit Test) pour la face côté cuivre.

Layer 39 – tKeepout

Ce calque contient les zones d’interdiction de placement de composant sur la face côté composants. Le seul composant autorisé dans cette zone est l’éventuel propriétaire de la zone.

Layer_39

Layer 40 – bKeepout

Ce calque contient les zones d’interdiction de placement de composant sur la face côté cuivre (cf. calque 39 pour plus de détails).

Layer 41 – tRestrict

Ce calque contient les zones d’interdiction de placement de pistes sur la face côté composants.

Layer 42 – bRestrict

Ce calque contient les zones d’interdiction de placement de pistes sur la face côté cuivre.

Layer 43 – vRestrict

Ce calque contient les zones d’interdiction de placement de vias.

Layer 44 – Drills

Cette couche contient le placement de rivets métalisés (trous conducteurs). Il est généralement réserver aux perçages des pastilles (pour les composants traversants) et des vias.

Layer_44

Layer 45 – Holes

Cette couche contient le placement de perçages (trous non-conducteurs). Il est généralement réservé aux trous de montage.

Layer_45

Layer 46 – Milling

Ce calque est dédié aux usinages (typiquement les fraisages). Si le fabriquant doit faire des trous oblong à l’intérieur de la carte, ces trous doivent être placé sur ce calque. Tout autre usinage interne peut être ajouté ici en n’en dessinant le contour. Il est à noter que le contour externe de la carte doit être conçu sur le calque 20 (Dimension).

Layer 47 – Measures

ce calque contient les côtes. Il n’est pas utilisé pendant la fabrication, il n’apparaît qu’à titre informatif.

Layer_47

Layer 48 – Document

Ce calque contient la documentation générale. On peut y ajouter d’éventuels commentaires, ou tout information permettant la compréhension du circuit imprimé.

Layer_48

Layer 49 – Reference

Ce calque contient les mires d’alignement (fiducial marks). Ces mires sont de petits repères qui apparaissent sur le cuivre du circuit imprimé et permettent à un système de vision par ordinateur de placer précisément les composants sur la carte. Ces marqueurs ne sont pas placés sur la sérigraphie car celle-ci peut être décalée par rapport au cuivre.

Layer_49

Le système de détection automatique des repères d’alignement est illustré ci-dessous (image du site de Lady Ada (Adafruit company)).

4mmoffset

Layer 51 – tDocu

Ce calque contient la documentation de la face côté composants. On peut y placer des données graphiques à titre informatif. Cette couche n’est pas vouée à être imprimée sur le circuit imprimé. Comme la couche 21 (tPlace) ne doit pas recouvrir les zones de soudure, une représentation plus détaillées des composants peut être reproduite sur le calque 51 qui n’est pas sujet à cette limitation.

Layer_51

Layer 52 – bDocu

Ce calque contient la documentation de la face côté cuivre (cf. calque 51 pour plus de détails).

Premiers pas avec EAGLE

Eagle_Logo

Tutoriel

Premiers pas avec EAGLE – Partie 1 – Le panneau de contrôle
Premiers pas avec EAGLE – Partie 2 – L’éditeur de schémas
Premiers pas avec EAGLE – Partie 3 – L’éditeur de cartes

Utilisation avancée

Premiers pas avec EAGLE – Ajouter des trous de montage sur un circuit imprimé
Premiers pas avec EAGLE – Le plan de masse
Premiers pas avec EAGLE – Comprendre les calques
Premiers pas avec EAGLE – Créer un modèle Solidworks 3D depuis Eagle

Download


Premiers pas avec EAGLE – Le plan de masse

Cet article fait partie d’un tutoriel sur le logiciel EAGLE. Le lecteur est invité à se référer aux autres sections de ce tutoriel en suivant ce lien : Premiers pas avec EAGLE

Créer un plan de masse

L’outil POLYGON permet de dessiner le contour du plan de masse.

Polygon

Selectionner cet outil. Si le plan de masse est attaché à une connexion, saisir le nom de la connexion au clavier directement après la sélection de l’outil POLYGON et valider par Entrée:

AttachNet

Il sera toujours possible de modifier la connexion en cliquant avec le bouton droit de la souris sur le contour du polygone, puis sélectionner NAME dans le menu contextuel. Dans la fenêtre qui apparaît, remplacer GND par le label de la nouvelle connexion. Cette astuce est aussi utile pour vérifier que la connexion a bien été prise en compte.
Cliquez pour dessiner les extrémités du contour et double-cliquer pour terminer le polygon. Une fois le contour achevé, ce dernier apparait en pointillés:

DottedLine

Cliquer sur l’icône RATSNETS pour calculer et afficher le plan de masse:

Ratsnets

Le routage doit être mis à jour. Quand le circuit est modifié, le plan de masse n’est pas systématiquement recalculé. L’outil RATSNETS permet de forcer la mise à jour du plan de masse.

CopperPour

Conflit avec le contour de la carte

Selon la configuration des règles de vérification, il se peut que le plan de masse soit isolé des contours de carte:

CopperPourOutline

Cela peut être résolu en paramètrant la distance entre le plan de masse et le calque 20 (Dimension). Sélectionner DRC, aller dans l’onglet Distance et paramètrer la distance à zéro:

DistanceCopperPour

Connecter le plan de masse

Avant de spécifier le potentiel du plan de masse, il est parfois utile d’enlever les pistes existantes. Cela peut être fait facilement avec le commande RIPUP, par exemple “RIPUP GND”, supprime toutes les pistes liées au potentiel GND déja routées.
Pour changer le potentiel d’un plan de masse, sélectionner la commande NAME et cliquer le contour du plan de masse. Une fenêtre apparait et l’utilisateur peut modifier le nom du plan de masse. Quand le nom est aussi celui d’une piste existante, (par exemple GND), une connexion électrique est automatiquement créée entre la piste et le plan de masse. Sur le routage illustré ci-dessous, le plan de masse est relié à la masse:

CopperPour

Supprimer le plan de masse

Pour supprimer définitivement un plan de masse, il suffit de supprimer son contour. Pour une suppression temporaire ou pour masquer le plan de masse, selectionner l’outil RIPUP et cliquer sur le contour. Cela efface le plan de masse tout en conservant son contour (en pointillés). L’outil RATSNETS permet de recalculer le plan de masse.

Cliquer ici pour revenir au sommaire

Premiers pas avec EAGLE – Ajouter des trous de montage sur un circuit imprimé

Cet article fait partie d’un tutoriel sur le logiciel EAGLE. Le lecteur est invité à se référer aux autres sections de ce tutoriel en suivant ce lien : Premiers pas avec EAGLE

VIA vs HOLE

Il y a deux façons d’ajouter un trou (perçage ou via) dans un circuit imprimé avec EAGLE et la différence mérite une explication.
via hole
Un via est composé d’un trou et d’une zone de cuivre (généralement de la forme d’une pastille) qui entoure ce trou. La différence principale entre un via (VIA) et un perçage (HOLE) est que le via crée une connexion électrique entre les couches. L’outil de perçage (HOLE) ne fait que placer un trou sans ajouter de cuivre ni de connexion électrique. Le choix dépendra donc du type de montage auquel est destiné le trou. L’image suivante montre la différence entre l’ajout de vias et de perçages. A gauche du circuit imprimé, des perçages ont été utilisés, à droite, ce sont des vias.

Board

Comme illustré sur la figure suivante, les vias sont isolés du plan de masse:

BoardCopperPour

Diamètres de perçage

Quelque soit l’outil choisi, le diamètre de perçage doit être défini. L’éditeur de circuit est généralement configuré en mils (ou inchs) et la visserie est côtée en millimètres.
Le tableau suivant vous permet de trouver la correspondance rapidement parmi les diamètres fréquemment utilisés.
[mil][mm]
19.68504 mils0.5 mm
23.62205 mils0.6 mm
27.55906 mils0.7 mm
31.49606 mils0.8 mm
35.43307 mils0.9 mm
39.37008 mils1.0 mm
43.30709 mils1.1 mm
47.24409 mils1.2 mm
51.1811 mils1.3 mm
55.11811 mils1.4 mm
59.05512 mils1.5 mm
62.99213 mils1.6 mm
78.74016 mils2.0 mm
86.61417 mils2.2 mm
110.23622 mils2.8 mm
125.98425 mils3.2 mm

Si la valeur n’est pas listée , consulter ce lien : Convertisseur de distance

Cliquer ici pour revenir au sommaire

Premiers pas avec EAGLE – Partie 3 – L’éditeur de cartes

Cet article fait partie d’un tutoriel sur le logiciel EAGLE. Le lecteur est invité à se référer aux autres sections de ce tutoriel en suivant ce lien : Premiers pas avec EAGLE
Le lecteur est supposé avoir lu et réalisé la partie 2 de ce tutoriel et disposeer du schéma finalisé. L’éditeur de circuit doit se présenter sous cette forme:

BoardEditor

Forward and backward annotation

Vérifier que l’éditeur de schéma et de circuit sont ouverts simultanément. Effectuer une sauvegarde dans les deux éditeurs et fermer l’éditeur de cartes. L’éditeur de schéma doit afficher l’avertissement suivant: : “Forward and backward annotation has been severed !”:

FB_Annotation

EAGLE repose sur le maintien permanant du lien entre le schéma et le routage. Lorsqu’une modification est réalisée dans le schéma, le routage est automatiquement mis à jour (forward annotation). De la même façon, lorsque le routage est modifié, le schéma est mis à jour (backward annotation). cela permet d’éviter la division du projet en deux parties incompatibles. La contrepartie est que l’utilisateur doit garder ce lien à l’esprit pendant la conception.

Espace de travail

L’environement de routage est très proche de l’éditeur de schéma (l’organisation de l’interface utilisateur est sensiblement identique). En procédant de façon similaire à l’éditeur de schéma, afficher une grille de 50 mils dans l’éditeur de circuit. Sélectionner l’outil WIRE pour dessiner le contour de la carte. Au dessus de la zone de travail, une barre de menu horizontale s’affiche automatiquement. Il s’agit des propriétés de l’outil WIRE. Sélectionner la couche 20 (Dimension) et choisir une épaisseur de trait de 10 mils. Une remarque importante est que l’unité utilisée dans l’éditeur est définie par l’unité utilisé pour la grille.

WireProperties

Cliquez sur l’origine de l’espace de travail (coordonnées 0,0), puis cliquez aux coordonnées 1600,1000 et finaliser le contour en cliquant à nouveau sur le point origine (un click droit pendant la définition du contour permet de modifier la forme de la liaison). Le contour de la carte devrait s’afficher en gris:

BoardOutline

Il est pratique de se souvenir que la molette de la souris permet de zoomer dans l’espace de travail et le bouton du milieu permet de se déplacer dans la vue courante (le bouton doit être maintenu pendant le déplacement de la souris).

Placement des composants

Comme pour l’éditeur de schéma, l’outil MOVE est utilisé pour déplacer les composants. L’éditeur de circuits affiche une vue de dessus de la carte. Les éléments affichés en rouge se trouvent sur le dessus de la carte (côté composants) et les élements déssinés en bleu sont sur le dessous (côté cuivre). L’outil MIRROR permet de changer un composant de face. Sélectionner l’outil, et cliquer sur l’origine (petite croix blanche) du composant à modifier. Placer C2 côté cuivre et C3 côté composants.

Mirror

Comme pour l’éditeur de schéma, lors du déplacement, un clic gauche place le composant, un clic droit permet de réaliser une rotation. Lors du placement des composants, il est possible d’actualiser le chevelu (i.e. calculer le lien direct le plus court pour chaque connexion) en utilisant l’outil RATSNETS:

Ratsnets

Placer les composants selon l’arrangement suivant et actualiser le chevelu:

ComponentArrangement

Routage

Le routage consiste maintenant à transformer le chevelu en pistes de cuivre. Cela se fait grâce à l’outil ROUTE:

Route

Pour créer une nouvelle piste, sélectionner l’outil de routage et cliquer sur une connexion non routée du chevelu. La piste apparait et s’adapte aux mouvements de la souris. Un clic droit permet de changer le chemin de la piste comme dans l’éditeur de schéma. Le double clic permet de terminer l’action. Changer la couche courante pendant le routage d’une piste (menu Layer situé en haut à gauche au dessus de l’espace de travail) permet de faire passer la piste d’une couche à l’autre et ajoute automatiquement un via si cela est nécessaire. Utiliser le bouton du milieu pour changer de face permet de gagner un temps considérable pendant le routage.
La transformation inverse (passer d’une piste routée vers le chevelu) n’est pas réalisée avec l’outil DELETE. Cet outil supprime la connexion. Lorsque le lien avec l’éditeur de schéma est actif (forward and backward annotation), supprimer une connexion n’est pas possible depuis l’éditeur de circuit; cela doit impérativement être fait dans l’éditeur de schéma. Pour supprimer le routage d’une piste, il faut utiliser l’outil RIPUP:

Ripup

Pour supprimer une connexion complète (et pas seulement un segment) il est possible de cliquer sur une connexion non routée (un fil du chevelu) et toutes les pistes et vias adjacents seront déroutées jusqu’à la prochaine broche ou composant. De cette façon, en cliquant deux fois sur une piste il est possible de supprimer rapidement l’ensemble des segments formant cette piste. Les pistes et les vias peuvent être déplacés avec l’outil MOVE. Sélectioner une piste proche d’une extrémité d’un segment va bouger cette extrémité. Sélectionner une piste au milieu d’un segment va déplacer le segment. Il est important de noter que pour déplacer un composant, sont origine doit être visible (calque 23 (tOrigins) et 24 (bOrigins) pour les composants situés respectivement côté composant et côté cuivre).
L’outil SPLIT permet de diviser un segment en deux (ajouter une courbure dans une piste). Cette commande est utilie pour déplacer ou modifier une piste existante:

Split

Router la carte selon l’illustration suivante (la largeur des pistes est de 50 mils):

Routed

Modifier le routage

L’outil CHANGE permet de modifier les propriétés des éléments du routage. Lors de la selection de cette commande, un menu contextuel apparaît avec la liste des propriétés:

Change

Selectionner WIDTH > 10 et cliquer sur une piste du routage. La largeur de la piste est alors modifiée. L’action peut être annulée avec la commande UNDO (Ctrl-Z). Les noms et valeurs des composants ne peuvent pas être modifiés avec cet outil, ils doivent impérativement être réalisés avec les commandes NAME et VALUE comme dans l’éditeur de schéma. Modifier la valeur de la résistance R3 de 680 à 470 et vérifier que le schéma est mis à jour:

BackAnnotate

Réaliser l’action inverse depuis l’éditeur de schéma et vérifier que le routage a été mis à jour. Lorsqu’une action est appliqué sur un objet trop proche d’un autre, le logiciel ne peut pas deviner lequel est concerné. Dans ce cas, un seul objet est mis en surbrillance et un clic droit permet de sélectionner un autre candidat. Un clic gauche permet finalement d’appliquer l’action à l’objet en surbrillance.

Vérification du respect des règles de routage

Avant de lancer la fabrication du circuit imprimé, il est prudent de vérifier le routage à l’aide de l’outil DRC (Design Rule Check). Sélectionner l’outil en cliquant sur l’icône.

DRC

La fenêtre de configuration s’ouvre. Le concepteur peut spécifier ses propres règles de vérification. Lorsque les règles sont configurées, cliquer sur le bouton CHECK pour lancer la vérification. S’il n’y a pas d’erreur, un message est simplement affiché en bas de l’éditeur. Si des erreurs sont détectées une fenêtre apparaît :

DRC_Errors

Ici deux erreurs sont détectées. Les perçages des vias sont trop petits au regard des règles de routages. En sélectionnant une des erreur, celle-ci est mis en évidence dans le routage:

Error_Hilighted

Avec l’outil CHANGE, augmenter le diamètre de perçage des vias de 23.62205 à 27.55906. Relancer la vérification, dans le coin inférieur gauche de la fenêtre, le message suivant devrait apparaitre : “DRC: No errors”. Le circuit est prêt pour la fabrication.

Cliquer ici pour revenir au sommaire

Premiers pas avec EAGLE – Partie 2 – L’éditeur de schémas

Cet article fait partie d’un tutoriel sur le logiciel EAGLE. Le lecteur est invité à se référer aux autres sections de ce tutoriel en suivant ce lien : Premiers pas avec EAGLE
Dans la suite de ce tutoriel, le lecteur sera guidé dans la création d’un circuit élémentaire afin de découvrir la réalisation intégrale d’un circuit imprimé. La première étape est la réalisation du schéma.

Espace de travail

Avant de commencer le schéma proprement dit, nous allons insérer un cartouche qui pourra contenir les éléments principaux de notre projet (titre, date, auteurs…). Dans la barre verticale située à gauche de la fenêtre, sélectionner l’outil d’ajout en cliquant sur l’icône ADD. Cet outils permet l’ajout de nouveaux éléments dans le schéma. Il est majoritairement utilisé pour l’ajout de composants.

Add_Icon

Une fenêtre s’ouvre et affiche la liste des bibliothèques disponibles. Dans le champ de recherche (Search) situé en bas à gauche de la fenêtre, entrez “frame” et confirmez par entrer :
Add_Frame
La liste des bibliothèques est maintenant limitée aux entrées contenant le mot “frame” dans leur titre ou leur description. Sélectionner le cartouche A4L-LOC qui est un cartouche standard DIN A4 disposé en paysage et valider en cliquant sur OK. Le cartouche est maintenant associé au curseur de la souris, placer le cartouche de façon à aligner le coin inférieur gauche avec l’origine du repère (0,0). Les coordonnées sont affichées en haut à gauche de l’espace de travail. L’origine est également représentée graphiquement par une petite croix dessinée en pointillés. Quand le cartouche est positionné, un clic gauche de la souris permet de le fixer et deux appuis consécutifs sur Echap permettent de quitter l’outil.

Frame_Grid

Sauvegarder votre schéma et ajuster la vue en cliquant sur “Zoom to fit”. Vous devriez maintenant avoir une vue générale du futur schéma.

ZoomToFit

Cliquez sur l’icône de configuration de la grille:

Grid

La fenêtre de configuration de la grille apparait, il est possible d’y régler les différents paramètres (taille, style, etc.). Rendre la grille visible en cochant “On” pour le champ “display”, valider sur “OK”. L’espace de travail est prêt pour recevoir le schéma et devrait resembler à ceci:

Workspace

Ajout des composants

Cliquer sur l’outil d’ajout qui a déjà été utilisé pour l’ajout du cartouche. EAGLE propose une large panoplie de bibliothèques de composants, et l’utilisateur peut utiliser des masques de recherche en utilisant les caractères spéciaux (wild cards) ‘?’ et ‘*’:

  • * est un masque de recherche qui peut être remplacé par un ou plusieurs caractères. Par exemple *555 va afficher toutes les entrées se terminant par 555. 555* va afficher toutes les entrées commençant par 555 et *555* va afficher toutes les entrées comportant 555.
  • ? est un masque de recherche similaire à l’étoile, mais il ne peut être remplacé que par un unique caractère.

Lors de l’ajout d’un composant, l’utilisation du clic droit est pratique pour tourner le composant avant de le placer (clic gauche). Lorsque le symbole est placé, des modifications sont toujours possibles :

Move Copy RotateDelete
Rechercher et ajouter les composants suivants :
DésignationBibliothèqueComposantBoitier
NE555st-microelectronicsNE555DIL-08
ResistancerclR-EU0204/7
Condensateur polarisérclCPOL-EU2,5-6EE2,5-6E
CondensateurrclC-EUC1206C1206
Borniercon-ptr500AK500/2AK500/2
LED 5mmledLED5MMLED5MM
Symbole VCC supply2VCC-
Symbole GNDsupply2GND-
Vous aurez remarqué que, bien que VCC et GND ne soit pas des composants physiques, nous les trouvons dans les bibliothèques. Ajouter, dupliquer et placer les composants selon l’arrangement suivant:

ComponentsPlacement

Ajout des connexions

Les connexions électriques doivent être ajoutées avec l’outil NET (ou l’outil Bus pour l’ajout de bus). Attention de ne pas confondre avec l’outil WIRE qui dessine aussi des lignes, mais n’est pas dédié aux connexions électriques. Il appartient aux outils de dessin (texte, cercle, arcs…).

net

lorsque l’outil de connexion NET est sélectionné, ajouter une connexion en cliquant sur la première broche à connecter. Placer le curseur sur la seconde broche (ou liaison); cliquer avec bouton droit de la souris permet de changer le chemin emprunté par la connexion. Cela peut aussi être réalisé en sélectionnant un des outils suivants:

WireBendStyle

Connecter les éléments de votre schéma selon la disposition suivante. Il s’agit d’un oscillateur élémentaire à base de NE555 qui permet de faire clignoter une LED:

SchematicWiring

Valeurs et noms des composants

L’icône suivant NAME permet à l’utilisateur de changer le nom d’un composant:

Name

De la même façon, l’icône suivant VALUE permet de modifier la valeur d’un composant (quand ce dernier s’y prête):

Value

Renommer et modifier les valeurs de chaque symbole conformément au schéma suivant:

Rename

Vérification du schéma

Lorsque le schéma est terminé, il est prudent d’utiliser l’outil ERC (Electric Rules Check). Cet outil permet de détecter d’éventuelles erreurs dans le schéma (composants mal connectés ou incompatibles …).

ERC.

Une nouvelle fenêtre apparait et affiche quatre avertissements:

ErrorList

Le premier dit que la broche 8 du NE555 s’appelle VCC+ alors qu’elle est connectée à VCC. Les trois autres stipulent que le cartouche, la LED et le bornier n’ont pas de valeur. Aucun de ces quatre avertissements n’est réellement une erreur et ils peuvent être amendés. La boite de dialogue ne doit maintenant afficher aucune erreur ni avertissement, et quatre approuvés:

ErrorApproved

Préparation du routage

Lorsque le schéma est terminé et vérifié, le circuit imprimé peut être créé. Cliquer sur l’icône suivant pour générer le circuit imprimé et lancer l’éditeur.

GenerateBoard

Il est possible qu’EAGLE vous demande de confirmer la création du nouveau circuit à partir de votre schéma, répondre Yes. Le circuit est automatiquement généré et préparé pour le routage:

BoardEditor

Cliquer ici pour passer à l’étape suivante
Cliquer ici pour revenir au sommaire

Premiers pas avec EAGLE – Partie 1 – Le panneau de contrôle

Cet article fait partie d’un tutoriel sur le logiciel EAGLE. Le lecteur est invité à se référer aux autres sections de ce tutoriel en suivant ce lien : Premiers pas avec EAGLE
Eagle signifie Easily Applicable Graphical Layout Editor. C’est un logiciel de CAO dédié à l’électronique développé par la société Allemande CadSoft Computer GmbH. EAGLE est founi avec, entre autre, un éditeur de schéma (schematic capture editor), un éditeur de circuit imprimés (PCB Printed Circuit Board layout editor), un routeur automatique et des outils d’aide à la mise en production (CAM Computer-Aided Manufacturing)… Ce logiciel est compatible avec Windows, Linux et Mac OS X. Ce tutoriel a été préparé avec le version 6.5.0 sous Ubuntu 12.04 LTS

Control panel

La fenêtre suivante apparait au démarrage d’EAGLE, il s’agit du panneau de contrôle:ControlPanelDans la partie gauche de la fenêtre, l’utilisateur peut avoir une vue d’ensemble des projets, des bibliothèques et des différents réglages:

  • Libraries: contient la liste des bibliothèques de composants disponibles. Chaque composant est constitué d’un symbole lié à son empreinte.
  • Design Rules: l’utilisateur peut régler ici les principaux paramètres de routages et de mise en production.
  • User Language Programs: ce sont des programmes (écrits dans un langage proche du C) qui peuvent être utilisés pour différentes fonctionalités. Ils peuvent servir, par exemple à modifier un projet ou automatiser certaines tâches.
  • Scripts: il est possible d’exécuter des fichiers de script contenant des séquences de commandes. Cela permet de personnaliser certaines actions selon des besoins propres (définir des touches de raccourci, charger des contours de cartes prédéfinis, changer les couleurs …)
  • CAM Jobs: CAM est l’accronyme de Computer-Aided Manufacturing (production assisté par ordinateur). Cela permet de générer les données pour la mise en production (par exemple la production des Gerbers, qui est le format le plus répandu dans l’industrie).
  • Projects: cet branche contient la liste des exemples et projets. Lors de la création d’un nouveau projet, celui-ci est automatiquement ajouté à la liste.

La carte Arduino MEGA2560 a été conçue avec EAGLE. Elle est fournie parmi les exemples:
Arduino

Répertoires

Par défaut, EAGLE sauvegarde tous les projets et les fichiers dans le même dossier principal et crée des sous-dossiers pour différencier les projets. Dans la barre de menu principal, sélectionner Option puis Directories:

Menu_Directory

L’interface illustré ci-dessous permet à l’utilisateur de configurer les répertoires de sauvegarde. $EAGLEDIR représente ici le répertoire principale (sur mon installation, celui-ci correspond à /home/username/eagle-6.5.0/). Lors de la création d’un nouveau projet, un nouveau sous-dossier est automatiquement créé dans $EAGLEDIR/projects/ . L’utilisateur peut paramétrer différents dossiers. Il est par exemple possible d’avoir les bibliothèques par défaut sur un disque réseau et les projets personnels dans un répertoire local privé.

Directory

Avant de poursuivre, vérifier que le répertoire pour les bibliothèques (Libraries) est correctement configuré: $EAGLEDIR\lbr.

Bibliothèques

Dans la partie gauche du panneau de contrôle, cliquer sur Libraries pour développer l’arborescnce et chercher la bibliothèque 74xx-eu.lbr. Cette bibliothèque contient les circuits TTL (série 74xx de Texas Instruments). Choisissez un circuit, dans la partie droite le symbole et l’empreinte apparaissent:

Library

Nouveau projet

Pour créer un nouveau projet, selectionner File > New > Project :
NewProject

Le nouveau projet est automatiquement ajouté dans la partie gauche de la fenêtre principale (sous Project/eagle). Entrer le nom de votre projet, par exemple FirstPCB :
ProjectName

Effectuer un clic droit sur le nouveau projet et choisisser New > Schematic.
NewSchematic

Une nouvelle fenêtre s’ouvre, c’est l’éditeur de schéma (Schematic Editor):
SchematicEditor

Cliquer ici pour passer à l’étape suivante
Cliquer ici pour revenir au sommaire