weikai.h

Go to the documentation of this file.

 
 
#pragma once
#include <memory>
#include <cinttypes>
#include "esphome/core/component.h"
#include "esphome/core/helpers.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;
 
const LogString *reg_to_str(int reg, bool page1);
 
void print_buffer(const char *tag, const uint8_t *data, size_t length, int level = ESPHOME_LOG_LEVEL_VERY_VERBOSE);
 
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 final : 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 final : 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 setup_channel();
 
  void 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;
 
#if defined(USE_ESP8266) || defined(USE_ESP32)
  void load_settings(bool dump_config) override {
    this->set_line_param_();
    this->set_baudrate_();
  }
  using UARTComponent::load_settings;  // also bring in the no-arg overload for convenience
#endif
 
 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 check_channel_down_();
 
#ifdef TEST_COMPONENT
 
  void uart_send_test_(char *message);
 
  bool uart_receive_test_(char *message);
#endif
 
  StaticRingBuffer<uint8_t, RING_BUFFER_SIZE> receive_buffer_;
  WeikaiComponent *parent_;  
  uint8_t channel_;          
  uint8_t data_;             
  std::string name_;         
};
 
}  // namespace esphome::weikai