Non classé
Dernière mise à jour le xx/xx/18
En cours et pas terminé…
Présentation
Le Mini-32 possèdes 5 broches qui fournissent des sorties de comparaison (PWM) avec plusieurs possibilités que nous allons détailler ci-dessous. Mais avant de rentrer dans ces détails, ciblons ces 5 broches de comparaisons.
– PIN 46 (Broche RD0 du PIC) = OC1 correspond à la sortie de comparaison 1
– PIN 49 (Broche RD1 du PIC) = OC2 correspond à la sortie de comparaison 2
– PIN 50 (Broche RD2 du PIC) = OC3 correspond à la sortie de comparaison 3
– PIN 51 (Broche RD3 du PIC) = OC4 correspond à la sortie de comparaison 4
– PIN 52 (Broche RD4 du PIC) = OC5 correspond à la sortie de comparaison 5
Configuration des broches
Registre OCxCON
Le registre OCxCON (avec « x » à remplacer par 1 ou 2 ou 3 ou 4 ou 5 qui correspond aux 5 sorties de comparaisons toutes indépendantes) permet d’attribuer des bits correspondant dans chaque registres que nous désirons utiliser.
Ce registre est composé de plusieurs bits avec le bit :
ON : Permet d’activer le module de comparaison (non fonctionnel si le bit est à «0 »)
SIDL : Utilisation quand le CPU est en sommeil ou non
OC32 : Soit on utilise le timer sur 32 bits (plus de comptage) ou 16 bits (moins de comptage)
OCFLT : Une condition est survenue
OCTSEL : Permet de choisir le Timer 3 ou le Timer2
OCM : Encore là aussi beaucoup de choix (des pulsations en continu/ un seul impulsion/… (voir DataSheet)
Historiques
– xx/xx/18
Première mise à disposition.
Dernière mise à jour le 10/02/18
Présentation
Le MINI-32 possédant le PIC32MX534F064H dispose sur ces broches de 5 captures d’entrées (Input capture). Ces broches sont :
PIN 42 (Broche RD8 du PIC) = IC1 correspond à l’entrée de la capture 1
PIN 43 (Broche RD9 du PIC) = IC2 correspond à l’entrée de la capture 2
PIN 44 (Broche RD10 du PIC) = IC3 correspond à l’entrée de la capture 3
PIN 45 (Broche RD11 du PIC) = IC4 correspond à l’entrée de la capture 4
PIN 52 (Broche RD4 du PIC) = IC5 correspond à l’entrée de la capture 5
La particularité de ces broches, c’est qu’elles peuvent au total réaliser 5 captures différentes!! Reste à savoir ce qu’est une capture, et quelles sont les plus prioritaires par rapport aux autres situés sur ces 5 entrées.
Configuration des broches
Essayons de comprendre comment fonctionne ces captures en entrée de notre PIC32
Les cadres rouge représentes les entrées de capture.
Registre ICxCON
Le registre ICxCON (avec « x » à remplacer par 1 ou 2 ou 3 ou 4 ou 5 qui correspond 5 captures toutes indépendantes) permet d’attribuer des bits correspondant dans chaque registres que nous désirons utiliser.
Si nous décidons uniquement d’activer le module via le bit « ON » , il faudra donc attribuer le chiffre 1 dans la case ou est situé ON ce qui donnera d’après le tableau sur 32 bits :
00000000 00000000 10000000 00000000
(de gauche à droite 1er ligne du tableau de 8bits, 2ème ligne du tableau de 8 bits, 3ème ligne de tableau de 8 bits, etc…)
Si pour une autre raison vous décidez de rajouter le bits ICI ( sur 2 bits : bit 0 et bits 1) à 1 cela nous donne :
00000000 00000000 10000000 01100000
Vous voyez cela en fait des « 0 » et des « 1 » à écrire !! Vous ne trouvez pas ? La chance que vous avez puisque c’est uniquement sur 32 bits quand serait-t-il de 64 bits ou voir même 128 ??!! Attention aux tendinites !!!
Routine MikroPascal nous sauves !!!
Ouf !!! Oui !! Comme dis précédemment, heureusement que les routines sont là pour nous faciliter la tâche. Plutôt que d’attribuer des « 0 » ou des « 1 » logique, il suffit de récupérer ces bits situés dans la routine MikroPascal. En reprenant les exemples précédents cela nous donnerais :
L’activation du module “ON” devient avec la routine de MikroPascal:
|
ON__IC1CON_bit:=1;
|
Et pour activer “ICI” sur les 2 bits cela devient:
|
ON__IC1CON_bit:=1;
ICI0_bit:=1; // bit « 0 » à l’état logique 1 ICI1_bit:=1; // bit « 1 » à l’état logique 1 |
On s’aperçoit que c’est beaucoup plus parlant, plus simple et cela nous évite de faire des erreurs qu’en pensez-vous ?
Les autres bits ?
ON/SIDL/FEDGE/C32/ICTMR/ICI/ICOV/ICBNE/ICM ???? Mais c’est quoi tout ça? Et à quoi cela peut bien servir ? Si vous voulez des détails vous pouvez voir sur le DataSheets du constructeur.
Pour faire simple :
ON : Permet d’activer le module de capture 1/2/3/4/5 capture en même temps à vous de choisir
SIDL : soit en mode sommeil soit en mode continu (tout le temps actif)
FEDGE : la capture sur l’entrée correspondante se fait soit sur un front montant soit sur un front descendant
C32 : Vous utiliser soit un compteur qui compte sur 32 bits (de 0 à 429 496 72 95) soit sur 16 bit (de 0 à 65535)
ICTMR : Timer 2 / Timer 3 pour compter soit sur 16 bits soit sur 32 bits.
ICI : Un déclenchement d’interruption est réalisé soit sur 1 évènement soit sur 2 évènements soit sur 3 ou voir même sur 4 événements.
Remarques : Lorsque vous réglé le bit ICI , ce bit est à mis à l’état 1 logique sur le premier événements de capture et restera à l’état logique 1 tant que tous les événements de captures non pas été lus à partir du FIFO ou buffer (ICxBUF). Il en résulte qu’il faut lire ces évènements pour vider le Buffer.
– 1 évènement, il faut lire le buffer au moins 1 fois ou plus pour le vider
– 2 évènements, il faut lire le buffer au moins 2 fois ou plus pour le vider
– 3 évènements, il faut lire le buffer au moins 3 fois ou plus pour le vider
– 4 évènements, il faut lire le buffer au moins 4 fois ou plus pour le vider
Attention !! Ceci est primordial afin de pouvoir vider complétement et correctement le buffer !!
ICOV/ICBNE : sont des bits en lectures seules on ne peut uniquement lire ces bits mais on ne peut pas écrire dedans seul le PIC pilote ces bits !!
Le bit ICBNE est utilisé afin de vérifier si le buffer est vidé totalement. Le buffer se vide via le bit ICxBUF (x à remplacerpar 1 ou 2 ou 3 ou bien 4) voir plus bas…
ICM : l’entrée permet de compter le nombre de front qui arrive sur ces broches ICx (x à remplacer soit par 1 ou 2 ou 3 ou 4 ou 5). Soit un seul front soit 4 soit 16 ou bien un front montant et un front descendant il suffit de tester pour en avoir le cœur net !!
ICxBUF
Ce bit permet de lire le Buffer et par la même occasion une fois lu, le buffer est vidé en fonction de nombre d’évènements autorisés (1 événement = 1 lecture /2 événements = 2 lecture / etc…)
Schéma
Programme PIC32 Input Capture – 1 évenement et 4 fronts montant
Programme disponible aussi en MikroC
|
program PIC32_Input_Capture;
var |
Dans cet exemple, j’ai programmé le PIC32 afin qu’il puisse réaliser une capture sur chaque 4ème front montant en paramétrant correctement le bit ICM (bit 0/1/2). Le 4ème capture sur front montant déclenchera une interruption qui celle-ci allumera la led verte.
Petite précision tout de même au niveau du déclenchement de l’interrutpion. Il faut avant tout sélectionner le nombre d’événements qui correspond au bit ICI, celui-ci est mis à l’état logique “0” pour le bit 1 ainsi que le bit 0 de qui donne :
|
ICI0_bit:=0; // | Déclenchement de l’interruption
ICI1_bit:=0; // | sur le 1er événement |
Ces bits permettent de contrôler les événements, et il permet de “retarder” les interruptions en fonction du nombre d’événement choisi en agissant sur ces 2 bits. Dans notre cas, puisque ces 2 bits sont à l’état « 0 » il s’agit d’un événement et celui-ci va se produire au bout de la 4ème capture (ou 4ème front montant) puisque je le rappel nous avons régler le bit ICM sur 4 front montant.
Lorsque chaque front montant vont se produire sur la broche RD8 du PIC32, le 4ème front montant déclenchera l’interruption « IVT_INPUT_CAPTURE_1 » ainsi la led verte s’allumera et 1 seconde après nous viderons le buffer qu’une seule fois puisque il s’agit d’un seul événement. Attention !! Ne pas confondre l’événement et la capture.
Mais c’est quoi un événement ? Un événement correspond à un cycle, et on règle le nombre d’événement via le bit ICI. Reprenons l’exemple précédent. Puisque nous avons sélectionné une capture sur chaque 4ème front montant et que nous avons sélectionné 1 seul événement, il en résulte que tout les 4èmes fronts montant une interruption va se produire.
Je vais prendre un autre exemple afin que vous puissiez bien assimilé. Gardons toujours 4 front montant, mais cette fois-ci réglons les bits ICI afin d’obtenir 3 événements ! ! Cela nous donnerais ceci en termes de programmation :
|
ICI0_bit:=0; // | Déclenchement de l’interruption
ICI1_bit:=1; // | sur le 3ème évenement |
Il en résulte qu’il faudra 12 front montant pour déclencher l’interruption
– 1er événement = 4 front montant;
– 2ème événement = 8 front montant;
– 3ème événement = 12 front montant;
4 événements et 4 fronts montants encore un exemple!
Continuons sur un autre exemple tout en gardant le même schéma électronique. Ici le programme qui va suivre est réalisé sur 4 événements et 4 fronts montants. Je vous laisse lire le programme qui va suivre. Notez que le buffer est vidé 4 fois!!
|
ICI0_bit:=1; // | Déclenchement de l’interruption
ICI1_bit:=1; // | sur le ‘ème événement |
Ces bits permettent de contrôler les événements, et il permet de “retarder” les interruptions en fonction du nombre d’événement choisi en agissant sur ces 2 bits. Dans notre cas, puisque ces 2 bits sont à l’état « 0 » il s’agit d’un événement et celui-ci va se produire au bout de la 4ème capture (ou 4ème front montant) puisque je le rappel nous avons régler le bit ICM sur 4 front montant.
Lorsque chaque front montant vont se produire sur la broche RD8 du PIC32, le 4ème front montant déclenchera l’interruption « IVT_INPUT_CAPTURE_1 » ainsi la led verte s’allumera et 1 seconde après nous viderons le buffer qu’une seule fois puisque il s’agit d’un seul événement. Attention !! Ne pas confondre l’événement et la capture.
Mais c’est quoi un événement ? Un événement correspond à un cycle, et on règle le nombre d’événement via le bit ICI. Reprenons l’exemple précédent. Puisque nous avons sélectionné une capture sur chaque 4ème front montant et que nous avons sélectionné 1 seul événement, il en résulte que tout les 4èmes fronts montant une interruption va se produire.
Je vais prendre un autre exemple afin que vous puissiez bien assimilé. Gardons toujours 4 front montant, mais cette fois-ci réglons les bits ICI afin d’obtenir 3 événements ! ! Cela nous donnerais ceci en termes de programmation :
Programme disponible aussi en MikroC
|
program PIC32_Input_Capture;
var |
Comment Allumée la led rouge?
êtes vous posé la question concernant la led rouge? et bien si vous voulez quelle s’allume reprenez le code ci-dessus et supprimer juste cette ligne:
|
ViderBufferLecture4:=IC1BUF; // 4ème lecture pour effacer la 4ème évenement de capture
|
Mais pourquoi elle s’allume maintenant Et bien comme dis précédemment sur 4 événements il faut vider 4 fois le buffer tout simplement 😉
Historiques
– 10/02/18
Programmation disponible aussi en MikroC.
– 03/02/18
Première mise à disposition.
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
