Essai de la carte PIC


Pour les essais utilisation de la carte pic.

Nous allons pas faire beaucoup d'essai avec cette carte étant donné qu'il s'agit de la carte principal qui nous servira pour toutes les autres cartes.
Nous testerons donc cette carte avec toutes les autres.

1 - Premiers Essai

Notre premier essai consiste a allumer une led sur le bit 0 du PORTC(utilisé led + résistance)

Voici la connectique de cette essai :

- Code C 

#include<pic1687x.h>

main()			// boucle principale et impérative
{
TRISC=0b00000000;	// configuration du portC en sortie
RC0=1;			// mise a 1 (5v) de la sortie RC0 du port C 
while(1);		// le programme se bloque ici
}
Télécharger le code C

Il suffit ensuite de modifier le programme pour changer de bit ou de PORT et ainsi de tester tous les ports utilisable en sortie

Essai de la carte moteurs


Pour les essais utilisation de la carte pic et de la carte moteurs.

Les moteurs utilisés sont des moteurs pas à pas bipolaires 200 pas / tour soit 1,8 deg / pas (4 phases)
En général les moteurs pas à pas peuvent être utilisés de trois façons

Variante 1 : commande par pas entiers, une seule phase alimentée à la fois, sens anti - horaire.

Position T1 T2 T3 T4
1 1 0 0 0
2 0 0 1 0
3 0 1 0 0
4 0 0 0 1

Variante 2 : commande par pas entiers, deux phases alimentées en même temps (augmentation du couple moteur), sens anti - horaire.

Position T1 T2 T3 T4
1 1 0 1 0
2 0 1 1 0
3 0 1 0 1
4 1 0 0 1

Variante 3 : commande par demi - pas (double le nombre de pas par tour), sens anti-horaire.

Position T1 T2 T3 T4
1 1 0 0 0
2 1 0 1 0
3 0 0 1 0
4 0 1 1 0
5 0 1 0 0
6 0 1 0 1
7 0 0 0 1
8 1 0 0 1

Afin de simplifié la programmation nous allons dans un premier temps faire nos essais avec la première variante.

Nous utiliserons le PORTC du PIC pour commander nos moteurs, les bits 0 à 3 commanderont le moteur de gauche et les bits 4 à 7 celui de droite

1 – Premier essai.

Notre premier essai consiste à commander notre moteur de gauche en marche avant
Nous utiliserons la variante 1
Nous utiliserons une temporisation entre chaque phase de 10 ms

Voici la connectique de cette essai :

- Code C 

// on fait tourner le moteur de gauche en mode simple 10 ms entre deux phase


#include<pic1687x.h>
#include<delay.h>

main()			// boucle principale et impérative
{
int j;
TRISD=0b00000000;	// configuration du portd en sortie
	do 		
	{
	// phase1a PD0
	// phase2a PD1
	// phase1b PD2
	// phase2b PD3

	PORTD = 0x00;
		for(j = 1;j <= 50;j++) // 1 pas pour moteur 200 pas tour 4*50 = 200
		{
		// phase 1
		RD3 = 0;
		RD0 = 1;
		DelayMs(10);

		// phase 2
		RD0 = 0;
		RD2 = 1;
		DelayMs(10);

		// phase 3
		RD2 = 0;
		RD1 = 1;
		DelayMs(10);
 
		// phase 4
		RD1 = 0;
		RD3 = 1;
		DelayMs(10);
		}
	}while(1);   	
} 

void
DelayMs(unsigned char cnt)
{
#if	XTAL_FREQ <= 2MHZ
	do {
		DelayUs(996);
	} while(--cnt);
#endif

#if    XTAL_FREQ > 2MHZ	
	unsigned char	i;
	do {
		i = 4;
		do {
			DelayUs(250);
		} while(--i);
	} while(--cnt);
#endif
}

Télécharger le code C

Voici le résultat :


