From 1b608ef4dbaadea7ca4a65fbf90a49fa462c34f1 Mon Sep 17 00:00:00 2001 From: Rohit Grover Date: Tue, 12 Aug 2014 14:53:35 +0100 Subject: [PATCH 01/11] cleaning up code within Nordic's mbed HAL using astyle --- .../TARGET_MCU_NRF51822/analogin_api.c | 34 +- .../TARGET_MCU_NRF51822/gpio_api.c | 33 +- .../TARGET_MCU_NRF51822/gpio_irq_api.c | 131 ++++---- .../TARGET_MCU_NRF51822/i2c_api.c | 215 ++++++------ .../TARGET_MCU_NRF51822/pinmap.c | 10 +- .../TARGET_MCU_NRF51822/port_api.c | 58 ++-- .../TARGET_MCU_NRF51822/pwmout_api.c | 308 +++++++++--------- .../TARGET_MCU_NRF51822/serial_api.c | 204 ++++++------ .../TARGET_NORDIC/TARGET_MCU_NRF51822/sleep.c | 10 +- .../TARGET_MCU_NRF51822/spi_api.c | 272 ++++++++-------- .../TARGET_MCU_NRF51822/us_ticker.c | 150 ++++----- 11 files changed, 741 insertions(+), 684 deletions(-) diff --git a/libraries/mbed/targets/hal/TARGET_NORDIC/TARGET_MCU_NRF51822/analogin_api.c b/libraries/mbed/targets/hal/TARGET_NORDIC/TARGET_MCU_NRF51822/analogin_api.c index c0802c96754..ab6da875456 100644 --- a/libraries/mbed/targets/hal/TARGET_NORDIC/TARGET_MCU_NRF51822/analogin_api.c +++ b/libraries/mbed/targets/hal/TARGET_NORDIC/TARGET_MCU_NRF51822/analogin_api.c @@ -29,45 +29,47 @@ static const PinMap PinMap_ADC[] = { {p4, ADC0_0, 32}, {p5, ADC0_0, 64}, {p6, ADC0_0, 128}, - {NC , NC , 0} + {NC, NC, 0} }; -void analogin_init(analogin_t *obj, PinName pin) { - int analogInputPin=0; - const PinMap *map = PinMap_ADC; - +void analogin_init(analogin_t *obj, PinName pin) +{ + int analogInputPin = 0; + const PinMap *map = PinMap_ADC; + obj->adc = (ADCName)pinmap_peripheral(pin, PinMap_ADC); //(NRF_ADC_Type *) MBED_ASSERT(obj->adc != (ADCName)NC); - + while (map->pin != NC) { - if (map->pin == pin){ + if (map->pin == pin) { analogInputPin = map->function; break; } map++; } obj->adc_pin = (uint8_t)analogInputPin; - + NRF_ADC->ENABLE = ADC_ENABLE_ENABLE_Enabled; NRF_ADC->CONFIG = (ADC_CONFIG_RES_10bit << ADC_CONFIG_RES_Pos) | - (ADC_CONFIG_INPSEL_AnalogInputOneThirdPrescaling<< ADC_CONFIG_INPSEL_Pos) | + (ADC_CONFIG_INPSEL_AnalogInputOneThirdPrescaling << ADC_CONFIG_INPSEL_Pos) | (ADC_CONFIG_REFSEL_SupplyOneThirdPrescaling << ADC_CONFIG_REFSEL_Pos) | (analogInputPin << ADC_CONFIG_PSEL_Pos) | (ADC_CONFIG_EXTREFSEL_None << ADC_CONFIG_EXTREFSEL_Pos); } -uint16_t analogin_read_u16(analogin_t *obj) { - NRF_ADC->CONFIG &= ~ADC_CONFIG_PSEL_Msk; - NRF_ADC->CONFIG |= obj->adc_pin << ADC_CONFIG_PSEL_Pos; +uint16_t analogin_read_u16(analogin_t *obj) +{ + NRF_ADC->CONFIG &= ~ADC_CONFIG_PSEL_Msk; + NRF_ADC->CONFIG |= obj->adc_pin << ADC_CONFIG_PSEL_Pos; NRF_ADC->TASKS_START = 1; - while ( ( (NRF_ADC->BUSY & ADC_BUSY_BUSY_Msk) >> ADC_BUSY_BUSY_Pos) == ADC_BUSY_BUSY_Busy) - { + while (((NRF_ADC->BUSY & ADC_BUSY_BUSY_Msk) >> ADC_BUSY_BUSY_Pos) == ADC_BUSY_BUSY_Busy) { } - + return (uint16_t)NRF_ADC->RESULT; // 10 bit } -float analogin_read(analogin_t *obj) { +float analogin_read(analogin_t *obj) +{ uint16_t value = analogin_read_u16(obj); return (float)value * (1.0f / (float)ADC_RANGE); } diff --git a/libraries/mbed/targets/hal/TARGET_NORDIC/TARGET_MCU_NRF51822/gpio_api.c b/libraries/mbed/targets/hal/TARGET_NORDIC/TARGET_MCU_NRF51822/gpio_api.c index 571b232ec53..099369733c8 100644 --- a/libraries/mbed/targets/hal/TARGET_NORDIC/TARGET_MCU_NRF51822/gpio_api.c +++ b/libraries/mbed/targets/hal/TARGET_NORDIC/TARGET_MCU_NRF51822/gpio_api.c @@ -17,10 +17,12 @@ #include "gpio_api.h" #include "pinmap.h" -void gpio_init(gpio_t *obj, PinName pin) { +void gpio_init(gpio_t *obj, PinName pin) +{ obj->pin = pin; - if (pin == (PinName)NC) + if (pin == (PinName)NC) { return; + } obj->mask = (1ul << pin); @@ -30,26 +32,27 @@ void gpio_init(gpio_t *obj, PinName pin) { obj->reg_dir = &NRF_GPIO->DIR; } -void gpio_mode(gpio_t *obj, PinMode mode) { +void gpio_mode(gpio_t *obj, PinMode mode) +{ pin_mode(obj->pin, mode); } -void gpio_dir(gpio_t *obj, PinDirection direction) { +void gpio_dir(gpio_t *obj, PinDirection direction) +{ MBED_ASSERT(obj->pin != (PinName)NC); switch (direction) { - case PIN_INPUT : - NRF_GPIO->PIN_CNF[obj->pin] = (GPIO_PIN_CNF_SENSE_Disabled << GPIO_PIN_CNF_SENSE_Pos) - | (GPIO_PIN_CNF_DRIVE_S0S1 << GPIO_PIN_CNF_DRIVE_Pos) - | (GPIO_PIN_CNF_INPUT_Connect << GPIO_PIN_CNF_INPUT_Pos) - | (GPIO_PIN_CNF_DIR_Input << GPIO_PIN_CNF_DIR_Pos); + case PIN_INPUT: + NRF_GPIO->PIN_CNF[obj->pin] = (GPIO_PIN_CNF_SENSE_Disabled << GPIO_PIN_CNF_SENSE_Pos) | + (GPIO_PIN_CNF_DRIVE_S0S1 << GPIO_PIN_CNF_DRIVE_Pos) | + (GPIO_PIN_CNF_INPUT_Connect << GPIO_PIN_CNF_INPUT_Pos) | + (GPIO_PIN_CNF_DIR_Input << GPIO_PIN_CNF_DIR_Pos); break; case PIN_OUTPUT: - NRF_GPIO->PIN_CNF[obj->pin] = (GPIO_PIN_CNF_SENSE_Disabled << GPIO_PIN_CNF_SENSE_Pos) - | (GPIO_PIN_CNF_DRIVE_S0S1 << GPIO_PIN_CNF_DRIVE_Pos) - | (GPIO_PIN_CNF_PULL_Disabled << GPIO_PIN_CNF_PULL_Pos) - | (GPIO_PIN_CNF_INPUT_Connect << GPIO_PIN_CNF_INPUT_Pos) - | (GPIO_PIN_CNF_DIR_Output << GPIO_PIN_CNF_DIR_Pos); + NRF_GPIO->PIN_CNF[obj->pin] = (GPIO_PIN_CNF_SENSE_Disabled << GPIO_PIN_CNF_SENSE_Pos) | + (GPIO_PIN_CNF_DRIVE_S0S1 << GPIO_PIN_CNF_DRIVE_Pos) | + (GPIO_PIN_CNF_PULL_Disabled << GPIO_PIN_CNF_PULL_Pos) | + (GPIO_PIN_CNF_INPUT_Connect << GPIO_PIN_CNF_INPUT_Pos) | + (GPIO_PIN_CNF_DIR_Output << GPIO_PIN_CNF_DIR_Pos); break; } } - diff --git a/libraries/mbed/targets/hal/TARGET_NORDIC/TARGET_MCU_NRF51822/gpio_irq_api.c b/libraries/mbed/targets/hal/TARGET_NORDIC/TARGET_MCU_NRF51822/gpio_irq_api.c index 73c68af03f4..0c86f87ec87 100644 --- a/libraries/mbed/targets/hal/TARGET_NORDIC/TARGET_MCU_NRF51822/gpio_irq_api.c +++ b/libraries/mbed/targets/hal/TARGET_NORDIC/TARGET_MCU_NRF51822/gpio_irq_api.c @@ -23,103 +23,106 @@ static uint32_t channel_ids[CHANNEL_NUM] = {0}; //each pin will be given an id, if id is 0 the pin can be ignored. static uint8_t channel_enabled[CHANNEL_NUM] = {0}; -static uint32_t portRISE= 0; -static uint32_t portFALL= 0; +static uint32_t portRISE = 0; +static uint32_t portFALL = 0; static gpio_irq_handler irq_handler; #ifdef __cplusplus extern "C" { -#endif -void GPIOTE_IRQHandler(void){ - volatile uint32_t newVal = NRF_GPIO->IN; - - if ( (NRF_GPIOTE->EVENTS_PORT != 0) && ( (NRF_GPIOTE->INTENSET & GPIOTE_INTENSET_PORT_Msk) != 0) ){ - NRF_GPIOTE->EVENTS_PORT = 0; - - for(uint8_t i=0;i<31;i++){ - if(channel_ids[i]>0){ - if(channel_enabled[i]){ - if( ((newVal>>i)&1) && ( ( (NRF_GPIO->PIN_CNF[i] >>GPIO_PIN_CNF_SENSE_Pos) & GPIO_PIN_CNF_SENSE_Low) != GPIO_PIN_CNF_SENSE_Low) && ( (portRISE>>i)&1) ){ - irq_handler(channel_ids[i], IRQ_RISE); - } - else if( ( ((newVal>>i)&1) == 0) && ( ( (NRF_GPIO->PIN_CNF[i] >>GPIO_PIN_CNF_SENSE_Pos)&GPIO_PIN_CNF_SENSE_Low) == GPIO_PIN_CNF_SENSE_Low) && ( (portFALL>>i)&1) ){ - irq_handler(channel_ids[i], IRQ_FALL); - } +#endif +void GPIOTE_IRQHandler(void) +{ + volatile uint32_t newVal = NRF_GPIO->IN; + + if ((NRF_GPIOTE->EVENTS_PORT != 0) && ((NRF_GPIOTE->INTENSET & GPIOTE_INTENSET_PORT_Msk) != 0)) { + NRF_GPIOTE->EVENTS_PORT = 0; + + for (uint8_t i = 0; i<31; i++) { + if (channel_ids[i]>0) { + if (channel_enabled[i]) { + if (((newVal >> i) & 1) && (((NRF_GPIO->PIN_CNF[i] >> GPIO_PIN_CNF_SENSE_Pos) & GPIO_PIN_CNF_SENSE_Low) != GPIO_PIN_CNF_SENSE_Low) && + ((portRISE >> i) & 1)) { + irq_handler(channel_ids[i], IRQ_RISE); + } else if ((((newVal >> i) & 1) == 0) && + (((NRF_GPIO->PIN_CNF[i] >> GPIO_PIN_CNF_SENSE_Pos) & GPIO_PIN_CNF_SENSE_Low) == GPIO_PIN_CNF_SENSE_Low) && + ((portFALL >> i) & 1)) { + irq_handler(channel_ids[i], IRQ_FALL); + } } - - if(NRF_GPIO->PIN_CNF[i] &GPIO_PIN_CNF_SENSE_Msk){ + + if (NRF_GPIO->PIN_CNF[i] & GPIO_PIN_CNF_SENSE_Msk) { NRF_GPIO->PIN_CNF[i] &= ~(GPIO_PIN_CNF_SENSE_Msk); - - if(newVal>>i &1){ - NRF_GPIO->PIN_CNF[i] |= (GPIO_PIN_CNF_SENSE_Low << GPIO_PIN_CNF_SENSE_Pos) ; - } - else{ - NRF_GPIO->PIN_CNF[i] |= (GPIO_PIN_CNF_SENSE_High << GPIO_PIN_CNF_SENSE_Pos) ; + + if (newVal >> i & 1) { + NRF_GPIO->PIN_CNF[i] |= (GPIO_PIN_CNF_SENSE_Low << GPIO_PIN_CNF_SENSE_Pos); + } else { + NRF_GPIO->PIN_CNF[i] |= (GPIO_PIN_CNF_SENSE_High << GPIO_PIN_CNF_SENSE_Pos); } } } - } + } } } + #ifdef __cplusplus } -#endif +#endif -int gpio_irq_init(gpio_irq_t *obj, PinName pin, gpio_irq_handler handler, uint32_t id) { +int gpio_irq_init(gpio_irq_t *obj, PinName pin, gpio_irq_handler handler, uint32_t id) +{ if (pin == NC) { return -1; } - - irq_handler = handler; - obj->ch = pin; - NRF_GPIOTE->EVENTS_PORT = 0; - channel_ids[pin] = id; - channel_enabled[pin] = 1; - NRF_GPIOTE->INTENSET = GPIOTE_INTENSET_PORT_Set<ch = pin; + NRF_GPIOTE->EVENTS_PORT = 0; + channel_ids[pin] = id; + channel_enabled[pin] = 1; + NRF_GPIOTE->INTENSET = GPIOTE_INTENSET_PORT_Set << GPIOTE_INTENSET_PORT_Pos; + NVIC_SetPriority(GPIOTE_IRQn, 3); - NVIC_EnableIRQ (GPIOTE_IRQn); + NVIC_EnableIRQ (GPIOTE_IRQn); return 0; } -void gpio_irq_free(gpio_irq_t *obj) { +void gpio_irq_free(gpio_irq_t *obj) +{ channel_ids[obj->ch] = 0; } -void gpio_irq_set(gpio_irq_t *obj, gpio_irq_event event, uint32_t enable) { +void gpio_irq_set(gpio_irq_t *obj, gpio_irq_event event, uint32_t enable) +{ NRF_GPIO->PIN_CNF[obj->ch] &= ~(GPIO_PIN_CNF_SENSE_Msk); - if(enable){ - if(event == IRQ_RISE){ - portRISE |= (1<ch); + if (enable) { + if (event == IRQ_RISE) { + portRISE |= (1 << obj->ch); + } else if (event == IRQ_FALL) { + portFALL |= (1 << obj->ch); } - else if(event == IRQ_FALL){ - portFALL |= (1<ch); - } - } - else{ - if(event == IRQ_RISE){ - portRISE &= ~(1<ch); + } else { + if (event == IRQ_RISE) { + portRISE &= ~(1 << obj->ch); + } else if (event == IRQ_FALL) { + portFALL &= ~(1 << obj->ch); } - else if(event == IRQ_FALL){ - portFALL &= ~(1<ch); - } - - } - - if( ( (portRISE>>obj->ch) & 1) || ( (portFALL>>obj->ch) & 1) ){ - if((NRF_GPIO->IN>>obj->ch)&1){ - NRF_GPIO->PIN_CNF[obj->ch] |= (GPIO_PIN_CNF_SENSE_Low << GPIO_PIN_CNF_SENSE_Pos);// | (GPIO_PIN_CNF_PULL_Disabled << GPIO_PIN_CNF_PULL_Pos); - } - else{ - NRF_GPIO->PIN_CNF[obj->ch] |= (GPIO_PIN_CNF_SENSE_High << GPIO_PIN_CNF_SENSE_Pos) ;//| (GPIO_PIN_CNF_PULL_Disabled << GPIO_PIN_CNF_PULL_Pos); + } + + if (((portRISE >> obj->ch) & 1) || ((portFALL >> obj->ch) & 1)) { + if ((NRF_GPIO->IN >> obj->ch) & 1) { + NRF_GPIO->PIN_CNF[obj->ch] |= (GPIO_PIN_CNF_SENSE_Low << GPIO_PIN_CNF_SENSE_Pos); // | (GPIO_PIN_CNF_PULL_Disabled << GPIO_PIN_CNF_PULL_Pos); + } else { + NRF_GPIO->PIN_CNF[obj->ch] |= (GPIO_PIN_CNF_SENSE_High << GPIO_PIN_CNF_SENSE_Pos); //| (GPIO_PIN_CNF_PULL_Disabled << GPIO_PIN_CNF_PULL_Pos); } } } -void gpio_irq_enable(gpio_irq_t *obj) { +void gpio_irq_enable(gpio_irq_t *obj) +{ channel_enabled[obj->ch] = 1; } -void gpio_irq_disable(gpio_irq_t *obj) { +void gpio_irq_disable(gpio_irq_t *obj) +{ channel_enabled[obj->ch] = 0; } diff --git a/libraries/mbed/targets/hal/TARGET_NORDIC/TARGET_MCU_NRF51822/i2c_api.c b/libraries/mbed/targets/hal/TARGET_NORDIC/TARGET_MCU_NRF51822/i2c_api.c index f1c704272f0..30f8ad453c9 100644 --- a/libraries/mbed/targets/hal/TARGET_NORDIC/TARGET_MCU_NRF51822/i2c_api.c +++ b/libraries/mbed/targets/hal/TARGET_NORDIC/TARGET_MCU_NRF51822/i2c_api.c @@ -21,175 +21,187 @@ static const PinMap PinMap_I2C_SDA[] = { {p22, I2C_0, 1}, {p13, I2C_1, 2}, - {NC , NC , 0} + {NC, NC, 0} }; static const PinMap PinMap_I2C_SCL[] = { {p20, I2C_0, 1}, {p15, I2C_1, 2}, - {NC , NC, 0} + {NC, NC, 0} }; -uint8_t addrSet=0; +uint8_t addrSet = 0; -void i2c_interface_enable(i2c_t *obj){ +void i2c_interface_enable(i2c_t *obj) +{ obj->i2c->ENABLE = (TWI_ENABLE_ENABLE_Enabled << TWI_ENABLE_ENABLE_Pos); } -void twi_master_init(i2c_t *obj, PinName sda, PinName scl, int frequency) { - NRF_GPIO->PIN_CNF[scl] = ((GPIO_PIN_CNF_DIR_Input << GPIO_PIN_CNF_DIR_Pos) | - (GPIO_PIN_CNF_INPUT_Connect << GPIO_PIN_CNF_INPUT_Pos) | - (GPIO_PIN_CNF_PULL_Disabled << GPIO_PIN_CNF_PULL_Pos) | - (GPIO_PIN_CNF_DRIVE_S0D1 << GPIO_PIN_CNF_DRIVE_Pos) | - (GPIO_PIN_CNF_SENSE_Disabled << GPIO_PIN_CNF_SENSE_Pos)); - - NRF_GPIO->PIN_CNF[sda] = ((GPIO_PIN_CNF_DIR_Input << GPIO_PIN_CNF_DIR_Pos) | - (GPIO_PIN_CNF_INPUT_Connect << GPIO_PIN_CNF_INPUT_Pos) | - (GPIO_PIN_CNF_PULL_Disabled << GPIO_PIN_CNF_PULL_Pos) | - (GPIO_PIN_CNF_DRIVE_S0D1 << GPIO_PIN_CNF_DRIVE_Pos) | - (GPIO_PIN_CNF_SENSE_Disabled << GPIO_PIN_CNF_SENSE_Pos)); - - obj->i2c->PSELSCL = scl; - obj->i2c->PSELSDA = sda; +void twi_master_init(i2c_t *obj, PinName sda, PinName scl, int frequency) +{ + NRF_GPIO->PIN_CNF[scl] = ((GPIO_PIN_CNF_DIR_Input << GPIO_PIN_CNF_DIR_Pos) | + (GPIO_PIN_CNF_INPUT_Connect << GPIO_PIN_CNF_INPUT_Pos) | + (GPIO_PIN_CNF_PULL_Disabled << GPIO_PIN_CNF_PULL_Pos) | + (GPIO_PIN_CNF_DRIVE_S0D1 << GPIO_PIN_CNF_DRIVE_Pos) | + (GPIO_PIN_CNF_SENSE_Disabled << GPIO_PIN_CNF_SENSE_Pos)); + + NRF_GPIO->PIN_CNF[sda] = ((GPIO_PIN_CNF_DIR_Input << GPIO_PIN_CNF_DIR_Pos) | + (GPIO_PIN_CNF_INPUT_Connect << GPIO_PIN_CNF_INPUT_Pos) | + (GPIO_PIN_CNF_PULL_Disabled << GPIO_PIN_CNF_PULL_Pos) | + (GPIO_PIN_CNF_DRIVE_S0D1 << GPIO_PIN_CNF_DRIVE_Pos) | + (GPIO_PIN_CNF_SENSE_Disabled << GPIO_PIN_CNF_SENSE_Pos)); + + obj->i2c->PSELSCL = scl; + obj->i2c->PSELSDA = sda; // set default frequency at 100k i2c_frequency(obj, frequency); i2c_interface_enable(obj); } -void i2c_init(i2c_t *obj, PinName sda, PinName scl) { + +void i2c_init(i2c_t *obj, PinName sda, PinName scl) +{ // determine the SPI to use I2CName i2c_sda = (I2CName)pinmap_peripheral(sda, PinMap_I2C_SDA); I2CName i2c_scl = (I2CName)pinmap_peripheral(scl, PinMap_I2C_SCL); - I2CName i2c = (I2CName)pinmap_merge(i2c_sda,i2c_scl); - obj->i2c = (NRF_TWI_Type *)i2c; - + I2CName i2c = (I2CName)pinmap_merge(i2c_sda, i2c_scl); + obj->i2c = (NRF_TWI_Type *)i2c; + MBED_ASSERT((int)obj->i2c != NC); - obj->scl=scl; - obj->sda=sda; + obj->scl = scl; + obj->sda = sda; obj->i2c->EVENTS_ERROR = 0; obj->i2c->ENABLE = TWI_ENABLE_ENABLE_Disabled << TWI_ENABLE_ENABLE_Pos; obj->i2c->POWER = 0; - - for(int i=0;i<100;i++){ + + for (int i = 0; i<100; i++) { } - - obj->i2c->POWER = 1; - twi_master_init(obj,sda,scl,100000); + + obj->i2c->POWER = 1; + twi_master_init(obj, sda, scl, 100000); } -void i2c_reset(i2c_t *obj) { + +void i2c_reset(i2c_t *obj) +{ obj->i2c->EVENTS_ERROR = 0; obj->i2c->ENABLE = TWI_ENABLE_ENABLE_Disabled << TWI_ENABLE_ENABLE_Pos; obj->i2c->POWER = 0; - for(int i=0;i<100;i++){ + for (int i = 0; i<100; i++) { } - - obj->i2c->POWER = 1; - twi_master_init(obj,obj->sda,obj->scl,obj->freq); + + obj->i2c->POWER = 1; + twi_master_init(obj, obj->sda, obj->scl, obj->freq); } -int i2c_start(i2c_t *obj) { +int i2c_start(i2c_t *obj) +{ int status = 0; i2c_reset(obj); - addrSet=0; + addrSet = 0; return status; } -int i2c_stop(i2c_t *obj) { +int i2c_stop(i2c_t *obj) +{ int timeOut = 100000; obj->i2c->EVENTS_STOPPED = 0; // write the stop bit obj->i2c->TASKS_STOP = 1; - while(!obj->i2c->EVENTS_STOPPED){ + while (!obj->i2c->EVENTS_STOPPED) { timeOut--; - if(timeOut<0) + if (timeOut<0) { return 1; + } } addrSet = 0; i2c_reset(obj); return 0; } - -int i2c_do_write(i2c_t *obj, int value) { +int i2c_do_write(i2c_t *obj, int value) +{ int timeOut = 100000; obj->i2c->TXD = value; - while(!obj->i2c->EVENTS_TXDSENT){ + while (!obj->i2c->EVENTS_TXDSENT) { timeOut--; - if(timeOut<0) + if (timeOut<0) { return 1; + } } obj->i2c->EVENTS_TXDSENT = 0; return 0; } -int i2c_do_read(i2c_t *obj, char * data, int last) { +int i2c_do_read(i2c_t *obj, char *data, int last) +{ int timeOut = 100000; - if (last){ + if (last) { obj->i2c->TASKS_STOP = 1; } - while(!obj->i2c->EVENTS_RXDREADY){ + while (!obj->i2c->EVENTS_RXDREADY) { timeOut--; - if(timeOut<0) + if (timeOut<0) { return 1; + } } - obj->i2c->EVENTS_RXDREADY = 0; - + obj->i2c->EVENTS_RXDREADY = 0; + *data = obj->i2c->RXD; - - for(int i=0;i<320;i++){ + + for (int i = 0; i<320; i++) { } - + obj->i2c->TASKS_RESUME = 1; - + return 0; } - -void i2c_frequency(i2c_t *obj, int hz) { - if(hz<250000){ +void i2c_frequency(i2c_t *obj, int hz) +{ + if (hz<250000) { obj->freq = 100000; obj->i2c->FREQUENCY = (TWI_FREQUENCY_FREQUENCY_K100 << TWI_FREQUENCY_FREQUENCY_Pos); - } - else if(hz<400000){ + } else if (hz<400000) { obj->freq = 250000; obj->i2c->FREQUENCY = (TWI_FREQUENCY_FREQUENCY_K250 << TWI_FREQUENCY_FREQUENCY_Pos); - } - else{ + } else { obj->freq = 400000; obj->i2c->FREQUENCY = (TWI_FREQUENCY_FREQUENCY_K400 << TWI_FREQUENCY_FREQUENCY_Pos); } } -int checkError(i2c_t *obj){ - if (obj->i2c->EVENTS_ERROR == 1){ - if (obj->i2c->ERRORSRC & TWI_ERRORSRC_ANACK_Msk){ - obj->i2c->EVENTS_ERROR = 0; - obj->i2c->TASKS_STOP = 1; +int checkError(i2c_t *obj) +{ + if (obj->i2c->EVENTS_ERROR == 1) { + if (obj->i2c->ERRORSRC & TWI_ERRORSRC_ANACK_Msk) { + obj->i2c->EVENTS_ERROR = 0; + obj->i2c->TASKS_STOP = 1; return I2C_ERROR_BUS_BUSY; } - - obj->i2c->EVENTS_ERROR = 0; - obj->i2c->TASKS_STOP = 1; + + obj->i2c->EVENTS_ERROR = 0; + obj->i2c->TASKS_STOP = 1; return I2C_ERROR_NO_SLAVE; } return 0; } -int i2c_read(i2c_t *obj, int address, char *data, int length, int stop) { - int status,count,errorResult; - obj->i2c->ADDRESS = (address>>1); +int i2c_read(i2c_t *obj, int address, char *data, int length, int stop) +{ + int status, count, errorResult; + obj->i2c->ADDRESS = (address >> 1); obj->i2c->SHORTS = 0; obj->i2c->EVENTS_RXDREADY = 0; obj->i2c->TASKS_STARTRX = 1; - + // Read in all except last byte for (count = 0; count < (length - 1); count++) { - status = i2c_do_read(obj,&data[count], 0); + status = i2c_do_read(obj, &data[count], 0); if (status) { errorResult = checkError(obj); i2c_reset(obj); - if(errorResult<0){ + if (errorResult<0) { return errorResult; } return count; @@ -197,77 +209,78 @@ int i2c_read(i2c_t *obj, int address, char *data, int length, int stop) { } // read in last byte - status = i2c_do_read(obj,&data[length-1], 1); + status = i2c_do_read(obj, &data[length - 1], 1); if (status) { i2c_reset(obj); return length - 1; } // If not repeated start, send stop. if (stop) { - while(!obj->i2c->EVENTS_STOPPED){ + while (!obj->i2c->EVENTS_STOPPED) { } obj->i2c->EVENTS_STOPPED = 0; } return length; } -int i2c_write(i2c_t *obj, int address, const char *data, int length, int stop) { +int i2c_write(i2c_t *obj, int address, const char *data, int length, int stop) +{ int status, errorResult; - obj->i2c->ADDRESS = (address>>1); + obj->i2c->ADDRESS = (address >> 1); obj->i2c->SHORTS = 0; obj->i2c->TASKS_STARTTX = 1; - - for (int i=0; ii2c->ADDRESS = (data>>1); - - if(data&1){ + if (!addrSet) { + addrSet = 1; + obj->i2c->ADDRESS = (data >> 1); + + if (data & 1) { obj->i2c->EVENTS_RXDREADY = 0; obj->i2c->TASKS_STARTRX = 1; + } else { + obj->i2c->TASKS_STARTTX = 1; } - else{ - obj->i2c->TASKS_STARTTX = 1; - } - } - else{ + } else { status = i2c_do_write(obj, data); - if(status) { + if (status) { i2c_reset(obj); } } - return (1-status); + return (1 - status); } diff --git a/libraries/mbed/targets/hal/TARGET_NORDIC/TARGET_MCU_NRF51822/pinmap.c b/libraries/mbed/targets/hal/TARGET_NORDIC/TARGET_MCU_NRF51822/pinmap.c index 9176da9e364..44ca32c0392 100644 --- a/libraries/mbed/targets/hal/TARGET_NORDIC/TARGET_MCU_NRF51822/pinmap.c +++ b/libraries/mbed/targets/hal/TARGET_NORDIC/TARGET_MCU_NRF51822/pinmap.c @@ -17,14 +17,16 @@ #include "pinmap.h" #include "mbed_error.h" -void pin_function(PinName pin, int function) { +void pin_function(PinName pin, int function) +{ } -void pin_mode(PinName pin, PinMode mode) { +void pin_mode(PinName pin, PinMode mode) +{ MBED_ASSERT(pin != (PinName)NC); - + uint32_t pin_number = (uint32_t)pin; - + NRF_GPIO->PIN_CNF[pin_number] &= ~GPIO_PIN_CNF_PULL_Msk; NRF_GPIO->PIN_CNF[pin_number] |= (mode << GPIO_PIN_CNF_PULL_Pos); } diff --git a/libraries/mbed/targets/hal/TARGET_NORDIC/TARGET_MCU_NRF51822/port_api.c b/libraries/mbed/targets/hal/TARGET_NORDIC/TARGET_MCU_NRF51822/port_api.c index d1c87afba0a..1c9a69c1394 100644 --- a/libraries/mbed/targets/hal/TARGET_NORDIC/TARGET_MCU_NRF51822/port_api.c +++ b/libraries/mbed/targets/hal/TARGET_NORDIC/TARGET_MCU_NRF51822/port_api.c @@ -17,62 +17,68 @@ #include "pinmap.h" #include "gpio_api.h" -PinName port_pin(PortName port, int pin_n) { +PinName port_pin(PortName port, int pin_n) +{ return (PinName)(pin_n); } -void port_init(port_t *obj, PortName port, int mask, PinDirection dir) { +void port_init(port_t *obj, PortName port, int mask, PinDirection dir) +{ obj->port = port; - obj->mask = mask; - + obj->mask = mask; + obj->reg_out = &NRF_GPIO->OUT; obj->reg_in = &NRF_GPIO->IN; obj->reg_cnf = NRF_GPIO->PIN_CNF; - + port_dir(obj, dir); } -void port_mode(port_t *obj, PinMode mode) { +void port_mode(port_t *obj, PinMode mode) +{ uint32_t i; // The mode is set per pin: reuse pinmap logic - for (i=0; i<31; i++) { - if (obj->mask & (1<mask & (1 << i)) { pin_mode(port_pin(obj->port, i), mode); } } } -void port_dir(port_t *obj, PinDirection dir) { +void port_dir(port_t *obj, PinDirection dir) +{ int i; switch (dir) { - case PIN_INPUT : - for (i=0; i<31; i++) { - if (obj->mask & (1<reg_cnf[i] = (GPIO_PIN_CNF_SENSE_Disabled << GPIO_PIN_CNF_SENSE_Pos) - | (GPIO_PIN_CNF_DRIVE_S0S1 << GPIO_PIN_CNF_DRIVE_Pos) - | (GPIO_PIN_CNF_INPUT_Connect << GPIO_PIN_CNF_INPUT_Pos) - | (GPIO_PIN_CNF_DIR_Input << GPIO_PIN_CNF_DIR_Pos); + case PIN_INPUT: + for (i = 0; i<31; i++) { + if (obj->mask & (1 << i)) { + obj->reg_cnf[i] = (GPIO_PIN_CNF_SENSE_Disabled << GPIO_PIN_CNF_SENSE_Pos) | + (GPIO_PIN_CNF_DRIVE_S0S1 << GPIO_PIN_CNF_DRIVE_Pos) | + (GPIO_PIN_CNF_INPUT_Connect << GPIO_PIN_CNF_INPUT_Pos) | + (GPIO_PIN_CNF_DIR_Input << GPIO_PIN_CNF_DIR_Pos); } } break; - case PIN_OUTPUT: - for (i=0; i<31; i++) { - if (obj->mask & (1<reg_cnf[i] = (GPIO_PIN_CNF_SENSE_Disabled << GPIO_PIN_CNF_SENSE_Pos) - | (GPIO_PIN_CNF_DRIVE_S0S1 << GPIO_PIN_CNF_DRIVE_Pos) - | (GPIO_PIN_CNF_PULL_Disabled << GPIO_PIN_CNF_PULL_Pos) - | (GPIO_PIN_CNF_INPUT_Connect << GPIO_PIN_CNF_INPUT_Pos) - | (GPIO_PIN_CNF_DIR_Output << GPIO_PIN_CNF_DIR_Pos); + case PIN_OUTPUT: + for (i = 0; i<31; i++) { + if (obj->mask & (1 << i)) { + obj->reg_cnf[i] = (GPIO_PIN_CNF_SENSE_Disabled << GPIO_PIN_CNF_SENSE_Pos) | + (GPIO_PIN_CNF_DRIVE_S0S1 << GPIO_PIN_CNF_DRIVE_Pos) | + (GPIO_PIN_CNF_PULL_Disabled << GPIO_PIN_CNF_PULL_Pos) | + (GPIO_PIN_CNF_INPUT_Connect << GPIO_PIN_CNF_INPUT_Pos) | + (GPIO_PIN_CNF_DIR_Output << GPIO_PIN_CNF_DIR_Pos); } } break; } } -void port_write(port_t *obj, int value) { +void port_write(port_t *obj, int value) +{ *obj->reg_out = value; } -int port_read(port_t *obj) { +int port_read(port_t *obj) +{ return (*obj->reg_in); } diff --git a/libraries/mbed/targets/hal/TARGET_NORDIC/TARGET_MCU_NRF51822/pwmout_api.c b/libraries/mbed/targets/hal/TARGET_NORDIC/TARGET_MCU_NRF51822/pwmout_api.c index cc5ae6129bf..c7a45127c11 100644 --- a/libraries/mbed/targets/hal/TARGET_NORDIC/TARGET_MCU_NRF51822/pwmout_api.c +++ b/libraries/mbed/targets/hal/TARGET_NORDIC/TARGET_MCU_NRF51822/pwmout_api.c @@ -20,7 +20,7 @@ #include "mbed_error.h" #define NO_PWMS 3 -#define TIMER_PRECISION 4 //4us ticks +#define TIMER_PRECISION 4 //4us ticks #define TIMER_PRESCALER 6 //4us ticks = 16Mhz/(2**6) static const PinMap PinMap_PWM[] = { {p0, PWM_1, 1}, @@ -59,285 +59,287 @@ static NRF_TIMER_Type *Timers[1] = { NRF_TIMER2 }; -uint16_t PERIOD = 20000/TIMER_PRECISION;//20ms -uint8_t PWM_taken[NO_PWMS] = {0,0,0}; -uint16_t PULSE_WIDTH[NO_PWMS] = {1,1,1};//set to 1 instead of 0 -uint16_t ACTUAL_PULSE[NO_PWMS] = {0,0,0}; +uint16_t PERIOD = 20000 / TIMER_PRECISION; //20ms +uint8_t PWM_taken[NO_PWMS] = {0, 0, 0}; +uint16_t PULSE_WIDTH[NO_PWMS] = {1, 1, 1}; //set to 1 instead of 0 +uint16_t ACTUAL_PULSE[NO_PWMS] = {0, 0, 0}; /** @brief Function for handling timer 2 peripheral interrupts. */ - #ifdef __cplusplus +#ifdef __cplusplus extern "C" { -#endif +#endif void TIMER2_IRQHandler(void) { NRF_TIMER2->EVENTS_COMPARE[3] = 0; - NRF_TIMER2->CC[3] = PERIOD; - - if(PWM_taken[0]){ - NRF_TIMER2->CC[0] = PULSE_WIDTH[0]; + NRF_TIMER2->CC[3] = PERIOD; + + if (PWM_taken[0]) { + NRF_TIMER2->CC[0] = PULSE_WIDTH[0]; } - if(PWM_taken[1]){ - NRF_TIMER2->CC[1] = PULSE_WIDTH[1]; + if (PWM_taken[1]) { + NRF_TIMER2->CC[1] = PULSE_WIDTH[1]; } - if(PWM_taken[2]){ - NRF_TIMER2->CC[2] = PULSE_WIDTH[2]; + if (PWM_taken[2]) { + NRF_TIMER2->CC[2] = PULSE_WIDTH[2]; } - - NRF_TIMER2->TASKS_START = 1; + NRF_TIMER2->TASKS_START = 1; } + #ifdef __cplusplus } -#endif +#endif /** @brief Function for initializing the Timer peripherals. */ void timer_init(uint8_t pwmChoice) { NRF_TIMER_Type *timer = Timers[0]; timer->TASKS_STOP = 0; - - if(pwmChoice == 0){ + + if (pwmChoice == 0) { timer->POWER = 0; - timer->POWER = 1; - timer->MODE = TIMER_MODE_MODE_Timer; + timer->POWER = 1; + timer->MODE = TIMER_MODE_MODE_Timer; timer->BITMODE = TIMER_BITMODE_BITMODE_16Bit << TIMER_BITMODE_BITMODE_Pos; - timer->PRESCALER = TIMER_PRESCALER; + timer->PRESCALER = TIMER_PRESCALER; timer->CC[3] = PERIOD; } - + timer->CC[pwmChoice] = PULSE_WIDTH[pwmChoice]; - + //high priority application interrupt NVIC_SetPriority(TIMER2_IRQn, 1); NVIC_EnableIRQ(TIMER2_IRQn); - + timer->TASKS_START = 0x01; } + /** @brief Function for initializing the GPIO Tasks/Events peripheral. */ -void gpiote_init(PinName pin,uint8_t channel_number) +void gpiote_init(PinName pin, uint8_t channel_number) { // Connect GPIO input buffers and configure PWM_OUTPUT_PIN_NUMBER as an output. - NRF_GPIO->PIN_CNF[pin] = (GPIO_PIN_CNF_SENSE_Disabled << GPIO_PIN_CNF_SENSE_Pos) - | (GPIO_PIN_CNF_DRIVE_S0S1 << GPIO_PIN_CNF_DRIVE_Pos) - | (GPIO_PIN_CNF_PULL_Disabled << GPIO_PIN_CNF_PULL_Pos) - | (GPIO_PIN_CNF_INPUT_Connect << GPIO_PIN_CNF_INPUT_Pos) - | (GPIO_PIN_CNF_DIR_Output << GPIO_PIN_CNF_DIR_Pos); + NRF_GPIO->PIN_CNF[pin] = (GPIO_PIN_CNF_SENSE_Disabled << GPIO_PIN_CNF_SENSE_Pos) | + (GPIO_PIN_CNF_DRIVE_S0S1 << GPIO_PIN_CNF_DRIVE_Pos) | + (GPIO_PIN_CNF_PULL_Disabled << GPIO_PIN_CNF_PULL_Pos) | + (GPIO_PIN_CNF_INPUT_Connect << GPIO_PIN_CNF_INPUT_Pos) | + (GPIO_PIN_CNF_DIR_Output << GPIO_PIN_CNF_DIR_Pos); NRF_GPIO->OUTCLR = (1UL << pin); // Configure GPIOTE channel 0 to toggle the PWM pin state // @note Only one GPIOTE task can be connected to an output pin. /* Configure channel to Pin31, not connected to the pin, and configure as a tasks that will set it to proper level */ - NRF_GPIOTE->CONFIG[channel_number] = (GPIOTE_CONFIG_MODE_Task << GPIOTE_CONFIG_MODE_Pos) | - (31UL << GPIOTE_CONFIG_PSEL_Pos) | + NRF_GPIOTE->CONFIG[channel_number] = (GPIOTE_CONFIG_MODE_Task << GPIOTE_CONFIG_MODE_Pos) | + (31UL << GPIOTE_CONFIG_PSEL_Pos) | (GPIOTE_CONFIG_POLARITY_HiToLo << GPIOTE_CONFIG_POLARITY_Pos); - /* Three NOPs are required to make sure configuration is written before setting tasks or getting events */ + /* Three NOPs are required to make sure configuration is written before setting tasks or getting events */ + __NOP(); __NOP(); __NOP(); - __NOP(); /* Launch the task to take the GPIOTE channel output to the desired level */ NRF_GPIOTE->TASKS_OUT[channel_number] = 1; - - /* Finally configure the channel as the caller expects. If OUTINIT works, the channel is configured properly. + + /* Finally configure the channel as the caller expects. If OUTINIT works, the channel is configured properly. If it does not, the channel output inheritance sets the proper level. */ - NRF_GPIOTE->CONFIG[channel_number] = (GPIOTE_CONFIG_MODE_Task << GPIOTE_CONFIG_MODE_Pos) | - ((uint32_t)pin << GPIOTE_CONFIG_PSEL_Pos) | - ((uint32_t)GPIOTE_CONFIG_POLARITY_Toggle << GPIOTE_CONFIG_POLARITY_Pos) | - ((uint32_t)GPIOTE_CONFIG_OUTINIT_Low << GPIOTE_CONFIG_OUTINIT_Pos);// ((uint32_t)GPIOTE_CONFIG_OUTINIT_High << GPIOTE_CONFIG_OUTINIT_Pos);// + NRF_GPIOTE->CONFIG[channel_number] = (GPIOTE_CONFIG_MODE_Task << GPIOTE_CONFIG_MODE_Pos) | + ((uint32_t)pin << GPIOTE_CONFIG_PSEL_Pos) | + ((uint32_t)GPIOTE_CONFIG_POLARITY_Toggle << GPIOTE_CONFIG_POLARITY_Pos) | + ((uint32_t)GPIOTE_CONFIG_OUTINIT_Low << GPIOTE_CONFIG_OUTINIT_Pos); // ((uint32_t)GPIOTE_CONFIG_OUTINIT_High << + // GPIOTE_CONFIG_OUTINIT_Pos);// /* Three NOPs are required to make sure configuration is written before setting tasks or getting events */ __NOP(); __NOP(); - __NOP(); + __NOP(); } + /** @brief Function for initializing the Programmable Peripheral Interconnect peripheral. */ static void ppi_init(uint8_t pwm) { -//using ppi channels 0-7 (only 0-7 are available) - uint8_t channel_number = 2*pwm; - NRF_TIMER_Type *timer = Timers[0]; - + //using ppi channels 0-7 (only 0-7 are available) + uint8_t channel_number = 2 * pwm; + NRF_TIMER_Type *timer = Timers[0]; + // Configure PPI channel 0 to toggle ADVERTISING_LED_PIN_NO on every TIMER1 COMPARE[0] match NRF_PPI->CH[channel_number].TEP = (uint32_t)&NRF_GPIOTE->TASKS_OUT[pwm]; - NRF_PPI->CH[channel_number+1].TEP = (uint32_t)&NRF_GPIOTE->TASKS_OUT[pwm]; - NRF_PPI->CH[channel_number].EEP = (uint32_t)&timer->EVENTS_COMPARE[pwm]; - NRF_PPI->CH[channel_number+1].EEP = (uint32_t)&timer->EVENTS_COMPARE[3]; - + NRF_PPI->CH[channel_number + 1].TEP = (uint32_t)&NRF_GPIOTE->TASKS_OUT[pwm]; + NRF_PPI->CH[channel_number].EEP = (uint32_t)&timer->EVENTS_COMPARE[pwm]; + NRF_PPI->CH[channel_number + 1].EEP = (uint32_t)&timer->EVENTS_COMPARE[3]; + // Enable PPI channels. - NRF_PPI->CHEN |= (1 << channel_number) - | (1 << (channel_number+1)); + NRF_PPI->CHEN |= (1 << channel_number) | + (1 << (channel_number + 1)); } -void setModulation(pwmout_t* obj,uint8_t toggle,uint8_t high) +void setModulation(pwmout_t *obj, uint8_t toggle, uint8_t high) { - if(high){ + if (high) { NRF_GPIOTE->CONFIG[obj->pwm] |= ((uint32_t)GPIOTE_CONFIG_OUTINIT_High << GPIOTE_CONFIG_OUTINIT_Pos); - if(toggle){ - NRF_GPIOTE->CONFIG[obj->pwm] |= (GPIOTE_CONFIG_MODE_Task << GPIOTE_CONFIG_MODE_Pos) | - ((uint32_t)GPIOTE_CONFIG_POLARITY_Toggle << GPIOTE_CONFIG_POLARITY_Pos); - } - else{ - NRF_GPIOTE->CONFIG[obj->pwm] &= ~((uint32_t)GPIOTE_CONFIG_POLARITY_Toggle << GPIOTE_CONFIG_POLARITY_Pos); - NRF_GPIOTE->CONFIG[obj->pwm] |= ((uint32_t)GPIOTE_CONFIG_POLARITY_LoToHi << GPIOTE_CONFIG_POLARITY_Pos); + if (toggle) { + NRF_GPIOTE->CONFIG[obj->pwm] |= (GPIOTE_CONFIG_MODE_Task << GPIOTE_CONFIG_MODE_Pos) | + ((uint32_t)GPIOTE_CONFIG_POLARITY_Toggle << GPIOTE_CONFIG_POLARITY_Pos); + } else { + NRF_GPIOTE->CONFIG[obj->pwm] &= ~((uint32_t)GPIOTE_CONFIG_POLARITY_Toggle << GPIOTE_CONFIG_POLARITY_Pos); + NRF_GPIOTE->CONFIG[obj->pwm] |= ((uint32_t)GPIOTE_CONFIG_POLARITY_LoToHi << GPIOTE_CONFIG_POLARITY_Pos); } - } - else{ + } else { NRF_GPIOTE->CONFIG[obj->pwm] &= ~((uint32_t)GPIOTE_CONFIG_OUTINIT_High << GPIOTE_CONFIG_OUTINIT_Pos); - - if(toggle){ - NRF_GPIOTE->CONFIG[obj->pwm] |= (GPIOTE_CONFIG_MODE_Task << GPIOTE_CONFIG_MODE_Pos) | - ((uint32_t)GPIOTE_CONFIG_POLARITY_Toggle << GPIOTE_CONFIG_POLARITY_Pos); - } - else{ - NRF_GPIOTE->CONFIG[obj->pwm] &= ~((uint32_t)GPIOTE_CONFIG_POLARITY_Toggle << GPIOTE_CONFIG_POLARITY_Pos); - NRF_GPIOTE->CONFIG[obj->pwm] |= ((uint32_t)GPIOTE_CONFIG_POLARITY_HiToLo << GPIOTE_CONFIG_POLARITY_Pos); + + if (toggle) { + NRF_GPIOTE->CONFIG[obj->pwm] |= (GPIOTE_CONFIG_MODE_Task << GPIOTE_CONFIG_MODE_Pos) | + ((uint32_t)GPIOTE_CONFIG_POLARITY_Toggle << GPIOTE_CONFIG_POLARITY_Pos); + } else { + NRF_GPIOTE->CONFIG[obj->pwm] &= ~((uint32_t)GPIOTE_CONFIG_POLARITY_Toggle << GPIOTE_CONFIG_POLARITY_Pos); + NRF_GPIOTE->CONFIG[obj->pwm] |= ((uint32_t)GPIOTE_CONFIG_POLARITY_HiToLo << GPIOTE_CONFIG_POLARITY_Pos); } } } -void pwmout_init(pwmout_t* obj, PinName pin) { + +void pwmout_init(pwmout_t *obj, PinName pin) +{ // determine the channel uint8_t pwmOutSuccess = 0; - PWMName pwm = (PWMName)pinmap_peripheral(pin, PinMap_PWM); - + PWMName pwm = (PWMName)pinmap_peripheral(pin, PinMap_PWM); + MBED_ASSERT(pwm != (PWMName)NC); - - if(PWM_taken[(uint8_t)pwm]){ - for(uint8_t i = 1; !pwmOutSuccess && (ipwm = pwm; obj->pin = pin; - - gpiote_init(pin,(uint8_t)pwm); + + gpiote_init(pin, (uint8_t)pwm); ppi_init((uint8_t)pwm); - - if(pwm == 0){ + + if (pwm == 0) { NRF_POWER->TASKS_CONSTLAT = 1; } - + timer_init((uint8_t)pwm); - + //default to 20ms: standard for servos, and fine for e.g. brightness control pwmout_period_ms(obj, 20); pwmout_write (obj, 0); - } -void pwmout_free(pwmout_t* obj) { +void pwmout_free(pwmout_t *obj) +{ // [TODO] } -void pwmout_write(pwmout_t* obj, float value) { +void pwmout_write(pwmout_t *obj, float value) +{ uint16_t oldPulseWidth; - + NRF_TIMER2->EVENTS_COMPARE[3] = 0; - NRF_TIMER2->TASKS_STOP = 1; - + NRF_TIMER2->TASKS_STOP = 1; + if (value < 0.0f) { value = 0.0; } else if (value > 1.0f) { value = 1.0; - } - - oldPulseWidth = ACTUAL_PULSE[obj->pwm]; - ACTUAL_PULSE[obj->pwm] = PULSE_WIDTH[obj->pwm] = value* PERIOD; - - if(PULSE_WIDTH[obj->pwm] == 0){ - PULSE_WIDTH[obj->pwm] = 1; - setModulation(obj,0,0); } - else if(PULSE_WIDTH[obj->pwm] == PERIOD){ - PULSE_WIDTH[obj->pwm] = PERIOD-1; - setModulation(obj,0,1); + + oldPulseWidth = ACTUAL_PULSE[obj->pwm]; + ACTUAL_PULSE[obj->pwm] = PULSE_WIDTH[obj->pwm] = value * PERIOD; + + if (PULSE_WIDTH[obj->pwm] == 0) { + PULSE_WIDTH[obj->pwm] = 1; + setModulation(obj, 0, 0); + } else if (PULSE_WIDTH[obj->pwm] == PERIOD) { + PULSE_WIDTH[obj->pwm] = PERIOD - 1; + setModulation(obj, 0, 1); + } else if ((oldPulseWidth == 0) || (oldPulseWidth == PERIOD)) { + setModulation(obj, 1, oldPulseWidth == PERIOD); } - else if( (oldPulseWidth == 0) || (oldPulseWidth == PERIOD) ){ - setModulation(obj,1,oldPulseWidth == PERIOD); - } - - NRF_TIMER2->INTENSET = TIMER_INTENSET_COMPARE3_Msk; - NRF_TIMER2->SHORTS = TIMER_SHORTS_COMPARE3_CLEAR_Msk | TIMER_SHORTS_COMPARE3_STOP_Msk; + + NRF_TIMER2->INTENSET = TIMER_INTENSET_COMPARE3_Msk; + NRF_TIMER2->SHORTS = TIMER_SHORTS_COMPARE3_CLEAR_Msk | TIMER_SHORTS_COMPARE3_STOP_Msk; NRF_TIMER2->TASKS_START = 1; } -float pwmout_read(pwmout_t* obj) { - return ((float)PULSE_WIDTH[obj->pwm]/(float)PERIOD); +float pwmout_read(pwmout_t *obj) +{ + return ((float)PULSE_WIDTH[obj->pwm] / (float)PERIOD); } -void pwmout_period(pwmout_t* obj, float seconds) { +void pwmout_period(pwmout_t *obj, float seconds) +{ pwmout_period_us(obj, seconds * 1000000.0f); } -void pwmout_period_ms(pwmout_t* obj, int ms) { +void pwmout_period_ms(pwmout_t *obj, int ms) +{ pwmout_period_us(obj, ms * 1000); } // Set the PWM period, keeping the duty cycle the same. -void pwmout_period_us(pwmout_t* obj, int us) { - uint32_t periodInTicks = us/TIMER_PRECISION; - +void pwmout_period_us(pwmout_t *obj, int us) +{ + uint32_t periodInTicks = us / TIMER_PRECISION; + NRF_TIMER2->EVENTS_COMPARE[3] = 0; - NRF_TIMER2->TASKS_STOP = 1; - - if(periodInTicks>((1<<16) -1)) - { - PERIOD = (1<<16 )-1;//131ms - } - else if(periodInTicks<5){ + NRF_TIMER2->TASKS_STOP = 1; + + if (periodInTicks>((1 << 16) - 1)) { + PERIOD = (1 << 16) - 1; //131ms + } else if (periodInTicks<5) { PERIOD = 5; + } else { + PERIOD = periodInTicks; } - else{ - PERIOD =periodInTicks; - } - NRF_TIMER2->INTENSET = TIMER_INTENSET_COMPARE3_Msk; - NRF_TIMER2->SHORTS = TIMER_SHORTS_COMPARE3_CLEAR_Msk | TIMER_SHORTS_COMPARE3_STOP_Msk; - NRF_TIMER2->TASKS_START = 1; + NRF_TIMER2->INTENSET = TIMER_INTENSET_COMPARE3_Msk; + NRF_TIMER2->SHORTS = TIMER_SHORTS_COMPARE3_CLEAR_Msk | TIMER_SHORTS_COMPARE3_STOP_Msk; + NRF_TIMER2->TASKS_START = 1; } -void pwmout_pulsewidth(pwmout_t* obj, float seconds) { +void pwmout_pulsewidth(pwmout_t *obj, float seconds) +{ pwmout_pulsewidth_us(obj, seconds * 1000000.0f); } -void pwmout_pulsewidth_ms(pwmout_t* obj, int ms) { +void pwmout_pulsewidth_ms(pwmout_t *obj, int ms) +{ pwmout_pulsewidth_us(obj, ms * 1000); } -void pwmout_pulsewidth_us(pwmout_t* obj, int us) { - uint32_t pulseInTicks = us/TIMER_PRECISION; +void pwmout_pulsewidth_us(pwmout_t *obj, int us) +{ + uint32_t pulseInTicks = us / TIMER_PRECISION; uint16_t oldPulseWidth = ACTUAL_PULSE[obj->pwm]; - + NRF_TIMER2->EVENTS_COMPARE[3] = 0; - NRF_TIMER2->TASKS_STOP = 1; - + NRF_TIMER2->TASKS_STOP = 1; + ACTUAL_PULSE[obj->pwm] = PULSE_WIDTH[obj->pwm] = pulseInTicks; - - if(PULSE_WIDTH[obj->pwm] == 0){ + + if (PULSE_WIDTH[obj->pwm] == 0) { PULSE_WIDTH[obj->pwm] = 1; - setModulation(obj,0,0); - } - else if(PULSE_WIDTH[obj->pwm] == PERIOD){ - PULSE_WIDTH[obj->pwm] = PERIOD-1; - setModulation(obj,0,1); + setModulation(obj, 0, 0); + } else if (PULSE_WIDTH[obj->pwm] == PERIOD) { + PULSE_WIDTH[obj->pwm] = PERIOD - 1; + setModulation(obj, 0, 1); + } else if ((oldPulseWidth == 0) || (oldPulseWidth == PERIOD)) { + setModulation(obj, 1, oldPulseWidth == PERIOD); } - else if( (oldPulseWidth == 0) || (oldPulseWidth == PERIOD) ){ - setModulation(obj,1,oldPulseWidth == PERIOD); - } - NRF_TIMER2->INTENSET = TIMER_INTENSET_COMPARE3_Msk; - NRF_TIMER2->SHORTS = TIMER_SHORTS_COMPARE3_CLEAR_Msk | TIMER_SHORTS_COMPARE3_STOP_Msk; - NRF_TIMER2->TASKS_START = 1; + NRF_TIMER2->INTENSET = TIMER_INTENSET_COMPARE3_Msk; + NRF_TIMER2->SHORTS = TIMER_SHORTS_COMPARE3_CLEAR_Msk | TIMER_SHORTS_COMPARE3_STOP_Msk; + NRF_TIMER2->TASKS_START = 1; } diff --git a/libraries/mbed/targets/hal/TARGET_NORDIC/TARGET_MCU_NRF51822/serial_api.c b/libraries/mbed/targets/hal/TARGET_NORDIC/TARGET_MCU_NRF51822/serial_api.c index 632182807d2..25c7df2de66 100644 --- a/libraries/mbed/targets/hal/TARGET_NORDIC/TARGET_MCU_NRF51822/serial_api.c +++ b/libraries/mbed/targets/hal/TARGET_NORDIC/TARGET_MCU_NRF51822/serial_api.c @@ -29,22 +29,22 @@ static uint32_t serial_irq_ids[UART_NUM] = {0}; static uart_irq_handler irq_handler; -static uint32_t acceptedSpeeds[16][2] = {{1200,UART_BAUDRATE_BAUDRATE_Baud1200}, - {2400,UART_BAUDRATE_BAUDRATE_Baud2400}, - {4800,UART_BAUDRATE_BAUDRATE_Baud4800}, - {9600,UART_BAUDRATE_BAUDRATE_Baud9600}, - {14400,UART_BAUDRATE_BAUDRATE_Baud14400}, - {19200,UART_BAUDRATE_BAUDRATE_Baud19200}, - {28800,UART_BAUDRATE_BAUDRATE_Baud28800}, - {38400,UART_BAUDRATE_BAUDRATE_Baud38400}, - {57600,UART_BAUDRATE_BAUDRATE_Baud57600}, - {76800,UART_BAUDRATE_BAUDRATE_Baud76800}, - {115200,UART_BAUDRATE_BAUDRATE_Baud115200}, - {230400,UART_BAUDRATE_BAUDRATE_Baud230400}, - {250000,UART_BAUDRATE_BAUDRATE_Baud250000}, - {460800,UART_BAUDRATE_BAUDRATE_Baud460800}, - {921600,UART_BAUDRATE_BAUDRATE_Baud921600}, - {1000000,UART_BAUDRATE_BAUDRATE_Baud1M}}; +static uint32_t acceptedSpeeds[16][2] = {{1200, UART_BAUDRATE_BAUDRATE_Baud1200}, + {2400, UART_BAUDRATE_BAUDRATE_Baud2400}, + {4800, UART_BAUDRATE_BAUDRATE_Baud4800}, + {9600, UART_BAUDRATE_BAUDRATE_Baud9600}, + {14400, UART_BAUDRATE_BAUDRATE_Baud14400}, + {19200, UART_BAUDRATE_BAUDRATE_Baud19200}, + {28800, UART_BAUDRATE_BAUDRATE_Baud28800}, + {38400, UART_BAUDRATE_BAUDRATE_Baud38400}, + {57600, UART_BAUDRATE_BAUDRATE_Baud57600}, + {76800, UART_BAUDRATE_BAUDRATE_Baud76800}, + {115200, UART_BAUDRATE_BAUDRATE_Baud115200}, + {230400, UART_BAUDRATE_BAUDRATE_Baud230400}, + {250000, UART_BAUDRATE_BAUDRATE_Baud250000}, + {460800, UART_BAUDRATE_BAUDRATE_Baud460800}, + {921600, UART_BAUDRATE_BAUDRATE_Baud921600}, + {1000000, UART_BAUDRATE_BAUDRATE_Baud1M}}; int stdio_uart_inited = 0; serial_t stdio_uart; @@ -52,78 +52,81 @@ serial_t stdio_uart; void serial_init(serial_t *obj, PinName tx, PinName rx) { UARTName uart = UART_0; - + MBED_ASSERT((int)uart != NC); - + obj->uart = (NRF_UART_Type *)uart; - + //pin configurations -- //outputs - NRF_GPIO->DIR |= (1<DIR |= (1<DIR |= (1 << tx); //TX_PIN_NUMBER); + NRF_GPIO->DIR |= (1 << RTS_PIN_NUMBER); + + NRF_GPIO->DIR &= ~(1 << rx); //RX_PIN_NUMBER); + NRF_GPIO->DIR &= ~(1 << CTS_PIN_NUMBER); - NRF_GPIO->DIR &= ~(1<DIR &= ~(1<uart->PSELRTS = RTS_PIN_NUMBER; - obj->uart->PSELTXD = tx;//TX_PIN_NUMBER; - + obj->uart->PSELTXD = tx; //TX_PIN_NUMBER; + //inputs obj->uart->PSELCTS = CTS_PIN_NUMBER; - obj->uart->PSELRXD = rx;//RX_PIN_NUMBER; - - + obj->uart->PSELRXD = rx; //RX_PIN_NUMBER; + + // set default baud rate and format serial_baud (obj, 9600); serial_format(obj, 8, ParityNone, 1); - - obj->uart->ENABLE = (UART_ENABLE_ENABLE_Enabled << UART_ENABLE_ENABLE_Pos);; + + obj->uart->ENABLE = (UART_ENABLE_ENABLE_Enabled << UART_ENABLE_ENABLE_Pos); obj->uart->TASKS_STARTTX = 1; obj->uart->TASKS_STARTRX = 1; - obj->uart->EVENTS_RXDRDY =0; - + obj->uart->EVENTS_RXDRDY = 0; + obj->index = 0; - + // set rx/tx pins in PullUp mode pin_mode(tx, PullUp); pin_mode(rx, PullUp); - + if (uart == STDIO_UART) { stdio_uart_inited = 1; memcpy(&stdio_uart, obj, sizeof(serial_t)); } } -void serial_free(serial_t *obj) { +void serial_free(serial_t *obj) +{ serial_irq_ids[obj->index] = 0; } // serial_baud // set the baud rate, taking in to account the current SystemFrequency -void serial_baud(serial_t *obj, int baudrate) { - if(baudrate<=1200){ +void serial_baud(serial_t *obj, int baudrate) +{ + if (baudrate<=1200) { obj->uart->BAUDRATE = UART_BAUDRATE_BAUDRATE_Baud1200; return; } - - for(int i=1;i<16;i++){ - if(baudrateuart->BAUDRATE = acceptedSpeeds[i-1][1]; + + for (int i = 1; i<16; i++) { + if (baudrateuart->BAUDRATE = acceptedSpeeds[i - 1][1]; return; } } obj->uart->BAUDRATE = UART_BAUDRATE_BAUDRATE_Baud1M; } -void serial_format(serial_t *obj, int data_bits, SerialParity parity, int stop_bits) { +void serial_format(serial_t *obj, int data_bits, SerialParity parity, int stop_bits) +{ // 0: 1 stop bits, 1: 2 stop bits - // int parity_enable, parity_select; + // int parity_enable, parity_select; switch (parity) { case ParityNone: - obj->uart->CONFIG = 0; - break; + obj->uart->CONFIG = 0; + break; default: - obj->uart->CONFIG = (UART_CONFIG_PARITY_Included<uart->CONFIG = (UART_CONFIG_PARITY_Included << UART_CONFIG_PARITY_Pos); return; } //no Flow Control @@ -132,74 +135,85 @@ void serial_format(serial_t *obj, int data_bits, SerialParity parity, int stop_b //****************************************************************************** // * INTERRUPT HANDLING //****************************************************************************** -static inline void uart_irq(uint32_t iir, uint32_t index) { +static inline void uart_irq(uint32_t iir, uint32_t index) +{ SerialIrq irq_type; switch (iir) { case 1: irq_type = TxIrq; - break; + break; case 2: irq_type = RxIrq; - break; - - default: return; + break; + + default: + return; } - - if (serial_irq_ids[index] != 0){ + + if (serial_irq_ids[index] != 0) { irq_handler(serial_irq_ids[index], irq_type); } } + #ifdef __cplusplus extern "C" { #endif void UART0_IRQHandler() { - uint32_t irtype =0; - - if(NRF_UART0->EVENTS_TXDRDY){ - irtype =1; - } - else if(NRF_UART0->EVENTS_RXDRDY){ - irtype =2; + uint32_t irtype = 0; + + if (NRF_UART0->EVENTS_TXDRDY) { + irtype = 1; + } else if (NRF_UART0->EVENTS_RXDRDY) { + irtype = 2; } uart_irq(irtype, 0); } + #ifdef __cplusplus } #endif -void serial_irq_handler(serial_t *obj, uart_irq_handler handler, uint32_t id) { - irq_handler = handler; +void serial_irq_handler(serial_t *obj, uart_irq_handler handler, uint32_t id) +{ + irq_handler = handler; serial_irq_ids[obj->index] = id; } -void serial_irq_set(serial_t *obj, SerialIrq irq, uint32_t enable) { +void serial_irq_set(serial_t *obj, SerialIrq irq, uint32_t enable) +{ IRQn_Type irq_n = (IRQn_Type)0; switch ((int)obj->uart) { - case UART_0: irq_n=UART0_IRQn ; + case UART_0: + irq_n = UART0_IRQn; break; } - + if (enable) { switch (irq) { - case RxIrq: obj->uart->INTENSET |= (UART_INTENSET_RXDRDY_Msk);break; - case TxIrq: obj->uart->INTENSET |= (UART_INTENSET_TXDRDY_Msk);break; + case RxIrq: + obj->uart->INTENSET |= (UART_INTENSET_RXDRDY_Msk); + break; + case TxIrq: + obj->uart->INTENSET |= (UART_INTENSET_TXDRDY_Msk); + break; } NVIC_SetPriority(irq_n, 3); NVIC_EnableIRQ(irq_n); - } - else { // disable + } else { // disable int all_disabled = 0; switch (irq) { - case RxIrq: obj->uart->INTENSET &= ~(UART_INTENSET_RXDRDY_Msk); - all_disabled = (obj->uart->INTENSET& (UART_INTENSET_TXDRDY_Msk))==0; - break; - case TxIrq: obj->uart->INTENSET &= ~(UART_INTENSET_TXDRDY_Msk); - all_disabled = (obj->uart->INTENSET& (UART_INTENSET_RXDRDY_Msk))==0; - break; + case RxIrq: + obj->uart->INTENSET &= ~(UART_INTENSET_RXDRDY_Msk); + all_disabled = (obj->uart->INTENSET & (UART_INTENSET_TXDRDY_Msk))==0; + break; + case TxIrq: + obj->uart->INTENSET &= ~(UART_INTENSET_TXDRDY_Msk); + all_disabled = (obj->uart->INTENSET & (UART_INTENSET_RXDRDY_Msk))==0; + break; } - - if (all_disabled){ + + if (all_disabled) { NVIC_DisableIRQ(irq_n); } } @@ -208,35 +222,43 @@ void serial_irq_set(serial_t *obj, SerialIrq irq, uint32_t enable) { //****************************************************************************** //* READ/WRITE //****************************************************************************** -int serial_getc(serial_t *obj) { - while (!serial_readable(obj)); - +int serial_getc(serial_t *obj) +{ + while (!serial_readable(obj)) { + } + obj->uart->EVENTS_RXDRDY = 0; - + return (uint8_t)obj->uart->RXD; } -void serial_putc(serial_t *obj, int c) { +void serial_putc(serial_t *obj, int c) +{ obj->uart->TXD = (uint8_t)c; - - while (!serial_writable(obj)); - - obj->uart->EVENTS_TXDRDY =0; + + while (!serial_writable(obj)) { + } + + obj->uart->EVENTS_TXDRDY = 0; } -int serial_readable(serial_t *obj) { +int serial_readable(serial_t *obj) +{ return (obj->uart->EVENTS_RXDRDY == 1); } -int serial_writable(serial_t *obj) { +int serial_writable(serial_t *obj) +{ return (obj->uart->EVENTS_TXDRDY ==1); } -void serial_break_set(serial_t *obj) { +void serial_break_set(serial_t *obj) +{ obj->uart->TASKS_SUSPEND = 1; } -void serial_break_clear(serial_t *obj) { +void serial_break_clear(serial_t *obj) +{ obj->uart->TASKS_STARTTX = 1; obj->uart->TASKS_STARTRX = 1; } diff --git a/libraries/mbed/targets/hal/TARGET_NORDIC/TARGET_MCU_NRF51822/sleep.c b/libraries/mbed/targets/hal/TARGET_NORDIC/TARGET_MCU_NRF51822/sleep.c index 344b978fee3..3c5ab7dbae8 100644 --- a/libraries/mbed/targets/hal/TARGET_NORDIC/TARGET_MCU_NRF51822/sleep.c +++ b/libraries/mbed/targets/hal/TARGET_NORDIC/TARGET_MCU_NRF51822/sleep.c @@ -17,14 +17,16 @@ #include "cmsis.h" #include "mbed_interface.h" -void sleep(void) { +void sleep(void) +{ // ensure debug is disconnected if semihost is enabled.... - NRF_POWER->TASKS_LOWPWR=1; + NRF_POWER->TASKS_LOWPWR = 1; // wait for interrupt __WFE(); } -void deepsleep(void) { +void deepsleep(void) +{ sleep(); - // NRF_POWER->SYSTEMOFF=1; + // NRF_POWER->SYSTEMOFF=1; } diff --git a/libraries/mbed/targets/hal/TARGET_NORDIC/TARGET_MCU_NRF51822/spi_api.c b/libraries/mbed/targets/hal/TARGET_NORDIC/TARGET_MCU_NRF51822/spi_api.c index 237179e83ec..e17710a7a52 100644 --- a/libraries/mbed/targets/hal/TARGET_NORDIC/TARGET_MCU_NRF51822/spi_api.c +++ b/libraries/mbed/targets/hal/TARGET_NORDIC/TARGET_MCU_NRF51822/spi_api.c @@ -21,29 +21,29 @@ #include "mbed_error.h" static const PinMap PinMap_SPI_SCLK[] = { - {SPI_PSELSCK0 , SPI_0, 0x01}, + {SPI_PSELSCK0, SPI_0, 0x01}, {SPI_PSELSCK1, SPI_1, 0x02}, {SPIS_PSELSCK, SPIS, 0x03}, - {NC , NC , 0} + {NC, NC, 0} }; static const PinMap PinMap_SPI_MOSI[] = { - {SPI_PSELMOSI0 , SPI_0, 0x01}, + {SPI_PSELMOSI0, SPI_0, 0x01}, {SPI_PSELMOSI1, SPI_1, 0x02}, {SPIS_PSELMOSI, SPIS, 0x03}, - {NC , NC , 0} + {NC, NC, 0} }; static const PinMap PinMap_SPI_MISO[] = { - {SPI_PSELMISO0 , SPI_0, 0x01}, + {SPI_PSELMISO0, SPI_0, 0x01}, {SPI_PSELMISO1, SPI_1, 0x02}, {SPIS_PSELMISO, SPIS, 0x03}, - {NC , NC , 0} + {NC, NC, 0} }; static const PinMap PinMap_SPI_SSEL[] = { {SPIS_PSELSS, SPIS, 0x03}, - {NC , NC , 0} + {NC, NC, 0} }; // {SPI_PSELSS0 , SPI_0, 0x01}, #define SPIS_MESSAGE_SIZE 1 @@ -51,7 +51,8 @@ volatile uint8_t m_tx_buf[SPIS_MESSAGE_SIZE] = {0}; volatile uint8_t m_rx_buf[SPIS_MESSAGE_SIZE] = {0}; -void spi_init(spi_t *obj, PinName mosi, PinName miso, PinName sclk, PinName ssel) { +void spi_init(spi_t *obj, PinName mosi, PinName miso, PinName sclk, PinName ssel) +{ // determine the SPI to use SPIName spi_mosi = (SPIName)pinmap_peripheral(mosi, PinMap_SPI_MOSI); SPIName spi_miso = (SPIName)pinmap_peripheral(miso, PinMap_SPI_MISO); @@ -59,133 +60,131 @@ void spi_init(spi_t *obj, PinName mosi, PinName miso, PinName sclk, PinName ssel SPIName spi_ssel = (SPIName)pinmap_peripheral(ssel, PinMap_SPI_SSEL); SPIName spi_data = (SPIName)pinmap_merge(spi_mosi, spi_miso); SPIName spi_cntl = (SPIName)pinmap_merge(spi_sclk, spi_ssel); - SPIName spi = (SPIName)pinmap_merge(spi_data, spi_cntl); + SPIName spi = (SPIName)pinmap_merge(spi_data, spi_cntl); //SPIName - if(ssel==NC){ - obj->spi = (NRF_SPI_Type*)spi; - obj->spis = (NRF_SPIS_Type*)NC; - } - else{ - obj->spi = (NRF_SPI_Type*)NC; - obj->spis = (NRF_SPIS_Type*)spi; + if (ssel==NC) { + obj->spi = (NRF_SPI_Type *)spi; + obj->spis = (NRF_SPIS_Type *)NC; + } else { + obj->spi = (NRF_SPI_Type *)NC; + obj->spis = (NRF_SPIS_Type *)spi; } MBED_ASSERT((int)obj->spi != NC || (int)obj->spis != NC); - // pin out the spi pins - if (ssel != NC) {//slave - obj->spis->POWER=0; - obj->spis->POWER=1; - - NRF_GPIO->PIN_CNF[mosi] = (GPIO_PIN_CNF_SENSE_Disabled << GPIO_PIN_CNF_SENSE_Pos) - | (GPIO_PIN_CNF_DRIVE_S0S1 << GPIO_PIN_CNF_DRIVE_Pos) - | (GPIO_PIN_CNF_PULL_Disabled << GPIO_PIN_CNF_PULL_Pos) - | (GPIO_PIN_CNF_INPUT_Connect << GPIO_PIN_CNF_INPUT_Pos) - | (GPIO_PIN_CNF_DIR_Input << GPIO_PIN_CNF_DIR_Pos); - NRF_GPIO->PIN_CNF[miso] = (GPIO_PIN_CNF_SENSE_Disabled << GPIO_PIN_CNF_SENSE_Pos) - | (GPIO_PIN_CNF_DRIVE_S0S1 << GPIO_PIN_CNF_DRIVE_Pos) - | (GPIO_PIN_CNF_PULL_Disabled << GPIO_PIN_CNF_PULL_Pos) - | (GPIO_PIN_CNF_INPUT_Connect << GPIO_PIN_CNF_INPUT_Pos) - | (GPIO_PIN_CNF_DIR_Input << GPIO_PIN_CNF_DIR_Pos); - NRF_GPIO->PIN_CNF[sclk] = (GPIO_PIN_CNF_SENSE_Disabled << GPIO_PIN_CNF_SENSE_Pos) - | (GPIO_PIN_CNF_DRIVE_S0S1 << GPIO_PIN_CNF_DRIVE_Pos) - | (GPIO_PIN_CNF_PULL_Disabled << GPIO_PIN_CNF_PULL_Pos) - | (GPIO_PIN_CNF_INPUT_Connect << GPIO_PIN_CNF_INPUT_Pos) - | (GPIO_PIN_CNF_DIR_Input << GPIO_PIN_CNF_DIR_Pos); - NRF_GPIO->PIN_CNF[ssel] = (GPIO_PIN_CNF_SENSE_Disabled << GPIO_PIN_CNF_SENSE_Pos) - | (GPIO_PIN_CNF_DRIVE_S0S1 << GPIO_PIN_CNF_DRIVE_Pos) - | (GPIO_PIN_CNF_PULL_Disabled << GPIO_PIN_CNF_PULL_Pos) - | (GPIO_PIN_CNF_INPUT_Connect << GPIO_PIN_CNF_INPUT_Pos) - | (GPIO_PIN_CNF_DIR_Input << GPIO_PIN_CNF_DIR_Pos); - + // pin out the spi pins + if (ssel != NC) { //slave + obj->spis->POWER = 0; + obj->spis->POWER = 1; + + NRF_GPIO->PIN_CNF[mosi] = (GPIO_PIN_CNF_SENSE_Disabled << GPIO_PIN_CNF_SENSE_Pos) | + (GPIO_PIN_CNF_DRIVE_S0S1 << GPIO_PIN_CNF_DRIVE_Pos) | + (GPIO_PIN_CNF_PULL_Disabled << GPIO_PIN_CNF_PULL_Pos) | + (GPIO_PIN_CNF_INPUT_Connect << GPIO_PIN_CNF_INPUT_Pos) | + (GPIO_PIN_CNF_DIR_Input << GPIO_PIN_CNF_DIR_Pos); + NRF_GPIO->PIN_CNF[miso] = (GPIO_PIN_CNF_SENSE_Disabled << GPIO_PIN_CNF_SENSE_Pos) | + (GPIO_PIN_CNF_DRIVE_S0S1 << GPIO_PIN_CNF_DRIVE_Pos) | + (GPIO_PIN_CNF_PULL_Disabled << GPIO_PIN_CNF_PULL_Pos) | + (GPIO_PIN_CNF_INPUT_Connect << GPIO_PIN_CNF_INPUT_Pos) | + (GPIO_PIN_CNF_DIR_Input << GPIO_PIN_CNF_DIR_Pos); + NRF_GPIO->PIN_CNF[sclk] = (GPIO_PIN_CNF_SENSE_Disabled << GPIO_PIN_CNF_SENSE_Pos) | + (GPIO_PIN_CNF_DRIVE_S0S1 << GPIO_PIN_CNF_DRIVE_Pos) | + (GPIO_PIN_CNF_PULL_Disabled << GPIO_PIN_CNF_PULL_Pos) | + (GPIO_PIN_CNF_INPUT_Connect << GPIO_PIN_CNF_INPUT_Pos) | + (GPIO_PIN_CNF_DIR_Input << GPIO_PIN_CNF_DIR_Pos); + NRF_GPIO->PIN_CNF[ssel] = (GPIO_PIN_CNF_SENSE_Disabled << GPIO_PIN_CNF_SENSE_Pos) | + (GPIO_PIN_CNF_DRIVE_S0S1 << GPIO_PIN_CNF_DRIVE_Pos) | + (GPIO_PIN_CNF_PULL_Disabled << GPIO_PIN_CNF_PULL_Pos) | + (GPIO_PIN_CNF_INPUT_Connect << GPIO_PIN_CNF_INPUT_Pos) | + (GPIO_PIN_CNF_DIR_Input << GPIO_PIN_CNF_DIR_Pos); + obj->spis->PSELMOSI = mosi; obj->spis->PSELMISO = miso; - obj->spis->PSELSCK = sclk; - obj->spis->PSELCSN = ssel; - - obj->spis->EVENTS_END=0; - obj->spis->EVENTS_ACQUIRED=0; - obj->spis->MAXRX=SPIS_MESSAGE_SIZE; - obj->spis->MAXTX=SPIS_MESSAGE_SIZE; - obj->spis->TXDPTR = (uint32_t)&m_tx_buf[0]; - obj->spis->RXDPTR = (uint32_t)&m_rx_buf[0]; - obj->spis->SHORTS = (SPIS_SHORTS_END_ACQUIRE_Enabled<spis->PSELSCK = sclk; + obj->spis->PSELCSN = ssel; + + obj->spis->EVENTS_END = 0; + obj->spis->EVENTS_ACQUIRED = 0; + obj->spis->MAXRX = SPIS_MESSAGE_SIZE; + obj->spis->MAXTX = SPIS_MESSAGE_SIZE; + obj->spis->TXDPTR = (uint32_t)&m_tx_buf[0]; + obj->spis->RXDPTR = (uint32_t)&m_rx_buf[0]; + obj->spis->SHORTS = (SPIS_SHORTS_END_ACQUIRE_Enabled << SPIS_SHORTS_END_ACQUIRE_Pos); spi_format(obj, 8, 0, 1); // 8 bits, mode 0, slave - } - else{//master - obj->spi->POWER=0; - obj->spi->POWER=1; - + } else { //master + obj->spi->POWER = 0; + obj->spi->POWER = 1; + //NRF_GPIO->DIR |= (1<PIN_CNF[mosi] = (GPIO_PIN_CNF_SENSE_Disabled << GPIO_PIN_CNF_SENSE_Pos) - | (GPIO_PIN_CNF_DRIVE_S0S1 << GPIO_PIN_CNF_DRIVE_Pos) - | (GPIO_PIN_CNF_PULL_Disabled << GPIO_PIN_CNF_PULL_Pos) - | (GPIO_PIN_CNF_INPUT_Connect << GPIO_PIN_CNF_INPUT_Pos) - | (GPIO_PIN_CNF_DIR_Output << GPIO_PIN_CNF_DIR_Pos); + NRF_GPIO->PIN_CNF[mosi] = (GPIO_PIN_CNF_SENSE_Disabled << GPIO_PIN_CNF_SENSE_Pos) | + (GPIO_PIN_CNF_DRIVE_S0S1 << GPIO_PIN_CNF_DRIVE_Pos) | + (GPIO_PIN_CNF_PULL_Disabled << GPIO_PIN_CNF_PULL_Pos) | + (GPIO_PIN_CNF_INPUT_Connect << GPIO_PIN_CNF_INPUT_Pos) | + (GPIO_PIN_CNF_DIR_Output << GPIO_PIN_CNF_DIR_Pos); obj->spi->PSELMOSI = mosi; - - NRF_GPIO->PIN_CNF[sclk] = (GPIO_PIN_CNF_SENSE_Disabled << GPIO_PIN_CNF_SENSE_Pos) - | (GPIO_PIN_CNF_DRIVE_S0S1 << GPIO_PIN_CNF_DRIVE_Pos) - | (GPIO_PIN_CNF_PULL_Disabled << GPIO_PIN_CNF_PULL_Pos) - | (GPIO_PIN_CNF_INPUT_Connect << GPIO_PIN_CNF_INPUT_Pos) - | (GPIO_PIN_CNF_DIR_Output << GPIO_PIN_CNF_DIR_Pos); + + NRF_GPIO->PIN_CNF[sclk] = (GPIO_PIN_CNF_SENSE_Disabled << GPIO_PIN_CNF_SENSE_Pos) | + (GPIO_PIN_CNF_DRIVE_S0S1 << GPIO_PIN_CNF_DRIVE_Pos) | + (GPIO_PIN_CNF_PULL_Disabled << GPIO_PIN_CNF_PULL_Pos) | + (GPIO_PIN_CNF_INPUT_Connect << GPIO_PIN_CNF_INPUT_Pos) | + (GPIO_PIN_CNF_DIR_Output << GPIO_PIN_CNF_DIR_Pos); obj->spi->PSELSCK = sclk; - + //NRF_GPIO->DIR &= ~(1<PIN_CNF[miso] = (GPIO_PIN_CNF_SENSE_Disabled << GPIO_PIN_CNF_SENSE_Pos) - | (GPIO_PIN_CNF_DRIVE_S0S1 << GPIO_PIN_CNF_DRIVE_Pos) - | (GPIO_PIN_CNF_PULL_Disabled << GPIO_PIN_CNF_PULL_Pos) - | (GPIO_PIN_CNF_INPUT_Connect << GPIO_PIN_CNF_INPUT_Pos) - | (GPIO_PIN_CNF_DIR_Input << GPIO_PIN_CNF_DIR_Pos); + NRF_GPIO->PIN_CNF[miso] = (GPIO_PIN_CNF_SENSE_Disabled << GPIO_PIN_CNF_SENSE_Pos) | + (GPIO_PIN_CNF_DRIVE_S0S1 << GPIO_PIN_CNF_DRIVE_Pos) | + (GPIO_PIN_CNF_PULL_Disabled << GPIO_PIN_CNF_PULL_Pos) | + (GPIO_PIN_CNF_INPUT_Connect << GPIO_PIN_CNF_INPUT_Pos) | + (GPIO_PIN_CNF_DIR_Input << GPIO_PIN_CNF_DIR_Pos); obj->spi->PSELMISO = miso; - + obj->spi->EVENTS_READY = 0U; spi_format(obj, 8, 0, 0); // 8 bits, mode 0, master spi_frequency(obj, 1000000); } - } -void spi_free(spi_t *obj) {} +void spi_free(spi_t *obj) { +} -static inline void spi_disable(spi_t *obj, int slave) { - if(slave){ +static inline void spi_disable(spi_t *obj, int slave) +{ + if (slave) { obj->spis->ENABLE = (SPIS_ENABLE_ENABLE_Disabled << SPIS_ENABLE_ENABLE_Pos); - } - else{ + } else { obj->spi->ENABLE = (SPI_ENABLE_ENABLE_Disabled << SPI_ENABLE_ENABLE_Pos); } } -static inline void spi_enable(spi_t *obj, int slave) { - if(slave){ +static inline void spi_enable(spi_t *obj, int slave) +{ + if (slave) { obj->spis->ENABLE = (SPIS_ENABLE_ENABLE_Enabled << SPIS_ENABLE_ENABLE_Pos); - } - else{ + } else { obj->spi->ENABLE = (SPI_ENABLE_ENABLE_Enabled << SPI_ENABLE_ENABLE_Pos); } } -void spi_format(spi_t *obj, int bits, int mode, int slave) { +void spi_format(spi_t *obj, int bits, int mode, int slave) +{ uint32_t config_mode = 0; - spi_disable(obj,slave); - + spi_disable(obj, slave); + if (bits != 8) { error("Only 8bits SPI supported"); } - - switch (mode) - { + + switch (mode) { case 0: - config_mode = (SPI_CONFIG_CPHA_Leading << SPI_CONFIG_CPHA_Pos) | (SPI_CONFIG_CPOL_ActiveHigh << SPI_CONFIG_CPOL_Pos); + config_mode = (SPI_CONFIG_CPHA_Leading << SPI_CONFIG_CPHA_Pos) | (SPI_CONFIG_CPOL_ActiveHigh << SPI_CONFIG_CPOL_Pos); break; case 1: config_mode = (SPI_CONFIG_CPHA_Trailing << SPI_CONFIG_CPHA_Pos) | (SPI_CONFIG_CPOL_ActiveHigh << SPI_CONFIG_CPOL_Pos); break; case 2: - config_mode = (SPI_CONFIG_CPHA_Leading << SPI_CONFIG_CPHA_Pos) | (SPI_CONFIG_CPOL_ActiveLow << SPI_CONFIG_CPOL_Pos); + config_mode = (SPI_CONFIG_CPHA_Leading << SPI_CONFIG_CPHA_Pos) | (SPI_CONFIG_CPOL_ActiveLow << SPI_CONFIG_CPOL_Pos); break; case 3: config_mode = (SPI_CONFIG_CPHA_Trailing << SPI_CONFIG_CPHA_Pos) | (SPI_CONFIG_CPOL_ActiveLow << SPI_CONFIG_CPOL_Pos); @@ -195,65 +194,63 @@ void spi_format(spi_t *obj, int bits, int mode, int slave) { break; } //default to msb first - if(slave){ - obj->spis->CONFIG = (config_mode | (SPI_CONFIG_ORDER_MsbFirst << SPI_CONFIG_ORDER_Pos) ); - } - else{ - obj->spi->CONFIG = (config_mode | (SPI_CONFIG_ORDER_MsbFirst << SPI_CONFIG_ORDER_Pos) ); + if (slave) { + obj->spis->CONFIG = (config_mode | (SPI_CONFIG_ORDER_MsbFirst << SPI_CONFIG_ORDER_Pos)); + } else { + obj->spi->CONFIG = (config_mode | (SPI_CONFIG_ORDER_MsbFirst << SPI_CONFIG_ORDER_Pos)); } - - spi_enable(obj,slave); + + spi_enable(obj, slave); } -void spi_frequency(spi_t *obj, int hz) { - if((int)obj->spi==NC) +void spi_frequency(spi_t *obj, int hz) +{ + if ((int)obj->spi==NC) { return; - spi_disable(obj,0); - - if(hz<250000) { //125Kbps - obj->spi->FREQUENCY = (uint32_t) SPI_FREQUENCY_FREQUENCY_K125; } - else if(hz<500000){//250Kbps + spi_disable(obj, 0); + + if (hz<250000) { //125Kbps + obj->spi->FREQUENCY = (uint32_t) SPI_FREQUENCY_FREQUENCY_K125; + } else if (hz<500000) { //250Kbps obj->spi->FREQUENCY = (uint32_t) SPI_FREQUENCY_FREQUENCY_K250; - } - else if(hz<1000000){//500Kbps + } else if (hz<1000000) { //500Kbps obj->spi->FREQUENCY = (uint32_t) SPI_FREQUENCY_FREQUENCY_K500; - } - else if(hz<2000000){//1Mbps + } else if (hz<2000000) { //1Mbps obj->spi->FREQUENCY = (uint32_t) SPI_FREQUENCY_FREQUENCY_M1; - } - else if(hz<4000000){//2Mbps + } else if (hz<4000000) { //2Mbps obj->spi->FREQUENCY = (uint32_t) SPI_FREQUENCY_FREQUENCY_M2; - } - else if(hz<8000000){//4Mbps + } else if (hz<8000000) { //4Mbps obj->spi->FREQUENCY = (uint32_t) SPI_FREQUENCY_FREQUENCY_M4; - } - else{//8Mbps + } else { //8Mbps obj->spi->FREQUENCY = (uint32_t) SPI_FREQUENCY_FREQUENCY_M8; } - - spi_enable(obj,0); + + spi_enable(obj, 0); } -static inline int spi_readable(spi_t *obj) { +static inline int spi_readable(spi_t *obj) +{ return (obj->spi->EVENTS_READY == 1); } -static inline int spi_writeable(spi_t *obj) { +static inline int spi_writeable(spi_t *obj) +{ return (obj->spi->EVENTS_READY == 0); } - -static inline int spi_read(spi_t *obj) { - while (!spi_readable(obj)){ +static inline int spi_read(spi_t *obj) +{ + while (!spi_readable(obj)) { } - - obj->spi->EVENTS_READY =0; + + obj->spi->EVENTS_READY = 0; return (int)obj->spi->RXD; } -int spi_master_write(spi_t *obj, int value) { - while (!spi_writeable(obj)){ +int spi_master_write(spi_t *obj, int value) +{ + while (!spi_writeable(obj)) { } obj->spi->TXD = (uint32_t)value; return spi_read(obj); @@ -263,17 +260,20 @@ int spi_master_write(spi_t *obj, int value) { // return (obj->spis->EVENTS_ACQUIRED==1); //} -int spi_slave_receive(spi_t *obj) { +int spi_slave_receive(spi_t *obj) +{ return obj->spis->EVENTS_END; -}; +} -int spi_slave_read(spi_t *obj) { +int spi_slave_read(spi_t *obj) +{ return m_rx_buf[0]; } -void spi_slave_write(spi_t *obj, int value) { - m_tx_buf[0]= value & 0xFF; - obj->spis->TASKS_RELEASE=1; - obj->spis->EVENTS_ACQUIRED=0; - obj->spis->EVENTS_END=0; +void spi_slave_write(spi_t *obj, int value) +{ + m_tx_buf[0] = value & 0xFF; + obj->spis->TASKS_RELEASE = 1; + obj->spis->EVENTS_ACQUIRED = 0; + obj->spis->EVENTS_END = 0; } diff --git a/libraries/mbed/targets/hal/TARGET_NORDIC/TARGET_MCU_NRF51822/us_ticker.c b/libraries/mbed/targets/hal/TARGET_NORDIC/TARGET_MCU_NRF51822/us_ticker.c index b650d52e0e1..d3ea63851e5 100644 --- a/libraries/mbed/targets/hal/TARGET_NORDIC/TARGET_MCU_NRF51822/us_ticker.c +++ b/libraries/mbed/targets/hal/TARGET_NORDIC/TARGET_MCU_NRF51822/us_ticker.c @@ -21,107 +21,109 @@ #define US_TICKER_TIMER NRF_TIMER1 #define US_TICKER_TIMER_IRQn TIMER1_IRQn -int us_ticker_inited = 0; -volatile uint16_t overflow=0; //overflow value that forms the upper 16 bits of the counter -volatile uint16_t timeStamp=0; +int us_ticker_inited = 0; +volatile uint16_t overflow = 0; //overflow value that forms the upper 16 bits of the counter +volatile uint16_t timeStamp = 0; #ifdef __cplusplus extern "C" { -#endif -void TIMER1_IRQHandler(void){ - - if ((US_TICKER_TIMER->EVENTS_COMPARE[1] != 0) && - ((US_TICKER_TIMER->INTENSET & TIMER_INTENSET_COMPARE1_Msk) != 0)) - { - US_TICKER_TIMER->EVENTS_COMPARE[1] = 0; - overflow++; - US_TICKER_TIMER->CC[1] =0xFFFF; - if(timeStamp>0) - { - timeStamp--; - if(timeStamp==0) - { - us_ticker_clear_interrupt(); - us_ticker_disable_interrupt(); - us_ticker_irq_handler(); - return; - } - } +#endif + +void TIMER1_IRQHandler(void) +{ + if ((US_TICKER_TIMER->EVENTS_COMPARE[1] != 0) && + ((US_TICKER_TIMER->INTENSET & TIMER_INTENSET_COMPARE1_Msk) != 0)) { + US_TICKER_TIMER->EVENTS_COMPARE[1] = 0; + overflow++; + US_TICKER_TIMER->CC[1] = 0xFFFF; + if (timeStamp>0) { + timeStamp--; + if (timeStamp==0) { + us_ticker_clear_interrupt(); + us_ticker_disable_interrupt(); + us_ticker_irq_handler(); + return; + } + } } - if ((US_TICKER_TIMER->EVENTS_COMPARE[0] != 0) && - ((US_TICKER_TIMER->INTENSET & TIMER_INTENSET_COMPARE0_Msk) != 0)) - { - us_ticker_clear_interrupt(); - us_ticker_disable_interrupt(); - if(timeStamp==0) - us_ticker_irq_handler(); + if ((US_TICKER_TIMER->EVENTS_COMPARE[0] != 0) && + ((US_TICKER_TIMER->INTENSET & TIMER_INTENSET_COMPARE0_Msk) != 0)) { + us_ticker_clear_interrupt(); + us_ticker_disable_interrupt(); + if (timeStamp==0) { + us_ticker_irq_handler(); + } } - } + #ifdef __cplusplus } -#endif -void us_ticker_init(void){ - if (us_ticker_inited && US_TICKER_TIMER->POWER){ +#endif +void us_ticker_init(void) +{ + if (us_ticker_inited && US_TICKER_TIMER->POWER) { return; } - + us_ticker_inited = 1; - + US_TICKER_TIMER->POWER = 0; US_TICKER_TIMER->POWER = 1; - + US_TICKER_TIMER->MODE = TIMER_MODE_MODE_Timer; - - US_TICKER_TIMER->PRESCALER = 4; - US_TICKER_TIMER->BITMODE = TIMER_BITMODE_BITMODE_16Bit; - US_TICKER_TIMER->TASKS_CLEAR =1; - US_TICKER_TIMER->CC[1] = 0xFFFF; - US_TICKER_TIMER->INTENSET = TIMER_INTENSET_COMPARE1_Set << TIMER_INTENSET_COMPARE1_Pos; - + + US_TICKER_TIMER->PRESCALER = 4; + US_TICKER_TIMER->BITMODE = TIMER_BITMODE_BITMODE_16Bit; + US_TICKER_TIMER->TASKS_CLEAR = 1; + US_TICKER_TIMER->CC[1] = 0xFFFF; + US_TICKER_TIMER->INTENSET = TIMER_INTENSET_COMPARE1_Set << TIMER_INTENSET_COMPARE1_Pos; + NVIC_SetPriority(US_TICKER_TIMER_IRQn, 3); NVIC_EnableIRQ(US_TICKER_TIMER_IRQn); - + US_TICKER_TIMER->TASKS_START = 0x01; } -uint32_t us_ticker_read(){ - if (!us_ticker_inited || US_TICKER_TIMER->POWER==0){ +uint32_t us_ticker_read() +{ + if (!us_ticker_inited || (US_TICKER_TIMER->POWER==0)) { us_ticker_init(); } - - uint16_t bufferedOverFlow = overflow; - US_TICKER_TIMER->TASKS_CAPTURE[2] = 1; - - if(overflow!=bufferedOverFlow){ - bufferedOverFlow = overflow; - US_TICKER_TIMER->TASKS_CAPTURE[2] = 1; - } - return (((uint32_t)bufferedOverFlow<<16) | US_TICKER_TIMER->CC[2]); + + uint16_t bufferedOverFlow = overflow; + US_TICKER_TIMER->TASKS_CAPTURE[2] = 1; + + if (overflow!=bufferedOverFlow) { + bufferedOverFlow = overflow; + US_TICKER_TIMER->TASKS_CAPTURE[2] = 1; + } + return (((uint32_t)bufferedOverFlow << 16) | US_TICKER_TIMER->CC[2]); } -void us_ticker_set_interrupt(unsigned int timestamp){ - if (!us_ticker_inited || US_TICKER_TIMER->POWER==0) - { +void us_ticker_set_interrupt(unsigned int timestamp) +{ + if (!us_ticker_inited || (US_TICKER_TIMER->POWER==0)) { us_ticker_init(); - } - - US_TICKER_TIMER->TASKS_CAPTURE[0] = 1; - uint16_t tsUpper16 = (uint16_t)((timestamp-us_ticker_read())>>16); - if(tsUpper16>0){ - if(timeStamp ==0 || timeStamp> tsUpper16){ - timeStamp = tsUpper16; - } - } - else{ - US_TICKER_TIMER->INTENSET |= TIMER_INTENSET_COMPARE0_Set << TIMER_INTENSET_COMPARE0_Pos; - US_TICKER_TIMER->CC[0] += timestamp-us_ticker_read(); - } + } + + US_TICKER_TIMER->TASKS_CAPTURE[0] = 1; + uint16_t tsUpper16 = (uint16_t)((timestamp - us_ticker_read()) >> 16); + if (tsUpper16>0) { + if ((timeStamp ==0) || (timeStamp> tsUpper16)) { + timeStamp = tsUpper16; + } + } else { + US_TICKER_TIMER->INTENSET |= TIMER_INTENSET_COMPARE0_Set << TIMER_INTENSET_COMPARE0_Pos; + US_TICKER_TIMER->CC[0] += timestamp - us_ticker_read(); + } } -void us_ticker_disable_interrupt(void){ +void us_ticker_disable_interrupt(void) +{ US_TICKER_TIMER->INTENCLR = TIMER_INTENCLR_COMPARE0_Clear << TIMER_INTENCLR_COMPARE0_Pos; } -void us_ticker_clear_interrupt(void){ + +void us_ticker_clear_interrupt(void) +{ US_TICKER_TIMER->EVENTS_COMPARE[0] = 0; } From 317d474577a857ca991110afb22c3da41acca3a2 Mon Sep 17 00:00:00 2001 From: Rohit Grover Date: Tue, 12 Aug 2014 14:55:41 +0100 Subject: [PATCH 02/11] Replace the 16mhz clock with a low-freqncy external crystal based clock source at statup. This results in a big win in power consumption. --- .../TARGET_MCU_NRF51822/system_nrf51822.c | 31 ++++++++++--------- 1 file changed, 16 insertions(+), 15 deletions(-) diff --git a/libraries/mbed/targets/cmsis/TARGET_NORDIC/TARGET_MCU_NRF51822/system_nrf51822.c b/libraries/mbed/targets/cmsis/TARGET_NORDIC/TARGET_MCU_NRF51822/system_nrf51822.c index d30ee8a0c0c..67c34a80da9 100644 --- a/libraries/mbed/targets/cmsis/TARGET_NORDIC/TARGET_MCU_NRF51822/system_nrf51822.c +++ b/libraries/mbed/targets/cmsis/TARGET_NORDIC/TARGET_MCU_NRF51822/system_nrf51822.c @@ -29,7 +29,7 @@ static bool is_disabled_in_debug_needed(void); #if defined ( __CC_ARM ) - uint32_t SystemCoreClock __attribute__((used)) = __SYSTEM_CLOCK; + uint32_t SystemCoreClock __attribute__((used)) = __SYSTEM_CLOCK; #elif defined ( __ICCARM__ ) __root uint32_t SystemCoreClock = __SYSTEM_CLOCK; #elif defined ( __GNUC__ ) @@ -43,35 +43,36 @@ void SystemCoreClockUpdate(void) } void SystemInit(void) -{ +{ // Prepare the peripherals for use as indicated by the PAN 26 "System: Manual setup is required // to enable the use of peripherals" found at Product Anomaly document for your device found at - // https://www.nordicsemi.com/. The side effect of executing these instructions in the devices + // https://www.nordicsemi.com/. The side effect of executing these instructions in the devices // that do not need it is that the new peripherals in the second generation devices (LPCOMP for // example) will not be available. if (is_manual_peripheral_setup_needed()){ *(uint32_t volatile *)0x40000504 = 0xC007FFDF; *(uint32_t volatile *)0x40006C18 = 0x00008000; } - + // Disable PROTENSET registers under debug, as indicated by PAN 59 "MPU: Reset value of DISABLEINDEBUG - // register is incorrect" found at Product Anomaly document four your device found at - // https://www.nordicsemi.com/. There is no side effect of using these instruction if not needed. + // register is incorrect" found at Product Anomaly document four your device found at + // https://www.nordicsemi.com/. There is no side effect of using these instruction if not needed. if (is_disabled_in_debug_needed()){ NRF_MPU->DISABLEINDEBUG = MPU_DISABLEINDEBUG_DISABLEINDEBUG_Disabled << MPU_DISABLEINDEBUG_DISABLEINDEBUG_Pos; } - - // Start 16 MHz crystal oscillator. - NRF_CLOCK->EVENTS_HFCLKSTARTED = 0; - NRF_CLOCK->TASKS_HFCLKSTART = 1; + + // Start the external 32khz crystal oscillator. + NRF_CLOCK->LFCLKSRC = (CLOCK_LFCLKSRC_SRC_Xtal << CLOCK_LFCLKSRC_SRC_Pos); + NRF_CLOCK->EVENTS_LFCLKSTARTED = 0; + NRF_CLOCK->TASKS_LFCLKSTART = 1; // Wait for the external oscillator to start up. - while (NRF_CLOCK->EVENTS_HFCLKSTARTED == 0) { + while (NRF_CLOCK->EVENTS_LFCLKSTARTED == 0) { // Do nothing. } } -static bool is_manual_peripheral_setup_needed(void) +static bool is_manual_peripheral_setup_needed(void) { if ((((*(uint32_t *)0xF0000FE0) & 0x000000FF) == 0x1) && (((*(uint32_t *)0xF0000FE4) & 0x0000000F) == 0x0)) { @@ -88,11 +89,11 @@ static bool is_manual_peripheral_setup_needed(void) return true; } } - + return false; } -static bool is_disabled_in_debug_needed(void) +static bool is_disabled_in_debug_needed(void) { if ((((*(uint32_t *)0xF0000FE0) & 0x000000FF) == 0x1) && (((*(uint32_t *)0xF0000FE4) & 0x0000000F) == 0x0)) { @@ -101,7 +102,7 @@ static bool is_disabled_in_debug_needed(void) return true; } } - + return false; } From a12507af2b52db47b49eff1c87f178463f0d2562 Mon Sep 17 00:00:00 2001 From: Rohit Grover Date: Fri, 15 Aug 2014 08:37:05 +0100 Subject: [PATCH 03/11] add a missing call to us_ticker_disable_interrupt from us_ticker_remove_event. --- libraries/mbed/common/us_ticker_api.c | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/libraries/mbed/common/us_ticker_api.c b/libraries/mbed/common/us_ticker_api.c index 434f7059386..6d7d0744f10 100644 --- a/libraries/mbed/common/us_ticker_api.c +++ b/libraries/mbed/common/us_ticker_api.c @@ -95,7 +95,9 @@ void us_ticker_remove_event(ticker_event_t *obj) { if (head == obj) { // first in the list, so just drop me head = obj->next; - if (obj->next != NULL) { + if (obj->next == NULL) { + us_ticker_disable_interrupt(); + } else { us_ticker_set_interrupt(head->timestamp); } } else { From 8429a7c6c193e0f42eacae8c11e82d390285cff4 Mon Sep 17 00:00:00 2001 From: Rohit Grover Date: Fri, 15 Aug 2014 08:46:43 +0100 Subject: [PATCH 04/11] reimplement the micro-second ticker on nRF51822 using the app_timer module (RTC) --- .../TARGET_MCU_NRF51822/us_ticker.c | 116 +++++++----------- 1 file changed, 41 insertions(+), 75 deletions(-) diff --git a/libraries/mbed/targets/hal/TARGET_NORDIC/TARGET_MCU_NRF51822/us_ticker.c b/libraries/mbed/targets/hal/TARGET_NORDIC/TARGET_MCU_NRF51822/us_ticker.c index d3ea63851e5..f7b1b28b9b7 100644 --- a/libraries/mbed/targets/hal/TARGET_NORDIC/TARGET_MCU_NRF51822/us_ticker.c +++ b/libraries/mbed/targets/hal/TARGET_NORDIC/TARGET_MCU_NRF51822/us_ticker.c @@ -17,113 +17,79 @@ #include "us_ticker_api.h" #include "cmsis.h" #include "PeripheralNames.h" +#include "app_timer.h" -#define US_TICKER_TIMER NRF_TIMER1 -#define US_TICKER_TIMER_IRQn TIMER1_IRQn +static bool us_ticker_inited = false; +static app_timer_id_t us_ticker_appTimerID = TIMER_NULL; -int us_ticker_inited = 0; -volatile uint16_t overflow = 0; //overflow value that forms the upper 16 bits of the counter -volatile uint16_t timeStamp = 0; +static const unsigned RTC_TO_US_CONVERSION_FACTOR = ((1000000 / APP_TIMER_CLOCK_FREQ) + 1); -#ifdef __cplusplus -extern "C" { -#endif - -void TIMER1_IRQHandler(void) -{ - if ((US_TICKER_TIMER->EVENTS_COMPARE[1] != 0) && - ((US_TICKER_TIMER->INTENSET & TIMER_INTENSET_COMPARE1_Msk) != 0)) { - US_TICKER_TIMER->EVENTS_COMPARE[1] = 0; - overflow++; - US_TICKER_TIMER->CC[1] = 0xFFFF; - if (timeStamp>0) { - timeStamp--; - if (timeStamp==0) { - us_ticker_clear_interrupt(); - us_ticker_disable_interrupt(); - us_ticker_irq_handler(); - return; - } - } - } - if ((US_TICKER_TIMER->EVENTS_COMPARE[0] != 0) && - ((US_TICKER_TIMER->INTENSET & TIMER_INTENSET_COMPARE0_Msk) != 0)) { - us_ticker_clear_interrupt(); - us_ticker_disable_interrupt(); - if (timeStamp==0) { - us_ticker_irq_handler(); - } - } -} - -#ifdef __cplusplus -} -#endif void us_ticker_init(void) { - if (us_ticker_inited && US_TICKER_TIMER->POWER) { + if (us_ticker_inited) { return; } - us_ticker_inited = 1; - - US_TICKER_TIMER->POWER = 0; - US_TICKER_TIMER->POWER = 1; + const bool useScheduler = false; + APP_TIMER_INIT(0 /* PRESCALAR */, 2 /* num timers */, 1 /* event queue max depth */, useScheduler); - US_TICKER_TIMER->MODE = TIMER_MODE_MODE_Timer; - - US_TICKER_TIMER->PRESCALER = 4; - US_TICKER_TIMER->BITMODE = TIMER_BITMODE_BITMODE_16Bit; - US_TICKER_TIMER->TASKS_CLEAR = 1; - US_TICKER_TIMER->CC[1] = 0xFFFF; - US_TICKER_TIMER->INTENSET = TIMER_INTENSET_COMPARE1_Set << TIMER_INTENSET_COMPARE1_Pos; - - NVIC_SetPriority(US_TICKER_TIMER_IRQn, 3); - NVIC_EnableIRQ(US_TICKER_TIMER_IRQn); - - US_TICKER_TIMER->TASKS_START = 0x01; + us_ticker_inited = true; } uint32_t us_ticker_read() { - if (!us_ticker_inited || (US_TICKER_TIMER->POWER==0)) { + if (!us_ticker_inited) { us_ticker_init(); } - uint16_t bufferedOverFlow = overflow; - US_TICKER_TIMER->TASKS_CAPTURE[2] = 1; + uint32_t value; + app_timer_cnt_get(&value); /* This returns the RTC counter (which is fed by the 32khz crystal clock source) */ + return value * RTC_TO_US_CONVERSION_FACTOR; /* Return a pseudo microsecond counter value. + * This is only as precise as the 32khz low-freq + * clock source, but could be adequate.*/ +} - if (overflow!=bufferedOverFlow) { - bufferedOverFlow = overflow; - US_TICKER_TIMER->TASKS_CAPTURE[2] = 1; - } - return (((uint32_t)bufferedOverFlow << 16) | US_TICKER_TIMER->CC[2]); +/* An adaptor to interface us_ticker_irq_handler with the app_timer callback. + * Needed because the irq_handler() doesn't take any parameter.*/ +static void us_ticker_app_timer_callback(void *context) +{ + us_ticker_irq_handler(); } void us_ticker_set_interrupt(unsigned int timestamp) { - if (!us_ticker_inited || (US_TICKER_TIMER->POWER==0)) { + if (!us_ticker_inited) { us_ticker_init(); } - US_TICKER_TIMER->TASKS_CAPTURE[0] = 1; - uint16_t tsUpper16 = (uint16_t)((timestamp - us_ticker_read()) >> 16); - if (tsUpper16>0) { - if ((timeStamp ==0) || (timeStamp> tsUpper16)) { - timeStamp = tsUpper16; + if (us_ticker_appTimerID == TIMER_NULL) { + if (app_timer_create(&us_ticker_appTimerID, APP_TIMER_MODE_SINGLE_SHOT, us_ticker_app_timer_callback) != NRF_SUCCESS) { + /* placeholder to do something to recover from error */ + return; + } + } + + uint32_t currentCounter; + app_timer_cnt_get(¤tCounter); + uint32_t targetCounter = (timestamp / RTC_TO_US_CONVERSION_FACTOR) + 1; /* we add 1 to allow for safe round-up of the target. */ + uint32_t ticksToCount = (targetCounter >= currentCounter) ? + (targetCounter - currentCounter) : APP_TIMER_CLOCK_FREQ - (currentCounter - targetCounter); + if (ticksToCount > 0) { + uint32_t rc; + rc = app_timer_start(us_ticker_appTimerID, ticksToCount, NULL /*p_context*/); + if (rc != NRF_SUCCESS) { + /* placeholder to do something to recover from error */ + return; } - } else { - US_TICKER_TIMER->INTENSET |= TIMER_INTENSET_COMPARE0_Set << TIMER_INTENSET_COMPARE0_Pos; - US_TICKER_TIMER->CC[0] += timestamp - us_ticker_read(); } } void us_ticker_disable_interrupt(void) { - US_TICKER_TIMER->INTENCLR = TIMER_INTENCLR_COMPARE0_Clear << TIMER_INTENCLR_COMPARE0_Pos; + app_timer_stop(us_ticker_appTimerID); } void us_ticker_clear_interrupt(void) { - US_TICKER_TIMER->EVENTS_COMPARE[0] = 0; + /* empty */ } From fbc79a2e457ed7517ddd7aa562d99a2293908f1d Mon Sep 17 00:00:00 2001 From: Rohit Grover Date: Fri, 15 Aug 2014 09:10:53 +0100 Subject: [PATCH 05/11] add a minor comment to explain some complex branching in us_ticker_irq_handler() --- libraries/mbed/common/us_ticker_api.c | 2 ++ 1 file changed, 2 insertions(+) diff --git a/libraries/mbed/common/us_ticker_api.c b/libraries/mbed/common/us_ticker_api.c index 6d7d0744f10..2805562340c 100644 --- a/libraries/mbed/common/us_ticker_api.c +++ b/libraries/mbed/common/us_ticker_api.c @@ -45,6 +45,8 @@ void us_ticker_irq_handler(void) { if (event_handler != NULL) { event_handler(p->id); // NOTE: the handler can set new events } + /* Note: We continue back to examining the head because calling the + * event handler may have altered the chain of pending events. */ } else { // This event and the following ones in the list are in the future: // set it as next interrupt and return From 22f35602a0713fa3b7a070cdb616f2b38a909a73 Mon Sep 17 00:00:00 2001 From: Rohit Grover Date: Fri, 15 Aug 2014 13:17:00 +0100 Subject: [PATCH 06/11] add a cachedInterruptTimestamp to us_ticker_set_interrupt() to short-circuit duplicate calls. --- .../hal/TARGET_NORDIC/TARGET_MCU_NRF51822/us_ticker.c | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/libraries/mbed/targets/hal/TARGET_NORDIC/TARGET_MCU_NRF51822/us_ticker.c b/libraries/mbed/targets/hal/TARGET_NORDIC/TARGET_MCU_NRF51822/us_ticker.c index f7b1b28b9b7..ed763eb6522 100644 --- a/libraries/mbed/targets/hal/TARGET_NORDIC/TARGET_MCU_NRF51822/us_ticker.c +++ b/libraries/mbed/targets/hal/TARGET_NORDIC/TARGET_MCU_NRF51822/us_ticker.c @@ -58,6 +58,8 @@ static void us_ticker_app_timer_callback(void *context) void us_ticker_set_interrupt(unsigned int timestamp) { + static unsigned cachedInterruptTimestamp; + if (!us_ticker_inited) { us_ticker_init(); } @@ -67,7 +69,13 @@ void us_ticker_set_interrupt(unsigned int timestamp) /* placeholder to do something to recover from error */ return; } + } else { + /* we want to avoid taking action on duplicate requests */ + if (timestamp == cachedInterruptTimestamp) { + return; + } } + cachedInterruptTimestamp = timestamp; uint32_t currentCounter; app_timer_cnt_get(¤tCounter); From ec7575bfa96d80a8f621744b4a030b783ef65fe7 Mon Sep 17 00:00:00 2001 From: Rohit Grover Date: Wed, 20 Aug 2014 13:32:49 +0100 Subject: [PATCH 07/11] introduce a timestamp_t to track timeouts for TimerEvents. The previous type used for this purpose was unsigned int, which was both un-portable and liable to wrap-around. --- libraries/mbed/api/TimerEvent.h | 2 +- libraries/mbed/common/TimerEvent.cpp | 2 +- libraries/mbed/common/us_ticker_api.c | 2 +- libraries/mbed/hal/us_ticker_api.h | 10 ++++++---- .../TARGET_MCU_NRF51822/us_ticker.c | 18 +++++++++--------- 5 files changed, 18 insertions(+), 16 deletions(-) diff --git a/libraries/mbed/api/TimerEvent.h b/libraries/mbed/api/TimerEvent.h index 81e47e11419..4ec7056a744 100644 --- a/libraries/mbed/api/TimerEvent.h +++ b/libraries/mbed/api/TimerEvent.h @@ -39,7 +39,7 @@ class TimerEvent { virtual void handler() = 0; // insert in to linked list - void insert(unsigned int timestamp); + void insert(timestamp_t timestamp); // remove from linked list, if in it void remove(); diff --git a/libraries/mbed/common/TimerEvent.cpp b/libraries/mbed/common/TimerEvent.cpp index 6af80dd09ab..272adf51f34 100644 --- a/libraries/mbed/common/TimerEvent.cpp +++ b/libraries/mbed/common/TimerEvent.cpp @@ -34,7 +34,7 @@ TimerEvent::~TimerEvent() { } // insert in to linked list -void TimerEvent::insert(unsigned int timestamp) { +void TimerEvent::insert(timestamp_t timestamp) { us_ticker_insert_event(&event, timestamp, (uint32_t)this); } diff --git a/libraries/mbed/common/us_ticker_api.c b/libraries/mbed/common/us_ticker_api.c index 2805562340c..749354a2975 100644 --- a/libraries/mbed/common/us_ticker_api.c +++ b/libraries/mbed/common/us_ticker_api.c @@ -56,7 +56,7 @@ void us_ticker_irq_handler(void) { } } -void us_ticker_insert_event(ticker_event_t *obj, unsigned int timestamp, uint32_t id) { +void us_ticker_insert_event(ticker_event_t *obj, timestamp_t timestamp, uint32_t id) { /* disable interrupts for the duration of the function */ __disable_irq(); diff --git a/libraries/mbed/hal/us_ticker_api.h b/libraries/mbed/hal/us_ticker_api.h index 703f100125f..ea62d7c06fa 100644 --- a/libraries/mbed/hal/us_ticker_api.h +++ b/libraries/mbed/hal/us_ticker_api.h @@ -22,24 +22,26 @@ extern "C" { #endif +typedef uint64_t timestamp_t; + uint32_t us_ticker_read(void); typedef void (*ticker_event_handler)(uint32_t id); void us_ticker_set_handler(ticker_event_handler handler); typedef struct ticker_event_s { - uint32_t timestamp; - uint32_t id; + timestamp_t timestamp; + uint32_t id; struct ticker_event_s *next; } ticker_event_t; void us_ticker_init(void); -void us_ticker_set_interrupt(unsigned int timestamp); +void us_ticker_set_interrupt(timestamp_t timestamp); void us_ticker_disable_interrupt(void); void us_ticker_clear_interrupt(void); void us_ticker_irq_handler(void); -void us_ticker_insert_event(ticker_event_t *obj, unsigned int timestamp, uint32_t id); +void us_ticker_insert_event(ticker_event_t *obj, timestamp_t timestamp, uint32_t id); void us_ticker_remove_event(ticker_event_t *obj); #ifdef __cplusplus diff --git a/libraries/mbed/targets/hal/TARGET_NORDIC/TARGET_MCU_NRF51822/us_ticker.c b/libraries/mbed/targets/hal/TARGET_NORDIC/TARGET_MCU_NRF51822/us_ticker.c index ed763eb6522..698fdae0cc0 100644 --- a/libraries/mbed/targets/hal/TARGET_NORDIC/TARGET_MCU_NRF51822/us_ticker.c +++ b/libraries/mbed/targets/hal/TARGET_NORDIC/TARGET_MCU_NRF51822/us_ticker.c @@ -22,8 +22,6 @@ static bool us_ticker_inited = false; static app_timer_id_t us_ticker_appTimerID = TIMER_NULL; -static const unsigned RTC_TO_US_CONVERSION_FACTOR = ((1000000 / APP_TIMER_CLOCK_FREQ) + 1); - void us_ticker_init(void) { if (us_ticker_inited) { @@ -42,9 +40,9 @@ uint32_t us_ticker_read() us_ticker_init(); } - uint32_t value; + timestamp_t value; app_timer_cnt_get(&value); /* This returns the RTC counter (which is fed by the 32khz crystal clock source) */ - return value * RTC_TO_US_CONVERSION_FACTOR; /* Return a pseudo microsecond counter value. + return (uint32_t)((value * 1000000) / APP_TIMER_CLOCK_FREQ); /* Return a pseudo microsecond counter value. * This is only as precise as the 32khz low-freq * clock source, but could be adequate.*/ } @@ -56,7 +54,7 @@ static void us_ticker_app_timer_callback(void *context) us_ticker_irq_handler(); } -void us_ticker_set_interrupt(unsigned int timestamp) +void us_ticker_set_interrupt(timestamp_t timestamp) { static unsigned cachedInterruptTimestamp; @@ -77,11 +75,13 @@ void us_ticker_set_interrupt(unsigned int timestamp) } cachedInterruptTimestamp = timestamp; - uint32_t currentCounter; - app_timer_cnt_get(¤tCounter); - uint32_t targetCounter = (timestamp / RTC_TO_US_CONVERSION_FACTOR) + 1; /* we add 1 to allow for safe round-up of the target. */ + + timestamp_t currentCounter64; + app_timer_cnt_get(¤tCounter64); + uint32_t currentCounter = currentCounter64 & MAX_RTC_COUNTER_VAL; + uint32_t targetCounter = ((uint32_t)((timestamp * (uint64_t)APP_TIMER_CLOCK_FREQ) / 1000000) + 1) & MAX_RTC_COUNTER_VAL; uint32_t ticksToCount = (targetCounter >= currentCounter) ? - (targetCounter - currentCounter) : APP_TIMER_CLOCK_FREQ - (currentCounter - targetCounter); + (targetCounter - currentCounter) : (MAX_RTC_COUNTER_VAL + 1) - (currentCounter - targetCounter); if (ticksToCount > 0) { uint32_t rc; rc = app_timer_start(us_ticker_appTimerID, ticksToCount, NULL /*p_context*/); From 3e42aec35ad5125a97abb66729a3654a0cbf450a Mon Sep 17 00:00:00 2001 From: Rohit Grover Date: Wed, 20 Aug 2014 13:37:44 +0100 Subject: [PATCH 08/11] updated call to APP_TIMER_INIT() to use contants from projectconfig.h --- .../targets/hal/TARGET_NORDIC/TARGET_MCU_NRF51822/us_ticker.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/libraries/mbed/targets/hal/TARGET_NORDIC/TARGET_MCU_NRF51822/us_ticker.c b/libraries/mbed/targets/hal/TARGET_NORDIC/TARGET_MCU_NRF51822/us_ticker.c index 698fdae0cc0..32736a42607 100644 --- a/libraries/mbed/targets/hal/TARGET_NORDIC/TARGET_MCU_NRF51822/us_ticker.c +++ b/libraries/mbed/targets/hal/TARGET_NORDIC/TARGET_MCU_NRF51822/us_ticker.c @@ -18,6 +18,7 @@ #include "cmsis.h" #include "PeripheralNames.h" #include "app_timer.h" +#include "projectconfig.h" static bool us_ticker_inited = false; static app_timer_id_t us_ticker_appTimerID = TIMER_NULL; @@ -29,7 +30,7 @@ void us_ticker_init(void) } const bool useScheduler = false; - APP_TIMER_INIT(0 /* PRESCALAR */, 2 /* num timers */, 1 /* event queue max depth */, useScheduler); + APP_TIMER_INIT(0 /*PRESCALAR*/ , CFG_TIMER_MAX_INSTANCE /* num timers */, CFG_TIMER_OPERATION_QUEUE_SIZE /* event queue max depth */, useScheduler); us_ticker_inited = true; } From d44f83c0c5f5d6fdd714c2acbc65ab727802e0ba Mon Sep 17 00:00:00 2001 From: Rohit Grover Date: Wed, 20 Aug 2014 13:40:08 +0100 Subject: [PATCH 09/11] simplify the algorithm which keeps only one app_timer timer running. --- .../TARGET_MCU_NRF51822/us_ticker.c | 18 ++++++++---------- 1 file changed, 8 insertions(+), 10 deletions(-) diff --git a/libraries/mbed/targets/hal/TARGET_NORDIC/TARGET_MCU_NRF51822/us_ticker.c b/libraries/mbed/targets/hal/TARGET_NORDIC/TARGET_MCU_NRF51822/us_ticker.c index 32736a42607..e133480b9b5 100644 --- a/libraries/mbed/targets/hal/TARGET_NORDIC/TARGET_MCU_NRF51822/us_ticker.c +++ b/libraries/mbed/targets/hal/TARGET_NORDIC/TARGET_MCU_NRF51822/us_ticker.c @@ -20,8 +20,9 @@ #include "app_timer.h" #include "projectconfig.h" -static bool us_ticker_inited = false; -static app_timer_id_t us_ticker_appTimerID = TIMER_NULL; +static bool us_ticker_inited = false; +static volatile bool us_ticker_appTimerRunning = false; +static app_timer_id_t us_ticker_appTimerID = TIMER_NULL; void us_ticker_init(void) { @@ -52,13 +53,12 @@ uint32_t us_ticker_read() * Needed because the irq_handler() doesn't take any parameter.*/ static void us_ticker_app_timer_callback(void *context) { + us_ticker_appTimerRunning = false; us_ticker_irq_handler(); } void us_ticker_set_interrupt(timestamp_t timestamp) { - static unsigned cachedInterruptTimestamp; - if (!us_ticker_inited) { us_ticker_init(); } @@ -68,14 +68,11 @@ void us_ticker_set_interrupt(timestamp_t timestamp) /* placeholder to do something to recover from error */ return; } - } else { - /* we want to avoid taking action on duplicate requests */ - if (timestamp == cachedInterruptTimestamp) { - return; - } } - cachedInterruptTimestamp = timestamp; + if (us_ticker_appTimerRunning) { + return; + } timestamp_t currentCounter64; app_timer_cnt_get(¤tCounter64); @@ -90,6 +87,7 @@ void us_ticker_set_interrupt(timestamp_t timestamp) /* placeholder to do something to recover from error */ return; } + us_ticker_appTimerRunning = true; } } From c2e8e133c097650b1a7fff5fc001d27453a121d0 Mon Sep 17 00:00:00 2001 From: Rohit Grover Date: Wed, 20 Aug 2014 13:47:02 +0100 Subject: [PATCH 10/11] white space diffs. --- .../targets/hal/TARGET_NORDIC/TARGET_MCU_NRF51822/us_ticker.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/libraries/mbed/targets/hal/TARGET_NORDIC/TARGET_MCU_NRF51822/us_ticker.c b/libraries/mbed/targets/hal/TARGET_NORDIC/TARGET_MCU_NRF51822/us_ticker.c index e133480b9b5..30fd6d03e4a 100644 --- a/libraries/mbed/targets/hal/TARGET_NORDIC/TARGET_MCU_NRF51822/us_ticker.c +++ b/libraries/mbed/targets/hal/TARGET_NORDIC/TARGET_MCU_NRF51822/us_ticker.c @@ -45,8 +45,8 @@ uint32_t us_ticker_read() timestamp_t value; app_timer_cnt_get(&value); /* This returns the RTC counter (which is fed by the 32khz crystal clock source) */ return (uint32_t)((value * 1000000) / APP_TIMER_CLOCK_FREQ); /* Return a pseudo microsecond counter value. - * This is only as precise as the 32khz low-freq - * clock source, but could be adequate.*/ + * This is only as precise as the 32khz low-freq + * clock source, but could be adequate.*/ } /* An adaptor to interface us_ticker_irq_handler with the app_timer callback. From dd7e52a49e854cdf73a6946f58748aeb693b1a90 Mon Sep 17 00:00:00 2001 From: Rohit Grover Date: Thu, 21 Aug 2014 11:48:02 +0100 Subject: [PATCH 11/11] update definitions for us_ticker_set_interrupt() across all platforms to use timestamp_t --- .../targets/hal/TARGET_Freescale/TARGET_K20D50M/us_ticker.c | 4 ++-- .../targets/hal/TARGET_Freescale/TARGET_KLXX/us_ticker.c | 4 ++-- .../TARGET_KPSDK_MCUS/TARGET_K64F/us_ticker.c | 4 ++-- .../mbed/targets/hal/TARGET_NXP/TARGET_LPC11U6X/us_ticker.c | 4 ++-- .../mbed/targets/hal/TARGET_NXP/TARGET_LPC11UXX/us_ticker.c | 4 ++-- .../targets/hal/TARGET_NXP/TARGET_LPC11XX_11CXX/us_ticker.c | 4 ++-- .../mbed/targets/hal/TARGET_NXP/TARGET_LPC13XX/us_ticker.c | 4 ++-- .../mbed/targets/hal/TARGET_NXP/TARGET_LPC15XX/us_ticker.c | 2 +- .../mbed/targets/hal/TARGET_NXP/TARGET_LPC176X/us_ticker.c | 4 ++-- .../mbed/targets/hal/TARGET_NXP/TARGET_LPC23XX/us_ticker.c | 4 ++-- .../mbed/targets/hal/TARGET_NXP/TARGET_LPC408X/us_ticker.c | 4 ++-- .../mbed/targets/hal/TARGET_NXP/TARGET_LPC43XX/us_ticker.c | 4 ++-- .../mbed/targets/hal/TARGET_NXP/TARGET_LPC81X/us_ticker.c | 4 ++-- .../targets/hal/TARGET_STM/TARGET_DISCO_F051R8/us_ticker.c | 6 +++--- .../targets/hal/TARGET_STM/TARGET_DISCO_F100RB/us_ticker.c | 6 +++--- .../targets/hal/TARGET_STM/TARGET_DISCO_F303VC/us_ticker.c | 6 +++--- .../targets/hal/TARGET_STM/TARGET_DISCO_F407VG/us_ticker.c | 4 ++-- .../targets/hal/TARGET_STM/TARGET_NUCLEO_F030R8/us_ticker.c | 6 +++--- .../targets/hal/TARGET_STM/TARGET_NUCLEO_F072RB/us_ticker.c | 6 +++--- .../targets/hal/TARGET_STM/TARGET_NUCLEO_F103RB/us_ticker.c | 6 +++--- .../targets/hal/TARGET_STM/TARGET_NUCLEO_F302R8/us_ticker.c | 6 +++--- .../targets/hal/TARGET_STM/TARGET_NUCLEO_F334R8/us_ticker.c | 6 +++--- .../targets/hal/TARGET_STM/TARGET_NUCLEO_F401RE/us_ticker.c | 4 ++-- .../targets/hal/TARGET_STM/TARGET_NUCLEO_F411RE/us_ticker.c | 4 ++-- .../targets/hal/TARGET_STM/TARGET_NUCLEO_L053R8/us_ticker.c | 6 +++--- .../targets/hal/TARGET_STM/TARGET_NUCLEO_L152RE/us_ticker.c | 6 +++--- .../targets/hal/TARGET_STM/TARGET_STM32F3XX/us_ticker.c | 6 +++--- .../targets/hal/TARGET_STM/TARGET_STM32F4XX/us_ticker.c | 4 ++-- 28 files changed, 66 insertions(+), 66 deletions(-) diff --git a/libraries/mbed/targets/hal/TARGET_Freescale/TARGET_K20D50M/us_ticker.c b/libraries/mbed/targets/hal/TARGET_Freescale/TARGET_K20D50M/us_ticker.c index c0666ccd160..4d62e8d37a8 100644 --- a/libraries/mbed/targets/hal/TARGET_Freescale/TARGET_K20D50M/us_ticker.c +++ b/libraries/mbed/targets/hal/TARGET_Freescale/TARGET_K20D50M/us_ticker.c @@ -135,8 +135,8 @@ static void ticker_isr(void) { } } -void us_ticker_set_interrupt(unsigned int timestamp) { - int delta = (int)(timestamp - us_ticker_read()); +void us_ticker_set_interrupt(timestamp_t timestamp) { + int delta = (int)((uint32_t)timestamp - us_ticker_read()); if (delta <= 0) { // This event was in the past: us_ticker_irq_handler(); diff --git a/libraries/mbed/targets/hal/TARGET_Freescale/TARGET_KLXX/us_ticker.c b/libraries/mbed/targets/hal/TARGET_Freescale/TARGET_KLXX/us_ticker.c index 756a9367971..5e70002649b 100644 --- a/libraries/mbed/targets/hal/TARGET_Freescale/TARGET_KLXX/us_ticker.c +++ b/libraries/mbed/targets/hal/TARGET_Freescale/TARGET_KLXX/us_ticker.c @@ -167,8 +167,8 @@ static void lptmr_isr(void) { } } -void us_ticker_set_interrupt(unsigned int timestamp) { - int delta = (int)(timestamp - us_ticker_read()); +void us_ticker_set_interrupt(timestamp_t timestamp) { + int delta = (int)((uint32_t)timestamp - us_ticker_read()); if (delta <= 0) { // This event was in the past: us_ticker_irq_handler(); diff --git a/libraries/mbed/targets/hal/TARGET_Freescale/TARGET_KPSDK_MCUS/TARGET_K64F/us_ticker.c b/libraries/mbed/targets/hal/TARGET_Freescale/TARGET_KPSDK_MCUS/TARGET_K64F/us_ticker.c index 9cd3545e5f8..eeaa6af2572 100644 --- a/libraries/mbed/targets/hal/TARGET_Freescale/TARGET_KPSDK_MCUS/TARGET_K64F/us_ticker.c +++ b/libraries/mbed/targets/hal/TARGET_Freescale/TARGET_KPSDK_MCUS/TARGET_K64F/us_ticker.c @@ -133,8 +133,8 @@ static void lptmr_isr(void) { } } -void us_ticker_set_interrupt(unsigned int timestamp) { - int delta = (int)(timestamp - us_ticker_read()); +void us_ticker_set_interrupt(timestamp_t timestamp) { + int delta = (int)((uint32_t)timestamp - us_ticker_read()); if (delta <= 0) { // This event was in the past: us_ticker_irq_handler(); diff --git a/libraries/mbed/targets/hal/TARGET_NXP/TARGET_LPC11U6X/us_ticker.c b/libraries/mbed/targets/hal/TARGET_NXP/TARGET_LPC11U6X/us_ticker.c index 5ce7098cee7..a38df4d5cea 100644 --- a/libraries/mbed/targets/hal/TARGET_NXP/TARGET_LPC11U6X/us_ticker.c +++ b/libraries/mbed/targets/hal/TARGET_NXP/TARGET_LPC11U6X/us_ticker.c @@ -46,9 +46,9 @@ uint32_t us_ticker_read() { return US_TICKER_TIMER->TC; } -void us_ticker_set_interrupt(unsigned int timestamp) { +void us_ticker_set_interrupt(timestamp_t timestamp) { // set match value - US_TICKER_TIMER->MR0 = timestamp; + US_TICKER_TIMER->MR0 = (uint32_t)timestamp; // enable match interrupt US_TICKER_TIMER->MCR |= 1; } diff --git a/libraries/mbed/targets/hal/TARGET_NXP/TARGET_LPC11UXX/us_ticker.c b/libraries/mbed/targets/hal/TARGET_NXP/TARGET_LPC11UXX/us_ticker.c index 2e41c09220a..059b272233c 100644 --- a/libraries/mbed/targets/hal/TARGET_NXP/TARGET_LPC11UXX/us_ticker.c +++ b/libraries/mbed/targets/hal/TARGET_NXP/TARGET_LPC11UXX/us_ticker.c @@ -46,9 +46,9 @@ uint32_t us_ticker_read() { return US_TICKER_TIMER->TC; } -void us_ticker_set_interrupt(unsigned int timestamp) { +void us_ticker_set_interrupt(timestamp_t timestamp) { // set match value - US_TICKER_TIMER->MR0 = timestamp; + US_TICKER_TIMER->MR0 = (uint32_t)timestamp; // enable match interrupt US_TICKER_TIMER->MCR |= 1; } diff --git a/libraries/mbed/targets/hal/TARGET_NXP/TARGET_LPC11XX_11CXX/us_ticker.c b/libraries/mbed/targets/hal/TARGET_NXP/TARGET_LPC11XX_11CXX/us_ticker.c index 32b7f0d66f5..909263782b7 100644 --- a/libraries/mbed/targets/hal/TARGET_NXP/TARGET_LPC11XX_11CXX/us_ticker.c +++ b/libraries/mbed/targets/hal/TARGET_NXP/TARGET_LPC11XX_11CXX/us_ticker.c @@ -46,9 +46,9 @@ uint32_t us_ticker_read() { return US_TICKER_TIMER->TC; } -void us_ticker_set_interrupt(unsigned int timestamp) { +void us_ticker_set_interrupt(timestamp_t timestamp) { // set match value - US_TICKER_TIMER->MR0 = timestamp; + US_TICKER_TIMER->MR0 = (uint32_t)timestamp; // enable match interrupt US_TICKER_TIMER->MCR |= 1; } diff --git a/libraries/mbed/targets/hal/TARGET_NXP/TARGET_LPC13XX/us_ticker.c b/libraries/mbed/targets/hal/TARGET_NXP/TARGET_LPC13XX/us_ticker.c index 05ba2c80e60..d77495d03ca 100644 --- a/libraries/mbed/targets/hal/TARGET_NXP/TARGET_LPC13XX/us_ticker.c +++ b/libraries/mbed/targets/hal/TARGET_NXP/TARGET_LPC13XX/us_ticker.c @@ -46,9 +46,9 @@ uint32_t us_ticker_read() { return US_TICKER_TIMER->TC; } -void us_ticker_set_interrupt(unsigned int timestamp) { +void us_ticker_set_interrupt(timestamp_t timestamp) { // set match value - US_TICKER_TIMER->MR0 = timestamp; + US_TICKER_TIMER->MR0 = (uint32_t)timestamp; // enable match interrupt US_TICKER_TIMER->MCR |= 1; } diff --git a/libraries/mbed/targets/hal/TARGET_NXP/TARGET_LPC15XX/us_ticker.c b/libraries/mbed/targets/hal/TARGET_NXP/TARGET_LPC15XX/us_ticker.c index 005188578bb..a4ad2d00396 100644 --- a/libraries/mbed/targets/hal/TARGET_NXP/TARGET_LPC15XX/us_ticker.c +++ b/libraries/mbed/targets/hal/TARGET_NXP/TARGET_LPC15XX/us_ticker.c @@ -58,7 +58,7 @@ uint32_t us_ticker_read() { return (uint32_t)temp; } -void us_ticker_set_interrupt(unsigned int timestamp) { +void us_ticker_set_interrupt(timestamp_t timestamp) { uint64_t temp = ((uint64_t)timestamp * (SystemCoreClock/1000000)); LPC_RIT->COMPVAL = (temp & 0xFFFFFFFFL); LPC_RIT->COMPVAL_H = ((temp >> 32)& 0x0000FFFFL); diff --git a/libraries/mbed/targets/hal/TARGET_NXP/TARGET_LPC176X/us_ticker.c b/libraries/mbed/targets/hal/TARGET_NXP/TARGET_LPC176X/us_ticker.c index 651e38eb9bf..b46d75e6bcc 100644 --- a/libraries/mbed/targets/hal/TARGET_NXP/TARGET_LPC176X/us_ticker.c +++ b/libraries/mbed/targets/hal/TARGET_NXP/TARGET_LPC176X/us_ticker.c @@ -48,9 +48,9 @@ uint32_t us_ticker_read() { return US_TICKER_TIMER->TC; } -void us_ticker_set_interrupt(unsigned int timestamp) { +void us_ticker_set_interrupt(timestamp_t timestamp) { // set match value - US_TICKER_TIMER->MR0 = timestamp; + US_TICKER_TIMER->MR0 = (uint32_t)timestamp; // enable match interrupt US_TICKER_TIMER->MCR |= 1; } diff --git a/libraries/mbed/targets/hal/TARGET_NXP/TARGET_LPC23XX/us_ticker.c b/libraries/mbed/targets/hal/TARGET_NXP/TARGET_LPC23XX/us_ticker.c index 651e38eb9bf..b46d75e6bcc 100644 --- a/libraries/mbed/targets/hal/TARGET_NXP/TARGET_LPC23XX/us_ticker.c +++ b/libraries/mbed/targets/hal/TARGET_NXP/TARGET_LPC23XX/us_ticker.c @@ -48,9 +48,9 @@ uint32_t us_ticker_read() { return US_TICKER_TIMER->TC; } -void us_ticker_set_interrupt(unsigned int timestamp) { +void us_ticker_set_interrupt(timestamp_t timestamp) { // set match value - US_TICKER_TIMER->MR0 = timestamp; + US_TICKER_TIMER->MR0 = (uint32_t)timestamp; // enable match interrupt US_TICKER_TIMER->MCR |= 1; } diff --git a/libraries/mbed/targets/hal/TARGET_NXP/TARGET_LPC408X/us_ticker.c b/libraries/mbed/targets/hal/TARGET_NXP/TARGET_LPC408X/us_ticker.c index cda516dca48..c7075b3c880 100644 --- a/libraries/mbed/targets/hal/TARGET_NXP/TARGET_LPC408X/us_ticker.c +++ b/libraries/mbed/targets/hal/TARGET_NXP/TARGET_LPC408X/us_ticker.c @@ -48,9 +48,9 @@ uint32_t us_ticker_read() { return US_TICKER_TIMER->TC; } -void us_ticker_set_interrupt(unsigned int timestamp) { +void us_ticker_set_interrupt(timestamp_t timestamp) { // set match value - US_TICKER_TIMER->MR0 = timestamp; + US_TICKER_TIMER->MR0 = (uint32_t)timestamp; // enable match interrupt US_TICKER_TIMER->MCR |= 1; } diff --git a/libraries/mbed/targets/hal/TARGET_NXP/TARGET_LPC43XX/us_ticker.c b/libraries/mbed/targets/hal/TARGET_NXP/TARGET_LPC43XX/us_ticker.c index 147e0feb1f1..1a9b413636d 100644 --- a/libraries/mbed/targets/hal/TARGET_NXP/TARGET_LPC43XX/us_ticker.c +++ b/libraries/mbed/targets/hal/TARGET_NXP/TARGET_LPC43XX/us_ticker.c @@ -48,9 +48,9 @@ uint32_t us_ticker_read() { return US_TICKER_TIMER->TC; } -void us_ticker_set_interrupt(unsigned int timestamp) { +void us_ticker_set_interrupt(timestamp_t timestamp) { // set match value - US_TICKER_TIMER->MR[3] = timestamp; + US_TICKER_TIMER->MR[3] = (uint32_t)timestamp; // enable match interrupt US_TICKER_TIMER->MCR |= 1; } diff --git a/libraries/mbed/targets/hal/TARGET_NXP/TARGET_LPC81X/us_ticker.c b/libraries/mbed/targets/hal/TARGET_NXP/TARGET_LPC81X/us_ticker.c index cf03fc931a7..c1d1a1c10e8 100644 --- a/libraries/mbed/targets/hal/TARGET_NXP/TARGET_LPC81X/us_ticker.c +++ b/libraries/mbed/targets/hal/TARGET_NXP/TARGET_LPC81X/us_ticker.c @@ -55,13 +55,13 @@ uint32_t us_ticker_read() { return LPC_SCT->COUNT_U; } -void us_ticker_set_interrupt(unsigned int timestamp) { +void us_ticker_set_interrupt(timestamp_t timestamp) { // halt the counter: // - setting bit 2 of the CTRL register LPC_SCT->CTRL_L |= (1 << 2); // set timestamp in compare register - LPC_SCT->MATCH[0].U = timestamp; + LPC_SCT->MATCH[0].U = (uint32_t)timestamp; // unhalt the counter: // - clearing bit 2 of the CTRL register diff --git a/libraries/mbed/targets/hal/TARGET_STM/TARGET_DISCO_F051R8/us_ticker.c b/libraries/mbed/targets/hal/TARGET_STM/TARGET_DISCO_F051R8/us_ticker.c index 24b7225436b..79de93ac7c4 100644 --- a/libraries/mbed/targets/hal/TARGET_STM/TARGET_DISCO_F051R8/us_ticker.c +++ b/libraries/mbed/targets/hal/TARGET_STM/TARGET_DISCO_F051R8/us_ticker.c @@ -90,7 +90,7 @@ void us_ticker_init(void) { // Configure time base TIM_TimeBaseStructInit(&TIM_TimeBaseStructure); TIM_TimeBaseStructure.TIM_Period = 0xFFFF; - TIM_TimeBaseStructure.TIM_Prescaler = (uint16_t)(SystemCoreClock / 1000000) - 1; // 1 µs tick + TIM_TimeBaseStructure.TIM_Prescaler = (uint16_t)(SystemCoreClock / 1000000) - 1; // 1 �s tick TIM_TimeBaseStructure.TIM_ClockDivision = 0; TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up; TIM_TimeBaseInit(TIM_MST, &TIM_TimeBaseStructure); @@ -131,8 +131,8 @@ uint32_t us_ticker_read() { return counter2; } -void us_ticker_set_interrupt(unsigned int timestamp) { - int delta = (int)(timestamp - us_ticker_read()); +void us_ticker_set_interrupt(timestamp_t timestamp) { + int delta = (int)((uint32_t)timestamp - us_ticker_read()); uint16_t cval = TIM_MST->CNT; if (delta <= 0) { // This event was in the past diff --git a/libraries/mbed/targets/hal/TARGET_STM/TARGET_DISCO_F100RB/us_ticker.c b/libraries/mbed/targets/hal/TARGET_STM/TARGET_DISCO_F100RB/us_ticker.c index 0875681abea..7fdf4752c3e 100644 --- a/libraries/mbed/targets/hal/TARGET_STM/TARGET_DISCO_F100RB/us_ticker.c +++ b/libraries/mbed/targets/hal/TARGET_STM/TARGET_DISCO_F100RB/us_ticker.c @@ -92,7 +92,7 @@ void us_ticker_init(void) { // Configure time base TIM_TimeBaseStructInit(&TIM_TimeBaseStructure); TIM_TimeBaseStructure.TIM_Period = 0xFFFF; - TIM_TimeBaseStructure.TIM_Prescaler = (uint16_t)(SystemCoreClock / 1000000) - 1; // 1 µs tick + TIM_TimeBaseStructure.TIM_Prescaler = (uint16_t)(SystemCoreClock / 1000000) - 1; // 1 �s tick TIM_TimeBaseStructure.TIM_ClockDivision = 0; TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up; TIM_TimeBaseInit(TIM_MST, &TIM_TimeBaseStructure); @@ -133,8 +133,8 @@ uint32_t us_ticker_read() { return counter2; } -void us_ticker_set_interrupt(unsigned int timestamp) { - int delta = (int)(timestamp - us_ticker_read()); +void us_ticker_set_interrupt(timestamp_t timestamp) { + int delta = (int)((uint32_t)timestamp - us_ticker_read()); uint16_t cval = TIM_MST->CNT; if (delta <= 0) { // This event was in the past diff --git a/libraries/mbed/targets/hal/TARGET_STM/TARGET_DISCO_F303VC/us_ticker.c b/libraries/mbed/targets/hal/TARGET_STM/TARGET_DISCO_F303VC/us_ticker.c index 9487baea3df..dcf2339a676 100644 --- a/libraries/mbed/targets/hal/TARGET_STM/TARGET_DISCO_F303VC/us_ticker.c +++ b/libraries/mbed/targets/hal/TARGET_STM/TARGET_DISCO_F303VC/us_ticker.c @@ -48,7 +48,7 @@ void us_ticker_init(void) { // Configure time base TIM_TimeBaseStructInit(&TIM_TimeBaseStructure); TIM_TimeBaseStructure.TIM_Period = 0xFFFFFFFF; - TIM_TimeBaseStructure.TIM_Prescaler = (uint16_t)(SystemCoreClock / 1000000) - 1; // 1 µs tick + TIM_TimeBaseStructure.TIM_Prescaler = (uint16_t)(SystemCoreClock / 1000000) - 1; // 1 �s tick TIM_TimeBaseStructure.TIM_ClockDivision = 0; TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up; TIM_TimeBaseInit(TIM_MST, &TIM_TimeBaseStructure); @@ -65,9 +65,9 @@ uint32_t us_ticker_read() { return TIM_MST->CNT; } -void us_ticker_set_interrupt(unsigned int timestamp) { +void us_ticker_set_interrupt(timestamp_t timestamp) { // Set new output compare value - TIM_SetCompare1(TIM_MST, timestamp); + TIM_SetCompare1(TIM_MST, (uint32_t)timestamp); // Enable IT TIM_ITConfig(TIM_MST, TIM_IT_CC1, ENABLE); } diff --git a/libraries/mbed/targets/hal/TARGET_STM/TARGET_DISCO_F407VG/us_ticker.c b/libraries/mbed/targets/hal/TARGET_STM/TARGET_DISCO_F407VG/us_ticker.c index 8f8b32ec4d4..8c2ec6933f2 100644 --- a/libraries/mbed/targets/hal/TARGET_STM/TARGET_DISCO_F407VG/us_ticker.c +++ b/libraries/mbed/targets/hal/TARGET_STM/TARGET_DISCO_F407VG/us_ticker.c @@ -48,9 +48,9 @@ uint32_t us_ticker_read() { return TIM_MST->CNT; } -void us_ticker_set_interrupt(unsigned int timestamp) { +void us_ticker_set_interrupt(timestamp_t timestamp) { // Set new output compare value - __HAL_TIM_SetCompare(&TimMasterHandle, TIM_CHANNEL_1, timestamp); + __HAL_TIM_SetCompare(&TimMasterHandle, TIM_CHANNEL_1, (uint32_t)timestamp); // Enable IT __HAL_TIM_ENABLE_IT(&TimMasterHandle, TIM_IT_CC1); } diff --git a/libraries/mbed/targets/hal/TARGET_STM/TARGET_NUCLEO_F030R8/us_ticker.c b/libraries/mbed/targets/hal/TARGET_STM/TARGET_NUCLEO_F030R8/us_ticker.c index 09bd402ed4a..3d380185a9a 100644 --- a/libraries/mbed/targets/hal/TARGET_STM/TARGET_NUCLEO_F030R8/us_ticker.c +++ b/libraries/mbed/targets/hal/TARGET_STM/TARGET_NUCLEO_F030R8/us_ticker.c @@ -90,7 +90,7 @@ void us_ticker_init(void) { // Configure time base TIM_TimeBaseStructInit(&TIM_TimeBaseStructure); TIM_TimeBaseStructure.TIM_Period = 0xFFFF; - TIM_TimeBaseStructure.TIM_Prescaler = (uint16_t)(SystemCoreClock / 1000000) - 1; // 1 µs tick + TIM_TimeBaseStructure.TIM_Prescaler = (uint16_t)(SystemCoreClock / 1000000) - 1; // 1 �s tick TIM_TimeBaseStructure.TIM_ClockDivision = 0; TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up; TIM_TimeBaseInit(TIM_MST, &TIM_TimeBaseStructure); @@ -131,8 +131,8 @@ uint32_t us_ticker_read() { return counter2; } -void us_ticker_set_interrupt(unsigned int timestamp) { - int delta = (int)(timestamp - us_ticker_read()); +void us_ticker_set_interrupt(timestamp_t timestamp) { + int delta = (int)((uint32_t)timestamp - us_ticker_read()); uint16_t cval = TIM_MST->CNT; if (delta <= 0) { // This event was in the past diff --git a/libraries/mbed/targets/hal/TARGET_STM/TARGET_NUCLEO_F072RB/us_ticker.c b/libraries/mbed/targets/hal/TARGET_STM/TARGET_NUCLEO_F072RB/us_ticker.c index dd887fa1cb6..2970ff48799 100644 --- a/libraries/mbed/targets/hal/TARGET_STM/TARGET_NUCLEO_F072RB/us_ticker.c +++ b/libraries/mbed/targets/hal/TARGET_STM/TARGET_NUCLEO_F072RB/us_ticker.c @@ -50,7 +50,7 @@ void us_ticker_init(void) { // Configure time base TimMasterHandle.Instance = TIM_MST; TimMasterHandle.Init.Period = 0xFFFFFFFF; - TimMasterHandle.Init.Prescaler = (uint32_t)(SystemCoreClock / 1000000) - 1; // 1 µs tick + TimMasterHandle.Init.Prescaler = (uint32_t)(SystemCoreClock / 1000000) - 1; // 1 �s tick TimMasterHandle.Init.ClockDivision = 0; TimMasterHandle.Init.CounterMode = TIM_COUNTERMODE_UP; TimMasterHandle.Init.RepetitionCounter = 0; @@ -68,9 +68,9 @@ uint32_t us_ticker_read() { return TIM_MST->CNT; } -void us_ticker_set_interrupt(unsigned int timestamp) { +void us_ticker_set_interrupt(timestamp_t timestamp) { // Set new output compare value - __HAL_TIM_SetCompare(&TimMasterHandle, TIM_CHANNEL_1, timestamp); + __HAL_TIM_SetCompare(&TimMasterHandle, TIM_CHANNEL_1, (uint32_t)timestamp); // Enable IT __HAL_TIM_ENABLE_IT(&TimMasterHandle, TIM_IT_CC1); } diff --git a/libraries/mbed/targets/hal/TARGET_STM/TARGET_NUCLEO_F103RB/us_ticker.c b/libraries/mbed/targets/hal/TARGET_STM/TARGET_NUCLEO_F103RB/us_ticker.c index 2b10e4cfd1d..bfb8db2e843 100644 --- a/libraries/mbed/targets/hal/TARGET_STM/TARGET_NUCLEO_F103RB/us_ticker.c +++ b/libraries/mbed/targets/hal/TARGET_STM/TARGET_NUCLEO_F103RB/us_ticker.c @@ -83,7 +83,7 @@ void us_ticker_init(void) { // Configure time base TIM_TimeBaseStructInit(&TIM_TimeBaseStructure); TIM_TimeBaseStructure.TIM_Period = 0xFFFF; - TIM_TimeBaseStructure.TIM_Prescaler = (uint16_t)(SystemCoreClock / 1000000) - 1; // 1 µs tick + TIM_TimeBaseStructure.TIM_Prescaler = (uint16_t)(SystemCoreClock / 1000000) - 1; // 1 �s tick TIM_TimeBaseStructure.TIM_ClockDivision = 0; TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up; TIM_TimeBaseInit(TIM_MST, &TIM_TimeBaseStructure); @@ -121,8 +121,8 @@ uint32_t us_ticker_read() { return counter2; } -void us_ticker_set_interrupt(unsigned int timestamp) { - int delta = (int)(timestamp - us_ticker_read()); +void us_ticker_set_interrupt(timestamp_t timestamp) { + int delta = (int)((uint32_t)timestamp - us_ticker_read()); uint16_t cval = TIM_MST->CNT; if (delta <= 0) { // This event was in the past diff --git a/libraries/mbed/targets/hal/TARGET_STM/TARGET_NUCLEO_F302R8/us_ticker.c b/libraries/mbed/targets/hal/TARGET_STM/TARGET_NUCLEO_F302R8/us_ticker.c index e2ffaeb3c37..7fffc3bccd1 100644 --- a/libraries/mbed/targets/hal/TARGET_STM/TARGET_NUCLEO_F302R8/us_ticker.c +++ b/libraries/mbed/targets/hal/TARGET_STM/TARGET_NUCLEO_F302R8/us_ticker.c @@ -48,7 +48,7 @@ void us_ticker_init(void) { // Configure time base TIM_TimeBaseStructInit(&TIM_TimeBaseStructure); TIM_TimeBaseStructure.TIM_Period = 0xFFFFFFFF; - TIM_TimeBaseStructure.TIM_Prescaler = (uint16_t)(SystemCoreClock / 1000000) - 1; // 1 µs tick + TIM_TimeBaseStructure.TIM_Prescaler = (uint16_t)(SystemCoreClock / 1000000) - 1; // 1 �s tick TIM_TimeBaseStructure.TIM_ClockDivision = 0; TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up; TIM_TimeBaseInit(TIM_MST, &TIM_TimeBaseStructure); @@ -65,9 +65,9 @@ uint32_t us_ticker_read() { return TIM_MST->CNT; } -void us_ticker_set_interrupt(unsigned int timestamp) { +void us_ticker_set_interrupt(timestamp_t timestamp) { // Set new output compare value - TIM_SetCompare1(TIM_MST, timestamp); + TIM_SetCompare1(TIM_MST, (uint32_t)timestamp); // Enable IT TIM_ITConfig(TIM_MST, TIM_IT_CC1, ENABLE); } diff --git a/libraries/mbed/targets/hal/TARGET_STM/TARGET_NUCLEO_F334R8/us_ticker.c b/libraries/mbed/targets/hal/TARGET_STM/TARGET_NUCLEO_F334R8/us_ticker.c index 1deccaa0f2c..dd649a9a34d 100644 --- a/libraries/mbed/targets/hal/TARGET_STM/TARGET_NUCLEO_F334R8/us_ticker.c +++ b/libraries/mbed/targets/hal/TARGET_STM/TARGET_NUCLEO_F334R8/us_ticker.c @@ -51,7 +51,7 @@ void us_ticker_init(void) // Configure time base TimMasterHandle.Instance = TIM_MST; TimMasterHandle.Init.Period = 0xFFFFFFFF; - TimMasterHandle.Init.Prescaler = (uint32_t)(SystemCoreClock / 1000000) - 1; // 1 µs tick + TimMasterHandle.Init.Prescaler = (uint32_t)(SystemCoreClock / 1000000) - 1; // 1 �s tick TimMasterHandle.Init.ClockDivision = 0; TimMasterHandle.Init.CounterMode = TIM_COUNTERMODE_UP; TimMasterHandle.Init.RepetitionCounter = 0; @@ -70,10 +70,10 @@ uint32_t us_ticker_read() return TIM_MST->CNT; } -void us_ticker_set_interrupt(unsigned int timestamp) +void us_ticker_set_interrupt(timestamp_t timestamp) { // Set new output compare value - __HAL_TIM_SetCompare(&TimMasterHandle, TIM_CHANNEL_1, timestamp); + __HAL_TIM_SetCompare(&TimMasterHandle, TIM_CHANNEL_1, (uint32_t)timestamp); // Enable IT __HAL_TIM_ENABLE_IT(&TimMasterHandle, TIM_IT_CC1); } diff --git a/libraries/mbed/targets/hal/TARGET_STM/TARGET_NUCLEO_F401RE/us_ticker.c b/libraries/mbed/targets/hal/TARGET_STM/TARGET_NUCLEO_F401RE/us_ticker.c index 8ef83ba041e..3a80ddcedeb 100644 --- a/libraries/mbed/targets/hal/TARGET_STM/TARGET_NUCLEO_F401RE/us_ticker.c +++ b/libraries/mbed/targets/hal/TARGET_STM/TARGET_NUCLEO_F401RE/us_ticker.c @@ -48,9 +48,9 @@ uint32_t us_ticker_read() { return TIM_MST->CNT; } -void us_ticker_set_interrupt(unsigned int timestamp) { +void us_ticker_set_interrupt(timestamp_t timestamp) { // Set new output compare value - __HAL_TIM_SetCompare(&TimMasterHandle, TIM_CHANNEL_1, timestamp); + __HAL_TIM_SetCompare(&TimMasterHandle, TIM_CHANNEL_1, (uint32_t)timestamp); // Enable IT __HAL_TIM_ENABLE_IT(&TimMasterHandle, TIM_IT_CC1); } diff --git a/libraries/mbed/targets/hal/TARGET_STM/TARGET_NUCLEO_F411RE/us_ticker.c b/libraries/mbed/targets/hal/TARGET_STM/TARGET_NUCLEO_F411RE/us_ticker.c index 6e9eaa07aba..be441989922 100644 --- a/libraries/mbed/targets/hal/TARGET_STM/TARGET_NUCLEO_F411RE/us_ticker.c +++ b/libraries/mbed/targets/hal/TARGET_STM/TARGET_NUCLEO_F411RE/us_ticker.c @@ -50,10 +50,10 @@ uint32_t us_ticker_read() return TIM_MST->CNT; } -void us_ticker_set_interrupt(unsigned int timestamp) +void us_ticker_set_interrupt(timestamp_t timestamp) { // Set new output compare value - __HAL_TIM_SetCompare(&TimMasterHandle, TIM_CHANNEL_1, timestamp); + __HAL_TIM_SetCompare(&TimMasterHandle, TIM_CHANNEL_1, (uint32_t)timestamp); // Enable IT __HAL_TIM_ENABLE_IT(&TimMasterHandle, TIM_IT_CC1); } diff --git a/libraries/mbed/targets/hal/TARGET_STM/TARGET_NUCLEO_L053R8/us_ticker.c b/libraries/mbed/targets/hal/TARGET_STM/TARGET_NUCLEO_L053R8/us_ticker.c index 4af44e3e3a4..1b7f9961661 100644 --- a/libraries/mbed/targets/hal/TARGET_STM/TARGET_NUCLEO_L053R8/us_ticker.c +++ b/libraries/mbed/targets/hal/TARGET_STM/TARGET_NUCLEO_L053R8/us_ticker.c @@ -85,7 +85,7 @@ void us_ticker_init(void) { // Configure time base TimMasterHandle.Instance = TIM_MST; TimMasterHandle.Init.Period = 0xFFFF; - TimMasterHandle.Init.Prescaler = (uint32_t)(SystemCoreClock / 1000000) - 1; // 1 µs tick + TimMasterHandle.Init.Prescaler = (uint32_t)(SystemCoreClock / 1000000) - 1; // 1 �s tick TimMasterHandle.Init.ClockDivision = 0; TimMasterHandle.Init.CounterMode = TIM_COUNTERMODE_UP; HAL_TIM_Base_Init(&TimMasterHandle); @@ -123,8 +123,8 @@ uint32_t us_ticker_read() { return counter2; } -void us_ticker_set_interrupt(unsigned int timestamp) { - int delta = (int)(timestamp - us_ticker_read()); +void us_ticker_set_interrupt(timestamp_t timestamp) { + int delta = (int)((uint32_t)timestamp - us_ticker_read()); uint16_t cval = TIM_MST->CNT; if (delta <= 0) { // This event was in the past diff --git a/libraries/mbed/targets/hal/TARGET_STM/TARGET_NUCLEO_L152RE/us_ticker.c b/libraries/mbed/targets/hal/TARGET_STM/TARGET_NUCLEO_L152RE/us_ticker.c index 29dd9d8298e..3fbfac24a77 100644 --- a/libraries/mbed/targets/hal/TARGET_STM/TARGET_NUCLEO_L152RE/us_ticker.c +++ b/libraries/mbed/targets/hal/TARGET_STM/TARGET_NUCLEO_L152RE/us_ticker.c @@ -48,7 +48,7 @@ void us_ticker_init(void) { // Configure time base TIM_TimeBaseStructInit(&TIM_TimeBaseStructure); TIM_TimeBaseStructure.TIM_Period = 0xFFFFFFFF; - TIM_TimeBaseStructure.TIM_Prescaler = (uint16_t)(SystemCoreClock / 1000000) - 1; // 1 µs tick + TIM_TimeBaseStructure.TIM_Prescaler = (uint16_t)(SystemCoreClock / 1000000) - 1; // 1 �s tick TIM_TimeBaseStructure.TIM_ClockDivision = 0; TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up; TIM_TimeBaseInit(TIM_MST, &TIM_TimeBaseStructure); @@ -65,9 +65,9 @@ uint32_t us_ticker_read() { return TIM_MST->CNT; } -void us_ticker_set_interrupt(unsigned int timestamp) { +void us_ticker_set_interrupt(timestamp_t timestamp) { // Set new output compare value - TIM_SetCompare1(TIM_MST, timestamp); + TIM_SetCompare1(TIM_MST, (uint32_t)timestamp); // Enable IT TIM_ITConfig(TIM_MST, TIM_IT_CC1, ENABLE); } diff --git a/libraries/mbed/targets/hal/TARGET_STM/TARGET_STM32F3XX/us_ticker.c b/libraries/mbed/targets/hal/TARGET_STM/TARGET_STM32F3XX/us_ticker.c index e2ffaeb3c37..7fffc3bccd1 100644 --- a/libraries/mbed/targets/hal/TARGET_STM/TARGET_STM32F3XX/us_ticker.c +++ b/libraries/mbed/targets/hal/TARGET_STM/TARGET_STM32F3XX/us_ticker.c @@ -48,7 +48,7 @@ void us_ticker_init(void) { // Configure time base TIM_TimeBaseStructInit(&TIM_TimeBaseStructure); TIM_TimeBaseStructure.TIM_Period = 0xFFFFFFFF; - TIM_TimeBaseStructure.TIM_Prescaler = (uint16_t)(SystemCoreClock / 1000000) - 1; // 1 µs tick + TIM_TimeBaseStructure.TIM_Prescaler = (uint16_t)(SystemCoreClock / 1000000) - 1; // 1 �s tick TIM_TimeBaseStructure.TIM_ClockDivision = 0; TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up; TIM_TimeBaseInit(TIM_MST, &TIM_TimeBaseStructure); @@ -65,9 +65,9 @@ uint32_t us_ticker_read() { return TIM_MST->CNT; } -void us_ticker_set_interrupt(unsigned int timestamp) { +void us_ticker_set_interrupt(timestamp_t timestamp) { // Set new output compare value - TIM_SetCompare1(TIM_MST, timestamp); + TIM_SetCompare1(TIM_MST, (uint32_t)timestamp); // Enable IT TIM_ITConfig(TIM_MST, TIM_IT_CC1, ENABLE); } diff --git a/libraries/mbed/targets/hal/TARGET_STM/TARGET_STM32F4XX/us_ticker.c b/libraries/mbed/targets/hal/TARGET_STM/TARGET_STM32F4XX/us_ticker.c index c80c2a505f9..287768030d6 100644 --- a/libraries/mbed/targets/hal/TARGET_STM/TARGET_STM32F4XX/us_ticker.c +++ b/libraries/mbed/targets/hal/TARGET_STM/TARGET_STM32F4XX/us_ticker.c @@ -47,9 +47,9 @@ uint32_t us_ticker_read() { return US_TICKER_TIMER->CNT; } -void us_ticker_set_interrupt(unsigned int timestamp) { +void us_ticker_set_interrupt(timestamp_t timestamp) { // set match value - US_TICKER_TIMER->CCR1 = timestamp; + US_TICKER_TIMER->CCR1 = (uint32_t)timestamp; // enable compare interrupt US_TICKER_TIMER->DIER |= TIM_DIER_CC1IE; }