Binome2020-5 : Différence entre versions

De Wiki de bureau d'études PeiP
(Carte Finalisée)
(Journal de la réalisation de la clé USB)
 
(165 révisions intermédiaires par 2 utilisateurs non affichées)
Ligne 1 : Ligne 1 :
 
=<div class="mcwiki-header" style="border-radius: 15px; padding: 15px; font-weight: bold; color: #FFFFFF; text-align: center; font-size: 80%; background: #0000FF; vertical-align: top; width: 98%;">Introduction </div>=
 
=<div class="mcwiki-header" style="border-radius: 15px; padding: 15px; font-weight: bold; color: #FFFFFF; text-align: center; font-size: 80%; background: #0000FF; vertical-align: top; width: 98%;">Introduction </div>=
  
Dans ce bureau d'étude, nous souhaitons réaliser une Clé USB de A à Z , en créant le circuit électronique , soudant les composants et programmant le micro-contrôleurs, avec l'ajout d'une option qui rendra cette clé USB unique.  
+
Dans ce bureau d'étude, nous souhaitons réaliser une Clé USB de A à Z , en créant le circuit électronique, soudant les composants et programmant le micro-contrôleur, avec l'ajout d'une option qui rendra cette clé USB unique.  
  
Après plusieurs pistes étudiées , nous avons décider d'intégrer à un boitier pratique, trois afficheurs 7 segments affichant la capacité restante sur la clé USB en pourcentage. Nous refléchissons également à un nom pour cette regle de poche que l'on pourrait graver sur le boitier en plus de la capacité totale de la clé.  
+
Après plusieurs pistes étudiées , nous avons décidé d'intégrer à un boitier pratique, trois afficheurs 7 segments affichant la capacité restante sur la clé USB en pourcentage. Nous refléchissons également à un nom pour cette règle de poche que l'on pourra graver sur le boitier en plus de la capacité totale de la clé.  
  
 
Afin de s'initier à toutes ces nouvelles expériences, nous allons commencer par réaliser un projet intermédiaire contenant notre option avant de s'attaquer à la clé USB.
 
Afin de s'initier à toutes ces nouvelles expériences, nous allons commencer par réaliser un projet intermédiaire contenant notre option avant de s'attaquer à la clé USB.
Ligne 9 : Ligne 9 :
 
=<div class="mcwiki-header" style="border-radius: 15px; padding: 15px; font-weight: bold; color: #FFFFFF; text-align: center; font-size: 80%; background: #0000FF; vertical-align: top; width: 98%;">Réalisation de l'option </div>=
 
=<div class="mcwiki-header" style="border-radius: 15px; padding: 15px; font-weight: bold; color: #FFFFFF; text-align: center; font-size: 80%; background: #0000FF; vertical-align: top; width: 98%;">Réalisation de l'option </div>=
  
Tous d'abord nous allons réaliser un projet intermédiaire nous permettant de réaliser notre option.  
+
Tous d'abord nous allons réalisé un projet intermédiaire nous permettant de réaliser notre option.  
  
 
Pour cela , nous avons crée un circuit électronique nous permettant de contrôler 3 afficheurs 7 segments afin d'afficher un chiffre préalablement défini.
 
Pour cela , nous avons crée un circuit électronique nous permettant de contrôler 3 afficheurs 7 segments afin d'afficher un chiffre préalablement défini.
Ligne 15 : Ligne 15 :
 
==Choix des composants==
 
==Choix des composants==
  
Dans un premier temps, nous avons commencer par chercher et lire les datasheet des composants utiles à la réalisation de notre option :
+
Dans un premier temps, nous avons commencé par chercher et lire les datasheet des composants utiles à la réalisation de notre option :
  
* Un micro-contrôleur Attiny84
+
* Un micro-contrôleur ATMEGA8U2 (pour la réalisation de l'option utilisation de l'Attiny84)
 
* Une batterie
 
* Une batterie
 
* Des pins  
 
* Des pins  
Ligne 23 : Ligne 23 :
 
* 8  Résistances
 
* 8  Résistances
 
* 3 Transistors
 
* 3 Transistors
 +
 +
<div style='display:flex; justify-content:space-around; align-items:right; flex-flow:row nowrap;'>[[File:ATMEGAU2.jpg|thumb|125px]]  [[File:afficheur.jpg|thumb|125px]] </div>
 +
 +
<br style="clear:both;"/>
  
 
== Élaboration du PCB et du schématique sous fritzing==
 
== Élaboration du PCB et du schématique sous fritzing==
Ligne 36 : Ligne 40 :
 
* Essayer de mettre un maximum sur la même face de la carte.
 
* Essayer de mettre un maximum sur la même face de la carte.
  
