how to use GPIO port 1 for Uarts

Question

Hey..

I'm having difficulties using P1 pins for UARTE0 and/or UARTE1.

configuring the RX & TX pins like this works great:

#define RBP_UARTE0_RX_PIN_NUMBER NRF_GPIO_PIN_MAP(0,26)
#define RBP_UARTE0_TX_PIN_NUMBER NRF_GPIO_PIN_MAP(0,27)

#define RBP_UARTE1_RX_PIN_NUMBER NRF_GPIO_PIN_MAP(0,8)
#define RBP_UARTE1_TX_PIN_NUMBER NRF_GPIO_PIN_MAP(0,6)

But if I change UARTE1 (and move the wires, obviously) to the following, I see nothing on UARTE1

#define RBP_UARTE1_RX_PIN_NUMBER NRF_GPIO_PIN_MAP(1,8)
#define RBP_UARTE1_TX_PIN_NUMBER NRF_GPIO_PIN_MAP(1,6)

I have, in fact, not had any luck with any of the P1 pins I've tried. Is there something I'm missing that needs doing before I can use P1?

see attached program & sdk_config.h

Fullscreen main.c Download

/*$$$LICENCE_NORDIC_STANDARD<2016>$$$*/
#include <stdint.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdio.h>

#include "nrf.h"
#include "nrf_drv_clock.h"
#include "nrf_gpio.h"
#include "nrf_delay.h"
#include "nrf_log.h"
#include "nrf_log_ctrl.h"
#include "nrf_drv_power.h"
#include "nrf_drv_uart.h"
#include "nrf_serial.h"
#include "app_timer.h"


#include "app_error.h"
#include "app_util.h"
#include "boards.h"

/** @file
 * @defgroup nrf_serial_example main.c
 * @{
 * @ingroup nrf_serial_example
 * @brief Example of @ref nrf_serial usage. Simple loopback.
 *
 */

#define OP_QUEUES_SIZE          3
#define APP_TIMER_PRESCALER     NRF_SERIAL_APP_TIMER_PRESCALER

static void sleep_handler(void)
{
    __WFE();
    __SEV();
    __WFE();
}


#define RBP_UARTE0_RX_PIN_NUMBER  NRF_GPIO_PIN_MAP(0,26)
#define RBP_UARTE0_TX_PIN_NUMBER  NRF_GPIO_PIN_MAP(0,27)
#define RBP_UARTE0_CTS_PIN_NUMBER NRF_UART_PSEL_DISCONNECTED
#define RBP_UARTE0_RTS_PIN_NUMBER NRF_UART_PSEL_DISCONNECTED
#define RBP_UARTE0_HWFC           false

#define RBP_UARTE1_RX_PIN_NUMBER  NRF_GPIO_PIN_MAP(1,8)
#define RBP_UARTE1_TX_PIN_NUMBER  NRF_GPIO_PIN_MAP(1,6)
#define RBP_UARTE1_CTS_PIN_NUMBER NRF_UART_PSEL_DISCONNECTED
#define RBP_UARTE1_RTS_PIN_NUMBER NRF_UART_PSEL_DISCONNECTED
#define RBP_UARTE1_HWFC           false


NRF_SERIAL_DRV_UART_CONFIG_DEF(m_uart0_drv_config,
                      RBP_UARTE0_RX_PIN_NUMBER,
                      RBP_UARTE0_TX_PIN_NUMBER,
                      RBP_UARTE0_RTS_PIN_NUMBER,
                      RBP_UARTE0_CTS_PIN_NUMBER,
                      RBP_UARTE0_HWFC,
                      NRF_UART_PARITY_EXCLUDED,
                      NRF_UART_BAUDRATE_115200,
                      UART_DEFAULT_CONFIG_IRQ_PRIORITY);

NRF_SERIAL_DRV_UART_CONFIG_DEF(m_uart1_drv_config,
                      RBP_UARTE1_RX_PIN_NUMBER,
                      RBP_UARTE1_TX_PIN_NUMBER,
                      RBP_UARTE1_RTS_PIN_NUMBER,
                      RBP_UARTE1_CTS_PIN_NUMBER,
                      RBP_UARTE1_HWFC,
                      NRF_UART_PARITY_EXCLUDED,
                      NRF_UART_BAUDRATE_115200,
                      UART_DEFAULT_CONFIG_IRQ_PRIORITY);

