Programmes de tests pour carte PICDEM.net 2

Cette article présente une suite de petits programmes qui m’ont permis de découvrir la carte PICDEM.net 2 et le compilateur C C18. Je n’aborde pas ici la pile TCP/IP mais des concepts beaucoup plus basiques tel que:

  • la commande de DELs
  • l’utilisation des boutons poussoirs
  • la lecture du potentiomètre et du capteur de température : utilisation du convertisseur analogique numérique (CAN)
  • la commande de l’afficheur LCD
  • l’utilisation de la voie série
  • l’utilisation de l’EEPROM externe en mode SPI
  • les interruptions (Timer, USART, PortB, …)

Remarquez que ces programmes ne sont en rien « spécifique » à cette carte et au PIC18F97J60 mais sont utilisables sur une carte de test classique équipée d’un PIC18F2520 par exemple.
Imprimer cet article Imprimer cet article

Le schéma de la carte PICDEM.net 2 est donné dans la documentation de cette carte par MicroChip. Je suppose que l’environnement de développement MPLAB et le compilateur C18 sont installés. Comme je débute avec C18, j’utilise l’assistant de création de projet : menu Project->Project Wizard. J’utilise aussi comme base de départ le document de présentation du compilateur C18 de l’académie d’Aix-Marseille et le document « MPLAB C18 C Compiler : Getting Started ».

Présentation de la carte

Implantatio de la carte PicDem.net2

  1. PIC18f97j60 : PIC avec contrôleur ethernet embarqué
  2. ENC28J60 : contrôleur ethernet externe
  3. 25LC256 : Mémoire EEPROM SPI
  4. Afficheur LC 2×16 caractères compatible HD44780
  5. Connecteur pour afficheur LCD externe optionnel
  6. Capteur de température TC1047
  7. Huit dels connectées au port J du PIC
  8. Quatre boutons poussoirs connectés au port B du PIC (portB<3:0>)
  9. Potentiomètre de 10K relié entre la masse et le +3,3V relié à l’entrée analogique AN2
  10. Bouton de Reset du PIC
  11. Connecteur RJ45 pour ethernet 10base-T (1 pour connexion directe au PIC, 1 pour connexion au ENC28J60)
  12. Connecteur RJ12 pour programmation in-situ du PIC (compatible avec le programmateur PicKit2)
  13. Connecteur DB9 pour port série à la norme RS232 (liaison PC). J’ai rajouté un connecteur HE10-10 pour avoir une connexion série à la norme TTL.
  14. Port d’extension compatible PICTail
  15. Zone de prototypage
  16. Connecteur d’alimentation : continu de 7V à 15V
  17. Del de précense d’alimentation
  18. Sous la carte, deux autocollants avec les adresses MAC pour chacun des connecteurs ethernet

Projet1 : allumer des diodes !

Le premier projet MPLAB aura donc comme nom « DELs ». Je rajoute un fichier source avec le nom « dels.c ». Le contenu de ce fichier est le suivant:

Les fusibles de programmation seront réglés par le menu Configure->Configuration Bits… comme dans la capture ci-dessous. Vous pouvez configurer les fusibles directement dans le code, là c’est juste la flemme 🙂

fusibles-pour-pic18f97j60-sur-carte-picdemnet-2

Si lors de la compilation le linker ne trouve pas le fichier « c018i.o », c’est que les chemins de recherche sont mal définis. J’ai résolu le problème par le menu Project->Build Options…->Project puis dans l’onglet Directories j’ai cliquez sur le bouton Suite Defaults. Si le linker échoue toujours, il faut regarder si les chemins sont configurés correctement dans Project->Set Language Tools Locations->Microchip C18->Default Search Path et positionnez correctement toutes les entrées.

La programmation s’effectue avec un PICkit2 par le menu Programmer->Select Programmer->PICkit2 puis par Programmer->Program. Pensez à relâcher le RESET par Programmer->Release from Reset. Les 8 dels doivent clignoter.

Projet2 : Tester les boutons poussoirs

Création d’un nouveau projet « bp ». Ajout d’un fichier « bp.c ». Le code source de ce fichier est visible ci-dessous:

Lors de l’appui d’un bouton, la del correspondante s’allume.

