Julien
Dernière mise à jour le 10/02/18
Présentation
Vous allez me dire que c’est la même chose que le timer1 ?? Oui mais non je vous assure que celui-ci est encore plus performant. En effet, celui-ci permet de combiner le Timer3 pour obtenir 32 bits plutôt que 16 bits, voilà cette différence alors que je tiens à le vous rappeler, le Timer1 comme le Timer2 ne fait que 16 bits …
L’exemple qui va suivre utilise le Timer2 sur 16 bits, et va permet de faire clignoter 2 leds toutes les secondes. La led verte représente le programme principal, et la led rouge le programme d’interruption.
Schéma PIC32 Interruptions Timer2
Programme PIC32 Interruptions Timer2
Programme disponible aussi en MikroC
|
program PIC32_Interruptions_Timer2;
procedure init; begin AD1PCFG := $FFFF; // Utilisation des entrées en numériques TRISB := $0000; // Les broches du PORTB sont configurées en sorties LATB := $0000; // Initialise toutes les sorties du PORTB à l’état logique BAS PORTB :=$0000; // On fixes les sorties à l’état zéro EnableInterrupts(); // Activations des interruptions IVT ON__T2CON_bit:=1; // On active le timer 2 SIDL_T2CON_bit:=0; TCKPS0_T2CON_bit:=1; // | TCKPS1_T2CON_bit:=1; // | prescaler sur 256 TCKPS2_bit:=1; // | T32_bit:=0; // Timer2 config sur 16 bits TCS_bit:=0; // Horloge interne (Quartz OSC1 et OSC2) 8MHZ T2IE_bit:=1; // On active les interrutpions du Timer2 T2IF_bit:=0; // Drapeau d’interrutpion baissé T2IP0_bit:=1; // | T2IP1_bit:=1; // | pritorité 7 de l’interruption du timer 2 T2IP2_bit:=1; // | TMR2:=$0000; // Le réglage à zéro le Timer2 c’est mieux pour commencer… end; procedure Timer2(); iv IVT_TIMER_2; // Interrutpion timer3 priorité 7 ilevel 7; begin if T2IF_bit=1 then //T2IF représente les 256 coups d’horloge du timer2 begin delay_ms(1000); LATB.4:=1; // Led rouge allumée interruption en cours… LATB.1:=0; // Led verte éteinte programme principale arrêté delay_ms(1000); LATB.4:=0; // Led rouge éteinte fin de l’interruption T2IF_bit:=0; // On sort de l’interruption end; end; begin init; while true do begin LATB.1:=1; // Led verte allumée programme principale en cours… end; end. |
Ce programme est fonctionnel, mais vous avez remarquez que j’ai utilisé des tempos de 1 seconde pour ralentir l’interruption qui occasionne par la même occasion le ralentissement du programme principal (led verte). C’est façon de faire n’est pas très élégante mais cela vous donne un premier aperçu de l’utilisation des interruptions du Timer2.
Nous allons voir maintenant comment utiliser le Timer2 et le Timer3 afin de pouvoir compter sur 32 bits. L’exemple qui va suivre permet de fair clignoter les 2 leds à la secondes
Programme PIC32 Interruptions Timer2 Timer3
Programme disponible aussi en MikroC
|
program PIC32_Interruptions_Timer2_Timer3;
procedure init; begin AD1PCFG:=$FFFF; // Utilisation des entrées en numériques TRISB:=$0000; // Les broches du PORTB sont configurées en sorties LATB:=$0000; // Initialise toutes les sorties du PORTB à l’état logique BAS PORTB:=$0000; // On fixe les sorties à l’état zéro EnableInterrupts(); // Activations des interruptions IVT ON__T2CON_bit:=1; // On active le Timer2 TCKPS0_T3CON_bit:=0; // | TCKPS1_T3CON_bit:=0; // | Timer3 réglé prescaler à 1:1 TCKPS2_T3CON_bit:=0; // | T32_bit:=1; // Mode 32 bits (Timer2 + Timer3) T3IP0_bit:= 1; // | T3IP1_bit:= 1; // | Priorité 7 T3IP2_bit:= 1; // | T3IF_bit:= 0; // On met le drapeau à zéro (Pas d’interrutpion) T3IE_bit:= 1; // On active les interrutpion du Timer3 TMR2:= 0; // On commence à compter à partir de zéro TMR3:= 0; // On commence à compter à partir de zéro PR2:= 47300; PR3:= 1220; LATB.4:=1; LATB.1:=0; end; procedure Timer2(); iv IVT_TIMER_3; // Interrutpion timer3 priorité 7 ilevel 7; begin if T3IF_bit=1 then //T3IF est à 1 lorsque Timer2/3 égale PR2/PR3 begin LATB.4:= LATB.4 xor 1; // Led rouge LATB.1:= LATB.1 xor 1; // Led verte T3IF_bit:=0; end; end; begin init; while true do begin // On ne fait rien end; end. |
Dans ce nouveau programme apparait PR2 et PR3, qui sont des bits qui permettent de fixer une valeur pour que celle-ci soit comparée par rapport à la valeur du comptage des Timer2/3. Lorsque la valeur PR2 et PR3 sera égale à la valeur du Timer2/3 nous obtiendrons une interruption.
Dans ce mode de 32 bits, en associant le Timer 2/3 celui-ci compte de 0 à 4294967295. Ce qu’il faut comprendre c’est que le Timer2 compte sur 16 bits, et le Timer 3 compte aussi sur 16 bits et la somme des 2 formes un compteur de 32 bits. Le Timer2 compte de 0 à 65535 et quand il arrivera à 65535 il incrémentera le Timer3. De nouveau le Timer recompte de 0 à 65535 et arrivé à 65535 il va de nouveau incrémenter le Timer3 soit deux incrémentations obtenu au Timer3. De nouveau on recommence le cycle le Timer2 terminer de compter et le Timer3 s’ incrémente une 3ème fois etc … etc….
La question est : Quelles sont les valeurs à donner à PR2 et PR3 pour que les leds clignotent toutes les secondes avec un CPU qui tourne à 80 Mhz et un prescaler de 256? Et bien facile !!! PR2= 47300 et PR3 = 1220 !!!
Bon ok !! Je vous vois venir ! comment fait-on pour calculer ?
Soit vous utilisez la solution la plus facile, et qui est de télécharger sur le site de Mikroe le « Timer Calculator » à cette adresse :
https://libstock.mikroe.com/projects/view/398/timer-calculator
Ou bien vous jouez de la calculette à savoir que vous allez tronquez les chiffres qui sont situé après la virgule afin de simplifier au maximum !
Calculatrice au secours!!!
Le Timer2 comme le Timer3 est cadencé à une vitesse de 80 Mhz soit toutes les 0,01micro-seconde. Imaginer vous que toutes les Microsecondes le Timer2 incrémenter de 1 cela va très vite, et il aura donc mis 820 microsecondes pour arriver à 65535. Dans ce cas le Timer2 une fois terminé de compter va incrémenter le Timer3, et le cycle recommence. On obtient quelque chose du genre:
– 1er tour de comptage pour le Timer2 = 65535 + 1 (incrément) pour le Timer3 total = 65536
– 2ème tours de comptage pour le Timer2 = 2×65535 + 2×1(incrément) pour le Timer3 total = 131072
– 3ème tour de comptage pour le Timer2 = 3×65535 + 3×1(incrément) pour le Timer3 total = 196608
– etc…
Calculs
D’une manière général on peut démontrer par cette formule que :
PR3 = x*F/(Prescaler*65536)
PR2 = (x*F)[1/Prescaler – PR3*65535]
x : le temps que l’on souhaite obtenir en seconde ;
F : la fréquence en Hz (ici 80 000 000 hz)
Prescaler : ici dans notre exemple il est de 1 : 1 pour notre programmation
En valeur numériques cela nous donne
PR3 = (1*80 000 000)/[(1/1)*65536] = 1220,703125 soit 1220 par arrondi.
PR3 = 1220
PR1 = (1*80 000 000)[1/(1/1)-( 1220*65535)] = 47300
PR2 = 47300
Lorsque le PR3 aura atteint 1220 coup d’horloge via le Timer3, il faudra ensuite attendre que PR2 soit arrivé à 47300 coup d’horloge via le Timer2 ce qui entrainera dans la foulé la mise à 1 du bit T3IF et donc une 1 interruption.
Historiques
– 10/02/18
Programmation disponible aussi en MikroC.
– 03/02/18
Première mise à disposition.
Dernière mise à jour le 03/02/18
Présentation
Dans ce présent article nous allons débroussailler le terrain afin d’avoir un aperçu de ce qu’on appel les interruptions, puis nous verrons dans des autres articles leurs utilisations. Avant d’aborder les autres articles, nous allons nous contenter d’expliquer simplement le rôle de ces interruptions afin de nous familiariser avec ces nouveaux outils de programmation, puisqu’ils sont différents des PICs de la famille 10F/12F/16F/18F.
Les interruptions sont des évènements qui sont exécutés en dehors du programme principal. Afin de pouvoir exécuter une interruption il faut dans un premier temps faire un préréglage dans la procédure d’initialisation du PIC qui celle-ci permettra de bien initialiser le PIC. Dès lors de sa mise sous tension (Attention !!! 3,3V pour rappel), cette initialisation sera effectuée dans la « procedure init ». Nous verrons plus en détails toutes les possibilités concernant les interruptions proposées par le PIC32 dans les prochains articles car la liste est longue.
Dans la procédure d’initialisation du PIC32, il faut avant tout insérer quelques lignes de programmation pour que l’interruption que vous désirez exécutée soit appelée.
EnableInterrupts()
Cette première routine est située dans le logiciel MikroPascal, mais pour ceux qui utiliserais MikroC ou MikroBascic…, cette routine est aussi présente. EnableInterrupts permet de faire appel aux “Interruptions Vecteurs” (IV). Pour faire simple sur ces interruptions, immaginez que vous ayez un classeur munis d’intercalaires, et que sur ces intercalaires le nom des thèmes, ou bien un classement alphabétique sont situés afin que vous puissiez retrouvez l’ensemble des documents que vous êtes entrain de rechercher. Et bien c’est la même chose avec les interruptions vector, au moment ou une interruption va se produire le nom de cette interruption sera “indexé” et son programme sera exécutée. (si on fait une analogie au niveau de “l’indexage” cela représente le nom de l’intercalaire sélectionné). Mais attention!! Si vous ne mettez pas « EnableInterrupts() » dans l’initialisation du PIC, aucune interruption vecteur ne sera appelés se qui empêchera sont éxécution!!.
IVT_XXXX
L’appel des interruptions sont faites par IVT_XXXX, ou XXX est à remplacer par l’interruption que vous désirez. Une interruptions est exécutée en fonction de notre besoin. Par exemple si on désire utiliser les interruptions du timer 1 nous mettrons iv IVT_TIMER_1, ou bien un autre exemple si nous désirons obtenir des interruptions sur une capture d’entrée, nous mettrons iv IVT_INPUT_CAPTURE_1. Nous verrons un peu plus loin qu’ils existes d’autres interruptions.
Gabarit du programme des interruptions
Comme nous l’avons dis précédemment, puisque ces interruptions sont appelées en dehors du programme principal le gabarit du programme est le suivant
|
//Initialisation du PIC
procedure init ; begin EnableInterrupts(); // Activations des interruptions IVT ilevel 7; // Propriété niveau 7 IC1IP0_bit:=1; // | IC1IP1_bit:=1; // | Capture 1 sur le niveau 7 IC1IP2_bit:=1; // | end ; // Interruption procedure Capture_1(); iv IVT_INPUT_CAPTURE_1; // Interruption de la capture sur la broche 1 ilevel 5; // Propriété niveau 5 begin //programme de l’interruption…. end ; // Programme principal begin init() ; while true do begin // On exécute en boucle le programme principal end; end. |
Visualisez bien cette mise en forme car celle-ci sera toujours réalisée de cette façon.
1 – L’initialisation du PIC ;
2 – L’interruption (ici dans l’exemple il s’agit de l’interruption INPUT- CAPTURE 1) ;
3 – Le programme principal exécuté en boucle.
Quelques interruptions en vues
MikroPascal for PIC32 propose une série d’interruptions possibles avec un PIC32. Les exemples ci-dessous montre quelques interruptions envisageables sur le MINI-32.
Possibilité de faire des interruptions sur :
– des interruptions externes,
– sur les Timers,
– sur des captures,
– sur des comparaisons,
– et bien d’autre encore….
Rq:Comme vous pouvez le constater, on retrouve l’interruption nommée INPUT_CAPTURE_1 comme dans l’exemple du gabarit du programme
C’est que le niveau de priorité? iLevel?
Prenons un exemple ou 2 voitures rentrent les unes après les autres dans un garage situé au sous-sol. La première voiture voit une led rouge (1er interruption) afin d’être stopper pour pouvoir prendre un ticket, et lorsque ce ticket a été pris cette même voiture verra une autre led qui passera au vert (2ème interruptions) indiquant au conducteur qu’il peut rentrer dans le parking. La voiture suivante se verra de nouveau avec une led Rouge allumée pour prendre de nouveau un ticket et rentrée elle aussi dans le parking souterrain.
Le programme va donc exécuter 2 interruptions, une pour la led Verte (par exemple une impression de ticket) et l’autre pour la led rouge (par exemple lever la barrière). Tout se passe bien puisque les voitures sont les unes derrière les autres et donc aucune voiture arrivera en même temps devant la barrière. Mais admettons que cette fois-ci nous nous retrouvons dans une situation ou les voitures sont les unes à côtés des autres! Et bien! c’est ce que nous allons voir tout de suite puisque c’est dans ce cas de figure que nous allons faire appel à la priorité (quelle voiture sera prioritaire par rapport à l’autre).
Niveau de priorité – iLevel X – bit xxIP
Nous avons dit précédemment que les interruptions pouvaient être prioritaires sur d’autre. Reprenons l’exemple précédent et imaginez maintenant que les voitures ne sont pas les unes après les autres mais cotes à côtes. Ce cas de figures est un peu plus complexe à réaliser car si 2 voitures arrivent au même moment , et qu’elles sont détectées en même temps, la seule manière de pouvoir rendre prioritaire l’une des deux pour « décoincer » la situation c’est de mettre des niveaux de priorités sur ces interruptions. Le PIC32 à la possibilité de mettre 7 niveaux de priorités, ainsi le premier niveau est prioritaire sur le 2ème, le 2ème niveau prioritaire sur le 3ème etc… etc … et cela jusqu’à 7!! Il en résulte que si nous avons 2 barrières situées l’une à côté de l’autre avec une barrière nommée barrièreA et l’autre nommée barrièreB , et que nous décidons de mettre une priorité sur la barrièreA et en 2ème priorité la barrièreB, il en résulte que si 2 voitures arrivent en même temps à la même seconde , c’est donc la barrièreA qui sera levée avant la barrièreB.
Dans ce cas iLevel X (ou X représente le niveau compris entre 1 et 7) permettra et vous l’aurez compris de rendre des interruptions prioritaires par rapports à d’autres. Imaginer vous qu’au même moment tout arrives en même temps!!! L’interruption (IV) à tout son intérêt, puisque il va interruptions concernée et en plus de choisir en fonction du “iLevel” celle qui sera prioritaire par rapport à l’autre tout simplement!. Hum!! qu’est ce qu’il nous raconte encore?!!
Ah oui!! une dernière chose, le réglage des niveaux de priorités sont réalisés par le bit xxIP (XX coresspond à l’interrutpion en question . par exemple si nous décidons d’utiliser le timer1 nous écrirons T1IP, si nous décidons le timer2 nous écrirons T2IP. Bien évidemment d’autre interrutpions sont accessible mais allons y doucement!!
Historiques
– 03/02/18
Première mise à disposition.
Dernière mise à jour le 10/02/18
Présentation
Commençons en douceur sur l’utilisation des interruptions du Timer1 qui à pour but de faire clignoter uniquement 3 leds de couleur Bleu/Rouge/Verte.
Schéma PIC32 Interruptions Timer1
Programme PIC32 Interruptions Timer1
Programme disponible aussi en MikroC
|
program PIC32_Interruptions_Timer1;
procedure init; begin AD1PCFG:= $FFFF; // Initialise les broches en numérique ou digital TRISB:= 0; // Initialise le PORTB en sortie LATB:= 0; // Initialise toutes les sorties du PORTB à l’état logique BAS PORTB :=$0000; // On fixes les sorties à l’état zéro EnableInterrupts(); // Activations des interruptions IVT ON__T1CON_bit:=1; // On active le du TIMER1 TCKPS0_bit:=1; // | TCKPS1_bit:=1; // | prescaler sur 256 T1IP0_bit:=1; // | T1IP1_bit:=1; // | Réglage du TIMER1 en priorité 7 T1IP2_bit:=1; // | T1IE_bit:=1; // On active le TIMER1 en mode interrutpion sur débordement TMR1 := 0; // On met à zéro le TIMER1 pour commencer à compter… end; procedure Timer1_Interruption; // Nom du programme de l’interruption iv IVT_TIMER_1; // Appel de l’interrutpion du TIMER1 ilevel 7; // Propriété niveau 7 begin LATB.1:=LATB.1 xor 1; LATB.4:=LATB.4 xor 1; LATB.5:=LATB.5 xor 1; IFS0.T1IF:= 0; // On sort de l’interruption et on recommence à compter end; begin init; while true do begin // On ne fait rien dans le programme principale end; end. end. |
Si on applique la structure comme expliqué précédemment dans les interruptions on y retrouve bien :
1 – La procédure nommée : procedure init; avec les instructions situé entre le début « begin » et la fin « end ; »
2 – L’interruption du Timer1 ;
3 – Le programme principal ;
Regardons en détails cette première programmation :
Activation du Timer1 – bit : T1CON
ON__T1CON_bit:=1; // On active le du TIMER1 afin de mettre en fonctionnement le Timer1
Réglage du prescaler – bit : TCKPS0/TCKPS1/TCKPS2
TCKPS0_bit:=1; // |
TCKPS1_bit:=1; // | prescaler sur 256
Exemple en vidéo?
Le réglage de ces bits permet de faire clignoter plus ou moins vite les leds. Une “grosse” vidéo ci-dessous permettra de mieux cerner l’intérêt du prescaler.
Réglage des priorités – bit : T1IP0/T1IP1/T1IP2
T1IP0_bit:=1; // |
T1IP1_bit:=1; // | Réglage du TIMER1 en priorité 7
T1IP2_bit:=1; // |
Nous retrouvons les 3 bits qui permettent de modifier la priorité soit 111 en binaire donne iLevel 7 – et 001 en binaire donne iLevel 1
Activation des interruptions sur débordement – bit : T1IE
T1IE_bit:=1; // On active le TIMER1 en mode interrutpion sur débordement.
Réglage des priorités – bit : T1IP0/T1IP1/T1IP2
Ce bit est accessible par le registre (REGISTER) IEC0.
Pour que l’interruption iv IVT_TIMER_1 se déclenche il faut que le bit d’interruption sur débordement du timer1 soit activée et c’est le rôle du bit T1IE_bit:=1. Ainsi Chaque fois que le Timer 1 va avoir terminé de compter, son drapeau d’interruption (voir Remarques) va se lever ce qui entraine la mise à l’état logique 1 du bit T1IF. Ensuite pour sortir de l’interruption du Timer, il suffit de mettre à 0 le bit T1IF.
Remarque : On parle de drapeau d’interruption chaque fois que le Timer est arrivé à sa dernière valeur de comptage (soit 255 pour le Timer1 qui compte sur 16 bits) ce qui entraine la mise à l’état logique 1 du bit T1IF. Plus généralement un drapeau levé correspond à l’état logique 1 et un drapeau baissé correspond à l’état logique 0.
iv IVT_TIMER_1;
Nous avons évoqué l’activation sur débordement du Timer1, mais nous n’avons pas vraiment approfondi la chose… Si vous avez manquez le début sur les interruptions il suffit de cliquer juste ici.
Nous savons maintenant que Iv IVT_TIMER_1 est une routine qui permet d’être appelé lorsque le Timer1 a débordé, mais c’est quoi un débordement ?
Pour n’importe quel Timer le débordement est le faite qu’un Timer va compter jusqu’à sa valeur maxi. Pour le Timer1 qui celui-ci compte sur 16 bits, sa valeur maxi est de 255 en décimal, c’est-à-dire qu’il va compter de 0 à 255 à chaque coup d’horloge, puis, lorsqu’il aura compté jusqu’à 255 son drapeau d’événement (drapeau d’interruption) va passer à l’état logique « 1 » indiquant que le Timer1 a débordé et qu’il a fini de compter ce qui va donc entrainer par la même occasion une interruption géré par iv IVT_TIMER_1 . Pour redémarrer de nouveau un cycle de comptage il suffit de remettre le drapeau d’interruption à 0 ce qui nous permettra de sortir de l’interruption iv IVT_TIMER_1.
D’autre Réglage du Timer1
Avant d’aborder les autres réglages du Timer1 je tiens à faire une parenthèse, Reprenons le tableau ci-dessous ensemble :
Ce tableau est le Registre (REGISTER) du T1CON qui permet de contrôler le Timer1. Ce registre est composé de 32 bits (0 à 31 on compte le zéro) 1 bit correspond à une case. Pour ma part, j’ai utilisé les routines de MikroPascal mais rien ne vous empêche d’utiliser le registre .
Plutôt que d’écrire en utilisant les routines de MikroPascal
|
ON__T1CON_bit:=1; // On active le du TIMER1
TCKPS0_bit:=1; // | TCKPS1_bit:=1; // | prescaler sur 256 |
J’aurais bien pu écrire sous cette forme :
|
T1CON:=$8030
|
Il en résulte que sur 32 bits le registre T1CON donne en binaire
T1CON := 00000000 00000000 10000000 00110000 (en Hexadécimal donne : $8030)
On commence toujours de gauche à droite (bit le plus fort=32 au bit le plus faible=0)
Comme vous pouvez le voir, cela en fait des 0 et des 1 à mettre il va falloir bien faire attention et c’est assez fastidieux comme méthode surtout si nous sommes pressés… Vous comprenez maintenant pourquoi j’ai un petit faible pour les routines toutes faites ?!
Bon !! Fermons la parenthèse, et regardons en détails les possibilités du Timer1. Je vous laisse lire…
Autre exemple pour le bit TCKPS bit compris entre 0 et 1, je peux mettre la valeur de 1:64 en écrivant comme ceci :
TCKPS0_bit:=0; // |
TCKPS1_bit:=1; // | prescaler sur 64
Il reste plus qu’à écrire cette nouvelle ligne à la place de l’ancienne, de compiler, de flasher et le tour est joué !!
Je vous remets la vidéo, car une erreur volontaire est glissée. Regarder bien les bits du prescaler j’ai indiqué TCKPS0/TCKPS1/TCKPS2, alors que le DataSheet indique seulement TCKPS0/TCKPS1. Il en résulte que le bit TCKPS2 est inutile!!
Historiques
– 10/02/18
Programmation du PIC32 disponible aussi en MikroC.
– 03/02/18
Première mise à disposition.
Dernière mise à jour le 10/02/18
Présentation
Nous allons voir dans ce présent article que certaines broches du PIC peuvent être configurées en mode analogique et pour cela il faut bien configurer le bit AD1PCFG ainsi que le bit TRISB comme entrée.
AD1PCFG – configuration en analogique
Le PIC32MX534F064H dispose d’un total de 16 broches analogiques AN0/AN1/AN2/AN3/../AN15.
En ce qui concerne le MINI-32 équipé du PIC32MX534F064H n’a seulement que la moitié de broches connectées soit un total de 8 broches analogiques qui sont :
AN0 – Broche RB0
AN1 – Broche RB1
AN4 – Broche RB4
AN5 – Broche RB5
AN8 – Broche RB8
AN9 – Broche RB9
AN14 – Broche RB14
AN15 – Broche RB15
Afin de pouvoir utiliser ces broches comme un mode analogique il suffit d’agir sur le bit AD1PCFG mais comment ?Si vous désirez utiliser la broche RB0 comme en mode analogique il faut donc mettre le bit RB0 à 1. Puisque le PIC32MX534F064H dispose d’un total de 16 broches analogiques (16bit) il suffit d’écrire en binaire 00000000 00000001 soit en hexadécimal donne $0001. L’extrémité droite correspond au bit 0 (RB0), ensuite le bit 1(RB1), bit 2(RB2), etc… Il en résulte que le 4ème bit qui représente la broche RB4 sera à 1, ce qui nous donne en binaire :
00000000 00010000. soit 10 000 nous donne en hexadécimal $0010.
Attention !!! Il ne faut pas compter comme nous le ferons tous à partir de 1 car la première broche n’est pas « 1 » mais « 0 » !!! On prend en compte le chiffre à partir de « 0 ».
Un autre exemple pour bien assimiler, on désire avoir 3 entrées analogiques qui sont RB15/RB4 et RB2, ce qui nous donne en binaire : 10000000 00010100 soit en hexadécimal $8014. Vous allez me dire pourquoi utiliser la broche RB2 alors que celle-ci n’est pas connectée ?!! Vous avez raison cela ne sert à rien mais c’est un exemple !!! Bon ok !! Alors mettons RB0 à la place ce qui nous donne en binaire : 10000000 00010001 et en HEX (hexadécimal) $8011. C’est bien beau tout ça mais comment le coder en langage MikroPascal ? Je vais y venir et ce n’est pas compliqué, il suffit d’écrire AD1PCFG := $8011 tout simplement. puisque c’est ce registre qui permet de configurer en mode analogique
TRISB – configuration en entrée
Nous venons de voir comment configurée en mode analogique mais il reste quand même une autre chose à configurer. Oui!! Il reste les broches du PIC qui doivent être configurés comme des entrées. Le bit TRISB, qui d‘ailleurs on ne peut pas se tromper, comporte les modes analogiques AN0/AN1/…. .Ainsi, si nous voulons configurer les entrées comme des entrées analogiques, il suffit de mettre (si on reprend l’exemple précédent avec RB15/RB4/RB0 comme entrée) le port TRISB, à “1” logique les 3 entrées désirées. Nous obtenons donc en hexadécimal TRISB:= $8011. Allons maintenant mettre en pratique ce montage électronique.
ADC1_Get_Sample(x) – lecture d’une valeur analogique
Pour pouvoir lire une valeur analogique en sortie d’un potentiomètre, il faut utiliser la routine ADC1_Get_Sample(x) (x qui représente l’entrée de la broche). dans notre exemple; 3 entrées analogiques sont lues, et leurs valeurs sont stockées directement dans la variable Valeur1/Valeur2/Valeur3. La programmation en langage MikroPascal nous donne:
|
var
Valeur1,Valeur2,Valeur3:word; // Déclaration des 3 variables Valeur1:=ADC1_Get_Sample(0); // Lecture de la broche RB0 et mis dans la variable Valeur1 Valeur2:=ADC1_Get_Sample(4); // Lecture de la broche RB4 et mis dans la variable Valeur2 Valeur3:=ADC1_Get_Sample(15); // Lecture de la broche RB15 et mis dans la variable Valeur3 |
Ces quelques lignes de codes permettent uniquement de lires les tensions analogiques et de les convertir en une valeur numérique afin que celle-ci soit stockée dans la variable “Valeur” , et par la suite de pourvoir l’exploiter plus tard… La conversion de la valeur analogique est réalisée sur 10 bits c’est-à-dire de 0 à 1023.
Conversion Anlogique Numerique (A/N)
La conversion d’une valeur analogique en numérique peut-être réalisée par une règle que nous connaisson tous “la règle de trois” ou bien le “produit en croix” ainsi pour une tension de 3,3V nous aurons une valeur numérique de 1023. Pour une tension de la moitié de la tension d’alimentation (3,3/2=1,65V) nous aurons une valeur numérique de 1023/2 soit 512. Si maintenant nous faisons l’inverse, soit pour une valeur numérique de 349, nous allons donc obtenir une tension analogique de (349*3,3)/1023 soit environ 1,13V. Pas compliqué vous ne trouvez pas?
Schéma PIC32 Entrées analogiques
Fonctionnement
Trois potentiomètres RV1, RV2, RV3. Ces potentiomètres sont raccordés sur les broches RB0/RB4/RB15 et les tensions sont lues sur ces broches qui sont toutes indépendantes et permettront d’éteindre ou d’allumer les leds par comparaison d’une tension de seuil que nous allons programmé. Cette tension de seuil sera fixée arbitrairement afin de pouvoir observer que les leds s’allumes lorsque nous dépassons cette tension de seuil. Les 3 tensions de seuils sont en valeurs numériques: 100/500/1000. Ainsi en comparant ces valeurs par rapport à celle qui est lue sur le potentiomètre, et que celle-ci est supérieure, les leds vont donc s’allumer.
Programme du PIC
Programme disponible aussi en MikroC
|
program PIC32_entrees_analogiques;
var Valeur1,Valeur2,Valeur3:word; // Déclaration des 3 variables procedure init; begin AD1PCFG := $7FEE; // Utilisation de l’entrée AN0/AN4/AN15 en mode analogique TRISB := $8011; // Configuration des broches RB0/RB4/RB15 comme des entrées LATB := $0000; // Initialise toutes les sorties du PORTB à l’état logique 0 ADC1_Init; // Initialisation du convertisseur analogique numérique (A/N) TRISE := $0000; // Configuration du PORTE comme sortie LATE := $0000; // Initialise toutes les sorties du PORTE à l’état logique 0 TRISF := $0000; // Configuration du PORTF comme sortie LATF := $0000; // Initialise toutes les sorties du PORTF à l’état logique 0 TRISG := $0000; // Configuration du PORTG comme sortie LATG := $0000; // Initialise toutes les sorties du PORTG à l’état logique 0 end; begin init; while true do begin Valeur1:=ADC1_Get_Sample(0); // Lecture de la broche RB0 et mis dans la variable Valeur1 Valeur2:=ADC1_Get_Sample(4); // Lecture de la broche RB4 et mis dans la variable Valeur2 Valeur3:=ADC1_Get_Sample(15); // Lecture de la broche RB15 et mis dans la variable Valeur3 begin if Valeur1>100 then LATE.0:=1 else LATE.0:=0 end; begin if Valeur2>500 then LATF.0:=1 else LATF.0:=0 end; begin if Valeur3>1000 then LATG.6:=1 else LATG.6:=0 end; end; end. |
Prototype en vidéo
Attention erreurs avec LAT et PORT , en effet Les sorties s’actives toujours avec le registre LAT et non avec PORT!! comme vous pouvez le voir sur la vidéo je n’ai pas corrigé mais le programme oui!!
Historiques
– 10/02/18
Correction des sorties, Les sorties s’actives toujours avec le registre LAT et non PORT!!.
– 03/02/18
Première mise à disposition.
Dernière mise à jour le 10/02/18
Présentation
Nous avons tous envies pour une première fois de faire clignoter une ou voir même plusieurs leds “seule” ou bien à l’aide d’un petit bouton poussoir. Et bien vous savez quoi?!C’est ce que nous allons voir dans ce présent article.
Afin de pouvoir faire fonctionner les entrées/sorties du MINI-32 mettant à disposition le PIC32MX534F064H il faut avant tout passer par quelques réglages élémentaires qui sont : TRISx/LATx/PORTx (x représente la lettre du PORT utilisé), ces 3 réglages sont ce qu’on appel ceci des registres.
Registre TRISx
Ce registre permet d’écrire sur le port entrée/sortie, et c’est ce registre qui permet de changer les états des broches afin de les configurées soit en entrées soit en sortie. Par exemple, si nous voulons que le port B – broche RB4 soit une entrée, il suffit de mettre TRISB.4:=1. Si par contre cette même broche nous décidons que celle-ci soit une sortie il suffira d’écrire TRISB.4:=0. Alors attention quand même lorsque je parle des broches!! Les broches ne correspondent pas au n° de broche en elle même, mais plutôt au bit qui lui correspondent. Ici dans l’exemple proposé RB4 est le bit n°4. En effet si on regarde le schéma ci-dessous la broche n°4 ou est branchée la led D4 correspond au bit RB4. Mais je préfère parler de broches pour simplifier la lecture car en utilisant les bits, il en résulte que le portB est un port qui contient au total 16 bits (16 broches) de RB0 à RB15. L’inconvénient c’est que que le MINI-32 n’a pas toutes ses broches à disposition, mais seulement RB0/RB1/RB4/….On ne va pas se plaindre!! car il y’a suffisamment assez pour réaliser des tonnes de montages electroniques!!
Que ce passe t’il au niveau de la programmation? cela ne changer rien car si vous décidez de déclarer la broche RB2 (bit 2) comme une sortie ” TRISB.2:=0″vous n’obtiendrez jamais rien de celle-ci puisque celle-ci n’est pas cablée…
Registre LATx
Ce registre permet d’écrire sur le port entrée sortie, et c’est ce registre qui permet de changer les état des broches. Nous verrons tout ça en toute simplicité
Registre PORTx
Ce registre quant à lui permet de lire le port, et c’est ce registre qui permet de « détecter » l’état des entrées. l’appui sur un bouton pousssoir sera détecter en utilisant PORTx.y (avec y le n° de la broche concernée. Des exemples ci-dessous permettront de vous familiariser avec les entrées sorties et de mieux comprendre l’utilisation de ces registres.
Schéma PIC32 Sorties Actives
Comme vous pouvez le constater, afin de ne pas encombrer le schéma, je n’ai pas représenté toutes les leds, mais uniquement de la led D1 à D10.
Pour les autres leds non représentées sur le shéma électronique, le câblage est identique en utilisant des résistances de 1 kilo-ohms qui feront bien l’affaires. Soyons économiques niveau courant ;-). Ce montage ne fait que alimenter les leds afin de tester si toutes les sorties sont bien toutes à l’état haut soit à l’état “1” logique.
Programme du PIC
Programme disponible aussi en MikroC
|
program PIC32_Sorties_Actives;
procedure init; begin AD1PCFG := $FFFF; // Utilisation de l’entrée en mode numérique (digital) TRISB := $0000; // toutes les broches du PORTB sont configurées en sorties LATB := $0000; // Initialise toutes les sorties du PORTB à l’état logique 0 TRISD := $0000; // toutes les broches du PORTD sont configurées en sorties LATD := $0000; // Initialise toutes les sorties du PORTD à l’état logique 0 TRISE := $0000; // toutes les broches du PORTE sont configurées en sorties LATE := $0000; // Initialise toutes les sorties du PORTE à l’état logique 0 TRISF := $0000; // toutes les broches du PORTF sont configurées en sorties LATF := $0000; // Initialise toutes les sorties du PORTF à l’état logique 0 TRISG := $0000; // toutes les broches du PORTG sont configurées en sorties LATG := $0000; // Initialise toutes les sorties du PORTG à l’état logique 0 end; begin init; while true do begin LATB:=$FFFF; LATD:=$FFFF; LATE:=$FFFF; // ici on force toutes les sorties à l’état logique 1 LATF:=$FFFF; // même pour les “broches” non cablées!! LATG:=$FFFF; end; end. |
Dans ce programme, on retrouve dans la procédure d’initialisation “procedure init;” le réglages des bits TRISx et LATx.
Puisque ici nous faisons que allumer des leds, la réglage de TRISx est configuré en sortie en écrivant “TRISx.y:=0” (x le port associé, et y le n° de broche (bit)), puis j’ai forcé l’état des sorties via le bit “LATx:=$FFFF” à 1 afin que les 16 bits (ou broches) soient toutes mises à l’état haut ce qui entraîne forcément la mise sous tension et l’éclairage des leds.
En ce qui concerne le bit AD1PCFG celui-ci permet uniquement de programmer les entrées en numérique (tout ou rien), j’aurais bien pu mettre ce bit AD1PCFG à l’état 0 soit “AD1PCFG:=$0000” afin d’obtenir cette fois-ci des entrées analogiques pouvant récupérer un signal qui variera entre 0 et 3,3V maxi!! Oui 3,3V maxi car l’alimentation du PIC est sous 3,3V et de même pour ces broches. Cela donne des idées l’analogique vous ne trouvez pas? je pense que vous me voyez venir…..
Que dire de plus mise à part que ce programme ne fait que d’allumer les leds à la mise sous tension. C’est un moyen simple de vérifier si tout les sorties du PIC vont changer d’état.
Schéma PIC32 Activer sortie à 1 bouton
Nous allons voir un autre montage éléctronique, qui celui-ci permettra à l’aide d’un boutons poussoirs d’allumer ou d’éteindre une leds.
Regardons ensembles ce nouveau schéma électronique et son programme:
Programme du PIC
Programme disponible aussi en MikroC
|
program PIC32_Activer_sortie_a_1_bouton;
procedure init; TRISB := $0010; // configure la broche RB1 comme une entrée |
La procédure “Allumer_led” permet comme son nom l’indique d’allumer la led D1. Lorsque le bouton Bp1 n’est pas pressé, la tension de 3,3V est appliquée directement sur la broche RB1 ce qui représente un “1” logique.
Lorsque cette fois-ci le bouton poussoir est relâché l’entrée RB1 se voit avec une tension de 0V ce qui entraîne l’extinction de la led. Avez vous remarquez que j’ai modifier le bit “TRISB” qui est configurée comme une entrée (broche RB1) en binaire sur 32 bits cela donne:
00000000 00000000 00000000 00000010 – 32 bits car je le rappel il y’a 16 Entrées/Sortie (E/S)
Schéma PIC32 Activer sorties à 2 boutons
Nous venons de voir avec 1 bouton poussoir, regardons maintenant ce qu’il en est avec 2 boutons poussoirs.
Programme du PIC
Programme disponible aussi en MikroC
|
program PIC32_Activer_sortie_a_2_boutons;
procedure init; TRISB := $0003; // configure la broche RB0 et RB1 comme des entrées TRISD := $0000; // toutes les broches du PORTD sont configurées en sorties procedure Allumer_Led_D1; procedure Allumer_Led_D2; begin |
Que dire …… Ah oui!!! j’ai encore modifié le bit TRISB car cette fois-ci 2 entrées sont raccordées sur les broches RB0 et RB1.
Historiques
– 10/02/18
Ajout programmation en MikroC
– 03/02/18
Première mise à disposition.
Dernière mise à jour le 16/12/17
Présentation
Ce petit programme permet à lui seul d’effacer le contenu du bloc note.
Programmation en C#
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using System.Diagnostics;
using System.IO;
namespace WindowsFormsApplication1
{
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
}
private void button1_Click(object sender, EventArgs e)
{
// Attention!!! Bloc note nommé "Electronique71"
StreamWriter writer = new StreamWriter(@"C:\Users\Julien\Desktop\Electronique71.txt", false);
}
}
}
|
Historiques
16/12/17
– Première mise à disposition
Dernière mise à jour le 16/12/17
Présentation
Ce petit programme permet d’écrire plusieurs lignes dans un bloc note. Rien ne vous empêches d’ajouter des lignes supplémentaires.
Programmation en C#
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using System.Diagnostics;
using System.IO;
namespace WindowsFormsApplication1
{
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
}
private void button1_Click(object sender, EventArgs e)
{
// Écrire dans un fichier texte sans l'ouvrir lignes par lignes
string a; // on déclare les variables
string b; // ici 3 variables car 3 lignes
string c; // on peut mettre plus!!
a = "1er ligne";
b = "2ème ligne";
c = "3ème ligne";
string[] lines = { a, b, c };
// Attention!!! Bloc note nommé "Electronique71"
File.WriteAllLines(@"C:\Users\Julien\Desktop\Electronique71.txt", lines);
}
}
}
|
Historiques
16/12/17
– Première mise à disposition
Dernière mise à jour le 01/11/2017
Présentation
Dans cette article, nous allons voir par calcul l’aspect physique du condensateur. Vous y trouverez 2 notes de calculs allant de la plus simple à la plus compliquées. La 1er note de calcul permet d’analyser des condensateurs de façon très simplifiés afin d’avoir une première approche et de comprendre le ou leurs comportements dans un montage électronique. (moi-même l’utilise car la charge d’un condensateur représenté par une droite affine ou linéaire est plus facile à comprendre!!)
- n°1
Note de calculs 1
- n°2
Note de calculs 2Historiques
01/11/2017
-1er mise à disposition
- n°2
Dernière mise à jour le 22/10/2017
Présentation
Le montage électronique présenté dans cette article, est un montage qui permet à partir d’une tension de fare varier un courant d’où son nom “Générateur de courant constant”. Le but est à partir d’une tension d’obtenir un courant proportionnel à cette tension qui sera appliquée sur l’entrée d’un amplificateur opérationnel. Afin d’avoir un courant qui représente “l’image” de la tension d’entrée, il est préférable d’utiliser des AOP de type “Rail to Rail”.
Schéma
Fonctionnement
J’ai utilisé l’AOP AD820, puisque celui-ci est du type “Rail to Rail”. Cet Gamme d’AOP permet d’obtenir en sortie une tension de 0 volts lorsque la tension sur la borne inverseuse et non inverseuse est égale à 0V.
Cet avantage est primordial puisque en sortie la tension ne génère aucune tension dirais-je “parasite”, ce qui aurait pus être le cas pour un AOP de type LM741, car la tension de sortie avoisine les 1,3V à 1,5V lorsque l’entrée inverseuse et non inverseuse est égale à 0V.
Le potentiomètre RV1, permet de modifier le courant qui parcours la led D1.
Lorsque ce potentiomètre est en haut, le courant sera nul ce qui entraîne l’extinction complète de la led D1.
Lorsque le potentiomètre est en bas, dans ce cas la led est allumée.
Courant
Vous allez me dire, “Mais Julien comment vous faites pour fixer le courant lorsque RV1 est en haut?“. Le raisonnementest le suivant, le montage proposé ci-dessus et un montage nommé suiveur, c’est-à-dire que la tension sur la borne inverseuse est égale à la tension sur la borne non inverseuse, si et seulement si la sortie de l’AOP est renvoyée sur l’entrée non inverseuse appelée boucle de rétroaction (en anglais feedback).
La formule magique devient donc I=(Vcc-E+)/R1 (avec Vcc la tension de la pile).
Ex: pour une tension E+=4,5V (potentiomètre réglé à moitié) I=(9-4,5)/1000=0,045 soit 4,5mA
Prototype
Pensez-vous que cela est vraiement nécessaire?
Circuit(s) imprimé(s)
Aucun, juste une vue en 3D pour voir la position des composants.
Historiques
22/10/2017
-1er mise à disposition
Dernière mise à jour le 09/10/2017
Présentation
Il vous arrives quelque fois de faire des tonnes et des tonnes de calculs et que ces valeurs que vous avez trouvées sur votre papier, ou votre cahier, ou bien l’énorme tableau blanc fixé au mur sont différentes avec les valeurs trouvées par simulation? Mais pourquoi avoir un écart aussi grand ou pourquoi les valeurs calculées non rien à voir avec la simulation ?
Cela tombe bien vous vous trouvez au bon endroit, et c’est ce que nous allons voir dans ce présent article.
Nous allons aborder dans un 1er temps les caractéristiques essentiels d’un transistor JFET puis ensuite nous allons simuler le montage électronique afin de faire la différence entre la théorie et la simulation.
Comment déterminer la transconductance gm
La formule la voici:
|
gm = (-2/Vp)*racine carré de (Idss*Id)
|
La tension de pincement du JFET est une donnée fondamentale du JFET, cette tension de pincement permet d’obtenir le courant Id=0mA, ce qui correspondrais à un interrupteur ouvert.
CANAL N Vgs < 0 – détermine Vp
(Exemple DataSheet d’un JFET Canal- N – la courbe à droite si Vgs=-2,5V environ Id=0A)
Pour un transistor JFET Canal-N, cette tension de pincement Vp peut être déterminée graphiquement en utilisant le graphique de simulation « Fonction de transfert » (voir Graph canal-N ci-dessous).
Il suffit de lire directement sur le graphique de la fonction de transfert du JFET et de vous placer sur le coté droit (partie saturée), puis de prendre la tension Vgs la plus basse
(elle correspond à la 1er « ligne » située en bas). Ainsi vous allez obtenir la tension de pincement Vp.
Pour un JFET canal-N, lorsque Vgs(off)<<0 (<< correspond à très inférieur) cela correspond à la tension de pincement Vp.
Graph Canal-N
CANAL P Vgs > 0 – détermine Vp
(Exemple DataSheet d’un JFET Canal- P – la courbe à droite si Vgs=3,5V environ Id=0A )
Pour un transistor JFET Canal-P, il suffit de faire exactement la même chose que précédemment. Si vous regardez bien le dataSheet du constructeur, vous allez vous apercevoir que cette valeur Vgs est supérieure à 0. Il en résulte que:
Pour un JFET canal-P, Vgs(off)>>0 (>> correspond à très supérieur) correspond à la tension de pincement Vp.
Graph Canal-P
Pas de graph Canal-P il suffit de prendre le graph du canal-N et d’enlever tout les signes “-” ainsi vous aurez la courbe d’un JFET canal-P, ce n’est pas plus compliqué que ça 😉
Courant de saturation Max Idss
Pour déterminer le courant Max il suffit encore une fois de prendre la partie la plus à droite de la courbe et la plus « haute ». Ainsi nous pouvons déterminer le courant IdssMax du transistor JFET. Il en est de même pour un transistor JFET à de Canal-P il suffit d’appliquer la même méthode.
Courant Id
Ce courant Id ce calcul avec les courant de repos (court-circuiter les sources de tension continu et ouvrir les générateurs de courants ainsi que les condensateurs).
Le courant qui circule sur le drain (D) est identique à celui qui circule sur la source (S).
Maintenant si vous appliquez tout ce qui a été dit précédemment vous pouvez dès à présent déterminer la transconductance gm en ampères/volt.
Paramétrer la “Fonction de Transfert”
Le montage ci-dessus permet de déterminer la fonction de transfert du JFET.
J’ai positionné, 2 sources de tensions Vds qui correspond à la chute de tension aux bornes du drain (D) et la source (S), et Vgs qui correspond à la chute de tension entre la grille (G) et la source (S).
Ce JFET comme vous pouvez le constater est un JFET à Canal-N, il en résulte que la tension Vgs est négative (N comme négatif), la tension va donc varier de 0 à – x (x une valeur). Si le JFET avait été un Canal-P la tension Vgs aurait été positive, la tension Vgs aurait donc variée de 0 à +x (x une valeur).
Paramétrer la courbe “Fonction de Transfert”
Pour ma part comme j’utilise un JFET Canal-N, j’ai donc placé sur :
Axe X correspond à Source 1 : Vds – paramétré de 0 à 5V
Axe Y correspond à Source 2 : Vgs – paramétré de 0 à -1V (tension Vgs négative)
Et voilà !! à quoi ressemble les caractéristiques de notre Transistor JFET, vous trouvez pas que cela ressemble au DataSheet du constructeur ?
Exemple 1: Simulation JFET 2N3819
Cette fois-ci passons au concret! Dans cet exemple j’utilise le 2N3819, je pouvais essayer un autre JFET, mais je me voyais mal à faire tout les exemples possible avec tout ces composant!!.
Calculs des valeurs et des composants
Plaçons le potentiel Va à Vcc/2 soit Va=Vds=9/2=4,5V. D’après la fonction de transfert pour une tension de 4,5V Id=10mA.
Calcul de R2
La résistance R2 est donc égale à R2 = (Vcc-Va)/Id=(9 – 4,5)/0,010= 450 Ohms
Calcul de la transconductance gm :
La formule est gm=(-2/Vp)*racine carre (Idss*Id)
Vp est la tension de pincement, cette tension de pincement est mesurable graphiquement, c’est-à-dire que plus la tension Vgs ira dans le négatif, et plus le courant sera nul.
Le principe est simple, on se place dans la zone de saturation et on prend la « ligne » située en bas du tableau
D’après le graphique il s’agirait d’une tension Vgs=-0,950V et un courant de 25uA. La tension de pincement Vgs(off) = -0,950V
Idss correspond au courant maxi, et d’après le graphique celui-ci est situé à 10mA.
En ce qui concerne le courant Id, c’est le courant que nous avons déterminé graphiquement précédemment et il est égal à 10mA.Gm=(-2/-0,950)*racine carré (0,010*0,010)=0,02105s
Calcul du gain
G = – gm*R2 = – 0,02105*450= – 9,47
Vout = Vin * 0,1 = 0,000707*(-9.47) = – 0,006695V soit – 6,695mV ce qui donne en valeur crête Vmax=0,006695*1,414=9,46mV
Vérifions :
Exemple 2: Simulation JFET 2N3819
Nous allons maintenant rajouter une résistance R3 entre la source et la masse ce qui nous donne ce nouveau schéma
Nous allons toujours maintenir la tension de 4,5V au point Va, et calculer la résistance R3 afin d’obtenir une tension Vgs à ses bornes de 0,350V soit -Vgs=Ur3 = 0,350V
Vds=Va-Ur3=4,5-0,350=4,15V.
Il faudra donc obtenir un Vgs de 0,350V pour une chute de tension de 4,15V aux bornes de Vds. Ainsi nous allons pouvoir déterminer graphiquement le courant Id ce qui nous donne graphiquement.
Calculs des valeurs et des composants
La valeur du courant Id=4,23mA
Calcul de R2
R2=(Vcc-Va)/Id=(9 – 4,5)/0,00423= 1063Ohms
Calcul de R3
R3=UR3/Id=0,350/0,00423=82 Ohms
Calcul de la transconductance gm
gm=(-2/Vp)*racine carre (Idss*Id)
avec Idss = 10mA (inchangé)
id = 4,23mA (déterminé graphiquement)
Vp = -0,950V (inchangé)
gm=(-2/-0,950)*racine carre (0,010*0,00423)
gm = 0,0136 soit 13,6 ms
Calcul du gain
Attention, pour ce nouveau montage électronique le gain est égale à :
G = – (gm*R2)/(1+gm*R3)
G = -(0,0136*1063)/(1+0,0136*82) = -6,835
Vout=Vin*G = 0,000707*(-6,835) = -0,004832 soit -4,832mV valeur crête Vmax=0,004832*1,414=6,833mV
