| 
| 
  | Ssd1306 (uint8_t address=0x3C) | 
|   | 
| 
bool  | pingBlocking () | 
|   | Pings the display. 
  | 
|   | 
| 
bool  | initializeBlocking () | 
|   | initializes for 3V3 with charge-pump 
  | 
|   | 
| 
void  | update () override | 
|   | Update the display with the content of the RAM buffer. 
  | 
|   | 
| bool  | isWritable () | 
|   | 
| 
bool  | initialize () | 
|   | initializes for 3V3 with charge-pump asynchronously 
  | 
|   | 
| 
virtual bool  | writeDisplay () | 
|   | 
| 
bool  | setDisplayMode (DisplayMode mode=DisplayMode::Normal) | 
|   | 
| 
bool  | setContrast (uint8_t contrast=0xCE) | 
|   | 
| bool  | setOrientation (glcd::Orientation orientation) | 
|   | 
| 
bool  | configureScroll (uint8_t origin, uint8_t size, ScrollDirection direction, ScrollStep steps) | 
|   | 
| 
bool  | enableScroll () | 
|   | 
| 
bool  | disableScroll () | 
|   | 
| 
IOStream &  | ascii () | 
|   | set the output mode to ASCII style for integer types 
  | 
|   | 
| 
IOStream &  | bin () | 
|   | set the output mode to binary style for integer types 
  | 
|   | 
| void  | clear () final | 
|   | 
| void  | clearPixel (int16_t x, int16_t y) final | 
|   | 
| void  | clearPixel (glcd::Point p) | 
|   | 
| void  | drawCircle (glcd::Point center, uint16_t radius) | 
|   | 
| void  | drawEllipse (glcd::Point center, int16_t rx, int16_t ry) | 
|   | 
| void  | drawImage (glcd::Point start, modm::accessor::Flash< uint8_t > image) | 
|   | 
| void  | drawImageRaw (glcd::Point start, uint16_t width, uint16_t height, modm::accessor::Flash< uint8_t > data) final | 
|   | 
| void  | drawLine (glcd::Point start, glcd::Point end) | 
|   | 
| void  | drawLine (int16_t x1, int16_t y1, int16_t x2, int16_t y2) | 
|   | 
| void  | drawRectangle (glcd::Point start, uint16_t width, uint16_t height) | 
|   | 
| void  | drawRectangle (int16_t x, int16_t y, uint16_t width, uint16_t height) | 
|   | 
| void  | drawRoundedRectangle (glcd::Point start, uint16_t width, uint16_t height, uint16_t radius) | 
|   | 
| 
IOStream &  | endl () | 
|   | 
| virtual void  | fillCircle (glcd::Point center, uint16_t radius) | 
|   | 
| void  | fillRectangle (glcd::Point start, uint16_t width, uint16_t height) | 
|   | 
| void  | fillRectangle (int16_t x, int16_t y, uint16_t width, uint16_t height) | 
|   | 
| 
IOStream &  | flush () | 
|   | 
| 
IOStream &  | get (char &c) | 
|   | Reads one character and returns it if available. Otherwise, returns IOStream::eof. 
  | 
|   | 
| IOStream &  | get (char *s, size_t n) | 
|   | 
| 
template<size_t N>  | 
| IOStream &  | get (char (&s)[N]) | 
|   | 
| std::size_t  | getBufferHeight () const final | 
|   | 
| std::size_t  | getBufferWidth () const final | 
|   | 
| 
glcd::Point  | getCursor () const | 
|   | 
| uint8_t  | getFontHeight () const | 
|   | 
| uint16_t  | getHeight () const final | 
|   | 
| 
bool  | getPixel (int16_t x, int16_t y) const final | 
|   | 
| uint16_t  | getStringWidth (const char *s) const | 
|   | 
| uint16_t  | getWidth () const final | 
|   | 
| 
IOStream &  | hex () | 
|   | set the output mode to hexadecimal style for integer types 
  | 
|   | 
| 
IOStream &  | operator<< (const bool &v) | 
|   | 
| 
IOStream &  | operator<< (const char &v) | 
|   | 
| 
IOStream &  | operator<< (const uint8_t &v) | 
|   | 
| 
IOStream &  | operator<< (const int16_t &v) | 
|   | 
| 
IOStream &  | operator<< (const uint16_t &v) | 
|   | 
| 
IOStream &  | operator<< (const int32_t &v) | 
|   | 
| 
IOStream &  | operator<< (const uint32_t &v) | 
|   | 
| 
IOStream &  | operator<< (const char *s) | 
|   | 
| 
IOStream &  | operator<< (const std::string_view sv) | 
|   | 
| 
IOStream &  | operator<< (const void *p) | 
|   | write the hex value of a pointer 
  | 
|   | 
| 
template<class Ret , class... Args>  | 
| IOStream &  | operator<< (Ret (*pointer)(Args...)) | 
|   | Write the hex value of any function pointer. 
  | 