Remarque: je trouvais lourd d’avoir à programmer le PIC puis à relâcher la ligne de RESET. Or dans le menu Programmer->Settings (si vous avez choisi un programmateur), vous pouvez choisir différentes options pour votre programmateur. J’ai donc choisi de relâcher la ligne de RESET après une programmation réussie (Run after a successful program) et de lancer une programmation automatique après chaque compilation réussie (Program after a successful build).

Projet3 : Utilisation du CAN (lecture potentiomètre et capteur de température)

Création d’un projet « CAN-Pot » et d’un fichier source en C « can-pot.c ». Pour ce premier test du CAN, je vais utiliser la doc et les registres internes du PIC. Je vais donc être au plus prêt du matériel mais la lisibilité du code s’en ressent :

Après compilation et programmation, tout fonctionne comme attendu. Les 8 bits de poids fort du résultat de la conversion s’affiche sur les dels.

Je « recode » le même programme en utilisant les bibliothèques de fonctions standards fourni par MicroChip. Pour cela il faut utiliser le document MPLAB-C18-Libraries. Ci-dessous le code source :

#include <p18f97j60.h>      // PIC utilisé sur PICDEM.net 2
#include <delays.h>         // Fonctions de delai
#include <adc.h>            // Fonctions pour le CAN

void main(void)             // Prog principal
{
volatile unsigned int resultat_CAN;     // Variable pour stocker le résultat du CAN

TRISJ=0x00;                // port J en sortie (dels)
TRISA=0x0C;                // Potentiometre sur AN2
// Capteur de Temperature sur AN3
// Ces deux broches doivent être en entrée

OpenADC( ADC_FOSC_64 &
ADC_LEFT_JUST &    // Alignement à gauche dans la variable resultat_CAN
ADC_20_TAD,
ADC_CH2 &          // Choix du canal à numériser
ADC_INT_OFF &      // Pas d’interruption
ADC_REF_VDD_VSS,   // Vref+=Vdd=3,3V Vref-=VSS=0V
11 );              // Masque pour indiquer les entrées A et N

Delay10TCYx( 5 );           // Delai de 10*5 cycles

while (1)                   // Boucle infinie
{
ConvertADC();           // Lance la conversion
while( BusyADC() );     // Attend que la conversion soit finie
resultat_CAN = ReadADC();   // Stocker le résultat dans un entier non signé 16bits
PORTJ = resultat_CAN>>8;    // PortJ est un port 8 bits, on récupère les 8 bits
// de poids fort de resultat_CAN
Delay10KTCYx(1);    // Attente de 10 000*1 cycles
}                        // Fin boucle infinie
}

J’ai eu beaucoup plus de mal à faire fonctionner ce petit programme car la doc n’est pas très explicite sur comment utiliser les tensions de référence du CAN. En essayant ADC_REF_VDD_VSS, c’est à dire Vref+=VDD et Vref-=GND, le programme fonctionne. Par contre il faut reconnaitre que c’est plus lisible.

Je passe maintenant au test du capteur de température. Celui-ci est un TC1047 de chez MicroChip.  Ce capteur peut mesurer des températures de -40°C à +125°C. Il est donné pour fournir 500mV à 0°C et a une sensibilité de +10mV/°C. La seule ligne a changé dans le code précédent est le choix du canal à numériser dans la ligne OpenADC : ADC_CH2 par ADC_CH3. Après recompilation et programmation, les dels affichent effectivement la « température » et celle-ci varie lorsque je pose mon doigt sur le capteur. Faisons un calcul pour vérifier la conversion, notez que celle-ci est loin d’être optimale puisque on numérise entre 0V et 5V. Or le capteur fournit une tension comprise entre 0,1V (-40°C) et 1,75V (+125°C). De plus je n’utilise que les 8 bits de poids forts d’où le quantum vaut (3,3V-0V)/255 = 12,94mV. En lisant les dels j’obtient le chiffre 58 soit une tension numérisée de 58*12,94mV = 0,75V soit une température de T=(0,75-0,5)/10mV soit T=25°C. La température est correcte !

Projet4 : Utilisation de la voie série

Maintenant que l’on sait lire la température, il serait intéressant de l’envoyer vers un PC par le biais d’une voie série RS232. La carte PICDEM.net 2 est équipée d’un connecteur DB9 et d’un convertisseur de tension type MAX232 pour mettre les bons niveaux de tensions. Dans ce programme, je vais utiliser la bibliothèque de fonctions fourni par MicroChip. Le PIC18F97J60 possède deux USART indépendantes. Celle qui est câblée sur la carte est la première. J’ouvre donc un nouveau projet dans MPLAB avec le nom « uart » ainsi qu’un nouveau code « uart.c ». Le code est donné ci-dessous:

