Pilotage à partir du composant A4935

De troyesGEII
Aller à : navigation, rechercher


Étude du composant A4935

Le composant A4935 sert à piloter des transistors MOS sur 3 phases différentes.

Le but est de fabriquer une carte permettant de tester le composant A4935 ainsi que de déterminer les valeurs des différents composants qui lui seront associés. Il faudra également déterminer quels signaux logiques, et sur quelles entrées ceux-ci iront afin de choisir un mode de fonctionnement approprié.

Le but est d'obtenir un signal carré en sortie, sur trois phases différentes, que l'on contrôlera indépendamment.

CarteA4935.png

Organisation de l'étude

Taches.png Gant1.png Gantt2.png

Informations tirées de la documentation

Schéma structurel

Les premières informations que nous avons récupéré sont grâce au schéma fonctionnel suivant:

Bloc fonctionnel.png

Nous avons suivit ce schéma afin de fabriquer la carte, cependant, la partie inférieure avec l'AOP et les différentes résistances et condensateurs ne seront pas présentes sur notre carte.


Table de vérité

Les différents modes nous intéressant sont les n°2 et n°3, puisque l'on veut commander de manière indépendante chacune des trois phases du moteur, en sortie. Cette table permet également de repérer les différentes entrées que nous devrons contrôler.

Le mode n°2 permettra de faire fonctionner le transistor du haut, tandis que le mode n°3 permettra de faire fonctionner le transistor du bas.

Table verite.png

Valeur des composants

Les différentes valeurs des condensateurs se calculent à partir des informations que l'on trouve dans la datasheet de l'A4935.

-Creg = 470nF (absent pour les tests)


D'après paragraphe Gate Drive Vooltage Regulation de la page 8, le condensateur Cp doit avoir une valeur minimum de 220nF, il est généralement de 470nF.

-Cp = 470 nF


Calcul de Cboot à partir du paragraphe Bootstrap Capacitor Selection & Bootstrap Charging de la page 18.

Tcharge = (Cboot*ΔV)/100

ΔV = 12V

Tcharge = 100μs

Cboot = 0.085nF ( 82pF en valeur normalisée )

-Cboota = 82pF

-Cbootb = 82pF

-Cbootc = 82pF


La valeur du Cdd nous a été donnée

-Cdd = 100nF


Deux potentiomètres de 40KΩ sont reliés à la patte 48 RDEAD et à la patte 20 VDSTH. Ces deux potentiomètres permettent durant la phase de test d'essayer plusieurs valeurs de résistance sans avoir à changer de composant à chaque essais.

Carte principale

Le composant A4935 sera placé dessus. Les condensateurs de découplage seront également placés là. Le condensateur CP sera remplacé par deux bornes afin de pouvoir faire différents test.

Schéma et board

Les entrées xHI, xLO sont reliées à un bornier femelle afin de pouvoir choisir indépendamment les valeurs qui leur seront données (sur ce bornier sont également présents le seuil haut et bas pour les autres entrées).

Les entrées RESET(oublié sur notre carte à cause d'une erreur de notre part),CCEN, COAST, PWMH, PWML sont reliées chacune à des borniers de 3 pattes (deux des pattes sont reliées au seuil logique haut, et au seuil logique bas) afin de pouvoir affecter une valeur différente à ces entrées à l'aide d'un cavalier.

Le VBB présent sur le schéma aurait également dû être relié à une alimentation (erreur de notre part).

De plus, le composant A4935 n'étant pas placé de base de la librairie Eagle, il a fallut créer celui-ci. On a pu réutiliser un package déjà présent dans la librairie Eagle, celui-ci étant similaire à celui de la documentation (48-pin LQFP)

A4935sch.png

Les pistes en sortie du composant A4935 sont les moins larges possibles afin de ne pas avoir de contact entre les différentes pattes. De plus, des détrompeurs sont présentes sur chacun des connecteurs, et chacun des noms de condensateur est noté afin de pouvoir les repérer plus simplement, sans forcément avoir le board à portée. Les connecteurs pour les cartes annexes sont tous les trois disposés sur trois côtés différents de la carte principale, au bord, afin de pouvoir connecter les annexes le plus simplement possible.

Le composant A4935 n'étant pas présent de base dans les librairies d'Eagle, nous avons du le créer pour l'occasion.

A4935brdbot.png A4935brdtop.png

Media:ER_carte_test.brd Media:ER_carte_test.sch

Fabrication

La carte ne comportant qu'un seul composant CMS (l'A4935), nous avons commencé par placer celui-ci avec de la pâte à braser, suivit d'un passage au four. Le reste des composants (potentiomètres, borniers) sont soudés de manière normale.