|   | 
| 
IOStream &  | operator<< (IOStream &(*format)(IOStream &)) | 
|   | 
| void  | setCursor (glcd::Point position) | 
|   | 
| void  | setCursor (int16_t x, int16_t y) | 
|   | 
| void  | setCursorX (int16_t x) | 
|   | 
| void  | setCursorY (int16_t y) | 
|   | 
| void  | setFont (const uint8_t *newFont) | 
|   | 
| 
void  | setFont (const modm::accessor::Flash< uint8_t > *font) | 
|   | 
| void  | setPixel (int16_t x, int16_t y) final | 
|   | 
| void  | setPixel (glcd::Point p) | 
|   | 
| virtual void  | update () = 0 | 
|   | 
| void  | write (char c) | 
|   | 
| void  | attachConfigurationHandler (I2c::ConfigurationHandler handler) | 
|   | 
| bool  | ping () | 
|   | 
| 
bool  | read (uint8_t *buffer, std::size_t size) | 
|   | Starts a write transaction and waits until finished. 
  | 
|   | 
| void  | setAddress (uint8_t address) | 
|   | 
| 
bool  | write (const uint8_t *buffer, std::size_t size) | 
|   | Starts a write transaction and waits until finished. 
  | 
|   | 
| 
bool  | writeRead (const uint8_t *writeBuffer, std::size_t writeSize, uint8_t *readBuffer, std::size_t readSize) | 
|   | Starts a write-read transaction and waits until finished. 
  | 
|   | 
 | 
| enum   | AdressingCommands : uint8_t {  
  MemoryMode = 0x20, 
ColumnAddress = 0x21, 
PageAddress = 0x22, 
PageStartAddress = 0xB0, 
 
  LowerColumnStartAddress = 0x00, 
HigherColumnStartAddress = 0x10
 
 } | 
|   | 
| enum   | ChargePump : uint8_t { DISABLE = 0x00, 
V7_5 = 0x14, 
V8_5 = 0x94, 
V9 = 0x95
 } | 
|   | 
| enum   | FundamentalCommands : uint8_t {  
  ContrastControl = 0x81, 
EntireDisplayResumeToRam = 0xA4, 
EntireDisplayIgnoreRam = 0xA5, 
NormalDisplay = 0xA6, 
 
  InvertedDisplay = 0xA7, 
DisplayOff = 0xAE, 
DisplayOn = 0xAF
 
 } | 
|   | 
| enum   | HardwareConfigCommands : uint8_t {  
  DisplayStartLine = 0x40, 
SegmentRemap0 = 0xA0, 
SegmentRemap127 = 0xA1, 
MultiplexRatio = 0xA8, 
 
  ComOutputScanDirectionIncrement = 0xC0, 
ComOutputScanDirectionDecrement = 0xC8, 
DisplayOffset = 0xD3, 
ComPinsOrder = 0xDA
 
 } | 
|   | 
| enum   | MemoryMode : uint8_t { HORIZONTAL = 0, 
VERTICAL = 1, 
PAGE = 2
 } | 
|   | 
| enum   | ScrollingCommands : uint8_t {  
  HorizontalScrollRight = 0x26, 
HorizontalScrollLeft = 0x27, 
VerticalAndHorizontalScrollRight = 0x29, 
VerticalAndHorizontalScrollLeft = 0x2A, 
 
  VerticalScrollArea = 0xA3, 
DisableScroll = 0x2E, 
EnableScroll = 0x2F
 
 } | 
|   | 
| enum   | TimingAndDrivingCommands : uint8_t {  
  ChargePump = 0x8D, 
DisplayClockDivideRatio = 0xD5, 
PreChargePeriod = 0xD9, 
V_DeselectLevel = 0xDB, 
 
  Nop = 0xE3
 
 } | 
|   | 
| enum   | Transfer : uint8_t { COMMAND_BURST = 0x00, 
DATA_BURST = 0x40, 
COMMAND = 0x80, 
DATA = 0xC0
 } | 
|   | 
 | 
| 
bool  | writeCommands (std::size_t length) | 
|   | 
| 
virtual void  | initializeMemoryMode () | 
|   | 
| 
virtual void  | startWriteDisplay () | 
|   | 
| 
void  | drawCircle4 (glcd::Point center, int16_t x, int16_t y) | 
|   | helper method for drawCircle() and drawEllipse() 
  | 
|   | 
| 
void  | drawHorizontalLine (glcd::Point start, uint16_t length) final | 
|   | 
| 
void  | drawVerticalLine (glcd::Point start, uint16_t length) final | 
|   | 
| 
void  | writeBin (uint8_t value) | 
|   | 
| 
void  | writeHex (uint8_t value) | 
|   | 
| 
void  | writeInteger (int16_t value) | 
|   | 
| 
void  | writeInteger (uint16_t value) | 
|   | 
| 
void  | writeInteger (int32_t value) | 
|   | 
| 
void  | writeInteger (uint32_t value) | 
|   | 
| 
template<typename T >  | 
| void  | writeIntegerMode (const T v) | 
|   | 
| 
void  | writePointer (const void *value) | 
|   | 
| bool  | isTransactionRunning () | 
|   | 
| 
bool  | runTransaction () | 
|   | Starts our own transaction and waits until finished. 
  | 
|   | 
| 
bool  | startTransaction () | 
|   | Starts the transaction with our own transaction object. 
  | 
|   | 
| 
bool  | startTransaction (modm::I2cTransaction *transaction) | 
|   | Starts the transaction with a separate transaction object. 
  | 
|   | 
| bool  | wasTransactionSuccessful () | 
|   | 
template<class I2cMaster, uint8_t Height = 64>
class modm::ssd1306< I2cMaster, Height >
Driver for SSD1306 based OLED-displays using I2C. This display is only rated to be driven with 400kHz, which limits the frame rate to about 40Hz.
- Author
 - Niklas Hauser 
 
- 
Thomas Sommer