* Ne pas faire d'angles droit.
+
* Ne pas faire d'angle droit.
  
 
* "Sortir droit au niveau des broches".
 
* "Sortir droit au niveau des broches".
Ligne 51 : Ligne 55 :
  
 
Après l'avoir rooter, nous avons fait la demande de génération de la carte sur le site de l'école : eei.polytech-lille.net
 
Après l'avoir rooter, nous avons fait la demande de génération de la carte sur le site de l'école : eei.polytech-lille.net
 +
 +
[[File:PCBOption.png|thumb|center|300px]]
  
 
04/02: Soudage  
 
04/02: Soudage  
  
Nous avons récupérer les différents composants (pins, micro-controleur, batterie) ainsi que la carte éléctronique et effectuer le soudage de tous ces composants sur celle-ci.
+
Nous avons récupéré les différents composants (pins, micro-contrôleur, batterie) ainsi que la carte électronique et effectué le soudage de tous ces composants sur celle-ci.
 +
 
 +
[[File:carte.jpg|thumb|left|250px]]
 +
Carte contenant le micro-contrôleur, l'alimentation auxiliaire et les pins
 +
 
 +
de connexion à la seconde carte.
 +
 
 +
*Lien fritzing PCB carte avec le micro-contrôleur et l'alimentation externe pour notre option:
 +
[[Fichier:PCB_option.zip]]
 +
 
 +
<br style="clear:both;"/>
  
 
== Code Arduino ==  
 
== Code Arduino ==  
Ligne 60 : Ligne 76 :
 
08/02: Prise en main d'Arduino  
 
08/02: Prise en main d'Arduino  
  
Nous avons configuré les paramètres Arduino pour qu'il reconnaisse et que l'on puisse commander notre micro-contrôleur. Puis nous avons commencé la résolution du code nous permettant d'afficher un nombre préalablement défini sur nos 3 afficheurs.
+
Nous avons configuré les paramètres Arduino pour qu'il reconnaisse et que l'on puisse commander notre micro-contrôleur. Puis nous avons commencé la réalisation du code nous permettant d'afficher un nombre préalablement défini sur nos 3 afficheurs.
  
 
11/02:  
 
11/02:  
Ligne 72 : Ligne 88 :
 
08/03 :
 
08/03 :
  
Suite a des problemes pour allumer les 3 afficheurs en meme temps, nous avons ré-écrit le tableau liant les LED et le controle des afficheurs a leur pins respectifs:
+
Suite à des problèmes pour allumer les 3 afficheurs en même temps, nous avons ré-écrit le tableau liant les LED à leur pins respectifs sur le micro-contrôleur :
 +
 
 +
[[File:attiny_datasheet.jpg|thumb|right|5000px]]
 +
[[File:afficheurs.jpg|thumb|right|150px]]
  
 
{| class="wikitable"
 
{| class="wikitable"
Ligne 112 : Ligne 131 :
 
|}
 
|}
  
Suite a cela, nous avons developpé un code afin de verifier le bon fonctionnement de la carte "affichage":
+
Suite à cela, nous avons devellopé un code afin de vérifier le bon fonctionnement de la carte "affichage":
  
  
  
unsigned char c0[8]={0,0,0,0,0,0,1,1}; //LED = {a,b,c,d,e,f,g,dp} c0[8][0]=0
+
  unsigned char c0[8]={0,0,0,0,0,0,1,1}; //LED = {a,b,c,d,e,f,g,dp} c0[8][0]=0
unsigned char c1[8]={1,0,0,1,1,1,1,1};
+
  unsigned char c1[8]={1,0,0,1,1,1,1,1};
unsigned char c2[8]={0,0,1,0,0,1,0,1};
+
  unsigned char c2[8]={0,0,1,0,0,1,0,1};
unsigned char c3[8]={0,0,0,0,1,1,0,1};
+
  unsigned char c3[8]={0,0,0,0,1,1,0,1};
unsigned char c4[8]={1,0,0,1,1,0,0,1};
+
  unsigned char c4[8]={1,0,0,1,1,0,0,1};
unsigned char c5[8]={0,1,0,0,1,0,0,1};
+
  unsigned char c5[8]={0,1,0,0,1,0,0,1};
unsigned char c6[8]={0,1,0,0,0,0,0,1};
+
  unsigned char c6[8]={0,1,0,0,0,0,0,1};
unsigned char c7[8]={0,0,0,1,1,1,0,1};
+
  unsigned char c7[8]={0,0,0,1,1,1,0,1};
unsigned char c8[8]={0,0,0,0,0,0,0,1};
+
  unsigned char c8[8]={0,0,0,0,0,0,0,1};
