gpio.h

Go to the documentation of this file.

#ifndef DRIVER_GPIO_H
#define DRIVER_GPIO_H
/**********************************************************************/
/*
 * Copyright (c) 2015-2016, Jetro AS
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without modification,
 * are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice,
 *    this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright notice,
 *    this list of conditions and the following disclaimer in the documentation
 *    and/or other materials provided with the distribution.
 * 3. The name of the author may not be used to endorse or promote products
 *    derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONRIBUTORS ``AS IS'' AND ANY EXPRESS
 * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
 * SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
 * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
 * OF SUCH DAMAGE.
 *
 * This file is part of the EVE platform.
 */

/**
 * \file
 * @brief Driver for port initialisazion and IO functions for nRF52 uC.
 *
 * @author PE, Jetro AS
 * @author DT, Jetro AS
 */ /******************************************************************/
#include <stdbool.h>
#include <hal/nrf_gpio.h>
#include <hal/nrf_gpiote.h>
#include <dev/eve-module.h>

/**
 * This GPIO driver has functions for:
 * - initialization of ports with default values.
 * - debouncing of input pins
 */

/**
 * \defgroup nrf_gpio nRF52 internal GPIO driver
 * \ingroup nrf52
 * \{
 */

/***********************************************************************
 * General mode definitions
 **********************************************************************/
#define GPIO_LOW                                  0UL
#define GPIO_HIGH                                 1UL
#define GPIO_PIN_ID_WIDTH                         (6)
#define GPIO_PIN_NC                               (32UL)  /**< Not connected */

/**********************************************************************/
/**
 * @brief Name:     GpioUnpackPin\n
 * Converts packed pin number to the format, accepted by hardware blocks
 *
 * @param Pin       Pin number or GPIO_PIN_NC if not connected
 * @return          Pin number or 0x8XXXXXXX if not connected
 ***********************************************************************/
static inline uint32_t GpioUnpackPin(uint32_t Pin)
{
  return (Pin | (Pin << 26)) /*& 0x8000001F*/;
}

struct port_init_t
{
  uint32_t Cfg;
};

extern const struct port_init_t PortInitTable[32];
extern const uint32_t PortInitValue;

#if defined(DRIVER_PORT_INIT_TABLE)
  #include <dev/port-init-generator.h>
#endif

#define GPIO_PIN_CNF(Direction, Input, Pull, Drive) \
  (((Direction) << GPIO_PIN_CNF_DIR_Pos) \
  | ((Input) << GPIO_PIN_CNF_INPUT_Pos) \
  | ((Pull) << GPIO_PIN_CNF_PULL_Pos) \
  | ((Drive) << GPIO_PIN_CNF_DRIVE_Pos))

/** Pin mode. */
enum gpio_mode_t
{
  /** Input disabled. */
  GpioModeDisabled
      = GPIO_PIN_CNF(GPIO_PIN_CNF_DIR_Input, GPIO_PIN_CNF_INPUT_Disconnect,
        GPIO_PIN_CNF_PULL_Disabled, GPIO_PIN_CNF_DRIVE_S0S1),

  /** Input disabled and pulled down */
  GpioModeDisabledPullDown
      = GPIO_PIN_CNF(GPIO_PIN_CNF_DIR_Input, GPIO_PIN_CNF_INPUT_Disconnect,
        GPIO_PIN_CNF_PULL_Pulldown, GPIO_PIN_CNF_DRIVE_S0S1),

  /** Input disabled and pulled up */
  GpioModeDisabledPullUp
      = GPIO_PIN_CNF(GPIO_PIN_CNF_DIR_Input, GPIO_PIN_CNF_INPUT_Disconnect,
        GPIO_PIN_CNF_PULL_Pullup, GPIO_PIN_CNF_DRIVE_S0S1),

  /** Input enabled. */
  GpioModeInput
      = GPIO_PIN_CNF(GPIO_PIN_CNF_DIR_Input, GPIO_PIN_CNF_INPUT_Connect,
        GPIO_PIN_CNF_PULL_Disabled, GPIO_PIN_CNF_DRIVE_S0S1),

  /** Input enabled and pulled down. */
  GpioModeInputPullDown
      = GPIO_PIN_CNF(GPIO_PIN_CNF_DIR_Input, GPIO_PIN_CNF_INPUT_Connect,
        GPIO_PIN_CNF_PULL_Pulldown, GPIO_PIN_CNF_DRIVE_S0S1),

