mirror of
https://github.com/DCC-EX/CommandStation-EX.git
synced 2024-11-27 01:56:14 +01:00
261 lines
8.7 KiB
C++
261 lines
8.7 KiB
C++
/*
|
|
* © 2023, Neil McKechnie. All rights reserved.
|
|
*
|
|
* This file is part of DCC++EX API
|
|
*
|
|
* This is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* It is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with CommandStation. If not, see <https://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
/*
|
|
* This driver provides a more immediate interface into the OLED display
|
|
* than the one installed through the config.h file. When an LCD(...) call
|
|
* is made, the text is output immediately to the specified display line,
|
|
* without waiting for the next 2.5 second refresh. However, if the line
|
|
* specified is off the screen then the text in the bottom line will be
|
|
* overwritten. There is however a special case that if line 255 is specified,
|
|
* the existing text will scroll up and the new line added to the bottom
|
|
* line of the screen.
|
|
*
|
|
* To install, use the following command in myHal.cpp:
|
|
|
|
* OLEDDisplay::create(address, width, height);
|
|
*
|
|
* where address is the I2C address (0x3c or 0x3d),
|
|
* width is the width in pixels of the display, and
|
|
* height is the height in pixels of the display.
|
|
*
|
|
* Valid width and height are 128x32 (SSD1306 controller),
|
|
* 128x64 (SSD1306) and 132x64 (SH1106). The driver uses
|
|
* a 5x7 character set in a 6x8 pixel cell.
|
|
*/
|
|
|
|
|
|
#ifndef IO_OLEDDISPLAY_H
|
|
#define IO_OLEDDISPLAY_H
|
|
|
|
#include "IODevice.h"
|
|
#include "DisplayInterface.h"
|
|
#include "SSD1306Ascii.h"
|
|
#include "version.h"
|
|
|
|
class OLEDDisplay : public IODevice, DisplayInterface {
|
|
private:
|
|
uint8_t _displayNo = 0;
|
|
// Here we define the device-specific variables.
|
|
uint8_t _height; // in pixels
|
|
uint8_t _width; // in pixels
|
|
SSD1306AsciiWire *oled;
|
|
uint8_t _rowNo = 0; // Row number being written by caller
|
|
uint8_t _colNo = 0; // Position in line being written by caller
|
|
uint8_t _numRows;
|
|
uint8_t _numCols;
|
|
char *_buffer = NULL;
|
|
uint8_t *_rowGeneration = NULL;
|
|
uint8_t *_lastRowGeneration = NULL;
|
|
uint8_t _rowNoToScreen = 0;
|
|
uint8_t _charPosToScreen = 0;
|
|
DisplayInterface *_nextDisplay = NULL;
|
|
uint8_t _selectedDisplayNo = 0;
|
|
|
|
public:
|
|
// Static function to handle "OLEDDisplay::create(...)" calls.
|
|
static void create(I2CAddress i2cAddress, int width = 128, int height=64) {
|
|
/* if (checkNoOverlap(i2cAddress)) */ new OLEDDisplay(0, i2cAddress, width, height);
|
|
}
|
|
static void create(uint8_t displayNo, I2CAddress i2cAddress, int width = 128, int height=64) {
|
|
/* if (checkNoOverlap(i2cAddress)) */ new OLEDDisplay(displayNo, i2cAddress, width, height);
|
|
}
|
|
|
|
protected:
|
|
// Constructor
|
|
OLEDDisplay(uint8_t displayNo, I2CAddress i2cAddress, int width, int height) {
|
|
_displayNo = displayNo;
|
|
_I2CAddress = i2cAddress;
|
|
_width = width;
|
|
_height = height;
|
|
_numCols = (_width+5) / 6; // character block 6 x 8, round up
|
|
_numRows = _height / 8; // Round down
|
|
|
|
_charPosToScreen = _numCols;
|
|
|
|
// Allocate arrays
|
|
_buffer = (char *)calloc(_numRows*_numCols, sizeof(char));
|
|
_rowGeneration = (uint8_t *)calloc(_numRows, sizeof(uint8_t));
|
|
_lastRowGeneration = (uint8_t *)calloc(_numRows, sizeof(uint8_t));
|
|
// Fill buffer with spaces
|
|
memset(_buffer, ' ', _numCols*_numRows);
|
|
|
|
// Is this the main display?
|
|
if (_displayNo == 0) {
|
|
// Set first two lines on screen
|
|
setRow(0);
|
|
print(F("DCC++ EX v"));
|
|
print(F(VERSION));
|
|
setRow(1);
|
|
print(F("Lic GPLv3"));
|
|
}
|
|
|
|
// Create OLED driver
|
|
oled = new SSD1306AsciiWire();
|
|
|
|
// Store pointer to this object into CS display hook, so that we
|
|
// will intercept any subsequent calls to displayHandler methods.
|
|
// Make a note of the existing display reference, to that we can
|
|
// pass on anything we're not interested in.
|
|
_nextDisplay = DisplayInterface::displayHandler;
|
|
DisplayInterface::displayHandler = this;
|
|
|
|
addDevice(this);
|
|
}
|
|
|
|
// Device-specific initialisation
|
|
void _begin() override {
|
|
// Initialise device
|
|
if (oled->begin(_I2CAddress, _width, _height)) {
|
|
|
|
DIAG(F("OLEDDisplay installed on address %s"), _I2CAddress.toString());
|
|
|
|
|
|
// Force all rows to be redrawn
|
|
for (uint8_t row=0; row<_numRows; row++)
|
|
_rowGeneration[row]++;
|
|
|
|
// Start with top line (looks better)
|
|
_rowNoToScreen = _numRows;
|
|
_charPosToScreen = _numCols;
|
|
}
|
|
}
|
|
|
|
void _loop(unsigned long) override {
|
|
//screenUpdate();
|
|
}
|
|
|
|
void screenUpdate() {
|
|
// Loop through the buffer and if a row has changed
|
|
// (rowGeneration[row] is changed) then start writing the
|
|
// characters from the buffer, one character per entry,
|
|
// to the screen until that row has been refreshed.
|
|
|
|
// First check if the OLED driver is still busy from a previous
|
|
// call. If so, don't to anything until the next entry.
|
|
if (!oled->isBusy()) {
|
|
// Check if we've just done the end of a row or just started
|
|
if (_charPosToScreen >= _numCols) {
|
|
// Move to next line
|
|
if (++_rowNoToScreen >= _numRows)
|
|
_rowNoToScreen = 0; // Wrap to first row
|
|
|
|
if (_rowGeneration[_rowNoToScreen] != _lastRowGeneration[_rowNoToScreen]) {
|
|
// Row content has changed, so start outputting it
|
|
_lastRowGeneration[_rowNoToScreen] = _rowGeneration[_rowNoToScreen];
|
|
oled->setRowNative(_rowNoToScreen);
|
|
_charPosToScreen = 0; // Prepare to output first character on next entry
|
|
} else {
|
|
// Row not changed, don't bother writing it.
|
|
}
|
|
} else {
|
|
// output character at current position
|
|
oled->writeNative(_buffer[_rowNoToScreen*_numCols+_charPosToScreen++]);
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
|
|
/////////////////////////////////////////////////
|
|
// DisplayInterface functions
|
|
//
|
|
/////////////////////////////////////////////////
|
|
DisplayInterface* loop2(bool force) override {
|
|
screenUpdate();
|
|
if (_nextDisplay)
|
|
return _nextDisplay->loop2(force); // continue to next display
|
|
return NULL;
|
|
}
|
|
|
|
// Position on nominated line number (0 to number of lines -1)
|
|
// Clear the line in the buffer ready for updating
|
|
// The displayNo referenced here is remembered and any following
|
|
// calls to write() will be directed to that display.
|
|
void setRow(uint8_t displayNo, byte line) override {
|
|
_selectedDisplayNo = displayNo;
|
|
if (displayNo == _displayNo) {
|
|
if (line == 255) {
|
|
// LCD(255,"xxx") or SCREEN(displayNo,255, "xxx") -
|
|
// scroll the contents of the buffer and put the new line
|
|
// at the bottom of the screen
|
|
for (int row=1; row<_numRows; row++) {
|
|
strncpy(&_buffer[(row-1)*_numCols], &_buffer[row*_numCols], _numCols);
|
|
_rowGeneration[row-1]++;
|
|
}
|
|
line = _numRows-1;
|
|
} else if (line >= _numRows)
|
|
line = _numRows - 1; // Overwrite bottom line.
|
|
|
|
_rowNo = line;
|
|
// Fill line with blanks
|
|
for (_colNo = 0; _colNo < _numCols; _colNo++)
|
|
_buffer[_rowNo*_numCols+_colNo] = ' ';
|
|
_colNo = 0;
|
|
// Mark that the buffer has been touched. It will be
|
|
// sent to the screen on the next loop entry, by which time
|
|
// the line should have been written to the buffer.
|
|
_rowGeneration[_rowNo]++;
|
|
|
|
} else if (_nextDisplay)
|
|
_nextDisplay->setRow(displayNo, line); // Pass to next display
|
|
|
|
}
|
|
|
|
// Write one character to the screen referenced in the last setRow() call.
|
|
size_t write(uint8_t c) override {
|
|
if (_selectedDisplayNo == _displayNo) {
|
|
// Write character to buffer (if there's space)
|
|
if (_colNo < _numCols) {
|
|
_buffer[_rowNo*_numCols+_colNo++] = c;
|
|
}
|
|
return 1;
|
|
} else if (_nextDisplay)
|
|
return _nextDisplay->write(c);
|
|
else
|
|
return 0;
|
|
}
|
|
|
|
// Write blanks to all of the screen (blocks until complete)
|
|
void clear (uint8_t displayNo) override {
|
|
if (displayNo == _displayNo) {
|
|
// Clear buffer
|
|
for (_rowNo = 0; _rowNo < _numRows; _rowNo++) {
|
|
setRow(displayNo, _rowNo);
|
|
}
|
|
_rowNo = 0;
|
|
} else if (_nextDisplay)
|
|
_nextDisplay->clear(displayNo); // Pass to next display
|
|
}
|
|
|
|
// Overloads of above, for compatibility
|
|
void setRow(uint8_t line) override {
|
|
setRow(0, line);
|
|
}
|
|
void clear() override {
|
|
clear(0);
|
|
}
|
|
|
|
// Display information about the device.
|
|
void _display() {
|
|
DIAG(F("OLEDDisplay %d Configured addr %s"), _displayNo, _I2CAddress.toString());
|
|
}
|
|
|
|
};
|
|
|
|
#endif // IO_OLEDDISPLAY_H
|