je bute sur le choix d'un moteur

[invitee0b658bd]

bonsoir,
le plus simple est bien sur d'utiliser une sortie pwm. le materiel s'occupe de tout. aprés cela depend de la resolution que tu desires.
fred
-----

[ABN84]

bonsoir,
l'avant projet va bientot finir. ce qui m'ammene à la question suivante:
pour apprendre les Pics, il faur un programmeur et une platine de developpement pour Pic. le probleme reside dans le nbr de personnes travaillant dessus, et du nbr des platines dispo, de plus pour avoir acces aux platines (dans un soucis d'organisation et de maintenance) il faut passer par plusieurs personnes pas tjrs disponibles. dans cette perspective je voulais savoir s'il etais possible de realiser cette platine soit meme, pas besoin qu'elle soit tres sofistiqué l'essenciel, c'est qu'elle me permette de tester mes programmes en toute quietude. connaitriez vous un schema elctrique, composants, etc?
merci

EDIT: dans l'ordre je vais utiliser un pic 16, un pic 18, et enfin un sdPic

[ABN84]

EDIT: travaillant sur un portable, j'ai pas de port serie, le seul port que je peux utiliser est l'USB

[ABN84]

bonsoir,
j'aimerais comprendre les servo du modelismes se nomment normalement servomoteur à retro controle. mais il n'y a que 3 fils deux pour l'alim et 1 pour la commande, il n'y a donc pas de feed back. c'est donc par abus de language qu'on appelle ca des servomoteurs? car pour asservir il faut, à ma connaissance, obligatoirement un retour de l'information,non?
merci

[invitee0b658bd]

bonjour,
pour les servo tu peux aller voir la
http://home.nordnet.fr/~fthobois/MRA-2.htm
http://www.teaser.fr/~osegouin/aeromode/servos.phtml
une petite recherche sur le net te l'aurait donné rapidement, je pensais que tu bossais le sujet depuis quelques semaines

pour la programmation des pics
1) aller sur le site microchip (ils vendent aussi des programmateurs)
2) taper programmateur pic dans un moteur de recherche
3) faire un montage usb pour debuter est peut etre un peu ambitieux
4) mplab dispose d'un bon simulateur (mpsim)

fred

[ABN84]

bonsoir,
merci fred.
je suis en train d'essayer de ce montage: http://fribotte.free.fr/bdtech/8serv...vomoteurs.html sur proteus/ISIS, le probleme est que je n'arrive pas à comprendre quel type de signal mettre sur la patte 18. il parle de valeurs allant de 4 à 255, mais c'est quoi comme signal (MLI, le code binaire d'une valeur 4/255...)?
merci

[ABN84]

il y a encore une autre chose. quand j'essaie de commander le servo directement par un signal MLI, il tourne de 90° qqsoit la trame que je mets. merci

[ABN84]

Rebonsoir,
pour la deuxieme question, c'est bon j'ai juste fais erreur sur la frequence

[invite03481543]

Salut,
un servo moteur se commande par des impulsions calibrées et envoyées à une électronique (dans le corps du moteur) qui convertit ces "timings" en position d'axe.
C'est pour cela que l'on appelle ce type de commande CMS (Code Modulated Signal) mieux adapté que PWM (Pulse Width) Modulation).
Le retour d'information position est donc inutile puisque la commande ordonne justement la position.
Car il s'agit bien d'un codage de position que sait interpréter l'électronique du moteur.
Ce codage consiste à traduire les 180° de rotation (selon les modèles on peut avoir plus) dans un temps allant de 1ms à 2ms, 1,5ms étant la position neutre.
Ces moteurs nécessitent une commande type TTL ou Cmos à 5V, avec un courant de l'ordre de 50µA.

