ARMmbed
/
mbed-os
mirror of https://github.com/ARMmbed/mbed-os.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Merge pull request #1229 from Wiznet/mbed_dev2 

Change us_ticker - one dual timer + one pwm timer
pull/1264/merge
Martin Kojtal 2015-07-27 09:38:55 +01:00
parent bfd1ddeee4 226d534d85
commit 9b9bab51e5
5 changed files with 368 additions and 54 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

37
libraries/mbed/targets/cmsis/TARGET_WIZNET/TARGET_W7500x/TARGET_WIZwiki_W7500/W7500x.h
View File

@ -1010,19 +1010,30 @@ typedef struct
/******************************************************************************/
/*********************** Bit definition for dualtimer ***********************/
#define DUALTIMER_TimerControl_TimerDIsable (0x0ul << 7)
#define DUALTIMER_TimerControl_TimerEnable (0x1ul << 7)
#define DUALTIMER_TimerControl_FreeRunning (0x0ul << 6)
#define DUALTIMER_TimerControl_Periodic (0x1ul << 6)
#define DUALTIMER_TimerControl_IntDisable (0x0ul << 5)
#define DUALTIMER_TimerControl_IntEnable (0x1ul << 5)
#define DUALTIMER_TimerControl_Pre_1 (0x0ul << 2)
#define DUALTIMER_TimerControl_Pre_16 (0x1ul << 2)
#define DUALTIMER_TimerControl_Pre_256 (0x2ul << 2)
#define DUALTIMER_TimerControl_Size_16 (0x0ul << 1)
#define DUALTIMER_TimerControl_Size_32 (0x1ul << 1)
#define DUALTIMER_TimerControl_Wrapping (0x0ul << 0)
#define DUALTIMER_TimerControl_OneShot (0x1ul << 0)
#define DUALTIMER_TimerControl_TimerDIsable 0x0ul
#define DUALTIMER_TimerControl_TimerEnable 0x1ul
#define DUALTIMER_TimerControl_TimerEnable_Pos 7
#define DUALTIMER_TimerControl_FreeRunning 0x0ul
#define DUALTIMER_TimerControl_Periodic 0x1ul
#define DUALTIMER_TimerControl_TimerMode_Pos 6
#define DUALTIMER_TimerControl_IntDisable 0x0ul
#define DUALTIMER_TimerControl_IntEnable 0x1ul
#define DUALTIMER_TimerControl_IntEnable_Pos 5
#define DUALTIMER_TimerControl_Pre_1 0x0ul
#define DUALTIMER_TimerControl_Pre_16 0x1ul
#define DUALTIMER_TimerControl_Pre_256 0x2ul
#define DUALTIMER_TimerControl_Pre_Pos 2
#define DUALTIMER_TimerControl_Size_16 0x0ul
#define DUALTIMER_TimerControl_Size_32 0x1ul
#define DUALTIMER_TimerControl_Size_Pos 1
#define DUALTIMER_TimerControl_Wrapping 0x0ul
#define DUALTIMER_TimerControl_OneShot 0x1ul
#define DUALTIMER_TimerControl_OneShot_Pos 0
/******************************************************************************/
/* */

1
libraries/mbed/targets/cmsis/TARGET_WIZNET/TARGET_W7500x/W7500x_conf.h
View File

@ -4,6 +4,7 @@
#include "W7500x_uart.h"
#include "W7500x_i2c.h"
#include "W7500x_adc.h"
#include "W7500x_dualtimer.h"
#include "system_W7500x.h"

205
libraries/mbed/targets/cmsis/TARGET_WIZNET/TARGET_W7500x/W7500x_dualtimer.c Normal file
View File

