Problème servo avec Timer 0 sur PIC

[invite7a536414]

Bonjour à tous,
Je suis sur un PIC 18F et je rencontre un problème avec l'utilisation d'un servo moteur....

Quartz = 4MHz

J'utilise le Timer 0 et cherche donc à générer des impulsions de 1 à 2ms avec une période de 20ms.

Je l'ai configuré comme suis :

****//TIMER*0
T0CON1bits.T0CS*=*0b010;*******//FOSC/4
T0CON1bits.T0ASYNC*=*0;*********//The*input*to*the*TMR0*counter*is*synchronized*to*FOSC/4
T0CON1bits.T0CKPS*=*0b0000;****//Préscaler*1:1
TMR0H*=*200*;*******************//TIMER0*COUNT*REGISTER

T0CON0bits.T0EN*=*1;***********//*The*module*is*enabled*and*operating
T0CON0bits.T016BIT*=*0;*********//TMR0*is*an*8-bit*timer
T0CON0bits.T0OUTPS*=*0b0000;****//1:1*Postscaler
PIE0bits.TMR0IE=1;***************//Timer*0*interrupt*enable


/*INTERRUPTIONS*/
INTCONbits.GIEH=1;*****//Global*Interrupt*Enable*bit
INTCONbits.PEIE=1;*****//Peripheral*Interrupt*Enable*bit
INTCONbits.IPEN=0;*****//Interrupt*Priority*Enable*bit



counterB*=*10;*//*2ms   counterB=5 pour du 1ms
*

Dans l'interruption :

 if(PIR0bits.TMR0IF == 1)                // Timer 0
    {
        counter = counter + 1;
        
        if (counter == counterB)
        {
            TEST = 0;               // Sortie PWM
        }
        
        if (counter == 100)
        {
            counter = 0;
            TEST = 1;                 // Sortie PWM
        }
        PIR0bits.TMR0IF = 0;
    }

4MHZ / 4 ==> 1µs
Pas de préscaler/post scaler
J'attends 200 cycles => 200µs puis encore 100 cycles ==> 20ms.
En cours de route, counterB permet de monter ou baisser la pwm.

PS : si en parallèle je fais un bête DELAY de 2 secondes... mon délais réel fait presque 4 secondes... et cela m'étonne d'une si grande différence...

Résultat :
A l'oscilloscope, j'obtiens exactement ce que je souhaite en terme de forme de courbe.
Le servo se rends bien à la bonne position, MAIS il a ensuite la tremblote.
(dur a expliquer)
Une fois a la bonne position, le servo va faire trois petites secousses, une pause, puis recommencer. C'est quelque chose de très périodique.

Cela fait la même chose sur n'importe quel servo.

Auriez vous des conseils ?

Merci par avance !!

Hoffmann
-----

[invitef86a6203]

