STM32F4 - Décalage d'un signal PWM

[invite9cc9ad42]

Bonjour,

J'ai programmé un signal PWM utilisant le port PB4 avec le timer TIM3 dans mon STM32F4 Discovery

int main (void)
{
while(1)
{
TIM3->CCR1 = 1000 ;        
}
}
 
/*____________________________TIM3______________________________*/
  /* TIM3 clock enable */
  RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM3, ENABLE);
  /* GPIOB Clock  */
  RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOB, ENABLE);
 
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_4 | GPIO_Pin_5 | GPIO_Pin_0 | GPIO_Pin_1;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
  GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
  GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP ;
  GPIO_Init(GPIOB, &GPIO_InitStructure);
 
  GPIO_PinAFConfig(GPIOB, GPIO_PinSource4, GPIO_AF_TIM3);
  GPIO_PinAFConfig(GPIOB, GPIO_PinSource5, GPIO_AF_TIM3);
  GPIO_PinAFConfig(GPIOB, GPIO_PinSource0, GPIO_AF_TIM3);
  GPIO_PinAFConfig(GPIOB, GPIO_PinSource1, GPIO_AF_TIM3);
//________________________________________________________________
/*__________________________TIM3____________________________________*/
 
  /* Time base configuration */
  TIM_TimeBaseStructure.TIM_Period = 1999;
  TIM_TimeBaseStructure.TIM_Prescaler = PrescalerValue;
  TIM_TimeBaseStructure.TIM_ClockDivision = 0;
  TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;
  TIM_TimeBaseInit(TIM3, &TIM_TimeBaseStructure);
 
  /* PWM1 Mode configuration: Channel1 */
  TIM_OCInitStructure.TIM_OCMode = TIM_OCMode_PWM1;
  TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;
  TIM_OCInitStructure.TIM_Pulse = 0;
  TIM_OCInitStructure.TIM_OCPolarity = TIM_OCPolarity_High;
  TIM_OC1Init(TIM3, &TIM_OCInitStructure);
  TIM_OC1PreloadConfig(TIM3, TIM_OCPreload_Enable);
 
  /* PWM1 Mode configuration: Channel2 */
  TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;
  TIM_OCInitStructure.TIM_Pulse = 0;
  TIM_OC2Init(TIM3, &TIM_OCInitStructure);
  TIM_OC2PreloadConfig(TIM3, TIM_OCPreload_Enable);
 
  /* PWM1 Mode configuration: Channel3 */
  TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;
  TIM_OCInitStructure.TIM_Pulse = 0;
  TIM_OC3Init(TIM3, &TIM_OCInitStructure);
  TIM_OC3PreloadConfig(TIM3, TIM_OCPreload_Enable);
 
  /* PWM1 Mode configuration: Channel4 */
  TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;
  TIM_OCInitStructure.TIM_Pulse = 0;
  TIM_OC4Init(TIM3, &TIM_OCInitStructure);
  TIM_OC4PreloadConfig(TIM3, TIM_OCPreload_Enable);
  TIM_ARRPreloadConfig(TIM3, ENABLE);
 
 
  /* TIM3 enable counter */
  TIM_Cmd(TIM3, ENABLE);
//________________________________________________________________

Ce programme donne un signal PWM à 50%

Je veux décaler ce signal PWM en temps

images.jpeg

avec une période T réglable

sigops1.png

Quel paramètre dois je changer ?

J'ai essayé de varier TIM_ClockDivision qui était initialement

TIM_TimeBaseStructure.TIM_Cloc kDivision = 0;

de 0 à 1 le signal se décale mais par une valeur T que ne le connais pas et elle n'est pas réglable

Quel est l'intervalle de variation de ce paramètre ClockDivision s'il vous plaît ?

Merci
-----

[sly37]

Bonjour,

Alors j'ai pas tout comprit à ta demande mais je peux t'expliquer les réglages possibles sur ce genre de Timer.
Dans une PWM tu peux régler la fréquence du signal et le rapport cyclique.
La fréquence ou période est réglable par "TIM_TimeBaseStructure.TIM_Per iod =..."
Le rapport cyclique est réglable par "TIM_OCInitStructure.TIM_P ulse =..."
Ce rapport cyclique ne s'exprime pas en % mais il reçoit une valeur comprise entre 0 et TIM_Period.