unsigned char c9[8]={0,0,0,0,1,0,0,1};
+
  unsigned char c9[8]={0,0,0,0,1,0,0,1};
const byte PIN_SEGMENT_A = 3;  
+
  const byte PIN_SEGMENT_A = 3;  
const byte PIN_SEGMENT_B = 4;
+
  const byte PIN_SEGMENT_B = 4;
const byte PIN_SEGMENT_C = 5;
+
  const byte PIN_SEGMENT_C = 5;
const byte PIN_SEGMENT_D = 11;
+
  const byte PIN_SEGMENT_D = 11;
const byte PIN_SEGMENT_E = 9;
+
  const byte PIN_SEGMENT_E = 9;
const byte PIN_SEGMENT_F = 7;
+
  const byte PIN_SEGMENT_F = 7;
const byte PIN_SEGMENT_G = 8;
+
  const byte PIN_SEGMENT_G = 8;
const byte PIN_SEGMENT_DP = 6;
+
  const byte PIN_SEGMENT_DP = 6;
const byte PIN_CONTROL_1 = 0;
+
  const byte PIN_CONTROL_1 = 0;
const byte PIN_CONTROL_2 = 1;
+
  const byte PIN_CONTROL_2 = 1;
const byte PIN_CONTROL_3 = 2;
+
  const byte PIN_CONTROL_3 = 2;
#define NB_LEDS 8
+
  #define NB_LEDS 8
#define NB_TR  3
+
  #define NB_TR  3
int LEDpins[]={PIN_SEGMENT_A,PIN_SEGMENT_B,PIN_SEGMENT_C,PIN_SEGMENT_D,PIN_SEGMENT_E,PIN_SEGMENT_F,PIN_SEGMENT_G,PIN_SEGMENT_DP};
+
  int LEDpins[]={PIN_SEGMENT_A,PIN_SEGMENT_B,PIN_SEGMENT_C,PIN_SEGMENT_D,PIN_SEGMENT_E,PIN_SEGMENT_F,PIN_SEGMENT_G,PIN_SEGMENT_DP};
int TRpins[]={PIN_CONTROL_1,PIN_CONTROL_2,PIN_CONTROL_3};
+
  int TRpins[]={PIN_CONTROL_1,PIN_CONTROL_2,PIN_CONTROL_3};
unsigned char *p;
+
  unsigned char *p;
void setup() {
+
  void setup() {
  int i;
+
    int i;
  for(i=0;i<NB_LEDS;i++){  
+
    for(i=0;i<NB_LEDS;i++){  
    pinMode(LEDpins[i], OUTPUT);
+
      pinMode(LEDpins[i], OUTPUT);
    digitalWrite(LEDpins[i], HIGH);
+
      digitalWrite(LEDpins[i], HIGH);
  }
+
    }
  for(i=0;i<NB_TR;i++){  
+
    for(i=0;i<NB_TR;i++){  
    pinMode(TRpins[i], OUTPUT);
+
      pinMode(TRpins[i], OUTPUT);
    digitalWrite(TRpins[i], HIGH);
+
      digitalWrite(TRpins[i], HIGH);
 +
    }
 +
    p=c0;
 
   }
 
   }
   p=c0;
+
   void loop() {
}
+
    for(int i = 0;i<NB_TR;i++)
void loop() {
+
    {
  for(int i = 0;i<NB_TR;i++)
+
      for(int a=0;a<NB_LEDS;a++){
  {
+
          digitalWrite(LEDpins[a],p[a]);
    for(int a=0;a<NB_LEDS;a++){
+
      }
        digitalWrite(LEDpins[a],p[a]);
+
      digitalWrite(TRpins[i], LOW);
    }
+
      delay(1);
    digitalWrite(TRpins[i], LOW);
+
      digitalWrite(TRpins[i], HIGH);
    delay(1);
+
    }
    digitalWrite(TRpins[i], HIGH);
 
 
   }
 
   }
}
 
  
 
== Carte Finalisée==
 
== Carte Finalisée==
  
[[File:carte.jpg|thumb|center|300px]]
+
[[File:carte_test.jpg|thumb|left|250px]]  
 +
Test d'affichage : comme on peut le voir, les 3 afficheurs s'allument et affichent ici trois zéro. En essayant d'afficher différents chiffres on s'est rendu compte que la LED D ne s'allumait jamais . Après avoir effectuer des recherches, on s'est rendu compte que on avait connecté cette LED à la broche 4 du micro-contrôleur, qui correspond à la broche reset qui ne peut donc pas contrôler/allumer la LED.
 +
 
 +
 
 +
 
 +
 
 +
 
 +
 
 +
 
 +
 
 +
 
 +
 
 +
 
 +
 
 +
 
 +
 
 +
 
  
