pins.h

Go to the documentation of this file.

//***************************************************************************
//
// file : bmptk/hardware/pins.h
//
// LICENSE (MIT expat license, copy of bmptk/license.txt)
//
// Copyright (c) 2013 Wouter van Ooijen (wouter@voti.nl)
// 
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
// 
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
// 
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
// CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
// TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
// SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE..
//
//***************************************************************************

// document everything in this file
namespace bmptk {
namespace hardware {

// ==========================================================================
//
// pin interface classes
//
// ==========================================================================

//
struct pin_in {

   enum { type = type_pin_in };
   
   enum { features = has_none };

   //
   static void init();
   
   //
   static bool get();
};

//
struct pin_out {

   enum { type = type_pin_out };
   
   enum { features = has_none };

   //
   static void init();
   
   //
   static void set( bool x );
};

//
struct pin_in_out {

   enum { type = type_pin_in_out };
   
   enum { features = has_none };
   
   //
   static void init();
   
   //
   static void direction_set_input();
   
   //
   static void direction_set_output();
     
   static bool get();
   
   static void set( bool x );
};

//
struct pin_oc {

   enum { type = type_pin_oc };
   
   enum { features = has_none };

   //
   static void init();
   
   static void set( bool x ); 
   
   static bool get();
};


//
class pin_configurable_pullup {
public:

   enum { features = has_pullup };

   static void pullup_enable();
   
   static void pullup_disable();
};

//
class pin_ad {
   
   enum { features = has_ad };

   //
   static void ad_init();
   
   //
   static unsigned int ad_get();
   
   static unsigned int ad_bits();
   
   static unsigned int ad_max();
};


// ==========================================================================
//
// create a pin from another pin
//
// ==========================================================================

#ifdef DOXYDOC

   //
   template< typename pin > struct pin_in_out_from : public pin_in_out {};

#else

template< typename pin, int flavour = pin::type >
struct pin_in_out_from {
   static_assert( 
      ( flavour == bmptk::type_pin_in_out )
      | ( flavour == bmptk::type_pin_oc ),
           "pin_in_out_from requires a pin_in_out or a pin_oc"
   );          
};

template< typename pin >
struct pin_in_out_from< pin, type_pin_in_out > : public pin {};

template< typename pin >
struct pin_in_out_from< pin, type_pin_oc > : public pin {

   static void direction_set_input(){
      // setting an open-collector pin high will
          // make it float
      pin::set( 1 );
   }
   
   static void direction_set_output(){
      // no need to do anything, setting the pin high
          // or low will do the real work
   }
        
};

#endif

#ifdef DOXYDOC

   //
   template< typename pin > struct pin_oc_from : public pin_oc {};
   
#else

template< typename pin, int flavour = pin::type >
struct pin_oc_from {
   static_assert( 
      ( flavour == bmptk::type_pin_oc )
      | ( flavour == bmptk::type_pin_in_out ),
           "pin_oc_from requires a pin_oc or a pin_in_out"
   );          
};

template< typename pin >
class pin_oc_from< pin, type_pin_oc > : public pin {};

template< typename pin >
struct pin_oc_from< pin, type_pin_in_out > : public pin_oc {

   // don't inherit from the pin, because that would inherit 
   // direction_set_input and direction_set_output

   static void set( bool x ){
      // to make a pin_in_out behave like a pin_oc
      if( x ){
          
             // make it float when it is set high
             pin::direction_set_input();
                 
      } else {
          
             // make it output and low when it is set low
         pin::direction_set_output();
         pin::set( 0 );
      }          
   }      
   
   static bool get(){
      return pin::get();
   }      
   
};


#endif

#ifdef DOXYDOC

   //
   template< typename pin > struct pin_out_from : public pin_out {};

#else

template< typename pin, int flavour = pin::type >
struct pin_out_from {
   static_assert( 
      ( flavour == bmptk::type_pin_out )
      | ( flavour == bmptk::type_pin_in_out )
      | ( flavour == bmptk::type_pin_oc ),
           "pin_out_from requires a pin_out, pin_in_out or a pin_oc"
   );          
};

template< class pin >
struct pin_out_from< pin, type_pin_out > : public pin {};

template< class pin >
struct pin_out_from< pin, type_pin_in_out > : public pin_out {

   // don't inherit from the pin, because that would inherit 
   // get() and direction_set_input and direction_set_output

   static void init(){
      pin::init();
          pin::direction_set_output();
   }
    
   static void set( bool x ){
      pin::set( x );
   }
};

template< class pin >
struct pin_out_from< pin, type_pin_oc > : public pin_out {

   // don't inherit from the pin, because that would inherit get()

   static void init(){
      pin::init();
   }      
   
   static void set( bool x ){
      pin::set( x );
   }
};

#endif
        
        
#ifdef DOXYDOC

   //
   template< typename pin > struct pin_in_from : public pin_in {};

#else

template< typename pin, int flavour = pin::type >
struct pin_in_from {
   static_assert( 
      ( flavour == bmptk::type_pin_in )
      | ( flavour == bmptk::type_pin_in_out )
      | ( flavour == bmptk::type_pin_oc ),
           "pin_in_from requires a pin_out, pin_in_out or a pin_oc"
   );          
};

template< class pin >
struct pin_out_from< pin, type_pin_in > : public pin {};

template< class pin >
struct pin_in_from< pin, type_pin_in_out > : public pin_in {

   // don't inherit from the pin, because that would inherit 
   // get() and direction_set_input and direction_set_output

   static void init(){
      pin::init();
          pin::direction_set_input();
   }
      
   static bool get(){
      return pin::get();          
   }   
};
        
template< class pin >
struct pin_in_from< pin, type_pin_oc > : public pin_in {

   // don't inherit from the pin, because that would inherit set()