@ -0,0 +1,205 @@
/**
******************************************************************************
* @file W7500x_stdPeriph_Driver/src/W7500x_dualtimer.c
* @author IOP Team
* @version v1.0.0
* @date 01-May-2015
* @brief This file contains all the functions prototypes for the dualtimer
* firmware library.
******************************************************************************
*
******************************************************************************
*/
/* Includes -------------------------------------------*/
#include "W7500x.h"
void DUALTIMER_ClockEnable(DUALTIMER_TypeDef* DUALTIMERn)
{
/* Check the parameters */
assert_param(IS_DUALTIMER_ALL_CH(DUALTIMERn));
if(DUALTIMERn == DUALTIMER0_0)
TIMCLKEN0_0 = DUALTIMER_Clock_Enable;
else if(DUALTIMERn == DUALTIMER0_1)
TIMCLKEN0_1 = DUALTIMER_Clock_Enable;
else if(DUALTIMERn == DUALTIMER1_0)
TIMCLKEN1_0 = DUALTIMER_Clock_Enable;
else if(DUALTIMERn == DUALTIMER1_1)
TIMCLKEN1_1 = DUALTIMER_Clock_Enable;
}
void DUALTIMER_ClockDisable(DUALTIMER_TypeDef* DUALTIMERn)
{
/* Check the parameters */
assert_param(IS_DUALTIMER_ALL_CH(DUALTIMERn));
if(DUALTIMERn == DUALTIMER0_0)
TIMCLKEN0_0 = DUALTIMER_Clock_Disable;
else if(DUALTIMERn == DUALTIMER0_1)
TIMCLKEN0_1 = DUALTIMER_Clock_Disable;
else if(DUALTIMERn == DUALTIMER1_0)
TIMCLKEN1_0 = DUALTIMER_Clock_Disable;
else if(DUALTIMERn == DUALTIMER1_1)
TIMCLKEN1_1 = DUALTIMER_Clock_Disable;
}
void DUALTIMER_DeInit(DUALTIMER_TypeDef* DUALTIMERn)
{
/* Check the parameters */
assert_param(IS_DUALTIMER_ALL_CH(DUALTIMERn));
DUALTIMER_Stop(DUALTIMERn);
DUALTIMERn->TimerLoad = 0x0;
DUALTIMERn->TimerControl = 0x20;
DUALTIMERn->TimerBGLoad = 0x0;
}
void DUALTIMER_Init(DUALTIMER_TypeDef* DUALTIMERn, DUALTIMER_InitTypDef* DUALTIMER_InitStruct)
{
uint32_t tmp = 0;
/* Check the parameters */
assert_param(IS_DUALTIMER_ALL_CH(DUALTIMERn));
assert_param(IS_DUALTIMER_TimerMode(DUALTIMER_InitStruct->TimerControl_Mode));
assert_param(IS_DUALTIMER_TimerPre(DUALTIMER_InitStruct->TimerControl_Pre));
assert_param(IS_DUALTIMER_TimerSize(DUALTIMER_InitStruct->TimerControl_Size));
assert_param(IS_DUALTIMER_OneShot(DUALTIMER_InitStruct->TimerControl_OneShot));
DUALTIMER_Stop(DUALTIMERn);
DUALTIMERn->TimerLoad = DUALTIMER_InitStruct->TimerLoad;
tmp = DUALTIMERn->TimerControl;
tmp |= (DUALTIMER_InitStruct->TimerControl_Mode << DUALTIMER_TimerControl_TimerMode_Pos);
tmp |= (DUALTIMER_InitStruct->TimerControl_Pre << DUALTIMER_TimerControl_Pre_Pos);
tmp |= (DUALTIMER_InitStruct->TimerControl_Size << DUALTIMER_TimerControl_Size_Pos);
tmp |= (DUALTIMER_InitStruct->TimerControl_OneShot << DUALTIMER_TimerControl_OneShot_Pos);
//Reset values not used
tmp &= 0xEF;
DUALTIMERn->TimerControl = tmp;
}
void DUALTIMER_IntConfig(DUALTIMER_TypeDef* DUALTIMERn, FunctionalState state)
{
/* Check the parameters */
assert_param(IS_DUALTIMER_ALL_CH(DUALTIMERn));
if(state == ENABLE)
DUALTIMERn->TimerControl |= (DUALTIMER_TimerControl_IntEnable << DUALTIMER_TimerControl_IntEnable_Pos);
else
DUALTIMERn->TimerControl &= ~(DUALTIMER_TimerControl_IntEnable << DUALTIMER_TimerControl_IntEnable_Pos);
}
void DUALTIMER_IntClear(DUALTIMER_TypeDef* DUALTIMERn)
{
/* Check the parameters */
assert_param(IS_DUALTIMER_ALL_CH(DUALTIMERn));
DUALTIMERn->TimerIntClr = DUALTIMER_Int_Clear;
}
ITStatus DUALTIMER_GetIntStatus(DUALTIMER_TypeDef* DUALTIMERn)
{
/* Check the parameters */
assert_param(IS_DUALTIMER_ALL_CH(DUALTIMERn));
return (ITStatus)DUALTIMERn->TimerMIS;
}
FlagStatus DUALTIMER_GetIntEnableStatus(DUALTIMER_TypeDef* DUALTIMERn)
{
/* Check the parameters */
assert_param(IS_DUALTIMER_ALL_CH(DUALTIMERn));
return (FlagStatus)((DUALTIMERn->TimerControl >> DUALTIMER_TimerControl_IntEnable_Pos) & 0x1);
}
void DUALTIMER_Start(DUALTIMER_TypeDef* DUALTIMERn)
{
/* Check the parameters */
assert_param(IS_DUALTIMER_ALL_CH(DUALTIMERn));
DUALTIMERn->TimerControl |= (DUALTIMER_TimerControl_TimerEnable << DUALTIMER_TimerControl_TimerEnable_Pos);
}
void DUALTIMER_Stop(DUALTIMER_TypeDef* DUALTIMERn)
{
/* Check the parameters */
assert_param(IS_DUALTIMER_ALL_CH(DUALTIMERn));
DUALTIMERn->TimerControl &= ~(DUALTIMER_TimerControl_TimerEnable << DUALTIMER_TimerControl_TimerEnable_Pos);
}
uint32_t DUALTIMER_GetTimerLoad(DUALTIMER_TypeDef* DUALTIMERn)
{
/* Check the parameters */
assert_param(IS_DUALTIMER_ALL_CH(DUALTIMERn));
return DUALTIMERn->TimerLoad;
}
void DUALTIMER_SetTimerLoad(DUALTIMER_TypeDef* DUALTIMERn, uint32_t TimerLoad)
{
/* Check the parameters */
assert_param(IS_DUALTIMER_ALL_CH(DUALTIMERn));
DUALTIMERn->TimerLoad = TimerLoad;
}
uint32_t DUALTIMER_GetTimerValue(DUALTIMER_TypeDef* DUALTIMERn)
{
/* Check the parameters */
assert_param(IS_DUALTIMER_ALL_CH(DUALTIMERn));
return DUALTIMERn->TimerValue;
}
uint32_t DUALTIMER_GetTimerControl(DUALTIMER_TypeDef* DUALTIMERn)
{
/* Check the parameters */
assert_param(IS_DUALTIMER_ALL_CH(DUALTIMERn));
return DUALTIMERn->TimerControl;
}
void DUALTIMER_SetTimerControl(DUALTIMER_TypeDef* DUALTIMERn, uint32_t TimerControl)
{
/* Check the parameters */
assert_param(IS_DUALTIMER_ALL_CH(DUALTIMERn));
DUALTIMERn->TimerControl = TimerControl;
}
uint32_t DUALTIMER_GetTimerRIS(DUALTIMER_TypeDef* DUALTIMERn)
{
/* Check the parameters */
assert_param(IS_DUALTIMER_ALL_CH(DUALTIMERn));
return DUALTIMERn->TimerRIS;
}
uint32_t DUALTIMER_GetTimerMIS(DUALTIMER_TypeDef* DUALTIMERn)
{
/* Check the parameters */
assert_param(IS_DUALTIMER_ALL_CH(DUALTIMERn));
return DUALTIMERn->TimerMIS;
}
uint32_t DUALTIMER_GetTimerBGLoad(DUALTIMER_TypeDef* DUALTIMERn)
{
/* Check the parameters */
assert_param(IS_DUALTIMER_ALL_CH(DUALTIMERn));
return DUALTIMERn->TimerBGLoad;
}
void DUALTIMER_SetTimerBGLoad(DUALTIMER_TypeDef* DUALTIMERn, uint32_t TimerBGLoad)
{
/* Check the parameters */
assert_param(IS_DUALTIMER_ALL_CH(DUALTIMERn));
DUALTIMERn->TimerBGLoad = TimerBGLoad;
}