Les registres TIM_Prescaler et TIM_ClockDivision sont initialisés en début de programme pour fixer le cadencement de ton timer.
Si tu agis sur un des deux pour faire varier la PWM, ça ne marchera pas. Par ce principe tu fais varier la période mais avec des bonds énormes !

En cours de déroulement du programme tu peux modifier la valeur de PWM par "TIM3->CCR1=..." pour la voie 1 par exemple.

Je ne sais pas si tu débute mais ton programme n'est pas bien structuré
Bon courage pour la suite.

[invite9cc9ad42]

Merci pour votre réponse,

Je sais que les réglages possibles sont la période et le rapport cyclique.

Mais la tache que je vais l'effectuer est de décaler le signal d'une période T

J'ai programmé le signal 1 et je veux le décaler pour être comme le signal 2 voila !



Je veux juste savoir sur quel paramètre peux je jouer ?

par exemple j'ai essayé de changer dans PWM configuration le mode

/* PWM1 Mode configuration: Channel1 */
TIM_OCInitStructure.TIM_OCMode = TIM_OCMode_PWM1;
TIM_OCInitStructure.TIM_Output State = TIM_OutputState_Enable;
TIM_OCInitStructure.TIM_Pulse = 0;
TIM_OCInitStructure.TIM_OCPola rity = TIM_OCPolarity_High;

De PWM1 à PWM2 je trouve que le signal est devenu inversé

il était 00000 11111 00000 11111 .... avec PWM1
mais avec PWM2 --> 11111 00000 11111 0000

voila

le décalage que je demande que le signal sera de la forme suivante 000 00000 11111 00000 11111

j'espère que ma demande est clair ...

[sly37]

je suis désolé d'être aussi ignorant Taeway mais je ne comprends pas ta demande.
Un chronogramme de ce que tu veux STP.

Saches qu'avec ce µC on peut quasiment tout faire donc ne t'inquiète pas sur la solution, le tout c'est de se comprendre !

[A voir en vidéo sur Futura]

[invite9cc9ad42]

Je vous ai montré le chronogramme mon ami

J'ai généré le signal 1 de la photo je veux avoir le signal 2



Je souhaite retarder la réponse de signal dans le temps par une période T variable

[sly37]

D'après tes chronos tu veux déphaser tes signaux en paramétrant le déphasage, c'est ça ?!

[invite9cc9ad42]

Oui exactement !

[sly37]

Après petite réflexion, une des solutions serait de faire une PWM sur une sortie 1 telle que tu le fais ci-dessus.
ça te fait la première sortie, pour la 2nd il faut utiliser le mode "One Pulse Mode".

Ce mode permet de générer un pulse sur une sortie à partir d'un Trig interne ou externe.
Gros intérêt puisque tu prends ta 1ère PWM comme Trig interne, donc ta sortie 2 sera forcément cadencée à partir de la PWM.
Et surtout avec ce mode tu peux gérer le "deadtime" de manière très simple à partir d'un registre.

Je te laisse te documenter sur ce mode et reviens vers nous si tu vois pas la solution.

[invite9cc9ad42]

J'ai pensé qu'il y a un petit réglage à faire sur les paramètres de Timer pour arriver à mon objectif

Je vais voir le principe du mode "One Pulse Mode" et comment l’implémenté pour générer le deuxième signal dont signal 1 va être son Trig interne.

Je vous tient au courant

Merci

[invite9cc9ad42]

Excuser moi pour le dérangement

Mais je n'ai pas compris la différence en chronogramme entre un signal PWM et un signal One-Pulse PWM Mode :-/

En plus que les exemples que je trouve utilise presque le même algorithme de Pwm que j'ai utilisé, ils changent juste les paramètre de TIM_OCInitStructure.TIM_Pulse = 0; de 0 à une valeur ..

donc je n'ai pas pu avancer .

[sly37]

Une partie de ce que j'ai déjà essayé sur un projet.
Si ça t'intéresse je te file le code mais ces sorties ne conviennent peut être pas.

[invite9cc9ad42]

Bonjour,

Merci pour le chronogramme.
Pouvez vous me donner le code pour essayer d'avoir la sortie désirée.

[sly37]

Bonjour,