#include <p18f97j60.h>      // PIC utilisé sur PICDEM.net 2
#include <delays.h>         // Fonctions de delai
#include <adc.h>            // Bibliothèque de fonctions pour le CAN
#include <usart.h>          // Bibliothèque de fonctions pour l’USART

void initialisation(void)
{
TRISJ=0x00;                // port J en sortie (dels)
TRISA=0x0C;                // Potentiometre sur AN2
// Capteur de Temperature sur AN3
// Ces deux broches doivent être en entrée

OpenADC( ADC_FOSC_64 &
ADC_LEFT_JUST &    // Alignement à gauche dans la variable resultat_CAN
ADC_20_TAD,
ADC_CH3 &
ADC_INT_OFF &
ADC_REF_VDD_VSS,
11 );

Open1USART( USART_TX_INT_OFF &      // Initialisation voie série
USART_RX_INT_OFF &
USART_ASYNCH_MODE &
USART_EIGHT_BIT &
USART_CONT_RX &
USART_BRGH_HIGH,
80 );           // Vitesse 19200 voir tableau dans doc officiel du 18F97J60
}

void main(void)                         // Prog principal
{
volatile unsigned int resultat_CAN;

initialisation();                   // Appel de la fonction d’initialisation

while (1)                           // Boucle infinie
{
ConvertADC();                   // Lance la conversion
while( BusyADC() );             // Attend que la conversion soit finie
resultat_CAN = ReadADC();       // Stocker le résultat dans un entier non signé 16bits
PORTJ = resultat_CAN>>8;        // PortJ est un port 8 bits, on récupère les 8 bits
// de poids fort de resultat_CAN
Write1USART( resultat_CAN>>8 ); // Ecriture sur la voie série 1 du résultat du CAN
Delay10KTCYx(1);                // Attente de 10 000*1 cycles
}                                    // Fin boucle infinie
}

C’est assez lisible comme code à condition de lire la documentation des bibliothèques. Comme je n’ai plus de port série DB9 sur mon portable, je jette un coup d’œil sur la ligne TX avec un oscilloscope et je retrouve bien la donnée affichée par les dels. La transmission s’effectue bien à 19200 bauds/s en 8N1.

Projet5: Mise en œuvre de l’afficheur LCD

Comme je ne peux pas connecter la voie série, je vais afficher la température sur l’afficheur LCD de la carte. MicroChip fournit une bibliothèque de fonctions pour gérer un afficheur compatible HD44780 du nom de XLCD. Je vais donc tester cette bibliothèque. Et c’est avec beaucoup de mal que j’obtient enfin un résultat. Il faut tout d’abord modifier le fichier « xlcd.h » disponible dans les fichiers include du compilateur C18 pour adapter le cablage de l’afficheur LCD à la carte PICDEM.net 2. J’obtient donc le fichier suivant:

/* Interface type 8-bit or 4-bit
* For 8-bit operation uncomment the #define BIT8
*/
// Afficheur LCD sur carte PICDEM.net 2
#define BIT8

/* When in 4-bit interface define if the data is in the upper
* or lower nibble.  For lower nibble, comment the #define UPPER
*/
/* #define UPPER */

/* DATA_PORT defines the port to which the LCD data lines are connected */
#define DATA_PORT              PORTE
#define TRIS_DATA_PORT         TRISE

/* CTRL_PORT defines the port where the control lines are connected.
* These are just samples, change to match your application.
*/
#define RW_PIN   PORTHbits.RH1           /* PORT for RW */
#define TRIS_RW  TRISHbits.TRISH1        /* TRIS for RW */

#define RS_PIN   PORTHbits.RH2           /* PORT for RS */
#define TRIS_RS  TRISHbits.TRISH2        /* TRIS for RS */

#define E_PIN    PORTHbits.RH0          /* PORT for E  */
#define TRIS_E   TRISHbits.TRISH0        /* TRIS for E  */

