Binome2019-8 : Différence entre versions

De Wiki de bureau d'études PeiP
(→‎Séances du 02/03 et du 05/03)
(→‎Code de la clé USB)
 
(24 révisions intermédiaires par 3 utilisateurs non affichées)
Ligne 41 : Ligne 41 :
 
Découverte du logiciel de modélisation Fritzing, que nous utiliserons par la suite pour réaliser la carte éléctronique de notre clé USB. Elaboration d'un circuit imprimé simple destiné à la réalisation d'un dé électronique.
 
Découverte du logiciel de modélisation Fritzing, que nous utiliserons par la suite pour réaliser la carte éléctronique de notre clé USB. Elaboration d'un circuit imprimé simple destiné à la réalisation d'un dé électronique.
  
−
[[Fichier: PCBB8.PNG.jpg]]
+
[[Fichier: PCBB8.PNG|thumb|center|400px]]
  
 
Dé électronique conceptualisé à l'aide du logiciel Fritzing.
 
Dé électronique conceptualisé à l'aide du logiciel Fritzing.
  
−
Voici le schéma de notre dé électronique
+
Voici le schéma de notre dé électronique, ainsi que le fichier .fzz sous format .zip : [[Média: Projet_Cle_USB_2.zip]]
  
 
=== Séances du 09/03 et du 12/03 ===
 
=== Séances du 09/03 et du 12/03 ===
Ligne 144 : Ligne 144 :
 
   }
 
   }
 
  }
 
  }
−
 
−
 
  
 
  void arret() {
 
  void arret() {
Ligne 166 : Ligne 164 :
 
   }
 
   }
 
   }
 
   }
 +
 +
Voici une démonstration de l'exécution du code ci-dessus à notre dé électronique : [[Média: demo_delec.mp4]]
 +
 +
=== Semaine du 27/04 ===
 +
 +
Nous avons démarré la mise en place d'une amélioration de notre choix sur la vue schématique d'une clé usb fournie par les professeurs, toujours depuis le logiciel Fritzing. Notre but serait l'ajout d'un haut-parleur, par le biais d'un transistor MOSFET, le tout contrôlé par le micro-contrôleur atmega8u2 présent dans le schématic de départ de la clé USB.
 +
 +
Après quelques recherches et l'aide des enseignants, on finit par arriver à une portion de circuit dédiée au haut parleur, reliée à la broche PWM PD4 du micro-contrôleur :
 +
 +
[[Fichier:hp.png]]
 +
 +
=== Semaine du 04/05 ===
 +
 +
Nous avons finalement réussi à avoir une représentation du circuit imprimé sur Fritzing avec l'ajout du haut parleur, en reliant les composants comme nous l'ont indiqué les professeurs.
 +
 +
Les vues de la face inférieure, puis supérieure de la clé USB sont celles ci-dessous :
 +
 +
 +
[[Fichier:faceinfcleusb.png]]
 +
 +
 +
[[Fichier:facesupcleusb.png]]
 +
 +
 +
Voici le fichier .fzz sous format .zip de notre clé USB : [[Média: cleplaudpourrier.zip]]
 +
 +
=== Code de la clé USB ===
 +
 +
 +
 +
Enfin, nous avons travaillé sur les premices du codage de notre clé USB particulière équipée d'un haut parleur. Nous avons tout d'abord trouvé comment initialiser la programmation du haut parleur et comment lui faire jouer des notes de musique grâce à la fonction tone(). Voici le morceau de code effectuant cette action :
 +
 +
 +
#include <stdio.h>
 +
#include <stdlib.h>
 +
#include <time.h>
 +
 +
const byte PIN_HP = 9; /* On définit une constante qui contient le numéro de la broche auquel est connecté le haut-parleur */
 +
 +
void setup
 +
{
 +
    pinMode(PIN_HP, OUTPUT);
 +
    tone(PIN_HP, 262); /* Le haut-parleur produira donc un son a une fréquence de 262 Hz, correspondant à un Do de 3eme harmonique C3 en notation internationale */
 +
    tone(PIN_HP, 440); /* Ici on joue un La 440 Hz */
 +
}
 +
 +
 +
 +
Les bases posées ici permettent donc de jouer basiquement des notes à une fréquence donnée. Voyons maintenant comment on peut gérer la notion de rythme entre les notes :
 +
 +
 +
