Cours:MesureConsommationUSB

Ressources enseignant

Présentation du projet

Objectif

Erreur lors de la création de la miniature : /bin/bash: convert: command not found

Les différents types de connecteurs USB 1 et 2

Nous allons nous intéresser dans cette étude à la consommation d'appareils connectés en USB.

Comme vous le savez, il existe différentes normes USB qui ont apportés des débits en évolution constante, mais également différentes puissances disponibles.

Vous trouverez ces différentes puissances sur la page Wikipédia consacrée

Nous nous contenterons ici des normes USB1 et USB2 pour lesquelles l'alimentation présente une tension fixe de 5V.

Comme nous souhaitons observer "l'état" de l'alimentation fournie par le bus USB, nous allons devoir mesurer les grandeurs électriques associées soit :

• La tension d'alimentation qui aura donc une valeur proche de 5V
• Le courant consommé par l'appareil, qu'on supposera inférieure à 600mA

Description du module

Mise en place

L'utilisation du module devra être aussi simple que possible. Il viendra donc s'intercaler entre le maître (en général un ordinateur) et le périphérique.

Il serait bien évidemment possible de réaliser un petit boîtier avec 2 cordons USB, l'un permettant de se connecter sur l'ordinateur et l'autre sur le périphérique, à l'exemple de l'image ci-contre.

Nous choisirons plutôt de réaliser un module avec 2 connecteurs de type A à souder, l'un femelle et l'autre mâle. Le module sera donc directement connecté sur l'ordinateur, et il suffira de brancher, comme à l'habitude, le cordon du périphérique sur notre module.

Comportement vis à vis de l'USB

Fonction Couleur Numéro de broche pour les types A et B Alimentation +5 (VBUS) Rouge 1 Données (D-) Blanc 2 Données (D+) Vert 3 Masse (GND) Noir 4

Le module devra être transparent pour les signaux USB, c'est à dire qu'il ne devra ni modifier ni observer les fils de données. Les fils de données relieront donc directement le connecteur mâle "d'entrée", au connecteur femelle de "sortie" du module. Le module devra limiter sa consommation afin de ne pas modifier le fonctionnement, et il devra indiquer uniquement la consommation du périphérique et ne pas tenir compte de sa propre consommation.

Interface avec l'utilisateur

Le module sera autonome, c'est à dire :

• que l'utilisateur ne pourra pas interagir avec le boîtier de mesure
• il faudra prévoir un affichage des informations

Le choix se porte sur des afficheurs 4 digits, et l'affichage se fera, suivant la grandeur mesurée, de la façon suivante :

Type de mesure	digits 3 à 1	digit 0 : unité
Tension	valeur en V	V
Intensité	valeur en mA	A

Découpage fonctionnel

Nous allons détailler ci dessous les différents blocs fonctionnels représentés sur la figure précédente.

Il convient de garder à l'esprit que nous représentons ici des fonctions et non des composants. De ce fait, plusieurs fonctions peuvent très bien (tout ou partie) être réalisées par le même composant.

Description des blocs fonctionnels :

• Mesure de Tension
  • Convertir la tension Vbus en une valeur numérique
  • Entrée : Vbat proche de 5V
  • Sortie : Un, nombre codé sur 10 bits
• Mesure de Courant
  • Convertir l'intensité du courant Ibus en une valeur numérique
  • Entrée : Ibus inférieure à 600mA
  • Sortie : In, nombre codé sur 10 bits
• Gestion
  • Gérer l'affichage et sélectionner l'une ou l'autre des grandeurs
  • Entrée : Un et In, nombres codés sur 10 bits
  • Sortie : Commande des segments des afficheurs
• Affichage
  • Commander l'état de l'afficheur 7 segments 4 digits
  • Entrée : État des différents segments
  • Sortie : Information lumineuse

Contraintes de fabrication

Passé ces premières explications, un point important de ce module est la réalisation de la carte électronique associée.

Comparativement à d'autres systèmes, il est bien évident que certaines contraintes supplémentaires sont à prendre en compte ici, à savoir

• Praticité d'utilisation du module
• Possibilité de connecter le module sur l'ordinateur
• Facilité de connexion du périphérique à observer
• Facilité de lecture des grandeurs mesurées
• Absence d'interférences avec le fonctionnement du port USB
• coût contenu de la carte électronique
• les pistes nécessaires à la mesure du courant seront les plus courtes possibles