[[File:carte_finalise.jpg|thumb|center|300px]]
 
  
=<div class="mcwiki-header" style="border-radius: 15px; padding: 15px; font-weight: bold; color: #FFFFFF; text-align: center; font-size: 80%; background: #0000FF; vertical-align: top; width: 98%;">Clé USB</div>=
 
  
  
  
 +
[[File:carte_finalise.jpg|thumb|left|250px]]
  
Comme exemple de boitier pratique, nous avons pensé a une mini regle que l'on pourrait par exemple attaché a un porte clé.
+
Carte de test de notre fonction supplémentaire avec la carte de contrôle
  
18/01: Nous avons eu comme idée d'integrer a un boitier pratique, un ecran LCD affichant la capacité restante sur la clé USB ou le temps de connexion par exemple. Comme exemple de boitier pratique, nous avons pensé a une mini regle que l'on pourrait par exemple attaché a un porte clé. Nous pensions afficher la capacité en pourcentage grace a un ecran OLED. Un code de verrouillage est envisageable si nous avons le temps pour le developper.
+
et la carte d'affichage. Nous avons pu la tester grâce au code ci dessus
  
Nous réflechissons a un nom pour cette regle de poche ainsi qu'a l'integration d'une petite cellule solaire afin de pouvoir mesurer la capacité meme quand la clé n'est pas branchée ou le remplacement de l'ecran OLED par un ecran E-Ink pour eviter d'avoir affaire a de l'alimentation auxiliaire
+
et cela fonctionne.
  
21/01:
 
Nous avons opté pour 3 afficheurs 7 segements pour afficher la capacité de la clé : https://www.mouser.fr/ProductDetail/Lite-On/LTS-4817CTB-P/?qs=%2Fha2pyFadujuQkQs814dann6mHMAjWb%252BHwSLzlJP83YAn7tUKhlEhg%3D%3D
 
Nous aurons donc besoin d'un microcontroleur secondaire :
 
  
25/01:
+
<br style="clear:both;"/>
Nous avons realisé un PCB de notre fonction supplementaire sur FRITZING
 
  
28/01:
+
=<div class="mcwiki-header" style="border-radius: 15px; padding: 15px; font-weight: bold; color: #FFFFFF; text-align: center; font-size: 80%; background: #0000FF; vertical-align: top; width: 98%;">Journal de la réalisation de la clé USB</div>=
Nous pensons remplacer la cellule solaire par une pile
 
  
01/02:
+
08/03:
Nous avons amelioré notre PCB en le rendant plus compact et en le faisant passer que par une seule des deux faces de la carte
+
Réalisation de la forme du PCB final de notre clé USB sous Inkscape. Pour ce faire, nous avons séparé les deux layers qui composaient le fichier de la forme de la clé, puis nous les avons modifié (silkscreen en dernier) pour s'adapter a notre fonction supplémentaire.
Lancement de l'impression de la carte.
+
[[File:clef_PCB_F.png|thumb|center|150px]]
  
 
11/03:
 
11/03:
Nous avons intégré notre fonction sur le fichier Fritzing de la clé USB. Nous avons realisé ces deux solutions probables suivantes:
 
  
- Sans modification des composants :[[Fichier:Cle_usb_sm.zip]]
+
Nous avons intégré notre fonction sur le fichier Fritzing de la clé USB. Nous avons réalisé ces deux solutions probables suivantes:
 +
 
 +
* Sans modification des composants :[[Fichier:Cle_usb_sm.zip]]
 +
* Avec modification des composants :[[Fichier:CUSB_Chloe_Thomas.zip]]
 +
* Solution proposée par ReX : [[Fichier:ClefChloeThomas2021.zip]]
 +
 
 +
<div style='display:flex; justify-content:space-around; align-items:center; flex-flow:row nowrap;'>[[File:Schematic_CleUSB.png|thumb|250px]]  [[File:PCB_CleUSB.png|thumb|250px]] </div>
 +
 
 +
Les séries de pins en haut et en bas servent à connecter la carte de la clé avec une autre carte (nommée bouclier) qui elle assurera la partie affichage, tandis que la carte en-dessous sera la clé USB avec la partie mémoire et contrôle.
 +
 
 +
<div style='display:flex; justify-content:space-around; align-items:center; flex-flow:row nowrap;'>[[File:bouclierAv.jpg|thumb|center|250px]]
 +
[[File:bouclierAr.jpg|thumb|center|250px]] </div>
 +
 
 +
Chaque afficheur est contrôlé grâce à un transistor. On a relié chaque cathode de LED A des trois afficheurs entre elles, le tout connecté à une résistance. On a fait pareil pour les LED B,C,D,E...
 +
 
 +
