/**
  ******************************************************************************
  * @file    global.c
  * @author  TMC Scan Team
  * @version V1.0.0
  * @date    09/12/2019
  * @brief
  ******************************************************************************
  *
  * THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
  * WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE
  * TIME. AS A RESULT, TMC SHALL NOT BE HELD LIABLE FOR ANY
  * DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING
  * FROM THE CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE
  * CODING INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
  *
  * <h2><center>&copy; COPYRIGHT 2016 TMC</center></h2>
  ******************************************************************************
**/

#include "global.h"

//全局变量
UART_HandleTypeDef ghuart1;                 //UART全局变量
volatile uint16_t gUartLen = 0x00;          //UART接收数据长度
uint8_t gUartBuff[MAX_RECEIVE_DATA_LEN];                    //UART全局BUF

volatile uint8_t gCommFlag = UART;          //硬件检测判断是UART还是USB，如果进USB中断，则是USB
uint32_t gReturnBLCnt;  //恢复BootLoader计时器
uint32_t gFunTrace=0;


/**
 * @function    ResetChip
 * @brief   复位芯片
 * @param[in]
 * @return
 */
//void ResetChip(void)
void ResetChip(uint8_t entid)
{

	char tmp[20];
	if(entid>9)
	{
		sprintf(tmp,"Fault(%d,%d)\r\n",entid,gFunTrace);
		JJJ_Prompt(tmp);
		Delay_us(500);
	}

	//复位操作
	SCB->AIRCR = 0x05FA0004;
	NVIC_SystemReset();
}

/**
 * @function    TimerDelay
 * @brief   以ms为单位的时间延迟函数
 * @param[in]   TIMx  x取值1~6
 * @param[in]   ms  延时时间
 * @return
 */
void TimerDelay(TIM_TypeDef *TIMx, uint32_t ms)
{
	uint32_t HSIClock = 12000000;
	TIM_TimeInitTypeDef timeBaseInit;

	if(TIMx == TIM1)
	{
		RCC_APB2PeriphClockCmd(RCC_APB2Periph_TIMER1_2, ENABLE);
		RCC_TimerClockConfig(PERIPHERAL_TIMER1, RCC_TIMER_CLKSRC_HSI, HSIClock / 2000000 - 1, ENABLE);
	}
	else if(TIMx == TIM2)
	{
		RCC_APB2PeriphClockCmd(RCC_APB2Periph_TIMER1_2, ENABLE);
		RCC_TimerClockConfig(PERIPHERAL_TIMER2, RCC_TIMER_CLKSRC_HSI, HSIClock / 2000000 - 1, ENABLE);
	}
	else if(TIMx == TIM3)
	{
		RCC_APB3PeriphClockCmd(RCC_APB3Periph_TIMER3_4, ENABLE);
		RCC_TimerClockConfig(PERIPHERAL_TIMER3, RCC_TIMER_CLKSRC_HSI, HSIClock / 2000000 - 1, ENABLE);
	}
	else if(TIMx == TIM4)
	{
		RCC_APB3PeriphClockCmd(RCC_APB3Periph_TIMER3_4, ENABLE);
		RCC_TimerClockConfig(PERIPHERAL_TIMER4, RCC_TIMER_CLKSRC_HSI, HSIClock / 2000000 - 1, ENABLE);
	}
	else if(TIMx == TIM5)
	{
		RCC_APB2PeriphClockCmd(RCC_APB2Periph_TIMER5_6, ENABLE);
		RCC_TimerClockConfig(PERIPHERAL_TIMER5, RCC_TIMER_CLKSRC_HSI, HSIClock / 2000000 - 1, ENABLE);
	}
	else
	{
		RCC_APB2PeriphClockCmd(RCC_APB2Periph_TIMER5_6, ENABLE);
		RCC_TimerClockConfig(PERIPHERAL_TIMER6, RCC_TIMER_CLKSRC_HSI, HSIClock / 2000000 - 1, ENABLE);
	}

	timeBaseInit.TIM_CounterMode = TIM_MODE_CONTINUITY_RELOAD;
	timeBaseInit.TIM_Presclar = TIM_PRESCLAR_NOT_DIV;
	timeBaseInit.TIM_SizeMode = TIM_SIZE_32BIT;
	TIM_TimeInit(TIMx, &timeBaseInit);
	TIM_SetLoadValue(TIMx, 2000 * ms);
	TIM_Cmd(TIMx, ENABLE);

	while(!TIM_GetFlagStatus(TIMx));

	TIM_ClearFlag(TIMx);
	TIM_Cmd(TIMx, DISABLE);
}

/**
 * @function   TimerHSIClockCount
 * @brief       timer count HSI clock cycles
 * @param[in]   TIMx  x取值1~6
 * @param[in]  controlType
 *        @arg START_TIMER
 *        @arg GET_TIMER
 *        @arg STOP_TIMER
 * @return      when controlType=GET_TIMER,return HSI clock cycles, others return 0.
 */
uint32_t TimerHSIClockCount(TIM_TypeDef *TIMx, uint8_t controlType)
{
	TIM_TimeInitTypeDef timeBaseInit;

	if(controlType == START_TIMER)
	{
		if(TIMx == TIM1)
		{
			RCC_APB2PeriphClockCmd(RCC_APB2Periph_TIMER1_2, ENABLE);
			RCC_TimerClockConfig(PERIPHERAL_TIMER1, RCC_TIMER_CLKSRC_HSI, 31, ENABLE);
		}
		else if(TIMx == TIM2)
		{
			RCC_APB2PeriphClockCmd(RCC_APB2Periph_TIMER1_2, ENABLE);
			RCC_TimerClockConfig(PERIPHERAL_TIMER2, RCC_TIMER_CLKSRC_HSI, 31, ENABLE);
		}
		else if(TIMx == TIM3)
		{
			RCC_APB3PeriphClockCmd(RCC_APB3Periph_TIMER3_4, ENABLE);
			RCC_TimerClockConfig(PERIPHERAL_TIMER3, RCC_TIMER_CLKSRC_HSI, 31, ENABLE);
		}
		else if(TIMx == TIM4)
		{
			RCC_APB3PeriphClockCmd(RCC_APB3Periph_TIMER3_4, ENABLE);
			RCC_TimerClockConfig(PERIPHERAL_TIMER4, RCC_TIMER_CLKSRC_HSI, 31, ENABLE);
		}
		else if(TIMx == TIM5)
		{
			RCC_APB2PeriphClockCmd(RCC_APB2Periph_TIMER5_6, ENABLE);
			RCC_TimerClockConfig(PERIPHERAL_TIMER5, RCC_TIMER_CLKSRC_HSI, 31, ENABLE);
		}
		else
		{
			RCC_APB2PeriphClockCmd(RCC_APB2Periph_TIMER5_6, ENABLE);
			RCC_TimerClockConfig(PERIPHERAL_TIMER6, RCC_TIMER_CLKSRC_HSI, 31, ENABLE);
		}

		timeBaseInit.TIM_CounterMode = TIM_MODE_CONTINUITY_RELOAD;
		timeBaseInit.TIM_Presclar = TIM_PRESCLAR_NOT_DIV;
		timeBaseInit.TIM_SizeMode = TIM_SIZE_32BIT;
		TIM_TimeInit(TIMx, &timeBaseInit);
		TIM_SetLoadValue(TIMx, 0xffffffff);
		TIM_Cmd(TIMx, ENABLE);
	}
	else if(controlType == GET_TIMER)
	{
		return ((0xFFFFFFFF - TIMx->VALUE) << 5);
	}
	else if(controlType == STOP_TIMER)
	{
		TIM_Cmd(TIMx, DISABLE);
	}
	else
	{}

	return 0;
}

//TIME 中断
/** 
 * @function    AppTIMxInterrupt
 * @brief       定时器TIMx中断初始化
 * @param[in]   ms   定时中断时间
 * @return      无
 */
void AppTIMxInterrupt(TIM_TypeDef *TIMx, uint32_t ms)
{
    uint32_t HSIClock = 12000000;
	TIM_TimeInitTypeDef TimerInterInit;
    
	if(TIMx == TIM1)
	{
		RCC_APB2PeriphClockCmd(RCC_APB2Periph_TIMER1_2, ENABLE);
		RCC_TimerClockConfig(PERIPHERAL_TIMER1, RCC_TIMER_CLKSRC_HSI, HSIClock/2000000-1, ENABLE);
	}
	else if(TIMx == TIM2)
	{
		RCC_APB2PeriphClockCmd(RCC_APB2Periph_TIMER1_2, ENABLE);
		RCC_TimerClockConfig(PERIPHERAL_TIMER2, RCC_TIMER_CLKSRC_HSI, HSIClock/2000000-1, ENABLE);
	}	
	else if(TIMx == TIM3)
	{
		RCC_APB3PeriphClockCmd(RCC_APB3Periph_TIMER3_4, ENABLE);
		RCC_TimerClockConfig(PERIPHERAL_TIMER3, RCC_TIMER_CLKSRC_HSI, HSIClock/2000000-1, ENABLE);
	}
	else if(TIMx == TIM4)
	{
		RCC_APB3PeriphClockCmd(RCC_APB3Periph_TIMER3_4, ENABLE);
		RCC_TimerClockConfig(PERIPHERAL_TIMER4, RCC_TIMER_CLKSRC_HSI, HSIClock/2000000-1, ENABLE);
	}
	else if(TIMx == TIM5)
	{
		RCC_APB2PeriphClockCmd(RCC_APB2Periph_TIMER5_6, ENABLE);
		RCC_TimerClockConfig(PERIPHERAL_TIMER5, RCC_TIMER_CLKSRC_HSI, HSIClock/2000000-1, ENABLE);
	}
	else
	{
		RCC_APB2PeriphClockCmd(RCC_APB2Periph_TIMER5_6, ENABLE);
		RCC_TimerClockConfig(PERIPHERAL_TIMER6, RCC_TIMER_CLKSRC_HSI, HSIClock/2000000-1, ENABLE);
	}
    
    TimerInterInit.TIM_CounterMode = TIM_MODE_CONTINUITY_RELOAD;
    TimerInterInit.TIM_Presclar = TIM_PRESCLAR_NOT_DIV;
    TimerInterInit.TIM_SizeMode = TIM_SIZE_32BIT;   
    TIM_TimeInit(TIMx, &TimerInterInit);   
    
    TIM_SetLoadValue(TIMx, 2000*ms);
    
	//使能中断
	if(TIMx == TIM1)
	{
		NVIC_ClearPendingIRQ(TIMER1_IRQn);
		NVIC_EnableIRQ(TIMER1_IRQn);
	}
	else if(TIMx == TIM2)
	{
		NVIC_ClearPendingIRQ(TIMER2_IRQn);
		NVIC_EnableIRQ(TIMER2_IRQn);
	}	
	else if(TIMx == TIM3)
	{
		NVIC_ClearPendingIRQ(TIMER3_IRQn);
		NVIC_EnableIRQ(TIMER3_IRQn);
	}
	else if(TIMx == TIM4)
	{
		NVIC_ClearPendingIRQ(TIMER4_IRQn);
		NVIC_EnableIRQ(TIMER4_IRQn);
	}
	else if(TIMx == TIM5)
	{
		NVIC_ClearPendingIRQ(TIMER5_IRQn);
		NVIC_EnableIRQ(TIMER5_IRQn);
	}
	else
	{
		NVIC_ClearPendingIRQ(TIMER6_IRQn);
		NVIC_EnableIRQ(TIMER6_IRQn);   	
	}
	
	//开始计时
	TIM_ITConfig(TIMx, ENABLE);
	TIM_Cmd(TIMx, ENABLE);	
}

/**
 * @function    Memcmp
 * @brief       比较两个数组是否相等
 * @param[in]   pchDest    指针指向目标数组
 * @param[in]   pchSrc     指针指向源数组
 * @param[in]   bLen       数组长度
 * @return      数组是否相等，是返回TRUE,否返回FALSE
 */
uint8_t Memcmp(uint8_t *pchDest, uint8_t *pchSrc, uint16_t bLen)
{
	uint16_t i;

	for(i = 0; i < bLen; i++)
	{
		if(pchDest[i] != pchSrc[i])
		{
			return FALSE;
		}
	}

	return TRUE;
}

/**
 * @function   Memcpy
 * @brief      memory copy
 * @param[in]   *dst :point destination address
 * @param[in]   *src :point source address
 * @param[in]   len :length to be copyed, unit byte
 * @return
 */
void Memcpy(uint8_t *dst, uint8_t *src, uint16_t len)
{
	memcpy(dst, src, len);
}

/**
 * @function   Delay
 * @brief      计数循环延时
 * @param[in]  n 延时数量
 * @return
 */
void Delay(u32 n)
{
	u32 i;

	for(i = 0; i < n; i++)
	{;}
}

/**
 * @function   NOP
 * @brief
 * @param[in]
 * @return
 */
__asm void NOP(void)
{
	nop
	BX lr
	nop
}