void OSProbe_TmrInit (void)
{
TIM_TimeBaseInitTypeDef tim_init;
tim_init.TIM_Period = 0xFFFF;
tim_init.TIM_Prescaler = 256;
tim_init.TIM_ClockDivision = TIM_CKD_DIV4;
tim_init.TIM_CounterMode = TIM_CounterMode_Up;
#if (OS_PROBE_TIMER_SEL == 2)
RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2, ENABLE);
TIM_TimeBaseInit(TIM2, &tim_init);
TIM_SetCounter(TIM2, 0);
TIM_PrescalerConfig(TIM2, 256, TIM_PSCReloadMode_Immediate);
TIM_Cmd(TIM2, ENABLE);
#elif (OS_PROBE_TIMER_SEL == 3)
RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM3, ENABLE);
TIM_TimeBaseInit(TIM3, &tim_init);
TIM_SetCounter(TIM3, 0);
TIM_PrescalerConfig(TIM3, 256, TIM_PSCReloadMode_Immediate);
TIM_Cmd(TIM3, ENABLE);
#elif (OS_PROBE_TIMER_SEL == 4)
RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM4, ENABLE);
TIM_TimeBaseInit(TIM4, &tim_init);
TIM_SetCounter(TIM4, 0);
TIM_PrescalerConfig(TIM4, 256, TIM_PSCReloadMode_Immediate);
TIM_Cmd(TIM4, ENABLE);
#endif
}
void setStatusLED(Led_status status)
{
current_led_status = status;
switch(status){
case SYSTEM_LED_ALLWAYS_OFF:
TIM_Cmd(TIM3, DISABLE);
TIM_ForcedOC2Config(TIM3, TIM_ForcedAction_InActive);
break;
case SYSTEM_LED_ALLWAYS_ON:
TIM_Cmd(TIM3, DISABLE);
TIM_ForcedOC2Config(TIM3, TIM_ForcedAction_Active);
break;
case SYSTEM_LED_TWINKLE_EASYLINK:
TIM_OC2Init(TIM3, &TIM_OCInitStructure);
TIM_SetCounter(TIM3, 0);
TIM_Cmd(TIM3, ENABLE);
break;
case SYSTEM_LED_TWINKLE_WPS:
TIM_OC2Init(TIM3, &TIM_OCInitStructure);
TIM_SetCounter(TIM3, 0);
TIM_Cmd(TIM3, ENABLE);
break;
default:
TIM_Cmd(TIM3, DISABLE);
TIM_ForcedOC2Config(TIM3, TIM_ForcedAction_InActive);
break;
}
}
// Updating encoder value
void TIM8_UP_TIM13_IRQHandler(void)
{
if (TIM_GetITStatus(TIM8, TIM_IT_Update) == SET) {
#ifdef ENCODERS_HAVE_QUADRATURE
// Specific operations have to be done to read encoder's value has negative
// when moving backward
uint16_t left_counter = TIM1->CNT;
int16_t left_encoder_diff = *(int16_t *)(&left_counter);
uint16_t right_counter = TIM3->CNT;
int16_t right_encoder_diff = -*(int16_t *)(&right_counter);
#else
// Reading encoder value
int32_t left_encoder_diff = TIM3->CNT;
int32_t right_encoder_diff = TIM1->CNT;
// If a motor is moving backward, its encoder value
// is read as a negative number
if (!motors_wrapper_left_motor_is_moving_forward()) {
left_encoder_diff = -left_encoder_diff;
}
if (!motors_wrapper_right_motor_is_moving_forward()) {
right_encoder_diff = -right_encoder_diff;
}
#endif
// Updating position
position_update(left_encoder_diff, right_encoder_diff);
// Resetting encoders value
TIM_SetCounter(TIM1, 0);
TIM_SetCounter(TIM3, 0);
TIM_ClearFlag(TIM8, TIM_FLAG_Update);
}
}
// @brief : Called from TIM5_IRQHandler, whenever TIM5 CH1 generates an interrupt
// or TIM5 generates an update. This function serves two purposes. Firstly,
// it will be used to debounce the switch after it is pressed or released
// (interrupt). Secondly, it is used to notify the user of the maximum hold
// time (update). This is part 2 of the switch service routine.
// @param : none
// @retval: none
void SWService2 (void) {
if (TIM_GetITStatus(TIM_SWITCH, TIM_IT_CC1) != RESET) {
TIM_ClearITPendingBit(TIM_SWITCH, TIM_IT_CC1);
if (SWstate == SW_DEBOUNCE_HIGH) { // previous state is debounce_high.
if (USER_SW) { // SW debounced and remained high (PRESSED / HELD)
SWstate = SW_HIGH;
SWstatus = SW_PRESS;
TIM_SetCompare2(TIM_SWITCH, sw_hold_time[SWstatus]);
bSWFlag = TRUE;
}
else { // SW debounced and went low (RELEASED)
SWstate = SW_DEBOUNCE_LOW;
TIM_SetCounter(TIM_SWITCH, 0); // TIM5->CNT = 0;
}
}
else if (SWstate == SW_DEBOUNCE_LOW) { // previous state is debounce_low
SWstate = SW_LOW;
TIM_Cmd(TIM_SWITCH, DISABLE); // Disabling timer DOESN'T reset the counter
TIM_SetCounter(TIM_SWITCH, 0);
}
}
else if (TIM_GetITStatus(TIM_SWITCH, TIM_IT_CC2) != RESET) {
TIM_ClearITPendingBit(TIM_SWITCH, TIM_IT_CC2);
SWstatus++;
TIM_SetCompare2(TIM_SWITCH, sw_hold_time[SWstatus]);
DispBlink();
}
}
void toPhone_modulate(uint8_t b)
{
volatile int tcnt,cnt;
if(b){
cnt = SOFT_MODEM_HIGH_CNT;
tcnt = SOFT_MODEM_HIGH_USEC / 2;
}else{
cnt = SOFT_MODEM_LOW_CNT;
tcnt = SOFT_MODEM_LOW_USEC / 2;
}
do {
cnt--;
{
Tim3_flg = 0;
TIM_SetCounter(TIM3, tcnt);
while(!Tim3_flg);
}
GPIO_WriteBit(GPIOB, GPIO_Pin_5, (BitAction)((1-GPIO_ReadOutputDataBit(GPIOB,GPIO_Pin_5))));
{
Tim3_flg = 0;
TIM_SetCounter(TIM3, tcnt);
while(!Tim3_flg);
}
GPIO_WriteBit(GPIOB, GPIO_Pin_5, (BitAction)((1-GPIO_ReadOutputDataBit(GPIOB,GPIO_Pin_5))));
} while (cnt);
GPIO_WriteBit(GPIOB, GPIO_Pin_5,0);
}
void encoderCalculate(int32_t encoder_ml, int32_t encoder_mr)
{
encoder_ml = TIM_GetCounter(ENCODER_M1_TIM) - 0x7FFF;
TIM_SetCounter(ENCODER_M1_TIM, 0x7FFF);
encoder_mr = TIM_GetCounter(ENCODER_M2_TIM) - 0x7FFF;
TIM_SetCounter(ENCODER_M2_TIM, 0x7FFF);
}
/* FIXME: Need to Change IrDA Tx process to match 38khz receiver */
void SweepRobot_IrDACodeTxProc(u8 code)
{
plat_int_reg_cb(STM32F4xx_INT_TIM7, SweepRobot_IrDACodeTxProc);
switch(gIrDACodeTxSeqNum) {
case 0:
gIrDACodeTxSeqNum++;
gIrDACodeTxSeqTime = 3000;
SweepRobot_IrDATestGPIOPINSet();
break;
case 1:
gIrDACodeTxSeqNum++;
gIrDACodeTxSeqTime = 1000;
SweepRobot_IrDATestGPIOPINReset();
break;
case 2:
gIrDACodeTxCnt++;
gIrDACodeTxSeqNum++;
gIrDACodeTxSeqTime = (code & 0x80)?800:1600;
SweepRobot_IrDATestGPIOPINSet();
break;
case 3:
if(gIrDACodeTxCnt != 8) {
gIrDACodeTxSeqNum--;
} else {
gIrDACodeTxSeqNum++;
}
gIrDACodeTxSeqTime = (code & 0x80)?1600:800;
SweepRobot_IrDATestGPIOPINReset();
code <<= 1;
break;
case 4:
gIrDACodeTxSeqNum++;
gIrDACodeTxSeqTime = 500;
SweepRobot_IrDATestGPIOPINSet();
break;
case 5:
gIrDACodeTxCnt = 0;
gIrDACodeTxSeqNum = 0;
TIM_SetCounter(IRDA_TEST_TX_TIM, 0);
TIM_ITConfig(IRDA_TEST_TX_TIM, TIM_IT_Update, DISABLE);
TIM_Cmd(IRDA_TEST_TX_TIM, DISABLE);
plat_int_dereg_cb(STM32F4xx_INT_TIM7);
SweepRobot_IrDATestGPIOPINReset();
return;
default:
break;
}
TIM_SetCounter(IRDA_TEST_TX_TIM, 0);
TIM_ITConfig(IRDA_TEST_TX_TIM, TIM_IT_Update, DISABLE);
TIM_SetAutoreload(IRDA_TEST_TX_TIM, gIrDACodeTxSeqTime);
TIM_ClearFlag(IRDA_TEST_TX_TIM, TIM_FLAG_Update);
TIM_ITConfig(IRDA_TEST_TX_TIM, TIM_IT_Update, ENABLE);
TIM_Cmd(IRDA_TEST_TX_TIM, ENABLE);
}
void TIM3_IRQHandler(void)
{
/* Clear the interrupt pending flag */
if(TIM_GetITStatus(TIM3, TIM_IT_Update) != RESET)
{
Error_times += 1;
TIM_SetCounter(TIM2, 0);
TIM_SetCounter(TIM3, 30000);
TIM_SetCounter(TIM4, 30000);
TIM_ClearFlag(TIM3, TIM_FLAG_Update);
}
}
void
bsp_timer_start(void)
{
// 根据波特率设置延时时间
uint32_t baud_timertick = 0xffffffff;
TIM_TimeBaseInitTypeDef TIM_TimeBaseStructure;
RCC->APB1ENR |= RCC_APB1Periph_TIM2;
//重新将Timer设置为缺省值
TIM_DeInit(TIM2);
//采用内部时钟给TIM2提供时钟源
//TIM_InternalClockConfig(TIM2);
TIM_TimeBaseStructure.TIM_Prescaler = 59;
//设置时钟分割
TIM_TimeBaseStructure.TIM_ClockDivision = TIM_CKD_DIV1;
//设置计数器模式为向上计数模式
TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;
//设置计数溢出大小，每计x个数就产生一个更新事件
TIM_TimeBaseStructure.TIM_Period = baud_timertick;
//将配置应用到TIM2中
TIM_TimeBaseInit(TIM2, &TIM_TimeBaseStructure);
//清除溢出中断标志
TIM_ClearFlag(TIM2, TIM_FLAG_Update);
//禁止ARR预装载缓冲器
//TIM_ARRPreloadConfig(TIM2, DISABLE);
//开启TIM2的中断
// TIM_ITConfig(TIM2, TIM_IT_Update, ENABLE);
/* TIM2 counter enable */
TIM_Cmd(TIM2, ENABLE);
TIM_SetCounter(TIM2, 0);
}
void vPTOConfig(void)
{
u8 i;
/*根据宏定义进行加减速中间量计算*/
for(i = 0; i < 50; i++)
{
MotorCycle_Buf[i] = 100000 / (ACC_HZ_MIN * (i + 1));
}
for(i = 0; i < 50; i++)
{
PulseNum_Buf[i] = (ACC_PERIOD * 100)/ MotorCycle_Buf[i];
}
PulseNum_Sum_Buf[0] = PulseNum_Buf[0];
for(i = 1; i < 50; i++)
{
PulseNum_Sum_Buf[i] = PulseNum_Sum_Buf[i-1] + PulseNum_Buf[i];
}
MotorCycleReal = 0;
PulseNum_Global = 0;
Motor_Init(100, 100, 50);
TIM_SetCounter(TIM1, 0);
}
void SensorPlus_caculateSpeed (void)
{
u16 plus_reg=0;
plus_reg=TIM2->CNT;
TIM_SetCounter(TIM2, 0);
Delta_1s_Plus=plus_reg;
#if 1
total_plus+=plus_reg;
if(Spd_senor_Null==0)
// Speed_cacu=(Delta_1s_Plus*36000)/JT808Conf_struct.Vech_Character_Value; // 计算的速度
Speed_cacu=Delta_1s_Plus; // 计算的速度 0.1km/h 400HZ==40KM/H
else
{
Speed_cacu=0;
Speed_gps=0; // GPS 也搞成 0
}
if(DispContent==4) // disp 显示
{
if(DF_K_adjustState)
rt_kprintf("\r\n 自动校准完成!");
else
rt_kprintf("\r\n 尚未自动校准校准!");
rt_kprintf("\r\n GPS速度=%d , 传感器速度=%d 上报速度: %d \r\n",Speed_gps,Speed_cacu,GPS_speed);
rt_kprintf("\r\n GPS实际速度=%d km/h , 传感器实际速度=%d km/h 上报实际速度: %d km/h\r\n",Speed_gps/10,Speed_cacu/10,GPS_speed/10);
rt_kprintf("\r\n TIM2->CNT=%d \r\n",plus_reg);
}
#endif
}
/**********************************************************************
* 名 称：EXTI9_5_IRQHandler()
* 功 能：外部中断通道5中断
* 入口参数：
* 出口参数：
***********************************************************************/
void EXTI9_5_IRQHandler (void)
{
OSIntEnter();
if(EXTI_GetITStatus(EXTI_Line5) != RESET)
{
if(SONICDEVICE.step == 1)
{
TIM_SetCounter(TIM6,0);
TIM_Cmd(TIM6, ENABLE);
SONICDEVICE.step = 2;
}
else if(SONICDEVICE.step == 2)
{
SONICDEVICE.databuff[SONICDEVICE.nextindex] = TIM_GetCounter(TIM6);
if(SONICDEVICE.nextindex == 9)
{
SONICDEVICE.nextindex = 0;
}
else
{
SONICDEVICE.nextindex ++;
}
TIM_Cmd(TIM6, DISABLE);
SONICDEVICE.step = 0;
}
EXTI_ClearFlag(EXTI_Line5); //清除中断标志（必须）
EXTI_ClearITPendingBit(EXTI_Line5);
}
OSIntExit();
}
void startTimer(void)
{
/*
* Timer obslugujacy LED
* Im szybciej piszemy, tym wiecej jest zapalonych
* klawiszy LED
*/
if (TIM_GetCounter(TIM3) > 0x00)
{
if (GPIO_ReadInputDataBit(GPIOD, GPIO_Pin_14))
{
GPIO_SetBits(GPIOD, GPIO_Pin_15);
} else if (GPIO_ReadInputDataBit(GPIOD, GPIO_Pin_13))
{
GPIO_SetBits(GPIOD, GPIO_Pin_14);
} else if (GPIO_ReadInputDataBit(GPIOD, GPIO_Pin_12))
{
GPIO_SetBits(GPIOD, GPIO_Pin_13);
}
TIM_SetCounter(TIM3, 0x00);
} else
{
TIM_Cmd(TIM3, ENABLE);
GPIO_SetBits(GPIOD, GPIO_Pin_12);
}
}
void TIM8_Encoder_Init()
{
RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOC, ENABLE);
RCC_APB2PeriphClockCmd(RCC_APB2Periph_TIM8, ENABLE);
TIM_DeInit(TIM8);
TIM_TimeBaseInitTypeDef TIM_TimeBaseStructure;
TIM_ICInitTypeDef TIM_ICInitStructure;
TIM_TimeBaseStructure.TIM_Prescaler = 0;
TIM_TimeBaseStructure.TIM_Period = 0xFFFFFFFF; // Max value for encoder pulse
TIM_TimeBaseStructure.TIM_ClockDivision = 0;
TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;
TIM_TimeBaseInit(TIM8, &TIM_TimeBaseStructure);
TIM_EncoderInterfaceConfig(TIM8, TIM_EncoderMode_TI12, TIM_ICPolarity_Rising, TIM_ICPolarity_Rising);
TIM_ICStructInit(&TIM_ICInitStructure);
TIM_ICInitStructure.TIM_ICFilter = 0;
TIM_ICInit(TIM8, &TIM_ICInitStructure);
// TIM_SetAutoreload(TIM2, 0xFFFF);
TIM_SetCounter(TIM8, 0);
TIM_Cmd(TIM8, ENABLE);
GPIO_InitTypeDef GPIO_InitStruct;
GPIO_InitStruct.GPIO_Pin = GPIO_Pin_6 | GPIO_Pin_7;
GPIO_InitStruct.GPIO_Mode = GPIO_Mode_AF;
GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStruct.GPIO_OType = GPIO_OType_PP;
GPIO_InitStruct.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIO_Init(GPIOC, &GPIO_InitStruct);
GPIO_PinAFConfig(GPIOC, GPIO_PinSource6, GPIO_AF_4);
GPIO_PinAFConfig(GPIOC, GPIO_PinSource7, GPIO_AF_4);
}
void IR_Enable(void)
{
TIM_ITConfig(TIM3,TIM_IT_CC3,ENABLE);
TIM_SetCounter(TIM3,0);
TIM_Cmd(TIM3,ENABLE);
TIM_ClearITPendingBit(TIM3,TIM_IT_CC3);
}
void ausbee_encoder_init_timer(TIM_TypeDef *TIMX, uint8_t use_encoder_quadrature)
{
if (use_encoder_quadrature)
{
// Set them up as encoder inputs
// Set both inputs to rising polarity to let it use both edges
TIM_EncoderInterfaceConfig(TIMX, TIM_EncoderMode_TI12, TIM_ICPolarity_Rising, TIM_ICPolarity_Rising);
TIM_SetAutoreload(TIMX, 0xffff);
// Turn on the timer/counters
TIM_Cmd(TIMX, ENABLE);
}
else
{
TIM_TimeBaseInitTypeDef timeBaseInitTypeDef;
TIM_TimeBaseStructInit(&timeBaseInitTypeDef);
timeBaseInitTypeDef.TIM_Period = 0xFFFF;
TIM_TimeBaseInit(TIMX, &timeBaseInitTypeDef);
TIM_TIxExternalClockConfig(TIMX, TIM_TS_TI1FP1, TIM_ICPolarity_Rising, 0x0);
TIM_Cmd(TIMX, ENABLE);
}
// Reset of the timer counter
TIM_SetCounter(TIMX, 0);
}
void dhtRead(u8 * rh, u8 * temp, u8 * checkSum ){
u8 tmp,j,i,tab[5] = {0x00,0x00,0x00,0x00,0x00};
dhtGpioOutInit();
GPIO_ResetBits(GPIOD,GPIO_Pin_7);
dhtDelay(18000);
GPIO_SetBits(GPIOD,GPIO_Pin_7);
dhtDelay(40);
dhtGpioInInit();
while(!GPIO_ReadInputDataBit(GPIOD,GPIO_Pin_7));
while(GPIO_ReadInputDataBit(GPIOD,GPIO_Pin_7));
for (i = 0; i < 5; ++i) {
for (j = 0; j < 8; ++j) {
while(!GPIO_ReadInputDataBit(GPIOD,GPIO_Pin_7));
TIM_SetCounter(TIM3,0);
while(GPIO_ReadInputDataBit(GPIOD,GPIO_Pin_7));
tmp = TIM_GetCounter(TIM3);
if(tmp<30){// trwanie sygna³u <30us-> 0; ok. 70us -> 1;
tab[i]=tab[i]<<1;
}
else{
tab[i] = tab[i]<<1;
tab[i] += 1;
}
}
}
*rh = tab[0];
*temp = tab[2];
*checkSum = tab[4];
}
void TIM2_Init(void)
{
TIM_TimeBaseInitTypeDef T; //创建定时器变量
RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2, ENABLE); //TIM2使用APB1时钟总线
TIM_DeInit(TIM2); //复位TIM2定时器到默认值
T.TIM_Period=500-1; //计数器溢出值，最大65535，此值不能更改，与输出比较的设定值一致，输出比较计数器溢出也为65535
if(get_APB1_prevdiv() > 0){
tim2_clock = Get_SyS_CLK(3)<<1;
}else{
tim2_clock = Get_SyS_CLK(3);
}
T.TIM_Prescaler = tim2_clock/TIM2_PREV_DIV - 1; //预分频系数，系统每秒72,000,000次，72000000/50000=1440分频，对系统频率72000000进行1440分频后，每秒计数频率为50000次，即每次计数时间为20us，每计满TIM_Period多次时变0重计
//T.TIM_Prescaler =7200 - 1; //预分频系数，系统每秒72,000,000次，72000000/50000=1440分频，对系统频率72000000进行1440分频后，每秒计数频率为50000次，即每次计数时间为20us，每计满TIM_Period多次时变0重计
T.TIM_ClockDivision = 0; //时钟分割 在定时器预分频之前作一段延时，很少用到，设为0即可
T.TIM_CounterMode = TIM_CounterMode_Up; //向上计数 UP：0到10000的计数 DOWN:FFFF到10000
TIM_TimeBaseInit(TIM2, &T); //根据上面设置初始化定时器TIM2
TIM_ClearFlag(TIM2, TIM_FLAG_Update); //清空溢出中断
TIM_SetCounter(TIM2,0); //设置计数器初值为0 //目前尚未启用该定时器
}
//Justin -- start
//串口接收数据，暂存数据到缓冲区，然后开启定时器TIM4，2.5ms之后会处理串口的数据
//Justin -- stop
void USART1_IRQHandler(void) {
if (USART_GetITStatus(USART1, USART_IT_RXNE) != RESET) {
//
if (usart_status == 0) {
usart_status = 1;
//开启计数器TIM4
TIM_ClearFlag(TIM4, TIM_FLAG_Update);
TIM_ITConfig(TIM4, TIM_IT_Update, ENABLE);
TIM_Cmd(TIM4, ENABLE);
usart_buffer[usart_index++] = USART1->DR;
if (usart_index == USART_BUFFER_LEN) {
usart_index = 0;
}
} else if (usart_status == 1) {
//计数器TIM4清零,
TIM_ITConfig(TIM4, TIM_IT_Update, DISABLE);
TIM_SetCounter(TIM4, 0x0000);
TIM_ClearFlag(TIM4, TIM_FLAG_Update);
TIM_ITConfig(TIM4, TIM_IT_Update, ENABLE);
usart_buffer[usart_index++] = USART1->DR;
if (usart_index == USART_BUFFER_LEN) {
usart_index = 0;
}
}
}
}
//use tim8,cc1
void Enc1Config(Encoder* me) {
GPIO_InitTypeDef GPIO_InitStructure;
RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM4, ENABLE);
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOB, ENABLE);
GPIO_StructInit(&GPIO_InitStructure);
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6; //channel1
GPIO_Init(GPIOB, &GPIO_InitStructure);
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_7; //channel2
GPIO_Init(GPIOB, &GPIO_InitStructure);
GPIO_PinAFConfig(GPIOB, GPIO_PinSource6, GPIO_AF_TIM4);
GPIO_PinAFConfig(GPIOB, GPIO_PinSource7, GPIO_AF_TIM4);
TIM_EncoderInterfaceConfig(TIM4, TIM_EncoderMode_TI12,
TIM_ICPolarity_Rising, TIM_ICPolarity_Rising);
TIM_SetAutoreload(TIM4, 0xffff);
TIM_SetCounter(TIM4, 0);
// TIM_Cmd(TIM4, ENABLE);
me->encoderTIM = TIM4;
me->encoderAddr = (unsigned int) &TIM4->CNT;
EnableEncoder(me); // TIM_Cmd(TIM4, ENABLE);
}
/******************************************
程序功能:红外接收中断服务程序
参程序数:无
返回参数:无
*******************************************/
void IRstudydata(void)
{
uint16_t datatimerbuf; //红外接收数据缓存
// if(hwred_bit_status != GPIO_ReadInputPin(IR_PORT, IRRED_PIN))
// {
// hwred_bit_status = (BitStatus)!hwred_bit_status;
if( bit_is_clear(Irtxflag,IRRXFINSH) && IRstudyflag)
{
datatimerbuf = TIM_GetCounter(TIM2);//- TIMECOUNT;
TIM_SetCounter(TIM2,0);
if(bit_is_clear(IRrxflag,IRRXSTART))
{
sbi_(IRrxflag,IRRXSTART);
memset((void *)Irtimebuf,'\0',300);
irdatalen = 0;
// uart_print(&irdatalen,1);
}
else if(irdatalen < TEMPTIMEBUF)
{
Irtimebuf[irdatalen] = datatimerbuf;
irdatalen++;
}
}
// }
}
void sleep_us(uint32_t time_us)
{
// Set TIM clock
RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2, ENABLE);
// Initialize TIM timer
TIM_TimeBaseInitTypeDef tim_init;
tim_init.TIM_Prescaler = 72 - 1;
tim_init.TIM_Period = 65535;
tim_init.TIM_ClockDivision = 0;
tim_init.TIM_CounterMode = TIM_CounterMode_Down;
TIM_TimeBaseInit(TIM2, &tim_init);
// Start timer
TIM_Cmd(TIM2, ENABLE);
TIM_SetCounter(TIM2, time_us);
// Wait
while (time_us)
{
time_us = TIM_GetCounter(TIM2);
}
// Disable timer
TIM_Cmd(TIM2, DISABLE);
}
void vMBMasterPortTimersDisable()
{
TIM_ClearITPendingBit(TIM2, TIM_IT_Update);
TIM_ITConfig(TIM2, TIM_IT_Update, DISABLE);
TIM_SetCounter(TIM2, 0);
TIM_Cmd(TIM2, DISABLE);
}
void ws2811LedStripDMAEnable(void)
{
DMA_SetCurrDataCounter(DMA1_Channel3, WS2811_DMA_BUFFER_SIZE); // load number of bytes to be transferred
TIM_SetCounter(TIM16, 0);
TIM_Cmd(TIM16, ENABLE);
DMA_Cmd(DMA1_Channel3, ENABLE);
}
void startTimer(uint32_t n)
{
TIM_ClearITPendingBit(timerIds[n], TIM_IT_Update);
TIM_SetCounter(timerIds[n], 1);
TIM_Cmd(timerIds[n], ENABLE);
active[n]=1;
}
void transponderIrDMAEnable(void)
{
DMA_SetCurrDataCounter(TRANSPONDER_DMA_CHANNEL, TRANSPONDER_DMA_BUFFER_SIZE); // load number of bytes to be transferred
TIM_SetCounter(TRANSPONDER_TIMER, 0);
TIM_Cmd(TRANSPONDER_TIMER, ENABLE);
DMA_Cmd(TRANSPONDER_DMA_CHANNEL, ENABLE);
}
/*==================================================================================
* 函 数 名： timer4_init
* 参 数： None
* 功能描述: 初始化TIM4
* 返 回 值： None
* 备 注：
* 作 者： gaodb
* 创建时间： 2012.10
==================================================================================*/
static void timer4_init(void)
{
TIM_TimeBaseInitTypeDef TIM_TimeBaseStructure;
TIM_DeInit(TIM4);
TIM_TimeBaseStructure.TIM_Period = 1089; //0.910222222ms * (1089 + 1)
TIM_TimeBaseStructure.TIM_Prescaler = 65535;
TIM_TimeBaseStructure.TIM_ClockDivision = TIM_CKD_DIV1;
TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;
TIM_TimeBaseInit(TIM4, &TIM_TimeBaseStructure);
//Timer4 clock source configured as Intenal Clock
TIM_InternalClockConfig(TIM4);
TIM_ARRPreloadConfig(TIM4, ENABLE);
TIM_SetCounter(TIM4,0);
TIM_ClearFlag(TIM4, TIM_FLAG_Update);
TIM_ITConfig(TIM4, TIM_IT_Update, ENABLE);
TIM_Cmd(TIM4, ENABLE);
}
//================ PRIVATE DEFINE ===========================================//
//
//================ PRIVATE MACRO ============================================//
//
//================ SOURCE CODE ==============================================//
//---------------- Init routie ----------------------------------------------//
void TimerInit(void) {
/* Enable clock for Timer2 module */
RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2, ENABLE);
NVIC_InitTypeDef NVIC_InitStructure;
NVIC_InitStructure.NVIC_IRQChannel = TIM2_IRQn;
NVIC_InitStructure.NVIC_IRQChannelPriority = 1;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStructure);
TIM_TimeBaseInitTypeDef TimerInit = {
.TIM_Period = 100,
.TIM_Prescaler = 8000,
.TIM_ClockDivision = TIM_CKD_DIV4,
.TIM_CounterMode = TIM_CounterMode_Up
};
TIM_TimeBaseInit(TIM2, &TimerInit);
TIM_ClearITPendingBit(TIM2, TIM_IT_Update);
//TIM2->DIER |=
TIM_ITConfig(TIM2, TIM_IT_Update, ENABLE);
}
void TimerResetCounter(void) {
TIM_SetCounter(TIM2, 0);
}
void timingFunctionsInit(void)
{
TIM_TimeBaseInitTypeDef TIM_TimeBaseStructure;
TIM_TimeBaseStructure.TIM_Period = 0xFFFF; // Just roll over counter at max value
TIM_TimeBaseStructure.TIM_Prescaler = 42 - 1; // 84 MHz / 42 = 2 MHz = 0.5 uSec Tick
TIM_TimeBaseStructure.TIM_ClockDivision = TIM_CKD_DIV1;
TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;
TIM_TimeBaseStructure.TIM_RepetitionCounter = 0x0000;
TIM_TimeBaseInit(TIM10, &TIM_TimeBaseStructure);
TIM_TimeBaseInit(TIM11, &TIM_TimeBaseStructure);
TIM_SetCounter(TIM10, 4000); // First pass value
TIM_SetCounter(TIM11, 20000); // First pass value
}
void WS2812B_Send_Buffer(void)
{
WS2812B_TC = 0;
DMA_ClearFlag(DMA1_FLAG_TC2 | DMA1_FLAG_HT2 | DMA1_FLAG_GL2 | DMA1_FLAG_TE2);
DMA_ClearFlag(DMA1_FLAG_TC3 | DMA1_FLAG_HT3 | DMA1_FLAG_GL3 | DMA1_FLAG_TE3);
DMA_ClearFlag(DMA1_FLAG_TC4 | DMA1_FLAG_HT4 | DMA1_FLAG_GL4 | DMA1_FLAG_TE4);
DMA_SetCurrDataCounter(DMA1_Channel2, WS2812B_BUFFER_SIZE);
DMA_SetCurrDataCounter(DMA1_Channel3, WS2812B_BUFFER_SIZE);
DMA_SetCurrDataCounter(DMA1_Channel4, WS2812B_BUFFER_SIZE);
TIM3->SR = 0;
DMA_Cmd(DMA1_Channel2, ENABLE);
DMA_Cmd(DMA1_Channel3, ENABLE);
DMA_Cmd(DMA1_Channel4, ENABLE);
TIM_DMACmd(TIM3, TIM_DMA_CC1, ENABLE);
TIM_DMACmd(TIM3, TIM_DMA_CC3, ENABLE);
TIM_DMACmd(TIM3, TIM_DMA_Update, ENABLE);
TIM_SetCounter(TIM3, 10);
TIM_Cmd(TIM3, ENABLE);
}
