spi_bb.h

Go to the documentation of this file.

#ifndef __utl_com_spi_bb_h__
#define __utl_com_spi_bb_h__

#include <utl/core/impl.h>
#include <utl/core/crtp.h>
#include <utl/com/spi.h>
#include <utl/meta/meta.h>


namespace utl {


   template <typename impl_t,
             spi::cpol CPOL,
             spi::cpha CPHA,
             spi::bitOrder BitOrder =spi::bitOrder::MSB_First>
   class spi_bb_i : public spi_i<spi_bb_i<impl_t, CPOL, CPHA, BitOrder>> {
      _CRTP_IMPL(impl_t);  
      friend spi_i<spi_bb_i<impl_t, CPOL, CPHA, BitOrder>>;
   public:
      using type = spi_bb_i<impl_t, CPOL, CPHA, BitOrder>; 

   protected:
      ~spi_bb_i () = default; 
      spi_bb_i (uint32_t clk) noexcept
         : nsec_ {1000000000/(2*clk)} {
      }

   private:
      template <spi::bitOrder B =BitOrder> constexpr
      meta::enable_if_t <(B == spi::bitOrder::LSB_First), void> shift (byte_t& b) { b <<=1; }
      template <spi::bitOrder B =BitOrder> constexpr
      meta::enable_if_t <(B == spi::bitOrder::MSB_First), void> shift (byte_t& b) { b >>=1; }
      template <spi::cpol C =CPOL> static constexpr bool clkHigh () {
         return !static_cast<bool>(C);
      }
      template <spi::cpol C =CPOL> static constexpr bool clkLow () {
         return static_cast<bool>(C);
      }
      static constexpr bool clkH_ {clkHigh()};
      static constexpr bool clkL_ {clkLow()};

   private:
      void MOSI (bool st)  { impl().MOSI(st); }       
      bool MISO ()         { return impl().MISO(); }  
      void SCLK (bool st)  { impl().SCLK (st); }      
      void delay (uint32_t nsec) { impl().delay (nsec); }   


   private:
      uint32_t _clock () const { return 1000000000/(2*nsec_); }
      void _clock (uint32_t c) { nsec_ = 1000000000/(2*c); }
      byte_t _tx_data (byte_t out) { return _tx_data_impl (out); }

      template <spi::cpha C =CPHA>
      meta::enable_if_t <(C == spi::cpha::LOW), byte_t> _tx_data_impl (byte_t out);
      template <spi::cpha C =CPHA>
      meta::enable_if_t <(C == spi::cpha::HIGH), byte_t> _tx_data_impl (byte_t out);

   private:
      uint32_t nsec_;      
   };

   template <typename impl_t, spi::cpol CPOL, spi::cpha CPHA, spi::bitOrder BitOrder>
   template <spi::cpha C>
      meta::enable_if_t <(C == spi::cpha::LOW), byte_t>
      spi_bb_i<impl_t, CPOL, CPHA, BitOrder>::_tx_data_impl (byte_t out) {
         byte_t in {};
         SCLK (clkL_);
         for (uint8_t bit {static_cast<uint8_t>(BitOrder)} ; bit ; shift (bit)) {
            MOSI (out & bit);    // Out at preceding clock trailing edge
            delay (nsec_);       // Half cycle delay
            SCLK (clkH_);        // Leading edge
            in |= (MISO ()) ? bit : 0; // In at leading clock edge
            delay (nsec_);       // Half cycle delay
            SCLK (clkL_);        // Trailing edge
         }
         return in;
      }

   template <typename impl_t, spi::cpol CPOL, spi::cpha CPHA, spi::bitOrder BitOrder>
   template <spi::cpha C>
      meta::enable_if_t <(C == spi::cpha::HIGH), byte_t>
      spi_bb_i<impl_t, CPOL, CPHA, BitOrder>::_tx_data_impl (byte_t out) {
         byte_t in {};
         SCLK (clkL_);
         for (uint8_t bit {static_cast<uint8_t>(BitOrder)} ; bit ; shift (bit)) {
            delay (nsec_);       // Half cycle delay
            SCLK (clkH_);        // Leading edge
            MOSI (out & bit);    // Out at leading clock edge
            delay (nsec_);       // Half cycle delay
            SCLK (clkL_);        // Trailing edge
            in |= (MISO ()) ? bit : 0; // In at trailing clock edge
         }
         return in;
      }


