CBitio.h

#pragma once

#include "CBaseio.h"

/*
READ_ONLY (or READ_ONLY_AL)
        CBitRO();                               // Constructor - config bit for input                   
        initPullup();                   // Turn on weak pull up
        unsigned char read();   // Return input bit value
WRITE_ONLY
        init()
        on()
        off()
        toggle()
        hiZ()
READ_WRITE (or READ_WRITE_AL)
        - initOut()
        - initIn()
        - initPullup()
        - on()
        - off()
        - toggle()
        - hiZ()
        - read()
*/

/*
        There are 7 possible bit operations per I/O bit:
        1) Clear DDxn
        2) Set   DDxn
        3) Read  DDxn
        4) Clear PORTxn
        5) Set   PORTxn
        6) Read  PORTxn
        7) Read  PINxn
        
        Operations that can be affected by "active low" logic are 4, 5, 6, and 7.
        (4, 5, and 7 affect the outside world.  6 is internal, but must adhere to
        convention.)
*/

//---------------------------------------------------------------------------
/*
        Use: READ_ONLY_IO(funcName, THE_PORT, THE_BIT)
        Parameters:
                funcName: The name of the READ ONLY object to be declared
                THE_PORT: Port letter for the AVR port B, C, D...
                THE_BIT:  Bit number for the AVR port 0, 1, 2... 7.
        Example: To create a switch input on I/O bit PD5
                READ_ONLY_IO(switchInput, D, 5)
                calls BUILD_CLASS(RO, switchInput, D, 5)
                        calls DECLARE_BASE_IO_CLASS(switchInput, D, 5)
                                calls BASE_IO(PORTD, DDRD, PIND, PD5, BASE_IO_D5)
                                [Creates base class called BASE_IO_D5]
                        calls DECLARE_IO_CLASS(RO_IO, switchInput, D, 5)
                                calls RO_IO(switchInput, RO_D5, BASE_IO_D5)
                                [Creates class RO_D5 : BASE_IO_D5
                                        amd declares class RO_IO_D5 switchInput]
        Creates:
                1) Unique base class BASE_IO_D5
                2) Unique io class RO_IO_D5 : public BASE_IO_D5
                3) Instance of class RO_IO_D5 switchInput
        Note that the base class includes all possible I/O operations. However,
        all of the functions are protected, meaning that they don't beome
        public until a new class is declared that defines the public interface
        to the I/O operations.  This is the process that defines the personality
        of the I/O bit - read-only, write-only, etc.
*/
//---------------------------------------------------------------------------

//---------------------------------------------------------------------------
//---------------------------------------------------------------------------

#define CBit(port, bit, type)                   \
        DECLARE_BASE_IO_CLASS(port, bit);       \
        CBit ## type<BASE_IO_ ## port ## bit>

//---------------------------------------------------------------------------





//---------------------------------------------------------------------------
template <class BASE_CLASS>
class CBitRO : BASE_CLASS
{
public:
        CBitRO()                                                                
                { BASE_CLASS::initIn();                 }
        void initPullup(void)                                   //*! Initializes input with pullup
                { BASE_CLASS::initPullup();             }
        unsigned char read(void)                                
                { return BASE_CLASS::read();    }
};

//---------------------------------------------------------------------------




//---------------------------------------------------------------------------
template <class BASE_CLASS>
class CBitRO_PU : BASE_CLASS
{
public:
        CBitRO_PU()                                                             
                { BASE_CLASS::initPullup();     }
        unsigned char read(void)                                
                { return BASE_CLASS::read();    }
};

//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
template <class BASE_CLASS>
class CBitRO_AL : BASE_CLASS
{
public:
        CBitRO_AL()                                                             // Constructor                                  
                { initPullup();                                 }
        void initPullup(void)
                { BASE_CLASS::initPullup();             }
        unsigned char read(void)                                // Return "active low" read
                { return BASE_CLASS::read_al(); }
        void hiZ(void)
                { BASE_CLASS::hiZ();                    }
};

