i2c.h

Go to the documentation of this file.

#ifndef _utl_com_i2c_h__
#define _utl_com_i2c_h__

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

namespace utl {


   template <typename impl_t>
   class i2c_i {
      _CRTP_IMPL(impl_t);

   public:
      using type = i2c_i<impl_t>;     
      enum class Sequence {
         BYTE =0, 
         ACK,     
         BYTEnACK 
      };

   protected:
      i2c_i () = default;              
      ~i2c_i () = default;             
      i2c_i (const type&) = delete;    
      type& operator= (const type&) = delete;

   private:
      uint32_t _clock () const { return impl()._clock (); } 
      void _clock (uint32_t c) { impl()._clock (c); }       
      void _start()            { impl()._start (); }        
      void _stop()             { impl()._stop (); }         
      byte_t _rx_data (bool ack, Sequence seq)  { return impl()._rx_data (ack, seq); }
      bool _tx_data (byte_t byte, Sequence seq) { return impl()._tx_data (byte, seq); }

   public:
      uint32_t clock () const { return _clock (); }  
      void clock (uint32_t f) { _clock (f); }        

   public:
      void start() { _start (); }   
      void stop () { _stop (); }    

      byte_t rx_data (bool ack, Sequence seq =Sequence::BYTEnACK) {
         return _rx_data (ack, seq);
      }

      bool tx_data (byte_t byte, Sequence seq =Sequence::BYTEnACK) {
         return _tx_data (byte, seq);
      }

   };

   template<>
   class i2c_i <virtual_tag> {
   public:
      using type = i2c_i <virtual_tag>;   

      enum class Sequence {
         BYTE=0,  
         ACK,     
         BYTEnACK 
      };

   protected:
      i2c_i () = default;                 
      i2c_i (const type&) = delete;       
      type& operator= (const type&) = delete;
   public:
      virtual ~i2c_i () = default;        

   private:
      virtual uint32_t _clock () const = 0;  
      virtual void _clock (uint32_t) = 0;    
      virtual void _start() = 0;             
      virtual void _stop() = 0;              
      virtual byte_t _rx_data (bool ack, Sequence seq) = 0;    
      virtual bool _tx_data (byte_t byte, Sequence seq) = 0;   

   public:
      uint32_t clock () const { return _clock(); } 
      void clock (uint32_t c) { _clock(c); }       

   public:
      void start () { _start(); }
      void stop () { _stop(); }
      byte_t rx_data (bool ack, Sequence seq =Sequence::BYTEnACK) {
         return _rx_data (ack, seq);
      }
      bool tx_data (byte_t byte, Sequence seq =Sequence::BYTEnACK) {
         return _tx_data (byte, seq);
      }

   };

#if defined _utl_have_concepts

   template <typename T>
   concept bool I2c_i = requires (T t, const T ct, typename T::Sequence s) {
      // Object type
      requires not_<std::is_copy_constructible<T>::value>::value;
      requires not_<std::is_copy_assignable<T>::value>::value;
      // Methods
      {ct.clock()} -> uint32_t;
      {t.clock(0)} -> void;
      {t.start()}  -> void;
      {t.stop()}   -> void;
      {t.rx_data (1, s)} -> byte_t;
      {t.tx_data (0, s)} -> bool;
   };
#else
   namespace i2c_i_details {
      using std::declval;

      template <class _Tp> using try_cclk_t  = decltype (declval<const _Tp>().clock());
      template <class _Tp> using try_clk_t   = decltype (declval<_Tp>().clock(declval<uint32_t>()));
      template <class _Tp> using try_start_t = decltype (declval<_Tp>().start());
      template <class _Tp> using try_stop_t  = decltype (declval<_Tp>().stop());
      template <class _Tp> using try_rx_data_t
            = decltype (declval<_Tp>().rx_data (declval<bool>(), declval<typename _Tp::Sequence>()));
      template <class _Tp> using try_tx_data_t
            = decltype (declval<_Tp>().tx_data (declval<byte_t>(), declval<typename _Tp::Sequence>()));

      template <typename _Tp, typename =void>
      struct is_i2c_ : meta::false_ { };

      template <typename _Tp>
      struct is_i2c_ <_Tp,
         meta::void_t <
            typename _Tp::Sequence,
//            meta::use_if_same_t <uint32_t,try_cclk_t <_Tp>>,
//            meta::use_if_same_t <void,    try_clk_t <_Tp>>,
//            meta::use_if_same_t <void,    try_start_t <_Tp>>,
//            meta::use_if_same_t <void,    try_stop_t <_Tp>>,
//            meta::use_if_same_t <byte_t,  try_rx_data_t <_Tp>>,
//            meta::use_if_same_t <bool,    try_tx_data_t <_Tp>>
            void
         >
      > : meta::true_ { };
   }
//   template <typename _Tp>
//   constexpr bool I2c_i = i2c_i_details::is_i2c_<_Tp>::value;
#endif


} // namespace utl

#endif // _utl_com_i2c_h__