static void qenc_init_gpiote(nrf_qdec_ledpol_t led_pol)
{
nrf_drv_gpiote_in_config_t config = GPIOTE_CONFIG_IN_SENSE_HITOLO(true);
nrf_drv_gpiote_out_config_t out_config = GPIOTE_CONFIG_OUT_SIMPLE(false);
config.pull = NRF_GPIO_PIN_PULLUP;
if (!nrf_drv_gpiote_is_init())
{
(void)nrf_drv_gpiote_init();
}
// change state on inactive edge of led pulse
if (led_pol == NRF_QDEC_LEPOL_ACTIVE_LOW)
{
config.sense = NRF_GPIOTE_POLARITY_HITOLO;
}
(void)nrf_drv_gpiote_in_init(QENC_CONFIG_PIO_LED,&config,gpiote_event_handler);
nrf_drv_gpiote_in_event_enable(QENC_CONFIG_PIO_LED, true);
//Configure output pins.
(void)nrf_drv_gpiote_out_init(QENC_CONFIG_PIO_A, &out_config);
(void)nrf_drv_gpiote_out_init(QENC_CONFIG_PIO_B, &out_config);
}
static void led_blinking_setup()
{
uint32_t compare_evt_addr;
uint32_t gpiote_task_addr;
nrf_ppi_channel_t ppi_channel;
ret_code_t err_code;
nrf_drv_gpiote_out_config_t config = GPIOTE_CONFIG_OUT_TASK_TOGGLE(false);
err_code = nrf_drv_gpiote_out_init(GPIO_OUTPUT_PIN_NUMBER, &config);
APP_ERROR_CHECK(err_code);
nrf_drv_timer_extended_compare(&timer, (nrf_timer_cc_channel_t)0, 200 * 1000UL, NRF_TIMER_SHORT_COMPARE0_CLEAR_MASK, false);
err_code = nrf_drv_ppi_channel_alloc(&ppi_channel);
APP_ERROR_CHECK(err_code);
compare_evt_addr = nrf_drv_timer_event_address_get(&timer, NRF_TIMER_EVENT_COMPARE0);
gpiote_task_addr = nrf_drv_gpiote_out_task_addr_get(GPIO_OUTPUT_PIN_NUMBER);
err_code = nrf_drv_ppi_channel_assign(ppi_channel, compare_evt_addr, gpiote_task_addr);
APP_ERROR_CHECK(err_code);
err_code = nrf_drv_ppi_channel_enable(ppi_channel);
APP_ERROR_CHECK(err_code);
nrf_drv_gpiote_out_task_enable(GPIO_OUTPUT_PIN_NUMBER);
}
/**
* Public methods
*/
void initLEDDriver(void)
{
ret_code_t err_code;
// gpioteモジュールを初期化する
if(!nrf_drv_gpiote_is_init()) {
err_code = nrf_drv_gpiote_init();
APP_ERROR_CHECK(err_code);
}
nrf_drv_gpiote_out_config_t out_config;
out_config.init_state = NRF_GPIOTE_INITIAL_VALUE_LOW;
out_config.task_pin = false;
err_code = nrf_drv_gpiote_out_init(PIN_NUMBER_LED, &out_config);
APP_ERROR_CHECK(err_code);
// 変数の初期化
m_pattern_index = 0;
m_blink_count = 1;
m_blank_period = 1000;
// タイマーの初期化
err_code = app_timer_create(&(m_led_timer_id), APP_TIMER_MODE_REPEATED, led_timer_handler);
APP_ERROR_CHECK(err_code);
err_code = app_timer_start(m_led_timer_id,
APP_TIMER_TICKS(100, APP_TIMER_PRESCALER),
NULL);
APP_ERROR_CHECK(err_code);
}
static void spi_slave_gpiote_init(void)
{
if (!nrf_drv_gpiote_is_init())
{
(void)nrf_drv_gpiote_init();
}
nrf_drv_gpiote_out_config_t config = GPIOTE_CONFIG_OUT_TASK_TOGGLE(true);
(void)nrf_drv_gpiote_out_init(m_spi_slave_raw_config.gpiote_rdy_ch, &config);
return;
}
static void gpio_apply_config(uint8_t pin)
{
if (m_gpio_initialized & (1UL << pin)) {
if ((m_gpio_cfg[pin].direction == PIN_OUTPUT) && (!m_gpio_cfg[pin].used_as_irq)) {
nrf_drv_gpiote_out_uninit(pin);
}
else {
nrf_drv_gpiote_in_uninit(pin);
}
}
if (m_gpio_cfg[pin].used_as_gpio || m_gpio_cfg[pin].used_as_irq) {
if ((m_gpio_cfg[pin].direction == PIN_INPUT)
|| (m_gpio_cfg[pin].used_as_irq)) {
//Configure as input.
nrf_drv_gpiote_in_config_t cfg;
cfg.hi_accuracy = false;
cfg.is_watcher = false;
cfg.sense = NRF_GPIOTE_POLARITY_TOGGLE;
if (m_gpio_cfg[pin].used_as_irq) {
cfg.pull = NRF_GPIO_PIN_PULLUP;
nrf_drv_gpiote_in_init(pin, &cfg, gpiote_irq_handler);
if ((m_gpio_irq_enabled & (1 << pin))
&& (m_gpio_cfg[pin].irq_rise || m_gpio_cfg[pin].irq_fall))
{
nrf_drv_gpiote_in_event_enable(pin, true);
}
}
else {
switch(m_gpio_cfg[pin].pull) {
case PullUp:
cfg.pull = NRF_GPIO_PIN_PULLUP;
break;
case PullDown:
cfg.pull = NRF_GPIO_PIN_PULLDOWN;
break;
default:
cfg.pull = NRF_GPIO_PIN_NOPULL;
break;
}
nrf_drv_gpiote_in_init(pin, &cfg, NULL);
}
}
else {
// Configure as output.
nrf_drv_gpiote_out_config_t cfg = GPIOTE_CONFIG_OUT_SIMPLE(m_gpio_cfg[pin].init_high);
nrf_drv_gpiote_out_init(pin, &cfg);
}
m_gpio_initialized |= (1UL << pin);
}
else {
m_gpio_initialized &= ~(1UL << pin);
}
}
/**
* @brief GPIO初期化
*/
static void gpio_init(void)
{
ret_code_t err_code;
nrf_drv_gpiote_out_config_t out_config = GPIOTE_CONFIG_OUT_SIMPLE(true); /* 初期値 : 1 */
nrf_drv_gpiote_in_config_t in_config = GPIOTE_CONFIG_IN_SENSE_HITOLO(true); /* 立ち下がり,EVENT使用 */
err_code = nrf_drv_gpiote_init();
APP_ERROR_CHECK(err_code);
/* output */
err_code = nrf_drv_gpiote_out_init(LED_PIN_NO_ADVERTISING, &out_config);
APP_ERROR_CHECK(err_code);
err_code = nrf_drv_gpiote_out_init(LED_PIN_NO_CONNECTED, &out_config);
APP_ERROR_CHECK(err_code);
err_code = nrf_drv_gpiote_out_init(LED_PIN_NO_ASSERT, &out_config);
APP_ERROR_CHECK(err_code);
/* input */
in_config.pull = NRF_GPIO_PIN_NOPULL;
err_code = nrf_drv_gpiote_in_init(RCS730_IRQ, &in_config, gpiote_irq_handler);
APP_ERROR_CHECK(err_code);
nrf_drv_gpiote_in_event_enable(RCS730_IRQ, true);
}
void setup_example(void)
{
uint32_t event;
nrf_ppi_channel_t ppi_channel;
uint32_t err_code;
nrf_gpio_cfg_output(BSP_LED_0);
err_code = nrf_drv_rtc_init(&rtc, NULL, rtc_evt_handler);
APP_ERROR_CHECK(err_code);
nrf_drv_rtc_tick_enable(&rtc, false);
event = nrf_drv_rtc_event_address_get(&rtc, NRF_RTC_EVENT_TICK);
if (!nrf_drv_gpiote_is_init())
{
err_code = nrf_drv_gpiote_init();
APP_ERROR_CHECK(err_code);
}
nrf_drv_gpiote_out_config_t pin_out_config = GPIOTE_CONFIG_OUT_TASK_TOGGLE(false);
err_code = nrf_drv_gpiote_out_init(BSP_LED_0,&pin_out_config);
APP_ERROR_CHECK(err_code);
nrf_drv_gpiote_out_task_enable(BSP_LED_0);
uint32_t gpiote_task_addr = nrf_drv_gpiote_out_task_addr_get(BSP_LED_0);
err_code = nrf_drv_ppi_init();
APP_ERROR_CHECK(err_code);
err_code = nrf_drv_ppi_channel_alloc(&ppi_channel);
APP_ERROR_CHECK(err_code);
err_code = nrf_drv_ppi_channel_assign(ppi_channel,event,gpiote_task_addr);
APP_ERROR_CHECK(err_code);
err_code = nrf_drv_ppi_channel_enable(ppi_channel);
APP_ERROR_CHECK(err_code);
nrf_drv_rtc_enable(&rtc);
}
static void gpio_init(void)
{
ret_code_t err_code;
err_code = nrf_drv_gpiote_init();
APP_ERROR_CHECK(err_code);
nrf_drv_gpiote_out_config_t out_config = GPIOTE_CONFIG_OUT_SIMPLE(false);
err_code = nrf_drv_gpiote_out_init(PIN_OUT, &out_config);
APP_ERROR_CHECK(err_code);
nrf_drv_gpiote_in_config_t in_config = GPIOTE_CONFIG_IN_SENSE_TOGGLE(true);
in_config.pull = NRF_GPIO_PIN_PULLUP;
err_code = nrf_drv_gpiote_in_init(PIN_IN, &in_config, in_pin_handler);
APP_ERROR_CHECK(err_code);
nrf_drv_gpiote_in_event_enable(PIN_IN, true);
}
/**
* @brief Initialise LED control pins
*/
void led_init()
{
nrf_drv_gpiote_out_config_t config = GPIOTE_CONFIG_OUT_SIMPLE(false);
uint32_t pin;
uint32_t err_code;
/* Initialise RGB LED */
for(pin = LED_RED; pin <= LED_BLUE; pin++)
{
/* Set pin mode */
err_code = nrf_drv_gpiote_out_init(led_rgb_pin[pin], &config);
APP_ERROR_CHECK(err_code);
/* Configure high drive */
NRF_GPIO->PIN_CNF[led_rgb_pin[pin]] =
(GPIO_PIN_CNF_DRIVE_H0S1 << GPIO_PIN_CNF_DRIVE_Pos) |
(GPIO_PIN_CNF_DIR_Output << GPIO_PIN_CNF_DIR_Pos);
}
nrf_gpio_pin_dir_set(2, NRF_GPIO_PIN_DIR_INPUT);
nrf_gpio_cfg_input(2, NRF_GPIO_PIN_PULLUP);
}
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;
}
