Wed Oct 05, 2016 1:56 am
Wed Oct 05, 2016 7:29 am
Wed Oct 05, 2016 7:51 am
oid Gamebuino::begin() {
timePerFrame = 50;
//nextFrameMillis = 0;
//frameCount = 0;
frameEndMicros = 1;
startMenuTimer = 255;
//read default settings from flash memory (set using settings.hex)
readSettings();
//init everything
backlight.begin();
backlight.set(BACKLIGHT_MAX);
buttons.begin();
buttons.update();
battery.begin();
display.begin(SCR_CLK, SCR_DIN, SCR_DC, SCR_CS, SCR_RST);
sound.begin();
//mute when B is held during start up
if(buttons.pressed(BTN_B)){
sound.setVolume(0);
}
else{ //play the startup sound on each channel for it to be louder
#if(NUM_CHANNELS > 0)
sound.playPattern(startupSound, 0);
#endif
#if(NUM_CHANNELS > 1)
sound.playPattern(startupSound, 1);
#endif
#if(NUM_CHANNELS > 2)
sound.playPattern(startupSound, 2);
#endif
#if(NUM_CHANNELS > 3)
sound.playPattern(startupSound, 3);
#endif
}
}
void LCD_2000_7775::begin()
{
if( this->_rest )
{
*(this->restport) &= (~this->restpinmask);
delay(50); // Delay 50ms
*(this->restport) |= this->restpinmask;
delay(10); // Delay 10ms
}
this->write_cmd(0x0001, 0x011C); // set SS and NL bit
this->write_cmd(0x0002, 0x0100); // set 1 line inversion
this->write_cmd(0x0003, 0x1030); // set GRAM write direction and BGR=1,??16BIT 65K?MDT1=0,MDT0=0
this->write_cmd(0x0008, 0x0808); // set BP and FP
this->write_cmd(0x000C, 0x0000); // RGB interface setting R0Ch=0x0110 for RGB 18Bit and R0Ch=0111for
this->write_cmd(0x000F, 0x0e01); // Set frame rate
//*************Power On sequence ****************//
delay(50); // Delay 50ms
this->write_cmd(0x0010, 0x0A00); // Set SAP,DSTB,STB
this->write_cmd(0x0011, 0x1038); // Set APON,PON,AON,VCI1EN,VC
//delay(50); // Delay 50ms
this->write_cmd(0x00ff, 0x0003); //
this->write_cmd(0x00b0, 0x1411); //Set VCOM 1d
this->write_cmd(0x00b1, 0x0202); //GVCL/GVDD voltage setting
this->write_cmd(0x00b2, 0x0313); //VCL voltage setting
//------------------------ Set GRAM area set window --------------------------------//
this->write_cmd (0x0030, 0x0000);//???????
this->write_cmd (0x0031, 0x00db);
this->write_cmd (0x0032, 0x0000);
this->write_cmd (0x0033, 0x0000);//??????
this->write_cmd (0x0034, 0x00db);
this->write_cmd (0x0035, 0x0000);//R34H,R35H???????
this->write_cmd (0x0036, 0x00AF);
this->write_cmd (0x0037, 0x0000);
this->write_cmd (0x0038, 0x00DB);
this->write_cmd (0x0039, 0x0000);
delay(20);
this->write_cmd(0x00ff, 0x0003);
// WriteRegister(0x00b0, 0x1d01);
// ----------- Adjust the Gamma Curve ----------//
this->write_cmd(0x0050, 0x0000);
this->write_cmd(0x0051, 0x0300);
this->write_cmd(0x0052, 0x0103);
this->write_cmd(0x0053, 0x2011);
this->write_cmd(0x0054, 0x0703);
this->write_cmd(0x0055, 0x0000);
this->write_cmd(0x0056, 0x0400);
this->write_cmd(0x0057, 0x0107);
this->write_cmd(0x0058, 0x2011);
this->write_cmd(0x0059, 0x0703);
delay(50); // Delay 50ms
this->write_cmd(0x0020, 0x0000); // Set GRAM Address
this->write_cmd(0x0021, 0x0000); // Set GRAM Address
this->write_cmd(0x0007, 0x1017);
this->fillRect(0,0,LCD_2000_7775_TFTWIDTH,LCD_2000_7775_TFTHEIGHT,0xffff);
}
Wed Oct 05, 2016 10:08 am
My advice would be to approach this thing step by step:
1) get the Nokia 5110 LCD working on the Teensy
2) get the Gamebuino library working on the Teensy with the 5110
3) get the color display of your choice working on the teensy
4) start adapting the Gamebuino library to support colors
Wed Oct 05, 2016 9:32 pm
Arduino: 1.6.11 (Windows 7), TD: 1.30-beta3, Board: "Teensy 3.2 / 3.1, Serial, 96 MHz optimize speed (overclock), US English"
In file included from C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Gamebuino.h:27:0,
from C:\Users\duhjoker\Desktop\ESMERELDA\ESMERELDA\ESMERELDA.ino:5:
C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Adafruit_GFX.h:59:36: error: ISO C++ forbids declaration of 'Adafruit_GFX' with no type [-fpermissive]
Adafruit_GFX(int16_t w, int16_t h); // Constructor
^
In file included from C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Gamebuino.h:27:0,
from C:\Users\duhjoker\Desktop\ESMERELDA\ESMERELDA\ESMERELDA.ino:5:
C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Adafruit_GFX.h:181:5: warning: non-static const member 'const int16_t Display::WIDTH' in class without a constructor [-Wuninitialized]
WIDTH, HEIGHT; // This is the 'raw' display w/h - never changes
^
C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Adafruit_GFX.h:181:12: warning: non-static const member 'const int16_t Display::HEIGHT' in class without a constructor [-Wuninitialized]
WIDTH, HEIGHT; // This is the 'raw' display w/h - never changes
^
C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Adafruit_GFX.h:238:19: error: 'Adafruit_GFX' has not been declared
void initButton(Adafruit_GFX *gfx, int16_t x, int16_t y,
^
C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Adafruit_GFX.h:250:3: error: 'Adafruit_GFX' does not name a type
Adafruit_GFX *_gfx;
^
C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Adafruit_GFX.h:260:40: error: expected class-name before '{' token
class GFXcanvas1 : public Adafruit_GFX {
^
C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Adafruit_GFX.h:272:41: error: expected class-name before '{' token
class GFXcanvas16 : public Adafruit_GFX {
^
In file included from C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Gamebuino.h:28:0,
from C:\Users\duhjoker\Desktop\ESMERELDA\ESMERELDA\ESMERELDA.ino:5:
C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/LCD_2000_7775.h:19:7: error: redefinition of 'class Display'
class Display: public Print
^
In file included from C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Gamebuino.h:27:0,
from C:\Users\duhjoker\Desktop\ESMERELDA\ESMERELDA\ESMERELDA.ino:5:
C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Adafruit_GFX.h:55:7: error: previous definition of 'class Display'
class Display : public Print {
^
In file included from C:\Users\duhjoker\Desktop\ESMERELDA\ESMERELDA\ESMERELDA.ino:5:0:
C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Gamebuino.h:42:5: error: 'Backlight' does not name a type
Backlight backlight;
^
C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Gamebuino.h:46:13: error: cannot declare field 'Gamebuino::display' to be of abstract type 'Display'
Display display;
^
In file included from C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Gamebuino.h:27:0,
from C:\Users\duhjoker\Desktop\ESMERELDA\ESMERELDA\ESMERELDA.ino:5:
C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Adafruit_GFX.h:55:7: note: because the following virtual functions are pure within 'Display':
class Display : public Print {
^
C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Adafruit_GFX.h:63:16: note: virtual void Display::drawPixel(int16_t, int16_t, uint16_t)
virtual void drawPixel(int16_t x, int16_t y, uint16_t color) = 0;
^
ESMERELDA:7: error: use of deleted function 'Gamebuino::Gamebuino()'
Gamebuino gb;
^
In file included from C:\Users\duhjoker\Desktop\ESMERELDA\ESMERELDA\ESMERELDA.ino:5:0:
C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Gamebuino.h:40:7: note: 'Gamebuino::Gamebuino()' is implicitly deleted because the default definition would be ill-formed:
class Gamebuino {
^
C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Gamebuino.h:40:7: error: use of deleted function 'Display::Display()'
In file included from C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Gamebuino.h:27:0,
from C:\Users\duhjoker\Desktop\ESMERELDA\ESMERELDA\ESMERELDA.ino:5:
C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Adafruit_GFX.h:55:7: note: 'Display::Display()' is implicitly deleted because the default definition would be ill-formed:
class Display : public Print {
^
C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Adafruit_GFX.h:55:7: error: uninitialized non-static const member 'const int16_t Display::WIDTH'
C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Adafruit_GFX.h:55:7: error: uninitialized non-static const member 'const int16_t Display::HEIGHT'
ESMERELDA: In function 'void loop()':
ESMERELDA:104: error: no matching function for call to 'Display::drawBitmap(int, int, const byte [530])'
gb.display.drawBitmap(0,0,room_1);
^
C:\Users\duhjoker\Desktop\ESMERELDA\ESMERELDA\ESMERELDA.ino:104:36: note: candidates are:
In file included from C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Gamebuino.h:27:0,
from C:\Users\duhjoker\Desktop\ESMERELDA\ESMERELDA\ESMERELDA.ino:5:
C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Adafruit_GFX.h:89:8: note: void Display::drawBitmap(int8_t, int8_t, const uint8_t*, uint16_t)
void drawBitmap(int8_t x, int8_t y, const uint8_t *bitmap, uint16_t color);
^
C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Adafruit_GFX.h:89:8: note: candidate expects 4 arguments, 3 provided
C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Adafruit_GFX.h:91:8: note: void Display::drawBitmap(int8_t, int8_t, const uint8_t*, uint8_t, uint8_t, uint16_t)
void drawBitmap(int8_t x, int8_t y, const uint8_t *bitmap, uint8_t rotation, uint8_t flip, uint16_t color);
^
C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Adafruit_GFX.h:91:8: note: candidate expects 6 arguments, 3 provided
C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Adafruit_GFX.h:92:8: note: void Display::drawBitmap(int8_t, int8_t, int8_t, int8_t, const uint8_t*, uint8_t, uint8_t, uint8_t, uint8_t, uint16_t)
void drawBitmap(int8_t x, int8_t y, int8_t w, int8_t h, const uint8_t *bitmap, uint8_t dx, uint8_t dy, uint8_t dw, uint8_t dh, uint16_t color);
^
C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Adafruit_GFX.h:92:8: note: candidate expects 10 arguments, 3 provided
ESMERELDA:107: error: no matching function for call to 'Display::drawBitmap(int&, int&, const byte [258])'
gb.display.drawBitmap(player_x,player_y,sever_front_1);
^
C:\Users\duhjoker\Desktop\ESMERELDA\ESMERELDA\ESMERELDA.ino:107:58: note: candidates are:
In file included from C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Gamebuino.h:27:0,
from C:\Users\duhjoker\Desktop\ESMERELDA\ESMERELDA\ESMERELDA.ino:5:
C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Adafruit_GFX.h:89:8: note: void Display::drawBitmap(int8_t, int8_t, const uint8_t*, uint16_t)
void drawBitmap(int8_t x, int8_t y, const uint8_t *bitmap, uint16_t color);
^
C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Adafruit_GFX.h:89:8: note: candidate expects 4 arguments, 3 provided
C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Adafruit_GFX.h:91:8: note: void Display::drawBitmap(int8_t, int8_t, const uint8_t*, uint8_t, uint8_t, uint16_t)
void drawBitmap(int8_t x, int8_t y, const uint8_t *bitmap, uint8_t rotation, uint8_t flip, uint16_t color);
^
C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Adafruit_GFX.h:91:8: note: candidate expects 6 arguments, 3 provided
C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Adafruit_GFX.h:92:8: note: void Display::drawBitmap(int8_t, int8_t, int8_t, int8_t, const uint8_t*, uint8_t, uint8_t, uint8_t, uint8_t, uint16_t)
void drawBitmap(int8_t x, int8_t y, int8_t w, int8_t h, const uint8_t *bitmap, uint8_t dx, uint8_t dy, uint8_t dw, uint8_t dh, uint16_t color);
^
C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Adafruit_GFX.h:92:8: note: candidate expects 10 arguments, 3 provided
ESMERELDA:116: error: no matching function for call to 'Display::drawBitmap(int&, int&, const byte [8])'
gb.display.drawBitmap(player_x,player_y,sever_rear_1);
^
C:\Users\duhjoker\Desktop\ESMERELDA\ESMERELDA\ESMERELDA.ino:116:57: note: candidates are:
In file included from C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Gamebuino.h:27:0,
from C:\Users\duhjoker\Desktop\ESMERELDA\ESMERELDA\ESMERELDA.ino:5:
C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Adafruit_GFX.h:89:8: note: void Display::drawBitmap(int8_t, int8_t, const uint8_t*, uint16_t)
void drawBitmap(int8_t x, int8_t y, const uint8_t *bitmap, uint16_t color);
^
C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Adafruit_GFX.h:89:8: note: candidate expects 4 arguments, 3 provided
C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Adafruit_GFX.h:91:8: note: void Display::drawBitmap(int8_t, int8_t, const uint8_t*, uint8_t, uint8_t, uint16_t)
void drawBitmap(int8_t x, int8_t y, const uint8_t *bitmap, uint8_t rotation, uint8_t flip, uint16_t color);
^
C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Adafruit_GFX.h:91:8: note: candidate expects 6 arguments, 3 provided
C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Adafruit_GFX.h:92:8: note: void Display::drawBitmap(int8_t, int8_t, int8_t, int8_t, const uint8_t*, uint8_t, uint8_t, uint8_t, uint8_t, uint16_t)
void drawBitmap(int8_t x, int8_t y, int8_t w, int8_t h, const uint8_t *bitmap, uint8_t dx, uint8_t dy, uint8_t dw, uint8_t dh, uint16_t color);
^
C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Adafruit_GFX.h:92:8: note: candidate expects 10 arguments, 3 provided
ESMERELDA:130: error: no matching function for call to 'Display::drawBitmap(int&, int&, const byte [258])'
gb.display.drawBitmap(player_x,player_y,sever_front_1);
^
C:\Users\duhjoker\Desktop\ESMERELDA\ESMERELDA\ESMERELDA.ino:130:58: note: candidates are:
In file included from C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Gamebuino.h:27:0,
from C:\Users\duhjoker\Desktop\ESMERELDA\ESMERELDA\ESMERELDA.ino:5:
C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Adafruit_GFX.h:89:8: note: void Display::drawBitmap(int8_t, int8_t, const uint8_t*, uint16_t)
void drawBitmap(int8_t x, int8_t y, const uint8_t *bitmap, uint16_t color);
^
C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Adafruit_GFX.h:89:8: note: candidate expects 4 arguments, 3 provided
C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Adafruit_GFX.h:91:8: note: void Display::drawBitmap(int8_t, int8_t, const uint8_t*, uint8_t, uint8_t, uint16_t)
void drawBitmap(int8_t x, int8_t y, const uint8_t *bitmap, uint8_t rotation, uint8_t flip, uint16_t color);
^
C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Adafruit_GFX.h:91:8: note: candidate expects 6 arguments, 3 provided
C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Adafruit_GFX.h:92:8: note: void Display::drawBitmap(int8_t, int8_t, int8_t, int8_t, const uint8_t*, uint8_t, uint8_t, uint8_t, uint8_t, uint16_t)
void drawBitmap(int8_t x, int8_t y, int8_t w, int8_t h, const uint8_t *bitmap, uint8_t dx, uint8_t dy, uint8_t dw, uint8_t dh, uint16_t color);
^
C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Adafruit_GFX.h:92:8: note: candidate expects 10 arguments, 3 provided
ESMERELDA:143: error: no matching function for call to 'Display::drawBitmap(int&, int&, const byte [8])'
gb.display.drawBitmap(player_x,player_y,sever_right_1);
^
C:\Users\duhjoker\Desktop\ESMERELDA\ESMERELDA\ESMERELDA.ino:143:58: note: candidates are:
In file included from C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Gamebuino.h:27:0,
from C:\Users\duhjoker\Desktop\ESMERELDA\ESMERELDA\ESMERELDA.ino:5:
C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Adafruit_GFX.h:89:8: note: void Display::drawBitmap(int8_t, int8_t, const uint8_t*, uint16_t)
void drawBitmap(int8_t x, int8_t y, const uint8_t *bitmap, uint16_t color);
^
C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Adafruit_GFX.h:89:8: note: candidate expects 4 arguments, 3 provided
C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Adafruit_GFX.h:91:8: note: void Display::drawBitmap(int8_t, int8_t, const uint8_t*, uint8_t, uint8_t, uint16_t)
void drawBitmap(int8_t x, int8_t y, const uint8_t *bitmap, uint8_t rotation, uint8_t flip, uint16_t color);
^
C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Adafruit_GFX.h:91:8: note: candidate expects 6 arguments, 3 provided
C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Adafruit_GFX.h:92:8: note: void Display::drawBitmap(int8_t, int8_t, int8_t, int8_t, const uint8_t*, uint8_t, uint8_t, uint8_t, uint8_t, uint16_t)
void drawBitmap(int8_t x, int8_t y, int8_t w, int8_t h, const uint8_t *bitmap, uint8_t dx, uint8_t dy, uint8_t dw, uint8_t dh, uint16_t color);
^
C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Adafruit_GFX.h:92:8: note: candidate expects 10 arguments, 3 provided
ESMERELDA:155: error: no matching function for call to 'Display::drawBitmap(int&, int&, const byte [8])'
gb.display.drawBitmap(player_x,player_y,sever_left_1);
^
C:\Users\duhjoker\Desktop\ESMERELDA\ESMERELDA\ESMERELDA.ino:155:57: note: candidates are:
In file included from C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Gamebuino.h:27:0,
from C:\Users\duhjoker\Desktop\ESMERELDA\ESMERELDA\ESMERELDA.ino:5:
C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Adafruit_GFX.h:89:8: note: void Display::drawBitmap(int8_t, int8_t, const uint8_t*, uint16_t)
void drawBitmap(int8_t x, int8_t y, const uint8_t *bitmap, uint16_t color);
^
C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Adafruit_GFX.h:89:8: note: candidate expects 4 arguments, 3 provided
C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Adafruit_GFX.h:91:8: note: void Display::drawBitmap(int8_t, int8_t, const uint8_t*, uint8_t, uint8_t, uint16_t)
void drawBitmap(int8_t x, int8_t y, const uint8_t *bitmap, uint8_t rotation, uint8_t flip, uint16_t color);
^
C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Adafruit_GFX.h:91:8: note: candidate expects 6 arguments, 3 provided
C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Adafruit_GFX.h:92:8: note: void Display::drawBitmap(int8_t, int8_t, int8_t, int8_t, const uint8_t*, uint8_t, uint8_t, uint8_t, uint8_t, uint16_t)
void drawBitmap(int8_t x, int8_t y, int8_t w, int8_t h, const uint8_t *bitmap, uint8_t dx, uint8_t dy, uint8_t dw, uint8_t dh, uint16_t color);
^
C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Adafruit_GFX.h:92:8: note: candidate expects 10 arguments, 3 provided
use of deleted function 'Gamebuino::Gamebuino()'
This report would have more information with
"Show verbose output during compilation"
option enabled in File -> Preferences.
Gamebuino gb;
const byte room_1[] PROGMEM = {88,48,
0x59,0x65,0x96,0x59,0x60,0x00,0x59,0x65,0x96,0x59,0x60
,0xa6,0x9a,0x69,0xa6,0x90,0x00,0xa6,0x9a,0x69,0xa6,0x90
,0x14,0x51,0x45,0x14,0x50,0x00,0x14,0x51,0x45,0x14,0x50
,0xa2,0x8a,0x28,0xa2,0x80,0x00,0xa2,0x8a,0x28,0xa2,0x80
,0x86,0x18,0x61,0x86,0x10,0x00,0x86,0x18,0x61,0x86,0x10
,0x59,0x65,0x96,0x59,0x60,0x00,0x59,0x65,0x96,0x59,0x60
,0x59,0x65,0x80,0x58,0x00,0x00,0x00,0x00,0x00,0x59,0x60
,0xa6,0x9a,0x40,0xa4,0x00,0x00,0x00,0x00,0x00,0xa6,0x90
,0x14,0x51,0x40,0x14,0x00,0x00,0x00,0x00,0x00,0x14,0x50
,0xa2,0x8a,0x00,0xa0,0x00,0x00,0x00,0x00,0x00,0xa2,0x80
,0x86,0x18,0x40,0x84,0x00,0x00,0x00,0x00,0x00,0x86,0x10
,0x59,0x65,0x80,0x58,0x00,0x00,0x00,0x00,0x00,0x59,0x60
,0x59,0x60,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x59,0x60
,0xa6,0x90,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xa6,0x90
,0x14,0x50,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x14,0x50
,0xa2,0x80,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xa2,0x80
,0x86,0x10,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x86,0x10
,0x59,0x60,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x59,0x60
,0x58,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x59,0x60
,0xa4,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xa6,0x90
,0x14,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x14,0x50
,0xa0,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xa2,0x80
,0x84,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x86,0x10
,0x58,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x59,0x60
,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
,0x59,0x60,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x59,0x60
,0xa6,0x90,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xa6,0x90
,0x14,0x50,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x14,0x50
,0xa2,0x80,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xa2,0x80
,0x86,0x10,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x86,0x10
,0x59,0x60,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x59,0x60
,0x59,0x60,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x59,0x60
,0xa6,0x90,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xa6,0x90
,0x14,0x50,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x14,0x50
,0xa2,0x80,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xa2,0x80
,0x86,0x10,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x86,0x10
,0x59,0x60,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x59,0x60
,0x59,0x65,0x96,0x59,0x65,0x96,0x59,0x65,0x96,0x59,0x60
,0xa6,0x9a,0x69,0xa6,0x9a,0x69,0xa6,0x9a,0x69,0xa6,0x90
,0x14,0x51,0x45,0x14,0x51,0x45,0x14,0x51,0x45,0x14,0x50
,0xa2,0x8a,0x28,0xa2,0x8a,0x28,0xa2,0x8a,0x28,0xa2,0x80
,0x86,0x18,0x61,0x86,0x18,0x61,0x86,0x18,0x61,0x86,0x10
,0x59,0x65,0x96,0x59,0x65,0x96,0x59,0x65,0x96,0x59,0x60,};
const byte sever_front_1[] PROGMEM = {16,16,0x00,0xff,0x00,0x00,0x00,0x07,0x07,0x07,0x07,0x07,0x00,0x00,0x00,0xff,0x00,0x00
,0x00,0xff,0xff,0xff,0x07,0x07,0x07,0x07,0x07,0x07,0x07,0xff,0xff,0xff,0x00,0x00
,0x00,0x00,0x00,0xff,0xff,0x07,0xff,0xff,0xff,0x07,0xff,0xff,0x00,0x00,0x00,0x00
,0x00,0xff,0x00,0x00,0x07,0x07,0x07,0x07,0x07,0x07,0x07,0x00,0x00,0x00,0x00,0x00
,0x00,0xff,0x00,0x07,0xf6,0x07,0xf6,0xf6,0xf6,0x07,0xf6,0x07,0x00,0x00,0x00,0x00
,0x00,0xff,0x07,0xf6,0xf6,0x07,0xf6,0xf6,0xf6,0x07,0xf6,0xf6,0x07,0x00,0x00,0x00
,0x00,0xff,0x07,0x07,0xf6,0xf6,0xf6,0x07,0xf6,0xf6,0xf6,0x07,0x07,0x07,0x07,0x00
,0x00,0xff,0x07,0xff,0x07,0x07,0xf6,0xf6,0xf6,0x07,0x07,0x07,0xff,0xff,0xff,0x07
,0x00,0xff,0x07,0xff,0xff,0x07,0x07,0x07,0x07,0x07,0x07,0xff,0x07,0x07,0x07,0xff
,0x07,0x07,0x07,0xff,0x07,0x07,0x07,0x07,0x07,0x07,0x07,0xff,0x07,0xf6,0x07,0xff
,0x07,0xf6,0xf6,0x00,0xff,0x07,0xff,0xff,0xff,0xff,0x07,0xff,0x07,0xf6,0x07,0xff
,0x07,0xf6,0xf6,0x00,0x07,0x07,0x07,0x07,0x07,0x07,0x07,0xff,0x07,0x07,0x07,0xff
,0x00,0xff,0x00,0x07,0x07,0xff,0x07,0x07,0x07,0x07,0x07,0xff,0xff,0xff,0xff,0x00
,0x00,0x00,0x00,0x07,0xff,0xff,0x07,0x07,0xff,0xff,0xff,0xff,0x00,0x00,0x00,0x00
,0x00,0x00,0x00,0xf6,0xf6,0xf6,0x00,0x00,0xf6,0xf6,0xf6,0xf6,0x00,0x00,0x00,0x00
,0x00,0x00,0x00,0x07,0x07,0x07,0x00,0x00,0x07,0x07,0x07,0x07,0x00,0x00,0x00,0x00
};
const byte sever_front_2[] PROGMEM = {8,6,0x84,0x48,0x78,0x84,0x78,0x0,};
const byte sever_left_1[] PROGMEM = {8,6,0x78,0x80,0xc8,0xb4,0x0,0xcc,};
const byte sever_left_2[] PROGMEM = {8,6,0x4,0x58,0x30,0x0,0x78,0x0,};
const byte sever_rear_1[] PROGMEM = {8,6,0X78,0X78,0X0,0X30,0X0,0XCC,};
const byte sever_rear_2[] PROGMEM = {8,6,0x84,0x0,0x78,0x84,0x78,0x0,};
const byte sever_right_1[] PROGMEM = {8,6,0x78,0x4,0x4c,0xb4,0x0,0xcc,};
const byte sever_right_2[] PROGMEM = {8,6,0x80,0x68,0x30,0x0,0x78,0x0,};
int player_x = 15;
int player_y = 15;
// the setup routine runs once when Gamebuino starts up
void setup(){
// initialize the Gamebuino object
gb.begin();
//display the main menu:
gb.titleScreen(F("Myth of ESmerelda"));
gb.setFrameRate(80);
}
// the loop routine runs over and over again forever
void loop(){
//updates the gamebuino (the display, the sound, the auto backlight... everything)
//returns true when it's time to render a new frame (20 times/second)
if(gb.update()){
//prints Hello World! on the screen
gb.display.drawBitmap(0,0,room_1);
// gb.display.setColor(BLACK);{
gb.display.drawBitmap(player_x,player_y,sever_front_1);
//}
//gb.display.setColor(GRAY);{
//gb.display.drawBitmap(player_x,player_y,sever_front_2);
if(gb.buttons.repeat(BTN_UP,1)){
//gb.display.setColor(BLACK);{
gb.display.drawBitmap(player_x,player_y,sever_rear_1);
//}
//gb.display.setColor(GRAY);{
// gb.display.drawBitmap(player_x,player_y,sever_rear_2);
//}
player_y = player_y - 1;}
if(player_y <= 0){
player_y = 0;}
//}
if(gb.buttons.repeat(BTN_DOWN,1)){
//gb.display.setColor(BLACK);{
gb.display.drawBitmap(player_x,player_y,sever_front_1);
// }
//gb.display.setColor(GRAY);{
//gb.display.drawBitmap(player_x,player_y,sever_front_2);
// }
player_y = player_y + 1;}
if(player_y >= 40){
player_y = 40;}
//}
if(gb.buttons.repeat(BTN_RIGHT,1)){
//gb.display.setColor(BLACK);{
gb.display.drawBitmap(player_x,player_y,sever_right_1);
//}
//gb.display.setColor(GRAY);{
//gb.display.drawBitmap(player_x,player_y,sever_right_2);
}
player_x = player_x + 1;}
if(player_x >= 77){
player_x = 77;}
if(gb.buttons.repeat(BTN_LEFT,1)){
//gb.display.setColor(BLACK);{
gb.display.drawBitmap(player_x,player_y,sever_left_1);
//}
//gb.display.setColor(GRAY);{
//gb.display.drawBitmap(player_x,player_y,sever_left_2);
//}
player_x = player_x - 1;}
if(player_x <= -2){
player_x = -2;}
}
#ifndef GAMEBUINO_H
#define GAMEBUINO_H
#include <Arduino.h>
#include <avr/pgmspace.h>
#include <avr/sleep.h>
#include "settings.c"
#include "Adafruit_GFX.h"
#include "LCD_2000_7775.h"
//#include "Backlight.h"
//#include "Display.h"
//#include "Buttons.h"
#include "Battery.h"
#include "Sound.h"
#define load_game (*((void(*)(const char* filename))(0x7ffc/2)))
#define write_flash_page (*((void(*)(const char * page, unsigned char * buffer))(0x7ffa/2)))
#define wrap(i, imax) ((imax+i)%(imax))
class Gamebuino {
public:
//Backlight backlight;
//Buttons buttons;
//Battery battery;
Sound sound;
Display display;
Thu Oct 06, 2016 12:16 pm
So please can I get some advice as to where or how to include the display files with in Gamebuino.h and cpp files.
Fri Oct 07, 2016 3:03 am
Fri Oct 07, 2016 7:12 am
Fri Oct 07, 2016 8:44 am
#ifndef LCD_2000_7775_H
#define LCD_2000_7775_H
#if ARDUINO >= 100
#include "Arduino.h"
#include "Print.h"
#else
#include "WProgram.h"
#endif
//#include "utility/Adafruit_GFX.h"
#include <avr/pgmspace.h>
#include "gfxfont.h"
#include "glcdfont.c"
#define LCD_2000_7775_TFTWIDTH 176
#define LCD_2000_7775_TFTHEIGHT 220
class Display : public print
{
public:
TFT(int16_t w, int16_t h);// Constructor
LCD(uint8_t cs,uint8_t wr ,uint8_t rs , uint8_t rest ,uint8_t pmw );
LCD(uint8_t cs,uint8_t wr ,uint8_t rs , uint8_t rest );
LCD(uint8_t cs,uint8_t wr ,uint8_t rs );
//LCD_2000_7775(){};
void write_spi(const uint8_t data);
void drawPixel(int16_t x, int16_t y, uint16_t color); = 0; //gfx
void setdatapin(uint8_t b0,uint8_t b1, uint8_t b2 , uint8_t b3, uint8_t b4, uint8_t b5, uint8_t b6, uint8_t b7);
void setbracklight(uint8_t pmw);
void begin();
/////from gfx
void drawLine(int16_t x0, int16_t y0, int16_t x1, int16_t y1, uint16_t color);
void drawFastVLine(int16_t x, int16_t y, int16_t h, uint16_t color);
void drawFastHLine(int16_t x, int16_t y, int16_t w, uint16_t color);
void drawRect(int16_t x, int16_t y, int16_t w, int16_t h, uint16_t color);
void fillRect(int16_t x, int16_t y, int16_t w, int16_t h, uint16_t color);
void fillScreen(uint16_t color);
invertDisplay(boolean i);
void drawCircle(int16_t x0, int16_t y0, int16_t r, uint16_t color);
void drawCircleHelper(int16_t x0, int16_t y0, int16_t r, uint8_t cornername, uint16_t color);
void fillCircle(int16_t x0, int16_t y0, int16_t r, uint16_t color);
void fillCircleHelper(int16_t x0, int16_t y0, int16_t r, uint8_t cornername, int16_t delta, uint16_t color);
void drawTriangle(int16_t x0, int16_t y0, int16_t x1, int16_t y1, int16_t x2, int16_t y2, uint16_t color);
void fillTriangle(int16_t x0, int16_t y0, int16_t x1, int16_t y1, int16_t x2, int16_t y2, uint16_t color);
void drawRoundRect(int16_t x0, int16_t y0, int16_t w, int16_t h, int16_t radius, uint16_t color);
void fillRoundRect(int16_t x0, int16_t y0, int16_t w, int16_t h, int16_t radius, uint16_t color);
// from gamebuino display.h
//void drawBitmap(int8_t x, int8_t y, const uint8_t *bitmap);
//void drawBitmap(int8_t x, int8_t y, int8_t w, int8_t h, const uint8_t *bitmap);
//void drawBitmap(int8_t x, int8_t y, const uint8_t *bitmap, uint8_t rotation, uint8_t flip);
//void drawBitmap(int8_t x, int8_t y, int8_t w, int8_t h, const uint8_t *bitmap, uint8_t dx, uint8_t dy, uint8_t dw, uint8_t dh);
/////from gfx
void drawBitmap(int16_t x, int16_t y, const uint8_t *bitmap, int16_t w, int16_t h, uint16_t color);
void drawBitmap(int16_t x, int16_t y, const uint8_t *bitmap, int16_t w, int16_t h, uint16_t color, uint16_t bg);
void drawBitmap(int16_t x, int16_t y, uint8_t *bitmap, int16_t w, int16_t h, uint16_t color);
void drawBitmap(int16_t x, int16_t y, uint8_t *bitmap, int16_t w, int16_t h, uint16_t color, uint16_t bg);
boolean getBitmapPixel(const uint8_t* bitmap, uint8_t x, uint8_t y);
//DRAW X-BITMAP
void drawXBitmap(int16_t x, int16_t y, const uint8_t *bitmap, int16_t w, int16_t h, uint16_t color);
/////from display.h
void drawTilemap(int x, int y, const uint8_t *tilemap, const uint8_t **spritesheet);
void drawTilemap(int x, int y, const uint8_t *tilemap, const uint8_t **spritesheet, uint8_t dx, uint8_t dy, uint8_t dw, uint8_t dh);
/////from gfx
void drawChar(int16_t x, int16_t y, unsigned char c, uint16_t color, uint16_t bg, uint8_t size);
void setCursor(int16_t x, int16_t y);
void setTextColor(uint16_t c);
void setTextColor(uint16_t c, uint16_t bg);
void setTextSize(uint8_t s);
void setTextWrap(boolean w);
void setRotation(uint8_t r);
void cp437(boolean x = true);
void setFont(const GFXfont *f = NULL);
void getTextBounds(char *string, int16_t x, int16_t y, int16_t *x1, int16_t *y1, uint16_t *w, uint16_t *h);
void getTextBounds(const __FlashStringHelper *s, int16_t x, int16_t y, int16_t *x1, int16_t *y1, uint16_t *w, uint16_t *h);
////from gfx
#if ARDUINO >= 100
virtual size_t write(uint8_t);
#else
virtual void write(uint8_t);
#endif
int16_t height(void) const;
int16_t width(void) const;
uint8_t getRotation(void) const;
// get current cursor position (get rotation safe maximum values, using: width() for x, height() for y)
int16_t getCursorX(void) const;
int16_t getCursorY(void) const;
protected:
const int16_t
WIDTH, HEIGHT; // This is the 'raw' display w/h - never changes
int16_t
_width, _height, // Display w/h as modified by current rotation
cursor_x, cursor_y;
uint16_t
textcolor, textbgcolor;
uint8_t
textsize,
rotation;
boolean
wrap, // If set, 'wrap' text at right edge of display
_cp437; // If set, use correct CP437 charset (default is off)
GFXfont
*gfxFont;
boolean persistence; //disable clean() at each frame if true
//boolean textWrap; // If set, 'wrap' text at right edge of
uint8_t fontSize;
int8_t cursorX, cursorY;
byte contrast;
byte frameCount;
typedef struct { //line 171 "Public Variables - ADD by Summoner123
int x; //X coordinate - ADD by Summoner123
int y; //Y coordinate - ADD by Summoner123
const byte *spritecol; //Sprite of object - ADD by Summoner123
}object;
object solid[60]; // Matriz were saved a Sprite, X and Y cordinates of all tiles on the screen - ADD by Summoner123
byte numcolision = 0; //count of solid objects indacat how many tiles drawed on the screen - ADD by Summoner123
bool flagcollision = true;
}; //
//fuction
private:
void set_window(uint8_t x1,uint8_t y1,uint8_t x2,uint8_t y2);
void write_wr_reg(uint16_t data);
void write_wr_data(uint16_t data);
void write_cmd(uint16_t cmd ,uint16_t data);
#if 0 //defined(ARDUINO_ARCH_SAM)
void write_delay();
#else
#define write_delay()
#endif
//value
//private:
#if defined(ARDUINO_ARCH_SAM)
uint32_t _cs;
uint32_t _pmw;
uint32_t _wr;
uint32_t _rs;
uint32_t _rest;
volatile uint32_t *csport;
volatile uint32_t *pmwport;
volatile uint32_t *wrport;
volatile uint32_t *rsport;
volatile uint32_t *restport;
uint32_t cspinmask;
uint32_t pmwpinmask;
uint32_t wrpinmask;
uint32_t rspinmask;
uint32_t restpinmask;
volatile uint32_t data[8];
volatile uint32_t datapinmask[8];
volatile uint32_t* dataport[8];
#else
uint8_t _cs;
uint8_t _pmw;
uint8_t _wr;
uint8_t _rs;
uint8_t _rest;
volatile uint8_t *csport;
volatile uint8_t *pmwport;
volatile uint8_t *wrport;
volatile uint8_t *rsport;
volatile uint8_t *restport;
uint8_t cspinmask;
uint8_t pmwpinmask;
uint8_t wrpinmask;
uint8_t rspinmask;
uint8_t restpinmask;
volatile uint8_t data[8];
volatile uint8_t datapinmask[8];
volatile uint8_t* dataport[8];
#endif
};
uint16_t RGB(uint16_t r,uint16_t g , uint16_t b);
#endif
#include "LCD_2000_7775.h"
#ifdef __AVR__
#include <avr/pgmspace.h>
#elif defined(ESP8266)
#include <pgmspace.h>
#endif
#include "Adafruit_GFX.h"
#include "glcdfont.c"
// Many (but maybe not all) non-AVR board installs define macros
// for compatibility with existing PROGMEM-reading AVR code.
// Do our own checks and defines here for good measure...
#ifndef pgm_read_byte
#define pgm_read_byte(addr) (*(const unsigned char *)(addr))
#endif
#ifndef pgm_read_word
#define pgm_read_word(addr) (*(const unsigned short *)(addr))
#endif
#ifndef pgm_read_dword
#define pgm_read_dword(addr) (*(const unsigned long *)(addr))
#endif
// Pointers are a peculiar case...typically 16-bit on AVR boards,
// 32 bits elsewhere. Try to accommodate both...
#if !defined(__INT_MAX__) || (__INT_MAX__ > 0xFFFF)
#define pgm_read_pointer(addr) ((void *)pgm_read_dword(addr))
#else
#define pgm_read_pointer(addr) ((void *)pgm_read_word(addr))
#endif
#ifndef min
#define min(a,b) (((a) < (b)) ? (a) : (b))
#endif
#ifndef _swap_int16_t
#define _swap_int16_t(a, b) { int16_t t = a; a = b; b = t; }
#endif
Display::TFT(int16_t w, int16_t h):
WIDTH(w), HEIGHT(h)
{
_width = WIDTH;
_height = HEIGHT;
rotation = 0;
cursor_y = cursor_x = 0;
textsize = 1;
textcolor = textbgcolor = 0xFFFF;
wrap = true;
_cp437 = false;
gfxFont = NULL;
}
Display::LCD(uint8_t cs,uint8_t wr ,uint8_t rs , uint8_t rest ,uint8_t pmw)
: Adafruit_GFX(176, 220)
{
this->_cs = cs;
//this->_rd = rd;
this->_wr = wr;
this->_rs = rs;
this->_rest = rest;
this->_pmw = pmw;
pinMode(this->_cs,OUTPUT);
//pinMode(this->_rd,OUTPUT);
pinMode(this->_wr,OUTPUT);
pinMode(this->_rs,OUTPUT);
pinMode(this->_rest,OUTPUT);
pinMode(this->_pmw,OUTPUT);
this->csport = portOutputRegister(digitalPinToPort(this->_cs));
//this->pmwport = portOutputRegister(digitalPinToPort(this->_pmw));
this->wrport = portOutputRegister(digitalPinToPort(this->_wr));
this->rsport = portOutputRegister(digitalPinToPort(this->_rs));
this->restport = portOutputRegister(digitalPinToPort(this->_rest));
this->cspinmask = digitalPinToBitMask(this->_cs);
//this->pmwpinmask = digitalPinToBitMask(this->_pmw);
this->wrpinmask = digitalPinToBitMask(this->_wr);
this->rspinmask = digitalPinToBitMask(this->_rs);
this->restpinmask = digitalPinToBitMask(this->_rest);
*(this->csport) |= this->cspinmask;
//*(this->pmwport) |= this->pmwpinmask;
*(this->wrport) |= this->wrpinmask;
*(this->rsport) |= this->rspinmask;
*(this->restport) |= this->restpinmask;
}
Display::LCD(uint8_t cs,uint8_t wr ,uint8_t rs , uint8_t rest )
: Adafruit_GFX(176, 220)
{
this->_cs = cs;
//this->_rd = rd;
this->_wr = wr;
this->_rs = rs;
this->_rest = rest;
pinMode(this->_cs,OUTPUT);
//pinMode(this->_rd,OUTPUT);
pinMode(this->_wr,OUTPUT);
pinMode(this->_rs,OUTPUT);
pinMode(this->_rest,OUTPUT);
this->csport = portOutputRegister(digitalPinToPort(this->_cs));
this->wrport = portOutputRegister(digitalPinToPort(this->_wr));
this->rsport = portOutputRegister(digitalPinToPort(this->_rs));
this->restport = portOutputRegister(digitalPinToPort(this->_rest));
this->cspinmask = digitalPinToBitMask(this->_cs);
this->wrpinmask = digitalPinToBitMask(this->_wr);
this->rspinmask = digitalPinToBitMask(this->_rs);
this->restpinmask = digitalPinToBitMask(this->_rest);
*(this->csport) |= this->cspinmask;
*(this->wrport) |= this->wrpinmask;
*(this->rsport) |= this->rspinmask;
*(this->restport) |= this->restpinmask;
}
Display::LCD(uint8_t cs,uint8_t wr ,uint8_t rs)
: Adafruit_GFX(176, 220)
{
this->_cs = cs;
this->_wr = wr;
this->_rs = rs;
this->_rest = 0;
pinMode(this->_cs,OUTPUT);
pinMode(this->_wr,OUTPUT);
pinMode(this->_rs,OUTPUT);
this->csport = portOutputRegister(digitalPinToPort(this->_cs));
this->wrport = portOutputRegister(digitalPinToPort(this->_wr));
this->rsport = portOutputRegister(digitalPinToPort(this->_rs));
this->cspinmask = digitalPinToBitMask(this->_cs);
this->wrpinmask = digitalPinToBitMask(this->_wr);
this->rspinmask = digitalPinToBitMask(this->_rs);
*(this->csport) |= this->cspinmask;
*(this->wrport) |= this->wrpinmask;
*(this->rsport) |= this->rspinmask;
}
#if 0 //defined(ARDUINO_ARCH_SAM)
void Display::write_delay()
{
volatile uint32_t delaycnt = 10;
while( delaycnt-- );
}
#endif
void Display::write_spi(const uint8_t data)
{
uint8_t bit,i;
for(bit = 0x01,i = 0 ; bit ; i++,bit <<= 1)
{
if(data & bit) *(this->dataport[i]) |= this->datapinmask[i];
else *(this->dataport[i]) &= (~this->datapinmask[i]);
//write_delay();
}
}
void Display::setdatapin(uint8_t b0,uint8_t b1, uint8_t b2 , uint8_t b3,
uint8_t b4, uint8_t b5, uint8_t b6, uint8_t b7)
{
uint8_t i;
this->data[0] = b0;
this->data[1] = b1;
this->data[2] = b2;
this->data[3] = b3;
this->data[4] = b4;
this->data[5] = b5;
this->data[6] = b6;
this->data[7] = b7;
for(i = 0; i < 8 ;i++)
pinMode(this->data[i],OUTPUT);
for(i = 0; i < 8 ;i++)
dataport[i] = portOutputRegister(digitalPinToPort(this->data[i]));
for(i = 0; i < 8 ;i++)
datapinmask[i] = digitalPinToBitMask(this->data[i]);
this->setbracklight(255);
}
void Display::write_wr_reg(uint16_t data)
{
*(this->rsport) &= (~this->rspinmask);
write_delay();
*(this->csport) &= (~this->cspinmask);
write_delay();
this->write_spi( data >> 8 );
write_delay();
*(this->wrport) &= (~this->wrpinmask);
write_delay();
*(this->wrport) |= this->wrpinmask;
write_delay();
this->write_spi( (data&0x00ff) );
write_delay();
*(this->wrport) &= (~this->wrpinmask);
write_delay();
*(this->wrport) |= this->wrpinmask;
write_delay();
*(this->csport) |= this->cspinmask;
write_delay();
}
void Display::write_wr_data(uint16_t data)
{
*(this->rsport) |= this->rspinmask;
write_delay();
*(this->csport) &= (~this->cspinmask);
write_delay();
this->write_spi( data >> 8 );
write_delay();
*(this->wrport) &= (~this->wrpinmask);
write_delay();
*(this->wrport) |= this->wrpinmask;
write_delay();
this->write_spi( (data&0x00ff) );
write_delay();
*(this->wrport) &= (~this->wrpinmask);
write_delay();
*(this->wrport) |= this->wrpinmask;
write_delay();
*(this->csport) |= this->cspinmask;
write_delay();
}
void Display::write_cmd(uint16_t cmd ,uint16_t data)
{
this->write_wr_reg(cmd);
this->write_wr_data(data);
}
void Display::set_window(uint8_t x1,uint8_t y1,uint8_t x2,uint8_t y2)
{
this->write_wr_reg(0x0037);this->write_wr_data(x1); // windows address
this->write_wr_reg(0x0036);this->write_wr_data(x2);
this->write_wr_reg(0x0039);this->write_wr_data(y1);
this->write_wr_reg(0x0038);this->write_wr_data(y2);
this->write_wr_reg(0x0020); //HS
this->write_wr_data(x1);
this->write_wr_reg(0x0021); //VS
this->write_wr_data(y1);
}
void Display::drawPixel(int16_t x, int16_t y, uint16_t color)
{
set_window(x,y,x,y);
//this->write_wr_reg(0x0022);
//this->write_wr_data(color);
this->write_cmd(0x22,color);
}
void Display::fillRect(int16_t x, int16_t y, int16_t w, int16_t h,
uint16_t color)
{
set_window(x,y,x+w-1,y+h-1);
this->write_wr_reg(0x22);
int i = w*h;
while(i--)
this->write_wr_data(color);
}
void Display::setbracklight(uint8_t pmw)
{
analogWrite(this->_pmw,pmw);
}
//void LCD_2000_7775::drawbitmap(uint16_t* data, uint16_t x ,uint16_t y,uint16_t with , uint16_t height)
//{
// uint32_t i;
// this->set_window(x,y,x+with-1,y+height-1);
// this->write_wr_reg(0x22);
// i = with * height;
// while(i--)
// {
// this->write_wr_data(*data);
// data++;
// }
//
//}
void Display::begin()
{
if( this->_rest )
{
*(this->restport) &= (~this->restpinmask);
delay(50); // Delay 50ms
*(this->restport) |= this->restpinmask;
delay(10); // Delay 10ms
}
this->write_cmd(0x0001, 0x011C); // set SS and NL bit
this->write_cmd(0x0002, 0x0100); // set 1 line inversion
this->write_cmd(0x0003, 0x1030); // set GRAM write direction and BGR=1,??16BIT 65K?MDT1=0,MDT0=0
this->write_cmd(0x0008, 0x0808); // set BP and FP
this->write_cmd(0x000C, 0x0000); // RGB interface setting R0Ch=0x0110 for RGB 18Bit and R0Ch=0111for
this->write_cmd(0x000F, 0x0e01); // Set frame rate
//*************Power On sequence ****************//
delay(50); // Delay 50ms
this->write_cmd(0x0010, 0x0A00); // Set SAP,DSTB,STB
this->write_cmd(0x0011, 0x1038); // Set APON,PON,AON,VCI1EN,VC
//delay(50); // Delay 50ms
this->write_cmd(0x00ff, 0x0003); //
this->write_cmd(0x00b0, 0x1411); //Set VCOM 1d
this->write_cmd(0x00b1, 0x0202); //GVCL/GVDD voltage setting
this->write_cmd(0x00b2, 0x0313); //VCL voltage setting
//------------------------ Set GRAM area set window --------------------------------//
this->write_cmd (0x0030, 0x0000);//???????
this->write_cmd (0x0031, 0x00db);
this->write_cmd (0x0032, 0x0000);
this->write_cmd (0x0033, 0x0000);//??????
this->write_cmd (0x0034, 0x00db);
this->write_cmd (0x0035, 0x0000);//R34H,R35H???????
this->write_cmd (0x0036, 0x00AF);
this->write_cmd (0x0037, 0x0000);
this->write_cmd (0x0038, 0x00DB);
this->write_cmd (0x0039, 0x0000);
delay(20);
this->write_cmd(0x00ff, 0x0003);
// WriteRegister(0x00b0, 0x1d01);
// ----------- Adjust the Gamma Curve ----------//
this->write_cmd(0x0050, 0x0000);
this->write_cmd(0x0051, 0x0300);
this->write_cmd(0x0052, 0x0103);
this->write_cmd(0x0053, 0x2011);
this->write_cmd(0x0054, 0x0703);
this->write_cmd(0x0055, 0x0000);
this->write_cmd(0x0056, 0x0400);
this->write_cmd(0x0057, 0x0107);
this->write_cmd(0x0058, 0x2011);
this->write_cmd(0x0059, 0x0703);
delay(50); // Delay 50ms
this->write_cmd(0x0020, 0x0000); // Set GRAM Address
this->write_cmd(0x0021, 0x0000); // Set GRAM Address
this->write_cmd(0x0007, 0x1017);
this->fillRect(0,0,LCD_2000_7775_TFTWIDTH,LCD_2000_7775_TFTHEIGHT,0xffff);
}
// Bresenham's algorithm - thx wikpedia
void Display::drawLine(int16_t x0, int16_t y0, int16_t x1, int16_t y1,
uint16_t color) {
int16_t steep = abs(y1 - y0) > abs(x1 - x0);
if (steep) {
_swap_int16_t(x0, y0);
_swap_int16_t(x1, y1);
}
if (x0 > x1) {
_swap_int16_t(x0, x1);
_swap_int16_t(y0, y1);
}
int16_t dx, dy;
dx = x1 - x0;
dy = abs(y1 - y0);
int16_t err = dx / 2;
int16_t ystep;
if (y0 < y1) {
ystep = 1;
}
else {
ystep = -1;
}
for (; x0 <= x1; x0++) {
if (steep) {
drawPixel(y0, x0, color);
}
else {
drawPixel(x0, y0, color);
}
err -= dy;
if (err < 0) {
y0 += ystep;
err += dx;
}
}
}
void Display::drawFastVLine(int16_t x, int16_t y,
int16_t h, uint16_t color) {
// Update in subclasses if desired!
drawLine(x, y, x, y + h - 1, color);
}
void Display::drawFastHLine(int16_t x, int16_t y,
int16_t w, uint16_t color) {
// Update in subclasses if desired!
drawLine(x, y, x + w - 1, y, color);
}
// Draw a rectangle
void Display::drawRect(int16_t x, int16_t y, int16_t w, int16_t h,
uint16_t color) {
drawFastHLine(x, y, w, color);
drawFastHLine(x, y + h - 1, w, color);
drawFastVLine(x, y, h, color);
drawFastVLine(x + w - 1, y, h, color);
}
void Display::fillRect(int16_t x, int16_t y, int16_t w, int16_t h,
uint16_t color) {
// Update in subclasses if desired!
for (int16_t i = x; i<x + w; i++) {
drawFastVLine(i, y, h, color);
}
}
void Display::fillScreen(uint16_t color) {
fillRect(0, 0, _width, _height, color);
}
// Draw a circle outline
void Display::drawCircle(int16_t x0, int16_t y0, int16_t r,
uint16_t color) {
int16_t f = 1 - r;
int16_t ddF_x = 1;
int16_t ddF_y = -2 * r;
int16_t x = 0;
int16_t y = r;
drawPixel(x0, y0 + r, color);
drawPixel(x0, y0 - r, color);
drawPixel(x0 + r, y0, color);
drawPixel(x0 - r, y0, color);
while (x<y) {
if (f >= 0) {
y--;
ddF_y += 2;
f += ddF_y;
}
x++;
ddF_x += 2;
f += ddF_x;
drawPixel(x0 + x, y0 + y, color);
drawPixel(x0 - x, y0 + y, color);
drawPixel(x0 + x, y0 - y, color);
drawPixel(x0 - x, y0 - y, color);
drawPixel(x0 + y, y0 + x, color);
drawPixel(x0 - y, y0 + x, color);
drawPixel(x0 + y, y0 - x, color);
drawPixel(x0 - y, y0 - x, color);
}
}
void Display::drawCircleHelper(int16_t x0, int16_t y0,
int16_t r, uint8_t cornername, uint16_t color) {
int16_t f = 1 - r;
int16_t ddF_x = 1;
int16_t ddF_y = -2 * r;
int16_t x = 0;
int16_t y = r;
while (x<y) {
if (f >= 0) {
y--;
ddF_y += 2;
f += ddF_y;
}
x++;
ddF_x += 2;
f += ddF_x;
if (cornername & 0x4) {
drawPixel(x0 + x, y0 + y, color);
drawPixel(x0 + y, y0 + x, color);
}
if (cornername & 0x2) {
drawPixel(x0 + x, y0 - y, color);
drawPixel(x0 + y, y0 - x, color);
}
if (cornername & 0x8) {
drawPixel(x0 - y, y0 + x, color);
drawPixel(x0 - x, y0 + y, color);
}
if (cornername & 0x1) {
drawPixel(x0 - y, y0 - x, color);
drawPixel(x0 - x, y0 - y, color);
}
}
}
void Display::fillCircle(int16_t x0, int16_t y0, int16_t r,
uint16_t color) {
drawFastVLine(x0, y0 - r, 2 * r + 1, color);
fillCircleHelper(x0, y0, r, 3, 0, color);
}
// Used to do circles and roundrects
void Display::fillCircleHelper(int16_t x0, int16_t y0, int16_t r,
uint8_t cornername, int16_t delta, uint16_t color) {
int16_t f = 1 - r;
int16_t ddF_x = 1;
int16_t ddF_y = -2 * r;
int16_t x = 0;
int16_t y = r;
while (x<y) {
if (f >= 0) {
y--;
ddF_y += 2;
f += ddF_y;
}
x++;
ddF_x += 2;
f += ddF_x;
if (cornername & 0x1) {
drawFastVLine(x0 + x, y0 - y, 2 * y + 1 + delta, color);
drawFastVLine(x0 + y, y0 - x, 2 * x + 1 + delta, color);
}
if (cornername & 0x2) {
drawFastVLine(x0 - x, y0 - y, 2 * y + 1 + delta, color);
drawFastVLine(x0 - y, y0 - x, 2 * x + 1 + delta, color);
}
}
}
// Draw a triangle
void Display::drawTriangle(int16_t x0, int16_t y0,
int16_t x1, int16_t y1, int16_t x2, int16_t y2, uint16_t color) {
drawLine(x0, y0, x1, y1, color);
drawLine(x1, y1, x2, y2, color);
drawLine(x2, y2, x0, y0, color);
}
// Fill a triangle
void Display::fillTriangle(int16_t x0, int16_t y0,
int16_t x1, int16_t y1, int16_t x2, int16_t y2, uint16_t color) {
int16_t a, b, y, last;
// Sort coordinates by Y order (y2 >= y1 >= y0)
if (y0 > y1) {
_swap_int16_t(y0, y1); _swap_int16_t(x0, x1);
}
if (y1 > y2) {
_swap_int16_t(y2, y1); _swap_int16_t(x2, x1);
}
if (y0 > y1) {
_swap_int16_t(y0, y1); _swap_int16_t(x0, x1);
}
if (y0 == y2) { // Handle awkward all-on-same-line case as its own thing
a = b = x0;
if (x1 < a) a = x1;
else if (x1 > b) b = x1;
if (x2 < a) a = x2;
else if (x2 > b) b = x2;
drawFastHLine(a, y0, b - a + 1, color);
return;
}
int16_t
dx01 = x1 - x0,
dy01 = y1 - y0,
dx02 = x2 - x0,
dy02 = y2 - y0,
dx12 = x2 - x1,
dy12 = y2 - y1;
int32_t
sa = 0,
sb = 0;
// For upper part of triangle, find scanline crossings for segments
// 0-1 and 0-2. If y1=y2 (flat-bottomed triangle), the scanline y1
// is included here (and second loop will be skipped, avoiding a /0
// error there), otherwise scanline y1 is skipped here and handled
// in the second loop...which also avoids a /0 error here if y0=y1
// (flat-topped triangle).
if (y1 == y2) last = y1; // Include y1 scanline
else last = y1 - 1; // Skip it
for (y = y0; y <= last; y++) {
a = x0 + sa / dy01;
b = x0 + sb / dy02;
sa += dx01;
sb += dx02;
/* longhand:
a = x0 + (x1 - x0) * (y - y0) / (y1 - y0);
b = x0 + (x2 - x0) * (y - y0) / (y2 - y0);
*/
if (a > b) _swap_int16_t(a, b);
drawFastHLine(a, y, b - a + 1, color);
}
// For lower part of triangle, find scanline crossings for segments
// 0-2 and 1-2. This loop is skipped if y1=y2.
sa = dx12 * (y - y1);
sb = dx02 * (y - y0);
for (; y <= y2; y++) {
a = x1 + sa / dy12;
b = x0 + sb / dy02;
sa += dx12;
sb += dx02;
/* longhand:
a = x1 + (x2 - x1) * (y - y1) / (y2 - y1);
b = x0 + (x2 - x0) * (y - y0) / (y2 - y0);
*/
if (a > b) _swap_int16_t(a, b);
drawFastHLine(a, y, b - a + 1, color);
}
}
// Draw a rounded rectangle
void Display::drawRoundRect(int16_t x, int16_t y, int16_t w,
int16_t h, int16_t r, uint16_t color) {
// smarter version
drawFastHLine(x + r, y, w - 2 * r, color); // Top
drawFastHLine(x + r, y + h - 1, w - 2 * r, color); // Bottom
drawFastVLine(x, y + r, h - 2 * r, color); // Left
drawFastVLine(x + w - 1, y + r, h - 2 * r, color); // Right
// draw four corners
drawCircleHelper(x + r, y + r, r, 1, color);
drawCircleHelper(x + w - r - 1, y + r, r, 2, color);
drawCircleHelper(x + w - r - 1, y + h - r - 1, r, 4, color);
drawCircleHelper(x + r, y + h - r - 1, r, 8, color);
}
// Fill a rounded rectangle
void Display::fillRoundRect(int16_t x, int16_t y, int16_t w,
int16_t h, int16_t r, uint16_t color) {
// smarter version
fillRect(x + r, y, w - 2 * r, h, color);
// draw four corners
fillCircleHelper(x + w - r - 1, y + r, r, 1, h - 2 * r - 1, color);
fillCircleHelper(x + r, y + r, r, 2, h - 2 * r - 1, color);
}
// Draw a 1-bit image (bitmap) at the specified (x,y) position from the
// provided bitmap buffer (must be PROGMEM memory) using the specified
// foreground color (unset bits are transparent).
void Display::drawBitmap(int16_t x, int16_t y,
const uint8_t *bitmap, int16_t w, int16_t h, uint16_t color) {
int16_t i, j, byteWidth = (w + 7) / 8;
uint8_t byte;
for (j = 0; j<h; j++) {
for (i = 0; i<w; i++) {
if (i & 7) byte <<= 1;
else byte = pgm_read_byte(bitmap + j * byteWidth + i / 8);
if (byte & 0x80) drawPixel(x + i, y + j, color);
}
}
}
// Draw a 1-bit image (bitmap) at the specified (x,y) position from the
// provided bitmap buffer (must be PROGMEM memory) using the specified
// foreground (for set bits) and background (for clear bits) colors.
void Display::drawBitmap(int16_t x, int16_t y,
const uint8_t *bitmap, int16_t w, int16_t h, uint16_t color, uint16_t bg) {
int16_t i, j, byteWidth = (w + 7) / 8;
uint8_t byte;
for (j = 0; j<h; j++) {
for (i = 0; i<w; i++) {
if (i & 7) byte <<= 1;
else byte = pgm_read_byte(bitmap + j * byteWidth + i / 8);
if (byte & 0x80) drawPixel(x + i, y + j, color);
else drawPixel(x + i, y + j, bg);
}
}
}
// drawBitmap() variant for RAM-resident (not PROGMEM) bitmaps.
void Display::drawBitmap(int16_t x, int16_t y,
uint8_t *bitmap, int16_t w, int16_t h, uint16_t color) {
int16_t i, j, byteWidth = (w + 7) / 8;
uint8_t byte;
for (j = 0; j<h; j++) {
for (i = 0; i<w; i++) {
if (i & 7) byte <<= 1;
else byte = bitmap[j * byteWidth + i / 8];
if (byte & 0x80) drawPixel(x + i, y + j, color);
}
}
}
// drawBitmap() variant w/background for RAM-resident (not PROGMEM) bitmaps.
void Display::drawBitmap(int16_t x, int16_t y,
uint8_t *bitmap, int16_t w, int16_t h, uint16_t color, uint16_t bg) {
int16_t i, j, byteWidth = (w + 7) / 8;
uint8_t byte;
for (j = 0; j<h; j++) {
for (i = 0; i<w; i++) {
if (i & 7) byte <<= 1;
else byte = bitmap[j * byteWidth + i / 8];
if (byte & 0x80) drawPixel(x + i, y + j, color);
else drawPixel(x + i, y + j, bg);
}
}
}
// Draw a 1-bit image (bitmap) at the specified (x,y) position from the
// provided bitmap buffer (must be PROGMEM memory) using the specified
// foreground color (unset bits are transparent).
void Display::drawBitmap(int16_t x, int16_t y,
const uint8_t *bitmap, int16_t w, int16_t h, uint16_t color) {
int16_t i, j, byteWidth = (w + 7) / 8;
uint8_t byte;
for (j = 0; j<h; j++) {
for (i = 0; i<w; i++) {
if (i & 7) byte <<= 1;
else byte = pgm_read_byte(bitmap + j * byteWidth + i / 8);
if (byte & 0x80) drawPixel(x + i, y + j, color);
}
}
}
// Draw a 1-bit image (bitmap) at the specified (x,y) position from the
// provided bitmap buffer (must be PROGMEM memory) using the specified
// foreground (for set bits) and background (for clear bits) colors.
void Display::drawBitmap(int16_t x, int16_t y,
const uint8_t *bitmap, int16_t w, int16_t h, uint16_t color, uint16_t bg) {
int16_t i, j, byteWidth = (w + 7) / 8;
uint8_t byte;
for (j = 0; j<h; j++) {
for (i = 0; i<w; i++) {
if (i & 7) byte <<= 1;
else byte = pgm_read_byte(bitmap + j * byteWidth + i / 8);
if (byte & 0x80) drawPixel(x + i, y + j, color);
else drawPixel(x + i, y + j, bg);
}
}
}
// drawBitmap() variant for RAM-resident (not PROGMEM) bitmaps.
void Display::drawBitmap(int16_t x, int16_t y,
uint8_t *bitmap, int16_t w, int16_t h, uint16_t color) {
int16_t i, j, byteWidth = (w + 7) / 8;
uint8_t byte;
for (j = 0; j<h; j++) {
for (i = 0; i<w; i++) {
if (i & 7) byte <<= 1;
else byte = bitmap[j * byteWidth + i / 8];
if (byte & 0x80) drawPixel(x + i, y + j, color);
}
}
}
// drawBitmap() variant w/background for RAM-resident (not PROGMEM) bitmaps.
void Display::drawBitmap(int16_t x, int16_t y,
uint8_t *bitmap, int16_t w, int16_t h, uint16_t color, uint16_t bg) {
int16_t i, j, byteWidth = (w + 7) / 8;
uint8_t byte;
for (j = 0; j<h; j++) {
for (i = 0; i<w; i++) {
if (i & 7) byte <<= 1;
else byte = bitmap[j * byteWidth + i / 8];
if (byte & 0x80) drawPixel(x + i, y + j, color);
else drawPixel(x + i, y + j, bg);
}
}
}
//Draw XBitMap Files (*.xbm), exported from GIMP,
//Usage: Export from GIMP to *.xbm, rename *.xbm to *.c and open in editor.
//C Array can be directly used with this function
void Display::drawXBitmap(int16_t x, int16_t y,
const uint8_t *bitmap, int16_t w, int16_t h, uint16_t color) {
int16_t i, j, byteWidth = (w + 7) / 8;
uint8_t byte;
for (j = 0; j<h; j++) {
for (i = 0; i<w; i++) {
if (i & 7) byte >>= 1;
else byte = pgm_read_byte(bitmap + j * byteWidth + i / 8);
if (byte & 0x01) drawPixel(x + i, y + j, color);
}
}
}
#if ARDUINO >= 100
size_t Display::write(uint8_t c) {
#else
void Display::write(uint8_t c) {
#endif
if (!gfxFont) { // 'Classic' built-in font
if (c == '\n') {
cursor_y += textsize * 8;
cursor_x = 0;
}
else if (c == '\r') {
// skip em
}
else {
if (wrap && ((cursor_x + textsize * 6) >= _width)) { // Heading off edge?
cursor_x = 0; // Reset x to zero
cursor_y += textsize * 8; // Advance y one line
}
drawChar(cursor_x, cursor_y, c, textcolor, textbgcolor, textsize);
cursor_x += textsize * 6;
}
}
else { // Custom font
if (c == '\n') {
cursor_x = 0;
cursor_y += (int16_t)textsize *
(uint8_t)pgm_read_byte(&gfxFont->yAdvance);
}
else if (c != '\r') {
uint8_t first = pgm_read_byte(&gfxFont->first);
if ((c >= first) && (c <= (uint8_t)pgm_read_byte(&gfxFont->last))) {
uint8_t c2 = c - pgm_read_byte(&gfxFont->first);
GFXglyph *glyph = &(((GFXglyph *)pgm_read_pointer(&gfxFont->glyph))[c2]);
uint8_t w = pgm_read_byte(&glyph->width),
h = pgm_read_byte(&glyph->height);
if ((w > 0) && (h > 0)) { // Is there an associated bitmap?
int16_t xo = (int8_t)pgm_read_byte(&glyph->xOffset); // sic
if (wrap && ((cursor_x + textsize * (xo + w)) >= _width)) {
// Drawing character would go off right edge; wrap to new line
cursor_x = 0;
cursor_y += (int16_t)textsize *
(uint8_t)pgm_read_byte(&gfxFont->yAdvance);
}
drawChar(cursor_x, cursor_y, c, textcolor, textbgcolor, textsize);
}
cursor_x += pgm_read_byte(&glyph->xAdvance) * (int16_t)textsize;
}
}
}
#if ARDUINO >= 100
return 1;
#endif
}
// Draw a character
void Display::drawChar(int16_t x, int16_t y, unsigned char c,
uint16_t color, uint16_t bg, uint8_t size) {
if (!gfxFont) { // 'Classic' built-in font
if ((x >= _width) || // Clip right
(y >= _height) || // Clip bottom
((x + 6 * size - 1) < 0) || // Clip left
((y + 8 * size - 1) < 0)) // Clip top
return;
if (!_cp437 && (c >= 176)) c++; // Handle 'classic' charset behavior
for (int8_t i = 0; i<6; i++) {
uint8_t line;
if (i < 5) line = pgm_read_byte(font + (c * 5) + i);
else line = 0x0;
for (int8_t j = 0; j<8; j++, line >>= 1) {
if (line & 0x1) {
if (size == 1) drawPixel(x + i, y + j, color);
else fillRect(x + (i*size), y + (j*size), size, size, color);
}
else if (bg != color) {
if (size == 1) drawPixel(x + i, y + j, bg);
else fillRect(x + i*size, y + j*size, size, size, bg);
}
}
}
}
else { // Custom font
// Character is assumed previously filtered by write() to eliminate
// newlines, returns, non-printable characters, etc. Calling drawChar()
// directly with 'bad' characters of font may cause mayhem!
c -= pgm_read_byte(&gfxFont->first);
GFXglyph *glyph = &(((GFXglyph *)pgm_read_pointer(&gfxFont->glyph))[c]);
uint8_t *bitmap = (uint8_t *)pgm_read_pointer(&gfxFont->bitmap);
uint16_t bo = pgm_read_word(&glyph->bitmapOffset);
uint8_t w = pgm_read_byte(&glyph->width),
h = pgm_read_byte(&glyph->height),
xa = pgm_read_byte(&glyph->xAdvance);
int8_t xo = pgm_read_byte(&glyph->xOffset),
yo = pgm_read_byte(&glyph->yOffset);
uint8_t xx, yy, bits, bit = 0;
int16_t xo16, yo16;
if (size > 1) {
xo16 = xo;
yo16 = yo;
}
// Todo: Add character clipping here
// NOTE: THERE IS NO 'BACKGROUND' COLOR OPTION ON CUSTOM FONTS.
// THIS IS ON PURPOSE AND BY DESIGN. The background color feature
// has typically been used with the 'classic' font to overwrite old
// screen contents with new data. This ONLY works because the
// characters are a uniform size; it's not a sensible thing to do with
// proportionally-spaced fonts with glyphs of varying sizes (and that
// may overlap). To replace previously-drawn text when using a custom
// font, use the getTextBounds() function to determine the smallest
// rectangle encompassing a string, erase the area with fillRect(),
// then draw new text. This WILL infortunately 'blink' the text, but
// is unavoidable. Drawing 'background' pixels will NOT fix this,
// only creates a new set of problems. Have an idea to work around
// this (a canvas object type for MCUs that can afford the RAM and
// displays supporting setAddrWindow() and pushColors()), but haven't
// implemented this yet.
for (yy = 0; yy<h; yy++) {
for (xx = 0; xx<w; xx++) {
if (!(bit++ & 7)) {
bits = pgm_read_byte(&bitmap[bo++]);
}
if (bits & 0x80) {
if (size == 1) {
drawPixel(x + xo + xx, y + yo + yy, color);
}
else {
fillRect(x + (xo16 + xx)*size, y + (yo16 + yy)*size, size, size, color);
}
}
bits <<= 1;
}
}
} // End classic vs custom font
}
void Display::setCursor(int16_t x, int16_t y) {
cursor_x = x;
cursor_y = y;
}
int16_t Display::getCursorX(void) const {
return cursor_x;
}
int16_t Display::getCursorY(void) const {
return cursor_y;
}
void Display::setTextSize(uint8_t s) {
textsize = (s > 0) ? s : 1;
}
void Display::setTextColor(uint16_t c) {
// For 'transparent' background, we'll set the bg
// to the same as fg instead of using a flag
textcolor = textbgcolor = c;
}
void Display::setTextColor(uint16_t c, uint16_t b) {
textcolor = c;
textbgcolor = b;
}
void Display::setTextWrap(boolean w) {
wrap = w;
}
uint8_t Display::getRotation(void) const {
return rotation;
}
void Display::setRotation(uint8_t x) {
rotation = (x & 3);
switch (rotation) {
case 0:
case 2:
_width = WIDTH;
_height = HEIGHT;
break;
case 1:
case 3:
_width = HEIGHT;
_height = WIDTH;
break;
}
}
// Enable (or disable) Code Page 437-compatible charset.
// There was an error in glcdfont.c for the longest time -- one character
// (#176, the 'light shade' block) was missing -- this threw off the index
// of every character that followed it. But a TON of code has been written
// with the erroneous character indices. By default, the library uses the
// original 'wrong' behavior and old sketches will still work. Pass 'true'
// to this function to use correct CP437 character values in your code.
void Display::cp437(boolean x) {
_cp437 = x;
}
void Display::setFont(const GFXfont *f) {
if (f) { // Font struct pointer passed in?
if (!gfxFont) { // And no current font struct?
// Switching from classic to new font behavior.
// Move cursor pos down 6 pixels so it's on baseline.
cursor_y += 6;
}
}
else if (gfxFont) { // NULL passed. Current font struct defined?
// Switching from new to classic font behavior.
// Move cursor pos up 6 pixels so it's at top-left of char.
cursor_y -= 6;
}
gfxFont = (GFXfont *)f;
}
// Pass string and a cursor position, returns UL corner and W,H.
void Display::getTextBounds(char *str, int16_t x, int16_t y,
int16_t *x1, int16_t *y1, uint16_t *w, uint16_t *h) {
uint8_t c; // Current character
*x1 = x;
*y1 = y;
*w = *h = 0;
if (gfxFont) {
GFXglyph *glyph;
uint8_t first = pgm_read_byte(&gfxFont->first),
last = pgm_read_byte(&gfxFont->last),
gw, gh, xa;
int8_t xo, yo;
int16_t minx = _width, miny = _height, maxx = -1, maxy = -1,
gx1, gy1, gx2, gy2, ts = (int16_t)textsize,
ya = ts * (uint8_t)pgm_read_byte(&gfxFont->yAdvance);
while ((c = *str++)) {
if (c != '\n') { // Not a newline
if (c != '\r') { // Not a carriage return, is normal char
if ((c >= first) && (c <= last)) { // Char present in current font
c -= first;
glyph = &(((GFXglyph *)pgm_read_pointer(&gfxFont->glyph))[c]);
gw = pgm_read_byte(&glyph->width);
gh = pgm_read_byte(&glyph->height);
xa = pgm_read_byte(&glyph->xAdvance);
xo = pgm_read_byte(&glyph->xOffset);
yo = pgm_read_byte(&glyph->yOffset);
if (wrap && ((x + (((int16_t)xo + gw) * ts)) >= _width)) {
// Line wrap
x = 0; // Reset x to 0
y += ya; // Advance y by 1 line
}
gx1 = x + xo * ts;
gy1 = y + yo * ts;
gx2 = gx1 + gw * ts - 1;
gy2 = gy1 + gh * ts - 1;
if (gx1 < minx) minx = gx1;
if (gy1 < miny) miny = gy1;
if (gx2 > maxx) maxx = gx2;
if (gy2 > maxy) maxy = gy2;
x += xa * ts;
}
} // Carriage return = do nothing
}
else { // Newline
x = 0; // Reset x
y += ya; // Advance y by 1 line
}
}
// End of string
*x1 = minx;
*y1 = miny;
if (maxx >= minx) *w = maxx - minx + 1;
if (maxy >= miny) *h = maxy - miny + 1;
}
else { // Default font
uint16_t lineWidth = 0, maxWidth = 0; // Width of current, all lines
while ((c = *str++)) {
if (c != '\n') { // Not a newline
if (c != '\r') { // Not a carriage return, is normal char
if (wrap && ((x + textsize * 6) >= _width)) {
x = 0; // Reset x to 0
y += textsize * 8; // Advance y by 1 line
if (lineWidth > maxWidth) maxWidth = lineWidth; // Save widest line
lineWidth = textsize * 6; // First char on new line
}
else { // No line wrap, just keep incrementing X
lineWidth += textsize * 6; // Includes interchar x gap
}
} // Carriage return = do nothing
}
else { // Newline
x = 0; // Reset x to 0
y += textsize * 8; // Advance y by 1 line
if (lineWidth > maxWidth) maxWidth = lineWidth; // Save widest line
lineWidth = 0; // Reset lineWidth for new line
}
}
// End of string
if (lineWidth) y += textsize * 8; // Add height of last (or only) line
*w = maxWidth - 1; // Don't include last interchar x gap
*h = y - *y1;
} // End classic vs custom font
}
// Same as above, but for PROGMEM strings
void Display::getTextBounds(const __FlashStringHelper *str,
int16_t x, int16_t y, int16_t *x1, int16_t *y1, uint16_t *w, uint16_t *h) {
uint8_t *s = (uint8_t *)str, c;
*x1 = x;
*y1 = y;
*w = *h = 0;
if (gfxFont) {
GFXglyph *glyph;
uint8_t first = pgm_read_byte(&gfxFont->first),
last = pgm_read_byte(&gfxFont->last),
gw, gh, xa;
int8_t xo, yo;
int16_t minx = _width, miny = _height, maxx = -1, maxy = -1,
gx1, gy1, gx2, gy2, ts = (int16_t)textsize,
ya = ts * (uint8_t)pgm_read_byte(&gfxFont->yAdvance);
while ((c = pgm_read_byte(s++))) {
if (c != '\n') { // Not a newline
if (c != '\r') { // Not a carriage return, is normal char
if ((c >= first) && (c <= last)) { // Char present in current font
c -= first;
glyph = &(((GFXglyph *)pgm_read_pointer(&gfxFont->glyph))[c]);
gw = pgm_read_byte(&glyph->width);
gh = pgm_read_byte(&glyph->height);
xa = pgm_read_byte(&glyph->xAdvance);
xo = pgm_read_byte(&glyph->xOffset);
yo = pgm_read_byte(&glyph->yOffset);
if (wrap && ((x + (((int16_t)xo + gw) * ts)) >= _width)) {
// Line wrap
x = 0; // Reset x to 0
y += ya; // Advance y by 1 line
}
gx1 = x + xo * ts;
gy1 = y + yo * ts;
gx2 = gx1 + gw * ts - 1;
gy2 = gy1 + gh * ts - 1;
if (gx1 < minx) minx = gx1;
if (gy1 < miny) miny = gy1;
if (gx2 > maxx) maxx = gx2;
if (gy2 > maxy) maxy = gy2;
x += xa * ts;
}
} // Carriage return = do nothing
}
else { // Newline
x = 0; // Reset x
y += ya; // Advance y by 1 line
}
}
// End of string
*x1 = minx;
*y1 = miny;
if (maxx >= minx) *w = maxx - minx + 1;
if (maxy >= miny) *h = maxy - miny + 1;
}
else { // Default font
uint16_t lineWidth = 0, maxWidth = 0; // Width of current, all lines
while ((c = pgm_read_byte(s++))) {
if (c != '\n') { // Not a newline
if (c != '\r') { // Not a carriage return, is normal char
if (wrap && ((x + textsize * 6) >= _width)) {
x = 0; // Reset x to 0
y += textsize * 8; // Advance y by 1 line
if (lineWidth > maxWidth) maxWidth = lineWidth; // Save widest line
lineWidth = textsize * 6; // First char on new line
}
else { // No line wrap, just keep incrementing X
lineWidth += textsize * 6; // Includes interchar x gap
}
} // Carriage return = do nothing
}
else { // Newline
x = 0; // Reset x to 0
y += textsize * 8; // Advance y by 1 line
if (lineWidth > maxWidth) maxWidth = lineWidth; // Save widest line
lineWidth = 0; // Reset lineWidth for new line
}
}
// End of string
if (lineWidth) y += textsize * 8; // Add height of last (or only) line
*w = maxWidth - 1; // Don't include last interchar x gap
*h = y - *y1;
} // End classic vs custom font
}
// Return the size of the display (per current rotation)
int16_t Display::width(void) const {
return _width;
}
int16_t Display::height(void) const {
return _height;
}
void Display::invertDisplay(boolean i) {
// Do nothing, must be subclassed if supported by hardware
}
/*********************************º¯Êý******************************/
uint16_t RGB(uint16_t r,uint16_t g , uint16_t b)
{
uint16_t rgb = 0;
r *= 31;
r /= 255;
g *= 63;
g /= 255;
b *= 31;
b /= 255;
rgb |= (r<<11);
rgb |= (g<<6);
rgb |= b;
return rgb;
}
Fri Oct 07, 2016 9:21 am
Display TFTscreen;
Display display;