spi.h

Go to the documentation of this file.

//***************************************************************************
//
// file : bmptk/hardware/spi.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 {
  
//
template< 
   class sclk_extern,
   class mosi_extern, 
   class miso_extern,
   unsigned int frequency = 1 * bmptk::MHz
> struct spi_bus_sclk_mosi_miso {

   enum { type = type_spi_bus };

   static_assert( 
      ( (int)sclk_extern::type == bmptk::type_port_out )
      | ( (int)sclk_extern::type == bmptk::type_pin_in_out )
      | ( (int)sclk_extern::type == bmptk::type_pin_oc ),
     "sclk must be a port_out, pin_in_out or a pin_oc"
   );
   static_assert( 
      ( (int)mosi_extern::type == bmptk::type_pin_out )
      | ( (int)mosi_extern::type == bmptk::type_pin_in_out )
      | ( (int)mosi_extern::type == bmptk::type_pin_oc ),
     "mosi must be a pin_out, pin_in_out or a pin_oc"
   );
   static_assert( 
      ( (int)miso_extern::type == bmptk::type_pin_in )
      | ( (int)miso_extern::type == bmptk::type_pin_in_out )
      | ( (int)miso_extern::type == bmptk::type_pin_oc ),
     "miso must be a pin_out, pin_in_out or a pin_oc"
   );
   
   typedef bmptk::hardware::pin_out_from< sclk_extern > sclk;
   
   typedef bmptk::hardware::pin_out_from< mosi_extern > mosi;
   
   typedef bmptk::hardware::pin_in_from< miso_extern > miso;
      
   static void wait(){
      static bmptk::time epoch = 0 * bmptk::us;
      epoch += bmptk::s / ( 2 * frequency );
      bmptk::wait_until( epoch );
      epoch = bmptk::current_time();
   }    
   
   static void init(){
      sclk::init();
      mosi::init();
      miso::init();
   }      
            
};     

enum spi_mode {

   //
   spi_mode_0 = 0, 
   
   //
   spi_mode_1 = 1, 

   //
   spi_mode_2 = 2, 

   //
   spi_mode_3 = 3
};


//
template< 
   typename bus,
   typename ss_extern,
   int mode = spi_mode_0
> class spi_channel {
private:

   static const bool cpha = ( mode & 0x01 ) != 0;
   static const bool cpol = ( mode & 0x02 ) != 0;
   
   static_assert( 
      ( (int)bus::type == bmptk::type_spi_bus ),
      "bus must be a spi bus"
   );
   
   static_assert( 
      ( (int)ss_extern::type == bmptk::type_pin_out )
      | ( (int)ss_extern::type == bmptk::type_pin_in_out )
      | ( (int)ss_extern::type == bmptk::type_pin_oc ),
     "ss must be a pin_out, pin_in_out or a pin_oc"
   );
   
   typedef bmptk::hardware::pin_out_from< ss_extern > ss;   
   
   static unsigned char byte_in_out(
      unsigned char out
   ){
      int in = 0;
      bus::wait();
      for( int i = 0; i < 8; i++ ){
        
         in = in << 1;
         
         if( cpha == 0 ){
     
            bus::mosi::set( out & 0x80 );
            bus::wait();
      
            bus::sclk::set( ! cpol );
            if( bus::miso::get() ){
               in |= 0x80;
            }
            
            bus::wait();
            bus::sclk::set( cpol );
      
         } else {

            bus::sclk::set( ! cpol );
            bus::wait();
       
            bus::mosi::set( out & 0x80 );
            bus::sclk::set( cpol );
            bus::wait();
      
            if( bus::miso::get() ){
               in |= 0x80;
            }      
         }
         out = out << 1;
      }   
      return in;
   }

public:

   enum { type = type_spi_channel };

   static void init(){
      bus::init();
      ss::init();   
   }
   
   //
   static void transaction_in_out_n( 
      unsigned char *input, 
      unsigned char *output, 
      int n_bytes 
   ){
      bus::sclk::set( cpol );
      ss::set( 0 );
        
      while( n_bytes-- ){
         unsigned char in, out = 0;
         if( output ){
            out = *output++;
         }      
         in = byte_in_out( out );
         if( input ){
           *input++ = in;
         }
      }      
      
      ss::set( 1 );
   }
   
   static void transaction_in_n( 
      unsigned char *input, 
      int n_bytes 
   ){
      transaction_in_out_n( input, 0, n_bytes );
   }
   
   static void transaction_out_n( 
      unsigned char *output, 
      int n_bytes 
   ){
      transaction_in_out_n( 0, output, n_bytes );
   }     
   
};

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