240 lines
7.4 KiB
C
240 lines
7.4 KiB
C
|
|
/** \file
|
|
|
|
\brief Code specific to the SSD1306 display.
|
|
*/
|
|
|
|
/**
|
|
D'oh. Shortly before completing this code, the display hardware died. Shows
|
|
just black, for whatever reason. Accordingly I can't test new code any longer
|
|
and writing code without seeing what it does makes no sense.
|
|
|
|
What already works:
|
|
|
|
- I2C with a queue for small transmissions. Sufficient to queue up sending
|
|
a rendered character. It's filled by displaybus_write() and drained by
|
|
the I2C interrupt. Larger transmissions are handled fine, too, but cause
|
|
wait cycles.
|
|
|
|
- 128 byte queue holding characters to send. This queue is filled by
|
|
display_writechar(). It's drained by display_tick(), which processes,
|
|
renders and forwards these characters to the I2C queue.
|
|
|
|
- Display initialisation.
|
|
|
|
- Clearing the display.
|
|
|
|
- Writing text with display_writestr_P().
|
|
|
|
- Writing formatted text with sendf_P(display_writechar, ...).
|
|
|
|
- Current state of code should clear the display at startup, show a
|
|
greeting message and start displaying current X/Y/Z coordinates, updated
|
|
once per second. All this not in a particularly pretty fashion, but
|
|
working.
|
|
|
|
TODO list:
|
|
|
|
- Lot's of prettification. Like a nice background picture with the Teacup
|
|
logo, like "Welcome to Teacup" as a greeting screen, like writing numbers
|
|
to readable places and so on.
|
|
|
|
- Allow different fonts. Already paraphrased in font.h and font.c. Needs
|
|
a selection menu in Configtool, of course, the same way one can select
|
|
display types.
|
|
|
|
- It's a bit unclear wether this 'last_byte' flag to displaybus_write() is
|
|
really ideal. Fact is, I2C transmissions need a start and an explicite
|
|
ending. Also thinkable would be a displaybus_finalise() function
|
|
which puts the marker in place. Saves a lot of shuffling parameters
|
|
around.
|
|
|
|
Yet another option would be to make sure the I2C send buffer is drained
|
|
befpre sending the next transmission. I2C code already finalises a
|
|
transmission on buffer drain, so only _reliable_ waiting needs an
|
|
implementation.
|
|
|
|
Each variant needs testing, which one gets away with the smallest code.
|
|
Smallest code is likely the fastest code as well.
|
|
|
|
- Here's an assistant to convert pictures/bitmaps into C code readable by
|
|
the compiler: http://en.radzio.dxp.pl/bitmap_converter/
|
|
*/
|
|
|
|
#include "display.h"
|
|
|
|
#if defined TEACUP_C_INCLUDE && defined DISPLAY_TYPE_SSD1306
|
|
|
|
#include "displaybus.h"
|
|
#include "font.h"
|
|
#include "sendf.h"
|
|
#include "delay.h"
|
|
#include "dda.h"
|
|
|
|
|
|
static const uint8_t PROGMEM init_sequence[] = {
|
|
0x00, // Command marker.
|
|
0xAE, // Display off.
|
|
0xD5, 0x80, // Display clock divider (reset).
|
|
0xA8, 0x1F, // 1/32 duty.
|
|
0x40 | 0x00, // Start line (reset).
|
|
0x20, 0x02, // Page addressing mode (reset).
|
|
0x22, 0x00, 0x03, // Start and end page in horiz./vert. addressing mode[1].
|
|
0x21, 0x00, 0x7F, // Start and end column in horiz./vert. addressing mode.
|
|
0xA0 | 0x00, // No segment remap (reset).
|
|
0xC0 | 0x00, // Normal com pins mapping (reset).
|
|
0xDA, 0x02, // Sequental without remap com pins.
|
|
0x81, 0x7F, // Contrast (reset).
|
|
0xDB, 0x20, // Vcomh (reset).
|
|
0xD9, 0xF1, // Precharge period.
|
|
0x8D, 0x14, // Charge pump.
|
|
0xA6, // Positive display.
|
|
0xA4, // Resume display.
|
|
0xAF // Display on.
|
|
};
|
|
// [1] Do not set this to 0x00..0x07 on a 32 pixel high display, or vertical
|
|
// addressing mode will mess up. 32 pixel high displays have only 4 pages
|
|
// (0..3), still addressing logic accepts, but can't deal with the 0..7
|
|
// meant for 64 pixel high displays.
|
|
|
|
/**
|
|
* Initializes the display's controller configuring the way of
|
|
* displaying data.
|
|
*/
|
|
void display_init(void) {
|
|
uint8_t i;
|
|
|
|
displaybus_init(DISPLAY_I2C_ADDRESS);
|
|
|
|
for (i = 0; i < sizeof(init_sequence); i++) {
|
|
// Send last byte with 'last_byte' set.
|
|
displaybus_write(init_sequence[i], (i == sizeof(init_sequence) - 1));
|
|
}
|
|
}
|
|
|
|
/**
|
|
Show a nice greeting. Pure eye candy.
|
|
*/
|
|
void display_greeting(void) {
|
|
|
|
display_clear();
|
|
|
|
/**
|
|
"Welcome to Teacup" is 64 pixel columns wide, entire display is
|
|
128 columns, so we offset by 32 columns to get it to the center.
|
|
*/
|
|
display_set_cursor(1, 32);
|
|
|
|
display_writestr_P(PSTR("Welcome to Teacup"));
|
|
|
|
// Forward this to the display immediately.
|
|
while (buf_canread(display)) {
|
|
display_tick();
|
|
}
|
|
|
|
// Allow the user to worship our work for a moment :-)
|
|
delay_ms(5000);
|
|
}
|
|
|
|
/**
|
|
Regular update of the display. Typically called once a second from clock.c.
|
|
*/
|
|
void display_clock(void) {
|
|
|
|
display_set_cursor(0, 2);
|
|
update_current_position();
|
|
sendf_P(display_writechar, PSTR("X:%lq Y:%lq Z:%lq F:%lu "),
|
|
current_position.axis[X], current_position.axis[Y],
|
|
current_position.axis[Z], current_position.F);
|
|
}
|
|
|
|
/**
|
|
Forwards a character or a control command from the display queue to the I2C
|
|
queue.
|
|
*/
|
|
void display_tick() {
|
|
uint16_t i, data, index;
|
|
|
|
if (displaybus_busy()) {
|
|
return;
|
|
}
|
|
|
|
/**
|
|
Possible strategy for error recovery: after a failed, aborted I2C
|
|
transmisson, 'i2c_state & I2C_INTERRUPTED' in i2c.c evaluates to true.
|
|
|
|
Having a getter like displaybus_failed() would allow to test this condition
|
|
here, so we could resend the previous data again, instead of grabbing a
|
|
new byte from the buffer.
|
|
*/
|
|
|
|
if (buf_canread(display)) {
|
|
buf_pop(display, data);
|
|
switch (data) {
|
|
case low_code_clear:
|
|
/**
|
|
Clear the screen. As this display supports many sophisticated
|
|
commands, but not a simple 'clear', we have to overwrite the entire
|
|
memory with zeros, byte by byte.
|
|
*/
|
|
// Set horizontal adressing mode.
|
|
displaybus_write(0x00, 0);
|
|
displaybus_write(0x20, 0);
|
|
displaybus_write(0x00, 1);
|
|
|
|
// Write 512 zeros.
|
|
displaybus_write(0x40, 0);
|
|
for (i = 0; i < 512; i++) {
|
|
displaybus_write(0x00, (i == 511));
|
|
}
|
|
|
|
// Return to page adressing mode.
|
|
displaybus_write(0x00, 0);
|
|
displaybus_write(0x20, 0);
|
|
displaybus_write(0x02, 1);
|
|
break;
|
|
|
|
case low_code_set_cursor:
|
|
/**
|
|
Set the cursor to the given position.
|
|
|
|
This is a three-byte control command, so we fetch additional bytes
|
|
from the queue and cross fingers they're actually there.
|
|
*/
|
|
// Enter command mode.
|
|
displaybus_write(0x00, 0);
|
|
// Set line.
|
|
buf_pop(display, data);
|
|
displaybus_write(0xB0 | (data & 0x03), 0);
|
|
// Set column.
|
|
buf_pop(display, data);
|
|
displaybus_write(0x00 | (data & 0x0F), 0);
|
|
displaybus_write(0x10 | ((data >> 4) & 0x0F), 1);
|
|
break;
|
|
|
|
default:
|
|
// Should be a printable character.
|
|
index = data - 0x20;
|
|
|
|
// Write pixels command.
|
|
displaybus_write(0x40, 0);
|
|
|
|
// Send the character bitmap.
|
|
#ifdef FONT_IS_PROPORTIONAL
|
|
for (i = 0; i < pgm_read_byte(&font[index].columns); i++) {
|
|
#else
|
|
for (i = 0; i < FONT_COLUMNS; i++) {
|
|
#endif
|
|
displaybus_write(pgm_read_byte(&font[index].data[i]), 0);
|
|
}
|
|
// Send space between characters.
|
|
for (i = 0; i < FONT_SYMBOL_SPACE; i++) {
|
|
displaybus_write(0x00, (i == FONT_SYMBOL_SPACE - 1));
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
#endif /* TEACUP_C_INCLUDE && DISPLAY_TYPE_SSD1306 */
|