Drivers

/*
 * quadEncoder.h
 *
 *  Created on: 30 juin 2016
 *      Author: kerhoas
 */

#ifndef INC_QUADENCODER_H_
#define INC_QUADENCODER_H_



#include "main.h"

void quadEncoder_Init(void);
uint16_t quadEncoder_GetPos16(void);
int32_t quadEncoder_GetPos32(void);
int16_t quadEncoder_GetSpeed(void);
void quadEncoder_CallbackIndexZ(void);
void quadEncoder_PosCalc(int*);


#endif /* INC_QUADENCODER_H_ */

/*
 * QuadEncoder.c
 */
#include "quadEncoder.h"
#define COUNT_PER_ROUND 2000
#define MAX_CNT_PER_REV (COUNT_PER_ROUND * 4 - 1)
#define MAX_COUNT (int)(((unsigned long)MAX_CNT_PER_REV*4096)/1000)
#define HALF_MAX_COUNT (MAX_COUNT>>1)

TIM_HandleTypeDef    TimEncoderHandle;

static int indexZ=-1;


int first_index_reached = 0;

//================================================================
//		TIMER INIT
//================================================================

void quadEncoder_Init(void)
{
	TIM_Encoder_InitTypeDef sConfig;

	TimEncoderHandle.Instance = TIM2;
	TimEncoderHandle.Init.Prescaler = 0;
	TimEncoderHandle.Init.CounterMode = TIM_COUNTERMODE_UP;
	TimEncoderHandle.Init.Period = COUNT_PER_ROUND*4;
	TimEncoderHandle.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;

	sConfig.EncoderMode = TIM_ENCODERMODE_TI12;
	sConfig.IC1Polarity = TIM_INPUTCHANNELPOLARITY_RISING;
	sConfig.IC1Selection = TIM_ICSELECTION_DIRECTTI;
	sConfig.IC1Prescaler = TIM_ICPSC_DIV4;
	sConfig.IC1Filter = 0x0F;
	sConfig.IC2Polarity = TIM_INPUTCHANNELPOLARITY_RISING;
	sConfig.IC2Selection = TIM_ICSELECTION_DIRECTTI;//TIM_ICSELECTION_DIRECTTI; //TIM_TI1SELECTION_XORCOMBINATION
	sConfig.IC2Prescaler = TIM_ICPSC_DIV4;
	sConfig.IC2Filter = 0x0F;

	HAL_TIM_Encoder_Init(&TimEncoderHandle, &sConfig);
	HAL_TIM_Encoder_Start(&TimEncoderHandle,TIM_CHANNEL_1);
	HAL_TIM_Encoder_Start(&TimEncoderHandle,TIM_CHANNEL_2);
}
//================================================================
//		POSITION LEFT CALC
//================================================================
void quadEncoder_PosCalc(int* AngPos)
{

int POSCNTcopy = 0;
POSCNTcopy = (int)TIM2->CNT;
AngPos[1] = AngPos[0];
AngPos[0] = (unsigned int)(((unsigned long)POSCNTcopy * 4096)/1000); // 0 <= POSCNT <= 4999 to 0 <= AngPos <= 32767
}
//================================================================
//		POSITION LEFT 16 BITS
//================================================================
uint16_t quadEncoder_GetPos16(void)
{
	uint16_t Pos = 0;
	Pos=TIM2->CNT;
	return Pos;
}
//================================================================
//		POSITION LEFT 32 BITS	(pos 16 bits + nombre de tours)
//================================================================
int32_t quadEncoder_GetPos32(void)
{
	int32_t  PosL = 0;
	PosL=indexZ*2*COUNT_PER_ROUND + (int32_t) quadEncoder_GetPos16();
	return -PosL;
}
//================================================================
//		SPEED LEFT
//--> get pos and reset timer ; must be called every Te
//================================================================
int16_t quadEncoder_GetSpeed(void)
{
	static int AngPos[2] = {0,0};
	static int16_t Speed=0;


	quadEncoder_PosCalc(AngPos);
	Speed = AngPos[0] - AngPos[1];
	if (Speed >= 0)
	{
		if (Speed >= HALF_MAX_COUNT)
			{
			Speed = Speed - MAX_COUNT;
			}
	}
	else
	{
		if (Speed < -HALF_MAX_COUNT)
			{
			Speed = Speed + MAX_COUNT;
			}
	}
	Speed = Speed << 1;		//*2
	return Speed;
}
//================================================================
//		MAJ indexZ Left
//================================================================
void quadEncoder_CallbackIndexZ()
{
				if (__HAL_TIM_DIRECTION_STATUS(&TimEncoderHandle)==1)
				{
					indexZ--;
				}
				else
				{
					indexZ++;
				}
				__HAL_TIM_SetCounter(&TimEncoderHandle, 0);		// RAZ Counter
				HAL_TIM_Encoder_Start(&TimEncoderHandle,TIM_CHANNEL_1);
				HAL_TIM_Encoder_Start(&TimEncoderHandle,TIM_CHANNEL_2);

				first_index_reached = 1;
}
//================================================================