En raison des différents oublis sur le schéma Eagle, nous avons dû essayer de réparer nos erreurs: nous avons soudé plusieurs fils sur les pattes du composant (afin de rajouter le VBB ainsi que le RESET), nous avons utilisé deux méthodes différentes, placer de la pâte à braser directement sur l'endroit voulu, ou bien placer de l'étain sur le fil puis le placer ensuite. Les pattes de ce composant étant extrêmement petites, plusieurs complications se sont rajoutées afin d'éviter les liaisons non voulues entre les pattes.

TopA4935.png BotA4935.png

Tests

Après avoir effectué les branchements sur la carte (signaux logiques, alimentation, etc...). Nous avons placé une des cartes annexes, à laquelle nous avons relié une résistance pour voir si un signal était bien récupéré. Le signal en sortie s'est avéré beaucoup trop faible. Les différents blocs fonctionnels ont été ensuite testés, et il semblerait que ça soit le "Charge pump regulator" qui ne fonctionne pas, la tension aux bornes de celui-ci étant inférieure à 0,5V alors que son but est de rehausser la tension d'entrée.

Cartes annexes

Deux transistors C-MOS IRF2204 y seront positionnés. Cinq pattes seront reliées à la carte principale, à savoir GHA, SA, GLA, VCC ainsi que la masse.

Schéma et Board

Les pistes sont les plus larges possibles, 2.2 mm, puisqu'elles sont destinées à accueillir des grosses valeurs de courant. Deux détrompeurs sont présents au niveau du connecteur.

Transiirfsch.png Transiirfbrd.png

Media:Transiirf.brd Media:Transiirf.sch

Fabrication

La carte est simple face en ce qui concerne les pistes. Nous avons placé les composants CMS du côté BOTTOM, en passant les 3 cartes au four. En ce qui concerne le reste des composants (barrette sécable, transistors et douilles), ceux-ci sont placés du côté top de la carte. Ils ont été soudés à la main.

Transiirf.png

Tests

On effectue d'abord le test sur le transistor du haut, on rentre un signal carré (d'amplitude 0-5V et de fréquence 1kHz) et on met le transistor du bas à la masse. On observe en sortie un signal carré d'amplitude 0-2.5V, le transistor se bloque donc correctement. On effectue le même test pour les transistors haut des deux autres cartes.

TestIRF haut.png

Pour le transistor du bas, on effectue la même manipulation mais avec un signal carré d'amplitude 0-4V et on met le transistor du haut à la masse. Ici aussi le transistor se bloque correctement, le signal de sortie est un signal carré d'amplitude 0-2V. On effectue le même test pour les transistors bas des deux autres cartes.

TestIRF bas.png

Pilotage du moteur

Partie informatique

But du programme

On cherche à générer trois MLI, ainsi que leurs opposées (donc six MLI au total) qui permettront de commander le composant A4935, et ainsi d’obtenir en sorties les 3 phases qui permettront de contrôler le moteur. Ces trois MLI devront chacune être déphasées de 2π/3 afin d’obtenir un champ magnétique permettant de faire tourner le moteur.

Une MLI est un signal logique dont le rapport cyclique varie afin d’obtenir une valeur moyenne, qui ici, formera un sinus. Dans notre cas, les MLI fonctionnent par paires (celles-ci allant sur les entrées xHI et xLO), afin que les deux transistors d’une paire ne conduisent pas en même temps, il faut qu’il y’ait un léger décalage à chaque transition

Décalages.png

Afin de pouvoir obtenir un retour d’informations, et donc de connaître la position du moteur en temps réel, un codeur incrémental est placé sur le moteur. Ce codeur fonctionne de la manière suivante : des crans (200 au total) sont placés sur deux lignes différentes, chacun légèrement décalés, sur un disque, à chaque passage sur l’un deux, un signal haut est délivré. Un autre cran est également placé afin de déterminer quand le moteur a terminé un tour.

Codeur incremental disque.gif


On se servira donc de ce codeur pour savoir la position du moteur, et ainsi déterminer l’angle qu’il faut donner au champ tournant pour pouvoir maximiser sa vitesse.

