1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
|
/*********************************************************************
This is a library for our Monochrome OLEDs based on SSD1306 drivers
Pick one up today in the adafruit shop!
------> http://www.adafruit.com/category/63_98
These displays use SPI to communicate, 4 or 5 pins are required to
interface
Adafruit invests time and resources providing this open source code,
please support Adafruit and open-source hardware by purchasing
products from Adafruit!
Written by Limor Fried/Ladyada for Adafruit Industries.
BSD license, check license.txt for more information
All text above, and the splash screen must be included in any redistribution
*********************************************************************/
/*
* Modified by Neal Horman 7/14/2012 for use in mbed
*/
#ifndef _ADAFRUIT_SSD1306_H_
#define _ADAFRUIT_SSD1306_H_
#include "mbed.h"
#include "Adafruit_GFX.h"
#include <vector>
#include <algorithm>
// A DigitalOut sub-class that provides a constructed default state
class DigitalOut2 : public DigitalOut
{
public:
DigitalOut2(PinName pin, bool active = false) : DigitalOut(pin) { write(active); };
DigitalOut2& operator= (int value) { write(value); return *this; };
DigitalOut2& operator= (DigitalOut2& rhs) { write(rhs.read()); return *this; };
operator int() { return read(); };
};
#define SSD1306_EXTERNALVCC 0x1
#define SSD1306_SWITCHCAPVCC 0x2
/** The pure base class for the SSD1306 display driver.
*
* You should derive from this for a new transport interface type,
* such as the SPI and I2C drivers.
*/
class Adafruit_SSD1306 : public Adafruit_GFX
{
public:
Adafruit_SSD1306(PinName RST, uint8_t rawHeight = 32, uint8_t rawWidth = 128)
: Adafruit_GFX(rawWidth,rawHeight)
, rst(RST,false)
{
buffer.resize(rawHeight * rawWidth / 8);
};
void begin(uint8_t switchvcc = SSD1306_SWITCHCAPVCC);
// These must be implemented in the derived transport driver
virtual void command(uint8_t c) = 0;
virtual void data(uint8_t c) = 0;
virtual void drawPixel(int16_t x, int16_t y, uint16_t color);
/// Clear the display buffer
void clearDisplay(void);
virtual void invertDisplay(bool i);
/// Cause the display to be updated with the buffer content.
void display();
/// Fill the buffer with the AdaFruit splash screen.
virtual void splash();
protected:
virtual void sendDisplayBuffer() = 0;
DigitalOut2 rst;
// the memory buffer for the LCD
std::vector<uint8_t> buffer;
};
/** This is the SPI SSD1306 display driver transport class
*
*/
class Adafruit_SSD1306_Spi : public Adafruit_SSD1306
{
public:
/** Create a SSD1306 SPI transport display driver instance with the specified DC, RST, and CS pins, as well as the display dimentions
*
* Required parameters
* @param spi - a reference to an initialized SPI object
* @param DC (Data/Command) pin name
* @param RST (Reset) pin name
* @param CS (Chip Select) pin name
*
* Optional parameters
* @param rawHeight - the vertical number of pixels for the display, defaults to 32
* @param rawWidth - the horizonal number of pixels for the display, defaults to 128
*/
Adafruit_SSD1306_Spi(SPI &spi, PinName DC, PinName RST, PinName CS, uint8_t rawHieght = 32, uint8_t rawWidth = 128)
: Adafruit_SSD1306(RST, rawHieght, rawWidth)
, cs(CS,true)
, dc(DC,false)
, mspi(spi)
{
begin();
splash();
display();
};
virtual void command(uint8_t c)
{
cs = 1;
dc = 0;
cs = 0;
mspi.write(c);
cs = 1;
};
virtual void data(uint8_t c)
{
cs = 1;
dc = 1;
cs = 0;
mspi.write(c);
cs = 1;
};
protected:
virtual void sendDisplayBuffer()
{
cs = 1;
dc = 1;
cs = 0;
for(uint16_t i=0, q=buffer.size(); i<q; i++)
mspi.write(buffer[i]);
if(height() == 32)
{
for(uint16_t i=0, q=buffer.size(); i<q; i++)
mspi.write(0);
}
cs = 1;
};
DigitalOut2 cs, dc;
SPI &mspi;
};
/** This is the I2C SSD1306 display driver transport class
*
*/
class Adafruit_SSD1306_I2c : public Adafruit_SSD1306
{
public:
#define SSD_I2C_ADDRESS 0x78
/** Create a SSD1306 I2C transport display driver instance with the specified RST pin name, the I2C address, as well as the display dimensions
*
* Required parameters
* @param i2c - A reference to an initialized I2C object
* @param RST - The Reset pin name
*
* Optional parameters
* @param i2cAddress - The i2c address of the display
* @param rawHeight - The vertical number of pixels for the display, defaults to 32
* @param rawWidth - The horizonal number of pixels for the display, defaults to 128
*/
Adafruit_SSD1306_I2c(I2C &i2c, PinName RST, uint8_t i2cAddress = SSD_I2C_ADDRESS, uint8_t rawHeight = 32, uint8_t rawWidth = 128)
: Adafruit_SSD1306(RST, rawHeight, rawWidth)
, mi2c(i2c)
, mi2cAddress(i2cAddress)
{
begin();
splash();
display();
};
virtual void command(uint8_t c)
{
char buff[2];
buff[0] = 0; // Command Mode
buff[1] = c;
mi2c.write(mi2cAddress, buff, sizeof(buff));
}
virtual void data(uint8_t c)
{
char buff[2];
buff[0] = 0x40; // Data Mode
buff[1] = c;
mi2c.write(mi2cAddress, buff, sizeof(buff));
};
protected:
virtual void sendDisplayBuffer()
{
char buff[17];
buff[0] = 0x40; // Data Mode
// send display buffer in 16 byte chunks
for(uint16_t i=0, q=buffer.size(); i<q; i+=16 )
{ uint8_t x ;
// TODO - this will segfault if buffer.size() % 16 != 0
for(x=1; x<sizeof(buff); x++)
buff[x] = buffer[i+x-1];
mi2c.write(mi2cAddress, buff, sizeof(buff));
}
};
I2C &mi2c;
uint8_t mi2cAddress;
};
#endif
|