Maintenant que nous avons réussi à commander le moteur de gauche.
Il suffit tous simplement de remplacer les bits 0 à 3 par les bits 4 à 7 pour commander le moteur de droite.

2 – Deuxième essai

Notre deuxième essai à commander notre moteur de gauche de façon à effectuer un tour en marche avant et un tour en marche arrière.
Nous utiliserons la variante 1.

Nous avons commandé simplement notre moteur gauche en marche avant lors de notre premier essai.
Pour effectuer un tour en marche arrière il nous suffit d’inverser la commande des phases du moteur.

La connectique est la même que pour le premier essai.

- Code C 

#include<pic1687x.h>
#include<delay.h>

main()			// boucle principale et impérative
{
int j;
TRISD=0b00000000;	// configuration du portd en sortie
	do 		
	{
	// phase1a PD0
	// phase2a PD1
	// phase1b PD2
	// phase2b PD3

	// un tour en marche avant

	PORTD = 0x00;
		for(j = 1;j <= 50;j++) // 1 pas pour moteur 200 pas tour 4*50 = 200
		{
		// phase 1
		RD3 = 0;
		RD0 = 1;
		DelayMs(10);

		// phase 2
		RD0 = 0;
		RD2 = 1;
		DelayMs(10);

		// phase 3
		RD2 = 0;
		RD1 = 1;
		DelayMs(10);
 
		// phase 4
		RD1 = 0;
		RD3 = 1;
		DelayMs(10);
		}

		// un tour en marche arriere

		PORTD = 0x00;
		for(j = 1;j <= 50;j++) // 1 pas pour moteur 200 pas tour 4*50 = 200
		{
		// phase 1	
		RD0 = 0;
		RD3 = 1;
		DelayMs(10);

		// phase 2
		RD3 = 0;
		RD1 = 1;
		DelayMs(10);

		// phase 3
		RD1 = 0;
		RD2 = 1;
		DelayMs(10);
 
		// phase 4
		RD2 = 0;
		RD0 = 1;
		DelayMs(10);
		}
	}while(1);   	
} 

void
DelayMs(unsigned char cnt)
{
#if	XTAL_FREQ <= 2MHZ
	do {
		DelayUs(996);
	} while(--cnt);
#endif

#if    XTAL_FREQ > 2MHZ	
	unsigned char	i;
	do {
		i = 4;
		do {
			DelayUs(250);
		} while(--i);
	} while(--cnt);
#endif
}

Télécharger le code C

Voici le résultat :



3 – Troisième essai

Nous allons effectuer le même test que le deuxième essai.
Nous allons uitilisé la variante 2 ce qui nous permettra d’améliorer le couple du moteur.
Nous comanderons le moteur de gauche et le moteur de droite.

Voici la connectique de cette essai :

- Code C 

#include<pic1687x.h>
#include<delay.h>

