troyesGEII - Contributions de l’utilisateur [fr]

Cours:Eval Mecatro

2017-07-03T14:22:39Z

Sisternas :

[[Cours:Eval_Mecatro_corr|{{Vert|<big>Corrigé uniquement accessible aux enseignants</big>}}]]

L'objectif consiste à réaliser un dé avec un affichage sur sept segments en lieu et place des chiffres d'un dé de la vraie vie.
=Quelques évaluations d'expressions=
Vous disposez pour ce travail d'introduction du code suivant :
<source lang=C>
void setup(){
char i;
for (i=6;i<=13;i++) pinMode(i,OUTPUT); // Déclaration des 6 so
pinMode(2,INPUT);
}
void allumeLeds(unsigned char motif){
char i;
for (i=0;i<8;i++) {
digitalWrite(i+6,(motif>>i) & 1);
}
}
</source>
Il est capable d'allumer les LEDs en fonction de la valeur passée dans motif.
==Expressions booléennes==
La variable a (de type unsigned char) est initialisée à 0xC7.
Écrire un programme qui est capable de trouver la valeur des expressions booléennes en allumant ou pas une Led choisie par avance :
* (a & 0x80)== 0x80
* (a & 0x47)== 0x47

==Expression de décalage==
La variable a (de type unsigned char) est encore initialisée à 0xC7.
Écrire un programme qui est capable de trouver la valeur des expressions :
* a >> 2
* a << 3

