Ce petit programme *très* simple utilise une fonction de délai pour allumer et éteindre à intervalles réguliers une led. Voici le code source du programme, que nous allons expliquer pas à pas.

Ce code a été compilé pour tourner à la fréquence de 40Mhz (quartz de 10Mhz et PLL activé). Le PLL est activé par la section de code entre #pragma à la fin du programme.

#include <delays.h> // fonctions de délais
#include <p18f252.h>// déclarations pour le PIC18F252

void main (void)
{
	// on configure le pin 0 du port A en sortie
	TRISAbits.TRISA0 = 0;
	
	while(1)
	{
		// on allume la led en mettant le pin 0 à l'état haut
		PORTAbits.RA0 = 1;
		// on attends environ 0,25s à 40Mhz
		Delay10KTCYx(0);
		// on éteint la led en mettant le pin 0 à l'état bas
		PORTAbits.RA0 = 0;
		// on attends environ 0,25s à 40Mhz
		Delay10KTCYx(0);
	}

}

#pragma romdata CONFIG
_CONFIG_DECL (
_CONFIG1H_DEFAULT & _OSC_HSPLL_1H,
_CONFIG2L_DEFAULT & _PWRT_ON_2L,
_CONFIG2H_DEFAULT & _WDT_OFF_2H,
_CONFIG3H_DEFAULT,
_CONFIG4L_DEFAULT & _STVR_OFF_4L & _LVP_OFF_4L 
   & _DEBUG_OFF_4L,
_CONFIG5L_DEFAULT & _CP0_OFF_5L & _CP1_OFF_5L 
   & _CP2_OFF_5L & _CP3_OFF_5L,
_CONFIG5H_DEFAULT & _CPB_OFF_5H & _CPD_OFF_5H,
_CONFIG6L_DEFAULT & _WRT0_OFF_6L & _WRT1_OFF_6L 
   & _WRT2_OFF_6L & _WRT3_OFF_6L,
_CONFIG6H_DEFAULT & _WPC_OFF_6H & _WPB_OFF_6H 
   & _WPD_OFF_6H,
_CONFIG7L_DEFAULT & _EBTR0_OFF_7L & _EBTR1_OFF_7L 
   & _EBTR2_OFF_7L & _EBTR3_OFF_7L,
_CONFIG7H_DEFAULT & _EBTRB_OFF_7H
); 
#pragma romdata

Ne partez pas revenez! Oui je sais, c'est un peu rébarbatif tout ce fatras, mais si on y regarde à plus près, y'a quasiment rien! Je m'explique : voici de quoi est constitué le programme (pour savoir de quoi je parle, il vous faudra avoir quelques notions de bases en programmation C, mais je vous rassure, très peu!).

#include <delays.h> // fonctions de délais
#include <p18f252.h>// déclarations pour le PIC18F252

La première ligne inclu la librairie avec les fonctions de délai. C'est dans cette librairie que se trouve la fonction "Delay10KTCYx(0);" entre autres. La deuxieme ligne inclu le header du PIC, avec la déclaration de tous les defines nécéssaires pour nous simplifier la vie! Il est en effet beaucoup plus pratique d'apeller le pin 0 du port A : PORTAbits.RA0 que de devoir directement utiliser l'adresse physique du registre associé à ce pin.

void main (void)
{
	// on configure le pin 0 du port A en sortie
   TRISAbits.TRISA0 = 0;

Ici on déclare une fonction "main" sans paramètres et sans retour. Cette fonction est LA fonction d'un programme en C, c'est la fonction principale, et aussi la seule qui soit absolument nécéssaire. C'est la première fonction exécutée par le programme, et c'est donc celle qui contiendra notre code de clignotement de led. Le code TRISAbits.TRISA0 va configurer le pin 0 du port A (donc le pin 2 du PIC 18f252) en écriture. Si on avait mis TRISAbits.TRISA0 = 1, il aurait été configuré en lecture.

while(1)
{

Voilà ce qui va permettre de clignoter la led indéfiniment (tant que le PIC restera allimenté). Cette boucle while (1) est une boucle infinie. En effet, une boucle while va répeter le code de la boucle tant que la condition sera vraie : dans notre cas, la condition est "1"... hors si on connait un peu comment fonctionne le langage C, on sait que une condition vraie est une condition différente de 0. Dans notre cas, la condition est donc toujours vraie.

	// on allume la led en mettant le pin 0 à l'état haut
	PORTAbits.RA0 = 1;
	// on attends environ 0,25s à 40Mhz
	Delay10KTCYx(0);

On met le bit correspondant au pin 0 du port A à 1, ce qui aura pour effet de mettre une tension de +Vcc sur ce pin. On va donc allumer la led en lui fournissant une tension de 5V (réduite par la résistance de 470 Ohms pour ne pas la faire claquer). Reportez vous au schéma en fin de page si nécéssaire. La fonction Delay10KTCYx(0) va faire un délai de 10 000 * 256 cycles. Delay10KTCYx va induire un délai (temps pendant lequel le PIC est en attente) de 10 000 fois le chiffre passé en paramètre. Dans notre cas, le paramètre est 0, ce qui correspond à une valeur de 256 (se reporter au fichier pdf décrivant les librairies du compilateur C18).

Notre PIC ayant un quartz à 40Mhz, et le PIC exécutant un cycle tous les 4 tics d'horloge (fournie par le quartz justement), le PIC va faire 10 000 000 cycles par seconde, ce qui correspond à un cycle toutes les 0,1µs. 10 000 * 256 = 2 560 000 cycles d'attente, ce qui fait une attente de 25,6ms. Nous allumons donc la led pendant 0,256 seconde.

	// on éteint la led en mettant le pin 0 à l'état bas
	PORTAbits.RA0 = 0;
	// on attends environ 0,25s à 40Mhz
	Delay10KTCYx(0);
}
}

Il ne nous reste plus qu'à éteindre la led pendant encore 0,256 seconde. Si on résume, la led va s'allumer et s'éteindre deux fois par secondes, pendant une durée de 0,256 secondes à chaque fois.

Voilà voilà, mais alors qu'est-ce donc que tout ce truc entre #pragma? Nous en reparlerons plus tard, mais pour résumer c'est une méthode pour configurer le PIC : on va écrire directement des options de configuration dans la mémoire du PIC (d'où l'instruction "romdata"). Cette configuration est un peu fastidieuse à faire, mais il n'est en général nécéssaire de la faire qu'une seule fois pour un modèle de PIC donné. Cela concerne les options de protection d'écriture, la fréquence d'oscillation du quartz et ce genre de joyeusetés ;)

Vous trouverez ici le fichier contenant le code source, et là le fichier .hex du programme compilé (à ouvrir dans ICPROG pour programmer le PIC). Pour télécharger ces fichiers, cliquer avec le bouton droit de la souris sur le lien, puis sélectionner "enregistrer la cible sous", et mettre le bon nom de fichier (leds.c ou leds.hex). Le plus important est l'extension du fichier: il faut absolument sélectionner "Tous les fichiers" à la place de "fichier texte" si vous ne voulez pas avoir à renommer votre fichier à la main une fois enregistré sur votre ordinateur.

Dans le cours suivant nous allons nous mettre aux interruptions !

Pour le schéma de montage avec la LED, on repart du schéma de montage "nu", et on rajoute une résistance de 470 Ohms (pour ne pas faire claquer la LED : il ne lui faut moins de 2V, et en sortie du PIC on a 5V), et bien sur, la LED. Voilà le schéma eagle.