/*
 * drv_adc.h
 *
 *  Created on: 25 oct. 2016
 *      Author: kerhoas
 */

#ifndef SRC_DRV_DRV_ADC_H_
#define SRC_DRV_DRV_ADC_H_

#include "main.h"

void adc1_Init(void);
uint32_t adc_getPotValue(void);
uint32_t adc_getIaValue(void);
uint32_t adc_getIbValue(void);


typedef struct {
  uint16_t* RegularValueBuffer;        /*!< Regular buffer for converted value*/
  uint16_t* InjectedValueBuffer;       /*!< Injected buffer for converted value*/
  uint32_t RegularCurrentRank;         /*!< Regular current rank*/
  uint32_t InjectedCurrentRank;        /*!< Injected current rank*/
  uint32_t nbRegChannel;               /*!< Number of regular channel*/
  uint32_t nbInjChannel;               /*!< Number of injected channel*/
  uint8_t useDMA;                      /*!< DMA aquisition mode */
  void (* ItEOCFcn)(void);
  void (* ItJEOCFcn)(void);
  void (* ItAWDFcn)(void);
  void (* ItOVRFcn)(void);
} ADC_DataLinkTypeDef;

extern uint16_t G_NbAdcConf;           /* Number of ADC configured */

/* Array of ADC data information */
extern ADC_DataLinkTypeDef* G_ADC_Data[2];
extern ADC_HandleTypeDef* G_ADC_Handler[2];

ADC_HandleTypeDef hadc1;
DMA_HandleTypeDef hdma_adc1;

/* ADC1 Regular channel Converted value buffer */
extern uint16_t ADC1_RegularConvertedValue[3];

/* ADC1 data information*/
extern ADC_DataLinkTypeDef ADC1_DataLink;


#endif /* SRC_DRV_DRV_ADC_H_ */

/*
 * drv_adc.c
 *
 *  Created on: 25 oct. 2016
 *      Author: kerhoas
 */

#include "drv_adc.h"

uint16_t G_NbAdcConf = 0;              /* Number of ADC configured */

ADC_DataLinkTypeDef* G_ADC_Data[2];
ADC_HandleTypeDef* G_ADC_Handler[2];
uint16_t ADC1_RegularConvertedValue[3];
ADC_DataLinkTypeDef ADC1_DataLink;

extern uint16_t g_ADCBuffer[3];
extern uint16_t potentiometre, Ia_mes, Ib_mes;