Travail attendu

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

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 : 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.

n° de séance	Fonction	Détail de l'attendu
1	Affichage	Étude documentaire des afficheurs et algorigramme pour leur utilisation
2	Mesures	Étude de le méthode de mesure de tension et courant et algorigramme associé
3	Routage	Validation du routage et schéma de la carte électronique
4	Fabrication	Brasage des composants
5	Programmation	Vérification du fonctionnement des afficheurs
6	Programmation	Acquisition des grandeurs électriques
7	Vérification	Mesure des performances de la carte réalisée

Étude du projet

Préambule

Le point le plus important à comprendre dans ce projet est l'organisation des différents composants autour d'un microcontrôleur.

Nous allons en quelque sorte greffer autour les composants nécessaires à la réalisation des différentes fonctions, telles que listées dans l'étude fonctionnelle.

Le microcontrôleur retenu est un attiny261A.

On vous demande de chercher les informations suivantes sur le microcontrôleur :

• Nombre d'entrées/sorties disponibles
• Nombre et position d'entrées analogiques

Gardez sous le coude la datasheet de ce composant dont vous aurez besoin par la suite et attaquez la rédaction de votre rapport avec les informations demandées.

Affichage des informations

Nous allons utiliser un afficheur 7 segments 4 digits qui sera relié au microcontrôleur.

Après avoir lu la page du site www.sonelec-musique.com et en sachant qu'il convient de conserver 3 entrées analogiques sur le µcontrôleur, proposer un schéma de principe permettant de piloter les afficheurs.

Il convient désormais

• d'adapter ce schéma à l'afficheur sélectionné
• de calculer la valeur des résistances nécessaires.

Remarque : On rappelle ici que la seule alimentation disponible provient de l'USB donc 5V.

Une fois le schéma choisit ainsi que la valeur des résistances calculées, vérifiez le fonctionnement à l'aide d'une carte arduino

Vous essaierez simplement de piloter individuellement les afficheurs afin de vérifier que vous pouvez :

• afficher et éteindre chaque segment
• piloter individuellement chaque digit
• multiplexer suffisamment rapidement pour avoir une impression visuelle d'affichage simultané

Arrivé au terme de cette partie, il convient d'écrire un algorigramme qui détaillera le principe d'utilisation de l'afficheur par le µcontrôleur.

Nous resterons ici sur une description de haut niveau, en utilisant par exemple un bloc décodeur 7 segments que vous avez utilisé en module M1102(logique) mais aussi en module M1103(informatique).

Écrire un algorigramme permettant d'afficher successivement la valeur

• de la tension. Ex d'affichage souhaité pour une tension de 4,89V : 489U
• du courant. Ex d'affichage souhaité pour une intensité de 52mA : 052A

Mesure de courant (et de tension !)

choix de la structure

Nous allons, dans cette partie également, commencer par un peu de documentation sur le site www.sonelec-musique.com qui nous fournit une bonne explication du principe de mesure de courant.

Le choix se porte sur une mesure de courant par résistance de shunt

Il convient de dimensionner cette résistance en fonction des éléments suivants :

• la chute de tension induite par le shunt devra être toujours inférieure à 500mV
• la résistance prendra la valeur la plus grande possible afin d'augmenter la précision de mesure

Évaluation des performances

Pour évaluer la précision de la mesure de courant, il convient d'avoir un minimum de connaissance sur les CAN ( Convertisseur Numérique Analogique).

En utilisant la datasheet de l'ATTINY261A (pages 141 et suivantes), choisir une valeur de tension de référence pour le CAN intégré.

On constate sur le schéma de la page 142, la présence d'un amplificateur à gain variable.

On vous demande de donner :

• les différents gains disponibles
• choisir le gain pour lequel la précision de mesure sera la plus élevée
• calculer alors le quantum de l'intensité mesurable (plus petite variation de courant détectable)
• l'intensité maximum mesurable à cette précision

Validation du principe

On vous demande d'évaluer la méthode de mesure à l'aide d'une carte arduino UNO. Le µcontrôleur utilisé sur cette carte (atmega328) ne disposant pas d'une structure aussi complexe de CAN, on ne pourra pas vérifier la précision de mesure.

