#include <stm32f4xx.

h>

//ALL the variables have been defined here

static int i = 0;int bit =0;int speed =0;int res =0;

// refernce and pid related constants

int ref_speed = 120;float duty =0;int iteration_time =0;

//errors variables
float previous_error = 0;float current_error = 0;

// variables for the pid function that is actually not a function

float KP = 0.1;int KI = 10;int KD = 1;

// some extra variables working as temporary storage

int input = 0;int integration_sum = 0;

// To Get Current Count

int GETVAL(void){
return SysTick->VAL;
}

// To account for Multiple Cycles of Timer

// for more than the period of the timer
void SysTick_Handler(void)
{
i++;
}

// Timer Start Function

// when called the timer starts counting
void Timer_start_func(void){
SysTick->LOAD = 168000 - 1; /* set reload
register */
NVIC_SetPriority (SysTick_IRQn, (1<<__NVIC_PRIO_BITS) - 1); /* set
Priority for Systick Interrupt */
SysTick->VAL = 0; /* Load the
SysTick Counter Value */
SysTick->CTRL = SysTick_CTRL_CLKSOURCE_Msk |
SysTick_CTRL_TICKINT_Msk |
SysTick_CTRL_ENABLE_Msk;
}

// Timer Count End Function

// when called the timer stops counting
void Timer_end_func(void){
SysTick->CTRL = 0;
i=0;
}

// Timer configurations done here

// initialization of timer related gpios also done here
static void Timer_configuration()
{
GPIO_InitTypeDef GPIO_InitStructure;
TIM_TimeBaseInitTypeDef TIM_TimeBaseStructure;
 TIM_OCInitTypeDef TIM_OCInitStructure;
uint16_t TimerPeriod = 0;
uint16_t Channel1Pulse = 0;

/* GPIOA Configuration*/
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_8;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
GPIO_Init(GPIOA, &GPIO_InitStructure);

GPIO_PinAFConfig(GPIOA, GPIO_PinSource8, GPIO_AF_TIM1);

/* TIM1 Configuration
* TIM1 input clock (TIM1CLK) is set to APB2 clock (PCLK2)
* => TIM1CLK = PCLK2 = SystemCoreClock
* TIM1CLK = SystemCoreClock, Prescaler = 0, TIM1 counter clock = SystemCoreClock
* SystemCoreClock is set to 168 MHz for STM32F30x devices
* TIM1_Period = (SystemCoreClock / 17570) - 1

* The Timer pulse is calculated as follows:

- ChannelxPulse = DutyCycle * (TIM1_Period - 1) / 100
*/

// Compute the value to be set in ARR register to generate signal frequency at 50

Hz
// was changed to 117
TimerPeriod = (SystemCoreClock / 117 ) - 1;
// Compute CCR1 value to generate a duty cycle at 100% for channel 1 and 1N
Channel1Pulse = (uint16_t) (((uint32_t) 1* (TimerPeriod - 1)) / 1);

/* TIM1 clock enable */

RCC_APB2PeriphClockCmd(RCC_APB2Periph_TIM1 , ENABLE);

/* Time Base configuration */

TIM_TimeBaseStructure.TIM_Prescaler = 0;
TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;
TIM_TimeBaseStructure.TIM_Period = TimerPeriod;
TIM_TimeBaseStructure.TIM_ClockDivision = 0;
TIM_TimeBaseStructure.TIM_RepetitionCounter = 0;

TIM_TimeBaseInit(TIM1, &TIM_TimeBaseStructure);

/* Channel 1, 2,3 and 4 Configuration in PWM mode */

TIM_OCInitStructure.TIM_OCMode = TIM_OCMode_PWM2;
TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;
TIM_OCInitStructure.TIM_OutputNState = TIM_OutputNState_Enable;
TIM_OCInitStructure.TIM_Pulse = Channel1Pulse;
TIM_OCInitStructure.TIM_OCPolarity = TIM_OCPolarity_Low;
TIM_OCInitStructure.TIM_OCNPolarity = TIM_OCNPolarity_High;
TIM_OCInitStructure.TIM_OCIdleState = TIM_OCIdleState_Set;
TIM_OCInitStructure.TIM_OCNIdleState = TIM_OCIdleState_Reset;

TIM_OC1Init(TIM1, &TIM_OCInitStructure);

/* TIM1 counter enable */

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

int main()
{
// Initializations of GPIO Modules
// GPIOE8 for LED
// GPIOA1 for Input Pin
GPIO_InitTypeDef gpio;
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA, ENABLE );

// Setting
Properties of Pins
// PinE8 is
for Identification of Completion of Revolution
//
GPIO_StructInit( &gpio );
//
gpio.GPIO_Mode = GPIO_Mode_OUT;
//
gpio.GPIO_Pin = GPIO_Pin_8;
//
GPIO_Init( GPIOE, &gpio );
// PinA1 is for Input speed
GPIO_StructInit( &gpio );
gpio.GPIO_Mode = GPIO_Mode_IN;
gpio.GPIO_Pin = GPIO_Pin_1;
GPIO_Init( GPIOA, &gpio );
GPIO_StructInit( &gpio );

Timer_configuration();

///////////////////////////////////////////////////////////////////////////////
//////////////////////////
///////////////////////////////////////////////////////////////////////////////
//////////////////////////
///////////////////////////////////////////////////////////////////////////////
//////////////////////////
///////////////////////////////////////////////////////////////////////////////
//////////////////////////
//************************************The main code starts
here****************************************//
///////////////////////////////////////////////////////////////////////////////
//////////////////////////
///////////////////////////////////////////////////////////////////////////////
//////////////////////////
///////////////////////////////////////////////////////////////////////////////
//////////////////////////
///////////////////////////////////////////////////////////////////////////////
//////////////////////////
Timer_start_func(); //

while(1)
{
// reads the current state of PA1
// default function used
 if ( GPIO_ReadInputDataBit(GPIOA, GPIO_Pin_1) == Bit_RESET){
while(GPIO_ReadInputDataBit(GPIOA, GPIO_Pin_1) == Bit_RESET){}

if (res==0){
// res here is a flag to see whether to start counter or to stop
it
Timer_start_func();
res=1;
} else if (res==1){

iteration_time = (1 - GETVAL()/168000) + i; //DOWN Counter 168000

to 0 Thats why we subtract

// this formula comes as

// time between on slit = iteration_time
// time for 20 slits = 20 * iteration_time
// for 1 time = 1/20*iteration time
// for one minute = 60000/20*iteration_time

speed = 3000/iteration_time;

// timer end function as we have seen the second high pulse

Timer_end_func();

// to remove certain high level debouncing values

if (speed < 3000) {
input = speed;
}

//******************************************///
//PId has been implemented here
//PID constants are
// KP =0.1 Kd = 1 KI =10
// input to the pid setup is the current_error
current_error = ref_speed - input;
integration_sum += (current_error * iteration_time);
duty = KP * current_error + KI * integration_sum + KD * 1000 *
(current_error -previous_error)/iteration_time;

// directly loaded to the current compare register value instead

of using the funtion for
// PWM to speed up the iteration tim intervals
TIM1->CCR1 = duty;

// to keep a track of the previous error

previous_error = current_error;

//*******************************************///
res=0;

}
}
}
}