Le TMR0 consomme beaucoup de ressource, donc d'après ce que tu dis 50% du temps de traitement est consommer par le TMR0.
Le delay (dans le prog principal, jamais dans l'int) est juste une boucle , il compte e si on fait des int le temps varie.

Il faut voir si le signal est stable au scope;
S'il est stable , le servo a un problème.
S'il bouge, d'autres interruptions peuvent perturber en consommant du temps lorsque normalement il devrait être dans TMR0.
Si on utilise le CLI dans le prog principal et que malheureusement ça arrive au moment de l'int TMR0, là aussi variation du temps TMR0.

Vérifier si l'horloge est stable , parfois les condos du quartz sont défectueux.

[RISC]

Salut,
Quel PIC18F ?
a+

[invite7a536414]

C'est un PIC 18F47K40.

J'ai désactivé les autres interruptions.


Oui apparemment le TMR0 consomme beaucoup de ressource (et ça m'étonne).

Entre un delay normal et un delay (avec TMR0 activé) j'ai le double. (vérifier a 1s et a 10s).
(oui je n'utilise le delay que dans le programme principal et jamais dans les interruptions)

Je n'arrive pas a comprendre qu'est ce qui fait bagoter mon servo toutes les x secondes (c'est très répétable, parfois 6 secondes d'ordre de grandeur)...

Merci pour votre aide en tout cas !

[A voir en vidéo sur Futura]

[invite5a48ffd1]

Bonjour hoffmann,

on ne procède pas ainsi pour faire les choses correctement.
Votre timer doit être configuré de manière à ce que votre comptage déclenche une interruption correspondant au timing désiré (2ms, 3ms,...10ms, 20ms), en général on utilise le mode "compare".
Pour cela vous devez calculer l'offset nécessaire (si besoin), le charger dans le timer puis lancer le timer, à l'issu l'interruption sera déclenchée et traitée.
Puis vous rechargez le timer avec le timing souhaité pour un nouveau cycle.

En cours de route, counterB permet de monter ou baisser la pwm.

Le traitement à la volée fait dans l'interruption (entre le moment où vous traitez TEST=0 ou TEST=1 dont on ne sait rien sur le temps nécessaire aux actions associées dans le prog principal) est peut être à l'origine de votre problème.
Il faudrait donc voir votre fonction main(), car si une autre action monopolise ou bloque le déroulement vous risquez de rater des événements qui seront traités en retard.

Voici un exemple avec le timer1:

void Init_compare (void)
{
if (TMR1IF)
        {
        TMR1H = 0xF6 ;
        TMR1L = 0x3B ;
        CCP1CON = 0b00001010 ;
        T1CON = 0b00110000 ;
        }
}

void Config_rapport_cycliqueV(long int Pos1)

{
CCPR1L = Pos1 ;
CCPR1H = Pos1>>8 ;
}

void Config_rapport_cycliqueH(long int Pos2)

{
CCPR1L = Pos2 ;
CCPR1H = Pos2>>8 ;
}

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

{
        if (TMR1IF)
                {
                RC6=0 ; // sortie à 0
                TMR1H=0xF6 ; //rechargement du timer
                TMR1L=0x3B ;
                TMR1IF=0 ;
                }
        if (CCP1IF)
                {
                RC6=1 ; //sortie à 1
                CCP1IF=0 ;
                }
}

[invite7a536414]

Merci pour l'aide,
Je vais étudier la solution, mais a première vue, tu n'appelles pas les deux fonctions : Config_rapport_cycliquex ?

Quand utilises t'on généralement le module Compare ? Dans des cas comme celui la ?

PS : pour mon application, il y a il une différence entre timer 0 et timer 1 ?

Merci d'avance

[invite5a48ffd1]

Voici quelques explications sur les différents modes:
https://www.mikroe.com/ebooks/pic-mi...ly/ccp-modules

[invitef86a6203]

La résolution max du trmr0 est très courte, donc il va suivant dans cette int.
Le TMR1 est sur 16 bits donc il peut être bien moins souvent appelé.

Généralement on utilise pas TMR0 pour faire du PPM.

Chtulhu a raison de fournir des exemples.
En voici un en C fourni pour HUL28 pour 2 voies sur ce forum;

// MPLAB 7.40 Compilateur Hitech C v8.02 PL1
// commande de deux servos moteurs (H et V) pour asservissement caméra vidéo
// les 2 servos sont commandés par un joystick 2 axes 4 positions
// l'action simultanée des deux servos permet des mouvements rotatifs, circulaire et en diagonale.

#include <pic.h>
#include "joystick.h"
#include "ad16f87x.h"
__CONFIG(XT & WDTEN & BORDIS & LVPDIS & UNPROTECT);
unsigned int val ;
unsigned char Vpos ;
unsigned char Hpos ;
#define Time 5
#define Clign 10
#define time_led 10
#define time2 40
void init_pic (void);
void Delais_Milli (int val) ;
void PosLed (void) ;
void Test_Leds (void) ;
void Reset (void) ;
static void interrupt inter(void) ;
void Init_compare(void) ;
void Config_rapport_cycliqueV(unsigned char) ;
void Config_rapport_cycliqueH(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; // /
// CLRWDT() ;
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 comparateur 1
CCP2IE = 1 ; // Interruption en mode comparaison autorisée comparateur 2

TMR1IE = 1 ; // Interruption du Timer1 autorisée 
}

main()
{
CLRWDT() ;
init_pic() ;

Init_compare() ;

Vpos = 90 ; // position centrale servo Vertical
Hpos = 90 ; // position centrale servo Horizontal
Config_rapport_cycliqueV (Vpos) ;
Config_rapport_cycliqueH (Hpos) ;

Test_Leds() ; // Test des leds au démarrage
while(1) // Le programme tourne dans cette boucle principale 
{

CLRWDT() ;
if (CENTRAGE_JOY == 0)
{
Reset() ; // Réinitialise les servos en position centrale
}
......... // tu mets ici tes commandes à envoyer au servos
}

static void interrupt inter(void) // Gestion du timer1 en mode compare
{
// CLRWDT() ;
if (TMR1IF)
{
RC6 = 1 ;
RC7 = 1 ;
TMR1H = 0xEC ;
TMR1L = 0x77 ;
TMR1IF = 0 ;
}
if (CCP1IF)
{
if ((Vpos > 0) && (Vpos < 180)) 
{
CCP1IF = 0 ;
RC6 = 0 ;
}
else
{
CCP1IF = 0 ;
RC6 = 1 ;
}
}
if (CCP2IF)
{
if ((Hpos > 0) && (Hpos < 180)) 
{
CCP2IF = 0 ;
RC7 = 0 ;
}
else
{
CCP2IF = 0 ;
RC7 = 1 ;
}
}

}

void Reset (void) // Fonction de remise en position centrale des servos
{
Vpos = 90 ;
Hpos = 90 ;
Config_rapport_cycliqueV(Vpos) ;
Config_rapport_cycliqueH(Hpos) ;
}

void Init_compare (void)
{
CLRWDT() ; 
{
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
}
}

//***********************************************************//
//Val_tmp = 60285+((139/100)*Hpos) ;
//Valeurs théoriques
// min (1ms)= (65535 - 20000µs/4µs) + 1000µs/4µs =60785
// moyen (1,5ms)=65535 - ((20000µs/4µs) + (1500µs/4µs))=60910
// define max (2ms)=65535 - ((20000µs/4µs) + (2000µs/4µs))=61035
void Config_rapport_cycliqueV(unsigned char)
{

unsigned int Val1_tmp ;
Val1_tmp = (139*Vpos)/100 ;
Val1_tmp += 60772 ; //Valeurs adaptées à la maquette et au servo

CCPR1L = Val1_tmp ;
CCPR1H = Val1_tmp >> 8 ; 

}

void Config_rapport_cycliqueH(unsigned char)
{
unsigned int Val2_tmp ;
Val2_tmp = (139*Hpos)/100 ;
Val2_tmp += 60772 ; //Valeurs adaptées à la maquette et au servo

CCPR2L = Val2_tmp ;
CCPR2H = Val2_tmp >> 8 ; 

}

[invitef86a6203]

Un second en asm qui vient de l'équipe Freebot (concours M6).

On reçoit une commande série RS232 (5V) pour 8 voies, il est cascadable avec une adresse 3 bits, pour en avoir 64 en tout.
résolution de 64 pas seulement mais pas d'int.
Un ancien pic , il y a différentes versions selon le quartz.
ça date un peu , c'est surprenant mais ça fonctionne bien malgré tout.

;           		  8 Servo Controller
;			Servo Interface Program
;
; Clock PIC with 19.6608 MHz crystal in HS mode.
; A 120 ohm resistor in series with the crystal is recommended.
; Disable the WDT configuration fuse.
; Connect:
; PA0..PA2 - Unit address select, high true. Do not float.
; PA3      - Serial input, low mark.
#define SERIN porta,3
; PB0..PB7 - Servo pulse outputs A..H, active high
; RTCC     - not used, connect to VSS or VDD to avoid float
;
;
; Uncomment only one baud rate
;#define BITTIME 4	;38,400 (reduced jitter immunity)
;#define BITTIME 8	;19,200
#define BITTIME 16	; 9,600
;#define BITTIME 32	; 4,800
;#define BITTIME 64	; 2,400
;#define BITTIME 128	; 1,200
;#define BITTIME 0	;   600

        PROCESSOR 16C54
        radix   decimal 
	;__CONFIG _HS_OSC&_WDT_OFF&_CP_OFF
        ; 
        cblock  0 
        indf 
        rtcc 
        pcl 
        status 
        fsr 
        porta 
        portb 
        portc           ;not in hardware 
	endc
#define _cy status,0
#define _z status,2
	;
	cblock	8	;servo positions MUST BE at 8..15
	ServoA		;position of servo A, 1..255, 0 represents 256
	ServoB
	ServoC
	ServoD
	ServoE
	ServoF
	ServoG
	ServoH
	Dummy		;initially selected null servo
	Enable		;bit map of enabled servo channels
	SShift		;serial receiver shift register
	STime		;serial bit timer
	SCount		;serial bit counter
	SState		;serial receive state
	SIndex		;which servo is addressed by serial port 0..7
	SData		;accumulate decimal digits
	Index		;points to setting of servo currently being pulsed
	Mask		;portb bit for servo currently being pulsed
	Pulse		;width of pulse being generated
	Flags
	endc
#define SSelect Flags,0 ;whether this unit is addressed by serial port
#define Gotdigt Flags,1	;whether any valid digits received
	;
	org	0
	;
RESET	movlw	0fh
	tris	porta	;port A all inputs
	movlw	00h
	movwf	portb	;port B all outputs
	tris	portb	
	clrf	Enable	;initially disable servos
	movlw	Idle
	movwf	SState	;start in idle state
	movlw	80h
	movwf	Mask	;start with servo A
	movlw	7
	movwf	Index
	bsf	SSelect
	bcf	Gotdigt
	movlw	Dummy-ServoA
	movwf	SIndex	;no servo selected
	clrf	SData
	;
;
; The program goes 'round the main loop generating a timed pulse
; for each servo in turn.  If a channel is disabled, the timing
; still runs bot the output port bit doesn't get set.
; Call the serial receive routine after every 7 instruction cycles.
;
LOOP	incf	Index,W	;advance Index to next servo setting
	andlw	07h
	movwf	Index
	iorlw	ServoA	;I wanted to addlw but there's no such thing
	movwf	fsr
	movf	indf,W
	movwf	Pulse
	call	Serial
	bcf	_cy
	btfsc	Mask,7
	bsf	_cy
	rlf	Mask,F	;advance mask to next servo bit
	movf	Mask,W
	andwf	Enable,W
	movwf	portb	;turn pulse on
puls1	call	Serial	;time programmed position * 32 cycles
	nop
	nop
	nop
	nop
	decfsz	Pulse,F
	goto	puls1
	nop
	call	Serial
	nop
	nop
	nop
	movlw	100	;minimum pulse width, 667uS = 102 * 32 cycles
	movwf	Pulse
puls2	nop
	nop
	call	Serial
	nop
	nop
	decfsz	Pulse,F
	goto	puls2
	clrf	portb	;end of pulse
	goto	LOOP
	;
;
; Call the serial receiver every 32 instruction cycles.
; Each call consumes 25 cycles including the call and retlw instructions.
;
Serial	movf	SState,W
	movwf	pcl	;dispatch to current state
	;
Idle	btfss	SERIN	;skip if serial input is space
	goto	idl15
	movlw	BITTIME/2 ;delay 1/2 bit time
	movwf	STime
	movlw	Ckstrt	;then make sure start bit persists
	movwf	SState
	goto	w10
	;
Ckstrt	decfsz	STime,F	;verify start bit by sampling at center
	goto	w15
	btfss	SERIN	;skip if start bit was valid
	goto	idl13
	movlw
BITTIME
;eelay 1 bit time
	movwf	STime
	movlw	Getbit	;then receive data
	movwf	SState
	movlw	8
	movwf	SCount	;for 8 bits
	goto	w6
	;
Getbit	decfsz	STime,F
	goto	w15
	rrf	SShift,F ;move prev bits right
	bcf	SShift,7
	btfss	SERIN
	bsf	SShift,7 ;insert new MSB
	movlw	BITTIME	;delay 1 bit time
	movwf	STime
	decfsz	SCount,F
	goto	w7	;more bits to go
	movlw	Ckstop
	movwf	SState
	goto	w4
	;
Ckstop	decfsz	STime,F
	goto	w15
	btfsc	SERIN	;skip if stop bit is valid
	goto	idl13
	bcf	SShift,7	;mask unused bit 7
	btfsc	SShift,6
	bcf	SShift,5	;make upper case
	movlw	Parse1
	movwf	SState
	goto	w7
	;
Parse1	movlw	-0dh
	addwf	SShift,W
	btfsc	_z
	goto	CRstate
	movlw	-'0'
	addwf	SShift,W
	btfss	_cy	;skip if SShift >= '0'
	goto	idl9
	movlw	-('9'+1)
	addwf	SShift,W
	movlw	Parse2	;continue parsing next time
	btfss	_cy	;skip if SShift >= ('9'+1)
	movlw	Digit	;process digit next time
	movwf	SState
	goto	w2
	;
Parse2	movlw	-'A'
	addwf	SShift,W
	btfss	_cy	;skip if SShift >= 'A'
	goto	idl13
	movlw	-('H'+1)
	addwf	SShift,W	
	btfss	_cy	;skip if SShift >= ('H'+1)
	goto	Select
	movlw	-'S'
	addwf	SShift,W
	btfss	_cy	;skip if >= 'S'
	goto	idl5
	movlw	-('Z'+1)
	addwf	SShift,W
	movlw	Unit
	btfsc	_cy	;skip if < ('Z'+1)
	movlw	Idle	;not recognized as valid
	movwf	SState
	retlw	0
	;
Unit	movlw	-'S'
	addwf	SShift,W	;S..Z => 0..7
	xorwf	porta,W
	bcf	SSelect
	andlw	07h
	btfsc	_z
	bsf	SSelect		;unit code matches PA0..PA2
	goto	idl9
	;	
Select	decf	SShift,W
	andlw	07h		;A..H => 0..7
	movwf	SIndex		;load this servo
	clrf	SData
	goto	idl3
	;
Digit	movf	SData,W
	addwf	SData,W
	movwf	SData	;SData *= 2
	addwf	SData,F
	addwf	SData,F
	addwf	SData,F
	addwf	SData,F	;SData *= 10
	movf	SShift,W
	andlw	0fh
	addwf	SData,F		;accrue decimal digit
	bsf	Gotdigt
	goto	idl4
	;
CRstate	btfss	Gotdigt
	goto	idl10
	bcf	Gotdigt
	movlw	CR		;process CR next time
	movwf	SState
	goto	w6
	;
CR	btfss	SSelect
	goto	idl15		;this unit not selected
	movlw	ServoA
	addwf	SIndex,W
	movwf	fwr
	movf	SData,W
	movwf	indf
	clrf	SData
	movf	SIndex,W
	call	Table	;get a bit mask
	iorwf	Enable,F ;enable the channel
	movlw	Idle
	movwf	SState
	retlw	0
	;
;
; Select Idle state and waste specified number of
; cycles to make up 25 cycles including call and retlw.
;
idl15	nop
idl14	nop
idl13	nop
idl12	nop
idl11	nop
idl10	nop
idl9	nop
idl8	nop
idl7	nop
idl6	nop
idl5	nop
idl4	nop
idl3	nop
	movlw	Idle
	movwf	SState
	retlw	0
	;
;
; Waste specified number of cycles to make up
; 25 cycles including call and return.
;
w15	nop
w14	nop
w13	nop
w12	nop
w11	nop
w10	nop
w9	nop
w8	nop
w7	nop
w6	nop
w5	nop
w4	nop
w3	nop
w2	nop
w1	nop
	retlw	0	
	;
;return mask (for setting enable bit) corresponding to index
;consumes 6 cycles including call and retlw
Table	addwf	pcl,F
	retlw	01h
	retlw	02h
	retlw	04h
	retlw	08h
	retlw	10h
	retlw	20h
	retlw	40h
	retlw	80h
	retlw	00h	;mask for dummy channel
	;
	org	1ffh
	goto	RESET
	;
	end

[invite7a536414]

Merci à tous pour votre aide.
J'ai travaillé sur le sujet afin de maîtriser au mieux les paramètres.

Pour résumer :
Pic : 18F47K40
Quartz = 4MHz
Je souhaite maintenant utiliser le Timer 1 et le monde "compare" afin de piloter un servo moteur...

Je n'ai pas la carte pic sous la main, mais voici la philosophie des registres que j'ai retenu :

Pour la partie initialisation :

CCP1CONbits.EN = 1;		// CCP is enabled
CCP1CONbits.MODE = 0b0001;	//Toggle output ; clear TMR1

TRISB0= 0;			//RB0 en sortie
RB0PPS = 0b0101 		//Brancher CCP1 sur la broche B0  (CCP1= PORT B ou PORTC)


//Timer1
T1CONbits.CKPS = 0b00; 	//Prescaler 1:1
T1CONbits.RD16 = 1;		//Timer 1 en mode 16 bits
T1CONbits.ON = 1;		// Enable Timer 1

T1GCONbits.GE = 0		//Always ON
T1GCONbits.GTM = 0;		//Timer 1 Gate Toggle mode is disable
T1GCONbits.GSPM = 0;		//Single Pulse mode is disable

TMR1CLKbits.CS = 0b0001;	// Fosc/4 Clock source

TMR1GATEbits.GSS =  0b1000;	//Timer1 Gate source selection bits : CCP1OUT

Ensuite je charge les registres CCPR1H et CCPR1L avec les bonnes valeurs. (mettons 2ms).
Dès que l'interruption CCP1IF se déclenche, je re charge à nouveau les registres CCPR1H et CCPR1L pour atteindre les 20-2ms.

Questions :
- Est ce la bonne philosophie ?
- Est ce que la sortie physique (RB0) va passer de 0->1 puis 1->0 "automatiquement" ou dois je gérer manuellement dans l'interruption ? (J'espère avoir configurer les registres pour ça se fasse en automatique).
- Finalement je n'ai pas besoin de toucher aux registres de comptage du timer1 non ? Je pense qu'il se reset tout seul non ?

Merci par avance

[invite7a536414]

petit up