  /** Input enabled and pulled up. */
  GpioModeInputPullUp
      = GPIO_PIN_CNF(GPIO_PIN_CNF_DIR_Input, GPIO_PIN_CNF_INPUT_Connect,
        GPIO_PIN_CNF_PULL_Pullup, GPIO_PIN_CNF_DRIVE_S0S1),

  /** Push-pull output */
  GpioModePushPull
      = GPIO_PIN_CNF(GPIO_PIN_CNF_DIR_Output, GPIO_PIN_CNF_INPUT_Connect,
        GPIO_PIN_CNF_PULL_Disabled, GPIO_PIN_CNF_DRIVE_S0S1),

  /** Push-pull output with drive-strength set by DRIVEMODE */
  GpioModePushPullDrive
      = GPIO_PIN_CNF(GPIO_PIN_CNF_DIR_Output, GPIO_PIN_CNF_INPUT_Connect,
        GPIO_PIN_CNF_PULL_Disabled, GPIO_PIN_CNF_DRIVE_H0H1),

  /** Wired-or output */
  GpioModeWiredOr
      = GPIO_PIN_CNF(GPIO_PIN_CNF_DIR_Output, GPIO_PIN_CNF_INPUT_Connect,
        GPIO_PIN_CNF_PULL_Disabled, GPIO_PIN_CNF_DRIVE_D0S1),

  /** Wired-or output high-drive */
  GpioModeWiredOrHigh
      = GPIO_PIN_CNF(GPIO_PIN_CNF_DIR_Output, GPIO_PIN_CNF_INPUT_Connect,
        GPIO_PIN_CNF_PULL_Disabled, GPIO_PIN_CNF_DRIVE_D0H1),

  /** Wired-or output with pull-down */
  GpioModeWiredOrPullDown
      = GPIO_PIN_CNF(GPIO_PIN_CNF_DIR_Output, GPIO_PIN_CNF_INPUT_Connect,
        GPIO_PIN_CNF_PULL_Pulldown, GPIO_PIN_CNF_DRIVE_D0S1),

  /** Open-drain output */
  GpioModeWiredAnd
      = GPIO_PIN_CNF(GPIO_PIN_CNF_DIR_Output, GPIO_PIN_CNF_INPUT_Connect,
        GPIO_PIN_CNF_PULL_Disabled, GPIO_PIN_CNF_DRIVE_S0D1),

  /** Open-drain output with pullup */
  GpioModeWiredAndPullUp
      = GPIO_PIN_CNF(GPIO_PIN_CNF_DIR_Output, GPIO_PIN_CNF_INPUT_Connect,
        GPIO_PIN_CNF_PULL_Pullup, GPIO_PIN_CNF_DRIVE_S0D1),

  /** Open-drain output with drive-strength set by DRIVEMODE */
  GpioModeWiredAndDrive
      = GPIO_PIN_CNF(GPIO_PIN_CNF_DIR_Output, GPIO_PIN_CNF_INPUT_Connect,
        GPIO_PIN_CNF_PULL_Disabled, GPIO_PIN_CNF_DRIVE_H0D1),

  /** Open-drain output with pullup and drive-strength set by DRIVEMODE */
  GpioModeWiredAndDrivePullUp
      = GPIO_PIN_CNF(GPIO_PIN_CNF_DIR_Output, GPIO_PIN_CNF_INPUT_Connect,
        GPIO_PIN_CNF_PULL_Pullup, GPIO_PIN_CNF_DRIVE_H0D1),
};
#undef GPIO_PIN_CNF

 /**
  * @name Functions called from application programs
  * @{
  */

/**********************************************************************/
/**
 * @brief Name:           GpioInit\n
 * Initializes ports to default values based on port-init.h.
 **********************************************************************/
extern void GpioInit(void);

/**********************************************************************/
/**
 * @brief Name: GpioPinConfig\n
 * Configures a GPIO pin to the desired mode, sets value for the pin
 *
 * @param Pin             The pin number to read.
 * @param Mode            Pin mode.
 ***********************************************************************/
static inline void GpioPinConfig(unsigned Pin, enum gpio_mode_t Mode)
{
  NRF_GPIO->PIN_CNF[Pin] = Mode;
}