Pour la résolution, 1 degré d'angle correspond à 1ms/180 soit 1ms+(5,5µs par degré d'angle) pour le timing à appliquer.
Comme le disais Verdifre, l'impulsion de commande doit être raffraichie toute les 20ms max, sous peine de perte de la position.
En travaillant avec un PIC à 4MHz (donc 1µs d'horloge), on peut sans soucis gérer ce type de résolution.
Il faut un pic possédant un timer 8 bits (255) ou 16 bits (65535) et utiliser le mode compare (CCPx) par exemple pour "caler" les temps précisemment.

Il existe des servos relativement puissants, j'en utilise un qui consomme 2A max sous 6V pour exercer une force de 12Kg sur des filins d'acier.
Selon l'application, il faudra choisir le modèle (taille, force, etc), la commande étant la même que décrite précedemment.

Pour la question des PIC, tu peux choisir ICD2 qui se connecte au PC via l'USB ou RS232, et te permet de programmer ta cible (le PIC) par un connecteur RJ45 à prévoir sur ta carte de développement.
Il te permet aussi de faire du débogage en temps réel par l'intermédiaire de MPLAB l'environnement gratuit de Microchip.
Le mieux c'est de te faire une carte judicieusement pensée que tu peux aussi acheter toute faite, et qui te permettra de faire joujoux avec tes PIC.
Il existe aussi le programmateur PicStart Plus qui permet juste de programmer les PIC, moins cher que ICD2 mais aussi moins pratique si tu décides d'opter pour des µC CMS par exemple.
Depuis que j'ai l'ICD2 je n'utilise plus le PicStart Plus.
Il faut penser aussi au langage de programmation que tu choisiras pour travailler.
L'assembleur nécessite plus de rigueur qu'un langage évolué car tu travailleras sur la couche intime du processeur donc cela nécessite de bien connaitre le fonctionnement de la bête.
Le langage évolué est plus souple et plus convivial surtout pour les modifs éventuelles.
Hésite pas à demander si tu as d'autres questions.

Voili, voilou.

[ABN84]

bonsoir,

Salut,
un servo moteur se commande par des impulsions calibrées et envoyées à une électronique (dans le corps du moteur) qui convertit ces "timings" en position d'axe.
C'est pour cela que l'on appelle ce type de commande CMS (Code Modulated Signal) mieux adapté que PWM (Pulse Width) Modulation).
Le retour d'information position est donc inutile puisque la commande ordonne justement la position.
Car il s'agit bien d'un codage de position que sait interpréter l'électronique du moteur.
Ce codage consiste à traduire les 180° de rotation (selon les modèles on peut avoir plus) dans un temps allant de 1ms à 2ms, 1,5ms étant la position neutre.
Ces moteurs nécessitent une commande type TTL ou Cmos à 5V, avec un courant de l'ordre de 50µA.

Pour la résolution, 1 degré d'angle correspond à 1ms/180 soit 1ms+(5,5µs par degré d'angle) pour le timing à appliquer.
Comme le disais Verdifre, l'impulsion de commande doit être raffraichie toute les 20ms max, sous peine de perte de la position.

jusque là, pas de probleme.

Pour la question des PIC, tu peux choisir ICD2 qui se connecte au PC via l'USB ou RS232, et te permet de programmer ta cible (le PIC) par un connecteur RJ45 à prévoir sur ta carte de développement.
Il te permet aussi de faire du débogage en temps réel par l'intermédiaire de MPLAB l'environnement gratuit de Microchip.

pas de probleme de ce coté, non plus

Le mieux c'est de te faire une carte judicieusement pensée que tu peux aussi acheter toute faite, et qui te permettra de faire joujoux avec tes PIC.

c'est là que ça se gate.
j'explique, la finalité de ce travail est d'asservir les servos en position selon des consignes fournies par des capteurs. le uC sera (à la fin) un dsPic33, mais vu que je n'ai jammais touché aux uC, il faut bien commencer par les bases.
sur ISIS, j'ai alimenté le servo et imposé un signal à la main, ça a bien fonctionné (selon la largeur d'impulsions j'ai eu differents angles):



logiquement l'etape suivant est de s'attaquer à la commande par pic. sur la toile, j'ai trouvé ce schema:



associé à ce code:

:02000000632873
:080008008C0003088D000B11B0
:100010000E193B288E183128CE30810002308E0018
:1000200013300F07840000089200031930280F08CE
:100030009000031906149003031986149003031902
:1000400006159003031986159003031906169003ED
:1000500003198616900303190617900303198617D0
:100060005E280000000000001208031980308100A3
:1000700004308E005E28120803198030FF3C810096
:1000800001308E000F089000031906109003031929
:10009000861090030319061190030319861190032B
:1000A000031906129003031986129003031906130D
:1000B0009003031986138F0A8F198F010D0883008F
:1000C0008C0E0C0E09000C3084008001840A503024
:1000D0000402031C652801308E006400860185013E
:1000E0008316003086001F30850082308100831225
:1000F0008101A0308B00A320FF302002031D7B284C
:10010000A32005081C39A3000310A30CA30C23088B
:100110002002031D7C28A3200830200203187C281D
:100120002008A400A3202008A50003199D2804305E
:10013000200203189D280430A500133024078400F2
:10014000250880007B280830A100851CA52885187B
:10015000A728B320B320B320031085180314A00CE4
:10016000A10BAA2808004030A200A20BB528080065
:02400E00F13F80
:00000001FF

j'ai inséré le code dans le pic, nada.
j'ai essayé ceci:

:020000002E28A8
:080008008C0003088D00940A2E
:10001000141B0B280E28900A0030940000001318BF
:1000200012281D2800308600831686308100831236
:100030008C308100003093002828FF308600831622
:100040008230810083121008FF3C81000130930050
:100050000B110D0883008C0E0C0E090033203E207E
:1000600064309000322886018316003086008312A7
:10007000850183161F3085008312080064008316F3
:10008000823081008312FA308100A0308B0008009A
:02400E00F13F80
:00000001FF

et là, ca a tourné de 90°. sans pour autant que je comprenne le pourquoi du comment.

helas, je n'arrive pas à changer ça en C (ça ne se fait peut etre pas) pour voir de quoi il en tourne, comment est generé le PWM.

le plus important je crois c'est ça:

Le mieux c'est de te faire une carte judicieusement pensée

mais là, je sèche.
merci

[ABN84]

bonsoir,
un petit up.

[ABN84]

bonsoir,
etant donné que PWM est un abus de language, un tel programme, qui genere des pwm, convient-il à la commande des servomoteurs (en mettant biensur les frequences adequate):

// programme de test de la sortie PWM d'un 16F877
// Jean-Pierre MANDON 2003


#pragma chip PIC16F877
#pragma config WDTE=off, FOSC=HS


#pragma bit sortie @ PORTC.2



void main(void)
{
 TRISC=0x80;       // Port C en sortie sauf C7 ( RX de l'UART )
 PR2=77;           // définit la période du signal PWM ( 25µS à 12 Mhz )
 CCP1CON=0x0C;     // CCP1CON.5:4 = bits de poids fort du cycle = 0 , mode PWM
 CCPR1L=38;        // au départ la valeur du signal à 1 dans le cycle est égale à 38 ( 50% )
                   // modifiez cette valeur pour modifier le rapport cyclique
 T2CON=0x04;       // prescaler et postscaler =1 , timer 2 on

 while(1)
 {
 // Ce programme ne fait rien
 }
}

[invite03481543]

Ca reste du PWM sur le plan du signal variable généré mais les créneaux de temps sont en réalité un code ensuite convertit en positions par l'électronique du servo moteur.
Le code que tu montres est très incomplet.
Il manque toute la gestion du calcul des temps variables par incrémentation ou décrémentation par 2 B.P par exemple.

// Commande d'un servo par 2 BP
// By Hulk


#include	<pic.h>
#include 	"servo.h"
#include	"ad16f87x.h"

__CONFIG(XT & WDTEN & BORDIS & LVPDIS & UNPROTECT);

unsigned int val ;
unsigned char pos ;

# define  Time  20

void init_pic (void);
void Delais_Milli (int val) ;
void Reset (void) ;
static void interrupt inter(void) ;
void Init_compare(void) ;
void Config_rapport_cyclique(unsigned char) ;