Écrire et valider par des mesures un programme de test :

• Vous devrez utiliser au minimum les fonctions :
  • analogRead()
  • analogReference()
• La charge (composant qui consommera un certain courant) pourra être :
  • différentes résistances
  • un potentiomètre

Fabrication de la carte électronique

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
• où placer la résistance de shunt

Quelques éléments de réponse :

ISP	In System Programming : la plupart des µcontrôleurs modernes dont celui-ci sont programmable 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.
shunt	Afin de pouvoir utiliser l'amplificateur à gain variable du Convertisseur Analogique Numérique, il est nécessaire d'effectuer une mesure différentielle. Il faudra donc relier au µcontrôleur les 2 tensions aux bornes de la résistances et mesurer la différence de tension. En tenant compte du tableau p157 de la datasheet, faire en sorte que la tension mesurée soit positive.	Attention, toutes les configurations ne sont pas possibles !
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 RESET principalement, ne peut servir qu'à cet usage !!	Dans le cas contraire, vous ne pourrez plus reprogrammer le microcontrôleur.

Routage

Voici quelques contraintes de routage que vous devez respecter :

- pistes : 0,4 mm mini
- écartement entre les pistes : 0,4 mm mini
- Via : 0.8 pour les trous et 1,25 pour le diamètre externe

ATTENTION : Si vous faites un circuit double face, n'oubliez pas que les pastilles qui doivent permettre le brasage des composants traversants ne doivent se trouver sur la même face que le composant (sinon vous ne pourrez pas le souder !)

- placer un condensateur de 100nF au plus près du microcontrôleur entre les bornes +Vcc et GND
- placer un condensateur de 150µF entre les bornes +Vcc et GND de l'alimentation
- n'oubliez pas les connecteurs pour l'alimentation de la carte et le signal fil pilote (voir 'douille alimentation' dans le tableau des composants)

ATTENTION : la masse analogique AGND doit être raccordée à la masse GND du microcontrôleur

- prévoyez un repère visuel côté composant sur le typon à côté de la borne 1 du connecteur ISP pour éviter les erreurs lors du raccordement car il n'y a pas de détrompeur sur ce connecteur
- faites apparaître les informations (NOM , PROJET , ANNEE) sur chaque face comportant des pistes afin de pouvoir identifier facilement le côté cuivre lors du tirage du PCB.

Rappels pour préparation des calques

Via : 0.8 pour les trous et 1,25 pour le diamètre externe

Exports sous forme d'images :

1. fond en blanc : Options -> user interface -> layout
2. lancer ulp -> drill-aid vous propose Drill center diameter 0,3mm et c'est OK. Le remplissage se fait en couche 116 mais avec des hachures.
3. Choisir cette couche 116 puis change -> Fillstyle en plein
4. Choisir les couches Bottom (bleu) Pads vias et la 116
5. File -> export -> Image donner un nom et choisir 1200 DPI et monochrome
6. Idem pour Top (rouge) avec pads et vias (et éventuellement la 116)

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 Convertisseur Analogique Numérique

1er test

Vérification de la communication avec le µcontroleur :

• dans un terminal lancer la commande
• avrdude -c avrisp2 -P usb -p t261

Compilation

Vous utiliserez l'IDE eclipse pour réaliser votre programme. L'horloge par défaut de votre µcontrôleur est 1MHz.

Une autre solution est d'utiliser 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 :

avr-gcc -Wall -g -Os -mmcu=attiny261a -o test.o test.c
avr-objcopy -j .text -j .data -O ihex  test.o test.hex
avrdude -c avrisp2 -P usb -p t261 -U flash:w:"test.hex"

Il conviendra bien entendu de remplacer les occurrences "test.*" par le nom de votre programme

Afficheurs

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 :

#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);
   }
}

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.

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

#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++;
   }
}

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

#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++;
   }
}

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

#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++;
   }
}

CAN

Vous trouverez la documentation nécessaire à l'utilisation du Convertisseur Analogique Numérique de l'atmega261A dans les documents suivants :

• datasheet Atmel
• page consacrée du wiki

Configuration

Avant de pouvoir effectuer une conversion, il est nécessaire de configurer le module Convertisseur Analogique Numérique du µcontrôleur, tel que suit :

