ports.h

Go to the documentation of this file.

//***************************************************************************
//
// file : bmptk/hardware/ports.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 {

// ==========================================================================
//
// port interface classes
//
// ==========================================================================

//
struct port_in {

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

   //
   static void init();
   
   static int n_pins();
   
   //
   static unsigned int get();
};

//
struct port_out {

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

   //
   static void init();
   
   static int n_pins();
   
   //
   static void set( unsigned int d );
};

//
struct port_in_out {

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

   //
   static void init();
   
   static int n_pins();
   
   //
   static void direction_set_input();
   
   //
   static void direction_set_output();
   
   static void set( unsigned int d );
   
   static unsigned int get();
};

//
struct port_oc {

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

   static void init();
   
   static int n_pins();
     
   static void set( unsigned int d );
   
   static unsigned int get();
};


// ==========================================================================
//
// combine pins into a port_out
//
// ==========================================================================

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

#ifndef DOXYDOC

template<> class port_out_from_pins<> : public port_out {
public: 
   static void init(){}
   static void set( unsigned int x ){}
   static int n_pins(){ return 0; }
};

template< typename arg_pin, typename... tail_args > 
struct port_out_from_pins< arg_pin, tail_args... > : public port_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 ),
           "port_out_from_pins requires pin_out, pin_in_out or a pin_oc"
   );

   typedef port_out_from_pins< tail_args... > tail;
   typedef pin_out_from< arg_pin > pin;
   
   static void init(){ 
      pin::init();
      tail::init(); 
   }
   
   static void set( unsigned int x ){
      pin::set( x & 0x01 );
      tail::set( x >> 1 );
   }
   
   static int n_pins(){ 
      return tail::n_pins() + 1;
   }
};

#endif


//
template< typename... > class port_in_from_pins : public port_in {};

#ifndef DOXYDOC

template<> class port_in_from_pins<> : public port_in {
public: 
   static void init(){}
   static unsigned int get(){ return 0; }
   static int n_pins(){ return 0; }
};

template< typename arg_pin, typename... tail_args > 
class port_in_from_pins< arg_pin, tail_args... > : public port_in {
public:

   typedef port_in_from_pins< tail_args... > tail;
   typedef pin_in_from< arg_pin > pin;
   
   static void init(){ 
      pin::init();
      tail::init(); 
   }
   
   static unsigned int get(){
      return 
             ( tail::get() << 1 )
                 | pin::get() ? 0x01 : 0x00;
   }
   
   static int n_pins(){ 
      return tail::n_pins() + 1;
   }
};

#endif


//
template< typename... > class port_in_out_from_pins : public port_in_out {};

#ifndef DOXYDOC

template<> class port_in_out_from_pins<> : public port_in_out {
public: 
   static void init(){}
   static unsigned int get(){ return 0; }
   static void set( unsigned int x ){}
   static int n_pins(){ return 0; }
   static void direction_set_input() {}
   static void direction_set_output() {}
};

template< typename arg_pin, typename... tail_args > 
class port_in_out_from_pins< arg_pin, tail_args... > : public port_in_out {
public:

   typedef port_in_out_from_pins< tail_args... > tail;
   typedef pin_in_out_from< arg_pin > pin;
   
   static void init(){ 
      pin::init();
      tail::init(); 
   }
   
   static void set( unsigned int x ){
      pin::set( x & 0x01 );
      tail::set( x >> 1 );
   }
   
   static unsigned int get(){
      return 
             ( tail::get() << 1 )
                 | pin::get() ? 0x01 : 0x00;
   }
   
   static void direction_set_input() {
      pin::direction_set_input();
           tail::direction_set_input();
   }
   
   static void direction_set_output() {
      pin::direction_set_output();
           tail::direction_set_output();
   }
   
   static int n_pins(){ 
      return tail::n_pins() + 1;
   }
};

#endif


//
template< typename... > class port_oc_from_pins : public port_oc {};

#ifndef DOXYDOC

template<> class port_oc_from_pins<> : public port_oc {
public: 
   static void init(){}
   static unsigned int get(){ return 0; }
   static void set( unsigned int x ){}
   static int n_pins(){ return 0; }
};

template< typename arg_pin, typename... tail_args > 
class port_oc_from_pins< arg_pin, tail_args... > : public port_oc {
public:

   typedef port_oc_from_pins< tail_args... > tail;
   typedef pin_oc_from< arg_pin > pin;
   
   static void init(){ 
      pin::init();
      tail::init(); 
   }
   
   static void set( unsigned int x ){
      pin::set( x & 0x01 );
      tail::set( x >> 1 );
   }
   
   static unsigned int get(){
      return 
             ( tail::get() << 1 )
                 | pin::get() ? 0x01 : 0x00;
   }
      
   static int n_pins(){ 
      return tail::n_pins() + 1;
   }
};

#endif

template< typename port >
class port_out_from : public port {};

// ==========================================================================
//
// 8-bit buffered ports
//
// ==========================================================================

class port_buffered_out_channel {

   static void init();
   
   static void set( unsigned int x );
};

//
template< typename channel >
class port_buffer_out : public port_out {

   static unsigned int port_out_buffer;
     
   static void port_out_flush(){
      channel::set( port_out_buffer );   
   }

   template< int p >
   class single_pin : public bmptk::hardware::pin_out {
   public:   
   
      static void init(){
         channel::init();   
           }
          
      static void set( bool x ){
             if( x ){
           port_out_buffer |= ( 0x01 << p );
        } else {
                     port_out_buffer &= ~ ( 0x01 << p );
        }                
                  port_out_flush();
          }
   };
   
public:   

   static void init(){
      channel::init();
   }

   static void set( unsigned int x ){
      port_out_buffer = x;
      port_out_flush();
   }
      
   static int n_pins(){ 
      return 8; 
   }
   
   typedef single_pin< 0 > pin_0;

   typedef single_pin< 1 > pin_1;

   typedef single_pin< 2 > pin_2;

   typedef single_pin< 3 > pin_3;

   typedef single_pin< 4 > pin_4;

   typedef single_pin< 5 > pin_5;

   typedef single_pin< 6 > pin_6;

   typedef single_pin< 7 > pin_7;
};

template < typename channel > 
unsigned int port_buffer_out< channel >::port_out_buffer;

class port_buffered_oc_channel {

   static void init();
   
   static void set( unsigned int x );
   
   static unsigned int get();
};

//
template< typename channel >
class port_buffer_oc : public port_oc {

   static unsigned int port_in_buffer;
   static unsigned int port_out_buffer;
     
   static void port_out_flush(){
      channel::set( port_out_buffer );  
   }

   static void port_in_refresh(){
      port_in_buffer = channel::get();   
   }

   template< int p >
   class single_pin : public bmptk::hardware::pin_oc {
   public:   
   
      static void init(){
         channel::init();   
           }
          
      static void set( bool x ){
             if( x ){
           port_out_buffer |= ( 0x01 << p );
        } else {
                     port_out_buffer &= ~ ( 0x01 << p );
        }                
                  port_out_flush();
          }
 
     static bool get(){
        port_in_refresh();
             return port_in_buffer &( 0x01 << p );
          } 
   };
   
public:   

   static void init(){
      channel::init();
   }

   static void set( unsigned int x ){
      port_out_buffer = x;
      port_out_flush();
   }
      
   static int n_pins(){ 
      return 8; 
   }
   
   static unsigned int get(){ 
      port_in_refresh();
      return port_in_buffer;
   }
   
   typedef single_pin< 0 > pin_0;

   typedef single_pin< 1 > pin_1;

   typedef single_pin< 2 > pin_2;

   typedef single_pin< 3 > pin_3;

   typedef single_pin< 4 > pin_4;

   typedef single_pin< 5 > pin_5;

   typedef single_pin< 6 > pin_6;

   typedef single_pin< 7 > pin_7;
};

template < typename channel > 
unsigned int port_buffer_oc< channel >::port_out_buffer;
template < typename channel > 
unsigned int port_buffer_oc< channel >::port_in_buffer;

class port_buffered_in_channel {

   static void init();
   
   static unsigned int get();
};

//
template< typename channel >
class port_buffer_in : public port_in {

   static unsigned int port_in_buffer;
     
   static void port_in_refresh(){
      port_in_buffer = channel::get();   
   }

   template< int p >
   class single_pin : public bmptk::hardware::pin_in {
   public:   
   
