Le code de test

Pour découvrir les fonctions de base de MPLAB SIM nous allons partir d’un petit code d’exemple assez simple à comprendre.
Le programme ci-dessous réalise la fonction suivante :

• Quand il reçoit le caractère « a » par le périphérique UART, il fait passer l’état de la broche « RC1 » à « 1 », s’il reçoit un autre message, « RC1 » passe à « 0 »
• Quand la broche « RC0 » passe à l’état « 1 », il envoie le message « Hello » par UART.

Pour utiliser le code, créer un nouveau projet pour le PIC18F4620 et indiquez que vous utilisez le compilateur C18 de Microchip (gratuit). Ajouter ensuite dans un fichier source le code suivant :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

/* Demo Debug */

#include <p18f4620.h> 
#include <usart.h> 

void interrupt MyInterruptRoutine(void)
{
	int c;	
	/* la source d'interruption vient de la reception de l'usart */
	if (PIR1bits.RCIF == 1)
	{
		/* lit le caractère reçu */
		c = ReadUSART();
		/* si il est égale à 1 alors RC1 = 1 */
		if (c =='a')
			PORTCbits.RC1 = 1;
		/* sinon RC1 = 0 */
		else PORTCbits.RC1 = 0; 
	}
}

//void getsUSART ( char * gps , unsigned char 80 ); 
void main(void) 
{ 
	int rc0_last_state = 0;
	char str[5]={'H','e','l','l','o'};

	/* configuration du port C */
	TRISCbits.TRISC0 = 1 ; // RC0 en Input
	TRISCbits.TRISC1 = 0 ; // RC1 en Output
	TRISCbits.TRISC6 = 0 ; // UART TX
	TRISCbits.TRISC7 = 1 ; // UART RX

	/* Ouverture de l'USART avec interruption active sur la réception */
	OpenUSART (USART_TX_INT_OFF & USART_RX_INT_ON & USART_ASYNCH_MODE & USART_EIGHT_BIT & USART_CONT_RX & USART_BRGH_HIGH, 64);

	/* Activation des sources d'interruption global et périphérique */
	INTCONbits.GIEH = 1; //enable all global interrupts 
        INTCONbits.GIEL = 1; //enable all global interrupts 
        INTCONbits.PEIE = 1; //enable peripheral 

	/* boucle principale */
	while(1){ 
			/* l'état de RC0 a-t-il changé? (pas de prise en compte de l'anti rebond dans cet exemple) */
			if (PORTCbits.RC0 != rc0_last_state)
			{	
				/* l'état est passé à 1 */
				if (PORTCbits.RC0 == 1)
				{	
					putsUSART(str); // envoie de "Hello"
				}
				rc0_last_state = PORTCbits.RC0; // enregistre l'état actuel
			}	
		} 
} 

Debugger

Le projet ne devrait pas poser de problème pour être compilé.

Allez dans « Debugger » -> « Select Tool » -> « MPLAB SIM »

Une nouvelle barre apparait dans les outils permettant l’exécution du code. Si vous cliquez sur « play » le code va s’exécuter à partir de la méthode main (comme il s’exécuterait sur votre microcontrôleur). Dès à présent l’intérêt est de pouvoir arrêter le code pour vérifier s’il s’exécute correctement.

Le breakpoint

Le breakpoint est un moyen d’arrêter le code lorsque celui-ci s’apprête à être exécuté. Pour placer un breakpoint, double cliquez sur la ligne où vous souhaitez placer le stop. Lorsque l’exécution du code arrivera à la ligne choisie, le déroulement du programme se mettra en pause et vous permettra d’analyser l’état des registres et des variables.

Le watch

Le watch est un outil qui permet d’espionner les variables et les registres du microcontrôleur. Pour ouvrir la fenêtre : menu « View » -> « Watch »

Vous retrouverez directement les registres du microcontrôleur ainsi que les variables déclarée dans votre programme. Il vous suffit de les ajouter aux variables espionnées.

Si une variable est notée « Out of scope » celà signifie qu’elle est locale à une fonction qui n’est pas parcourue pour le moment.

Vous avez également la possibilité de changer la valeur d’une variable depuis cet écran.

Le stimulus

Cette partie est particulièrement intéressante, elle permet de générer des évènements penant la simulation comme la fin d'une conversion analogique, la réception d’un message UART, le changement d’état d’une broche, générer des signaux spécifiques sur une entrée.

Dans l’exemple que nous suivons, nous allons injecter la réception d’un message sur le périphérique UART ainsi que le changement d’état de la broche « RC0 ».

Créez un nouveau « Workbook », pour cela allez depuis le menu « Debugger » -> « Stimulus » -> « New WorkBook »

• Encodez les 3 lignes données sur l’illustration ci-dessous :

Placez un breakpoint sur la ligne « if (PIR1bits.RCIF == 1) » et sur la ligne « if (PORTCbits.RC0 == 1) ».

• Lancez la simulation.
• Dans le workbook, pour la ligne envoie « a » sur « RCREG » (registre de réception de l’uart), cliquez sur « Fire ».

Le programme va directement entrer dans la routine d’interruption et s’arrêter sur le breakpoint. En avançant au pas à pas vous constaterez que le caractère reçu est bien « a » et qu’il va passer l’état de la broche « RC1 » à « 1 ». Si vous envoyez l’autre ligne vous constaterez que « RC1 » repassera à « 0 ».

Pour le constater, je vous invite à insérer dans la fenêtre « Watch » le port « PORTC ». Pour plus de lisibilité, changez la propriété de l’affichage (clic droit sur la ligne -> « properties ») et demandez l’affichage en « binaire ».

Pour visualiser l’envoie d’un message depuis le pic (la partie du code qui envoie « Hello » lorsque « RC0 » passe à « 1 »), il faut dire à MPLAB d’afficher les messages échangé depuis l’UART.

Pour cela, allez dans « Debugger » -> « Settings » et configurez comme suit :

Dès à présent, lorsque « RC0 » passera à « 1 », via le toggle intégré dans le « workbook », le message « Hello » apparaitra sur la fenêtre de sortie.

Conclusion

Nous venons d’avoir un petit aperçu des fonctionnalités de debugging présente dans MPLAB et nous ne pouvons que constater qu’il est déjà possible d’analyser profondément les éventuels problèmes du code. En cherchant un petit peu dans les autres options des fenêtres présentées, vous ne manquerez pas de devenir un expert du debug des pics !