##// END OF EJS Templates
HG_REPOSITORIES » LPP » INSTRUMENTATION » libuc2
RSS

Clone from http://pc-instru.lpp.polytechnique.fr:5000/libuc2

Added cpuid getter...
Added cpuid getter Refactored gpio API, and updated for better consistency with other APIs. Started descriptive init.
Alexis Jeandet - - Load All Authors

File last commit:

r104:cfe8b1e0657d dev_alexis
r104:cfe8b1e0657d dev_alexis
Show More
gpio.h
737 lines | 17.9 KiB | text/x-c | CLexer
/ include / PERIPHERALS / gpio.h
History | Annotation | Raw |Copy content |Copy permalink
/* ------------------------------------------------------------------------------
-- This file is a part of the libuc, microcontroler library
-- Copyright (C) 2012, Alexis Jeandet
--
-- This program is free software; you can redistribute it and/or modify
-- it under the terms of the GNU General Public License as published by
-- the Free Software Foundation; either version 3 of the License, or
-- (at your option) any later version.
--
-- This program is distributed in the hope that it will be useful,
-- but WITHOUT ANY WARRANTY; without even the implied warranty of
-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-- GNU General Public License for more details.
--
-- You should have received a copy of the GNU General Public License
-- along with this program; if not, write to the Free Software
-- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-------------------------------------------------------------------------------*/
/** @author Alexis Jeandet alexis.jeandet@member.fsf.org
-------------------------------------------------------------------------------*/
/*! \file gpio.h
\brief GPIO api.
The gpio api gives you a standard way to drive any gpio on any processor.
With this api you will be able to open and configure your gpios and set/clear read them.
A simple example to drive PA0 and read PA1.
\code
// lets open PA0 and PA1
gpio_t mygpio1 = gpioopen(PA0);
gpioopen(PA1);
mygpio1 |= gpiohighspeed | gpiooutdir | gpiopushpulltype | gpionopulltype;
gpiosetconfig(mygpio1);
//you can also configure with the pin name
gpiosetconfig(PA1|gpiohighspeed | gpioindir);
//to set PA0
gpioset(mygpio1);
//to clear it
gpioclr(PA0); //PA0 also works and save 4 bytes!
//Let read PA1 and write it to PA0
gpiosetval(PA0,gpiogetval(PA1));
\endcode
\defgroup GPIO
\ingroup GPIO
*/
#ifndef GPIO_H
#define GPIO_H
#include <stdint.h>
#ifdef __cplusplus
extern "C" {
#endif
/**
* @brief gpio handle
*
*gpio_t is the handle type you will use for all
*gpio related functions.
*
* \ingroup GPIO
*/
typedef uint32_t gpio_t;
/**
* @brief GPIO speed enum
*
* Use gpiospeed_t values to configure the speed of your GPIO pin with
* gpiosetspeed(gpio_t gpio,gpiospeed_t speed) function or gpiosetconfig(gpio_t gpio).
* The speed values are realy platform dependant check for each target if you whant to
* know the meaning of each speed.
* Don't try to use numerical values directly!
* @sa gpiosetspeed(gpio_t gpio,gpiospeed_t speed),gpiosetconfig(gpio_t gpio)
*
* \ingroup GPIO
*/
typedef enum gpiospeed_t
{
gpiolowspeed = 0, /**< Lowest speed value*/
gpiomediumspeed, /**< Normal or medium speed value*/
gpiofastspeed , /**< Higher speed value*/
gpiohighspeed /**< Highest speed value*/
}gpiospeed_t;
/**
* @brief GPIO direction enum
*
* Use gpiodir_t values to configure the direction of your GPIO pin with
* gpiosetdir(gpio_t gpio,gpiodir_t dir) function or gpiosetconfig(gpio_t gpio).
* Don't try to use numerical values directly!
* @sa gpiosetdir(gpio_t gpio,gpiodir_t dir),gpiosetconfig(gpio_t gpio)
*
* \ingroup GPIO
*/
typedef enum gpiodir_t
{
gpioindir = 0,/**< Input direction*/
gpiooutdir, /**< Output direction*/
gpioaf, /**< Alternate function such as spi, uart, ...*/
gpioan /**< Configure the pin for analogic mode*/
}gpiodir_t;
/**
* @brief GPIO output type enum
*
* Use gpioouttype_t values to configure the kind of output you want with
* gpiosetouttype(gpio_t gpio, gpioouttype_t outtype) function or gpiosetconfig(gpio_t gpio).
* Don't try to use numerical values directly!
* @sa gpiosetouttype(gpio_t gpio, gpioouttype_t outtype),gpiosetconfig(gpio_t gpio)
*
* \ingroup GPIO
*/
typedef enum gpioouttype_t
{
gpiopushpulltype = 0, /**< Pushpull output*/
gpioopendraintype /**< Open drain output*/
}gpioouttype_t;
/**
* @brief GPIO pull resistor configuration enum
*
* Use gpiopulltype_t values to configure the pull resistor of your GPIO pin with
* gpiosetpulltype(gpio_t gpio,gpiopulltype_t pulltype) function or gpiosetconfig(gpio_t gpio).
* Don't try to use numerical values directly!
* @sa gpiosetpulltype(gpio_t gpio,gpiopulltype_t pulltype),gpiosetconfig(gpio_t gpio)
*
* \ingroup GPIO
*/
typedef enum gpiopulltype_t
{
gpionopulltype = 0,
gpiopulluptype,
gpiopulldowntype
}gpiopulltype_t;
typedef struct
{
gpiodir_t direction;
gpiospeed_t speed;
gpioouttype_t outType;
gpiopulltype_t pullType;
}gpioconfig_str;
#ifndef DOXYGEN_SHOULD_SKIP_THIS
#define GPIOSPEEDMASK 0x30000
#define GPIODIRMASK 0xC0000
#define GPIOOUTTYPEMASK 0x100000
#define GPIOPULLTYPEMASK 0x600000
#endif
/**
* @brief gpioopen
* @param gpio
* @return
* @sa gpioclose(gpio_t gpio)
*
* \ingroup GPIO
*/
extern gpio_t gpioopen(uint32_t gpio);
extern gpio_t gpioopenandconfig(uint32_t gpio, gpioconfig_str* config);
/**
* @brief gpioclose
* @param gpio
* @sa gpioopen(uint32_t gpio)
*
* \ingroup GPIO
*/
extern void gpioclose(gpio_t gpio);
/**
* @brief gpiosetconfig
* @param gpio
* @param direction
* @param speed
* @param outType
* @param pullType
*
* \ingroup GPIO
*/
extern void gpiosetconfig(gpio_t gpio, gpiodir_t direction, gpiospeed_t speed, gpioouttype_t outType, gpiopulltype_t pullType);
extern void gpiosetconfigstr(gpio_t gpio, gpioconfig_str *config);
/**
* @brief gpiosetdir
* @param gpio
* @param dir
*
* \ingroup GPIO
*/
extern void gpiosetdir(gpio_t gpio,gpiodir_t dir);
/**
* @brief gpiosetouttype
* @param gpio
* @param outtype
* @sa gpiosetconfig(gpio_t gpio)
*
* \ingroup GPIO
*/
extern void gpiosetouttype(gpio_t gpio, gpioouttype_t outtype);
/**
* @brief gpiosetpulltype
* @param gpio
* @param pulltype
* @sa gpiosetconfig(gpio_t gpio)
*
* \ingroup GPIO
*/
extern void gpiosetpulltype(gpio_t gpio,gpiopulltype_t pulltype);
/**
* @brief gpiosetspeed
* @param gpio
* @param speed
* @sa gpiosetconfig(gpio_t gpio)
*
* \ingroup GPIO
*/
extern void gpiosetspeed(gpio_t gpio,gpiospeed_t speed);
/**
* @brief gpioset
* @param gpio
* @sa gpiosetconfig(gpio_t gpio)
*
* \ingroup GPIO
*/
extern void gpioset(gpio_t gpio);
/**
* @brief gpioclr
* @param gpio
*
* \ingroup GPIO
*/
extern void gpioclr(gpio_t gpio);
/**
* @brief gpiosetval
* @param gpio
* @param val
*
* \ingroup GPIO
*/
extern void gpiosetval(gpio_t gpio,int val);
/**
* @brief gpiogetval
* @param gpio
* @return
*
* \ingroup GPIO
*/
extern int gpiogetval(gpio_t gpio);
#ifndef DOXYGEN_SHOULD_SKIP_THIS
//#define GPIOISINPUT(gpio) (((gpio) & GPIODIRMASK)==gpioindir)
//#define GPIOISOUTPUT(gpio) (((gpio) & GPIOSPEEDMASK)==gpiooutdir)
//#define GPIOISLOWSPEED(gpio) (((gpio) & GPIOSPEEDMASK)==gpiolowspeed)
//#define GPIOISMEDIUMSPEED(gpio) (((gpio) & GPIOSPEEDMASK)==gpiomediumspeed)
//#define GPIOISFASTPEED(gpio) (((gpio) & GPIOSPEEDMASK)==gpiofastspeed)
//#define GPIOISHIGHSPEED(gpio) (((gpio) & GPIOSPEEDMASK)==gpiohighspeeds)
//#define GPIOISPUSHPULL(gpio) (((gpio) & GPIOOUTTYPEMASK)==gpiopushpulltype)
//#define GPIOISOPENDRAIN(gpio) (((gpio) & GPIOOUTTYPEMASK)==gpioopendraintype)
//#define GPIOISNOPULL(GPIO) (((gpio) & GPIOPULLTYPEMASK)==gpionopulltype)
//#define GPIOISPULLUP(GPIO) (((gpio) & GPIOPULLTYPEMASK)==gpiopulluptype)
//#define GPIOISPULLDOWN(GPIO) (((gpio) & GPIOPULLTYPEMASK)==gpiopulldowntype)
#define PA0 ((0<<8)+0)
#define PA1 ((0<<8)+1)
#define PA2 ((0<<8)+2)
#define PA3 ((0<<8)+3)
#define PA4 ((0<<8)+4)
#define PA5 ((0<<8)+5)
#define PA6 ((0<<8)+6)
#define PA7 ((0<<8)+7)
#define PA8 ((0<<8)+8)
#define PA9 ((0<<8)+9)
#define PA10 ((0<<8)+10)
#define PA11 ((0<<8)+11)
#define PA12 ((0<<8)+12)
#define PA13 ((0<<8)+13)
#define PA14 ((0<<8)+14)
#define PA15 ((0<<8)+15)
#define PAX ((0<<8)+255)
#define PB0 ((1<<8)+0)
#define PB1 ((1<<8)+1)
#define PB2 ((1<<8)+2)
#define PB3 ((1<<8)+3)
#define PB4 ((1<<8)+4)
#define PB5 ((1<<8)+5)
#define PB6 ((1<<8)+6)
#define PB7 ((1<<8)+7)
#define PB8 ((1<<8)+8)
#define PB9 ((1<<8)+9)
#define PB10 ((1<<8)+10)
#define PB11 ((1<<8)+11)
#define PB12 ((1<<8)+12)
#define PB13 ((1<<8)+13)
#define PB14 ((1<<8)+14)
#define PB15 ((1<<8)+15)
#define PBX ((1<<8)+255)
#define PC0 ((2<<8)+0)
#define PC1 ((2<<8)+1)
#define PC2 ((2<<8)+2)
#define PC3 ((2<<8)+3)
#define PC4 ((2<<8)+4)
#define PC5 ((2<<8)+5)
#define PC6 ((2<<8)+6)
#define PC7 ((2<<8)+7)
#define PC8 ((2<<8)+8)
#define PC9 ((2<<8)+9)
#define PC10 ((2<<8)+10)
#define PC11 ((2<<8)+11)
#define PC12 ((2<<8)+12)
#define PC13 ((2<<8)+13)
#define PC14 ((2<<8)+14)
#define PC15 ((2<<8)+15)
#define PCX ((2<<8)+255)
#define PD0 ((3<<8)+0)
#define PD1 ((3<<8)+1)
#define PD2 ((3<<8)+2)
#define PD3 ((3<<8)+3)
#define PD4 ((3<<8)+4)
#define PD5 ((3<<8)+5)
#define PD6 ((3<<8)+6)
#define PD7 ((3<<8)+7)
#define PD8 ((3<<8)+8)
#define PD9 ((3<<8)+9)
#define PD10 ((3<<8)+10)
#define PD11 ((3<<8)+11)
#define PD12 ((3<<8)+12)
#define PD13 ((3<<8)+13)
#define PD14 ((3<<8)+14)
#define PD15 ((3<<8)+15)
#define PDX ((3<<8)+255)
#define PE0 ((4<<8)+0)
#define PE1 ((4<<8)+1)
#define PE2 ((4<<8)+2)
#define PE3 ((4<<8)+3)
#define PE4 ((4<<8)+4)
#define PE5 ((4<<8)+5)
#define PE6 ((4<<8)+6)
#define PE7 ((4<<8)+7)
#define PE8 ((4<<8)+8)
#define PE9 ((4<<8)+9)
#define PE10 ((4<<8)+10)
#define PE11 ((4<<8)+11)
#define PE12 ((4<<8)+12)
#define PE13 ((4<<8)+13)
#define PE14 ((4<<8)+14)
#define PE15 ((4<<8)+15)
#define PEX ((4<<8)+255)
#define PF0 ((5<<8)+0)
#define PF1 ((5<<8)+1)
#define PF2 ((5<<8)+2)
#define PF3 ((5<<8)+3)
#define PF4 ((5<<8)+4)
#define PF5 ((5<<8)+5)
#define PF6 ((5<<8)+6)
#define PF7 ((5<<8)+7)
#define PF8 ((5<<8)+8)
#define PF9 ((5<<8)+9)
#define PF10 ((5<<8)+10)
#define PF11 ((5<<8)+11)
#define PF12 ((5<<8)+12)
#define PF13 ((5<<8)+13)
#define PF14 ((5<<8)+14)
#define PF15 ((5<<8)+15)
#define PFX ((5<<8)+255)
#define PG0 ((6<<8)+0)
#define PG1 ((6<<8)+1)
#define PG2 ((6<<8)+2)
#define PG3 ((6<<8)+3)
#define PG4 ((6<<8)+4)
#define PG5 ((6<<8)+5)
#define PG6 ((6<<8)+6)
#define PG7 ((6<<8)+7)
#define PG8 ((6<<8)+8)
#define PG9 ((6<<8)+9)
#define PG10 ((6<<8)+10)
#define PG11 ((6<<8)+11)
#define PG12 ((6<<8)+12)
#define PG13 ((6<<8)+13)
#define PG14 ((6<<8)+14)
#define PG15 ((6<<8)+15)
#define PGX ((6<<8)+255)
#define PH0 ((7<<8)+0)
#define PH1 ((7<<8)+1)
#define PH2 ((7<<8)+2)
#define PH3 ((7<<8)+3)
#define PH4 ((7<<8)+4)
#define PH5 ((7<<8)+5)
#define PH6 ((7<<8)+6)
#define PH7 ((7<<8)+7)
#define PH8 ((7<<8)+8)
#define PH9 ((7<<8)+9)
#define PH10 ((7<<8)+10)
#define PH11 ((7<<8)+11)
#define PH12 ((7<<8)+12)
#define PH13 ((7<<8)+13)
#define PH14 ((7<<8)+14)
#define PH15 ((7<<8)+15)
#define PHX ((7<<8)+255)
#define PI0 ((8<<8)+0)
#define PI1 ((8<<8)+1)
#define PI2 ((8<<8)+2)
#define PI3 ((8<<8)+3)
#define PI4 ((8<<8)+4)
#define PI5 ((8<<8)+5)
#define PI6 ((8<<8)+6)
#define PI7 ((8<<8)+7)
#define PI8 ((8<<8)+8)
#define PI9 ((8<<8)+9)
#define PI10 ((8<<8)+10)
#define PI11 ((8<<8)+11)
#define PI12 ((8<<8)+12)
#define PI13 ((8<<8)+13)
#define PI14 ((8<<8)+14)
#define PI15 ((8<<8)+15)
#define PIX ((8<<8)+255)
#define PJ0 ((9<<8)+0)
#define PJ1 ((9<<8)+1)
#define PJ2 ((9<<8)+2)
#define PJ3 ((9<<8)+3)
#define PJ4 ((9<<8)+4)
#define PJ5 ((9<<8)+5)
#define PJ6 ((9<<8)+6)
#define PJ7 ((9<<8)+7)
#define PJ8 ((9<<8)+8)
#define PJ9 ((9<<8)+9)
#define PJ10 ((9<<8)+10)
#define PJ11 ((9<<8)+11)
#define PJ12 ((9<<8)+12)
#define PJ13 ((9<<8)+13)
#define PJ14 ((9<<8)+14)
#define PJ15 ((9<<8)+15)
#define PJX ((9<<8)+255)
#define PK0 ((10<<8)+0)
#define PK1 ((10<<8)+1)
#define PK2 ((10<<8)+2)
#define PK3 ((10<<8)+3)
#define PK4 ((10<<8)+4)
#define PK5 ((10<<8)+5)
#define PK6 ((10<<8)+6)
#define PK7 ((10<<8)+7)
#define PK8 ((10<<8)+8)
#define PK9 ((10<<8)+9)
#define PK10 ((10<<8)+10)
#define PK11 ((10<<8)+11)
#define PK12 ((10<<8)+12)
#define PK13 ((10<<8)+13)
#define PK14 ((10<<8)+14)
#define PK15 ((10<<8)+15)
#define PKX ((10<<8)+255)
#define PL0 ((11<<8)+0)
#define PL1 ((11<<8)+1)
#define PL2 ((11<<8)+2)
#define PL3 ((11<<8)+3)
#define PL4 ((11<<8)+4)
#define PL5 ((11<<8)+5)
#define PL6 ((11<<8)+6)
#define PL7 ((11<<8)+7)
#define PL8 ((11<<8)+8)
#define PL9 ((11<<8)+9)
#define PL10 ((11<<8)+10)
#define PL11 ((11<<8)+11)
#define PL12 ((11<<8)+12)
#define PL13 ((11<<8)+13)
#define PL14 ((11<<8)+14)
#define PL15 ((11<<8)+15)
#define PLX ((11<<8)+255)
#define PM0 ((12<<8)+0)
#define PM1 ((12<<8)+1)
#define PM2 ((12<<8)+2)
#define PM3 ((12<<8)+3)
#define PM4 ((12<<8)+4)
#define PM5 ((12<<8)+5)
#define PM6 ((12<<8)+6)
#define PM7 ((12<<8)+7)
#define PM8 ((12<<8)+8)
#define PM9 ((12<<8)+9)
#define PM10 ((12<<8)+10)
#define PM11 ((12<<8)+11)
#define PM12 ((12<<8)+12)
#define PM13 ((12<<8)+13)
#define PM14 ((12<<8)+14)
#define PM15 ((12<<8)+15)
#define PMX ((12<<8)+255)
#define PN0 ((13<<8)+0)
#define PN1 ((13<<8)+1)
#define PN2 ((13<<8)+2)
#define PN3 ((13<<8)+3)
#define PN4 ((13<<8)+4)
#define PN5 ((13<<8)+5)
#define PN6 ((13<<8)+6)
#define PN7 ((13<<8)+7)
#define PN8 ((13<<8)+8)
#define PN9 ((13<<8)+9)
#define PN10 ((13<<8)+10)
#define PN11 ((13<<8)+11)
#define PN12 ((13<<8)+12)
#define PN13 ((13<<8)+13)
#define PN14 ((13<<8)+14)
#define PN15 ((13<<8)+15)
#define PNX ((13<<8)+255)
#define PO0 ((14<<8)+0)
#define PO1 ((14<<8)+1)
#define PO2 ((14<<8)+2)
#define PO3 ((14<<8)+3)
#define PO4 ((14<<8)+4)
#define PO5 ((14<<8)+5)
#define PO6 ((14<<8)+6)
#define PO7 ((14<<8)+7)
#define PO8 ((14<<8)+8)
#define PO9 ((14<<8)+9)
#define PO10 ((14<<8)+10)
#define PO11 ((14<<8)+11)
#define PO12 ((14<<8)+12)
#define PO13 ((14<<8)+13)
#define PO14 ((14<<8)+14)
#define PO15 ((14<<8)+15)
#define POX ((14<<8)+255)
#define PP0 ((15<<8)+0)
#define PP1 ((15<<8)+1)
#define PP2 ((15<<8)+2)
#define PP3 ((15<<8)+3)
#define PP4 ((15<<8)+4)
#define PP5 ((15<<8)+5)
#define PP6 ((15<<8)+6)
#define PP7 ((15<<8)+7)
#define PP8 ((15<<8)+8)
#define PP9 ((15<<8)+9)
#define PP10 ((15<<8)+10)
#define PP11 ((15<<8)+11)
#define PP12 ((15<<8)+12)
#define PP13 ((15<<8)+13)
#define PP14 ((15<<8)+14)
#define PP15 ((15<<8)+15)
#define PPX ((15<<8)+255)
#define PQ0 ((16<<8)+0)
#define PQ1 ((16<<8)+1)
#define PQ2 ((16<<8)+2)
#define PQ3 ((16<<8)+3)
#define PQ4 ((16<<8)+4)
#define PQ5 ((16<<8)+5)
#define PQ6 ((16<<8)+6)
#define PQ7 ((16<<8)+7)
#define PQ8 ((16<<8)+8)
#define PQ9 ((16<<8)+9)
#define PQ10 ((16<<8)+10)
#define PQ11 ((16<<8)+11)
#define PQ12 ((16<<8)+12)
#define PQ13 ((16<<8)+13)
#define PQ14 ((16<<8)+14)
#define PQ15 ((16<<8)+15)
#define PQX ((16<<8)+255)
#define PR0 ((17<<8)+0)
#define PR1 ((17<<8)+1)
#define PR2 ((17<<8)+2)
#define PR3 ((17<<8)+3)
#define PR4 ((17<<8)+4)
#define PR5 ((17<<8)+5)
#define PR6 ((17<<8)+6)
#define PR7 ((17<<8)+7)
#define PR8 ((17<<8)+8)
#define PR9 ((17<<8)+9)
#define PR10 ((17<<8)+10)
#define PR11 ((17<<8)+11)
#define PR12 ((17<<8)+12)
#define PR13 ((17<<8)+13)
#define PR14 ((17<<8)+14)
#define PR15 ((17<<8)+15)
#define PRX ((17<<8)+255)
#define PS0 ((18<<8)+0)
#define PS1 ((18<<8)+1)
#define PS2 ((18<<8)+2)
#define PS3 ((18<<8)+3)
#define PS4 ((18<<8)+4)
#define PS5 ((18<<8)+5)
#define PS6 ((18<<8)+6)
#define PS7 ((18<<8)+7)
#define PS8 ((18<<8)+8)
#define PS9 ((18<<8)+9)
#define PS10 ((18<<8)+10)
#define PS11 ((18<<8)+11)
#define PS12 ((18<<8)+12)
#define PS13 ((18<<8)+13)
#define PS14 ((18<<8)+14)
#define PS15 ((18<<8)+15)
#define PSX ((18<<8)+255)
#define PT0 ((19<<8)+0)
#define PT1 ((19<<8)+1)
#define PT2 ((19<<8)+2)
#define PT3 ((19<<8)+3)
#define PT4 ((19<<8)+4)
#define PT5 ((19<<8)+5)
#define PT6 ((19<<8)+6)
#define PT7 ((19<<8)+7)
#define PT8 ((19<<8)+8)
#define PT9 ((19<<8)+9)
#define PT10 ((19<<8)+10)
#define PT11 ((19<<8)+11)
#define PT12 ((19<<8)+12)
#define PT13 ((19<<8)+13)
#define PT14 ((19<<8)+14)
#define PT15 ((19<<8)+15)
#define PTX ((19<<8)+255)
#define PU0 ((20<<8)+0)
#define PU1 ((20<<8)+1)
#define PU2 ((20<<8)+2)
#define PU3 ((20<<8)+3)
#define PU4 ((20<<8)+4)
#define PU5 ((20<<8)+5)
#define PU6 ((20<<8)+6)
#define PU7 ((20<<8)+7)
#define PU8 ((20<<8)+8)
#define PU9 ((20<<8)+9)
#define PU10 ((20<<8)+10)
#define PU11 ((20<<8)+11)
#define PU12 ((20<<8)+12)
#define PU13 ((20<<8)+13)
#define PU14 ((20<<8)+14)
#define PU15 ((20<<8)+15)
#define PUX ((20<<8)+255)
#define PV0 ((21<<8)+0)
#define PV1 ((21<<8)+1)
#define PV2 ((21<<8)+2)
#define PV3 ((21<<8)+3)
#define PV4 ((21<<8)+4)
#define PV5 ((21<<8)+5)
#define PV6 ((21<<8)+6)
#define PV7 ((21<<8)+7)
#define PV8 ((21<<8)+8)
#define PV9 ((21<<8)+9)
#define PV10 ((21<<8)+10)
#define PV11 ((21<<8)+11)
#define PV12 ((21<<8)+12)
#define PV13 ((21<<8)+13)
#define PV14 ((21<<8)+14)
#define PV15 ((21<<8)+15)
#define PVX ((21<<8)+255)
#define PW0 ((22<<8)+0)
#define PW1 ((22<<8)+1)
#define PW2 ((22<<8)+2)
#define PW3 ((22<<8)+3)
#define PW4 ((22<<8)+4)
#define PW5 ((22<<8)+5)
#define PW6 ((22<<8)+6)
#define PW7 ((22<<8)+7)
#define PW8 ((22<<8)+8)
#define PW9 ((22<<8)+9)
#define PW10 ((22<<8)+10)
#define PW11 ((22<<8)+11)
#define PW12 ((22<<8)+12)
#define PW13 ((22<<8)+13)
#define PW14 ((22<<8)+14)
#define PW15 ((22<<8)+15)
#define PWX ((22<<8)+255)
#define PX0 ((23<<8)+0)
#define PX1 ((23<<8)+1)
#define PX2 ((23<<8)+2)
#define PX3 ((23<<8)+3)
#define PX4 ((23<<8)+4)
#define PX5 ((23<<8)+5)
#define PX6 ((23<<8)+6)
#define PX7 ((23<<8)+7)
#define PX8 ((23<<8)+8)
#define PX9 ((23<<8)+9)
#define PX10 ((23<<8)+10)
#define PX11 ((23<<8)+11)
#define PX12 ((23<<8)+12)
#define PX13 ((23<<8)+13)
#define PX14 ((23<<8)+14)
#define PX15 ((23<<8)+15)
#define PXX ((23<<8)+255)
#define PY0 ((24<<8)+0)
#define PY1 ((24<<8)+1)
#define PY2 ((24<<8)+2)
#define PY3 ((24<<8)+3)
#define PY4 ((24<<8)+4)
#define PY5 ((24<<8)+5)
#define PY6 ((24<<8)+6)
#define PY7 ((24<<8)+7)
#define PY8 ((24<<8)+8)
#define PY9 ((24<<8)+9)
#define PY10 ((24<<8)+10)
#define PY11 ((24<<8)+11)
#define PY12 ((24<<8)+12)
#define PY13 ((24<<8)+13)
#define PY14 ((24<<8)+14)
#define PY15 ((24<<8)+15)
#define PYX ((24<<8)+255)
#define PZ0 ((25<<8)+0)
#define PZ1 ((25<<8)+1)
#define PZ2 ((25<<8)+2)
#define PZ3 ((25<<8)+3)
#define PZ4 ((25<<8)+4)
#define PZ5 ((25<<8)+5)
#define PZ6 ((25<<8)+6)
#define PZ7 ((25<<8)+7)
#define PZ8 ((25<<8)+8)
#define PZ9 ((25<<8)+9)
#define PZ10 ((25<<8)+10)
#define PZ11 ((25<<8)+11)
#define PZ12 ((25<<8)+12)
#define PZ13 ((25<<8)+13)
#define PZ14 ((25<<8)+14)
#define PZ15 ((25<<8)+15)
#define PZX ((25<<8)+255)
#endif
#ifdef __cplusplus
}
#endif
#endif //GPIO_H