Probleme bei Zeitmessung zwischen Interrupts mit STM32f107

#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;

    }

  }

}