Choix du matériel utilisé

La première solution a été d'utiliser une carte Arduino UNO, pour comprendre le fonctionnement des MLI, apprendre à utiliser le codeur incrémental: récupérer les données de celui-ci, et les utiliser. Cette carte n'étant cependant pas assez rapide, il aurait fallu la coupler avec un FPGA.

La seconde solution a été d'utiliser l'Arduino DUE, qui en plus d'avoir une vitesse de calculs bien supérieure à l'Arduino UNO, possède plusieurs fonctions directement implémentées dans le microcontrôleur, telles que générer les MLI, ou encore exploiter le codeur incrémental. On a donc adopté cette option, et le programme a été développé pour l'Arduino DUE.

Présentation et explications du programme

L’exploitation du codeur se fait grâce à trois fils qui sont branchés sur les entrées 2 – 13 – A6 de la carte Arduino DUE. Ces entrées sont utilisées dans une première interruption qui permet d’obtenir la position (sur 800) du moteur, ainsi qu’une seconde interruption qui permet de savoir quand on a fait un tour complet. Pour utiliser ces fonctions directement implantées dans le matériel, il faut cependant choisir ces modes à l’aide des registres dont on a besoin. Tout ceci est précisé dans la documentation de l’arduino DUE.

Ensuite, la génération des MLI se fait également à l’aide de fonctions présentes dans le matériel, il faut de la même manière appliquées les valeurs que l’on veut aux registres concernés pour choisir le mode dont on a besoin. On affecte ensuite les valeurs que l’on veut dans une autre fonction (cette valeur dépendant directement de la position retournée par les interruptions du codeur) où on repasse la valeur de la position en radians (Position*2π/800), puis l’on prend le sinus de celle-ci, pour au final obtenir cette formule que l’on affecte aux MLI : amplitude * sin(Position*2π/800)+1. On rajoute 1 afin de ne pas obtenir de valeur négative, et on multiplie par l’amplitude car c’est grâce à celle-ci qu’on pourra augmenter ou diminuer la vitesse de rotation du moteur.

Lors de l’initialisation du moteur, il faut commencer par trouver le top tour. On effectue donc un premier tout manuel jusqu’à ce que le message "ok, top tour trouve" apparaisse sur le moniteur série. Suite à ça, on initialise les interruptions et on affiche l’angle de base ainsi que l’amplitude de base. Le moteur doit normalement être en train de tourner.

Les dernières fonctions dans le loop permettent de modifier l’amplitude ainsi que l’angle zéro manuellement. Celles-ci nous ont permis, grâce aux tests (on branche la sortie de la carte à laquelle est branchée l’arduino à un oscilloscope) de voir pour quel angle la valeur de la fréquence était la plus élevée, pour finalement déterminer que l’angle zéro était aux alentours de 93°. On a cependant choisis de ne pas mettre une trop grande amplitude, car, puisqu’on doit lancer le moteur manuellement, si celui-ci se met à tourner trop vite d’un coup, il y a un risque de se blesser au niveau des doigts.

Une dernière fonction était en cours de réalisation, il s'agit de initMoteur présente au début du programme, celle-ci avait pour but de permettre au moteur de se lancer de lui-même, elle n'a cependant pas été achevée. Enfin, une dernière amélioration possible qui était en cours de réalisation, était de ne pas générer 3 paires de MLI, mais d'en générer 6 paires afin de piloter les trois derniers câbles du moteur que nous n'avions pas utilisé.

// voie A -> 2
// voie B -> 13
// voie T -> A6
// angleInit=93


const uint32_t rMax = 2000;
const uint32_t nbi = 800; // 200*4n
const int quad_A = 2;
const int quad_B = 13;
const unsigned int mask_quad_A = digitalPinToBitMask(quad_A);
const unsigned int mask_quad_B = digitalPinToBitMask(quad_B);

unsigned char sensMoteur = 1;
const int angleMax = 800;
float amplitude = 100;
int angleInit = 100;
const int seuilSens = 500;

volatile boolean change = 0;
volatile unsigned angle;

const unsigned char timing = 10;

volatile char top = 0;
volatile int32_t tourne = 0, pos = 0;
volatile uint32_t nbt = 0;
volatile int32_t nbe = -1;