96
libraries/mbed/targets/cmsis/TARGET_WIZNET/TARGET_W7500x/W7500x_dualtimer.h Normal file
View File

@ -0,0 +1,96 @@
/**
******************************************************************************
* @file W7500x_stdPeriph_Driver/inc/W7500x_dualtimer.h
* @author IOP Team
* @version V1.0.0
* @date 01-May-2015
* @brief This file contains all the functions prototypes for the dualtimer
* firmware library.
******************************************************************************
*
******************************************************************************
*/
/* Define to prevent recursive inclusion -------------------------------------*/
#ifndef __W7500X_DUALTIMER_H
#define __W7500X_DUALTIMER_H
#ifdef __cplusplus
extern "C" {
#endif
/* Includes ------------------------------------------------------------------*/
#include "W7500x.h"
/**********************************************************************************************/
/**********************************************************************************************/
// This structure and define must be in W7500x.h
/**********************************************************************************************/
/**********************************************************************************************/
typedef struct
{
uint32_t TimerLoad;
uint32_t TimerControl_Mode;
uint32_t TimerControl_Pre;
uint32_t TimerControl_Size;
uint32_t TimerControl_OneShot;
}DUALTIMER_InitTypDef;
#define IS_DUALTIMER_TimerMode(MODE) (MODE <= 1)
#define IS_DUALTIMER_TimerPre(PREE) (PRE <= 2)
#define IS_DUALTIMER_TimerSize(SIZE) (SIZE <= 1)
#define IS_DUALTIMER_OneShot(ONESHOT) (ONESHOT <= 1)
#define DUALTIMER_Int_Clear 0x1ul
#define DUALTIMER_Clock_Enable 0x1ul
#define DUALTIMER_Clock_Disable ~DUALTIMER_Clock_Enable
#define IS_DUALTIMER_ALL_CH(CH) ((CH == DUALTIMER0_0) || \
(CH == DUALTIMER0_1) || \
(CH == DUALTIMER1_0) || \
(CH == DUALTIMER1_1))
void DUALTIMER_ClockEnable(DUALTIMER_TypeDef* DUALTIMERn);
void DUALTIMER_ClockDisable(DUALTIMER_TypeDef* DUALTIMERn);
void DUALTIMER_DeInit(DUALTIMER_TypeDef* DUALTIMERn);
void DUALTIMER_Init(DUALTIMER_TypeDef* DUALTIMERn, DUALTIMER_InitTypDef* DUALTIMER_InitStruct);
void DUALTIMER_IntConfig(DUALTIMER_TypeDef* DUALTIMERn, FunctionalState state);
void DUALTIMER_IntClear(DUALTIMER_TypeDef* DUALTIMERn);
ITStatus DUALTIMER_GetIntStatus(DUALTIMER_TypeDef* DUALTIMERn);
FlagStatus DUALTIMER_GetIntEnableStatus(DUALTIMER_TypeDef* DUALTIMERn);
void DUALTIMER_Start(DUALTIMER_TypeDef* DUALTIMERn);
void DUALTIMER_Stop(DUALTIMER_TypeDef* DUALTIMERn);
uint32_t DUALTIMER_GetTimerLoad(DUALTIMER_TypeDef* DUALTIMERn);
void DUALTIMER_SetTimerLoad(DUALTIMER_TypeDef* DUALTIMERn, uint32_t TimerLoad);
uint32_t DUALTIMER_GetTimerValue(DUALTIMER_TypeDef* DUALTIMERn);
uint32_t DUALTIMER_GetTimerControl(DUALTIMER_TypeDef* DUALTIMERn);
void DUALTIMER_SetTimerControl(DUALTIMER_TypeDef* DUALTIMERn, uint32_t TimerControl);
uint32_t DUALTIMER_GetTimerRIS(DUALTIMER_TypeDef* DUALTIMERn);
uint32_t DUALTIMER_GetTimerMIS(DUALTIMER_TypeDef* DUALTIMERn);
uint32_t DUALTIMER_GetTimerBGLoad(DUALTIMER_TypeDef* DUALTIMERn);
void DUALTIMER_SetTimerBGLoad(DUALTIMER_TypeDef* DUALTIMERn, uint32_t TimerBGLoad);
//======================= Interrupt handler ==============================
//void DUALTIMER0_Handler();
//void DUALTIMER1_Handler();
#ifdef __cplusplus
}
#endif
#endif //__W7500X_DUALTIMER_H