   static void init(){
      pin::init();
          pin::set( 1 );
   }
      
   static bool get(){
      return pin::get();          
   }   
};

#endif


// ==========================================================================
//
// invert a pin (or port, in ports.h)
//
// ==========================================================================

#ifdef DOXYDOC

   //
   template< typename pin_or_port > class invert : public pin_or_port {};

#else

template< class t, int flavour = t::type >
struct invert {
   static_assert( 
      // dummy condition
      flavour == bmptk::type_pin_in,
           "invert requires a pin or port"
   );   
};
        
template< class pin >
struct invert< pin, type_pin_in > : public pin {

   static bool get(){
      return ! pin::get();        
   }  
};      

template< class pin >
struct invert< pin, type_pin_out > : public pin {

   static void set( bool x ){
      pin::set( ! x );    
   }   
};      

template< class pin >
struct invert< pin, type_pin_in_out > : public pin {

   static void set( bool x ){
      pin::set( ! x );    
   }  

   static bool get(){
      return ! pin::get();        
   }  
};      

template< class pin >
struct invert< pin, type_pin_oc > : public pin {
 
   static void set( bool x ){
      pin::set( ! x );    
   }   

   static bool get(){
      return ! pin::get();        
   } 
};      

#endif

// ==========================================================================
//
// flipable
//
// ==========================================================================

template< class pin, int flavour = pin::type >
struct flipable : public pin {
private:

   static_assert( 
      ( flavour == bmptk::type_pin_out )
      | ( flavour == bmptk::type_pin_in_out )
      | ( flavour == bmptk::type_pin_oc ),
           "flipable requires a pin_out, pin_in_out or a pin_oc"
   );

   static bool value;
   
public:   

   static void set( bool x ){
      value = x;
          pin::set( x );
   }

   //
   static void flip(){
      value = ! value;
      pin::set( value );
   }
};

template< class pin, int flavour > bool flipable< pin, flavour >::value;


// ==========================================================================
//
// detect a rising_edge
//
// ==========================================================================

template< class arg_pin, int flavour = arg_pin::type >
struct rising_edge : public pin_in {
private:

   static_assert( 
      ( flavour == bmptk::type_pin_in )
      | ( flavour == bmptk::type_pin_in_out )
      | ( flavour == bmptk::type_pin_oc ),
           "flipable requires a pin_in, pin_in_out or a pin_oc"
   );

   typedef pin_in_from< arg_pin > pin;
   
   static bool last;
   
public:   

   static void init(){
      pin::init();
   }      
   
   //
   static bool get(){
          if( last ){
             if( ! pin::get() ){
                    last = false;
         }               
      } else {  
             if( pin::get() ){
                    last = true;
                        return true;
                 }
          }
      return false;
   }   
};

template< class pin, int flavour > bool rising_edge< pin, flavour >::last = 0;


// ==========================================================================
//
// debounce
//
// ==========================================================================

//
template< class arg_pin >
struct debounce : public pin_in {
private:

   static_assert( 
      ( (int)arg_pin::type == bmptk::type_pin_in )
      | ( (int)arg_pin::type == bmptk::type_pin_in_out )
      | ( (int)arg_pin::type == bmptk::type_pin_oc ),
           "flipable requires a pin_in, pin_in_out or a pin_oc"
   );

   typedef pin_in_from< arg_pin > pin;
   
public:   

   static void init(){
      pin::init();
   }      
   
   //
   static bool get( bmptk::time interval = 50 * bmptk::ms ){
      static bool last_value;
      static bmptk::time last_time = -1 * bmptk::s;
      bmptk::time now = bmptk::current_time();
           if( now >= last_time + interval ){
              last_value = pin::get();
         last_time = now;
      }         
      return last_value;
   }   
};


// ==========================================================================
//
// combine pins tee-wise: write to the master to write to them all
//
// ==========================================================================

#ifdef DOXYDOC

   //
   template< typename... > class tee : public pin_out {};
   template< typename port_out > class tee : public pin_out {};

#else

template< typename... > class tee;

template<>
class tee<> : public pin_out {
public:
   static void init(){}
   static void set( bool b ){}   
};

template< typename arg_pin, typename... tail_args >
struct tee< arg_pin, tail_args... > : public pin_out {

   static_assert( 
      ( (int)arg_pin::type == bmptk::type_pin_out )
      | ( (int)arg_pin::type == bmptk::type_pin_in_out )
      | ( (int)arg_pin::type  == bmptk::type_pin_oc ),
           "flipable requires a pin_out, pin_in_out or a pin_oc"
   );
   
   typedef pin_out_from< arg_pin > pin;

   typedef tee< tail_args... > tail;

   static void init(){
      pin::init();
      tail::init();
   }
   
   static void set( bool b ){
      pin::set( b );
      tail::set( b );   
   }   
};

//
struct pin_in_out_dummy : pin_in_out {
   static void init(){}
   static void direction_set_input(){}
   static void direction_set_output(){}
   static bool get(){ return 0; }
   static void set( bool x ){}
};


/*
// ==========================================================================
//
// combine two pins with a logic function
//
// ==========================================================================

template < typename a, typename b > struct logic_xor : public pin_out {
   static void init(){ a::init(); b::init(); }    
   static bool get(){ return a::get() ^ b::get(); }
};   

*/


/*
template < 
   typename port
> class tee < 
   port,
   std::enable_if< std::is_base_of< port_out, port >::value, int >
> : public pin_out {
public:

   static_assert(
      std::is_base_of< port_out, port>::value, 
      "port must be a descendant of port_out"
   );

   static void init(){
      port::init();
   }
   
   static void set( bool b ){
      port::set( b ? -1 : 0 );
   }
   
};
*/



#endif


        
}; // namespace hardware          
}; // namespace bmptk;