void adc1_Init(void)
{
  ADC_ChannelConfTypeDef sConfig;

  hadc1.Instance = ADC1;
  hadc1.Init.ClockPrescaler = ADC_CLOCKPRESCALER_PCLK_DIV2;
  hadc1.Init.Resolution = ADC_RESOLUTION12b;
  hadc1.Init.ScanConvMode = ENABLE;
  hadc1.Init.ContinuousConvMode = DISABLE; // Conversions Triggered
  hadc1.Init.DiscontinuousConvMode = DISABLE;
  hadc1.Init.ExternalTrigConvEdge = ADC_EXTERNALTRIGCONVEDGE_RISING;
  hadc1.Init.ExternalTrigConv =ADC_EXTERNALTRIGCONV_T3_CC1;

  hadc1.Init.DataAlign = ADC_DATAALIGN_RIGHT;
  hadc1.Init.NbrOfConversion = 3;
  hadc1.Init.DMAContinuousRequests = ENABLE;
  hadc1.Init.EOCSelection = ADC_EOC_SEQ_CONV;
  HAL_ADC_Init(&hadc1);

  sConfig.Channel = ADC_CHANNEL_9; // POT VALUE
  sConfig.Rank = 3;
  sConfig.SamplingTime =  ADC_SAMPLETIME_84CYCLES;
  HAL_ADC_ConfigChannel(&hadc1, &sConfig);

  sConfig.Channel = ADC_CHANNEL_0; // Ia VALUE
  sConfig.Rank = 1;
  HAL_ADC_ConfigChannel(&hadc1, &sConfig);

  sConfig.Channel = ADC_CHANNEL_11; // Ib VALUE
  sConfig.Rank = 2;
  HAL_ADC_ConfigChannel(&hadc1, &sConfig);

  hdma_adc1.Instance = DMA2_Stream0;
  hdma_adc1.Init.Channel = DMA_CHANNEL_0;
  hdma_adc1.Init.Direction = DMA_PERIPH_TO_MEMORY;
  hdma_adc1.Init.PeriphInc = DMA_PINC_DISABLE;
  hdma_adc1.Init.MemInc = DMA_MINC_ENABLE;
  hdma_adc1.Init.PeriphDataAlignment = DMA_PDATAALIGN_HALFWORD;
  hdma_adc1.Init.MemDataAlignment = DMA_MDATAALIGN_HALFWORD;
  hdma_adc1.Init.Mode = DMA_CIRCULAR;
  hdma_adc1.Init.Priority = DMA_PRIORITY_HIGH;
  hdma_adc1.Init.FIFOMode = DMA_FIFOMODE_DISABLE;
  HAL_DMA_Init(&hdma_adc1);

  __HAL_LINKDMA(&hadc1,DMA_Handle,hdma_adc1);
}


//============================================================================
//		INTERRUPTION ADC
//============================================================================
void HAL_ADC_ConvCpltCallback(ADC_HandleTypeDef* hadc)
{
//	HAL_GPIO_WritePin(GPIOC, GPIO_PIN_9, 1);
	Ia_mes	 = g_ADCBuffer[0];
	Ib_mes	=  g_ADCBuffer[1];
	potentiometre =  g_ADCBuffer[2];

//	HAL_GPIO_WritePin(GPIOC, GPIO_PIN_9, 0);
}
//============================================================================

#include <stdint.h>
#include <stdio.h>

#include "stm32f4xx_hal.h"
#include "stm32f4xx.h"
#include "stm32f4xx_hal_conf.h"


#include "drv_adc.h"
#include "stm32F446_nucleo_ihm07m1_enib.h"
#include "drv_uart.h"
#include "SystemClock.h"
#include "calc.h"
#include "config.h"
#include "tickTimer.h"
#include "drv_can.h"

#include "pulseGenerator.h"

#include "sendtoXcos.h"
#include "quadEncoder.h"
#include "pwmTimer.h"

#include "FreeRTOS.h"
#include "task.h"
#include "queue.h"
#include "semphr.h"

#include "X2C.h"


extern ADC_HandleTypeDef hadc1;
extern TIM_HandleTypeDef htim1;
extern TIM_HandleTypeDef htim3;
extern TIM_HandleTypeDef htim4;
extern UART_HandleTypeDef huart2;



typedef unsigned short uint16_t;
typedef short int16_t;
typedef unsigned char uint8_t;
typedef signed char int8_t;
typedef unsigned short uint16_t;
typedef short int16_t;
typedef unsigned char uint8_t;
typedef signed char int8_t;

#include "main.h"
#include "motorControl.h"


#define OFFSET_THETA	800

extern void SystemClock_Config(void);
extern void findFirstIndex();
extern void MX_TIM1_Init(void);
extern void MC_FOC_Start_PWM_driving(void);
extern void  MC_FOC_EnableInputs();

