Cours:MesureConsommationUSB

De troyesGEII
Aller à : navigation, rechercher

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.

MesureUSBcordon.jpg
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.
MesureUSB.JPG
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

FonctionnelMesureUSB.png

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.

Question.jpg 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

Todo.jpg 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.

Todo.jpg 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.


Todo.jpg 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).

Todo.jpg É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

Todo.jpg 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).

Todo.jpg 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.

Todo.jpg 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.

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

  • Vous devrez utiliser au minimum les fonctions :
  • 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
  • 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.

Avr isp.jpg
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

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 !

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

Compilation

Vous pourrez utilisere 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


Une autre solution est d'utiliser un IDE comme eclipse configuré avec un plugin pour les cibles AVR.

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.

Todo.jpg 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++;
   }
}

Todo.jpg 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++;
   }
}

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

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
  2. Choix de la tension de référence :
  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 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
  2. Attendre la fin de la conversion
  3. Lire la valeur


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