weikai.h

Go to the documentation of this file.

#pragma once
#include <bitset>
#include <memory>
#include <cinttypes>
#include "esphome/core/component.h"
#include "esphome/components/uart/uart.h"
#include "wk_reg_def.h"

// #define TEST_COMPONENT

namespace esphome {
namespace weikai {

#if defined(I2C_BUFFER_LENGTH)
constexpr size_t XFER_MAX_SIZE = I2C_BUFFER_LENGTH;
#else
constexpr size_t XFER_MAX_SIZE = 128;
#endif

constexpr size_t FIFO_SIZE = 256;

constexpr size_t RING_BUFFER_SIZE = FIFO_SIZE;

template<typename T, size_t SIZE> class WKRingBuffer {
 public:
  bool push(const T item) {
    if (is_full())
      return false;
    this->rb_[this->head_] = item;
    this->head_ = (this->head_ + 1) % SIZE;
    this->count_++;
    return true;
  }

  bool pop(T &item) {
    if (is_empty())
      return false;
    item = this->rb_[this->tail_];
    this->tail_ = (this->tail_ + 1) % SIZE;
    this->count_--;
    return true;
  }

  bool peek(T &item) {
    if (is_empty())
      return false;
    item = this->rb_[this->tail_];
    return true;
  }

  inline bool is_empty() { return (this->count_ == 0); }

  inline bool is_full() { return (this->count_ == SIZE); }

  inline size_t count() { return this->count_; }

  inline size_t free() { return SIZE - this->count_; }

  inline void clear() { this->head_ = this->tail_ = this->count_ = 0; }

 protected:
  std::array<T, SIZE> rb_{0};  
  int tail_{0};                
  int head_{0};                
  size_t count_{0};            
};

class WeikaiComponent;
// class WeikaiComponentSPI;
class WeikaiRegister {
 public:
  WeikaiRegister(WeikaiComponent *const comp, uint8_t reg, uint8_t channel)
      : comp_(comp), register_(reg), channel_(channel) {}
  virtual ~WeikaiRegister() {}

  WeikaiRegister &operator=(uint8_t value);

  WeikaiRegister &operator&=(uint8_t value);

  WeikaiRegister &operator|=(uint8_t value);

  operator uint8_t() const { return read_reg(); }

  virtual uint8_t read_reg() const = 0;

  virtual void write_reg(uint8_t value) = 0;

  virtual void read_fifo(uint8_t *data, size_t length) const = 0;

  virtual void write_fifo(uint8_t *data, size_t length) = 0;

  WeikaiComponent *const comp_;  
  uint8_t register_;             
  uint8_t channel_;              
};

class WeikaiChannel;  // forward declaration
class WeikaiComponent : public Component {
 public:
  virtual ~WeikaiComponent() {}

  void set_crystal(uint32_t crystal) { this->crystal_ = crystal; }

  void set_test_mode(int test_mode) { this->test_mode_ = test_mode; }

  void set_name(std::string &&name) { this->name_ = std::move(name); }

  const char *get_name() { return this->name_.c_str(); }

  void loop() override;

  bool page1() { return page1_; }

  virtual WeikaiRegister &reg(uint8_t reg, uint8_t channel) = 0;

 protected:
  friend class WeikaiChannel;

  float get_setup_priority() const override { return setup_priority::BUS - 0.1F; }

  friend class WeikaiGPIOPin;
  bool read_pin_val_(uint8_t pin);

  void write_pin_val_(uint8_t pin, bool value);

  void set_pin_direction_(uint8_t pin, gpio::Flags flags);

#ifdef TEST_COMPONENT
  void test_gpio_input_();
  void test_gpio_output_();
#endif

  uint8_t pin_config_{0x00};                 
  uint8_t output_state_{0x00};               
  uint8_t input_state_{0x00};                
  uint32_t crystal_;                         
  int test_mode_;                            
  bool page1_{false};                        
  std::vector<WeikaiChannel *> children_{};  
  std::string name_;                         
};

class WeikaiGPIOPin : public GPIOPin {
 public:
  void set_parent(WeikaiComponent *parent) { this->parent_ = parent; }
  void set_pin(uint8_t pin) { this->pin_ = pin; }
  void set_inverted(bool inverted) { this->inverted_ = inverted; }
  void set_flags(gpio::Flags flags) { this->flags_ = flags; }

  void setup() override;
  std::string dump_summary() const override;
  void pin_mode(gpio::Flags flags) override { this->parent_->set_pin_direction_(this->pin_, flags); }
  bool digital_read() override { return this->parent_->read_pin_val_(this->pin_) != this->inverted_; }
  void digital_write(bool value) override { this->parent_->write_pin_val_(this->pin_, value != this->inverted_); }

 protected:
  WeikaiComponent *parent_{nullptr};
  uint8_t pin_;
  bool inverted_;
  gpio::Flags flags_;
};

class WeikaiChannel : public uart::UARTComponent {
 public:
  void set_parent(WeikaiComponent *parent) {
    this->parent_ = parent;
    this->parent_->children_.push_back(this);  // add ourself to the list (vector)
  }

  void set_channel(uint8_t channel) { this->channel_ = channel; }

  void set_channel_name(std::string &&name) { this->name_ = std::move(name); }

  const char *get_channel_name() { return this->name_.c_str(); }

  void virtual setup_channel();

  void virtual dump_channel();

  WeikaiRegister &reg(uint8_t reg) { return this->parent_->reg(reg, channel_); }

  //
  // we implements/overrides the virtual class from UARTComponent
  //

  void write_array(const uint8_t *buffer, size_t length) override;

  bool read_array(uint8_t *buffer, size_t length) override;

  bool peek_byte(uint8_t *buffer) override;

  int available() override;

  void flush() override;

 protected:
  friend class WeikaiComponent;

  void check_logger_conflict() override {}

  void reset_fifo_();

  void set_line_param_();

  void set_baudrate_();

  size_t rx_in_fifo_();

  size_t tx_in_fifo_();

  bool tx_fifo_is_not_empty_();

  size_t xfer_fifo_to_buffer_();

  bool virtual check_channel_down();

#ifdef TEST_COMPONENT

  void uart_send_test_(char *message);

  bool uart_receive_test_(char *message);
#endif

  WKRingBuffer<uint8_t, RING_BUFFER_SIZE> receive_buffer_;
  WeikaiComponent *parent_;  
  uint8_t channel_;          
  uint8_t data_;             
  std::string name_;         
};

}  // namespace weikai
}  // namespace esphome