HG_REPOSITORIES/LPP/INSTRUMENTATION/libuc2 Commit - r73:5e865c663d35

Some more doc.

jeandet -

r73:5e865c663d35 dev_alexis

parent child

Context file:

r73:5e865c663d35

Collapse all files

include/GRAPHIC/CONTROLERS/ili9328.h +11 0

             /*------------------------------------------------------------------------------
             --  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
             --                   Mail : alexis.jeandet@gmail.com
             -------------------------------------------------------------------------------*/
             #ifndef ILI9328_H
             #define ILI9328_H
+            /**
+              @todo Make an abstract layer for framebuffer devices and a painting api for it.
+            */
             #include <genericLCD_Controler.h>
+            /**
+             * @brief ili9328init
+             * @param LCD
+             * @return
+             */
             extern int  ili9328init(struct LCD_t* LCD);
             extern void ili9328setFrame(LCD_t* LCD,uint16_t X,uint16_t Y,uint16_t W,uint16_t H);
             extern void ili9328setGRAMaddress(LCD_t* LCD,uint16_t Haddress,uint16_t Vaddress);
             extern void ili9328paint(LCD_t* LCD,void* buffer,uint16_t Xpos,uint16_t Ypos,uint16_t Width,uint16_t Height);
             extern void ili9328paintText(LCD_t* LCD,char* buffer,uint16_t Xpos,uint16_t Ypos,sFONT *font,uint32_t color);
             extern void ili9328paintFilRect(LCD_t* LCD,uint16_t Xpos,uint16_t Ypos,uint16_t w,uint16_t h,uint32_t contColor,uint16_t contSz,uint32_t fillColor);
             extern void ili9328paintFilCirc(LCD_t* LCD,uint16_t Xpos,uint16_t Ypos,uint16_t r,uint32_t contColor,uint16_t contSz,uint32_t fillColor);
             extern void ili9328paintFilCircMidPoint(LCD_t* LCD,uint16_t Xpos,uint16_t Ypos,uint16_t r,uint32_t contColor,uint16_t contSz,uint32_t fillColor);
             extern void ili9328getPix(struct LCD_t* LCD,uint16_t* buffer,uint16_t Xpos,uint16_t Ypos,uint16_t w,uint16_t h);
             extern void ili9328refreshenable(struct LCD_t* LCD,int enable);
             extern void ili9328paintChar(LCD_t* LCD,char buffer,uint16_t Xpos,uint16_t Ypos,sFONT* font,uint32_t color);
             #define	ILI9328_REGISTER_DRIVERCODEREAD                 ((uint32_t) 0x0000 )
             #define	ILI9328_REGISTER_DRIVEROUTPUTCONTROL1           ((uint32_t) 0x0001 )
             #define	ILI9328_REGISTER_LCDDRIVINGCONTROL              ((uint32_t) 0x0002 )
             #define	ILI9328_REGISTER_ENTRYMODE                      ((uint32_t) 0x0003 )
             #define	ILI9328_REGISTER_RESIZECONTROL                  ((uint32_t) 0x0004 )
             #define	ILI9328_REGISTER_DISPLAYCONTROL1                ((uint32_t) 0x0007 )
             #define	ILI9328_REGISTER_DISPLAYCONTROL2                ((uint32_t) 0x0008 )
             #define	ILI9328_REGISTER_DISPLAYCONTROL3                ((uint32_t) 0x0009 )
             #define	ILI9328_REGISTER_DISPLAYCONTROL4                ((uint32_t) 0x000A )
             #define	ILI9328_REGISTER_RGBDISPLAYINTERFACECONTROL1    ((uint32_t) 0x000C )
             #define	ILI9328_REGISTER_FRAMEMAKERPOSITION             ((uint32_t) 0x000D )
             #define	ILI9328_REGISTER_RGBDISPLAYINTERFACECONTROL2    ((uint32_t) 0x000F )
             #define	ILI9328_REGISTER_POWERCONTROL1                  ((uint32_t) 0x0010 )
             #define	ILI9328_REGISTER_POWERCONTROL2                  ((uint32_t) 0x0011 )
             #define	ILI9328_REGISTER_POWERCONTROL3                  ((uint32_t) 0x0012 )
             #define	ILI9328_REGISTER_POWERCONTROL4                  ((uint32_t) 0x0013 )
             #define	ILI9328_REGISTER_HORIZONTALGRAMADDRESSSET       ((uint32_t) 0x0020 )
             #define	ILI9328_REGISTER_VERTICALGRAMADDRESSSET         ((uint32_t) 0x0021 )
             #define	ILI9328_REGISTER_WRITEDATATOGRAM                ((uint32_t) 0x0022 )
             #define	ILI9328_REGISTER_POWERCONTROL7                  ((uint32_t) 0x0029 )
             #define	ILI9328_REGISTER_FRAMERATEANDCOLORCONTROL       ((uint32_t) 0x002B )
             #define	ILI9328_REGISTER_GAMMACONTROL1                  ((uint32_t) 0x0030 )
             #define	ILI9328_REGISTER_GAMMACONTROL2                  ((uint32_t) 0x0031 )
             #define	ILI9328_REGISTER_GAMMACONTROL3                  ((uint32_t) 0x0032 )
             #define	ILI9328_REGISTER_GAMMACONTROL4                  ((uint32_t) 0x0035 )
             #define	ILI9328_REGISTER_GAMMACONTROL5                  ((uint32_t) 0x0036 )
             #define	ILI9328_REGISTER_GAMMACONTROL6                  ((uint32_t) 0x0037 )
             #define	ILI9328_REGISTER_GAMMACONTROL7                  ((uint32_t) 0x0038 )
             #define	ILI9328_REGISTER_GAMMACONTROL8                  ((uint32_t) 0x0039 )
             #define	ILI9328_REGISTER_GAMMACONTROL9                  ((uint32_t) 0x003C )
             #define	ILI9328_REGISTER_GAMMACONTROL10                 ((uint32_t) 0x003D )
             #define	ILI9328_REGISTER_HORIZONTALADDRESSSTARTPOSITION	((uint32_t)	0x0050 )
             #define	ILI9328_REGISTER_HORIZONTALADDRESSENDPOSITION	((uint32_t) 0x0051 )
             #define	ILI9328_REGISTER_VERTICALADDRESSSTARTPOSITION	((uint32_t) 0x0052 )
             #define	ILI9328_REGISTER_VERTICALADDRESSENDPOSITION     ((uint32_t) 0x0053 )
             #define	ILI9328_REGISTER_DRIVEROUTPUTCONTROL2           ((uint32_t) 0x0060 )
             #define	ILI9328_REGISTER_BASEIMAGEDISPLAYCONTROL        ((uint32_t) 0x0061 )
             #define	ILI9328_REGISTER_VERTICALSCROLLCONTROL          ((uint32_t) 0x006A )
             #define	ILI9328_REGISTER_PARTIALIMAGE1DISPLAYPOSITION   ((uint32_t) 0x0080 )
             #define	ILI9328_REGISTER_PARTIALIMAGE1AREASTARTLINE     ((uint32_t) 0x0081 )
             #define	ILI9328_REGISTER_PARTIALIMAGE1AREAENDLINE       ((uint32_t) 0x0082 )
             #define	ILI9328_REGISTER_PARTIALIMAGE2DISPLAYPOSITION   ((uint32_t) 0x0083 )
             #define	ILI9328_REGISTER_PARTIALIMAGE2AREASTARTLINE     ((uint32_t) 0x0084 )
             #define	ILI9328_REGISTER_PARTIALIMAGE2AREAENDLINE       ((uint32_t) 0x0085 )
             #define	ILI9328_REGISTER_PANELINTERFACECONTROL1         ((uint32_t) 0x0090 )
             #define	ILI9328_REGISTER_PANELINTERFACECONTROL2         ((uint32_t) 0x0092 )
             #define	ILI9328_REGISTER_PANELINTERFACECONTROL4         ((uint32_t) 0x0095 )
             #define	ILI9328_REGISTER_OTPVCMPROGRAMMINGCONTROL       ((uint32_t) 0x00A1 )
             #define	ILI9328_REGISTER_OTPVCMSTATUSANDENABLE          ((uint32_t) 0x00A2 )
             #define	ILI9328_REGISTER_OTPPROGRAMMINGIDKEY            ((uint32_t) 0x00A5 )
             #ifdef _PRVATE_ILI9328_
             void ili9328cpFrame(LCD_t* LCD,void* buffer,int x,int y,int w, int h);
             #endif
             #endif