Lors de la compilation, le LCD restait désespérément muet ! J’ai donc cherché une solution sur différents forums. Il existe deux solutions à ce problème. La solution la plus simple est de mon point de vue de faire recompiler toute la partie gestion du LCD en insérant les fichiers source dans le projet MPLAB (voir capture d’écran ci-dessous) et PAS de créer une nouvelle librairie (la seconde solution, beaucoup trop lourde).

fichiers-necessaire-a-la-compilation-de-la-librairie-xlcd

Faire bien attention à l’initialisation du LCD sinon seul le premier caractère s’affiche. Il manque aussi quelques fonctions de bases à XLCD comme un « gotoxy » ou un « clearscreen ». Une fois le problème du LCD résolu, un autre problème apparait. Comment transformer un nombre flottant en chaine de caractères. La fonction « ftoa » n’existe pas dans la librairie standard de MicroChip. Cependant, ce problème a été traité de nombreuses fois (faire une recherche avec ftoa dans les forums de MicroChip) et il existe plusieurs solutions. Pour ma part, j’ai choisi une solution relativement simple avec la fonction « sprintf » (consultez le code !). Enfin tout fonctionne maintenant, j’affiche sur la première ligne du LCD le résultat brut de la conversion du capteur de température en sortie du CAN et sur la deuxième ligne la température en degré. Le code est présenté ci-dessous :

#include <p18f97j60.h>      // PIC utilisé sur PICDEM.net 2
#include <stdio.h>          // Bibliothèque d’entrées/sorties standard (ici pour sprintf)
#include <delays.h>         // Fonctions de delai
#include <adc.h>            // Bibliothèque de fonctions pour le CAN
#include <usart.h>          // Bibliothèque de fonctions pour l’USART
#include <xlcd.h>           // Bibliothèque de fonctions pour LCD
// Cela permet de définir les broches connectées
// au LCD

// Les trois fonctions suivantes sont nécessaires pour XLCD
void DelayFor18TCY(void)    // un delay de 18 cycles mini
{
Delay10TCYx(2);
}

void DelayPORXLCD(void)     // un delai de 15ms
{                           // cycles = (delai * Fosc) / 4
Delay1KTCYx(94);        // cycles = (15ms * 25Mhz) / 4 = 93750
}

void DelayXLCD(void)        // un delai de 5ms
{
Delay1KTCYx(32);        // cycles = (5ms * 25MHz ) / 4 = 31250
}

void initialisation(void)
{
TRISJ=0x00;                // port J en sortie (dels)
TRISA=0x0C;                // Potentiometre sur AN2
// Capteur de Temperature sur AN3
// Ces deux broches doivent être en entrée

OpenADC( ADC_FOSC_64 &
ADC_LEFT_JUST &    // Alignement à gauche dans la variable resultat_CAN
ADC_20_TAD,
ADC_CH3 &
ADC_INT_OFF &
ADC_REF_VDD_VSS,
11 );

Open1USART( USART_TX_INT_OFF &      // Initialisation voie série
USART_RX_INT_OFF &
USART_ASYNCH_MODE &
USART_EIGHT_BIT &
USART_CONT_RX &
USART_BRGH_HIGH,
80 );           // Vitesse 19200 voir tableau dans doc officielle du PIC18F97J60

OpenXLCD( EIGHT_BIT & LINES_5X7 );      // Initialisation du LCD en mode 8 bits, 2 lignes, caractères 5×7
WriteCmdXLCD( CURSOR_OFF & BLINK_OFF);  // Effacement du curseur
WriteCmdXLCD( SHIFT_DISP_LEFT );        // Déplacement du curseur aprés chaque caractère
}

