unlimited buffer and continuous option

Author: Samuel Sieb

components/ht16k33_alpha/README.md

@@ -30,6 +30,8 @@ display:
 
 `scroll:` defaults to false
 
+`continuous:` is whether the start follows immediately after the end in a continuous loop, defaults to false
+
 `scroll_speed:` is the time between each movement, default 250ms
 
 `scroll_dwell:` is the time to wait at the end before going back to the start, default 2s

components/ht16k33_alpha/display.py

@@ -8,6 +8,7 @@
 ht16k33_alpha_ns = cg.esphome_ns.namespace('ht16k33_alpha')
 HT16K33AlphaDisplay = ht16k33_alpha_ns.class_('HT16K33AlphaDisplay', cg.PollingComponent, i2c.I2CDevice)
 
+CONF_CONTINUOUS = "continuous"
 CONF_SCROLL = "scroll"
 CONF_SCROLL_SPEED = "scroll_speed"
 CONF_SCROLL_DWELL = "scroll_dwell"
@@ -20,6 +21,7 @@
 
 CONFIG_SCHEMA = display.BASIC_DISPLAY_SCHEMA.extend({
     cv.GenerateID(): cv.declare_id(HT16K33AlphaDisplay),
+    cv.Optional(CONF_CONTINUOUS, default=False): cv.boolean,
     cv.Optional(CONF_SCROLL, default=False): cv.boolean,
     cv.Optional(CONF_SCROLL_SPEED, default='250ms'): cv.positive_time_period_milliseconds,
     cv.Optional(CONF_SCROLL_DWELL, default='2s'): cv.positive_time_period_milliseconds,
@@ -39,6 +41,7 @@ async def to_code(config):
         cg.add(var.set_writer(lambda_))
     if config[CONF_SCROLL]:
         cg.add(var.set_scroll(True))
+        cg.add(var.set_continuous(config[CONF_CONTINUOUS]))
         cg.add(var.set_scroll_speed(config[CONF_SCROLL_SPEED]))
         cg.add(var.set_scroll_dwell(config[CONF_SCROLL_DWELL]))
         cg.add(var.set_scroll_delay(int(config[CONF_SCROLL_DELAY] * config[CONF_SCROLL_SPEED].total_milliseconds)))

components/ht16k33_alpha/ht16k33_display.cpp

@@ -26,29 +26,24 @@ void HT16K33AlphaDisplay::setup() {
     display->write_bytes(DISPLAY_COMMAND_DISPLAY_ON, nullptr, 0);
   }
   this->set_brightness(1);
-  memset(this->buffer_, 0, 64);
 }
 
 void HT16K33AlphaDisplay::loop() {
   unsigned long now = millis();
   int numc = this->displays_.size() * 8;
-  // check if the buffer has shrunk past the current position since last update
-  if (this->offset_ + numc > this->buffer_fill_) {
-    this->offset_ = std::max(this->buffer_fill_ - numc, 0);
-    this->display_();
-  }
-  if (!this->scroll_ || (this->buffer_fill_ <= numc))
+  int len = this->buffer_.size();
+  if (!this->scroll_ || (len <= numc))
     return;
   if ((this->offset_ == 0) && (now - this->last_scroll_ < this->scroll_delay_))
     return;
-  if (this->offset_ + numc >= this->buffer_fill_) {
-    if (now - this->last_scroll_ >= this->scroll_dwell_) {
+  if ((!this->continuous_ && (this->offset_ + numc >= len)) ||
+      (this->continuous_ && (this->offset_ > len - 2))) {
+    if (this->continuous_ || (now - this->last_scroll_ >= this->scroll_dwell_)) {
       this->offset_ = 0;
       this->last_scroll_ = now;
       this->display_();
     }
-  } else
-  if (now - this->last_scroll_ >= this->scroll_speed_) {
+  } else if (now - this->last_scroll_ >= this->scroll_speed_) {
     this->offset_ += 2;
     this->last_scroll_ = now;
     this->display_();
@@ -58,19 +53,33 @@ void HT16K33AlphaDisplay::loop() {
 float HT16K33AlphaDisplay::get_setup_priority() const { return setup_priority::PROCESSOR; }
 
 void HT16K33AlphaDisplay::display_() {
-  int offset = this->offset_;
+  int numc = this->displays_.size() * 8;
+  int len = this->buffer_.size();
+  uint8_t data[numc];
+  memset(data, 0, numc);
+  int pos = this->offset_;
+  for (int i = 0; i < numc; i++, pos++) {
+    if (pos >= len) {
+      if (!this->continuous_)
+        break;
+      pos %= len;
+    }
+    data[i] = this->buffer_[pos];
+  }
+  pos = 0;
   for (auto *display : this->displays_) {
-    display->write_bytes(DISPLAY_COMMAND_SET_DDRAM_ADDR, this->buffer_ + offset, 8);
-    offset += 8;
+    display->write_bytes(DISPLAY_COMMAND_SET_DDRAM_ADDR, data + pos, 8);
+    pos += 8;
   }
 }
 
 void HT16K33AlphaDisplay::update() {
-  memset(this->buffer_, 0, 64);
-  int prev_fill = this->buffer_fill_;
-  this->buffer_fill_ = 0;
+  int prev_fill = this->buffer_.size();
+  this->buffer_.clear();
   this->call_writer();
-  if (this->scroll_ && (prev_fill != this->buffer_fill_)) {
+  int numc = this->displays_.size() * 8;
+  int len = this->buffer_.size();
+  if ((this->scroll_ && (prev_fill != len) && !this->continuous_) || (len <= numc)) {
     this->last_scroll_ = millis();
     this->offset_ = 0;
   }
@@ -99,14 +108,8 @@ float HT16K33AlphaDisplay::get_brightness() {
 }
 
 void HT16K33AlphaDisplay::print(const char *str) {
-  uint8_t pos = this->buffer_fill_;
   uint16_t fontc = 0;
   while (*str != '\0') {
-    if (pos >= 64) {
-      ESP_LOGW(TAG, "output buffer full!");
-      break;
-    }
-
     uint8_t c = *reinterpret_cast<const uint8_t *>(str++);
     if (c > 127)
       fontc = 0;
@@ -117,10 +120,9 @@ void HT16K33AlphaDisplay::print(const char *str) {
       fontc |= 0x4000;
       str++;
     }
-    this->buffer_[pos++] = fontc & 0xff;
-    this->buffer_[pos++] = fontc >> 8;
+    this->buffer_.push_back(fontc & 0xff);
+    this->buffer_.push_back(fontc >> 8);
   }
-  this->buffer_fill_ = pos;
 }
 
 void HT16K33AlphaDisplay::print(const std::string &str) { this->print(str.c_str()); }

components/ht16k33_alpha/ht16k33_display.h

@@ -20,6 +20,7 @@ class HT16K33AlphaDisplay : public PollingComponent, public i2c::I2CDevice {
   float get_setup_priority() const override;
   void add_secondary_display(i2c::I2CDevice *display) { this->displays_.push_back(display); }
   void set_scroll(bool scroll) { this->scroll_ = scroll; }
+  void set_continuous(bool continuous) { this->continuous_ = continuous; }
   void set_scroll_speed(unsigned long scroll_speed) { this->scroll_speed_ = scroll_speed; }
   void set_scroll_dwell(unsigned long scroll_dwell) { this->scroll_dwell_ = scroll_dwell; }
   void set_scroll_delay(unsigned long scroll_delay) { this->scroll_delay_ = scroll_delay; }
@@ -48,12 +49,12 @@ class HT16K33AlphaDisplay : public PollingComponent, public i2c::I2CDevice {
   std::vector<i2c::I2CDevice *> displays_ {this};
   std::function<void(HT16K33AlphaDisplay &)> writer_;
   bool scroll_ {false};
+  bool continuous_ {false};
   unsigned long scroll_speed_ {250};
   unsigned long scroll_dwell_ {2000};
   unsigned long scroll_delay_ {750};
   unsigned long last_scroll_ {0};
-  uint8_t buffer_[64];
-  int buffer_fill_ {0};
+  std::vector<uint8_t> buffer_;
   int offset_ {0};
   uint8_t brightness_ = 16;
 };