/**
  ******************************************************************************
  * @file    Project/STM32F4xx_StdPeriph_Templates/stm32f4xx_it.c 
  * @author  MCD Application Team
  * @version V1.3.0
  * @date    13-November-2013
  * @brief   Main Interrupt Service Routines.
  *          This file provides template for all exceptions handler and 
  *          peripherals interrupt service routine.
  ******************************************************************************
  * @attention
  *
  * <h2><center>&copy; COPYRIGHT 2013 STMicroelectronics</center></h2>
  *
  * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License");
  * You may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
  *
  *        http://www.st.com/software_license_agreement_liberty_v2
  *
  * Unless required by applicable law or agreed to in writing, software 
  * distributed under the License is distributed on an "AS IS" BASIS, 
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  *
  ******************************************************************************
  */

/* Includes ------------------------------------------------------------------*/
#include "stm32f4xx_it.h"
#include "stm32f4xx_dac.h"
#include "main.h"
#include "paradacontrolada.h"
#include "homing.h"

/** @addtogroup Template_Project
  * @{
  */

/* Private typedef -----------------------------------------------------------*/
/* Private define ------------------------------------------------------------*/
/* Private macro -------------------------------------------------------------*/
/* Private variables ---------------------------------------------------------*/
/* Private function prototypes -----------------------------------------------*/
/* Private functions ---------------------------------------------------------*/

/******************************************************************************/
/*            Cortex-M4 Processor Exceptions Handlers                         */
/******************************************************************************/

/**
  * @brief  This function handles NMI exception.
  * @param  None
  * @retval None
  */
void NMI_Handler(void)
{
}

/**
  * @brief  This function handles Hard Fault exception.
  * @param  None
  * @retval None
  */
void HardFault_Handler(void)
{
  /* Go to infinite loop when Hard Fault exception occurs */
  while (1)
  {
  }
}

/**
  * @brief  This function handles Memory Manage exception.
  * @param  None
  * @retval None
  */
void MemManage_Handler(void)
{
  /* Go to infinite loop when Memory Manage exception occurs */
  while (1)
  {
  }
}

/**
  * @brief  This function handles Bus Fault exception.
  * @param  None
  * @retval None
  */
void BusFault_Handler(void)
{
  /* Go to infinite loop when Bus Fault exception occurs */
  while (1)
  {
  }
}

/**
  * @brief  This function handles Usage Fault exception.
  * @param  None
  * @retval None
  */
void UsageFault_Handler(void)
{
  /* Go to infinite loop when Usage Fault exception occurs */
  while (1)
  {
  }
}

/**
  * @brief  This function handles SVCall exception.
  * @param  None
  * @retval None
  */
void SVC_Handler(void)
{
}

/**
  * @brief  This function handles Debug Monitor exception.
  * @param  None
  * @retval None
  */
void DebugMon_Handler(void)
{
}

/**
  * @brief  This function handles PendSVC exception.
  * @param  None
  * @retval None
  */
void PendSV_Handler(void)
{
}

/**
  * @brief  This function decrement timing variable
  *	@with __weak parameter to prevent errors
  * @param  None
  * @retval None
  */
__weak void TimingDelay_Decrement(void) {

}

/**
  * @brief  This function handles SysTick Handler.
  * @param  None
  * @retval None
  */
void SysTick_Handler(void)
{
	TimingDelay_Decrement();
}

int8_t flag_Exp;
void TIM2_IRQHandler(void) 
{
	 //Ha pasado el tiempo de muestreo?
	 if (TIM_GetITStatus(TIM2, TIM_IT_Update) != RESET)
	 {
		 	//flag_Control = 1;
		 flag_Exp = 1;
		 
		 //Clear interruption flag
		 TIM_ClearITPendingBit(TIM2, TIM_IT_Update);
	
		 //printf("Han pasado 0,1 ms!\n");
		 //printf("interrupt \n");
		 
	 }
 }	

 extern volatile homing_t homing;
 
/* Handle PB0 interrupt */
void EXTI0_IRQHandler(void) {

    if (EXTI_GetITStatus(EXTI_Line0) != RESET) {
        /* Do your stuff when PB0 is changed */
		if(homing.state==1){
			homing.B0=1;
			DAC->DHR12R1 = escalado(2.5);
		}      
		else{
			paradacontrolada();
		}
		
        /* Clear interrupt flag */
        EXTI_ClearITPendingBit(EXTI_Line0);
    }
}