15/03:
 +
 +
Nous avons regardé au PCB ainsi que au schématique réalisé sous Fritzing par M.Redon.
 +
Après avoir regarder à celui-ci nous avons commencé à lire et essayer de comprendre le programme pour la Clé USB.
 +
 
 +
18/03:
 +
 
 +
Nous avons poursuivi notre travail de compréhension sur le programme et ajouter les quelques lignes manquantes.
 +
 
 +
22/03:
 +
 
 +
Nous avons commencer à modifier le fichier d'écriture et de lecture de la memoire de la clé USB : [[Fichier:*DataFlashManager.zip]] et commencer le soudage de la première clé.
 +
 
 +
Pour commencer, nous soudons uniquement les composants nécessaire à la partie micro-contrôleur.
 +
 
 +
'''Photos de la clé USB avec soudure de la partie micro-contrôleur et mémoire''':
 +
<div style='display:flex; justify-content:space-around; align-items:center; flex-flow:row nowrap;'> [[File:CleUSBSoudeeAV.jpg|thumb|250px]][[File:CleUSBSoudeeAR.jpg|thumb|250px]]</div>
 +
 
 +
25/03 et 29/03:
 +
 
 +
Test des mémoires sur la premiere clé fonctionnelle :
 +
* TestMemRW [[Fichier: TestMemRW.zip]]
 +
* TestmemRW2[[Fichier:TestmemRW2.zip]]
 +
 
 +
Ces deux tests fonctionnent sur la clé USB.
 +
 
 +
01/04 et 08/04:
 +
 
 +
Test du code pour contrôler les afficheurs afin d'afficher un compteur.
 +
Code: [[Fichier:Bouclier7seg.zip]]
 +
 
 +
 
 +
Soudure des différents composants sur la deuxieme clé.
 +
 
 +
<br style="clear:both;"/>
 +
 
 +
12/04:
 +
 
 +
Test en fin de séance du bouclier d’affichage. Problème sur les chiffres qui ne s’affichent pas comme il le faudrait. Nous pensons donc qu’il y a un problème concernant l’affectation des pins aux LEDs des différents afficheurs dans le fichier nommé « card_io.h »
 +
 
 +
15/04:
 +
 
 +
Nous avons eu beaucoup de mal pour faire détecter la clé USB par l’ordinateur. Lorsque l’on tape la commande lsusb dans le terminal de commande, nous n’obtenions pas la ligne suivante: '''Bus 001 Device 064: ID 03eb:2ffa Atmel Corp. at90usb162 DFU bootloader
 +
'''
 +
 
 +
Nous sommes tout de meme parvenu a la faire détecter plus souvent et avons résolu le problème des afficheurs qui affichent correctement les différents chiffres: Nous avons modifié les valeurs hexadécimales correspondant aux pins de l’ATMega ou nous avions relié chacune des LED et avons également rectifié une erreur sur la valeur hexadécimale des ports de sorties. Nous avons donc les valeurs suivantes:
 +
 
 +
'''Ports de sorties:'''
 +
#define OUTPUT_PORTB 0x80
 +
#define OUTPUT_PORTC 0x74
 +
#define OUTPUT_PORTD 0xFE
 +
 
 +
'''LEDS:'''
 +
uint32_t leds[MAX_LED]={
 +
  0x00400000,
 +
  0x00000080, 0x00000040, 0x00000020, 0x00000002,
 +
  0x00000400, 0x00000008, 0x00000004, 0x00000010
 +
  };
 +
 
 +
'''Afficheurs:'''
 +
uint32_t displays[MAX_DISPLAY]={
 +
  0x00001000, 0x00002000, 0x00800000
 +
  };
 +
 
 +
Il nous reste donc à programmer notre fonction supplémentaire, l’affichage de la capacité de la clé.
 +
 
 +
19/04:
 +
 
 +
Nous avons modifié le fichier DataFlashManager.c afin de prendre en compte les modifications faites par Mr.Redon. Nous avons également ajouté le refresh des afficheurs dans le code mis sur la clé USB mais aucun afficheur ne s’allume, laissant présager un problème de ce côté la. Comme point positif, l’ordinateur reconnaît maintenant notre clé comme un device de « LUFA Mass Storage »
 +
 
 +
22/04:
 +
 
 +
Nous avons programmé les deux clés USB afin de pouvoir écrire, lire et stocker et que nos afficheurs affichent 000.
 +
Finalement nous avons tenté de modifier notre programme afin que les afficheurs affichent un compteur pour commencer avant d'essayer d'afficher la capacité comme voulu initialement.
 +