La fonction tone peut s'utiliser de la sorte : tone(numero_pin, frequence, durée). On peut ainsi gérer la durée en secondes du signal émis par le hautparleur. En combinaison avec la fonction delay(durée) qui nous permet d'attendre un certain temps avant de continuer le programme, on peut donc créer des mélodies :
 +
 +
 +
   
 +
void loop          /* Un exemple de mélodie jouable grâce à une fonction loop, mélodie toutefois de piètre qualité */
 +
{
 +
    tone(PIN_HP, 440, 200);
 +
    delay(200);
 +
    tone(PIN_HP, 440, 200);
 +
    delay(200);
 +
    tone(PIN_HP, 440, 200);
 +
    delay(200);
 +
    tone(PIN_HP, 260, 200);
 +
    delay(200);
 +
}
 +
 +
 +
Finalement, on pourrait même construire un programme, qui serait capable en utilisant ces outils et certains codes de traductions de jouer une mélodie passée en paramètre :
 +
 +
On retranscrirai la partition de cette manière, en prenant comme indice de rythme un note noire=1, une blanche=2, une croche=1/2, etc.
 +
De la même manière on décrit la durée du silence après une note par ces indices. (1 noire de silence correspond à un silence de 1)
 +
Pour définir l'octave de la note on prend simplement en paramètre le nombre de l'harmonique. (Si do1=65 alors do5=65*(2^(5-1)=1040)
 +
                                   
 +
                                                                                               
 +
On aurait donc un tableau représentant la partition, composée de N notes de la forme :
 +
 +
int partition[N][4]=N*{frequence, temps, silence, octave}
 +
   
 +
Et on pourrai donc la jouer grâce à un programme tel que celui-ci :
 +
 +
 +
#include <stdio.h>
 +
#include <stdlib.h>
 +
#include <time.h>
 +
 +
/* On définit les notes comme étant leur fréquence à la première harmonique */
 +
 +
#define DO 65
 +
#define DOd 69
 +
#define RE 74
 +
#define REd 78
 +
#define MI 83
 +
#define FA 87
 +
#define FAd 93
 +
#define SOL 98
 +
#define SOLd 104
 +
#define LA 110
 +
#define LAd 117
 +
#define SI 123
 +
 +
int melodie[N][4];
 +
int N;            /* On définit N le nombre de notes comme une variable à part entière car on en a besoin pour la boucle for */
 +
int tempo =200;  /* Le temps que durera une noire : si on veut augmenter le rythme de la musique, il faut donc réduire cette variable, même si cela est un peu contre-intuitif */
 +
const byte PIN_BUZZER = 9;
 +
 +
void setup
 +
{
 +
    pinMode(PIN_HP, OUTPUT);
 +
}
 +
 +
void loop
 +
{
 +
    for (int i=0; i<N; i++)
 +
    {
 +
        int note=melodie[i][0];
 +
        int temps=melodie[i][1];
 +
        int silence=melodie[i][2];
 +
        int octave=melodie[i][3];
 +
       
 +
        int freq= note* pow(2, octave-1);
 +
        int pause=silence*tempo;
 +
        temps2=temps*tempo;
 +
       
 +
        tone(PIN_HP, freq, temps2);        /*On joue la N-ième note pendant le temps indiqué dans la partition */
 +
        delay(pause);                      /* On attend pendant le temps indiqué à silence dans la partition avant de continuer la boucle et donc jouer la note suivante */
 +
    }
 +
}
 +
 +
 +
Ce programme est une esquisse qui n'a malheureusement pas pu être testée, nous ne nous attendons donc pas à ce qu'il fonctionne du premier coup. Toutefois, il représente quelque chose de proche d'une solution correcte et donne une idée des choses que l'on peut faire avec un microprocesseur et un haut parleur en terme de programmation !
 +
Une piste interessante à explorer également aurait été de faire jouer ces differentes partitions par notre haut-parleur à des moments particuliers, ce qui leur aurait donné une signification. Par exemple, si la clé joue une certaine chanson, c'est qu'elle est en train d'écrire sur sa mémoire, ou alors elle pourrait émettre des sons caractéristiques quand on branche ou débranche la clé. Malheureusement le temps ne nous a pas permis de concrétiser cette partie de notre projet.
 +
 +
== III - Retours sur le projet : ==
 +
 +
En somme, ce projet dont le but était, à partir d'un fichier préétabli par les enseignants, d'apporter une amélioration de notre choix au circuit intégré d'une clé USB, nous a conforté dans notre choix d'orientation pour notre cycle ingénieur. Bien que malmené par le confinement, il nous a permis de découvrir les prémices de la microélectronique, et les différentes étapes qui composent l'élaboration de tels systèmes : la partie conception, avec un logiciel informatique spécialisé dans le domaine des circuits intégrés (Fritzing), mais également la partie codage, que l'on a abordée avec le logiciel Arduino pour faire fonctionner un dé électronique, réalisé comme une entrée en matière de ce bureau d'étude.

Version actuelle datée du 22 mai 2020 à 20:53

I - Réflexions sur le projet :

Séance du 27/01

Suite à nos toutes premières réflexions, nous pensons nous diriger vers la réalisation d'une clé USB2 classique, composée d'une première carte électronique associée à sa fonction principale, le stockage usb, et d'en superposer une seconde contenant un micro-haut-parleur, ainsi que les autres composants électroniques nécessaires à son bon fonctionnement.

Fonctionnalités à ajouter :

  • Sons particuliers lors des phases d'écriture de la clé, ou marquant la fin de celles-ci. --> Rajout d'un second microprocesseur éventuellement dirigé par le premier, qui déclencherait donc la lecture d'une piste son dans le haut parleur dans certaines situations. (puce MP3 nécessaire ?)
  • Vumètre indiquant le pourcentage de remplissage de la mémoire de la clé grâce a l'installation de différentes LED.
  • Ajout potentiel d'une batterie, qui peut amener des complications (peut-être), mais aussi de nombreuses possibilités telle que celle de pouvoir déclencher à distance une alarme quand la clé est perdue.

Séance du 10/02

Nous avons choisi d'installer en priorité un micro-haut-parleur et ainsi de laisser de côté les autres améliorations pour le moment.

  • Premières recherches pour trouver un haut parleur adapté. Les critères que nous recherchons principalement sont l'efficacité et la très petite taille, pour pouvoir être intégré facilement à la clé USB sans augmenter démesurément la taille de celle-ci :

Dans cette mesure nous avons trouvé deux potentiels haut-parleurs :

Problème de ce type de haut-parleur, il est apparemment fourni sans fils de connexions mais avec des bornes + ou -

Sourcingmap® 4 pcs 1W 8 Ohm 15x11x3.7mm

Ce modèle de haut-parleur, toujours de dimensions raisonnables, nous paraît être un bon choix pour notre projet, de par sa simplicité d'installation.

Au niveau de la réalisation, nous restons pour l'instant sur l'idée d'une carte électronique en deux étages, le premier identique au modèle proposé sur la page du BE, et pour le second, on se concentrerait sur la connexion du haut-parleur et éventuellement du vumètre si l'idée paraît toujours réalisable à l'issue de cette phase de réflexion.

II - Concrétisation du projet :

Séances du 02/03 et du 05/03

Découverte du logiciel de modélisation Fritzing, que nous utiliserons par la suite pour réaliser la carte éléctronique de notre clé USB. Elaboration d'un circuit imprimé simple destiné à la réalisation d'un dé électronique.

PCBB8.PNG

Dé électronique conceptualisé à l'aide du logiciel Fritzing.

Voici le schéma de notre dé électronique, ainsi que le fichier .fzz sous format .zip : Média: Projet_Cle_USB_2.zip

Séances du 09/03 et du 12/03

Réception de notre circuit imprimé, sur lequel nous avons commencé à souder le micro-contrôleur, l'ensemble des résistances ainsi que deux LEDs. Nous avons rencontré un problème lors de la soudure d'une des résistances, qui n'a pas l'air d'être fonctionnelle, ce qui posera problème lors du test du dé électronique.

Semaine du 16/03

Les problèmes liés au confinement ne nous ont pas permis d'avancer de manière significative sur notre projet.

Semaine du 23/03

Avancée sur le codage en C du programme permettant l'allumage et l'extinction des LEDs de notre clé USB grâce au logiciel Arduino.

Semaine du 30/03

Nous essayons de résoudre un probleme lié au bouton de notre dé électronique, pour cela nous devons examiner son PCB. Malheureusement la version du PCB dont nous avons besoin semble ne pas avoir été enregistrée par notre binome. Pour palier a cela nous avons effectué une tentative de reconstitution du PCB grâce aux fichiers gerber que j'ai pu récupérer dans le mail de Polytech faisant suite à la demande d'impression de la carte.

Voici le résultat obtenu :

Gerber.jpg.PNG

Finalement, grâce aux professeurs qui ont pu finir les soudures pour nous, on obtient cela pour notre dé électronique :

De elec.png

Le code utilisé pour faire fonctionner le dé électronique est le suivant : 

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

int nb()
 {
   return random(1,7);
 }

void setup()  
 {
   pinMode(0, OUTPUT);
   pinMode(1, OUTPUT);
   pinMode(2, OUTPUT);
   pinMode(3, OUTPUT);
   pinMode(4, OUTPUT);
   pinMode(5, OUTPUT);
   pinMode(6, OUTPUT);
   pinMode(9, INPUT_PULLUP);
   randomSeed(analogRead(A7)); // Patte inutilisée
 }

void lancer(int a) {
 if (a==1)
 {
   digitalWrite(3,HIGH);
   
 }
 if (a==2)
 {
   digitalWrite(0,HIGH);
   digitalWrite(5,HIGH);
   
 }
 if (a==3)
 {
   digitalWrite(3,HIGH);
   digitalWrite(0,HIGH);
   digitalWrite(5,HIGH);
   
 }
 if (a==4)
 {
   digitalWrite(6,HIGH);
   digitalWrite(5,HIGH);
   digitalWrite(0,HIGH);
   digitalWrite(1,HIGH);
   
 }
 if (a==5)
 {
   digitalWrite(0,HIGH);
   digitalWrite(5,HIGH);
   digitalWrite(6,HIGH);
   digitalWrite(1,HIGH);
   digitalWrite(3,HIGH);
 }
 if (a==6)
 {
   digitalWrite(4,HIGH);
   digitalWrite(5,HIGH);
   digitalWrite(0,HIGH);
   digitalWrite(1,HIGH);
   digitalWrite(2,HIGH);
   digitalWrite(6,HIGH);
 }
}

void arret() {
 digitalWrite(0,LOW);
 digitalWrite(1,LOW);
 digitalWrite(2,LOW);
 digitalWrite(3,LOW);
 digitalWrite(4,LOW);
 digitalWrite(5,LOW);
 digitalWrite(6,LOW);
}

void loop() {
 int nombre;
 nombre = nb();
 if (digitalRead(9) == LOW) {
 lancer(nombre);
 delay(1000);
 arret();
 }
 }

Voici une démonstration de l'exécution du code ci-dessus à notre dé électronique : Média: demo_delec.mp4

Semaine du 27/04

Nous avons démarré la mise en place d'une amélioration de notre choix sur la vue schématique d'une clé usb fournie par les professeurs, toujours depuis le logiciel Fritzing. Notre but serait l'ajout d'un haut-parleur, par le biais d'un transistor MOSFET, le tout contrôlé par le micro-contrôleur atmega8u2 présent dans le schématic de départ de la clé USB.

Après quelques recherches et l'aide des enseignants, on finit par arriver à une portion de circuit dédiée au haut parleur, reliée à la broche PWM PD4 du micro-contrôleur :

Hp.png

Semaine du 04/05

Nous avons finalement réussi à avoir une représentation du circuit imprimé sur Fritzing avec l'ajout du haut parleur, en reliant les composants comme nous l'ont indiqué les professeurs.

Les vues de la face inférieure, puis supérieure de la clé USB sont celles ci-dessous :


Faceinfcleusb.png


Facesupcleusb.png


Voici le fichier .fzz sous format .zip de notre clé USB : Média: cleplaudpourrier.zip

Code de la clé USB

Enfin, nous avons travaillé sur les premices du codage de notre clé USB particulière équipée d'un haut parleur. Nous avons tout d'abord trouvé comment initialiser la programmation du haut parleur et comment lui faire jouer des notes de musique grâce à la fonction tone(). Voici le morceau de code effectuant cette action : 


#include <stdio.h>
#include <stdlib.h>
#include <time.h>

const byte PIN_HP = 9; /* On définit une constante qui contient le numéro de la broche auquel est connecté le haut-parleur */

void setup 
{
    pinMode(PIN_HP, OUTPUT);
    tone(PIN_HP, 262); /* Le haut-parleur produira donc un son a une fréquence de 262 Hz, correspondant à un Do de 3eme harmonique C3 en notation internationale */
    tone(PIN_HP, 440); /* Ici on joue un La 440 Hz */
}


Les bases posées ici permettent donc de jouer basiquement des notes à une fréquence donnée. Voyons maintenant comment on peut gérer la notion de rythme entre les notes :


La fonction tone peut s'utiliser de la sorte : tone(numero_pin, frequence, durée). On peut ainsi gérer la durée en secondes du signal émis par le hautparleur. En combinaison avec la fonction delay(durée) qui nous permet d'attendre un certain temps avant de continuer le programme, on peut donc créer des mélodies : 


void loop           /* Un exemple de mélodie jouable grâce à une fonction loop, mélodie toutefois de piètre qualité */
{
    tone(PIN_HP, 440, 200);
    delay(200);
    tone(PIN_HP, 440, 200);
    delay(200);
    tone(PIN_HP, 440, 200);
    delay(200);
    tone(PIN_HP, 260, 200);
    delay(200);
}


Finalement, on pourrait même construire un programme, qui serait capable en utilisant ces outils et certains codes de traductions de jouer une mélodie passée en paramètre :

On retranscrirai la partition de cette manière, en prenant comme indice de rythme un note noire=1, une blanche=2, une croche=1/2, etc. De la même manière on décrit la durée du silence après une note par ces indices. (1 noire de silence correspond à un silence de 1) Pour définir l'octave de la note on prend simplement en paramètre le nombre de l'harmonique. (Si do1=65 alors do5=65*(2^(5-1)=1040)


On aurait donc un tableau représentant la partition, composée de N notes de la forme : 

int partition[N][4]=N*{frequence, temps, silence, octave}

Et on pourrai donc la jouer grâce à un programme tel que celui-ci : 


#include <stdio.h>
#include <stdlib.h>
#include <time.h>

/* On définit les notes comme étant leur fréquence à la première harmonique */

#define DO 65
#define DOd 69
#define RE 74
#define REd 78
#define MI 83
#define FA 87
#define FAd 93
#define SOL 98
#define SOLd 104
#define LA 110
#define LAd 117
#define SI 123

int melodie[N][4];
int N;            /* On définit N le nombre de notes comme une variable à part entière car on en a besoin pour la boucle for */
int tempo =200;   /* Le temps que durera une noire : si on veut augmenter le rythme de la musique, il faut donc réduire cette variable, même si cela est un peu contre-intuitif */
const byte PIN_BUZZER = 9;

void setup
{
    pinMode(PIN_HP, OUTPUT);
}

void loop
{
    for (int i=0; i<N; i++)
    {
        int note=melodie[i][0];
        int temps=melodie[i][1];
        int silence=melodie[i][2];
        int octave=melodie[i][3];
        
        int freq= note* pow(2, octave-1);
        int pause=silence*tempo;
        temps2=temps*tempo;
       
        tone(PIN_HP, freq, temps2);         /*On joue la N-ième note pendant le temps indiqué dans la partition */
        delay(pause);                       /* On attend pendant le temps indiqué à silence dans la partition avant de continuer la boucle et donc jouer la note suivante */
    }
}


Ce programme est une esquisse qui n'a malheureusement pas pu être testée, nous ne nous attendons donc pas à ce qu'il fonctionne du premier coup. Toutefois, il représente quelque chose de proche d'une solution correcte et donne une idée des choses que l'on peut faire avec un microprocesseur et un haut parleur en terme de programmation ! Une piste interessante à explorer également aurait été de faire jouer ces differentes partitions par notre haut-parleur à des moments particuliers, ce qui leur aurait donné une signification. Par exemple, si la clé joue une certaine chanson, c'est qu'elle est en train d'écrire sur sa mémoire, ou alors elle pourrait émettre des sons caractéristiques quand on branche ou débranche la clé. Malheureusement le temps ne nous a pas permis de concrétiser cette partie de notre projet.

III - Retours sur le projet :

En somme, ce projet dont le but était, à partir d'un fichier préétabli par les enseignants, d'apporter une amélioration de notre choix au circuit intégré d'une clé USB, nous a conforté dans notre choix d'orientation pour notre cycle ingénieur. Bien que malmené par le confinement, il nous a permis de découvrir les prémices de la microélectronique, et les différentes étapes qui composent l'élaboration de tels systèmes : la partie conception, avec un logiciel informatique spécialisé dans le domaine des circuits intégrés (Fritzing), mais également la partie codage, que l'on a abordée avec le logiciel Arduino pour faire fonctionner un dé électronique, réalisé comme une entrée en matière de ce bureau d'étude.

Récupérée de « https://peip-ima.plil.fr/mediawiki/index.php?title=Binome2019-8&oldid=12812 »