extern int32_t quadPos, theta_elec;
extern q31_t iq_mes;
extern int first_index_reached;
extern TIM_HandleTypeDef    TimHandle_period, TimHandle_adc, h_TimSlowTask;
extern 	uint16_t	potentiometre;
extern uint16_t Ia_mes, Ib_mes, Ic_mes;
extern int32_t	Ia_mes_ext, Ib_mes_ext;
extern 	q31_t alpha, beta, sinVal, cosVal;

int16_t speed_mes;

uint32_t pot;
int16_t Ia_bias, Ib_bias;
uint16_t g_ADCBuffer[3];
int32_t pulse=-1;

void (*rxCompleteCallback) (void);
void can_callback(void);

CAN_Message      rxMsg;
CAN_Message      txMsg;
long int        counter = 0;

uint8_t* aTxBuffer[2];

xSemaphoreHandle xSemaphore_Fast = NULL;
xSemaphoreHandle xSemaphore_Slow = NULL;
xQueueHandle qh = NULL;
extern q31_t  iq_err, iq_cde;


int32_t theta_elec_ex;

//int32_t tab_speed[5000];
int FC1, FC2;

//============================================================================
static void Fast_Task(void *pvParameters)
{
	vTaskDelay(5);
	Ia_bias=Ia_mes;
	Ib_bias=Ib_mes;
	int cnt_40 = 40;
	int16_t signe;
	int state=0;


	for (;;)
	{

		if (first_index_reached == 0)
			{

			#if USE_MOTOR
				findFirstIndex();	// stm32F446_nucleo_ihm07m1_enib.c
			#else
				first_indeInports.pot=potentiometre; break;x_reached = 1;
			#endif

			}
		else
			{

		HAL_GPIO_WritePin(GPIOC, GPIO_PIN_9, 1);		// PC9 MES PER 1 --> To profile function
		//---------------------------------------------------

		Inports.pot=potentiometre;
		Inports.pulse=pulse;



		//---------------------------------------------------
 		quadPos = quadEncoder_GetPos16();			// cf quadEncoder.c
		signe=((int16_t)quadPos+OFFSET_THETA);

		if (signe>8000)
		{quadPos = quadPos + OFFSET_THETA - 8000;}
		else
		{quadPos = quadPos + OFFSET_THETA;}

		theta_elec=quadPos%2000 ;	//theta_elec=quadPos/POLE_PAIR; // [0 8000] --> [0 2000]
		theta_elec_ex=(int32_t)(theta_elec)*16;

		Inports.theta_elec=theta_elec_ex;
		//........................................................

		Ia_mes_ext=((int32_t)Ia_mes)-Ia_bias;
		Ib_mes_ext=((int32_t)Ib_mes)-Ib_bias;


		Inports.Ia=Ia_mes_ext;
		Inports.Ib=Ib_mes_ext;

		//........................................................

	    if (cnt_40 == 0)
	    {
	    	speed_mes=-quadEncoder_GetSpeed();
	    	Inports.speed=speed_mes;

	        cnt_40 = 40;

	    }

	    cnt_40--;

 		X2C_Update();


 		// Update Duty Cycle
		pwmSetDutyCycle(*Outports.pduty_1,*Outports.pduty_2,*Outports.pduty_3);

		HAL_GPIO_WritePin(GPIOC, GPIO_PIN_9, 0);		// PC9

			}

	xSemaphoreTake( xSemaphore_Fast, portMAX_DELAY );
	}
}
//============================================================================
static void Print_Task(void *pvParameters)
{
	txFrame txf;
	for (;;)
	{
		txf.data0 = potentiometre;
		txf.data1 = pulse;
		txf.data2 = speed_mes;
		txf.data3 =Inports.Ia;
		txf.data4 = *Outports.pIQ_mes;
		txf.data5 = *Outports.pduty_1;
		txf.data6 =0;
		sendtoXcos(txf);
	}
}
//============================================================================
//	>>>>>>>>>>>>>>>>>>>>>>>>>>	MAIN  <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
//============================================================================
int main(void)
{
  HAL_Init();
  SystemClock_Config();

  adc1_Init();
  uart2_Init();
  quadEncoder_Init();
  pwmTimer_Init();
  tickTimerInit(PWM_COUNT_PERIOD);

  first_index_reached=0;
  MC_FOC_Nucleo_Init();
  MC_FOC_Start_PWM_driving();
  pwmSetDutyCycle(420,420,420);
  HAL_GPIO_WritePin(GPIOB,GPIO_PIN_2,GPIO_PIN_SET); //BSP_X_NUCLEO_FAULT_LED_ON();
  MC_FOC_EnableInputs();

#if USE_PULSE
  pulseGenerator_Init(3000);
#endif

  can_Init();		// Default CAN BAUDRATE : 500kb/s
  can_Filter_disable(); // Accept everybody
  can_IrqInit();
  can_IrqSet(&can_callback);

  txMsg.id=0x7FF;
  txMsg.data[0]=1;
  txMsg.data[1]=2;
  txMsg.len=2;
  txMsg.format=CANStandard;
  txMsg.type=CANData;

  can_Write(txMsg);		// TEST CAN BUS
  HAL_Delay(100);

  X2C_Init();

  //--------------------------------------------
  // 				FREERTOS
  //--------------------------------------------

  potentiometre =450;

  xTaskCreate( Fast_Task, ( const portCHAR * ) "Fast_Task", 512, NULL, tskIDLE_PRIORITY+3, NULL );
  xTaskCreate( Print_Task, ( const portCHAR * ) "Print_Task", 512, NULL, tskIDLE_PRIORITY+1, NULL );

  vSemaphoreCreateBinary(xSemaphore_Fast);
  xSemaphoreTake( xSemaphore_Fast, portMAX_DELAY );

  vSemaphoreCreateBinary(xSemaphore_Slow);
  xSemaphoreTake( xSemaphore_Slow, portMAX_DELAY );


  __HAL_TIM_ENABLE_IT(&TimHandle_period,TIM_IT_UPDATE); // ??
  HAL_TIM_OC_Start(&TimHandle_period, TIM_CHANNEL_1);
  HAL_ADC_Start_DMA(&hadc1, g_ADCBuffer, 3);

  vTaskStartScheduler();

  return 0;
}
//============================================================================
//		INTERRUPTION CALLBACK ON TIMER PERIOD
//============================================================================
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{

	static BaseType_t xHigherPriorityTaskWoken;

	if (htim->Instance==TIM3)	// Fast Task
	{
		xSemaphoreGiveFromISR( xSemaphore_Fast,&xHigherPriorityTaskWoken );
		portYIELD_FROM_ISR( xHigherPriorityTaskWoken );
	}


	if (htim->Instance==TIM5)
	{
		if (pulse==0)
		{	pulse=potentiometre;}
		else
		{	pulse=0; }
	}

}
//====================================================================
//			INTERRUPT CALLBACK ON CAN RECEIVE
//====================================================================
void can_callback(void)
{
	CAN_Message msg_rcv;
	int i=0;

	can_Read(&msg_rcv);
	txMsg.id=0x55;			// Identifiant du message à envoyer

	for(i=0;i<8;i++)
	{
	txMsg.data[i]=msg_rcv.data[i]+1;
	}
	txMsg.len=8;			// Nombre d'octets à envoyer
	txMsg.format=CANStandard;
	txMsg.type=CANData;

	can_Write(txMsg);
}
//============================================================================
//		INTERRUPTION EXTI --> When we push blue button
//============================================================================
void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
{
	if(GPIO_Pin==GPIO_PIN_13)
	{
	 MC_FOC_Nucleo_Init();
	 first_index_reached=0;
	 MC_FOC_Start_PWM_driving();
	 pwmSetDutyCycle(420,420,420);
	 HAL_GPIO_WritePin(GPIOB,GPIO_PIN_2,GPIO_PIN_SET);//BSP_X_NUCLEO_FAULT_LED_ON();
	 MC_FOC_EnableInputs();
	 __HAL_TIM_ENABLE_IT(&TimHandle_period,TIM_IT_UPDATE); // ??
	 HAL_TIM_OC_Start(&TimHandle_period, TIM_CHANNEL_1);

	}
	else if (GPIO_Pin==GPIO_PIN_10)
	{
	 quadEncoder_CallbackIndexZ();
	}

	else if (GPIO_Pin==GPIO_PIN_4)
	{
		FC1=1;
		FC2=0;//term_printf("FC1\n\r");
	}
	else if (GPIO_Pin==GPIO_PIN_5)
	{
		//term_printf("FC2\n\r");

		FC1=0;
		FC2=1;//term_printf("FC1\n\r");
	}

}
//=================================================================
// Called if stack overflow during execution
extern void vApplicationStackOverflowHook(xTaskHandle *pxTask,
		signed char *pcTaskName)
{
	//term_printf("stack overflow %x %s\r\n", pxTask, (portCHAR *)pcTaskName);
	/* If the parameters have been corrupted then inspect pxCurrentTCB to
	 * identify which task has overflowed its stack.
	 */
	for (;;) {
	}
}
//=================================================================
//This function is called by FreeRTOS idle task
extern void vApplicationIdleHook(void)
{
}
//=================================================================
// brief This function is called by FreeRTOS each tick
extern void vApplicationTickHook(void)
{
//	HAL_IncTick();
}
//================================================================
#ifdef USE_FULL_ASSERT

/**
   * @brief Reports the name of the source file and the source line number
   * where the assert_param error has occurred.
   * @param file: pointer to the source file name
   * @param line: assert_param error line source number
   * @retval None
   */
void assert_failed(uint8_t* file, uint32_t line)
{
  /* USER CODE BEGIN 6 */
  /* User can add his own implementation to report the file name and line number,
    ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
  /* USER CODE END 6 */

}

#endif

/*
 * pwmTimer.h
 *
 *  Created on: 25 oct. 2016
 *      Author: kerhoas
 */

#ifndef INC_PWMTIMER_H_
#define INC_PWMTIMER_H_

#include "main.h"

void pwmTimer_Init(void);

TIM_HandleTypeDef htim1;

#endif /* INC_PWMTIMER_H_ */

/*
 * pwmTimer.c
 *
 *  Created on: 25 oct. 2016
 *      Author: kerhoas
 */


#include "pwmTimer.h"
#include "stm32f4xx_hal.h"

//================================================================
void pwmTimer_Init(void)
{
  TIM_SlaveConfigTypeDef sSlaveConfig;
  TIM_MasterConfigTypeDef sMasterConfig;
  TIM_OC_InitTypeDef sConfigOC;
  TIM_ClearInputConfigTypeDef sClearInputConfig;
  TIM_BreakDeadTimeConfigTypeDef sBreakDeadTimeConfig;

  htim1.Instance = TIM1;
  htim1.Init.Prescaler = 0;
  htim1.Init.CounterMode = TIM_COUNTERMODE_CENTERALIGNED2;//TIM_COUNTERMODE_CENTERALIGNED2;
  htim1.Init.Period = PWM_COUNT_PERIOD-1;
  htim1.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
  htim1.Init.RepetitionCounter = 0;
  HAL_TIM_Base_Init(&htim1);
  HAL_TIM_PWM_Init(&htim1);
  //--------------------------------------------------------
  sSlaveConfig.SlaveMode = TIM_SLAVEMODE_TRIGGER;
  sSlaveConfig.InputTrigger = TIM_TS_ITR3; // TRIGGER FROM TIMER 3
  HAL_TIM_SlaveConfigSynchronization(&htim1, &sSlaveConfig);

  sMasterConfig.MasterOutputTrigger = TIM_TRGO_UPDATE;
  sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_ENABLE;
  HAL_TIMEx_MasterConfigSynchronization(&htim1, &sMasterConfig);

  //------------------------------------------------------------

  sBreakDeadTimeConfig.OffStateRunMode = TIM_OSSR_ENABLE;
  sBreakDeadTimeConfig.OffStateIDLEMode = TIM_OSSI_ENABLE;
  sBreakDeadTimeConfig.LockLevel = TIM_LOCKLEVEL_OFF;
  sBreakDeadTimeConfig.DeadTime = 5;
  sBreakDeadTimeConfig.BreakState = TIM_BREAK_DISABLE;
  sBreakDeadTimeConfig.BreakPolarity = TIM_BREAKPOLARITY_HIGH;
  sBreakDeadTimeConfig.AutomaticOutput = TIM_AUTOMATICOUTPUT_ENABLE;
  HAL_TIMEx_ConfigBreakDeadTime(&htim1, &sBreakDeadTimeConfig);

  //------------------------------------------------------------
  sConfigOC.OCMode = TIM_OCMODE_PWM2; // _PWM1 : Clear on compare match / _PWM2 : Set on compare match
  sConfigOC.Pulse = 0;
  sConfigOC.OCPolarity = TIM_OCPOLARITY_LOW;
  sConfigOC.OCNPolarity = TIM_OCNPOLARITY_LOW;
  sConfigOC.OCFastMode = TIM_OCFAST_DISABLE;
  sConfigOC.OCIdleState = TIM_OCIDLESTATE_RESET;
  sConfigOC.OCNIdleState = TIM_OCNIDLESTATE_RESET;
  HAL_TIM_PWM_ConfigChannel(&htim1, &sConfigOC, TIM_CHANNEL_1);
  HAL_TIM_PWM_ConfigChannel(&htim1, &sConfigOC, TIM_CHANNEL_2);
  HAL_TIM_PWM_ConfigChannel(&htim1, &sConfigOC, TIM_CHANNEL_3);

  sClearInputConfig.ClearInputSource = TIM_CLEARINPUTSOURCE_ETR;
  sClearInputConfig.ClearInputPolarity = TIM_CLEARINPUTPOLARITY_NONINVERTED;
  sClearInputConfig.ClearInputPrescaler = TIM_CLEARINPUTPRESCALER_DIV1;
  sClearInputConfig.ClearInputFilter = 0;
  HAL_TIM_ConfigOCrefClear(&htim1, &sClearInputConfig, TIM_CHANNEL_1);
  HAL_TIM_ConfigOCrefClear(&htim1, &sClearInputConfig, TIM_CHANNEL_2);
  HAL_TIM_ConfigOCrefClear(&htim1, &sClearInputConfig, TIM_CHANNEL_3);
}
//================================================================