Nous n'avons malheureusement pas eu le temps de finir et nous avons tenté de finir chez nous mais aucun de nous étant sous Linux nous avons pas réussi à programmer nos clés avec nos nouveaux codes.
 +
 
 +
=<div class="mcwiki-header" style="border-radius: 15px; padding: 15px; font-weight: bold; color: #FFFFFF; text-align: center; font-size: 80%; background: #0000FF; vertical-align: top; width: 98%;">Clé USB finale</div>=
 +
 
 +
==Clé soudée et assemblée avec le bouclier==
 +
 
 +
<div style='display:flex; justify-content:space-around; align-items:center; flex-flow:row nowrap;'> [[File:CleUSBbouclier.jpg|thumb|250px]][[File:Assemblage.jpg|thumb|250px]]</div>
 +
 
 +
== Code==
 +
 
 +
Code dans nos clés à ce jour:[[Fichier:MassStoragePeiPF.zip]]
 +
 
 +
==Rendu final==
  
- Avec modification des composants :[[Fichier:CUSB_Chloe_Thomas.zip]]
+
A la fin de ces séances de BE, nous avons une clé fonctionnelle même si elle n'affiche pas exactement ce que l'on souhaitait au départ.
 +
Nous sommes ravis d'avoir pu suivre vos cours et réaliser cela.
  
- Solution proposée par ReX : [[Fichier:ClefChloeThomas2021.zip]]
+
Vidéo de notre clé en cours d'utilisation :[[Fichier:CleUSB.mp4]]

Version actuelle datée du 24 mai 2021 à 14:45

Introduction

Dans ce bureau d'étude, nous souhaitons réaliser une Clé USB de A à Z , en créant le circuit électronique, soudant les composants et programmant le micro-contrôleur, avec l'ajout d'une option qui rendra cette clé USB unique.

Après plusieurs pistes étudiées , nous avons décidé d'intégrer à un boitier pratique, trois afficheurs 7 segments affichant la capacité restante sur la clé USB en pourcentage. Nous refléchissons également à un nom pour cette règle de poche que l'on pourra graver sur le boitier en plus de la capacité totale de la clé.

Afin de s'initier à toutes ces nouvelles expériences, nous allons commencer par réaliser un projet intermédiaire contenant notre option avant de s'attaquer à la clé USB.

Réalisation de l'option

Tous d'abord nous allons réalisé un projet intermédiaire nous permettant de réaliser notre option.

Pour cela , nous avons crée un circuit électronique nous permettant de contrôler 3 afficheurs 7 segments afin d'afficher un chiffre préalablement défini.

Choix des composants

Dans un premier temps, nous avons commencé par chercher et lire les datasheet des composants utiles à la réalisation de notre option :

  • Un micro-contrôleur ATMEGA8U2 (pour la réalisation de l'option utilisation de l'Attiny84)
  • Une batterie
  • Des pins
  • 3 afficheurs 7 segments
  • 8 Résistances
  • 3 Transistors
ATMEGAU2.jpg
Afficheur.jpg


Élaboration du PCB et du schématique sous fritzing

25/01: Prise en main du logiciel Fritzing.

Nous avons découvert le logiciel ainsi que les règles de réalisation utiles à la réalisation d'un PCB.

Quelques règles:

  • Ne jamais se faire croiser des fils.
  • Essayer de mettre un maximum sur la même face de la carte.
  • Ne pas faire d'angle droit.
  • "Sortir droit au niveau des broches".

27/01: Avancement du PCB.

Nous avons commencé par réaliser la totalité du PCB avec tous les composants (transistors, résistances, afficheurs, micro-contrôleur, pile,...)

Finalement, nous avons supprimé la partie "affichage" de notre carte car elle sera transferée sur une autre carte que nous pourrons emboiter par dessus.

01/02:

Nous avons terminé la réalisation de notre PCB , la mise en forme du schématique.

Après l'avoir rooter, nous avons fait la demande de génération de la carte sur le site de l'école : eei.polytech-lille.net

PCBOption.png

04/02: Soudage

Nous avons récupéré les différents composants (pins, micro-contrôleur, batterie) ainsi que la carte électronique et effectué le soudage de tous ces composants sur celle-ci.

Carte.jpg

Carte contenant le micro-contrôleur, l'alimentation auxiliaire et les pins

de connexion à la seconde carte.

  • Lien fritzing PCB carte avec le micro-contrôleur et l'alimentation externe pour notre option:

Fichier:PCB option.zip


Code Arduino

08/02: Prise en main d'Arduino

Nous avons configuré les paramètres Arduino pour qu'il reconnaisse et que l'on puisse commander notre micro-contrôleur. Puis nous avons commencé la réalisation du code nous permettant d'afficher un nombre préalablement défini sur nos 3 afficheurs.

11/02:

Poursuite du code

18/02:

Test de notre code après l'avoir transféré sur le micro-contrôleur. Problème: impossible d'allumer la LED D des afficheurs car on l'a lié à la pin 4 du micro-contrôleur qui est la pin reset.

08/03 :

Suite à des problèmes pour allumer les 3 afficheurs en même temps, nous avons ré-écrit le tableau liant les LED à leur pins respectifs sur le micro-contrôleur :

Attiny datasheet.jpg
Afficheurs.jpg
Numero du Pin Fonction
0 Afficheur 1
1 Afficheur 2
2 Afficheur 3
3 LED A
4 LED B
5 LED C
6 LED DP
7 LED F
8 LED G
9 LED E
11 LED D

Suite à cela, nous avons devellopé un code afin de vérifier le bon fonctionnement de la carte "affichage":


 unsigned char c0[8]={0,0,0,0,0,0,1,1}; //LED = {a,b,c,d,e,f,g,dp} c0[8][0]=0
 unsigned char c1[8]={1,0,0,1,1,1,1,1};
 unsigned char c2[8]={0,0,1,0,0,1,0,1};
 unsigned char c3[8]={0,0,0,0,1,1,0,1};
 unsigned char c4[8]={1,0,0,1,1,0,0,1};
 unsigned char c5[8]={0,1,0,0,1,0,0,1};
 unsigned char c6[8]={0,1,0,0,0,0,0,1};
 unsigned char c7[8]={0,0,0,1,1,1,0,1};
 unsigned char c8[8]={0,0,0,0,0,0,0,1};
 unsigned char c9[8]={0,0,0,0,1,0,0,1};
 const byte PIN_SEGMENT_A = 3; 
 const byte PIN_SEGMENT_B = 4;
 const byte PIN_SEGMENT_C = 5;
 const byte PIN_SEGMENT_D = 11;
 const byte PIN_SEGMENT_E = 9;
 const byte PIN_SEGMENT_F = 7;
 const byte PIN_SEGMENT_G = 8;
 const byte PIN_SEGMENT_DP = 6;
 const byte PIN_CONTROL_1 = 0;
 const byte PIN_CONTROL_2 = 1;
 const byte PIN_CONTROL_3 = 2;
 #define NB_LEDS 8
 #define NB_TR   3
 int LEDpins[]={PIN_SEGMENT_A,PIN_SEGMENT_B,PIN_SEGMENT_C,PIN_SEGMENT_D,PIN_SEGMENT_E,PIN_SEGMENT_F,PIN_SEGMENT_G,PIN_SEGMENT_DP};
 int TRpins[]={PIN_CONTROL_1,PIN_CONTROL_2,PIN_CONTROL_3};
 unsigned char *p;
 void setup() {
   int i;
   for(i=0;i<NB_LEDS;i++){ 
     pinMode(LEDpins[i], OUTPUT);
     digitalWrite(LEDpins[i], HIGH);
   }
   for(i=0;i<NB_TR;i++){ 
     pinMode(TRpins[i], OUTPUT);
     digitalWrite(TRpins[i], HIGH);
   }
   p=c0;
 }
 void loop() {
   for(int i = 0;i<NB_TR;i++)
   {
      for(int a=0;a<NB_LEDS;a++){
         digitalWrite(LEDpins[a],p[a]);
      }
      digitalWrite(TRpins[i], LOW);
      delay(1);
      digitalWrite(TRpins[i], HIGH);
   }
 }

Carte Finalisée

Carte test.jpg

Test d'affichage : comme on peut le voir, les 3 afficheurs s'allument et affichent ici trois zéro. En essayant d'afficher différents chiffres on s'est rendu compte que la LED D ne s'allumait jamais . Après avoir effectuer des recherches, on s'est rendu compte que on avait connecté cette LED à la broche 4 du micro-contrôleur, qui correspond à la broche reset qui ne peut donc pas contrôler/allumer la LED.











Carte finalise.jpg

Carte de test de notre fonction supplémentaire avec la carte de contrôle

et la carte d'affichage. Nous avons pu la tester grâce au code ci dessus

et cela fonctionne.



Journal de la réalisation de la clé USB

08/03: Réalisation de la forme du PCB final de notre clé USB sous Inkscape. Pour ce faire, nous avons séparé les deux layers qui composaient le fichier de la forme de la clé, puis nous les avons modifié (silkscreen en dernier) pour s'adapter a notre fonction supplémentaire.

Clef PCB F.png

11/03:

Nous avons intégré notre fonction sur le fichier Fritzing de la clé USB. Nous avons réalisé ces deux solutions probables suivantes:

Schematic CleUSB.png
PCB CleUSB.png