=Réalisation du dé avec le shield de l'IUT=
Nous désirons réaliser un dé avec le shield que l'on utilise régulièrement à l'IUT. Les leds étant alignées, elles ne présentent pas une organisation facilement exploitable pour un affichage de type "dé à jouer". Nous décidons donc d'afficher directement le chiffre sur ''' un afficheur sept segments'''.

Nous allons utiliser un tableau précalculé de valeurs.Nous décidons d'utiliser la configuration du tableau ci-dessous.

{| class="wikitable"
|-
! Segment
|| pt || g || f || e || d || c || b || a
|-
|-
! Arduino Pin
|| 11 || 9 || 10 || 8 || 7 || 6 || 12 || 13
|-
! Port
|| PB3 || PB1 || PB2 || PB0 || PD7 || PD6 || PB4 || PB5
|}

On vous impose le sous programme suivant :
<source lang=c>
const char pinMux = 4;
const char pinAff[8]={13,12,6,7,8,10,9,11};
const char de[7]={/*A compléter les valeurs 0,1,2,3,4,5,6*/};

void affiche7seg(unsigned char v){
char i,s;
unsigned char c;
// boucle d'affichage :
for (i=0;i<8;i++) {
if ((v & (1<<i)) == (1<<i) ) digitalWrite(pinAff[i],1); // Modifie successivement l'état des segments a (ou patte 13)
else digitalWrite(pinAff[i],0);
}
}
</source>
Exercice 1 : calculer les valeurs pour afficher 0, 1, 2, 3, 4 , 5 et 6 et mettez-les dans le tableau à compléter.
==Affichage du tableau==
Exercice 2 : après ce calcul on fera un programme de test qui affiche toutes les secondes toutes les valeurs possibles du dé. On prendra bien soin de gérer la sélection de l'afficheur (de droite avec pinMux à 1).
<source lang=C>
void setup() {
// put your setup code here, to run once:
char i;
for (i=0;i<8;i++) pinMode(pinAff[i],OUTPUT); // Déclaration des 8 sorties des afficheurs
pinMode(pinMux,OUTPUT); // + sortie de multiplexage (choix de l'afficheur)
digitalWrite(??,??); // sur l'afficheur 1 : à compléter
}

void loop() {
// put your main code here, to run repeatedly:

}
</source>
L'étape suivante consiste à introduire de l'aléatoire pour que cela ressemble le plus possible à un vrai dé.

==Utilisation du pseudo aléatoire==
On vous propose le code suivant :
<source lang=C>
unsigned char pseudoAleat(int Lim) {
unsigned char Result;
static unsigned int Y=1;
Y = (Y * 32719 + 3) % 32749;
Result = ((Y % Lim)+1);//+1 : eviter 0
return Result;
}
</source>
Exercice 3 : Réaliser un programme qui fait défiler les valeurs de cette fonction pseudo aléatoire pour un appel avec un paramètre égal à 6 (qui vous permet d'avoir systématiquement des nombres entre 1 et 6 compris).

==Gestion du bouton de lancement==
===Description===

Le shield comporte 4 boutons, dont 2 possèdent une interruption spécifique. Chaque bouton est relié à une porte "non". Une fonction "trigger" sur les entrées permet de limiter les changements d'états impromptus (rebonds) lors du changement d'état des boutons.

Le tableau suivant donne les caractéristiques utiles :

{{Cours:ShieldinfoTableauBps}}

On utilisera le bouton B qui est en pullup sur PC0.

Exercice 4 : après avoir mis au point une boucle d'attente d'un appui sur le bouton B, réaliser le programme complet qui attend un appui du bouton B et appelle le générateur pseudo-aléatoire pour afficher le résultat.

==Gestion de deux dés==
C'est le bit PD4 du PORTD (appelé "pinMux" dans nos programmes) qui est responsable de la sélection d'un afficheur :
* PD4 = 1 c'est l'afficheur de droite qui est en action
* PD4 = 0 c'est l'afficheur de gauche qui est en action
Si vous voulez afficher deux valeurs, il vous faut les écrire en synchronisme avec la commutation des afficheurs. Cette commutation doit être réalisée à plus de 25 Hz pour un fonctionnement correct (sans scintillation pour les yeux).

Exercice 5 : Réaliser un programme qui affiche sur deux afficheurs deux résultats de la fonction pseudo-aléatoire. Il faut afficher pendant un certain temps pour que l’œil perçoive !
'''INDICATION''' : Le sous-programme ci-dessous affiche les deux valeurs et dure 400 ms
<source lang=C>
void affiche2Digits(char de2,char de1) {
char c;
for (c=0;c<20;c++) {
digitalWrite(pinMux,1); // sur l'afficheur unité
affiche7seg(de1);
delay(10);
digitalWrite(pinMux,0); // puis sur l'afficheur dizaine
affiche7seg(de2);
delay(10); }
}
</source>

Exercice 6 : Réaliser un programme complet qui attend que l'on appui sur le bouton B et qui alors utilise deux fois la fonction pseudo-aléatoire pour trouver la valeur des deux dé et qui affiche alors les deux valeurs sur les deux afficheurs.

'''Indication''' : il est impossible d'utiliser la boucle d'attente de l'exercice 4 car pendant l'attente, on perdrait l'affichage. Il faut donc utiliser la technique de détection de changement d'état :
<source lang=C>
void loop(){
etatPasse=etatPresent; // mémorise l'état précédent (le présent devient le passé)
etatPresent=digitalRead(??); // lecture de la valeur actuelle
if ( ( etatPresent == ?? ) && ( etatPasse == ?? ) ) { // si appui alors ....
.....
}
delay(20); // est-ce obligatoire ???
}
</source>
dans laquelle on remplacera le "delay(20)" par l'affichage des deux dés. Cela devient un peu lent mais suffisant pour nos propos.

Cours:Eval Mecatro

2017-07-03T14:16:12Z

Sisternas :

<accesscontrol> Acces:Prof </accesscontrol>

[[Cours:Eval_Mecatro_corr|{{Vert|<big>Corrigé uniquement accessible aux enseignants</big>}}]]

L'objectif consiste à réaliser un dé avec un affichage sur sept segments en lieu et place des chiffres d'un dé de la vraie vie.
=Quelques évaluations d'expressions=
Vous disposez pour ce travail d'introduction du code suivant :
<source lang=C>
void setup(){
char i;
for (i=6;i<=13;i++) pinMode(i,OUTPUT); // Déclaration des 6 so
pinMode(2,INPUT);
}
void allumeLeds(unsigned char motif){
char i;
for (i=0;i<8;i++) {
digitalWrite(i+6,(motif>>i) & 1);
}
}
</source>
Il est capable d'allumer les LEDs en fonction de la valeur passée dans motif.
==Expressions booléennes==
La variable a (de type unsigned char) est initialisée à 0xC7.
Écrire un programme qui est capable de trouver la valeur des expressions booléennes en allumant ou pas une Led choisie par avance :
* (a & 0x80)== 0x80
* (a & 0x47)== 0x47

==Expression de décalage==
La variable a (de type unsigned char) est encore initialisée à 0xC7.
Écrire un programme qui est capable de trouver la valeur des expressions :
* a >> 2
* a << 3

=Réalisation du dé avec le shield de l'IUT=
Nous désirons réaliser un dé avec le shield que l'on utilise régulièrement à l'IUT. Les leds étant alignées, elles ne présentent pas une organisation facilement exploitable pour un affichage de type "dé à jouer". Nous décidons donc d'afficher directement le chiffre sur ''' un afficheur sept segments'''.

Nous allons utiliser un tableau précalculé de valeurs.Nous décidons d'utiliser la configuration du tableau ci-dessous.

{| class="wikitable"
|-
! Segment
|| pt || g || f || e || d || c || b || a
|-
|-
! Arduino Pin
|| 11 || 9 || 10 || 8 || 7 || 6 || 12 || 13
|-
! Port
|| PB3 || PB1 || PB2 || PB0 || PD7 || PD6 || PB4 || PB5
|}

On vous impose le sous programme suivant :
<source lang=c>
const char pinMux = 4;
const char pinAff[8]={13,12,6,7,8,10,9,11};
const char de[7]={/*A compléter les valeurs 0,1,2,3,4,5,6*/};

void affiche7seg(unsigned char v){
char i,s;
unsigned char c;
// boucle d'affichage :
for (i=0;i<8;i++) {
if ((v & (1<<i)) == (1<<i) ) digitalWrite(pinAff[i],1); // Modifie successivement l'état des segments a (ou patte 13)
else digitalWrite(pinAff[i],0);
}
}
</source>
Exercice 1 : calculer les valeurs pour afficher 0, 1, 2, 3, 4 , 5 et 6 et mettez-les dans le tableau à compléter.
==Affichage du tableau==
Exercice 2 : après ce calcul on fera un programme de test qui affiche toutes les secondes toutes les valeurs possibles du dé. On prendra bien soin de gérer la sélection de l'afficheur (de droite avec pinMux à 1).
<source lang=C>
void setup() {
// put your setup code here, to run once:
char i;
for (i=0;i<8;i++) pinMode(pinAff[i],OUTPUT); // Déclaration des 8 sorties des afficheurs
pinMode(pinMux,OUTPUT); // + sortie de multiplexage (choix de l'afficheur)
digitalWrite(??,??); // sur l'afficheur 1 : à compléter
}

void loop() {
// put your main code here, to run repeatedly:

}
</source>
L'étape suivante consiste à introduire de l'aléatoire pour que cela ressemble le plus possible à un vrai dé.

==Utilisation du pseudo aléatoire==
On vous propose le code suivant :
<source lang=C>
unsigned char pseudoAleat(int Lim) {
unsigned char Result;
static unsigned int Y=1;
Y = (Y * 32719 + 3) % 32749;
Result = ((Y % Lim)+1);//+1 : eviter 0
return Result;
}
</source>
Exercice 3 : Réaliser un programme qui fait défiler les valeurs de cette fonction pseudo aléatoire pour un appel avec un paramètre égal à 6 (qui vous permet d'avoir systématiquement des nombres entre 1 et 6 compris).

==Gestion du bouton de lancement==
===Description===

Le shield comporte 4 boutons, dont 2 possèdent une interruption spécifique. Chaque bouton est relié à une porte "non". Une fonction "trigger" sur les entrées permet de limiter les changements d'états impromptus (rebonds) lors du changement d'état des boutons.

Le tableau suivant donne les caractéristiques utiles :

{{Cours:ShieldinfoTableauBps}}

On utilisera le bouton B qui est en pullup sur PC0.

Exercice 4 : après avoir mis au point une boucle d'attente d'un appui sur le bouton B, réaliser le programme complet qui attend un appui du bouton B et appelle le générateur pseudo-aléatoire pour afficher le résultat.

==Gestion de deux dés==
C'est le bit PD4 du PORTD (appelé "pinMux" dans nos programmes) qui est responsable de la sélection d'un afficheur :
* PD4 = 1 c'est l'afficheur de droite qui est en action
* PD4 = 0 c'est l'afficheur de gauche qui est en action
Si vous voulez afficher deux valeurs, il vous faut les écrire en synchronisme avec la commutation des afficheurs. Cette commutation doit être réalisée à plus de 25 Hz pour un fonctionnement correct (sans scintillation pour les yeux).

Exercice 5 : Réaliser un programme qui affiche sur deux afficheurs deux résultats de la fonction pseudo-aléatoire. Il faut afficher pendant un certain temps pour que l’œil perçoive !
'''INDICATION''' : Le sous-programme ci-dessous affiche les deux valeurs et dure 400 ms
<source lang=C>
void affiche2Digits(char de2,char de1) {
char c;
for (c=0;c<20;c++) {
digitalWrite(pinMux,1); // sur l'afficheur unité
affiche7seg(de1);
delay(10);
digitalWrite(pinMux,0); // puis sur l'afficheur dizaine
affiche7seg(de2);
delay(10); }
}
</source>

Exercice 6 : Réaliser un programme complet qui attend que l'on appui sur le bouton B et qui alors utilise deux fois la fonction pseudo-aléatoire pour trouver la valeur des deux dé et qui affiche alors les deux valeurs sur les deux afficheurs.

'''Indication''' : il est impossible d'utiliser la boucle d'attente de l'exercice 4 car pendant l'attente, on perdrait l'affichage. Il faut donc utiliser la technique de détection de changement d'état :
<source lang=C>
void loop(){
etatPasse=etatPresent; // mémorise l'état précédent (le présent devient le passé)
etatPresent=digitalRead(??); // lecture de la valeur actuelle
if ( ( etatPresent == ?? ) && ( etatPasse == ?? ) ) { // si appui alors ....
.....
}
delay(20); // est-ce obligatoire ???
}
</source>
dans laquelle on remplacera le "delay(20)" par l'affichage des deux dés. Cela devient un peu lent mais suffisant pour nos propos.

Cours:Eval Mecatro

2017-07-03T14:14:43Z

Sisternas :

[[Cours:Eval_Mecatro_corr|{{Vert|<big>Corrigé uniquement accessible aux enseignants</big>}}]]

L'objectif consiste à réaliser un dé avec un affichage sur sept segments en lieu et place des chiffres d'un dé de la vraie vie.
=Quelques évaluations d'expressions=
Vous disposez pour ce travail d'introduction du code suivant :
<source lang=C>
void setup(){
char i;
for (i=6;i<=13;i++) pinMode(i,OUTPUT); // Déclaration des 6 so
pinMode(2,INPUT);
}
void allumeLeds(unsigned char motif){
char i;
for (i=0;i<8;i++) {
digitalWrite(i+6,(motif>>i) & 1);
}
}
</source>
Il est capable d'allumer les LEDs en fonction de la valeur passée dans motif.
==Expressions booléennes==
La variable a (de type unsigned char) est initialisée à 0xC7.
Écrire un programme qui est capable de trouver la valeur des expressions booléennes en allumant ou pas une Led choisie par avance :
* (a & 0x80)== 0x80
* (a & 0x47)== 0x47

==Expression de décalage==
La variable a (de type unsigned char) est encore initialisée à 0xC7.
Écrire un programme qui est capable de trouver la valeur des expressions :
* a >> 2
* a << 3

=Réalisation du dé avec le shield de l'IUT=
Nous désirons réaliser un dé avec le shield que l'on utilise régulièrement à l'IUT. Les leds étant alignées, elles ne présentent pas une organisation facilement exploitable pour un affichage de type "dé à jouer". Nous décidons donc d'afficher directement le chiffre sur ''' un afficheur sept segments'''.

Nous allons utiliser un tableau précalculé de valeurs.Nous décidons d'utiliser la configuration du tableau ci-dessous.

{| class="wikitable"
|-
! Segment
|| pt || g || f || e || d || c || b || a
|-
|-
! Arduino Pin
|| 11 || 9 || 10 || 8 || 7 || 6 || 12 || 13
|-
! Port
|| PB3 || PB1 || PB2 || PB0 || PD7 || PD6 || PB4 || PB5
|}

On vous impose le sous programme suivant :
<source lang=c>
const char pinMux = 4;
const char pinAff[8]={13,12,6,7,8,10,9,11};
const char de[7]={/*A compléter les valeurs 0,1,2,3,4,5,6*/};

void affiche7seg(unsigned char v){
char i,s;
unsigned char c;
// boucle d'affichage :
for (i=0;i<8;i++) {
if ((v & (1<<i)) == (1<<i) ) digitalWrite(pinAff[i],1); // Modifie successivement l'état des segments a (ou patte 13)
else digitalWrite(pinAff[i],0);
}
}
</source>
Exercice 1 : calculer les valeurs pour afficher 0, 1, 2, 3, 4 , 5 et 6 et mettez-les dans le tableau à compléter.
==Affichage du tableau==
Exercice 2 : après ce calcul on fera un programme de test qui affiche toutes les secondes toutes les valeurs possibles du dé. On prendra bien soin de gérer la sélection de l'afficheur (de droite avec pinMux à 1).
<source lang=C>
void setup() {
// put your setup code here, to run once:
char i;
for (i=0;i<8;i++) pinMode(pinAff[i],OUTPUT); // Déclaration des 8 sorties des afficheurs
pinMode(pinMux,OUTPUT); // + sortie de multiplexage (choix de l'afficheur)
digitalWrite(??,??); // sur l'afficheur 1 : à compléter
}

void loop() {
// put your main code here, to run repeatedly:

}
</source>
L'étape suivante consiste à introduire de l'aléatoire pour que cela ressemble le plus possible à un vrai dé.

==Utilisation du pseudo aléatoire==
On vous propose le code suivant :
<source lang=C>
unsigned char pseudoAleat(int Lim) {
unsigned char Result;
static unsigned int Y=1;
Y = (Y * 32719 + 3) % 32749;
Result = ((Y % Lim)+1);//+1 : eviter 0
return Result;
}
</source>
Exercice 3 : Réaliser un programme qui fait défiler les valeurs de cette fonction pseudo aléatoire pour un appel avec un paramètre égal à 6 (qui vous permet d'avoir systématiquement des nombres entre 1 et 6 compris).

==Gestion du bouton de lancement==
===Description===

Le shield comporte 4 boutons, dont 2 possèdent une interruption spécifique. Chaque bouton est relié à une porte "non". Une fonction "trigger" sur les entrées permet de limiter les changements d'états impromptus (rebonds) lors du changement d'état des boutons.

Le tableau suivant donne les caractéristiques utiles :

{{Cours:ShieldinfoTableauBps}}

On utilisera le bouton B qui est en pullup sur PC0.

Exercice 4 : après avoir mis au point une boucle d'attente d'un appui sur le bouton B, réaliser le programme complet qui attend un appui du bouton B et appelle le générateur pseudo-aléatoire pour afficher le résultat.

==Gestion de deux dés==
C'est le bit PD4 du PORTD (appelé "pinMux" dans nos programmes) qui est responsable de la sélection d'un afficheur :
* PD4 = 1 c'est l'afficheur de droite qui est en action
* PD4 = 0 c'est l'afficheur de gauche qui est en action
Si vous voulez afficher deux valeurs, il vous faut les écrire en synchronisme avec la commutation des afficheurs. Cette commutation doit être réalisée à plus de 25 Hz pour un fonctionnement correct (sans scintillation pour les yeux).

Exercice 5 : Réaliser un programme qui affiche sur deux afficheurs deux résultats de la fonction pseudo-aléatoire. Il faut afficher pendant un certain temps pour que l’œil perçoive !
'''INDICATION''' : Le sous-programme ci-dessous affiche les deux valeurs et dure 400 ms
<source lang=C>
void affiche2Digits(char de2,char de1) {
char c;
for (c=0;c<20;c++) {
digitalWrite(pinMux,1); // sur l'afficheur unité
affiche7seg(de1);
delay(10);
digitalWrite(pinMux,0); // puis sur l'afficheur dizaine
affiche7seg(de2);
delay(10); }
}
</source>

Exercice 6 : Réaliser un programme complet qui attend que l'on appui sur le bouton B et qui alors utilise deux fois la fonction pseudo-aléatoire pour trouver la valeur des deux dé et qui affiche alors les deux valeurs sur les deux afficheurs.

'''Indication''' : il est impossible d'utiliser la boucle d'attente de l'exercice 4 car pendant l'attente, on perdrait l'affichage. Il faut donc utiliser la technique de détection de changement d'état :
<source lang=C>
void loop(){
etatPasse=etatPresent; // mémorise l'état précédent (le présent devient le passé)
etatPresent=digitalRead(??); // lecture de la valeur actuelle
if ( ( etatPresent == ?? ) && ( etatPasse == ?? ) ) { // si appui alors ....
.....
}
delay(20); // est-ce obligatoire ???
}
</source>
dans laquelle on remplacera le "delay(20)" par l'affichage des deux dés. Cela devient un peu lent mais suffisant pour nos propos.

Cours:Eval Mecatro

2017-07-03T14:11:52Z

Sisternas :

[[Cours:Eval_Mecatro_corr|{{Vert|<big>Corrigé uniquement accessible aux enseignants</big>}}]]

L'objectif consiste à réaliser un dé avec un affichage sur sept segments en lieu et place des chiffres d'un dé de la vraie vie.
=Quelques évaluations d'expressions=
Vous disposez pour ce travail d'introduction du code suivant :
<source lang=C>
void setup(){
char i;
for (i=6;i<=13;i++) pinMode(i,OUTPUT); // Déclaration des 6 so
pinMode(2,INPUT);
}
void allumeLeds(unsigned char motif){
char i;
for (i=0;i<8;i++) {
digitalWrite(i+6,(motif>>i) & 1);
}
}
</source>
Il est capable d'allumer les LEDs en fonction de la valeur passée dans motif.
==Expressions booléennes==
La variable a (de type unsigned char) est initialisée à 0xC7.
Écrire un programme qui est capable de trouver la valeur des expressions booléennes en allumant ou pas une Led choisie par avance :
* (a & 0x80)== 0x80
* (a & 0x47)== 0x47

==Expression de décalage==
La variable a (de type unsigned char) est encore initialisée à 0xC7.
Écrire un programme qui est capable de trouver la valeur des expressions :
* a >> 2
* a << 3

=Réalisation du dé avec le shield de l'IUT=
Nous désirons réaliser un dé avec le shield que l'on utilise régulièrement à l'IUT. Les leds étant alignées, elles ne présentent pas une organisation facilement exploitable pour un affichage de type "dé à jouer". Nous décidons donc d'afficher directement le chiffre sur ''' un afficheur sept segments'''.

Nous allons utiliser un tableau précalculé de valeurs.Nous décidons d'utiliser la configuration du tableau ci-dessous.

{| class="wikitable"
|-
! Segment
|| pt || g || f || e || d || c || b || a
|-
|-
! Arduino Pin
|| 11 || 9 || 10 || 8 || 7 || 6 || 12 || 13
|-
! Port
|| PB3 || PB1 || PB2 || PB0 || PD7 || PD6 || PB4 || PB5
|}

On vous impose le sous programme suivant :
<source lang=c>
const char pinMux = 4;
const char pinAff[8]={13,12,6,7,8,10,9,11};
const char de[7]={/*A compléter les valeurs 0,1,2,3,4,5,6*/};

void affiche7seg(unsigned char v){
char i,s;
unsigned char c;
// boucle d'affichage :
for (i=0;i<8;i++) {
if ((v & (1<<i)) == (1<<i) ) digitalWrite(pinAff[i],1); // Modifie successivement l'état des segments a (ou patte 13)
else digitalWrite(pinAff[i],0);
}
}
</source>
Exercice 1 : calculer les valeurs pour afficher 0, 1, 2, 3, 4 , 5 et 6 et mettez-les dans le tableau à compléter.
==Affichage du tableau==
Exercice 2 : après ce calcul on fera un programme de test qui affiche toutes les secondes toutes les valeurs possibles du dé. On prendra bien soin de gérer la sélection de l'afficheur (de droite avec pinMux à 1).
<source lang=C>
void setup() {
// put your setup code here, to run once:
char i;
for (i=0;i<8;i++) pinMode(pinAff[i],OUTPUT); // Déclaration des 8 sorties des afficheurs
pinMode(pinMux,OUTPUT); // + sortie de multiplexage (choix de l'afficheur)
digitalWrite(??,??); // sur l'afficheur 1 : à compléter
}

void loop() {
// put your main code here, to run repeatedly:

}
</source>
L'étape suivante consiste à introduire de l'aléatoire pour que cela ressemble le plus possible à un vrai dé.

==Utilisation du pseudo aléatoire==
On vous propose le code suivant :
<source lang=C>
unsigned char pseudoAleat(int Lim) {
unsigned char Result;
static unsigned int Y=1;
Y = (Y * 32719 + 3) % 32749;
Result = ((Y % Lim)+1);//+1 : eviter 0
return Result;
}
</source>
Exercice 3 : Réaliser un programme qui fait défiler les valeurs de cette fonction pseudo aléatoire pour un appel avec un paramètre égal à 6 (qui vous permet d'avoir systématiquement des nombres entre 1 et 6 compris).

==Gestion du bouton de lancement==
===Description===

Le shield comporte 4 boutons, dont 2 possèdent une interruption spécifique. Chaque bouton est relié à une porte "non". Une fonction "trigger" sur les entrées permet de limiter les changements d'états impromptus (rebonds) lors du changement d'état des boutons.

Le tableau suivant donne les caractéristiques utiles :

{{Cours:ShieldinfoTableauBps}}

On utilisera le bouton B qui est en pullup sur PC0.

Exercice 4 : après avoir mis au point une boucle d'attente d'un appui sur le bouton B, réaliser le programme complet qui attend un appui du bouton B et appelle le générateur pseudo-aléatoire pour afficher le résultat.

==Gestion de deux dés==
C'est le bit PD4 du PORTD (appelé "pinMux" dans nos programmes) qui est responsable de la sélection d'un afficheur :
* PD4 = 1 c'est l'afficheur de droite qui est en action
* PD4 = 0 c'est l'afficheur de gauche qui est en action
Si vous voulez afficher deux valeurs, il vous faut les écrire en synchronisme avec la commutation des afficheurs. Cette commutation doit être réalisée à plus de 25 Hz pour un fonctionnement correct (sans scintillation pour les yeux).

Exercice 5 : Réaliser un programme qui affiche sur deux afficheurs deux résultats de la fonction pseudo-aléatoire. Il faut afficher pendant un certain temps pour que l’œil perçoive !
'''INDICATION''' : Le sous-programme ci-dessous affiche les deux valeurs et dure 400 ms
<source lang=C>
void affiche2Digits(char de2,char de1) {
char c;
for (c=0;c<20;c++) {
digitalWrite(pinMux,1); // sur l'afficheur unité
affiche7seg(de1);
delay(10);
digitalWrite(pinMux,0); // puis sur l'afficheur dizaine
affiche7seg(de2);
delay(10); }
}
</source>

Exercice 6 : Réaliser un programme complet qui attend que l'on appui sur le bouton B et qui alors utilise deux fois la fonction pseudo-aléatoire pour trouver la valeur des deux dé et qui affiche alors les deux valeurs sur les deux afficheurs.

'''Indication''' : il est impossible d'utiliser la boucle d'attente de l'exercice 4 car pendant l'attente, on perdrait l'affichage. Il faut donc utiliser la technique de détection de changement d'état :
<source lang=C>
void loop(){
etatPasse=etatPresent; // mémorise l'état précédent (le présent devient le passé)
etatPresent=digitalRead(??); // lecture de la valeur actuelle
if ( ( etatPresent == ?? ) && ( etatPasse == ?? ) ) { // si appui alors ....
.....
}
delay(20); // est-ce obligatoire ???
}
</source>
dans laquelle on remplacera le "delay(20)" par l'affichage des deux dés. Cela devient un peu lent mais suffisant pour nos propos.

Cours:Eval Mecatro

2017-07-03T14:08:03Z

Sisternas :

[[Cours:Eval_Mecatro_corr|{{Vert|<big>Corrigé uniquement accessible aux enseignants</big>}}]]

L'objectif consiste à réaliser un dé avec un affichage sur sept segments en lieu et place des chiffres d'un dé de la vraie vie.
=Quelques évaluations d'expressions=
Vous disposez pour ce travail d'introduction du code suivant :
<source lang=C>
void setup(){
char i;
for (i=6;i<=13;i++) pinMode(i,OUTPUT); // Déclaration des 6 so
pinMode(2,INPUT);
}
void allumeLeds(unsigned char motif){
char i;
for (i=0;i<8;i++) {
digitalWrite(i+6,(motif>>i) & 1);
}
}
</source>
Il est capable d'allumer les LEDs en fonction de la valeur passée dans motif.
==Expressions booléennes==
La variable a (de type unsigned char) est initialisée à 0xC7.
Écrire un programme qui est capable de trouver la valeur des expressions booléennes en allumant ou pas une Led choisie par avance :
* (a & 0x80)== 0x80
* (a & 0x47)== 0x47

==Expression de décalage==
La variable a (de type unsigned char) est encore initialisée à 0xC7.
Écrire un programme qui est capable de trouver la valeur des expressions :
* a >> 2
* a << 3

=Réalisation du dé avec le shield de l'IUT=
Nous désirons réaliser un dé avec le shield que l'on utilise régulièrement à l'IUT. Les leds étant alignées, elles ne présentent pas une organisation facilement exploitable pour un affichage de type "dé à jouer". Nous décidons donc d'afficher directement le chiffre sur ''' un afficheur sept segments'''.

Nous allons utiliser un tableau précalculé de valeurs.Nous décidons d'utiliser la configuration du tableau ci-dessous.

{| class="wikitable"
|-
! Segment
|| pt || g || f || e || d || c || b || a
|-
|-
! Arduino Pin
|| 11 || 9 || 10 || 8 || 7 || 6 || 12 || 13
|-
! Port
|| PB3 || PB1 || PB2 || PB0 || PD7 || PD6 || PB4 || PB5
|}

On vous impose le sous programme suivant :
<source lang=c>
const char pinMux = 4;
const char pinAff[8]={13,12,6,7,8,10,9,11};
const char de[7]={/*A compléter les valeurs 0,1,2,3,4,5,6*/};

void affiche7seg(unsigned char v){
char i,s;
unsigned char c;
// boucle d'affichage :
for (i=0;i<8;i++) {
if ((v & (1<<i)) == (1<<i) ) digitalWrite(pinAff[i],1); // Modifie successivement l'état des segments a (ou patte 13)
else digitalWrite(pinAff[i],0);
}
}
</source>
Exercice 1 : calculer les valeurs pour afficher 0, 1, 2, 3, 4 , 5 et 6 et mettez-les dans le tableau à compléter.
==Affichage du tableau==
Exercice 2 : après ce calcul on fera un programme de test qui affiche toutes les secondes toutes les valeurs possibles du dé. On prendra bien soin de gérer la sélection de l'afficheur (de droite avec pinMux à 1).
<source lang=C>
void setup() {
// put your setup code here, to run once:
char i;
for (i=0;i<8;i++) pinMode(pinAff[i],OUTPUT); // Déclaration des 8 sorties des afficheurs
pinMode(pinMux,OUTPUT); // + sortie de multiplexage (choix de l'afficheur)
digitalWrite(??,??); // sur l'afficheur 1 : à compléter
}

void loop() {
// put your main code here, to run repeatedly:

}
</source>
L'étape suivante consiste à introduire de l'aléatoire pour que cela ressemble le plus possible à un vrai dé.

==Utilisation du pseudo aléatoire==
On vous propose le code suivant :
<source lang=C>
unsigned char pseudoAleat(int Lim) {
unsigned char Result;
static unsigned int Y=1;
Y = (Y * 32719 + 3) % 32749;
Result = ((Y % Lim)+1);//+1 : eviter 0
return Result;
}
</source>
Exercice 3 : Réaliser un programme qui fait défiler les valeurs de cette fonction pseudo aléatoire pour un appel avec un paramètre égal à 6 (qui vous permet d'avoir systématiquement des nombres entre 1 et 6 compris).

==Gestion du bouton de lancement==
===Description===

Le shield comporte 4 boutons, dont 2 possèdent une interruption spécifique. Chaque bouton est relié à une porte "non". Une fonction "trigger" sur les entrées permet de limiter les changements d'états impromptus (rebonds) lors du changement d'état des boutons.

Le tableau suivant donne les caractéristiques utiles :

{{Cours:ShieldinfoTableauBps}}

On utilisera le bouton B qui est en pullup sur PC0.

Exercice 4 : après avoir mis au point une boucle d'attente d'un appui sur le bouton B, réaliser le programme complet qui attend un appui du bouton B et appelle le générateur pseudo-aléatoire pour afficher le résultat.

==Gestion de deux dés==
C'est le bit PD4 du PORTD (appelé "pinMux" dans nos programmes) qui est responsable de la sélection d'un afficheur :
* PD4 = 1 c'est l'afficheur de droite qui est en action
* PD4 = 0 c'est l'afficheur de gauche qui est en action
Si vous voulez afficher deux valeurs, il vous faut les écrire en synchronisme avec la commutation des afficheurs. Cette commutation doit être réalisée à plus de 25 Hz pour un fonctionnement correct (sans scintillation pour les yeux).

Exercice 5 : Réaliser un programme qui affiche sur deux afficheurs deux résultats de la fonction pseudo-aléatoire. Il faut afficher pendant un certain temps pour que l’œil perçoive !
'''INDICATION''' : Le sous-programme ci-dessous affiche les deux valeurs et dure 400 ms
<source lang=C>
void affiche2Digits(char de2,char de1) {
char c;
for (c=0;c<20;c++) {
digitalWrite(pinMux,1); // sur l'afficheur unité
affiche7seg(de1);
delay(10);
digitalWrite(pinMux,0); // puis sur l'afficheur dizaine
affiche7seg(de2);
delay(10); }
}
</source>

Exercice 6 : Réaliser un programme complet qui attend que l'on appui sur le bouton B et qui alors utilise deux fois la fonction pseudo-aléatoire pour trouver la valeur des deux dé et qui affiche alors les deux valeurs sur les deux afficheurs.

'''Indication''' : il est impossible d'utiliser la boucle d'attente de l'exercice 4 car pendant l'attente, on perdrait l'affichage. Il faut donc utiliser la technique de détection de changement d'état :
<source lang=C>
void loop(){
etatPasse=etatPresent; // mémorise l'état précédent (le présent devient le passé)
etatPresent=digitalRead(??); // lecture de la valeur actuelle
if ( ( etatPresent == ?? ) && ( etatPasse == ?? ) ) { // si appui alors ....
.....
}
delay(20); // est-ce obligatoire ???
}
</source>
dans laquelle on remplacera le "delay(20)" par l'affichage des deux dés. Cela devient un peu lent mais suffisant pour nos propos.

Cours:Télémètre

2016-01-29T11:28:12Z

Sisternas :

[[Cours:TélémètreCorrection|Ressources enseignant]]

={{Rouge|Présentation du projet}}=
=={{Bleu|Objectif}}==
Ce projet consiste à réaliser un télémètre à ultrasons.

=={{Bleu|Notions de base}}==
[[Fichier:Telemetre.jpg|vignette|right| télémètre de chantier ]]
[[Fichier:Transducteurs US.jpg|vignette|left|transducteurs ultrasons]]

Un télémètre est un instrument qui permet de mesurer la distance séparant un observateur d'un point éloigné par des procédés optiques , acoustiques ou radioélectriques et qui est employé par exemple par les photographes, géomètres et géographes ainsi que dans l'armée et l'aviation.

L'ultrason (US) est une onde mécanique et élastique, diffusée par les gaz, les liquides, les tissus mous (chair, organes) ou les solides. La gamme de fréquences des ultrasons se situe entre 16 000 et 10 000 000 Hertz donc trop élevées pour être perçues par l'oreille humaine.

La mesure par ultrasons utilise un ensemble composé de deux transducteurs (un émetteur et un récepteur), parfois dans le même élément, associé à une électronique de contrôle.

={{Rouge|Principe du télémètre}}=
[[Fichier:Reflexion US.jpg|vignette|left|mesure par réflexion]]
Le télémètre à ultrason émet un signal à une fréquence en ultra-sonique et attend le retour d'un écho provoqué par la réflexion de l'onde émise. La distance est mesurée à partir de la vitesse de propagation de l'onde et du temps qui sépare la génération du signal et la réception de l'écho.
La vitesse du son dans l'air est de 342 m/s à 20°C ( 331 m/s à 0° C).

=={{Bleu|Autres applications des ultrasons}}==
[[Fichier:Controle de pièce.jpg|400px||thumb|right|contrôle de pièce par ultrasons]]
[[Fichier:Echographie.jpg|180px|vignette|left|Echographie médicale]]
Les ultrasons sont utilisés pour mesurer les distances, mais aussi dans le domaine médical pour les échographies et industriel pour la recherche de défauts ( crack sur le dessin ) dans des pièces métalliques

=={{Bleu|Principe de mesure}}==
Il est basé sur la mesure du temps écoulé entre l’émission et le retour de l’écho. Lors de la commande de mesure, le télémètre met le chronomètre à zéro puis commence l’émission d'une salve ultrasonique. L’onde ultrasonore se propage à la vitesse du son dans l’air environnant, soit 342m/sec. Dès qu’un obstacle est rencontré, l'écho revient vers le transducteur qui stoppe le chronomètre dès réception du signal. Le résultat sortant du chronomètre est proportionnel à la distance parcourue par l'onde. Il suffit donc de le convertir en mètres pour connaître la mesure, puis de l'afficher.

 

={{Rouge|Cahier des charges technique :}}=

=={{Bleu|Caratéristiques :}}==
*Commande de la mesure par appui sur bouton poussoir 
*affichage du résultat sur un écran LCD 
*alimentation autonôme 
*distance mesurée : de 1cm à 1 m 
*précision : +/- 1 mm 

=={{Bleu|Principe de la mesure par ultrason :}}==
[[Fichier:Telemetre N1.jpg|600px]]

{|class="wikitable"
|-
|style="vertical-align:top;"|{{Vert|PRODUIRE une SALVE :}}|| la salve sera produite par un appui sur un bouton poussoir.

Ses caractéristiques ( fréquence et amplitude )dépendront de celles du transducteur.

|-
|style="vertical-align:top;"|{{Vert|EMETTRE une onde US :}}||
|-
|style="vertical-align:top;"|{{Vert|RECEVOIR une onde US :}}||
|-
|style="vertical-align:top;"|{{Vert|DETECTER le premier écho :}}|| cette fonction assure l'élimination des échos suivants et/ou des parasites.

Le signal issu du récepteur est ensuite amplifié plusieurs dizaines de fois.
|-
|style="width:15em;vertical-align:top;"|{{Vert|MESURER le temps :}}|| mesure le temps entre le signal émis et la réception de sa réverbération.
|-
|style="vertical-align:top;"|{{Vert|CONVERTIR en mètres :}}||
|-
|style="vertical-align:top;"|{{Vert|AFFICHER le résultat :}}|| affiche la mesure sur un afficheur 4 digits.
|}

=={{Bleu|Structure du télémètre}}==
Le télémètre sera conçu autour d'une carte à micro-contrôleur ATtiny 2313 et d'un module Emetteur/Récepteur à ultrason de type HC SR04. L'affichage de la mesure s'effectuera grâce à un afficheur 7 segments 4 digits CC04-41SURKWA.

[[Fichier:Hc-sr04.jpg|250px|left|module E/R ultrason]]

[[Fichier:ATtiny2313.JPG||250px|center|microcontrôleur ATMEL]]

[[Fichier:Afficheur CC04-41.JPG||250px|afficheur 4 digits]]

=={{Bleu|Description des fonctions secondaires}}==
[[Fichier:Principe avec module US.jpg|900px|]]

[[Fichier:Working-of-HC-SR04-Ultrasonic-Sensor.jpg|vignette|600px|center|fonctionnement de l'émetteur/récepteur ultrason HC-SR04]]

 

={{Rouge|Organisation du travail :}}=

==={{Vert|Organisation du travail}}===

Le travail s'effectuera en binôme sur 7 semaines suivant le calendrier ci-dessous : 

{| class="wikitable"
|-
! n° de séance !! !! Détail de l'attendu
|-
| align="center" | 1 || ''' ''' || Étude théorique des fonctions
|-
| align="center" | 2 || ''' ''' || Étude des fonctions/programmes (tests)
|-
| align="center" | 3 || '''Saisie''' || Étude (validation) et saisie du schéma
|-
| align="center" | 4 || '''Routage''' || Validation du schéma et routage de la carte électronique
|-
| align="center" | 5 || '''Fabrication''' || Brasage des composants
|-
| align="center" | 6 || '''Vérification''' || Tests et dépannage de la carte
|-
| align="center" | 7 || '''Programmation''' || Mesure des performances de la carte réalisée
|}

'''Quelques conseils :'''

Répartissez le travail au sein du groupe dès le début du projet et testez les différentes fonctions programmées à l'aide d'une carte Arduino parallèlement à la fabrication (ne pas attendre que la carte soit terminée pour aborder la partie programmation). 

Inspirez-vous des structures étudiées au premier semestre en électronique, en séances de TP ou en ER et testez les structures au fur et à mesure. 

==={{Vert|Saisie du schéma}}===

La relative simplicité de l'étude doit vous amener à approfondir votre réflexion sur le schéma de votre carte et notamment sur les points suivants :
*comment allez-vous '''programmer''' le µcontrôleur ?
*comment choisir les '''meilleurs pattes''' du µcontrôleur
*où '''placer''' la résistance de shunt

'''Quelques éléments de réponse :'''
{| class="wikitable"
|-
| ISP || In System Programming : la plupart des µcontrôleurs modernes dont celui-ci sont programmables directement sur la carte (in situ).

Il faut donc prévoir le connecteur de programmation et le relier au composant en respectant l'ordre de câblage.

Vous utiliserez, comme Atmel le préconise, le connecteur ISP à 6 broches.
||
[[Fichier:Avr isp.jpg|vignette]]

|-
| choix des pattes || L'avantage d'utiliser un composant programmable est de pouvoir placer (dans une certaine mesure) les entrées et sorties où bon nous semble.

Attention cependant, il faut garder à l'esprit que le programme sera plus complexe à écrire s'il n'y a pas un minimum de réflexion.

|| Il est avantageux de placer les commandes de tous les segments [a,b,...,g] sur le même port. La commande du segment associé au point de l'afficheur pourra être sur un port différent.
|-
| Pins réservées || La patte {{Rouge|RESET}} principalement, ne peut servir qu'à cet usage !!

|| Dans le cas contraire, vous ne pourrez plus reprogrammer le microcontrôleur.
|}

==={{Vert|Routage}}===

Il est bien évident que vous devez essayer de respecter les conseils de bases pour réaliser une bonne carte électronique.

Rappelons également qu'une partie de ce dossier est dédiée aux contraintes de fabrication, qu'il convient sans doute à ce stade de relire !

={{Rouge| Quelques conseils concernant la programmation de l'afficheur}}=

=={{Vert|Premier test}}==

L'objectif est ici de faire clignoter au moins un segment. Ceci permettra de vérifier au minimum :
*que vous arrivez à programmer le µcontrôleur
*qu'il est possible de commander un segment
*que vous avez configuré la bonne fréquence d'horloge

Le programme ressemblera sans doute au suivant :

<source lang=c>
#define F_CPU xxxxxxxxxxUL
#include <avr/io.h>
#include <util/delay.h>
//déclaration des constantes et variables globales

int main(void)
{
// déclaration des variables locales

// phase de configuration du µcontrôleur (e/s, ... )

// boucle infinie
while(1)
{
// il y aura sans doute une attente quelque part !
_delay_ms(xxx);
}
}
</source>

=={{Vert|Afficheur 7 segments}}==

La première phase est réalisée, passons à des choses plus sérieuses ! Il faudrait maintenant exploiter les afficheurs et y afficher les différents symboles nécessaires (les chiffres en somme !).

Il va falloir écrire un tableau de transcodage comme vous l'avez déjà réalisé en informatique S1 ou en logique S1.

{{Todo|Commencer par faire un compteur sur seulement 1 digit (donc de 0 à 9 !)}}

<source lang=c>
#define F_CPU xxxxxxxxxxUL
#include <avr/io.h>
#include <util/delay.h>
//déclaration des constantes et variables globales

const unsigned char aff7[10]={...}; /// tableau de transcodage qui donnera les valeurs à placer sur le port correspondant aux segements

int main(void)
{
// déclaration des variables locales
int i=0;

// phase de configuration du µcontrôleur (e/s, ... )

// on sélectionne l'un des digits
PORTx = ... ;

// boucle infinie
while(1)
{
// il y aura sans doute une attente quelque part !
_delay_ms(xxx);
if (i==9) i=0; else i++;
}
}
</source>

{{Todo|Encore un peu de travail et vous avez un compteur de 0 à 9999 : il faut penser à afficher alternativement unité, dizaine, centaine, millier !}}

<source lang=c>
#define F_CPU xxxxxxxxxxUL
#include <avr/io.h>
#include <util/delay.h>
//déclaration des constantes et variables globales

const unsigned char aff7[10]={...}; /// tableau de transcodage qui donnera les valeurs à placer sur le port correspondant aux segements

int main(void)
{
// déclaration des variables locales
int i=0;

// phase de configuration du µcontrôleur (e/s, ... )

// boucle infinie
while(1)
{
for (j=0;j<5;j++) // donne la vitesse de comptage
{
// sélection unité et valeur à afficher
PORTx = ... ;
PORTy = aff7[i];
_delay_ms(xxx);
// sélection dizaine et valeur à afficher
PORTx = ... ;
PORTy = aff7[i];
_delay_ms(xxx);
....
}
if (i==9) i=0; else i++;
}
}
</source>

{{Todo|Et enfin, on déclare une fonction affiche() qui permettra de rendre le programme plus lisible}}

<source lang=c>
#define F_CPU xxxxxxxxxxUL
#include <avr/io.h>
#include <util/delay.h>
//déclaration des constantes et variables globales

const unsigned char aff7[10]={...}; /// tableau de transcodage qui donnera les valeurs à placer sur le port correspondant aux segments

static void affiche(unsigned int n)
{
// fonction d'affichage d'un nombre sur l'afficheur
// il affichera successivement les unité puis dizaine, centaine et enfin millier

}

int main(void)
{
// déclaration des variables locales
int i=0,j;

// phase de configuration du µcontrôleur (e/s, ... )

// boucle infinie
while(1)
{
for (j=0;j<5;j++) // donne la vitesse de comptage
{
affiche(i);
}
if (i==9999) i=0; else i++;
}
}
</source>

={{Rouge|Composants utilisés}}=

{| class="wikitable sortable"
|-
! Nom !! Type !! Boîtier !! Librairie Eagle !! Référence eagle !! Documentation !! Fournisseur !! Référence
|-

|-
| Rx|| Résistances || CMS ||rcl ||R1206 || || Farnell ||

|-
| Cx|| Condensateurs || CMS ||rcl ||C1206 || || Farnell ||

|-
| CPOL|| Condensateurs 150µF 6.3V || CMS ||rcl ||SMC_D || || Farnell ||

|-
| Xn|| Connecteur 2 bornes à vis || ||con-wago-500 ||W237-102 || || Farnell ||

|}

Cours:Télémètre

2016-01-29T11:21:12Z

Sisternas :

[[Cours:TélémètreCorrection|Ressources enseignant]]

={{Rouge|Présentation du projet}}=
=={{Bleu|Objectif}}==
Ce projet consiste à réaliser un télémètre à ultrasons.

=={{Bleu|Notions de base}}==
[[Fichier:Telemetre.jpg|vignette|right| télémètre de chantier ]]
[[Fichier:Transducteurs US.jpg|vignette|left|transducteurs ultrasons]]

Un télémètre est un instrument qui permet de mesurer la distance séparant un observateur d'un point éloigné par des procédés optiques , acoustiques ou radioélectriques et qui est employé par exemple par les photographes, géomètres et géographes ainsi que dans l'armée et l'aviation.

L'ultrason (US) est une onde mécanique et élastique, diffusée par les gaz, les liquides, les tissus mous (chair, organes) ou les solides. La gamme de fréquences des ultrasons se situe entre 16 000 et 10 000 000 Hertz donc trop élevées pour être perçues par l'oreille humaine.

La mesure par ultrasons utilise un ensemble composé de deux transducteurs (un émetteur et un récepteur), parfois dans le même élément, associé à une électronique de contrôle.

={{Rouge|Principe du télémètre}}=
[[Fichier:Reflexion US.jpg|vignette|left|mesure par réflexion]]
Le télémètre à ultrason émet un signal à une fréquence en ultra-sonique et attend le retour d'un écho provoqué par la réflexion de l'onde émise. La distance est mesurée à partir de la vitesse de propagation de l'onde et du temps qui sépare la génération du signal et la réception de l'écho.
La vitesse du son dans l'air est de 342 m/s à 20°C ( 331 m/s à 0° C).

=={{Bleu|Autres applications des ultrasons}}==
[[Fichier:Controle de pièce.jpg|400px||thumb|right|contrôle de pièce par ultrasons]]
[[Fichier:Echographie.jpg|180px|vignette|left|Echographie médicale]]
Les ultrasons sont utilisés pour mesurer les distances, mais aussi dans le domaine médical pour les échographies et industriel pour la recherche de défauts ( crack sur le dessin ) dans des pièces métalliques

=={{Bleu|Principe de mesure}}==
Il est basé sur la mesure du temps écoulé entre l’émission et le retour de l’écho. Lors de la commande de mesure, le télémètre met le chronomètre à zéro puis commence l’émission d'une salve ultrasonique. L’onde ultrasonore se propage à la vitesse du son dans l’air environnant, soit 342m/sec. Dès qu’un obstacle est rencontré, l'écho revient vers le transducteur qui stoppe le chronomètre dès réception du signal. Le résultat sortant du chronomètre est proportionnel à la distance parcourue par l'onde. Il suffit donc de le convertir en mètres pour connaître la mesure, puis de l'afficher.

 

={{Rouge|Cahier des charges technique :}}=

=={{Bleu|Caratéristiques :}}==
*Commande de la mesure par appui sur bouton poussoir 
*affichage du résultat sur un écran LCD 
*alimentation autonôme 
*distance mesurée : de 1cm à 1 m 
*précision : +/- 1 mm 

=={{Bleu|Principe de la mesure par ultrason :}}==
[[Fichier:Telemetre N1.jpg|600px]]

{|class="wikitable"
|-
|style="vertical-align:top;"|{{Vert|PRODUIRE une SALVE :}}|| la salve sera produite par un appui sur un bouton poussoir.

Ses caractéristiques ( fréquence et amplitude )dépendront de celles du transducteur.

|-
|style="vertical-align:top;"|{{Vert|EMETTRE une onde US :}}||
|-
|style="vertical-align:top;"|{{Vert|RECEVOIR une onde US :}}||
|-
|style="vertical-align:top;"|{{Vert|DETECTER le premier écho :}}|| cette fonction assure l'élimination des échos suivants et/ou des parasites.

Le signal issu du récepteur est ensuite amplifié plusieurs dizaines de fois.
|-
|style="width:15em;vertical-align:top;"|{{Vert|MESURER le temps :}}|| mesure le temps entre le signal émis et la réception de sa réverbération.
|-
|style="vertical-align:top;"|{{Vert|CONVERTIR en mètres :}}||
|-
|style="vertical-align:top;"|{{Vert|AFFICHER le résultat :}}|| affiche la mesure sur un afficheur 4 digits.
|}

=={{Bleu|Structure du télémètre}}==
Le télémètre sera conçu autour d'une carte à micro-contrôleur ATtiny 2313 et d'un module Emetteur/Récepteur à ultrason de type HC SR04. L'affichage de la mesure s'effectuera grâce à un afficheur 7 segments 4 digits CC04-41SURKWA.

[[Fichier:Hc-sr04.jpg|250px|left|module E/R ultrason]]

[[Fichier:ATtiny2313.JPG||250px|center|microcontrôleur ATMEL]]

[[Fichier:Afficheur CC04-41.JPG||250px|afficheur 4 digits]]

=={{Bleu|Description des fonctions secondaires}}==
[[Fichier:Principe avec module US.jpg|900px|]]

[[Fichier:Working-of-HC-SR04-Ultrasonic-Sensor.jpg|vignette|600px|center|fonctionnement de l'émetteur/récepteur ultrason HC-SR04]]

 

={{Rouge|Organisation du travail :}}=

==={{Vert|Organisation du travail}}===

Le travail s'effectuera en binôme sur 7 semaines suivant le calendrier ci-dessous : 

{| class="wikitable"
|-
! n° de séance !! !! Détail de l'attendu
|-
| align="center" | 1 || ''' ''' || Étude théorique des fonctions
|-
| align="center" | 2 || ''' ''' || Étude des fonctions/programmes (tests)
|-
| align="center" | 3 || '''Saisie''' || Étude (validation) et saisie du schéma
|-
| align="center" | 4 || '''Routage''' || Validation du schéma et routage de la carte électronique
|-
| align="center" | 5 || '''Fabrication''' || Brasage des composants
|-
| align="center" | 6 || '''Vérification''' || Tests et dépannage de la carte
|-
| align="center" | 7 || '''Programmation''' || Mesure des performances de la carte réalisée
|}

Il est vivement conseillé de répartir le travail au sein du groupe dès le début du projet et de tester les différentes fonctions programmées à l'aide d'une carte Arduino parallèlement à la fabrication (ne pas attendre que la carte soit terminée pour aborder la partie programmation).

==={{Vert|Saisie du schéma}}===

La relative simplicité de l'étude doit vous amener à approfondir votre réflexion sur le schéma de votre carte et notamment sur les points suivants :
*comment allez-vous '''programmer''' le µcontrôleur ?
*comment choisir les '''meilleurs pattes''' du µcontrôleur
*où '''placer''' la résistance de shunt

'''Quelques éléments de réponse :'''
{| class="wikitable"
|-
| ISP || In System Programming : la plupart des µcontrôleurs modernes dont celui-ci sont programmables directement sur la carte (in situ).

Il faut donc prévoir le connecteur de programmation et le relier au composant en respectant l'ordre de câblage.

Vous utiliserez, comme Atmel le préconise, le connecteur ISP à 6 broches.
||
[[Fichier:Avr isp.jpg|vignette]]

|-
| choix des pattes || L'avantage d'utiliser un composant programmable est de pouvoir placer (dans une certaine mesure) les entrées et sorties où bon nous semble.

Attention cependant, il faut garder à l'esprit que le programme sera plus complexe à écrire s'il n'y a pas un minimum de réflexion.

|| Il est avantageux de placer les commandes de tous les segments [a,b,...,g] sur le même port. La commande du segment associé au point de l'afficheur pourra être sur un port différent.
|-
| Pins réservées || La patte {{Rouge|RESET}} principalement, ne peut servir qu'à cet usage !!

|| Dans le cas contraire, vous ne pourrez plus reprogrammer le microcontrôleur.
|}

==={{Vert|Routage}}===

Il est bien évident que vous devez essayer de respecter les conseils de bases pour réaliser une bonne carte électronique.

Rappelons également qu'une partie de ce dossier est dédiée aux contraintes de fabrication, qu'il convient sans doute à ce stade de relire !

={{Rouge|Étude du projet}}=

L'étude consiste à proposer et à tester des structures répondant aux différentes fonctions. 

Il est conseillé de s'inspirer des structures étudiées au premier semestre en électronique, en séances de TP ou en ER et de tester les structures au fur et à mesure. 

'''Travaillez en parallèle''' : distribuez vous le travail au sein du groupe afin d'être le plus efficace possible. 

=={{Bleu| Quelques conseils concernant la programmation de l'afficheur}}==

==={{Vert|Premier test}}===

L'objectif est ici de faire clignoter au moins un segment. Ceci permettra de vérifier au minimum :
*que vous arrivez à programmer le µcontrôleur
*qu'il est possible de commander un segment
*que vous avez configuré la bonne fréquence d'horloge

Le programme ressemblera sans doute au suivant :

<source lang=c>
#define F_CPU xxxxxxxxxxUL
#include <avr/io.h>
#include <util/delay.h>
//déclaration des constantes et variables globales

int main(void)
{
// déclaration des variables locales

// phase de configuration du µcontrôleur (e/s, ... )

// boucle infinie
while(1)
{
// il y aura sans doute une attente quelque part !
_delay_ms(xxx);
}
}
</source>

==={{Vert|Afficheur 7 segments}}===

La première phase est réalisée, passons à des choses plus sérieuses ! Il faudrait maintenant exploiter les afficheurs et y afficher les différents symboles nécessaires (les chiffres en somme !).

Il va falloir écrire un tableau de transcodage comme vous l'avez déjà réalisé en informatique S1 ou en logique S1.

{{Todo|Commencer par faire un compteur sur seulement 1 digit (donc de 0 à 9 !)}}

<source lang=c>
#define F_CPU xxxxxxxxxxUL
#include <avr/io.h>
#include <util/delay.h>
//déclaration des constantes et variables globales

const unsigned char aff7[10]={...}; /// tableau de transcodage qui donnera les valeurs à placer sur le port correspondant aux segements

int main(void)
{
// déclaration des variables locales
int i=0;

// phase de configuration du µcontrôleur (e/s, ... )

// on sélectionne l'un des digits
PORTx = ... ;

// boucle infinie
while(1)
{
// il y aura sans doute une attente quelque part !
_delay_ms(xxx);
if (i==9) i=0; else i++;
}
}
</source>

{{Todo|Encore un peu de travail et vous avez un compteur de 0 à 9999 : il faut penser à afficher alternativement unité, dizaine, centaine, millier !}}

<source lang=c>
#define F_CPU xxxxxxxxxxUL
#include <avr/io.h>
#include <util/delay.h>
//déclaration des constantes et variables globales

const unsigned char aff7[10]={...}; /// tableau de transcodage qui donnera les valeurs à placer sur le port correspondant aux segements

int main(void)
{
// déclaration des variables locales
int i=0;

// phase de configuration du µcontrôleur (e/s, ... )

// boucle infinie
while(1)
{
for (j=0;j<5;j++) // donne la vitesse de comptage
{
// sélection unité et valeur à afficher
PORTx = ... ;
PORTy = aff7[i];
_delay_ms(xxx);
// sélection dizaine et valeur à afficher
PORTx = ... ;
PORTy = aff7[i];
_delay_ms(xxx);
....
}
if (i==9) i=0; else i++;
}
}
</source>

{{Todo|Et enfin, on déclare une fonction affiche() qui permettra de rendre le programme plus lisible}}

<source lang=c>
#define F_CPU xxxxxxxxxxUL
#include <avr/io.h>
#include <util/delay.h>
//déclaration des constantes et variables globales

const unsigned char aff7[10]={...}; /// tableau de transcodage qui donnera les valeurs à placer sur le port correspondant aux segments

static void affiche(unsigned int n)
{
// fonction d'affichage d'un nombre sur l'afficheur
// il affichera successivement les unité puis dizaine, centaine et enfin millier

}

int main(void)
{
// déclaration des variables locales
int i=0,j;

// phase de configuration du µcontrôleur (e/s, ... )

// boucle infinie
while(1)
{
for (j=0;j<5;j++) // donne la vitesse de comptage
{
affiche(i);
}
if (i==9999) i=0; else i++;
}
}
</source>

={{Rouge|Composants utilisés}}=

{| class="wikitable sortable"
|-
! Nom !! Type !! Boîtier !! Librairie Eagle !! Référence eagle !! Documentation !! Fournisseur !! Référence
|-

|-
| Rx|| Résistances || CMS ||rcl ||R1206 || || Farnell ||

|-
| Cx|| Condensateurs || CMS ||rcl ||C1206 || || Farnell ||

|-
| CPOL|| Condensateurs 150µF 6.3V || CMS ||rcl ||SMC_D || || Farnell ||

|-
| Xn|| Connecteur 2 bornes à vis || ||con-wago-500 ||W237-102 || || Farnell ||

|}

Cours:Télémètre

2016-01-29T11:10:35Z

Sisternas : /* {{Rouge|Organisation du travail :}} */

[[Cours:TélémètreCorrection|Ressources enseignant]]

={{Rouge|Présentation du projet}}=
=={{Bleu|Objectif}}==
Ce projet consiste à réaliser un télémètre à ultrasons.

=={{Bleu|Notions de base}}==
[[Fichier:Telemetre.jpg|vignette|right| télémètre de chantier ]]
[[Fichier:Transducteurs US.jpg|vignette|left|transducteurs ultrasons]]

Un télémètre est un instrument qui permet de mesurer la distance séparant un observateur d'un point éloigné par des procédés optiques , acoustiques ou radioélectriques et qui est employé par exemple par les photographes, géomètres et géographes ainsi que dans l'armée et l'aviation.

L'ultrason (US) est une onde mécanique et élastique, diffusée par les gaz, les liquides, les tissus mous (chair, organes) ou les solides. La gamme de fréquences des ultrasons se situe entre 16 000 et 10 000 000 Hertz donc trop élevées pour être perçues par l'oreille humaine.

La mesure par ultrasons utilise un ensemble composé de deux transducteurs (un émetteur et un récepteur), parfois dans le même élément, associé à une électronique de contrôle.

={{Rouge|Principe du télémètre}}=
[[Fichier:Reflexion US.jpg|vignette|left|mesure par réflexion]]
Le télémètre à ultrason émet un signal à une fréquence en ultra-sonique et attend le retour d'un écho provoqué par la réflexion de l'onde émise. La distance est mesurée à partir de la vitesse de propagation de l'onde et du temps qui sépare la génération du signal et la réception de l'écho.
La vitesse du son dans l'air est de 342 m/s à 20°C ( 331 m/s à 0° C).

=={{Bleu|Autres applications des ultrasons}}==
[[Fichier:Controle de pièce.jpg|400px||thumb|right|contrôle de pièce par ultrasons]]
[[Fichier:Echographie.jpg|180px|vignette|left|Echographie médicale]]
Les ultrasons sont utilisés pour mesurer les distances, mais aussi dans le domaine médical pour les échographies et industriel pour la recherche de défauts ( crack sur le dessin ) dans des pièces métalliques

=={{Bleu|Principe de mesure}}==
Il est basé sur la mesure du temps écoulé entre l’émission et le retour de l’écho. Lors de la commande de mesure, le télémètre met le chronomètre à zéro puis commence l’émission d'une salve ultrasonique. L’onde ultrasonore se propage à la vitesse du son dans l’air environnant, soit 342m/sec. Dès qu’un obstacle est rencontré, l'écho revient vers le transducteur qui stoppe le chronomètre dès réception du signal. Le résultat sortant du chronomètre est proportionnel à la distance parcourue par l'onde. Il suffit donc de le convertir en mètres pour connaître la mesure, puis de l'afficher.

 

={{Rouge|Cahier des charges technique :}}=

=={{Bleu|Caratéristiques :}}==
*Commande de la mesure par appui sur bouton poussoir 
*affichage du résultat sur un écran LCD 
*alimentation autonôme 
*distance mesurée : de 1cm à 1 m 
*précision : +/- 1 mm 

=={{Bleu|Principe de la mesure par ultrason :}}==
[[Fichier:Telemetre N1.jpg|600px]]

{|class="wikitable"
|-
|style="vertical-align:top;"|{{Vert|PRODUIRE une SALVE :}}|| la salve sera produite par un appui sur un bouton poussoir.

Ses caractéristiques ( fréquence et amplitude )dépendront de celles du transducteur.

|-
|style="vertical-align:top;"|{{Vert|EMETTRE une onde US :}}||
|-
|style="vertical-align:top;"|{{Vert|RECEVOIR une onde US :}}||
|-
|style="vertical-align:top;"|{{Vert|DETECTER le premier écho :}}|| cette fonction assure l'élimination des échos suivants et/ou des parasites.

Le signal issu du récepteur est ensuite amplifié plusieurs dizaines de fois.
|-
|style="width:15em;vertical-align:top;"|{{Vert|MESURER le temps :}}|| mesure le temps entre le signal émis et la réception de sa réverbération.
|-
|style="vertical-align:top;"|{{Vert|CONVERTIR en mètres :}}||
|-
|style="vertical-align:top;"|{{Vert|AFFICHER le résultat :}}|| affiche la mesure sur un afficheur 4 digits.
|}

=={{Bleu|Structure du télémètre}}==
Le télémètre sera conçu autour d'une carte à micro-contrôleur ATtiny 2313 et d'un module Emetteur/Récepteur à ultrason de type HC SR04. L'affichage de la mesure s'effectuera grâce à un afficheur 7 segments 4 digits CC04-41SURKWA.

[[Fichier:Hc-sr04.jpg|250px|left|module E/R ultrason]]

[[Fichier:ATtiny2313.JPG||250px|center|microcontrôleur ATMEL]]

[[Fichier:Afficheur CC04-41.JPG||250px|afficheur 4 digits]]

=={{Bleu|Description des fonctions secondaires}}==
[[Fichier:Principe avec module US.jpg|900px|]]

[[Fichier:Working-of-HC-SR04-Ultrasonic-Sensor.jpg|vignette|600px|center|fonctionnement de l'émetteur/récepteur ultrason HC-SR04]]

 

={{Rouge|Organisation du travail :}}=

==={{Vert|Organisation du travail}}===

Le travail s'effectuera en binôme sur 7 semaines suivant le calendrier ci-dessous : 

{| class="wikitable"
|-
! n° de séance !! !! Détail de l'attendu
|-
| align="center" | 1 || ''' ''' || Étude théorique des fonctions
|-
| align="center" | 2 || ''' ''' || Étude des fonctions/programmes (tests)
|-
| align="center" | 3 || '''Saisie''' || Étude (validation) et saisie du schéma
|-
| align="center" | 4 || '''Routage''' || Validation du schéma et routage de la carte électronique
|-
| align="center" | 5 || '''Fabrication''' || Brasage des composants
|-
| align="center" | 6 || '''Vérification''' || Tests et dépannage de la carte
|-
| align="center" | 7 || '''Programmation''' || Mesure des performances de la carte réalisée
|}

Il est vivement conseillé de répartir le travail au sein du groupe dès le début du projet et de tester les différentes fonctions programmées à l'aide d'une carte Arduino parallèlement à la fabrication (ne pas attendre que la carte soit terminée pour aborder la partie programmation).

==={{Vert|Saisie du schéma}}===

La relative simplicité de l'étude doit vous amener à approfondir votre réflexion sur le schéma de votre carte et notamment sur les points suivants :
*comment allez-vous '''programmer''' le µcontrôleur ?
*comment choisir les '''meilleurs pattes''' du µcontrôleur
*où '''placer''' la résistance de shunt

'''Quelques éléments de réponse :'''
{| class="wikitable"
|-
| ISP || In System Programming : la plupart des µcontrôleurs modernes dont celui-ci sont programmables directement sur la carte (in situ).

Il faut donc prévoir le connecteur de programmation et le relier au composant en respectant l'ordre de câblage.

Vous utiliserez, comme Atmel le préconise, le connecteur ISP à 6 broches.
||
[[Fichier:Avr isp.jpg|vignette]]

|-
| choix des pattes || L'avantage d'utiliser un composant programmable est de pouvoir placer (dans une certaine mesure) les entrées et sorties où bon nous semble.

Attention cependant, il faut garder à l'esprit que le programme sera plus complexe à écrire s'il n'y a pas un minimum de réflexion.

|| Il est avantageux de placer les commandes de tous les segments [a,b,...,g] sur le même port. La commande du segment associé au point de l'afficheur pourra être sur un port différent.
|-
| Pins réservées || La patte {{Rouge|RESET}} principalement, ne peut servir qu'à cet usage !!

|| Dans le cas contraire, vous ne pourrez plus reprogrammer le microcontrôleur.
|}

==={{Vert|Routage}}===

Il est bien évident que vous devez essayer de respecter les conseils de bases pour réaliser une bonne carte électronique.

Rappelons également qu'une partie de ce dossier est dédiée aux contraintes de fabrication, qu'il convient sans doute à ce stade de relire !

={{Rouge|Étude du projet}}=

L'étude consiste à proposer et à tester des structures répondant aux différentes fonctions. 

Il est conseillé de s'inspirer des structures étudiées au premier semestre en électronique, en séances de TP ou en ER et de tester les structures au fur et à mesure. 

'''Travaillez en parallèle''' : distribuez vous le travail au sein du groupe afin d'être le plus efficace possible. 

={{Rouge|Composants utilisés}}=

{| class="wikitable sortable"
|-
! Nom !! Type !! Boîtier !! Librairie Eagle !! Référence eagle !! Documentation !! Fournisseur !! Référence
|-

|-
| Rx|| Résistances || CMS ||rcl ||R1206 || || Farnell ||

|-
| Cx|| Condensateurs || CMS ||rcl ||C1206 || || Farnell ||

|-
| CPOL|| Condensateurs 150µF 6.3V || CMS ||rcl ||SMC_D || || Farnell ||

|-
| Xn|| Connecteur 2 bornes à vis || ||con-wago-500 ||W237-102 || || Farnell ||

|}

Cours:Télémètre

2016-01-29T11:07:54Z

Sisternas : /* {{Vert|Organisation du travail}} */

Cours:Télémètre

2016-01-29T11:00:37Z

Sisternas : /* {{Rouge|Organisation du travail :}} */

Cours:Télémètre

2016-01-29T10:53:52Z

Sisternas :

Cours:Télémètre

2016-01-29T10:44:44Z

Sisternas :

Cours:Télémètre

2016-01-29T07:40:15Z

Sisternas :

Fichier:Principe avec module US.jpg

2016-01-28T17:38:00Z

Sisternas :

Fichier:Working-of-HC-SR04-Ultrasonic-Sensor.jpg

2016-01-28T17:37:34Z

Sisternas : fonctionnement du HC SR04

fonctionnement du HC SR04

Fichier:Hc-sr04.jpg

2016-01-28T17:36:47Z

Sisternas : module Ultrason HC-SR04

module Ultrason HC-SR04

Cours:Télémètre

2016-01-28T17:01:55Z

Sisternas :

[[Cours:TélémètreCorrection|Ressources enseignant]]

={{Rouge|Présentation du projet}}=
=={{Bleu|Objectif}}==
Ce projet consiste à réaliser un télémètre à ultrasons.

=={{Bleu|Notions de base}}==
[[Fichier:Telemetre.jpg|vignette|right| télémètre de chantier ]]
[[Fichier:Transducteurs US.jpg|vignette|left|transducteurs ultrasons]]

Un télémètre est un instrument qui permet de mesurer la distance séparant un observateur d'un point éloigné par des procédés optiques , acoustiques ou radioélectriques et qui est employé par exemple par les photographes, géomètres et géographes ainsi que dans l'armée et l'aviation.

L'ultrason (US) est une onde mécanique et élastique, diffusée par les gaz, les liquides, les tissus mous (chair, organes) ou les solides. La gamme de fréquences des ultrasons se situe entre 16 000 et 10 000 000 Hertz donc trop élevées pour être perçues par l'oreille humaine.

La mesure par ultrasons utilise un ensemble composé de deux transducteurs (un émetteur et un récepteur), parfois dans le même élément, associé à une électronique de contrôle.

={{Rouge|Principe du télémètre}}=
[[Fichier:Reflexion US.jpg|vignette|left|mesure par réflexion]]
Le télémètre à ultrason émet un signal à une fréquence en ultra-sonique et attend le retour d'un écho provoqué par la réflexion de l'onde émise. La distance est mesurée à partir de la vitesse de propagation de l'onde et du temps qui sépare la génération du signal et la réception de l'écho.
La vitesse du son dans l'air est de 342 m/s à 20°C ( 331 m/s à 0° C).

=={{Bleu|Autres applications des ultrasons}}==
[[Fichier:Controle de pièce.jpg|400px||thumb|right|contrôle de pièce par ultrasons]]
[[Fichier:Echographie.jpg|180px|vignette|left|Echographie médicale]]
Les ultrasons sont utilisés pour mesurer les distances, mais aussi dans le domaine médical pour les échographies et industriel pour la recherche de défauts ( crack sur le dessin ) dans des pièces métalliques

=={{Bleu|Principe de mesure}}==
Il est basé sur la mesure du temps écoulé entre l’émission et le retour de l’écho. Lors de la commande de mesure, le télémètre met le chronomètre à zéro puis commence l’émission d'une salve ultrasonique. L’onde ultrasonore se propage à la vitesse du son dans l’air environnant, soit 342m/sec. Dès qu’un obstacle est rencontré, l'écho revient vers le transducteur qui stoppe le chronomètre dès réception du signal. Le résultat sortant du chronomètre est proportionnel à la distance parcourue par l'onde. Il suffit donc de le convertir en mètres pour connaître la mesure, puis de l'afficher.

 

={{Rouge|Cahier des charges technique :}}=

=={{Bleu|Caratéristiques :}}==
*Commande de la mesure par appui sur bouton poussoir 
*affichage du résultat sur un écran LCD 
*alimentation autonôme 
*utilisation d'un module Emetteur/Récepteur à ultrason de type HC SR04 
*distance mesurée : de 1cm à 1 m 
*précision : +/- 1 mm 

=={{Bleu|Principe de la mesure par ultrason :}}==
[[Fichier:Telemetre N1.jpg|600px]]

{|class="wikitable"
|-
|style="vertical-align:top;"|{{Vert|PRODUIRE une SALVE :}}|| la salve sera produite par un appui sur un bouton poussoir.

Ses caractéristiques ( fréquence et amplitude )dépendront de celles du transducteur.

|-
|style="vertical-align:top;"|{{Vert|EMETTRE une onde US :}}|| l'émetteur est un MA40S4S du fabricant MURATA
|-
|style="vertical-align:top;"|{{Vert|RECEVOIR une onde US :}}|| Le récepteur est un MA40S4R du fabricant MURATA
|-
|style="vertical-align:top;"|{{Vert|DETECTER le premier écho :}}|| cette fonction devra assurer l'élimination des échos suivants et/ou des parasites.

Le signal issu du récepteur sera amplifié entre 10 et 200 fois.

On détectera son enveloppe qu'on comparera à une rampe de référence destinée à éliminer les échos et les parasites afin ne de détecter que le signal utile ( voir dessin ).
|-
|style="width:15em;vertical-align:top;"|{{Vert|MESURER le temps :}}|| entre le signal émis et la réception de sa réverbération.
|-
|style="vertical-align:top;"|{{Vert|CONVERTIR en mètres :}}|| la mesure devra être précise à +/-1mm
|-
|style="vertical-align:top;"|{{Vert|AFFICHER le résultat :}}|| l'affichage sur 4 digits se fera par l'intermédiaire du moniteur accessible par le biais de l'outil de développement Arduino.
|}

=={{Bleu|Structure du télémètre}}==
Le télémètre sera conçu autour d'une carte à micro-contrôleur ATtiny 2313 et d'un module Emetteur/Récepteur à ultrason de type HC SR04. L'affichage de la mesure s'effectuera grâce à un afficheur 7 segments 4 digits CC04-41SURKWA.

=={{Bleu|Description des fonctions secondaires}}==
[[Fichier:Telemetre D2.jpg]]

[[Fichier:telemetre signaux.jpg|vignette|300px|left|signaux du télémètre]]

{|class="wikitable"
|-
|style="vertical-align:top;"|{{Vert|GENERATEUR de SALVE :}}|| produit une salve de à .... Hz à chaque appui sur un bouton poussoir.
|-
|style="vertical-align:top;"|{{Vert|AMPLIFICATEUR émission :}}|| assure le doublement de la tension grâce à un pont en H à transistors bipolaires
|-
|style="vertical-align:top;"|{{Vert|EMETTEUR US :}}|| émetteur MA40S4S du fabricant MURATA
|-
|style="vertical-align:top;"|{{Vert|RECEPTEUR US :}}|| récepteur MA40S4R du fabricant MURATA
|-
|style="vertical-align:top;"|{{Vert|AMPLIFICATEUR réception :}}|| amplifie le signal issu du récepteur entre 10 et 200 fois ( réglable )
|-
|style="vertical-align:top;"|{{Vert|DETECTEUR d'enveloppe :}}|| restitue l'enveloppe du signal reçu
|-
|style="vertical-align:top;"|{{Vert|GENERATEUR de RAMPE :}}|| génère une rampe négative représentant le gabarit minimum du signal à percevoir afin d'éliminer les parasites et ne détecter que le signal utile ( voir dessin ). 

La rampe est réinitialisée à chaque commande.
|-

|style="width:15em;vertical-align:top;"|{{Vert|COMPARATEUR :}}|| compare l'enveloppe du signal détecté à la rampe afin de détecter le signal reçu.
|-

|style="width:15em;vertical-align:top;"|{{Vert|BASE de temps :}}|| produit un signal périodique représentatif du temps
|-
|style="width:15em;vertical-align:top;"|{{Vert|COMPTEUR :}}|| détermine le temps entre la commande de mesure et le retour du signal ( ce temps est caratéristique de la distance parcourue ) . 
Le comptage démarre lors de la commande et s'arrête lors de la réception du signal. 
|-
|style="vertical-align:top;"|{{Vert|CONVERTISSEUR :}}|| convertit le temps en distance
|-
|style="vertical-align:top;"|{{Vert|TRANSMISSION :}}|| permet la transmission du résultat au moniteur sur l'écran du PC
|-
|style="vertical-align:top;"|{{Vert|AFFICHEUR le résultat :}}|| affichage le résultat sur 4 digits sur l'écran de l'ordinateur.
|}

 

={{Rouge|Organisation du travail :}}=
travail en binôme sur 7 semaines 

'''1ère semaine''' : 
* Présentation des projets et choix 
* Etude des transducteurs : 
* Recherche des caractéristiques de fonctionnement des transducteurs ( tension et fréquence ) 
* Tests : mise en oeuvre d'un émetteur et d'un récepteur ( portée, influence de la fréquence, influence de la tension )
* Recherche documentaire sur les "pont en H à transistors bipolaires" 
* Recherche documentaire "amplificateur à gain variable" ( 10 < amplification < 200 ) 

'''2ème semaine : ''' 
* Tests : mise en oeuvre d'un "pont en H à transistors bipolaires" 
* Tests : mise en oeuvre d'un "amplificateur à gain variable" 
* Recherche documentaire sur la structure "détecteur d'enveloppe" 
* Recherche documentaire sur la structure "comparateur" 

'''3ème semaine :''' 
* Tests : structure "comparateur" 
* Tests : structure "détecteur d'enveloppe" 
* Fonction programmée " génération d'une salve" 

'''4ème semaine :''' 
* Fin des tests fonctionnels 
* Saisie du schéma et routage 
* Programmation 
conseils pour le routage :
** ne pas utiliser les bornes DIGITAL 0 et 1 de la carte Arduino ( car elles servent pour la programmation ) 
** utiliser les bornes DIGITAL 2 et 3 pour détecter le signal ( car elles permettent de gérer des interruptions ) 

'''5ème semaine :''' 
* Routage /Programmation 
* Tirage du PCB 

'''6ème semaine :''' 
* Montage / Programmation 

'''7ème semaine :''' 
Intégration / Tests finaux 

={{Rouge|Composants utilisés}}=

{| class="wikitable sortable"
|-
! Nom !! Type !! Boîtier !! Librairie Eagle !! Référence eagle !! Documentation !! Fournisseur !! Référence
|-
| MA40S4S* || Émetteur US || traversant ||con-wago-500 ||W237-102 || [http://www.farnell.com/datasheets/484560.pdf MA40S4S.pdf] || Farnell || [http://fr.farnell.com/murata/ma40s4s/capteur-ultrasonic-0-2-4m-tx/dp/1777667?Ntt=1777667 1777667]

|-
| MA40S4R* || Récepteur US || traversant ||con-wago-500 ||W237-102 || [http://www.farnell.com/datasheets/484560.pdf MA40S4R.pdf] || Farnell || [http://fr.farnell.com/murata/ma40s4r/capteur-ultrasonic-0-2-4m-rx/dp/1777668 1777668]

|-
| TL081 ID || 1 AOp || CMS || || || [http://www.farnell.com/datasheets/1846992.pdf TL081] || Farnell || [http://fr.farnell.com/jsp/search/results.jsp?N=0&Ntk=partnumbers&Ntt=TL081ID&Ntx=mode+matchall&ref=lookahead 1459712]

|-
| TL082 CD*|| 2 AOp || CMS ||linear ||TL082D (TL082) ||[http://www.farnell.com/datasheets/1846992.pdf TL082] || Farnell || [http://fr.farnell.com/jsp/search/results.jsp?N=0&Ntk=partnumbers&Ntt=TL082CD&Ntx=mode+matchall&ref=lookahead 1103183]

|-
| MC33201 || AOp rail to rail || CMS || || ||[http://www.farnell.com/datasheets/62229.pdf MC33201] || Farnell || [http://fr.farnell.com/on-semiconductor/mc33201dg/ampli-op-cms-alim-simple/dp/9666656?ref=lookahead 9666656]

|-
| LM311 D* || comparateur || CMS ||linear ||LM311D (LM311) ||[http://www.farnell.com/datasheets/1831041.pdf LM311] || Farnell ||[http://fr.farnell.com/jsp/search/results.jsp?N=0&Ntk=partnumbers&Ntt=LM311D&Ntx=mode+matchall&ref=lookahead 2293183]

|-
| LM339 AD || 4 AOp || CMS || || ||[http://www.farnell.com/datasheets/1633630.pdf LM339] || Farnell ||[http://fr.farnell.com/jsp/search/results.jsp?N=0&Ntk=partnumbers&Ntt=LM339AD&Ntx=mode+matchall&ref=lookahead 2293717]

|-
| BC 856B*|| Transistor PNP || CMS ||transistor-pnp ||BC856BSMD (BC856*) || [http://www.farnell.com/datasheets/1662680.pdf BC856] || Farnell || [http://fr.farnell.com/jsp/search/results.jsp?N=0&Ntk=partnumbers&Ntt=BC856B&Ntx=mode+matchall&ref=lookahead 17198065]

|-
| BC 807|| Transistor PNP || CMS || || || [http://www.farnell.com/datasheets/1702498.pdf BC807] || Farnell || [http://fr.farnell.com/jsp/search/results.jsp?N=0&Ntk=partnumbers&Ntt=BC807&Ntx=mode+matchall&ref=lookahead 1798082 ]

|-
| BC 817|| Transistor NPN || CMS || || ||[http://www.farnell.com/datasheets/1702509.pdf BC817] || Farnell || [http://fr.farnell.com/jsp/search/results.jsp?N=0&Ntk=partnumbers&Ntt=BC817&Ntx=mode+matchall&ref=lookahead 1798076]

|-
| BC 846 B*|| Transistor NPN || CMS ||transistor-npn ||BC846BSMD (BC846*) || [http://www.farnell.com/datasheets/1685296.pdf BC846] || Farnell || [http://fr.farnell.com/jsp/search/results.jsp?N=0&Ntk=partnumbers&Ntt=BC846B&Ntx=mode+matchall&ref=lookahead 1798074 ]

|-
| BAT60J*|| Diode de commutation || CMS ||diode ||SOD323_ST || [http://www.farnell.com/datasheets/1689728.pdf BAT60J] || Farnell ||[http://fr.farnell.com/stmicroelectronics/bat60jfilm/diode-schottky-3a-10v-cms-sot-323/dp/1467544RL 1467544]

|-
| TS4148|| Diode de signal || CMS || || || || Farnell ||[http://fr.farnell.com/jsp/search/results.jsp?N=0&Ntk=partnumbers&Ntt=TS4148+RX&Ntx=mode+matchall&ref=lookahead 8150214]

|-
| Rx|| Résistances || CMS ||rcl ||R1206 || || Farnell ||

|-
| Cx|| Condensateurs || CMS ||rcl ||C1206 || || Farnell ||

|-
| CPOL|| Condensateurs 150µF 6.3V || CMS ||rcl ||SMC_D || || Farnell ||

|-
| Xn|| Connecteur 2 bornes à vis || ||con-wago-500 ||W237-102 || || Farnell ||

|}

Cours:EtatFilPilote

2016-01-27T17:04:36Z

Sisternas :

[[Cours:EtatFilPiloteCorrection|Ressources enseignant]]

={{Rouge|Présentation du projet}}=

Un fil pilote est un conducteur utilisé pour transmettre des commandes à des appareils raccordés sur le secteur. 

Les commandes envoyées sur le fil pilote permettent de définir le mode de fonctionnement des appareils qui les reçoivent. 

L'avantage du fil pilote est que l'information n'est transmise que sur un seul fil, le retour étant assuré par le conducteur "Neutre" qui est aussi utilisé pour alimenté l'appareil. 

Le signal envoyé sur le fil pilote est généré par un appareil spécifique. Les signaux de commande ont la particularité d'être "fabriqués" directement à partir de la tension 230V du réseau. 

<gallery>
Fil-pilote.gif|signaux de commande
Cablage fil pilote.jpg|principe de fonctionnement
</gallery>
Par exemple, les radiateurs électriques raccordés à un même fil pilote, pourront basculer simultanément du mode "Hors gel" au mode "Eco".

=={{Bleu|Objectif}}==

Le projet consiste à fabriquer une carte électronique capable de décoder les signaux de commande et d'afficher le signal transmis à l'aide d'une led.

=={{Bleu|Découpage fonctionnel}}==

=={{Bleu|Contraintes de fabrication}}==

La carte utilisera un microcontrôleur ATtiny2313. 

Le signal issu du fil pilote sera isolé par un optocoupleur. 

Les six modes de fonctionnement seront matérialisés par six LED. 

={{Rouge|Travail attendu}}=

=={{Bleu|Objectif}}==

L'objectif sera bien évidemment de terminer le projet de sorte qu'il réponde au cahier des charges décrit précédemment.

Pour ce faire, il conviendra de :
*'''rechercher des solutions''' à partir du schéma fonctionnel fourni ( schéma électronique et composants )
*'''dimensionner''' les composants utilisés
*'''tester''' les différents blocs fonctionnels
*'''fabriquer''' la carte électronique
*'''programmer''' les composants
*'''valider''' le fonctionnement

Vous serez évalué sur la fabrication de la carte électronique, ainsi que sur un dossier qui devra :
*détailler les différentes '''fonctions'''
*expliquer les '''choix''' effectués (structure,composants ....)
*utiliser des '''courbes ou mesures''' pour appuyer les explications
*donner une estimation (hors temps de conception) du '''coût''' de la carte électronique

=={{Bleu|Planning à respecter}}==

Vous serez évalué tout au long du projet en début de séance. Ce qui vous permettra de terminer en dehors des séances le travail que vous n'aurez pas achevé.

Une chose importante à noter : {{Rouge|'''Il vous revient de saisir au fur et à mesure le schéma des différentes fonctions étudiées dès que possible'''.}}

Vous trouverez ci dessous l'avancement attendu des différentes séances. Notons également que vous devrez '''achever votre travail après les 7 séances''' si le projet n'est pas terminé.

De plus, '''le routage''' devra être fait en bonne partie '''en dehors des séances'''.

{| class="wikitable"
|-
! n° de séance !! !! Détail de l'attendu
|-
| align="center" | 1 || ''' ''' || Étude
|-
| align="center" | 2 || ''' ''' || Étude
|-
| align="center" | 3 || '''Saisie''' || Étude, validation et saisie
|-
| align="center" | 4 || '''Routage''' || Validation du routage et schéma de la carte électronique
|-
| align="center" | 5 || '''Fabrication''' || Brasage des composants
|-
| align="center" | 6 || '''Vérification''' || Tests et dépannage de la carte
|-
| align="center" | 7 || '''Programmation''' || Mesure des performances de la carte réalisée
|}

={{Rouge|Étude du projet}}=

L'étude consiste à proposer et à tester des structures répondant aux différentes fonctions. 

Il est conseillé de s'inspirer des structures étudiées au premier semestre en électronique, en séances de TP ou en ER et de tester les structures au fur et à mesure. 

'''Travaillez en parallèle''' : distribuez vous le travail au sein du groupe afin d'être le plus efficace possible. 

=={{Bleu|Fabrication de la carte électronique}}==

==={{Vert|Saisie du schéma}}===

Comme précisé en introduction, le schéma devrait à ce point être déjà bien avancé.

La relative simplicité de l'étude doit vous amener à approfondir votre réflexion sur le schéma de votre carte et notamment sur les points suivants :
*comment allez-vous '''programmer''' le µcontrôleur ?
*comment '''choisir judicieusement les pattes''' du µcontrôleur

==={{Vert|Routage}}===

Il est bien évident que vous devez essayer de respecter les conseils de bases pour réaliser une bonne carte électronique.

Rappelons également qu'une partie de ce dossier est dédiée aux contraintes de fabrication, qu'il convient sans doute à ce stade de relire !

={{Rouge|Conception du programme}}=

L'absence de liaisons série disponible sur la carte implique une mise au point plus complexe liée à l'absence d'un débugger.

=={{Bleu|Compilation}}==

Vous utiliserez un éditeur de texte quelconque (gedit par ex) pour créer votre programme (fichier test.c par ex). L'étape de compilation s'effectuera en "ligne de commande" de la façon suivante :

<source lang=bash>
avr-gcc -Wall -g -Os -mmcu=attiny2313 -o test.o test.c
avr-objcopy -j .text -j .data -O ihex test.o test.hex
avrdude -c avrisp2 -P usb -p t2313 -U flash:w:"test.hex"
</source>

={{Rouge|Composants utilisés}}=

{| class="wikitable sortable"
|-
! Nom !! Type !! Boîtier !! Librairie Eagle !! Référence eagle !! Documentation !! Fournisseur !! Référence
|-
| ISP || barrette mâle sécable|| traversant || con-lstb || MA03-2 || || ||
|}

Fichier:Ordre fil pilote3.jpg

2016-01-27T16:04:18Z

Sisternas : 4 ORDRES

4 ORDRES

Cours:EtatFilPilote

2016-01-27T15:58:58Z

Sisternas :

[[Cours:EtatFilPiloteCorrection|Ressources enseignant]]

={{Rouge|Présentation du projet}}=

Un fil pilote est un conducteur utilisé pour transmettre des commandes à des appareils raccordés sur le secteur.
Les commandes envoyées sur le fil pilote permettent de définir le mode de fonctionnement des appareils qui les reçoivent.
L'avantage du fil pilote est que l'information n'est transmise que sur un seul fil, le retour étant assuré par le conducteur "Neutre".

Par exemple, un radiateur électrique à fil pilote, pourra se mettre automatiquement en

Un décodeur pour fil pilote est un système destiné à commander un appareil raccordé sur le secteur à partir d'informations transmises sur un conducteur appelé "fil pilote".
Les informations transmises sur le fil pilote définissent l'état dans lequel

=={{Bleu|Objectif}}==

=={{Bleu|Découpage fonctionnel}}==

=={{Bleu|Contraintes de fabrication}}==

={{Rouge|Travail attendu}}=

=={{Bleu|Objectif}}==

L'objectif sera bien évidemment de terminer le projet de sorte qu'il réponde au cahier des charges décrit précédemment.

Pour ce faire, il conviendra de :
*'''dimensionner''' les composants utilisés
*'''tester''' les différents blocs fonctionnels
*'''fabriquer''' la carte électronique
*'''programmer''' les composants
*'''valider''' le fonctionnement

Vous serez évalué sur la fabrication de la carte électronique, ainsi que sur un dossier qui devra :
*détailler les différentes '''fonctions'''
*expliquer les '''choix''' effectués (structure,composants ....)
*utilisera des '''courbes ou mesures''' pour appuyer les explications
*donnera une estimation (hors temps de conception) du '''coût''' de la carte électronique

=={{Bleu|Planning à respecter}}==

Vous serez évalué tout au long du projet en début de séance. Ce qui vous permet de terminer en dehors des séances si vous n'avez pas achevé le travail demandé.

Une chose importante à noter : {{Rouge|'''Il vous revient de saisir au fur et à mesure le schéma des différentes fonctions étudiées dès que possible'''.}}

Vous trouverez ci dessous l'avancement attendu des différentes séances. Notons également que vous devrez '''achever votre travail après les 7 séances''' si le projet n'est pas terminé.

De plus, '''le routage''' devra être fait en bonne partie '''en dehors des séances'''.

{| class="wikitable"
|-
! n° de séance !! Fonction !! Détail de l'attendu
|-
| align="center" | 1 || ''' ''' || Étude
|-
| align="center" | 2 || ''' ''' || Étude
|-
| align="center" | 3 || '''Saisie''' || Étude, validation et saisie
|-
| align="center" | 4 || '''Routage''' || Validation du routage et schéma de la carte électronique
|-
| align="center" | 5 || '''Fabrication''' || VBrasage des composants
|-
| align="center" | 6 || '''Vérification''' || Tests et dépannage de la carte
|-
| align="center" | 7 || '''Programmation''' || Mesure des performances de la carte réalisée
|}

={{Rouge|Étude du projet}}=

=={{Bleu|A rédiger !}}==

=={{Bleu|Fabrication de la carte électronique}}==

==={{Vert|Saisie du schéma}}===

Comme précisé en introduction, le schéma devrait à ce point être déjà bien avancé.

La relative simplicité de l'étude doit vous amener à approfondir votre réflexion sur le schéma de votre carte et notamment sur les points suivants :
*comment allez-vous '''programmer''' le µcontrôleur ?
*comment choisir les '''meilleurs pattes''' du µcontrôleur

==={{Vert|Routage}}===

Il est bien évident que vous devez essayer de respecter les conseils de bases pour réaliser une bonne carte électronique.

Rappelons également qu'une partie de ce dossier est dédiée aux contraintes de fabrication, qu'il convient sans doute à ce stade de relire !

={{Rouge|Conception du programme}}=

L'absence de liaisons série disponible sur la carte implique une mise au point (en l'absence de l'utilisation d'un débugger) plus complexe.

Afin de mettre au point progressivement le programme, il est sans doute sage de réaliser les étapes dans l'ordre indiqué !

Vous commencerez donc par commander les afficheurs et seulement après vous pourrez vous attelez au {{CAN}}

=={{Bleu|Compilation}}==

Vous utiliserez un éditeur de texte quelconque (gedit par ex) pour créer votre programme (fichier test.c par ex). L'étape de compilation s'effectuera en "ligne de commande" de la façon suivante :

<source lang=bash>
avr-gcc -Wall -g -Os -mmcu=attiny2313 -o test.o test.c
avr-objcopy -j .text -j .data -O ihex test.o test.hex
avrdude -c avrisp2 -P usb -p t2313 -U flash:w:"test.hex"
</source>

={{Rouge|Composants utilisés}}=

{| class="wikitable sortable"
|-
! Nom !! Type !! Boîtier !! Librairie Eagle !! Référence eagle !! Documentation !! Fournisseur !! Référence
|-
| ISP || barrette mâle sécable|| traversant || con-lstb || MA03-2 || || ||
|}

Cours:EtatFilPilote

2016-01-27T15:35:54Z

Sisternas : /* {{Rouge|Présentation du projet}} */

[[Cours:EtatFilPiloteCorrection|Ressources enseignant]]

={{Rouge|Présentation du projet}}=

Un fil pilote est un conducteur utilisé pour transmettre des commandes à des appareils raccordés sur le secteur.
Les
Un décodeur pour fil pilote est un système destiné à commander un appareil raccordé sur le secteur à partir d'informations transmises sur un conducteur appelé "fil pilote".
Les informations transmises sur le fil pilote définissent l'état dans lequel

=={{Bleu|Objectif}}==

=={{Bleu|Découpage fonctionnel}}==

=={{Bleu|Contraintes de fabrication}}==

={{Rouge|Travail attendu}}=

=={{Bleu|Objectif}}==

L'objectif sera bien évidemment de terminer le projet de sorte qu'il réponde au cahier des charges décrit précédemment.

Pour ce faire, il conviendra de :
*'''dimensionner''' les composants utilisés
*'''tester''' les différents blocs fonctionnels
*'''fabriquer''' la carte électronique
*'''programmer''' les composants
*'''valider''' le fonctionnement

Vous serez évalué sur la fabrication de la carte électronique, ainsi que sur un dossier qui devra :
*détailler les différentes '''fonctions'''
*expliquer les '''choix''' effectués (structure,composants ....)
*utilisera des '''courbes ou mesures''' pour appuyer les explications
*donnera une estimation (hors temps de conception) du '''coût''' de la carte électronique

=={{Bleu|Planning à respecter}}==

Vous serez évalué tout au long du projet en début de séance. Ce qui vous permet de terminer en dehors des séances si vous n'avez pas achevé le travail demandé.

Une chose importante à noter : {{Rouge|'''Il vous revient de saisir au fur et à mesure le schéma des différentes fonctions étudiées dès que possible'''.}}

Vous trouverez ci dessous l'avancement attendu des différentes séances. Notons également que vous devrez '''achever votre travail après les 7 séances''' si le projet n'est pas terminé.

De plus, '''le routage''' devra être fait en bonne partie '''en dehors des séances'''.

{| class="wikitable"
|-
! n° de séance !! Fonction !! Détail de l'attendu
|-
| align="center" | 1 || ''' ''' || Étude
|-
| align="center" | 2 || ''' ''' || Étude
|-
| align="center" | 3 || '''Saisie''' || Étude, validation et saisie
|-
| align="center" | 4 || '''Routage''' || Validation du routage et schéma de la carte électronique
|-
| align="center" | 5 || '''Fabrication''' || VBrasage des composants
|-
| align="center" | 6 || '''Vérification''' || Tests et dépannage de la carte
|-
| align="center" | 7 || '''Programmation''' || Mesure des performances de la carte réalisée
|}

={{Rouge|Étude du projet}}=

=={{Bleu|A rédiger !}}==

=={{Bleu|Fabrication de la carte électronique}}==

==={{Vert|Saisie du schéma}}===

Comme précisé en introduction, le schéma devrait à ce point être déjà bien avancé.

La relative simplicité de l'étude doit vous amener à approfondir votre réflexion sur le schéma de votre carte et notamment sur les points suivants :
*comment allez-vous '''programmer''' le µcontrôleur ?
*comment choisir les '''meilleurs pattes''' du µcontrôleur

==={{Vert|Routage}}===

Il est bien évident que vous devez essayer de respecter les conseils de bases pour réaliser une bonne carte électronique.

Rappelons également qu'une partie de ce dossier est dédiée aux contraintes de fabrication, qu'il convient sans doute à ce stade de relire !

={{Rouge|Conception du programme}}=

L'absence de liaisons série disponible sur la carte implique une mise au point (en l'absence de l'utilisation d'un débugger) plus complexe.

Afin de mettre au point progressivement le programme, il est sans doute sage de réaliser les étapes dans l'ordre indiqué !

Vous commencerez donc par commander les afficheurs et seulement après vous pourrez vous attelez au {{CAN}}

=={{Bleu|Compilation}}==

Vous utiliserez un éditeur de texte quelconque (gedit par ex) pour créer votre programme (fichier test.c par ex). L'étape de compilation s'effectuera en "ligne de commande" de la façon suivante :

<source lang=bash>
avr-gcc -Wall -g -Os -mmcu=attiny2313 -o test.o test.c
avr-objcopy -j .text -j .data -O ihex test.o test.hex
avrdude -c avrisp2 -P usb -p t2313 -U flash:w:"test.hex"
</source>

={{Rouge|Composants utilisés}}=

{| class="wikitable sortable"
|-
! Nom !! Type !! Boîtier !! Librairie Eagle !! Référence eagle !! Documentation !! Fournisseur !! Référence
|-
| ISP || barrette mâle sécable|| traversant || con-lstb || MA03-2 || || ||
|}

Arexx SIMONIN

2015-06-16T07:41:49Z

Sisternas : Page créée avec « Catégorie:Projets Tutorés S2 »

[[Catégorie:Projets Tutorés S2]]

Arexx MENAHO

2015-06-16T07:40:20Z

Sisternas : Page créée avec « Catégorie:Projets Tutorés S2 »

[[Catégorie:Projets Tutorés S2]]

Arexx SUPERHEROS

2015-06-16T07:39:46Z

Sisternas : Page créée avec « Catégorie:Projets Tutorés S2 »

[[Catégorie:Projets Tutorés S2]]

Arexx CONQUERANTS

2015-06-16T07:38:11Z

Sisternas : Page créée avec « Catégorie:Projets Tutorés S2 »

[[Catégorie:Projets Tutorés S2]]

Cours:BatakConceptionAfficheur

2015-06-09T09:10:21Z

Sisternas : /* {{Bleu|Segments des Afficheurs}} */

={{Rouge|Système Batak}}=

[[Cours:Batak_presentation_generale|Commencez par lire la description du système "Batak" sur ce lien !]]

={{Rouge|Cahier des charges}}=

=={{Bleu|Présentation de l'afficheur}}==

Le système d'entraînement de type Batak dispose d'un affichage permettant de connaître le temps qu'il reste à jouer ( ou le temps écoulé ) et le score du joueur. 

Cet affichage est réalisé par deux afficheurs 7 segments où les deux informations ( temps et score )apparaîtront alternativement. 

Chaque afficheur sera indépendant. Ils seront pilotés par un microcontrôleur grâce à un '''bus i2c'''. Les afficheurs seront raccordés entre eux par des connecteurs, ce qui permettra d'étendre l'affichage à 3 ou 4 digits si besoin, il faudra donc pouvoir '''définir l'adresse de chaque afficheur'''. 