/*
 * tickTimer.h
 *
 *  Created on: 30 juin 2016
 *      Author: kerhoas
 */

#ifndef INC_TICKTIMER_H_
#define INC_TICKTIMER_H_

#include "main.h"

void tickTimerInit(uint16_t);



#endif /* INC_TICKTIMER_H_ */

#include "tickTimer.h"
TIM_HandleTypeDef    TimHandle_period;

//================================================
//		TIMER 3 INIT : FAST TRACK UPDATE
//================================================

void tickTimerInit(uint16_t pwm_count_period)
{
  TIM_MasterConfigTypeDef sMasterConfig;
  TIM_OC_InitTypeDef sConfigOC;

  TimHandle_period.Instance = TIM3;
  TimHandle_period.Init.Prescaler = 0;
  TimHandle_period.Init.Period = 2*PWM_COUNT_PERIOD-3;
  TimHandle_period.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
  TimHandle_period.Init.CounterMode = TIM_COUNTERMODE_UP;//TIM_COUNTERMODE_CENTERALIGNED1;
  TimHandle_period.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
  TimHandle_period.Init.RepetitionCounter = 0;
  HAL_TIM_Base_Init(&TimHandle_period);
  HAL_TIM_PWM_Init(&TimHandle_period);

  sMasterConfig.MasterOutputTrigger = TIM_TRGO_OC1;
  sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_ENABLE;
  HAL_TIMEx_MasterConfigSynchronization(&TimHandle_period, &sMasterConfig);

  sConfigOC.OCMode = TIM_OCMODE_PWM1; // TIM_OCMODE_PWM2; ??  PWM1 : Clear on compare match / PWM2 : Set on compare match
  sConfigOC.Pulse =2250;//2250;//2200;//2100;//2000;		// Pour régler le moment de la conversion anlogique --> Numérique
  sConfigOC.OCPolarity = TIM_OCPOLARITY_LOW;
  sConfigOC.OCNPolarity = TIM_OCNPOLARITY_LOW;
  sConfigOC.OCFastMode = TIM_OCFAST_DISABLE;
  sConfigOC.OCIdleState = TIM_OCIDLESTATE_RESET;
  sConfigOC.OCNIdleState = TIM_OCNIDLESTATE_RESET;
  HAL_TIM_PWM_ConfigChannel(&TimHandle_period, &sConfigOC, TIM_CHANNEL_1);
}

//================================================