Source de tension numérique (DAC) avec PIC16F887

Objectifs

• Savoir l’utilité d’un convertisseur Numérique Analogique (DAC)
• Connaitre les caractéristiques du DAC0808
• Savoir réaliser une source de tension numérique
• Savoir utiliser un LCD avec MikroC
• Connaitre les caractéristiques du LCD LM016L 16×2
• Savoir utiliser quelques fonctions de conversions de types
• Comprendre le fonctionnement d’un amplificateur de transimpédance
• Et autres astuces pratiques

Applications

• Source de tension précise
• Générateur des signaux
• Asservissement des moteurs

Fonctionnement  partie matérielle

Principe

L’objectif du projet est de concevoir une source de tension numérique précise dont la tension peut varier entre 0 et une valeur maximale. Nous disposons de deux boutons poussoirs permettant d’incrémenter ou décrémenter la tension de sortie d’un pas ajustable dans le programme. Le convertisseur numérique-analogique est l’élément essentiel dans notre montage. Il sert à convertir une valeur numérique sur 8 bits à une grandeur analogique (courant ou tension). La valeur de la tension de sortie sera ensuite affichée dans l’afficheur LCD en format flottant.

Convertisseur N/A DAC

Le DAC0808 est un convertisseur numérique analogique (DAC) monolithique de 8 bits offrant un temps de stabilisation du courant de sortie à pleine échelle de 150 ns en ne dissipant que 33 mW avec des alimentations de ± 5V. Aucun ajustement du courant de référence (IREF) n’est requis pour la plupart des applications puisque le courant de sortie à pleine échelle est typiquement ± 1LSB de 255= IREF / 256. La précision est de l’ordre de ± 0,19% assurent une bonne linéarité sur 8 bits pour IREF≥2 mA. Le courant d’alimentation du Le DAC0808 est indépendant du mot binaire, il présente des caractéristiques essentiellement constantes sur toute la plage de tension. De plus, le DAC0808 s’interface directement avec les protocoles TTL, DTL ou Niveaux logiques CMOS et remplace directement le MC1508 / MC1408 pour les applications à plus grande vitesse. Ci-dessous les caractéristiques essentielles du DAC :

• Résolution binaire : 8 bits
• Erreur de linéarité maximale de ± 0,19%
• Correspondance du courant en pleine échelle: ± 1 type LSB
• Temps de réponse : 150 ns typique (6.66 MHz)
• Compatible avec les entrées numériques: TTL et CMOS
• Vitesse de balayage d’entrée multiplicatrice à grande vitesse (Slew Rate): 8 mA / µs
• Gamme de tension d’alimentation: ± 4,5V à ± 18V
• Faible consommation d’énergie: 33 mW @ ± 5V
• Plus de détails: Datasheet DAC0808

Comment calculer le courant de sortie du DAC ?

On considère le montage ci-dessous (voir la page 8 du datasheet) utilisé par le constructeur pour faire ses tests. Le courant de sortie I0 d’après l’équation dépend de la tension de référence Vref fixée par l’utilisateur et la résistance R14 et l’état des bits d’entrées A1 (poids fort) à A8 (poids faible). Par conséquent la valeur LSB (la valeur la plus que peut prendre le courant I0) est égale au courant I0 lorsque le bit A8 est égal à « 1 ». On considère une tension Vref=10V, R14=5k. Alors le courant I0_LSB=(10/5000)*(1/256)= 7.8125E-6A=7.8125µA. Cette valeur nous sera intégrer dans le programme afin de calculer le courant I0 quelque soit l’état des bits A1-A8.

La résistance liée à la broche 15 permets de compenser en température le courant de polarisation, elle n’est pas nécessaire pour la plupart des applications.

Amplificateur de trans-impédance

Un amplificateur de trans-impédance est un convertisseur courant (I)/ tension (Vout). Il est constitué d’un amplificateur AOP et une résistance R (voir le montage ci-dessous). Le courant parcouru par la résistance R est égal au courant à l’entrée I. On a :

V(-)=Vout+R*I, V(+)=V(-)=0 ==> Vout=-RI