Chaque segment sera réalisé par 4 LED, le point décimal par deux LED . 

Schéma de raccordement 

[[Image:Afficheur i2c - raccordements.jpg]]

=={{Bleu|TRAVAIL A REALISER}}==
Vous devez concevoir et fabriquer un afficheur puis vérifier son fonctionnement en le pilotant avec une carte Arduino UNO. 

={{Bleu|Contraintes de fabrication}}=

=={{Bleu|Contraintes générales}}==

*encombrement minimal 
*pistes les plus courtes possibles 
*largeur minimale des pistes conduisant aux LED : 0.4mm 
*prévoir au minimum 2 trous pour la fixation 
*côté dessus / recto 
**4 LED par segment 
**2 LED pour le point 
*côté dessous / verso 
**connecteur MOLEX côté BUS i2c ( en respectant la norme GEII pour le raccordement ) 
**connecteur femelle coudé ( compatible avec le connecteur MOLEX ) 
*'''tous les autres composants que les LED seront implantés côté verso''' 

=={{Bleu|Connexions}}==

L'alimentation sera fournie par la carte Arduino via le connecteur MOLEX 
Pour les raccordements sur le connecteur MOLEX, voir la page GEII correspondant 

=={{Bleu|Composants}}==

interface i2c : MCP230008