Voici un bout de code dont je me suis servis il y a quelques temps.
Je ne peux pas le tester actuellement, mais s'il ne marche pas chez toi je t'expliquerai comment faire pour t'en sortir.
Il suffit de configurer tes propres ports pour ça marche.

L'idée générale c'est de générer une PWM à partir d'une timer quelconque, puis de capturer cette PWM sur une entrée timer qui accepte le trig et ensuite de faire coincider la sortie OnePulse avecette entrée.

Courage chez moi ça fonctionne très avec 3 sorties utilisées en OnePulseMode.

/*----- Config sortie PWM : PA8 TIM1.CH1 -----*/
void Init_PWM_PA8(void)
{
/* Time Base configuration */
TIM_TimeBaseStructure.TIM_Pres caler = 0;
TIM_TimeBaseStructure.TIM_Coun terMode = TIM_CounterMode_Up;
TIM_TimeBaseStructure.TIM_Peri od = gConsig.PeriodPWM;
TIM_TimeBaseStructure.TIM_Cloc kDivision = 0;
TIM_TimeBaseStructure.TIM_Repe titionCounter = 0;

TIM_TimeBaseInit(TIM1, &TIM_TimeBaseStructure);

/* Configuration in PWM mode */
TIM_OCInitStructure.TIM_OCMode = TIM_OCMode_PWM2;
TIM_OCInitStructure.TIM_Output State = TIM_OutputState_Enable;
TIM_OCInitStructure.TIM_Output NState = TIM_OutputNState_Disable;
TIM_OCInitStructure.TIM_Pulse = gConsig.RapportVari;
TIM_OCInitStructure.TIM_OCPola rity = TIM_OCPolarity_Low;
TIM_OCInitStructure.TIM_OCNPol arity = TIM_OCNPolarity_High;
TIM_OCInitStructure.TIM_OCIdle State = TIM_OCIdleState_Set;
TIM_OCInitStructure.TIM_OCNIdl eState = TIM_OCIdleState_Reset;

TIM_OC1Init(TIM1, &TIM_OCInitStructure);

/* TIM1 counter enable */
TIM_Cmd(TIM1, ENABLE);

/* TIM1 Main Output Enable */
TIM_CtrlPWMOutputs(TIM1, ENABLE);
}

/*----- Config sortie du One Pulse Mode -----*/
void Init_OP_PA2(void)
{
/* Time base configuration */
TIM_TimeBaseStructure.TIM_Peri od = gConsig.ValPeriod;
TIM_TimeBaseStructure.TIM_Pres caler = 0;
TIM_TimeBaseStructure.TIM_Cloc kDivision = 0;
TIM_TimeBaseStructure.TIM_Coun terMode = TIM_CounterMode_Up;

TIM_TimeBaseInit(TIM2, &TIM_TimeBaseStructure);

/* TIM2 PWM2 Mode configuration: Channel1 */
TIM_OCInitStructure.TIM_OCMode = TIM_OCMode_PWM2;
TIM_OCInitStructure.TIM_Output State = TIM_OutputState_Enable;
TIM_OCInitStructure.TIM_Pulse = gConsig.ValDelai;
TIM_OCInitStructure.TIM_OCPola rity = TIM_OCPolarity_High;

TIM_OC3Init(TIM2, &TIM_OCInitStructure);

/* Input Capture Mode sur PA0 : TIM2.CH1 */

TIM_ICStructInit(&TIM_ICInitSt ructure);

TIM_ICInitStructure.TIM_Channe l = TIM_Channel_1;
TIM_ICInitStructure.TIM_ICPola rity = TIM_ICPolarity_Rising;
TIM_ICInitStructure.TIM_ICSele ction = TIM_ICSelection_DirectTI;
TIM_ICInitStructure.TIM_ICPres caler = TIM_ICPSC_DIV1;
TIM_ICInitStructure.TIM_ICFilt er = 0;

TIM_ICInit(TIM2, &TIM_ICInitStructure);

/* génération du One Pulse Mode sur PA2 : TIM2.CH3 */
TIM_SelectOnePulseMode(TIM2, TIM_OPMode_Single);

/* Input Trigger selection PA8 : TIM1 CH1 */
TIM_SelectInputTrigger(TIM2, TIM_TS_TI1FP1);

/* Slave Mode selection: Trigger Mode */
TIM_SelectSlaveMode(TIM2, TIM_SlaveMode_Trigger);
}