Binome2020-10

De Wiki de bureau d'études PeiP
Révision datée du 6 mai 2021 à 14:41 par Egodard (discussion | contributions) (Clé finale)

Introduction

Lors de ce BE nous allons devoir réaliser une clé USB avec une particularité en plus. Nous allons devoir réaliser un PCB (Printed Circuit Board) à l'aide du logiciel Fritzing, souder les composants que nous avons besoin sur une carte et faire un programme pour que notre fonctionnalité marche. Ensuite nous allons faire la clé USB dans les bonnes dimensions et lui fabriquer un boitier.


Idée de la Carte

Première idée

Notre idée principale a été de faire une Clé Minuteur composée de 2 afficheurs à LED 7 segments pour aller de 0 à 99 secondes (on peut aller jusqu'à 3 afficheurs pour couvrir le temps de 0 à 10 min) avec 2 boutons poussoirs, un pour les dizaines de secondes et 1 bouton pour les unités ( nous devons réflechir sur le fait de mettre en pause et lancer le minuteur et enfin une petite LED et un buzzer pour montrer la fin du minuteur.

Mise en commun & solution pour une carte

En discutant avec d'autres groupes qui utilisent des afficheurs et les professeurs, nous avons décidé d'utiliser 3 afficheurs 7 segments par soucis de stock d'afficheurs au sein de l'école.


M. Redon et M. Boé nous ont donc proposé de faire une carte externe qui contiendra les afficheurs, que nous pourrions connecter à chacune des cartes contenant le programme de la clé (dans notre cas: nous connecterons la carte d'afficheur sur notre carte "minuteur")


Idée finale

Par la suite, nous sommes dont partis pour une carte avec 3 afficheurs et 3 boutons: un pour les secondes, un pour les minutes et un autre pour démarrer, mettre en pause et arrêter le minuteur.


Nos recherches

Nous nous sommes documentés sur le fonctionnement de composants comme les afficheurs 7 segments que nous utilisons,

Afficheur 7 segments.jpg


référence

Celui-ci est composé de 5 connections de chaque côté, cet afficheur est un afficheur à anode commune (3 et 8)


La carte "afficheurs" va être composée 5 broches en haut (respectivement Afficheur 1 / Afficheur 2 / Afficheur 3 / +5V / GND) et de 8 broches en bas (respectivement A / B / C / D / E / F / G / DP) La distance entre les deux lignes de broche est de 12 broches

Les afficheurs auront 3 transistors (pour les Afficheurs) et 8 résistances (pour les lettres A,B,..,DP)


Au tout départ, nous voulions commencer le "Schematic" sur le logiciel Fritzing cependant, il fallait tout d'abord se renseigner sur les composants.

C'est pourquoi nous nous sommes renseigné sur le fonctionnement d'un transistor et nous avons remarqué qu'il en existait 2 sortes, les PNP et les NPN, la différence entre les deux correspond au fait que pour les PNP le courant va de l'émetteur vers la base et le collecteur est relié au GND tandis que pour un NPN le courant va de la base vers l'émetteur et le collecteur est relié à l'alimentation.


Lors de la conception de notre carte, nous avons utilisé le microprocesseur "ATTiny 84".


AtTiny84


Ce microprocesseur possède 14 broches, les broches 1 et 14 sont respectivement l'alimentation et la masse. Il faut donc utiliser les 12 autres broches pour contrôler nos composants électroniques. Cependant nous avons besoin de 3 broches pour les transistors, 8 broches pour les LED des afficheurs (7 segments + le point) mais aussi 3 broches pour les boutons ( et possiblement une supplémentaire pour rajouter un buzzer et/ou une led pour indiquer la fin du minuteur). la solution : sacrifier l'affichage du point et l'utilisation de 2 boutons au lieu de 3.









Première carte

Frtizing

En commençant à faire notre dé électronique sur Fritzing, nous étions partis pour faire la carte avec les afficheurs, mais il nous suffisait de faire simplement notre schematic avec notre fonction minuteur et à représenter les connecteurs présents sur la carte pour qu'on puisse l'emboiter avec la carte "afficheurs".


Notre problème était le manque de broche pour tout nos composants. On nous avait donc conseillé d'enlever un bouton de notre carte et d'enleverde ne pas utiliser le point de l'afficheur. Nous avons donc eu l'idée de faire un pont de résistance pour notre carte ce qui nous a permi de garder un 3ème bouton et de mettre un buzzer pour marquer la fin du minuteur.

Voici à quoi ressemble notre Schematin et notre PCB:

Circuit imprime minuteur.pngSchematic minuteur.png


Après cela,nous avons pu imprimer notre carte:

Carte imprime .jpg

Soudure

Lors de la séance du 4 Février nous avons découvert la soudure et nous avons pu commencer a souder les composants. Il a fallut a plusieurs reprise resouder certains composants car nous nous sommes apercus par la suite, quand nous commencions la programation, que cela ne marchait pas. Nous avons donc fait des test avec un multimètre pour voir si le courant passait et nous avons vu qu'un bouton et une résistance n'avait pas assez d'étain pour que le courant puisse passer.

Voici donc notre carte soudée:

Carte soudee2.jpg

Code arduino

// si le minuteur se décompte alors l'état vaut 1, 0 sinon
char etatMinuteur = 0;
// nombre de 0 à 959, les centaines sont les minutes, les dizaines sont les dizaines de secondes et les unités sont les secondes
int affichage = 0;
// variable qui permet de stocker le temps depuis une action précédente
unsigned long ancienTemps = 0;
// intervalle entre chaque décompte (1000 ms)
long intervalle = 1000;
//variable qui stocke le fait d'avoir appuyer ou non sur un minuteur (permet de faire une unique incrémentaion de la variable affichage par appui)
char prevSwitchState=0;
//variable allant de 0 à 2 indiquant quel transistor prendre en charge
char transis =0;
//Chiffre à afficher
char chiffre;
// tableau regroupant sous format d'octet les led à allumer sur les afficheurs pour former chaque chiffre (ex : tab[4] donne le chiffre 4
unsigned char tab[] = {0x37, 0x06, 0x63, 0x67, 0x56, 0x75, 0x7D, 0x07, 0x7F, 0x77 };

void setup() {
  // put your setup code here, to run once:
  //Les pins 9 à 11 sont ceux reliés aux transistors
  for( char pin= 9; pin<12; pin++){
    pinMode(pin,OUTPUT);
    digitalWrite(pin,HIGH);
  }
  //Les pins 1 à 7 sont ceux reliés aux afficheurs
  for( char pin=1; pin<8; pin++){
    pinMode(pin,OUTPUT);
    digitalWrite(pin,HIGH);
  }

}

void loop() {
  // put your main code here, to run repeatedly:
  //On stocke la tension de notre pont
  int valeurPont = analogRead(0);
  //Instruction qui s'effectue si le minuteur n'est pas en marche et qui s'effectue une fois par appuis de boutons 
  if (etatMinuteur==0 && prevSwitchState==0){
    //interprétation de la valeur du pont pour savoir sur quel bouton on a appuyé
    // ici on gère les minutes
    if (valeurPont >= 700 && valeurPont<= 750){
      if(affichage<900){
        affichage+=100;
      }
      //retour à 0 après 9
      else{
        affichage-=900;
      }
      prevSwitchState=1;
    }
    //gestion des secondes
    if(valeurPont>=800 && valeurPont<=850){
      //retour à 0 après 59
      if (affichage%100 == 59){
        affichage-=59;
      }
      else{
        affichage+=1;
      }
      prevSwitchState=1;
    }
    //mise en marche du minuteur
    if (valeurPont>=500 && valeurPont<=550){
      etatMinuteur+=1;
      etatMinuteur=etatMinuteur%2;
      ancienTemps = millis();
      prevSwitchState=1;
    }
  }
  else if(etatMinuteur==1 && prevSwitchState==0){
    unsigned long tempsActuel=millis();
    //On compare le temps actuel avec l'ancien temps stocké pour voir si on a depassé 1 seconde et agir en conséquence
    if(tempsActuel - ancienTemps > intervalle){
      ancienTemps = tempsActuel;
      if(affichage%100 == 0){
        affichage-=41;
      }
      else{
        affichage-=1;
      }
    }
    //mise en pause du minuteur
    if (valeurPont>=500 && valeurPont<=550){
      etatMinuteur+=1;
      etatMinuteur=etatMinuteur%2;
      ancienTemps = millis();
      prevSwitchState=1;
    }
    //si le décompte est fini le buzzer se met à bipper pendant 5 secondes
    if(affichage==0){
      etatMinuteur=0;
      for(char x = 0; x<10; x++){
        tone(8,440,250);
        delay(250);
      }
    }
    
  }
  //chiffre à afficher en fonction du transistor actuel
  switch(transis){
    case 2:
    //chiffre des dizaines de secondes
    chiffre = (affichage%100)/10;
    break;
    case 0:
    //chiffre des secondes
    chiffre = affichage%10;
    break;
    case 1:
    //chiffre des minutes
    chiffre = affichage/100;
    break;
  }
  transis= (transis+1)%3;
  //si la tension du pont est maximal alors aucun bouton n'a été pressé
  if(valeurPont >1000){
    prevSwitchState=0;
  }
  // On refait passer tous les pins à l'état high
  
  for( char pin= 9; pin<12; pin++){
    pinMode(pin,OUTPUT);
    digitalWrite(pin,HIGH);
  }
  
  for( char pin=1; pin<8; pin++){
    pinMode(pin,OUTPUT);
    digitalWrite(pin,HIGH);
  }
  
  //gestion des pin à allumer pour afficher le chiffre
  unsigned char decal= 0x01;
  for( char i = 1; i<8; i++){
    if ((tab[chiffre] & decal )>0){
      digitalWrite(i,LOW);
      digitalWrite(9+transis,LOW);
    }
    decal <<= 1;
    
  }
}

Clé finale

Fritzing

Pour réaliser notre Fritzing, nous avons pris le PCB et le Schematic de base qui était sur le wiki et nous avons dû rajouter d'autres composants tel que les 3 boutons, le buzzer et surtout les connecteurs qui permettent de raccorder le bouclier où se trouvent les afficheurs avec notre clé principale .

Schematic Clé finale PCB Clé finale


Soudure

Après avoir fini le PCB et reçu notre carte nous avons pris tous les composants qu'il nous fallait et nous avons commencé à souder. La clé comporte en plus un bouclier avec les afficheurs 7 segments.

Bouclier 7 segments
Carte













Code

Nous avons pu tester les mémoires de notre clé USB en passant par le terminal de l'ordinateur, nous avons pu vérifier si tout fonctionnait en observant la petite LED clignoter cinq fois, ce qui signifie que tout est bon. Fichier:Test memoire binome10.mp4

Chronologie

  • 18 Janvier

Idée principale: clé minuteur (2 afficheurs à led 7 segments, 2 boutons poussoirs, une led et un buzzer)

2 afficheurs pour aller de 0 à 99 secondes (à voir pour en rajouter un 3eme et couvrir le temps de 0 à 10 min)

1 bouton pour les dizaines de secondes et 1 bouton pour les unités

réfléchir pour mettre en pause et lancer le minuteur


  • 21 Janvier

Lors de cette séance, nous nous sommes documentés sur comment fonctionne un microprocsseur et un afficheur 7 segments. Nous voulions commencer le "Schematic" sur l'outil Fritzing mais nous ne savons pas qu'elle était la référence de l'afficheur. Après avoir vu le matériel dont disponait Polytech, nous avons convenu avec les professeurs et 2 autres groupes qui utilisent aussi l'afficheur 7 segments que nous partions sur 3 afficheurs 7 segments car ayant pas assez d'afficheurs pour tout le monde.

M. Redon et M. Boé nous ont donc proposé de faire une carte externe qui contiendra les afficheurs, que nous pourrions connecter à chacune des cartes contenant le programme de la clé ( dans notre cas: nous connecterons la carte d'afficheur sur notre carte "minuteur")

Ce "problème" nous a permis d'en savoir plus sur l'afficheur 7 segments:

Afficheur 7 segments.jpg


référence



Celui-ci est composé de 5 connections de chaque coté, cet afficheur est un afficheur à anode commune (3 et 8)


La carte "afficheurs" va être composée 5 broches en haut ( respectivement Afficheur 1 / Afficheur 2 / Afficheur 3 / +5V / GND ) et de 8 broches en bas (respectivement A / B / C / D / E / F / G / DP) La distance entre les deux lignes de broche est de 12 broches (voir capture écran Fritzing)

Les afficheurs auront 3 transistors (pour les Afficheurs) et 8 résistances (pour les lettres A,B,..,DP)

  • 25 Janvier

Suite de la réalisation du dé électronique sur Fritzing. Nous pensions qu'il fallait aussi incorporer les éléments qui seront présents sur la carte secondaire mais en fait il suffit juste de représenter les connecteurs présents sur cette dernière. Nous nous étions alors renseigné sur le fonctionnement d'un transistor et nous avons remarqué qu'il en existait 2 sortes, les PNP et les NPN, la différence entre les deux correspond au fait que pour les PNP le courant va de l'émetteur vers la base et le collecteur est relié au GND tandis que pour un NPN le courant va de la base vers l'émetteur et le collecteur est relié à l'alimentation.



AtTiny84

De plus pour ce premier dé électronique nous utiliserons l'ATTiny84 comme micro-controleur. Ce dernier possède 14 broches, les broches 1 et 14 sont respectivement l'alimentation et la masse. Il faut donc utiliser les 12 autres broches pour contrôler nos composants électroniques. Cependant nous avons besoin de 3 broches pour les transistors, 8 broches pour les led des afficheurs (7 segments + le point) mais aussi 3 broches pour les boutons ( et possiblement une supplémentaire pour rajouter un buzzer et/ou une led pour indiquer la fin du minuteur). la solution : sacrifier l'affichage du point et l'utilisation de 2 boutons au lieu de 3.










  • 28 Janvier

Nous avons opté pour un pont de résistance pour notre carte ce qui nous permet de garder un 3e bouton et un buzzer pour la fin du minuteur.

Nous avons également réalisé le Schematic et le PCB.

Circuit imprime minuteur.pngSchematic minuteur.png


  • 1er Février

Impression du circuit et début de recherche d'un programme.

Carte imprime .jpg

  • 4 Février

Découverte de la soudure sur la carte, nous avons commencé le programme


  • 8 Février

Nous avons finis de souder la carte et nous avons testé notre carte avec un Arduino UNO pour voir si notre carte fonctionnait.

Carte soudee2.jpg


  • 11 Février

Nous avons fait vérifier notre programme. Nous n'avons pas pour l'instant d'afficheurs donc nous allons créer un mini programme pour tester si nos boutons fonctionnent.

  • 15 Février

Nous avons commencé à faire le "Schematic" de la clé usb

  • 18 Février


  • 11 Mars

Lors de cette séance on a continuer le PCB de la clé usb final. Pour cela on a du déplacer certains éléments pour pouvoir faire passer le connexions de plus on manquera de place du coup on va devoir agrandir notre PCB . Sinon toutes les connexions ont été réalisées, il suffit juste de les rendre un peu plus belle et agrandir la surface du PCB

Média:Cle_binome10.zip


  • 15 Mars

Lors de cette séance nous avons réarranger les fils pour pas qu'ils se chevauchent, nous avons commencé a faire le nouveau PCB car notre carte dépasse par rapport aux PCB de base à cause des afficheurs.

  • 18 Mars

Pendant cette séance nous avons remarqué que des defauts de fils qui se chevauchent n'avaient pas été vu par le logiciel lundi dernier, nous avons donc fini de bien placer les fils dans le PCB et nous avons arrangés les noms des pièces pour que ces noms soient gravés sur la carte. De plus, nous nous sommes rendu compte que l'ICSP n'était pas conforme à celui que nous avions de base, un via était relié à la fois au GND et à la fois au RTN. Nous avons réussi a régler ce problème et a bien refaire apparaître le ICSP sur notre carte

Voici le PCB fini :

Média:cle_binome10_fini.zip


  • 22 Mars

Pendant cette séance, nous avons le socle pour la pile sur la nouvelle carte. Nous avons essayé de faire un programme pour savoir quel pin allume quel segment de l'afficheur.

  • 25 Mars

utiliser seulement la premiere memoire pour l'initalisation , recevoir des blocs de 512 octets mais on peut les stocker que dans des blocs de 256 adapter les programmes read et write 2bloxkadress+2i pour aller dans le 1er bloc

2blockadress +2i+1 pour aller dans le 2 eme bloc

  • Carte (re)commandée

La carte a été modifiée pour intégrer un connecteur ICSP classique plus facile à utiliser pour la programmation de l'ATMega16u2. Le nouveau fichier Fritzing : Fichier:2021ClefLucasEstelle.zip.

  • Carte et programmation

La carte a été testée sans mémoire mais avec un bouclier 7 segments.

Une erreur de conception : le bouclier est alimenté en 5V (USB) alors qu'il devait l'être en 3,3V (régulateur). Une piste a été coupée et un fil soudé sur les cartes de test.

Le bouclier fonctionne avec le projet C ci-joint : Fichier:2021EstelleLucas7Seg.zip.


  • 29 Mars

Nous avons fini le pcb de la carte et nous l'avons envoyé pour la conception

  • 1er Avril

Pendant cette séance, Nous avons reçu notre premier clé et nous avons commencé à souder les composants de celle ci

  • 8 Avril

Durant cette séance nous avons continué à souder les composants sur une des clés et nous avons continué la programmation des mémoires de la clé

  • 12 Avril

Durant cette séance nous avons soudé les deux mémoires sur une des clés et nous avons continué la programmation du minuteur et des memoires de la clé

  • 15 Avril
  • 19 Avril

On a enfin fini le code pour gérer la fonctionnalité minuteur de notre clé usb. Les différents fichier le composant sont disponible dans le zip ci joint.

Fichier:Bouclier7Seg fini.zip

On devait surement avoir une erreur de sauvegarde des fichiers ce qui empêchait leurs actualisations avant l'upload sur l'atmega. De plus on a aussi augmenté le TIMEOUT pour que la décrémentation du compteur se fasse bien pour chaque seconde et non plus rapidement. On a aussi empêché la décrémentation du compteur lorsque ce dernier arrive à 0, en effet il repassait auparavant à 999 après 0 et tournait donc en boucle tant que l'on n'appuyait pas sur le bouton pour l'arrêter.

Pour la prochaine séance il faut que l'on s'intéresse à l'aspect usb de notre clé et réussir à combiner cet aspect avec notre fonctionnalité minuteur.


  • 22 Avril

Pendant cette séance nous avons soudé 2 autres mémoires sur la 2ème carte et nous avons testé si les mémoires de la clé fonctionnent grâce aux codes situés dans le wiki du BE .