void initMoteur()
{
  int a=0,i,j;
  int anglefin[2];
  int angleCourant,anglePrec;
  int sens=0;
  long offset=0;
  
  rotation(0);
  delay(30);
  
  Serial.println("Rercherche du sens de rotation");
  angleCourant=pos;
  anglePrec=angleCourant;
  do
  {
    a++;
    if (a==angleMax) a=0;
    rotation(a);
    delay(timing);    
    angleCourant=pos;
    if (angleCourant>anglePrec) sens++;
    if (angleCourant<anglePrec) sens--;
    Serial.println(pos);
    anglePrec=angleCourant;
  }
  while((sens<seuilSens)&&((-sens)<seuilSens));
  Serial.print("sens = ");
  Serial.println(sens);
  if (sens<0)
  {
   Serial.println("sens inverse"); 
    sensMoteur=0;
  }
  else 
  {
    Serial.println("sens ok");
  }
  
  Serial.println("Remise à la position 0");
  i=a;
  for (a=i;a>0;a--)
  {
    rotation(a);
    delay(timing/2);
  }
  
  Serial.println("Recherche de l'angle zero");
  
  while (1);
}

void interruption_setup()
{
  // activate peripheral functions for quad pins
  REG_PIOB_PDR = mask_quad_A;     // activate peripheral function (disables all PIO functionality)
  REG_PIOB_ABSR |= mask_quad_A;   // choose peripheral option B
  REG_PIOB_PDR = mask_quad_B;     // activate peripheral function (disables all PIO functionality)
  REG_PIOB_ABSR |= mask_quad_B;   // choose peripheral option B

  // activate clock for TC0
  REG_PMC_PCER0 = (1 << 27);
  REG_PMC_PCER0 = (1 << 28); // activate clock for TC1
  // select XC0 as clock source and set capture mode
  REG_TC0_CMR0 = 5;
  // activate quadrature encoder and position measure mode, no filters
  REG_TC0_BMR = (1 << 9) | (1 << 8) | (1 << 12);
  // enable the clock (CLKEN=1) and reset the counter (SWTRG=1)
  // SWTRG = 1 necessary to start the clock!!
  REG_TC0_CCR0 = 5;
  REG_TC0_CCR1 = 5;

  //sécurité : remise à zéro lorsque le cpt est au maxi
  REG_TC0_RC0 = nbi;
  REG_TC0_CMR0 |= 1 << 14;

  // remise à zéro à chaque tour
  REG_TC0_CMR0 |= 1 << 8;
  REG_TC0_CMR0 |= 1 << 10;



  REG_TC0_CMR1 = (1 << 8); // Set rising edge of Z
  REG_TC0_IER1 = 0b10000000; // enable interrupt on Z
  REG_TC0_IDR1 = 0b01111111; // disable other interrupts
  NVIC_EnableIRQ(TC1_IRQn);


  // entrée PC28
  REG_PIOC_PER |= 1 << 28;
}

void initInterrupt()
{
  pmc_enable_periph_clk(ID_PIOC);
  NVIC_DisableIRQ(PIOC_IRQn);
  NVIC_ClearPendingIRQ(PIOC_IRQn);
  NVIC_SetPriority(PIOC_IRQn, 0);
  NVIC_EnableIRQ(PIOC_IRQn);
}

void setInterrupt()
{
  REG_PIOC_IER |= 1 << 28; // enable interrupt
  REG_PIOC_AIMER |= 1 << 28; //
  REG_PIOC_ESR |= 1 << 28; // détection changement état
  REG_PIOC_REHLSR |= 1 << 28; // enable interrupt
}

void pwmc_setup()
{
  //Configure PWM channels 0,1,2,3 (PWML0,PWMH0,PWML1,PWMH1,PWML2,PWMH2,PWML3,PWMH3,PWML5,PWMH5,PWML6,PWMH6), (port C.2,C.3,C.4,C.5,C.6,C.7,C.8,C.9,C.18,C.19,C.22,C.23)
  //(pins P34,P35,P36,P37,P38,P39,P40,P41,P8,P44,P7,P45)

  REG_PIOC_PDR = 0xCC03FC;  //B11001100 00000011 11111100, PIO Disable Register
  REG_PIOC_ABSR = REG_PIOC_ABSR | 0xCC03FC; //B1111111100, Peripheral AB Select Register
  REG_PMC_PCER1 = REG_PMC_PCER1 | 16; //Peripheral Clock Enable Register 1 (activate clock for PWM, id36, bit5 of PMC_PCSR1)
  REG_PWM_ENA = REG_PWM_SR | B01101111; //PWM Enable Register | PWM Status Register (activate channels 0,1,2,3)

  REG_PWM_CMR0 = 0x10000; //Channe0 Mode Register: Dead Time Enable DTE=1
  REG_PWM_CMR1 = 0x10000; //Channe1 Mode Register: Dead Time Enable DTE=1
  REG_PWM_CMR2 = 0x10000; //Channe2 Mode Register: Dead Time Enable DTE=1
  REG_PWM_CMR3 = 0x10000; //Channe3 Mode Register: Dead Time Enable DTE=1
  REG_PWM_CMR5 = 0x10000; //Channe5 Mode Register: Dead Time Enable DTE=1
  REG_PWM_CMR6 = 0x10000; //Channe6 Mode Register: Dead Time Enable DTE=1

  REG_PWM_DT0 = 0x00080008; //Channe0 Dead Time Register (168=2us for outputs PWML0,PWMH0)
  REG_PWM_DT1 = 0x00080008; //Channe1 Dead Time Register (168=2us for outputs PWML1,PWMH1)
  REG_PWM_DT2 = 0x00080008; //Channe2 Dead Time Register (168=2us for outputs PWML2,PWMH2)
  REG_PWM_DT3 = 0x00080008; //Channe3 Dead Time Register (168=2us for outputs PWML3,PWMH3)
  REG_PWM_DT5 = 0x00080008; //Channe5 Dead Time Register (168=2us for outputs PWML5,PWMH5)
  REG_PWM_DT6 = 0x00080008; //Channe6 Dead Time Register (168=2us for outputs PWML6,PWMH6)


  REG_PWM_CPRD0 = rMax; //Channe0 Period Register 20kHz
  REG_PWM_CPRD1 = rMax; //Channe1 Period Register (84mhz/65535=1.281khz=780.64us period)
  REG_PWM_CPRD2 = rMax; //Channe2 Period Register (84mhz/65535=1.281khz=780.64us period)
  REG_PWM_CPRD3 = rMax; //Channe3 Period Register (84mhz/65535=1.281khz=780.64us period)
  REG_PWM_CPRD5 = rMax; //Channe5 Period Register (84mhz/65535=1.281khz=780.64us period)
  REG_PWM_CPRD6 = rMax; //Channe6 Period Register (84mhz/65535=1.281khz=780.64us period)

}

inline void pwmc_duty(unsigned short phaseA, unsigned short phaseB, unsigned short phaseC) {
  REG_PWM_CDTY0 = phaseA;
  REG_PWM_CDTY1 = phaseB;
  REG_PWM_CDTY2 = phaseC;
}

void rotation(int angleSouhaite)
{
  float sinA, sinB, sinC;
  sinA = sin(((float)angleSouhaite * 6.28) / angleMax);
  sinB = sin(((float)angleSouhaite * 6.28) / angleMax - 2.09);
  sinC = sin(((float)angleSouhaite * 6.28) / angleMax + 2.09);
  if (sensMoteur == 0)
  {
    pwmc_duty(amplitude * (sinA + 1), amplitude * (sinB + 1), amplitude * (sinC + 1));
  }
  else
    pwmc_duty(amplitude * (sinA + 1), amplitude * (sinC + 1), amplitude * (sinB + 1));

}

void PIOC_Handler(void)
{
  uint32_t isr = PIOC->PIO_ISR;
  tourne = 1;
  pos = REG_TC0_CV0;
  if (pos < 0)
  {
    pos = 800 + pos;
  }
  pos=pos-angleInit;
  if (pos < 0)
  {
    pos = 800 + pos;
  }
  if (pos>800) pos=pos-800;  
  rotation(pos);
}

void TC1_Handler() {
  //static uint32_t pos=0;
  static uint32_t lastpos = 0;
  //pos=REG_TC0_CV0;
  long dummy = REG_TC0_SR1;
  nbt++;
  //if ((pos-lastpos)!=nbi) nbe++;
  //lastpos=pos;
  //  nbe=pos;
  top = 1;                        // otherwise you get infinite interrupts
}

