#define __SDCC__

#include "stdint.h"
#include "stdlib.h"
#include "stdbool.h"
#include "stm8s_gpio.h"
#include "stm8s_tim2.h"
#include "stm8s_tim4.h"
#include "stm8s_clk.h"
#include "stm8s_it.h"
#include "stm8s_exti.h"

#define _BV(x) (1 << x)
 /*

   A
  ___           A - PD1
 |   |          B - PD4        DIG1 - PC7
F| G |B         C - PB4        DIG2 - PA3
 |___|          D - PC5        DIG3 - PD6
 |   |          E - PC6        DIG4 - PC3
E| D |C         F - PD5
 |___|  .       G - PB5
                . - PC4

    0bABCDEFG.
0 - 0b00000011
1 - 0b10011111
2 - 0b00100101
3 - 0b00001101
4 - 0b10011001
5 - 0b01001001
6 - 0b01000001
7 - 0b00011111
8 - 0b00000001
9 - 0b00001001

*/

volatile  uint16_t rpm=0;
volatile static uint16_t current_period=0;
volatile static uint16_t periods[8]={0};
volatile static int16_t sum = 0;
volatile static uint8_t pos = 0;
volatile static bool filled = false;
volatile static bool overflow = false;
volatile  uint32_t average;


void print(uint16_t value){

	volatile static uint8_t led_disp;
	led_disp++;
	if(led_disp>4) led_disp = 1;


	uint8_t digit;

	const uint8_t symbols[10] = {
			0b00000011,
			0b10011111,
			0b00100101,
			0b00001101,
			0b10011001,
			0b01001001,
			0b01000001,
			0b00011111,
			0b00000001,
			0b00001001,
	};


	if(value>9999) value = 9999;

	GPIO_WriteLow(GPIOC, GPIO_PIN_7);
	GPIO_WriteLow(GPIOA, GPIO_PIN_3);
	GPIO_WriteLow(GPIOD, GPIO_PIN_6);
	GPIO_WriteLow(GPIOC, GPIO_PIN_3);


	switch(led_disp){
	case 1:
		digit = (value/1000)%10;
		break;
	case 2:
		digit = (value/100)%10;
		break;
	case 3:
		digit = (value/10)%10;
		break;
	case 4:
		digit = value%10;
		break;
	}


	GPIOD->ODR &= ~(_BV(1)|_BV(4)|_BV(5));
	GPIOB->ODR &= ~(_BV(4)|_BV(5));
	GPIOC->ODR &= ~(_BV(5)|_BV(6)|_BV(4));


	GPIOD->ODR |= ((_BV(7) & symbols[digit]) >> 6) // A - PD1
				| ((_BV(6) & symbols[digit]) >> 2) // B - PD4
				| ((_BV(2) & symbols[digit]) << 3); // F - PD5

	GPIOB->ODR |= ((_BV(5) & symbols[digit]) >> 1) // C - PB4
				| ((_BV(1) & symbols[digit]) << 4); // G - PB5

	GPIOC->ODR |= ((_BV(4) & symbols[digit]) << 1) // D - PC5
				| ((_BV(3) & symbols[digit]) << 3) // E - PC6
				| ((_BV(0) & symbols[digit]) << 4); // . - PC4

//	GPIOD->ODR = (GPIOD->ODR & (~(1<<1))) | (!!((1<<7) & symbols[digit]) << 1); // A - PD1
//	GPIOD->ODR = (GPIOD->ODR & (~(1<<4))) | (!!((1<<6) & symbols[digit]) << 4); // B - PD4
//	GPIOD->ODR = (GPIOD->ODR & (~(1<<5))) | (!!((1<<2) & symbols[digit]) << 5); // F - PD5
//
//	GPIOB->ODR = (GPIOB->ODR & (~(1<<4))) | (!!((1<<5) & symbols[digit]) << 4); // C - PB4
//	GPIOB->ODR = (GPIOB->ODR & (~(1<<5))) | (!!((1<<1) & symbols[digit]) << 5); // G - PB5
//
//	GPIOC->ODR = (GPIOC->ODR & (~(1<<5))) | (!!((1<<4) & symbols[digit]) << 5); // D - PC5
//	GPIOC->ODR = (GPIOC->ODR & (~(1<<6))) | (!!((1<<3) & symbols[digit]) << 6); // E - PC6
//	GPIOC->ODR = (GPIOC->ODR & (~(1<<4))) | (!!((1<<0) & symbols[digit]) << 4); // . - PC4

	switch(led_disp){
	case 1:
		GPIO_WriteHigh(GPIOC, GPIO_PIN_7);
		break;
	case 2:
		GPIO_WriteHigh(GPIOA, GPIO_PIN_3);
		break;
	case 3:
		GPIO_WriteHigh(GPIOD, GPIO_PIN_6);
		break;
	case 4:
		GPIO_WriteHigh(GPIOC, GPIO_PIN_3);
		break;
	}

}
void main(void)
{


	GPIO_Init(GPIOA,
			GPIO_PIN_3,
			GPIO_MODE_OUT_PP_LOW_FAST);

	GPIO_Init(GPIOB,
			GPIO_PIN_4|
			GPIO_PIN_5,
			GPIO_MODE_OUT_PP_LOW_FAST);

	GPIO_Init(GPIOC,
			GPIO_PIN_3|
			GPIO_PIN_4|
			GPIO_PIN_5|
			GPIO_PIN_6|
			GPIO_PIN_7,
			GPIO_MODE_OUT_PP_LOW_FAST);

	GPIO_Init(GPIOD,
			GPIO_PIN_1|
			GPIO_PIN_4|
			GPIO_PIN_5|
			GPIO_PIN_6,
			GPIO_MODE_OUT_PP_LOW_FAST);

	//sensor
	GPIO_Init(GPIOD,
			GPIO_PIN_2,
			GPIO_MODE_IN_PU_IT);
	EXTI_SetExtIntSensitivity(EXTI_PORT_GPIOD,EXTI_SENSITIVITY_FALL_ONLY);

	CLK_ClockSwitchConfig(CLK_SWITCHMODE_AUTO, CLK_SOURCE_HSE, DISABLE, CLK_CURRENTCLOCKSTATE_DISABLE);

	CLK_PeripheralClockConfig(CLK_PERIPHERAL_TIMER4,ENABLE);
	TIM4_ITConfig(TIM4_IT_UPDATE, ENABLE);
	TIM4_TimeBaseInit(TIM4_PRESCALER_128, 255);
	enableInterrupts();
	TIM4_Cmd(ENABLE);

	CLK_PeripheralClockConfig(CLK_PERIPHERAL_TIMER2, ENABLE);
	TIM2_TimeBaseInit(TIM2_PRESCALER_256, 0xFFFF);
	TIM2_ICInit(TIM2_CHANNEL_3, TIM2_ICPOLARITY_FALLING,TIM2_ICSELECTION_DIRECTTI, TIM2_ICPSC_DIV1,0x00);
	TIM2_ITConfig(TIM2_IT_UPDATE, ENABLE);
	TIM2_Cmd(ENABLE);

	while (1) {

		if (overflow) {
			rpm = 0;

		} else {


			rpm =  (uint32_t)(62500 * 60) / average;
		}

		for (uint16_t i = 1; i < 65200; i++) {
			for (uint16_t j = 1; j < 3; j++);
		}

	}

}


INTERRUPT_HANDLER(TIM4_UPD_OVF_IRQHandler, 23)
{
	print(rpm);
	TIM4_ClearITPendingBit(TIM4_IT_UPDATE);
}


INTERRUPT_HANDLER(EXTI_PORTD_IRQHandler, 6)
{
	if(TIM2_GetFlagStatus(TIM2_FLAG_CC3)){
		current_period = TIM2_GetCapture3();


		sum = sum - periods[pos];
		periods[pos] = current_period;
		sum += current_period;

		if(++pos == sizeof(periods)/sizeof(*periods))
		{
			pos = 0;
			filled = true;
		}
		size_t count = filled ? sizeof(periods)/sizeof(*periods) : pos;
		average = (sum < 0 ? sum - count / 2 : sum + count / 2 ) / count;


		TIM2_ClearFlag(TIM2_FLAG_CC3);
		overflow = false;
		TIM2_SetCounter(0);
	}

}

INTERRUPT_HANDLER(TIM2_UPD_OVF_BRK_IRQHandler, 13)
{
	overflow = true;
	TIM2_ClearITPendingBit(TIM2_IT_UPDATE);
}