   template <spi::cpol CPOL,
             spi::cpha CPHA,
             spi::bitOrder BitOrder>
   class spi_bb_i <virtual_tag, CPOL, CPHA, BitOrder> : public spi_i<virtual_tag> {
   public:
      using type = spi_bb_i<virtual_tag, CPOL, CPHA, BitOrder>; 

   protected:
      ~spi_bb_i () = default; 
      spi_bb_i (uint32_t clk) noexcept
         : nsec_ {1000000000/(2*clk)} {
      }

   private:
      template <spi::bitOrder B =BitOrder> constexpr
      meta::enable_if_t <(B == spi::bitOrder::LSB_First), void> shift (byte_t& b) { b <<=1; }
      template <spi::bitOrder B =BitOrder> constexpr
      meta::enable_if_t <(B == spi::bitOrder::MSB_First), void> shift (byte_t& b) { b >>=1; }
      template <spi::cpol C =CPOL> static constexpr bool clkHigh () {
         return !static_cast<bool>(C);
      }
      template <spi::cpol C =CPOL> static constexpr bool clkLow () {
         return static_cast<bool>(C);
      }
      static constexpr bool clkH_ {clkHigh()};
      static constexpr bool clkL_ {clkLow()};


   private:
      virtual void MOSI (bool) =0;  
      virtual bool MISO ()     =0;  
      virtual void SCLK (bool) =0;  
      virtual void delay (uint32_t) =0; 


   private:
      uint32_t _clock () const final { return 1000000000/(2*nsec_); }
      void _clock (uint32_t c) final { nsec_ = 1000000000/(2*c); }
      byte_t _tx_data (byte_t out) final { return _tx_data_impl (out); }

      template <spi::cpha C =CPHA>
      meta::enable_if_t <(C == spi::cpha::LOW), byte_t> _tx_data_impl (byte_t out);
      template <spi::cpha C =CPHA>
      meta::enable_if_t <(C == spi::cpha::HIGH), byte_t> _tx_data_impl (byte_t out);

   private:
      uint32_t nsec_;      
   };

   template <spi::cpol CPOL, spi::cpha CPHA, spi::bitOrder BitOrder>
   template <spi::cpha C>
      meta::enable_if_t <(C == spi::cpha::LOW), byte_t>
      spi_bb_i<virtual_tag, CPOL, CPHA, BitOrder>::_tx_data_impl (byte_t out) {
         byte_t in {};
         SCLK (clkL_);
         for (uint8_t bit {static_cast<uint8_t>(BitOrder)} ; bit ; shift (bit)) {
            MOSI (out & bit);    // Out at preceding clock trailing edge
            delay (nsec_);       // Half cycle delay
            SCLK (clkH_);        // Leading edge
            in |= (MISO ()) ? bit : 0; // In at leading clock edge
            delay (nsec_);       // Half cycle delay
            SCLK (clkL_);        // Trailing edge
         }
         return in;
      }

   template <spi::cpol CPOL, spi::cpha CPHA, spi::bitOrder BitOrder>
   template <spi::cpha C>
      meta::enable_if_t <(C == spi::cpha::HIGH), byte_t>
      spi_bb_i<virtual_tag, CPOL, CPHA, BitOrder>::_tx_data_impl (byte_t out) {
         byte_t in {};
         SCLK (clkL_);
         for (uint8_t bit {static_cast<uint8_t>(BitOrder)} ; bit ; shift (bit)) {
            delay (nsec_);       // Half cycle delay
            SCLK (clkH_);        // Leading edge
            MOSI (out & bit);    // Out at leading clock edge
            delay (nsec_);       // Half cycle delay
            SCLK (clkL_);        // Trailing edge
            in |= (MISO ()) ? bit : 0; // In at trailing clock edge
         }
         return in;
      }

}

#endif   //#ifndef __spi_bb_h__