void main(void)             // Prog principal
{
volatile unsigned int resultat_CAN;     // variable contenant le résulat sur 10 bits de la conversion
char buffer[20];                        // un tableau de caractères qui contiendra la coversion flottant vers ascii

initialisation();                       // Appel de la fonction d’initialisation

while (1)                               // Boucle infinie
{
ConvertADC();                       // Lance la conversion
while( BusyADC() );                 // Attend que la conversion soit finie
resultat_CAN = ReadADC();           // Stocker le résultat dans un entier non signé 16bits
PORTJ = resultat_CAN>>8;            // PortJ est un port 8 bits, on récupère les 8 bits
// de poids fort de resultat_CAN
Write1USART( resultat_CAN>>8 );     // Ecriture sur la voie serie du résultat de conversion
SetDDRamAddr(0);                    // On se positionne au début de la première ligne du LCD
putrsXLCD( « Temp. CAN:  » );         // On affiche une chaine située en flash (put’r’s) sur le LCD
sprintf (buffer, « %u », resultat_CAN>>8);    // On ecrit dans buffer la conversion en chaine
// de caractères des 8 bits de poids fort de resultat_CAN
putsXLCD( buffer );                 // On affiche ‘buffer’ sur le LCD
SetDDRamAddr(0x40);                 // On passe à la deuxième ligne du LCD
putrsXLCD( « Temp. DEG: « );          // On affiche la chaine situé en flash
sprintf (buffer, »%d », (int)((((resultat_CAN>>8)*0.0129)-0.5)*100)); // on ecrit dans buffer la
// chaine de cractère qui correspond à la conversion en °C
// de la tension issu du capteur de température. Ici ce sera
// un nombre entier
putsXLCD( buffer );                 // On l’affiche sur le LCD

Delay10KTCYx(1);                    // Attente de 10 000*1 cycles
}                                        // Fin boucle infinie
}

On peut améliorer le code en faisant par exemple 128 mesures de la température et faire une moyenne, afficher la température avec deux chiffres avant la virgule et un après (chiffre non significatif ici) ou encore rajouter quelques fonctions de gestion du LCD. Un exemple avec ces améliorations est donné ci-dessous:

#include <p18f97j60.h>      // PIC utilisé sur PICDEM.net 2
#include <stdio.h>          // Bibliothèque d’entrées/sorties standard (ici pour sprintf)
#include <delays.h>         // Fonctions de delai
#include <adc.h>            // Bibliothèque de fonctions pour le CAN
#include <xlcd.h>           // Bibliothèque de fonctions pour LCD
// Cela permet de définir les broches connectées
// au LCD

// Les trois fonctions suivantes sont nécessaires pour XLCD
void DelayFor18TCY(void)    // un delay de 18 cycles mini
{
Delay10TCYx(2);
}

void DelayPORXLCD(void)     // un delai de 15ms
{                           // cycles = (delai * Fosc) / 4
Delay1KTCYx(94);        // cycles = (15ms * 25Mhz) / 4 = 93750
}

void DelayXLCD(void)        // un delai de 5ms
{
Delay1KTCYx(32);        // cycles = (5ms * 25MHz ) / 4 = 31250
}

// Fonctions supplémentaires pour le LCD, libellé des fonctions en anglais
void GotoxyXLCD(unsigned char x, unsigned char y) // Déplacement du curseur en Y (0 ou 1) et X (0 à 15)
{
if (y<2 && x<16)
{
if (y) SetDDRamAddr(0x40+x);
else SetDDRamAddr(x);
}
}

void ClearScreenXLCD(void)
{
static rom const unsigned char vide[]= »                « ;   // chaine d’espace pour effacer le LCD (16 caractères)

GotoxyXLCD(0,0);
putrsXLCD(vide);
GotoxyXLCD(0,1);
putrsXLCD(vide);
}

void initialisation(void)
{
TRISJ=0x00;                // port J en sortie (dels)
TRISA=0x0C;                // Potentiometre sur AN2
// Capteur de Temperature sur AN3
// Ces deux broches doivent être en entrée

OpenADC( ADC_FOSC_64 &
ADC_LEFT_JUST &    // Alignement à gauche dans la variable resultat_CAN
ADC_20_TAD,
ADC_CH3 &
ADC_INT_OFF &
ADC_REF_VDD_VSS,
11 );

OpenXLCD( EIGHT_BIT & LINES_5X7 );      // Initialisation du LCD en mode 8 bits, 2 lignes, caractères 5×7
WriteCmdXLCD( CURSOR_OFF & BLINK_OFF);  // Effacement du curseur
WriteCmdXLCD( SHIFT_DISP_LEFT );        // Déplacement du curseur aprés chaque caractère

GotoxyXLCD(0,0);                        // Message de bienvenue
putrsXLCD( « Capteur Temp » );
GotoxyXLCD(0,1);
putrsXLCD( « O. Dartois » );
Delay10KTCYx(255);
Delay10KTCYx(255);
Delay10KTCYx(255);
Delay10KTCYx(255);
ClearScreenXLCD();
}