main()				// boucle principale et impérative
{
int j;
TRISD=0b00000000;	// configuration du portd en sortie
	do 		
	{

	// Moteur Gauche
	// phase1a PD0
	// phase2a PD1
	// phase1b PD2
	// phase2b PD3

	// Moteur Droit
	// phase1a PD4
	// phase2a PD5
	// phase1b PD6
	// phase2b PD7


	// un tour en marche avant
		for(j = 1;j <= 50;j++) // 1 pas pour moteur 200 pas tour 4*50 = 200
		{
		// phase 1
		RD0 = 1;	
		RD1 = 0;
		RD2 = 1; 
		RD3 = 0;

		RD4 = 1;
		RD5 = 0;
		RD6 = 1;
		RD7 = 0;
		
		DelayMs(10);

		// phase 2
		RD0 = 0;	
		RD1 = 1;
		RD2 = 1; 
		RD3 = 0;

		RD4 = 0;
		RD5 = 1;
		RD6 = 1;
		RD7 = 0;

		DelayMs(10);

		// phase 3
		RD0 = 0;	
		RD1 = 1;
		RD2 = 0; 
		RD3 = 1;

		RD4 = 0;
		RD5 = 1;
		RD6 = 0;
		RD7 = 1;

		DelayMs(10);
 
		// phase 4
		RD0 = 1;	
		RD1 = 0;
		RD2 = 0; 
		RD3 = 1;

		RD4 = 1;
		RD5 = 0;
		RD6 = 0;
		RD7 = 1;

		DelayMs(10);
		}
	
	// un tour en marche arriere
		for(j = 1;j <= 50;j++) // 1 pas pour moteur 200 pas tour 4*50 = 200
		{
		// phase 1
		RD0 = 1;	
		RD1 = 0;
		RD2 = 0; 
		RD3 = 1;

		RD4 = 1;
		RD5 = 0;
		RD6 = 0;
		RD7 = 1;

		DelayMs(10);

		// phase 2
		RD0 = 0;	
		RD1 = 1;
		RD2 = 0; 
		RD3 = 1;

		RD4 = 0;
		RD5 = 1;
		RD6 = 0;
		RD7 = 1;

		DelayMs(10);

		// phase 3
		RD0 = 0;	
		RD1 = 1;
		RD2 = 1; 
		RD3 = 0;

		RD4 = 0;
		RD5 = 1;
		RD6 = 1;
		RD7 = 0;

		DelayMs(10);
 
		// phase 4
		RD0 = 1;	
		RD1 = 0;
		RD2 = 1; 
		RD3 = 0;

		RD4 = 1;
		RD5 = 0;
		RD6 = 1;
		RD7 = 0;

		DelayMs(10);
		}
	}while(1);   	
} 

void
DelayMs(unsigned char cnt)
{
#if	XTAL_FREQ <= 2MHZ
	do 
	{
		DelayUs(996);
	} while(--cnt);
#endif

#if    XTAL_FREQ > 2MHZ	
unsigned char	i;
	do
 	{
		i = 4;
		do 
		{
			DelayUs(250);
		} while(--i);
	} while(--cnt);
#endif
}

Télécharger le code C

Le robot qui ne passait même pas les petite montée les passe maintenant avec succés grâce a l'amélioration du couple
Nous pourrions encore faire un test avec la variante 3.
Cette dernière permettant d’améliorer la précision mais ce test ne sera pas effectuer car la précision n'est pas notre but premier.

Nous avons tous de même encore un problème important car il faut aider les moteurs au démarrage
Pour régler ce problème nous allons gérer un table d'accélération se qui lui permettra un démarrage en douceur

4 – Quatrième essai.

Nous allons effectuer le même test que le troisième essai en ajoutant une table d'accélération.
Nous utiliserons une table dont l'allure théorique doit être la suivante :

Sachant que chaque moteur a une vitesse maxi nous serons forcement saturer a un moment.

Pour pouvoir vérifier le test nous ferons 20 tours en marche avant et 20 tours en marche arrière.

La connectique est la même que celle de l'essai trois.

- Code C

Tous ces essais nous laisse penser qu’il sera maintenant facile de piloter un robot. Or un robot n’est pas équipé que de moteurs. Nous voyons vite l’inconvénient de nos programmes ci-dessus, qui gère la commande des moteurs dans la boucle principal du robot il est donc difficile d’effectuer d’autres contrôle dans la même boucle sans perturber la commande de nos moteurs.

La solution est l’utilisation des timer du PIC (dans notre cas utilisation du timer1) qui nous permettra de gérer des impulsions tous les 10 ms sous forme d’interruption

5 – Cinquième essai.

Nous allons effectuer le même test que le quatrième essai mais en utilisant le TIMER1 du PIC. Pour libérer la boucle principale du programme qui nous servira ultérieurement.

Le résultat est bien entendu le même que le quatrième mais notre boucle principal est libérée.

Accueil | La carte PIC | La carte Moteur | Les essais | Le forum |