Les séries de pins en haut et en bas servent à connecter la carte de la clé avec une autre carte (nommée bouclier) qui elle assurera la partie affichage, tandis que la carte en-dessous sera la clé USB avec la partie mémoire et contrôle.

BouclierAv.jpg
BouclierAr.jpg

Chaque afficheur est contrôlé grâce à un transistor. On a relié chaque cathode de LED A des trois afficheurs entre elles, le tout connecté à une résistance. On a fait pareil pour les LED B,C,D,E...

15/03:

Nous avons regardé au PCB ainsi que au schématique réalisé sous Fritzing par M.Redon. Après avoir regarder à celui-ci nous avons commencé à lire et essayer de comprendre le programme pour la Clé USB.

18/03:

Nous avons poursuivi notre travail de compréhension sur le programme et ajouter les quelques lignes manquantes.

22/03:

Nous avons commencer à modifier le fichier d'écriture et de lecture de la memoire de la clé USB : Fichier:*DataFlashManager.zip et commencer le soudage de la première clé.

Pour commencer, nous soudons uniquement les composants nécessaire à la partie micro-contrôleur.

Photos de la clé USB avec soudure de la partie micro-contrôleur et mémoire:

CleUSBSoudeeAV.jpg
CleUSBSoudeeAR.jpg

25/03 et 29/03:

Test des mémoires sur la premiere clé fonctionnelle :

Ces deux tests fonctionnent sur la clé USB.

01/04 et 08/04:

Test du code pour contrôler les afficheurs afin d'afficher un compteur. Code: Fichier:Bouclier7seg.zip


Soudure des différents composants sur la deuxieme clé.


12/04:

Test en fin de séance du bouclier d’affichage. Problème sur les chiffres qui ne s’affichent pas comme il le faudrait. Nous pensons donc qu’il y a un problème concernant l’affectation des pins aux LEDs des différents afficheurs dans le fichier nommé « card_io.h »

15/04:

Nous avons eu beaucoup de mal pour faire détecter la clé USB par l’ordinateur. Lorsque l’on tape la commande lsusb dans le terminal de commande, nous n’obtenions pas la ligne suivante: Bus 001 Device 064: ID 03eb:2ffa Atmel Corp. at90usb162 DFU bootloader

Nous sommes tout de meme parvenu a la faire détecter plus souvent et avons résolu le problème des afficheurs qui affichent correctement les différents chiffres: Nous avons modifié les valeurs hexadécimales correspondant aux pins de l’ATMega ou nous avions relié chacune des LED et avons également rectifié une erreur sur la valeur hexadécimale des ports de sorties. Nous avons donc les valeurs suivantes:

Ports de sorties:
#define OUTPUT_PORTB	0x80
#define OUTPUT_PORTC	0x74
#define OUTPUT_PORTD	0xFE
LEDS:
uint32_t leds[MAX_LED]={
 0x00400000,
 0x00000080, 0x00000040, 0x00000020, 0x00000002,
 0x00000400, 0x00000008, 0x00000004, 0x00000010
 };
Afficheurs:
uint32_t displays[MAX_DISPLAY]={
 0x00001000, 0x00002000, 0x00800000
 };

Il nous reste donc à programmer notre fonction supplémentaire, l’affichage de la capacité de la clé.

19/04:

Nous avons modifié le fichier DataFlashManager.c afin de prendre en compte les modifications faites par Mr.Redon. Nous avons également ajouté le refresh des afficheurs dans le code mis sur la clé USB mais aucun afficheur ne s’allume, laissant présager un problème de ce côté la. Comme point positif, l’ordinateur reconnaît maintenant notre clé comme un device de « LUFA Mass Storage »

22/04:

Nous avons programmé les deux clés USB afin de pouvoir écrire, lire et stocker et que nos afficheurs affichent 000. Finalement nous avons tenté de modifier notre programme afin que les afficheurs affichent un compteur pour commencer avant d'essayer d'afficher la capacité comme voulu initialement. Nous n'avons malheureusement pas eu le temps de finir et nous avons tenté de finir chez nous mais aucun de nous étant sous Linux nous avons pas réussi à programmer nos clés avec nos nouveaux codes.

Clé USB finale

Clé soudée et assemblée avec le bouclier

CleUSBbouclier.jpg
Assemblage.jpg

Code

Code dans nos clés à ce jour:Fichier:MassStoragePeiPF.zip

Rendu final

A la fin de ces séances de BE, nous avons une clé fonctionnelle même si elle n'affiche pas exactement ce que l'on souhaitait au départ. Nous sommes ravis d'avoir pu suivre vos cours et réaliser cela.

Vidéo de notre clé en cours d'utilisation :Fichier:CleUSB.mp4