ErikZalm
12 years ago
120 changed files with 113639 additions and 2162 deletions
@ -0,0 +1,114 @@ |
|||
|
|||
u8glib ChangeLog |
|||
|
|||
2012-01-01 v0.01 Oliver Kraus <olikraus@gmail.com> |
|||
* first beta release for Arduino IDE with simple SSD1325 support |
|||
2012-01-04 v0.02 Oliver Kraus <olikraus@gmail.com> |
|||
* support for some more display types |
|||
2012-01-07 v0.03 Oliver Kraus <olikraus@gmail.com> |
|||
* fixed some bugs, added more examples |
|||
2012-01-07 v0.04 Oliver Kraus <olikraus@gmail.com> |
|||
* single font file |
|||
2012-01-08 v0.05 Oliver Kraus <olikraus@gmail.com> |
|||
* Cleanup |
|||
* More examples |
|||
* SSD1325 graylevel support |
|||
2012-01-15 v0.06 Oliver Kraus <olikraus@gmail.com> |
|||
* LM6063 support |
|||
2012-01-17 v0.07 Oliver Kraus <olikraus@gmail.com> |
|||
* LM6063 support (update) |
|||
2012-01-19 v0.08 Oliver Kraus <olikraus@gmail.com> |
|||
* ST7920 beta device |
|||
2012-01-21 v0.09 Oliver Kraus <olikraus@gmail.com> |
|||
* ST7920 fixed (192x32) |
|||
* fixed bug in com layer if pins are none |
|||
* str reference position |
|||
2012-01-22 v0.10 Oliver Kraus <olikraus@gmail.com> |
|||
* Experimental LM6059 |
|||
2012-01-24 v0.11 Oliver Kraus <olikraus@gmail.com> |
|||
* new st7920 memory layout for 128x64 lcd |
|||
* experimental st7920 SPI |
|||
2012-01-25 v0.12 Oliver Kraus <olikraus@gmail.com> |
|||
* fixed st7920 memory layout for 128x64 lcd |
|||
* ST7920 SPI performance improvement |
|||
2012-01-27 v0.13 Oliver Kraus <olikraus@gmail.com> |
|||
* LM6059 (Adafruit Display) fixed |
|||
2012-02-01 v0.14 Oliver Kraus <olikraus@gmail.com> |
|||
* undoRotation() |
|||
* setRot..() can be used without restrictions |
|||
* Class U8GLIB derived from Print class. New function "print" |
|||
* Fixed memory index bug in the page management procedures |
|||
2012-02-12 v1.00 Oliver Kraus <olikraus@gmail.com> |
|||
* XBM support |
|||
* F() macro support |
|||
* str-rotation commands support ref-height and ref-position |
|||
2012-03-17 v1.02 Oliver Kraus <olikraus@gmail.com> |
|||
* U8GLIB_ST7687_C144MVGD spi experimental |
|||
* U8GLIB_LC7981_160X80 8bit |
|||
* Intersection test for frame and box procedures |
|||
* 4L double memory architecture |
|||
* setContrast infrastructure implemented, but not available for all devices |
|||
* drawCircle, drawDisc |
|||
* Bugfix for drawStr270 |
|||
* New examples: Chess (ported from dogm128 lib) and GraphicsTest |
|||
2012-03-31 v1.03 Oliver Kraus <olikraus@gmail.com> |
|||
* experimental parallel mode atmega |
|||
* more unifont code pages |
|||
* double memory, for NHD OLED and DOGXL160 |
|||
* "Menu" example |
|||
* drawLine |
|||
2012-04-13 v1.04 Oliver Kraus <olikraus@gmail.com> |
|||
* Adjust U8grelease: Same version number with AVR and Arduino variant |
|||
2012-06-10 v1.05 Oliver Kraus <olikraus@gmail.com> |
|||
* m2icon font |
|||
* experimental lc7981_240x64 device |
|||
* experimental ssd1306 |
|||
* experimental ssd1322 |
|||
* Hardware state backup/restore procedure |
|||
2012-06-15 v1.06 Oliver Kraus <olikraus@gmail.com> |
|||
* SBN1661 (SED1520?) support |
|||
* SSD1306 support |
|||
* U8G_PROGMEM bugfix |
|||
2012-07-04 v1.07 Oliver Kraus <olikraus@gmail.com> |
|||
* Added Makefiles for AVR release (issue 77) |
|||
* Fixed examples for Arduino Environment (issue 78) |
|||
2012-10-02 v1.08 Oliver Kraus <olikraus@gmail.com> |
|||
* Improved delay calculation for strobe pulse (issue 20) |
|||
* Support Chipkit (issue 39) |
|||
* Improved speed for ST7920 parallel mode (issue 79) |
|||
* Overall speed optimization (new page intersection algorithm) |
|||
* Support for Displays Newhaven NHD-C12864, CrystalFontz GFAG20232, Seeedstudio 96x96 OLED |
|||
* Added SPI support for ST7920 with plain AVR (issue 85) |
|||
* Add more LC7981 devices |
|||
2012-12-23 v1.09 Oliver Kraus <olikraus@gmail.com> |
|||
* Support for Displaytech 64128n |
|||
* Support for MINI12864 |
|||
* HW SPI for ST7920 |
|||
* Add delay after sending a byte with (ST7920 com) |
|||
* Support ATTiny |
|||
* Support I2C for SSD1306 |
|||
* bdf2u8g, Windows executable released |
|||
* LC7981 320x64 |
|||
* Scalue up: u8g::setScale2x2 |
|||
* Added more bitmap fonts |
|||
* u8g::drawRBox(), u8g::drawRFrame() |
|||
* Support for CFAG20232 (st7920_202x32) |
|||
* Fixed ST7920 SW SPI for ChipKit |
|||
* Support for tls8204 |
|||
2013-02-02 v1.10 Oliver Kraus <olikraus@gmail.com> |
|||
* Support for SSD1309 |
|||
* Support for NHD-C12832A1Z |
|||
* Bugfix: Fixed reset controll in parallel modes |
|||
* Bugfix: Fixed calculation of cursor position |
|||
* Bugfix: ST7920 parallel mode |
|||
2013-03-2 v1.11 Oliver Kraus <olikraus@gmail.com> |
|||
* Support for T6963 |
|||
* Support for Arduino Due |
|||
* Sleep Mode |
|||
* 4x mode for ST7920 |
|||
* New C++ interface for ST7920 |
|||
|
|||
|
|||
|
|||
|
|||
|
|||
@ -0,0 +1,21 @@ |
|||
|
|||
U8GLIB |
|||
http://code.google.com/p/u8glib/ |
|||
|
|||
|
|||
Install instructions for the Arduino environment. |
|||
|
|||
1. Unzip u8glib_arduino_vX.XX.zip into the "libraries" folder |
|||
2. Start Arduino IDE |
|||
|
|||
Install instructions for the Chipkit (Arduino) environment. |
|||
|
|||
1. cd <mpide-... path>/libraries |
|||
2. unzip u8glib_arduino_vX.XX.zip |
|||
3. cd <mpide-... path>///hardware/pic32/libraries |
|||
4. again: u8glib_arduino_vX.XX.zip |
|||
5. Open hardware/pic32/cores/pic32/Print.h |
|||
Remove line |
|||
#define BYTE 0 |
|||
from the file, use PRINT_BYTE instead of BYTE. |
|||
|
|||
@ -0,0 +1,80 @@ |
|||
/*
|
|||
|
|||
U8glib.cpp |
|||
|
|||
C++ Interface |
|||
|
|||
Universal 8bit Graphics Library |
|||
|
|||
Copyright (c) 2011, olikraus@gmail.com |
|||
All rights reserved. |
|||
|
|||
Redistribution and use in source and binary forms, with or without modification, |
|||
are permitted provided that the following conditions are met: |
|||
|
|||
* Redistributions of source code must retain the above copyright notice, this list |
|||
of conditions and the following disclaimer. |
|||
|
|||
* Redistributions in binary form must reproduce the above copyright notice, this |
|||
list of conditions and the following disclaimer in the documentation and/or other |
|||
materials provided with the distribution. |
|||
|
|||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
|||
CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
|||
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
|||
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
|||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
|||
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
|||
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
|||
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
|||
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
|||
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF |
|||
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|||
|
|||
*/ |
|||
|
|||
#include "U8glib.h" |
|||
|
|||
|
|||
|
|||
uint8_t U8GLIB::initSPI(u8g_dev_t *dev, uint8_t sck, uint8_t mosi, uint8_t cs, uint8_t a0, uint8_t reset) |
|||
{ |
|||
prepare(); |
|||
return u8g_InitSPI(&u8g, dev, sck, mosi, cs, a0, reset); |
|||
} |
|||
|
|||
uint8_t U8GLIB::initHWSPI(u8g_dev_t *dev, uint8_t cs, uint8_t a0, uint8_t reset) |
|||
{ |
|||
prepare(); |
|||
return u8g_InitHWSPI(&u8g, dev, cs, a0, reset); |
|||
} |
|||
|
|||
uint8_t U8GLIB::initI2C(u8g_dev_t *dev, uint8_t options) |
|||
{ |
|||
prepare(); |
|||
return u8g_InitI2C(&u8g, dev, options); |
|||
} |
|||
|
|||
uint8_t U8GLIB::init8Bit(u8g_dev_t *dev, uint8_t d0, uint8_t d1, uint8_t d2, uint8_t d3, uint8_t d4, uint8_t d5, uint8_t d6, uint8_t d7, |
|||
uint8_t en, uint8_t cs1, uint8_t cs2, uint8_t di, uint8_t rw, uint8_t reset) |
|||
{ |
|||
prepare(); |
|||
return u8g_Init8Bit(&u8g, dev, d0, d1, d2, d3, d4, d5, d6, d7, en, cs1, cs2, di, rw, reset); |
|||
} |
|||
|
|||
uint8_t U8GLIB::init8BitFixedPort(u8g_dev_t *dev, uint8_t en, uint8_t cs, uint8_t di, uint8_t rw, uint8_t reset) |
|||
{ |
|||
prepare(); |
|||
return u8g_Init8BitFixedPort(&u8g, dev, en, cs, di, rw, reset); |
|||
} |
|||
|
|||
uint8_t U8GLIB::initRW8Bit(u8g_dev_t *dev, uint8_t d0, uint8_t d1, uint8_t d2, uint8_t d3, uint8_t d4, uint8_t d5, uint8_t d6, uint8_t d7, |
|||
uint8_t cs, uint8_t a0, uint8_t wr, uint8_t rd, uint8_t reset) |
|||
{ |
|||
prepare(); |
|||
return u8g_InitRW8Bit(&u8g, dev, d0, d1, d2, d3, d4, d5, d6, d7, cs, a0, wr, rd, reset); |
|||
} |
|||
|
|||
|
|||
@ -0,0 +1,826 @@ |
|||
/*
|
|||
|
|||
U8glib.h |
|||
|
|||
C++ Interface |
|||
|
|||
Universal 8bit Graphics Library |
|||
|
|||
Copyright (c) 2011, olikraus@gmail.com |
|||
All rights reserved. |
|||
|
|||
Redistribution and use in source and binary forms, with or without modification, |
|||
are permitted provided that the following conditions are met: |
|||
|
|||
* Redistributions of source code must retain the above copyright notice, this list |
|||
of conditions and the following disclaimer. |
|||
|
|||
* Redistributions in binary form must reproduce the above copyright notice, this |
|||
list of conditions and the following disclaimer in the documentation and/or other |
|||
materials provided with the distribution. |
|||
|
|||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
|||
CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
|||
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
|||
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
|||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
|||
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
|||
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
|||
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
|||
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
|||
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF |
|||
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|||
|
|||
*/ |
|||
|
|||
#ifndef _CPP_U8GLIB |
|||
#define _CPP_U8GLIB |
|||
|
|||
#include <Print.h> |
|||
#include "utility/u8g.h" |
|||
|
|||
|
|||
class U8GLIB : public Print |
|||
{ |
|||
private: |
|||
u8g_t u8g; |
|||
u8g_uint_t tx, ty; // current position for the Print base class procedures
|
|||
uint8_t is_begin; |
|||
|
|||
void prepare(void) { tx = 0; ty = 0; is_begin = 0; } |
|||
void cbegin(void) { if ( is_begin == 0 ) { is_begin = 1; u8g_Begin(&u8g); } } |
|||
uint8_t initSPI(u8g_dev_t *dev, uint8_t sck, uint8_t mosi, uint8_t cs, uint8_t a0, uint8_t reset = U8G_PIN_NONE); |
|||
uint8_t initHWSPI(u8g_dev_t *dev, uint8_t cs, uint8_t a0, uint8_t reset = U8G_PIN_NONE); |
|||
uint8_t initI2C(u8g_dev_t *dev, uint8_t options); |
|||
protected: |
|||
uint8_t init8BitFixedPort(u8g_dev_t *dev, uint8_t en, uint8_t cs, uint8_t di, uint8_t rw, uint8_t reset); |
|||
private: |
|||
uint8_t init8Bit(u8g_dev_t *dev, uint8_t d0, uint8_t d1, uint8_t d2, uint8_t d3, uint8_t d4, uint8_t d5, uint8_t d6, uint8_t d7, |
|||
uint8_t en, uint8_t cs1, uint8_t cs2, uint8_t di, uint8_t rw = U8G_PIN_NONE, uint8_t reset = U8G_PIN_NONE); |
|||
uint8_t initRW8Bit(u8g_dev_t *dev, uint8_t d0, uint8_t d1, uint8_t d2, uint8_t d3, uint8_t d4, uint8_t d5, uint8_t d6, uint8_t d7, |
|||
uint8_t cs, uint8_t a0, uint8_t wr, uint8_t rd, uint8_t reset); |
|||
public: |
|||
|
|||
/* constructor */ |
|||
U8GLIB(void) |
|||
{ } |
|||
U8GLIB(u8g_dev_t *dev) |
|||
{ prepare(); u8g_Init(&u8g, dev); } |
|||
U8GLIB(u8g_dev_t *dev, uint8_t sck, uint8_t mosi, uint8_t cs, uint8_t a0, uint8_t reset) |
|||
{ initSPI(dev, sck, mosi, cs, a0, reset); } |
|||
U8GLIB(u8g_dev_t *dev, uint8_t cs, uint8_t a0, uint8_t reset) |
|||
{ initHWSPI(dev, cs, a0, reset); } |
|||
U8GLIB(u8g_dev_t *dev, uint8_t options) |
|||
{ initI2C(dev, options); } |
|||
U8GLIB(u8g_dev_t *dev, uint8_t d0, uint8_t d1, uint8_t d2, uint8_t d3, uint8_t d4, uint8_t d5, uint8_t d6, uint8_t d7, |
|||
uint8_t en, uint8_t cs1, uint8_t cs2, uint8_t di, uint8_t rw, uint8_t reset) |
|||
{ init8Bit(dev, d0, d1, d2, d3, d4, d5, d6, d7, en, cs1, cs2, di, rw, reset); } |
|||
U8GLIB(u8g_dev_t *dev, uint8_t d0, uint8_t d1, uint8_t d2, uint8_t d3, uint8_t d4, uint8_t d5, uint8_t d6, uint8_t d7, |
|||
uint8_t cs, uint8_t a0, uint8_t wr, uint8_t rd, uint8_t reset) |
|||
{ initRW8Bit(dev, d0, d1, d2, d3, d4, d5, d6, d7, cs, a0, wr, rd, reset); } |
|||
|
|||
uint8_t begin(void) { is_begin = 1; return u8g_Begin(&u8g); } |
|||
|
|||
void setPrintPos(u8g_uint_t x, u8g_uint_t y) { tx = x; ty = y; } |
|||
u8g_t *getU8g(void) { return &u8g; } |
|||
|
|||
|
|||
/* implementation of the write interface to the print class */ |
|||
#if defined(ARDUINO) && ARDUINO >= 100 |
|||
size_t write(uint8_t c) { tx += u8g_DrawGlyph(&u8g, tx, ty, c); return 1;} |
|||
#else |
|||
void write(uint8_t c) { tx += u8g_DrawGlyph(&u8g, tx, ty, c); } |
|||
#endif |
|||
|
|||
/* screen rotation */ |
|||
void undoRotation(void) { u8g_UndoRotation(&u8g); } |
|||
void setRot90(void) { u8g_SetRot90(&u8g); } |
|||
void setRot180(void) { u8g_SetRot180(&u8g); } |
|||
void setRot270(void) { u8g_SetRot270(&u8g); } |
|||
|
|||
/* screen scaling */ |
|||
void undoScale(void) { u8g_UndoScale(&u8g); } |
|||
void setScale2x2(void) { u8g_SetScale2x2(&u8g); } |
|||
|
|||
/* picture loop */ |
|||
void firstPage(void) { cbegin(); u8g_FirstPage(&u8g); } |
|||
uint8_t nextPage(void) { return u8g_NextPage(&u8g); } |
|||
|
|||
/* system commands */ |
|||
uint8_t setContrast(uint8_t contrast) { cbegin(); return u8g_SetContrast(&u8g, contrast); } |
|||
void sleepOn(void) { u8g_SleepOn(&u8g); } |
|||
void sleepOff(void) { u8g_SleepOff(&u8g); } |
|||
|
|||
/* graphic primitives */ |
|||
void setColorIndex(uint8_t color_index) { u8g_SetColorIndex(&u8g, color_index); } |
|||
uint8_t getColorIndex(void) { return u8g_GetColorIndex(&u8g); } |
|||
|
|||
void setDefaultForegroundColor(void) { u8g_SetDefaultForegroundColor(&u8g); } |
|||
void setDefaultBackgroundColor(void) { u8g_SetDefaultBackgroundColor(&u8g); } |
|||
void setDefaultMidColor(void) { u8g_SetDefaultMidColor(&u8g); } |
|||
|
|||
u8g_uint_t getWidth(void) { return u8g_GetWidth(&u8g); } |
|||
u8g_uint_t getHeight(void) { return u8g_GetHeight(&u8g); } |
|||
uint8_t getMode(void) { return u8g_GetMode(&u8g); } |
|||
|
|||
void drawPixel(u8g_uint_t x, u8g_uint_t y) { return u8g_DrawPixel(&u8g, x, y); } |
|||
void drawHLine(u8g_uint_t x, u8g_uint_t y, u8g_uint_t w) { u8g_DrawHLine(&u8g, x, y, w); } |
|||
void drawVLine(u8g_uint_t x, u8g_uint_t y, u8g_uint_t h) { u8g_DrawVLine(&u8g, x, y, h); } |
|||
void drawLine(u8g_uint_t x1, u8g_uint_t y1, u8g_uint_t x2, u8g_uint_t y2) { u8g_DrawLine(&u8g, x1, y1, x2, y2); } |
|||
|
|||
void drawFrame(u8g_uint_t x, u8g_uint_t y, u8g_uint_t w, u8g_uint_t h) { u8g_DrawFrame(&u8g, x, y, w, h); } |
|||
void drawRFrame(u8g_uint_t x, u8g_uint_t y, u8g_uint_t w, u8g_uint_t h, u8g_uint_t r) { u8g_DrawRFrame(&u8g, x, y, w, h,r); } |
|||
void drawBox(u8g_uint_t x, u8g_uint_t y, u8g_uint_t w, u8g_uint_t h) { u8g_DrawBox(&u8g, x, y, w, h); } |
|||
void drawRBox(u8g_uint_t x, u8g_uint_t y, u8g_uint_t w, u8g_uint_t h, u8g_uint_t r) { u8g_DrawRBox(&u8g, x, y, w, h,r); } |
|||
|
|||
void drawCircle(u8g_uint_t x0, u8g_uint_t y0, u8g_uint_t rad, uint8_t opt = U8G_DRAW_ALL) { u8g_DrawCircle(&u8g, x0, y0, rad, opt); } |
|||
void drawDisc(u8g_uint_t x0, u8g_uint_t y0, u8g_uint_t rad, uint8_t opt = U8G_DRAW_ALL) { u8g_DrawDisc(&u8g, x0, y0, rad, opt); } |
|||
|
|||
/* bitmap handling */ |
|||
void drawBitmap(u8g_uint_t x, u8g_uint_t y, u8g_uint_t cnt, u8g_uint_t h, const uint8_t *bitmap) |
|||
{ u8g_DrawBitmap(&u8g, x, y, cnt, h, bitmap); } |
|||
void drawBitmapP(u8g_uint_t x, u8g_uint_t y, u8g_uint_t cnt, u8g_uint_t h, const u8g_pgm_uint8_t *bitmap) |
|||
{ u8g_DrawBitmapP(&u8g, x, y, cnt, h, bitmap); } |
|||
|
|||
void drawXBM(u8g_uint_t x, u8g_uint_t y, u8g_uint_t w, u8g_uint_t h, const uint8_t *bitmap) |
|||
{ u8g_DrawXBM(&u8g, x, y, w, h, bitmap); } |
|||
void drawXBMP(u8g_uint_t x, u8g_uint_t y, u8g_uint_t w, u8g_uint_t h, const u8g_pgm_uint8_t *bitmap) |
|||
{ u8g_DrawXBMP(&u8g, x, y, w, h, bitmap); } |
|||
|
|||
|
|||
/* font handling */ |
|||
void setFont(const u8g_fntpgm_uint8_t *font) {u8g_SetFont(&u8g, font); } |
|||
int8_t getFontAscent(void) { return u8g_GetFontAscent(&u8g); } |
|||
int8_t getFontDescent(void) { return u8g_GetFontDescent(&u8g); } |
|||
int8_t getFontLineSpacing(void) { return u8g_GetFontLineSpacing(&u8g); } |
|||
|
|||
u8g_uint_t drawStr(u8g_uint_t x, u8g_uint_t y, const char *s) { return u8g_DrawStr(&u8g, x, y, s); } |
|||
u8g_uint_t drawStr90(u8g_uint_t x, u8g_uint_t y, const char *s) { return u8g_DrawStr90(&u8g, x, y, s); } |
|||
u8g_uint_t drawStr180(u8g_uint_t x, u8g_uint_t y, const char *s) { return u8g_DrawStr180(&u8g, x, y, s); } |
|||
u8g_uint_t drawStr270(u8g_uint_t x, u8g_uint_t y, const char *s) { return u8g_DrawStr270(&u8g, x, y, s); } |
|||
u8g_uint_t drawStrP(u8g_uint_t x, u8g_uint_t y, const u8g_pgm_uint8_t *s) { return u8g_DrawStrP(&u8g, x, y, s); } |
|||
u8g_uint_t drawStr90P(u8g_uint_t x, u8g_uint_t y, const u8g_pgm_uint8_t *s) { return u8g_DrawStr90P(&u8g, x, y, s); } |
|||
u8g_uint_t drawStr180P(u8g_uint_t x, u8g_uint_t y, const u8g_pgm_uint8_t *s) { return u8g_DrawStr180P(&u8g, x, y, s); } |
|||
u8g_uint_t drawStr270P(u8g_uint_t x, u8g_uint_t y, const u8g_pgm_uint8_t *s) { return u8g_DrawStr270P(&u8g, x, y, s); } |
|||
|
|||
void setFontPosBaseline(void) { u8g_SetFontPosBaseline(&u8g); } |
|||
void setFontPosBottom(void) { u8g_SetFontPosBottom(&u8g); } |
|||
void setFontPosCenter(void) { u8g_SetFontPosCenter(&u8g); } |
|||
void setFontPosTop(void) { u8g_SetFontPosTop(&u8g); } |
|||
|
|||
void setFontRefHeightText(void) { u8g_SetFontRefHeightText(&u8g); } |
|||
void setFontRefHeightExtendedText(void) { u8g_SetFontRefHeightExtendedText(&u8g); } |
|||
void setFontRefHeightAll(void) { u8g_SetFontRefHeightAll(&u8g); } |
|||
void setFontLineSpacingFactor(uint8_t factor) { u8g_SetFontLineSpacingFactor(&u8g, factor); } |
|||
|
|||
|
|||
u8g_uint_t getStrPixelWidth(const char *s) { return u8g_GetStrPixelWidth(&u8g, s); } |
|||
u8g_uint_t getStrPixelWidthP(u8g_pgm_uint8_t *s) { return u8g_GetStrPixelWidthP(&u8g, s); } |
|||
u8g_uint_t getStrWidth(const char *s) { return u8g_GetStrWidth(&u8g, s); } |
|||
u8g_uint_t getStrWidthP(u8g_pgm_uint8_t *s) { return u8g_GetStrWidthP(&u8g, s); } |
|||
|
|||
void setHardwareBackup(u8g_state_cb backup_cb) { u8g_SetHardwareBackup(&u8g, backup_cb); } |
|||
|
|||
#if defined(ARDUINO) && ARDUINO >= 100 |
|||
// support for the F() macro
|
|||
|
|||
u8g_uint_t drawStr(u8g_uint_t x, u8g_uint_t y, const __FlashStringHelper *s) { return u8g_DrawStrP(&u8g, x, y, (u8g_pgm_uint8_t *)s); } |
|||
u8g_uint_t drawStr90(u8g_uint_t x, u8g_uint_t y, const __FlashStringHelper *s) { return u8g_DrawStr90P(&u8g, x, y, (u8g_pgm_uint8_t *)s); } |
|||
u8g_uint_t drawStr180(u8g_uint_t x, u8g_uint_t y, const __FlashStringHelper *s) { return u8g_DrawStr180P(&u8g, x, y, (u8g_pgm_uint8_t *)s); } |
|||
u8g_uint_t drawStr270(u8g_uint_t x, u8g_uint_t y, const __FlashStringHelper *s) { return u8g_DrawStr270P(&u8g, x, y, (u8g_pgm_uint8_t *)s); } |
|||
|
|||
u8g_uint_t getStrPixelWidth(const __FlashStringHelper *s) { return u8g_GetStrPixelWidthP(&u8g, (u8g_pgm_uint8_t *)s); } |
|||
u8g_uint_t getStrWidth(const __FlashStringHelper *s) { return u8g_GetStrWidthP(&u8g, (u8g_pgm_uint8_t *)s); } |
|||
#endif |
|||
|
|||
/* cursor handling */ |
|||
void setCursorFont(const u8g_pgm_uint8_t *cursor_font) { u8g_SetCursorFont(&u8g, cursor_font); } |
|||
void setCursorStyle(uint8_t encoding) { u8g_SetCursorStyle(&u8g, encoding); } |
|||
void setCursorPos(u8g_uint_t cursor_x, u8g_uint_t cursor_y) { u8g_SetCursorPos(&u8g, cursor_x, cursor_y); } |
|||
void setCursorColor(uint8_t fg, uint8_t bg) { u8g_SetCursorColor(&u8g, fg, bg); } |
|||
void enableCursor(void) { u8g_EnableCursor(&u8g); } |
|||
void disableCursor(void) { u8g_DisableCursor(&u8g); } |
|||
void drawCursor(void) { u8g_DrawCursor(&u8g); } |
|||
|
|||
/* virtual screen */ |
|||
|
|||
void setVirtualScreenDimension(u8g_uint_t width, u8g_uint_t height) { u8g_SetVirtualScreenDimension(&u8g, width, height); } |
|||
uint8_t addToVirtualScreen(u8g_uint_t x, u8g_uint_t y, U8GLIB &child_u8g) { return u8g_AddToVirtualScreen(&u8g, x, y, &child_u8g.u8g); } |
|||
|
|||
}; |
|||
|
|||
|
|||
class U8GLIB_DOGS102 : public U8GLIB |
|||
{ |
|||
public: |
|||
U8GLIB_DOGS102(uint8_t sck, uint8_t mosi, uint8_t cs, uint8_t a0, uint8_t reset = U8G_PIN_NONE) |
|||
: U8GLIB(&u8g_dev_uc1701_dogs102_sw_spi, sck, mosi, cs, a0, reset) |
|||
{ } |
|||
U8GLIB_DOGS102(uint8_t cs, uint8_t a0, uint8_t reset = U8G_PIN_NONE) |
|||
: U8GLIB(&u8g_dev_uc1701_dogs102_hw_spi, cs, a0, reset) |
|||
{ } |
|||
}; |
|||
|
|||
class U8GLIB_MINI12864 : public U8GLIB |
|||
{ |
|||
public: |
|||
U8GLIB_MINI12864(uint8_t sck, uint8_t mosi, uint8_t cs, uint8_t a0, uint8_t reset = U8G_PIN_NONE) |
|||
: U8GLIB(&u8g_dev_uc1701_mini12864_sw_spi, sck, mosi, cs, a0, reset) |
|||
{ } |
|||
U8GLIB_MINI12864(uint8_t cs, uint8_t a0, uint8_t reset = U8G_PIN_NONE) |
|||
: U8GLIB(&u8g_dev_uc1701_mini12864_hw_spi, cs, a0, reset) |
|||
{ } |
|||
}; |
|||
|
|||
class U8GLIB_DOGM132 : public U8GLIB |
|||
{ |
|||
public: |
|||
U8GLIB_DOGM132(uint8_t sck, uint8_t mosi, uint8_t cs, uint8_t a0, uint8_t reset = U8G_PIN_NONE) |
|||
: U8GLIB(&u8g_dev_st7565_dogm132_sw_spi, sck, mosi, cs, a0, reset) |
|||
{ } |
|||
U8GLIB_DOGM132(uint8_t cs, uint8_t a0, uint8_t reset = U8G_PIN_NONE) |
|||
: U8GLIB(&u8g_dev_st7565_dogm132_hw_spi, cs, a0, reset) |
|||
{ } |
|||
}; |
|||
|
|||
class U8GLIB_NHD_C12832 : public U8GLIB |
|||
{ |
|||
public: |
|||
U8GLIB_NHD_C12832(uint8_t sck, uint8_t mosi, uint8_t cs, uint8_t a0, uint8_t reset = U8G_PIN_NONE) |
|||
: U8GLIB(&u8g_dev_st7565_nhd_c12832_sw_spi, sck, mosi, cs, a0, reset) |
|||
{ } |
|||
U8GLIB_NHD_C12832(uint8_t cs, uint8_t a0, uint8_t reset = U8G_PIN_NONE) |
|||
: U8GLIB(&u8g_dev_st7565_nhd_c12832_hw_spi, cs, a0, reset) |
|||
{ } |
|||
U8GLIB_NHD_C12832(uint8_t d0, uint8_t d1, uint8_t d2, uint8_t d3, uint8_t d4, uint8_t d5, uint8_t d6, uint8_t d7, |
|||
uint8_t en, uint8_t cs1, uint8_t di, uint8_t rw = U8G_PIN_NONE, uint8_t reset = U8G_PIN_NONE) |
|||
: U8GLIB(&u8g_dev_st7565_nhd_c12832_parallel, d0, d1, d2, d3, d4, d5, d6, d7, en, cs1, U8G_PIN_NONE, di, rw, reset) |
|||
{ } |
|||
}; |
|||
|
|||
class U8GLIB_DOGM128 : public U8GLIB |
|||
{ |
|||
public: |
|||
U8GLIB_DOGM128(uint8_t sck, uint8_t mosi, uint8_t cs, uint8_t a0, uint8_t reset = U8G_PIN_NONE) |
|||
: U8GLIB(&u8g_dev_st7565_dogm128_sw_spi, sck, mosi, cs, a0, reset) |
|||
{ } |
|||
U8GLIB_DOGM128(uint8_t cs, uint8_t a0, uint8_t reset = U8G_PIN_NONE) |
|||
: U8GLIB(&u8g_dev_st7565_dogm128_hw_spi, cs, a0, reset) |
|||
{ } |
|||
}; |
|||
|
|||
class U8GLIB_LM6059 : public U8GLIB |
|||
{ |
|||
public: |
|||
U8GLIB_LM6059(uint8_t sck, uint8_t mosi, uint8_t cs, uint8_t a0, uint8_t reset = U8G_PIN_NONE) |
|||
: U8GLIB(&u8g_dev_st7565_lm6059_sw_spi, sck, mosi, cs, a0, reset) |
|||
{ } |
|||
U8GLIB_LM6059(uint8_t cs, uint8_t a0, uint8_t reset = U8G_PIN_NONE) |
|||
: U8GLIB(&u8g_dev_st7565_lm6059_hw_spi, cs, a0, reset) |
|||
{ } |
|||
}; |
|||
|
|||
class U8GLIB_LM6063 : public U8GLIB |
|||
{ |
|||
public: |
|||
U8GLIB_LM6063(uint8_t sck, uint8_t mosi, uint8_t cs, uint8_t a0, uint8_t reset = U8G_PIN_NONE) |
|||
: U8GLIB(&u8g_dev_st7565_lm6063_sw_spi, sck, mosi, cs, a0, reset) |
|||
{ } |
|||
U8GLIB_LM6063(uint8_t cs, uint8_t a0, uint8_t reset = U8G_PIN_NONE) |
|||
: U8GLIB(&u8g_dev_st7565_lm6063_hw_spi, cs, a0, reset) |
|||
{ } |
|||
}; |
|||
|
|||
class U8GLIB_64128N : public U8GLIB |
|||
{ |
|||
public: |
|||
U8GLIB_64128N(uint8_t sck, uint8_t mosi, uint8_t cs, uint8_t a0, uint8_t reset = U8G_PIN_NONE) |
|||
: U8GLIB(&u8g_dev_st7565_64128n_sw_spi, sck, mosi, cs, a0, reset) |
|||
{ } |
|||
U8GLIB_64128N(uint8_t cs, uint8_t a0, uint8_t reset = U8G_PIN_NONE) |
|||
: U8GLIB(&u8g_dev_st7565_64128n_hw_spi, cs, a0, reset) |
|||
{ } |
|||
}; |
|||
|
|||
class U8GLIB_NHD_C12864 : public U8GLIB |
|||
{ |
|||
public: |
|||
U8GLIB_NHD_C12864(uint8_t sck, uint8_t mosi, uint8_t cs, uint8_t a0, uint8_t reset = U8G_PIN_NONE) |
|||
: U8GLIB(&u8g_dev_st7565_nhd_c12864_sw_spi, sck, mosi, cs, a0, reset) |
|||
{ } |
|||
U8GLIB_NHD_C12864(uint8_t cs, uint8_t a0, uint8_t reset = U8G_PIN_NONE) |
|||
: U8GLIB(&u8g_dev_st7565_nhd_c12864_hw_spi, cs, a0, reset) |
|||
{ } |
|||
}; |
|||
|
|||
|
|||
class U8GLIB_ST7920_128X64 : public U8GLIB |
|||
{ |
|||
public: |
|||
U8GLIB_ST7920_128X64(uint8_t sck, uint8_t mosi, uint8_t cs, uint8_t a0, uint8_t reset = U8G_PIN_NONE) |
|||
: U8GLIB(&u8g_dev_st7920_128x64_sw_spi, sck, mosi, cs, a0, reset) |
|||
{ } |
|||
U8GLIB_ST7920_128X64(uint8_t cs, uint8_t a0, uint8_t reset = U8G_PIN_NONE) |
|||
: U8GLIB(&u8g_dev_st7920_128x64_hw_spi, cs, a0, reset) |
|||
{ } |
|||
U8GLIB_ST7920_128X64(uint8_t d0, uint8_t d1, uint8_t d2, uint8_t d3, uint8_t d4, uint8_t d5, uint8_t d6, uint8_t d7, |
|||
uint8_t en, uint8_t cs1, uint8_t cs2, uint8_t di, uint8_t rw = U8G_PIN_NONE, uint8_t reset = U8G_PIN_NONE) |
|||
: U8GLIB(&u8g_dev_st7920_128x64_8bit, d0, d1, d2, d3, d4, d5, d6, d7, en, cs1, cs2, di, rw, reset) |
|||
{ } |
|||
// U8GLIB_ST7920_128X64(uint8_t cs)
|
|||
// : U8GLIB(&u8g_dev_st7920_128x64_sw_spi, cs, U8G_PIN_NONE, U8G_PIN_NONE)
|
|||
// { }
|
|||
}; |
|||
|
|||
class U8GLIB_ST7920_128X64_1X : public U8GLIB |
|||
{ |
|||
public: |
|||
U8GLIB_ST7920_128X64_1X(uint8_t sck, uint8_t mosi, uint8_t cs, uint8_t reset = U8G_PIN_NONE) |
|||
: U8GLIB(&u8g_dev_st7920_128x64_sw_spi, sck, mosi, cs, U8G_PIN_NONE, reset) // a0 = U8G_PIN_NONE
|
|||
{ } |
|||
U8GLIB_ST7920_128X64_1X(uint8_t cs, uint8_t reset = U8G_PIN_NONE) |
|||
: U8GLIB(&u8g_dev_st7920_128x64_hw_spi, cs, U8G_PIN_NONE, reset) // a0 = U8G_PIN_NONE
|
|||
{ } |
|||
U8GLIB_ST7920_128X64_1X(uint8_t d0, uint8_t d1, uint8_t d2, uint8_t d3, uint8_t d4, uint8_t d5, uint8_t d6, uint8_t d7, |
|||
uint8_t en, uint8_t di, uint8_t rw = U8G_PIN_NONE, uint8_t reset = U8G_PIN_NONE) |
|||
: U8GLIB(&u8g_dev_st7920_128x64_8bit, d0, d1, d2, d3, d4, d5, d6, d7, en, U8G_PIN_NONE, U8G_PIN_NONE, di, rw, reset) // cs1 = cs2 = U8G_PIN_NONE
|
|||
{ } |
|||
}; |
|||
|
|||
class U8GLIB_ST7920_128X64_4X : public U8GLIB |
|||
{ |
|||
public: |
|||
U8GLIB_ST7920_128X64_4X(uint8_t sck, uint8_t mosi, uint8_t cs, uint8_t reset = U8G_PIN_NONE) |
|||
: U8GLIB(&u8g_dev_st7920_128x64_4x_sw_spi, sck, mosi, cs, U8G_PIN_NONE, reset) // a0 = U8G_PIN_NONE
|
|||
{ } |
|||
U8GLIB_ST7920_128X64_4X(uint8_t cs, uint8_t reset = U8G_PIN_NONE) |
|||
: U8GLIB(&u8g_dev_st7920_128x64_4x_hw_spi, cs, U8G_PIN_NONE, reset) // a0 = U8G_PIN_NONE
|
|||
{ } |
|||
U8GLIB_ST7920_128X64_4X(uint8_t d0, uint8_t d1, uint8_t d2, uint8_t d3, uint8_t d4, uint8_t d5, uint8_t d6, uint8_t d7, |
|||
uint8_t en, uint8_t di, uint8_t rw = U8G_PIN_NONE, uint8_t reset = U8G_PIN_NONE) |
|||
: U8GLIB(&u8g_dev_st7920_128x64_4x_8bit, d0, d1, d2, d3, d4, d5, d6, d7, en, U8G_PIN_NONE, U8G_PIN_NONE, di, rw, reset) // cs1 = cs2 = U8G_PIN_NONE
|
|||
{ } |
|||
}; |
|||
|
|||
|
|||
|
|||
class U8GLIB_ST7920_192X32 : public U8GLIB // OBSOLETE, use U8GLIB_ST7920_192X32_1X instead
|
|||
{ |
|||
public: |
|||
U8GLIB_ST7920_192X32(uint8_t sck, uint8_t mosi, uint8_t cs, uint8_t a0, uint8_t reset = U8G_PIN_NONE) |
|||
: U8GLIB(&u8g_dev_st7920_192x32_sw_spi, sck, mosi, cs, a0, reset) |
|||
{ } |
|||
U8GLIB_ST7920_192X32(uint8_t cs, uint8_t a0, uint8_t reset = U8G_PIN_NONE) |
|||
: U8GLIB(&u8g_dev_st7920_192x32_hw_spi, cs, a0, reset) |
|||
{ } |
|||
U8GLIB_ST7920_192X32(uint8_t d0, uint8_t d1, uint8_t d2, uint8_t d3, uint8_t d4, uint8_t d5, uint8_t d6, uint8_t d7, |
|||
uint8_t en, uint8_t cs1, uint8_t cs2, uint8_t di, uint8_t rw = U8G_PIN_NONE, uint8_t reset = U8G_PIN_NONE) |
|||
: U8GLIB(&u8g_dev_st7920_192x32_8bit, d0, d1, d2, d3, d4, d5, d6, d7, en, cs1, cs2, di, rw, reset) |
|||
{ } |
|||
}; |
|||
|
|||
class U8GLIB_ST7920_192X32_1X : public U8GLIB |
|||
{ |
|||
public: |
|||
U8GLIB_ST7920_192X32_1X(uint8_t sck, uint8_t mosi, uint8_t cs, uint8_t reset = U8G_PIN_NONE) |
|||
: U8GLIB(&u8g_dev_st7920_192x32_sw_spi, sck, mosi, cs, U8G_PIN_NONE, reset) // a0 = U8G_PIN_NONE
|
|||
{ } |
|||
U8GLIB_ST7920_192X32_1X(uint8_t cs, uint8_t reset = U8G_PIN_NONE) |
|||
: U8GLIB(&u8g_dev_st7920_192x32_hw_spi, cs, U8G_PIN_NONE, reset) // a0 = U8G_PIN_NONE
|
|||
{ } |
|||
U8GLIB_ST7920_192X32_1X(uint8_t d0, uint8_t d1, uint8_t d2, uint8_t d3, uint8_t d4, uint8_t d5, uint8_t d6, uint8_t d7, |
|||
uint8_t en, uint8_t di, uint8_t rw = U8G_PIN_NONE, uint8_t reset = U8G_PIN_NONE) |
|||
: U8GLIB(&u8g_dev_st7920_192x32_8bit, d0, d1, d2, d3, d4, d5, d6, d7, en, U8G_PIN_NONE, U8G_PIN_NONE, di, rw, reset) // cs1 = cs2 = U8G_PIN_NONE
|
|||
{ } |
|||
}; |
|||
|
|||
class U8GLIB_ST7920_192X32_4X : public U8GLIB |
|||
{ |
|||
public: |
|||
U8GLIB_ST7920_192X32_4X(uint8_t sck, uint8_t mosi, uint8_t cs, uint8_t reset = U8G_PIN_NONE) |
|||
: U8GLIB(&u8g_dev_st7920_192x32_4x_sw_spi, sck, mosi, cs, U8G_PIN_NONE, reset) // a0 = U8G_PIN_NONE
|
|||
{ } |
|||
U8GLIB_ST7920_192X32_4X(uint8_t cs, uint8_t reset = U8G_PIN_NONE) |
|||
: U8GLIB(&u8g_dev_st7920_192x32_4x_hw_spi, cs, U8G_PIN_NONE, reset) // a0 = U8G_PIN_NONE
|
|||
{ } |
|||
U8GLIB_ST7920_192X32_4X(uint8_t d0, uint8_t d1, uint8_t d2, uint8_t d3, uint8_t d4, uint8_t d5, uint8_t d6, uint8_t d7, |
|||
uint8_t en, uint8_t di, uint8_t rw = U8G_PIN_NONE, uint8_t reset = U8G_PIN_NONE) |
|||
: U8GLIB(&u8g_dev_st7920_192x32_4x_8bit, d0, d1, d2, d3, d4, d5, d6, d7, en, U8G_PIN_NONE, U8G_PIN_NONE, di, rw, reset) // cs1 = cs2 = U8G_PIN_NONE
|
|||
{ } |
|||
}; |
|||
|
|||
|
|||
class U8GLIB_ST7920_202X32 : public U8GLIB |
|||
{ |
|||
public: |
|||
U8GLIB_ST7920_202X32(uint8_t sck, uint8_t mosi, uint8_t cs, uint8_t a0, uint8_t reset = U8G_PIN_NONE) |
|||
: U8GLIB(&u8g_dev_st7920_202x32_sw_spi, sck, mosi, cs, a0, reset) |
|||
{ } |
|||
U8GLIB_ST7920_202X32(uint8_t cs, uint8_t a0, uint8_t reset = U8G_PIN_NONE) |
|||
: U8GLIB(&u8g_dev_st7920_202x32_hw_spi, cs, a0, reset) |
|||
{ } |
|||
U8GLIB_ST7920_202X32(uint8_t d0, uint8_t d1, uint8_t d2, uint8_t d3, uint8_t d4, uint8_t d5, uint8_t d6, uint8_t d7, |
|||
uint8_t en, uint8_t cs1, uint8_t cs2, uint8_t di, uint8_t rw = U8G_PIN_NONE, uint8_t reset = U8G_PIN_NONE) |
|||
: U8GLIB(&u8g_dev_st7920_202x32_8bit, d0, d1, d2, d3, d4, d5, d6, d7, en, cs1, cs2, di, rw, reset) |
|||
{ } |
|||
}; |
|||
|
|||
class U8GLIB_ST7920_202X32_1X : public U8GLIB |
|||
{ |
|||
public: |
|||
U8GLIB_ST7920_202X32_1X(uint8_t sck, uint8_t mosi, uint8_t cs, uint8_t reset = U8G_PIN_NONE) |
|||
: U8GLIB(&u8g_dev_st7920_202x32_sw_spi, sck, mosi, cs, U8G_PIN_NONE, reset) // a0 = U8G_PIN_NONE
|
|||
{ } |
|||
U8GLIB_ST7920_202X32_1X(uint8_t cs, uint8_t reset = U8G_PIN_NONE) |
|||
: U8GLIB(&u8g_dev_st7920_202x32_hw_spi, cs, U8G_PIN_NONE, reset) // a0 = U8G_PIN_NONE
|
|||
{ } |
|||
U8GLIB_ST7920_202X32_1X(uint8_t d0, uint8_t d1, uint8_t d2, uint8_t d3, uint8_t d4, uint8_t d5, uint8_t d6, uint8_t d7, |
|||
uint8_t en, uint8_t di, uint8_t rw = U8G_PIN_NONE, uint8_t reset = U8G_PIN_NONE) |
|||
: U8GLIB(&u8g_dev_st7920_202x32_8bit, d0, d1, d2, d3, d4, d5, d6, d7, en, U8G_PIN_NONE, U8G_PIN_NONE, di, rw, reset) // cs1 = cs2 = U8G_PIN_NONE
|
|||
{ } |
|||
}; |
|||
|
|||
class U8GLIB_ST7920_202X32_4X : public U8GLIB |
|||
{ |
|||
public: |
|||
U8GLIB_ST7920_202X32_4X(uint8_t sck, uint8_t mosi, uint8_t cs, uint8_t reset = U8G_PIN_NONE) |
|||
: U8GLIB(&u8g_dev_st7920_202x32_4x_sw_spi, sck, mosi, cs, U8G_PIN_NONE, reset) // a0 = U8G_PIN_NONE
|
|||
{ } |
|||
U8GLIB_ST7920_202X32_4X(uint8_t cs, uint8_t reset = U8G_PIN_NONE) |
|||
: U8GLIB(&u8g_dev_st7920_202x32_4x_hw_spi, cs, U8G_PIN_NONE, reset) // a0 = U8G_PIN_NONE
|
|||
{ } |
|||
U8GLIB_ST7920_202X32_4X(uint8_t d0, uint8_t d1, uint8_t d2, uint8_t d3, uint8_t d4, uint8_t d5, uint8_t d6, uint8_t d7, |
|||
uint8_t en, uint8_t di, uint8_t rw = U8G_PIN_NONE, uint8_t reset = U8G_PIN_NONE) |
|||
: U8GLIB(&u8g_dev_st7920_202x32_4x_8bit, d0, d1, d2, d3, d4, d5, d6, d7, en, U8G_PIN_NONE, U8G_PIN_NONE, di, rw, reset) // cs1 = cs2 = U8G_PIN_NONE
|
|||
{ } |
|||
}; |
|||
|
|||
|
|||
class U8GLIB_LC7981_160X80 : public U8GLIB |
|||
{ |
|||
public: |
|||
U8GLIB_LC7981_160X80(uint8_t d0, uint8_t d1, uint8_t d2, uint8_t d3, uint8_t d4, uint8_t d5, uint8_t d6, uint8_t d7, |
|||
uint8_t en, uint8_t cs1, uint8_t di, uint8_t rw = U8G_PIN_NONE, uint8_t reset = U8G_PIN_NONE) |
|||
: U8GLIB(&u8g_dev_lc7981_160x80_8bit, d0, d1, d2, d3, d4, d5, d6, d7, en, cs1, U8G_PIN_NONE, di, rw, reset) |
|||
{ } |
|||
}; |
|||
|
|||
class U8GLIB_LC7981_240X64 : public U8GLIB |
|||
{ |
|||
public: |
|||
U8GLIB_LC7981_240X64(uint8_t d0, uint8_t d1, uint8_t d2, uint8_t d3, uint8_t d4, uint8_t d5, uint8_t d6, uint8_t d7, |
|||
uint8_t en, uint8_t cs1, uint8_t di, uint8_t rw = U8G_PIN_NONE, uint8_t reset = U8G_PIN_NONE) |
|||
: U8GLIB(&u8g_dev_lc7981_240x64_8bit, d0, d1, d2, d3, d4, d5, d6, d7, en, cs1, U8G_PIN_NONE, di, rw, reset) |
|||
{ } |
|||
}; |
|||
|
|||
class U8GLIB_LC7981_240X128 : public U8GLIB |
|||
{ |
|||
public: |
|||
U8GLIB_LC7981_240X128(uint8_t d0, uint8_t d1, uint8_t d2, uint8_t d3, uint8_t d4, uint8_t d5, uint8_t d6, uint8_t d7, |
|||
uint8_t en, uint8_t cs1, uint8_t di, uint8_t rw = U8G_PIN_NONE, uint8_t reset = U8G_PIN_NONE) |
|||
: U8GLIB(&u8g_dev_lc7981_240x128_8bit, d0, d1, d2, d3, d4, d5, d6, d7, en, cs1, U8G_PIN_NONE, di, rw, reset) |
|||
{ } |
|||
}; |
|||
|
|||
// 16 bit mode required: Remove comment from "#define U8G_16BIT 1" in utility/u8g.h
|
|||
class U8GLIB_LC7981_320X64 : public U8GLIB |
|||
{ |
|||
public: |
|||
U8GLIB_LC7981_320X64(uint8_t d0, uint8_t d1, uint8_t d2, uint8_t d3, uint8_t d4, uint8_t d5, uint8_t d6, uint8_t d7, |
|||
uint8_t en, uint8_t cs1, uint8_t di, uint8_t rw = U8G_PIN_NONE, uint8_t reset = U8G_PIN_NONE) |
|||
: U8GLIB(&u8g_dev_lc7981_320x64_8bit, d0, d1, d2, d3, d4, d5, d6, d7, en, cs1, U8G_PIN_NONE, di, rw, reset) |
|||
{ } |
|||
}; |
|||
|
|||
|
|||
|
|||
class U8GLIB_DOGXL160_BW : public U8GLIB |
|||
{ |
|||
public: |
|||
U8GLIB_DOGXL160_BW(uint8_t sck, uint8_t mosi, uint8_t cs, uint8_t a0, uint8_t reset = U8G_PIN_NONE) |
|||
: U8GLIB(&u8g_dev_uc1610_dogxl160_bw_sw_spi, sck, mosi, cs, a0, reset) |
|||
{ } |
|||
U8GLIB_DOGXL160_BW(uint8_t cs, uint8_t a0, uint8_t reset = U8G_PIN_NONE) |
|||
: U8GLIB(&u8g_dev_uc1610_dogxl160_bw_hw_spi, cs, a0, reset) |
|||
{ } |
|||
}; |
|||
|
|||
class U8GLIB_DOGXL160_GR : public U8GLIB |
|||
{ |
|||
public: |
|||
U8GLIB_DOGXL160_GR(uint8_t sck, uint8_t mosi, uint8_t cs, uint8_t a0, uint8_t reset = U8G_PIN_NONE) |
|||
: U8GLIB(&u8g_dev_uc1610_dogxl160_gr_sw_spi, sck, mosi, cs, a0, reset) |
|||
{ } |
|||
U8GLIB_DOGXL160_GR(uint8_t cs, uint8_t a0, uint8_t reset = U8G_PIN_NONE) |
|||
: U8GLIB(&u8g_dev_uc1610_dogxl160_gr_hw_spi, cs, a0, reset) |
|||
{ } |
|||
}; |
|||
|
|||
class U8GLIB_DOGXL160_2X_BW : public U8GLIB |
|||
{ |
|||
public: |
|||
U8GLIB_DOGXL160_2X_BW(uint8_t sck, uint8_t mosi, uint8_t cs, uint8_t a0, uint8_t reset = U8G_PIN_NONE) |
|||
: U8GLIB(&u8g_dev_uc1610_dogxl160_2x_bw_sw_spi, sck, mosi, cs, a0, reset) |
|||
{ } |
|||
U8GLIB_DOGXL160_2X_BW(uint8_t cs, uint8_t a0, uint8_t reset = U8G_PIN_NONE) |
|||
: U8GLIB(&u8g_dev_uc1610_dogxl160_2x_bw_hw_spi, cs, a0, reset) |
|||
{ } |
|||
}; |
|||
|
|||
class U8GLIB_DOGXL160_2X_GR : public U8GLIB |
|||
{ |
|||
public: |
|||
U8GLIB_DOGXL160_2X_GR(uint8_t sck, uint8_t mosi, uint8_t cs, uint8_t a0, uint8_t reset = U8G_PIN_NONE) |
|||
: U8GLIB(&u8g_dev_uc1610_dogxl160_2x_gr_sw_spi, sck, mosi, cs, a0, reset) |
|||
{ } |
|||
U8GLIB_DOGXL160_2X_GR(uint8_t cs, uint8_t a0, uint8_t reset = U8G_PIN_NONE) |
|||
: U8GLIB(&u8g_dev_uc1610_dogxl160_2x_gr_hw_spi, cs, a0, reset) |
|||
{ } |
|||
}; |
|||
|
|||
|
|||
class U8GLIB_NHD27OLED_BW : public U8GLIB |
|||
{ |
|||
public: |
|||
U8GLIB_NHD27OLED_BW(uint8_t sck, uint8_t mosi, uint8_t cs, uint8_t a0, uint8_t reset = U8G_PIN_NONE) |
|||
: U8GLIB(&u8g_dev_ssd1325_nhd27oled_bw_sw_spi, sck, mosi, cs, a0, reset) |
|||
{ } |
|||
U8GLIB_NHD27OLED_BW(uint8_t cs, uint8_t a0, uint8_t reset = U8G_PIN_NONE) |
|||
: U8GLIB(&u8g_dev_ssd1325_nhd27oled_bw_hw_spi, cs, a0, reset) |
|||
{ } |
|||
U8GLIB_NHD27OLED_BW(uint8_t d0, uint8_t d1, uint8_t d2, uint8_t d3, uint8_t d4, uint8_t d5, uint8_t d6, uint8_t d7, |
|||
uint8_t cs, uint8_t di, uint8_t rw = U8G_PIN_NONE, uint8_t reset = U8G_PIN_NONE) |
|||
: U8GLIB(&u8g_dev_ssd1325_nhd27oled_bw_parallel, d0, d1, d2, d3, d4, d5, d6, d7, U8G_PIN_NONE, cs, U8G_PIN_NONE, di, rw, reset) |
|||
{ } |
|||
}; |
|||
|
|||
class U8GLIB_NHD27OLED_2X_BW : public U8GLIB |
|||
{ |
|||
public: |
|||
U8GLIB_NHD27OLED_2X_BW(uint8_t sck, uint8_t mosi, uint8_t cs, uint8_t a0, uint8_t reset = U8G_PIN_NONE) |
|||
: U8GLIB(&u8g_dev_ssd1325_nhd27oled_2x_bw_sw_spi, sck, mosi, cs, a0, reset) |
|||
{ } |
|||
U8GLIB_NHD27OLED_2X_BW(uint8_t cs, uint8_t a0, uint8_t reset = U8G_PIN_NONE) |
|||
: U8GLIB(&u8g_dev_ssd1325_nhd27oled_2x_bw_hw_spi, cs, a0, reset) |
|||
{ } |
|||
U8GLIB_NHD27OLED_2X_BW(uint8_t d0, uint8_t d1, uint8_t d2, uint8_t d3, uint8_t d4, uint8_t d5, uint8_t d6, uint8_t d7, |
|||
uint8_t cs, uint8_t di, uint8_t rw = U8G_PIN_NONE, uint8_t reset = U8G_PIN_NONE) |
|||
: U8GLIB(&u8g_dev_ssd1325_nhd27oled_2x_bw_parallel, d0, d1, d2, d3, d4, d5, d6, d7, U8G_PIN_NONE, cs, U8G_PIN_NONE, di, rw, reset) |
|||
{ } |
|||
}; |
|||
|
|||
class U8GLIB_NHD31OLED_BW : public U8GLIB |
|||
{ |
|||
public: |
|||
U8GLIB_NHD31OLED_BW(uint8_t sck, uint8_t mosi, uint8_t cs, uint8_t a0, uint8_t reset = U8G_PIN_NONE) |
|||
: U8GLIB(&u8g_dev_ssd1322_nhd31oled_bw_sw_spi, sck, mosi, cs, a0, reset) |
|||
{ } |
|||
U8GLIB_NHD31OLED_BW(uint8_t cs, uint8_t a0, uint8_t reset = U8G_PIN_NONE) |
|||
: U8GLIB(&u8g_dev_ssd1322_nhd31oled_bw_hw_spi, cs, a0, reset) |
|||
{ } |
|||
}; |
|||
|
|||
class U8GLIB_NHD31OLED_2X_BW : public U8GLIB |
|||
{ |
|||
public: |
|||
U8GLIB_NHD31OLED_2X_BW(uint8_t sck, uint8_t mosi, uint8_t cs, uint8_t a0, uint8_t reset = U8G_PIN_NONE) |
|||
: U8GLIB(&u8g_dev_ssd1322_nhd31oled_2x_bw_sw_spi, sck, mosi, cs, a0, reset) |
|||
{ } |
|||
U8GLIB_NHD31OLED_2X_BW(uint8_t cs, uint8_t a0, uint8_t reset = U8G_PIN_NONE) |
|||
: U8GLIB(&u8g_dev_ssd1322_nhd31oled_2x_bw_hw_spi, cs, a0, reset) |
|||
{ } |
|||
}; |
|||
|
|||
class U8GLIB_NHD31OLED_GR : public U8GLIB |
|||
{ |
|||
public: |
|||
U8GLIB_NHD31OLED_GR(uint8_t sck, uint8_t mosi, uint8_t cs, uint8_t a0, uint8_t reset = U8G_PIN_NONE) |
|||
: U8GLIB(&u8g_dev_ssd1322_nhd31oled_gr_sw_spi, sck, mosi, cs, a0, reset) |
|||
{ } |
|||
U8GLIB_NHD31OLED_GR(uint8_t cs, uint8_t a0, uint8_t reset = U8G_PIN_NONE) |
|||
: U8GLIB(&u8g_dev_ssd1322_nhd31oled_gr_hw_spi, cs, a0, reset) |
|||
{ } |
|||
}; |
|||
|
|||
class U8GLIB_NHD31OLED_2X_GR : public U8GLIB |
|||
{ |
|||
public: |
|||
U8GLIB_NHD31OLED_2X_GR(uint8_t sck, uint8_t mosi, uint8_t cs, uint8_t a0, uint8_t reset = U8G_PIN_NONE) |
|||
: U8GLIB(&u8g_dev_ssd1322_nhd31oled_2x_gr_sw_spi, sck, mosi, cs, a0, reset) |
|||
{ } |
|||
U8GLIB_NHD31OLED_2X_GR(uint8_t cs, uint8_t a0, uint8_t reset = U8G_PIN_NONE) |
|||
: U8GLIB(&u8g_dev_ssd1322_nhd31oled_2x_gr_hw_spi, cs, a0, reset) |
|||
{ } |
|||
}; |
|||
|
|||
|
|||
class U8GLIB_SSD1306_128X64 : public U8GLIB |
|||
{ |
|||
public: |
|||
U8GLIB_SSD1306_128X64(uint8_t sck, uint8_t mosi, uint8_t cs, uint8_t a0, uint8_t reset = U8G_PIN_NONE) |
|||
: U8GLIB(&u8g_dev_ssd1306_128x64_sw_spi, sck, mosi, cs, a0, reset) |
|||
{ } |
|||
U8GLIB_SSD1306_128X64(uint8_t cs, uint8_t a0, uint8_t reset = U8G_PIN_NONE) |
|||
: U8GLIB(&u8g_dev_ssd1306_128x64_hw_spi, cs, a0, reset) |
|||
{ } |
|||
U8GLIB_SSD1306_128X64(uint8_t options = U8G_I2C_OPT_NONE) |
|||
: U8GLIB(&u8g_dev_ssd1306_128x64_i2c, options) |
|||
{ } |
|||
|
|||
}; |
|||
|
|||
class U8GLIB_SSD1309_128X64 : public U8GLIB |
|||
{ |
|||
public: |
|||
U8GLIB_SSD1309_128X64(uint8_t sck, uint8_t mosi, uint8_t cs, uint8_t a0, uint8_t reset = U8G_PIN_NONE) |
|||
: U8GLIB(&u8g_dev_ssd1309_128x64_sw_spi, sck, mosi, cs, a0, reset) |
|||
{ } |
|||
U8GLIB_SSD1309_128X64(uint8_t cs, uint8_t a0, uint8_t reset = U8G_PIN_NONE) |
|||
: U8GLIB(&u8g_dev_ssd1309_128x64_hw_spi, cs, a0, reset) |
|||
{ } |
|||
U8GLIB_SSD1309_128X64(uint8_t options = U8G_I2C_OPT_NONE) |
|||
: U8GLIB(&u8g_dev_ssd1309_128x64_i2c, options) |
|||
{ } |
|||
|
|||
}; |
|||
|
|||
class U8GLIB_SSD1306_128X32 : public U8GLIB |
|||
{ |
|||
public: |
|||
U8GLIB_SSD1306_128X32(uint8_t sck, uint8_t mosi, uint8_t cs, uint8_t a0, uint8_t reset = U8G_PIN_NONE) |
|||
: U8GLIB(&u8g_dev_ssd1306_128x32_sw_spi, sck, mosi, cs, a0, reset) |
|||
{ } |
|||
U8GLIB_SSD1306_128X32(uint8_t cs, uint8_t a0, uint8_t reset = U8G_PIN_NONE) |
|||
: U8GLIB(&u8g_dev_ssd1306_128x32_hw_spi, cs, a0, reset) |
|||
{ } |
|||
U8GLIB_SSD1306_128X32(uint8_t options = U8G_I2C_OPT_NONE) |
|||
: U8GLIB(&u8g_dev_ssd1306_128x32_i2c, options) |
|||
{ } |
|||
|
|||
}; |
|||
|
|||
|
|||
class U8GLIB_NHD27OLED_GR : public U8GLIB |
|||
{ |
|||
public: |
|||
U8GLIB_NHD27OLED_GR(uint8_t sck, uint8_t mosi, uint8_t cs, uint8_t a0, uint8_t reset = U8G_PIN_NONE) |
|||
: U8GLIB(&u8g_dev_ssd1325_nhd27oled_gr_sw_spi, sck, mosi, cs, a0, reset) |
|||
{ } |
|||
U8GLIB_NHD27OLED_GR(uint8_t cs, uint8_t a0, uint8_t reset = U8G_PIN_NONE) |
|||
: U8GLIB(&u8g_dev_ssd1325_nhd27oled_gr_hw_spi, cs, a0, reset) |
|||
{ } |
|||
}; |
|||
|
|||
class U8GLIB_NHD27OLED_2X_GR : public U8GLIB |
|||
{ |
|||
public: |
|||
U8GLIB_NHD27OLED_2X_GR(uint8_t sck, uint8_t mosi, uint8_t cs, uint8_t a0, uint8_t reset = U8G_PIN_NONE) |
|||
: U8GLIB(&u8g_dev_ssd1325_nhd27oled_2x_gr_sw_spi, sck, mosi, cs, a0, reset) |
|||
{ } |
|||
U8GLIB_NHD27OLED_2X_GR(uint8_t cs, uint8_t a0, uint8_t reset = U8G_PIN_NONE) |
|||
: U8GLIB(&u8g_dev_ssd1325_nhd27oled_2x_gr_hw_spi, cs, a0, reset) |
|||
{ } |
|||
}; |
|||
|
|||
class U8GLIB_SSD1327_96X96_GR : public U8GLIB |
|||
{ |
|||
public: |
|||
U8GLIB_SSD1327_96X96_GR(uint8_t sck, uint8_t mosi, uint8_t cs, uint8_t a0, uint8_t reset = U8G_PIN_NONE) |
|||
: U8GLIB(&u8g_dev_ssd1327_96x96_gr_sw_spi, sck, mosi, cs, a0, reset) |
|||
{ } |
|||
U8GLIB_SSD1327_96X96_GR(uint8_t cs, uint8_t a0, uint8_t reset = U8G_PIN_NONE) |
|||
: U8GLIB(&u8g_dev_ssd1327_96x96_gr_hw_spi, cs, a0, reset) |
|||
{ } |
|||
U8GLIB_SSD1327_96X96_GR(uint8_t options = U8G_I2C_OPT_NONE) |
|||
: U8GLIB(&u8g_dev_ssd1327_96x96_gr_i2c, options) |
|||
{ } |
|||
}; |
|||
|
|||
class U8GLIB_SSD1327_96X96_2X_GR : public U8GLIB |
|||
{ |
|||
public: |
|||
U8GLIB_SSD1327_96X96_2X_GR(uint8_t sck, uint8_t mosi, uint8_t cs, uint8_t a0, uint8_t reset = U8G_PIN_NONE) |
|||
: U8GLIB(&u8g_dev_ssd1327_96x96_2x_gr_sw_spi, sck, mosi, cs, a0, reset) |
|||
{ } |
|||
U8GLIB_SSD1327_96X96_2X_GR(uint8_t cs, uint8_t a0, uint8_t reset = U8G_PIN_NONE) |
|||
: U8GLIB(&u8g_dev_ssd1327_96x96_2x_gr_hw_spi, cs, a0, reset) |
|||
{ } |
|||
U8GLIB_SSD1327_96X96_2X_GR(uint8_t options = U8G_I2C_OPT_NONE) |
|||
: U8GLIB(&u8g_dev_ssd1327_96x96_2x_gr_i2c, options) |
|||
{ } |
|||
}; |
|||
|
|||
class U8GLIB_PCF8812 : public U8GLIB |
|||
{ |
|||
public: |
|||
U8GLIB_PCF8812(uint8_t sck, uint8_t mosi, uint8_t cs, uint8_t a0, uint8_t reset = U8G_PIN_NONE) |
|||
: U8GLIB(&u8g_dev_pcf8812_96x65_sw_spi, sck, mosi, cs, a0, reset) |
|||
{ } |
|||
}; |
|||
|
|||
class U8GLIB_PCD8544 : public U8GLIB |
|||
{ |
|||
public: |
|||
U8GLIB_PCD8544(uint8_t sck, uint8_t mosi, uint8_t cs, uint8_t a0, uint8_t reset = U8G_PIN_NONE) |
|||
: U8GLIB(&u8g_dev_pcd8544_84x48_sw_spi, sck, mosi, cs, a0, reset) |
|||
{ } |
|||
}; |
|||
|
|||
class U8GLIB_TLS8204_84X48 : public U8GLIB |
|||
{ |
|||
public: |
|||
U8GLIB_TLS8204_84X48(uint8_t sck, uint8_t mosi, uint8_t cs, uint8_t a0, uint8_t reset = U8G_PIN_NONE) |
|||
: U8GLIB(&u8g_dev_tls8204_84x48_sw_spi, sck, mosi, cs, a0, reset) |
|||
{ } |
|||
}; |
|||
|
|||
class U8GLIB_KS0108_128 : public U8GLIB |
|||
{ |
|||
public: |
|||
U8GLIB_KS0108_128(uint8_t d0, uint8_t d1, uint8_t d2, uint8_t d3, uint8_t d4, uint8_t d5, uint8_t d6, uint8_t d7, |
|||
uint8_t en, uint8_t cs1, uint8_t cs2, uint8_t di, uint8_t rw = U8G_PIN_NONE, uint8_t reset = U8G_PIN_NONE) |
|||
: U8GLIB(&u8g_dev_ks0108_128x64_fast, d0, d1, d2, d3, d4, d5, d6, d7, en, cs1, cs2, di, rw, reset) |
|||
{ } |
|||
}; |
|||
|
|||
class U8GLIB_SBN1661_122X32 : public U8GLIB |
|||
{ |
|||
public: |
|||
U8GLIB_SBN1661_122X32(uint8_t d0, uint8_t d1, uint8_t d2, uint8_t d3, uint8_t d4, uint8_t d5, uint8_t d6, uint8_t d7, |
|||
uint8_t cs1, uint8_t cs2, uint8_t di, uint8_t rw = U8G_PIN_NONE, uint8_t reset = U8G_PIN_NONE) |
|||
: U8GLIB(&u8g_dev_sbn1661_122x32, d0, d1, d2, d3, d4, d5, d6, d7, U8G_PIN_NONE, cs1, cs2, di, rw, reset) |
|||
{ } |
|||
}; |
|||
|
|||
class U8GLIB_T6963_240X128 : public U8GLIB |
|||
{ |
|||
public: |
|||
U8GLIB_T6963_240X128(uint8_t d0, uint8_t d1, uint8_t d2, uint8_t d3, uint8_t d4, uint8_t d5, uint8_t d6, uint8_t d7, |
|||
uint8_t cs, uint8_t a0, uint8_t wr, uint8_t rd, uint8_t reset = U8G_PIN_NONE) |
|||
: U8GLIB(&u8g_dev_t6963_240x128_8bit, d0, d1, d2, d3, d4, d5, d6, d7, cs, a0, wr, rd, reset) |
|||
{ } |
|||
}; |
|||
|
|||
class U8GLIB_T6963_240X64 : public U8GLIB |
|||
{ |
|||
public: |
|||
U8GLIB_T6963_240X64(uint8_t d0, uint8_t d1, uint8_t d2, uint8_t d3, uint8_t d4, uint8_t d5, uint8_t d6, uint8_t d7, |
|||
uint8_t cs, uint8_t a0, uint8_t wr, uint8_t rd, uint8_t reset = U8G_PIN_NONE) |
|||
: U8GLIB(&u8g_dev_t6963_240x64_8bit, d0, d1, d2, d3, d4, d5, d6, d7, cs, a0, wr, rd, reset) |
|||
{ } |
|||
}; |
|||
|
|||
class U8GLIB_T6963_128X64 : public U8GLIB |
|||
{ |
|||
public: |
|||
U8GLIB_T6963_128X64(uint8_t d0, uint8_t d1, uint8_t d2, uint8_t d3, uint8_t d4, uint8_t d5, uint8_t d6, uint8_t d7, |
|||
uint8_t cs, uint8_t a0, uint8_t wr, uint8_t rd, uint8_t reset = U8G_PIN_NONE) |
|||
: U8GLIB(&u8g_dev_t6963_128x64_8bit, d0, d1, d2, d3, d4, d5, d6, d7, cs, a0, wr, rd, reset) |
|||
{ } |
|||
}; |
|||
|
|||
|
|||
class U8GLIB_ST7687_C144MVGD: public U8GLIB |
|||
{ |
|||
public: |
|||
U8GLIB_ST7687_C144MVGD(uint8_t sck, uint8_t mosi, uint8_t cs, uint8_t a0, uint8_t reset = U8G_PIN_NONE) |
|||
: U8GLIB(&u8g_dev_st7687_c144mvgd_sw_spi, sck, mosi, cs, a0, reset) |
|||
{ } |
|||
U8GLIB_ST7687_C144MVGD(uint8_t d0, uint8_t d1, uint8_t d2, uint8_t d3, uint8_t d4, uint8_t d5, uint8_t d6, uint8_t d7, |
|||
uint8_t en, uint8_t cs, uint8_t a0, uint8_t rw = U8G_PIN_NONE, uint8_t reset = U8G_PIN_NONE) |
|||
: U8GLIB(&u8g_dev_ks0108_128x64_fast, d0, d1, d2, d3, d4, d5, d6, d7, en, cs, U8G_PIN_NONE, a0, rw, reset) |
|||
{ } |
|||
}; |
|||
|
|||
class U8GLIB_ILI9325D_320x240 : public U8GLIB |
|||
{ |
|||
public: |
|||
/*
|
|||
U8GLIB_ILI9325D_320x240(uint8_t d0, uint8_t d1, uint8_t d2, uint8_t d3, uint8_t d4, uint8_t d5, uint8_t d6, uint8_t d7, |
|||
uint8_t en, uint8_t cs1, uint8_t di, uint8_t rw = U8G_PIN_NONE, uint8_t reset = U8G_PIN_NONE) |
|||
: U8GLIB(&u8g_dev_ili9325d_320x240_8bit, d0, d1, d2, d3, d4, d5, d6, d7, en, cs1, U8G_PIN_NONE, di, rw, reset) |
|||
{ } |
|||
*/ |
|||
U8GLIB_ILI9325D_320x240( uint8_t en, uint8_t cs1, uint8_t di, uint8_t rw = U8G_PIN_NONE, uint8_t reset = U8G_PIN_NONE) |
|||
{ init8BitFixedPort(&u8g_dev_ili9325d_320x240_8bit, en, cs1, di, rw, reset); } |
|||
}; |
|||
|
|||
class U8GLIB_FLIPDISC_2X7 : public U8GLIB |
|||
{ |
|||
public: |
|||
U8GLIB_FLIPDISC_2X7(void) : U8GLIB(&u8g_dev_flipdisc_2x7) |
|||
{ } |
|||
}; |
|||
|
|||
class U8GLIB_VS : public U8GLIB |
|||
{ |
|||
public: |
|||
U8GLIB_VS(void) : U8GLIB(&u8g_dev_vs) |
|||
{ } |
|||
}; |
|||
|
|||
|
|||
#endif /* _CPP_U8GLIB */ |
|||
@ -0,0 +1,130 @@ |
|||
/* |
|||
|
|||
Bitmap.pde |
|||
|
|||
Show simple bitmap |
|||
|
|||
>>> Before compiling: Please remove comment from the constructor of the |
|||
>>> connected graphics display (see below). |
|||
|
|||
Universal 8bit Graphics Library, http://code.google.com/p/u8glib/ |
|||
|
|||
Copyright (c) 2011, olikraus@gmail.com |
|||
All rights reserved. |
|||
|
|||
Redistribution and use in source and binary forms, with or without modification, |
|||
are permitted provided that the following conditions are met: |
|||
|
|||
* Redistributions of source code must retain the above copyright notice, this list |
|||
of conditions and the following disclaimer. |
|||
|
|||
* Redistributions in binary form must reproduce the above copyright notice, this |
|||
list of conditions and the following disclaimer in the documentation and/or other |
|||
materials provided with the distribution. |
|||
|
|||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
|||
CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
|||
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
|||
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
|||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
|||
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
|||
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
|||
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
|||
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
|||
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF |
|||
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|||
|
|||
*/ |
|||
|
|||
|
|||
#include "U8glib.h" |
|||
|
|||
// setup u8g object, please remove comment from one of the following constructor calls |
|||
// IMPORTANT NOTE: The complete list of supported devices is here: http://code.google.com/p/u8glib/wiki/device |
|||
|
|||
//U8GLIB_NHD27OLED_BW u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_NHD27OLED_2X_BW u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_NHD27OLED_GR u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_NHD27OLED_2X_GR u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_NHD31OLED_BW u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_NHD31OLED_2X_BW u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_NHD31OLED_GR u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_NHD31OLED_2X_GR u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_DOGS102 u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_DOGM132 u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_DOGM128 u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_ST7920_128X64_1X u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, di=17,rw=16 |
|||
//U8GLIB_ST7920_128X64_4X u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, di=17,rw=16 |
|||
//U8GLIB_ST7920_128X64_1X u8g(18, 16, 17); // SPI Com: SCK = en = 18, MOSI = rw = 16, CS = di = 17 |
|||
//U8GLIB_ST7920_128X64_4X u8g(18, 16, 17); // SPI Com: SCK = en = 18, MOSI = rw = 16, CS = di = 17 |
|||
//U8GLIB_ST7920_192X32_1X u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, di=17,rw=16 |
|||
//U8GLIB_ST7920_192X32_4X u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, di=17,rw=16 |
|||
//U8GLIB_ST7920_192X32_1X u8g(18, 16, 17); // SPI Com: SCK = en = 18, MOSI = rw = 16, CS = di = 17 |
|||
//U8GLIB_ST7920_192X32_4X u8g(18, 16, 17); // SPI Com: SCK = en = 18, MOSI = rw = 16, CS = di = 17 |
|||
//U8GLIB_ST7920_192X32_1X u8g(13, 11, 10); // SPI Com: SCK = en = 13, MOSI = rw = 11, CS = di = 10 |
|||
//U8GLIB_ST7920_192X32_4X u8g(10); // SPI Com: SCK = en = 13, MOSI = rw = 11, CS = di = 10, HW SPI |
|||
//U8GLIB_ST7920_202X32_1X u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, di=17,rw=16 |
|||
//U8GLIB_ST7920_202X32_4X u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, di=17,rw=16 |
|||
//U8GLIB_ST7920_202X32_1X u8g(18, 16, 17); // SPI Com: SCK = en = 18, MOSI = rw = 16, CS = di = 17 |
|||
//U8GLIB_ST7920_202X32_4X u8g(18, 16, 17); // SPI Com: SCK = en = 18, MOSI = rw = 16, CS = di = 17 |
|||
//U8GLIB_LM6059 u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_LM6063 u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_DOGXL160_BW u8g(10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_DOGXL160_GR u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_DOGXL160_2X_BW u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_DOGXL160_2X_GR u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_PCD8544 u8g(13, 11, 10, 9, 8); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9, Reset = 8 |
|||
//U8GLIB_PCF8812 u8g(13, 11, 10, 9, 8); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9, Reset = 8 |
|||
//U8GLIB_KS0108_128 u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 14, 15, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, cs1=14, cs2=15,di=17,rw=16 |
|||
//U8GLIB_LC7981_160X80 u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 14, 15, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, cs=14 ,di=15,rw=17, reset = 16 |
|||
//U8GLIB_LC7981_240X64 u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 14, 15, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, cs=14 ,di=15,rw=17, reset = 16 |
|||
//U8GLIB_LC7981_240X128 u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 14, 15, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, cs=14 ,di=15,rw=17, reset = 16 |
|||
//U8GLIB_ILI9325D_320x240 u8g(18,17,19,U8G_PIN_NONE,16 ); // 8Bit Com: D0..D7: 0,1,2,3,4,5,6,7 en=wr=18, cs=17, rs=19, rd=U8G_PIN_NONE, reset = 16 |
|||
//U8GLIB_SBN1661_122X32 u8g(8,9,10,11,4,5,6,7,14,15, 17, U8G_PIN_NONE, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 cs1=14, cs2=15,di=17,rw=16,reset = 16 |
|||
//U8GLIB_SSD1306_128X64 u8g(13, 11, 10, 9); // SW SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_SSD1306_128X64 u8g(10, 9); // HW SPI Com: CS = 10, A0 = 9 (Hardware Pins are SCK = 13 and MOSI = 11) |
|||
//U8GLIB_SSD1306_128X64 u8g(U8G_I2C_OPT_NONE); // HW SPI Com: CS = 10, A0 = 9 (Hardware Pins are SCK = 13 and MOSI = 11) |
|||
//U8GLIB_SSD1306_128X32 u8g(13, 11, 10, 9); // SW SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_SSD1306_128X32 u8g(10, 9); // HW SPI Com: CS = 10, A0 = 9 (Hardware Pins are SCK = 13 and MOSI = 11) |
|||
//U8GLIB_SSD1306_128X32 u8g(U8G_I2C_OPT_NONE); // HW SPI Com: CS = 10, A0 = 9 (Hardware Pins are SCK = 13 and MOSI = 11) |
|||
//U8GLIB_SSD1309_128X64 u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_SSD1327_96X96_GR u8g(U8G_I2C_OPT_NONE); // I2C |
|||
//U8GLIB_SSD1327_96X96_2X_GR u8g(U8G_I2C_OPT_NONE); // I2C |
|||
//U8GLIB_NHD_C12864 u8g(13, 11, 10, 9, 8); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9, RST = 8 |
|||
//U8GLIB_NHD_C12832 u8g(13, 11, 10, 9, 8); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9, RST = 8 |
|||
//U8GLIB_T6963_240X128 u8g(8, 9, 10, 11, 4, 5, 6, 7, 14, 15, 17, 18, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7, cs=14, a0=15, wr=17, rd=18, reset=16 |
|||
//U8GLIB_T6963_240X64 u8g(8, 9, 10, 11, 4, 5, 6, 7, 14, 15, 17, 18, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7, cs=14, a0=15, wr=17, rd=18, reset=16 |
|||
//U8GLIB_T6963_128X64 u8g(8, 9, 10, 11, 4, 5, 6, 7, 14, 15, 17, 18, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7, cs=14, a0=15, wr=17, rd=18, reset=16 |
|||
|
|||
const uint8_t rook_bitmap[] PROGMEM = { |
|||
0x00, // 00000000 |
|||
0x55, // 01010101 |
|||
0x7f, // 01111111 |
|||
0x3e, // 00111110 |
|||
0x3e, // 00111110 |
|||
0x3e, // 00111110 |
|||
0x3e, // 00111110 |
|||
0x7f // 01111111 |
|||
}; |
|||
|
|||
void draw(void) { |
|||
// graphic commands to redraw the complete screen should be placed here |
|||
u8g.drawBitmapP( 0, 0, 1, 8, rook_bitmap); |
|||
} |
|||
|
|||
void setup(void) { |
|||
} |
|||
|
|||
void loop(void) { |
|||
// picture loop |
|||
u8g.firstPage(); |
|||
do { |
|||
draw(); |
|||
} while( u8g.nextPage() ); |
|||
|
|||
// rebuild the picture after some delay |
|||
delay(1000); |
|||
} |
|||
|
|||
@ -0,0 +1,180 @@ |
|||
/* |
|||
|
|||
Chess.pde |
|||
|
|||
Little Rook Chess |
|||
|
|||
>>> Before compiling: Please remove comment from the constructor of the |
|||
>>> connected graphics display (see below). |
|||
|
|||
Universal 8bit Graphics Library, http://code.google.com/p/u8glib/ |
|||
|
|||
Copyright (c) 2012, olikraus@gmail.com |
|||
All rights reserved. |
|||
|
|||
Redistribution and use in source and binary forms, with or without modification, |
|||
are permitted provided that the following conditions are met: |
|||
|
|||
* Redistributions of source code must retain the above copyright notice, this list |
|||
of conditions and the following disclaimer. |
|||
|
|||
* Redistributions in binary form must reproduce the above copyright notice, this |
|||
list of conditions and the following disclaimer in the documentation and/or other |
|||
materials provided with the distribution. |
|||
|
|||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
|||
CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
|||
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
|||
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
|||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
|||
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
|||
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
|||
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
|||
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
|||
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF |
|||
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|||
|
|||
|
|||
*/ |
|||
|
|||
|
|||
#include "U8glib.h" |
|||
|
|||
// setup u8g object, please remove comment from one of the following constructor calls |
|||
// IMPORTANT NOTE: The complete list of supported devices is here: http://code.google.com/p/u8glib/wiki/device |
|||
|
|||
//U8GLIB_NHD27OLED_BW u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_NHD27OLED_2X_BW u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_NHD27OLED_GR u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_NHD27OLED_2X_GR u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_NHD31OLED_BW u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_NHD31OLED_2X_BW u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_NHD31OLED_GR u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_NHD31OLED_2X_GR u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_DOGS102 u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_DOGM132 u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_DOGM128 u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_ST7920_128X64_1X u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, di=17,rw=16 |
|||
//U8GLIB_ST7920_128X64_4X u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, di=17,rw=16 |
|||
//U8GLIB_ST7920_128X64_1X u8g(18, 16, 17); // SPI Com: SCK = en = 18, MOSI = rw = 16, CS = di = 17 |
|||
//U8GLIB_ST7920_128X64_4X u8g(18, 16, 17); // SPI Com: SCK = en = 18, MOSI = rw = 16, CS = di = 17 |
|||
//U8GLIB_ST7920_192X32_1X u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, di=17,rw=16 |
|||
//U8GLIB_ST7920_192X32_4X u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, di=17,rw=16 |
|||
//U8GLIB_ST7920_192X32_1X u8g(18, 16, 17); // SPI Com: SCK = en = 18, MOSI = rw = 16, CS = di = 17 |
|||
//U8GLIB_ST7920_192X32_4X u8g(18, 16, 17); // SPI Com: SCK = en = 18, MOSI = rw = 16, CS = di = 17 |
|||
//U8GLIB_ST7920_192X32_1X u8g(13, 11, 10); // SPI Com: SCK = en = 13, MOSI = rw = 11, CS = di = 10 |
|||
//U8GLIB_ST7920_192X32_4X u8g(10); // SPI Com: SCK = en = 13, MOSI = rw = 11, CS = di = 10, HW SPI |
|||
//U8GLIB_ST7920_202X32_1X u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, di=17,rw=16 |
|||
//U8GLIB_ST7920_202X32_4X u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, di=17,rw=16 |
|||
//U8GLIB_ST7920_202X32_1X u8g(18, 16, 17); // SPI Com: SCK = en = 18, MOSI = rw = 16, CS = di = 17 |
|||
//U8GLIB_ST7920_202X32_4X u8g(18, 16, 17); // SPI Com: SCK = en = 18, MOSI = rw = 16, CS = di = 17 |
|||
//U8GLIB_LM6059 u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_LM6063 u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_DOGXL160_BW u8g(10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_DOGXL160_GR u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_DOGXL160_2X_BW u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_DOGXL160_2X_GR u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_PCD8544 u8g(13, 11, 10, 9, 8); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9, Reset = 8 |
|||
//U8GLIB_PCF8812 u8g(13, 11, 10, 9, 8); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9, Reset = 8 |
|||
//U8GLIB_KS0108_128 u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 14, 15, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, cs1=14, cs2=15,di=17,rw=16 |
|||
//U8GLIB_LC7981_160X80 u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 14, 15, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, cs=14 ,di=15,rw=17, reset = 16 |
|||
//U8GLIB_LC7981_240X64 u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 14, 15, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, cs=14 ,di=15,rw=17, reset = 16 |
|||
//U8GLIB_LC7981_240X128 u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 14, 15, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, cs=14 ,di=15,rw=17, reset = 16 |
|||
//U8GLIB_ILI9325D_320x240 u8g(18,17,19,U8G_PIN_NONE,16 ); // 8Bit Com: D0..D7: 0,1,2,3,4,5,6,7 en=wr=18, cs=17, rs=19, rd=U8G_PIN_NONE, reset = 16 |
|||
//U8GLIB_SBN1661_122X32 u8g(8,9,10,11,4,5,6,7,14,15, 17, U8G_PIN_NONE, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 cs1=14, cs2=15,di=17,rw=16,reset = 16 |
|||
//U8GLIB_SSD1306_128X64 u8g(13, 11, 10, 9); // SW SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_SSD1306_128X64 u8g(10, 9); // HW SPI Com: CS = 10, A0 = 9 (Hardware Pins are SCK = 13 and MOSI = 11) |
|||
//U8GLIB_SSD1306_128X64 u8g(U8G_I2C_OPT_NONE); // HW SPI Com: CS = 10, A0 = 9 (Hardware Pins are SCK = 13 and MOSI = 11) |
|||
//U8GLIB_SSD1306_128X32 u8g(13, 11, 10, 9); // SW SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_SSD1306_128X32 u8g(10, 9); // HW SPI Com: CS = 10, A0 = 9 (Hardware Pins are SCK = 13 and MOSI = 11) |
|||
//U8GLIB_SSD1306_128X32 u8g(U8G_I2C_OPT_NONE); // HW SPI Com: CS = 10, A0 = 9 (Hardware Pins are SCK = 13 and MOSI = 11) |
|||
//U8GLIB_SSD1309_128X64 u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_SSD1327_96X96_GR u8g(U8G_I2C_OPT_NONE); // I2C |
|||
//U8GLIB_SSD1327_96X96_2X_GR u8g(U8G_I2C_OPT_NONE); // I2C |
|||
//U8GLIB_NHD_C12864 u8g(13, 11, 10, 9, 8); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9, RST = 8 |
|||
//U8GLIB_NHD_C12832 u8g(13, 11, 10, 9, 8); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9, RST = 8 |
|||
//U8GLIB_T6963_240X128 u8g(8, 9, 10, 11, 4, 5, 6, 7, 14, 15, 17, 18, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7, cs=14, a0=15, wr=17, rd=18, reset=16 |
|||
//U8GLIB_T6963_240X64 u8g(8, 9, 10, 11, 4, 5, 6, 7, 14, 15, 17, 18, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7, cs=14, a0=15, wr=17, rd=18, reset=16 |
|||
//U8GLIB_T6963_128X64 u8g(8, 9, 10, 11, 4, 5, 6, 7, 14, 15, 17, 18, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7, cs=14, a0=15, wr=17, rd=18, reset=16 |
|||
|
|||
|
|||
// DOGS102 shield configuration values |
|||
uint8_t uiKeyPrev = 2; |
|||
uint8_t uiKeyNext = 4; |
|||
uint8_t uiKeySelect = 5; |
|||
uint8_t uiKeyBack = 3; |
|||
|
|||
// DOGM128-Shield configuration values |
|||
// DOGXL60-Shield configuration values |
|||
//uint8_t uiKeyPrev = 7; |
|||
//uint8_t uiKeyNext = 3; |
|||
//uint8_t uiKeySelect = 2; |
|||
//uint8_t uiKeyBack = 8; |
|||
|
|||
uint8_t uiKeyCodeFirst = CHESS_KEY_NONE; |
|||
uint8_t uiKeyCodeSecond = CHESS_KEY_NONE; |
|||
uint8_t uiKeyCode = CHESS_KEY_NONE; |
|||
|
|||
|
|||
void uiSetup(void) { |
|||
// configure input keys |
|||
|
|||
pinMode(uiKeyPrev, INPUT); // set pin to input |
|||
digitalWrite(uiKeyPrev, HIGH); // turn on pullup resistors |
|||
pinMode(uiKeyNext, INPUT); // set pin to input |
|||
digitalWrite(uiKeyNext, HIGH); // turn on pullup resistors |
|||
pinMode(uiKeySelect, INPUT); // set pin to input |
|||
digitalWrite(uiKeySelect, HIGH); // turn on pullup resistors |
|||
pinMode(uiKeyBack, INPUT); // set pin to input |
|||
digitalWrite(uiKeyBack, HIGH); // turn on pullup resistors |
|||
} |
|||
|
|||
void uiStep(void) |
|||
{ |
|||
uiKeyCodeSecond = uiKeyCodeFirst; |
|||
if ( digitalRead(uiKeyPrev) == LOW ) |
|||
uiKeyCodeFirst = CHESS_KEY_PREV; |
|||
else if ( digitalRead(uiKeyNext) == LOW ) |
|||
uiKeyCodeFirst = CHESS_KEY_NEXT; |
|||
else if ( digitalRead(uiKeySelect) == LOW ) |
|||
uiKeyCodeFirst = CHESS_KEY_SELECT; |
|||
else if ( digitalRead(uiKeyBack) == LOW ) |
|||
uiKeyCodeFirst = CHESS_KEY_BACK; |
|||
else |
|||
uiKeyCodeFirst = CHESS_KEY_NONE; |
|||
|
|||
if ( uiKeyCodeSecond == uiKeyCodeFirst ) |
|||
uiKeyCode = uiKeyCodeFirst; |
|||
else |
|||
uiKeyCode = CHESS_KEY_NONE; |
|||
} |
|||
|
|||
|
|||
void setup() { |
|||
// rotate screen, if required |
|||
u8g.setRot180(); |
|||
|
|||
uiSetup(); |
|||
chess_Init(u8g.getU8g(), 0); |
|||
} |
|||
|
|||
void loop() { |
|||
uint8_t keyCode = CHESS_KEY_NONE; |
|||
|
|||
u8g.firstPage(); |
|||
do { |
|||
chess_Draw(); |
|||
uiStep(); |
|||
if ( uiKeyCode != CHESS_KEY_NONE ) |
|||
keyCode = uiKeyCode; |
|||
} while( u8g.nextPage() ); |
|||
|
|||
u8g_Delay(10); |
|||
chess_Step(keyCode); |
|||
uiStep(); |
|||
keyCode = uiKeyCode; |
|||
} |
|||
|
|||
|
|||
@ -0,0 +1,230 @@ |
|||
/* |
|||
|
|||
Console.pde |
|||
|
|||
Read from serial monitor, output to display |
|||
|
|||
>>> Before compiling: Please remove comment from the constructor of the |
|||
>>> connected graphics display (see below). |
|||
|
|||
Universal 8bit Graphics Library, http://code.google.com/p/u8glib/ |
|||
|
|||
Copyright (c) 2011, olikraus@gmail.com |
|||
All rights reserved. |
|||
|
|||
Redistribution and use in source and binary forms, with or without modification, |
|||
are permitted provided that the following conditions are met: |
|||
|
|||
* Redistributions of source code must retain the above copyright notice, this list |
|||
of conditions and the following disclaimer. |
|||
|
|||
* Redistributions in binary form must reproduce the above copyright notice, this |
|||
list of conditions and the following disclaimer in the documentation and/or other |
|||
materials provided with the distribution. |
|||
|
|||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
|||
CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
|||
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
|||
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
|||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
|||
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
|||
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
|||
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
|||
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
|||
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF |
|||
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|||
|
|||
*/ |
|||
|
|||
|
|||
#include "U8glib.h" |
|||
|
|||
// setup u8g object, please remove comment from one of the following constructor calls |
|||
// IMPORTANT NOTE: The complete list of supported devices is here: http://code.google.com/p/u8glib/wiki/device |
|||
|
|||
//U8GLIB_NHD27OLED_BW u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_NHD27OLED_2X_BW u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_NHD27OLED_GR u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_NHD27OLED_2X_GR u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_NHD31OLED_BW u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_NHD31OLED_2X_BW u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_NHD31OLED_GR u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_NHD31OLED_2X_GR u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_DOGS102 u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_DOGM132 u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_DOGM128 u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_ST7920_128X64_1X u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, di=17,rw=16 |
|||
//U8GLIB_ST7920_128X64_4X u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, di=17,rw=16 |
|||
//U8GLIB_ST7920_128X64_1X u8g(18, 16, 17); // SPI Com: SCK = en = 18, MOSI = rw = 16, CS = di = 17 |
|||
//U8GLIB_ST7920_128X64_4X u8g(18, 16, 17); // SPI Com: SCK = en = 18, MOSI = rw = 16, CS = di = 17 |
|||
//U8GLIB_ST7920_192X32_1X u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, di=17,rw=16 |
|||
//U8GLIB_ST7920_192X32_4X u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, di=17,rw=16 |
|||
//U8GLIB_ST7920_192X32_1X u8g(18, 16, 17); // SPI Com: SCK = en = 18, MOSI = rw = 16, CS = di = 17 |
|||
//U8GLIB_ST7920_192X32_4X u8g(18, 16, 17); // SPI Com: SCK = en = 18, MOSI = rw = 16, CS = di = 17 |
|||
//U8GLIB_ST7920_192X32_1X u8g(13, 11, 10); // SPI Com: SCK = en = 13, MOSI = rw = 11, CS = di = 10 |
|||
//U8GLIB_ST7920_192X32_4X u8g(10); // SPI Com: SCK = en = 13, MOSI = rw = 11, CS = di = 10, HW SPI |
|||
//U8GLIB_ST7920_202X32_1X u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, di=17,rw=16 |
|||
//U8GLIB_ST7920_202X32_4X u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, di=17,rw=16 |
|||
//U8GLIB_ST7920_202X32_1X u8g(18, 16, 17); // SPI Com: SCK = en = 18, MOSI = rw = 16, CS = di = 17 |
|||
//U8GLIB_ST7920_202X32_4X u8g(18, 16, 17); // SPI Com: SCK = en = 18, MOSI = rw = 16, CS = di = 17 |
|||
//U8GLIB_LM6059 u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_LM6063 u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_DOGXL160_BW u8g(10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_DOGXL160_GR u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_DOGXL160_2X_BW u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_DOGXL160_2X_GR u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_PCD8544 u8g(13, 11, 10, 9, 8); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9, Reset = 8 |
|||
//U8GLIB_PCF8812 u8g(13, 11, 10, 9, 8); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9, Reset = 8 |
|||
//U8GLIB_KS0108_128 u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 14, 15, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, cs1=14, cs2=15,di=17,rw=16 |
|||
//U8GLIB_LC7981_160X80 u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 14, 15, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, cs=14 ,di=15,rw=17, reset = 16 |
|||
//U8GLIB_LC7981_240X64 u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 14, 15, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, cs=14 ,di=15,rw=17, reset = 16 |
|||
//U8GLIB_LC7981_240X128 u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 14, 15, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, cs=14 ,di=15,rw=17, reset = 16 |
|||
//U8GLIB_ILI9325D_320x240 u8g(18,17,19,U8G_PIN_NONE,16 ); // 8Bit Com: D0..D7: 0,1,2,3,4,5,6,7 en=wr=18, cs=17, rs=19, rd=U8G_PIN_NONE, reset = 16 |
|||
//U8GLIB_SBN1661_122X32 u8g(8,9,10,11,4,5,6,7,14,15, 17, U8G_PIN_NONE, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 cs1=14, cs2=15,di=17,rw=16,reset = 16 |
|||
//U8GLIB_SSD1306_128X64 u8g(13, 11, 10, 9); // SW SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_SSD1306_128X64 u8g(10, 9); // HW SPI Com: CS = 10, A0 = 9 (Hardware Pins are SCK = 13 and MOSI = 11) |
|||
//U8GLIB_SSD1306_128X64 u8g(U8G_I2C_OPT_NONE); // HW SPI Com: CS = 10, A0 = 9 (Hardware Pins are SCK = 13 and MOSI = 11) |
|||
//U8GLIB_SSD1306_128X32 u8g(13, 11, 10, 9); // SW SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_SSD1306_128X32 u8g(10, 9); // HW SPI Com: CS = 10, A0 = 9 (Hardware Pins are SCK = 13 and MOSI = 11) |
|||
//U8GLIB_SSD1306_128X32 u8g(U8G_I2C_OPT_NONE); // HW SPI Com: CS = 10, A0 = 9 (Hardware Pins are SCK = 13 and MOSI = 11) |
|||
//U8GLIB_SSD1309_128X64 u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_SSD1327_96X96_GR u8g(U8G_I2C_OPT_NONE); // I2C |
|||
//U8GLIB_SSD1327_96X96_2X_GR u8g(U8G_I2C_OPT_NONE); // I2C |
|||
//U8GLIB_NHD_C12864 u8g(13, 11, 10, 9, 8); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9, RST = 8 |
|||
//U8GLIB_NHD_C12832 u8g(13, 11, 10, 9, 8); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9, RST = 8 |
|||
//U8GLIB_T6963_240X128 u8g(8, 9, 10, 11, 4, 5, 6, 7, 14, 15, 17, 18, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7, cs=14, a0=15, wr=17, rd=18, reset=16 |
|||
//U8GLIB_T6963_240X64 u8g(8, 9, 10, 11, 4, 5, 6, 7, 14, 15, 17, 18, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7, cs=14, a0=15, wr=17, rd=18, reset=16 |
|||
//U8GLIB_T6963_128X64 u8g(8, 9, 10, 11, 4, 5, 6, 7, 14, 15, 17, 18, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7, cs=14, a0=15, wr=17, rd=18, reset=16 |
|||
|
|||
|
|||
// setup input buffer |
|||
#define LINE_MAX 30 |
|||
uint8_t line_buf[LINE_MAX] = "U8GLIB Console"; |
|||
uint8_t line_pos = 0; |
|||
|
|||
// setup a text screen to support scrolling |
|||
#define ROW_MAX 12 |
|||
|
|||
|
|||
uint8_t screen[ROW_MAX][LINE_MAX]; |
|||
uint8_t rows, cols; |
|||
|
|||
// line height, which matches the selected font (5x7) |
|||
#define LINE_PIXEL_HEIGHT 7 |
|||
|
|||
// clear entire screen, called during setup |
|||
void clear_screen(void) { |
|||
uint8_t i, j; |
|||
for( i = 0; i < ROW_MAX; i++ ) |
|||
for( j = 0; j < LINE_MAX; j++ ) |
|||
screen[i][j] = 0; |
|||
} |
|||
|
|||
// append a line to the screen, scroll up |
|||
void add_line_to_screen(void) { |
|||
uint8_t i, j; |
|||
for( j = 0; j < LINE_MAX; j++ ) |
|||
for( i = 0; i < rows-1; i++ ) |
|||
screen[i][j] = screen[i+1][j]; |
|||
|
|||
for( j = 0; j < LINE_MAX; j++ ) |
|||
screen[rows-1][j] = line_buf[j]; |
|||
} |
|||
|
|||
// U8GLIB draw procedure: output the screen |
|||
void draw(void) { |
|||
uint8_t i, y; |
|||
// graphic commands to redraw the complete screen are placed here |
|||
y = 0; // reference is the top left -1 position of the string |
|||
y--; // correct the -1 position of the drawStr |
|||
for( i = 0; i < rows; i++ ) |
|||
{ |
|||
u8g.drawStr( 0, y, (char *)(screen[i])); |
|||
y += u8g.getFontLineSpacing(); |
|||
} |
|||
} |
|||
|
|||
void exec_line(void) { |
|||
// echo line to the serial monitor |
|||
Serial.println((const char *)line_buf); |
|||
|
|||
// add the line to the screen |
|||
add_line_to_screen(); |
|||
|
|||
// U8GLIB picture loop |
|||
u8g.firstPage(); |
|||
do { |
|||
draw(); |
|||
} while( u8g.nextPage() ); |
|||
} |
|||
|
|||
// clear current input buffer |
|||
void reset_line(void) { |
|||
line_pos = 0; |
|||
line_buf[line_pos] = '\0'; |
|||
} |
|||
|
|||
// add a single character to the input buffer |
|||
void char_to_line(uint8_t c) { |
|||
line_buf[line_pos] = c; |
|||
line_pos++; |
|||
line_buf[line_pos] = '\0'; |
|||
} |
|||
|
|||
// check serial in and handle the character |
|||
void read_line(void) { |
|||
if ( Serial.available() ) |
|||
{ |
|||
uint8_t c; |
|||
c = Serial.read(); |
|||
if ( line_pos >= cols-1 ) { |
|||
exec_line(); |
|||
reset_line(); |
|||
char_to_line(c); |
|||
} |
|||
else if ( c == '\n' ) { |
|||
// ignore '\n' |
|||
} |
|||
else if ( c == '\r' ) { |
|||
exec_line(); |
|||
reset_line(); |
|||
} |
|||
else { |
|||
char_to_line(c); |
|||
} |
|||
} |
|||
} |
|||
|
|||
// Arduino master setup |
|||
void setup(void) { |
|||
// set font for the console window |
|||
u8g.setFont(u8g_font_5x7); |
|||
//u8g.setFont(u8g_font_9x15); |
|||
|
|||
// set upper left position for the string draw procedure |
|||
u8g.setFontPosTop(); |
|||
|
|||
// calculate the number of rows for the display |
|||
rows = u8g.getHeight() / u8g.getFontLineSpacing(); |
|||
if ( rows > ROW_MAX ) |
|||
rows = ROW_MAX; |
|||
|
|||
// estimate the number of columns for the display |
|||
cols = u8g.getWidth() / u8g.getStrWidth("m"); |
|||
if ( cols > LINE_MAX-1 ) |
|||
cols = LINE_MAX-1; |
|||
|
|||
clear_screen(); // clear screen |
|||
delay(1000); // do some delay |
|||
Serial.begin(9600); // init serial |
|||
exec_line(); // place the input buffer into the screen |
|||
reset_line(); // clear input buffer |
|||
} |
|||
|
|||
// Arduino main loop |
|||
void loop(void) { |
|||
read_line(); |
|||
} |
|||
|
|||
@ -0,0 +1,139 @@ |
|||
/* |
|||
|
|||
F.pde |
|||
|
|||
Example code for the F() macro. |
|||
|
|||
>>> This example requires Arduino 1.0 and above. |
|||
|
|||
>>> Before compiling: Please remove comment from the constructor of the |
|||
>>> connected graphics display (see below). |
|||
|
|||
Universal 8bit Graphics Library, http://code.google.com/p/u8glib/ |
|||
|
|||
Copyright (c) 2012, olikraus@gmail.com |
|||
All rights reserved. |
|||
|
|||
Redistribution and use in source and binary forms, with or without modification, |
|||
are permitted provided that the following conditions are met: |
|||
|
|||
* Redistributions of source code must retain the above copyright notice, this list |
|||
of conditions and the following disclaimer. |
|||
|
|||
* Redistributions in binary form must reproduce the above copyright notice, this |
|||
list of conditions and the following disclaimer in the documentation and/or other |
|||
materials provided with the distribution. |
|||
|
|||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
|||
CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
|||
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
|||
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
|||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
|||
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
|||
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
|||
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
|||
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
|||
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF |
|||
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|||
|
|||
*/ |
|||
|
|||
|
|||
#include "U8glib.h" |
|||
|
|||
// setup u8g object, please remove comment from one of the following constructor calls |
|||
// IMPORTANT NOTE: The complete list of supported devices is here: http://code.google.com/p/u8glib/wiki/device |
|||
|
|||
//U8GLIB_NHD27OLED_BW u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_NHD27OLED_2X_BW u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_NHD27OLED_GR u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_NHD27OLED_2X_GR u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_NHD31OLED_BW u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_NHD31OLED_2X_BW u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_NHD31OLED_GR u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_NHD31OLED_2X_GR u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_DOGS102 u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_DOGM132 u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_DOGM128 u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_ST7920_128X64_1X u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, di=17,rw=16 |
|||
//U8GLIB_ST7920_128X64_4X u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, di=17,rw=16 |
|||
//U8GLIB_ST7920_128X64_1X u8g(18, 16, 17); // SPI Com: SCK = en = 18, MOSI = rw = 16, CS = di = 17 |
|||
//U8GLIB_ST7920_128X64_4X u8g(18, 16, 17); // SPI Com: SCK = en = 18, MOSI = rw = 16, CS = di = 17 |
|||
//U8GLIB_ST7920_192X32_1X u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, di=17,rw=16 |
|||
//U8GLIB_ST7920_192X32_4X u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, di=17,rw=16 |
|||
//U8GLIB_ST7920_192X32_1X u8g(18, 16, 17); // SPI Com: SCK = en = 18, MOSI = rw = 16, CS = di = 17 |
|||
//U8GLIB_ST7920_192X32_4X u8g(18, 16, 17); // SPI Com: SCK = en = 18, MOSI = rw = 16, CS = di = 17 |
|||
//U8GLIB_ST7920_192X32_1X u8g(13, 11, 10); // SPI Com: SCK = en = 13, MOSI = rw = 11, CS = di = 10 |
|||
//U8GLIB_ST7920_192X32_4X u8g(10); // SPI Com: SCK = en = 13, MOSI = rw = 11, CS = di = 10, HW SPI |
|||
//U8GLIB_ST7920_202X32_1X u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, di=17,rw=16 |
|||
//U8GLIB_ST7920_202X32_4X u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, di=17,rw=16 |
|||
//U8GLIB_ST7920_202X32_1X u8g(18, 16, 17); // SPI Com: SCK = en = 18, MOSI = rw = 16, CS = di = 17 |
|||
//U8GLIB_ST7920_202X32_4X u8g(18, 16, 17); // SPI Com: SCK = en = 18, MOSI = rw = 16, CS = di = 17 |
|||
//U8GLIB_LM6059 u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_LM6063 u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_DOGXL160_BW u8g(10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_DOGXL160_GR u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_DOGXL160_2X_BW u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_DOGXL160_2X_GR u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_PCD8544 u8g(13, 11, 10, 9, 8); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9, Reset = 8 |
|||
//U8GLIB_PCF8812 u8g(13, 11, 10, 9, 8); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9, Reset = 8 |
|||
//U8GLIB_KS0108_128 u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 14, 15, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, cs1=14, cs2=15,di=17,rw=16 |
|||
//U8GLIB_LC7981_160X80 u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 14, 15, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, cs=14 ,di=15,rw=17, reset = 16 |
|||
//U8GLIB_LC7981_240X64 u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 14, 15, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, cs=14 ,di=15,rw=17, reset = 16 |
|||
//U8GLIB_LC7981_240X128 u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 14, 15, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, cs=14 ,di=15,rw=17, reset = 16 |
|||
//U8GLIB_ILI9325D_320x240 u8g(18,17,19,U8G_PIN_NONE,16 ); // 8Bit Com: D0..D7: 0,1,2,3,4,5,6,7 en=wr=18, cs=17, rs=19, rd=U8G_PIN_NONE, reset = 16 |
|||
//U8GLIB_SBN1661_122X32 u8g(8,9,10,11,4,5,6,7,14,15, 17, U8G_PIN_NONE, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 cs1=14, cs2=15,di=17,rw=16,reset = 16 |
|||
//U8GLIB_SSD1306_128X64 u8g(13, 11, 10, 9); // SW SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_SSD1306_128X64 u8g(10, 9); // HW SPI Com: CS = 10, A0 = 9 (Hardware Pins are SCK = 13 and MOSI = 11) |
|||
//U8GLIB_SSD1306_128X64 u8g(U8G_I2C_OPT_NONE); // HW SPI Com: CS = 10, A0 = 9 (Hardware Pins are SCK = 13 and MOSI = 11) |
|||
//U8GLIB_SSD1306_128X32 u8g(13, 11, 10, 9); // SW SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_SSD1306_128X32 u8g(10, 9); // HW SPI Com: CS = 10, A0 = 9 (Hardware Pins are SCK = 13 and MOSI = 11) |
|||
//U8GLIB_SSD1306_128X32 u8g(U8G_I2C_OPT_NONE); // HW SPI Com: CS = 10, A0 = 9 (Hardware Pins are SCK = 13 and MOSI = 11) |
|||
//U8GLIB_SSD1309_128X64 u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_SSD1327_96X96_GR u8g(U8G_I2C_OPT_NONE); // I2C |
|||
//U8GLIB_SSD1327_96X96_2X_GR u8g(U8G_I2C_OPT_NONE); // I2C |
|||
//U8GLIB_NHD_C12864 u8g(13, 11, 10, 9, 8); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9, RST = 8 |
|||
//U8GLIB_NHD_C12832 u8g(13, 11, 10, 9, 8); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9, RST = 8 |
|||
//U8GLIB_T6963_240X128 u8g(8, 9, 10, 11, 4, 5, 6, 7, 14, 15, 17, 18, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7, cs=14, a0=15, wr=17, rd=18, reset=16 |
|||
//U8GLIB_T6963_240X64 u8g(8, 9, 10, 11, 4, 5, 6, 7, 14, 15, 17, 18, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7, cs=14, a0=15, wr=17, rd=18, reset=16 |
|||
//U8GLIB_T6963_128X64 u8g(8, 9, 10, 11, 4, 5, 6, 7, 14, 15, 17, 18, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7, cs=14, a0=15, wr=17, rd=18, reset=16 |
|||
|
|||
void draw(void) { |
|||
// graphic commands to redraw the complete screen should be placed here |
|||
|
|||
// assign default font |
|||
u8g.setFont(u8g_font_unifont); |
|||
|
|||
// pointer to strings in flash memory can be stored in a special type |
|||
const __FlashStringHelper *flash_ptr; |
|||
|
|||
// the result of the F() macro can be assigned to this pointer |
|||
flash_ptr = F("Hello World!"); |
|||
|
|||
// this pointer can be used as argument to the draw procedures |
|||
u8g.drawStr( 0+1, 20+1, flash_ptr); |
|||
u8g.drawStr( 0, 20, flash_ptr); |
|||
|
|||
// of course, the F() macro can be used directly |
|||
u8g.drawStr( 0, 40, F("PROGMEM")); |
|||
|
|||
} |
|||
|
|||
void setup(void) { |
|||
// flip screen, if required |
|||
// u8g.setRot180(); |
|||
} |
|||
|
|||
void loop(void) { |
|||
// picture loop |
|||
u8g.firstPage(); |
|||
do { |
|||
draw(); |
|||
} while( u8g.nextPage() ); |
|||
|
|||
// rebuild the picture after some delay |
|||
delay(500); |
|||
} |
|||
|
|||
@ -0,0 +1,223 @@ |
|||
/* |
|||
|
|||
GraphicsTest.pde |
|||
|
|||
>>> Before compiling: Please remove comment from the constructor of the |
|||
>>> connected graphics display (see below). |
|||
|
|||
Universal 8bit Graphics Library, http://code.google.com/p/u8glib/ |
|||
|
|||
Copyright (c) 2012, olikraus@gmail.com |
|||
All rights reserved. |
|||
|
|||
Redistribution and use in source and binary forms, with or without modification, |
|||
are permitted provided that the following conditions are met: |
|||
|
|||
* Redistributions of source code must retain the above copyright notice, this list |
|||
of conditions and the following disclaimer. |
|||
|
|||
* Redistributions in binary form must reproduce the above copyright notice, this |
|||
list of conditions and the following disclaimer in the documentation and/or other |
|||
materials provided with the distribution. |
|||
|
|||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
|||
CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
|||
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
|||
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
|||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
|||
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
|||
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
|||
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
|||
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
|||
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF |
|||
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|||
|
|||
|
|||
*/ |
|||
|
|||
|
|||
#include "U8glib.h" |
|||
|
|||
// setup u8g object, please remove comment from one of the following constructor calls |
|||
// IMPORTANT NOTE: The complete list of supported devices is here: http://code.google.com/p/u8glib/wiki/device |
|||
|
|||
//U8GLIB_NHD27OLED_BW u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_NHD27OLED_2X_BW u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_NHD27OLED_GR u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_NHD27OLED_2X_GR u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_NHD31OLED_BW u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_NHD31OLED_2X_BW u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_NHD31OLED_GR u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_NHD31OLED_2X_GR u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_DOGS102 u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_DOGM132 u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_DOGM128 u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_ST7920_128X64_1X u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, di=17,rw=16 |
|||
//U8GLIB_ST7920_128X64_4X u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, di=17,rw=16 |
|||
//U8GLIB_ST7920_128X64_1X u8g(18, 16, 17); // SPI Com: SCK = en = 18, MOSI = rw = 16, CS = di = 17 |
|||
//U8GLIB_ST7920_128X64_4X u8g(18, 16, 17); // SPI Com: SCK = en = 18, MOSI = rw = 16, CS = di = 17 |
|||
//U8GLIB_ST7920_192X32_1X u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, di=17,rw=16 |
|||
//U8GLIB_ST7920_192X32_4X u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, di=17,rw=16 |
|||
//U8GLIB_ST7920_192X32_1X u8g(18, 16, 17); // SPI Com: SCK = en = 18, MOSI = rw = 16, CS = di = 17 |
|||
//U8GLIB_ST7920_192X32_4X u8g(18, 16, 17); // SPI Com: SCK = en = 18, MOSI = rw = 16, CS = di = 17 |
|||
//U8GLIB_ST7920_192X32_1X u8g(13, 11, 10); // SPI Com: SCK = en = 13, MOSI = rw = 11, CS = di = 10 |
|||
//U8GLIB_ST7920_192X32_4X u8g(10); // SPI Com: SCK = en = 13, MOSI = rw = 11, CS = di = 10, HW SPI |
|||
//U8GLIB_ST7920_202X32_1X u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, di=17,rw=16 |
|||
//U8GLIB_ST7920_202X32_4X u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, di=17,rw=16 |
|||
//U8GLIB_ST7920_202X32_1X u8g(18, 16, 17); // SPI Com: SCK = en = 18, MOSI = rw = 16, CS = di = 17 |
|||
//U8GLIB_ST7920_202X32_4X u8g(18, 16, 17); // SPI Com: SCK = en = 18, MOSI = rw = 16, CS = di = 17 |
|||
//U8GLIB_LM6059 u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_LM6063 u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_DOGXL160_BW u8g(10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_DOGXL160_GR u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_DOGXL160_2X_BW u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_DOGXL160_2X_GR u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_PCD8544 u8g(13, 11, 10, 9, 8); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9, Reset = 8 |
|||
//U8GLIB_PCF8812 u8g(13, 11, 10, 9, 8); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9, Reset = 8 |
|||
//U8GLIB_KS0108_128 u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 14, 15, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, cs1=14, cs2=15,di=17,rw=16 |
|||
//U8GLIB_LC7981_160X80 u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 14, 15, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, cs=14 ,di=15,rw=17, reset = 16 |
|||
//U8GLIB_LC7981_240X64 u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 14, 15, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, cs=14 ,di=15,rw=17, reset = 16 |
|||
//U8GLIB_LC7981_240X128 u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 14, 15, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, cs=14 ,di=15,rw=17, reset = 16 |
|||
//U8GLIB_ILI9325D_320x240 u8g(18,17,19,U8G_PIN_NONE,16 ); // 8Bit Com: D0..D7: 0,1,2,3,4,5,6,7 en=wr=18, cs=17, rs=19, rd=U8G_PIN_NONE, reset = 16 |
|||
//U8GLIB_SBN1661_122X32 u8g(8,9,10,11,4,5,6,7,14,15, 17, U8G_PIN_NONE, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 cs1=14, cs2=15,di=17,rw=16,reset = 16 |
|||
//U8GLIB_SSD1306_128X64 u8g(13, 11, 10, 9); // SW SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_SSD1306_128X64 u8g(10, 9); // HW SPI Com: CS = 10, A0 = 9 (Hardware Pins are SCK = 13 and MOSI = 11) |
|||
//U8GLIB_SSD1306_128X64 u8g(U8G_I2C_OPT_NONE); // HW SPI Com: CS = 10, A0 = 9 (Hardware Pins are SCK = 13 and MOSI = 11) |
|||
//U8GLIB_SSD1306_128X32 u8g(13, 11, 10, 9); // SW SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_SSD1306_128X32 u8g(10, 9); // HW SPI Com: CS = 10, A0 = 9 (Hardware Pins are SCK = 13 and MOSI = 11) |
|||
//U8GLIB_SSD1306_128X32 u8g(U8G_I2C_OPT_NONE); // HW SPI Com: CS = 10, A0 = 9 (Hardware Pins are SCK = 13 and MOSI = 11) |
|||
//U8GLIB_SSD1309_128X64 u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_SSD1327_96X96_GR u8g(U8G_I2C_OPT_NONE); // I2C |
|||
//U8GLIB_SSD1327_96X96_2X_GR u8g(U8G_I2C_OPT_NONE); // I2C |
|||
//U8GLIB_NHD_C12864 u8g(13, 11, 10, 9, 8); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9, RST = 8 |
|||
//U8GLIB_NHD_C12832 u8g(13, 11, 10, 9, 8); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9, RST = 8 |
|||
//U8GLIB_T6963_240X128 u8g(8, 9, 10, 11, 4, 5, 6, 7, 14, 15, 17, 18, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7, cs=14, a0=15, wr=17, rd=18, reset=16 |
|||
//U8GLIB_T6963_240X64 u8g(8, 9, 10, 11, 4, 5, 6, 7, 14, 15, 17, 18, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7, cs=14, a0=15, wr=17, rd=18, reset=16 |
|||
//U8GLIB_T6963_128X64 u8g(8, 9, 10, 11, 4, 5, 6, 7, 14, 15, 17, 18, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7, cs=14, a0=15, wr=17, rd=18, reset=16 |
|||
|
|||
void u8g_prepare(void) { |
|||
u8g.setFont(u8g_font_6x10); |
|||
u8g.setFontRefHeightExtendedText(); |
|||
u8g.setDefaultForegroundColor(); |
|||
u8g.setFontPosTop(); |
|||
} |
|||
|
|||
void u8g_box_frame(uint8_t a) { |
|||
u8g.drawStr( 0, 0, "drawBox"); |
|||
u8g.drawBox(5,10,20,10); |
|||
u8g.drawBox(10+a,15,30,7); |
|||
u8g.drawStr( 0, 30, "drawFrame"); |
|||
u8g.drawFrame(5,10+30,20,10); |
|||
u8g.drawFrame(10+a,15+30,30,7); |
|||
} |
|||
|
|||
void u8g_disc_circle(uint8_t a) { |
|||
u8g.drawStr( 0, 0, "drawDisc"); |
|||
u8g.drawDisc(10,18,9); |
|||
u8g.drawDisc(24+a,16,7); |
|||
u8g.drawStr( 0, 30, "drawCircle"); |
|||
u8g.drawCircle(10,18+30,9); |
|||
u8g.drawCircle(24+a,16+30,7); |
|||
} |
|||
|
|||
void u8g_r_frame(uint8_t a) { |
|||
u8g.drawStr( 0, 0, "drawRFrame/Box"); |
|||
u8g.drawRFrame(5, 10,40,30, a+1); |
|||
u8g.drawRBox(50, 10,25,40, a+1); |
|||
} |
|||
|
|||
void u8g_string(uint8_t a) { |
|||
u8g.drawStr(30+a,31, " 0"); |
|||
u8g.drawStr90(30,31+a, " 90"); |
|||
u8g.drawStr180(30-a,31, " 180"); |
|||
u8g.drawStr270(30,31-a, " 270"); |
|||
} |
|||
|
|||
void u8g_line(uint8_t a) { |
|||
u8g.drawStr( 0, 0, "drawLine"); |
|||
u8g.drawLine(7+a, 10, 40, 55); |
|||
u8g.drawLine(7+a*2, 10, 60, 55); |
|||
u8g.drawLine(7+a*3, 10, 80, 55); |
|||
u8g.drawLine(7+a*4, 10, 100, 55); |
|||
} |
|||
|
|||
void u8g_ascii_1() { |
|||
char s[2] = " "; |
|||
uint8_t x, y; |
|||
u8g.drawStr( 0, 0, "ASCII page 1"); |
|||
for( y = 0; y < 6; y++ ) { |
|||
for( x = 0; x < 16; x++ ) { |
|||
s[0] = y*16 + x + 32; |
|||
u8g.drawStr(x*7, y*10+10, s); |
|||
} |
|||
} |
|||
} |
|||
|
|||
void u8g_ascii_2() { |
|||
char s[2] = " "; |
|||
uint8_t x, y; |
|||
u8g.drawStr( 0, 0, "ASCII page 2"); |
|||
for( y = 0; y < 6; y++ ) { |
|||
for( x = 0; x < 16; x++ ) { |
|||
s[0] = y*16 + x + 160; |
|||
u8g.drawStr(x*7, y*10+10, s); |
|||
} |
|||
} |
|||
} |
|||
|
|||
|
|||
uint8_t draw_state = 0; |
|||
|
|||
void draw(void) { |
|||
u8g_prepare(); |
|||
switch(draw_state >> 3) { |
|||
case 0: u8g_box_frame(draw_state&7); break; |
|||
case 1: u8g_disc_circle(draw_state&7); break; |
|||
case 2: u8g_r_frame(draw_state&7); break; |
|||
case 3: u8g_string(draw_state&7); break; |
|||
case 4: u8g_line(draw_state&7); break; |
|||
case 5: u8g_ascii_1(); break; |
|||
case 6: u8g_ascii_2(); break; |
|||
} |
|||
} |
|||
|
|||
void setup(void) { |
|||
|
|||
// flip screen, if required |
|||
//u8g.setRot180(); |
|||
|
|||
// assign default color value |
|||
if ( u8g.getMode() == U8G_MODE_R3G3B2 ) |
|||
u8g.setColorIndex(255); // white |
|||
else if ( u8g.getMode() == U8G_MODE_GRAY2BIT ) |
|||
u8g.setColorIndex(3); // max intensity |
|||
else if ( u8g.getMode() == U8G_MODE_BW ) |
|||
u8g.setColorIndex(1); // pixel on |
|||
|
|||
//u8g.setContrast(0x30); |
|||
|
|||
pinMode(13, OUTPUT); |
|||
digitalWrite(13, HIGH); |
|||
} |
|||
|
|||
void loop(void) { |
|||
|
|||
// picture loop |
|||
u8g.firstPage(); |
|||
do { |
|||
draw(); |
|||
} while( u8g.nextPage() ); |
|||
|
|||
// increase the state |
|||
draw_state++; |
|||
if ( draw_state >= 7*8 ) |
|||
draw_state = 0; |
|||
|
|||
// rebuild the picture after some delay |
|||
delay(150); |
|||
|
|||
} |
|||
|
|||
|
|||
@ -0,0 +1,136 @@ |
|||
/* |
|||
|
|||
HelloWorld.pde |
|||
|
|||
"Hello World!" example code. |
|||
|
|||
>>> Before compiling: Please remove comment from the constructor of the |
|||
>>> connected graphics display (see below). |
|||
|
|||
Universal 8bit Graphics Library, http://code.google.com/p/u8glib/ |
|||
|
|||
Copyright (c) 2012, olikraus@gmail.com |
|||
All rights reserved. |
|||
|
|||
Redistribution and use in source and binary forms, with or without modification, |
|||
are permitted provided that the following conditions are met: |
|||
|
|||
* Redistributions of source code must retain the above copyright notice, this list |
|||
of conditions and the following disclaimer. |
|||
|
|||
* Redistributions in binary form must reproduce the above copyright notice, this |
|||
list of conditions and the following disclaimer in the documentation and/or other |
|||
materials provided with the distribution. |
|||
|
|||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
|||
CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
|||
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
|||
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
|||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
|||
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
|||
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
|||
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
|||
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
|||
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF |
|||
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|||
|
|||
*/ |
|||
|
|||
|
|||
#include "U8glib.h" |
|||
|
|||
// setup u8g object, please remove comment from one of the following constructor calls |
|||
// IMPORTANT NOTE: The complete list of supported devices is here: http://code.google.com/p/u8glib/wiki/device |
|||
|
|||
//U8GLIB_NHD27OLED_BW u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_NHD27OLED_2X_BW u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_NHD27OLED_GR u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_NHD27OLED_2X_GR u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_NHD31OLED_BW u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_NHD31OLED_2X_BW u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_NHD31OLED_GR u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_NHD31OLED_2X_GR u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_DOGS102 u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_DOGM132 u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_DOGM128 u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_ST7920_128X64_1X u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, di=17,rw=16 |
|||
//U8GLIB_ST7920_128X64_4X u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, di=17,rw=16 |
|||
//U8GLIB_ST7920_128X64_1X u8g(18, 16, 17); // SPI Com: SCK = en = 18, MOSI = rw = 16, CS = di = 17 |
|||
//U8GLIB_ST7920_128X64_4X u8g(18, 16, 17); // SPI Com: SCK = en = 18, MOSI = rw = 16, CS = di = 17 |
|||
//U8GLIB_ST7920_192X32_1X u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, di=17,rw=16 |
|||
//U8GLIB_ST7920_192X32_4X u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, di=17,rw=16 |
|||
//U8GLIB_ST7920_192X32_1X u8g(18, 16, 17); // SPI Com: SCK = en = 18, MOSI = rw = 16, CS = di = 17 |
|||
//U8GLIB_ST7920_192X32_4X u8g(18, 16, 17); // SPI Com: SCK = en = 18, MOSI = rw = 16, CS = di = 17 |
|||
//U8GLIB_ST7920_192X32_1X u8g(13, 11, 10); // SPI Com: SCK = en = 13, MOSI = rw = 11, CS = di = 10 |
|||
//U8GLIB_ST7920_192X32_4X u8g(10); // SPI Com: SCK = en = 13, MOSI = rw = 11, CS = di = 10, HW SPI |
|||
//U8GLIB_ST7920_202X32_1X u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, di=17,rw=16 |
|||
//U8GLIB_ST7920_202X32_4X u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, di=17,rw=16 |
|||
//U8GLIB_ST7920_202X32_1X u8g(18, 16, 17); // SPI Com: SCK = en = 18, MOSI = rw = 16, CS = di = 17 |
|||
//U8GLIB_ST7920_202X32_4X u8g(18, 16, 17); // SPI Com: SCK = en = 18, MOSI = rw = 16, CS = di = 17 |
|||
//U8GLIB_LM6059 u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_LM6063 u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_DOGXL160_BW u8g(10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_DOGXL160_GR u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_DOGXL160_2X_BW u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_DOGXL160_2X_GR u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_PCD8544 u8g(13, 11, 10, 9, 8); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9, Reset = 8 |
|||
//U8GLIB_PCF8812 u8g(13, 11, 10, 9, 8); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9, Reset = 8 |
|||
//U8GLIB_KS0108_128 u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 14, 15, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, cs1=14, cs2=15,di=17,rw=16 |
|||
//U8GLIB_LC7981_160X80 u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 14, 15, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, cs=14 ,di=15,rw=17, reset = 16 |
|||
//U8GLIB_LC7981_240X64 u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 14, 15, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, cs=14 ,di=15,rw=17, reset = 16 |
|||
//U8GLIB_LC7981_240X128 u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 14, 15, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, cs=14 ,di=15,rw=17, reset = 16 |
|||
//U8GLIB_ILI9325D_320x240 u8g(18,17,19,U8G_PIN_NONE,16 ); // 8Bit Com: D0..D7: 0,1,2,3,4,5,6,7 en=wr=18, cs=17, rs=19, rd=U8G_PIN_NONE, reset = 16 |
|||
//U8GLIB_SBN1661_122X32 u8g(8,9,10,11,4,5,6,7,14,15, 17, U8G_PIN_NONE, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 cs1=14, cs2=15,di=17,rw=16,reset = 16 |
|||
//U8GLIB_SSD1306_128X64 u8g(13, 11, 10, 9); // SW SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_SSD1306_128X64 u8g(10, 9); // HW SPI Com: CS = 10, A0 = 9 (Hardware Pins are SCK = 13 and MOSI = 11) |
|||
//U8GLIB_SSD1306_128X64 u8g(U8G_I2C_OPT_NONE); // HW SPI Com: CS = 10, A0 = 9 (Hardware Pins are SCK = 13 and MOSI = 11) |
|||
//U8GLIB_SSD1306_128X32 u8g(13, 11, 10, 9); // SW SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_SSD1306_128X32 u8g(10, 9); // HW SPI Com: CS = 10, A0 = 9 (Hardware Pins are SCK = 13 and MOSI = 11) |
|||
//U8GLIB_SSD1306_128X32 u8g(U8G_I2C_OPT_NONE); // HW SPI Com: CS = 10, A0 = 9 (Hardware Pins are SCK = 13 and MOSI = 11) |
|||
//U8GLIB_SSD1309_128X64 u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_SSD1327_96X96_GR u8g(U8G_I2C_OPT_NONE); // I2C |
|||
//U8GLIB_SSD1327_96X96_2X_GR u8g(U8G_I2C_OPT_NONE); // I2C |
|||
//U8GLIB_NHD_C12864 u8g(13, 11, 10, 9, 8); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9, RST = 8 |
|||
//U8GLIB_NHD_C12832 u8g(13, 11, 10, 9, 8); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9, RST = 8 |
|||
//U8GLIB_T6963_240X128 u8g(8, 9, 10, 11, 4, 5, 6, 7, 14, 15, 17, 18, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7, cs=14, a0=15, wr=17, rd=18, reset=16 |
|||
//U8GLIB_T6963_240X64 u8g(8, 9, 10, 11, 4, 5, 6, 7, 14, 15, 17, 18, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7, cs=14, a0=15, wr=17, rd=18, reset=16 |
|||
//U8GLIB_T6963_128X64 u8g(8, 9, 10, 11, 4, 5, 6, 7, 14, 15, 17, 18, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7, cs=14, a0=15, wr=17, rd=18, reset=16 |
|||
|
|||
|
|||
void draw(void) { |
|||
// graphic commands to redraw the complete screen should be placed here |
|||
u8g.setFont(u8g_font_unifont); |
|||
//u8g.setFont(u8g_font_osb21); |
|||
u8g.drawStr( 0, 22, "Hello World!"); |
|||
} |
|||
|
|||
void setup(void) { |
|||
|
|||
// flip screen, if required |
|||
// u8g.setRot180(); |
|||
|
|||
// set SPI backup if required |
|||
//u8g.setHardwareBackup(u8g_backup_avr_spi); |
|||
|
|||
// assign default color value |
|||
if ( u8g.getMode() == U8G_MODE_R3G3B2 ) |
|||
u8g.setColorIndex(255); // white |
|||
else if ( u8g.getMode() == U8G_MODE_GRAY2BIT ) |
|||
u8g.setColorIndex(3); // max intensity |
|||
else if ( u8g.getMode() == U8G_MODE_BW ) |
|||
u8g.setColorIndex(1); // pixel on |
|||
} |
|||
|
|||
void loop(void) { |
|||
// picture loop |
|||
u8g.firstPage(); |
|||
do { |
|||
draw(); |
|||
} while( u8g.nextPage() ); |
|||
|
|||
// rebuild the picture after some delay |
|||
delay(500); |
|||
} |
|||
|
|||
@ -0,0 +1,234 @@ |
|||
/* |
|||
|
|||
Menu.pde |
|||
|
|||
Simple Menu Selection |
|||
|
|||
>>> Before compiling: Please remove comment from the constructor of the |
|||
>>> connected graphics display (see below). |
|||
|
|||
Universal 8bit Graphics Library, http://code.google.com/p/u8glib/ |
|||
|
|||
Copyright (c) 2012, olikraus@gmail.com |
|||
All rights reserved. |
|||
|
|||
Redistribution and use in source and binary forms, with or without modification, |
|||
are permitted provided that the following conditions are met: |
|||
|
|||
* Redistributions of source code must retain the above copyright notice, this list |
|||
of conditions and the following disclaimer. |
|||
|
|||
* Redistributions in binary form must reproduce the above copyright notice, this |
|||
list of conditions and the following disclaimer in the documentation and/or other |
|||
materials provided with the distribution. |
|||
|
|||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
|||
CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
|||
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
|||
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
|||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
|||
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
|||
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
|||
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
|||
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
|||
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF |
|||
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|||
|
|||
|
|||
*/ |
|||
|
|||
|
|||
#include "U8glib.h" |
|||
|
|||
// setup u8g object, please remove comment from one of the following constructor calls |
|||
// IMPORTANT NOTE: The complete list of supported devices is here: http://code.google.com/p/u8glib/wiki/device |
|||
|
|||
//U8GLIB_NHD27OLED_BW u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_NHD27OLED_2X_BW u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_NHD27OLED_GR u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_NHD27OLED_2X_GR u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_NHD31OLED_BW u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_NHD31OLED_2X_BW u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_NHD31OLED_GR u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_NHD31OLED_2X_GR u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_DOGS102 u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_DOGM132 u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_DOGM128 u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_ST7920_128X64_1X u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, di=17,rw=16 |
|||
//U8GLIB_ST7920_128X64_4X u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, di=17,rw=16 |
|||
//U8GLIB_ST7920_128X64_1X u8g(18, 16, 17); // SPI Com: SCK = en = 18, MOSI = rw = 16, CS = di = 17 |
|||
//U8GLIB_ST7920_128X64_4X u8g(18, 16, 17); // SPI Com: SCK = en = 18, MOSI = rw = 16, CS = di = 17 |
|||
//U8GLIB_ST7920_192X32_1X u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, di=17,rw=16 |
|||
//U8GLIB_ST7920_192X32_4X u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, di=17,rw=16 |
|||
//U8GLIB_ST7920_192X32_1X u8g(18, 16, 17); // SPI Com: SCK = en = 18, MOSI = rw = 16, CS = di = 17 |
|||
//U8GLIB_ST7920_192X32_4X u8g(18, 16, 17); // SPI Com: SCK = en = 18, MOSI = rw = 16, CS = di = 17 |
|||
//U8GLIB_ST7920_192X32_1X u8g(13, 11, 10); // SPI Com: SCK = en = 13, MOSI = rw = 11, CS = di = 10 |
|||
//U8GLIB_ST7920_192X32_4X u8g(10); // SPI Com: SCK = en = 13, MOSI = rw = 11, CS = di = 10, HW SPI |
|||
//U8GLIB_ST7920_202X32_1X u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, di=17,rw=16 |
|||
//U8GLIB_ST7920_202X32_4X u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, di=17,rw=16 |
|||
//U8GLIB_ST7920_202X32_1X u8g(18, 16, 17); // SPI Com: SCK = en = 18, MOSI = rw = 16, CS = di = 17 |
|||
//U8GLIB_ST7920_202X32_4X u8g(18, 16, 17); // SPI Com: SCK = en = 18, MOSI = rw = 16, CS = di = 17 |
|||
//U8GLIB_LM6059 u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_LM6063 u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_DOGXL160_BW u8g(10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_DOGXL160_GR u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_DOGXL160_2X_BW u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_DOGXL160_2X_GR u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_PCD8544 u8g(13, 11, 10, 9, 8); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9, Reset = 8 |
|||
//U8GLIB_PCF8812 u8g(13, 11, 10, 9, 8); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9, Reset = 8 |
|||
//U8GLIB_KS0108_128 u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 14, 15, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, cs1=14, cs2=15,di=17,rw=16 |
|||
//U8GLIB_LC7981_160X80 u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 14, 15, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, cs=14 ,di=15,rw=17, reset = 16 |
|||
//U8GLIB_LC7981_240X64 u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 14, 15, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, cs=14 ,di=15,rw=17, reset = 16 |
|||
//U8GLIB_LC7981_240X128 u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 14, 15, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, cs=14 ,di=15,rw=17, reset = 16 |
|||
//U8GLIB_ILI9325D_320x240 u8g(18,17,19,U8G_PIN_NONE,16 ); // 8Bit Com: D0..D7: 0,1,2,3,4,5,6,7 en=wr=18, cs=17, rs=19, rd=U8G_PIN_NONE, reset = 16 |
|||
//U8GLIB_SBN1661_122X32 u8g(8,9,10,11,4,5,6,7,14,15, 17, U8G_PIN_NONE, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 cs1=14, cs2=15,di=17,rw=16,reset = 16 |
|||
//U8GLIB_SSD1306_128X64 u8g(13, 11, 10, 9); // SW SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_SSD1306_128X64 u8g(10, 9); // HW SPI Com: CS = 10, A0 = 9 (Hardware Pins are SCK = 13 and MOSI = 11) |
|||
//U8GLIB_SSD1306_128X64 u8g(U8G_I2C_OPT_NONE); // HW SPI Com: CS = 10, A0 = 9 (Hardware Pins are SCK = 13 and MOSI = 11) |
|||
//U8GLIB_SSD1306_128X32 u8g(13, 11, 10, 9); // SW SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_SSD1306_128X32 u8g(10, 9); // HW SPI Com: CS = 10, A0 = 9 (Hardware Pins are SCK = 13 and MOSI = 11) |
|||
//U8GLIB_SSD1306_128X32 u8g(U8G_I2C_OPT_NONE); // HW SPI Com: CS = 10, A0 = 9 (Hardware Pins are SCK = 13 and MOSI = 11) |
|||
//U8GLIB_SSD1309_128X64 u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_SSD1327_96X96_GR u8g(U8G_I2C_OPT_NONE); // I2C |
|||
//U8GLIB_SSD1327_96X96_2X_GR u8g(U8G_I2C_OPT_NONE); // I2C |
|||
//U8GLIB_NHD_C12864 u8g(13, 11, 10, 9, 8); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9, RST = 8 |
|||
//U8GLIB_NHD_C12832 u8g(13, 11, 10, 9, 8); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9, RST = 8 |
|||
//U8GLIB_T6963_240X128 u8g(8, 9, 10, 11, 4, 5, 6, 7, 14, 15, 17, 18, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7, cs=14, a0=15, wr=17, rd=18, reset=16 |
|||
//U8GLIB_T6963_240X64 u8g(8, 9, 10, 11, 4, 5, 6, 7, 14, 15, 17, 18, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7, cs=14, a0=15, wr=17, rd=18, reset=16 |
|||
//U8GLIB_T6963_128X64 u8g(8, 9, 10, 11, 4, 5, 6, 7, 14, 15, 17, 18, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7, cs=14, a0=15, wr=17, rd=18, reset=16 |
|||
|
|||
|
|||
#define KEY_NONE 0 |
|||
#define KEY_PREV 1 |
|||
#define KEY_NEXT 2 |
|||
#define KEY_SELECT 3 |
|||
#define KEY_BACK 4 |
|||
|
|||
// DOGS102 shield configuration values |
|||
//uint8_t uiKeyPrev = 2; |
|||
//uint8_t uiKeyNext = 4; |
|||
//uint8_t uiKeySelect = 5; |
|||
//uint8_t uiKeyBack = 3; |
|||
|
|||
// DOGM128-Shield configuration values |
|||
// DOGXL60-Shield configuration values |
|||
uint8_t uiKeyPrev = 7; |
|||
uint8_t uiKeyNext = 3; |
|||
uint8_t uiKeySelect = 2; |
|||
uint8_t uiKeyBack = 8; |
|||
|
|||
uint8_t uiKeyCodeFirst = KEY_NONE; |
|||
uint8_t uiKeyCodeSecond = KEY_NONE; |
|||
uint8_t uiKeyCode = KEY_NONE; |
|||
|
|||
|
|||
void uiSetup(void) { |
|||
// configure input keys |
|||
|
|||
pinMode(uiKeyPrev, INPUT); // set pin to input |
|||
digitalWrite(uiKeyPrev, HIGH); // turn on pullup resistors |
|||
pinMode(uiKeyNext, INPUT); // set pin to input |
|||
digitalWrite(uiKeyNext, HIGH); // turn on pullup resistors |
|||
pinMode(uiKeySelect, INPUT); // set pin to input |
|||
digitalWrite(uiKeySelect, HIGH); // turn on pullup resistors |
|||
pinMode(uiKeyBack, INPUT); // set pin to input |
|||
digitalWrite(uiKeyBack, HIGH); // turn on pullup resistors |
|||
} |
|||
|
|||
void uiStep(void) { |
|||
uiKeyCodeSecond = uiKeyCodeFirst; |
|||
if ( digitalRead(uiKeyPrev) == LOW ) |
|||
uiKeyCodeFirst = KEY_PREV; |
|||
else if ( digitalRead(uiKeyNext) == LOW ) |
|||
uiKeyCodeFirst = KEY_NEXT; |
|||
else if ( digitalRead(uiKeySelect) == LOW ) |
|||
uiKeyCodeFirst = KEY_SELECT; |
|||
else if ( digitalRead(uiKeyBack) == LOW ) |
|||
uiKeyCodeFirst = KEY_BACK; |
|||
else |
|||
uiKeyCodeFirst = KEY_NONE; |
|||
|
|||
if ( uiKeyCodeSecond == uiKeyCodeFirst ) |
|||
uiKeyCode = uiKeyCodeFirst; |
|||
else |
|||
uiKeyCode = KEY_NONE; |
|||
} |
|||
|
|||
|
|||
#define MENU_ITEMS 4 |
|||
char *menu_strings[MENU_ITEMS] = { "First Line", "Second Item", "3333333", "abcdefg" }; |
|||
|
|||
uint8_t menu_current = 0; |
|||
uint8_t menu_redraw_required = 0; |
|||
uint8_t last_key_code = KEY_NONE; |
|||
|
|||
|
|||
void drawMenu(void) { |
|||
uint8_t i, h; |
|||
u8g_uint_t w, d; |
|||
|
|||
u8g.setFont(u8g_font_6x13); |
|||
u8g.setFontRefHeightText(); |
|||
u8g.setFontPosTop(); |
|||
|
|||
h = u8g.getFontAscent()-u8g.getFontDescent(); |
|||
w = u8g.getWidth(); |
|||
for( i = 0; i < MENU_ITEMS; i++ ) { |
|||
d = (w-u8g.getStrWidth(menu_strings[i]))/2; |
|||
u8g.setDefaultForegroundColor(); |
|||
if ( i == menu_current ) { |
|||
u8g.drawBox(0, i*h+1, w, h); |
|||
u8g.setDefaultBackgroundColor(); |
|||
} |
|||
u8g.drawStr(d, i*h, menu_strings[i]); |
|||
} |
|||
} |
|||
|
|||
void updateMenu(void) { |
|||
if ( uiKeyCode != KEY_NONE && last_key_code == uiKeyCode ) { |
|||
return; |
|||
} |
|||
last_key_code = uiKeyCode; |
|||
|
|||
switch ( uiKeyCode ) { |
|||
case KEY_NEXT: |
|||
menu_current++; |
|||
if ( menu_current >= MENU_ITEMS ) |
|||
menu_current = 0; |
|||
menu_redraw_required = 1; |
|||
break; |
|||
case KEY_PREV: |
|||
if ( menu_current == 0 ) |
|||
menu_current = MENU_ITEMS; |
|||
menu_current--; |
|||
menu_redraw_required = 1; |
|||
break; |
|||
} |
|||
} |
|||
|
|||
|
|||
void setup() { |
|||
// rotate screen, if required |
|||
// u8g.setRot180(); |
|||
|
|||
uiSetup(); // setup key detection and debounce algorithm |
|||
menu_redraw_required = 1; // force initial redraw |
|||
} |
|||
|
|||
void loop() { |
|||
|
|||
uiStep(); // check for key press |
|||
|
|||
if ( menu_redraw_required != 0 ) { |
|||
u8g.firstPage(); |
|||
do { |
|||
drawMenu(); |
|||
} while( u8g.nextPage() ); |
|||
menu_redraw_required = 0; |
|||
} |
|||
|
|||
updateMenu(); // update menu bar |
|||
|
|||
} |
|||
@ -0,0 +1,124 @@ |
|||
/* |
|||
|
|||
PrintTest.pde |
|||
|
|||
How to use the base class "Print" |
|||
|
|||
>>> Before compiling: Please remove comment from the constructor of the |
|||
>>> connected graphics display (see below). |
|||
|
|||
Universal 8bit Graphics Library, http://code.google.com/p/u8glib/ |
|||
|
|||
Copyright (c) 2012, olikraus@gmail.com |
|||
All rights reserved. |
|||
|
|||
Redistribution and use in source and binary forms, with or without modification, |
|||
are permitted provided that the following conditions are met: |
|||
|
|||
* Redistributions of source code must retain the above copyright notice, this list |
|||
of conditions and the following disclaimer. |
|||
|
|||
* Redistributions in binary form must reproduce the above copyright notice, this |
|||
list of conditions and the following disclaimer in the documentation and/or other |
|||
materials provided with the distribution. |
|||
|
|||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
|||
CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
|||
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
|||
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
|||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
|||
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
|||
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
|||
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
|||
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
|||
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF |
|||
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|||
|
|||
*/ |
|||
|
|||
|
|||
#include "U8glib.h" |
|||
|
|||
// setup u8g object, please remove comment from one of the following constructor calls |
|||
// IMPORTANT NOTE: The complete list of supported devices is here: http://code.google.com/p/u8glib/wiki/device |
|||
|
|||
//U8GLIB_NHD27OLED_BW u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_NHD27OLED_2X_BW u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_NHD27OLED_GR u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_NHD27OLED_2X_GR u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_NHD31OLED_BW u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_NHD31OLED_2X_BW u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_NHD31OLED_GR u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_NHD31OLED_2X_GR u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_DOGS102 u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_DOGM132 u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_DOGM128 u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_ST7920_128X64_1X u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, di=17,rw=16 |
|||
//U8GLIB_ST7920_128X64_4X u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, di=17,rw=16 |
|||
//U8GLIB_ST7920_128X64_1X u8g(18, 16, 17); // SPI Com: SCK = en = 18, MOSI = rw = 16, CS = di = 17 |
|||
//U8GLIB_ST7920_128X64_4X u8g(18, 16, 17); // SPI Com: SCK = en = 18, MOSI = rw = 16, CS = di = 17 |
|||
//U8GLIB_ST7920_192X32_1X u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, di=17,rw=16 |
|||
//U8GLIB_ST7920_192X32_4X u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, di=17,rw=16 |
|||
//U8GLIB_ST7920_192X32_1X u8g(18, 16, 17); // SPI Com: SCK = en = 18, MOSI = rw = 16, CS = di = 17 |
|||
//U8GLIB_ST7920_192X32_4X u8g(18, 16, 17); // SPI Com: SCK = en = 18, MOSI = rw = 16, CS = di = 17 |
|||
//U8GLIB_ST7920_192X32_1X u8g(13, 11, 10); // SPI Com: SCK = en = 13, MOSI = rw = 11, CS = di = 10 |
|||
//U8GLIB_ST7920_192X32_4X u8g(10); // SPI Com: SCK = en = 13, MOSI = rw = 11, CS = di = 10, HW SPI |
|||
//U8GLIB_ST7920_202X32_1X u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, di=17,rw=16 |
|||
//U8GLIB_ST7920_202X32_4X u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, di=17,rw=16 |
|||
//U8GLIB_ST7920_202X32_1X u8g(18, 16, 17); // SPI Com: SCK = en = 18, MOSI = rw = 16, CS = di = 17 |
|||
//U8GLIB_ST7920_202X32_4X u8g(18, 16, 17); // SPI Com: SCK = en = 18, MOSI = rw = 16, CS = di = 17 |
|||
//U8GLIB_LM6059 u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_LM6063 u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_DOGXL160_BW u8g(10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_DOGXL160_GR u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_DOGXL160_2X_BW u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_DOGXL160_2X_GR u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_PCD8544 u8g(13, 11, 10, 9, 8); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9, Reset = 8 |
|||
//U8GLIB_PCF8812 u8g(13, 11, 10, 9, 8); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9, Reset = 8 |
|||
//U8GLIB_KS0108_128 u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 14, 15, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, cs1=14, cs2=15,di=17,rw=16 |
|||
//U8GLIB_LC7981_160X80 u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 14, 15, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, cs=14 ,di=15,rw=17, reset = 16 |
|||
//U8GLIB_LC7981_240X64 u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 14, 15, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, cs=14 ,di=15,rw=17, reset = 16 |
|||
//U8GLIB_LC7981_240X128 u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 14, 15, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, cs=14 ,di=15,rw=17, reset = 16 |
|||
//U8GLIB_ILI9325D_320x240 u8g(18,17,19,U8G_PIN_NONE,16 ); // 8Bit Com: D0..D7: 0,1,2,3,4,5,6,7 en=wr=18, cs=17, rs=19, rd=U8G_PIN_NONE, reset = 16 |
|||
//U8GLIB_SBN1661_122X32 u8g(8,9,10,11,4,5,6,7,14,15, 17, U8G_PIN_NONE, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 cs1=14, cs2=15,di=17,rw=16,reset = 16 |
|||
//U8GLIB_SSD1306_128X64 u8g(13, 11, 10, 9); // SW SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_SSD1306_128X64 u8g(10, 9); // HW SPI Com: CS = 10, A0 = 9 (Hardware Pins are SCK = 13 and MOSI = 11) |
|||
//U8GLIB_SSD1306_128X64 u8g(U8G_I2C_OPT_NONE); // HW SPI Com: CS = 10, A0 = 9 (Hardware Pins are SCK = 13 and MOSI = 11) |
|||
//U8GLIB_SSD1306_128X32 u8g(13, 11, 10, 9); // SW SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_SSD1306_128X32 u8g(10, 9); // HW SPI Com: CS = 10, A0 = 9 (Hardware Pins are SCK = 13 and MOSI = 11) |
|||
//U8GLIB_SSD1306_128X32 u8g(U8G_I2C_OPT_NONE); // HW SPI Com: CS = 10, A0 = 9 (Hardware Pins are SCK = 13 and MOSI = 11) |
|||
//U8GLIB_SSD1309_128X64 u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_SSD1327_96X96_GR u8g(U8G_I2C_OPT_NONE); // I2C |
|||
//U8GLIB_SSD1327_96X96_2X_GR u8g(U8G_I2C_OPT_NONE); // I2C |
|||
//U8GLIB_NHD_C12864 u8g(13, 11, 10, 9, 8); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9, RST = 8 |
|||
//U8GLIB_NHD_C12832 u8g(13, 11, 10, 9, 8); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9, RST = 8 |
|||
//U8GLIB_T6963_240X128 u8g(8, 9, 10, 11, 4, 5, 6, 7, 14, 15, 17, 18, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7, cs=14, a0=15, wr=17, rd=18, reset=16 |
|||
//U8GLIB_T6963_240X64 u8g(8, 9, 10, 11, 4, 5, 6, 7, 14, 15, 17, 18, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7, cs=14, a0=15, wr=17, rd=18, reset=16 |
|||
//U8GLIB_T6963_128X64 u8g(8, 9, 10, 11, 4, 5, 6, 7, 14, 15, 17, 18, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7, cs=14, a0=15, wr=17, rd=18, reset=16 |
|||
|
|||
void draw(void) { |
|||
// graphic commands to redraw the complete screen should be placed here |
|||
u8g.setFont(u8g_font_unifont); |
|||
u8g.setPrintPos(0, 20); |
|||
// call procedure from base class, http://arduino.cc/en/Serial/Print |
|||
u8g.print("Hello World!"); |
|||
} |
|||
|
|||
void setup(void) { |
|||
// flip screen, if required |
|||
// u8g.setRot180(); |
|||
} |
|||
|
|||
void loop(void) { |
|||
// picture loop |
|||
u8g.firstPage(); |
|||
do { |
|||
draw(); |
|||
} while( u8g.nextPage() ); |
|||
|
|||
// rebuild the picture after some delay |
|||
delay(500); |
|||
} |
|||
|
|||
@ -0,0 +1,152 @@ |
|||
/* |
|||
|
|||
HelloWorld.pde |
|||
|
|||
"Hello World!" example code. |
|||
|
|||
>>> Before compiling: Please remove comment from the constructor of the |
|||
>>> connected graphics display (see below). |
|||
|
|||
Universal 8bit Graphics Library, http://code.google.com/p/u8glib/ |
|||
|
|||
Copyright (c) 2012, olikraus@gmail.com |
|||
All rights reserved. |
|||
|
|||
Redistribution and use in source and binary forms, with or without modification, |
|||
are permitted provided that the following conditions are met: |
|||
|
|||
* Redistributions of source code must retain the above copyright notice, this list |
|||
of conditions and the following disclaimer. |
|||
|
|||
* Redistributions in binary form must reproduce the above copyright notice, this |
|||
list of conditions and the following disclaimer in the documentation and/or other |
|||
materials provided with the distribution. |
|||
|
|||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
|||
CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
|||
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
|||
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
|||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
|||
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
|||
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
|||
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
|||
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
|||
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF |
|||
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|||
|
|||
*/ |
|||
|
|||
|
|||
#include "U8glib.h" |
|||
|
|||
// setup u8g object, please remove comment from one of the following constructor calls |
|||
// IMPORTANT NOTE: The complete list of supported devices is here: http://code.google.com/p/u8glib/wiki/device |
|||
|
|||
//U8GLIB_NHD27OLED_BW u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_NHD27OLED_2X_BW u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_NHD27OLED_GR u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_NHD27OLED_2X_GR u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_NHD31OLED_BW u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_NHD31OLED_2X_BW u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_NHD31OLED_GR u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_NHD31OLED_2X_GR u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_DOGS102 u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_DOGM132 u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_DOGM128 u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_ST7920_128X64_1X u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, di=17,rw=16 |
|||
//U8GLIB_ST7920_128X64_4X u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, di=17,rw=16 |
|||
//U8GLIB_ST7920_128X64_1X u8g(18, 16, 17); // SPI Com: SCK = en = 18, MOSI = rw = 16, CS = di = 17 |
|||
//U8GLIB_ST7920_128X64_4X u8g(18, 16, 17); // SPI Com: SCK = en = 18, MOSI = rw = 16, CS = di = 17 |
|||
//U8GLIB_ST7920_192X32_1X u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, di=17,rw=16 |
|||
//U8GLIB_ST7920_192X32_4X u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, di=17,rw=16 |
|||
//U8GLIB_ST7920_192X32_1X u8g(18, 16, 17); // SPI Com: SCK = en = 18, MOSI = rw = 16, CS = di = 17 |
|||
//U8GLIB_ST7920_192X32_4X u8g(18, 16, 17); // SPI Com: SCK = en = 18, MOSI = rw = 16, CS = di = 17 |
|||
//U8GLIB_ST7920_192X32_1X u8g(13, 11, 10); // SPI Com: SCK = en = 13, MOSI = rw = 11, CS = di = 10 |
|||
//U8GLIB_ST7920_192X32_4X u8g(10); // SPI Com: SCK = en = 13, MOSI = rw = 11, CS = di = 10, HW SPI |
|||
//U8GLIB_ST7920_202X32_1X u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, di=17,rw=16 |
|||
//U8GLIB_ST7920_202X32_4X u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, di=17,rw=16 |
|||
//U8GLIB_ST7920_202X32_1X u8g(18, 16, 17); // SPI Com: SCK = en = 18, MOSI = rw = 16, CS = di = 17 |
|||
//U8GLIB_ST7920_202X32_4X u8g(18, 16, 17); // SPI Com: SCK = en = 18, MOSI = rw = 16, CS = di = 17 |
|||
//U8GLIB_LM6059 u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_LM6063 u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_DOGXL160_BW u8g(10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_DOGXL160_GR u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_DOGXL160_2X_BW u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_DOGXL160_2X_GR u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_PCD8544 u8g(13, 11, 10, 9, 8); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9, Reset = 8 |
|||
//U8GLIB_PCF8812 u8g(13, 11, 10, 9, 8); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9, Reset = 8 |
|||
//U8GLIB_KS0108_128 u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 14, 15, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, cs1=14, cs2=15,di=17,rw=16 |
|||
//U8GLIB_LC7981_160X80 u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 14, 15, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, cs=14 ,di=15,rw=17, reset = 16 |
|||
//U8GLIB_LC7981_240X64 u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 14, 15, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, cs=14 ,di=15,rw=17, reset = 16 |
|||
//U8GLIB_LC7981_240X128 u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 14, 15, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, cs=14 ,di=15,rw=17, reset = 16 |
|||
//U8GLIB_ILI9325D_320x240 u8g(18,17,19,U8G_PIN_NONE,16 ); // 8Bit Com: D0..D7: 0,1,2,3,4,5,6,7 en=wr=18, cs=17, rs=19, rd=U8G_PIN_NONE, reset = 16 |
|||
//U8GLIB_SBN1661_122X32 u8g(8,9,10,11,4,5,6,7,14,15, 17, U8G_PIN_NONE, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 cs1=14, cs2=15,di=17,rw=16,reset = 16 |
|||
//U8GLIB_SSD1306_128X64 u8g(13, 11, 10, 9); // SW SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_SSD1306_128X64 u8g(10, 9); // HW SPI Com: CS = 10, A0 = 9 (Hardware Pins are SCK = 13 and MOSI = 11) |
|||
//U8GLIB_SSD1306_128X64 u8g(U8G_I2C_OPT_NONE); // HW SPI Com: CS = 10, A0 = 9 (Hardware Pins are SCK = 13 and MOSI = 11) |
|||
//U8GLIB_SSD1306_128X32 u8g(13, 11, 10, 9); // SW SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_SSD1306_128X32 u8g(10, 9); // HW SPI Com: CS = 10, A0 = 9 (Hardware Pins are SCK = 13 and MOSI = 11) |
|||
//U8GLIB_SSD1306_128X32 u8g(U8G_I2C_OPT_NONE); // HW SPI Com: CS = 10, A0 = 9 (Hardware Pins are SCK = 13 and MOSI = 11) |
|||
//U8GLIB_SSD1309_128X64 u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_SSD1327_96X96_GR u8g(U8G_I2C_OPT_NONE); // I2C |
|||
//U8GLIB_SSD1327_96X96_2X_GR u8g(U8G_I2C_OPT_NONE); // I2C |
|||
//U8GLIB_NHD_C12864 u8g(13, 11, 10, 9, 8); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9, RST = 8 |
|||
//U8GLIB_NHD_C12832 u8g(13, 11, 10, 9, 8); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9, RST = 8 |
|||
//U8GLIB_T6963_240X128 u8g(8, 9, 10, 11, 4, 5, 6, 7, 14, 15, 17, 18, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7, cs=14, a0=15, wr=17, rd=18, reset=16 |
|||
//U8GLIB_T6963_240X64 u8g(8, 9, 10, 11, 4, 5, 6, 7, 14, 15, 17, 18, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7, cs=14, a0=15, wr=17, rd=18, reset=16 |
|||
//U8GLIB_T6963_128X64 u8g(8, 9, 10, 11, 4, 5, 6, 7, 14, 15, 17, 18, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7, cs=14, a0=15, wr=17, rd=18, reset=16 |
|||
|
|||
uint8_t offset = 0; |
|||
|
|||
void draw(void) { |
|||
// graphic commands to redraw the complete screen should be placed here |
|||
u8g.setFont(u8g_font_unifont); |
|||
u8g.drawStr( 0+0, 20+0, "Hello!"); |
|||
u8g.drawStr( 0+2, 20+16, "Hello!"); |
|||
|
|||
u8g.drawBox(0, 0, 3, 3); |
|||
u8g.drawBox(u8g.getWidth()-6, 0, 6, 6); |
|||
u8g.drawBox(u8g.getWidth()-9, u8g.getHeight()-9, 9, 9); |
|||
u8g.drawBox(0, u8g.getHeight()-12, 12, 12); |
|||
} |
|||
|
|||
void setup(void) { |
|||
} |
|||
|
|||
|
|||
void rotate(void) { |
|||
static uint8_t dir = 0; |
|||
static unsigned long next_rotation = 0; |
|||
|
|||
if ( next_rotation < millis() ) |
|||
{ |
|||
switch(dir) { |
|||
case 0: u8g.undoRotation(); break; |
|||
case 1: u8g.setRot90(); break; |
|||
case 2: u8g.setRot180(); break; |
|||
case 3: u8g.setRot270(); offset = ( offset + 1 ) & 0x0f; break; |
|||
} |
|||
|
|||
dir++; |
|||
dir &= 3; |
|||
next_rotation = millis(); |
|||
next_rotation += 1000; |
|||
} |
|||
} |
|||
|
|||
void loop(void) { |
|||
// screen rotation |
|||
rotate(); |
|||
|
|||
// picture loop |
|||
u8g.firstPage(); |
|||
do { |
|||
draw(); |
|||
} while( u8g.nextPage() ); |
|||
|
|||
// rebuild the picture after some delay |
|||
delay(100); |
|||
} |
|||
|
|||
@ -0,0 +1,141 @@ |
|||
/* |
|||
|
|||
HelloWorld.pde |
|||
|
|||
"Hello World!" example code. |
|||
|
|||
>>> Before compiling: Please remove comment from the constructor of the |
|||
>>> connected graphics display (see below). |
|||
|
|||
Universal 8bit Graphics Library, http://code.google.com/p/u8glib/ |
|||
|
|||
Copyright (c) 2012, olikraus@gmail.com |
|||
All rights reserved. |
|||
|
|||
Redistribution and use in source and binary forms, with or without modification, |
|||
are permitted provided that the following conditions are met: |
|||
|
|||
* Redistributions of source code must retain the above copyright notice, this list |
|||
of conditions and the following disclaimer. |
|||
|
|||
* Redistributions in binary form must reproduce the above copyright notice, this |
|||
list of conditions and the following disclaimer in the documentation and/or other |
|||
materials provided with the distribution. |
|||
|
|||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
|||
CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
|||
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
|||
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
|||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
|||
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
|||
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
|||
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
|||
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
|||
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF |
|||
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|||
|
|||
*/ |
|||
|
|||
|
|||
#include "U8glib.h" |
|||
|
|||
// setup u8g object, please remove comment from one of the following constructor calls |
|||
// IMPORTANT NOTE: The complete list of supported devices is here: http://code.google.com/p/u8glib/wiki/device |
|||
|
|||
//U8GLIB_NHD27OLED_BW u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_NHD27OLED_2X_BW u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_NHD27OLED_GR u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_NHD27OLED_2X_GR u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_NHD31OLED_BW u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_NHD31OLED_2X_BW u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_NHD31OLED_GR u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_NHD31OLED_2X_GR u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_DOGS102 u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_DOGM132 u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_DOGM128 u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_ST7920_128X64_1X u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, di=17,rw=16 |
|||
//U8GLIB_ST7920_128X64_4X u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, di=17,rw=16 |
|||
//U8GLIB_ST7920_128X64_1X u8g(18, 16, 17); // SPI Com: SCK = en = 18, MOSI = rw = 16, CS = di = 17 |
|||
//U8GLIB_ST7920_128X64_4X u8g(18, 16, 17); // SPI Com: SCK = en = 18, MOSI = rw = 16, CS = di = 17 |
|||
//U8GLIB_ST7920_192X32_1X u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, di=17,rw=16 |
|||
//U8GLIB_ST7920_192X32_4X u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, di=17,rw=16 |
|||
//U8GLIB_ST7920_192X32_1X u8g(18, 16, 17); // SPI Com: SCK = en = 18, MOSI = rw = 16, CS = di = 17 |
|||
//U8GLIB_ST7920_192X32_4X u8g(18, 16, 17); // SPI Com: SCK = en = 18, MOSI = rw = 16, CS = di = 17 |
|||
//U8GLIB_ST7920_192X32_1X u8g(13, 11, 10); // SPI Com: SCK = en = 13, MOSI = rw = 11, CS = di = 10 |
|||
//U8GLIB_ST7920_192X32_4X u8g(10); // SPI Com: SCK = en = 13, MOSI = rw = 11, CS = di = 10, HW SPI |
|||
//U8GLIB_ST7920_202X32_1X u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, di=17,rw=16 |
|||
//U8GLIB_ST7920_202X32_4X u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, di=17,rw=16 |
|||
//U8GLIB_ST7920_202X32_1X u8g(18, 16, 17); // SPI Com: SCK = en = 18, MOSI = rw = 16, CS = di = 17 |
|||
//U8GLIB_ST7920_202X32_4X u8g(18, 16, 17); // SPI Com: SCK = en = 18, MOSI = rw = 16, CS = di = 17 |
|||
//U8GLIB_LM6059 u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_LM6063 u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_DOGXL160_BW u8g(10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_DOGXL160_GR u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_DOGXL160_2X_BW u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_DOGXL160_2X_GR u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_PCD8544 u8g(13, 11, 10, 9, 8); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9, Reset = 8 |
|||
//U8GLIB_PCF8812 u8g(13, 11, 10, 9, 8); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9, Reset = 8 |
|||
//U8GLIB_KS0108_128 u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 14, 15, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, cs1=14, cs2=15,di=17,rw=16 |
|||
//U8GLIB_LC7981_160X80 u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 14, 15, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, cs=14 ,di=15,rw=17, reset = 16 |
|||
//U8GLIB_LC7981_240X64 u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 14, 15, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, cs=14 ,di=15,rw=17, reset = 16 |
|||
//U8GLIB_LC7981_240X128 u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 14, 15, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, cs=14 ,di=15,rw=17, reset = 16 |
|||
//U8GLIB_ILI9325D_320x240 u8g(18,17,19,U8G_PIN_NONE,16 ); // 8Bit Com: D0..D7: 0,1,2,3,4,5,6,7 en=wr=18, cs=17, rs=19, rd=U8G_PIN_NONE, reset = 16 |
|||
//U8GLIB_SBN1661_122X32 u8g(8,9,10,11,4,5,6,7,14,15, 17, U8G_PIN_NONE, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 cs1=14, cs2=15,di=17,rw=16,reset = 16 |
|||
//U8GLIB_SSD1306_128X64 u8g(13, 11, 10, 9); // SW SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_SSD1306_128X64 u8g(10, 9); // HW SPI Com: CS = 10, A0 = 9 (Hardware Pins are SCK = 13 and MOSI = 11) |
|||
//U8GLIB_SSD1306_128X64 u8g(U8G_I2C_OPT_NONE); // HW SPI Com: CS = 10, A0 = 9 (Hardware Pins are SCK = 13 and MOSI = 11) |
|||
//U8GLIB_SSD1306_128X32 u8g(13, 11, 10, 9); // SW SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_SSD1306_128X32 u8g(10, 9); // HW SPI Com: CS = 10, A0 = 9 (Hardware Pins are SCK = 13 and MOSI = 11) |
|||
//U8GLIB_SSD1306_128X32 u8g(U8G_I2C_OPT_NONE); // HW SPI Com: CS = 10, A0 = 9 (Hardware Pins are SCK = 13 and MOSI = 11) |
|||
//U8GLIB_SSD1309_128X64 u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_SSD1327_96X96_GR u8g(U8G_I2C_OPT_NONE); // I2C |
|||
//U8GLIB_SSD1327_96X96_2X_GR u8g(U8G_I2C_OPT_NONE); // I2C |
|||
//U8GLIB_NHD_C12864 u8g(13, 11, 10, 9, 8); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9, RST = 8 |
|||
//U8GLIB_NHD_C12832 u8g(13, 11, 10, 9, 8); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9, RST = 8 |
|||
//U8GLIB_T6963_240X128 u8g(8, 9, 10, 11, 4, 5, 6, 7, 14, 15, 17, 18, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7, cs=14, a0=15, wr=17, rd=18, reset=16 |
|||
//U8GLIB_T6963_240X64 u8g(8, 9, 10, 11, 4, 5, 6, 7, 14, 15, 17, 18, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7, cs=14, a0=15, wr=17, rd=18, reset=16 |
|||
//U8GLIB_T6963_128X64 u8g(8, 9, 10, 11, 4, 5, 6, 7, 14, 15, 17, 18, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7, cs=14, a0=15, wr=17, rd=18, reset=16 |
|||
|
|||
|
|||
void draw(void) { |
|||
// graphic commands to redraw the complete screen should be placed here |
|||
u8g.setFont(u8g_font_unifont); |
|||
u8g.setFontPosTop(); |
|||
u8g.drawStr(0, 1, "Hello"); |
|||
u8g.drawHLine(0, 1+14, 40); |
|||
u8g.setScale2x2(); // Scale up all draw procedures |
|||
u8g.drawStr(0, 12, "Hello"); // actual display position is (0,24) |
|||
u8g.drawHLine(0, 12+14, 40); // All other procedures are also affected |
|||
u8g.undoScale(); // IMPORTANT: Switch back to normal mode |
|||
} |
|||
|
|||
void setup(void) { |
|||
|
|||
// flip screen, if required |
|||
u8g.setRot180(); |
|||
|
|||
// set SPI backup if required |
|||
//u8g.setHardwareBackup(u8g_backup_avr_spi); |
|||
|
|||
// assign default color value |
|||
if ( u8g.getMode() == U8G_MODE_R3G3B2 ) |
|||
u8g.setColorIndex(255); // white |
|||
else if ( u8g.getMode() == U8G_MODE_GRAY2BIT ) |
|||
u8g.setColorIndex(3); // max intensity |
|||
else if ( u8g.getMode() == U8G_MODE_BW ) |
|||
u8g.setColorIndex(1); // pixel on |
|||
} |
|||
|
|||
void loop(void) { |
|||
// picture loop |
|||
u8g.firstPage(); |
|||
do { |
|||
draw(); |
|||
} while( u8g.nextPage() ); |
|||
|
|||
// rebuild the picture after some delay |
|||
delay(500); |
|||
} |
|||
|
|||
@ -0,0 +1,154 @@ |
|||
/* |
|||
|
|||
TextRotX.pde |
|||
|
|||
Text rotation example code. |
|||
|
|||
>>> Before compiling: Please remove comment from the constructor of the |
|||
>>> connected graphics display (see below). |
|||
|
|||
Universal 8bit Graphics Library, http://code.google.com/p/u8glib/ |
|||
|
|||
Copyright (c) 2012, olikraus@gmail.com |
|||
All rights reserved. |
|||
|
|||
Redistribution and use in source and binary forms, with or without modification, |
|||
are permitted provided that the following conditions are met: |
|||
|
|||
* Redistributions of source code must retain the above copyright notice, this list |
|||
of conditions and the following disclaimer. |
|||
|
|||
* Redistributions in binary form must reproduce the above copyright notice, this |
|||
list of conditions and the following disclaimer in the documentation and/or other |
|||
materials provided with the distribution. |
|||
|
|||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
|||
CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
|||
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
|||
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
|||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
|||
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
|||
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
|||
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
|||
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
|||
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF |
|||
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|||
|
|||
*/ |
|||
|
|||
|
|||
#include "U8glib.h" |
|||
|
|||
// setup u8g object, please remove comment from one of the following constructor calls |
|||
// IMPORTANT NOTE: The complete list of supported devices is here: http://code.google.com/p/u8glib/wiki/device |
|||
|
|||
//U8GLIB_NHD27OLED_BW u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_NHD27OLED_2X_BW u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_NHD27OLED_GR u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_NHD27OLED_2X_GR u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_NHD31OLED_BW u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_NHD31OLED_2X_BW u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_NHD31OLED_GR u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_NHD31OLED_2X_GR u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_DOGS102 u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_DOGM132 u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_DOGM128 u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_ST7920_128X64_1X u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, di=17,rw=16 |
|||
//U8GLIB_ST7920_128X64_4X u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, di=17,rw=16 |
|||
//U8GLIB_ST7920_128X64_1X u8g(18, 16, 17); // SPI Com: SCK = en = 18, MOSI = rw = 16, CS = di = 17 |
|||
//U8GLIB_ST7920_128X64_4X u8g(18, 16, 17); // SPI Com: SCK = en = 18, MOSI = rw = 16, CS = di = 17 |
|||
//U8GLIB_ST7920_192X32_1X u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, di=17,rw=16 |
|||
//U8GLIB_ST7920_192X32_4X u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, di=17,rw=16 |
|||
//U8GLIB_ST7920_192X32_1X u8g(18, 16, 17); // SPI Com: SCK = en = 18, MOSI = rw = 16, CS = di = 17 |
|||
//U8GLIB_ST7920_192X32_4X u8g(18, 16, 17); // SPI Com: SCK = en = 18, MOSI = rw = 16, CS = di = 17 |
|||
//U8GLIB_ST7920_192X32_1X u8g(13, 11, 10); // SPI Com: SCK = en = 13, MOSI = rw = 11, CS = di = 10 |
|||
//U8GLIB_ST7920_192X32_4X u8g(10); // SPI Com: SCK = en = 13, MOSI = rw = 11, CS = di = 10, HW SPI |
|||
//U8GLIB_ST7920_202X32_1X u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, di=17,rw=16 |
|||
//U8GLIB_ST7920_202X32_4X u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, di=17,rw=16 |
|||
//U8GLIB_ST7920_202X32_1X u8g(18, 16, 17); // SPI Com: SCK = en = 18, MOSI = rw = 16, CS = di = 17 |
|||
//U8GLIB_ST7920_202X32_4X u8g(18, 16, 17); // SPI Com: SCK = en = 18, MOSI = rw = 16, CS = di = 17 |
|||
//U8GLIB_LM6059 u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_LM6063 u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_DOGXL160_BW u8g(10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_DOGXL160_GR u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_DOGXL160_2X_BW u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_DOGXL160_2X_GR u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_PCD8544 u8g(13, 11, 10, 9, 8); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9, Reset = 8 |
|||
//U8GLIB_PCF8812 u8g(13, 11, 10, 9, 8); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9, Reset = 8 |
|||
//U8GLIB_KS0108_128 u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 14, 15, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, cs1=14, cs2=15,di=17,rw=16 |
|||
//U8GLIB_LC7981_160X80 u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 14, 15, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, cs=14 ,di=15,rw=17, reset = 16 |
|||
//U8GLIB_LC7981_240X64 u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 14, 15, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, cs=14 ,di=15,rw=17, reset = 16 |
|||
//U8GLIB_LC7981_240X128 u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 14, 15, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, cs=14 ,di=15,rw=17, reset = 16 |
|||
//U8GLIB_ILI9325D_320x240 u8g(18,17,19,U8G_PIN_NONE,16 ); // 8Bit Com: D0..D7: 0,1,2,3,4,5,6,7 en=wr=18, cs=17, rs=19, rd=U8G_PIN_NONE, reset = 16 |
|||
//U8GLIB_SBN1661_122X32 u8g(8,9,10,11,4,5,6,7,14,15, 17, U8G_PIN_NONE, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 cs1=14, cs2=15,di=17,rw=16,reset = 16 |
|||
//U8GLIB_SSD1306_128X64 u8g(13, 11, 10, 9); // SW SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_SSD1306_128X64 u8g(10, 9); // HW SPI Com: CS = 10, A0 = 9 (Hardware Pins are SCK = 13 and MOSI = 11) |
|||
//U8GLIB_SSD1306_128X64 u8g(U8G_I2C_OPT_NONE); // HW SPI Com: CS = 10, A0 = 9 (Hardware Pins are SCK = 13 and MOSI = 11) |
|||
//U8GLIB_SSD1306_128X32 u8g(13, 11, 10, 9); // SW SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_SSD1306_128X32 u8g(10, 9); // HW SPI Com: CS = 10, A0 = 9 (Hardware Pins are SCK = 13 and MOSI = 11) |
|||
//U8GLIB_SSD1306_128X32 u8g(U8G_I2C_OPT_NONE); // HW SPI Com: CS = 10, A0 = 9 (Hardware Pins are SCK = 13 and MOSI = 11) |
|||
//U8GLIB_SSD1309_128X64 u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_SSD1327_96X96_GR u8g(U8G_I2C_OPT_NONE); // I2C |
|||
//U8GLIB_SSD1327_96X96_2X_GR u8g(U8G_I2C_OPT_NONE); // I2C |
|||
//U8GLIB_NHD_C12864 u8g(13, 11, 10, 9, 8); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9, RST = 8 |
|||
//U8GLIB_NHD_C12832 u8g(13, 11, 10, 9, 8); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9, RST = 8 |
|||
//U8GLIB_T6963_240X128 u8g(8, 9, 10, 11, 4, 5, 6, 7, 14, 15, 17, 18, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7, cs=14, a0=15, wr=17, rd=18, reset=16 |
|||
//U8GLIB_T6963_240X64 u8g(8, 9, 10, 11, 4, 5, 6, 7, 14, 15, 17, 18, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7, cs=14, a0=15, wr=17, rd=18, reset=16 |
|||
//U8GLIB_T6963_128X64 u8g(8, 9, 10, 11, 4, 5, 6, 7, 14, 15, 17, 18, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7, cs=14, a0=15, wr=17, rd=18, reset=16 |
|||
|
|||
// graphic commands to redraw the complete screen should be placed here |
|||
void draw(void) { |
|||
u8g_uint_t mx, my; |
|||
|
|||
mx = u8g.getWidth(); |
|||
mx >>= 1; |
|||
|
|||
my = u8g.getHeight(); |
|||
my >>= 1; |
|||
|
|||
u8g.drawStr( mx, my, "Ag"); |
|||
u8g.drawStr90( mx, my, "Ag"); |
|||
u8g.drawStr180( mx, my, "Ag"); |
|||
u8g.drawStr270( mx, my, "Ag"); |
|||
} |
|||
|
|||
void setup(void) { |
|||
u8g.setFont(u8g_font_9x18); |
|||
} |
|||
|
|||
void change_font_pos(void) { |
|||
static uint8_t dir = 0; |
|||
static unsigned long next = 0; |
|||
|
|||
if ( next < millis() ) |
|||
{ |
|||
switch(dir) { |
|||
case 0: u8g.setFontPosBottom(); break; |
|||
case 1: u8g.setFontPosBaseline(); break; |
|||
case 2: u8g.setFontPosCenter(); break; |
|||
case 3: u8g.setFontPosTop(); break; |
|||
} |
|||
|
|||
dir++; |
|||
dir &= 3; |
|||
next = millis(); |
|||
next += 1000; |
|||
} |
|||
} |
|||
|
|||
void loop(void) { |
|||
// change the font position |
|||
change_font_pos(); |
|||
|
|||
// picture loop |
|||
u8g.firstPage(); |
|||
do { |
|||
draw(); |
|||
} while( u8g.nextPage() ); |
|||
|
|||
// rebuild the picture after some delay |
|||
delay(100); |
|||
} |
|||
|
|||
@ -0,0 +1,179 @@ |
|||
/* |
|||
|
|||
U8gLogo.pde |
|||
|
|||
Put the U8GLIB logo on the display. |
|||
|
|||
>>> Before compiling: Please remove comment from the constructor of the |
|||
>>> connected graphics display (see below). |
|||
|
|||
Universal 8bit Graphics Library, http://code.google.com/p/u8glib/ |
|||
|
|||
Copyright (c) 2012, olikraus@gmail.com |
|||
All rights reserved. |
|||
|
|||
Redistribution and use in source and binary forms, with or without modification, |
|||
are permitted provided that the following conditions are met: |
|||
|
|||
* Redistributions of source code must retain the above copyright notice, this list |
|||
of conditions and the following disclaimer. |
|||
|
|||
* Redistributions in binary form must reproduce the above copyright notice, this |
|||
list of conditions and the following disclaimer in the documentation and/or other |
|||
materials provided with the distribution. |
|||
|
|||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
|||
CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
|||
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
|||
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
|||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
|||
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
|||
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
|||
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
|||
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
|||
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF |
|||
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|||
|
|||
*/ |
|||
|
|||
|
|||
#include "U8glib.h" |
|||
|
|||
// setup u8g object, please remove comment from one of the following constructor calls |
|||
// IMPORTANT NOTE: The complete list of supported devices is here: http://code.google.com/p/u8glib/wiki/device |
|||
|
|||
//U8GLIB_NHD27OLED_BW u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_NHD27OLED_2X_BW u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_NHD27OLED_GR u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_NHD27OLED_2X_GR u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_NHD31OLED_BW u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_NHD31OLED_2X_BW u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_NHD31OLED_GR u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_NHD31OLED_2X_GR u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_DOGS102 u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_DOGM132 u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_DOGM128 u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_ST7920_128X64_1X u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, di=17,rw=16 |
|||
//U8GLIB_ST7920_128X64_4X u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, di=17,rw=16 |
|||
//U8GLIB_ST7920_128X64_1X u8g(18, 16, 17); // SPI Com: SCK = en = 18, MOSI = rw = 16, CS = di = 17 |
|||
//U8GLIB_ST7920_128X64_4X u8g(18, 16, 17); // SPI Com: SCK = en = 18, MOSI = rw = 16, CS = di = 17 |
|||
//U8GLIB_ST7920_192X32_1X u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, di=17,rw=16 |
|||
//U8GLIB_ST7920_192X32_4X u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, di=17,rw=16 |
|||
//U8GLIB_ST7920_192X32_1X u8g(18, 16, 17); // SPI Com: SCK = en = 18, MOSI = rw = 16, CS = di = 17 |
|||
//U8GLIB_ST7920_192X32_4X u8g(18, 16, 17); // SPI Com: SCK = en = 18, MOSI = rw = 16, CS = di = 17 |
|||
//U8GLIB_ST7920_192X32_1X u8g(13, 11, 10); // SPI Com: SCK = en = 13, MOSI = rw = 11, CS = di = 10 |
|||
//U8GLIB_ST7920_192X32_4X u8g(10); // SPI Com: SCK = en = 13, MOSI = rw = 11, CS = di = 10, HW SPI |
|||
//U8GLIB_ST7920_202X32_1X u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, di=17,rw=16 |
|||
//U8GLIB_ST7920_202X32_4X u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, di=17,rw=16 |
|||
//U8GLIB_ST7920_202X32_1X u8g(18, 16, 17); // SPI Com: SCK = en = 18, MOSI = rw = 16, CS = di = 17 |
|||
//U8GLIB_ST7920_202X32_4X u8g(18, 16, 17); // SPI Com: SCK = en = 18, MOSI = rw = 16, CS = di = 17 |
|||
//U8GLIB_LM6059 u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_LM6063 u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_DOGXL160_BW u8g(10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_DOGXL160_GR u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_DOGXL160_2X_BW u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_DOGXL160_2X_GR u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_PCD8544 u8g(13, 11, 10, 9, 8); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9, Reset = 8 |
|||
//U8GLIB_PCF8812 u8g(13, 11, 10, 9, 8); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9, Reset = 8 |
|||
//U8GLIB_KS0108_128 u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 14, 15, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, cs1=14, cs2=15,di=17,rw=16 |
|||
//U8GLIB_LC7981_160X80 u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 14, 15, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, cs=14 ,di=15,rw=17, reset = 16 |
|||
//U8GLIB_LC7981_240X64 u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 14, 15, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, cs=14 ,di=15,rw=17, reset = 16 |
|||
//U8GLIB_LC7981_240X128 u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 14, 15, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, cs=14 ,di=15,rw=17, reset = 16 |
|||
//U8GLIB_ILI9325D_320x240 u8g(18,17,19,U8G_PIN_NONE,16 ); // 8Bit Com: D0..D7: 0,1,2,3,4,5,6,7 en=wr=18, cs=17, rs=19, rd=U8G_PIN_NONE, reset = 16 |
|||
//U8GLIB_SBN1661_122X32 u8g(8,9,10,11,4,5,6,7,14,15, 17, U8G_PIN_NONE, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 cs1=14, cs2=15,di=17,rw=16,reset = 16 |
|||
//U8GLIB_SSD1306_128X64 u8g(13, 11, 10, 9); // SW SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_SSD1306_128X64 u8g(10, 9); // HW SPI Com: CS = 10, A0 = 9 (Hardware Pins are SCK = 13 and MOSI = 11) |
|||
//U8GLIB_SSD1306_128X64 u8g(U8G_I2C_OPT_NONE); // HW SPI Com: CS = 10, A0 = 9 (Hardware Pins are SCK = 13 and MOSI = 11) |
|||
//U8GLIB_SSD1306_128X32 u8g(13, 11, 10, 9); // SW SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_SSD1306_128X32 u8g(10, 9); // HW SPI Com: CS = 10, A0 = 9 (Hardware Pins are SCK = 13 and MOSI = 11) |
|||
//U8GLIB_SSD1306_128X32 u8g(U8G_I2C_OPT_NONE); // HW SPI Com: CS = 10, A0 = 9 (Hardware Pins are SCK = 13 and MOSI = 11) |
|||
//U8GLIB_SSD1309_128X64 u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_SSD1327_96X96_GR u8g(U8G_I2C_OPT_NONE); // I2C |
|||
//U8GLIB_SSD1327_96X96_2X_GR u8g(U8G_I2C_OPT_NONE); // I2C |
|||
//U8GLIB_NHD_C12864 u8g(13, 11, 10, 9, 8); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9, RST = 8 |
|||
//U8GLIB_NHD_C12832 u8g(13, 11, 10, 9, 8); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9, RST = 8 |
|||
//U8GLIB_T6963_240X128 u8g(8, 9, 10, 11, 4, 5, 6, 7, 14, 15, 17, 18, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7, cs=14, a0=15, wr=17, rd=18, reset=16 |
|||
//U8GLIB_T6963_240X64 u8g(8, 9, 10, 11, 4, 5, 6, 7, 14, 15, 17, 18, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7, cs=14, a0=15, wr=17, rd=18, reset=16 |
|||
//U8GLIB_T6963_128X64 u8g(8, 9, 10, 11, 4, 5, 6, 7, 14, 15, 17, 18, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7, cs=14, a0=15, wr=17, rd=18, reset=16 |
|||
|
|||
|
|||
void drawColorBox(void) |
|||
{ |
|||
u8g_uint_t w,h; |
|||
u8g_uint_t r, g, b; |
|||
|
|||
w = u8g.getWidth()/32; |
|||
h = u8g.getHeight()/8; |
|||
for( b = 0; b < 4; b++ ) |
|||
for( g = 0; g < 8; g++ ) |
|||
for( r = 0; r < 8; r++ ) |
|||
{ |
|||
u8g.setColorIndex((r<<5) | (g<<2) | b ); |
|||
u8g.drawBox(g*w + b*w*8, r*h, w, h); |
|||
} |
|||
} |
|||
|
|||
void drawLogo(uint8_t d) |
|||
{ |
|||
u8g.setFont(u8g_font_gdr25r); |
|||
u8g.drawStr(0+d, 30+d, "U"); |
|||
u8g.setFont(u8g_font_gdr30n); |
|||
u8g.drawStr90(23+d,10+d,"8"); |
|||
u8g.setFont(u8g_font_gdr25r); |
|||
u8g.drawStr(53+d,30+d,"g"); |
|||
|
|||
u8g.drawHLine(2+d, 35+d, 47); |
|||
u8g.drawVLine(45+d, 32+d, 12); |
|||
} |
|||
|
|||
void drawURL(void) |
|||
{ |
|||
u8g.setFont(u8g_font_4x6); |
|||
if ( u8g.getHeight() < 59 ) |
|||
{ |
|||
u8g.drawStr(53,9,"code.google.com"); |
|||
u8g.drawStr(77,18,"/p/u8glib"); |
|||
} |
|||
else |
|||
{ |
|||
u8g.drawStr(1,54,"code.google.com/p/u8glib"); |
|||
} |
|||
} |
|||
|
|||
|
|||
void draw(void) { |
|||
if ( u8g.getMode() == U8G_MODE_R3G3B2 ) { |
|||
drawColorBox(); |
|||
} |
|||
u8g.setColorIndex(1); |
|||
if ( U8G_MODE_GET_BITS_PER_PIXEL(u8g.getMode()) > 1 ) { |
|||
drawLogo(2); |
|||
u8g.setColorIndex(2); |
|||
drawLogo(1); |
|||
u8g.setColorIndex(3); |
|||
} |
|||
drawLogo(0); |
|||
drawURL(); |
|||
|
|||
} |
|||
|
|||
void setup(void) { |
|||
// flip screen, if required |
|||
//u8g.setRot180(); |
|||
} |
|||
|
|||
void loop(void) { |
|||
|
|||
// picture loop |
|||
u8g.firstPage(); |
|||
do { |
|||
draw(); |
|||
u8g.setColorIndex(1); |
|||
} while( u8g.nextPage() ); |
|||
|
|||
// rebuild the picture after some delay |
|||
delay(200); |
|||
} |
|||
|
|||
@ -0,0 +1,136 @@ |
|||
/* |
|||
|
|||
XBM.pde |
|||
|
|||
drawXBM example code. |
|||
|
|||
>>> Before compiling: Please remove comment from the constructor of the |
|||
>>> connected graphics display (see below). |
|||
|
|||
Universal 8bit Graphics Library, http://code.google.com/p/u8glib/ |
|||
|
|||
Copyright (c) 2012, olikraus@gmail.com |
|||
All rights reserved. |
|||
|
|||
Redistribution and use in source and binary forms, with or without modification, |
|||
are permitted provided that the following conditions are met: |
|||
|
|||
* Redistributions of source code must retain the above copyright notice, this list |
|||
of conditions and the following disclaimer. |
|||
|
|||
* Redistributions in binary form must reproduce the above copyright notice, this |
|||
list of conditions and the following disclaimer in the documentation and/or other |
|||
materials provided with the distribution. |
|||
|
|||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
|||
CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
|||
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
|||
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
|||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
|||
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
|||
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
|||
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
|||
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
|||
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF |
|||
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|||
|
|||
*/ |
|||
|
|||
|
|||
#include "U8glib.h" |
|||
|
|||
// setup u8g object, please remove comment from one of the following constructor calls |
|||
// IMPORTANT NOTE: The complete list of supported devices is here: http://code.google.com/p/u8glib/wiki/device |
|||
|
|||
//U8GLIB_NHD27OLED_BW u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_NHD27OLED_2X_BW u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_NHD27OLED_GR u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_NHD27OLED_2X_GR u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_NHD31OLED_BW u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_NHD31OLED_2X_BW u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_NHD31OLED_GR u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_NHD31OLED_2X_GR u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_DOGS102 u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_DOGM132 u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_DOGM128 u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_ST7920_128X64_1X u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, di=17,rw=16 |
|||
//U8GLIB_ST7920_128X64_4X u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, di=17,rw=16 |
|||
//U8GLIB_ST7920_128X64_1X u8g(18, 16, 17); // SPI Com: SCK = en = 18, MOSI = rw = 16, CS = di = 17 |
|||
//U8GLIB_ST7920_128X64_4X u8g(18, 16, 17); // SPI Com: SCK = en = 18, MOSI = rw = 16, CS = di = 17 |
|||
//U8GLIB_ST7920_192X32_1X u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, di=17,rw=16 |
|||
//U8GLIB_ST7920_192X32_4X u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, di=17,rw=16 |
|||
//U8GLIB_ST7920_192X32_1X u8g(18, 16, 17); // SPI Com: SCK = en = 18, MOSI = rw = 16, CS = di = 17 |
|||
//U8GLIB_ST7920_192X32_4X u8g(18, 16, 17); // SPI Com: SCK = en = 18, MOSI = rw = 16, CS = di = 17 |
|||
//U8GLIB_ST7920_192X32_1X u8g(13, 11, 10); // SPI Com: SCK = en = 13, MOSI = rw = 11, CS = di = 10 |
|||
//U8GLIB_ST7920_192X32_4X u8g(10); // SPI Com: SCK = en = 13, MOSI = rw = 11, CS = di = 10, HW SPI |
|||
//U8GLIB_ST7920_202X32_1X u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, di=17,rw=16 |
|||
//U8GLIB_ST7920_202X32_4X u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, di=17,rw=16 |
|||
//U8GLIB_ST7920_202X32_1X u8g(18, 16, 17); // SPI Com: SCK = en = 18, MOSI = rw = 16, CS = di = 17 |
|||
//U8GLIB_ST7920_202X32_4X u8g(18, 16, 17); // SPI Com: SCK = en = 18, MOSI = rw = 16, CS = di = 17 |
|||
//U8GLIB_LM6059 u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_LM6063 u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_DOGXL160_BW u8g(10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_DOGXL160_GR u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_DOGXL160_2X_BW u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_DOGXL160_2X_GR u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_PCD8544 u8g(13, 11, 10, 9, 8); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9, Reset = 8 |
|||
//U8GLIB_PCF8812 u8g(13, 11, 10, 9, 8); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9, Reset = 8 |
|||
//U8GLIB_KS0108_128 u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 14, 15, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, cs1=14, cs2=15,di=17,rw=16 |
|||
//U8GLIB_LC7981_160X80 u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 14, 15, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, cs=14 ,di=15,rw=17, reset = 16 |
|||
//U8GLIB_LC7981_240X64 u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 14, 15, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, cs=14 ,di=15,rw=17, reset = 16 |
|||
//U8GLIB_LC7981_240X128 u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 14, 15, 17, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, cs=14 ,di=15,rw=17, reset = 16 |
|||
//U8GLIB_ILI9325D_320x240 u8g(18,17,19,U8G_PIN_NONE,16 ); // 8Bit Com: D0..D7: 0,1,2,3,4,5,6,7 en=wr=18, cs=17, rs=19, rd=U8G_PIN_NONE, reset = 16 |
|||
//U8GLIB_SBN1661_122X32 u8g(8,9,10,11,4,5,6,7,14,15, 17, U8G_PIN_NONE, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 cs1=14, cs2=15,di=17,rw=16,reset = 16 |
|||
//U8GLIB_SSD1306_128X64 u8g(13, 11, 10, 9); // SW SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_SSD1306_128X64 u8g(10, 9); // HW SPI Com: CS = 10, A0 = 9 (Hardware Pins are SCK = 13 and MOSI = 11) |
|||
//U8GLIB_SSD1306_128X64 u8g(U8G_I2C_OPT_NONE); // HW SPI Com: CS = 10, A0 = 9 (Hardware Pins are SCK = 13 and MOSI = 11) |
|||
//U8GLIB_SSD1306_128X32 u8g(13, 11, 10, 9); // SW SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_SSD1306_128X32 u8g(10, 9); // HW SPI Com: CS = 10, A0 = 9 (Hardware Pins are SCK = 13 and MOSI = 11) |
|||
//U8GLIB_SSD1306_128X32 u8g(U8G_I2C_OPT_NONE); // HW SPI Com: CS = 10, A0 = 9 (Hardware Pins are SCK = 13 and MOSI = 11) |
|||
//U8GLIB_SSD1309_128X64 u8g(13, 11, 10, 9); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9 |
|||
//U8GLIB_SSD1327_96X96_GR u8g(U8G_I2C_OPT_NONE); // I2C |
|||
//U8GLIB_SSD1327_96X96_2X_GR u8g(U8G_I2C_OPT_NONE); // I2C |
|||
//U8GLIB_NHD_C12864 u8g(13, 11, 10, 9, 8); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9, RST = 8 |
|||
//U8GLIB_NHD_C12832 u8g(13, 11, 10, 9, 8); // SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9, RST = 8 |
|||
//U8GLIB_T6963_240X128 u8g(8, 9, 10, 11, 4, 5, 6, 7, 14, 15, 17, 18, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7, cs=14, a0=15, wr=17, rd=18, reset=16 |
|||
//U8GLIB_T6963_240X64 u8g(8, 9, 10, 11, 4, 5, 6, 7, 14, 15, 17, 18, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7, cs=14, a0=15, wr=17, rd=18, reset=16 |
|||
//U8GLIB_T6963_128X64 u8g(8, 9, 10, 11, 4, 5, 6, 7, 14, 15, 17, 18, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7, cs=14, a0=15, wr=17, rd=18, reset=16 |
|||
|
|||
#define u8g_logo_width 38 |
|||
#define u8g_logo_height 24 |
|||
//static unsigned char u8g_logo_bits[] = { |
|||
static unsigned char u8g_logo_bits[] U8G_PROGMEM = { |
|||
0xff, 0xff, 0xff, 0xff, 0x3f, 0xff, 0xff, 0xff, 0xff, 0x3f, 0xe0, 0xe0, |
|||
0xff, 0xff, 0x3f, 0xe3, 0xe1, 0xff, 0xff, 0x3f, 0xf3, 0xf1, 0xff, 0xff, |
|||
0x3f, 0xf3, 0xf1, 0xfe, 0xbf, 0x37, 0xf3, 0x11, 0x1c, 0x1f, 0x30, 0xf3, |
|||
0x01, 0x08, 0x8c, 0x20, 0xf3, 0x01, 0x00, 0xc0, 0x39, 0xf3, 0x81, 0xc7, |
|||
0xc1, 0x39, 0xf3, 0xc1, 0xc7, 0xc9, 0x38, 0xf3, 0xc1, 0xc3, 0x19, 0x3c, |
|||
0xe3, 0x89, 0x01, 0x98, 0x3f, 0xc7, 0x18, 0x00, 0x08, 0x3e, 0x0f, 0x3c, |
|||
0x70, 0x1c, 0x30, 0x3f, 0xff, 0xfc, 0x87, 0x31, 0xff, 0xff, 0xbf, 0xc7, |
|||
0x23, 0x01, 0x00, 0x00, 0xc6, 0x23, 0x03, 0x00, 0x00, 0x0e, 0x30, 0xff, |
|||
0xff, 0x3f, 0x1f, 0x3c, 0xff, 0xff, 0x3f, 0xff, 0x3f, 0xff, 0xff, 0x3f, |
|||
0xff, 0x3f, 0xff, 0xff, 0xff, 0xff, 0x3f, 0xff, 0xff, 0xff, 0xff, 0x3f }; |
|||
|
|||
void draw(void) { |
|||
// graphic commands to redraw the complete screen should be placed here |
|||
u8g.drawXBMP( 0, 0, u8g_logo_width, u8g_logo_height, u8g_logo_bits); |
|||
} |
|||
|
|||
void setup(void) { |
|||
// flip screen, if required |
|||
// u8g.setRot180(); |
|||
} |
|||
|
|||
void loop(void) { |
|||
// picture loop |
|||
u8g.firstPage(); |
|||
do { |
|||
draw(); |
|||
} while( u8g.nextPage() ); |
|||
|
|||
// rebuild the picture after some delay |
|||
delay(500); |
|||
} |
|||
|
|||
@ -0,0 +1,80 @@ |
|||
|
|||
The U8glib code (http://code.google.com/p/u8glib/) is licensed under the terms of |
|||
the new-bsd license (two-clause bsd license). |
|||
See also: http://www.opensource.org/licenses/bsd-license.php |
|||
|
|||
The repository and optionally the releases contain icons, which are |
|||
derived from the WPZOOM Developer Icon Set: |
|||
http://www.wpzoom.com/wpzoom/new-freebie-wpzoom-developer-icon-set-154-free-icons/ |
|||
WPZOOM Developer Icon Set by WPZOOM is licensed under a Creative Commons |
|||
Attribution-ShareAlike 3.0 Unported License. |
|||
|
|||
Fonts are licensed under different conditions. |
|||
See http://code.google.com/p/u8glib/wiki/fontgroup for |
|||
detailed information on the licensing conditions for each font. |
|||
|
|||
============ X11 Fonts COUR, HELV, NCEN, TIM, SYMB ============ |
|||
|
|||
For fonts derived from the following files, the license below applies. |
|||
COURB08.BDF COURB10.BDF COURB12.BDF COURB14.BDF COURB18.BDF |
|||
COURB24.BDF COURR08.BDF COURR10.BDF COURR12.BDF COURR14.BDF |
|||
COURR18.BDF COURR24.BDF HELVB08.BDF HELVB10.BDF HELVB12.BDF HELVB14.BDF |
|||
HELVB18.BDF HELVB24.BDF HELVR08.BDF HELVR10.BDF HELVR12.BDF HELVR14.BDF |
|||
HELVR18.BDF HELVR24.BDF NCENB08.BDF NCENB10.BDF NCENB12.BDF |
|||
NCENB14.BDF NCENB18.BDF NCENB24.BDF NCENR08.BDF NCENR10.BDF |
|||
NCENR12.BDF NCENR14.BDF NCENR18.BDF NCENR24.BDF SYMB08.BDF SYMB10.BDF |
|||
SYMB12.BDF SYMB14.BDF SYMB18.BDF SYMB24.BDF TIMB08.BDF TIMB10.BDF |
|||
TIMB12.BDF TIMB14.BDF TIMB18.BDF TIMB24.BDF TIMR08.BDF TIMR10.BDF |
|||
TIMR12.BDF TIMR14.BDF TIMR18.BDF TIMR24.BDF |
|||
|
|||
Copyright 1984-1989, 1994 Adobe Systems Incorporated. |
|||
Copyright 1988, 1994 Digital Equipment Corporation. |
|||
|
|||
Adobe is a trademark of Adobe Systems Incorporated which may be |
|||
registered in certain jurisdictions. |
|||
Permission to use these trademarks is hereby granted only in |
|||
association with the images described in this file. |
|||
|
|||
Permission to use, copy, modify, distribute and sell this software |
|||
and its documentation for any purpose and without fee is hereby |
|||
granted, provided that the above copyright notices appear in all |
|||
copies and that both those copyright notices and this permission |
|||
notice appear in supporting documentation, and that the names of |
|||
Adobe Systems and Digital Equipment Corporation not be used in |
|||
advertising or publicity pertaining to distribution of the software |
|||
without specific, written prior permission. Adobe Systems and |
|||
Digital Equipment Corporation make no representations about the |
|||
suitability of this software for any purpose. It is provided "as |
|||
is" without express or implied warranty. |
|||
|
|||
|
|||
============ BSD License for U8glib Code ============ |
|||
|
|||
Universal 8bit Graphics Library (http://code.google.com/p/u8glib/) |
|||
|
|||
Copyright (c) 2011, olikraus@gmail.com |
|||
All rights reserved. |
|||
|
|||
Redistribution and use in source and binary forms, with or without modification, |
|||
are permitted provided that the following conditions are met: |
|||
|
|||
* Redistributions of source code must retain the above copyright notice, this list |
|||
of conditions and the following disclaimer. |
|||
|
|||
* Redistributions in binary form must reproduce the above copyright notice, this |
|||
list of conditions and the following disclaimer in the documentation and/or other |
|||
materials provided with the distribution. |
|||
|
|||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
|||
CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
|||
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
|||
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
|||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
|||
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
|||
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
|||
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
|||
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
|||
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF |
|||
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|||
File diff suppressed because it is too large
File diff suppressed because it is too large
@ -0,0 +1,177 @@ |
|||
/*
|
|||
|
|||
u8g_bitmap.c |
|||
|
|||
Universal 8bit Graphics Library |
|||
|
|||
Copyright (c) 2011, olikraus@gmail.com |
|||
All rights reserved. |
|||
|
|||
Redistribution and use in source and binary forms, with or without modification, |
|||
are permitted provided that the following conditions are met: |
|||
|
|||
* Redistributions of source code must retain the above copyright notice, this list |
|||
of conditions and the following disclaimer. |
|||
|
|||
* Redistributions in binary form must reproduce the above copyright notice, this |
|||
list of conditions and the following disclaimer in the documentation and/or other |
|||
materials provided with the distribution. |
|||
|
|||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
|||
CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
|||
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
|||
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
|||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
|||
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
|||
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
|||
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
|||
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
|||
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF |
|||
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|||
|
|||
|
|||
*/ |
|||
|
|||
#include "u8g.h" |
|||
|
|||
void u8g_DrawHBitmap(u8g_t *u8g, u8g_uint_t x, u8g_uint_t y, u8g_uint_t cnt, const uint8_t *bitmap) |
|||
{ |
|||
while( cnt > 0 ) |
|||
{ |
|||
u8g_Draw8Pixel(u8g, x, y, 0, *bitmap); |
|||
bitmap++; |
|||
cnt--; |
|||
x+=8; |
|||
} |
|||
} |
|||
|
|||
void u8g_DrawBitmap(u8g_t *u8g, u8g_uint_t x, u8g_uint_t y, u8g_uint_t cnt, u8g_uint_t h, const uint8_t *bitmap) |
|||
{ |
|||
if ( u8g_IsBBXIntersection(u8g, x, y, cnt*8, h) == 0 ) |
|||
return; |
|||
while( h > 0 ) |
|||
{ |
|||
u8g_DrawHBitmap(u8g, x, y, cnt, bitmap); |
|||
bitmap += cnt; |
|||
y++; |
|||
h--; |
|||
} |
|||
} |
|||
|
|||
|
|||
void u8g_DrawHBitmapP(u8g_t *u8g, u8g_uint_t x, u8g_uint_t y, u8g_uint_t cnt, const u8g_pgm_uint8_t *bitmap) |
|||
{ |
|||
while( cnt > 0 ) |
|||
{ |
|||
u8g_Draw8Pixel(u8g, x, y, 0, u8g_pgm_read(bitmap)); |
|||
bitmap++; |
|||
cnt--; |
|||
x+=8; |
|||
} |
|||
} |
|||
|
|||
void u8g_DrawBitmapP(u8g_t *u8g, u8g_uint_t x, u8g_uint_t y, u8g_uint_t cnt, u8g_uint_t h, const u8g_pgm_uint8_t *bitmap) |
|||
{ |
|||
if ( u8g_IsBBXIntersection(u8g, x, y, cnt*8, h) == 0 ) |
|||
return; |
|||
while( h > 0 ) |
|||
{ |
|||
u8g_DrawHBitmapP(u8g, x, y, cnt, bitmap); |
|||
bitmap += cnt; |
|||
y++; |
|||
h--; |
|||
} |
|||
} |
|||
|
|||
/*=========================================================================*/ |
|||
|
|||
static void u8g_DrawHXBM(u8g_t *u8g, u8g_uint_t x, u8g_uint_t y, u8g_uint_t w, const uint8_t *bitmap) |
|||
{ |
|||
uint8_t d; |
|||
x+=7; |
|||
while( w >= 8 ) |
|||
{ |
|||
u8g_Draw8Pixel(u8g, x, y, 2, *bitmap); |
|||
bitmap++; |
|||
w-= 8; |
|||
x+=8; |
|||
} |
|||
if ( w > 0 ) |
|||
{ |
|||
d = *bitmap; |
|||
x -= 7; |
|||
do |
|||
{ |
|||
if ( d & 1 ) |
|||
u8g_DrawPixel(u8g, x, y); |
|||
x++; |
|||
w--; |
|||
d >>= 1; |
|||
} while ( w > 0 ); |
|||
} |
|||
} |
|||
|
|||
void u8g_DrawXBM(u8g_t *u8g, u8g_uint_t x, u8g_uint_t y, u8g_uint_t w, u8g_uint_t h, const uint8_t *bitmap) |
|||
{ |
|||
u8g_uint_t b; |
|||
b = w; |
|||
b += 7; |
|||
b >>= 3; |
|||
|
|||
if ( u8g_IsBBXIntersection(u8g, x, y, w, h) == 0 ) |
|||
return; |
|||
|
|||
while( h > 0 ) |
|||
{ |
|||
u8g_DrawHXBM(u8g, x, y, w, bitmap); |
|||
bitmap += b; |
|||
y++; |
|||
h--; |
|||
} |
|||
} |
|||
|
|||
static void u8g_DrawHXBMP(u8g_t *u8g, u8g_uint_t x, u8g_uint_t y, u8g_uint_t w, const u8g_pgm_uint8_t *bitmap) |
|||
{ |
|||
uint8_t d; |
|||
x+=7; |
|||
while( w >= 8 ) |
|||
{ |
|||
u8g_Draw8Pixel(u8g, x, y, 2, u8g_pgm_read(bitmap)); |
|||
bitmap++; |
|||
w-= 8; |
|||
x+=8; |
|||
} |
|||
if ( w > 0 ) |
|||
{ |
|||
d = u8g_pgm_read(bitmap); |
|||
x -= 7; |
|||
do |
|||
{ |
|||
if ( d & 1 ) |
|||
u8g_DrawPixel(u8g, x, y); |
|||
x++; |
|||
w--; |
|||
d >>= 1; |
|||
} while ( w > 0 ); |
|||
} |
|||
} |
|||
|
|||
void u8g_DrawXBMP(u8g_t *u8g, u8g_uint_t x, u8g_uint_t y, u8g_uint_t w, u8g_uint_t h, const u8g_pgm_uint8_t *bitmap) |
|||
{ |
|||
u8g_uint_t b; |
|||
b = w; |
|||
b += 7; |
|||
b >>= 3; |
|||
|
|||
if ( u8g_IsBBXIntersection(u8g, x, y, w, h) == 0 ) |
|||
return; |
|||
while( h > 0 ) |
|||
{ |
|||
u8g_DrawHXBMP(u8g, x, y, w, bitmap); |
|||
bitmap += b; |
|||
y++; |
|||
h--; |
|||
} |
|||
} |
|||
@ -0,0 +1,382 @@ |
|||
/*
|
|||
|
|||
u8g_circle.c |
|||
|
|||
Utility to draw empty and filled circles. |
|||
|
|||
Universal 8bit Graphics Library |
|||
|
|||
Copyright (c) 2011, bjthom@gmail.com |
|||
u8g_DrawCircle & u8g_DrawDisc by olikraus@gmail.com |
|||
|
|||
All rights reserved. |
|||
|
|||
Redistribution and use in source and binary forms, with or without modification, |
|||
are permitted provided that the following conditions are met: |
|||
|
|||
* Redistributions of source code must retain the above copyright notice, this list |
|||
of conditions and the following disclaimer. |
|||
|
|||
* Redistributions in binary form must reproduce the above copyright notice, this |
|||
list of conditions and the following disclaimer in the documentation and/or other |
|||
materials provided with the distribution. |
|||
|
|||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
|||
CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
|||
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
|||
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
|||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
|||
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
|||
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
|||
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
|||
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
|||
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF |
|||
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|||
|
|||
Addition to the U8G Library 02/25/12 |
|||
|
|||
|
|||
*/ |
|||
|
|||
#include "u8g.h" |
|||
|
|||
#ifdef OLD_CODE |
|||
|
|||
void circ_upperRight(u8g_t *u8g, u8g_uint_t x, u8g_uint_t y, u8g_uint_t x0, u8g_uint_t y0) { |
|||
u8g_DrawPixel(u8g, x0 + x, y0 - y); |
|||
u8g_DrawPixel(u8g, x0 + y, y0 - x); |
|||
} |
|||
|
|||
void circ_upperLeft(u8g_t *u8g, u8g_uint_t x, u8g_uint_t y, u8g_uint_t x0, u8g_uint_t y0) { |
|||
u8g_DrawPixel(u8g, x0 - x, y0 - y); |
|||
u8g_DrawPixel(u8g, x0 - y, y0 - x); |
|||
} |
|||
|
|||
void circ_lowerRight(u8g_t *u8g, u8g_uint_t x, u8g_uint_t y, u8g_uint_t x0, u8g_uint_t y0) { |
|||
u8g_DrawPixel(u8g, x0 + x, y0 + y); |
|||
u8g_DrawPixel(u8g, x0 + y, y0 + x); |
|||
} |
|||
|
|||
void circ_lowerLeft(u8g_t *u8g, u8g_uint_t x, u8g_uint_t y, u8g_uint_t x0, u8g_uint_t y0) { |
|||
u8g_DrawPixel(u8g, x0 - x, y0 + y); |
|||
u8g_DrawPixel(u8g, x0 - y, y0 + x); |
|||
} |
|||
|
|||
void circ_all(u8g_t *u8g, u8g_uint_t x, u8g_uint_t y, u8g_uint_t x0, u8g_uint_t y0) { |
|||
circ_upperRight(u8g, x, y, x0, y0); |
|||
circ_upperLeft(u8g, x, y, x0, y0); |
|||
circ_lowerRight(u8g, x, y, x0, y0); |
|||
circ_lowerLeft(u8g, x, y, x0, y0); |
|||
} |
|||
|
|||
void u8g_DrawEmpCirc(u8g_t *u8g, u8g_uint_t x0, u8g_uint_t y0, u8g_uint_t rad, uint8_t option) |
|||
{ |
|||
if ( u8g_IsBBXIntersection(u8g, x0-rad-1, y0-rad-1, 2*rad+1, 2*rad+1) == 0) |
|||
return; |
|||
|
|||
int f = 1 - rad; |
|||
int ddF_x = 1; |
|||
int ddF_y = -2*rad; |
|||
uint8_t x = 0; |
|||
uint8_t y = rad; |
|||
|
|||
void ( *circ_util )(u8g_t *, u8g_uint_t, u8g_uint_t, u8g_uint_t, u8g_uint_t); |
|||
|
|||
switch (option) |
|||
{ |
|||
case U8G_CIRC_UPPER_RIGHT: |
|||
u8g_DrawPixel(u8g, x0, y0 - rad); |
|||
u8g_DrawPixel(u8g, x0 + rad, y0); |
|||
circ_util = circ_upperRight; |
|||
break; |
|||
case U8G_CIRC_UPPER_LEFT: |
|||
u8g_DrawPixel(u8g, x0, y0 - rad); |
|||
u8g_DrawPixel(u8g, x0 - rad, y0); |
|||
circ_util = circ_upperLeft; |
|||
break; |
|||
case U8G_CIRC_LOWER_RIGHT: |
|||
u8g_DrawPixel(u8g, x0, y0 + rad); |
|||
u8g_DrawPixel(u8g, x0 + rad, y0); |
|||
circ_util = circ_lowerRight; |
|||
break; |
|||
case U8G_CIRC_LOWER_LEFT: |
|||
u8g_DrawPixel(u8g, x0, y0 + rad); |
|||
u8g_DrawPixel(u8g, x0 - rad, y0); |
|||
circ_util = circ_lowerLeft; |
|||
break; |
|||
default: |
|||
case U8G_CIRC_ALL: |
|||
u8g_DrawPixel(u8g, x0, y0 + rad); |
|||
u8g_DrawPixel(u8g, x0, y0 - rad); |
|||
u8g_DrawPixel(u8g, x0 + rad, y0); |
|||
u8g_DrawPixel(u8g, x0 - rad, y0); |
|||
circ_util = circ_all; |
|||
break; |
|||
} |
|||
|
|||
while( x < y ) |
|||
{ |
|||
if(f >= 0) |
|||
{ |
|||
y--; |
|||
ddF_y += 2; |
|||
f += ddF_y; |
|||
} |
|||
x++; |
|||
ddF_x += 2; |
|||
f += ddF_x; |
|||
|
|||
circ_util(u8g, x, y, x0, y0); |
|||
} |
|||
} |
|||
|
|||
|
|||
void u8g_DrawFillCirc(u8g_t *u8g, u8g_uint_t x0, u8g_uint_t y0, u8g_uint_t rad, uint8_t option) |
|||
{ |
|||
if ( u8g_IsBBXIntersection(u8g, x0-rad-1, y0-rad-1, 2*rad+1, 2*rad+1) == 0) |
|||
return; |
|||
|
|||
int f = 1 - rad; |
|||
int ddF_x = 1; |
|||
int ddF_y = -2*rad; |
|||
uint8_t x = 0; |
|||
uint8_t y = rad; |
|||
|
|||
// Draw vertical diameter at the horiz. center
|
|||
// u8g_DrawVLine(u8g, x0, y0 - rad, 2*rad+1);
|
|||
|
|||
if (option == U8G_CIRC_UPPER_LEFT || option == U8G_CIRC_UPPER_RIGHT) { |
|||
u8g_DrawVLine(u8g, x0, y0 - rad, rad+1); |
|||
} |
|||
else if (option == U8G_CIRC_LOWER_LEFT || option == U8G_CIRC_LOWER_RIGHT) { |
|||
u8g_DrawVLine(u8g, x0, y0, rad+1); |
|||
} |
|||
else { |
|||
u8g_DrawVLine(u8g, x0, y0 - rad, 2*rad+1); |
|||
} |
|||
|
|||
while( x < y ) |
|||
{ |
|||
if(f >= 0) |
|||
{ |
|||
y--; |
|||
ddF_y += 2; |
|||
f += ddF_y; |
|||
} |
|||
x++; |
|||
ddF_x += 2; |
|||
f += ddF_x; |
|||
|
|||
//Draw vertical lines from one point to another
|
|||
|
|||
switch (option) |
|||
{ |
|||
case U8G_CIRC_UPPER_RIGHT: |
|||
u8g_DrawVLine(u8g, x0+x, y0-y, y+1); |
|||
u8g_DrawVLine(u8g, x0+y, y0-x, x+1); |
|||
break; |
|||
case U8G_CIRC_UPPER_LEFT: |
|||
u8g_DrawVLine(u8g, x0-x, y0-y, y+1); |
|||
u8g_DrawVLine(u8g, x0-y, y0-x, x+1); |
|||
break; |
|||
case U8G_CIRC_LOWER_RIGHT: |
|||
u8g_DrawVLine(u8g, x0+x, y0, y+1); |
|||
u8g_DrawVLine(u8g, x0+y, y0, x+1); |
|||
break; |
|||
case U8G_CIRC_LOWER_LEFT: |
|||
u8g_DrawVLine(u8g, x0-x, y0, y+1); |
|||
u8g_DrawVLine(u8g, x0-y, y0, x+1); |
|||
break; |
|||
case U8G_CIRC_ALL: |
|||
u8g_DrawVLine(u8g, x0+x, y0-y, 2*y+1); |
|||
u8g_DrawVLine(u8g, x0-x, y0-y, 2*y+1); |
|||
u8g_DrawVLine(u8g, x0+y, y0-x, 2*x+1); |
|||
u8g_DrawVLine(u8g, x0-y, y0-x, 2*x+1); |
|||
break; |
|||
} |
|||
} |
|||
} |
|||
|
|||
#endif |
|||
|
|||
/*=========================================================================*/ |
|||
|
|||
static void u8g_draw_circle_section(u8g_t *u8g, u8g_uint_t x, u8g_uint_t y, u8g_uint_t x0, u8g_uint_t y0, uint8_t option) U8G_NOINLINE; |
|||
|
|||
static void u8g_draw_circle_section(u8g_t *u8g, u8g_uint_t x, u8g_uint_t y, u8g_uint_t x0, u8g_uint_t y0, uint8_t option) |
|||
{ |
|||
/* upper right */ |
|||
if ( option & U8G_DRAW_UPPER_RIGHT ) |
|||
{ |
|||
u8g_DrawPixel(u8g, x0 + x, y0 - y); |
|||
u8g_DrawPixel(u8g, x0 + y, y0 - x); |
|||
} |
|||
|
|||
/* upper left */ |
|||
if ( option & U8G_DRAW_UPPER_LEFT ) |
|||
{ |
|||
u8g_DrawPixel(u8g, x0 - x, y0 - y); |
|||
u8g_DrawPixel(u8g, x0 - y, y0 - x); |
|||
} |
|||
|
|||
/* lower right */ |
|||
if ( option & U8G_DRAW_LOWER_RIGHT ) |
|||
{ |
|||
u8g_DrawPixel(u8g, x0 + x, y0 + y); |
|||
u8g_DrawPixel(u8g, x0 + y, y0 + x); |
|||
} |
|||
|
|||
/* lower left */ |
|||
if ( option & U8G_DRAW_LOWER_LEFT ) |
|||
{ |
|||
u8g_DrawPixel(u8g, x0 - x, y0 + y); |
|||
u8g_DrawPixel(u8g, x0 - y, y0 + x); |
|||
} |
|||
} |
|||
|
|||
void u8g_draw_circle(u8g_t *u8g, u8g_uint_t x0, u8g_uint_t y0, u8g_uint_t rad, uint8_t option) |
|||
{ |
|||
u8g_int_t f; |
|||
u8g_int_t ddF_x; |
|||
u8g_int_t ddF_y; |
|||
u8g_uint_t x; |
|||
u8g_uint_t y; |
|||
|
|||
f = 1; |
|||
f -= rad; |
|||
ddF_x = 1; |
|||
ddF_y = 0; |
|||
ddF_y -= rad; |
|||
ddF_y *= 2; |
|||
x = 0; |
|||
y = rad; |
|||
|
|||
u8g_draw_circle_section(u8g, x, y, x0, y0, option); |
|||
|
|||
while ( x < y ) |
|||
{ |
|||
if (f >= 0) |
|||
{ |
|||
y--; |
|||
ddF_y += 2; |
|||
f += ddF_y; |
|||
} |
|||
x++; |
|||
ddF_x += 2; |
|||
f += ddF_x; |
|||
|
|||
u8g_draw_circle_section(u8g, x, y, x0, y0, option); |
|||
} |
|||
} |
|||
|
|||
void u8g_DrawCircle(u8g_t *u8g, u8g_uint_t x0, u8g_uint_t y0, u8g_uint_t rad, uint8_t option) |
|||
{ |
|||
/* check for bounding box */ |
|||
{ |
|||
u8g_uint_t radp, radp2; |
|||
|
|||
radp = rad; |
|||
radp++; |
|||
radp2 = radp; |
|||
radp2 *= 2; |
|||
|
|||
if ( u8g_IsBBXIntersection(u8g, x0-radp, y0-radp, radp2, radp2) == 0) |
|||
return; |
|||
} |
|||
|
|||
/* draw circle */ |
|||
u8g_draw_circle(u8g, x0, y0, rad, option); |
|||
} |
|||
|
|||
static void u8g_draw_disc_section(u8g_t *u8g, u8g_uint_t x, u8g_uint_t y, u8g_uint_t x0, u8g_uint_t y0, uint8_t option) U8G_NOINLINE; |
|||
|
|||
static void u8g_draw_disc_section(u8g_t *u8g, u8g_uint_t x, u8g_uint_t y, u8g_uint_t x0, u8g_uint_t y0, uint8_t option) |
|||
{ |
|||
/* upper right */ |
|||
if ( option & U8G_DRAW_UPPER_RIGHT ) |
|||
{ |
|||
u8g_DrawVLine(u8g, x0+x, y0-y, y+1); |
|||
u8g_DrawVLine(u8g, x0+y, y0-x, x+1); |
|||
} |
|||
|
|||
/* upper left */ |
|||
if ( option & U8G_DRAW_UPPER_LEFT ) |
|||
{ |
|||
u8g_DrawVLine(u8g, x0-x, y0-y, y+1); |
|||
u8g_DrawVLine(u8g, x0-y, y0-x, x+1); |
|||
} |
|||
|
|||
/* lower right */ |
|||
if ( option & U8G_DRAW_LOWER_RIGHT ) |
|||
{ |
|||
u8g_DrawVLine(u8g, x0+x, y0, y+1); |
|||
u8g_DrawVLine(u8g, x0+y, y0, x+1); |
|||
} |
|||
|
|||
/* lower left */ |
|||
if ( option & U8G_DRAW_LOWER_LEFT ) |
|||
{ |
|||
u8g_DrawVLine(u8g, x0-x, y0, y+1); |
|||
u8g_DrawVLine(u8g, x0-y, y0, x+1); |
|||
} |
|||
} |
|||
|
|||
void u8g_draw_disc(u8g_t *u8g, u8g_uint_t x0, u8g_uint_t y0, u8g_uint_t rad, uint8_t option) |
|||
{ |
|||
u8g_int_t f; |
|||
u8g_int_t ddF_x; |
|||
u8g_int_t ddF_y; |
|||
u8g_uint_t x; |
|||
u8g_uint_t y; |
|||
|
|||
f = 1; |
|||
f -= rad; |
|||
ddF_x = 1; |
|||
ddF_y = 0; |
|||
ddF_y -= rad; |
|||
ddF_y *= 2; |
|||
x = 0; |
|||
y = rad; |
|||
|
|||
u8g_draw_disc_section(u8g, x, y, x0, y0, option); |
|||
|
|||
while ( x < y ) |
|||
{ |
|||
if (f >= 0) |
|||
{ |
|||
y--; |
|||
ddF_y += 2; |
|||
f += ddF_y; |
|||
} |
|||
x++; |
|||
ddF_x += 2; |
|||
f += ddF_x; |
|||
|
|||
u8g_draw_disc_section(u8g, x, y, x0, y0, option); |
|||
} |
|||
} |
|||
|
|||
void u8g_DrawDisc(u8g_t *u8g, u8g_uint_t x0, u8g_uint_t y0, u8g_uint_t rad, uint8_t option) |
|||
{ |
|||
/* check for bounding box */ |
|||
{ |
|||
u8g_uint_t radp, radp2; |
|||
|
|||
radp = rad; |
|||
radp++; |
|||
radp2 = radp; |
|||
radp2 *= 2; |
|||
|
|||
if ( u8g_IsBBXIntersection(u8g, x0-radp, y0-radp, radp2, radp2) == 0) |
|||
return; |
|||
} |
|||
|
|||
/* draw disc */ |
|||
u8g_draw_disc(u8g, x0, y0, rad, option); |
|||
} |
|||
|
|||
|
|||
|
|||
|
|||
@ -0,0 +1,156 @@ |
|||
/*
|
|||
|
|||
u8g_clip.c |
|||
|
|||
procedures for clipping |
|||
taken over from procs in u8g_pb.c |
|||
|
|||
Universal 8bit Graphics Library |
|||
|
|||
Copyright (c) 2012, olikraus@gmail.com |
|||
All rights reserved. |
|||
|
|||
Redistribution and use in source and binary forms, with or without modification, |
|||
are permitted provided that the following conditions are met: |
|||
|
|||
* Redistributions of source code must retain the above copyright notice, this list |
|||
of conditions and the following disclaimer. |
|||
|
|||
* Redistributions in binary form must reproduce the above copyright notice, this |
|||
list of conditions and the following disclaimer in the documentation and/or other |
|||
materials provided with the distribution. |
|||
|
|||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
|||
CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
|||
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
|||
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
|||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
|||
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
|||
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
|||
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
|||
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
|||
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF |
|||
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|||
|
|||
Notes |
|||
|
|||
This is one of the most critical parts of u8glib. It must be fast, but still reliable. |
|||
Based on the intersection program (see tools folder), there is minimized version of |
|||
the condition for the intersaction test: |
|||
minimized version |
|||
---1----0 1 b1 <= a2 && b1 > b2 |
|||
-----1--0 1 b2 >= a1 && b1 > b2 |
|||
---1-1--- 1 b1 <= a2 && b2 >= a1 |
|||
It includes the assumption, that a1 <= a2 is always true (correct, because |
|||
a1, a2 are the page dimensions. |
|||
|
|||
The direct implementation of the above result is done in: |
|||
uint8_t u8g_is_intersection_boolean(u8g_uint_t a0, u8g_uint_t a1, u8g_uint_t v0, u8g_uint_t v1) |
|||
However, this is slower than a decision tree version: |
|||
static uint8_t u8g_is_intersection_decision_tree(u8g_uint_t a0, u8g_uint_t a1, u8g_uint_t v0, u8g_uint_t v1) |
|||
Also suprising is, that he the macro implementation is slower than the inlined version. |
|||
|
|||
The decision tree is based on the expansion of the truth table. |
|||
|
|||
*/ |
|||
|
|||
#include "u8g.h" |
|||
|
|||
#ifdef __GNUC__ |
|||
#define U8G_ALWAYS_INLINE __attribute__((always_inline)) |
|||
#else |
|||
#define U8G_ALWAYS_INLINE |
|||
#endif |
|||
|
|||
/*
|
|||
intersection assumptions: |
|||
a1 <= a2 is always true |
|||
|
|||
minimized version |
|||
---1----0 1 b1 <= a2 && b1 > b2 |
|||
-----1--0 1 b2 >= a1 && b1 > b2 |
|||
---1-1--- 1 b1 <= a2 && b2 >= a1 |
|||
*/ |
|||
|
|||
#ifdef OLD_CODE_WHICH_IS_TOO_SLOW |
|||
static uint8_t u8g_is_intersection_boolean(u8g_uint_t a0, u8g_uint_t a1, u8g_uint_t v0, u8g_uint_t v1) |
|||
{ |
|||
uint8_t c1, c2, c3, tmp; |
|||
c1 = v0 <= a1; |
|||
c2 = v1 >= a0; |
|||
c3 = v0 > v1; |
|||
|
|||
tmp = c1; |
|||
c1 &= c2; |
|||
c2 &= c3; |
|||
c3 &= tmp; |
|||
c1 |= c2; |
|||
c1 |= c3; |
|||
return c1 & 1; |
|||
} |
|||
#endif |
|||
|
|||
#define U8G_IS_INTERSECTION_MACRO(a0,a1,v0,v1) ((uint8_t)( (v0) <= (a1) ) ? ( ( (v1) >= (a0) ) ? ( 1 ) : ( (v0) > (v1) ) ) : ( ( (v1) >= (a0) ) ? ( (v0) > (v1) ) : ( 0 ) )) |
|||
|
|||
static uint8_t u8g_is_intersection_decision_tree(u8g_uint_t a0, u8g_uint_t a1, u8g_uint_t v0, u8g_uint_t v1) U8G_ALWAYS_INLINE; |
|||
static uint8_t u8g_is_intersection_decision_tree(u8g_uint_t a0, u8g_uint_t a1, u8g_uint_t v0, u8g_uint_t v1) |
|||
{ |
|||
/* surprisingly the macro leads to larger code */ |
|||
/* return U8G_IS_INTERSECTION_MACRO(a0,a1,v0,v1); */ |
|||
if ( v0 <= a1 ) |
|||
{ |
|||
if ( v1 >= a0 ) |
|||
{ |
|||
return 1; |
|||
} |
|||
else |
|||
{ |
|||
if ( v0 > v1 ) |
|||
{ |
|||
return 1; |
|||
} |
|||
else |
|||
{ |
|||
return 0; |
|||
} |
|||
} |
|||
} |
|||
else |
|||
{ |
|||
if ( v1 >= a0 ) |
|||
{ |
|||
if ( v0 > v1 ) |
|||
{ |
|||
return 1; |
|||
} |
|||
else |
|||
{ |
|||
return 0; |
|||
} |
|||
} |
|||
else |
|||
{ |
|||
return 0; |
|||
} |
|||
} |
|||
} |
|||
|
|||
|
|||
uint8_t u8g_IsBBXIntersection(u8g_t *u8g, u8g_uint_t x, u8g_uint_t y, u8g_uint_t w, u8g_uint_t h) |
|||
{ |
|||
register u8g_uint_t tmp; |
|||
tmp = y; |
|||
tmp += h; |
|||
tmp--; |
|||
if ( u8g_is_intersection_decision_tree(u8g->current_page.y0, u8g->current_page.y1, y, tmp) == 0 ) |
|||
return 0; |
|||
|
|||
tmp = x; |
|||
tmp += w; |
|||
tmp--; |
|||
return u8g_is_intersection_decision_tree(u8g->current_page.x0, u8g->current_page.x1, x, tmp); |
|||
} |
|||
|
|||
|
|||
@ -0,0 +1,173 @@ |
|||
/*
|
|||
|
|||
u8g_com_api.c |
|||
|
|||
Universal 8bit Graphics Library |
|||
|
|||
Copyright (c) 2011, olikraus@gmail.com |
|||
All rights reserved. |
|||
|
|||
Redistribution and use in source and binary forms, with or without modification, |
|||
are permitted provided that the following conditions are met: |
|||
|
|||
* Redistributions of source code must retain the above copyright notice, this list |
|||
of conditions and the following disclaimer. |
|||
|
|||
* Redistributions in binary form must reproduce the above copyright notice, this |
|||
list of conditions and the following disclaimer in the documentation and/or other |
|||
materials provided with the distribution. |
|||
|
|||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
|||
CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
|||
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
|||
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
|||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
|||
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
|||
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
|||
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
|||
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
|||
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF |
|||
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|||
|
|||
|
|||
*/ |
|||
|
|||
#include "u8g.h" |
|||
|
|||
uint8_t u8g_InitCom(u8g_t *u8g, u8g_dev_t *dev) |
|||
{ |
|||
return dev->com_fn(u8g, U8G_COM_MSG_INIT, 0, NULL); |
|||
} |
|||
|
|||
void u8g_StopCom(u8g_t *u8g, u8g_dev_t *dev) |
|||
{ |
|||
dev->com_fn(u8g, U8G_COM_MSG_STOP, 0, NULL); |
|||
} |
|||
|
|||
/* cs contains the chip number, which should be enabled */ |
|||
void u8g_SetChipSelect(u8g_t *u8g, u8g_dev_t *dev, uint8_t cs) |
|||
{ |
|||
dev->com_fn(u8g, U8G_COM_MSG_CHIP_SELECT, cs, NULL); |
|||
} |
|||
|
|||
void u8g_SetResetLow(u8g_t *u8g, u8g_dev_t *dev) |
|||
{ |
|||
dev->com_fn(u8g, U8G_COM_MSG_RESET, 0, NULL); |
|||
} |
|||
|
|||
void u8g_SetResetHigh(u8g_t *u8g, u8g_dev_t *dev) |
|||
{ |
|||
dev->com_fn(u8g, U8G_COM_MSG_RESET, 1, NULL); |
|||
} |
|||
|
|||
|
|||
void u8g_SetAddress(u8g_t *u8g, u8g_dev_t *dev, uint8_t address) |
|||
{ |
|||
dev->com_fn(u8g, U8G_COM_MSG_ADDRESS, address, NULL); |
|||
} |
|||
|
|||
uint8_t u8g_WriteByte(u8g_t *u8g, u8g_dev_t *dev, uint8_t val) |
|||
{ |
|||
return dev->com_fn(u8g, U8G_COM_MSG_WRITE_BYTE, val, NULL); |
|||
} |
|||
|
|||
uint8_t u8g_WriteSequence(u8g_t *u8g, u8g_dev_t *dev, uint8_t cnt, uint8_t *seq) |
|||
{ |
|||
return dev->com_fn(u8g, U8G_COM_MSG_WRITE_SEQ, cnt, seq); |
|||
} |
|||
|
|||
uint8_t u8g_WriteSequenceP(u8g_t *u8g, u8g_dev_t *dev, uint8_t cnt, const uint8_t *seq) |
|||
{ |
|||
return dev->com_fn(u8g, U8G_COM_MSG_WRITE_SEQ_P, cnt, (void *)seq); |
|||
} |
|||
|
|||
/*
|
|||
sequence := { direct_value | escape_sequence } |
|||
direct_value := 0..254 |
|||
escape_sequence := value_255 | sequence_end | delay | adr | cs | not_used |
|||
value_255 := 255 255 |
|||
sequence_end = 255 254 |
|||
delay := 255 0..127 |
|||
adr := 255 0x0e0 .. 0x0ef |
|||
cs := 255 0x0d0 .. 0x0df |
|||
not_used := 255 101..254 |
|||
|
|||
#define U8G_ESC_DLY(x) 255, ((x) & 0x7f) |
|||
#define U8G_ESC_CS(x) 255, (0xd0 | ((x)&0x0f)) |
|||
#define U8G_ESC_ADR(x) 255, (0xe0 | ((x)&0x0f)) |
|||
#define U8G_ESC_VCC(x) 255, (0xbe | ((x)&0x01)) |
|||
#define U8G_ESC_END 255, 254 |
|||
#define U8G_ESC_255 255, 255 |
|||
#define U8G_ESC_RST(x) 255, (0xc0 | ((x)&0x0f)) |
|||
|
|||
*/ |
|||
uint8_t u8g_WriteEscSeqP(u8g_t *u8g, u8g_dev_t *dev, const uint8_t *esc_seq) |
|||
{ |
|||
uint8_t is_escape = 0; |
|||
uint8_t value; |
|||
for(;;) |
|||
{ |
|||
value = u8g_pgm_read(esc_seq); |
|||
if ( is_escape == 0 ) |
|||
{ |
|||
if ( value != 255 ) |
|||
{ |
|||
if ( u8g_WriteByte(u8g, dev, value) == 0 ) |
|||
return 0; |
|||
} |
|||
else |
|||
{ |
|||
is_escape = 1; |
|||
} |
|||
} |
|||
else |
|||
{ |
|||
if ( value == 255 ) |
|||
{ |
|||
if ( u8g_WriteByte(u8g, dev, value) == 0 ) |
|||
return 0; |
|||
} |
|||
else if ( value == 254 ) |
|||
{ |
|||
break; |
|||
} |
|||
else if ( value >= 0x0f0 ) |
|||
{ |
|||
/* not yet used, do nothing */ |
|||
} |
|||
else if ( value >= 0xe0 ) |
|||
{ |
|||
u8g_SetAddress(u8g, dev, value & 0x0f); |
|||
} |
|||
else if ( value >= 0xd0 ) |
|||
{ |
|||
u8g_SetChipSelect(u8g, dev, value & 0x0f); |
|||
} |
|||
else if ( value >= 0xc0 ) |
|||
{ |
|||
u8g_SetResetLow(u8g, dev); |
|||
value &= 0x0f; |
|||
value <<= 4; |
|||
value+=2; |
|||
u8g_Delay(value); |
|||
u8g_SetResetHigh(u8g, dev); |
|||
u8g_Delay(value); |
|||
} |
|||
else if ( value >= 0xbe ) |
|||
{ |
|||
/* not yet implemented */ |
|||
/* u8g_SetVCC(u8g, dev, value & 0x01); */ |
|||
} |
|||
else if ( value <= 127 ) |
|||
{ |
|||
u8g_Delay(value); |
|||
} |
|||
is_escape = 0; |
|||
} |
|||
esc_seq++; |
|||
} |
|||
return 1; |
|||
} |
|||
|
|||
@ -0,0 +1,94 @@ |
|||
/*
|
|||
|
|||
u8g_com_api_16gr.c |
|||
|
|||
Extension of the com api for devices with 16 graylevels (4 bit per pixel). |
|||
This should fit to the 8h and 16h architectures (pb8v1, pb8v2, pb16v1, pb16v2), |
|||
mainly intended for SSD OLEDs |
|||
|
|||
Universal 8bit Graphics Library |
|||
|
|||
Copyright (c) 2011, olikraus@gmail.com |
|||
All rights reserved. |
|||
|
|||
Redistribution and use in source and binary forms, with or without modification, |
|||
are permitted provided that the following conditions are met: |
|||
|
|||
* Redistributions of source code must retain the above copyright notice, this list |
|||
of conditions and the following disclaimer. |
|||
|
|||
* Redistributions in binary form must reproduce the above copyright notice, this |
|||
list of conditions and the following disclaimer in the documentation and/or other |
|||
materials provided with the distribution. |
|||
|
|||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
|||
CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
|||
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
|||
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
|||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
|||
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
|||
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
|||
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
|||
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
|||
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF |
|||
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|||
|
|||
|
|||
*/ |
|||
|
|||
#include "u8g.h" |
|||
|
|||
/* interpret b as a monochrome bit pattern, write value 15 for high bit and value 0 for a low bit */ |
|||
/* topbit (msb) is sent last */ |
|||
/* example: b = 0x083 will send 0xff, 0x00, 0x00, 0xf0 */ |
|||
uint8_t u8g_WriteByteBWTo16GrDevice(u8g_t *u8g, u8g_dev_t *dev, uint8_t b) |
|||
{ |
|||
static uint8_t buf[4]; |
|||
static uint8_t map[4] = { 0, 0x00f, 0x0f0, 0x0ff }; |
|||
buf [3] = map[b & 3]; |
|||
b>>=2; |
|||
buf [2] = map[b & 3]; |
|||
b>>=2; |
|||
buf [1] = map[b & 3]; |
|||
b>>=2; |
|||
buf [0] = map[b & 3]; |
|||
return dev->com_fn(u8g, U8G_COM_MSG_WRITE_SEQ, 4, buf); |
|||
} |
|||
|
|||
uint8_t u8g_WriteSequenceBWTo16GrDevice(u8g_t *u8g, u8g_dev_t *dev, uint8_t cnt, uint8_t *ptr) |
|||
{ |
|||
do |
|||
{ |
|||
if ( u8g_WriteByteBWTo16GrDevice(u8g, dev, *ptr++) == 0 ) |
|||
return 0; |
|||
cnt--; |
|||
} while( cnt != 0 ); |
|||
return 1; |
|||
} |
|||
|
|||
/* interpret b as a 4L bit pattern, write values 0x000, 0x004, 0x008, 0x00c */ |
|||
uint8_t u8g_WriteByte4LTo16GrDevice(u8g_t *u8g, u8g_dev_t *dev, uint8_t b) |
|||
{ |
|||
//static uint8_t map[16] = { 0x000, 0x004, 0x008, 0x00c, 0x040, 0x044, 0x048, 0x04c, 0x080, 0x084, 0x088, 0x08c, 0x0c0, 0x0c4, 0x0c8, 0x0cc};
|
|||
//static uint8_t map[16] = { 0x000, 0x004, 0x00a, 0x00f, 0x040, 0x044, 0x04a, 0x04f, 0x0a0, 0x0a4, 0x0aa, 0x0af, 0x0f0, 0x0f4, 0x0fa, 0x0ff};
|
|||
static uint8_t map[16] = { 0x000, 0x040, 0x0a0, 0x0f0, 0x004, 0x044, 0x0a4, 0x0f4, 0x00a, 0x04a, 0x0aa, 0x0fa, 0x00f, 0x04f, 0x0af, 0x0ff}; |
|||
uint8_t bb; |
|||
bb = b; |
|||
bb &= 15; |
|||
b>>=4; |
|||
dev->com_fn(u8g, U8G_COM_MSG_WRITE_BYTE, map[bb], NULL); |
|||
return dev->com_fn(u8g, U8G_COM_MSG_WRITE_BYTE, map[b], NULL); |
|||
} |
|||
|
|||
uint8_t u8g_WriteSequence4LTo16GrDevice(u8g_t *u8g, u8g_dev_t *dev, uint8_t cnt, uint8_t *ptr) |
|||
{ |
|||
do |
|||
{ |
|||
if ( u8g_WriteByte4LTo16GrDevice(u8g, dev, *ptr++) == 0 ) |
|||
return 0; |
|||
cnt--; |
|||
} while( cnt != 0 ); |
|||
return 1; |
|||
} |
|||
@ -0,0 +1,75 @@ |
|||
/*
|
|||
|
|||
u8g_com_arduino_common.c |
|||
|
|||
shared procedures for the arduino communication procedures |
|||
|
|||
Universal 8bit Graphics Library |
|||
|
|||
Copyright (c) 2011, olikraus@gmail.com |
|||
All rights reserved. |
|||
|
|||
Redistribution and use in source and binary forms, with or without modification, |
|||
are permitted provided that the following conditions are met: |
|||
|
|||
* Redistributions of source code must retain the above copyright notice, this list |
|||
of conditions and the following disclaimer. |
|||
|
|||
* Redistributions in binary form must reproduce the above copyright notice, this |
|||
list of conditions and the following disclaimer in the documentation and/or other |
|||
materials provided with the distribution. |
|||
|
|||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
|||
CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
|||
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
|||
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
|||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
|||
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
|||
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
|||
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
|||
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
|||
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF |
|||
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|||
|
|||
|
|||
*/ |
|||
|
|||
#include "u8g.h" |
|||
|
|||
#if defined(ARDUINO) |
|||
|
|||
#if ARDUINO < 100 |
|||
#include <WProgram.h> |
|||
#else |
|||
#include <Arduino.h> |
|||
#endif |
|||
|
|||
void u8g_com_arduino_digital_write(u8g_t *u8g, uint8_t pin_index, uint8_t value) |
|||
{ |
|||
uint8_t pin; |
|||
pin = u8g->pin_list[pin_index]; |
|||
if ( pin != U8G_PIN_NONE ) |
|||
digitalWrite(pin, value); |
|||
} |
|||
|
|||
/* this procedure does not set the RW pin */ |
|||
void u8g_com_arduino_assign_pin_output_high(u8g_t *u8g) |
|||
{ |
|||
uint8_t i; |
|||
/* skip the RW pin, which is the last pin in the list */ |
|||
for( i = 0; i < U8G_PIN_LIST_LEN-1; i++ ) |
|||
{ |
|||
if ( u8g->pin_list[i] != U8G_PIN_NONE ) |
|||
{ |
|||
pinMode(u8g->pin_list[i], OUTPUT); |
|||
digitalWrite(u8g->pin_list[i], HIGH); |
|||
} |
|||
} |
|||
} |
|||
|
|||
|
|||
#endif |
|||
|
|||
|
|||
@ -0,0 +1,245 @@ |
|||
/*
|
|||
|
|||
u8g_arduino_fast_parallel.c |
|||
|
|||
Universal 8bit Graphics Library |
|||
|
|||
Copyright (c) 2011, olikraus@gmail.com |
|||
All rights reserved. |
|||
|
|||
Redistribution and use in source and binary forms, with or without modification, |
|||
are permitted provided that the following conditions are met: |
|||
|
|||
* Redistributions of source code must retain the above copyright notice, this list |
|||
of conditions and the following disclaimer. |
|||
|
|||
* Redistributions in binary form must reproduce the above copyright notice, this |
|||
list of conditions and the following disclaimer in the documentation and/or other |
|||
materials provided with the distribution. |
|||
|
|||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
|||
CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
|||
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
|||
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
|||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
|||
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
|||
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
|||
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
|||
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
|||
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF |
|||
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|||
|
|||
PIN_D0 8 |
|||
PIN_D1 9 |
|||
PIN_D2 10 |
|||
PIN_D3 11 |
|||
PIN_D4 4 |
|||
PIN_D5 5 |
|||
PIN_D6 6 |
|||
PIN_D7 7 |
|||
|
|||
PIN_CS1 14 |
|||
PIN_CS2 15 |
|||
PIN_RW 16 |
|||
PIN_DI 17 |
|||
PIN_EN 18 |
|||
|
|||
u8g_Init8Bit(u8g, dev, d0, d1, d2, d3, d4, d5, d6, d7, en, cs1, cs2, di, rw, reset) |
|||
u8g_Init8Bit(u8g, dev, 8, 9, 10, 11, 4, 5, 6, 7, 18, 14, 15, 17, 16, U8G_PIN_NONE) |
|||
|
|||
*/ |
|||
|
|||
#include "u8g.h" |
|||
|
|||
#if defined(ARDUINO) |
|||
|
|||
#if ARDUINO < 100 |
|||
//#include <WProgram.h>
|
|||
#include <wiring_private.h> |
|||
#include <pins_arduino.h> |
|||
#else |
|||
#include <Arduino.h> |
|||
#endif |
|||
|
|||
|
|||
#define PIN_D0 8 |
|||
#define PIN_D1 9 |
|||
#define PIN_D2 10 |
|||
#define PIN_D3 11 |
|||
#define PIN_D4 4 |
|||
#define PIN_D5 5 |
|||
#define PIN_D6 6 |
|||
#define PIN_D7 7 |
|||
|
|||
#define PIN_CS1 14 |
|||
#define PIN_CS2 15 |
|||
#define PIN_RW 16 |
|||
#define PIN_DI 17 |
|||
#define PIN_EN 18 |
|||
|
|||
//#define PIN_RESET
|
|||
|
|||
|
|||
#if defined(__PIC32MX) |
|||
/* CHIPKIT PIC32 */ |
|||
static volatile uint32_t *u8g_data_port[8]; |
|||
static uint32_t u8g_data_mask[8]; |
|||
#else |
|||
static volatile uint8_t *u8g_data_port[8]; |
|||
static uint8_t u8g_data_mask[8]; |
|||
#endif |
|||
|
|||
|
|||
|
|||
static void u8g_com_arduino_fast_parallel_init(u8g_t *u8g) |
|||
{ |
|||
u8g_data_port[0] = portOutputRegister(digitalPinToPort(u8g->pin_list[U8G_PI_D0])); |
|||
u8g_data_mask[0] = digitalPinToBitMask(u8g->pin_list[U8G_PI_D0]); |
|||
u8g_data_port[1] = portOutputRegister(digitalPinToPort(u8g->pin_list[U8G_PI_D1])); |
|||
u8g_data_mask[1] = digitalPinToBitMask(u8g->pin_list[U8G_PI_D1]); |
|||
u8g_data_port[2] = portOutputRegister(digitalPinToPort(u8g->pin_list[U8G_PI_D2])); |
|||
u8g_data_mask[2] = digitalPinToBitMask(u8g->pin_list[U8G_PI_D2]); |
|||
u8g_data_port[3] = portOutputRegister(digitalPinToPort(u8g->pin_list[U8G_PI_D3])); |
|||
u8g_data_mask[3] = digitalPinToBitMask(u8g->pin_list[U8G_PI_D3]); |
|||
|
|||
u8g_data_port[4] = portOutputRegister(digitalPinToPort(u8g->pin_list[U8G_PI_D4])); |
|||
u8g_data_mask[4] = digitalPinToBitMask(u8g->pin_list[U8G_PI_D4]); |
|||
u8g_data_port[5] = portOutputRegister(digitalPinToPort(u8g->pin_list[U8G_PI_D5])); |
|||
u8g_data_mask[5] = digitalPinToBitMask(u8g->pin_list[U8G_PI_D5]); |
|||
u8g_data_port[6] = portOutputRegister(digitalPinToPort(u8g->pin_list[U8G_PI_D6])); |
|||
u8g_data_mask[6] = digitalPinToBitMask(u8g->pin_list[U8G_PI_D6]); |
|||
u8g_data_port[7] = portOutputRegister(digitalPinToPort(u8g->pin_list[U8G_PI_D7])); |
|||
u8g_data_mask[7] = digitalPinToBitMask(u8g->pin_list[U8G_PI_D7]); |
|||
} |
|||
|
|||
void u8g_com_arduino_fast_write_data_pin(uint8_t pin, uint8_t val) |
|||
{ |
|||
if ( val != 0 ) |
|||
*u8g_data_port[pin] |= u8g_data_mask[pin]; |
|||
else |
|||
*u8g_data_port[pin] &= ~u8g_data_mask[pin]; |
|||
} |
|||
|
|||
|
|||
void u8g_com_arduino_fast_parallel_write(u8g_t *u8g, uint8_t val) |
|||
{ |
|||
u8g_com_arduino_fast_write_data_pin( 0, val&1 ); |
|||
val >>= 1; |
|||
u8g_com_arduino_fast_write_data_pin( 1, val&1 ); |
|||
val >>= 1; |
|||
u8g_com_arduino_fast_write_data_pin( 2, val&1 ); |
|||
val >>= 1; |
|||
u8g_com_arduino_fast_write_data_pin( 3, val&1 ); |
|||
val >>= 1; |
|||
|
|||
u8g_com_arduino_fast_write_data_pin( 4, val&1 ); |
|||
val >>= 1; |
|||
u8g_com_arduino_fast_write_data_pin( 5, val&1 ); |
|||
val >>= 1; |
|||
u8g_com_arduino_fast_write_data_pin( 6, val&1 ); |
|||
val >>= 1; |
|||
u8g_com_arduino_fast_write_data_pin( 7, val&1 ); |
|||
val >>= 1; |
|||
|
|||
/* EN cycle time must be 1 micro second */ |
|||
u8g_com_arduino_digital_write(u8g, U8G_PI_EN, HIGH); |
|||
u8g_MicroDelay(); /* delay by 1000ns, reference: ST7920: 140ns, SBN1661: 100ns */ |
|||
u8g_com_arduino_digital_write(u8g, U8G_PI_EN, LOW); |
|||
u8g_10MicroDelay(); /* ST7920 commands: 72us */ |
|||
u8g_10MicroDelay(); /* ST7920 commands: 72us */ |
|||
} |
|||
|
|||
|
|||
uint8_t u8g_com_arduino_fast_parallel_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_ptr) |
|||
{ |
|||
switch(msg) |
|||
{ |
|||
case U8G_COM_MSG_INIT: |
|||
u8g_com_arduino_fast_parallel_init(u8g); |
|||
/* setup the RW pin as output and force it to low */ |
|||
if ( u8g->pin_list[U8G_PI_RW] != U8G_PIN_NONE ) |
|||
{ |
|||
pinMode(u8g->pin_list[U8G_PI_RW], OUTPUT); |
|||
u8g_com_arduino_digital_write(u8g, U8G_PI_RW, LOW); |
|||
} |
|||
/* set all pins (except RW pin) */ |
|||
u8g_com_arduino_assign_pin_output_high(u8g); |
|||
break; |
|||
case U8G_COM_MSG_STOP: |
|||
break; |
|||
|
|||
case U8G_COM_MSG_CHIP_SELECT: |
|||
if ( arg_val == 0 ) |
|||
{ |
|||
/* disable */ |
|||
u8g_com_arduino_digital_write(u8g, U8G_PI_CS1, HIGH); |
|||
u8g_com_arduino_digital_write(u8g, U8G_PI_CS2, HIGH); |
|||
} |
|||
else if ( arg_val == 1 ) |
|||
{ |
|||
/* enable */ |
|||
u8g_com_arduino_digital_write(u8g, U8G_PI_CS1, LOW); |
|||
u8g_com_arduino_digital_write(u8g, U8G_PI_CS2, HIGH); |
|||
} |
|||
else if ( arg_val == 2 ) |
|||
{ |
|||
/* enable */ |
|||
u8g_com_arduino_digital_write(u8g, U8G_PI_CS1, HIGH); |
|||
u8g_com_arduino_digital_write(u8g, U8G_PI_CS2, LOW); |
|||
} |
|||
else |
|||
{ |
|||
/* enable */ |
|||
u8g_com_arduino_digital_write(u8g, U8G_PI_CS1, LOW); |
|||
u8g_com_arduino_digital_write(u8g, U8G_PI_CS2, LOW); |
|||
} |
|||
break; |
|||
case U8G_COM_MSG_WRITE_BYTE: |
|||
u8g_com_arduino_fast_parallel_write(u8g, arg_val); |
|||
break; |
|||
case U8G_COM_MSG_WRITE_SEQ: |
|||
{ |
|||
register uint8_t *ptr = arg_ptr; |
|||
while( arg_val > 0 ) |
|||
{ |
|||
u8g_com_arduino_fast_parallel_write(u8g, *ptr++); |
|||
arg_val--; |
|||
} |
|||
} |
|||
break; |
|||
case U8G_COM_MSG_WRITE_SEQ_P: |
|||
{ |
|||
register uint8_t *ptr = arg_ptr; |
|||
while( arg_val > 0 ) |
|||
{ |
|||
u8g_com_arduino_fast_parallel_write(u8g, u8g_pgm_read(ptr)); |
|||
ptr++; |
|||
arg_val--; |
|||
} |
|||
} |
|||
break; |
|||
case U8G_COM_MSG_ADDRESS: /* define cmd (arg_val = 0) or data mode (arg_val = 1) */ |
|||
u8g_com_arduino_digital_write(u8g, U8G_PI_DI, arg_val); |
|||
break; |
|||
case U8G_COM_MSG_RESET: |
|||
if ( u8g->pin_list[U8G_PI_RESET] != U8G_PIN_NONE ) |
|||
u8g_com_arduino_digital_write(u8g, U8G_PI_RESET, arg_val); |
|||
break; |
|||
|
|||
} |
|||
return 1; |
|||
} |
|||
|
|||
#else |
|||
|
|||
|
|||
uint8_t u8g_com_arduino_fast_parallel_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_ptr) |
|||
{ |
|||
return 1; |
|||
} |
|||
|
|||
|
|||
#endif /* ARDUINO */ |
|||
|
|||
@ -0,0 +1,191 @@ |
|||
/*
|
|||
|
|||
u8g_com_arduino_hw_spi.c |
|||
|
|||
Universal 8bit Graphics Library |
|||
|
|||
Copyright (c) 2011, olikraus@gmail.com |
|||
All rights reserved. |
|||
|
|||
Redistribution and use in source and binary forms, with or without modification, |
|||
are permitted provided that the following conditions are met: |
|||
|
|||
* Redistributions of source code must retain the above copyright notice, this list |
|||
of conditions and the following disclaimer. |
|||
|
|||
* Redistributions in binary form must reproduce the above copyright notice, this |
|||
list of conditions and the following disclaimer in the documentation and/or other |
|||
materials provided with the distribution. |
|||
|
|||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
|||
CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
|||
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
|||
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
|||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
|||
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
|||
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
|||
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
|||
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
|||
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF |
|||
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|||
|
|||
|
|||
*/ |
|||
|
|||
#include "u8g.h" |
|||
|
|||
#if defined(ARDUINO) |
|||
|
|||
#if defined(__AVR__) |
|||
|
|||
#include <avr/interrupt.h> |
|||
#include <avr/io.h> |
|||
|
|||
#if ARDUINO < 100 |
|||
#include <WProgram.h> |
|||
|
|||
/* fixed pins */ |
|||
#if defined(__AVR_ATmega644P__) || defined(__AVR_ATmega1284P__) // Sanguino.cc board
|
|||
#define PIN_SCK 7 |
|||
#define PIN_MISO 6 |
|||
#define PIN_MOSI 5 |
|||
#define PIN_CS 4 |
|||
#else // Arduino Board
|
|||
#define PIN_SCK 13 |
|||
#define PIN_MISO 12 |
|||
#define PIN_MOSI 11 |
|||
#define PIN_CS 10 |
|||
#endif // (__AVR_ATmega644P__) || defined(__AVR_ATmega1284P__)
|
|||
|
|||
#else |
|||
|
|||
#include <Arduino.h> |
|||
|
|||
/* use Arduino pin definitions */ |
|||
#define PIN_SCK SCK |
|||
#define PIN_MISO MISO |
|||
#define PIN_MOSI MOSI |
|||
#define PIN_CS SS |
|||
|
|||
#endif |
|||
|
|||
|
|||
|
|||
//static uint8_t u8g_spi_out(uint8_t data) U8G_NOINLINE;
|
|||
static uint8_t u8g_spi_out(uint8_t data) |
|||
{ |
|||
/* unsigned char x = 100; */ |
|||
/* send data */ |
|||
SPDR = data; |
|||
/* wait for transmission */ |
|||
while (!(SPSR & (1<<SPIF))) |
|||
; |
|||
/* clear the SPIF flag by reading SPDR */ |
|||
return SPDR; |
|||
} |
|||
|
|||
|
|||
uint8_t u8g_com_arduino_hw_spi_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_ptr) |
|||
{ |
|||
switch(msg) |
|||
{ |
|||
case U8G_COM_MSG_STOP: |
|||
break; |
|||
|
|||
case U8G_COM_MSG_INIT: |
|||
u8g_com_arduino_assign_pin_output_high(u8g); |
|||
pinMode(PIN_SCK, OUTPUT); |
|||
digitalWrite(PIN_SCK, LOW); |
|||
pinMode(PIN_MOSI, OUTPUT); |
|||
digitalWrite(PIN_MOSI, LOW); |
|||
/* pinMode(PIN_MISO, INPUT); */ |
|||
|
|||
pinMode(PIN_CS, OUTPUT); /* system chip select for the atmega board */ |
|||
digitalWrite(PIN_CS, HIGH); |
|||
|
|||
|
|||
|
|||
/*
|
|||
SPR1 SPR0 |
|||
0 0 fclk/4 |
|||
0 1 fclk/16 |
|||
1 0 fclk/64 |
|||
1 1 fclk/128 |
|||
*/ |
|||
SPCR = 0; |
|||
SPCR = (1<<SPE) | (1<<MSTR)|(0<<SPR1)|(1<<SPR0)|(0<<CPOL)|(0<<CPHA); |
|||
#ifdef U8G_HW_SPI_2X |
|||
SPSR = (1 << SPI2X); /* double speed, issue 89 */ |
|||
#endif |
|||
|
|||
break; |
|||
|
|||
case U8G_COM_MSG_ADDRESS: /* define cmd (arg_val = 0) or data mode (arg_val = 1) */ |
|||
u8g_com_arduino_digital_write(u8g, U8G_PI_A0, arg_val); |
|||
break; |
|||
|
|||
case U8G_COM_MSG_CHIP_SELECT: |
|||
if ( arg_val == 0 ) |
|||
{ |
|||
/* disable */ |
|||
u8g_com_arduino_digital_write(u8g, U8G_PI_CS, HIGH); |
|||
} |
|||
else |
|||
{ |
|||
/* enable */ |
|||
u8g_com_arduino_digital_write(u8g, U8G_PI_SCK, LOW); |
|||
u8g_com_arduino_digital_write(u8g, U8G_PI_CS, LOW); |
|||
} |
|||
break; |
|||
|
|||
case U8G_COM_MSG_RESET: |
|||
if ( u8g->pin_list[U8G_PI_RESET] != U8G_PIN_NONE ) |
|||
u8g_com_arduino_digital_write(u8g, U8G_PI_RESET, arg_val); |
|||
break; |
|||
|
|||
case U8G_COM_MSG_WRITE_BYTE: |
|||
u8g_spi_out(arg_val); |
|||
break; |
|||
|
|||
case U8G_COM_MSG_WRITE_SEQ: |
|||
{ |
|||
register uint8_t *ptr = arg_ptr; |
|||
while( arg_val > 0 ) |
|||
{ |
|||
u8g_spi_out(*ptr++); |
|||
arg_val--; |
|||
} |
|||
} |
|||
break; |
|||
case U8G_COM_MSG_WRITE_SEQ_P: |
|||
{ |
|||
register uint8_t *ptr = arg_ptr; |
|||
while( arg_val > 0 ) |
|||
{ |
|||
u8g_spi_out(u8g_pgm_read(ptr)); |
|||
ptr++; |
|||
arg_val--; |
|||
} |
|||
} |
|||
break; |
|||
} |
|||
return 1; |
|||
} |
|||
|
|||
/* #elif defined(__18CXX) || defined(__PIC32MX) */ |
|||
|
|||
#else /* __AVR__ */ |
|||
|
|||
#endif /* __AVR__ */ |
|||
|
|||
#else /* ARDUINO */ |
|||
|
|||
uint8_t u8g_com_arduino_hw_spi_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_ptr) |
|||
{ |
|||
return 1; |
|||
} |
|||
|
|||
#endif /* ARDUINO */ |
|||
|
|||
@ -0,0 +1,221 @@ |
|||
/*
|
|||
|
|||
u8g_arduino_no_en_parallel.c |
|||
|
|||
Universal 8bit Graphics Library |
|||
|
|||
Copyright (c) 2012, olikraus@gmail.com |
|||
All rights reserved. |
|||
|
|||
Redistribution and use in source and binary forms, with or without modification, |
|||
are permitted provided that the following conditions are met: |
|||
|
|||
* Redistributions of source code must retain the above copyright notice, this list |
|||
of conditions and the following disclaimer. |
|||
|
|||
* Redistributions in binary form must reproduce the above copyright notice, this |
|||
list of conditions and the following disclaimer in the documentation and/or other |
|||
materials provided with the distribution. |
|||
|
|||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
|||
CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
|||
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
|||
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
|||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
|||
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
|||
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
|||
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
|||
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
|||
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF |
|||
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|||
|
|||
PIN_D0 8 |
|||
PIN_D1 9 |
|||
PIN_D2 10 |
|||
PIN_D3 11 |
|||
PIN_D4 4 |
|||
PIN_D5 5 |
|||
PIN_D6 6 |
|||
PIN_D7 7 |
|||
|
|||
PIN_CS1 14 |
|||
PIN_CS2 15 |
|||
PIN_RW 16 |
|||
PIN_DI 17 |
|||
PIN_EN 18 |
|||
|
|||
u8g_Init8Bit(u8g, dev, d0, d1, d2, d3, d4, d5, d6, d7, en, cs1, cs2, di, rw, reset) |
|||
u8g_Init8Bit(u8g, dev, 8, 9, 10, 11, 4, 5, 6, 7, 18, 14, 15, 17, 16, U8G_PIN_NONE) |
|||
|
|||
*/ |
|||
|
|||
#include "u8g.h" |
|||
|
|||
#if defined(ARDUINO) |
|||
|
|||
#if ARDUINO < 100 |
|||
//#include <WProgram.h>
|
|||
#include <wiring_private.h> |
|||
#include <pins_arduino.h> |
|||
#else |
|||
#include <Arduino.h> |
|||
#endif |
|||
|
|||
//#define PIN_RESET
|
|||
|
|||
#if defined(__PIC32MX) |
|||
/* CHIPKIT PIC32 */ |
|||
static volatile uint32_t *u8g_data_port[8]; |
|||
static uint32_t u8g_data_mask[8]; |
|||
#else |
|||
static volatile uint8_t *u8g_data_port[8]; |
|||
static uint8_t u8g_data_mask[8]; |
|||
#endif |
|||
|
|||
|
|||
|
|||
static void u8g_com_arduino_no_en_parallel_init(u8g_t *u8g) |
|||
{ |
|||
u8g_data_port[0] = portOutputRegister(digitalPinToPort(u8g->pin_list[U8G_PI_D0])); |
|||
u8g_data_mask[0] = digitalPinToBitMask(u8g->pin_list[U8G_PI_D0]); |
|||
u8g_data_port[1] = portOutputRegister(digitalPinToPort(u8g->pin_list[U8G_PI_D1])); |
|||
u8g_data_mask[1] = digitalPinToBitMask(u8g->pin_list[U8G_PI_D1]); |
|||
u8g_data_port[2] = portOutputRegister(digitalPinToPort(u8g->pin_list[U8G_PI_D2])); |
|||
u8g_data_mask[2] = digitalPinToBitMask(u8g->pin_list[U8G_PI_D2]); |
|||
u8g_data_port[3] = portOutputRegister(digitalPinToPort(u8g->pin_list[U8G_PI_D3])); |
|||
u8g_data_mask[3] = digitalPinToBitMask(u8g->pin_list[U8G_PI_D3]); |
|||
|
|||
u8g_data_port[4] = portOutputRegister(digitalPinToPort(u8g->pin_list[U8G_PI_D4])); |
|||
u8g_data_mask[4] = digitalPinToBitMask(u8g->pin_list[U8G_PI_D4]); |
|||
u8g_data_port[5] = portOutputRegister(digitalPinToPort(u8g->pin_list[U8G_PI_D5])); |
|||
u8g_data_mask[5] = digitalPinToBitMask(u8g->pin_list[U8G_PI_D5]); |
|||
u8g_data_port[6] = portOutputRegister(digitalPinToPort(u8g->pin_list[U8G_PI_D6])); |
|||
u8g_data_mask[6] = digitalPinToBitMask(u8g->pin_list[U8G_PI_D6]); |
|||
u8g_data_port[7] = portOutputRegister(digitalPinToPort(u8g->pin_list[U8G_PI_D7])); |
|||
u8g_data_mask[7] = digitalPinToBitMask(u8g->pin_list[U8G_PI_D7]); |
|||
} |
|||
|
|||
void u8g_com_arduino_no_en_write_data_pin(uint8_t pin, uint8_t val) |
|||
{ |
|||
if ( val != 0 ) |
|||
*u8g_data_port[pin] |= u8g_data_mask[pin]; |
|||
else |
|||
*u8g_data_port[pin] &= ~u8g_data_mask[pin]; |
|||
} |
|||
|
|||
|
|||
void u8g_com_arduino_no_en_parallel_write(u8g_t *u8g, uint8_t val) |
|||
{ |
|||
u8g_com_arduino_no_en_write_data_pin( 0, val&1 ); |
|||
val >>= 1; |
|||
u8g_com_arduino_no_en_write_data_pin( 1, val&1 ); |
|||
val >>= 1; |
|||
u8g_com_arduino_no_en_write_data_pin( 2, val&1 ); |
|||
val >>= 1; |
|||
u8g_com_arduino_no_en_write_data_pin( 3, val&1 ); |
|||
val >>= 1; |
|||
|
|||
u8g_com_arduino_no_en_write_data_pin( 4, val&1 ); |
|||
val >>= 1; |
|||
u8g_com_arduino_no_en_write_data_pin( 5, val&1 ); |
|||
val >>= 1; |
|||
u8g_com_arduino_no_en_write_data_pin( 6, val&1 ); |
|||
val >>= 1; |
|||
u8g_com_arduino_no_en_write_data_pin( 7, val&1 ); |
|||
val >>= 1; |
|||
|
|||
/* EN cycle time must be 1 micro second, digitalWrite is slow enough to do this */ |
|||
if ( u8g->pin_list[U8G_PI_CS_STATE] == 1 ) |
|||
{ |
|||
u8g_MicroDelay(); |
|||
u8g_com_arduino_digital_write(u8g, U8G_PI_CS1, HIGH); |
|||
u8g_MicroDelay(); |
|||
u8g_com_arduino_digital_write(u8g, U8G_PI_CS1, LOW); |
|||
u8g_MicroDelay(); |
|||
} |
|||
else if ( u8g->pin_list[U8G_PI_CS_STATE] == 2 ) |
|||
{ |
|||
u8g_MicroDelay(); |
|||
u8g_com_arduino_digital_write(u8g, U8G_PI_CS2, HIGH); |
|||
u8g_MicroDelay(); |
|||
u8g_com_arduino_digital_write(u8g, U8G_PI_CS2, LOW); |
|||
u8g_MicroDelay(); |
|||
} |
|||
} |
|||
|
|||
|
|||
uint8_t u8g_com_arduino_no_en_parallel_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_ptr) |
|||
{ |
|||
switch(msg) |
|||
{ |
|||
case U8G_COM_MSG_INIT: |
|||
u8g_com_arduino_no_en_parallel_init(u8g); |
|||
/* setup the RW pin as output and force it to low */ |
|||
if ( u8g->pin_list[U8G_PI_RW] != U8G_PIN_NONE ) |
|||
{ |
|||
pinMode(u8g->pin_list[U8G_PI_RW], OUTPUT); |
|||
u8g_com_arduino_digital_write(u8g, U8G_PI_RW, LOW); |
|||
} |
|||
/* set all pins (except RW pin) */ |
|||
u8g_com_arduino_assign_pin_output_high(u8g); |
|||
break; |
|||
case U8G_COM_MSG_STOP: |
|||
break; |
|||
|
|||
case U8G_COM_MSG_CHIP_SELECT: |
|||
/*
|
|||
0: nothing selected |
|||
1: CS1 will be used as enable line |
|||
2: CS2 will be used as enable line |
|||
this will be used in the u8g_com_arduino_no_en_parallel_write() procedure |
|||
*/ |
|||
u8g->pin_list[U8G_PI_CS_STATE] = arg_val; |
|||
break; |
|||
case U8G_COM_MSG_WRITE_BYTE: |
|||
u8g_com_arduino_no_en_parallel_write(u8g, arg_val); |
|||
break; |
|||
case U8G_COM_MSG_WRITE_SEQ: |
|||
{ |
|||
register uint8_t *ptr = arg_ptr; |
|||
while( arg_val > 0 ) |
|||
{ |
|||
u8g_com_arduino_no_en_parallel_write(u8g, *ptr++); |
|||
arg_val--; |
|||
} |
|||
} |
|||
break; |
|||
case U8G_COM_MSG_WRITE_SEQ_P: |
|||
{ |
|||
register uint8_t *ptr = arg_ptr; |
|||
while( arg_val > 0 ) |
|||
{ |
|||
u8g_com_arduino_no_en_parallel_write(u8g, u8g_pgm_read(ptr)); |
|||
ptr++; |
|||
arg_val--; |
|||
} |
|||
} |
|||
break; |
|||
case U8G_COM_MSG_ADDRESS: /* define cmd (arg_val = 0) or data mode (arg_val = 1) */ |
|||
u8g_com_arduino_digital_write(u8g, U8G_PI_DI, arg_val); |
|||
break; |
|||
case U8G_COM_MSG_RESET: |
|||
if ( u8g->pin_list[U8G_PI_RESET] != U8G_PIN_NONE ) |
|||
u8g_com_arduino_digital_write(u8g, U8G_PI_RESET, arg_val); |
|||
break; |
|||
} |
|||
return 1; |
|||
} |
|||
|
|||
#else |
|||
|
|||
|
|||
uint8_t u8g_com_arduino_no_en_parallel_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_ptr) |
|||
{ |
|||
return 1; |
|||
} |
|||
|
|||
|
|||
#endif /* ARDUINO */ |
|||
|
|||
@ -0,0 +1,187 @@ |
|||
/*
|
|||
|
|||
u8g_arduino_parallel.c |
|||
|
|||
Universal 8bit Graphics Library |
|||
|
|||
Copyright (c) 2011, olikraus@gmail.com |
|||
All rights reserved. |
|||
|
|||
Redistribution and use in source and binary forms, with or without modification, |
|||
are permitted provided that the following conditions are met: |
|||
|
|||
* Redistributions of source code must retain the above copyright notice, this list |
|||
of conditions and the following disclaimer. |
|||
|
|||
* Redistributions in binary form must reproduce the above copyright notice, this |
|||
list of conditions and the following disclaimer in the documentation and/or other |
|||
materials provided with the distribution. |
|||
|
|||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
|||
CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
|||
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
|||
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
|||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
|||
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
|||
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
|||
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
|||
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
|||
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF |
|||
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|||
|
|||
|
|||
PIN_D0 8 |
|||
PIN_D1 9 |
|||
PIN_D2 10 |
|||
PIN_D3 11 |
|||
PIN_D4 4 |
|||
PIN_D5 5 |
|||
PIN_D6 6 |
|||
PIN_D7 7 |
|||
|
|||
PIN_CS1 14 |
|||
PIN_CS2 15 |
|||
PIN_RW 16 |
|||
PIN_DI 17 |
|||
PIN_EN 18 |
|||
|
|||
u8g_Init8Bit(u8g, dev, d0, d1, d2, d3, d4, d5, d6, d7, en, cs1, cs2, di, rw, reset) |
|||
u8g_Init8Bit(u8g, dev, 8, 9, 10, 11, 4, 5, 6, 7, 18, 14, 15, 17, 16, U8G_PIN_NONE) |
|||
|
|||
*/ |
|||
|
|||
#include "u8g.h" |
|||
|
|||
|
|||
#if defined(ARDUINO) |
|||
|
|||
#if ARDUINO < 100 |
|||
#include <WProgram.h> |
|||
#else |
|||
#include <Arduino.h> |
|||
#endif |
|||
|
|||
|
|||
|
|||
|
|||
|
|||
|
|||
void u8g_com_arduino_parallel_write(u8g_t *u8g, uint8_t val) |
|||
{ |
|||
u8g_com_arduino_digital_write(u8g, U8G_PI_D0, val&1); |
|||
val >>= 1; |
|||
u8g_com_arduino_digital_write(u8g, U8G_PI_D1, val&1); |
|||
val >>= 1; |
|||
u8g_com_arduino_digital_write(u8g, U8G_PI_D2, val&1); |
|||
val >>= 1; |
|||
u8g_com_arduino_digital_write(u8g, U8G_PI_D3, val&1); |
|||
val >>= 1; |
|||
u8g_com_arduino_digital_write(u8g, U8G_PI_D4, val&1); |
|||
val >>= 1; |
|||
u8g_com_arduino_digital_write(u8g, U8G_PI_D5, val&1); |
|||
val >>= 1; |
|||
u8g_com_arduino_digital_write(u8g, U8G_PI_D6, val&1); |
|||
val >>= 1; |
|||
u8g_com_arduino_digital_write(u8g, U8G_PI_D7, val&1); |
|||
|
|||
/* EN cycle time must be 1 micro second, digitalWrite is slow enough to do this */ |
|||
//u8g_Delay(1);
|
|||
u8g_com_arduino_digital_write(u8g, U8G_PI_EN, HIGH); |
|||
//u8g_Delay(1);
|
|||
u8g_MicroDelay(); /* delay by 1000ns, reference: ST7920: 140ns, SBN1661: 100ns */ |
|||
u8g_com_arduino_digital_write(u8g, U8G_PI_EN, LOW); |
|||
u8g_10MicroDelay(); /* ST7920 commands: 72us */ |
|||
//u8g_Delay(2);
|
|||
} |
|||
|
|||
|
|||
uint8_t u8g_com_arduino_parallel_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_ptr) |
|||
{ |
|||
switch(msg) |
|||
{ |
|||
case U8G_COM_MSG_INIT: |
|||
/* setup the RW pin as output and force it to low */ |
|||
if ( u8g->pin_list[U8G_PI_RW] != U8G_PIN_NONE ) |
|||
{ |
|||
pinMode(u8g->pin_list[U8G_PI_RW], OUTPUT); |
|||
u8g_com_arduino_digital_write(u8g, U8G_PI_RW, LOW); |
|||
} |
|||
/* set all pins (except RW pin) */ |
|||
u8g_com_arduino_assign_pin_output_high(u8g); |
|||
break; |
|||
case U8G_COM_MSG_STOP: |
|||
break; |
|||
case U8G_COM_MSG_CHIP_SELECT: |
|||
if ( arg_val == 0 ) |
|||
{ |
|||
/* disable */ |
|||
u8g_com_arduino_digital_write(u8g, U8G_PI_CS1, HIGH); |
|||
u8g_com_arduino_digital_write(u8g, U8G_PI_CS2, HIGH); |
|||
} |
|||
else if ( arg_val == 1 ) |
|||
{ |
|||
/* enable */ |
|||
u8g_com_arduino_digital_write(u8g, U8G_PI_CS1, LOW); |
|||
u8g_com_arduino_digital_write(u8g, U8G_PI_CS2, HIGH); |
|||
} |
|||
else if ( arg_val == 2 ) |
|||
{ |
|||
/* enable */ |
|||
u8g_com_arduino_digital_write(u8g, U8G_PI_CS1, HIGH); |
|||
u8g_com_arduino_digital_write(u8g, U8G_PI_CS2, LOW); |
|||
} |
|||
else |
|||
{ |
|||
/* enable */ |
|||
u8g_com_arduino_digital_write(u8g, U8G_PI_CS1, LOW); |
|||
u8g_com_arduino_digital_write(u8g, U8G_PI_CS2, LOW); |
|||
} |
|||
break; |
|||
case U8G_COM_MSG_WRITE_BYTE: |
|||
u8g_com_arduino_parallel_write(u8g, arg_val); |
|||
break; |
|||
case U8G_COM_MSG_WRITE_SEQ: |
|||
{ |
|||
register uint8_t *ptr = arg_ptr; |
|||
while( arg_val > 0 ) |
|||
{ |
|||
u8g_com_arduino_parallel_write(u8g, *ptr++); |
|||
arg_val--; |
|||
} |
|||
} |
|||
break; |
|||
case U8G_COM_MSG_WRITE_SEQ_P: |
|||
{ |
|||
register uint8_t *ptr = arg_ptr; |
|||
while( arg_val > 0 ) |
|||
{ |
|||
u8g_com_arduino_parallel_write(u8g, u8g_pgm_read(ptr)); |
|||
ptr++; |
|||
arg_val--; |
|||
} |
|||
} |
|||
break; |
|||
case U8G_COM_MSG_ADDRESS: /* define cmd (arg_val = 0) or data mode (arg_val = 1) */ |
|||
u8g_com_arduino_digital_write(u8g, U8G_PI_DI, arg_val); |
|||
break; |
|||
case U8G_COM_MSG_RESET: |
|||
if ( u8g->pin_list[U8G_PI_RESET] != U8G_PIN_NONE ) |
|||
u8g_com_arduino_digital_write(u8g, U8G_PI_RESET, arg_val); |
|||
break; |
|||
|
|||
} |
|||
return 1; |
|||
} |
|||
|
|||
#else |
|||
|
|||
|
|||
uint8_t u8g_com_arduino_parallel_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_ptr) |
|||
{ |
|||
return 1; |
|||
} |
|||
|
|||
#endif /* ARDUINO */ |
|||
|
|||
@ -0,0 +1,168 @@ |
|||
/*
|
|||
|
|||
u8g_arduino_port_d_wr.c |
|||
|
|||
Universal 8bit Graphics Library |
|||
|
|||
Copyright (c) 2011, olikraus@gmail.com |
|||
All rights reserved. |
|||
|
|||
Redistribution and use in source and binary forms, with or without modification, |
|||
are permitted provided that the following conditions are met: |
|||
|
|||
* Redistributions of source code must retain the above copyright notice, this list |
|||
of conditions and the following disclaimer. |
|||
|
|||
* Redistributions in binary form must reproduce the above copyright notice, this |
|||
list of conditions and the following disclaimer in the documentation and/or other |
|||
materials provided with the distribution. |
|||
|
|||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
|||
CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
|||
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
|||
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
|||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
|||
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
|||
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
|||
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
|||
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
|||
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF |
|||
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|||
|
|||
|
|||
Assumes PORTD for 8 bit data transfer. |
|||
EN is assumed to be a low active write signal (WR) |
|||
|
|||
ILI9325D_320x240 from iteadstudio.com |
|||
RS=19, WR=18, CS=17, RST=16 |
|||
|
|||
|
|||
u8g_Init8Bit(u8g, dev, d0, d1, d2, d3, d4, d5, d6, d7, en, cs1, cs2, di, rw, reset) |
|||
u8g_Init8Bit(u8g, dev, 8, 9, 10, 11, 4, 5, 6, 7, 18, 14, 15, 17, 16, U8G_PIN_NONE) |
|||
|
|||
*/ |
|||
|
|||
#include "u8g.h" |
|||
|
|||
|
|||
#if defined(ARDUINO) && defined(PORTD) |
|||
|
|||
#if ARDUINO < 100 |
|||
#include <WProgram.h> |
|||
#else |
|||
#include <Arduino.h> |
|||
#endif |
|||
|
|||
|
|||
|
|||
|
|||
|
|||
|
|||
static void u8g_com_arduino_port_d_8bit_wr(u8g_t *u8g, uint8_t val) |
|||
{ |
|||
PORTD = val; |
|||
|
|||
/* WR cycle time must be 1 micro second, digitalWrite is slow enough to do this */ |
|||
u8g_com_arduino_digital_write(u8g, U8G_PI_EN, LOW); |
|||
u8g_com_arduino_digital_write(u8g, U8G_PI_EN, HIGH); |
|||
} |
|||
|
|||
|
|||
uint8_t u8g_com_arduino_port_d_wr_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_ptr) |
|||
{ |
|||
|
|||
switch(msg) |
|||
{ |
|||
case U8G_COM_MSG_INIT: |
|||
|
|||
#ifdef UCSR0B |
|||
UCSR0B = 0; // disable USART 0
|
|||
#endif |
|||
DDRD = 0x0ff; |
|||
PORTD = 0x0ff; |
|||
|
|||
/* setup the RW pin as output and force it to low */ |
|||
if ( u8g->pin_list[U8G_PI_RW] != U8G_PIN_NONE ) |
|||
{ |
|||
pinMode(u8g->pin_list[U8G_PI_RW], OUTPUT); |
|||
u8g_com_arduino_digital_write(u8g, U8G_PI_RW, HIGH); |
|||
} |
|||
/* set all pins (except RW pin) */ |
|||
u8g_com_arduino_assign_pin_output_high(u8g); |
|||
u8g_com_arduino_digital_write(u8g, U8G_PI_EN, HIGH); |
|||
break; |
|||
case U8G_COM_MSG_STOP: |
|||
break; |
|||
case U8G_COM_MSG_CHIP_SELECT: |
|||
if ( arg_val == 0 ) |
|||
{ |
|||
/* disable */ |
|||
u8g_com_arduino_digital_write(u8g, U8G_PI_CS1, HIGH); |
|||
u8g_com_arduino_digital_write(u8g, U8G_PI_CS2, HIGH); |
|||
} |
|||
else if ( arg_val == 1 ) |
|||
{ |
|||
/* enable */ |
|||
u8g_com_arduino_digital_write(u8g, U8G_PI_CS1, LOW); |
|||
u8g_com_arduino_digital_write(u8g, U8G_PI_CS2, HIGH); |
|||
} |
|||
else if ( arg_val == 2 ) |
|||
{ |
|||
/* enable */ |
|||
u8g_com_arduino_digital_write(u8g, U8G_PI_CS1, HIGH); |
|||
u8g_com_arduino_digital_write(u8g, U8G_PI_CS2, LOW); |
|||
} |
|||
else |
|||
{ |
|||
/* enable */ |
|||
u8g_com_arduino_digital_write(u8g, U8G_PI_CS1, LOW); |
|||
u8g_com_arduino_digital_write(u8g, U8G_PI_CS2, LOW); |
|||
} |
|||
break; |
|||
case U8G_COM_MSG_WRITE_BYTE: |
|||
u8g_com_arduino_port_d_8bit_wr(u8g, arg_val); |
|||
break; |
|||
case U8G_COM_MSG_WRITE_SEQ: |
|||
{ |
|||
register uint8_t *ptr = arg_ptr; |
|||
while( arg_val > 0 ) |
|||
{ |
|||
u8g_com_arduino_port_d_8bit_wr(u8g, *ptr++); |
|||
arg_val--; |
|||
} |
|||
} |
|||
break; |
|||
case U8G_COM_MSG_WRITE_SEQ_P: |
|||
{ |
|||
register uint8_t *ptr = arg_ptr; |
|||
while( arg_val > 0 ) |
|||
{ |
|||
u8g_com_arduino_port_d_8bit_wr(u8g, u8g_pgm_read(ptr)); |
|||
ptr++; |
|||
arg_val--; |
|||
} |
|||
} |
|||
break; |
|||
case U8G_COM_MSG_ADDRESS: /* define cmd (arg_val = 0) or data mode (arg_val = 1) */ |
|||
u8g_com_arduino_digital_write(u8g, U8G_PI_DI, arg_val); |
|||
break; |
|||
case U8G_COM_MSG_RESET: |
|||
if ( u8g->pin_list[U8G_PI_RESET] != U8G_PIN_NONE ) |
|||
u8g_com_arduino_digital_write(u8g, U8G_PI_RESET, arg_val); |
|||
break; |
|||
} |
|||
return 1; |
|||
} |
|||
|
|||
#else |
|||
|
|||
|
|||
uint8_t u8g_com_arduino_port_d_wr_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_ptr) |
|||
{ |
|||
return 1; |
|||
} |
|||
|
|||
#endif /* ARDUINO && PORTD */ |
|||
|
|||
@ -0,0 +1,201 @@ |
|||
/*
|
|||
|
|||
u8g_com_arduino_ssd_i2c.c |
|||
|
|||
com interface for arduino (AND atmega) and the SSDxxxx chip (SOLOMON) variant |
|||
I2C protocol |
|||
|
|||
ToDo: Rename this to u8g_com_avr_ssd_i2c.c |
|||
|
|||
Universal 8bit Graphics Library |
|||
|
|||
Copyright (c) 2012, olikraus@gmail.com |
|||
All rights reserved. |
|||
|
|||
Redistribution and use in source and binary forms, with or without modification, |
|||
are permitted provided that the following conditions are met: |
|||
|
|||
* Redistributions of source code must retain the above copyright notice, this list |
|||
of conditions and the following disclaimer. |
|||
|
|||
* Redistributions in binary form must reproduce the above copyright notice, this |
|||
list of conditions and the following disclaimer in the documentation and/or other |
|||
materials provided with the distribution. |
|||
|
|||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
|||
CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
|||
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
|||
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
|||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
|||
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
|||
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
|||
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
|||
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
|||
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF |
|||
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|||
|
|||
Special pin usage: |
|||
U8G_PI_I2C_OPTION additional options |
|||
U8G_PI_A0_STATE used to store the last value of the command/data register selection |
|||
U8G_PI_SET_A0 1: Signal request to update I2C device with new A0_STATE, 0: Do nothing, A0_STATE matches I2C device |
|||
U8G_PI_SCL clock line (NOT USED) |
|||
U8G_PI_SDA data line (NOT USED) |
|||
|
|||
U8G_PI_RESET reset line (currently disabled, see below) |
|||
|
|||
Protocol: |
|||
SLA, Cmd/Data Selection, Arguments |
|||
The command/data register is selected by a special instruction byte, which is sent after SLA |
|||
|
|||
The continue bit is always 0 so that a (re)start is equired for the change from cmd to/data mode |
|||
*/ |
|||
|
|||
#include "u8g.h" |
|||
|
|||
#define I2C_SLA (0x3c*2) |
|||
//#define I2C_CMD_MODE 0x080
|
|||
#define I2C_CMD_MODE 0x000 |
|||
#define I2C_DATA_MODE 0x040 |
|||
|
|||
|
|||
uint8_t u8g_com_arduino_ssd_start_sequence(u8g_t *u8g) |
|||
{ |
|||
/* are we requested to set the a0 state? */ |
|||
if ( u8g->pin_list[U8G_PI_SET_A0] == 0 ) |
|||
return 1; |
|||
|
|||
/* setup bus, might be a repeated start */ |
|||
if ( u8g_i2c_start(I2C_SLA) == 0 ) |
|||
return 0; |
|||
if ( u8g->pin_list[U8G_PI_A0_STATE] == 0 ) |
|||
{ |
|||
if ( u8g_i2c_send_byte(I2C_CMD_MODE) == 0 ) |
|||
return 0; |
|||
} |
|||
else |
|||
{ |
|||
if ( u8g_i2c_send_byte(I2C_DATA_MODE) == 0 ) |
|||
return 0; |
|||
} |
|||
|
|||
|
|||
u8g->pin_list[U8G_PI_SET_A0] = 0; |
|||
return 1; |
|||
} |
|||
|
|||
uint8_t u8g_com_arduino_ssd_i2c_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_ptr) |
|||
{ |
|||
switch(msg) |
|||
{ |
|||
case U8G_COM_MSG_INIT: |
|||
//u8g_com_arduino_digital_write(u8g, U8G_PI_SCL, HIGH);
|
|||
//u8g_com_arduino_digital_write(u8g, U8G_PI_SDA, HIGH);
|
|||
//u8g->pin_list[U8G_PI_A0_STATE] = 0; /* inital RS state: unknown mode */
|
|||
|
|||
u8g_i2c_init(u8g->pin_list[U8G_PI_I2C_OPTION]); |
|||
|
|||
break; |
|||
|
|||
case U8G_COM_MSG_STOP: |
|||
break; |
|||
|
|||
case U8G_COM_MSG_RESET: |
|||
/* Currently disabled, but it could be enable. Previous restrictions have been removed */ |
|||
/* u8g_com_arduino_digital_write(u8g, U8G_PI_RESET, arg_val); */ |
|||
break; |
|||
|
|||
case U8G_COM_MSG_CHIP_SELECT: |
|||
u8g->pin_list[U8G_PI_A0_STATE] = 0; |
|||
u8g->pin_list[U8G_PI_SET_A0] = 1; /* force a0 to set again, also forces start condition */ |
|||
if ( arg_val == 0 ) |
|||
{ |
|||
/* disable chip, send stop condition */ |
|||
u8g_i2c_stop(); |
|||
} |
|||
else |
|||
{ |
|||
/* enable, do nothing: any byte writing will trigger the i2c start */ |
|||
} |
|||
break; |
|||
|
|||
case U8G_COM_MSG_WRITE_BYTE: |
|||
//u8g->pin_list[U8G_PI_SET_A0] = 1;
|
|||
if ( u8g_com_arduino_ssd_start_sequence(u8g) == 0 ) |
|||
return u8g_i2c_stop(), 0; |
|||
if ( u8g_i2c_send_byte(arg_val) == 0 ) |
|||
return u8g_i2c_stop(), 0; |
|||
// u8g_i2c_stop();
|
|||
break; |
|||
|
|||
case U8G_COM_MSG_WRITE_SEQ: |
|||
//u8g->pin_list[U8G_PI_SET_A0] = 1;
|
|||
if ( u8g_com_arduino_ssd_start_sequence(u8g) == 0 ) |
|||
return u8g_i2c_stop(), 0; |
|||
{ |
|||
register uint8_t *ptr = arg_ptr; |
|||
while( arg_val > 0 ) |
|||
{ |
|||
if ( u8g_i2c_send_byte(*ptr++) == 0 ) |
|||
return u8g_i2c_stop(), 0; |
|||
arg_val--; |
|||
} |
|||
} |
|||
// u8g_i2c_stop();
|
|||
break; |
|||
|
|||
case U8G_COM_MSG_WRITE_SEQ_P: |
|||
//u8g->pin_list[U8G_PI_SET_A0] = 1;
|
|||
if ( u8g_com_arduino_ssd_start_sequence(u8g) == 0 ) |
|||
return u8g_i2c_stop(), 0; |
|||
{ |
|||
register uint8_t *ptr = arg_ptr; |
|||
while( arg_val > 0 ) |
|||
{ |
|||
if ( u8g_i2c_send_byte(u8g_pgm_read(ptr)) == 0 ) |
|||
return 0; |
|||
ptr++; |
|||
arg_val--; |
|||
} |
|||
} |
|||
// u8g_i2c_stop();
|
|||
break; |
|||
|
|||
case U8G_COM_MSG_ADDRESS: /* define cmd (arg_val = 0) or data mode (arg_val = 1) */ |
|||
u8g->pin_list[U8G_PI_A0_STATE] = arg_val; |
|||
u8g->pin_list[U8G_PI_SET_A0] = 1; /* force a0 to set again */ |
|||
|
|||
#ifdef OLD_CODE |
|||
if ( i2c_state != 0 ) |
|||
{ |
|||
u8g_i2c_stop(); |
|||
i2c_state = 0; |
|||
} |
|||
|
|||
if ( u8g_com_arduino_ssd_start_sequence(arg_val) == 0 ) |
|||
return 0; |
|||
|
|||
/* setup bus, might be a repeated start */ |
|||
/*
|
|||
if ( u8g_i2c_start(I2C_SLA) == 0 ) |
|||
return 0; |
|||
if ( arg_val == 0 ) |
|||
{ |
|||
i2c_state = 1; |
|||
|
|||
if ( u8g_i2c_send_byte(I2C_CMD_MODE) == 0 ) |
|||
return 0; |
|||
} |
|||
else |
|||
{ |
|||
i2c_state = 2; |
|||
if ( u8g_i2c_send_byte(I2C_DATA_MODE) == 0 ) |
|||
return 0; |
|||
} |
|||
*/ |
|||
#endif |
|||
break; |
|||
} |
|||
return 1; |
|||
} |
|||
@ -0,0 +1,220 @@ |
|||
/*
|
|||
|
|||
u8g_com_arduino_st7920_hw_spi.c |
|||
|
|||
Universal 8bit Graphics Library |
|||
|
|||
Copyright (c) 2011, olikraus@gmail.com |
|||
All rights reserved. |
|||
|
|||
Redistribution and use in source and binary forms, with or without modification, |
|||
are permitted provided that the following conditions are met: |
|||
|
|||
* Redistributions of source code must retain the above copyright notice, this list |
|||
of conditions and the following disclaimer. |
|||
|
|||
* Redistributions in binary form must reproduce the above copyright notice, this |
|||
list of conditions and the following disclaimer in the documentation and/or other |
|||
materials provided with the distribution. |
|||
|
|||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
|||
CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
|||
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
|||
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
|||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
|||
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
|||
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
|||
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
|||
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
|||
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF |
|||
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|||
|
|||
A special HW SPI interface for ST7920 controller |
|||
|
|||
*/ |
|||
|
|||
#include "u8g.h" |
|||
|
|||
#if defined(ARDUINO) |
|||
|
|||
#if ARDUINO < 100 |
|||
#include <WProgram.h> |
|||
#include "wiring_private.h" |
|||
#include "pins_arduino.h" |
|||
|
|||
#else |
|||
#include <Arduino.h> |
|||
#include "wiring_private.h" |
|||
#endif |
|||
|
|||
#if defined(__AVR__) |
|||
#define U8G_ARDUINO_ATMEGA_HW_SPI |
|||
|
|||
/* remove the definition for attiny */ |
|||
#if __AVR_ARCH__ == 2 |
|||
#undef U8G_ATMEGA_HW_SPI |
|||
#endif |
|||
#if __AVR_ARCH__ == 25 |
|||
#undef U8G_ATMEGA_HW_SPI |
|||
#endif |
|||
|
|||
#endif |
|||
|
|||
|
|||
#if defined(U8G_ARDUINO_ATMEGA_HW_SPI) |
|||
|
|||
#include <avr/interrupt.h> |
|||
#include <avr/io.h> |
|||
|
|||
static uint8_t u8g_arduino_st7920_hw_spi_shift_out(u8g_t *u8g, uint8_t val) U8G_NOINLINE; |
|||
static uint8_t u8g_arduino_st7920_hw_spi_shift_out(u8g_t *u8g, uint8_t val) |
|||
{ |
|||
/* send data */ |
|||
SPDR = val; |
|||
/* wait for transmission */ |
|||
while (!(SPSR & (1<<SPIF))) |
|||
; |
|||
/* clear the SPIF flag by reading SPDR */ |
|||
return SPDR; |
|||
} |
|||
|
|||
|
|||
static void u8g_com_arduino_st7920_write_byte_hw_spi(u8g_t *u8g, uint8_t rs, uint8_t val) U8G_NOINLINE; |
|||
static void u8g_com_arduino_st7920_write_byte_hw_spi(u8g_t *u8g, uint8_t rs, uint8_t val) |
|||
{ |
|||
uint8_t i; |
|||
|
|||
if ( rs == 0 ) |
|||
{ |
|||
/* command */ |
|||
u8g_arduino_st7920_hw_spi_shift_out(u8g, 0x0f8); |
|||
} |
|||
else if ( rs == 1 ) |
|||
{ |
|||
/* data */ |
|||
u8g_arduino_st7920_hw_spi_shift_out(u8g, 0x0fa); |
|||
} |
|||
else |
|||
{ |
|||
/* do nothing, keep same state */ |
|||
} |
|||
|
|||
u8g_arduino_st7920_hw_spi_shift_out(u8g, val & 0x0f0); |
|||
u8g_arduino_st7920_hw_spi_shift_out(u8g, val << 4); |
|||
|
|||
for( i = 0; i < 4; i++ ) |
|||
u8g_10MicroDelay(); |
|||
} |
|||
|
|||
|
|||
uint8_t u8g_com_arduino_st7920_hw_spi_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_ptr) |
|||
{ |
|||
switch(msg) |
|||
{ |
|||
case U8G_COM_MSG_INIT: |
|||
u8g_com_arduino_assign_pin_output_high(u8g); |
|||
u8g_com_arduino_digital_write(u8g, U8G_PI_CS, LOW); |
|||
|
|||
DDRB |= _BV(3); /* D0, MOSI */ |
|||
DDRB |= _BV(5); /* SCK */ |
|||
DDRB |= _BV(2); /* slave select */ |
|||
|
|||
PORTB &= ~_BV(3); /* D0, MOSI = 0 */ |
|||
PORTB &= ~_BV(5); /* SCK = 0 */ |
|||
|
|||
/*
|
|||
SPR1 SPR0 |
|||
0 0 fclk/4 |
|||
0 1 fclk/16 |
|||
1 0 fclk/64 |
|||
1 1 fclk/128 |
|||
*/ |
|||
SPCR = 0; |
|||
|
|||
/* 20 Dez 2012: set CPOL and CPHA to 1 !!! */ |
|||
SPCR = (1<<SPE) | (1<<MSTR)|(0<<SPR1)|(0<<SPR0)|(1<<CPOL)|(1<<CPHA); |
|||
#ifdef U8G_HW_SPI_2X |
|||
SPSR = (1 << SPI2X); /* double speed, issue 89 */ |
|||
#endif |
|||
u8g->pin_list[U8G_PI_A0_STATE] = 0; /* inital RS state: command mode */ |
|||
break; |
|||
|
|||
case U8G_COM_MSG_STOP: |
|||
break; |
|||
|
|||
case U8G_COM_MSG_RESET: |
|||
if ( u8g->pin_list[U8G_PI_RESET] != U8G_PIN_NONE ) |
|||
u8g_com_arduino_digital_write(u8g, U8G_PI_RESET, arg_val); |
|||
break; |
|||
|
|||
case U8G_COM_MSG_CHIP_SELECT: |
|||
if ( arg_val == 0 ) |
|||
{ |
|||
/* disable, note: the st7920 has an active high chip select */ |
|||
u8g_com_arduino_digital_write(u8g, U8G_PI_CS, LOW); |
|||
} |
|||
else |
|||
{ |
|||
/* enable */ |
|||
//u8g_com_arduino_digital_write(u8g, U8G_PI_SCK, LOW);
|
|||
u8g_com_arduino_digital_write(u8g, U8G_PI_CS, HIGH); |
|||
} |
|||
break; |
|||
|
|||
case U8G_COM_MSG_WRITE_BYTE: |
|||
u8g_com_arduino_st7920_write_byte_hw_spi(u8g, u8g->pin_list[U8G_PI_A0_STATE], arg_val); |
|||
// u8g->pin_list[U8G_PI_A0_STATE] = 2;
|
|||
//u8g_arduino_sw_spi_shift_out(u8g->pin_list[U8G_PI_MOSI], u8g->pin_list[U8G_PI_SCK], arg_val);
|
|||
break; |
|||
|
|||
case U8G_COM_MSG_WRITE_SEQ: |
|||
{ |
|||
register uint8_t *ptr = arg_ptr; |
|||
while( arg_val > 0 ) |
|||
{ |
|||
u8g_com_arduino_st7920_write_byte_hw_spi(u8g, u8g->pin_list[U8G_PI_A0_STATE], *ptr++); |
|||
// u8g->pin_list[U8G_PI_A0_STATE] = 2;
|
|||
arg_val--; |
|||
} |
|||
} |
|||
break; |
|||
|
|||
case U8G_COM_MSG_WRITE_SEQ_P: |
|||
{ |
|||
register uint8_t *ptr = arg_ptr; |
|||
while( arg_val > 0 ) |
|||
{ |
|||
u8g_com_arduino_st7920_write_byte_hw_spi(u8g, u8g->pin_list[U8G_PI_A0_STATE], u8g_pgm_read(ptr) ); |
|||
// u8g->pin_list[U8G_PI_A0_STATE] = 2;
|
|||
ptr++; |
|||
arg_val--; |
|||
} |
|||
} |
|||
break; |
|||
|
|||
case U8G_COM_MSG_ADDRESS: /* define cmd (arg_val = 0) or data mode (arg_val = 1) */ |
|||
u8g->pin_list[U8G_PI_A0_STATE] = arg_val; |
|||
break; |
|||
} |
|||
return 1; |
|||
} |
|||
|
|||
#else |
|||
|
|||
uint8_t u8g_com_arduino_st7920_hw_spi_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_ptr) |
|||
{ |
|||
return 1; |
|||
} |
|||
#endif |
|||
|
|||
#else /* ARDUINO */ |
|||
|
|||
uint8_t u8g_com_arduino_st7920_hw_spi_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_ptr) |
|||
{ |
|||
return 1; |
|||
} |
|||
|
|||
#endif /* ARDUINO */ |
|||
|
|||
@ -0,0 +1,295 @@ |
|||
/*
|
|||
|
|||
u8g_com_arduino_st7920_spi.c |
|||
|
|||
Universal 8bit Graphics Library |
|||
|
|||
Copyright (c) 2011, olikraus@gmail.com |
|||
All rights reserved. |
|||
|
|||
Redistribution and use in source and binary forms, with or without modification, |
|||
are permitted provided that the following conditions are met: |
|||
|
|||
* Redistributions of source code must retain the above copyright notice, this list |
|||
of conditions and the following disclaimer. |
|||
|
|||
* Redistributions in binary form must reproduce the above copyright notice, this |
|||
list of conditions and the following disclaimer in the documentation and/or other |
|||
materials provided with the distribution. |
|||
|
|||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
|||
CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
|||
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
|||
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
|||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
|||
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
|||
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
|||
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
|||
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
|||
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF |
|||
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|||
|
|||
A special SPI interface for ST7920 controller |
|||
|
|||
*/ |
|||
|
|||
#include "u8g.h" |
|||
|
|||
#if defined(ARDUINO) |
|||
|
|||
#if ARDUINO < 100 |
|||
#include <WProgram.h> |
|||
#include "wiring_private.h" |
|||
#include "pins_arduino.h" |
|||
|
|||
#else |
|||
#include <Arduino.h> |
|||
#include "wiring_private.h" |
|||
#endif |
|||
|
|||
#if defined(__AVR__) |
|||
|
|||
uint8_t u8g_bitData, u8g_bitNotData; |
|||
uint8_t u8g_bitClock, u8g_bitNotClock; |
|||
volatile uint8_t *u8g_outData; |
|||
volatile uint8_t *u8g_outClock; |
|||
|
|||
static void u8g_com_arduino_init_shift_out(uint8_t dataPin, uint8_t clockPin) |
|||
{ |
|||
u8g_outData = portOutputRegister(digitalPinToPort(dataPin)); |
|||
u8g_outClock = portOutputRegister(digitalPinToPort(clockPin)); |
|||
u8g_bitData = digitalPinToBitMask(dataPin); |
|||
u8g_bitClock = digitalPinToBitMask(clockPin); |
|||
|
|||
u8g_bitNotClock = u8g_bitClock; |
|||
u8g_bitNotClock ^= 0x0ff; |
|||
|
|||
u8g_bitNotData = u8g_bitData; |
|||
u8g_bitNotData ^= 0x0ff; |
|||
} |
|||
|
|||
static void u8g_com_arduino_do_shift_out_msb_first(uint8_t val) U8G_NOINLINE; |
|||
static void u8g_com_arduino_do_shift_out_msb_first(uint8_t val) |
|||
{ |
|||
uint8_t cnt = 8; |
|||
uint8_t bitData = u8g_bitData; |
|||
uint8_t bitNotData = u8g_bitNotData; |
|||
uint8_t bitClock = u8g_bitClock; |
|||
uint8_t bitNotClock = u8g_bitNotClock; |
|||
volatile uint8_t *outData = u8g_outData; |
|||
volatile uint8_t *outClock = u8g_outClock; |
|||
do |
|||
{ |
|||
if ( val & 128 ) |
|||
*outData |= bitData; |
|||
else |
|||
*outData &= bitNotData; |
|||
|
|||
/*
|
|||
*outClock |= bitClock; |
|||
val <<= 1; |
|||
cnt--; |
|||
*outClock &= bitNotClock; |
|||
*/ |
|||
|
|||
val <<= 1; |
|||
*outClock &= bitNotClock; |
|||
cnt--; |
|||
// removed micro delays, because AVRs are too slow and the delay is not required
|
|||
//u8g_MicroDelay();
|
|||
*outClock |= bitClock; |
|||
//u8g_MicroDelay();
|
|||
} while( cnt != 0 ); |
|||
} |
|||
|
|||
#elif defined(__18CXX) || defined(__PIC32MX) |
|||
|
|||
uint16_t dog_bitData, dog_bitNotData; |
|||
uint16_t dog_bitClock, dog_bitNotClock; |
|||
volatile uint32_t *dog_outData; |
|||
volatile uint32_t *dog_outClock; |
|||
volatile uint32_t dog_pic32_spi_tmp; |
|||
|
|||
static void u8g_com_arduino_init_shift_out(uint8_t dataPin, uint8_t clockPin) |
|||
{ |
|||
dog_outData = portOutputRegister(digitalPinToPort(dataPin)); |
|||
dog_outClock = portOutputRegister(digitalPinToPort(clockPin)); |
|||
dog_bitData = digitalPinToBitMask(dataPin); |
|||
dog_bitClock = digitalPinToBitMask(clockPin); |
|||
|
|||
dog_bitNotClock = dog_bitClock; |
|||
dog_bitNotClock ^= 0x0ffff; |
|||
|
|||
dog_bitNotData = dog_bitData; |
|||
dog_bitNotData ^= 0x0ffff; |
|||
} |
|||
|
|||
static void u8g_com_arduino_do_shift_out_msb_first(uint8_t val) |
|||
{ |
|||
uint8_t cnt = 8; |
|||
do |
|||
{ |
|||
if ( val & 128 ) |
|||
*dog_outData |= dog_bitData; |
|||
else |
|||
*dog_outData &= dog_bitNotData; |
|||
val <<= 1; |
|||
//u8g_MicroDelay();
|
|||
//*dog_outClock |= dog_bitClock;
|
|||
*dog_outClock &= dog_bitNotClock; |
|||
cnt--; |
|||
u8g_MicroDelay(); |
|||
//*dog_outClock &= dog_bitNotClock;
|
|||
*dog_outClock |= dog_bitClock; |
|||
u8g_MicroDelay(); |
|||
|
|||
} while( cnt != 0 ); |
|||
} |
|||
|
|||
#else |
|||
|
|||
/* default interface, Arduino DUE (__arm__) */ |
|||
|
|||
uint8_t u8g_data_pin; |
|||
uint8_t u8g_clock_pin; |
|||
|
|||
static void u8g_com_arduino_init_shift_out(uint8_t dataPin, uint8_t clockPin) |
|||
{ |
|||
u8g_data_pin = dataPin; |
|||
u8g_clock_pin = clockPin; |
|||
} |
|||
|
|||
static void u8g_com_arduino_do_shift_out_msb_first(uint8_t val) |
|||
{ |
|||
uint8_t cnt = 8; |
|||
do |
|||
{ |
|||
if ( val & 128 ) |
|||
digitalWrite(u8g_data_pin, HIGH); |
|||
else |
|||
digitalWrite(u8g_data_pin, LOW); |
|||
val <<= 1; |
|||
//u8g_MicroDelay();
|
|||
digitalWrite(u8g_clock_pin, LOW); |
|||
cnt--; |
|||
u8g_MicroDelay(); |
|||
digitalWrite(u8g_clock_pin, HIGH); |
|||
u8g_MicroDelay(); |
|||
} while( cnt != 0 ); |
|||
} |
|||
|
|||
#endif |
|||
|
|||
|
|||
|
|||
|
|||
static void u8g_com_arduino_st7920_write_byte(uint8_t rs, uint8_t val) |
|||
{ |
|||
uint8_t i; |
|||
|
|||
if ( rs == 0 ) |
|||
{ |
|||
/* command */ |
|||
u8g_com_arduino_do_shift_out_msb_first(0x0f8); |
|||
} |
|||
else if ( rs == 1 ) |
|||
{ |
|||
/* data */ |
|||
u8g_com_arduino_do_shift_out_msb_first(0x0fa); |
|||
} |
|||
|
|||
u8g_com_arduino_do_shift_out_msb_first(val & 0x0f0); |
|||
u8g_com_arduino_do_shift_out_msb_first(val << 4); |
|||
|
|||
for( i = 0; i < 4; i++ ) |
|||
u8g_10MicroDelay(); |
|||
|
|||
} |
|||
|
|||
|
|||
|
|||
uint8_t u8g_com_arduino_st7920_spi_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_ptr) |
|||
{ |
|||
switch(msg) |
|||
{ |
|||
case U8G_COM_MSG_INIT: |
|||
u8g_com_arduino_assign_pin_output_high(u8g); |
|||
u8g_com_arduino_digital_write(u8g, U8G_PI_CS, LOW); |
|||
// u8g_com_arduino_digital_write(u8g, U8G_PI_SCK, LOW);
|
|||
u8g_com_arduino_digital_write(u8g, U8G_PI_SCK, HIGH); |
|||
u8g_com_arduino_digital_write(u8g, U8G_PI_MOSI, LOW); |
|||
u8g_com_arduino_init_shift_out(u8g->pin_list[U8G_PI_MOSI], u8g->pin_list[U8G_PI_SCK]); |
|||
u8g->pin_list[U8G_PI_A0_STATE] = 0; /* inital RS state: command mode */ |
|||
break; |
|||
|
|||
case U8G_COM_MSG_STOP: |
|||
break; |
|||
|
|||
case U8G_COM_MSG_RESET: |
|||
if ( u8g->pin_list[U8G_PI_RESET] != U8G_PIN_NONE ) |
|||
u8g_com_arduino_digital_write(u8g, U8G_PI_RESET, arg_val); |
|||
break; |
|||
|
|||
case U8G_COM_MSG_CHIP_SELECT: |
|||
if ( arg_val == 0 ) |
|||
{ |
|||
/* disable, note: the st7920 has an active high chip select */ |
|||
u8g_com_arduino_digital_write(u8g, U8G_PI_CS, LOW); |
|||
} |
|||
else |
|||
{ |
|||
/* enable */ |
|||
//u8g_com_arduino_digital_write(u8g, U8G_PI_SCK, HIGH);
|
|||
u8g_com_arduino_digital_write(u8g, U8G_PI_CS, HIGH); |
|||
} |
|||
break; |
|||
|
|||
case U8G_COM_MSG_WRITE_BYTE: |
|||
u8g_com_arduino_st7920_write_byte( u8g->pin_list[U8G_PI_A0_STATE], arg_val); |
|||
//u8g->pin_list[U8G_PI_A0_STATE] = 2;
|
|||
//u8g_arduino_sw_spi_shift_out(u8g->pin_list[U8G_PI_MOSI], u8g->pin_list[U8G_PI_SCK], arg_val);
|
|||
break; |
|||
|
|||
case U8G_COM_MSG_WRITE_SEQ: |
|||
{ |
|||
register uint8_t *ptr = arg_ptr; |
|||
while( arg_val > 0 ) |
|||
{ |
|||
u8g_com_arduino_st7920_write_byte(u8g->pin_list[U8G_PI_A0_STATE], *ptr++); |
|||
//u8g->pin_list[U8G_PI_A0_STATE] = 2;
|
|||
arg_val--; |
|||
} |
|||
} |
|||
break; |
|||
|
|||
case U8G_COM_MSG_WRITE_SEQ_P: |
|||
{ |
|||
register uint8_t *ptr = arg_ptr; |
|||
while( arg_val > 0 ) |
|||
{ |
|||
u8g_com_arduino_st7920_write_byte(u8g->pin_list[U8G_PI_A0_STATE], u8g_pgm_read(ptr) ); |
|||
//u8g->pin_list[U8G_PI_A0_STATE] = 2;
|
|||
ptr++; |
|||
arg_val--; |
|||
} |
|||
} |
|||
break; |
|||
|
|||
case U8G_COM_MSG_ADDRESS: /* define cmd (arg_val = 0) or data mode (arg_val = 1) */ |
|||
u8g->pin_list[U8G_PI_A0_STATE] = arg_val; |
|||
break; |
|||
} |
|||
return 1; |
|||
} |
|||
|
|||
#else /* ARDUINO */ |
|||
|
|||
uint8_t u8g_com_arduino_st7920_spi_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_ptr) |
|||
{ |
|||
return 1; |
|||
} |
|||
|
|||
#endif /* ARDUINO */ |
|||
|
|||
@ -0,0 +1,144 @@ |
|||
/*
|
|||
|
|||
u8g_arduino_std_sw_spi.c |
|||
|
|||
Universal 8bit Graphics Library |
|||
|
|||
Copyright (c) 2011, olikraus@gmail.com |
|||
All rights reserved. |
|||
|
|||
Redistribution and use in source and binary forms, with or without modification, |
|||
are permitted provided that the following conditions are met: |
|||
|
|||
* Redistributions of source code must retain the above copyright notice, this list |
|||
of conditions and the following disclaimer. |
|||
|
|||
* Redistributions in binary form must reproduce the above copyright notice, this |
|||
list of conditions and the following disclaimer in the documentation and/or other |
|||
materials provided with the distribution. |
|||
|
|||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
|||
CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
|||
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
|||
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
|||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
|||
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
|||
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
|||
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
|||
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
|||
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF |
|||
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|||
|
|||
|
|||
*/ |
|||
|
|||
#include "u8g.h" |
|||
|
|||
|
|||
#if defined(ARDUINO) |
|||
|
|||
#if ARDUINO < 100 |
|||
#include <WProgram.h> |
|||
#else |
|||
#include <Arduino.h> |
|||
#endif |
|||
|
|||
void u8g_arduino_sw_spi_shift_out(uint8_t dataPin, uint8_t clockPin, uint8_t val) |
|||
{ |
|||
uint8_t i = 8; |
|||
do |
|||
{ |
|||
if ( val & 128 ) |
|||
digitalWrite(dataPin, HIGH); |
|||
else |
|||
digitalWrite(dataPin, LOW); |
|||
val <<= 1; |
|||
u8g_MicroDelay(); /* 23 Sep 2012 */ |
|||
//delay(1);
|
|||
digitalWrite(clockPin, HIGH); |
|||
u8g_MicroDelay(); /* 23 Sep 2012 */ |
|||
//delay(1);
|
|||
digitalWrite(clockPin, LOW); |
|||
u8g_MicroDelay(); /* 23 Sep 2012 */ |
|||
//delay(1);
|
|||
i--; |
|||
} while( i != 0 ); |
|||
} |
|||
|
|||
uint8_t u8g_com_arduino_std_sw_spi_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_ptr) |
|||
{ |
|||
switch(msg) |
|||
{ |
|||
case U8G_COM_MSG_INIT: |
|||
u8g_com_arduino_assign_pin_output_high(u8g); |
|||
u8g_com_arduino_digital_write(u8g, U8G_PI_SCK, LOW); |
|||
u8g_com_arduino_digital_write(u8g, U8G_PI_MOSI, LOW); |
|||
break; |
|||
|
|||
case U8G_COM_MSG_STOP: |
|||
break; |
|||
|
|||
case U8G_COM_MSG_RESET: |
|||
if ( u8g->pin_list[U8G_PI_RESET] != U8G_PIN_NONE ) |
|||
u8g_com_arduino_digital_write(u8g, U8G_PI_RESET, arg_val); |
|||
break; |
|||
|
|||
case U8G_COM_MSG_CHIP_SELECT: |
|||
if ( arg_val == 0 ) |
|||
{ |
|||
/* disable */ |
|||
u8g_com_arduino_digital_write(u8g, U8G_PI_CS, HIGH); |
|||
} |
|||
else |
|||
{ |
|||
/* enable */ |
|||
u8g_com_arduino_digital_write(u8g, U8G_PI_SCK, LOW); |
|||
u8g_com_arduino_digital_write(u8g, U8G_PI_CS, LOW); |
|||
} |
|||
break; |
|||
|
|||
case U8G_COM_MSG_WRITE_BYTE: |
|||
u8g_arduino_sw_spi_shift_out(u8g->pin_list[U8G_PI_MOSI], u8g->pin_list[U8G_PI_SCK], arg_val); |
|||
break; |
|||
|
|||
case U8G_COM_MSG_WRITE_SEQ: |
|||
{ |
|||
register uint8_t *ptr = arg_ptr; |
|||
while( arg_val > 0 ) |
|||
{ |
|||
u8g_arduino_sw_spi_shift_out(u8g->pin_list[U8G_PI_MOSI], u8g->pin_list[U8G_PI_SCK], *ptr++); |
|||
arg_val--; |
|||
} |
|||
} |
|||
break; |
|||
|
|||
case U8G_COM_MSG_WRITE_SEQ_P: |
|||
{ |
|||
register uint8_t *ptr = arg_ptr; |
|||
while( arg_val > 0 ) |
|||
{ |
|||
u8g_arduino_sw_spi_shift_out(u8g->pin_list[U8G_PI_MOSI], u8g->pin_list[U8G_PI_SCK], u8g_pgm_read(ptr)); |
|||
ptr++; |
|||
arg_val--; |
|||
} |
|||
} |
|||
break; |
|||
|
|||
case U8G_COM_MSG_ADDRESS: /* define cmd (arg_val = 0) or data mode (arg_val = 1) */ |
|||
u8g_com_arduino_digital_write(u8g, U8G_PI_A0, arg_val); |
|||
break; |
|||
} |
|||
return 1; |
|||
} |
|||
|
|||
#else /* ARDUINO */ |
|||
|
|||
uint8_t u8g_com_arduino_std_sw_spi_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_ptr) |
|||
{ |
|||
return 1; |
|||
} |
|||
|
|||
#endif /* ARDUINO */ |
|||
|
|||
@ -0,0 +1,239 @@ |
|||
/*
|
|||
|
|||
u8g_arduino_sw_spi.c |
|||
|
|||
Universal 8bit Graphics Library |
|||
|
|||
Copyright (c) 2011, olikraus@gmail.com |
|||
All rights reserved. |
|||
|
|||
Redistribution and use in source and binary forms, with or without modification, |
|||
are permitted provided that the following conditions are met: |
|||
|
|||
* Redistributions of source code must retain the above copyright notice, this list |
|||
of conditions and the following disclaimer. |
|||
|
|||
* Redistributions in binary form must reproduce the above copyright notice, this |
|||
list of conditions and the following disclaimer in the documentation and/or other |
|||
materials provided with the distribution. |
|||
|
|||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
|||
CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
|||
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
|||
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
|||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
|||
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
|||
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
|||
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
|||
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
|||
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF |
|||
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|||
|
|||
|
|||
*/ |
|||
|
|||
#include "u8g.h" |
|||
|
|||
#if defined(ARDUINO) |
|||
|
|||
#if ARDUINO < 100 |
|||
#include <WProgram.h> |
|||
#include "wiring_private.h" |
|||
#include "pins_arduino.h" |
|||
|
|||
#else |
|||
#include <Arduino.h> |
|||
#include "wiring_private.h" |
|||
#endif |
|||
|
|||
#if defined(__AVR__) |
|||
|
|||
uint8_t u8g_bitData, u8g_bitNotData; |
|||
uint8_t u8g_bitClock, u8g_bitNotClock; |
|||
volatile uint8_t *u8g_outData; |
|||
volatile uint8_t *u8g_outClock; |
|||
|
|||
static void u8g_com_arduino_init_shift_out(uint8_t dataPin, uint8_t clockPin) |
|||
{ |
|||
u8g_outData = portOutputRegister(digitalPinToPort(dataPin)); |
|||
u8g_outClock = portOutputRegister(digitalPinToPort(clockPin)); |
|||
u8g_bitData = digitalPinToBitMask(dataPin); |
|||
u8g_bitClock = digitalPinToBitMask(clockPin); |
|||
|
|||
u8g_bitNotClock = u8g_bitClock; |
|||
u8g_bitNotClock ^= 0x0ff; |
|||
|
|||
u8g_bitNotData = u8g_bitData; |
|||
u8g_bitNotData ^= 0x0ff; |
|||
} |
|||
|
|||
static void u8g_com_arduino_do_shift_out_msb_first(uint8_t val) U8G_NOINLINE; |
|||
static void u8g_com_arduino_do_shift_out_msb_first(uint8_t val) |
|||
{ |
|||
uint8_t cnt = 8; |
|||
uint8_t bitData = u8g_bitData; |
|||
uint8_t bitNotData = u8g_bitNotData; |
|||
uint8_t bitClock = u8g_bitClock; |
|||
uint8_t bitNotClock = u8g_bitNotClock; |
|||
volatile uint8_t *outData = u8g_outData; |
|||
volatile uint8_t *outClock = u8g_outClock; |
|||
do |
|||
{ |
|||
if ( val & 128 ) |
|||
*outData |= bitData; |
|||
else |
|||
*outData &= bitNotData; |
|||
|
|||
*outClock |= bitClock; |
|||
val <<= 1; |
|||
cnt--; |
|||
*outClock &= bitNotClock; |
|||
} while( cnt != 0 ); |
|||
} |
|||
|
|||
#elif defined(__18CXX) || defined(__PIC32MX) |
|||
|
|||
uint16_t dog_bitData, dog_bitNotData; |
|||
uint16_t dog_bitClock, dog_bitNotClock; |
|||
volatile uint32_t *dog_outData; |
|||
volatile uint32_t *dog_outClock; |
|||
volatile uint32_t dog_pic32_spi_tmp; |
|||
|
|||
static void u8g_com_arduino_init_shift_out(uint8_t dataPin, uint8_t clockPin) |
|||
{ |
|||
dog_outData = portOutputRegister(digitalPinToPort(dataPin)); |
|||
dog_outClock = portOutputRegister(digitalPinToPort(clockPin)); |
|||
dog_bitData = digitalPinToBitMask(dataPin); |
|||
dog_bitClock = digitalPinToBitMask(clockPin); |
|||
|
|||
dog_bitNotClock = dog_bitClock; |
|||
dog_bitNotClock ^= 0x0ffff; |
|||
|
|||
dog_bitNotData = dog_bitData; |
|||
dog_bitNotData ^= 0x0ffff; |
|||
} |
|||
|
|||
static void u8g_com_arduino_do_shift_out_msb_first(uint8_t val) |
|||
{ |
|||
uint8_t cnt = 8; |
|||
do |
|||
{ |
|||
if ( val & 128 ) |
|||
*dog_outData |= dog_bitData; |
|||
else |
|||
*dog_outData &= dog_bitNotData; |
|||
val <<= 1; |
|||
/*
|
|||
There must be some delay here. However |
|||
fetching the adress dog_outClock is enough delay, so |
|||
do not place dog_outClock in a local variable. This will |
|||
break the procedure |
|||
*/ |
|||
*dog_outClock |= dog_bitClock; |
|||
cnt--; |
|||
*dog_outClock &= dog_bitNotClock; |
|||
/*
|
|||
little additional delay after clk pulse, done by 3x32bit reads |
|||
from I/O. Optimized for PIC32 with 80 MHz. |
|||
*/ |
|||
dog_pic32_spi_tmp = *dog_outClock; |
|||
dog_pic32_spi_tmp = *dog_outClock; |
|||
dog_pic32_spi_tmp = *dog_outClock; |
|||
} while( cnt != 0 ); |
|||
} |
|||
|
|||
#else |
|||
/* empty interface */ |
|||
|
|||
static void u8g_com_arduino_init_shift_out(uint8_t dataPin, uint8_t clockPin) |
|||
{ |
|||
} |
|||
|
|||
static void u8g_com_arduino_do_shift_out_msb_first(uint8_t val) |
|||
{ |
|||
} |
|||
|
|||
#endif |
|||
|
|||
|
|||
uint8_t u8g_com_arduino_sw_spi_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_ptr) |
|||
{ |
|||
switch(msg) |
|||
{ |
|||
case U8G_COM_MSG_INIT: |
|||
u8g_com_arduino_assign_pin_output_high(u8g); |
|||
u8g_com_arduino_digital_write(u8g, U8G_PI_SCK, LOW); |
|||
u8g_com_arduino_digital_write(u8g, U8G_PI_MOSI, LOW); |
|||
u8g_com_arduino_init_shift_out(u8g->pin_list[U8G_PI_MOSI], u8g->pin_list[U8G_PI_SCK]); |
|||
break; |
|||
|
|||
case U8G_COM_MSG_STOP: |
|||
break; |
|||
|
|||
case U8G_COM_MSG_RESET: |
|||
if ( u8g->pin_list[U8G_PI_RESET] != U8G_PIN_NONE ) |
|||
u8g_com_arduino_digital_write(u8g, U8G_PI_RESET, arg_val); |
|||
break; |
|||
|
|||
case U8G_COM_MSG_CHIP_SELECT: |
|||
if ( arg_val == 0 ) |
|||
{ |
|||
/* disable */ |
|||
u8g_com_arduino_digital_write(u8g, U8G_PI_CS, HIGH); |
|||
} |
|||
else |
|||
{ |
|||
/* enable */ |
|||
u8g_com_arduino_digital_write(u8g, U8G_PI_SCK, LOW); |
|||
u8g_com_arduino_digital_write(u8g, U8G_PI_CS, LOW); |
|||
} |
|||
break; |
|||
|
|||
case U8G_COM_MSG_WRITE_BYTE: |
|||
u8g_com_arduino_do_shift_out_msb_first( arg_val ); |
|||
//u8g_arduino_sw_spi_shift_out(u8g->pin_list[U8G_PI_MOSI], u8g->pin_list[U8G_PI_SCK], arg_val);
|
|||
break; |
|||
|
|||
case U8G_COM_MSG_WRITE_SEQ: |
|||
{ |
|||
register uint8_t *ptr = arg_ptr; |
|||
while( arg_val > 0 ) |
|||
{ |
|||
u8g_com_arduino_do_shift_out_msb_first(*ptr++); |
|||
// u8g_arduino_sw_spi_shift_out(u8g->pin_list[U8G_PI_MOSI], u8g->pin_list[U8G_PI_SCK], *ptr++);
|
|||
arg_val--; |
|||
} |
|||
} |
|||
break; |
|||
|
|||
case U8G_COM_MSG_WRITE_SEQ_P: |
|||
{ |
|||
register uint8_t *ptr = arg_ptr; |
|||
while( arg_val > 0 ) |
|||
{ |
|||
u8g_com_arduino_do_shift_out_msb_first( u8g_pgm_read(ptr) ); |
|||
//u8g_arduino_sw_spi_shift_out(u8g->pin_list[U8G_PI_MOSI], u8g->pin_list[U8G_PI_SCK], u8g_pgm_read(ptr));
|
|||
ptr++; |
|||
arg_val--; |
|||
} |
|||
} |
|||
break; |
|||
|
|||
case U8G_COM_MSG_ADDRESS: /* define cmd (arg_val = 0) or data mode (arg_val = 1) */ |
|||
u8g_com_arduino_digital_write(u8g, U8G_PI_A0, arg_val); |
|||
break; |
|||
} |
|||
return 1; |
|||
} |
|||
|
|||
#else /* ARDUINO */ |
|||
|
|||
uint8_t u8g_com_arduino_sw_spi_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_ptr) |
|||
{ |
|||
return 1; |
|||
} |
|||
|
|||
#endif /* ARDUINO */ |
|||
|
|||
@ -0,0 +1,385 @@ |
|||
/*
|
|||
|
|||
u8g_com_arduino_t6963.c |
|||
|
|||
Universal 8bit Graphics Library |
|||
|
|||
Copyright (c) 2011, olikraus@gmail.com |
|||
All rights reserved. |
|||
|
|||
Redistribution and use in source and binary forms, with or without modification, |
|||
are permitted provided that the following conditions are met: |
|||
|
|||
* Redistributions of source code must retain the above copyright notice, this list |
|||
of conditions and the following disclaimer. |
|||
|
|||
* Redistributions in binary form must reproduce the above copyright notice, this |
|||
list of conditions and the following disclaimer in the documentation and/or other |
|||
materials provided with the distribution. |
|||
|
|||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
|||
CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
|||
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
|||
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
|||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
|||
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
|||
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
|||
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
|||
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
|||
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF |
|||
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|||
|
|||
|
|||
PIN_D0 8 |
|||
PIN_D1 9 |
|||
PIN_D2 10 |
|||
PIN_D3 11 |
|||
PIN_D4 4 |
|||
PIN_D5 5 |
|||
PIN_D6 6 |
|||
PIN_D7 7 |
|||
|
|||
PIN_CS 14 |
|||
PIN_A0 15 |
|||
PIN_RESET 16 |
|||
PIN_WR 17 |
|||
PIN_RD 18 |
|||
|
|||
u8g_InitRW8Bit(u8g, dev, d0, d1, d2, d3, d4, d5, d6, d7, cs, a0, wr, rd, reset) |
|||
u8g_InitRW8Bit(u8g, dev, 8, 9, 10, 11, 4, 5, 6, 7, 14, 15, 17, 18, 16) |
|||
|
|||
*/ |
|||
|
|||
#include "u8g.h" |
|||
|
|||
#if defined(ARDUINO) |
|||
|
|||
#if ARDUINO < 100 |
|||
//#include <WProgram.h>
|
|||
#include <wiring_private.h> |
|||
#include <pins_arduino.h> |
|||
#else |
|||
#include <Arduino.h> |
|||
#endif |
|||
|
|||
|
|||
#if defined(__PIC32MX) |
|||
/* CHIPKIT PIC32 */ |
|||
static volatile uint32_t *u8g_output_data_port[8]; |
|||
static volatile uint32_t *u8g_input_data_port[8]; |
|||
static volatile uint32_t *u8g_mode_port[8]; |
|||
static uint32_t u8g_data_mask[8]; |
|||
#else |
|||
static volatile uint8_t *u8g_output_data_port[8]; |
|||
static volatile uint8_t *u8g_input_data_port[8]; |
|||
static volatile uint8_t *u8g_mode_port[8]; |
|||
static uint8_t u8g_data_mask[8]; |
|||
#endif |
|||
|
|||
|
|||
|
|||
static void u8g_com_arduino_t6963_init(u8g_t *u8g) |
|||
{ |
|||
u8g_output_data_port[0] = portOutputRegister(digitalPinToPort(u8g->pin_list[U8G_PI_D0])); |
|||
u8g_input_data_port[0] = portInputRegister(digitalPinToPort(u8g->pin_list[U8G_PI_D0])); |
|||
u8g_mode_port[0] = portModeRegister(digitalPinToPort(u8g->pin_list[U8G_PI_D0])); |
|||
u8g_data_mask[0] = digitalPinToBitMask(u8g->pin_list[U8G_PI_D0]); |
|||
|
|||
u8g_output_data_port[1] = portOutputRegister(digitalPinToPort(u8g->pin_list[U8G_PI_D1])); |
|||
u8g_input_data_port[1] = portInputRegister(digitalPinToPort(u8g->pin_list[U8G_PI_D1])); |
|||
u8g_mode_port[1] = portModeRegister(digitalPinToPort(u8g->pin_list[U8G_PI_D1])); |
|||
u8g_data_mask[1] = digitalPinToBitMask(u8g->pin_list[U8G_PI_D1]); |
|||
|
|||
u8g_output_data_port[2] = portOutputRegister(digitalPinToPort(u8g->pin_list[U8G_PI_D2])); |
|||
u8g_input_data_port[2] = portInputRegister(digitalPinToPort(u8g->pin_list[U8G_PI_D2])); |
|||
u8g_mode_port[2] = portModeRegister(digitalPinToPort(u8g->pin_list[U8G_PI_D2])); |
|||
u8g_data_mask[2] = digitalPinToBitMask(u8g->pin_list[U8G_PI_D2]); |
|||
|
|||
u8g_output_data_port[3] = portOutputRegister(digitalPinToPort(u8g->pin_list[U8G_PI_D3])); |
|||
u8g_input_data_port[3] = portInputRegister(digitalPinToPort(u8g->pin_list[U8G_PI_D3])); |
|||
u8g_mode_port[3] = portModeRegister(digitalPinToPort(u8g->pin_list[U8G_PI_D3])); |
|||
u8g_data_mask[3] = digitalPinToBitMask(u8g->pin_list[U8G_PI_D3]); |
|||
|
|||
u8g_output_data_port[4] = portOutputRegister(digitalPinToPort(u8g->pin_list[U8G_PI_D4])); |
|||
u8g_input_data_port[4] = portInputRegister(digitalPinToPort(u8g->pin_list[U8G_PI_D4])); |
|||
u8g_mode_port[4] = portModeRegister(digitalPinToPort(u8g->pin_list[U8G_PI_D4])); |
|||
u8g_data_mask[4] = digitalPinToBitMask(u8g->pin_list[U8G_PI_D4]); |
|||
|
|||
u8g_output_data_port[5] = portOutputRegister(digitalPinToPort(u8g->pin_list[U8G_PI_D5])); |
|||
u8g_input_data_port[5] = portInputRegister(digitalPinToPort(u8g->pin_list[U8G_PI_D5])); |
|||
u8g_mode_port[5] = portModeRegister(digitalPinToPort(u8g->pin_list[U8G_PI_D5])); |
|||
u8g_data_mask[5] = digitalPinToBitMask(u8g->pin_list[U8G_PI_D5]); |
|||
|
|||
u8g_output_data_port[6] = portOutputRegister(digitalPinToPort(u8g->pin_list[U8G_PI_D6])); |
|||
u8g_input_data_port[6] = portInputRegister(digitalPinToPort(u8g->pin_list[U8G_PI_D6])); |
|||
u8g_mode_port[6] = portModeRegister(digitalPinToPort(u8g->pin_list[U8G_PI_D6])); |
|||
u8g_data_mask[6] = digitalPinToBitMask(u8g->pin_list[U8G_PI_D6]); |
|||
|
|||
u8g_output_data_port[7] = portOutputRegister(digitalPinToPort(u8g->pin_list[U8G_PI_D7])); |
|||
u8g_input_data_port[7] = portInputRegister(digitalPinToPort(u8g->pin_list[U8G_PI_D7])); |
|||
u8g_mode_port[7] = portModeRegister(digitalPinToPort(u8g->pin_list[U8G_PI_D7])); |
|||
u8g_data_mask[7] = digitalPinToBitMask(u8g->pin_list[U8G_PI_D7]); |
|||
} |
|||
|
|||
static void u8g_com_arduino_t6963_write_data_pin(uint8_t pin, uint8_t val) |
|||
{ |
|||
if ( val != 0 ) |
|||
*u8g_output_data_port[pin] |= u8g_data_mask[pin]; |
|||
else |
|||
*u8g_output_data_port[pin] &= ~u8g_data_mask[pin]; |
|||
} |
|||
|
|||
static void u8g_com_arduino_t6963_set_port_output(void) |
|||
{ |
|||
uint8_t i; |
|||
for( i = 0; i < 8; i++ ) |
|||
{ |
|||
#if defined(__PIC32MX) |
|||
/* CHIPKIT PIC32 */ |
|||
*u8g_mode_port[i] |= u8g_data_mask[i]; |
|||
#elif defined(__AVR__) |
|||
*u8g_mode_port[i] |= u8g_data_mask[i]; |
|||
#else |
|||
/* TODO: use generic Arduino API */ |
|||
*u8g_mode_port[i] |= u8g_data_mask[i]; |
|||
#endif |
|||
|
|||
} |
|||
} |
|||
|
|||
static void u8g_com_arduino_t6963_set_port_input(void) |
|||
{ |
|||
uint8_t i; |
|||
for( i = 0; i < 8; i++ ) |
|||
{ |
|||
#if defined(__PIC32MX) |
|||
/* CHIPKIT PIC32 */ |
|||
*u8g_mode_port[i] &= ~u8g_data_mask[i]; |
|||
#elif defined(__AVR__) |
|||
/* avr */ |
|||
*u8g_mode_port[i] &= ~u8g_data_mask[i]; |
|||
*u8g_output_data_port[i] &= ~u8g_data_mask[i]; // no pullup
|
|||
#else |
|||
/* TODO: use generic Arduino API */ |
|||
*u8g_mode_port[i] &= ~u8g_data_mask[i]; |
|||
*u8g_output_data_port[i] &= ~u8g_data_mask[i]; // no pullup
|
|||
#endif |
|||
} |
|||
} |
|||
|
|||
|
|||
static void u8g_com_arduino_t6963_write(u8g_t *u8g, uint8_t val) |
|||
{ |
|||
u8g_com_arduino_t6963_write_data_pin( 0, val&1 ); |
|||
val >>= 1; |
|||
u8g_com_arduino_t6963_write_data_pin( 1, val&1 ); |
|||
val >>= 1; |
|||
u8g_com_arduino_t6963_write_data_pin( 2, val&1 ); |
|||
val >>= 1; |
|||
u8g_com_arduino_t6963_write_data_pin( 3, val&1 ); |
|||
val >>= 1; |
|||
|
|||
u8g_com_arduino_t6963_write_data_pin( 4, val&1 ); |
|||
val >>= 1; |
|||
u8g_com_arduino_t6963_write_data_pin( 5, val&1 ); |
|||
val >>= 1; |
|||
u8g_com_arduino_t6963_write_data_pin( 6, val&1 ); |
|||
val >>= 1; |
|||
u8g_com_arduino_t6963_write_data_pin( 7, val&1 ); |
|||
val >>= 1; |
|||
|
|||
u8g_com_arduino_digital_write(u8g, U8G_PI_WR, 0); |
|||
u8g_MicroDelay(); /* 80ns, reference: t6963 datasheet */ |
|||
u8g_com_arduino_digital_write(u8g, U8G_PI_WR, 1); |
|||
u8g_MicroDelay(); /* 10ns, reference: t6963 datasheet */ |
|||
} |
|||
|
|||
static uint8_t u8g_com_arduino_t6963_read(u8g_t *u8g) |
|||
{ |
|||
uint8_t val = 0; |
|||
|
|||
u8g_com_arduino_digital_write(u8g, U8G_PI_RD, 0); |
|||
u8g_MicroDelay(); /* 150ns, reference: t6963 datasheet */ |
|||
|
|||
/* only read bits 0, 1 and 3 */ |
|||
if ( (*u8g_input_data_port[3] & u8g_data_mask[3]) != 0 ) |
|||
val++; |
|||
val <<= 1; |
|||
val <<= 1; |
|||
if ( (*u8g_input_data_port[1] & u8g_data_mask[1]) != 0 ) |
|||
val++; |
|||
val <<= 1; |
|||
if ( (*u8g_input_data_port[0] & u8g_data_mask[0]) != 0 ) |
|||
val++; |
|||
|
|||
u8g_com_arduino_digital_write(u8g, U8G_PI_RD, 1); |
|||
u8g_MicroDelay(); /* 10ns, reference: t6963 datasheet */ |
|||
|
|||
return val; |
|||
} |
|||
|
|||
#define U8G_STATUS_TIMEOUT 50 |
|||
|
|||
static uint8_t u8g_com_arduino_t6963_until_01_ok(u8g_t *u8g) |
|||
{ |
|||
long x; |
|||
|
|||
u8g_com_arduino_t6963_set_port_input(); |
|||
x = millis(); |
|||
x += U8G_STATUS_TIMEOUT; |
|||
|
|||
for(;;) |
|||
{ |
|||
if ( (u8g_com_arduino_t6963_read(u8g) & 3) == 3 ) |
|||
break; |
|||
if ( x < millis() ) |
|||
return 0; |
|||
} |
|||
u8g_com_arduino_t6963_set_port_output(); |
|||
return 1; |
|||
} |
|||
|
|||
static uint8_t u8g_com_arduino_t6963_until_3_ok(u8g_t *u8g) |
|||
{ |
|||
long x; |
|||
|
|||
u8g_com_arduino_t6963_set_port_input(); |
|||
x = millis(); |
|||
x += U8G_STATUS_TIMEOUT; |
|||
|
|||
for(;;) |
|||
{ |
|||
if ( (u8g_com_arduino_t6963_read(u8g) & 8) == 8 ) |
|||
break; |
|||
if ( x < millis() ) |
|||
return 0; |
|||
} |
|||
u8g_com_arduino_t6963_set_port_output(); |
|||
return 1; |
|||
} |
|||
|
|||
static uint8_t u8g_com_arduino_t6963_write_cmd(u8g_t *u8g, uint8_t val) |
|||
{ |
|||
u8g_com_arduino_digital_write(u8g, U8G_PI_A0, 1); |
|||
if ( u8g_com_arduino_t6963_until_01_ok(u8g) == 0 ) |
|||
return 0; |
|||
u8g_com_arduino_digital_write(u8g, U8G_PI_A0, 1); |
|||
u8g_com_arduino_t6963_write(u8g, val); |
|||
return 1; |
|||
} |
|||
|
|||
static uint8_t u8g_com_arduino_t6963_write_data(u8g_t *u8g, uint8_t val) |
|||
{ |
|||
u8g_com_arduino_digital_write(u8g, U8G_PI_A0, 1); |
|||
if ( u8g_com_arduino_t6963_until_01_ok(u8g) == 0 ) |
|||
return 0; |
|||
u8g_com_arduino_digital_write(u8g, U8G_PI_A0, 0); |
|||
u8g_com_arduino_t6963_write(u8g, val); |
|||
return 1; |
|||
} |
|||
|
|||
static uint8_t u8g_com_arduino_t6963_write_auto_data(u8g_t *u8g, uint8_t val) |
|||
{ |
|||
u8g_com_arduino_digital_write(u8g, U8G_PI_A0, 1); |
|||
if ( u8g_com_arduino_t6963_until_3_ok(u8g) == 0 ) |
|||
return 0; |
|||
u8g_com_arduino_digital_write(u8g, U8G_PI_A0, 0); |
|||
u8g_com_arduino_t6963_write(u8g, val); |
|||
return 1; |
|||
} |
|||
|
|||
|
|||
uint8_t u8g_com_arduino_t6963_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_ptr) |
|||
{ |
|||
switch(msg) |
|||
{ |
|||
case U8G_COM_MSG_INIT: |
|||
u8g->pin_list[U8G_PI_A0_STATE] = 0; |
|||
u8g_com_arduino_t6963_init(u8g); |
|||
/* setup the RW (equal to WR) pin as output and force it to high */ |
|||
if ( u8g->pin_list[U8G_PI_WR] != U8G_PIN_NONE ) |
|||
{ |
|||
pinMode(u8g->pin_list[U8G_PI_WR], OUTPUT); |
|||
u8g_com_arduino_digital_write(u8g, U8G_PI_WR, HIGH); |
|||
} |
|||
/* set all pins (except WR pin) */ |
|||
u8g_com_arduino_assign_pin_output_high(u8g); |
|||
break; |
|||
case U8G_COM_MSG_STOP: |
|||
break; |
|||
|
|||
case U8G_COM_MSG_CHIP_SELECT: |
|||
if ( arg_val == 0 ) |
|||
{ |
|||
/* disable, active low chip select */ |
|||
u8g_com_arduino_digital_write(u8g, U8G_PI_CS, HIGH); |
|||
} |
|||
else |
|||
{ |
|||
/* enable */ |
|||
u8g_com_arduino_digital_write(u8g, U8G_PI_CS, LOW); |
|||
} |
|||
break; |
|||
case U8G_COM_MSG_WRITE_BYTE: |
|||
if ( u8g->pin_list[U8G_PI_A0_STATE] == 0 ) |
|||
{ |
|||
u8g_com_arduino_t6963_write_data(u8g, arg_val); |
|||
} |
|||
else |
|||
{ |
|||
u8g_com_arduino_t6963_write_cmd(u8g, arg_val); |
|||
} |
|||
break; |
|||
case U8G_COM_MSG_WRITE_SEQ: |
|||
{ |
|||
register uint8_t *ptr = arg_ptr; |
|||
u8g_com_arduino_t6963_write_cmd(u8g, 0x0b0); /* auto write */ |
|||
while( arg_val > 0 ) |
|||
{ |
|||
if ( u8g_com_arduino_t6963_write_auto_data(u8g, *ptr++) == 0 ) |
|||
break; |
|||
arg_val--; |
|||
} |
|||
u8g_com_arduino_t6963_write_cmd(u8g, 0x0b2); /* auto reset */ |
|||
} |
|||
break; |
|||
case U8G_COM_MSG_WRITE_SEQ_P: |
|||
{ |
|||
register uint8_t *ptr = arg_ptr; |
|||
u8g_com_arduino_t6963_write_cmd(u8g, 0x0b0); /* auto write */ |
|||
while( arg_val > 0 ) |
|||
{ |
|||
if ( u8g_com_arduino_t6963_write_auto_data(u8g, u8g_pgm_read(ptr)) == 0 ) |
|||
break; |
|||
ptr++; |
|||
arg_val--; |
|||
} |
|||
u8g_com_arduino_t6963_write_cmd(u8g, 0x0b2); /* auto reset */ |
|||
} |
|||
break; |
|||
case U8G_COM_MSG_ADDRESS: /* define cmd (arg_val = 1) or data mode (arg_val = 0) */ |
|||
u8g->pin_list[U8G_PI_A0_STATE] = arg_val; |
|||
//u8g_com_arduino_digital_write(u8g, U8G_PI_DI, arg_val);
|
|||
break; |
|||
case U8G_COM_MSG_RESET: |
|||
if ( u8g->pin_list[U8G_PI_RESET] != U8G_PIN_NONE ) |
|||
u8g_com_arduino_digital_write(u8g, U8G_PI_RESET, arg_val); |
|||
break; |
|||
|
|||
} |
|||
return 1; |
|||
} |
|||
|
|||
#else |
|||
|
|||
|
|||
uint8_t u8g_com_arduino_t6963_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_ptr) |
|||
{ |
|||
return 1; |
|||
} |
|||
|
|||
|
|||
#endif /* ARDUINO */ |
|||
|
|||
@ -0,0 +1,174 @@ |
|||
/*
|
|||
|
|||
u8g_com_atmega_hw_spi.c |
|||
|
|||
Universal 8bit Graphics Library |
|||
|
|||
Copyright (c) 2012, olikraus@gmail.com |
|||
All rights reserved. |
|||
|
|||
Redistribution and use in source and binary forms, with or without modification, |
|||
are permitted provided that the following conditions are met: |
|||
|
|||
* Redistributions of source code must retain the above copyright notice, this list |
|||
of conditions and the following disclaimer. |
|||
|
|||
* Redistributions in binary form must reproduce the above copyright notice, this |
|||
list of conditions and the following disclaimer in the documentation and/or other |
|||
materials provided with the distribution. |
|||
|
|||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
|||
CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
|||
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
|||
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
|||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
|||
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
|||
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
|||
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
|||
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
|||
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF |
|||
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|||
|
|||
|
|||
Assumes, that |
|||
MOSI is at PORTB, Pin 3 |
|||
and |
|||
SCK is at PORTB, Pin 5 |
|||
|
|||
*/ |
|||
|
|||
#include "u8g.h" |
|||
|
|||
|
|||
#if defined(__AVR__) |
|||
#define U8G_ATMEGA_HW_SPI |
|||
|
|||
/* remove the definition for attiny */ |
|||
#if __AVR_ARCH__ == 2 |
|||
#undef U8G_ATMEGA_HW_SPI |
|||
#endif |
|||
#if __AVR_ARCH__ == 25 |
|||
#undef U8G_ATMEGA_HW_SPI |
|||
#endif |
|||
#endif |
|||
|
|||
|
|||
#if defined(U8G_ATMEGA_HW_SPI) |
|||
|
|||
#include <avr/interrupt.h> |
|||
#include <avr/io.h> |
|||
|
|||
|
|||
static uint8_t u8g_atmega_spi_out(uint8_t data) |
|||
{ |
|||
/* unsigned char x = 100; */ |
|||
/* send data */ |
|||
SPDR = data; |
|||
/* wait for transmission */ |
|||
while (!(SPSR & (1<<SPIF))) |
|||
; |
|||
/* clear the SPIF flag by reading SPDR */ |
|||
return SPDR; |
|||
} |
|||
|
|||
|
|||
uint8_t u8g_com_atmega_hw_spi_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_ptr) |
|||
{ |
|||
switch(msg) |
|||
{ |
|||
case U8G_COM_MSG_STOP: |
|||
break; |
|||
|
|||
case U8G_COM_MSG_INIT: |
|||
|
|||
u8g_SetPIOutput(u8g, U8G_PI_CS); |
|||
u8g_SetPIOutput(u8g, U8G_PI_A0); |
|||
|
|||
DDRB |= _BV(3); /* D0, MOSI */ |
|||
DDRB |= _BV(5); /* SCK */ |
|||
DDRB |= _BV(2); /* slave select */ |
|||
|
|||
PORTB &= ~_BV(3); /* D0, MOSI = 0 */ |
|||
PORTB &= ~_BV(5); /* SCK = 0 */ |
|||
u8g_SetPILevel(u8g, U8G_PI_CS, 1); |
|||
|
|||
/*
|
|||
SPR1 SPR0 |
|||
0 0 fclk/4 x |
|||
0 1 fclk/16 |
|||
1 0 fclk/64 |
|||
1 1 fclk/128 |
|||
*/ |
|||
SPCR = 0; |
|||
SPCR = (1<<SPE) | (1<<MSTR)|(0<<SPR1)|(0<<SPR0)|(0<<CPOL)|(0<<CPHA); |
|||
#ifdef U8G_HW_SPI_2X |
|||
SPSR = (1 << SPI2X); /* double speed, issue 89 */ |
|||
#endif |
|||
|
|||
break; |
|||
|
|||
case U8G_COM_MSG_ADDRESS: /* define cmd (arg_val = 0) or data mode (arg_val = 1) */ |
|||
u8g_SetPILevel(u8g, U8G_PI_A0, arg_val); |
|||
break; |
|||
|
|||
case U8G_COM_MSG_CHIP_SELECT: |
|||
|
|||
if ( arg_val == 0 ) |
|||
{ |
|||
/* disable */ |
|||
u8g_SetPILevel(u8g, U8G_PI_CS, 1); |
|||
} |
|||
else |
|||
{ |
|||
PORTB &= ~_BV(5); /* SCK = 0 */ |
|||
/* enable */ |
|||
u8g_SetPILevel(u8g, U8G_PI_CS, 0); /* CS = 0 (low active) */ |
|||
} |
|||
|
|||
break; |
|||
|
|||
case U8G_COM_MSG_RESET: |
|||
u8g_SetPILevel(u8g, U8G_PI_RESET, arg_val); |
|||
break; |
|||
|
|||
case U8G_COM_MSG_WRITE_BYTE: |
|||
u8g_atmega_spi_out(arg_val); |
|||
break; |
|||
|
|||
case U8G_COM_MSG_WRITE_SEQ: |
|||
{ |
|||
register uint8_t *ptr = arg_ptr; |
|||
while( arg_val > 0 ) |
|||
{ |
|||
u8g_atmega_spi_out(*ptr++); |
|||
arg_val--; |
|||
} |
|||
} |
|||
break; |
|||
case U8G_COM_MSG_WRITE_SEQ_P: |
|||
{ |
|||
register uint8_t *ptr = arg_ptr; |
|||
while( arg_val > 0 ) |
|||
{ |
|||
u8g_atmega_spi_out(u8g_pgm_read(ptr)); |
|||
ptr++; |
|||
arg_val--; |
|||
} |
|||
} |
|||
break; |
|||
} |
|||
return 1; |
|||
} |
|||
|
|||
#else |
|||
|
|||
uint8_t u8g_com_atmega_hw_spi_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_ptr) |
|||
{ |
|||
return 1; |
|||
} |
|||
|
|||
#endif |
|||
|
|||
|
|||
@ -0,0 +1,183 @@ |
|||
/*
|
|||
|
|||
u8g_atmega_parallel.c |
|||
|
|||
Universal 8bit Graphics Library |
|||
|
|||
Copyright (c) 2012, olikraus@gmail.com |
|||
All rights reserved. |
|||
|
|||
Redistribution and use in source and binary forms, with or without modification, |
|||
are permitted provided that the following conditions are met: |
|||
|
|||
* Redistributions of source code must retain the above copyright notice, this list |
|||
of conditions and the following disclaimer. |
|||
|
|||
* Redistributions in binary form must reproduce the above copyright notice, this |
|||
list of conditions and the following disclaimer in the documentation and/or other |
|||
materials provided with the distribution. |
|||
|
|||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
|||
CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
|||
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
|||
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
|||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
|||
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
|||
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
|||
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
|||
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
|||
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF |
|||
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|||
|
|||
|
|||
PIN_D0 8 |
|||
PIN_D1 9 |
|||
PIN_D2 10 |
|||
PIN_D3 11 |
|||
PIN_D4 4 |
|||
PIN_D5 5 |
|||
PIN_D6 6 |
|||
PIN_D7 7 |
|||
|
|||
PIN_CS1 14 |
|||
PIN_CS2 15 |
|||
PIN_RW 16 |
|||
PIN_DI 17 |
|||
PIN_EN 18 |
|||
|
|||
u8g_Init8Bit(u8g, dev, d0, d1, d2, d3, d4, d5, d6, d7, en, cs1, cs2, di, rw, reset) |
|||
u8g_Init8Bit(u8g, dev, 8, 9, 10, 11, 4, 5, 6, 7, 18, 14, 15, 17, 16, U8G_PIN_NONE) |
|||
|
|||
*/ |
|||
|
|||
#include "u8g.h" |
|||
|
|||
#if defined(__AVR__) |
|||
|
|||
static void u8g_com_atmega_parallel_write(u8g_t *u8g, uint8_t val) U8G_NOINLINE; |
|||
static void u8g_com_atmega_parallel_write(u8g_t *u8g, uint8_t val) |
|||
{ |
|||
|
|||
u8g_SetPILevel(u8g, U8G_PI_D0, val&1); |
|||
val >>= 1; |
|||
u8g_SetPILevel(u8g, U8G_PI_D1, val&1); |
|||
val >>= 1; |
|||
u8g_SetPILevel(u8g, U8G_PI_D2, val&1); |
|||
val >>= 1; |
|||
u8g_SetPILevel(u8g, U8G_PI_D3, val&1); |
|||
val >>= 1; |
|||
u8g_SetPILevel(u8g, U8G_PI_D4, val&1); |
|||
val >>= 1; |
|||
u8g_SetPILevel(u8g, U8G_PI_D5, val&1); |
|||
val >>= 1; |
|||
u8g_SetPILevel(u8g, U8G_PI_D6, val&1); |
|||
val >>= 1; |
|||
u8g_SetPILevel(u8g, U8G_PI_D7, val&1); |
|||
|
|||
/* EN cycle time must be 1 micro second */ |
|||
u8g_SetPILevel(u8g, U8G_PI_EN, 1); |
|||
u8g_MicroDelay(); /* delay by 1000ns, reference: ST7920: 140ns, SBN1661: 100ns */ |
|||
u8g_SetPILevel(u8g, U8G_PI_EN, 0); |
|||
u8g_10MicroDelay(); /* ST7920 commands: 72us */ |
|||
u8g_10MicroDelay(); /* ST7920 commands: 72us */ |
|||
} |
|||
|
|||
|
|||
uint8_t u8g_com_atmega_parallel_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_ptr) |
|||
{ |
|||
switch(msg) |
|||
{ |
|||
case U8G_COM_MSG_INIT: |
|||
/* setup the RW pin as output and force it to low */ |
|||
u8g_SetPIOutput(u8g, U8G_PI_RW); |
|||
u8g_SetPILevel(u8g, U8G_PI_RW, 0); |
|||
|
|||
u8g_SetPIOutput(u8g, U8G_PI_D0); |
|||
u8g_SetPIOutput(u8g, U8G_PI_D1); |
|||
u8g_SetPIOutput(u8g, U8G_PI_D2); |
|||
u8g_SetPIOutput(u8g, U8G_PI_D3); |
|||
u8g_SetPIOutput(u8g, U8G_PI_D4); |
|||
u8g_SetPIOutput(u8g, U8G_PI_D5); |
|||
u8g_SetPIOutput(u8g, U8G_PI_D6); |
|||
u8g_SetPIOutput(u8g, U8G_PI_D7); |
|||
u8g_SetPIOutput(u8g, U8G_PI_EN); |
|||
u8g_SetPIOutput(u8g, U8G_PI_CS1); |
|||
u8g_SetPIOutput(u8g, U8G_PI_CS2); |
|||
u8g_SetPIOutput(u8g, U8G_PI_DI); |
|||
u8g_SetPILevel(u8g, U8G_PI_CS1, 1); |
|||
u8g_SetPILevel(u8g, U8G_PI_CS2, 1); |
|||
|
|||
break; |
|||
case U8G_COM_MSG_STOP: |
|||
break; |
|||
case U8G_COM_MSG_CHIP_SELECT: |
|||
if ( arg_val == 0 ) |
|||
{ |
|||
/* disable */ |
|||
u8g_SetPILevel(u8g, U8G_PI_CS1, 1); |
|||
u8g_SetPILevel(u8g, U8G_PI_CS2, 1); |
|||
} |
|||
else if ( arg_val == 1 ) |
|||
{ |
|||
/* enable */ |
|||
u8g_SetPILevel(u8g, U8G_PI_CS1, 0); |
|||
u8g_SetPILevel(u8g, U8G_PI_CS2, 1); |
|||
} |
|||
else if ( arg_val == 2 ) |
|||
{ |
|||
/* enable */ |
|||
u8g_SetPILevel(u8g, U8G_PI_CS1, 1); |
|||
u8g_SetPILevel(u8g, U8G_PI_CS2, 0); |
|||
} |
|||
else |
|||
{ |
|||
/* enable */ |
|||
u8g_SetPILevel(u8g, U8G_PI_CS1, 0); |
|||
u8g_SetPILevel(u8g, U8G_PI_CS2, 0); |
|||
} |
|||
break; |
|||
case U8G_COM_MSG_WRITE_BYTE: |
|||
u8g_com_atmega_parallel_write(u8g, arg_val); |
|||
break; |
|||
case U8G_COM_MSG_WRITE_SEQ: |
|||
{ |
|||
register uint8_t *ptr = arg_ptr; |
|||
while( arg_val > 0 ) |
|||
{ |
|||
u8g_com_atmega_parallel_write(u8g, *ptr++); |
|||
arg_val--; |
|||
} |
|||
} |
|||
break; |
|||
case U8G_COM_MSG_WRITE_SEQ_P: |
|||
{ |
|||
register uint8_t *ptr = arg_ptr; |
|||
while( arg_val > 0 ) |
|||
{ |
|||
u8g_com_atmega_parallel_write(u8g, u8g_pgm_read(ptr)); |
|||
ptr++; |
|||
arg_val--; |
|||
} |
|||
} |
|||
break; |
|||
case U8G_COM_MSG_ADDRESS: /* define cmd (arg_val = 0) or data mode (arg_val = 1) */ |
|||
u8g_SetPILevel(u8g, U8G_PI_DI, arg_val); |
|||
break; |
|||
case U8G_COM_MSG_RESET: |
|||
u8g_SetPILevel(u8g, U8G_PI_RESET, arg_val); |
|||
break; |
|||
} |
|||
return 1; |
|||
} |
|||
|
|||
#else |
|||
|
|||
uint8_t u8g_com_atmega_parallel_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_ptr) |
|||
{ |
|||
return 1; |
|||
} |
|||
|
|||
#endif /* ARDUINO */ |
|||
|
|||
@ -0,0 +1,205 @@ |
|||
/*
|
|||
|
|||
u8g_com_atmega_st7920_hw_spi.c |
|||
|
|||
Universal 8bit Graphics Library |
|||
|
|||
Copyright (c) 2011, olikraus@gmail.com |
|||
All rights reserved. |
|||
|
|||
Redistribution and use in source and binary forms, with or without modification, |
|||
are permitted provided that the following conditions are met: |
|||
|
|||
* Redistributions of source code must retain the above copyright notice, this list |
|||
of conditions and the following disclaimer. |
|||
|
|||
* Redistributions in binary form must reproduce the above copyright notice, this |
|||
list of conditions and the following disclaimer in the documentation and/or other |
|||
materials provided with the distribution. |
|||
|
|||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
|||
CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
|||
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
|||
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
|||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
|||
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
|||
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
|||
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
|||
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
|||
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF |
|||
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|||
|
|||
A special SPI interface for ST7920 controller with HW SPI Support |
|||
|
|||
Assumes, that |
|||
MOSI is at PORTB, Pin 3 |
|||
and |
|||
SCK is at PORTB, Pin 5 |
|||
|
|||
|
|||
*/ |
|||
|
|||
#include "u8g.h" |
|||
|
|||
#if defined(__AVR__) |
|||
#define U8G_ATMEGA_HW_SPI |
|||
|
|||
/* remove the definition for attiny */ |
|||
#if __AVR_ARCH__ == 2 |
|||
#undef U8G_ATMEGA_HW_SPI |
|||
#endif |
|||
#if __AVR_ARCH__ == 25 |
|||
#undef U8G_ATMEGA_HW_SPI |
|||
#endif |
|||
|
|||
#endif |
|||
|
|||
#if defined(U8G_ATMEGA_HW_SPI) |
|||
|
|||
#include <avr/interrupt.h> |
|||
#include <avr/io.h> |
|||
|
|||
static uint8_t u8g_atmega_st7920_hw_spi_shift_out(u8g_t *u8g, uint8_t val) U8G_NOINLINE; |
|||
static uint8_t u8g_atmega_st7920_hw_spi_shift_out(u8g_t *u8g, uint8_t val) |
|||
{ |
|||
/* send data */ |
|||
SPDR = val; |
|||
/* wait for transmission */ |
|||
while (!(SPSR & (1<<SPIF))) |
|||
; |
|||
/* clear the SPIF flag by reading SPDR */ |
|||
return SPDR; |
|||
} |
|||
|
|||
|
|||
static void u8g_com_atmega_st7920_write_byte_hw_spi(u8g_t *u8g, uint8_t rs, uint8_t val) U8G_NOINLINE; |
|||
static void u8g_com_atmega_st7920_write_byte_hw_spi(u8g_t *u8g, uint8_t rs, uint8_t val) |
|||
{ |
|||
uint8_t i; |
|||
|
|||
if ( rs == 0 ) |
|||
{ |
|||
/* command */ |
|||
u8g_atmega_st7920_hw_spi_shift_out(u8g, 0x0f8); |
|||
} |
|||
else if ( rs == 1 ) |
|||
{ |
|||
/* data */ |
|||
u8g_atmega_st7920_hw_spi_shift_out(u8g, 0x0fa); |
|||
} |
|||
|
|||
u8g_atmega_st7920_hw_spi_shift_out(u8g, val & 0x0f0); |
|||
u8g_atmega_st7920_hw_spi_shift_out(u8g, val << 4); |
|||
|
|||
for( i = 0; i < 4; i++ ) |
|||
u8g_10MicroDelay(); |
|||
} |
|||
|
|||
|
|||
uint8_t u8g_com_atmega_st7920_hw_spi_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_ptr) |
|||
{ |
|||
switch(msg) |
|||
{ |
|||
case U8G_COM_MSG_INIT: |
|||
u8g_SetPIOutput(u8g, U8G_PI_CS); |
|||
//u8g_SetPIOutput(u8g, U8G_PI_A0);
|
|||
|
|||
DDRB |= _BV(3); /* D0, MOSI */ |
|||
DDRB |= _BV(5); /* SCK */ |
|||
DDRB |= _BV(2); /* slave select */ |
|||
|
|||
PORTB &= ~_BV(3); /* D0, MOSI = 0 */ |
|||
PORTB &= ~_BV(5); /* SCK = 0 */ |
|||
u8g_SetPILevel(u8g, U8G_PI_CS, 1); |
|||
|
|||
/*
|
|||
SPR1 SPR0 |
|||
0 0 fclk/4 |
|||
0 1 fclk/16 |
|||
1 0 fclk/64 |
|||
1 1 fclk/128 |
|||
*/ |
|||
SPCR = 0; |
|||
|
|||
/* maybe set CPOL and CPHA to 1 */ |
|||
/* 20 Dez 2012: did set CPOL and CPHA to 1 in Arduino variant! */ |
|||
SPCR = (1<<SPE) | (1<<MSTR)|(0<<SPR1)|(0<<SPR0)|(0<<CPOL)|(0<<CPHA); |
|||
#ifdef U8G_HW_SPI_2X |
|||
SPSR = (1 << SPI2X); /* double speed, issue 89 */ |
|||
#endif |
|||
u8g->pin_list[U8G_PI_A0_STATE] = 0; /* inital RS state: command mode */ |
|||
break; |
|||
|
|||
case U8G_COM_MSG_STOP: |
|||
break; |
|||
|
|||
case U8G_COM_MSG_RESET: |
|||
u8g_SetPILevel(u8g, U8G_PI_RESET, arg_val); |
|||
break; |
|||
|
|||
case U8G_COM_MSG_ADDRESS: /* define cmd (arg_val = 0) or data mode (arg_val = 1) */ |
|||
u8g->pin_list[U8G_PI_A0_STATE] = arg_val; |
|||
break; |
|||
|
|||
case U8G_COM_MSG_CHIP_SELECT: |
|||
if ( arg_val == 0 ) |
|||
{ |
|||
/* disable, note: the st7920 has an active high chip select */ |
|||
u8g_SetPILevel(u8g, U8G_PI_CS, 0); |
|||
} |
|||
else |
|||
{ |
|||
/* u8g_SetPILevel(u8g, U8G_PI_SCK, 0 ); */ |
|||
/* enable */ |
|||
u8g_SetPILevel(u8g, U8G_PI_CS, 1); /* CS = 1 (high active) */ |
|||
} |
|||
break; |
|||
|
|||
|
|||
case U8G_COM_MSG_WRITE_BYTE: |
|||
u8g_com_atmega_st7920_write_byte_hw_spi(u8g, u8g->pin_list[U8G_PI_A0_STATE], arg_val); |
|||
//u8g->pin_list[U8G_PI_A0_STATE] = 2;
|
|||
break; |
|||
|
|||
case U8G_COM_MSG_WRITE_SEQ: |
|||
{ |
|||
register uint8_t *ptr = arg_ptr; |
|||
while( arg_val > 0 ) |
|||
{ |
|||
u8g_com_atmega_st7920_write_byte_hw_spi(u8g, u8g->pin_list[U8G_PI_A0_STATE], *ptr++); |
|||
//u8g->pin_list[U8G_PI_A0_STATE] = 2;
|
|||
arg_val--; |
|||
} |
|||
} |
|||
break; |
|||
|
|||
case U8G_COM_MSG_WRITE_SEQ_P: |
|||
{ |
|||
register uint8_t *ptr = arg_ptr; |
|||
while( arg_val > 0 ) |
|||
{ |
|||
u8g_com_atmega_st7920_write_byte_hw_spi(u8g, u8g->pin_list[U8G_PI_A0_STATE], u8g_pgm_read(ptr)); |
|||
//u8g->pin_list[U8G_PI_A0_STATE] = 2;
|
|||
ptr++; |
|||
arg_val--; |
|||
} |
|||
} |
|||
break; |
|||
} |
|||
return 1; |
|||
} |
|||
|
|||
#else |
|||
|
|||
|
|||
uint8_t u8g_com_atmega_st7920_hw_spi_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_ptr) |
|||
{ |
|||
return 1; |
|||
} |
|||
|
|||
|
|||
#endif |
|||
|
|||
|
|||
@ -0,0 +1,170 @@ |
|||
/*
|
|||
|
|||
u8g_com_atmega_st7920_spi.c |
|||
|
|||
Universal 8bit Graphics Library |
|||
|
|||
Copyright (c) 2011, olikraus@gmail.com |
|||
All rights reserved. |
|||
|
|||
Redistribution and use in source and binary forms, with or without modification, |
|||
are permitted provided that the following conditions are met: |
|||
|
|||
* Redistributions of source code must retain the above copyright notice, this list |
|||
of conditions and the following disclaimer. |
|||
|
|||
* Redistributions in binary form must reproduce the above copyright notice, this |
|||
list of conditions and the following disclaimer in the documentation and/or other |
|||
materials provided with the distribution. |
|||
|
|||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
|||
CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
|||
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
|||
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
|||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
|||
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
|||
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
|||
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
|||
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
|||
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF |
|||
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|||
|
|||
A special SPI interface for ST7920 controller |
|||
|
|||
*/ |
|||
|
|||
#include "u8g.h" |
|||
|
|||
#if defined(__AVR__) |
|||
|
|||
static void u8g_atmega_st7920_sw_spi_shift_out(u8g_t *u8g, uint8_t val) U8G_NOINLINE; |
|||
static void u8g_atmega_st7920_sw_spi_shift_out(u8g_t *u8g, uint8_t val) |
|||
{ |
|||
uint8_t i = 8; |
|||
do |
|||
{ |
|||
u8g_SetPILevel(u8g, U8G_PI_MOSI, val & 128 ); |
|||
val <<= 1; |
|||
u8g_SetPILevel(u8g, U8G_PI_SCK, 1 ); |
|||
u8g_MicroDelay(); /* 15 Aug 2012: added for high speed uC */ |
|||
u8g_SetPILevel(u8g, U8G_PI_SCK, 0 ); |
|||
u8g_MicroDelay(); /* 15 Aug 2012: added for high speed uC */ |
|||
i--; |
|||
} while( i != 0 ); |
|||
} |
|||
|
|||
static void u8g_com_atmega_st7920_write_byte(u8g_t *u8g, uint8_t rs, uint8_t val) U8G_NOINLINE; |
|||
static void u8g_com_atmega_st7920_write_byte(u8g_t *u8g, uint8_t rs, uint8_t val) |
|||
{ |
|||
uint8_t i; |
|||
|
|||
if ( rs == 0 ) |
|||
{ |
|||
/* command */ |
|||
u8g_atmega_st7920_sw_spi_shift_out(u8g, 0x0f8); |
|||
} |
|||
else if ( rs == 1 ) |
|||
{ |
|||
/* data */ |
|||
u8g_atmega_st7920_sw_spi_shift_out(u8g, 0x0fa); |
|||
} |
|||
|
|||
u8g_atmega_st7920_sw_spi_shift_out(u8g, val & 0x0f0); |
|||
u8g_atmega_st7920_sw_spi_shift_out(u8g, val << 4); |
|||
|
|||
for( i = 0; i < 4; i++ ) |
|||
u8g_10MicroDelay(); |
|||
} |
|||
|
|||
|
|||
uint8_t u8g_com_atmega_st7920_sw_spi_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_ptr) |
|||
{ |
|||
switch(msg) |
|||
{ |
|||
case U8G_COM_MSG_INIT: |
|||
u8g_SetPIOutput(u8g, U8G_PI_SCK); |
|||
u8g_SetPIOutput(u8g, U8G_PI_MOSI); |
|||
/* u8g_SetPIOutput(u8g, U8G_PI_A0); */ |
|||
u8g_SetPIOutput(u8g, U8G_PI_CS); |
|||
u8g_SetPIOutput(u8g, U8G_PI_RESET); |
|||
|
|||
u8g_SetPILevel(u8g, U8G_PI_SCK, 0 ); |
|||
u8g_SetPILevel(u8g, U8G_PI_MOSI, 0 ); |
|||
u8g_SetPILevel(u8g, U8G_PI_CS, 0 ); |
|||
/* u8g_SetPILevel(u8g, U8G_PI_A0, 0); */ |
|||
|
|||
u8g->pin_list[U8G_PI_A0_STATE] = 0; /* inital RS state: command mode */ |
|||
break; |
|||
|
|||
case U8G_COM_MSG_STOP: |
|||
break; |
|||
|
|||
case U8G_COM_MSG_RESET: |
|||
u8g_SetPILevel(u8g, U8G_PI_RESET, arg_val); |
|||
break; |
|||
|
|||
case U8G_COM_MSG_ADDRESS: /* define cmd (arg_val = 0) or data mode (arg_val = 1) */ |
|||
u8g->pin_list[U8G_PI_A0_STATE] = arg_val; |
|||
break; |
|||
|
|||
case U8G_COM_MSG_CHIP_SELECT: |
|||
if ( arg_val == 0 ) |
|||
{ |
|||
/* disable, note: the st7920 has an active high chip select */ |
|||
u8g_SetPILevel(u8g, U8G_PI_CS, 0); |
|||
} |
|||
else |
|||
{ |
|||
/* u8g_SetPILevel(u8g, U8G_PI_SCK, 0 ); */ |
|||
/* enable */ |
|||
u8g_SetPILevel(u8g, U8G_PI_CS, 1); /* CS = 1 (high active) */ |
|||
} |
|||
break; |
|||
|
|||
|
|||
case U8G_COM_MSG_WRITE_BYTE: |
|||
u8g_com_atmega_st7920_write_byte(u8g, u8g->pin_list[U8G_PI_A0_STATE], arg_val); |
|||
u8g->pin_list[U8G_PI_A0_STATE] = 2; |
|||
break; |
|||
|
|||
case U8G_COM_MSG_WRITE_SEQ: |
|||
{ |
|||
register uint8_t *ptr = arg_ptr; |
|||
while( arg_val > 0 ) |
|||
{ |
|||
u8g_com_atmega_st7920_write_byte(u8g, u8g->pin_list[U8G_PI_A0_STATE], *ptr++); |
|||
u8g->pin_list[U8G_PI_A0_STATE] = 2; |
|||
arg_val--; |
|||
} |
|||
} |
|||
break; |
|||
|
|||
case U8G_COM_MSG_WRITE_SEQ_P: |
|||
{ |
|||
register uint8_t *ptr = arg_ptr; |
|||
while( arg_val > 0 ) |
|||
{ |
|||
u8g_com_atmega_st7920_write_byte(u8g, u8g->pin_list[U8G_PI_A0_STATE], u8g_pgm_read(ptr)); |
|||
u8g->pin_list[U8G_PI_A0_STATE] = 2; |
|||
ptr++; |
|||
arg_val--; |
|||
} |
|||
} |
|||
break; |
|||
} |
|||
return 1; |
|||
} |
|||
|
|||
#else |
|||
|
|||
|
|||
uint8_t u8g_com_atmega_st7920_sw_spi_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_ptr) |
|||
{ |
|||
return 1; |
|||
} |
|||
|
|||
|
|||
#endif |
|||
|
|||
@ -0,0 +1,141 @@ |
|||
/*
|
|||
|
|||
u8g_com_atmega_sw_spi.c |
|||
|
|||
Universal 8bit Graphics Library |
|||
|
|||
Copyright (c) 2012, olikraus@gmail.com |
|||
All rights reserved. |
|||
|
|||
Redistribution and use in source and binary forms, with or without modification, |
|||
are permitted provided that the following conditions are met: |
|||
|
|||
* Redistributions of source code must retain the above copyright notice, this list |
|||
of conditions and the following disclaimer. |
|||
|
|||
* Redistributions in binary form must reproduce the above copyright notice, this |
|||
list of conditions and the following disclaimer in the documentation and/or other |
|||
materials provided with the distribution. |
|||
|
|||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
|||
CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
|||
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
|||
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
|||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
|||
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
|||
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
|||
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
|||
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
|||
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF |
|||
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|||
|
|||
|
|||
*/ |
|||
|
|||
#include "u8g.h" |
|||
|
|||
#if defined(__AVR__) |
|||
|
|||
static void u8g_atmega_sw_spi_shift_out(u8g_t *u8g, uint8_t val) U8G_NOINLINE; |
|||
static void u8g_atmega_sw_spi_shift_out(u8g_t *u8g, uint8_t val) |
|||
{ |
|||
uint8_t i = 8; |
|||
do |
|||
{ |
|||
u8g_SetPILevel(u8g, U8G_PI_MOSI, val & 128 ); |
|||
val <<= 1; |
|||
u8g_SetPILevel(u8g, U8G_PI_SCK, 1 ); |
|||
u8g_MicroDelay(); /* 15 Aug 2012: added for high speed uC */ |
|||
u8g_SetPILevel(u8g, U8G_PI_SCK, 0 ); |
|||
u8g_MicroDelay(); /* 15 Aug 2012: added for high speed uC */ |
|||
i--; |
|||
} while( i != 0 ); |
|||
} |
|||
|
|||
uint8_t u8g_com_atmega_sw_spi_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_ptr) |
|||
{ |
|||
switch(msg) |
|||
{ |
|||
case U8G_COM_MSG_INIT: |
|||
u8g_SetPIOutput(u8g, U8G_PI_SCK); |
|||
u8g_SetPIOutput(u8g, U8G_PI_MOSI); |
|||
u8g_SetPIOutput(u8g, U8G_PI_A0); |
|||
u8g_SetPIOutput(u8g, U8G_PI_CS); |
|||
u8g_SetPIOutput(u8g, U8G_PI_RESET); |
|||
|
|||
u8g_SetPILevel(u8g, U8G_PI_SCK, 0 ); |
|||
u8g_SetPILevel(u8g, U8G_PI_MOSI, 0 ); |
|||
u8g_SetPILevel(u8g, U8G_PI_CS, 1 ); |
|||
u8g_SetPILevel(u8g, U8G_PI_A0, 0); |
|||
break; |
|||
|
|||
case U8G_COM_MSG_STOP: |
|||
break; |
|||
|
|||
case U8G_COM_MSG_ADDRESS: /* define cmd (arg_val = 0) or data mode (arg_val = 1) */ |
|||
u8g_SetPILevel(u8g, U8G_PI_A0, arg_val); |
|||
break; |
|||
|
|||
case U8G_COM_MSG_CHIP_SELECT: |
|||
|
|||
if ( arg_val == 0 ) |
|||
{ |
|||
/* disable */ |
|||
u8g_SetPILevel(u8g, U8G_PI_CS, 1); |
|||
} |
|||
else |
|||
{ |
|||
u8g_SetPILevel(u8g, U8G_PI_SCK, 0 ); |
|||
/* enable */ |
|||
u8g_SetPILevel(u8g, U8G_PI_CS, 0); /* CS = 0 (low active) */ |
|||
} |
|||
break; |
|||
|
|||
case U8G_COM_MSG_RESET: |
|||
u8g_SetPILevel(u8g, U8G_PI_RESET, arg_val); |
|||
break; |
|||
|
|||
|
|||
case U8G_COM_MSG_WRITE_BYTE: |
|||
u8g_atmega_sw_spi_shift_out(u8g, arg_val); |
|||
break; |
|||
|
|||
case U8G_COM_MSG_WRITE_SEQ: |
|||
{ |
|||
register uint8_t *ptr = arg_ptr; |
|||
while( arg_val > 0 ) |
|||
{ |
|||
u8g_atmega_sw_spi_shift_out(u8g, *ptr++); |
|||
arg_val--; |
|||
} |
|||
} |
|||
break; |
|||
|
|||
case U8G_COM_MSG_WRITE_SEQ_P: |
|||
{ |
|||
register uint8_t *ptr = arg_ptr; |
|||
while( arg_val > 0 ) |
|||
{ |
|||
u8g_atmega_sw_spi_shift_out(u8g, u8g_pgm_read(ptr)); |
|||
ptr++; |
|||
arg_val--; |
|||
} |
|||
} |
|||
break; |
|||
} |
|||
return 1; |
|||
} |
|||
|
|||
#else |
|||
|
|||
|
|||
uint8_t u8g_com_atmega_sw_spi_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_ptr) |
|||
{ |
|||
return 1; |
|||
} |
|||
|
|||
|
|||
#endif |
|||
|
|||
@ -0,0 +1,249 @@ |
|||
/*
|
|||
|
|||
u8g_com_i2c.c |
|||
|
|||
generic i2c interface |
|||
|
|||
Universal 8bit Graphics Library |
|||
|
|||
Copyright (c) 2011, olikraus@gmail.com |
|||
All rights reserved. |
|||
|
|||
Redistribution and use in source and binary forms, with or without modification, |
|||
are permitted provided that the following conditions are met: |
|||
|
|||
* Redistributions of source code must retain the above copyright notice, this list |
|||
of conditions and the following disclaimer. |
|||
|
|||
* Redistributions in binary form must reproduce the above copyright notice, this |
|||
list of conditions and the following disclaimer in the documentation and/or other |
|||
materials provided with the distribution. |
|||
|
|||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
|||
CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
|||
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
|||
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
|||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
|||
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
|||
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
|||
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
|||
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
|||
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF |
|||
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|||
|
|||
*/ |
|||
|
|||
#include "u8g.h" |
|||
|
|||
static uint8_t u8g_i2c_err_code; |
|||
|
|||
/*
|
|||
position values |
|||
1: start condition |
|||
2: sla transfer |
|||
*/ |
|||
static uint8_t u8g_i2c_err_pos; |
|||
|
|||
|
|||
void u8g_i2c_clear_error(void) |
|||
{ |
|||
u8g_i2c_err_code = U8G_I2C_ERR_NONE; |
|||
u8g_i2c_err_pos = 0; |
|||
} |
|||
|
|||
uint8_t u8g_i2c_get_error(void) |
|||
{ |
|||
return u8g_i2c_err_code; |
|||
} |
|||
|
|||
uint8_t u8g_i2c_get_err_pos(void) |
|||
{ |
|||
return u8g_i2c_err_pos; |
|||
} |
|||
|
|||
static void u8g_i2c_set_error(uint8_t code, uint8_t pos) |
|||
{ |
|||
if ( u8g_i2c_err_code > 0 ) |
|||
return; |
|||
u8g_i2c_err_code |= code; |
|||
u8g_i2c_err_pos = pos; |
|||
} |
|||
|
|||
|
|||
|
|||
#if defined(__AVR__) |
|||
#define U8G_ATMEGA_HW_TWI |
|||
|
|||
/* remove the definition for attiny */ |
|||
#if __AVR_ARCH__ == 2 |
|||
#undef U8G_ATMEGA_HW_TWI |
|||
#endif |
|||
#if __AVR_ARCH__ == 25 |
|||
#undef U8G_ATMEGA_HW_TWI |
|||
#endif |
|||
#endif |
|||
|
|||
#if defined(U8G_ATMEGA_HW_TWI) |
|||
|
|||
#include <avr/io.h> |
|||
#include <util/twi.h> |
|||
|
|||
|
|||
|
|||
void u8g_i2c_init(uint8_t options) |
|||
{ |
|||
/*
|
|||
TWBR: bit rate register |
|||
TWSR: status register (contains preselector bits) |
|||
|
|||
prescalar |
|||
0 1 |
|||
1 4 |
|||
2 16 |
|||
3 64 |
|||
|
|||
f = F_CPU/(16+2*TWBR*prescalar) |
|||
|
|||
F_CPU = 16MHz |
|||
TWBR = 152; |
|||
TWSR = 0; |
|||
--> 50KHz |
|||
|
|||
TWBR = 72; |
|||
TWSR = 0; |
|||
--> 100KHz |
|||
|
|||
F_CPU/(2*100000)-8 --> calculate TWBR value for 100KHz |
|||
*/ |
|||
TWSR = 0; |
|||
TWBR = F_CPU/(2*100000)-8; |
|||
u8g_i2c_clear_error(); |
|||
} |
|||
|
|||
uint8_t u8g_i2c_wait(uint8_t mask, uint8_t pos) |
|||
{ |
|||
volatile uint16_t cnt = 2000; /* timout value should be > 280 for 50KHz Bus and 16 Mhz CPU, however the start condition might need longer */ |
|||
while( !(TWCR & mask) ) |
|||
{ |
|||
if ( cnt == 0 ) |
|||
{ |
|||
u8g_i2c_set_error(U8G_I2C_ERR_TIMEOUT, pos); |
|||
return 0; /* error */ |
|||
} |
|||
cnt--; |
|||
} |
|||
return 1; /* all ok */ |
|||
} |
|||
|
|||
/* sla includes all 8 bits (with r/w bit), assums master transmit */ |
|||
uint8_t u8g_i2c_start(uint8_t sla) |
|||
{ |
|||
register uint8_t status; |
|||
|
|||
/* send start */ |
|||
TWCR = _BV(TWINT) | _BV(TWSTA) | _BV(TWEN); |
|||
|
|||
/* wait */ |
|||
if ( u8g_i2c_wait(_BV(TWINT), 1) == 0 ) |
|||
return 0; |
|||
|
|||
status = TW_STATUS; |
|||
|
|||
/* check status after start */ |
|||
if ( status != TW_START && status != TW_REP_START ) |
|||
{ |
|||
u8g_i2c_set_error(U8G_I2C_ERR_BUS, 1); |
|||
return 0; |
|||
} |
|||
|
|||
/* set slave address */ |
|||
TWDR = sla; |
|||
|
|||
/* enable sla transfer */ |
|||
TWCR = _BV(TWINT) | _BV(TWEN); |
|||
|
|||
/* wait */ |
|||
if ( u8g_i2c_wait(_BV(TWINT), 2) == 0 ) |
|||
return 0; |
|||
status = TW_STATUS; |
|||
|
|||
/* check status after sla */ |
|||
if ( status != TW_MT_SLA_ACK ) |
|||
{ |
|||
u8g_i2c_set_error(U8G_I2C_ERR_BUS, 2); |
|||
return 0; |
|||
} |
|||
|
|||
return 1; |
|||
} |
|||
|
|||
uint8_t u8g_i2c_send_byte(uint8_t data) |
|||
{ |
|||
register uint8_t status; |
|||
TWDR = data; |
|||
TWCR = _BV(TWINT) | _BV(TWEN); |
|||
if ( u8g_i2c_wait(_BV(TWINT), 3) == 0 ) |
|||
return 0; |
|||
status = TW_STATUS; |
|||
|
|||
if ( status != TW_MT_DATA_ACK ) |
|||
{ |
|||
u8g_i2c_set_error(U8G_I2C_ERR_BUS, 3); |
|||
return 0; |
|||
} |
|||
|
|||
return 1; |
|||
} |
|||
|
|||
void u8g_i2c_stop(void) |
|||
{ |
|||
/* write stop */ |
|||
TWCR = _BV(TWINT) | _BV(TWEN) | _BV(TWSTO); |
|||
|
|||
/* no error is checked for the stop condition */ |
|||
u8g_i2c_wait(_BV(TWSTO), 4); |
|||
|
|||
} |
|||
|
|||
/*
|
|||
void twi_send(uint8_t adr, uint8_t data1, uint8_t data2) |
|||
{ |
|||
u8g_i2c_start(adr<<1); |
|||
u8g_i2c_send_byte(data1); |
|||
u8g_i2c_send_byte(data2); |
|||
u8g_i2c_stop(); |
|||
} |
|||
*/ |
|||
|
|||
#else |
|||
|
|||
/* empty interface */ |
|||
|
|||
void u8g_i2c_init(uint8_t options) |
|||
{ |
|||
u8g_i2c_clear_error(); |
|||
} |
|||
|
|||
uint8_t u8g_i2c_wait(uint8_t mask, uint8_t pos) |
|||
{ |
|||
return 1; |
|||
} |
|||
|
|||
uint8_t u8g_i2c_start(uint8_t sla) |
|||
{ |
|||
return 1; |
|||
} |
|||
uint8_t u8g_i2c_send_byte(uint8_t data) |
|||
{ |
|||
return 1; |
|||
} |
|||
|
|||
void u8g_i2c_stop(void) |
|||
{ |
|||
} |
|||
|
|||
|
|||
#endif |
|||
|
|||
@ -0,0 +1,218 @@ |
|||
/*
|
|||
|
|||
u8g_com_io.c |
|||
|
|||
abstraction layer for low level i/o |
|||
|
|||
Universal 8bit Graphics Library |
|||
|
|||
Copyright (c) 2012, olikraus@gmail.com |
|||
All rights reserved. |
|||
|
|||
Redistribution and use in source and binary forms, with or without modification, |
|||
are permitted provided that the following conditions are met: |
|||
|
|||
* Redistributions of source code must retain the above copyright notice, this list |
|||
of conditions and the following disclaimer. |
|||
|
|||
* Redistributions in binary form must reproduce the above copyright notice, this |
|||
list of conditions and the following disclaimer in the documentation and/or other |
|||
materials provided with the distribution. |
|||
|
|||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
|||
CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
|||
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
|||
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
|||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
|||
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
|||
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
|||
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
|||
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
|||
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF |
|||
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|||
|
|||
|
|||
*/ |
|||
|
|||
#include "u8g.h" |
|||
|
|||
#if defined(__AVR__) |
|||
|
|||
#include <avr/interrupt.h> |
|||
#include <avr/io.h> |
|||
|
|||
typedef volatile uint8_t * IO_PTR; |
|||
|
|||
/* create internal pin number */ |
|||
uint8_t u8g_Pin(uint8_t port, uint8_t bitpos) |
|||
{ |
|||
port <<= 3; |
|||
port += bitpos; |
|||
return port; |
|||
} |
|||
|
|||
const IO_PTR u8g_avr_ddr_P[] PROGMEM = { |
|||
#ifdef DDRA |
|||
&DDRA, |
|||
#else |
|||
0, |
|||
#endif |
|||
&DDRB, |
|||
#ifdef DDRC |
|||
&DDRC, |
|||
#ifdef DDRD |
|||
&DDRD, |
|||
#ifdef DDRE |
|||
&DDRE, |
|||
#ifdef DDRF |
|||
&DDRF, |
|||
#ifdef DDRG |
|||
&DDRG, |
|||
#ifdef DDRH |
|||
&DDRH, |
|||
#endif |
|||
#endif |
|||
#endif |
|||
#endif |
|||
#endif |
|||
#endif |
|||
}; |
|||
|
|||
|
|||
const IO_PTR u8g_avr_port_P[] PROGMEM = { |
|||
#ifdef PORTA |
|||
&PORTA, |
|||
#else |
|||
0, |
|||
#endif |
|||
&PORTB, |
|||
#ifdef PORTC |
|||
&PORTC, |
|||
#ifdef PORTD |
|||
&PORTD, |
|||
#ifdef PORTE |
|||
&PORTE, |
|||
#ifdef PORTF |
|||
&PORTF, |
|||
#ifdef PORTG |
|||
&PORTG, |
|||
#ifdef PORTH |
|||
&PORTH, |
|||
#endif |
|||
#endif |
|||
#endif |
|||
#endif |
|||
#endif |
|||
#endif |
|||
}; |
|||
|
|||
const IO_PTR u8g_avr_pin_P[] PROGMEM = { |
|||
#ifdef PINA |
|||
&PINA, |
|||
#else |
|||
0, |
|||
#endif |
|||
&PINB, |
|||
#ifdef PINC |
|||
&PINC, |
|||
#ifdef PIND |
|||
&PIND, |
|||
#ifdef PINE |
|||
&PINE, |
|||
#ifdef PINF |
|||
&PINF, |
|||
#ifdef PING |
|||
&PING, |
|||
#ifdef PINH |
|||
&PINH, |
|||
#endif |
|||
#endif |
|||
#endif |
|||
#endif |
|||
#endif |
|||
#endif |
|||
}; |
|||
|
|||
static volatile uint8_t *u8g_get_avr_io_ptr(const IO_PTR *base, uint8_t offset) |
|||
{ |
|||
volatile uint8_t * tmp; |
|||
base += offset; |
|||
memcpy_P(&tmp, base, sizeof(volatile uint8_t * PROGMEM)); |
|||
return tmp; |
|||
} |
|||
|
|||
/* set direction to output of the specified pin (internal pin number) */ |
|||
void u8g_SetPinOutput(uint8_t internal_pin_number) |
|||
{ |
|||
*u8g_get_avr_io_ptr(u8g_avr_ddr_P, internal_pin_number>>3) |= _BV(internal_pin_number&7); |
|||
} |
|||
|
|||
void u8g_SetPinInput(uint8_t internal_pin_number) |
|||
{ |
|||
*u8g_get_avr_io_ptr(u8g_avr_ddr_P, internal_pin_number>>3) &= ~_BV(internal_pin_number&7); |
|||
} |
|||
|
|||
void u8g_SetPinLevel(uint8_t internal_pin_number, uint8_t level) |
|||
{ |
|||
volatile uint8_t * tmp = u8g_get_avr_io_ptr(u8g_avr_port_P, internal_pin_number>>3); |
|||
|
|||
if ( level == 0 ) |
|||
*tmp &= ~_BV(internal_pin_number&7); |
|||
else |
|||
*tmp |= _BV(internal_pin_number&7); |
|||
} |
|||
|
|||
uint8_t u8g_GetPinLevel(uint8_t internal_pin_number) |
|||
{ |
|||
volatile uint8_t * tmp = u8g_get_avr_io_ptr(u8g_avr_pin_P, internal_pin_number>>3); |
|||
if ( ((*tmp) & _BV(internal_pin_number&7)) != 0 ) |
|||
return 1; |
|||
return 0; |
|||
} |
|||
|
|||
#else |
|||
|
|||
uint8_t u8g_Pin(uint8_t port, uint8_t bitpos) |
|||
{ |
|||
port <<= 3; |
|||
port += bitpos; |
|||
return port; |
|||
} |
|||
|
|||
void u8g_SetPinOutput(uint8_t internal_pin_number) |
|||
{ |
|||
} |
|||
|
|||
void u8g_SetPinInput(uint8_t internal_pin_number) |
|||
{ |
|||
} |
|||
|
|||
void u8g_SetPinLevel(uint8_t internal_pin_number, uint8_t level) |
|||
{ |
|||
} |
|||
|
|||
uint8_t u8g_GetPinLevel(uint8_t internal_pin_number) |
|||
{ |
|||
return 0; |
|||
} |
|||
|
|||
#endif |
|||
|
|||
|
|||
void u8g_SetPIOutput(u8g_t *u8g, uint8_t pi) |
|||
{ |
|||
uint8_t pin; |
|||
pin = u8g->pin_list[pi]; |
|||
if ( pin != U8G_PIN_NONE ) |
|||
u8g_SetPinOutput(pin); |
|||
} |
|||
|
|||
void u8g_SetPILevel(u8g_t *u8g, uint8_t pi, uint8_t level) |
|||
{ |
|||
uint8_t pin; |
|||
pin = u8g->pin_list[pi]; |
|||
if ( pin != U8G_PIN_NONE ) |
|||
u8g_SetPinLevel(pin, level); |
|||
} |
|||
@ -0,0 +1,63 @@ |
|||
/*
|
|||
|
|||
u8g_com_null.c |
|||
|
|||
communication null device |
|||
|
|||
Universal 8bit Graphics Library |
|||
|
|||
Copyright (c) 2011, olikraus@gmail.com |
|||
All rights reserved. |
|||
|
|||
Redistribution and use in source and binary forms, with or without modification, |
|||
are permitted provided that the following conditions are met: |
|||
|
|||
* Redistributions of source code must retain the above copyright notice, this list |
|||
of conditions and the following disclaimer. |
|||
|
|||
* Redistributions in binary form must reproduce the above copyright notice, this |
|||
list of conditions and the following disclaimer in the documentation and/or other |
|||
materials provided with the distribution. |
|||
|
|||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
|||
CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
|||
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
|||
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
|||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
|||
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
|||
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
|||
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
|||
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
|||
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF |
|||
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|||
|
|||
|
|||
*/ |
|||
|
|||
#include "u8g.h" |
|||
|
|||
uint8_t u8g_com_null_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_ptr) |
|||
{ |
|||
switch(msg) |
|||
{ |
|||
case U8G_COM_MSG_INIT: |
|||
break; |
|||
case U8G_COM_MSG_STOP: |
|||
break; |
|||
|
|||
|
|||
case U8G_COM_MSG_CHIP_SELECT: |
|||
/* arg_val contains the chip number, which should be enabled */ |
|||
break; |
|||
|
|||
|
|||
case U8G_COM_MSG_WRITE_BYTE: |
|||
break; |
|||
case U8G_COM_MSG_WRITE_SEQ: |
|||
break; |
|||
} |
|||
return 1; |
|||
} |
|||
|
|||
@ -0,0 +1,99 @@ |
|||
/*
|
|||
|
|||
u8g_cursor.c |
|||
|
|||
Universal 8bit Graphics Library |
|||
|
|||
Copyright (c) 2011, olikraus@gmail.com |
|||
All rights reserved. |
|||
|
|||
Redistribution and use in source and binary forms, with or without modification, |
|||
are permitted provided that the following conditions are met: |
|||
|
|||
* Redistributions of source code must retain the above copyright notice, this list |
|||
of conditions and the following disclaimer. |
|||
|
|||
* Redistributions in binary form must reproduce the above copyright notice, this |
|||
list of conditions and the following disclaimer in the documentation and/or other |
|||
materials provided with the distribution. |
|||
|
|||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
|||
CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
|||
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
|||
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
|||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
|||
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
|||
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
|||
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
|||
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
|||
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF |
|||
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|||
|
|||
|
|||
*/ |
|||
|
|||
#include "u8g.h" |
|||
|
|||
void u8g_SetCursorFont(u8g_t *u8g, const u8g_pgm_uint8_t *cursor_font) |
|||
{ |
|||
u8g->cursor_font = cursor_font; |
|||
} |
|||
|
|||
void u8g_SetCursorStyle(u8g_t *u8g, uint8_t encoding) |
|||
{ |
|||
u8g->cursor_encoding = encoding; |
|||
} |
|||
|
|||
void u8g_SetCursorColor(u8g_t *u8g, uint8_t fg, uint8_t bg) |
|||
{ |
|||
u8g->cursor_bg_color = bg; |
|||
u8g->cursor_fg_color = fg; |
|||
} |
|||
|
|||
void u8g_SetCursorPos(u8g_t *u8g, u8g_uint_t cursor_x, u8g_uint_t cursor_y) |
|||
{ |
|||
u8g->cursor_x = cursor_x; |
|||
u8g->cursor_y = cursor_y; |
|||
} |
|||
|
|||
void u8g_EnableCursor(u8g_t *u8g) |
|||
{ |
|||
u8g->cursor_fn = u8g_DrawCursor; |
|||
} |
|||
|
|||
void u8g_DisableCursor(u8g_t *u8g) |
|||
{ |
|||
u8g->cursor_fn = (u8g_draw_cursor_fn)0; |
|||
} |
|||
|
|||
void u8g_DrawCursor(u8g_t *u8g) |
|||
{ |
|||
const u8g_pgm_uint8_t *font; |
|||
uint8_t color; |
|||
uint8_t encoding = u8g->cursor_encoding; |
|||
|
|||
/* get current values */ |
|||
color = u8g_GetColorIndex(u8g); |
|||
font = u8g->font; |
|||
|
|||
/* draw cursor */ |
|||
u8g->font = u8g->cursor_font; |
|||
encoding++; |
|||
u8g_SetColorIndex(u8g, u8g->cursor_bg_color); |
|||
/* 27. Jan 2013: replaced call to u8g_DrawGlyph with call to u8g_draw_glyph */ |
|||
/* required, because y adjustment should not happen to the cursor fonts */ |
|||
u8g_draw_glyph(u8g, u8g->cursor_x, u8g->cursor_y, encoding); |
|||
encoding--; |
|||
u8g_SetColorIndex(u8g, u8g->cursor_fg_color); |
|||
/* 27. Jan 2013: replaced call to u8g_DrawGlyph with call to u8g_draw_glyph */ |
|||
/* required, because y adjustment should not happen to the cursor fonts */ |
|||
/* u8g_DrawGlyph(u8g, u8g->cursor_x, u8g->cursor_y, encoding); */ |
|||
u8g_draw_glyph(u8g, u8g->cursor_x, u8g->cursor_y, encoding); |
|||
|
|||
/* restore previous values */ |
|||
u8g->font = font; |
|||
u8g_SetColorIndex(u8g, color); |
|||
} |
|||
|
|||
@ -0,0 +1,215 @@ |
|||
/*
|
|||
|
|||
u8g_delay.c |
|||
|
|||
Universal 8bit Graphics Library |
|||
|
|||
Copyright (c) 2011, olikraus@gmail.com |
|||
All rights reserved. |
|||
|
|||
Redistribution and use in source and binary forms, with or without modification, |
|||
are permitted provided that the following conditions are met: |
|||
|
|||
* Redistributions of source code must retain the above copyright notice, this list |
|||
of conditions and the following disclaimer. |
|||
|
|||
* Redistributions in binary form must reproduce the above copyright notice, this |
|||
list of conditions and the following disclaimer in the documentation and/or other |
|||
materials provided with the distribution. |
|||
|
|||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
|||
CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
|||
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
|||
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
|||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
|||
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
|||
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
|||
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
|||
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
|||
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF |
|||
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|||
|
|||
|
|||
*/ |
|||
|
|||
|
|||
#include "u8g.h" |
|||
|
|||
/*==== Part 1: Derive suitable delay procedure ====*/ |
|||
|
|||
#if defined(ARDUINO) |
|||
# if defined(__AVR__) |
|||
# define USE_AVR_DELAY |
|||
# elif defined(__PIC32MX) |
|||
# define USE_PIC32_DELAY |
|||
# elif defined(__arm__) /* Arduino Due */ |
|||
# define USE_ARDUINO_DELAY |
|||
# else |
|||
# define USE_ARDUINO_DELAY |
|||
# endif |
|||
#elif defined(__AVR__) |
|||
# define USE_AVR_DELAY |
|||
#elif defined(__18CXX) |
|||
# define USE_PIC18_DELAY |
|||
#else |
|||
# define USE_DUMMY_DELAY |
|||
#endif |
|||
|
|||
|
|||
|
|||
/*==== Part 2: Definition of the delay procedures ====*/ |
|||
|
|||
/*== AVR Delay ==*/ |
|||
|
|||
#if defined(USE_AVR_DELAY) |
|||
#include <avr/interrupt.h> |
|||
#include <avr/io.h> |
|||
#include <util/delay.h> |
|||
|
|||
/*
|
|||
Delay by the provided number of milliseconds. |
|||
Thus, a 16 bit value will allow a delay of 0..65 seconds |
|||
Makes use of the _delay_loop_2 |
|||
|
|||
_delay_loop_2 will do a delay of n * 4 prozessor cycles. |
|||
with f = F_CPU cycles per second, |
|||
n = f / (1000 * 4 ) |
|||
with f = 16000000 the result is 4000 |
|||
with f = 1000000 the result is 250 |
|||
|
|||
the millisec loop, gcc requires the following overhead: |
|||
- movev 1 |
|||
- subwi 2x2 |
|||
- bne i 2 |
|||
==> 7 cycles |
|||
==> must be devided by 4, rounded up 7/4 = 2 |
|||
*/ |
|||
void u8g_Delay(uint16_t val) |
|||
{ |
|||
/* old version did a call to the arduino lib: delay(val); */ |
|||
while( val != 0 ) |
|||
{ |
|||
_delay_loop_2( (F_CPU / 4000 ) -2); |
|||
val--; |
|||
} |
|||
} |
|||
|
|||
/* delay by one micro second */ |
|||
void u8g_MicroDelay(void) |
|||
{ |
|||
#if (F_CPU / 4000000 ) > 0 |
|||
_delay_loop_2( (F_CPU / 4000000 ) ); |
|||
#endif |
|||
} |
|||
|
|||
/* delay by 10 micro seconds */ |
|||
void u8g_10MicroDelay(void) |
|||
{ |
|||
#if (F_CPU / 400000 ) > 0 |
|||
_delay_loop_2( (F_CPU / 400000 ) ); |
|||
#endif |
|||
} |
|||
|
|||
#endif |
|||
|
|||
|
|||
/*== Delay for PIC18 (not tested) ==*/ |
|||
|
|||
#if defined(USE_PIC18_DELAY) |
|||
#include <delays.h> |
|||
#define GetSystemClock() (64000000ul) // Hz
|
|||
#define GetInstructionClock() (GetSystemClock()/4) |
|||
|
|||
void u8g_Delay(uint16_t val) |
|||
{/*
|
|||
unsigned int _iTemp = (val); |
|||
while(_iTemp--) |
|||
Delay1KTCYx((GetInstructionClock()+999999)/1000000); |
|||
*/ |
|||
} |
|||
void u8g_MicroDelay(void) |
|||
{ |
|||
/* not implemented */ |
|||
} |
|||
void u8g_10MicroDelay(void) |
|||
{ |
|||
/* not implemented */ |
|||
} |
|||
#endif |
|||
|
|||
|
|||
/*== Arduino Delay ==*/ |
|||
#if defined(USE_ARDUINO_DELAY) |
|||
void u8g_Delay(uint16_t val) |
|||
{ |
|||
delay(val); |
|||
} |
|||
void u8g_MicroDelay(void) |
|||
{ |
|||
delayMicroseconds(1); |
|||
} |
|||
void u8g_10MicroDelay(void) |
|||
{ |
|||
delayMicroseconds(10); |
|||
} |
|||
#endif |
|||
|
|||
#if defined(USE_PIC32_DELAY) |
|||
/*
|
|||
Assume chipkit here with F_CPU correctly defined |
|||
The problem was, that u8g_Delay() is called within the constructor. |
|||
It seems that the chipkit is not fully setup at this time, so a |
|||
call to delay() will not work. So here is my own implementation. |
|||
|
|||
*/ |
|||
#define CPU_COUNTS_PER_SECOND (F_CPU/2UL) |
|||
#define TICKS_PER_MILLISECOND (CPU_COUNTS_PER_SECOND/1000UL) |
|||
#include "plib.h" |
|||
void u8g_Delay(uint16_t val) |
|||
{ |
|||
uint32_t d; |
|||
uint32_t s; |
|||
d = val; |
|||
d *= TICKS_PER_MILLISECOND; |
|||
s = ReadCoreTimer(); |
|||
while ( (uint32_t)(ReadCoreTimer() - s) < d ) |
|||
; |
|||
} |
|||
|
|||
void u8g_MicroDelay(void) |
|||
{ |
|||
uint32_t d; |
|||
uint32_t s; |
|||
d = TICKS_PER_MILLISECOND/1000; |
|||
s = ReadCoreTimer(); |
|||
while ( (uint32_t)(ReadCoreTimer() - s) < d ) |
|||
; |
|||
} |
|||
|
|||
void u8g_10MicroDelay(void) |
|||
{ |
|||
uint32_t d; |
|||
uint32_t s; |
|||
d = TICKS_PER_MILLISECOND/100; |
|||
s = ReadCoreTimer(); |
|||
while ( (uint32_t)(ReadCoreTimer() - s) < d ) |
|||
; |
|||
} |
|||
|
|||
#endif |
|||
|
|||
/*== Any other systems: Dummy Delay ==*/ |
|||
#if defined(USE_DUMMY_DELAY) |
|||
void u8g_Delay(uint16_t val) |
|||
{ |
|||
/* do not know how to delay... */ |
|||
} |
|||
void u8g_MicroDelay(void) |
|||
{ |
|||
} |
|||
void u8g_10MicroDelay(void) |
|||
{ |
|||
} |
|||
#endif |
|||
@ -0,0 +1,92 @@ |
|||
/*
|
|||
|
|||
u8g_dev_flipdisc.c |
|||
|
|||
1-Bit (BW) Driver for flip disc matrix |
|||
2x 7 pixel height |
|||
|
|||
Universal 8bit Graphics Library |
|||
|
|||
Copyright (c) 2011, olikraus@gmail.com |
|||
All rights reserved. |
|||
|
|||
Redistribution and use in source and binary forms, with or without modification, |
|||
are permitted provided that the following conditions are met: |
|||
|
|||
* Redistributions of source code must retain the above copyright notice, this list |
|||
of conditions and the following disclaimer. |
|||
|
|||
* Redistributions in binary form must reproduce the above copyright notice, this |
|||
list of conditions and the following disclaimer in the documentation and/or other |
|||
materials provided with the distribution. |
|||
|
|||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
|||
CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
|||
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
|||
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
|||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
|||
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
|||
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
|||
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
|||
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
|||
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF |
|||
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|||
|
|||
*/ |
|||
|
|||
#include "u8g.h" |
|||
|
|||
#define WIDTH 28 |
|||
#define HEIGHT 14 |
|||
#define PAGE_HEIGHT 14 |
|||
|
|||
/*
|
|||
Write data to the flip disc matrix. |
|||
This procedure must be implemented by the user. |
|||
Arguments: |
|||
id: Id for the matrix. Currently always 0. |
|||
page: A page has a height of 14 pixel. For a matrix with HEIGHT == 14 this will be always 0 |
|||
width: The width of the flip disc matrix. Always equal to WIDTH |
|||
row1: first data line (7 pixel per byte) |
|||
row2: first data line (7 pixel per byte) |
|||
*/ |
|||
void writeFlipDiscMatrix(uint8_t id, uint8_t page, uint8_t width, uint8_t *row1, uint8_t *row2); |
|||
|
|||
|
|||
|
|||
void (*u8g_write_flip_disc_matrix)(uint8_t id, uint8_t page, uint8_t width, uint8_t *row1, uint8_t *row2); |
|||
|
|||
void u8g_SetFlipDiscCallback(u8g_t *u8g, void (*cb)(uint8_t id, uint8_t page, uint8_t width, uint8_t *row1, uint8_t *row2)) |
|||
{ |
|||
u8g_write_flip_disc_matrix = cb; |
|||
} |
|||
|
|||
uint8_t u8g_dev_flipdisc_2x7_bw_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg) |
|||
{ |
|||
switch(msg) |
|||
{ |
|||
case U8G_DEV_MSG_INIT: |
|||
break; |
|||
case U8G_DEV_MSG_STOP: |
|||
break; |
|||
case U8G_DEV_MSG_PAGE_NEXT: |
|||
{ |
|||
u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem); |
|||
|
|||
/* current page: pb->p.page */ |
|||
/* ptr to the buffer: pb->buf */ |
|||
|
|||
(*u8g_write_flip_disc_matrix)(0, pb->p.page, WIDTH, pb->buf, pb->buf+WIDTH); |
|||
} |
|||
break; |
|||
case U8G_DEV_MSG_CONTRAST: |
|||
return 1; |
|||
} |
|||
return u8g_dev_pb14v1_base_fn(u8g, dev, msg, arg); |
|||
} |
|||
|
|||
uint8_t u8g_dev_flipdisc_2x7_bw_buf[WIDTH*2] U8G_NOCOMMON ; |
|||
u8g_pb_t u8g_dev_flipdisc_2x7_bw_pb = { {16, HEIGHT, 0, 0, 0}, WIDTH, u8g_dev_flipdisc_2x7_bw_buf}; |
|||
u8g_dev_t u8g_dev_flipdisc_2x7 = { u8g_dev_flipdisc_2x7_bw_fn, &u8g_dev_flipdisc_2x7_bw_pb, u8g_com_null_fn }; |
|||
@ -0,0 +1,130 @@ |
|||
/*
|
|||
|
|||
u8g_dev_gprof.c |
|||
|
|||
Device for performance measurement with gprof. |
|||
Does not write any data, but uses a buffer. |
|||
|
|||
Universal 8bit Graphics Library |
|||
|
|||
Copyright (c) 2011, olikraus@gmail.com |
|||
All rights reserved. |
|||
|
|||
Redistribution and use in source and binary forms, with or without modification, |
|||
are permitted provided that the following conditions are met: |
|||
|
|||
* Redistributions of source code must retain the above copyright notice, this list |
|||
of conditions and the following disclaimer. |
|||
|
|||
* Redistributions in binary form must reproduce the above copyright notice, this |
|||
list of conditions and the following disclaimer in the documentation and/or other |
|||
materials provided with the distribution. |
|||
|
|||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
|||
CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
|||
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
|||
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
|||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
|||
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
|||
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
|||
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
|||
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
|||
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF |
|||
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|||
|
|||
|
|||
|
|||
*/ |
|||
|
|||
#include "u8g.h" |
|||
|
|||
|
|||
#define WIDTH 128 |
|||
#define HEIGHT 64 |
|||
#define PAGE_HEIGHT 8 |
|||
|
|||
uint8_t u8g_dev_gprof_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg); |
|||
|
|||
uint8_t u8g_pb_dev_gprof_buf[WIDTH]; |
|||
u8g_pb_t u8g_pb_dev_gprof = { {PAGE_HEIGHT, HEIGHT, 0, 0, 0}, WIDTH, u8g_pb_dev_gprof_buf }; |
|||
|
|||
u8g_dev_t u8g_dev_gprof = { u8g_dev_gprof_fn, &u8g_pb_dev_gprof, NULL }; |
|||
|
|||
uint8_t u8g_dev_gprof_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg) |
|||
{ |
|||
u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem); |
|||
|
|||
switch(msg) |
|||
{ |
|||
case U8G_DEV_MSG_INIT: |
|||
break; |
|||
case U8G_DEV_MSG_STOP: |
|||
break; |
|||
case U8G_DEV_MSG_PAGE_FIRST: |
|||
u8g_pb_Clear(pb); |
|||
u8g_page_First(&(pb->p)); |
|||
break; |
|||
case U8G_DEV_MSG_PAGE_NEXT: |
|||
/*
|
|||
{ |
|||
uint8_t i, j; |
|||
uint8_t page_height; |
|||
page_height = pb->p.page_y1; |
|||
page_height -= pb->p.page_y0; |
|||
page_height++; |
|||
for( j = 0; j < page_height; j++ ) |
|||
{ |
|||
printf("%02d ", j); |
|||
for( i = 0; i < WIDTH; i++ ) |
|||
{ |
|||
if ( (u8g_pb_dev_stdout_buf[i] & (1<<j)) != 0 ) |
|||
printf("#"); |
|||
else |
|||
printf("."); |
|||
} |
|||
printf("\n"); |
|||
} |
|||
} |
|||
*/ |
|||
if ( u8g_page_Next(&(pb->p)) == 0 ) |
|||
{ |
|||
//printf("\n");
|
|||
return 0; |
|||
} |
|||
u8g_pb_Clear(pb); |
|||
break; |
|||
#ifdef U8G_DEV_MSG_IS_BBX_INTERSECTION |
|||
case U8G_DEV_MSG_IS_BBX_INTERSECTION: |
|||
{ |
|||
u8g_dev_arg_bbx_t *bbx = (u8g_dev_arg_bbx_t *)arg; |
|||
u8g_uint_t x2, y2; |
|||
|
|||
y2 = bbx->y; |
|||
y2 += bbx->h; |
|||
y2--; |
|||
|
|||
if ( u8g_pb_IsYIntersection(pb, bbx->y, y2) == 0 ) |
|||
return 0; |
|||
|
|||
/* maybe this one can be skiped... probability is very high to have an intersection, so it would be ok to always return 1 */ |
|||
x2 = bbx->x; |
|||
x2 += bbx->w; |
|||
x2--; |
|||
|
|||
if ( u8g_pb_IsXIntersection(pb, bbx->x, x2) == 0 ) |
|||
return 0; |
|||
} |
|||
return 1; |
|||
#endif |
|||
case U8G_DEV_MSG_GET_PAGE_BOX: |
|||
u8g_pb_GetPageBox(pb, (u8g_box_t *)arg); |
|||
break; |
|||
case U8G_DEV_MSG_SET_COLOR_INDEX: |
|||
break; |
|||
case U8G_DEV_MSG_SET_XY_CB: |
|||
break; |
|||
} |
|||
return u8g_dev_pb8v1_base_fn(u8g, dev, msg, arg); |
|||
} |
|||
@ -0,0 +1,326 @@ |
|||
/*
|
|||
|
|||
u8g_dev_ili9325d_320x240.c |
|||
|
|||
Universal 8bit Graphics Library |
|||
|
|||
Copyright (c) 2011, olikraus@gmail.com |
|||
All rights reserved. |
|||
|
|||
Redistribution and use in source and binary forms, with or without modification, |
|||
are permitted provided that the following conditions are met: |
|||
|
|||
* Redistributions of source code must retain the above copyright notice, this list |
|||
of conditions and the following disclaimer. |
|||
|
|||
* Redistributions in binary form must reproduce the above copyright notice, this |
|||
list of conditions and the following disclaimer in the documentation and/or other |
|||
materials provided with the distribution. |
|||
|
|||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
|||
CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
|||
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
|||
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
|||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
|||
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
|||
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
|||
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
|||
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
|||
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF |
|||
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|||
|
|||
Color format |
|||
Red: 5 Bit |
|||
Green: 6 Bit |
|||
Blue: 5 Bit |
|||
|
|||
|
|||
*/ |
|||
|
|||
#include "u8g.h" |
|||
|
|||
#define WIDTH 240 |
|||
|
|||
#if defined(U8G_16BIT) |
|||
#define HEIGHT 320 |
|||
#else |
|||
/* if the user tries to compile the 8Bit version of the lib, then restrict the height to something which fits to 8Bit */ |
|||
#define HEIGHT 240 |
|||
#endif |
|||
#define PAGE_HEIGHT 4 |
|||
|
|||
|
|||
/*
|
|||
reference board for this device: |
|||
http://iteadstudio.com/store/index.php?main_page=product_info&cPath=57_58&products_id=55
|
|||
documentation: |
|||
http://iteadstudio.com/Downloadfile/ITDB02_material.rar
|
|||
datasheet |
|||
http://www.newhavendisplay.com/app_notes/ILI9325D.pdf
|
|||
other libs |
|||
http://henningkarlsen.com/electronics/library.php
|
|||
init sequence |
|||
http://code.google.com/p/itdb02/, ITDB02.cpp, iteadstudio.com
|
|||
*/ |
|||
|
|||
static const uint8_t u8g_dev_ili9325d_320x240_init_seq[] PROGMEM = { |
|||
U8G_ESC_CS(0), /* disable chip */ |
|||
U8G_ESC_DLY(50), /* delay 50 ms */ |
|||
U8G_ESC_RST(15), /* do reset low pulse with (15*16)+2 milliseconds (=maximum delay)*/ |
|||
U8G_ESC_DLY(50), /* delay 50 ms */ |
|||
U8G_ESC_RST(15), /* do reset low pulse with (15*16)+2 milliseconds (=maximum delay)*/ |
|||
U8G_ESC_DLY(50), /* delay 50 ms */ |
|||
U8G_ESC_CS(1), /* enable chip */ |
|||
U8G_ESC_DLY(50), /* delay 50 ms */ |
|||
|
|||
|
|||
//U8G_ESC_ADR(0), 0x000, 0x0E5, /* only used for none D version: set SRAM internal timing */
|
|||
//U8G_ESC_ADR(1), 0x078, 0x0f0,
|
|||
U8G_ESC_ADR(0), 0x000, 0x001, /* Driver Output Control, bits 8 & 10 */ |
|||
U8G_ESC_ADR(1), 0x001, 0x000, |
|||
U8G_ESC_ADR(0), 0x000, 0x002, /* LCD Driving Wave Control, bit 9: Set line inversion */ |
|||
U8G_ESC_ADR(1), 0x002, 0x000, /* ITDB02 none D verion: 0x007, 0x000 */ |
|||
U8G_ESC_ADR(0), 0x000, 0x003, /* Entry Mode, GRAM write direction and BGR=1 */ |
|||
U8G_ESC_ADR(1), 0x010, 0x030, |
|||
U8G_ESC_ADR(0), 0x000, 0x004, /* Resize register */ |
|||
U8G_ESC_ADR(1), 0x000, 0x000, |
|||
U8G_ESC_ADR(0), 0x000, 0x008, /* Display Control 2: set the back porch and front porch */ |
|||
U8G_ESC_ADR(1), 0x002, 0x007, |
|||
|
|||
U8G_ESC_ADR(0), 0x000, 0x009, /* Display Control 3 */ |
|||
U8G_ESC_ADR(1), 0x000, 0x000, |
|||
|
|||
U8G_ESC_ADR(0), 0x000, 0x00a, /* Display Control 4: FMARK */ |
|||
U8G_ESC_ADR(1), 0x000, 0x000, |
|||
U8G_ESC_ADR(0), 0x000, 0x00c, /* RGB Display Interface Control 1 */ |
|||
U8G_ESC_ADR(1), 0x000, 0x000, |
|||
U8G_ESC_ADR(0), 0x000, 0x00d, /* Frame Maker Position */ |
|||
U8G_ESC_ADR(1), 0x000, 0x000, |
|||
U8G_ESC_ADR(0), 0x000, 0x00f, /* RGB Display Interface Control 2 */ |
|||
U8G_ESC_ADR(1), 0x000, 0x000, |
|||
U8G_ESC_ADR(0), 0x000, 0x010, /* Power Control 1: SAP, BT[3:0], AP, DSTB, SLP, STB */ |
|||
U8G_ESC_ADR(1), 0x000, 0x000, |
|||
U8G_ESC_ADR(0), 0x000, 0x011, /* Power Control 2: DC1[2:0], DC0[2:0], VC[2:0] */ |
|||
U8G_ESC_ADR(1), 0x000, 0x007, |
|||
U8G_ESC_ADR(0), 0x000, 0x012, /* Power Control 3: VREG1OUT voltage */ |
|||
U8G_ESC_ADR(1), 0x000, 0x000, |
|||
U8G_ESC_ADR(0), 0x000, 0x013, /* Power Control 4: VDV[4:0] for VCOM amplitude */ |
|||
U8G_ESC_ADR(1), 0x000, 0x000, |
|||
U8G_ESC_ADR(0), 0x000, 0x007, /* Display Control 1: Operate, but do not display */ |
|||
U8G_ESC_ADR(1), 0x000, 0x001, |
|||
|
|||
U8G_ESC_DLY(100), /* delay 100 ms */ /* ITDB02 none D verion: 50ms */ |
|||
U8G_ESC_DLY(100), /* delay 100 ms */ |
|||
|
|||
U8G_ESC_ADR(0), 0x000, 0x010, /* Power Control 1: SAP, BT[3:0], AP, DSTB, SLP, STB */ |
|||
U8G_ESC_ADR(1), 0x016, 0x090, /* ITDB02 none D verion: 0x010, 0x090 */ |
|||
U8G_ESC_ADR(0), 0x000, 0x011, /* Power Control 2: SAP, BT[3:0], AP, DSTB, SLP, STB */ |
|||
U8G_ESC_ADR(1), 0x002, 0x027, |
|||
|
|||
U8G_ESC_DLY(50), /* delay 50 ms */ |
|||
|
|||
U8G_ESC_ADR(0), 0x000, 0x012, /* Power Control 3: VCI: External, VCI*1.80 */ |
|||
U8G_ESC_ADR(1), 0x000, 0x00d, /* ITDB02 none D verion: 0x000, 0x01f */ |
|||
|
|||
U8G_ESC_DLY(50), /* delay 50 ms */ |
|||
|
|||
U8G_ESC_ADR(0), 0x000, 0x013, /* Power Control 4: VDV[4:0] for VCOM amplitude */ |
|||
U8G_ESC_ADR(1), 0x012, 0x000, /* ITDB02 none D verion: 0x015, 0x000 */ |
|||
U8G_ESC_ADR(0), 0x000, 0x029, /* Power Control 7 */ |
|||
U8G_ESC_ADR(1), 0x000, 0x00a, /* ITDB02 none D verion: 0x000, 0x027 */ |
|||
U8G_ESC_ADR(0), 0x000, 0x02b, /* Frame Rate: 83 */ |
|||
U8G_ESC_ADR(1), 0x000, 0x00d, |
|||
|
|||
U8G_ESC_DLY(50), /* delay 50 ms */ |
|||
|
|||
U8G_ESC_ADR(0), 0x000, 0x020, /* Horizontal GRAM Address Set */ |
|||
U8G_ESC_ADR(1), 0x000, 0x000, |
|||
U8G_ESC_ADR(0), 0x000, 0x021, /* Vertical GRAM Address Set */ |
|||
U8G_ESC_ADR(1), 0x000, 0x000, |
|||
|
|||
/* gamma control */ |
|||
U8G_ESC_ADR(0), 0x000, 0x030, |
|||
U8G_ESC_ADR(1), 0x000, 0x000, |
|||
U8G_ESC_ADR(0), 0x000, 0x031, |
|||
U8G_ESC_ADR(1), 0x004, 0x004, |
|||
U8G_ESC_ADR(0), 0x000, 0x032, |
|||
U8G_ESC_ADR(1), 0x000, 0x003, |
|||
U8G_ESC_ADR(0), 0x000, 0x035, |
|||
U8G_ESC_ADR(1), 0x004, 0x005, |
|||
U8G_ESC_ADR(0), 0x000, 0x036, |
|||
U8G_ESC_ADR(1), 0x008, 0x008, |
|||
U8G_ESC_ADR(0), 0x000, 0x037, |
|||
U8G_ESC_ADR(1), 0x004, 0x007, |
|||
U8G_ESC_ADR(0), 0x000, 0x038, |
|||
U8G_ESC_ADR(1), 0x003, 0x003, |
|||
U8G_ESC_ADR(0), 0x000, 0x039, |
|||
U8G_ESC_ADR(1), 0x007, 0x007, |
|||
U8G_ESC_ADR(0), 0x000, 0x03c, |
|||
U8G_ESC_ADR(1), 0x005, 0x004, |
|||
U8G_ESC_ADR(0), 0x000, 0x03d, |
|||
U8G_ESC_ADR(1), 0x008, 0x008, |
|||
|
|||
U8G_ESC_ADR(0), 0x000, 0x050, /* Horizontal GRAM Start Address */ |
|||
U8G_ESC_ADR(1), 0x000, 0x000, |
|||
U8G_ESC_ADR(0), 0x000, 0x051, /* Horizontal GRAM End Address: 239 */ |
|||
U8G_ESC_ADR(1), 0x000, 0x0EF, |
|||
U8G_ESC_ADR(0), 0x000, 0x052, /* Vertical GRAM Start Address */ |
|||
U8G_ESC_ADR(1), 0x000, 0x000, |
|||
U8G_ESC_ADR(0), 0x000, 0x053, /* Vertical GRAM End Address: 319 */ |
|||
U8G_ESC_ADR(1), 0x001, 0x03F, |
|||
|
|||
U8G_ESC_ADR(0), 0x000, 0x060, /* Driver Output Control 2 */ |
|||
U8G_ESC_ADR(1), 0x0a7, 0x000, |
|||
U8G_ESC_ADR(0), 0x000, 0x061, /* Base Image Display Control: NDL,VLE, REV */ |
|||
U8G_ESC_ADR(1), 0x000, 0x001, |
|||
U8G_ESC_ADR(0), 0x000, 0x06a, /* Vertical Scroll Control */ |
|||
U8G_ESC_ADR(1), 0x000, 0x000, |
|||
|
|||
U8G_ESC_ADR(0), 0x000, 0x080, /* Partial Image 1 Display Position */ |
|||
U8G_ESC_ADR(1), 0x000, 0x000, |
|||
U8G_ESC_ADR(0), 0x000, 0x081, /* Partial Image 1 RAM Start Address */ |
|||
U8G_ESC_ADR(1), 0x000, 0x000, |
|||
U8G_ESC_ADR(0), 0x000, 0x082, /* Partial Image 1 RAM End Address */ |
|||
U8G_ESC_ADR(1), 0x000, 0x000, |
|||
U8G_ESC_ADR(0), 0x000, 0x083, /* Partial Image 2 Display Position */ |
|||
U8G_ESC_ADR(1), 0x000, 0x000, |
|||
U8G_ESC_ADR(0), 0x000, 0x084, /* Partial Image 2 RAM Start Address */ |
|||
U8G_ESC_ADR(1), 0x000, 0x000, |
|||
U8G_ESC_ADR(0), 0x000, 0x085, /* Partial Image 2 RAM End Address */ |
|||
U8G_ESC_ADR(1), 0x000, 0x000, |
|||
|
|||
U8G_ESC_ADR(0), 0x000, 0x090, /* Panel Interface Control 1 */ |
|||
U8G_ESC_ADR(1), 0x000, 0x010, |
|||
U8G_ESC_ADR(0), 0x000, 0x092, /* Panel Interface Control 2 */ |
|||
U8G_ESC_ADR(1), 0x000, 0x000, /* 0x006, 0x000 */ |
|||
|
|||
U8G_ESC_ADR(0), 0x000, 0x007, /* Display Control 1: Operate, display ON */ |
|||
U8G_ESC_ADR(1), 0x001, 0x033, |
|||
|
|||
U8G_ESC_DLY(10), /* delay 10 ms */ |
|||
|
|||
/* write test pattern */ |
|||
U8G_ESC_ADR(0), 0x000, 0x020, /* Horizontal GRAM Address Set */ |
|||
U8G_ESC_ADR(1), 0x000, 0x000, |
|||
U8G_ESC_ADR(0), 0x000, 0x021, /* Vertical GRAM Address Set */ |
|||
U8G_ESC_ADR(1), 0x000, 0x010, |
|||
U8G_ESC_ADR(0), 0x000, 0x022, /* Write Data to GRAM */ |
|||
U8G_ESC_ADR(1), 0x0fe, 0x0fe, |
|||
0x000, 0x000, |
|||
0x0fe, 0x0fe, |
|||
0x000, 0x000, |
|||
0x0fe, 0x0fe, |
|||
0x000, 0x000, |
|||
0x0fe, 0x0fe, |
|||
0x000, 0x000, |
|||
0x0fe, 0x0fe, |
|||
0x000, 0x000, |
|||
0x0fe, 0x0fe, |
|||
0x000, 0x000, |
|||
0x0fe, 0x0fe, |
|||
0x000, 0x000, |
|||
0x0fe, 0x0fe, |
|||
0x000, 0x000, |
|||
0x0fe, 0x0fe, |
|||
|
|||
U8G_ESC_CS(0), /* disable chip */ |
|||
U8G_ESC_END /* end of sequence */ |
|||
}; |
|||
|
|||
|
|||
static const uint8_t u8g_dev_ili9325d_320x240_page_seq[] PROGMEM = { |
|||
U8G_ESC_CS(1), /* enable chip */ |
|||
U8G_ESC_ADR(0), 0x000, 0x020, /* Horizontal GRAM Address Set */ |
|||
U8G_ESC_ADR(1), 0x000, 0x000, |
|||
U8G_ESC_ADR(0), 0x000, 0x021, /* Vertical GRAM Address Set */ |
|||
U8G_ESC_ADR(1), |
|||
U8G_ESC_END /* end of sequence */ |
|||
}; |
|||
|
|||
/* convert the internal RGB 332 to 65K high byte */ |
|||
static uint8_t u8g_dev_ili9325d_get_65K_high_byte(uint8_t color) |
|||
{ |
|||
uint8_t h; |
|||
h = color; |
|||
h &= 0x0e0; |
|||
h |= h>>3; |
|||
h &= 0x0f8; |
|||
color>>=2; |
|||
color &= 7; |
|||
h |= color; |
|||
return h; |
|||
} |
|||
|
|||
/* convert the internal RGB 332 to 65K high byte */ |
|||
static uint8_t u8g_dev_ili9325d_get_65K_low_byte(uint8_t color) |
|||
{ |
|||
uint8_t l; |
|||
l = color; |
|||
l <<= 3; |
|||
color &= 3; |
|||
color <<= 1; |
|||
l |= color; |
|||
return l; |
|||
} |
|||
|
|||
|
|||
uint8_t u8g_dev_ili9325d_320x240_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg) |
|||
{ |
|||
|
|||
switch(msg) |
|||
{ |
|||
case U8G_DEV_MSG_INIT: |
|||
u8g_InitCom(u8g, dev); |
|||
//for(;;)
|
|||
u8g_WriteEscSeqP(u8g, dev, u8g_dev_ili9325d_320x240_init_seq); |
|||
|
|||
break; |
|||
case U8G_DEV_MSG_STOP: |
|||
break; |
|||
case U8G_DEV_MSG_PAGE_NEXT: |
|||
{ |
|||
uint8_t i; |
|||
uint16_t y, j; |
|||
uint8_t *ptr; |
|||
u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem); |
|||
|
|||
y = pb->p.page_y0; |
|||
ptr = pb->buf; |
|||
for( i = 0; i < pb->p.page_height; i ++ ) |
|||
{ |
|||
u8g_WriteEscSeqP(u8g, dev, u8g_dev_ili9325d_320x240_page_seq); |
|||
u8g_WriteByte(u8g, dev, y >> 8 ); /* display ram (cursor) address high byte */ |
|||
u8g_WriteByte(u8g, dev, y & 255 ); /* display ram (cursor) address low byte */ |
|||
|
|||
u8g_SetAddress(u8g, dev, 0); /* cmd mode */ |
|||
u8g_WriteByte(u8g, dev, 0 ); |
|||
u8g_WriteByte(u8g, dev, 0x022 ); /* start gram data */ |
|||
|
|||
u8g_SetAddress(u8g, dev, 1); /* data mode */ |
|||
|
|||
for( j = 0; j < pb->width; j++ ) |
|||
{ |
|||
u8g_WriteByte(u8g, dev, u8g_dev_ili9325d_get_65K_high_byte(*ptr) ); |
|||
u8g_WriteByte(u8g, dev, u8g_dev_ili9325d_get_65K_low_byte(*ptr) ); |
|||
|
|||
ptr++; |
|||
} |
|||
y++; |
|||
} |
|||
u8g_SetChipSelect(u8g, dev, 0); |
|||
} |
|||
break; |
|||
} |
|||
return u8g_dev_pb8h8_base_fn(u8g, dev, msg, arg); |
|||
} |
|||
|
|||
uint8_t u8g_ili9325d_320x240_8h8_buf[WIDTH*PAGE_HEIGHT] U8G_NOCOMMON ; |
|||
u8g_pb_t u8g_ili9325d_320x240_8h8_pb U8G_NOCOMMON = { {PAGE_HEIGHT, HEIGHT, 0, 0, 0}, WIDTH, u8g_ili9325d_320x240_8h8_buf}; |
|||
u8g_dev_t u8g_dev_ili9325d_320x240_8bit U8G_NOCOMMON = { u8g_dev_ili9325d_320x240_fn, &u8g_ili9325d_320x240_8h8_pb, u8g_com_arduino_port_d_wr_fn }; |
|||
//u8g_dev_t u8g_dev_ili9325d_320x240_8bit = { u8g_dev_ili9325d_320x240_fn, &u8g_ili9325d_320x240_8h8_pb, u8g_com_arduino_parallel_fn };
|
|||
|
|||
//U8G_PB_DEV(u8g_dev_ili9325d_320x240_8bit, WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_ili9325d_320x240_fn, U8G_COM_PARALLEL);
|
|||
|
|||
|
|||
@ -0,0 +1,110 @@ |
|||
/*
|
|||
|
|||
u8g_dev_ks0108_128x64.c |
|||
|
|||
Universal 8bit Graphics Library |
|||
|
|||
Copyright (c) 2011, olikraus@gmail.com |
|||
All rights reserved. |
|||
|
|||
Redistribution and use in source and binary forms, with or without modification, |
|||
are permitted provided that the following conditions are met: |
|||
|
|||
* Redistributions of source code must retain the above copyright notice, this list |
|||
of conditions and the following disclaimer. |
|||
|
|||
* Redistributions in binary form must reproduce the above copyright notice, this |
|||
list of conditions and the following disclaimer in the documentation and/or other |
|||
materials provided with the distribution. |
|||
|
|||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
|||
CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
|||
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
|||
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
|||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
|||
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
|||
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
|||
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
|||
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
|||
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF |
|||
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|||
|
|||
|
|||
ADDRESS = 0 (Command Mode) |
|||
0x03f Display On |
|||
0x0c0 Start Display at line 0 |
|||
0x040 | y write to y address (y:0..63) |
|||
0x0b8 | x write to page [0..7] |
|||
|
|||
|
|||
u8g_Init8Bit(u8g, dev, d0, d1, d2, d3, d4, d5, d6, d7, en, cs1, cs2, di, rw, reset) |
|||
u8g_Init8Bit(u8g, dev, 8, 9, 10, 11, 4, 5, 6, 7, 18, 14, 15, 17, 16, U8G_PIN_NONE) |
|||
|
|||
*/ |
|||
|
|||
#include "u8g.h" |
|||
|
|||
#define WIDTH 128 |
|||
#define HEIGHT 64 |
|||
#define PAGE_HEIGHT 8 |
|||
|
|||
static const uint8_t u8g_dev_ks0108_128x64_init_seq[] PROGMEM = { |
|||
U8G_ESC_CS(0), /* disable chip */ |
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
U8G_ESC_RST(1), /* do reset low pulse with (1*16)+2 milliseconds */ |
|||
U8G_ESC_CS(1), /* enable chip 1 */ |
|||
0x03f, /* display on */ |
|||
0x0c0, /* start at line 0 */ |
|||
U8G_ESC_DLY(20), /* delay 20 ms */ |
|||
U8G_ESC_CS(2), /* enable chip 2 */ |
|||
0x03f, /* display on */ |
|||
0x0c0, /* start at line 0 */ |
|||
U8G_ESC_DLY(20), /* delay 20 ms */ |
|||
U8G_ESC_CS(0), /* disable all chips */ |
|||
U8G_ESC_END /* end of sequence */ |
|||
}; |
|||
|
|||
|
|||
uint8_t u8g_dev_ks0108_128x64_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg) |
|||
{ |
|||
|
|||
switch(msg) |
|||
{ |
|||
case U8G_DEV_MSG_INIT: |
|||
u8g_InitCom(u8g, dev); |
|||
u8g_WriteEscSeqP(u8g, dev, u8g_dev_ks0108_128x64_init_seq); |
|||
break; |
|||
case U8G_DEV_MSG_STOP: |
|||
break; |
|||
case U8G_DEV_MSG_PAGE_NEXT: |
|||
{ |
|||
u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem); |
|||
|
|||
u8g_SetAddress(u8g, dev, 0); /* command mode */ |
|||
u8g_SetChipSelect(u8g, dev, 2); |
|||
u8g_WriteByte(u8g, dev, 0x0b8 | pb->p.page); /* select current page (KS0108b) */ |
|||
u8g_WriteByte(u8g, dev, 0x040 ); /* set address 0 */ |
|||
u8g_SetAddress(u8g, dev, 1); /* data mode */ |
|||
u8g_WriteSequence(u8g, dev, 64, pb->buf); |
|||
u8g_SetChipSelect(u8g, dev, 0); |
|||
|
|||
u8g_SetAddress(u8g, dev, 0); /* command mode */ |
|||
u8g_SetChipSelect(u8g, dev, 1); |
|||
u8g_WriteByte(u8g, dev, 0x0b8 | pb->p.page); /* select current page (KS0108b) */ |
|||
u8g_WriteByte(u8g, dev, 0x040 ); /* set address 0 */ |
|||
u8g_SetAddress(u8g, dev, 1); /* data mode */ |
|||
u8g_WriteSequence(u8g, dev, 64, 64+(uint8_t *)pb->buf); |
|||
u8g_SetChipSelect(u8g, dev, 0); |
|||
|
|||
} |
|||
break; |
|||
} |
|||
return u8g_dev_pb8v1_base_fn(u8g, dev, msg, arg); |
|||
} |
|||
|
|||
U8G_PB_DEV(u8g_dev_ks0108_128x64, WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_ks0108_128x64_fn, U8G_COM_PARALLEL); |
|||
U8G_PB_DEV(u8g_dev_ks0108_128x64_fast, WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_ks0108_128x64_fn, U8G_COM_FAST_PARALLEL); |
|||
|
|||
|
|||
@ -0,0 +1,147 @@ |
|||
/*
|
|||
|
|||
u8g_dev_lc7981_160x80.c |
|||
|
|||
Universal 8bit Graphics Library |
|||
|
|||
Copyright (c) 2011, olikraus@gmail.com |
|||
All rights reserved. |
|||
|
|||
Redistribution and use in source and binary forms, with or without modification, |
|||
are permitted provided that the following conditions are met: |
|||
|
|||
* Redistributions of source code must retain the above copyright notice, this list |
|||
of conditions and the following disclaimer. |
|||
|
|||
* Redistributions in binary form must reproduce the above copyright notice, this |
|||
list of conditions and the following disclaimer in the documentation and/or other |
|||
materials provided with the distribution. |
|||
|
|||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
|||
CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
|||
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
|||
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
|||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
|||
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
|||
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
|||
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
|||
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
|||
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF |
|||
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|||
|
|||
|
|||
*/ |
|||
|
|||
#include "u8g.h" |
|||
|
|||
#define WIDTH 160 |
|||
#define HEIGHT 80 |
|||
#define PAGE_HEIGHT 8 |
|||
|
|||
|
|||
/*
|
|||
code ideas: |
|||
https://github.com/vsergeev/embedded-drivers/tree/master/avr-lc7981
|
|||
data sheets: |
|||
http://www.lcd-module.de/eng/pdf/zubehoer/lc7981.pdf
|
|||
http://www.lcd-module.de/pdf/grafik/w160-6.pdf
|
|||
*/ |
|||
|
|||
static const uint8_t u8g_dev_lc7981_160x80_init_seq[] PROGMEM = { |
|||
U8G_ESC_CS(0), /* disable chip */ |
|||
U8G_ESC_ADR(1), /* instruction mode */ |
|||
U8G_ESC_RST(15), /* do reset low pulse with (15*16)+2 milliseconds (=maximum delay)*/ |
|||
U8G_ESC_CS(1), /* enable chip */ |
|||
U8G_ESC_DLY(50), /* delay 50 ms */ |
|||
|
|||
|
|||
U8G_ESC_ADR(1), /* instruction mode */ |
|||
0x000, /* mode register */ |
|||
U8G_ESC_ADR(0), /* data mode */ |
|||
0x032, /* display on (bit 5), master mode on (bit 4), graphics mode on (bit 1)*/ |
|||
|
|||
U8G_ESC_ADR(1), /* instruction mode */ |
|||
0x001, /* character/bits per pixel pitch */ |
|||
U8G_ESC_ADR(0), /* data mode */ |
|||
0x007, /* 8 bits per pixel */ |
|||
|
|||
U8G_ESC_ADR(1), /* instruction mode */ |
|||
0x002, /* number of chars/byte width of the screen */ |
|||
U8G_ESC_ADR(0), /* data mode */ |
|||
WIDTH/8-1, /* 8 bits per pixel */ |
|||
|
|||
U8G_ESC_ADR(1), /* instruction mode */ |
|||
0x003, /* time division */ |
|||
U8G_ESC_ADR(0), /* data mode */ |
|||
0x07f, /* */ |
|||
|
|||
U8G_ESC_ADR(1), /* instruction mode */ |
|||
0x008, /* display start low */ |
|||
U8G_ESC_ADR(0), /* data mode */ |
|||
0x000, /* */ |
|||
|
|||
U8G_ESC_ADR(1), /* instruction mode */ |
|||
0x009, /* display start high */ |
|||
U8G_ESC_ADR(0), /* data mode */ |
|||
0x000, /* */ |
|||
|
|||
U8G_ESC_DLY(10), /* delay 10 ms */ |
|||
|
|||
U8G_ESC_CS(0), /* disable chip */ |
|||
U8G_ESC_END /* end of sequence */ |
|||
}; |
|||
|
|||
uint8_t u8g_dev_lc7981_160x80_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg) |
|||
{ |
|||
switch(msg) |
|||
{ |
|||
case U8G_DEV_MSG_INIT: |
|||
u8g_InitCom(u8g, dev); |
|||
u8g_WriteEscSeqP(u8g, dev, u8g_dev_lc7981_160x80_init_seq); |
|||
break; |
|||
case U8G_DEV_MSG_STOP: |
|||
break; |
|||
case U8G_DEV_MSG_PAGE_NEXT: |
|||
{ |
|||
uint8_t y, i; |
|||
uint16_t disp_ram_adr; |
|||
uint8_t *ptr; |
|||
u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem); |
|||
|
|||
u8g_SetAddress(u8g, dev, 1); /* cmd mode */ |
|||
u8g_SetChipSelect(u8g, dev, 1); |
|||
y = pb->p.page_y0; |
|||
ptr = pb->buf; |
|||
disp_ram_adr = WIDTH/8; |
|||
disp_ram_adr *= y; |
|||
for( i = 0; i < 8; i ++ ) |
|||
{ |
|||
u8g_SetAddress(u8g, dev, 1); /* cmd mode */ |
|||
u8g_WriteByte(u8g, dev, 0x00a ); /* display ram (cursor) address low byte */ |
|||
u8g_SetAddress(u8g, dev, 0); /* data mode */ |
|||
u8g_WriteByte(u8g, dev, disp_ram_adr & 0x0ff ); |
|||
|
|||
u8g_SetAddress(u8g, dev, 1); /* cmd mode */ |
|||
u8g_WriteByte(u8g, dev, 0x00b ); /* display ram (cursor) address hight byte */ |
|||
u8g_SetAddress(u8g, dev, 0); /* data mode */ |
|||
u8g_WriteByte(u8g, dev, disp_ram_adr >> 8 ); |
|||
|
|||
u8g_SetAddress(u8g, dev, 1); /* cmd mode */ |
|||
u8g_WriteByte(u8g, dev, 0x00c ); /* write data */ |
|||
u8g_SetAddress(u8g, dev, 0); /* data mode */ |
|||
u8g_WriteSequence(u8g, dev, WIDTH/8, ptr); |
|||
ptr += WIDTH/8; |
|||
disp_ram_adr += WIDTH/8; |
|||
} |
|||
u8g_SetChipSelect(u8g, dev, 0); |
|||
} |
|||
break; |
|||
} |
|||
return u8g_dev_pb8h1f_base_fn(u8g, dev, msg, arg); |
|||
} |
|||
|
|||
U8G_PB_DEV(u8g_dev_lc7981_160x80_8bit, WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_lc7981_160x80_fn, U8G_COM_FAST_PARALLEL); |
|||
|
|||
|
|||
@ -0,0 +1,145 @@ |
|||
/*
|
|||
|
|||
u8g_dev_lc7981_240x128.c |
|||
|
|||
Hitachi Display SP14N002 |
|||
|
|||
Universal 8bit Graphics Library |
|||
|
|||
Copyright (c) 2012, olikraus@gmail.com |
|||
All rights reserved. |
|||
|
|||
Redistribution and use in source and binary forms, with or without modification, |
|||
are permitted provided that the following conditions are met: |
|||
|
|||
* Redistributions of source code must retain the above copyright notice, this list |
|||
of conditions and the following disclaimer. |
|||
|
|||
* Redistributions in binary form must reproduce the above copyright notice, this |
|||
list of conditions and the following disclaimer in the documentation and/or other |
|||
materials provided with the distribution. |
|||
|
|||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
|||
CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
|||
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
|||
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
|||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
|||
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
|||
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
|||
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
|||
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
|||
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF |
|||
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|||
|
|||
|
|||
*/ |
|||
|
|||
#include "u8g.h" |
|||
|
|||
#define WIDTH 240 |
|||
#define HEIGHT 128 |
|||
#define PAGE_HEIGHT 8 |
|||
|
|||
|
|||
/*
|
|||
http://www.mark-products.com/graphics.htm#240x128%20Pixel%20Format
|
|||
*/ |
|||
|
|||
static const uint8_t u8g_dev_lc7981_240x128_init_seq[] PROGMEM = { |
|||
U8G_ESC_CS(0), /* disable chip */ |
|||
U8G_ESC_ADR(1), /* instruction mode */ |
|||
U8G_ESC_RST(15), /* do reset low pulse with (15*16)+2 milliseconds (=maximum delay)*/ |
|||
U8G_ESC_CS(1), /* enable chip */ |
|||
U8G_ESC_DLY(50), /* delay 50 ms */ |
|||
|
|||
|
|||
U8G_ESC_ADR(1), /* instruction mode */ |
|||
0x000, /* mode register */ |
|||
U8G_ESC_ADR(0), /* data mode */ |
|||
0x032, /* display on (bit 5), master mode on (bit 4), graphics mode on (bit 1)*/ |
|||
|
|||
U8G_ESC_ADR(1), /* instruction mode */ |
|||
0x001, /* character/bits per pixel pitch */ |
|||
U8G_ESC_ADR(0), /* data mode */ |
|||
0x007, /* 8 bits per pixel */ |
|||
|
|||
U8G_ESC_ADR(1), /* instruction mode */ |
|||
0x002, /* number of chars/byte width of the screen */ |
|||
U8G_ESC_ADR(0), /* data mode */ |
|||
WIDTH/8-1, /* 8 bits per pixel */ |
|||
|
|||
U8G_ESC_ADR(1), /* instruction mode */ |
|||
0x003, /* time division */ |
|||
U8G_ESC_ADR(0), /* data mode */ |
|||
0x07f, /* */ |
|||
|
|||
U8G_ESC_ADR(1), /* instruction mode */ |
|||
0x008, /* display start low */ |
|||
U8G_ESC_ADR(0), /* data mode */ |
|||
0x000, /* */ |
|||
|
|||
U8G_ESC_ADR(1), /* instruction mode */ |
|||
0x009, /* display start high */ |
|||
U8G_ESC_ADR(0), /* data mode */ |
|||
0x000, /* */ |
|||
|
|||
U8G_ESC_DLY(10), /* delay 10 ms */ |
|||
|
|||
U8G_ESC_CS(0), /* disable chip */ |
|||
U8G_ESC_END /* end of sequence */ |
|||
}; |
|||
|
|||
uint8_t u8g_dev_lc7981_240x128_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg) |
|||
{ |
|||
switch(msg) |
|||
{ |
|||
case U8G_DEV_MSG_INIT: |
|||
u8g_InitCom(u8g, dev); |
|||
u8g_WriteEscSeqP(u8g, dev, u8g_dev_lc7981_240x128_init_seq); |
|||
break; |
|||
case U8G_DEV_MSG_STOP: |
|||
break; |
|||
case U8G_DEV_MSG_PAGE_NEXT: |
|||
{ |
|||
uint8_t y, i; |
|||
uint16_t disp_ram_adr; |
|||
uint8_t *ptr; |
|||
u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem); |
|||
|
|||
u8g_SetAddress(u8g, dev, 1); /* cmd mode */ |
|||
u8g_SetChipSelect(u8g, dev, 1); |
|||
y = pb->p.page_y0; |
|||
ptr = pb->buf; |
|||
disp_ram_adr = WIDTH/8; |
|||
disp_ram_adr *= y; |
|||
for( i = 0; i < 8; i ++ ) |
|||
{ |
|||
u8g_SetAddress(u8g, dev, 1); /* cmd mode */ |
|||
u8g_WriteByte(u8g, dev, 0x00a ); /* display ram (cursor) address low byte */ |
|||
u8g_SetAddress(u8g, dev, 0); /* data mode */ |
|||
u8g_WriteByte(u8g, dev, disp_ram_adr & 0x0ff ); |
|||
|
|||
u8g_SetAddress(u8g, dev, 1); /* cmd mode */ |
|||
u8g_WriteByte(u8g, dev, 0x00b ); /* display ram (cursor) address hight byte */ |
|||
u8g_SetAddress(u8g, dev, 0); /* data mode */ |
|||
u8g_WriteByte(u8g, dev, disp_ram_adr >> 8 ); |
|||
|
|||
u8g_SetAddress(u8g, dev, 1); /* cmd mode */ |
|||
u8g_WriteByte(u8g, dev, 0x00c ); /* write data */ |
|||
u8g_SetAddress(u8g, dev, 0); /* data mode */ |
|||
u8g_WriteSequence(u8g, dev, WIDTH/8, ptr); |
|||
ptr += WIDTH/8; |
|||
disp_ram_adr += WIDTH/8; |
|||
} |
|||
u8g_SetChipSelect(u8g, dev, 0); |
|||
} |
|||
break; |
|||
} |
|||
return u8g_dev_pb8h1f_base_fn(u8g, dev, msg, arg); |
|||
} |
|||
|
|||
U8G_PB_DEV(u8g_dev_lc7981_240x128_8bit, WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_lc7981_240x128_fn, U8G_COM_FAST_PARALLEL); |
|||
|
|||
|
|||
@ -0,0 +1,145 @@ |
|||
/*
|
|||
|
|||
u8g_dev_lc7981_240x64.c |
|||
|
|||
Tested with Nan Ya LM_J6_003_ |
|||
|
|||
Universal 8bit Graphics Library |
|||
|
|||
Copyright (c) 2012, olikraus@gmail.com |
|||
All rights reserved. |
|||
|
|||
Redistribution and use in source and binary forms, with or without modification, |
|||
are permitted provided that the following conditions are met: |
|||
|
|||
* Redistributions of source code must retain the above copyright notice, this list |
|||
of conditions and the following disclaimer. |
|||
|
|||
* Redistributions in binary form must reproduce the above copyright notice, this |
|||
list of conditions and the following disclaimer in the documentation and/or other |
|||
materials provided with the distribution. |
|||
|
|||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
|||
CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
|||
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
|||
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
|||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
|||
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
|||
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
|||
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
|||
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
|||
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF |
|||
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|||
|
|||
|
|||
*/ |
|||
|
|||
#include "u8g.h" |
|||
|
|||
#define WIDTH 240 |
|||
#define HEIGHT 64 |
|||
#define PAGE_HEIGHT 8 |
|||
|
|||
|
|||
/*
|
|||
http://www.mark-products.com/graphics.htm#240x64%20Pixel%20Format
|
|||
*/ |
|||
|
|||
static const uint8_t u8g_dev_lc7981_240x64_init_seq[] PROGMEM = { |
|||
U8G_ESC_CS(0), /* disable chip */ |
|||
U8G_ESC_ADR(1), /* instruction mode */ |
|||
U8G_ESC_RST(15), /* do reset low pulse with (15*16)+2 milliseconds (=maximum delay)*/ |
|||
U8G_ESC_CS(1), /* enable chip */ |
|||
U8G_ESC_DLY(50), /* delay 50 ms */ |
|||
|
|||
|
|||
U8G_ESC_ADR(1), /* instruction mode */ |
|||
0x000, /* mode register */ |
|||
U8G_ESC_ADR(0), /* data mode */ |
|||
0x032, /* display on (bit 5), master mode on (bit 4), graphics mode on (bit 1)*/ |
|||
|
|||
U8G_ESC_ADR(1), /* instruction mode */ |
|||
0x001, /* character/bits per pixel pitch */ |
|||
U8G_ESC_ADR(0), /* data mode */ |
|||
0x007, /* 8 bits per pixel */ |
|||
|
|||
U8G_ESC_ADR(1), /* instruction mode */ |
|||
0x002, /* number of chars/byte width of the screen */ |
|||
U8G_ESC_ADR(0), /* data mode */ |
|||
WIDTH/8-1, /* 8 bits per pixel */ |
|||
|
|||
U8G_ESC_ADR(1), /* instruction mode */ |
|||
0x003, /* time division */ |
|||
U8G_ESC_ADR(0), /* data mode */ |
|||
0x07f, /* */ |
|||
|
|||
U8G_ESC_ADR(1), /* instruction mode */ |
|||
0x008, /* display start low */ |
|||
U8G_ESC_ADR(0), /* data mode */ |
|||
0x000, /* */ |
|||
|
|||
U8G_ESC_ADR(1), /* instruction mode */ |
|||
0x009, /* display start high */ |
|||
U8G_ESC_ADR(0), /* data mode */ |
|||
0x000, /* */ |
|||
|
|||
U8G_ESC_DLY(10), /* delay 10 ms */ |
|||
|
|||
U8G_ESC_CS(0), /* disable chip */ |
|||
U8G_ESC_END /* end of sequence */ |
|||
}; |
|||
|
|||
uint8_t u8g_dev_lc7981_240x64_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg) |
|||
{ |
|||
switch(msg) |
|||
{ |
|||
case U8G_DEV_MSG_INIT: |
|||
u8g_InitCom(u8g, dev); |
|||
u8g_WriteEscSeqP(u8g, dev, u8g_dev_lc7981_240x64_init_seq); |
|||
break; |
|||
case U8G_DEV_MSG_STOP: |
|||
break; |
|||
case U8G_DEV_MSG_PAGE_NEXT: |
|||
{ |
|||
uint8_t y, i; |
|||
uint16_t disp_ram_adr; |
|||
uint8_t *ptr; |
|||
u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem); |
|||
|
|||
u8g_SetAddress(u8g, dev, 1); /* cmd mode */ |
|||
u8g_SetChipSelect(u8g, dev, 1); |
|||
y = pb->p.page_y0; |
|||
ptr = pb->buf; |
|||
disp_ram_adr = WIDTH/8; |
|||
disp_ram_adr *= y; |
|||
for( i = 0; i < 8; i ++ ) |
|||
{ |
|||
u8g_SetAddress(u8g, dev, 1); /* cmd mode */ |
|||
u8g_WriteByte(u8g, dev, 0x00a ); /* display ram (cursor) address low byte */ |
|||
u8g_SetAddress(u8g, dev, 0); /* data mode */ |
|||
u8g_WriteByte(u8g, dev, disp_ram_adr & 0x0ff ); |
|||
|
|||
u8g_SetAddress(u8g, dev, 1); /* cmd mode */ |
|||
u8g_WriteByte(u8g, dev, 0x00b ); /* display ram (cursor) address hight byte */ |
|||
u8g_SetAddress(u8g, dev, 0); /* data mode */ |
|||
u8g_WriteByte(u8g, dev, disp_ram_adr >> 8 ); |
|||
|
|||
u8g_SetAddress(u8g, dev, 1); /* cmd mode */ |
|||
u8g_WriteByte(u8g, dev, 0x00c ); /* write data */ |
|||
u8g_SetAddress(u8g, dev, 0); /* data mode */ |
|||
u8g_WriteSequence(u8g, dev, WIDTH/8, ptr); |
|||
ptr += WIDTH/8; |
|||
disp_ram_adr += WIDTH/8; |
|||
} |
|||
u8g_SetChipSelect(u8g, dev, 0); |
|||
} |
|||
break; |
|||
} |
|||
return u8g_dev_pb8h1f_base_fn(u8g, dev, msg, arg); |
|||
} |
|||
|
|||
U8G_PB_DEV(u8g_dev_lc7981_240x64_8bit, WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_lc7981_240x64_fn, U8G_COM_FAST_PARALLEL); |
|||
|
|||
|
|||
@ -0,0 +1,145 @@ |
|||
/*
|
|||
|
|||
u8g_dev_lc7981_320x64.c |
|||
|
|||
Note: Requires 16 bit mode (Must be enabled in u8g.h) |
|||
|
|||
Tested with Varitronix MGLS32064-03.pdf |
|||
|
|||
Universal 8bit Graphics Library |
|||
|
|||
Copyright (c) 2012, olikraus@gmail.com |
|||
All rights reserved. |
|||
|
|||
Redistribution and use in source and binary forms, with or without modification, |
|||
are permitted provided that the following conditions are met: |
|||
|
|||
* Redistributions of source code must retain the above copyright notice, this list |
|||
of conditions and the following disclaimer. |
|||
|
|||
* Redistributions in binary form must reproduce the above copyright notice, this |
|||
list of conditions and the following disclaimer in the documentation and/or other |
|||
materials provided with the distribution. |
|||
|
|||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
|||
CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
|||
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
|||
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
|||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
|||
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
|||
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
|||
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
|||
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
|||
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF |
|||
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|||
|
|||
|
|||
*/ |
|||
|
|||
#include "u8g.h" |
|||
|
|||
#define WIDTH 320 |
|||
#define HEIGHT 64 |
|||
#define PAGE_HEIGHT 8 |
|||
|
|||
|
|||
/*
|
|||
http://www.gaw.ru/pdf/lcd/lcm/Varitronix/graf/MGLS32064-03.pdf
|
|||
*/ |
|||
|
|||
static const uint8_t u8g_dev_lc7981_320x64_init_seq[] PROGMEM = { |
|||
U8G_ESC_CS(0), /* disable chip */ |
|||
U8G_ESC_ADR(1), /* instruction mode */ |
|||
U8G_ESC_RST(15), /* do reset low pulse with (15*16)+2 milliseconds (=maximum delay)*/ |
|||
U8G_ESC_CS(1), /* enable chip */ |
|||
U8G_ESC_DLY(50), /* delay 50 ms */ |
|||
|
|||
|
|||
U8G_ESC_ADR(1), /* instruction mode */ |
|||
0x000, /* mode register */ |
|||
U8G_ESC_ADR(0), /* data mode */ |
|||
0x032, /* display on (bit 5), master mode on (bit 4), graphics mode on (bit 1)*/ |
|||
|
|||
U8G_ESC_ADR(1), /* instruction mode */ |
|||
0x001, /* character/bits per pixel pitch */ |
|||
U8G_ESC_ADR(0), /* data mode */ |
|||
0x007, /* 8 bits per pixel */ |
|||
|
|||
U8G_ESC_ADR(1), /* instruction mode */ |
|||
0x002, /* number of chars/byte width of the screen */ |
|||
U8G_ESC_ADR(0), /* data mode */ |
|||
WIDTH/8-1, /* 8 bits per pixel */ |
|||
|
|||
U8G_ESC_ADR(1), /* instruction mode */ |
|||
0x003, /* time division */ |
|||
U8G_ESC_ADR(0), /* data mode */ |
|||
0x07f, /* */ |
|||
|
|||
U8G_ESC_ADR(1), /* instruction mode */ |
|||
0x008, /* display start low */ |
|||
U8G_ESC_ADR(0), /* data mode */ |
|||
0x000, /* */ |
|||
|
|||
U8G_ESC_ADR(1), /* instruction mode */ |
|||
0x009, /* display start high */ |
|||
U8G_ESC_ADR(0), /* data mode */ |
|||
0x000, /* */ |
|||
|
|||
U8G_ESC_DLY(10), /* delay 10 ms */ |
|||
|
|||
U8G_ESC_CS(0), /* disable chip */ |
|||
U8G_ESC_END /* end of sequence */ |
|||
}; |
|||
|
|||
uint8_t u8g_dev_lc7981_320x64_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg) |
|||
{ |
|||
switch(msg) |
|||
{ |
|||
case U8G_DEV_MSG_INIT: |
|||
u8g_InitCom(u8g, dev); |
|||
u8g_WriteEscSeqP(u8g, dev, u8g_dev_lc7981_320x64_init_seq); |
|||
break; |
|||
case U8G_DEV_MSG_STOP: |
|||
break; |
|||
case U8G_DEV_MSG_PAGE_NEXT: |
|||
{ |
|||
uint8_t y, i; |
|||
uint16_t disp_ram_adr; |
|||
uint8_t *ptr; |
|||
u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem); |
|||
|
|||
u8g_SetAddress(u8g, dev, 1); /* cmd mode */ |
|||
u8g_SetChipSelect(u8g, dev, 1); |
|||
y = pb->p.page_y0; |
|||
ptr = pb->buf; |
|||
disp_ram_adr = WIDTH/8; |
|||
disp_ram_adr *= y; |
|||
for( i = 0; i < 8; i ++ ) |
|||
{ |
|||
u8g_SetAddress(u8g, dev, 1); /* cmd mode */ |
|||
u8g_WriteByte(u8g, dev, 0x00a ); /* display ram (cursor) address low byte */ |
|||
u8g_SetAddress(u8g, dev, 0); /* data mode */ |
|||
u8g_WriteByte(u8g, dev, disp_ram_adr & 0x0ff ); |
|||
|
|||
u8g_SetAddress(u8g, dev, 1); /* cmd mode */ |
|||
u8g_WriteByte(u8g, dev, 0x00b ); /* display ram (cursor) address hight byte */ |
|||
u8g_SetAddress(u8g, dev, 0); /* data mode */ |
|||
u8g_WriteByte(u8g, dev, disp_ram_adr >> 8 ); |
|||
|
|||
u8g_SetAddress(u8g, dev, 1); /* cmd mode */ |
|||
u8g_WriteByte(u8g, dev, 0x00c ); /* write data */ |
|||
u8g_SetAddress(u8g, dev, 0); /* data mode */ |
|||
u8g_WriteSequence(u8g, dev, WIDTH/8, ptr); |
|||
ptr += WIDTH/8; |
|||
disp_ram_adr += WIDTH/8; |
|||
} |
|||
u8g_SetChipSelect(u8g, dev, 0); |
|||
} |
|||
break; |
|||
} |
|||
return u8g_dev_pb8h1f_base_fn(u8g, dev, msg, arg); |
|||
} |
|||
|
|||
U8G_PB_DEV(u8g_dev_lc7981_320x64_8bit, WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_lc7981_320x64_fn, U8G_COM_FAST_PARALLEL); |
|||
@ -0,0 +1,67 @@ |
|||
/*
|
|||
|
|||
u8g_dev_null.c |
|||
|
|||
Universal 8bit Graphics Library |
|||
|
|||
Copyright (c) 2011, olikraus@gmail.com |
|||
All rights reserved. |
|||
|
|||
Redistribution and use in source and binary forms, with or without modification, |
|||
are permitted provided that the following conditions are met: |
|||
|
|||
* Redistributions of source code must retain the above copyright notice, this list |
|||
of conditions and the following disclaimer. |
|||
|
|||
* Redistributions in binary form must reproduce the above copyright notice, this |
|||
list of conditions and the following disclaimer in the documentation and/or other |
|||
materials provided with the distribution. |
|||
|
|||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
|||
CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
|||
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
|||
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
|||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
|||
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
|||
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
|||
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
|||
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
|||
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF |
|||
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|||
|
|||
|
|||
*/ |
|||
|
|||
#include "u8g.h" |
|||
|
|||
uint8_t u8g_dev_null(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg) |
|||
{ |
|||
switch(msg) |
|||
{ |
|||
case U8G_DEV_MSG_SET_8PIXEL: /* most often used command */ |
|||
break; |
|||
case U8G_DEV_MSG_SET_PIXEL: |
|||
break; |
|||
case U8G_DEV_MSG_INIT: |
|||
break; |
|||
case U8G_DEV_MSG_STOP: |
|||
break; |
|||
case U8G_DEV_MSG_PAGE_FIRST: |
|||
break; |
|||
case U8G_DEV_MSG_PAGE_NEXT: |
|||
break; |
|||
#ifdef U8G_DEV_MSG_IS_BBX_INTERSECTION |
|||
case U8G_DEV_MSG_IS_BBX_INTERSECTION: |
|||
return 1; |
|||
#endif |
|||
case U8G_DEV_MSG_GET_PAGE_BOX: |
|||
break; |
|||
case U8G_DEV_MSG_SET_COLOR_INDEX: |
|||
break; |
|||
case U8G_DEV_MSG_SET_XY_CB: |
|||
break; |
|||
} |
|||
return 1; |
|||
} |
|||
@ -0,0 +1,110 @@ |
|||
/*
|
|||
|
|||
u8g_dev_pcd8544_84x48.c |
|||
|
|||
Display: Nokia 84x48 |
|||
|
|||
Status: Tested with PCF8812 Display |
|||
|
|||
|
|||
Universal 8bit Graphics Library |
|||
|
|||
Copyright (c) 2011, olikraus@gmail.com |
|||
All rights reserved. |
|||
|
|||
Redistribution and use in source and binary forms, with or without modification, |
|||
are permitted provided that the following conditions are met: |
|||
|
|||
* Redistributions of source code must retain the above copyright notice, this list |
|||
of conditions and the following disclaimer. |
|||
|
|||
* Redistributions in binary form must reproduce the above copyright notice, this |
|||
list of conditions and the following disclaimer in the documentation and/or other |
|||
materials provided with the distribution. |
|||
|
|||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
|||
CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
|||
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
|||
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
|||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
|||
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
|||
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
|||
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
|||
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
|||
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF |
|||
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|||
|
|||
|
|||
*/ |
|||
|
|||
#include "u8g.h" |
|||
|
|||
#define WIDTH 84 |
|||
#define HEIGHT 48 |
|||
#define PAGE_HEIGHT 8 |
|||
|
|||
|
|||
static const uint8_t u8g_dev_pcd8544_init_seq[] PROGMEM = { |
|||
U8G_ESC_CS(0), /* disable chip */ |
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
U8G_ESC_RST(1), /* do reset low pulse with (1*16)+2 milliseconds */ |
|||
U8G_ESC_CS(1), /* enable chip */ |
|||
0x021, /* activate chip (PD=0), horizontal increment (V=0), enter extended command set (H=1) */ |
|||
0x006, /* temp. control: b10 = 2 */ |
|||
0x013, /* bias system 1:48 */ |
|||
0x0c0, /* medium Vop */ |
|||
0x020, /* activate chip (PD=0), horizontal increment (V=0), enter normal command set (H=0) */ |
|||
0x00c, /* display on, normal operation */ |
|||
U8G_ESC_DLY(100), /* delay 100 ms */ |
|||
0x020, /* activate chip (PD=0), horizontal increment (V=0), enter normal command set (H=0) */ |
|||
0x00d, /* display on, invert */ |
|||
U8G_ESC_DLY(100), /* delay 100 ms */ |
|||
U8G_ESC_DLY(100), /* delay 100 ms */ |
|||
0x020, /* activate chip (PD=0), horizontal increment (V=0), enter normal command set (H=0) */ |
|||
0x00c, /* display on, normal */ |
|||
U8G_ESC_DLY(100), /* delay 100 ms */ |
|||
U8G_ESC_CS(0), /* disable chip */ |
|||
U8G_ESC_END /* end of sequence */ |
|||
}; |
|||
|
|||
uint8_t u8g_dev_pcd8544_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg) |
|||
{ |
|||
switch(msg) |
|||
{ |
|||
case U8G_DEV_MSG_INIT: |
|||
u8g_InitCom(u8g, dev); |
|||
u8g_WriteEscSeqP(u8g, dev, u8g_dev_pcd8544_init_seq); |
|||
break; |
|||
case U8G_DEV_MSG_STOP: |
|||
break; |
|||
case U8G_DEV_MSG_PAGE_NEXT: |
|||
{ |
|||
u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem); |
|||
u8g_SetAddress(u8g, dev, 0); /* command mode */ |
|||
u8g_SetChipSelect(u8g, dev, 1); |
|||
u8g_WriteByte(u8g, dev, 0x020 ); /* activate chip (PD=0), horizontal increment (V=0), enter normal command set (H=0) */ |
|||
u8g_WriteByte(u8g, dev, 0x080 ); /* set X address */ |
|||
u8g_WriteByte(u8g, dev, 0x040 | pb->p.page); /* set Y address */ |
|||
u8g_SetAddress(u8g, dev, 1); /* data mode */ |
|||
if ( u8g_pb_WriteBuffer(pb, u8g, dev) == 0 ) |
|||
return 0; |
|||
u8g_SetChipSelect(u8g, dev, 0); |
|||
} |
|||
break; |
|||
case U8G_DEV_MSG_CONTRAST: |
|||
/* the contrast adjustment does not work, needs to be analysed */ |
|||
u8g_SetAddress(u8g, dev, 0); /* instruction mode */ |
|||
u8g_SetChipSelect(u8g, dev, 1); |
|||
u8g_WriteByte(u8g, dev, 0x021); /* command mode, extended function set */ |
|||
u8g_WriteByte(u8g, dev, 0x080 | ( (*(uint8_t *)arg) >> 1 ) ); |
|||
u8g_SetChipSelect(u8g, dev, 0); |
|||
return 1; |
|||
} |
|||
return u8g_dev_pb8v1_base_fn(u8g, dev, msg, arg); |
|||
} |
|||
|
|||
|
|||
U8G_PB_DEV(u8g_dev_pcd8544_84x48_sw_spi , WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_pcd8544_fn, U8G_COM_SW_SPI); |
|||
|
|||
@ -0,0 +1,123 @@ |
|||
/*
|
|||
|
|||
u8g_dev_pcf8812_96x65.c |
|||
|
|||
Display: Nokia 96x65 |
|||
|
|||
Universal 8bit Graphics Library |
|||
|
|||
Copyright (c) 2011, olikraus@gmail.com |
|||
All rights reserved. |
|||
|
|||
Redistribution and use in source and binary forms, with or without modification, |
|||
are permitted provided that the following conditions are met: |
|||
|
|||
* Redistributions of source code must retain the above copyright notice, this list |
|||
of conditions and the following disclaimer. |
|||
|
|||
* Redistributions in binary form must reproduce the above copyright notice, this |
|||
list of conditions and the following disclaimer in the documentation and/or other |
|||
materials provided with the distribution. |
|||
|
|||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
|||
CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
|||
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
|||
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
|||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
|||
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
|||
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
|||
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
|||
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
|||
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF |
|||
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|||
|
|||
|
|||
|
|||
om6206 comaptible to pcf8812 ? |
|||
|
|||
Status: Tested |
|||
|
|||
|
|||
Display Controller Seen in |
|||
LPH7366 (9 pins, 84x48) PCD8544 Nokia 5110 / 5120 / 5130 / 5160 / 6110 / 6150 |
|||
LPH7677 (8 pins, 84x48) PCD8544 Nokia 3210 |
|||
LPH7779 (8 pins, 84x48) PCD8544 Nokia 3310 / 3315 / 3330 / 3110, also 3410? |
|||
??? PCD8544 Nokia 5110 / 6110 |
|||
LPH7690 ? (96x65) PCF8455/OM6202 Nokia 3410 |
|||
LPH7690 ? (96x65?) SED1565/S1D15605 Nokia 7110 / 3510? |
|||
LPH7690 ??? Nokia 6210 |
|||
|
|||
|
|||
|
|||
*/ |
|||
|
|||
#include "u8g.h" |
|||
|
|||
#define WIDTH 96 |
|||
#define HEIGHT 65 |
|||
#define PAGE_HEIGHT 8 |
|||
|
|||
|
|||
static const uint8_t u8g_dev_pcf8812_init_seq[] PROGMEM = { |
|||
U8G_ESC_CS(0), /* disable chip */ |
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
U8G_ESC_RST(1), /* do reset low pulse with (1*16)+2 milliseconds */ |
|||
U8G_ESC_CS(1), /* enable chip */ |
|||
0x021, /* activate chip (PD=0), horizontal increment (V=0), enter extended command set (H=1) */ |
|||
0x006, /* temp. control: b10 = 2 */ |
|||
0x013, /* bias system 1:48 */ |
|||
0x080 | 0x040, /* medium Vop */ |
|||
0x020, /* activate chip (PD=0), horizontal increment (V=0), enter normal command set (H=0) */ |
|||
0x00c, /* display on, normal operation */ |
|||
U8G_ESC_DLY(100), /* delay 100 ms */ |
|||
0x020, /* activate chip (PD=0), horizontal increment (V=0), enter normal command set (H=0) */ |
|||
0x00d, /* display on, invert */ |
|||
U8G_ESC_DLY(100), /* delay 100 ms */ |
|||
U8G_ESC_DLY(100), /* delay 100 ms */ |
|||
0x020, /* activate chip (PD=0), horizontal increment (V=0), enter normal command set (H=0) */ |
|||
0x00c, /* display on, normal */ |
|||
U8G_ESC_DLY(100), /* delay 100 ms */ |
|||
U8G_ESC_CS(0), /* disable chip */ |
|||
U8G_ESC_END /* end of sequence */ |
|||
}; |
|||
|
|||
uint8_t u8g_dev_pcf8812_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg) |
|||
{ |
|||
switch(msg) |
|||
{ |
|||
case U8G_DEV_MSG_INIT: |
|||
u8g_InitCom(u8g, dev); |
|||
u8g_WriteEscSeqP(u8g, dev, u8g_dev_pcf8812_init_seq); |
|||
break; |
|||
case U8G_DEV_MSG_STOP: |
|||
break; |
|||
case U8G_DEV_MSG_PAGE_NEXT: |
|||
{ |
|||
u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem); |
|||
u8g_SetAddress(u8g, dev, 0); /* command mode */ |
|||
u8g_SetChipSelect(u8g, dev, 1); |
|||
u8g_WriteByte(u8g, dev, 0x020 ); /* activate chip (PD=0), horizontal increment (V=0), enter normal command set (H=0) */ |
|||
u8g_WriteByte(u8g, dev, 0x080 ); /* set X address */ |
|||
u8g_WriteByte(u8g, dev, 0x040 | pb->p.page); /* set Y address */ |
|||
u8g_SetAddress(u8g, dev, 1); /* data mode */ |
|||
if ( u8g_pb_WriteBuffer(pb, u8g, dev) == 0 ) |
|||
return 0; |
|||
u8g_SetChipSelect(u8g, dev, 0); |
|||
} |
|||
break; |
|||
case U8G_DEV_MSG_CONTRAST: |
|||
/* the contrast adjustment does not work, needs to be analysed */ |
|||
u8g_SetAddress(u8g, dev, 0); /* instruction mode */ |
|||
u8g_SetChipSelect(u8g, dev, 1); |
|||
u8g_WriteByte(u8g, dev, 0x021); /* command mode, extended function set */ |
|||
u8g_WriteByte(u8g, dev, 0x080 | ( (*(uint8_t *)arg) >> 1 ) ); |
|||
u8g_SetChipSelect(u8g, dev, 0); |
|||
return 1; |
|||
} |
|||
return u8g_dev_pb8v1_base_fn(u8g, dev, msg, arg); |
|||
} |
|||
|
|||
/* u8g_com_arduino_sw_spi_fn does not work, too fast??? */ |
|||
U8G_PB_DEV(u8g_dev_pcf8812_96x65_sw_spi , WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_pcf8812_fn, U8G_COM_SW_SPI); |
|||
@ -0,0 +1,107 @@ |
|||
/*
|
|||
|
|||
u8g_dev_sbn1661_122x32.c |
|||
|
|||
WG12232 display with 2xSBN1661 / SED1520 controller (122x32 display) |
|||
At the moment only available in the Arduino Environment |
|||
|
|||
Universal 8bit Graphics Library |
|||
|
|||
Copyright (c) 2011, olikraus@gmail.com |
|||
All rights reserved. |
|||
|
|||
Redistribution and use in source and binary forms, with or without modification, |
|||
are permitted provided that the following conditions are met: |
|||
|
|||
* Redistributions of source code must retain the above copyright notice, this list |
|||
of conditions and the following disclaimer. |
|||
|
|||
* Redistributions in binary form must reproduce the above copyright notice, this |
|||
list of conditions and the following disclaimer in the documentation and/or other |
|||
materials provided with the distribution. |
|||
|
|||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
|||
CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
|||
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
|||
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
|||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
|||
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
|||
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
|||
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
|||
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
|||
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF |
|||
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|||
|
|||
|
|||
*/ |
|||
|
|||
#include "u8g.h" |
|||
|
|||
#define WIDTH 122 |
|||
#define HEIGHT 32 |
|||
#define PAGE_HEIGHT 8 |
|||
|
|||
|
|||
static const uint8_t u8g_dev_sbn1661_122x32_init_seq[] PROGMEM = { |
|||
U8G_ESC_CS(0), /* disable chip */ |
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
U8G_ESC_RST(15), /* do reset low pulse with (15*16)+2 milliseconds */ |
|||
U8G_ESC_CS(1), /* enable chip 1 */ |
|||
0x0af, /* display on */ |
|||
0x0c0, /* display start at line 0 */ |
|||
0x0a0, /* a0: ADC forward, a1: ADC reverse */ |
|||
0x0a9, /* a8: 1/16, a9: 1/32 duty */ |
|||
U8G_ESC_CS(2), /* enable chip 2 */ |
|||
0x0af, /* display on */ |
|||
0x0c0, /* display start at line 0 */ |
|||
0x0a0, /* a0: ADC forward, a1: ADC reverse */ |
|||
0x0a9, /* a8: 1/16, a9: 1/32 duty */ |
|||
|
|||
U8G_ESC_CS(0), /* disable chip */ |
|||
|
|||
|
|||
U8G_ESC_END /* end of sequence */ |
|||
}; |
|||
|
|||
uint8_t u8g_dev_sbn1661_122x32_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg) |
|||
{ |
|||
switch(msg) |
|||
{ |
|||
case U8G_DEV_MSG_INIT: |
|||
u8g_InitCom(u8g, dev); |
|||
u8g_WriteEscSeqP(u8g, dev, u8g_dev_sbn1661_122x32_init_seq); |
|||
break; |
|||
case U8G_DEV_MSG_STOP: |
|||
break; |
|||
case U8G_DEV_MSG_PAGE_NEXT: |
|||
{ |
|||
u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem); |
|||
|
|||
u8g_SetAddress(u8g, dev, 0); /* command mode */ |
|||
u8g_SetChipSelect(u8g, dev, 1); |
|||
u8g_WriteByte(u8g, dev, 0x0b8 | pb->p.page); /* select current page (SBN1661/SED1520) */ |
|||
u8g_WriteByte(u8g, dev, 0x000 ); /* set X address */ |
|||
u8g_SetAddress(u8g, dev, 1); /* data mode */ |
|||
u8g_WriteSequence(u8g, dev, WIDTH/2, pb->buf); |
|||
|
|||
u8g_SetAddress(u8g, dev, 0); /* command mode */ |
|||
u8g_SetChipSelect(u8g, dev, 2); |
|||
u8g_WriteByte(u8g, dev, 0x0b8 | pb->p.page); /* select current page (SBN1661/SED1520) */ |
|||
u8g_WriteByte(u8g, dev, 0x000 ); /* set X address */ |
|||
u8g_SetAddress(u8g, dev, 1); /* data mode */ |
|||
u8g_WriteSequence(u8g, dev, WIDTH/2, WIDTH/2+(uint8_t *)pb->buf); |
|||
|
|||
u8g_SetChipSelect(u8g, dev, 0); |
|||
|
|||
} |
|||
break; |
|||
case U8G_DEV_MSG_CONTRAST: |
|||
break; |
|||
} |
|||
return u8g_dev_pb8v1_base_fn(u8g, dev, msg, arg); |
|||
} |
|||
|
|||
/* u8g_com_arduino_sw_spi_fn does not work, too fast??? */ |
|||
U8G_PB_DEV(u8g_dev_sbn1661_122x32 , WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_sbn1661_122x32_fn, u8g_com_arduino_no_en_parallel_fn); |
|||
@ -0,0 +1,247 @@ |
|||
/*
|
|||
|
|||
u8g_dev_ssd1306_128x32.c |
|||
|
|||
Universal 8bit Graphics Library |
|||
|
|||
Copyright (c) 2011, olikraus@gmail.com |
|||
All rights reserved. |
|||
|
|||
Redistribution and use in source and binary forms, with or without modification, |
|||
are permitted provided that the following conditions are met: |
|||
|
|||
* Redistributions of source code must retain the above copyright notice, this list |
|||
of conditions and the following disclaimer. |
|||
|
|||
* Redistributions in binary form must reproduce the above copyright notice, this |
|||
list of conditions and the following disclaimer in the documentation and/or other |
|||
materials provided with the distribution. |
|||
|
|||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
|||
CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
|||
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
|||
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
|||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
|||
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
|||
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
|||
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
|||
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
|||
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF |
|||
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|||
|
|||
|
|||
23 Feb 2013: Fixed, Issue 147 |
|||
|
|||
*/ |
|||
|
|||
|
|||
#include "u8g.h" |
|||
|
|||
#define WIDTH 128 |
|||
#define HEIGHT 32 |
|||
#define PAGE_HEIGHT 8 |
|||
|
|||
|
|||
/* init sequence adafruit 128x32 OLED (NOT TESTED) */ |
|||
static const uint8_t u8g_dev_ssd1306_128x32_adafruit1_init_seq[] PROGMEM = { |
|||
U8G_ESC_CS(0), /* disable chip */ |
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
U8G_ESC_RST(1), /* do reset low pulse with (1*16)+2 milliseconds */ |
|||
U8G_ESC_CS(1), /* enable chip */ |
|||
|
|||
0x0ae, /* display off, sleep mode */ |
|||
0x0d5, 0x080, /* clock divide ratio (0x00=1) and oscillator frequency (0x8) */ |
|||
0x0a8, 0x03f, /* */ |
|||
|
|||
0x0d3, 0x000, /* */ |
|||
|
|||
0x040, /* start line */ |
|||
|
|||
0x08d, 0x010, /* [1] charge pump setting (p62): 0x014 enable, 0x010 disable */ |
|||
|
|||
0x020, 0x000, /* */ |
|||
0x0a1, /* segment remap a0/a1*/ |
|||
0x0c8, /* c0: scan dir normal, c8: reverse */ |
|||
0x0da, 0x012, /* com pin HW config, sequential com pin config (bit 4), disable left/right remap (bit 5) */ |
|||
0x081, 0x09f, /* [1] set contrast control */ |
|||
0x0d9, 0x022, /* [1] pre-charge period 0x022/f1*/ |
|||
0x0db, 0x040, /* vcomh deselect level */ |
|||
|
|||
0x02e, /* 2012-05-27: Deactivate scroll */ |
|||
0x0a4, /* output ram to display */ |
|||
0x0a6, /* none inverted normal display mode */ |
|||
0x0af, /* display on */ |
|||
|
|||
U8G_ESC_CS(0), /* disable chip */ |
|||
U8G_ESC_END /* end of sequence */ |
|||
}; |
|||
|
|||
|
|||
/* init sequence adafruit 128x32 OLED (NOT TESTED) */ |
|||
static const uint8_t u8g_dev_ssd1306_128x32_adafruit2_init_seq[] PROGMEM = { |
|||
U8G_ESC_CS(0), /* disable chip */ |
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
U8G_ESC_RST(1), /* do reset low pulse with (1*16)+2 milliseconds */ |
|||
U8G_ESC_CS(1), /* enable chip */ |
|||
|
|||
0x0ae, /* display off, sleep mode */ |
|||
0x0d5, 0x080, /* clock divide ratio (0x00=1) and oscillator frequency (0x8) */ |
|||
0x0a8, 0x03f, /* */ |
|||
|
|||
0x0d3, 0x000, /* */ |
|||
|
|||
0x040, /* start line */ |
|||
|
|||
0x08d, 0x014, /* [2] charge pump setting (p62): 0x014 enable, 0x010 disable */ |
|||
|
|||
0x020, 0x000, /* */ |
|||
0x0a1, /* segment remap a0/a1*/ |
|||
0x0c8, /* c0: scan dir normal, c8: reverse */ |
|||
0x0da, 0x012, /* com pin HW config, sequential com pin config (bit 4), disable left/right remap (bit 5) */ |
|||
0x081, 0x0cf, /* [2] set contrast control */ |
|||
0x0d9, 0x0f1, /* [2] pre-charge period 0x022/f1*/ |
|||
0x0db, 0x040, /* vcomh deselect level */ |
|||
|
|||
0x02e, /* 2012-05-27: Deactivate scroll */ |
|||
0x0a4, /* output ram to display */ |
|||
0x0a6, /* none inverted normal display mode */ |
|||
0x0af, /* display on */ |
|||
|
|||
U8G_ESC_CS(0), /* disable chip */ |
|||
U8G_ESC_END /* end of sequence */ |
|||
}; |
|||
|
|||
|
|||
/* init sequence adafruit 128x32 OLED (TESTED - WORKING 23.02.13), like adafruit3, but with page addressing mode */ |
|||
static const uint8_t u8g_dev_ssd1306_128x32_adafruit3_init_seq[] PROGMEM = { |
|||
U8G_ESC_CS(0), /* disable chip */ |
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
U8G_ESC_RST(1), /* do reset low pulse with (1*16)+2 milliseconds */ |
|||
U8G_ESC_CS(1), /* enable chip */ |
|||
|
|||
0x0ae, /* display off, sleep mode */ |
|||
0x0d5, 0x080, /* clock divide ratio (0x00=1) and oscillator frequency (0x8) */ |
|||
0x0a8, 0x01f, /* Feb 23, 2013: 128x32 OLED: 0x01f, 128x64 OLED 0x03f */ |
|||
|
|||
0x0d3, 0x000, /* */ |
|||
|
|||
0x040, /* start line */ |
|||
|
|||
0x08d, 0x014, /* [2] charge pump setting (p62): 0x014 enable, 0x010 disable */ |
|||
|
|||
0x020, 0x002, /* com pin HW config, sequential com pin config (bit 4), disable left/right remap (bit 5), Feb 23, 2013: 128x32 OLED: 0x002, 128x64 OLED 0x012 */ |
|||
0x0a1, /* segment remap a0/a1*/ |
|||
0x0c8, /* c0: scan dir normal, c8: reverse */ |
|||
0x0da, 0x002, /* com pin HW config, sequential com pin config (bit 4), disable left/right remap (bit 5) */ |
|||
0x081, 0x0cf, /* [2] set contrast control */ |
|||
0x0d9, 0x0f1, /* [2] pre-charge period 0x022/f1*/ |
|||
0x0db, 0x040, /* vcomh deselect level */ |
|||
|
|||
0x02e, /* 2012-05-27: Deactivate scroll */ |
|||
0x0a4, /* output ram to display */ |
|||
0x0a6, /* none inverted normal display mode */ |
|||
0x0af, /* display on */ |
|||
|
|||
U8G_ESC_CS(0), /* disable chip */ |
|||
U8G_ESC_END /* end of sequence */ |
|||
}; |
|||
|
|||
|
|||
/* init sequence Univision datasheet (NOT TESTED) */ |
|||
static const uint8_t u8g_dev_ssd1306_128x32_univision_init_seq[] PROGMEM = { |
|||
U8G_ESC_CS(0), /* disable chip */ |
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
U8G_ESC_RST(1), /* do reset low pulse with (1*16)+2 milliseconds */ |
|||
U8G_ESC_CS(1), /* enable chip */ |
|||
|
|||
0x0ae, /* display off, sleep mode */ |
|||
0x0d5, 0x080, /* clock divide ratio (0x00=1) and oscillator frequency (0x8) */ |
|||
0x0a8, 0x03f, /* multiplex ratio */ |
|||
0x0d3, 0x000, /* display offset */ |
|||
0x040, /* start line */ |
|||
0x08d, 0x010, /* charge pump setting (p62): 0x014 enable, 0x010 disable */ |
|||
0x0a1, /* segment remap a0/a1*/ |
|||
0x0c8, /* c0: scan dir normal, c8: reverse */ |
|||
0x0da, 0x012, /* com pin HW config, sequential com pin config (bit 4), disable left/right remap (bit 5) */ |
|||
0x081, 0x09f, /* set contrast control */ |
|||
0x0d9, 0x022, /* pre-charge period */ |
|||
0x0db, 0x040, /* vcomh deselect level */ |
|||
0x022, 0x000, /* page addressing mode WRONG: 3 byte cmd! */ |
|||
0x0a4, /* output ram to display */ |
|||
0x0a6, /* none inverted normal display mode */ |
|||
0x0af, /* display on */ |
|||
U8G_ESC_CS(0), /* disable chip */ |
|||
U8G_ESC_END /* end of sequence */ |
|||
}; |
|||
|
|||
|
|||
/* select one init sequence here */ |
|||
//define u8g_dev_ssd1306_128x32_init_seq u8g_dev_ssd1306_128x32_univision_init_seq
|
|||
//define u8g_dev_ssd1306_128x32_init_seq u8g_dev_ssd1306_128x32_adafruit1_init_seq
|
|||
//define u8g_dev_ssd1306_128x32_init_seq u8g_dev_ssd1306_128x32_adafruit2_init_seq
|
|||
#define u8g_dev_ssd1306_128x32_init_seq u8g_dev_ssd1306_128x32_adafruit3_init_seq |
|||
|
|||
|
|||
static const uint8_t u8g_dev_ssd1306_128x32_data_start[] PROGMEM = { |
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
U8G_ESC_CS(1), /* enable chip */ |
|||
0x010, /* set upper 4 bit of the col adr. to 0 */ |
|||
0x000, /* set lower 4 bit of the col adr. to 4 */ |
|||
U8G_ESC_END /* end of sequence */ |
|||
}; |
|||
|
|||
static const uint8_t u8g_dev_ssd13xx_sleep_on[] PROGMEM = { |
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
U8G_ESC_CS(1), /* enable chip */ |
|||
0x0ae, /* display off */ |
|||
U8G_ESC_CS(1), /* disable chip */ |
|||
U8G_ESC_END /* end of sequence */ |
|||
}; |
|||
|
|||
static const uint8_t u8g_dev_ssd13xx_sleep_off[] PROGMEM = { |
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
U8G_ESC_CS(1), /* enable chip */ |
|||
0x0af, /* display on */ |
|||
U8G_ESC_DLY(50), /* delay 50 ms */ |
|||
U8G_ESC_CS(1), /* disable chip */ |
|||
U8G_ESC_END /* end of sequence */ |
|||
}; |
|||
|
|||
uint8_t u8g_dev_ssd1306_128x32_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg) |
|||
{ |
|||
switch(msg) |
|||
{ |
|||
case U8G_DEV_MSG_INIT: |
|||
u8g_InitCom(u8g, dev); |
|||
u8g_WriteEscSeqP(u8g, dev, u8g_dev_ssd1306_128x32_init_seq); |
|||
break; |
|||
case U8G_DEV_MSG_STOP: |
|||
break; |
|||
case U8G_DEV_MSG_PAGE_NEXT: |
|||
{ |
|||
u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem); |
|||
u8g_WriteEscSeqP(u8g, dev, u8g_dev_ssd1306_128x32_data_start); |
|||
u8g_WriteByte(u8g, dev, 0x0b0 | pb->p.page); /* select current page (SSD1306) */ |
|||
u8g_SetAddress(u8g, dev, 1); /* data mode */ |
|||
if ( u8g_pb_WriteBuffer(pb, u8g, dev) == 0 ) |
|||
return 0; |
|||
u8g_SetChipSelect(u8g, dev, 0); |
|||
} |
|||
break; |
|||
case U8G_DEV_MSG_SLEEP_ON: |
|||
u8g_WriteEscSeqP(u8g, dev, u8g_dev_ssd13xx_sleep_on); |
|||
return 1; |
|||
case U8G_DEV_MSG_SLEEP_OFF: |
|||
u8g_WriteEscSeqP(u8g, dev, u8g_dev_ssd13xx_sleep_off); |
|||
return 1; |
|||
} |
|||
|
|||
return u8g_dev_pb8v1_base_fn(u8g, dev, msg, arg); |
|||
} |
|||
|
|||
U8G_PB_DEV(u8g_dev_ssd1306_128x32_sw_spi, WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_ssd1306_128x32_fn, U8G_COM_SW_SPI); |
|||
U8G_PB_DEV(u8g_dev_ssd1306_128x32_hw_spi, WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_ssd1306_128x32_fn, U8G_COM_HW_SPI); |
|||
U8G_PB_DEV(u8g_dev_ssd1306_128x32_i2c, WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_ssd1306_128x32_fn, U8G_COM_SSD_I2C); |
|||
|
|||
@ -0,0 +1,237 @@ |
|||
/*
|
|||
|
|||
u8g_dev_ssd1306_128x64.c |
|||
|
|||
Universal 8bit Graphics Library |
|||
|
|||
Copyright (c) 2011, olikraus@gmail.com |
|||
All rights reserved. |
|||
|
|||
Redistribution and use in source and binary forms, with or without modification, |
|||
are permitted provided that the following conditions are met: |
|||
|
|||
* Redistributions of source code must retain the above copyright notice, this list |
|||
of conditions and the following disclaimer. |
|||
|
|||
* Redistributions in binary form must reproduce the above copyright notice, this |
|||
list of conditions and the following disclaimer in the documentation and/or other |
|||
materials provided with the distribution. |
|||
|
|||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
|||
CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
|||
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
|||
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
|||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
|||
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
|||
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
|||
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
|||
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
|||
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF |
|||
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|||
|
|||
|
|||
*/ |
|||
|
|||
#include "u8g.h" |
|||
|
|||
#define WIDTH 128 |
|||
#define HEIGHT 64 |
|||
#define PAGE_HEIGHT 8 |
|||
|
|||
/* init sequence adafruit 128x64 OLED (NOT TESTED) */ |
|||
static const uint8_t u8g_dev_ssd1306_128x64_adafruit1_init_seq[] PROGMEM = { |
|||
U8G_ESC_CS(0), /* disable chip */ |
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
U8G_ESC_RST(1), /* do reset low pulse with (1*16)+2 milliseconds */ |
|||
U8G_ESC_CS(1), /* enable chip */ |
|||
|
|||
0x0ae, /* display off, sleep mode */ |
|||
0x0d5, 0x080, /* clock divide ratio (0x00=1) and oscillator frequency (0x8) */ |
|||
0x0a8, 0x03f, /* */ |
|||
|
|||
0x0d3, 0x000, /* */ |
|||
|
|||
0x040, /* start line */ |
|||
|
|||
0x08d, 0x010, /* [1] charge pump setting (p62): 0x014 enable, 0x010 disable */ |
|||
|
|||
0x020, 0x000, /* */ |
|||
0x0a1, /* segment remap a0/a1*/ |
|||
0x0c8, /* c0: scan dir normal, c8: reverse */ |
|||
0x0da, 0x012, /* com pin HW config, sequential com pin config (bit 4), disable left/right remap (bit 5) */ |
|||
0x081, 0x09f, /* [1] set contrast control */ |
|||
0x0d9, 0x022, /* [1] pre-charge period 0x022/f1*/ |
|||
0x0db, 0x040, /* vcomh deselect level */ |
|||
|
|||
0x02e, /* 2012-05-27: Deactivate scroll */ |
|||
0x0a4, /* output ram to display */ |
|||
0x0a6, /* none inverted normal display mode */ |
|||
0x0af, /* display on */ |
|||
|
|||
U8G_ESC_CS(0), /* disable chip */ |
|||
U8G_ESC_END /* end of sequence */ |
|||
}; |
|||
|
|||
/* init sequence adafruit 128x64 OLED (NOT TESTED) */ |
|||
static const uint8_t u8g_dev_ssd1306_128x64_adafruit2_init_seq[] PROGMEM = { |
|||
U8G_ESC_CS(0), /* disable chip */ |
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
U8G_ESC_RST(1), /* do reset low pulse with (1*16)+2 milliseconds */ |
|||
U8G_ESC_CS(1), /* enable chip */ |
|||
|
|||
0x0ae, /* display off, sleep mode */ |
|||
0x0d5, 0x080, /* clock divide ratio (0x00=1) and oscillator frequency (0x8) */ |
|||
0x0a8, 0x03f, /* */ |
|||
|
|||
0x0d3, 0x000, /* */ |
|||
|
|||
0x040, /* start line */ |
|||
|
|||
0x08d, 0x014, /* [2] charge pump setting (p62): 0x014 enable, 0x010 disable */ |
|||
|
|||
0x020, 0x000, /* */ |
|||
0x0a1, /* segment remap a0/a1*/ |
|||
0x0c8, /* c0: scan dir normal, c8: reverse */ |
|||
0x0da, 0x012, /* com pin HW config, sequential com pin config (bit 4), disable left/right remap (bit 5) */ |
|||
0x081, 0x0cf, /* [2] set contrast control */ |
|||
0x0d9, 0x0f1, /* [2] pre-charge period 0x022/f1*/ |
|||
0x0db, 0x040, /* vcomh deselect level */ |
|||
|
|||
0x02e, /* 2012-05-27: Deactivate scroll */ |
|||
0x0a4, /* output ram to display */ |
|||
0x0a6, /* none inverted normal display mode */ |
|||
0x0af, /* display on */ |
|||
|
|||
U8G_ESC_CS(0), /* disable chip */ |
|||
U8G_ESC_END /* end of sequence */ |
|||
}; |
|||
|
|||
/* init sequence adafruit 128x64 OLED (NOT TESTED), like adafruit3, but with page addressing mode */ |
|||
static const uint8_t u8g_dev_ssd1306_128x64_adafruit3_init_seq[] PROGMEM = { |
|||
U8G_ESC_CS(0), /* disable chip */ |
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
U8G_ESC_RST(1), /* do reset low pulse with (1*16)+2 milliseconds */ |
|||
U8G_ESC_CS(1), /* enable chip */ |
|||
|
|||
0x0ae, /* display off, sleep mode */ |
|||
0x0d5, 0x080, /* clock divide ratio (0x00=1) and oscillator frequency (0x8) */ |
|||
0x0a8, 0x03f, /* */ |
|||
|
|||
0x0d3, 0x000, /* */ |
|||
|
|||
0x040, /* start line */ |
|||
|
|||
0x08d, 0x014, /* [2] charge pump setting (p62): 0x014 enable, 0x010 disable */ |
|||
|
|||
0x020, 0x002, /* 2012-05-27: page addressing mode */ |
|||
0x0a1, /* segment remap a0/a1*/ |
|||
0x0c8, /* c0: scan dir normal, c8: reverse */ |
|||
0x0da, 0x012, /* com pin HW config, sequential com pin config (bit 4), disable left/right remap (bit 5) */ |
|||
0x081, 0x0cf, /* [2] set contrast control */ |
|||
0x0d9, 0x0f1, /* [2] pre-charge period 0x022/f1*/ |
|||
0x0db, 0x040, /* vcomh deselect level */ |
|||
|
|||
0x02e, /* 2012-05-27: Deactivate scroll */ |
|||
0x0a4, /* output ram to display */ |
|||
0x0a6, /* none inverted normal display mode */ |
|||
0x0af, /* display on */ |
|||
|
|||
U8G_ESC_CS(0), /* disable chip */ |
|||
U8G_ESC_END /* end of sequence */ |
|||
}; |
|||
|
|||
/* init sequence Univision datasheet (NOT TESTED) */ |
|||
static const uint8_t u8g_dev_ssd1306_128x64_univision_init_seq[] PROGMEM = { |
|||
U8G_ESC_CS(0), /* disable chip */ |
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
U8G_ESC_RST(1), /* do reset low pulse with (1*16)+2 milliseconds */ |
|||
U8G_ESC_CS(1), /* enable chip */ |
|||
|
|||
0x0ae, /* display off, sleep mode */ |
|||
0x0d5, 0x080, /* clock divide ratio (0x00=1) and oscillator frequency (0x8) */ |
|||
0x0a8, 0x03f, /* multiplex ratio */ |
|||
0x0d3, 0x000, /* display offset */ |
|||
0x040, /* start line */ |
|||
0x08d, 0x010, /* charge pump setting (p62): 0x014 enable, 0x010 disable */ |
|||
0x0a1, /* segment remap a0/a1*/ |
|||
0x0c8, /* c0: scan dir normal, c8: reverse */ |
|||
0x0da, 0x012, /* com pin HW config, sequential com pin config (bit 4), disable left/right remap (bit 5) */ |
|||
0x081, 0x09f, /* set contrast control */ |
|||
0x0d9, 0x022, /* pre-charge period */ |
|||
0x0db, 0x040, /* vcomh deselect level */ |
|||
0x022, 0x000, /* page addressing mode WRONG: 3 byte cmd! */ |
|||
0x0a4, /* output ram to display */ |
|||
0x0a6, /* none inverted normal display mode */ |
|||
0x0af, /* display on */ |
|||
U8G_ESC_CS(0), /* disable chip */ |
|||
U8G_ESC_END /* end of sequence */ |
|||
}; |
|||
|
|||
/* select one init sequence here */ |
|||
//#define u8g_dev_ssd1306_128x64_init_seq u8g_dev_ssd1306_128x64_univision_init_seq
|
|||
//#define u8g_dev_ssd1306_128x64_init_seq u8g_dev_ssd1306_128x64_adafruit1_init_seq
|
|||
//#define u8g_dev_ssd1306_128x64_init_seq u8g_dev_ssd1306_128x64_adafruit2_init_seq
|
|||
#define u8g_dev_ssd1306_128x64_init_seq u8g_dev_ssd1306_128x64_adafruit3_init_seq |
|||
|
|||
|
|||
static const uint8_t u8g_dev_ssd1306_128x64_data_start[] PROGMEM = { |
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
U8G_ESC_CS(1), /* enable chip */ |
|||
0x010, /* set upper 4 bit of the col adr to 0 */ |
|||
0x000, /* set lower 4 bit of the col adr to 4 */ |
|||
U8G_ESC_END /* end of sequence */ |
|||
}; |
|||
|
|||
static const uint8_t u8g_dev_ssd13xx_sleep_on[] PROGMEM = { |
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
U8G_ESC_CS(1), /* enable chip */ |
|||
0x0ae, /* display off */ |
|||
U8G_ESC_CS(1), /* disable chip */ |
|||
U8G_ESC_END /* end of sequence */ |
|||
}; |
|||
|
|||
static const uint8_t u8g_dev_ssd13xx_sleep_off[] PROGMEM = { |
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
U8G_ESC_CS(1), /* enable chip */ |
|||
0x0af, /* display on */ |
|||
U8G_ESC_DLY(50), /* delay 50 ms */ |
|||
U8G_ESC_CS(1), /* disable chip */ |
|||
U8G_ESC_END /* end of sequence */ |
|||
}; |
|||
|
|||
uint8_t u8g_dev_ssd1306_128x64_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg) |
|||
{ |
|||
switch(msg) |
|||
{ |
|||
case U8G_DEV_MSG_INIT: |
|||
u8g_InitCom(u8g, dev); |
|||
u8g_WriteEscSeqP(u8g, dev, u8g_dev_ssd1306_128x64_init_seq); |
|||
break; |
|||
case U8G_DEV_MSG_STOP: |
|||
break; |
|||
case U8G_DEV_MSG_PAGE_NEXT: |
|||
{ |
|||
u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem); |
|||
u8g_WriteEscSeqP(u8g, dev, u8g_dev_ssd1306_128x64_data_start); |
|||
u8g_WriteByte(u8g, dev, 0x0b0 | pb->p.page); /* select current page (SSD1306) */ |
|||
u8g_SetAddress(u8g, dev, 1); /* data mode */ |
|||
if ( u8g_pb_WriteBuffer(pb, u8g, dev) == 0 ) |
|||
return 0; |
|||
u8g_SetChipSelect(u8g, dev, 0); |
|||
} |
|||
break; |
|||
case U8G_DEV_MSG_SLEEP_ON: |
|||
u8g_WriteEscSeqP(u8g, dev, u8g_dev_ssd13xx_sleep_on); |
|||
return 1; |
|||
case U8G_DEV_MSG_SLEEP_OFF: |
|||
u8g_WriteEscSeqP(u8g, dev, u8g_dev_ssd13xx_sleep_off); |
|||
return 1; |
|||
} |
|||
return u8g_dev_pb8v1_base_fn(u8g, dev, msg, arg); |
|||
} |
|||
|
|||
U8G_PB_DEV(u8g_dev_ssd1306_128x64_sw_spi, WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_ssd1306_128x64_fn, U8G_COM_SW_SPI); |
|||
U8G_PB_DEV(u8g_dev_ssd1306_128x64_hw_spi, WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_ssd1306_128x64_fn, U8G_COM_HW_SPI); |
|||
U8G_PB_DEV(u8g_dev_ssd1306_128x64_i2c, WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_ssd1306_128x64_fn, U8G_COM_SSD_I2C); |
|||
@ -0,0 +1,144 @@ |
|||
/*
|
|||
|
|||
u8g_dev_ssd1309_128x64.c |
|||
|
|||
Universal 8bit Graphics Library |
|||
|
|||
Copyright (c) 2012, olikraus@gmail.com |
|||
All rights reserved. |
|||
|
|||
Redistribution and use in source and binary forms, with or without modification, |
|||
are permitted provided that the following conditions are met: |
|||
|
|||
* Redistributions of source code must retain the above copyright notice, this list |
|||
of conditions and the following disclaimer. |
|||
|
|||
* Redistributions in binary form must reproduce the above copyright notice, this |
|||
list of conditions and the following disclaimer in the documentation and/or other |
|||
materials provided with the distribution. |
|||
|
|||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
|||
CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
|||
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
|||
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
|||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
|||
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
|||
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
|||
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
|||
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
|||
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF |
|||
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|||
|
|||
|
|||
*/ |
|||
|
|||
#include "u8g.h" |
|||
|
|||
#define WIDTH 128 |
|||
#define HEIGHT 64 |
|||
#define PAGE_HEIGHT 8 |
|||
|
|||
|
|||
/* ssd1309 ini sequence*/ |
|||
static const uint8_t u8g_dev_ssd1309_128x64_init_seq[] PROGMEM={ |
|||
U8G_ESC_CS(0), /* disable chip */ |
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
U8G_ESC_RST(1), /* do reset low pulse with (1*16)+2 milliseconds */ |
|||
U8G_ESC_CS(1), /* enable chip */ |
|||
|
|||
0xfd,0x12, /*Command Lock */ |
|||
0xae, /*Set Display Off */ |
|||
0xd5,0xa0, /*set Display Clock Divide Ratio/Oscillator Frequency */ |
|||
0xa8,0x3f, /*Set Multiplex Ratio */ |
|||
0x3d,0x00, /*Set Display Offset*/ |
|||
0x40, /*Set Display Start Line*/ |
|||
0xa1, /*Set Segment Re-Map*/ |
|||
0xc8, /*Set COM Output Scan Direction*/ |
|||
0xda,0x12, /*Set COM Pins Hardware Configuration*/ |
|||
0x81,0xdf, /*Set Current Control */ |
|||
0xd9,0x82, /*Set Pre-Charge Period */ |
|||
0xdb,0x34, /*Set VCOMH Deselect Level */ |
|||
0xa4, /*Set Entire Display On/Off */ |
|||
0xa6, /*Set Normal/Inverse Display*/ |
|||
U8G_ESC_VCC(1), /*Power up VCC & Stabilized */ |
|||
U8G_ESC_DLY(50), |
|||
0xaf, /*Set Display On */ |
|||
U8G_ESC_DLY(50), |
|||
U8G_ESC_CS(0), /* disable chip */ |
|||
U8G_ESC_END /* end of sequence */ |
|||
}; |
|||
|
|||
/* select one init sequence here */ |
|||
#define u8g_dev_ssd1309_128x64_init_seq u8g_dev_ssd1309_128x64_init_seq |
|||
|
|||
|
|||
static const uint8_t u8g_dev_ssd1309_128x64_data_start[] PROGMEM = { |
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
U8G_ESC_CS(1), /* enable chip */ |
|||
0x010, /* set upper 4 bit of the col adr to 0 */ |
|||
0x000, /* set lower 4 bit of the col adr to 4 */ |
|||
U8G_ESC_END /* end of sequence */ |
|||
}; |
|||
|
|||
static const uint8_t u8g_dev_ssd13xx_sleep_on[] PROGMEM = { |
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
U8G_ESC_CS(1), /* enable chip */ |
|||
0x0ae, /* display off */ |
|||
U8G_ESC_CS(1), /* disable chip */ |
|||
U8G_ESC_END /* end of sequence */ |
|||
}; |
|||
|
|||
static const uint8_t u8g_dev_ssd13xx_sleep_off[] PROGMEM = { |
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
U8G_ESC_CS(1), /* enable chip */ |
|||
0x0af, /* display on */ |
|||
U8G_ESC_DLY(50), /* delay 50 ms */ |
|||
U8G_ESC_CS(1), /* disable chip */ |
|||
U8G_ESC_END /* end of sequence */ |
|||
}; |
|||
|
|||
uint8_t u8g_dev_ssd1309_128x64_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg) |
|||
{ |
|||
switch(msg) |
|||
{ |
|||
case U8G_DEV_MSG_INIT: |
|||
u8g_InitCom(u8g, dev); |
|||
u8g_WriteEscSeqP(u8g, dev, u8g_dev_ssd1309_128x64_init_seq); |
|||
break; |
|||
case U8G_DEV_MSG_STOP: |
|||
break; |
|||
case U8G_DEV_MSG_PAGE_NEXT: |
|||
{ |
|||
u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem); |
|||
u8g_WriteEscSeqP(u8g, dev, u8g_dev_ssd1309_128x64_data_start); |
|||
u8g_WriteByte(u8g, dev, 0x0b0 | pb->p.page); /* select current page (SSD1306) */ |
|||
u8g_SetAddress(u8g, dev, 1); /* data mode */ |
|||
if ( u8g_pb_WriteBuffer(pb, u8g, dev) == 0 ) |
|||
return 0; |
|||
u8g_SetChipSelect(u8g, dev, 0); |
|||
} |
|||
break; |
|||
case U8G_DEV_MSG_CONTRAST: |
|||
u8g_SetChipSelect(u8g, dev, 1); |
|||
u8g_SetAddress(u8g, dev, 0); /* instruction mode */ |
|||
u8g_WriteByte(u8g, dev, 0x081); |
|||
u8g_WriteByte(u8g, dev, (*(uint8_t *)arg) >> 2); |
|||
u8g_SetChipSelect(u8g, dev, 0); |
|||
return 1; |
|||
case U8G_DEV_MSG_SLEEP_ON: |
|||
u8g_WriteEscSeqP(u8g, dev, u8g_dev_ssd13xx_sleep_on); |
|||
return 1; |
|||
case U8G_DEV_MSG_SLEEP_OFF: |
|||
u8g_WriteEscSeqP(u8g, dev, u8g_dev_ssd13xx_sleep_off); |
|||
return 1; |
|||
} |
|||
return u8g_dev_pb8v1_base_fn(u8g, dev, msg, arg); |
|||
} |
|||
|
|||
U8G_PB_DEV(u8g_dev_ssd1309_128x64_hw_spi, WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_ssd1309_128x64_fn, U8G_COM_HW_SPI); |
|||
U8G_PB_DEV(u8g_dev_ssd1309_128x64_sw_spi, WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_ssd1309_128x64_fn, U8G_COM_SW_SPI); |
|||
U8G_PB_DEV(u8g_dev_ssd1309_128x64_i2c, WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_ssd1309_128x64_fn, U8G_COM_SSD_I2C); |
|||
|
|||
|
|||
@ -0,0 +1,334 @@ |
|||
/*
|
|||
|
|||
u8g_dev_ssd1322_nhd31oled_bw.c |
|||
|
|||
1-Bit (BW) Driver for SSD1322 Controller (OLED Display) |
|||
Tested with NHD-3.12-25664 |
|||
|
|||
Universal 8bit Graphics Library |
|||
|
|||
Copyright (c) 2012, olikraus@gmail.com |
|||
All rights reserved. |
|||
|
|||
Redistribution and use in source and binary forms, with or without modification, |
|||
are permitted provided that the following conditions are met: |
|||
|
|||
* Redistributions of source code must retain the above copyright notice, this list |
|||
of conditions and the following disclaimer. |
|||
|
|||
* Redistributions in binary form must reproduce the above copyright notice, this |
|||
list of conditions and the following disclaimer in the documentation and/or other |
|||
materials provided with the distribution. |
|||
|
|||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
|||
CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
|||
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
|||
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
|||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
|||
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
|||
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
|||
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
|||
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
|||
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF |
|||
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|||
|
|||
SSD130x Monochrom OLED Controller |
|||
SSD131x Character OLED Controller |
|||
SSD132x Graylevel OLED Controller |
|||
SSD1331 Color OLED Controller |
|||
|
|||
*/ |
|||
|
|||
#include "u8g.h" |
|||
|
|||
/* width must be multiple of 8, largest value is 248 unless u8g 16 bit mode is enabled */ |
|||
#if defined(U8G_16BIT) |
|||
#define WIDTH 256 |
|||
#else |
|||
#define WIDTH 248 |
|||
#endif |
|||
#define HEIGHT 64 |
|||
#define PAGE_HEIGHT 8 |
|||
|
|||
/*
|
|||
http://www.newhavendisplay.com/app_notes/OLED_25664.txt
|
|||
http://www.newhavendisplay.com/forum/viewtopic.php?f=15&t=3758
|
|||
*/ |
|||
|
|||
static const uint8_t u8g_dev_ssd1322_1bit_nhd_312_init_seq[] PROGMEM = { |
|||
U8G_ESC_DLY(10), /* delay 10 ms */ |
|||
U8G_ESC_CS(0), /* disable chip */ |
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
U8G_ESC_RST(1), /* do reset low pulse with (1*16)+2 milliseconds */ |
|||
U8G_ESC_CS(1), /* enable chip */ |
|||
|
|||
U8G_ESC_DLY(100), /* delay 100 ms */ |
|||
U8G_ESC_DLY(100), /* delay 100 ms */ |
|||
|
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
0x0fd, /* lock command */ |
|||
U8G_ESC_ADR(1), /* data mode */ |
|||
0x012, /* unlock */ |
|||
|
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
0x0ae, /* display off, sleep mode */ |
|||
|
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
0x0b3, |
|||
U8G_ESC_ADR(1), /* data mode */ |
|||
0x091, /* set display clock divide ratio/oscillator frequency (set clock as 80 frames/sec) */ |
|||
|
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
0x0ca, /* multiplex ratio */ |
|||
U8G_ESC_ADR(1), /* data mode */ |
|||
0x03f, /* 1/64 Duty (0x0F~0x3F) */ |
|||
|
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
0x0a2, |
|||
U8G_ESC_ADR(1), /* data mode */ |
|||
0x000, /* display offset, shift mapping ram counter */ |
|||
|
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
0x0a1, |
|||
U8G_ESC_ADR(1), /* data mode */ |
|||
0x000, /* display start line */ |
|||
|
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
0x0a0, /* Set Re-Map / Dual COM Line Mode */ |
|||
U8G_ESC_ADR(1), /* data mode */ |
|||
0x014, /* was 0x014 */ |
|||
0x011, /* was 0x011 */ |
|||
|
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
0x0ab, |
|||
U8G_ESC_ADR(1), /* data mode */ |
|||
0x001, /* Enable Internal VDD Regulator */ |
|||
|
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
0x0b4, /* Display Enhancement A */ |
|||
U8G_ESC_ADR(1), /* data mode */ |
|||
0x0a0, |
|||
0x005|0x0fd, |
|||
|
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
0x0c1, /* contrast */ |
|||
U8G_ESC_ADR(1), /* data mode */ |
|||
0x09f, |
|||
|
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
0x0c7, /* Set Scale Factor of Segment Output Current Control */ |
|||
U8G_ESC_ADR(1), /* data mode */ |
|||
0x00f, |
|||
|
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
0x0b9, /* linear gray scale */ |
|||
|
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
0x0b1, /* Phase 1 (Reset) & Phase 2 (Pre-Charge) Period Adjustment */ |
|||
U8G_ESC_ADR(1), /* data mode */ |
|||
0x0e2, |
|||
|
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
0x0d1, /* Display Enhancement B */ |
|||
U8G_ESC_ADR(1), /* data mode */ |
|||
0x082|0x020, |
|||
0x020, |
|||
|
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
0x0bb, /* precharge voltage */ |
|||
U8G_ESC_ADR(1), /* data mode */ |
|||
0x01f, |
|||
|
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
0x0b6, /* precharge period */ |
|||
U8G_ESC_ADR(1), /* data mode */ |
|||
0x008, |
|||
|
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
0x0be, /* vcomh */ |
|||
U8G_ESC_ADR(1), /* data mode */ |
|||
0x007, |
|||
|
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
0x0a6, /* normal display */ |
|||
|
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
0x0a9, /* exit partial display */ |
|||
|
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
0x0af, /* display on */ |
|||
|
|||
|
|||
U8G_ESC_CS(0), /* disable chip */ |
|||
U8G_ESC_END /* end of sequence */ |
|||
}; |
|||
|
|||
static const uint8_t u8g_dev_ssd1322_1bit_nhd_312_prepare_page_seq[] PROGMEM = { |
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
U8G_ESC_CS(1), /* enable chip */ |
|||
0x015, /* column address... */ |
|||
U8G_ESC_ADR(1), /* data mode */ |
|||
0x01c, /* start at column 0 */ |
|||
0x05b, /* end column */ |
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
0x075, /* row address... */ |
|||
U8G_ESC_ADR(1), /* data mode */ |
|||
U8G_ESC_END /* end of sequence */ |
|||
}; |
|||
|
|||
static void u8g_dev_ssd1322_1bit_prepare_row(u8g_t *u8g, u8g_dev_t *dev, uint8_t delta_row) |
|||
{ |
|||
uint8_t row = ((u8g_pb_t *)(dev->dev_mem))->p.page; |
|||
|
|||
row *= ((u8g_pb_t *)(dev->dev_mem))->p.page_height; |
|||
row += delta_row; |
|||
|
|||
u8g_WriteEscSeqP(u8g, dev, u8g_dev_ssd1322_1bit_nhd_312_prepare_page_seq); |
|||
|
|||
u8g_WriteByte(u8g, dev, row); /* start at the selected row */ |
|||
u8g_WriteByte(u8g, dev, row+1); /* end within the selected row */ |
|||
|
|||
u8g_SetAddress(u8g, dev, 0); /* instruction mode mode */ |
|||
u8g_WriteByte(u8g, dev, 0x05c); /* write to ram */ |
|||
u8g_SetAddress(u8g, dev, 1); /* data mode */ |
|||
} |
|||
|
|||
static const uint8_t u8g_dev_ssd13xx_sleep_on[] PROGMEM = { |
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
U8G_ESC_CS(1), /* enable chip */ |
|||
0x0ae, /* display off */ |
|||
U8G_ESC_CS(1), /* disable chip */ |
|||
U8G_ESC_END /* end of sequence */ |
|||
}; |
|||
|
|||
static const uint8_t u8g_dev_ssd13xx_sleep_off[] PROGMEM = { |
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
U8G_ESC_CS(1), /* enable chip */ |
|||
0x0af, /* display on */ |
|||
U8G_ESC_DLY(50), /* delay 50 ms */ |
|||
U8G_ESC_CS(1), /* disable chip */ |
|||
U8G_ESC_END /* end of sequence */ |
|||
}; |
|||
|
|||
|
|||
uint8_t u8g_dev_ssd1322_nhd31oled_bw_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg) |
|||
{ |
|||
switch(msg) |
|||
{ |
|||
case U8G_DEV_MSG_INIT: |
|||
u8g_InitCom(u8g, dev); |
|||
u8g_WriteEscSeqP(u8g, dev, u8g_dev_ssd1322_1bit_nhd_312_init_seq); |
|||
break; |
|||
case U8G_DEV_MSG_STOP: |
|||
break; |
|||
case U8G_DEV_MSG_PAGE_NEXT: |
|||
{ |
|||
uint8_t i; |
|||
u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem); |
|||
uint8_t *p = pb->buf; |
|||
u8g_uint_t cnt; |
|||
cnt = pb->width; |
|||
cnt >>= 3; |
|||
|
|||
for( i = 0; i < pb->p.page_height; i++ ) |
|||
{ |
|||
u8g_dev_ssd1322_1bit_prepare_row(u8g, dev, i); /* this will also enable chip select */ |
|||
#if !defined(U8G_16BIT) |
|||
u8g_WriteByte(u8g, dev, 0x0ff); |
|||
u8g_WriteByte(u8g, dev, 0x0ff); |
|||
#endif |
|||
u8g_WriteSequenceBWTo16GrDevice(u8g, dev, cnt, p); |
|||
#if !defined(U8G_16BIT) |
|||
u8g_WriteByte(u8g, dev, 0x0ff); |
|||
u8g_WriteByte(u8g, dev, 0x0ff); |
|||
#endif |
|||
u8g_SetChipSelect(u8g, dev, 0); |
|||
p+=cnt; |
|||
} |
|||
} |
|||
break; |
|||
case U8G_DEV_MSG_CONTRAST: |
|||
u8g_SetChipSelect(u8g, dev, 1); |
|||
u8g_SetAddress(u8g, dev, 0); /* instruction mode */ |
|||
u8g_WriteByte(u8g, dev, 0x081); |
|||
u8g_SetAddress(u8g, dev, 1); /* data mode */ |
|||
u8g_WriteByte(u8g, dev, (*(uint8_t *)arg) >> 1); |
|||
u8g_SetChipSelect(u8g, dev, 0); |
|||
break; |
|||
case U8G_DEV_MSG_SLEEP_ON: |
|||
u8g_WriteEscSeqP(u8g, dev, u8g_dev_ssd13xx_sleep_on); |
|||
return 1; |
|||
case U8G_DEV_MSG_SLEEP_OFF: |
|||
u8g_WriteEscSeqP(u8g, dev, u8g_dev_ssd13xx_sleep_off); |
|||
return 1; |
|||
} |
|||
return u8g_dev_pb8h1_base_fn(u8g, dev, msg, arg); |
|||
} |
|||
|
|||
|
|||
uint8_t u8g_dev_ssd1322_nhd31oled_2x_bw_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg) |
|||
{ |
|||
switch(msg) |
|||
{ |
|||
case U8G_DEV_MSG_INIT: |
|||
u8g_InitCom(u8g, dev); |
|||
u8g_WriteEscSeqP(u8g, dev, u8g_dev_ssd1322_1bit_nhd_312_init_seq); |
|||
break; |
|||
case U8G_DEV_MSG_STOP: |
|||
break; |
|||
case U8G_DEV_MSG_PAGE_NEXT: |
|||
{ |
|||
uint8_t i; |
|||
u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem); |
|||
uint8_t *p = pb->buf; |
|||
u8g_uint_t cnt; |
|||
cnt = pb->width; |
|||
cnt >>= 3; |
|||
|
|||
for( i = 0; i < pb->p.page_height; i++ ) |
|||
{ |
|||
u8g_dev_ssd1322_1bit_prepare_row(u8g, dev, i); /* this will also enable chip select */ |
|||
#if !defined(U8G_16BIT) |
|||
u8g_WriteByte(u8g, dev, 0x0ff); |
|||
u8g_WriteByte(u8g, dev, 0x0ff); |
|||
#endif |
|||
u8g_WriteSequenceBWTo16GrDevice(u8g, dev, cnt, p); |
|||
#if !defined(U8G_16BIT) |
|||
u8g_WriteByte(u8g, dev, 0x0ff); |
|||
u8g_WriteByte(u8g, dev, 0x0ff); |
|||
#endif |
|||
u8g_SetChipSelect(u8g, dev, 0); |
|||
p+=cnt; |
|||
} |
|||
} |
|||
break; |
|||
case U8G_DEV_MSG_CONTRAST: |
|||
u8g_SetChipSelect(u8g, dev, 1); |
|||
u8g_SetAddress(u8g, dev, 0); /* instruction mode */ |
|||
u8g_WriteByte(u8g, dev, 0x081); |
|||
u8g_SetAddress(u8g, dev, 1); /* data mode */ |
|||
u8g_WriteByte(u8g, dev, (*(uint8_t *)arg) >> 1); |
|||
u8g_SetChipSelect(u8g, dev, 0); |
|||
break; |
|||
case U8G_DEV_MSG_SLEEP_ON: |
|||
u8g_WriteEscSeqP(u8g, dev, u8g_dev_ssd13xx_sleep_on); |
|||
return 1; |
|||
case U8G_DEV_MSG_SLEEP_OFF: |
|||
u8g_WriteEscSeqP(u8g, dev, u8g_dev_ssd13xx_sleep_off); |
|||
return 1; |
|||
} |
|||
return u8g_dev_pb16h1_base_fn(u8g, dev, msg, arg); |
|||
} |
|||
|
|||
|
|||
U8G_PB_DEV(u8g_dev_ssd1322_nhd31oled_bw_sw_spi , WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_ssd1322_nhd31oled_bw_fn, U8G_COM_SW_SPI); |
|||
U8G_PB_DEV(u8g_dev_ssd1322_nhd31oled_bw_hw_spi , WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_ssd1322_nhd31oled_bw_fn, U8G_COM_HW_SPI); |
|||
|
|||
#define DWIDTH (WIDTH*2) |
|||
uint8_t u8g_dev_ssd1322_nhd31oled_2x_bw_buf[DWIDTH] U8G_NOCOMMON ; |
|||
u8g_pb_t u8g_dev_ssd1322_nhd31oled_2x_bw_pb = { {16, HEIGHT, 0, 0, 0}, WIDTH, u8g_dev_ssd1322_nhd31oled_2x_bw_buf}; |
|||
u8g_dev_t u8g_dev_ssd1322_nhd31oled_2x_bw_sw_spi = { u8g_dev_ssd1322_nhd31oled_2x_bw_fn, &u8g_dev_ssd1322_nhd31oled_2x_bw_pb, U8G_COM_SW_SPI }; |
|||
u8g_dev_t u8g_dev_ssd1322_nhd31oled_2x_bw_hw_spi = { u8g_dev_ssd1322_nhd31oled_2x_bw_fn, &u8g_dev_ssd1322_nhd31oled_2x_bw_pb, U8G_COM_HW_SPI }; |
|||
|
|||
@ -0,0 +1,333 @@ |
|||
/*
|
|||
|
|||
u8g_dev_ssd1322_nhd31oled_gr.c |
|||
|
|||
2-Bit (4L) Driver for SSD1322 Controller (OLED Display) |
|||
Tested with NHD-3.12-25664 |
|||
|
|||
Universal 8bit Graphics Library |
|||
|
|||
Copyright (c) 2012, olikraus@gmail.com |
|||
All rights reserved. |
|||
|
|||
Redistribution and use in source and binary forms, with or without modification, |
|||
are permitted provided that the following conditions are met: |
|||
|
|||
* Redistributions of source code must retain the above copyright notice, this list |
|||
of conditions and the following disclaimer. |
|||
|
|||
* Redistributions in binary form must reproduce the above copyright notice, this |
|||
list of conditions and the following disclaimer in the documentation and/or other |
|||
materials provided with the distribution. |
|||
|
|||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
|||
CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
|||
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
|||
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
|||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
|||
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
|||
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
|||
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
|||
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
|||
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF |
|||
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|||
|
|||
SSD130x Monochrom OLED Controller |
|||
SSD131x Character OLED Controller |
|||
SSD132x Graylevel OLED Controller |
|||
SSD1331 Color OLED Controller |
|||
|
|||
*/ |
|||
|
|||
#include "u8g.h" |
|||
|
|||
/* width must be multiple of 8, largest value is 248 unless u8g 16 bit mode is enabled */ |
|||
#if defined(U8G_16BIT) |
|||
#define WIDTH 256 |
|||
#else |
|||
#define WIDTH 248 |
|||
#endif |
|||
#define HEIGHT 64 |
|||
#define PAGE_HEIGHT 8 |
|||
|
|||
/*
|
|||
http://www.newhavendisplay.com/app_notes/OLED_25664.txt
|
|||
http://www.newhavendisplay.com/forum/viewtopic.php?f=15&t=3758
|
|||
*/ |
|||
|
|||
static const uint8_t u8g_dev_ssd1322_2bit_nhd_312_init_seq[] PROGMEM = { |
|||
U8G_ESC_DLY(10), /* delay 10 ms */ |
|||
U8G_ESC_CS(0), /* disable chip */ |
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
U8G_ESC_RST(1), /* do reset low pulse with (1*16)+2 milliseconds */ |
|||
U8G_ESC_CS(1), /* enable chip */ |
|||
|
|||
U8G_ESC_DLY(100), /* delay 100 ms */ |
|||
U8G_ESC_DLY(100), /* delay 100 ms */ |
|||
|
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
0x0fd, /* lock command */ |
|||
U8G_ESC_ADR(1), /* data mode */ |
|||
0x012, /* unlock */ |
|||
|
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
0x0ae, /* display off, sleep mode */ |
|||
|
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
0x0b3, |
|||
U8G_ESC_ADR(1), /* data mode */ |
|||
0x091, /* set display clock divide ratio/oscillator frequency (set clock as 80 frames/sec) */ |
|||
|
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
0x0ca, /* multiplex ratio */ |
|||
U8G_ESC_ADR(1), /* data mode */ |
|||
0x03f, /* 1/64 Duty (0x0F~0x3F) */ |
|||
|
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
0x0a2, |
|||
U8G_ESC_ADR(1), /* data mode */ |
|||
0x000, /* display offset, shift mapping ram counter */ |
|||
|
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
0x0a1, |
|||
U8G_ESC_ADR(1), /* data mode */ |
|||
0x000, /* display start line */ |
|||
|
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
0x0a0, /* Set Re-Map / Dual COM Line Mode */ |
|||
U8G_ESC_ADR(1), /* data mode */ |
|||
0x014, /* was 0x014 */ |
|||
0x011, /* was 0x011 */ |
|||
|
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
0x0ab, |
|||
U8G_ESC_ADR(1), /* data mode */ |
|||
0x001, /* Enable Internal VDD Regulator */ |
|||
|
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
0x0b4, /* Display Enhancement A */ |
|||
U8G_ESC_ADR(1), /* data mode */ |
|||
0x0a0, |
|||
0x005|0x0fd, |
|||
|
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
0x0c1, /* contrast */ |
|||
U8G_ESC_ADR(1), /* data mode */ |
|||
0x09f, |
|||
|
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
0x0c7, /* Set Scale Factor of Segment Output Current Control */ |
|||
U8G_ESC_ADR(1), /* data mode */ |
|||
0x00f, |
|||
|
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
0x0b9, /* linear gray scale */ |
|||
|
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
0x0b1, /* Phase 1 (Reset) & Phase 2 (Pre-Charge) Period Adjustment */ |
|||
U8G_ESC_ADR(1), /* data mode */ |
|||
0x0e2, |
|||
|
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
0x0d1, /* Display Enhancement B */ |
|||
U8G_ESC_ADR(1), /* data mode */ |
|||
0x082|0x020, |
|||
0x020, |
|||
|
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
0x0bb, /* precharge voltage */ |
|||
U8G_ESC_ADR(1), /* data mode */ |
|||
0x01f, |
|||
|
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
0x0b6, /* precharge period */ |
|||
U8G_ESC_ADR(1), /* data mode */ |
|||
0x008, |
|||
|
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
0x0be, /* vcomh */ |
|||
U8G_ESC_ADR(1), /* data mode */ |
|||
0x007, |
|||
|
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
0x0a6, /* normal display */ |
|||
|
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
0x0a9, /* exit partial display */ |
|||
|
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
0x0af, /* display on */ |
|||
|
|||
|
|||
U8G_ESC_CS(0), /* disable chip */ |
|||
U8G_ESC_END /* end of sequence */ |
|||
}; |
|||
|
|||
static const uint8_t u8g_dev_ssd1322_2bit_nhd_312_prepare_page_seq[] PROGMEM = { |
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
U8G_ESC_CS(1), /* enable chip */ |
|||
0x015, /* column address... */ |
|||
U8G_ESC_ADR(1), /* data mode */ |
|||
0x01c, /* start at column 0 */ |
|||
0x05b, /* end column */ |
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
0x075, /* row address... */ |
|||
U8G_ESC_ADR(1), /* data mode */ |
|||
U8G_ESC_END /* end of sequence */ |
|||
}; |
|||
|
|||
static void u8g_dev_ssd1322_2bit_prepare_row(u8g_t *u8g, u8g_dev_t *dev, uint8_t delta_row) |
|||
{ |
|||
uint8_t row = ((u8g_pb_t *)(dev->dev_mem))->p.page; |
|||
|
|||
row *= ((u8g_pb_t *)(dev->dev_mem))->p.page_height; |
|||
row += delta_row; |
|||
|
|||
u8g_WriteEscSeqP(u8g, dev, u8g_dev_ssd1322_2bit_nhd_312_prepare_page_seq); |
|||
|
|||
u8g_WriteByte(u8g, dev, row); /* start at the selected row */ |
|||
u8g_WriteByte(u8g, dev, row+1); /* end within the selected row */ |
|||
|
|||
u8g_SetAddress(u8g, dev, 0); /* instruction mode mode */ |
|||
u8g_WriteByte(u8g, dev, 0x05c); /* write to ram */ |
|||
u8g_SetAddress(u8g, dev, 1); /* data mode */ |
|||
} |
|||
|
|||
static const uint8_t u8g_dev_ssd13xx_sleep_on[] PROGMEM = { |
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
U8G_ESC_CS(1), /* enable chip */ |
|||
0x0ae, /* display off */ |
|||
U8G_ESC_CS(1), /* disable chip */ |
|||
U8G_ESC_END /* end of sequence */ |
|||
}; |
|||
|
|||
static const uint8_t u8g_dev_ssd13xx_sleep_off[] PROGMEM = { |
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
U8G_ESC_CS(1), /* enable chip */ |
|||
0x0af, /* display on */ |
|||
U8G_ESC_DLY(50), /* delay 50 ms */ |
|||
U8G_ESC_CS(1), /* disable chip */ |
|||
U8G_ESC_END /* end of sequence */ |
|||
}; |
|||
|
|||
uint8_t u8g_dev_ssd1322_nhd31oled_gr_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg) |
|||
{ |
|||
switch(msg) |
|||
{ |
|||
case U8G_DEV_MSG_INIT: |
|||
u8g_InitCom(u8g, dev); |
|||
u8g_WriteEscSeqP(u8g, dev, u8g_dev_ssd1322_2bit_nhd_312_init_seq); |
|||
break; |
|||
case U8G_DEV_MSG_STOP: |
|||
break; |
|||
case U8G_DEV_MSG_PAGE_NEXT: |
|||
{ |
|||
uint8_t i; |
|||
u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem); |
|||
uint8_t *p = pb->buf; |
|||
u8g_uint_t cnt; |
|||
cnt = pb->width; |
|||
cnt >>= 2; |
|||
|
|||
for( i = 0; i < pb->p.page_height; i++ ) |
|||
{ |
|||
u8g_dev_ssd1322_2bit_prepare_row(u8g, dev, i); /* this will also enable chip select */ |
|||
#if !defined(U8G_16BIT) |
|||
u8g_WriteByte(u8g, dev, 0x00); |
|||
u8g_WriteByte(u8g, dev, 0x00); |
|||
#endif |
|||
u8g_WriteSequence4LTo16GrDevice(u8g, dev, cnt, p); |
|||
#if !defined(U8G_16BIT) |
|||
u8g_WriteByte(u8g, dev, 0x00); |
|||
u8g_WriteByte(u8g, dev, 0x00); |
|||
#endif |
|||
u8g_SetChipSelect(u8g, dev, 0); |
|||
p+=cnt; |
|||
} |
|||
} |
|||
break; |
|||
case U8G_DEV_MSG_CONTRAST: |
|||
u8g_SetChipSelect(u8g, dev, 1); |
|||
u8g_SetAddress(u8g, dev, 0); /* instruction mode */ |
|||
u8g_WriteByte(u8g, dev, 0x081); |
|||
u8g_SetAddress(u8g, dev, 1); /* data mode */ |
|||
u8g_WriteByte(u8g, dev, (*(uint8_t *)arg) >> 1); |
|||
u8g_SetChipSelect(u8g, dev, 0); |
|||
break; |
|||
case U8G_DEV_MSG_SLEEP_ON: |
|||
u8g_WriteEscSeqP(u8g, dev, u8g_dev_ssd13xx_sleep_on); |
|||
return 1; |
|||
case U8G_DEV_MSG_SLEEP_OFF: |
|||
u8g_WriteEscSeqP(u8g, dev, u8g_dev_ssd13xx_sleep_off); |
|||
return 1; |
|||
} |
|||
return u8g_dev_pb8h2_base_fn(u8g, dev, msg, arg); |
|||
} |
|||
|
|||
|
|||
uint8_t u8g_dev_ssd1322_nhd31oled_2x_gr_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg) |
|||
{ |
|||
switch(msg) |
|||
{ |
|||
case U8G_DEV_MSG_INIT: |
|||
u8g_InitCom(u8g, dev); |
|||
u8g_WriteEscSeqP(u8g, dev, u8g_dev_ssd1322_2bit_nhd_312_init_seq); |
|||
break; |
|||
case U8G_DEV_MSG_STOP: |
|||
break; |
|||
case U8G_DEV_MSG_PAGE_NEXT: |
|||
{ |
|||
uint8_t i; |
|||
u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem); |
|||
uint8_t *p = pb->buf; |
|||
u8g_uint_t cnt; |
|||
cnt = pb->width; |
|||
cnt >>= 3; |
|||
|
|||
for( i = 0; i < pb->p.page_height; i++ ) |
|||
{ |
|||
u8g_dev_ssd1322_2bit_prepare_row(u8g, dev, i); /* this will also enable chip select */ |
|||
#if !defined(U8G_16BIT) |
|||
u8g_WriteByte(u8g, dev, 0x00); |
|||
u8g_WriteByte(u8g, dev, 0x00); |
|||
#endif |
|||
u8g_WriteSequence4LTo16GrDevice(u8g, dev, cnt, p); |
|||
#if !defined(U8G_16BIT) |
|||
u8g_WriteByte(u8g, dev, 0x00); |
|||
u8g_WriteByte(u8g, dev, 0x00); |
|||
#endif |
|||
u8g_SetChipSelect(u8g, dev, 0); |
|||
p+=cnt; |
|||
} |
|||
} |
|||
break; |
|||
case U8G_DEV_MSG_CONTRAST: |
|||
u8g_SetChipSelect(u8g, dev, 1); |
|||
u8g_SetAddress(u8g, dev, 0); /* instruction mode */ |
|||
u8g_WriteByte(u8g, dev, 0x081); |
|||
u8g_SetAddress(u8g, dev, 1); /* data mode */ |
|||
u8g_WriteByte(u8g, dev, (*(uint8_t *)arg) >> 1); |
|||
u8g_SetChipSelect(u8g, dev, 0); |
|||
break; |
|||
case U8G_DEV_MSG_SLEEP_ON: |
|||
u8g_WriteEscSeqP(u8g, dev, u8g_dev_ssd13xx_sleep_on); |
|||
return 1; |
|||
case U8G_DEV_MSG_SLEEP_OFF: |
|||
u8g_WriteEscSeqP(u8g, dev, u8g_dev_ssd13xx_sleep_off); |
|||
return 1; |
|||
} |
|||
return u8g_dev_pb16h2_base_fn(u8g, dev, msg, arg); |
|||
} |
|||
|
|||
|
|||
U8G_PB_DEV(u8g_dev_ssd1322_nhd31oled_gr_sw_spi , WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_ssd1322_nhd31oled_gr_fn, U8G_COM_SW_SPI); |
|||
U8G_PB_DEV(u8g_dev_ssd1322_nhd31oled_gr_hw_spi , WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_ssd1322_nhd31oled_gr_fn, U8G_COM_HW_SPI); |
|||
|
|||
#define DWIDTH (WIDTH*2) |
|||
uint8_t u8g_dev_ssd1322_nhd31oled_2x_gr_buf[DWIDTH] U8G_NOCOMMON ; |
|||
u8g_pb_t u8g_dev_ssd1322_nhd31oled_2x_gr_pb = { {16, HEIGHT, 0, 0, 0}, WIDTH, u8g_dev_ssd1322_nhd31oled_2x_gr_buf}; |
|||
u8g_dev_t u8g_dev_ssd1322_nhd31oled_2x_gr_sw_spi = { u8g_dev_ssd1322_nhd31oled_2x_gr_fn, &u8g_dev_ssd1322_nhd31oled_2x_gr_pb, U8G_COM_SW_SPI }; |
|||
u8g_dev_t u8g_dev_ssd1322_nhd31oled_2x_gr_hw_spi = { u8g_dev_ssd1322_nhd31oled_2x_gr_fn, &u8g_dev_ssd1322_nhd31oled_2x_gr_pb, U8G_COM_HW_SPI }; |
|||
|
|||
@ -0,0 +1,263 @@ |
|||
/*
|
|||
|
|||
u8g_dev_ssd1325_nhd27oled_bw.c |
|||
|
|||
1-Bit (BW) Driver for SSD1325 Controller (OLED Display) |
|||
Tested with NHD-2.7-12864UCY3 |
|||
|
|||
Universal 8bit Graphics Library |
|||
|
|||
Copyright (c) 2011, olikraus@gmail.com |
|||
All rights reserved. |
|||
|
|||
Redistribution and use in source and binary forms, with or without modification, |
|||
are permitted provided that the following conditions are met: |
|||
|
|||
* Redistributions of source code must retain the above copyright notice, this list |
|||
of conditions and the following disclaimer. |
|||
|
|||
* Redistributions in binary form must reproduce the above copyright notice, this |
|||
list of conditions and the following disclaimer in the documentation and/or other |
|||
materials provided with the distribution. |
|||
|
|||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
|||
CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
|||
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
|||
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
|||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
|||
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
|||
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
|||
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
|||
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
|||
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF |
|||
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|||
|
|||
SSD130x Monochrom OLED Controller |
|||
SSD131x Character OLED Controller |
|||
SSD132x Graylevel OLED Controller |
|||
SSD1331 Color OLED Controller |
|||
|
|||
*/ |
|||
|
|||
#ifdef OBSOLETE_CODE |
|||
|
|||
#include "u8g.h" |
|||
|
|||
#define WIDTH 128 |
|||
#define HEIGHT 64 |
|||
#define PAGE_HEIGHT 8 |
|||
|
|||
/* http://www.newhavendisplay.com/app_notes/OLED_2_7_12864.txt */ |
|||
static const uint8_t u8g_dev_ssd1325_1bit_nhd_27_12864ucy3_init_seq[] PROGMEM = { |
|||
U8G_ESC_DLY(10), /* delay 10 ms */ |
|||
U8G_ESC_CS(0), /* disable chip */ |
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
U8G_ESC_RST(1), /* do reset low pulse with (1*16)+2 milliseconds */ |
|||
U8G_ESC_CS(1), /* enable chip */ |
|||
0x0ae, /* display off, sleep mode */ |
|||
0x0b3, 0x091, /* set display clock divide ratio/oscillator frequency (set clock as 135 frames/sec) */ |
|||
0x0a8, 0x03f, /* multiplex ratio: 0x03f * 1/64 duty */ |
|||
0x0a2, 0x04c, /* display offset, shift mapping ram counter */ |
|||
0x0a1, 0x000, /* display start line */ |
|||
0x0ad, 0x002, /* master configuration: disable embedded DC-DC, enable internal VCOMH */ |
|||
0x0a0, 0x056, /* remap configuration, vertical address increment, enable nibble remap (upper nibble is left) */ |
|||
0x086, /* full current range (0x084, 0x085, 0x086) */ |
|||
0x0b8, /* set gray scale table */ |
|||
0x01, 0x011, 0x022, 0x032, 0x043, 0x054, 0x065, 0x076, |
|||
0x081, 0x070, /* contrast, brightness, 0..128, Newhaven: 0x040 */ |
|||
0x0b2, 0x051, /* frame frequency (row period) */ |
|||
0x0b1, 0x055, /* phase length */ |
|||
0x0bc, 0x010, /* pre-charge voltage level */ |
|||
0x0b4, 0x002, /* set pre-charge compensation level (not documented in the SDD1325 datasheet, but used in the NHD init seq.) */ |
|||
0x0b0, 0x028, /* enable pre-charge compensation (not documented in the SDD1325 datasheet, but used in the NHD init seq.) */ |
|||
0x0be, 0x01c, /* VCOMH voltage */ |
|||
0x0bf, 0x002|0x00d, /* VSL voltage level (not documented in the SDD1325 datasheet, but used in the NHD init seq.) */ |
|||
0x0a5, /* all pixel on */ |
|||
0x0af, /* display on */ |
|||
U8G_ESC_DLY(100), /* delay 100 ms */ |
|||
U8G_ESC_DLY(100), /* delay 100 ms */ |
|||
0x0a4, /* normal display mode */ |
|||
U8G_ESC_CS(0), /* disable chip */ |
|||
U8G_ESC_END /* end of sequence */ |
|||
}; |
|||
|
|||
static const uint8_t u8g_dev_ssd1325_1bit_nhd_27_12864ucy3_prepare_page_seq[] PROGMEM = { |
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
U8G_ESC_CS(1), /* enable chip */ |
|||
0x015, /* column address... */ |
|||
0x000, /* start at column 0 */ |
|||
0x03f, /* end at column 63 (which is y == 127), because there are two pixel in one column */ |
|||
0x075, /* row address... */ |
|||
U8G_ESC_END /* end of sequence */ |
|||
}; |
|||
|
|||
|
|||
static void u8g_dev_ssd1325_1bit_prepare_page(u8g_t *u8g, u8g_dev_t *dev) |
|||
{ |
|||
uint8_t page = ((u8g_pb_t *)(dev->dev_mem))->p.page; |
|||
|
|||
u8g_WriteEscSeqP(u8g, dev, u8g_dev_ssd1325_1bit_nhd_27_12864ucy3_prepare_page_seq); |
|||
|
|||
page <<= 3; |
|||
u8g_WriteByte(u8g, dev, page); /* start at the selected page */ |
|||
page += 7; |
|||
u8g_WriteByte(u8g, dev, page); /* end within the selected page */ |
|||
|
|||
u8g_SetAddress(u8g, dev, 1); /* data mode */ |
|||
} |
|||
|
|||
static void u8g_dev_ssd1325_1bit_2x_prepare_page(u8g_t *u8g, u8g_dev_t *dev, uint8_t is_odd) |
|||
{ |
|||
uint8_t page = ((u8g_pb_t *)(dev->dev_mem))->p.page; |
|||
|
|||
u8g_WriteEscSeqP(u8g, dev, u8g_dev_ssd1325_1bit_nhd_27_12864ucy3_prepare_page_seq); |
|||
|
|||
page <<= 1; |
|||
page += is_odd; |
|||
|
|||
page <<= 3; |
|||
u8g_WriteByte(u8g, dev, page); /* start at the selected page */ |
|||
page += 7; |
|||
u8g_WriteByte(u8g, dev, page); /* end within the selected page */ |
|||
|
|||
u8g_SetAddress(u8g, dev, 1); /* data mode */ |
|||
} |
|||
|
|||
/* assumes row autoincrement and activated nibble remap */ |
|||
#ifdef OLD |
|||
static void _OLD_u8g_dev_ssd1325_1bit_write_16_pixel(u8g_t *u8g, u8g_dev_t *dev, uint8_t left, uint8_t right) |
|||
{ |
|||
uint8_t d, cnt; |
|||
cnt = 8; |
|||
do |
|||
{ |
|||
d = 0; |
|||
if ( left & 1 ) |
|||
d |= 0x0f0; |
|||
if ( right & 1 ) |
|||
d |= 0x00f; |
|||
u8g_WriteByte(u8g, dev, d); |
|||
left >>= 1; |
|||
right >>= 1; |
|||
cnt--; |
|||
}while ( cnt > 0 ); |
|||
} |
|||
#endif |
|||
|
|||
static void u8g_dev_ssd1325_1bit_write_16_pixel(u8g_t *u8g, u8g_dev_t *dev, uint8_t left, uint8_t right) |
|||
{ |
|||
uint8_t d, cnt; |
|||
static uint8_t buf[8]; |
|||
cnt = 8; |
|||
do |
|||
{ |
|||
d = 0; |
|||
if ( left & 128 ) |
|||
d |= 0x0f0; |
|||
if ( right & 128 ) |
|||
d |= 0x00f; |
|||
cnt--; |
|||
buf[cnt] = d; |
|||
left <<= 1; |
|||
right <<= 1; |
|||
}while ( cnt > 0 ); |
|||
u8g_WriteSequence(u8g, dev, 8, buf); |
|||
} |
|||
|
|||
static void u8g_dev_ssd1325_1bit_write_buffer(u8g_t *u8g, u8g_dev_t *dev, uint8_t is_odd) |
|||
{ |
|||
uint8_t cnt, left, right; |
|||
uint8_t *ptr; |
|||
u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem); |
|||
|
|||
ptr = pb->buf; |
|||
cnt = pb->width; |
|||
if ( is_odd ) |
|||
ptr += cnt; |
|||
cnt >>= 1; |
|||
do |
|||
{ |
|||
left = *ptr++; |
|||
right = *ptr++; |
|||
u8g_dev_ssd1325_1bit_write_16_pixel(u8g, dev, left, right); |
|||
cnt--; |
|||
} while( cnt > 0 ); |
|||
} |
|||
|
|||
uint8_t u8g_dev_ssd1325_nhd27oled_bw_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg) |
|||
{ |
|||
switch(msg) |
|||
{ |
|||
case U8G_DEV_MSG_INIT: |
|||
u8g_InitCom(u8g, dev); |
|||
u8g_WriteEscSeqP(u8g, dev, u8g_dev_ssd1325_1bit_nhd_27_12864ucy3_init_seq); |
|||
break; |
|||
case U8G_DEV_MSG_STOP: |
|||
break; |
|||
case U8G_DEV_MSG_PAGE_NEXT: |
|||
{ |
|||
u8g_dev_ssd1325_1bit_prepare_page(u8g, dev); |
|||
u8g_dev_ssd1325_1bit_write_buffer(u8g, dev, 0); |
|||
u8g_SetChipSelect(u8g, dev, 0); |
|||
} |
|||
break; |
|||
case U8G_DEV_MSG_CONTRAST: |
|||
u8g_SetChipSelect(u8g, dev, 1); |
|||
u8g_SetAddress(u8g, dev, 0); /* instruction mode */ |
|||
u8g_WriteByte(u8g, dev, 0x081); |
|||
u8g_WriteByte(u8g, dev, (*(uint8_t *)arg) >> 1); |
|||
u8g_SetChipSelect(u8g, dev, 0); |
|||
break; |
|||
} |
|||
return u8g_dev_pb8v1_base_fn(u8g, dev, msg, arg); |
|||
} |
|||
|
|||
uint8_t u8g_dev_ssd1325_nhd27oled_2x_bw_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg) |
|||
{ |
|||
switch(msg) |
|||
{ |
|||
case U8G_DEV_MSG_INIT: |
|||
u8g_InitCom(u8g, dev); |
|||
u8g_WriteEscSeqP(u8g, dev, u8g_dev_ssd1325_1bit_nhd_27_12864ucy3_init_seq); |
|||
break; |
|||
case U8G_DEV_MSG_STOP: |
|||
break; |
|||
case U8G_DEV_MSG_PAGE_NEXT: |
|||
{ |
|||
u8g_dev_ssd1325_1bit_2x_prepare_page(u8g, dev, 0); |
|||
u8g_dev_ssd1325_1bit_write_buffer(u8g, dev, 0); |
|||
u8g_dev_ssd1325_1bit_2x_prepare_page(u8g, dev, 1); |
|||
u8g_dev_ssd1325_1bit_write_buffer(u8g, dev, 1); |
|||
u8g_SetChipSelect(u8g, dev, 0); |
|||
} |
|||
break; |
|||
case U8G_DEV_MSG_CONTRAST: |
|||
u8g_SetChipSelect(u8g, dev, 1); |
|||
u8g_SetAddress(u8g, dev, 0); /* instruction mode */ |
|||
u8g_WriteByte(u8g, dev, 0x081); |
|||
u8g_WriteByte(u8g, dev, (*(uint8_t *)arg) >> 1); |
|||
u8g_SetChipSelect(u8g, dev, 0); |
|||
break; |
|||
} |
|||
return u8g_dev_pb16v1_base_fn(u8g, dev, msg, arg); |
|||
} |
|||
|
|||
/* disabled, see bw_new.c */ |
|||
/*
|
|||
U8G_PB_DEV(u8g_dev_ssd1325_nhd27oled_bw_sw_spi , WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_ssd1325_nhd27oled_bw_fn, U8G_COM_SW_SPI); |
|||
U8G_PB_DEV(u8g_dev_ssd1325_nhd27oled_bw_hw_spi , WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_ssd1325_nhd27oled_bw_fn, U8G_COM_HW_SPI); |
|||
U8G_PB_DEV(u8g_dev_ssd1325_nhd27oled_bw_parallel , WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_ssd1325_nhd27oled_bw_fn, U8G_COM_FAST_PARALLEL); |
|||
*/ |
|||
|
|||
/*
|
|||
uint8_t u8g_dev_ssd1325_nhd27oled_2x_bw_buf[WIDTH*2] U8G_NOCOMMON ; |
|||
u8g_pb_t u8g_dev_ssd1325_nhd27oled_2x_bw_pb = { {16, HEIGHT, 0, 0, 0}, WIDTH, u8g_dev_ssd1325_nhd27oled_2x_bw_buf}; |
|||
u8g_dev_t u8g_dev_ssd1325_nhd27oled_2x_bw_sw_spi = { u8g_dev_ssd1325_nhd27oled_2x_bw_fn, &u8g_dev_ssd1325_nhd27oled_2x_bw_pb, U8G_COM_SW_SPI }; |
|||
u8g_dev_t u8g_dev_ssd1325_nhd27oled_2x_bw_hw_spi = { u8g_dev_ssd1325_nhd27oled_2x_bw_fn, &u8g_dev_ssd1325_nhd27oled_2x_bw_pb, U8G_COM_HW_SPI }; |
|||
u8g_dev_t u8g_dev_ssd1325_nhd27oled_2x_bw_parallel = { u8g_dev_ssd1325_nhd27oled_2x_bw_fn, &u8g_dev_ssd1325_nhd27oled_2x_bw_pb, U8G_COM_FAST_PARALLEL }; |
|||
*/ |
|||
|
|||
#endif |
|||
|
|||
@ -0,0 +1,232 @@ |
|||
/*
|
|||
|
|||
u8g_dev_ssd1325_nhd27oled_bw.c |
|||
|
|||
1-Bit (BW) Driver for SSD1325 Controller (OLED Display) |
|||
Horizontal architecture, completly rewritten |
|||
Tested with NHD-2.7-12864UCY3 |
|||
|
|||
Universal 8bit Graphics Library |
|||
|
|||
Copyright (c) 2012, olikraus@gmail.com |
|||
All rights reserved. |
|||
|
|||
Redistribution and use in source and binary forms, with or without modification, |
|||
are permitted provided that the following conditions are met: |
|||
|
|||
* Redistributions of source code must retain the above copyright notice, this list |
|||
of conditions and the following disclaimer. |
|||
|
|||
* Redistributions in binary form must reproduce the above copyright notice, this |
|||
list of conditions and the following disclaimer in the documentation and/or other |
|||
materials provided with the distribution. |
|||
|
|||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
|||
CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
|||
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
|||
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
|||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
|||
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
|||
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
|||
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
|||
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
|||
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF |
|||
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|||
|
|||
SSD130x Monochrom OLED Controller |
|||
SSD131x Character OLED Controller |
|||
SSD132x Graylevel OLED Controller |
|||
SSD1331 Color OLED Controller |
|||
|
|||
*/ |
|||
|
|||
#include "u8g.h" |
|||
|
|||
/* width must be multiple of 8, largest value is 248 unless u8g 16 bit mode is enabled */ |
|||
#define WIDTH 128 |
|||
#define HEIGHT 64 |
|||
|
|||
/* http://www.newhavendisplay.com/app_notes/OLED_2_7_12864.txt */ |
|||
static const uint8_t u8g_dev_ssd1325_nhd_27_12864_init_seq[] PROGMEM = { |
|||
U8G_ESC_DLY(10), /* delay 10 ms */ |
|||
U8G_ESC_CS(0), /* disable chip */ |
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
U8G_ESC_RST(1), /* do reset low pulse with (1*16)+2 milliseconds */ |
|||
U8G_ESC_CS(1), /* enable chip */ |
|||
0x0ae, /* display off, sleep mode */ |
|||
0x0b3, 0x091, /* set display clock divide ratio/oscillator frequency (set clock as 135 frames/sec) */ |
|||
0x0a8, 0x03f, /* multiplex ratio: 0x03f * 1/64 duty */ |
|||
0x0a2, 0x04c, /* display offset, shift mapping ram counter */ |
|||
0x0a1, 0x000, /* display start line */ |
|||
0x0ad, 0x002, /* master configuration: disable embedded DC-DC, enable internal VCOMH */ |
|||
0x0a0, 0x052, /* remap configuration, horizontal address increment (bit 2 = 0), enable nibble remap (upper nibble is left, bit 1 = 1) */ |
|||
0x086, /* full current range (0x084, 0x085, 0x086) */ |
|||
0x0b8, /* set gray scale table */ |
|||
0x01, 0x011, 0x022, 0x032, 0x043, 0x054, 0x065, 0x076, |
|||
|
|||
0x081, 0x070, /* contrast, brightness, 0..128, Newhaven: 0x040 */ |
|||
0x0b2, 0x051, /* frame frequency (row period) */ |
|||
0x0b1, 0x055, /* phase length */ |
|||
0x0bc, 0x010, /* pre-charge voltage level */ |
|||
0x0b4, 0x002, /* set pre-charge compensation level (not documented in the SDD1325 datasheet, but used in the NHD init seq.) */ |
|||
0x0b0, 0x028, /* enable pre-charge compensation (not documented in the SDD1325 datasheet, but used in the NHD init seq.) */ |
|||
0x0be, 0x01c, /* VCOMH voltage */ |
|||
0x0bf, 0x002|0x00d, /* VSL voltage level (not documented in the SDD1325 datasheet, but used in the NHD init seq.) */ |
|||
0x0a4, /* normal display mode */ |
|||
0x0af, /* display on */ |
|||
U8G_ESC_DLY(50), /* delay 50 ms */ |
|||
U8G_ESC_CS(0), /* disable chip */ |
|||
U8G_ESC_END /* end of sequence */ |
|||
}; |
|||
|
|||
static const uint8_t u8g_dev_ssd1325_prepare_row_seq[] PROGMEM = { |
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
U8G_ESC_CS(1), /* enable chip */ |
|||
0x015, /* column address... */ |
|||
0x000, /* start at column 0 */ |
|||
0x03f, /* end at column 63 (which is y == 127), because there are two pixel in one column */ |
|||
0x075, /* row address... */ |
|||
U8G_ESC_END /* end of sequence */ |
|||
}; |
|||
|
|||
static void u8g_dev_ssd1325_prepare_row(u8g_t *u8g, u8g_dev_t *dev, uint8_t delta_row) |
|||
{ |
|||
uint8_t row = ((u8g_pb_t *)(dev->dev_mem))->p.page; |
|||
|
|||
row *= ((u8g_pb_t *)(dev->dev_mem))->p.page_height; |
|||
row += delta_row; |
|||
|
|||
u8g_WriteEscSeqP(u8g, dev, u8g_dev_ssd1325_prepare_row_seq); |
|||
|
|||
u8g_WriteByte(u8g, dev, row); /* start at the selected row */ |
|||
u8g_WriteByte(u8g, dev, row+1); /* end within the selected row */ |
|||
|
|||
//u8g_SetAddress(u8g, dev, 0); /* instruction mode mode */
|
|||
//u8g_WriteByte(u8g, dev, 0x05c); /* write to ram */
|
|||
u8g_SetAddress(u8g, dev, 1); /* data mode */ |
|||
} |
|||
|
|||
static const uint8_t u8g_dev_ssd13xx_sleep_on[] PROGMEM = { |
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
U8G_ESC_CS(1), /* enable chip */ |
|||
0x0ae, /* display off */ |
|||
U8G_ESC_CS(1), /* disable chip */ |
|||
U8G_ESC_END /* end of sequence */ |
|||
}; |
|||
|
|||
static const uint8_t u8g_dev_ssd13xx_sleep_off[] PROGMEM = { |
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
U8G_ESC_CS(1), /* enable chip */ |
|||
0x0af, /* display on */ |
|||
U8G_ESC_DLY(50), /* delay 50 ms */ |
|||
U8G_ESC_CS(1), /* disable chip */ |
|||
U8G_ESC_END /* end of sequence */ |
|||
}; |
|||
|
|||
|
|||
static uint8_t u8g_dev_ssd1325_nhd27oled_bw_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg) |
|||
{ |
|||
switch(msg) |
|||
{ |
|||
//case U8G_DEV_MSG_IS_BBX_INTERSECTION:
|
|||
// return u8g_pb_IsIntersection((u8g_pb_t *)(dev->dev_mem), (u8g_dev_arg_bbx_t *)arg);
|
|||
case U8G_DEV_MSG_INIT: |
|||
u8g_InitCom(u8g, dev); |
|||
u8g_WriteEscSeqP(u8g, dev, u8g_dev_ssd1325_nhd_27_12864_init_seq); |
|||
break; |
|||
case U8G_DEV_MSG_STOP: |
|||
break; |
|||
case U8G_DEV_MSG_PAGE_NEXT: |
|||
{ |
|||
uint8_t i; |
|||
u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem); |
|||
uint8_t *p = pb->buf; |
|||
u8g_uint_t cnt; |
|||
cnt = pb->width; |
|||
cnt >>= 3; |
|||
|
|||
for( i = 0; i < pb->p.page_height; i++ ) |
|||
{ |
|||
u8g_dev_ssd1325_prepare_row(u8g, dev, i); /* this will also enable chip select */ |
|||
u8g_WriteSequenceBWTo16GrDevice(u8g, dev, cnt, p); |
|||
u8g_SetChipSelect(u8g, dev, 0); |
|||
p+=cnt; |
|||
} |
|||
} |
|||
break; |
|||
case U8G_DEV_MSG_CONTRAST: |
|||
u8g_SetChipSelect(u8g, dev, 1); |
|||
u8g_SetAddress(u8g, dev, 0); /* instruction mode */ |
|||
u8g_WriteByte(u8g, dev, 0x081); |
|||
u8g_WriteByte(u8g, dev, (*(uint8_t *)arg) >> 1); |
|||
u8g_SetChipSelect(u8g, dev, 0); |
|||
break; |
|||
case U8G_DEV_MSG_SLEEP_ON: |
|||
u8g_WriteEscSeqP(u8g, dev, u8g_dev_ssd13xx_sleep_on); |
|||
return 1; |
|||
case U8G_DEV_MSG_SLEEP_OFF: |
|||
u8g_WriteEscSeqP(u8g, dev, u8g_dev_ssd13xx_sleep_off); |
|||
return 1; |
|||
} |
|||
return u8g_dev_pb8h1_base_fn(u8g, dev, msg, arg); |
|||
} |
|||
|
|||
static uint8_t u8g_dev_ssd1325_nhd27oled_2x_bw_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg) |
|||
{ |
|||
switch(msg) |
|||
{ |
|||
case U8G_DEV_MSG_INIT: |
|||
u8g_InitCom(u8g, dev); |
|||
u8g_WriteEscSeqP(u8g, dev, u8g_dev_ssd1325_nhd_27_12864_init_seq); |
|||
break; |
|||
case U8G_DEV_MSG_STOP: |
|||
break; |
|||
case U8G_DEV_MSG_PAGE_NEXT: |
|||
{ |
|||
uint8_t i; |
|||
u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem); |
|||
uint8_t *p = pb->buf; |
|||
u8g_uint_t cnt; |
|||
cnt = pb->width; |
|||
cnt >>= 3; |
|||
|
|||
for( i = 0; i < pb->p.page_height; i++ ) |
|||
{ |
|||
u8g_dev_ssd1325_prepare_row(u8g, dev, i); /* this will also enable chip select */ |
|||
u8g_WriteSequenceBWTo16GrDevice(u8g, dev, cnt, p); |
|||
u8g_SetChipSelect(u8g, dev, 0); |
|||
p+=cnt; |
|||
} |
|||
} |
|||
break; |
|||
case U8G_DEV_MSG_CONTRAST: |
|||
u8g_SetChipSelect(u8g, dev, 1); |
|||
u8g_SetAddress(u8g, dev, 0); /* instruction mode */ |
|||
u8g_WriteByte(u8g, dev, 0x081); |
|||
u8g_WriteByte(u8g, dev, (*(uint8_t *)arg) >> 1); |
|||
u8g_SetChipSelect(u8g, dev, 0); |
|||
break; |
|||
case U8G_DEV_MSG_SLEEP_ON: |
|||
u8g_WriteEscSeqP(u8g, dev, u8g_dev_ssd13xx_sleep_on); |
|||
return 1; |
|||
case U8G_DEV_MSG_SLEEP_OFF: |
|||
u8g_WriteEscSeqP(u8g, dev, u8g_dev_ssd13xx_sleep_off); |
|||
return 1; |
|||
} |
|||
return u8g_dev_pb16h1_base_fn(u8g, dev, msg, arg); |
|||
} |
|||
|
|||
|
|||
|
|||
U8G_PB_DEV(u8g_dev_ssd1325_nhd27oled_bw_sw_spi , WIDTH, HEIGHT, 8, u8g_dev_ssd1325_nhd27oled_bw_fn, U8G_COM_SW_SPI); |
|||
U8G_PB_DEV(u8g_dev_ssd1325_nhd27oled_bw_hw_spi , WIDTH, HEIGHT, 8, u8g_dev_ssd1325_nhd27oled_bw_fn, U8G_COM_HW_SPI); |
|||
U8G_PB_DEV(u8g_dev_ssd1325_nhd27oled_bw_parallel , WIDTH, HEIGHT, 8, u8g_dev_ssd1325_nhd27oled_bw_fn, U8G_COM_FAST_PARALLEL); |
|||
|
|||
uint8_t u8g_dev_ssd1325_nhd27oled_2x_bw_buf[WIDTH*2] U8G_NOCOMMON ; |
|||
u8g_pb_t u8g_dev_ssd1325_nhd27oled_2x_bw_pb = { {16, HEIGHT, 0, 0, 0}, WIDTH, u8g_dev_ssd1325_nhd27oled_2x_bw_buf}; |
|||
u8g_dev_t u8g_dev_ssd1325_nhd27oled_2x_bw_sw_spi = { u8g_dev_ssd1325_nhd27oled_2x_bw_fn, &u8g_dev_ssd1325_nhd27oled_2x_bw_pb, U8G_COM_SW_SPI }; |
|||
u8g_dev_t u8g_dev_ssd1325_nhd27oled_2x_bw_hw_spi = { u8g_dev_ssd1325_nhd27oled_2x_bw_fn, &u8g_dev_ssd1325_nhd27oled_2x_bw_pb, U8G_COM_HW_SPI }; |
|||
u8g_dev_t u8g_dev_ssd1325_nhd27oled_2x_bw_parallel = { u8g_dev_ssd1325_nhd27oled_2x_bw_fn, &u8g_dev_ssd1325_nhd27oled_2x_bw_pb, U8G_COM_FAST_PARALLEL }; |
|||
|
|||
@ -0,0 +1,255 @@ |
|||
/*
|
|||
|
|||
u8g_dev_ssd1325_nhd27oled_gr.c |
|||
|
|||
2-Bit (gray level) Driver for SSD1325 Controller (OLED Display) |
|||
Tested with NHD-2.7-12864UCY3 |
|||
|
|||
Universal 8bit Graphics Library |
|||
|
|||
Copyright (c) 2011, olikraus@gmail.com |
|||
All rights reserved. |
|||
|
|||
Redistribution and use in source and binary forms, with or without modification, |
|||
are permitted provided that the following conditions are met: |
|||
|
|||
* Redistributions of source code must retain the above copyright notice, this list |
|||
of conditions and the following disclaimer. |
|||
|
|||
* Redistributions in binary form must reproduce the above copyright notice, this |
|||
list of conditions and the following disclaimer in the documentation and/or other |
|||
materials provided with the distribution. |
|||
|
|||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
|||
CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
|||
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
|||
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
|||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
|||
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
|||
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
|||
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
|||
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
|||
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF |
|||
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|||
|
|||
SSD130x Monochrom OLED Controller |
|||
SSD131x Character OLED Controller |
|||
SSD132x Graylevel OLED Controller |
|||
SSD1331 Color OLED Controller |
|||
|
|||
*/ |
|||
|
|||
#ifdef OBSOLETE_CODE |
|||
|
|||
#include "u8g.h" |
|||
|
|||
#define WIDTH 128 |
|||
#define HEIGHT 64 |
|||
|
|||
/* http://www.newhavendisplay.com/app_notes/OLED_2_7_12864.txt */ |
|||
static const uint8_t u8g_dev_ssd1325_2bit_nhd_27_12864ucy3_init_seq[] PROGMEM = { |
|||
U8G_ESC_DLY(10), /* delay 10 ms */ |
|||
U8G_ESC_CS(0), /* disable chip */ |
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
U8G_ESC_RST(1), /* do reset low pulse with (1*16)+2 milliseconds */ |
|||
U8G_ESC_CS(1), /* enable chip */ |
|||
0x0ae, /* display off, sleep mode */ |
|||
0x0b3, 0x091, /* set display clock divide ratio/oscillator frequency (set clock as 135 frames/sec) */ |
|||
0x0a8, 0x03f, /* multiplex ratio: 0x03f * 1/64 duty */ |
|||
0x0a2, 0x04c, /* display offset, shift mapping ram counter */ |
|||
0x0a1, 0x000, /* display start line */ |
|||
0x0ad, 0x002, /* master configuration: disable embedded DC-DC, enable internal VCOMH */ |
|||
0x0a0, 0x056, /* remap configuration, vertical address increment, enable nibble remap (upper nibble is left) */ |
|||
0x086, /* full current range (0x084, 0x085, 0x086) */ |
|||
0x0b8, /* set gray scale table */ |
|||
//0x01, 0x011, 0x022, 0x032, 0x043, 0x054, 0x065, 0x076,
|
|||
0x01, 0x011, 0x022, 0x032, 0x043, 0x054, 0x077, 0x077, // 4L mode uses 0, 2, 4, 7
|
|||
0x081, 0x070, /* contrast, brightness, 0..128, Newhaven: 0x040 */ |
|||
0x0b2, 0x051, /* frame frequency (row period) */ |
|||
0x0b1, 0x055, /* phase length */ |
|||
0x0bc, 0x010, /* pre-charge voltage level */ |
|||
0x0b4, 0x002, /* set pre-charge compensation level (not documented in the SDD1325 datasheet, but used in the NHD init seq.) */ |
|||
0x0b0, 0x028, /* enable pre-charge compensation (not documented in the SDD1325 datasheet, but used in the NHD init seq.) */ |
|||
0x0be, 0x01c, /* VCOMH voltage */ |
|||
0x0bf, 0x002|0x00d, /* VSL voltage level (not documented in the SDD1325 datasheet, but used in the NHD init seq.) */ |
|||
0x0a5, /* all pixel on */ |
|||
0x0af, /* display on */ |
|||
U8G_ESC_DLY(100), /* delay 100 ms */ |
|||
U8G_ESC_DLY(100), /* delay 100 ms */ |
|||
0x0a4, /* normal display mode */ |
|||
U8G_ESC_CS(0), /* disable chip */ |
|||
U8G_ESC_END /* end of sequence */ |
|||
}; |
|||
|
|||
static const uint8_t u8g_dev_ssd1325_2bit_nhd_27_12864ucy3_prepare_page_seq[] PROGMEM = { |
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
U8G_ESC_CS(1), /* enable chip */ |
|||
0x015, /* column address... */ |
|||
0x000, /* start at column 0 */ |
|||
0x03f, /* end at column 63 (which is y == 127), because there are two pixel in one column */ |
|||
0x075, /* row address... */ |
|||
U8G_ESC_END /* end of sequence */ |
|||
}; |
|||
|
|||
|
|||
static void u8g_dev_ssd1325_2bit_prepare_page(u8g_t *u8g, u8g_dev_t *dev) |
|||
{ |
|||
uint8_t page = ((u8g_pb_t *)(dev->dev_mem))->p.page; |
|||
|
|||
u8g_WriteEscSeqP(u8g, dev, u8g_dev_ssd1325_2bit_nhd_27_12864ucy3_prepare_page_seq); |
|||
|
|||
page <<= 2; |
|||
u8g_WriteByte(u8g, dev, page); /* start at the selected page */ |
|||
page += 3; |
|||
u8g_WriteByte(u8g, dev, page); /* end within the selected page */ |
|||
|
|||
u8g_SetAddress(u8g, dev, 1); /* data mode */ |
|||
} |
|||
|
|||
static void u8g_dev_ssd1325_2bit_2x_prepare_page(u8g_t *u8g, u8g_dev_t *dev, uint8_t is_odd) |
|||
{ |
|||
uint8_t page = ((u8g_pb_t *)(dev->dev_mem))->p.page; |
|||
|
|||
u8g_WriteEscSeqP(u8g, dev, u8g_dev_ssd1325_2bit_nhd_27_12864ucy3_prepare_page_seq); |
|||
|
|||
page <<= 1; |
|||
page += is_odd; |
|||
|
|||
|
|||
page <<= 2; |
|||
u8g_WriteByte(u8g, dev, page); /* start at the selected page */ |
|||
page += 3; |
|||
u8g_WriteByte(u8g, dev, page); /* end within the selected page */ |
|||
|
|||
u8g_SetAddress(u8g, dev, 1); /* data mode */ |
|||
} |
|||
|
|||
/* assumes row autoincrement and activated nibble remap */ |
|||
static void u8g_dev_ssd1325_2bit_write_4_pixel(u8g_t *u8g, u8g_dev_t *dev, uint8_t left, uint8_t right) |
|||
{ |
|||
uint8_t d, tmp, cnt; |
|||
cnt = 4; |
|||
do |
|||
{ |
|||
d = left; |
|||
d &= 3; |
|||
d <<= 4; |
|||
tmp = right; |
|||
tmp &= 3; |
|||
d |= tmp; |
|||
d <<= 2; |
|||
u8g_WriteByte(u8g, dev, d); |
|||
left >>= 2; |
|||
right >>= 2; |
|||
cnt--; |
|||
}while ( cnt > 0 ); |
|||
} |
|||
|
|||
static void u8g_dev_ssd1325_2bit_write_buffer(u8g_t *u8g, u8g_dev_t *dev) |
|||
{ |
|||
uint8_t cnt, left, right; |
|||
uint8_t *ptr; |
|||
u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem); |
|||
|
|||
cnt = pb->width; |
|||
cnt >>= 1; |
|||
ptr = pb->buf; |
|||
do |
|||
{ |
|||
left = *ptr++; |
|||
right = *ptr++; |
|||
u8g_dev_ssd1325_2bit_write_4_pixel(u8g, dev, left, right); |
|||
cnt--; |
|||
} while( cnt > 0 ); |
|||
} |
|||
|
|||
static void u8g_dev_ssd1325_2bit_2x_write_buffer(u8g_t *u8g, u8g_dev_t *dev, uint8_t is_odd) |
|||
{ |
|||
uint8_t cnt, left, right; |
|||
uint8_t *ptr; |
|||
u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem); |
|||
|
|||
ptr = pb->buf; |
|||
cnt = pb->width; |
|||
if ( is_odd ) |
|||
ptr += cnt; |
|||
cnt >>= 1; |
|||
do |
|||
{ |
|||
left = *ptr++; |
|||
right = *ptr++; |
|||
u8g_dev_ssd1325_2bit_write_4_pixel(u8g, dev, left, right); |
|||
cnt--; |
|||
} while( cnt > 0 ); |
|||
} |
|||
|
|||
static uint8_t u8g_dev_ssd1325_nhd27oled_gr_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg) |
|||
{ |
|||
switch(msg) |
|||
{ |
|||
case U8G_DEV_MSG_INIT: |
|||
u8g_InitCom(u8g, dev); |
|||
u8g_WriteEscSeqP(u8g, dev, u8g_dev_ssd1325_2bit_nhd_27_12864ucy3_init_seq); |
|||
break; |
|||
case U8G_DEV_MSG_STOP: |
|||
break; |
|||
case U8G_DEV_MSG_PAGE_NEXT: |
|||
{ |
|||
u8g_dev_ssd1325_2bit_prepare_page(u8g, dev); |
|||
u8g_dev_ssd1325_2bit_write_buffer(u8g, dev); |
|||
u8g_SetChipSelect(u8g, dev, 0); |
|||
} |
|||
break; |
|||
case U8G_DEV_MSG_CONTRAST: |
|||
u8g_SetChipSelect(u8g, dev, 1); |
|||
u8g_SetAddress(u8g, dev, 0); /* instruction mode */ |
|||
u8g_WriteByte(u8g, dev, 0x081); |
|||
u8g_WriteByte(u8g, dev, (*(uint8_t *)arg) >> 1); |
|||
u8g_SetChipSelect(u8g, dev, 0); |
|||
return 1; |
|||
} |
|||
return u8g_dev_pb8v2_base_fn(u8g, dev, msg, arg); |
|||
} |
|||
|
|||
static uint8_t u8g_dev_ssd1325_nhd27oled_2x_gr_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg) |
|||
{ |
|||
switch(msg) |
|||
{ |
|||
case U8G_DEV_MSG_INIT: |
|||
u8g_InitCom(u8g, dev); |
|||
u8g_WriteEscSeqP(u8g, dev, u8g_dev_ssd1325_2bit_nhd_27_12864ucy3_init_seq); |
|||
break; |
|||
case U8G_DEV_MSG_STOP: |
|||
break; |
|||
case U8G_DEV_MSG_PAGE_NEXT: |
|||
{ |
|||
u8g_dev_ssd1325_2bit_2x_prepare_page(u8g, dev, 0); |
|||
u8g_dev_ssd1325_2bit_2x_write_buffer(u8g, dev, 0); |
|||
u8g_dev_ssd1325_2bit_2x_prepare_page(u8g, dev, 1); |
|||
u8g_dev_ssd1325_2bit_2x_write_buffer(u8g, dev, 1); |
|||
u8g_SetChipSelect(u8g, dev, 0); |
|||
} |
|||
break; |
|||
case U8G_DEV_MSG_CONTRAST: |
|||
u8g_SetChipSelect(u8g, dev, 1); |
|||
u8g_SetAddress(u8g, dev, 0); /* instruction mode */ |
|||
u8g_WriteByte(u8g, dev, 0x081); |
|||
u8g_WriteByte(u8g, dev, (*(uint8_t *)arg) >> 1); |
|||
u8g_SetChipSelect(u8g, dev, 0); |
|||
return 1; |
|||
} |
|||
return u8g_dev_pb16v2_base_fn(u8g, dev, msg, arg); |
|||
} |
|||
|
|||
//U8G_PB_DEV(u8g_dev_ssd1325_nhd27oled_gr_sw_spi , WIDTH, HEIGHT, 4, u8g_dev_ssd1325_nhd27oled_gr_fn, U8G_COM_SW_SPI);
|
|||
//U8G_PB_DEV(u8g_dev_ssd1325_nhd27oled_gr_hw_spi , WIDTH, HEIGHT, 4, u8g_dev_ssd1325_nhd27oled_gr_fn, U8G_COM_HW_SPI);
|
|||
|
|||
//uint8_t u8g_dev_ssd1325_nhd27oled_2x_buf[WIDTH*2] U8G_NOCOMMON ;
|
|||
//u8g_pb_t u8g_dev_ssd1325_nhd27oled_2x_pb = { {8, HEIGHT, 0, 0, 0}, WIDTH, u8g_dev_ssd1325_nhd27oled_2x_buf};
|
|||
//u8g_dev_t u8g_dev_ssd1325_nhd27oled_2x_gr_sw_spi = { u8g_dev_ssd1325_nhd27oled_2x_gr_fn, &u8g_dev_ssd1325_nhd27oled_2x_pb, U8G_COM_SW_SPI };
|
|||
//u8g_dev_t u8g_dev_ssd1325_nhd27oled_2x_gr_hw_spi = { u8g_dev_ssd1325_nhd27oled_2x_gr_fn, &u8g_dev_ssd1325_nhd27oled_2x_pb, U8G_COM_HW_SPI };
|
|||
|
|||
|
|||
#endif /* OBSOLETE_CODE */ |
|||
@ -0,0 +1,227 @@ |
|||
/*
|
|||
|
|||
u8g_dev_ssd1325_nhd27oled_gr.c |
|||
|
|||
2-Bit (gray level) Driver for SSD1325 Controller (OLED Display) |
|||
Rewritten with new architecture |
|||
Tested with NHD-2.7-12864UCY3 |
|||
|
|||
Universal 8bit Graphics Library |
|||
|
|||
Copyright (c) 2011, olikraus@gmail.com |
|||
All rights reserved. |
|||
|
|||
Redistribution and use in source and binary forms, with or without modification, |
|||
are permitted provided that the following conditions are met: |
|||
|
|||
* Redistributions of source code must retain the above copyright notice, this list |
|||
of conditions and the following disclaimer. |
|||
|
|||
* Redistributions in binary form must reproduce the above copyright notice, this |
|||
list of conditions and the following disclaimer in the documentation and/or other |
|||
materials provided with the distribution. |
|||
|
|||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
|||
CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
|||
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
|||
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
|||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
|||
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
|||
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
|||
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
|||
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
|||
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF |
|||
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|||
|
|||
SSD130x Monochrom OLED Controller |
|||
SSD131x Character OLED Controller |
|||
SSD132x Graylevel OLED Controller |
|||
SSD1331 Color OLED Controller |
|||
|
|||
*/ |
|||
|
|||
#include "u8g.h" |
|||
|
|||
#define WIDTH 128 |
|||
#define HEIGHT 64 |
|||
|
|||
/* http://www.newhavendisplay.com/app_notes/OLED_2_7_12864.txt */ |
|||
static const uint8_t u8g_dev_ssd1325_2bit_nhd_27_12864ucy3_init_seq[] PROGMEM = { |
|||
U8G_ESC_DLY(10), /* delay 10 ms */ |
|||
U8G_ESC_CS(0), /* disable chip */ |
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
U8G_ESC_RST(1), /* do reset low pulse with (1*16)+2 milliseconds */ |
|||
U8G_ESC_CS(1), /* enable chip */ |
|||
0x0ae, /* display off, sleep mode */ |
|||
0x0b3, 0x091, /* set display clock divide ratio/oscillator frequency (set clock as 135 frames/sec) */ |
|||
0x0a8, 0x03f, /* multiplex ratio: 0x03f * 1/64 duty */ |
|||
0x0a2, 0x04c, /* display offset, shift mapping ram counter */ |
|||
0x0a1, 0x000, /* display start line */ |
|||
0x0ad, 0x002, /* master configuration: disable embedded DC-DC, enable internal VCOMH */ |
|||
0x0a0, 0x052, /* remap configuration, horizontal address increment (bit 2 = 0), enable nibble remap (upper nibble is left, bit 1 = 1), old values: 0x0a0 0x0a6 */ |
|||
0x086, /* full current range (0x084, 0x085, 0x086) */ |
|||
0x0b8, /* set gray scale table */ |
|||
//0x01, 0x011, 0x022, 0x032, 0x043, 0x054, 0x065, 0x076,
|
|||
0x01, 0x011, 0x022, 0x032, 0x043, 0x054, 0x077, 0x077, // 4L mode uses 0, 2, 4, 7
|
|||
0x081, 0x070, /* contrast, brightness, 0..128, Newhaven: 0x040 */ |
|||
0x0b2, 0x051, /* frame frequency (row period) */ |
|||
0x0b1, 0x055, /* phase length */ |
|||
0x0bc, 0x010, /* pre-charge voltage level */ |
|||
0x0b4, 0x002, /* set pre-charge compensation level (not documented in the SDD1325 datasheet, but used in the NHD init seq.) */ |
|||
0x0b0, 0x028, /* enable pre-charge compensation (not documented in the SDD1325 datasheet, but used in the NHD init seq.) */ |
|||
0x0be, 0x01c, /* VCOMH voltage */ |
|||
0x0bf, 0x002|0x00d, /* VSL voltage level (not documented in the SDD1325 datasheet, but used in the NHD init seq.) */ |
|||
0x0a4, /* normal display mode */ |
|||
0x0af, /* display on */ |
|||
U8G_ESC_DLY(50), /* delay 50 ms */ |
|||
U8G_ESC_CS(0), /* disable chip */ |
|||
U8G_ESC_END /* end of sequence */ |
|||
}; |
|||
|
|||
static const uint8_t u8g_dev_ssd1325_2bit_nhd_27_12864ucy3_prepare_page_seq[] PROGMEM = { |
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
U8G_ESC_CS(1), /* enable chip */ |
|||
0x015, /* column address... */ |
|||
0x000, /* start at column 0 */ |
|||
0x03f, /* end at column 63 (which is y == 127), because there are two pixel in one column */ |
|||
0x075, /* row address... */ |
|||
U8G_ESC_END /* end of sequence */ |
|||
}; |
|||
|
|||
static void u8g_dev_ssd1325_gr_prepare_row(u8g_t *u8g, u8g_dev_t *dev, uint8_t delta_row) |
|||
{ |
|||
uint8_t row = ((u8g_pb_t *)(dev->dev_mem))->p.page; |
|||
|
|||
row *= ((u8g_pb_t *)(dev->dev_mem))->p.page_height; |
|||
row += delta_row; |
|||
|
|||
u8g_WriteEscSeqP(u8g, dev, u8g_dev_ssd1325_2bit_nhd_27_12864ucy3_prepare_page_seq); |
|||
|
|||
u8g_WriteByte(u8g, dev, row); /* start at the selected row */ |
|||
u8g_WriteByte(u8g, dev, row+1); /* end within the selected row */ |
|||
|
|||
//u8g_SetAddress(u8g, dev, 0); /* instruction mode mode */
|
|||
//u8g_WriteByte(u8g, dev, 0x05c); /* write to ram */
|
|||
u8g_SetAddress(u8g, dev, 1); /* data mode */ |
|||
} |
|||
|
|||
static const uint8_t u8g_dev_ssd13xx_sleep_on[] PROGMEM = { |
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
U8G_ESC_CS(1), /* enable chip */ |
|||
0x0ae, /* display off */ |
|||
U8G_ESC_CS(1), /* disable chip */ |
|||
U8G_ESC_END /* end of sequence */ |
|||
}; |
|||
|
|||
static const uint8_t u8g_dev_ssd13xx_sleep_off[] PROGMEM = { |
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
U8G_ESC_CS(1), /* enable chip */ |
|||
0x0af, /* display on */ |
|||
U8G_ESC_DLY(50), /* delay 50 ms */ |
|||
U8G_ESC_CS(1), /* disable chip */ |
|||
U8G_ESC_END /* end of sequence */ |
|||
}; |
|||
|
|||
|
|||
|
|||
static uint8_t u8g_dev_ssd1325_nhd27oled_gr_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg) |
|||
{ |
|||
switch(msg) |
|||
{ |
|||
case U8G_DEV_MSG_INIT: |
|||
u8g_InitCom(u8g, dev); |
|||
u8g_WriteEscSeqP(u8g, dev, u8g_dev_ssd1325_2bit_nhd_27_12864ucy3_init_seq); |
|||
break; |
|||
case U8G_DEV_MSG_STOP: |
|||
break; |
|||
case U8G_DEV_MSG_PAGE_NEXT: |
|||
{ |
|||
uint8_t i; |
|||
u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem); |
|||
uint8_t *p = pb->buf; |
|||
u8g_uint_t cnt; |
|||
cnt = pb->width; |
|||
cnt >>= 2; |
|||
|
|||
for( i = 0; i < pb->p.page_height; i++ ) |
|||
{ |
|||
u8g_dev_ssd1325_gr_prepare_row(u8g, dev, i); /* this will also enable chip select */ |
|||
u8g_WriteSequence4LTo16GrDevice(u8g, dev, cnt, p); |
|||
u8g_SetChipSelect(u8g, dev, 0); |
|||
p+=cnt; |
|||
} |
|||
} |
|||
break; |
|||
case U8G_DEV_MSG_CONTRAST: |
|||
u8g_SetChipSelect(u8g, dev, 1); |
|||
u8g_SetAddress(u8g, dev, 0); /* instruction mode */ |
|||
u8g_WriteByte(u8g, dev, 0x081); |
|||
u8g_WriteByte(u8g, dev, (*(uint8_t *)arg) >> 1); |
|||
u8g_SetChipSelect(u8g, dev, 0); |
|||
return 1; |
|||
case U8G_DEV_MSG_SLEEP_ON: |
|||
u8g_WriteEscSeqP(u8g, dev, u8g_dev_ssd13xx_sleep_on); |
|||
return 1; |
|||
case U8G_DEV_MSG_SLEEP_OFF: |
|||
u8g_WriteEscSeqP(u8g, dev, u8g_dev_ssd13xx_sleep_off); |
|||
return 1; |
|||
} |
|||
return u8g_dev_pb8h2_base_fn(u8g, dev, msg, arg); |
|||
} |
|||
|
|||
|
|||
|
|||
static uint8_t u8g_dev_ssd1325_nhd27oled_2x_gr_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg) |
|||
{ |
|||
switch(msg) |
|||
{ |
|||
case U8G_DEV_MSG_INIT: |
|||
u8g_InitCom(u8g, dev); |
|||
u8g_WriteEscSeqP(u8g, dev, u8g_dev_ssd1325_2bit_nhd_27_12864ucy3_init_seq); |
|||
break; |
|||
case U8G_DEV_MSG_STOP: |
|||
break; |
|||
case U8G_DEV_MSG_PAGE_NEXT: |
|||
{ |
|||
uint8_t i; |
|||
u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem); |
|||
uint8_t *p = pb->buf; |
|||
u8g_uint_t cnt; |
|||
cnt = pb->width; |
|||
cnt >>= 2; |
|||
|
|||
for( i = 0; i < pb->p.page_height; i++ ) |
|||
{ |
|||
u8g_dev_ssd1325_gr_prepare_row(u8g, dev, i); /* this will also enable chip select */ |
|||
u8g_WriteSequence4LTo16GrDevice(u8g, dev, cnt, p); |
|||
u8g_SetChipSelect(u8g, dev, 0); |
|||
p+=cnt; |
|||
} |
|||
} |
|||
break; |
|||
case U8G_DEV_MSG_CONTRAST: |
|||
u8g_SetChipSelect(u8g, dev, 1); |
|||
u8g_SetAddress(u8g, dev, 0); /* instruction mode */ |
|||
u8g_WriteByte(u8g, dev, 0x081); |
|||
u8g_WriteByte(u8g, dev, (*(uint8_t *)arg) >> 1); |
|||
u8g_SetChipSelect(u8g, dev, 0); |
|||
return 1; |
|||
case U8G_DEV_MSG_SLEEP_ON: |
|||
u8g_WriteEscSeqP(u8g, dev, u8g_dev_ssd13xx_sleep_on); |
|||
return 1; |
|||
case U8G_DEV_MSG_SLEEP_OFF: |
|||
u8g_WriteEscSeqP(u8g, dev, u8g_dev_ssd13xx_sleep_off); |
|||
return 1; |
|||
} |
|||
return u8g_dev_pb16h2_base_fn(u8g, dev, msg, arg); |
|||
} |
|||
|
|||
U8G_PB_DEV(u8g_dev_ssd1325_nhd27oled_gr_sw_spi , WIDTH, HEIGHT, 4, u8g_dev_ssd1325_nhd27oled_gr_fn, U8G_COM_SW_SPI); |
|||
U8G_PB_DEV(u8g_dev_ssd1325_nhd27oled_gr_hw_spi , WIDTH, HEIGHT, 4, u8g_dev_ssd1325_nhd27oled_gr_fn, U8G_COM_HW_SPI); |
|||
|
|||
uint8_t u8g_dev_ssd1325_nhd27oled_2x_buf[WIDTH*2] U8G_NOCOMMON ; |
|||
u8g_pb_t u8g_dev_ssd1325_nhd27oled_2x_pb = { {8, HEIGHT, 0, 0, 0}, WIDTH, u8g_dev_ssd1325_nhd27oled_2x_buf}; |
|||
u8g_dev_t u8g_dev_ssd1325_nhd27oled_2x_gr_sw_spi = { u8g_dev_ssd1325_nhd27oled_2x_gr_fn, &u8g_dev_ssd1325_nhd27oled_2x_pb, U8G_COM_SW_SPI }; |
|||
u8g_dev_t u8g_dev_ssd1325_nhd27oled_2x_gr_hw_spi = { u8g_dev_ssd1325_nhd27oled_2x_gr_fn, &u8g_dev_ssd1325_nhd27oled_2x_pb, U8G_COM_HW_SPI }; |
|||
@ -0,0 +1,299 @@ |
|||
/*
|
|||
|
|||
u8g_dev_ssd1327_96x96_gr.c |
|||
|
|||
2-Bit (graylevel) Driver for SSD1327 Controller (OLED Display) |
|||
Tested with Seedstudio 96x96 Oled (LY120) |
|||
http://www.seeedstudio.com/wiki/index.php?title=Twig_-_OLED_96x96
|
|||
|
|||
Universal 8bit Graphics Library |
|||
|
|||
Copyright (c) 2012, olikraus@gmail.com |
|||
All rights reserved. |
|||
|
|||
Redistribution and use in source and binary forms, with or without modification, |
|||
are permitted provided that the following conditions are met: |
|||
|
|||
* Redistributions of source code must retain the above copyright notice, this list |
|||
of conditions and the following disclaimer. |
|||
|
|||
* Redistributions in binary form must reproduce the above copyright notice, this |
|||
list of conditions and the following disclaimer in the documentation and/or other |
|||
materials provided with the distribution. |
|||
|
|||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
|||
CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
|||
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
|||
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
|||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
|||
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
|||
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
|||
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
|||
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
|||
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF |
|||
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|||
|
|||
SSD130x Monochrom OLED Controller |
|||
SSD131x Character OLED Controller |
|||
SSD132x Graylevel OLED Controller |
|||
SSD1331 Color OLED Controller |
|||
|
|||
*/ |
|||
|
|||
#include "u8g.h" |
|||
|
|||
#define WIDTH 96 |
|||
#define HEIGHT 96 |
|||
#define XOFFSET 8 |
|||
|
|||
/*
|
|||
http://www.seeedstudio.com/wiki/index.php?title=Twig_-_OLED_96x96
|
|||
*/ |
|||
static const uint8_t u8g_dev_ssd1327_2bit_96x96_init_seq[] PROGMEM = { |
|||
U8G_ESC_DLY(10), /* delay 10 ms */ |
|||
U8G_ESC_CS(0), /* disable chip */ |
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
U8G_ESC_RST(1), /* do reset low pulse with (1*16)+2 milliseconds */ |
|||
U8G_ESC_CS(1), /* enable chip */ |
|||
0x0fd, 0x012, /* unlock display, usually not required because the display is unlocked after reset */ |
|||
0x0ae, /* display off, sleep mode */ |
|||
0x0a8, 0x05f, /* multiplex ratio: 0x05f * 1/64 duty */ |
|||
0x0a1, 0x000, /* display start line */ |
|||
0x0a2, 0x060, /* display offset, shift mapping ram counter */ |
|||
//0x0a2, 0x04c, /* NHD: display offset, shift mapping ram counter */
|
|||
0x0a0, 0x046, /* remap configuration, vertical address increment, enable nibble remap (upper nibble is left) */ |
|||
//0x0a0, 0x056, /* NHD: remap configuration, vertical address increment, enable nibble remap (upper nibble is left) */
|
|||
0x0ab, 0x001, /* Enable internal VDD regulator (RESET) */ |
|||
0x081, 0x053, /* contrast, brightness, 0..128, Newhaven: 0x040, LY120 0x053, 0x070 seems also ok */ |
|||
0x0b1, 0x051, /* phase length */ |
|||
0x0b3, 0x001, /* set display clock divide ratio/oscillator frequency */ |
|||
0x0b9, /* use linear lookup table */ |
|||
#if 0 |
|||
0x0b8, /* set gray scale table */ |
|||
//0x01, 0x011, 0x022, 0x032, 0x043, 0x054, 0x065, 0x076,
|
|||
0x01, 0x011, 0x022, 0x032, 0x043, 0x054, 0x077, 0x077, // 4L mode uses 0, 2, 4, 7
|
|||
#endif |
|||
0x0bc, 0x008, /* pre-charge voltage level */ |
|||
0x0be, 0x007, /* VCOMH voltage */ |
|||
0x0b6, 0x001, /* second precharge */ |
|||
0x0d5, 0x062, /* enable second precharge, internal vsl (bit0 = 0) */ |
|||
|
|||
#if 0 |
|||
// the following commands are not used by the SeeedGrayOLED sequence */
|
|||
0x0ad, 0x002, /* master configuration: disable embedded DC-DC, enable internal VCOMH */ |
|||
0x086, /* full current range (0x084, 0x085, 0x086) */ |
|||
0x0b2, 0x051, /* frame frequency (row period) */ |
|||
0x0b4, 0x002, /* set pre-charge compensation level (not documented in the SDD1325 datasheet, but used in the NHD init seq.) */ |
|||
0x0b0, 0x028, /* enable pre-charge compensation (not documented in the SDD1325 datasheet, but used in the NHD init seq.) */ |
|||
0x0bf, 0x002|0x00d, /* VSL voltage level (not documented in the SDD1325 datasheet, but used in the NHD init seq.) */ |
|||
#endif |
|||
|
|||
0x0a5, /* all pixel on */ |
|||
//0x02e, /* no scroll (according to SeeedGrayOLED sequence) */
|
|||
0x0af, /* display on */ |
|||
U8G_ESC_DLY(100), /* delay 100 ms */ |
|||
0x0a4, /* normal display mode */ |
|||
U8G_ESC_DLY(100), /* delay 100 ms */ |
|||
0x0a5, /* all pixel on */ |
|||
0x0af, /* display on */ |
|||
U8G_ESC_DLY(100), /* delay 100 ms */ |
|||
0x0a4, /* normal display mode */ |
|||
|
|||
0x015, /* column address... */ |
|||
0x008, /* start at column 8, special for the LY120 ??? */ |
|||
0x037, /* end at column 55, note: there are two pixel in one column */ |
|||
|
|||
0x075, /* row address... */ |
|||
0x008, |
|||
0x05f, |
|||
|
|||
U8G_ESC_ADR(1), /* data mode */ |
|||
0x000f, 0x000f, 0x0000, 0x0000, 0x000f,0x000f,0x0000,0x0000, |
|||
0x000f, 0x000f, 0x0000, 0x0000, 0x000f,0x000f,0x0000,0x0000, |
|||
0x000f, 0x000f, 0x0000, 0x0000, 0x000f,0x000f,0x0000,0x0000, |
|||
0x000f, 0x000f, 0x0000, 0x0000, 0x000f,0x000f,0x0000,0x0000, |
|||
|
|||
U8G_ESC_CS(0), /* disable chip */ |
|||
U8G_ESC_END /* end of sequence */ |
|||
}; |
|||
|
|||
static const uint8_t u8g_dev_ssd1327_2bit_96x96_prepare_page_seq[] PROGMEM = { |
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
U8G_ESC_CS(1), /* enable chip */ |
|||
0x015, /* column address... */ |
|||
XOFFSET, /* start at column 8, special for the LY120 ??? */ |
|||
0x037, /* end at column 55, note: there are two pixel in one column */ |
|||
0x075, /* row address... */ |
|||
U8G_ESC_END /* end of sequence */ |
|||
}; |
|||
|
|||
|
|||
static void u8g_dev_ssd1327_2bit_prepare_page(u8g_t *u8g, u8g_dev_t *dev) |
|||
{ |
|||
uint8_t page = ((u8g_pb_t *)(dev->dev_mem))->p.page; |
|||
|
|||
u8g_WriteEscSeqP(u8g, dev, u8g_dev_ssd1327_2bit_96x96_prepare_page_seq); |
|||
|
|||
page <<= 2; |
|||
u8g_WriteByte(u8g, dev, page); /* start at the selected page */ |
|||
page += 3; |
|||
u8g_WriteByte(u8g, dev, page); /* end within the selected page */ |
|||
|
|||
u8g_SetAddress(u8g, dev, 1); /* data mode */ |
|||
} |
|||
|
|||
static void u8g_dev_ssd1327_2bit_2x_prepare_page(u8g_t *u8g, u8g_dev_t *dev, uint8_t is_odd) |
|||
{ |
|||
uint8_t page = ((u8g_pb_t *)(dev->dev_mem))->p.page; |
|||
|
|||
u8g_WriteEscSeqP(u8g, dev, u8g_dev_ssd1327_2bit_96x96_prepare_page_seq); |
|||
|
|||
page <<= 1; |
|||
page += is_odd; |
|||
|
|||
page <<= 2; |
|||
u8g_WriteByte(u8g, dev, page); /* start at the selected page */ |
|||
page += 3; |
|||
u8g_WriteByte(u8g, dev, page); /* end within the selected page */ |
|||
|
|||
u8g_SetAddress(u8g, dev, 1); /* data mode */ |
|||
} |
|||
|
|||
/* assumes row autoincrement and activated nibble remap */ |
|||
static void u8g_dev_ssd1327_2bit_write_4_pixel(u8g_t *u8g, u8g_dev_t *dev, uint8_t left, uint8_t right) |
|||
{ |
|||
uint8_t d, tmp, cnt; |
|||
static uint8_t buf[4]; |
|||
buf[0] = 0; |
|||
buf[1] = 0; |
|||
buf[2] = 0; |
|||
buf[3] = 0; |
|||
cnt = 0; |
|||
do |
|||
{ |
|||
if ( left == 0 && right == 0 ) |
|||
break; |
|||
d = left; |
|||
d &= 3; |
|||
d <<= 4; |
|||
tmp = right; |
|||
tmp &= 3; |
|||
d |= tmp; |
|||
d <<= 2; |
|||
buf[cnt] = d; |
|||
left >>= 2; |
|||
right >>= 2; |
|||
cnt++; |
|||
}while ( cnt < 4 ); |
|||
u8g_WriteSequence(u8g, dev, 4, buf); |
|||
} |
|||
|
|||
static void u8g_dev_ssd1327_2bit_write_buffer(u8g_t *u8g, u8g_dev_t *dev) |
|||
{ |
|||
uint8_t cnt, left, right; |
|||
uint8_t *ptr; |
|||
u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem); |
|||
|
|||
cnt = pb->width; |
|||
cnt >>= 1; |
|||
ptr = pb->buf; |
|||
do |
|||
{ |
|||
left = *ptr++; |
|||
right = *ptr++; |
|||
u8g_dev_ssd1327_2bit_write_4_pixel(u8g, dev, left, right); |
|||
cnt--; |
|||
} while( cnt > 0 ); |
|||
} |
|||
|
|||
static void u8g_dev_ssd1327_2bit_2x_write_buffer(u8g_t *u8g, u8g_dev_t *dev, uint8_t is_odd) |
|||
{ |
|||
uint8_t cnt, left, right; |
|||
uint8_t *ptr; |
|||
u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem); |
|||
|
|||
ptr = pb->buf; |
|||
cnt = pb->width; |
|||
if ( is_odd ) |
|||
ptr += cnt; |
|||
cnt >>= 1; |
|||
do |
|||
{ |
|||
left = *ptr++; |
|||
right = *ptr++; |
|||
u8g_dev_ssd1327_2bit_write_4_pixel(u8g, dev, left, right); |
|||
cnt--; |
|||
} while( cnt > 0 ); |
|||
} |
|||
|
|||
uint8_t u8g_dev_ssd1327_96x96_gr_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg) |
|||
{ |
|||
switch(msg) |
|||
{ |
|||
case U8G_DEV_MSG_INIT: |
|||
u8g_InitCom(u8g, dev); |
|||
u8g_WriteEscSeqP(u8g, dev, u8g_dev_ssd1327_2bit_96x96_init_seq); |
|||
break; |
|||
case U8G_DEV_MSG_STOP: |
|||
break; |
|||
case U8G_DEV_MSG_PAGE_NEXT: |
|||
{ |
|||
u8g_dev_ssd1327_2bit_prepare_page(u8g, dev); |
|||
u8g_dev_ssd1327_2bit_write_buffer(u8g, dev); |
|||
u8g_SetChipSelect(u8g, dev, 0); |
|||
} |
|||
break; |
|||
case U8G_DEV_MSG_CONTRAST: |
|||
u8g_SetChipSelect(u8g, dev, 1); |
|||
u8g_SetAddress(u8g, dev, 0); /* instruction mode */ |
|||
u8g_WriteByte(u8g, dev, 0x081); |
|||
u8g_WriteByte(u8g, dev, (*(uint8_t *)arg) >> 1); |
|||
u8g_SetChipSelect(u8g, dev, 0); |
|||
return 1; |
|||
} |
|||
return u8g_dev_pb8v2_base_fn(u8g, dev, msg, arg); |
|||
} |
|||
|
|||
uint8_t u8g_dev_ssd1327_96x96_2x_gr_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg) |
|||
{ |
|||
switch(msg) |
|||
{ |
|||
case U8G_DEV_MSG_INIT: |
|||
u8g_InitCom(u8g, dev); |
|||
u8g_WriteEscSeqP(u8g, dev, u8g_dev_ssd1327_2bit_96x96_init_seq); |
|||
break; |
|||
case U8G_DEV_MSG_STOP: |
|||
break; |
|||
case U8G_DEV_MSG_PAGE_NEXT: |
|||
{ |
|||
u8g_dev_ssd1327_2bit_2x_prepare_page(u8g, dev, 0); |
|||
u8g_dev_ssd1327_2bit_2x_write_buffer(u8g, dev, 0); |
|||
u8g_dev_ssd1327_2bit_2x_prepare_page(u8g, dev, 1); |
|||
u8g_dev_ssd1327_2bit_2x_write_buffer(u8g, dev, 1); |
|||
u8g_SetChipSelect(u8g, dev, 0); |
|||
} |
|||
break; |
|||
case U8G_DEV_MSG_CONTRAST: |
|||
u8g_SetChipSelect(u8g, dev, 1); |
|||
u8g_SetAddress(u8g, dev, 0); /* instruction mode */ |
|||
u8g_WriteByte(u8g, dev, 0x081); |
|||
u8g_WriteByte(u8g, dev, (*(uint8_t *)arg) >> 1); |
|||
u8g_SetChipSelect(u8g, dev, 0); |
|||
return 1; |
|||
} |
|||
return u8g_dev_pb16v2_base_fn(u8g, dev, msg, arg); |
|||
} |
|||
|
|||
U8G_PB_DEV(u8g_dev_ssd1327_96x96_gr_sw_spi , WIDTH, HEIGHT, 4, u8g_dev_ssd1327_96x96_gr_fn, U8G_COM_SW_SPI); |
|||
U8G_PB_DEV(u8g_dev_ssd1327_96x96_gr_hw_spi , WIDTH, HEIGHT, 4, u8g_dev_ssd1327_96x96_gr_fn, U8G_COM_HW_SPI); |
|||
U8G_PB_DEV(u8g_dev_ssd1327_96x96_gr_i2c , WIDTH, HEIGHT, 4, u8g_dev_ssd1327_96x96_gr_fn, U8G_COM_SSD_I2C); |
|||
|
|||
#define DWIDTH (2*WIDTH) |
|||
uint8_t u8g_dev_ssd1327_96x96_2x_buf[DWIDTH] U8G_NOCOMMON ; |
|||
u8g_pb_t u8g_dev_ssd1327_96x96_2x_pb = { {8, HEIGHT, 0, 0, 0}, WIDTH, u8g_dev_ssd1327_96x96_2x_buf}; |
|||
u8g_dev_t u8g_dev_ssd1327_96x96_2x_gr_sw_spi = { u8g_dev_ssd1327_96x96_2x_gr_fn, &u8g_dev_ssd1327_96x96_2x_pb, U8G_COM_SW_SPI }; |
|||
u8g_dev_t u8g_dev_ssd1327_96x96_2x_gr_hw_spi = { u8g_dev_ssd1327_96x96_2x_gr_fn, &u8g_dev_ssd1327_96x96_2x_pb, U8G_COM_HW_SPI }; |
|||
u8g_dev_t u8g_dev_ssd1327_96x96_2x_gr_i2c = { u8g_dev_ssd1327_96x96_2x_gr_fn, &u8g_dev_ssd1327_96x96_2x_pb, U8G_COM_SSD_I2C }; |
|||
|
|||
@ -0,0 +1,153 @@ |
|||
/*
|
|||
|
|||
u8g_dev_st7565_64128n.c (Displaytech) |
|||
|
|||
Universal 8bit Graphics Library |
|||
|
|||
Copyright (c) 2011, olikraus@gmail.com |
|||
All rights reserved. |
|||
|
|||
Redistribution and use in source and binary forms, with or without modification, |
|||
are permitted provided that the following conditions are met: |
|||
|
|||
* Redistributions of source code must retain the above copyright notice, this list |
|||
of conditions and the following disclaimer. |
|||
|
|||
* Redistributions in binary form must reproduce the above copyright notice, this |
|||
list of conditions and the following disclaimer in the documentation and/or other |
|||
materials provided with the distribution. |
|||
|
|||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
|||
CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
|||
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
|||
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
|||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
|||
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
|||
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
|||
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
|||
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
|||
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF |
|||
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|||
|
|||
|
|||
*/ |
|||
|
|||
#include "u8g.h" |
|||
|
|||
#define WIDTH 128 |
|||
#define HEIGHT 64 |
|||
#define PAGE_HEIGHT 8 |
|||
|
|||
/* init sequence from https://github.com/adafruit/ST7565-LCD/blob/master/ST7565/ST7565.cpp */ |
|||
static const uint8_t u8g_dev_st7565_64128n_init_seq[] PROGMEM = { |
|||
U8G_ESC_CS(0), /* disable chip */ |
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
U8G_ESC_CS(1), /* enable chip */ |
|||
U8G_ESC_RST(15), /* do reset low pulse with (15*16)+2 milliseconds (=maximum delay)*/ |
|||
|
|||
0x0A2, /* 0x0a2: LCD bias 1/9 (according to Displaytech 64128N datasheet) */ |
|||
0x0A0, /* Normal ADC Select (according to Displaytech 64128N datasheet) */ |
|||
|
|||
0x0c8, /* common output mode: set scan direction normal operation/SHL Select, 0x0c0 --> SHL = 0, normal, 0x0c8 --> SHL = 1 */ |
|||
0x040, /* Display start line for Displaytech 64128N */ |
|||
|
|||
0x028 | 0x04, /* power control: turn on voltage converter */ |
|||
U8G_ESC_DLY(50), /* delay 50 ms */ |
|||
|
|||
0x028 | 0x06, /* power control: turn on voltage regulator */ |
|||
U8G_ESC_DLY(50), /* delay 50 ms */ |
|||
|
|||
0x028 | 0x07, /* power control: turn on voltage follower */ |
|||
U8G_ESC_DLY(50), /* delay 50 ms */ |
|||
|
|||
0x010, /* Set V0 voltage resistor ratio. Setting for controlling brightness of Displaytech 64128N */ |
|||
|
|||
0x0a6, /* display normal, bit val 0: LCD pixel off. */ |
|||
|
|||
0x081, /* set contrast */ |
|||
0x01e, /* Contrast value. Setting for controlling brightness of Displaytech 64128N */ |
|||
|
|||
|
|||
0x0af, /* display on */ |
|||
|
|||
U8G_ESC_DLY(100), /* delay 100 ms */ |
|||
0x0a5, /* display all points, ST7565 */ |
|||
U8G_ESC_DLY(100), /* delay 100 ms */ |
|||
U8G_ESC_DLY(100), /* delay 100 ms */ |
|||
0x0a4, /* normal display */ |
|||
U8G_ESC_CS(0), /* disable chip */ |
|||
U8G_ESC_END /* end of sequence */ |
|||
}; |
|||
|
|||
static const uint8_t u8g_dev_st7565_64128n_data_start[] PROGMEM = { |
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
U8G_ESC_CS(1), /* enable chip */ |
|||
0x010, /* set upper 4 bit of the col adr to 0x10 */ |
|||
0x000, /* set lower 4 bit of the col adr to 0x00. Changed for DisplayTech 64128N */ |
|||
U8G_ESC_END /* end of sequence */ |
|||
}; |
|||
|
|||
static const uint8_t u8g_dev_st7565_64128n_sleep_on[] PROGMEM = { |
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
U8G_ESC_CS(1), /* enable chip */ |
|||
0x0ac, /* static indicator off */ |
|||
0x000, /* indicator register set (not sure if this is required) */ |
|||
0x0ae, /* display off */ |
|||
0x0a5, /* all points on */ |
|||
U8G_ESC_CS(1), /* disable chip */ |
|||
U8G_ESC_END /* end of sequence */ |
|||
}; |
|||
|
|||
static const uint8_t u8g_dev_st7565_64128n_sleep_off[] PROGMEM = { |
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
U8G_ESC_CS(1), /* enable chip */ |
|||
0x0a4, /* all points off */ |
|||
0x0af, /* display on */ |
|||
U8G_ESC_DLY(50), /* delay 50 ms */ |
|||
U8G_ESC_CS(1), /* disable chip */ |
|||
U8G_ESC_END /* end of sequence */ |
|||
}; |
|||
|
|||
uint8_t u8g_dev_st7565_64128n_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg) |
|||
{ |
|||
switch(msg) |
|||
{ |
|||
case U8G_DEV_MSG_INIT: |
|||
u8g_InitCom(u8g, dev); |
|||
u8g_WriteEscSeqP(u8g, dev, u8g_dev_st7565_64128n_init_seq); |
|||
break; |
|||
case U8G_DEV_MSG_STOP: |
|||
break; |
|||
case U8G_DEV_MSG_PAGE_NEXT: |
|||
{ |
|||
u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem); |
|||
u8g_WriteEscSeqP(u8g, dev, u8g_dev_st7565_64128n_data_start); |
|||
u8g_WriteByte(u8g, dev, 0x0b0 | pb->p.page); /* select current page (ST7565R) */ |
|||
u8g_SetAddress(u8g, dev, 1); /* data mode */ |
|||
if ( u8g_pb_WriteBuffer(pb, u8g, dev) == 0 ) |
|||
return 0; |
|||
u8g_SetChipSelect(u8g, dev, 0); |
|||
} |
|||
break; |
|||
case U8G_DEV_MSG_CONTRAST: |
|||
u8g_SetChipSelect(u8g, dev, 1); |
|||
u8g_SetAddress(u8g, dev, 0); /* instruction mode */ |
|||
u8g_WriteByte(u8g, dev, 0x081); |
|||
u8g_WriteByte(u8g, dev, (*(uint8_t *)arg) >> 2); |
|||
u8g_SetChipSelect(u8g, dev, 0); |
|||
return 1; |
|||
case U8G_DEV_MSG_SLEEP_ON: |
|||
u8g_WriteEscSeqP(u8g, dev, u8g_dev_st7565_64128n_sleep_on); |
|||
return 1; |
|||
case U8G_DEV_MSG_SLEEP_OFF: |
|||
u8g_WriteEscSeqP(u8g, dev, u8g_dev_st7565_64128n_sleep_off); |
|||
return 1; |
|||
} |
|||
return u8g_dev_pb8v1_base_fn(u8g, dev, msg, arg); |
|||
} |
|||
|
|||
U8G_PB_DEV(u8g_dev_st7565_64128n_sw_spi, WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_st7565_64128n_fn, U8G_COM_SW_SPI); |
|||
U8G_PB_DEV(u8g_dev_st7565_64128n_hw_spi, WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_st7565_64128n_fn, U8G_COM_HW_SPI); |
|||
|
|||
@ -0,0 +1,140 @@ |
|||
/*
|
|||
|
|||
u8g_dev_st7565_dogm128.c |
|||
|
|||
Universal 8bit Graphics Library |
|||
|
|||
Copyright (c) 2011, olikraus@gmail.com |
|||
All rights reserved. |
|||
|
|||
Redistribution and use in source and binary forms, with or without modification, |
|||
are permitted provided that the following conditions are met: |
|||
|
|||
* Redistributions of source code must retain the above copyright notice, this list |
|||
of conditions and the following disclaimer. |
|||
|
|||
* Redistributions in binary form must reproduce the above copyright notice, this |
|||
list of conditions and the following disclaimer in the documentation and/or other |
|||
materials provided with the distribution. |
|||
|
|||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
|||
CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
|||
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
|||
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
|||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
|||
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
|||
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
|||
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
|||
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
|||
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF |
|||
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|||
|
|||
|
|||
*/ |
|||
|
|||
#include "u8g.h" |
|||
|
|||
#define WIDTH 128 |
|||
#define HEIGHT 64 |
|||
#define PAGE_HEIGHT 8 |
|||
|
|||
const uint8_t u8g_dev_st7565_dogm128_init_seq[] PROGMEM = { |
|||
U8G_ESC_CS(0), /* disable chip */ |
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
U8G_ESC_RST(1), /* do reset low pulse with (1*16)+2 milliseconds */ |
|||
U8G_ESC_CS(1), /* enable chip */ |
|||
|
|||
0x040, /* set display start line */ |
|||
0x0a1, /* ADC set to reverse */ |
|||
0x0c0, /* common output mode: set scan direction normal operation */ |
|||
0x0a6, /* display normal (none reverse) */ |
|||
0x0a2, /* LCD bias 1/9 */ |
|||
0x02f, /* all power control circuits on */ |
|||
0x0f8, /* set booster ratio to */ |
|||
0x000, /* 4x */ |
|||
0x027, /* set V0 voltage resistor ratio to large */ |
|||
0x081, /* set contrast */ |
|||
0x018, /* contrast value, EA default: 0x016 */ |
|||
0x0ac, /* indicator */ |
|||
0x000, /* disable */ |
|||
0x0a4, /* normal display (not all on) */ |
|||
0x0af, /* display on */ |
|||
U8G_ESC_DLY(50), /* delay 50 ms */ |
|||
|
|||
U8G_ESC_CS(0), /* disable chip */ |
|||
U8G_ESC_END /* end of sequence */ |
|||
}; |
|||
|
|||
static const uint8_t u8g_dev_st7565_dogm128_data_start[] PROGMEM = { |
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
U8G_ESC_CS(1), /* enable chip */ |
|||
0x010, /* set upper 4 bit of the col adr to 0 */ |
|||
0x000, /* set lower 4 bit of the col adr to 0 */ |
|||
U8G_ESC_END /* end of sequence */ |
|||
}; |
|||
|
|||
static const uint8_t u8g_dev_st7565_dogm128_sleep_on[] PROGMEM = { |
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
U8G_ESC_CS(1), /* enable chip */ |
|||
0x0ac, /* static indicator off */ |
|||
0x000, /* indicator register set (not sure if this is required) */ |
|||
0x0ae, /* display off */ |
|||
0x0a5, /* all points on */ |
|||
U8G_ESC_CS(1), /* disable chip */ |
|||
U8G_ESC_END /* end of sequence */ |
|||
}; |
|||
|
|||
static const uint8_t u8g_dev_st7565_dogm128_sleep_off[] PROGMEM = { |
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
U8G_ESC_CS(1), /* enable chip */ |
|||
0x0a4, /* all points off */ |
|||
0x0af, /* display on */ |
|||
U8G_ESC_DLY(50), /* delay 50 ms */ |
|||
U8G_ESC_CS(1), /* disable chip */ |
|||
U8G_ESC_END /* end of sequence */ |
|||
}; |
|||
|
|||
uint8_t u8g_dev_st7565_dogm128_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg) |
|||
{ |
|||
switch(msg) |
|||
{ |
|||
case U8G_DEV_MSG_INIT: |
|||
u8g_InitCom(u8g, dev); |
|||
u8g_WriteEscSeqP(u8g, dev, u8g_dev_st7565_dogm128_init_seq); |
|||
break; |
|||
case U8G_DEV_MSG_STOP: |
|||
break; |
|||
case U8G_DEV_MSG_PAGE_NEXT: |
|||
{ |
|||
u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem); |
|||
u8g_WriteEscSeqP(u8g, dev, u8g_dev_st7565_dogm128_data_start); |
|||
u8g_WriteByte(u8g, dev, 0x0b0 | pb->p.page); /* select current page (ST7565R) */ |
|||
u8g_SetAddress(u8g, dev, 1); /* data mode */ |
|||
if ( u8g_pb_WriteBuffer(pb, u8g, dev) == 0 ) |
|||
return 0; |
|||
u8g_SetChipSelect(u8g, dev, 0); |
|||
} |
|||
break; |
|||
case U8G_DEV_MSG_CONTRAST: |
|||
u8g_SetChipSelect(u8g, dev, 1); |
|||
u8g_SetAddress(u8g, dev, 0); /* instruction mode */ |
|||
u8g_WriteByte(u8g, dev, 0x081); |
|||
u8g_WriteByte(u8g, dev, (*(uint8_t *)arg) >> 2); |
|||
u8g_SetChipSelect(u8g, dev, 0); |
|||
return 1; |
|||
case U8G_DEV_MSG_SLEEP_ON: |
|||
u8g_WriteEscSeqP(u8g, dev, u8g_dev_st7565_dogm128_sleep_on); |
|||
return 1; |
|||
case U8G_DEV_MSG_SLEEP_OFF: |
|||
u8g_WriteEscSeqP(u8g, dev, u8g_dev_st7565_dogm128_sleep_off); |
|||
return 1; |
|||
} |
|||
return u8g_dev_pb8v1_base_fn(u8g, dev, msg, arg); |
|||
} |
|||
|
|||
U8G_PB_DEV(u8g_dev_st7565_dogm128_sw_spi, WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_st7565_dogm128_fn, U8G_COM_SW_SPI); |
|||
U8G_PB_DEV(u8g_dev_st7565_dogm128_hw_spi, WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_st7565_dogm128_fn, U8G_COM_HW_SPI); |
|||
|
|||
|
|||
@ -0,0 +1,157 @@ |
|||
/*
|
|||
|
|||
u8g_dev_st7565_dogm132.c |
|||
|
|||
Universal 8bit Graphics Library |
|||
|
|||
Copyright (c) 2011, olikraus@gmail.com |
|||
All rights reserved. |
|||
|
|||
Redistribution and use in source and binary forms, with or without modification, |
|||
are permitted provided that the following conditions are met: |
|||
|
|||
* Redistributions of source code must retain the above copyright notice, this list |
|||
of conditions and the following disclaimer. |
|||
|
|||
* Redistributions in binary form must reproduce the above copyright notice, this |
|||
list of conditions and the following disclaimer in the documentation and/or other |
|||
materials provided with the distribution. |
|||
|
|||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
|||
CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
|||
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
|||
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
|||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
|||
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
|||
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
|||
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
|||
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
|||
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF |
|||
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|||
|
|||
|
|||
*/ |
|||
|
|||
#include "u8g.h" |
|||
|
|||
#define WIDTH 132 |
|||
#define HEIGHT 32 |
|||
#define PAGE_HEIGHT 8 |
|||
|
|||
static const uint8_t u8g_dev_st7565_dogm132_init_seq[] PROGMEM = { |
|||
U8G_ESC_CS(0), /* disable chip */ |
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
U8G_ESC_RST(1), /* do reset low pulse with (1*16)+2 milliseconds */ |
|||
U8G_ESC_CS(1), /* enable chip */ |
|||
|
|||
0x040, /* set display start line to 0 */ |
|||
0x0a1, /* ADC set to reverse */ |
|||
0x0c0, /* common output mode */ |
|||
0x0a6, /* display normal, bit val 0: LCD pixel off. */ |
|||
0x0a2, /* LCD bias 1/9 */ |
|||
0x02f, /* all power control circuits on */ |
|||
0x0f8, /* set booster ratio to */ |
|||
0x000, /* 4x */ |
|||
0x023, /* set V0 voltage resistor ratio to large */ |
|||
0x081, /* set contrast */ |
|||
0x01f, /* contrast value, EA default: 0x01f */ |
|||
0x0ac, /* indicator */ |
|||
0x000, /* disable */ |
|||
0x0af, /* display on */ |
|||
|
|||
#ifdef OBSOLETE_DOGM128 |
|||
0x040, /* set display start line */ |
|||
0x0c8, /* set scan direction inverse operation */ |
|||
0x0a2, /* LCD bias 1/9 */ |
|||
0x02f, /* all power control circuits on */ |
|||
0x0f8, /* set booster ratio to */ |
|||
0x000, /* 4x */ |
|||
0x027, /* set V0 voltage resistor ratio to large */ |
|||
0x081, /* set contrast */ |
|||
0x018, /* contrast value, EA default: 0x016 */ |
|||
0x0ac, /* indicator */ |
|||
0x000, /* disable */ |
|||
0x0af, /* display on */ |
|||
#endif |
|||
|
|||
|
|||
U8G_ESC_DLY(100), /* delay 100 ms */ |
|||
0x0a5, /* display all points, ST7565 */ |
|||
U8G_ESC_DLY(100), /* delay 100 ms */ |
|||
U8G_ESC_DLY(100), /* delay 100 ms */ |
|||
0x0a4, /* normal display */ |
|||
U8G_ESC_CS(0), /* disable chip */ |
|||
U8G_ESC_END /* end of sequence */ |
|||
}; |
|||
|
|||
static const uint8_t u8g_dev_st7565_dogm132_data_start[] PROGMEM = { |
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
U8G_ESC_CS(1), /* enable chip */ |
|||
0x010, /* set upper 4 bit of the col adr to 0 */ |
|||
0x000, /* set lower 4 bit of the col adr to 0 */ |
|||
U8G_ESC_END /* end of sequence */ |
|||
}; |
|||
|
|||
static const uint8_t u8g_dev_st7565_dogm132_sleep_on[] PROGMEM = { |
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
U8G_ESC_CS(1), /* enable chip */ |
|||
0x0ac, /* static indicator off */ |
|||
0x000, /* indicator register set (not sure if this is required) */ |
|||
0x0ae, /* display off */ |
|||
0x0a5, /* all points on */ |
|||
U8G_ESC_CS(1), /* disable chip */ |
|||
U8G_ESC_END /* end of sequence */ |
|||
}; |
|||
|
|||
static const uint8_t u8g_dev_st7565_dogm132_sleep_off[] PROGMEM = { |
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
U8G_ESC_CS(1), /* enable chip */ |
|||
0x0a4, /* all points off */ |
|||
0x0af, /* display on */ |
|||
U8G_ESC_DLY(50), /* delay 50 ms */ |
|||
U8G_ESC_CS(1), /* disable chip */ |
|||
U8G_ESC_END /* end of sequence */ |
|||
}; |
|||
|
|||
uint8_t u8g_dev_st7565_dogm132_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg) |
|||
{ |
|||
switch(msg) |
|||
{ |
|||
case U8G_DEV_MSG_INIT: |
|||
u8g_InitCom(u8g, dev); |
|||
u8g_WriteEscSeqP(u8g, dev, u8g_dev_st7565_dogm132_init_seq); |
|||
break; |
|||
case U8G_DEV_MSG_STOP: |
|||
break; |
|||
case U8G_DEV_MSG_PAGE_NEXT: |
|||
{ |
|||
u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem); |
|||
u8g_WriteEscSeqP(u8g, dev, u8g_dev_st7565_dogm132_data_start); |
|||
u8g_WriteByte(u8g, dev, 0x0b0 | pb->p.page); /* select current page (ST7565R) */ |
|||
u8g_SetAddress(u8g, dev, 1); /* data mode */ |
|||
if ( u8g_pb_WriteBuffer(pb, u8g, dev) == 0 ) |
|||
return 0; |
|||
u8g_SetChipSelect(u8g, dev, 0); |
|||
} |
|||
break; |
|||
case U8G_DEV_MSG_CONTRAST: |
|||
u8g_SetChipSelect(u8g, dev, 1); |
|||
u8g_SetAddress(u8g, dev, 0); /* instruction mode */ |
|||
u8g_WriteByte(u8g, dev, 0x081); |
|||
u8g_WriteByte(u8g, dev, (*(uint8_t *)arg) >> 2); |
|||
u8g_SetChipSelect(u8g, dev, 0); |
|||
return 1; |
|||
case U8G_DEV_MSG_SLEEP_ON: |
|||
u8g_WriteEscSeqP(u8g, dev, u8g_dev_st7565_dogm132_sleep_on); |
|||
return 1; |
|||
case U8G_DEV_MSG_SLEEP_OFF: |
|||
u8g_WriteEscSeqP(u8g, dev, u8g_dev_st7565_dogm132_sleep_off); |
|||
return 1; |
|||
} |
|||
return u8g_dev_pb8v1_base_fn(u8g, dev, msg, arg); |
|||
} |
|||
|
|||
U8G_PB_DEV(u8g_dev_st7565_dogm132_sw_spi, WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_st7565_dogm132_fn, U8G_COM_SW_SPI); |
|||
U8G_PB_DEV(u8g_dev_st7565_dogm132_hw_spi, WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_st7565_dogm132_fn, U8G_COM_HW_SPI); |
|||
@ -0,0 +1,157 @@ |
|||
/*
|
|||
|
|||
u8g_dev_st7565_lm6059.c (Adafruit display) |
|||
|
|||
Universal 8bit Graphics Library |
|||
|
|||
Copyright (c) 2011, olikraus@gmail.com |
|||
All rights reserved. |
|||
|
|||
Redistribution and use in source and binary forms, with or without modification, |
|||
are permitted provided that the following conditions are met: |
|||
|
|||
* Redistributions of source code must retain the above copyright notice, this list |
|||
of conditions and the following disclaimer. |
|||
|
|||
* Redistributions in binary form must reproduce the above copyright notice, this |
|||
list of conditions and the following disclaimer in the documentation and/or other |
|||
materials provided with the distribution. |
|||
|
|||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
|||
CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
|||
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
|||
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
|||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
|||
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
|||
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
|||
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
|||
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
|||
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF |
|||
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|||
|
|||
|
|||
*/ |
|||
|
|||
#include "u8g.h" |
|||
|
|||
#define WIDTH 128 |
|||
#define HEIGHT 64 |
|||
#define PAGE_HEIGHT 8 |
|||
|
|||
/* init sequence from https://github.com/adafruit/ST7565-LCD/blob/master/ST7565/ST7565.cpp */ |
|||
static const uint8_t u8g_dev_st7565_lm6059_init_seq[] PROGMEM = { |
|||
U8G_ESC_CS(0), /* disable chip */ |
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
U8G_ESC_CS(1), /* enable chip */ |
|||
U8G_ESC_RST(15), /* do reset low pulse with (15*16)+2 milliseconds (=maximum delay)*/ |
|||
|
|||
0x0a3, /* 0x0a2: LCD bias 1/9 (suggested for the LM6063), 0x0a3: Used by Adafruit, 0x0a2 does not work */ |
|||
/* the LM6059 vs LM6063, ADC and SHL have inverted settings */ |
|||
0x0a0, /* 0x0a1: ADC set to normal (suggested for the LM6059), 0x0a0: Used by Adafruit -> normal mode */ |
|||
0x0c8, /* common output mode: set scan direction normal operation/SHL Select, 0x0c0 --> SHL = 0, normal, 0x0c8 --> SHL = 1 */ |
|||
0x060, /* set display start line */ |
|||
|
|||
0x028 | 0x04, /* power control: turn on voltage converter */ |
|||
U8G_ESC_DLY(50), /* delay 50 ms */ |
|||
|
|||
0x028 | 0x06, /* power control: turn on voltage regulator */ |
|||
U8G_ESC_DLY(50), /* delay 50 ms */ |
|||
|
|||
0x028 | 0x07, /* power control: turn on voltage follower */ |
|||
U8G_ESC_DLY(50), /* delay 50 ms */ |
|||
|
|||
0x026, /* set V0 voltage resistor ratio to 6 (Adafruit Value, no info from LM6063 Manual) */ |
|||
|
|||
0x0a6, /* display normal, bit val 0: LCD pixel off. */ |
|||
|
|||
0x081, /* set contrast */ |
|||
0x018, /* contrast value*/ |
|||
|
|||
/*0x0ac,*/ /* indicator */ |
|||
/*0x000,*/ /* disable */ |
|||
|
|||
0x0af, /* display on */ |
|||
|
|||
U8G_ESC_DLY(100), /* delay 100 ms */ |
|||
0x0a5, /* display all points, ST7565 */ |
|||
U8G_ESC_DLY(100), /* delay 100 ms */ |
|||
U8G_ESC_DLY(100), /* delay 100 ms */ |
|||
0x0a4, /* normal display */ |
|||
U8G_ESC_CS(0), /* disable chip */ |
|||
U8G_ESC_END /* end of sequence */ |
|||
}; |
|||
|
|||
static const uint8_t u8g_dev_st7565_lm6059_data_start[] PROGMEM = { |
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
U8G_ESC_CS(1), /* enable chip */ |
|||
0x010, /* set upper 4 bit of the col adr to 0 */ |
|||
0x001, /* set lower 4 bit of the col adr */ |
|||
U8G_ESC_END /* end of sequence */ |
|||
}; |
|||
|
|||
static const uint8_t u8g_dev_st7565_lm6059_sleep_on[] PROGMEM = { |
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
U8G_ESC_CS(1), /* enable chip */ |
|||
0x0ac, /* static indicator off */ |
|||
0x000, /* indicator register set (not sure if this is required) */ |
|||
0x0ae, /* display off */ |
|||
0x0a5, /* all points on */ |
|||
U8G_ESC_CS(1), /* disable chip */ |
|||
U8G_ESC_END /* end of sequence */ |
|||
}; |
|||
|
|||
static const uint8_t u8g_dev_st7565_lm6059_sleep_off[] PROGMEM = { |
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
U8G_ESC_CS(1), /* enable chip */ |
|||
0x0a4, /* all points off */ |
|||
0x0af, /* display on */ |
|||
U8G_ESC_DLY(50), /* delay 50 ms */ |
|||
U8G_ESC_CS(1), /* disable chip */ |
|||
U8G_ESC_END /* end of sequence */ |
|||
}; |
|||
|
|||
|
|||
uint8_t u8g_dev_st7565_lm6059_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg) |
|||
{ |
|||
switch(msg) |
|||
{ |
|||
case U8G_DEV_MSG_INIT: |
|||
u8g_InitCom(u8g, dev); |
|||
u8g_WriteEscSeqP(u8g, dev, u8g_dev_st7565_lm6059_init_seq); |
|||
break; |
|||
case U8G_DEV_MSG_STOP: |
|||
break; |
|||
case U8G_DEV_MSG_PAGE_NEXT: |
|||
{ |
|||
u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem); |
|||
u8g_WriteEscSeqP(u8g, dev, u8g_dev_st7565_lm6059_data_start); |
|||
u8g_WriteByte(u8g, dev, 0x0b0 | pb->p.page); /* select current page (ST7565R) */ |
|||
u8g_SetAddress(u8g, dev, 1); /* data mode */ |
|||
if ( u8g_pb_WriteBuffer(pb, u8g, dev) == 0 ) |
|||
return 0; |
|||
u8g_SetChipSelect(u8g, dev, 0); |
|||
} |
|||
break; |
|||
case U8G_DEV_MSG_CONTRAST: |
|||
u8g_SetChipSelect(u8g, dev, 1); |
|||
u8g_SetAddress(u8g, dev, 0); /* instruction mode */ |
|||
u8g_WriteByte(u8g, dev, 0x081); |
|||
u8g_WriteByte(u8g, dev, (*(uint8_t *)arg) >> 2); |
|||
u8g_SetChipSelect(u8g, dev, 0); |
|||
return 1; |
|||
case U8G_DEV_MSG_SLEEP_ON: |
|||
u8g_WriteEscSeqP(u8g, dev, u8g_dev_st7565_lm6059_sleep_on); |
|||
return 1; |
|||
case U8G_DEV_MSG_SLEEP_OFF: |
|||
u8g_WriteEscSeqP(u8g, dev, u8g_dev_st7565_lm6059_sleep_off); |
|||
return 1; |
|||
} |
|||
return u8g_dev_pb8v1_base_fn(u8g, dev, msg, arg); |
|||
} |
|||
|
|||
U8G_PB_DEV(u8g_dev_st7565_lm6059_sw_spi, WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_st7565_lm6059_fn, U8G_COM_SW_SPI); |
|||
U8G_PB_DEV(u8g_dev_st7565_lm6059_hw_spi, WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_st7565_lm6059_fn, U8G_COM_HW_SPI); |
|||
|
|||
|
|||
@ -0,0 +1,188 @@ |
|||
/*
|
|||
|
|||
u8g_dev_st7565_lm6063.c |
|||
|
|||
Universal 8bit Graphics Library |
|||
|
|||
Copyright (c) 2011, olikraus@gmail.com |
|||
All rights reserved. |
|||
|
|||
Redistribution and use in source and binary forms, with or without modification, |
|||
are permitted provided that the following conditions are met: |
|||
|
|||
* Redistributions of source code must retain the above copyright notice, this list |
|||
of conditions and the following disclaimer. |
|||
|
|||
* Redistributions in binary form must reproduce the above copyright notice, this |
|||
list of conditions and the following disclaimer in the documentation and/or other |
|||
materials provided with the distribution. |
|||
|
|||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
|||
CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
|||
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
|||
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
|||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
|||
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
|||
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
|||
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
|||
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
|||
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF |
|||
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|||
|
|||
|
|||
*/ |
|||
|
|||
#include "u8g.h" |
|||
|
|||
#define WIDTH 128 |
|||
#define HEIGHT 64 |
|||
#define PAGE_HEIGHT 8 |
|||
|
|||
#ifdef OLD_ADAFRUIT_CODE |
|||
static const uint8_t OLD_u8g_dev_st7565_lm6063_init_seq[] PROGMEM = { |
|||
U8G_ESC_CS(0), /* disable chip */ |
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
U8G_ESC_RST(1), /* do reset low pulse with (1*16)+2 milliseconds */ |
|||
U8G_ESC_CS(1), /* enable chip */ |
|||
|
|||
0x040, /* set display start line */ |
|||
0x0a1, /* ADC set to reverse */ |
|||
0x0c8, /* common output mode: set scan direction normal operation/SHL Select / 17 Jan: seems to be a bug, must be 0x0c0 */ |
|||
0x0a6, /* display normal, bit val 0: LCD pixel off. */ |
|||
0x0a2, /* LCD bias 1/9 */ |
|||
0x02f, /* all power control circuits on */ |
|||
/*0x0f8,*/ /* set booster ratio to */ |
|||
/*0x000, */ /* 4x */ |
|||
/*0x027,*/ /* set V0 voltage resistor ratio to large */ |
|||
0x081, /* set contrast */ |
|||
0x018, /* contrast value*/ |
|||
0x0ac, /* indicator */ |
|||
0x000, /* disable */ |
|||
0x0af, /* display on */ |
|||
|
|||
U8G_ESC_DLY(100), /* delay 100 ms */ |
|||
0x0a5, /* display all points, ST7565 */ |
|||
U8G_ESC_DLY(100), /* delay 100 ms */ |
|||
U8G_ESC_DLY(100), /* delay 100 ms */ |
|||
0x0a4, /* normal display */ |
|||
U8G_ESC_CS(0), /* disable chip */ |
|||
U8G_ESC_END /* end of sequence */ |
|||
}; |
|||
#endif |
|||
|
|||
/* init sequence from https://github.com/adafruit/ST7565-LCD/blob/master/ST7565/ST7565.cpp */ |
|||
static const uint8_t u8g_dev_st7565_lm6063_init_seq[] PROGMEM = { |
|||
U8G_ESC_CS(0), /* disable chip */ |
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
U8G_ESC_CS(1), /* enable chip */ |
|||
U8G_ESC_RST(15), /* do reset low pulse with (15*16)+2 milliseconds (=maximum delay)*/ |
|||
|
|||
0x0a3, /* 0x0a2: LCD bias 1/9 (suggested for the LM6063), 0x0a3: Used by Adafruit */ |
|||
0x0a1, /* 0x0a1: ADC set to reverse (suggested for the LM6063), 0x0a0: Used by Adafruit -> normal mode */ |
|||
0x0c0, /* common output mode: set scan direction normal operation/SHL Select, 0x0c0 --> SHL = 0, normal, 0x0c8 --> SHL = 1 */ |
|||
0x040, /* set display start line */ |
|||
|
|||
0x028 | 0x04, /* power control: turn on voltage converter */ |
|||
U8G_ESC_DLY(50), /* delay 50 ms */ |
|||
|
|||
0x028 | 0x06, /* power control: turn on voltage regulator */ |
|||
U8G_ESC_DLY(50), /* delay 50 ms */ |
|||
|
|||
0x028 | 0x07, /* power control: turn on voltage follower */ |
|||
U8G_ESC_DLY(50), /* delay 50 ms */ |
|||
|
|||
0x026, /* set V0 voltage resistor ratio to 6 (Adafruit Value, no info from LM6063 Manual) */ |
|||
|
|||
0x0a6, /* display normal, bit val 0: LCD pixel off. */ |
|||
|
|||
0x081, /* set contrast */ |
|||
0x018, /* contrast value*/ |
|||
|
|||
/*0x0ac,*/ /* indicator */ |
|||
/*0x000,*/ /* disable */ |
|||
|
|||
0x0af, /* display on */ |
|||
|
|||
U8G_ESC_DLY(100), /* delay 100 ms */ |
|||
0x0a5, /* display all points, ST7565 */ |
|||
U8G_ESC_DLY(100), /* delay 100 ms */ |
|||
U8G_ESC_DLY(100), /* delay 100 ms */ |
|||
0x0a4, /* normal display */ |
|||
U8G_ESC_CS(0), /* disable chip */ |
|||
U8G_ESC_END /* end of sequence */ |
|||
}; |
|||
|
|||
static const uint8_t u8g_dev_st7565_lm6063_data_start[] PROGMEM = { |
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
U8G_ESC_CS(1), /* enable chip */ |
|||
0x010, /* set upper 4 bit of the col adr to 0 */ |
|||
0x000, /* set lower 4 bit of the col adr to 0 */ |
|||
U8G_ESC_END /* end of sequence */ |
|||
}; |
|||
|
|||
static const uint8_t u8g_dev_st7565_st7565_sleep_on[] PROGMEM = { |
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
U8G_ESC_CS(1), /* enable chip */ |
|||
0x0ac, /* static indicator off */ |
|||
0x000, /* indicator register set (not sure if this is required) */ |
|||
0x0ae, /* display off */ |
|||
0x0a5, /* all points on */ |
|||
U8G_ESC_CS(1), /* disable chip */ |
|||
U8G_ESC_END /* end of sequence */ |
|||
}; |
|||
|
|||
static const uint8_t u8g_dev_st7565_st7565_sleep_off[] PROGMEM = { |
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
U8G_ESC_CS(1), /* enable chip */ |
|||
0x0a4, /* all points off */ |
|||
0x0af, /* display on */ |
|||
U8G_ESC_DLY(50), /* delay 50 ms */ |
|||
U8G_ESC_CS(1), /* disable chip */ |
|||
U8G_ESC_END /* end of sequence */ |
|||
}; |
|||
|
|||
|
|||
uint8_t u8g_dev_st7565_lm6063_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg) |
|||
{ |
|||
switch(msg) |
|||
{ |
|||
case U8G_DEV_MSG_INIT: |
|||
u8g_InitCom(u8g, dev); |
|||
u8g_WriteEscSeqP(u8g, dev, u8g_dev_st7565_lm6063_init_seq); |
|||
break; |
|||
case U8G_DEV_MSG_STOP: |
|||
break; |
|||
case U8G_DEV_MSG_PAGE_NEXT: |
|||
{ |
|||
u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem); |
|||
u8g_WriteEscSeqP(u8g, dev, u8g_dev_st7565_lm6063_data_start); |
|||
u8g_WriteByte(u8g, dev, 0x0b0 | pb->p.page); /* select current page (ST7565R) */ |
|||
u8g_SetAddress(u8g, dev, 1); /* data mode */ |
|||
if ( u8g_pb_WriteBuffer(pb, u8g, dev) == 0 ) |
|||
return 0; |
|||
u8g_SetChipSelect(u8g, dev, 0); |
|||
} |
|||
break; |
|||
case U8G_DEV_MSG_CONTRAST: |
|||
u8g_SetChipSelect(u8g, dev, 1); |
|||
u8g_SetAddress(u8g, dev, 0); /* instruction mode */ |
|||
u8g_WriteByte(u8g, dev, 0x081); |
|||
u8g_WriteByte(u8g, dev, (*(uint8_t *)arg) >> 2); |
|||
u8g_SetChipSelect(u8g, dev, 0); |
|||
return 1; |
|||
case U8G_DEV_MSG_SLEEP_ON: |
|||
u8g_WriteEscSeqP(u8g, dev, u8g_dev_st7565_st7565_sleep_on); |
|||
return 1; |
|||
case U8G_DEV_MSG_SLEEP_OFF: |
|||
u8g_WriteEscSeqP(u8g, dev, u8g_dev_st7565_st7565_sleep_off); |
|||
return 1; |
|||
} |
|||
return u8g_dev_pb8v1_base_fn(u8g, dev, msg, arg); |
|||
} |
|||
|
|||
U8G_PB_DEV(u8g_dev_st7565_lm6063_sw_spi, WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_st7565_lm6063_fn, U8G_COM_SW_SPI); |
|||
U8G_PB_DEV(u8g_dev_st7565_lm6063_hw_spi, WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_st7565_lm6063_fn, U8G_COM_HW_SPI); |
|||
|
|||
|
|||
@ -0,0 +1,143 @@ |
|||
/*
|
|||
|
|||
u8g_dev_st7565_nhd_c12832.c |
|||
|
|||
Universal 8bit Graphics Library |
|||
|
|||
Copyright (c) 2011, olikraus@gmail.com |
|||
All rights reserved. |
|||
|
|||
Redistribution and use in source and binary forms, with or without modification, |
|||
are permitted provided that the following conditions are met: |
|||
|
|||
* Redistributions of source code must retain the above copyright notice, this list |
|||
of conditions and the following disclaimer. |
|||
|
|||
* Redistributions in binary form must reproduce the above copyright notice, this |
|||
list of conditions and the following disclaimer in the documentation and/or other |
|||
materials provided with the distribution. |
|||
|
|||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
|||
CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
|||
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
|||
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
|||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
|||
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
|||
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
|||
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
|||
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
|||
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF |
|||
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|||
|
|||
|
|||
*/ |
|||
|
|||
#include "u8g.h" |
|||
|
|||
#define WIDTH 128 |
|||
#define HEIGHT 32 |
|||
#define PAGE_HEIGHT 8 |
|||
|
|||
static const uint8_t u8g_dev_st7565_c12832_init_seq[] PROGMEM = { |
|||
U8G_ESC_CS(0), /* disable chip */ |
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
U8G_ESC_RST(1), /* do reset low pulse with (1*16)+2 milliseconds */ |
|||
U8G_ESC_CS(1), /* enable chip */ |
|||
|
|||
0x040, /* set display start line to 0 */ |
|||
0x0a0, /* ADC set, values: a0=normal, a1=reverse */ |
|||
0x0c8, /* common output mode: c0=normal, c8=reverse */ |
|||
0x0a6, /* display normal, bit val 0: LCD pixel off. */ |
|||
0x0a2, /* LCD bias 1/9 */ |
|||
0x02f, /* all power control circuits on */ |
|||
0x0f8, /* set booster ratio to */ |
|||
0x000, /* 4x */ |
|||
0x023, /* set V0 voltage resistor ratio to large */ |
|||
0x081, /* set contrast */ |
|||
0x00a, /* contrast value */ |
|||
0x0ac, /* indicator */ |
|||
0x000, /* disable */ |
|||
0x0af, /* display on */ |
|||
|
|||
|
|||
U8G_ESC_DLY(100), /* delay 100 ms */ |
|||
0x0a5, /* display all points, ST7565 */ |
|||
U8G_ESC_DLY(100), /* delay 100 ms */ |
|||
U8G_ESC_DLY(100), /* delay 100 ms */ |
|||
0x0a4, /* normal display */ |
|||
U8G_ESC_CS(0), /* disable chip */ |
|||
U8G_ESC_END /* end of sequence */ |
|||
}; |
|||
|
|||
static const uint8_t u8g_dev_st7565_c12832_data_start[] PROGMEM = { |
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
U8G_ESC_CS(1), /* enable chip */ |
|||
0x010, /* set upper 4 bit of the col adr to 0 */ |
|||
0x000, /* set lower 4 bit of the col adr to 0 */ |
|||
U8G_ESC_END /* end of sequence */ |
|||
}; |
|||
|
|||
static const uint8_t u8g_dev_st7565_c12832_sleep_on[] PROGMEM = { |
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
U8G_ESC_CS(1), /* enable chip */ |
|||
0x0ac, /* static indicator off */ |
|||
0x000, /* indicator register set (not sure if this is required) */ |
|||
0x0ae, /* display off */ |
|||
0x0a5, /* all points on */ |
|||
U8G_ESC_CS(1), /* disable chip */ |
|||
U8G_ESC_END /* end of sequence */ |
|||
}; |
|||
|
|||
static const uint8_t u8g_dev_st7565_c12832_sleep_off[] PROGMEM = { |
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
U8G_ESC_CS(1), /* enable chip */ |
|||
0x0a4, /* all points off */ |
|||
0x0af, /* display on */ |
|||
U8G_ESC_DLY(50), /* delay 50 ms */ |
|||
U8G_ESC_CS(1), /* disable chip */ |
|||
U8G_ESC_END /* end of sequence */ |
|||
}; |
|||
|
|||
uint8_t u8g_dev_st7565_c12832_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg) |
|||
{ |
|||
switch(msg) |
|||
{ |
|||
case U8G_DEV_MSG_INIT: |
|||
u8g_InitCom(u8g, dev); |
|||
u8g_WriteEscSeqP(u8g, dev, u8g_dev_st7565_c12832_init_seq); |
|||
break; |
|||
case U8G_DEV_MSG_STOP: |
|||
break; |
|||
case U8G_DEV_MSG_PAGE_NEXT: |
|||
{ |
|||
u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem); |
|||
u8g_WriteEscSeqP(u8g, dev, u8g_dev_st7565_c12832_data_start); |
|||
u8g_WriteByte(u8g, dev, 0x0b0 | pb->p.page); /* select current page (ST7565R) */ |
|||
u8g_SetAddress(u8g, dev, 1); /* data mode */ |
|||
if ( u8g_pb_WriteBuffer(pb, u8g, dev) == 0 ) |
|||
return 0; |
|||
u8g_SetChipSelect(u8g, dev, 0); |
|||
} |
|||
break; |
|||
case U8G_DEV_MSG_CONTRAST: |
|||
u8g_SetChipSelect(u8g, dev, 1); |
|||
u8g_SetAddress(u8g, dev, 0); /* instruction mode */ |
|||
u8g_WriteByte(u8g, dev, 0x081); |
|||
u8g_WriteByte(u8g, dev, (*(uint8_t *)arg) >> 2); |
|||
u8g_SetChipSelect(u8g, dev, 0); |
|||
return 1; |
|||
case U8G_DEV_MSG_SLEEP_ON: |
|||
u8g_WriteEscSeqP(u8g, dev, u8g_dev_st7565_c12832_sleep_on); |
|||
return 1; |
|||
case U8G_DEV_MSG_SLEEP_OFF: |
|||
u8g_WriteEscSeqP(u8g, dev, u8g_dev_st7565_c12832_sleep_off); |
|||
return 1; |
|||
} |
|||
return u8g_dev_pb8v1_base_fn(u8g, dev, msg, arg); |
|||
} |
|||
|
|||
U8G_PB_DEV(u8g_dev_st7565_nhd_c12832_sw_spi, WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_st7565_c12832_fn, U8G_COM_SW_SPI); |
|||
U8G_PB_DEV(u8g_dev_st7565_nhd_c12832_hw_spi, WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_st7565_c12832_fn, U8G_COM_HW_SPI); |
|||
U8G_PB_DEV(u8g_dev_st7565_nhd_c12832_parallel, WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_st7565_c12832_fn, U8G_COM_PARALLEL); |
|||
@ -0,0 +1,145 @@ |
|||
/*
|
|||
|
|||
u8g_dev_st7565_nhd_c12864.c |
|||
|
|||
Support for the NHD-C12864A1Z-FSB-FBW (Newhaven Display) |
|||
|
|||
Universal 8bit Graphics Library |
|||
|
|||
Copyright (c) 2012, olikraus@gmail.com |
|||
All rights reserved. |
|||
|
|||
Redistribution and use in source and binary forms, with or without modification, |
|||
are permitted provided that the following conditions are met: |
|||
|
|||
* Redistributions of source code must retain the above copyright notice, this list |
|||
of conditions and the following disclaimer. |
|||
|
|||
* Redistributions in binary form must reproduce the above copyright notice, this |
|||
list of conditions and the following disclaimer in the documentation and/or other |
|||
materials provided with the distribution. |
|||
|
|||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
|||
CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
|||
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
|||
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
|||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
|||
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
|||
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
|||
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
|||
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
|||
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF |
|||
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|||
|
|||
|
|||
*/ |
|||
|
|||
#include "u8g.h" |
|||
|
|||
#define WIDTH 128 |
|||
#define HEIGHT 64 |
|||
#define PAGE_HEIGHT 8 |
|||
|
|||
const uint8_t u8g_dev_st7565_nhd_c12864_init_seq[] PROGMEM = { |
|||
U8G_ESC_CS(0), /* disable chip */ |
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
U8G_ESC_RST(10), /* do reset low pulse with (10*16)+2 milliseconds */ |
|||
U8G_ESC_CS(1), /* enable chip */ |
|||
|
|||
0x040, /* set display start line */ |
|||
0x0a1, /* ADC set to reverse */ |
|||
0x0c0, /* common output mode: set scan direction normal operation */ |
|||
0x0a6, /* display normal, bit val 0: LCD pixel off. */ |
|||
0x0a2, /* LCD bias 1/9 */ |
|||
0x02f, /* all power control circuits on */ |
|||
0x0f8, /* set booster ratio to */ |
|||
0x000, /* 4x */ |
|||
0x027, /* set V0 voltage resistor ratio to large */ |
|||
0x081, /* set contrast */ |
|||
0x008, /* contrast: 0x008 is a good value for NHD C12864, Nov 2012: User reports that 0x1a is much better */ |
|||
0x0ac, /* indicator */ |
|||
0x000, /* disable */ |
|||
0x0af, /* display on */ |
|||
|
|||
U8G_ESC_DLY(100), /* delay 100 ms */ |
|||
0x0a5, /* display all points, ST7565 */ |
|||
U8G_ESC_DLY(100), /* delay 100 ms */ |
|||
U8G_ESC_DLY(100), /* delay 100 ms */ |
|||
0x0a4, /* normal display */ |
|||
U8G_ESC_CS(0), /* disable chip */ |
|||
U8G_ESC_END /* end of sequence */ |
|||
}; |
|||
|
|||
static const uint8_t u8g_dev_st7565_nhd_c12864_data_start[] PROGMEM = { |
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
U8G_ESC_CS(1), /* enable chip */ |
|||
0x010, /* set upper 4 bit of the col adr to 0 */ |
|||
0x004, /* set lower 4 bit of the col adr to 4 (NHD C12864) */ |
|||
U8G_ESC_END /* end of sequence */ |
|||
}; |
|||
|
|||
static const uint8_t u8g_dev_st7565_c12864_sleep_on[] PROGMEM = { |
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
U8G_ESC_CS(1), /* enable chip */ |
|||
0x0ac, /* static indicator off */ |
|||
0x000, /* indicator register set (not sure if this is required) */ |
|||
0x0ae, /* display off */ |
|||
0x0a5, /* all points on */ |
|||
U8G_ESC_CS(1), /* disable chip */ |
|||
U8G_ESC_END /* end of sequence */ |
|||
}; |
|||
|
|||
static const uint8_t u8g_dev_st7565_c12864_sleep_off[] PROGMEM = { |
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
U8G_ESC_CS(1), /* enable chip */ |
|||
0x0a4, /* all points off */ |
|||
0x0af, /* display on */ |
|||
U8G_ESC_DLY(50), /* delay 50 ms */ |
|||
U8G_ESC_CS(1), /* disable chip */ |
|||
U8G_ESC_END /* end of sequence */ |
|||
}; |
|||
|
|||
uint8_t u8g_dev_st7565_nhd_c12864_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg) |
|||
{ |
|||
switch(msg) |
|||
{ |
|||
case U8G_DEV_MSG_INIT: |
|||
u8g_InitCom(u8g, dev); |
|||
u8g_WriteEscSeqP(u8g, dev, u8g_dev_st7565_nhd_c12864_init_seq); |
|||
break; |
|||
case U8G_DEV_MSG_STOP: |
|||
break; |
|||
case U8G_DEV_MSG_PAGE_NEXT: |
|||
{ |
|||
u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem); |
|||
u8g_WriteEscSeqP(u8g, dev, u8g_dev_st7565_nhd_c12864_data_start); |
|||
u8g_WriteByte(u8g, dev, 0x0b0 | pb->p.page); /* select current page (ST7565R) */ |
|||
u8g_SetAddress(u8g, dev, 1); /* data mode */ |
|||
if ( u8g_pb_WriteBuffer(pb, u8g, dev) == 0 ) |
|||
return 0; |
|||
u8g_SetChipSelect(u8g, dev, 0); |
|||
} |
|||
break; |
|||
case U8G_DEV_MSG_CONTRAST: |
|||
u8g_SetChipSelect(u8g, dev, 1); |
|||
u8g_SetAddress(u8g, dev, 0); /* instruction mode */ |
|||
u8g_WriteByte(u8g, dev, 0x081); |
|||
u8g_WriteByte(u8g, dev, (*(uint8_t *)arg) >> 2); |
|||
u8g_SetChipSelect(u8g, dev, 0); |
|||
return 1; |
|||
case U8G_DEV_MSG_SLEEP_ON: |
|||
u8g_WriteEscSeqP(u8g, dev, u8g_dev_st7565_c12864_sleep_on); |
|||
return 1; |
|||
case U8G_DEV_MSG_SLEEP_OFF: |
|||
u8g_WriteEscSeqP(u8g, dev, u8g_dev_st7565_c12864_sleep_off); |
|||
return 1; |
|||
} |
|||
return u8g_dev_pb8v1_base_fn(u8g, dev, msg, arg); |
|||
} |
|||
|
|||
U8G_PB_DEV(u8g_dev_st7565_nhd_c12864_sw_spi, WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_st7565_nhd_c12864_fn, U8G_COM_SW_SPI); |
|||
U8G_PB_DEV(u8g_dev_st7565_nhd_c12864_hw_spi, WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_st7565_nhd_c12864_fn, U8G_COM_HW_SPI); |
|||
|
|||
|
|||
@ -0,0 +1,420 @@ |
|||
/*
|
|||
|
|||
u8g_dev_st7687_c144mvgd.c (1.44" TFT) |
|||
|
|||
Status: Started, but not finished |
|||
|
|||
Universal 8bit Graphics Library |
|||
|
|||
Copyright (c) 2012, olikraus@gmail.com |
|||
All rights reserved. |
|||
|
|||
Redistribution and use in source and binary forms, with or without modification, |
|||
are permitted provided that the following conditions are met: |
|||
|
|||
* Redistributions of source code must retain the above copyright notice, this list |
|||
of conditions and the following disclaimer. |
|||
|
|||
* Redistributions in binary form must reproduce the above copyright notice, this |
|||
list of conditions and the following disclaimer in the documentation and/or other |
|||
materials provided with the distribution. |
|||
|
|||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
|||
CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
|||
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
|||
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
|||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
|||
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
|||
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
|||
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
|||
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
|||
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF |
|||
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|||
|
|||
|
|||
*/ |
|||
|
|||
#include "u8g.h" |
|||
|
|||
#define WIDTH 128 |
|||
#define HEIGHT 128 |
|||
#define PAGE_HEIGHT 8 |
|||
|
|||
|
|||
#ifdef FIRST_VERSION |
|||
/*
|
|||
see also: read.pudn.com/downloads115/sourcecode/app/484503/LCM_Display.c__.htm |
|||
http://en.pudn.com/downloads115/sourcecode/app/detail484503_en.html
|
|||
*/ |
|||
|
|||
static const uint8_t u8g_dev_st7687_c144mvgd_init_seq[] PROGMEM = { |
|||
U8G_ESC_CS(0), /* disable chip */ |
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
U8G_ESC_CS(1), /* enable chip */ |
|||
U8G_ESC_RST(15), /* do reset low pulse with (15*16)+2 milliseconds (=maximum delay)*/ |
|||
|
|||
0x001, /* A0=0, SW reset */ |
|||
U8G_ESC_DLY(200), /* delay 200 ms */ |
|||
|
|||
0x0d7, /* EEPROM data auto re-load control */ |
|||
U8G_ESC_ADR(1), /* data mode */ |
|||
0x09f, /* ARD = 1 */ |
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
U8G_ESC_DLY(100), /* delay 100 ms */ |
|||
|
|||
0x0e0, /* EEPROM control in */ |
|||
U8G_ESC_ADR(1), /* data mode */ |
|||
0x000, /* */ |
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
U8G_ESC_DLY(100), /* delay 100 ms */ |
|||
|
|||
#ifdef NOT_REQUIRED |
|||
0x0fa, /* EEPROM function selection 8.1.66 */ |
|||
U8G_ESC_ADR(1), /* data mode */ |
|||
0x000, /* */ |
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
U8G_ESC_DLY(100), /* delay 100 ms */ |
|||
#endif |
|||
|
|||
0x0e3, /* Read from EEPROM, 8.1.55 */ |
|||
U8G_ESC_DLY(100), /* delay 100 ms */ |
|||
|
|||
0x0e1, /* EEPROM control out, 8.1.53 */ |
|||
U8G_ESC_DLY(100), /* delay 100 ms */ |
|||
|
|||
//0x028, /* display off */
|
|||
0x011, /* Sleep out & booster on */ |
|||
U8G_ESC_DLY(100), /* delay 100 ms */ |
|||
|
|||
0x0c0, /* Vop setting, 8.1.42 */ |
|||
U8G_ESC_ADR(1), /* data mode */ |
|||
0x000, /* */ |
|||
0x001, /* 3.6 + 256*0.04 = 13.84 Volt */ |
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
U8G_ESC_DLY(100), /* delay 100 ms */ |
|||
|
|||
0x0c3, /* Bias selection, 8.1.45 */ |
|||
U8G_ESC_ADR(1), /* data mode */ |
|||
0x003, |
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
|
|||
0x0c4, /* Booster setting 8.1.46 */ |
|||
U8G_ESC_ADR(1), /* data mode */ |
|||
0x007, |
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
|
|||
0x0c5, /* ??? */ |
|||
U8G_ESC_ADR(1), /* data mode */ |
|||
0x001, |
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
|
|||
0x0cb, /* FV3 with Booster x2 control, 8.1.47 */ |
|||
U8G_ESC_ADR(1), /* data mode */ |
|||
0x001, |
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
|
|||
0x036, /* Memory data access control, 8.1.28 */ |
|||
U8G_ESC_ADR(1), /* data mode */ |
|||
0x080, |
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
|
|||
0x0b5, /* N-line control, 8.1.37 */ |
|||
U8G_ESC_ADR(1), /* data mode */ |
|||
0x089, |
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
|
|||
|
|||
0x0d0, /* Analog circuit setting, 8.1.49 */ |
|||
U8G_ESC_ADR(1), /* data mode */ |
|||
0x01d, |
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
|
|||
0x0b7, /* Com/Seg Scan Direction, 8.1.38 */ |
|||
U8G_ESC_ADR(1), /* data mode */ |
|||
0x040, |
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
|
|||
0x025, /* Write contrast, 8.1.17 */ |
|||
U8G_ESC_ADR(1), /* data mode */ |
|||
0x03f, |
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
|
|||
0x03a, /* Interface pixel format, 8.1.32 */ |
|||
U8G_ESC_ADR(1), /* data mode */ |
|||
0x004, /* 3: 12 bit per pixel Type A, 4: 12 bit Type B, 5: 16bit per pixel */ |
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
|
|||
0x0b0, /* Display Duty setting, 8.1.34 */ |
|||
U8G_ESC_ADR(1), /* data mode */ |
|||
0x07f, |
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
|
|||
0x0f0, /* Frame Freq. in Temp range A,B,C and D, 8.1.59 */ |
|||
U8G_ESC_ADR(1), /* data mode */ |
|||
0x007, |
|||
0x00c, |
|||
0x00c, |
|||
0x015, |
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
|
|||
0x0f9, /* Frame RGB Value, 8.1.65 */ |
|||
U8G_ESC_ADR(1), /* data mode */ |
|||
0x000, |
|||
0x005, |
|||
0x008, |
|||
0x00a, |
|||
0x00c, |
|||
0x00e, |
|||
0x010, |
|||
0x011, |
|||
0x012, |
|||
0x013, |
|||
0x014, |
|||
0x015, |
|||
0x016, |
|||
0x018, |
|||
0x01a, |
|||
0x01b, |
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
|
|||
0x0f9, /* Frame RGB Value, 8.1.65 */ |
|||
U8G_ESC_ADR(1), /* data mode */ |
|||
0x000, |
|||
0x000, |
|||
0x000, |
|||
0x000, |
|||
0x033, |
|||
0x055, |
|||
0x055, |
|||
0x055, |
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
|
|||
0x029, /* display on */ |
|||
|
|||
U8G_ESC_CS(0), /* disable chip */ |
|||
U8G_ESC_END /* end of sequence */ |
|||
|
|||
}; |
|||
|
|||
#else |
|||
|
|||
/*
|
|||
http://www.waitingforfriday.com/images/e/e3/FTM144D01N_test.zip
|
|||
*/ |
|||
|
|||
static const uint8_t u8g_dev_st7687_c144mvgd_init_seq[] PROGMEM = { |
|||
U8G_ESC_CS(0), /* disable chip */ |
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
U8G_ESC_CS(1), /* enable chip */ |
|||
U8G_ESC_RST(15), /* do reset low pulse with (15*16)+2 milliseconds (=maximum delay)*/ |
|||
|
|||
0x011, /* Sleep out & booster on */ |
|||
U8G_ESC_DLY(5), /* delay 5 ms */ |
|||
|
|||
0x03a, /* Interface pixel format, 8.1.32 */ |
|||
U8G_ESC_ADR(1), /* data mode */ |
|||
0x004, /* 3: 12 bit per pixel Type A, 4: 12 bit Type B, 5: 16bit per pixel */ |
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
|
|||
|
|||
0x026, /* SET_GAMMA_CURVE */ |
|||
U8G_ESC_ADR(1), /* data mode */ |
|||
0x004, |
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
|
|||
0x0f2, /* GAM_R_SEL */ |
|||
U8G_ESC_ADR(1), /* data mode */ |
|||
0x001, /* enable gamma adj */ |
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
|
|||
|
|||
0x0e0, /* POSITIVE_GAMMA_CORRECT */ |
|||
U8G_ESC_ADR(1), /* data mode */ |
|||
0x3f, |
|||
0x25, |
|||
0x1c, |
|||
0x1e, |
|||
0x20, |
|||
0x12, |
|||
0x2a, |
|||
0x90, |
|||
0x24, |
|||
0x11, |
|||
0x00, |
|||
0x00, |
|||
0x00, |
|||
0x00, |
|||
0x00, |
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
|
|||
0x0e1, /* NEGATIVE_GAMMA_CORRECT */ |
|||
U8G_ESC_ADR(1), /* data mode */ |
|||
0x20, |
|||
0x20, |
|||
0x20, |
|||
0x20, |
|||
0x05, |
|||
0x00, |
|||
0x15, |
|||
0xa7, |
|||
0x3d, |
|||
0x18, |
|||
0x25, |
|||
0x2a, |
|||
0x2b, |
|||
0x2b, |
|||
0x3a, |
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
|
|||
0x0b1, /* FRAME_RATE_CONTROL1 */ |
|||
U8G_ESC_ADR(1), /* data mode */ |
|||
0x008, /* DIVA = 8 */ |
|||
0x008, /* VPA = 8 */ |
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
|
|||
|
|||
0x0b4, /* DISPLAY_INVERSION */ |
|||
U8G_ESC_ADR(1), /* data mode */ |
|||
0x007, /* NLA = 1, NLB = 1, NLC = 1 (all on Frame Inversion) */ |
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
|
|||
0x0c0, /* POWER_CONTROL1 */ |
|||
U8G_ESC_ADR(1), /* data mode */ |
|||
0x00a, /* VRH = 10: GVDD = 4.30 */ |
|||
0x002, /* VC = 2: VCI1 = 2.65 */ |
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
|
|||
0x0c1, /* POWER_CONTROL2 */ |
|||
U8G_ESC_ADR(1), /* data mode */ |
|||
0x002, /* BT = 2: AVDD = 2xVCI1, VCL = -1xVCI1, VGH = 5xVCI1, VGL = -2xVCI1 */ |
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
|
|||
0x0c5, /* VCOM_CONTROL1 */ |
|||
U8G_ESC_ADR(1), /* data mode */ |
|||
0x050, /* VMH = 80: VCOMH voltage = 4.5 */ |
|||
0x05b, /* VML = 91: VCOML voltage = -0.225 */ |
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
|
|||
0x0c7, /* VCOM_OFFSET_CONTROL */ |
|||
U8G_ESC_ADR(1), /* data mode */ |
|||
0x040, /* nVM = 0, VMF = 64: VCOMH output = VMH, VCOML output = VML */ |
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
|
|||
0x02a, /* SET_COLUMN_ADDRESS */ |
|||
U8G_ESC_ADR(1), /* data mode */ |
|||
0x000, /* */ |
|||
0x000, /* */ |
|||
0x000, /* */ |
|||
0x07f, /* */ |
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
|
|||
0x02b, /* SET_PAGE_ADDRESS */ |
|||
U8G_ESC_ADR(1), /* data mode */ |
|||
0x000, /* */ |
|||
0x000, /* */ |
|||
0x000, /* */ |
|||
0x07f, /* */ |
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
|
|||
0x036, /* SET_ADDRESS_MODE */ |
|||
U8G_ESC_ADR(1), /* data mode */ |
|||
0x000, /* Select display orientation */ |
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
|
|||
|
|||
0x029, /* display on */ |
|||
|
|||
0x02c, /* write start */ |
|||
|
|||
U8G_ESC_CS(0), /* disable chip */ |
|||
U8G_ESC_END /* end of sequence */ |
|||
|
|||
}; |
|||
|
|||
#endif |
|||
|
|||
|
|||
|
|||
|
|||
/* calculate bytes for Type B 4096 color display */ |
|||
static uint8_t get_byte_1(uint8_t v) |
|||
{ |
|||
v >>= 4; |
|||
v &= 0x0e; |
|||
return v; |
|||
} |
|||
|
|||
static uint8_t get_byte_2(uint8_t v) |
|||
{ |
|||
uint8_t w; |
|||
w = v; |
|||
w &= 3; |
|||
w = (w<<2) | w; |
|||
v <<= 3; |
|||
v &= 0x0e0; |
|||
w |= v; |
|||
return w; |
|||
} |
|||
|
|||
uint8_t u8g_dev_st7687_c144mvgd_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg) |
|||
{ |
|||
switch(msg) |
|||
{ |
|||
case U8G_DEV_MSG_INIT: |
|||
u8g_InitCom(u8g, dev); |
|||
u8g_WriteEscSeqP(u8g, dev, u8g_dev_st7687_c144mvgd_init_seq); |
|||
break; |
|||
case U8G_DEV_MSG_STOP: |
|||
break; |
|||
case U8G_DEV_MSG_PAGE_NEXT: |
|||
{ |
|||
uint8_t y, i, j; |
|||
uint8_t *ptr; |
|||
u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem); |
|||
|
|||
u8g_SetAddress(u8g, dev, 0); /* cmd mode */ |
|||
u8g_SetChipSelect(u8g, dev, 1); |
|||
y = pb->p.page_y0; |
|||
ptr = pb->buf; |
|||
|
|||
u8g_SetAddress(u8g, dev, 0); /* cmd mode */ |
|||
u8g_WriteByte(u8g, dev, 0x02a ); /* Column address set 8.1.20 */ |
|||
u8g_SetAddress(u8g, dev, 1); /* data mode */ |
|||
u8g_WriteByte(u8g, dev, 0x000 ); /* x0 */ |
|||
u8g_WriteByte(u8g, dev, WIDTH-1 ); /* x1 */ |
|||
u8g_SetAddress(u8g, dev, 0); /* cmd mode */ |
|||
u8g_WriteByte(u8g, dev, 0x02b ); /* Row address set 8.1.21 */ |
|||
u8g_SetAddress(u8g, dev, 1); /* data mode */ |
|||
u8g_WriteByte(u8g, dev, y ); /* y0 */ |
|||
u8g_WriteByte(u8g, dev, y+PAGE_HEIGHT-1 ); /* y1 */ |
|||
u8g_SetAddress(u8g, dev, 0); /* cmd mode */ |
|||
u8g_WriteByte(u8g, dev, 0x02c ); /* Memory write 8.1.22 */ |
|||
u8g_SetAddress(u8g, dev, 1); /* data mode */ |
|||
|
|||
for( i = 0; i < PAGE_HEIGHT; i ++ ) |
|||
{ |
|||
|
|||
for( j = 0; j < WIDTH; j ++ ) |
|||
{ |
|||
u8g_WriteByte(u8g, dev, get_byte_1(*ptr) ); |
|||
u8g_WriteByte(u8g, dev, get_byte_2(*ptr) ); |
|||
ptr++; |
|||
} |
|||
} |
|||
u8g_SetAddress(u8g, dev, 0); /* cmd mode */ |
|||
u8g_SetChipSelect(u8g, dev, 0); |
|||
} |
|||
break; |
|||
} |
|||
return u8g_dev_pb8h8_base_fn(u8g, dev, msg, arg); |
|||
} |
|||
|
|||
|
|||
uint8_t u8g_st7687_c144mvgd_8h8_buf[WIDTH*8] U8G_NOCOMMON ; |
|||
u8g_pb_t u8g_st7687_c144mvgd_8h8_pb = { {8, HEIGHT, 0, 0, 0}, WIDTH, u8g_st7687_c144mvgd_8h8_buf}; |
|||
|
|||
u8g_dev_t u8g_dev_st7687_c144mvgd_sw_spi = { u8g_dev_st7687_c144mvgd_fn, &u8g_st7687_c144mvgd_8h8_pb, u8g_com_arduino_sw_spi_fn }; |
|||
|
|||
u8g_dev_t u8g_dev_st7687_c144mvgd_8bit = { u8g_dev_st7687_c144mvgd_fn, &u8g_st7687_c144mvgd_8h8_pb, U8G_COM_PARALLEL }; |
|||
@ -0,0 +1,171 @@ |
|||
/*
|
|||
|
|||
u8g_dev_st7565_128x64.c |
|||
|
|||
Universal 8bit Graphics Library |
|||
|
|||
Copyright (c) 2011, olikraus@gmail.com |
|||
All rights reserved. |
|||
|
|||
Redistribution and use in source and binary forms, with or without modification, |
|||
are permitted provided that the following conditions are met: |
|||
|
|||
* Redistributions of source code must retain the above copyright notice, this list |
|||
of conditions and the following disclaimer. |
|||
|
|||
* Redistributions in binary form must reproduce the above copyright notice, this |
|||
list of conditions and the following disclaimer in the documentation and/or other |
|||
materials provided with the distribution. |
|||
|
|||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
|||
CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
|||
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
|||
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
|||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
|||
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
|||
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
|||
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
|||
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
|||
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF |
|||
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|||
|
|||
|
|||
*/ |
|||
|
|||
#include "u8g.h" |
|||
|
|||
#define WIDTH 128 |
|||
#define HEIGHT 64 |
|||
#define PAGE_HEIGHT 8 |
|||
|
|||
|
|||
/* init sequence from https://github.com/adafruit/ST7565-LCD/blob/master/ST7565/ST7565.cpp */ |
|||
static const uint8_t u8g_dev_st7920_128x64_init_seq[] PROGMEM = { |
|||
U8G_ESC_CS(0), /* disable chip */ |
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
U8G_ESC_RST(15), /* do reset low pulse with (15*16)+2 milliseconds (=maximum delay)*/ |
|||
U8G_ESC_DLY(100), /* 8 Dez 2012: additional delay 100 ms because of reset*/ |
|||
U8G_ESC_CS(1), /* enable chip */ |
|||
U8G_ESC_DLY(50), /* delay 50 ms */ |
|||
|
|||
0x038, /* 8 Bit interface (DL=1), basic instruction set (RE=0) */ |
|||
0x00c, /* display on, cursor & blink off; 0x08: all off */ |
|||
0x006, /* Entry mode: Cursor move to right ,DDRAM address counter (AC) plus 1, no shift */ |
|||
0x002, /* disable scroll, enable CGRAM adress */ |
|||
0x001, /* clear RAM, needs 1.6 ms */ |
|||
U8G_ESC_DLY(100), /* delay 100 ms */ |
|||
|
|||
U8G_ESC_CS(0), /* disable chip */ |
|||
U8G_ESC_END /* end of sequence */ |
|||
}; |
|||
|
|||
uint8_t u8g_dev_st7920_128x64_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg) |
|||
{ |
|||
switch(msg) |
|||
{ |
|||
case U8G_DEV_MSG_INIT: |
|||
u8g_InitCom(u8g, dev); |
|||
u8g_WriteEscSeqP(u8g, dev, u8g_dev_st7920_128x64_init_seq); |
|||
break; |
|||
case U8G_DEV_MSG_STOP: |
|||
break; |
|||
case U8G_DEV_MSG_PAGE_NEXT: |
|||
{ |
|||
uint8_t y, i; |
|||
uint8_t *ptr; |
|||
u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem); |
|||
|
|||
u8g_SetAddress(u8g, dev, 0); /* cmd mode */ |
|||
u8g_SetChipSelect(u8g, dev, 1); |
|||
y = pb->p.page_y0; |
|||
ptr = pb->buf; |
|||
for( i = 0; i < 8; i ++ ) |
|||
{ |
|||
u8g_SetAddress(u8g, dev, 0); /* cmd mode */ |
|||
u8g_WriteByte(u8g, dev, 0x03e ); /* enable extended mode */ |
|||
|
|||
if ( y < 32 ) |
|||
{ |
|||
u8g_WriteByte(u8g, dev, 0x080 | y ); /* y pos */ |
|||
u8g_WriteByte(u8g, dev, 0x080 ); /* set x pos to 0*/ |
|||
} |
|||
else |
|||
{ |
|||
u8g_WriteByte(u8g, dev, 0x080 | (y-32) ); /* y pos */ |
|||
u8g_WriteByte(u8g, dev, 0x080 | 8); /* set x pos to 64*/ |
|||
} |
|||
|
|||
u8g_SetAddress(u8g, dev, 1); /* data mode */ |
|||
u8g_WriteSequence(u8g, dev, WIDTH/8, ptr); |
|||
ptr += WIDTH/8; |
|||
y++; |
|||
} |
|||
u8g_SetChipSelect(u8g, dev, 0); |
|||
} |
|||
break; |
|||
} |
|||
return u8g_dev_pb8h1_base_fn(u8g, dev, msg, arg); |
|||
} |
|||
|
|||
uint8_t u8g_dev_st7920_128x64_4x_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg) |
|||
{ |
|||
switch(msg) |
|||
{ |
|||
case U8G_DEV_MSG_INIT: |
|||
u8g_InitCom(u8g, dev); |
|||
u8g_WriteEscSeqP(u8g, dev, u8g_dev_st7920_128x64_init_seq); |
|||
break; |
|||
case U8G_DEV_MSG_STOP: |
|||
break; |
|||
case U8G_DEV_MSG_PAGE_NEXT: |
|||
{ |
|||
uint8_t y, i; |
|||
uint8_t *ptr; |
|||
u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem); |
|||
|
|||
u8g_SetAddress(u8g, dev, 0); /* cmd mode */ |
|||
u8g_SetChipSelect(u8g, dev, 1); |
|||
y = pb->p.page_y0; |
|||
ptr = pb->buf; |
|||
for( i = 0; i < 32; i ++ ) |
|||
{ |
|||
u8g_SetAddress(u8g, dev, 0); /* cmd mode */ |
|||
u8g_WriteByte(u8g, dev, 0x03e ); /* enable extended mode */ |
|||
|
|||
if ( y < 32 ) |
|||
{ |
|||
u8g_WriteByte(u8g, dev, 0x080 | y ); /* y pos */ |
|||
u8g_WriteByte(u8g, dev, 0x080 ); /* set x pos to 0*/ |
|||
} |
|||
else |
|||
{ |
|||
u8g_WriteByte(u8g, dev, 0x080 | (y-32) ); /* y pos */ |
|||
u8g_WriteByte(u8g, dev, 0x080 | 8); /* set x pos to 64*/ |
|||
} |
|||
|
|||
u8g_SetAddress(u8g, dev, 1); /* data mode */ |
|||
u8g_WriteSequence(u8g, dev, WIDTH/8, ptr); |
|||
ptr += WIDTH/8; |
|||
y++; |
|||
} |
|||
u8g_SetChipSelect(u8g, dev, 0); |
|||
} |
|||
break; |
|||
} |
|||
return u8g_dev_pb32h1_base_fn(u8g, dev, msg, arg); |
|||
} |
|||
|
|||
U8G_PB_DEV(u8g_dev_st7920_128x64_sw_spi, WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_st7920_128x64_fn, U8G_COM_ST7920_SW_SPI); |
|||
U8G_PB_DEV(u8g_dev_st7920_128x64_hw_spi, WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_st7920_128x64_fn, U8G_COM_ST7920_HW_SPI); |
|||
U8G_PB_DEV(u8g_dev_st7920_128x64_8bit, WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_st7920_128x64_fn, U8G_COM_FAST_PARALLEL); |
|||
|
|||
#define QWIDTH (WIDTH*4) |
|||
uint8_t u8g_dev_st7920_128x64_4x_buf[QWIDTH] U8G_NOCOMMON ; |
|||
u8g_pb_t u8g_dev_st7920_128x64_4x_pb = { {32, HEIGHT, 0, 0, 0}, WIDTH, u8g_dev_st7920_128x64_4x_buf}; |
|||
u8g_dev_t u8g_dev_st7920_128x64_4x_sw_spi = { u8g_dev_st7920_128x64_4x_fn, &u8g_dev_st7920_128x64_4x_pb, U8G_COM_ST7920_SW_SPI }; |
|||
u8g_dev_t u8g_dev_st7920_128x64_4x_hw_spi = { u8g_dev_st7920_128x64_4x_fn, &u8g_dev_st7920_128x64_4x_pb, U8G_COM_ST7920_HW_SPI }; |
|||
u8g_dev_t u8g_dev_st7920_128x64_4x_8bit = { u8g_dev_st7920_128x64_4x_fn, &u8g_dev_st7920_128x64_4x_pb, U8G_COM_FAST_PARALLEL }; |
|||
|
|||
|
|||
@ -0,0 +1,151 @@ |
|||
/*
|
|||
|
|||
u8g_dev_st7920_192x32.c |
|||
|
|||
Universal 8bit Graphics Library |
|||
|
|||
Copyright (c) 2011, olikraus@gmail.com |
|||
All rights reserved. |
|||
|
|||
Redistribution and use in source and binary forms, with or without modification, |
|||
are permitted provided that the following conditions are met: |
|||
|
|||
* Redistributions of source code must retain the above copyright notice, this list |
|||
of conditions and the following disclaimer. |
|||
|
|||
* Redistributions in binary form must reproduce the above copyright notice, this |
|||
list of conditions and the following disclaimer in the documentation and/or other |
|||
materials provided with the distribution. |
|||
|
|||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
|||
CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
|||
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
|||
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
|||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
|||
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
|||
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
|||
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
|||
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
|||
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF |
|||
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|||
|
|||
|
|||
*/ |
|||
|
|||
#include "u8g.h" |
|||
|
|||
#define WIDTH 192 |
|||
#define HEIGHT 32 |
|||
|
|||
|
|||
/* init sequence from https://github.com/adafruit/ST7565-LCD/blob/master/ST7565/ST7565.cpp */ |
|||
static const uint8_t u8g_dev_st7920_192x32_init_seq[] PROGMEM = { |
|||
U8G_ESC_CS(0), /* disable chip */ |
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
U8G_ESC_RST(15), /* do reset low pulse with (15*16)+2 milliseconds (=maximum delay)*/ |
|||
U8G_ESC_DLY(100), /* 8 Dez 2012: additional delay 100 ms because of reset*/ |
|||
U8G_ESC_CS(1), /* enable chip */ |
|||
U8G_ESC_DLY(50), /* delay 50 ms */ |
|||
|
|||
0x038, /* 8 Bit interface (DL=1), basic instruction set (RE=0) */ |
|||
0x00c, /* display on, cursor & blink off; 0x08: all off */ |
|||
0x006, /* Entry mode: Cursor move to right ,DDRAM address counter (AC) plus 1, no shift */ |
|||
0x002, /* disable scroll, enable CGRAM adress */ |
|||
0x001, /* clear RAM, needs 1.6 ms */ |
|||
U8G_ESC_DLY(100), /* delay 10 ms */ |
|||
|
|||
U8G_ESC_CS(0), /* disable chip */ |
|||
U8G_ESC_END /* end of sequence */ |
|||
}; |
|||
|
|||
uint8_t u8g_dev_st7920_192x32_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg) |
|||
{ |
|||
switch(msg) |
|||
{ |
|||
case U8G_DEV_MSG_INIT: |
|||
u8g_InitCom(u8g, dev); |
|||
u8g_WriteEscSeqP(u8g, dev, u8g_dev_st7920_192x32_init_seq); |
|||
break; |
|||
case U8G_DEV_MSG_STOP: |
|||
break; |
|||
case U8G_DEV_MSG_PAGE_NEXT: |
|||
{ |
|||
uint8_t y, i; |
|||
uint8_t *ptr; |
|||
u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem); |
|||
|
|||
u8g_SetAddress(u8g, dev, 0); /* cmd mode */ |
|||
u8g_SetChipSelect(u8g, dev, 1); |
|||
y = pb->p.page_y0; |
|||
ptr = pb->buf; |
|||
for( i = 0; i < 8; i ++ ) |
|||
{ |
|||
u8g_SetAddress(u8g, dev, 0); /* cmd mode */ |
|||
u8g_WriteByte(u8g, dev, 0x03e ); /* enable extended mode */ |
|||
u8g_WriteByte(u8g, dev, 0x080 | y ); /* y pos */ |
|||
u8g_WriteByte(u8g, dev, 0x080 ); /* set x pos to 0*/ |
|||
u8g_SetAddress(u8g, dev, 1); /* data mode */ |
|||
u8g_WriteSequence(u8g, dev, WIDTH/8, ptr); |
|||
ptr += WIDTH/8; |
|||
y++; |
|||
} |
|||
u8g_SetChipSelect(u8g, dev, 0); |
|||
} |
|||
break; |
|||
} |
|||
return u8g_dev_pb8h1_base_fn(u8g, dev, msg, arg); |
|||
} |
|||
|
|||
uint8_t u8g_dev_st7920_192x32_4x_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg) |
|||
{ |
|||
switch(msg) |
|||
{ |
|||
case U8G_DEV_MSG_INIT: |
|||
u8g_InitCom(u8g, dev); |
|||
u8g_WriteEscSeqP(u8g, dev, u8g_dev_st7920_192x32_init_seq); |
|||
break; |
|||
case U8G_DEV_MSG_STOP: |
|||
break; |
|||
case U8G_DEV_MSG_PAGE_NEXT: |
|||
{ |
|||
uint8_t y, i; |
|||
uint8_t *ptr; |
|||
u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem); |
|||
|
|||
u8g_SetAddress(u8g, dev, 0); /* cmd mode */ |
|||
u8g_SetChipSelect(u8g, dev, 1); |
|||
y = pb->p.page_y0; |
|||
ptr = pb->buf; |
|||
for( i = 0; i < 32; i ++ ) |
|||
{ |
|||
u8g_SetAddress(u8g, dev, 0); /* cmd mode */ |
|||
u8g_WriteByte(u8g, dev, 0x03e ); /* enable extended mode */ |
|||
u8g_WriteByte(u8g, dev, 0x080 | y ); /* y pos */ |
|||
u8g_WriteByte(u8g, dev, 0x080 ); /* set x pos to 0*/ |
|||
u8g_SetAddress(u8g, dev, 1); /* data mode */ |
|||
u8g_WriteSequence(u8g, dev, WIDTH/8, ptr); |
|||
ptr += WIDTH/8; |
|||
y++; |
|||
} |
|||
u8g_SetChipSelect(u8g, dev, 0); |
|||
} |
|||
break; |
|||
} |
|||
return u8g_dev_pb32h1_base_fn(u8g, dev, msg, arg); |
|||
} |
|||
|
|||
|
|||
U8G_PB_DEV(u8g_dev_st7920_192x32_sw_spi, WIDTH, HEIGHT, 8, u8g_dev_st7920_192x32_fn, U8G_COM_ST7920_SW_SPI); |
|||
U8G_PB_DEV(u8g_dev_st7920_192x32_hw_spi, WIDTH, HEIGHT, 8, u8g_dev_st7920_192x32_fn, U8G_COM_ST7920_HW_SPI); |
|||
U8G_PB_DEV(u8g_dev_st7920_192x32_8bit, WIDTH, HEIGHT, 8, u8g_dev_st7920_192x32_fn, U8G_COM_FAST_PARALLEL); |
|||
|
|||
|
|||
#define QWIDTH (WIDTH*4) |
|||
uint8_t u8g_dev_st7920_192x32_4x_buf[QWIDTH] U8G_NOCOMMON ; |
|||
u8g_pb_t u8g_dev_st7920_192x32_4x_pb = { {32, HEIGHT, 0, 0, 0}, WIDTH, u8g_dev_st7920_192x32_4x_buf}; |
|||
u8g_dev_t u8g_dev_st7920_192x32_4x_sw_spi = { u8g_dev_st7920_192x32_4x_fn, &u8g_dev_st7920_192x32_4x_pb, U8G_COM_ST7920_SW_SPI }; |
|||
u8g_dev_t u8g_dev_st7920_192x32_4x_hw_spi = { u8g_dev_st7920_192x32_4x_fn, &u8g_dev_st7920_192x32_4x_pb, U8G_COM_ST7920_HW_SPI }; |
|||
u8g_dev_t u8g_dev_st7920_192x32_4x_8bit = { u8g_dev_st7920_192x32_4x_fn, &u8g_dev_st7920_192x32_4x_pb, U8G_COM_FAST_PARALLEL }; |
|||
|
|||
@ -0,0 +1,154 @@ |
|||
/*
|
|||
|
|||
u8g_dev_st7920_202x32.c |
|||
tested with CFAG20232 |
|||
|
|||
|
|||
Universal 8bit Graphics Library |
|||
|
|||
Copyright (c) 2011, olikraus@gmail.com |
|||
All rights reserved. |
|||
|
|||
Redistribution and use in source and binary forms, with or without modification, |
|||
are permitted provided that the following conditions are met: |
|||
|
|||
* Redistributions of source code must retain the above copyright notice, this list |
|||
of conditions and the following disclaimer. |
|||
|
|||
* Redistributions in binary form must reproduce the above copyright notice, this |
|||
list of conditions and the following disclaimer in the documentation and/or other |
|||
materials provided with the distribution. |
|||
|
|||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
|||
CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
|||
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
|||
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
|||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
|||
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
|||
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
|||
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
|||
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
|||
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF |
|||
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|||
|
|||
|
|||
*/ |
|||
|
|||
#include "u8g.h" |
|||
|
|||
#define WIDTH 202 |
|||
#define HEIGHT 32 |
|||
#define PAGE_HEIGHT 8 |
|||
|
|||
|
|||
/* init sequence from https://github.com/adafruit/ST7565-LCD/blob/master/ST7565/ST7565.cpp */ |
|||
static const uint8_t u8g_dev_st7920_202x32_init_seq[] PROGMEM = { |
|||
U8G_ESC_CS(0), /* disable chip */ |
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
U8G_ESC_RST(15), /* do reset low pulse with (15*16)+2 milliseconds (=maximum delay)*/ |
|||
U8G_ESC_DLY(100), /* 8 Dez 2012: additional delay 100 ms because of reset*/ |
|||
U8G_ESC_CS(1), /* enable chip */ |
|||
U8G_ESC_DLY(50), /* delay 50 ms */ |
|||
|
|||
0x038, /* 8 Bit interface (DL=1), basic instruction set (RE=0) */ |
|||
0x00c, /* display on, cursor & blink off; 0x08: all off */ |
|||
0x006, /* Entry mode: Cursor move to right ,DDRAM address counter (AC) plus 1, no shift */ |
|||
0x002, /* disable scroll, enable CGRAM adress */ |
|||
0x001, /* clear RAM, needs 1.6 ms */ |
|||
U8G_ESC_DLY(100), /* delay 10 ms */ |
|||
|
|||
U8G_ESC_CS(0), /* disable chip */ |
|||
U8G_ESC_END /* end of sequence */ |
|||
}; |
|||
|
|||
uint8_t u8g_dev_st7920_202x32_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg) |
|||
{ |
|||
switch(msg) |
|||
{ |
|||
case U8G_DEV_MSG_INIT: |
|||
u8g_InitCom(u8g, dev); |
|||
u8g_WriteEscSeqP(u8g, dev, u8g_dev_st7920_202x32_init_seq); |
|||
break; |
|||
case U8G_DEV_MSG_STOP: |
|||
break; |
|||
case U8G_DEV_MSG_PAGE_NEXT: |
|||
{ |
|||
uint8_t y, i; |
|||
uint8_t *ptr; |
|||
u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem); |
|||
|
|||
u8g_SetAddress(u8g, dev, 0); /* cmd mode */ |
|||
u8g_SetChipSelect(u8g, dev, 1); |
|||
y = pb->p.page_y0; |
|||
ptr = pb->buf; |
|||
for( i = 0; i < 8; i ++ ) |
|||
{ |
|||
u8g_SetAddress(u8g, dev, 0); /* cmd mode */ |
|||
u8g_WriteByte(u8g, dev, 0x03e ); /* enable extended mode */ |
|||
u8g_WriteByte(u8g, dev, 0x080 | y ); /* y pos */ |
|||
u8g_WriteByte(u8g, dev, 0x080 ); /* set x pos to 0*/ |
|||
u8g_SetAddress(u8g, dev, 1); /* data mode */ |
|||
u8g_WriteSequence(u8g, dev, WIDTH/8, ptr); |
|||
ptr += WIDTH/8; |
|||
y++; |
|||
} |
|||
u8g_SetChipSelect(u8g, dev, 0); |
|||
} |
|||
break; |
|||
} |
|||
return u8g_dev_pb8h1_base_fn(u8g, dev, msg, arg); |
|||
} |
|||
|
|||
uint8_t u8g_dev_st7920_202x32_4x_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg) |
|||
{ |
|||
switch(msg) |
|||
{ |
|||
case U8G_DEV_MSG_INIT: |
|||
u8g_InitCom(u8g, dev); |
|||
u8g_WriteEscSeqP(u8g, dev, u8g_dev_st7920_202x32_init_seq); |
|||
break; |
|||
case U8G_DEV_MSG_STOP: |
|||
break; |
|||
case U8G_DEV_MSG_PAGE_NEXT: |
|||
{ |
|||
uint8_t y, i; |
|||
uint8_t *ptr; |
|||
u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem); |
|||
|
|||
u8g_SetAddress(u8g, dev, 0); /* cmd mode */ |
|||
u8g_SetChipSelect(u8g, dev, 1); |
|||
y = pb->p.page_y0; |
|||
ptr = pb->buf; |
|||
for( i = 0; i < 32; i ++ ) |
|||
{ |
|||
u8g_SetAddress(u8g, dev, 0); /* cmd mode */ |
|||
u8g_WriteByte(u8g, dev, 0x03e ); /* enable extended mode */ |
|||
u8g_WriteByte(u8g, dev, 0x080 | y ); /* y pos */ |
|||
u8g_WriteByte(u8g, dev, 0x080 ); /* set x pos to 0*/ |
|||
u8g_SetAddress(u8g, dev, 1); /* data mode */ |
|||
u8g_WriteSequence(u8g, dev, WIDTH/8, ptr); |
|||
ptr += WIDTH/8; |
|||
y++; |
|||
} |
|||
u8g_SetChipSelect(u8g, dev, 0); |
|||
} |
|||
break; |
|||
} |
|||
return u8g_dev_pb32h1_base_fn(u8g, dev, msg, arg); |
|||
} |
|||
|
|||
|
|||
U8G_PB_DEV(u8g_dev_st7920_202x32_sw_spi, WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_st7920_202x32_fn, U8G_COM_ST7920_SW_SPI); |
|||
U8G_PB_DEV(u8g_dev_st7920_202x32_hw_spi, WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_st7920_202x32_fn, U8G_COM_ST7920_HW_SPI); |
|||
U8G_PB_DEV(u8g_dev_st7920_202x32_8bit, WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_st7920_202x32_fn, U8G_COM_FAST_PARALLEL); |
|||
|
|||
#define QWIDTH (WIDTH*4) |
|||
uint8_t u8g_dev_st7920_202x32_4x_buf[QWIDTH] U8G_NOCOMMON ; |
|||
u8g_pb_t u8g_dev_st7920_202x32_4x_pb = { {32, HEIGHT, 0, 0, 0}, WIDTH, u8g_dev_st7920_202x32_4x_buf}; |
|||
u8g_dev_t u8g_dev_st7920_202x32_4x_sw_spi = { u8g_dev_st7920_202x32_4x_fn, &u8g_dev_st7920_202x32_4x_pb, U8G_COM_ST7920_SW_SPI }; |
|||
u8g_dev_t u8g_dev_st7920_202x32_4x_hw_spi = { u8g_dev_st7920_202x32_4x_fn, &u8g_dev_st7920_202x32_4x_pb, U8G_COM_ST7920_HW_SPI }; |
|||
u8g_dev_t u8g_dev_st7920_202x32_4x_8bit = { u8g_dev_st7920_202x32_4x_fn, &u8g_dev_st7920_202x32_4x_pb, U8G_COM_FAST_PARALLEL }; |
|||
|
|||
|
|||
@ -0,0 +1,191 @@ |
|||
/*
|
|||
|
|||
u8g_dev_t6963_128x64.c |
|||
|
|||
Tested with Varitronix MGLS240128TZ |
|||
|
|||
Universal 8bit Graphics Library |
|||
|
|||
Copyright (c) 2013, olikraus@gmail.com |
|||
All rights reserved. |
|||
|
|||
Redistribution and use in source and binary forms, with or without modification, |
|||
are permitted provided that the following conditions are met: |
|||
|
|||
* Redistributions of source code must retain the above copyright notice, this list |
|||
of conditions and the following disclaimer. |
|||
|
|||
* Redistributions in binary form must reproduce the above copyright notice, this |
|||
list of conditions and the following disclaimer in the documentation and/or other |
|||
materials provided with the distribution. |
|||
|
|||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
|||
CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
|||
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
|||
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
|||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
|||
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
|||
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
|||
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
|||
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
|||
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF |
|||
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|||
|
|||
|
|||
Application Notes for the MGLS 240x128 |
|||
www.baso.no/content/pdf/T6963C_Application.pdf |
|||
|
|||
Hitachi App Notes: |
|||
https://www.sparkfun.com/datasheets/LCD/Monochrome/AN-029-Toshiba_T6963C.pdf
|
|||
|
|||
Notes: |
|||
The font selection pins should generate the 8x8 font. |
|||
For the MGLS240128TZ only FS1 is available on pin 18. |
|||
FS1 must be low to generate the 8x8 font. |
|||
|
|||
|
|||
*/ |
|||
|
|||
#include "u8g.h" |
|||
|
|||
#define WIDTH 128 |
|||
#define HEIGHT 64 |
|||
#define PAGE_HEIGHT 16 |
|||
|
|||
|
|||
/* text is not used, so settings are not relevant */ |
|||
static const uint8_t u8g_dev_t6963_128x64_init_seq[] PROGMEM = { |
|||
U8G_ESC_CS(0), /* disable chip */ |
|||
U8G_ESC_ADR(0), /* data mode */ |
|||
U8G_ESC_RST(15), /* do reset low pulse with (15*16)+2 milliseconds (=maximum delay)*/ |
|||
|
|||
U8G_ESC_CS(1), /* enable chip */ |
|||
U8G_ESC_DLY(50), /* delay 50 ms */ |
|||
|
|||
U8G_ESC_ADR(0), /* data mode */ |
|||
0x000, /* low byte */ |
|||
0x000, /* height byte */ |
|||
U8G_ESC_ADR(1), /* instruction mode */ |
|||
0x021, /* set cursor position */ |
|||
|
|||
U8G_ESC_ADR(0), /* data mode */ |
|||
0x000, /* low byte */ |
|||
0x000, /* height byte */ |
|||
U8G_ESC_ADR(1), /* instruction mode */ |
|||
0x022, /* set offset */ |
|||
|
|||
U8G_ESC_ADR(0), /* data mode */ |
|||
0x000, /* low byte */ |
|||
0x000, /* height byte */ |
|||
U8G_ESC_ADR(1), /* instruction mode */ |
|||
0x040, /* text home */ |
|||
|
|||
U8G_ESC_ADR(0), /* data mode */ |
|||
WIDTH/8, /* low byte */ |
|||
0x000, /* height byte */ |
|||
U8G_ESC_ADR(1), /* instruction mode */ |
|||
0x041, /* text columns */ |
|||
|
|||
U8G_ESC_ADR(0), /* data mode */ |
|||
0x000, /* low byte */ |
|||
0x000, /* height byte */ |
|||
U8G_ESC_ADR(1), /* instruction mode */ |
|||
0x042, /* graphics home */ |
|||
|
|||
U8G_ESC_ADR(0), /* data mode */ |
|||
WIDTH/8, /* low byte */ |
|||
0x000, /* height byte */ |
|||
U8G_ESC_ADR(1), /* instruction mode */ |
|||
0x043, /* graphics columns */ |
|||
|
|||
// mode set
|
|||
// 0x080: Internal CG, OR Mode
|
|||
// 0x081: Internal CG, EXOR Mode
|
|||
// 0x083: Internal CG, AND Mode
|
|||
// 0x088: External CG, OR Mode
|
|||
// 0x089: External CG, EXOR Mode
|
|||
// 0x08B: External CG, AND Mode
|
|||
U8G_ESC_ADR(1), /* instruction mode */ |
|||
0x080, /* mode register: OR Mode, Internal Character Mode */ |
|||
|
|||
U8G_ESC_ADR(1), /* instruction mode */ |
|||
// display mode
|
|||
// 0x090: Display off
|
|||
// 0x094: Graphic off, text on, cursor off, blink off
|
|||
// 0x096: Graphic off, text on, cursor on, blink off
|
|||
// 0x097: Graphic off, text on, cursor on, blink on
|
|||
// 0x098: Graphic on, text off, cursor off, blink off
|
|||
// 0x09a: Graphic on, text off, cursor on, blink off
|
|||
// ...
|
|||
// 0x09c: Graphic on, text on, cursor off, blink off
|
|||
// 0x09f: Graphic on, text on, cursor on, blink on
|
|||
0x098, /* mode register: Display Mode, Graphics on, Text off, Cursor off */ |
|||
|
|||
U8G_ESC_ADR(0), /* data mode */ |
|||
0x000, /* low byte */ |
|||
0x000, /* height byte */ |
|||
U8G_ESC_ADR(1), /* instruction mode */ |
|||
0x024, /* set adr pointer */ |
|||
|
|||
|
|||
U8G_ESC_DLY(100), /* delay 100 ms */ |
|||
|
|||
U8G_ESC_ADR(0), /* data mode */ |
|||
U8G_ESC_CS(0), /* disable chip */ |
|||
U8G_ESC_END /* end of sequence */ |
|||
}; |
|||
|
|||
uint8_t u8g_dev_t6963_128x64_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg) |
|||
{ |
|||
switch(msg) |
|||
{ |
|||
case U8G_DEV_MSG_INIT: |
|||
u8g_InitCom(u8g, dev); |
|||
u8g_WriteEscSeqP(u8g, dev, u8g_dev_t6963_128x64_init_seq); |
|||
break; |
|||
case U8G_DEV_MSG_STOP: |
|||
break; |
|||
case U8G_DEV_MSG_PAGE_NEXT: |
|||
{ |
|||
uint8_t y, i; |
|||
uint16_t disp_ram_adr; |
|||
uint8_t *ptr; |
|||
u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem); |
|||
|
|||
|
|||
u8g_SetAddress(u8g, dev, 0); /* data mode */ |
|||
u8g_SetChipSelect(u8g, dev, 1); |
|||
y = pb->p.page_y0; |
|||
ptr = pb->buf; |
|||
disp_ram_adr = WIDTH/8; |
|||
disp_ram_adr *= y; |
|||
for( i = 0; i < PAGE_HEIGHT; i ++ ) |
|||
{ |
|||
u8g_SetAddress(u8g, dev, 0); /* data mode */ |
|||
u8g_WriteByte(u8g, dev, disp_ram_adr&255 ); /* address low byte */ |
|||
u8g_WriteByte(u8g, dev, disp_ram_adr>>8 ); /* address hight byte */ |
|||
u8g_SetAddress(u8g, dev, 1); /* cmd mode */ |
|||
u8g_WriteByte(u8g, dev, 0x024 ); /* set adr ptr */ |
|||
|
|||
u8g_WriteSequence(u8g, dev, WIDTH/8, ptr); |
|||
|
|||
ptr += WIDTH/8; |
|||
disp_ram_adr += WIDTH/8; |
|||
} |
|||
u8g_SetAddress(u8g, dev, 0); /* data mode */ |
|||
u8g_SetChipSelect(u8g, dev, 0); |
|||
} |
|||
break; |
|||
} |
|||
return u8g_dev_pb16h1_base_fn(u8g, dev, msg, arg); |
|||
} |
|||
|
|||
// U8G_PB_DEV(u8g_dev_t6963_128x64_8bit, WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_t6963_128x64_fn, U8G_COM_T6963);
|
|||
|
|||
uint8_t u8g_dev_t6963_128x64_2x_bw_buf[WIDTH/8*PAGE_HEIGHT] U8G_NOCOMMON ; |
|||
u8g_pb_t u8g_dev_t6963_128x64_2x_bw_pb = { {PAGE_HEIGHT, HEIGHT, 0, 0, 0}, WIDTH, u8g_dev_t6963_128x64_2x_bw_buf}; |
|||
u8g_dev_t u8g_dev_t6963_128x64_8bit = { u8g_dev_t6963_128x64_fn, &u8g_dev_t6963_128x64_2x_bw_pb, U8G_COM_T6963 }; |
|||
|
|||
|
|||
@ -0,0 +1,195 @@ |
|||
/*
|
|||
|
|||
u8g_dev_t6963_240x128.c |
|||
|
|||
Tested with Varitronix MGLS240128TZ |
|||
|
|||
Universal 8bit Graphics Library |
|||
|
|||
Copyright (c) 2013, olikraus@gmail.com |
|||
All rights reserved. |
|||
|
|||
Redistribution and use in source and binary forms, with or without modification, |
|||
are permitted provided that the following conditions are met: |
|||
|
|||
* Redistributions of source code must retain the above copyright notice, this list |
|||
of conditions and the following disclaimer. |
|||
|
|||
* Redistributions in binary form must reproduce the above copyright notice, this |
|||
list of conditions and the following disclaimer in the documentation and/or other |
|||
materials provided with the distribution. |
|||
|
|||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
|||
CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
|||
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
|||
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
|||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
|||
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
|||
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
|||
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
|||
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
|||
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF |
|||
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|||
|
|||
|
|||
Application Notes for the MGLS 240x128 |
|||
www.baso.no/content/pdf/T6963C_Application.pdf |
|||
|
|||
Hitachi App Notes: |
|||
https://www.sparkfun.com/datasheets/LCD/Monochrome/AN-029-Toshiba_T6963C.pdf
|
|||
|
|||
Notes: |
|||
The font selection pins should generate the 8x8 font. |
|||
For the MGLS240128TZ only FS1 is available on pin 18. |
|||
FS1 must be low to generate the 8x8 font. |
|||
|
|||
|
|||
*/ |
|||
|
|||
#include "u8g.h" |
|||
|
|||
#define WIDTH 240 |
|||
#define HEIGHT 128 |
|||
#define PAGE_HEIGHT 16 |
|||
|
|||
|
|||
/*
|
|||
http://www.mark-products.com/graphics.htm#240x64%20Pixel%20Format
|
|||
*/ |
|||
|
|||
/* text is not used, so settings are not relevant */ |
|||
static const uint8_t u8g_dev_t6963_240x128_init_seq[] PROGMEM = { |
|||
U8G_ESC_CS(0), /* disable chip */ |
|||
U8G_ESC_ADR(0), /* data mode */ |
|||
U8G_ESC_RST(15), /* do reset low pulse with (15*16)+2 milliseconds (=maximum delay)*/ |
|||
|
|||
U8G_ESC_CS(1), /* enable chip */ |
|||
U8G_ESC_DLY(50), /* delay 50 ms */ |
|||
|
|||
U8G_ESC_ADR(0), /* data mode */ |
|||
0x000, /* low byte */ |
|||
0x000, /* height byte */ |
|||
U8G_ESC_ADR(1), /* instruction mode */ |
|||
0x021, /* set cursor position */ |
|||
|
|||
U8G_ESC_ADR(0), /* data mode */ |
|||
0x000, /* low byte */ |
|||
0x000, /* height byte */ |
|||
U8G_ESC_ADR(1), /* instruction mode */ |
|||
0x022, /* set offset */ |
|||
|
|||
U8G_ESC_ADR(0), /* data mode */ |
|||
0x000, /* low byte */ |
|||
0x000, /* height byte */ |
|||
U8G_ESC_ADR(1), /* instruction mode */ |
|||
0x040, /* text home */ |
|||
|
|||
U8G_ESC_ADR(0), /* data mode */ |
|||
WIDTH/8, /* low byte */ |
|||
0x000, /* height byte */ |
|||
U8G_ESC_ADR(1), /* instruction mode */ |
|||
0x041, /* text columns */ |
|||
|
|||
U8G_ESC_ADR(0), /* data mode */ |
|||
0x000, /* low byte */ |
|||
0x000, /* height byte */ |
|||
U8G_ESC_ADR(1), /* instruction mode */ |
|||
0x042, /* graphics home */ |
|||
|
|||
U8G_ESC_ADR(0), /* data mode */ |
|||
WIDTH/8, /* low byte */ |
|||
0x000, /* height byte */ |
|||
U8G_ESC_ADR(1), /* instruction mode */ |
|||
0x043, /* graphics columns */ |
|||
|
|||
// mode set
|
|||
// 0x080: Internal CG, OR Mode
|
|||
// 0x081: Internal CG, EXOR Mode
|
|||
// 0x083: Internal CG, AND Mode
|
|||
// 0x088: External CG, OR Mode
|
|||
// 0x089: External CG, EXOR Mode
|
|||
// 0x08B: External CG, AND Mode
|
|||
U8G_ESC_ADR(1), /* instruction mode */ |
|||
0x080, /* mode register: OR Mode, Internal Character Mode */ |
|||
|
|||
U8G_ESC_ADR(1), /* instruction mode */ |
|||
// display mode
|
|||
// 0x090: Display off
|
|||
// 0x094: Graphic off, text on, cursor off, blink off
|
|||
// 0x096: Graphic off, text on, cursor on, blink off
|
|||
// 0x097: Graphic off, text on, cursor on, blink on
|
|||
// 0x098: Graphic on, text off, cursor off, blink off
|
|||
// 0x09a: Graphic on, text off, cursor on, blink off
|
|||
// ...
|
|||
// 0x09c: Graphic on, text on, cursor off, blink off
|
|||
// 0x09f: Graphic on, text on, cursor on, blink on
|
|||
0x098, /* mode register: Display Mode, Graphics on, Text off, Cursor off */ |
|||
|
|||
U8G_ESC_ADR(0), /* data mode */ |
|||
0x000, /* low byte */ |
|||
0x000, /* height byte */ |
|||
U8G_ESC_ADR(1), /* instruction mode */ |
|||
0x024, /* set adr pointer */ |
|||
|
|||
|
|||
U8G_ESC_DLY(100), /* delay 100 ms */ |
|||
|
|||
U8G_ESC_ADR(0), /* data mode */ |
|||
U8G_ESC_CS(0), /* disable chip */ |
|||
U8G_ESC_END /* end of sequence */ |
|||
}; |
|||
|
|||
uint8_t u8g_dev_t6963_240x128_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg) |
|||
{ |
|||
switch(msg) |
|||
{ |
|||
case U8G_DEV_MSG_INIT: |
|||
u8g_InitCom(u8g, dev); |
|||
u8g_WriteEscSeqP(u8g, dev, u8g_dev_t6963_240x128_init_seq); |
|||
break; |
|||
case U8G_DEV_MSG_STOP: |
|||
break; |
|||
case U8G_DEV_MSG_PAGE_NEXT: |
|||
{ |
|||
uint8_t y, i; |
|||
uint16_t disp_ram_adr; |
|||
uint8_t *ptr; |
|||
u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem); |
|||
|
|||
|
|||
u8g_SetAddress(u8g, dev, 0); /* data mode */ |
|||
u8g_SetChipSelect(u8g, dev, 1); |
|||
y = pb->p.page_y0; |
|||
ptr = pb->buf; |
|||
disp_ram_adr = WIDTH/8; |
|||
disp_ram_adr *= y; |
|||
for( i = 0; i < PAGE_HEIGHT; i ++ ) |
|||
{ |
|||
u8g_SetAddress(u8g, dev, 0); /* data mode */ |
|||
u8g_WriteByte(u8g, dev, disp_ram_adr&255 ); /* address low byte */ |
|||
u8g_WriteByte(u8g, dev, disp_ram_adr>>8 ); /* address hight byte */ |
|||
u8g_SetAddress(u8g, dev, 1); /* cmd mode */ |
|||
u8g_WriteByte(u8g, dev, 0x024 ); /* set adr ptr */ |
|||
|
|||
u8g_WriteSequence(u8g, dev, WIDTH/8, ptr); |
|||
|
|||
ptr += WIDTH/8; |
|||
disp_ram_adr += WIDTH/8; |
|||
} |
|||
u8g_SetAddress(u8g, dev, 0); /* data mode */ |
|||
u8g_SetChipSelect(u8g, dev, 0); |
|||
} |
|||
break; |
|||
} |
|||
return u8g_dev_pb16h1_base_fn(u8g, dev, msg, arg); |
|||
} |
|||
|
|||
// U8G_PB_DEV(u8g_dev_t6963_240x128_8bit, WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_t6963_240x128_fn, U8G_COM_T6963);
|
|||
|
|||
uint8_t u8g_dev_t6963_240x128_2x_bw_buf[WIDTH/8*PAGE_HEIGHT] U8G_NOCOMMON ; |
|||
u8g_pb_t u8g_dev_t6963_240x128_2x_bw_pb = { {PAGE_HEIGHT, HEIGHT, 0, 0, 0}, WIDTH, u8g_dev_t6963_240x128_2x_bw_buf}; |
|||
u8g_dev_t u8g_dev_t6963_240x128_8bit = { u8g_dev_t6963_240x128_fn, &u8g_dev_t6963_240x128_2x_bw_pb, U8G_COM_T6963 }; |
|||
|
|||
|
|||
@ -0,0 +1,195 @@ |
|||
/*
|
|||
|
|||
u8g_dev_t6963_240x64.c |
|||
|
|||
Tested with Varitronix MGLS240128TZ |
|||
|
|||
Universal 8bit Graphics Library |
|||
|
|||
Copyright (c) 2013, olikraus@gmail.com |
|||
All rights reserved. |
|||
|
|||
Redistribution and use in source and binary forms, with or without modification, |
|||
are permitted provided that the following conditions are met: |
|||
|
|||
* Redistributions of source code must retain the above copyright notice, this list |
|||
of conditions and the following disclaimer. |
|||
|
|||
* Redistributions in binary form must reproduce the above copyright notice, this |
|||
list of conditions and the following disclaimer in the documentation and/or other |
|||
materials provided with the distribution. |
|||
|
|||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
|||
CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
|||
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
|||
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
|||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
|||
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
|||
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
|||
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
|||
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
|||
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF |
|||
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|||
|
|||
|
|||
Application Notes for the MGLS 240x128 |
|||
www.baso.no/content/pdf/T6963C_Application.pdf |
|||
|
|||
Hitachi App Notes: |
|||
https://www.sparkfun.com/datasheets/LCD/Monochrome/AN-029-Toshiba_T6963C.pdf
|
|||
|
|||
Notes: |
|||
The font selection pins should generate the 8x8 font. |
|||
For the MGLS240128TZ only FS1 is available on pin 18. |
|||
FS1 must be low to generate the 8x8 font. |
|||
|
|||
|
|||
*/ |
|||
|
|||
#include "u8g.h" |
|||
|
|||
#define WIDTH 240 |
|||
#define HEIGHT 64 |
|||
#define PAGE_HEIGHT 16 |
|||
|
|||
|
|||
/*
|
|||
http://www.mark-products.com/graphics.htm#240x64%20Pixel%20Format
|
|||
*/ |
|||
|
|||
/* text is not used, so settings are not relevant */ |
|||
static const uint8_t u8g_dev_t6963_240x64_init_seq[] PROGMEM = { |
|||
U8G_ESC_CS(0), /* disable chip */ |
|||
U8G_ESC_ADR(0), /* data mode */ |
|||
U8G_ESC_RST(15), /* do reset low pulse with (15*16)+2 milliseconds (=maximum delay)*/ |
|||
|
|||
U8G_ESC_CS(1), /* enable chip */ |
|||
U8G_ESC_DLY(50), /* delay 50 ms */ |
|||
|
|||
U8G_ESC_ADR(0), /* data mode */ |
|||
0x000, /* low byte */ |
|||
0x000, /* height byte */ |
|||
U8G_ESC_ADR(1), /* instruction mode */ |
|||
0x021, /* set cursor position */ |
|||
|
|||
U8G_ESC_ADR(0), /* data mode */ |
|||
0x000, /* low byte */ |
|||
0x000, /* height byte */ |
|||
U8G_ESC_ADR(1), /* instruction mode */ |
|||
0x022, /* set offset */ |
|||
|
|||
U8G_ESC_ADR(0), /* data mode */ |
|||
0x000, /* low byte */ |
|||
0x000, /* height byte */ |
|||
U8G_ESC_ADR(1), /* instruction mode */ |
|||
0x040, /* text home */ |
|||
|
|||
U8G_ESC_ADR(0), /* data mode */ |
|||
WIDTH/8, /* low byte */ |
|||
0x000, /* height byte */ |
|||
U8G_ESC_ADR(1), /* instruction mode */ |
|||
0x041, /* text columns */ |
|||
|
|||
U8G_ESC_ADR(0), /* data mode */ |
|||
0x000, /* low byte */ |
|||
0x000, /* height byte */ |
|||
U8G_ESC_ADR(1), /* instruction mode */ |
|||
0x042, /* graphics home */ |
|||
|
|||
U8G_ESC_ADR(0), /* data mode */ |
|||
WIDTH/8, /* low byte */ |
|||
0x000, /* height byte */ |
|||
U8G_ESC_ADR(1), /* instruction mode */ |
|||
0x043, /* graphics columns */ |
|||
|
|||
// mode set
|
|||
// 0x080: Internal CG, OR Mode
|
|||
// 0x081: Internal CG, EXOR Mode
|
|||
// 0x083: Internal CG, AND Mode
|
|||
// 0x088: External CG, OR Mode
|
|||
// 0x089: External CG, EXOR Mode
|
|||
// 0x08B: External CG, AND Mode
|
|||
U8G_ESC_ADR(1), /* instruction mode */ |
|||
0x080, /* mode register: OR Mode, Internal Character Mode */ |
|||
|
|||
U8G_ESC_ADR(1), /* instruction mode */ |
|||
// display mode
|
|||
// 0x090: Display off
|
|||
// 0x094: Graphic off, text on, cursor off, blink off
|
|||
// 0x096: Graphic off, text on, cursor on, blink off
|
|||
// 0x097: Graphic off, text on, cursor on, blink on
|
|||
// 0x098: Graphic on, text off, cursor off, blink off
|
|||
// 0x09a: Graphic on, text off, cursor on, blink off
|
|||
// ...
|
|||
// 0x09c: Graphic on, text on, cursor off, blink off
|
|||
// 0x09f: Graphic on, text on, cursor on, blink on
|
|||
0x098, /* mode register: Display Mode, Graphics on, Text off, Cursor off */ |
|||
|
|||
U8G_ESC_ADR(0), /* data mode */ |
|||
0x000, /* low byte */ |
|||
0x000, /* height byte */ |
|||
U8G_ESC_ADR(1), /* instruction mode */ |
|||
0x024, /* set adr pointer */ |
|||
|
|||
|
|||
U8G_ESC_DLY(100), /* delay 100 ms */ |
|||
|
|||
U8G_ESC_ADR(0), /* data mode */ |
|||
U8G_ESC_CS(0), /* disable chip */ |
|||
U8G_ESC_END /* end of sequence */ |
|||
}; |
|||
|
|||
uint8_t u8g_dev_t6963_240x64_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg) |
|||
{ |
|||
switch(msg) |
|||
{ |
|||
case U8G_DEV_MSG_INIT: |
|||
u8g_InitCom(u8g, dev); |
|||
u8g_WriteEscSeqP(u8g, dev, u8g_dev_t6963_240x64_init_seq); |
|||
break; |
|||
case U8G_DEV_MSG_STOP: |
|||
break; |
|||
case U8G_DEV_MSG_PAGE_NEXT: |
|||
{ |
|||
uint8_t y, i; |
|||
uint16_t disp_ram_adr; |
|||
uint8_t *ptr; |
|||
u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem); |
|||
|
|||
|
|||
u8g_SetAddress(u8g, dev, 0); /* data mode */ |
|||
u8g_SetChipSelect(u8g, dev, 1); |
|||
y = pb->p.page_y0; |
|||
ptr = pb->buf; |
|||
disp_ram_adr = WIDTH/8; |
|||
disp_ram_adr *= y; |
|||
for( i = 0; i < PAGE_HEIGHT; i ++ ) |
|||
{ |
|||
u8g_SetAddress(u8g, dev, 0); /* data mode */ |
|||
u8g_WriteByte(u8g, dev, disp_ram_adr&255 ); /* address low byte */ |
|||
u8g_WriteByte(u8g, dev, disp_ram_adr>>8 ); /* address hight byte */ |
|||
u8g_SetAddress(u8g, dev, 1); /* cmd mode */ |
|||
u8g_WriteByte(u8g, dev, 0x024 ); /* set adr ptr */ |
|||
|
|||
u8g_WriteSequence(u8g, dev, WIDTH/8, ptr); |
|||
|
|||
ptr += WIDTH/8; |
|||
disp_ram_adr += WIDTH/8; |
|||
} |
|||
u8g_SetAddress(u8g, dev, 0); /* data mode */ |
|||
u8g_SetChipSelect(u8g, dev, 0); |
|||
} |
|||
break; |
|||
} |
|||
return u8g_dev_pb16h1_base_fn(u8g, dev, msg, arg); |
|||
} |
|||
|
|||
// U8G_PB_DEV(u8g_dev_t6963_240x64_8bit, WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_t6963_240x64_fn, U8G_COM_T6963);
|
|||
|
|||
uint8_t u8g_dev_t6963_240x64_2x_bw_buf[WIDTH/8*PAGE_HEIGHT] U8G_NOCOMMON ; |
|||
u8g_pb_t u8g_dev_t6963_240x64_2x_bw_pb = { {PAGE_HEIGHT, HEIGHT, 0, 0, 0}, WIDTH, u8g_dev_t6963_240x64_2x_bw_buf}; |
|||
u8g_dev_t u8g_dev_t6963_240x64_8bit = { u8g_dev_t6963_240x64_fn, &u8g_dev_t6963_240x64_2x_bw_pb, U8G_COM_T6963 }; |
|||
|
|||
|
|||
@ -0,0 +1,115 @@ |
|||
/*
|
|||
|
|||
u8g_dev_tls8204_84x48.c |
|||
|
|||
Display: Nokia 84x48 |
|||
|
|||
Status: Tested with TLS8204V12 Display by Olimex MOD-LCD3310 |
|||
|
|||
Contributed: http://code.google.com/p/u8glib/issues/detail?id=126
|
|||
|
|||
Universal 8bit Graphics Library |
|||
|
|||
Copyright (c) 2011, olikraus@gmail.com |
|||
All rights reserved. |
|||
|
|||
Redistribution and use in source and binary forms, with or without modification, |
|||
are permitted provided that the following conditions are met: |
|||
|
|||
* Redistributions of source code must retain the above copyright notice, this list |
|||
of conditions and the following disclaimer. |
|||
|
|||
* Redistributions in binary form must reproduce the above copyright notice, this |
|||
list of conditions and the following disclaimer in the documentation and/or other |
|||
materials provided with the distribution. |
|||
|
|||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
|||
CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
|||
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
|||
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
|||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
|||
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
|||
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
|||
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
|||
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
|||
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF |
|||
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|||
|
|||
|
|||
*/ |
|||
|
|||
#include "u8g.h" |
|||
|
|||
#define WIDTH 84 |
|||
#define HEIGHT 48 |
|||
#define PAGE_HEIGHT 8 |
|||
|
|||
|
|||
static const uint8_t u8g_dev_tls8204_init_seq[] PROGMEM = { |
|||
U8G_ESC_CS(0), /* disable chip */ |
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
U8G_ESC_RST(1), /* do reset low pulse with (1*16)+2 milliseconds */ |
|||
U8G_ESC_CS(1), /* enable chip */ |
|||
0x021, /* activate chip (PD=0), horizontal increment (V=0), enter extended command set (H=1) */ |
|||
0x006, /* temp. control: b10 = 2 */ |
|||
0x04 | !!((66-1)&(1u<<6)), |
|||
0x40 | ((66-2) & ((1u<<6)-1)), |
|||
0x013, /* bias system 1:48 */ |
|||
0x0c0, /* medium Vop */ |
|||
0x020, /* activate chip (PD=0), horizontal increment (V=0), enter normal command set (H=0) */ |
|||
0x00c, /* display on, normal operation */ |
|||
U8G_ESC_DLY(100), /* delay 100 ms */ |
|||
0x020, /* activate chip (PD=0), horizontal increment (V=0), enter normal command set (H=0) */ |
|||
0x00d, /* display on, invert */ |
|||
U8G_ESC_DLY(100), /* delay 100 ms */ |
|||
U8G_ESC_DLY(100), /* delay 100 ms */ |
|||
0x020, /* activate chip (PD=0), horizontal increment (V=0), enter normal command set (H=0) */ |
|||
0x00c, /* display on, normal */ |
|||
U8G_ESC_DLY(100), /* delay 100 ms */ |
|||
U8G_ESC_CS(0), /* disable chip */ |
|||
U8G_ESC_END /* end of sequence */ |
|||
}; |
|||
|
|||
|
|||
uint8_t u8g_dev_tls8204_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg) |
|||
{ |
|||
switch(msg) |
|||
{ |
|||
case U8G_DEV_MSG_INIT: |
|||
u8g_InitCom(u8g, dev); |
|||
u8g_WriteEscSeqP(u8g, dev, u8g_dev_tls8204_init_seq); |
|||
break; |
|||
case U8G_DEV_MSG_STOP: |
|||
break; |
|||
case U8G_DEV_MSG_PAGE_NEXT: |
|||
{ |
|||
u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem); |
|||
u8g_SetAddress(u8g, dev, 0); /* command mode */ |
|||
u8g_SetChipSelect(u8g, dev, 1); |
|||
u8g_WriteByte(u8g, dev, 0x020 ); /* activate chip (PD=0), horizontal increment (V=0), enter normal command set (H=0) */ |
|||
u8g_WriteByte(u8g, dev, 0x080 ); /* set X address */ |
|||
u8g_WriteByte(u8g, dev, 0x040 | pb->p.page); /* set Y address */ |
|||
u8g_SetAddress(u8g, dev, 1); /* data mode */ |
|||
if ( u8g_pb_WriteBuffer(pb, u8g, dev) == 0 ) |
|||
return 0; |
|||
u8g_SetChipSelect(u8g, dev, 0); |
|||
} |
|||
break; |
|||
case U8G_DEV_MSG_CONTRAST: |
|||
/* the contrast adjustment does not work, needs to be analysed */ |
|||
u8g_SetAddress(u8g, dev, 0); /* instruction mode */ |
|||
u8g_SetChipSelect(u8g, dev, 1); |
|||
u8g_WriteByte(u8g, dev, 0x021); /* command mode, extended function set */ |
|||
u8g_WriteByte(u8g, dev, 0x080 | ( (*(uint8_t *)arg) >> 1 ) ); |
|||
u8g_WriteByte(u8g, dev, 0x020); /* command mode, extended function set */ |
|||
u8g_SetChipSelect(u8g, dev, 0); |
|||
return 1; |
|||
} |
|||
return u8g_dev_pb8v1_base_fn(u8g, dev, msg, arg); |
|||
} |
|||
|
|||
|
|||
U8G_PB_DEV(u8g_dev_tls8204_84x48_sw_spi , WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_tls8204_fn, U8G_COM_SW_SPI); |
|||
|
|||
@ -0,0 +1,290 @@ |
|||
/*
|
|||
|
|||
u8g_dev_uc1610_dogxl160.c |
|||
|
|||
Universal 8bit Graphics Library |
|||
|
|||
Copyright (c) 2011, olikraus@gmail.com |
|||
All rights reserved. |
|||
|
|||
Redistribution and use in source and binary forms, with or without modification, |
|||
are permitted provided that the following conditions are met: |
|||
|
|||
* Redistributions of source code must retain the above copyright notice, this list |
|||
of conditions and the following disclaimer. |
|||
|
|||
* Redistributions in binary form must reproduce the above copyright notice, this |
|||
list of conditions and the following disclaimer in the documentation and/or other |
|||
materials provided with the distribution. |
|||
|
|||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
|||
CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
|||
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
|||
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
|||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
|||
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
|||
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
|||
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
|||
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
|||
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF |
|||
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|||
|
|||
|
|||
*/ |
|||
|
|||
#include "u8g.h" |
|||
|
|||
#define WIDTH 160 |
|||
#define HEIGHT 104 |
|||
|
|||
static const uint8_t u8g_dev_uc1610_dogxl160_init_seq[] PROGMEM = { |
|||
U8G_ESC_CS(0), /* disable chip */ |
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
U8G_ESC_RST(1), /* do reset low pulse with (1*16)+2 milliseconds */ |
|||
U8G_ESC_CS(1), /* enable chip */ |
|||
0x0f1, /* set display height-1 */ |
|||
0x067, /* */ |
|||
0x0c0, /* SEG & COM normal */ |
|||
0x040, /* set display start line */ |
|||
0x050, /* */ |
|||
0x02b, /* set panelloading */ |
|||
0x0eb, /* set bias 1/2 */ |
|||
0x081, /* set contrast */ |
|||
0x05f, /* */ |
|||
0x089, /* set auto increment */ |
|||
0x0a6, /* normal pixel mode */ |
|||
0x0d3, /* 0xd3=40% RMS separation for gray levels */ |
|||
0x0af, /* display on */ |
|||
U8G_ESC_DLY(100), /* delay 100 ms */ |
|||
0x0a5, /* display all points, ST7565, UC1610 */ |
|||
U8G_ESC_DLY(100), /* delay 100 ms */ |
|||
U8G_ESC_DLY(100), /* delay 100 ms */ |
|||
0x0a4, /* normal display */ |
|||
|
|||
|
|||
U8G_ESC_CS(0), /* disable chip */ |
|||
U8G_ESC_END /* end of sequence */ |
|||
}; |
|||
|
|||
static const uint8_t u8g_dev_uc1610_dogxl160_data_start[] PROGMEM = { |
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
U8G_ESC_CS(1), /* enable chip */ |
|||
0x010, /* set upper 4 bit of the col adr to 0 */ |
|||
0x000, /* set lower 4 bit of the col adr to 0 */ |
|||
U8G_ESC_END /* end of sequence */ |
|||
}; |
|||
|
|||
static uint8_t u8g_dev_1to2(uint8_t n) |
|||
{ |
|||
register uint8_t a,b,c; |
|||
a = n; |
|||
a &= 1; |
|||
n <<= 1; |
|||
b = n; |
|||
b &= 4; |
|||
n <<= 1; |
|||
c = n; |
|||
c &= 16; |
|||
n <<= 1; |
|||
n &= 64; |
|||
n |= a; |
|||
n |= b; |
|||
n |= c; |
|||
n |= n << 1; |
|||
return n; |
|||
} |
|||
|
|||
uint8_t u8g_dev_uc1610_dogxl160_bw_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg) |
|||
{ |
|||
switch(msg) |
|||
{ |
|||
case U8G_DEV_MSG_INIT: |
|||
u8g_InitCom(u8g, dev); |
|||
u8g_WriteEscSeqP(u8g, dev, u8g_dev_uc1610_dogxl160_init_seq); |
|||
break; |
|||
case U8G_DEV_MSG_STOP: |
|||
break; |
|||
case U8G_DEV_MSG_PAGE_NEXT: |
|||
{ |
|||
int i; |
|||
u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem); |
|||
u8g_WriteEscSeqP(u8g, dev, u8g_dev_uc1610_dogxl160_data_start); |
|||
u8g_WriteByte(u8g, dev, 0x060 | (pb->p.page*2) ); /* select current page 1/2 (UC1610) */ |
|||
u8g_SetAddress(u8g, dev, 1); /* data mode */ |
|||
for( i = 0; i < WIDTH; i++ ) |
|||
{ |
|||
u8g_WriteByte(u8g, dev, u8g_dev_1to2( ((uint8_t *)(pb->buf))[i] ) ); |
|||
} |
|||
|
|||
u8g_WriteEscSeqP(u8g, dev, u8g_dev_uc1610_dogxl160_data_start); |
|||
u8g_WriteByte(u8g, dev, 0x060 | (pb->p.page*2+1) ); /* select current page 2/2 (UC1610) */ |
|||
u8g_SetAddress(u8g, dev, 1); /* data mode */ |
|||
for( i = 0; i < WIDTH; i++ ) |
|||
{ |
|||
u8g_WriteByte(u8g, dev, u8g_dev_1to2( ((uint8_t *)(pb->buf))[i] >> 4 ) ); |
|||
} |
|||
|
|||
u8g_SetChipSelect(u8g, dev, 0); |
|||
} |
|||
break; |
|||
case U8G_DEV_MSG_CONTRAST: |
|||
u8g_SetChipSelect(u8g, dev, 1); |
|||
u8g_SetAddress(u8g, dev, 0); /* instruction mode */ |
|||
u8g_WriteByte(u8g, dev, 0x081); |
|||
u8g_WriteByte(u8g, dev, (*(uint8_t *)arg) >> 1); |
|||
u8g_SetChipSelect(u8g, dev, 0); |
|||
return 1; |
|||
} |
|||
return u8g_dev_pb8v1_base_fn(u8g, dev, msg, arg); |
|||
} |
|||
|
|||
uint8_t u8g_dev_uc1610_dogxl160_gr_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg) |
|||
{ |
|||
switch(msg) |
|||
{ |
|||
case U8G_DEV_MSG_INIT: |
|||
u8g_InitCom(u8g, dev); |
|||
u8g_WriteEscSeqP(u8g, dev, u8g_dev_uc1610_dogxl160_init_seq); |
|||
break; |
|||
case U8G_DEV_MSG_STOP: |
|||
break; |
|||
case U8G_DEV_MSG_PAGE_NEXT: |
|||
{ |
|||
u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem); |
|||
u8g_WriteEscSeqP(u8g, dev, u8g_dev_uc1610_dogxl160_data_start); |
|||
u8g_WriteByte(u8g, dev, 0x060 | (pb->p.page) ); /* select current page (UC1610) */ |
|||
u8g_SetAddress(u8g, dev, 1); /* data mode */ |
|||
if ( u8g_pb_WriteBuffer(pb, u8g, dev) == 0 ) |
|||
return 0; |
|||
u8g_SetChipSelect(u8g, dev, 0); |
|||
} |
|||
break; |
|||
case U8G_DEV_MSG_CONTRAST: |
|||
u8g_SetChipSelect(u8g, dev, 1); |
|||
u8g_SetAddress(u8g, dev, 0); /* instruction mode */ |
|||
u8g_WriteByte(u8g, dev, 0x081); |
|||
u8g_WriteByte(u8g, dev, (*(uint8_t *)arg) >> 1); |
|||
u8g_SetChipSelect(u8g, dev, 0); |
|||
return 1; |
|||
} |
|||
return u8g_dev_pb8v2_base_fn(u8g, dev, msg, arg); |
|||
} |
|||
|
|||
uint8_t u8g_dev_uc1610_dogxl160_2x_bw_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg) |
|||
{ |
|||
switch(msg) |
|||
{ |
|||
case U8G_DEV_MSG_INIT: |
|||
u8g_InitCom(u8g, dev); |
|||
u8g_WriteEscSeqP(u8g, dev, u8g_dev_uc1610_dogxl160_init_seq); |
|||
break; |
|||
case U8G_DEV_MSG_STOP: |
|||
break; |
|||
case U8G_DEV_MSG_PAGE_NEXT: |
|||
{ |
|||
int i; |
|||
u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem); |
|||
|
|||
u8g_WriteEscSeqP(u8g, dev, u8g_dev_uc1610_dogxl160_data_start); |
|||
u8g_WriteByte(u8g, dev, 0x060 | (pb->p.page*4) ); /* select current page 1/2 (UC1610) */ |
|||
u8g_SetAddress(u8g, dev, 1); /* data mode */ |
|||
for( i = 0; i < WIDTH; i++ ) |
|||
{ |
|||
u8g_WriteByte(u8g, dev, u8g_dev_1to2( ((uint8_t *)(pb->buf))[i] ) ); |
|||
} |
|||
|
|||
u8g_WriteEscSeqP(u8g, dev, u8g_dev_uc1610_dogxl160_data_start); |
|||
u8g_WriteByte(u8g, dev, 0x060 | (pb->p.page*4+1) ); /* select current page 2/2 (UC1610) */ |
|||
u8g_SetAddress(u8g, dev, 1); /* data mode */ |
|||
for( i = 0; i < WIDTH; i++ ) |
|||
{ |
|||
u8g_WriteByte(u8g, dev, u8g_dev_1to2( ((uint8_t *)(pb->buf))[i] >> 4 ) ); |
|||
} |
|||
|
|||
u8g_WriteEscSeqP(u8g, dev, u8g_dev_uc1610_dogxl160_data_start); |
|||
u8g_WriteByte(u8g, dev, 0x060 | (pb->p.page*4+2) ); /* select current page 1/2 (UC1610) */ |
|||
u8g_SetAddress(u8g, dev, 1); /* data mode */ |
|||
for( i = 0; i < WIDTH; i++ ) |
|||
{ |
|||
u8g_WriteByte(u8g, dev, u8g_dev_1to2( ((uint8_t *)(pb->buf+WIDTH))[i] ) ); |
|||
} |
|||
|
|||
u8g_WriteEscSeqP(u8g, dev, u8g_dev_uc1610_dogxl160_data_start); |
|||
u8g_WriteByte(u8g, dev, 0x060 | (pb->p.page*4+3) ); /* select current page 2/2 (UC1610) */ |
|||
u8g_SetAddress(u8g, dev, 1); /* data mode */ |
|||
for( i = 0; i < WIDTH; i++ ) |
|||
{ |
|||
u8g_WriteByte(u8g, dev, u8g_dev_1to2( ((uint8_t *)(pb->buf+WIDTH))[i] >> 4 ) ); |
|||
} |
|||
|
|||
u8g_SetChipSelect(u8g, dev, 0); |
|||
} |
|||
break; |
|||
case U8G_DEV_MSG_CONTRAST: |
|||
u8g_SetChipSelect(u8g, dev, 1); |
|||
u8g_SetAddress(u8g, dev, 0); /* instruction mode */ |
|||
u8g_WriteByte(u8g, dev, 0x081); |
|||
u8g_WriteByte(u8g, dev, (*(uint8_t *)arg) >> 1); |
|||
u8g_SetChipSelect(u8g, dev, 0); |
|||
return 1; |
|||
} |
|||
return u8g_dev_pb16v1_base_fn(u8g, dev, msg, arg); |
|||
} |
|||
|
|||
uint8_t u8g_dev_uc1610_dogxl160_2x_gr_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg) |
|||
{ |
|||
switch(msg) |
|||
{ |
|||
case U8G_DEV_MSG_INIT: |
|||
u8g_InitCom(u8g, dev); |
|||
u8g_WriteEscSeqP(u8g, dev, u8g_dev_uc1610_dogxl160_init_seq); |
|||
break; |
|||
case U8G_DEV_MSG_STOP: |
|||
break; |
|||
case U8G_DEV_MSG_PAGE_NEXT: |
|||
{ |
|||
u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem); |
|||
|
|||
u8g_WriteEscSeqP(u8g, dev, u8g_dev_uc1610_dogxl160_data_start); |
|||
u8g_WriteByte(u8g, dev, 0x060 | (pb->p.page*2) ); /* select current page (UC1610) */ |
|||
u8g_SetAddress(u8g, dev, 1); /* data mode */ |
|||
if ( u8g_WriteSequence(u8g, dev, WIDTH, pb->buf) == 0 ) |
|||
return 0; |
|||
|
|||
u8g_WriteEscSeqP(u8g, dev, u8g_dev_uc1610_dogxl160_data_start); |
|||
u8g_WriteByte(u8g, dev, 0x060 | (pb->p.page*2+1) ); /* select current page (UC1610) */ |
|||
u8g_SetAddress(u8g, dev, 1); /* data mode */ |
|||
if ( u8g_WriteSequence(u8g, dev, WIDTH, pb->buf+WIDTH) == 0 ) |
|||
return 0; |
|||
|
|||
u8g_SetChipSelect(u8g, dev, 0); |
|||
} |
|||
break; |
|||
case U8G_DEV_MSG_CONTRAST: |
|||
u8g_SetChipSelect(u8g, dev, 1); |
|||
u8g_SetAddress(u8g, dev, 0); /* instruction mode */ |
|||
u8g_WriteByte(u8g, dev, 0x081); |
|||
u8g_WriteByte(u8g, dev, (*(uint8_t *)arg) >> 1); |
|||
u8g_SetChipSelect(u8g, dev, 0); |
|||
return 1; |
|||
} |
|||
return u8g_dev_pb16v2_base_fn(u8g, dev, msg, arg); |
|||
} |
|||
|
|||
U8G_PB_DEV(u8g_dev_uc1610_dogxl160_bw_sw_spi, WIDTH, HEIGHT, 8, u8g_dev_uc1610_dogxl160_bw_fn, U8G_COM_SW_SPI); |
|||
U8G_PB_DEV(u8g_dev_uc1610_dogxl160_bw_hw_spi, WIDTH, HEIGHT, 8, u8g_dev_uc1610_dogxl160_bw_fn, U8G_COM_HW_SPI); |
|||
|
|||
U8G_PB_DEV(u8g_dev_uc1610_dogxl160_gr_sw_spi, WIDTH, HEIGHT, 4, u8g_dev_uc1610_dogxl160_gr_fn, U8G_COM_SW_SPI); |
|||
U8G_PB_DEV(u8g_dev_uc1610_dogxl160_gr_hw_spi, WIDTH, HEIGHT, 4, u8g_dev_uc1610_dogxl160_gr_fn, U8G_COM_HW_SPI); |
|||
|
|||
uint8_t u8g_dev_uc1610_dogxl160_2x_bw_buf[WIDTH*2] U8G_NOCOMMON ; |
|||
u8g_pb_t u8g_dev_uc1610_dogxl160_2x_bw_pb = { {16, HEIGHT, 0, 0, 0}, WIDTH, u8g_dev_uc1610_dogxl160_2x_bw_buf}; |
|||
u8g_dev_t u8g_dev_uc1610_dogxl160_2x_bw_sw_spi = { u8g_dev_uc1610_dogxl160_2x_bw_fn, &u8g_dev_uc1610_dogxl160_2x_bw_pb, U8G_COM_SW_SPI }; |
|||
u8g_dev_t u8g_dev_uc1610_dogxl160_2x_bw_hw_spi = { u8g_dev_uc1610_dogxl160_2x_bw_fn, &u8g_dev_uc1610_dogxl160_2x_bw_pb, U8G_COM_HW_SPI }; |
|||
|
|||
uint8_t u8g_dev_uc1610_dogxl160_2x_gr_buf[WIDTH*2] U8G_NOCOMMON ; |
|||
u8g_pb_t u8g_dev_uc1610_dogxl160_2x_gr_pb = { {8, HEIGHT, 0, 0, 0}, WIDTH, u8g_dev_uc1610_dogxl160_2x_gr_buf}; |
|||
u8g_dev_t u8g_dev_uc1610_dogxl160_2x_gr_sw_spi = { u8g_dev_uc1610_dogxl160_2x_gr_fn, &u8g_dev_uc1610_dogxl160_2x_gr_pb, U8G_COM_SW_SPI }; |
|||
u8g_dev_t u8g_dev_uc1610_dogxl160_2x_gr_hw_spi = { u8g_dev_uc1610_dogxl160_2x_gr_fn, &u8g_dev_uc1610_dogxl160_2x_gr_pb, U8G_COM_HW_SPI }; |
|||
@ -0,0 +1,113 @@ |
|||
/*
|
|||
|
|||
u8g_dev_uc1701_dogs102.c |
|||
|
|||
Universal 8bit Graphics Library |
|||
|
|||
Copyright (c) 2011, olikraus@gmail.com |
|||
All rights reserved. |
|||
|
|||
Redistribution and use in source and binary forms, with or without modification, |
|||
are permitted provided that the following conditions are met: |
|||
|
|||
* Redistributions of source code must retain the above copyright notice, this list |
|||
of conditions and the following disclaimer. |
|||
|
|||
* Redistributions in binary form must reproduce the above copyright notice, this |
|||
list of conditions and the following disclaimer in the documentation and/or other |
|||
materials provided with the distribution. |
|||
|
|||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
|||
CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
|||
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
|||
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
|||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
|||
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
|||
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
|||
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
|||
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
|||
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF |
|||
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|||
|
|||
|
|||
*/ |
|||
|
|||
#include "u8g.h" |
|||
|
|||
#define WIDTH 102 |
|||
#define HEIGHT 64 |
|||
#define PAGE_HEIGHT 8 |
|||
|
|||
static const uint8_t u8g_dev_dogs102_init_seq[] PROGMEM = { |
|||
U8G_ESC_CS(0), /* disable chip */ |
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
U8G_ESC_RST(1), /* do reset low pulse with (1*16)+2 milliseconds */ |
|||
U8G_ESC_CS(1), /* enable chip */ |
|||
0x040, /* set display start line to 0 */ |
|||
0x0a1, /* ADC set to reverse */ |
|||
0x0c0, /* common output mode */ |
|||
0x0a6, /* display normal, bit val 0: LCD pixel off. */ |
|||
0x0a2, /* LCD bias 1/9 */ |
|||
0x02f, /* all power control circuits on */ |
|||
0x027, /* regulator, booster and follower */ |
|||
0x081, /* set contrast */ |
|||
0x00e, /* contrast value, EA default: 0x010, previous value for S102: 0x0e */ |
|||
0x0fa, /* Set Temp compensation */ |
|||
0x090, /* 0.11 deg/c WP Off WC Off*/ |
|||
0x0a4, /* normal display */ |
|||
0x0af, /* display on */ |
|||
U8G_ESC_DLY(100), /* delay 100 ms */ |
|||
0x0a5, /* display all points, ST7565, UC1610 */ |
|||
U8G_ESC_DLY(100), /* delay 100 ms */ |
|||
U8G_ESC_DLY(100), /* delay 100 ms */ |
|||
0x0a4, /* normal display */ |
|||
U8G_ESC_CS(0), /* disable chip */ |
|||
U8G_ESC_END /* end of sequence */ |
|||
}; |
|||
|
|||
static const uint8_t u8g_dev_dogs102_data_start[] PROGMEM = { |
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
U8G_ESC_CS(1), /* enable chip */ |
|||
0x010, /* set upper 4 bit of the col adr to 0 */ |
|||
0x000, /* set lower 4 bit of the col adr to 0 */ |
|||
U8G_ESC_END /* end of sequence */ |
|||
}; |
|||
|
|||
uint8_t u8g_dev_dogs102_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg) |
|||
{ |
|||
switch(msg) |
|||
{ |
|||
case U8G_DEV_MSG_INIT: |
|||
u8g_InitCom(u8g, dev); |
|||
u8g_WriteEscSeqP(u8g, dev, u8g_dev_dogs102_init_seq); |
|||
break; |
|||
case U8G_DEV_MSG_STOP: |
|||
break; |
|||
case U8G_DEV_MSG_PAGE_NEXT: |
|||
{ |
|||
u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem); |
|||
u8g_WriteEscSeqP(u8g, dev, u8g_dev_dogs102_data_start); |
|||
u8g_WriteByte(u8g, dev, 0x0b0 | pb->p.page); /* select current page (ST7565R) */ |
|||
u8g_SetAddress(u8g, dev, 1); /* data mode */ |
|||
if ( u8g_pb_WriteBuffer(pb, u8g, dev) == 0 ) |
|||
return 0; |
|||
u8g_SetChipSelect(u8g, dev, 0); |
|||
} |
|||
break; |
|||
case U8G_DEV_MSG_CONTRAST: |
|||
u8g_SetChipSelect(u8g, dev, 1); |
|||
u8g_SetAddress(u8g, dev, 0); /* instruction mode */ |
|||
u8g_WriteByte(u8g, dev, 0x081); |
|||
u8g_WriteByte(u8g, dev, (*(uint8_t *)arg) >> 2); |
|||
u8g_SetChipSelect(u8g, dev, 0); |
|||
return 1; |
|||
} |
|||
return u8g_dev_pb8v1_base_fn(u8g, dev, msg, arg); |
|||
} |
|||
|
|||
U8G_PB_DEV(u8g_dev_uc1701_dogs102_sw_spi , WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_dogs102_fn, U8G_COM_SW_SPI); |
|||
U8G_PB_DEV(u8g_dev_uc1701_dogs102_hw_spi , WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_dogs102_fn, U8G_COM_HW_SPI); |
|||
|
|||
|
|||
@ -0,0 +1,114 @@ |
|||
/*
|
|||
|
|||
u8g_dev_uc1701_mini12864.c (dealextreme) |
|||
|
|||
Universal 8bit Graphics Library |
|||
|
|||
Copyright (c) 2011, olikraus@gmail.com |
|||
All rights reserved. |
|||
|
|||
Redistribution and use in source and binary forms, with or without modification, |
|||
are permitted provided that the following conditions are met: |
|||
|
|||
* Redistributions of source code must retain the above copyright notice, this list |
|||
of conditions and the following disclaimer. |
|||
|
|||
* Redistributions in binary form must reproduce the above copyright notice, this |
|||
list of conditions and the following disclaimer in the documentation and/or other |
|||
materials provided with the distribution. |
|||
|
|||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
|||
CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
|||
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
|||
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
|||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
|||
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
|||
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
|||
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
|||
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
|||
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF |
|||
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|||
|
|||
|
|||
*/ |
|||
|
|||
#include "u8g.h" |
|||
|
|||
#define WIDTH 128 |
|||
#define HEIGHT 64 |
|||
#define PAGE_HEIGHT 8 |
|||
|
|||
static const uint8_t u8g_dev_uc1701_mini12864_init_seq[] PROGMEM = { |
|||
U8G_ESC_CS(0), /* disable chip */ |
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
U8G_ESC_RST(1), /* do reset low pulse with (1*16)+2 milliseconds */ |
|||
U8G_ESC_CS(1), /* enable chip */ |
|||
|
|||
0x040, /* set display start line to 0 */ |
|||
0x0a0, /* ADC set to reverse */ |
|||
0x0c8, /* common output mode */ |
|||
0x0a6, /* display normal, bit val 0: LCD pixel off. */ |
|||
0x0a2, /* LCD bias 1/9 */ |
|||
0x02f, /* all power control circuits on */ |
|||
0x0f8, /* set booster ratio to */ |
|||
0x000, /* 4x */ |
|||
0x023, /* set V0 voltage resistor ratio to large */ |
|||
0x081, /* set contrast */ |
|||
0x027, /* contrast value */ |
|||
0x0ac, /* indicator */ |
|||
0x000, /* disable */ |
|||
0x0af, /* display on */ |
|||
|
|||
U8G_ESC_DLY(100), /* delay 100 ms */ |
|||
0x0a5, /* display all points, ST7565 */ |
|||
U8G_ESC_DLY(100), /* delay 100 ms */ |
|||
U8G_ESC_DLY(100), /* delay 100 ms */ |
|||
0x0a4, /* normal display */ |
|||
U8G_ESC_CS(0), /* disable chip */ |
|||
U8G_ESC_END /* end of sequence */ |
|||
}; |
|||
|
|||
static const uint8_t u8g_dev_uc1701_mini12864_data_start[] PROGMEM = { |
|||
U8G_ESC_ADR(0), /* instruction mode */ |
|||
U8G_ESC_CS(1), /* enable chip */ |
|||
0x010, /* set upper 4 bit of the col adr to 0 */ |
|||
0x000, /* set lower 4 bit of the col adr to 4 */ |
|||
U8G_ESC_END /* end of sequence */ |
|||
}; |
|||
|
|||
uint8_t u8g_dev_uc1701_mini12864_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg) |
|||
{ |
|||
switch(msg) |
|||
{ |
|||
case U8G_DEV_MSG_INIT: |
|||
u8g_InitCom(u8g, dev); |
|||
u8g_WriteEscSeqP(u8g, dev, u8g_dev_uc1701_mini12864_init_seq); |
|||
break; |
|||
case U8G_DEV_MSG_STOP: |
|||
break; |
|||
case U8G_DEV_MSG_PAGE_NEXT: |
|||
{ |
|||
u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem); |
|||
u8g_WriteEscSeqP(u8g, dev, u8g_dev_uc1701_mini12864_data_start); |
|||
u8g_WriteByte(u8g, dev, 0x0b0 | pb->p.page); /* select current page */ |
|||
u8g_SetAddress(u8g, dev, 1); /* data mode */ |
|||
if ( u8g_pb_WriteBuffer(pb, u8g, dev) == 0 ) |
|||
return 0; |
|||
u8g_SetChipSelect(u8g, dev, 0); |
|||
} |
|||
break; |
|||
case U8G_DEV_MSG_CONTRAST: |
|||
u8g_SetChipSelect(u8g, dev, 1); |
|||
u8g_SetAddress(u8g, dev, 0); /* instruction mode */ |
|||
u8g_WriteByte(u8g, dev, 0x081); |
|||
u8g_WriteByte(u8g, dev, (*(uint8_t *)arg) >> 2); |
|||
u8g_SetChipSelect(u8g, dev, 0); |
|||
return 1; |
|||
} |
|||
return u8g_dev_pb8v1_base_fn(u8g, dev, msg, arg); |
|||
} |
|||
|
|||
U8G_PB_DEV(u8g_dev_uc1701_mini12864_sw_spi, WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_uc1701_mini12864_fn, U8G_COM_SW_SPI); |
|||
U8G_PB_DEV(u8g_dev_uc1701_mini12864_hw_spi, WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_uc1701_mini12864_fn, U8G_COM_HW_SPI); |
|||
@ -0,0 +1,100 @@ |
|||
/*
|
|||
|
|||
u8g_ellipse.c |
|||
|
|||
Utility to draw empty and filled ellipses. |
|||
|
|||
Universal 8bit Graphics Library |
|||
|
|||
Copyright (c) 2011, bjthom@gmail.com |
|||
All rights reserved. |
|||
|
|||
Redistribution and use in source and binary forms, with or without modification, |
|||
are permitted provided that the following conditions are met: |
|||
|
|||
* Redistributions of source code must retain the above copyright notice, this list |
|||
of conditions and the following disclaimer. |
|||
|
|||
* Redistributions in binary form must reproduce the above copyright notice, this |
|||
list of conditions and the following disclaimer in the documentation and/or other |
|||
materials provided with the distribution. |
|||
|
|||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
|||
CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
|||
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
|||
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
|||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
|||
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
|||
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
|||
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
|||
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
|||
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF |
|||
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|||
|
|||
Addition to the U8G Library as of 02/29/12 |
|||
Adapted from Bresenham's Algorithm and the following websites: |
|||
http://free.pages.at/easyfilter/bresenham.html
|
|||
http://homepage.smc.edu/kennedy_john/belipse.pdf
|
|||
|
|||
*/ |
|||
|
|||
#include "u8g.h" |
|||
|
|||
|
|||
#ifdef WORK_IN_PROGRESS |
|||
|
|||
void u8g_DrawEllipseRect(u8g_t *u8g, u8g_uint_t x0, u8g_uint_t y0, u8g_uint_t x1, u8g_uint_t y1) |
|||
{ |
|||
int a = abs(x1 - x0); |
|||
int b = abs(y1 - y0); //get diameters
|
|||
int b1 = b&1; |
|||
long dx = 4*(1-a)*b*b; |
|||
long dy = 4*(b1+1)*a*a; |
|||
long err = dx+dy+b1*a*a; |
|||
long e2; |
|||
|
|||
if (x0 > x1) { x0 = x1; x1 += a; } |
|||
if (y0 > y1) { y0 = y1; } |
|||
y0 += (b+1)/2; |
|||
y1 = y0-b1; |
|||
a *= 8*a; |
|||
b1 = 8*b*b; |
|||
|
|||
do { |
|||
u8g_DrawPixel(u8g, x1, y0); |
|||
u8g_DrawPixel(u8g, x0, y0); |
|||
u8g_DrawPixel(u8g, x0, y1); |
|||
u8g_DrawPixel(u8g, x1, y1); |
|||
e2 = 2*err; |
|||
if (e2 >= dx) { |
|||
x0++; |
|||
x1--; |
|||
err += dx += b1; |
|||
} |
|||
if (e2 <= dy) { |
|||
y0++; |
|||
y1--; |
|||
err += dy += a; |
|||
} |
|||
} while (x0 <= x1); |
|||
|
|||
while (y0-y1 < b) { |
|||
u8g_DrawPixel(u8g, x0-1, y0); |
|||
u8g_DrawPixel(u8g, x1+1, y0++); |
|||
u8g_DrawPixel(u8g, x0-1, y1); |
|||
u8g_DrawPixel(u8g, x1+1, y1--); |
|||
} |
|||
} |
|||
|
|||
void u8g_DrawEllipse(u8g_t *u8g, u8g_uint_t x0, u8g_uint_t y0, u8g_uint_t xr, u8g_uint_t yr) |
|||
{ |
|||
u8g_DrawPixel(u8g, x0, y0+yr); |
|||
u8g_DrawPixel(u8g, x0, y0-yr); |
|||
u8g_DrawPixel(u8g, x0+xr, y0); |
|||
u8g_DrawPixel(u8g, x0-xr, y0); |
|||
} |
|||
|
|||
#endif |
|||
|
|||
File diff suppressed because it is too large
File diff suppressed because it is too large
@ -0,0 +1,81 @@ |
|||
/*
|
|||
|
|||
u8g_line.h |
|||
|
|||
Universal 8bit Graphics Library |
|||
|
|||
Copyright (c) 2012, olikraus@gmail.com |
|||
All rights reserved. |
|||
|
|||
Redistribution and use in source and binary forms, with or without modification, |
|||
are permitted provided that the following conditions are met: |
|||
|
|||
* Redistributions of source code must retain the above copyright notice, this list |
|||
of conditions and the following disclaimer. |
|||
|
|||
* Redistributions in binary form must reproduce the above copyright notice, this |
|||
list of conditions and the following disclaimer in the documentation and/or other |
|||
materials provided with the distribution. |
|||
|
|||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
|||
CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
|||
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
|||
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
|||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
|||
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
|||
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
|||
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
|||
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
|||
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF |
|||
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|||
|
|||
*/ |
|||
|
|||
#include "u8g.h" |
|||
|
|||
void u8g_DrawLine(u8g_t *u8g, u8g_uint_t x1, u8g_uint_t y1, u8g_uint_t x2, u8g_uint_t y2) |
|||
{ |
|||
u8g_uint_t tmp; |
|||
u8g_uint_t x,y; |
|||
u8g_uint_t dx, dy; |
|||
u8g_int_t err; |
|||
u8g_int_t ystep; |
|||
|
|||
uint8_t swapxy = 0; |
|||
|
|||
/* no BBX intersection check at the moment, should be added... */ |
|||
|
|||
if ( x1 > x2 ) dx = x1-x2; else dx = x2-x1; |
|||
if ( y1 > y2 ) dy = y1-y2; else dy = y2-y1; |
|||
|
|||
if ( dy > dx ) |
|||
{ |
|||
swapxy = 1; |
|||
tmp = dx; dx =dy; dy = tmp; |
|||
tmp = x1; x1 =y1; y1 = tmp; |
|||
tmp = x2; x2 =y2; y2 = tmp; |
|||
} |
|||
if ( x1 > x2 ) |
|||
{ |
|||
tmp = x1; x1 =x2; x2 = tmp; |
|||
tmp = y1; y1 =y2; y2 = tmp; |
|||
} |
|||
err = dx >> 1; |
|||
if ( y2 > y1 ) ystep = 1; else ystep = -1; |
|||
y = y1; |
|||
for( x = x1; x <= x2; x++ ) |
|||
{ |
|||
if ( swapxy == 0 ) |
|||
u8g_DrawPixel(u8g, x, y); |
|||
else |
|||
u8g_DrawPixel(u8g, y, x); |
|||
err -= (uint8_t)dy; |
|||
if ( err < 0 ) |
|||
{ |
|||
y += (u8g_uint_t)ystep; |
|||
err += (u8g_uint_t)dx; |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,456 @@ |
|||
/*
|
|||
|
|||
u8g_ll_api.c |
|||
|
|||
low level api |
|||
|
|||
Universal 8bit Graphics Library |
|||
|
|||
Copyright (c) 2011, olikraus@gmail.com |
|||
All rights reserved. |
|||
|
|||
Redistribution and use in source and binary forms, with or without modification, |
|||
are permitted provided that the following conditions are met: |
|||
|
|||
* Redistributions of source code must retain the above copyright notice, this list |
|||
of conditions and the following disclaimer. |
|||
|
|||
* Redistributions in binary form must reproduce the above copyright notice, this |
|||
list of conditions and the following disclaimer in the documentation and/or other |
|||
materials provided with the distribution. |
|||
|
|||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
|||
CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
|||
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
|||
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
|||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
|||
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
|||
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
|||
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
|||
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
|||
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF |
|||
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|||
|
|||
|
|||
*/ |
|||
|
|||
#include <stddef.h> |
|||
#include "u8g.h" |
|||
|
|||
uint8_t u8g_call_dev_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg) |
|||
{ |
|||
return dev->dev_fn(u8g, dev, msg, arg); |
|||
} |
|||
|
|||
/*====================================================================*/ |
|||
|
|||
uint8_t u8g_InitLL(u8g_t *u8g, u8g_dev_t *dev) |
|||
{ |
|||
uint8_t r; |
|||
u8g->state_cb(U8G_STATE_MSG_BACKUP_ENV); |
|||
r = u8g_call_dev_fn(u8g, dev, U8G_DEV_MSG_INIT, NULL); |
|||
u8g->state_cb(U8G_STATE_MSG_BACKUP_U8G); |
|||
u8g->state_cb(U8G_STATE_MSG_RESTORE_ENV); |
|||
return r; |
|||
} |
|||
|
|||
void u8g_FirstPageLL(u8g_t *u8g, u8g_dev_t *dev) |
|||
{ |
|||
u8g->state_cb(U8G_STATE_MSG_BACKUP_ENV); |
|||
u8g->state_cb(U8G_STATE_MSG_RESTORE_U8G); |
|||
u8g_call_dev_fn(u8g, dev, U8G_DEV_MSG_PAGE_FIRST, NULL); |
|||
u8g_call_dev_fn(u8g, dev, U8G_DEV_MSG_GET_PAGE_BOX, &(u8g->current_page)); |
|||
u8g->state_cb(U8G_STATE_MSG_RESTORE_ENV); |
|||
} |
|||
|
|||
uint8_t u8g_NextPageLL(u8g_t *u8g, u8g_dev_t *dev) |
|||
{ |
|||
uint8_t r; |
|||
u8g->state_cb(U8G_STATE_MSG_BACKUP_ENV); |
|||
u8g->state_cb(U8G_STATE_MSG_RESTORE_U8G); |
|||
r = u8g_call_dev_fn(u8g, dev, U8G_DEV_MSG_PAGE_NEXT, NULL); |
|||
if ( r != 0 ) |
|||
{ |
|||
u8g_call_dev_fn(u8g, dev, U8G_DEV_MSG_GET_PAGE_BOX, &(u8g->current_page)); |
|||
} |
|||
u8g->state_cb(U8G_STATE_MSG_RESTORE_ENV); |
|||
return r; |
|||
} |
|||
|
|||
uint8_t u8g_SetContrastLL(u8g_t *u8g, u8g_dev_t *dev, uint8_t contrast) |
|||
{ |
|||
return u8g_call_dev_fn(u8g, dev, U8G_DEV_MSG_CONTRAST, &contrast); |
|||
} |
|||
|
|||
void u8g_DrawPixelLL(u8g_t *u8g, u8g_dev_t *dev, u8g_uint_t x, u8g_uint_t y) |
|||
{ |
|||
u8g_dev_arg_pixel_t *arg = &(u8g->arg_pixel); |
|||
arg->x = x; |
|||
arg->y = y; |
|||
u8g_call_dev_fn(u8g, dev, U8G_DEV_MSG_SET_PIXEL, arg); |
|||
} |
|||
|
|||
void u8g_Draw8PixelLL(u8g_t *u8g, u8g_dev_t *dev, u8g_uint_t x, u8g_uint_t y, uint8_t dir, uint8_t pixel) |
|||
{ |
|||
u8g_dev_arg_pixel_t *arg = &(u8g->arg_pixel); |
|||
arg->x = x; |
|||
arg->y = y; |
|||
arg->dir = dir; |
|||
arg->pixel = pixel; |
|||
u8g_call_dev_fn(u8g, dev, U8G_DEV_MSG_SET_8PIXEL, arg); |
|||
} |
|||
|
|||
#ifdef U8G_DEV_MSG_IS_BBX_INTERSECTION |
|||
uint8_t u8g_IsBBXIntersectionLL(u8g_t *u8g, u8g_dev_t *dev, u8g_uint_t x, u8g_uint_t y, u8g_uint_t w, u8g_uint_t h) |
|||
{ |
|||
return u8g_call_dev_fn(u8g, dev, U8G_DEV_MSG_IS_BBX_INTERSECTION, &arg); |
|||
} |
|||
#endif |
|||
|
|||
|
|||
|
|||
u8g_uint_t u8g_GetWidthLL(u8g_t *u8g, u8g_dev_t *dev) |
|||
{ |
|||
u8g_uint_t r; |
|||
u8g_call_dev_fn(u8g, dev, U8G_DEV_MSG_GET_WIDTH, &r); |
|||
return r; |
|||
} |
|||
|
|||
u8g_uint_t u8g_GetHeightLL(u8g_t *u8g, u8g_dev_t *dev) |
|||
{ |
|||
u8g_uint_t r; |
|||
u8g_call_dev_fn(u8g, dev, U8G_DEV_MSG_GET_HEIGHT, &r); |
|||
return r; |
|||
} |
|||
|
|||
u8g_uint_t u8g_GetModeLL(u8g_t *u8g, u8g_dev_t *dev) |
|||
{ |
|||
return u8g_call_dev_fn(u8g, dev, U8G_DEV_MSG_GET_MODE, NULL); |
|||
} |
|||
|
|||
|
|||
|
|||
/*====================================================================*/ |
|||
|
|||
void u8g_UpdateDimension(u8g_t *u8g) |
|||
{ |
|||
u8g->width = u8g_GetWidthLL(u8g, u8g->dev); |
|||
u8g->height = u8g_GetHeightLL(u8g, u8g->dev); |
|||
u8g->mode = u8g_GetModeLL(u8g, u8g->dev); |
|||
/* 9 Dec 2012: u8g_scale.c requires update of current page */ |
|||
u8g_call_dev_fn(u8g, u8g->dev, U8G_DEV_MSG_GET_PAGE_BOX, &(u8g->current_page)); |
|||
} |
|||
|
|||
static void u8g_init_data(u8g_t *u8g) |
|||
{ |
|||
uint8_t i; |
|||
u8g->font = NULL; |
|||
u8g->cursor_font = NULL; |
|||
u8g->cursor_bg_color = 0; |
|||
u8g->cursor_fg_color = 1; |
|||
u8g->cursor_encoding = 34; |
|||
u8g->cursor_fn = (u8g_draw_cursor_fn)0; |
|||
|
|||
for( i = 0; i < U8G_PIN_LIST_LEN; i++ ) |
|||
u8g->pin_list[i] = U8G_PIN_NONE; |
|||
|
|||
u8g_SetColorIndex(u8g, 1); |
|||
|
|||
u8g_SetFontPosBaseline(u8g); |
|||
|
|||
u8g->font_height_mode = U8G_FONT_HEIGHT_MODE_XTEXT; |
|||
u8g->font_ref_ascent = 0; |
|||
u8g->font_ref_descent = 0; |
|||
u8g->font_line_spacing_factor = 64; /* 64 = 1.0, 77 = 1.2 line spacing factor */ |
|||
u8g->line_spacing = 0; |
|||
|
|||
u8g->state_cb = u8g_state_dummy_cb; |
|||
|
|||
} |
|||
|
|||
uint8_t u8g_Begin(u8g_t *u8g) |
|||
{ |
|||
/* call and init low level driver and com device */ |
|||
if ( u8g_InitLL(u8g, u8g->dev) == 0 ) |
|||
return 0; |
|||
/* fetch width and height from the low level */ |
|||
u8g_UpdateDimension(u8g); |
|||
return 1; |
|||
} |
|||
|
|||
uint8_t u8g_Init(u8g_t *u8g, u8g_dev_t *dev) |
|||
{ |
|||
u8g_init_data(u8g); |
|||
u8g->dev = dev; |
|||
|
|||
/* On the Arduino Environment this will lead to two calls to u8g_Begin(), the following line will be called first (by U8glib constructors) */ |
|||
/* if - in future releases - this is removed, then still call u8g_UpdateDimension() */ |
|||
/* if Arduino call u8g_UpdateDimension else u8g_Begin */ |
|||
/* issue 146 */ |
|||
return u8g_Begin(u8g); |
|||
} |
|||
|
|||
uint8_t u8g_InitSPI(u8g_t *u8g, u8g_dev_t *dev, uint8_t sck, uint8_t mosi, uint8_t cs, uint8_t a0, uint8_t reset) |
|||
{ |
|||
|
|||
/* fill data structure with some suitable values */ |
|||
u8g_init_data(u8g); |
|||
u8g->dev = dev; |
|||
|
|||
/* assign user pins */ |
|||
u8g->pin_list[U8G_PI_SCK] = sck; |
|||
u8g->pin_list[U8G_PI_MOSI] = mosi; |
|||
u8g->pin_list[U8G_PI_CS] = cs; |
|||
u8g->pin_list[U8G_PI_A0] = a0; |
|||
u8g->pin_list[U8G_PI_RESET] = reset; |
|||
|
|||
/* On the Arduino Environment this will lead to two calls to u8g_Begin(), the following line will be called first (by U8glib constructors) */ |
|||
/* if - in future releases - this is removed, then still call u8g_UpdateDimension() */ |
|||
/* if Arduino call u8g_UpdateDimension else u8g_Begin */ |
|||
/* issue 146 */ |
|||
return u8g_Begin(u8g); |
|||
} |
|||
|
|||
uint8_t u8g_InitHWSPI(u8g_t *u8g, u8g_dev_t *dev, uint8_t cs, uint8_t a0, uint8_t reset) |
|||
{ |
|||
/* fill data structure with some suitable values */ |
|||
u8g_init_data(u8g); |
|||
u8g->dev = dev; |
|||
|
|||
|
|||
/* assign user pins */ |
|||
u8g->pin_list[U8G_PI_CS] = cs; |
|||
u8g->pin_list[U8G_PI_A0] = a0; |
|||
u8g->pin_list[U8G_PI_RESET] = reset; |
|||
|
|||
return u8g_Begin(u8g); |
|||
} |
|||
|
|||
uint8_t u8g_InitI2C(u8g_t *u8g, u8g_dev_t *dev, uint8_t options) |
|||
{ |
|||
/* fill data structure with some suitable values */ |
|||
u8g_init_data(u8g); |
|||
u8g->dev = dev; |
|||
|
|||
u8g->pin_list[U8G_PI_I2C_OPTION] = options; |
|||
|
|||
return u8g_Begin(u8g); |
|||
} |
|||
|
|||
|
|||
uint8_t u8g_Init8BitFixedPort(u8g_t *u8g, u8g_dev_t *dev, uint8_t en, uint8_t cs, uint8_t di, uint8_t rw, uint8_t reset) |
|||
{ |
|||
|
|||
/* fill data structure with some suitable values */ |
|||
u8g_init_data(u8g); |
|||
u8g->dev = dev; |
|||
|
|||
/* assign user pins */ |
|||
|
|||
u8g->pin_list[U8G_PI_EN] = en; |
|||
u8g->pin_list[U8G_PI_CS] = cs; |
|||
u8g->pin_list[U8G_PI_DI] = di; |
|||
u8g->pin_list[U8G_PI_RW] = rw; |
|||
u8g->pin_list[U8G_PI_RESET] = reset; |
|||
|
|||
return u8g_Begin(u8g); |
|||
} |
|||
|
|||
uint8_t u8g_Init8Bit(u8g_t *u8g, u8g_dev_t *dev, uint8_t d0, uint8_t d1, uint8_t d2, uint8_t d3, uint8_t d4, uint8_t d5, uint8_t d6, uint8_t d7, |
|||
uint8_t en, uint8_t cs1, uint8_t cs2, uint8_t di, uint8_t rw, uint8_t reset) |
|||
{ |
|||
|
|||
/* fill data structure with some suitable values */ |
|||
u8g_init_data(u8g); |
|||
u8g->dev = dev; |
|||
|
|||
/* assign user pins */ |
|||
|
|||
u8g->pin_list[U8G_PI_D0] = d0; |
|||
u8g->pin_list[U8G_PI_D1] = d1; |
|||
u8g->pin_list[U8G_PI_D2] = d2; |
|||
u8g->pin_list[U8G_PI_D3] = d3; |
|||
u8g->pin_list[U8G_PI_D4] = d4; |
|||
u8g->pin_list[U8G_PI_D5] = d5; |
|||
u8g->pin_list[U8G_PI_D6] = d6; |
|||
u8g->pin_list[U8G_PI_D7] = d7; |
|||
|
|||
u8g->pin_list[U8G_PI_EN] = en; |
|||
u8g->pin_list[U8G_PI_CS1] = cs1; |
|||
u8g->pin_list[U8G_PI_CS2] = cs2; |
|||
u8g->pin_list[U8G_PI_DI] = di; |
|||
u8g->pin_list[U8G_PI_RW] = rw; |
|||
u8g->pin_list[U8G_PI_RESET] = reset; |
|||
|
|||
return u8g_Begin(u8g); |
|||
} |
|||
|
|||
/*
|
|||
|
|||
PIN_D0 8 |
|||
PIN_D1 9 |
|||
PIN_D2 10 |
|||
PIN_D3 11 |
|||
PIN_D4 4 |
|||
PIN_D5 5 |
|||
PIN_D6 6 |
|||
PIN_D7 7 |
|||
|
|||
PIN_CS 14 |
|||
PIN_A0 15 |
|||
PIN_RESET 16 |
|||
PIN_WR 17 |
|||
PIN_RD 18 |
|||
|
|||
u8g_InitRW8Bit(u8g, dev, d0, d1, d2, d3, d4, d5, d6, d7, cs, a0, wr, rd, reset) |
|||
u8g_InitRW8Bit(u8g, dev, 8, 9, 10, 11, 4, 5, 6, 7, 14, 15, 17, 18, 16) |
|||
|
|||
*/ |
|||
|
|||
uint8_t u8g_InitRW8Bit(u8g_t *u8g, u8g_dev_t *dev, uint8_t d0, uint8_t d1, uint8_t d2, uint8_t d3, uint8_t d4, uint8_t d5, uint8_t d6, uint8_t d7, |
|||
uint8_t cs, uint8_t a0, uint8_t wr, uint8_t rd, uint8_t reset) |
|||
{ |
|||
|
|||
/* fill data structure with some suitable values */ |
|||
u8g_init_data(u8g); |
|||
u8g->dev = dev; |
|||
|
|||
/* assign user pins */ |
|||
|
|||
u8g->pin_list[U8G_PI_D0] = d0; |
|||
u8g->pin_list[U8G_PI_D1] = d1; |
|||
u8g->pin_list[U8G_PI_D2] = d2; |
|||
u8g->pin_list[U8G_PI_D3] = d3; |
|||
u8g->pin_list[U8G_PI_D4] = d4; |
|||
u8g->pin_list[U8G_PI_D5] = d5; |
|||
u8g->pin_list[U8G_PI_D6] = d6; |
|||
u8g->pin_list[U8G_PI_D7] = d7; |
|||
|
|||
u8g->pin_list[U8G_PI_CS] = cs; |
|||
u8g->pin_list[U8G_PI_A0] = a0; |
|||
u8g->pin_list[U8G_PI_WR] = wr; |
|||
u8g->pin_list[U8G_PI_RD] = rd; |
|||
u8g->pin_list[U8G_PI_RESET] = reset; |
|||
|
|||
return u8g_Begin(u8g); |
|||
} |
|||
|
|||
void u8g_FirstPage(u8g_t *u8g) |
|||
{ |
|||
u8g_FirstPageLL(u8g, u8g->dev); |
|||
} |
|||
|
|||
uint8_t u8g_NextPage(u8g_t *u8g) |
|||
{ |
|||
if ( u8g->cursor_fn != (u8g_draw_cursor_fn)0 ) |
|||
{ |
|||
u8g->cursor_fn(u8g); |
|||
} |
|||
return u8g_NextPageLL(u8g, u8g->dev); |
|||
} |
|||
|
|||
uint8_t u8g_SetContrast(u8g_t *u8g, uint8_t contrast) |
|||
{ |
|||
return u8g_SetContrastLL(u8g, u8g->dev, contrast); |
|||
} |
|||
|
|||
void u8g_SleepOn(u8g_t *u8g) |
|||
{ |
|||
u8g_call_dev_fn(u8g, u8g->dev, U8G_DEV_MSG_SLEEP_ON, NULL); |
|||
} |
|||
|
|||
void u8g_SleepOff(u8g_t *u8g) |
|||
{ |
|||
u8g_call_dev_fn(u8g, u8g->dev, U8G_DEV_MSG_SLEEP_OFF, NULL); |
|||
} |
|||
|
|||
|
|||
void u8g_DrawPixel(u8g_t *u8g, u8g_uint_t x, u8g_uint_t y) |
|||
{ |
|||
u8g_DrawPixelLL(u8g, u8g->dev, x, y); |
|||
} |
|||
|
|||
void u8g_Draw8Pixel(u8g_t *u8g, u8g_uint_t x, u8g_uint_t y, uint8_t dir, uint8_t pixel) |
|||
{ |
|||
u8g_Draw8PixelLL(u8g, u8g->dev, x, y, dir, pixel); |
|||
} |
|||
|
|||
/* u8g_IsBBXIntersection() has been moved to u8g_clip.c */ |
|||
#ifdef OBSOLETE_CODE |
|||
uint8_t u8g_IsBBXIntersection(u8g_t *u8g, u8g_uint_t x, u8g_uint_t y, u8g_uint_t w, u8g_uint_t h) |
|||
{ |
|||
/* new code */ |
|||
u8g_dev_arg_bbx_t arg; |
|||
arg.x = x; |
|||
arg.y = y; |
|||
arg.w = w; |
|||
arg.h = h; |
|||
return u8g_is_box_bbx_intersection(&(u8g->current_page), &arg); |
|||
|
|||
/* old code */ |
|||
//return u8g_IsBBXIntersectionLL(u8g, u8g->dev, x, y, w, h);
|
|||
} |
|||
#endif |
|||
|
|||
void u8g_SetColorIndex(u8g_t *u8g, uint8_t idx) |
|||
{ |
|||
u8g->arg_pixel.color = idx; |
|||
/*u8g->color_index = idx; */ /* must be removed */ |
|||
} |
|||
|
|||
uint8_t u8g_GetColorIndex(u8g_t *u8g) |
|||
{ |
|||
return u8g->arg_pixel.color; |
|||
} |
|||
|
|||
uint8_t u8g_GetDefaultForegroundColor(u8g_t *u8g) |
|||
{ |
|||
uint8_t mode; |
|||
mode = u8g_GetMode(u8g); |
|||
if ( mode == U8G_MODE_R3G3B2 ) |
|||
return 255; /* white */ |
|||
else if ( u8g_GetMode(u8g) == U8G_MODE_GRAY2BIT ) |
|||
return 3; /* max intensity */ |
|||
else /* if ( u8g.getMode() == U8G_MODE_BW ) */ |
|||
return 1; /* pixel on */ |
|||
return 1; |
|||
} |
|||
|
|||
void u8g_SetDefaultForegroundColor(u8g_t *u8g) |
|||
{ |
|||
u8g_SetColorIndex(u8g, u8g_GetDefaultForegroundColor(u8g)); |
|||
} |
|||
|
|||
uint8_t u8g_GetDefaultBackgroundColor(u8g_t *u8g) |
|||
{ |
|||
return 0; |
|||
} |
|||
|
|||
void u8g_SetDefaultBackgroundColor(u8g_t *u8g) |
|||
{ |
|||
u8g_SetColorIndex(u8g, u8g_GetDefaultBackgroundColor(u8g)); /* pixel on / black */ |
|||
} |
|||
|
|||
uint8_t u8g_GetDefaultMidColor(u8g_t *u8g) |
|||
{ |
|||
uint8_t mode; |
|||
mode = u8g_GetMode(u8g); |
|||
if ( mode == U8G_MODE_R3G3B2 ) |
|||
return 0x06d; /* gray: 01101101 */ |
|||
else if ( u8g_GetMode(u8g) == U8G_MODE_GRAY2BIT ) |
|||
return 1; /* low mid intensity */ |
|||
else /* if ( u8g.getMode() == U8G_MODE_BW ) */ |
|||
return 1; /* pixel on */ |
|||
return 1; /* default */ |
|||
} |
|||
|
|||
void u8g_SetDefaultMidColor(u8g_t *u8g) |
|||
{ |
|||
u8g_SetColorIndex(u8g, u8g_GetDefaultMidColor(u8g)); |
|||
} |
|||
|
|||
|
|||
|
|||
|
|||
@ -0,0 +1,81 @@ |
|||
/*
|
|||
|
|||
u8g_page.c |
|||
|
|||
page helper functions, only called by the dev handler. |
|||
|
|||
Universal 8bit Graphics Library |
|||
|
|||
Copyright (c) 2011, olikraus@gmail.com |
|||
All rights reserved. |
|||
|
|||
Redistribution and use in source and binary forms, with or without modification, |
|||
are permitted provided that the following conditions are met: |
|||
|
|||
* Redistributions of source code must retain the above copyright notice, this list |
|||
of conditions and the following disclaimer. |
|||
|
|||
* Redistributions in binary form must reproduce the above copyright notice, this |
|||
list of conditions and the following disclaimer in the documentation and/or other |
|||
materials provided with the distribution. |
|||
|
|||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
|||
CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
|||
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
|||
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
|||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
|||
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
|||
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
|||
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
|||
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
|||
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF |
|||
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|||
|
|||
|
|||
*/ |
|||
|
|||
#include "u8g.h" |
|||
|
|||
/*
|
|||
setup page count structure |
|||
conditions: page_height <= total_height |
|||
*/ |
|||
void u8g_page_Init(u8g_page_t *p, u8g_uint_t page_height, u8g_uint_t total_height ) |
|||
{ |
|||
p->page_height = page_height; |
|||
p->total_height = total_height; |
|||
p->page = 0; |
|||
u8g_page_First(p); |
|||
} |
|||
|
|||
void u8g_page_First(u8g_page_t *p) |
|||
{ |
|||
p->page_y0 = 0; |
|||
p->page_y1 = p->page_height; |
|||
p->page_y1--; |
|||
p->page = 0; |
|||
} |
|||
|
|||
uint8_t u8g_page_Next(u8g_page_t * p) |
|||
{ |
|||
register u8g_uint_t y1; |
|||
p->page_y0 += p->page_height; |
|||
if ( p->page_y0 >= p->total_height ) |
|||
return 0; |
|||
p->page++; |
|||
y1 = p->page_y1; |
|||
y1 += p->page_height; |
|||
if ( y1 >= p->total_height ) |
|||
{ |
|||
y1 = p->total_height; |
|||
y1--; |
|||
} |
|||
p->page_y1 = y1; |
|||
|
|||
return 1; |
|||
} |
|||
|
|||
|
|||
|
|||
@ -0,0 +1,191 @@ |
|||
/*
|
|||
|
|||
u8g_pb.c |
|||
|
|||
common procedures for the page buffer |
|||
|
|||
Universal 8bit Graphics Library |
|||
|
|||
Copyright (c) 2011, olikraus@gmail.com |
|||
All rights reserved. |
|||
|
|||
Redistribution and use in source and binary forms, with or without modification, |
|||
are permitted provided that the following conditions are met: |
|||
|
|||
* Redistributions of source code must retain the above copyright notice, this list |
|||
of conditions and the following disclaimer. |
|||
|
|||
* Redistributions in binary form must reproduce the above copyright notice, this |
|||
list of conditions and the following disclaimer in the documentation and/or other |
|||
materials provided with the distribution. |
|||
|
|||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
|||
CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
|||
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
|||
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
|||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
|||
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
|||
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
|||
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
|||
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
|||
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF |
|||
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|||
|
|||
|
|||
*/ |
|||
|
|||
#include "u8g.h" |
|||
|
|||
void u8g_pb_Clear(u8g_pb_t *b) |
|||
{ |
|||
uint8_t *ptr = (uint8_t *)b->buf; |
|||
uint8_t *end_ptr = ptr; |
|||
end_ptr += b->width; |
|||
do |
|||
{ |
|||
*ptr++ = 0; |
|||
} while( ptr != end_ptr ); |
|||
} |
|||
|
|||
/* the following procedure does not work. why? Can be checked with descpic */ |
|||
/*
|
|||
void u8g_pb_Clear(u8g_pb_t *b) |
|||
{ |
|||
uint8_t *ptr = (uint8_t *)b->buf; |
|||
uint8_t cnt = b->width; |
|||
do |
|||
{ |
|||
*ptr++ = 0; |
|||
cnt--; |
|||
} while( cnt != 0 ); |
|||
} |
|||
*/ |
|||
|
|||
/*
|
|||
intersection assumptions: |
|||
a1 <= a2 is always true |
|||
*/ |
|||
/*
|
|||
minimized version |
|||
---1----0 1 b1 <= a2 && b1 > b2 |
|||
-----1--0 1 b2 >= a1 && b1 > b2 |
|||
---1-1--- 1 b1 <= a2 && b2 >= a1 |
|||
*/ |
|||
/*
|
|||
uint8_t u8g_pb8v1_IsYIntersection___Old(u8g_pb_t *b, u8g_uint_t v0, u8g_uint_t v1) |
|||
{ |
|||
uint8_t c0, c1, c; |
|||
c0 = v0 <= b->p.page_y1; |
|||
c1 = v1 >= b->p.page_y0; |
|||
c = v0 > v1; |
|||
if ( c0 && c1 ) return 1; |
|||
if ( c0 && c ) return 1; |
|||
if ( c1 && c ) return 1; |
|||
return 0; |
|||
} |
|||
*/ |
|||
|
|||
uint8_t u8g_pb_IsYIntersection(u8g_pb_t *pb, u8g_uint_t v0, u8g_uint_t v1) |
|||
{ |
|||
uint8_t c1, c2, c3, tmp; |
|||
c1 = v0 <= pb->p.page_y1; |
|||
c2 = v1 >= pb->p.page_y0; |
|||
c3 = v0 > v1; |
|||
/*
|
|||
if ( c1 && c2 ) |
|||
return 1; |
|||
if ( c1 && c3 ) |
|||
return 1; |
|||
if ( c2 && c3 ) |
|||
return 1; |
|||
return 0; |
|||
*/ |
|||
|
|||
tmp = c1; |
|||
c1 &= c2; |
|||
c2 &= c3; |
|||
c3 &= tmp; |
|||
c1 |= c2; |
|||
c1 |= c3; |
|||
return c1 & 1; |
|||
} |
|||
|
|||
|
|||
uint8_t u8g_pb_IsXIntersection(u8g_pb_t *b, u8g_uint_t v0, u8g_uint_t v1) |
|||
{ |
|||
uint8_t /*c0, c1, */ c2, c3; |
|||
/*
|
|||
conditions: b->p.page_y0 < b->p.page_y1 |
|||
there are no restriction on v0 and v1. If v0 > v1, then warp around unsigned is assumed |
|||
*/ |
|||
/*
|
|||
c0 = v0 < 0; |
|||
c1 = v1 < 0; |
|||
*/ |
|||
c2 = v0 > b->width; |
|||
c3 = v1 > b->width; |
|||
/*if ( c0 && c1 ) return 0;*/ |
|||
if ( c2 && c3 ) return 0; |
|||
/*if ( c1 && c2 ) return 0;*/ |
|||
return 1; |
|||
} |
|||
|
|||
uint8_t u8g_pb_IsIntersection(u8g_pb_t *pb, u8g_dev_arg_bbx_t *bbx) |
|||
{ |
|||
u8g_uint_t tmp; |
|||
|
|||
tmp = bbx->y; |
|||
tmp += bbx->h; |
|||
tmp--; |
|||
|
|||
if ( u8g_pb_IsYIntersection(pb, bbx->y, tmp) == 0 ) |
|||
return 0; |
|||
|
|||
/* maybe this one can be skiped... probability is very high to have an intersection, so it would be ok to always return 1 */ |
|||
tmp = bbx->x; |
|||
tmp += bbx->w; |
|||
tmp--; |
|||
|
|||
return u8g_pb_IsXIntersection(pb, bbx->x, tmp); |
|||
} |
|||
|
|||
void u8g_pb_GetPageBox(u8g_pb_t *pb, u8g_box_t *box) |
|||
{ |
|||
box->x0 = 0; |
|||
box->y0 = pb->p.page_y0; |
|||
box->x1 = pb->width; |
|||
box->x1--; |
|||
box->y1 = pb->p.page_y1; |
|||
} |
|||
|
|||
|
|||
uint8_t u8g_pb_Is8PixelVisible(u8g_pb_t *b, u8g_dev_arg_pixel_t *arg_pixel) |
|||
{ |
|||
u8g_uint_t v0, v1; |
|||
v0 = arg_pixel->y; |
|||
v1 = v0; |
|||
switch( arg_pixel->dir ) |
|||
{ |
|||
case 0: |
|||
break; |
|||
case 1: |
|||
v1 += 8; /* this is independent from the page height */ |
|||
break; |
|||
case 2: |
|||
break; |
|||
case 3: |
|||
v0 -= 8; |
|||
break; |
|||
} |
|||
return u8g_pb_IsYIntersection(b, v0, v1); |
|||
} |
|||
|
|||
|
|||
|
|||
uint8_t u8g_pb_WriteBuffer(u8g_pb_t *b, u8g_t *u8g, u8g_dev_t *dev) |
|||
{ |
|||
return u8g_WriteSequence(u8g, dev, b->width, b->buf); |
|||
} |
|||
|
|||
@ -0,0 +1,200 @@ |
|||
/*
|
|||
|
|||
u8g_pb14v1.c |
|||
|
|||
14bit height monochrom (1 bit) page buffer, |
|||
byte has vertical orientation, 7 bits per byte |
|||
|
|||
Universal 8bit Graphics Library |
|||
|
|||
Copyright (c) 2011, olikraus@gmail.com |
|||
All rights reserved. |
|||
|
|||
Redistribution and use in source and binary forms, with or without modification, |
|||
are permitted provided that the following conditions are met: |
|||
|
|||
* Redistributions of source code must retain the above copyright notice, this list |
|||
of conditions and the following disclaimer. |
|||
|
|||
* Redistributions in binary form must reproduce the above copyright notice, this |
|||
list of conditions and the following disclaimer in the documentation and/or other |
|||
materials provided with the distribution. |
|||
|
|||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
|||
CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
|||
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
|||
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
|||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
|||
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
|||
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
|||
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
|||
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
|||
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF |
|||
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|||
|
|||
|
|||
*/ |
|||
|
|||
#include "u8g.h" |
|||
#include <string.h> |
|||
|
|||
|
|||
void u8g_pb14v1_Init(u8g_pb_t *b, void *buf, u8g_uint_t width) U8G_NOINLINE; |
|||
void u8g_pb14v1_set_pixel(u8g_pb_t *b, u8g_uint_t x, u8g_uint_t y, uint8_t color_index) U8G_NOINLINE; |
|||
void u8g_pb14v1_SetPixel(u8g_pb_t *b, const u8g_dev_arg_pixel_t * const arg_pixel) U8G_NOINLINE ; |
|||
void u8g_pb14v1_Set8PixelStd(u8g_pb_t *b, u8g_dev_arg_pixel_t *arg_pixel) U8G_NOINLINE; |
|||
|
|||
|
|||
void u8g_pb14v1_Clear(u8g_pb_t *b) |
|||
{ |
|||
uint8_t *ptr = (uint8_t *)b->buf; |
|||
uint8_t *end_ptr = ptr; |
|||
end_ptr += b->width*2; |
|||
do |
|||
{ |
|||
*ptr++ = 0; |
|||
} while( ptr != end_ptr ); |
|||
} |
|||
|
|||
/* Obsolete, usually set by the init of the structure */ |
|||
void u8g_pb14v1_Init(u8g_pb_t *b, void *buf, u8g_uint_t width) |
|||
{ |
|||
b->buf = buf; |
|||
b->width = width; |
|||
u8g_pb14v1_Clear(b); |
|||
} |
|||
|
|||
void u8g_pb14v1_set_pixel(u8g_pb_t *b, u8g_uint_t x, u8g_uint_t y, uint8_t color_index) |
|||
{ |
|||
register uint8_t mask; |
|||
uint8_t *ptr = b->buf; |
|||
|
|||
y -= b->p.page_y0; |
|||
if ( y >= 7 ) |
|||
{ |
|||
ptr += b->width; |
|||
y -= 7; |
|||
} |
|||
mask = 1; |
|||
mask <<= y; |
|||
ptr += x; |
|||
if ( color_index ) |
|||
{ |
|||
*ptr |= mask; |
|||
} |
|||
else |
|||
{ |
|||
mask ^=0xff; |
|||
*ptr &= mask; |
|||
} |
|||
} |
|||
|
|||
|
|||
void u8g_pb14v1_SetPixel(u8g_pb_t *b, const u8g_dev_arg_pixel_t * const arg_pixel) |
|||
{ |
|||
if ( arg_pixel->y < b->p.page_y0 ) |
|||
return; |
|||
if ( arg_pixel->y > b->p.page_y1 ) |
|||
return; |
|||
if ( arg_pixel->x >= b->width ) |
|||
return; |
|||
u8g_pb14v1_set_pixel(b, arg_pixel->x, arg_pixel->y, arg_pixel->color); |
|||
} |
|||
|
|||
void u8g_pb14v1_Set8PixelStd(u8g_pb_t *b, u8g_dev_arg_pixel_t *arg_pixel) |
|||
{ |
|||
register uint8_t pixel = arg_pixel->pixel; |
|||
do |
|||
{ |
|||
if ( pixel & 128 ) |
|||
{ |
|||
u8g_pb14v1_SetPixel(b, arg_pixel); |
|||
} |
|||
switch( arg_pixel->dir ) |
|||
{ |
|||
case 0: arg_pixel->x++; break; |
|||
case 1: arg_pixel->y++; break; |
|||
case 2: arg_pixel->x--; break; |
|||
case 3: arg_pixel->y--; break; |
|||
} |
|||
pixel <<= 1; |
|||
} while( pixel != 0 ); |
|||
} |
|||
|
|||
|
|||
void u8g_pb14v1_Set8PixelOpt2(u8g_pb_t *b, u8g_dev_arg_pixel_t *arg_pixel) |
|||
{ |
|||
register uint8_t pixel = arg_pixel->pixel; |
|||
u8g_uint_t dx = 0; |
|||
u8g_uint_t dy = 0; |
|||
|
|||
switch( arg_pixel->dir ) |
|||
{ |
|||
case 0: dx++; break; |
|||
case 1: dy++; break; |
|||
case 2: dx--; break; |
|||
case 3: dy--; break; |
|||
} |
|||
|
|||
do |
|||
{ |
|||
if ( pixel & 128 ) |
|||
u8g_pb14v1_SetPixel(b, arg_pixel); |
|||
arg_pixel->x += dx; |
|||
arg_pixel->y += dy; |
|||
pixel <<= 1; |
|||
} while( pixel != 0 ); |
|||
|
|||
} |
|||
|
|||
uint8_t u8g_dev_pb14v1_base_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg) |
|||
{ |
|||
u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem); |
|||
switch(msg) |
|||
{ |
|||
case U8G_DEV_MSG_SET_8PIXEL: |
|||
if ( u8g_pb_Is8PixelVisible(pb, (u8g_dev_arg_pixel_t *)arg) ) |
|||
u8g_pb14v1_Set8PixelOpt2(pb, (u8g_dev_arg_pixel_t *)arg); |
|||
break; |
|||
case U8G_DEV_MSG_SET_PIXEL: |
|||
u8g_pb14v1_SetPixel(pb, (u8g_dev_arg_pixel_t *)arg); |
|||
break; |
|||
case U8G_DEV_MSG_INIT: |
|||
break; |
|||
case U8G_DEV_MSG_STOP: |
|||
break; |
|||
case U8G_DEV_MSG_PAGE_FIRST: |
|||
u8g_pb14v1_Clear(pb); |
|||
u8g_page_First(&(pb->p)); |
|||
break; |
|||
case U8G_DEV_MSG_PAGE_NEXT: |
|||
if ( u8g_page_Next(&(pb->p)) == 0 ) |
|||
return 0; |
|||
u8g_pb14v1_Clear(pb); |
|||
break; |
|||
#ifdef U8G_DEV_MSG_IS_BBX_INTERSECTION |
|||
case U8G_DEV_MSG_IS_BBX_INTERSECTION: |
|||
return u8g_pb_IsIntersection(pb, (u8g_dev_arg_bbx_t *)arg); |
|||
#endif |
|||
case U8G_DEV_MSG_GET_PAGE_BOX: |
|||
u8g_pb_GetPageBox(pb, (u8g_box_t *)arg); |
|||
break; |
|||
case U8G_DEV_MSG_GET_WIDTH: |
|||
*((u8g_uint_t *)arg) = pb->width; |
|||
break; |
|||
case U8G_DEV_MSG_GET_HEIGHT: |
|||
*((u8g_uint_t *)arg) = pb->p.total_height; |
|||
break; |
|||
case U8G_DEV_MSG_SET_COLOR_INDEX: |
|||
break; |
|||
case U8G_DEV_MSG_SET_XY_CB: |
|||
break; |
|||
case U8G_DEV_MSG_GET_MODE: |
|||
return U8G_MODE_BW; |
|||
} |
|||
return 1; |
|||
} |
|||
|
|||
|
|||
@ -0,0 +1,213 @@ |
|||
/*
|
|||
|
|||
u8g_pb16h1.c |
|||
|
|||
2x 8bit height monochrom (1 bit) page buffer |
|||
byte has horizontal orientation |
|||
|
|||
Universal 8bit Graphics Library |
|||
|
|||
Copyright (c) 2012, olikraus@gmail.com |
|||
All rights reserved. |
|||
|
|||
Redistribution and use in source and binary forms, with or without modification, |
|||
are permitted provided that the following conditions are met: |
|||
|
|||
* Redistributions of source code must retain the above copyright notice, this list |
|||
of conditions and the following disclaimer. |
|||
|
|||
* Redistributions in binary form must reproduce the above copyright notice, this |
|||
list of conditions and the following disclaimer in the documentation and/or other |
|||
materials provided with the distribution. |
|||
|
|||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
|||
CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
|||
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
|||
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
|||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
|||
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
|||
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
|||
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
|||
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
|||
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF |
|||
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|||
|
|||
|
|||
total buffer size is limited to 2*256 bytes because of the calculation inside the set pixel procedure |
|||
|
|||
|
|||
*/ |
|||
|
|||
#include "u8g.h" |
|||
#include <string.h> |
|||
|
|||
|
|||
void u8g_pb16h1_Init(u8g_pb_t *b, void *buf, u8g_uint_t width) U8G_NOINLINE; |
|||
void u8g_pb16h1_set_pixel(u8g_pb_t *b, u8g_uint_t x, u8g_uint_t y, uint8_t color_index) U8G_NOINLINE; |
|||
void u8g_pb16h1_SetPixel(u8g_pb_t *b, const u8g_dev_arg_pixel_t * const arg_pixel) U8G_NOINLINE ; |
|||
void u8g_pb16h1_Set8PixelStd(u8g_pb_t *b, u8g_dev_arg_pixel_t *arg_pixel) U8G_NOINLINE; |
|||
uint8_t u8g_dev_pb8h1_base_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg); |
|||
|
|||
void u8g_pb16h1_Clear(u8g_pb_t *b) |
|||
{ |
|||
uint8_t *ptr = (uint8_t *)b->buf; |
|||
uint8_t *end_ptr = ptr; |
|||
end_ptr += b->width*2; |
|||
do |
|||
{ |
|||
*ptr++ = 0; |
|||
} while( ptr != end_ptr ); |
|||
} |
|||
|
|||
|
|||
|
|||
void u8g_pb16h1_Init(u8g_pb_t *b, void *buf, u8g_uint_t width) |
|||
{ |
|||
b->buf = buf; |
|||
b->width = width; |
|||
u8g_pb16h1_Clear(b); |
|||
} |
|||
|
|||
|
|||
/* limitation: total buffer must not exceed 2*256 bytes */ |
|||
void u8g_pb16h1_set_pixel(u8g_pb_t *b, u8g_uint_t x, u8g_uint_t y, uint8_t color_index) |
|||
{ |
|||
register uint8_t mask; |
|||
u8g_uint_t tmp; |
|||
uint8_t *ptr = b->buf; |
|||
|
|||
y -= b->p.page_y0; |
|||
if ( y >= 8 ) |
|||
{ |
|||
ptr += b->width; |
|||
y &= 0x07; |
|||
} |
|||
tmp = b->width; |
|||
tmp >>= 3; |
|||
tmp *= (uint8_t)y; |
|||
ptr += tmp; |
|||
|
|||
mask = 0x080; |
|||
mask >>= x & 7; |
|||
x >>= 3; |
|||
ptr += x; |
|||
if ( color_index ) |
|||
{ |
|||
*ptr |= mask; |
|||
} |
|||
else |
|||
{ |
|||
mask ^=0xff; |
|||
*ptr &= mask; |
|||
} |
|||
|
|||
} |
|||
|
|||
|
|||
void u8g_pb16h1_SetPixel(u8g_pb_t *b, const u8g_dev_arg_pixel_t * const arg_pixel) |
|||
{ |
|||
if ( arg_pixel->y < b->p.page_y0 ) |
|||
return; |
|||
if ( arg_pixel->y > b->p.page_y1 ) |
|||
return; |
|||
if ( arg_pixel->x >= b->width ) |
|||
return; |
|||
u8g_pb16h1_set_pixel(b, arg_pixel->x, arg_pixel->y, arg_pixel->color); |
|||
} |
|||
|
|||
void u8g_pb16h1_Set8PixelStd(u8g_pb_t *b, u8g_dev_arg_pixel_t *arg_pixel) |
|||
{ |
|||
register uint8_t pixel = arg_pixel->pixel; |
|||
do |
|||
{ |
|||
if ( pixel & 128 ) |
|||
{ |
|||
u8g_pb16h1_SetPixel(b, arg_pixel); |
|||
} |
|||
switch( arg_pixel->dir ) |
|||
{ |
|||
case 0: arg_pixel->x++; break; |
|||
case 1: arg_pixel->y++; break; |
|||
case 2: arg_pixel->x--; break; |
|||
case 3: arg_pixel->y--; break; |
|||
} |
|||
pixel <<= 1; |
|||
} while( pixel != 0 ); |
|||
} |
|||
|
|||
void u8g_pb16h1_Set8PixelOpt2(u8g_pb_t *b, u8g_dev_arg_pixel_t *arg_pixel) |
|||
{ |
|||
register uint8_t pixel = arg_pixel->pixel; |
|||
u8g_uint_t dx = 0; |
|||
u8g_uint_t dy = 0; |
|||
|
|||
switch( arg_pixel->dir ) |
|||
{ |
|||
case 0: dx++; break; |
|||
case 1: dy++; break; |
|||
case 2: dx--; break; |
|||
case 3: dy--; break; |
|||
} |
|||
|
|||
do |
|||
{ |
|||
if ( pixel & 128 ) |
|||
u8g_pb16h1_SetPixel(b, arg_pixel); |
|||
arg_pixel->x += dx; |
|||
arg_pixel->y += dy; |
|||
pixel <<= 1; |
|||
} while( pixel != 0 ); |
|||
} |
|||
|
|||
|
|||
uint8_t u8g_dev_pb16h1_base_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg) |
|||
{ |
|||
u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem); |
|||
switch(msg) |
|||
{ |
|||
case U8G_DEV_MSG_SET_8PIXEL: |
|||
if ( u8g_pb_Is8PixelVisible(pb, (u8g_dev_arg_pixel_t *)arg) ) |
|||
u8g_pb16h1_Set8PixelOpt2(pb, (u8g_dev_arg_pixel_t *)arg); |
|||
break; |
|||
case U8G_DEV_MSG_SET_PIXEL: |
|||
u8g_pb16h1_SetPixel(pb, (u8g_dev_arg_pixel_t *)arg); |
|||
break; |
|||
case U8G_DEV_MSG_INIT: |
|||
break; |
|||
case U8G_DEV_MSG_STOP: |
|||
break; |
|||
case U8G_DEV_MSG_PAGE_FIRST: |
|||
u8g_pb16h1_Clear(pb); |
|||
u8g_page_First(&(pb->p)); |
|||
break; |
|||
case U8G_DEV_MSG_PAGE_NEXT: |
|||
if ( u8g_page_Next(&(pb->p)) == 0 ) |
|||
return 0; |
|||
u8g_pb16h1_Clear(pb); |
|||
break; |
|||
#ifdef U8G_DEV_MSG_IS_BBX_INTERSECTION |
|||
case U8G_DEV_MSG_IS_BBX_INTERSECTION: |
|||
return u8g_pb_IsIntersection(pb, (u8g_dev_arg_bbx_t *)arg); |
|||
#endif |
|||
case U8G_DEV_MSG_GET_PAGE_BOX: |
|||
u8g_pb_GetPageBox(pb, (u8g_box_t *)arg); |
|||
break; |
|||
case U8G_DEV_MSG_GET_WIDTH: |
|||
*((u8g_uint_t *)arg) = pb->width; |
|||
break; |
|||
case U8G_DEV_MSG_GET_HEIGHT: |
|||
*((u8g_uint_t *)arg) = pb->p.total_height; |
|||
break; |
|||
case U8G_DEV_MSG_SET_COLOR_INDEX: |
|||
break; |
|||
case U8G_DEV_MSG_SET_XY_CB: |
|||
break; |
|||
case U8G_DEV_MSG_GET_MODE: |
|||
return U8G_MODE_BW; |
|||
} |
|||
return 1; |
|||
} |
|||
|
|||
|
|||
@ -0,0 +1,182 @@ |
|||
/*
|
|||
|
|||
u8g_pb16h2.c |
|||
|
|||
2 bit per pixel page buffer |
|||
byte has horizontal orientation |
|||
|
|||
Universal 8bit Graphics Library |
|||
|
|||
Copyright (c) 2011, olikraus@gmail.com |
|||
All rights reserved. |
|||
|
|||
Redistribution and use in source and binary forms, with or without modification, |
|||
are permitted provided that the following conditions are met: |
|||
|
|||
* Redistributions of source code must retain the above copyright notice, this list |
|||
of conditions and the following disclaimer. |
|||
|
|||
* Redistributions in binary form must reproduce the above copyright notice, this |
|||
list of conditions and the following disclaimer in the documentation and/or other |
|||
materials provided with the distribution. |
|||
|
|||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
|||
CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
|||
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
|||
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
|||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
|||
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
|||
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
|||
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
|||
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
|||
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF |
|||
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|||
|
|||
|
|||
*/ |
|||
|
|||
#include "u8g.h" |
|||
#include <string.h> |
|||
|
|||
void u8g_pb16h2_Clear(u8g_pb_t *b) |
|||
{ |
|||
uint8_t *ptr = (uint8_t *)b->buf; |
|||
uint8_t *end_ptr = ptr; |
|||
|
|||
/* two bits per pixel, 16 bits height --> 8 pixel --> 4 pixel per byte */ |
|||
end_ptr += b->width; |
|||
end_ptr += b->width; |
|||
|
|||
do |
|||
{ |
|||
*ptr++ = 0; |
|||
} while( ptr != end_ptr ); |
|||
} |
|||
|
|||
void u8g_pb16h2_Init(u8g_pb_t *b, void *buf, u8g_uint_t width) |
|||
{ |
|||
b->buf = buf; |
|||
b->width = width; |
|||
u8g_pb16h2_Clear(b); |
|||
} |
|||
|
|||
static void u8g_pb16h2_set_pixel(u8g_pb_t *b, u8g_uint_t x, u8g_uint_t y, uint8_t color_index) U8G_NOINLINE; |
|||
static void u8g_pb16h2_set_pixel(u8g_pb_t *b, u8g_uint_t x, u8g_uint_t y, uint8_t color_index) |
|||
{ |
|||
register uint8_t mask; |
|||
register uint16_t tmp; |
|||
|
|||
uint8_t *ptr = b->buf; |
|||
|
|||
y -= b->p.page_y0; |
|||
|
|||
tmp = b->width; |
|||
tmp >>= 2; |
|||
tmp *= (uint8_t)y; |
|||
ptr += tmp; |
|||
|
|||
tmp = x; |
|||
tmp >>= 2; |
|||
ptr += tmp; |
|||
|
|||
tmp = x; |
|||
tmp &= 3; |
|||
tmp <<= 1; |
|||
mask = 3; |
|||
mask <<= tmp; |
|||
mask = ~mask; |
|||
color_index &= 3; |
|||
color_index <<= tmp; |
|||
|
|||
*ptr &= mask; |
|||
*ptr |= color_index; |
|||
} |
|||
|
|||
|
|||
void u8g_pb16h2_SetPixel(u8g_pb_t *b, const u8g_dev_arg_pixel_t * const arg_pixel) |
|||
{ |
|||
if ( arg_pixel->y < b->p.page_y0 ) |
|||
return; |
|||
if ( arg_pixel->y > b->p.page_y1 ) |
|||
return; |
|||
if ( arg_pixel->x >= b->width ) |
|||
return; |
|||
u8g_pb16h2_set_pixel(b, arg_pixel->x, arg_pixel->y, arg_pixel->color); |
|||
} |
|||
|
|||
|
|||
void u8g_pb16h2_Set8PixelStd(u8g_pb_t *b, u8g_dev_arg_pixel_t *arg_pixel) |
|||
{ |
|||
register uint8_t pixel = arg_pixel->pixel; |
|||
do |
|||
{ |
|||
if ( pixel & 128 ) |
|||
{ |
|||
u8g_pb16h2_SetPixel(b, arg_pixel); |
|||
} |
|||
switch( arg_pixel->dir ) |
|||
{ |
|||
case 0: arg_pixel->x++; break; |
|||
case 1: arg_pixel->y++; break; |
|||
case 2: arg_pixel->x--; break; |
|||
case 3: arg_pixel->y--; break; |
|||
} |
|||
pixel <<= 1; |
|||
} while( pixel != 0 ); |
|||
} |
|||
|
|||
|
|||
|
|||
uint8_t u8g_dev_pb16h2_base_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg) |
|||
{ |
|||
u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem); |
|||
switch(msg) |
|||
{ |
|||
case U8G_DEV_MSG_SET_8PIXEL: |
|||
if ( u8g_pb_Is8PixelVisible(pb, (u8g_dev_arg_pixel_t *)arg) ) |
|||
{ |
|||
u8g_pb16h2_Set8PixelStd(pb, (u8g_dev_arg_pixel_t *)arg); |
|||
} |
|||
break; |
|||
case U8G_DEV_MSG_SET_PIXEL: |
|||
u8g_pb16h2_SetPixel(pb, (u8g_dev_arg_pixel_t *)arg); |
|||
break; |
|||
case U8G_DEV_MSG_INIT: |
|||
break; |
|||
case U8G_DEV_MSG_STOP: |
|||
break; |
|||
case U8G_DEV_MSG_PAGE_FIRST: |
|||
u8g_page_First(&(pb->p)); |
|||
u8g_pb16h2_Clear(pb); |
|||
break; |
|||
case U8G_DEV_MSG_PAGE_NEXT: |
|||
if ( u8g_page_Next(&(pb->p)) == 0 ) |
|||
return 0; |
|||
u8g_pb16h2_Clear(pb); |
|||
break; |
|||
#ifdef U8G_DEV_MSG_IS_BBX_INTERSECTION |
|||
case U8G_DEV_MSG_IS_BBX_INTERSECTION: |
|||
return u8g_pb_IsIntersection(pb, (u8g_dev_arg_bbx_t *)arg); |
|||
#endif |
|||
case U8G_DEV_MSG_GET_PAGE_BOX: |
|||
u8g_pb_GetPageBox(pb, (u8g_box_t *)arg); |
|||
break; |
|||
case U8G_DEV_MSG_GET_WIDTH: |
|||
*((u8g_uint_t *)arg) = pb->width; |
|||
break; |
|||
case U8G_DEV_MSG_GET_HEIGHT: |
|||
*((u8g_uint_t *)arg) = pb->p.total_height; |
|||
break; |
|||
case U8G_DEV_MSG_SET_COLOR_INDEX: |
|||
break; |
|||
case U8G_DEV_MSG_SET_XY_CB: |
|||
break; |
|||
case U8G_DEV_MSG_GET_MODE: |
|||
return U8G_MODE_GRAY2BIT; |
|||
} |
|||
return 1; |
|||
} |
|||
|
|||
|
|||
@ -0,0 +1,200 @@ |
|||
/*
|
|||
|
|||
u8g_pb16v1.c |
|||
|
|||
16bit height monochrom (1 bit) page buffer |
|||
byte has vertical orientation |
|||
|
|||
Universal 8bit Graphics Library |
|||
|
|||
Copyright (c) 2011, olikraus@gmail.com |
|||
All rights reserved. |
|||
|
|||
Redistribution and use in source and binary forms, with or without modification, |
|||
are permitted provided that the following conditions are met: |
|||
|
|||
* Redistributions of source code must retain the above copyright notice, this list |
|||
of conditions and the following disclaimer. |
|||
|
|||
* Redistributions in binary form must reproduce the above copyright notice, this |
|||
list of conditions and the following disclaimer in the documentation and/or other |
|||
materials provided with the distribution. |
|||
|
|||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
|||
CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
|||
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
|||
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
|||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
|||
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
|||
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
|||
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
|||
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
|||
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF |
|||
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|||
|
|||
|
|||
*/ |
|||
|
|||
#include "u8g.h" |
|||
#include <string.h> |
|||
|
|||
|
|||
void u8g_pb16v1_Init(u8g_pb_t *b, void *buf, u8g_uint_t width) U8G_NOINLINE; |
|||
void u8g_pb16v1_set_pixel(u8g_pb_t *b, u8g_uint_t x, u8g_uint_t y, uint8_t color_index) U8G_NOINLINE; |
|||
void u8g_pb16v1_SetPixel(u8g_pb_t *b, const u8g_dev_arg_pixel_t * const arg_pixel) U8G_NOINLINE ; |
|||
void u8g_pb16v1_Set8PixelStd(u8g_pb_t *b, u8g_dev_arg_pixel_t *arg_pixel) U8G_NOINLINE; |
|||
|
|||
|
|||
void u8g_pb16v1_Clear(u8g_pb_t *b) |
|||
{ |
|||
uint8_t *ptr = (uint8_t *)b->buf; |
|||
uint8_t *end_ptr = ptr; |
|||
end_ptr += b->width*2; |
|||
do |
|||
{ |
|||
*ptr++ = 0; |
|||
} while( ptr != end_ptr ); |
|||
} |
|||
|
|||
/* Obsolete, usually set by the init of the structure */ |
|||
void u8g_pb16v1_Init(u8g_pb_t *b, void *buf, u8g_uint_t width) |
|||
{ |
|||
b->buf = buf; |
|||
b->width = width; |
|||
u8g_pb16v1_Clear(b); |
|||
} |
|||
|
|||
void u8g_pb16v1_set_pixel(u8g_pb_t *b, u8g_uint_t x, u8g_uint_t y, uint8_t color_index) |
|||
{ |
|||
register uint8_t mask; |
|||
uint8_t *ptr = b->buf; |
|||
|
|||
y -= b->p.page_y0; |
|||
if ( y >= 8 ) |
|||
{ |
|||
ptr += b->width; |
|||
y &= 0x07; |
|||
} |
|||
mask = 1; |
|||
mask <<= y; |
|||
ptr += x; |
|||
if ( color_index ) |
|||
{ |
|||
*ptr |= mask; |
|||
} |
|||
else |
|||
{ |
|||
mask ^=0xff; |
|||
*ptr &= mask; |
|||
} |
|||
} |
|||
|
|||
|
|||
void u8g_pb16v1_SetPixel(u8g_pb_t *b, const u8g_dev_arg_pixel_t * const arg_pixel) |
|||
{ |
|||
if ( arg_pixel->y < b->p.page_y0 ) |
|||
return; |
|||
if ( arg_pixel->y > b->p.page_y1 ) |
|||
return; |
|||
if ( arg_pixel->x >= b->width ) |
|||
return; |
|||
u8g_pb16v1_set_pixel(b, arg_pixel->x, arg_pixel->y, arg_pixel->color); |
|||
} |
|||
|
|||
void u8g_pb16v1_Set8PixelStd(u8g_pb_t *b, u8g_dev_arg_pixel_t *arg_pixel) |
|||
{ |
|||
register uint8_t pixel = arg_pixel->pixel; |
|||
do |
|||
{ |
|||
if ( pixel & 128 ) |
|||
{ |
|||
u8g_pb16v1_SetPixel(b, arg_pixel); |
|||
} |
|||
switch( arg_pixel->dir ) |
|||
{ |
|||
case 0: arg_pixel->x++; break; |
|||
case 1: arg_pixel->y++; break; |
|||
case 2: arg_pixel->x--; break; |
|||
case 3: arg_pixel->y--; break; |
|||
} |
|||
pixel <<= 1; |
|||
} while( pixel != 0 ); |
|||
} |
|||
|
|||
|
|||
void u8g_pb16v1_Set8PixelOpt2(u8g_pb_t *b, u8g_dev_arg_pixel_t *arg_pixel) |
|||
{ |
|||
register uint8_t pixel = arg_pixel->pixel; |
|||
u8g_uint_t dx = 0; |
|||
u8g_uint_t dy = 0; |
|||
|
|||
switch( arg_pixel->dir ) |
|||
{ |
|||
case 0: dx++; break; |
|||
case 1: dy++; break; |
|||
case 2: dx--; break; |
|||
case 3: dy--; break; |
|||
} |
|||
|
|||
do |
|||
{ |
|||
if ( pixel & 128 ) |
|||
u8g_pb16v1_SetPixel(b, arg_pixel); |
|||
arg_pixel->x += dx; |
|||
arg_pixel->y += dy; |
|||
pixel <<= 1; |
|||
} while( pixel != 0 ); |
|||
|
|||
} |
|||
|
|||
uint8_t u8g_dev_pb16v1_base_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg) |
|||
{ |
|||
u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem); |
|||
switch(msg) |
|||
{ |
|||
case U8G_DEV_MSG_SET_8PIXEL: |
|||
if ( u8g_pb_Is8PixelVisible(pb, (u8g_dev_arg_pixel_t *)arg) ) |
|||
u8g_pb16v1_Set8PixelOpt2(pb, (u8g_dev_arg_pixel_t *)arg); |
|||
break; |
|||
case U8G_DEV_MSG_SET_PIXEL: |
|||
u8g_pb16v1_SetPixel(pb, (u8g_dev_arg_pixel_t *)arg); |
|||
break; |
|||
case U8G_DEV_MSG_INIT: |
|||
break; |
|||
case U8G_DEV_MSG_STOP: |
|||
break; |
|||
case U8G_DEV_MSG_PAGE_FIRST: |
|||
u8g_pb16v1_Clear(pb); |
|||
u8g_page_First(&(pb->p)); |
|||
break; |
|||
case U8G_DEV_MSG_PAGE_NEXT: |
|||
if ( u8g_page_Next(&(pb->p)) == 0 ) |
|||
return 0; |
|||
u8g_pb16v1_Clear(pb); |
|||
break; |
|||
#ifdef U8G_DEV_MSG_IS_BBX_INTERSECTION |
|||
case U8G_DEV_MSG_IS_BBX_INTERSECTION: |
|||
return u8g_pb_IsIntersection(pb, (u8g_dev_arg_bbx_t *)arg); |
|||
#endif |
|||
case U8G_DEV_MSG_GET_PAGE_BOX: |
|||
u8g_pb_GetPageBox(pb, (u8g_box_t *)arg); |
|||
break; |
|||
case U8G_DEV_MSG_GET_WIDTH: |
|||
*((u8g_uint_t *)arg) = pb->width; |
|||
break; |
|||
case U8G_DEV_MSG_GET_HEIGHT: |
|||
*((u8g_uint_t *)arg) = pb->p.total_height; |
|||
break; |
|||
case U8G_DEV_MSG_SET_COLOR_INDEX: |
|||
break; |
|||
case U8G_DEV_MSG_SET_XY_CB: |
|||
break; |
|||
case U8G_DEV_MSG_GET_MODE: |
|||
return U8G_MODE_BW; |
|||
} |
|||
return 1; |
|||
} |
|||
|
|||
|
|||
@ -0,0 +1,172 @@ |
|||
/*
|
|||
|
|||
u8g_pb16v2.c |
|||
|
|||
16 bit height 2 bit per pixel page buffer |
|||
byte has vertical orientation |
|||
|
|||
Universal 8bit Graphics Library |
|||
|
|||
Copyright (c) 2012, olikraus@gmail.com |
|||
All rights reserved. |
|||
|
|||
Redistribution and use in source and binary forms, with or without modification, |
|||
are permitted provided that the following conditions are met: |
|||
|
|||
* Redistributions of source code must retain the above copyright notice, this list |
|||
of conditions and the following disclaimer. |
|||
|
|||
* Redistributions in binary form must reproduce the above copyright notice, this |
|||
list of conditions and the following disclaimer in the documentation and/or other |
|||
materials provided with the distribution. |
|||
|
|||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
|||
CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
|||
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
|||
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
|||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
|||
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
|||
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
|||
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
|||
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
|||
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF |
|||
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|||
|
|||
|
|||
*/ |
|||
|
|||
#include "u8g.h" |
|||
#include <string.h> |
|||
|
|||
|
|||
void u8g_pb16v2_Clear(u8g_pb_t *b) |
|||
{ |
|||
uint8_t *ptr = (uint8_t *)b->buf; |
|||
uint8_t *end_ptr = ptr; |
|||
|
|||
/* two bits per pixel, 16 bits height --> 8 pixel --> 4 pixel per byte */ |
|||
end_ptr += b->width; |
|||
end_ptr += b->width; |
|||
|
|||
do |
|||
{ |
|||
*ptr++ = 0; |
|||
} while( ptr != end_ptr ); |
|||
} |
|||
|
|||
void u8g_pb16v2Init(u8g_pb_t *b, void *buf, u8g_uint_t width) |
|||
{ |
|||
b->buf = buf; |
|||
b->width = width; |
|||
u8g_pb16v2_Clear(b); |
|||
} |
|||
|
|||
void u8g_pb16v2_set_pixel(u8g_pb_t *b, u8g_uint_t x, u8g_uint_t y, uint8_t color_index) |
|||
{ |
|||
register uint8_t mask; |
|||
uint8_t *ptr = b->buf; |
|||
y -= b->p.page_y0; |
|||
if ( y >= 4 ) |
|||
{ |
|||
ptr += b->width; |
|||
} |
|||
mask = 0x03; |
|||
y &= 0x03; |
|||
y <<= 1; |
|||
mask <<= y; |
|||
mask ^=0xff; |
|||
color_index &= 3; |
|||
color_index <<= y; |
|||
ptr += x; |
|||
*ptr &= mask; |
|||
*ptr |= color_index; |
|||
} |
|||
|
|||
|
|||
void u8g_pb16v2_SetPixel(u8g_pb_t *b, const u8g_dev_arg_pixel_t * const arg_pixel) |
|||
{ |
|||
if ( arg_pixel->y < b->p.page_y0 ) |
|||
return; |
|||
if ( arg_pixel->y > b->p.page_y1 ) |
|||
return; |
|||
if ( arg_pixel->x >= b->width ) |
|||
return; |
|||
u8g_pb16v2_set_pixel(b, arg_pixel->x, arg_pixel->y, arg_pixel->color); |
|||
} |
|||
|
|||
|
|||
void u8g_pb16v2_Set8PixelStd(u8g_pb_t *b, u8g_dev_arg_pixel_t *arg_pixel) |
|||
{ |
|||
register uint8_t pixel = arg_pixel->pixel; |
|||
do |
|||
{ |
|||
if ( pixel & 128 ) |
|||
{ |
|||
u8g_pb16v2_SetPixel(b, arg_pixel); |
|||
} |
|||
switch( arg_pixel->dir ) |
|||
{ |
|||
case 0: arg_pixel->x++; break; |
|||
case 1: arg_pixel->y++; break; |
|||
case 2: arg_pixel->x--; break; |
|||
case 3: arg_pixel->y--; break; |
|||
} |
|||
pixel <<= 1; |
|||
} while( pixel != 0 ); |
|||
} |
|||
|
|||
|
|||
|
|||
uint8_t u8g_dev_pb16v2_base_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg) |
|||
{ |
|||
u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem); |
|||
switch(msg) |
|||
{ |
|||
case U8G_DEV_MSG_SET_8PIXEL: |
|||
if ( u8g_pb_Is8PixelVisible(pb, (u8g_dev_arg_pixel_t *)arg) ) |
|||
{ |
|||
u8g_pb16v2_Set8PixelStd(pb, (u8g_dev_arg_pixel_t *)arg); |
|||
} |
|||
break; |
|||
case U8G_DEV_MSG_SET_PIXEL: |
|||
u8g_pb16v2_SetPixel(pb, (u8g_dev_arg_pixel_t *)arg); |
|||
break; |
|||
case U8G_DEV_MSG_INIT: |
|||
break; |
|||
case U8G_DEV_MSG_STOP: |
|||
break; |
|||
case U8G_DEV_MSG_PAGE_FIRST: |
|||
u8g_pb16v2_Clear(pb); |
|||
u8g_page_First(&(pb->p)); |
|||
break; |
|||
case U8G_DEV_MSG_PAGE_NEXT: |
|||
if ( u8g_page_Next(&(pb->p)) == 0 ) |
|||
return 0; |
|||
u8g_pb16v2_Clear(pb); |
|||
break; |
|||
#ifdef U8G_DEV_MSG_IS_BBX_INTERSECTION |
|||
case U8G_DEV_MSG_IS_BBX_INTERSECTION: |
|||
return u8g_pb_IsIntersection(pb, (u8g_dev_arg_bbx_t *)arg); |
|||
#endif |
|||
case U8G_DEV_MSG_GET_PAGE_BOX: |
|||
u8g_pb_GetPageBox(pb, (u8g_box_t *)arg); |
|||
break; |
|||
case U8G_DEV_MSG_GET_WIDTH: |
|||
*((u8g_uint_t *)arg) = pb->width; |
|||
break; |
|||
case U8G_DEV_MSG_GET_HEIGHT: |
|||
*((u8g_uint_t *)arg) = pb->p.total_height; |
|||
break; |
|||
case U8G_DEV_MSG_SET_COLOR_INDEX: |
|||
break; |
|||
case U8G_DEV_MSG_SET_XY_CB: |
|||
break; |
|||
case U8G_DEV_MSG_GET_MODE: |
|||
return U8G_MODE_GRAY2BIT; |
|||
} |
|||
return 1; |
|||
} |
|||
|
|||
|
|||
@ -0,0 +1,208 @@ |
|||
/*
|
|||
|
|||
u8g_pb32h1.c |
|||
|
|||
2x 8bit height monochrom (1 bit) page buffer |
|||
byte has horizontal orientation |
|||
|
|||
Universal 8bit Graphics Library |
|||
|
|||
Copyright (c) 2012, olikraus@gmail.com |
|||
All rights reserved. |
|||
|
|||
Redistribution and use in source and binary forms, with or without modification, |
|||
are permitted provided that the following conditions are met: |
|||
|
|||
* Redistributions of source code must retain the above copyright notice, this list |
|||
of conditions and the following disclaimer. |
|||
|
|||
* Redistributions in binary form must reproduce the above copyright notice, this |
|||
list of conditions and the following disclaimer in the documentation and/or other |
|||
materials provided with the distribution. |
|||
|
|||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
|||
CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
|||
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
|||
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
|||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
|||
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
|||
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
|||
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
|||
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
|||
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF |
|||
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|||
|
|||
|
|||
total buffer size is limited to 2*256 bytes because of the calculation inside the set pixel procedure |
|||
|
|||
|
|||
*/ |
|||
|
|||
#include "u8g.h" |
|||
#include <string.h> |
|||
|
|||
|
|||
void u8g_pb32h1_Init(u8g_pb_t *b, void *buf, u8g_uint_t width) U8G_NOINLINE; |
|||
void u8g_pb32h1_set_pixel(u8g_pb_t *b, u8g_uint_t x, u8g_uint_t y, uint8_t color_index) U8G_NOINLINE; |
|||
void u8g_pb32h1_SetPixel(u8g_pb_t *b, const u8g_dev_arg_pixel_t * const arg_pixel) U8G_NOINLINE ; |
|||
void u8g_pb32h1_Set8PixelStd(u8g_pb_t *b, u8g_dev_arg_pixel_t *arg_pixel) U8G_NOINLINE; |
|||
uint8_t u8g_dev_pb8h1_base_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg); |
|||
|
|||
void u8g_pb32h1_Clear(u8g_pb_t *b) |
|||
{ |
|||
uint8_t *ptr = (uint8_t *)b->buf; |
|||
uint8_t *end_ptr = ptr; |
|||
end_ptr += b->width*4; |
|||
do |
|||
{ |
|||
*ptr++ = 0; |
|||
} while( ptr != end_ptr ); |
|||
} |
|||
|
|||
|
|||
|
|||
void u8g_pb32h1_Init(u8g_pb_t *b, void *buf, u8g_uint_t width) |
|||
{ |
|||
b->buf = buf; |
|||
b->width = width; |
|||
u8g_pb32h1_Clear(b); |
|||
} |
|||
|
|||
|
|||
/* limitation: total buffer must not exceed 2*256 bytes */ |
|||
void u8g_pb32h1_set_pixel(u8g_pb_t *b, u8g_uint_t x, u8g_uint_t y, uint8_t color_index) |
|||
{ |
|||
register uint8_t mask; |
|||
uint16_t tmp; |
|||
uint8_t *ptr = b->buf; |
|||
|
|||
y -= b->p.page_y0; |
|||
tmp = b->width; |
|||
tmp >>= 3; |
|||
tmp *= y; |
|||
ptr += tmp; |
|||
|
|||
mask = 0x080; |
|||
mask >>= x & 7; |
|||
x >>= 3; |
|||
ptr += x; |
|||
if ( color_index ) |
|||
{ |
|||
*ptr |= mask; |
|||
} |
|||
else |
|||
{ |
|||
mask ^=0xff; |
|||
*ptr &= mask; |
|||
} |
|||
|
|||
} |
|||
|
|||
|
|||
void u8g_pb32h1_SetPixel(u8g_pb_t *b, const u8g_dev_arg_pixel_t * const arg_pixel) |
|||
{ |
|||
if ( arg_pixel->y < b->p.page_y0 ) |
|||
return; |
|||
if ( arg_pixel->y > b->p.page_y1 ) |
|||
return; |
|||
if ( arg_pixel->x >= b->width ) |
|||
return; |
|||
u8g_pb32h1_set_pixel(b, arg_pixel->x, arg_pixel->y, arg_pixel->color); |
|||
} |
|||
|
|||
void u8g_pb32h1_Set8PixelStd(u8g_pb_t *b, u8g_dev_arg_pixel_t *arg_pixel) |
|||
{ |
|||
register uint8_t pixel = arg_pixel->pixel; |
|||
do |
|||
{ |
|||
if ( pixel & 128 ) |
|||
{ |
|||
u8g_pb32h1_SetPixel(b, arg_pixel); |
|||
} |
|||
switch( arg_pixel->dir ) |
|||
{ |
|||
case 0: arg_pixel->x++; break; |
|||
case 1: arg_pixel->y++; break; |
|||
case 2: arg_pixel->x--; break; |
|||
case 3: arg_pixel->y--; break; |
|||
} |
|||
pixel <<= 1; |
|||
} while( pixel != 0 ); |
|||
} |
|||
|
|||
void u8g_pb32h1_Set8PixelOpt2(u8g_pb_t *b, u8g_dev_arg_pixel_t *arg_pixel) |
|||
{ |
|||
register uint8_t pixel = arg_pixel->pixel; |
|||
u8g_uint_t dx = 0; |
|||
u8g_uint_t dy = 0; |
|||
|
|||
switch( arg_pixel->dir ) |
|||
{ |
|||
case 0: dx++; break; |
|||
case 1: dy++; break; |
|||
case 2: dx--; break; |
|||
case 3: dy--; break; |
|||
} |
|||
|
|||
do |
|||
{ |
|||
if ( pixel & 128 ) |
|||
u8g_pb32h1_SetPixel(b, arg_pixel); |
|||
arg_pixel->x += dx; |
|||
arg_pixel->y += dy; |
|||
pixel <<= 1; |
|||
} while( pixel != 0 ); |
|||
} |
|||
|
|||
|
|||
uint8_t u8g_dev_pb32h1_base_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg) |
|||
{ |
|||
u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem); |
|||
switch(msg) |
|||
{ |
|||
case U8G_DEV_MSG_SET_8PIXEL: |
|||
if ( u8g_pb_Is8PixelVisible(pb, (u8g_dev_arg_pixel_t *)arg) ) |
|||
u8g_pb32h1_Set8PixelOpt2(pb, (u8g_dev_arg_pixel_t *)arg); |
|||
break; |
|||
case U8G_DEV_MSG_SET_PIXEL: |
|||
u8g_pb32h1_SetPixel(pb, (u8g_dev_arg_pixel_t *)arg); |
|||
break; |
|||
case U8G_DEV_MSG_INIT: |
|||
break; |
|||
case U8G_DEV_MSG_STOP: |
|||
break; |
|||
case U8G_DEV_MSG_PAGE_FIRST: |
|||
u8g_pb32h1_Clear(pb); |
|||
u8g_page_First(&(pb->p)); |
|||
break; |
|||
case U8G_DEV_MSG_PAGE_NEXT: |
|||
if ( u8g_page_Next(&(pb->p)) == 0 ) |
|||
return 0; |
|||
u8g_pb32h1_Clear(pb); |
|||
break; |
|||
#ifdef U8G_DEV_MSG_IS_BBX_INTERSECTION |
|||
case U8G_DEV_MSG_IS_BBX_INTERSECTION: |
|||
return u8g_pb_IsIntersection(pb, (u8g_dev_arg_bbx_t *)arg); |
|||
#endif |
|||
case U8G_DEV_MSG_GET_PAGE_BOX: |
|||
u8g_pb_GetPageBox(pb, (u8g_box_t *)arg); |
|||
break; |
|||
case U8G_DEV_MSG_GET_WIDTH: |
|||
*((u8g_uint_t *)arg) = pb->width; |
|||
break; |
|||
case U8G_DEV_MSG_GET_HEIGHT: |
|||
*((u8g_uint_t *)arg) = pb->p.total_height; |
|||
break; |
|||
case U8G_DEV_MSG_SET_COLOR_INDEX: |
|||
break; |
|||
case U8G_DEV_MSG_SET_XY_CB: |
|||
break; |
|||
case U8G_DEV_MSG_GET_MODE: |
|||
return U8G_MODE_BW; |
|||
} |
|||
return 1; |
|||
} |
|||
|
|||
|
|||
Some files were not shown because too many files changed in this diff
Loading…
Reference in new issue