void init_pic (void)
{

	RBPU = 1; 		// Pull up désactivés   

// Timer 0 est utilisé pour le wachtdog à 2,3 s.

	Timer0ClockSource = 0;			// Clock interne
	PrescalerAssignement = 1;		// timer0 = Wachtdog
	Timer0PrescalerRate2 = 1;		// \
	Timer0PrescalerRate1 = 1;		//  => 111 + WDT => 18 ms x 128 = 2,304 s 
	Timer0PrescalerRate0 = 1;		// /

	ADCON1= 6 ;				// Passe le port A en mode digital
        TRISA = ConfigIOPortA ;	 	// Configuration du port A
        TRISB = ConfigIOPortB ;		// Configuration du port B 
	TRISC = 0 ;					// Configuration du port C 
   
        PORTA = 0x3F ;		// Toutes les sorties à 5V
        PORTB = 0xFF ;		// Toutes les entrées à 5V
	PORTC = 0 ;				// Toutes les sorties à 0V
	GIE = 1;				// Valide toutes les interruptions
	PEIE = 1 ;   

	CCP1IE = 1 ;				// Interruption en mode comparaison autorisée
	
	TMR1IE = 1 ;				// Interruption du Timer1 autorisée 

}


main()
    {
	CLRWDT() ;
   	init_pic() ;
	CLRWDT() ;
   	Init_compare() ;
	
	pos = 90 ;	// position centrale servo 	Config_rapport_cyclique (pos) ;
	
	
   	
    while(1) 					// Le programme tourne dans cette boucle principale 
              {
		
		CLRWDT() ;
				
			while (BP1 == 0)    // On incrémente				{
					Delais_Milli(40) ;					
					pos = pos++ ;
					Config_rapport_cyclique(pos) ;
					Delais_Milli(Time) ;
				}
                                      while (BP2 == 0)    // On décrémente				{
					Delais_Milli(40) ;					
					pos = pos-- ;
					Config_rapport_cyclique(pos) ;
					Delais_Milli(Time) ;
				}

             }

}	
static void interrupt inter(void)		// Gestion du timer1 en mode compare

{


	if (TMR1IF)
		{
		RC6 = 1 ;
		RC7 = 1 ;
		TMR1H = 0xEC ;
		TMR1L = 0x77 ;
		TMR1IF = 0 ;
		}

	if (CCP1IF)
		{
			if ((pos > 0) && (pos < 180)) 
				{
				CCP1IF = 0 ;
				RC6 = 0 ;
				}
			else
				{
				CCP1IF = 0 ;
				RC6 = 1 ;
				}
		}

}


//***********************************************************//
//Val_tmp = 60285+((139/100)*pos) ;

// min (1ms)= 65535 - ((20000µs/4µs) + (1000µs/4µs))=60785
// moyen (1,5ms)=65535 - ((20000µs/4µs) + (1500µs/4µs))=60909
// define max (2ms)=65535 - ((20000µs/4µs) + (2000µs/4µs))=61035

void Config_rapport_cyclique(unsigned char)
{
	
		unsigned int Val_tmp ;
		Val_tmp = (139*pos)/100 ;
		Val_tmp += 60785 ;	
			
		CCPR1L = Val_tmp ;
		CCPR1H = Val_tmp >> 8 ;		
	
}

void Init_compare (void)
{
	
	{
	TMR1H = 0xEC ; //on fixe la fréquence 65535-20000µs/4µs = 0xEC77
	TMR1L = 0x77 ;
	CCP1CON = 0b00001010 ;
	CCP2CON = 0b00001010 ;
	T1CON = 0b00100001 ; //Prescaler=1:4 Timer1=on
	}
}

Voilà pour te faire une idée plus précise ici avec une utilisation du timer1 (16 bits).

[ABN84]

merci HULK, je regarde ça de suite.

[ABN84]

bonsoir HULK,
je viens d'introduit ce bout de code dans mikroC et lors de la compilation il m'indique que pic.h, servo.h et ad16f87x.h sont introuvables. je suppose que ce sont des biblio.
est ce que tu les as tiré d'ilternet ou ecrit toi meme?
merci

[ABN84]

bonsoir HULK,
dans ton programme tu incremente le servo par "pos", mais je ne vois nullepart ou est definit pos. dans servo.h ?
merci