void setup() {
  Serial.begin(115200);
  delay(100);
  Serial.println("mise en route");
  Serial.println("tourner le moteur manuellement !");
  
  interruption_setup();
  pwmc_setup();

  boolean etatLed = 0;
  pinMode(4, OUTPUT);
  digitalWrite(4, 1);
  while (top == 0);

  Serial.println("ok, top tour trouve");

  for (char j = 0; j < 20; j++)
  {
    digitalWrite(4, etatLed);
    etatLed = !etatLed;
    delay(100);
  }
  digitalWrite(4, 0);

  initInterrupt();
  setInterrupt();
  Serial.print("amplitude=");
  Serial.println(amplitude);
  Serial.print("angleInit=");
  Serial.println(angleInit);
//  initMoteur();
}

void loop() {
char c;
if (tourne==1)
{
  Serial.println(pos);
  tourne=0;  
  delay(100);
  }
  if (Serial.available())
  {
    c = Serial.read();
    if ((c == '+') && (amplitude < 3000)) {
      amplitude += 10;
      Serial.print("amplitude=");
      Serial.println(amplitude);
    }
    if ((c == '-') && (amplitude > 10)) {
      amplitude -= 10;
      Serial.print("amplitude=");
      Serial.println(amplitude);
    }
    if (c == 'a') {
      angleInit--;
      Serial.print("angleInit=");
      Serial.println(angleInit);
    }
    if (c == 'q') {
      angleInit++;
      Serial.print("angleInit=");
      Serial.println(angleInit);
    }
    if (c == 's') {
     amplitude=0;
     }
   PIOC_Handler();
  }

}

Carte à tester

Réparation

La carte qui nous a été fournis n'était pas en bon état de fonctionnement, il fallut procéder à l'identification des problèmes et à sa réparation, celle-ci s'est déroulé en deux étapes.


La première étape étant la vérification de toutes les valeurs des composants à partir des valeurs données de la carte industrielle ATmega. Il a fallu modifier la valeur du condensateur Cp celui étant trop faible, afin de pouvoir augmenter sa valeur, on a soudé en parallèles du condensateur déjà présent un autre condensateur afin d'obtenir une valeur en farad suffisante.


La deuxième étape était de vérifier toutes les connexions entre les composants, les pistes au niveau des pattes du composants A4935 étant très minces, il a fallu les renforcer à certains endroits difficiles sans créer de court-circuits. Plusieurs retouches ont ainsi été faites au fer à souder afin d'assurer un bon fonctionnement.


Les mêmes réparations ont été effectuées des deux côtés de la carte.

Schéma et board

Cartsch.PNG Cartbrd.PNG

Test

Après la vérification des valeurs de tout les composants, on a procédé aux tests de la carte. Les tests se déroulent de la même manière que pour la carte test, les branchements s'effectue à l'aide de la table de vérité présente dans la datasheet. Deux plaques ont aussi été créées afin de pouvoir regrouper tout les branchements à l'alimentation (8V) et à la masse, cela permet de simplifier les branchements et d'éviter les oublis.


Il a fallu vérifier qu'on obtenait bien les bons signaux de sorties au niveau de tout les transistors de chacune des phases (A-B-C). On s'est alors aperçu que lorsque l'on voulait avoir un signal de sortie sur le transistor du haut et que l'on bloquait celui du bas, on obtenait le signal voulu en sortie du transistor H mais que celui du transistor B persistait à 1 (alimentation 8V) malgré le fait que celui-ci soit forcé à 0 en étant relié directement à la masse. La solution se trouvait au niveau de la patte lss de l'A4935, en effet on avait jugé celle-ci inutile alors qu'elle permet au transistor de se décharger. On répète le même test pour chacune des trois phases pour valider le bon fonctionnement de la carte.

Réalisation d'un shield

Sur une carte Arduino, il est possible d'y emboîter une autre carte nommée shield possédant les mêmes dimensions et permettant de faciliter son utilisation. Ce shield permet la liaison entre le moteur et les transistors présent sur notre carte, il permet également de simplifier les branchements à l'alimentation et à la masse, et on peut aussi le brancher directement sur le moteur afin d'obtenir directement un retour d'informations.

Pour sa conception, on a téléchargé la forme d'une Arduino pour avoir les dimension exact sur Eagle et afin d'avoir un modèle sur lequel travailler directement. Ensuite nous avons listé les entrées et sorties nécessaires et relié certaines pistes ayant une alimentation commune afin d'avoir un minimum de branchements à faire.


Shieldsch.PNG Shielbrd.PNG