1. Mise en route du convertisseur
   • le bit ADEN contrôle l'activation du convertisseur
   • si ADEN = 1 le convertisseur est actif
   • consulter la page 154 de la datasheet
   • configurer le registre ADCSRA en conséquence
2. Choix de la tension de référence :
   • les bits REFS[2..0] permettent de choisir la tension de référence
   • consulter cette page pour choisir
   • configurer en conséquence les registres ADMUX et ADCSRB
3. Choix de l'entrée différentielle
   • les bits MUX[5..0] permettent de choisir l'entrée à convertir
   • consulter les pages 156 à 158 de la datasheet
   • rque : le choix du gain parmi 1x/8x ou 20x/32x se fera ultérieurement
   • configurer les registres ADMUX et ADCSRB en conséquence
4. Choix du gain
   • le bit GSEL permet de choisir le gain
   • consulter la page 159 de la datasheet
   • configurer le registre ADCSRB en conséquence

Le tableau suivant est une autre représentation possible des différentes étapes :

Fonctionnalité	Code
Activation du CAN	ADCSRA |= 1<<... ;
Tension de référence	ADMUX |= 1<<... ; ADCSRB |= 1<<... ;
Choix de l'entrée	ADMUX |= 1<<... ; ADCSRB |= 1<<... ;
Choix du gain	ADCSRB |= 1<<... ;

Remarque : toutes les instructions ne sont pas forcément nécessaires !

Conversion

Une fois configuré, nous pouvons utiliser le Convertisseur Analogique Numérique. Pour cela, il convient de :

1. lancer une conversion
   • le bit ADSC permet de lancer une conversion
   • consulter la page 154 de la datasheet
   • configurer le registre ADCSRA en conséquence
2. Attendre la fin de la conversion
   • le bit ADSC repasse à 0 à la fin de la conversion
   • consulter la page 154 de la datasheet
   • il faut donc attendre que le bit ADSC passe à 0
3. Lire la valeur
   • les registres ADCH et ADCL (qui forment ADC) contiennent la conversion
   • consulter la page 155 de la datasheet
   • il suffit de lire le registre ADC

Le tableau suivant est une autre représentation possible des différentes étapes :

Fonctionnalité	Code
lancer une mesure	... |= 1<<ADSC ;
Attendre fin de conversion	while ( (ADCSRA & (1<<...) ) == ... ) ;
Lire la valeur	n = ADC ;

Un début d'assemblage des différents éléments

Il vous reste à assembler ces différentes briques et de faire un programme répondant au cahier des charges du projet. Voici un canevas qui vous aidera dans votre conception :

#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 n,...

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

   // configuration du CAN

   // boucle infinie
   while(1)
   {
       // lancer une conversion

       // attendre la fin de conversion et pendant ce temps afficher la précédente valeur 
       do
       {
           affiche(n);
       }
       while ( _conversion_en_cours_ );

       // récupérer la valeur convertie
       n = ... ;
   }
}

Plus malin : Tout compris au timer, c'est l'occasion de les utiliser ! Supprimez donc cette fonction affiche et remplacer là par une interruption de débordement sur l'un des 2 timers disponibles.

N'hésitez par à consulter vos Tds M2103 !

Composants utilisés

Nom	Type	Boîtier	Librairie Eagle	Référence eagle	Documentation	Fournisseur	Référence
ATTINY261A	µcontrôleur	WSOIC20	atmelIUT	ATTINY261A	attiny261A.pdf	Farnell	2443187
HDSP-B09G	afficheur 7 sgts 4 digits	traversant	media:HDSP-B09G.lbr	*HDSP-B09G*	af7sgt4dgts.pdf	Farnell	2095874
CC04-41SURKWA	afficheur 7 sgts 4 digits	traversant	atmelIUT	CC04-41SURKWA	af7sgt4dgts.pdf	Farnell	2426180
MC32593	fiche femelle USB coudée type A	traversant	con-berg	PN87520	ficheUSBfemelleA.pdf	Farnell	1696534
MC32593	fiche mâle USB coudée type A	CMS	atmelIUT	USB_CMS_MALE_A	ficheUSBmaleA.pdf	Farnell	1696545
ISP	barrette mâle sécable	traversant	con-lstb	MA03-2