Binome2020-5
Sommaire
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ôleurs, 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é.
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éaliser 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 commencer par chercher et lire les datasheet des composants utiles à la réalisation de notre option :
- Un micro-contrôleur Attiny84
- Une batterie
- Des pins
- 3 afficheurs 7 segments
- 8 Résistances
- 3 Transistors
É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.
- Ne jamais se faire croiser des fils.
- Essayer de mettre un maximum sur la même face de la carte.
- Ne pas faire d'angles 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
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.
- Lien fritzing PCB carte avec le microcontroleur 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ésolution 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 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:
| 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 a cela, nous avons developpé un code afin de verifier 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 contenant le microcontroleur, l'alimentation auxiliaire et les pins
de connexion à la seconde carte.
Carte de test de notre fonction supplémentaire avec la carte de controle
et la carte d'affichage. Nous avons pu la tester grace au code ci dessus
et cela fonctionne.
Clé USB
Journal de la réalisation de la clé
08/03: Realisation de la forme du PCB final de notre clé USB sous Inkscape.
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
- Avec modification des composants :Fichier:CUSB Chloe Thomas.zip
- Solution proposée par ReX : Fichier:ClefChloeThomas2021.zip
22/03: Nous avons commencer a modifier le fichier d'ecriture et de lecture de la memoire de la clé USB : Fichier:*DataFlashManager.zip
25/03: Test des memoires sur la premiere clé fonctionnelle
29/03:
01/04 et 08/04: Soudure des differents composants sur la deuxieme clé.
Photos de la seconde clé avec soudure de la partie micro-contrôleur et mémoire:
12/08: 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/08: 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: insérer la ligne ici
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 a programmer notre fonction supplémentaire, l’affichage de la capacité de la clé.