Le courant de sortie du convertisseur DAC I0=I14 (voir le datasheet) a un sens opposé à celui de l’amplificateur à transimpédance. Alors Vout=-(-RI)=RI. Par conséquent, la tension de sortie Vout est positive ou nulle en fonction de l’état des bits A1-A8.

Comment valider le fonctionnement du DAC ?

Il est important de faire correspondre les résultats théoriques et ceux de la simulation. En effet, on a besoin de vérifier si le courant LSB correspond parfaitement à la valeur obtenue par le calcul théorique I0_LSB=.7.8125µA. La méthode consiste à positionner le bit A8 à « 1 », et à 0 les autres bits : A1-A7= « 0000000 » puis utiliser la résistance R5 d’une valeur égale à 1 Ohm (Vout=R5*I0=I0). Ci-dessous le résultat de simulation :

Le  résultat de simulation correspond parfaitement à la valeur calculée du courant I0_LSB (A8=1)

Alors: Vout=R5*I0

Valeur maximale: MSB

Afficheur LCD 12×2 LM016L (Caractéristiques)

Les écrans à cristaux liquides à base de caractères ils sont couramment utilisés. Ils sont basés sur le contrôleur HD44780 d’Hitachi ou autres, compatibles avec le HD44580. Nous abordons dans la suite les différents pins de l’afficheur, de son interface avec le microcontrôleur PIC18F887 en utilisant la commande 4 bits par l’intermédiaire d’un ensemble des fonctions MikroC. Le LM016L est constitué de deux lignes (1) et (2), chaque ligne est peut contenir 16 caractères (numérotation : 1-16). Lire la suite Datasheet LM016L.

La tension VEE permet d’ajuster le contraste du LCD. On peut utiliser un potentiomètre branché avec une alimentation 5V afin de régler l’éclairage de l’afficheur. Pour des raisons de simplification, nous avons branché le pin VEE avec une alimentation 5V fixe.

Afficheur LCD 12×2 LM016L (Fonctions de contrôle)

