i2c.h

Go to the documentation of this file.

//***************************************************************************
//
// file : bmptk/hardware/i2c.h
//
// LICENSE (MIT expat license, copy of 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 {
        
class i2c_interface {  
public:

   enum { type = type_i2c_bus };

   static void init();   

   static void put_start();
   
   static void put_stop();
     
   //
   static bool get_ack();
   
   static void put_ack();
   
   static void put_nack();
   
   static void put_byte( unsigned char x );
   
   static unsigned char get_byte();
   
   //
   static void write( unsigned char address, unsigned const char *data, int n ){
      put_start();
      put_byte( address << 1 );
      for( int i = 0; i < n; i++ ){
         get_ack();
         put_byte( data[ i ] );
      }               
      get_ack();
      put_stop();
   }           
   
   //
   static void read( unsigned char address, unsigned char *data, int n ){
      put_start();
      put_byte( ( address << 1 ) | 0x01 );    
      for( int i = 0; i < n; i++ ){
         get_ack();
         data[ i ] = get_byte();
      }               
      put_stop();
   }           
   
};
                   
//
template< 
   class extern_scl, 
   class extern_sda,
   unsigned int frequency = 1 * bmptk::MHz 
>         
class i2c_master : public i2c_interface {
private: 

   static_assert( 
      ( (int)extern_scl::type == bmptk::type_pin_out )
      | ( (int)extern_scl::type == bmptk::type_pin_in_out )
      | ( (int)extern_scl::type == bmptk::type_pin_oc ),
           "scl must be a pin_out, pin_in_out or a pin_oc"
   );
   static_assert( 
      ( (int)extern_sda::type == bmptk::type_pin_out )
      | ( (int)extern_sda::type == bmptk::type_pin_in_out )
      | ( (int)extern_sda::type == bmptk::type_pin_oc ),
           "sda must be a pin_out, pin_in_out or a pin_oc"
   );
   
   typedef bmptk::hardware::pin_oc_from< extern_scl > scl;
   typedef bmptk::hardware::pin_oc_from< extern_sda > sda;
        
   static void delay_half_period(){
      static bmptk::time epoch = 0 * bmptk::us;
      epoch += bmptk::s / ( 2 * frequency );
      bmptk::wait_until( epoch );
      epoch = bmptk::current_time();
   }    
   
   static void put_bit( bool x ){
      scl::set( 0 );
      delay_half_period();
      sda::set( x );
      scl::set( 1 );
      delay_half_period();
   }
   
   static bool get_bit(){
      scl::set( 0 );
      delay_half_period();  
      sda::set( 1 );
      scl::set( 1 );
      delay_half_period();
      bool result = sda::get();
      delay_half_period();     
      return result;
   }    
   
public:

   static void init(){
      scl::init();
      sda::init();
      scl::set( 1 );            
      sda::set( 1 );
   }      

   static void put_start(){
      sda::set( 0 );
      delay_half_period();  
      scl::set( 0 );
      delay_half_period();  
   }

   static void put_stop(){
      scl::set( 0 );
      delay_half_period();    
      sda::set( 0 );
      delay_half_period();    
      scl::set( 1 );
      delay_half_period();    
      sda::set( 1 );
      delay_half_period();    
   }
      
   static bool get_ack(){
      bool ack = ! get_bit(); 
      return ack;
   } 
   
   static void put_ack(){
      put_bit( 0 );
   }

   static void put_nack(){
      put_bit( 1 );
   }
   
   static void put_byte( unsigned char x ){
      for( int i = 0; i < 8; i++ ){
         put_bit( ( x & 0x80 ) != 0 );
         x = x << 1;
      }         
   }
   
   static unsigned char get_byte(){
      unsigned char result = 0;
      for( int i = 0; i < 8; i++ ){
         result = result << 1;
         if( get_bit() ){
            result |= 0x01;
         } 
      }   
      return result;     
   }        
   
};     


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