GpioPinMacros.h

Go to the documentation of this file.

/*
    GpioPinMacros.h - Macros for naming and manipulating Arduino pins.
    For AVR ATMega328p (Arduino Uno) and ATMega2560 (Arduino Mega).
    This is part of the AVRTools library.
    Copyright (c) 2014 Igor Mikolic-Torreira.  All right reserved.
 
    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, see <http://www.gnu.org/licenses/>.
*/
 
 
#ifndef GpioPinMacros_h
#define GpioPinMacros_h
 
 
#include <avr/io.h>
 
 
 
enum
{
    kDigitalLow = 0,        
    kDigitalHigh = 1        
};
 
 
 
 
 
/*
 
    These macros are implementation details for the port naming macros and are not intended
    for end-users.  These are required to make the macros work due to the
    reparsing and resubstitution rules of the C/C++ preprocessor.
 
*/
 
 
#define _GpioPin( ddr, port, pin, nbr )     \
                                        ddr, port, pin, nbr, -1, 0, -1, 0
 
#define _GpioPinAnalog( ddr, port, pin, nbr, adc )  \
                                        ddr, port, pin, nbr, adc, 0, -1, 0
 
#define _GpioPinPwm( ddr, port, pin, nbr, ocr, com, tccr )       \
                                     ddr, port, pin, nbr, -1, ocr, com, tccr
 
#define _isGpioPinModeOutput( ddr, port, pin, nbr, adc, ocr, com, tccr )        ( ddr & (1<<nbr) )
 
#define _isGpioPinModeInput( ddr, port, pin, nbr, adc, ocr, com, tccr )         (!( ddr & (1<<nbr) ))
 
#define _setGpioPinModeOutput( ddr, port, pin, nbr, adc, ocr, com, tccr )       ddr |= (1<<nbr)
 
#define _setGpioPinModeInput( ddr, port, pin, nbr, adc, ocr, com, tccr )        ddr &= ~(1<<nbr), port &= ~(1<<nbr)
 
#define _setGpioPinModeInputPullup( ddr, port, pin, nbr, adc, ocr, com, tccr )  ddr &= ~(1<<nbr), port |= (1<<nbr)
 
#define _readGpioPinDigital( ddr, port, pin, nbr, adc, ocr, com, tccr )         ( pin & (1<<nbr) )
 
#define _writeGpioPinDigital( ddr, port, pin, nbr, adc, ocr, com, tccr, value )     \
                                        do { if (value) port |= (1<<nbr); else port &= ~(1<<nbr); } while ( 0 )
 
#define _setGpioPinHigh( ddr, port, pin, nbr, adc, ocr, com, tccr )             port |= (1<<nbr)
 
#define _setGpioPinLow( ddr, port, pin, nbr, adc, ocr, com, tccr )              port &= ~(1<<nbr)
 
#define _getGpioDDR( ddr, port, pin, nbr, adc, ocr, com, tccr )                 ddr
 
#define _getGpioPORT( ddr, port, pin, nbr, adc, ocr, com, tccr )                port
 
#define _getGpioPIN( ddr, port, pin, nbr, adc, ocr, com, tccr )                 pin
 
#define _getGpioMASK( ddr, port, pin, nbr, adc, ocr, com, tccr )                (1<<nbr)
 
#define _getGpioADC( ddr, port, pin, nbr, adc, ocr, com, tccr )                 adc
 
#define _getGpioOCR( ddr, port, pin, nbr, adc, ocr, com, tccr )                 ocr
 
#define _getGpioCOM( ddr, port, pin, nbr, adc, ocr, com, tccr )                 com
 
#define _getGpioTCCR( ddr, port, pin, nbr, adc, ocr, com, tccr )                tccr
 
 
 
 
 
/*
 
    These macros are for end-users to name GPIO pins and manipulate GPIO pin name macros.
 
*/
 
 
 
#define GpioPin( portLtr, pinNbr )          \
                                        _GpioPin( DDR##portLtr, PORT##portLtr, PIN##portLtr, pinNbr )
 
 
 
#define GpioPinAnalog( portLtr, pinNbr, adcNbr )    \
                                        _GpioPinAnalog( DDR##portLtr, PORT##portLtr, PIN##portLtr, pinNbr, adcNbr )
 
 
#define GpioPinPwm( portLtr, pinNbr, timer, chan )   \
    _GpioPinPwm( DDR##portLtr, PORT##portLtr, PIN##portLtr, pinNbr, OCR##timer##chan, COM##timer##chan##1, TCCR##timer##A )
 
 
 
#define isGpioPinModeOutput( pinName )                                         _isGpioPinModeOutput( pinName )
 
 
 
#define isGpioPinModeInput( pinName )                                          _isGpioPinModeInput( pinName )
 
 
 
#define setGpioPinModeOutput( pinName )                                         _setGpioPinModeOutput( pinName )
 
 
 
#define setGpioPinModeInput( pinName )                                          _setGpioPinModeInput( pinName )
 
 
 
#define setGpioPinModeInputPullup( pinName )                                    _setGpioPinModeInputPullup( pinName )
 
 
 
#define readGpioPinDigital( pinName )                                           _readGpioPinDigital( pinName )
 
 
#define writeGpioPinDigital( pinName, val )                                     _writeGpioPinDigital( pinName, val )
 
 
 
#define setGpioPinHigh( pinName )                                               _setGpioPinHigh( pinName )
 
 
 
#define setGpioPinLow( pinName )                                                _setGpioPinLow( pinName )
 
 
 
#define getGpioDDR( pinName )                                                   _getGpioDDR( pinName )
 
 
 
#define getGpioPORT( pinName )                                                  _getGpioPORT( pinName )
 
 
 
#define getGpioPIN( pinName )                                                   _getGpioPIN( pinName )
 
 
 
#define getGpioMASK( pinName )                                                  _getGpioMASK( pinName )
 
 
 
#define getGpioADC( pinName )                                                   _getGpioADC( pinName )
 
 
 
#define getGpioOCR( pinName )                                                   _getGpioOCR( pinName )
 
 
 
#define getGpioCOM( pinName )                                                   _getGpioCOM( pinName )
 
 
 
#define getGpioTCCR( pinName )                                                  _getGpioTCCR( pinName )
 
 
 
 
/******************************************/
 
/*
 * Support for GPIO pin variables
 *
 */
 
 
typedef volatile uint8_t* Gpio8Ptr;
typedef volatile uint16_t* Gpio16Ptr;
 
class GpioPinVariable
{
public:
 
    GpioPinVariable()
    : mDdr( 0 ), mPort( 0 ), mPin( 0 ), mOcr( 0 ), mTccr( 0 ), mCom( 0xFF ),
    mNbr( 0xFF ), mAdc( 0xFF )
    {}
 
    GpioPinVariable( Gpio8Ptr ddr, Gpio8Ptr port, Gpio8Ptr pin, int8_t nbr )
    : mDdr( ddr ), mPort( port ), mPin( pin ), mOcr( 0 ), mTccr( 0 ), mCom( 0xFF ),
    mNbr( static_cast<uint8_t>(nbr) ), mAdc( 0xFF )
    {}
 
    GpioPinVariable( Gpio8Ptr ddr, Gpio8Ptr port, Gpio8Ptr pin, int8_t nbr, int8_t adc )
    : mDdr( ddr ), mPort( port ), mPin( pin ), mOcr( 0 ), mTccr( 0 ), mCom( 0xFF ),
    mNbr( static_cast<uint8_t>(nbr) ), mAdc( static_cast<uint8_t>(adc) )
    {}
 
    GpioPinVariable( Gpio8Ptr ddr, Gpio8Ptr port, Gpio8Ptr pin, int8_t nbr, Gpio16Ptr ocr, Gpio8Ptr tccr, int8_t com )
    : mDdr( ddr ), mPort( port ), mPin( pin ), mOcr( ocr ), mTccr( tccr ), mCom( com ),
    mNbr( static_cast<uint8_t>(nbr) ), mAdc( 0xFF )
    {}
 
    Gpio8Ptr ddr() const
    { return mDdr; }
 
    Gpio8Ptr port() const
    { return mPort; }
 
    Gpio8Ptr pin() const
    { return mPin; }
 
    Gpio16Ptr ocr() const
    { return mOcr; }
 
    Gpio8Ptr tccr() const
    { return mTccr; }
 
    uint8_t bitNbr() const
    { return mNbr; }
 
    uint8_t com() const
    { return mCom; }
 
    uint8_t adcNbr() const
    { return mAdc; }
 
 
private:
 
    Gpio8Ptr        mDdr;
    Gpio8Ptr        mPort;
    Gpio8Ptr        mPin;
    Gpio16Ptr       mOcr;
    Gpio8Ptr        mTccr;
    uint8_t         mCom;
    uint8_t         mNbr;
    uint8_t         mAdc;
};
 
 
 
 
 
#define _makeGpioVarFromGpioPin( ddr, port, pin, nbr, adc, ocr, com, tccr )         \
                                                    GpioPinVariable( &(ddr), &(port), &(pin), nbr )
 
#define _makeGpioVarFromGpioPinAnalog( ddr, port, pin, nbr, adc, ocr, com, tccr )   \
                                                    GpioPinVariable( &(ddr), &(port), &(pin), nbr, adc )
 
#define _makeGpioVarFromGpioPinPwm( ddr, port, pin, nbr, adc, ocr, com, tccr )      \
                                                    GpioPinVariable( &(ddr), &(port), &(pin), nbr, &(ocr), &(tccr), com )
 
 
 
#define makeGpioVarFromGpioPin( pinName )               _makeGpioVarFromGpioPin( pinName )
 
 
#define makeGpioVarFromGpioPinAnalog( pinName )         _makeGpioVarFromGpioPinAnalog( pinName )
 
 
#define makeGpioVarFromGpioPinPwm( pinName )            _makeGpioVarFromGpioPinPwm( pinName )
 
 
 
 
 
inline bool isGpioPinModeOutputV( const GpioPinVariable& pinVar )
{
    return *(pinVar.ddr()) & ( 1 << pinVar.bitNbr() );
}
 
 
inline bool isGpioPinModeInputV( const GpioPinVariable& pinVar )
{
    return  !( *(pinVar.ddr()) & ( 1 << pinVar.bitNbr() ) );
}
 
 
 
 
 
inline void setGpioPinModeOutputV( const GpioPinVariable& pinVar )
{
    *(pinVar.ddr()) |= (1 << pinVar.bitNbr() );
}
 
 
 
 
inline void setGpioPinModeInputV( const GpioPinVariable& pinVar )
{
    *(pinVar.ddr()) &= ~( 1 << pinVar.bitNbr() );
    *(pinVar.port()) &= ~( 1 << pinVar.bitNbr() );
}
 
 
 
inline void setGpioPinModeInputPullupV( const GpioPinVariable& pinVar )
{
    *(pinVar.ddr()) &= ~( 1 << pinVar.bitNbr() );
    *(pinVar.port()) |= ( 1 << pinVar.bitNbr() );
}
 
 
 
inline bool readGpioPinDigitalV( const GpioPinVariable& pinVar )
{
    return *(pinVar.pin()) & ( 1 << pinVar.bitNbr() );
}
 
 
 
 
inline void writeGpioPinDigitalV( const GpioPinVariable& pinVar, bool value )
{
    if  ( value )
    {
        *(pinVar.port()) |= ( 1 << pinVar.bitNbr() );
    }
    else
    {
        *(pinVar.port()) &= ~( 1 << pinVar.bitNbr() );
    }
}
 
 
 
inline void setGpioPinHighV( const GpioPinVariable& pinVar )
{
    *(pinVar.port()) |= ( 1 << pinVar.bitNbr() );
}
 
 
 
 
inline void setGpioPinLowV( const GpioPinVariable& pinVar )
{
    *(pinVar.port()) &= ~( 1 << pinVar.bitNbr() );
}
 
 
 
#endif