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