83
libraries/mbed/targets/hal/TARGET_WIZNET/TARGET_W7500x/us_ticker.c
View File

@ -33,9 +33,12 @@
#include "PeripheralNames.h"
#include "system_W7500x.h"
#define TIMER_0 DUALTIMER0_0
#define TIMER_1 PWM_CH1
#define TIMER_IRQn DUALTIMER0_IRQn
static PWM_TimerModeInitTypeDef TimMasterHandle_CH3;
static PWM_TimerModeInitTypeDef TimMasterHandle_CH2;
static PWM_TimerModeInitTypeDef TimerInitType;
static DUALTIMER_InitTypDef TimerHandler;
static int us_ticker_inited = 0;
@ -43,17 +46,12 @@ static int us_ticker_inited = 0;
#ifdef __cplusplus
extern "C"{
#endif
void PWM2_Handler(void)
void DUALTIMER0_Handler(void)
{
uint32_t IntFlag = 0;
IntFlag = PWM_CHn_GetIntFlagStatus(PWM_CH2);
/* If overflow interrupt is occurred */
if( (IntFlag & PWM_CHn_IER_OI_Msk) != 0 )
if(DUALTIMER_GetIntStatus(DUALTIMER0_0))
{
/* Clear overflow interrupt */
PWM_CH2_ClearOverflowInt();
DUALTIMER_IntClear(DUALTIMER0_0);
us_ticker_irq_handler();
}
}
@ -68,66 +66,69 @@ void us_ticker_init(void)
us_ticker_inited = 1;
SystemCoreClockUpdate();
TimMasterHandle_CH3.PWM_CHn_PR = (GetSystemClock() / 1000000) -1;
TimMasterHandle_CH3.PWM_CHn_LR = 0xFFFFFFFF;
TimMasterHandle_CH3.PWM_CHn_PDMR = 1;
TimerInitType.PWM_CHn_PR = (GetSystemClock() / 1000000) -1;
TimerInitType.PWM_CHn_LR = 0xFFFFFFFF;
TimerInitType.PWM_CHn_PDMR = 1;
PWM_TimerModeInit(PWM_CH3, &TimMasterHandle_CH3);
PWM_CHn_Start(PWM_CH3);
PWM_TimerModeInit(TIMER_1, &TimerInitType);
PWM_CHn_Start(TIMER_1);
}
uint32_t us_ticker_read()
{
if (!us_ticker_inited) us_ticker_init();
return (PWM_CH3->TCR);
return (TIMER_1->TCR);
}
void us_ticker_set_interrupt(timestamp_t timestamp)
{
int32_t dev = 0;
if (!us_ticker_inited)
{
us_ticker_init();
}
dev = (int32_t)(timestamp - (us_ticker_read() + 150));
dev = (int32_t)(timestamp - us_ticker_read());
dev = dev * ((GetSystemClock() / 1000000) / 16);
if(dev <= 0)
{
us_ticker_irq_handler();
return;
return;
}
DUALTIMER_ClockEnable(TIMER_0);
DUALTIMER_Stop(TIMER_0);
TimerHandler.TimerControl_Mode = DUALTIMER_TimerControl_Periodic;
TimerHandler.TimerControl_OneShot = DUALTIMER_TimerControl_OneShot;
TimerHandler.TimerControl_Pre = DUALTIMER_TimerControl_Pre_16;
TimerHandler.TimerControl_Size = DUALTIMER_TimerControl_Size_32;
TimerHandler.TimerLoad = (uint32_t)dev;
DUALTIMER_Init(TIMER_0, &TimerHandler);
DUALTIMER_IntConfig(TIMER_0, ENABLE);
NVIC_EnableIRQ(TIMER_IRQn);
DUALTIMER_Start(TIMER_0);
PWM_CHn_Stop(PWM_CH2);
SystemCoreClockUpdate();
TimMasterHandle_CH2.PWM_CHn_PR = (GetSystemClock() / 1000000) -1;
TimMasterHandle_CH2.PWM_CHn_LR = dev;
TimMasterHandle_CH2.PWM_CHn_UDMR = 0;
TimMasterHandle_CH2.PWM_CHn_PDMR = 0;
NVIC_EnableIRQ(PWM2_IRQn);
PWM_CHn_IntConfig(PWM_CH2, PWM_CHn_IER_OIE, ENABLE);
PWM_IntConfig(PWM_CH2, ENABLE);
PWM_TimerModeInit(PWM_CH2, &TimMasterHandle_CH2);
PWM_CHn_Start(PWM_CH2);
}
void us_ticker_disable_interrupt(void)
{
NVIC_DisableIRQ(PWM2_IRQn);
PWM_CHn_IntConfig(PWM_CH2, PWM_CHn_IER_OIE, DISABLE);
PWM_IntConfig(PWM_CH2, DISABLE);
NVIC_DisableIRQ(TIMER_IRQn);
DUALTIMER_IntConfig(TIMER_0, DISABLE);
}
void us_ticker_clear_interrupt(void)
{
PWM_CHn_ClearInt(PWM_CH2, PWM_CHn_IER_OIE);
DUALTIMER_IntClear(TIMER_0);
}