Le mikroC PRO for PIC fournit une bibliothèque pour la communication avec les écrans à cristaux liquides via l’interface 4 bits (D4-D7. Un exemple de connexions LCD est donné dans le schéma de principe illustré au début du projet. Le logiciel MikroC dispose de six fonctions et un ensemble de variables internes pour la manipulation de ‘afficheur LCD.

Lcd_Init()

Initialisation de l’écran LCD. La fonction ne dispose pas des variables d’entrées ou des sorties. Elle nécessite la déclaration des variables des données et des directions avant son utilisation.

// Exemple:

// Lcd pinout 
sbit LCD_RS at RB4_bit;
sbit LCD_EN at RB5_bit;
sbit LCD_D7 at RB3_bit;
sbit LCD_D6 at RB2_bit;
sbit LCD_D5 at RB1_bit;
sbit LCD_D4 at RB0_bit;

// Direction
sbit LCD_RS_Direction at TRISB4_bit;
sbit LCD_EN_Direction at TRISB5_bit;
sbit LCD_D7_Direction at TRISB3_bit;
sbit LCD_D6_Direction at TRISB2_bit;
sbit LCD_D5_Direction at TRISB1_bit;
sbit LCD_D4_Direction at TRISB0_bit;
...

Lcd_Init();

Lcd_Out()

Syntaxe: void Lcd_Out(char row, char column, char *text);

• row: Numéro de ligne (1 ou 2 dans notre cas, la valeur peut être importante lorsqu’on utilise un LCD 4×16, …)
• column: Numéro de la colonne dont on souhaite commencer. La valeur peut varier entre 1 et 16.
• *text: Pointeur du tableau des caractères.

// Déclaration 
char txt1[] = "Bonjour";
char txt2[] = "Electronique";

// Affichage
Lcd_Out(1, 1, txt1); 		// Première ligne, première colonne 
Lcd_Out(2, 1, txt2); 		// Deuxième ligne, première colonne 
Lcd_Out(1, 3, "Hello"; ); 	// Première ligne, troisième colonne

Lcd_Out_Cp()

Afficher le texte dans la position actuelle du curseur.

Syntaxe : void Lcd_Out_Cp(char *text);

Exemple: Lcd_Out_Cp("Here!");

Lcd_Chr()

Affichage d’un seul caractère dans une position (ligne, colonne) dans l’afficheur LCD.

Syntaxe : void Lcd_Chr(char row, char column, char out_char);

// Exemple: 
Lcd_Chr(2, 3, 'A');

• Row: Ligne
• Column: Colonne
• out_char: Caractère unique (pas une chaîne de caractères! )

Lcd_Chr_Cp()

Afficher un caractère das la position actuelle du curseur.

Syntaxe: void Lcd_Chr_Cp(char out_char);
Exemple : Lcd_Chr_Cp('e');

Lcd_Cmd()

Envoyer une commande prédéfinie à l’afficheur LCD. Ci-dessous une liste exhaustive des commandes (voir MikroC LCD pour plus de détails)

Syntaxe: void Lcd_Cmd(char out_char);

Syntaxe : unsigned char FloatToStr(float fnum, unsigned char *str);

// Exemple

float Volt=4.50 ;

unsigned char VoltStr[10] ;

…

FloatToStr(Volt, VoltStr);

// Paramètres de la Tension de sortie

const float Res_5=5000;

const float Courant_LSB=7.8125E-6;

float Tension=0.0;


// Valeur du DAC

unsigned short  DAC_val=1;

…

// Conversion Int ==> Float

DAC_fval=(float)DAC_val;


// Calcul de la Tension de sortie

Tension=DAC_fval*Res_5*Courant_LSB;

#include <built_in.h>

unsigned short  DAC_val=1;
unsigned short  DAC_step=1;
float DAC_fval=0.0;

// LCD module connections
sbit LCD_RS at RB4_bit;
sbit LCD_EN at RB5_bit;
sbit LCD_D4 at RB0_bit;
sbit LCD_D5 at RB1_bit;
sbit LCD_D6 at RB2_bit;
sbit LCD_D7 at RB3_bit;

sbit LCD_RS_Direction at TRISB4_bit;
sbit LCD_EN_Direction at TRISB5_bit;
sbit LCD_D4_Direction at TRISB0_bit;
sbit LCD_D5_Direction at TRISB1_bit;
sbit LCD_D6_Direction at TRISB2_bit;
sbit LCD_D7_Direction at TRISB3_bit;
 
char txt1[] = "Tension (V): ";
char txt2[16];

// Tension de sortie
const float Res_5=5000;
const float Courant_LSB=7.8125E-6;
float Tension=0.0;
    
void main() 
{
     // Configure AN pins as digital
     ANSEL  = 0;
     ANSELH = 0;

     // Port A en entrée
     TRISA=0xFF;

     // Configuration en sortie des ports
     TRISB=0;
     TRISC=0;
     TRISD=0;
     TRISE=0;
     
     // Initialisation LCD
     Lcd_Init();                     // Initialize Lcd
     Lcd_Cmd(_LCD_CLEAR);            // Clear display
     Lcd_Cmd(_LCD_CURSOR_OFF);       // Cursor off
     Lcd_Out(1,2,txt1);              // Write text in first row
      

     // Lecture et affichage de la donnée ADC
     while(1)
     {
      // Lecture des entrées & Mise à jour DAC
      if (Button(&PORTA, 0, 1, 1))
      {
         // Mise à jour  de valeur du DAC
         DAC_val=DAC_val+DAC_step;
         
         // Affectation de la valeur
         PORTD=DAC_val;
         
         // Effacer LCD
         Lcd_Cmd(_LCD_CLEAR);
         
         // Tempo
         Delay_ms(200);
      }
      if (Button(&PORTA, 1, 1, 1))
      {
         DAC_val=DAC_val-DAC_step;
         PORTD=DAC_val;
         Lcd_Cmd(_LCD_CLEAR);
         Delay_ms(200);
      }
      
      // Conversion Int ==> Float
      DAC_fval=(float)DAC_val;
      
      // Calcul de la Tension de sortie
      Tension=DAC_fval*Res_5*Courant_LSB;
      
      // Conversion Float ==> String
      FloatToStr(Tension,txt2);
      
      // Affichage
      Lcd_Out(1,2,txt1);
      Lcd_Out(2,2,txt2);
     }
}