include/PERIPHERALS/gpio.h +111 -16

-            /*------------------------------------------------------------------------------
+            /** ------------------------------------------------------------------------------
             --  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
+            --                 @Author : Alexis Jeandet
-            --                   Mail : alexis.jeandet@gmail.com
+            --                  @Mail : alexis.jeandet@gmail.com
             -------------------------------------------------------------------------------*/
             /*! \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
             */
             #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.
+             */
             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)
+             */
             typedef enum gpiospeed_t
             {
-              gpiolowspeed    = 0x00000,
+              gpiolowspeed    = 0x00000, /**< Lowest speed value*/
-              gpiomediumspeed = 0x10000,
+              gpiomediumspeed = 0x10000, /**< Normal or medium speed value*/
-              gpiofastspeed   = 0x20000,
+              gpiofastspeed   = 0x20000, /**< Higher speed value*/
-              gpiohighspeed   = 0x30000
+              gpiohighspeed   = 0x30000  /**< 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)
+             */
             typedef enum gpiodir_t
             {
-              gpioindir    = 0x00000,
+              gpioindir    = 0x00000, /**<  Input direction*/
-              gpiooutdir   = 0x40000,
+              gpiooutdir   = 0x40000, /**<  Output direction*/
-              gpioaf       = 0x80000,
+              gpioaf       = 0x80000, /**<  Alternate function such as spi, uart, ...*/
-              gpioan       = 0xC0000
+              gpioan       = 0xC0000  /**<  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)
+             */
             typedef enum gpioouttype_t
             {
-              gpiopushpulltype    = 0x000000,
+              gpiopushpulltype    = 0x000000, /**< Pushpull output*/
-              gpioopendraintype   = 0x100000
+              gpioopendraintype   = 0x100000  /**< 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)
+             */
             typedef enum gpiopulltype_t
             {
               gpionopulltype    = 0x000000,
               gpiopulluptype    = 0x200000,
               gpiopulldowntype  = 0x400000
             }gpiopulltype_t;
             #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)
+             */
             extern gpio_t gpioopen(uint32_t gpio);
+            /**
+             * @brief gpioclose
+             * @param gpio
+             * @sa gpioopen(uint32_t gpio)
+             */
             extern void gpioclose(gpio_t gpio);
+            /**
+             * @brief gpiosetconfig
+             * @param gpio
+             */
             extern void gpiosetconfig(gpio_t* gpio);
+            /**
+             * @brief gpiosetdir
+             * @param gpio
+             * @param dir
+             */
             extern void gpiosetdir(gpio_t* gpio,gpiodir_t dir);
+            /**
+             * @brief gpiosetouttype
+             * @param gpio
+             * @param outtype
+             * @sa gpiosetconfig(gpio_t* gpio)
+             */
             extern void gpiosetouttype(gpio_t* gpio, gpioouttype_t outtype);
+            /**
+             * @brief gpiosetpulltype
+             * @param gpio
+             * @param pulltype
+             * @sa gpiosetconfig(gpio_t* gpio)
+             */
             extern void gpiosetpulltype(gpio_t* gpio,gpiopulltype_t pulltype);
+            /**
+             * @brief gpiosetspeed
+             * @param gpio
+             * @param speed
+             * @sa gpiosetconfig(gpio_t* gpio)
+             */
             extern void gpiosetspeed(gpio_t* gpio,gpiospeed_t speed);
+            /**
+             * @brief gpioset
+             * @param gpio
+             * @sa gpiosetconfig(gpio_t* gpio)
+             */
             extern void gpioset(gpio_t gpio);
+            /**
+             * @brief gpioclr
+             * @param gpio
+             */
             extern void gpioclr(gpio_t gpio);
+            /**
+             * @brief gpiosetval
+             * @param gpio
+             * @param val
+             */
             extern void gpiosetval(gpio_t gpio,int val);
+            /**
+             * @brief gpiogetval
+             * @param gpio
+             * @return
+             */
             extern int  gpiogetval(gpio_t gpio);
             #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)
             #ifndef DOXYGEN_SHOULD_SKIP_THIS
             #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

include/PERIPHERALS/uart.h 0 -9

             /*------------------------------------------------------------------------------
             --  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
             --                   Mail : alexis.jeandet@gmail.com
             -------------------------------------------------------------------------------*/
             /*! \file uart.h
             \brief UART api.
             The uart api gives you a standard way to drive any uart on any processor.
             With this api you will be able to open and configure your UART define the
             associated pins when applicable and read/write on it. Note that depending
             on the target architecture you can have soft or hard UART.
             A simple example to read or writes on uart1.
               \code
               // lets open uart1
               //config :
               // -parity = No
               // -data bits = 8
               // -stop bits = 1
               // -speed = 115200 bauds
               // -TX = PA9
               // -RX = PA10
               // -CTS = unused (-1)
               // -RTS = unused (-1)
               uart_t uart = uartopenandconfig(uart1,uartparitynone | uart8bits | uartonestop,115200,PA9,PA10,-1,-1);
               //check that everything is ok
               if(uart==uart1)
               {
                   //to write 0xFF on uart1
                   uartputc(uart,0xFF);
                   //you can also send a string on uart1
                   char* buffer="hello";
                   uartputs(uart,buffer);
                   //to read a char
                   char result = uartgetc(uart);
               }
               \endcode
             */
             #ifndef UART_H
             #define UART_H
             #include <streamdevices.h>
             #ifdef __cplusplus
             extern "C" {
             #endif
-            /*
-            typedef volatile struct uart_t
-                 volatile void* _dev;
-                 volatile int   cfg;
-                 volatile int   speed;
-            }uart_t;
-             */
             /**
              * @brief uart handle
              *
              * uart_t is the handle type you will use for all uart related functions.
              */
             typedef int uart_t;
             #define uart1 0 ///< uart1
             #define uart2 1 ///< uart2
             #define uart3 2 ///< uart3
             #define uart4 3 ///< uart4
             #define uart5 4 ///< uart5
             #define uart6 5 ///< uart6
             #define uart7 6 ///< uart7
             #define uart8 7 ///< uart8
             #define uart9 8 ///< uart9
             #ifndef DOXYGEN_SHOULD_SKIP_THIS
              #define UARTPARITYMASK  0x3
              #define UARTBITSMASK  0xC
              #define UARTSTOPBITSMASK 0x70
             #endif
             /**
               * @brief Uart parity enum
               *
               * Use uartparity_t values to configure the parity of your UART port with
               * uartsetparity function or uartsetconfig. Don't try to use numerical values
               * directly!
               */
             typedef enum uartparity_t
             {
                 uartparitynone = 0x1, /**< No parity */
                 uartparityeven = 0x2, /**< Even parity */
                 uartparityodd  = 0x3  /**< Odd parity */
             }uartparity_t;
             /**
               * @brief Uart data bits enum
               *
               * Use uartbits_t values to configure the number of data bits of your UART port with
               * uartsetdatabits function or uartsetconfig. Don't try to use numerical values
               * directly!
               */
             typedef enum uartbits_t
             {
                 uart7bits    = 0x4, /**< 7 data bits communication */
                 uart8bits    = 0x8, /**< 8 data bits communication */
                 uart9bits    = 0xC  /**< 9 data bits communication */
             }uartbits_t;
             /**
               * @brief Uart stop bits enum
               *
               * Use uartstopbits_t values to configure the number of stop bits of your UART port with
               * uartsetstopbits function or uartsetconfig. Don't try to use numerical values
               * directly!
               */
             typedef enum uartstopbits_t
             {
                 uarthalfstop    = 0x10, /**< 0.5 stop bits communication */
                 uartonestop     = 0x20, /**< 1 stop bits communication */
                 uartonehalfstop = 0x30, /**< 1.5 stop bits communication */
                 uarttwostop     = 0x40  /**< 2 stop bits communication */
             }uartstopbits_t;
             /**
              * @brief Uart open function
              *
              * This function opens the given uart, it should turn it ON iff needed and enable it.
              * @param count The uart identifier uart1 for example
              * @return The uart identifier on success or -1 if it fails.
              */
             extern uart_t uartopen(int count);
             /**
              * @brief Uart open and configure function
              *
              * This function call uartopen and configure the UART with the given parameters.
              * @param count The uart identifier uart1 for example
              * @param cfg  The configuration of the UART, build from an or mask.
              * @param speed The target speed of the UART in bauds, the real speed depend on the implementation
              * and the target.
              * @param TXpin The TXpin look gpio api.
              * @param RXpin The RXpin look gpio api.
              * @param RTSpin The RTSpin look gpio api.
              * @param CTSpin The CTSpin look gpio api.
              * @return The uart identifier on success or -1 if it fails.
              * @sa uartclose(uart_t uart), uartopenandconfig(int count ,uint32_t cfg,uint32_t speed,uint32_t TXpin,uint32_t RXpin,uint32_t RTSpin,uint32_t CTSpin), uartsetconfig(uart_t uart,uint32_t cfg,uint32_t speed)
              */
             extern uart_t uartopenandconfig(int count ,uint32_t cfg,uint32_t speed,uint32_t TXpin,uint32_t RXpin,uint32_t RTSpin,uint32_t CTSpin);
             /**
              * @brief Uart close function
              *
              * This function should at least reset the UART configuration.
              * @param uart The uart identifier uart1 for example.
              * @return 1 on success or -1 on error.
              */
             extern int uartclose(uart_t uart);
             /**
              * @brief uart set pins function
              *
              * This function sets the Uart pins, you have to check for each target that the pins you selected
              * are compatible with the desired function.
              * @param uart The uart identifier uart1 for example.
              * @param TXpin The TXpin look gpio api.
              * @param RXpin The RXpin look gpio api.
              * @param RTSpin The RTSpin look gpio api.
              * @param CTSpin The CTSpin look gpio api.
              * @return 1 on success or -1 on error.
              * @sa uartopen(int count)
              */
             extern int uartsetpins(uart_t uart,uint32_t TXpin,uint32_t RXpin,uint32_t RTSpin,uint32_t CTSpin);
             /**
              * @brief Enable uart functionnable
              *
              *This function enables given uart, it makes sens on target where you can enable or disable
              *the uart.
              * @param uart The uart identifier uart1 for example.
              * @return 1 on success or -1 on error.
              * @sa uartenable(uart_t uart)
              */
             extern int uartenable(uart_t uart);
             /**
              * @brief Disable uart function
              *
              *This function disables given uart, it makes sens on target where you can enable or disable
              *the uart.
              * @param uart The uart identifier uart1 for example.
              * @return 1 on success or -1 on error.
              */
             extern int uartdisable(uart_t uart);
             /**
              * @brief uart set configuration function
              *
              * This function configure the given uart.
              * @param uart The uart identifier uart1 for example.
              * @param cfg
              * @param speed
              * @return
              */
             extern int uartsetconfig(uart_t uart,uint32_t cfg,uint32_t speed);
             /**
              * @brief uartsetspeed
              * @param uart The uart identifier uart1 for example.
              * @param speed
              * @return
              */
             extern int uartsetspeed(uart_t uart,uint32_t speed);
             /**
              * @brief uartsetparity
              * @param uart The uart identifier uart1 for example.
              * @param parity
              * @return
              */
             extern int uartsetparity(uart_t uart,uartparity_t parity);
             /**
              * @brief uartsetdatabits
              * @param uart The uart identifier uart1 for example.
              * @param databits
              * @return
              */
             extern int uartsetdatabits(uart_t uart,uartbits_t databits);
             /**
              * @brief uartsetstopbits
              * @param uart The uart identifier uart1 for example.
              * @param stopbits
              * @return
              */
             extern int uartsetstopbits(uart_t uart,uartstopbits_t stopbits);
             /**
              * @brief uartputc
              * @param uart The uart identifier uart1 for example.
              * @param c
              * @return
              */
             extern int uartputc(uart_t uart,char c);
             /**
              * @brief uartgetc
              * @param uart The uart identifier uart1 for example.
              * @return
              */
             extern char uartgetc(uart_t uart);
             /**
              * @brief uartputs
              * @param uart The uart identifier uart1 for example.
              * @param s
              * @return
              */
             extern int uartputs(uart_t uart,char* s);
             /**
              * @brief uartgets
              * @param uart The uart identifier uart1 for example.
              * @param s
              * @return
              */
             extern int uartgets(uart_t uart,char* s);
             /**
              * @brief uartputnc
              * @param uart The uart identifier uart1 for example.
              * @param c
              * @param n
              * @return
              */
             extern int uartputnc(uart_t uart,char* c,int n);
             /**
              * @brief uartgetnc
              * @param uart The uart identifier uart1 for example.
              * @param c
              * @param n
              * @return
              */
             extern int uartgetnc(uart_t uart,char* c,int n);
             /**
              * @brief uartavailiabledata
              * @param uart The uart identifier uart1 for example.
              * @return
              */
             extern int uartavailiabledata(uart_t uart);
             /**
              * @brief uartmkstreamdev
              * @param uart The uart identifier uart1 for example.
              * @param strdev
              * @return
              */
             extern int uartmkstreamdev(uart_t uart,streamdevice* strdev);
             #ifdef __cplusplus
             }
             #endif
             #endif //SPI_H

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages