text: /*
   * Code generated from Atmel Start.
   *
   * This file will be overwritten when reconfiguring your Atmel Start project.
   * Please copy examples or other code you want to keep to a separate file
   * to avoid losing it when reconfiguring.
   */
  #ifndef ATMEL_START_PINS_H_INCLUDED
  #define ATMEL_START_PINS_H_INCLUDED
  
  #include <port.h>
  
  /**
   * \brief Set PB0 pull mode
   *
   * Configure pin to pull up, down or disable pull mode, supported pull
   * modes are defined by device used
   *
   * \param[in] pull_mode Pin pull mode
   */
  static inline void PB0_set_pull_mode(const enum port_pull_mode pull_mode)
  {
  	PORTB_set_pin_pull_mode(0, pull_mode);
  }
  
  /**
   * \brief Set PB0 data direction
   *
   * Select if the pin data direction is input, output or disabled.
   * If disabled state is not possible, this function throws an assert.
   *
   * \param[in] direction PORT_DIR_IN  = Data direction in
   *                      PORT_DIR_OUT = Data direction out
   *                      PORT_DIR_OFF = Disables the pin
   *                      (low power state)
   */
  static inline void PB0_set_dir(const enum port_dir dir)
  {
  	PORTB_set_pin_dir(0, dir);
  }
  
  /**
   * \brief Set PB0 level
   *
   * Sets output level on a pin
   *
   * \param[in] level true  = Pin level set to "high" state
   *                  false = Pin level set to "low" state
   */
  static inline void PB0_set_level(const bool level)
  {
  	PORTB_set_pin_level(0, level);
  }
  
  /**
   * \brief Toggle output level on PB0
   *
   * Toggle the pin level
   */
  static inline void PB0_toggle_level()
  {
  	PORTB_toggle_pin_level(0);
  }
  
  /**
   * \brief Get level on PB0
   *
   * Reads the level on a pin
   */
  static inline bool PB0_get_level()
  {
  	return PORTB_get_pin_level(0);
  }
  
  /**
   * \brief Set PB1 pull mode
   *
   * Configure pin to pull up, down or disable pull mode, supported pull
   * modes are defined by device used
   *
   * \param[in] pull_mode Pin pull mode
   */
  static inline void PB1_set_pull_mode(const enum port_pull_mode pull_mode)
  {
  	PORTB_set_pin_pull_mode(1, pull_mode);
  }
  
  /**
   * \brief Set PB1 data direction
   *
   * Select if the pin data direction is input, output or disabled.
   * If disabled state is not possible, this function throws an assert.
   *
   * \param[in] direction PORT_DIR_IN  = Data direction in
   *                      PORT_DIR_OUT = Data direction out
   *                      PORT_DIR_OFF = Disables the pin
   *                      (low power state)
   */
  static inline void PB1_set_dir(const enum port_dir dir)
  {
  	PORTB_set_pin_dir(1, dir);
  }
  
  /**
   * \brief Set PB1 level
   *
   * Sets output level on a pin
   *
   * \param[in] level true  = Pin level set to "high" state
   *                  false = Pin level set to "low" state
   */
  static inline void PB1_set_level(const bool level)
  {
  	PORTB_set_pin_level(1, level);
  }
  
  /**
   * \brief Toggle output level on PB1
   *
   * Toggle the pin level
   */
  static inline void PB1_toggle_level()
  {
  	PORTB_toggle_pin_level(1);
  }
  
  /**
   * \brief Get level on PB1
   *
   * Reads the level on a pin
   */
  static inline bool PB1_get_level()
  {
  	return PORTB_get_pin_level(1);
  }
  
  /**
   * \brief Set PB2 pull mode
   *
   * Configure pin to pull up, down or disable pull mode, supported pull
   * modes are defined by device used
   *
   * \param[in] pull_mode Pin pull mode
   */
  static inline void PB2_set_pull_mode(const enum port_pull_mode pull_mode)
  {
  	PORTB_set_pin_pull_mode(2, pull_mode);
  }
  
  /**
   * \brief Set PB2 data direction
   *
   * Select if the pin data direction is input, output or disabled.
   * If disabled state is not possible, this function throws an assert.
   *
   * \param[in] direction PORT_DIR_IN  = Data direction in
   *                      PORT_DIR_OUT = Data direction out
   *                      PORT_DIR_OFF = Disables the pin
   *                      (low power state)
   */
  static inline void PB2_set_dir(const enum port_dir dir)
  {
  	PORTB_set_pin_dir(2, dir);
  }
  
  /**
   * \brief Set PB2 level
   *
   * Sets output level on a pin
   *
   * \param[in] level true  = Pin level set to "high" state
   *                  false = Pin level set to "low" state
   */
  static inline void PB2_set_level(const bool level)
  {
  	PORTB_set_pin_level(2, level);
  }
  
  /**
   * \brief Toggle output level on PB2
   *
   * Toggle the pin level
   */
  static inline void PB2_toggle_level()
  {
  	PORTB_toggle_pin_level(2);
  }
  
  /**
   * \brief Get level on PB2
   *
   * Reads the level on a pin
   */
  static inline bool PB2_get_level()
  {
  	return PORTB_get_pin_level(2);
  }
  
  /**
   * \brief Set PB3 pull mode
   *
   * Configure pin to pull up, down or disable pull mode, supported pull
   * modes are defined by device used
   *
   * \param[in] pull_mode Pin pull mode
   */
  static inline void PB3_set_pull_mode(const enum port_pull_mode pull_mode)
  {
  	PORTB_set_pin_pull_mode(3, pull_mode);
  }
  
  /**
   * \brief Set PB3 data direction
   *
   * Select if the pin data direction is input, output or disabled.
   * If disabled state is not possible, this function throws an assert.
   *
   * \param[in] direction PORT_DIR_IN  = Data direction in
   *                      PORT_DIR_OUT = Data direction out
   *                      PORT_DIR_OFF = Disables the pin
   *                      (low power state)
   */
  static inline void PB3_set_dir(const enum port_dir dir)
  {
  	PORTB_set_pin_dir(3, dir);
  }
  
  /**
   * \brief Set PB3 level
   *
   * Sets output level on a pin
   *
   * \param[in] level true  = Pin level set to "high" state
   *                  false = Pin level set to "low" state
   */
  static inline void PB3_set_level(const bool level)
  {
  	PORTB_set_pin_level(3, level);
  }
  
  /**
   * \brief Toggle output level on PB3
   *
   * Toggle the pin level
   */
  static inline void PB3_toggle_level()
  {
  	PORTB_toggle_pin_level(3);
  }
  
  /**
   * \brief Get level on PB3
   *
   * Reads the level on a pin
   */
  static inline bool PB3_get_level()
  {
  	return PORTB_get_pin_level(3);
  }
  
  /**
   * \brief Set PB4 pull mode
   *
   * Configure pin to pull up, down or disable pull mode, supported pull
   * modes are defined by device used
   *
   * \param[in] pull_mode Pin pull mode
   */
  static inline void PB4_set_pull_mode(const enum port_pull_mode pull_mode)
  {
  	PORTB_set_pin_pull_mode(4, pull_mode);
  }
  
  /**
   * \brief Set PB4 data direction
   *
   * Select if the pin data direction is input, output or disabled.
   * If disabled state is not possible, this function throws an assert.
   *
   * \param[in] direction PORT_DIR_IN  = Data direction in
   *                      PORT_DIR_OUT = Data direction out
   *                      PORT_DIR_OFF = Disables the pin
   *                      (low power state)
   */
  static inline void PB4_set_dir(const enum port_dir dir)
  {
  	PORTB_set_pin_dir(4, dir);
  }
  
  /**
   * \brief Set PB4 level
   *
   * Sets output level on a pin
   *
   * \param[in] level true  = Pin level set to "high" state
   *                  false = Pin level set to "low" state
   */
  static inline void PB4_set_level(const bool level)
  {
  	PORTB_set_pin_level(4, level);
  }
  
  /**
   * \brief Toggle output level on PB4
   *
   * Toggle the pin level
   */
  static inline void PB4_toggle_level()
  {
  	PORTB_toggle_pin_level(4);
  }
  
  /**
   * \brief Get level on PB4
   *
   * Reads the level on a pin
   */
  static inline bool PB4_get_level()
  {
  	return PORTB_get_pin_level(4);
  }
  
  /**
   * \brief Set PB5 pull mode
   *
   * Configure pin to pull up, down or disable pull mode, supported pull
   * modes are defined by device used
   *
   * \param[in] pull_mode Pin pull mode
   */
  static inline void PB5_set_pull_mode(const enum port_pull_mode pull_mode)
  {
  	PORTB_set_pin_pull_mode(5, pull_mode);
  }
  
  /**
   * \brief Set PB5 data direction
   *
   * Select if the pin data direction is input, output or disabled.
   * If disabled state is not possible, this function throws an assert.
   *
   * \param[in] direction PORT_DIR_IN  = Data direction in
   *                      PORT_DIR_OUT = Data direction out
   *                      PORT_DIR_OFF = Disables the pin
   *                      (low power state)
   */
  static inline void PB5_set_dir(const enum port_dir dir)
  {
  	PORTB_set_pin_dir(5, dir);
  }
  
  /**
   * \brief Set PB5 level
   *
   * Sets output level on a pin
   *
   * \param[in] level true  = Pin level set to "high" state
   *                  false = Pin level set to "low" state
   */
  static inline void PB5_set_level(const bool level)
  {
  	PORTB_set_pin_level(5, level);
  }
  
  /**
   * \brief Toggle output level on PB5
   *
   * Toggle the pin level
   */
  static inline void PB5_toggle_level()
  {
  	PORTB_toggle_pin_level(5);
  }
  
  /**
   * \brief Get level on PB5
   *
   * Reads the level on a pin
   */
  static inline bool PB5_get_level()
  {
  	return PORTB_get_pin_level(5);
  }
  
  /**
   * \brief Set PC0 pull mode
   *
   * Configure pin to pull up, down or disable pull mode, supported pull
   * modes are defined by device used
   *
   * \param[in] pull_mode Pin pull mode
   */
  static inline void PC0_set_pull_mode(const enum port_pull_mode pull_mode)
  {
  	PORTC_set_pin_pull_mode(0, pull_mode);
  }
  
  /**
   * \brief Set PC0 data direction
   *
   * Select if the pin data direction is input, output or disabled.
   * If disabled state is not possible, this function throws an assert.
   *
   * \param[in] direction PORT_DIR_IN  = Data direction in
   *                      PORT_DIR_OUT = Data direction out
   *                      PORT_DIR_OFF = Disables the pin
   *                      (low power state)
   */
  static inline void PC0_set_dir(const enum port_dir dir)
  {
  	PORTC_set_pin_dir(0, dir);
  }
  
  /**
   * \brief Set PC0 level
   *
   * Sets output level on a pin
   *
   * \param[in] level true  = Pin level set to "high" state
   *                  false = Pin level set to "low" state
   */
  static inline void PC0_set_level(const bool level)
  {
  	PORTC_set_pin_level(0, level);
  }
  
  /**
   * \brief Toggle output level on PC0
   *
   * Toggle the pin level
   */
  static inline void PC0_toggle_level()
  {
  	PORTC_toggle_pin_level(0);
  }
  
  /**
   * \brief Get level on PC0
   *
   * Reads the level on a pin
   */
  static inline bool PC0_get_level()
  {
  	return PORTC_get_pin_level(0);
  }
  
  /**
   * \brief Set PC1 pull mode
   *
   * Configure pin to pull up, down or disable pull mode, supported pull
   * modes are defined by device used
   *
   * \param[in] pull_mode Pin pull mode
   */
  static inline void PC1_set_pull_mode(const enum port_pull_mode pull_mode)
  {
  	PORTC_set_pin_pull_mode(1, pull_mode);
  }
  
  /**
   * \brief Set PC1 data direction
   *
   * Select if the pin data direction is input, output or disabled.
   * If disabled state is not possible, this function throws an assert.
   *
   * \param[in] direction PORT_DIR_IN  = Data direction in
   *                      PORT_DIR_OUT = Data direction out
   *                      PORT_DIR_OFF = Disables the pin
   *                      (low power state)
   */
  static inline void PC1_set_dir(const enum port_dir dir)
  {
  	PORTC_set_pin_dir(1, dir);
  }
  
  /**
   * \brief Set PC1 level
   *
   * Sets output level on a pin
   *
   * \param[in] level true  = Pin level set to "high" state
   *                  false = Pin level set to "low" state
   */
  static inline void PC1_set_level(const bool level)
  {
  	PORTC_set_pin_level(1, level);
  }
  
  /**
   * \brief Toggle output level on PC1
   *
   * Toggle the pin level
   */
  static inline void PC1_toggle_level()
  {
  	PORTC_toggle_pin_level(1);
  }
  
  /**
   * \brief Get level on PC1
   *
   * Reads the level on a pin
   */
  static inline bool PC1_get_level()
  {
  	return PORTC_get_pin_level(1);
  }
  
  /**
   * \brief Set PC2 pull mode
   *
   * Configure pin to pull up, down or disable pull mode, supported pull
   * modes are defined by device used
   *
   * \param[in] pull_mode Pin pull mode
   */
  static inline void PC2_set_pull_mode(const enum port_pull_mode pull_mode)
  {
  	PORTC_set_pin_pull_mode(2, pull_mode);
  }
  
  /**
   * \brief Set PC2 data direction
   *
   * Select if the pin data direction is input, output or disabled.
   * If disabled state is not possible, this function throws an assert.
   *
   * \param[in] direction PORT_DIR_IN  = Data direction in
   *                      PORT_DIR_OUT = Data direction out
   *                      PORT_DIR_OFF = Disables the pin
   *                      (low power state)
   */
  static inline void PC2_set_dir(const enum port_dir dir)
  {
  	PORTC_set_pin_dir(2, dir);
  }
  
  /**
   * \brief Set PC2 level
   *
   * Sets output level on a pin
   *
   * \param[in] level true  = Pin level set to "high" state
   *                  false = Pin level set to "low" state
   */
  static inline void PC2_set_level(const bool level)
  {
  	PORTC_set_pin_level(2, level);
  }
  
  /**
   * \brief Toggle output level on PC2
   *
   * Toggle the pin level
   */
  static inline void PC2_toggle_level()
  {
  	PORTC_toggle_pin_level(2);
  }
  
  /**
   * \brief Get level on PC2
   *
   * Reads the level on a pin
   */
  static inline bool PC2_get_level()
  {
  	return PORTC_get_pin_level(2);
  }
  
  /**
   * \brief Set PC3 pull mode
   *
   * Configure pin to pull up, down or disable pull mode, supported pull
   * modes are defined by device used
   *
   * \param[in] pull_mode Pin pull mode
   */
  static inline void PC3_set_pull_mode(const enum port_pull_mode pull_mode)
  {
  	PORTC_set_pin_pull_mode(3, pull_mode);
  }
  
  /**
   * \brief Set PC3 data direction
   *
   * Select if the pin data direction is input, output or disabled.
   * If disabled state is not possible, this function throws an assert.
   *
   * \param[in] direction PORT_DIR_IN  = Data direction in
   *                      PORT_DIR_OUT = Data direction out
   *                      PORT_DIR_OFF = Disables the pin
   *                      (low power state)
   */
  static inline void PC3_set_dir(const enum port_dir dir)
  {
  	PORTC_set_pin_dir(3, dir);
  }
  
  /**
   * \brief Set PC3 level
   *
   * Sets output level on a pin
   *
   * \param[in] level true  = Pin level set to "high" state
   *                  false = Pin level set to "low" state
   */
  static inline void PC3_set_level(const bool level)
  {
  	PORTC_set_pin_level(3, level);
  }
  
  /**
   * \brief Toggle output level on PC3
   *
   * Toggle the pin level
   */
  static inline void PC3_toggle_level()
  {
  	PORTC_toggle_pin_level(3);
  }
  
  /**
   * \brief Get level on PC3
   *
   * Reads the level on a pin
   */
  static inline bool PC3_get_level()
  {
  	return PORTC_get_pin_level(3);
  }
  
  /**
   * \brief Set PC4 pull mode
   *
   * Configure pin to pull up, down or disable pull mode, supported pull
   * modes are defined by device used
   *
   * \param[in] pull_mode Pin pull mode
   */
  static inline void PC4_set_pull_mode(const enum port_pull_mode pull_mode)
  {
  	PORTC_set_pin_pull_mode(4, pull_mode);
  }
  
  /**
   * \brief Set PC4 data direction
   *
   * Select if the pin data direction is input, output or disabled.
   * If disabled state is not possible, this function throws an assert.
   *
   * \param[in] direction PORT_DIR_IN  = Data direction in
   *                      PORT_DIR_OUT = Data direction out
   *                      PORT_DIR_OFF = Disables the pin
   *                      (low power state)
   */
  static inline void PC4_set_dir(const enum port_dir dir)
  {
  	PORTC_set_pin_dir(4, dir);
  }
  
  /**
   * \brief Set PC4 level
   *
   * Sets output level on a pin
   *
   * \param[in] level true  = Pin level set to "high" state
   *                  false = Pin level set to "low" state
   */
  static inline void PC4_set_level(const bool level)
  {
  	PORTC_set_pin_level(4, level);
  }
  
  /**
   * \brief Toggle output level on PC4
   *
   * Toggle the pin level
   */
  static inline void PC4_toggle_level()
  {
  	PORTC_toggle_pin_level(4);
  }
  
  /**
   * \brief Get level on PC4
   *
   * Reads the level on a pin
   */
  static inline bool PC4_get_level()
  {
  	return PORTC_get_pin_level(4);
  }
  
  /**
   * \brief Set PC5 pull mode
   *
   * Configure pin to pull up, down or disable pull mode, supported pull
   * modes are defined by device used
   *
   * \param[in] pull_mode Pin pull mode
   */
  static inline void PC5_set_pull_mode(const enum port_pull_mode pull_mode)
  {
  	PORTC_set_pin_pull_mode(5, pull_mode);
  }
  
  /**
   * \brief Set PC5 data direction
   *
   * Select if the pin data direction is input, output or disabled.
   * If disabled state is not possible, this function throws an assert.
   *
   * \param[in] direction PORT_DIR_IN  = Data direction in
   *                      PORT_DIR_OUT = Data direction out
   *                      PORT_DIR_OFF = Disables the pin
   *                      (low power state)
   */
  static inline void PC5_set_dir(const enum port_dir dir)
  {
  	PORTC_set_pin_dir(5, dir);
  }
  
  /**
   * \brief Set PC5 level
   *
   * Sets output level on a pin
   *
   * \param[in] level true  = Pin level set to "high" state
   *                  false = Pin level set to "low" state
   */
  static inline void PC5_set_level(const bool level)
  {
  	PORTC_set_pin_level(5, level);
  }
  
  /**
   * \brief Toggle output level on PC5
   *
   * Toggle the pin level
   */
  static inline void PC5_toggle_level()
  {
  	PORTC_toggle_pin_level(5);
  }
  
  /**
   * \brief Get level on PC5
   *
   * Reads the level on a pin
   */
  static inline bool PC5_get_level()
  {
  	return PORTC_get_pin_level(5);
  }
  
  /**
   * \brief Set PD2 pull mode
   *
   * Configure pin to pull up, down or disable pull mode, supported pull
   * modes are defined by device used
   *
   * \param[in] pull_mode Pin pull mode
   */
  static inline void PD2_set_pull_mode(const enum port_pull_mode pull_mode)
  {
  	PORTD_set_pin_pull_mode(2, pull_mode);
  }
  
  /**
   * \brief Set PD2 data direction
   *
   * Select if the pin data direction is input, output or disabled.
   * If disabled state is not possible, this function throws an assert.
   *
   * \param[in] direction PORT_DIR_IN  = Data direction in
   *                      PORT_DIR_OUT = Data direction out
   *                      PORT_DIR_OFF = Disables the pin
   *                      (low power state)
   */
  static inline void PD2_set_dir(const enum port_dir dir)
  {
  	PORTD_set_pin_dir(2, dir);
  }
  
  /**
   * \brief Set PD2 level
   *
   * Sets output level on a pin
   *
   * \param[in] level true  = Pin level set to "high" state
   *                  false = Pin level set to "low" state
   */
  static inline void PD2_set_level(const bool level)
  {
  	PORTD_set_pin_level(2, level);
  }
  
  /**
   * \brief Toggle output level on PD2
   *
   * Toggle the pin level
   */
  static inline void PD2_toggle_level()
  {
  	PORTD_toggle_pin_level(2);
  }
  
  /**
   * \brief Get level on PD2
   *
   * Reads the level on a pin
   */
  static inline bool PD2_get_level()
  {
  	return PORTD_get_pin_level(2);
  }
  
  /**
   * \brief Set PD3 pull mode
   *
   * Configure pin to pull up, down or disable pull mode, supported pull
   * modes are defined by device used
   *
   * \param[in] pull_mode Pin pull mode
   */
  static inline void PD3_set_pull_mode(const enum port_pull_mode pull_mode)
  {
  	PORTD_set_pin_pull_mode(3, pull_mode);
  }
  
  /**
   * \brief Set PD3 data direction
   *
   * Select if the pin data direction is input, output or disabled.
   * If disabled state is not possible, this function throws an assert.
   *
   * \param[in] direction PORT_DIR_IN  = Data direction in
   *                      PORT_DIR_OUT = Data direction out
   *                      PORT_DIR_OFF = Disables the pin
   *                      (low power state)
   */
  static inline void PD3_set_dir(const enum port_dir dir)
  {
  	PORTD_set_pin_dir(3, dir);
  }
  
  /**
   * \brief Set PD3 level
   *
   * Sets output level on a pin
   *
   * \param[in] level true  = Pin level set to "high" state
   *                  false = Pin level set to "low" state
   */
  static inline void PD3_set_level(const bool level)
  {
  	PORTD_set_pin_level(3, level);
  }
  
  /**
   * \brief Toggle output level on PD3
   *
   * Toggle the pin level
   */
  static inline void PD3_toggle_level()
  {
  	PORTD_toggle_pin_level(3);
  }
  
  /**
   * \brief Get level on PD3
   *
   * Reads the level on a pin
   */
  static inline bool PD3_get_level()
  {
  	return PORTD_get_pin_level(3);
  }
  
  /**
   * \brief Set PD4 pull mode
   *
   * Configure pin to pull up, down or disable pull mode, supported pull
   * modes are defined by device used
   *
   * \param[in] pull_mode Pin pull mode
   */
  static inline void PD4_set_pull_mode(const enum port_pull_mode pull_mode)
  {
  	PORTD_set_pin_pull_mode(4, pull_mode);
  }
  
  /**
   * \brief Set PD4 data direction
   *
   * Select if the pin data direction is input, output or disabled.
   * If disabled state is not possible, this function throws an assert.
   *
   * \param[in] direction PORT_DIR_IN  = Data direction in
   *                      PORT_DIR_OUT = Data direction out
   *                      PORT_DIR_OFF = Disables the pin
   *                      (low power state)
   */
  static inline void PD4_set_dir(const enum port_dir dir)
  {
  	PORTD_set_pin_dir(4, dir);
  }
  
  /**
   * \brief Set PD4 level
   *
   * Sets output level on a pin
   *
   * \param[in] level true  = Pin level set to "high" state
   *                  false = Pin level set to "low" state
   */
  static inline void PD4_set_level(const bool level)
  {
  	PORTD_set_pin_level(4, level);
  }
  
  /**
   * \brief Toggle output level on PD4
   *
   * Toggle the pin level
   */
  static inline void PD4_toggle_level()
  {
  	PORTD_toggle_pin_level(4);
  }
  
  /**
   * \brief Get level on PD4
   *
   * Reads the level on a pin
   */
  static inline bool PD4_get_level()
  {
  	return PORTD_get_pin_level(4);
  }
  
  /**
   * \brief Set PD5 pull mode
   *
   * Configure pin to pull up, down or disable pull mode, supported pull
   * modes are defined by device used
   *
   * \param[in] pull_mode Pin pull mode
   */
  static inline void PD5_set_pull_mode(const enum port_pull_mode pull_mode)
  {
  	PORTD_set_pin_pull_mode(5, pull_mode);
  }
  
  /**
   * \brief Set PD5 data direction
   *
   * Select if the pin data direction is input, output or disabled.
   * If disabled state is not possible, this function throws an assert.
   *
   * \param[in] direction PORT_DIR_IN  = Data direction in
   *                      PORT_DIR_OUT = Data direction out
   *                      PORT_DIR_OFF = Disables the pin
   *                      (low power state)
   */
  static inline void PD5_set_dir(const enum port_dir dir)
  {
  	PORTD_set_pin_dir(5, dir);
  }
  
  /**
   * \brief Set PD5 level
   *
   * Sets output level on a pin
   *
   * \param[in] level true  = Pin level set to "high" state
   *                  false = Pin level set to "low" state
   */
  static inline void PD5_set_level(const bool level)
  {
  	PORTD_set_pin_level(5, level);
  }
  
  /**
   * \brief Toggle output level on PD5
   *
   * Toggle the pin level
   */
  static inline void PD5_toggle_level()
  {
  	PORTD_toggle_pin_level(5);
  }
  
  /**
   * \brief Get level on PD5
   *
   * Reads the level on a pin
   */
  static inline bool PD5_get_level()
  {
  	return PORTD_get_pin_level(5);
  }
  
  /**
   * \brief Set PD6 pull mode
   *
   * Configure pin to pull up, down or disable pull mode, supported pull
   * modes are defined by device used
   *
   * \param[in] pull_mode Pin pull mode
   */
  static inline void PD6_set_pull_mode(const enum port_pull_mode pull_mode)
  {
  	PORTD_set_pin_pull_mode(6, pull_mode);
  }
  
  /**
   * \brief Set PD6 data direction
   *
   * Select if the pin data direction is input, output or disabled.
   * If disabled state is not possible, this function throws an assert.
   *
   * \param[in] direction PORT_DIR_IN  = Data direction in
   *                      PORT_DIR_OUT = Data direction out
   *                      PORT_DIR_OFF = Disables the pin
   *                      (low power state)
   */
  static inline void PD6_set_dir(const enum port_dir dir)
  {
  	PORTD_set_pin_dir(6, dir);
  }
  
  /**
   * \brief Set PD6 level
   *
   * Sets output level on a pin
   *
   * \param[in] level true  = Pin level set to "high" state
   *                  false = Pin level set to "low" state
   */
  static inline void PD6_set_level(const bool level)
  {
  	PORTD_set_pin_level(6, level);
  }
  
  /**
   * \brief Toggle output level on PD6
   *
   * Toggle the pin level
   */
  static inline void PD6_toggle_level()
  {
  	PORTD_toggle_pin_level(6);
  }
  
  /**
   * \brief Get level on PD6
   *
   * Reads the level on a pin
   */
  static inline bool PD6_get_level()
  {
  	return PORTD_get_pin_level(6);
  }
  
  /**
   * \brief Set PD7 pull mode
   *
   * Configure pin to pull up, down or disable pull mode, supported pull
   * modes are defined by device used
   *
   * \param[in] pull_mode Pin pull mode
   */
  static inline void PD7_set_pull_mode(const enum port_pull_mode pull_mode)
  {
  	PORTD_set_pin_pull_mode(7, pull_mode);
  }
  
  /**
   * \brief Set PD7 data direction
   *
   * Select if the pin data direction is input, output or disabled.
   * If disabled state is not possible, this function throws an assert.
   *
   * \param[in] direction PORT_DIR_IN  = Data direction in
   *                      PORT_DIR_OUT = Data direction out
   *                      PORT_DIR_OFF = Disables the pin
   *                      (low power state)
   */
  static inline void PD7_set_dir(const enum port_dir dir)
  {
  	PORTD_set_pin_dir(7, dir);
  }
  
  /**
   * \brief Set PD7 level
   *
   * Sets output level on a pin
   *
   * \param[in] level true  = Pin level set to "high" state
   *                  false = Pin level set to "low" state
   */
  static inline void PD7_set_level(const bool level)
  {
  	PORTD_set_pin_level(7, level);
  }
  
  /**
   * \brief Toggle output level on PD7
   *
   * Toggle the pin level
   */
  static inline void PD7_toggle_level()
  {
  	PORTD_toggle_pin_level(7);
  }
  
  /**
   * \brief Get level on PD7
   *
   * Reads the level on a pin
   */
  static inline bool PD7_get_level()
  {
  	return PORTD_get_pin_level(7);
  }
  
  /**
   * \brief Set PE2 pull mode
   *
   * Configure pin to pull up, down or disable pull mode, supported pull
   * modes are defined by device used
   *
   * \param[in] pull_mode Pin pull mode
   */
  static inline void PE2_set_pull_mode(const enum port_pull_mode pull_mode)
  {
  	PORTE_set_pin_pull_mode(2, pull_mode);
  }
  
  /**
   * \brief Set PE2 data direction
   *
   * Select if the pin data direction is input, output or disabled.
   * If disabled state is not possible, this function throws an assert.
   *
   * \param[in] direction PORT_DIR_IN  = Data direction in
   *                      PORT_DIR_OUT = Data direction out
   *                      PORT_DIR_OFF = Disables the pin
   *                      (low power state)
   */
  static inline void PE2_set_dir(const enum port_dir dir)
  {
  	PORTE_set_pin_dir(2, dir);
  }
  
  /**
   * \brief Set PE2 level
   *
   * Sets output level on a pin
   *
   * \param[in] level true  = Pin level set to "high" state
   *                  false = Pin level set to "low" state
   */
  static inline void PE2_set_level(const bool level)
  {
  	PORTE_set_pin_level(2, level);
  }
  
  /**
   * \brief Toggle output level on PE2
   *
   * Toggle the pin level
   */
  static inline void PE2_toggle_level()
  {
  	PORTE_toggle_pin_level(2);
  }
  
  /**
   * \brief Get level on PE2
   *
   * Reads the level on a pin
   */
  static inline bool PE2_get_level()
  {
  	return PORTE_get_pin_level(2);
  }
  
  #endif /* ATMEL_START_PINS_H_INCLUDED */
  