weikai.h

Go to the documentation of this file.

 
 
#pragma once
#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::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; }
 
  gpio::Flags get_flags() const override { return this->flags_; }
 
  void setup() override;
  size_t dump_summary(char *buffer, size_t len) 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;
 
  size_t available() override;
 
  uart::UARTFlushResult 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 esphome::weikai