343 lines
8.3 KiB
C++
343 lines
8.3 KiB
C++
// Arduino Mega 2560 + HV5812P VFD driver
|
|
//
|
|
// Tube wiring:
|
|
// - HVOut1..HVOut7 -> digit segments A..G
|
|
// - HVOut8 -> decimal point segment on the indicator grid
|
|
// - HVOut9 -> alarm bell segment on the indicator grid
|
|
// - HVOut10..HVOut13 -> digits 1..4
|
|
// - HVOut14 -> indicator grid between digits 2 and 3
|
|
//
|
|
// Send an integer over the USB serial port and it will be shown on the VFD.
|
|
// Examples:
|
|
// 42<newline>
|
|
// -17<newline>
|
|
// 1234.<newline> // enables the decimal point
|
|
// 1234!<newline> // enables the alarm bell
|
|
// 1234.!<newline> // enables both
|
|
|
|
#include <Arduino.h>
|
|
|
|
namespace {
|
|
|
|
constexpr uint8_t kHvDataPin = 51; // MOSI on Mega 2560
|
|
constexpr uint8_t kHvClockPin = 52; // SCK on Mega 2560
|
|
constexpr uint8_t kHvLatchPin = 53; // User-configurable latch/strobe pin
|
|
constexpr int8_t kHvBlankPin = 49; // Set to -1 if BL/OE is not connected
|
|
constexpr bool kBlankActiveHigh = true;
|
|
|
|
constexpr unsigned long kSerialBaud = 115200;
|
|
constexpr unsigned long kDigitHoldMicros = 2000;
|
|
|
|
constexpr uint8_t kDigitCount = 4;
|
|
constexpr uint8_t kSegmentCount = 7;
|
|
constexpr uint8_t kDriverBits = 20;
|
|
|
|
constexpr uint8_t kSegmentStartBit = 0; // HVOut1 -> bit 0
|
|
constexpr uint8_t kPointSegmentBit = 7; // HVOut8 -> bit 7
|
|
constexpr uint8_t kBellSegmentBit = 8; // HVOut9 -> bit 8
|
|
constexpr uint8_t kGridStartBit = 9; // HVOut10 -> bit 9
|
|
constexpr uint8_t kIndicatorGridBit = 13; // HVOut14 -> bit 13
|
|
|
|
char g_displayBuffer[kDigitCount] = {' ', ' ', ' ', ' '};
|
|
char g_inputBuffer[16];
|
|
uint8_t g_inputLength = 0;
|
|
bool g_pointEnabled = false;
|
|
bool g_bellEnabled = false;
|
|
uint8_t g_rawOutput = 0;
|
|
|
|
// Seven-segment encoding order is A, B, C, D, E, F, G.
|
|
uint8_t encodeCharacter(char c) {
|
|
switch (c) {
|
|
case '0': return 0b0111111;
|
|
case '1': return 0b0000110;
|
|
case '2': return 0b1011011;
|
|
case '3': return 0b1001111;
|
|
case '4': return 0b1100110;
|
|
case '5': return 0b1101101;
|
|
case '6': return 0b1111101;
|
|
case '7': return 0b0000111;
|
|
case '8': return 0b1111111;
|
|
case '9': return 0b1101111;
|
|
case 'A':
|
|
case 'a': return 0b1110111;
|
|
case 'B':
|
|
case 'b': return 0b1111100;
|
|
case 'C':
|
|
case 'c': return 0b0111001;
|
|
case 'D':
|
|
case 'd': return 0b1011110;
|
|
case 'E':
|
|
case 'e': return 0b1111001;
|
|
case 'F':
|
|
case 'f': return 0b1110001;
|
|
case '-': return 0b1000000;
|
|
default: return 0;
|
|
}
|
|
}
|
|
|
|
void shiftDriverWord(uint32_t word) {
|
|
digitalWrite(kHvLatchPin, HIGH);
|
|
digitalWrite(kHvClockPin, HIGH);
|
|
|
|
for (int8_t bit = kDriverBits - 1; bit >= 0; --bit) {
|
|
digitalWrite(kHvDataPin, (word >> bit) & 0x1U ? HIGH : LOW);
|
|
digitalWrite(kHvClockPin, LOW);
|
|
digitalWrite(kHvClockPin, HIGH);
|
|
}
|
|
|
|
digitalWrite(kHvLatchPin, LOW);
|
|
digitalWrite(kHvLatchPin, HIGH);
|
|
}
|
|
|
|
void setDisplayBlanked(bool blanked) {
|
|
if (kHvBlankPin < 0) {
|
|
return;
|
|
}
|
|
|
|
const bool level = kBlankActiveHigh ? blanked : !blanked;
|
|
digitalWrite(kHvBlankPin, level ? HIGH : LOW);
|
|
}
|
|
|
|
void blankDisplay() {
|
|
shiftDriverWord(0);
|
|
}
|
|
|
|
uint32_t maskForHvOutput(uint8_t hvOutput) {
|
|
if (hvOutput == 0 || hvOutput > kDriverBits) {
|
|
return 0;
|
|
}
|
|
|
|
return 1UL << (hvOutput - 1);
|
|
}
|
|
|
|
void renderDigit(uint8_t digitIndex) {
|
|
uint32_t word = 0;
|
|
const uint8_t segments = encodeCharacter(g_displayBuffer[digitIndex]);
|
|
|
|
for (uint8_t segment = 0; segment < kSegmentCount; ++segment) {
|
|
if ((segments >> segment) & 0x1U) {
|
|
word |= (1UL << (kSegmentStartBit + segment));
|
|
}
|
|
}
|
|
|
|
word |= (1UL << (kGridStartBit + digitIndex));
|
|
shiftDriverWord(word);
|
|
}
|
|
|
|
void renderIndicator() {
|
|
uint32_t word = 1UL << kIndicatorGridBit;
|
|
|
|
if (g_pointEnabled) {
|
|
word |= 1UL << kPointSegmentBit;
|
|
}
|
|
|
|
if (g_bellEnabled) {
|
|
word |= 1UL << kBellSegmentBit;
|
|
}
|
|
|
|
shiftDriverWord(word);
|
|
}
|
|
|
|
void writeTextToDisplay(const char* text) {
|
|
for (uint8_t i = 0; i < kDigitCount; ++i) {
|
|
g_displayBuffer[i] = ' ';
|
|
}
|
|
|
|
size_t len = strlen(text);
|
|
if (len > kDigitCount) {
|
|
text += len - kDigitCount;
|
|
len = kDigitCount;
|
|
}
|
|
|
|
const uint8_t start = kDigitCount - len;
|
|
for (uint8_t i = 0; i < len; ++i) {
|
|
g_displayBuffer[start + i] = text[i];
|
|
}
|
|
}
|
|
|
|
void setDisplayFromNumber(long value) {
|
|
char buffer[16];
|
|
ltoa(value, buffer, 10);
|
|
writeTextToDisplay(buffer);
|
|
}
|
|
|
|
bool parseDisplayCommand(const char* input,
|
|
char* displayText,
|
|
size_t displayTextSize,
|
|
bool& pointEnabled,
|
|
bool& bellEnabled) {
|
|
size_t inputIndex = 0;
|
|
size_t displayIndex = 0;
|
|
|
|
if (input[inputIndex] == '-') {
|
|
if (displayIndex + 1 >= displayTextSize) {
|
|
return false;
|
|
}
|
|
displayText[displayIndex++] = input[inputIndex++];
|
|
}
|
|
|
|
const size_t digitStart = inputIndex;
|
|
while (isxdigit(static_cast<unsigned char>(input[inputIndex]))) {
|
|
if (displayIndex + 1 >= displayTextSize) {
|
|
return false;
|
|
}
|
|
displayText[displayIndex] = toupper(static_cast<unsigned char>(input[inputIndex]));
|
|
++displayIndex;
|
|
++inputIndex;
|
|
}
|
|
|
|
if (inputIndex == digitStart) {
|
|
return false;
|
|
}
|
|
|
|
pointEnabled = false;
|
|
bellEnabled = false;
|
|
|
|
while (input[inputIndex] != '\0') {
|
|
if (input[inputIndex] == '.') {
|
|
pointEnabled = true;
|
|
} else if (input[inputIndex] == '!') {
|
|
bellEnabled = true;
|
|
} else {
|
|
return false;
|
|
}
|
|
++inputIndex;
|
|
}
|
|
|
|
displayText[displayIndex] = '\0';
|
|
return true;
|
|
}
|
|
|
|
bool parseRawOutputCommand(const char* input, uint8_t& hvOutput) {
|
|
if (strncmp(input, "RAW ", 4) != 0) {
|
|
return false;
|
|
}
|
|
|
|
char* endPtr = nullptr;
|
|
const long parsed = strtol(input + 4, &endPtr, 10);
|
|
if (*endPtr != '\0' || parsed < 0 || parsed > kDriverBits) {
|
|
return false;
|
|
}
|
|
|
|
hvOutput = static_cast<uint8_t>(parsed);
|
|
return true;
|
|
}
|
|
|
|
void commitSerialBuffer() {
|
|
if (g_inputLength == 0) {
|
|
return;
|
|
}
|
|
|
|
g_inputBuffer[g_inputLength] = '\0';
|
|
|
|
uint8_t rawOutput = 0;
|
|
if (parseRawOutputCommand(g_inputBuffer, rawOutput)) {
|
|
g_rawOutput = rawOutput;
|
|
if (g_rawOutput == 0) {
|
|
Serial.println(F("RAW mode OFF"));
|
|
} else {
|
|
Serial.print(F("RAW mode: HVOUT"));
|
|
Serial.println(g_rawOutput);
|
|
}
|
|
g_inputLength = 0;
|
|
return;
|
|
}
|
|
|
|
char displayText[16];
|
|
bool pointEnabled = false;
|
|
bool bellEnabled = false;
|
|
if (parseDisplayCommand(g_inputBuffer, displayText, sizeof(displayText), pointEnabled, bellEnabled)) {
|
|
g_rawOutput = 0;
|
|
writeTextToDisplay(displayText);
|
|
g_pointEnabled = pointEnabled;
|
|
g_bellEnabled = bellEnabled;
|
|
Serial.print(F("Displaying: "));
|
|
Serial.println(displayText);
|
|
Serial.print(F("Point: "));
|
|
Serial.println(g_pointEnabled ? F("ON") : F("OFF"));
|
|
Serial.print(F("Bell: "));
|
|
Serial.println(g_bellEnabled ? F("ON") : F("OFF"));
|
|
} else {
|
|
Serial.print(F("Ignored invalid input: "));
|
|
Serial.println(g_inputBuffer);
|
|
}
|
|
|
|
g_inputLength = 0;
|
|
}
|
|
|
|
void pollSerial() {
|
|
while (Serial.available() > 0) {
|
|
const char incoming = static_cast<char>(Serial.read());
|
|
|
|
if (incoming == '\r' || incoming == '\n') {
|
|
commitSerialBuffer();
|
|
continue;
|
|
}
|
|
|
|
if (incoming == '\b' || incoming == 127) {
|
|
if (g_inputLength > 0) {
|
|
--g_inputLength;
|
|
}
|
|
continue;
|
|
}
|
|
|
|
if (g_inputLength < sizeof(g_inputBuffer) - 1) {
|
|
g_inputBuffer[g_inputLength++] = incoming;
|
|
}
|
|
}
|
|
}
|
|
|
|
void refreshDisplay() {
|
|
if (g_rawOutput != 0) {
|
|
setDisplayBlanked(true);
|
|
shiftDriverWord(maskForHvOutput(g_rawOutput));
|
|
setDisplayBlanked(false);
|
|
delayMicroseconds(kDigitHoldMicros);
|
|
return;
|
|
}
|
|
|
|
static uint8_t currentPhase = 0;
|
|
|
|
setDisplayBlanked(true);
|
|
if (currentPhase < kDigitCount) {
|
|
renderDigit(currentPhase);
|
|
} else if (g_pointEnabled || g_bellEnabled) {
|
|
renderIndicator();
|
|
} else {
|
|
blankDisplay();
|
|
}
|
|
setDisplayBlanked(false);
|
|
delayMicroseconds(kDigitHoldMicros);
|
|
setDisplayBlanked(true);
|
|
|
|
currentPhase = (currentPhase + 1) % (kDigitCount + 1);
|
|
}
|
|
|
|
} // namespace
|
|
|
|
void setup() {
|
|
pinMode(kHvDataPin, OUTPUT);
|
|
pinMode(kHvClockPin, OUTPUT);
|
|
pinMode(kHvLatchPin, OUTPUT);
|
|
if (kHvBlankPin >= 0) {
|
|
pinMode(kHvBlankPin, OUTPUT);
|
|
}
|
|
|
|
digitalWrite(kHvDataPin, LOW);
|
|
digitalWrite(kHvClockPin, HIGH);
|
|
digitalWrite(kHvLatchPin, HIGH);
|
|
setDisplayBlanked(true);
|
|
|
|
Serial.begin(kSerialBaud);
|
|
writeTextToDisplay("0");
|
|
blankDisplay();
|
|
|
|
Serial.println(F("HV5812P VFD controller ready."));
|
|
Serial.println(F("Send an integer followed by newline."));
|
|
}
|
|
|
|
void loop() {
|
|
pollSerial();
|
|
refreshDisplay();
|
|
}
|