=={{Bleu|Segments des Afficheurs}}==

les segments devront impérativement être raccordés au MCP20008 conformément au tableau suivant :
{| class="wikitable"
|-
! segment !! N° de patte
|-
| a || 17
|-
| b || 12
|-
| c || 13
|-
| d || 14
|-
| e || 15
|-
| f || 16
|-
| g || 10
|-
| point || 11
|}

={{Rouge|Livrables}}=
*carte électronique testée
*programme
*dossier technique ( réalisation + programme commenté )

={{Rouge|Délais}}=
*{{Rouge|Le typon correspondant au routage doit être terminé au plus tard mercredi soir pour tirage jeudi matin à 9h30}}
*{{Rouge|La réalisation complète devra être validée avant lundi soir}}

Cours:BatakConceptionAfficheur

2015-06-09T06:31:01Z

Sisternas :

={{Rouge|Système Batak}}=

[[Cours:Batak_presentation_generale|Commencez par lire la description du système "Batak" sur ce lien !]]

={{Rouge|Cahier des charges}}=

=={{Bleu|Présentation de l'afficheur}}==

Le système d'entraînement de type Batak dispose d'un affichage permettant de connaître le temps qu'il reste à jouer ( ou le temps écoulé ) et le score du joueur. 

Cet affichage est réalisé par deux afficheurs 7 segments où les deux informations ( temps et score )apparaîtront alternativement. 

Chaque afficheur sera indépendant. Ils seront pilotés par un microcontrôleur grâce à un '''bus i2c'''. Les afficheurs seront raccordés entre eux par des connecteurs, ce qui permettra d'étendre l'affichage à 3 ou 4 digits si besoin, il faudra donc pouvoir '''définir l'adresse de chaque afficheur'''. 

Chaque segment sera réalisé par 4 LED, le point décimal par deux LED . 

Schéma de raccordement 

[[Image:Afficheur i2c - raccordements.jpg]]

=={{Bleu|TRAVAIL A REALISER}}==
Vous devez concevoir et fabriquer un afficheur puis vérifier son fonctionnement en le pilotant avec une carte Arduino UNO. 

={{Bleu|Contraintes de fabrication}}=

=={{Bleu|Contraintes générales}}==

*encombrement minimal 
*pistes les plus courtes possibles 
*largeur minimale des pistes conduisant aux LED : 0.4mm 
*prévoir au minimum 2 trous pour la fixation 
*côté dessus / recto 
**4 LED par segment 
**2 LED pour le point 
*côté dessous / verso 
**connecteur MOLEX côté BUS i2c ( en respectant la norme GEII pour le raccordement ) 
**connecteur femelle coudé ( compatible avec le connecteur MOLEX ) 
*'''tous les autres composants que les LED seront implantés côté verso''' 

=={{Bleu|Connexions}}==

L'alimentation sera fournie par la carte Arduino via le connecteur MOLEX 
Pour les raccordements sur le connecteur MOLEX, voir la page GEII correspondant 

=={{Bleu|Composants}}==

interface i2c : MCP230008

=={{Bleu|Segments des Afficheurs}}==

les segments devront impérativement être raccordés au MCP20008 conformément au tableau suivant :
{| class="wikitable"
|-
! segment !! N° de patte
|-
| a || 17
|-
| b || 12
|-
| c || 13
|-
| d || 14
|-| e || 15
|-
| f || 16
|-
| g || 10
|-
| point || 11
|}

={{Rouge|Livrables}}=
*carte électronique testée
*programme
*dossier technique ( réalisation + programme commenté )

={{Rouge|Délais}}=
*{{Rouge|Le typon correspondant au routage doit être terminé au plus tard mercredi soir pour tirage jeudi matin à 9h30}}
*{{Rouge|La réalisation complète devra être validée avant lundi soir}}

Cours:DomotiqueFilPilote

2015-06-09T06:29:54Z

Sisternas :

={{Rouge|Cahier des charges}}=

=={{Bleu|Présentation du fil pilote}}==

Les radiateurs électriques récents peuvent tous être pilotés à distance par l'intermédiaire d'un "fil pilote".

Physiquement, ce signal est véhiculé par un seul fil électrique, dont le potentiel va varier par rapport au neutre.

Les radiateurs gèrent un maximum de 6 ordres, récapitulés dans l'image suivante :

[[Image:Fil-pilote.gif]]

Les 2 derniers ordres, confort -1° et confort -2° ne sont pas pris en compte par tous les radiateurs. 

=={{Bleu|TRAVAIL A REALISER}}==

Vous allez concevoir et fabriquer une carte qui permettra la commande d'un radiateur répondant aux quatre premiers ordres d'une commande per fil pilote ( voir ci-avant ). Le choix de l'ordre se fera par l'intermédiaire d'un ordinateur qui le transmettra via une liaison série à une carte Arduino UNO, qui le transmettra à son tour à votre carte par une liaison i2c. 
le schéma ci-dessous illustre ce fonctionnement : 
[[Image:Cablage_fil_pilote.jpg]]

=={{Bleu|Découpage fonctionnel}}==

Vous allez utiliser le découpage fonctionnel du système tel que détaillé ci après. 
[[Image:Schema_fonctionnel_2.jpg]]

{{Todo|Le travail à réaliser consistera à proposer un schéma structurel pour chaque fonction, à valider son fonctionnement et à fabriquer la carte électronique.}} 

=={{Bleu|Détail des signaux}}==
Flèches {{Rouge|ROUGE}} : les signaux provenant du réseau 230V/50Hz. 
Flèches {{Bleu|BLEUES}} : les signaux provenant de la carte arduino UNO. 
Flèches {{Vert|VERTES}} : les signaux lumineux destinés à visualiser le mode de fonctionnement sélectionné. 

=={{Bleu|Description des fonctions}}==

<big>'''FP1'''</big> 
Le signal i2c est lu puis décodé par un circuit MCP23008 qui délivre deux types de signaux : 
*des signaux permettant d'activer le signal du fil pilote 
*des signaux permettant de commander l'affichage du mode sélectionné 

<big>'''FP2'''</big> 
Le mode sélectionné est affiché par l'intermédiaire de quatre LED 

<big>'''FP3'''</big> 
La tension 230V/50Hz du réseau est mise en forme pour générer les signaux de commande du fil pilote 

<big>'''FP4'''</big> 
Les tensions issues des FP3 sont combinées afin de produire le signal de commande du fil pilote 
La partie "courants faibles" est séparée de la partie 230V/50Hz par une isolation galvanique assurée par des coupleurs optiques 

=={{Rouge|Contraintes techniques}}==

*La carte devra être de la taille d'une carte Arduino UNO, afin de pouvoir être installée sur un rail DIN industriel grâce à un support qui vous sera fourni. 

*Elle disposera des connexions suivantes : 
**Entrées :
***I2C
***+5V continu
***230V AC
**Sorties :
***Bornes pour brancher les fils pilote 

*Les bornes connectées au réseau et au fil pilote seront de type "cosses FASTON". 
*Le raccordement à la liaison i2c s'effectuera à l'aide d'un connecteur MOLEX selon la norme définie en GEII ( voir documentation ) 
*La carte devra permettre le choix d'une adresse parmi 8 
*4 LED permettront de connaître le mode de fonctionnement sélectionné. 
*Les signaux 230V seront séparés autant que possible des signaux "courants faibles"( voir figure ci-dessous ). 

[[Image:Fil_pilote_implantation.jpg]]

'''Choix du mode de fonctionnement :''' 
*la commande "0" correspondra au mode "Confort" 

*la commande "1" correspondra au mode "Eco" 

*la commande "2" correspondra au mode "Hors gel" 

*la commande "3" correspondra au mode "Arrêt" 

'''Composants imposés: ''' 
*La partie I2C se composera juste d'un composant '''MCP23008''' 
*la fonction FP4 "isolation galvanique et activation" sera réalisée par des phototriacs '''MOC3041''' 
*Les bornes connectées au réseau et au fil pilote seront de type '''cosses FASTON'''. 
*Le raccordement à la liaison i2c s'effectuera à l'aide d'un '''connecteur MOLEX''' 
*'''4 LED''' permettront de connaître le mode de fonctionnement sélectionné. 

={{Rouge|Démarche à suivre}}=

Quelques conseils sur la démarche à suivre : 
*Effectuer une recherche documentaire pour définir les structures correspondant à chaque fonction 
{{Rouge|Il va sans dire que la lecture des documentations (datasheet) des composants utilisés est très utile !}}
 
*Tester chaque fonction individuellement 
{{Rouge|Pour tester le fonctionnement des parties "réseau" et "fil pilote", on utilisera une tension alternative de l'ordre de 20V crête à crête.}} 
*Réaliser le routage de la carte en respectant les règles de base suivantes : 
**pistes larges 
**pistes espacées 
**pistes courtes 
**{{Rouge|Séparer au maximum la partie puissance (230V) de la partie commande !}}

={{Rouge|Livrables}}=
*carte électronique testée
*programme
*dossier technique ( réalisation + programme commenté )

={{Rouge|Délais}}=
*{{Rouge|Le typon correspondant au routage doit être terminé au plus tard mercredi soir pour tirage jeudi matin à 9h30}}
*{{Rouge|La réalisation complète devra être validée avant lundi soir}}

Cours:BatakConceptionAfficheur

2015-06-09T06:26:18Z

Sisternas : /* {{Bleu|Segments des Afficheurs}} */

={{Rouge|Système Batak}}=

[[Cours:Batak_presentation_generale|Commencez par lire la description du système "Batak" sur ce lien !]]

={{Rouge|Cahier des charges}}=

=={{Bleu|Présentation de l'afficheur}}==

Le système d'entraînement de type Batak dispose d'un affichage permettant de connaître le temps qu'il reste à jouer ( ou le temps écoulé ) et le score du joueur. 

Cet affichage est réalisé par deux afficheurs 7 segments où les deux informations ( temps et score )apparaîtront alternativement. 

Chaque afficheur sera indépendant. Ils seront pilotés par un microcontrôleur grâce à un '''bus i2c'''. Les afficheurs seront raccordés entre eux par des connecteurs, ce qui permettra d'étendre l'affichage à 3 ou 4 digits si besoin, il faudra donc pouvoir '''définir l'adresse de chaque afficheur'''. 

Chaque segment sera réalisé par 4 LED, le point décimal par deux LED . 

Schéma de raccordement 

[[Image:Afficheur i2c - raccordements.jpg]]

=={{Bleu|TRAVAIL A REALISER}}==
Vous devez concevoir et fabriquer un afficheur puis vérifier son fonctionnement en le pilotant avec une carte Arduino UNO. 

={{Bleu|Contraintes de fabrication}}=

=={{Bleu|Contraintes générales}}==

*encombrement minimal 
*pistes les plus courtes possibles 
*largeur minimale des pistes conduisant aux LED : 0.4mm 
*prévoir au minimum 2 trous pour la fixation 
*côté dessus / recto 
**4 LED par segment 
**2 LED pour le point 
*côté dessous / verso 
**connecteur MOLEX côté BUS i2c ( en respectant la norme GEII pour le raccordement ) 
**connecteur femelle coudé ( compatible avec le connecteur MOLEX ) 
*'''tous les autres composants que les LED seront implantés côté verso''' 

=={{Bleu|Connexions}}==

L'alimentation sera fournie par la carte Arduino via le connecteur MOLEX 
Pour les raccordements sur le connecteur MOLEX, voir la page GEII correspondant 

=={{Bleu|Composants}}==

interface i2c : MCP230008

=={{Bleu|Segments des Afficheurs}}==

les segments devront impérativement être raccordés au MCP20008 conformément au tableau suivant :
{| class="wikitable"
|-
! segment !! N° de patte
|-
| a || 17
|-
| b || 12
|-
| c || 13
|-
| d || 14
|-| e || 15
|-
| f || 16
|-
| g || 10
|-
| point || 11
|}

Cours:BatakConceptionAfficheur

2015-06-09T06:21:28Z

Sisternas :

={{Rouge|Système Batak}}=

[[Cours:Batak_presentation_generale|Commencez par lire la description du système "Batak" sur ce lien !]]

={{Rouge|Cahier des charges}}=

=={{Bleu|Présentation de l'afficheur}}==

Le système d'entraînement de type Batak dispose d'un affichage permettant de connaître le temps qu'il reste à jouer ( ou le temps écoulé ) et le score du joueur. 

Cet affichage est réalisé par deux afficheurs 7 segments où les deux informations ( temps et score )apparaîtront alternativement. 

Chaque afficheur sera indépendant. Ils seront pilotés par un microcontrôleur grâce à un '''bus i2c'''. Les afficheurs seront raccordés entre eux par des connecteurs, ce qui permettra d'étendre l'affichage à 3 ou 4 digits si besoin, il faudra donc pouvoir '''définir l'adresse de chaque afficheur'''. 

Chaque segment sera réalisé par 4 LED, le point décimal par deux LED . 

Schéma de raccordement 

[[Image:Afficheur i2c - raccordements.jpg]]

=={{Bleu|TRAVAIL A REALISER}}==
Vous devez concevoir et fabriquer un afficheur puis vérifier son fonctionnement en le pilotant avec une carte Arduino UNO. 

={{Bleu|Contraintes de fabrication}}=

=={{Bleu|Contraintes générales}}==

*encombrement minimal 
*pistes les plus courtes possibles 
*largeur minimale des pistes conduisant aux LED : 0.4mm 
*prévoir au minimum 2 trous pour la fixation 
*côté dessus / recto 
**4 LED par segment 
**2 LED pour le point 
*côté dessous / verso 
**connecteur MOLEX côté BUS i2c ( en respectant la norme GEII pour le raccordement ) 
**connecteur femelle coudé ( compatible avec le connecteur MOLEX ) 
*'''tous les autres composants que les LED seront implantés côté verso''' 

=={{Bleu|Connexions}}==

L'alimentation sera fournie par la carte Arduino via le connecteur MOLEX 
Pour les raccordements sur le connecteur MOLEX, voir la page GEII correspondant 

=={{Bleu|Composants}}==

interface i2c : MCP230008

=={{Bleu|Segments des Afficheurs}}==

les segments devront impérativement être raccordés au MCP20008 conformément au tableau suivant :{| class="wikitable"|-! segment !! N° de patte |-| a || 17|-| b || 12|-| c || 13|-| d || 14|-| e || 15|-| f || 16|-| g || 10|-| point || 11|}

ProjetArrexGrp1

2015-02-27T14:20:50Z

Sisternas :

[[Catégorie:Projets Tutorés S2]]

=Présentation du projet=

ProjetArrexGrp1

2015-02-27T14:18:34Z

Sisternas : Page créée avec « Catégorie:Projets Tutorés S2 »

[[Catégorie:Projets Tutorés S2]]