_1wire_uart.h

Go to the documentation of this file.

#ifndef __utl_com_1wire_uart_h__
#define __utl_com_1wire_uart_h__

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

namespace utl {

  template <typename Impl_t>
  class _1wire_uart_i : public _1wire_i<_1wire_uart_i<Impl_t>> {
     _CRTP_IMPL(Impl_t);   
     friend _1wire_i <_1wire_uart_i<Impl_t>>;
  public:
     using type    = _1wire_uart_i<Impl_t>;          
     using Speed   = typename _1wire_i<type>::Speed; 

  protected:
      _1wire_uart_i () = default;   
      ~_1wire_uart_i () = default;  

  private:
     byte_t UART_RW (byte_t byte) { return impl().UART_RW (byte); }

     void UART_BR (uint32_t br) { impl().UART_BR (br); }

  private:
     enum BR {
        BR_STD_RST  =9600,
        BR_OVR_RST  =57600,
        BR_STD      =115200,
        BR_OVR      =921600
     };
     Speed     _speed {Speed::STD};

     Speed speed () const { return _speed; } 
     void speed (Speed s);                   

     bool bit (bool b) {
        if (b)
           return (UART_RW (0xFF) < 0xFF) ? 0 : 1;
        else {
           UART_RW (0x00);
           return 0;
        }
     }
     bool _reset (Speed s);
  };

  template <typename Impl_t>
  void _1wire_uart_i<Impl_t>::speed (Speed s) {
     switch (_speed = s) {
        case Speed::STD:   UART_BR (BR_STD); break;
        case Speed::OVDR:  UART_BR (BR_OVR); break;
     }
  }

  template <typename Impl_t>
  bool _1wire_uart_i<Impl_t>::_reset (Speed s) {
     // Select frame to send
     uint8_t   w = ((_speed = s) == Speed::STD) ? 0xF0 : 0xF8;
     // Select baudrate
     impl().UART_BR ((_speed == Speed::STD) ? BR_STD_RST : BR_OVR_RST);
     // Send frame and check the result
     return (impl().UART_RW (w) < w);
  }

   template <>
   class _1wire_uart_i<virtual_tag> : public _1wire_i<virtual_tag> {
   public:
      using type    = _1wire_uart_i<virtual_tag>;              
      using Speed   = typename _1wire_i<virtual_tag>::Speed;   

   protected:
      _1wire_uart_i () = default;   
      ~_1wire_uart_i () = default;  

   private:
      virtual byte_t UART_RW (byte_t byte) =0;

      virtual void UART_BR (uint32_t br) =0;

   private:
      enum BR {
         BR_STD_RST  =9600,
         BR_OVR_RST  =57600,
         BR_STD      =115200,
         BR_OVR      =921600
      };
      Speed _speed {Speed::STD};

      Speed speed () const { return _speed; }   
      void speed (Speed s);                     

      bool bit (bool b) {
         if (b)
            return (UART_RW (0xFF) < 0xFF) ? 0 : 1;
         else {
            UART_RW (0x00);
            return 0;
         }
      }
      bool _reset (Speed s);
   };

   void _1wire_uart_i<virtual_tag>::speed (Speed s) {
      switch (_speed = s) {
         case Speed::STD:  UART_BR (BR_STD); break;
         case Speed::OVDR: UART_BR (BR_OVR); break;
      }
   }

   bool _1wire_uart_i<virtual_tag>::_reset (Speed s) {
      // Select frame to send
      uint8_t   w = ((_speed = s) == Speed::STD) ? 0xF0 : 0xF8;
      // Select baudrate
      UART_BR ((_speed == Speed::STD) ? BR_STD_RST : BR_OVR_RST);
      // Send frame and check the result
      return (UART_RW (w) < w);
   }


}  // namespace utl

#endif /* __utl_com_1wire_uart_h__ */