void main(void)             // Prog principal
{
unsigned char i;                        // variable sur 8 bit pour une boucle
volatile unsigned int resultat_CAN;     // variable contenant le résulat sur 10 bits de la conversion
char buffer[20];                        // un tableau de caractères qui contiendra la conversion flottant vers ascii
float temperature;                      // la variable qui accueille le calcul de température
int temp_entiere, temp_virgule;         // deux variables entières pour réaliser la conversion flottant vers ascii

initialisation();                       // Appel de la fonction d’initialisation

while (1)                               // Boucle infinie
{
resultat_CAN = 0;                   // remise à zero de la variable
for (i=0;i<128;i++) {               // On fait 128 acquisition pour augmenter artificiellement la résolution (surechantillonage)
Delay1KTCYx(32);                // On attends 5ms -> cycles = (5ms * 25MHz ) / 4 = 31250, Fosc=25MHz
ConvertADC();                   // Lance la conversion
while( BusyADC() );             // Attend que la conversion soit finie
resultat_CAN += ADRESH;         // Stocker les 8 bits de poids fort issu du CAN dans un entier non signé 16bits
}
resultat_CAN >>=7;                  // Division par 128 pour faire la moyenne
PORTJ = resultat_CAN;               // Affichage sur les dels

temperature = ((resultat_CAN*0.0129)-0.5)*1000; // Conversion tension vers température *10
// pour recuperer 1 chiffre aprés la virgule (vor ci-dessous)
temp_virgule = (int)(temperature) % 10;         // Récupération de la partie décimale
temp_entiere = (int)(temperature / 10);         // Récupération de la partie entière
GotoxyXLCD( 0,0 );                  // On se positionne au début de la première ligne du LCD
putrsXLCD( « Temp. CAN:  » );         // On affiche une chaine située en flash (put’r’s) sur le LCD
sprintf (buffer, « %4u », resultat_CAN);    // On ecrit dans buffer la conversion en chaine
// de caractères des 8 bits de poids fort de resultat_CAN
putsXLCD( buffer );                 // On affiche ‘buffer’ sur le LCD
GotoxyXLCD( 0,1 );                  // On passe à la deuxième ligne du LCD
putrsXLCD( « Temp. DEG: « );          // On affiche la chaine situé en flash
sprintf (buffer, »%02d.%1d », temp_entiere, temp_virgule ); // on ecrit dans buffer la
// chaine de cractère qui correspond à la conversion en °C
// de la tension issu du capteur de température. Ici ce sera
// un nombre XX.Y où XX et Y sont des nombres entiers signés (%d)
putsXLCD( buffer );                 // On l’affiche sur le LCD
}                                        // Fin boucle infinie
}

Projet6: Suite de la mise en oeuvre de l’afficheur LCD : BarGraph

Dans plusieurs exemple de montage sur Internet, il n’est pas rare de trouver un afficheur LCD utilisé en « BarGraph ». C’est à dire une barre qui augmente ou diminue en fonction du phénomène que l’on mesure. Je me suis donné comme but dans ce projet de réaliser un bargraph sur la deuxième ligne de l’afficheur LCD qui réagisse à la tension donnée par le potentiomètre. Pour que le bargrah soit plus joli, il faut redéfinir des caractères de l’afficheur LCD. On dispose de huit caractères personnalisables. La matrice d’un caractère fait 5×8 (5 colonnes sur 8 lignes). Je redéfinis donc un caractère vide, un caractère avec une barre verticale puis deux puis trois puis quatre. Le caractère plein existe déjà dans le jeu de caractère de l’afficheur LCD. La redéfinition des caractères est donnée ci-dessous :

L’exploitation de ces nouveaux caractères avec un « bargraph » est présenté ci-dessous :

Ce qui donne en vidéo (de mauvaise qualité) ceci:

Projet7: Utilisation des interruptions – Le timer0

Dans un PIC18F, vous avez deux niveaux d’interruptions : haute et basse. Au moment ou vous activez une interruption, vous pouvez la déclarer en haute priorité ou basse priorité. Lorsqu’une interruption se déclenche, le PIC saute alors à deux adresses spéciales:

  • l’adresse 0x08 : adresse pour les interruptions hautes priorités
  • l’adresse 0x18 : adresse pour les interruptions basses priorités