/**********************************************************************/
/**
 * @brief Name: GpioPinGet\n
 * Reads the pad value for a single pin in a GPIO port.
 *
 * @param Pin             The pin number to read.
 * @return                The pin value, 0 or 1.
 ***********************************************************************/
static inline bool GpioPinGet(unsigned Pin)
{
  return nrf_gpio_pin_read(Pin);
}

/**********************************************************************/
/**
 * @brief Name: GpioPinClear\n
 * Sets the pad value for a single pin in a GPIO port to 0
 *
 * @param Pin             The pin number to modify.
 ***********************************************************************/
static inline void GpioPinClear(unsigned Pin)
{
  nrf_gpio_pin_clear(Pin);
}

/**********************************************************************/
/**
 * @brief Name: GpioPinSet\n
 * Sets the pad value for a single pin in a GPIO port to 1
 *
 * @param Pin             The pin number to modify.
 ***********************************************************************/
static inline void GpioPinSet(unsigned Pin)
{
  nrf_gpio_pin_set(Pin);
}

/**********************************************************************/
/**
 * @brief Name: GpioPinToggle\n
 * Toggles a single pin in a GPIO port
 *
 * @param Pin             The pin number to modify.
 ***********************************************************************/
static inline void GpioPinToggle(unsigned Pin)
{
  nrf_gpio_pin_toggle(Pin);
}

/**********************************************************************/
/**
 * @brief Name: GpioPinSetValue\n
 * Sets the pad value for a single pin in a GPIO port to the value provided.
 *
 * @param Pin             The pin number to modify.
 * @param Value           Value to be set.
 ***********************************************************************/
static inline void GpioPinSetValue(unsigned Pin, bool Value)
{
  nrf_gpio_pin_write(Pin, Value);
}

/**********************************************************************/
/**
 * @brief Name: GpioPortGet\n
 * Reads the pad values for all the pins in a GPIO port.
 *
 * @return                32-bit bitmap, where LSB stands for the pin 0.
 ***********************************************************************/
static inline uint32_t GpioPortGet(void)
{
  return nrf_gpio_pins_read();
}

/**********************************************************************/
/**
 * @brief Name: GpioPortClear\n
 * Sets the pad values for pins specified by a mask to 0
 *
 * @param Mask            The bitmaps of the pins to modify.
 ***********************************************************************/
static inline void GpioPortClear(uint32_t Mask)
{
  nrf_gpio_pins_clear(Mask);
}

/**********************************************************************/
/**
 * @brief Name: GpioPortSet\n
 * Sets the pad values for pins specified by a mask to 1
 *
 * @param Mask            The bitmaps of the pins to modify.
 ***********************************************************************/
static inline void GpioPortSet(uint32_t Mask)
{
  nrf_gpio_pins_set(Mask);
}

/**********************************************************************/
/**
 * @brief Name: GpioPortToggle\n
 * Toggles pins specified by a mask in a GPIO port
 *
 * @param Mask            The bitmaps of the pins to modify.
 ***********************************************************************/
static inline void GpioPortToggle(uint32_t Mask)
{
  nrf_gpio_pins_toggle(Mask);
}

/**********************************************************************/
/**
 * @brief Name: GpioPortSetValue\n
 * Sets the pad value for a single pin in a GPIO port to the value provided.
 *
 * @param Value           The bitmap, containing values for the pins.
 * @param Mask            The bitmaps of the pins to modify.
 ***********************************************************************/
static inline void GpioPortSetValue(uint32_t Value, uint32_t Mask)
{
  NRF_GPIO->OUTSET = (Mask &  Value);
  NRF_GPIO->OUTCLR = (Mask & ~Value);
}

/**********************************************************************/
/**
 * @brief Name: GpioGetDebouncedInput
 * Reads and debounces input pins.
 *
 * @param BitMask         BitMask for actual bits to read
 * @param BitInvert       Bits to be inverted (for example if active 'L' input
 *                        should return 'H', then resp. bit in BitInvert must be set)
 * @param Count           Required number of equal readings
 * @param ShiftRightCount Spesifies right adjustment (0-31)
 * @return                Returns port input status after Count equal readings.
 ***********************************************************************/
extern uint32_t GpioGetDebouncedInput(uint32_t BitMask, uint32_t BitInvert, uint8_t Count, uint8_t ShiftRightCount);

/** @} */

/** \} nrf_gpio */


#endif //DRIVER_GPIO_H