Probleme bei Zeitmessung zwischen Interrupts mit STM32f107

[Jakub (Gast)]

Hallo!
Nach langer und erfolgloser Fehlersuche muss ich mich an euch um Hilfe 
wenden.
Ich versuche mithilfe eines STM32-f107 uC, einer Zahnscheibe und eines 
Hall-Sensors die Drehzahl eines Rades zu bestimmen. Der Hallsensor geht 
auf High sobald ein Zahn vor ihm vorbeiläuft und löst einen Interrupt 
aus. Mithilfe eines Hardware-Timers soll dann die Zeit zwischen zwei 
solchen Interrupts gemessen und in eine Raddrehzahl umgerechnet werden.

Im jetzigen Versuchsaufbau wird dieses Signal mit einem sauberen PWM 
Signal mit konstaner Frequenz von 100 Hz (resultierend in einer 
soll-Raddrehzahl von 300) simuliert. Der Microcontroller zeigt jedoch 
das Verhalten wie auf dem beigefügten Bild: Ausreißer zum Wert 150 
deuten auf verpasste Signalflanken hin, die Ausreißer zur 0 kann ich mir 
nicht erklären, da diese sehr hohe werte im Timer-Register bedeuten. 
Weitere Anomalien mit Ausschlägen nach oben treten ebenfalls auf. Das 
ganze lässt mich Vermuten es handle sich um ein Problem mit der Abfolge 
der Interrupt Ausführung, mein Wissen reicht jedoch nicht bis zu einer 
Lösung. Ich hoffe jemand kann mir dabei behilflich sein. Als Referenz 
poste ich auch den benutzen Code. Vielen Dank!

#include "blink.h"

#include "stm32f10x_it.h"
#include "stm32f10x_conf.h"
#include "stm32f10x_adc.h"
#include "stm32f10x_can.h"
#include "stm32f10x_rcc.h"
#include "stm32f10x_dma.h"
#include "stm32f10x_can.h"
#include "misc.h"
#include "can_handling.h"


uint32_t sysTick_counter = 0;
uint32_t last_exti9 = 0;
uint32_t last_exti10 = 0;
uint32_t time_exti9 = 0;
uint32_t time_exti10 = 0;

void SysTick_Handler(void){
  sysTick_counter++;
}

void revolutionCounter_InitGPIO(void)
{
  GPIO_InitTypeDef GPIO_InitStructure;

  //RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOD, ENABLE);
  RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOD | RCC_APB2Periph_AFIO, ENABLE);

  //GPIOC Initilization
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPD; //GPIO_Mode_IN_FLOATING
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9 | GPIO_Pin_10;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_Init(GPIOD, &GPIO_InitStructure);
}


void revolutionCounter_InitEXTI(void)
{
  EXTI_InitTypeDef EXTI_InitStructure;

  //Init EXTI
  EXTI_InitStructure.EXTI_Line = EXTI_Line9;
  EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt;
  EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Rising;
  EXTI_InitStructure.EXTI_LineCmd = ENABLE;
  EXTI_Init(&EXTI_InitStructure);

  //Second time for Line10?
  EXTI_InitStructure.EXTI_Line = EXTI_Line10; //The rest should stay the same?
  EXTI_Init(&EXTI_InitStructure);

  //Connect GPIO to EXTI
  GPIO_EXTILineConfig(GPIO_PortSourceGPIOD, GPIO_PinSource9); //left
  GPIO_EXTILineConfig(GPIO_PortSourceGPIOD, GPIO_PinSource10); //right
}

void revolutionCounter_InitNVIC(void)
{
  NVIC_InitTypeDef NVIC_InitStructure;

  //Init NVIC
  NVIC_PriorityGroupConfig(NVIC_PriorityGroup_4);

  NVIC_InitStructure.NVIC_IRQChannel = EXTI9_5_IRQn;
  NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
  NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0x00;//0xBF;
  NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0x0F;
  NVIC_Init(&NVIC_InitStructure);

  //Second time for line10?
  NVIC_InitStructure.NVIC_IRQChannel = EXTI15_10_IRQn;
  NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
  NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0x00; //0xBF;
  NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0x0F;
  NVIC_Init(&NVIC_InitStructure);
}

void revolutionCounter_initTim() //TODO: TIM2 und 4
{
  //Setup hardware timer 2
  TIM_DeInit(TIM2);
  RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2, ENABLE);
  TIM_TimeBaseInitTypeDef timer_init_struct2;
  timer_init_struct2.TIM_Prescaler = 36000;
  timer_init_struct2.TIM_CounterMode = TIM_CounterMode_Up;
  timer_init_struct2.TIM_Period = 10000; //divide by 2?!
  timer_init_struct2.TIM_ClockDivision = TIM_CKD_DIV2;
  timer_init_struct2.TIM_RepetitionCounter = 0;
  //TIM_SelectOutputTrigger(TIM2, TIM_TRGOSource_Update);
  TIM_TimeBaseInit(TIM2, &timer_init_struct2);

  NVIC_InitTypeDef tim2_it_struct;

  TIM_Cmd(TIM2, ENABLE);

  //TIM 4
  TIM_DeInit(TIM4);
  RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM4, ENABLE);
  TIM_TimeBaseInitTypeDef timer_init_struct4;
  timer_init_struct4.TIM_Prescaler = 36000;
  timer_init_struct4.TIM_CounterMode = TIM_CounterMode_Up;
  timer_init_struct4.TIM_Period = 10000;
  timer_init_struct4.TIM_ClockDivision = TIM_CKD_DIV2;
  timer_init_struct4.TIM_RepetitionCounter = 0;
  //TIM_SelectOutputTrigger(TIM4, TIM_TRGOSource_Update);
  TIM_TimeBaseInit(TIM4, &timer_init_struct4);

  NVIC_InitTypeDef tim4_it_struct;

  TIM_Cmd(TIM4, ENABLE);

  //TIM_SetCounter wenn zeit ausgelesen
  //TIM_GetCounter() to get it

}

void EXTI9_IRQHandler(void){
  uint32_t now = TIM_GetCounter(TIM2);
  if(GPIO_ReadInputDataBit(GPIOD, GPIO_PinSource10)){
    time_exti9 = now;
//    time_exti9 = now-last_exti9;

    //last_exti9 = now;
    TIM_SetCounter(TIM2, (uint16_t) 0);
  }

  EXTI_ClearITPendingBit(EXTI_Line9);
}

void EXTI10_IRQHandler(void){

  uint32_t now = sysTick_counter;
  if(GPIO_ReadInputDataBit(GPIOD, GPIO_PinSource10)){
    time_exti10 = now-last_exti10;
    last_exti10 = now;
  }
  EXTI_ClearITPendingBit(EXTI_Line10);

}
void usb_lp_can_rx0_isr(void){}
void can2_rx0_isr(void){}

int main(void)
{

  ///////*General Controller Initialization *///////
  NVIC_PriorityGroupConfig(NVIC_PriorityGroup_4);
  SysTick_CLKSourceConfig(SysTick_CLKSource_HCLK_Div8);
  SysTick_Config(9000);

  volatile uint32_t now = sysTick_counter;
  while ((sysTick_counter - now) <= 10){
    __asm__ volatile ("nop");
  }
  RCC_APB1PeriphClockCmd(RCC_APB1Periph_CAN2, ENABLE);
  RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO, ENABLE);
  RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE); //GPIOB
  blink_setup();
  can_setup();

  revolutionCounter_InitGPIO();
  revolutionCounter_InitNVIC();
  revolutionCounter_InitEXTI();
  revolutionCounter_initTim();

  uint32_t last_sent = 0xFFFF;

  CanTxMsg revCounter_sensorData1;
  revCounter_sensorData1.StdId = 0x390;
  revCounter_sensorData1.ExtId = 0;
  revCounter_sensorData1.IDE = CAN_Id_Standard;
  revCounter_sensorData1.RTR = CAN_RTR_DATA;
  revCounter_sensorData1.DLC = 8;

  for(;;){

    if (sysTick_counter - last_sent > 10){
      int32_t revCounter_resultLeft = 60000 / (time_exti9 * 20);
      int32_t revCounter_resultRight = 60000 / (time_exti10 * 20);

      revCounter_sensorData1.Data[0] = (uint8_t) (revCounter_resultLeft);
      revCounter_sensorData1.Data[1] = (uint8_t) (revCounter_resultLeft >> 8);
      revCounter_sensorData1.Data[2] = (uint8_t) (revCounter_resultLeft >> 16);
      revCounter_sensorData1.Data[3] = (uint8_t) (revCounter_resultLeft >> 24);
      revCounter_sensorData1.Data[4] = (uint8_t) (revCounter_resultRight);
      revCounter_sensorData1.Data[5] = (uint8_t) (revCounter_resultRight >> 8);
      revCounter_sensorData1.Data[6] = (uint8_t) (revCounter_resultRight >> 16);
      revCounter_sensorData1.Data[7] = (uint8_t) (revCounter_resultRight >> 24);

      if (revCounter_resultLeft <= 150){
        uint32_t dummy = 0xBEEF;
      }

      CAN_Transmit(CAN2, &revCounter_sensorData1);
      last_sent = sysTick_counter;
    }
  }
}

[STK500-Besitzer (Gast)]

Warum verwendest du nicht einfach die Input-Capture-Unit des Timers?

[Jakub (Gast)]

Hatte ich um ehrlich zu sein nicht auf dem Schirm. Werde das als 
nächstes versuchen, allerdings würde ich auch gerne wissen wo der Fehler 
in meinem Code liegt, weil das etwas mittlerweile etwas frustrierend ist 
die Fehlerursache nicht zu kennen :D

[Thomas E. (picalic)]

Servus,

sollte das if() im EXTI9_IRQHandler nicht PD9 auf high testen? Sieht 
nach einem typischen "Copy+Paste" Fehler aus...

Die Variablen, die in der ISR verändert werden und in main gelesen 
werden, solltest Du als volatile deklarieren. Sonst könnte der Compiler 
z.B. auf die Idee kommen, time_exti9 einmal vor der Endlosschleife in 
ein Register zu laden und dann nur mit diesem Register zu arbeiten. Die 
ISR schreibt aber in das für time_exti9 reservierte RAM.

[Jakub (Gast)]

Ja das müsste es tatsächlich, praktisch macht es aber keinen 
unterschied, D10 war auf permament auf High und das Bild sieht genauso 
aus.

[Jakub (Gast)]

Die Variablen auf volatile zu setzen macht ebenfalls keinen Unterschied

[Thomas F. (igel)]

So aus eigener Erfahrung:
Auf einem Atmega16 habe ich sowas ähnliches in Assembler am laufen. Dort 
mit Input Capture Interrupt. Funktioniert gut...

Die Elektronik des Sensors muss natürlich erst mal passen. Wenn die 
schon zwischendrin zusätzliche kurze Spikes erzeugt und eben keine 
sauberen Flanken so hat man gleich mal eine unangenehme Störquelle. Also 
erst mal mit dem Oszi den Signalpfad ansehen ob dort alles passt.

Zur Auswertung des Timer-Counters in der Software: Die Drehzahl bzw. 
schon der Counterwert ändert sich zwischen zwei Impulsen einer 
Zahnscheibe nicht abrupt um den doppelten Wert. Ich vergleiche in meiner 
Software daher den neuen Wert mit dem letzten Wert des Counters. Ist der 
Unterschied größer als 25% so liegt ein Messfehler vor und der neue Wert 
kann gleich verworfen werden.