      static void init(){
         channel::init();   
           }
 
      static bool get(){
         port_in_refresh();
              return port_in_buffer &( 0x01 << p );
           } 
   };
   
public:   

   static void init(){
      channel::init();
   }
     
   static int n_pins(){ 
      return 8; 
   }
   
   static unsigned int get(){ 
      port_in_refresh();
      return port_in_buffer;
   }
   
   typedef single_pin< 0 > pin_0;

   typedef single_pin< 1 > pin_1;

   typedef single_pin< 2 > pin_2;

   typedef single_pin< 3 > pin_3;

   typedef single_pin< 4 > pin_4;

   typedef single_pin< 5 > pin_5;

   typedef single_pin< 6 > pin_6;

   typedef single_pin< 7 > pin_7;
};

template < typename channel > 
unsigned int port_buffer_in< channel >::port_in_buffer;

class port_buffered_in_out_channel {

   static void init();
   
   static void set( unsigned int x );
   
   static unsigned int get();
   
   //
   static unsigned direction( unsigned int x );
};

//
template< typename channel >
class port_buffer_in_out : public port_in_out {

   static unsigned int port_in_buffer;
   static unsigned int port_out_buffer;
   static unsigned int port_direction_buffer;
     
   static void port_out_flush(){
      channel::set( port_out_buffer );  
   }

   static void port_in_refresh(){
      port_in_buffer = channel::get();   
   }

   static void port_direction_flush(){
      channel::direction( port_direction_buffer );    
   }

   template< int p >
   class single_pin : public bmptk::hardware::pin_in_out {
   public:   
   
      static void init(){
         channel::init();
           }
          
      static void set( bool x ){
             if( x ){
           port_out_buffer |= ( 0x01 << p );
        } else {
                     port_out_buffer &= ~ ( 0x01 << p );
        }                
                  port_out_flush();
          }
 
     static bool get(){
        port_in_refresh();
             return port_in_buffer &( 0x01 << p );
          } 
     
      static void direction_set_input(){
         port_direction_buffer &= ( 0x01 << p ) ^ -1;
         port_direction_flush();
      }      
   
      static void direction_set_output(){
         port_direction_buffer |= ( 0x01 << p );
         port_direction_flush();
      }   
   };
   
public:   

   static void init(){
      channel::init();
   }

   static void set( unsigned int x ){
      port_out_buffer = x;
      port_out_flush();
   }
      
   static int n_pins(){ 
      return 8; 
   }
   
   static unsigned int get(){ 
      port_in_refresh();
      return port_in_buffer;
   }
   
   static void direction_set_input(){
      port_direction_buffer = 0;
      port_direction_flush();
   }      
   
   static void direction_set_output(){
      port_direction_buffer = 0 ^ -1;
      port_direction_flush();
   }      
   
   typedef single_pin< 0 > pin_0;

   typedef single_pin< 1 > pin_1;

   typedef single_pin< 2 > pin_2;

   typedef single_pin< 3 > pin_3;

   typedef single_pin< 4 > pin_4;

   typedef single_pin< 5 > pin_5;

   typedef single_pin< 6 > pin_6;

   typedef single_pin< 7 > pin_7;
};

template < typename channel > 
unsigned int port_buffer_in_out< channel >::port_out_buffer;
template < typename channel > 
unsigned int port_buffer_in_out< channel >::port_in_buffer;
template < typename channel > 
unsigned int port_buffer_in_out< channel >::port_direction_buffer = 0;


// ==========================================================================
//
// invert a port
//
// ==========================================================================

#ifndef DOXYDOC

template< class port >
struct invert< port, type_port_out > : public port {
   static void set( unsigned int x ){ port::set( x ^ -1 ); }
};

template< class port >
struct invert< port, type_port_in > : public port {
   static unsigned int get(){ return port::get() ^ -1; }
};

template< class port >
struct invert< port, type_port_in_out > : public port {
   static void set( unsigned int x ){ port::set( x ^ -1 ); }
   static unsigned int get(){ return port::get() ^ -1; }
};
template< class port >

struct invert< port, type_port_oc > : public port {
   static void set( unsigned int x ){ port::set( x ^ -1 ); }
   static unsigned int get(){ return port::get() ^ -1; }
};

#endif

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