/** Initializes GPIO Tasks/Events peripheral. */ static void gpiote_init(void) { NRF_GPIO->OUT = 0x00000000UL; NRF_GPIO->DIRSET = 0x0000FF00UL; NRF_GPIO->DIRCLR = 0x000000FFUL; /* Configuring Button 0 as input */ nrf_gpio_cfg_input(BUTTON0, NRF_GPIO_PIN_NOPULL); /* Configuring Button 1 as input */ /*lint -e{845} // A zero has been given as right argument to operator '|'" */ nrf_gpio_cfg_input(BUTTON1, NRF_GPIO_PIN_NOPULL); /* Configuring Pin PWM_OUTPUT_PIN_NUMBER as output to be used for the PWM waveform */ nrf_gpio_cfg_output(PWM_OUTPUT_PIN_NUMBER); *(uint32_t *)0x40000504 = 0xC007FFDF; // Workaround for PAN_028 rev1.1 anomaly 23 - System: Manual setup is required to enable use of peripherals /* Configure GPIOTE channel 0 to toggle the PWM pin state */ /* Note that we can only connect one GPIOTE task to an output pin */ nrf_gpiote_task_config(0, PWM_OUTPUT_PIN_NUMBER, NRF_GPIOTE_POLARITY_TOGGLE, NRF_GPIOTE_INITIAL_VALUE_HIGH); }
/** * @brief Function for application main entry. */ int main(void) { uint8_t pos=0; // setup // Configure LED-pin as outputs and clear. for (pos=0;pos<LEDPINS;pos++) { nrf_gpio_cfg_output(led_pin[pos]); nrf_gpio_pin_clear(led_pin[pos]); } // loop // Toggle LED. pos=0; while (true) { nrf_gpio_pin_toggle(led_pin[pos]); nrf_delay_ms(1000); pos++; if (pos>=LEDPINS) { pos=0; } } }
/**@brief Function for UART initialization. */ static uint32_t uart_init(app_uart_stream_comm_params_t * p_comm_params) { if (p_comm_params->baud_rate > UART_BAUD_RATE_115200) { return NRF_ERROR_INVALID_PARAM; } NVIC_DisableIRQ(UART0_IRQn); NVIC_ClearPendingIRQ(UART0_IRQn); NRF_UART0->INTENCLR = 0xFFFFFFFF; m_iterations_next_byte_max = m_iteration[p_comm_params->baud_rate]; //Configure UART0 pins. nrf_gpio_cfg_output(p_comm_params->tx_pin_no); nrf_gpio_cfg_input(p_comm_params->rx_pin_no, NRF_GPIO_PIN_NOPULL); NRF_UART0->PSELTXD = p_comm_params->tx_pin_no; NRF_UART0->PSELRXD = p_comm_params->rx_pin_no; NRF_UART0->PSELCTS = UART_PIN_DISCONNECTED; NRF_UART0->PSELRTS = UART_PIN_DISCONNECTED; NRF_UART0->BAUDRATE = m_baud_rates[p_comm_params->baud_rate]; NRF_UART0->CONFIG = (UART_CONFIG_PARITY_Excluded << UART_CONFIG_PARITY_Msk) | (UART_CONFIG_HWFC_Disabled << UART_CONFIG_HWFC_Pos); //Clean out possible events from earlier operations NRF_UART0->EVENTS_RXDRDY = 0; NRF_UART0->EVENTS_TXDRDY = 0; NRF_UART0->EVENTS_ERROR = 0; //Activate UART. NRF_UART0->ENABLE = UART_ENABLE_ENABLE_Enabled; NRF_UART0->INTENSET = 0; NRF_UART0->TASKS_STARTTX = 1; NRF_UART0->TASKS_STARTRX = 1; return NRF_SUCCESS; }
int main() { //APP_GPIOTE_INIT(APP_GPIOTE_MAX_USERS); nrf_gpio_cfg_output(LED_CONNECTED); APP_SCHED_INIT(SCHED_MAX_EVENT_DATA_SIZE, SCHED_QUEUE_SIZE); timers_init(); uart_init(); // blink(); nrf_gpio_pin_clear(LED_CONNECTED); BLEStart(); // timers_start(); // blink(); while (1) { app_sched_execute(); uint32_t err_code = sd_app_evt_wait(); APP_ERROR_CHECK(err_code); //BlueIOADCStart(); } }
int main(int argc, char **argv) { // configure console pins nrf_gpio_cfg_output(TXPIN); nrf_gpio_cfg_input(RXPIN, NRF_GPIO_PIN_NOPULL); nrf_uart_txrx_pins_set(NRF_UART0, TXPIN, RXPIN); // Start lf clock nrf_clock_lf_src_set(NRF_CLOCK_LFCLK_Xtal); nrf_clock_event_clear(NRF_CLOCK_EVENT_LFCLKSTARTED); nrf_clock_task_trigger(NRF_CLOCK_TASK_LFCLKSTART); while (!nrf_clock_event_check(NRF_CLOCK_EVENT_LFCLKSTARTED)); nrf_clock_event_clear(NRF_CLOCK_EVENT_LFCLKSTARTED); SCB->SCR |= SCB_SCR_SLEEPDEEP_Msk; testStart(); return 0; }
static void uart_peripheral_disable(void) { if ((m_tx_state == UART_IDLE || m_tx_state == UART_STALL) && (m_rx_state == UART_IDLE)) { NRF_UART0->TASKS_STOPTX = 1; NRF_UART0->TASKS_STOPRX = 1; NRF_UART0->PSELCTS = UART_PIN_DISCONNECTED; NRF_UART0->PSELRTS = UART_PIN_DISCONNECTED; NRF_UART0->ENABLE = (UART_ENABLE_ENABLE_Disabled << UART_ENABLE_ENABLE_Pos); nrf_gpio_cfg_input(SER_PHY_UART_RTS, NRF_GPIO_PIN_NOPULL); nrf_gpiote_event_config(0, SER_PHY_UART_CTS, NRF_GPIOTE_POLARITY_TOGGLE); if (!nrf_gpio_pin_read(SER_PHY_UART_CTS)) { NRF_GPIO->OUTSET = 1 << SER_PHY_UART_RTS; nrf_gpio_cfg_output(SER_PHY_UART_RTS); uart_peripheral_enable(); } } }
static void pmRunSystem(bool enable) { if (enable) { // Release the reset pin! nrf_gpio_pin_set(STM_NRST_PIN); //Activate UART TX pin nrf_gpio_cfg_output(UART_TX_PIN); nrf_gpio_pin_set(UART_TX_PIN); nrf_gpio_cfg_output(PM_EN1); nrf_gpio_cfg_output(PM_EN2); // Set 500mA current nrf_gpio_pin_set(PM_EN1); nrf_gpio_pin_clear(PM_EN2); // 980mA current // nrf_gpio_pin_clear(PM_EN1); // nrf_gpio_pin_set(PM_EN2); // Enable charging nrf_gpio_cfg_output(PM_CHG_EN); nrf_gpio_pin_clear(PM_CHG_EN); // Enable RF power amplifier nrf_gpio_cfg_output(RADIO_PAEN_PIN); #ifdef DISABLE_PA nrf_gpio_pin_clear(RADIO_PAEN_PIN); #else nrf_gpio_pin_set(RADIO_PAEN_PIN); #endif // Sink battery divider nrf_gpio_cfg_output(PM_VBAT_SINK_PIN); nrf_gpio_pin_clear(PM_VBAT_SINK_PIN); pmStartAdc(adcVBAT); } else { //Disable UART nrf_gpio_cfg_input(UART_TX_PIN, NRF_GPIO_PIN_PULLDOWN); //Hold reset nrf_gpio_pin_clear(STM_NRST_PIN); } }
void app_error_handler(uint32_t error_code, uint32_t line_num, const uint8_t * p_file_name) { // disable INTs CRITICAL_REGION_ENTER(); /* Light a LED on error or warning. */ nrf_gpio_cfg_output(SER_CONN_ASSERT_LED_PIN); nrf_gpio_pin_set(SER_CONN_ASSERT_LED_PIN); // m_p_error_file_name = p_file_name; // m_error_code = error_code; // m_error_line_num = line_num; /* Do not reset when warning. */ if(SER_WARNING_CODE != error_code) { /* This call can be used for debug purposes during application development. * @note CAUTION: Activating code below will write the stack to flash on an error. * This function should NOT be used in a final product. * It is intended STRICTLY for development/debugging purposes. * The flash write will happen EVEN if the radio is active, thus interrupting any communication. * Use with care. Un-comment the line below to use. */ /* ble_debug_assert_handler(error_code, line_num, p_file_name); */ #if 0 /* Reset the chip. Should be used in the release version. */ NVIC_SystemReset(); #else /* Debug version. */ /* To be able to see function parameters in a debugger. */ uint32_t temp = 1; while(temp); #endif CRITICAL_REGION_EXIT(); } }
/**@brief Function for the output pin initialization. * * @details Initializes all output pins used by the application. */ static void pin_output_init(void) { for(uint8_t i = 0; i < PIN_OUTPUT_OFFSET; i++){ nrf_gpio_cfg_output((PIN_OUTPUT_START + i)); nrf_gpio_pin_clear((PIN_OUTPUT_START + i)); } nrf_gpio_cfg_output(LED_CONNECTED_PIN); nrf_gpio_cfg_output(LED_ADVERTISING_PIN); nrf_gpio_cfg_output(LED_MOTOR_TWI_WRITE_PIN); nrf_gpio_cfg_output(LED_RFID_TWI_READ_PIN); nrf_gpio_pin_set(LED_CONNECTED_PIN); nrf_gpio_pin_set(LED_ADVERTISING_PIN); nrf_gpio_pin_set(LED_MOTOR_TWI_WRITE_PIN); nrf_gpio_pin_set(LED_RFID_TWI_READ_PIN); nrf_gpio_cfg_output(PIEZO_BUZZER_PIN); nrf_gpio_pin_clear(PIEZO_BUZZER_PIN); }
/** * @brief Initialize PPI to toggle GPIO pins on radio events. */ static void radio_event_gpio_toggle_init(void) { nrf_gpio_cfg_output(PIN_DBG_RADIO_EVT_END); nrf_gpio_cfg_output(PIN_DBG_RADIO_EVT_DISABLED); nrf_gpio_cfg_output(PIN_DBG_RADIO_EVT_READY); nrf_gpio_cfg_output(PIN_DBG_RADIO_EVT_FRAMESTART); nrf_gpio_cfg_output(PIN_DBG_RADIO_EVT_EDEND); nrf_gpio_cfg_output(PIN_DBG_RADIO_EVT_PHYEND); nrf_gpiote_task_configure(0, PIN_DBG_RADIO_EVT_END, NRF_GPIOTE_POLARITY_TOGGLE, NRF_GPIOTE_INITIAL_VALUE_HIGH); nrf_gpiote_task_configure(1, PIN_DBG_RADIO_EVT_DISABLED, NRF_GPIOTE_POLARITY_TOGGLE, NRF_GPIOTE_INITIAL_VALUE_HIGH); nrf_gpiote_task_configure(2, PIN_DBG_RADIO_EVT_READY, NRF_GPIOTE_POLARITY_TOGGLE, NRF_GPIOTE_INITIAL_VALUE_HIGH); nrf_gpiote_task_configure(3, PIN_DBG_RADIO_EVT_FRAMESTART, NRF_GPIOTE_POLARITY_TOGGLE, NRF_GPIOTE_INITIAL_VALUE_HIGH); nrf_gpiote_task_configure(4, PIN_DBG_RADIO_EVT_EDEND, NRF_GPIOTE_POLARITY_TOGGLE, NRF_GPIOTE_INITIAL_VALUE_HIGH); nrf_gpiote_task_configure(5, PIN_DBG_RADIO_EVT_PHYEND, NRF_GPIOTE_POLARITY_TOGGLE, NRF_GPIOTE_INITIAL_VALUE_HIGH); nrf_gpiote_task_enable(0); nrf_gpiote_task_enable(1); nrf_gpiote_task_enable(2); nrf_gpiote_task_enable(3); nrf_gpiote_task_enable(4); nrf_gpiote_task_enable(5); nrf_ppi_channel_endpoint_setup(NRF_PPI_CHANNEL0, (uint32_t) &NRF_RADIO->EVENTS_END, nrf_gpiote_task_addr_get(NRF_GPIOTE_TASKS_OUT_0)); nrf_ppi_channel_endpoint_setup(NRF_PPI_CHANNEL1, (uint32_t) &NRF_RADIO->EVENTS_DISABLED, nrf_gpiote_task_addr_get(NRF_GPIOTE_TASKS_OUT_1)); nrf_ppi_channel_endpoint_setup(NRF_PPI_CHANNEL2, (uint32_t) &NRF_RADIO->EVENTS_READY, nrf_gpiote_task_addr_get(NRF_GPIOTE_TASKS_OUT_2)); nrf_ppi_channel_endpoint_setup(NRF_PPI_CHANNEL3, (uint32_t) &NRF_RADIO->EVENTS_FRAMESTART, nrf_gpiote_task_addr_get(NRF_GPIOTE_TASKS_OUT_3)); nrf_ppi_channel_endpoint_setup(NRF_PPI_CHANNEL4, (uint32_t) &NRF_RADIO->EVENTS_EDEND, nrf_gpiote_task_addr_get(NRF_GPIOTE_TASKS_OUT_4)); nrf_ppi_channel_endpoint_setup(NRF_PPI_CHANNEL5, (uint32_t) &NRF_RADIO->EVENTS_PHYEND, nrf_gpiote_task_addr_get(NRF_GPIOTE_TASKS_OUT_5)); nrf_ppi_channel_enable(NRF_PPI_CHANNEL0); nrf_ppi_channel_enable(NRF_PPI_CHANNEL1); nrf_ppi_channel_enable(NRF_PPI_CHANNEL2); nrf_ppi_channel_enable(NRF_PPI_CHANNEL3); nrf_ppi_channel_enable(NRF_PPI_CHANNEL4); nrf_ppi_channel_enable(NRF_PPI_CHANNEL5); }
/**@brief Function for the LEDs initialization. */ static void leds_init(void) { nrf_gpio_cfg_output(ADVERTISING_LED_PIN_NO); nrf_gpio_cfg_output(CONNECTED_LED_PIN_NO); nrf_gpio_cfg_output(ASSERT_LED_PIN_NO); }
/**@brief Function for initialization of LEDs. */ static void leds_init(void) { nrf_gpio_cfg_output(UPDATE_IN_PROGRESS_LED); nrf_gpio_pin_set(UPDATE_IN_PROGRESS_LED); }
int main() { static char address[5]; sd_mbr_command(&startSdCmd); sd_softdevice_vector_table_base_set(BOOTLOADER_ADDRESS); // If the master boot switch has detected short or no click: boot the firmware if (((NRF_POWER->GPREGRET&0x86U) != 0x82U) && ((NRF_POWER->GPREGRET&0x40U) != 0x40U) && (*(uint32_t *)FW_ADDRESS != 0xFFFFFFFFU) ) { start_firmware(); } if (NRF_POWER->GPREGRET&0x40U) { address[4] = 0xb1; memcpy(&address[0], (char*)&NRF_FICR->DEVICEADDR[0], 4); esbSetAddress(address); } NRF_POWER->GPREGRET &= ~(0x60U); // Enable the radio LNA nrf_gpio_cfg_output(RADIO_PAEN_PIN); nrf_gpio_pin_set(RADIO_PAEN_PIN); // Initialize timer module. APP_TIMER_INIT(APP_TIMER_PRESCALER, APP_TIMER_MAX_TIMERS, APP_TIMER_OP_QUEUE_SIZE, false); ble_init(); /* NRF_CLOCK->LFCLKSRC = CLOCK_LFCLKSTAT_SRC_Synth; NRF_CLOCK->TASKS_LFCLKSTART = 1UL; while(!NRF_CLOCK->EVENTS_LFCLKSTARTED); */ systickInit(); buttonInit(buttonIdle); #ifndef DEBUG_TIMESLOT //sd_ppi_channel_assign(0, &(NRF_TIMER1->EVENTS_COMPARE[0]), &(NRF_GPIOTE->TASKS_OUT[0])); //sd_ppi_channel_enable_set(PPI_CHEN_CH0_Msk); //NRF_PPI->CH[0].EEP = &(NRF_TIMER1->EVENTS_COMPARE[0]); //NRF_PPI->CH[0].TEP = &(NRF_GPIOTE->TASKS_OUT[0]); //NRF_PPI->CHENSET = 1; #endif // Start (or continue) to blink the LED at 0.5Hz //NRF_TIMER1->TASKS_STOP = 1; //NRF_TIMER1->MODE = TIMER_MODE_MODE_Timer; //NRF_TIMER1->PRESCALER = 7; //NRF_TIMER1->BITMODE = TIMER_BITMODE_BITMODE_16Bit << TIMER_BITMODE_BITMODE_Pos; //NRF_TIMER1->SHORTS = TIMER_SHORTS_COMPARE0_CLEAR_Msk; // | TIMER_SHORTS_COMPARE1_CLEAR_Msk; //NRF_TIMER1->TASKS_CLEAR = 1; NRF_TIMER1->CC[0] = 1*SEC; //0x1E84 ; NRF_TIMER1->CC[1] = 2*SEC; nrf_gpio_cfg_output(LED_PIN); nrf_gpiote_task_config(0, LED_PIN, NRF_GPIOTE_POLARITY_TOGGLE, NRF_GPIOTE_INITIAL_VALUE_LOW); NRF_TIMER1->TASKS_START = 1; // Enable 500mA USB input and enable battery charging nrf_gpio_cfg_output(PM_EN1); nrf_gpio_pin_set(PM_EN1); nrf_gpio_cfg_output(PM_EN2); nrf_gpio_pin_clear(PM_EN2); nrf_gpio_cfg_output(PM_CHG_EN); nrf_gpio_pin_clear(PM_CHG_EN); // Power STM32, hold reset nrf_gpio_cfg_output(PM_VCCEN_PIN); nrf_gpio_pin_set(PM_VCCEN_PIN); nrf_gpio_cfg_output(STM_NRST_PIN); nrf_gpio_pin_clear(STM_NRST_PIN); // Set flow control and activate pull-down on RX data pin nrf_gpio_cfg_output(UART_TX_PIN); nrf_gpio_pin_set(UART_TX_PIN); nrf_gpio_cfg_output(UART_RTS_PIN); nrf_gpio_pin_set(UART_RTS_PIN); nrf_gpio_cfg_input(UART_RX_PIN, NRF_GPIO_PIN_PULLDOWN); nrf_gpio_pin_set(STM_NRST_PIN); //systickInit(); //syslinkInit(); //buttonInit(); // nrf_gpio_cfg_input(BUTTON_PIN, NRF_GPIO_PIN_PULLUP); mainLoop(); while(1); }
/** @brief Function initialization and configuration of RTC driver instance. */ static void gpio_config(void) { // Configure LED-pin as outputs and clear. nrf_gpio_cfg_output(led_pin1); nrf_gpio_pin_clear(led_pin1); }
uint32_t app_uart_init(const app_uart_comm_params_t * p_comm_params, app_uart_buffers_t * p_buffers, app_uart_event_handler_t event_handler, app_irq_priority_t irq_priority, uint16_t * p_app_uart_uid) { uint32_t err_code; m_current_state = UART_OFF; m_event_handler = event_handler; m_rx_byte = BYTE_INVALID; // Configure RX and TX pins. nrf_gpio_pin_set(p_comm_params->tx_pin_no); nrf_gpio_cfg_output(p_comm_params->tx_pin_no); nrf_gpio_cfg_input(p_comm_params->rx_pin_no, NRF_GPIO_PIN_PULLUP); NRF_UART0->PSELTXD = p_comm_params->tx_pin_no; NRF_UART0->PSELRXD = p_comm_params->rx_pin_no; // Configure baud rate and parity. NRF_UART0->BAUDRATE = (p_comm_params->baud_rate << UART_BAUDRATE_BAUDRATE_Pos); if (p_comm_params->use_parity) { NRF_UART0->CONFIG = (UART_CONFIG_PARITY_Included << UART_CONFIG_PARITY_Pos); } else { NRF_UART0->CONFIG = (UART_CONFIG_PARITY_Excluded << UART_CONFIG_PARITY_Pos); } if (p_comm_params->flow_control == APP_UART_FLOW_CONTROL_LOW_POWER) { if (!nrf_drv_gpiote_is_init()) { err_code = nrf_drv_gpiote_init(); if (err_code != NRF_SUCCESS) { return err_code; } } // Configure hardware flow control. nrf_drv_gpiote_out_config_t rts_config = GPIOTE_CONFIG_OUT_SIMPLE(true); err_code = nrf_drv_gpiote_out_init(p_comm_params->rts_pin_no, &rts_config); if (err_code != NRF_SUCCESS) { return err_code; } NRF_UART0->PSELCTS = UART_PIN_DISCONNECTED; NRF_UART0->PSELRTS = p_comm_params->rts_pin_no; NRF_UART0->CONFIG |= (UART_CONFIG_HWFC_Enabled << UART_CONFIG_HWFC_Pos); // Setup the gpiote to handle pin events on cts-pin. // For the UART we want to detect both low->high and high->low transitions in order to // know when to activate/de-activate the TX/RX in the UART. // Configure pin. nrf_drv_gpiote_in_config_t cts_config = GPIOTE_CONFIG_IN_SENSE_TOGGLE(false); err_code = nrf_drv_gpiote_in_init(p_comm_params->cts_pin_no, &cts_config, gpiote_uart_event_handler); if (err_code != NRF_SUCCESS) { return err_code; } nrf_drv_gpiote_in_event_enable(p_comm_params->cts_pin_no, true); // UART CTS pin is active when low. if (nrf_drv_gpiote_in_is_set(p_comm_params->cts_pin_no)) { on_uart_event(ON_CTS_HIGH); } else { on_uart_event(ON_CTS_LOW); } } else if (p_comm_params->flow_control == APP_UART_FLOW_CONTROL_ENABLED) { uart_standard_flow_control_init(p_comm_params); m_current_state = UART_READY; } else { uart_no_flow_control_init(); m_current_state = UART_READY; } if (*p_app_uart_uid == UART_INSTANCE_ID_INVALID) { *p_app_uart_uid = m_instance_counter++; } // Enable UART interrupt NRF_UART0->INTENCLR = 0xffffffffUL; NRF_UART0->INTENSET = (UART_INTENSET_RXDRDY_Set << UART_INTENSET_RXDRDY_Pos) | (UART_INTENSET_TXDRDY_Set << UART_INTENSET_TXDRDY_Pos) | (UART_INTENSET_ERROR_Set << UART_INTENSET_ERROR_Pos); NVIC_ClearPendingIRQ(UART_IRQ); NVIC_SetPriority(UART_IRQ, irq_priority); NVIC_EnableIRQ(UART_IRQ); return NRF_SUCCESS; }
static int uarte_instance_init(struct device *dev, const struct uarte_init_config *config, u8_t interrupts_active) { int err; NRF_UARTE_Type *uarte = get_uarte_instance(dev); struct uarte_nrfx_data *data = get_dev_data(dev); nrf_gpio_pin_write(config->pseltxd, 1); nrf_gpio_cfg_output(config->pseltxd); nrf_gpio_cfg_input(config->pselrxd, NRF_GPIO_PIN_NOPULL); nrf_uarte_txrx_pins_set(uarte, config->pseltxd, config->pselrxd); if (config->hwfc == NRF_UARTE_HWFC_ENABLED) { nrf_gpio_pin_write(config->pselrts, 1); nrf_gpio_cfg_output(config->pselrts); nrf_gpio_cfg_input(config->pselcts, NRF_GPIO_PIN_NOPULL); nrf_uarte_hwfc_pins_set(uarte, config->pselrts, config->pselcts); } /* Configure flow control and parity checking */ nrf_uarte_configure(uarte, config->parity, config->hwfc); err = baudrate_set(dev, config->baudrate); if (err) { return err; } /* Enable receiver and transmitter */ nrf_uarte_enable(uarte); nrf_uarte_event_clear(uarte, NRF_UARTE_EVENT_ENDRX); nrf_uarte_rx_buffer_set(uarte, &data->rx_data, 1); nrf_uarte_task_trigger(uarte, NRF_UARTE_TASK_STARTRX); #if UARTE_INTERRUPT_DRIVEN if (interrupts_active) { /* Set ENDTX event by requesting fake (zero-length) transfer. * Pointer to RAM variable (data->tx_buffer) is set because * otherwise such operation may result in HardFault or RAM * corruption. */ nrf_uarte_tx_buffer_set(uarte, data->tx_buffer, 0); nrf_uarte_task_trigger(uarte, NRF_UARTE_TASK_STARTTX); /* switch off transmitter to save an energy */ nrf_uarte_task_trigger(uarte, NRF_UARTE_TASK_STOPTX); } #endif /* UARTE_INTERRUPT_DRIVEN */ return 0; }
// Application main function. int main(void) { uint32_t err_code; // set up timers APP_TIMER_INIT(0, 4, 4, false); // initlialize BLE ble_stack_init(); gap_params_init(); services_init(); advertising_init(); conn_params_init(); err_code = ble_advertising_start(BLE_ADV_MODE_FAST); APP_ERROR_CHECK(err_code); // init GPIOTE err_code = nrf_drv_gpiote_init(); APP_ERROR_CHECK(err_code); // init PPI err_code = nrf_drv_ppi_init(); APP_ERROR_CHECK(err_code); // intialize UART uart_init(); // prints to serial port printf("starting...\n"); // Create the instance "PWM1" using TIMER1. APP_PWM_INSTANCE(PWM1,1); // RGB LED pins // (Common cathode) uint32_t pinR = 1; uint32_t pinG = 2; uint32_t pinB = 3; // 2-channel PWM, 200Hz app_pwm_config_t pwm1_cfg = APP_PWM_DEFAULT_CONFIG_2CH(5000L, pinR, pinG); /* Initialize and enable PWM. */ err_code = app_pwm_init(&PWM1,&pwm1_cfg,pwm_ready_callback); APP_ERROR_CHECK(err_code); app_pwm_enable(&PWM1); // Create the instance "PWM2" using TIMER2. APP_PWM_INSTANCE(PWM2,2); // 1-channel PWM, 200Hz app_pwm_config_t pwm2_cfg = APP_PWM_DEFAULT_CONFIG_1CH(5000L, pinB); /* Initialize and enable PWM. */ err_code = app_pwm_init(&PWM2,&pwm2_cfg,pwm_ready_callback); APP_ERROR_CHECK(err_code); app_pwm_enable(&PWM2); // Enter main loop. int dir = 1; int val = 0; // main loop: bool pwmEnabled = true; while(1) { // only if not paused if (!pausePWM) { // enable disable as needed if(!enablePWM) { if(pwmEnabled) { app_pwm_disable(&PWM1); app_pwm_disable(&PWM2); // This is required becauase app_pwm_disable() // has a bug. // See: // https://devzone.nordicsemi.com/question/41179/how-to-stop-pwm-and-set-pin-to-clear/ nrf_drv_gpiote_out_task_disable(pinR); nrf_gpio_cfg_output(pinR); nrf_gpio_pin_clear(pinR); nrf_drv_gpiote_out_task_disable(pinG); nrf_gpio_cfg_output(pinG); nrf_gpio_pin_clear(pinG); nrf_drv_gpiote_out_task_disable(pinB); nrf_gpio_cfg_output(pinB); nrf_gpio_pin_clear(pinB); pwmEnabled = false; } } else { if(!pwmEnabled) { // enable PWM nrf_drv_gpiote_out_task_enable(pinR); nrf_drv_gpiote_out_task_enable(pinG); nrf_drv_gpiote_out_task_enable(pinB); app_pwm_enable(&PWM1); app_pwm_enable(&PWM2); pwmEnabled = true; } } if(pwmEnabled) { // Set the duty cycle - keep trying until PWM is ready while (app_pwm_channel_duty_set(&PWM1, 0, val) == NRF_ERROR_BUSY); while (app_pwm_channel_duty_set(&PWM1, 1, val) == NRF_ERROR_BUSY); while (app_pwm_channel_duty_set(&PWM2, 0, val) == NRF_ERROR_BUSY); } // change direction at edges if(val > 99) { dir = -1; } else if (val < 1){ dir = 1; } // increment/decrement val += dir*5; } // delay nrf_delay_ms(delay); } }
void led_init(void) { for (uint8_t i = 0; i < NUM_LEDS; i++) { LED_OFF((board_led_obj_t*)&board_led_obj[i]); nrf_gpio_cfg_output(board_led_obj[i].hw_pin); } }
uint32_t spi_master_open(const spi_master_hw_instance_t spi_master_hw_instance, spi_master_config_t const * const p_spi_master_config) { #if defined(SPI_MASTER_0_ENABLE) || defined(SPI_MASTER_1_ENABLE) /* Check against null */ if (p_spi_master_config == NULL) { return NRF_ERROR_NULL; } volatile spi_master_instance_t * p_spi_instance = spi_master_get_instance( spi_master_hw_instance); APP_ERROR_CHECK_BOOL(p_spi_instance != NULL); switch (spi_master_hw_instance) { #ifdef SPI_MASTER_0_ENABLE case SPI_MASTER_0: spi_master_init_hw_instance(NRF_SPI0, SPI0_TWI0_IRQn, p_spi_instance, p_spi_master_config->SPI_DisableAllIRQ); break; #endif /* SPI_MASTER_0_ENABLE */ #ifdef SPI_MASTER_1_ENABLE case SPI_MASTER_1: spi_master_init_hw_instance(NRF_SPI1, SPI1_TWI1_IRQn, p_spi_instance, p_spi_master_config->SPI_DisableAllIRQ); break; #endif /* SPI_MASTER_1_ENABLE */ default: break; } //A Slave select must be set as high before setting it as output, //because during connect it to the pin it causes glitches. nrf_gpio_pin_set(p_spi_master_config->SPI_Pin_SS); nrf_gpio_cfg_output(p_spi_master_config->SPI_Pin_SS); nrf_gpio_pin_set(p_spi_master_config->SPI_Pin_SS); //Configure GPIO nrf_gpio_cfg_output(p_spi_master_config->SPI_Pin_SCK); nrf_gpio_cfg_output(p_spi_master_config->SPI_Pin_MOSI); nrf_gpio_cfg_input(p_spi_master_config->SPI_Pin_MISO, NRF_GPIO_PIN_NOPULL); p_spi_instance->pin_slave_select = p_spi_master_config->SPI_Pin_SS; /* Configure SPI hardware */ p_spi_instance->p_nrf_spi->PSELSCK = p_spi_master_config->SPI_Pin_SCK; p_spi_instance->p_nrf_spi->PSELMOSI = p_spi_master_config->SPI_Pin_MOSI; p_spi_instance->p_nrf_spi->PSELMISO = p_spi_master_config->SPI_Pin_MISO; p_spi_instance->p_nrf_spi->FREQUENCY = p_spi_master_config->SPI_Freq; p_spi_instance->p_nrf_spi->CONFIG = (uint32_t)(p_spi_master_config->SPI_CONFIG_CPHA << SPI_CONFIG_CPHA_Pos) | (p_spi_master_config->SPI_CONFIG_CPOL << SPI_CONFIG_CPOL_Pos) | (p_spi_master_config->SPI_CONFIG_ORDER << SPI_CONFIG_ORDER_Pos); /* Clear waiting interrupts and events */ p_spi_instance->p_nrf_spi->EVENTS_READY = 0; APP_ERROR_CHECK(sd_nvic_ClearPendingIRQ(p_spi_instance->irq_type)); APP_ERROR_CHECK(sd_nvic_SetPriority(p_spi_instance->irq_type, p_spi_master_config->SPI_PriorityIRQ)); /* Clear event handler */ p_spi_instance->callback_event_handler = NULL; /* Enable interrupt */ p_spi_instance->p_nrf_spi->INTENSET = (SPI_INTENSET_READY_Set << SPI_INTENCLR_READY_Pos); APP_ERROR_CHECK(sd_nvic_EnableIRQ(p_spi_instance->irq_type)); /* Enable SPI hardware */ p_spi_instance->p_nrf_spi->ENABLE = (SPI_ENABLE_ENABLE_Enabled << SPI_ENABLE_ENABLE_Pos); /* Change state to IDLE */ p_spi_instance->state = SPI_MASTER_STATE_IDLE; return NRF_SUCCESS; #else return NRF_ERROR_NOT_SUPPORTED; #endif }
int main(void) { bool init_status; int retValue; int i = defaultPerso.fall_detection_window; // initialize LEDs nrf_gpio_cfg_output(LED_RESETTING); nrf_gpio_cfg_output(LED_NO_FALL); nrf_gpio_cfg_output(LED_FALL_DETECTED); nrf_gpio_cfg_output(LED_OTHER); welcomeLEDs(); // Initialize timers_init(); ble_stack_init(); gap_params_init(); services_init(); advertising_init(); conn_params_init(); sec_params_init(); twi_master_init(); #ifdef TEST_ACTIVITY_LOG testActivityLog(); #endif initActivityLog(); initSnapshotBuffer(); initCoefficients(); // initialize values retValue = 0; init_status = mpu6050_init(MPU6050_DEVICE_ADDR); if ( false == init_status ) { init_status = mpu6050_init(MPU6050_DEVICE_ADDR+1); if ( false == init_status ) { retValue = -1; errorLEDs(); sd_nvic_SystemReset(); } } if ( 0 == retValue ) { init_status = false; i = 0; while ( false == init_status ) { if (i == 6) { errorLEDs(); sd_nvic_SystemReset(); } init_status = accel_setup(); i++; } } if (0 == retValue) { char outbuf[20]; // Start execution - write a log entry with zero steps to indicate startup // writeLogEntry(999); advertising_start(); setup_wdt(); timers_start(); // start sampliing while(1) { if (ReadSnapshots == 1) { FullSnapshotEntry* entry = (FullSnapshotEntry*)(SNAPSHOT_DATA_ADDRESS_START) ; SnapshotHeader *h; Sensor_Reading *r; sprintf (outbuf, "ID: %s ", getPerso()->uname); ble_nus_send_string(&m_nus, (unsigned char*)outbuf, 20); for(int i=0;i < getActivityLogSize(); i++) { h = &entry->hdr; sprintf (outbuf, ": SNAPSHOT # %d \n ",(i)); ble_nus_send_string(&m_nus, (unsigned char*)outbuf, 16); sprintf (outbuf, "Version: 2 \n");// ble_nus_send_string(&m_nus, (unsigned char*)outbuf, 12); sprintf (outbuf, "t:%d n:%d last:%d",h->data.time, h->data.num_of_data_points, h->data.latest_data_point_index); ble_nus_send_string(&m_nus, (unsigned char*)outbuf, 20); // ptr++; r = entry->r; for (int j = 0; j < NUMBER_OF_ENTRIES; j++) { #define FLASH_READ_DELAY 40 nrf_gpio_pin_set(LED_RESETTING); sprintf (outbuf, "i: %d T: %04x ",j,r[j].val.temp); ble_nus_send_string(&m_nus, (unsigned char*)outbuf, 20); nrf_delay_ms(FLASH_READ_DELAY); sprintf (outbuf, "A: x%04xy%04xz%04x",r[j].val.x_ac,r[j].val.y_ac,r[j].val.z_ac); ble_nus_send_string(&m_nus, (unsigned char*)outbuf, 20); nrf_delay_ms(FLASH_READ_DELAY); sprintf (outbuf, "G: x%04xy%04xz%04x",r[j].val.x_gy,r[j].val.y_gy,r[j].val.z_gy); ble_nus_send_string(&m_nus, (unsigned char*)outbuf, 20); nrf_delay_ms(FLASH_READ_DELAY); nrf_gpio_pin_clear(LED_RESETTING); nrf_delay_ms(FLASH_READ_DELAY); //ptr += sizeof(Sensor_Reading); } entry++; } ReadSnapshots = 0; } if (ReadSnapshotsPartial == 1) { PartialSnapTotal = ((PartialSnap1-('0'))*10)+(PartialSnap2-('0')); FullSnapshotEntry* entry = (FullSnapshotEntry*)(SNAPSHOT_DATA_ADDRESS_START+(((PartialSnapTotal*sizeof(FullSnapshotEntry)*10))/4)) ; SnapshotHeader *h; Sensor_Reading *r; sprintf (outbuf, "ID: %s ", getPerso()->uname); ble_nus_send_string(&m_nus, (unsigned char*)outbuf, 20); for(int i=0;i < 10; i++) { h = &entry->hdr; sprintf (outbuf, ": SNAPSHOT # %d \n ",(i+(PartialSnapTotal*10))); ble_nus_send_string(&m_nus, (unsigned char*)outbuf, 16); sprintf (outbuf, "Version: 2 \n");// ble_nus_send_string(&m_nus, (unsigned char*)outbuf, 12); sprintf (outbuf, "t:%d n:%d last:%d",h->data.time, h->data.num_of_data_points, h->data.latest_data_point_index); ble_nus_send_string(&m_nus, (unsigned char*)outbuf, 20); // ptr++; r = entry->r; for (int j = 0; j < NUMBER_OF_ENTRIES; j++) { #define FLASH_READ_DELAY 40 nrf_gpio_pin_set(LED_RESETTING); sprintf (outbuf, "i: %d T: %04x ",j,r[j].val.temp); ble_nus_send_string(&m_nus, (unsigned char*)outbuf, 20); nrf_delay_ms(FLASH_READ_DELAY); sprintf (outbuf, "A: x%04xy%04xz%04x",r[j].val.x_ac,r[j].val.y_ac,r[j].val.z_ac); ble_nus_send_string(&m_nus, (unsigned char*)outbuf, 20); nrf_delay_ms(FLASH_READ_DELAY); sprintf (outbuf, "G: x%04xy%04xz%04x",r[j].val.x_gy,r[j].val.y_gy,r[j].val.z_gy); ble_nus_send_string(&m_nus, (unsigned char*)outbuf, 20); nrf_delay_ms(FLASH_READ_DELAY); nrf_gpio_pin_clear(LED_RESETTING); nrf_delay_ms(FLASH_READ_DELAY); //ptr += sizeof(Sensor_Reading); } entry++; } ReadSnapshotsPartial = 0; } if (ReadDataBuffer == 1) { LogEntry *addr; sprintf (outbuf, "ID: %s ", getPerso()->uname); ble_nus_send_string(&m_nus, (unsigned char*)outbuf, 20); addr = (LogEntry *)(STEP_DATA_ADDRESS_START); for(int i=0;i < getActivityLogSize(); i++) { nrf_gpio_pin_set(LED_RESETTING); nrf_delay_ms(20); nrf_gpio_pin_clear(LED_RESETTING); nrf_delay_ms(20); // sprintf ( outbuf, ": h:%d s:%d a:%04f ",addr->item.hour, addr->item.sec, addr->item.activity_level); sprintf ( outbuf, "%d:%d - %03f ",addr->item.hour, (addr->item.sec)/60, addr->item.activity_level); ble_nus_send_string(&m_nus, (unsigned char*)outbuf, 20); //nrf_delay_ms(1); addr++; } ReadDataBuffer = 0; } if (ReadDataBufferPartial == 1) { LogEntry *addr; sprintf (outbuf, "ID: %s ", getPerso()->uname); ble_nus_send_string(&m_nus, (unsigned char*)outbuf, 20); PartialCountTotal = ((PartialCount1-('0'))*10)+(PartialCount2-('0')); addr = (LogEntry *)(STEP_DATA_ADDRESS_START+(2*(PartialCountTotal*1000))); for(int i=0;i < 1000; i++) { nrf_gpio_pin_set(LED_RESETTING); nrf_delay_ms(20); nrf_gpio_pin_clear(LED_RESETTING); nrf_delay_ms(20); // sprintf ( outbuf, ": h:%d s:%d a:%04f ",addr->item.hour, addr->item.sec, addr->item.activity_level); sprintf ( outbuf, "%d:%d - %03f ",addr->item.hour, (addr->item.sec)/60, addr->item.activity_level); ble_nus_send_string(&m_nus, (unsigned char*)outbuf, 20); //nrf_delay_ms(1); addr++; } ReadDataBufferPartial = 0; } if (Dumper == 1) { sprintf (outbuf, "Log: %d ",getActivityLogSize()); ble_nus_send_string(&m_nus, (unsigned char*)outbuf, 20); Dumper = 0; } if (ReadBigSnapshot == 1) { SnapshotHeader *h = getSnapshotHeader(); sprintf (outbuf, "t:%d n:%d last:%d",h->data.time, h->data.num_of_data_points, h->data.latest_data_point_index); ble_nus_send_string(&m_nus, (unsigned char*)outbuf, 20); for (i = 0; i < NUMBER_OF_ENTRIES; i++) //i <= h->data.latest_data_point_index; i++) { #define RAM_READ_DELAY 15 sprintf (outbuf, "i: %d T: %04x ",i,raw_data[i].val.temp); ble_nus_send_string(&m_nus, (unsigned char*)outbuf, 20); nrf_delay_ms(RAM_READ_DELAY); sprintf (outbuf, "A: x%04xy%04xz%04x",raw_data[i].val.x_ac,raw_data[i].val.y_ac,raw_data[i].val.z_ac); ble_nus_send_string(&m_nus, (unsigned char*)outbuf, 20); nrf_delay_ms(RAM_READ_DELAY); sprintf (outbuf, "G: x%04xy%04xz%04x",raw_data[i].val.x_gy,raw_data[i].val.y_gy,raw_data[i].val.z_gy); ble_nus_send_string(&m_nus, (unsigned char*)outbuf, 20); nrf_delay_ms(RAM_READ_DELAY); } ReadBigSnapshot = 0; } if (do_post_processing == true) { do_post_processing = false; if (emergencyCall == 1) { makeTheCall(); emergencyCall = 0; } post_comm_processing(); } // Power Method 1 // nrf_gpio_pin_write(LED_OTHER,1); // power_manage(); // nrf_gpio_pin_write(LED_OTHER,0); } } return retValue; }
/******************************************************************************* * Function Name : SSD1306_Init * Description : Initialize display *******************************************************************************/ void SSD1306_Init() { nrf_gpio_cfg_output(D_CS); nrf_gpio_cfg_output(D_DC); nrf_gpio_cfg_output(D_RESET); nrf_gpio_cfg_output(SPI_CLK); nrf_gpio_cfg_output(SPI_MOSI); NRF_SPI0->PSELSCK = SPI_CLK; NRF_SPI0->PSELMOSI = SPI_MOSI; NRF_SPI0->FREQUENCY = (uint32_t) 0x80000000;//0x02000000 NRF_SPI0->CONFIG = (SPI_CONFIG_CPHA_Leading << SPI_CONFIG_CPHA_Pos) | (SPI_CONFIG_CPOL_ActiveHigh << SPI_CONFIG_CPOL_Pos) | (SPI_CONFIG_ORDER_MsbFirst << SPI_CONFIG_ORDER_Pos); NRF_SPI0->EVENTS_READY = 0U; NRF_SPI0->ENABLE = (SPI_ENABLE_ENABLE_Enabled << SPI_ENABLE_ENABLE_Pos); RESET_H; nrf_delay_us(10000); RESET_L; nrf_delay_us(50000); RESET_H; // Init sequence for 128x64 OLED module SSD1306_Command(SSD1306_DISPLAYOFF); // 0xAE SSD1306_Command(SSD1306_SETDISPLAYCLOCKDIV); // 0xD5 SSD1306_Command(0x80); // the suggested ratio 0x80 SSD1306_Command(SSD1306_SETMULTIPLEX); // 0xA8 SSD1306_Command(0x3F); SSD1306_Command(SSD1306_SETDISPLAYOFFSET); // 0xD3 SSD1306_Command(0x0); // no offset SSD1306_Command(SSD1306_SETSTARTLINE | 0x0); // line #0 SSD1306_Command(SSD1306_CHARGEPUMP); // 0x8D #if 0 SSD1306_Command(0x10); // SSD1306_EXTERNALVCC #else SSD1306_Command(0x14); #endif SSD1306_Command(SSD1306_MEMORYMODE); // 0x20 SSD1306_Command(0x00); // 0x0 act like ks0108 SSD1306_Command(SSD1306_SEGREMAP | 0x1); SSD1306_Command(SSD1306_COMSCANDEC); SSD1306_Command(SSD1306_SETCOMPINS); // 0xDA SSD1306_Command(0x12); SSD1306_Command(SSD1306_SETCONTRAST); // 0x81 #if 0 SSD1306_Command(0x9F); // SSD1306_EXTERNALVCC) #else SSD1306_Command(0xCF); #endif SSD1306_Command(SSD1306_SETPRECHARGE); // 0xd9 #if 0 SSD1306_Command(0x22); // SSD1306_EXTERNALVCC) #else SSD1306_Command(0xF1); #endif SSD1306_Command(SSD1306_SETVCOMDETECT); // 0xDB SSD1306_Command(0x40); SSD1306_Command(SSD1306_DISPLAYALLON_RESUME); // 0xA4 SSD1306_Command(SSD1306_NORMALDISPLAY); // 0xA6 SSD1306_Command(SSD1306_DISPLAYON); //--turn on oled panel nrf_delay_us(100000); //SSD1306_ReDraw(); //orient = LANDSCAPE; orient = PORTRAIT; }
/*JSON{ "type" : "function", "name" : "show", "generate" : "jswrap_microbit_show", "params" : [ ["image","JsVar","The image to show"] ] } Show an image on the in-built 5x5 LED screen. Image can be: * A number where each bit represents a pixel (so 25 bits) */ void jswrap_microbit_show(JsVar *image) { if (!jsvIsInt(image)) { jsError("Expecting a number, got %t\n", image); return; } uint32_t newState = jsvGetInteger(image); if ((newState!=0) && (microbitLEDState==0)) { // we want to display something but we don't have an interval jstExecuteFn(jswrap_microbit_display_callback, jshGetTimeFromMilliseconds(5)); // and also set pins to outputs nrf_gpio_cfg_output(MB_LED_COL1); nrf_gpio_cfg_output(MB_LED_COL2); nrf_gpio_cfg_output(MB_LED_COL3); nrf_gpio_cfg_output(MB_LED_COL4); nrf_gpio_cfg_output(MB_LED_COL5); nrf_gpio_cfg_output(MB_LED_COL6); nrf_gpio_cfg_output(MB_LED_COL7); nrf_gpio_cfg_output(MB_LED_COL8); nrf_gpio_cfg_output(MB_LED_COL9); nrf_gpio_cfg_output(MB_LED_ROW1); nrf_gpio_cfg_output(MB_LED_ROW2); nrf_gpio_cfg_output(MB_LED_ROW3); } else if ((newState==0) && (microbitLEDState!=0)) { jswrap_microbit_stopDisplay(); } microbitLEDState = newState; }
void LED_Init(void) { // Configure LED-pins as outputs nrf_gpio_cfg_output(LED_0); nrf_gpio_cfg_output(LED_1); }
/*====================================================================================================*/ void GPIO_Config( void ) { nrf_gpio_range_cfg_output(1, 6); nrf_gpio_cfg_output(8); }
void pinMode(uint32_t pin, int mode) { if (mode == OUTPUT) { nrf_gpio_cfg_output(pin); } }
uint32_t* spi_master_init(SPIModuleNumber module_number, SPIMode mode, bool lsb_first) { uint32_t config_mode; NRF_SPI_Type *spi_base_address = (SPI0 == module_number)? NRF_SPI0 : (NRF_SPI_Type *)NRF_SPI1; if(SPI0 == module_number) { /* Configure GPIO pins used for pselsck, pselmosi, pselmiso and pselss for SPI0 */ nrf_gpio_cfg_output(SPI_PSELSCK0); nrf_gpio_cfg_output(SPI_PSELMOSI0); nrf_gpio_cfg_input(SPI_PSELMISO0, NRF_GPIO_PIN_NOPULL); nrf_gpio_cfg_output(SPI_PSELSS0); /* Configure pins, frequency and mode */ spi_base_address->PSELSCK = SPI_PSELSCK0; spi_base_address->PSELMOSI = SPI_PSELMOSI0; spi_base_address->PSELMISO = SPI_PSELMISO0; nrf_gpio_pin_set(SPI_PSELSS0); /* disable Set slave select (inactive high) */ } else { /* Configure GPIO pins used for pselsck, pselmosi, pselmiso and pselss for SPI1*/ nrf_gpio_cfg_output(SPI_PSELSCK1); nrf_gpio_cfg_output(SPI_PSELMOSI1); nrf_gpio_cfg_input(SPI_PSELMISO1, NRF_GPIO_PIN_NOPULL); nrf_gpio_cfg_output(SPI_PSELSS1); /* Configure pins, frequency and mode */ spi_base_address->PSELSCK = SPI_PSELSCK1; spi_base_address->PSELMOSI = SPI_PSELMOSI1; spi_base_address->PSELMISO = SPI_PSELMISO1; nrf_gpio_pin_set(SPI_PSELSS1); /* disable Set slave select (inactive high) */ } spi_base_address->FREQUENCY = (uint32_t) SPI_OPERATING_FREQUENCY; /*lint -e845 -save // A zero has been given as right argument to operator '!'" */ /** @snippet [SPI Select mode] */ switch (mode ) { case SPI_MODE0: config_mode = (SPI_CONFIG_CPHA_Leading << SPI_CONFIG_CPHA_Pos) | (SPI_CONFIG_CPOL_ActiveHigh << SPI_CONFIG_CPOL_Pos); break; case SPI_MODE1: config_mode = (SPI_CONFIG_CPHA_Trailing << SPI_CONFIG_CPHA_Pos) | (SPI_CONFIG_CPOL_ActiveHigh << SPI_CONFIG_CPOL_Pos); break; case SPI_MODE2: config_mode = (SPI_CONFIG_CPHA_Leading << SPI_CONFIG_CPHA_Pos) | (SPI_CONFIG_CPOL_ActiveLow << SPI_CONFIG_CPOL_Pos); break; case SPI_MODE3: config_mode = (SPI_CONFIG_CPHA_Trailing << SPI_CONFIG_CPHA_Pos) | (SPI_CONFIG_CPOL_ActiveLow << SPI_CONFIG_CPOL_Pos); break; default: config_mode = 0; break; } /** @snippet [SPI Select mode] */ /*lint -restore */ /*lint -e845 -save // A zero has been given as right argument to operator '!'" */ /** @snippet [SPI Select endianess] */ if (lsb_first) { spi_base_address->CONFIG = (config_mode | (SPI_CONFIG_ORDER_LsbFirst << SPI_CONFIG_ORDER_Pos)); } else { spi_base_address->CONFIG = (config_mode | (SPI_CONFIG_ORDER_MsbFirst << SPI_CONFIG_ORDER_Pos)); } /** @snippet [SPI Select endianess] */ /*lint -restore */ spi_base_address->EVENTS_READY = 0U; /* Enable */ spi_base_address->ENABLE = (SPI_ENABLE_ENABLE_Enabled << SPI_ENABLE_ENABLE_Pos); return (uint32_t *)spi_base_address; }
/**@brief Function for the LEDs initialization. * * @details Initializes all LEDs used by this application. */ static void leds_init(void) { nrf_gpio_cfg_output(LED_RQ_PENDING); nrf_gpio_cfg_output(LED_CONNECTED); }
// Initialize IO static void rino_init(void) { nrf_gpio_pin_clear(NRF51_TO_RT5350_MAIL_IO); nrf_gpio_cfg_output(NRF51_TO_RT5350_MAIL_IO); nrf_gpio_pin_clear(NRF51_TO_RT5350_MAIL_IO); }
/**@brief Function for initialization of LEDs. */ static void leds_init(void) { nrf_gpio_cfg_output(LED_0); nrf_gpio_cfg_output(LED_1); }
/**@brief Init the SPI and the CS pin. */ void spi_init(){ sdcard_spi_addr = spi_master_init(SPI0, SPI_MODE0, 0); nrf_gpio_cfg_output(MMCSD_PIN_SELECT); nrf_gpio_pin_set(MMCSD_PIN_SELECT); }