//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
template <class BASE_CLASS>
class CBitWO : BASE_CLASS
{
public:
        CBitWO()                                                                // Constructor
                { BASE_CLASS::initOut();                }       // Set pin direction to output
        void init(void)                                                 // init()
                { BASE_CLASS::initOut();                }
        void on(void)                                                   // Set output high
                { BASE_CLASS::on();                             }
        void off(void)                                                  // Set output low
                { BASE_CLASS::off();                    }
        void hiZ(void)                                                  // Set pin to high Z
                { BASE_CLASS::hiZ();                    }
        void toggle(void)                                               // Toggle the output
// ATmega48,88,168  or  ATmega32u4
#if defined(_AVR_IOMX8_H_) || defined(_AVR_IOXXX_H_)
                { BASE_CLASS::toggleMX();               }
#else
                { BASE_CLASS::toggle();                 }
#endif
        unsigned char toggle(char x)                    // Toggle and return value
                { return BASE_CLASS::toggle(0); }
        // Sometimes one needs to read the state of an output, i.e. OC1
        unsigned char read(void)                                // Read state of output pin
                { return BASE_CLASS::read();    }
};

//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
template <class BASE_CLASS>
class CBitWO_AL : BASE_CLASS
{
public:
        CBitWO_AL()                                                             // Constructor
                { BASE_CLASS::initOut_al();             }       // Output with data high
        void init(void)                                                 // Output with data low
                { BASE_CLASS::initOut();                }
        void on(void)                                                   // Data active (low)
                { BASE_CLASS::on_al();                  }
        void off(void)                                                  // Data inactive (high)
                { BASE_CLASS::off_al();                 }
        void hiZ(void)                                                  // Input, pullup off
                { BASE_CLASS::hiZ();                    }
        void toggle(void)                                               // Toggle
                { BASE_CLASS::toggle();                 }
        unsigned char toggle(char x)                    // Toggle and return active low val
                { return BASE_CLASS::toggle_al(0); }
};

//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
template <class BASE_CLASS>
class CBitWO_AL_OC : BASE_CLASS
{
public:
        CBitWO_AL_OC()                                                  // Constructor
                { BASE_CLASS::initPullup();             }       // Init to input w/pullup
        void on(void)
                { BASE_CLASS::initOut();                }       // Set to output, data low
        void off(void)
                { BASE_CLASS::initPullup();             }       // Off is input w/pullup
};

//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
template <class BASE_CLASS>
class CBitWO_NC : BASE_CLASS
{
public:
        void init(void)                                                 // Output with data low
                { BASE_CLASS::initOut();                }
        void on(void)
                { BASE_CLASS::on();                             }       // Set output high
        void off(void)
                { BASE_CLASS::off();                    }       // Set output low
        void toggle(void)                                               // Toggle the output
// ATmega48,88,168  or  ATmega32u4
#if defined(_AVR_IOMX8_H_) || defined(_AVR_IOXXX_H_)
                { BASE_CLASS::toggleMX();               }
#else
                { BASE_CLASS::toggle();                 }
#endif
        unsigned char read(void)                                // Read state of output pin
                { return BASE_CLASS::read();    }
};

//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
template <class BASE_CLASS>
class CBitWO_AL_NC : BASE_CLASS
{
public:
        void init(void)                                                 // Output with data low
                { BASE_CLASS::initOut_al();             }       // Output with data high
        void on(void)
                { BASE_CLASS::on_al();                  }       // Set output low
        void off(void)
                { BASE_CLASS::off_al();                 }       // Set output high
        void toggle(void)                                               // Toggle the output
// ATmega48,88,168  or  ATmega32u4
#if defined(_AVR_IOMX8_H_) || defined(_AVR_IOXXX_H_)
                { BASE_CLASS::toggleMX();               }
#else
                { BASE_CLASS::toggle();                 }
#endif
        unsigned char read(void)                                // Read state of output pin
                { return BASE_CLASS::read_al(); }
};

//---------------------------------------------------------------------------
//---------------------------------------------------------------------------