void EXTI1_IRQHandler(void) {

    if (EXTI_GetITStatus(EXTI_Line1) != RESET) {
        /* Do your stuff when PB1 is changed */
        if(homing.state==1){
			homing.B1=1;
			DAC->DHR12R1 = escalado(2.5);
		}      
		else{
			paradacontrolada();
		}
		     
        /* Clear interrupt flag */
        EXTI_ClearITPendingBit(EXTI_Line1);
    }
}

void EXTI2_IRQHandler(void) {

    if (EXTI_GetITStatus(EXTI_Line2) != RESET) {
        /* Do your stuff when PB2 is changed */
        if(homing.state==1){
			homing.B2=1;
			paradacontrolada();
		}      
		else{
			paradacontrolada();
		}
		        
        /* Clear interrupt flag */
        EXTI_ClearITPendingBit(EXTI_Line2);
    }
}

void EXTI3_IRQHandler(void) {

    if (EXTI_GetITStatus(EXTI_Line3) != RESET) {
        /* Do your stuff when PB3 is changed */
        if(homing.state==1){
			homing.B3=1;
			paradacontrolada();
		}      
		else{
			paradacontrolada();
		}
		        
        /* Clear interrupt flag */
        EXTI_ClearITPendingBit(EXTI_Line3);
    }
}


// Interrupciones para detectar el Indice del encoder
void EXTI4_IRQHandler(void) {

    if (EXTI_GetITStatus(EXTI_Line4) != RESET) {

		homing.Index1e=1;
		// paramos motor y registramos la posición
		DAC->DHR12R1 = escalado(2.5);
		encoder1.offset_index1e = TIM_GetCounter(TIM4);
		encoder3.offset_index1e = TIM_GetCounter(TIM8);

        
        // Clear interrupt flag //
        EXTI_ClearITPendingBit(EXTI_Line4);
    }
}
 
// Interrupciones para detectar el Indice del encoder
void EXTI9_5_IRQHandler(void) {

    if (EXTI_GetITStatus(EXTI_Line5) != RESET) {

		homing.Index1m=1;
		// paramos motor y registramos la posición
		DAC->DHR12R1 = escalado(2.5);
		encoder1.offset_index1m = TIM_GetCounter(TIM4);
		encoder3.offset_index1m = TIM_GetCounter(TIM8);
        
        // Clear interrupt flag 
        EXTI_ClearITPendingBit(EXTI_Line5);
    }
	
	/*if (EXTI_GetITStatus(EXTI_Line6) != RESET) {
        // Do your stuff when PF7 is changed //
        PF6_encoder2_indx=1;
		
		lectura_encoder2_homming = TIM_GetCounter(TIM8);
		
        
        // Clear interrupt flag //
        EXTI_ClearITPendingBit(EXTI_Line6);
    }
	
	if (EXTI_GetITStatus(EXTI_Line7) != RESET) {
        // Do your stuff when PF8 is changed //
        PF7_encoder3_indx=1;
		
		lectura_encoder3_homming = TIM_GetCounter(TIM1);
		//paradacontrolada();
        
        // Clear interrupt flag //
        EXTI_ClearITPendingBit(EXTI_Line7);
    }
	if (EXTI_GetITStatus(EXTI_Line8) != RESET) {
        // Do your stuff when PF6 is changed //
        PF8_encoder4_indx=1;
		lectura_encoder4_homming = TIM_GetCounter(TIM3);
		
		
		
		//PB8=1;
        
        // Clear interrupt flag //
        EXTI_ClearITPendingBit(EXTI_Line8);
    }*/
}


/******************************************************************************/
/*                 STM32F4xx Peripherals Interrupt Handlers                   */
/*  Add here the Interrupt Handler for the used peripheral(s) (PPP), for the  */
/*  available peripheral interrupt handler's name please refer to the startup */
/*  file (startup_stm32f4xx.s).                                               */
/******************************************************************************/

/**
  * @brief  This function handles PPP interrupt request.
  * @param  None
  * @retval None
  */
/*void PPP_IRQHandler(void)
{
}*/

/**
  * @}
  */ 


/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