A partir de là, il faut examiner les drapeaux pour savoir quelle interruption a été levé et rediriger vers la fonction adéquate. Pour déclarer les interruptions en C, il faut utiliser un vocabulaire particulier (se reporter au code ci-dessous) pour déclarer le vecteur d’interruption et les fonctions d’interruptions. Dans l’exmple ci-dessous, on utilise le timer0 en mode 16 bits pour faire clignoter la DEL de poids faible du port J tout en faisant « battre » un coeur sur l’afficheur LCD (imitation d’un signal « heartbeat »). Le code est donné ci-dessous:

Projet7: Utilisation des interruptions – Le timer1 – Horloge temps réel

La carte est équipée d’un oscillateur secondaire à 32768Hz connecté aux entrées d’oscillateur du timer1. Cela permet entre autre de réaliser une horloge temps réel (Real Time Clock = RTC) avec ce timer ou encore d’utiliser ce quartz comme source d’horloge basse consommation. Le programme ci-dessous réalise donc une horloge avec affichage sur l’affichage LCD. En laissant tourner le programme, j’ai observé « en gros » une dérive de 3s par jour, ce qui est correcte compte tenu de la qualité du quartz et que je ne compense pas le temps mis pour traiter l’interruption. Pour réaliser une horloge sans trop de dérive avec un timer plusieurs méthodes sont décrites sur le forum du compilateur Hi-Tech C ( lire XX). Le code est présenté ci-dessous :

Imprimer cet article Imprimer cet article

6 réflexions au sujet de « Programmes de tests pour carte PICDEM.net 2 »

  1. marie

    bonjour j’ai un problème et j’ai besoin de votre aide
    j’ai un signal analogique que je doit convertir a l’aide du convertisseur intègre dans le pic 18F252 et afficher ce résultat numérique sur LCD
    et mon pic est connecter par voie série (deux broches TX RX) a un module sans fil qui est le xbee.
    alors mon problème c’est bien la programmation du pic18F252
    esq ce programme que vous avez réalise peu fonctionner dans mon cas si c’est non esq vous pouvez m’aider
    merci et j’attend votre réponse je suis prise par le temps je dois en finir le plus vite possible

  2. elrix

    Vous pouvez utiliser les programmes de l’article, il vous faut juste le compilateur C18 et changer l’include de départ par un #include p18f252.h en mettant les signes < et > autour de p18f252.h. Ensuite le reste doit fonctionner…

    Bon courage

    Olivier

  3. marie

    bonjour je v vous déranger encor un peu avec mes questions de débutante dans le domaine de parogrammation C.
    la carte que j’ai réaliser comporte un quartz de 4MHZ et je veux bien programmer ma connexion série avec une vitesse de 9600bauds N-1-8
    et la je me suis un petit peu perdue dans ces instructions
    mon deuxieme problem c’est la compilation de mon programme avec C18 j’ai suivit toute les étapes pour mais une fois je l’éxcute avec F10 (make) sa m’affiche le message suivant :
    Make: The target « C:\Users\nawel\Desktop\mplab\elecronique innovante.o » is out of date.
    Executing: « C:\Program Files\MPLAB IDE\MCHIP_Tools\mcc18.exe » -p=18F252 « elecronique innovante.c » -fo= »elecronique innovante.o » -Ou- -Ot- -Ob- -Op- -Or- -Od- -Opa-
    Skipping link step. The project contains no linker script.
    BUILD FAILED: Mon Aug 02 20:43:29 2010

    j’ais ésaiyer en ajoutant aussi le linker o.c dans le nom du fichier sa a marcher au début mé la sa marche plus je sais pas pour quoi?
    j’ais encor ésaiyer en ajoutant le 18F252.lkr dans mon projet sa marche toujours pas?
    je souhaite bien recevoir votre réponse le plus vite possible puisque comme je vous ais dit avant j’ais pas trop de temps je suis prise par le temps
    merci d’avance.

  4. marie

    bonjour j’attends toujours votre réponse je travaille dessus depuis plus d’une semaine et j’ai toujours le même problème
    s’il vous plais j’ai vraiment besoin de votre aide
    merci d’avance

  5. marie

    bonjour
    j’ai ésaiyé votre programme il marche pas la compilation ne s’affectuer même pas sa m’affiche des fautes
    je sais pas quoi faire il me reste 2semaines pour réussir a faire marché ma plaque et la je lé toujours pas fais
    svp aidez mois

Laisser un commentaire

Votre adresse de messagerie ne sera pas publiée. Les champs obligatoires sont indiqués avec *