#define TEST_UARTE0
#define TEST_UARTE1


#define SERIAL_FIFO_TX_SIZE 128
#define SERIAL_FIFO_RX_SIZE 128

NRF_SERIAL_QUEUES_DEF(serial0_queues, SERIAL_FIFO_TX_SIZE, SERIAL_FIFO_RX_SIZE);
NRF_SERIAL_QUEUES_DEF(serial1_queues, SERIAL_FIFO_TX_SIZE, SERIAL_FIFO_RX_SIZE);


#define SERIAL_BUFF_TX_SIZE 1
#define SERIAL_BUFF_RX_SIZE 1

NRF_SERIAL_BUFFERS_DEF(serial0_buffs, SERIAL_BUFF_TX_SIZE, SERIAL_BUFF_RX_SIZE);
NRF_SERIAL_BUFFERS_DEF(serial1_buffs, SERIAL_BUFF_TX_SIZE, SERIAL_BUFF_RX_SIZE);

NRF_SERIAL_CONFIG_DEF(serial0_config, NRF_SERIAL_MODE_IRQ,
                      &serial0_queues, &serial0_buffs, NULL, sleep_handler);
NRF_SERIAL_CONFIG_DEF(serial1_config, NRF_SERIAL_MODE_IRQ,
                      &serial1_queues, &serial1_buffs, NULL, sleep_handler);

NRF_SERIAL_UART_DEF(serial0_uart, 0);
NRF_SERIAL_UART_DEF(serial1_uart, 1);

int main(void)
{
    ret_code_t ret;

    ret = nrf_drv_clock_init();
    APP_ERROR_CHECK(ret);
    ret = nrf_drv_power_init(NULL);
    APP_ERROR_CHECK(ret);

    nrf_drv_clock_lfclk_request(NULL);
    ret = app_timer_init();
    APP_ERROR_CHECK(ret);

    //bsp_board_leds_init();
    //bsp_board_buttons_init();

    ret = nrf_serial_init(&serial0_uart, &m_uart0_drv_config, &serial0_config);
    APP_ERROR_CHECK(ret);

    ret = nrf_serial_init(&serial1_uart, &m_uart1_drv_config, &serial1_config);
    APP_ERROR_CHECK(ret);

#ifdef TEST_UARTE0
    static char tx_message[] = "Hello nrf_serial 0\n\r";

    ret = nrf_serial_write(&serial0_uart,
                           tx_message,
                           strlen(tx_message),
                           NULL,
                           NRF_SERIAL_MAX_TIMEOUT);
    (void)nrf_serial_flush(&serial0_uart, 0);
    APP_ERROR_CHECK(ret);

#endif

#ifdef TEST_UARTE1
     static char tx_message1[] = "Hello nrf_serial 1\n\r";

    ret = nrf_serial_write(&serial1_uart,
                           tx_message1,
                           strlen(tx_message1),
                           NULL,
                           NRF_SERIAL_MAX_TIMEOUT);
    (void)nrf_serial_flush(&serial1_uart, 0);
    APP_ERROR_CHECK(ret);
#endif

    while (true)
    {

        char c;
        char c1;

#ifdef TEST_UARTE0
        ret = nrf_serial_read(&serial0_uart, &c, sizeof(c), NULL, 10);
        if (ret == NRF_SUCCESS)
        {
            (void)nrf_serial_write(&serial0_uart, &c, sizeof(c), NULL, 0);
            (void)nrf_serial_flush(&serial0_uart, 0);
        }
#endif

#ifdef TEST_UARTE1
        ret = nrf_serial_read(&serial1_uart, &c1, sizeof(c1), NULL, 10);
        if (ret == NRF_SUCCESS)
        {
            (void)nrf_serial_write(&serial1_uart, &c1, sizeof(c1), NULL, 0);
            (void)nrf_serial_flush(&serial1_uart, 0);
        }
#endif
    }
}

/** @} */

sdk_config.h

Rob Philip · Accepted Answer

And once again the joy of development environments hits home. 
 This configuration works just fine if you power down everything on the lab bench and restart your test computer. 
 Feel free to close this. But FWIW this is a good piece of test code for testing UARTs.

how to use GPIO port 1 for Uarts

Top Replies