NE-HCS12SS59T-R1 I2C VFD

// This example sketch may be freely used and considered in the public domain
// in countries where releasing code into the public domain is not possible
// this code may be used under the terms specified in the CC0 license
// https://creativecommons.org/public-domain/cc0/

#include <Wire.h>

#define VFD_REG_CTRL         0
#define VFD_REG_OFFSET       1
#define VFD_REG_SCROLL_LEN   2
#define VFD_REG_SCROLL_MODE  3
#define VFD_REG_SCROLL_SPEED 4
#define VFD_REG_DATA         10

#define VFD_SCROLL_DISABLE   0
#define VFD_SCROLL_LEFT      1
#define VFD_SCROLL_RIGHT     2

const int16_t I2C_ADDR = 0x10;

// Functions for reading and writing

void vfd_read_regs(uint8_t reg, uint8_t* val, uint8_t len) {
  Wire.beginTransmission(I2C_ADDR);
  Wire.write(reg);
  Wire.endTransmission(false);
  Wire.requestFrom((uint8_t) I2C_ADDR, (uint8_t) len);
  for (uint8_t index = 0; index < len; index++) {
    val[index] = Wire.read();
  }
  Wire.endTransmission();
}

void vfd_read_reg(uint8_t reg, uint8_t* val) {
  vfd_read_regs(reg, val, 1);
}

void vfd_write_regs(uint8_t reg, uint8_t* val, uint8_t len) {
  Serial.print("I2C write to register " + String(reg) + ": ");
  Wire.beginTransmission(I2C_ADDR);
  Wire.write(reg);
  for (uint8_t index = 0; index < len; index++) {
    Serial.print(String(val[index], HEX) + ", ");
    Wire.write(val[index]);
  }
  Serial.println();
  Wire.endTransmission();
}

void vfd_write_reg(uint8_t reg, uint8_t val) {
  vfd_write_regs(reg, &val, 1);
}

// Functions for using the control register

void vfd_control_led(bool state) {
  uint8_t val = 0;
  vfd_read_reg(VFD_REG_CTRL, &val);
  Serial.println("LED, READ  " + String(val, HEX));
  val &= ~(1 << 2); // Turn off the LED
  if (state) {
    val |= (1 << 2); // Turn on the LED
  }
  Serial.println("LED, WRITE " + String(val, HEX));
  vfd_write_reg(VFD_REG_CTRL, val);
}

void vfd_control_test(bool state) {
  uint8_t val = 0;
  vfd_read_reg(VFD_REG_CTRL, &val);
  val &= ~(1 << 1); // Turn off the test mode
  if (state) {
    val |= (1 << 1); // Turn on the test mode
  }
  vfd_write_reg(VFD_REG_CTRL, val);
}

void vfd_control_enable(bool state) {
  uint8_t val = 0;
  vfd_read_reg(VFD_REG_CTRL, &val);
  val &= ~(1 << 0); // Turn off the VFD
  if (state) {
    val |= (1 << 0); // Turn on the VFD
  }
  vfd_write_reg(VFD_REG_CTRL, val);
}

void vfd_control(bool enable, bool test, bool led) {
  uint8_t val = 0;
  if (enable) {
    val |= (1 << 0);
  }
  if (test) {
    val |= (1 << 1);
  }
  if (led) {
    val |= (1 << 2);
  }
  vfd_write_reg(VFD_REG_CTRL, val);
}

// Functions for using the scroll features

void vfd_set_offset(uint8_t offset) {
  vfd_write_reg(VFD_REG_OFFSET, offset);
}

void vfd_set_scroll_length(uint8_t len) {
  vfd_write_reg(VFD_REG_SCROLL_LEN, len);
}

void vfd_set_scroll_mode(uint8_t scroll_mode, bool scroll_loop) {
  uint8_t val = scroll_mode & 0x0F;
  if (scroll_loop) {
    val |= (1 << 4);
  }
  vfd_write_reg(VFD_REG_SCROLL_MODE, val);
}

void vfd_set_scroll_speed(uint16_t scroll_speed) {
  uint8_t values[2];
  values[0] = (scroll_speed) & 0xFF;
  values[1] = (scroll_speed >> 8) & 0xFF;
  vfd_write_regs(VFD_REG_SCROLL_SPEED, values, sizeof(uint16_t));
}

// Functions for using the text buffer

void vfd_write_text(String text) {
  // This function writes an ASCII string into
  // register 10 to 255

  const size_t max_len = 245; // can store text in registers 10 to 255
  size_t len = text.length();

  if (len > max_len) {
    // Silently limit the length of the string
    len = max_len;
  }

  Wire.beginTransmission(I2C_ADDR);
  Wire.write(VFD_REG_DATA);
  for (size_t index = 0; index < len; index++) {
    Wire.write(text[index]);
  }
  Wire.endTransmission();
}

// Functions for Arduino program

void setup() {
  Serial.begin(115200);

  Serial.println("Initialize I2C bus");
  Wire.begin(); // Initialize the I2C bus

  // Configure the display and show a message
  Serial.println("Configure the display and show a message");
  vfd_set_scroll_mode(VFD_SCROLL_DISABLE, false); // Disable scrolling
  vfd_set_offset(0); // Move to beginning of text buffer
  vfd_write_text("Hello world ");
  vfd_control(true, false, true); // Turn on VFD and LED
  delay(1000); // Wait a bit

  Serial.println("Demonstrate scrolling");
  String text = "            The quick brown fox jumps over the lazy dog 0123456789 !@$%^&*()-_=+";
  vfd_write_text(text);
  vfd_set_scroll_length(text.length() - 12); // Scroll until the last character of the string is on the most right character of the display
  vfd_set_scroll_speed(100); // Scroll one character every 100ms
  vfd_set_scroll_mode(VFD_SCROLL_LEFT, false); // Scroll left then stop
  vfd_control_led(false);
  delay(10000);

  vfd_set_scroll_mode(VFD_SCROLL_RIGHT, false); // Scroll right then stop
  vfd_control_led(true); // Turn on LED
  delay(10000);

  vfd_set_scroll_mode(VFD_SCROLL_LEFT, true); // Scroll left then loop
  vfd_control_led(false); // Turn off LED
  delay(20000);

  vfd_set_scroll_mode(VFD_SCROLL_DISABLE, false); // Disable scrolling
  vfd_write_text("            "); // Clear screen
  vfd_set_offset(0); // Move to beginning of text buffer
  vfd_control_led(true); // Turn on LED

  Serial.println("Starting counter loop");
}

uint32_t counter = 0;
void loop() {
  // Count as fast as we can
  vfd_write_text(String(counter));
  counter++;
}